#elseint ide_diag_taskfile (ide_drive_t *drive, ide_task_t *args, unsigned long data_size, u8 *buf){	struct request *rq;	unsigned long flags;	ide_hwgroup_t *hwgroup = HWGROUP(drive);	unsigned int major = HWIF(drive)->major;	struct list_head *queue_head = &drive->queue.queue_head;	DECLARE_COMPLETION(wait);	if (HWIF(drive)->chipset == ide_pdc4030 && buf != NULL)		return -ENOSYS; /* special drive cmds not supported */	memset(rq, 0, sizeof(*rq));	rq->cmd = IDE_DRIVE_TASKFILE;	rq->buffer = buf;	/*	 * (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.	 */	if (args->command_type != IDE_DRIVE_TASK_NO_DATA) {		if (data_size == 0) {			ata_nsector_t nsector;			nsector.b.low = args->hobRegister[IDE_NSECTOR_OFFSET_HOB];			nsector.b.high = args->tfRegister[IDE_NSECTOR_OFFSET];			rq.nr_sectors = nsector.all;		} else {			rq.nr_sectors = data_size / SECTOR_SIZE;		}		rq.current_nr_sectors = rq.nr_sectors;	//	rq.hard_cur_sectors = rq.nr_sectors;	}	if (args->tf_out_flags.all == 0) {		/*		 * clean up kernel settings for driver sanity, regardless.		 * except for discrete diag services.		 */		args->posthandler = ide_post_handler_parser(				(struct hd_drive_task_hdr *) args->tfRegister,				(struct hd_drive_hob_hdr *) args->hobRegister);	}	rq->special = args;	rq->errors = 0;	rq->rq_status = RQ_ACTIVE;	rq->rq_dev = MKDEV(major,(drive->select.b.unit)<<PARTN_BITS);	rq->waiting = &wait;	spin_lock_irqsave(&io_request_lock, flags);	queue_head = queue_head->prev;	list_add(&rq->queue, queue_head);	ide_do_request(hwgroup, 0);	spin_unlock_irqrestore(&io_request_lock, flags);	wait_for_completion(&wait);	/* wait for it to be serviced */	return rq->errors ? -EIO : 0;	/* return -EIO if errors */}#endifEXPORT_SYMBOL(ide_diag_taskfile);int ide_raw_taskfile (ide_drive_t *drive, ide_task_t *args, u8 *buf){	return ide_diag_taskfile(drive, args, 0, buf);}EXPORT_SYMBOL(ide_raw_taskfile);	#ifdef CONFIG_IDE_TASK_IOCTL_DEBUGchar * ide_ioctl_verbose (unsigned int cmd){	return("unknown");}char * ide_task_cmd_verbose (u8 task){	return("unknown");}#endif /* CONFIG_IDE_TASK_IOCTL_DEBUG */#define MAX_DMA		(256*SECTOR_WORDS)ide_startstop_t flagged_taskfile(ide_drive_t *, ide_task_t *);ide_startstop_t flagged_task_no_data_intr(ide_drive_t *);ide_startstop_t flagged_task_in_intr(ide_drive_t *);ide_startstop_t flagged_task_mulin_intr(ide_drive_t *);ide_startstop_t flagged_pre_task_out_intr(ide_drive_t *, struct request *);ide_startstop_t flagged_task_out_intr(ide_drive_t *);ide_startstop_t flagged_pre_task_mulout_intr(ide_drive_t *, struct request *);ide_startstop_t flagged_task_mulout_intr(ide_drive_t *);int ide_taskfile_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg){	ide_task_request_t	*req_task;	ide_task_t		args;	u8 *outbuf		= NULL;	u8 *inbuf		= NULL;	task_ioreg_t *argsptr	= args.tfRegister;	task_ioreg_t *hobsptr	= args.hobRegister;	int err			= 0;	int tasksize		= sizeof(struct ide_task_request_s);	int taskin		= 0;	int taskout		= 0;	u8 io_32bit		= drive->io_32bit;//	printk("IDE Taskfile ...\n");	req_task = kmalloc(tasksize, GFP_KERNEL);	if (req_task == NULL) return -ENOMEM;	memset(req_task, 0, tasksize);	if (copy_from_user(req_task, (void *) arg, tasksize)) {		kfree(req_task);		return -EFAULT;	}	taskout = (int) req_task->out_size;	taskin  = (int) req_task->in_size;	if (taskout) {		int outtotal = tasksize;		outbuf = kmalloc(taskout, GFP_KERNEL);		if (outbuf == NULL) {			err = -ENOMEM;			goto abort;		}		memset(outbuf, 0, taskout);		if (copy_from_user(outbuf, (void *)arg + outtotal, taskout)) {			err = -EFAULT;			goto abort;		}	}	if (taskin) {		int intotal = tasksize + taskout;		inbuf = kmalloc(taskin, GFP_KERNEL);		if (inbuf == NULL) {			err = -ENOMEM;			goto abort;		}		memset(inbuf, 0, taskin);		if (copy_from_user(inbuf, (void *)arg + intotal , taskin)) {			err = -EFAULT;			goto abort;		}	}	memset(&args, 0, sizeof(ide_task_t));	memcpy(argsptr, req_task->io_ports, HDIO_DRIVE_TASK_HDR_SIZE);	memcpy(hobsptr, req_task->hob_ports, HDIO_DRIVE_HOB_HDR_SIZE);	args.tf_in_flags  = req_task->in_flags;	args.tf_out_flags = req_task->out_flags;	args.data_phase   = req_task->data_phase;	args.command_type = req_task->req_cmd;#ifdef CONFIG_IDE_TASK_IOCTL_DEBUG	DTF("%s: ide_ioctl_cmd %s:  ide_task_cmd %s\n",		drive->name,		ide_ioctl_verbose(cmd),		ide_task_cmd_verbose(args.tfRegister[IDE_COMMAND_OFFSET]));#endif /* CONFIG_IDE_TASK_IOCTL_DEBUG */	drive->io_32bit = 0;	switch(req_task->data_phase) {		case TASKFILE_OUT_DMAQ:		case TASKFILE_OUT_DMA:			err = ide_diag_taskfile(drive, &args, taskout, outbuf);			break;		case TASKFILE_IN_DMAQ:		case TASKFILE_IN_DMA:			err = ide_diag_taskfile(drive, &args, taskin, inbuf);			break;		case TASKFILE_IN_OUT:#if 0			args.prehandler = &pre_task_out_intr;			args.handler = &task_out_intr;			args.posthandler = NULL;			err = ide_diag_taskfile(drive, &args, taskout, outbuf);			args.prehandler = NULL;			args.handler = &task_in_intr;			args.posthandler = NULL;			err = ide_diag_taskfile(drive, &args, taskin, inbuf);			break;#else			err = -EFAULT;			goto abort;#endif		case TASKFILE_MULTI_OUT:			if (!drive->mult_count) {				/* (hs): give up if multcount is not set */				printk(KERN_ERR "%s: %s Multimode Write " \					"multcount is not set\n",					drive->name, __FUNCTION__);				err = -EPERM;				goto abort;			}			if (args.tf_out_flags.all != 0) {				args.prehandler = &flagged_pre_task_mulout_intr;				args.handler = &flagged_task_mulout_intr;			} else {				args.prehandler = &pre_task_mulout_intr;				args.handler = &task_mulout_intr;			}			err = ide_diag_taskfile(drive, &args, taskout, outbuf);			break;		case TASKFILE_OUT:			if (args.tf_out_flags.all != 0) {				args.prehandler = &flagged_pre_task_out_intr;				args.handler    = &flagged_task_out_intr;			} else {				args.prehandler = &pre_task_out_intr;				args.handler = &task_out_intr;			}			err = ide_diag_taskfile(drive, &args, taskout, outbuf);			break;		case TASKFILE_MULTI_IN:			if (!drive->mult_count) {				/* (hs): give up if multcount is not set */				printk(KERN_ERR "%s: %s Multimode Read failure " \					"multcount is not set\n",					drive->name, __FUNCTION__);				err = -EPERM;				goto abort;			}			if (args.tf_out_flags.all != 0) {				args.handler = &flagged_task_mulin_intr;			} else {				args.handler = &task_mulin_intr;			}			err = ide_diag_taskfile(drive, &args, taskin, inbuf);			break;		case TASKFILE_IN:			if (args.tf_out_flags.all != 0) {				args.handler = &flagged_task_in_intr;			} else {				args.handler = &task_in_intr;			}			err = ide_diag_taskfile(drive, &args, taskin, inbuf);			break;		case TASKFILE_NO_DATA:			if (args.tf_out_flags.all != 0) {				args.handler = &flagged_task_no_data_intr;			} else {				args.handler = &task_no_data_intr;			}			err = ide_diag_taskfile(drive, &args, 0, NULL);			break;		default:			err = -EFAULT;			goto abort;	}	memcpy(req_task->io_ports, &(args.tfRegister), HDIO_DRIVE_TASK_HDR_SIZE);	memcpy(req_task->hob_ports, &(args.hobRegister), HDIO_DRIVE_HOB_HDR_SIZE);	req_task->in_flags  = args.tf_in_flags;	req_task->out_flags = args.tf_out_flags;	if (copy_to_user((void *)arg, req_task, tasksize)) {		err = -EFAULT;		goto abort;	}	if (taskout) {		int outtotal = tasksize;		if (copy_to_user((void *)arg+outtotal, outbuf, taskout)) {			err = -EFAULT;			goto abort;		}	}	if (taskin) {		int intotal = tasksize + taskout;		if (copy_to_user((void *)arg+intotal, inbuf, taskin)) {			err = -EFAULT;			goto abort;		}	}abort:	kfree(req_task);	if (outbuf != NULL)		kfree(outbuf);	if (inbuf != NULL)		kfree(inbuf);//	printk("IDE Taskfile ioctl ended. rc = %i\n", err);	drive->io_32bit = io_32bit;	return err;}EXPORT_SYMBOL(ide_taskfile_ioctl);int ide_wait_cmd (ide_drive_t *drive, u8 cmd, u8 nsect, u8 feature, u8 sectors, u8 *buf){	struct request rq;	u8 buffer[4];	if (!buf)		buf = buffer;	memset(buf, 0, 4 + SECTOR_WORDS * 4 * sectors);	ide_init_drive_cmd(&rq);	rq.buffer = buf;	*buf++ = cmd;	*buf++ = nsect;	*buf++ = feature;	*buf++ = sectors;	return ide_do_drive_cmd(drive, &rq, ide_wait);}EXPORT_SYMBOL(ide_wait_cmd);/* * FIXME : this needs to map into at taskfile. <andre@linux-ide.org> */int ide_cmd_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg){#if 1	int err = -EIO;	u8 args[4], *argbuf = args;	u8 xfer_rate = 0;	int argsize = 4;	ide_task_t tfargs;	if (NULL == (void *) arg) {		struct request rq;		ide_init_drive_cmd(&rq);		return ide_do_drive_cmd(drive, &rq, ide_wait);	}	if (copy_from_user(args, (void *)arg, 4))		return -EFAULT;	memset(&tfargs, 0, sizeof(ide_task_t));	tfargs.tfRegister[IDE_FEATURE_OFFSET] = args[2];	tfargs.tfRegister[IDE_NSECTOR_OFFSET] = args[3];	tfargs.tfRegister[IDE_SECTOR_OFFSET]  = args[1];	tfargs.tfRegister[IDE_LCYL_OFFSET]    = 0x00;	tfargs.tfRegister[IDE_HCYL_OFFSET]    = 0x00;	tfargs.tfRegister[IDE_SELECT_OFFSET]  = 0x00;	tfargs.tfRegister[IDE_COMMAND_OFFSET] = args[0];	if (args[3]) {		argsize = 4 + (SECTOR_WORDS * 4 * args[3]);		argbuf = kmalloc(argsize, GFP_KERNEL);		if (argbuf == NULL)			return -ENOMEM;		memcpy(argbuf, args, 4);	}	if (set_transfer(drive, &tfargs)) {		xfer_rate = args[1];		if (ide_ata66_check(drive, &tfargs))			goto abort;	}	err = ide_wait_cmd(drive, args[0], args[1], args[2], args[3], argbuf);	if (!err && xfer_rate) {		/* active-retuning-calls future */		ide_set_xfer_rate(drive, xfer_rate);		ide_driveid_update(drive);	}abort:	if (copy_to_user((void *)arg, argbuf, argsize))		err = -EFAULT;	if (argsize > 4)		kfree(argbuf);	return err;#else	int err = 0;	u8 args[4], *argbuf = args;	u8 xfer_rate = 0;	int argsize = 0;	ide_task_t tfargs;	if (NULL == (void *) arg) {		struct request rq;		ide_init_drive_cmd(&rq);		return ide_do_drive_cmd(drive, &rq, ide_wait);	}	if (copy_from_user(args, (void *)arg, 4))		return -EFAULT;	memset(&tfargs, 0, sizeof(ide_task_t));	tfargs.tfRegister[IDE_FEATURE_OFFSET] = args[2];	tfargs.tfRegister[IDE_NSECTOR_OFFSET] = args[3];	tfargs.tfRegister[IDE_SECTOR_OFFSET]  = args[1];	tfargs.tfRegister[IDE_LCYL_OFFSET]    = 0x00;	tfargs.tfRegister[IDE_HCYL_OFFSET]    = 0x00;	tfargs.tfRegister[IDE_SELECT_OFFSET]  = 0x00;	tfargs.tfRegister[IDE_COMMAND_OFFSET] = args[0];	if (args[3]) {		argsize = (SECTOR_WORDS * 4 * args[3]);		argbuf = kmalloc(argsize, GFP_KERNEL);		if (argbuf == NULL)			return -ENOMEM;	}	if (set_transfer(drive, &tfargs)) {		xfer_rate = args[1];		if (ide_ata66_check(drive, &tfargs))			goto abort;	}	tfargs.command_type = ide_cmd_type_parser(&tfargs);	err = ide_raw_taskfile(drive, &tfargs, argbuf);	if (!err && xfer_rate) {		/* active-retuning-calls future */		ide_set_xfer_rate(drive, xfer_rate);		ide_driveid_update(drive);	}abort:	args[0] = tfargs.tfRegister[IDE_COMMAND_OFFSET];	args[1] = tfargs.tfRegister[IDE_FEATURE_OFFSET];	args[2] = tfargs.tfRegister[IDE_NSECTOR_OFFSET];	args[3] = 0;	if (copy_to_user((void *)arg, argbuf, 4))		err = -EFAULT;	if (argbuf != NULL) {		if (copy_to_user((void *)arg, argbuf + 4, argsize))			err = -EFAULT;		kfree(argbuf);	}	return err;#endif}EXPORT_SYMBOL(ide_cmd_ioctl);int ide_wait_cmd_task (ide_drive_t *drive, u8 *buf){	struct request rq;	ide_init_drive_cmd(&rq);	rq.cmd = IDE_DRIVE_TASK;	rq.buffer = buf;	return ide_do_drive_cmd(drive, &rq, ide_wait);}