ide-io.c revision f9e3326dce0ef117308872cd234b903aa19aa40f
1/* 2 * IDE I/O functions 3 * 4 * Basic PIO and command management functionality. 5 * 6 * This code was split off from ide.c. See ide.c for history and original 7 * copyrights. 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the 11 * Free Software Foundation; either version 2, or (at your option) any 12 * later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * For the avoidance of doubt the "preferred form" of this code is one which 20 * is in an open non patent encumbered format. Where cryptographic key signing 21 * forms part of the process of creating an executable the information 22 * including keys needed to generate an equivalently functional executable 23 * are deemed to be part of the source code. 24 */ 25 26 27#include <linux/module.h> 28#include <linux/types.h> 29#include <linux/string.h> 30#include <linux/kernel.h> 31#include <linux/timer.h> 32#include <linux/mm.h> 33#include <linux/interrupt.h> 34#include <linux/major.h> 35#include <linux/errno.h> 36#include <linux/genhd.h> 37#include <linux/blkpg.h> 38#include <linux/slab.h> 39#include <linux/init.h> 40#include <linux/pci.h> 41#include <linux/delay.h> 42#include <linux/ide.h> 43#include <linux/hdreg.h> 44#include <linux/completion.h> 45#include <linux/reboot.h> 46#include <linux/cdrom.h> 47#include <linux/seq_file.h> 48#include <linux/device.h> 49#include <linux/kmod.h> 50#include <linux/scatterlist.h> 51#include <linux/bitops.h> 52 53#include <asm/byteorder.h> 54#include <asm/irq.h> 55#include <asm/uaccess.h> 56#include <asm/io.h> 57 58static int __ide_end_request(ide_drive_t *drive, struct request *rq, 59 int uptodate, unsigned int nr_bytes, int dequeue) 60{ 61 int ret = 1; 62 int error = 0; 63 64 if (uptodate <= 0) 65 error = uptodate ? uptodate : -EIO; 66 67 /* 68 * if failfast is set on a request, override number of sectors and 69 * complete the whole request right now 70 */ 71 if (blk_noretry_request(rq) && error) 72 nr_bytes = rq->hard_nr_sectors << 9; 73 74 if (!blk_fs_request(rq) && error && !rq->errors) 75 rq->errors = -EIO; 76 77 /* 78 * decide whether to reenable DMA -- 3 is a random magic for now, 79 * if we DMA timeout more than 3 times, just stay in PIO 80 */ 81 if ((drive->dev_flags & IDE_DFLAG_DMA_PIO_RETRY) && 82 drive->retry_pio <= 3) { 83 drive->dev_flags &= ~IDE_DFLAG_DMA_PIO_RETRY; 84 ide_dma_on(drive); 85 } 86 87 if (!__blk_end_request(rq, error, nr_bytes)) { 88 if (dequeue) 89 HWGROUP(drive)->rq = NULL; 90 ret = 0; 91 } 92 93 return ret; 94} 95 96/** 97 * ide_end_request - complete an IDE I/O 98 * @drive: IDE device for the I/O 99 * @uptodate: 100 * @nr_sectors: number of sectors completed 101 * 102 * This is our end_request wrapper function. We complete the I/O 103 * update random number input and dequeue the request, which if 104 * it was tagged may be out of order. 105 */ 106 107int ide_end_request (ide_drive_t *drive, int uptodate, int nr_sectors) 108{ 109 unsigned int nr_bytes = nr_sectors << 9; 110 struct request *rq; 111 unsigned long flags; 112 int ret = 1; 113 114 /* 115 * room for locking improvements here, the calls below don't 116 * need the queue lock held at all 117 */ 118 spin_lock_irqsave(&ide_lock, flags); 119 rq = HWGROUP(drive)->rq; 120 121 if (!nr_bytes) { 122 if (blk_pc_request(rq)) 123 nr_bytes = rq->data_len; 124 else 125 nr_bytes = rq->hard_cur_sectors << 9; 126 } 127 128 ret = __ide_end_request(drive, rq, uptodate, nr_bytes, 1); 129 130 spin_unlock_irqrestore(&ide_lock, flags); 131 return ret; 132} 133EXPORT_SYMBOL(ide_end_request); 134 135static void ide_complete_power_step(ide_drive_t *drive, struct request *rq, u8 stat, u8 error) 136{ 137 struct request_pm_state *pm = rq->data; 138 139 if (drive->media != ide_disk) 140 return; 141 142 switch (pm->pm_step) { 143 case IDE_PM_FLUSH_CACHE: /* Suspend step 1 (flush cache) */ 144 if (pm->pm_state == PM_EVENT_FREEZE) 145 pm->pm_step = IDE_PM_COMPLETED; 146 else 147 pm->pm_step = IDE_PM_STANDBY; 148 break; 149 case IDE_PM_STANDBY: /* Suspend step 2 (standby) */ 150 pm->pm_step = IDE_PM_COMPLETED; 151 break; 152 case IDE_PM_RESTORE_PIO: /* Resume step 1 (restore PIO) */ 153 pm->pm_step = IDE_PM_IDLE; 154 break; 155 case IDE_PM_IDLE: /* Resume step 2 (idle)*/ 156 pm->pm_step = IDE_PM_RESTORE_DMA; 157 break; 158 } 159} 160 161static ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq) 162{ 163 struct request_pm_state *pm = rq->data; 164 ide_task_t *args = rq->special; 165 166 memset(args, 0, sizeof(*args)); 167 168 switch (pm->pm_step) { 169 case IDE_PM_FLUSH_CACHE: /* Suspend step 1 (flush cache) */ 170 if (drive->media != ide_disk) 171 break; 172 /* Not supported? Switch to next step now. */ 173 if (ata_id_flush_enabled(drive->id) == 0 || 174 (drive->dev_flags & IDE_DFLAG_WCACHE) == 0) { 175 ide_complete_power_step(drive, rq, 0, 0); 176 return ide_stopped; 177 } 178 if (ata_id_flush_ext_enabled(drive->id)) 179 args->tf.command = ATA_CMD_FLUSH_EXT; 180 else 181 args->tf.command = ATA_CMD_FLUSH; 182 goto out_do_tf; 183 case IDE_PM_STANDBY: /* Suspend step 2 (standby) */ 184 args->tf.command = ATA_CMD_STANDBYNOW1; 185 goto out_do_tf; 186 case IDE_PM_RESTORE_PIO: /* Resume step 1 (restore PIO) */ 187 ide_set_max_pio(drive); 188 /* 189 * skip IDE_PM_IDLE for ATAPI devices 190 */ 191 if (drive->media != ide_disk) 192 pm->pm_step = IDE_PM_RESTORE_DMA; 193 else 194 ide_complete_power_step(drive, rq, 0, 0); 195 return ide_stopped; 196 case IDE_PM_IDLE: /* Resume step 2 (idle) */ 197 args->tf.command = ATA_CMD_IDLEIMMEDIATE; 198 goto out_do_tf; 199 case IDE_PM_RESTORE_DMA: /* Resume step 3 (restore DMA) */ 200 /* 201 * Right now, all we do is call ide_set_dma(drive), 202 * we could be smarter and check for current xfer_speed 203 * in struct drive etc... 204 */ 205 if (drive->hwif->dma_ops == NULL) 206 break; 207 /* 208 * TODO: respect IDE_DFLAG_USING_DMA 209 */ 210 ide_set_dma(drive); 211 break; 212 } 213 214 pm->pm_step = IDE_PM_COMPLETED; 215 return ide_stopped; 216 217out_do_tf: 218 args->tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 219 args->data_phase = TASKFILE_NO_DATA; 220 return do_rw_taskfile(drive, args); 221} 222 223/** 224 * ide_end_dequeued_request - complete an IDE I/O 225 * @drive: IDE device for the I/O 226 * @uptodate: 227 * @nr_sectors: number of sectors completed 228 * 229 * Complete an I/O that is no longer on the request queue. This 230 * typically occurs when we pull the request and issue a REQUEST_SENSE. 231 * We must still finish the old request but we must not tamper with the 232 * queue in the meantime. 233 * 234 * NOTE: This path does not handle barrier, but barrier is not supported 235 * on ide-cd anyway. 236 */ 237 238int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq, 239 int uptodate, int nr_sectors) 240{ 241 unsigned long flags; 242 int ret; 243 244 spin_lock_irqsave(&ide_lock, flags); 245 BUG_ON(!blk_rq_started(rq)); 246 ret = __ide_end_request(drive, rq, uptodate, nr_sectors << 9, 0); 247 spin_unlock_irqrestore(&ide_lock, flags); 248 249 return ret; 250} 251EXPORT_SYMBOL_GPL(ide_end_dequeued_request); 252 253 254/** 255 * ide_complete_pm_request - end the current Power Management request 256 * @drive: target drive 257 * @rq: request 258 * 259 * This function cleans up the current PM request and stops the queue 260 * if necessary. 261 */ 262static void ide_complete_pm_request (ide_drive_t *drive, struct request *rq) 263{ 264 unsigned long flags; 265 266#ifdef DEBUG_PM 267 printk("%s: completing PM request, %s\n", drive->name, 268 blk_pm_suspend_request(rq) ? "suspend" : "resume"); 269#endif 270 spin_lock_irqsave(&ide_lock, flags); 271 if (blk_pm_suspend_request(rq)) { 272 blk_stop_queue(drive->queue); 273 } else { 274 drive->dev_flags &= ~IDE_DFLAG_BLOCKED; 275 blk_start_queue(drive->queue); 276 } 277 HWGROUP(drive)->rq = NULL; 278 if (__blk_end_request(rq, 0, 0)) 279 BUG(); 280 spin_unlock_irqrestore(&ide_lock, flags); 281} 282 283/** 284 * ide_end_drive_cmd - end an explicit drive command 285 * @drive: command 286 * @stat: status bits 287 * @err: error bits 288 * 289 * Clean up after success/failure of an explicit drive command. 290 * These get thrown onto the queue so they are synchronized with 291 * real I/O operations on the drive. 292 * 293 * In LBA48 mode we have to read the register set twice to get 294 * all the extra information out. 295 */ 296 297void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err) 298{ 299 unsigned long flags; 300 struct request *rq; 301 302 spin_lock_irqsave(&ide_lock, flags); 303 rq = HWGROUP(drive)->rq; 304 spin_unlock_irqrestore(&ide_lock, flags); 305 306 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) { 307 ide_task_t *task = (ide_task_t *)rq->special; 308 309 if (rq->errors == 0) 310 rq->errors = !OK_STAT(stat, ATA_DRDY, BAD_STAT); 311 312 if (task) { 313 struct ide_taskfile *tf = &task->tf; 314 315 tf->error = err; 316 tf->status = stat; 317 318 drive->hwif->tp_ops->tf_read(drive, task); 319 320 if (task->tf_flags & IDE_TFLAG_DYN) 321 kfree(task); 322 } 323 } else if (blk_pm_request(rq)) { 324 struct request_pm_state *pm = rq->data; 325#ifdef DEBUG_PM 326 printk("%s: complete_power_step(step: %d, stat: %x, err: %x)\n", 327 drive->name, rq->pm->pm_step, stat, err); 328#endif 329 ide_complete_power_step(drive, rq, stat, err); 330 if (pm->pm_step == IDE_PM_COMPLETED) 331 ide_complete_pm_request(drive, rq); 332 return; 333 } 334 335 spin_lock_irqsave(&ide_lock, flags); 336 HWGROUP(drive)->rq = NULL; 337 rq->errors = err; 338 if (unlikely(__blk_end_request(rq, (rq->errors ? -EIO : 0), 339 blk_rq_bytes(rq)))) 340 BUG(); 341 spin_unlock_irqrestore(&ide_lock, flags); 342} 343 344EXPORT_SYMBOL(ide_end_drive_cmd); 345 346static void ide_kill_rq(ide_drive_t *drive, struct request *rq) 347{ 348 if (rq->rq_disk) { 349 ide_driver_t *drv; 350 351 drv = *(ide_driver_t **)rq->rq_disk->private_data; 352 drv->end_request(drive, 0, 0); 353 } else 354 ide_end_request(drive, 0, 0); 355} 356 357static ide_startstop_t ide_ata_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err) 358{ 359 ide_hwif_t *hwif = drive->hwif; 360 361 if ((stat & ATA_BUSY) || 362 ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) { 363 /* other bits are useless when BUSY */ 364 rq->errors |= ERROR_RESET; 365 } else if (stat & ATA_ERR) { 366 /* err has different meaning on cdrom and tape */ 367 if (err == ATA_ABORTED) { 368 if ((drive->dev_flags & IDE_DFLAG_LBA) && 369 /* some newer drives don't support ATA_CMD_INIT_DEV_PARAMS */ 370 hwif->tp_ops->read_status(hwif) == ATA_CMD_INIT_DEV_PARAMS) 371 return ide_stopped; 372 } else if ((err & BAD_CRC) == BAD_CRC) { 373 /* UDMA crc error, just retry the operation */ 374 drive->crc_count++; 375 } else if (err & (ATA_BBK | ATA_UNC)) { 376 /* retries won't help these */ 377 rq->errors = ERROR_MAX; 378 } else if (err & ATA_TRK0NF) { 379 /* help it find track zero */ 380 rq->errors |= ERROR_RECAL; 381 } 382 } 383 384 if ((stat & ATA_DRQ) && rq_data_dir(rq) == READ && 385 (hwif->host_flags & IDE_HFLAG_ERROR_STOPS_FIFO) == 0) { 386 int nsect = drive->mult_count ? drive->mult_count : 1; 387 388 ide_pad_transfer(drive, READ, nsect * SECTOR_SIZE); 389 } 390 391 if (rq->errors >= ERROR_MAX || blk_noretry_request(rq)) { 392 ide_kill_rq(drive, rq); 393 return ide_stopped; 394 } 395 396 if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ)) 397 rq->errors |= ERROR_RESET; 398 399 if ((rq->errors & ERROR_RESET) == ERROR_RESET) { 400 ++rq->errors; 401 return ide_do_reset(drive); 402 } 403 404 if ((rq->errors & ERROR_RECAL) == ERROR_RECAL) 405 drive->special.b.recalibrate = 1; 406 407 ++rq->errors; 408 409 return ide_stopped; 410} 411 412static ide_startstop_t ide_atapi_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err) 413{ 414 ide_hwif_t *hwif = drive->hwif; 415 416 if ((stat & ATA_BUSY) || 417 ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) { 418 /* other bits are useless when BUSY */ 419 rq->errors |= ERROR_RESET; 420 } else { 421 /* add decoding error stuff */ 422 } 423 424 if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ)) 425 /* force an abort */ 426 hwif->tp_ops->exec_command(hwif, ATA_CMD_IDLEIMMEDIATE); 427 428 if (rq->errors >= ERROR_MAX) { 429 ide_kill_rq(drive, rq); 430 } else { 431 if ((rq->errors & ERROR_RESET) == ERROR_RESET) { 432 ++rq->errors; 433 return ide_do_reset(drive); 434 } 435 ++rq->errors; 436 } 437 438 return ide_stopped; 439} 440 441ide_startstop_t 442__ide_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err) 443{ 444 if (drive->media == ide_disk) 445 return ide_ata_error(drive, rq, stat, err); 446 return ide_atapi_error(drive, rq, stat, err); 447} 448 449EXPORT_SYMBOL_GPL(__ide_error); 450 451/** 452 * ide_error - handle an error on the IDE 453 * @drive: drive the error occurred on 454 * @msg: message to report 455 * @stat: status bits 456 * 457 * ide_error() takes action based on the error returned by the drive. 458 * For normal I/O that may well include retries. We deal with 459 * both new-style (taskfile) and old style command handling here. 460 * In the case of taskfile command handling there is work left to 461 * do 462 */ 463 464ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, u8 stat) 465{ 466 struct request *rq; 467 u8 err; 468 469 err = ide_dump_status(drive, msg, stat); 470 471 if ((rq = HWGROUP(drive)->rq) == NULL) 472 return ide_stopped; 473 474 /* retry only "normal" I/O: */ 475 if (!blk_fs_request(rq)) { 476 rq->errors = 1; 477 ide_end_drive_cmd(drive, stat, err); 478 return ide_stopped; 479 } 480 481 if (rq->rq_disk) { 482 ide_driver_t *drv; 483 484 drv = *(ide_driver_t **)rq->rq_disk->private_data; 485 return drv->error(drive, rq, stat, err); 486 } else 487 return __ide_error(drive, rq, stat, err); 488} 489 490EXPORT_SYMBOL_GPL(ide_error); 491 492static void ide_tf_set_specify_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 493{ 494 tf->nsect = drive->sect; 495 tf->lbal = drive->sect; 496 tf->lbam = drive->cyl; 497 tf->lbah = drive->cyl >> 8; 498 tf->device = (drive->head - 1) | drive->select; 499 tf->command = ATA_CMD_INIT_DEV_PARAMS; 500} 501 502static void ide_tf_set_restore_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 503{ 504 tf->nsect = drive->sect; 505 tf->command = ATA_CMD_RESTORE; 506} 507 508static void ide_tf_set_setmult_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 509{ 510 tf->nsect = drive->mult_req; 511 tf->command = ATA_CMD_SET_MULTI; 512} 513 514static ide_startstop_t ide_disk_special(ide_drive_t *drive) 515{ 516 special_t *s = &drive->special; 517 ide_task_t args; 518 519 memset(&args, 0, sizeof(ide_task_t)); 520 args.data_phase = TASKFILE_NO_DATA; 521 522 if (s->b.set_geometry) { 523 s->b.set_geometry = 0; 524 ide_tf_set_specify_cmd(drive, &args.tf); 525 } else if (s->b.recalibrate) { 526 s->b.recalibrate = 0; 527 ide_tf_set_restore_cmd(drive, &args.tf); 528 } else if (s->b.set_multmode) { 529 s->b.set_multmode = 0; 530 ide_tf_set_setmult_cmd(drive, &args.tf); 531 } else if (s->all) { 532 int special = s->all; 533 s->all = 0; 534 printk(KERN_ERR "%s: bad special flag: 0x%02x\n", drive->name, special); 535 return ide_stopped; 536 } 537 538 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE | 539 IDE_TFLAG_CUSTOM_HANDLER; 540 541 do_rw_taskfile(drive, &args); 542 543 return ide_started; 544} 545 546/** 547 * do_special - issue some special commands 548 * @drive: drive the command is for 549 * 550 * do_special() is used to issue ATA_CMD_INIT_DEV_PARAMS, 551 * ATA_CMD_RESTORE and ATA_CMD_SET_MULTI commands to a drive. 552 * 553 * It used to do much more, but has been scaled back. 554 */ 555 556static ide_startstop_t do_special (ide_drive_t *drive) 557{ 558 special_t *s = &drive->special; 559 560#ifdef DEBUG 561 printk("%s: do_special: 0x%02x\n", drive->name, s->all); 562#endif 563 if (drive->media == ide_disk) 564 return ide_disk_special(drive); 565 566 s->all = 0; 567 drive->mult_req = 0; 568 return ide_stopped; 569} 570 571void ide_map_sg(ide_drive_t *drive, struct request *rq) 572{ 573 ide_hwif_t *hwif = drive->hwif; 574 struct scatterlist *sg = hwif->sg_table; 575 576 if (hwif->sg_mapped) /* needed by ide-scsi */ 577 return; 578 579 if (rq->cmd_type != REQ_TYPE_ATA_TASKFILE) { 580 hwif->sg_nents = blk_rq_map_sg(drive->queue, rq, sg); 581 } else { 582 sg_init_one(sg, rq->buffer, rq->nr_sectors * SECTOR_SIZE); 583 hwif->sg_nents = 1; 584 } 585} 586 587EXPORT_SYMBOL_GPL(ide_map_sg); 588 589void ide_init_sg_cmd(ide_drive_t *drive, struct request *rq) 590{ 591 ide_hwif_t *hwif = drive->hwif; 592 593 hwif->nsect = hwif->nleft = rq->nr_sectors; 594 hwif->cursg_ofs = 0; 595 hwif->cursg = NULL; 596} 597 598EXPORT_SYMBOL_GPL(ide_init_sg_cmd); 599 600/** 601 * execute_drive_command - issue special drive command 602 * @drive: the drive to issue the command on 603 * @rq: the request structure holding the command 604 * 605 * execute_drive_cmd() issues a special drive command, usually 606 * initiated by ioctl() from the external hdparm program. The 607 * command can be a drive command, drive task or taskfile 608 * operation. Weirdly you can call it with NULL to wait for 609 * all commands to finish. Don't do this as that is due to change 610 */ 611 612static ide_startstop_t execute_drive_cmd (ide_drive_t *drive, 613 struct request *rq) 614{ 615 ide_hwif_t *hwif = HWIF(drive); 616 ide_task_t *task = rq->special; 617 618 if (task) { 619 hwif->data_phase = task->data_phase; 620 621 switch (hwif->data_phase) { 622 case TASKFILE_MULTI_OUT: 623 case TASKFILE_OUT: 624 case TASKFILE_MULTI_IN: 625 case TASKFILE_IN: 626 ide_init_sg_cmd(drive, rq); 627 ide_map_sg(drive, rq); 628 default: 629 break; 630 } 631 632 return do_rw_taskfile(drive, task); 633 } 634 635 /* 636 * NULL is actually a valid way of waiting for 637 * all current requests to be flushed from the queue. 638 */ 639#ifdef DEBUG 640 printk("%s: DRIVE_CMD (null)\n", drive->name); 641#endif 642 ide_end_drive_cmd(drive, hwif->tp_ops->read_status(hwif), 643 ide_read_error(drive)); 644 645 return ide_stopped; 646} 647 648int ide_devset_execute(ide_drive_t *drive, const struct ide_devset *setting, 649 int arg) 650{ 651 struct request_queue *q = drive->queue; 652 struct request *rq; 653 int ret = 0; 654 655 if (!(setting->flags & DS_SYNC)) 656 return setting->set(drive, arg); 657 658 rq = blk_get_request(q, READ, __GFP_WAIT); 659 rq->cmd_type = REQ_TYPE_SPECIAL; 660 rq->cmd_len = 5; 661 rq->cmd[0] = REQ_DEVSET_EXEC; 662 *(int *)&rq->cmd[1] = arg; 663 rq->special = setting->set; 664 665 if (blk_execute_rq(q, NULL, rq, 0)) 666 ret = rq->errors; 667 blk_put_request(rq); 668 669 return ret; 670} 671EXPORT_SYMBOL_GPL(ide_devset_execute); 672 673static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq) 674{ 675 u8 cmd = rq->cmd[0]; 676 677 if (cmd == REQ_PARK_HEADS || cmd == REQ_UNPARK_HEADS) { 678 ide_task_t task; 679 struct ide_taskfile *tf = &task.tf; 680 681 memset(&task, 0, sizeof(task)); 682 if (cmd == REQ_PARK_HEADS) { 683 drive->sleep = *(unsigned long *)rq->special; 684 drive->dev_flags |= IDE_DFLAG_SLEEPING; 685 tf->command = ATA_CMD_IDLEIMMEDIATE; 686 tf->feature = 0x44; 687 tf->lbal = 0x4c; 688 tf->lbam = 0x4e; 689 tf->lbah = 0x55; 690 task.tf_flags |= IDE_TFLAG_CUSTOM_HANDLER; 691 } else /* cmd == REQ_UNPARK_HEADS */ 692 tf->command = ATA_CMD_CHK_POWER; 693 694 task.tf_flags |= IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 695 task.rq = rq; 696 drive->hwif->data_phase = task.data_phase = TASKFILE_NO_DATA; 697 return do_rw_taskfile(drive, &task); 698 } 699 700 switch (cmd) { 701 case REQ_DEVSET_EXEC: 702 { 703 int err, (*setfunc)(ide_drive_t *, int) = rq->special; 704 705 err = setfunc(drive, *(int *)&rq->cmd[1]); 706 if (err) 707 rq->errors = err; 708 else 709 err = 1; 710 ide_end_request(drive, err, 0); 711 return ide_stopped; 712 } 713 case REQ_DRIVE_RESET: 714 return ide_do_reset(drive); 715 default: 716 blk_dump_rq_flags(rq, "ide_special_rq - bad request"); 717 ide_end_request(drive, 0, 0); 718 return ide_stopped; 719 } 720} 721 722static void ide_check_pm_state(ide_drive_t *drive, struct request *rq) 723{ 724 struct request_pm_state *pm = rq->data; 725 726 if (blk_pm_suspend_request(rq) && 727 pm->pm_step == IDE_PM_START_SUSPEND) 728 /* Mark drive blocked when starting the suspend sequence. */ 729 drive->dev_flags |= IDE_DFLAG_BLOCKED; 730 else if (blk_pm_resume_request(rq) && 731 pm->pm_step == IDE_PM_START_RESUME) { 732 /* 733 * The first thing we do on wakeup is to wait for BSY bit to 734 * go away (with a looong timeout) as a drive on this hwif may 735 * just be POSTing itself. 736 * We do that before even selecting as the "other" device on 737 * the bus may be broken enough to walk on our toes at this 738 * point. 739 */ 740 ide_hwif_t *hwif = drive->hwif; 741 int rc; 742#ifdef DEBUG_PM 743 printk("%s: Wakeup request inited, waiting for !BSY...\n", drive->name); 744#endif 745 rc = ide_wait_not_busy(hwif, 35000); 746 if (rc) 747 printk(KERN_WARNING "%s: bus not ready on wakeup\n", drive->name); 748 SELECT_DRIVE(drive); 749 hwif->tp_ops->set_irq(hwif, 1); 750 rc = ide_wait_not_busy(hwif, 100000); 751 if (rc) 752 printk(KERN_WARNING "%s: drive not ready on wakeup\n", drive->name); 753 } 754} 755 756/** 757 * start_request - start of I/O and command issuing for IDE 758 * 759 * start_request() initiates handling of a new I/O request. It 760 * accepts commands and I/O (read/write) requests. 761 * 762 * FIXME: this function needs a rename 763 */ 764 765static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq) 766{ 767 ide_startstop_t startstop; 768 769 BUG_ON(!blk_rq_started(rq)); 770 771#ifdef DEBUG 772 printk("%s: start_request: current=0x%08lx\n", 773 HWIF(drive)->name, (unsigned long) rq); 774#endif 775 776 /* bail early if we've exceeded max_failures */ 777 if (drive->max_failures && (drive->failures > drive->max_failures)) { 778 rq->cmd_flags |= REQ_FAILED; 779 goto kill_rq; 780 } 781 782 if (blk_pm_request(rq)) 783 ide_check_pm_state(drive, rq); 784 785 SELECT_DRIVE(drive); 786 if (ide_wait_stat(&startstop, drive, drive->ready_stat, 787 ATA_BUSY | ATA_DRQ, WAIT_READY)) { 788 printk(KERN_ERR "%s: drive not ready for command\n", drive->name); 789 return startstop; 790 } 791 if (!drive->special.all) { 792 ide_driver_t *drv; 793 794 /* 795 * We reset the drive so we need to issue a SETFEATURES. 796 * Do it _after_ do_special() restored device parameters. 797 */ 798 if (drive->current_speed == 0xff) 799 ide_config_drive_speed(drive, drive->desired_speed); 800 801 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) 802 return execute_drive_cmd(drive, rq); 803 else if (blk_pm_request(rq)) { 804 struct request_pm_state *pm = rq->data; 805#ifdef DEBUG_PM 806 printk("%s: start_power_step(step: %d)\n", 807 drive->name, rq->pm->pm_step); 808#endif 809 startstop = ide_start_power_step(drive, rq); 810 if (startstop == ide_stopped && 811 pm->pm_step == IDE_PM_COMPLETED) 812 ide_complete_pm_request(drive, rq); 813 return startstop; 814 } else if (!rq->rq_disk && blk_special_request(rq)) 815 /* 816 * TODO: Once all ULDs have been modified to 817 * check for specific op codes rather than 818 * blindly accepting any special request, the 819 * check for ->rq_disk above may be replaced 820 * by a more suitable mechanism or even 821 * dropped entirely. 822 */ 823 return ide_special_rq(drive, rq); 824 825 drv = *(ide_driver_t **)rq->rq_disk->private_data; 826 827 return drv->do_request(drive, rq, rq->sector); 828 } 829 return do_special(drive); 830kill_rq: 831 ide_kill_rq(drive, rq); 832 return ide_stopped; 833} 834 835/** 836 * ide_stall_queue - pause an IDE device 837 * @drive: drive to stall 838 * @timeout: time to stall for (jiffies) 839 * 840 * ide_stall_queue() can be used by a drive to give excess bandwidth back 841 * to the hwgroup by sleeping for timeout jiffies. 842 */ 843 844void ide_stall_queue (ide_drive_t *drive, unsigned long timeout) 845{ 846 if (timeout > WAIT_WORSTCASE) 847 timeout = WAIT_WORSTCASE; 848 drive->sleep = timeout + jiffies; 849 drive->dev_flags |= IDE_DFLAG_SLEEPING; 850} 851 852EXPORT_SYMBOL(ide_stall_queue); 853 854#define WAKEUP(drive) ((drive)->service_start + 2 * (drive)->service_time) 855 856/** 857 * choose_drive - select a drive to service 858 * @hwgroup: hardware group to select on 859 * 860 * choose_drive() selects the next drive which will be serviced. 861 * This is necessary because the IDE layer can't issue commands 862 * to both drives on the same cable, unlike SCSI. 863 */ 864 865static inline ide_drive_t *choose_drive (ide_hwgroup_t *hwgroup) 866{ 867 ide_drive_t *drive, *best; 868 869repeat: 870 best = NULL; 871 drive = hwgroup->drive; 872 873 /* 874 * drive is doing pre-flush, ordered write, post-flush sequence. even 875 * though that is 3 requests, it must be seen as a single transaction. 876 * we must not preempt this drive until that is complete 877 */ 878 if (blk_queue_flushing(drive->queue)) { 879 /* 880 * small race where queue could get replugged during 881 * the 3-request flush cycle, just yank the plug since 882 * we want it to finish asap 883 */ 884 blk_remove_plug(drive->queue); 885 return drive; 886 } 887 888 do { 889 u8 dev_s = !!(drive->dev_flags & IDE_DFLAG_SLEEPING); 890 u8 best_s = (best && !!(best->dev_flags & IDE_DFLAG_SLEEPING)); 891 892 if ((dev_s == 0 || time_after_eq(jiffies, drive->sleep)) && 893 !elv_queue_empty(drive->queue)) { 894 if (best == NULL || 895 (dev_s && (best_s == 0 || time_before(drive->sleep, best->sleep))) || 896 (best_s == 0 && time_before(WAKEUP(drive), WAKEUP(best)))) { 897 if (!blk_queue_plugged(drive->queue)) 898 best = drive; 899 } 900 } 901 } while ((drive = drive->next) != hwgroup->drive); 902 903 if (best && (best->dev_flags & IDE_DFLAG_NICE1) && 904 (best->dev_flags & IDE_DFLAG_SLEEPING) == 0 && 905 best != hwgroup->drive && best->service_time > WAIT_MIN_SLEEP) { 906 long t = (signed long)(WAKEUP(best) - jiffies); 907 if (t >= WAIT_MIN_SLEEP) { 908 /* 909 * We *may* have some time to spare, but first let's see if 910 * someone can potentially benefit from our nice mood today.. 911 */ 912 drive = best->next; 913 do { 914 if ((drive->dev_flags & IDE_DFLAG_SLEEPING) == 0 915 && time_before(jiffies - best->service_time, WAKEUP(drive)) 916 && time_before(WAKEUP(drive), jiffies + t)) 917 { 918 ide_stall_queue(best, min_t(long, t, 10 * WAIT_MIN_SLEEP)); 919 goto repeat; 920 } 921 } while ((drive = drive->next) != best); 922 } 923 } 924 return best; 925} 926 927/* 928 * Issue a new request to a drive from hwgroup 929 * Caller must have already done spin_lock_irqsave(&ide_lock, ..); 930 * 931 * A hwgroup is a serialized group of IDE interfaces. Usually there is 932 * exactly one hwif (interface) per hwgroup, but buggy controllers (eg. CMD640) 933 * may have both interfaces in a single hwgroup to "serialize" access. 934 * Or possibly multiple ISA interfaces can share a common IRQ by being grouped 935 * together into one hwgroup for serialized access. 936 * 937 * Note also that several hwgroups can end up sharing a single IRQ, 938 * possibly along with many other devices. This is especially common in 939 * PCI-based systems with off-board IDE controller cards. 940 * 941 * The IDE driver uses the single global ide_lock spinlock to protect 942 * access to the request queues, and to protect the hwgroup->busy flag. 943 * 944 * The first thread into the driver for a particular hwgroup sets the 945 * hwgroup->busy flag to indicate that this hwgroup is now active, 946 * and then initiates processing of the top request from the request queue. 947 * 948 * Other threads attempting entry notice the busy setting, and will simply 949 * queue their new requests and exit immediately. Note that hwgroup->busy 950 * remains set even when the driver is merely awaiting the next interrupt. 951 * Thus, the meaning is "this hwgroup is busy processing a request". 952 * 953 * When processing of a request completes, the completing thread or IRQ-handler 954 * will start the next request from the queue. If no more work remains, 955 * the driver will clear the hwgroup->busy flag and exit. 956 * 957 * The ide_lock (spinlock) is used to protect all access to the 958 * hwgroup->busy flag, but is otherwise not needed for most processing in 959 * the driver. This makes the driver much more friendlier to shared IRQs 960 * than previous designs, while remaining 100% (?) SMP safe and capable. 961 */ 962static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq) 963{ 964 ide_drive_t *drive; 965 ide_hwif_t *hwif; 966 struct request *rq; 967 ide_startstop_t startstop; 968 int loops = 0; 969 970 /* caller must own ide_lock */ 971 BUG_ON(!irqs_disabled()); 972 973 while (!hwgroup->busy) { 974 hwgroup->busy = 1; 975 /* for atari only */ 976 ide_get_lock(ide_intr, hwgroup); 977 drive = choose_drive(hwgroup); 978 if (drive == NULL) { 979 int sleeping = 0; 980 unsigned long sleep = 0; /* shut up, gcc */ 981 hwgroup->rq = NULL; 982 drive = hwgroup->drive; 983 do { 984 if ((drive->dev_flags & IDE_DFLAG_SLEEPING) && 985 (sleeping == 0 || 986 time_before(drive->sleep, sleep))) { 987 sleeping = 1; 988 sleep = drive->sleep; 989 } 990 } while ((drive = drive->next) != hwgroup->drive); 991 if (sleeping) { 992 /* 993 * Take a short snooze, and then wake up this hwgroup again. 994 * This gives other hwgroups on the same a chance to 995 * play fairly with us, just in case there are big differences 996 * in relative throughputs.. don't want to hog the cpu too much. 997 */ 998 if (time_before(sleep, jiffies + WAIT_MIN_SLEEP)) 999 sleep = jiffies + WAIT_MIN_SLEEP; 1000#if 1 1001 if (timer_pending(&hwgroup->timer)) 1002 printk(KERN_CRIT "ide_set_handler: timer already active\n"); 1003#endif 1004 /* so that ide_timer_expiry knows what to do */ 1005 hwgroup->sleeping = 1; 1006 hwgroup->req_gen_timer = hwgroup->req_gen; 1007 mod_timer(&hwgroup->timer, sleep); 1008 /* we purposely leave hwgroup->busy==1 1009 * while sleeping */ 1010 } else { 1011 /* Ugly, but how can we sleep for the lock 1012 * otherwise? perhaps from tq_disk? 1013 */ 1014 1015 /* for atari only */ 1016 ide_release_lock(); 1017 hwgroup->busy = 0; 1018 } 1019 1020 /* no more work for this hwgroup (for now) */ 1021 return; 1022 } 1023 again: 1024 hwif = HWIF(drive); 1025 if (hwgroup->hwif->sharing_irq && hwif != hwgroup->hwif) { 1026 /* 1027 * set nIEN for previous hwif, drives in the 1028 * quirk_list may not like intr setups/cleanups 1029 */ 1030 if (drive->quirk_list != 1) 1031 hwif->tp_ops->set_irq(hwif, 0); 1032 } 1033 hwgroup->hwif = hwif; 1034 hwgroup->drive = drive; 1035 drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED); 1036 drive->service_start = jiffies; 1037 1038 if (blk_queue_plugged(drive->queue)) { 1039 printk(KERN_ERR "ide: huh? queue was plugged!\n"); 1040 break; 1041 } 1042 1043 /* 1044 * we know that the queue isn't empty, but this can happen 1045 * if the q->prep_rq_fn() decides to kill a request 1046 */ 1047 rq = elv_next_request(drive->queue); 1048 if (!rq) { 1049 hwgroup->busy = 0; 1050 break; 1051 } 1052 1053 /* 1054 * Sanity: don't accept a request that isn't a PM request 1055 * if we are currently power managed. This is very important as 1056 * blk_stop_queue() doesn't prevent the elv_next_request() 1057 * above to return us whatever is in the queue. Since we call 1058 * ide_do_request() ourselves, we end up taking requests while 1059 * the queue is blocked... 1060 * 1061 * We let requests forced at head of queue with ide-preempt 1062 * though. I hope that doesn't happen too much, hopefully not 1063 * unless the subdriver triggers such a thing in its own PM 1064 * state machine. 1065 * 1066 * We count how many times we loop here to make sure we service 1067 * all drives in the hwgroup without looping for ever 1068 */ 1069 if ((drive->dev_flags & IDE_DFLAG_BLOCKED) && 1070 blk_pm_request(rq) == 0 && 1071 (rq->cmd_flags & REQ_PREEMPT) == 0) { 1072 drive = drive->next ? drive->next : hwgroup->drive; 1073 if (loops++ < 4 && !blk_queue_plugged(drive->queue)) 1074 goto again; 1075 /* We clear busy, there should be no pending ATA command at this point. */ 1076 hwgroup->busy = 0; 1077 break; 1078 } 1079 1080 hwgroup->rq = rq; 1081 1082 /* 1083 * Some systems have trouble with IDE IRQs arriving while 1084 * the driver is still setting things up. So, here we disable 1085 * the IRQ used by this interface while the request is being started. 1086 * This may look bad at first, but pretty much the same thing 1087 * happens anyway when any interrupt comes in, IDE or otherwise 1088 * -- the kernel masks the IRQ while it is being handled. 1089 */ 1090 if (masked_irq != IDE_NO_IRQ && hwif->irq != masked_irq) 1091 disable_irq_nosync(hwif->irq); 1092 spin_unlock(&ide_lock); 1093 local_irq_enable_in_hardirq(); 1094 /* allow other IRQs while we start this request */ 1095 startstop = start_request(drive, rq); 1096 spin_lock_irq(&ide_lock); 1097 if (masked_irq != IDE_NO_IRQ && hwif->irq != masked_irq) 1098 enable_irq(hwif->irq); 1099 if (startstop == ide_stopped) 1100 hwgroup->busy = 0; 1101 } 1102} 1103 1104/* 1105 * Passes the stuff to ide_do_request 1106 */ 1107void do_ide_request(struct request_queue *q) 1108{ 1109 ide_drive_t *drive = q->queuedata; 1110 1111 ide_do_request(HWGROUP(drive), IDE_NO_IRQ); 1112} 1113 1114/* 1115 * un-busy the hwgroup etc, and clear any pending DMA status. we want to 1116 * retry the current request in pio mode instead of risking tossing it 1117 * all away 1118 */ 1119static ide_startstop_t ide_dma_timeout_retry(ide_drive_t *drive, int error) 1120{ 1121 ide_hwif_t *hwif = HWIF(drive); 1122 struct request *rq; 1123 ide_startstop_t ret = ide_stopped; 1124 1125 /* 1126 * end current dma transaction 1127 */ 1128 1129 if (error < 0) { 1130 printk(KERN_WARNING "%s: DMA timeout error\n", drive->name); 1131 (void)hwif->dma_ops->dma_end(drive); 1132 ret = ide_error(drive, "dma timeout error", 1133 hwif->tp_ops->read_status(hwif)); 1134 } else { 1135 printk(KERN_WARNING "%s: DMA timeout retry\n", drive->name); 1136 hwif->dma_ops->dma_timeout(drive); 1137 } 1138 1139 /* 1140 * disable dma for now, but remember that we did so because of 1141 * a timeout -- we'll reenable after we finish this next request 1142 * (or rather the first chunk of it) in pio. 1143 */ 1144 drive->dev_flags |= IDE_DFLAG_DMA_PIO_RETRY; 1145 drive->retry_pio++; 1146 ide_dma_off_quietly(drive); 1147 1148 /* 1149 * un-busy drive etc (hwgroup->busy is cleared on return) and 1150 * make sure request is sane 1151 */ 1152 rq = HWGROUP(drive)->rq; 1153 1154 if (!rq) 1155 goto out; 1156 1157 HWGROUP(drive)->rq = NULL; 1158 1159 rq->errors = 0; 1160 1161 if (!rq->bio) 1162 goto out; 1163 1164 rq->sector = rq->bio->bi_sector; 1165 rq->current_nr_sectors = bio_iovec(rq->bio)->bv_len >> 9; 1166 rq->hard_cur_sectors = rq->current_nr_sectors; 1167 rq->buffer = bio_data(rq->bio); 1168out: 1169 return ret; 1170} 1171 1172/** 1173 * ide_timer_expiry - handle lack of an IDE interrupt 1174 * @data: timer callback magic (hwgroup) 1175 * 1176 * An IDE command has timed out before the expected drive return 1177 * occurred. At this point we attempt to clean up the current 1178 * mess. If the current handler includes an expiry handler then 1179 * we invoke the expiry handler, and providing it is happy the 1180 * work is done. If that fails we apply generic recovery rules 1181 * invoking the handler and checking the drive DMA status. We 1182 * have an excessively incestuous relationship with the DMA 1183 * logic that wants cleaning up. 1184 */ 1185 1186void ide_timer_expiry (unsigned long data) 1187{ 1188 ide_hwgroup_t *hwgroup = (ide_hwgroup_t *) data; 1189 ide_handler_t *handler; 1190 ide_expiry_t *expiry; 1191 unsigned long flags; 1192 unsigned long wait = -1; 1193 1194 spin_lock_irqsave(&ide_lock, flags); 1195 1196 if (((handler = hwgroup->handler) == NULL) || 1197 (hwgroup->req_gen != hwgroup->req_gen_timer)) { 1198 /* 1199 * Either a marginal timeout occurred 1200 * (got the interrupt just as timer expired), 1201 * or we were "sleeping" to give other devices a chance. 1202 * Either way, we don't really want to complain about anything. 1203 */ 1204 if (hwgroup->sleeping) { 1205 hwgroup->sleeping = 0; 1206 hwgroup->busy = 0; 1207 } 1208 } else { 1209 ide_drive_t *drive = hwgroup->drive; 1210 if (!drive) { 1211 printk(KERN_ERR "ide_timer_expiry: hwgroup->drive was NULL\n"); 1212 hwgroup->handler = NULL; 1213 } else { 1214 ide_hwif_t *hwif; 1215 ide_startstop_t startstop = ide_stopped; 1216 if (!hwgroup->busy) { 1217 hwgroup->busy = 1; /* paranoia */ 1218 printk(KERN_ERR "%s: ide_timer_expiry: hwgroup->busy was 0 ??\n", drive->name); 1219 } 1220 if ((expiry = hwgroup->expiry) != NULL) { 1221 /* continue */ 1222 if ((wait = expiry(drive)) > 0) { 1223 /* reset timer */ 1224 hwgroup->timer.expires = jiffies + wait; 1225 hwgroup->req_gen_timer = hwgroup->req_gen; 1226 add_timer(&hwgroup->timer); 1227 spin_unlock_irqrestore(&ide_lock, flags); 1228 return; 1229 } 1230 } 1231 hwgroup->handler = NULL; 1232 /* 1233 * We need to simulate a real interrupt when invoking 1234 * the handler() function, which means we need to 1235 * globally mask the specific IRQ: 1236 */ 1237 spin_unlock(&ide_lock); 1238 hwif = HWIF(drive); 1239 /* disable_irq_nosync ?? */ 1240 disable_irq(hwif->irq); 1241 /* local CPU only, 1242 * as if we were handling an interrupt */ 1243 local_irq_disable(); 1244 if (hwgroup->polling) { 1245 startstop = handler(drive); 1246 } else if (drive_is_ready(drive)) { 1247 if (drive->waiting_for_dma) 1248 hwif->dma_ops->dma_lost_irq(drive); 1249 (void)ide_ack_intr(hwif); 1250 printk(KERN_WARNING "%s: lost interrupt\n", drive->name); 1251 startstop = handler(drive); 1252 } else { 1253 if (drive->waiting_for_dma) { 1254 startstop = ide_dma_timeout_retry(drive, wait); 1255 } else 1256 startstop = 1257 ide_error(drive, "irq timeout", 1258 hwif->tp_ops->read_status(hwif)); 1259 } 1260 drive->service_time = jiffies - drive->service_start; 1261 spin_lock_irq(&ide_lock); 1262 enable_irq(hwif->irq); 1263 if (startstop == ide_stopped) 1264 hwgroup->busy = 0; 1265 } 1266 } 1267 ide_do_request(hwgroup, IDE_NO_IRQ); 1268 spin_unlock_irqrestore(&ide_lock, flags); 1269} 1270 1271/** 1272 * unexpected_intr - handle an unexpected IDE interrupt 1273 * @irq: interrupt line 1274 * @hwgroup: hwgroup being processed 1275 * 1276 * There's nothing really useful we can do with an unexpected interrupt, 1277 * other than reading the status register (to clear it), and logging it. 1278 * There should be no way that an irq can happen before we're ready for it, 1279 * so we needn't worry much about losing an "important" interrupt here. 1280 * 1281 * On laptops (and "green" PCs), an unexpected interrupt occurs whenever 1282 * the drive enters "idle", "standby", or "sleep" mode, so if the status 1283 * looks "good", we just ignore the interrupt completely. 1284 * 1285 * This routine assumes __cli() is in effect when called. 1286 * 1287 * If an unexpected interrupt happens on irq15 while we are handling irq14 1288 * and if the two interfaces are "serialized" (CMD640), then it looks like 1289 * we could screw up by interfering with a new request being set up for 1290 * irq15. 1291 * 1292 * In reality, this is a non-issue. The new command is not sent unless 1293 * the drive is ready to accept one, in which case we know the drive is 1294 * not trying to interrupt us. And ide_set_handler() is always invoked 1295 * before completing the issuance of any new drive command, so we will not 1296 * be accidentally invoked as a result of any valid command completion 1297 * interrupt. 1298 * 1299 * Note that we must walk the entire hwgroup here. We know which hwif 1300 * is doing the current command, but we don't know which hwif burped 1301 * mysteriously. 1302 */ 1303 1304static void unexpected_intr (int irq, ide_hwgroup_t *hwgroup) 1305{ 1306 u8 stat; 1307 ide_hwif_t *hwif = hwgroup->hwif; 1308 1309 /* 1310 * handle the unexpected interrupt 1311 */ 1312 do { 1313 if (hwif->irq == irq) { 1314 stat = hwif->tp_ops->read_status(hwif); 1315 1316 if (!OK_STAT(stat, ATA_DRDY, BAD_STAT)) { 1317 /* Try to not flood the console with msgs */ 1318 static unsigned long last_msgtime, count; 1319 ++count; 1320 if (time_after(jiffies, last_msgtime + HZ)) { 1321 last_msgtime = jiffies; 1322 printk(KERN_ERR "%s%s: unexpected interrupt, " 1323 "status=0x%02x, count=%ld\n", 1324 hwif->name, 1325 (hwif->next==hwgroup->hwif) ? "" : "(?)", stat, count); 1326 } 1327 } 1328 } 1329 } while ((hwif = hwif->next) != hwgroup->hwif); 1330} 1331 1332/** 1333 * ide_intr - default IDE interrupt handler 1334 * @irq: interrupt number 1335 * @dev_id: hwif group 1336 * @regs: unused weirdness from the kernel irq layer 1337 * 1338 * This is the default IRQ handler for the IDE layer. You should 1339 * not need to override it. If you do be aware it is subtle in 1340 * places 1341 * 1342 * hwgroup->hwif is the interface in the group currently performing 1343 * a command. hwgroup->drive is the drive and hwgroup->handler is 1344 * the IRQ handler to call. As we issue a command the handlers 1345 * step through multiple states, reassigning the handler to the 1346 * next step in the process. Unlike a smart SCSI controller IDE 1347 * expects the main processor to sequence the various transfer 1348 * stages. We also manage a poll timer to catch up with most 1349 * timeout situations. There are still a few where the handlers 1350 * don't ever decide to give up. 1351 * 1352 * The handler eventually returns ide_stopped to indicate the 1353 * request completed. At this point we issue the next request 1354 * on the hwgroup and the process begins again. 1355 */ 1356 1357irqreturn_t ide_intr (int irq, void *dev_id) 1358{ 1359 unsigned long flags; 1360 ide_hwgroup_t *hwgroup = (ide_hwgroup_t *)dev_id; 1361 ide_hwif_t *hwif; 1362 ide_drive_t *drive; 1363 ide_handler_t *handler; 1364 ide_startstop_t startstop; 1365 1366 spin_lock_irqsave(&ide_lock, flags); 1367 hwif = hwgroup->hwif; 1368 1369 if (!ide_ack_intr(hwif)) { 1370 spin_unlock_irqrestore(&ide_lock, flags); 1371 return IRQ_NONE; 1372 } 1373 1374 if ((handler = hwgroup->handler) == NULL || hwgroup->polling) { 1375 /* 1376 * Not expecting an interrupt from this drive. 1377 * That means this could be: 1378 * (1) an interrupt from another PCI device 1379 * sharing the same PCI INT# as us. 1380 * or (2) a drive just entered sleep or standby mode, 1381 * and is interrupting to let us know. 1382 * or (3) a spurious interrupt of unknown origin. 1383 * 1384 * For PCI, we cannot tell the difference, 1385 * so in that case we just ignore it and hope it goes away. 1386 * 1387 * FIXME: unexpected_intr should be hwif-> then we can 1388 * remove all the ifdef PCI crap 1389 */ 1390#ifdef CONFIG_BLK_DEV_IDEPCI 1391 if (hwif->chipset != ide_pci) 1392#endif /* CONFIG_BLK_DEV_IDEPCI */ 1393 { 1394 /* 1395 * Probably not a shared PCI interrupt, 1396 * so we can safely try to do something about it: 1397 */ 1398 unexpected_intr(irq, hwgroup); 1399#ifdef CONFIG_BLK_DEV_IDEPCI 1400 } else { 1401 /* 1402 * Whack the status register, just in case 1403 * we have a leftover pending IRQ. 1404 */ 1405 (void)hwif->tp_ops->read_status(hwif); 1406#endif /* CONFIG_BLK_DEV_IDEPCI */ 1407 } 1408 spin_unlock_irqrestore(&ide_lock, flags); 1409 return IRQ_NONE; 1410 } 1411 drive = hwgroup->drive; 1412 if (!drive) { 1413 /* 1414 * This should NEVER happen, and there isn't much 1415 * we could do about it here. 1416 * 1417 * [Note - this can occur if the drive is hot unplugged] 1418 */ 1419 spin_unlock_irqrestore(&ide_lock, flags); 1420 return IRQ_HANDLED; 1421 } 1422 if (!drive_is_ready(drive)) { 1423 /* 1424 * This happens regularly when we share a PCI IRQ with 1425 * another device. Unfortunately, it can also happen 1426 * with some buggy drives that trigger the IRQ before 1427 * their status register is up to date. Hopefully we have 1428 * enough advance overhead that the latter isn't a problem. 1429 */ 1430 spin_unlock_irqrestore(&ide_lock, flags); 1431 return IRQ_NONE; 1432 } 1433 if (!hwgroup->busy) { 1434 hwgroup->busy = 1; /* paranoia */ 1435 printk(KERN_ERR "%s: ide_intr: hwgroup->busy was 0 ??\n", drive->name); 1436 } 1437 hwgroup->handler = NULL; 1438 hwgroup->req_gen++; 1439 del_timer(&hwgroup->timer); 1440 spin_unlock(&ide_lock); 1441 1442 if (hwif->port_ops && hwif->port_ops->clear_irq) 1443 hwif->port_ops->clear_irq(drive); 1444 1445 if (drive->dev_flags & IDE_DFLAG_UNMASK) 1446 local_irq_enable_in_hardirq(); 1447 1448 /* service this interrupt, may set handler for next interrupt */ 1449 startstop = handler(drive); 1450 1451 spin_lock_irq(&ide_lock); 1452 /* 1453 * Note that handler() may have set things up for another 1454 * interrupt to occur soon, but it cannot happen until 1455 * we exit from this routine, because it will be the 1456 * same irq as is currently being serviced here, and Linux 1457 * won't allow another of the same (on any CPU) until we return. 1458 */ 1459 drive->service_time = jiffies - drive->service_start; 1460 if (startstop == ide_stopped) { 1461 if (hwgroup->handler == NULL) { /* paranoia */ 1462 hwgroup->busy = 0; 1463 ide_do_request(hwgroup, hwif->irq); 1464 } else { 1465 printk(KERN_ERR "%s: ide_intr: huh? expected NULL handler " 1466 "on exit\n", drive->name); 1467 } 1468 } 1469 spin_unlock_irqrestore(&ide_lock, flags); 1470 return IRQ_HANDLED; 1471} 1472 1473/** 1474 * ide_do_drive_cmd - issue IDE special command 1475 * @drive: device to issue command 1476 * @rq: request to issue 1477 * 1478 * This function issues a special IDE device request 1479 * onto the request queue. 1480 * 1481 * the rq is queued at the head of the request queue, displacing 1482 * the currently-being-processed request and this function 1483 * returns immediately without waiting for the new rq to be 1484 * completed. This is VERY DANGEROUS, and is intended for 1485 * careful use by the ATAPI tape/cdrom driver code. 1486 */ 1487 1488void ide_do_drive_cmd(ide_drive_t *drive, struct request *rq) 1489{ 1490 unsigned long flags; 1491 ide_hwgroup_t *hwgroup = HWGROUP(drive); 1492 1493 spin_lock_irqsave(&ide_lock, flags); 1494 hwgroup->rq = NULL; 1495 __elv_add_request(drive->queue, rq, ELEVATOR_INSERT_FRONT, 0); 1496 blk_start_queueing(drive->queue); 1497 spin_unlock_irqrestore(&ide_lock, flags); 1498} 1499 1500EXPORT_SYMBOL(ide_do_drive_cmd); 1501 1502void ide_pktcmd_tf_load(ide_drive_t *drive, u32 tf_flags, u16 bcount, u8 dma) 1503{ 1504 ide_hwif_t *hwif = drive->hwif; 1505 ide_task_t task; 1506 1507 memset(&task, 0, sizeof(task)); 1508 task.tf_flags = IDE_TFLAG_OUT_LBAH | IDE_TFLAG_OUT_LBAM | 1509 IDE_TFLAG_OUT_FEATURE | tf_flags; 1510 task.tf.feature = dma; /* Use PIO/DMA */ 1511 task.tf.lbam = bcount & 0xff; 1512 task.tf.lbah = (bcount >> 8) & 0xff; 1513 1514 ide_tf_dump(drive->name, &task.tf); 1515 hwif->tp_ops->set_irq(hwif, 1); 1516 SELECT_MASK(drive, 0); 1517 hwif->tp_ops->tf_load(drive, &task); 1518} 1519 1520EXPORT_SYMBOL_GPL(ide_pktcmd_tf_load); 1521 1522void ide_pad_transfer(ide_drive_t *drive, int write, int len) 1523{ 1524 ide_hwif_t *hwif = drive->hwif; 1525 u8 buf[4] = { 0 }; 1526 1527 while (len > 0) { 1528 if (write) 1529 hwif->tp_ops->output_data(drive, NULL, buf, min(4, len)); 1530 else 1531 hwif->tp_ops->input_data(drive, NULL, buf, min(4, len)); 1532 len -= 4; 1533 } 1534} 1535EXPORT_SYMBOL_GPL(ide_pad_transfer); 1536