开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ppdev.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：18k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

ppdev.c：源码内容
  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 Tim Waugh <tim@cyberelk.demon.co.uk>
  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.  */
  59. #include <linux/module.h>
  60. #include <linux/init.h>
  61. #include <linux/sched.h>
  62. #include <linux/devfs_fs_kernel.h>
  63. #include <linux/ioctl.h>
  64. #include <linux/parport.h>
  65. #include <linux/ctype.h>
  66. #include <linux/poll.h>
  67. #include <asm/uaccess.h>
  68. #include <linux/ppdev.h>
  69. #include <linux/smp_lock.h>
  71. #define PP_VERSION "ppdev: user-space parallel port driver"
  72. #define CHRDEV "ppdev"
  74. struct pp_struct {
  75. struct pardevice * pdev;
  76. wait_queue_head_t irq_wait;
  77. atomic_t irqc;
  78. unsigned int flags;
  79. int irqresponse;
  80. unsigned char irqctl;
  81. struct ieee1284_info state;
  82. struct ieee1284_info saved_state;
  83. };
  85. /* pp_struct.flags bitfields */
  86. #define PP_CLAIMED    (1<<0)
  87. #define PP_EXCL       (1<<1)
  89. /* Other constants */
  90. #define PP_INTERRUPT_TIMEOUT (10 * HZ) /* 10s */
  91. #define PP_BUFFER_SIZE 1024
  92. #define PARDEVICE_MAX 8
  94. /* ROUND_UP macro from fs/select.c */
  95. #define ROUND_UP(x,y) (((x)+(y)-1)/(y))
  97. static inline void pp_enable_irq (struct pp_struct *pp)
  98. {
  99. struct parport *port = pp->pdev->port;
  100. port->ops->enable_irq (port);
  101. }
  103. static ssize_t pp_read (struct file * file, char * buf, size_t count,
  104. loff_t * ppos)
  105. {
  106. unsigned int minor = MINOR (file->f_dentry->d_inode->i_rdev);
  107. struct pp_struct *pp = file->private_data;
  108. char * kbuffer;
  109. ssize_t bytes_read = 0;
  110. ssize_t got = 0;
  111. struct parport *pport;
  112. int mode;
  114. if (!(pp->flags & PP_CLAIMED)) {
  115. /* Don't have the port claimed */
  116. printk (KERN_DEBUG CHRDEV "%x: claim the port firstn",
  117. minor);
  118. return -EINVAL;
  119. }
  121. kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
  122. if (!kbuffer) {
  123. return -ENOMEM;
  124. }
  125. pport = pp->pdev->port;
  126. mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
  128. while (bytes_read < count) {
  129. ssize_t need = min_t(unsigned long, count - bytes_read, 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);
  136. if (pp->flags & PP_W91284PIC) {
  137. flags |= PARPORT_W91284PIC;
  138. }
  139. if (pp->flags & PP_FASTREAD) {
  140. flags |= PARPORT_EPP_FAST;
  141. }
  142. if (pport->ieee1284.mode & IEEE1284_ADDR) {
  143. fn = pport->ops->epp_read_addr;
  144. } else {
  145. fn = pport->ops->epp_read_data;
  146. }
  147. got = (*fn)(pport, kbuffer, need, flags);
  148. } else {
  149. got = parport_read (pport, kbuffer, need);
  150. }
  152. if (got <= 0) {
  153. if (!bytes_read) {
  154. bytes_read = got;
  155. }
  156. break;
  157. }
  159. if (copy_to_user (buf + bytes_read, kbuffer, got)) {
  160. bytes_read = -EFAULT;
  161. break;
  162. }
  164. bytes_read += got;
  166. if (signal_pending (current)) {
  167. if (!bytes_read) {
  168. bytes_read = -EINTR;
  169. }
  170. break;
  171. }
  173. if (current->need_resched) {
  174. schedule ();
  175. }
  176. }
  178. kfree (kbuffer);
  179. pp_enable_irq (pp);
  180. return bytes_read;
  181. }
  183. static ssize_t pp_write (struct file * file, const char * buf, size_t count,
  184.  loff_t * ppos)
  185. {
  186. unsigned int minor = MINOR (file->f_dentry->d_inode->i_rdev);
  187. struct pp_struct *pp = file->private_data;
  188. char * kbuffer;
  189. ssize_t bytes_written = 0;
  190. ssize_t wrote;
  191. int mode;
  192. struct parport *pport;
  194. if (!(pp->flags & PP_CLAIMED)) {
  195. /* Don't have the port claimed */
  196. printk (KERN_DEBUG CHRDEV "%x: claim the port firstn",
  197. minor);
  198. return -EINVAL;
  199. }
  201. kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL);
  202. if (!kbuffer) {
  203. return -ENOMEM;
  204. }
  205. pport = pp->pdev->port;
  206. mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
  208. while (bytes_written < count) {
  209. ssize_t n = min_t(unsigned long, count - bytes_written, PP_BUFFER_SIZE);
  211. if (copy_from_user (kbuffer, buf + bytes_written, n)) {
  212. bytes_written = -EFAULT;
  213. break;
  214. }
  216. if ((pp->flags & PP_FASTWRITE) && (mode == IEEE1284_MODE_EPP)) {
  217. /* do a fast EPP write */
  218. if (pport->ieee1284.mode & IEEE1284_ADDR) {
  219. wrote = pport->ops->epp_write_addr (pport,
  220. kbuffer, n, PARPORT_EPP_FAST);
  221. } else {
  222. wrote = pport->ops->epp_write_data (pport,
  223. kbuffer, n, PARPORT_EPP_FAST);
  224. }
  225. } else {
  226. wrote = parport_write (pp->pdev->port, kbuffer, n);
  227. }
  229. if (wrote <= 0) {
  230. if (!bytes_written) {
  231. bytes_written = wrote;
  232. }
  233. break;
  234. }
  236. bytes_written += wrote;
  238. if (signal_pending (current)) {
  239. if (!bytes_written) {
  240. bytes_written = -EINTR;
  241. }
  242. break;
  243. }
  245. if (current->need_resched) {
  246. schedule ();
  247. }
  248. }
  250. kfree (kbuffer);
  251. pp_enable_irq (pp);
  252. return bytes_written;
  253. }
  255. static void pp_irq (int irq, void * private, struct pt_regs * unused)
  256. {
  257. struct pp_struct * pp = (struct pp_struct *) private;
  259. if (pp->irqresponse) {
  260. parport_write_control (pp->pdev->port, pp->irqctl);
  261. pp->irqresponse = 0;
  262. }
  264. atomic_inc (&pp->irqc);
  265. wake_up_interruptible (&pp->irq_wait);
  266. }
  268. static int register_device (int minor, struct pp_struct *pp)
  269. {
  270. struct parport *port;
  271. struct pardevice * pdev = NULL;
  272. char *name;
  273. int fl;
  275. name = kmalloc (strlen (CHRDEV) + 3, GFP_KERNEL);
  276. if (name == NULL)
  277. return -ENOMEM;
  279. sprintf (name, CHRDEV "%x", minor);
  281. port = parport_find_number (minor);
  282. if (!port) {
  283. printk (KERN_WARNING "%s: no associated port!n", name);
  284. kfree (name);
  285. return -ENXIO;
  286. }
  288. fl = (pp->flags & PP_EXCL) ? PARPORT_FLAG_EXCL : 0;
  289. pdev = parport_register_device (port, name, NULL,
  290. NULL, pp_irq, fl, pp);
  291. parport_put_port (port);
  293. if (!pdev) {
  294. printk (KERN_WARNING "%s: failed to register device!n", name);
  295. kfree (name);
  296. return -ENXIO;
  297. }
  299. pp->pdev = pdev;
  300. printk (KERN_DEBUG "%s: registered pardevicen", name);
  301. return 0;
  302. }
  304. static enum ieee1284_phase init_phase (int mode)
  305. {
  306. switch (mode & ~(IEEE1284_DEVICEID
  307.  | IEEE1284_ADDR)) {
  308. case IEEE1284_MODE_NIBBLE:
  309. case IEEE1284_MODE_BYTE:
  310. return IEEE1284_PH_REV_IDLE;
  311. }
  312. return IEEE1284_PH_FWD_IDLE;
  313. }
  315. static int pp_ioctl(struct inode *inode, struct file *file,
  316.     unsigned int cmd, unsigned long arg)
  317. {
  318. unsigned int minor = MINOR(inode->i_rdev);
  319. struct pp_struct *pp = file->private_data;
  320. struct parport * port;
  322. /* First handle the cases that don't take arguments. */
  323. switch (cmd) {
  324. case PPCLAIM:
  325.     {
  326. struct ieee1284_info *info;
  327. int ret;
  329. if (pp->flags & PP_CLAIMED) {
  330. printk (KERN_DEBUG CHRDEV
  331. "%x: you've already got it!n", minor);
  332. return -EINVAL;
  333. }
  335. /* Deferred device registration. */
  336. if (!pp->pdev) {
  337. int err = register_device (minor, pp);
  338. if (err) {
  339. return err;
  340. }
  341. }
  343. ret = parport_claim_or_block (pp->pdev);
  344. if (ret < 0)
  345. return ret;
  347. pp->flags |= PP_CLAIMED;
  349. /* For interrupt-reporting to work, we need to be
  350.  * informed of each interrupt. */
  351. pp_enable_irq (pp);
  353. /* We may need to fix up the state machine. */
  354. info = &pp->pdev->port->ieee1284;
  355. pp->saved_state.mode = info->mode;
  356. pp->saved_state.phase = info->phase;
  357. info->mode = pp->state.mode;
  358. info->phase = pp->state.phase;
  360. return 0;
  361.     }
  362. case PPEXCL:
  363. if (pp->pdev) {
  364. printk (KERN_DEBUG CHRDEV "%x: too late for PPEXCL; "
  365. "already registeredn", minor);
  366. if (pp->flags & PP_EXCL)
  367. /* But it's not really an error. */
  368. return 0;
  369. /* There's no chance of making the driver happy. */
  370. return -EINVAL;
  371. }
  373. /* Just remember to register the device exclusively
  374.  * when we finally do the registration. */
  375. pp->flags |= PP_EXCL;
  376. return 0;
  377. case PPSETMODE:
  378.     {
  379. int mode;
  380. if (copy_from_user (&mode, (int *) arg, sizeof (mode)))
  381. return -EFAULT;
  382. /* FIXME: validate mode */
  383. pp->state.mode = mode;
  384. pp->state.phase = init_phase (mode);
  386. if (pp->flags & PP_CLAIMED) {
  387. pp->pdev->port->ieee1284.mode = mode;
  388. pp->pdev->port->ieee1284.phase = pp->state.phase;
  389. }
  391. return 0;
  392.     }
  393. case PPGETMODE:
  394.     {
  395. int mode;
  397. if (pp->flags & PP_CLAIMED) {
  398. mode = pp->pdev->port->ieee1284.mode;
  399. } else {
  400. mode = pp->state.mode;
  401. }
  402. if (copy_to_user ((int *)arg, &mode, sizeof (mode))) {
  403. return -EFAULT;
  404. }
  405. return 0;
  406.     }
  407. case PPSETPHASE:
  408.     {
  409. int phase;
  410. if (copy_from_user (&phase, (int *) arg, sizeof (phase))) {
  411. return -EFAULT;
  412. }
  413. /* FIXME: validate phase */
  414. pp->state.phase = phase;
  416. if (pp->flags & PP_CLAIMED) {
  417. pp->pdev->port->ieee1284.phase = phase;
  418. }
  420. return 0;
  421.     }
  422. case PPGETPHASE:
  423.     {
  424. int phase;
  426. if (pp->flags & PP_CLAIMED) {
  427. phase = pp->pdev->port->ieee1284.phase;
  428. } else {
  429. phase = pp->state.phase;
  430. }
  431. if (copy_to_user ((int *)arg, &phase, sizeof (phase))) {
  432. return -EFAULT;
  433. }
  434. return 0;
  435.     }
  436. case PPGETMODES:
  437.     {
  438. unsigned int modes;
  440. port = parport_find_number (minor);
  441. if (!port)
  442. return -ENODEV;
  444. modes = port->modes;
  445. if (copy_to_user ((unsigned int *)arg, &modes, sizeof (modes))) {
  446. return -EFAULT;
  447. }
  448. return 0;
  449.     }
  450. case PPSETFLAGS:
  451.     {
  452. int uflags;
  454. if (copy_from_user (&uflags, (int *)arg, sizeof (uflags))) {
  455. return -EFAULT;
  456. }
  457. pp->flags &= ~PP_FLAGMASK;
  458. pp->flags |= (uflags & PP_FLAGMASK);
  459. return 0;
  460.     }
  461. case PPGETFLAGS:
  462.     {
  463. int uflags;
  465. uflags = pp->flags & PP_FLAGMASK;
  466. if (copy_to_user ((int *)arg, &uflags, sizeof (uflags))) {
  467. return -EFAULT;
  468. }
  469. return 0;
  470.     }
  471. } /* end switch() */
  473. /* Everything else requires the port to be claimed, so check
  474.  * that now. */
  475. if ((pp->flags & PP_CLAIMED) == 0) {
  476. printk (KERN_DEBUG CHRDEV "%x: claim the port firstn",
  477. minor);
  478. return -EINVAL;
  479. }
  481. port = pp->pdev->port;
  482. switch (cmd) {
  483. struct ieee1284_info *info;
  484. unsigned char reg;
  485. unsigned char mask;
  486. int mode;
  487. int ret;
  488. struct timeval par_timeout;
  489. long to_jiffies;
  491. case PPRSTATUS:
  492. reg = parport_read_status (port);
  493. if (copy_to_user ((unsigned char *) arg, &reg, sizeof (reg)))
  494. return -EFAULT;
  495. return 0;
  496. case PPRDATA:
  497. reg = parport_read_data (port);
  498. if (copy_to_user ((unsigned char *) arg, &reg, sizeof (reg)))
  499. return -EFAULT;
  500. return 0;
  501. case PPRCONTROL:
  502. reg = parport_read_control (port);
  503. if (copy_to_user ((unsigned char *) arg, &reg, sizeof (reg)))
  504. return -EFAULT;
  505. return 0;
  506. case PPYIELD:
  507. parport_yield_blocking (pp->pdev);
  508. return 0;
  510. case PPRELEASE:
  511. /* Save the state machine's state. */
  512. info = &pp->pdev->port->ieee1284;
  513. pp->state.mode = info->mode;
  514. pp->state.phase = info->phase;
  515. info->mode = pp->saved_state.mode;
  516. info->phase = pp->saved_state.phase;
  517. parport_release (pp->pdev);
  518. pp->flags &= ~PP_CLAIMED;
  519. return 0;
  521. case PPWCONTROL:
  522. if (copy_from_user (&reg, (unsigned char *) arg, sizeof (reg)))
  523. return -EFAULT;
  524. parport_write_control (port, reg);
  525. return 0;
  527. case PPWDATA:
  528. if (copy_from_user (&reg, (unsigned char *) arg, sizeof (reg)))
  529. return -EFAULT;
  530. parport_write_data (port, reg);
  531. return 0;
  533. case PPFCONTROL:
  534. if (copy_from_user (&mask, (unsigned char *) arg,
  535.     sizeof (mask)))
  536. return -EFAULT;
  537. if (copy_from_user (&reg, 1 + (unsigned char *) arg,
  538.     sizeof (reg)))
  539. return -EFAULT;
  540. parport_frob_control (port, mask, reg);
  541. return 0;
  543. case PPDATADIR:
  544. if (copy_from_user (&mode, (int *) arg, sizeof (mode)))
  545. return -EFAULT;
  546. if (mode)
  547. port->ops->data_reverse (port);
  548. else
  549. port->ops->data_forward (port);
  550. return 0;
  552. case PPNEGOT:
  553. if (copy_from_user (&mode, (int *) arg, sizeof (mode)))
  554. return -EFAULT;
  555. switch ((ret = parport_negotiate (port, mode))) {
  556. case 0: break;
  557. case -1: /* handshake failed, peripheral not IEEE 1284 */
  558. ret = -EIO;
  559. break;
  560. case 1:  /* handshake succeeded, peripheral rejected mode */
  561. ret = -ENXIO;
  562. break;
  563. }
  564. pp_enable_irq (pp);
  565. return ret;
  567. case PPWCTLONIRQ:
  568. if (copy_from_user (&reg, (unsigned char *) arg,
  569.     sizeof (reg)))
  570. return -EFAULT;
  572. /* Remember what to set the control lines to, for next
  573.  * time we get an interrupt. */
  574. pp->irqctl = reg;
  575. pp->irqresponse = 1;
  576. return 0;
  578. case PPCLRIRQ:
  579. ret = atomic_read (&pp->irqc);
  580. if (copy_to_user ((int *) arg, &ret, sizeof (ret)))
  581. return -EFAULT;
  582. atomic_sub (ret, &pp->irqc);
  583. return 0;
  585. case PPSETTIME:
  586. if (copy_from_user (&par_timeout, (struct timeval *)arg,
  587.     sizeof(struct timeval))) {
  588. return -EFAULT;
  589. }
  590. /* Convert to jiffies, place in pp->pdev->timeout */
  591. if ((par_timeout.tv_sec < 0) || (par_timeout.tv_usec < 0)) {
  592. return -EINVAL;
  593. }
  594. to_jiffies = ROUND_UP(par_timeout.tv_usec, 1000000/HZ);
  595. to_jiffies += par_timeout.tv_sec * (long)HZ;
  596. if (to_jiffies <= 0) {
  597. return -EINVAL;
  598. }
  599. pp->pdev->timeout = to_jiffies;
  600. return 0;
  602. case PPGETTIME:
  603. to_jiffies = pp->pdev->timeout;
  604. par_timeout.tv_sec = to_jiffies / HZ;
  605. par_timeout.tv_usec = (to_jiffies % (long)HZ) * (1000000/HZ);
  606. if (copy_to_user ((struct timeval *)arg, &par_timeout,
  607.   sizeof(struct timeval))) {
  608. return -EFAULT;
  609. }
  610. return 0;
  612. default:
  613. printk (KERN_DEBUG CHRDEV "%x: What? (cmd=0x%x)n", minor,
  614. cmd);
  615. return -EINVAL;
  616. }
  618. /* Keep the compiler happy */
  619. return 0;
  620. }
  622. static int pp_open (struct inode * inode, struct file * file)
  623. {
  624. unsigned int minor = MINOR (inode->i_rdev);
  625. struct pp_struct *pp;
  627. if (minor >= PARPORT_MAX)
  628. return -ENXIO;
  630. pp = kmalloc (sizeof (struct pp_struct), GFP_KERNEL);
  631. if (!pp)
  632. return -ENOMEM;
  634. pp->state.mode = IEEE1284_MODE_COMPAT;
  635. pp->state.phase = init_phase (pp->state.mode);
  636. pp->flags = 0;
  637. pp->irqresponse = 0;
  638. atomic_set (&pp->irqc, 0);
  639. init_waitqueue_head (&pp->irq_wait);
  641. /* Defer the actual device registration until the first claim.
  642.  * That way, we know whether or not the driver wants to have
  643.  * exclusive access to the port (PPEXCL).
  644.  */
  645. pp->pdev = NULL;
  646. file->private_data = pp;
  648. return 0;
  649. }
  651. static int pp_release (struct inode * inode, struct file * file)
  652. {
  653. unsigned int minor = MINOR (inode->i_rdev);
  654. struct pp_struct *pp = file->private_data;
  655. int compat_negot;
  657. lock_kernel();
  658. compat_negot = 0;
  659. if (!(pp->flags & PP_CLAIMED) && pp->pdev &&
  660.     (pp->state.mode != IEEE1284_MODE_COMPAT)) {
  661.      struct ieee1284_info *info;
  663. /* parport released, but not in compatability mode */
  664. parport_claim_or_block (pp->pdev);
  665. pp->flags |= PP_CLAIMED;
  666. info = &pp->pdev->port->ieee1284;
  667. pp->saved_state.mode = info->mode;
  668. pp->saved_state.phase = info->phase;
  669. info->mode = pp->state.mode;
  670. info->phase = pp->state.phase;
  671. compat_negot = 1;
  672. } else if ((pp->flags & PP_CLAIMED) && pp->pdev &&
  673.     (pp->pdev->port->ieee1284.mode != IEEE1284_MODE_COMPAT)) {
  674. compat_negot = 2;
  675. }
  676. if (compat_negot) {
  677. parport_negotiate (pp->pdev->port, IEEE1284_MODE_COMPAT);
  678. printk (KERN_DEBUG CHRDEV
  679. "%x: negotiated back to compatibility mode because "
  680. "user-space forgotn", minor);
  681. }
  683. if (pp->flags & PP_CLAIMED) {
  684. struct ieee1284_info *info;
  686. info = &pp->pdev->port->ieee1284;
  687. pp->state.mode = info->mode;
  688. pp->state.phase = info->phase;
  689. info->mode = pp->saved_state.mode;
  690. info->phase = pp->saved_state.phase;
  691. parport_release (pp->pdev);
  692. if (compat_negot != 1) {
  693. printk (KERN_DEBUG CHRDEV "%x: released pardevice "
  694. "because user-space forgotn", minor);
  695. }
  696. }
  698. if (pp->pdev) {
  699. const char *name = pp->pdev->name;
  700. parport_unregister_device (pp->pdev);
  701. kfree (name);
  702. pp->pdev = NULL;
  703. printk (KERN_DEBUG CHRDEV "%x: unregistered pardevicen",
  704. minor);
  705. }
  706. unlock_kernel();
  708. kfree (pp);
  710. return 0;
  711. }
  713. /* No kernel lock held - fine */
  714. static unsigned int pp_poll (struct file * file, poll_table * wait)
  715. {
  716. struct pp_struct *pp = file->private_data;
  717. unsigned int mask = 0;
  719. poll_wait (file, &pp->irq_wait, wait);
  720. if (atomic_read (&pp->irqc))
  721. mask |= POLLIN | POLLRDNORM;
  723. return mask;
  724. }
  726. static struct file_operations pp_fops = {
  727. owner: THIS_MODULE,
  728. llseek: no_llseek,
  729. read: pp_read,
  730. write: pp_write,
  731. poll: pp_poll,
  732. ioctl: pp_ioctl,
  733. open: pp_open,
  734. release: pp_release,
  735. };
  737. static devfs_handle_t devfs_handle;
  739. static int __init ppdev_init (void)
  740. {
  741. if (devfs_register_chrdev (PP_MAJOR, CHRDEV, &pp_fops)) {
  742. printk (KERN_WARNING CHRDEV ": unable to get major %dn",
  743. PP_MAJOR);
  744. return -EIO;
  745. }
  746. devfs_handle = devfs_mk_dir (NULL, "parports", NULL);
  747. devfs_register_series (devfs_handle, "%u", PARPORT_MAX,
  748.        DEVFS_FL_DEFAULT, PP_MAJOR, 0,
  749.        S_IFCHR | S_IRUGO | S_IWUGO,
  750.        &pp_fops, NULL);
  752. printk (KERN_INFO PP_VERSION "n");
  753. return 0;
  754. }
  756. static void __exit ppdev_cleanup (void)
  757. {
  758. /* Clean up all parport stuff */
  759. devfs_unregister (devfs_handle);
  760. devfs_unregister_chrdev (PP_MAJOR, CHRDEV);
  761. }
  763. module_init(ppdev_init);
  764. module_exit(ppdev_cleanup);
  766. MODULE_LICENSE("GPL");
  768. EXPORT_NO_SYMBOLS;