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 override 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 #include <linux/types.h>
134 /* Here are things one can override from the insmod command.
135 Most are autoprobed by paride unless set here. Verbose is 0
136 by default.
137
138 */
139
140 static int verbose;
141 static int major = PG_MAJOR;
142 static char *name = PG_NAME;
143 static int disable = 0;
144
145 static int drive0[6] = { 0, 0, 0, -1, -1, -1 };
146 static int drive1[6] = { 0, 0, 0, -1, -1, -1 };
147 static int drive2[6] = { 0, 0, 0, -1, -1, -1 };
148 static int drive3[6] = { 0, 0, 0, -1, -1, -1 };
149
150 static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
151 static int pg_drive_count;
152
153 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_DLY};
154
155 /* end of parameters */
156
157 #include <linux/module.h>
158 #include <linux/init.h>
159 #include <linux/fs.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 #include <linux/sched.h> /* current, TASK_* */
166 #include <linux/mutex.h>
167 #include <linux/jiffies.h>
168
169 #include <linux/uaccess.h>
170
171 module_param(verbose, int, 0644);
172 module_param(major, int, 0);
173 module_param(name, charp, 0);
174 module_param_array(drive0, int, NULL, 0);
175 module_param_array(drive1, int, NULL, 0);
176 module_param_array(drive2, int, NULL, 0);
177 module_param_array(drive3, int, NULL, 0);
178
179 #include "paride.h"
180
181 #define PG_SPIN_DEL 50 /* spin delay in micro-seconds */
182 #define PG_SPIN 200
183 #define PG_TMO HZ
184 #define PG_RESET_TMO 10*HZ
185
186 #define STAT_ERR 0x01
187 #define STAT_INDEX 0x02
188 #define STAT_ECC 0x04
189 #define STAT_DRQ 0x08
190 #define STAT_SEEK 0x10
191 #define STAT_WRERR 0x20
192 #define STAT_READY 0x40
193 #define STAT_BUSY 0x80
194
195 #define ATAPI_IDENTIFY 0x12
196
197 static DEFINE_MUTEX(pg_mutex);
198 static int pg_open(struct inode *inode, struct file *file);
199 static int pg_release(struct inode *inode, struct file *file);
200 static ssize_t pg_read(struct file *filp, char __user *buf,
201 size_t count, loff_t * ppos);
202 static ssize_t pg_write(struct file *filp, const char __user *buf,
203 size_t count, loff_t * ppos);
204 static int pg_detect(void);
205
206 #define PG_NAMELEN 8
207
208 struct pg {
209 struct pi_adapter pia; /* interface to paride layer */
210 struct pi_adapter *pi;
211 int busy; /* write done, read expected */
212 int start; /* jiffies at command start */
213 int dlen; /* transfer size requested */
214 unsigned long timeout; /* timeout requested */
215 int status; /* last sense key */
216 int drive; /* drive */
217 unsigned long access; /* count of active opens ... */
218 int present; /* device present ? */
219 char *bufptr;
220 char name[PG_NAMELEN]; /* pg0, pg1, ... */
221 };
222
223 static struct pg devices[PG_UNITS];
224
225 static int pg_identify(struct pg *dev, int log);
226
227 static char pg_scratch[512]; /* scratch block buffer */
228
229 static struct class *pg_class;
230 static void *par_drv; /* reference of parport driver */
231
232 /* kernel glue structures */
233
234 static const struct file_operations pg_fops = {
235 .owner = THIS_MODULE,
236 .read = pg_read,
237 .write = pg_write,
238 .open = pg_open,
239 .release = pg_release,
240 .llseek = noop_llseek,
241 };
242
pg_init_units(void)243 static void pg_init_units(void)
244 {
245 int unit;
246
247 pg_drive_count = 0;
248 for (unit = 0; unit < PG_UNITS; unit++) {
249 int *parm = *drives[unit];
250 struct pg *dev = &devices[unit];
251 dev->pi = &dev->pia;
252 clear_bit(0, &dev->access);
253 dev->busy = 0;
254 dev->present = 0;
255 dev->bufptr = NULL;
256 dev->drive = parm[D_SLV];
257 snprintf(dev->name, PG_NAMELEN, "%s%c", name, 'a'+unit);
258 if (parm[D_PRT])
259 pg_drive_count++;
260 }
261 }
262
status_reg(struct pg * dev)263 static inline int status_reg(struct pg *dev)
264 {
265 return pi_read_regr(dev->pi, 1, 6);
266 }
267
read_reg(struct pg * dev,int reg)268 static inline int read_reg(struct pg *dev, int reg)
269 {
270 return pi_read_regr(dev->pi, 0, reg);
271 }
272
write_reg(struct pg * dev,int reg,int val)273 static inline void write_reg(struct pg *dev, int reg, int val)
274 {
275 pi_write_regr(dev->pi, 0, reg, val);
276 }
277
DRIVE(struct pg * dev)278 static inline u8 DRIVE(struct pg *dev)
279 {
280 return 0xa0+0x10*dev->drive;
281 }
282
pg_sleep(int cs)283 static void pg_sleep(int cs)
284 {
285 schedule_timeout_interruptible(cs);
286 }
287
pg_wait(struct pg * dev,int go,int stop,unsigned long tmo,char * msg)288 static int pg_wait(struct pg *dev, int go, int stop, unsigned long tmo, char *msg)
289 {
290 int j, r, e, s, p, to;
291
292 dev->status = 0;
293
294 j = 0;
295 while ((((r = status_reg(dev)) & go) || (stop && (!(r & stop))))
296 && time_before(jiffies, tmo)) {
297 if (j++ < PG_SPIN)
298 udelay(PG_SPIN_DEL);
299 else
300 pg_sleep(1);
301 }
302
303 to = time_after_eq(jiffies, tmo);
304
305 if ((r & (STAT_ERR & stop)) || to) {
306 s = read_reg(dev, 7);
307 e = read_reg(dev, 1);
308 p = read_reg(dev, 2);
309 if (verbose > 1)
310 printk("%s: %s: stat=0x%x err=0x%x phase=%d%s\n",
311 dev->name, msg, s, e, p, to ? " timeout" : "");
312 if (to)
313 e |= 0x100;
314 dev->status = (e >> 4) & 0xff;
315 return -1;
316 }
317 return 0;
318 }
319
pg_command(struct pg * dev,char * cmd,int dlen,unsigned long tmo)320 static int pg_command(struct pg *dev, char *cmd, int dlen, unsigned long tmo)
321 {
322 int k;
323
324 pi_connect(dev->pi);
325
326 write_reg(dev, 6, DRIVE(dev));
327
328 if (pg_wait(dev, STAT_BUSY | STAT_DRQ, 0, tmo, "before command"))
329 goto fail;
330
331 write_reg(dev, 4, dlen % 256);
332 write_reg(dev, 5, dlen / 256);
333 write_reg(dev, 7, 0xa0); /* ATAPI packet command */
334
335 if (pg_wait(dev, STAT_BUSY, STAT_DRQ, tmo, "command DRQ"))
336 goto fail;
337
338 if (read_reg(dev, 2) != 1) {
339 printk("%s: command phase error\n", dev->name);
340 goto fail;
341 }
342
343 pi_write_block(dev->pi, cmd, 12);
344
345 if (verbose > 1) {
346 printk("%s: Command sent, dlen=%d packet= ", dev->name, dlen);
347 for (k = 0; k < 12; k++)
348 printk("%02x ", cmd[k] & 0xff);
349 printk("\n");
350 }
351 return 0;
352 fail:
353 pi_disconnect(dev->pi);
354 return -1;
355 }
356
pg_completion(struct pg * dev,char * buf,unsigned long tmo)357 static int pg_completion(struct pg *dev, char *buf, unsigned long tmo)
358 {
359 int r, d, n, p;
360
361 r = pg_wait(dev, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
362 tmo, "completion");
363
364 dev->dlen = 0;
365
366 while (read_reg(dev, 7) & STAT_DRQ) {
367 d = (read_reg(dev, 4) + 256 * read_reg(dev, 5));
368 n = ((d + 3) & 0xfffc);
369 p = read_reg(dev, 2) & 3;
370 if (p == 0)
371 pi_write_block(dev->pi, buf, n);
372 if (p == 2)
373 pi_read_block(dev->pi, buf, n);
374 if (verbose > 1)
375 printk("%s: %s %d bytes\n", dev->name,
376 p ? "Read" : "Write", n);
377 dev->dlen += (1 - p) * d;
378 buf += d;
379 r = pg_wait(dev, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
380 tmo, "completion");
381 }
382
383 pi_disconnect(dev->pi);
384
385 return r;
386 }
387
pg_reset(struct pg * dev)388 static int pg_reset(struct pg *dev)
389 {
390 int i, k, err;
391 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
392 int got[5];
393
394 pi_connect(dev->pi);
395 write_reg(dev, 6, DRIVE(dev));
396 write_reg(dev, 7, 8);
397
398 pg_sleep(20 * HZ / 1000);
399
400 k = 0;
401 while ((k++ < PG_RESET_TMO) && (status_reg(dev) & STAT_BUSY))
402 pg_sleep(1);
403
404 for (i = 0; i < 5; i++)
405 got[i] = read_reg(dev, i + 1);
406
407 err = memcmp(expect, got, sizeof(got)) ? -1 : 0;
408
409 if (verbose) {
410 printk("%s: Reset (%d) signature = ", dev->name, k);
411 for (i = 0; i < 5; i++)
412 printk("%3x", got[i]);
413 if (err)
414 printk(" (incorrect)");
415 printk("\n");
416 }
417
418 pi_disconnect(dev->pi);
419 return err;
420 }
421
xs(char * buf,char * targ,int len)422 static void xs(char *buf, char *targ, int len)
423 {
424 char l = '\0';
425 int k;
426
427 for (k = 0; k < len; k++) {
428 char c = *buf++;
429 if (c != ' ' && c != l)
430 l = *targ++ = c;
431 }
432 if (l == ' ')
433 targ--;
434 *targ = '\0';
435 }
436
pg_identify(struct pg * dev,int log)437 static int pg_identify(struct pg *dev, int log)
438 {
439 int s;
440 char *ms[2] = { "master", "slave" };
441 char mf[10], id[18];
442 char id_cmd[12] = { ATAPI_IDENTIFY, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
443 char buf[36];
444
445 s = pg_command(dev, id_cmd, 36, jiffies + PG_TMO);
446 if (s)
447 return -1;
448 s = pg_completion(dev, buf, jiffies + PG_TMO);
449 if (s)
450 return -1;
451
452 if (log) {
453 xs(buf + 8, mf, 8);
454 xs(buf + 16, id, 16);
455 printk("%s: %s %s, %s\n", dev->name, mf, id, ms[dev->drive]);
456 }
457
458 return 0;
459 }
460
461 /*
462 * returns 0, with id set if drive is detected
463 * -1, if drive detection failed
464 */
pg_probe(struct pg * dev)465 static int pg_probe(struct pg *dev)
466 {
467 if (dev->drive == -1) {
468 for (dev->drive = 0; dev->drive <= 1; dev->drive++)
469 if (!pg_reset(dev))
470 return pg_identify(dev, 1);
471 } else {
472 if (!pg_reset(dev))
473 return pg_identify(dev, 1);
474 }
475 return -1;
476 }
477
pg_detect(void)478 static int pg_detect(void)
479 {
480 struct pg *dev = &devices[0];
481 int k, unit;
482
483 printk("%s: %s version %s, major %d\n", name, name, PG_VERSION, major);
484
485 par_drv = pi_register_driver(name);
486 if (!par_drv) {
487 pr_err("failed to register %s driver\n", name);
488 return -1;
489 }
490
491 k = 0;
492 if (pg_drive_count == 0) {
493 if (pi_init(dev->pi, 1, -1, -1, -1, -1, -1, pg_scratch,
494 PI_PG, verbose, dev->name)) {
495 if (!pg_probe(dev)) {
496 dev->present = 1;
497 k++;
498 } else
499 pi_release(dev->pi);
500 }
501
502 } else
503 for (unit = 0; unit < PG_UNITS; unit++, dev++) {
504 int *parm = *drives[unit];
505 if (!parm[D_PRT])
506 continue;
507 if (pi_init(dev->pi, 0, parm[D_PRT], parm[D_MOD],
508 parm[D_UNI], parm[D_PRO], parm[D_DLY],
509 pg_scratch, PI_PG, verbose, dev->name)) {
510 if (!pg_probe(dev)) {
511 dev->present = 1;
512 k++;
513 } else
514 pi_release(dev->pi);
515 }
516 }
517
518 if (k)
519 return 0;
520
521 pi_unregister_driver(par_drv);
522 printk("%s: No ATAPI device detected\n", name);
523 return -1;
524 }
525
pg_open(struct inode * inode,struct file * file)526 static int pg_open(struct inode *inode, struct file *file)
527 {
528 int unit = iminor(inode) & 0x7f;
529 struct pg *dev = &devices[unit];
530 int ret = 0;
531
532 mutex_lock(&pg_mutex);
533 if ((unit >= PG_UNITS) || (!dev->present)) {
534 ret = -ENODEV;
535 goto out;
536 }
537
538 if (test_and_set_bit(0, &dev->access)) {
539 ret = -EBUSY;
540 goto out;
541 }
542
543 if (dev->busy) {
544 pg_reset(dev);
545 dev->busy = 0;
546 }
547
548 pg_identify(dev, (verbose > 1));
549
550 dev->bufptr = kmalloc(PG_MAX_DATA, GFP_KERNEL);
551 if (dev->bufptr == NULL) {
552 clear_bit(0, &dev->access);
553 printk("%s: buffer allocation failed\n", dev->name);
554 ret = -ENOMEM;
555 goto out;
556 }
557
558 file->private_data = dev;
559
560 out:
561 mutex_unlock(&pg_mutex);
562 return ret;
563 }
564
pg_release(struct inode * inode,struct file * file)565 static int pg_release(struct inode *inode, struct file *file)
566 {
567 struct pg *dev = file->private_data;
568
569 kfree(dev->bufptr);
570 dev->bufptr = NULL;
571 clear_bit(0, &dev->access);
572
573 return 0;
574 }
575
pg_write(struct file * filp,const char __user * buf,size_t count,loff_t * ppos)576 static ssize_t pg_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
577 {
578 struct pg *dev = filp->private_data;
579 struct pg_write_hdr hdr;
580 int hs = sizeof (hdr);
581
582 if (dev->busy)
583 return -EBUSY;
584 if (count < hs)
585 return -EINVAL;
586
587 if (copy_from_user(&hdr, buf, hs))
588 return -EFAULT;
589
590 if (hdr.magic != PG_MAGIC)
591 return -EINVAL;
592 if (hdr.dlen < 0 || hdr.dlen > PG_MAX_DATA)
593 return -EINVAL;
594 if ((count - hs) > PG_MAX_DATA)
595 return -EINVAL;
596
597 if (hdr.func == PG_RESET) {
598 if (count != hs)
599 return -EINVAL;
600 if (pg_reset(dev))
601 return -EIO;
602 return count;
603 }
604
605 if (hdr.func != PG_COMMAND)
606 return -EINVAL;
607
608 dev->start = jiffies;
609 dev->timeout = hdr.timeout * HZ + HZ / 2 + jiffies;
610
611 if (pg_command(dev, hdr.packet, hdr.dlen, jiffies + PG_TMO)) {
612 if (dev->status & 0x10)
613 return -ETIME;
614 return -EIO;
615 }
616
617 dev->busy = 1;
618
619 if (copy_from_user(dev->bufptr, buf + hs, count - hs))
620 return -EFAULT;
621 return count;
622 }
623
pg_read(struct file * filp,char __user * buf,size_t count,loff_t * ppos)624 static ssize_t pg_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
625 {
626 struct pg *dev = filp->private_data;
627 struct pg_read_hdr hdr;
628 int hs = sizeof (hdr);
629 int copy;
630
631 if (!dev->busy)
632 return -EINVAL;
633 if (count < hs)
634 return -EINVAL;
635
636 dev->busy = 0;
637
638 if (pg_completion(dev, dev->bufptr, dev->timeout))
639 if (dev->status & 0x10)
640 return -ETIME;
641
642 memset(&hdr, 0, sizeof(hdr));
643 hdr.magic = PG_MAGIC;
644 hdr.dlen = dev->dlen;
645 copy = 0;
646
647 if (hdr.dlen < 0) {
648 hdr.dlen = -1 * hdr.dlen;
649 copy = hdr.dlen;
650 if (copy > (count - hs))
651 copy = count - hs;
652 }
653
654 hdr.duration = (jiffies - dev->start + HZ / 2) / HZ;
655 hdr.scsi = dev->status & 0x0f;
656
657 if (copy_to_user(buf, &hdr, hs))
658 return -EFAULT;
659 if (copy > 0)
660 if (copy_to_user(buf + hs, dev->bufptr, copy))
661 return -EFAULT;
662 return copy + hs;
663 }
664
pg_init(void)665 static int __init pg_init(void)
666 {
667 int unit;
668 int err;
669
670 if (disable){
671 err = -EINVAL;
672 goto out;
673 }
674
675 pg_init_units();
676
677 if (pg_detect()) {
678 err = -ENODEV;
679 goto out;
680 }
681
682 err = register_chrdev(major, name, &pg_fops);
683 if (err < 0) {
684 printk("pg_init: unable to get major number %d\n", major);
685 for (unit = 0; unit < PG_UNITS; unit++) {
686 struct pg *dev = &devices[unit];
687 if (dev->present)
688 pi_release(dev->pi);
689 }
690 goto out;
691 }
692 major = err; /* In case the user specified `major=0' (dynamic) */
693 pg_class = class_create(THIS_MODULE, "pg");
694 if (IS_ERR(pg_class)) {
695 err = PTR_ERR(pg_class);
696 goto out_chrdev;
697 }
698 for (unit = 0; unit < PG_UNITS; unit++) {
699 struct pg *dev = &devices[unit];
700 if (dev->present)
701 device_create(pg_class, NULL, MKDEV(major, unit), NULL,
702 "pg%u", unit);
703 }
704 err = 0;
705 goto out;
706
707 out_chrdev:
708 unregister_chrdev(major, "pg");
709 out:
710 return err;
711 }
712
pg_exit(void)713 static void __exit pg_exit(void)
714 {
715 int unit;
716
717 for (unit = 0; unit < PG_UNITS; unit++) {
718 struct pg *dev = &devices[unit];
719 if (dev->present)
720 device_destroy(pg_class, MKDEV(major, unit));
721 }
722 class_destroy(pg_class);
723 unregister_chrdev(major, name);
724
725 for (unit = 0; unit < PG_UNITS; unit++) {
726 struct pg *dev = &devices[unit];
727 if (dev->present)
728 pi_release(dev->pi);
729 }
730 }
731
732 MODULE_LICENSE("GPL");
733 module_init(pg_init)
734 module_exit(pg_exit)
735