2 pt.c (c) 1998 Grant R. Guenther <grant@torque.net>
3 Under the terms of the GNU General Public License.
5 This is the high-level driver for parallel port ATAPI tape
6 drives based on chips supported by the paride module.
8 The driver implements both rewinding and non-rewinding
9 devices, filemarks, and the rewind ioctl. It allocates
10 a small internal "bounce buffer" for each open device, but
11 otherwise expects buffering and blocking to be done at the
12 user level. As with most block-structured tapes, short
13 writes are padded to full tape blocks, so reading back a file
14 may return more data than was actually written.
16 By default, the driver will autoprobe for a single parallel
17 port ATAPI tape drive, but if their individual parameters are
18 specified, the driver can handle up to 4 drives.
20 The rewinding devices are named /dev/pt0, /dev/pt1, ...
21 while the non-rewinding devices are /dev/npt0, /dev/npt1, etc.
23 The behaviour of the pt driver can be altered by setting
24 some parameters from the insmod command line. The following
25 parameters are adjustable:
27 drive0 These four arguments can be arrays of
28 drive1 1-6 integers as follows:
30 drive3 <prt>,<pro>,<uni>,<mod>,<slv>,<dly>
34 <prt> is the base of the parallel port address for
35 the corresponding drive. (required)
37 <pro> is the protocol number for the adapter that
38 supports this drive. These numbers are
39 logged by 'paride' when the protocol modules
40 are initialised. (0 if not given)
42 <uni> for those adapters that support chained
43 devices, this is the unit selector for the
44 chain of devices on the given port. It should
45 be zero for devices that don't support chaining.
48 <mod> this can be -1 to choose the best mode, or one
49 of the mode numbers supported by the adapter.
52 <slv> ATAPI devices can be jumpered to master or slave.
53 Set this to 0 to choose the master drive, 1 to
54 choose the slave, -1 (the default) to choose the
57 <dly> some parallel ports require the driver to
58 go more slowly. -1 sets a default value that
59 should work with the chosen protocol. Otherwise,
60 set this to a small integer, the larger it is
61 the slower the port i/o. In some cases, setting
62 this to zero will speed up the device. (default -1)
64 major You may use this parameter to overide the
65 default major number (96) that this driver
66 will use. Be sure to change the device
69 name This parameter is a character string that
70 contains the name the kernel will use for this
71 device (in /proc output, for instance).
74 verbose This parameter controls the amount of logging
75 that the driver will do. Set it to 0 for
76 normal operation, 1 to see autoprobe progress
77 messages, or 2 to see additional debugging
80 If this driver is built into the kernel, you can use
81 the following command line parameters, with the same values
82 as the corresponding module parameters listed above:
89 In addition, you can use the parameter pt.disable to disable
96 1.01 GRG 1998.05.06 Round up transfer size, fix ready_wait,
97 loosed interpretation of ATAPI standard
98 for clearing error status.
100 1.02 GRG 1998.06.16 Eliminate an Ugh.
101 1.03 GRG 1998.08.15 Adjusted PT_TMO, use HZ in loop timing,
103 1.04 GRG 1998.09.24 Repair minor coding error, added jumbo support
107 #define PT_VERSION "1.04"
112 /* Here are things one can override from the insmod command.
113 Most are autoprobed by paride unless set here. Verbose is on
118 static int verbose = 0;
119 static int major = PT_MAJOR;
120 static char *name = PT_NAME;
121 static int disable = 0;
123 static int drive0[6] = { 0, 0, 0, -1, -1, -1 };
124 static int drive1[6] = { 0, 0, 0, -1, -1, -1 };
125 static int drive2[6] = { 0, 0, 0, -1, -1, -1 };
126 static int drive3[6] = { 0, 0, 0, -1, -1, -1 };
128 static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
137 #define DU (*drives[unit])
139 /* end of parameters */
141 #include <linux/module.h>
142 #include <linux/init.h>
143 #include <linux/fs.h>
144 #include <linux/devfs_fs_kernel.h>
145 #include <linux/delay.h>
146 #include <linux/slab.h>
147 #include <linux/mtio.h>
148 #include <linux/device.h>
150 #include <asm/uaccess.h>
156 static STT pt_stt[5] = {
157 {"drive0", 6, drive0},
158 {"drive1", 6, drive1},
159 {"drive2", 6, drive2},
160 {"drive3", 6, drive3},
161 {"disable", 1, &disable}
165 pt_setup(char *str, int *ints)
167 generic_setup(pt_stt, 5, str);
172 MODULE_PARM(verbose, "i");
173 MODULE_PARM(major, "i");
174 MODULE_PARM(name, "s");
175 MODULE_PARM(drive0, "1-6i");
176 MODULE_PARM(drive1, "1-6i");
177 MODULE_PARM(drive2, "1-6i");
178 MODULE_PARM(drive3, "1-6i");
182 #define PT_MAX_RETRIES 5
183 #define PT_TMO 3000 /* interrupt timeout in jiffies */
184 #define PT_SPIN_DEL 50 /* spin delay in micro-seconds */
185 #define PT_RESET_TMO 30 /* 30 seconds */
186 #define PT_READY_TMO 60 /* 60 seconds */
187 #define PT_REWIND_TMO 1200 /* 20 minutes */
189 #define PT_SPIN ((1000000/(HZ*PT_SPIN_DEL))*PT_TMO)
191 #define STAT_ERR 0x00001
192 #define STAT_INDEX 0x00002
193 #define STAT_ECC 0x00004
194 #define STAT_DRQ 0x00008
195 #define STAT_SEEK 0x00010
196 #define STAT_WRERR 0x00020
197 #define STAT_READY 0x00040
198 #define STAT_BUSY 0x00080
199 #define STAT_SENSE 0x1f000
201 #define ATAPI_TEST_READY 0x00
202 #define ATAPI_REWIND 0x01
203 #define ATAPI_REQ_SENSE 0x03
204 #define ATAPI_READ_6 0x08
205 #define ATAPI_WRITE_6 0x0a
206 #define ATAPI_WFM 0x10
207 #define ATAPI_IDENTIFY 0x12
208 #define ATAPI_MODE_SENSE 0x1a
209 #define ATAPI_LOG_SENSE 0x4d
211 static int pt_open(struct inode *inode, struct file *file);
212 static int pt_ioctl(struct inode *inode, struct file *file,
213 unsigned int cmd, unsigned long arg);
214 static int pt_release(struct inode *inode, struct file *file);
215 static ssize_t pt_read(struct file *filp, char __user *buf,
216 size_t count, loff_t * ppos);
217 static ssize_t pt_write(struct file *filp, const char __user *buf,
218 size_t count, loff_t * ppos);
219 static int pt_detect(void);
221 /* bits in tape->flags */
224 #define PT_WRITE_OK 2
227 #define PT_READING 16
231 #define PT_BUFSIZE 16384
234 struct pi_adapter pia; /* interface to paride layer */
235 struct pi_adapter *pi;
236 int flags; /* various state flags */
237 int last_sense; /* result of last request sense */
238 int drive; /* drive */
239 atomic_t available; /* 1 if access is available 0 otherwise */
240 int bs; /* block size */
241 int capacity; /* Size of tape in KB */
242 int present; /* device present ? */
244 char name[PT_NAMELEN]; /* pf0, pf1, ... */
247 static int pt_identify(struct pt_unit *tape);
249 struct pt_unit pt[PT_UNITS];
251 static char pt_scratch[512]; /* scratch block buffer */
253 /* kernel glue structures */
255 static struct file_operations pt_fops = {
256 .owner = THIS_MODULE,
261 .release = pt_release,
264 /* sysfs class support */
265 static struct class_simple *pt_class;
267 static inline int status_reg(struct pi_adapter *pi)
269 return pi_read_regr(pi, 1, 6);
272 static inline int read_reg(struct pi_adapter *pi, int reg)
274 return pi_read_regr(pi, 0, reg);
277 static inline void write_reg(struct pi_adapter *pi, int reg, int val)
279 pi_write_regr(pi, 0, reg, val);
282 static inline u8 DRIVE(struct pt_unit *tape)
284 return 0xa0+0x10*tape->drive;
287 static int pt_wait(struct pt_unit *tape, int go, int stop, char *fun, char *msg)
290 struct pi_adapter *pi = tape->pi;
293 while ((((r = status_reg(pi)) & go) || (stop && (!(r & stop))))
297 if ((r & (STAT_ERR & stop)) || (j >= PT_SPIN)) {
304 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
305 " loop=%d phase=%d\n",
306 tape->name, fun, msg, r, s, e, j, p);
312 static int pt_command(struct pt_unit *tape, char *cmd, int dlen, char *fun)
314 struct pi_adapter *pi = tape->pi;
317 write_reg(pi, 6, DRIVE(tape));
319 if (pt_wait(tape, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
324 write_reg(pi, 4, dlen % 256);
325 write_reg(pi, 5, dlen / 256);
326 write_reg(pi, 7, 0xa0); /* ATAPI packet command */
328 if (pt_wait(tape, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
333 if (read_reg(pi, 2) != 1) {
334 printk("%s: %s: command phase error\n", tape->name, fun);
339 pi_write_block(pi, cmd, 12);
344 static int pt_completion(struct pt_unit *tape, char *buf, char *fun)
346 struct pi_adapter *pi = tape->pi;
349 r = pt_wait(tape, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
352 if (read_reg(pi, 7) & STAT_DRQ) {
353 n = (((read_reg(pi, 4) + 256 * read_reg(pi, 5)) +
355 p = read_reg(pi, 2) & 3;
357 pi_write_block(pi, buf, n);
359 pi_read_block(pi, buf, n);
362 s = pt_wait(tape, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
369 static void pt_req_sense(struct pt_unit *tape, int quiet)
371 char rs_cmd[12] = { ATAPI_REQ_SENSE, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
375 r = pt_command(tape, rs_cmd, 16, "Request sense");
378 pt_completion(tape, buf, "Request sense");
380 tape->last_sense = -1;
383 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
384 tape->name, buf[2] & 0xf, buf[12], buf[13]);
385 tape->last_sense = (buf[2] & 0xf) | ((buf[12] & 0xff) << 8)
386 | ((buf[13] & 0xff) << 16);
390 static int pt_atapi(struct pt_unit *tape, char *cmd, int dlen, char *buf, char *fun)
394 r = pt_command(tape, cmd, dlen, fun);
397 r = pt_completion(tape, buf, fun);
399 pt_req_sense(tape, !fun);
404 static void pt_sleep(int cs)
406 current->state = TASK_INTERRUPTIBLE;
407 schedule_timeout(cs);
410 static int pt_poll_dsc(struct pt_unit *tape, int pause, int tmo, char *msg)
412 struct pi_adapter *pi = tape->pi;
422 write_reg(pi, 6, DRIVE(tape));
426 if (s & (STAT_ERR | STAT_SEEK))
429 if ((k >= tmo) || (s & STAT_ERR)) {
431 printk("%s: %s DSC timeout\n", tape->name, msg);
433 printk("%s: %s stat=0x%x err=0x%x\n", tape->name, msg, s,
435 pt_req_sense(tape, 0);
441 static void pt_media_access_cmd(struct pt_unit *tape, int tmo, char *cmd, char *fun)
443 if (pt_command(tape, cmd, 0, fun)) {
444 pt_req_sense(tape, 0);
447 pi_disconnect(tape->pi);
448 pt_poll_dsc(tape, HZ, tmo, fun);
451 static void pt_rewind(struct pt_unit *tape)
453 char rw_cmd[12] = { ATAPI_REWIND, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
455 pt_media_access_cmd(tape, PT_REWIND_TMO, rw_cmd, "rewind");
458 static void pt_write_fm(struct pt_unit *tape)
460 char wm_cmd[12] = { ATAPI_WFM, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 };
462 pt_media_access_cmd(tape, PT_TMO, wm_cmd, "write filemark");
465 #define DBMSG(msg) ((verbose>1)?(msg):NULL)
467 static int pt_reset(struct pt_unit *tape)
469 struct pi_adapter *pi = tape->pi;
471 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
474 write_reg(pi, 6, DRIVE(tape));
477 pt_sleep(20 * HZ / 1000);
480 while ((k++ < PT_RESET_TMO) && (status_reg(pi) & STAT_BUSY))
484 for (i = 0; i < 5; i++)
485 flg &= (read_reg(pi, i + 1) == expect[i]);
488 printk("%s: Reset (%d) signature = ", tape->name, k);
489 for (i = 0; i < 5; i++)
490 printk("%3x", read_reg(pi, i + 1));
492 printk(" (incorrect)");
500 static int pt_ready_wait(struct pt_unit *tape, int tmo)
502 char tr_cmd[12] = { ATAPI_TEST_READY, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
507 tape->last_sense = 0;
508 pt_atapi(tape, tr_cmd, 0, NULL, DBMSG("test unit ready"));
509 p = tape->last_sense;
512 if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6)))
517 return 0x000020; /* timeout */
520 static void xs(char *buf, char *targ, int offs, int len)
526 for (k = 0; k < len; k++)
527 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
528 l = targ[j++] = buf[k + offs];
534 static int xn(char *buf, int offs, int size)
539 for (k = 0; k < size; k++)
540 v = v * 256 + (buf[k + offs] & 0xff);
544 static int pt_identify(struct pt_unit *tape)
547 char *ms[2] = { "master", "slave" };
549 char id_cmd[12] = { ATAPI_IDENTIFY, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
551 { ATAPI_MODE_SENSE, 0, 0x2a, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
553 { ATAPI_LOG_SENSE, 0, 0x71, 0, 0, 0, 0, 0, 36, 0, 0, 0 };
556 s = pt_atapi(tape, id_cmd, 36, buf, "identify");
563 printk("%s: Drive %d, unsupported type %d\n",
564 tape->name, tape->drive, dt);
575 if (!pt_ready_wait(tape, PT_READY_TMO))
576 tape->flags |= PT_MEDIA;
578 if (!pt_atapi(tape, ms_cmd, 36, buf, "mode sense")) {
579 if (!(buf[2] & 0x80))
580 tape->flags |= PT_WRITE_OK;
581 tape->bs = xn(buf, 10, 2);
584 if (!pt_atapi(tape, ls_cmd, 36, buf, "log sense"))
585 tape->capacity = xn(buf, 24, 4);
587 printk("%s: %s %s, %s", tape->name, mf, id, ms[tape->drive]);
588 if (!(tape->flags & PT_MEDIA))
589 printk(", no media\n");
591 if (!(tape->flags & PT_WRITE_OK))
593 printk(", blocksize %d, %d MB\n", tape->bs, tape->capacity / 1024);
601 * returns 0, with id set if drive is detected
602 * -1, if drive detection failed
604 static int pt_probe(struct pt_unit *tape)
606 if (tape->drive == -1) {
607 for (tape->drive = 0; tape->drive <= 1; tape->drive++)
609 return pt_identify(tape);
612 return pt_identify(tape);
617 static int pt_detect(void)
619 struct pt_unit *tape;
620 int specified = 0, found = 0;
623 printk("%s: %s version %s, major %d\n", name, name, PT_VERSION, major);
626 for (unit = 0; unit < PT_UNITS; unit++) {
627 struct pt_unit *tape = &pt[unit];
628 tape->pi = &tape->pia;
629 atomic_set(&tape->available, 1);
631 tape->last_sense = 0;
634 tape->drive = DU[D_SLV];
635 snprintf(tape->name, PT_NAMELEN, "%s%d", name, unit);
639 if (pi_init(tape->pi, 0, DU[D_PRT], DU[D_MOD], DU[D_UNI],
640 DU[D_PRO], DU[D_DLY], pt_scratch, PI_PT,
641 verbose, tape->name)) {
642 if (!pt_probe(tape)) {
646 pi_release(tape->pi);
649 if (specified == 0) {
651 if (pi_init(tape->pi, 1, -1, -1, -1, -1, -1, pt_scratch,
652 PI_PT, verbose, tape->name)) {
653 if (!pt_probe(tape)) {
657 pi_release(tape->pi);
664 printk("%s: No ATAPI tape drive detected\n", name);
668 static int pt_open(struct inode *inode, struct file *file)
670 int unit = iminor(inode) & 0x7F;
671 struct pt_unit *tape = pt + unit;
674 if (unit >= PT_UNITS || (!tape->present))
678 if (!atomic_dec_and_test(&tape->available))
684 if (!tape->flags & PT_MEDIA)
688 if ((!tape->flags & PT_WRITE_OK) && (file->f_mode & 2))
691 if (!(iminor(inode) & 128))
692 tape->flags |= PT_REWIND;
695 tape->bufptr = kmalloc(PT_BUFSIZE, GFP_KERNEL);
696 if (tape->bufptr == NULL) {
697 printk("%s: buffer allocation failed\n", tape->name);
701 file->private_data = tape;
705 atomic_inc(&tape->available);
709 static int pt_ioctl(struct inode *inode, struct file *file,
710 unsigned int cmd, unsigned long arg)
712 struct pt_unit *tape = file->private_data;
713 struct mtop __user *p = (void __user *)arg;
718 if (copy_from_user(&mtop, p, sizeof(struct mtop)))
721 switch (mtop.mt_op) {
732 printk("%s: Unimplemented mt_op %d\n", tape->name,
738 printk("%s: Unimplemented ioctl 0x%x\n", tape->name, cmd);
745 pt_release(struct inode *inode, struct file *file)
747 struct pt_unit *tape = file->private_data;
749 if (atomic_read(&tape->available) > 1)
752 if (tape->flags & PT_WRITING)
755 if (tape->flags & PT_REWIND)
761 atomic_inc(&tape->available);
767 static ssize_t pt_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
769 struct pt_unit *tape = filp->private_data;
770 struct pi_adapter *pi = tape->pi;
771 char rd_cmd[12] = { ATAPI_READ_6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
772 int k, n, r, p, s, t, b;
774 if (!(tape->flags & (PT_READING | PT_WRITING))) {
775 tape->flags |= PT_READING;
776 if (pt_atapi(tape, rd_cmd, 0, NULL, "start read-ahead"))
778 } else if (tape->flags & PT_WRITING)
781 if (tape->flags & PT_EOF)
788 if (!pt_poll_dsc(tape, HZ / 100, PT_TMO, "read"))
793 n = 32768; /* max per command */
794 b = (n - 1 + tape->bs) / tape->bs;
795 n = b * tape->bs; /* rounded up to even block */
799 r = pt_command(tape, rd_cmd, n, "read");
804 pt_req_sense(tape, 0);
810 r = pt_wait(tape, STAT_BUSY,
811 STAT_DRQ | STAT_ERR | STAT_READY,
812 DBMSG("read DRQ"), "");
814 if (r & STAT_SENSE) {
816 pt_req_sense(tape, 0);
821 tape->flags |= PT_EOF;
828 n = (read_reg(pi, 4) + 256 * read_reg(pi, 5));
829 p = (read_reg(pi, 2) & 3);
832 printk("%s: Phase error on read: %d\n", tape->name,
841 pi_read_block(pi, tape->bufptr, k);
846 if (copy_to_user(buf + t, tape->bufptr, b)) {
856 if (tape->flags & PT_EOF)
864 static ssize_t pt_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
866 struct pt_unit *tape = filp->private_data;
867 struct pi_adapter *pi = tape->pi;
868 char wr_cmd[12] = { ATAPI_WRITE_6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
869 int k, n, r, p, s, t, b;
871 if (!(tape->flags & PT_WRITE_OK))
874 if (!(tape->flags & (PT_READING | PT_WRITING))) {
875 tape->flags |= PT_WRITING;
877 (tape, wr_cmd, 0, NULL, "start buffer-available mode"))
879 } else if (tape->flags & PT_READING)
882 if (tape->flags & PT_EOF)
889 if (!pt_poll_dsc(tape, HZ / 100, PT_TMO, "write"))
894 n = 32768; /* max per command */
895 b = (n - 1 + tape->bs) / tape->bs;
896 n = b * tape->bs; /* rounded up to even block */
900 r = pt_command(tape, wr_cmd, n, "write");
904 if (r) { /* error delivering command only */
905 pt_req_sense(tape, 0);
911 r = pt_wait(tape, STAT_BUSY,
912 STAT_DRQ | STAT_ERR | STAT_READY,
913 DBMSG("write DRQ"), NULL);
915 if (r & STAT_SENSE) {
917 pt_req_sense(tape, 0);
922 tape->flags |= PT_EOF;
929 n = (read_reg(pi, 4) + 256 * read_reg(pi, 5));
930 p = (read_reg(pi, 2) & 3);
933 printk("%s: Phase error on write: %d \n",
945 if (copy_from_user(tape->bufptr, buf + t, b)) {
949 pi_write_block(pi, tape->bufptr, k);
957 if (tape->flags & PT_EOF)
964 static int __init pt_init(void)
978 if (register_chrdev(major, name, &pt_fops)) {
979 printk("pt_init: unable to get major number %d\n", major);
980 for (unit = 0; unit < PT_UNITS; unit++)
981 if (pt[unit].present)
982 pi_release(pt[unit].pi);
986 pt_class = class_simple_create(THIS_MODULE, "pt");
987 if (IS_ERR(pt_class)) {
988 err = PTR_ERR(pt_class);
993 for (unit = 0; unit < PT_UNITS; unit++)
994 if (pt[unit].present) {
995 class_simple_device_add(pt_class, MKDEV(major, unit),
997 err = devfs_mk_cdev(MKDEV(major, unit),
998 S_IFCHR | S_IRUSR | S_IWUSR,
1001 class_simple_device_remove(MKDEV(major, unit));
1004 class_simple_device_add(pt_class, MKDEV(major, unit + 128),
1005 NULL, "pt%dn", unit);
1006 err = devfs_mk_cdev(MKDEV(major, unit + 128),
1007 S_IFCHR | S_IRUSR | S_IWUSR,
1010 class_simple_device_remove(MKDEV(major, unit + 128));
1017 class_simple_destroy(pt_class);
1019 unregister_chrdev(major, "pt");
1024 static void __exit pt_exit(void)
1027 for (unit = 0; unit < PT_UNITS; unit++)
1028 if (pt[unit].present) {
1029 class_simple_device_remove(MKDEV(major, unit));
1030 devfs_remove("pt/%d", unit);
1031 class_simple_device_remove(MKDEV(major, unit + 128));
1032 devfs_remove("pt/%dn", unit);
1034 class_simple_destroy(pt_class);
1036 unregister_chrdev(major, name);
1037 for (unit = 0; unit < PT_UNITS; unit++)
1038 if (pt[unit].present)
1039 pi_release(pt[unit].pi);
1042 MODULE_LICENSE("GPL");
1043 module_init(pt_init)
1044 module_exit(pt_exit)