cregit-Linux how code gets into the kernel

Release 4.7 drivers/hid/hidraw.c

Directory: drivers/hid
/*
 * HID raw devices, giving access to raw HID events.
 *
 * In comparison to hiddev, this device does not process the
 * hid events at all (no parsing, no lookups). This lets applications
 * to work on raw hid events as they want to, and avoids a need to
 * use a transport-specific userspace libhid/libusb libraries.
 *
 *  Copyright (c) 2007-2014 Jiri Kosina
 */

/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/fs.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/poll.h>
#include <linux/device.h>
#include <linux/major.h>
#include <linux/slab.h>
#include <linux/hid.h>
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/string.h>

#include <linux/hidraw.h>


static int hidraw_major;

static struct cdev hidraw_cdev;

static struct class *hidraw_class;

static struct hidraw *hidraw_table[HIDRAW_MAX_DEVICES];
static DEFINE_MUTEX(minors_lock);


static ssize_t hidraw_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos) { struct hidraw_list *list = file->private_data; int ret = 0, len; DECLARE_WAITQUEUE(wait, current); mutex_lock(&list->read_mutex); while (ret == 0) { if (list->head == list->tail) { add_wait_queue(&list->hidraw->wait, &wait); set_current_state(TASK_INTERRUPTIBLE); while (list->head == list->tail) { if (signal_pending(current)) { ret = -ERESTARTSYS; break; } if (!list->hidraw->exist) { ret = -EIO; break; } if (file->f_flags & O_NONBLOCK) { ret = -EAGAIN; break; } /* allow O_NONBLOCK to work well from other threads */ mutex_unlock(&list->read_mutex); schedule(); mutex_lock(&list->read_mutex); set_current_state(TASK_INTERRUPTIBLE); } set_current_state(TASK_RUNNING); remove_wait_queue(&list->hidraw->wait, &wait); } if (ret) goto out; len = list->buffer[list->tail].len > count ? count : list->buffer[list->tail].len; if (list->buffer[list->tail].value) { if (copy_to_user(buffer, list->buffer[list->tail].value, len)) { ret = -EFAULT; goto out; } ret = len; } kfree(list->buffer[list->tail].value); list->buffer[list->tail].value = NULL; list->tail = (list->tail + 1) & (HIDRAW_BUFFER_SIZE - 1); } out: mutex_unlock(&list->read_mutex); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
jiri kosinajiri kosina30791.10%350.00%
founder fangfounder fang164.75%116.67%
matthieu castetmatthieu castet133.86%116.67%
alan ottalan ott10.30%116.67%
Total337100.00%6100.00%

/* * The first byte of the report buffer is expected to be a report number. * * This function is to be called with the minors_lock mutex held. */
static ssize_t hidraw_send_report(struct file *file, const char __user *buffer, size_t count, unsigned char report_type) { unsigned int minor = iminor(file_inode(file)); struct hid_device *dev; __u8 *buf; int ret = 0; if (!hidraw_table[minor] || !hidraw_table[minor]->exist) { ret = -ENODEV; goto out; } dev = hidraw_table[minor]->hid; if (count > HID_MAX_BUFFER_SIZE) { hid_warn(dev, "pid %d passed too large report\n", task_pid_nr(current)); ret = -EINVAL; goto out; } if (count < 2) { hid_warn(dev, "pid %d passed too short report\n", task_pid_nr(current)); ret = -EINVAL; goto out; } buf = memdup_user(buffer, count); if (IS_ERR(buf)) { ret = PTR_ERR(buf); goto out; } if ((report_type == HID_OUTPUT_REPORT) && !(dev->quirks & HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP)) { ret = hid_hw_output_report(dev, buf, count); /* * compatibility with old implementation of USB-HID and I2C-HID: * if the device does not support receiving output reports, * on an interrupt endpoint, fallback to SET_REPORT HID command. */ if (ret != -ENOSYS) goto out_free; } ret = hid_hw_raw_request(dev, buf[0], buf, count, report_type, HID_REQ_SET_REPORT); out_free: kfree(buf); out: return ret; }

Contributors

PersonTokensPropCommitsCommitProp
jiri kosinajiri kosina13656.20%430.77%
benjamin tissoiresbenjamin tissoires4619.01%215.38%
antonio ospiteantonio ospite187.44%17.69%
alan ottalan ott93.72%17.69%
joe perchesjoe perches83.31%17.69%
manoj chourasiamanoj chourasia83.31%17.69%
dmitry torokhovdmitry torokhov83.31%17.69%
pavel emelianovpavel emelianov62.48%17.69%
al viroal viro31.24%17.69%
Total242100.00%13100.00%


static ssize_t hidraw_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos) { ssize_t ret; mutex_lock(&minors_lock); ret = hidraw_send_report(file, buffer, count, HID_OUTPUT_REPORT); mutex_unlock(&minors_lock); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
alan ottalan ott4581.82%133.33%
jiri kosinajiri kosina1018.18%266.67%
Total55100.00%3100.00%

/* * This function performs a Get_Report transfer over the control endpoint * per section 7.2.1 of the HID specification, version 1.1. The first byte * of buffer is the report number to request, or 0x0 if the defice does not * use numbered reports. The report_type parameter can be HID_FEATURE_REPORT * or HID_INPUT_REPORT. * * This function is to be called with the minors_lock mutex held. */
static ssize_t hidraw_get_report(struct file *file, char __user *buffer, size_t count, unsigned char report_type) { unsigned int minor = iminor(file_inode(file)); struct hid_device *dev; __u8 *buf; int ret = 0, len; unsigned char report_number; dev = hidraw_table[minor]->hid; if (!dev->ll_driver->raw_request) { ret = -ENODEV; goto out; } if (count > HID_MAX_BUFFER_SIZE) { printk(KERN_WARNING "hidraw: pid %d passed too large report\n", task_pid_nr(current)); ret = -EINVAL; goto out; } if (count < 2) { printk(KERN_WARNING "hidraw: pid %d passed too short report\n", task_pid_nr(current)); ret = -EINVAL; goto out; } buf = kmalloc(count * sizeof(__u8), GFP_KERNEL); if (!buf) { ret = -ENOMEM; goto out; } /* * Read the first byte from the user. This is the report number, * which is passed to hid_hw_raw_request(). */ if (copy_from_user(&report_number, buffer, 1)) { ret = -EFAULT; goto out_free; } ret = hid_hw_raw_request(dev, report_number, buf, count, report_type, HID_REQ_GET_REPORT); if (ret < 0) goto out_free; len = (ret < count) ? ret : count; if (copy_to_user(buffer, buf, len)) { ret = -EFAULT; goto out_free; } ret = len; out_free: kfree(buf); out: return ret; }

Contributors

PersonTokensPropCommitsCommitProp
alan ottalan ott25496.21%133.33%
benjamin tissoiresbenjamin tissoires72.65%133.33%
al viroal viro31.14%133.33%
Total264100.00%3100.00%


static unsigned int hidraw_poll(struct file *file, poll_table *wait) { struct hidraw_list *list = file->private_data; poll_wait(file, &list->hidraw->wait, wait); if (list->head != list->tail) return POLLIN | POLLRDNORM; if (!list->hidraw->exist) return POLLERR | POLLHUP; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
jiri kosinajiri kosina71100.00%1100.00%
Total71100.00%1100.00%


static int hidraw_open(struct inode *inode, struct file *file) { unsigned int minor = iminor(inode); struct hidraw *dev; struct hidraw_list *list; unsigned long flags; int err = 0; if (!(list = kzalloc(sizeof(struct hidraw_list), GFP_KERNEL))) { err = -ENOMEM; goto out; } mutex_lock(&minors_lock); if (!hidraw_table[minor] || !hidraw_table[minor]->exist) { err = -ENODEV; goto out_unlock; } dev = hidraw_table[minor]; if (!dev->open++) { err = hid_hw_power(dev->hid, PM_HINT_FULLON); if (err < 0) { dev->open--; goto out_unlock; } err = hid_hw_open(dev->hid); if (err < 0) { hid_hw_power(dev->hid, PM_HINT_NORMAL); dev->open--; goto out_unlock; } } list->hidraw = hidraw_table[minor]; mutex_init(&list->read_mutex); spin_lock_irqsave(&hidraw_table[minor]->list_lock, flags); list_add_tail(&list->node, &hidraw_table[minor]->list); spin_unlock_irqrestore(&hidraw_table[minor]->list_lock, flags); file->private_data = list; out_unlock: mutex_unlock(&minors_lock); out: if (err < 0) kfree(list); return err; }

Contributors

PersonTokensPropCommitsCommitProp
jiri kosinajiri kosina12245.02%112.50%
yonghua zhengyonghua zheng7226.57%112.50%
oliver neukumoliver neukum4817.71%225.00%
amit nagalamit nagal186.64%225.00%
manoj chourasiamanoj chourasia82.95%112.50%
dmitry torokhovdmitry torokhov31.11%112.50%
Total271100.00%8100.00%


static int hidraw_fasync(int fd, struct file *file, int on) { struct hidraw_list *list = file->private_data; return fasync_helper(fd, file, on, &list->fasync); }

Contributors

PersonTokensPropCommitsCommitProp
andrew dugganandrew duggan41100.00%1100.00%
Total41100.00%1100.00%


static void drop_ref(struct hidraw *hidraw, int exists_bit) { if (exists_bit) { hidraw->exist = 0; if (hidraw->open) { hid_hw_close(hidraw->hid); wake_up_interruptible(&hidraw->wait); } device_destroy(hidraw_class, MKDEV(hidraw_major, hidraw->minor)); } else { --hidraw->open; } if (!hidraw->open) { if (!hidraw->exist) { hidraw_table[hidraw->minor] = NULL; kfree(hidraw); } else { /* close device for last reader */ hid_hw_power(hidraw->hid, PM_HINT_NORMAL); hid_hw_close(hidraw->hid); } } }

Contributors

PersonTokensPropCommitsCommitProp
manoj chourasiamanoj chourasia10988.62%266.67%
fernando luis vazquez caofernando luis vazquez cao1411.38%133.33%
Total123100.00%3100.00%


static int hidraw_release(struct inode * inode, struct file * file) { unsigned int minor = iminor(inode); struct hidraw_list *list = file->private_data; unsigned long flags; mutex_lock(&minors_lock); spin_lock_irqsave(&hidraw_table[minor]->list_lock, flags); list_del(&list->node); spin_unlock_irqrestore(&hidraw_table[minor]->list_lock, flags); kfree(list); drop_ref(hidraw_table[minor], 0); mutex_unlock(&minors_lock); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
jiri kosinajiri kosina6462.75%342.86%
yonghua zhengyonghua zheng3029.41%114.29%
manoj chourasiamanoj chourasia65.88%114.29%
jiri slabyjiri slaby10.98%114.29%
ratan nalumasuratan nalumasu10.98%114.29%
Total102100.00%7100.00%


static long hidraw_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct inode *inode = file_inode(file); unsigned int minor = iminor(inode); long ret = 0; struct hidraw *dev; void __user *user_arg = (void __user*) arg; mutex_lock(&minors_lock); dev = hidraw_table[minor]; if (!dev) { ret = -ENODEV; goto out; } switch (cmd) { case HIDIOCGRDESCSIZE: if (put_user(dev->hid->rsize, (int __user *)arg)) ret = -EFAULT; break; case HIDIOCGRDESC: { __u32 len; if (get_user(len, (int __user *)arg)) ret = -EFAULT; else if (len > HID_MAX_DESCRIPTOR_SIZE - 1) ret = -EINVAL; else if (copy_to_user(user_arg + offsetof( struct hidraw_report_descriptor, value[0]), dev->hid->rdesc, min(dev->hid->rsize, len))) ret = -EFAULT; break; } case HIDIOCGRAWINFO: { struct hidraw_devinfo dinfo; dinfo.bustype = dev->hid->bus; dinfo.vendor = dev->hid->vendor; dinfo.product = dev->hid->product; if (copy_to_user(user_arg, &dinfo, sizeof(dinfo))) ret = -EFAULT; break; } default: { struct hid_device *hid = dev->hid; if (_IOC_TYPE(cmd) != 'H') { ret = -EINVAL; break; } if (_IOC_NR(cmd) == _IOC_NR(HIDIOCSFEATURE(0))) { int len = _IOC_SIZE(cmd); ret = hidraw_send_report(file, user_arg, len, HID_FEATURE_REPORT); break; } if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGFEATURE(0))) { int len = _IOC_SIZE(cmd); ret = hidraw_get_report(file, user_arg, len, HID_FEATURE_REPORT); break; } /* Begin Read-only ioctls. */ if (_IOC_DIR(cmd) != _IOC_READ) { ret = -EINVAL; break; } if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGRAWNAME(0))) { int len = strlen(hid->name) + 1; if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd); ret = copy_to_user(user_arg, hid->name, len) ? -EFAULT : len; break; } if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGRAWPHYS(0))) { int len = strlen(hid->phys) + 1; if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd); ret = copy_to_user(user_arg, hid->phys, len) ? -EFAULT : len; break; } } ret = -ENOTTY; } out: mutex_unlock(&minors_lock); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
jiri kosinajiri kosina36568.48%436.36%
alan ottalan ott9016.89%19.09%
alan coxalan cox397.32%19.09%
antonio ospiteantonio ospite173.19%19.09%
dan carpenterdan carpenter142.63%19.09%
daniel mackdaniel mack40.75%19.09%
al viroal viro30.56%19.09%
jiri slabyjiri slaby10.19%19.09%
Total533100.00%11100.00%

