| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Jeremy Kerr | 1691 | 92.81% | 2 | 10.00% |
| Vasant Hegde | 45 | 2.47% | 3 | 15.00% |
| Michael Ellerman | 37 | 2.03% | 2 | 10.00% |
| Benjamin Herrenschmidt | 14 | 0.77% | 2 | 10.00% |
| Geliang Tang | 8 | 0.44% | 1 | 5.00% |
| Mahesh Salgaonkar | 6 | 0.33% | 1 | 5.00% |
| Haoran Liu | 6 | 0.33% | 1 | 5.00% |
| Vaidyanathan Srinivasan | 5 | 0.27% | 1 | 5.00% |
| Linus Torvalds | 3 | 0.16% | 2 | 10.00% |
| Uwe Kleine-König | 2 | 0.11% | 1 | 5.00% |
| Thomas Gleixner | 2 | 0.11% | 1 | 5.00% |
| dingsenjie | 1 | 0.05% | 1 | 5.00% |
| Al Viro | 1 | 0.05% | 1 | 5.00% |
| Oliver O'Halloran | 1 | 0.05% | 1 | 5.00% |
| Total | 1822 | 20 |
// SPDX-License-Identifier: GPL-2.0-only /* * OPAL Runtime Diagnostics interface driver * Supported on POWERNV platform * * Copyright IBM Corporation 2015 */ #define pr_fmt(fmt) "opal-prd: " fmt #include <linux/kernel.h> #include <linux/module.h> #include <linux/platform_device.h> #include <linux/miscdevice.h> #include <linux/fs.h> #include <linux/of.h> #include <linux/of_address.h> #include <linux/poll.h> #include <linux/mm.h> #include <linux/slab.h> #include <asm/opal-prd.h> #include <asm/opal.h> #include <asm/io.h> #include <linux/uaccess.h> struct opal_prd_msg { union { struct opal_prd_msg_header header; DECLARE_FLEX_ARRAY(u8, data); }; }; /* * The msg member must be at the end of the struct, as it's followed by the * message data. */ struct opal_prd_msg_queue_item { struct list_head list; struct opal_prd_msg msg; }; static struct device_node *prd_node; static LIST_HEAD(opal_prd_msg_queue); static DEFINE_SPINLOCK(opal_prd_msg_queue_lock); static DECLARE_WAIT_QUEUE_HEAD(opal_prd_msg_wait); static atomic_t prd_usage; static bool opal_prd_range_is_valid(uint64_t addr, uint64_t size) { struct device_node *parent, *node; bool found; if (addr + size < addr) return false; parent = of_find_node_by_path("/reserved-memory"); if (!parent) return false; found = false; for_each_child_of_node(parent, node) { uint64_t range_addr, range_size, range_end; const __be32 *addrp; const char *label; addrp = of_get_address(node, 0, &range_size, NULL); if (!addrp) continue; range_addr = of_read_number(addrp, 2); range_end = range_addr + range_size; label = of_get_property(node, "ibm,prd-label", NULL); /* PRD ranges need a label */ if (!label) continue; if (range_end <= range_addr) continue; if (addr >= range_addr && addr + size <= range_end) { found = true; of_node_put(node); break; } } of_node_put(parent); return found; } static int opal_prd_open(struct inode *inode, struct file *file) { /* * Prevent multiple (separate) processes from concurrent interactions * with the FW PRD channel */ if (atomic_xchg(&prd_usage, 1) == 1) return -EBUSY; return 0; } /* * opal_prd_mmap - maps firmware-provided ranges into userspace * @file: file structure for the device * @vma: VMA to map the registers into */ static int opal_prd_mmap(struct file *file, struct vm_area_struct *vma) { size_t addr, size; pgprot_t page_prot; pr_devel("opal_prd_mmap(0x%016lx, 0x%016lx, 0x%lx, 0x%lx)\n", vma->vm_start, vma->vm_end, vma->vm_pgoff, vma->vm_flags); addr = vma->vm_pgoff << PAGE_SHIFT; size = vma->vm_end - vma->vm_start; /* ensure we're mapping within one of the allowable ranges */ if (!opal_prd_range_is_valid(addr, size)) return -EINVAL; page_prot = phys_mem_access_prot(file, vma->vm_pgoff, size, vma->vm_page_prot); return remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff, size, page_prot); } static bool opal_msg_queue_empty(void) { unsigned long flags; bool ret; spin_lock_irqsave(&opal_prd_msg_queue_lock, flags); ret = list_empty(&opal_prd_msg_queue); spin_unlock_irqrestore(&opal_prd_msg_queue_lock, flags); return ret; } static __poll_t opal_prd_poll(struct file *file, struct poll_table_struct *wait) { poll_wait(file, &opal_prd_msg_wait, wait); if (!opal_msg_queue_empty()) return EPOLLIN | EPOLLRDNORM; return 0; } static ssize_t opal_prd_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) { struct opal_prd_msg_queue_item *item; unsigned long flags; ssize_t size, err; int rc; /* we need at least a header's worth of data */ if (count < sizeof(item->msg.header)) return -EINVAL; if (*ppos) return -ESPIPE; item = NULL; for (;;) { spin_lock_irqsave(&opal_prd_msg_queue_lock, flags); if (!list_empty(&opal_prd_msg_queue)) { item = list_first_entry(&opal_prd_msg_queue, struct opal_prd_msg_queue_item, list); list_del(&item->list); } spin_unlock_irqrestore(&opal_prd_msg_queue_lock, flags); if (item) break; if (file->f_flags & O_NONBLOCK) return -EAGAIN; rc = wait_event_interruptible(opal_prd_msg_wait, !opal_msg_queue_empty()); if (rc) return -EINTR; } size = be16_to_cpu(item->msg.header.size); if (size > count) { err = -EINVAL; goto err_requeue; } rc = copy_to_user(buf, &item->msg, size); if (rc) { err = -EFAULT; goto err_requeue; } kfree(item); return size; err_requeue: /* eep! re-queue at the head of the list */ spin_lock_irqsave(&opal_prd_msg_queue_lock, flags); list_add(&item->list, &opal_prd_msg_queue); spin_unlock_irqrestore(&opal_prd_msg_queue_lock, flags); return err; } static ssize_t opal_prd_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { struct opal_prd_msg_header hdr; struct opal_prd_msg *msg; ssize_t size; int rc; size = sizeof(hdr); if (count < size) return -EINVAL; /* grab the header */ rc = copy_from_user(&hdr, buf, sizeof(hdr)); if (rc) return -EFAULT; size = be16_to_cpu(hdr.size); msg = memdup_user(buf, size); if (IS_ERR(msg)) return PTR_ERR(msg); rc = opal_prd_msg(msg); if (rc) { pr_warn("write: opal_prd_msg returned %d\n", rc); size = -EIO; } kfree(msg); return size; } static int opal_prd_release(struct inode *inode, struct file *file) { struct opal_prd_msg msg; msg.header.size = cpu_to_be16(sizeof(msg)); msg.header.type = OPAL_PRD_MSG_TYPE_FINI; opal_prd_msg(&msg); atomic_xchg(&prd_usage, 0); return 0; } static long opal_prd_ioctl(struct file *file, unsigned int cmd, unsigned long param) { struct opal_prd_info info; struct opal_prd_scom scom; int rc = 0; switch (cmd) { case OPAL_PRD_GET_INFO: memset(&info, 0, sizeof(info)); info.version = OPAL_PRD_KERNEL_VERSION; rc = copy_to_user((void __user *)param, &info, sizeof(info)); if (rc) return -EFAULT; break; case OPAL_PRD_SCOM_READ: rc = copy_from_user(&scom, (void __user *)param, sizeof(scom)); if (rc) return -EFAULT; scom.rc = opal_xscom_read(scom.chip, scom.addr, (__be64 *)&scom.data); scom.data = be64_to_cpu(scom.data); pr_devel("ioctl SCOM_READ: chip %llx addr %016llx data %016llx rc %lld\n", scom.chip, scom.addr, scom.data, scom.rc); rc = copy_to_user((void __user *)param, &scom, sizeof(scom)); if (rc) return -EFAULT; break; case OPAL_PRD_SCOM_WRITE: rc = copy_from_user(&scom, (void __user *)param, sizeof(scom)); if (rc) return -EFAULT; scom.rc = opal_xscom_write(scom.chip, scom.addr, scom.data); pr_devel("ioctl SCOM_WRITE: chip %llx addr %016llx data %016llx rc %lld\n", scom.chip, scom.addr, scom.data, scom.rc); rc = copy_to_user((void __user *)param, &scom, sizeof(scom)); if (rc) return -EFAULT; break; default: rc = -EINVAL; } return rc; } static const struct file_operations opal_prd_fops = { .open = opal_prd_open, .mmap = opal_prd_mmap, .poll = opal_prd_poll, .read = opal_prd_read, .write = opal_prd_write, .unlocked_ioctl = opal_prd_ioctl, .release = opal_prd_release, .owner = THIS_MODULE, }; static struct miscdevice opal_prd_dev = { .minor = MISC_DYNAMIC_MINOR, .name = "opal-prd", .fops = &opal_prd_fops, }; /* opal interface */ static int opal_prd_msg_notifier(struct notifier_block *nb, unsigned long msg_type, void *_msg) { struct opal_prd_msg_queue_item *item; struct opal_prd_msg_header *hdr; struct opal_msg *msg = _msg; int msg_size, item_size; unsigned long flags; if (msg_type != OPAL_MSG_PRD && msg_type != OPAL_MSG_PRD2) return 0; /* Calculate total size of the message and item we need to store. The * 'size' field in the header includes the header itself. */ hdr = (void *)msg->params; msg_size = be16_to_cpu(hdr->size); item_size = msg_size + sizeof(*item) - sizeof(item->msg); item = kzalloc(item_size, GFP_ATOMIC); if (!item) return -ENOMEM; memcpy(&item->msg.data, msg->params, msg_size); spin_lock_irqsave(&opal_prd_msg_queue_lock, flags); list_add_tail(&item->list, &opal_prd_msg_queue); spin_unlock_irqrestore(&opal_prd_msg_queue_lock, flags); wake_up_interruptible(&opal_prd_msg_wait); return 0; } static struct notifier_block opal_prd_event_nb = { .notifier_call = opal_prd_msg_notifier, .next = NULL, .priority = 0, }; static struct notifier_block opal_prd_event_nb2 = { .notifier_call = opal_prd_msg_notifier, .next = NULL, .priority = 0, }; static int opal_prd_probe(struct platform_device *pdev) { int rc; if (!pdev || !pdev->dev.of_node) return -ENODEV; /* We should only have one prd driver instance per machine; ensure * that we only get a valid probe on a single OF node. */ if (prd_node) return -EBUSY; prd_node = pdev->dev.of_node; rc = opal_message_notifier_register(OPAL_MSG_PRD, &opal_prd_event_nb); if (rc) { pr_err("Couldn't register event notifier\n"); return rc; } rc = opal_message_notifier_register(OPAL_MSG_PRD2, &opal_prd_event_nb2); if (rc) { pr_err("Couldn't register PRD2 event notifier\n"); opal_message_notifier_unregister(OPAL_MSG_PRD, &opal_prd_event_nb); return rc; } rc = misc_register(&opal_prd_dev); if (rc) { pr_err("failed to register miscdev\n"); opal_message_notifier_unregister(OPAL_MSG_PRD, &opal_prd_event_nb); opal_message_notifier_unregister(OPAL_MSG_PRD2, &opal_prd_event_nb2); return rc; } return 0; } static void opal_prd_remove(struct platform_device *pdev) { misc_deregister(&opal_prd_dev); opal_message_notifier_unregister(OPAL_MSG_PRD, &opal_prd_event_nb); opal_message_notifier_unregister(OPAL_MSG_PRD2, &opal_prd_event_nb2); } static const struct of_device_id opal_prd_match[] = { { .compatible = "ibm,opal-prd" }, { }, }; static struct platform_driver opal_prd_driver = { .driver = { .name = "opal-prd", .of_match_table = opal_prd_match, }, .probe = opal_prd_probe, .remove_new = opal_prd_remove, }; module_platform_driver(opal_prd_driver); MODULE_DEVICE_TABLE(of, opal_prd_match); MODULE_DESCRIPTION("PowerNV OPAL runtime diagnostic driver"); MODULE_LICENSE("GPL");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1