933 lines · c
1/*2 * Freescale Hypervisor Management Driver3 4 * Copyright (C) 2008-2011 Freescale Semiconductor, Inc.5 * Author: Timur Tabi <timur@freescale.com>6 *7 * This file is licensed under the terms of the GNU General Public License8 * version 2. This program is licensed "as is" without any warranty of any9 * kind, whether express or implied.10 *11 * The Freescale hypervisor management driver provides several services to12 * drivers and applications related to the Freescale hypervisor:13 *14 * 1. An ioctl interface for querying and managing partitions.15 *16 * 2. A file interface to reading incoming doorbells.17 *18 * 3. An interrupt handler for shutting down the partition upon receiving the19 * shutdown doorbell from a manager partition.20 *21 * 4. A kernel interface for receiving callbacks when a managed partition22 * shuts down.23 */24 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>30#include <linux/fs.h>31#include <linux/miscdevice.h>32#include <linux/mm.h>33#include <linux/pagemap.h>34#include <linux/slab.h>35#include <linux/poll.h>36#include <linux/of.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>42 43#include <linux/io.h>44#include <asm/fsl_hcalls.h>45 46#include <linux/fsl_hypervisor.h>47 48static BLOCKING_NOTIFIER_HEAD(failover_subscribers);49 50/*51 * Ioctl interface for FSL_HV_IOCTL_PARTITION_RESTART52 *53 * Restart a running partition54 */55static long ioctl_restart(struct fsl_hv_ioctl_restart __user *p)56{57 struct fsl_hv_ioctl_restart param;58 59 /* Get the parameters from the user */60 if (copy_from_user(¶m, p, sizeof(struct fsl_hv_ioctl_restart)))61 return -EFAULT;62 63 param.ret = fh_partition_restart(param.partition);64 65 if (copy_to_user(&p->ret, ¶m.ret, sizeof(__u32)))66 return -EFAULT;67 68 return 0;69}70 71/*72 * Ioctl interface for FSL_HV_IOCTL_PARTITION_STATUS73 *74 * Query the status of a partition75 */76static long ioctl_status(struct fsl_hv_ioctl_status __user *p)77{78 struct fsl_hv_ioctl_status param;79 u32 status;80 81 /* Get the parameters from the user */82 if (copy_from_user(¶m, p, sizeof(struct fsl_hv_ioctl_status)))83 return -EFAULT;84 85 param.ret = fh_partition_get_status(param.partition, &status);86 if (!param.ret)87 param.status = status;88 89 if (copy_to_user(p, ¶m, sizeof(struct fsl_hv_ioctl_status)))90 return -EFAULT;91 92 return 0;93}94 95/*96 * Ioctl interface for FSL_HV_IOCTL_PARTITION_START97 *98 * Start a stopped partition.99 */100static long ioctl_start(struct fsl_hv_ioctl_start __user *p)101{102 struct fsl_hv_ioctl_start param;103 104 /* Get the parameters from the user */105 if (copy_from_user(¶m, p, sizeof(struct fsl_hv_ioctl_start)))106 return -EFAULT;107 108 param.ret = fh_partition_start(param.partition, param.entry_point,109 param.load);110 111 if (copy_to_user(&p->ret, ¶m.ret, sizeof(__u32)))112 return -EFAULT;113 114 return 0;115}116 117/*118 * Ioctl interface for FSL_HV_IOCTL_PARTITION_STOP119 *120 * Stop a running partition121 */122static long ioctl_stop(struct fsl_hv_ioctl_stop __user *p)123{124 struct fsl_hv_ioctl_stop param;125 126 /* Get the parameters from the user */127 if (copy_from_user(¶m, p, sizeof(struct fsl_hv_ioctl_stop)))128 return -EFAULT;129 130 param.ret = fh_partition_stop(param.partition);131 132 if (copy_to_user(&p->ret, ¶m.ret, sizeof(__u32)))133 return -EFAULT;134 135 return 0;136}137 138/*139 * Ioctl interface for FSL_HV_IOCTL_MEMCPY140 *141 * The FH_MEMCPY hypercall takes an array of address/address/size structures142 * to represent the data being copied. As a convenience to the user, this143 * ioctl takes a user-create buffer and a pointer to a guest physically144 * contiguous buffer in the remote partition, and creates the145 * address/address/size array for the hypercall.146 */147static long ioctl_memcpy(struct fsl_hv_ioctl_memcpy __user *p)148{149 struct fsl_hv_ioctl_memcpy param;150 151 struct page **pages = NULL;152 void *sg_list_unaligned = NULL;153 struct fh_sg_list *sg_list = NULL;154 155 unsigned int num_pages;156 unsigned long lb_offset; /* Offset within a page of the local buffer */157 158 unsigned int i;159 long ret = 0;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 */163 164 /* Get the parameters from the user */165 if (copy_from_user(¶m, p, sizeof(struct fsl_hv_ioctl_memcpy)))166 return -EFAULT;167 168 /*169 * One partition must be local, the other must be remote. In other170 * words, if source and target are both -1, or are both not -1, then171 * return an error.172 */173 if ((param.source == -1) == (param.target == -1))174 return -EINVAL;175 176 /*177 * The array of pages returned by get_user_pages_fast() covers only178 * page-aligned memory. Since the user buffer is probably not179 * page-aligned, we need to handle the discrepancy.180 *181 * We calculate the offset within a page of the S/G list, and make182 * adjustments accordingly. This will result in a page list that looks183 * like this:184 *185 * ---- <-- first page starts before the buffer186 * | |187 * |////|-> ----188 * |////| | |189 * ---- | |190 * | |191 * ---- | |192 * |////| | |193 * |////| | |194 * |////| | |195 * ---- | |196 * | |197 * ---- | |198 * |////| | |199 * |////| | |200 * |////| | |201 * ---- | |202 * | |203 * ---- | |204 * |////| | |205 * |////|-> ----206 * | | <-- last page ends after the buffer207 * ----208 *209 * The distance between the start of the first page and the start of the210 * buffer is lb_offset. The hashed (///) areas are the parts of the211 * page list that contain the actual buffer.212 *213 * The advantage of this approach is that the number of pages is214 * equal to the number of entries in the S/G list that we give to the215 * hypervisor.216 */217 lb_offset = param.local_vaddr & (PAGE_SIZE - 1);218 if (param.count == 0 ||219 param.count > U64_MAX - lb_offset - PAGE_SIZE + 1)220 return -EINVAL;221 num_pages = (param.count + lb_offset + PAGE_SIZE - 1) >> PAGE_SHIFT;222 223 /* Allocate the buffers we need */224 225 /*226 * 'pages' is an array of struct page pointers that's initialized by227 * get_user_pages_fast().228 */229 pages = kcalloc(num_pages, sizeof(struct page *), GFP_KERNEL);230 if (!pages) {231 pr_debug("fsl-hv: could not allocate page list\n");232 return -ENOMEM;233 }234 235 /*236 * sg_list is the list of fh_sg_list objects that we pass to the237 * hypervisor.238 */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");243 ret = -ENOMEM;244 goto free_pages;245 }246 sg_list = PTR_ALIGN(sg_list_unaligned, sizeof(struct fh_sg_list));247 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);251 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;255 goto exit;256 }257 258 /*259 * Build the fh_sg_list[] array. The first page is special260 * because it's misaligned.261 */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;265 } else {266 sg_list[0].source = param.remote_paddr;267 sg_list[0].target = page_to_phys(pages[0]) + lb_offset;268 }269 sg_list[0].size = min_t(uint64_t, param.count, PAGE_SIZE - lb_offset);270 271 remote_paddr = param.remote_paddr + sg_list[0].size;272 count = param.count - sg_list[0].size;273 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;279 } else {280 /* remote to local */281 sg_list[i].source = remote_paddr;282 sg_list[i].target = page_to_phys(pages[i]);283 }284 sg_list[i].size = min_t(uint64_t, count, PAGE_SIZE);285 286 remote_paddr += sg_list[i].size;287 count -= sg_list[i].size;288 }289 290 param.ret = fh_partition_memcpy(param.source, param.target,291 virt_to_phys(sg_list), num_pages);292 293exit:294 if (pages && (num_pinned > 0)) {295 for (i = 0; i < num_pinned; i++)296 put_page(pages[i]);297 }298 299 kfree(sg_list_unaligned);300free_pages:301 kfree(pages);302 303 if (!ret)304 if (copy_to_user(&p->ret, ¶m.ret, sizeof(__u32)))305 return -EFAULT;306 307 return ret;308}309 310/*311 * Ioctl interface for FSL_HV_IOCTL_DOORBELL312 *313 * Ring a doorbell314 */315static long ioctl_doorbell(struct fsl_hv_ioctl_doorbell __user *p)316{317 struct fsl_hv_ioctl_doorbell param;318 319 /* Get the parameters from the user. */320 if (copy_from_user(¶m, p, sizeof(struct fsl_hv_ioctl_doorbell)))321 return -EFAULT;322 323 param.ret = ev_doorbell_send(param.doorbell);324 325 if (copy_to_user(&p->ret, ¶m.ret, sizeof(__u32)))326 return -EFAULT;327 328 return 0;329}330 331static long ioctl_dtprop(struct fsl_hv_ioctl_prop __user *p, int set)332{333 struct fsl_hv_ioctl_prop param;334 char __user *upath, *upropname;335 void __user *upropval;336 char *path, *propname;337 void *propval;338 int ret = 0;339 340 /* Get the parameters from the user. */341 if (copy_from_user(¶m, p, sizeof(struct fsl_hv_ioctl_prop)))342 return -EFAULT;343 344 upath = (char __user *)(uintptr_t)param.path;345 upropname = (char __user *)(uintptr_t)param.propname;346 upropval = (void __user *)(uintptr_t)param.propval;347 348 path = strndup_user(upath, FH_DTPROP_MAX_PATHLEN);349 if (IS_ERR(path))350 return PTR_ERR(path);351 352 propname = strndup_user(upropname, FH_DTPROP_MAX_PATHLEN);353 if (IS_ERR(propname)) {354 ret = PTR_ERR(propname);355 goto err_free_path;356 }357 358 if (param.proplen > FH_DTPROP_MAX_PROPLEN) {359 ret = -EINVAL;360 goto err_free_propname;361 }362 363 propval = kmalloc(param.proplen, GFP_KERNEL);364 if (!propval) {365 ret = -ENOMEM;366 goto err_free_propname;367 }368 369 if (set) {370 if (copy_from_user(propval, upropval, param.proplen)) {371 ret = -EFAULT;372 goto err_free_propval;373 }374 375 param.ret = fh_partition_set_dtprop(param.handle,376 virt_to_phys(path),377 virt_to_phys(propname),378 virt_to_phys(propval),379 param.proplen);380 } else {381 param.ret = fh_partition_get_dtprop(param.handle,382 virt_to_phys(path),383 virt_to_phys(propname),384 virt_to_phys(propval),385 ¶m.proplen);386 387 if (param.ret == 0) {388 if (copy_to_user(upropval, propval, param.proplen) ||389 put_user(param.proplen, &p->proplen)) {390 ret = -EFAULT;391 goto err_free_propval;392 }393 }394 }395 396 if (put_user(param.ret, &p->ret))397 ret = -EFAULT;398 399err_free_propval:400 kfree(propval);401err_free_propname:402 kfree(propname);403err_free_path:404 kfree(path);405 406 return ret;407}408 409/*410 * Ioctl main entry point411 */412static long fsl_hv_ioctl(struct file *file, unsigned int cmd,413 unsigned long argaddr)414{415 void __user *arg = (void __user *)argaddr;416 long ret;417 418 switch (cmd) {419 case FSL_HV_IOCTL_PARTITION_RESTART:420 ret = ioctl_restart(arg);421 break;422 case FSL_HV_IOCTL_PARTITION_GET_STATUS:423 ret = ioctl_status(arg);424 break;425 case FSL_HV_IOCTL_PARTITION_START:426 ret = ioctl_start(arg);427 break;428 case FSL_HV_IOCTL_PARTITION_STOP:429 ret = ioctl_stop(arg);430 break;431 case FSL_HV_IOCTL_MEMCPY:432 ret = ioctl_memcpy(arg);433 break;434 case FSL_HV_IOCTL_DOORBELL:435 ret = ioctl_doorbell(arg);436 break;437 case FSL_HV_IOCTL_GETPROP:438 ret = ioctl_dtprop(arg, 0);439 break;440 case FSL_HV_IOCTL_SETPROP:441 ret = ioctl_dtprop(arg, 1);442 break;443 default: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),446 _IOC_SIZE(cmd));447 return -ENOTTY;448 }449 450 return ret;451}452 453/* Linked list of processes that have us open */454static struct list_head db_list;455 456/* spinlock for db_list */457static DEFINE_SPINLOCK(db_list_lock);458 459/* The size of the doorbell event queue. This must be a power of two. */460#define QSIZE 16461 462/* Returns the next head/tail pointer, wrapping around the queue if necessary */463#define nextp(x) (((x) + 1) & (QSIZE - 1))464 465/* Per-open data structure */466struct doorbell_queue {467 struct list_head list;468 spinlock_t lock;469 wait_queue_head_t wait;470 unsigned int head;471 unsigned int tail;472 uint32_t q[QSIZE];473};474 475/* Linked list of ISRs that we registered */476struct list_head isr_list;477 478/* Per-ISR data structure */479struct doorbell_isr {480 struct list_head list;481 unsigned int irq;482 uint32_t doorbell; /* The doorbell handle */483 uint32_t partition; /* The partition handle, if used */484};485 486/*487 * Add a doorbell to all of the doorbell queues488 */489static void fsl_hv_queue_doorbell(uint32_t doorbell)490{491 struct doorbell_queue *dbq;492 unsigned long flags;493 494 /* Prevent another core from modifying db_list */495 spin_lock_irqsave(&db_list_lock, flags);496 497 list_for_each_entry(dbq, &db_list, list) {498 if (dbq->head != nextp(dbq->tail)) {499 dbq->q[dbq->tail] = doorbell;500 /*501 * This memory barrier eliminates the need to grab502 * the spinlock for dbq.503 */504 smp_wmb();505 dbq->tail = nextp(dbq->tail);506 wake_up_interruptible(&dbq->wait);507 }508 }509 510 spin_unlock_irqrestore(&db_list_lock, flags);511}512 513/*514 * Interrupt handler for all doorbells515 *516 * We use the same interrupt handler for all doorbells. Whenever a doorbell517 * is rung, and we receive an interrupt, we just put the handle for that518 * doorbell (passed to us as *data) into all of the queues.519 */520static irqreturn_t fsl_hv_isr(int irq, void *data)521{522 fsl_hv_queue_doorbell((uintptr_t) data);523 524 return IRQ_HANDLED;525}526 527/*528 * State change thread function529 *530 * The state change notification arrives in an interrupt, but we can't call531 * blocking_notifier_call_chain() in an interrupt handler. We could call532 * atomic_notifier_call_chain(), but that would require the clients' call-back533 * function to run in interrupt context. Since we don't want to impose that534 * restriction on the clients, we use a threaded IRQ to process the535 * notification in kernel context.536 */537static irqreturn_t fsl_hv_state_change_thread(int irq, void *data)538{539 struct doorbell_isr *dbisr = data;540 541 blocking_notifier_call_chain(&failover_subscribers, dbisr->partition,542 NULL);543 544 return IRQ_HANDLED;545}546 547/*548 * Interrupt handler for state-change doorbells549 */550static irqreturn_t fsl_hv_state_change_isr(int irq, void *data)551{552 unsigned int status;553 struct doorbell_isr *dbisr = data;554 int ret;555 556 /* It's still a doorbell, so add it to all the queues. */557 fsl_hv_queue_doorbell(dbisr->doorbell);558 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;563 564 return IRQ_HANDLED;565}566 567/*568 * Returns a bitmask indicating whether a read will block569 */570static __poll_t fsl_hv_poll(struct file *filp, struct poll_table_struct *p)571{572 struct doorbell_queue *dbq = filp->private_data;573 unsigned long flags;574 __poll_t mask;575 576 spin_lock_irqsave(&dbq->lock, flags);577 578 poll_wait(filp, &dbq->wait, p);579 mask = (dbq->head == dbq->tail) ? 0 : (EPOLLIN | EPOLLRDNORM);580 581 spin_unlock_irqrestore(&dbq->lock, flags);582 583 return mask;584}585 586/*587 * Return the handles for any incoming doorbells588 *589 * If there are doorbell handles in the queue for this open instance, then590 * return them to the caller as an array of 32-bit integers. Otherwise,591 * block until there is at least one handle to return.592 */593static ssize_t fsl_hv_read(struct file *filp, char __user *buf, size_t len,594 loff_t *off)595{596 struct doorbell_queue *dbq = filp->private_data;597 uint32_t __user *p = (uint32_t __user *) buf; /* for put_user() */598 unsigned long flags;599 ssize_t count = 0;600 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 */604 605 spin_lock_irqsave(&dbq->lock, flags);606 607 /*608 * If the queue is empty, then either we're done or we need609 * to block. If the application specified O_NONBLOCK, then610 * we return the appropriate error code.611 */612 if (dbq->head == dbq->tail) {613 spin_unlock_irqrestore(&dbq->lock, flags);614 if (count)615 break;616 if (filp->f_flags & O_NONBLOCK)617 return -EAGAIN;618 if (wait_event_interruptible(dbq->wait,619 dbq->head != dbq->tail))620 return -ERESTARTSYS;621 continue;622 }623 624 /*625 * Even though we have an smp_wmb() in the ISR, the core626 * might speculatively execute the "dbell = ..." below while627 * it's evaluating the if-statement above. In that case, the628 * value put into dbell could be stale if the core accepts the629 * speculation. To prevent that, we need a read memory barrier630 * here as well.631 */632 smp_rmb();633 634 /* Copy the data to a temporary local buffer, because635 * we can't call copy_to_user() from inside a spinlock636 */637 dbell = dbq->q[dbq->head];638 dbq->head = nextp(dbq->head);639 640 spin_unlock_irqrestore(&dbq->lock, flags);641 642 if (put_user(dbell, p))643 return -EFAULT;644 p++;645 count += sizeof(uint32_t);646 len -= sizeof(uint32_t);647 }648 649 return count;650}651 652/*653 * Open the driver and prepare for reading doorbells.654 *655 * Every time an application opens the driver, we create a doorbell queue656 * for that file handle. This queue is used for any incoming doorbells.657 */658static int fsl_hv_open(struct inode *inode, struct file *filp)659{660 struct doorbell_queue *dbq;661 unsigned long flags;662 663 dbq = kzalloc(sizeof(struct doorbell_queue), GFP_KERNEL);664 if (!dbq) {665 pr_err("fsl-hv: out of memory\n");666 return -ENOMEM;667 }668 669 spin_lock_init(&dbq->lock);670 init_waitqueue_head(&dbq->wait);671 672 spin_lock_irqsave(&db_list_lock, flags);673 list_add(&dbq->list, &db_list);674 spin_unlock_irqrestore(&db_list_lock, flags);675 676 filp->private_data = dbq;677 678 return 0;679}680 681/*682 * Close the driver683 */684static int fsl_hv_close(struct inode *inode, struct file *filp)685{686 struct doorbell_queue *dbq = filp->private_data;687 unsigned long flags;688 689 spin_lock_irqsave(&db_list_lock, flags);690 list_del(&dbq->list);691 spin_unlock_irqrestore(&db_list_lock, flags);692 693 kfree(dbq);694 695 return 0;696}697 698static const struct file_operations fsl_hv_fops = {699 .owner = THIS_MODULE,700 .open = fsl_hv_open,701 .release = fsl_hv_close,702 .poll = fsl_hv_poll,703 .read = fsl_hv_read,704 .unlocked_ioctl = fsl_hv_ioctl,705 .compat_ioctl = compat_ptr_ioctl,706};707 708static struct miscdevice fsl_hv_misc_dev = {709 MISC_DYNAMIC_MINOR,710 "fsl-hv",711 &fsl_hv_fops712};713 714static irqreturn_t fsl_hv_shutdown_isr(int irq, void *data)715{716 orderly_poweroff(false);717 718 return IRQ_HANDLED;719}720 721/*722 * Returns the handle of the parent of the given node723 *724 * The handle is the value of the 'hv-handle' property725 */726static int get_parent_handle(struct device_node *np)727{728 struct device_node *parent;729 const uint32_t *prop;730 uint32_t handle;731 int len;732 733 parent = of_get_parent(np);734 if (!parent)735 /* It's not really possible for this to fail */736 return -ENODEV;737 738 /*739 * The proper name for the handle property is "hv-handle", but some740 * older versions of the hypervisor used "reg".741 */742 prop = of_get_property(parent, "hv-handle", &len);743 if (!prop)744 prop = of_get_property(parent, "reg", &len);745 746 if (!prop || (len != sizeof(uint32_t))) {747 /* This can happen only if the node is malformed */748 of_node_put(parent);749 return -ENODEV;750 }751 752 handle = be32_to_cpup(prop);753 of_node_put(parent);754 755 return handle;756}757 758/*759 * Register a callback for failover events760 *761 * This function is called by device drivers to register their callback762 * functions for fail-over events.763 */764int fsl_hv_failover_register(struct notifier_block *nb)765{766 return blocking_notifier_chain_register(&failover_subscribers, nb);767}768EXPORT_SYMBOL(fsl_hv_failover_register);769 770/*771 * Unregister a callback for failover events772 */773int fsl_hv_failover_unregister(struct notifier_block *nb)774{775 return blocking_notifier_chain_unregister(&failover_subscribers, nb);776}777EXPORT_SYMBOL(fsl_hv_failover_unregister);778 779/*780 * Return TRUE if we're running under FSL hypervisor781 *782 * This function checks to see if we're running under the Freescale783 * hypervisor, and returns zero if we're not, or non-zero if we are.784 *785 * First, it checks if MSR[GS]==1, which means we're running under some786 * hypervisor. Then it checks if there is a hypervisor node in the device787 * tree. Currently, that means there needs to be a node in the root called788 * "hypervisor" and which has a property named "fsl,hv-version".789 */790static int has_fsl_hypervisor(void)791{792 struct device_node *node;793 int ret;794 795 node = of_find_node_by_path("/hypervisor");796 if (!node)797 return 0;798 799 ret = of_property_present(node, "fsl,hv-version");800 801 of_node_put(node);802 803 return ret;804}805 806/*807 * Freescale hypervisor management driver init808 *809 * This function is called when this module is loaded.810 *811 * Register ourselves as a miscellaneous driver. This will register the812 * fops structure and create the right sysfs entries for udev.813 */814static int __init fsl_hypervisor_init(void)815{816 struct device_node *np;817 struct doorbell_isr *dbisr, *n;818 int ret;819 820 pr_info("Freescale hypervisor management driver\n");821 822 if (!has_fsl_hypervisor()) {823 pr_info("fsl-hv: no hypervisor found\n");824 return -ENODEV;825 }826 827 ret = misc_register(&fsl_hv_misc_dev);828 if (ret) {829 pr_err("fsl-hv: cannot register device\n");830 return ret;831 }832 833 INIT_LIST_HEAD(&db_list);834 INIT_LIST_HEAD(&isr_list);835 836 for_each_compatible_node(np, NULL, "epapr,hv-receive-doorbell") {837 unsigned int irq;838 const uint32_t *handle;839 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",844 np);845 continue;846 }847 848 dbisr = kzalloc(sizeof(*dbisr), GFP_KERNEL);849 if (!dbisr)850 goto out_of_memory;851 852 dbisr->irq = irq;853 dbisr->doorbell = be32_to_cpup(handle);854 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,858 np->name, NULL);859 } else if (of_device_is_compatible(np,860 "fsl,hv-state-change-doorbell")) {861 /*862 * The state change doorbell triggers a notification if863 * the state of the managed partition changes to864 * "stopped". We need a separate interrupt handler for865 * that, and we also need to know the handle of the866 * target partition, not just the handle of the867 * doorbell.868 */869 dbisr->partition = ret = get_parent_handle(np);870 if (ret < 0) {871 pr_err("fsl-hv: node %pOF has missing or "872 "malformed parent\n", np);873 kfree(dbisr);874 continue;875 }876 ret = request_threaded_irq(irq, fsl_hv_state_change_isr,877 fsl_hv_state_change_thread,878 0, np->name, dbisr);879 } else880 ret = request_irq(irq, fsl_hv_isr, 0, np->name, dbisr);881 882 if (ret < 0) {883 pr_err("fsl-hv: could not request irq %u for node %pOF\n",884 irq, np);885 kfree(dbisr);886 continue;887 }888 889 list_add(&dbisr->list, &isr_list);890 891 pr_info("fsl-hv: registered handler for doorbell %u\n",892 dbisr->doorbell);893 }894 895 return 0;896 897out_of_memory:898 list_for_each_entry_safe(dbisr, n, &isr_list, list) {899 free_irq(dbisr->irq, dbisr);900 list_del(&dbisr->list);901 kfree(dbisr);902 }903 904 misc_deregister(&fsl_hv_misc_dev);905 906 return -ENOMEM;907}908 909/*910 * Freescale hypervisor management driver termination911 *912 * This function is called when this driver is unloaded.913 */914static void __exit fsl_hypervisor_exit(void)915{916 struct doorbell_isr *dbisr, *n;917 918 list_for_each_entry_safe(dbisr, n, &isr_list, list) {919 free_irq(dbisr->irq, dbisr);920 list_del(&dbisr->list);921 kfree(dbisr);922 }923 924 misc_deregister(&fsl_hv_misc_dev);925}926 927module_init(fsl_hypervisor_init);928module_exit(fsl_hypervisor_exit);929 930MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");931MODULE_DESCRIPTION("Freescale hypervisor management driver");932MODULE_LICENSE("GPL v2");933