Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 22aa4b32 authored by Bartlomiej Zolnierkiewicz's avatar Bartlomiej Zolnierkiewicz
Browse files

ide: remove ide_task_t typedef 



While at it:
- rename struct ide_task_s to struct ide_cmd
- remove stale comments from idedisk_{read_native,set}_max_address()
- drop unused 'cmd' argument from ide_{cmd,task}_ioctl()
- drop unused 'task' argument from tx4939ide_tf_load_fixup()
- rename ide_complete_task() to ide_complete_cmd()
- use consistent naming for struct ide_cmd variables

There should be no functional changes caused by this patch.

Signed-off-by: default avatarBartlomiej Zolnierkiewicz <bzolnier@gmail.com>
parent e6830a86

drivers/ide/at91_ide.c

+31 −31
Original line number Diff line number Diff line
@@ -185,55 +185,55 @@ static void ide_mm_outb(u8 value, unsigned long port) 
	writeb(value, (void __iomem *) port);

}



static void at91_ide_tf_load(ide_drive_t *drive, ide_task_t *task)

static void at91_ide_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)

{

	ide_hwif_t *hwif = drive->hwif;

	struct ide_io_ports *io_ports = &hwif->io_ports;

	struct ide_taskfile *tf = &task->tf;

	u8 HIHI = (task->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;

	struct ide_taskfile *tf = &cmd->tf;

	u8 HIHI = (cmd->tf_flags & IDE_TFLAG_LBA48) ? 0xE0 : 0xEF;



	if (task->tf_flags & IDE_FTFLAG_FLAGGED)

	if (cmd->tf_flags & IDE_FTFLAG_FLAGGED)

		HIHI = 0xFF;



	if (task->tf_flags & IDE_FTFLAG_OUT_DATA) {

	if (cmd->tf_flags & IDE_FTFLAG_OUT_DATA) {

		u16 data = (tf->hob_data << 8) | tf->data;



		at91_ide_output_data(drive, NULL, &data, 2);

	}



	if (task->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)

	if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_FEATURE)

		ide_mm_outb(tf->hob_feature, io_ports->feature_addr);

	if (task->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)

	if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_NSECT)

		ide_mm_outb(tf->hob_nsect, io_ports->nsect_addr);

	if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)

	if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAL)

		ide_mm_outb(tf->hob_lbal, io_ports->lbal_addr);

	if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)

	if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAM)

		ide_mm_outb(tf->hob_lbam, io_ports->lbam_addr);

	if (task->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)

	if (cmd->tf_flags & IDE_TFLAG_OUT_HOB_LBAH)

		ide_mm_outb(tf->hob_lbah, io_ports->lbah_addr);



	if (task->tf_flags & IDE_TFLAG_OUT_FEATURE)

	if (cmd->tf_flags & IDE_TFLAG_OUT_FEATURE)

		ide_mm_outb(tf->feature, io_ports->feature_addr);

	if (task->tf_flags & IDE_TFLAG_OUT_NSECT)

	if (cmd->tf_flags & IDE_TFLAG_OUT_NSECT)

		ide_mm_outb(tf->nsect, io_ports->nsect_addr);

	if (task->tf_flags & IDE_TFLAG_OUT_LBAL)

	if (cmd->tf_flags & IDE_TFLAG_OUT_LBAL)

		ide_mm_outb(tf->lbal, io_ports->lbal_addr);

	if (task->tf_flags & IDE_TFLAG_OUT_LBAM)

	if (cmd->tf_flags & IDE_TFLAG_OUT_LBAM)

		ide_mm_outb(tf->lbam, io_ports->lbam_addr);

	if (task->tf_flags & IDE_TFLAG_OUT_LBAH)

	if (cmd->tf_flags & IDE_TFLAG_OUT_LBAH)

		ide_mm_outb(tf->lbah, io_ports->lbah_addr);



	if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)

	if (cmd->tf_flags & IDE_TFLAG_OUT_DEVICE)

		ide_mm_outb((tf->device & HIHI) | drive->select, io_ports->device_addr);

}



static void at91_ide_tf_read(ide_drive_t *drive, ide_task_t *task)

static void at91_ide_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)

