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