]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/virt/fsl_hypervisor.c
Merge tag 'for-linville-20131203' of git://github.com/kvalo/ath
[mirror_ubuntu-artful-kernel.git] / drivers / virt / fsl_hypervisor.c
1 /*
2 * Freescale Hypervisor Management Driver
3
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 License
8 * version 2. This program is licensed "as is" without any warranty of any
9 * kind, whether express or implied.
10 *
11 * The Freescale hypervisor management driver provides several services to
12 * 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 the
19 * shutdown doorbell from a manager partition.
20 *
21 * 4. A kernel interface for receiving callbacks when a managed partition
22 * 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
48 static BLOCKING_NOTIFIER_HEAD(failover_subscribers);
49
50 /*
51 * Ioctl interface for FSL_HV_IOCTL_PARTITION_RESTART
52 *
53 * Restart a running partition
54 */
55 static 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(&param, 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, &param.ret, sizeof(__u32)))
66 return -EFAULT;
67
68 return 0;
69 }
70
71 /*
72 * Ioctl interface for FSL_HV_IOCTL_PARTITION_STATUS
73 *
74 * Query the status of a partition
75 */
76 static 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(&param, 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, &param, sizeof(struct fsl_hv_ioctl_status)))
90 return -EFAULT;
91
92 return 0;
93 }
94
95 /*
96 * Ioctl interface for FSL_HV_IOCTL_PARTITION_START
97 *
98 * Start a stopped partition.
99 */
100 static 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(&param, 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, &param.ret, sizeof(__u32)))
112 return -EFAULT;
113
114 return 0;
115 }
116
117 /*
118 * Ioctl interface for FSL_HV_IOCTL_PARTITION_STOP
119 *
120 * Stop a running partition
121 */
122 static 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(&param, 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, &param.ret, sizeof(__u32)))
133 return -EFAULT;
134
135 return 0;
136 }
137
138 /*
139 * Ioctl interface for FSL_HV_IOCTL_MEMCPY
140 *
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.
146 */
147 static 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; /* return value from get_user_pages() */
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(&param, p, sizeof(struct fsl_hv_ioctl_memcpy)))
166 return -EFAULT;
167
168 /*
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
171 * 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() covers only
178 * page-aligned memory. Since the user buffer is probably not
179 * page-aligned, we need to handle the discrepancy.
180 *
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
183 * like this:
184 *
185 * ---- <-- first page starts before the buffer
186 * | |
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 buffer
207 * ----
208 *
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.
212 *
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
215 * hypervisor.
216 */
217 lb_offset = param.local_vaddr & (PAGE_SIZE - 1);
218 num_pages = (param.count + lb_offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
219
220 /* Allocate the buffers we need */
221
222 /*
223 * 'pages' is an array of struct page pointers that's initialized by
224 * get_user_pages().
225 */
226 pages = kzalloc(num_pages * sizeof(struct page *), GFP_KERNEL);
227 if (!pages) {
228 pr_debug("fsl-hv: could not allocate page list\n");
229 return -ENOMEM;
230 }
231
232 /*
233 * sg_list is the list of fh_sg_list objects that we pass to the
234 * hypervisor.
235 */
236 sg_list_unaligned = kmalloc(num_pages * sizeof(struct fh_sg_list) +
237 sizeof(struct fh_sg_list) - 1, GFP_KERNEL);
238 if (!sg_list_unaligned) {
239 pr_debug("fsl-hv: could not allocate S/G list\n");
240 ret = -ENOMEM;
241 goto exit;
242 }
243 sg_list = PTR_ALIGN(sg_list_unaligned, sizeof(struct fh_sg_list));
244
245 /* Get the physical addresses of the source buffer */
246 down_read(&current->mm->mmap_sem);
247 num_pinned = get_user_pages(current, current->mm,
248 param.local_vaddr - lb_offset, num_pages,
249 (param.source == -1) ? READ : WRITE,
250 0, pages, NULL);
251 up_read(&current->mm->mmap_sem);
252
253 if (num_pinned != num_pages) {
254 /* get_user_pages() failed */
255 pr_debug("fsl-hv: could not lock source buffer\n");
256 ret = (num_pinned < 0) ? num_pinned : -EFAULT;
257 goto exit;
258 }
259
260 /*
261 * Build the fh_sg_list[] array. The first page is special
262 * because it's misaligned.
263 */
264 if (param.source == -1) {
265 sg_list[0].source = page_to_phys(pages[0]) + lb_offset;
266 sg_list[0].target = param.remote_paddr;
267 } else {
268 sg_list[0].source = param.remote_paddr;
269 sg_list[0].target = page_to_phys(pages[0]) + lb_offset;
270 }
271 sg_list[0].size = min_t(uint64_t, param.count, PAGE_SIZE - lb_offset);
272
273 remote_paddr = param.remote_paddr + sg_list[0].size;
274 count = param.count - sg_list[0].size;
275
276 for (i = 1; i < num_pages; i++) {
277 if (param.source == -1) {
278 /* local to remote */
279 sg_list[i].source = page_to_phys(pages[i]);
280 sg_list[i].target = remote_paddr;
281 } else {
282 /* remote to local */
283 sg_list[i].source = remote_paddr;
284 sg_list[i].target = page_to_phys(pages[i]);
285 }
286 sg_list[i].size = min_t(uint64_t, count, PAGE_SIZE);
287
288 remote_paddr += sg_list[i].size;
289 count -= sg_list[i].size;
290 }
291
292 param.ret = fh_partition_memcpy(param.source, param.target,
293 virt_to_phys(sg_list), num_pages);
294
295 exit:
296 if (pages) {
297 for (i = 0; i < num_pages; i++)
298 if (pages[i])
299 put_page(pages[i]);
300 }
301
302 kfree(sg_list_unaligned);
303 kfree(pages);
304
305 if (!ret)
306 if (copy_to_user(&p->ret, &param.ret, sizeof(__u32)))
307 return -EFAULT;
308
309 return ret;
310 }
311
312 /*
313 * Ioctl interface for FSL_HV_IOCTL_DOORBELL
314 *
315 * Ring a doorbell
316 */
317 static long ioctl_doorbell(struct fsl_hv_ioctl_doorbell __user *p)
318 {
319 struct fsl_hv_ioctl_doorbell param;
320
321 /* Get the parameters from the user. */
322 if (copy_from_user(&param, p, sizeof(struct fsl_hv_ioctl_doorbell)))
323 return -EFAULT;
324
325 param.ret = ev_doorbell_send(param.doorbell);
326
327 if (copy_to_user(&p->ret, &param.ret, sizeof(__u32)))
328 return -EFAULT;
329
330 return 0;
331 }
332
333 static long ioctl_dtprop(struct fsl_hv_ioctl_prop __user *p, int set)
334 {
335 struct fsl_hv_ioctl_prop param;
336 char __user *upath, *upropname;
337 void __user *upropval;
338 char *path = NULL, *propname = NULL;
339 void *propval = NULL;
340 int ret = 0;
341
342 /* Get the parameters from the user. */
343 if (copy_from_user(&param, p, sizeof(struct fsl_hv_ioctl_prop)))
344 return -EFAULT;
345
346 upath = (char __user *)(uintptr_t)param.path;
347 upropname = (char __user *)(uintptr_t)param.propname;
348 upropval = (void __user *)(uintptr_t)param.propval;
349
350 path = strndup_user(upath, FH_DTPROP_MAX_PATHLEN);
351 if (IS_ERR(path)) {
352 ret = PTR_ERR(path);
353 goto out;
354 }
355
356 propname = strndup_user(upropname, FH_DTPROP_MAX_PATHLEN);
357 if (IS_ERR(propname)) {
358 ret = PTR_ERR(propname);
359 goto out;
360 }
361
362 if (param.proplen > FH_DTPROP_MAX_PROPLEN) {
363 ret = -EINVAL;
364 goto out;
365 }
366
367 propval = kmalloc(param.proplen, GFP_KERNEL);
368 if (!propval) {
369 ret = -ENOMEM;
370 goto out;
371 }
372
373 if (set) {
374 if (copy_from_user(propval, upropval, param.proplen)) {
375 ret = -EFAULT;
376 goto out;
377 }
378
379 param.ret = fh_partition_set_dtprop(param.handle,
380 virt_to_phys(path),
381 virt_to_phys(propname),
382 virt_to_phys(propval),
383 param.proplen);
384 } else {
385 param.ret = fh_partition_get_dtprop(param.handle,
386 virt_to_phys(path),
387 virt_to_phys(propname),
388 virt_to_phys(propval),
389 &param.proplen);
390
391 if (param.ret == 0) {
392 if (copy_to_user(upropval, propval, param.proplen) ||
393 put_user(param.proplen, &p->proplen)) {
394 ret = -EFAULT;
395 goto out;
396 }
397 }
398 }
399
400 if (put_user(param.ret, &p->ret))
401 ret = -EFAULT;
402
403 out:
404 kfree(path);
405 kfree(propval);
406 kfree(propname);
407
408 return ret;
409 }
410
411 /*
412 * Ioctl main entry point
413 */
414 static long fsl_hv_ioctl(struct file *file, unsigned int cmd,
415 unsigned long argaddr)
416 {
417 void __user *arg = (void __user *)argaddr;
418 long ret;
419
420 switch (cmd) {
421 case FSL_HV_IOCTL_PARTITION_RESTART:
422 ret = ioctl_restart(arg);
423 break;
424 case FSL_HV_IOCTL_PARTITION_GET_STATUS:
425 ret = ioctl_status(arg);
426 break;
427 case FSL_HV_IOCTL_PARTITION_START:
428 ret = ioctl_start(arg);
429 break;
430 case FSL_HV_IOCTL_PARTITION_STOP:
431 ret = ioctl_stop(arg);
432 break;
433 case FSL_HV_IOCTL_MEMCPY:
434 ret = ioctl_memcpy(arg);
435 break;
436 case FSL_HV_IOCTL_DOORBELL:
437 ret = ioctl_doorbell(arg);
438 break;
439 case FSL_HV_IOCTL_GETPROP:
440 ret = ioctl_dtprop(arg, 0);
441 break;
442 case FSL_HV_IOCTL_SETPROP:
443 ret = ioctl_dtprop(arg, 1);
444 break;
445 default:
446 pr_debug("fsl-hv: bad ioctl dir=%u type=%u cmd=%u size=%u\n",
447 _IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd),
448 _IOC_SIZE(cmd));
449 return -ENOTTY;
450 }
451
452 return ret;
453 }
454
455 /* Linked list of processes that have us open */
456 static struct list_head db_list;
457
458 /* spinlock for db_list */
459 static DEFINE_SPINLOCK(db_list_lock);
460
461 /* The size of the doorbell event queue. This must be a power of two. */
462 #define QSIZE 16
463
464 /* Returns the next head/tail pointer, wrapping around the queue if necessary */
465 #define nextp(x) (((x) + 1) & (QSIZE - 1))
466
467 /* Per-open data structure */
468 struct doorbell_queue {
469 struct list_head list;
470 spinlock_t lock;
471 wait_queue_head_t wait;
472 unsigned int head;
473 unsigned int tail;
474 uint32_t q[QSIZE];
475 };
476
477 /* Linked list of ISRs that we registered */
478 struct list_head isr_list;
479
480 /* Per-ISR data structure */
481 struct doorbell_isr {
482 struct list_head list;
483 unsigned int irq;
484 uint32_t doorbell; /* The doorbell handle */
485 uint32_t partition; /* The partition handle, if used */
486 };
487
488 /*
489 * Add a doorbell to all of the doorbell queues
490 */
491 static void fsl_hv_queue_doorbell(uint32_t doorbell)
492 {
493 struct doorbell_queue *dbq;
494 unsigned long flags;
495
496 /* Prevent another core from modifying db_list */
497 spin_lock_irqsave(&db_list_lock, flags);
498
499 list_for_each_entry(dbq, &db_list, list) {
500 if (dbq->head != nextp(dbq->tail)) {
501 dbq->q[dbq->tail] = doorbell;
502 /*
503 * This memory barrier eliminates the need to grab
504 * the spinlock for dbq.
505 */
506 smp_wmb();
507 dbq->tail = nextp(dbq->tail);
508 wake_up_interruptible(&dbq->wait);
509 }
510 }
511
512 spin_unlock_irqrestore(&db_list_lock, flags);
513 }
514
515 /*
516 * Interrupt handler for all doorbells
517 *
518 * We use the same interrupt handler for all doorbells. Whenever a doorbell
519 * is rung, and we receive an interrupt, we just put the handle for that
520 * doorbell (passed to us as *data) into all of the queues.
521 */
522 static irqreturn_t fsl_hv_isr(int irq, void *data)
523 {
524 fsl_hv_queue_doorbell((uintptr_t) data);
525
526 return IRQ_HANDLED;
527 }
528
529 /*
530 * State change thread function
531 *
532 * The state change notification arrives in an interrupt, but we can't call
533 * blocking_notifier_call_chain() in an interrupt handler. We could call
534 * atomic_notifier_call_chain(), but that would require the clients' call-back
535 * function to run in interrupt context. Since we don't want to impose that
536 * restriction on the clients, we use a threaded IRQ to process the
537 * notification in kernel context.
538 */
539 static irqreturn_t fsl_hv_state_change_thread(int irq, void *data)
540 {
541 struct doorbell_isr *dbisr = data;
542
543 blocking_notifier_call_chain(&failover_subscribers, dbisr->partition,
544 NULL);
545
546 return IRQ_HANDLED;
547 }
548
549 /*
550 * Interrupt handler for state-change doorbells
551 */
552 static irqreturn_t fsl_hv_state_change_isr(int irq, void *data)
553 {
554 unsigned int status;
555 struct doorbell_isr *dbisr = data;
556 int ret;
557
558 /* It's still a doorbell, so add it to all the queues. */
559 fsl_hv_queue_doorbell(dbisr->doorbell);
560
561 /* Determine the new state, and if it's stopped, notify the clients. */
562 ret = fh_partition_get_status(dbisr->partition, &status);
563 if (!ret && (status == FH_PARTITION_STOPPED))
564 return IRQ_WAKE_THREAD;
565
566 return IRQ_HANDLED;
567 }
568
569 /*
570 * Returns a bitmask indicating whether a read will block
571 */
572 static unsigned int fsl_hv_poll(struct file *filp, struct poll_table_struct *p)
573 {
574 struct doorbell_queue *dbq = filp->private_data;
575 unsigned long flags;
576 unsigned int mask;
577
578 spin_lock_irqsave(&dbq->lock, flags);
579
580 poll_wait(filp, &dbq->wait, p);
581 mask = (dbq->head == dbq->tail) ? 0 : (POLLIN | POLLRDNORM);
582
583 spin_unlock_irqrestore(&dbq->lock, flags);
584
585 return mask;
586 }
587
588 /*
589 * Return the handles for any incoming doorbells
590 *
591 * If there are doorbell handles in the queue for this open instance, then
592 * return them to the caller as an array of 32-bit integers. Otherwise,
593 * block until there is at least one handle to return.
594 */
595 static ssize_t fsl_hv_read(struct file *filp, char __user *buf, size_t len,
596 loff_t *off)
597 {
598 struct doorbell_queue *dbq = filp->private_data;
599 uint32_t __user *p = (uint32_t __user *) buf; /* for put_user() */
600 unsigned long flags;
601 ssize_t count = 0;
602
603 /* Make sure we stop when the user buffer is full. */
604 while (len >= sizeof(uint32_t)) {
605 uint32_t dbell; /* Local copy of doorbell queue data */
606
607 spin_lock_irqsave(&dbq->lock, flags);
608
609 /*
610 * If the queue is empty, then either we're done or we need
611 * to block. If the application specified O_NONBLOCK, then
612 * we return the appropriate error code.
613 */
614 if (dbq->head == dbq->tail) {
615 spin_unlock_irqrestore(&dbq->lock, flags);
616 if (count)
617 break;
618 if (filp->f_flags & O_NONBLOCK)
619 return -EAGAIN;
620 if (wait_event_interruptible(dbq->wait,
621 dbq->head != dbq->tail))
622 return -ERESTARTSYS;
623 continue;
624 }
625
626 /*
627 * Even though we have an smp_wmb() in the ISR, the core
628 * might speculatively execute the "dbell = ..." below while
629 * it's evaluating the if-statement above. In that case, the
630 * value put into dbell could be stale if the core accepts the
631 * speculation. To prevent that, we need a read memory barrier
632 * here as well.
633 */
634 smp_rmb();
635
636 /* Copy the data to a temporary local buffer, because
637 * we can't call copy_to_user() from inside a spinlock
638 */
639 dbell = dbq->q[dbq->head];
640 dbq->head = nextp(dbq->head);
641
642 spin_unlock_irqrestore(&dbq->lock, flags);
643
644 if (put_user(dbell, p))
645 return -EFAULT;
646 p++;
647 count += sizeof(uint32_t);
648 len -= sizeof(uint32_t);
649 }
650
651 return count;
652 }
653
654 /*
655 * Open the driver and prepare for reading doorbells.
656 *
657 * Every time an application opens the driver, we create a doorbell queue
658 * for that file handle. This queue is used for any incoming doorbells.
659 */
660 static int fsl_hv_open(struct inode *inode, struct file *filp)
661 {
662 struct doorbell_queue *dbq;
663 unsigned long flags;
664 int ret = 0;
665
666 dbq = kzalloc(sizeof(struct doorbell_queue), GFP_KERNEL);
667 if (!dbq) {
668 pr_err("fsl-hv: out of memory\n");
669 return -ENOMEM;
670 }
671
672 spin_lock_init(&dbq->lock);
673 init_waitqueue_head(&dbq->wait);
674
675 spin_lock_irqsave(&db_list_lock, flags);
676 list_add(&dbq->list, &db_list);
677 spin_unlock_irqrestore(&db_list_lock, flags);
678
679 filp->private_data = dbq;
680
681 return ret;
682 }
683
684 /*
685 * Close the driver
686 */
687 static int fsl_hv_close(struct inode *inode, struct file *filp)
688 {
689 struct doorbell_queue *dbq = filp->private_data;
690 unsigned long flags;
691
692 int ret = 0;
693
694 spin_lock_irqsave(&db_list_lock, flags);
695 list_del(&dbq->list);
696 spin_unlock_irqrestore(&db_list_lock, flags);
697
698 kfree(dbq);
699
700 return ret;
701 }
702
703 static const struct file_operations fsl_hv_fops = {
704 .owner = THIS_MODULE,
705 .open = fsl_hv_open,
706 .release = fsl_hv_close,
707 .poll = fsl_hv_poll,
708 .read = fsl_hv_read,
709 .unlocked_ioctl = fsl_hv_ioctl,
710 .compat_ioctl = fsl_hv_ioctl,
711 };
712
713 static struct miscdevice fsl_hv_misc_dev = {
714 MISC_DYNAMIC_MINOR,
715 "fsl-hv",
716 &fsl_hv_fops
717 };
718
719 static irqreturn_t fsl_hv_shutdown_isr(int irq, void *data)
720 {
721 orderly_poweroff(false);
722
723 return IRQ_HANDLED;
724 }
725
726 /*
727 * Returns the handle of the parent of the given node
728 *
729 * The handle is the value of the 'hv-handle' property
730 */
731 static int get_parent_handle(struct device_node *np)
732 {
733 struct device_node *parent;
734 const uint32_t *prop;
735 uint32_t handle;
736 int len;
737
738 parent = of_get_parent(np);
739 if (!parent)
740 /* It's not really possible for this to fail */
741 return -ENODEV;
742
743 /*
744 * The proper name for the handle property is "hv-handle", but some
745 * older versions of the hypervisor used "reg".
746 */
747 prop = of_get_property(parent, "hv-handle", &len);
748 if (!prop)
749 prop = of_get_property(parent, "reg", &len);
750
751 if (!prop || (len != sizeof(uint32_t))) {
752 /* This can happen only if the node is malformed */
753 of_node_put(parent);
754 return -ENODEV;
755 }
756
757 handle = be32_to_cpup(prop);
758 of_node_put(parent);
759
760 return handle;
761 }
762
763 /*
764 * Register a callback for failover events
765 *
766 * This function is called by device drivers to register their callback
767 * functions for fail-over events.
768 */
769 int fsl_hv_failover_register(struct notifier_block *nb)
770 {
771 return blocking_notifier_chain_register(&failover_subscribers, nb);
772 }
773 EXPORT_SYMBOL(fsl_hv_failover_register);
774
775 /*
776 * Unregister a callback for failover events
777 */
778 int fsl_hv_failover_unregister(struct notifier_block *nb)
779 {
780 return blocking_notifier_chain_unregister(&failover_subscribers, nb);
781 }
782 EXPORT_SYMBOL(fsl_hv_failover_unregister);
783
784 /*
785 * Return TRUE if we're running under FSL hypervisor
786 *
787 * This function checks to see if we're running under the Freescale
788 * hypervisor, and returns zero if we're not, or non-zero if we are.
789 *
790 * First, it checks if MSR[GS]==1, which means we're running under some
791 * hypervisor. Then it checks if there is a hypervisor node in the device
792 * tree. Currently, that means there needs to be a node in the root called
793 * "hypervisor" and which has a property named "fsl,hv-version".
794 */
795 static int has_fsl_hypervisor(void)
796 {
797 struct device_node *node;
798 int ret;
799
800 node = of_find_node_by_path("/hypervisor");
801 if (!node)
802 return 0;
803
804 ret = of_find_property(node, "fsl,hv-version", NULL) != NULL;
805
806 of_node_put(node);
807
808 return ret;
809 }
810
811 /*
812 * Freescale hypervisor management driver init
813 *
814 * This function is called when this module is loaded.
815 *
816 * Register ourselves as a miscellaneous driver. This will register the
817 * fops structure and create the right sysfs entries for udev.
818 */
819 static int __init fsl_hypervisor_init(void)
820 {
821 struct device_node *np;
822 struct doorbell_isr *dbisr, *n;
823 int ret;
824
825 pr_info("Freescale hypervisor management driver\n");
826
827 if (!has_fsl_hypervisor()) {
828 pr_info("fsl-hv: no hypervisor found\n");
829 return -ENODEV;
830 }
831
832 ret = misc_register(&fsl_hv_misc_dev);
833 if (ret) {
834 pr_err("fsl-hv: cannot register device\n");
835 return ret;
836 }
837
838 INIT_LIST_HEAD(&db_list);
839 INIT_LIST_HEAD(&isr_list);
840
841 for_each_compatible_node(np, NULL, "epapr,hv-receive-doorbell") {
842 unsigned int irq;
843 const uint32_t *handle;
844
845 handle = of_get_property(np, "interrupts", NULL);
846 irq = irq_of_parse_and_map(np, 0);
847 if (!handle || (irq == NO_IRQ)) {
848 pr_err("fsl-hv: no 'interrupts' property in %s node\n",
849 np->full_name);
850 continue;
851 }
852
853 dbisr = kzalloc(sizeof(*dbisr), GFP_KERNEL);
854 if (!dbisr)
855 goto out_of_memory;
856
857 dbisr->irq = irq;
858 dbisr->doorbell = be32_to_cpup(handle);
859
860 if (of_device_is_compatible(np, "fsl,hv-shutdown-doorbell")) {
861 /* The shutdown doorbell gets its own ISR */
862 ret = request_irq(irq, fsl_hv_shutdown_isr, 0,
863 np->name, NULL);
864 } else if (of_device_is_compatible(np,
865 "fsl,hv-state-change-doorbell")) {
866 /*
867 * The state change doorbell triggers a notification if
868 * the state of the managed partition changes to
869 * "stopped". We need a separate interrupt handler for
870 * that, and we also need to know the handle of the
871 * target partition, not just the handle of the
872 * doorbell.
873 */
874 dbisr->partition = ret = get_parent_handle(np);
875 if (ret < 0) {
876 pr_err("fsl-hv: node %s has missing or "
877 "malformed parent\n", np->full_name);
878 kfree(dbisr);
879 continue;
880 }
881 ret = request_threaded_irq(irq, fsl_hv_state_change_isr,
882 fsl_hv_state_change_thread,
883 0, np->name, dbisr);
884 } else
885 ret = request_irq(irq, fsl_hv_isr, 0, np->name, dbisr);
886
887 if (ret < 0) {
888 pr_err("fsl-hv: could not request irq %u for node %s\n",
889 irq, np->full_name);
890 kfree(dbisr);
891 continue;
892 }
893
894 list_add(&dbisr->list, &isr_list);
895
896 pr_info("fsl-hv: registered handler for doorbell %u\n",
897 dbisr->doorbell);
898 }
899
900 return 0;
901
902 out_of_memory:
903 list_for_each_entry_safe(dbisr, n, &isr_list, list) {
904 free_irq(dbisr->irq, dbisr);
905 list_del(&dbisr->list);
906 kfree(dbisr);
907 }
908
909 misc_deregister(&fsl_hv_misc_dev);
910
911 return -ENOMEM;
912 }
913
914 /*
915 * Freescale hypervisor management driver termination
916 *
917 * This function is called when this driver is unloaded.
918 */
919 static void __exit fsl_hypervisor_exit(void)
920 {
921 struct doorbell_isr *dbisr, *n;
922
923 list_for_each_entry_safe(dbisr, n, &isr_list, list) {
924 free_irq(dbisr->irq, dbisr);
925 list_del(&dbisr->list);
926 kfree(dbisr);
927 }
928
929 misc_deregister(&fsl_hv_misc_dev);
930 }
931
932 module_init(fsl_hypervisor_init);
933 module_exit(fsl_hypervisor_exit);
934
935 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
936 MODULE_DESCRIPTION("Freescale hypervisor management driver");
937 MODULE_LICENSE("GPL v2");