{

	ide_hwif_t *hwif = drive->hwif;

	struct ide_io_ports *io_ports = &hwif->io_ports;

	struct ide_taskfile *tf = &task->tf;

	struct ide_taskfile *tf = &cmd->tf;



	if (task->tf_flags & IDE_FTFLAG_IN_DATA) {

	if (cmd->tf_flags & IDE_FTFLAG_IN_DATA) {

		u16 data;



		at91_ide_input_data(drive, NULL, &data, 2);
@@ -244,31 +244,31 @@ static void at91_ide_tf_read(ide_drive_t *drive, ide_task_t *task) 
	/* be sure we're looking at the low order bits */

	ide_mm_outb(ATA_DEVCTL_OBS & ~0x80, io_ports->ctl_addr);



	if (task->tf_flags & IDE_TFLAG_IN_FEATURE)

	if (cmd->tf_flags & IDE_TFLAG_IN_FEATURE)

		tf->feature = ide_mm_inb(io_ports->feature_addr);

	if (task->tf_flags & IDE_TFLAG_IN_NSECT)

	if (cmd->tf_flags & IDE_TFLAG_IN_NSECT)

		tf->nsect  = ide_mm_inb(io_ports->nsect_addr);

	if (task->tf_flags & IDE_TFLAG_IN_LBAL)

	if (cmd->tf_flags & IDE_TFLAG_IN_LBAL)

		tf->lbal   = ide_mm_inb(io_ports->lbal_addr);

	if (task->tf_flags & IDE_TFLAG_IN_LBAM)

	if (cmd->tf_flags & IDE_TFLAG_IN_LBAM)

		tf->lbam   = ide_mm_inb(io_ports->lbam_addr);

	if (task->tf_flags & IDE_TFLAG_IN_LBAH)

	if (cmd->tf_flags & IDE_TFLAG_IN_LBAH)

		tf->lbah   = ide_mm_inb(io_ports->lbah_addr);

	if (task->tf_flags & IDE_TFLAG_IN_DEVICE)

	if (cmd->tf_flags & IDE_TFLAG_IN_DEVICE)

		tf->device = ide_mm_inb(io_ports->device_addr);



	if (task->tf_flags & IDE_TFLAG_LBA48) {

	if (cmd->tf_flags & IDE_TFLAG_LBA48) {

		ide_mm_outb(ATA_DEVCTL_OBS | 0x80, io_ports->ctl_addr);



		if (task->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)

		if (cmd->tf_flags & IDE_TFLAG_IN_HOB_FEATURE)

			tf->hob_feature = ide_mm_inb(io_ports->feature_addr);

		if (task->tf_flags & IDE_TFLAG_IN_HOB_NSECT)

		if (cmd->tf_flags & IDE_TFLAG_IN_HOB_NSECT)

			tf->hob_nsect   = ide_mm_inb(io_ports->nsect_addr);

		if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAL)

		if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAL)

			tf->hob_lbal    = ide_mm_inb(io_ports->lbal_addr);

		if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAM)

		if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAM)

			tf->hob_lbam    = ide_mm_inb(io_ports->lbam_addr);

		if (task->tf_flags & IDE_TFLAG_IN_HOB_LBAH)

		if (cmd->tf_flags & IDE_TFLAG_IN_HOB_LBAH)

			tf->hob_lbah    = ide_mm_inb(io_ports->lbah_addr);

	}

}

drivers/ide/ide-acpi.c

