ide-taskfile.c revision 154ed280e3f48995d0689b57f10b7063add63019
1/* 2 * Copyright (C) 2000-2002 Michael Cornwell <cornwell@acm.org> 3 * Copyright (C) 2000-2002 Andre Hedrick <andre@linux-ide.org> 4 * Copyright (C) 2001-2002 Klaus Smolin 5 * IBM Storage Technology Division 6 * Copyright (C) 2003-2004, 2007 Bartlomiej Zolnierkiewicz 7 * 8 * The big the bad and the ugly. 9 */ 10 11#include <linux/module.h> 12#include <linux/types.h> 13#include <linux/string.h> 14#include <linux/kernel.h> 15#include <linux/timer.h> 16#include <linux/mm.h> 17#include <linux/sched.h> 18#include <linux/interrupt.h> 19#include <linux/major.h> 20#include <linux/errno.h> 21#include <linux/genhd.h> 22#include <linux/blkpg.h> 23#include <linux/slab.h> 24#include <linux/pci.h> 25#include <linux/delay.h> 26#include <linux/hdreg.h> 27#include <linux/ide.h> 28#include <linux/bitops.h> 29#include <linux/scatterlist.h> 30 31#include <asm/byteorder.h> 32#include <asm/irq.h> 33#include <asm/uaccess.h> 34#include <asm/io.h> 35 36void ide_tf_dump(const char *s, struct ide_taskfile *tf) 37{ 38#ifdef DEBUG 39 printk("%s: tf: feat 0x%02x nsect 0x%02x lbal 0x%02x " 40 "lbam 0x%02x lbah 0x%02x dev 0x%02x cmd 0x%02x\n", 41 s, tf->feature, tf->nsect, tf->lbal, 42 tf->lbam, tf->lbah, tf->device, tf->command); 43 printk("%s: hob: nsect 0x%02x lbal 0x%02x " 44 "lbam 0x%02x lbah 0x%02x\n", 45 s, tf->hob_nsect, tf->hob_lbal, 46 tf->hob_lbam, tf->hob_lbah); 47#endif 48} 49 50int taskfile_lib_get_identify (ide_drive_t *drive, u8 *buf) 51{ 52 ide_task_t args; 53 54 memset(&args, 0, sizeof(ide_task_t)); 55 args.tf.nsect = 0x01; 56 if (drive->media == ide_disk) 57 args.tf.command = WIN_IDENTIFY; 58 else 59 args.tf.command = WIN_PIDENTIFY; 60 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 61 args.data_phase = TASKFILE_IN; 62 return ide_raw_taskfile(drive, &args, buf, 1); 63} 64 65static int inline task_dma_ok(ide_task_t *task) 66{ 67 if (blk_fs_request(task->rq) || (task->tf_flags & IDE_TFLAG_FLAGGED)) 68 return 1; 69 70 switch (task->tf.command) { 71 case WIN_WRITEDMA_ONCE: 72 case WIN_WRITEDMA: 73 case WIN_WRITEDMA_EXT: 74 case WIN_READDMA_ONCE: 75 case WIN_READDMA: 76 case WIN_READDMA_EXT: 77 case WIN_IDENTIFY_DMA: 78 return 1; 79 } 80 81 return 0; 82} 83 84static ide_startstop_t task_no_data_intr(ide_drive_t *); 85static ide_startstop_t set_geometry_intr(ide_drive_t *); 86static ide_startstop_t recal_intr(ide_drive_t *); 87static ide_startstop_t set_multmode_intr(ide_drive_t *); 88static ide_startstop_t pre_task_out_intr(ide_drive_t *, struct request *); 89static ide_startstop_t task_in_intr(ide_drive_t *); 90 91ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task) 92{ 93 ide_hwif_t *hwif = HWIF(drive); 94 struct ide_taskfile *tf = &task->tf; 95 ide_handler_t *handler = NULL; 96 const struct ide_dma_ops *dma_ops = hwif->dma_ops; 97 98 if (task->data_phase == TASKFILE_MULTI_IN || 99 task->data_phase == TASKFILE_MULTI_OUT) { 100 if (!drive->mult_count) { 101 printk(KERN_ERR "%s: multimode not set!\n", 102 drive->name); 103 return ide_stopped; 104 } 105 } 106 107 if (task->tf_flags & IDE_TFLAG_FLAGGED) 108 task->tf_flags |= IDE_TFLAG_FLAGGED_SET_IN_FLAGS; 109 110 if ((task->tf_flags & IDE_TFLAG_DMA_PIO_FALLBACK) == 0) { 111 ide_tf_dump(drive->name, tf); 112 hwif->tf_load(drive, task); 113 } 114 115 switch (task->data_phase) { 116 case TASKFILE_MULTI_OUT: 117 case TASKFILE_OUT: 118 hwif->OUTBSYNC(drive, tf->command, hwif->io_ports.command_addr); 119 ndelay(400); /* FIXME */ 120 return pre_task_out_intr(drive, task->rq); 121 case TASKFILE_MULTI_IN: 122 case TASKFILE_IN: 123 handler = task_in_intr; 124 /* fall-through */ 125 case TASKFILE_NO_DATA: 126 if (handler == NULL) 127 handler = task_no_data_intr; 128 /* WIN_{SPECIFY,RESTORE,SETMULT} use custom handlers */ 129 if (task->tf_flags & IDE_TFLAG_CUSTOM_HANDLER) { 130 switch (tf->command) { 131 case WIN_SPECIFY: handler = set_geometry_intr; break; 132 case WIN_RESTORE: handler = recal_intr; break; 133 case WIN_SETMULT: handler = set_multmode_intr; break; 134 } 135 } 136 ide_execute_command(drive, tf->command, handler, 137 WAIT_WORSTCASE, NULL); 138 return ide_started; 139 default: 140 if (task_dma_ok(task) == 0 || drive->using_dma == 0 || 141 dma_ops->dma_setup(drive)) 142 return ide_stopped; 143 dma_ops->dma_exec_cmd(drive, tf->command); 144 dma_ops->dma_start(drive); 145 return ide_started; 146 } 147} 148EXPORT_SYMBOL_GPL(do_rw_taskfile); 149 150/* 151 * set_multmode_intr() is invoked on completion of a WIN_SETMULT cmd. 152 */ 153static ide_startstop_t set_multmode_intr(ide_drive_t *drive) 154{ 155 u8 stat = ide_read_status(drive); 156 157 if (OK_STAT(stat, READY_STAT, BAD_STAT)) 158 drive->mult_count = drive->mult_req; 159 else { 160 drive->mult_req = drive->mult_count = 0; 161 drive->special.b.recalibrate = 1; 162 (void) ide_dump_status(drive, "set_multmode", stat); 163 } 164 return ide_stopped; 165} 166 167/* 168 * set_geometry_intr() is invoked on completion of a WIN_SPECIFY cmd. 169 */ 170static ide_startstop_t set_geometry_intr(ide_drive_t *drive) 171{ 172 int retries = 5; 173 u8 stat; 174 175 while (((stat = ide_read_status(drive)) & BUSY_STAT) && retries--) 176 udelay(10); 177 178 if (OK_STAT(stat, READY_STAT, BAD_STAT)) 179 return ide_stopped; 180 181 if (stat & (ERR_STAT|DRQ_STAT)) 182 return ide_error(drive, "set_geometry_intr", stat); 183 184 BUG_ON(HWGROUP(drive)->handler != NULL); 185 ide_set_handler(drive, &set_geometry_intr, WAIT_WORSTCASE, NULL); 186 return ide_started; 187} 188 189/* 190 * recal_intr() is invoked on completion of a WIN_RESTORE (recalibrate) cmd. 191 */ 192static ide_startstop_t recal_intr(ide_drive_t *drive) 193{ 194 u8 stat = ide_read_status(drive); 195 196 if (!OK_STAT(stat, READY_STAT, BAD_STAT)) 197 return ide_error(drive, "recal_intr", stat); 198 return ide_stopped; 199} 200 201/* 202 * Handler for commands without a data phase 203 */ 204static ide_startstop_t task_no_data_intr(ide_drive_t *drive) 205{ 206 ide_task_t *args = HWGROUP(drive)->rq->special; 207 u8 stat; 208 209 local_irq_enable_in_hardirq(); 210 stat = ide_read_status(drive); 211 212 if (!OK_STAT(stat, READY_STAT, BAD_STAT)) 213 return ide_error(drive, "task_no_data_intr", stat); 214 /* calls ide_end_drive_cmd */ 215 216 if (args) 217 ide_end_drive_cmd(drive, stat, ide_read_error(drive)); 218 219 return ide_stopped; 220} 221 222static u8 wait_drive_not_busy(ide_drive_t *drive) 223{ 224 int retries; 225 u8 stat; 226 227 /* 228 * Last sector was transfered, wait until device is ready. This can 229 * take up to 6 ms on some ATAPI devices, so we will wait max 10 ms. 230 */ 231 for (retries = 0; retries < 1000; retries++) { 232 stat = ide_read_status(drive); 233 234 if (stat & BUSY_STAT) 235 udelay(10); 236 else 237 break; 238 } 239 240 if (stat & BUSY_STAT) 241 printk(KERN_ERR "%s: drive still BUSY!\n", drive->name); 242 243 return stat; 244} 245 246static void ide_pio_sector(ide_drive_t *drive, struct request *rq, 247 unsigned int write) 248{ 249 ide_hwif_t *hwif = drive->hwif; 250 struct scatterlist *sg = hwif->sg_table; 251 struct scatterlist *cursg = hwif->cursg; 252 struct page *page; 253#ifdef CONFIG_HIGHMEM 254 unsigned long flags; 255#endif 256 unsigned int offset; 257 u8 *buf; 258 259 cursg = hwif->cursg; 260 if (!cursg) { 261 cursg = sg; 262 hwif->cursg = sg; 263 } 264 265 page = sg_page(cursg); 266 offset = cursg->offset + hwif->cursg_ofs * SECTOR_SIZE; 267 268 /* get the current page and offset */ 269 page = nth_page(page, (offset >> PAGE_SHIFT)); 270 offset %= PAGE_SIZE; 271 272#ifdef CONFIG_HIGHMEM 273 local_irq_save(flags); 274#endif 275 buf = kmap_atomic(page, KM_BIO_SRC_IRQ) + offset; 276 277 hwif->nleft--; 278 hwif->cursg_ofs++; 279 280 if ((hwif->cursg_ofs * SECTOR_SIZE) == cursg->length) { 281 hwif->cursg = sg_next(hwif->cursg); 282 hwif->cursg_ofs = 0; 283 } 284 285 /* do the actual data transfer */ 286 if (write) 287 hwif->output_data(drive, rq, buf, SECTOR_SIZE); 288 else 289 hwif->input_data(drive, rq, buf, SECTOR_SIZE); 290 291 kunmap_atomic(buf, KM_BIO_SRC_IRQ); 292#ifdef CONFIG_HIGHMEM 293 local_irq_restore(flags); 294#endif 295} 296 297static void ide_pio_multi(ide_drive_t *drive, struct request *rq, 298 unsigned int write) 299{ 300 unsigned int nsect; 301 302 nsect = min_t(unsigned int, drive->hwif->nleft, drive->mult_count); 303 while (nsect--) 304 ide_pio_sector(drive, rq, write); 305} 306 307static void ide_pio_datablock(ide_drive_t *drive, struct request *rq, 308 unsigned int write) 309{ 310 u8 saved_io_32bit = drive->io_32bit; 311 312 if (rq->bio) /* fs request */ 313 rq->errors = 0; 314 315 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) { 316 ide_task_t *task = rq->special; 317 318 if (task->tf_flags & IDE_TFLAG_IO_16BIT) 319 drive->io_32bit = 0; 320 } 321 322 touch_softlockup_watchdog(); 323 324 switch (drive->hwif->data_phase) { 325 case TASKFILE_MULTI_IN: 326 case TASKFILE_MULTI_OUT: 327 ide_pio_multi(drive, rq, write); 328 break; 329 default: 330 ide_pio_sector(drive, rq, write); 331 break; 332 } 333 334 drive->io_32bit = saved_io_32bit; 335} 336 337static ide_startstop_t task_error(ide_drive_t *drive, struct request *rq, 338 const char *s, u8 stat) 339{ 340 if (rq->bio) { 341 ide_hwif_t *hwif = drive->hwif; 342 int sectors = hwif->nsect - hwif->nleft; 343 344 switch (hwif->data_phase) { 345 case TASKFILE_IN: 346 if (hwif->nleft) 347 break; 348 /* fall through */ 349 case TASKFILE_OUT: 350 sectors--; 351 break; 352 case TASKFILE_MULTI_IN: 353 if (hwif->nleft) 354 break; 355 /* fall through */ 356 case TASKFILE_MULTI_OUT: 357 sectors -= drive->mult_count; 358 default: 359 break; 360 } 361 362 if (sectors > 0) { 363 ide_driver_t *drv; 364 365 drv = *(ide_driver_t **)rq->rq_disk->private_data; 366 drv->end_request(drive, 1, sectors); 367 } 368 } 369 return ide_error(drive, s, stat); 370} 371 372void task_end_request(ide_drive_t *drive, struct request *rq, u8 stat) 373{ 374 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) { 375 u8 err = ide_read_error(drive); 376 377 ide_end_drive_cmd(drive, stat, err); 378 return; 379 } 380 381 if (rq->rq_disk) { 382 ide_driver_t *drv; 383 384 drv = *(ide_driver_t **)rq->rq_disk->private_data;; 385 drv->end_request(drive, 1, rq->nr_sectors); 386 } else 387 ide_end_request(drive, 1, rq->nr_sectors); 388} 389 390/* 391 * We got an interrupt on a task_in case, but no errors and no DRQ. 392 * 393 * It might be a spurious irq (shared irq), but it might be a 394 * command that had no output. 395 */ 396static ide_startstop_t task_in_unexpected(ide_drive_t *drive, struct request *rq, u8 stat) 397{ 398 /* Command all done? */ 399 if (OK_STAT(stat, READY_STAT, BUSY_STAT)) { 400 task_end_request(drive, rq, stat); 401 return ide_stopped; 402 } 403 404 /* Assume it was a spurious irq */ 405 ide_set_handler(drive, &task_in_intr, WAIT_WORSTCASE, NULL); 406 return ide_started; 407} 408 409/* 410 * Handler for command with PIO data-in phase (Read/Read Multiple). 411 */ 412static ide_startstop_t task_in_intr(ide_drive_t *drive) 413{ 414 ide_hwif_t *hwif = drive->hwif; 415 struct request *rq = HWGROUP(drive)->rq; 416 u8 stat = ide_read_status(drive); 417 418 /* Error? */ 419 if (stat & ERR_STAT) 420 return task_error(drive, rq, __func__, stat); 421 422 /* Didn't want any data? Odd. */ 423 if (!(stat & DRQ_STAT)) 424 return task_in_unexpected(drive, rq, stat); 425 426 ide_pio_datablock(drive, rq, 0); 427 428 /* Are we done? Check status and finish transfer. */ 429 if (!hwif->nleft) { 430 stat = wait_drive_not_busy(drive); 431 if (!OK_STAT(stat, 0, BAD_STAT)) 432 return task_error(drive, rq, __func__, stat); 433 task_end_request(drive, rq, stat); 434 return ide_stopped; 435 } 436 437 /* Still data left to transfer. */ 438 ide_set_handler(drive, &task_in_intr, WAIT_WORSTCASE, NULL); 439 440 return ide_started; 441} 442 443/* 444 * Handler for command with PIO data-out phase (Write/Write Multiple). 445 */ 446static ide_startstop_t task_out_intr (ide_drive_t *drive) 447{ 448 ide_hwif_t *hwif = drive->hwif; 449 struct request *rq = HWGROUP(drive)->rq; 450 u8 stat = ide_read_status(drive); 451 452 if (!OK_STAT(stat, DRIVE_READY, drive->bad_wstat)) 453 return task_error(drive, rq, __func__, stat); 454 455 /* Deal with unexpected ATA data phase. */ 456 if (((stat & DRQ_STAT) == 0) ^ !hwif->nleft) 457 return task_error(drive, rq, __func__, stat); 458 459 if (!hwif->nleft) { 460 task_end_request(drive, rq, stat); 461 return ide_stopped; 462 } 463 464 /* Still data left to transfer. */ 465 ide_pio_datablock(drive, rq, 1); 466 ide_set_handler(drive, &task_out_intr, WAIT_WORSTCASE, NULL); 467 468 return ide_started; 469} 470 471static ide_startstop_t pre_task_out_intr(ide_drive_t *drive, struct request *rq) 472{ 473 ide_startstop_t startstop; 474 475 if (ide_wait_stat(&startstop, drive, DRQ_STAT, 476 drive->bad_wstat, WAIT_DRQ)) { 477 printk(KERN_ERR "%s: no DRQ after issuing %sWRITE%s\n", 478 drive->name, 479 drive->hwif->data_phase ? "MULT" : "", 480 drive->addressing ? "_EXT" : ""); 481 return startstop; 482 } 483 484 if (!drive->unmask) 485 local_irq_disable(); 486 487 ide_set_handler(drive, &task_out_intr, WAIT_WORSTCASE, NULL); 488 ide_pio_datablock(drive, rq, 1); 489 490 return ide_started; 491} 492 493int ide_raw_taskfile(ide_drive_t *drive, ide_task_t *task, u8 *buf, u16 nsect) 494{ 495 struct request *rq; 496 int error; 497 498 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 499 rq->cmd_type = REQ_TYPE_ATA_TASKFILE; 500 rq->buffer = buf; 501 502 /* 503 * (ks) We transfer currently only whole sectors. 504 * This is suffient for now. But, it would be great, 505 * if we would find a solution to transfer any size. 506 * To support special commands like READ LONG. 507 */ 508 rq->hard_nr_sectors = rq->nr_sectors = nsect; 509 rq->hard_cur_sectors = rq->current_nr_sectors = nsect; 510 511 if (task->tf_flags & IDE_TFLAG_WRITE) 512 rq->cmd_flags |= REQ_RW; 513 514 rq->special = task; 515 task->rq = rq; 516 517 error = blk_execute_rq(drive->queue, NULL, rq, 0); 518 blk_put_request(rq); 519 520 return error; 521} 522 523EXPORT_SYMBOL(ide_raw_taskfile); 524 525int ide_no_data_taskfile(ide_drive_t *drive, ide_task_t *task) 526{ 527 task->data_phase = TASKFILE_NO_DATA; 528 529 return ide_raw_taskfile(drive, task, NULL, 0); 530} 531EXPORT_SYMBOL_GPL(ide_no_data_taskfile); 532 533#ifdef CONFIG_IDE_TASK_IOCTL 534int ide_taskfile_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg) 535{ 536 ide_task_request_t *req_task; 537 ide_task_t args; 538 u8 *outbuf = NULL; 539 u8 *inbuf = NULL; 540 u8 *data_buf = NULL; 541 int err = 0; 542 int tasksize = sizeof(struct ide_task_request_s); 543 unsigned int taskin = 0; 544 unsigned int taskout = 0; 545 u16 nsect = 0; 546 char __user *buf = (char __user *)arg; 547 548// printk("IDE Taskfile ...\n"); 549 550 req_task = kzalloc(tasksize, GFP_KERNEL); 551 if (req_task == NULL) return -ENOMEM; 552 if (copy_from_user(req_task, buf, tasksize)) { 553 kfree(req_task); 554 return -EFAULT; 555 } 556 557 taskout = req_task->out_size; 558 taskin = req_task->in_size; 559 560 if (taskin > 65536 || taskout > 65536) { 561 err = -EINVAL; 562 goto abort; 563 } 564 565 if (taskout) { 566 int outtotal = tasksize; 567 outbuf = kzalloc(taskout, GFP_KERNEL); 568 if (outbuf == NULL) { 569 err = -ENOMEM; 570 goto abort; 571 } 572 if (copy_from_user(outbuf, buf + outtotal, taskout)) { 573 err = -EFAULT; 574 goto abort; 575 } 576 } 577 578 if (taskin) { 579 int intotal = tasksize + taskout; 580 inbuf = kzalloc(taskin, GFP_KERNEL); 581 if (inbuf == NULL) { 582 err = -ENOMEM; 583 goto abort; 584 } 585 if (copy_from_user(inbuf, buf + intotal, taskin)) { 586 err = -EFAULT; 587 goto abort; 588 } 589 } 590 591 memset(&args, 0, sizeof(ide_task_t)); 592 593 memcpy(&args.tf_array[0], req_task->hob_ports, HDIO_DRIVE_HOB_HDR_SIZE - 2); 594 memcpy(&args.tf_array[6], req_task->io_ports, HDIO_DRIVE_TASK_HDR_SIZE); 595 596 args.data_phase = req_task->data_phase; 597 598 args.tf_flags = IDE_TFLAG_IO_16BIT | IDE_TFLAG_DEVICE | 599 IDE_TFLAG_IN_TF; 600 if (drive->addressing == 1) 601 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_IN_HOB); 602 603 if (req_task->out_flags.all) { 604 args.tf_flags |= IDE_TFLAG_FLAGGED; 605 606 if (req_task->out_flags.b.data) 607 args.tf_flags |= IDE_TFLAG_OUT_DATA; 608 609 if (req_task->out_flags.b.nsector_hob) 610 args.tf_flags |= IDE_TFLAG_OUT_HOB_NSECT; 611 if (req_task->out_flags.b.sector_hob) 612 args.tf_flags |= IDE_TFLAG_OUT_HOB_LBAL; 613 if (req_task->out_flags.b.lcyl_hob) 614 args.tf_flags |= IDE_TFLAG_OUT_HOB_LBAM; 615 if (req_task->out_flags.b.hcyl_hob) 616 args.tf_flags |= IDE_TFLAG_OUT_HOB_LBAH; 617 618 if (req_task->out_flags.b.error_feature) 619 args.tf_flags |= IDE_TFLAG_OUT_FEATURE; 620 if (req_task->out_flags.b.nsector) 621 args.tf_flags |= IDE_TFLAG_OUT_NSECT; 622 if (req_task->out_flags.b.sector) 623 args.tf_flags |= IDE_TFLAG_OUT_LBAL; 624 if (req_task->out_flags.b.lcyl) 625 args.tf_flags |= IDE_TFLAG_OUT_LBAM; 626 if (req_task->out_flags.b.hcyl) 627 args.tf_flags |= IDE_TFLAG_OUT_LBAH; 628 } else { 629 args.tf_flags |= IDE_TFLAG_OUT_TF; 630 if (args.tf_flags & IDE_TFLAG_LBA48) 631 args.tf_flags |= IDE_TFLAG_OUT_HOB; 632 } 633 634 if (req_task->in_flags.b.data) 635 args.tf_flags |= IDE_TFLAG_IN_DATA; 636 637 switch(req_task->data_phase) { 638 case TASKFILE_MULTI_OUT: 639 if (!drive->mult_count) { 640 /* (hs): give up if multcount is not set */ 641 printk(KERN_ERR "%s: %s Multimode Write " \ 642 "multcount is not set\n", 643 drive->name, __func__); 644 err = -EPERM; 645 goto abort; 646 } 647 /* fall through */ 648 case TASKFILE_OUT: 649 /* fall through */ 650 case TASKFILE_OUT_DMAQ: 651 case TASKFILE_OUT_DMA: 652 nsect = taskout / SECTOR_SIZE; 653 data_buf = outbuf; 654 break; 655 case TASKFILE_MULTI_IN: 656 if (!drive->mult_count) { 657 /* (hs): give up if multcount is not set */ 658 printk(KERN_ERR "%s: %s Multimode Read failure " \ 659 "multcount is not set\n", 660 drive->name, __func__); 661 err = -EPERM; 662 goto abort; 663 } 664 /* fall through */ 665 case TASKFILE_IN: 666 /* fall through */ 667 case TASKFILE_IN_DMAQ: 668 case TASKFILE_IN_DMA: 669 nsect = taskin / SECTOR_SIZE; 670 data_buf = inbuf; 671 break; 672 case TASKFILE_NO_DATA: 673 break; 674 default: 675 err = -EFAULT; 676 goto abort; 677 } 678 679 if (req_task->req_cmd == IDE_DRIVE_TASK_NO_DATA) 680 nsect = 0; 681 else if (!nsect) { 682 nsect = (args.tf.hob_nsect << 8) | args.tf.nsect; 683 684 if (!nsect) { 685 printk(KERN_ERR "%s: in/out command without data\n", 686 drive->name); 687 err = -EFAULT; 688 goto abort; 689 } 690 } 691 692 if (req_task->req_cmd == IDE_DRIVE_TASK_RAW_WRITE) 693 args.tf_flags |= IDE_TFLAG_WRITE; 694 695 err = ide_raw_taskfile(drive, &args, data_buf, nsect); 696 697 memcpy(req_task->hob_ports, &args.tf_array[0], HDIO_DRIVE_HOB_HDR_SIZE - 2); 698 memcpy(req_task->io_ports, &args.tf_array[6], HDIO_DRIVE_TASK_HDR_SIZE); 699 700 if ((args.tf_flags & IDE_TFLAG_FLAGGED_SET_IN_FLAGS) && 701 req_task->in_flags.all == 0) { 702 req_task->in_flags.all = IDE_TASKFILE_STD_IN_FLAGS; 703 if (drive->addressing == 1) 704 req_task->in_flags.all |= (IDE_HOB_STD_IN_FLAGS << 8); 705 } 706 707 if (copy_to_user(buf, req_task, tasksize)) { 708 err = -EFAULT; 709 goto abort; 710 } 711 if (taskout) { 712 int outtotal = tasksize; 713 if (copy_to_user(buf + outtotal, outbuf, taskout)) { 714 err = -EFAULT; 715 goto abort; 716 } 717 } 718 if (taskin) { 719 int intotal = tasksize + taskout; 720 if (copy_to_user(buf + intotal, inbuf, taskin)) { 721 err = -EFAULT; 722 goto abort; 723 } 724 } 725abort: 726 kfree(req_task); 727 kfree(outbuf); 728 kfree(inbuf); 729 730// printk("IDE Taskfile ioctl ended. rc = %i\n", err); 731 732 return err; 733} 734#endif 735 736int ide_cmd_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg) 737{ 738 u8 *buf = NULL; 739 int bufsize = 0, err = 0; 740 u8 args[4], xfer_rate = 0; 741 ide_task_t tfargs; 742 struct ide_taskfile *tf = &tfargs.tf; 743 struct hd_driveid *id = drive->id; 744 745 if (NULL == (void *) arg) { 746 struct request *rq; 747 748 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 749 rq->cmd_type = REQ_TYPE_ATA_TASKFILE; 750 err = blk_execute_rq(drive->queue, NULL, rq, 0); 751 blk_put_request(rq); 752 753 return err; 754 } 755 756 if (copy_from_user(args, (void __user *)arg, 4)) 757 return -EFAULT; 758 759 memset(&tfargs, 0, sizeof(ide_task_t)); 760 tf->feature = args[2]; 761 if (args[0] == WIN_SMART) { 762 tf->nsect = args[3]; 763 tf->lbal = args[1]; 764 tf->lbam = 0x4f; 765 tf->lbah = 0xc2; 766 tfargs.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_IN_NSECT; 767 } else { 768 tf->nsect = args[1]; 769 tfargs.tf_flags = IDE_TFLAG_OUT_FEATURE | 770 IDE_TFLAG_OUT_NSECT | IDE_TFLAG_IN_NSECT; 771 } 772 tf->command = args[0]; 773 tfargs.data_phase = args[3] ? TASKFILE_IN : TASKFILE_NO_DATA; 774 775 if (args[3]) { 776 tfargs.tf_flags |= IDE_TFLAG_IO_16BIT; 777 bufsize = SECTOR_WORDS * 4 * args[3]; 778 buf = kzalloc(bufsize, GFP_KERNEL); 779 if (buf == NULL) 780 return -ENOMEM; 781 } 782 783 if (tf->command == WIN_SETFEATURES && 784 tf->feature == SETFEATURES_XFER && 785 tf->nsect >= XFER_SW_DMA_0 && 786 (id->dma_ultra || id->dma_mword || id->dma_1word)) { 787 xfer_rate = args[1]; 788 if (tf->nsect > XFER_UDMA_2 && !eighty_ninty_three(drive)) { 789 printk(KERN_WARNING "%s: UDMA speeds >UDMA33 cannot " 790 "be set\n", drive->name); 791 goto abort; 792 } 793 } 794 795 err = ide_raw_taskfile(drive, &tfargs, buf, args[3]); 796 797 args[0] = tf->status; 798 args[1] = tf->error; 799 args[2] = tf->nsect; 800 801 if (!err && xfer_rate) { 802 /* active-retuning-calls future */ 803 ide_set_xfer_rate(drive, xfer_rate); 804 ide_driveid_update(drive); 805 } 806abort: 807 if (copy_to_user((void __user *)arg, &args, 4)) 808 err = -EFAULT; 809 if (buf) { 810 if (copy_to_user((void __user *)(arg + 4), buf, bufsize)) 811 err = -EFAULT; 812 kfree(buf); 813 } 814 return err; 815} 816 817int ide_task_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg) 818{ 819 void __user *p = (void __user *)arg; 820 int err = 0; 821 u8 args[7]; 822 ide_task_t task; 823 824 if (copy_from_user(args, p, 7)) 825 return -EFAULT; 826 827 memset(&task, 0, sizeof(task)); 828 memcpy(&task.tf_array[7], &args[1], 6); 829 task.tf.command = args[0]; 830 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 831 832 err = ide_no_data_taskfile(drive, &task); 833 834 args[0] = task.tf.command; 835 memcpy(&args[1], &task.tf_array[7], 6); 836 837 if (copy_to_user(p, args, 7)) 838 err = -EFAULT; 839 840 return err; 841} 842