Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * LIRC base driver
0004  *
0005  * by Artur Lipowski <alipowski@interia.pl>
0006  */
0007 
0008 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0009 
0010 #include <linux/module.h>
0011 #include <linux/mutex.h>
0012 #include <linux/device.h>
0013 #include <linux/file.h>
0014 #include <linux/idr.h>
0015 #include <linux/poll.h>
0016 #include <linux/sched.h>
0017 #include <linux/wait.h>
0018 
0019 #include "rc-core-priv.h"
0020 #include <uapi/linux/lirc.h>
0021 
0022 #define LIRCBUF_SIZE    1024
0023 
0024 static dev_t lirc_base_dev;
0025 
0026 /* Used to keep track of allocated lirc devices */
0027 static DEFINE_IDA(lirc_ida);
0028 
0029 /* Only used for sysfs but defined to void otherwise */
0030 static struct class *lirc_class;
0031 
0032 /**
0033  * lirc_raw_event() - Send raw IR data to lirc to be relayed to userspace
0034  *
0035  * @dev:    the struct rc_dev descriptor of the device
0036  * @ev:     the struct ir_raw_event descriptor of the pulse/space
0037  */
0038 void lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev)
0039 {
0040     unsigned long flags;
0041     struct lirc_fh *fh;
0042     int sample;
0043 
0044     /* Receiver overflow, data missing */
0045     if (ev.overflow) {
0046         /*
0047          * Send lirc overflow message. This message is unknown to
0048          * lircd, but it will interpret this as a long space as
0049          * long as the value is set to high value. This resets its
0050          * decoder state.
0051          */
0052         sample = LIRC_OVERFLOW(LIRC_VALUE_MASK);
0053         dev_dbg(&dev->dev, "delivering overflow to lirc_dev\n");
0054 
0055     /* Carrier reports */
0056     } else if (ev.carrier_report) {
0057         sample = LIRC_FREQUENCY(ev.carrier);
0058         dev_dbg(&dev->dev, "carrier report (freq: %d)\n", sample);
0059 
0060     /* Packet end */
0061     } else if (ev.timeout) {
0062         dev->gap_start = ktime_get();
0063 
0064         sample = LIRC_TIMEOUT(ev.duration);
0065         dev_dbg(&dev->dev, "timeout report (duration: %d)\n", sample);
0066 
0067     /* Normal sample */
0068     } else {
0069         if (dev->gap_start) {
0070             u64 duration = ktime_us_delta(ktime_get(),
0071                               dev->gap_start);
0072 
0073             /* Cap by LIRC_VALUE_MASK */
0074             duration = min_t(u64, duration, LIRC_VALUE_MASK);
0075 
0076             spin_lock_irqsave(&dev->lirc_fh_lock, flags);
0077             list_for_each_entry(fh, &dev->lirc_fh, list)
0078                 kfifo_put(&fh->rawir, LIRC_SPACE(duration));
0079             spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
0080             dev->gap_start = 0;
0081         }
0082 
0083         sample = ev.pulse ? LIRC_PULSE(ev.duration) :
0084                     LIRC_SPACE(ev.duration);
0085         dev_dbg(&dev->dev, "delivering %uus %s to lirc_dev\n",
0086             ev.duration, TO_STR(ev.pulse));
0087     }
0088 
0089     /*
0090      * bpf does not care about the gap generated above; that exists
0091      * for backwards compatibility
0092      */
0093     lirc_bpf_run(dev, sample);
0094 
0095     spin_lock_irqsave(&dev->lirc_fh_lock, flags);
0096     list_for_each_entry(fh, &dev->lirc_fh, list) {
0097         if (kfifo_put(&fh->rawir, sample))
0098             wake_up_poll(&fh->wait_poll, EPOLLIN | EPOLLRDNORM);
0099     }
0100     spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
0101 }
0102 
0103 /**
0104  * lirc_scancode_event() - Send scancode data to lirc to be relayed to
0105  *      userspace. This can be called in atomic context.
0106  * @dev:    the struct rc_dev descriptor of the device
0107  * @lsc:    the struct lirc_scancode describing the decoded scancode
0108  */
0109 void lirc_scancode_event(struct rc_dev *dev, struct lirc_scancode *lsc)
0110 {
0111     unsigned long flags;
0112     struct lirc_fh *fh;
0113 
0114     lsc->timestamp = ktime_get_ns();
0115 
0116     spin_lock_irqsave(&dev->lirc_fh_lock, flags);
0117     list_for_each_entry(fh, &dev->lirc_fh, list) {
0118         if (kfifo_put(&fh->scancodes, *lsc))
0119             wake_up_poll(&fh->wait_poll, EPOLLIN | EPOLLRDNORM);
0120     }
0121     spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
0122 }
0123 EXPORT_SYMBOL_GPL(lirc_scancode_event);
0124 
0125 static int lirc_open(struct inode *inode, struct file *file)
0126 {
0127     struct rc_dev *dev = container_of(inode->i_cdev, struct rc_dev,
0128                       lirc_cdev);
0129     struct lirc_fh *fh = kzalloc(sizeof(*fh), GFP_KERNEL);
0130     unsigned long flags;
0131     int retval;
0132 
0133     if (!fh)
0134         return -ENOMEM;
0135 
0136     get_device(&dev->dev);
0137 
0138     if (!dev->registered) {
0139         retval = -ENODEV;
0140         goto out_fh;
0141     }
0142 
0143     if (dev->driver_type == RC_DRIVER_IR_RAW) {
0144         if (kfifo_alloc(&fh->rawir, MAX_IR_EVENT_SIZE, GFP_KERNEL)) {
0145             retval = -ENOMEM;
0146             goto out_fh;
0147         }
0148     }
0149 
0150     if (dev->driver_type != RC_DRIVER_IR_RAW_TX) {
0151         if (kfifo_alloc(&fh->scancodes, 32, GFP_KERNEL)) {
0152             retval = -ENOMEM;
0153             goto out_rawir;
0154         }
0155     }
0156 
0157     fh->send_mode = LIRC_MODE_PULSE;
0158     fh->rc = dev;
0159 
0160     if (dev->driver_type == RC_DRIVER_SCANCODE)
0161         fh->rec_mode = LIRC_MODE_SCANCODE;
0162     else
0163         fh->rec_mode = LIRC_MODE_MODE2;
0164 
0165     retval = rc_open(dev);
0166     if (retval)
0167         goto out_kfifo;
0168 
0169     init_waitqueue_head(&fh->wait_poll);
0170 
0171     file->private_data = fh;
0172     spin_lock_irqsave(&dev->lirc_fh_lock, flags);
0173     list_add(&fh->list, &dev->lirc_fh);
0174     spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
0175 
0176     stream_open(inode, file);
0177 
0178     return 0;
0179 out_kfifo:
0180     if (dev->driver_type != RC_DRIVER_IR_RAW_TX)
0181         kfifo_free(&fh->scancodes);
0182 out_rawir:
0183     if (dev->driver_type == RC_DRIVER_IR_RAW)
0184         kfifo_free(&fh->rawir);
0185 out_fh:
0186     kfree(fh);
0187     put_device(&dev->dev);
0188 
0189     return retval;
0190 }
0191 
0192 static int lirc_close(struct inode *inode, struct file *file)
0193 {
0194     struct lirc_fh *fh = file->private_data;
0195     struct rc_dev *dev = fh->rc;
0196     unsigned long flags;
0197 
0198     spin_lock_irqsave(&dev->lirc_fh_lock, flags);
0199     list_del(&fh->list);
0200     spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
0201 
0202     if (dev->driver_type == RC_DRIVER_IR_RAW)
0203         kfifo_free(&fh->rawir);
0204     if (dev->driver_type != RC_DRIVER_IR_RAW_TX)
0205         kfifo_free(&fh->scancodes);
0206     kfree(fh);
0207 
0208     rc_close(dev);
0209     put_device(&dev->dev);
0210 
0211     return 0;
0212 }
0213 
0214 static ssize_t lirc_transmit(struct file *file, const char __user *buf,
0215                  size_t n, loff_t *ppos)
0216 {
0217     struct lirc_fh *fh = file->private_data;
0218     struct rc_dev *dev = fh->rc;
0219     unsigned int *txbuf;
0220     struct ir_raw_event *raw = NULL;
0221     ssize_t ret;
0222     size_t count;
0223     ktime_t start;
0224     s64 towait;
0225     unsigned int duration = 0; /* signal duration in us */
0226     int i;
0227 
0228     ret = mutex_lock_interruptible(&dev->lock);
0229     if (ret)
0230         return ret;
0231 
0232     if (!dev->registered) {
0233         ret = -ENODEV;
0234         goto out_unlock;
0235     }
0236 
0237     if (!dev->tx_ir) {
0238         ret = -EINVAL;
0239         goto out_unlock;
0240     }
0241 
0242     if (fh->send_mode == LIRC_MODE_SCANCODE) {
0243         struct lirc_scancode scan;
0244 
0245         if (n != sizeof(scan)) {
0246             ret = -EINVAL;
0247             goto out_unlock;
0248         }
0249 
0250         if (copy_from_user(&scan, buf, sizeof(scan))) {
0251             ret = -EFAULT;
0252             goto out_unlock;
0253         }
0254 
0255         if (scan.flags || scan.keycode || scan.timestamp ||
0256             scan.rc_proto > RC_PROTO_MAX) {
0257             ret = -EINVAL;
0258             goto out_unlock;
0259         }
0260 
0261         /* We only have encoders for 32-bit protocols. */
0262         if (scan.scancode > U32_MAX ||
0263             !rc_validate_scancode(scan.rc_proto, scan.scancode)) {
0264             ret = -EINVAL;
0265             goto out_unlock;
0266         }
0267 
0268         raw = kmalloc_array(LIRCBUF_SIZE, sizeof(*raw), GFP_KERNEL);
0269         if (!raw) {
0270             ret = -ENOMEM;
0271             goto out_unlock;
0272         }
0273 
0274         ret = ir_raw_encode_scancode(scan.rc_proto, scan.scancode,
0275                          raw, LIRCBUF_SIZE);
0276         if (ret < 0)
0277             goto out_kfree_raw;
0278 
0279         count = ret;
0280 
0281         txbuf = kmalloc_array(count, sizeof(unsigned int), GFP_KERNEL);
0282         if (!txbuf) {
0283             ret = -ENOMEM;
0284             goto out_kfree_raw;
0285         }
0286 
0287         for (i = 0; i < count; i++)
0288             txbuf[i] = raw[i].duration;
0289 
0290         if (dev->s_tx_carrier) {
0291             int carrier = ir_raw_encode_carrier(scan.rc_proto);
0292 
0293             if (carrier > 0)
0294                 dev->s_tx_carrier(dev, carrier);
0295         }
0296     } else {
0297         if (n < sizeof(unsigned int) || n % sizeof(unsigned int)) {
0298             ret = -EINVAL;
0299             goto out_unlock;
0300         }
0301 
0302         count = n / sizeof(unsigned int);
0303         if (count > LIRCBUF_SIZE || count % 2 == 0) {
0304             ret = -EINVAL;
0305             goto out_unlock;
0306         }
0307 
0308         txbuf = memdup_user(buf, n);
0309         if (IS_ERR(txbuf)) {
0310             ret = PTR_ERR(txbuf);
0311             goto out_unlock;
0312         }
0313     }
0314 
0315     for (i = 0; i < count; i++) {
0316         if (txbuf[i] > IR_MAX_DURATION - duration || !txbuf[i]) {
0317             ret = -EINVAL;
0318             goto out_kfree;
0319         }
0320 
0321         duration += txbuf[i];
0322     }
0323 
0324     start = ktime_get();
0325 
0326     ret = dev->tx_ir(dev, txbuf, count);
0327     if (ret < 0)
0328         goto out_kfree;
0329 
0330     kfree(txbuf);
0331     kfree(raw);
0332     mutex_unlock(&dev->lock);
0333 
0334     /*
0335      * The lircd gap calculation expects the write function to
0336      * wait for the actual IR signal to be transmitted before
0337      * returning.
0338      */
0339     towait = ktime_us_delta(ktime_add_us(start, duration),
0340                 ktime_get());
0341     if (towait > 0) {
0342         set_current_state(TASK_INTERRUPTIBLE);
0343         schedule_timeout(usecs_to_jiffies(towait));
0344     }
0345 
0346     return n;
0347 out_kfree:
0348     kfree(txbuf);
0349 out_kfree_raw:
0350     kfree(raw);
0351 out_unlock:
0352     mutex_unlock(&dev->lock);
0353     return ret;
0354 }
0355 
0356 static long lirc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
0357 {
0358     struct lirc_fh *fh = file->private_data;
0359     struct rc_dev *dev = fh->rc;
0360     u32 __user *argp = (u32 __user *)(arg);
0361     u32 val = 0;
0362     int ret;
0363 
0364     if (_IOC_DIR(cmd) & _IOC_WRITE) {
0365         ret = get_user(val, argp);
0366         if (ret)
0367             return ret;
0368     }
0369 
0370     ret = mutex_lock_interruptible(&dev->lock);
0371     if (ret)
0372         return ret;
0373 
0374     if (!dev->registered) {
0375         ret = -ENODEV;
0376         goto out;
0377     }
0378 
0379     switch (cmd) {
0380     case LIRC_GET_FEATURES:
0381         if (dev->driver_type == RC_DRIVER_SCANCODE)
0382             val |= LIRC_CAN_REC_SCANCODE;
0383 
0384         if (dev->driver_type == RC_DRIVER_IR_RAW) {
0385             val |= LIRC_CAN_REC_MODE2;
0386             if (dev->rx_resolution)
0387                 val |= LIRC_CAN_GET_REC_RESOLUTION;
0388         }
0389 
0390         if (dev->tx_ir) {
0391             val |= LIRC_CAN_SEND_PULSE;
0392             if (dev->s_tx_mask)
0393                 val |= LIRC_CAN_SET_TRANSMITTER_MASK;
0394             if (dev->s_tx_carrier)
0395                 val |= LIRC_CAN_SET_SEND_CARRIER;
0396             if (dev->s_tx_duty_cycle)
0397                 val |= LIRC_CAN_SET_SEND_DUTY_CYCLE;
0398         }
0399 
0400         if (dev->s_rx_carrier_range)
0401             val |= LIRC_CAN_SET_REC_CARRIER |
0402                 LIRC_CAN_SET_REC_CARRIER_RANGE;
0403 
0404         if (dev->s_wideband_receiver)
0405             val |= LIRC_CAN_USE_WIDEBAND_RECEIVER;
0406 
0407         if (dev->s_carrier_report)
0408             val |= LIRC_CAN_MEASURE_CARRIER;
0409 
0410         if (dev->max_timeout)
0411             val |= LIRC_CAN_SET_REC_TIMEOUT;
0412 
0413         break;
0414 
0415     /* mode support */
0416     case LIRC_GET_REC_MODE:
0417         if (dev->driver_type == RC_DRIVER_IR_RAW_TX)
0418             ret = -ENOTTY;
0419         else
0420             val = fh->rec_mode;
0421         break;
0422 
0423     case LIRC_SET_REC_MODE:
0424         switch (dev->driver_type) {
0425         case RC_DRIVER_IR_RAW_TX:
0426             ret = -ENOTTY;
0427             break;
0428         case RC_DRIVER_SCANCODE:
0429             if (val != LIRC_MODE_SCANCODE)
0430                 ret = -EINVAL;
0431             break;
0432         case RC_DRIVER_IR_RAW:
0433             if (!(val == LIRC_MODE_MODE2 ||
0434                   val == LIRC_MODE_SCANCODE))
0435                 ret = -EINVAL;
0436             break;
0437         }
0438 
0439         if (!ret)
0440             fh->rec_mode = val;
0441         break;
0442 
0443     case LIRC_GET_SEND_MODE:
0444         if (!dev->tx_ir)
0445             ret = -ENOTTY;
0446         else
0447             val = fh->send_mode;
0448         break;
0449 
0450     case LIRC_SET_SEND_MODE:
0451         if (!dev->tx_ir)
0452             ret = -ENOTTY;
0453         else if (!(val == LIRC_MODE_PULSE || val == LIRC_MODE_SCANCODE))
0454             ret = -EINVAL;
0455         else
0456             fh->send_mode = val;
0457         break;
0458 
0459     /* TX settings */
0460     case LIRC_SET_TRANSMITTER_MASK:
0461         if (!dev->s_tx_mask)
0462             ret = -ENOTTY;
0463         else
0464             ret = dev->s_tx_mask(dev, val);
0465         break;
0466 
0467     case LIRC_SET_SEND_CARRIER:
0468         if (!dev->s_tx_carrier)
0469             ret = -ENOTTY;
0470         else
0471             ret = dev->s_tx_carrier(dev, val);
0472         break;
0473 
0474     case LIRC_SET_SEND_DUTY_CYCLE:
0475         if (!dev->s_tx_duty_cycle)
0476             ret = -ENOTTY;
0477         else if (val <= 0 || val >= 100)
0478             ret = -EINVAL;
0479         else
0480             ret = dev->s_tx_duty_cycle(dev, val);
0481         break;
0482 
0483     /* RX settings */
0484     case LIRC_SET_REC_CARRIER:
0485         if (!dev->s_rx_carrier_range)
0486             ret = -ENOTTY;
0487         else if (val <= 0)
0488             ret = -EINVAL;
0489         else
0490             ret = dev->s_rx_carrier_range(dev, fh->carrier_low,
0491                               val);
0492         break;
0493 
0494     case LIRC_SET_REC_CARRIER_RANGE:
0495         if (!dev->s_rx_carrier_range)
0496             ret = -ENOTTY;
0497         else if (val <= 0)
0498             ret = -EINVAL;
0499         else
0500             fh->carrier_low = val;
0501         break;
0502 
0503     case LIRC_GET_REC_RESOLUTION:
0504         if (!dev->rx_resolution)
0505             ret = -ENOTTY;
0506         else
0507             val = dev->rx_resolution;
0508         break;
0509 
0510     case LIRC_SET_WIDEBAND_RECEIVER:
0511         if (!dev->s_wideband_receiver)
0512             ret = -ENOTTY;
0513         else
0514             ret = dev->s_wideband_receiver(dev, !!val);
0515         break;
0516 
0517     case LIRC_SET_MEASURE_CARRIER_MODE:
0518         if (!dev->s_carrier_report)
0519             ret = -ENOTTY;
0520         else
0521             ret = dev->s_carrier_report(dev, !!val);
0522         break;
0523 
0524     /* Generic timeout support */
0525     case LIRC_GET_MIN_TIMEOUT:
0526         if (!dev->max_timeout)
0527             ret = -ENOTTY;
0528         else
0529             val = dev->min_timeout;
0530         break;
0531 
0532     case LIRC_GET_MAX_TIMEOUT:
0533         if (!dev->max_timeout)
0534             ret = -ENOTTY;
0535         else
0536             val = dev->max_timeout;
0537         break;
0538 
0539     case LIRC_SET_REC_TIMEOUT:
0540         if (!dev->max_timeout) {
0541             ret = -ENOTTY;
0542         } else {
0543             if (val < dev->min_timeout || val > dev->max_timeout)
0544                 ret = -EINVAL;
0545             else if (dev->s_timeout)
0546                 ret = dev->s_timeout(dev, val);
0547             else
0548                 dev->timeout = val;
0549         }
0550         break;
0551 
0552     case LIRC_GET_REC_TIMEOUT:
0553         if (!dev->timeout)
0554             ret = -ENOTTY;
0555         else
0556             val = dev->timeout;
0557         break;
0558 
0559     case LIRC_SET_REC_TIMEOUT_REPORTS:
0560         if (dev->driver_type != RC_DRIVER_IR_RAW)
0561             ret = -ENOTTY;
0562         break;
0563 
0564     default:
0565         ret = -ENOTTY;
0566     }
0567 
0568     if (!ret && _IOC_DIR(cmd) & _IOC_READ)
0569         ret = put_user(val, argp);
0570 
0571 out:
0572     mutex_unlock(&dev->lock);
0573     return ret;
0574 }
0575 
0576 static __poll_t lirc_poll(struct file *file, struct poll_table_struct *wait)
0577 {
0578     struct lirc_fh *fh = file->private_data;
0579     struct rc_dev *rcdev = fh->rc;
0580     __poll_t events = 0;
0581 
0582     poll_wait(file, &fh->wait_poll, wait);
0583 
0584     if (!rcdev->registered) {
0585         events = EPOLLHUP | EPOLLERR;
0586     } else if (rcdev->driver_type != RC_DRIVER_IR_RAW_TX) {
0587         if (fh->rec_mode == LIRC_MODE_SCANCODE &&
0588             !kfifo_is_empty(&fh->scancodes))
0589             events = EPOLLIN | EPOLLRDNORM;
0590 
0591         if (fh->rec_mode == LIRC_MODE_MODE2 &&
0592             !kfifo_is_empty(&fh->rawir))
0593             events = EPOLLIN | EPOLLRDNORM;
0594     }
0595 
0596     return events;
0597 }
0598 
0599 static ssize_t lirc_read_mode2(struct file *file, char __user *buffer,
0600                    size_t length)
0601 {
0602     struct lirc_fh *fh = file->private_data;
0603     struct rc_dev *rcdev = fh->rc;
0604     unsigned int copied;
0605     int ret;
0606 
0607     if (length < sizeof(unsigned int) || length % sizeof(unsigned int))
0608         return -EINVAL;
0609 
0610     do {
0611         if (kfifo_is_empty(&fh->rawir)) {
0612             if (file->f_flags & O_NONBLOCK)
0613                 return -EAGAIN;
0614 
0615             ret = wait_event_interruptible(fh->wait_poll,
0616                     !kfifo_is_empty(&fh->rawir) ||
0617                     !rcdev->registered);
0618             if (ret)
0619                 return ret;
0620         }
0621 
0622         if (!rcdev->registered)
0623             return -ENODEV;
0624 
0625         ret = mutex_lock_interruptible(&rcdev->lock);
0626         if (ret)
0627             return ret;
0628         ret = kfifo_to_user(&fh->rawir, buffer, length, &copied);
0629         mutex_unlock(&rcdev->lock);
0630         if (ret)
0631             return ret;
0632     } while (copied == 0);
0633 
0634     return copied;
0635 }
0636 
0637 static ssize_t lirc_read_scancode(struct file *file, char __user *buffer,
0638                   size_t length)
0639 {
0640     struct lirc_fh *fh = file->private_data;
0641     struct rc_dev *rcdev = fh->rc;
0642     unsigned int copied;
0643     int ret;
0644 
0645     if (length < sizeof(struct lirc_scancode) ||
0646         length % sizeof(struct lirc_scancode))
0647         return -EINVAL;
0648 
0649     do {
0650         if (kfifo_is_empty(&fh->scancodes)) {
0651             if (file->f_flags & O_NONBLOCK)
0652                 return -EAGAIN;
0653 
0654             ret = wait_event_interruptible(fh->wait_poll,
0655                     !kfifo_is_empty(&fh->scancodes) ||
0656                     !rcdev->registered);
0657             if (ret)
0658                 return ret;
0659         }
0660 
0661         if (!rcdev->registered)
0662             return -ENODEV;
0663 
0664         ret = mutex_lock_interruptible(&rcdev->lock);
0665         if (ret)
0666             return ret;
0667         ret = kfifo_to_user(&fh->scancodes, buffer, length, &copied);
0668         mutex_unlock(&rcdev->lock);
0669         if (ret)
0670             return ret;
0671     } while (copied == 0);
0672 
0673     return copied;
0674 }
0675 
0676 static ssize_t lirc_read(struct file *file, char __user *buffer, size_t length,
0677              loff_t *ppos)
0678 {
0679     struct lirc_fh *fh = file->private_data;
0680     struct rc_dev *rcdev = fh->rc;
0681 
0682     if (rcdev->driver_type == RC_DRIVER_IR_RAW_TX)
0683         return -EINVAL;
0684 
0685     if (!rcdev->registered)
0686         return -ENODEV;
0687 
0688     if (fh->rec_mode == LIRC_MODE_MODE2)
0689         return lirc_read_mode2(file, buffer, length);
0690     else /* LIRC_MODE_SCANCODE */
0691         return lirc_read_scancode(file, buffer, length);
0692 }
0693 
0694 static const struct file_operations lirc_fops = {
0695     .owner      = THIS_MODULE,
0696     .write      = lirc_transmit,
0697     .unlocked_ioctl = lirc_ioctl,
0698     .compat_ioctl   = compat_ptr_ioctl,
0699     .read       = lirc_read,
0700     .poll       = lirc_poll,
0701     .open       = lirc_open,
0702     .release    = lirc_close,
0703     .llseek     = no_llseek,
0704 };
0705 
0706 static void lirc_release_device(struct device *ld)
0707 {
0708     struct rc_dev *rcdev = container_of(ld, struct rc_dev, lirc_dev);
0709 
0710     put_device(&rcdev->dev);
0711 }
0712 
0713 int lirc_register(struct rc_dev *dev)
0714 {
0715     const char *rx_type, *tx_type;
0716     int err, minor;
0717 
0718     minor = ida_alloc_max(&lirc_ida, RC_DEV_MAX - 1, GFP_KERNEL);
0719     if (minor < 0)
0720         return minor;
0721 
0722     device_initialize(&dev->lirc_dev);
0723     dev->lirc_dev.class = lirc_class;
0724     dev->lirc_dev.parent = &dev->dev;
0725     dev->lirc_dev.release = lirc_release_device;
0726     dev->lirc_dev.devt = MKDEV(MAJOR(lirc_base_dev), minor);
0727     dev_set_name(&dev->lirc_dev, "lirc%d", minor);
0728 
0729     INIT_LIST_HEAD(&dev->lirc_fh);
0730     spin_lock_init(&dev->lirc_fh_lock);
0731 
0732     cdev_init(&dev->lirc_cdev, &lirc_fops);
0733 
0734     err = cdev_device_add(&dev->lirc_cdev, &dev->lirc_dev);
0735     if (err)
0736         goto out_ida;
0737 
0738     get_device(&dev->dev);
0739 
0740     switch (dev->driver_type) {
0741     case RC_DRIVER_SCANCODE:
0742         rx_type = "scancode";
0743         break;
0744     case RC_DRIVER_IR_RAW:
0745         rx_type = "raw IR";
0746         break;
0747     default:
0748         rx_type = "no";
0749         break;
0750     }
0751 
0752     if (dev->tx_ir)
0753         tx_type = "raw IR";
0754     else
0755         tx_type = "no";
0756 
0757     dev_info(&dev->dev, "lirc_dev: driver %s registered at minor = %d, %s receiver, %s transmitter",
0758          dev->driver_name, minor, rx_type, tx_type);
0759 
0760     return 0;
0761 
0762 out_ida:
0763     ida_free(&lirc_ida, minor);
0764     return err;
0765 }
0766 
0767 void lirc_unregister(struct rc_dev *dev)
0768 {
0769     unsigned long flags;
0770     struct lirc_fh *fh;
0771 
0772     dev_dbg(&dev->dev, "lirc_dev: driver %s unregistered from minor = %d\n",
0773         dev->driver_name, MINOR(dev->lirc_dev.devt));
0774 
0775     spin_lock_irqsave(&dev->lirc_fh_lock, flags);
0776     list_for_each_entry(fh, &dev->lirc_fh, list)
0777         wake_up_poll(&fh->wait_poll, EPOLLHUP | EPOLLERR);
0778     spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
0779 
0780     cdev_device_del(&dev->lirc_cdev, &dev->lirc_dev);
0781     ida_free(&lirc_ida, MINOR(dev->lirc_dev.devt));
0782 }
0783 
0784 int __init lirc_dev_init(void)
0785 {
0786     int retval;
0787 
0788     lirc_class = class_create(THIS_MODULE, "lirc");
0789     if (IS_ERR(lirc_class)) {
0790         pr_err("class_create failed\n");
0791         return PTR_ERR(lirc_class);
0792     }
0793 
0794     retval = alloc_chrdev_region(&lirc_base_dev, 0, RC_DEV_MAX, "lirc");
0795     if (retval) {
0796         class_destroy(lirc_class);
0797         pr_err("alloc_chrdev_region failed\n");
0798         return retval;
0799     }
0800 
0801     pr_debug("IR Remote Control driver registered, major %d\n",
0802          MAJOR(lirc_base_dev));
0803 
0804     return 0;
0805 }
0806 
0807 void __exit lirc_dev_exit(void)
0808 {
0809     class_destroy(lirc_class);
0810     unregister_chrdev_region(lirc_base_dev, RC_DEV_MAX);
0811 }
0812 
0813 struct rc_dev *rc_dev_get_from_fd(int fd)
0814 {
0815     struct fd f = fdget(fd);
0816     struct lirc_fh *fh;
0817     struct rc_dev *dev;
0818 
0819     if (!f.file)
0820         return ERR_PTR(-EBADF);
0821 
0822     if (f.file->f_op != &lirc_fops) {
0823         fdput(f);
0824         return ERR_PTR(-EINVAL);
0825     }
0826 
0827     fh = f.file->private_data;
0828     dev = fh->rc;
0829 
0830     get_device(&dev->dev);
0831     fdput(f);
0832 
0833     return dev;
0834 }
0835 
0836 MODULE_ALIAS("lirc_dev");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!