Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
i8254.c
Go to the documentation of this file.
1 /*
2  * 8253/8254 interval timer emulation
3  *
4  * Copyright (c) 2003-2004 Fabrice Bellard
5  * Copyright (c) 2006 Intel Corporation
6  * Copyright (c) 2007 Keir Fraser, XenSource Inc
7  * Copyright (c) 2008 Intel Corporation
8  * Copyright 2009 Red Hat, Inc. and/or its affiliates.
9  *
10  * Permission is hereby granted, free of charge, to any person obtaining a copy
11  * of this software and associated documentation files (the "Software"), to deal
12  * in the Software without restriction, including without limitation the rights
13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14  * copies of the Software, and to permit persons to whom the Software is
15  * furnished to do so, subject to the following conditions:
16  *
17  * The above copyright notice and this permission notice shall be included in
18  * all copies or substantial portions of the Software.
19  *
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26  * THE SOFTWARE.
27  *
28  * Authors:
29  * Sheng Yang <[email protected]>
30  * Based on QEMU and Xen.
31  */
32 
33 #define pr_fmt(fmt) "pit: " fmt
34 
35 #include <linux/kvm_host.h>
36 #include <linux/slab.h>
37 
38 #include "irq.h"
39 #include "i8254.h"
40 
41 #ifndef CONFIG_X86_64
42 #define mod_64(x, y) ((x) - (y) * div64_u64(x, y))
43 #else
44 #define mod_64(x, y) ((x) % (y))
45 #endif
46 
47 #define RW_STATE_LSB 1
48 #define RW_STATE_MSB 2
49 #define RW_STATE_WORD0 3
50 #define RW_STATE_WORD1 4
51 
52 /* Compute with 96 bit intermediate result: (a*b)/c */
53 static u64 muldiv64(u64 a, u32 b, u32 c)
54 {
55  union {
56  u64 ll;
57  struct {
58  u32 low, high;
59  } l;
60  } u, res;
61  u64 rl, rh;
62 
63  u.ll = a;
64  rl = (u64)u.l.low * (u64)b;
65  rh = (u64)u.l.high * (u64)b;
66  rh += (rl >> 32);
67  res.l.high = div64_u64(rh, c);
68  res.l.low = div64_u64(((mod_64(rh, c) << 32) + (rl & 0xffffffff)), c);
69  return res.ll;
70 }
71 
72 static void pit_set_gate(struct kvm *kvm, int channel, u32 val)
73 {
74  struct kvm_kpit_channel_state *c =
75  &kvm->arch.vpit->pit_state.channels[channel];
76 
77  WARN_ON(!mutex_is_locked(&kvm->arch.vpit->pit_state.lock));
78 
79  switch (c->mode) {
80  default:
81  case 0:
82  case 4:
83  /* XXX: just disable/enable counting */
84  break;
85  case 1:
86  case 2:
87  case 3:
88  case 5:
89  /* Restart counting on rising edge. */
90  if (c->gate < val)
92  break;
93  }
94 
95  c->gate = val;
96 }
97 
98 static int pit_get_gate(struct kvm *kvm, int channel)
99 {
100  WARN_ON(!mutex_is_locked(&kvm->arch.vpit->pit_state.lock));
101 
102  return kvm->arch.vpit->pit_state.channels[channel].gate;
103 }
104 
105 static s64 __kpit_elapsed(struct kvm *kvm)
106 {
107  s64 elapsed;
108  ktime_t remaining;
109  struct kvm_kpit_state *ps = &kvm->arch.vpit->pit_state;
110 
111  if (!ps->period)
112  return 0;
113 
114  /*
115  * The Counter does not stop when it reaches zero. In
116  * Modes 0, 1, 4, and 5 the Counter ``wraps around'' to
117  * the highest count, either FFFF hex for binary counting
118  * or 9999 for BCD counting, and continues counting.
119  * Modes 2 and 3 are periodic; the Counter reloads
120  * itself with the initial count and continues counting
121  * from there.
122  */
123  remaining = hrtimer_get_remaining(&ps->timer);
124  elapsed = ps->period - ktime_to_ns(remaining);
125  elapsed = mod_64(elapsed, ps->period);
126 
127  return elapsed;
128 }
129 
130 static s64 kpit_elapsed(struct kvm *kvm, struct kvm_kpit_channel_state *c,
131  int channel)
132 {
133  if (channel == 0)
134  return __kpit_elapsed(kvm);
135 
136  return ktime_to_ns(ktime_sub(ktime_get(), c->count_load_time));
137 }
138 
139 static int pit_get_count(struct kvm *kvm, int channel)
140 {
141  struct kvm_kpit_channel_state *c =
142  &kvm->arch.vpit->pit_state.channels[channel];
143  s64 d, t;
144  int counter;
145 
146  WARN_ON(!mutex_is_locked(&kvm->arch.vpit->pit_state.lock));
147 
148  t = kpit_elapsed(kvm, c, channel);
149  d = muldiv64(t, KVM_PIT_FREQ, NSEC_PER_SEC);
150 
151  switch (c->mode) {
152  case 0:
153  case 1:
154  case 4:
155  case 5:
156  counter = (c->count - d) & 0xffff;
157  break;
158  case 3:
159  /* XXX: may be incorrect for odd counts */
160  counter = c->count - (mod_64((2 * d), c->count));
161  break;
162  default:
163  counter = c->count - mod_64(d, c->count);
164  break;
165  }
166  return counter;
167 }
168 
169 static int pit_get_out(struct kvm *kvm, int channel)
170 {
171  struct kvm_kpit_channel_state *c =
172  &kvm->arch.vpit->pit_state.channels[channel];
173  s64 d, t;
174  int out;
175 
176  WARN_ON(!mutex_is_locked(&kvm->arch.vpit->pit_state.lock));
177 
178  t = kpit_elapsed(kvm, c, channel);
179  d = muldiv64(t, KVM_PIT_FREQ, NSEC_PER_SEC);
180 
181  switch (c->mode) {
182  default:
183  case 0:
184  out = (d >= c->count);
185  break;
186  case 1:
187  out = (d < c->count);
188  break;
189  case 2:
190  out = ((mod_64(d, c->count) == 0) && (d != 0));
191  break;
192  case 3:
193  out = (mod_64(d, c->count) < ((c->count + 1) >> 1));
194  break;
195  case 4:
196  case 5:
197  out = (d == c->count);
198  break;
199  }
200 
201  return out;
202 }
203 
204 static void pit_latch_count(struct kvm *kvm, int channel)
205 {
206  struct kvm_kpit_channel_state *c =
207  &kvm->arch.vpit->pit_state.channels[channel];
208 
209  WARN_ON(!mutex_is_locked(&kvm->arch.vpit->pit_state.lock));
210 
211  if (!c->count_latched) {
212  c->latched_count = pit_get_count(kvm, channel);
213  c->count_latched = c->rw_mode;
214  }
215 }
216 
217 static void pit_latch_status(struct kvm *kvm, int channel)
218 {
219  struct kvm_kpit_channel_state *c =
220  &kvm->arch.vpit->pit_state.channels[channel];
221 
222  WARN_ON(!mutex_is_locked(&kvm->arch.vpit->pit_state.lock));
223 
224  if (!c->status_latched) {
225  /* TODO: Return NULL COUNT (bit 6). */
226  c->status = ((pit_get_out(kvm, channel) << 7) |
227  (c->rw_mode << 4) |
228  (c->mode << 1) |
229  c->bcd);
230  c->status_latched = 1;
231  }
232 }
233 
234 static void kvm_pit_ack_irq(struct kvm_irq_ack_notifier *kian)
235 {
236  struct kvm_kpit_state *ps = container_of(kian, struct kvm_kpit_state,
238  int value;
239 
240  spin_lock(&ps->inject_lock);
241  value = atomic_dec_return(&ps->pending);
242  if (value < 0)
243  /* spurious acks can be generated if, for example, the
244  * PIC is being reset. Handle it gracefully here
245  */
246  atomic_inc(&ps->pending);
247  else if (value > 0)
248  /* in this case, we had multiple outstanding pit interrupts
249  * that we needed to inject. Reinject
250  */
251  queue_kthread_work(&ps->pit->worker, &ps->pit->expired);
252  ps->irq_ack = 1;
253  spin_unlock(&ps->inject_lock);
254 }
255 
257 {
258  struct kvm_pit *pit = vcpu->kvm->arch.vpit;
259  struct hrtimer *timer;
260 
261  if (!kvm_vcpu_is_bsp(vcpu) || !pit)
262  return;
263 
264  timer = &pit->pit_state.timer;
265  if (hrtimer_cancel(timer))
266  hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
267 }
268 
269 static void destroy_pit_timer(struct kvm_pit *pit)
270 {
271  hrtimer_cancel(&pit->pit_state.timer);
273 }
274 
275 static void pit_do_work(struct kthread_work *work)
276 {
277  struct kvm_pit *pit = container_of(work, struct kvm_pit, expired);
278  struct kvm *kvm = pit->kvm;
279  struct kvm_vcpu *vcpu;
280  int i;
281  struct kvm_kpit_state *ps = &pit->pit_state;
282  int inject = 0;
283 
284  /* Try to inject pending interrupts when
285  * last one has been acked.
286  */
287  spin_lock(&ps->inject_lock);
288  if (ps->irq_ack) {
289  ps->irq_ack = 0;
290  inject = 1;
291  }
292  spin_unlock(&ps->inject_lock);
293  if (inject) {
294  kvm_set_irq(kvm, kvm->arch.vpit->irq_source_id, 0, 1);
295  kvm_set_irq(kvm, kvm->arch.vpit->irq_source_id, 0, 0);
296 
297  /*
298  * Provides NMI watchdog support via Virtual Wire mode.
299  * The route is: PIT -> PIC -> LVT0 in NMI mode.
300  *
301  * Note: Our Virtual Wire implementation is simplified, only
302  * propagating PIT interrupts to all VCPUs when they have set
303  * LVT0 to NMI delivery. Other PIC interrupts are just sent to
304  * VCPU0, and only if its LVT0 is in EXTINT mode.
305  */
306  if (kvm->arch.vapics_in_nmi_mode > 0)
307  kvm_for_each_vcpu(i, vcpu, kvm)
309  }
310 }
311 
312 static enum hrtimer_restart pit_timer_fn(struct hrtimer *data)
313 {
314  struct kvm_kpit_state *ps = container_of(data, struct kvm_kpit_state, timer);
315  struct kvm_pit *pt = ps->kvm->arch.vpit;
316 
317  if (ps->reinject || !atomic_read(&ps->pending)) {
318  atomic_inc(&ps->pending);
319  queue_kthread_work(&pt->worker, &pt->expired);
320  }
321 
322  if (ps->is_periodic) {
323  hrtimer_add_expires_ns(&ps->timer, ps->period);
324  return HRTIMER_RESTART;
325  } else
326  return HRTIMER_NORESTART;
327 }
328 
329 static void create_pit_timer(struct kvm *kvm, u32 val, int is_period)
330 {
331  struct kvm_kpit_state *ps = &kvm->arch.vpit->pit_state;
332  s64 interval;
333 
334  if (!irqchip_in_kernel(kvm) || ps->flags & KVM_PIT_FLAGS_HPET_LEGACY)
335  return;
336 
337  interval = muldiv64(val, NSEC_PER_SEC, KVM_PIT_FREQ);
338 
339  pr_debug("create pit timer, interval is %llu nsec\n", interval);
340 
341  /* TODO The new value only affected after the retriggered */
342  hrtimer_cancel(&ps->timer);
343  flush_kthread_work(&ps->pit->expired);
344  ps->period = interval;
345  ps->is_periodic = is_period;
346 
347  ps->timer.function = pit_timer_fn;
348  ps->kvm = ps->pit->kvm;
349 
350  atomic_set(&ps->pending, 0);
351  ps->irq_ack = 1;
352 
353  hrtimer_start(&ps->timer, ktime_add_ns(ktime_get(), interval),
355 }
356 
357 static void pit_load_count(struct kvm *kvm, int channel, u32 val)
358 {
359  struct kvm_kpit_state *ps = &kvm->arch.vpit->pit_state;
360 
361  WARN_ON(!mutex_is_locked(&ps->lock));
362 
363  pr_debug("load_count val is %d, channel is %d\n", val, channel);
364 
365  /*
366  * The largest possible initial count is 0; this is equivalent
367  * to 216 for binary counting and 104 for BCD counting.
368  */
369  if (val == 0)
370  val = 0x10000;
371 
372  ps->channels[channel].count = val;
373 
374  if (channel != 0) {
375  ps->channels[channel].count_load_time = ktime_get();
376  return;
377  }
378 
379  /* Two types of timer
380  * mode 1 is one shot, mode 2 is period, otherwise del timer */
381  switch (ps->channels[0].mode) {
382  case 0:
383  case 1:
384  /* FIXME: enhance mode 4 precision */
385  case 4:
386  create_pit_timer(kvm, val, 0);
387  break;
388  case 2:
389  case 3:
390  create_pit_timer(kvm, val, 1);
391  break;
392  default:
393  destroy_pit_timer(kvm->arch.vpit);
394  }
395 }
396 
397 void kvm_pit_load_count(struct kvm *kvm, int channel, u32 val, int hpet_legacy_start)
398 {
399  u8 saved_mode;
400  if (hpet_legacy_start) {
401  /* save existing mode for later reenablement */
402  saved_mode = kvm->arch.vpit->pit_state.channels[0].mode;
403  kvm->arch.vpit->pit_state.channels[0].mode = 0xff; /* disable timer */
404  pit_load_count(kvm, channel, val);
405  kvm->arch.vpit->pit_state.channels[0].mode = saved_mode;
406  } else {
407  pit_load_count(kvm, channel, val);
408  }
409 }
410 
411 static inline struct kvm_pit *dev_to_pit(struct kvm_io_device *dev)
412 {
413  return container_of(dev, struct kvm_pit, dev);
414 }
415 
416 static inline struct kvm_pit *speaker_to_pit(struct kvm_io_device *dev)
417 {
418  return container_of(dev, struct kvm_pit, speaker_dev);
419 }
420 
421 static inline int pit_in_range(gpa_t addr)
422 {
423  return ((addr >= KVM_PIT_BASE_ADDRESS) &&
425 }
426 
427 static int pit_ioport_write(struct kvm_io_device *this,
428  gpa_t addr, int len, const void *data)
429 {
430  struct kvm_pit *pit = dev_to_pit(this);
431  struct kvm_kpit_state *pit_state = &pit->pit_state;
432  struct kvm *kvm = pit->kvm;
433  int channel, access;
434  struct kvm_kpit_channel_state *s;
435  u32 val = *(u32 *) data;
436  if (!pit_in_range(addr))
437  return -EOPNOTSUPP;
438 
439  val &= 0xff;
440  addr &= KVM_PIT_CHANNEL_MASK;
441 
442  mutex_lock(&pit_state->lock);
443 
444  if (val != 0)
445  pr_debug("write addr is 0x%x, len is %d, val is 0x%x\n",
446  (unsigned int)addr, len, val);
447 
448  if (addr == 3) {
449  channel = val >> 6;
450  if (channel == 3) {
451  /* Read-Back Command. */
452  for (channel = 0; channel < 3; channel++) {
453  s = &pit_state->channels[channel];
454  if (val & (2 << channel)) {
455  if (!(val & 0x20))
456  pit_latch_count(kvm, channel);
457  if (!(val & 0x10))
458  pit_latch_status(kvm, channel);
459  }
460  }
461  } else {
462  /* Select Counter <channel>. */
463  s = &pit_state->channels[channel];
464  access = (val >> 4) & KVM_PIT_CHANNEL_MASK;
465  if (access == 0) {
466  pit_latch_count(kvm, channel);
467  } else {
468  s->rw_mode = access;
469  s->read_state = access;
470  s->write_state = access;
471  s->mode = (val >> 1) & 7;
472  if (s->mode > 5)
473  s->mode -= 4;
474  s->bcd = val & 1;
475  }
476  }
477  } else {
478  /* Write Count. */
479  s = &pit_state->channels[addr];
480  switch (s->write_state) {
481  default:
482  case RW_STATE_LSB:
483  pit_load_count(kvm, addr, val);
484  break;
485  case RW_STATE_MSB:
486  pit_load_count(kvm, addr, val << 8);
487  break;
488  case RW_STATE_WORD0:
489  s->write_latch = val;
491  break;
492  case RW_STATE_WORD1:
493  pit_load_count(kvm, addr, s->write_latch | (val << 8));
495  break;
496  }
497  }
498 
499  mutex_unlock(&pit_state->lock);
500  return 0;
501 }
502 
503 static int pit_ioport_read(struct kvm_io_device *this,
504  gpa_t addr, int len, void *data)
505 {
506  struct kvm_pit *pit = dev_to_pit(this);
507  struct kvm_kpit_state *pit_state = &pit->pit_state;
508  struct kvm *kvm = pit->kvm;
509  int ret, count;
510  struct kvm_kpit_channel_state *s;
511  if (!pit_in_range(addr))
512  return -EOPNOTSUPP;
513 
514  addr &= KVM_PIT_CHANNEL_MASK;
515  if (addr == 3)
516  return 0;
517 
518  s = &pit_state->channels[addr];
519 
520  mutex_lock(&pit_state->lock);
521 
522  if (s->status_latched) {
523  s->status_latched = 0;
524  ret = s->status;
525  } else if (s->count_latched) {
526  switch (s->count_latched) {
527  default:
528  case RW_STATE_LSB:
529  ret = s->latched_count & 0xff;
530  s->count_latched = 0;
531  break;
532  case RW_STATE_MSB:
533  ret = s->latched_count >> 8;
534  s->count_latched = 0;
535  break;
536  case RW_STATE_WORD0:
537  ret = s->latched_count & 0xff;
539  break;
540  }
541  } else {
542  switch (s->read_state) {
543  default:
544  case RW_STATE_LSB:
545  count = pit_get_count(kvm, addr);
546  ret = count & 0xff;
547  break;
548  case RW_STATE_MSB:
549  count = pit_get_count(kvm, addr);
550  ret = (count >> 8) & 0xff;
551  break;
552  case RW_STATE_WORD0:
553  count = pit_get_count(kvm, addr);
554  ret = count & 0xff;
556  break;
557  case RW_STATE_WORD1:
558  count = pit_get_count(kvm, addr);
559  ret = (count >> 8) & 0xff;
561  break;
562  }
563  }
564 
565  if (len > sizeof(ret))
566  len = sizeof(ret);
567  memcpy(data, (char *)&ret, len);
568 
569  mutex_unlock(&pit_state->lock);
570  return 0;
571 }
572 
573 static int speaker_ioport_write(struct kvm_io_device *this,
574  gpa_t addr, int len, const void *data)
575 {
576  struct kvm_pit *pit = speaker_to_pit(this);
577  struct kvm_kpit_state *pit_state = &pit->pit_state;
578  struct kvm *kvm = pit->kvm;
579  u32 val = *(u32 *) data;
580  if (addr != KVM_SPEAKER_BASE_ADDRESS)
581  return -EOPNOTSUPP;
582 
583  mutex_lock(&pit_state->lock);
584  pit_state->speaker_data_on = (val >> 1) & 1;
585  pit_set_gate(kvm, 2, val & 1);
586  mutex_unlock(&pit_state->lock);
587  return 0;
588 }
589 
590 static int speaker_ioport_read(struct kvm_io_device *this,
591  gpa_t addr, int len, void *data)
592 {
593  struct kvm_pit *pit = speaker_to_pit(this);
594  struct kvm_kpit_state *pit_state = &pit->pit_state;
595  struct kvm *kvm = pit->kvm;
596  unsigned int refresh_clock;
597  int ret;
598  if (addr != KVM_SPEAKER_BASE_ADDRESS)
599  return -EOPNOTSUPP;
600 
601  /* Refresh clock toggles at about 15us. We approximate as 2^14ns. */
602  refresh_clock = ((unsigned int)ktime_to_ns(ktime_get()) >> 14) & 1;
603 
604  mutex_lock(&pit_state->lock);
605  ret = ((pit_state->speaker_data_on << 1) | pit_get_gate(kvm, 2) |
606  (pit_get_out(kvm, 2) << 5) | (refresh_clock << 4));
607  if (len > sizeof(ret))
608  len = sizeof(ret);
609  memcpy(data, (char *)&ret, len);
610  mutex_unlock(&pit_state->lock);
611  return 0;
612 }
613 
614 void kvm_pit_reset(struct kvm_pit *pit)
615 {
616  int i;
617  struct kvm_kpit_channel_state *c;
618 
619  mutex_lock(&pit->pit_state.lock);
620  pit->pit_state.flags = 0;
621  for (i = 0; i < 3; i++) {
622  c = &pit->pit_state.channels[i];
623  c->mode = 0xff;
624  c->gate = (i != 2);
625  pit_load_count(pit->kvm, i, 0);
626  }
627  mutex_unlock(&pit->pit_state.lock);
628 
629  atomic_set(&pit->pit_state.pending, 0);
630  pit->pit_state.irq_ack = 1;
631 }
632 
633 static void pit_mask_notifer(struct kvm_irq_mask_notifier *kimn, bool mask)
634 {
635  struct kvm_pit *pit = container_of(kimn, struct kvm_pit, mask_notifier);
636 
637  if (!mask) {
638  atomic_set(&pit->pit_state.pending, 0);
639  pit->pit_state.irq_ack = 1;
640  }
641 }
642 
643 static const struct kvm_io_device_ops pit_dev_ops = {
644  .read = pit_ioport_read,
645  .write = pit_ioport_write,
646 };
647 
648 static const struct kvm_io_device_ops speaker_dev_ops = {
649  .read = speaker_ioport_read,
650  .write = speaker_ioport_write,
651 };
652 
653 /* Caller must hold slots_lock */
654 struct kvm_pit *kvm_create_pit(struct kvm *kvm, u32 flags)
655 {
656  struct kvm_pit *pit;
657  struct kvm_kpit_state *pit_state;
658  struct pid *pid;
659  pid_t pid_nr;
660  int ret;
661 
662  pit = kzalloc(sizeof(struct kvm_pit), GFP_KERNEL);
663  if (!pit)
664  return NULL;
665 
667  if (pit->irq_source_id < 0) {
668  kfree(pit);
669  return NULL;
670  }
671 
672  mutex_init(&pit->pit_state.lock);
673  mutex_lock(&pit->pit_state.lock);
674  spin_lock_init(&pit->pit_state.inject_lock);
675 
676  pid = get_pid(task_tgid(current));
677  pid_nr = pid_vnr(pid);
678  put_pid(pid);
679 
682  "kvm-pit/%d", pid_nr);
683  if (IS_ERR(pit->worker_task)) {
684  mutex_unlock(&pit->pit_state.lock);
686  kfree(pit);
687  return NULL;
688  }
689  init_kthread_work(&pit->expired, pit_do_work);
690 
691  kvm->arch.vpit = pit;
692  pit->kvm = kvm;
693 
694  pit_state = &pit->pit_state;
695  pit_state->pit = pit;
697  pit_state->irq_ack_notifier.gsi = 0;
698  pit_state->irq_ack_notifier.irq_acked = kvm_pit_ack_irq;
700  pit_state->reinject = true;
701  mutex_unlock(&pit->pit_state.lock);
702 
703  kvm_pit_reset(pit);
704 
705  pit->mask_notifier.func = pit_mask_notifer;
707 
708  kvm_iodevice_init(&pit->dev, &pit_dev_ops);
710  KVM_PIT_MEM_LENGTH, &pit->dev);
711  if (ret < 0)
712  goto fail;
713 
714  if (flags & KVM_PIT_SPEAKER_DUMMY) {
715  kvm_iodevice_init(&pit->speaker_dev, &speaker_dev_ops);
718  &pit->speaker_dev);
719  if (ret < 0)
720  goto fail_unregister;
721  }
722 
723  return pit;
724 
725 fail_unregister:
727 
728 fail:
733  kfree(pit);
734  return NULL;
735 }
736 
737 void kvm_free_pit(struct kvm *kvm)
738 {
739  struct hrtimer *timer;
740 
741  if (kvm->arch.vpit) {
742  kvm_io_bus_unregister_dev(kvm, KVM_PIO_BUS, &kvm->arch.vpit->dev);
744  &kvm->arch.vpit->speaker_dev);
746  &kvm->arch.vpit->mask_notifier);
748  &kvm->arch.vpit->pit_state.irq_ack_notifier);
749  mutex_lock(&kvm->arch.vpit->pit_state.lock);
750  timer = &kvm->arch.vpit->pit_state.timer;
751  hrtimer_cancel(timer);
752  flush_kthread_work(&kvm->arch.vpit->expired);
753  kthread_stop(kvm->arch.vpit->worker_task);
754  kvm_free_irq_source_id(kvm, kvm->arch.vpit->irq_source_id);
755  mutex_unlock(&kvm->arch.vpit->pit_state.lock);
756  kfree(kvm->arch.vpit);
757  }
758 }