blob: 78a39f736c64f7edb6eb5d721e391d9e25f4a113 [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*/
Rusty Russell90ab5ee2012-01-13 09:32:20 +1030127#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
Arnd Bergmanndec63a42016-03-15 14:53:29 -0700129static int verbose = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130static 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/* end of parameters */
146
147#include <linux/init.h>
148#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +0900149#include <linux/gfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150#include <linux/fs.h>
151#include <linux/delay.h>
152#include <linux/hdreg.h>
153#include <linux/cdrom.h> /* for the eject ioctl */
154#include <linux/blkdev.h>
155#include <linux/blkpg.h>
Adrian Bunk3b717972006-03-28 01:56:25 -0800156#include <linux/kernel.h>
Arnd Bergmann2a48fc02010-06-02 14:28:52 +0200157#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159#include <linux/workqueue.h>
160
Arnd Bergmann2a48fc02010-06-02 14:28:52 +0200161static DEFINE_MUTEX(pd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162static DEFINE_SPINLOCK(pd_lock);
163
Arnd Bergmanndec63a42016-03-15 14:53:29 -0700164module_param(verbose, int, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165module_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/* numbers for "SCSI" geometry */
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 /* interrupt timeout in jiffies */
188#define PD_SPIN_DEL 50 /* spin delay in micro-seconds */
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; /* interface to paride layer */
225 struct pi_adapter *pi;
226 int access; /* count of active opens ... */
227 int capacity; /* Size of this volume in sectors */
228 int heads; /* physical geometry */
229 int sectors;
230 int cylinders;
231 int can_lba;
232 int drive; /* master=0 slave=1 */
233 int changed; /* Have we seen a disk change ? */
234 int removable; /* removable media device ? */
235 int standby;
236 int alt_geom;
237 char name[PD_NAMELEN]; /* pda, pdb, etc ... */
238 struct gendisk *gd;
239};
240
241static struct pd_unit pd[PD_UNITS];
242
243static char pd_scratch[512]; /* scratch block buffer */
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
Sudip Mukherjee9f4ba6b2015-05-20 20:57:01 +0530250static void *par_drv; /* reference of parport driver */
251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252static inline int status_reg(struct pd_unit *disk)
253{
254 return pi_read_regr(disk->pi, 1, 6);
255}
256
257static inline int read_reg(struct pd_unit *disk, int reg)
258{
259 return pi_read_regr(disk->pi, 0, reg);
260}
261
262static inline void write_status(struct pd_unit *disk, int val)
263{
264 pi_write_regr(disk->pi, 1, 6, val);
265}
266
267static inline void write_reg(struct pd_unit *disk, int reg, int val)
268{
269 pi_write_regr(disk->pi, 0, reg, val);
270}
271
272static inline u8 DRIVE(struct pd_unit *disk)
273{
274 return 0xa0+0x10*disk->drive;
275}
276
277/* ide command interface */
278
279static void pd_print_error(struct pd_unit *disk, char *msg, int status)
280{
281 int i;
282
283 printk("%s: %s: status = 0x%x =", disk->name, msg, status);
Adrian Bunk3b717972006-03-28 01:56:25 -0800284 for (i = 0; i < ARRAY_SIZE(pd_errs); i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 if (status & (1 << i))
286 printk(" %s", pd_errs[i]);
287 printk("\n");
288}
289
290static void pd_reset(struct pd_unit *disk)
291{ /* called only for MASTER drive */
292 write_status(disk, 4);
293 udelay(50);
294 write_status(disk, 0);
295 udelay(250);
296}
297
298#define DBMSG(msg) ((verbose>1)?(msg):NULL)
299
300static int pd_wait_for(struct pd_unit *disk, int w, char *msg)
301{ /* polled wait */
302 int k, r, e;
303
304 k = 0;
305 while (k < PD_SPIN) {
306 r = status_reg(disk);
307 k++;
308 if (((r & w) == w) && !(r & STAT_BUSY))
309 break;
310 udelay(PD_SPIN_DEL);
311 }
312 e = (read_reg(disk, 1) << 8) + read_reg(disk, 7);
313 if (k >= PD_SPIN)
314 e |= ERR_TMO;
315 if ((e & (STAT_ERR | ERR_TMO)) && (msg != NULL))
316 pd_print_error(disk, msg, e);
317 return e;
318}
319
320static void pd_send_command(struct pd_unit *disk, int n, int s, int h, int c0, int c1, int func)
321{
322 write_reg(disk, 6, DRIVE(disk) + h);
323 write_reg(disk, 1, 0); /* the IDE task file */
324 write_reg(disk, 2, n);
325 write_reg(disk, 3, s);
326 write_reg(disk, 4, c0);
327 write_reg(disk, 5, c1);
328 write_reg(disk, 7, func);
329
330 udelay(1);
331}
332
333static void pd_ide_command(struct pd_unit *disk, int func, int block, int count)
334{
335 int c1, c0, h, s;
336
337 if (disk->can_lba) {
338 s = block & 255;
339 c0 = (block >>= 8) & 255;
340 c1 = (block >>= 8) & 255;
341 h = ((block >>= 8) & 15) + 0x40;
342 } else {
343 s = (block % disk->sectors) + 1;
344 h = (block /= disk->sectors) % disk->heads;
345 c0 = (block /= disk->heads) % 256;
346 c1 = (block >>= 8);
347 }
348 pd_send_command(disk, count, s, h, c0, c1, func);
349}
350
351/* The i/o request engine */
352
353enum action {Fail = 0, Ok = 1, Hold, Wait};
354
355static struct request *pd_req; /* current request */
356static enum action (*phase)(void);
357
358static void run_fsm(void);
359
David Howellsc4028952006-11-22 14:57:56 +0000360static void ps_tq_int(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
David Howellsc4028952006-11-22 14:57:56 +0000362static DECLARE_DELAYED_WORK(fsm_tq, ps_tq_int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
364static void schedule_fsm(void)
365{
366 if (!nice)
David Howellsc4028952006-11-22 14:57:56 +0000367 schedule_delayed_work(&fsm_tq, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 else
369 schedule_delayed_work(&fsm_tq, nice-1);
370}
371
David Howellsc4028952006-11-22 14:57:56 +0000372static void ps_tq_int(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373{
374 run_fsm();
375}
376
377static enum action do_pd_io_start(void);
378static enum action pd_special(void);
379static enum action do_pd_read_start(void);
380static enum action do_pd_write_start(void);
381static enum action do_pd_read_drq(void);
382static enum action do_pd_write_done(void);
383
384static struct request_queue *pd_queue;
385static int pd_claimed;
386
387static struct pd_unit *pd_current; /* current request's drive */
388static PIA *pi_current; /* current request's PIA */
389
390static void run_fsm(void)
391{
392 while (1) {
393 enum action res;
394 unsigned long saved_flags;
395 int stop = 0;
396
397 if (!phase) {
398 pd_current = pd_req->rq_disk->private_data;
399 pi_current = pd_current->pi;
400 phase = do_pd_io_start;
401 }
402
403 switch (pd_claimed) {
404 case 0:
405 pd_claimed = 1;
406 if (!pi_schedule_claimed(pi_current, run_fsm))
407 return;
408 case 1:
409 pd_claimed = 2;
410 pi_current->proto->connect(pi_current);
411 }
412
413 switch(res = phase()) {
414 case Ok: case Fail:
415 pi_disconnect(pi_current);
416 pd_claimed = 0;
417 phase = NULL;
418 spin_lock_irqsave(&pd_lock, saved_flags);
Tejun Heob12d4f82009-05-08 11:54:06 +0900419 if (!__blk_end_request_cur(pd_req,
420 res == Ok ? 0 : -EIO)) {
Tejun Heo9934c8c2009-05-08 11:54:16 +0900421 pd_req = blk_fetch_request(pd_queue);
Tejun Heob12d4f82009-05-08 11:54:06 +0900422 if (!pd_req)
423 stop = 1;
Tejun Heob12d4f82009-05-08 11:54:06 +0900424 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 spin_unlock_irqrestore(&pd_lock, saved_flags);
426 if (stop)
427 return;
428 case Hold:
429 schedule_fsm();
430 return;
431 case Wait:
432 pi_disconnect(pi_current);
433 pd_claimed = 0;
434 }
435 }
436}
437
438static int pd_retries = 0; /* i/o error retry count */
439static int pd_block; /* address of next requested block */
440static int pd_count; /* number of blocks still to do */
441static int pd_run; /* sectors in current cluster */
442static int pd_cmd; /* current command READ/WRITE */
443static char *pd_buf; /* buffer for request in progress */
444
445static enum action do_pd_io_start(void)
446{
Christoph Hellwig4f8c9512015-04-17 22:37:16 +0200447 if (pd_req->cmd_type == REQ_TYPE_DRV_PRIV) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 phase = pd_special;
449 return pd_special();
450 }
451
452 pd_cmd = rq_data_dir(pd_req);
453 if (pd_cmd == READ || pd_cmd == WRITE) {
Tejun Heo83096eb2009-05-07 22:24:39 +0900454 pd_block = blk_rq_pos(pd_req);
455 pd_count = blk_rq_cur_sectors(pd_req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 if (pd_block + pd_count > get_capacity(pd_req->rq_disk))
457 return Fail;
Tejun Heo83096eb2009-05-07 22:24:39 +0900458 pd_run = blk_rq_sectors(pd_req);
Jens Axboeb4f42e22014-04-10 09:46:28 -0600459 pd_buf = bio_data(pd_req->bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 pd_retries = 0;
461 if (pd_cmd == READ)
462 return do_pd_read_start();
463 else
464 return do_pd_write_start();
465 }
466 return Fail;
467}
468
469static enum action pd_special(void)
470{
471 enum action (*func)(struct pd_unit *) = pd_req->special;
472 return func(pd_current);
473}
474
475static int pd_next_buf(void)
476{
477 unsigned long saved_flags;
478
479 pd_count--;
480 pd_run--;
481 pd_buf += 512;
482 pd_block++;
483 if (!pd_run)
484 return 1;
485 if (pd_count)
486 return 0;
487 spin_lock_irqsave(&pd_lock, saved_flags);
Tejun Heof06d9a22009-04-23 11:05:19 +0900488 __blk_end_request_cur(pd_req, 0);
Tejun Heo83096eb2009-05-07 22:24:39 +0900489 pd_count = blk_rq_cur_sectors(pd_req);
Jens Axboeb4f42e22014-04-10 09:46:28 -0600490 pd_buf = bio_data(pd_req->bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 spin_unlock_irqrestore(&pd_lock, saved_flags);
492 return 0;
493}
494
495static unsigned long pd_timeout;
496
497static enum action do_pd_read_start(void)
498{
499 if (pd_wait_for(pd_current, STAT_READY, "do_pd_read") & STAT_ERR) {
500 if (pd_retries < PD_MAX_RETRIES) {
501 pd_retries++;
502 return Wait;
503 }
504 return Fail;
505 }
506 pd_ide_command(pd_current, IDE_READ, pd_block, pd_run);
507 phase = do_pd_read_drq;
508 pd_timeout = jiffies + PD_TMO;
509 return Hold;
510}
511
512static enum action do_pd_write_start(void)
513{
514 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write") & STAT_ERR) {
515 if (pd_retries < PD_MAX_RETRIES) {
516 pd_retries++;
517 return Wait;
518 }
519 return Fail;
520 }
521 pd_ide_command(pd_current, IDE_WRITE, pd_block, pd_run);
522 while (1) {
523 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_write_drq") & STAT_ERR) {
524 if (pd_retries < PD_MAX_RETRIES) {
525 pd_retries++;
526 return Wait;
527 }
528 return Fail;
529 }
530 pi_write_block(pd_current->pi, pd_buf, 512);
531 if (pd_next_buf())
532 break;
533 }
534 phase = do_pd_write_done;
535 pd_timeout = jiffies + PD_TMO;
536 return Hold;
537}
538
539static inline int pd_ready(void)
540{
541 return !(status_reg(pd_current) & STAT_BUSY);
542}
543
544static enum action do_pd_read_drq(void)
545{
546 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
547 return Hold;
548
549 while (1) {
550 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_read_drq") & STAT_ERR) {
551 if (pd_retries < PD_MAX_RETRIES) {
552 pd_retries++;
553 phase = do_pd_read_start;
554 return Wait;
555 }
556 return Fail;
557 }
558 pi_read_block(pd_current->pi, pd_buf, 512);
559 if (pd_next_buf())
560 break;
561 }
562 return Ok;
563}
564
565static enum action do_pd_write_done(void)
566{
567 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout))
568 return Hold;
569
570 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write_done") & STAT_ERR) {
571 if (pd_retries < PD_MAX_RETRIES) {
572 pd_retries++;
573 phase = do_pd_write_start;
574 return Wait;
575 }
576 return Fail;
577 }
578 return Ok;
579}
580
581/* special io requests */
582
583/* According to the ATA standard, the default CHS geometry should be
584 available following a reset. Some Western Digital drives come up
585 in a mode where only LBA addresses are accepted until the device
586 parameters are initialised.
587*/
588
589static void pd_init_dev_parms(struct pd_unit *disk)
590{
591 pd_wait_for(disk, 0, DBMSG("before init_dev_parms"));
592 pd_send_command(disk, disk->sectors, 0, disk->heads - 1, 0, 0,
593 IDE_INIT_DEV_PARMS);
594 udelay(300);
595 pd_wait_for(disk, 0, "Initialise device parameters");
596}
597
598static enum action pd_door_lock(struct pd_unit *disk)
599{
600 if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
601 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORLOCK);
602 pd_wait_for(disk, STAT_READY, "Lock done");
603 }
604 return Ok;
605}
606
607static enum action pd_door_unlock(struct pd_unit *disk)
608{
609 if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) {
610 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
611 pd_wait_for(disk, STAT_READY, "Lock done");
612 }
613 return Ok;
614}
615
616static enum action pd_eject(struct pd_unit *disk)
617{
618 pd_wait_for(disk, 0, DBMSG("before unlock on eject"));
619 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK);
620 pd_wait_for(disk, 0, DBMSG("after unlock on eject"));
621 pd_wait_for(disk, 0, DBMSG("before eject"));
622 pd_send_command(disk, 0, 0, 0, 0, 0, IDE_EJECT);
623 pd_wait_for(disk, 0, DBMSG("after eject"));
624 return Ok;
625}
626
627static enum action pd_media_check(struct pd_unit *disk)
628{
629 int r = pd_wait_for(disk, STAT_READY, DBMSG("before media_check"));
630 if (!(r & STAT_ERR)) {
631 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
632 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after READ_VRFY"));
633 } else
634 disk->changed = 1; /* say changed if other error */
635 if (r & ERR_MC) {
636 disk->changed = 1;
637 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_ACKCHANGE);
638 pd_wait_for(disk, STAT_READY, DBMSG("RDY after ACKCHANGE"));
639 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY);
640 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after VRFY"));
641 }
642 return Ok;
643}
644
645static void pd_standby_off(struct pd_unit *disk)
646{
647 pd_wait_for(disk, 0, DBMSG("before STANDBY"));
648 pd_send_command(disk, 0, 0, 0, 0, 0, IDE_STANDBY);
649 pd_wait_for(disk, 0, DBMSG("after STANDBY"));
650}
651
652static enum action pd_identify(struct pd_unit *disk)
653{
654 int j;
655 char id[PD_ID_LEN + 1];
656
657/* WARNING: here there may be dragons. reset() applies to both drives,
658 but we call it only on probing the MASTER. This should allow most
659 common configurations to work, but be warned that a reset can clear
660 settings on the SLAVE drive.
661*/
662
663 if (disk->drive == 0)
664 pd_reset(disk);
665
666 write_reg(disk, 6, DRIVE(disk));
667 pd_wait_for(disk, 0, DBMSG("before IDENT"));
668 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_IDENTIFY);
669
670 if (pd_wait_for(disk, STAT_DRQ, DBMSG("IDENT DRQ")) & STAT_ERR)
671 return Fail;
672 pi_read_block(disk->pi, pd_scratch, 512);
673 disk->can_lba = pd_scratch[99] & 2;
Al Viro27d87182007-03-14 09:20:30 +0000674 disk->sectors = le16_to_cpu(*(__le16 *) (pd_scratch + 12));
675 disk->heads = le16_to_cpu(*(__le16 *) (pd_scratch + 6));
676 disk->cylinders = le16_to_cpu(*(__le16 *) (pd_scratch + 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 if (disk->can_lba)
Al Viro27d87182007-03-14 09:20:30 +0000678 disk->capacity = le32_to_cpu(*(__le32 *) (pd_scratch + 120));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 else
680 disk->capacity = disk->sectors * disk->heads * disk->cylinders;
681
682 for (j = 0; j < PD_ID_LEN; j++)
683 id[j ^ 1] = pd_scratch[j + PD_ID_OFF];
684 j = PD_ID_LEN - 1;
685 while ((j >= 0) && (id[j] <= 0x20))
686 j--;
687 j++;
688 id[j] = 0;
689
690 disk->removable = pd_scratch[0] & 0x80;
691
692 printk("%s: %s, %s, %d blocks [%dM], (%d/%d/%d), %s media\n",
693 disk->name, id,
694 disk->drive ? "slave" : "master",
695 disk->capacity, disk->capacity / 2048,
696 disk->cylinders, disk->heads, disk->sectors,
697 disk->removable ? "removable" : "fixed");
698
699 if (disk->capacity)
700 pd_init_dev_parms(disk);
701 if (!disk->standby)
702 pd_standby_off(disk);
703
704 return Ok;
705}
706
707/* end of io request engine */
708
Jens Axboe165125e2007-07-24 09:28:11 +0200709static void do_pd_request(struct request_queue * q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710{
711 if (pd_req)
712 return;
Tejun Heo9934c8c2009-05-08 11:54:16 +0900713 pd_req = blk_fetch_request(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 if (!pd_req)
715 return;
716
717 schedule_fsm();
718}
719
720static int pd_special_command(struct pd_unit *disk,
721 enum action (*func)(struct pd_unit *disk))
722{
FUJITA Tomonorid79c5a62008-07-15 21:21:45 +0200723 struct request *rq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 int err = 0;
725
Mel Gorman71baba42015-11-06 16:28:28 -0800726 rq = blk_get_request(disk->gd->queue, READ, __GFP_RECLAIM);
Joe Lawrencea492f072014-08-28 08:15:21 -0600727 if (IS_ERR(rq))
728 return PTR_ERR(rq);
FUJITA Tomonorid79c5a62008-07-15 21:21:45 +0200729
Christoph Hellwig4f8c9512015-04-17 22:37:16 +0200730 rq->cmd_type = REQ_TYPE_DRV_PRIV;
FUJITA Tomonorid79c5a62008-07-15 21:21:45 +0200731 rq->special = func;
732
733 err = blk_execute_rq(disk->gd->queue, disk->gd, rq, 0);
734
735 blk_put_request(rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 return err;
737}
738
739/* kernel glue structures */
740
Al Virob6a89532008-03-02 09:35:54 -0500741static int pd_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742{
Al Virob6a89532008-03-02 09:35:54 -0500743 struct pd_unit *disk = bdev->bd_disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Arnd Bergmann2a48fc02010-06-02 14:28:52 +0200745 mutex_lock(&pd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 disk->access++;
747
748 if (disk->removable) {
749 pd_special_command(disk, pd_media_check);
750 pd_special_command(disk, pd_door_lock);
751 }
Arnd Bergmann2a48fc02010-06-02 14:28:52 +0200752 mutex_unlock(&pd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 return 0;
754}
755
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800756static int pd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
757{
758 struct pd_unit *disk = bdev->bd_disk->private_data;
759
760 if (disk->alt_geom) {
761 geo->heads = PD_LOG_HEADS;
762 geo->sectors = PD_LOG_SECTS;
763 geo->cylinders = disk->capacity / (geo->heads * geo->sectors);
764 } else {
765 geo->heads = disk->heads;
766 geo->sectors = disk->sectors;
767 geo->cylinders = disk->cylinders;
768 }
769
770 return 0;
771}
772
Al Virob6a89532008-03-02 09:35:54 -0500773static int pd_ioctl(struct block_device *bdev, fmode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 unsigned int cmd, unsigned long arg)
775{
Al Virob6a89532008-03-02 09:35:54 -0500776 struct pd_unit *disk = bdev->bd_disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
778 switch (cmd) {
779 case CDROMEJECT:
Arnd Bergmann2a48fc02010-06-02 14:28:52 +0200780 mutex_lock(&pd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 if (disk->access == 1)
782 pd_special_command(disk, pd_eject);
Arnd Bergmann2a48fc02010-06-02 14:28:52 +0200783 mutex_unlock(&pd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 default:
786 return -EINVAL;
787 }
788}
789
Al Virodb2a1442013-05-05 21:52:57 -0400790static void pd_release(struct gendisk *p, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791{
Al Virob6a89532008-03-02 09:35:54 -0500792 struct pd_unit *disk = p->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Arnd Bergmann2a48fc02010-06-02 14:28:52 +0200794 mutex_lock(&pd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 if (!--disk->access && disk->removable)
796 pd_special_command(disk, pd_door_unlock);
Arnd Bergmann2a48fc02010-06-02 14:28:52 +0200797 mutex_unlock(&pd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798}
799
Tejun Heob1b56b92011-03-09 19:54:28 +0100800static unsigned int pd_check_events(struct gendisk *p, unsigned int clearing)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801{
802 struct pd_unit *disk = p->private_data;
803 int r;
804 if (!disk->removable)
805 return 0;
806 pd_special_command(disk, pd_media_check);
807 r = disk->changed;
808 disk->changed = 0;
Tejun Heob1b56b92011-03-09 19:54:28 +0100809 return r ? DISK_EVENT_MEDIA_CHANGE : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810}
811
812static int pd_revalidate(struct gendisk *p)
813{
814 struct pd_unit *disk = p->private_data;
815 if (pd_special_command(disk, pd_identify) == 0)
816 set_capacity(p, disk->capacity);
817 else
818 set_capacity(p, 0);
819 return 0;
820}
821
Alexey Dobriyan83d5cde2009-09-21 17:01:13 -0700822static const struct block_device_operations pd_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 .owner = THIS_MODULE,
Al Virob6a89532008-03-02 09:35:54 -0500824 .open = pd_open,
825 .release = pd_release,
Arnd Bergmann8a6cfeb2010-07-08 10:18:46 +0200826 .ioctl = pd_ioctl,
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800827 .getgeo = pd_getgeo,
Tejun Heob1b56b92011-03-09 19:54:28 +0100828 .check_events = pd_check_events,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 .revalidate_disk= pd_revalidate
830};
831
832/* probing */
833
834static void pd_probe_drive(struct pd_unit *disk)
835{
836 struct gendisk *p = alloc_disk(1 << PD_BITS);
837 if (!p)
838 return;
839 strcpy(p->disk_name, disk->name);
840 p->fops = &pd_fops;
841 p->major = major;
842 p->first_minor = (disk - pd) << PD_BITS;
843 disk->gd = p;
844 p->private_data = disk;
845 p->queue = pd_queue;
846
847 if (disk->drive == -1) {
848 for (disk->drive = 0; disk->drive <= 1; disk->drive++)
849 if (pd_special_command(disk, pd_identify) == 0)
850 return;
851 } else if (pd_special_command(disk, pd_identify) == 0)
852 return;
853 disk->gd = NULL;
854 put_disk(p);
855}
856
857static int pd_detect(void)
858{
859 int found = 0, unit, pd_drive_count = 0;
860 struct pd_unit *disk;
861
862 for (unit = 0; unit < PD_UNITS; unit++) {
863 int *parm = *drives[unit];
864 struct pd_unit *disk = pd + unit;
865 disk->pi = &disk->pia;
866 disk->access = 0;
867 disk->changed = 1;
868 disk->capacity = 0;
869 disk->drive = parm[D_SLV];
870 snprintf(disk->name, PD_NAMELEN, "%s%c", name, 'a'+unit);
871 disk->alt_geom = parm[D_GEO];
872 disk->standby = parm[D_SBY];
873 if (parm[D_PRT])
874 pd_drive_count++;
875 }
876
Sudip Mukherjee9f4ba6b2015-05-20 20:57:01 +0530877 par_drv = pi_register_driver(name);
878 if (!par_drv) {
879 pr_err("failed to register %s driver\n", name);
880 return -1;
881 }
882
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 if (pd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
884 disk = pd;
885 if (pi_init(disk->pi, 1, -1, -1, -1, -1, -1, pd_scratch,
886 PI_PD, verbose, disk->name)) {
887 pd_probe_drive(disk);
888 if (!disk->gd)
889 pi_release(disk->pi);
890 }
891
892 } else {
893 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
894 int *parm = *drives[unit];
895 if (!parm[D_PRT])
896 continue;
897 if (pi_init(disk->pi, 0, parm[D_PRT], parm[D_MOD],
898 parm[D_UNI], parm[D_PRO], parm[D_DLY],
899 pd_scratch, PI_PD, verbose, disk->name)) {
900 pd_probe_drive(disk);
901 if (!disk->gd)
902 pi_release(disk->pi);
903 }
904 }
905 }
906 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
907 if (disk->gd) {
908 set_capacity(disk->gd, disk->capacity);
909 add_disk(disk->gd);
910 found = 1;
911 }
912 }
Sudip Mukherjee9f4ba6b2015-05-20 20:57:01 +0530913 if (!found) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 printk("%s: no valid drive found\n", name);
Sudip Mukherjee9f4ba6b2015-05-20 20:57:01 +0530915 pi_unregister_driver(par_drv);
916 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 return found;
918}
919
920static int __init pd_init(void)
921{
922 if (disable)
923 goto out1;
924
925 pd_queue = blk_init_queue(do_pd_request, &pd_lock);
926 if (!pd_queue)
927 goto out1;
928
Martin K. Petersen086fa5f2010-02-26 00:20:38 -0500929 blk_queue_max_hw_sectors(pd_queue, cluster);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930
931 if (register_blkdev(major, name))
932 goto out2;
933
934 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
935 name, name, PD_VERSION, major, cluster, nice);
936 if (!pd_detect())
937 goto out3;
938
939 return 0;
940
941out3:
942 unregister_blkdev(major, name);
943out2:
944 blk_cleanup_queue(pd_queue);
945out1:
946 return -ENODEV;
947}
948
949static void __exit pd_exit(void)
950{
951 struct pd_unit *disk;
952 int unit;
953 unregister_blkdev(major, name);
954 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) {
955 struct gendisk *p = disk->gd;
956 if (p) {
957 disk->gd = NULL;
958 del_gendisk(p);
959 put_disk(p);
960 pi_release(disk->pi);
961 }
962 }
963 blk_cleanup_queue(pd_queue);
964}
965
966MODULE_LICENSE("GPL");
967module_init(pd_init)
968module_exit(pd_exit)