2 pg.c (c) 1998 Grant R. Guenther <grant@torque.net>
3 Under the terms of the GNU General Public License.
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
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.
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
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".
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.
34 To use this device, you must have the following device
35 special files defined:
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
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:
50 drive0 These four arguments can be arrays of
51 drive1 1-6 integers as follows:
53 drive3 <prt>,<pro>,<uni>,<mod>,<slv>,<dly>
57 <prt> is the base of the parallel port address for
58 the corresponding drive. (required)
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)
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.
71 <mod> this can be -1 to choose the best mode, or one
72 of the mode numbers supported by the adapter.
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
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)
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
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).
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)
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:
112 In addition, you can use the parameter pg.disable to disable
119 1.01 GRG 1998.06.16 Bug fixes
120 1.02 GRG 1998.09.24 Added jumbo support
124 #define PG_VERSION "1.02"
133 /* Here are things one can override from the insmod command.
134 Most are autoprobed by paride unless set here. Verbose is 0
139 static int verbose = 0;
140 static int major = PG_MAJOR;
141 static char *name = PG_NAME;
142 static int disable = 0;
144 static int drive0[6] = { 0, 0, 0, -1, -1, -1 };
145 static int drive1[6] = { 0, 0, 0, -1, -1, -1 };
146 static int drive2[6] = { 0, 0, 0, -1, -1, -1 };
147 static int drive3[6] = { 0, 0, 0, -1, -1, -1 };
149 static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
150 static int pg_drive_count;
152 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_DLY};
154 /* end of parameters */
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>
165 #include <asm/uaccess.h>
171 static STT pg_stt[5] = {
172 {"drive0", 6, drive0},
173 {"drive1", 6, drive1},
174 {"drive2", 6, drive2},
175 {"drive3", 6, drive3},
176 {"disable", 1, &disable}
179 void pg_setup(char *str, int *ints)
181 generic_setup(pg_stt, 5, str);
186 MODULE_PARM(verbose, "i");
187 MODULE_PARM(major, "i");
188 MODULE_PARM(name, "s");
189 MODULE_PARM(drive0, "1-6i");
190 MODULE_PARM(drive1, "1-6i");
191 MODULE_PARM(drive2, "1-6i");
192 MODULE_PARM(drive3, "1-6i");
196 #define PG_SPIN_DEL 50 /* spin delay in micro-seconds */
199 #define PG_RESET_TMO 10*HZ
201 #define STAT_ERR 0x01
202 #define STAT_INDEX 0x02
203 #define STAT_ECC 0x04
204 #define STAT_DRQ 0x08
205 #define STAT_SEEK 0x10
206 #define STAT_WRERR 0x20
207 #define STAT_READY 0x40
208 #define STAT_BUSY 0x80
210 #define ATAPI_IDENTIFY 0x12
212 static int pg_open(struct inode *inode, struct file *file);
213 static int pg_release(struct inode *inode, struct file *file);
214 static ssize_t pg_read(struct file *filp, char *buf,
215 size_t count, loff_t * ppos);
216 static ssize_t pg_write(struct file *filp, const char *buf,
217 size_t count, loff_t * ppos);
218 static int pg_detect(void);
223 struct pi_adapter pia; /* interface to paride layer */
224 struct pi_adapter *pi;
225 int busy; /* write done, read expected */
226 int start; /* jiffies at command start */
227 int dlen; /* transfer size requested */
228 unsigned long timeout; /* timeout requested */
229 int status; /* last sense key */
230 int drive; /* drive */
231 unsigned long access; /* count of active opens ... */
232 int present; /* device present ? */
234 char name[PG_NAMELEN]; /* pg0, pg1, ... */
237 struct pg devices[PG_UNITS];
239 static int pg_identify(struct pg *dev, int log);
241 static char pg_scratch[512]; /* scratch block buffer */
243 /* kernel glue structures */
245 static struct file_operations pg_fops = {
246 .owner = THIS_MODULE,
250 .release = pg_release,
253 static void pg_init_units(void)
258 for (unit = 0; unit < PG_UNITS; unit++) {
259 int *parm = *drives[unit];
260 struct pg *dev = &devices[unit];
262 set_bit(0, &dev->access);
266 dev->drive = parm[D_SLV];
267 snprintf(dev->name, PG_NAMELEN, "%s%c", name, 'a'+unit);
273 static inline int status_reg(struct pg *dev)
275 return pi_read_regr(dev->pi, 1, 6);
278 static inline int read_reg(struct pg *dev, int reg)
280 return pi_read_regr(dev->pi, 0, reg);
283 static inline void write_reg(struct pg *dev, int reg, int val)
285 pi_write_regr(dev->pi, 0, reg, val);
288 static inline u8 DRIVE(struct pg *dev)
290 return 0xa0+0x10*dev->drive;
293 static void pg_sleep(int cs)
295 current->state = TASK_INTERRUPTIBLE;
296 schedule_timeout(cs);
299 static int pg_wait(struct pg *dev, int go, int stop, unsigned long tmo, char *msg)
301 int j, r, e, s, p, to;
306 while ((((r = status_reg(dev)) & go) || (stop && (!(r & stop))))
307 && time_before(jiffies, tmo)) {
314 to = time_after_eq(jiffies, tmo);
316 if ((r & (STAT_ERR & stop)) || to) {
317 s = read_reg(dev, 7);
318 e = read_reg(dev, 1);
319 p = read_reg(dev, 2);
321 printk("%s: %s: stat=0x%x err=0x%x phase=%d%s\n",
322 dev->name, msg, s, e, p, to ? " timeout" : "");
325 dev->status = (e >> 4) & 0xff;
331 static int pg_command(struct pg *dev, char *cmd, int dlen, unsigned long tmo)
337 write_reg(dev, 6, DRIVE(dev));
339 if (pg_wait(dev, STAT_BUSY | STAT_DRQ, 0, tmo, "before command"))
342 write_reg(dev, 4, dlen % 256);
343 write_reg(dev, 5, dlen / 256);
344 write_reg(dev, 7, 0xa0); /* ATAPI packet command */
346 if (pg_wait(dev, STAT_BUSY, STAT_DRQ, tmo, "command DRQ"))
349 if (read_reg(dev, 2) != 1) {
350 printk("%s: command phase error\n", dev->name);
354 pi_write_block(dev->pi, cmd, 12);
357 printk("%s: Command sent, dlen=%d packet= ", dev->name, dlen);
358 for (k = 0; k < 12; k++)
359 printk("%02x ", cmd[k] & 0xff);
364 pi_disconnect(dev->pi);
368 static int pg_completion(struct pg *dev, char *buf, unsigned long tmo)
372 r = pg_wait(dev, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
377 while (read_reg(dev, 7) & STAT_DRQ) {
378 d = (read_reg(dev, 4) + 256 * read_reg(dev, 5));
379 n = ((d + 3) & 0xfffc);
380 p = read_reg(dev, 2) & 3;
382 pi_write_block(dev->pi, buf, n);
384 pi_read_block(dev->pi, buf, n);
386 printk("%s: %s %d bytes\n", dev->name,
387 p ? "Read" : "Write", n);
388 dev->dlen += (1 - p) * d;
390 r = pg_wait(dev, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
394 pi_disconnect(dev->pi);
399 static int pg_reset(struct pg *dev)
402 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
406 write_reg(dev, 6, DRIVE(dev));
407 write_reg(dev, 7, 8);
409 pg_sleep(20 * HZ / 1000);
412 while ((k++ < PG_RESET_TMO) && (status_reg(dev) & STAT_BUSY))
415 for (i = 0; i < 5; i++)
416 got[i] = read_reg(dev, i + 1);
418 err = memcmp(expect, got, sizeof(got)) ? -1 : 0;
421 printk("%s: Reset (%d) signature = ", dev->name, k);
422 for (i = 0; i < 5; i++)
423 printk("%3x", got[i]);
425 printk(" (incorrect)");
429 pi_disconnect(dev->pi);
433 static void xs(char *buf, char *targ, int len)
438 for (k = 0; k < len; k++) {
440 if (c != ' ' || c != l)
448 static int pg_identify(struct pg *dev, int log)
451 char *ms[2] = { "master", "slave" };
453 char id_cmd[12] = { ATAPI_IDENTIFY, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
456 s = pg_command(dev, id_cmd, 36, jiffies + PG_TMO);
459 s = pg_completion(dev, buf, jiffies + PG_TMO);
465 xs(buf + 16, id, 16);
466 printk("%s: %s %s, %s\n", dev->name, mf, id, ms[dev->drive]);
473 * returns 0, with id set if drive is detected
474 * -1, if drive detection failed
476 static int pg_probe(struct pg *dev)
478 if (dev->drive == -1) {
479 for (dev->drive = 0; dev->drive <= 1; dev->drive++)
481 return pg_identify(dev, 1);
484 return pg_identify(dev, 1);
489 static int pg_detect(void)
491 struct pg *dev = &devices[0];
494 printk("%s: %s version %s, major %d\n", name, name, PG_VERSION, major);
497 if (pg_drive_count == 0) {
498 if (pi_init(dev->pi, 1, -1, -1, -1, -1, -1, pg_scratch,
499 PI_PG, verbose, dev->name)) {
500 if (!pg_probe(dev)) {
508 for (unit = 0; unit < PG_UNITS; unit++, dev++) {
509 int *parm = *drives[unit];
512 if (pi_init(dev->pi, 0, parm[D_PRT], parm[D_MOD],
513 parm[D_UNI], parm[D_PRO], parm[D_DLY],
514 pg_scratch, PI_PG, verbose, dev->name)) {
515 if (!pg_probe(dev)) {
526 printk("%s: No ATAPI device detected\n", name);
530 static int pg_open(struct inode *inode, struct file *file)
532 int unit = iminor(inode) & 0x7f;
533 struct pg *dev = &devices[unit];
535 if ((unit >= PG_UNITS) || (!dev->present))
538 if (test_and_set_bit(0, &dev->access))
546 pg_identify(dev, (verbose > 1));
548 dev->bufptr = kmalloc(PG_MAX_DATA, GFP_KERNEL);
549 if (dev->bufptr == NULL) {
550 clear_bit(0, &dev->access);
551 printk("%s: buffer allocation failed\n", dev->name);
555 file->private_data = dev;
560 static int pg_release(struct inode *inode, struct file *file)
562 struct pg *dev = file->private_data;
566 clear_bit(0, &dev->access);
571 static ssize_t pg_write(struct file *filp, const char *buf, size_t count, loff_t *ppos)
573 struct pg *dev = filp->private_data;
574 struct pg_write_hdr hdr;
575 int hs = sizeof (hdr);
582 if (copy_from_user((char *) &hdr, buf, hs))
585 if (hdr.magic != PG_MAGIC)
587 if (hdr.dlen > PG_MAX_DATA)
589 if ((count - hs) > PG_MAX_DATA)
592 if (hdr.func == PG_RESET) {
600 if (hdr.func != PG_COMMAND)
603 dev->start = jiffies;
604 dev->timeout = hdr.timeout * HZ + HZ / 2 + jiffies;
606 if (pg_command(dev, hdr.packet, hdr.dlen, jiffies + PG_TMO)) {
607 if (dev->status & 0x10)
614 if (copy_from_user(dev->bufptr, buf + hs, count - hs))
619 static ssize_t pg_read(struct file *filp, char *buf, size_t count, loff_t *ppos)
621 struct pg *dev = filp->private_data;
622 struct pg_read_hdr hdr;
623 int hs = sizeof (hdr);
633 if (pg_completion(dev, dev->bufptr, dev->timeout))
634 if (dev->status & 0x10)
637 hdr.magic = PG_MAGIC;
638 hdr.dlen = dev->dlen;
642 hdr.dlen = -1 * hdr.dlen;
644 if (copy > (count - hs))
648 hdr.duration = (jiffies - dev->start + HZ / 2) / HZ;
649 hdr.scsi = dev->status & 0x0f;
651 if (copy_to_user(buf, (char *) &hdr, hs))
654 if (copy_to_user(buf + hs, dev->bufptr, copy))
659 static int __init pg_init(void)
671 if (register_chrdev(major, name, &pg_fops)) {
672 printk("pg_init: unable to get major number %d\n", major);
673 for (unit = 0; unit < PG_UNITS; unit++) {
674 struct pg *dev = &devices[unit];
681 for (unit = 0; unit < PG_UNITS; unit++) {
682 struct pg *dev = &devices[unit];
684 devfs_mk_cdev(MKDEV(major, unit),
685 S_IFCHR | S_IRUSR | S_IWUSR, "pg/%u",
692 static void __exit pg_exit(void)
696 for (unit = 0; unit < PG_UNITS; unit++) {
697 struct pg *dev = &devices[unit];
699 devfs_remove("pg/%u", unit);
703 unregister_chrdev(major, name);
705 for (unit = 0; unit < PG_UNITS; unit++) {
706 struct pg *dev = &devices[unit];
712 MODULE_LICENSE("GPL");