static const struct file_operations hidraw_ops = { .owner = THIS_MODULE, .read = hidraw_read, .write = hidraw_write, .poll = hidraw_poll, .open = hidraw_open, .release = hidraw_release, .unlocked_ioctl = hidraw_ioctl, .fasync = hidraw_fasync, #ifdef CONFIG_COMPAT .compat_ioctl = hidraw_ioctl, #endif .llseek = noop_llseek, };
int hidraw_report_event(struct hid_device *hid, u8 *data, int len) { struct hidraw *dev = hid->hidraw; struct hidraw_list *list; int ret = 0; unsigned long flags; spin_lock_irqsave(&dev->list_lock, flags); list_for_each_entry(list, &dev->list, node) { int new_head = (list->head + 1) & (HIDRAW_BUFFER_SIZE - 1); if (new_head == list->tail) continue; if (!(list->buffer[list->head].value = kmemdup(data, len, GFP_ATOMIC))) { ret = -ENOMEM; break; } list->buffer[list->head].len = len; list->head = new_head; kill_fasync(&list->fasync, SIGIO, POLL_IN); } spin_unlock_irqrestore(&dev->list_lock, flags); wake_up_interruptible(&dev->wait); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
jiri kosinajiri kosina12070.18%250.00%
matthieu castetmatthieu castet2715.79%125.00%
yonghua zhengyonghua zheng2414.04%125.00%
Total171100.00%4100.00%

EXPORT_SYMBOL_GPL(hidraw_report_event);
int hidraw_connect(struct hid_device *hid) { int minor, result; struct hidraw *dev; /* we accept any HID device, all applications */ dev = kzalloc(sizeof(struct hidraw), GFP_KERNEL); if (!dev) return -ENOMEM; result = -EINVAL; mutex_lock(&minors_lock); for (minor = 0; minor < HIDRAW_MAX_DEVICES; minor++) { if (hidraw_table[minor]) continue; hidraw_table[minor] = dev; result = 0; break; } if (result) { mutex_unlock(&minors_lock); kfree(dev); goto out; } dev->dev = device_create(hidraw_class, &hid->dev, MKDEV(hidraw_major, minor), NULL, "%s%d", "hidraw", minor); if (IS_ERR(dev->dev)) { hidraw_table[minor] = NULL; mutex_unlock(&minors_lock); result = PTR_ERR(dev->dev); kfree(dev); goto out; } init_waitqueue_head(&dev->wait); spin_lock_init(&dev->list_lock); INIT_LIST_HEAD(&dev->list); dev->hid = hid; dev->minor = minor; dev->exist = 1; hid->hidraw = dev; mutex_unlock(&minors_lock); out: return result; }

Contributors

PersonTokensPropCommitsCommitProp
jiri kosinajiri kosina19079.83%333.33%
mariusz kozlowskimariusz kozlowski239.66%111.11%
yonghua zhengyonghua zheng145.88%222.22%
oliver neukumoliver neukum83.36%111.11%
greg kroah-hartmangreg kroah-hartman31.26%222.22%
Total238100.00%9100.00%

EXPORT_SYMBOL_GPL(hidraw_connect);
void hidraw_disconnect(struct hid_device *hid) { struct hidraw *hidraw = hid->hidraw; mutex_lock(&minors_lock); drop_ref(hidraw, 1); mutex_unlock(&minors_lock); }

Contributors

PersonTokensPropCommitsCommitProp
jiri kosinajiri kosina3284.21%250.00%
manoj chourasiamanoj chourasia37.89%125.00%
james hoganjames hogan37.89%125.00%
Total38100.00%4100.00%

EXPORT_SYMBOL_GPL(hidraw_disconnect);
int __init hidraw_init(void) { int result; dev_t dev_id; result = alloc_chrdev_region(&dev_id, HIDRAW_FIRST_MINOR, HIDRAW_MAX_DEVICES, "hidraw"); if (result < 0) { pr_warn("can't get major number\n"); goto out; } hidraw_major = MAJOR(dev_id); hidraw_class = class_create(THIS_MODULE, "hidraw"); if (IS_ERR(hidraw_class)) { result = PTR_ERR(hidraw_class); goto error_cdev; } cdev_init(&hidraw_cdev, &hidraw_ops); result = cdev_add(&hidraw_cdev, dev_id, HIDRAW_MAX_DEVICES); if (result < 0) goto error_class; printk(KERN_INFO "hidraw: raw HID events driver (C) Jiri Kosina\n"); out: return result; error_class: class_destroy(hidraw_class); error_cdev: unregister_chrdev_region(dev_id, HIDRAW_MAX_DEVICES); goto out; }

Contributors

PersonTokensPropCommitsCommitProp
jiri kosinajiri kosina9971.22%240.00%
alexey khoroshilovalexey khoroshilov3122.30%120.00%
dan carpenterdan carpenter75.04%120.00%
joe perchesjoe perches21.44%120.00%
Total139100.00%5100.00%


void hidraw_exit(void) { dev_t dev_id = MKDEV(hidraw_major, 0); cdev_del(&hidraw_cdev); class_destroy(hidraw_class); unregister_chrdev_region(dev_id, HIDRAW_MAX_DEVICES); }

Contributors

PersonTokensPropCommitsCommitProp
jiri kosinajiri kosina35100.00%1100.00%
Total35100.00%1100.00%


Overall Contributors

PersonTokensPropCommitsCommitProp
jiri kosinajiri kosina167759.38%1324.53%
alan ottalan ott40914.48%35.66%
yonghua zhengyonghua zheng1404.96%23.77%
manoj chourasiamanoj chourasia1344.75%23.77%
oliver neukumoliver neukum572.02%23.77%
benjamin tissoiresbenjamin tissoires531.88%35.66%
andrew dugganandrew duggan461.63%11.89%
matthieu castetmatthieu castet401.42%11.89%
alan coxalan cox401.42%11.89%
antonio ospiteantonio ospite351.24%23.77%
alexey khoroshilovalexey khoroshilov311.10%11.89%
mariusz kozlowskimariusz kozlowski230.81%11.89%
dan carpenterdan carpenter210.74%23.77%
amit nagalamit nagal180.64%23.77%
joe perchesjoe perches170.60%11.89%
founder fangfounder fang160.57%11.89%
dmitry torokhovdmitry torokhov140.50%23.77%
fernando luis vazquez caofernando luis vazquez cao140.50%11.89%
al viroal viro90.32%11.89%
pavel emelianovpavel emelianov60.21%11.89%
arnd bergmannarnd bergmann50.18%11.89%
daniel mackdaniel mack40.14%11.89%
greg kroah-hartmangreg kroah-hartman30.11%23.77%
alexey dobriyanalexey dobriyan30.11%11.89%
tejun heotejun heo30.11%11.89%
james hoganjames hogan30.11%11.89%
jiri slabyjiri slaby20.07%23.77%
ratan nalumasuratan nalumasu10.04%11.89%
Total2824100.00%53100.00%
Directory: drivers/hid
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
{% endraw %}