2 pd.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 IDE hard
6 drives based on chips supported by the paride module.
8 By default, the driver will autoprobe for a single parallel
9 port IDE drive, but if their individual parameters are
10 specified, the driver can handle up to 4 drives.
12 The behaviour of the pd 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-8 integers as follows:
19 drive3 <prt>,<pro>,<uni>,<mod>,<geo>,<sby>,<dly>,<slv>
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 <geo> this defaults to 0 to indicate that the driver
42 should use the CHS geometry provided by the drive
43 itself. If set to 1, the driver will provide
44 a logical geometry with 64 heads and 32 sectors
45 per track, to be consistent with most SCSI
46 drivers. (0 if not given)
48 <sby> set this to zero to disable the power saving
49 standby mode, if needed. (1 if not given)
51 <dly> some parallel ports require the driver to
52 go more slowly. -1 sets a default value that
53 should work with the chosen protocol. Otherwise,
54 set this to a small integer, the larger it is
55 the slower the port i/o. In some cases, setting
56 this to zero will speed up the device. (default -1)
58 <slv> IDE disks can be jumpered to master or slave.
59 Set this to 0 to choose the master drive, 1 to
60 choose the slave, -1 (the default) to choose the
64 major You may use this parameter to overide the
65 default major number (45) 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 cluster The driver will attempt to aggregate requests
75 for adjacent blocks into larger multi-block
76 clusters. The maximum cluster size (in 512
77 byte sectors) is set with this parameter.
80 verbose This parameter controls the amount of logging
81 that the driver will do. Set it to 0 for
82 normal operation, 1 to see autoprobe progress
83 messages, or 2 to see additional debugging
86 nice This parameter controls the driver's use of
87 idle CPU time, at the expense of some speed.
89 If this driver is built into the kernel, you can use kernel
90 the following command line parameters, with the same values
91 as the corresponding module parameters listed above:
100 In addition, you can use the parameter pd.disable to disable
107 1.01 GRG 1997.01.24 Restored pd_reset()
109 1.02 GRG 1998.05.06 SMP spinlock changes,
111 1.03 GRG 1998.06.16 Eliminate an Ugh.
112 1.04 GRG 1998.08.15 Extra debugging, use HZ in loop timing
113 1.05 GRG 1998.09.24 Added jumbo support
117 #define PD_VERSION "1.05"
122 /* Here are things one can override from the insmod command.
123 Most are autoprobed by paride unless set here. Verbose is off
128 static int verbose = 0;
129 static int major = PD_MAJOR;
130 static char *name = PD_NAME;
131 static int cluster = 64;
133 static int disable = 0;
135 static int drive0[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
136 static int drive1[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
137 static int drive2[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
138 static int drive3[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
140 static int (*drives[4])[8] = {&drive0, &drive1, &drive2, &drive3};
142 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_GEO, D_SBY, D_DLY, D_SLV};
144 /* end of parameters */
146 #include <linux/init.h>
147 #include <linux/module.h>
148 #include <linux/fs.h>
149 #include <linux/delay.h>
150 #include <linux/hdreg.h>
151 #include <linux/cdrom.h> /* for the eject ioctl */
152 #include <linux/blkdev.h>
153 #include <linux/blkpg.h>
154 #include <linux/kernel.h>
155 #include <asm/uaccess.h>
156 #include <linux/workqueue.h>
158 static DEFINE_SPINLOCK(pd_lock);
160 module_param(verbose, bool, 0);
161 module_param(major, int, 0);
162 module_param(name, charp, 0);
163 module_param(cluster, int, 0);
164 module_param(nice, int, 0);
165 module_param_array(drive0, int, NULL, 0);
166 module_param_array(drive1, int, NULL, 0);
167 module_param_array(drive2, int, NULL, 0);
168 module_param_array(drive3, int, NULL, 0);
174 /* numbers for "SCSI" geometry */
176 #define PD_LOG_HEADS 64
177 #define PD_LOG_SECTS 32
182 #define PD_MAX_RETRIES 5
183 #define PD_TMO 800 /* interrupt timeout in jiffies */
184 #define PD_SPIN_DEL 50 /* spin delay in micro-seconds */
186 #define PD_SPIN (1000000*PD_TMO)/(HZ*PD_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 ERR_AMNF 0x00100
198 #define ERR_TK0NF 0x00200
199 #define ERR_ABRT 0x00400
200 #define ERR_MCR 0x00800
201 #define ERR_IDNF 0x01000
202 #define ERR_MC 0x02000
203 #define ERR_UNC 0x04000
204 #define ERR_TMO 0x10000
206 #define IDE_READ 0x20
207 #define IDE_WRITE 0x30
208 #define IDE_READ_VRFY 0x40
209 #define IDE_INIT_DEV_PARMS 0x91
210 #define IDE_STANDBY 0x96
211 #define IDE_ACKCHANGE 0xdb
212 #define IDE_DOORLOCK 0xde
213 #define IDE_DOORUNLOCK 0xdf
214 #define IDE_IDENTIFY 0xec
215 #define IDE_EJECT 0xed
220 struct pi_adapter pia; /* interface to paride layer */
221 struct pi_adapter *pi;
222 int access; /* count of active opens ... */
223 int capacity; /* Size of this volume in sectors */
224 int heads; /* physical geometry */
228 int drive; /* master=0 slave=1 */
229 int changed; /* Have we seen a disk change ? */
230 int removable; /* removable media device ? */
233 char name[PD_NAMELEN]; /* pda, pdb, etc ... */
237 static struct pd_unit pd[PD_UNITS];
239 static char pd_scratch[512]; /* scratch block buffer */
241 static char *pd_errs[17] = { "ERR", "INDEX", "ECC", "DRQ", "SEEK", "WRERR",
242 "READY", "BUSY", "AMNF", "TK0NF", "ABRT", "MCR",
243 "IDNF", "MC", "UNC", "???", "TMO"
246 static inline int status_reg(struct pd_unit *disk)
248 return pi_read_regr(disk->pi, 1, 6);
251 static inline int read_reg(struct pd_unit *disk, int reg)
253 return pi_read_regr(disk->pi, 0, reg);
256 static inline void write_status(struct pd_unit *disk, int val)
258 pi_write_regr(disk->pi, 1, 6, val);
261 static inline void write_reg(struct pd_unit *disk, int reg, int val)
263 pi_write_regr(disk->pi, 0, reg, val);
266 static inline u8 DRIVE(struct pd_unit *disk)
268 return 0xa0+0x10*disk->drive;
271 /* ide command interface */
273 static void pd_print_error(struct pd_unit *disk, char *msg, int status)
277 printk("%s: %s: status = 0x%x =", disk->name, msg, status);
278 for (i = 0; i < ARRAY_SIZE(pd_errs); i++)
279 if (status & (1 << i))
280 printk(" %s", pd_errs[i]);
284 static void pd_reset(struct pd_unit *disk)
285 { /* called only for MASTER drive */
286 write_status(disk, 4);
288 write_status(disk, 0);
292 #define DBMSG(msg) ((verbose>1)?(msg):NULL)
294 static int pd_wait_for(struct pd_unit *disk, int w, char *msg)
299 while (k < PD_SPIN) {
300 r = status_reg(disk);
302 if (((r & w) == w) && !(r & STAT_BUSY))
306 e = (read_reg(disk, 1) << 8) + read_reg(disk, 7);
309 if ((e & (STAT_ERR | ERR_TMO)) && (msg != NULL))
310 pd_print_error(disk, msg, e);
314 static void pd_send_command(struct pd_unit *disk, int n, int s, int h, int c0, int c1, int func)
316 write_reg(disk, 6, DRIVE(disk) + h);
317 write_reg(disk, 1, 0); /* the IDE task file */
318 write_reg(disk, 2, n);
319 write_reg(disk, 3, s);
320 write_reg(disk, 4, c0);
321 write_reg(disk, 5, c1);
322 write_reg(disk, 7, func);
327 static void pd_ide_command(struct pd_unit *disk, int func, int block, int count)
333 c0 = (block >>= 8) & 255;
334 c1 = (block >>= 8) & 255;
335 h = ((block >>= 8) & 15) + 0x40;
337 s = (block % disk->sectors) + 1;
338 h = (block /= disk->sectors) % disk->heads;
339 c0 = (block /= disk->heads) % 256;
342 pd_send_command(disk, count, s, h, c0, c1, func);
345 /* The i/o request engine */
347 enum action {Fail = 0, Ok = 1, Hold, Wait};
349 static struct request *pd_req; /* current request */
350 static enum action (*phase)(void);
352 static void run_fsm(void);
354 static void ps_tq_int(struct work_struct *work);
356 static DECLARE_DELAYED_WORK(fsm_tq, ps_tq_int);
358 static void schedule_fsm(void)
361 schedule_delayed_work(&fsm_tq, 0);
363 schedule_delayed_work(&fsm_tq, nice-1);
366 static void ps_tq_int(struct work_struct *work)
371 static enum action do_pd_io_start(void);
372 static enum action pd_special(void);
373 static enum action do_pd_read_start(void);
374 static enum action do_pd_write_start(void);
375 static enum action do_pd_read_drq(void);
376 static enum action do_pd_write_done(void);
378 static struct request_queue *pd_queue;
379 static int pd_claimed;
381 static struct pd_unit *pd_current; /* current request's drive */
382 static PIA *pi_current; /* current request's PIA */
384 static void run_fsm(void)
388 unsigned long saved_flags;
392 pd_current = pd_req->rq_disk->private_data;
393 pi_current = pd_current->pi;
394 phase = do_pd_io_start;
397 switch (pd_claimed) {
400 if (!pi_schedule_claimed(pi_current, run_fsm))
404 pi_current->proto->connect(pi_current);
407 switch(res = phase()) {
409 pi_disconnect(pi_current);
412 spin_lock_irqsave(&pd_lock, saved_flags);
413 if (!__blk_end_request_cur(pd_req,
414 res == Ok ? 0 : -EIO)) {
415 pd_req = blk_fetch_request(pd_queue);
419 spin_unlock_irqrestore(&pd_lock, saved_flags);
426 pi_disconnect(pi_current);
432 static int pd_retries = 0; /* i/o error retry count */
433 static int pd_block; /* address of next requested block */
434 static int pd_count; /* number of blocks still to do */
435 static int pd_run; /* sectors in current cluster */
436 static int pd_cmd; /* current command READ/WRITE */
437 static char *pd_buf; /* buffer for request in progress */
439 static enum action do_pd_io_start(void)
441 if (blk_special_request(pd_req)) {
446 pd_cmd = rq_data_dir(pd_req);
447 if (pd_cmd == READ || pd_cmd == WRITE) {
448 pd_block = blk_rq_pos(pd_req);
449 pd_count = blk_rq_cur_sectors(pd_req);
450 if (pd_block + pd_count > get_capacity(pd_req->rq_disk))
452 pd_run = blk_rq_sectors(pd_req);
453 pd_buf = pd_req->buffer;
456 return do_pd_read_start();
458 return do_pd_write_start();
463 static enum action pd_special(void)
465 enum action (*func)(struct pd_unit *) = pd_req->special;
466 return func(pd_current);
469 static int pd_next_buf(void)
471 unsigned long saved_flags;
481 spin_lock_irqsave(&pd_lock, saved_flags);
482 __blk_end_request_cur(pd_req, 0);
483 pd_count = blk_rq_cur_sectors(pd_req);
484 pd_buf = pd_req->buffer;
485 spin_unlock_irqrestore(&pd_lock, saved_flags);
489 static unsigned long pd_timeout;
491 static enum action do_pd_read_start(void)
493 if (pd_wait_for(pd_current, STAT_READY, "do_pd_read") & STAT_ERR) {
494 if (pd_retries < PD_MAX_RETRIES) {
500 pd_ide_command(pd_current, IDE_READ, pd_block, pd_run);
501 phase = do_pd_read_drq;
502 pd_timeout = jiffies + PD_TMO;
506 static enum action do_pd_write_start(void)
508 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write") & STAT_ERR) {
509 if (pd_retries < PD_MAX_RETRIES) {
515 pd_ide_command(pd_current, IDE_WRITE, pd_block, pd_run);
517 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_write_drq") & STAT_ERR) {
518 if (pd_retries < PD_MAX_RETRIES) {
524 pi_write_block(pd_current->pi, pd_buf, 512);
528 phase = do_pd_write_done;
529 pd_timeout = jiffies + PD_TMO;
533 static inline int pd_ready(void)
535 return !(status_reg(pd_current) & STAT_BUSY);
538 static enum action do_pd_read_drq(void)
540 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
544 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_read_drq") & STAT_ERR) {
545 if (pd_retries < PD_MAX_RETRIES) {
547 phase = do_pd_read_start;
552 pi_read_block(pd_current->pi, pd_buf, 512);
559 static enum action do_pd_write_done(void)
561 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
564 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write_done") & STAT_ERR) {
565 if (pd_retries < PD_MAX_RETRIES) {
567 phase = do_pd_write_start;
575 /* special io requests */
577 /* According to the ATA standard, the default CHS geometry should be
578 available following a reset. Some Western Digital drives come up
579 in a mode where only LBA addresses are accepted until the device
580 parameters are initialised.
583 static void pd_init_dev_parms(struct pd_unit *disk)
585 pd_wait_for(disk, 0, DBMSG("before init_dev_parms"));
586 pd_send_command(disk, disk->sectors, 0, disk->heads - 1, 0, 0,
589 pd_wait_for(disk, 0, "Initialise device parameters");
592 static enum action pd_door_lock(struct pd_unit *disk)
594 if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
595 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORLOCK);
596 pd_wait_for(disk, STAT_READY, "Lock done");
601 static enum action pd_door_unlock(struct pd_unit *disk)
603 if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
604 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
605 pd_wait_for(disk, STAT_READY, "Lock done");
610 static enum action pd_eject(struct pd_unit *disk)
612 pd_wait_for(disk, 0, DBMSG("before unlock on eject"));
613 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
614 pd_wait_for(disk, 0, DBMSG("after unlock on eject"));
615 pd_wait_for(disk, 0, DBMSG("before eject"));
616 pd_send_command(disk, 0, 0, 0, 0, 0, IDE_EJECT);
617 pd_wait_for(disk, 0, DBMSG("after eject"));
621 static enum action pd_media_check(struct pd_unit *disk)
623 int r = pd_wait_for(disk, STAT_READY, DBMSG("before media_check"));
624 if (!(r & STAT_ERR)) {
625 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
626 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after READ_VRFY"));
628 disk->changed = 1; /* say changed if other error */
631 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_ACKCHANGE);
632 pd_wait_for(disk, STAT_READY, DBMSG("RDY after ACKCHANGE"));
633 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
634 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after VRFY"));
639 static void pd_standby_off(struct pd_unit *disk)
641 pd_wait_for(disk, 0, DBMSG("before STANDBY"));
642 pd_send_command(disk, 0, 0, 0, 0, 0, IDE_STANDBY);
643 pd_wait_for(disk, 0, DBMSG("after STANDBY"));
646 static enum action pd_identify(struct pd_unit *disk)
649 char id[PD_ID_LEN + 1];
651 /* WARNING: here there may be dragons. reset() applies to both drives,
652 but we call it only on probing the MASTER. This should allow most
653 common configurations to work, but be warned that a reset can clear
654 settings on the SLAVE drive.
657 if (disk->drive == 0)
660 write_reg(disk, 6, DRIVE(disk));
661 pd_wait_for(disk, 0, DBMSG("before IDENT"));
662 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_IDENTIFY);
664 if (pd_wait_for(disk, STAT_DRQ, DBMSG("IDENT DRQ")) & STAT_ERR)
666 pi_read_block(disk->pi, pd_scratch, 512);
667 disk->can_lba = pd_scratch[99] & 2;
668 disk->sectors = le16_to_cpu(*(__le16 *) (pd_scratch + 12));
669 disk->heads = le16_to_cpu(*(__le16 *) (pd_scratch + 6));
670 disk->cylinders = le16_to_cpu(*(__le16 *) (pd_scratch + 2));
672 disk->capacity = le32_to_cpu(*(__le32 *) (pd_scratch + 120));
674 disk->capacity = disk->sectors * disk->heads * disk->cylinders;
676 for (j = 0; j < PD_ID_LEN; j++)
677 id[j ^ 1] = pd_scratch[j + PD_ID_OFF];
679 while ((j >= 0) && (id[j] <= 0x20))
684 disk->removable = pd_scratch[0] & 0x80;
686 printk("%s: %s, %s, %d blocks [%dM], (%d/%d/%d), %s media\n",
688 disk->drive ? "slave" : "master",
689 disk->capacity, disk->capacity / 2048,
690 disk->cylinders, disk->heads, disk->sectors,
691 disk->removable ? "removable" : "fixed");
694 pd_init_dev_parms(disk);
696 pd_standby_off(disk);
701 /* end of io request engine */
703 static void do_pd_request(struct request_queue * q)
707 pd_req = blk_fetch_request(q);
714 static int pd_special_command(struct pd_unit *disk,
715 enum action (*func)(struct pd_unit *disk))
720 rq = blk_get_request(disk->gd->queue, READ, __GFP_WAIT);
722 rq->cmd_type = REQ_TYPE_SPECIAL;
725 err = blk_execute_rq(disk->gd->queue, disk->gd, rq, 0);
731 /* kernel glue structures */
733 static int pd_open(struct block_device *bdev, fmode_t mode)
735 struct pd_unit *disk = bdev->bd_disk->private_data;
739 if (disk->removable) {
740 pd_special_command(disk, pd_media_check);
741 pd_special_command(disk, pd_door_lock);
746 static int pd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
748 struct pd_unit *disk = bdev->bd_disk->private_data;
750 if (disk->alt_geom) {
751 geo->heads = PD_LOG_HEADS;
752 geo->sectors = PD_LOG_SECTS;
753 geo->cylinders = disk->capacity / (geo->heads * geo->sectors);
755 geo->heads = disk->heads;
756 geo->sectors = disk->sectors;
757 geo->cylinders = disk->cylinders;
763 static int pd_ioctl(struct block_device *bdev, fmode_t mode,
764 unsigned int cmd, unsigned long arg)
766 struct pd_unit *disk = bdev->bd_disk->private_data;
770 if (disk->access == 1)
771 pd_special_command(disk, pd_eject);
778 static int pd_release(struct gendisk *p, fmode_t mode)
780 struct pd_unit *disk = p->private_data;
782 if (!--disk->access && disk->removable)
783 pd_special_command(disk, pd_door_unlock);
788 static int pd_check_media(struct gendisk *p)
790 struct pd_unit *disk = p->private_data;
792 if (!disk->removable)
794 pd_special_command(disk, pd_media_check);
800 static int pd_revalidate(struct gendisk *p)
802 struct pd_unit *disk = p->private_data;
803 if (pd_special_command(disk, pd_identify) == 0)
804 set_capacity(p, disk->capacity);
810 static struct block_device_operations pd_fops = {
811 .owner = THIS_MODULE,
813 .release = pd_release,
814 .locked_ioctl = pd_ioctl,
816 .media_changed = pd_check_media,
817 .revalidate_disk= pd_revalidate
822 static void pd_probe_drive(struct pd_unit *disk)
824 struct gendisk *p = alloc_disk(1 << PD_BITS);
827 strcpy(p->disk_name, disk->name);
830 p->first_minor = (disk - pd) << PD_BITS;
832 p->private_data = disk;
835 if (disk->drive == -1) {
836 for (disk->drive = 0; disk->drive <= 1; disk->drive++)
837 if (pd_special_command(disk, pd_identify) == 0)
839 } else if (pd_special_command(disk, pd_identify) == 0)
845 static int pd_detect(void)
847 int found = 0, unit, pd_drive_count = 0;
848 struct pd_unit *disk;
850 for (unit = 0; unit < PD_UNITS; unit++) {
851 int *parm = *drives[unit];
852 struct pd_unit *disk = pd + unit;
853 disk->pi = &disk->pia;
857 disk->drive = parm[D_SLV];
858 snprintf(disk->name, PD_NAMELEN, "%s%c", name, 'a'+unit);
859 disk->alt_geom = parm[D_GEO];
860 disk->standby = parm[D_SBY];
865 if (pd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
867 if (pi_init(disk->pi, 1, -1, -1, -1, -1, -1, pd_scratch,
868 PI_PD, verbose, disk->name)) {
869 pd_probe_drive(disk);
871 pi_release(disk->pi);
875 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
876 int *parm = *drives[unit];
879 if (pi_init(disk->pi, 0, parm[D_PRT], parm[D_MOD],
880 parm[D_UNI], parm[D_PRO], parm[D_DLY],
881 pd_scratch, PI_PD, verbose, disk->name)) {
882 pd_probe_drive(disk);
884 pi_release(disk->pi);
888 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
890 set_capacity(disk->gd, disk->capacity);
896 printk("%s: no valid drive found\n", name);
900 static int __init pd_init(void)
905 pd_queue = blk_init_queue(do_pd_request, &pd_lock);
909 blk_queue_max_sectors(pd_queue, cluster);
911 if (register_blkdev(major, name))
914 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
915 name, name, PD_VERSION, major, cluster, nice);
922 unregister_blkdev(major, name);
924 blk_cleanup_queue(pd_queue);
929 static void __exit pd_exit(void)
931 struct pd_unit *disk;
933 unregister_blkdev(major, name);
934 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
935 struct gendisk *p = disk->gd;
940 pi_release(disk->pi);
943 blk_cleanup_queue(pd_queue);
946 MODULE_LICENSE("GPL");