ppdev.c 19 KB

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