aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/block/paride/pg.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/block/paride/pg.c')
-rw-r--r--drivers/block/paride/pg.c723
1 files changed, 723 insertions, 0 deletions
diff --git a/drivers/block/paride/pg.c b/drivers/block/paride/pg.c
new file mode 100644
index 000000000000..dbeb107bb971
--- /dev/null
+++ b/drivers/block/paride/pg.c
@@ -0,0 +1,723 @@
1/*
2 pg.c (c) 1998 Grant R. Guenther <grant@torque.net>
3 Under the terms of the GNU General Public License.
4
5 The pg driver provides a simple character device interface for
6 sending ATAPI commands to a device. With the exception of the
7 ATAPI reset operation, all operations are performed by a pair
8 of read and write operations to the appropriate /dev/pgN device.
9 A write operation delivers a command and any outbound data in
10 a single buffer. Normally, the write will succeed unless the
11 device is offline or malfunctioning, or there is already another
12 command pending. If the write succeeds, it should be followed
13 immediately by a read operation, to obtain any returned data and
14 status information. A read will fail if there is no operation
15 in progress.
16
17 As a special case, the device can be reset with a write operation,
18 and in this case, no following read is expected, or permitted.
19
20 There are no ioctl() operations. Any single operation
21 may transfer at most PG_MAX_DATA bytes. Note that the driver must
22 copy the data through an internal buffer. In keeping with all
23 current ATAPI devices, command packets are assumed to be exactly
24 12 bytes in length.
25
26 To permit future changes to this interface, the headers in the
27 read and write buffers contain a single character "magic" flag.
28 Currently this flag must be the character "P".
29
30 By default, the driver will autoprobe for a single parallel
31 port ATAPI device, but if their individual parameters are
32 specified, the driver can handle up to 4 devices.
33
34 To use this device, you must have the following device
35 special files defined:
36
37 /dev/pg0 c 97 0
38 /dev/pg1 c 97 1
39 /dev/pg2 c 97 2
40 /dev/pg3 c 97 3
41
42 (You'll need to change the 97 to something else if you use
43 the 'major' parameter to install the driver on a different
44 major number.)
45
46 The behaviour of the pg driver can be altered by setting
47 some parameters from the insmod command line. The following
48 parameters are adjustable:
49
50 drive0 These four arguments can be arrays of
51 drive1 1-6 integers as follows:
52 drive2
53 drive3 <prt>,<pro>,<uni>,<mod>,<slv>,<dly>
54
55 Where,
56
57 <prt> is the base of the parallel port address for
58 the corresponding drive. (required)
59
60 <pro> is the protocol number for the adapter that
61 supports this drive. These numbers are
62 logged by 'paride' when the protocol modules
63 are initialised. (0 if not given)
64
65 <uni> for those adapters that support chained
66 devices, this is the unit selector for the
67 chain of devices on the given port. It should
68 be zero for devices that don't support chaining.
69 (0 if not given)
70
71 <mod> this can be -1 to choose the best mode, or one
72 of the mode numbers supported by the adapter.
73 (-1 if not given)
74
75 <slv> ATAPI devices can be jumpered to master or slave.
76 Set this to 0 to choose the master drive, 1 to
77 choose the slave, -1 (the default) to choose the
78 first drive found.
79
80 <dly> some parallel ports require the driver to
81 go more slowly. -1 sets a default value that
82 should work with the chosen protocol. Otherwise,
83 set this to a small integer, the larger it is
84 the slower the port i/o. In some cases, setting
85 this to zero will speed up the device. (default -1)
86
87 major You may use this parameter to overide the
88 default major number (97) that this driver
89 will use. Be sure to change the device
90 name as well.
91
92 name This parameter is a character string that
93 contains the name the kernel will use for this
94 device (in /proc output, for instance).
95 (default "pg").
96
97 verbose This parameter controls the amount of logging
98 that is done by the driver. Set it to 0 for
99 quiet operation, to 1 to enable progress
100 messages while the driver probes for devices,
101 or to 2 for full debug logging. (default 0)
102
103 If this driver is built into the kernel, you can use
104 the following command line parameters, with the same values
105 as the corresponding module parameters listed above:
106
107 pg.drive0
108 pg.drive1
109 pg.drive2
110 pg.drive3
111
112 In addition, you can use the parameter pg.disable to disable
113 the driver entirely.
114
115*/
116
117/* Changes:
118
119 1.01 GRG 1998.06.16 Bug fixes
120 1.02 GRG 1998.09.24 Added jumbo support
121
122*/
123
124#define PG_VERSION "1.02"
125#define PG_MAJOR 97
126#define PG_NAME "pg"
127#define PG_UNITS 4
128
129#ifndef PI_PG
130#define PI_PG 4
131#endif
132
133/* Here are things one can override from the insmod command.
134 Most are autoprobed by paride unless set here. Verbose is 0
135 by default.
136
137*/
138
139static int verbose = 0;
140static int major = PG_MAJOR;
141static char *name = PG_NAME;
142static int disable = 0;
143
144static int drive0[6] = { 0, 0, 0, -1, -1, -1 };
145static int drive1[6] = { 0, 0, 0, -1, -1, -1 };
146static int drive2[6] = { 0, 0, 0, -1, -1, -1 };
147static int drive3[6] = { 0, 0, 0, -1, -1, -1 };
148
149static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
150static int pg_drive_count;
151
152enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_DLY};
153
154/* end of parameters */
155
156#include <linux/module.h>
157#include <linux/init.h>
158#include <linux/fs.h>
159#include <linux/devfs_fs_kernel.h>
160#include <linux/delay.h>
161#include <linux/slab.h>
162#include <linux/mtio.h>
163#include <linux/pg.h>
164#include <linux/device.h>
165
166#include <asm/uaccess.h>
167
168module_param(verbose, bool, 0644);
169module_param(major, int, 0);
170module_param(name, charp, 0);
171module_param_array(drive0, int, NULL, 0);
172module_param_array(drive1, int, NULL, 0);
173module_param_array(drive2, int, NULL, 0);
174module_param_array(drive3, int, NULL, 0);
175
176#include "paride.h"
177
178#define PG_SPIN_DEL 50 /* spin delay in micro-seconds */
179#define PG_SPIN 200
180#define PG_TMO HZ
181#define PG_RESET_TMO 10*HZ
182
183#define STAT_ERR 0x01
184#define STAT_INDEX 0x02
185#define STAT_ECC 0x04
186#define STAT_DRQ 0x08
187#define STAT_SEEK 0x10
188#define STAT_WRERR 0x20
189#define STAT_READY 0x40
190#define STAT_BUSY 0x80
191
192#define ATAPI_IDENTIFY 0x12
193
194static int pg_open(struct inode *inode, struct file *file);
195static int pg_release(struct inode *inode, struct file *file);
196static ssize_t pg_read(struct file *filp, char __user *buf,
197 size_t count, loff_t * ppos);
198static ssize_t pg_write(struct file *filp, const char __user *buf,
199 size_t count, loff_t * ppos);
200static int pg_detect(void);
201
202#define PG_NAMELEN 8
203
204struct pg {
205 struct pi_adapter pia; /* interface to paride layer */
206 struct pi_adapter *pi;
207 int busy; /* write done, read expected */
208 int start; /* jiffies at command start */
209 int dlen; /* transfer size requested */
210 unsigned long timeout; /* timeout requested */
211 int status; /* last sense key */
212 int drive; /* drive */
213 unsigned long access; /* count of active opens ... */
214 int present; /* device present ? */
215 char *bufptr;
216 char name[PG_NAMELEN]; /* pg0, pg1, ... */
217};
218
219static struct pg devices[PG_UNITS];
220
221static int pg_identify(struct pg *dev, int log);
222
223static char pg_scratch[512]; /* scratch block buffer */
224
225static struct class_simple *pg_class;
226
227/* kernel glue structures */
228
229static struct file_operations pg_fops = {
230 .owner = THIS_MODULE,
231 .read = pg_read,
232 .write = pg_write,
233 .open = pg_open,
234 .release = pg_release,
235};
236
237static void pg_init_units(void)
238{
239 int unit;
240
241 pg_drive_count = 0;
242 for (unit = 0; unit < PG_UNITS; unit++) {
243 int *parm = *drives[unit];
244 struct pg *dev = &devices[unit];
245 dev->pi = &dev->pia;
246 clear_bit(0, &dev->access);
247 dev->busy = 0;
248 dev->present = 0;
249 dev->bufptr = NULL;
250 dev->drive = parm[D_SLV];
251 snprintf(dev->name, PG_NAMELEN, "%s%c", name, 'a'+unit);
252 if (parm[D_PRT])
253 pg_drive_count++;
254 }
255}
256
257static inline int status_reg(struct pg *dev)
258{
259 return pi_read_regr(dev->pi, 1, 6);
260}
261
262static inline int read_reg(struct pg *dev, int reg)
263{
264 return pi_read_regr(dev->pi, 0, reg);
265}
266
267static inline void write_reg(struct pg *dev, int reg, int val)
268{
269 pi_write_regr(dev->pi, 0, reg, val);
270}
271
272static inline u8 DRIVE(struct pg *dev)
273{
274 return 0xa0+0x10*dev->drive;
275}
276
277static void pg_sleep(int cs)
278{
279 current->state = TASK_INTERRUPTIBLE;
280 schedule_timeout(cs);
281}
282
283static int pg_wait(struct pg *dev, int go, int stop, unsigned long tmo, char *msg)
284{
285 int j, r, e, s, p, to;
286
287 dev->status = 0;
288
289 j = 0;
290 while ((((r = status_reg(dev)) & go) || (stop && (!(r & stop))))
291 && time_before(jiffies, tmo)) {
292 if (j++ < PG_SPIN)
293 udelay(PG_SPIN_DEL);
294 else
295 pg_sleep(1);
296 }
297
298 to = time_after_eq(jiffies, tmo);
299
300 if ((r & (STAT_ERR & stop)) || to) {
301 s = read_reg(dev, 7);
302 e = read_reg(dev, 1);
303 p = read_reg(dev, 2);
304 if (verbose > 1)
305 printk("%s: %s: stat=0x%x err=0x%x phase=%d%s\n",
306 dev->name, msg, s, e, p, to ? " timeout" : "");
307 if (to)
308 e |= 0x100;
309 dev->status = (e >> 4) & 0xff;
310 return -1;
311 }
312 return 0;
313}
314
315static int pg_command(struct pg *dev, char *cmd, int dlen, unsigned long tmo)
316{
317 int k;
318
319 pi_connect(dev->pi);
320
321 write_reg(dev, 6, DRIVE(dev));
322
323 if (pg_wait(dev, STAT_BUSY | STAT_DRQ, 0, tmo, "before command"))
324 goto fail;
325
326 write_reg(dev, 4, dlen % 256);
327 write_reg(dev, 5, dlen / 256);
328 write_reg(dev, 7, 0xa0); /* ATAPI packet command */
329
330 if (pg_wait(dev, STAT_BUSY, STAT_DRQ, tmo, "command DRQ"))
331 goto fail;
332
333 if (read_reg(dev, 2) != 1) {
334 printk("%s: command phase error\n", dev->name);
335 goto fail;
336 }
337
338 pi_write_block(dev->pi, cmd, 12);
339
340 if (verbose > 1) {
341 printk("%s: Command sent, dlen=%d packet= ", dev->name, dlen);
342 for (k = 0; k < 12; k++)
343 printk("%02x ", cmd[k] & 0xff);
344 printk("\n");
345 }
346 return 0;
347fail:
348 pi_disconnect(dev->pi);
349 return -1;
350}
351
352static int pg_completion(struct pg *dev, char *buf, unsigned long tmo)
353{
354 int r, d, n, p;
355
356 r = pg_wait(dev, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
357 tmo, "completion");
358
359 dev->dlen = 0;
360
361 while (read_reg(dev, 7) & STAT_DRQ) {
362 d = (read_reg(dev, 4) + 256 * read_reg(dev, 5));
363 n = ((d + 3) & 0xfffc);
364 p = read_reg(dev, 2) & 3;
365 if (p == 0)
366 pi_write_block(dev->pi, buf, n);
367 if (p == 2)
368 pi_read_block(dev->pi, buf, n);
369 if (verbose > 1)
370 printk("%s: %s %d bytes\n", dev->name,
371 p ? "Read" : "Write", n);
372 dev->dlen += (1 - p) * d;
373 buf += d;
374 r = pg_wait(dev, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
375 tmo, "completion");
376 }
377
378 pi_disconnect(dev->pi);
379
380 return r;
381}
382
383static int pg_reset(struct pg *dev)
384{
385 int i, k, err;
386 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
387 int got[5];
388
389 pi_connect(dev->pi);
390 write_reg(dev, 6, DRIVE(dev));
391 write_reg(dev, 7, 8);
392
393 pg_sleep(20 * HZ / 1000);
394
395 k = 0;
396 while ((k++ < PG_RESET_TMO) && (status_reg(dev) & STAT_BUSY))
397 pg_sleep(1);
398
399 for (i = 0; i < 5; i++)
400 got[i] = read_reg(dev, i + 1);
401
402 err = memcmp(expect, got, sizeof(got)) ? -1 : 0;
403
404 if (verbose) {
405 printk("%s: Reset (%d) signature = ", dev->name, k);
406 for (i = 0; i < 5; i++)
407 printk("%3x", got[i]);
408 if (err)
409 printk(" (incorrect)");
410 printk("\n");
411 }
412
413 pi_disconnect(dev->pi);
414 return err;
415}
416
417static void xs(char *buf, char *targ, int len)
418{
419 char l = '\0';
420 int k;
421
422 for (k = 0; k < len; k++) {
423 char c = *buf++;
424 if (c != ' ' || c != l)
425 l = *targ++ = c;
426 }
427 if (l == ' ')
428 targ--;
429 *targ = '\0';
430}
431
432static int pg_identify(struct pg *dev, int log)
433{
434 int s;
435 char *ms[2] = { "master", "slave" };
436 char mf[10], id[18];
437 char id_cmd[12] = { ATAPI_IDENTIFY, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
438 char buf[36];
439
440 s = pg_command(dev, id_cmd, 36, jiffies + PG_TMO);
441 if (s)
442 return -1;
443 s = pg_completion(dev, buf, jiffies + PG_TMO);
444 if (s)
445 return -1;
446
447 if (log) {
448 xs(buf + 8, mf, 8);
449 xs(buf + 16, id, 16);
450 printk("%s: %s %s, %s\n", dev->name, mf, id, ms[dev->drive]);
451 }
452
453 return 0;
454}
455
456/*
457 * returns 0, with id set if drive is detected
458 * -1, if drive detection failed
459 */
460static int pg_probe(struct pg *dev)
461{
462 if (dev->drive == -1) {
463 for (dev->drive = 0; dev->drive <= 1; dev->drive++)
464 if (!pg_reset(dev))
465 return pg_identify(dev, 1);
466 } else {
467 if (!pg_reset(dev))
468 return pg_identify(dev, 1);
469 }
470 return -1;
471}
472
473static int pg_detect(void)
474{
475 struct pg *dev = &devices[0];
476 int k, unit;
477
478 printk("%s: %s version %s, major %d\n", name, name, PG_VERSION, major);
479
480 k = 0;
481 if (pg_drive_count == 0) {
482 if (pi_init(dev->pi, 1, -1, -1, -1, -1, -1, pg_scratch,
483 PI_PG, verbose, dev->name)) {
484 if (!pg_probe(dev)) {
485 dev->present = 1;
486 k++;
487 } else
488 pi_release(dev->pi);
489 }
490
491 } else
492 for (unit = 0; unit < PG_UNITS; unit++, dev++) {
493 int *parm = *drives[unit];
494 if (!parm[D_PRT])
495 continue;
496 if (pi_init(dev->pi, 0, parm[D_PRT], parm[D_MOD],
497 parm[D_UNI], parm[D_PRO], parm[D_DLY],
498 pg_scratch, PI_PG, verbose, dev->name)) {
499 if (!pg_probe(dev)) {
500 dev->present = 1;
501 k++;
502 } else
503 pi_release(dev->pi);
504 }
505 }
506
507 if (k)
508 return 0;
509
510 printk("%s: No ATAPI device detected\n", name);
511 return -1;
512}
513
514static int pg_open(struct inode *inode, struct file *file)
515{
516 int unit = iminor(inode) & 0x7f;
517 struct pg *dev = &devices[unit];
518
519 if ((unit >= PG_UNITS) || (!dev->present))
520 return -ENODEV;
521
522 if (test_and_set_bit(0, &dev->access))
523 return -EBUSY;
524
525 if (dev->busy) {
526 pg_reset(dev);
527 dev->busy = 0;
528 }
529
530 pg_identify(dev, (verbose > 1));
531
532 dev->bufptr = kmalloc(PG_MAX_DATA, GFP_KERNEL);
533 if (dev->bufptr == NULL) {
534 clear_bit(0, &dev->access);
535 printk("%s: buffer allocation failed\n", dev->name);
536 return -ENOMEM;
537 }
538
539 file->private_data = dev;
540
541 return 0;
542}
543
544static int pg_release(struct inode *inode, struct file *file)
545{
546 struct pg *dev = file->private_data;
547
548 kfree(dev->bufptr);
549 dev->bufptr = NULL;
550 clear_bit(0, &dev->access);
551
552 return 0;
553}
554
555static ssize_t pg_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
556{
557 struct pg *dev = filp->private_data;
558 struct pg_write_hdr hdr;
559 int hs = sizeof (hdr);
560
561 if (dev->busy)
562 return -EBUSY;
563 if (count < hs)
564 return -EINVAL;
565
566 if (copy_from_user(&hdr, buf, hs))
567 return -EFAULT;
568
569 if (hdr.magic != PG_MAGIC)
570 return -EINVAL;
571 if (hdr.dlen > PG_MAX_DATA)
572 return -EINVAL;
573 if ((count - hs) > PG_MAX_DATA)
574 return -EINVAL;
575
576 if (hdr.func == PG_RESET) {
577 if (count != hs)
578 return -EINVAL;
579 if (pg_reset(dev))
580 return -EIO;
581 return count;
582 }
583
584 if (hdr.func != PG_COMMAND)
585 return -EINVAL;
586
587 dev->start = jiffies;
588 dev->timeout = hdr.timeout * HZ + HZ / 2 + jiffies;
589
590 if (pg_command(dev, hdr.packet, hdr.dlen, jiffies + PG_TMO)) {
591 if (dev->status & 0x10)
592 return -ETIME;
593 return -EIO;
594 }
595
596 dev->busy = 1;
597
598 if (copy_from_user(dev->bufptr, buf + hs, count - hs))
599 return -EFAULT;
600 return count;
601}
602
603static ssize_t pg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
604{
605 struct pg *dev = filp->private_data;
606 struct pg_read_hdr hdr;
607 int hs = sizeof (hdr);
608 int copy;
609
610 if (!dev->busy)
611 return -EINVAL;
612 if (count < hs)
613 return -EINVAL;
614
615 dev->busy = 0;
616
617 if (pg_completion(dev, dev->bufptr, dev->timeout))
618 if (dev->status & 0x10)
619 return -ETIME;
620
621 hdr.magic = PG_MAGIC;
622 hdr.dlen = dev->dlen;
623 copy = 0;
624
625 if (hdr.dlen < 0) {
626 hdr.dlen = -1 * hdr.dlen;
627 copy = hdr.dlen;
628 if (copy > (count - hs))
629 copy = count - hs;
630 }
631
632 hdr.duration = (jiffies - dev->start + HZ / 2) / HZ;
633 hdr.scsi = dev->status & 0x0f;
634
635 if (copy_to_user(buf, &hdr, hs))
636 return -EFAULT;
637 if (copy > 0)
638 if (copy_to_user(buf + hs, dev->bufptr, copy))
639 return -EFAULT;
640 return copy + hs;
641}
642
643static int __init pg_init(void)
644{
645 int unit, err = 0;
646
647 if (disable){
648 err = -1;
649 goto out;
650 }
651
652 pg_init_units();
653
654 if (pg_detect()) {
655 err = -1;
656 goto out;
657 }
658
659 if (register_chrdev(major, name, &pg_fops)) {
660 printk("pg_init: unable to get major number %d\n", major);
661 for (unit = 0; unit < PG_UNITS; unit++) {
662 struct pg *dev = &devices[unit];
663 if (dev->present)
664 pi_release(dev->pi);
665 }
666 err = -1;
667 goto out;
668 }
669 pg_class = class_simple_create(THIS_MODULE, "pg");
670 if (IS_ERR(pg_class)) {
671 err = PTR_ERR(pg_class);
672 goto out_chrdev;
673 }
674 devfs_mk_dir("pg");
675 for (unit = 0; unit < PG_UNITS; unit++) {
676 struct pg *dev = &devices[unit];
677 if (dev->present) {
678 class_simple_device_add(pg_class, MKDEV(major, unit),
679 NULL, "pg%u", unit);
680 err = devfs_mk_cdev(MKDEV(major, unit),
681 S_IFCHR | S_IRUSR | S_IWUSR, "pg/%u",
682 unit);
683 if (err)
684 goto out_class;
685 }
686 }
687 err = 0;
688 goto out;
689
690out_class:
691 class_simple_device_remove(MKDEV(major, unit));
692 class_simple_destroy(pg_class);
693out_chrdev:
694 unregister_chrdev(major, "pg");
695out:
696 return err;
697}
698
699static void __exit pg_exit(void)
700{
701 int unit;
702
703 for (unit = 0; unit < PG_UNITS; unit++) {
704 struct pg *dev = &devices[unit];
705 if (dev->present) {
706 class_simple_device_remove(MKDEV(major, unit));
707 devfs_remove("pg/%u", unit);
708 }
709 }
710 class_simple_destroy(pg_class);
711 devfs_remove("pg");
712 unregister_chrdev(major, name);
713
714 for (unit = 0; unit < PG_UNITS; unit++) {
715 struct pg *dev = &devices[unit];
716 if (dev->present)
717 pi_release(dev->pi);
718 }
719}
720
721MODULE_LICENSE("GPL");
722module_init(pg_init)
723module_exit(pg_exit)