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 128static int verbose = 0; 129static int major = PD_MAJOR; 130static char *name = PD_NAME; 131static int cluster = 64; 132static int nice = 0; 133static int disable = 0; 134 135static int drive0[8] = { 0, 0, 0, -1, 0, 1, -1, -1 }; 136static int drive1[8] = { 0, 0, 0, -1, 0, 1, -1, -1 }; 137static int drive2[8] = { 0, 0, 0, -1, 0, 1, -1, -1 }; 138static int drive3[8] = { 0, 0, 0, -1, 0, 1, -1, -1 }; 139 140static int (*drives[4])[8] = {&drive0, &drive1, &drive2, &drive3}; 141 142enum {D_PRT, D_PRO, D_UNI, D_MOD, D_GEO, D_SBY, D_DLY, D_SLV}; 143 144/* end of parameters */ 145 146#include <linux/init.h> 147#include <linux/module.h> 148#include <linux/gfp.h> 149#include <linux/fs.h> 150#include <linux/delay.h> 151#include <linux/hdreg.h> 152#include <linux/cdrom.h> /* for the eject ioctl */ 153#include <linux/blkdev.h> 154#include <linux/blkpg.h> 155#include <linux/kernel.h> 156#include <linux/smp_lock.h> 157#include <asm/uaccess.h> 158#include <linux/workqueue.h> 159 160static DEFINE_SPINLOCK(pd_lock); 161 162module_param(verbose, bool, 0); 163module_param(major, int, 0); 164module_param(name, charp, 0); 165module_param(cluster, int, 0); 166module_param(nice, int, 0); 167module_param_array(drive0, int, NULL, 0); 168module_param_array(drive1, int, NULL, 0); 169module_param_array(drive2, int, NULL, 0); 170module_param_array(drive3, int, NULL, 0); 171 172#include "paride.h" 173 174#define PD_BITS 4 175 176/* numbers for "SCSI" geometry */ 177 178#define PD_LOG_HEADS 64 179#define PD_LOG_SECTS 32 180 181#define PD_ID_OFF 54 182#define PD_ID_LEN 14 183 184#define PD_MAX_RETRIES 5 185#define PD_TMO 800 /* interrupt timeout in jiffies */ 186#define PD_SPIN_DEL 50 /* spin delay in micro-seconds */ 187 188#define PD_SPIN (1000000*PD_TMO)/(HZ*PD_SPIN_DEL) 189 190#define STAT_ERR 0x00001 191#define STAT_INDEX 0x00002 192#define STAT_ECC 0x00004 193#define STAT_DRQ 0x00008 194#define STAT_SEEK 0x00010 195#define STAT_WRERR 0x00020 196#define STAT_READY 0x00040 197#define STAT_BUSY 0x00080 198 199#define ERR_AMNF 0x00100 200#define ERR_TK0NF 0x00200 201#define ERR_ABRT 0x00400 202#define ERR_MCR 0x00800 203#define ERR_IDNF 0x01000 204#define ERR_MC 0x02000 205#define ERR_UNC 0x04000 206#define ERR_TMO 0x10000 207 208#define IDE_READ 0x20 209#define IDE_WRITE 0x30 210#define IDE_READ_VRFY 0x40 211#define IDE_INIT_DEV_PARMS 0x91 212#define IDE_STANDBY 0x96 213#define IDE_ACKCHANGE 0xdb 214#define IDE_DOORLOCK 0xde 215#define IDE_DOORUNLOCK 0xdf 216#define IDE_IDENTIFY 0xec 217#define IDE_EJECT 0xed 218 219#define PD_NAMELEN 8 220 221struct pd_unit { 222 struct pi_adapter pia; /* interface to paride layer */ 223 struct pi_adapter *pi; 224 int access; /* count of active opens ... */ 225 int capacity; /* Size of this volume in sectors */ 226 int heads; /* physical geometry */ 227 int sectors; 228 int cylinders; 229 int can_lba; 230 int drive; /* master=0 slave=1 */ 231 int changed; /* Have we seen a disk change ? */ 232 int removable; /* removable media device ? */ 233 int standby; 234 int alt_geom; 235 char name[PD_NAMELEN]; /* pda, pdb, etc ... */ 236 struct gendisk *gd; 237}; 238 239static struct pd_unit pd[PD_UNITS]; 240 241static char pd_scratch[512]; /* scratch block buffer */ 242 243static char *pd_errs[17] = { "ERR", "INDEX", "ECC", "DRQ", "SEEK", "WRERR", 244 "READY", "BUSY", "AMNF", "TK0NF", "ABRT", "MCR", 245 "IDNF", "MC", "UNC", "???", "TMO" 246}; 247 248static inline int status_reg(struct pd_unit *disk) 249{ 250 return pi_read_regr(disk->pi, 1, 6); 251} 252 253static inline int read_reg(struct pd_unit *disk, int reg) 254{ 255 return pi_read_regr(disk->pi, 0, reg); 256} 257 258static inline void write_status(struct pd_unit *disk, int val) 259{ 260 pi_write_regr(disk->pi, 1, 6, val); 261} 262 263static inline void write_reg(struct pd_unit *disk, int reg, int val) 264{ 265 pi_write_regr(disk->pi, 0, reg, val); 266} 267 268static inline u8 DRIVE(struct pd_unit *disk) 269{ 270 return 0xa0+0x10*disk->drive; 271} 272 273/* ide command interface */ 274 275static void pd_print_error(struct pd_unit *disk, char *msg, int status) 276{ 277 int i; 278 279 printk("%s: %s: status = 0x%x =", disk->name, msg, status); 280 for (i = 0; i < ARRAY_SIZE(pd_errs); i++) 281 if (status & (1 << i)) 282 printk(" %s", pd_errs[i]); 283 printk("\n"); 284} 285 286static void pd_reset(struct pd_unit *disk) 287{ /* called only for MASTER drive */ 288 write_status(disk, 4); 289 udelay(50); 290 write_status(disk, 0); 291 udelay(250); 292} 293 294#define DBMSG(msg) ((verbose>1)?(msg):NULL) 295 296static int pd_wait_for(struct pd_unit *disk, int w, char *msg) 297{ /* polled wait */ 298 int k, r, e; 299 300 k = 0; 301 while (k < PD_SPIN) { 302 r = status_reg(disk); 303 k++; 304 if (((r & w) == w) && !(r & STAT_BUSY)) 305 break; 306 udelay(PD_SPIN_DEL); 307 } 308 e = (read_reg(disk, 1) << 8) + read_reg(disk, 7); 309 if (k >= PD_SPIN) 310 e |= ERR_TMO; 311 if ((e & (STAT_ERR | ERR_TMO)) && (msg != NULL)) 312 pd_print_error(disk, msg, e); 313 return e; 314} 315 316static void pd_send_command(struct pd_unit *disk, int n, int s, int h, int c0, int c1, int func) 317{ 318 write_reg(disk, 6, DRIVE(disk) + h); 319 write_reg(disk, 1, 0); /* the IDE task file */ 320 write_reg(disk, 2, n); 321 write_reg(disk, 3, s); 322 write_reg(disk, 4, c0); 323 write_reg(disk, 5, c1); 324 write_reg(disk, 7, func); 325 326 udelay(1); 327} 328 329static void pd_ide_command(struct pd_unit *disk, int func, int block, int count) 330{ 331 int c1, c0, h, s; 332 333 if (disk->can_lba) { 334 s = block & 255; 335 c0 = (block >>= 8) & 255; 336 c1 = (block >>= 8) & 255; 337 h = ((block >>= 8) & 15) + 0x40; 338 } else { 339 s = (block % disk->sectors) + 1; 340 h = (block /= disk->sectors) % disk->heads; 341 c0 = (block /= disk->heads) % 256; 342 c1 = (block >>= 8); 343 } 344 pd_send_command(disk, count, s, h, c0, c1, func); 345} 346 347/* The i/o request engine */ 348 349enum action {Fail = 0, Ok = 1, Hold, Wait}; 350 351static struct request *pd_req; /* current request */ 352static enum action (*phase)(void); 353 354static void run_fsm(void); 355 356static void ps_tq_int(struct work_struct *work); 357 358static DECLARE_DELAYED_WORK(fsm_tq, ps_tq_int); 359 360static void schedule_fsm(void) 361{ 362 if (!nice) 363 schedule_delayed_work(&fsm_tq, 0); 364 else 365 schedule_delayed_work(&fsm_tq, nice-1); 366} 367 368static void ps_tq_int(struct work_struct *work) 369{ 370 run_fsm(); 371} 372 373static enum action do_pd_io_start(void); 374static enum action pd_special(void); 375static enum action do_pd_read_start(void); 376static enum action do_pd_write_start(void); 377static enum action do_pd_read_drq(void); 378static enum action do_pd_write_done(void); 379 380static struct request_queue *pd_queue; 381static int pd_claimed; 382 383static struct pd_unit *pd_current; /* current request's drive */ 384static PIA *pi_current; /* current request's PIA */ 385 386static void run_fsm(void) 387{ 388 while (1) { 389 enum action res; 390 unsigned long saved_flags; 391 int stop = 0; 392 393 if (!phase) { 394 pd_current = pd_req->rq_disk->private_data; 395 pi_current = pd_current->pi; 396 phase = do_pd_io_start; 397 } 398 399 switch (pd_claimed) { 400 case 0: 401 pd_claimed = 1; 402 if (!pi_schedule_claimed(pi_current, run_fsm)) 403 return; 404 case 1: 405 pd_claimed = 2; 406 pi_current->proto->connect(pi_current); 407 } 408 409 switch(res = phase()) { 410 case Ok: case Fail: 411 pi_disconnect(pi_current); 412 pd_claimed = 0; 413 phase = NULL; 414 spin_lock_irqsave(&pd_lock, saved_flags); 415 if (!__blk_end_request_cur(pd_req, 416 res == Ok ? 0 : -EIO)) { 417 pd_req = blk_fetch_request(pd_queue); 418 if (!pd_req) 419 stop = 1; 420 } 421 spin_unlock_irqrestore(&pd_lock, saved_flags); 422 if (stop) 423 return; 424 case Hold: 425 schedule_fsm(); 426 return; 427 case Wait: 428 pi_disconnect(pi_current); 429 pd_claimed = 0; 430 } 431 } 432} 433 434static int pd_retries = 0; /* i/o error retry count */ 435static int pd_block; /* address of next requested block */ 436static int pd_count; /* number of blocks still to do */ 437static int pd_run; /* sectors in current cluster */ 438static int pd_cmd; /* current command READ/WRITE */ 439static char *pd_buf; /* buffer for request in progress */ 440 441static enum action do_pd_io_start(void) 442{ 443 if (pd_req->cmd_type == REQ_TYPE_SPECIAL) { 444 phase = pd_special; 445 return pd_special(); 446 } 447 448 pd_cmd = rq_data_dir(pd_req); 449 if (pd_cmd == READ || pd_cmd == WRITE) { 450 pd_block = blk_rq_pos(pd_req); 451 pd_count = blk_rq_cur_sectors(pd_req); 452 if (pd_block + pd_count > get_capacity(pd_req->rq_disk)) 453 return Fail; 454 pd_run = blk_rq_sectors(pd_req); 455 pd_buf = pd_req->buffer; 456 pd_retries = 0; 457 if (pd_cmd == READ) 458 return do_pd_read_start(); 459 else 460 return do_pd_write_start(); 461 } 462 return Fail; 463} 464 465static enum action pd_special(void) 466{ 467 enum action (*func)(struct pd_unit *) = pd_req->special; 468 return func(pd_current); 469} 470 471static int pd_next_buf(void) 472{ 473 unsigned long saved_flags; 474 475 pd_count--; 476 pd_run--; 477 pd_buf += 512; 478 pd_block++; 479 if (!pd_run) 480 return 1; 481 if (pd_count) 482 return 0; 483 spin_lock_irqsave(&pd_lock, saved_flags); 484 __blk_end_request_cur(pd_req, 0); 485 pd_count = blk_rq_cur_sectors(pd_req); 486 pd_buf = pd_req->buffer; 487 spin_unlock_irqrestore(&pd_lock, saved_flags); 488 return 0; 489} 490 491static unsigned long pd_timeout; 492 493static enum action do_pd_read_start(void) 494{ 495 if (pd_wait_for(pd_current, STAT_READY, "do_pd_read") & STAT_ERR) { 496 if (pd_retries < PD_MAX_RETRIES) { 497 pd_retries++; 498 return Wait; 499 } 500 return Fail; 501 } 502 pd_ide_command(pd_current, IDE_READ, pd_block, pd_run); 503 phase = do_pd_read_drq; 504 pd_timeout = jiffies + PD_TMO; 505 return Hold; 506} 507 508static enum action do_pd_write_start(void) 509{ 510 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write") & STAT_ERR) { 511 if (pd_retries < PD_MAX_RETRIES) { 512 pd_retries++; 513 return Wait; 514 } 515 return Fail; 516 } 517 pd_ide_command(pd_current, IDE_WRITE, pd_block, pd_run); 518 while (1) { 519 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_write_drq") & STAT_ERR) { 520 if (pd_retries < PD_MAX_RETRIES) { 521 pd_retries++; 522 return Wait; 523 } 524 return Fail; 525 } 526 pi_write_block(pd_current->pi, pd_buf, 512); 527 if (pd_next_buf()) 528 break; 529 } 530 phase = do_pd_write_done; 531 pd_timeout = jiffies + PD_TMO; 532 return Hold; 533} 534 535static inline int pd_ready(void) 536{ 537 return !(status_reg(pd_current) & STAT_BUSY); 538} 539 540static enum action do_pd_read_drq(void) 541{ 542 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout)) 543 return Hold; 544 545 while (1) { 546 if (pd_wait_for(pd_current, STAT_DRQ, "do_pd_read_drq") & STAT_ERR) { 547 if (pd_retries < PD_MAX_RETRIES) { 548 pd_retries++; 549 phase = do_pd_read_start; 550 return Wait; 551 } 552 return Fail; 553 } 554 pi_read_block(pd_current->pi, pd_buf, 512); 555 if (pd_next_buf()) 556 break; 557 } 558 return Ok; 559} 560 561static enum action do_pd_write_done(void) 562{ 563 if (!pd_ready() && !time_after_eq(jiffies, pd_timeout)) 564 return Hold; 565 566 if (pd_wait_for(pd_current, STAT_READY, "do_pd_write_done") & STAT_ERR) { 567 if (pd_retries < PD_MAX_RETRIES) { 568 pd_retries++; 569 phase = do_pd_write_start; 570 return Wait; 571 } 572 return Fail; 573 } 574 return Ok; 575} 576 577/* special io requests */ 578 579/* According to the ATA standard, the default CHS geometry should be 580 available following a reset. Some Western Digital drives come up 581 in a mode where only LBA addresses are accepted until the device 582 parameters are initialised. 583*/ 584 585static void pd_init_dev_parms(struct pd_unit *disk) 586{ 587 pd_wait_for(disk, 0, DBMSG("before init_dev_parms")); 588 pd_send_command(disk, disk->sectors, 0, disk->heads - 1, 0, 0, 589 IDE_INIT_DEV_PARMS); 590 udelay(300); 591 pd_wait_for(disk, 0, "Initialise device parameters"); 592} 593 594static enum action pd_door_lock(struct pd_unit *disk) 595{ 596 if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) { 597 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORLOCK); 598 pd_wait_for(disk, STAT_READY, "Lock done"); 599 } 600 return Ok; 601} 602 603static enum action pd_door_unlock(struct pd_unit *disk) 604{ 605 if (!(pd_wait_for(disk, STAT_READY, "Lock") & STAT_ERR)) { 606 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK); 607 pd_wait_for(disk, STAT_READY, "Lock done"); 608 } 609 return Ok; 610} 611 612static enum action pd_eject(struct pd_unit *disk) 613{ 614 pd_wait_for(disk, 0, DBMSG("before unlock on eject")); 615 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_DOORUNLOCK); 616 pd_wait_for(disk, 0, DBMSG("after unlock on eject")); 617 pd_wait_for(disk, 0, DBMSG("before eject")); 618 pd_send_command(disk, 0, 0, 0, 0, 0, IDE_EJECT); 619 pd_wait_for(disk, 0, DBMSG("after eject")); 620 return Ok; 621} 622 623static enum action pd_media_check(struct pd_unit *disk) 624{ 625 int r = pd_wait_for(disk, STAT_READY, DBMSG("before media_check")); 626 if (!(r & STAT_ERR)) { 627 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY); 628 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after READ_VRFY")); 629 } else 630 disk->changed = 1; /* say changed if other error */ 631 if (r & ERR_MC) { 632 disk->changed = 1; 633 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_ACKCHANGE); 634 pd_wait_for(disk, STAT_READY, DBMSG("RDY after ACKCHANGE")); 635 pd_send_command(disk, 1, 1, 0, 0, 0, IDE_READ_VRFY); 636 r = pd_wait_for(disk, STAT_READY, DBMSG("RDY after VRFY")); 637 } 638 return Ok; 639} 640 641static void pd_standby_off(struct pd_unit *disk) 642{ 643 pd_wait_for(disk, 0, DBMSG("before STANDBY")); 644 pd_send_command(disk, 0, 0, 0, 0, 0, IDE_STANDBY); 645 pd_wait_for(disk, 0, DBMSG("after STANDBY")); 646} 647 648static enum action pd_identify(struct pd_unit *disk) 649{ 650 int j; 651 char id[PD_ID_LEN + 1]; 652 653/* WARNING: here there may be dragons. reset() applies to both drives, 654 but we call it only on probing the MASTER. This should allow most 655 common configurations to work, but be warned that a reset can clear 656 settings on the SLAVE drive. 657*/ 658 659 if (disk->drive == 0) 660 pd_reset(disk); 661 662 write_reg(disk, 6, DRIVE(disk)); 663 pd_wait_for(disk, 0, DBMSG("before IDENT")); 664 pd_send_command(disk, 1, 0, 0, 0, 0, IDE_IDENTIFY); 665 666 if (pd_wait_for(disk, STAT_DRQ, DBMSG("IDENT DRQ")) & STAT_ERR) 667 return Fail; 668 pi_read_block(disk->pi, pd_scratch, 512); 669 disk->can_lba = pd_scratch[99] & 2; 670 disk->sectors = le16_to_cpu(*(__le16 *) (pd_scratch + 12)); 671 disk->heads = le16_to_cpu(*(__le16 *) (pd_scratch + 6)); 672 disk->cylinders = le16_to_cpu(*(__le16 *) (pd_scratch + 2)); 673 if (disk->can_lba) 674 disk->capacity = le32_to_cpu(*(__le32 *) (pd_scratch + 120)); 675 else 676 disk->capacity = disk->sectors * disk->heads * disk->cylinders; 677 678 for (j = 0; j < PD_ID_LEN; j++) 679 id[j ^ 1] = pd_scratch[j + PD_ID_OFF]; 680 j = PD_ID_LEN - 1; 681 while ((j >= 0) && (id[j] <= 0x20)) 682 j--; 683 j++; 684 id[j] = 0; 685 686 disk->removable = pd_scratch[0] & 0x80; 687 688 printk("%s: %s, %s, %d blocks [%dM], (%d/%d/%d), %s media\n", 689 disk->name, id, 690 disk->drive ? "slave" : "master", 691 disk->capacity, disk->capacity / 2048, 692 disk->cylinders, disk->heads, disk->sectors, 693 disk->removable ? "removable" : "fixed"); 694 695 if (disk->capacity) 696 pd_init_dev_parms(disk); 697 if (!disk->standby) 698 pd_standby_off(disk); 699 700 return Ok; 701} 702 703/* end of io request engine */ 704 705static void do_pd_request(struct request_queue * q) 706{ 707 if (pd_req) 708 return; 709 pd_req = blk_fetch_request(q); 710 if (!pd_req) 711 return; 712 713 schedule_fsm(); 714} 715 716static int pd_special_command(struct pd_unit *disk, 717 enum action (*func)(struct pd_unit *disk)) 718{ 719 struct request *rq; 720 int err = 0; 721 722 rq = blk_get_request(disk->gd->queue, READ, __GFP_WAIT); 723 724 rq->cmd_type = REQ_TYPE_SPECIAL; 725 rq->special = func; 726 727 err = blk_execute_rq(disk->gd->queue, disk->gd, rq, 0); 728 729 blk_put_request(rq); 730 return err; 731} 732 733/* kernel glue structures */ 734 735static int pd_open(struct block_device *bdev, fmode_t mode) 736{ 737 struct pd_unit *disk = bdev->bd_disk->private_data; 738 739 lock_kernel(); 740 disk->access++; 741 742 if (disk->removable) { 743 pd_special_command(disk, pd_media_check); 744 pd_special_command(disk, pd_door_lock); 745 } 746 unlock_kernel(); 747 return 0; 748} 749 750static int pd_getgeo(struct block_device *bdev, struct hd_geometry *geo) 751{ 752 struct pd_unit *disk = bdev->bd_disk->private_data; 753 754 if (disk->alt_geom) { 755 geo->heads = PD_LOG_HEADS; 756 geo->sectors = PD_LOG_SECTS; 757 geo->cylinders = disk->capacity / (geo->heads * geo->sectors); 758 } else { 759 geo->heads = disk->heads; 760 geo->sectors = disk->sectors; 761 geo->cylinders = disk->cylinders; 762 } 763 764 return 0; 765} 766 767static int pd_ioctl(struct block_device *bdev, fmode_t mode, 768 unsigned int cmd, unsigned long arg) 769{ 770 struct pd_unit *disk = bdev->bd_disk->private_data; 771 772 switch (cmd) { 773 case CDROMEJECT: 774 lock_kernel(); 775 if (disk->access == 1) 776 pd_special_command(disk, pd_eject); 777 unlock_kernel(); 778 return 0; 779 default: 780 return -EINVAL; 781 } 782} 783 784static int pd_release(struct gendisk *p, fmode_t mode) 785{ 786 struct pd_unit *disk = p->private_data; 787 788 lock_kernel(); 789 if (!--disk->access && disk->removable) 790 pd_special_command(disk, pd_door_unlock); 791 unlock_kernel(); 792 793 return 0; 794} 795 796static int pd_check_media(struct gendisk *p) 797{ 798 struct pd_unit *disk = p->private_data; 799 int r; 800 if (!disk->removable) 801 return 0; 802 pd_special_command(disk, pd_media_check); 803 r = disk->changed; 804 disk->changed = 0; 805 return r; 806} 807 808static int pd_revalidate(struct gendisk *p) 809{ 810 struct pd_unit *disk = p->private_data; 811 if (pd_special_command(disk, pd_identify) == 0) 812 set_capacity(p, disk->capacity); 813 else 814 set_capacity(p, 0); 815 return 0; 816} 817 818static const struct block_device_operations pd_fops = { 819 .owner = THIS_MODULE, 820 .open = pd_open, 821 .release = pd_release, 822 .ioctl = pd_ioctl, 823 .getgeo = pd_getgeo, 824 .media_changed = pd_check_media, 825 .revalidate_disk= pd_revalidate 826}; 827 828/* probing */ 829 830static void pd_probe_drive(struct pd_unit *disk) 831{ 832 struct gendisk *p = alloc_disk(1 << PD_BITS); 833 if (!p) 834 return; 835 strcpy(p->disk_name, disk->name); 836 p->fops = &pd_fops; 837 p->major = major; 838 p->first_minor = (disk - pd) << PD_BITS; 839 disk->gd = p; 840 p->private_data = disk; 841 p->queue = pd_queue; 842 843 if (disk->drive == -1) { 844 for (disk->drive = 0; disk->drive <= 1; disk->drive++) 845 if (pd_special_command(disk, pd_identify) == 0) 846 return; 847 } else if (pd_special_command(disk, pd_identify) == 0) 848 return; 849 disk->gd = NULL; 850 put_disk(p); 851} 852 853static int pd_detect(void) 854{ 855 int found = 0, unit, pd_drive_count = 0; 856 struct pd_unit *disk; 857 858 for (unit = 0; unit < PD_UNITS; unit++) { 859 int *parm = *drives[unit]; 860 struct pd_unit *disk = pd + unit; 861 disk->pi = &disk->pia; 862 disk->access = 0; 863 disk->changed = 1; 864 disk->capacity = 0; 865 disk->drive = parm[D_SLV]; 866 snprintf(disk->name, PD_NAMELEN, "%s%c", name, 'a'+unit); 867 disk->alt_geom = parm[D_GEO]; 868 disk->standby = parm[D_SBY]; 869 if (parm[D_PRT]) 870 pd_drive_count++; 871 } 872 873 if (pd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */ 874 disk = pd; 875 if (pi_init(disk->pi, 1, -1, -1, -1, -1, -1, pd_scratch, 876 PI_PD, verbose, disk->name)) { 877 pd_probe_drive(disk); 878 if (!disk->gd) 879 pi_release(disk->pi); 880 } 881 882 } else { 883 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) { 884 int *parm = *drives[unit]; 885 if (!parm[D_PRT]) 886 continue; 887 if (pi_init(disk->pi, 0, parm[D_PRT], parm[D_MOD], 888 parm[D_UNI], parm[D_PRO], parm[D_DLY], 889 pd_scratch, PI_PD, verbose, disk->name)) { 890 pd_probe_drive(disk); 891 if (!disk->gd) 892 pi_release(disk->pi); 893 } 894 } 895 } 896 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) { 897 if (disk->gd) { 898 set_capacity(disk->gd, disk->capacity); 899 add_disk(disk->gd); 900 found = 1; 901 } 902 } 903 if (!found) 904 printk("%s: no valid drive found\n", name); 905 return found; 906} 907 908static int __init pd_init(void) 909{ 910 if (disable) 911 goto out1; 912 913 pd_queue = blk_init_queue(do_pd_request, &pd_lock); 914 if (!pd_queue) 915 goto out1; 916 917 blk_queue_max_hw_sectors(pd_queue, cluster); 918 919 if (register_blkdev(major, name)) 920 goto out2; 921 922 printk("%s: %s version %s, major %d, cluster %d, nice %d\n", 923 name, name, PD_VERSION, major, cluster, nice); 924 if (!pd_detect()) 925 goto out3; 926 927 return 0; 928 929out3: 930 unregister_blkdev(major, name); 931out2: 932 blk_cleanup_queue(pd_queue); 933out1: 934 return -ENODEV; 935} 936 937static void __exit pd_exit(void) 938{ 939 struct pd_unit *disk; 940 int unit; 941 unregister_blkdev(major, name); 942 for (unit = 0, disk = pd; unit < PD_UNITS; unit++, disk++) { 943 struct gendisk *p = disk->gd; 944 if (p) { 945 disk->gd = NULL; 946 del_gendisk(p); 947 put_disk(p); 948 pi_release(disk->pi); 949 } 950 } 951 blk_cleanup_queue(pd_queue); 952} 953 954MODULE_LICENSE("GPL"); 955module_init(pd_init) 956module_exit(pd_exit) 957