+5 −5
Original line number Diff line number Diff line
@@ -304,7 +304,7 @@ static int do_drive_set_taskfiles(ide_drive_t *drive, 
	/* send all taskfile registers (0x1f1-0x1f7) *in*that*order* */

	for (ix = 0; ix < gtf_count; ix++) {

		u8 *gtf = (u8 *)(gtf_address + ix * REGS_PER_GTF);

		ide_task_t task;

		struct ide_cmd cmd;



		DEBPRINT("(0x1f1-1f7): "

			 "hex: %02x %02x %02x %02x %02x %02x %02x\n",
@@ -317,11 +317,11 @@ static int do_drive_set_taskfiles(ide_drive_t *drive, 
		}



		/* convert GTF to taskfile */

		memset(&task, 0, sizeof(ide_task_t));

		memcpy(&task.tf_array[7], gtf, REGS_PER_GTF);

		task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;

		memset(&cmd, 0, sizeof(cmd));

		memcpy(&cmd.tf_array[7], gtf, REGS_PER_GTF);

		cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;



		err = ide_no_data_taskfile(drive, &task);

		err = ide_no_data_taskfile(drive, &cmd);

		if (err) {

			printk(KERN_ERR "%s: ide_no_data_taskfile failed: %u\n",

					__func__, err);

drivers/ide/ide-atapi.c

+21 −21
Original line number Diff line number Diff line
@@ -302,16 +302,16 @@ EXPORT_SYMBOL_GPL(ide_cd_get_xferlen); 


void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason)

{

	ide_task_t task;

	struct ide_cmd cmd;



	memset(&task, 0, sizeof(task));

	task.tf_flags = IDE_TFLAG_IN_LBAH | IDE_TFLAG_IN_LBAM |

	memset(&cmd, 0, sizeof(cmd));

	cmd.tf_flags = IDE_TFLAG_IN_LBAH | IDE_TFLAG_IN_LBAM |

		       IDE_TFLAG_IN_NSECT;



	drive->hwif->tp_ops->tf_read(drive, &task);

	drive->hwif->tp_ops->tf_read(drive, &cmd);



	*bcount = (task.tf.lbah << 8) | task.tf.lbam;

	*ireason = task.tf.nsect & 3;

	*bcount = (cmd.tf.lbah << 8) | cmd.tf.lbam;

	*ireason = cmd.tf.nsect & 3;

}

EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);
@@ -482,32 +482,32 @@ next_irq: 
static void ide_pktcmd_tf_load(ide_drive_t *drive, u32 tf_flags, u16 bcount)

{

	ide_hwif_t *hwif = drive->hwif;

	ide_task_t task;

	struct ide_cmd cmd;

	u8 dma = drive->dma;



	memset(&task, 0, sizeof(task));

	task.tf_flags = IDE_TFLAG_OUT_LBAH | IDE_TFLAG_OUT_LBAM |

	memset(&cmd, 0, sizeof(cmd));

	cmd.tf_flags = IDE_TFLAG_OUT_LBAH | IDE_TFLAG_OUT_LBAM |

		       IDE_TFLAG_OUT_FEATURE | tf_flags;

	task.tf.feature = dma;		/* Use PIO/DMA */

	task.tf.lbam    = bcount & 0xff;

	task.tf.lbah    = (bcount >> 8) & 0xff;

	cmd.tf.feature = dma;		/* Use PIO/DMA */

	cmd.tf.lbam    = bcount & 0xff;

	cmd.tf.lbah    = (bcount >> 8) & 0xff;



	ide_tf_dump(drive->name, &task.tf);

	ide_tf_dump(drive->name, &cmd.tf);

	hwif->tp_ops->set_irq(hwif, 1);

	SELECT_MASK(drive, 0);

	hwif->tp_ops->tf_load(drive, &task);

	hwif->tp_ops->tf_load(drive, &cmd);

}



static u8 ide_read_ireason(ide_drive_t *drive)

{

	ide_task_t task;

	struct ide_cmd cmd;



	memset(&task, 0, sizeof(task));

	task.tf_flags = IDE_TFLAG_IN_NSECT;

	memset(&cmd, 0, sizeof(cmd));

	cmd.tf_flags = IDE_TFLAG_IN_NSECT;



	drive->hwif->tp_ops->tf_read(drive, &task);

	drive->hwif->tp_ops->tf_read(drive, &cmd);



	return task.tf.nsect & 3;

	return cmd.tf.nsect & 3;

}



static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason)

drivers/ide/ide-disk.c

+62 −59
Original line number Diff line number Diff line
@@ -62,24 +62,24 @@ static const u8 ide_data_phases[] = { 
	TASKFILE_OUT_DMA,

};



static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)

static void ide_tf_set_cmd(ide_drive_t *drive, struct ide_cmd *cmd, u8 dma)

