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/gfp.h>
149 #include <linux/fs.h>
150 #include <linux/delay.h>
151 #include <linux/hdreg.h>
152 #include <linux/cdrom.h> /* for the eject ioctl */
153 #include <linux/blkdev.h>
154 #include <linux/blkpg.h>
155 #include <linux/kernel.h>
156 #include <asm/uaccess.h>
157 #include <linux/workqueue.h>
159 static DEFINE_SPINLOCK(pd_lock);
161 module_param(verbose, bool, 0);
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);
175 /* numbers for "SCSI" geometry */
177 #define PD_LOG_HEADS 64
178 #define PD_LOG_SECTS 32
183 #define PD_MAX_RETRIES 5
184 #define PD_TMO 800 /* interrupt timeout in jiffies */
185 #define PD_SPIN_DEL 50 /* spin delay in micro-seconds */
187 #define PD_SPIN (1000000*PD_TMO)/(HZ*PD_SPIN_DEL)
189 #define STAT_ERR 0x00001
190 #define STAT_INDEX 0x00002
191 #define STAT_ECC 0x00004
192 #define STAT_DRQ 0x00008
193 #define STAT_SEEK 0x00010
194 #define STAT_WRERR 0x00020
195 #define STAT_READY 0x00040
196 #define STAT_BUSY 0x00080
198 #define ERR_AMNF 0x00100
199 #define ERR_TK0NF 0x00200
200 #define ERR_ABRT 0x00400
201 #define ERR_MCR 0x00800
202 #define ERR_IDNF 0x01000
203 #define ERR_MC 0x02000
204 #define ERR_UNC 0x04000
205 #define ERR_TMO 0x10000
207 #define IDE_READ 0x20
208 #define IDE_WRITE 0x30
209 #define IDE_READ_VRFY 0x40
210 #define IDE_INIT_DEV_PARMS 0x91
211 #define IDE_STANDBY 0x96
212 #define IDE_ACKCHANGE 0xdb
213 #define IDE_DOORLOCK 0xde
214 #define IDE_DOORUNLOCK 0xdf
215 #define IDE_IDENTIFY 0xec
216 #define IDE_EJECT 0xed
221 struct pi_adapter pia; /* interface to paride layer */
222 struct pi_adapter *pi;
223 int access; /* count of active opens ... */
224 int capacity; /* Size of this volume in sectors */
225 int heads; /* physical geometry */
229 int drive; /* master=0 slave=1 */
230 int changed; /* Have we seen a disk change ? */
231 int removable; /* removable media device ? */
234 char name[PD_NAMELEN]; /* pda, pdb, etc ... */
238 static struct pd_unit pd[PD_UNITS];
240 static char pd_scratch[512]; /* scratch block buffer */
242 static char *pd_errs[17] = { "ERR", "INDEX", "ECC", "DRQ", "SEEK", "WRERR",
243 "READY", "BUSY", "AMNF", "TK0NF", "ABRT", "MCR",
244 "IDNF", "MC", "UNC", "???", "TMO"
247 static inline int status_reg(struct pd_unit *disk)
249 return pi_read_regr(disk->pi, 1, 6);
252 static inline int read_reg(struct pd_unit *disk, int reg)
254 return pi_read_regr(disk->pi, 0, reg);
257 static inline void write_status(struct pd_unit *disk, int val)
259 pi_write_regr(disk->pi, 1, 6, val);
262 static inline void write_reg(struct pd_unit *disk, int reg, int val)
264 pi_write_regr(disk->pi, 0, reg, val);
267 static inline u8 DRIVE(struct pd_unit *disk)
269 return 0xa0+0x10*disk->drive;
272 /* ide command interface */
274 static void pd_print_error(struct pd_unit *disk, char *msg, int status)
278 printk("%s: %s: status = 0x%x =", disk->name, msg, status);
279 for (i = 0; i < ARRAY_SIZE(pd_errs); i++)
280 if (status & (1 << i))
281 printk(" %s", pd_errs[i]);
285 static void pd_reset(struct pd_unit *disk)
286 { /* called only for MASTER drive */
287 write_status(disk, 4);
289 write_status(disk, 0);
293 #define DBMSG(msg) ((verbose>1)?(msg):NULL)
295 static int pd_wait_for(struct pd_unit *disk, int w, char *msg)
300 while (k < PD_SPIN) {
301 r = status_reg(disk);
303 if (((r & w) == w) && !(r & STAT_BUSY))
307 e = (read_reg(disk, 1) << 8) + read_reg(disk, 7);
310 if ((e & (STAT_ERR | ERR_TMO)) && (msg != NULL))
311 pd_print_error(disk, msg, e);
315 static void pd_send_command(struct pd_unit *disk, int n, int s, int h, int c0, int c1, int func)
317 write_reg(disk, 6, DRIVE(disk) + h);
318 write_reg(disk, 1, 0); /* the IDE task file */
319 write_reg(disk, 2, n);
320 write_reg(disk, 3, s);
321 write_reg(disk, 4, c0);
322 write_reg(disk, 5, c1);
323 write_reg(disk, 7, func);
328 static void pd_ide_command(struct pd_unit *disk, int func, int block, int count)
334 c0 = (block >>= 8) & 255;
335 c1 = (block >>= 8) & 255;
336 h = ((block >>= 8) & 15) + 0x40;
338 s = (block % disk->sectors) + 1;
339 h = (block /= disk->sectors) % disk->heads;
340 c0 = (block /= disk->heads) % 256;
343 pd_send_command(disk, count, s, h, c0, c1, func);
346 /* The i/o request engine */
348 enum action {Fail = 0, Ok = 1, Hold, Wait};
350 static struct request *pd_req; /* current request */
351 static enum action (*phase)(void);
353 static void run_fsm(void);
355 static void ps_tq_int(struct work_struct *work);
357 static DECLARE_DELAYED_WORK(fsm_tq, ps_tq_int);
359 static void schedule_fsm(void)
362 schedule_delayed_work(&fsm_tq, 0);
364 schedule_delayed_work(&fsm_tq, nice-1);
367 static void ps_tq_int(struct work_struct *work)
372 static enum action do_pd_io_start(void);
373 static enum action pd_special(void);
374 static enum action do_pd_read_start(void);
375 static enum action do_pd_write_start(void);
376 static enum action do_pd_read_drq(void);
377 static enum action do_pd_write_done(void);
379 static struct request_queue *pd_queue;
380 static int pd_claimed;
382 static struct pd_unit *pd_current; /* current request's drive */
383 static PIA *pi_current; /* current request's PIA */
385 static void run_fsm(void)
389 unsigned long saved_flags;
393 pd_current = pd_req->rq_disk->private_data;
394 pi_current = pd_current->pi;
395 phase = do_pd_io_start;
398 switch (pd_claimed) {
401 if (!pi_schedule_claimed(pi_current, run_fsm))
405 pi_current->proto->connect(pi_current);
408 switch(res = phase()) {
410 pi_disconnect(pi_current);
413 spin_lock_irqsave(&pd_lock, saved_flags);
414 if (!__blk_end_request_cur(pd_req,
415 res == Ok ? 0 : -EIO)) {
416 pd_req = blk_fetch_request(pd_queue);
420 spin_unlock_irqrestore(&pd_lock, saved_flags);
427 pi_disconnect(pi_current);
433 static int pd_retries = 0; /* i/o error retry count */
434 static int pd_block; /* address of next requested block */
435 static int pd_count; /* number of blocks still to do */
436 static int pd_run; /* sectors in current cluster */
437 static int pd_cmd; /* current command READ/WRITE */
438 static char *pd_buf; /* buffer for request in progress */
440 static enum action do_pd_io_start(void)
442 if (blk_special_request(pd_req)) {
447 pd_cmd = rq_data_dir(pd_req);
448 if (pd_cmd == READ || pd_cmd == WRITE) {
449 pd_block = blk_rq_pos(pd_req);
450 pd_count = blk_rq_cur_sectors(pd_req);
451 if (pd_block + pd_count > get_capacity(pd_req->rq_disk))
453 pd_run = blk_rq_sectors(pd_req);
454 pd_buf = pd_req->buffer;
457 return do_pd_read_start();
459 return do_pd_write_start();
464 static enum action pd_special(void)
466 enum action (*func)(struct pd_unit *) = pd_req->special;
467 return func(pd_current);
470 static int pd_next_buf(void)
472 unsigned long saved_flags;
482 spin_lock_irqsave(&pd_lock, saved_flags);
483 __blk_end_request_cur(pd_req, 0);
484 pd_count = blk_rq_cur_sectors(pd_req);
485 pd_buf = pd_req->buffer;
486 spin_unlock_irqrestore(&pd_lock, saved_flags);
490 static unsigned long pd_timeout;
492 static enum action do_pd_read_start(void)
494 if (pd_wait_for(pd_current, STAT_READY, "do_pd_read") & STAT_ERR) {
495 if (pd_retries < PD_MAX_RETRIES) {
501 pd_ide_command(pd_current, IDE_READ, pd_block, pd_run);
502 phase = do_pd_read_drq;
503 pd_timeout = jiffies + PD_TMO;
507 static enum action do_pd_write_start(void)
509 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write") & STAT_ERR) {
510 if (pd_retries < PD_MAX_RETRIES) {
516 pd_ide_command(pd_current, IDE_WRITE, pd_block, pd_run);
518 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_write_drq") & STAT_ERR) {
519 if (pd_retries < PD_MAX_RETRIES) {
525 pi_write_block(pd_current->pi, pd_buf, 512);
529 phase = do_pd_write_done;
530 pd_timeout = jiffies + PD_TMO;
534 static inline int pd_ready(void)
536 return !(status_reg(pd_current) & STAT_BUSY);
539 static enum action do_pd_read_drq(void)
541 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
545 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_read_drq") & STAT_ERR) {
546 if (pd_retries < PD_MAX_RETRIES) {
548 phase = do_pd_read_start;
553 pi_read_block(pd_current->pi, pd_buf, 512);
560 static enum action do_pd_write_done(void)
562 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
565 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write_done") & STAT_ERR) {
566 if (pd_retries < PD_MAX_RETRIES) {
568 phase = do_pd_write_start;
576 /* special io requests */
578 /* According to the ATA standard, the default CHS geometry should be
579 available following a reset. Some Western Digital drives come up
580 in a mode where only LBA addresses are accepted until the device
581 parameters are initialised.
584 static void pd_init_dev_parms(struct pd_unit *disk)
586 pd_wait_for(disk, 0, DBMSG("before init_dev_parms"));
587 pd_send_command(disk, disk->sectors, 0, disk->heads - 1, 0, 0,
590 pd_wait_for(disk, 0, "Initialise device parameters");
593 static enum action pd_door_lock(struct pd_unit *disk)
595 if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
596 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORLOCK);
597 pd_wait_for(disk, STAT_READY, "Lock done");
602 static enum action pd_door_unlock(struct pd_unit *disk)
604 if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
605 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
606 pd_wait_for(disk, STAT_READY, "Lock done");
611 static enum action pd_eject(struct pd_unit *disk)
613 pd_wait_for(disk, 0, DBMSG("before unlock on eject"));
614 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
615 pd_wait_for(disk, 0, DBMSG("after unlock on eject"));
616 pd_wait_for(disk, 0, DBMSG("before eject"));
617 pd_send_command(disk, 0, 0, 0, 0, 0, IDE_EJECT);
618 pd_wait_for(disk, 0, DBMSG("after eject"));
622 static enum action pd_media_check(struct pd_unit *disk)
624 int r = pd_wait_for(disk, STAT_READY, DBMSG("before media_check"));
625 if (!(r & STAT_ERR)) {
626 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
627 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after READ_VRFY"));
629 disk->changed = 1; /* say changed if other error */
632 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_ACKCHANGE);
633 pd_wait_for(disk, STAT_READY, DBMSG("RDY after ACKCHANGE"));
634 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
635 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after VRFY"));
640 static void pd_standby_off(struct pd_unit *disk)
642 pd_wait_for(disk, 0, DBMSG("before STANDBY"));
643 pd_send_command(disk, 0, 0, 0, 0, 0, IDE_STANDBY);
644 pd_wait_for(disk, 0, DBMSG("after STANDBY"));
647 static enum action pd_identify(struct pd_unit *disk)
650 char id[PD_ID_LEN + 1];
652 /* WARNING: here there may be dragons. reset() applies to both drives,
653 but we call it only on probing the MASTER. This should allow most
654 common configurations to work, but be warned that a reset can clear
655 settings on the SLAVE drive.
658 if (disk->drive == 0)
661 write_reg(disk, 6, DRIVE(disk));
662 pd_wait_for(disk, 0, DBMSG("before IDENT"));
663 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_IDENTIFY);
665 if (pd_wait_for(disk, STAT_DRQ, DBMSG("IDENT DRQ")) & STAT_ERR)
667 pi_read_block(disk->pi, pd_scratch, 512);
668 disk->can_lba = pd_scratch[99] & 2;
669 disk->sectors = le16_to_cpu(*(__le16 *) (pd_scratch + 12));
670 disk->heads = le16_to_cpu(*(__le16 *) (pd_scratch + 6));
671 disk->cylinders = le16_to_cpu(*(__le16 *) (pd_scratch + 2));
673 disk->capacity = le32_to_cpu(*(__le32 *) (pd_scratch + 120));
675 disk->capacity = disk->sectors * disk->heads * disk->cylinders;
677 for (j = 0; j < PD_ID_LEN; j++)
678 id[j ^ 1] = pd_scratch[j + PD_ID_OFF];
680 while ((j >= 0) && (id[j] <= 0x20))
685 disk->removable = pd_scratch[0] & 0x80;
687 printk("%s: %s, %s, %d blocks [%dM], (%d/%d/%d), %s media\n",
689 disk->drive ? "slave" : "master",
690 disk->capacity, disk->capacity / 2048,
691 disk->cylinders, disk->heads, disk->sectors,
692 disk->removable ? "removable" : "fixed");
695 pd_init_dev_parms(disk);
697 pd_standby_off(disk);
702 /* end of io request engine */
704 static void do_pd_request(struct request_queue * q)
708 pd_req = blk_fetch_request(q);
715 static int pd_special_command(struct pd_unit *disk,
716 enum action (*func)(struct pd_unit *disk))
721 rq = blk_get_request(disk->gd->queue, READ, __GFP_WAIT);
723 rq->cmd_type = REQ_TYPE_SPECIAL;
726 err = blk_execute_rq(disk->gd->queue, disk->gd, rq, 0);
732 /* kernel glue structures */
734 static int pd_open(struct block_device *bdev, fmode_t mode)
736 struct pd_unit *disk = bdev->bd_disk->private_data;
740 if (disk->removable) {
741 pd_special_command(disk, pd_media_check);
742 pd_special_command(disk, pd_door_lock);
747 static int pd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
749 struct pd_unit *disk = bdev->bd_disk->private_data;
751 if (disk->alt_geom) {
752 geo->heads = PD_LOG_HEADS;
753 geo->sectors = PD_LOG_SECTS;
754 geo->cylinders = disk->capacity / (geo->heads * geo->sectors);
756 geo->heads = disk->heads;
757 geo->sectors = disk->sectors;
758 geo->cylinders = disk->cylinders;
764 static int pd_ioctl(struct block_device *bdev, fmode_t mode,
765 unsigned int cmd, unsigned long arg)
767 struct pd_unit *disk = bdev->bd_disk->private_data;
771 if (disk->access == 1)
772 pd_special_command(disk, pd_eject);
779 static int pd_release(struct gendisk *p, fmode_t mode)
781 struct pd_unit *disk = p->private_data;
783 if (!--disk->access && disk->removable)
784 pd_special_command(disk, pd_door_unlock);
789 static int pd_check_media(struct gendisk *p)
791 struct pd_unit *disk = p->private_data;
793 if (!disk->removable)
795 pd_special_command(disk, pd_media_check);
801 static int pd_revalidate(struct gendisk *p)
803 struct pd_unit *disk = p->private_data;
804 if (pd_special_command(disk, pd_identify) == 0)
805 set_capacity(p, disk->capacity);
811 static const struct block_device_operations pd_fops = {
812 .owner = THIS_MODULE,
814 .release = pd_release,
815 .locked_ioctl = pd_ioctl,
817 .media_changed = pd_check_media,
818 .revalidate_disk= pd_revalidate
823 static void pd_probe_drive(struct pd_unit *disk)
825 struct gendisk *p = alloc_disk(1 << PD_BITS);
828 strcpy(p->disk_name, disk->name);
831 p->first_minor = (disk - pd) << PD_BITS;
833 p->private_data = disk;
836 if (disk->drive == -1) {
837 for (disk->drive = 0; disk->drive <= 1; disk->drive++)
838 if (pd_special_command(disk, pd_identify) == 0)
840 } else if (pd_special_command(disk, pd_identify) == 0)
846 static int pd_detect(void)
848 int found = 0, unit, pd_drive_count = 0;
849 struct pd_unit *disk;
851 for (unit = 0; unit < PD_UNITS; unit++) {
852 int *parm = *drives[unit];
853 struct pd_unit *disk = pd + unit;
854 disk->pi = &disk->pia;
858 disk->drive = parm[D_SLV];
859 snprintf(disk->name, PD_NAMELEN, "%s%c", name, 'a'+unit);
860 disk->alt_geom = parm[D_GEO];
861 disk->standby = parm[D_SBY];
866 if (pd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
868 if (pi_init(disk->pi, 1, -1, -1, -1, -1, -1, pd_scratch,
869 PI_PD, verbose, disk->name)) {
870 pd_probe_drive(disk);
872 pi_release(disk->pi);
876 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
877 int *parm = *drives[unit];
880 if (pi_init(disk->pi, 0, parm[D_PRT], parm[D_MOD],
881 parm[D_UNI], parm[D_PRO], parm[D_DLY],
882 pd_scratch, PI_PD, verbose, disk->name)) {
883 pd_probe_drive(disk);
885 pi_release(disk->pi);
889 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
891 set_capacity(disk->gd, disk->capacity);
897 printk("%s: no valid drive found\n", name);
901 static int __init pd_init(void)
906 pd_queue = blk_init_queue(do_pd_request, &pd_lock);
910 blk_queue_max_hw_sectors(pd_queue, cluster);
912 if (register_blkdev(major, name))
915 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
916 name, name, PD_VERSION, major, cluster, nice);
923 unregister_blkdev(major, name);
925 blk_cleanup_queue(pd_queue);
930 static void __exit pd_exit(void)
932 struct pd_unit *disk;
934 unregister_blkdev(major, name);
935 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
936 struct gendisk *p = disk->gd;
941 pi_release(disk->pi);
944 blk_cleanup_queue(pd_queue);
947 MODULE_LICENSE("GPL");