blob: 9ec5d4ac0b644a42bb399bd2581e4f6c511eef7a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 pd.c (c) 1997-8 Grant R. Guenther <grant@torque.net>
3 Under the terms of the GNU General Public License.
4
5 This is the high-level driver for parallel port IDE hard
6 drives based on chips supported by the paride module.
7
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.
11
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:
15
16 drive0 These four arguments can be arrays of
17 drive1 1-8 integers as follows:
18 drive2
19 drive3 <prt>,<pro>,<uni>,<mod>,<geo>,<sby>,<dly>,<slv>
20
21 Where,
22
23 <prt> is the base of the parallel port address for
24 the corresponding drive. (required)
25
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)
30
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.
35 (0 if not given)
36
37 <mod> this can be -1 to choose the best mode, or one
38 of the mode numbers supported by the adapter.
39 (-1 if not given)
40
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)
47
48 <sby> set this to zero to disable the power saving
49 standby mode, if needed. (1 if not given)
50
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)
57
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
61 first drive found.
62
63
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
67 name as well.
68
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).
72 (default "pd")
73
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.
78 (default 64)
79
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
84 output. (default 0)
85
86 nice This parameter controls the driver's use of
87 idle CPU time, at the expense of some speed.
88
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:
92
93 pd.drive0
94 pd.drive1
95 pd.drive2
96 pd.drive3
97 pd.cluster
98 pd.nice
99
100 In addition, you can use the parameter pd.disable to disable
101 the driver entirely.
102
103*/
104
105/* Changes:
106
107 1.01 GRG 1997.01.24 Restored pd_reset()
108 Added eject ioctl
109 1.02 GRG 1998.05.06 SMP spinlock changes,
110 Added slave support
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
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/* Here are things one can override from the insmod command.
123 Most are autoprobed by paride unless set here. Verbose is off
124 by default.
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/* end of parameters */
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> /* for the eject ioctl */
152#include <linux/blkdev.h>
153#include <linux/blkpg.h>
Adrian Bunk3b717972006-03-28 01:56:25 -0800154#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156#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/* numbers for "SCSI" geometry */
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 /* interrupt timeout in jiffies */
184#define PD_SPIN_DEL 50 /* spin delay in micro-seconds */
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; /* 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 */
225 int sectors;
226 int cylinders;
227 int can_lba;
228 int drive; /* master=0 slave=1 */
229 int changed; /* Have we seen a disk change ? */
230 int removable; /* removable media device ? */
231 int standby;
232 int alt_geom;
233 char name[PD_NAMELEN]; /* pda, pdb, etc ... */
234 struct gendisk *gd;
235};
236
237static struct pd_unit pd[PD_UNITS];
238
239static char pd_scratch[512]; /* scratch block buffer */
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/* ide command interface */
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);
Adrian Bunk3b717972006-03-28 01:56:25 -0800278 for (i = 0; i < ARRAY_SIZE(pd_errs); i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 if (status & (1 << i))
280 printk(" %s", pd_errs[i]);
281 printk("\n");
282}
283
284static void pd_reset(struct pd_unit *disk)
285{ /* called only for MASTER drive */
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{ /* polled wait */
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); /* 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);
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/* The i/o request engine */
346
347enum action {Fail = 0, Ok = 1, Hold, Wait};
348
349static struct request *pd_req; /* current request */
350static enum action (*phase)(void);
351
352static void run_fsm(void);
353
David Howellsc4028952006-11-22 14:57:56 +0000354static void ps_tq_int(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
David Howellsc4028952006-11-22 14:57:56 +0000356static DECLARE_DELAYED_WORK(fsm_tq, ps_tq_int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
358static void schedule_fsm(void)
359{
360 if (!nice)
David Howellsc4028952006-11-22 14:57:56 +0000361 schedule_delayed_work(&fsm_tq, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 else
363 schedule_delayed_work(&fsm_tq, nice-1);
364}
365
David Howellsc4028952006-11-22 14:57:56 +0000366static void ps_tq_int(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367{
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; /* current request's drive */
382static PIA *pi_current; /* current request's PIA */
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);
Tejun Heof06d9a22009-04-23 11:05:19 +0900413 __blk_end_request_cur(pd_req,
414 res == Ok ? 0 : -EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 pd_req = elv_next_request(pd_queue);
416 if (!pd_req)
417 stop = 1;
418 spin_unlock_irqrestore(&pd_lock, saved_flags);
419 if (stop)
420 return;
421 case Hold:
422 schedule_fsm();
423 return;
424 case Wait:
425 pi_disconnect(pi_current);
426 pd_claimed = 0;
427 }
428 }
429}
430
431static int pd_retries = 0; /* i/o error retry count */
432static int pd_block; /* address of next requested block */
433static int pd_count; /* number of blocks still to do */
434static int pd_run; /* sectors in current cluster */
435static int pd_cmd; /* current command READ/WRITE */
436static char *pd_buf; /* buffer for request in progress */
437
438static enum action do_pd_io_start(void)
439{
Jens Axboe4aff5e22006-08-10 08:44:47 +0200440 if (blk_special_request(pd_req)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 phase = pd_special;
442 return pd_special();
443 }
444
445 pd_cmd = rq_data_dir(pd_req);
446 if (pd_cmd == READ || pd_cmd == WRITE) {
Tejun Heo83096eb2009-05-07 22:24:39 +0900447 pd_block = blk_rq_pos(pd_req);
448 pd_count = blk_rq_cur_sectors(pd_req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 if (pd_block + pd_count > get_capacity(pd_req->rq_disk))
450 return Fail;
Tejun Heo83096eb2009-05-07 22:24:39 +0900451 pd_run = blk_rq_sectors(pd_req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 pd_buf = pd_req->buffer;
453 pd_retries = 0;
454 if (pd_cmd == READ)
455 return do_pd_read_start();
456 else
457 return do_pd_write_start();
458 }
459 return Fail;
460}
461
462static enum action pd_special(void)
463{
464 enum action (*func)(struct pd_unit *) = pd_req->special;
465 return func(pd_current);
466}
467
468static int pd_next_buf(void)
469{
470 unsigned long saved_flags;
471
472 pd_count--;
473 pd_run--;
474 pd_buf += 512;
475 pd_block++;
476 if (!pd_run)
477 return 1;
478 if (pd_count)
479 return 0;
480 spin_lock_irqsave(&pd_lock, saved_flags);
Tejun Heof06d9a22009-04-23 11:05:19 +0900481 __blk_end_request_cur(pd_req, 0);
Tejun Heo83096eb2009-05-07 22:24:39 +0900482 pd_count = blk_rq_cur_sectors(pd_req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 pd_buf = pd_req->buffer;
484 spin_unlock_irqrestore(&pd_lock, saved_flags);
485 return 0;
486}
487
488static unsigned long pd_timeout;
489
490static enum action do_pd_read_start(void)
491{
492 if (pd_wait_for(pd_current, STAT_READY, "do_pd_read") & STAT_ERR) {
493 if (pd_retries < PD_MAX_RETRIES) {
494 pd_retries++;
495 return Wait;
496 }
497 return Fail;
498 }
499 pd_ide_command(pd_current, IDE_READ, pd_block, pd_run);
500 phase = do_pd_read_drq;
501 pd_timeout = jiffies + PD_TMO;
502 return Hold;
503}
504
505static enum action do_pd_write_start(void)
506{
507 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write") & STAT_ERR) {
508 if (pd_retries < PD_MAX_RETRIES) {
509 pd_retries++;
510 return Wait;
511 }
512 return Fail;
513 }
514 pd_ide_command(pd_current, IDE_WRITE, pd_block, pd_run);
515 while (1) {
516 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_write_drq") & STAT_ERR) {
517 if (pd_retries < PD_MAX_RETRIES) {
518 pd_retries++;
519 return Wait;
520 }
521 return Fail;
522 }
523 pi_write_block(pd_current->pi, pd_buf, 512);
524 if (pd_next_buf())
525 break;
526 }
527 phase = do_pd_write_done;
528 pd_timeout = jiffies + PD_TMO;
529 return Hold;
530}
531
532static inline int pd_ready(void)
533{
534 return !(status_reg(pd_current) & STAT_BUSY);
535}
536
537static enum action do_pd_read_drq(void)
538{
539 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
540 return Hold;
541
542 while (1) {
543 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_read_drq") & STAT_ERR) {
544 if (pd_retries < PD_MAX_RETRIES) {
545 pd_retries++;
546 phase = do_pd_read_start;
547 return Wait;
548 }
549 return Fail;
550 }
551 pi_read_block(pd_current->pi, pd_buf, 512);
552 if (pd_next_buf())
553 break;
554 }
555 return Ok;
556}
557
558static enum action do_pd_write_done(void)
559{
560 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
561 return Hold;
562
563 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write_done") & STAT_ERR) {
564 if (pd_retries < PD_MAX_RETRIES) {
565 pd_retries++;
566 phase = do_pd_write_start;
567 return Wait;
568 }
569 return Fail;
570 }
571 return Ok;
572}
573
574/* special io requests */
575
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.
580*/
581
582static void pd_init_dev_parms(struct pd_unit *disk)
583{
584 pd_wait_for(disk, 0, DBMSG("before init_dev_parms"));
585 pd_send_command(disk, disk->sectors, 0, disk->heads - 1, 0, 0,
586 IDE_INIT_DEV_PARMS);
587 udelay(300);
588 pd_wait_for(disk, 0, "Initialise device parameters");
589}
590
591static enum action pd_door_lock(struct pd_unit *disk)
592{
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");
596 }
597 return Ok;
598}
599
600static enum action pd_door_unlock(struct pd_unit *disk)
601{
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");
605 }
606 return Ok;
607}
608
609static enum action pd_eject(struct pd_unit *disk)
610{
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"));
617 return Ok;
618}
619
620static enum action pd_media_check(struct pd_unit *disk)
621{
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"));
626 } else
627 disk->changed = 1; /* say changed if other error */
628 if (r & ERR_MC) {
629 disk->changed = 1;
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"));
634 }
635 return Ok;
636}
637
638static void pd_standby_off(struct pd_unit *disk)
639{
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"));
643}
644
645static enum action pd_identify(struct pd_unit *disk)
646{
647 int j;
648 char id[PD_ID_LEN + 1];
649
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.
654*/
655
656 if (disk->drive == 0)
657 pd_reset(disk);
658
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);
662
663 if (pd_wait_for(disk, STAT_DRQ, DBMSG("IDENT DRQ")) & STAT_ERR)
664 return Fail;
665 pi_read_block(disk->pi, pd_scratch, 512);
666 disk->can_lba = pd_scratch[99] & 2;
Al Viro27d87182007-03-14 09:20:30 +0000667 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));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 if (disk->can_lba)
Al Viro27d87182007-03-14 09:20:30 +0000671 disk->capacity = le32_to_cpu(*(__le32 *) (pd_scratch + 120));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 else
673 disk->capacity = disk->sectors * disk->heads * disk->cylinders;
674
675 for (j = 0; j < PD_ID_LEN; j++)
676 id[j ^ 1] = pd_scratch[j + PD_ID_OFF];
677 j = PD_ID_LEN - 1;
678 while ((j >= 0) && (id[j] <= 0x20))
679 j--;
680 j++;
681 id[j] = 0;
682
683 disk->removable = pd_scratch[0] & 0x80;
684
685 printk("%s: %s, %s, %d blocks [%dM], (%d/%d/%d), %s media\n",
686 disk->name, id,
687 disk->drive ? "slave" : "master",
688 disk->capacity, disk->capacity / 2048,
689 disk->cylinders, disk->heads, disk->sectors,
690 disk->removable ? "removable" : "fixed");
691
692 if (disk->capacity)
693 pd_init_dev_parms(disk);
694 if (!disk->standby)
695 pd_standby_off(disk);
696
697 return Ok;
698}
699
700/* end of io request engine */
701
Jens Axboe165125e2007-07-24 09:28:11 +0200702static void do_pd_request(struct request_queue * q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703{
704 if (pd_req)
705 return;
706 pd_req = elv_next_request(q);
707 if (!pd_req)
708 return;
709
710 schedule_fsm();
711}
712
713static int pd_special_command(struct pd_unit *disk,
714 enum action (*func)(struct pd_unit *disk))
715{
FUJITA Tomonorid79c5a62008-07-15 21:21:45 +0200716 struct request *rq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 int err = 0;
718
FUJITA Tomonorid79c5a62008-07-15 21:21:45 +0200719 rq = blk_get_request(disk->gd->queue, READ, __GFP_WAIT);
720
721 rq->cmd_type = REQ_TYPE_SPECIAL;
722 rq->special = func;
723
724 err = blk_execute_rq(disk->gd->queue, disk->gd, rq, 0);
725
726 blk_put_request(rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 return err;
728}
729
730/* kernel glue structures */
731
Al Virob6a89532008-03-02 09:35:54 -0500732static int pd_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733{
Al Virob6a89532008-03-02 09:35:54 -0500734 struct pd_unit *disk = bdev->bd_disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
736 disk->access++;
737
738 if (disk->removable) {
739 pd_special_command(disk, pd_media_check);
740 pd_special_command(disk, pd_door_lock);
741 }
742 return 0;
743}
744
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800745static int pd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
746{
747 struct pd_unit *disk = bdev->bd_disk->private_data;
748
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);
753 } else {
754 geo->heads = disk->heads;
755 geo->sectors = disk->sectors;
756 geo->cylinders = disk->cylinders;
757 }
758
759 return 0;
760}
761
Al Virob6a89532008-03-02 09:35:54 -0500762static int pd_ioctl(struct block_device *bdev, fmode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 unsigned int cmd, unsigned long arg)
764{
Al Virob6a89532008-03-02 09:35:54 -0500765 struct pd_unit *disk = bdev->bd_disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
767 switch (cmd) {
768 case CDROMEJECT:
769 if (disk->access == 1)
770 pd_special_command(disk, pd_eject);
771 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 default:
773 return -EINVAL;
774 }
775}
776
Al Virob6a89532008-03-02 09:35:54 -0500777static int pd_release(struct gendisk *p, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778{
Al Virob6a89532008-03-02 09:35:54 -0500779 struct pd_unit *disk = p->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
781 if (!--disk->access && disk->removable)
782 pd_special_command(disk, pd_door_unlock);
783
784 return 0;
785}
786
787static int pd_check_media(struct gendisk *p)
788{
789 struct pd_unit *disk = p->private_data;
790 int r;
791 if (!disk->removable)
792 return 0;
793 pd_special_command(disk, pd_media_check);
794 r = disk->changed;
795 disk->changed = 0;
796 return r;
797}
798
799static int pd_revalidate(struct gendisk *p)
800{
801 struct pd_unit *disk = p->private_data;
802 if (pd_special_command(disk, pd_identify) == 0)
803 set_capacity(p, disk->capacity);
804 else
805 set_capacity(p, 0);
806 return 0;
807}
808
809static struct block_device_operations pd_fops = {
810 .owner = THIS_MODULE,
Al Virob6a89532008-03-02 09:35:54 -0500811 .open = pd_open,
812 .release = pd_release,
813 .locked_ioctl = pd_ioctl,
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800814 .getgeo = pd_getgeo,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 .media_changed = pd_check_media,
816 .revalidate_disk= pd_revalidate
817};
818
819/* probing */
820
821static void pd_probe_drive(struct pd_unit *disk)
822{
823 struct gendisk *p = alloc_disk(1 << PD_BITS);
824 if (!p)
825 return;
826 strcpy(p->disk_name, disk->name);
827 p->fops = &pd_fops;
828 p->major = major;
829 p->first_minor = (disk - pd) << PD_BITS;
830 disk->gd = p;
831 p->private_data = disk;
832 p->queue = pd_queue;
833
834 if (disk->drive == -1) {
835 for (disk->drive = 0; disk->drive <= 1; disk->drive++)
836 if (pd_special_command(disk, pd_identify) == 0)
837 return;
838 } else if (pd_special_command(disk, pd_identify) == 0)
839 return;
840 disk->gd = NULL;
841 put_disk(p);
842}
843
844static int pd_detect(void)
845{
846 int found = 0, unit, pd_drive_count = 0;
847 struct pd_unit *disk;
848
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;
853 disk->access = 0;
854 disk->changed = 1;
855 disk->capacity = 0;
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];
860 if (parm[D_PRT])
861 pd_drive_count++;
862 }
863
864 if (pd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
865 disk = pd;
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);
869 if (!disk->gd)
870 pi_release(disk->pi);
871 }
872
873 } else {
874 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
875 int *parm = *drives[unit];
876 if (!parm[D_PRT])
877 continue;
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);
882 if (!disk->gd)
883 pi_release(disk->pi);
884 }
885 }
886 }
887 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
888 if (disk->gd) {
889 set_capacity(disk->gd, disk->capacity);
890 add_disk(disk->gd);
891 found = 1;
892 }
893 }
894 if (!found)
895 printk("%s: no valid drive found\n", name);
896 return found;
897}
898
899static int __init pd_init(void)
900{
901 if (disable)
902 goto out1;
903
904 pd_queue = blk_init_queue(do_pd_request, &pd_lock);
905 if (!pd_queue)
906 goto out1;
907
908 blk_queue_max_sectors(pd_queue, cluster);
909
910 if (register_blkdev(major, name))
911 goto out2;
912
913 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
914 name, name, PD_VERSION, major, cluster, nice);
915 if (!pd_detect())
916 goto out3;
917
918 return 0;
919
920out3:
921 unregister_blkdev(major, name);
922out2:
923 blk_cleanup_queue(pd_queue);
924out1:
925 return -ENODEV;
926}
927
928static void __exit pd_exit(void)
929{
930 struct pd_unit *disk;
931 int unit;
932 unregister_blkdev(major, name);
933 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
934 struct gendisk *p = disk->gd;
935 if (p) {
936 disk->gd = NULL;
937 del_gendisk(p);
938 put_disk(p);
939 pi_release(disk->pi);
940 }
941 }
942 blk_cleanup_queue(pd_queue);
943}
944
945MODULE_LICENSE("GPL");
946module_init(pd_init)
947module_exit(pd_exit)