ppdev.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * linux/drivers/char/ppdev.c
  4. *
  5. * This is the code behind /dev/parport* -- it allows a user-space
  6. * application to use the parport subsystem.
  7. *
  8. * Copyright (C) 1998-2000, 2002 Tim Waugh <tim@cyberelk.net>
  9. *
  10. * A /dev/parportx device node represents an arbitrary device
  11. * on port 'x'. The following operations are possible:
  12. *
  13. * open do nothing, set up default IEEE 1284 protocol to be COMPAT
  14. * close release port and unregister device (if necessary)
  15. * ioctl
  16. * EXCL register device exclusively (may fail)
  17. * CLAIM (register device first time) parport_claim_or_block
  18. * RELEASE parport_release
  19. * SETMODE set the IEEE 1284 protocol to use for read/write
  20. * SETPHASE set the IEEE 1284 phase of a particular mode. Not to be
  21. * confused with ioctl(fd, SETPHASER, &stun). ;-)
  22. * DATADIR data_forward / data_reverse
  23. * WDATA write_data
  24. * RDATA read_data
  25. * WCONTROL write_control
  26. * RCONTROL read_control
  27. * FCONTROL frob_control
  28. * RSTATUS read_status
  29. * NEGOT parport_negotiate
  30. * YIELD parport_yield_blocking
  31. * WCTLONIRQ on interrupt, set control lines
  32. * CLRIRQ clear (and return) interrupt count
  33. * SETTIME sets device timeout (struct timeval)
  34. * GETTIME gets device timeout (struct timeval)
  35. * GETMODES gets hardware supported modes (unsigned int)
  36. * GETMODE gets the current IEEE1284 mode
  37. * GETPHASE gets the current IEEE1284 phase
  38. * GETFLAGS gets current (user-visible) flags
  39. * SETFLAGS sets current (user-visible) flags
  40. * read/write read or write in current IEEE 1284 protocol
  41. * select wait for interrupt (in readfds)
  42. *
  43. * Changes:
  44. * Added SETTIME/GETTIME ioctl, Fred Barnes, 1999.
  45. *
  46. * Arnaldo Carvalho de Melo <acme@conectiva.com.br> 2000/08/25
  47. * - On error, copy_from_user and copy_to_user do not return -EFAULT,
  48. * They return the positive number of bytes *not* copied due to address
  49. * space errors.
  50. *
  51. * Added GETMODES/GETMODE/GETPHASE ioctls, Fred Barnes <frmb2@ukc.ac.uk>, 03/01/2001.
  52. * Added GETFLAGS/SETFLAGS ioctls, Fred Barnes, 04/2001
  53. */
  54. #include <linux/module.h>
  55. #include <linux/init.h>
  56. #include <linux/sched/signal.h>
  57. #include <linux/device.h>
  58. #include <linux/ioctl.h>
  59. #include <linux/parport.h>
  60. #include <linux/ctype.h>
  61. #include <linux/poll.h>
  62. #include <linux/slab.h>
  63. #include <linux/major.h>
  64. #include <linux/ppdev.h>
  65. #include <linux/mutex.h>
  66. #include <linux/uaccess.h>
  67. #include <linux/compat.h>
  68. #define PP_VERSION "ppdev: user-space parallel port driver"
  69. #define CHRDEV "ppdev"
  70. struct pp_struct {
  71. struct pardevice *pdev;
  72. wait_queue_head_t irq_wait;
  73. atomic_t irqc;
  74. unsigned int flags;
  75. int irqresponse;
  76. unsigned char irqctl;
  77. struct ieee1284_info state;
  78. struct ieee1284_info saved_state;
  79. long default_inactivity;
  80. int index;
  81. };
  82. /* should we use PARDEVICE_MAX here? */
  83. static struct device *devices[PARPORT_MAX];
  84. static DEFINE_IDA(ida_index);
  85. /* pp_struct.flags bitfields */
  86. #define PP_CLAIMED (1<<0)
  87. #define PP_EXCL (1<<1)
  88. /* Other constants */
  89. #define PP_INTERRUPT_TIMEOUT (10 * HZ) /* 10s */
  90. #define PP_BUFFER_SIZE 1024
  91. #define PARDEVICE_MAX 8
  92. static DEFINE_MUTEX(pp_do_mutex);
  93. /* define fixed sized ioctl cmd for y2038 migration */
  94. #define PPGETTIME32 _IOR(PP_IOCTL, 0x95, s32[2])
  95. #define PPSETTIME32 _IOW(PP_IOCTL, 0x96, s32[2])
  96. #define PPGETTIME64 _IOR(PP_IOCTL, 0x95, s64[2])
  97. #define PPSETTIME64 _IOW(PP_IOCTL, 0x96, s64[2])
  98. static inline void pp_enable_irq(struct pp_struct *pp)
  99. {
  100. struct parport *port = pp->pdev->port;
  101. port->ops->enable_irq(port);
  102. }
  103. static ssize_t pp_read(struct file *file, char __user *buf, size_t count,
  104. loff_t *ppos)
  105. {
  106. unsigned int minor = iminor(file_inode(file));
  107. struct pp_struct *pp = file->private_data;
  108. char *kbuffer;
  109. ssize_t bytes_read = 0;
  110. struct parport *pport;
  111. int mode;
  112. if (!(pp->flags & PP_CLAIMED)) {
  113. /* Don't have the port claimed */
  114. pr_debug(CHRDEV "%x: claim the port first\n", minor);
  115. return -EINVAL;
  116. }
  117. /* Trivial case. */
  118. if (count == 0)
  119. return 0;
  120. kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
  121. if (!kbuffer)
  122. return -ENOMEM;
  123. pport = pp->pdev->port;
  124. mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
  125. parport_set_timeout(pp->pdev,
  126. (file->f_flags & O_NONBLOCK) ?
  127. PARPORT_INACTIVITY_O_NONBLOCK :
  128. pp->default_inactivity);
  129. while (bytes_read == 0) {
  130. ssize_t need = min_t(unsigned long, count, PP_BUFFER_SIZE);
  131. if (mode == IEEE1284_MODE_EPP) {
  132. /* various specials for EPP mode */
  133. int flags = 0;
  134. size_t (*fn)(struct parport *, void *, size_t, int);
  135. if (pp->flags & PP_W91284PIC)
  136. flags |= PARPORT_W91284PIC;
  137. if (pp->flags & PP_FASTREAD)
  138. flags |= PARPORT_EPP_FAST;
  139. if (pport->ieee1284.mode & IEEE1284_ADDR)
  140. fn = pport->ops->epp_read_addr;
  141. else
  142. fn = pport->ops->epp_read_data;
  143. bytes_read = (*fn)(pport, kbuffer, need, flags);
  144. } else {
  145. bytes_read = parport_read(pport, kbuffer, need);
  146. }
  147. if (bytes_read != 0)
  148. break;
  149. if (file->f_flags & O_NONBLOCK) {
  150. bytes_read = -EAGAIN;
  151. break;
  152. }
  153. if (signal_pending(current)) {
  154. bytes_read = -ERESTARTSYS;
  155. break;
  156. }
  157. cond_resched();
  158. }
  159. parport_set_timeout(pp->pdev, pp->default_inactivity);
  160. if (bytes_read > 0 && copy_to_user(buf, kbuffer, bytes_read))
  161. bytes_read = -EFAULT;
  162. kfree(kbuffer);
  163. pp_enable_irq(pp);
  164. return bytes_read;
  165. }
  166. static ssize_t pp_write(struct file *file, const char __user *buf,
  167. size_t count, loff_t *ppos)
  168. {
  169. unsigned int minor = iminor(file_inode(file));
  170. struct pp_struct *pp = file->private_data;
  171. char *kbuffer;
  172. ssize_t bytes_written = 0;
  173. ssize_t wrote;
  174. int mode;
  175. struct parport *pport;
  176. if (!(pp->flags & PP_CLAIMED)) {
  177. /* Don't have the port claimed */
  178. pr_debug(CHRDEV "%x: claim the port first\n", minor);
  179. return -EINVAL;
  180. }
  181. kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
  182. if (!kbuffer)
  183. return -ENOMEM;
  184. pport = pp->pdev->port;
  185. mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
  186. parport_set_timeout(pp->pdev,
  187. (file->f_flags & O_NONBLOCK) ?
  188. PARPORT_INACTIVITY_O_NONBLOCK :
  189. pp->default_inactivity);
  190. while (bytes_written < count) {
  191. ssize_t n = min_t(unsigned long, count - bytes_written, PP_BUFFER_SIZE);
  192. if (copy_from_user(kbuffer, buf + bytes_written, n)) {
  193. bytes_written = -EFAULT;
  194. break;
  195. }
  196. if ((pp->flags & PP_FASTWRITE) && (mode == IEEE1284_MODE_EPP)) {
  197. /* do a fast EPP write */
  198. if (pport->ieee1284.mode & IEEE1284_ADDR) {
  199. wrote = pport->ops->epp_write_addr(pport,
  200. kbuffer, n, PARPORT_EPP_FAST);
  201. } else {
  202. wrote = pport->ops->epp_write_data(pport,
  203. kbuffer, n, PARPORT_EPP_FAST);
  204. }
  205. } else {
  206. wrote = parport_write(pp->pdev->port, kbuffer, n);
  207. }
  208. if (wrote <= 0) {
  209. if (!bytes_written)
  210. bytes_written = wrote;
  211. break;
  212. }
  213. bytes_written += wrote;
  214. if (file->f_flags & O_NONBLOCK) {
  215. if (!bytes_written)
  216. bytes_written = -EAGAIN;
  217. break;
  218. }
  219. if (signal_pending(current))
  220. break;
  221. cond_resched();
  222. }
  223. parport_set_timeout(pp->pdev, pp->default_inactivity);
  224. kfree(kbuffer);
  225. pp_enable_irq(pp);
  226. return bytes_written;
  227. }
  228. static void pp_irq(void *private)
  229. {
  230. struct pp_struct *pp = private;
  231. if (pp->irqresponse) {
  232. parport_write_control(pp->pdev->port, pp->irqctl);
  233. pp->irqresponse = 0;
  234. }
  235. atomic_inc(&pp->irqc);
  236. wake_up_interruptible(&pp->irq_wait);
  237. }
  238. static int register_device(int minor, struct pp_struct *pp)
  239. {
  240. struct parport *port;
  241. struct pardevice *pdev = NULL;
  242. char *name;
  243. struct pardev_cb ppdev_cb;
  244. int rc = 0, index;
  245. name = kasprintf(GFP_KERNEL, CHRDEV "%x", minor);
  246. if (name == NULL)
  247. return -ENOMEM;
  248. port = parport_find_number(minor);
  249. if (!port) {
  250. pr_warn("%s: no associated port!\n", name);
  251. rc = -ENXIO;
  252. goto err;
  253. }
  254. index = ida_simple_get(&ida_index, 0, 0, GFP_KERNEL);
  255. memset(&ppdev_cb, 0, sizeof(ppdev_cb));
  256. ppdev_cb.irq_func = pp_irq;
  257. ppdev_cb.flags = (pp->flags & PP_EXCL) ? PARPORT_FLAG_EXCL : 0;
  258. ppdev_cb.private = pp;
  259. pdev = parport_register_dev_model(port, name, &ppdev_cb, index);
  260. parport_put_port(port);
  261. if (!pdev) {
  262. pr_warn("%s: failed to register device!\n", name);
  263. rc = -ENXIO;
  264. ida_simple_remove(&ida_index, index);
  265. goto err;
  266. }
  267. pp->pdev = pdev;
  268. pp->index = index;
  269. dev_dbg(&pdev->dev, "registered pardevice\n");
  270. err:
  271. kfree(name);
  272. return rc;
  273. }
  274. static enum ieee1284_phase init_phase(int mode)
  275. {
  276. switch (mode & ~(IEEE1284_DEVICEID
  277. | IEEE1284_ADDR)) {
  278. case IEEE1284_MODE_NIBBLE:
  279. case IEEE1284_MODE_BYTE:
  280. return IEEE1284_PH_REV_IDLE;
  281. }
  282. return IEEE1284_PH_FWD_IDLE;
  283. }
  284. static int pp_set_timeout(struct pardevice *pdev, long tv_sec, int tv_usec)
  285. {
  286. long to_jiffies;
  287. if ((tv_sec < 0) || (tv_usec < 0))
  288. return -EINVAL;
  289. to_jiffies = usecs_to_jiffies(tv_usec);
  290. to_jiffies += tv_sec * HZ;
  291. if (to_jiffies <= 0)
  292. return -EINVAL;
  293. pdev->timeout = to_jiffies;
  294. return 0;
  295. }
  296. static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  297. {
  298. unsigned int minor = iminor(file_inode(file));
  299. struct pp_struct *pp = file->private_data;
  300. struct parport *port;
  301. void __user *argp = (void __user *)arg;
  302. struct ieee1284_info *info;
  303. unsigned char reg;
  304. unsigned char mask;
  305. int mode;
  306. s32 time32[2];
  307. s64 time64[2];
  308. struct timespec64 ts;
  309. int ret;
  310. /* First handle the cases that don't take arguments. */
  311. switch (cmd) {
  312. case PPCLAIM:
  313. {
  314. if (pp->flags & PP_CLAIMED) {
  315. dev_dbg(&pp->pdev->dev, "you've already got it!\n");
  316. return -EINVAL;
  317. }
  318. /* Deferred device registration. */
  319. if (!pp->pdev) {
  320. int err = register_device(minor, pp);
  321. if (err)
  322. return err;
  323. }
  324. ret = parport_claim_or_block(pp->pdev);
  325. if (ret < 0)
  326. return ret;
  327. pp->flags |= PP_CLAIMED;
  328. /* For interrupt-reporting to work, we need to be
  329. * informed of each interrupt. */
  330. pp_enable_irq(pp);
  331. /* We may need to fix up the state machine. */
  332. info = &pp->pdev->port->ieee1284;
  333. pp->saved_state.mode = info->mode;
  334. pp->saved_state.phase = info->phase;
  335. info->mode = pp->state.mode;
  336. info->phase = pp->state.phase;
  337. pp->default_inactivity = parport_set_timeout(pp->pdev, 0);
  338. parport_set_timeout(pp->pdev, pp->default_inactivity);
  339. return 0;
  340. }
  341. case PPEXCL:
  342. if (pp->pdev) {
  343. dev_dbg(&pp->pdev->dev,
  344. "too late for PPEXCL; already registered\n");
  345. if (pp->flags & PP_EXCL)
  346. /* But it's not really an error. */
  347. return 0;
  348. /* There's no chance of making the driver happy. */
  349. return -EINVAL;
  350. }
  351. /* Just remember to register the device exclusively
  352. * when we finally do the registration. */
  353. pp->flags |= PP_EXCL;
  354. return 0;
  355. case PPSETMODE:
  356. {
  357. int mode;
  358. if (copy_from_user(&mode, argp, sizeof(mode)))
  359. return -EFAULT;
  360. /* FIXME: validate mode */
  361. pp->state.mode = mode;
  362. pp->state.phase = init_phase(mode);
  363. if (pp->flags & PP_CLAIMED) {
  364. pp->pdev->port->ieee1284.mode = mode;
  365. pp->pdev->port->ieee1284.phase = pp->state.phase;
  366. }
  367. return 0;
  368. }
  369. case PPGETMODE:
  370. {
  371. int mode;
  372. if (pp->flags & PP_CLAIMED)
  373. mode = pp->pdev->port->ieee1284.mode;
  374. else
  375. mode = pp->state.mode;
  376. if (copy_to_user(argp, &mode, sizeof(mode)))
  377. return -EFAULT;
  378. return 0;
  379. }
  380. case PPSETPHASE:
  381. {
  382. int phase;
  383. if (copy_from_user(&phase, argp, sizeof(phase)))
  384. return -EFAULT;
  385. /* FIXME: validate phase */
  386. pp->state.phase = phase;
  387. if (pp->flags & PP_CLAIMED)
  388. pp->pdev->port->ieee1284.phase = phase;
  389. return 0;
  390. }
  391. case PPGETPHASE:
  392. {
  393. int phase;
  394. if (pp->flags & PP_CLAIMED)
  395. phase = pp->pdev->port->ieee1284.phase;
  396. else
  397. phase = pp->state.phase;
  398. if (copy_to_user(argp, &phase, sizeof(phase)))
  399. return -EFAULT;
  400. return 0;
  401. }
  402. case PPGETMODES:
  403. {
  404. unsigned int modes;
  405. port = parport_find_number(minor);
  406. if (!port)
  407. return -ENODEV;
  408. modes = port->modes;
  409. parport_put_port(port);
  410. if (copy_to_user(argp, &modes, sizeof(modes)))
  411. return -EFAULT;
  412. return 0;
  413. }
  414. case PPSETFLAGS:
  415. {
  416. int uflags;
  417. if (copy_from_user(&uflags, argp, sizeof(uflags)))
  418. return -EFAULT;
  419. pp->flags &= ~PP_FLAGMASK;
  420. pp->flags |= (uflags & PP_FLAGMASK);
  421. return 0;
  422. }
  423. case PPGETFLAGS:
  424. {
  425. int uflags;
  426. uflags = pp->flags & PP_FLAGMASK;
  427. if (copy_to_user(argp, &uflags, sizeof(uflags)))
  428. return -EFAULT;
  429. return 0;
  430. }
  431. } /* end switch() */
  432. /* Everything else requires the port to be claimed, so check
  433. * that now. */
  434. if ((pp->flags & PP_CLAIMED) == 0) {
  435. pr_debug(CHRDEV "%x: claim the port first\n", minor);
  436. return -EINVAL;
  437. }
  438. port = pp->pdev->port;
  439. switch (cmd) {
  440. case PPRSTATUS:
  441. reg = parport_read_status(port);
  442. if (copy_to_user(argp, &reg, sizeof(reg)))
  443. return -EFAULT;
  444. return 0;
  445. case PPRDATA:
  446. reg = parport_read_data(port);
  447. if (copy_to_user(argp, &reg, sizeof(reg)))
  448. return -EFAULT;
  449. return 0;
  450. case PPRCONTROL:
  451. reg = parport_read_control(port);
  452. if (copy_to_user(argp, &reg, sizeof(reg)))
  453. return -EFAULT;
  454. return 0;
  455. case PPYIELD:
  456. parport_yield_blocking(pp->pdev);
  457. return 0;
  458. case PPRELEASE:
  459. /* Save the state machine's state. */
  460. info = &pp->pdev->port->ieee1284;
  461. pp->state.mode = info->mode;
  462. pp->state.phase = info->phase;
  463. info->mode = pp->saved_state.mode;
  464. info->phase = pp->saved_state.phase;
  465. parport_release(pp->pdev);
  466. pp->flags &= ~PP_CLAIMED;
  467. return 0;
  468. case PPWCONTROL:
  469. if (copy_from_user(&reg, argp, sizeof(reg)))
  470. return -EFAULT;
  471. parport_write_control(port, reg);
  472. return 0;
  473. case PPWDATA:
  474. if (copy_from_user(&reg, argp, sizeof(reg)))
  475. return -EFAULT;
  476. parport_write_data(port, reg);
  477. return 0;
  478. case PPFCONTROL:
  479. if (copy_from_user(&mask, argp,
  480. sizeof(mask)))
  481. return -EFAULT;
  482. if (copy_from_user(&reg, 1 + (unsigned char __user *) arg,
  483. sizeof(reg)))
  484. return -EFAULT;
  485. parport_frob_control(port, mask, reg);
  486. return 0;
  487. case PPDATADIR:
  488. if (copy_from_user(&mode, argp, sizeof(mode)))
  489. return -EFAULT;
  490. if (mode)
  491. port->ops->data_reverse(port);
  492. else
  493. port->ops->data_forward(port);
  494. return 0;
  495. case PPNEGOT:
  496. if (copy_from_user(&mode, argp, sizeof(mode)))
  497. return -EFAULT;
  498. switch ((ret = parport_negotiate(port, mode))) {
  499. case 0: break;
  500. case -1: /* handshake failed, peripheral not IEEE 1284 */
  501. ret = -EIO;
  502. break;
  503. case 1: /* handshake succeeded, peripheral rejected mode */
  504. ret = -ENXIO;
  505. break;
  506. }
  507. pp_enable_irq(pp);
  508. return ret;
  509. case PPWCTLONIRQ:
  510. if (copy_from_user(&reg, argp, sizeof(reg)))
  511. return -EFAULT;
  512. /* Remember what to set the control lines to, for next
  513. * time we get an interrupt. */
  514. pp->irqctl = reg;
  515. pp->irqresponse = 1;
  516. return 0;
  517. case PPCLRIRQ:
  518. ret = atomic_read(&pp->irqc);
  519. if (copy_to_user(argp, &ret, sizeof(ret)))
  520. return -EFAULT;
  521. atomic_sub(ret, &pp->irqc);
  522. return 0;
  523. case PPSETTIME32:
  524. if (copy_from_user(time32, argp, sizeof(time32)))
  525. return -EFAULT;
  526. if ((time32[0] < 0) || (time32[1] < 0))
  527. return -EINVAL;
  528. return pp_set_timeout(pp->pdev, time32[0], time32[1]);
  529. case PPSETTIME64:
  530. if (copy_from_user(time64, argp, sizeof(time64)))
  531. return -EFAULT;
  532. if ((time64[0] < 0) || (time64[1] < 0))
  533. return -EINVAL;
  534. if (IS_ENABLED(CONFIG_SPARC64) && !in_compat_syscall())
  535. time64[1] >>= 32;
  536. return pp_set_timeout(pp->pdev, time64[0], time64[1]);
  537. case PPGETTIME32:
  538. jiffies_to_timespec64(pp->pdev->timeout, &ts);
  539. time32[0] = ts.tv_sec;
  540. time32[1] = ts.tv_nsec / NSEC_PER_USEC;
  541. if (copy_to_user(argp, time32, sizeof(time32)))
  542. return -EFAULT;
  543. return 0;
  544. case PPGETTIME64:
  545. jiffies_to_timespec64(pp->pdev->timeout, &ts);
  546. time64[0] = ts.tv_sec;
  547. time64[1] = ts.tv_nsec / NSEC_PER_USEC;
  548. if (IS_ENABLED(CONFIG_SPARC64) && !in_compat_syscall())
  549. time64[1] <<= 32;
  550. if (copy_to_user(argp, time64, sizeof(time64)))
  551. return -EFAULT;
  552. return 0;
  553. default:
  554. dev_dbg(&pp->pdev->dev, "What? (cmd=0x%x)\n", cmd);
  555. return -EINVAL;
  556. }
  557. /* Keep the compiler happy */
  558. return 0;
  559. }
  560. static long pp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  561. {
  562. long ret;
  563. mutex_lock(&pp_do_mutex);
  564. ret = pp_do_ioctl(file, cmd, arg);
  565. mutex_unlock(&pp_do_mutex);
  566. return ret;
  567. }
  568. static int pp_open(struct inode *inode, struct file *file)
  569. {
  570. unsigned int minor = iminor(inode);
  571. struct pp_struct *pp;
  572. if (minor >= PARPORT_MAX)
  573. return -ENXIO;
  574. pp = kmalloc(sizeof(struct pp_struct), GFP_KERNEL);
  575. if (!pp)
  576. return -ENOMEM;
  577. pp->state.mode = IEEE1284_MODE_COMPAT;
  578. pp->state.phase = init_phase(pp->state.mode);
  579. pp->flags = 0;
  580. pp->irqresponse = 0;
  581. atomic_set(&pp->irqc, 0);
  582. init_waitqueue_head(&pp->irq_wait);
  583. /* Defer the actual device registration until the first claim.
  584. * That way, we know whether or not the driver wants to have
  585. * exclusive access to the port (PPEXCL).
  586. */
  587. pp->pdev = NULL;
  588. file->private_data = pp;
  589. return 0;
  590. }
  591. static int pp_release(struct inode *inode, struct file *file)
  592. {
  593. unsigned int minor = iminor(inode);
  594. struct pp_struct *pp = file->private_data;
  595. int compat_negot;
  596. compat_negot = 0;
  597. if (!(pp->flags & PP_CLAIMED) && pp->pdev &&
  598. (pp->state.mode != IEEE1284_MODE_COMPAT)) {
  599. struct ieee1284_info *info;
  600. /* parport released, but not in compatibility mode */
  601. parport_claim_or_block(pp->pdev);
  602. pp->flags |= PP_CLAIMED;
  603. info = &pp->pdev->port->ieee1284;
  604. pp->saved_state.mode = info->mode;
  605. pp->saved_state.phase = info->phase;
  606. info->mode = pp->state.mode;
  607. info->phase = pp->state.phase;
  608. compat_negot = 1;
  609. } else if ((pp->flags & PP_CLAIMED) && pp->pdev &&
  610. (pp->pdev->port->ieee1284.mode != IEEE1284_MODE_COMPAT)) {
  611. compat_negot = 2;
  612. }
  613. if (compat_negot) {
  614. parport_negotiate(pp->pdev->port, IEEE1284_MODE_COMPAT);
  615. dev_dbg(&pp->pdev->dev,
  616. "negotiated back to compatibility mode because user-space forgot\n");
  617. }
  618. if ((pp->flags & PP_CLAIMED) && pp->pdev) {
  619. struct ieee1284_info *info;
  620. info = &pp->pdev->port->ieee1284;
  621. pp->state.mode = info->mode;
  622. pp->state.phase = info->phase;
  623. info->mode = pp->saved_state.mode;
  624. info->phase = pp->saved_state.phase;
  625. parport_release(pp->pdev);
  626. if (compat_negot != 1) {
  627. pr_debug(CHRDEV "%x: released pardevice "
  628. "because user-space forgot\n", minor);
  629. }
  630. }
  631. if (pp->pdev) {
  632. parport_unregister_device(pp->pdev);
  633. ida_simple_remove(&ida_index, pp->index);
  634. pp->pdev = NULL;
  635. pr_debug(CHRDEV "%x: unregistered pardevice\n", minor);
  636. }
  637. kfree(pp);
  638. return 0;
  639. }
  640. /* No kernel lock held - fine */
  641. static __poll_t pp_poll(struct file *file, poll_table *wait)
  642. {
  643. struct pp_struct *pp = file->private_data;
  644. __poll_t mask = 0;
  645. poll_wait(file, &pp->irq_wait, wait);
  646. if (atomic_read(&pp->irqc))
  647. mask |= EPOLLIN | EPOLLRDNORM;
  648. return mask;
  649. }
  650. static struct class *ppdev_class;
  651. static const struct file_operations pp_fops = {
  652. .owner = THIS_MODULE,
  653. .llseek = no_llseek,
  654. .read = pp_read,
  655. .write = pp_write,
  656. .poll = pp_poll,
  657. .unlocked_ioctl = pp_ioctl,
  658. .compat_ioctl = compat_ptr_ioctl,
  659. .open = pp_open,
  660. .release = pp_release,
  661. };
  662. static void pp_attach(struct parport *port)
  663. {
  664. struct device *ret;
  665. if (devices[port->number])
  666. return;
  667. ret = device_create(ppdev_class, port->dev,
  668. MKDEV(PP_MAJOR, port->number), NULL,
  669. "parport%d", port->number);
  670. if (IS_ERR(ret)) {
  671. pr_err("Failed to create device parport%d\n",
  672. port->number);
  673. return;
  674. }
  675. devices[port->number] = ret;
  676. }
  677. static void pp_detach(struct parport *port)
  678. {
  679. if (!devices[port->number])
  680. return;
  681. device_destroy(ppdev_class, MKDEV(PP_MAJOR, port->number));
  682. devices[port->number] = NULL;
  683. }
  684. static int pp_probe(struct pardevice *par_dev)
  685. {
  686. struct device_driver *drv = par_dev->dev.driver;
  687. int len = strlen(drv->name);
  688. if (strncmp(par_dev->name, drv->name, len))
  689. return -ENODEV;
  690. return 0;
  691. }
  692. static struct parport_driver pp_driver = {
  693. .name = CHRDEV,
  694. .probe = pp_probe,
  695. .match_port = pp_attach,
  696. .detach = pp_detach,
  697. .devmodel = true,
  698. };
  699. static int __init ppdev_init(void)
  700. {
  701. int err = 0;
  702. if (register_chrdev(PP_MAJOR, CHRDEV, &pp_fops)) {
  703. pr_warn(CHRDEV ": unable to get major %d\n", PP_MAJOR);
  704. return -EIO;
  705. }
  706. ppdev_class = class_create(THIS_MODULE, CHRDEV);
  707. if (IS_ERR(ppdev_class)) {
  708. err = PTR_ERR(ppdev_class);
  709. goto out_chrdev;
  710. }
  711. err = parport_register_driver(&pp_driver);
  712. if (err < 0) {
  713. pr_warn(CHRDEV ": unable to register with parport\n");
  714. goto out_class;
  715. }
  716. pr_info(PP_VERSION "\n");
  717. goto out;
  718. out_class:
  719. class_destroy(ppdev_class);
  720. out_chrdev:
  721. unregister_chrdev(PP_MAJOR, CHRDEV);
  722. out:
  723. return err;
  724. }
  725. static void __exit ppdev_cleanup(void)
  726. {
  727. /* Clean up all parport stuff */
  728. parport_unregister_driver(&pp_driver);
  729. class_destroy(ppdev_class);
  730. unregister_chrdev(PP_MAJOR, CHRDEV);
  731. }
  732. module_init(ppdev_init);
  733. module_exit(ppdev_cleanup);
  734. MODULE_LICENSE("GPL");
  735. MODULE_ALIAS_CHARDEV_MAJOR(PP_MAJOR);