SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/ide/ide-taskfile.c

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