drivers/block/paride/pd.c

   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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 853 static int pd_ready( void )
 854
 855 {       int unit = pd_unit;
 856
 857         return (!(RR(1,6) & STAT_BUSY)) ;
 858 }
 859
 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
 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
 924 static void do_pd_read( void )
 925
 926 {       ps_set_intr(do_pd_read_start,0,0,nice);
 927 }
 928
 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
 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
 990 static void do_pd_write( void )
 991
 992 {        ps_set_intr(do_pd_write_start,0,0,nice);
 993 }
 994
 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
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");