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