drivers/block/paride/pf.c

Name: Public Git Hosting - davej-history.git/blob - drivers/block/paride/pf.c
Rating: 4.7 (9340 reviews)
 1 /*
 2  pf.c (c) 1997-8 Grant R. Guenther <grant@torque.net>
 3  Under the terms of the GNU public license.
 4
 5  This is the high-level driver for parallel port ATAPI disk
 6  drives based on chips supported by the paride module.
 7
 8  By default, the driver will autoprobe for a single parallel
 9  port ATAPI disk drive, but if their individual parameters are
 10  specified, the driver can handle up to 4 drives.
 11
 12  The behaviour of the pf 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-7 integers as follows:
 18  drive2
 19  drive3 <prt>,<pro>,<uni>,<mod>,<slv>,<lun>,<dly>
 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  <slv> ATAPI CDroms can be jumpered to master or slave.
 42  Set this to 0 to choose the master drive, 1 to
 43  choose the slave, -1 (the default) to choose the
 44  first drive found.
 45
 46  <lun> Some ATAPI devices support multiple LUNs.
 47  One example is the ATAPI PD/CD drive from
 48  Matshita/Panasonic. This device has a
 49  CD drive on LUN 0 and a PD drive on LUN 1.
 50  By default, the driver will search for the
 51  first LUN with a supported device. Set
 52  this parameter to force it to use a specific
 53  LUN. (default -1)
 54
 55  <dly> some parallel ports require the driver to
 56  go more slowly. -1 sets a default value that
 57  should work with the chosen protocol. Otherwise,
 58  set this to a small integer, the larger it is
 59  the slower the port i/o. In some cases, setting
 60  this to zero will speed up the device. (default -1)
 61
 62  major You may use this parameter to overide the
 63  default major number (47) that this driver
 64  will use. Be sure to change the device
 65  name as well.
 66
 67  name This parameter is a character string that
 68  contains the name the kernel will use for this
 69  device (in /proc output, for instance).
 70  (default "pf").
 71
 72  cluster The driver will attempt to aggregate requests
 73  for adjacent blocks into larger multi-block
 74  clusters. The maximum cluster size (in 512
 75  byte sectors) is set with this parameter.
 76  (default 64)
 77
 78  verbose This parameter controls the amount of logging
 79  that the driver will do. Set it to 0 for
 80  normal operation, 1 to see autoprobe progress
 81  messages, or 2 to see additional debugging
 82  output. (default 0)
 83
 84  nice This parameter controls the driver's use of
 85  idle CPU time, at the expense of some speed.
 86
 87  If this driver is built into the kernel, you can use the
 88  following command line parameters, with the same values
 89  as the corresponding module parameters listed above:
 90
 91  pf.drive0
 92  pf.drive1
 93  pf.drive2
 94  pf.drive3
 95  pf.cluster
 96  pf.nice
 97
 98  In addition, you can use the parameter pf.disable to disable
 99  the driver entirely.
 100
 101 */
 102
 103 /* Changes:
 104
 105  1.01 GRG 1998.05.03 Changes for SMP. Eliminate sti().
 106  Fix for drives that don't clear STAT_ERR
 107  until after next CDB delivered.
 108  Small change in pf_completion to round
 109  up transfer size.
 110  1.02 GRG 1998.06.16 Eliminated an Ugh
 111  1.03 GRG 1998.08.16 Use HZ in loop timings, extra debugging
 112  1.04 GRG 1998.09.24 Added jumbo support
 113
 114 */
 115
 116 #define PF_VERSION"1.04"
 117 #define PF_MAJOR 47
 118 #define PF_NAME"pf"
 119 #define PF_UNITS 4
 120
 121 /* Here are things one can override from the insmod command.
 122  Most are autoprobed by paride unless set here. Verbose is off
 123  by default.
 124
 125 */
 126
 127 static int verbose =0;
 128 static int major = PF_MAJOR;
 129 static char*name = PF_NAME;
 130 static int cluster =64;
 131 static int nice =0;
 132 static int disable =0;
 133
 134 static int drive0[7] = {0,0,0,-1,-1,-1,-1};
 135 static int drive1[7] = {0,0,0,-1,-1,-1,-1};
 136 static int drive2[7] = {0,0,0,-1,-1,-1,-1};
 137 static int drive3[7] = {0,0,0,-1,-1,-1,-1};
 138
 139 static int(*drives[4])[7] = {&drive0,&drive1,&drive2,&drive3};
 140 static int pf_drive_count;
 141
 142 #define D_PRT 0
 143 #define D_PRO 1
 144 #define D_UNI 2
 145 #define D_MOD 3
 146 #define D_SLV 4
 147 #define D_LUN 5
 148 #define D_DLY 6
 149
 150 #define DU (*drives[unit])
 151
 152 /* end of parameters */
 153
 154
 155 #include <linux/module.h>
 156 #include <linux/errno.h>
 157 #include <linux/fs.h>
 158 #include <linux/kernel.h>
 159 #include <linux/delay.h>
 160 #include <linux/genhd.h>
 161 #include <linux/hdreg.h>
 162 #include <linux/cdrom.h>
 163 #include <linux/spinlock.h>
 164
 165 #include <asm/uaccess.h>
 166
 167 #ifndef MODULE
 168
 169 #include"setup.h"
 170
 171 static STT pf_stt[7] = {{"drive0",7,drive0},
 172 {"drive1",7,drive1},
 173 {"drive2",7,drive2},
 174 {"drive3",7,drive3},
 175 {"disable",1,&disable},
 176 {"cluster",1,&cluster},
 177 {"nice",1,&nice}};
 178
 179 voidpf_setup(char*str,int*ints)
 180
 181 {generic_setup(pf_stt,7,str);
 182 }
 183
 184 #endif
 185
 186 MODULE_PARM(verbose,"i");
 187 MODULE_PARM(major,"i");
 188 MODULE_PARM(name,"s");
 189 MODULE_PARM(cluster,"i");
 190 MODULE_PARM(nice,"i");
 191 MODULE_PARM(drive0,"1-7i");
 192 MODULE_PARM(drive1,"1-7i");
 193 MODULE_PARM(drive2,"1-7i");
 194 MODULE_PARM(drive3,"1-7i");
 195
 196 #include"paride.h"
 197
 198 /* set up defines for blk.h, why don't all drivers do it this way ? */
 199
 200 #define MAJOR_NR major
 201 #define DEVICE_NAME"PF"
 202 #define DEVICE_REQUEST do_pf_request
 203 #define DEVICE_NR(device) MINOR(device)
 204 #define DEVICE_ON(device)
 205 #define DEVICE_OFF(device)
 206
 207 #include <linux/blk.h>
 208 #include <linux/blkpg.h>
 209
 210 #include"pseudo.h"
 211
 212 /* constants for faking geometry numbers */
 213
 214 #define PF_FD_MAX 8192/* use FD geometry under this size */
 215 #define PF_FD_HDS 2
 216 #define PF_FD_SPT 18
 217 #define PF_HD_HDS 64
 218 #define PF_HD_SPT 32
 219
 220 #define PF_MAX_RETRIES 5
 221 #define PF_TMO 800/* interrupt timeout in jiffies */
 222 #define PF_SPIN_DEL 50/* spin delay in micro-seconds */
 223
 224 #define PF_SPIN (1000000*PF_TMO)/(HZ*PF_SPIN_DEL)
 225
 226 #define STAT_ERR 0x00001
 227 #define STAT_INDEX 0x00002
 228 #define STAT_ECC 0x00004
 229 #define STAT_DRQ 0x00008
 230 #define STAT_SEEK 0x00010
 231 #define STAT_WRERR 0x00020
 232 #define STAT_READY 0x00040
 233 #define STAT_BUSY 0x00080
 234
 235 #define ATAPI_REQ_SENSE 0x03
 236 #define ATAPI_LOCK 0x1e
 237 #define ATAPI_DOOR 0x1b
 238 #define ATAPI_MODE_SENSE 0x5a
 239 #define ATAPI_CAPACITY 0x25
 240 #define ATAPI_IDENTIFY 0x12
 241 #define ATAPI_READ_10 0x28
 242 #define ATAPI_WRITE_10 0x2a
 243
 244 intpf_init(void);
 245 #ifdef MODULE
 246 voidcleanup_module(void);
 247 #endif
 248 static intpf_open(struct inode *inode,struct file *file);
 249 static voiddo_pf_request(void);
 250 static intpf_ioctl(struct inode *inode,struct file *file,
 251 unsigned int cmd,unsigned long arg);
 252
 253 static intpf_release(struct inode *inode,struct file *file);
 254
 255 static intpf_detect(void);
 256 static voiddo_pf_read(void);
 257 static voiddo_pf_read_start(void);
 258 static voiddo_pf_write(void);
 259 static voiddo_pf_write_start(void);
 260 static voiddo_pf_read_drq(void);
 261 static voiddo_pf_write_done(void);
 262
 263 static intpf_identify(int unit);
 264 static voidpf_lock(int unit,int func);
 265 static voidpf_eject(int unit);
 266 static intpf_check_media(kdev_t dev);
 267
 268 static int pf_blocksizes[PF_UNITS];
 269
 270 #define PF_NM 0
 271 #define PF_RO 1
 272 #define PF_RW 2
 273
 274 #define PF_NAMELEN 8
 275
 276 struct pf_unit {
 277 struct pi_adapter pia;/* interface to paride layer */
 278 struct pi_adapter *pi;
 279 int removable;/* removable media device ? */
 280 int media_status;/* media present ? WP ? */
 281 int drive;/* drive */
 282 int lun;
 283 int access;/* count of active opens ... */
 284 int capacity;/* Size of this volume in sectors */
 285 int present;/* device present ? */
 286 char name[PF_NAMELEN];/* pf0, pf1, ... */
 287 };
 288
 289 struct pf_unit pf[PF_UNITS];
 290
 291 /* 'unit' must be defined in all functions - either as a local or a param */
 292
 293 #define PF pf[unit]
 294 #define PI PF.pi
 295
 296 static char pf_scratch[512];/* scratch block buffer */
 297
 298 /* the variables below are used mainly in the I/O request engine, which
 299  processes only one request at a time.
 300 */
 301
 302 static int pf_retries =0;/* i/o error retry count */
 303 static int pf_busy =0;/* request being processed ? */
 304 static int pf_block;/* address of next requested block */
 305 static int pf_count;/* number of blocks still to do */
 306 static int pf_run;/* sectors in current cluster */
 307 static int pf_cmd;/* current command READ/WRITE */
 308 static int pf_unit;/* unit of current request */
 309 static int pf_mask;/* stopper for pseudo-int */
 310 static char* pf_buf;/* buffer for request in progress */
 311
 312 /* kernel glue structures */
 313
 314 static struct file_operations pf_fops = {
 315  NULL,/* lseek - default */
 316  block_read,/* read - general block-dev read */
 317  block_write,/* write - general block-dev write */
 318  NULL,/* readdir - bad */
 319  NULL,/* select */
 320  pf_ioctl,/* ioctl */
 321  NULL,/* mmap */
 322  pf_open,/* open */
 323  NULL,/* flush */
 324  pf_release,/* release */
 325  block_fsync,/* fsync */
 326  NULL,/* fasync */
 327  pf_check_media,/* media change ? */
 328  NULL /* revalidate new media */
 329 };
 330
 331 voidpf_init_units(void)
 332
 333 {int unit, j;
 334
 335  pf_drive_count =0;
 336 for(unit=0;unit<PF_UNITS;unit++) {
 337  PF.pi = & PF.pia;
 338  PF.access =0;
 339  PF.media_status = PF_NM;
 340  PF.capacity =0;
 341  PF.present =0;
 342  PF.drive = DU[D_SLV];
 343  PF.lun = DU[D_LUN];
 344  j =0;
 345 while((j < PF_NAMELEN-2) && (PF.name[j]=name[j])) j++;
 346  PF.name[j++] ='0'+ unit;
 347  PF.name[j] =0;
 348 if(DU[D_PRT]) pf_drive_count++;
 349 }
 350 }
 351
 352 intpf_init(void)/* preliminary initialisation */
 353
 354 {int i;
 355
 356 if(disable)return-1;
 357
 358 pf_init_units();
 359
 360 if(pf_detect())return-1;
 361  pf_busy =0;
 362
 363 if(register_blkdev(MAJOR_NR,name,&pf_fops)) {
 364 printk("pf_init: unable to get major number %d\n",
 365  major);
 366 return-1;
 367 }
 368  blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
 369  read_ahead[MAJOR_NR] =8;/* 8 sector (4kB) read ahead */
 370
 371 for(i=0;i<PF_UNITS;i++) pf_blocksizes[i] =1024;
 372  blksize_size[MAJOR_NR] = pf_blocksizes;
 373
 374 return0;
 375 }
 376
 377 static intpf_open(struct inode *inode,struct file *file)
 378
 379 {int unit =DEVICE_NR(inode->i_rdev);
 380
 381 if((unit >= PF_UNITS) || (!PF.present))return-ENODEV;
 382
 383  MOD_INC_USE_COUNT;
 384
 385 pf_identify(unit);
 386
 387 if(PF.media_status == PF_NM) {
 388  MOD_DEC_USE_COUNT;
 389 return-ENODEV;
 390 }
 391
 392 if((PF.media_status == PF_RO) && (file ->f_mode &2)) {
 393  MOD_DEC_USE_COUNT;
 394 return-EROFS;
 395 }
 396
 397  PF.access++;
 398 if(PF.removable)pf_lock(unit,1);
 399
 400 return0;
 401 }
 402
 403 static intpf_ioctl(struct inode *inode,struct file *file,
 404 unsigned int cmd,unsigned long arg)
 405
 406 {int err, unit;
 407 struct hd_geometry *geo = (struct hd_geometry *) arg;
 408
 409 if((!inode) || (!inode->i_rdev))return-EINVAL;
 410  unit =DEVICE_NR(inode->i_rdev);
 411 if(unit >= PF_UNITS)return-EINVAL;
 412 if(!PF.present)return-ENODEV;
 413
 414 switch(cmd) {
 415 case CDROMEJECT:
 416 if(PF.access ==1) {
 417 pf_eject(unit);
 418 return0;
 419 }
 420 case HDIO_GETGEO:
 421 if(!geo)return-EINVAL;
 422  err =verify_area(VERIFY_WRITE,geo,sizeof(*geo));
 423 if(err)return err;
 424 if(PF.capacity < PF_FD_MAX) {
 425 put_user(PF.capacity/(PF_FD_HDS*PF_FD_SPT),
 426 (short*) &geo->cylinders);
 427 put_user(PF_FD_HDS, (char*) &geo->heads);
 428 put_user(PF_FD_SPT, (char*) &geo->sectors);
 429 }else{
 430 put_user(PF.capacity/(PF_HD_HDS*PF_HD_SPT),
 431 (short*) &geo->cylinders);
 432 put_user(PF_HD_HDS, (char*) &geo->heads);
 433 put_user(PF_HD_SPT, (char*) &geo->sectors);
 434 }
 435 put_user(0,(long*)&geo->start);
 436 return0;
 437 case BLKGETSIZE:
 438 if(!arg)return-EINVAL;
 439  err =verify_area(VERIFY_WRITE,(long*) arg,sizeof(long));
 440 if(err)return(err);
 441 put_user(PF.capacity,(long*) arg);
 442 return(0);
 443 case BLKROSET:
 444 case BLKROGET:
 445 case BLKRASET:
 446 case BLKRAGET:
 447 case BLKFLSBUF:
 448 returnblk_ioctl(inode->i_rdev, cmd, arg);
 449 default:
 450 return-EINVAL;
 451 }
 452 }
 453
 454
 455 static intpf_release(struct inode *inode,struct file *file)
 456
 457 { kdev_t devp;
 458 int unit;
 459
 460 struct super_block *sb;
 461
 462  devp = inode->i_rdev;
 463  unit =DEVICE_NR(devp);
 464
 465 if((unit >= PF_UNITS) || (PF.access <=0))
 466 return-EINVAL;
 467
 468  PF.access--;
 469
 470 if(!PF.access) {
 471 fsync_dev(devp);
 472
 473  sb =get_super(devp);
 474 if(sb)invalidate_inodes(sb);
 475
 476 invalidate_buffers(devp);
 477 if(PF.removable)pf_lock(unit,0);
 478 }
 479
 480  MOD_DEC_USE_COUNT;
 481
 482 return0;
 483
 484 }
 485
 486 static intpf_check_media( kdev_t dev)
 487
 488 {return1;
 489 }
 490
 491 #ifdef MODULE
 492
 493 /* Glue for modules ... */
 494
 495 voidcleanup_module(void);
 496
 497 intinit_module(void)
 498
 499 {int err;
 500
 501 #ifdef PARIDE_JUMBO
 502 {externparide_init();
 503 paride_init();
 504 }
 505 #endif
 506
 507  err =pf_init();
 508
 509 return err;
 510 }
 511
 512 voidcleanup_module(void)
 513
 514 {int unit;
 515
 516 unregister_blkdev(MAJOR_NR,name);
 517
 518 for(unit=0;unit<PF_UNITS;unit++)
 519 if(PF.present)pi_release(PI);
 520 }
 521
 522 #endif
 523
 524 #define WR(c,r,v) pi_write_regr(PI,c,r,v)
 525 #define RR(c,r) (pi_read_regr(PI,c,r))
 526
 527 #define LUN (0x20*PF.lun)
 528 #define DRIVE (0xa0+0x10*PF.drive)
 529
 530 static intpf_wait(int unit,int go,int stop,char* fun,char* msg )
 531
 532 {int j, r, e, s, p;
 533
 534  j =0;
 535 while((((r=RR(1,6))&go)||(stop&&(!(r&stop))))&&(j++<PF_SPIN))
 536 udelay(PF_SPIN_DEL);
 537
 538 if((r&(STAT_ERR&stop))||(j>=PF_SPIN)) {
 539  s =RR(0,7);
 540  e =RR(0,1);
 541  p =RR(0,2);
 542 if(j >= PF_SPIN) e |=0x100;
 543 if(fun)printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
 544 " loop=%d phase=%d\n",
 545  PF.name,fun,msg,r,s,e,j,p);
 546 return(e<<8)+s;
 547 }
 548 return0;
 549 }
 550
 551 static intpf_command(int unit,char* cmd,int dlen,char* fun )
 552
 553 {pi_connect(PI);
 554
 555 WR(0,6,DRIVE);
 556
 557 if(pf_wait(unit,STAT_BUSY|STAT_DRQ,0,fun,"before command")) {
 558 pi_disconnect(PI);
 559 return-1;
 560 }
 561
 562 WR(0,4,dlen %256);
 563 WR(0,5,dlen /256);
 564 WR(0,7,0xa0);/* ATAPI packet command */
 565
 566 if(pf_wait(unit,STAT_BUSY,STAT_DRQ,fun,"command DRQ")) {
 567 pi_disconnect(PI);
 568 return-1;
 569 }
 570
 571 if(RR(0,2) !=1) {
 572 printk("%s: %s: command phase error\n",PF.name,fun);
 573 pi_disconnect(PI);
 574 return-1;
 575 }
 576
 577 pi_write_block(PI,cmd,12);
 578
 579 return0;
 580 }
 581
 582 static intpf_completion(int unit,char* buf,char* fun )
 583
 584 {int r, s, n;
 585
 586  r =pf_wait(unit,STAT_BUSY,STAT_DRQ|STAT_READY|STAT_ERR,
 587  fun,"completion");
 588
 589 if((RR(0,2)&2) && (RR(0,7)&STAT_DRQ)) {
 590  n = (((RR(0,4)+256*RR(0,5))+3)&0xfffc);
 591 pi_read_block(PI,buf,n);
 592 }
 593
 594  s =pf_wait(unit,STAT_BUSY,STAT_READY|STAT_ERR,fun,"data done");
 595
 596 pi_disconnect(PI);
 597
 598 return(r?r:s);
 599 }
 600
 601 static voidpf_req_sense(int unit,int quiet )
 602
 603 {char rs_cmd[12] = { ATAPI_REQ_SENSE,LUN,0,0,16,0,0,0,0,0,0,0};
 604 char buf[16];
 605 int r;
 606
 607  r =pf_command(unit,rs_cmd,16,"Request sense");
 608 mdelay(1);
 609 if(!r)pf_completion(unit,buf,"Request sense");
 610
 611 if((!r)&&(!quiet))
 612 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
 613  PF.name,buf[2]&0xf,buf[12],buf[13]);
 614 }
 615
 616 static intpf_atapi(int unit,char* cmd,int dlen,char* buf,char* fun )
 617
 618 {int r;
 619
 620  r =pf_command(unit,cmd,dlen,fun);
 621 mdelay(1);
 622 if(!r) r =pf_completion(unit,buf,fun);
 623 if(r)pf_req_sense(unit,!fun);
 624
 625 return r;
 626 }
 627
 628 #define DBMSG(msg) ((verbose>1)?(msg):NULL)
 629
 630 static voidpf_lock(int unit,int func)
 631
 632 {char lo_cmd[12] = { ATAPI_LOCK,LUN,0,0,func,0,0,0,0,0,0,0};
 633
 634 pf_atapi(unit,lo_cmd,0,pf_scratch,func?"unlock":"lock");
 635 }
 636
 637
 638 static voidpf_eject(int unit )
 639
 640 {char ej_cmd[12] = { ATAPI_DOOR,LUN,0,0,2,0,0,0,0,0,0,0};
 641
 642 pf_lock(unit,0);
 643 pf_atapi(unit,ej_cmd,0,pf_scratch,"eject");
 644 }
 645
 646 #define PF_RESET_TMO 30/* in tenths of a second */
 647
 648 static voidpf_sleep(int cs )
 649
 650 { current->state = TASK_INTERRUPTIBLE;
 651 schedule_timeout(cs);
 652 }
 653
 654
 655 static intpf_reset(int unit )
 656
 657 /* the ATAPI standard actually specifies the contents of all 7 registers
 658  after a reset, but the specification is ambiguous concerning the last
 659  two bytes, and different drives interpret the standard differently.
 660 */
 661
 662 {int i, k, flg;
 663 int expect[5] = {1,1,1,0x14,0xeb};
 664
 665 pi_connect(PI);
 666 WR(0,6,DRIVE);
 667 WR(0,7,8);
 668
 669 pf_sleep(2);
 670
 671  k =0;
 672 while((k++ < PF_RESET_TMO) && (RR(1,6)&STAT_BUSY))
 673 pf_sleep(10);
 674
 675  flg =1;
 676 for(i=0;i<5;i++) flg &= (RR(0,i+1) == expect[i]);
 677
 678 if(verbose) {
 679 printk("%s: Reset (%d) signature = ",PF.name,k);
 680 for(i=0;i<5;i++)printk("%3x",RR(0,i+1));
 681 if(!flg)printk(" (incorrect)");
 682 printk("\n");
 683 }
 684
 685 pi_disconnect(PI);
 686 return flg-1;
 687 }
 688
 689 static voidpf_mode_sense(int unit )
 690
 691 {char ms_cmd[12] = { ATAPI_MODE_SENSE,LUN,0,0,0,0,0,0,8,0,0,0};
 692 char buf[8];
 693
 694 pf_atapi(unit,ms_cmd,8,buf,DBMSG("mode sense"));
 695  PF.media_status = PF_RW;
 696 if(buf[3] &0x80) PF.media_status = PF_RO;
 697 }
 698
 699 static voidxs(char*buf,char*targ,int offs,int len )
 700
 701 {int j,k,l;
 702
 703  j=0; l=0;
 704 for(k=0;k<len;k++)
 705 if((buf[k+offs]!=0x20)||(buf[k+offs]!=l))
 706  l=targ[j++]=buf[k+offs];
 707 if(l==0x20) j--; targ[j]=0;
 708 }
 709
 710 static intxl(char*buf,int offs )
 711
 712 {int v,k;
 713
 714  v=0;
 715 for(k=0;k<4;k++) v=v*256+(buf[k+offs]&0xff);
 716 return v;
 717 }
 718
 719 static voidpf_get_capacity(int unit )
 720
 721 {char rc_cmd[12] = { ATAPI_CAPACITY,LUN,0,0,0,0,0,0,0,0,0,0};
 722 char buf[8];
 723 int bs;
 724
 725 if(pf_atapi(unit,rc_cmd,8,buf,DBMSG("get capacity"))) {
 726  PF.media_status = PF_NM;
 727 return;
 728 }
 729  PF.capacity =xl(buf,0) +1;
 730  bs =xl(buf,4);
 731 if(bs !=512) {
 732  PF.capacity =0;
 733 if(verbose)printk("%s: Drive %d, LUN %d,"
 734 " unsupported block size %d\n",
 735  PF.name,PF.drive,PF.lun,bs);
 736 }
 737 }
 738
 739 static intpf_identify(int unit )
 740
 741 {int dt, s;
 742 char*ms[2] = {"master","slave"};
 743 char mf[10], id[18];
 744 char id_cmd[12] = { ATAPI_IDENTIFY,LUN,0,0,36,0,0,0,0,0,0,0};
 745 char buf[36];
 746
 747  s =pf_atapi(unit,id_cmd,36,buf,"identify");
 748 if(s)return-1;
 749
 750  dt = buf[0] &0x1f;
 751 if((dt !=0) && (dt !=7)) {
 752 if(verbose)
 753 printk("%s: Drive %d, LUN %d, unsupported type %d\n",
 754  PF.name,PF.drive,PF.lun,dt);
 755 return-1;
 756 }
 757
 758 xs(buf,mf,8,8);
 759 xs(buf,id,16,16);
 760
 761  PF.removable = (buf[1] &0x80);
 762
 763 pf_mode_sense(unit);
 764 pf_mode_sense(unit);
 765 pf_mode_sense(unit);
 766
 767 pf_get_capacity(unit);
 768
 769 printk("%s: %s %s, %s LUN %d, type %d",
 770  PF.name,mf,id,ms[PF.drive],PF.lun,dt);
 771 if(PF.removable)printk(", removable");
 772 if(PF.media_status == PF_NM)
 773 printk(", no media\n");
 774 else{if(PF.media_status == PF_RO)printk(", RO");
 775 printk(", %d blocks\n",PF.capacity);
 776 }
 777
 778 return0;
 779 }
 780
 781 static intpf_probe(int unit )
 782
 783 /* returns 0, with id set if drive is detected
 784  -1, if drive detection failed
 785 */
 786
 787 {if(PF.drive == -1) {
 788 for(PF.drive=0;PF.drive<=1;PF.drive++)
 789 if(!pf_reset(unit)) {
 790 if(PF.lun != -1)returnpf_identify(unit);
 791 else for(PF.lun=0;PF.lun<8;PF.lun++)
 792 if(!pf_identify(unit))return0;
 793 }
 794 }else{
 795 if(pf_reset(unit))return-1;
 796 if(PF.lun != -1)returnpf_identify(unit);
 797 for(PF.lun=0;PF.lun<8;PF.lun++)
 798 if(!pf_identify(unit))return0;
 799 }
 800 return-1;
 801 }
 802
 803 static intpf_detect(void)
 804
 805 {int k, unit;
 806
 807 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
 808  name,name,PF_VERSION,major,cluster,nice);
 809
 810  k =0;
 811 if(pf_drive_count ==0) {
 812  unit =0;
 813 if(pi_init(PI,1,-1,-1,-1,-1,-1,pf_scratch,
 814  PI_PF,verbose,PF.name)) {
 815 if(!pf_probe(unit)) {
 816  PF.present =1;
 817  k++;
 818 }elsepi_release(PI);
 819 }
 820
 821 }else for(unit=0;unit<PF_UNITS;unit++)if(DU[D_PRT])
 822 if(pi_init(PI,0,DU[D_PRT],DU[D_MOD],DU[D_UNI],
 823  DU[D_PRO],DU[D_DLY],pf_scratch,PI_PF,verbose,
 824  PF.name)) {
 825 if(!pf_probe(unit)) {
 826  PF.present =1;
 827  k++;
 828 }elsepi_release(PI);
 829 }
 830
 831 if(k)return0;
 832
 833 printk("%s: No ATAPI disk detected\n",name);
 834 return-1;
 835 }
 836
 837 /* The i/o request engine */
 838
 839 static intpf_start(int unit,int cmd,int b,int c )
 840
 841 {int i;
 842 char io_cmd[12] = {cmd,LUN,0,0,0,0,0,0,0,0,0,0};
 843
 844 for(i=0;i<4;i++) {
 845  io_cmd[5-i] = b &0xff;
 846  b = b >>8;
 847 }
 848
 849  io_cmd[8] = c &0xff;
 850  io_cmd[7] = (c >>8) &0xff;
 851
 852  i =pf_command(unit,io_cmd,c*512,"start i/o");
 853
 854 mdelay(1);
 855
 856 return i;
 857 }
 858
 859 static intpf_ready(void)
 860
 861 {int unit = pf_unit;
 862
 863 return(((RR(1,6)&(STAT_BUSY|pf_mask)) == pf_mask));
 864 }
 865
 866 static voiddo_pf_request(void)
 867
 868 {struct buffer_head * bh;
 869 struct request * req;
 870 int unit;
 871
 872 if(pf_busy)return;
 873 repeat:
 874 if((!CURRENT) || (CURRENT->rq_status == RQ_INACTIVE))return;
 875  INIT_REQUEST;
 876
 877  pf_unit = unit =DEVICE_NR(CURRENT->rq_dev);
 878  pf_block = CURRENT->sector;
 879  pf_count = CURRENT->nr_sectors;
 880
 881  bh = CURRENT->bh;
 882  req = CURRENT;
 883 if(bh->b_reqnext)
 884 printk("%s: OUCH: b_reqnext != NULL\n",PF.name);
 885
 886 if((pf_unit >= PF_UNITS) || (pf_block+pf_count > PF.capacity)) {
 887 end_request(0);
 888 goto repeat;
 889 }
 890
 891  pf_cmd = CURRENT->cmd;
 892  pf_run = pf_count;
 893 while((pf_run <= cluster) &&
 894 (req = req->next) &&
 895 (pf_block+pf_run == req->sector) &&
 896 (pf_cmd == req->cmd) &&
 897 (pf_unit ==DEVICE_NR(req->rq_dev)))
 898  pf_run += req->nr_sectors;
 899
 900  pf_buf = CURRENT->buffer;
 901  pf_retries =0;
 902
 903  pf_busy =1;
 904 if(pf_cmd == READ)pi_do_claimed(PI,do_pf_read);
 905 else if(pf_cmd == WRITE)pi_do_claimed(PI,do_pf_write);
 906 else{ pf_busy =0;
 907 end_request(0);
 908 goto repeat;
 909 }
 910 }
 911
 912 static voidpf_next_buf(int unit )
 913
 914 {long saved_flags;
 915
 916 spin_lock_irqsave(&io_request_lock,saved_flags);
 917 end_request(1);
 918 if(!pf_run) {spin_unlock_irqrestore(&io_request_lock,saved_flags);
 919 return;
 920 }
 921
 922 /* paranoia */
 923
 924 if((!CURRENT) ||
 925 (CURRENT->cmd != pf_cmd) ||
 926 (DEVICE_NR(CURRENT->rq_dev) != pf_unit) ||
 927 (CURRENT->rq_status == RQ_INACTIVE) ||
 928 (CURRENT->sector != pf_block))
 929 printk("%s: OUCH: request list changed unexpectedly\n",
 930  PF.name);
 931
 932  pf_count = CURRENT->nr_sectors;
 933  pf_buf = CURRENT->buffer;
 934 spin_unlock_irqrestore(&io_request_lock,saved_flags);
 935 }
 936
 937 static voiddo_pf_read(void)
 938
 939 /* detach from the calling context - in case the spinlock is held */
 940
 941 {ps_set_intr(do_pf_read_start,0,0,nice);
 942 }
 943
 944 static voiddo_pf_read_start(void)
 945
 946 {int unit = pf_unit;
 947 long saved_flags;
 948
 949  pf_busy =1;
 950
 951 if(pf_start(unit,ATAPI_READ_10,pf_block,pf_run)) {
 952 pi_disconnect(PI);
 953 if(pf_retries < PF_MAX_RETRIES) {
 954  pf_retries++;
 955 pi_do_claimed(PI,do_pf_read_start);
 956 return;
 957 }
 958 spin_lock_irqsave(&io_request_lock,saved_flags);
 959 end_request(0);
 960  pf_busy =0;
 961 do_pf_request();
 962 spin_unlock_irqrestore(&io_request_lock,saved_flags);
 963 return;
 964 }
 965  pf_mask = STAT_DRQ;
 966 ps_set_intr(do_pf_read_drq,pf_ready,PF_TMO,nice);
 967 }
 968
 969 static voiddo_pf_read_drq(void)
 970
 971 {int unit = pf_unit;
 972 long saved_flags;
 973
 974 while(1) {
 975 if(pf_wait(unit,STAT_BUSY,STAT_DRQ|STAT_ERR,
 976 "read block","completion") & STAT_ERR) {
 977 pi_disconnect(PI);
 978 if(pf_retries < PF_MAX_RETRIES) {
 979 pf_req_sense(unit,0);
 980  pf_retries++;
 981 pi_do_claimed(PI,do_pf_read_start);
 982 return;
 983 }
 984 spin_lock_irqsave(&io_request_lock,saved_flags);
 985 end_request(0);
 986  pf_busy =0;
 987 do_pf_request();
 988 spin_unlock_irqrestore(&io_request_lock,saved_flags);
 989 return;
 990 }
 991 pi_read_block(PI,pf_buf,512);
 992  pf_count--; pf_run--;
 993  pf_buf +=512;
 994  pf_block++;
 995 if(!pf_run)break;
 996 if(!pf_count)pf_next_buf(unit);
 997 }
 998 pi_disconnect(PI);
 999 spin_lock_irqsave(&io_request_lock,saved_flags);
1000 end_request(1);
1001  pf_busy =0;
1002 do_pf_request();
1003 spin_unlock_irqrestore(&io_request_lock,saved_flags);
1004 }
1005
1006 static voiddo_pf_write(void)
1007
1008 {ps_set_intr(do_pf_write_start,0,0,nice);
1009 }
1010
1011 static voiddo_pf_write_start(void)
1012
1013 {int unit = pf_unit;
1014 long saved_flags;
1015
1016  pf_busy =1;
1017
1018 if(pf_start(unit,ATAPI_WRITE_10,pf_block,pf_run)) {
1019 pi_disconnect(PI);
1020 if(pf_retries < PF_MAX_RETRIES) {
1021  pf_retries++;
1022 pi_do_claimed(PI,do_pf_write_start);
1023 return;
1024 }
1025 spin_lock_irqsave(&io_request_lock,saved_flags);
1026 end_request(0);
1027  pf_busy =0;
1028 do_pf_request();
1029 spin_unlock_irqrestore(&io_request_lock,saved_flags);
1030 return;
1031 }
1032
1033 while(1) {
1034 if(pf_wait(unit,STAT_BUSY,STAT_DRQ|STAT_ERR,
1035 "write block","data wait") & STAT_ERR) {
1036 pi_disconnect(PI);
1037 if(pf_retries < PF_MAX_RETRIES) {
1038  pf_retries++;
1039 pi_do_claimed(PI,do_pf_write_start);
1040 return;
1041 }
1042 spin_lock_irqsave(&io_request_lock,saved_flags);
1043 end_request(0);
1044  pf_busy =0;
1045 do_pf_request();
1046 spin_unlock_irqrestore(&io_request_lock,saved_flags);
1047 return;
1048 }
1049 pi_write_block(PI,pf_buf,512);
1050  pf_count--; pf_run--;
1051  pf_buf +=512;
1052  pf_block++;
1053 if(!pf_run)break;
1054 if(!pf_count)pf_next_buf(unit);
1055 }
1056  pf_mask =0;
1057 ps_set_intr(do_pf_write_done,pf_ready,PF_TMO,nice);
1058 }
1059
1060 static voiddo_pf_write_done(void)
1061
1062 {int unit = pf_unit;
1063 long saved_flags;
1064
1065 if(pf_wait(unit,STAT_BUSY,0,"write block","done") & STAT_ERR) {
1066 pi_disconnect(PI);
1067 if(pf_retries < PF_MAX_RETRIES) {
1068  pf_retries++;
1069 pi_do_claimed(PI,do_pf_write_start);
1070 return;
1071 }
1072 spin_lock_irqsave(&io_request_lock,saved_flags);
1073 end_request(0);
1074  pf_busy =0;
1075 do_pf_request();
1076 spin_unlock_irqrestore(&io_request_lock,saved_flags);
1077 return;
1078 }
1079 pi_disconnect(PI);
1080 spin_lock_irqsave(&io_request_lock,saved_flags);
1081 end_request(1);
1082  pf_busy =0;
1083 do_pf_request();
1084 spin_unlock_irqrestore(&io_request_lock,saved_flags);
1085 }
1086
1087 /* end of pf.c */
1088