1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117#define PD_VERSION "1.05"
118#define PD_MAJOR 45
119#define PD_NAME "pd"
120#define PD_UNITS 4
121
122
123
124
125
126
127#include <linux/types.h>
128
129static bool verbose = 0;
130static int major = PD_MAJOR;
131static char *name = PD_NAME;
132static int cluster = 64;
133static int nice = 0;
134static int disable = 0;
135
136static int drive0[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
137static int drive1[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
138static int drive2[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
139static int drive3[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
140
141static int (*drives[4])[8] = {&drive0, &drive1, &drive2, &drive3};
142
143enum {D_PRT, D_PRO, D_UNI, D_MOD, D_GEO, D_SBY, D_DLY, D_SLV};
144
145
146
147#include <linux/init.h>
148#include <linux/module.h>
149#include <linux/gfp.h>
150#include <linux/fs.h>
151#include <linux/delay.h>
152#include <linux/hdreg.h>
153#include <linux/cdrom.h>
154#include <linux/blkdev.h>
155#include <linux/blkpg.h>
156#include <linux/kernel.h>
157#include <linux/mutex.h>
158#include <asm/uaccess.h>
159#include <linux/workqueue.h>
160
161static DEFINE_MUTEX(pd_mutex);
162static DEFINE_SPINLOCK(pd_lock);
163
164module_param(verbose, bool, 0);
165module_param(major, int, 0);
166module_param(name, charp, 0);
167module_param(cluster, int, 0);
168module_param(nice, int, 0);
169module_param_array(drive0, int, NULL, 0);
170module_param_array(drive1, int, NULL, 0);
171module_param_array(drive2, int, NULL, 0);
172module_param_array(drive3, int, NULL, 0);
173
174#include "paride.h"
175
176#define PD_BITS 4
177
178
179
180#define PD_LOG_HEADS 64
181#define PD_LOG_SECTS 32
182
183#define PD_ID_OFF 54
184#define PD_ID_LEN 14
185
186#define PD_MAX_RETRIES 5
187#define PD_TMO 800
188#define PD_SPIN_DEL 50
189
190#define PD_SPIN (1000000*PD_TMO)/(HZ*PD_SPIN_DEL)
191
192#define STAT_ERR 0x00001
193#define STAT_INDEX 0x00002
194#define STAT_ECC 0x00004
195#define STAT_DRQ 0x00008
196#define STAT_SEEK 0x00010
197#define STAT_WRERR 0x00020
198#define STAT_READY 0x00040
199#define STAT_BUSY 0x00080
200
201#define ERR_AMNF 0x00100
202#define ERR_TK0NF 0x00200
203#define ERR_ABRT 0x00400
204#define ERR_MCR 0x00800
205#define ERR_IDNF 0x01000
206#define ERR_MC 0x02000
207#define ERR_UNC 0x04000
208#define ERR_TMO 0x10000
209
210#define IDE_READ 0x20
211#define IDE_WRITE 0x30
212#define IDE_READ_VRFY 0x40
213#define IDE_INIT_DEV_PARMS 0x91
214#define IDE_STANDBY 0x96
215#define IDE_ACKCHANGE 0xdb
216#define IDE_DOORLOCK 0xde
217#define IDE_DOORUNLOCK 0xdf
218#define IDE_IDENTIFY 0xec
219#define IDE_EJECT 0xed
220
221#define PD_NAMELEN 8
222
223struct pd_unit {
224 struct pi_adapter pia;
225 struct pi_adapter *pi;
226 int access;
227 int capacity;
228 int heads;
229 int sectors;
230 int cylinders;
231 int can_lba;
232 int drive;
233 int changed;
234 int removable;
235 int standby;
236 int alt_geom;
237 char name[PD_NAMELEN];
238 struct gendisk *gd;
239};
240
241static struct pd_unit pd[PD_UNITS];
242
243static char pd_scratch[512];
244
245static char *pd_errs[17] = { "ERR", "INDEX", "ECC", "DRQ", "SEEK", "WRERR",
246 "READY", "BUSY", "AMNF", "TK0NF", "ABRT", "MCR",
247 "IDNF", "MC", "UNC", "???", "TMO"
248};
249
250static inline int status_reg(struct pd_unit *disk)
251{
252 return pi_read_regr(disk->pi, 1, 6);
253}
254
255static inline int read_reg(struct pd_unit *disk, int reg)
256{
257 return pi_read_regr(disk->pi, 0, reg);
258}
259
260static inline void write_status(struct pd_unit *disk, int val)
261{
262 pi_write_regr(disk->pi, 1, 6, val);
263}
264
265static inline void write_reg(struct pd_unit *disk, int reg, int val)
266{
267 pi_write_regr(disk->pi, 0, reg, val);
268}
269
270static inline u8 DRIVE(struct pd_unit *disk)
271{
272 return 0xa0+0x10*disk->drive;
273}
274
275
276
277static void pd_print_error(struct pd_unit *disk, char *msg, int status)
278{
279 int i;
280
281 printk("%s: %s: status = 0x%x =", disk->name, msg, status);
282 for (i = 0; i < ARRAY_SIZE(pd_errs); i++)
283 if (status & (1 << i))
284 printk(" %s", pd_errs[i]);
285 printk("\n");
286}
287
288static void pd_reset(struct pd_unit *disk)
289{
290 write_status(disk, 4);
291 udelay(50);
292 write_status(disk, 0);
293 udelay(250);
294}
295
296#define DBMSG(msg) ((verbose>1)?(msg):NULL)
297
298static int pd_wait_for(struct pd_unit *disk, int w, char *msg)
299{
300 int k, r, e;
301
302 k = 0;
303 while (k < PD_SPIN) {
304 r = status_reg(disk);
305 k++;
306 if (((r & w) == w) && !(r & STAT_BUSY))
307 break;
308 udelay(PD_SPIN_DEL);
309 }
310 e = (read_reg(disk, 1) << 8) + read_reg(disk, 7);
311 if (k >= PD_SPIN)
312 e |= ERR_TMO;
313 if ((e & (STAT_ERR | ERR_TMO)) && (msg != NULL))
314 pd_print_error(disk, msg, e);
315 return e;
316}
317
318static void pd_send_command(struct pd_unit *disk, int n, int s, int h, int c0, int c1, int func)
319{
320 write_reg(disk, 6, DRIVE(disk) + h);
321 write_reg(disk, 1, 0);
322 write_reg(disk, 2, n);
323 write_reg(disk, 3, s);
324 write_reg(disk, 4, c0);
325 write_reg(disk, 5, c1);
326 write_reg(disk, 7, func);
327
328 udelay(1);
329}
330
331static void pd_ide_command(struct pd_unit *disk, int func, int block, int count)
332{
333 int c1, c0, h, s;
334
335 if (disk->can_lba) {
336 s = block & 255;
337 c0 = (block >>= 8) & 255;
338 c1 = (block >>= 8) & 255;
339 h = ((block >>= 8) & 15) + 0x40;
340 } else {
341 s = (block % disk->sectors) + 1;
342 h = (block /= disk->sectors) % disk->heads;
343 c0 = (block /= disk->heads) % 256;
344 c1 = (block >>= 8);
345 }
346 pd_send_command(disk, count, s, h, c0, c1, func);
347}
348
349
350
351enum action {Fail = 0, Ok = 1, Hold, Wait};
352
353static struct request *pd_req;
354static enum action (*phase)(void);
355
356static void run_fsm(void);
357
358static void ps_tq_int(struct work_struct *work);
359
360static DECLARE_DELAYED_WORK(fsm_tq, ps_tq_int);
361
362static void schedule_fsm(void)
363{
364 if (!nice)
365 schedule_delayed_work(&fsm_tq, 0);
366 else
367 schedule_delayed_work(&fsm_tq, nice-1);
368}
369
370static void ps_tq_int(struct work_struct *work)
371{
372 run_fsm();
373}
374
375static enum action do_pd_io_start(void);
376static enum action pd_special(void);
377static enum action do_pd_read_start(void);
378static enum action do_pd_write_start(void);
379static enum action do_pd_read_drq(void);
380static enum action do_pd_write_done(void);
381
382static struct request_queue *pd_queue;
383static int pd_claimed;
384
385static struct pd_unit *pd_current;
386static PIA *pi_current;
387
388static void run_fsm(void)
389{
390 while (1) {
391 enum action res;
392 unsigned long saved_flags;
393 int stop = 0;
394
395 if (!phase) {
396 pd_current = pd_req->rq_disk->private_data;
397 pi_current = pd_current->pi;
398 phase = do_pd_io_start;
399 }
400
401 switch (pd_claimed) {
402 case 0:
403 pd_claimed = 1;
404 if (!pi_schedule_claimed(pi_current, run_fsm))
405 return;
406 case 1:
407 pd_claimed = 2;
408 pi_current->proto->connect(pi_current);
409 }
410
411 switch(res = phase()) {
412 case Ok: case Fail:
413 pi_disconnect(pi_current);
414 pd_claimed = 0;
415 phase = NULL;
416 spin_lock_irqsave(&pd_lock, saved_flags);
417 if (!__blk_end_request_cur(pd_req,
418 res == Ok ? 0 : -EIO)) {
419 pd_req = blk_fetch_request(pd_queue);
420 if (!pd_req)
421 stop = 1;
422 }
423 spin_unlock_irqrestore(&pd_lock, saved_flags);
424 if (stop)
425 return;
426 case Hold:
427 schedule_fsm();
428 return;
429 case Wait:
430 pi_disconnect(pi_current);
431 pd_claimed = 0;
432 }
433 }
434}
435
436static int pd_retries = 0;
437static int pd_block;
438static int pd_count;
439static int pd_run;
440static int pd_cmd;
441static char *pd_buf;
442
443static enum action do_pd_io_start(void)
444{
445 if (pd_req->cmd_type == REQ_TYPE_SPECIAL) {
446 phase = pd_special;
447 return pd_special();
448 }
449
450 pd_cmd = rq_data_dir(pd_req);
451 if (pd_cmd == READ || pd_cmd == WRITE) {
452 pd_block = blk_rq_pos(pd_req);
453 pd_count = blk_rq_cur_sectors(pd_req);
454 if (pd_block + pd_count > get_capacity(pd_req->rq_disk))
455 return Fail;
456 pd_run = blk_rq_sectors(pd_req);
457 pd_buf = pd_req->buffer;
458 pd_retries = 0;
459 if (pd_cmd == READ)
460 return do_pd_read_start();
461 else
462 return do_pd_write_start();
463 }
464 return Fail;
465}
466
467static enum action pd_special(void)
468{
469 enum action (*func)(struct pd_unit *) = pd_req->special;
470 return func(pd_current);
471}
472
473static int pd_next_buf(void)
474{
475 unsigned long saved_flags;
476
477 pd_count--;
478 pd_run--;
479 pd_buf += 512;
480 pd_block++;
481 if (!pd_run)
482 return 1;
483 if (pd_count)
484 return 0;
485 spin_lock_irqsave(&pd_lock, saved_flags);
486 __blk_end_request_cur(pd_req, 0);
487 pd_count = blk_rq_cur_sectors(pd_req);
488 pd_buf = pd_req->buffer;
489 spin_unlock_irqrestore(&pd_lock, saved_flags);
490 return 0;
491}
492
493static unsigned long pd_timeout;
494
495static enum action do_pd_read_start(void)
496{
497 if (pd_wait_for(pd_current, STAT_READY, "do_pd_read") & STAT_ERR) {
498 if (pd_retries < PD_MAX_RETRIES) {
499 pd_retries++;
500 return Wait;
501 }
502 return Fail;
503 }
504 pd_ide_command(pd_current, IDE_READ, pd_block, pd_run);
505 phase = do_pd_read_drq;
506 pd_timeout = jiffies + PD_TMO;
507 return Hold;
508}
509
510static enum action do_pd_write_start(void)
511{
512 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write") & STAT_ERR) {
513 if (pd_retries < PD_MAX_RETRIES) {
514 pd_retries++;
515 return Wait;
516 }
517 return Fail;
518 }
519 pd_ide_command(pd_current, IDE_WRITE, pd_block, pd_run);
520 while (1) {
521 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_write_drq") & STAT_ERR) {
522 if (pd_retries < PD_MAX_RETRIES) {
523 pd_retries++;
524 return Wait;
525 }
526 return Fail;
527 }
528 pi_write_block(pd_current->pi, pd_buf, 512);
529 if (pd_next_buf())
530 break;
531 }
532 phase = do_pd_write_done;
533 pd_timeout = jiffies + PD_TMO;
534 return Hold;
535}
536
537static inline int pd_ready(void)
538{
539 return !(status_reg(pd_current) & STAT_BUSY);
540}
541
542static enum action do_pd_read_drq(void)
543{
544 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
545 return Hold;
546
547 while (1) {
548 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_read_drq") & STAT_ERR) {
549 if (pd_retries < PD_MAX_RETRIES) {
550 pd_retries++;
551 phase = do_pd_read_start;
552 return Wait;
553 }
554 return Fail;
555 }
556 pi_read_block(pd_current->pi, pd_buf, 512);
557 if (pd_next_buf())
558 break;
559 }
560 return Ok;
561}
562
563static enum action do_pd_write_done(void)
564{
565 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
566 return Hold;
567
568 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write_done") & STAT_ERR) {
569 if (pd_retries < PD_MAX_RETRIES) {
570 pd_retries++;
571 phase = do_pd_write_start;
572 return Wait;
573 }
574 return Fail;
575 }
576 return Ok;
577}
578
579
580
581
582
583
584
585
586
587static void pd_init_dev_parms(struct pd_unit *disk)
588{
589 pd_wait_for(disk, 0, DBMSG("before init_dev_parms"));
590 pd_send_command(disk, disk->sectors, 0, disk->heads - 1, 0, 0,
591 IDE_INIT_DEV_PARMS);
592 udelay(300);
593 pd_wait_for(disk, 0, "Initialise device parameters");
594}
595
596static enum action pd_door_lock(struct pd_unit *disk)
597{
598 if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
599 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORLOCK);
600 pd_wait_for(disk, STAT_READY, "Lock done");
601 }
602 return Ok;
603}
604
605static enum action pd_door_unlock(struct pd_unit *disk)
606{
607 if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
608 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
609 pd_wait_for(disk, STAT_READY, "Lock done");
610 }
611 return Ok;
612}
613
614static enum action pd_eject(struct pd_unit *disk)
615{
616 pd_wait_for(disk, 0, DBMSG("before unlock on eject"));
617 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
618 pd_wait_for(disk, 0, DBMSG("after unlock on eject"));
619 pd_wait_for(disk, 0, DBMSG("before eject"));
620 pd_send_command(disk, 0, 0, 0, 0, 0, IDE_EJECT);
621 pd_wait_for(disk, 0, DBMSG("after eject"));
622 return Ok;
623}
624
625static enum action pd_media_check(struct pd_unit *disk)
626{
627 int r = pd_wait_for(disk, STAT_READY, DBMSG("before media_check"));
628 if (!(r & STAT_ERR)) {
629 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
630 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after READ_VRFY"));
631 } else
632 disk->changed = 1;
633 if (r & ERR_MC) {
634 disk->changed = 1;
635 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_ACKCHANGE);
636 pd_wait_for(disk, STAT_READY, DBMSG("RDY after ACKCHANGE"));
637 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
638 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after VRFY"));
639 }
640 return Ok;
641}
642
643static void pd_standby_off(struct pd_unit *disk)
644{
645 pd_wait_for(disk, 0, DBMSG("before STANDBY"));
646 pd_send_command(disk, 0, 0, 0, 0, 0, IDE_STANDBY);
647 pd_wait_for(disk, 0, DBMSG("after STANDBY"));
648}
649
650static enum action pd_identify(struct pd_unit *disk)
651{
652 int j;
653 char id[PD_ID_LEN + 1];
654
655
656
657
658
659
660
661 if (disk->drive == 0)
662 pd_reset(disk);
663
664 write_reg(disk, 6, DRIVE(disk));
665 pd_wait_for(disk, 0, DBMSG("before IDENT"));
666 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_IDENTIFY);
667
668 if (pd_wait_for(disk, STAT_DRQ, DBMSG("IDENT DRQ")) & STAT_ERR)
669 return Fail;
670 pi_read_block(disk->pi, pd_scratch, 512);
671 disk->can_lba = pd_scratch[99] & 2;
672 disk->sectors = le16_to_cpu(*(__le16 *) (pd_scratch + 12));
673 disk->heads = le16_to_cpu(*(__le16 *) (pd_scratch + 6));
674 disk->cylinders = le16_to_cpu(*(__le16 *) (pd_scratch + 2));
675 if (disk->can_lba)
676 disk->capacity = le32_to_cpu(*(__le32 *) (pd_scratch + 120));
677 else
678 disk->capacity = disk->sectors * disk->heads * disk->cylinders;
679
680 for (j = 0; j < PD_ID_LEN; j++)
681 id[j ^ 1] = pd_scratch[j + PD_ID_OFF];
682 j = PD_ID_LEN - 1;
683 while ((j >= 0) && (id[j] <= 0x20))
684 j--;
685 j++;
686 id[j] = 0;
687
688 disk->removable = pd_scratch[0] & 0x80;
689
690 printk("%s: %s, %s, %d blocks [%dM], (%d/%d/%d), %s media\n",
691 disk->name, id,
692 disk->drive ? "slave" : "master",
693 disk->capacity, disk->capacity / 2048,
694 disk->cylinders, disk->heads, disk->sectors,
695 disk->removable ? "removable" : "fixed");
696
697 if (disk->capacity)
698 pd_init_dev_parms(disk);
699 if (!disk->standby)
700 pd_standby_off(disk);
701
702 return Ok;
703}
704
705
706
707static void do_pd_request(struct request_queue * q)
708{
709 if (pd_req)
710 return;
711 pd_req = blk_fetch_request(q);
712 if (!pd_req)
713 return;
714
715 schedule_fsm();
716}
717
718static int pd_special_command(struct pd_unit *disk,
719 enum action (*func)(struct pd_unit *disk))
720{
721 struct request *rq;
722 int err = 0;
723
724 rq = blk_get_request(disk->gd->queue, READ, __GFP_WAIT);
725
726 rq->cmd_type = REQ_TYPE_SPECIAL;
727 rq->special = func;
728
729 err = blk_execute_rq(disk->gd->queue, disk->gd, rq, 0);
730
731 blk_put_request(rq);
732 return err;
733}
734
735
736
737static int pd_open(struct block_device *bdev, fmode_t mode)
738{
739 struct pd_unit *disk = bdev->bd_disk->private_data;
740
741 mutex_lock(&pd_mutex);
742 disk->access++;
743
744 if (disk->removable) {
745 pd_special_command(disk, pd_media_check);
746 pd_special_command(disk, pd_door_lock);
747 }
748 mutex_unlock(&pd_mutex);
749 return 0;
750}
751
752static int pd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
753{
754 struct pd_unit *disk = bdev->bd_disk->private_data;
755
756 if (disk->alt_geom) {
757 geo->heads = PD_LOG_HEADS;
758 geo->sectors = PD_LOG_SECTS;
759 geo->cylinders = disk->capacity / (geo->heads * geo->sectors);
760 } else {
761 geo->heads = disk->heads;
762 geo->sectors = disk->sectors;
763 geo->cylinders = disk->cylinders;
764 }
765
766 return 0;
767}
768
769static int pd_ioctl(struct block_device *bdev, fmode_t mode,
770 unsigned int cmd, unsigned long arg)
771{
772 struct pd_unit *disk = bdev->bd_disk->private_data;
773
774 switch (cmd) {
775 case CDROMEJECT:
776 mutex_lock(&pd_mutex);
777 if (disk->access == 1)
778 pd_special_command(disk, pd_eject);
779 mutex_unlock(&pd_mutex);
780 return 0;
781 default:
782 return -EINVAL;
783 }
784}
785
786static void pd_release(struct gendisk *p, fmode_t mode)
787{
788 struct pd_unit *disk = p->private_data;
789
790 mutex_lock(&pd_mutex);
791 if (!--disk->access && disk->removable)
792 pd_special_command(disk, pd_door_unlock);
793 mutex_unlock(&pd_mutex);
794}
795
796static unsigned int pd_check_events(struct gendisk *p, unsigned int clearing)
797{
798 struct pd_unit *disk = p->private_data;
799 int r;
800 if (!disk->removable)
801 return 0;
802 pd_special_command(disk, pd_media_check);
803 r = disk->changed;
804 disk->changed = 0;
805 return r ? DISK_EVENT_MEDIA_CHANGE : 0;
806}
807
808static int pd_revalidate(struct gendisk *p)
809{
810 struct pd_unit *disk = p->private_data;
811 if (pd_special_command(disk, pd_identify) == 0)
812 set_capacity(p, disk->capacity);
813 else
814 set_capacity(p, 0);
815 return 0;
816}
817
818static const struct block_device_operations pd_fops = {
819 .owner = THIS_MODULE,
820 .open = pd_open,
821 .release = pd_release,
822 .ioctl = pd_ioctl,
823 .getgeo = pd_getgeo,
824 .check_events = pd_check_events,
825 .revalidate_disk= pd_revalidate
826};
827
828
829
830static void pd_probe_drive(struct pd_unit *disk)
831{
832 struct gendisk *p = alloc_disk(1 << PD_BITS);
833 if (!p)
834 return;
835 strcpy(p->disk_name, disk->name);
836 p->fops = &pd_fops;
837 p->major = major;
838 p->first_minor = (disk - pd) << PD_BITS;
839 disk->gd = p;
840 p->private_data = disk;
841 p->queue = pd_queue;
842
843 if (disk->drive == -1) {
844 for (disk->drive = 0; disk->drive <= 1; disk->drive++)
845 if (pd_special_command(disk, pd_identify) == 0)
846 return;
847 } else if (pd_special_command(disk, pd_identify) == 0)
848 return;
849 disk->gd = NULL;
850 put_disk(p);
851}
852
853static int pd_detect(void)
854{
855 int found = 0, unit, pd_drive_count = 0;
856 struct pd_unit *disk;
857
858 for (unit = 0; unit < PD_UNITS; unit++) {
859 int *parm = *drives[unit];
860 struct pd_unit *disk = pd + unit;
861 disk->pi = &disk->pia;
862 disk->access = 0;
863 disk->changed = 1;
864 disk->capacity = 0;
865 disk->drive = parm[D_SLV];
866 snprintf(disk->name, PD_NAMELEN, "%s%c", name, 'a'+unit);
867 disk->alt_geom = parm[D_GEO];
868 disk->standby = parm[D_SBY];
869 if (parm[D_PRT])
870 pd_drive_count++;
871 }
872
873 if (pd_drive_count == 0) {
874 disk = pd;
875 if (pi_init(disk->pi, 1, -1, -1, -1, -1, -1, pd_scratch,
876 PI_PD, verbose, disk->name)) {
877 pd_probe_drive(disk);
878 if (!disk->gd)
879 pi_release(disk->pi);
880 }
881
882 } else {
883 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
884 int *parm = *drives[unit];
885 if (!parm[D_PRT])
886 continue;
887 if (pi_init(disk->pi, 0, parm[D_PRT], parm[D_MOD],
888 parm[D_UNI], parm[D_PRO], parm[D_DLY],
889 pd_scratch, PI_PD, verbose, disk->name)) {
890 pd_probe_drive(disk);
891 if (!disk->gd)
892 pi_release(disk->pi);
893 }
894 }
895 }
896 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
897 if (disk->gd) {
898 set_capacity(disk->gd, disk->capacity);
899 add_disk(disk->gd);
900 found = 1;
901 }
902 }
903 if (!found)
904 printk("%s: no valid drive found\n", name);
905 return found;
906}
907
908static int __init pd_init(void)
909{
910 if (disable)
911 goto out1;
912
913 pd_queue = blk_init_queue(do_pd_request, &pd_lock);
914 if (!pd_queue)
915 goto out1;
916
917 blk_queue_max_hw_sectors(pd_queue, cluster);
918
919 if (register_blkdev(major, name))
920 goto out2;
921
922 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
923 name, name, PD_VERSION, major, cluster, nice);
924 if (!pd_detect())
925 goto out3;
926
927 return 0;
928
929out3:
930 unregister_blkdev(major, name);
931out2:
932 blk_cleanup_queue(pd_queue);
933out1:
934 return -ENODEV;
935}
936
937static void __exit pd_exit(void)
938{
939 struct pd_unit *disk;
940 int unit;
941 unregister_blkdev(major, name);
942 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
943 struct gendisk *p = disk->gd;
944 if (p) {
945 disk->gd = NULL;
946 del_gendisk(p);
947 put_disk(p);
948 pi_release(disk->pi);
949 }
950 }
951 blk_cleanup_queue(pd_queue);
952}
953
954MODULE_LICENSE("GPL");
955module_init(pd_init)
956module_exit(pd_exit)
957