2 pf.c (c) 1997-8 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 disk
6 drives based on chips supported by the paride module.
8 By default, the driver will autoprobe for a single parallel
9 port ATAPI disk drive, but if their individual parameters are
10 specified, the driver can handle up to 4 drives.
12 The behaviour of the pf driver can be altered by setting
13 some parameters from the insmod command line. The following
14 parameters are adjustable:
16 drive0 These four arguments can be arrays of
17 drive1 1-7 integers as follows:
19 drive3 <prt>,<pro>,<uni>,<mod>,<slv>,<lun>,<dly>
23 <prt> is the base of the parallel port address for
24 the corresponding drive. (required)
26 <pro> is the protocol number for the adapter that
27 supports this drive. These numbers are
28 logged by 'paride' when the protocol modules
29 are initialised. (0 if not given)
31 <uni> for those adapters that support chained
32 devices, this is the unit selector for the
33 chain of devices on the given port. It should
34 be zero for devices that don't support chaining.
37 <mod> this can be -1 to choose the best mode, or one
38 of the mode numbers supported by the adapter.
41 <slv> ATAPI CDroms can be jumpered to master or slave.
42 Set this to 0 to choose the master drive, 1 to
43 choose the slave, -1 (the default) to choose the
46 <lun> Some ATAPI devices support multiple LUNs.
47 One example is the ATAPI PD/CD drive from
48 Matshita/Panasonic. This device has a
49 CD drive on LUN 0 and a PD drive on LUN 1.
50 By default, the driver will search for the
51 first LUN with a supported device. Set
52 this parameter to force it to use a specific
55 <dly> some parallel ports require the driver to
56 go more slowly. -1 sets a default value that
57 should work with the chosen protocol. Otherwise,
58 set this to a small integer, the larger it is
59 the slower the port i/o. In some cases, setting
60 this to zero will speed up the device. (default -1)
62 major You may use this parameter to overide the
63 default major number (47) that this driver
64 will use. Be sure to change the device
67 name This parameter is a character string that
68 contains the name the kernel will use for this
69 device (in /proc output, for instance).
72 cluster The driver will attempt to aggregate requests
73 for adjacent blocks into larger multi-block
74 clusters. The maximum cluster size (in 512
75 byte sectors) is set with this parameter.
78 verbose This parameter controls the amount of logging
79 that the driver will do. Set it to 0 for
80 normal operation, 1 to see autoprobe progress
81 messages, or 2 to see additional debugging
84 nice This parameter controls the driver's use of
85 idle CPU time, at the expense of some speed.
87 If this driver is built into the kernel, you can use the
88 following command line parameters, with the same values
89 as the corresponding module parameters listed above:
98 In addition, you can use the parameter pf.disable to disable
105 1.01 GRG 1998.05.03 Changes for SMP. Eliminate sti().
106 Fix for drives that don't clear STAT_ERR
107 until after next CDB delivered.
108 Small change in pf_completion to round
110 1.02 GRG 1998.06.16 Eliminated an Ugh
111 1.03 GRG 1998.08.16 Use HZ in loop timings, extra debugging
112 1.04 GRG 1998.09.24 Added jumbo support
116 #define PF_VERSION "1.04"
121 /* Here are things one can override from the insmod command.
122 Most are autoprobed by paride unless set here. Verbose is off
127 static int verbose = 0;
128 static int major = PF_MAJOR;
129 static char *name = PF_NAME;
130 static int cluster = 64;
132 static int disable = 0;
134 static int drive0[7] = { 0, 0, 0, -1, -1, -1, -1 };
135 static int drive1[7] = { 0, 0, 0, -1, -1, -1, -1 };
136 static int drive2[7] = { 0, 0, 0, -1, -1, -1, -1 };
137 static int drive3[7] = { 0, 0, 0, -1, -1, -1, -1 };
139 static int (*drives[4])[7] = {&drive0, &drive1, &drive2, &drive3};
140 static int pf_drive_count;
142 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_LUN, D_DLY};
144 /* end of parameters */
146 #include <linux/module.h>
147 #include <linux/init.h>
148 #include <linux/fs.h>
149 #include <linux/delay.h>
150 #include <linux/hdreg.h>
151 #include <linux/cdrom.h>
152 #include <linux/spinlock.h>
153 #include <linux/blkdev.h>
154 #include <linux/blkpg.h>
155 #include <linux/mutex.h>
156 #include <asm/uaccess.h>
158 static DEFINE_MUTEX(pf_mutex);
159 static DEFINE_SPINLOCK(pf_spin_lock);
161 module_param(verbose, bool, 0644);
162 module_param(major, int, 0);
163 module_param(name, charp, 0);
164 module_param(cluster, int, 0);
165 module_param(nice, int, 0);
166 module_param_array(drive0, int, NULL, 0);
167 module_param_array(drive1, int, NULL, 0);
168 module_param_array(drive2, int, NULL, 0);
169 module_param_array(drive3, int, NULL, 0);
174 /* constants for faking geometry numbers */
176 #define PF_FD_MAX 8192 /* use FD geometry under this size */
182 #define PF_MAX_RETRIES 5
183 #define PF_TMO 800 /* interrupt timeout in jiffies */
184 #define PF_SPIN_DEL 50 /* spin delay in micro-seconds */
186 #define PF_SPIN (1000000*PF_TMO)/(HZ*PF_SPIN_DEL)
188 #define STAT_ERR 0x00001
189 #define STAT_INDEX 0x00002
190 #define STAT_ECC 0x00004
191 #define STAT_DRQ 0x00008
192 #define STAT_SEEK 0x00010
193 #define STAT_WRERR 0x00020
194 #define STAT_READY 0x00040
195 #define STAT_BUSY 0x00080
197 #define ATAPI_REQ_SENSE 0x03
198 #define ATAPI_LOCK 0x1e
199 #define ATAPI_DOOR 0x1b
200 #define ATAPI_MODE_SENSE 0x5a
201 #define ATAPI_CAPACITY 0x25
202 #define ATAPI_IDENTIFY 0x12
203 #define ATAPI_READ_10 0x28
204 #define ATAPI_WRITE_10 0x2a
206 static int pf_open(struct block_device *bdev, fmode_t mode);
207 static void do_pf_request(struct request_queue * q);
208 static int pf_ioctl(struct block_device *bdev, fmode_t mode,
209 unsigned int cmd, unsigned long arg);
210 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
212 static int pf_release(struct gendisk *disk, fmode_t mode);
214 static int pf_detect(void);
215 static void do_pf_read(void);
216 static void do_pf_read_start(void);
217 static void do_pf_write(void);
218 static void do_pf_write_start(void);
219 static void do_pf_read_drq(void);
220 static void do_pf_write_done(void);
229 struct pi_adapter pia; /* interface to paride layer */
230 struct pi_adapter *pi;
231 int removable; /* removable media device ? */
232 int media_status; /* media present ? WP ? */
233 int drive; /* drive */
235 int access; /* count of active opens ... */
236 int present; /* device present ? */
237 char name[PF_NAMELEN]; /* pf0, pf1, ... */
238 struct gendisk *disk;
241 static struct pf_unit units[PF_UNITS];
243 static int pf_identify(struct pf_unit *pf);
244 static void pf_lock(struct pf_unit *pf, int func);
245 static void pf_eject(struct pf_unit *pf);
246 static int pf_check_media(struct gendisk *disk);
248 static char pf_scratch[512]; /* scratch block buffer */
250 /* the variables below are used mainly in the I/O request engine, which
251 processes only one request at a time.
254 static int pf_retries = 0; /* i/o error retry count */
255 static int pf_busy = 0; /* request being processed ? */
256 static struct request *pf_req; /* current request */
257 static int pf_block; /* address of next requested block */
258 static int pf_count; /* number of blocks still to do */
259 static int pf_run; /* sectors in current cluster */
260 static int pf_cmd; /* current command READ/WRITE */
261 static struct pf_unit *pf_current;/* unit of current request */
262 static int pf_mask; /* stopper for pseudo-int */
263 static char *pf_buf; /* buffer for request in progress */
265 /* kernel glue structures */
267 static const struct block_device_operations pf_fops = {
268 .owner = THIS_MODULE,
270 .release = pf_release,
273 .media_changed = pf_check_media,
276 static void __init pf_init_units(void)
282 for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
283 struct gendisk *disk = alloc_disk(1);
288 pf->media_status = PF_NM;
289 pf->drive = (*drives[unit])[D_SLV];
290 pf->lun = (*drives[unit])[D_LUN];
291 snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
293 disk->first_minor = unit;
294 strcpy(disk->disk_name, pf->name);
295 disk->fops = &pf_fops;
296 if (!(*drives[unit])[D_PRT])
301 static int pf_open(struct block_device *bdev, fmode_t mode)
303 struct pf_unit *pf = bdev->bd_disk->private_data;
306 mutex_lock(&pf_mutex);
310 if (pf->media_status == PF_NM)
314 if ((pf->media_status == PF_RO) && (mode & FMODE_WRITE))
322 mutex_unlock(&pf_mutex);
326 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo)
328 struct pf_unit *pf = bdev->bd_disk->private_data;
329 sector_t capacity = get_capacity(pf->disk);
331 if (capacity < PF_FD_MAX) {
332 geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT);
333 geo->heads = PF_FD_HDS;
334 geo->sectors = PF_FD_SPT;
336 geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT);
337 geo->heads = PF_HD_HDS;
338 geo->sectors = PF_HD_SPT;
344 static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
346 struct pf_unit *pf = bdev->bd_disk->private_data;
348 if (cmd != CDROMEJECT)
353 mutex_lock(&pf_mutex);
355 mutex_unlock(&pf_mutex);
360 static int pf_release(struct gendisk *disk, fmode_t mode)
362 struct pf_unit *pf = disk->private_data;
364 mutex_lock(&pf_mutex);
365 if (pf->access <= 0) {
366 mutex_unlock(&pf_mutex);
372 if (!pf->access && pf->removable)
375 mutex_unlock(&pf_mutex);
380 static int pf_check_media(struct gendisk *disk)
385 static inline int status_reg(struct pf_unit *pf)
387 return pi_read_regr(pf->pi, 1, 6);
390 static inline int read_reg(struct pf_unit *pf, int reg)
392 return pi_read_regr(pf->pi, 0, reg);
395 static inline void write_reg(struct pf_unit *pf, int reg, int val)
397 pi_write_regr(pf->pi, 0, reg, val);
400 static int pf_wait(struct pf_unit *pf, int go, int stop, char *fun, char *msg)
405 while ((((r = status_reg(pf)) & go) || (stop && (!(r & stop))))
409 if ((r & (STAT_ERR & stop)) || (j > PF_SPIN)) {
416 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
417 " loop=%d phase=%d\n",
418 pf->name, fun, msg, r, s, e, j, p);
424 static int pf_command(struct pf_unit *pf, char *cmd, int dlen, char *fun)
428 write_reg(pf, 6, 0xa0+0x10*pf->drive);
430 if (pf_wait(pf, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
431 pi_disconnect(pf->pi);
435 write_reg(pf, 4, dlen % 256);
436 write_reg(pf, 5, dlen / 256);
437 write_reg(pf, 7, 0xa0); /* ATAPI packet command */
439 if (pf_wait(pf, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
440 pi_disconnect(pf->pi);
444 if (read_reg(pf, 2) != 1) {
445 printk("%s: %s: command phase error\n", pf->name, fun);
446 pi_disconnect(pf->pi);
450 pi_write_block(pf->pi, cmd, 12);
455 static int pf_completion(struct pf_unit *pf, char *buf, char *fun)
459 r = pf_wait(pf, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
462 if ((read_reg(pf, 2) & 2) && (read_reg(pf, 7) & STAT_DRQ)) {
463 n = (((read_reg(pf, 4) + 256 * read_reg(pf, 5)) +
465 pi_read_block(pf->pi, buf, n);
468 s = pf_wait(pf, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
470 pi_disconnect(pf->pi);
475 static void pf_req_sense(struct pf_unit *pf, int quiet)
478 { ATAPI_REQ_SENSE, pf->lun << 5, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
482 r = pf_command(pf, rs_cmd, 16, "Request sense");
485 pf_completion(pf, buf, "Request sense");
487 if ((!r) && (!quiet))
488 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
489 pf->name, buf[2] & 0xf, buf[12], buf[13]);
492 static int pf_atapi(struct pf_unit *pf, char *cmd, int dlen, char *buf, char *fun)
496 r = pf_command(pf, cmd, dlen, fun);
499 r = pf_completion(pf, buf, fun);
501 pf_req_sense(pf, !fun);
506 static void pf_lock(struct pf_unit *pf, int func)
508 char lo_cmd[12] = { ATAPI_LOCK, pf->lun << 5, 0, 0, func, 0, 0, 0, 0, 0, 0, 0 };
510 pf_atapi(pf, lo_cmd, 0, pf_scratch, func ? "lock" : "unlock");
513 static void pf_eject(struct pf_unit *pf)
515 char ej_cmd[12] = { ATAPI_DOOR, pf->lun << 5, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
518 pf_atapi(pf, ej_cmd, 0, pf_scratch, "eject");
521 #define PF_RESET_TMO 30 /* in tenths of a second */
523 static void pf_sleep(int cs)
525 schedule_timeout_interruptible(cs);
528 /* the ATAPI standard actually specifies the contents of all 7 registers
529 after a reset, but the specification is ambiguous concerning the last
530 two bytes, and different drives interpret the standard differently.
533 static int pf_reset(struct pf_unit *pf)
536 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
539 write_reg(pf, 6, 0xa0+0x10*pf->drive);
542 pf_sleep(20 * HZ / 1000);
545 while ((k++ < PF_RESET_TMO) && (status_reg(pf) & STAT_BUSY))
549 for (i = 0; i < 5; i++)
550 flg &= (read_reg(pf, i + 1) == expect[i]);
553 printk("%s: Reset (%d) signature = ", pf->name, k);
554 for (i = 0; i < 5; i++)
555 printk("%3x", read_reg(pf, i + 1));
557 printk(" (incorrect)");
561 pi_disconnect(pf->pi);
565 static void pf_mode_sense(struct pf_unit *pf)
568 { ATAPI_MODE_SENSE, pf->lun << 5, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0 };
571 pf_atapi(pf, ms_cmd, 8, buf, "mode sense");
572 pf->media_status = PF_RW;
574 pf->media_status = PF_RO;
577 static void xs(char *buf, char *targ, int offs, int len)
583 for (k = 0; k < len; k++)
584 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
585 l = targ[j++] = buf[k + offs];
591 static int xl(char *buf, int offs)
596 for (k = 0; k < 4; k++)
597 v = v * 256 + (buf[k + offs] & 0xff);
601 static void pf_get_capacity(struct pf_unit *pf)
603 char rc_cmd[12] = { ATAPI_CAPACITY, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
607 if (pf_atapi(pf, rc_cmd, 8, buf, "get capacity")) {
608 pf->media_status = PF_NM;
611 set_capacity(pf->disk, xl(buf, 0) + 1);
614 set_capacity(pf->disk, 0);
616 printk("%s: Drive %d, LUN %d,"
617 " unsupported block size %d\n",
618 pf->name, pf->drive, pf->lun, bs);
622 static int pf_identify(struct pf_unit *pf)
625 char *ms[2] = { "master", "slave" };
628 { ATAPI_IDENTIFY, pf->lun << 5, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
631 s = pf_atapi(pf, id_cmd, 36, buf, "identify");
636 if ((dt != 0) && (dt != 7)) {
638 printk("%s: Drive %d, LUN %d, unsupported type %d\n",
639 pf->name, pf->drive, pf->lun, dt);
646 pf->removable = (buf[1] & 0x80);
654 printk("%s: %s %s, %s LUN %d, type %d",
655 pf->name, mf, id, ms[pf->drive], pf->lun, dt);
657 printk(", removable");
658 if (pf->media_status == PF_NM)
659 printk(", no media\n");
661 if (pf->media_status == PF_RO)
663 printk(", %llu blocks\n",
664 (unsigned long long)get_capacity(pf->disk));
669 /* returns 0, with id set if drive is detected
670 -1, if drive detection failed
672 static int pf_probe(struct pf_unit *pf)
674 if (pf->drive == -1) {
675 for (pf->drive = 0; pf->drive <= 1; pf->drive++)
678 return pf_identify(pf);
680 for (pf->lun = 0; pf->lun < 8; pf->lun++)
681 if (!pf_identify(pf))
688 return pf_identify(pf);
689 for (pf->lun = 0; pf->lun < 8; pf->lun++)
690 if (!pf_identify(pf))
696 static int pf_detect(void)
698 struct pf_unit *pf = units;
701 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
702 name, name, PF_VERSION, major, cluster, nice);
705 if (pf_drive_count == 0) {
706 if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
707 verbose, pf->name)) {
708 if (!pf_probe(pf) && pf->disk) {
716 for (unit = 0; unit < PF_UNITS; unit++, pf++) {
717 int *conf = *drives[unit];
720 if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
721 conf[D_UNI], conf[D_PRO], conf[D_DLY],
722 pf_scratch, PI_PF, verbose, pf->name)) {
723 if (pf->disk && !pf_probe(pf)) {
733 printk("%s: No ATAPI disk detected\n", name);
734 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
739 /* The i/o request engine */
741 static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
744 char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
746 for (i = 0; i < 4; i++) {
747 io_cmd[5 - i] = b & 0xff;
751 io_cmd[8] = c & 0xff;
752 io_cmd[7] = (c >> 8) & 0xff;
754 i = pf_command(pf, io_cmd, c * 512, "start i/o");
761 static int pf_ready(void)
763 return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
766 static struct request_queue *pf_queue;
768 static void pf_end_request(int err)
770 if (pf_req && !__blk_end_request_cur(pf_req, err))
774 static void do_pf_request(struct request_queue * q)
780 pf_req = blk_fetch_request(q);
785 pf_current = pf_req->rq_disk->private_data;
786 pf_block = blk_rq_pos(pf_req);
787 pf_run = blk_rq_sectors(pf_req);
788 pf_count = blk_rq_cur_sectors(pf_req);
790 if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
791 pf_end_request(-EIO);
795 pf_cmd = rq_data_dir(pf_req);
796 pf_buf = pf_req->buffer;
801 pi_do_claimed(pf_current->pi, do_pf_read);
802 else if (pf_cmd == WRITE)
803 pi_do_claimed(pf_current->pi, do_pf_write);
806 pf_end_request(-EIO);
811 static int pf_next_buf(void)
813 unsigned long saved_flags;
822 spin_lock_irqsave(&pf_spin_lock, saved_flags);
824 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
827 pf_count = blk_rq_cur_sectors(pf_req);
828 pf_buf = pf_req->buffer;
833 static inline void next_request(int err)
835 unsigned long saved_flags;
837 spin_lock_irqsave(&pf_spin_lock, saved_flags);
840 do_pf_request(pf_queue);
841 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
844 /* detach from the calling context - in case the spinlock is held */
845 static void do_pf_read(void)
847 ps_set_intr(do_pf_read_start, NULL, 0, nice);
850 static void do_pf_read_start(void)
854 if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
855 pi_disconnect(pf_current->pi);
856 if (pf_retries < PF_MAX_RETRIES) {
858 pi_do_claimed(pf_current->pi, do_pf_read_start);
865 ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
868 static void do_pf_read_drq(void)
871 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
872 "read block", "completion") & STAT_ERR) {
873 pi_disconnect(pf_current->pi);
874 if (pf_retries < PF_MAX_RETRIES) {
875 pf_req_sense(pf_current, 0);
877 pi_do_claimed(pf_current->pi, do_pf_read_start);
883 pi_read_block(pf_current->pi, pf_buf, 512);
887 pi_disconnect(pf_current->pi);
891 static void do_pf_write(void)
893 ps_set_intr(do_pf_write_start, NULL, 0, nice);
896 static void do_pf_write_start(void)
900 if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
901 pi_disconnect(pf_current->pi);
902 if (pf_retries < PF_MAX_RETRIES) {
904 pi_do_claimed(pf_current->pi, do_pf_write_start);
912 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
913 "write block", "data wait") & STAT_ERR) {
914 pi_disconnect(pf_current->pi);
915 if (pf_retries < PF_MAX_RETRIES) {
917 pi_do_claimed(pf_current->pi, do_pf_write_start);
923 pi_write_block(pf_current->pi, pf_buf, 512);
928 ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
931 static void do_pf_write_done(void)
933 if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
934 pi_disconnect(pf_current->pi);
935 if (pf_retries < PF_MAX_RETRIES) {
937 pi_do_claimed(pf_current->pi, do_pf_write_start);
943 pi_disconnect(pf_current->pi);
947 static int __init pf_init(void)
948 { /* preliminary initialisation */
961 if (register_blkdev(major, name)) {
962 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
966 pf_queue = blk_init_queue(do_pf_request, &pf_spin_lock);
968 unregister_blkdev(major, name);
969 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
974 blk_queue_max_segments(pf_queue, cluster);
976 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
977 struct gendisk *disk = pf->disk;
981 disk->private_data = pf;
982 disk->queue = pf_queue;
988 static void __exit pf_exit(void)
992 unregister_blkdev(major, name);
993 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
996 del_gendisk(pf->disk);
1000 blk_cleanup_queue(pf_queue);
1003 MODULE_LICENSE("GPL");
1004 module_init(pf_init)
1005 module_exit(pf_exit)