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