Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
| 59 | #include <linux/module.h> |
| 60 | #include <linux/init.h> |
| 61 | #include <linux/sched.h> |
| 62 | #include <linux/device.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | #include <linux/ioctl.h> |
| 64 | #include <linux/parport.h> |
| 65 | #include <linux/ctype.h> |
| 66 | #include <linux/poll.h> |
Rene Herman | e6a6784 | 2006-03-25 03:07:13 -0800 | [diff] [blame] | 67 | #include <linux/major.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | #include <linux/ppdev.h> |
| 69 | #include <linux/smp_lock.h> |
| 70 | #include <linux/device.h> |
Rene Herman | e6a6784 | 2006-03-25 03:07:13 -0800 | [diff] [blame] | 71 | #include <asm/uaccess.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | |
| 73 | #define PP_VERSION "ppdev: user-space parallel port driver" |
| 74 | #define CHRDEV "ppdev" |
| 75 | |
| 76 | struct pp_struct { |
| 77 | struct pardevice * pdev; |
| 78 | wait_queue_head_t irq_wait; |
| 79 | atomic_t irqc; |
| 80 | unsigned int flags; |
| 81 | int irqresponse; |
| 82 | unsigned char irqctl; |
| 83 | struct ieee1284_info state; |
| 84 | struct ieee1284_info saved_state; |
| 85 | long default_inactivity; |
| 86 | }; |
| 87 | |
| 88 | /* pp_struct.flags bitfields */ |
| 89 | #define PP_CLAIMED (1<<0) |
| 90 | #define PP_EXCL (1<<1) |
| 91 | |
| 92 | /* Other constants */ |
| 93 | #define PP_INTERRUPT_TIMEOUT (10 * HZ) /* 10s */ |
| 94 | #define PP_BUFFER_SIZE 1024 |
| 95 | #define PARDEVICE_MAX 8 |
| 96 | |
| 97 | /* ROUND_UP macro from fs/select.c */ |
| 98 | #define ROUND_UP(x,y) (((x)+(y)-1)/(y)) |
| 99 | |
| 100 | static inline void pp_enable_irq (struct pp_struct *pp) |
| 101 | { |
| 102 | struct parport *port = pp->pdev->port; |
| 103 | port->ops->enable_irq (port); |
| 104 | } |
| 105 | |
| 106 | static ssize_t pp_read (struct file * file, char __user * buf, size_t count, |
| 107 | loff_t * ppos) |
| 108 | { |
| 109 | unsigned int minor = iminor(file->f_dentry->d_inode); |
| 110 | struct pp_struct *pp = file->private_data; |
| 111 | char * kbuffer; |
| 112 | ssize_t bytes_read = 0; |
| 113 | struct parport *pport; |
| 114 | int mode; |
| 115 | |
| 116 | if (!(pp->flags & PP_CLAIMED)) { |
| 117 | /* Don't have the port claimed */ |
| 118 | printk (KERN_DEBUG CHRDEV "%x: claim the port first\n", |
| 119 | minor); |
| 120 | return -EINVAL; |
| 121 | } |
| 122 | |
| 123 | /* Trivial case. */ |
| 124 | if (count == 0) |
| 125 | return 0; |
| 126 | |
| 127 | kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL); |
| 128 | if (!kbuffer) { |
| 129 | return -ENOMEM; |
| 130 | } |
| 131 | pport = pp->pdev->port; |
| 132 | mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR); |
| 133 | |
| 134 | parport_set_timeout (pp->pdev, |
| 135 | (file->f_flags & O_NONBLOCK) ? |
| 136 | PARPORT_INACTIVITY_O_NONBLOCK : |
| 137 | pp->default_inactivity); |
| 138 | |
| 139 | while (bytes_read == 0) { |
| 140 | ssize_t need = min_t(unsigned long, count, PP_BUFFER_SIZE); |
| 141 | |
| 142 | if (mode == IEEE1284_MODE_EPP) { |
| 143 | /* various specials for EPP mode */ |
| 144 | int flags = 0; |
| 145 | size_t (*fn)(struct parport *, void *, size_t, int); |
| 146 | |
| 147 | if (pp->flags & PP_W91284PIC) { |
| 148 | flags |= PARPORT_W91284PIC; |
| 149 | } |
| 150 | if (pp->flags & PP_FASTREAD) { |
| 151 | flags |= PARPORT_EPP_FAST; |
| 152 | } |
| 153 | if (pport->ieee1284.mode & IEEE1284_ADDR) { |
| 154 | fn = pport->ops->epp_read_addr; |
| 155 | } else { |
| 156 | fn = pport->ops->epp_read_data; |
| 157 | } |
| 158 | bytes_read = (*fn)(pport, kbuffer, need, flags); |
| 159 | } else { |
| 160 | bytes_read = parport_read (pport, kbuffer, need); |
| 161 | } |
| 162 | |
| 163 | if (bytes_read != 0) |
| 164 | break; |
| 165 | |
| 166 | if (file->f_flags & O_NONBLOCK) { |
| 167 | bytes_read = -EAGAIN; |
| 168 | break; |
| 169 | } |
| 170 | |
| 171 | if (signal_pending (current)) { |
| 172 | bytes_read = -ERESTARTSYS; |
| 173 | break; |
| 174 | } |
| 175 | |
| 176 | cond_resched(); |
| 177 | } |
| 178 | |
| 179 | parport_set_timeout (pp->pdev, pp->default_inactivity); |
| 180 | |
| 181 | if (bytes_read > 0 && copy_to_user (buf, kbuffer, bytes_read)) |
| 182 | bytes_read = -EFAULT; |
| 183 | |
| 184 | kfree (kbuffer); |
| 185 | pp_enable_irq (pp); |
| 186 | return bytes_read; |
| 187 | } |
| 188 | |
| 189 | static ssize_t pp_write (struct file * file, const char __user * buf, |
| 190 | size_t count, loff_t * ppos) |
| 191 | { |
| 192 | unsigned int minor = iminor(file->f_dentry->d_inode); |
| 193 | struct pp_struct *pp = file->private_data; |
| 194 | char * kbuffer; |
| 195 | ssize_t bytes_written = 0; |
| 196 | ssize_t wrote; |
| 197 | int mode; |
| 198 | struct parport *pport; |
| 199 | |
| 200 | if (!(pp->flags & PP_CLAIMED)) { |
| 201 | /* Don't have the port claimed */ |
| 202 | printk (KERN_DEBUG CHRDEV "%x: claim the port first\n", |
| 203 | minor); |
| 204 | return -EINVAL; |
| 205 | } |
| 206 | |
| 207 | kbuffer = kmalloc(min_t(size_t, count, PP_BUFFER_SIZE), GFP_KERNEL); |
| 208 | if (!kbuffer) { |
| 209 | return -ENOMEM; |
| 210 | } |
| 211 | pport = pp->pdev->port; |
| 212 | mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR); |
| 213 | |
| 214 | parport_set_timeout (pp->pdev, |
| 215 | (file->f_flags & O_NONBLOCK) ? |
| 216 | PARPORT_INACTIVITY_O_NONBLOCK : |
| 217 | pp->default_inactivity); |
| 218 | |
| 219 | while (bytes_written < count) { |
| 220 | ssize_t n = min_t(unsigned long, count - bytes_written, PP_BUFFER_SIZE); |
| 221 | |
| 222 | if (copy_from_user (kbuffer, buf + bytes_written, n)) { |
| 223 | bytes_written = -EFAULT; |
| 224 | break; |
| 225 | } |
| 226 | |
| 227 | if ((pp->flags & PP_FASTWRITE) && (mode == IEEE1284_MODE_EPP)) { |
| 228 | /* do a fast EPP write */ |
| 229 | if (pport->ieee1284.mode & IEEE1284_ADDR) { |
| 230 | wrote = pport->ops->epp_write_addr (pport, |
| 231 | kbuffer, n, PARPORT_EPP_FAST); |
| 232 | } else { |
| 233 | wrote = pport->ops->epp_write_data (pport, |
| 234 | kbuffer, n, PARPORT_EPP_FAST); |
| 235 | } |
| 236 | } else { |
| 237 | wrote = parport_write (pp->pdev->port, kbuffer, n); |
| 238 | } |
| 239 | |
| 240 | if (wrote <= 0) { |
| 241 | if (!bytes_written) { |
| 242 | bytes_written = wrote; |
| 243 | } |
| 244 | break; |
| 245 | } |
| 246 | |
| 247 | bytes_written += wrote; |
| 248 | |
| 249 | if (file->f_flags & O_NONBLOCK) { |
| 250 | if (!bytes_written) |
| 251 | bytes_written = -EAGAIN; |
| 252 | break; |
| 253 | } |
| 254 | |
| 255 | if (signal_pending (current)) { |
| 256 | if (!bytes_written) { |
| 257 | bytes_written = -EINTR; |
| 258 | } |
| 259 | break; |
| 260 | } |
| 261 | |
| 262 | cond_resched(); |
| 263 | } |
| 264 | |
| 265 | parport_set_timeout (pp->pdev, pp->default_inactivity); |
| 266 | |
| 267 | kfree (kbuffer); |
| 268 | pp_enable_irq (pp); |
| 269 | return bytes_written; |
| 270 | } |
| 271 | |
| 272 | static void pp_irq (int irq, void * private, struct pt_regs * unused) |
| 273 | { |
| 274 | struct pp_struct * pp = (struct pp_struct *) private; |
| 275 | |
| 276 | if (pp->irqresponse) { |
| 277 | parport_write_control (pp->pdev->port, pp->irqctl); |
| 278 | pp->irqresponse = 0; |
| 279 | } |
| 280 | |
| 281 | atomic_inc (&pp->irqc); |
| 282 | wake_up_interruptible (&pp->irq_wait); |
| 283 | } |
| 284 | |
| 285 | static int register_device (int minor, struct pp_struct *pp) |
| 286 | { |
| 287 | struct parport *port; |
| 288 | struct pardevice * pdev = NULL; |
| 289 | char *name; |
| 290 | int fl; |
| 291 | |
| 292 | name = kmalloc (strlen (CHRDEV) + 3, GFP_KERNEL); |
| 293 | if (name == NULL) |
| 294 | return -ENOMEM; |
| 295 | |
| 296 | sprintf (name, CHRDEV "%x", minor); |
| 297 | |
| 298 | port = parport_find_number (minor); |
| 299 | if (!port) { |
| 300 | printk (KERN_WARNING "%s: no associated port!\n", name); |
| 301 | kfree (name); |
| 302 | return -ENXIO; |
| 303 | } |
| 304 | |
| 305 | fl = (pp->flags & PP_EXCL) ? PARPORT_FLAG_EXCL : 0; |
| 306 | pdev = parport_register_device (port, name, NULL, |
| 307 | NULL, pp_irq, fl, pp); |
| 308 | parport_put_port (port); |
| 309 | |
| 310 | if (!pdev) { |
| 311 | printk (KERN_WARNING "%s: failed to register device!\n", name); |
| 312 | kfree (name); |
| 313 | return -ENXIO; |
| 314 | } |
| 315 | |
| 316 | pp->pdev = pdev; |
| 317 | printk (KERN_DEBUG "%s: registered pardevice\n", name); |
| 318 | return 0; |
| 319 | } |
| 320 | |
| 321 | static enum ieee1284_phase init_phase (int mode) |
| 322 | { |
| 323 | switch (mode & ~(IEEE1284_DEVICEID |
| 324 | | IEEE1284_ADDR)) { |
| 325 | case IEEE1284_MODE_NIBBLE: |
| 326 | case IEEE1284_MODE_BYTE: |
| 327 | return IEEE1284_PH_REV_IDLE; |
| 328 | } |
| 329 | return IEEE1284_PH_FWD_IDLE; |
| 330 | } |
| 331 | |
| 332 | static int pp_ioctl(struct inode *inode, struct file *file, |
| 333 | unsigned int cmd, unsigned long arg) |
| 334 | { |
| 335 | unsigned int minor = iminor(inode); |
| 336 | struct pp_struct *pp = file->private_data; |
| 337 | struct parport * port; |
| 338 | void __user *argp = (void __user *)arg; |
| 339 | |
| 340 | /* First handle the cases that don't take arguments. */ |
| 341 | switch (cmd) { |
| 342 | case PPCLAIM: |
| 343 | { |
| 344 | struct ieee1284_info *info; |
| 345 | int ret; |
| 346 | |
| 347 | if (pp->flags & PP_CLAIMED) { |
| 348 | printk (KERN_DEBUG CHRDEV |
| 349 | "%x: you've already got it!\n", minor); |
| 350 | return -EINVAL; |
| 351 | } |
| 352 | |
| 353 | /* Deferred device registration. */ |
| 354 | if (!pp->pdev) { |
| 355 | int err = register_device (minor, pp); |
| 356 | if (err) { |
| 357 | return err; |
| 358 | } |
| 359 | } |
| 360 | |
| 361 | ret = parport_claim_or_block (pp->pdev); |
| 362 | if (ret < 0) |
| 363 | return ret; |
| 364 | |
| 365 | pp->flags |= PP_CLAIMED; |
| 366 | |
| 367 | /* For interrupt-reporting to work, we need to be |
| 368 | * informed of each interrupt. */ |
| 369 | pp_enable_irq (pp); |
| 370 | |
| 371 | /* We may need to fix up the state machine. */ |
| 372 | info = &pp->pdev->port->ieee1284; |
| 373 | pp->saved_state.mode = info->mode; |
| 374 | pp->saved_state.phase = info->phase; |
| 375 | info->mode = pp->state.mode; |
| 376 | info->phase = pp->state.phase; |
| 377 | pp->default_inactivity = parport_set_timeout (pp->pdev, 0); |
| 378 | parport_set_timeout (pp->pdev, pp->default_inactivity); |
| 379 | |
| 380 | return 0; |
| 381 | } |
| 382 | case PPEXCL: |
| 383 | if (pp->pdev) { |
| 384 | printk (KERN_DEBUG CHRDEV "%x: too late for PPEXCL; " |
| 385 | "already registered\n", minor); |
| 386 | if (pp->flags & PP_EXCL) |
| 387 | /* But it's not really an error. */ |
| 388 | return 0; |
| 389 | /* There's no chance of making the driver happy. */ |
| 390 | return -EINVAL; |
| 391 | } |
| 392 | |
| 393 | /* Just remember to register the device exclusively |
| 394 | * when we finally do the registration. */ |
| 395 | pp->flags |= PP_EXCL; |
| 396 | return 0; |
| 397 | case PPSETMODE: |
| 398 | { |
| 399 | int mode; |
| 400 | if (copy_from_user (&mode, argp, sizeof (mode))) |
| 401 | return -EFAULT; |
| 402 | /* FIXME: validate mode */ |
| 403 | pp->state.mode = mode; |
| 404 | pp->state.phase = init_phase (mode); |
| 405 | |
| 406 | if (pp->flags & PP_CLAIMED) { |
| 407 | pp->pdev->port->ieee1284.mode = mode; |
| 408 | pp->pdev->port->ieee1284.phase = pp->state.phase; |
| 409 | } |
| 410 | |
| 411 | return 0; |
| 412 | } |
| 413 | case PPGETMODE: |
| 414 | { |
| 415 | int mode; |
| 416 | |
| 417 | if (pp->flags & PP_CLAIMED) { |
| 418 | mode = pp->pdev->port->ieee1284.mode; |
| 419 | } else { |
| 420 | mode = pp->state.mode; |
| 421 | } |
| 422 | if (copy_to_user (argp, &mode, sizeof (mode))) { |
| 423 | return -EFAULT; |
| 424 | } |
| 425 | return 0; |
| 426 | } |
| 427 | case PPSETPHASE: |
| 428 | { |
| 429 | int phase; |
| 430 | if (copy_from_user (&phase, argp, sizeof (phase))) { |
| 431 | return -EFAULT; |
| 432 | } |
| 433 | /* FIXME: validate phase */ |
| 434 | pp->state.phase = phase; |
| 435 | |
| 436 | if (pp->flags & PP_CLAIMED) { |
| 437 | pp->pdev->port->ieee1284.phase = phase; |
| 438 | } |
| 439 | |
| 440 | return 0; |
| 441 | } |
| 442 | case PPGETPHASE: |
| 443 | { |
| 444 | int phase; |
| 445 | |
| 446 | if (pp->flags & PP_CLAIMED) { |
| 447 | phase = pp->pdev->port->ieee1284.phase; |
| 448 | } else { |
| 449 | phase = pp->state.phase; |
| 450 | } |
| 451 | if (copy_to_user (argp, &phase, sizeof (phase))) { |
| 452 | return -EFAULT; |
| 453 | } |
| 454 | return 0; |
| 455 | } |
| 456 | case PPGETMODES: |
| 457 | { |
| 458 | unsigned int modes; |
| 459 | |
| 460 | port = parport_find_number (minor); |
| 461 | if (!port) |
| 462 | return -ENODEV; |
| 463 | |
| 464 | modes = port->modes; |
| 465 | if (copy_to_user (argp, &modes, sizeof (modes))) { |
| 466 | return -EFAULT; |
| 467 | } |
| 468 | return 0; |
| 469 | } |
| 470 | case PPSETFLAGS: |
| 471 | { |
| 472 | int uflags; |
| 473 | |
| 474 | if (copy_from_user (&uflags, argp, sizeof (uflags))) { |
| 475 | return -EFAULT; |
| 476 | } |
| 477 | pp->flags &= ~PP_FLAGMASK; |
| 478 | pp->flags |= (uflags & PP_FLAGMASK); |
| 479 | return 0; |
| 480 | } |
| 481 | case PPGETFLAGS: |
| 482 | { |
| 483 | int uflags; |
| 484 | |
| 485 | uflags = pp->flags & PP_FLAGMASK; |
| 486 | if (copy_to_user (argp, &uflags, sizeof (uflags))) { |
| 487 | return -EFAULT; |
| 488 | } |
| 489 | return 0; |
| 490 | } |
| 491 | } /* end switch() */ |
| 492 | |
| 493 | /* Everything else requires the port to be claimed, so check |
| 494 | * that now. */ |
| 495 | if ((pp->flags & PP_CLAIMED) == 0) { |
| 496 | printk (KERN_DEBUG CHRDEV "%x: claim the port first\n", |
| 497 | minor); |
| 498 | return -EINVAL; |
| 499 | } |
| 500 | |
| 501 | port = pp->pdev->port; |
| 502 | switch (cmd) { |
| 503 | struct ieee1284_info *info; |
| 504 | unsigned char reg; |
| 505 | unsigned char mask; |
| 506 | int mode; |
| 507 | int ret; |
| 508 | struct timeval par_timeout; |
| 509 | long to_jiffies; |
| 510 | |
| 511 | case PPRSTATUS: |
| 512 | reg = parport_read_status (port); |
| 513 | if (copy_to_user (argp, ®, sizeof (reg))) |
| 514 | return -EFAULT; |
| 515 | return 0; |
| 516 | case PPRDATA: |
| 517 | reg = parport_read_data (port); |
| 518 | if (copy_to_user (argp, ®, sizeof (reg))) |
| 519 | return -EFAULT; |
| 520 | return 0; |
| 521 | case PPRCONTROL: |
| 522 | reg = parport_read_control (port); |
| 523 | if (copy_to_user (argp, ®, sizeof (reg))) |
| 524 | return -EFAULT; |
| 525 | return 0; |
| 526 | case PPYIELD: |
| 527 | parport_yield_blocking (pp->pdev); |
| 528 | return 0; |
| 529 | |
| 530 | case PPRELEASE: |
| 531 | /* Save the state machine's state. */ |
| 532 | info = &pp->pdev->port->ieee1284; |
| 533 | pp->state.mode = info->mode; |
| 534 | pp->state.phase = info->phase; |
| 535 | info->mode = pp->saved_state.mode; |
| 536 | info->phase = pp->saved_state.phase; |
| 537 | parport_release (pp->pdev); |
| 538 | pp->flags &= ~PP_CLAIMED; |
| 539 | return 0; |
| 540 | |
| 541 | case PPWCONTROL: |
| 542 | if (copy_from_user (®, argp, sizeof (reg))) |
| 543 | return -EFAULT; |
| 544 | parport_write_control (port, reg); |
| 545 | return 0; |
| 546 | |
| 547 | case PPWDATA: |
| 548 | if (copy_from_user (®, argp, sizeof (reg))) |
| 549 | return -EFAULT; |
| 550 | parport_write_data (port, reg); |
| 551 | return 0; |
| 552 | |
| 553 | case PPFCONTROL: |
| 554 | if (copy_from_user (&mask, argp, |
| 555 | sizeof (mask))) |
| 556 | return -EFAULT; |
| 557 | if (copy_from_user (®, 1 + (unsigned char __user *) arg, |
| 558 | sizeof (reg))) |
| 559 | return -EFAULT; |
| 560 | parport_frob_control (port, mask, reg); |
| 561 | return 0; |
| 562 | |
| 563 | case PPDATADIR: |
| 564 | if (copy_from_user (&mode, argp, sizeof (mode))) |
| 565 | return -EFAULT; |
| 566 | if (mode) |
| 567 | port->ops->data_reverse (port); |
| 568 | else |
| 569 | port->ops->data_forward (port); |
| 570 | return 0; |
| 571 | |
| 572 | case PPNEGOT: |
| 573 | if (copy_from_user (&mode, argp, sizeof (mode))) |
| 574 | return -EFAULT; |
| 575 | switch ((ret = parport_negotiate (port, mode))) { |
| 576 | case 0: break; |
| 577 | case -1: /* handshake failed, peripheral not IEEE 1284 */ |
| 578 | ret = -EIO; |
| 579 | break; |
| 580 | case 1: /* handshake succeeded, peripheral rejected mode */ |
| 581 | ret = -ENXIO; |
| 582 | break; |
| 583 | } |
| 584 | pp_enable_irq (pp); |
| 585 | return ret; |
| 586 | |
| 587 | case PPWCTLONIRQ: |
| 588 | if (copy_from_user (®, argp, sizeof (reg))) |
| 589 | return -EFAULT; |
| 590 | |
| 591 | /* Remember what to set the control lines to, for next |
| 592 | * time we get an interrupt. */ |
| 593 | pp->irqctl = reg; |
| 594 | pp->irqresponse = 1; |
| 595 | return 0; |
| 596 | |
| 597 | case PPCLRIRQ: |
| 598 | ret = atomic_read (&pp->irqc); |
| 599 | if (copy_to_user (argp, &ret, sizeof (ret))) |
| 600 | return -EFAULT; |
| 601 | atomic_sub (ret, &pp->irqc); |
| 602 | return 0; |
| 603 | |
| 604 | case PPSETTIME: |
| 605 | if (copy_from_user (&par_timeout, argp, sizeof(struct timeval))) { |
| 606 | return -EFAULT; |
| 607 | } |
| 608 | /* Convert to jiffies, place in pp->pdev->timeout */ |
| 609 | if ((par_timeout.tv_sec < 0) || (par_timeout.tv_usec < 0)) { |
| 610 | return -EINVAL; |
| 611 | } |
| 612 | to_jiffies = ROUND_UP(par_timeout.tv_usec, 1000000/HZ); |
| 613 | to_jiffies += par_timeout.tv_sec * (long)HZ; |
| 614 | if (to_jiffies <= 0) { |
| 615 | return -EINVAL; |
| 616 | } |
| 617 | pp->pdev->timeout = to_jiffies; |
| 618 | return 0; |
| 619 | |
| 620 | case PPGETTIME: |
| 621 | to_jiffies = pp->pdev->timeout; |
| 622 | par_timeout.tv_sec = to_jiffies / HZ; |
| 623 | par_timeout.tv_usec = (to_jiffies % (long)HZ) * (1000000/HZ); |
| 624 | if (copy_to_user (argp, &par_timeout, sizeof(struct timeval))) |
| 625 | return -EFAULT; |
| 626 | return 0; |
| 627 | |
| 628 | default: |
| 629 | printk (KERN_DEBUG CHRDEV "%x: What? (cmd=0x%x)\n", minor, |
| 630 | cmd); |
| 631 | return -EINVAL; |
| 632 | } |
| 633 | |
| 634 | /* Keep the compiler happy */ |
| 635 | return 0; |
| 636 | } |
| 637 | |
| 638 | static int pp_open (struct inode * inode, struct file * file) |
| 639 | { |
| 640 | unsigned int minor = iminor(inode); |
| 641 | struct pp_struct *pp; |
| 642 | |
| 643 | if (minor >= PARPORT_MAX) |
| 644 | return -ENXIO; |
| 645 | |
| 646 | pp = kmalloc (sizeof (struct pp_struct), GFP_KERNEL); |
| 647 | if (!pp) |
| 648 | return -ENOMEM; |
| 649 | |
| 650 | pp->state.mode = IEEE1284_MODE_COMPAT; |
| 651 | pp->state.phase = init_phase (pp->state.mode); |
| 652 | pp->flags = 0; |
| 653 | pp->irqresponse = 0; |
| 654 | atomic_set (&pp->irqc, 0); |
| 655 | init_waitqueue_head (&pp->irq_wait); |
| 656 | |
| 657 | /* Defer the actual device registration until the first claim. |
| 658 | * That way, we know whether or not the driver wants to have |
| 659 | * exclusive access to the port (PPEXCL). |
| 660 | */ |
| 661 | pp->pdev = NULL; |
| 662 | file->private_data = pp; |
| 663 | |
| 664 | return 0; |
| 665 | } |
| 666 | |
| 667 | static int pp_release (struct inode * inode, struct file * file) |
| 668 | { |
| 669 | unsigned int minor = iminor(inode); |
| 670 | struct pp_struct *pp = file->private_data; |
| 671 | int compat_negot; |
| 672 | |
| 673 | compat_negot = 0; |
| 674 | if (!(pp->flags & PP_CLAIMED) && pp->pdev && |
| 675 | (pp->state.mode != IEEE1284_MODE_COMPAT)) { |
| 676 | struct ieee1284_info *info; |
| 677 | |
| 678 | /* parport released, but not in compatibility mode */ |
| 679 | parport_claim_or_block (pp->pdev); |
| 680 | pp->flags |= PP_CLAIMED; |
| 681 | info = &pp->pdev->port->ieee1284; |
| 682 | pp->saved_state.mode = info->mode; |
| 683 | pp->saved_state.phase = info->phase; |
| 684 | info->mode = pp->state.mode; |
| 685 | info->phase = pp->state.phase; |
| 686 | compat_negot = 1; |
| 687 | } else if ((pp->flags & PP_CLAIMED) && pp->pdev && |
| 688 | (pp->pdev->port->ieee1284.mode != IEEE1284_MODE_COMPAT)) { |
| 689 | compat_negot = 2; |
| 690 | } |
| 691 | if (compat_negot) { |
| 692 | parport_negotiate (pp->pdev->port, IEEE1284_MODE_COMPAT); |
| 693 | printk (KERN_DEBUG CHRDEV |
| 694 | "%x: negotiated back to compatibility mode because " |
| 695 | "user-space forgot\n", minor); |
| 696 | } |
| 697 | |
| 698 | if (pp->flags & PP_CLAIMED) { |
| 699 | struct ieee1284_info *info; |
| 700 | |
| 701 | info = &pp->pdev->port->ieee1284; |
| 702 | pp->state.mode = info->mode; |
| 703 | pp->state.phase = info->phase; |
| 704 | info->mode = pp->saved_state.mode; |
| 705 | info->phase = pp->saved_state.phase; |
| 706 | parport_release (pp->pdev); |
| 707 | if (compat_negot != 1) { |
| 708 | printk (KERN_DEBUG CHRDEV "%x: released pardevice " |
| 709 | "because user-space forgot\n", minor); |
| 710 | } |
| 711 | } |
| 712 | |
| 713 | if (pp->pdev) { |
| 714 | const char *name = pp->pdev->name; |
| 715 | parport_unregister_device (pp->pdev); |
| 716 | kfree (name); |
| 717 | pp->pdev = NULL; |
| 718 | printk (KERN_DEBUG CHRDEV "%x: unregistered pardevice\n", |
| 719 | minor); |
| 720 | } |
| 721 | |
| 722 | kfree (pp); |
| 723 | |
| 724 | return 0; |
| 725 | } |
| 726 | |
| 727 | /* No kernel lock held - fine */ |
| 728 | static unsigned int pp_poll (struct file * file, poll_table * wait) |
| 729 | { |
| 730 | struct pp_struct *pp = file->private_data; |
| 731 | unsigned int mask = 0; |
| 732 | |
| 733 | poll_wait (file, &pp->irq_wait, wait); |
| 734 | if (atomic_read (&pp->irqc)) |
| 735 | mask |= POLLIN | POLLRDNORM; |
| 736 | |
| 737 | return mask; |
| 738 | } |
| 739 | |
gregkh@suse.de | ca8eca6 | 2005-03-23 09:53:09 -0800 | [diff] [blame] | 740 | static struct class *ppdev_class; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 741 | |
| 742 | static struct file_operations pp_fops = { |
| 743 | .owner = THIS_MODULE, |
| 744 | .llseek = no_llseek, |
| 745 | .read = pp_read, |
| 746 | .write = pp_write, |
| 747 | .poll = pp_poll, |
| 748 | .ioctl = pp_ioctl, |
| 749 | .open = pp_open, |
| 750 | .release = pp_release, |
| 751 | }; |
| 752 | |
| 753 | static void pp_attach(struct parport *port) |
| 754 | { |
Greg Kroah-Hartman | 53f4654 | 2005-10-27 22:25:43 -0700 | [diff] [blame] | 755 | class_device_create(ppdev_class, NULL, MKDEV(PP_MAJOR, port->number), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 756 | NULL, "parport%d", port->number); |
| 757 | } |
| 758 | |
| 759 | static void pp_detach(struct parport *port) |
| 760 | { |
gregkh@suse.de | ca8eca6 | 2005-03-23 09:53:09 -0800 | [diff] [blame] | 761 | class_device_destroy(ppdev_class, MKDEV(PP_MAJOR, port->number)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 762 | } |
| 763 | |
| 764 | static struct parport_driver pp_driver = { |
| 765 | .name = CHRDEV, |
| 766 | .attach = pp_attach, |
| 767 | .detach = pp_detach, |
| 768 | }; |
| 769 | |
| 770 | static int __init ppdev_init (void) |
| 771 | { |
Greg Kroah-Hartman | 8ab5e4c | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 772 | int err = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 773 | |
| 774 | if (register_chrdev (PP_MAJOR, CHRDEV, &pp_fops)) { |
| 775 | printk (KERN_WARNING CHRDEV ": unable to get major %d\n", |
| 776 | PP_MAJOR); |
| 777 | return -EIO; |
| 778 | } |
gregkh@suse.de | ca8eca6 | 2005-03-23 09:53:09 -0800 | [diff] [blame] | 779 | ppdev_class = class_create(THIS_MODULE, CHRDEV); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 780 | if (IS_ERR(ppdev_class)) { |
| 781 | err = PTR_ERR(ppdev_class); |
| 782 | goto out_chrdev; |
| 783 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 784 | if (parport_register_driver(&pp_driver)) { |
| 785 | printk (KERN_WARNING CHRDEV ": unable to register with parport\n"); |
| 786 | goto out_class; |
| 787 | } |
| 788 | |
| 789 | printk (KERN_INFO PP_VERSION "\n"); |
| 790 | goto out; |
| 791 | |
| 792 | out_class: |
gregkh@suse.de | ca8eca6 | 2005-03-23 09:53:09 -0800 | [diff] [blame] | 793 | class_destroy(ppdev_class); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 794 | out_chrdev: |
| 795 | unregister_chrdev(PP_MAJOR, CHRDEV); |
| 796 | out: |
| 797 | return err; |
| 798 | } |
| 799 | |
| 800 | static void __exit ppdev_cleanup (void) |
| 801 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 802 | /* Clean up all parport stuff */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 803 | parport_unregister_driver(&pp_driver); |
gregkh@suse.de | ca8eca6 | 2005-03-23 09:53:09 -0800 | [diff] [blame] | 804 | class_destroy(ppdev_class); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 805 | unregister_chrdev (PP_MAJOR, CHRDEV); |
| 806 | } |
| 807 | |
| 808 | module_init(ppdev_init); |
| 809 | module_exit(ppdev_cleanup); |
| 810 | |
| 811 | MODULE_LICENSE("GPL"); |
| 812 | MODULE_ALIAS_CHARDEV_MAJOR(PP_MAJOR); |