1 /*
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
128 static int verbose = 0;
129 static int major = PD_MAJOR;
130 static char *name = PD_NAME;
131 static int cluster = 64;
132 static int nice = 0;
133 static int disable = 0;
134
135 static int drive0[8] = {0,0,0,-1,0,1,-1,-1};
136 static int drive1[8] = {0,0,0,-1,0,1,-1,-1};
137 static int drive2[8] = {0,0,0,-1,0,1,-1,-1};
138 static int drive3[8] = {0,0,0,-1,0,1,-1,-1};
139
140 static int (*drives[4])[8] = {&drive0,&drive1,&drive2,&drive3};
141 static int pd_drive_count;
142
143 #define D_PRT 0
144 #define D_PRO 1
145 #define D_UNI 2
146 #define D_MOD 3
147 #define D_GEO 4
148 #define D_SBY 5
149 #define D_DLY 6
150 #define D_SLV 7
151
152 #define DU (*drives[unit])
153
154 /* end of parameters */
155
156 #include <linux/module.h>
157 #include <linux/errno.h>
158 #include <linux/fs.h>
159 #include <linux/devfs_fs_kernel.h>
160 #include <linux/kernel.h>
161 #include <linux/delay.h>
162 #include <linux/genhd.h>
163 #include <linux/hdreg.h>
164 #include <linux/cdrom.h> /* for the eject ioctl */
165 #include <linux/spinlock.h>
166
167 #include <asm/uaccess.h>
168
169 #ifndef MODULE
170
171 #include "setup.h"
172
173 static STT pd_stt[7] = {{"drive0",8,drive0},
174 {"drive1",8,drive1},
175 {"drive2",8,drive2},
176 {"drive3",8,drive3},
177 {"disable",1,&disable},
178 {"cluster",1,&cluster},
179 {"nice",1,&nice}};
180
pd_setup(char * str,int * ints)181 void pd_setup( char *str, int *ints)
182
183 {
184 generic_setup(pd_stt,7,str);
185 }
186
187 #endif
188
189 MODULE_PARM(verbose,"i");
190 MODULE_PARM(major,"i");
191 MODULE_PARM(name,"s");
192 MODULE_PARM(cluster,"i");
193 MODULE_PARM(nice,"i");
194 MODULE_PARM(drive0,"1-8i");
195 MODULE_PARM(drive1,"1-8i");
196 MODULE_PARM(drive2,"1-8i");
197 MODULE_PARM(drive3,"1-8i");
198
199 #include "paride.h"
200
201 #define PD_BITS 4
202
203 /* set up defines for blk.h, why don't all drivers do it this way ? */
204
205 #define MAJOR_NR major
206 #define DEVICE_NAME "PD"
207 #define DEVICE_REQUEST do_pd_request
208 #define DEVICE_NR(device) (MINOR(device)>>PD_BITS)
209 #define DEVICE_ON(device)
210 #define DEVICE_OFF(device)
211
212 #include <linux/blk.h>
213 #include <linux/blkpg.h>
214
215 #include "pseudo.h"
216
217 #define PD_PARTNS (1<<PD_BITS)
218 #define PD_DEVS PD_PARTNS*PD_UNITS
219
220 /* numbers for "SCSI" geometry */
221
222 #define PD_LOG_HEADS 64
223 #define PD_LOG_SECTS 32
224
225 #define PD_ID_OFF 54
226 #define PD_ID_LEN 14
227
228 #define PD_MAX_RETRIES 5
229 #define PD_TMO 800 /* interrupt timeout in jiffies */
230 #define PD_SPIN_DEL 50 /* spin delay in micro-seconds */
231
232 #define PD_SPIN (1000000*PD_TMO)/(HZ*PD_SPIN_DEL)
233
234 #define STAT_ERR 0x00001
235 #define STAT_INDEX 0x00002
236 #define STAT_ECC 0x00004
237 #define STAT_DRQ 0x00008
238 #define STAT_SEEK 0x00010
239 #define STAT_WRERR 0x00020
240 #define STAT_READY 0x00040
241 #define STAT_BUSY 0x00080
242
243 #define ERR_AMNF 0x00100
244 #define ERR_TK0NF 0x00200
245 #define ERR_ABRT 0x00400
246 #define ERR_MCR 0x00800
247 #define ERR_IDNF 0x01000
248 #define ERR_MC 0x02000
249 #define ERR_UNC 0x04000
250 #define ERR_TMO 0x10000
251
252 #define IDE_READ 0x20
253 #define IDE_WRITE 0x30
254 #define IDE_READ_VRFY 0x40
255 #define IDE_INIT_DEV_PARMS 0x91
256 #define IDE_STANDBY 0x96
257 #define IDE_ACKCHANGE 0xdb
258 #define IDE_DOORLOCK 0xde
259 #define IDE_DOORUNLOCK 0xdf
260 #define IDE_IDENTIFY 0xec
261 #define IDE_EJECT 0xed
262
263 int pd_init(void);
264 void pd_setup(char * str, int * ints);
265 #ifdef MODULE
266 void cleanup_module( void );
267 #endif
268 static int pd_open(struct inode *inode, struct file *file);
269 static void do_pd_request(request_queue_t * q);
270 static int pd_ioctl(struct inode *inode,struct file *file,
271 unsigned int cmd, unsigned long arg);
272 static int pd_release (struct inode *inode, struct file *file);
273 static int pd_revalidate(kdev_t dev);
274 static int pd_detect(void);
275 static void do_pd_read(void);
276 static void do_pd_read_start(void);
277 static void do_pd_write(void);
278 static void do_pd_write_start(void);
279 static void do_pd_read_drq( void );
280 static void do_pd_write_done( void );
281
282 static int pd_identify (int unit);
283 static void pd_media_check(int unit);
284 static void pd_doorlock(int unit, int func);
285 static int pd_check_media(kdev_t dev);
286 static void pd_eject( int unit);
287
288 static struct hd_struct pd_hd[PD_DEVS];
289 static int pd_sizes[PD_DEVS];
290 static int pd_blocksizes[PD_DEVS];
291 static int pd_maxsectors[PD_DEVS];
292
293 #define PD_NAMELEN 8
294
295 struct pd_unit {
296 struct pi_adapter pia; /* interface to paride layer */
297 struct pi_adapter *pi;
298 int access; /* count of active opens ... */
299 int capacity; /* Size of this volume in sectors */
300 int heads; /* physical geometry */
301 int sectors;
302 int cylinders;
303 int can_lba;
304 int drive; /* master=0 slave=1 */
305 int changed; /* Have we seen a disk change ? */
306 int removable; /* removable media device ? */
307 int standby;
308 int alt_geom;
309 int present;
310 char name[PD_NAMELEN]; /* pda, pdb, etc ... */
311 };
312
313 struct pd_unit pd[PD_UNITS];
314
315 /* 'unit' must be defined in all functions - either as a local or a param */
316
317 #define PD pd[unit]
318 #define PI PD.pi
319
320 static int pd_valid = 1; /* serialise partition checks */
321 static char pd_scratch[512]; /* scratch block buffer */
322
323 /* the variables below are used mainly in the I/O request engine, which
324 processes only one request at a time.
325 */
326
327 static int pd_retries = 0; /* i/o error retry count */
328 static int pd_busy = 0; /* request being processed ? */
329 static int pd_block; /* address of next requested block */
330 static int pd_count; /* number of blocks still to do */
331 static int pd_run; /* sectors in current cluster */
332 static int pd_cmd; /* current command READ/WRITE */
333 static int pd_unit; /* unit of current request */
334 static int pd_dev; /* minor of current request */
335 static int pd_poffs; /* partition offset of current minor */
336 static char * pd_buf; /* buffer for request in progress */
337
338 static DECLARE_WAIT_QUEUE_HEAD(pd_wait_open);
339
340 static char *pd_errs[17] = { "ERR","INDEX","ECC","DRQ","SEEK","WRERR",
341 "READY","BUSY","AMNF","TK0NF","ABRT","MCR",
342 "IDNF","MC","UNC","???","TMO"};
343
344 /* kernel glue structures */
345
346 static struct block_device_operations pd_fops = {
347 owner: THIS_MODULE,
348 open: pd_open,
349 release: pd_release,
350 ioctl: pd_ioctl,
351 check_media_change: pd_check_media,
352 revalidate: pd_revalidate
353 };
354
355 static struct gendisk pd_gendisk = {
356 major: PD_MAJOR,
357 major_name: PD_NAME,
358 minor_shift: PD_BITS,
359 max_p: PD_PARTNS,
360 part: pd_hd,
361 sizes: pd_sizes,
362 fops: &pd_fops,
363 };
364
pd_init_units(void)365 void pd_init_units( void )
366
367 { int unit, j;
368
369 pd_drive_count = 0;
370 for (unit=0;unit<PD_UNITS;unit++) {
371 PD.pi = & PD.pia;
372 PD.access = 0;
373 PD.changed = 1;
374 PD.capacity = 0;
375 PD.drive = DU[D_SLV];
376 PD.present = 0;
377 j = 0;
378 while ((j < PD_NAMELEN-2) && (PD.name[j]=name[j])) j++;
379 PD.name[j++] = 'a' + unit;
380 PD.name[j] = 0;
381 PD.alt_geom = DU[D_GEO];
382 PD.standby = DU[D_SBY];
383 if (DU[D_PRT]) pd_drive_count++;
384 }
385 }
386
pd_init(void)387 int pd_init (void)
388
389 { int i;
390 request_queue_t * q;
391
392 if (disable) return -1;
393 if (devfs_register_blkdev(MAJOR_NR,name,&pd_fops)) {
394 printk("%s: unable to get major number %d\n",
395 name,major);
396 return -1;
397 }
398 q = BLK_DEFAULT_QUEUE(MAJOR_NR);
399 blk_init_queue(q, DEVICE_REQUEST);
400 read_ahead[MAJOR_NR] = 8; /* 8 sector (4kB) read ahead */
401
402 pd_gendisk.major = major;
403 pd_gendisk.major_name = name;
404 add_gendisk(&pd_gendisk);
405
406 for(i=0;i<PD_DEVS;i++) pd_blocksizes[i] = 1024;
407 blksize_size[MAJOR_NR] = pd_blocksizes;
408
409 for(i=0;i<PD_DEVS;i++) pd_maxsectors[i] = cluster;
410 max_sectors[MAJOR_NR] = pd_maxsectors;
411
412 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
413 name,name,PD_VERSION,major,cluster,nice);
414 pd_init_units();
415 pd_valid = 0;
416 pd_gendisk.nr_real = pd_detect();
417 pd_valid = 1;
418
419 #ifdef MODULE
420 if (!pd_gendisk.nr_real) {
421 cleanup_module();
422 return -1;
423 }
424 #endif
425 return 0;
426 }
427
pd_open(struct inode * inode,struct file * file)428 static int pd_open (struct inode *inode, struct file *file)
429
430 { int unit = DEVICE_NR(inode->i_rdev);
431
432 if ((unit >= PD_UNITS) || (!PD.present)) return -ENODEV;
433
434 wait_event (pd_wait_open, pd_valid);
435
436 PD.access++;
437
438 if (PD.removable) {
439 pd_media_check(unit);
440 pd_doorlock(unit,IDE_DOORLOCK);
441 }
442 return 0;
443 }
444
pd_ioctl(struct inode * inode,struct file * file,unsigned int cmd,unsigned long arg)445 static int pd_ioctl(struct inode *inode,struct file *file,
446 unsigned int cmd, unsigned long arg)
447
448 { struct hd_geometry *geo = (struct hd_geometry *) arg;
449 int dev, err, unit;
450
451 if ((!inode) || (!inode->i_rdev)) return -EINVAL;
452 dev = MINOR(inode->i_rdev);
453 unit = DEVICE_NR(inode->i_rdev);
454 if (dev >= PD_DEVS) return -EINVAL;
455 if (!PD.present) return -ENODEV;
456
457 switch (cmd) {
458 case CDROMEJECT:
459 if (PD.access == 1) pd_eject(unit);
460 return 0;
461 case HDIO_GETGEO:
462 if (!geo) return -EINVAL;
463 err = verify_area(VERIFY_WRITE,geo,sizeof(*geo));
464 if (err) return err;
465
466 if (PD.alt_geom) {
467 put_user(PD.capacity/(PD_LOG_HEADS*PD_LOG_SECTS),
468 (short *) &geo->cylinders);
469 put_user(PD_LOG_HEADS, (char *) &geo->heads);
470 put_user(PD_LOG_SECTS, (char *) &geo->sectors);
471 } else {
472 put_user(PD.cylinders, (short *) &geo->cylinders);
473 put_user(PD.heads, (char *) &geo->heads);
474 put_user(PD.sectors, (char *) &geo->sectors);
475 }
476 put_user(pd_hd[dev].start_sect,(long *)&geo->start);
477 return 0;
478 case BLKRRPART:
479 if (!capable(CAP_SYS_ADMIN))
480 return -EACCES;
481 return pd_revalidate(inode->i_rdev);
482 case BLKGETSIZE:
483 case BLKGETSIZE64:
484 case BLKROSET:
485 case BLKROGET:
486 case BLKRASET:
487 case BLKRAGET:
488 case BLKFLSBUF:
489 case BLKPG:
490 return blk_ioctl(inode->i_rdev, cmd, arg);
491 default:
492 return -EINVAL;
493 }
494 }
495
pd_release(struct inode * inode,struct file * file)496 static int pd_release (struct inode *inode, struct file *file)
497
498 { kdev_t devp;
499 int unit;
500
501 devp = inode->i_rdev;
502 unit = DEVICE_NR(devp);
503
504 if ((unit >= PD_UNITS) || (PD.access <= 0))
505 return -EINVAL;
506
507 PD.access--;
508
509 if (!PD.access && PD.removable)
510 pd_doorlock(unit,IDE_DOORUNLOCK);
511
512 return 0;
513 }
514
pd_check_media(kdev_t dev)515 static int pd_check_media( kdev_t dev)
516
517 { int r, unit;
518
519 unit = DEVICE_NR(dev);
520 if ((unit >= PD_UNITS) || (!PD.present)) return -ENODEV;
521 if (!PD.removable) return 0;
522 pd_media_check(unit);
523 r = PD.changed;
524 PD.changed = 0;
525 return r;
526 }
527
pd_revalidate(kdev_t dev)528 static int pd_revalidate(kdev_t dev)
529
530 { int p, unit, minor;
531 long flags;
532
533 unit = DEVICE_NR(dev);
534 if ((unit >= PD_UNITS) || (!PD.present)) return -ENODEV;
535
536 save_flags(flags);
537 cli();
538 if (PD.access > 1) {
539 restore_flags(flags);
540 return -EBUSY;
541 }
542 pd_valid = 0;
543 restore_flags(flags);
544
545 for (p=(PD_PARTNS-1);p>=0;p--) {
546 minor = p + unit*PD_PARTNS;
547 invalidate_device(MKDEV(MAJOR_NR, minor), 1);
548 pd_hd[minor].start_sect = 0;
549 pd_hd[minor].nr_sects = 0;
550 }
551
552 if (pd_identify(unit))
553 grok_partitions(&pd_gendisk,unit,1<<PD_BITS,PD.capacity);
554
555 pd_valid = 1;
556 wake_up(&pd_wait_open);
557
558 return 0;
559 }
560
561 #ifdef MODULE
562
563 /* Glue for modules ... */
564
565 void cleanup_module(void);
566
init_module(void)567 int init_module(void)
568
569 {
570
571 #ifdef PARIDE_JUMBO
572 { extern paride_init();
573 paride_init();
574 }
575 #endif
576 return pd_init();
577 }
578
cleanup_module(void)579 void cleanup_module(void)
580 {
581 int unit;
582
583 devfs_unregister_blkdev(MAJOR_NR,name);
584 del_gendisk(&pd_gendisk);
585
586 for (unit=0;unit<PD_UNITS;unit++)
587 if (PD.present) pi_release(PI);
588
589 max_sectors[MAJOR_NR] = NULL;
590 }
591
592 #endif
593
594 #define WR(c,r,v) pi_write_regr(PI,c,r,v)
595 #define RR(c,r) (pi_read_regr(PI,c,r))
596
597 #define DRIVE (0xa0+0x10*PD.drive)
598
599 /* ide command interface */
600
pd_print_error(int unit,char * msg,int status)601 static void pd_print_error( int unit, char * msg, int status )
602
603 { int i;
604
605 printk("%s: %s: status = 0x%x =",PD.name,msg,status);
606 for(i=0;i<18;i++) if (status & (1<<i)) printk(" %s",pd_errs[i]);
607 printk("\n");
608 }
609
pd_reset(int unit)610 static void pd_reset( int unit ) /* called only for MASTER drive */
611
612 { pi_connect(PI);
613 WR(1,6,4);
614 udelay(50);
615 WR(1,6,0);
616 pi_disconnect(PI);
617 udelay(250);
618 }
619
620 #define DBMSG(msg) ((verbose>1)?(msg):NULL)
621
pd_wait_for(int unit,int w,char * msg)622 static int pd_wait_for( int unit, int w, char * msg ) /* polled wait */
623
624 { int k, r, e;
625
626 k=0;
627 while(k < PD_SPIN) {
628 r = RR(1,6);
629 k++;
630 if (((r & w) == w) && !(r & STAT_BUSY)) break;
631 udelay(PD_SPIN_DEL);
632 }
633 e = (RR(0,1)<<8) + RR(0,7);
634 if (k >= PD_SPIN) e |= ERR_TMO;
635 if ((e & (STAT_ERR|ERR_TMO)) && (msg != NULL))
636 pd_print_error(unit,msg,e);
637 return e;
638 }
639
pd_send_command(int unit,int n,int s,int h,int c0,int c1,int func)640 static void pd_send_command( int unit, int n, int s, int h,
641 int c0, int c1, int func )
642
643 {
644 WR(0,6,DRIVE+h);
645 WR(0,1,0); /* the IDE task file */
646 WR(0,2,n);
647 WR(0,3,s);
648 WR(0,4,c0);
649 WR(0,5,c1);
650 WR(0,7,func);
651
652 udelay(1);
653 }
654
pd_ide_command(int unit,int func,int block,int count)655 static void pd_ide_command( int unit, int func, int block, int count )
656
657 /* Don't use this call if the capacity is zero. */
658
659 {
660 int c1, c0, h, s;
661 if (PD.can_lba) {
662 s = block & 255;
663 c0 = (block >>= 8) & 255;
664 c1 = (block >>= 8) & 255;
665 h = ((block >>= 8) & 15) + 0x40;
666 } else {
667 s = ( block % PD.sectors) + 1;
668 h = ( block /= PD.sectors) % PD.heads;
669 c0 = ( block /= PD.heads) % 256;
670 c1 = (block >>= 8);
671 }
672 pd_send_command(unit,count,s,h,c0,c1,func);
673 }
674
675 /* According to the ATA standard, the default CHS geometry should be
676 available following a reset. Some Western Digital drives come up
677 in a mode where only LBA addresses are accepted until the device
678 parameters are initialised.
679 */
680
pd_init_dev_parms(int unit)681 static void pd_init_dev_parms( int unit )
682
683 { pi_connect(PI);
684 pd_wait_for(unit,0,DBMSG("before init_dev_parms"));
685 pd_send_command(unit,PD.sectors,0,PD.heads-1,0,0,IDE_INIT_DEV_PARMS);
686 udelay(300);
687 pd_wait_for(unit,0,"Initialise device parameters");
688 pi_disconnect(PI);
689 }
690
pd_doorlock(int unit,int func)691 static void pd_doorlock( int unit, int func )
692
693 { pi_connect(PI);
694 if (pd_wait_for(unit,STAT_READY,"Lock") & STAT_ERR) {
695 pi_disconnect(PI);
696 return;
697 }
698 pd_send_command(unit,1,0,0,0,0,func);
699 pd_wait_for(unit,STAT_READY,"Lock done");
700 pi_disconnect(PI);
701 }
702
pd_eject(int unit)703 static void pd_eject( int unit )
704
705 { pi_connect(PI);
706 pd_wait_for(unit,0,DBMSG("before unlock on eject"));
707 pd_send_command(unit,1,0,0,0,0,IDE_DOORUNLOCK);
708 pd_wait_for(unit,0,DBMSG("after unlock on eject"));
709 pd_wait_for(unit,0,DBMSG("before eject"));
710 pd_send_command(unit,0,0,0,0,0,IDE_EJECT);
711 pd_wait_for(unit,0,DBMSG("after eject"));
712 pi_disconnect(PI);
713 }
714
pd_media_check(int unit)715 static void pd_media_check( int unit )
716
717 { int r;
718
719 pi_connect(PI);
720 r = pd_wait_for(unit,STAT_READY,DBMSG("before media_check"));
721 if (!(r & STAT_ERR)) {
722 pd_send_command(unit,1,1,0,0,0,IDE_READ_VRFY);
723 r = pd_wait_for(unit,STAT_READY,DBMSG("RDY after READ_VRFY"));
724 } else PD.changed = 1; /* say changed if other error */
725 if (r & ERR_MC) {
726 PD.changed = 1;
727 pd_send_command(unit,1,0,0,0,0,IDE_ACKCHANGE);
728 pd_wait_for(unit,STAT_READY,DBMSG("RDY after ACKCHANGE"));
729 pd_send_command(unit,1,1,0,0,0,IDE_READ_VRFY);
730 r = pd_wait_for(unit,STAT_READY,DBMSG("RDY after VRFY"));
731 }
732 pi_disconnect(PI);
733
734 }
735
pd_standby_off(int unit)736 static void pd_standby_off( int unit )
737
738 { pi_connect(PI);
739 pd_wait_for(unit,0,DBMSG("before STANDBY"));
740 pd_send_command(unit,0,0,0,0,0,IDE_STANDBY);
741 pd_wait_for(unit,0,DBMSG("after STANDBY"));
742 pi_disconnect(PI);
743 }
744
745 #define word_val(n) ((pd_scratch[2*n]&0xff)+256*(pd_scratch[2*n+1]&0xff))
746
pd_identify(int unit)747 static int pd_identify( int unit )
748
749 { int j;
750 char id[PD_ID_LEN+1];
751
752 /* WARNING: here there may be dragons. reset() applies to both drives,
753 but we call it only on probing the MASTER. This should allow most
754 common configurations to work, but be warned that a reset can clear
755 settings on the SLAVE drive.
756 */
757
758 if (PD.drive == 0) pd_reset(unit);
759
760 pi_connect(PI);
761 WR(0,6,DRIVE);
762 pd_wait_for(unit,0,DBMSG("before IDENT"));
763 pd_send_command(unit,1,0,0,0,0,IDE_IDENTIFY);
764
765 if (pd_wait_for(unit,STAT_DRQ,DBMSG("IDENT DRQ")) & STAT_ERR) {
766 pi_disconnect(PI);
767 return 0;
768 }
769 pi_read_block(PI,pd_scratch,512);
770 pi_disconnect(PI);
771 PD.can_lba = pd_scratch[99] & 2;
772 PD.sectors = le16_to_cpu(*(u16*)(pd_scratch+12));
773 PD.heads = le16_to_cpu(*(u16*)(pd_scratch+6));
774 PD.cylinders = le16_to_cpu(*(u16*)(pd_scratch+2));
775 if (PD.can_lba)
776 PD.capacity = le32_to_cpu(*(u32*)(pd_scratch + 120));
777 else
778 PD.capacity = PD.sectors*PD.heads*PD.cylinders;
779
780 for(j=0;j<PD_ID_LEN;j++) id[j^1] = pd_scratch[j+PD_ID_OFF];
781 j = PD_ID_LEN-1;
782 while ((j >= 0) && (id[j] <= 0x20)) j--;
783 j++; id[j] = 0;
784
785 PD.removable = (word_val(0) & 0x80);
786
787 printk("%s: %s, %s, %d blocks [%dM], (%d/%d/%d), %s media\n",
788 PD.name,id,
789 PD.drive?"slave":"master",
790 PD.capacity,PD.capacity/2048,
791 PD.cylinders,PD.heads,PD.sectors,
792 PD.removable?"removable":"fixed");
793
794 if (PD.capacity) pd_init_dev_parms(unit);
795 if (!PD.standby) pd_standby_off(unit);
796
797 return 1;
798 }
799
pd_probe_drive(int unit)800 static int pd_probe_drive( int unit )
801 {
802 if (PD.drive == -1) {
803 for (PD.drive=0;PD.drive<=1;PD.drive++)
804 if (pd_identify(unit))
805 return 1;
806 return 0;
807 }
808 return pd_identify(unit);
809 }
810
pd_detect(void)811 static int pd_detect( void )
812
813 { int k, unit;
814
815 k = 0;
816 if (pd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
817 unit = 0;
818 if (pi_init(PI,1,-1,-1,-1,-1,-1,pd_scratch,
819 PI_PD,verbose,PD.name)) {
820 if (pd_probe_drive(unit)) {
821 PD.present = 1;
822 k = 1;
823 } else pi_release(PI);
824 }
825
826 } else for (unit=0;unit<PD_UNITS;unit++) if (DU[D_PRT])
827 if (pi_init(PI,0,DU[D_PRT],DU[D_MOD],DU[D_UNI],
828 DU[D_PRO],DU[D_DLY],pd_scratch,
829 PI_PD,verbose,PD.name)) {
830 if (pd_probe_drive(unit)) {
831 PD.present = 1;
832 k = unit+1;
833 } else pi_release(PI);
834 }
835 for (unit=0;unit<PD_UNITS;unit++)
836 register_disk(&pd_gendisk,MKDEV(MAJOR_NR,unit<<PD_BITS),
837 PD_PARTNS,&pd_fops,
838 PD.present?PD.capacity:0);
839
840 /* We lie about the number of drives found, as the generic partition
841 scanner assumes that the drives are numbered sequentially from 0.
842 This can result in some bogus error messages if non-sequential
843 drive numbers are used.
844 */
845 if (k)
846 return k;
847 printk("%s: no valid drive found\n",name);
848 return 0;
849 }
850
851 /* The i/o request engine */
852
pd_ready(void)853 static int pd_ready( void )
854
855 { int unit = pd_unit;
856
857 return (!(RR(1,6) & STAT_BUSY)) ;
858 }
859
do_pd_request(request_queue_t * q)860 static void do_pd_request (request_queue_t * q)
861
862 { struct buffer_head * bh;
863 int unit;
864
865 if (pd_busy) return;
866 repeat:
867 if (QUEUE_EMPTY || (CURRENT->rq_status == RQ_INACTIVE)) return;
868 INIT_REQUEST;
869
870 pd_dev = MINOR(CURRENT->rq_dev);
871 pd_unit = unit = DEVICE_NR(CURRENT->rq_dev);
872 pd_block = CURRENT->sector;
873 pd_run = CURRENT->nr_sectors;
874 pd_count = CURRENT->current_nr_sectors;
875
876 bh = CURRENT->bh;
877
878 if ((pd_dev >= PD_DEVS) ||
879 ((pd_block+pd_count) > pd_hd[pd_dev].nr_sects)) {
880 end_request(0);
881 goto repeat;
882 }
883
884 pd_cmd = CURRENT->cmd;
885 pd_poffs = pd_hd[pd_dev].start_sect;
886 pd_block += pd_poffs;
887 pd_buf = CURRENT->buffer;
888 pd_retries = 0;
889
890 pd_busy = 1;
891 if (pd_cmd == READ) pi_do_claimed(PI,do_pd_read);
892 else if (pd_cmd == WRITE) pi_do_claimed(PI,do_pd_write);
893 else { pd_busy = 0;
894 end_request(0);
895 goto repeat;
896 }
897 }
898
pd_next_buf(int unit)899 static void pd_next_buf( int unit )
900
901 { unsigned long saved_flags;
902
903 spin_lock_irqsave(&io_request_lock,saved_flags);
904 end_request(1);
905 if (!pd_run) { spin_unlock_irqrestore(&io_request_lock,saved_flags);
906 return;
907 }
908
909 /* paranoia */
910
911 if (QUEUE_EMPTY ||
912 (CURRENT->cmd != pd_cmd) ||
913 (MINOR(CURRENT->rq_dev) != pd_dev) ||
914 (CURRENT->rq_status == RQ_INACTIVE) ||
915 (CURRENT->sector+pd_poffs != pd_block))
916 printk("%s: OUCH: request list changed unexpectedly\n",
917 PD.name);
918
919 pd_count = CURRENT->current_nr_sectors;
920 pd_buf = CURRENT->buffer;
921 spin_unlock_irqrestore(&io_request_lock,saved_flags);
922 }
923
do_pd_read(void)924 static void do_pd_read( void )
925
926 { ps_set_intr(do_pd_read_start,0,0,nice);
927 }
928
do_pd_read_start(void)929 static void do_pd_read_start( void )
930
931 { int unit = pd_unit;
932 unsigned long saved_flags;
933
934 pd_busy = 1;
935
936 pi_connect(PI);
937 if (pd_wait_for(unit,STAT_READY,"do_pd_read") & STAT_ERR) {
938 pi_disconnect(PI);
939 if (pd_retries < PD_MAX_RETRIES) {
940 pd_retries++;
941 pi_do_claimed(PI,do_pd_read_start);
942 return;
943 }
944 spin_lock_irqsave(&io_request_lock,saved_flags);
945 end_request(0);
946 pd_busy = 0;
947 do_pd_request(NULL);
948 spin_unlock_irqrestore(&io_request_lock,saved_flags);
949 return;
950 }
951 pd_ide_command(unit,IDE_READ,pd_block,pd_run);
952 ps_set_intr(do_pd_read_drq,pd_ready,PD_TMO,nice);
953 }
954
do_pd_read_drq(void)955 static void do_pd_read_drq( void )
956
957 { int unit = pd_unit;
958 unsigned long saved_flags;
959
960 while (1) {
961 if (pd_wait_for(unit,STAT_DRQ,"do_pd_read_drq") & STAT_ERR) {
962 pi_disconnect(PI);
963 if (pd_retries < PD_MAX_RETRIES) {
964 pd_retries++;
965 pi_do_claimed(PI,do_pd_read_start);
966 return;
967 }
968 spin_lock_irqsave(&io_request_lock,saved_flags);
969 end_request(0);
970 pd_busy = 0;
971 do_pd_request(NULL);
972 spin_unlock_irqrestore(&io_request_lock,saved_flags);
973 return;
974 }
975 pi_read_block(PI,pd_buf,512);
976 pd_count--; pd_run--;
977 pd_buf += 512;
978 pd_block++;
979 if (!pd_run) break;
980 if (!pd_count) pd_next_buf(unit);
981 }
982 pi_disconnect(PI);
983 spin_lock_irqsave(&io_request_lock,saved_flags);
984 end_request(1);
985 pd_busy = 0;
986 do_pd_request(NULL);
987 spin_unlock_irqrestore(&io_request_lock,saved_flags);
988 }
989
do_pd_write(void)990 static void do_pd_write( void )
991
992 { ps_set_intr(do_pd_write_start,0,0,nice);
993 }
994
do_pd_write_start(void)995 static void do_pd_write_start( void )
996
997 { int unit = pd_unit;
998 unsigned long saved_flags;
999
1000 pd_busy = 1;
1001
1002 pi_connect(PI);
1003 if (pd_wait_for(unit,STAT_READY,"do_pd_write") & STAT_ERR) {
1004 pi_disconnect(PI);
1005 if (pd_retries < PD_MAX_RETRIES) {
1006 pd_retries++;
1007 pi_do_claimed(PI,do_pd_write_start);
1008 return;
1009 }
1010 spin_lock_irqsave(&io_request_lock,saved_flags);
1011 end_request(0);
1012 pd_busy = 0;
1013 do_pd_request(NULL);
1014 spin_unlock_irqrestore(&io_request_lock,saved_flags);
1015 return;
1016 }
1017 pd_ide_command(unit,IDE_WRITE,pd_block,pd_run);
1018 while (1) {
1019 if (pd_wait_for(unit,STAT_DRQ,"do_pd_write_drq") & STAT_ERR) {
1020 pi_disconnect(PI);
1021 if (pd_retries < PD_MAX_RETRIES) {
1022 pd_retries++;
1023 pi_do_claimed(PI,do_pd_write_start);
1024 return;
1025 }
1026 spin_lock_irqsave(&io_request_lock,saved_flags);
1027 end_request(0);
1028 pd_busy = 0;
1029 do_pd_request(NULL);
1030 spin_unlock_irqrestore(&io_request_lock,saved_flags);
1031 return;
1032 }
1033 pi_write_block(PI,pd_buf,512);
1034 pd_count--; pd_run--;
1035 pd_buf += 512;
1036 pd_block++;
1037 if (!pd_run) break;
1038 if (!pd_count) pd_next_buf(unit);
1039 }
1040 ps_set_intr(do_pd_write_done,pd_ready,PD_TMO,nice);
1041 }
1042
do_pd_write_done(void)1043 static void do_pd_write_done( void )
1044
1045 { int unit = pd_unit;
1046 unsigned long saved_flags;
1047
1048 if (pd_wait_for(unit,STAT_READY,"do_pd_write_done") & STAT_ERR) {
1049 pi_disconnect(PI);
1050 if (pd_retries < PD_MAX_RETRIES) {
1051 pd_retries++;
1052 pi_do_claimed(PI,do_pd_write_start);
1053 return;
1054 }
1055 spin_lock_irqsave(&io_request_lock,saved_flags);
1056 end_request(0);
1057 pd_busy = 0;
1058 do_pd_request(NULL);
1059 spin_unlock_irqrestore(&io_request_lock,saved_flags);
1060 return;
1061 }
1062 pi_disconnect(PI);
1063 spin_lock_irqsave(&io_request_lock,saved_flags);
1064 end_request(1);
1065 pd_busy = 0;
1066 do_pd_request(NULL);
1067 spin_unlock_irqrestore(&io_request_lock,saved_flags);
1068 }
1069
1070 /* end of pd.c */
1071
1072 MODULE_LICENSE("GPL");
1073