lirc_dev.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * LIRC base driver
  4. *
  5. * by Artur Lipowski <alipowski@interia.pl>
  6. */
  7. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  8. #include <linux/module.h>
  9. #include <linux/mutex.h>
  10. #include <linux/device.h>
  11. #include <linux/file.h>
  12. #include <linux/idr.h>
  13. #include <linux/poll.h>
  14. #include <linux/sched.h>
  15. #include <linux/wait.h>
  16. #include "rc-core-priv.h"
  17. #include <uapi/linux/lirc.h>
  18. #define LIRCBUF_SIZE 1024
  19. static dev_t lirc_base_dev;
  20. /* Used to keep track of allocated lirc devices */
  21. static DEFINE_IDA(lirc_ida);
  22. /* Only used for sysfs but defined to void otherwise */
  23. static struct class *lirc_class;
  24. /**
  25. * lirc_raw_event() - Send raw IR data to lirc to be relayed to userspace
  26. *
  27. * @dev: the struct rc_dev descriptor of the device
  28. * @ev: the struct ir_raw_event descriptor of the pulse/space
  29. */
  30. void lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev)
  31. {
  32. unsigned long flags;
  33. struct lirc_fh *fh;
  34. int sample;
  35. /* Packet start */
  36. if (ev.reset) {
  37. /*
  38. * Userspace expects a long space event before the start of
  39. * the signal to use as a sync. This may be done with repeat
  40. * packets and normal samples. But if a reset has been sent
  41. * then we assume that a long time has passed, so we send a
  42. * space with the maximum time value.
  43. */
  44. sample = LIRC_SPACE(LIRC_VALUE_MASK);
  45. dev_dbg(&dev->dev, "delivering reset sync space to lirc_dev\n");
  46. /* Carrier reports */
  47. } else if (ev.carrier_report) {
  48. sample = LIRC_FREQUENCY(ev.carrier);
  49. dev_dbg(&dev->dev, "carrier report (freq: %d)\n", sample);
  50. /* Packet end */
  51. } else if (ev.timeout) {
  52. if (dev->gap)
  53. return;
  54. dev->gap_start = ktime_get();
  55. dev->gap = true;
  56. dev->gap_duration = ev.duration;
  57. sample = LIRC_TIMEOUT(ev.duration);
  58. dev_dbg(&dev->dev, "timeout report (duration: %d)\n", sample);
  59. /* Normal sample */
  60. } else {
  61. if (dev->gap) {
  62. dev->gap_duration += ktime_to_us(ktime_sub(ktime_get(),
  63. dev->gap_start));
  64. /* Cap by LIRC_VALUE_MASK */
  65. dev->gap_duration = min_t(u64, dev->gap_duration,
  66. LIRC_VALUE_MASK);
  67. spin_lock_irqsave(&dev->lirc_fh_lock, flags);
  68. list_for_each_entry(fh, &dev->lirc_fh, list)
  69. kfifo_put(&fh->rawir,
  70. LIRC_SPACE(dev->gap_duration));
  71. spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
  72. dev->gap = false;
  73. }
  74. sample = ev.pulse ? LIRC_PULSE(ev.duration) :
  75. LIRC_SPACE(ev.duration);
  76. dev_dbg(&dev->dev, "delivering %uus %s to lirc_dev\n",
  77. ev.duration, TO_STR(ev.pulse));
  78. }
  79. /*
  80. * bpf does not care about the gap generated above; that exists
  81. * for backwards compatibility
  82. */
  83. lirc_bpf_run(dev, sample);
  84. spin_lock_irqsave(&dev->lirc_fh_lock, flags);
  85. list_for_each_entry(fh, &dev->lirc_fh, list) {
  86. if (LIRC_IS_TIMEOUT(sample) && !fh->send_timeout_reports)
  87. continue;
  88. if (kfifo_put(&fh->rawir, sample))
  89. wake_up_poll(&fh->wait_poll, EPOLLIN | EPOLLRDNORM);
  90. }
  91. spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
  92. }
  93. /**
  94. * lirc_scancode_event() - Send scancode data to lirc to be relayed to
  95. * userspace. This can be called in atomic context.
  96. * @dev: the struct rc_dev descriptor of the device
  97. * @lsc: the struct lirc_scancode describing the decoded scancode
  98. */
  99. void lirc_scancode_event(struct rc_dev *dev, struct lirc_scancode *lsc)
  100. {
  101. unsigned long flags;
  102. struct lirc_fh *fh;
  103. lsc->timestamp = ktime_get_ns();
  104. spin_lock_irqsave(&dev->lirc_fh_lock, flags);
  105. list_for_each_entry(fh, &dev->lirc_fh, list) {
  106. if (kfifo_put(&fh->scancodes, *lsc))
  107. wake_up_poll(&fh->wait_poll, EPOLLIN | EPOLLRDNORM);
  108. }
  109. spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
  110. }
  111. EXPORT_SYMBOL_GPL(lirc_scancode_event);
  112. static int lirc_open(struct inode *inode, struct file *file)
  113. {
  114. struct rc_dev *dev = container_of(inode->i_cdev, struct rc_dev,
  115. lirc_cdev);
  116. struct lirc_fh *fh = kzalloc(sizeof(*fh), GFP_KERNEL);
  117. unsigned long flags;
  118. int retval;
  119. if (!fh)
  120. return -ENOMEM;
  121. get_device(&dev->dev);
  122. if (!dev->registered) {
  123. retval = -ENODEV;
  124. goto out_fh;
  125. }
  126. if (dev->driver_type == RC_DRIVER_IR_RAW) {
  127. if (kfifo_alloc(&fh->rawir, MAX_IR_EVENT_SIZE, GFP_KERNEL)) {
  128. retval = -ENOMEM;
  129. goto out_fh;
  130. }
  131. }
  132. if (dev->driver_type != RC_DRIVER_IR_RAW_TX) {
  133. if (kfifo_alloc(&fh->scancodes, 32, GFP_KERNEL)) {
  134. retval = -ENOMEM;
  135. goto out_rawir;
  136. }
  137. }
  138. fh->send_mode = LIRC_MODE_PULSE;
  139. fh->rc = dev;
  140. fh->send_timeout_reports = true;
  141. if (dev->driver_type == RC_DRIVER_SCANCODE)
  142. fh->rec_mode = LIRC_MODE_SCANCODE;
  143. else
  144. fh->rec_mode = LIRC_MODE_MODE2;
  145. retval = rc_open(dev);
  146. if (retval)
  147. goto out_kfifo;
  148. init_waitqueue_head(&fh->wait_poll);
  149. file->private_data = fh;
  150. spin_lock_irqsave(&dev->lirc_fh_lock, flags);
  151. list_add(&fh->list, &dev->lirc_fh);
  152. spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
  153. stream_open(inode, file);
  154. return 0;
  155. out_kfifo:
  156. if (dev->driver_type != RC_DRIVER_IR_RAW_TX)
  157. kfifo_free(&fh->scancodes);
  158. out_rawir:
  159. if (dev->driver_type == RC_DRIVER_IR_RAW)
  160. kfifo_free(&fh->rawir);
  161. out_fh:
  162. kfree(fh);
  163. put_device(&dev->dev);
  164. return retval;
  165. }
  166. static int lirc_close(struct inode *inode, struct file *file)
  167. {
  168. struct lirc_fh *fh = file->private_data;
  169. struct rc_dev *dev = fh->rc;
  170. unsigned long flags;
  171. spin_lock_irqsave(&dev->lirc_fh_lock, flags);
  172. list_del(&fh->list);
  173. spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
  174. if (dev->driver_type == RC_DRIVER_IR_RAW)
  175. kfifo_free(&fh->rawir);
  176. if (dev->driver_type != RC_DRIVER_IR_RAW_TX)
  177. kfifo_free(&fh->scancodes);
  178. kfree(fh);
  179. rc_close(dev);
  180. put_device(&dev->dev);
  181. return 0;
  182. }
  183. static ssize_t lirc_transmit(struct file *file, const char __user *buf,
  184. size_t n, loff_t *ppos)
  185. {
  186. struct lirc_fh *fh = file->private_data;
  187. struct rc_dev *dev = fh->rc;
  188. unsigned int *txbuf;
  189. struct ir_raw_event *raw = NULL;
  190. ssize_t ret;
  191. size_t count;
  192. ktime_t start;
  193. s64 towait;
  194. unsigned int duration = 0; /* signal duration in us */
  195. int i;
  196. ret = mutex_lock_interruptible(&dev->lock);
  197. if (ret)
  198. return ret;
  199. if (!dev->registered) {
  200. ret = -ENODEV;
  201. goto out_unlock;
  202. }
  203. if (!dev->tx_ir) {
  204. ret = -EINVAL;
  205. goto out_unlock;
  206. }
  207. if (fh->send_mode == LIRC_MODE_SCANCODE) {
  208. struct lirc_scancode scan;
  209. if (n != sizeof(scan)) {
  210. ret = -EINVAL;
  211. goto out_unlock;
  212. }
  213. if (copy_from_user(&scan, buf, sizeof(scan))) {
  214. ret = -EFAULT;
  215. goto out_unlock;
  216. }
  217. if (scan.flags || scan.keycode || scan.timestamp) {
  218. ret = -EINVAL;
  219. goto out_unlock;
  220. }
  221. /* We only have encoders for 32-bit protocols. */
  222. if (scan.scancode > U32_MAX ||
  223. !rc_validate_scancode(scan.rc_proto, scan.scancode)) {
  224. ret = -EINVAL;
  225. goto out_unlock;
  226. }
  227. raw = kmalloc_array(LIRCBUF_SIZE, sizeof(*raw), GFP_KERNEL);
  228. if (!raw) {
  229. ret = -ENOMEM;
  230. goto out_unlock;
  231. }
  232. ret = ir_raw_encode_scancode(scan.rc_proto, scan.scancode,
  233. raw, LIRCBUF_SIZE);
  234. if (ret < 0)
  235. goto out_kfree_raw;
  236. count = ret;
  237. txbuf = kmalloc_array(count, sizeof(unsigned int), GFP_KERNEL);
  238. if (!txbuf) {
  239. ret = -ENOMEM;
  240. goto out_kfree_raw;
  241. }
  242. for (i = 0; i < count; i++)
  243. txbuf[i] = raw[i].duration;
  244. if (dev->s_tx_carrier) {
  245. int carrier = ir_raw_encode_carrier(scan.rc_proto);
  246. if (carrier > 0)
  247. dev->s_tx_carrier(dev, carrier);
  248. }
  249. } else {
  250. if (n < sizeof(unsigned int) || n % sizeof(unsigned int)) {
  251. ret = -EINVAL;
  252. goto out_unlock;
  253. }
  254. count = n / sizeof(unsigned int);
  255. if (count > LIRCBUF_SIZE || count % 2 == 0) {
  256. ret = -EINVAL;
  257. goto out_unlock;
  258. }
  259. txbuf = memdup_user(buf, n);
  260. if (IS_ERR(txbuf)) {
  261. ret = PTR_ERR(txbuf);
  262. goto out_unlock;
  263. }
  264. }
  265. for (i = 0; i < count; i++) {
  266. if (txbuf[i] > IR_MAX_DURATION - duration || !txbuf[i]) {
  267. ret = -EINVAL;
  268. goto out_kfree;
  269. }
  270. duration += txbuf[i];
  271. }
  272. start = ktime_get();
  273. ret = dev->tx_ir(dev, txbuf, count);
  274. if (ret < 0)
  275. goto out_kfree;
  276. kfree(txbuf);
  277. kfree(raw);
  278. mutex_unlock(&dev->lock);
  279. /*
  280. * The lircd gap calculation expects the write function to
  281. * wait for the actual IR signal to be transmitted before
  282. * returning.
  283. */
  284. towait = ktime_us_delta(ktime_add_us(start, duration),
  285. ktime_get());
  286. if (towait > 0) {
  287. set_current_state(TASK_INTERRUPTIBLE);
  288. schedule_timeout(usecs_to_jiffies(towait));
  289. }
  290. return n;
  291. out_kfree:
  292. kfree(txbuf);
  293. out_kfree_raw:
  294. kfree(raw);
  295. out_unlock:
  296. mutex_unlock(&dev->lock);
  297. return ret;
  298. }
  299. static long lirc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  300. {
  301. struct lirc_fh *fh = file->private_data;
  302. struct rc_dev *dev = fh->rc;
  303. u32 __user *argp = (u32 __user *)(arg);
  304. u32 val = 0;
  305. int ret;
  306. if (_IOC_DIR(cmd) & _IOC_WRITE) {
  307. ret = get_user(val, argp);
  308. if (ret)
  309. return ret;
  310. }
  311. ret = mutex_lock_interruptible(&dev->lock);
  312. if (ret)
  313. return ret;
  314. if (!dev->registered) {
  315. ret = -ENODEV;
  316. goto out;
  317. }
  318. switch (cmd) {
  319. case LIRC_GET_FEATURES:
  320. if (dev->driver_type == RC_DRIVER_SCANCODE)
  321. val |= LIRC_CAN_REC_SCANCODE;
  322. if (dev->driver_type == RC_DRIVER_IR_RAW) {
  323. val |= LIRC_CAN_REC_MODE2;
  324. if (dev->rx_resolution)
  325. val |= LIRC_CAN_GET_REC_RESOLUTION;
  326. }
  327. if (dev->tx_ir) {
  328. val |= LIRC_CAN_SEND_PULSE;
  329. if (dev->s_tx_mask)
  330. val |= LIRC_CAN_SET_TRANSMITTER_MASK;
  331. if (dev->s_tx_carrier)
  332. val |= LIRC_CAN_SET_SEND_CARRIER;
  333. if (dev->s_tx_duty_cycle)
  334. val |= LIRC_CAN_SET_SEND_DUTY_CYCLE;
  335. }
  336. if (dev->s_rx_carrier_range)
  337. val |= LIRC_CAN_SET_REC_CARRIER |
  338. LIRC_CAN_SET_REC_CARRIER_RANGE;
  339. if (dev->s_learning_mode)
  340. val |= LIRC_CAN_USE_WIDEBAND_RECEIVER;
  341. if (dev->s_carrier_report)
  342. val |= LIRC_CAN_MEASURE_CARRIER;
  343. if (dev->max_timeout)
  344. val |= LIRC_CAN_SET_REC_TIMEOUT;
  345. break;
  346. /* mode support */
  347. case LIRC_GET_REC_MODE:
  348. if (dev->driver_type == RC_DRIVER_IR_RAW_TX)
  349. ret = -ENOTTY;
  350. else
  351. val = fh->rec_mode;
  352. break;
  353. case LIRC_SET_REC_MODE:
  354. switch (dev->driver_type) {
  355. case RC_DRIVER_IR_RAW_TX:
  356. ret = -ENOTTY;
  357. break;
  358. case RC_DRIVER_SCANCODE:
  359. if (val != LIRC_MODE_SCANCODE)
  360. ret = -EINVAL;
  361. break;
  362. case RC_DRIVER_IR_RAW:
  363. if (!(val == LIRC_MODE_MODE2 ||
  364. val == LIRC_MODE_SCANCODE))
  365. ret = -EINVAL;
  366. break;
  367. }
  368. if (!ret)
  369. fh->rec_mode = val;
  370. break;
  371. case LIRC_GET_SEND_MODE:
  372. if (!dev->tx_ir)
  373. ret = -ENOTTY;
  374. else
  375. val = fh->send_mode;
  376. break;
  377. case LIRC_SET_SEND_MODE:
  378. if (!dev->tx_ir)
  379. ret = -ENOTTY;
  380. else if (!(val == LIRC_MODE_PULSE || val == LIRC_MODE_SCANCODE))
  381. ret = -EINVAL;
  382. else
  383. fh->send_mode = val;
  384. break;
  385. /* TX settings */
  386. case LIRC_SET_TRANSMITTER_MASK:
  387. if (!dev->s_tx_mask)
  388. ret = -ENOTTY;
  389. else
  390. ret = dev->s_tx_mask(dev, val);
  391. break;
  392. case LIRC_SET_SEND_CARRIER:
  393. if (!dev->s_tx_carrier)
  394. ret = -ENOTTY;
  395. else
  396. ret = dev->s_tx_carrier(dev, val);
  397. break;
  398. case LIRC_SET_SEND_DUTY_CYCLE:
  399. if (!dev->s_tx_duty_cycle)
  400. ret = -ENOTTY;
  401. else if (val <= 0 || val >= 100)
  402. ret = -EINVAL;
  403. else
  404. ret = dev->s_tx_duty_cycle(dev, val);
  405. break;
  406. /* RX settings */
  407. case LIRC_SET_REC_CARRIER:
  408. if (!dev->s_rx_carrier_range)
  409. ret = -ENOTTY;
  410. else if (val <= 0)
  411. ret = -EINVAL;
  412. else
  413. ret = dev->s_rx_carrier_range(dev, fh->carrier_low,
  414. val);
  415. break;
  416. case LIRC_SET_REC_CARRIER_RANGE:
  417. if (!dev->s_rx_carrier_range)
  418. ret = -ENOTTY;
  419. else if (val <= 0)
  420. ret = -EINVAL;
  421. else
  422. fh->carrier_low = val;
  423. break;
  424. case LIRC_GET_REC_RESOLUTION:
  425. if (!dev->rx_resolution)
  426. ret = -ENOTTY;
  427. else
  428. val = dev->rx_resolution;
  429. break;
  430. case LIRC_SET_WIDEBAND_RECEIVER:
  431. if (!dev->s_learning_mode)
  432. ret = -ENOTTY;
  433. else
  434. ret = dev->s_learning_mode(dev, !!val);
  435. break;
  436. case LIRC_SET_MEASURE_CARRIER_MODE:
  437. if (!dev->s_carrier_report)
  438. ret = -ENOTTY;
  439. else
  440. ret = dev->s_carrier_report(dev, !!val);
  441. break;
  442. /* Generic timeout support */
  443. case LIRC_GET_MIN_TIMEOUT:
  444. if (!dev->max_timeout)
  445. ret = -ENOTTY;
  446. else
  447. val = dev->min_timeout;
  448. break;
  449. case LIRC_GET_MAX_TIMEOUT:
  450. if (!dev->max_timeout)
  451. ret = -ENOTTY;
  452. else
  453. val = dev->max_timeout;
  454. break;
  455. case LIRC_SET_REC_TIMEOUT:
  456. if (!dev->max_timeout) {
  457. ret = -ENOTTY;
  458. } else {
  459. if (val < dev->min_timeout || val > dev->max_timeout)
  460. ret = -EINVAL;
  461. else if (dev->s_timeout)
  462. ret = dev->s_timeout(dev, val);
  463. else
  464. dev->timeout = val;
  465. }
  466. break;
  467. case LIRC_GET_REC_TIMEOUT:
  468. if (!dev->timeout)
  469. ret = -ENOTTY;
  470. else
  471. val = dev->timeout;
  472. break;
  473. case LIRC_SET_REC_TIMEOUT_REPORTS:
  474. if (dev->driver_type != RC_DRIVER_IR_RAW)
  475. ret = -ENOTTY;
  476. else
  477. fh->send_timeout_reports = !!val;
  478. break;
  479. default:
  480. ret = -ENOTTY;
  481. }
  482. if (!ret && _IOC_DIR(cmd) & _IOC_READ)
  483. ret = put_user(val, argp);
  484. out:
  485. mutex_unlock(&dev->lock);
  486. return ret;
  487. }
  488. static __poll_t lirc_poll(struct file *file, struct poll_table_struct *wait)
  489. {
  490. struct lirc_fh *fh = file->private_data;
  491. struct rc_dev *rcdev = fh->rc;
  492. __poll_t events = 0;
  493. poll_wait(file, &fh->wait_poll, wait);
  494. if (!rcdev->registered) {
  495. events = EPOLLHUP | EPOLLERR;
  496. } else if (rcdev->driver_type != RC_DRIVER_IR_RAW_TX) {
  497. if (fh->rec_mode == LIRC_MODE_SCANCODE &&
  498. !kfifo_is_empty(&fh->scancodes))
  499. events = EPOLLIN | EPOLLRDNORM;
  500. if (fh->rec_mode == LIRC_MODE_MODE2 &&
  501. !kfifo_is_empty(&fh->rawir))
  502. events = EPOLLIN | EPOLLRDNORM;
  503. }
  504. return events;
  505. }
  506. static ssize_t lirc_read_mode2(struct file *file, char __user *buffer,
  507. size_t length)
  508. {
  509. struct lirc_fh *fh = file->private_data;
  510. struct rc_dev *rcdev = fh->rc;
  511. unsigned int copied;
  512. int ret;
  513. if (length < sizeof(unsigned int) || length % sizeof(unsigned int))
  514. return -EINVAL;
  515. do {
  516. if (kfifo_is_empty(&fh->rawir)) {
  517. if (file->f_flags & O_NONBLOCK)
  518. return -EAGAIN;
  519. ret = wait_event_interruptible(fh->wait_poll,
  520. !kfifo_is_empty(&fh->rawir) ||
  521. !rcdev->registered);
  522. if (ret)
  523. return ret;
  524. }
  525. if (!rcdev->registered)
  526. return -ENODEV;
  527. ret = mutex_lock_interruptible(&rcdev->lock);
  528. if (ret)
  529. return ret;
  530. ret = kfifo_to_user(&fh->rawir, buffer, length, &copied);
  531. mutex_unlock(&rcdev->lock);
  532. if (ret)
  533. return ret;
  534. } while (copied == 0);
  535. return copied;
  536. }
  537. static ssize_t lirc_read_scancode(struct file *file, char __user *buffer,
  538. size_t length)
  539. {
  540. struct lirc_fh *fh = file->private_data;
  541. struct rc_dev *rcdev = fh->rc;
  542. unsigned int copied;
  543. int ret;
  544. if (length < sizeof(struct lirc_scancode) ||
  545. length % sizeof(struct lirc_scancode))
  546. return -EINVAL;
  547. do {
  548. if (kfifo_is_empty(&fh->scancodes)) {
  549. if (file->f_flags & O_NONBLOCK)
  550. return -EAGAIN;
  551. ret = wait_event_interruptible(fh->wait_poll,
  552. !kfifo_is_empty(&fh->scancodes) ||
  553. !rcdev->registered);
  554. if (ret)
  555. return ret;
  556. }
  557. if (!rcdev->registered)
  558. return -ENODEV;
  559. ret = mutex_lock_interruptible(&rcdev->lock);
  560. if (ret)
  561. return ret;
  562. ret = kfifo_to_user(&fh->scancodes, buffer, length, &copied);
  563. mutex_unlock(&rcdev->lock);
  564. if (ret)
  565. return ret;
  566. } while (copied == 0);
  567. return copied;
  568. }
  569. static ssize_t lirc_read(struct file *file, char __user *buffer, size_t length,
  570. loff_t *ppos)
  571. {
  572. struct lirc_fh *fh = file->private_data;
  573. struct rc_dev *rcdev = fh->rc;
  574. if (rcdev->driver_type == RC_DRIVER_IR_RAW_TX)
  575. return -EINVAL;
  576. if (!rcdev->registered)
  577. return -ENODEV;
  578. if (fh->rec_mode == LIRC_MODE_MODE2)
  579. return lirc_read_mode2(file, buffer, length);
  580. else /* LIRC_MODE_SCANCODE */
  581. return lirc_read_scancode(file, buffer, length);
  582. }
  583. static const struct file_operations lirc_fops = {
  584. .owner = THIS_MODULE,
  585. .write = lirc_transmit,
  586. .unlocked_ioctl = lirc_ioctl,
  587. .compat_ioctl = compat_ptr_ioctl,
  588. .read = lirc_read,
  589. .poll = lirc_poll,
  590. .open = lirc_open,
  591. .release = lirc_close,
  592. .llseek = no_llseek,
  593. };
  594. static void lirc_release_device(struct device *ld)
  595. {
  596. struct rc_dev *rcdev = container_of(ld, struct rc_dev, lirc_dev);
  597. put_device(&rcdev->dev);
  598. }
  599. int lirc_register(struct rc_dev *dev)
  600. {
  601. const char *rx_type, *tx_type;
  602. int err, minor;
  603. minor = ida_simple_get(&lirc_ida, 0, RC_DEV_MAX, GFP_KERNEL);
  604. if (minor < 0)
  605. return minor;
  606. device_initialize(&dev->lirc_dev);
  607. dev->lirc_dev.class = lirc_class;
  608. dev->lirc_dev.parent = &dev->dev;
  609. dev->lirc_dev.release = lirc_release_device;
  610. dev->lirc_dev.devt = MKDEV(MAJOR(lirc_base_dev), minor);
  611. dev_set_name(&dev->lirc_dev, "lirc%d", minor);
  612. INIT_LIST_HEAD(&dev->lirc_fh);
  613. spin_lock_init(&dev->lirc_fh_lock);
  614. cdev_init(&dev->lirc_cdev, &lirc_fops);
  615. err = cdev_device_add(&dev->lirc_cdev, &dev->lirc_dev);
  616. if (err)
  617. goto out_ida;
  618. get_device(&dev->dev);
  619. switch (dev->driver_type) {
  620. case RC_DRIVER_SCANCODE:
  621. rx_type = "scancode";
  622. break;
  623. case RC_DRIVER_IR_RAW:
  624. rx_type = "raw IR";
  625. break;
  626. default:
  627. rx_type = "no";
  628. break;
  629. }
  630. if (dev->tx_ir)
  631. tx_type = "raw IR";
  632. else
  633. tx_type = "no";
  634. dev_info(&dev->dev, "lirc_dev: driver %s registered at minor = %d, %s receiver, %s transmitter",
  635. dev->driver_name, minor, rx_type, tx_type);
  636. return 0;
  637. out_ida:
  638. ida_simple_remove(&lirc_ida, minor);
  639. return err;
  640. }
  641. void lirc_unregister(struct rc_dev *dev)
  642. {
  643. unsigned long flags;
  644. struct lirc_fh *fh;
  645. dev_dbg(&dev->dev, "lirc_dev: driver %s unregistered from minor = %d\n",
  646. dev->driver_name, MINOR(dev->lirc_dev.devt));
  647. spin_lock_irqsave(&dev->lirc_fh_lock, flags);
  648. list_for_each_entry(fh, &dev->lirc_fh, list)
  649. wake_up_poll(&fh->wait_poll, EPOLLHUP | EPOLLERR);
  650. spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
  651. cdev_device_del(&dev->lirc_cdev, &dev->lirc_dev);
  652. ida_simple_remove(&lirc_ida, MINOR(dev->lirc_dev.devt));
  653. }
  654. int __init lirc_dev_init(void)
  655. {
  656. int retval;
  657. lirc_class = class_create(THIS_MODULE, "lirc");
  658. if (IS_ERR(lirc_class)) {
  659. pr_err("class_create failed\n");
  660. return PTR_ERR(lirc_class);
  661. }
  662. retval = alloc_chrdev_region(&lirc_base_dev, 0, RC_DEV_MAX, "lirc");
  663. if (retval) {
  664. class_destroy(lirc_class);
  665. pr_err("alloc_chrdev_region failed\n");
  666. return retval;
  667. }
  668. pr_debug("IR Remote Control driver registered, major %d\n",
  669. MAJOR(lirc_base_dev));
  670. return 0;
  671. }
  672. void __exit lirc_dev_exit(void)
  673. {
  674. class_destroy(lirc_class);
  675. unregister_chrdev_region(lirc_base_dev, RC_DEV_MAX);
  676. }
  677. struct rc_dev *rc_dev_get_from_fd(int fd)
  678. {
  679. struct fd f = fdget(fd);
  680. struct lirc_fh *fh;
  681. struct rc_dev *dev;
  682. if (!f.file)
  683. return ERR_PTR(-EBADF);
  684. if (f.file->f_op != &lirc_fops) {
  685. fdput(f);
  686. return ERR_PTR(-EINVAL);
  687. }
  688. fh = f.file->private_data;
  689. dev = fh->rc;
  690. get_device(&dev->dev);
  691. fdput(f);
  692. return dev;
  693. }
  694. MODULE_ALIAS("lirc_dev");