2 * Freescale Hypervisor Management Driver
4 * Copyright (C) 2008-2011 Freescale Semiconductor, Inc.
5 * Author: Timur Tabi <timur@freescale.com>
7 * This file is licensed under the terms of the GNU General Public License
8 * version 2. This program is licensed "as is" without any warranty of any
9 * kind, whether express or implied.
11 * The Freescale hypervisor management driver provides several services to
12 * drivers and applications related to the Freescale hypervisor:
14 * 1. An ioctl interface for querying and managing partitions.
16 * 2. A file interface to reading incoming doorbells.
18 * 3. An interrupt handler for shutting down the partition upon receiving the
19 * shutdown doorbell from a manager partition.
21 * 4. A kernel interface for receiving callbacks when a managed partition
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/types.h>
29 #include <linux/err.h>
31 #include <linux/miscdevice.h>
33 #include <linux/pagemap.h>
34 #include <linux/slab.h>
35 #include <linux/poll.h>
37 #include <linux/of_irq.h>
38 #include <linux/reboot.h>
39 #include <linux/uaccess.h>
40 #include <linux/notifier.h>
41 #include <linux/interrupt.h>
44 #include <asm/fsl_hcalls.h>
46 #include <linux/fsl_hypervisor.h>
48 static BLOCKING_NOTIFIER_HEAD(failover_subscribers
);
51 * Ioctl interface for FSL_HV_IOCTL_PARTITION_RESTART
53 * Restart a running partition
55 static long ioctl_restart(struct fsl_hv_ioctl_restart __user
*p
)
57 struct fsl_hv_ioctl_restart param
;
59 /* Get the parameters from the user */
60 if (copy_from_user(¶m
, p
, sizeof(struct fsl_hv_ioctl_restart
)))
63 param
.ret
= fh_partition_restart(param
.partition
);
65 if (copy_to_user(&p
->ret
, ¶m
.ret
, sizeof(__u32
)))
72 * Ioctl interface for FSL_HV_IOCTL_PARTITION_STATUS
74 * Query the status of a partition
76 static long ioctl_status(struct fsl_hv_ioctl_status __user
*p
)
78 struct fsl_hv_ioctl_status param
;
81 /* Get the parameters from the user */
82 if (copy_from_user(¶m
, p
, sizeof(struct fsl_hv_ioctl_status
)))
85 param
.ret
= fh_partition_get_status(param
.partition
, &status
);
87 param
.status
= status
;
89 if (copy_to_user(p
, ¶m
, sizeof(struct fsl_hv_ioctl_status
)))
96 * Ioctl interface for FSL_HV_IOCTL_PARTITION_START
98 * Start a stopped partition.
100 static long ioctl_start(struct fsl_hv_ioctl_start __user
*p
)
102 struct fsl_hv_ioctl_start param
;
104 /* Get the parameters from the user */
105 if (copy_from_user(¶m
, p
, sizeof(struct fsl_hv_ioctl_start
)))
108 param
.ret
= fh_partition_start(param
.partition
, param
.entry_point
,
111 if (copy_to_user(&p
->ret
, ¶m
.ret
, sizeof(__u32
)))
118 * Ioctl interface for FSL_HV_IOCTL_PARTITION_STOP
120 * Stop a running partition
122 static long ioctl_stop(struct fsl_hv_ioctl_stop __user
*p
)
124 struct fsl_hv_ioctl_stop param
;
126 /* Get the parameters from the user */
127 if (copy_from_user(¶m
, p
, sizeof(struct fsl_hv_ioctl_stop
)))
130 param
.ret
= fh_partition_stop(param
.partition
);
132 if (copy_to_user(&p
->ret
, ¶m
.ret
, sizeof(__u32
)))
139 * Ioctl interface for FSL_HV_IOCTL_MEMCPY
141 * The FH_MEMCPY hypercall takes an array of address/address/size structures
142 * to represent the data being copied. As a convenience to the user, this
143 * ioctl takes a user-create buffer and a pointer to a guest physically
144 * contiguous buffer in the remote partition, and creates the
145 * address/address/size array for the hypercall.
147 static long ioctl_memcpy(struct fsl_hv_ioctl_memcpy __user
*p
)
149 struct fsl_hv_ioctl_memcpy param
;
151 struct page
**pages
= NULL
;
152 void *sg_list_unaligned
= NULL
;
153 struct fh_sg_list
*sg_list
= NULL
;
155 unsigned int num_pages
;
156 unsigned long lb_offset
; /* Offset within a page of the local buffer */
160 int num_pinned
= 0; /* return value from get_user_pages_fast() */
161 phys_addr_t remote_paddr
; /* The next address in the remote buffer */
162 uint32_t count
; /* The number of bytes left to copy */
164 /* Get the parameters from the user */
165 if (copy_from_user(¶m
, p
, sizeof(struct fsl_hv_ioctl_memcpy
)))
169 * One partition must be local, the other must be remote. In other
170 * words, if source and target are both -1, or are both not -1, then
173 if ((param
.source
== -1) == (param
.target
== -1))
177 * The array of pages returned by get_user_pages_fast() covers only
178 * page-aligned memory. Since the user buffer is probably not
179 * page-aligned, we need to handle the discrepancy.
181 * We calculate the offset within a page of the S/G list, and make
182 * adjustments accordingly. This will result in a page list that looks
185 * ---- <-- first page starts before the buffer
206 * | | <-- last page ends after the buffer
209 * The distance between the start of the first page and the start of the
210 * buffer is lb_offset. The hashed (///) areas are the parts of the
211 * page list that contain the actual buffer.
213 * The advantage of this approach is that the number of pages is
214 * equal to the number of entries in the S/G list that we give to the
217 lb_offset
= param
.local_vaddr
& (PAGE_SIZE
- 1);
218 if (param
.count
== 0 ||
219 param
.count
> U64_MAX
- lb_offset
- PAGE_SIZE
+ 1)
221 num_pages
= (param
.count
+ lb_offset
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
223 /* Allocate the buffers we need */
226 * 'pages' is an array of struct page pointers that's initialized by
227 * get_user_pages_fast().
229 pages
= kcalloc(num_pages
, sizeof(struct page
*), GFP_KERNEL
);
231 pr_debug("fsl-hv: could not allocate page list\n");
236 * sg_list is the list of fh_sg_list objects that we pass to the
239 sg_list_unaligned
= kmalloc(num_pages
* sizeof(struct fh_sg_list
) +
240 sizeof(struct fh_sg_list
) - 1, GFP_KERNEL
);
241 if (!sg_list_unaligned
) {
242 pr_debug("fsl-hv: could not allocate S/G list\n");
246 sg_list
= PTR_ALIGN(sg_list_unaligned
, sizeof(struct fh_sg_list
));
248 /* Get the physical addresses of the source buffer */
249 num_pinned
= get_user_pages_fast(param
.local_vaddr
- lb_offset
,
250 num_pages
, param
.source
!= -1 ? FOLL_WRITE
: 0, pages
);
252 if (num_pinned
!= num_pages
) {
253 pr_debug("fsl-hv: could not lock source buffer\n");
254 ret
= (num_pinned
< 0) ? num_pinned
: -EFAULT
;
259 * Build the fh_sg_list[] array. The first page is special
260 * because it's misaligned.
262 if (param
.source
== -1) {
263 sg_list
[0].source
= page_to_phys(pages
[0]) + lb_offset
;
264 sg_list
[0].target
= param
.remote_paddr
;
266 sg_list
[0].source
= param
.remote_paddr
;
267 sg_list
[0].target
= page_to_phys(pages
[0]) + lb_offset
;
269 sg_list
[0].size
= min_t(uint64_t, param
.count
, PAGE_SIZE
- lb_offset
);
271 remote_paddr
= param
.remote_paddr
+ sg_list
[0].size
;
272 count
= param
.count
- sg_list
[0].size
;
274 for (i
= 1; i
< num_pages
; i
++) {
275 if (param
.source
== -1) {
276 /* local to remote */
277 sg_list
[i
].source
= page_to_phys(pages
[i
]);
278 sg_list
[i
].target
= remote_paddr
;
280 /* remote to local */
281 sg_list
[i
].source
= remote_paddr
;
282 sg_list
[i
].target
= page_to_phys(pages
[i
]);
284 sg_list
[i
].size
= min_t(uint64_t, count
, PAGE_SIZE
);
286 remote_paddr
+= sg_list
[i
].size
;
287 count
-= sg_list
[i
].size
;
290 param
.ret
= fh_partition_memcpy(param
.source
, param
.target
,
291 virt_to_phys(sg_list
), num_pages
);
294 if (pages
&& (num_pinned
> 0)) {
295 for (i
= 0; i
< num_pinned
; i
++)
299 kfree(sg_list_unaligned
);
304 if (copy_to_user(&p
->ret
, ¶m
.ret
, sizeof(__u32
)))
311 * Ioctl interface for FSL_HV_IOCTL_DOORBELL
315 static long ioctl_doorbell(struct fsl_hv_ioctl_doorbell __user
*p
)
317 struct fsl_hv_ioctl_doorbell param
;
319 /* Get the parameters from the user. */
320 if (copy_from_user(¶m
, p
, sizeof(struct fsl_hv_ioctl_doorbell
)))
323 param
.ret
= ev_doorbell_send(param
.doorbell
);
325 if (copy_to_user(&p
->ret
, ¶m
.ret
, sizeof(__u32
)))
331 static long ioctl_dtprop(struct fsl_hv_ioctl_prop __user
*p
, int set
)
333 struct fsl_hv_ioctl_prop param
;
334 char __user
*upath
, *upropname
;
335 void __user
*upropval
;
336 char *path
, *propname
;
340 /* Get the parameters from the user. */
341 if (copy_from_user(¶m
, p
, sizeof(struct fsl_hv_ioctl_prop
)))
344 upath
= (char __user
*)(uintptr_t)param
.path
;
345 upropname
= (char __user
*)(uintptr_t)param
.propname
;
346 upropval
= (void __user
*)(uintptr_t)param
.propval
;
348 path
= strndup_user(upath
, FH_DTPROP_MAX_PATHLEN
);
350 return PTR_ERR(path
);
352 propname
= strndup_user(upropname
, FH_DTPROP_MAX_PATHLEN
);
353 if (IS_ERR(propname
)) {
354 ret
= PTR_ERR(propname
);
358 if (param
.proplen
> FH_DTPROP_MAX_PROPLEN
) {
360 goto err_free_propname
;
363 propval
= kmalloc(param
.proplen
, GFP_KERNEL
);
366 goto err_free_propname
;
370 if (copy_from_user(propval
, upropval
, param
.proplen
)) {
372 goto err_free_propval
;
375 param
.ret
= fh_partition_set_dtprop(param
.handle
,
377 virt_to_phys(propname
),
378 virt_to_phys(propval
),
381 param
.ret
= fh_partition_get_dtprop(param
.handle
,
383 virt_to_phys(propname
),
384 virt_to_phys(propval
),
387 if (param
.ret
== 0) {
388 if (copy_to_user(upropval
, propval
, param
.proplen
) ||
389 put_user(param
.proplen
, &p
->proplen
)) {
391 goto err_free_propval
;
396 if (put_user(param
.ret
, &p
->ret
))
410 * Ioctl main entry point
412 static long fsl_hv_ioctl(struct file
*file
, unsigned int cmd
,
413 unsigned long argaddr
)
415 void __user
*arg
= (void __user
*)argaddr
;
419 case FSL_HV_IOCTL_PARTITION_RESTART
:
420 ret
= ioctl_restart(arg
);
422 case FSL_HV_IOCTL_PARTITION_GET_STATUS
:
423 ret
= ioctl_status(arg
);
425 case FSL_HV_IOCTL_PARTITION_START
:
426 ret
= ioctl_start(arg
);
428 case FSL_HV_IOCTL_PARTITION_STOP
:
429 ret
= ioctl_stop(arg
);
431 case FSL_HV_IOCTL_MEMCPY
:
432 ret
= ioctl_memcpy(arg
);
434 case FSL_HV_IOCTL_DOORBELL
:
435 ret
= ioctl_doorbell(arg
);
437 case FSL_HV_IOCTL_GETPROP
:
438 ret
= ioctl_dtprop(arg
, 0);
440 case FSL_HV_IOCTL_SETPROP
:
441 ret
= ioctl_dtprop(arg
, 1);
444 pr_debug("fsl-hv: bad ioctl dir=%u type=%u cmd=%u size=%u\n",
445 _IOC_DIR(cmd
), _IOC_TYPE(cmd
), _IOC_NR(cmd
),
453 /* Linked list of processes that have us open */
454 static struct list_head db_list
;
456 /* spinlock for db_list */
457 static DEFINE_SPINLOCK(db_list_lock
);
459 /* The size of the doorbell event queue. This must be a power of two. */
462 /* Returns the next head/tail pointer, wrapping around the queue if necessary */
463 #define nextp(x) (((x) + 1) & (QSIZE - 1))
465 /* Per-open data structure */
466 struct doorbell_queue
{
467 struct list_head list
;
469 wait_queue_head_t wait
;
475 /* Linked list of ISRs that we registered */
476 struct list_head isr_list
;
478 /* Per-ISR data structure */
479 struct doorbell_isr
{
480 struct list_head list
;
482 uint32_t doorbell
; /* The doorbell handle */
483 uint32_t partition
; /* The partition handle, if used */
487 * Add a doorbell to all of the doorbell queues
489 static void fsl_hv_queue_doorbell(uint32_t doorbell
)
491 struct doorbell_queue
*dbq
;
494 /* Prevent another core from modifying db_list */
495 spin_lock_irqsave(&db_list_lock
, flags
);
497 list_for_each_entry(dbq
, &db_list
, list
) {
498 if (dbq
->head
!= nextp(dbq
->tail
)) {
499 dbq
->q
[dbq
->tail
] = doorbell
;
501 * This memory barrier eliminates the need to grab
502 * the spinlock for dbq.
505 dbq
->tail
= nextp(dbq
->tail
);
506 wake_up_interruptible(&dbq
->wait
);
510 spin_unlock_irqrestore(&db_list_lock
, flags
);
514 * Interrupt handler for all doorbells
516 * We use the same interrupt handler for all doorbells. Whenever a doorbell
517 * is rung, and we receive an interrupt, we just put the handle for that
518 * doorbell (passed to us as *data) into all of the queues.
520 static irqreturn_t
fsl_hv_isr(int irq
, void *data
)
522 fsl_hv_queue_doorbell((uintptr_t) data
);
528 * State change thread function
530 * The state change notification arrives in an interrupt, but we can't call
531 * blocking_notifier_call_chain() in an interrupt handler. We could call
532 * atomic_notifier_call_chain(), but that would require the clients' call-back
533 * function to run in interrupt context. Since we don't want to impose that
534 * restriction on the clients, we use a threaded IRQ to process the
535 * notification in kernel context.
537 static irqreturn_t
fsl_hv_state_change_thread(int irq
, void *data
)
539 struct doorbell_isr
*dbisr
= data
;
541 blocking_notifier_call_chain(&failover_subscribers
, dbisr
->partition
,
548 * Interrupt handler for state-change doorbells
550 static irqreturn_t
fsl_hv_state_change_isr(int irq
, void *data
)
553 struct doorbell_isr
*dbisr
= data
;
556 /* It's still a doorbell, so add it to all the queues. */
557 fsl_hv_queue_doorbell(dbisr
->doorbell
);
559 /* Determine the new state, and if it's stopped, notify the clients. */
560 ret
= fh_partition_get_status(dbisr
->partition
, &status
);
561 if (!ret
&& (status
== FH_PARTITION_STOPPED
))
562 return IRQ_WAKE_THREAD
;
568 * Returns a bitmask indicating whether a read will block
570 static __poll_t
fsl_hv_poll(struct file
*filp
, struct poll_table_struct
*p
)
572 struct doorbell_queue
*dbq
= filp
->private_data
;
576 spin_lock_irqsave(&dbq
->lock
, flags
);
578 poll_wait(filp
, &dbq
->wait
, p
);
579 mask
= (dbq
->head
== dbq
->tail
) ? 0 : (EPOLLIN
| EPOLLRDNORM
);
581 spin_unlock_irqrestore(&dbq
->lock
, flags
);
587 * Return the handles for any incoming doorbells
589 * If there are doorbell handles in the queue for this open instance, then
590 * return them to the caller as an array of 32-bit integers. Otherwise,
591 * block until there is at least one handle to return.
593 static ssize_t
fsl_hv_read(struct file
*filp
, char __user
*buf
, size_t len
,
596 struct doorbell_queue
*dbq
= filp
->private_data
;
597 uint32_t __user
*p
= (uint32_t __user
*) buf
; /* for put_user() */
601 /* Make sure we stop when the user buffer is full. */
602 while (len
>= sizeof(uint32_t)) {
603 uint32_t dbell
; /* Local copy of doorbell queue data */
605 spin_lock_irqsave(&dbq
->lock
, flags
);
608 * If the queue is empty, then either we're done or we need
609 * to block. If the application specified O_NONBLOCK, then
610 * we return the appropriate error code.
612 if (dbq
->head
== dbq
->tail
) {
613 spin_unlock_irqrestore(&dbq
->lock
, flags
);
616 if (filp
->f_flags
& O_NONBLOCK
)
618 if (wait_event_interruptible(dbq
->wait
,
619 dbq
->head
!= dbq
->tail
))
625 * Even though we have an smp_wmb() in the ISR, the core
626 * might speculatively execute the "dbell = ..." below while
627 * it's evaluating the if-statement above. In that case, the
628 * value put into dbell could be stale if the core accepts the
629 * speculation. To prevent that, we need a read memory barrier
634 /* Copy the data to a temporary local buffer, because
635 * we can't call copy_to_user() from inside a spinlock
637 dbell
= dbq
->q
[dbq
->head
];
638 dbq
->head
= nextp(dbq
->head
);
640 spin_unlock_irqrestore(&dbq
->lock
, flags
);
642 if (put_user(dbell
, p
))
645 count
+= sizeof(uint32_t);
646 len
-= sizeof(uint32_t);
653 * Open the driver and prepare for reading doorbells.
655 * Every time an application opens the driver, we create a doorbell queue
656 * for that file handle. This queue is used for any incoming doorbells.
658 static int fsl_hv_open(struct inode
*inode
, struct file
*filp
)
660 struct doorbell_queue
*dbq
;
663 dbq
= kzalloc(sizeof(struct doorbell_queue
), GFP_KERNEL
);
665 pr_err("fsl-hv: out of memory\n");
669 spin_lock_init(&dbq
->lock
);
670 init_waitqueue_head(&dbq
->wait
);
672 spin_lock_irqsave(&db_list_lock
, flags
);
673 list_add(&dbq
->list
, &db_list
);
674 spin_unlock_irqrestore(&db_list_lock
, flags
);
676 filp
->private_data
= dbq
;
684 static int fsl_hv_close(struct inode
*inode
, struct file
*filp
)
686 struct doorbell_queue
*dbq
= filp
->private_data
;
689 spin_lock_irqsave(&db_list_lock
, flags
);
690 list_del(&dbq
->list
);
691 spin_unlock_irqrestore(&db_list_lock
, flags
);
698 static const struct file_operations fsl_hv_fops
= {
699 .owner
= THIS_MODULE
,
701 .release
= fsl_hv_close
,
704 .unlocked_ioctl
= fsl_hv_ioctl
,
705 .compat_ioctl
= compat_ptr_ioctl
,
708 static struct miscdevice fsl_hv_misc_dev
= {
714 static irqreturn_t
fsl_hv_shutdown_isr(int irq
, void *data
)
716 orderly_poweroff(false);
722 * Returns the handle of the parent of the given node
724 * The handle is the value of the 'hv-handle' property
726 static int get_parent_handle(struct device_node
*np
)
728 struct device_node
*parent
;
729 const uint32_t *prop
;
733 parent
= of_get_parent(np
);
735 /* It's not really possible for this to fail */
739 * The proper name for the handle property is "hv-handle", but some
740 * older versions of the hypervisor used "reg".
742 prop
= of_get_property(parent
, "hv-handle", &len
);
744 prop
= of_get_property(parent
, "reg", &len
);
746 if (!prop
|| (len
!= sizeof(uint32_t))) {
747 /* This can happen only if the node is malformed */
752 handle
= be32_to_cpup(prop
);
759 * Register a callback for failover events
761 * This function is called by device drivers to register their callback
762 * functions for fail-over events.
764 int fsl_hv_failover_register(struct notifier_block
*nb
)
766 return blocking_notifier_chain_register(&failover_subscribers
, nb
);
768 EXPORT_SYMBOL(fsl_hv_failover_register
);
771 * Unregister a callback for failover events
773 int fsl_hv_failover_unregister(struct notifier_block
*nb
)
775 return blocking_notifier_chain_unregister(&failover_subscribers
, nb
);
777 EXPORT_SYMBOL(fsl_hv_failover_unregister
);
780 * Return TRUE if we're running under FSL hypervisor
782 * This function checks to see if we're running under the Freescale
783 * hypervisor, and returns zero if we're not, or non-zero if we are.
785 * First, it checks if MSR[GS]==1, which means we're running under some
786 * hypervisor. Then it checks if there is a hypervisor node in the device
787 * tree. Currently, that means there needs to be a node in the root called
788 * "hypervisor" and which has a property named "fsl,hv-version".
790 static int has_fsl_hypervisor(void)
792 struct device_node
*node
;
795 node
= of_find_node_by_path("/hypervisor");
799 ret
= of_property_present(node
, "fsl,hv-version");
807 * Freescale hypervisor management driver init
809 * This function is called when this module is loaded.
811 * Register ourselves as a miscellaneous driver. This will register the
812 * fops structure and create the right sysfs entries for udev.
814 static int __init
fsl_hypervisor_init(void)
816 struct device_node
*np
;
817 struct doorbell_isr
*dbisr
, *n
;
820 pr_info("Freescale hypervisor management driver\n");
822 if (!has_fsl_hypervisor()) {
823 pr_info("fsl-hv: no hypervisor found\n");
827 ret
= misc_register(&fsl_hv_misc_dev
);
829 pr_err("fsl-hv: cannot register device\n");
833 INIT_LIST_HEAD(&db_list
);
834 INIT_LIST_HEAD(&isr_list
);
836 for_each_compatible_node(np
, NULL
, "epapr,hv-receive-doorbell") {
838 const uint32_t *handle
;
840 handle
= of_get_property(np
, "interrupts", NULL
);
841 irq
= irq_of_parse_and_map(np
, 0);
842 if (!handle
|| !irq
) {
843 pr_err("fsl-hv: no 'interrupts' property in %pOF node\n",
848 dbisr
= kzalloc(sizeof(*dbisr
), GFP_KERNEL
);
853 dbisr
->doorbell
= be32_to_cpup(handle
);
855 if (of_device_is_compatible(np
, "fsl,hv-shutdown-doorbell")) {
856 /* The shutdown doorbell gets its own ISR */
857 ret
= request_irq(irq
, fsl_hv_shutdown_isr
, 0,
859 } else if (of_device_is_compatible(np
,
860 "fsl,hv-state-change-doorbell")) {
862 * The state change doorbell triggers a notification if
863 * the state of the managed partition changes to
864 * "stopped". We need a separate interrupt handler for
865 * that, and we also need to know the handle of the
866 * target partition, not just the handle of the
869 dbisr
->partition
= ret
= get_parent_handle(np
);
871 pr_err("fsl-hv: node %pOF has missing or "
872 "malformed parent\n", np
);
876 ret
= request_threaded_irq(irq
, fsl_hv_state_change_isr
,
877 fsl_hv_state_change_thread
,
880 ret
= request_irq(irq
, fsl_hv_isr
, 0, np
->name
, dbisr
);
883 pr_err("fsl-hv: could not request irq %u for node %pOF\n",
889 list_add(&dbisr
->list
, &isr_list
);
891 pr_info("fsl-hv: registered handler for doorbell %u\n",
898 list_for_each_entry_safe(dbisr
, n
, &isr_list
, list
) {
899 free_irq(dbisr
->irq
, dbisr
);
900 list_del(&dbisr
->list
);
904 misc_deregister(&fsl_hv_misc_dev
);
910 * Freescale hypervisor management driver termination
912 * This function is called when this driver is unloaded.
914 static void __exit
fsl_hypervisor_exit(void)
916 struct doorbell_isr
*dbisr
, *n
;
918 list_for_each_entry_safe(dbisr
, n
, &isr_list
, list
) {
919 free_irq(dbisr
->irq
, dbisr
);
920 list_del(&dbisr
->list
);
924 misc_deregister(&fsl_hv_misc_dev
);
927 module_init(fsl_hypervisor_init
);
928 module_exit(fsl_hypervisor_exit
);
930 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
931 MODULE_DESCRIPTION("Freescale hypervisor management driver");
932 MODULE_LICENSE("GPL v2");