ide-floppy.c revision dd2e9a032bc552f6e2ae852e81cde602c09d7d3e
1/* 2 * IDE ATAPI floppy driver. 3 * 4 * Copyright (C) 1996-1999 Gadi Oxman <gadio@netvision.net.il> 5 * Copyright (C) 2000-2002 Paul Bristow <paul@paulbristow.net> 6 * Copyright (C) 2005 Bartlomiej Zolnierkiewicz 7 * 8 * This driver supports the following IDE floppy drives: 9 * 10 * LS-120/240 SuperDisk 11 * Iomega Zip 100/250 12 * Iomega PC Card Clik!/PocketZip 13 * 14 * For a historical changelog see 15 * Documentation/ide/ChangeLog.ide-floppy.1996-2002 16 */ 17 18#define IDEFLOPPY_VERSION "1.00" 19 20#include <linux/module.h> 21#include <linux/types.h> 22#include <linux/string.h> 23#include <linux/kernel.h> 24#include <linux/delay.h> 25#include <linux/timer.h> 26#include <linux/mm.h> 27#include <linux/interrupt.h> 28#include <linux/major.h> 29#include <linux/errno.h> 30#include <linux/genhd.h> 31#include <linux/slab.h> 32#include <linux/cdrom.h> 33#include <linux/ide.h> 34#include <linux/bitops.h> 35#include <linux/mutex.h> 36 37#include <scsi/scsi_ioctl.h> 38 39#include <asm/byteorder.h> 40#include <linux/irq.h> 41#include <linux/uaccess.h> 42#include <linux/io.h> 43#include <asm/unaligned.h> 44 45/* define to see debug info */ 46#define IDEFLOPPY_DEBUG_LOG 0 47 48/* #define IDEFLOPPY_DEBUG(fmt, args...) printk(KERN_INFO fmt, ## args) */ 49#define IDEFLOPPY_DEBUG(fmt, args...) 50 51#if IDEFLOPPY_DEBUG_LOG 52#define debug_log(fmt, args...) \ 53 printk(KERN_INFO "ide-floppy: " fmt, ## args) 54#else 55#define debug_log(fmt, args...) do {} while (0) 56#endif 57 58 59/* Some drives require a longer irq timeout. */ 60#define IDEFLOPPY_WAIT_CMD (5 * WAIT_CMD) 61 62/* 63 * After each failed packet command we issue a request sense command and retry 64 * the packet command IDEFLOPPY_MAX_PC_RETRIES times. 65 */ 66#define IDEFLOPPY_MAX_PC_RETRIES 3 67 68/* 69 * With each packet command, we allocate a buffer of IDEFLOPPY_PC_BUFFER_SIZE 70 * bytes. 71 */ 72#define IDEFLOPPY_PC_BUFFER_SIZE 256 73 74/* 75 * In various places in the driver, we need to allocate storage for packet 76 * commands and requests, which will remain valid while we leave the driver to 77 * wait for an interrupt or a timeout event. 78 */ 79#define IDEFLOPPY_PC_STACK (10 + IDEFLOPPY_MAX_PC_RETRIES) 80 81/* format capacities descriptor codes */ 82#define CAPACITY_INVALID 0x00 83#define CAPACITY_UNFORMATTED 0x01 84#define CAPACITY_CURRENT 0x02 85#define CAPACITY_NO_CARTRIDGE 0x03 86 87/* 88 * Most of our global data which we need to save even as we leave the driver 89 * due to an interrupt or a timer event is stored in a variable of type 90 * idefloppy_floppy_t, defined below. 91 */ 92typedef struct ide_floppy_obj { 93 ide_drive_t *drive; 94 ide_driver_t *driver; 95 struct gendisk *disk; 96 struct kref kref; 97 unsigned int openers; /* protected by BKL for now */ 98 99 /* Current packet command */ 100 struct ide_atapi_pc *pc; 101 /* Last failed packet command */ 102 struct ide_atapi_pc *failed_pc; 103 /* Packet command stack */ 104 struct ide_atapi_pc pc_stack[IDEFLOPPY_PC_STACK]; 105 /* Next free packet command storage space */ 106 int pc_stack_index; 107 struct request rq_stack[IDEFLOPPY_PC_STACK]; 108 /* We implement a circular array */ 109 int rq_stack_index; 110 111 /* Last error information */ 112 u8 sense_key, asc, ascq; 113 /* delay this long before sending packet command */ 114 u8 ticks; 115 int progress_indication; 116 117 /* Device information */ 118 /* Current format */ 119 int blocks, block_size, bs_factor; 120 /* Last format capacity descriptor */ 121 u8 cap_desc[8]; 122 /* Copy of the flexible disk page */ 123 u8 flexible_disk_page[32]; 124 /* Write protect */ 125 int wp; 126 /* Supports format progress report */ 127 int srfp; 128 /* Status/Action flags */ 129 unsigned long flags; 130} idefloppy_floppy_t; 131 132#define IDEFLOPPY_TICKS_DELAY HZ/20 /* default delay for ZIP 100 (50ms) */ 133 134/* Floppy flag bits values. */ 135enum { 136 /* DRQ interrupt device */ 137 IDEFLOPPY_FLAG_DRQ_INTERRUPT = (1 << 0), 138 /* Media may have changed */ 139 IDEFLOPPY_FLAG_MEDIA_CHANGED = (1 << 1), 140 /* Format in progress */ 141 IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS = (1 << 2), 142 /* Avoid commands not supported in Clik drive */ 143 IDEFLOPPY_FLAG_CLIK_DRIVE = (1 << 3), 144 /* Requires BH algorithm for packets */ 145 IDEFLOPPY_FLAG_ZIP_DRIVE = (1 << 4), 146}; 147 148/* Defines for the MODE SENSE command */ 149#define MODE_SENSE_CURRENT 0x00 150#define MODE_SENSE_CHANGEABLE 0x01 151#define MODE_SENSE_DEFAULT 0x02 152#define MODE_SENSE_SAVED 0x03 153 154/* IOCTLs used in low-level formatting. */ 155#define IDEFLOPPY_IOCTL_FORMAT_SUPPORTED 0x4600 156#define IDEFLOPPY_IOCTL_FORMAT_GET_CAPACITY 0x4601 157#define IDEFLOPPY_IOCTL_FORMAT_START 0x4602 158#define IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS 0x4603 159 160/* Error code returned in rq->errors to the higher part of the driver. */ 161#define IDEFLOPPY_ERROR_GENERAL 101 162 163/* 164 * Pages of the SELECT SENSE / MODE SENSE packet commands. 165 * See SFF-8070i spec. 166 */ 167#define IDEFLOPPY_CAPABILITIES_PAGE 0x1b 168#define IDEFLOPPY_FLEXIBLE_DISK_PAGE 0x05 169 170static DEFINE_MUTEX(idefloppy_ref_mutex); 171 172#define to_ide_floppy(obj) container_of(obj, struct ide_floppy_obj, kref) 173 174#define ide_floppy_g(disk) \ 175 container_of((disk)->private_data, struct ide_floppy_obj, driver) 176 177static struct ide_floppy_obj *ide_floppy_get(struct gendisk *disk) 178{ 179 struct ide_floppy_obj *floppy = NULL; 180 181 mutex_lock(&idefloppy_ref_mutex); 182 floppy = ide_floppy_g(disk); 183 if (floppy) 184 kref_get(&floppy->kref); 185 mutex_unlock(&idefloppy_ref_mutex); 186 return floppy; 187} 188 189static void idefloppy_cleanup_obj(struct kref *); 190 191static void ide_floppy_put(struct ide_floppy_obj *floppy) 192{ 193 mutex_lock(&idefloppy_ref_mutex); 194 kref_put(&floppy->kref, idefloppy_cleanup_obj); 195 mutex_unlock(&idefloppy_ref_mutex); 196} 197 198/* 199 * Used to finish servicing a request. For read/write requests, we will call 200 * ide_end_request to pass to the next buffer. 201 */ 202static int idefloppy_end_request(ide_drive_t *drive, int uptodate, int nsecs) 203{ 204 idefloppy_floppy_t *floppy = drive->driver_data; 205 struct request *rq = HWGROUP(drive)->rq; 206 int error; 207 208 debug_log("Reached %s\n", __func__); 209 210 switch (uptodate) { 211 case 0: error = IDEFLOPPY_ERROR_GENERAL; break; 212 case 1: error = 0; break; 213 default: error = uptodate; 214 } 215 if (error) 216 floppy->failed_pc = NULL; 217 /* Why does this happen? */ 218 if (!rq) 219 return 0; 220 if (!blk_special_request(rq)) { 221 /* our real local end request function */ 222 ide_end_request(drive, uptodate, nsecs); 223 return 0; 224 } 225 rq->errors = error; 226 /* fixme: need to move this local also */ 227 ide_end_drive_cmd(drive, 0, 0); 228 return 0; 229} 230 231static void ide_floppy_io_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc, 232 unsigned int bcount, int direction) 233{ 234 ide_hwif_t *hwif = drive->hwif; 235 struct request *rq = pc->rq; 236 struct req_iterator iter; 237 struct bio_vec *bvec; 238 unsigned long flags; 239 int count, done = 0; 240 char *data; 241 242 rq_for_each_segment(bvec, rq, iter) { 243 if (!bcount) 244 break; 245 246 count = min(bvec->bv_len, bcount); 247 248 data = bvec_kmap_irq(bvec, &flags); 249 if (direction) 250 hwif->output_data(drive, NULL, data, count); 251 else 252 hwif->input_data(drive, NULL, data, count); 253 bvec_kunmap_irq(data, &flags); 254 255 bcount -= count; 256 pc->b_count += count; 257 done += count; 258 } 259 260 idefloppy_end_request(drive, 1, done >> 9); 261 262 if (bcount) { 263 printk(KERN_ERR "%s: leftover data in %s, bcount == %d\n", 264 drive->name, __func__, bcount); 265 ide_pad_transfer(drive, direction, bcount); 266 } 267} 268 269static void idefloppy_update_buffers(ide_drive_t *drive, 270 struct ide_atapi_pc *pc) 271{ 272 struct request *rq = pc->rq; 273 struct bio *bio = rq->bio; 274 275 while ((bio = rq->bio) != NULL) 276 idefloppy_end_request(drive, 1, 0); 277} 278 279/* 280 * Generate a new packet command request in front of the request queue, before 281 * the current request so that it will be processed immediately, on the next 282 * pass through the driver. 283 */ 284static void idefloppy_queue_pc_head(ide_drive_t *drive, struct ide_atapi_pc *pc, 285 struct request *rq) 286{ 287 struct ide_floppy_obj *floppy = drive->driver_data; 288 289 blk_rq_init(NULL, rq); 290 rq->buffer = (char *) pc; 291 rq->cmd_type = REQ_TYPE_SPECIAL; 292 rq->cmd_flags |= REQ_PREEMPT; 293 rq->rq_disk = floppy->disk; 294 ide_do_drive_cmd(drive, rq); 295} 296 297static struct ide_atapi_pc *idefloppy_next_pc_storage(ide_drive_t *drive) 298{ 299 idefloppy_floppy_t *floppy = drive->driver_data; 300 301 if (floppy->pc_stack_index == IDEFLOPPY_PC_STACK) 302 floppy->pc_stack_index = 0; 303 return (&floppy->pc_stack[floppy->pc_stack_index++]); 304} 305 306static struct request *idefloppy_next_rq_storage(ide_drive_t *drive) 307{ 308 idefloppy_floppy_t *floppy = drive->driver_data; 309 310 if (floppy->rq_stack_index == IDEFLOPPY_PC_STACK) 311 floppy->rq_stack_index = 0; 312 return (&floppy->rq_stack[floppy->rq_stack_index++]); 313} 314 315static void ide_floppy_callback(ide_drive_t *drive) 316{ 317 idefloppy_floppy_t *floppy = drive->driver_data; 318 struct ide_atapi_pc *pc = floppy->pc; 319 int uptodate = pc->error ? 0 : 1; 320 321 debug_log("Reached %s\n", __func__); 322 323 if (floppy->failed_pc == pc) 324 floppy->failed_pc = NULL; 325 326 if (pc->c[0] == GPCMD_READ_10 || pc->c[0] == GPCMD_WRITE_10 || 327 (pc->rq && blk_pc_request(pc->rq))) 328 uptodate = 1; /* FIXME */ 329 else if (pc->c[0] == GPCMD_REQUEST_SENSE) { 330 u8 *buf = floppy->pc->buf; 331 332 if (!pc->error) { 333 floppy->sense_key = buf[2] & 0x0F; 334 floppy->asc = buf[12]; 335 floppy->ascq = buf[13]; 336 floppy->progress_indication = buf[15] & 0x80 ? 337 (u16)get_unaligned((u16 *)&buf[16]) : 0x10000; 338 339 if (floppy->failed_pc) 340 debug_log("pc = %x, ", floppy->failed_pc->c[0]); 341 342 debug_log("sense key = %x, asc = %x, ascq = %x\n", 343 floppy->sense_key, floppy->asc, floppy->ascq); 344 } else 345 printk(KERN_ERR "Error in REQUEST SENSE itself - " 346 "Aborting request!\n"); 347 } 348 349 idefloppy_end_request(drive, uptodate, 0); 350} 351 352static void idefloppy_init_pc(struct ide_atapi_pc *pc) 353{ 354 memset(pc->c, 0, 12); 355 pc->retries = 0; 356 pc->flags = 0; 357 pc->req_xfer = 0; 358 pc->buf = pc->pc_buf; 359 pc->buf_size = IDEFLOPPY_PC_BUFFER_SIZE; 360 pc->callback = ide_floppy_callback; 361} 362 363static void idefloppy_create_request_sense_cmd(struct ide_atapi_pc *pc) 364{ 365 idefloppy_init_pc(pc); 366 pc->c[0] = GPCMD_REQUEST_SENSE; 367 pc->c[4] = 255; 368 pc->req_xfer = 18; 369} 370 371/* 372 * Called when an error was detected during the last packet command. We queue a 373 * request sense packet command in the head of the request list. 374 */ 375static void idefloppy_retry_pc(ide_drive_t *drive) 376{ 377 struct ide_atapi_pc *pc; 378 struct request *rq; 379 380 (void)ide_read_error(drive); 381 pc = idefloppy_next_pc_storage(drive); 382 rq = idefloppy_next_rq_storage(drive); 383 idefloppy_create_request_sense_cmd(pc); 384 idefloppy_queue_pc_head(drive, pc, rq); 385} 386 387/* The usual interrupt handler called during a packet command. */ 388static ide_startstop_t idefloppy_pc_intr(ide_drive_t *drive) 389{ 390 idefloppy_floppy_t *floppy = drive->driver_data; 391 ide_hwif_t *hwif = drive->hwif; 392 struct ide_atapi_pc *pc = floppy->pc; 393 struct request *rq = pc->rq; 394 xfer_func_t *xferfunc; 395 unsigned int temp; 396 int dma_error = 0; 397 u16 bcount; 398 u8 stat, ireason; 399 400 debug_log("Reached %s interrupt handler\n", __func__); 401 402 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { 403 dma_error = hwif->dma_ops->dma_end(drive); 404 if (dma_error) { 405 printk(KERN_ERR "%s: DMA %s error\n", drive->name, 406 rq_data_dir(rq) ? "write" : "read"); 407 pc->flags |= PC_FLAG_DMA_ERROR; 408 } else { 409 pc->xferred = pc->req_xfer; 410 idefloppy_update_buffers(drive, pc); 411 } 412 debug_log("DMA finished\n"); 413 } 414 415 /* Clear the interrupt */ 416 stat = ide_read_status(drive); 417 418 /* No more interrupts */ 419 if ((stat & DRQ_STAT) == 0) { 420 debug_log("Packet command completed, %d bytes transferred\n", 421 pc->xferred); 422 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS; 423 424 local_irq_enable_in_hardirq(); 425 426 if ((stat & ERR_STAT) || (pc->flags & PC_FLAG_DMA_ERROR)) { 427 /* Error detected */ 428 debug_log("%s: I/O error\n", drive->name); 429 rq->errors++; 430 if (pc->c[0] == GPCMD_REQUEST_SENSE) { 431 printk(KERN_ERR "%s: I/O error in request sense" 432 " command\n", drive->name); 433 return ide_do_reset(drive); 434 } 435 /* Retry operation */ 436 idefloppy_retry_pc(drive); 437 /* queued, but not started */ 438 return ide_stopped; 439 } 440 pc->error = 0; 441 /* Command finished - Call the callback function */ 442 pc->callback(drive); 443 return ide_stopped; 444 } 445 446 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { 447 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS; 448 printk(KERN_ERR "%s: The device wants to issue more interrupts " 449 "in DMA mode\n", drive->name); 450 ide_dma_off(drive); 451 return ide_do_reset(drive); 452 } 453 454 /* Get the number of bytes to transfer */ 455 bcount = (hwif->INB(hwif->io_ports.lbah_addr) << 8) | 456 hwif->INB(hwif->io_ports.lbam_addr); 457 /* on this interrupt */ 458 ireason = hwif->INB(hwif->io_ports.nsect_addr); 459 460 if (ireason & CD) { 461 printk(KERN_ERR "%s: CoD != 0 in %s\n", drive->name, __func__); 462 return ide_do_reset(drive); 463 } 464 if (((ireason & IO) == IO) == !!(pc->flags & PC_FLAG_WRITING)) { 465 /* Hopefully, we will never get here */ 466 printk(KERN_ERR "%s: We wanted to %s, but the device wants us " 467 "to %s!\n", drive->name, 468 (ireason & IO) ? "Write" : "Read", 469 (ireason & IO) ? "Read" : "Write"); 470 return ide_do_reset(drive); 471 } 472 if (!(pc->flags & PC_FLAG_WRITING)) { 473 /* Reading - Check that we have enough space */ 474 temp = pc->xferred + bcount; 475 if (temp > pc->req_xfer) { 476 if (temp > pc->buf_size) { 477 printk(KERN_ERR "%s: The device wants to send " 478 "us more data than expected - " 479 "discarding data\n", 480 drive->name); 481 ide_pad_transfer(drive, 0, bcount); 482 483 ide_set_handler(drive, 484 &idefloppy_pc_intr, 485 IDEFLOPPY_WAIT_CMD, 486 NULL); 487 return ide_started; 488 } 489 debug_log("The device wants to send us more data than " 490 "expected - allowing transfer\n"); 491 } 492 } 493 if (pc->flags & PC_FLAG_WRITING) 494 xferfunc = hwif->output_data; 495 else 496 xferfunc = hwif->input_data; 497 498 if (pc->buf) 499 xferfunc(drive, NULL, pc->cur_pos, bcount); 500 else 501 ide_floppy_io_buffers(drive, pc, bcount, 502 !!(pc->flags & PC_FLAG_WRITING)); 503 504 /* Update the current position */ 505 pc->xferred += bcount; 506 pc->cur_pos += bcount; 507 508 /* And set the interrupt handler again */ 509 ide_set_handler(drive, &idefloppy_pc_intr, IDEFLOPPY_WAIT_CMD, NULL); 510 return ide_started; 511} 512 513/* 514 * What we have here is a classic case of a top half / bottom half interrupt 515 * service routine. In interrupt mode, the device sends an interrupt to signal 516 * that it is ready to receive a packet. However, we need to delay about 2-3 517 * ticks before issuing the packet or we gets in trouble. 518 * 519 * So, follow carefully. transfer_pc1 is called as an interrupt (or directly). 520 * In either case, when the device says it's ready for a packet, we schedule 521 * the packet transfer to occur about 2-3 ticks later in transfer_pc2. 522 */ 523static int idefloppy_transfer_pc2(ide_drive_t *drive) 524{ 525 idefloppy_floppy_t *floppy = drive->driver_data; 526 527 /* Send the actual packet */ 528 drive->hwif->output_data(drive, NULL, floppy->pc->c, 12); 529 530 /* Timeout for the packet command */ 531 return IDEFLOPPY_WAIT_CMD; 532} 533 534static ide_startstop_t idefloppy_transfer_pc1(ide_drive_t *drive) 535{ 536 idefloppy_floppy_t *floppy = drive->driver_data; 537 struct ide_atapi_pc *pc = floppy->pc; 538 ide_expiry_t *expiry; 539 unsigned int timeout; 540 541 /* 542 * The following delay solves a problem with ATAPI Zip 100 drives 543 * where the Busy flag was apparently being deasserted before the 544 * unit was ready to receive data. This was happening on a 545 * 1200 MHz Athlon system. 10/26/01 25msec is too short, 546 * 40 and 50msec work well. idefloppy_pc_intr will not be actually 547 * used until after the packet is moved in about 50 msec. 548 */ 549 if (pc->flags & PC_FLAG_ZIP_DRIVE) { 550 timeout = floppy->ticks; 551 expiry = &idefloppy_transfer_pc2; 552 } else { 553 timeout = IDEFLOPPY_WAIT_CMD; 554 expiry = NULL; 555 } 556 557 return ide_transfer_pc(drive, pc, idefloppy_pc_intr, timeout, expiry); 558} 559 560static void ide_floppy_report_error(idefloppy_floppy_t *floppy, 561 struct ide_atapi_pc *pc) 562{ 563 /* supress error messages resulting from Medium not present */ 564 if (floppy->sense_key == 0x02 && 565 floppy->asc == 0x3a && 566 floppy->ascq == 0x00) 567 return; 568 569 printk(KERN_ERR "ide-floppy: %s: I/O error, pc = %2x, key = %2x, " 570 "asc = %2x, ascq = %2x\n", 571 floppy->drive->name, pc->c[0], floppy->sense_key, 572 floppy->asc, floppy->ascq); 573 574} 575 576static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive, 577 struct ide_atapi_pc *pc) 578{ 579 idefloppy_floppy_t *floppy = drive->driver_data; 580 581 if (floppy->failed_pc == NULL && 582 pc->c[0] != GPCMD_REQUEST_SENSE) 583 floppy->failed_pc = pc; 584 /* Set the current packet command */ 585 floppy->pc = pc; 586 587 if (pc->retries > IDEFLOPPY_MAX_PC_RETRIES) { 588 if (!(pc->flags & PC_FLAG_SUPPRESS_ERROR)) 589 ide_floppy_report_error(floppy, pc); 590 /* Giving up */ 591 pc->error = IDEFLOPPY_ERROR_GENERAL; 592 593 floppy->failed_pc = NULL; 594 pc->callback(drive); 595 return ide_stopped; 596 } 597 598 debug_log("Retry number - %d\n", pc->retries); 599 600 pc->retries++; 601 602 return ide_issue_pc(drive, pc, idefloppy_transfer_pc1, 603 IDEFLOPPY_WAIT_CMD, NULL); 604} 605 606static void idefloppy_create_prevent_cmd(struct ide_atapi_pc *pc, int prevent) 607{ 608 debug_log("creating prevent removal command, prevent = %d\n", prevent); 609 610 idefloppy_init_pc(pc); 611 pc->c[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL; 612 pc->c[4] = prevent; 613} 614 615static void idefloppy_create_read_capacity_cmd(struct ide_atapi_pc *pc) 616{ 617 idefloppy_init_pc(pc); 618 pc->c[0] = GPCMD_READ_FORMAT_CAPACITIES; 619 pc->c[7] = 255; 620 pc->c[8] = 255; 621 pc->req_xfer = 255; 622} 623 624static void idefloppy_create_format_unit_cmd(struct ide_atapi_pc *pc, int b, 625 int l, int flags) 626{ 627 idefloppy_init_pc(pc); 628 pc->c[0] = GPCMD_FORMAT_UNIT; 629 pc->c[1] = 0x17; 630 631 memset(pc->buf, 0, 12); 632 pc->buf[1] = 0xA2; 633 /* Default format list header, u8 1: FOV/DCRT/IMM bits set */ 634 635 if (flags & 1) /* Verify bit on... */ 636 pc->buf[1] ^= 0x20; /* ... turn off DCRT bit */ 637 pc->buf[3] = 8; 638 639 put_unaligned(cpu_to_be32(b), (unsigned int *)(&pc->buf[4])); 640 put_unaligned(cpu_to_be32(l), (unsigned int *)(&pc->buf[8])); 641 pc->buf_size = 12; 642 pc->flags |= PC_FLAG_WRITING; 643} 644 645/* A mode sense command is used to "sense" floppy parameters. */ 646static void idefloppy_create_mode_sense_cmd(struct ide_atapi_pc *pc, 647 u8 page_code, u8 type) 648{ 649 u16 length = 8; /* sizeof(Mode Parameter Header) = 8 Bytes */ 650 651 idefloppy_init_pc(pc); 652 pc->c[0] = GPCMD_MODE_SENSE_10; 653 pc->c[1] = 0; 654 pc->c[2] = page_code + (type << 6); 655 656 switch (page_code) { 657 case IDEFLOPPY_CAPABILITIES_PAGE: 658 length += 12; 659 break; 660 case IDEFLOPPY_FLEXIBLE_DISK_PAGE: 661 length += 32; 662 break; 663 default: 664 printk(KERN_ERR "ide-floppy: unsupported page code " 665 "in create_mode_sense_cmd\n"); 666 } 667 put_unaligned(cpu_to_be16(length), (u16 *) &pc->c[7]); 668 pc->req_xfer = length; 669} 670 671static void idefloppy_create_start_stop_cmd(struct ide_atapi_pc *pc, int start) 672{ 673 idefloppy_init_pc(pc); 674 pc->c[0] = GPCMD_START_STOP_UNIT; 675 pc->c[4] = start; 676} 677 678static void idefloppy_create_test_unit_ready_cmd(struct ide_atapi_pc *pc) 679{ 680 idefloppy_init_pc(pc); 681 pc->c[0] = GPCMD_TEST_UNIT_READY; 682} 683 684static void idefloppy_create_rw_cmd(idefloppy_floppy_t *floppy, 685 struct ide_atapi_pc *pc, struct request *rq, 686 unsigned long sector) 687{ 688 int block = sector / floppy->bs_factor; 689 int blocks = rq->nr_sectors / floppy->bs_factor; 690 int cmd = rq_data_dir(rq); 691 692 debug_log("create_rw10_cmd: block == %d, blocks == %d\n", 693 block, blocks); 694 695 idefloppy_init_pc(pc); 696 pc->c[0] = cmd == READ ? GPCMD_READ_10 : GPCMD_WRITE_10; 697 put_unaligned(cpu_to_be16(blocks), (unsigned short *)&pc->c[7]); 698 put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[2]); 699 700 pc->rq = rq; 701 pc->b_count = cmd == READ ? 0 : rq->bio->bi_size; 702 if (rq->cmd_flags & REQ_RW) 703 pc->flags |= PC_FLAG_WRITING; 704 pc->buf = NULL; 705 pc->req_xfer = pc->buf_size = blocks * floppy->block_size; 706 pc->flags |= PC_FLAG_DMA_OK; 707} 708 709static void idefloppy_blockpc_cmd(idefloppy_floppy_t *floppy, 710 struct ide_atapi_pc *pc, struct request *rq) 711{ 712 idefloppy_init_pc(pc); 713 memcpy(pc->c, rq->cmd, sizeof(pc->c)); 714 pc->rq = rq; 715 pc->b_count = rq->data_len; 716 if (rq->data_len && rq_data_dir(rq) == WRITE) 717 pc->flags |= PC_FLAG_WRITING; 718 pc->buf = rq->data; 719 if (rq->bio) 720 pc->flags |= PC_FLAG_DMA_OK; 721 /* 722 * possibly problematic, doesn't look like ide-floppy correctly 723 * handled scattered requests if dma fails... 724 */ 725 pc->req_xfer = pc->buf_size = rq->data_len; 726} 727 728static ide_startstop_t idefloppy_do_request(ide_drive_t *drive, 729 struct request *rq, sector_t block_s) 730{ 731 idefloppy_floppy_t *floppy = drive->driver_data; 732 struct ide_atapi_pc *pc; 733 unsigned long block = (unsigned long)block_s; 734 735 debug_log("dev: %s, cmd_type: %x, errors: %d\n", 736 rq->rq_disk ? rq->rq_disk->disk_name : "?", 737 rq->cmd_type, rq->errors); 738 debug_log("sector: %ld, nr_sectors: %ld, " 739 "current_nr_sectors: %d\n", (long)rq->sector, 740 rq->nr_sectors, rq->current_nr_sectors); 741 742 if (rq->errors >= ERROR_MAX) { 743 if (floppy->failed_pc) 744 ide_floppy_report_error(floppy, floppy->failed_pc); 745 else 746 printk(KERN_ERR "ide-floppy: %s: I/O error\n", 747 drive->name); 748 idefloppy_end_request(drive, 0, 0); 749 return ide_stopped; 750 } 751 if (blk_fs_request(rq)) { 752 if (((long)rq->sector % floppy->bs_factor) || 753 (rq->nr_sectors % floppy->bs_factor)) { 754 printk(KERN_ERR "%s: unsupported r/w request size\n", 755 drive->name); 756 idefloppy_end_request(drive, 0, 0); 757 return ide_stopped; 758 } 759 pc = idefloppy_next_pc_storage(drive); 760 idefloppy_create_rw_cmd(floppy, pc, rq, block); 761 } else if (blk_special_request(rq)) { 762 pc = (struct ide_atapi_pc *) rq->buffer; 763 } else if (blk_pc_request(rq)) { 764 pc = idefloppy_next_pc_storage(drive); 765 idefloppy_blockpc_cmd(floppy, pc, rq); 766 } else { 767 blk_dump_rq_flags(rq, 768 "ide-floppy: unsupported command in queue"); 769 idefloppy_end_request(drive, 0, 0); 770 return ide_stopped; 771 } 772 773 if (floppy->flags & IDEFLOPPY_FLAG_DRQ_INTERRUPT) 774 pc->flags |= PC_FLAG_DRQ_INTERRUPT; 775 776 if (floppy->flags & IDEFLOPPY_FLAG_ZIP_DRIVE) 777 pc->flags |= PC_FLAG_ZIP_DRIVE; 778 779 pc->rq = rq; 780 781 return idefloppy_issue_pc(drive, pc); 782} 783 784/* 785 * Add a special packet command request to the tail of the request queue, 786 * and wait for it to be serviced. 787 */ 788static int idefloppy_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc) 789{ 790 struct ide_floppy_obj *floppy = drive->driver_data; 791 struct request *rq; 792 int error; 793 794 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 795 rq->buffer = (char *) pc; 796 rq->cmd_type = REQ_TYPE_SPECIAL; 797 error = blk_execute_rq(drive->queue, floppy->disk, rq, 0); 798 blk_put_request(rq); 799 800 return error; 801} 802 803/* 804 * Look at the flexible disk page parameters. We ignore the CHS capacity 805 * parameters and use the LBA parameters instead. 806 */ 807static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive) 808{ 809 idefloppy_floppy_t *floppy = drive->driver_data; 810 struct ide_atapi_pc pc; 811 u8 *page; 812 int capacity, lba_capacity; 813 u16 transfer_rate, sector_size, cyls, rpm; 814 u8 heads, sectors; 815 816 idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE, 817 MODE_SENSE_CURRENT); 818 819 if (idefloppy_queue_pc_tail(drive, &pc)) { 820 printk(KERN_ERR "ide-floppy: Can't get flexible disk page" 821 " parameters\n"); 822 return 1; 823 } 824 floppy->wp = !!(pc.buf[3] & 0x80); 825 set_disk_ro(floppy->disk, floppy->wp); 826 page = &pc.buf[8]; 827 828 transfer_rate = be16_to_cpu(*(u16 *)&pc.buf[8 + 2]); 829 sector_size = be16_to_cpu(*(u16 *)&pc.buf[8 + 6]); 830 cyls = be16_to_cpu(*(u16 *)&pc.buf[8 + 8]); 831 rpm = be16_to_cpu(*(u16 *)&pc.buf[8 + 28]); 832 heads = pc.buf[8 + 4]; 833 sectors = pc.buf[8 + 5]; 834 835 capacity = cyls * heads * sectors * sector_size; 836 837 if (memcmp(page, &floppy->flexible_disk_page, 32)) 838 printk(KERN_INFO "%s: %dkB, %d/%d/%d CHS, %d kBps, " 839 "%d sector size, %d rpm\n", 840 drive->name, capacity / 1024, cyls, heads, 841 sectors, transfer_rate / 8, sector_size, rpm); 842 843 memcpy(&floppy->flexible_disk_page, page, 32); 844 drive->bios_cyl = cyls; 845 drive->bios_head = heads; 846 drive->bios_sect = sectors; 847 lba_capacity = floppy->blocks * floppy->block_size; 848 849 if (capacity < lba_capacity) { 850 printk(KERN_NOTICE "%s: The disk reports a capacity of %d " 851 "bytes, but the drive only handles %d\n", 852 drive->name, lba_capacity, capacity); 853 floppy->blocks = floppy->block_size ? 854 capacity / floppy->block_size : 0; 855 } 856 return 0; 857} 858 859static int idefloppy_get_sfrp_bit(ide_drive_t *drive) 860{ 861 idefloppy_floppy_t *floppy = drive->driver_data; 862 struct ide_atapi_pc pc; 863 864 floppy->srfp = 0; 865 idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_CAPABILITIES_PAGE, 866 MODE_SENSE_CURRENT); 867 868 pc.flags |= PC_FLAG_SUPPRESS_ERROR; 869 if (idefloppy_queue_pc_tail(drive, &pc)) 870 return 1; 871 872 floppy->srfp = pc.buf[8 + 2] & 0x40; 873 return (0); 874} 875 876/* 877 * Determine if a media is present in the floppy drive, and if so, its LBA 878 * capacity. 879 */ 880static int ide_floppy_get_capacity(ide_drive_t *drive) 881{ 882 idefloppy_floppy_t *floppy = drive->driver_data; 883 struct ide_atapi_pc pc; 884 u8 *cap_desc; 885 u8 header_len, desc_cnt; 886 int i, rc = 1, blocks, length; 887 888 drive->bios_cyl = 0; 889 drive->bios_head = drive->bios_sect = 0; 890 floppy->blocks = 0; 891 floppy->bs_factor = 1; 892 set_capacity(floppy->disk, 0); 893 894 idefloppy_create_read_capacity_cmd(&pc); 895 if (idefloppy_queue_pc_tail(drive, &pc)) { 896 printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n"); 897 return 1; 898 } 899 header_len = pc.buf[3]; 900 cap_desc = &pc.buf[4]; 901 desc_cnt = header_len / 8; /* capacity descriptor of 8 bytes */ 902 903 for (i = 0; i < desc_cnt; i++) { 904 unsigned int desc_start = 4 + i*8; 905 906 blocks = be32_to_cpu(*(u32 *)&pc.buf[desc_start]); 907 length = be16_to_cpu(*(u16 *)&pc.buf[desc_start + 6]); 908 909 debug_log("Descriptor %d: %dkB, %d blocks, %d sector size\n", 910 i, blocks * length / 1024, blocks, length); 911 912 if (i) 913 continue; 914 /* 915 * the code below is valid only for the 1st descriptor, ie i=0 916 */ 917 918 switch (pc.buf[desc_start + 4] & 0x03) { 919 /* Clik! drive returns this instead of CAPACITY_CURRENT */ 920 case CAPACITY_UNFORMATTED: 921 if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE)) 922 /* 923 * If it is not a clik drive, break out 924 * (maintains previous driver behaviour) 925 */ 926 break; 927 case CAPACITY_CURRENT: 928 /* Normal Zip/LS-120 disks */ 929 if (memcmp(cap_desc, &floppy->cap_desc, 8)) 930 printk(KERN_INFO "%s: %dkB, %d blocks, %d " 931 "sector size\n", drive->name, 932 blocks * length / 1024, blocks, length); 933 memcpy(&floppy->cap_desc, cap_desc, 8); 934 935 if (!length || length % 512) { 936 printk(KERN_NOTICE "%s: %d bytes block size " 937 "not supported\n", drive->name, length); 938 } else { 939 floppy->blocks = blocks; 940 floppy->block_size = length; 941 floppy->bs_factor = length / 512; 942 if (floppy->bs_factor != 1) 943 printk(KERN_NOTICE "%s: warning: non " 944 "512 bytes block size not " 945 "fully supported\n", 946 drive->name); 947 rc = 0; 948 } 949 break; 950 case CAPACITY_NO_CARTRIDGE: 951 /* 952 * This is a KERN_ERR so it appears on screen 953 * for the user to see 954 */ 955 printk(KERN_ERR "%s: No disk in drive\n", drive->name); 956 break; 957 case CAPACITY_INVALID: 958 printk(KERN_ERR "%s: Invalid capacity for disk " 959 "in drive\n", drive->name); 960 break; 961 } 962 debug_log("Descriptor 0 Code: %d\n", 963 pc.buf[desc_start + 4] & 0x03); 964 } 965 966 /* Clik! disk does not support get_flexible_disk_page */ 967 if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE)) 968 (void) ide_floppy_get_flexible_disk_page(drive); 969 970 set_capacity(floppy->disk, floppy->blocks * floppy->bs_factor); 971 return rc; 972} 973 974/* 975 * Obtain the list of formattable capacities. 976 * Very similar to ide_floppy_get_capacity, except that we push the capacity 977 * descriptors to userland, instead of our own structures. 978 * 979 * Userland gives us the following structure: 980 * 981 * struct idefloppy_format_capacities { 982 * int nformats; 983 * struct { 984 * int nblocks; 985 * int blocksize; 986 * } formats[]; 987 * }; 988 * 989 * userland initializes nformats to the number of allocated formats[] records. 990 * On exit we set nformats to the number of records we've actually initialized. 991 */ 992 993static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg) 994{ 995 struct ide_atapi_pc pc; 996 u8 header_len, desc_cnt; 997 int i, blocks, length, u_array_size, u_index; 998 int __user *argp; 999 1000 if (get_user(u_array_size, arg)) 1001 return (-EFAULT); 1002 1003 if (u_array_size <= 0) 1004 return (-EINVAL); 1005 1006 idefloppy_create_read_capacity_cmd(&pc); 1007 if (idefloppy_queue_pc_tail(drive, &pc)) { 1008 printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n"); 1009 return (-EIO); 1010 } 1011 header_len = pc.buf[3]; 1012 desc_cnt = header_len / 8; /* capacity descriptor of 8 bytes */ 1013 1014 u_index = 0; 1015 argp = arg + 1; 1016 1017 /* 1018 * We always skip the first capacity descriptor. That's the current 1019 * capacity. We are interested in the remaining descriptors, the 1020 * formattable capacities. 1021 */ 1022 for (i = 1; i < desc_cnt; i++) { 1023 unsigned int desc_start = 4 + i*8; 1024 1025 if (u_index >= u_array_size) 1026 break; /* User-supplied buffer too small */ 1027 1028 blocks = be32_to_cpu(*(u32 *)&pc.buf[desc_start]); 1029 length = be16_to_cpu(*(u16 *)&pc.buf[desc_start + 6]); 1030 1031 if (put_user(blocks, argp)) 1032 return(-EFAULT); 1033 ++argp; 1034 1035 if (put_user(length, argp)) 1036 return (-EFAULT); 1037 ++argp; 1038 1039 ++u_index; 1040 } 1041 1042 if (put_user(u_index, arg)) 1043 return (-EFAULT); 1044 return (0); 1045} 1046 1047/* 1048 * Get ATAPI_FORMAT_UNIT progress indication. 1049 * 1050 * Userland gives a pointer to an int. The int is set to a progress 1051 * indicator 0-65536, with 65536=100%. 1052 * 1053 * If the drive does not support format progress indication, we just check 1054 * the dsc bit, and return either 0 or 65536. 1055 */ 1056 1057static int idefloppy_get_format_progress(ide_drive_t *drive, int __user *arg) 1058{ 1059 idefloppy_floppy_t *floppy = drive->driver_data; 1060 struct ide_atapi_pc pc; 1061 int progress_indication = 0x10000; 1062 1063 if (floppy->srfp) { 1064 idefloppy_create_request_sense_cmd(&pc); 1065 if (idefloppy_queue_pc_tail(drive, &pc)) 1066 return (-EIO); 1067 1068 if (floppy->sense_key == 2 && 1069 floppy->asc == 4 && 1070 floppy->ascq == 4) 1071 progress_indication = floppy->progress_indication; 1072 1073 /* Else assume format_unit has finished, and we're at 0x10000 */ 1074 } else { 1075 unsigned long flags; 1076 u8 stat; 1077 1078 local_irq_save(flags); 1079 stat = ide_read_status(drive); 1080 local_irq_restore(flags); 1081 1082 progress_indication = ((stat & SEEK_STAT) == 0) ? 0 : 0x10000; 1083 } 1084 if (put_user(progress_indication, arg)) 1085 return (-EFAULT); 1086 1087 return (0); 1088} 1089 1090static sector_t idefloppy_capacity(ide_drive_t *drive) 1091{ 1092 idefloppy_floppy_t *floppy = drive->driver_data; 1093 unsigned long capacity = floppy->blocks * floppy->bs_factor; 1094 1095 return capacity; 1096} 1097 1098/* 1099 * Check whether we can support a drive, based on the ATAPI IDENTIFY command 1100 * results. 1101 */ 1102static int idefloppy_identify_device(ide_drive_t *drive, struct hd_driveid *id) 1103{ 1104 u8 gcw[2]; 1105 u8 device_type, protocol, removable, drq_type, packet_size; 1106 1107 *((u16 *) &gcw) = id->config; 1108 1109 device_type = gcw[1] & 0x1F; 1110 removable = (gcw[0] & 0x80) >> 7; 1111 protocol = (gcw[1] & 0xC0) >> 6; 1112 drq_type = (gcw[0] & 0x60) >> 5; 1113 packet_size = gcw[0] & 0x03; 1114 1115#ifdef CONFIG_PPC 1116 /* kludge for Apple PowerBook internal zip */ 1117 if (device_type == 5 && 1118 !strstr(id->model, "CD-ROM") && strstr(id->model, "ZIP")) 1119 device_type = 0; 1120#endif 1121 1122 if (protocol != 2) 1123 printk(KERN_ERR "ide-floppy: Protocol (0x%02x) is not ATAPI\n", 1124 protocol); 1125 else if (device_type != 0) 1126 printk(KERN_ERR "ide-floppy: Device type (0x%02x) is not set " 1127 "to floppy\n", device_type); 1128 else if (!removable) 1129 printk(KERN_ERR "ide-floppy: The removable flag is not set\n"); 1130 else if (drq_type == 3) 1131 printk(KERN_ERR "ide-floppy: Sorry, DRQ type (0x%02x) not " 1132 "supported\n", drq_type); 1133 else if (packet_size != 0) 1134 printk(KERN_ERR "ide-floppy: Packet size (0x%02x) is not 12 " 1135 "bytes\n", packet_size); 1136 else 1137 return 1; 1138 return 0; 1139} 1140 1141#ifdef CONFIG_IDE_PROC_FS 1142static void idefloppy_add_settings(ide_drive_t *drive) 1143{ 1144 idefloppy_floppy_t *floppy = drive->driver_data; 1145 1146 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 1023, 1, 1, 1147 &drive->bios_cyl, NULL); 1148 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, 1149 &drive->bios_head, NULL); 1150 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, 1151 &drive->bios_sect, NULL); 1152 ide_add_setting(drive, "ticks", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, 1153 &floppy->ticks, NULL); 1154} 1155#else 1156static inline void idefloppy_add_settings(ide_drive_t *drive) { ; } 1157#endif 1158 1159static void idefloppy_setup(ide_drive_t *drive, idefloppy_floppy_t *floppy) 1160{ 1161 u8 gcw[2]; 1162 1163 *((u16 *) &gcw) = drive->id->config; 1164 floppy->pc = floppy->pc_stack; 1165 1166 if (((gcw[0] & 0x60) >> 5) == 1) 1167 floppy->flags |= IDEFLOPPY_FLAG_DRQ_INTERRUPT; 1168 /* 1169 * We used to check revisions here. At this point however I'm giving up. 1170 * Just assume they are all broken, its easier. 1171 * 1172 * The actual reason for the workarounds was likely a driver bug after 1173 * all rather than a firmware bug, and the workaround below used to hide 1174 * it. It should be fixed as of version 1.9, but to be on the safe side 1175 * we'll leave the limitation below for the 2.2.x tree. 1176 */ 1177 if (!strncmp(drive->id->model, "IOMEGA ZIP 100 ATAPI", 20)) { 1178 floppy->flags |= IDEFLOPPY_FLAG_ZIP_DRIVE; 1179 /* This value will be visible in the /proc/ide/hdx/settings */ 1180 floppy->ticks = IDEFLOPPY_TICKS_DELAY; 1181 blk_queue_max_sectors(drive->queue, 64); 1182 } 1183 1184 /* 1185 * Guess what? The IOMEGA Clik! drive also needs the above fix. It makes 1186 * nasty clicking noises without it, so please don't remove this. 1187 */ 1188 if (strncmp(drive->id->model, "IOMEGA Clik!", 11) == 0) { 1189 blk_queue_max_sectors(drive->queue, 64); 1190 floppy->flags |= IDEFLOPPY_FLAG_CLIK_DRIVE; 1191 } 1192 1193 (void) ide_floppy_get_capacity(drive); 1194 idefloppy_add_settings(drive); 1195} 1196 1197static void ide_floppy_remove(ide_drive_t *drive) 1198{ 1199 idefloppy_floppy_t *floppy = drive->driver_data; 1200 struct gendisk *g = floppy->disk; 1201 1202 ide_proc_unregister_driver(drive, floppy->driver); 1203 1204 del_gendisk(g); 1205 1206 ide_floppy_put(floppy); 1207} 1208 1209static void idefloppy_cleanup_obj(struct kref *kref) 1210{ 1211 struct ide_floppy_obj *floppy = to_ide_floppy(kref); 1212 ide_drive_t *drive = floppy->drive; 1213 struct gendisk *g = floppy->disk; 1214 1215 drive->driver_data = NULL; 1216 g->private_data = NULL; 1217 put_disk(g); 1218 kfree(floppy); 1219} 1220 1221#ifdef CONFIG_IDE_PROC_FS 1222static int proc_idefloppy_read_capacity(char *page, char **start, off_t off, 1223 int count, int *eof, void *data) 1224{ 1225 ide_drive_t*drive = (ide_drive_t *)data; 1226 int len; 1227 1228 len = sprintf(page, "%llu\n", (long long)idefloppy_capacity(drive)); 1229 PROC_IDE_READ_RETURN(page, start, off, count, eof, len); 1230} 1231 1232static ide_proc_entry_t idefloppy_proc[] = { 1233 { "capacity", S_IFREG|S_IRUGO, proc_idefloppy_read_capacity, NULL }, 1234 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL }, 1235 { NULL, 0, NULL, NULL } 1236}; 1237#endif /* CONFIG_IDE_PROC_FS */ 1238 1239static int ide_floppy_probe(ide_drive_t *); 1240 1241static ide_driver_t idefloppy_driver = { 1242 .gen_driver = { 1243 .owner = THIS_MODULE, 1244 .name = "ide-floppy", 1245 .bus = &ide_bus_type, 1246 }, 1247 .probe = ide_floppy_probe, 1248 .remove = ide_floppy_remove, 1249 .version = IDEFLOPPY_VERSION, 1250 .media = ide_floppy, 1251 .supports_dsc_overlap = 0, 1252 .do_request = idefloppy_do_request, 1253 .end_request = idefloppy_end_request, 1254 .error = __ide_error, 1255 .abort = __ide_abort, 1256#ifdef CONFIG_IDE_PROC_FS 1257 .proc = idefloppy_proc, 1258#endif 1259}; 1260 1261static int idefloppy_open(struct inode *inode, struct file *filp) 1262{ 1263 struct gendisk *disk = inode->i_bdev->bd_disk; 1264 struct ide_floppy_obj *floppy; 1265 ide_drive_t *drive; 1266 struct ide_atapi_pc pc; 1267 int ret = 0; 1268 1269 debug_log("Reached %s\n", __func__); 1270 1271 floppy = ide_floppy_get(disk); 1272 if (!floppy) 1273 return -ENXIO; 1274 1275 drive = floppy->drive; 1276 1277 floppy->openers++; 1278 1279 if (floppy->openers == 1) { 1280 floppy->flags &= ~IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS; 1281 /* Just in case */ 1282 1283 idefloppy_create_test_unit_ready_cmd(&pc); 1284 if (idefloppy_queue_pc_tail(drive, &pc)) { 1285 idefloppy_create_start_stop_cmd(&pc, 1); 1286 (void) idefloppy_queue_pc_tail(drive, &pc); 1287 } 1288 1289 if (ide_floppy_get_capacity(drive) 1290 && (filp->f_flags & O_NDELAY) == 0 1291 /* 1292 * Allow O_NDELAY to open a drive without a disk, or with an 1293 * unreadable disk, so that we can get the format capacity 1294 * of the drive or begin the format - Sam 1295 */ 1296 ) { 1297 ret = -EIO; 1298 goto out_put_floppy; 1299 } 1300 1301 if (floppy->wp && (filp->f_mode & 2)) { 1302 ret = -EROFS; 1303 goto out_put_floppy; 1304 } 1305 floppy->flags |= IDEFLOPPY_FLAG_MEDIA_CHANGED; 1306 /* IOMEGA Clik! drives do not support lock/unlock commands */ 1307 if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE)) { 1308 idefloppy_create_prevent_cmd(&pc, 1); 1309 (void) idefloppy_queue_pc_tail(drive, &pc); 1310 } 1311 check_disk_change(inode->i_bdev); 1312 } else if (floppy->flags & IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS) { 1313 ret = -EBUSY; 1314 goto out_put_floppy; 1315 } 1316 return 0; 1317 1318out_put_floppy: 1319 floppy->openers--; 1320 ide_floppy_put(floppy); 1321 return ret; 1322} 1323 1324static int idefloppy_release(struct inode *inode, struct file *filp) 1325{ 1326 struct gendisk *disk = inode->i_bdev->bd_disk; 1327 struct ide_floppy_obj *floppy = ide_floppy_g(disk); 1328 ide_drive_t *drive = floppy->drive; 1329 struct ide_atapi_pc pc; 1330 1331 debug_log("Reached %s\n", __func__); 1332 1333 if (floppy->openers == 1) { 1334 /* IOMEGA Clik! drives do not support lock/unlock commands */ 1335 if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE)) { 1336 idefloppy_create_prevent_cmd(&pc, 0); 1337 (void) idefloppy_queue_pc_tail(drive, &pc); 1338 } 1339 1340 floppy->flags &= ~IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS; 1341 } 1342 1343 floppy->openers--; 1344 1345 ide_floppy_put(floppy); 1346 1347 return 0; 1348} 1349 1350static int idefloppy_getgeo(struct block_device *bdev, struct hd_geometry *geo) 1351{ 1352 struct ide_floppy_obj *floppy = ide_floppy_g(bdev->bd_disk); 1353 ide_drive_t *drive = floppy->drive; 1354 1355 geo->heads = drive->bios_head; 1356 geo->sectors = drive->bios_sect; 1357 geo->cylinders = (u16)drive->bios_cyl; /* truncate */ 1358 return 0; 1359} 1360 1361static int ide_floppy_lockdoor(idefloppy_floppy_t *floppy, 1362 struct ide_atapi_pc *pc, unsigned long arg, unsigned int cmd) 1363{ 1364 if (floppy->openers > 1) 1365 return -EBUSY; 1366 1367 /* The IOMEGA Clik! Drive doesn't support this command - 1368 * no room for an eject mechanism */ 1369 if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE)) { 1370 int prevent = arg ? 1 : 0; 1371 1372 if (cmd == CDROMEJECT) 1373 prevent = 0; 1374 1375 idefloppy_create_prevent_cmd(pc, prevent); 1376 (void) idefloppy_queue_pc_tail(floppy->drive, pc); 1377 } 1378 1379 if (cmd == CDROMEJECT) { 1380 idefloppy_create_start_stop_cmd(pc, 2); 1381 (void) idefloppy_queue_pc_tail(floppy->drive, pc); 1382 } 1383 1384 return 0; 1385} 1386 1387static int ide_floppy_format_unit(idefloppy_floppy_t *floppy, 1388 int __user *arg) 1389{ 1390 int blocks, length, flags, err = 0; 1391 struct ide_atapi_pc pc; 1392 1393 if (floppy->openers > 1) { 1394 /* Don't format if someone is using the disk */ 1395 floppy->flags &= ~IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS; 1396 return -EBUSY; 1397 } 1398 1399 floppy->flags |= IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS; 1400 1401 /* 1402 * Send ATAPI_FORMAT_UNIT to the drive. 1403 * 1404 * Userland gives us the following structure: 1405 * 1406 * struct idefloppy_format_command { 1407 * int nblocks; 1408 * int blocksize; 1409 * int flags; 1410 * } ; 1411 * 1412 * flags is a bitmask, currently, the only defined flag is: 1413 * 1414 * 0x01 - verify media after format. 1415 */ 1416 if (get_user(blocks, arg) || 1417 get_user(length, arg+1) || 1418 get_user(flags, arg+2)) { 1419 err = -EFAULT; 1420 goto out; 1421 } 1422 1423 (void) idefloppy_get_sfrp_bit(floppy->drive); 1424 idefloppy_create_format_unit_cmd(&pc, blocks, length, flags); 1425 1426 if (idefloppy_queue_pc_tail(floppy->drive, &pc)) 1427 err = -EIO; 1428 1429out: 1430 if (err) 1431 floppy->flags &= ~IDEFLOPPY_FLAG_FORMAT_IN_PROGRESS; 1432 return err; 1433} 1434 1435 1436static int idefloppy_ioctl(struct inode *inode, struct file *file, 1437 unsigned int cmd, unsigned long arg) 1438{ 1439 struct block_device *bdev = inode->i_bdev; 1440 struct ide_floppy_obj *floppy = ide_floppy_g(bdev->bd_disk); 1441 ide_drive_t *drive = floppy->drive; 1442 struct ide_atapi_pc pc; 1443 void __user *argp = (void __user *)arg; 1444 int err; 1445 1446 switch (cmd) { 1447 case CDROMEJECT: 1448 /* fall through */ 1449 case CDROM_LOCKDOOR: 1450 return ide_floppy_lockdoor(floppy, &pc, arg, cmd); 1451 case IDEFLOPPY_IOCTL_FORMAT_SUPPORTED: 1452 return 0; 1453 case IDEFLOPPY_IOCTL_FORMAT_GET_CAPACITY: 1454 return ide_floppy_get_format_capacities(drive, argp); 1455 case IDEFLOPPY_IOCTL_FORMAT_START: 1456 if (!(file->f_mode & 2)) 1457 return -EPERM; 1458 1459 return ide_floppy_format_unit(floppy, (int __user *)arg); 1460 case IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS: 1461 return idefloppy_get_format_progress(drive, argp); 1462 } 1463 1464 /* 1465 * skip SCSI_IOCTL_SEND_COMMAND (deprecated) 1466 * and CDROM_SEND_PACKET (legacy) ioctls 1467 */ 1468 if (cmd != CDROM_SEND_PACKET && cmd != SCSI_IOCTL_SEND_COMMAND) 1469 err = scsi_cmd_ioctl(file, bdev->bd_disk->queue, 1470 bdev->bd_disk, cmd, argp); 1471 else 1472 err = -ENOTTY; 1473 1474 if (err == -ENOTTY) 1475 err = generic_ide_ioctl(drive, file, bdev, cmd, arg); 1476 1477 return err; 1478} 1479 1480static int idefloppy_media_changed(struct gendisk *disk) 1481{ 1482 struct ide_floppy_obj *floppy = ide_floppy_g(disk); 1483 ide_drive_t *drive = floppy->drive; 1484 int ret; 1485 1486 /* do not scan partitions twice if this is a removable device */ 1487 if (drive->attach) { 1488 drive->attach = 0; 1489 return 0; 1490 } 1491 ret = !!(floppy->flags & IDEFLOPPY_FLAG_MEDIA_CHANGED); 1492 floppy->flags &= ~IDEFLOPPY_FLAG_MEDIA_CHANGED; 1493 return ret; 1494} 1495 1496static int idefloppy_revalidate_disk(struct gendisk *disk) 1497{ 1498 struct ide_floppy_obj *floppy = ide_floppy_g(disk); 1499 set_capacity(disk, idefloppy_capacity(floppy->drive)); 1500 return 0; 1501} 1502 1503static struct block_device_operations idefloppy_ops = { 1504 .owner = THIS_MODULE, 1505 .open = idefloppy_open, 1506 .release = idefloppy_release, 1507 .ioctl = idefloppy_ioctl, 1508 .getgeo = idefloppy_getgeo, 1509 .media_changed = idefloppy_media_changed, 1510 .revalidate_disk = idefloppy_revalidate_disk 1511}; 1512 1513static int ide_floppy_probe(ide_drive_t *drive) 1514{ 1515 idefloppy_floppy_t *floppy; 1516 struct gendisk *g; 1517 1518 if (!strstr("ide-floppy", drive->driver_req)) 1519 goto failed; 1520 if (!drive->present) 1521 goto failed; 1522 if (drive->media != ide_floppy) 1523 goto failed; 1524 if (!idefloppy_identify_device(drive, drive->id)) { 1525 printk(KERN_ERR "ide-floppy: %s: not supported by this version" 1526 " of ide-floppy\n", drive->name); 1527 goto failed; 1528 } 1529 floppy = kzalloc(sizeof(idefloppy_floppy_t), GFP_KERNEL); 1530 if (!floppy) { 1531 printk(KERN_ERR "ide-floppy: %s: Can't allocate a floppy" 1532 " structure\n", drive->name); 1533 goto failed; 1534 } 1535 1536 g = alloc_disk(1 << PARTN_BITS); 1537 if (!g) 1538 goto out_free_floppy; 1539 1540 ide_init_disk(g, drive); 1541 1542 ide_proc_register_driver(drive, &idefloppy_driver); 1543 1544 kref_init(&floppy->kref); 1545 1546 floppy->drive = drive; 1547 floppy->driver = &idefloppy_driver; 1548 floppy->disk = g; 1549 1550 g->private_data = &floppy->driver; 1551 1552 drive->driver_data = floppy; 1553 1554 idefloppy_setup(drive, floppy); 1555 1556 g->minors = 1 << PARTN_BITS; 1557 g->driverfs_dev = &drive->gendev; 1558 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0; 1559 g->fops = &idefloppy_ops; 1560 drive->attach = 1; 1561 add_disk(g); 1562 return 0; 1563 1564out_free_floppy: 1565 kfree(floppy); 1566failed: 1567 return -ENODEV; 1568} 1569 1570static void __exit idefloppy_exit(void) 1571{ 1572 driver_unregister(&idefloppy_driver.gen_driver); 1573} 1574 1575static int __init idefloppy_init(void) 1576{ 1577 printk("ide-floppy driver " IDEFLOPPY_VERSION "\n"); 1578 return driver_register(&idefloppy_driver.gen_driver); 1579} 1580 1581MODULE_ALIAS("ide:*m-floppy*"); 1582module_init(idefloppy_init); 1583module_exit(idefloppy_exit); 1584MODULE_LICENSE("GPL"); 1585MODULE_DESCRIPTION("ATAPI FLOPPY Driver"); 1586 1587