{

	u8 index, lba48, write;



	lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;

	write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;

	lba48 = (cmd->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;

	write = (cmd->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;



	if (dma)

		index = 8;

	else

		index = drive->mult_count ? 0 : 4;



	task->tf.command = ide_rw_cmds[index + lba48 + write];

	cmd->tf.command = ide_rw_cmds[index + lba48 + write];



	if (dma)

		index = 8; /* fixup index */



	task->data_phase = ide_data_phases[index / 2 + write];

	cmd->data_phase = ide_data_phases[index / 2 + write];

}



/*
@@ -93,8 +93,8 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, 
	u16 nsectors		= (u16)rq->nr_sectors;

	u8 lba48		= !!(drive->dev_flags & IDE_DFLAG_LBA48);

	u8 dma			= !!(drive->dev_flags & IDE_DFLAG_USING_DMA);

	ide_task_t		task;

	struct ide_taskfile	*tf = &task.tf;

	struct ide_cmd		cmd;

	struct ide_taskfile	*tf = &cmd.tf;

	ide_startstop_t		rc;



	if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
@@ -109,8 +109,8 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, 
		ide_map_sg(drive, rq);

	}



	memset(&task, 0, sizeof(task));

	task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;

	memset(&cmd, 0, sizeof(cmd));

	cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;



	if (drive->dev_flags & IDE_DFLAG_LBA) {

		if (lba48) {
@@ -129,7 +129,7 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, 
			tf->lbam   = (u8)(block >>  8);

			tf->lbah   = (u8)(block >> 16);



			task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);

			cmd.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);

		} else {

			tf->nsect  = nsectors & 0xff;

			tf->lbal   = block;
@@ -157,19 +157,19 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, 
	}



	if (rq_data_dir(rq))

		task.tf_flags |= IDE_TFLAG_WRITE;

		cmd.tf_flags |= IDE_TFLAG_WRITE;



	ide_tf_set_cmd(drive, &task, dma);

	task.rq = rq;

	ide_tf_set_cmd(drive, &cmd, dma);

	cmd.rq = rq;



	rc = do_rw_taskfile(drive, &task);

	rc = do_rw_taskfile(drive, &cmd);



	if (rc == ide_stopped && dma) {

		/* fallback to PIO */

		task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;

		ide_tf_set_cmd(drive, &task, 0);

		cmd.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;

		ide_tf_set_cmd(drive, &cmd, 0);

		ide_init_sg_cmd(drive, rq);

		rc = do_rw_taskfile(drive, &task);

		rc = do_rw_taskfile(drive, &cmd);

	}



	return rc;
@@ -213,22 +213,22 @@ static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq, 
 */

static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)

{

	ide_task_t args;

	struct ide_taskfile *tf = &args.tf;

	struct ide_cmd cmd;

	struct ide_taskfile *tf = &cmd.tf;

	u64 addr = 0;



	/* Create IDE/ATA command request structure */

	memset(&args, 0, sizeof(ide_task_t));

	memset(&cmd, 0, sizeof(cmd));

	if (lba48)

		tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;

	else

		tf->command = ATA_CMD_READ_NATIVE_MAX;

	tf->device  = ATA_LBA;

	args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;



	cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;

	if (lba48)

		args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);

	/* submit command request */

	ide_no_data_taskfile(drive, &args);

		cmd.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);



	ide_no_data_taskfile(drive, &cmd);



	/* if OK, compute maximum address value */

	if ((tf->status & 0x01) == 0)
@@ -243,13 +243,13 @@ static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48) 
 */

static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)

{

	ide_task_t args;

	struct ide_taskfile *tf = &args.tf;

	struct ide_cmd cmd;

	struct ide_taskfile *tf = &cmd.tf;

	u64 addr_set = 0;



	addr_req--;

	/* Create IDE/ATA command request structure */

	memset(&args, 0, sizeof(ide_task_t));



	memset(&cmd, 0, sizeof(cmd));

	tf->lbal     = (addr_req >>  0) & 0xff;

	tf->lbam     = (addr_req >>= 8) & 0xff;

	tf->lbah     = (addr_req >>= 8) & 0xff;
@@ -263,11 +263,13 @@ static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48) 
		tf->command  = ATA_CMD_SET_MAX;

	}

	tf->device |= ATA_LBA;

	args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;



	cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;

	if (lba48)

		args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);

	/* submit command request */

	ide_no_data_taskfile(drive, &args);

		cmd.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);



	ide_no_data_taskfile(drive, &cmd);



	/* if OK, compute maximum address value */

	if ((tf->status & 0x01) == 0)

		addr_set = ide_get_lba_addr(tf, lba48) + 1;
@@ -386,24 +388,24 @@ static int ide_disk_get_capacity(ide_drive_t *drive) 
static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)

{

	ide_drive_t *drive = q->queuedata;

	ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);

	struct ide_cmd *cmd = kmalloc(sizeof(*cmd), GFP_ATOMIC);



	/* FIXME: map struct ide_taskfile on rq->cmd[] */

	BUG_ON(task == NULL);

	BUG_ON(cmd == NULL);



	memset(task, 0, sizeof(*task));

	memset(cmd, 0, sizeof(*cmd));

	if (ata_id_flush_ext_enabled(drive->id) &&

	    (drive->capacity64 >= (1UL << 28)))

		task->tf.command = ATA_CMD_FLUSH_EXT;

		cmd->tf.command = ATA_CMD_FLUSH_EXT;

	else

		task->tf.command = ATA_CMD_FLUSH;

	task->tf_flags	 = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |

		cmd->tf.command = ATA_CMD_FLUSH;

	cmd->tf_flags	 = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |

			   IDE_TFLAG_DYN;

	task->data_phase = TASKFILE_NO_DATA;

	cmd->data_phase = TASKFILE_NO_DATA;



	rq->cmd_type = REQ_TYPE_ATA_TASKFILE;

	rq->cmd_flags |= REQ_SOFTBARRIER;

	rq->special = task;

	rq->special = cmd;

}



