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
48static BLOCKING_NOTIFIER_HEAD(failover_subscribers);
49
50/*
51 * Ioctl interface for FSL_HV_IOCTL_PARTITION_RESTART
52 *
53 * Restart a running partition
54 */
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(&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 */
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(&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 */
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(&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 */
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(&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 */
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; /* 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
295exit:
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 */
317static 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
333static 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
403out:
404	kfree(path);
405	kfree(propval);
406	kfree(propname);
407
408	return ret;
409}
410
411/*
412 * Ioctl main entry point
413 */
414static 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 */
456static struct list_head db_list;
457
458/* spinlock for db_list */
459static 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 */
468struct 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 */
478struct list_head isr_list;
479
480/* Per-ISR data structure */
481struct 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 */
491static 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 */
522static 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 */
539static 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 */
552static 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 */
572static 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 */
595static 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 */
660static 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 */
687static 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
703static 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
713static struct miscdevice fsl_hv_misc_dev = {
714	MISC_DYNAMIC_MINOR,
715	"fsl-hv",
716	&fsl_hv_fops
717};
718
719static 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 */
731static 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 */
769int fsl_hv_failover_register(struct notifier_block *nb)
770{
771	return blocking_notifier_chain_register(&failover_subscribers, nb);
772}
773EXPORT_SYMBOL(fsl_hv_failover_register);
774
775/*
776 * Unregister a callback for failover events
777 */
778int fsl_hv_failover_unregister(struct notifier_block *nb)
779{
780	return blocking_notifier_chain_unregister(&failover_subscribers, nb);
781}
782EXPORT_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 */
795static 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 */
819static 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
902out_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 */
919static 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
932module_init(fsl_hypervisor_init);
933module_exit(fsl_hypervisor_exit);
934
935MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
936MODULE_DESCRIPTION("Freescale hypervisor management driver");
937MODULE_LICENSE("GPL v2");
938