ide-taskfile.c 16.6 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
Linus Torvalds's avatar
Linus Torvalds committed
2
/*
3 4 5
 *  Copyright (C) 2000-2002	   Michael Cornwell <cornwell@acm.org>
 *  Copyright (C) 2000-2002	   Andre Hedrick <andre@linux-ide.org>
 *  Copyright (C) 2001-2002	   Klaus Smolin
Linus Torvalds's avatar
Linus Torvalds committed
6
 *					IBM Storage Technology Division
7
 *  Copyright (C) 2003-2004, 2007  Bartlomiej Zolnierkiewicz
Linus Torvalds's avatar
Linus Torvalds committed
8 9 10 11 12 13 14
 *
 *  The big the bad and the ugly.
 */

#include <linux/types.h>
#include <linux/string.h>
#include <linux/kernel.h>
15
#include <linux/export.h>
16
#include <linux/sched.h>
Linus Torvalds's avatar
Linus Torvalds committed
17 18 19 20 21 22
#include <linux/interrupt.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/hdreg.h>
#include <linux/ide.h>
23
#include <linux/nmi.h>
Jens Axboe's avatar
Jens Axboe committed
24
#include <linux/scatterlist.h>
25
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
26 27 28

#include <asm/io.h>

29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
void ide_tf_readback(ide_drive_t *drive, struct ide_cmd *cmd)
{
	ide_hwif_t *hwif = drive->hwif;
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;

	/* Be sure we're looking at the low order bytes */
	tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);

	tp_ops->tf_read(drive, &cmd->tf, cmd->valid.in.tf);

	if (cmd->tf_flags & IDE_TFLAG_LBA48) {
		tp_ops->write_devctl(hwif, ATA_HOB | ATA_DEVCTL_OBS);

		tp_ops->tf_read(drive, &cmd->hob, cmd->valid.in.hob);
	}
}

46
void ide_tf_dump(const char *s, struct ide_cmd *cmd)
47
{
48 49 50
#ifdef DEBUG
	printk("%s: tf: feat 0x%02x nsect 0x%02x lbal 0x%02x "
		"lbam 0x%02x lbah 0x%02x dev 0x%02x cmd 0x%02x\n",
51 52 53 54 55
	       s, cmd->tf.feature, cmd->tf.nsect,
	       cmd->tf.lbal, cmd->tf.lbam, cmd->tf.lbah,
	       cmd->tf.device, cmd->tf.command);
	printk("%s: hob: nsect 0x%02x lbal 0x%02x lbam 0x%02x lbah 0x%02x\n",
	       s, cmd->hob.nsect, cmd->hob.lbal, cmd->hob.lbam, cmd->hob.lbah);
56
#endif
57 58
}

59
int taskfile_lib_get_identify(ide_drive_t *drive, u8 *buf)
Linus Torvalds's avatar
Linus Torvalds committed
60
{
61
	struct ide_cmd cmd;
62

63 64
	memset(&cmd, 0, sizeof(cmd));
	cmd.tf.nsect = 0x01;
Linus Torvalds's avatar
Linus Torvalds committed
65
	if (drive->media == ide_disk)
66
		cmd.tf.command = ATA_CMD_ID_ATA;
Linus Torvalds's avatar
Linus Torvalds committed
67
	else
68
		cmd.tf.command = ATA_CMD_ID_ATAPI;
69 70
	cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
	cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
71
	cmd.protocol = ATA_PROT_PIO;
72 73

	return ide_raw_taskfile(drive, &cmd, buf, 1);
Linus Torvalds's avatar
Linus Torvalds committed
74 75
}

76
static ide_startstop_t task_no_data_intr(ide_drive_t *);
77
static ide_startstop_t pre_task_out_intr(ide_drive_t *, struct ide_cmd *);
78
static ide_startstop_t task_pio_intr(ide_drive_t *);
79