ide_devset_get(multcount, mult_count);
@@ -453,15 +455,15 @@ static int set_nowerr(ide_drive_t *drive, int arg) 


static int ide_do_setfeature(ide_drive_t *drive, u8 feature, u8 nsect)

{

	ide_task_t task;

	struct ide_cmd cmd;



	memset(&task, 0, sizeof(task));

	task.tf.feature = feature;

	task.tf.nsect   = nsect;

	task.tf.command = ATA_CMD_SET_FEATURES;

	task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;

	memset(&cmd, 0, sizeof(cmd));

	cmd.tf.feature = feature;

	cmd.tf.nsect   = nsect;

	cmd.tf.command = ATA_CMD_SET_FEATURES;

	cmd.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;



	return ide_no_data_taskfile(drive, &task);

	return ide_no_data_taskfile(drive, &cmd);

}



static void update_ordered(ide_drive_t *drive)
@@ -528,15 +530,16 @@ static int set_wcache(ide_drive_t *drive, int arg) 


static int do_idedisk_flushcache(ide_drive_t *drive)

{

	ide_task_t args;

	struct ide_cmd cmd;



	memset(&args, 0, sizeof(ide_task_t));

	memset(&cmd, 0, sizeof(cmd));

	if (ata_id_flush_ext_enabled(drive->id))

		args.tf.command = ATA_CMD_FLUSH_EXT;

		cmd.tf.command = ATA_CMD_FLUSH_EXT;

	else

		args.tf.command = ATA_CMD_FLUSH;

	args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;

	return ide_no_data_taskfile(drive, &args);

		cmd.tf.command = ATA_CMD_FLUSH;

	cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;



	return ide_no_data_taskfile(drive, &cmd);

}



ide_devset_get(acoustic, acoustic);
@@ -708,17 +711,17 @@ static int ide_disk_init_media(ide_drive_t *drive, struct gendisk *disk) 
static int ide_disk_set_doorlock(ide_drive_t *drive, struct gendisk *disk,

				 int on)

{

	ide_task_t task;

	struct ide_cmd cmd;

	int ret;



	if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)

		return 0;



	memset(&task, 0, sizeof(task));

	task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;

	task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;

	memset(&cmd, 0, sizeof(cmd));

	cmd.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;

	cmd.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;



	ret = ide_no_data_taskfile(drive, &task);

	ret = ide_no_data_taskfile(drive, &cmd);



	if (ret)

		drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;

drivers/ide/ide-disk_proc.c

+12 −11
Original line number Diff line number Diff line
@@ -6,33 +6,34 @@ 


static int smart_enable(ide_drive_t *drive)

{

	ide_task_t args;

	struct ide_taskfile *tf = &args.tf;

	struct ide_cmd cmd;

	struct ide_taskfile *tf = &cmd.tf;



	memset(&args, 0, sizeof(ide_task_t));

	memset(&cmd, 0, sizeof(cmd));

	tf->feature = ATA_SMART_ENABLE;

	tf->lbam    = ATA_SMART_LBAM_PASS;

	tf->lbah    = ATA_SMART_LBAH_PASS;

	tf->command = ATA_CMD_SMART;

	args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;

	return ide_no_data_taskfile(drive, &args);

	cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;



	return ide_no_data_taskfile(drive, &cmd);

}



static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)

{

	ide_task_t args;

	struct ide_taskfile *tf = &args.tf;

	struct ide_cmd cmd;

	struct ide_taskfile *tf = &cmd.tf;



	memset(&args, 0, sizeof(ide_task_t));

	memset(&cmd, 0, sizeof(cmd));

	tf->feature = sub_cmd;

	tf->nsect   = 0x01;

	tf->lbam    = ATA_SMART_LBAM_PASS;

	tf->lbah    = ATA_SMART_LBAH_PASS;

	tf->command = ATA_CMD_SMART;

	args.tf_flags	= IDE_TFLAG_TF | IDE_TFLAG_DEVICE;

	args.data_phase	= TASKFILE_IN;

	cmd.tf_flags	= IDE_TFLAG_TF | IDE_TFLAG_DEVICE;

	cmd.data_phase	= TASKFILE_IN;



	return ide_raw_taskfile(drive, &args, buf, 1);

	return ide_raw_taskfile(drive, &cmd, buf, 1);

}



static int proc_idedisk_read_cache