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 __blk_end_request_cur(pd_req
,
414 res
== Ok
? 0 : -EIO
);
415 pd_req
= elv_next_request(pd_queue
);
418 spin_unlock_irqrestore(&pd_lock
, saved_flags
);
425 pi_disconnect(pi_current
);
431 static int pd_retries
= 0; /* i/o error retry count */
432 static int pd_block
; /* address of next requested block */
433 static int pd_count
; /* number of blocks still to do */
434 static int pd_run
; /* sectors in current cluster */
435 static int pd_cmd
; /* current command READ/WRITE */
436 static char *pd_buf
; /* buffer for request in progress */
438 static enum action
do_pd_io_start(void)
440 if (blk_special_request(pd_req
)) {
445 pd_cmd
= rq_data_dir(pd_req
);
446 if (pd_cmd
== READ
|| pd_cmd
== WRITE
) {
447 pd_block
= pd_req
->sector
;
448 pd_count
= pd_req
->current_nr_sectors
;
449 if (pd_block
+ pd_count
> get_capacity(pd_req
->rq_disk
))
451 pd_run
= pd_req
->nr_sectors
;
452 pd_buf
= pd_req
->buffer
;
455 return do_pd_read_start();
457 return do_pd_write_start();
462 static enum action
pd_special(void)
464 enum action (*func
)(struct pd_unit
*) = pd_req
->special
;
465 return func(pd_current
);
468 static int pd_next_buf(void)
470 unsigned long saved_flags
;
480 spin_lock_irqsave(&pd_lock
, saved_flags
);
481 __blk_end_request_cur(pd_req
, 0);
482 pd_count
= pd_req
->current_nr_sectors
;
483 pd_buf
= pd_req
->buffer
;
484 spin_unlock_irqrestore(&pd_lock
, saved_flags
);
488 static unsigned long pd_timeout
;
490 static enum action
do_pd_read_start(void)
492 if (pd_wait_for(pd_current
, STAT_READY
, "do_pd_read") & STAT_ERR
) {
493 if (pd_retries
< PD_MAX_RETRIES
) {
499 pd_ide_command(pd_current
, IDE_READ
, pd_block
, pd_run
);
500 phase
= do_pd_read_drq
;
501 pd_timeout
= jiffies
+ PD_TMO
;
505 static enum action
do_pd_write_start(void)
507 if (pd_wait_for(pd_current
, STAT_READY
, "do_pd_write") & STAT_ERR
) {
508 if (pd_retries
< PD_MAX_RETRIES
) {
514 pd_ide_command(pd_current
, IDE_WRITE
, pd_block
, pd_run
);
516 if (pd_wait_for(pd_current
, STAT_DRQ
, "do_pd_write_drq") & STAT_ERR
) {
517 if (pd_retries
< PD_MAX_RETRIES
) {
523 pi_write_block(pd_current
->pi
, pd_buf
, 512);
527 phase
= do_pd_write_done
;
528 pd_timeout
= jiffies
+ PD_TMO
;
532 static inline int pd_ready(void)
534 return !(status_reg(pd_current
) & STAT_BUSY
);
537 static enum action
do_pd_read_drq(void)
539 if (!pd_ready() && !time_after_eq(jiffies
, pd_timeout
))
543 if (pd_wait_for(pd_current
, STAT_DRQ
, "do_pd_read_drq") & STAT_ERR
) {
544 if (pd_retries
< PD_MAX_RETRIES
) {
546 phase
= do_pd_read_start
;
551 pi_read_block(pd_current
->pi
, pd_buf
, 512);
558 static enum action
do_pd_write_done(void)
560 if (!pd_ready() && !time_after_eq(jiffies
, pd_timeout
))
563 if (pd_wait_for(pd_current
, STAT_READY
, "do_pd_write_done") & STAT_ERR
) {
564 if (pd_retries
< PD_MAX_RETRIES
) {
566 phase
= do_pd_write_start
;
574 /* special io requests */
576 /* According to the ATA standard, the default CHS geometry should be
577 available following a reset. Some Western Digital drives come up
578 in a mode where only LBA addresses are accepted until the device
579 parameters are initialised.
582 static void pd_init_dev_parms(struct pd_unit
*disk
)
584 pd_wait_for(disk
, 0, DBMSG("before init_dev_parms"));
585 pd_send_command(disk
, disk
->sectors
, 0, disk
->heads
- 1, 0, 0,
588 pd_wait_for(disk
, 0, "Initialise device parameters");
591 static enum action
pd_door_lock(struct pd_unit
*disk
)
593 if (!(pd_wait_for(disk
, STAT_READY
, "Lock") & STAT_ERR
)) {
594 pd_send_command(disk
, 1, 0, 0, 0, 0, IDE_DOORLOCK
);
595 pd_wait_for(disk
, STAT_READY
, "Lock done");
600 static enum action
pd_door_unlock(struct pd_unit
*disk
)
602 if (!(pd_wait_for(disk
, STAT_READY
, "Lock") & STAT_ERR
)) {
603 pd_send_command(disk
, 1, 0, 0, 0, 0, IDE_DOORUNLOCK
);
604 pd_wait_for(disk
, STAT_READY
, "Lock done");
609 static enum action
pd_eject(struct pd_unit
*disk
)
611 pd_wait_for(disk
, 0, DBMSG("before unlock on eject"));
612 pd_send_command(disk
, 1, 0, 0, 0, 0, IDE_DOORUNLOCK
);
613 pd_wait_for(disk
, 0, DBMSG("after unlock on eject"));
614 pd_wait_for(disk
, 0, DBMSG("before eject"));
615 pd_send_command(disk
, 0, 0, 0, 0, 0, IDE_EJECT
);
616 pd_wait_for(disk
, 0, DBMSG("after eject"));
620 static enum action
pd_media_check(struct pd_unit
*disk
)
622 int r
= pd_wait_for(disk
, STAT_READY
, DBMSG("before media_check"));
623 if (!(r
& STAT_ERR
)) {
624 pd_send_command(disk
, 1, 1, 0, 0, 0, IDE_READ_VRFY
);
625 r
= pd_wait_for(disk
, STAT_READY
, DBMSG("RDY after READ_VRFY"));
627 disk
->changed
= 1; /* say changed if other error */
630 pd_send_command(disk
, 1, 0, 0, 0, 0, IDE_ACKCHANGE
);
631 pd_wait_for(disk
, STAT_READY
, DBMSG("RDY after ACKCHANGE"));
632 pd_send_command(disk
, 1, 1, 0, 0, 0, IDE_READ_VRFY
);
633 r
= pd_wait_for(disk
, STAT_READY
, DBMSG("RDY after VRFY"));
638 static void pd_standby_off(struct pd_unit
*disk
)
640 pd_wait_for(disk
, 0, DBMSG("before STANDBY"));
641 pd_send_command(disk
, 0, 0, 0, 0, 0, IDE_STANDBY
);
642 pd_wait_for(disk
, 0, DBMSG("after STANDBY"));
645 static enum action
pd_identify(struct pd_unit
*disk
)
648 char id
[PD_ID_LEN
+ 1];
650 /* WARNING: here there may be dragons. reset() applies to both drives,
651 but we call it only on probing the MASTER. This should allow most
652 common configurations to work, but be warned that a reset can clear
653 settings on the SLAVE drive.
656 if (disk
->drive
== 0)
659 write_reg(disk
, 6, DRIVE(disk
));
660 pd_wait_for(disk
, 0, DBMSG("before IDENT"));
661 pd_send_command(disk
, 1, 0, 0, 0, 0, IDE_IDENTIFY
);
663 if (pd_wait_for(disk
, STAT_DRQ
, DBMSG("IDENT DRQ")) & STAT_ERR
)
665 pi_read_block(disk
->pi
, pd_scratch
, 512);
666 disk
->can_lba
= pd_scratch
[99] & 2;
667 disk
->sectors
= le16_to_cpu(*(__le16
*) (pd_scratch
+ 12));
668 disk
->heads
= le16_to_cpu(*(__le16
*) (pd_scratch
+ 6));
669 disk
->cylinders
= le16_to_cpu(*(__le16
*) (pd_scratch
+ 2));
671 disk
->capacity
= le32_to_cpu(*(__le32
*) (pd_scratch
+ 120));
673 disk
->capacity
= disk
->sectors
* disk
->heads
* disk
->cylinders
;
675 for (j
= 0; j
< PD_ID_LEN
; j
++)
676 id
[j
^ 1] = pd_scratch
[j
+ PD_ID_OFF
];
678 while ((j
>= 0) && (id
[j
] <= 0x20))
683 disk
->removable
= pd_scratch
[0] & 0x80;
685 printk("%s: %s, %s, %d blocks [%dM], (%d/%d/%d), %s media\n",
687 disk
->drive
? "slave" : "master",
688 disk
->capacity
, disk
->capacity
/ 2048,
689 disk
->cylinders
, disk
->heads
, disk
->sectors
,
690 disk
->removable
? "removable" : "fixed");
693 pd_init_dev_parms(disk
);
695 pd_standby_off(disk
);
700 /* end of io request engine */
702 static void do_pd_request(struct request_queue
* q
)
706 pd_req
= elv_next_request(q
);
713 static int pd_special_command(struct pd_unit
*disk
,
714 enum action (*func
)(struct pd_unit
*disk
))
719 rq
= blk_get_request(disk
->gd
->queue
, READ
, __GFP_WAIT
);
721 rq
->cmd_type
= REQ_TYPE_SPECIAL
;
724 err
= blk_execute_rq(disk
->gd
->queue
, disk
->gd
, rq
, 0);
730 /* kernel glue structures */
732 static int pd_open(struct block_device
*bdev
, fmode_t mode
)
734 struct pd_unit
*disk
= bdev
->bd_disk
->private_data
;
738 if (disk
->removable
) {
739 pd_special_command(disk
, pd_media_check
);
740 pd_special_command(disk
, pd_door_lock
);
745 static int pd_getgeo(struct block_device
*bdev
, struct hd_geometry
*geo
)
747 struct pd_unit
*disk
= bdev
->bd_disk
->private_data
;
749 if (disk
->alt_geom
) {
750 geo
->heads
= PD_LOG_HEADS
;
751 geo
->sectors
= PD_LOG_SECTS
;
752 geo
->cylinders
= disk
->capacity
/ (geo
->heads
* geo
->sectors
);
754 geo
->heads
= disk
->heads
;
755 geo
->sectors
= disk
->sectors
;
756 geo
->cylinders
= disk
->cylinders
;
762 static int pd_ioctl(struct block_device
*bdev
, fmode_t mode
,
763 unsigned int cmd
, unsigned long arg
)
765 struct pd_unit
*disk
= bdev
->bd_disk
->private_data
;
769 if (disk
->access
== 1)
770 pd_special_command(disk
, pd_eject
);
777 static int pd_release(struct gendisk
*p
, fmode_t mode
)
779 struct pd_unit
*disk
= p
->private_data
;
781 if (!--disk
->access
&& disk
->removable
)
782 pd_special_command(disk
, pd_door_unlock
);
787 static int pd_check_media(struct gendisk
*p
)
789 struct pd_unit
*disk
= p
->private_data
;
791 if (!disk
->removable
)
793 pd_special_command(disk
, pd_media_check
);
799 static int pd_revalidate(struct gendisk
*p
)
801 struct pd_unit
*disk
= p
->private_data
;
802 if (pd_special_command(disk
, pd_identify
) == 0)
803 set_capacity(p
, disk
->capacity
);
809 static struct block_device_operations pd_fops
= {
810 .owner
= THIS_MODULE
,
812 .release
= pd_release
,
813 .locked_ioctl
= pd_ioctl
,
815 .media_changed
= pd_check_media
,
816 .revalidate_disk
= pd_revalidate
821 static void pd_probe_drive(struct pd_unit
*disk
)
823 struct gendisk
*p
= alloc_disk(1 << PD_BITS
);
826 strcpy(p
->disk_name
, disk
->name
);
829 p
->first_minor
= (disk
- pd
) << PD_BITS
;
831 p
->private_data
= disk
;
834 if (disk
->drive
== -1) {
835 for (disk
->drive
= 0; disk
->drive
<= 1; disk
->drive
++)
836 if (pd_special_command(disk
, pd_identify
) == 0)
838 } else if (pd_special_command(disk
, pd_identify
) == 0)
844 static int pd_detect(void)
846 int found
= 0, unit
, pd_drive_count
= 0;
847 struct pd_unit
*disk
;
849 for (unit
= 0; unit
< PD_UNITS
; unit
++) {
850 int *parm
= *drives
[unit
];
851 struct pd_unit
*disk
= pd
+ unit
;
852 disk
->pi
= &disk
->pia
;
856 disk
->drive
= parm
[D_SLV
];
857 snprintf(disk
->name
, PD_NAMELEN
, "%s%c", name
, 'a'+unit
);
858 disk
->alt_geom
= parm
[D_GEO
];
859 disk
->standby
= parm
[D_SBY
];
864 if (pd_drive_count
== 0) { /* nothing spec'd - so autoprobe for 1 */
866 if (pi_init(disk
->pi
, 1, -1, -1, -1, -1, -1, pd_scratch
,
867 PI_PD
, verbose
, disk
->name
)) {
868 pd_probe_drive(disk
);
870 pi_release(disk
->pi
);
874 for (unit
= 0, disk
= pd
; unit
< PD_UNITS
; unit
++, disk
++) {
875 int *parm
= *drives
[unit
];
878 if (pi_init(disk
->pi
, 0, parm
[D_PRT
], parm
[D_MOD
],
879 parm
[D_UNI
], parm
[D_PRO
], parm
[D_DLY
],
880 pd_scratch
, PI_PD
, verbose
, disk
->name
)) {
881 pd_probe_drive(disk
);
883 pi_release(disk
->pi
);
887 for (unit
= 0, disk
= pd
; unit
< PD_UNITS
; unit
++, disk
++) {
889 set_capacity(disk
->gd
, disk
->capacity
);
895 printk("%s: no valid drive found\n", name
);
899 static int __init
pd_init(void)
904 pd_queue
= blk_init_queue(do_pd_request
, &pd_lock
);
908 blk_queue_max_sectors(pd_queue
, cluster
);
910 if (register_blkdev(major
, name
))
913 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
914 name
, name
, PD_VERSION
, major
, cluster
, nice
);
921 unregister_blkdev(major
, name
);
923 blk_cleanup_queue(pd_queue
);
928 static void __exit
pd_exit(void)
930 struct pd_unit
*disk
;
932 unregister_blkdev(major
, name
);
933 for (unit
= 0, disk
= pd
; unit
< PD_UNITS
; unit
++, disk
++) {
934 struct gendisk
*p
= disk
->gd
;
939 pi_release(disk
->pi
);
942 blk_cleanup_queue(pd_queue
);
945 MODULE_LICENSE("GPL");