Merge branch 'bp-remove-pc-buf' into for-next (8dcce408) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/ide/ide-atapi.c

+87 −51

Original line number	Diff line number	Diff line
		@@ -10,6 +10,9 @@

		#include <scsi/scsi.h>

		#define DRV_NAME "ide-atapi"
		#define PFX DRV_NAME ": "

		#ifdef DEBUG
		#define debug_log(fmt, args...) \
		printk(KERN_INFO "ide: " fmt, ## args)
		@@ -74,8 +77,6 @@ EXPORT_SYMBOL_GPL(ide_check_atapi_device);
		void ide_init_pc(struct ide_atapi_pc *pc)
		{
		memset(pc, 0, sizeof(*pc));
		pc->buf = pc->pc_buf;
		pc->buf_size = IDE_PC_BUFFER_SIZE;
		}
		EXPORT_SYMBOL_GPL(ide_init_pc);

		@@ -84,7 +85,7 @@ EXPORT_SYMBOL_GPL(ide_init_pc);
		* and wait for it to be serviced.
		*/
		int ide_queue_pc_tail(ide_drive_t drive, struct gendisk disk,
		struct ide_atapi_pc *pc)
		struct ide_atapi_pc pc, void buf, unsigned int bufflen)
		{
		struct request *rq;
		int error;
		@@ -93,8 +94,8 @@ int ide_queue_pc_tail(ide_drive_t drive, struct gendisk disk,
		rq->cmd_type = REQ_TYPE_SPECIAL;
		rq->special = (char *)pc;

		if (pc->req_xfer) {
		error = blk_rq_map_kern(drive->queue, rq, pc->buf, pc->req_xfer,
		if (buf && bufflen) {
		error = blk_rq_map_kern(drive->queue, rq, buf, bufflen,
		GFP_NOIO);
		if (error)
		goto put_req;
		@@ -117,7 +118,7 @@ int ide_do_test_unit_ready(ide_drive_t drive, struct gendisk disk)
		ide_init_pc(&pc);
		pc.c[0] = TEST_UNIT_READY;

		return ide_queue_pc_tail(drive, disk, &pc);
		return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
		}
		EXPORT_SYMBOL_GPL(ide_do_test_unit_ready);

		@@ -132,7 +133,7 @@ int ide_do_start_stop(ide_drive_t drive, struct gendisk disk, int start)
		if (drive->media == ide_tape)
		pc.flags \|= PC_FLAG_WAIT_FOR_DSC;

		return ide_queue_pc_tail(drive, disk, &pc);
		return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
		}
		EXPORT_SYMBOL_GPL(ide_do_start_stop);

		@@ -147,7 +148,7 @@ int ide_set_media_lock(ide_drive_t drive, struct gendisk disk, int on)
		pc.c[0] = ALLOW_MEDIUM_REMOVAL;
		pc.c[4] = on;

		return ide_queue_pc_tail(drive, disk, &pc);
		return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
		}
		EXPORT_SYMBOL_GPL(ide_set_media_lock);

		@@ -172,8 +173,6 @@ void ide_prep_sense(ide_drive_t drive, struct request rq)
		unsigned int cmd_len, sense_len;
		int err;

		debug_log("%s: enter\n", __func__);

		switch (drive->media) {
		case ide_floppy:
		cmd_len = 255;
		@@ -201,8 +200,8 @@ void ide_prep_sense(ide_drive_t drive, struct request rq)
		GFP_NOIO);
		if (unlikely(err)) {
		if (printk_ratelimit())
		printk(KERN_WARNING "%s: failed to map sense buffer\n",
		drive->name);
		printk(KERN_WARNING PFX "%s: failed to map sense "
		"buffer\n", drive->name);
		return;
		}

		@@ -223,7 +222,7 @@ int ide_queue_sense_rq(ide_drive_t drive, void special)
		{
		/* deferred failure from ide_prep_sense() */
		if (!drive->sense_rq_armed) {
		printk(KERN_WARNING "%s: failed queue sense request\n",
		printk(KERN_WARNING PFX "%s: error queuing a sense request\n",
		drive->name);
		return -ENOMEM;
		}
		@@ -255,8 +254,6 @@ void ide_retry_pc(ide_drive_t *drive)
		/* init pc from sense_rq */
		ide_init_pc(pc);
		memcpy(pc->c, sense_rq->cmd, 12);
		pc->buf = bio_data(sense_rq->bio); /* pointer to mapped address */
		pc->req_xfer = blk_rq_bytes(sense_rq);

		if (drive->media == ide_tape)
		drive->atapi_flags \|= IDE_AFLAG_IGNORE_DSC;
		@@ -298,7 +295,7 @@ int ide_cd_expiry(ide_drive_t *drive)
		break;
		default:
		if (!(rq->cmd_flags & REQ_QUIET))
		printk(KERN_INFO "cmd 0x%x timed out\n",
		printk(KERN_INFO PFX "cmd 0x%x timed out\n",
		rq->cmd[0]);
		wait = 0;
		break;
		@@ -331,6 +328,55 @@ void ide_read_bcount_and_ireason(ide_drive_t drive, u16 bcount, u8 *ireason)
		}
		EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);

		/*
		* Check the contents of the interrupt reason register and attempt to recover if
		* there are problems.
		*
		* Returns:
		* - 0 if everything's ok
		* - 1 if the request has to be terminated.
		*/
		int ide_check_ireason(ide_drive_t drive, struct request rq, int len,
		int ireason, int rw)
		{
		ide_hwif_t *hwif = drive->hwif;

		debug_log("ireason: 0x%x, rw: 0x%x\n", ireason, rw);

		if (ireason == (!rw << 1))
		return 0;
		else if (ireason == (rw << 1)) {
		printk(KERN_ERR PFX "%s: %s: wrong transfer direction!\n",
		drive->name, __func__);

		if (dev_is_idecd(drive))
		ide_pad_transfer(drive, rw, len);
		} else if (!rw && ireason == ATAPI_COD) {
		if (dev_is_idecd(drive)) {
		/*
		* Some drives (ASUS) seem to tell us that status info
		* is available. Just get it and ignore.
		*/
		(void)hwif->tp_ops->read_status(hwif);
		return 0;
		}
		} else {
		if (ireason & ATAPI_COD)
		printk(KERN_ERR PFX "%s: CoD != 0 in %s\n", drive->name,
		__func__);

		/* drive wants a command packet, or invalid ireason... */
		printk(KERN_ERR PFX "%s: %s: bad interrupt reason 0x%02x\n",
		drive->name, __func__, ireason);
		}

		if (dev_is_idecd(drive) && rq->cmd_type == REQ_TYPE_ATA_PC)
		rq->cmd_flags \|= REQ_FAILED;

		return 1;
		}
		EXPORT_SYMBOL_GPL(ide_check_ireason);

		/*
		* This is the usual interrupt handler which will be called during a packet
		* command. We will transfer some of the data (as requested by the drive)
		@@ -365,12 +411,12 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)

		if (rc \|\| (drive->media == ide_tape && (stat & ATA_ERR))) {
		if (drive->media == ide_floppy)
		printk(KERN_ERR "%s: DMA %s error\n",
		printk(KERN_ERR PFX "%s: DMA %s error\n",
		drive->name, rq_data_dir(pc->rq)
		? "write" : "read");
		pc->flags \|= PC_FLAG_DMA_ERROR;
		} else
		pc->xferred = pc->req_xfer;
		rq->resid_len = 0;
		debug_log("%s: DMA finished\n", drive->name);
		}

		@@ -379,7 +425,7 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
		int uptodate, error;

		debug_log("Packet command completed, %d bytes transferred\n",
		pc->xferred);
		blk_rq_bytes(rq));

		pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;

		@@ -397,8 +443,8 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
		pc->rq->errors++;

		if (rq->cmd[0] == REQUEST_SENSE) {
		printk(KERN_ERR "%s: I/O error in request sense"
		" command\n", drive->name);
		printk(KERN_ERR PFX "%s: I/O error in request "
		"sense command\n", drive->name);
		return ide_do_reset(drive);
		}

		@@ -446,8 +492,8 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)

		if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
		pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
		printk(KERN_ERR "%s: The device wants to issue more interrupts "
		"in DMA mode\n", drive->name);
		printk(KERN_ERR PFX "%s: The device wants to issue more "
		"interrupts in DMA mode\n", drive->name);
		ide_dma_off(drive);
		return ide_do_reset(drive);
		}
		@@ -455,33 +501,22 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
		/* Get the number of bytes to transfer on this interrupt. */
		ide_read_bcount_and_ireason(drive, &bcount, &ireason);

		if (ireason & ATAPI_COD) {
		printk(KERN_ERR "%s: CoD != 0 in %s\n", drive->name, __func__);
		return ide_do_reset(drive);
		}

		if (((ireason & ATAPI_IO) == ATAPI_IO) == write) {
		/* Hopefully, we will never get here */
		printk(KERN_ERR "%s: We wanted to %s, but the device wants us "
		"to %s!\n", drive->name,
		(ireason & ATAPI_IO) ? "Write" : "Read",
		(ireason & ATAPI_IO) ? "Read" : "Write");
		if (ide_check_ireason(drive, rq, bcount, ireason, write))
		return ide_do_reset(drive);
		}

		done = min_t(unsigned int, bcount, cmd->nleft);
		ide_pio_bytes(drive, cmd, write, done);

		/* Update transferred byte count */
		pc->xferred += done;
		rq->resid_len -= done;

		bcount -= done;

		if (bcount)
		ide_pad_transfer(drive, write, bcount);

		debug_log("[cmd %x] transferred %d bytes, padded %d bytes\n",
		rq->cmd[0], done, bcount);
		debug_log("[cmd %x] transferred %d bytes, padded %d bytes, resid: %u\n",
		rq->cmd[0], done, bcount, rq->resid_len);

		/* And set the interrupt handler again */
		ide_set_handler(drive, ide_pc_intr, timeout);
		@@ -515,12 +550,12 @@ static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason)

		while (retries-- && ((ireason & ATAPI_COD) == 0 \|\|
		(ireason & ATAPI_IO))) {
		printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing "
		printk(KERN_ERR PFX "%s: (IO,CoD != (0,1) while issuing "
		"a packet command, retrying\n", drive->name);
		udelay(100);
		ireason = ide_read_ireason(drive);
		if (retries == 0) {
		printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing "
		printk(KERN_ERR PFX "%s: (IO,CoD != (0,1) while issuing"
		" a packet command, ignoring\n",
		drive->name);
		ireason \|= ATAPI_COD;
		@@ -552,7 +587,7 @@ static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
		u8 ireason;

		if (ide_wait_stat(&startstop, drive, ATA_DRQ, ATA_BUSY, WAIT_READY)) {
		printk(KERN_ERR "%s: Strange, packet command initiated yet "
		printk(KERN_ERR PFX "%s: Strange, packet command initiated yet "
		"DRQ isn't asserted\n", drive->name);
		return startstop;
		}
		@@ -594,8 +629,8 @@ static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
		ireason = ide_wait_ireason(drive, ireason);

		if ((ireason & ATAPI_COD) == 0 \|\| (ireason & ATAPI_IO)) {
		printk(KERN_ERR "%s: (IO,CoD) != (0,1) while issuing "
		"a packet command\n", drive->name);
		printk(KERN_ERR PFX "%s: (IO,CoD) != (0,1) while "
		"issuing a packet command\n", drive->name);

		return ide_do_reset(drive);
		}
		@@ -633,7 +668,7 @@ ide_startstop_t ide_issue_pc(ide_drive_t drive, struct ide_cmd cmd)
		ide_hwif_t *hwif = drive->hwif;
		ide_expiry_t *expiry = NULL;
		struct request *rq = hwif->rq;
		unsigned int timeout;
		unsigned int timeout, bytes;
		u16 bcount;
		u8 valid_tf;
		u8 drq_int = !!(drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT);
		@@ -649,13 +684,14 @@ ide_startstop_t ide_issue_pc(ide_drive_t drive, struct ide_cmd cmd)
		} else {
		pc = drive->pc;

		/* We haven't transferred any data yet */
		pc->xferred = 0;

		valid_tf = IDE_VALID_DEVICE;
		bcount = ((drive->media == ide_tape) ?
		pc->req_xfer :
		min(pc->req_xfer, 63 * 1024));
		bytes = blk_rq_bytes(rq);
		bcount = ((drive->media == ide_tape) ? bytes
		: min_t(unsigned int,
		bytes, 63 * 1024));

		/* We haven't transferred any data yet */
		rq->resid_len = bcount;

		if (pc->flags & PC_FLAG_DMA_ERROR) {
		pc->flags &= ~PC_FLAG_DMA_ERROR;

drivers/ide/ide-cd.c

+11 −57

Original line number	Diff line number	Diff line
		@@ -92,16 +92,16 @@ static void cdrom_saw_media_change(ide_drive_t *drive)
		drive->atapi_flags &= ~IDE_AFLAG_TOC_VALID;
		}

		static int cdrom_log_sense(ide_drive_t drive, struct request rq,
		struct request_sense *sense)
		static int cdrom_log_sense(ide_drive_t drive, struct request rq)
		{
		struct request_sense *sense = &drive->sense_data;
		int log = 0;

		ide_debug_log(IDE_DBG_SENSE, "sense_key: 0x%x", sense->sense_key);

		if (!sense \|\| !rq \|\| (rq->cmd_flags & REQ_QUIET))
		return 0;

		ide_debug_log(IDE_DBG_SENSE, "sense_key: 0x%x", sense->sense_key);

		switch (sense->sense_key) {
		case NO_SENSE:
		case RECOVERED_ERROR:
		@@ -140,12 +140,12 @@ static int cdrom_log_sense(ide_drive_t drive, struct request rq,
		}

		static void cdrom_analyze_sense_data(ide_drive_t *drive,
		struct request *failed_command,
		struct request_sense *sense)
		struct request *failed_command)
		{
		struct request_sense *sense = &drive->sense_data;
		struct cdrom_info *info = drive->driver_data;
		unsigned long sector;
		unsigned long bio_sectors;
		struct cdrom_info *info = drive->driver_data;

		ide_debug_log(IDE_DBG_SENSE, "error_code: 0x%x, sense_key: 0x%x",
		sense->error_code, sense->sense_key);
		@@ -154,7 +154,7 @@ static void cdrom_analyze_sense_data(ide_drive_t *drive,
		ide_debug_log(IDE_DBG_SENSE, "failed cmd: 0x%x",
		failed_command->cmd[0]);

		if (!cdrom_log_sense(drive, failed_command, sense))
		if (!cdrom_log_sense(drive, failed_command))
		return;

		/*
		@@ -225,15 +225,14 @@ static void ide_cd_complete_failed_rq(ide_drive_t drive, struct request rq)
		* sense pointer set.
		*/
		memcpy(failed->sense, sense, 18);
		sense = failed->sense;
		failed->sense_len = rq->sense_len;
		}
		cdrom_analyze_sense_data(drive, failed, sense);
		cdrom_analyze_sense_data(drive, failed);

		if (ide_end_rq(drive, failed, -EIO, blk_rq_bytes(failed)))
		BUG();
		} else
		cdrom_analyze_sense_data(drive, NULL, sense);
		cdrom_analyze_sense_data(drive, NULL);
		}


		@@ -410,50 +409,6 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat)
		return 2;
		}

		/*
		* Check the contents of the interrupt reason register from the cdrom
		* and attempt to recover if there are problems. Returns 0 if everything's
		* ok; nonzero if the request has been terminated.
		*/
		static int ide_cd_check_ireason(ide_drive_t drive, struct request rq,
		int len, int ireason, int rw)
		{
		ide_hwif_t *hwif = drive->hwif;

		ide_debug_log(IDE_DBG_FUNC, "ireason: 0x%x, rw: 0x%x", ireason, rw);

		/*
		* ireason == 0: the drive wants to receive data from us
		* ireason == 2: the drive is expecting to transfer data to us
		*/
		if (ireason == (!rw << 1))
		return 0;
		else if (ireason == (rw << 1)) {

		/* whoops... */
		printk(KERN_ERR PFX "%s: %s: wrong transfer direction!\n",
		drive->name, __func__);

		ide_pad_transfer(drive, rw, len);
		} else if (rw == 0 && ireason == 1) {
		/*
		* Some drives (ASUS) seem to tell us that status info is
		* available. Just get it and ignore.
		*/
		(void)hwif->tp_ops->read_status(hwif);
		return 0;
		} else {
		/* drive wants a command packet, or invalid ireason... */
		printk(KERN_ERR PFX "%s: %s: bad interrupt reason 0x%02x\n",
		drive->name, __func__, ireason);
		}

		if (rq->cmd_type == REQ_TYPE_ATA_PC)
		rq->cmd_flags \|= REQ_FAILED;

		return -1;
		}

		static void ide_cd_request_sense_fixup(ide_drive_t drive, struct ide_cmd cmd)
		{
		struct request *rq = cmd->rq;
		@@ -645,8 +600,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
		goto out_end;
		}

		/* check which way to transfer data */
		rc = ide_cd_check_ireason(drive, rq, len, ireason, write);
		rc = ide_check_ireason(drive, rq, len, ireason, write);
		if (rc)
		goto out_end;

drivers/ide/ide-floppy.c

+22 −28

Original line number	Diff line number	Diff line
		@@ -77,7 +77,8 @@ static int ide_floppy_callback(ide_drive_t *drive, int dsc)
		(rq && blk_pc_request(rq)))
		uptodate = 1; /* FIXME */
		else if (pc->c[0] == GPCMD_REQUEST_SENSE) {
		u8 *buf = pc->buf;

		u8 *buf = bio_data(rq->bio);

		if (!pc->error) {
		floppy->sense_key = buf[2] & 0x0F;
		@@ -209,8 +210,7 @@ static void idefloppy_create_rw_cmd(ide_drive_t *drive,
		pc->rq = rq;
		if (rq->cmd_flags & REQ_RW)
		pc->flags \|= PC_FLAG_WRITING;
		pc->buf = NULL;
		pc->req_xfer = pc->buf_size = blocks * floppy->block_size;

		pc->flags \|= PC_FLAG_DMA_OK;
		}

		@@ -225,9 +225,6 @@ static void idefloppy_blockpc_cmd(struct ide_disk_obj *floppy,
		if (rq_data_dir(rq) == WRITE)
		pc->flags \|= PC_FLAG_WRITING;
		}
		/* pio will be performed by ide_pio_bytes() which handles sg fine */
		pc->buf = NULL;
		pc->req_xfer = pc->buf_size = blk_rq_bytes(rq);
		}

		static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
		@@ -286,8 +283,8 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,

		cmd.rq = rq;

		if (blk_fs_request(rq) \|\| pc->req_xfer) {
		ide_init_sg_cmd(&cmd, pc->req_xfer);
		if (blk_fs_request(rq) \|\| blk_rq_bytes(rq)) {
		ide_init_sg_cmd(&cmd, blk_rq_bytes(rq));
		ide_map_sg(drive, &cmd);
		}

		@@ -311,33 +308,33 @@ static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive,
		{
		struct ide_disk_obj *floppy = drive->driver_data;
		struct gendisk *disk = floppy->disk;
		u8 *page;
		u8 *page, buf[40];
		int capacity, lba_capacity;
		u16 transfer_rate, sector_size, cyls, rpm;
		u8 heads, sectors;

		ide_floppy_create_mode_sense_cmd(pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE);

		if (ide_queue_pc_tail(drive, disk, pc)) {
		if (ide_queue_pc_tail(drive, disk, pc, buf, pc->req_xfer)) {
		printk(KERN_ERR PFX "Can't get flexible disk page params\n");
		return 1;
		}

		if (pc->buf[3] & 0x80)
		if (buf[3] & 0x80)
		drive->dev_flags \|= IDE_DFLAG_WP;
		else
		drive->dev_flags &= ~IDE_DFLAG_WP;

		set_disk_ro(disk, !!(drive->dev_flags & IDE_DFLAG_WP));

		page = &pc->buf[8];
		page = &buf[8];

		transfer_rate = be16_to_cpup((__be16 *)&pc->buf[8 + 2]);
		sector_size = be16_to_cpup((__be16 *)&pc->buf[8 + 6]);
		cyls = be16_to_cpup((__be16 *)&pc->buf[8 + 8]);
		rpm = be16_to_cpup((__be16 *)&pc->buf[8 + 28]);
		heads = pc->buf[8 + 4];
		sectors = pc->buf[8 + 5];
		transfer_rate = be16_to_cpup((__be16 *)&buf[8 + 2]);
		sector_size = be16_to_cpup((__be16 *)&buf[8 + 6]);
		cyls = be16_to_cpup((__be16 *)&buf[8 + 8]);
		rpm = be16_to_cpup((__be16 *)&buf[8 + 28]);
		heads = buf[8 + 4];
		sectors = buf[8 + 5];

		capacity = cyls * heads * sectors * sector_size;

		@@ -387,22 +384,19 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
		drive->capacity64 = 0;

		ide_floppy_create_read_capacity_cmd(&pc);
		pc.buf = &pc_buf[0];
		pc.buf_size = sizeof(pc_buf);

		if (ide_queue_pc_tail(drive, disk, &pc)) {
		if (ide_queue_pc_tail(drive, disk, &pc, pc_buf, pc.req_xfer)) {
		printk(KERN_ERR PFX "Can't get floppy parameters\n");
		return 1;
		}
		header_len = pc.buf[3];
		cap_desc = &pc.buf[4];
		header_len = pc_buf[3];
		cap_desc = &pc_buf[4];
		desc_cnt = header_len / 8; /* capacity descriptor of 8 bytes */

		for (i = 0; i < desc_cnt; i++) {
		unsigned int desc_start = 4 + i*8;

		blocks = be32_to_cpup((__be32 *)&pc.buf[desc_start]);
		length = be16_to_cpup((__be16 *)&pc.buf[desc_start + 6]);
		blocks = be32_to_cpup((__be32 *)&pc_buf[desc_start]);
		length = be16_to_cpup((__be16 *)&pc_buf[desc_start + 6]);

		ide_debug_log(IDE_DBG_PROBE, "Descriptor %d: %dkB, %d blocks, "
		"%d sector size",
		@@ -415,7 +409,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
		* the code below is valid only for the 1st descriptor, ie i=0
		*/

		switch (pc.buf[desc_start + 4] & 0x03) {
		switch (pc_buf[desc_start + 4] & 0x03) {
		/* Clik! drive returns this instead of CAPACITY_CURRENT */
		case CAPACITY_UNFORMATTED:
		if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE))
		@@ -464,7 +458,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
		break;
		}
		ide_debug_log(IDE_DBG_PROBE, "Descriptor 0 Code: %d",
		pc.buf[desc_start + 4] & 0x03);
		pc_buf[desc_start + 4] & 0x03);
		}

		/* Clik! disk does not support get_flexible_disk_page */

drivers/ide/ide-floppy_ioctl.c

+23 −20

Original line number	Diff line number	Diff line
		@@ -47,15 +47,13 @@ static int ide_floppy_get_format_capacities(ide_drive_t *drive,
		return -EINVAL;

		ide_floppy_create_read_capacity_cmd(pc);
		pc->buf = &pc_buf[0];
		pc->buf_size = sizeof(pc_buf);

		if (ide_queue_pc_tail(drive, floppy->disk, pc)) {
		if (ide_queue_pc_tail(drive, floppy->disk, pc, pc_buf, pc->req_xfer)) {
		printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");
		return -EIO;
		}

		header_len = pc->buf[3];
		header_len = pc_buf[3];
		desc_cnt = header_len / 8; /* capacity descriptor of 8 bytes */

		u_index = 0;
		@@ -72,8 +70,8 @@ static int ide_floppy_get_format_capacities(ide_drive_t *drive,
		if (u_index >= u_array_size)
		break; /* User-supplied buffer too small */

		blocks = be32_to_cpup((__be32 *)&pc->buf[desc_start]);
		length = be16_to_cpup((__be16 *)&pc->buf[desc_start + 6]);
		blocks = be32_to_cpup((__be32 *)&pc_buf[desc_start]);
		length = be16_to_cpup((__be16 *)&pc_buf[desc_start + 6]);

		if (put_user(blocks, argp))
		return -EFAULT;
		@@ -94,40 +92,42 @@ static int ide_floppy_get_format_capacities(ide_drive_t *drive,
		return 0;
		}

		static void ide_floppy_create_format_unit_cmd(struct ide_atapi_pc *pc, int b,
		int l, int flags)
		static void ide_floppy_create_format_unit_cmd(struct ide_atapi_pc *pc,
		u8 *buf, int b, int l,
		int flags)
		{
		ide_init_pc(pc);
		pc->c[0] = GPCMD_FORMAT_UNIT;
		pc->c[1] = 0x17;

		memset(pc->buf, 0, 12);
		pc->buf[1] = 0xA2;
		memset(buf, 0, 12);
		buf[1] = 0xA2;
		/* Default format list header, u8 1: FOV/DCRT/IMM bits set */

		if (flags & 1) /* Verify bit on... */
		pc->buf[1] ^= 0x20; /* ... turn off DCRT bit */
		pc->buf[3] = 8;
		buf[1] ^= 0x20; /* ... turn off DCRT bit */
		buf[3] = 8;

		put_unaligned(cpu_to_be32(b), (unsigned int *)(&pc->buf[4]));
		put_unaligned(cpu_to_be32(l), (unsigned int *)(&pc->buf[8]));
		pc->buf_size = 12;
		put_unaligned(cpu_to_be32(b), (unsigned int *)(&buf[4]));
		put_unaligned(cpu_to_be32(l), (unsigned int *)(&buf[8]));
		pc->req_xfer = 12;
		pc->flags \|= PC_FLAG_WRITING;
		}

		static int ide_floppy_get_sfrp_bit(ide_drive_t drive, struct ide_atapi_pc pc)
		{
		struct ide_disk_obj *floppy = drive->driver_data;
		u8 buf[20];

		drive->atapi_flags &= ~IDE_AFLAG_SRFP;

		ide_floppy_create_mode_sense_cmd(pc, IDEFLOPPY_CAPABILITIES_PAGE);
		pc->flags \|= PC_FLAG_SUPPRESS_ERROR;

		if (ide_queue_pc_tail(drive, floppy->disk, pc))
		if (ide_queue_pc_tail(drive, floppy->disk, pc, buf, pc->req_xfer))
		return 1;

		if (pc->buf[8 + 2] & 0x40)
		if (buf[8 + 2] & 0x40)
		drive->atapi_flags \|= IDE_AFLAG_SRFP;

		return 0;
		@@ -137,6 +137,7 @@ static int ide_floppy_format_unit(ide_drive_t drive, struct ide_atapi_pc pc,
		int __user *arg)
		{
		struct ide_disk_obj *floppy = drive->driver_data;
		u8 buf[12];
		int blocks, length, flags, err = 0;

		if (floppy->openers > 1) {
		@@ -170,9 +171,9 @@ static int ide_floppy_format_unit(ide_drive_t drive, struct ide_atapi_pc pc,
		}

		ide_floppy_get_sfrp_bit(drive, pc);
		ide_floppy_create_format_unit_cmd(pc, blocks, length, flags);
		ide_floppy_create_format_unit_cmd(pc, buf, blocks, length, flags);

		if (ide_queue_pc_tail(drive, floppy->disk, pc))
		if (ide_queue_pc_tail(drive, floppy->disk, pc, buf, pc->req_xfer))
		err = -EIO;

		out:
		@@ -196,11 +197,13 @@ static int ide_floppy_get_format_progress(ide_drive_t *drive,
		int __user *arg)
		{
		struct ide_disk_obj *floppy = drive->driver_data;
		u8 sense_buf[18];
		int progress_indication = 0x10000;

		if (drive->atapi_flags & IDE_AFLAG_SRFP) {
		ide_create_request_sense_cmd(drive, pc);
		if (ide_queue_pc_tail(drive, floppy->disk, pc))
		if (ide_queue_pc_tail(drive, floppy->disk, pc, sense_buf,
		pc->req_xfer))
		return -EIO;

		if (floppy->sense_key == 2 &&

drivers/ide/ide-tape.c

+83 −91

File changed.

Preview size limit exceeded, changes collapsed.