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
128static int verbose = 0;
129static int major = PD_MAJOR;
130static char *name = PD_NAME;
131static int cluster = 64;
132static int nice = 0;
133static int disable = 0;
134
135static int drive0[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
136static int drive1[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
137static int drive2[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
138static int drive3[8] = { 0, 0, 0, -1, 0, 1, -1, -1 };
139
140static int (*drives[4])[8] = {&drive0, &drive1, &drive2, &drive3};
141
142enum {D_PRT, D_PRO, D_UNI, D_MOD, D_GEO, D_SBY, D_DLY, D_SLV};
143
144
145
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>
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>
157
158static DEFINE_SPINLOCK(pd_lock);
159
160module_param(verbose, bool, 0);
161module_param(major, int, 0);
162module_param(name, charp, 0);
163module_param(cluster, int, 0);
164module_param(nice, int, 0);
165module_param_array(drive0, int, NULL, 0);
166module_param_array(drive1, int, NULL, 0);
167module_param_array(drive2, int, NULL, 0);
168module_param_array(drive3, int, NULL, 0);
169
170#include "paride.h"
171
172#define PD_BITS 4
173
174
175
176#define PD_LOG_HEADS 64
177#define PD_LOG_SECTS 32
178
179#define PD_ID_OFF 54
180#define PD_ID_LEN 14
181
182#define PD_MAX_RETRIES 5
183#define PD_TMO 800
184#define PD_SPIN_DEL 50
185
186#define PD_SPIN (1000000*PD_TMO)/(HZ*PD_SPIN_DEL)
187
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
196
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
205
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
216
217#define PD_NAMELEN 8
218
219struct pd_unit {
220 struct pi_adapter pia;
221 struct pi_adapter *pi;
222 int access;
223 int capacity;
224 int heads;
225 int sectors;
226 int cylinders;
227 int can_lba;
228 int drive;
229 int changed;
230 int removable;
231 int standby;
232 int alt_geom;
233 char name[PD_NAMELEN];
234 struct gendisk *gd;
235};
236
237static struct pd_unit pd[PD_UNITS];
238
239static char pd_scratch[512];
240
241static char *pd_errs[17] = { "ERR", "INDEX", "ECC", "DRQ", "SEEK", "WRERR",
242 "READY", "BUSY", "AMNF", "TK0NF", "ABRT", "MCR",
243 "IDNF", "MC", "UNC", "???", "TMO"
244};
245
246static inline int status_reg(struct pd_unit *disk)
247{
248 return pi_read_regr(disk->pi, 1, 6);
249}
250
251static inline int read_reg(struct pd_unit *disk, int reg)
252{
253 return pi_read_regr(disk->pi, 0, reg);
254}
255
256static inline void write_status(struct pd_unit *disk, int val)
257{
258 pi_write_regr(disk->pi, 1, 6, val);
259}
260
261static inline void write_reg(struct pd_unit *disk, int reg, int val)
262{
263 pi_write_regr(disk->pi, 0, reg, val);
264}
265
266static inline u8 DRIVE(struct pd_unit *disk)
267{
268 return 0xa0+0x10*disk->drive;
269}
270
271
272
273static void pd_print_error(struct pd_unit *disk, char *msg, int status)
274{
275 int i;
276
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]);
281 printk("\n");
282}
283
284static void pd_reset(struct pd_unit *disk)
285{
286 write_status(disk, 4);
287 udelay(50);
288 write_status(disk, 0);
289 udelay(250);
290}
291
292#define DBMSG(msg) ((verbose>1)?(msg):NULL)
293
294static int pd_wait_for(struct pd_unit *disk, int w, char *msg)
295{
296 int k, r, e;
297
298 k = 0;
299 while (k < PD_SPIN) {
300 r = status_reg(disk);
301 k++;
302 if (((r & w) == w) && !(r & STAT_BUSY))
303 break;
304 udelay(PD_SPIN_DEL);
305 }
306 e = (read_reg(disk, 1) << 8) + read_reg(disk, 7);
307 if (k >= PD_SPIN)
308 e |= ERR_TMO;
309 if ((e & (STAT_ERR | ERR_TMO)) && (msg != NULL))
310 pd_print_error(disk, msg, e);
311 return e;
312}
313
314static void pd_send_command(struct pd_unit *disk, int n, int s, int h, int c0, int c1, int func)
315{
316 write_reg(disk, 6, DRIVE(disk) + h);
317 write_reg(disk, 1, 0);
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);
323
324 udelay(1);
325}
326
327static void pd_ide_command(struct pd_unit *disk, int func, int block, int count)
328{
329 int c1, c0, h, s;
330
331 if (disk->can_lba) {
332 s = block & 255;
333 c0 = (block >>= 8) & 255;
334 c1 = (block >>= 8) & 255;
335 h = ((block >>= 8) & 15) + 0x40;
336 } else {
337 s = (block % disk->sectors) + 1;
338 h = (block /= disk->sectors) % disk->heads;
339 c0 = (block /= disk->heads) % 256;
340 c1 = (block >>= 8);
341 }
342 pd_send_command(disk, count, s, h, c0, c1, func);
343}
344
345
346
347enum action {Fail = 0, Ok = 1, Hold, Wait};
348
349static struct request *pd_req;
350static enum action (*phase)(void);
351
352static void run_fsm(void);
353
354static void ps_tq_int(struct work_struct *work);
355
356static DECLARE_DELAYED_WORK(fsm_tq, ps_tq_int);
357
358static void schedule_fsm(void)
359{
360 if (!nice)
361 schedule_delayed_work(&fsm_tq, 0);
362 else
363 schedule_delayed_work(&fsm_tq, nice-1);
364}
365
366static void ps_tq_int(struct work_struct *work)
367{
368 run_fsm();
369}
370
371static enum action do_pd_io_start(void);
372static enum action pd_special(void);
373static enum action do_pd_read_start(void);
374static enum action do_pd_write_start(void);
375static enum action do_pd_read_drq(void);
376static enum action do_pd_write_done(void);
377
378static struct request_queue *pd_queue;
379static int pd_claimed;
380
381static struct pd_unit *pd_current;
382static PIA *pi_current;
383
384static void run_fsm(void)
385{
386 while (1) {
387 enum action res;
388 unsigned long saved_flags;
389 int stop = 0;
390
391 if (!phase) {
392 pd_current = pd_req->rq_disk->private_data;
393 pi_current = pd_current->pi;
394 phase = do_pd_io_start;
395 }
396
397 switch (pd_claimed) {
398 case 0:
399 pd_claimed = 1;
400 if (!pi_schedule_claimed(pi_current, run_fsm))
401 return;
402 case 1:
403 pd_claimed = 2;
404 pi_current->proto->connect(pi_current);
405 }
406
407 switch(res = phase()) {
408 case Ok: case Fail:
409 pi_disconnect(pi_current);
410 pd_claimed = 0;
411 phase = NULL;
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);
416 if (!pd_req)
417 stop = 1;
418 }
419 spin_unlock_irqrestore(&pd_lock, saved_flags);
420 if (stop)
421 return;
422 case Hold:
423 schedule_fsm();
424 return;
425 case Wait:
426 pi_disconnect(pi_current);
427 pd_claimed = 0;
428 }
429 }
430}
431
432static int pd_retries = 0;
433static int pd_block;
434static int pd_count;
435static int pd_run;
436static int pd_cmd;
437static char *pd_buf;
438
439static enum action do_pd_io_start(void)
440{
441 if (blk_special_request(pd_req)) {
442 phase = pd_special;
443 return pd_special();
444 }
445
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))
451 return Fail;
452 pd_run = blk_rq_sectors(pd_req);
453 pd_buf = pd_req->buffer;
454 pd_retries = 0;
455 if (pd_cmd == READ)
456 return do_pd_read_start();
457 else
458 return do_pd_write_start();
459 }
460 return Fail;
461}
462
463static enum action pd_special(void)
464{
465 enum action (*func)(struct pd_unit *) = pd_req->special;
466 return func(pd_current);
467}
468
469static int pd_next_buf(void)
470{
471 unsigned long saved_flags;
472
473 pd_count--;
474 pd_run--;
475 pd_buf += 512;
476 pd_block++;
477 if (!pd_run)
478 return 1;
479 if (pd_count)
480 return 0;
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);
486 return 0;
487}
488
489static unsigned long pd_timeout;
490
491static enum action do_pd_read_start(void)
492{
493 if (pd_wait_for(pd_current, STAT_READY, "do_pd_read") & STAT_ERR) {
494 if (pd_retries < PD_MAX_RETRIES) {
495 pd_retries++;
496 return Wait;
497 }
498 return Fail;
499 }
500 pd_ide_command(pd_current, IDE_READ, pd_block, pd_run);
501 phase = do_pd_read_drq;
502 pd_timeout = jiffies + PD_TMO;
503 return Hold;
504}
505
506static enum action do_pd_write_start(void)
507{
508 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write") & STAT_ERR) {
509 if (pd_retries < PD_MAX_RETRIES) {
510 pd_retries++;
511 return Wait;
512 }
513 return Fail;
514 }
515 pd_ide_command(pd_current, IDE_WRITE, pd_block, pd_run);
516 while (1) {
517 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_write_drq") & STAT_ERR) {
518 if (pd_retries < PD_MAX_RETRIES) {
519 pd_retries++;
520 return Wait;
521 }
522 return Fail;
523 }
524 pi_write_block(pd_current->pi, pd_buf, 512);
525 if (pd_next_buf())
526 break;
527 }
528 phase = do_pd_write_done;
529 pd_timeout = jiffies + PD_TMO;
530 return Hold;
531}
532
533static inline int pd_ready(void)
534{
535 return !(status_reg(pd_current) & STAT_BUSY);
536}
537
538static enum action do_pd_read_drq(void)
539{
540 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
541 return Hold;
542
543 while (1) {
544 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_read_drq") & STAT_ERR) {
545 if (pd_retries < PD_MAX_RETRIES) {
546 pd_retries++;
547 phase = do_pd_read_start;
548 return Wait;
549 }
550 return Fail;
551 }
552 pi_read_block(pd_current->pi, pd_buf, 512);
553 if (pd_next_buf())
554 break;
555 }
556 return Ok;
557}
558
559static enum action do_pd_write_done(void)
560{
561 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
562 return Hold;
563
564 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write_done") & STAT_ERR) {
565 if (pd_retries < PD_MAX_RETRIES) {
566 pd_retries++;
567 phase = do_pd_write_start;
568 return Wait;
569 }
570 return Fail;
571 }
572 return Ok;
573}
574
575
576
577
578
579
580
581
582
583static void pd_init_dev_parms(struct pd_unit *disk)
584{
585 pd_wait_for(disk, 0, DBMSG("before init_dev_parms"));
586 pd_send_command(disk, disk->sectors, 0, disk->heads - 1, 0, 0,
587 IDE_INIT_DEV_PARMS);
588 udelay(300);
589 pd_wait_for(disk, 0, "Initialise device parameters");
590}
591
592static enum action pd_door_lock(struct pd_unit *disk)
593{
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");
597 }
598 return Ok;
599}
600
601static enum action pd_door_unlock(struct pd_unit *disk)
602{
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");
606 }
607 return Ok;
608}
609
610static enum action pd_eject(struct pd_unit *disk)
611{
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"));
618 return Ok;
619}
620
621static enum action pd_media_check(struct pd_unit *disk)
622{
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"));
627 } else
628 disk->changed = 1;
629 if (r & ERR_MC) {
630 disk->changed = 1;
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"));
635 }
636 return Ok;
637}
638
639static void pd_standby_off(struct pd_unit *disk)
640{
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"));
644}
645
646static enum action pd_identify(struct pd_unit *disk)
647{
648 int j;
649 char id[PD_ID_LEN + 1];
650
651
652
653
654
655
656
657 if (disk->drive == 0)
658 pd_reset(disk);
659
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);
663
664 if (pd_wait_for(disk, STAT_DRQ, DBMSG("IDENT DRQ")) & STAT_ERR)
665 return Fail;
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));
671 if (disk->can_lba)
672 disk->capacity = le32_to_cpu(*(__le32 *) (pd_scratch + 120));
673 else
674 disk->capacity = disk->sectors * disk->heads * disk->cylinders;
675
676 for (j = 0; j < PD_ID_LEN; j++)
677 id[j ^ 1] = pd_scratch[j + PD_ID_OFF];
678 j = PD_ID_LEN - 1;
679 while ((j >= 0) && (id[j] <= 0x20))
680 j--;
681 j++;
682 id[j] = 0;
683
684 disk->removable = pd_scratch[0] & 0x80;
685
686 printk("%s: %s, %s, %d blocks [%dM], (%d/%d/%d), %s media\n",
687 disk->name, id,
688 disk->drive ? "slave" : "master",
689 disk->capacity, disk->capacity / 2048,
690 disk->cylinders, disk->heads, disk->sectors,
691 disk->removable ? "removable" : "fixed");
692
693 if (disk->capacity)
694 pd_init_dev_parms(disk);
695 if (!disk->standby)
696 pd_standby_off(disk);
697
698 return Ok;
699}
700
701
702
703static void do_pd_request(struct request_queue * q)
704{
705 if (pd_req)
706 return;
707 pd_req = blk_fetch_request(q);
708 if (!pd_req)
709 return;
710
711 schedule_fsm();
712}
713
714static int pd_special_command(struct pd_unit *disk,
715 enum action (*func)(struct pd_unit *disk))
716{
717 struct request *rq;
718 int err = 0;
719
720 rq = blk_get_request(disk->gd->queue, READ, __GFP_WAIT);
721
722 rq->cmd_type = REQ_TYPE_SPECIAL;
723 rq->special = func;
724
725 err = blk_execute_rq(disk->gd->queue, disk->gd, rq, 0);
726
727 blk_put_request(rq);
728 return err;
729}
730
731
732
733static int pd_open(struct block_device *bdev, fmode_t mode)
734{
735 struct pd_unit *disk = bdev->bd_disk->private_data;
736
737 disk->access++;
738
739 if (disk->removable) {
740 pd_special_command(disk, pd_media_check);
741 pd_special_command(disk, pd_door_lock);
742 }
743 return 0;
744}
745
746static int pd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
747{
748 struct pd_unit *disk = bdev->bd_disk->private_data;
749
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);
754 } else {
755 geo->heads = disk->heads;
756 geo->sectors = disk->sectors;
757 geo->cylinders = disk->cylinders;
758 }
759
760 return 0;
761}
762
763static int pd_ioctl(struct block_device *bdev, fmode_t mode,
764 unsigned int cmd, unsigned long arg)
765{
766 struct pd_unit *disk = bdev->bd_disk->private_data;
767
768 switch (cmd) {
769 case CDROMEJECT:
770 if (disk->access == 1)
771 pd_special_command(disk, pd_eject);
772 return 0;
773 default:
774 return -EINVAL;
775 }
776}
777
778static int pd_release(struct gendisk *p, fmode_t mode)
779{
780 struct pd_unit *disk = p->private_data;
781
782 if (!--disk->access && disk->removable)
783 pd_special_command(disk, pd_door_unlock);
784
785 return 0;
786}
787
788static int pd_check_media(struct gendisk *p)
789{
790 struct pd_unit *disk = p->private_data;
791 int r;
792 if (!disk->removable)
793 return 0;
794 pd_special_command(disk, pd_media_check);
795 r = disk->changed;
796 disk->changed = 0;
797 return r;
798}
799
800static int pd_revalidate(struct gendisk *p)
801{
802 struct pd_unit *disk = p->private_data;
803 if (pd_special_command(disk, pd_identify) == 0)
804 set_capacity(p, disk->capacity);
805 else
806 set_capacity(p, 0);
807 return 0;
808}
809
810static const struct block_device_operations pd_fops = {
811 .owner = THIS_MODULE,
812 .open = pd_open,
813 .release = pd_release,
814 .locked_ioctl = pd_ioctl,
815 .getgeo = pd_getgeo,
816 .media_changed = pd_check_media,
817 .revalidate_disk= pd_revalidate
818};
819
820
821
822static void pd_probe_drive(struct pd_unit *disk)
823{
824 struct gendisk *p = alloc_disk(1 << PD_BITS);
825 if (!p)
826 return;
827 strcpy(p->disk_name, disk->name);
828 p->fops = &pd_fops;
829 p->major = major;
830 p->first_minor = (disk - pd) << PD_BITS;
831 disk->gd = p;
832 p->private_data = disk;
833 p->queue = pd_queue;
834
835 if (disk->drive == -1) {
836 for (disk->drive = 0; disk->drive <= 1; disk->drive++)
837 if (pd_special_command(disk, pd_identify) == 0)
838 return;
839 } else if (pd_special_command(disk, pd_identify) == 0)
840 return;
841 disk->gd = NULL;
842 put_disk(p);
843}
844
845static int pd_detect(void)
846{
847 int found = 0, unit, pd_drive_count = 0;
848 struct pd_unit *disk;
849
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;
854 disk->access = 0;
855 disk->changed = 1;
856 disk->capacity = 0;
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];
861 if (parm[D_PRT])
862 pd_drive_count++;
863 }
864
865 if (pd_drive_count == 0) {
866 disk = pd;
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);
870 if (!disk->gd)
871 pi_release(disk->pi);
872 }
873
874 } else {
875 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
876 int *parm = *drives[unit];
877 if (!parm[D_PRT])
878 continue;
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);
883 if (!disk->gd)
884 pi_release(disk->pi);
885 }
886 }
887 }
888 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
889 if (disk->gd) {
890 set_capacity(disk->gd, disk->capacity);
891 add_disk(disk->gd);
892 found = 1;
893 }
894 }
895 if (!found)
896 printk("%s: no valid drive found\n", name);
897 return found;
898}
899
900static int __init pd_init(void)
901{
902 if (disable)
903 goto out1;
904
905 pd_queue = blk_init_queue(do_pd_request, &pd_lock);
906 if (!pd_queue)
907 goto out1;
908
909 blk_queue_max_sectors(pd_queue, cluster);
910
911 if (register_blkdev(major, name))
912 goto out2;
913
914 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
915 name, name, PD_VERSION, major, cluster, nice);
916 if (!pd_detect())
917 goto out3;
918
919 return 0;
920
921out3:
922 unregister_blkdev(major, name);
923out2:
924 blk_cleanup_queue(pd_queue);
925out1:
926 return -ENODEV;
927}
928
929static void __exit pd_exit(void)
930{
931 struct pd_unit *disk;
932 int unit;
933 unregister_blkdev(major, name);
934 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
935 struct gendisk *p = disk->gd;
936 if (p) {
937 disk->gd = NULL;
938 del_gendisk(p);
939 put_disk(p);
940 pi_release(disk->pi);
941 }
942 }
943 blk_cleanup_queue(pd_queue);
944}
945
946MODULE_LICENSE("GPL");
947module_init(pd_init)
948module_exit(pd_exit)
949