80
ide_startstop_t do_rw_taskfile(ide_drive_t *drive, struct ide_cmd *orig_cmd)
Linus Torvalds's avatar
Linus Torvalds committed
81
{
82
	ide_hwif_t *hwif = drive->hwif;
83
	struct ide_cmd *cmd = &hwif->cmd;
84
	struct ide_taskfile *tf = &cmd->tf;
85
	ide_handler_t *handler = NULL;
86
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
87
	const struct ide_dma_ops *dma_ops = hwif->dma_ops;
Linus Torvalds's avatar
Linus Torvalds committed
88

89 90 91
	if (orig_cmd->protocol == ATA_PROT_PIO &&
	    (orig_cmd->tf_flags & IDE_TFLAG_MULTI_PIO) &&
	    drive->mult_count == 0) {
92
		pr_err("%s: multimode not set!\n", drive->name);
93
		return ide_stopped;
94 95
	}

96 97
	if (orig_cmd->ftf_flags & IDE_FTFLAG_FLAGGED)
		orig_cmd->ftf_flags |= IDE_FTFLAG_SET_IN_FLAGS;
98

99
	memcpy(cmd, orig_cmd, sizeof(*cmd));
100

101
	if ((cmd->tf_flags & IDE_TFLAG_DMA_PIO_FALLBACK) == 0) {
102
		ide_tf_dump(drive->name, cmd);
103
		tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
104 105

		if (cmd->ftf_flags & IDE_FTFLAG_OUT_DATA) {
106
			u8 data[2] = { cmd->tf.data, cmd->hob.data };
107 108 109

			tp_ops->output_data(drive, cmd, data, 2);
		}
110 111 112 113 114 115 116 117 118 119

		if (cmd->valid.out.tf & IDE_VALID_DEVICE) {
			u8 HIHI = (cmd->tf_flags & IDE_TFLAG_LBA48) ?
				  0xE0 : 0xEF;

			if (!(cmd->ftf_flags & IDE_FTFLAG_FLAGGED))
				cmd->tf.device &= HIHI;
			cmd->tf.device |= drive->select;
		}

120 121
		tp_ops->tf_load(drive, &cmd->hob, cmd->valid.out.hob);
		tp_ops->tf_load(drive, &cmd->tf,  cmd->valid.out.tf);
122
	}
Linus Torvalds's avatar
Linus Torvalds committed
123

124 125 126 127 128 129 130
	switch (cmd->protocol) {
	case ATA_PROT_PIO:
		if (cmd->tf_flags & IDE_TFLAG_WRITE) {
			tp_ops->exec_command(hwif, tf->command);
			ndelay(400);	/* FIXME */
			return pre_task_out_intr(drive, cmd);
		}
131
		handler = task_pio_intr;
132
		/* fall through */
133
	case ATA_PROT_NODATA:
134 135
		if (handler == NULL)
			handler = task_no_data_intr;
136
		ide_execute_command(drive, cmd, handler, WAIT_WORSTCASE);
Linus Torvalds's avatar
Linus Torvalds committed
137
		return ide_started;
138
	case ATA_PROT_DMA:
139
		if (ide_dma_prepare(drive, cmd))
140
			return ide_stopped;
141
		hwif->expiry = dma_ops->dma_timer_expiry;
142
		ide_execute_command(drive, cmd, ide_dma_intr, 2 * WAIT_CMD);
143
		dma_ops->dma_start(drive);
144
		/* fall through */
145
	default:
146
		return ide_started;
Linus Torvalds's avatar
Linus Torvalds committed
147 148
	}
}
149
EXPORT_SYMBOL_GPL(do_rw_taskfile);
Linus Torvalds's avatar
Linus Torvalds committed
150

151
static ide_startstop_t task_no_data_intr(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
152
{
153
	ide_hwif_t *hwif = drive->hwif;
154 155 156
	struct ide_cmd *cmd = &hwif->cmd;
	struct ide_taskfile *tf = &cmd->tf;
	int custom = (cmd->tf_flags & IDE_TFLAG_CUSTOM_HANDLER) ? 1 : 0;
157
	int retries = (custom && tf->command == ATA_CMD_INIT_DEV_PARAMS) ? 5 : 1;
Linus Torvalds's avatar
Linus Torvalds committed
158 159
	u8 stat;

160 161
	local_irq_enable_in_hardirq();

162 163
	while (1) {
		stat = hwif->tp_ops->read_status(hwif);
164
		if ((stat & ATA_BUSY) == 0 || retries-- == 0)
165
			break;
Linus Torvalds's avatar
Linus Torvalds committed
166
		udelay(10);
167
	};
Linus Torvalds's avatar
Linus Torvalds committed
168

169 170 171
	if (!OK_STAT(stat, ATA_DRDY, BAD_STAT)) {
		if (custom && tf->command == ATA_CMD_SET_MULTI) {
			drive->mult_req = drive->mult_count = 0;
172
			drive->special_flags |= IDE_SFLAG_RECALIBRATE;
173 174 175 176 177
			(void)ide_dump_status(drive, __func__, stat);
			return ide_stopped;
		} else if (custom && tf->command == ATA_CMD_INIT_DEV_PARAMS) {
			if ((stat & (ATA_ERR | ATA_DRQ)) == 0) {
				ide_set_handler(drive, &task_no_data_intr,
178
						WAIT_WORSTCASE);
179 180 181
				return ide_started;
			}
		}
Linus Torvalds's avatar
Linus Torvalds committed
182
		return ide_error(drive, "task_no_data_intr", stat);
183
	}
184

185
	if (custom && tf->command == ATA_CMD_SET_MULTI)
186
		drive->mult_count = drive->mult_req;
Linus Torvalds's avatar
Linus Torvalds committed
187

188 189
	if (custom == 0 || tf->command == ATA_CMD_IDLEIMMEDIATE ||
	    tf->command == ATA_CMD_CHK_POWER) {
190 191
		struct request *rq = hwif->rq;

192
		if (ata_pm_request(rq))
193
			ide_complete_pm_rq(drive, rq);
194 195
		else
			ide_finish_cmd(drive, cmd, stat);
196 197
	}

Linus Torvalds's avatar
Linus Torvalds committed
198 199 200
	return ide_stopped;
}

201
static u8 wait_drive_not_busy(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
202
{
203
	ide_hwif_t *hwif = drive->hwif;
204
	int retries;
Linus Torvalds's avatar
Linus Torvalds committed
205 206 207
	u8 stat;

	/*
208
	 * Last sector was transferred, wait until device is ready.  This can
209
	 * take up to 6 ms on some ATAPI devices, so we will wait max 10 ms.
Linus Torvalds's avatar
Linus Torvalds committed
210
	 */
211
	for (retries = 0; retries < 1000; retries++) {
212
		stat = hwif->tp_ops->read_status(hwif);
213

214
		if (stat & ATA_BUSY)
215 216 217 218
			udelay(10);
		else
			break;
	}
Linus Torvalds's avatar
Linus Torvalds committed
219

220
	if (stat & ATA_BUSY)
221
		pr_err("%s: drive still BUSY!\n", drive->name);
Linus Torvalds's avatar
Linus Torvalds committed
222 223 224 225

	return stat;
}

226 227
void ide_pio_bytes(ide_drive_t *drive, struct ide_cmd *cmd,
		   unsigned int write, unsigned int len)
Linus Torvalds's avatar
Linus Torvalds committed
228 229 230
{
	ide_hwif_t *hwif = drive->hwif;
	struct scatterlist *sg = hwif->sg_table;
231
	struct scatterlist *cursg = cmd->cursg;
232
	unsigned long uninitialized_var(flags);
Linus Torvalds's avatar
Linus Torvalds committed
233 234 235 236
	struct page *page;
	unsigned int offset;
	u8 *buf;

237 238 239 240 241
	if (cursg == NULL)
		cursg = cmd->cursg = sg;

	while (len) {
		unsigned nr_bytes = min(len, cursg->length - cmd->cursg_ofs);
Jens Axboe's avatar
Jens Axboe committed
242

243 244 245 246 247 248
		page = sg_page(cursg);
		offset = cursg->offset + cmd->cursg_ofs;

		/* get the current page and offset */
		page = nth_page(page, (offset >> PAGE_SHIFT));
		offset %= PAGE_SIZE;
Linus Torvalds's avatar
Linus Torvalds committed
249

250 251
		nr_bytes = min_t(unsigned, nr_bytes, (PAGE_SIZE - offset));

252
		buf = kmap_atomic(page) + offset;
Linus Torvalds's avatar
Linus Torvalds committed
253

254 255
		cmd->nleft -= nr_bytes;
		cmd->cursg_ofs += nr_bytes;
Linus Torvalds's avatar
Linus Torvalds committed
256

257 258 259 260
		if (cmd->cursg_ofs == cursg->length) {
			cursg = cmd->cursg = sg_next(cmd->cursg);
			cmd->cursg_ofs = 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
261

262 263 264 265 266
		/* do the actual data transfer */
		if (write)
			hwif->tp_ops->output_data(drive, cmd, buf, nr_bytes);
		else
			hwif->tp_ops->input_data(drive, cmd, buf, nr_bytes);
Linus Torvalds's avatar
Linus Torvalds committed
267

268
		kunmap_atomic(buf);
269

270 271
		len -= nr_bytes;
	}
Linus Torvalds's avatar
Linus Torvalds committed
272
}
273
EXPORT_SYMBOL_GPL(ide_pio_bytes);
Linus Torvalds's avatar
Linus Torvalds committed
274

275 276
static void ide_pio_datablock(ide_drive_t *drive, struct ide_cmd *cmd,
			      unsigned int write)
Linus Torvalds's avatar
Linus Torvalds committed
277
{
278 279
	unsigned int nr_bytes;

280 281
	u8 saved_io_32bit = drive->io_32bit;

282
	if (cmd->tf_flags & IDE_TFLAG_FS)
283
		scsi_req(cmd->rq)->result = 0;
Linus Torvalds's avatar
Linus Torvalds committed
284

285
	if (cmd->tf_flags & IDE_TFLAG_IO_16BIT)
286
		drive->io_32bit = 0;
287

288 289
	touch_softlockup_watchdog();

290
	if (cmd->tf_flags & IDE_TFLAG_MULTI_PIO)
291
		nr_bytes = min_t(unsigned, cmd->nleft, drive->mult_count << 9);
292
	else
293 294 295
		nr_bytes = SECTOR_SIZE;

	ide_pio_bytes(drive, cmd, write, nr_bytes);
296 297

	drive->io_32bit = saved_io_32bit;
Linus Torvalds's avatar
Linus Torvalds committed
298 299
}

300
static void ide_error_cmd(ide_drive_t *drive, struct ide_cmd *cmd)
Linus Torvalds's avatar
Linus Torvalds committed
301
{
302
	if (cmd->tf_flags & IDE_TFLAG_FS) {
303
		int nr_bytes = cmd->nbytes - cmd->nleft;
Linus Torvalds's avatar
Linus Torvalds committed
304

305 306 307
		if (cmd->protocol == ATA_PROT_PIO &&
		    ((cmd->tf_flags & IDE_TFLAG_WRITE) || cmd->nleft == 0)) {
			if (cmd->tf_flags & IDE_TFLAG_MULTI_PIO)
308
				nr_bytes -= drive->mult_count << 9;
309
			else
310
				nr_bytes -= SECTOR_SIZE;
Linus Torvalds's avatar
Linus Torvalds committed
311 312
		}

313
		if (nr_bytes > 0)
314
			ide_complete_rq(drive, BLK_STS_OK, nr_bytes);
Linus Torvalds's avatar
Linus Torvalds committed
315 316 317
	}
}

318
void ide_finish_cmd(ide_drive_t *drive, struct ide_cmd *cmd, u8 stat)
Linus Torvalds's avatar
Linus Torvalds committed
319
{
320
	struct request *rq = drive->hwif->rq;
321 322
	u8 err = ide_read_error(drive), nsect = cmd->tf.nsect;
	u8 set_xfer = !!(cmd->tf_flags & IDE_TFLAG_SET_XFER);
Linus Torvalds's avatar
Linus Torvalds committed
323

324
	ide_complete_cmd(drive, cmd, stat, err);
325
	scsi_req(rq)->result = err;
326 327 328 329 330 331

	if (err == 0 && set_xfer) {
		ide_set_xfer_rate(drive, nsect);
		ide_driveid_update(drive);
	}

332
	ide_complete_rq(drive, err ? BLK_STS_IOERR : BLK_STS_OK, blk_rq_bytes(rq));
Linus Torvalds's avatar
Linus Torvalds committed
333 334 335
}

/*
336
 * Handler for command with PIO data phase.
Linus Torvalds's avatar
Linus Torvalds committed
337
 */
338
static ide_startstop_t task_pio_intr(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
339 340
{
	ide_hwif_t *hwif = drive->hwif;
341
	struct ide_cmd *cmd = &drive->hwif->cmd;
342
	u8 stat = hwif->tp_ops->read_status(hwif);
343
	u8 write = !!(cmd->tf_flags & IDE_TFLAG_WRITE);
Linus Torvalds's avatar
Linus Torvalds committed
344

345 346 347
	if (write == 0) {
		/* Error? */
		if (stat & ATA_ERR)
348
			goto out_err;
Linus Torvalds's avatar
Linus Torvalds committed
349

350
		/* Didn't want any data? Odd. */
351 352
		if ((stat & ATA_DRQ) == 0) {
			/* Command all done? */
353 354
			if (OK_STAT(stat, ATA_DRDY, ATA_BUSY))
				goto out_end;
355 356

			/* Assume it was a spurious irq */
357
			goto out_wait;
358
		}
359 360
	} else {
		if (!OK_STAT(stat, DRIVE_READY, drive->bad_wstat))
361
			goto out_err;
Linus Torvalds's avatar
Linus Torvalds committed
362

363 364
		/* Deal with unexpected ATA data phase. */
		if (((stat & ATA_DRQ) == 0) ^ (cmd->nleft == 0))
365
			goto out_err;
366 367
	}

368 369
	if (write && cmd->nleft == 0)
		goto out_end;
Linus Torvalds's avatar
Linus Torvalds committed
370 371

	/* Still data left to transfer. */
372
	ide_pio_datablock(drive, cmd, write);
Linus Torvalds's avatar
Linus Torvalds committed
373

374 375 376 377
	/* Are we done? Check status and finish transfer. */
	if (write == 0 && cmd->nleft == 0) {
		stat = wait_drive_not_busy(drive);
		if (!OK_STAT(stat, 0, BAD_STAT))
378
			goto out_err;
Linus Torvalds's avatar
Linus Torvalds committed
379

380 381 382
		goto out_end;
	}
out_wait:
Linus Torvalds's avatar
Linus Torvalds committed
383
	/* Still data left to transfer. */
384
	ide_set_handler(drive, &task_pio_intr, WAIT_WORSTCASE);
Linus Torvalds's avatar
Linus Torvalds committed
385
	return ide_started;
386
out_end:
387 388 389
	if ((cmd->tf_flags & IDE_TFLAG_FS) == 0)
		ide_finish_cmd(drive, cmd, stat);
	else
390
		ide_complete_rq(drive, BLK_STS_OK, blk_rq_sectors(cmd->rq) << 9);
391 392
	return ide_stopped;
out_err:
393 394
	ide_error_cmd(drive, cmd);
	return ide_error(drive, __func__, stat);
Linus Torvalds's avatar
Linus Torvalds committed
395 396
}

397 398
static ide_startstop_t pre_task_out_intr(ide_drive_t *drive,
					 struct ide_cmd *cmd)
Linus Torvalds's avatar
Linus Torvalds committed
399 400 401
{
	ide_startstop_t startstop;

402
	if (ide_wait_stat(&startstop, drive, ATA_DRQ,
Linus Torvalds's avatar
Linus Torvalds committed
403
			  drive->bad_wstat, WAIT_DRQ)) {
404
		pr_err("%s: no DRQ after issuing %sWRITE%s\n", drive->name,
405
			(cmd->tf_flags & IDE_TFLAG_MULTI_PIO) ? "MULT" : "",
406
			(drive->dev_flags & IDE_DFLAG_LBA48) ? "_EXT" : "");
Linus Torvalds's avatar
Linus Torvalds committed
407 408 409
		return startstop;
	}

410
	if (!force_irqthreads && (drive->dev_flags & IDE_DFLAG_UNMASK) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
411 412
		local_irq_disable();

413
	ide_set_handler(drive, &task_pio_intr, WAIT_WORSTCASE);
414

415
	ide_pio_datablock(drive, cmd, 1);
Linus Torvalds's avatar
Linus Torvalds committed
416 417 418 419

	return ide_started;
}

420 421
int ide_raw_taskfile(ide_drive_t *drive, struct ide_cmd *cmd, u8 *buf,
		     u16 nsect)
Linus Torvalds's avatar
Linus Torvalds committed
422
{
423 424
	struct request *rq;
	int error;
Linus Torvalds's avatar
Linus Torvalds committed
425

426 427
	rq = blk_get_request(drive->queue,
		(cmd->tf_flags & IDE_TFLAG_WRITE) ?
428
			REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
429
	ide_req(rq)->type = ATA_PRIV_TASKFILE;
430

Linus Torvalds's avatar
Linus Torvalds committed
431 432 433 434 435 436
	/*
	 * (ks) We transfer currently only whole sectors.
	 * This is suffient for now.  But, it would be great,
	 * if we would find a solution to transfer any size.
	 * To support special commands like READ LONG.
	 */
437 438
	if (nsect) {
		error = blk_rq_map_kern(drive->queue, rq, buf,
439
					nsect * SECTOR_SIZE, GFP_NOIO);
440 441 442
		if (error)
			goto put_req;
	}
Linus Torvalds's avatar
Linus Torvalds committed
443

444
	ide_req(rq)->special = cmd;
445
	cmd->rq = rq;
Linus Torvalds's avatar
Linus Torvalds committed
446

447
	blk_execute_rq(drive->queue, NULL, rq, 0);
448
	error = scsi_req(rq)->result ? -EIO : 0;
449 450
put_req:
	blk_put_request(rq);
451
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
452 453 454
}
EXPORT_SYMBOL(ide_raw_taskfile);

455
int ide_no_data_taskfile(ide_drive_t *drive, struct ide_cmd *cmd)
456
{
457
	cmd->protocol = ATA_PROT_NODATA;
458

459
	return ide_raw_taskfile(drive, cmd, NULL, 0);
460 461 462
}
EXPORT_SYMBOL_GPL(ide_no_data_taskfile);

463
#ifdef CONFIG_IDE_TASK_IOCTL
464
int ide_taskfile_ioctl(ide_drive_t *drive, unsigned long arg)
Linus Torvalds's avatar
Linus Torvalds committed
465 466
{
	ide_task_request_t	*req_task;
467
	struct ide_cmd		cmd;
Linus Torvalds's avatar
Linus Torvalds committed
468 469
	u8 *outbuf		= NULL;
	u8 *inbuf		= NULL;
470
	u8 *data_buf		= NULL;
Linus Torvalds's avatar
Linus Torvalds committed
471 472
	int err			= 0;
	int tasksize		= sizeof(struct ide_task_request_s);
473 474
	unsigned int taskin	= 0;
	unsigned int taskout	= 0;
475
	u16 nsect		= 0;
Linus Torvalds's avatar
Linus Torvalds committed
476 477
	char __user *buf = (char __user *)arg;

478 479 480
	req_task = memdup_user(buf, tasksize);
	if (IS_ERR(req_task))
		return PTR_ERR(req_task);
Linus Torvalds's avatar
Linus Torvalds committed
481

482 483
	taskout = req_task->out_size;
	taskin  = req_task->in_size;
484

485 486 487 488
	if (taskin > 65536 || taskout > 65536) {
		err = -EINVAL;
		goto abort;
	}
Linus Torvalds's avatar
Linus Torvalds committed
489 490 491

	if (taskout) {
		int outtotal = tasksize;
492
		outbuf = kzalloc(taskout, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
493 494 495 496 497 498 499 500 501 502 503 504
		if (outbuf == NULL) {
			err = -ENOMEM;
			goto abort;
		}
		if (copy_from_user(outbuf, buf + outtotal, taskout)) {
			err = -EFAULT;
			goto abort;
		}
	}

	if (taskin) {
		int intotal = tasksize + taskout;
505
		inbuf = kzalloc(taskin, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
506 507 508 509 510 511 512 513 514 515
		if (inbuf == NULL) {
			err = -ENOMEM;
			goto abort;
		}
		if (copy_from_user(inbuf, buf + intotal, taskin)) {
			err = -EFAULT;
			goto abort;
		}
	}

516
	memset(&cmd, 0, sizeof(cmd));
Linus Torvalds's avatar
Linus Torvalds committed
517

518 519
	memcpy(&cmd.hob, req_task->hob_ports, HDIO_DRIVE_HOB_HDR_SIZE - 2);
	memcpy(&cmd.tf,  req_task->io_ports,  HDIO_DRIVE_TASK_HDR_SIZE);
520

521 522 523
	cmd.valid.out.tf = IDE_VALID_DEVICE;
	cmd.valid.in.tf  = IDE_VALID_DEVICE | IDE_VALID_IN_TF;
	cmd.tf_flags = IDE_TFLAG_IO_16BIT;
Linus Torvalds's avatar
Linus Torvalds committed
524

525 526 527 528
	if (drive->dev_flags & IDE_DFLAG_LBA48) {
		cmd.tf_flags |= IDE_TFLAG_LBA48;
		cmd.valid.in.hob = IDE_VALID_IN_HOB;
	}
529

530
	if (req_task->out_flags.all) {
531
		cmd.ftf_flags |= IDE_FTFLAG_FLAGGED;
532 533

		if (req_task->out_flags.b.data)
534
			cmd.ftf_flags |= IDE_FTFLAG_OUT_DATA;
535 536

		if (req_task->out_flags.b.nsector_hob)
537
			cmd.valid.out.hob |= IDE_VALID_NSECT;
538
		if (req_task->out_flags.b.sector_hob)
539
			cmd.valid.out.hob |= IDE_VALID_LBAL;
540
		if (req_task->out_flags.b.lcyl_hob)
541
			cmd.valid.out.hob |= IDE_VALID_LBAM;
542
		if (req_task->out_flags.b.hcyl_hob)
543
			cmd.valid.out.hob |= IDE_VALID_LBAH;
544 545

		if (req_task->out_flags.b.error_feature)
546
			cmd.valid.out.tf  |= IDE_VALID_FEATURE;
547
		if (req_task->out_flags.b.nsector)
548
			cmd.valid.out.tf  |= IDE_VALID_NSECT;
549
		if (req_task->out_flags.b.sector)
550
			cmd.valid.out.tf  |= IDE_VALID_LBAL;
551
		if (req_task->out_flags.b.lcyl)
552
			cmd.valid.out.tf  |= IDE_VALID_LBAM;
553
		if (req_task->out_flags.b.hcyl)
554
			cmd.valid.out.tf  |= IDE_VALID_LBAH;
555
	} else {
556
		cmd.valid.out.tf |= IDE_VALID_OUT_TF;
557
		if (cmd.tf_flags & IDE_TFLAG_LBA48)
558
			cmd.valid.out.hob |= IDE_VALID_OUT_HOB;
559 560
	}

561
	if (req_task->in_flags.b.data)
562
		cmd.ftf_flags |= IDE_FTFLAG_IN_DATA;
563

564 565 566 567
	if (req_task->req_cmd == IDE_DRIVE_TASK_RAW_WRITE) {
		/* fixup data phase if needed */
		if (req_task->data_phase == TASKFILE_IN_DMAQ ||
		    req_task->data_phase == TASKFILE_IN_DMA)
568
			cmd.tf_flags |= IDE_TFLAG_WRITE;
569 570
	}

571 572 573
	cmd.protocol = ATA_PROT_DMA;

	switch (req_task->data_phase) {
574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
	case TASKFILE_MULTI_OUT:
		if (!drive->mult_count) {
			/* (hs): give up if multcount is not set */
			pr_err("%s: %s Multimode Write multcount is not set\n",
				drive->name, __func__);
			err = -EPERM;
			goto abort;
		}
		cmd.tf_flags |= IDE_TFLAG_MULTI_PIO;
		/* fall through */
	case TASKFILE_OUT:
		cmd.protocol = ATA_PROT_PIO;
		/* fall through */
	case TASKFILE_OUT_DMAQ:
	case TASKFILE_OUT_DMA:
		cmd.tf_flags |= IDE_TFLAG_WRITE;
		nsect = taskout / SECTOR_SIZE;
		data_buf = outbuf;
		break;
	case TASKFILE_MULTI_IN:
		if (!drive->mult_count) {
			/* (hs): give up if multcount is not set */
			pr_err("%s: %s Multimode Read multcount is not set\n",
				drive->name, __func__);
			err = -EPERM;
Linus Torvalds's avatar
Linus Torvalds committed
599
			goto abort;
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
		}
		cmd.tf_flags |= IDE_TFLAG_MULTI_PIO;
		/* fall through */
	case TASKFILE_IN:
		cmd.protocol = ATA_PROT_PIO;
		/* fall through */
	case TASKFILE_IN_DMAQ:
	case TASKFILE_IN_DMA:
		nsect = taskin / SECTOR_SIZE;
		data_buf = inbuf;
		break;
	case TASKFILE_NO_DATA:
		cmd.protocol = ATA_PROT_NODATA;
		break;
	default:
		err = -EFAULT;
		goto abort;
Linus Torvalds's avatar
Linus Torvalds committed
617 618
	}

619 620 621
	if (req_task->req_cmd == IDE_DRIVE_TASK_NO_DATA)
		nsect = 0;
	else if (!nsect) {
622
		nsect = (cmd.hob.nsect << 8) | cmd.tf.nsect;
623 624

		if (!nsect) {
625
			pr_err("%s: in/out command without data\n",
626 627 628 629 630 631
					drive->name);
			err = -EFAULT;
			goto abort;
		}
	}

632
	err = ide_raw_taskfile(drive, &cmd, data_buf, nsect);
633

634 635
	memcpy(req_task->hob_ports, &cmd.hob, HDIO_DRIVE_HOB_HDR_SIZE - 2);
	memcpy(req_task->io_ports,  &cmd.tf,  HDIO_DRIVE_TASK_HDR_SIZE);
636

637
	if ((cmd.ftf_flags & IDE_FTFLAG_SET_IN_FLAGS) &&
638 639
	    req_task->in_flags.all == 0) {
		req_task->in_flags.all = IDE_TASKFILE_STD_IN_FLAGS;
640
		if (drive->dev_flags & IDE_DFLAG_LBA48)
641 642
			req_task->in_flags.all |= (IDE_HOB_STD_IN_FLAGS << 8);
	}
Linus Torvalds's avatar
Linus Torvalds committed
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663

	if (copy_to_user(buf, req_task, tasksize)) {
		err = -EFAULT;
		goto abort;
	}
	if (taskout) {
		int outtotal = tasksize;
		if (copy_to_user(buf + outtotal, outbuf, taskout)) {
			err = -EFAULT;
			goto abort;
		}
	}
	if (taskin) {
		int intotal = tasksize + taskout;
		if (copy_to_user(buf + intotal, inbuf, taskin)) {
			err = -EFAULT;
			goto abort;
		}
	}
abort:
	kfree(req_task);
664 665
	kfree(outbuf);
	kfree(inbuf);
Linus Torvalds's avatar
Linus Torvalds committed
666 667 668

	return err;
}
669
#endif