2008-07-15 13:21:58 -06:00
|
|
|
/*
|
|
|
|
* ATAPI support.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
2009-01-02 08:12:53 -07:00
|
|
|
#include <linux/cdrom.h>
|
2008-07-15 13:21:58 -06:00
|
|
|
#include <linux/delay.h>
|
2011-07-17 13:33:58 -06:00
|
|
|
#include <linux/export.h>
|
2008-07-15 13:21:58 -06:00
|
|
|
#include <linux/ide.h>
|
2009-03-31 12:14:57 -06:00
|
|
|
#include <linux/scatterlist.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/gfp.h>
|
2009-03-31 12:14:57 -06:00
|
|
|
|
2008-07-15 13:22:03 -06:00
|
|
|
#include <scsi/scsi.h>
|
|
|
|
|
2009-04-26 02:39:07 -06:00
|
|
|
#define DRV_NAME "ide-atapi"
|
|
|
|
#define PFX DRV_NAME ": "
|
|
|
|
|
2008-07-15 13:22:03 -06:00
|
|
|
#ifdef DEBUG
|
|
|
|
#define debug_log(fmt, args...) \
|
|
|
|
printk(KERN_INFO "ide: " fmt, ## args)
|
|
|
|
#else
|
|
|
|
#define debug_log(fmt, args...) do {} while (0)
|
|
|
|
#endif
|
|
|
|
|
2009-01-02 08:12:54 -07:00
|
|
|
#define ATAPI_MIN_CDB_BYTES 12
|
|
|
|
|
2009-01-02 08:12:52 -07:00
|
|
|
static inline int dev_is_idecd(ide_drive_t *drive)
|
|
|
|
{
|
2009-01-02 08:12:54 -07:00
|
|
|
return drive->media == ide_cdrom || drive->media == ide_optical;
|
2009-01-02 08:12:52 -07:00
|
|
|
}
|
|
|
|
|
2008-10-10 14:39:34 -06:00
|
|
|
/*
|
|
|
|
* Check whether we can support a device,
|
|
|
|
* based on the ATAPI IDENTIFY command results.
|
|
|
|
*/
|
|
|
|
int ide_check_atapi_device(ide_drive_t *drive, const char *s)
|
|
|
|
{
|
|
|
|
u16 *id = drive->id;
|
|
|
|
u8 gcw[2], protocol, device_type, removable, drq_type, packet_size;
|
|
|
|
|
|
|
|
*((u16 *)&gcw) = id[ATA_ID_CONFIG];
|
|
|
|
|
|
|
|
protocol = (gcw[1] & 0xC0) >> 6;
|
|
|
|
device_type = gcw[1] & 0x1F;
|
|
|
|
removable = (gcw[0] & 0x80) >> 7;
|
|
|
|
drq_type = (gcw[0] & 0x60) >> 5;
|
|
|
|
packet_size = gcw[0] & 0x03;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC
|
|
|
|
/* kludge for Apple PowerBook internal zip */
|
|
|
|
if (drive->media == ide_floppy && device_type == 5 &&
|
|
|
|
!strstr((char *)&id[ATA_ID_PROD], "CD-ROM") &&
|
|
|
|
strstr((char *)&id[ATA_ID_PROD], "ZIP"))
|
|
|
|
device_type = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (protocol != 2)
|
|
|
|
printk(KERN_ERR "%s: %s: protocol (0x%02x) is not ATAPI\n",
|
|
|
|
s, drive->name, protocol);
|
|
|
|
else if ((drive->media == ide_floppy && device_type != 0) ||
|
|
|
|
(drive->media == ide_tape && device_type != 1))
|
|
|
|
printk(KERN_ERR "%s: %s: invalid device type (0x%02x)\n",
|
|
|
|
s, drive->name, device_type);
|
|
|
|
else if (removable == 0)
|
|
|
|
printk(KERN_ERR "%s: %s: the removable flag is not set\n",
|
|
|
|
s, drive->name);
|
|
|
|
else if (drive->media == ide_floppy && drq_type == 3)
|
|
|
|
printk(KERN_ERR "%s: %s: sorry, DRQ type (0x%02x) not "
|
|
|
|
"supported\n", s, drive->name, drq_type);
|
|
|
|
else if (packet_size != 0)
|
|
|
|
printk(KERN_ERR "%s: %s: packet size (0x%02x) is not 12 "
|
|
|
|
"bytes\n", s, drive->name, packet_size);
|
|
|
|
else
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_check_atapi_device);
|
|
|
|
|
2008-10-10 14:39:37 -06:00
|
|
|
void ide_init_pc(struct ide_atapi_pc *pc)
|
|
|
|
{
|
|
|
|
memset(pc, 0, sizeof(*pc));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_init_pc);
|
|
|
|
|
2008-10-10 14:39:38 -06:00
|
|
|
/*
|
|
|
|
* Add a special packet command request to the tail of the request queue,
|
|
|
|
* and wait for it to be serviced.
|
|
|
|
*/
|
|
|
|
int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
|
2009-05-02 02:26:12 -06:00
|
|
|
struct ide_atapi_pc *pc, void *buf, unsigned int bufflen)
|
2008-10-10 14:39:38 -06:00
|
|
|
{
|
|
|
|
struct request *rq;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
|
2015-04-17 14:37:16 -06:00
|
|
|
rq->cmd_type = REQ_TYPE_DRV_PRIV;
|
2009-04-18 16:00:42 -06:00
|
|
|
rq->special = (char *)pc;
|
2009-03-13 14:16:12 -06:00
|
|
|
|
2009-05-02 02:26:12 -06:00
|
|
|
if (buf && bufflen) {
|
|
|
|
error = blk_rq_map_kern(drive->queue, rq, buf, bufflen,
|
2009-04-18 16:00:42 -06:00
|
|
|
GFP_NOIO);
|
|
|
|
if (error)
|
|
|
|
goto put_req;
|
2009-03-13 14:16:12 -06:00
|
|
|
}
|
|
|
|
|
2008-10-10 14:39:38 -06:00
|
|
|
memcpy(rq->cmd, pc->c, 12);
|
|
|
|
if (drive->media == ide_tape)
|
|
|
|
rq->cmd[13] = REQ_IDETAPE_PC1;
|
|
|
|
error = blk_execute_rq(drive->queue, disk, rq, 0);
|
2009-04-18 16:00:42 -06:00
|
|
|
put_req:
|
2008-10-10 14:39:38 -06:00
|
|
|
blk_put_request(rq);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_queue_pc_tail);
|
|
|
|
|
2008-10-10 14:39:39 -06:00
|
|
|
int ide_do_test_unit_ready(ide_drive_t *drive, struct gendisk *disk)
|
|
|
|
{
|
|
|
|
struct ide_atapi_pc pc;
|
|
|
|
|
|
|
|
ide_init_pc(&pc);
|
|
|
|
pc.c[0] = TEST_UNIT_READY;
|
|
|
|
|
2009-05-02 02:26:12 -06:00
|
|
|
return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
|
2008-10-10 14:39:39 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_do_test_unit_ready);
|
|
|
|
|
2008-10-10 14:39:39 -06:00
|
|
|
int ide_do_start_stop(ide_drive_t *drive, struct gendisk *disk, int start)
|
|
|
|
{
|
|
|
|
struct ide_atapi_pc pc;
|
|
|
|
|
|
|
|
ide_init_pc(&pc);
|
|
|
|
pc.c[0] = START_STOP;
|
|
|
|
pc.c[4] = start;
|
|
|
|
|
|
|
|
if (drive->media == ide_tape)
|
|
|
|
pc.flags |= PC_FLAG_WAIT_FOR_DSC;
|
|
|
|
|
2009-05-02 02:26:12 -06:00
|
|
|
return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
|
2008-10-10 14:39:39 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_do_start_stop);
|
|
|
|
|
2008-10-10 14:39:38 -06:00
|
|
|
int ide_set_media_lock(ide_drive_t *drive, struct gendisk *disk, int on)
|
|
|
|
{
|
|
|
|
struct ide_atapi_pc pc;
|
|
|
|
|
2008-10-17 10:09:11 -06:00
|
|
|
if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
|
2008-10-10 14:39:38 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
ide_init_pc(&pc);
|
|
|
|
pc.c[0] = ALLOW_MEDIUM_REMOVAL;
|
|
|
|
pc.c[4] = on;
|
|
|
|
|
2009-05-02 02:26:12 -06:00
|
|
|
return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
|
2008-10-10 14:39:38 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_set_media_lock);
|
|
|
|
|
2008-10-13 13:39:32 -06:00
|
|
|
void ide_create_request_sense_cmd(ide_drive_t *drive, struct ide_atapi_pc *pc)
|
|
|
|
{
|
|
|
|
ide_init_pc(pc);
|
|
|
|
pc->c[0] = REQUEST_SENSE;
|
|
|
|
if (drive->media == ide_floppy) {
|
|
|
|
pc->c[4] = 255;
|
|
|
|
pc->req_xfer = 18;
|
|
|
|
} else {
|
|
|
|
pc->c[4] = 20;
|
|
|
|
pc->req_xfer = 20;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd);
|
|
|
|
|
2009-04-18 16:00:42 -06:00
|
|
|
void ide_prep_sense(ide_drive_t *drive, struct request *rq)
|
|
|
|
{
|
|
|
|
struct request_sense *sense = &drive->sense_data;
|
|
|
|
struct request *sense_rq = &drive->sense_rq;
|
|
|
|
unsigned int cmd_len, sense_len;
|
2009-04-18 16:00:42 -06:00
|
|
|
int err;
|
2009-04-18 16:00:42 -06:00
|
|
|
|
|
|
|
switch (drive->media) {
|
|
|
|
case ide_floppy:
|
|
|
|
cmd_len = 255;
|
|
|
|
sense_len = 18;
|
|
|
|
break;
|
|
|
|
case ide_tape:
|
|
|
|
cmd_len = 20;
|
|
|
|
sense_len = 20;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
cmd_len = 18;
|
|
|
|
sense_len = 18;
|
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(sense_len > sizeof(*sense));
|
|
|
|
|
2015-04-17 14:37:18 -06:00
|
|
|
if (rq->cmd_type == REQ_TYPE_ATA_SENSE || drive->sense_rq_armed)
|
2009-04-18 16:00:42 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
memset(sense, 0, sizeof(*sense));
|
|
|
|
|
|
|
|
blk_rq_init(rq->q, sense_rq);
|
|
|
|
|
2009-04-18 16:00:42 -06:00
|
|
|
err = blk_rq_map_kern(drive->queue, sense_rq, sense, sense_len,
|
|
|
|
GFP_NOIO);
|
|
|
|
if (unlikely(err)) {
|
|
|
|
if (printk_ratelimit())
|
2009-04-26 02:39:07 -06:00
|
|
|
printk(KERN_WARNING PFX "%s: failed to map sense "
|
|
|
|
"buffer\n", drive->name);
|
2009-04-18 16:00:42 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
sense_rq->rq_disk = rq->rq_disk;
|
2009-04-18 16:00:42 -06:00
|
|
|
sense_rq->cmd[0] = GPCMD_REQUEST_SENSE;
|
|
|
|
sense_rq->cmd[4] = cmd_len;
|
2015-04-17 14:37:18 -06:00
|
|
|
sense_rq->cmd_type = REQ_TYPE_ATA_SENSE;
|
2009-04-18 16:00:42 -06:00
|
|
|
sense_rq->cmd_flags |= REQ_PREEMPT;
|
|
|
|
|
|
|
|
if (drive->media == ide_tape)
|
|
|
|
sense_rq->cmd[13] = REQ_IDETAPE_PC1;
|
|
|
|
|
|
|
|
drive->sense_rq_armed = true;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_prep_sense);
|
|
|
|
|
2009-04-18 16:00:42 -06:00
|
|
|
int ide_queue_sense_rq(ide_drive_t *drive, void *special)
|
2009-04-18 16:00:42 -06:00
|
|
|
{
|
2009-04-18 16:00:42 -06:00
|
|
|
/* deferred failure from ide_prep_sense() */
|
|
|
|
if (!drive->sense_rq_armed) {
|
2009-04-26 02:39:07 -06:00
|
|
|
printk(KERN_WARNING PFX "%s: error queuing a sense request\n",
|
2009-04-18 16:00:42 -06:00
|
|
|
drive->name);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2009-04-18 16:00:42 -06:00
|
|
|
|
|
|
|
drive->sense_rq.special = special;
|
|
|
|
drive->sense_rq_armed = false;
|
|
|
|
|
|
|
|
drive->hwif->rq = NULL;
|
|
|
|
|
2011-03-10 00:52:07 -07:00
|
|
|
elv_add_request(drive->queue, &drive->sense_rq, ELEVATOR_INSERT_FRONT);
|
2009-04-18 16:00:42 -06:00
|
|
|
return 0;
|
2009-04-18 16:00:42 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_queue_sense_rq);
|
|
|
|
|
2008-10-13 13:39:32 -06:00
|
|
|
/*
|
|
|
|
* Called when an error was detected during the last packet command.
|
2009-04-18 16:00:42 -06:00
|
|
|
* We queue a request sense packet command at the head of the request
|
|
|
|
* queue.
|
2008-10-13 13:39:32 -06:00
|
|
|
*/
|
2009-04-18 16:00:42 -06:00
|
|
|
void ide_retry_pc(ide_drive_t *drive)
|
2008-10-13 13:39:32 -06:00
|
|
|
{
|
2009-05-07 20:53:59 -06:00
|
|
|
struct request *failed_rq = drive->hwif->rq;
|
2009-04-18 16:00:42 -06:00
|
|
|
struct request *sense_rq = &drive->sense_rq;
|
2008-10-13 13:39:32 -06:00
|
|
|
struct ide_atapi_pc *pc = &drive->request_sense_pc;
|
|
|
|
|
|
|
|
(void)ide_read_error(drive);
|
2009-04-18 16:00:42 -06:00
|
|
|
|
|
|
|
/* init pc from sense_rq */
|
|
|
|
ide_init_pc(pc);
|
|
|
|
memcpy(pc->c, sense_rq->cmd, 12);
|
|
|
|
|
2008-10-13 13:39:32 -06:00
|
|
|
if (drive->media == ide_tape)
|
2009-06-07 07:37:05 -06:00
|
|
|
drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC;
|
2009-04-18 16:00:42 -06:00
|
|
|
|
2009-05-07 20:53:59 -06:00
|
|
|
/*
|
|
|
|
* Push back the failed request and put request sense on top
|
|
|
|
* of it. The failed command will be retried after sense data
|
|
|
|
* is acquired.
|
|
|
|
*/
|
|
|
|
drive->hwif->rq = NULL;
|
2010-03-31 14:13:39 -06:00
|
|
|
ide_requeue_and_plug(drive, failed_rq);
|
2009-05-07 20:53:59 -06:00
|
|
|
if (ide_queue_sense_rq(drive, pc)) {
|
2009-05-07 20:54:16 -06:00
|
|
|
blk_start_request(failed_rq);
|
2009-05-07 20:53:59 -06:00
|
|
|
ide_complete_rq(drive, -EIO, blk_rq_bytes(failed_rq));
|
|
|
|
}
|
2008-10-13 13:39:32 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_retry_pc);
|
|
|
|
|
2009-01-02 08:12:53 -07:00
|
|
|
int ide_cd_expiry(ide_drive_t *drive)
|
|
|
|
{
|
2009-01-06 09:20:50 -07:00
|
|
|
struct request *rq = drive->hwif->rq;
|
2009-01-02 08:12:53 -07:00
|
|
|
unsigned long wait = 0;
|
|
|
|
|
|
|
|
debug_log("%s: rq->cmd[0]: 0x%x\n", __func__, rq->cmd[0]);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some commands are *slow* and normally take a long time to complete.
|
|
|
|
* Usually we can use the ATAPI "disconnect" to bypass this, but not all
|
|
|
|
* commands/drives support that. Let ide_timer_expiry keep polling us
|
|
|
|
* for these.
|
|
|
|
*/
|
|
|
|
switch (rq->cmd[0]) {
|
|
|
|
case GPCMD_BLANK:
|
|
|
|
case GPCMD_FORMAT_UNIT:
|
|
|
|
case GPCMD_RESERVE_RZONE_TRACK:
|
|
|
|
case GPCMD_CLOSE_TRACK:
|
|
|
|
case GPCMD_FLUSH_CACHE:
|
|
|
|
wait = ATAPI_WAIT_PC;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (!(rq->cmd_flags & REQ_QUIET))
|
2009-04-26 02:39:07 -06:00
|
|
|
printk(KERN_INFO PFX "cmd 0x%x timed out\n",
|
2009-01-02 08:12:53 -07:00
|
|
|
rq->cmd[0]);
|
|
|
|
wait = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return wait;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_cd_expiry);
|
|
|
|
|
2009-01-02 08:12:52 -07:00
|
|
|
int ide_cd_get_xferlen(struct request *rq)
|
|
|
|
{
|
2010-06-19 09:26:47 -06:00
|
|
|
switch (rq->cmd_type) {
|
2010-08-07 10:17:56 -06:00
|
|
|
case REQ_TYPE_FS:
|
2009-01-02 08:12:52 -07:00
|
|
|
return 32768;
|
2015-04-17 14:37:18 -06:00
|
|
|
case REQ_TYPE_ATA_SENSE:
|
2010-08-07 10:17:56 -06:00
|
|
|
case REQ_TYPE_BLOCK_PC:
|
|
|
|
case REQ_TYPE_ATA_PC:
|
2009-05-07 07:24:43 -06:00
|
|
|
return blk_rq_bytes(rq);
|
2010-08-07 10:17:56 -06:00
|
|
|
default:
|
2009-01-02 08:12:52 -07:00
|
|
|
return 0;
|
2010-08-07 10:17:56 -06:00
|
|
|
}
|
2009-01-02 08:12:52 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_cd_get_xferlen);
|
|
|
|
|
2009-03-24 16:22:46 -06:00
|
|
|
void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason)
|
|
|
|
{
|
2009-04-08 06:13:03 -06:00
|
|
|
struct ide_taskfile tf;
|
2009-03-24 16:22:46 -06:00
|
|
|
|
2009-04-08 06:13:03 -06:00
|
|
|
drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_NSECT |
|
|
|
|
IDE_VALID_LBAM | IDE_VALID_LBAH);
|
2009-03-24 16:22:46 -06:00
|
|
|
|
2009-04-08 06:13:03 -06:00
|
|
|
*bcount = (tf.lbah << 8) | tf.lbam;
|
|
|
|
*ireason = tf.nsect & 3;
|
2009-03-24 16:22:46 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);
|
|
|
|
|
2009-04-26 02:39:07 -06:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
2008-10-13 13:39:32 -06:00
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
* and will re-point interrupt handler to us.
|
|
|
|
*/
|
|
|
|
static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
|
2008-07-15 13:22:03 -06:00
|
|
|
{
|
2008-10-13 13:39:31 -06:00
|
|
|
struct ide_atapi_pc *pc = drive->pc;
|
2008-07-15 13:22:03 -06:00
|
|
|
ide_hwif_t *hwif = drive->hwif;
|
2009-03-31 12:15:24 -06:00
|
|
|
struct ide_cmd *cmd = &hwif->cmd;
|
2009-01-06 09:20:50 -07:00
|
|
|
struct request *rq = hwif->rq;
|
2008-07-23 11:55:56 -06:00
|
|
|
const struct ide_tp_ops *tp_ops = hwif->tp_ops;
|
2009-03-31 12:15:26 -06:00
|
|
|
unsigned int timeout, done;
|
2008-07-15 13:22:03 -06:00
|
|
|
u16 bcount;
|
2009-01-02 08:12:54 -07:00
|
|
|
u8 stat, ireason, dsc = 0;
|
2009-03-31 12:15:26 -06:00
|
|
|
u8 write = !!(pc->flags & PC_FLAG_WRITING);
|
2008-07-15 13:22:03 -06:00
|
|
|
|
|
|
|
debug_log("Enter %s - interrupt handler\n", __func__);
|
|
|
|
|
2009-01-02 08:12:54 -07:00
|
|
|
timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
|
|
|
|
: WAIT_TAPE_CMD;
|
2008-10-13 13:39:31 -06:00
|
|
|
|
2008-07-15 13:22:03 -06:00
|
|
|
/* Clear the interrupt */
|
2008-07-23 11:55:56 -06:00
|
|
|
stat = tp_ops->read_status(hwif);
|
2008-07-15 13:22:03 -06:00
|
|
|
|
|
|
|
if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
|
2009-03-31 12:15:22 -06:00
|
|
|
int rc;
|
2009-03-31 12:15:20 -06:00
|
|
|
|
2009-03-31 12:15:22 -06:00
|
|
|
drive->waiting_for_dma = 0;
|
|
|
|
rc = hwif->dma_ops->dma_end(drive);
|
2009-03-31 12:15:24 -06:00
|
|
|
ide_dma_unmap_sg(drive, cmd);
|
2009-03-31 12:15:20 -06:00
|
|
|
|
|
|
|
if (rc || (drive->media == ide_tape && (stat & ATA_ERR))) {
|
2009-01-02 08:12:54 -07:00
|
|
|
if (drive->media == ide_floppy)
|
2009-04-26 02:39:07 -06:00
|
|
|
printk(KERN_ERR PFX "%s: DMA %s error\n",
|
2008-07-15 13:22:03 -06:00
|
|
|
drive->name, rq_data_dir(pc->rq)
|
|
|
|
? "write" : "read");
|
|
|
|
pc->flags |= PC_FLAG_DMA_ERROR;
|
2009-04-18 17:46:03 -06:00
|
|
|
} else
|
2009-05-01 13:21:02 -06:00
|
|
|
rq->resid_len = 0;
|
2008-07-15 13:22:03 -06:00
|
|
|
debug_log("%s: DMA finished\n", drive->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No more interrupts */
|
2008-10-10 14:39:21 -06:00
|
|
|
if ((stat & ATA_DRQ) == 0) {
|
2009-03-31 12:15:34 -06:00
|
|
|
int uptodate, error;
|
2009-03-27 05:46:36 -06:00
|
|
|
|
2008-07-15 13:22:03 -06:00
|
|
|
debug_log("Packet command completed, %d bytes transferred\n",
|
2009-05-01 13:21:02 -06:00
|
|
|
blk_rq_bytes(rq));
|
2008-07-15 13:22:03 -06:00
|
|
|
|
|
|
|
pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
|
|
|
|
|
|
|
|
local_irq_enable_in_hardirq();
|
|
|
|
|
2009-01-02 08:12:54 -07:00
|
|
|
if (drive->media == ide_tape &&
|
2008-10-10 14:39:21 -06:00
|
|
|
(stat & ATA_ERR) && rq->cmd[0] == REQUEST_SENSE)
|
|
|
|
stat &= ~ATA_ERR;
|
2008-07-23 11:56:01 -06:00
|
|
|
|
2008-10-10 14:39:21 -06:00
|
|
|
if ((stat & ATA_ERR) || (pc->flags & PC_FLAG_DMA_ERROR)) {
|
2008-07-15 13:22:03 -06:00
|
|
|
/* Error detected */
|
|
|
|
debug_log("%s: I/O error\n", drive->name);
|
|
|
|
|
2009-01-02 08:12:54 -07:00
|
|
|
if (drive->media != ide_tape)
|
2008-07-15 13:22:03 -06:00
|
|
|
pc->rq->errors++;
|
|
|
|
|
2008-07-23 11:56:01 -06:00
|
|
|
if (rq->cmd[0] == REQUEST_SENSE) {
|
2009-04-26 02:39:07 -06:00
|
|
|
printk(KERN_ERR PFX "%s: I/O error in request "
|
|
|
|
"sense command\n", drive->name);
|
2008-07-15 13:22:03 -06:00
|
|
|
return ide_do_reset(drive);
|
|
|
|
}
|
|
|
|
|
2008-07-23 11:56:01 -06:00
|
|
|
debug_log("[cmd %x]: check condition\n", rq->cmd[0]);
|
2008-07-15 13:22:03 -06:00
|
|
|
|
|
|
|
/* Retry operation */
|
2009-04-18 16:00:42 -06:00
|
|
|
ide_retry_pc(drive);
|
2008-07-23 11:56:01 -06:00
|
|
|
|
2008-07-15 13:22:03 -06:00
|
|
|
/* queued, but not started */
|
|
|
|
return ide_stopped;
|
|
|
|
}
|
|
|
|
pc->error = 0;
|
2008-10-13 13:39:30 -06:00
|
|
|
|
|
|
|
if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0)
|
|
|
|
dsc = 1;
|
2008-07-23 11:56:01 -06:00
|
|
|
|
2009-04-18 17:46:02 -06:00
|
|
|
/*
|
|
|
|
* ->pc_callback() might change rq->data_len for
|
|
|
|
* residual count, cache total length.
|
|
|
|
*/
|
2009-04-18 17:46:02 -06:00
|
|
|
done = blk_rq_bytes(rq);
|
2009-04-18 17:46:02 -06:00
|
|
|
|
2008-07-15 13:22:03 -06:00
|
|
|
/* Command finished - Call the callback function */
|
2009-03-27 05:46:36 -06:00
|
|
|
uptodate = drive->pc_callback(drive, dsc);
|
|
|
|
|
|
|
|
if (uptodate == 0)
|
|
|
|
drive->failed_pc = NULL;
|
|
|
|
|
2015-04-17 14:37:16 -06:00
|
|
|
if (rq->cmd_type == REQ_TYPE_DRV_PRIV) {
|
2009-03-27 05:46:43 -06:00
|
|
|
rq->errors = 0;
|
2009-03-31 12:15:34 -06:00
|
|
|
error = 0;
|
2009-03-27 05:46:43 -06:00
|
|
|
} else {
|
2009-03-31 12:15:26 -06:00
|
|
|
|
2010-06-19 09:26:47 -06:00
|
|
|
if (rq->cmd_type != REQ_TYPE_FS && uptodate <= 0) {
|
2009-03-27 05:46:43 -06:00
|
|
|
if (rq->errors == 0)
|
|
|
|
rq->errors = -EIO;
|
|
|
|
}
|
2009-03-31 12:15:26 -06:00
|
|
|
|
2009-03-31 12:15:34 -06:00
|
|
|
error = uptodate ? 0 : -EIO;
|
2009-03-27 05:46:43 -06:00
|
|
|
}
|
2008-07-23 11:56:01 -06:00
|
|
|
|
2009-05-07 07:24:37 -06:00
|
|
|
ide_complete_rq(drive, error, blk_rq_bytes(rq));
|
2008-07-15 13:22:03 -06:00
|
|
|
return ide_stopped;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
|
|
|
|
pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
|
2009-04-26 02:39:07 -06:00
|
|
|
printk(KERN_ERR PFX "%s: The device wants to issue more "
|
|
|
|
"interrupts in DMA mode\n", drive->name);
|
2008-07-15 13:22:03 -06:00
|
|
|
ide_dma_off(drive);
|
|
|
|
return ide_do_reset(drive);
|
|
|
|
}
|
|
|
|
|
2008-07-23 11:55:54 -06:00
|
|
|
/* Get the number of bytes to transfer on this interrupt. */
|
|
|
|
ide_read_bcount_and_ireason(drive, &bcount, &ireason);
|
2008-07-15 13:22:03 -06:00
|
|
|
|
2009-04-26 02:39:07 -06:00
|
|
|
if (ide_check_ireason(drive, rq, bcount, ireason, write))
|
2008-07-15 13:22:03 -06:00
|
|
|
return ide_do_reset(drive);
|
2008-07-23 11:56:01 -06:00
|
|
|
|
2009-04-18 17:46:03 -06:00
|
|
|
done = min_t(unsigned int, bcount, cmd->nleft);
|
|
|
|
ide_pio_bytes(drive, cmd, write, done);
|
2008-07-15 13:22:03 -06:00
|
|
|
|
2009-04-18 17:46:03 -06:00
|
|
|
/* Update transferred byte count */
|
2009-05-01 13:21:02 -06:00
|
|
|
rq->resid_len -= done;
|
2009-03-31 12:15:26 -06:00
|
|
|
|
|
|
|
bcount -= done;
|
|
|
|
|
|
|
|
if (bcount)
|
|
|
|
ide_pad_transfer(drive, write, bcount);
|
|
|
|
|
2009-05-01 13:21:02 -06:00
|
|
|
debug_log("[cmd %x] transferred %d bytes, padded %d bytes, resid: %u\n",
|
|
|
|
rq->cmd[0], done, bcount, rq->resid_len);
|
2008-07-15 13:22:03 -06:00
|
|
|
|
|
|
|
/* And set the interrupt handler again */
|
2009-03-27 05:46:46 -06:00
|
|
|
ide_set_handler(drive, ide_pc_intr, timeout);
|
2008-07-15 13:22:03 -06:00
|
|
|
return ide_started;
|
|
|
|
}
|
2008-07-15 13:21:58 -06:00
|
|
|
|
2009-04-08 06:13:01 -06:00
|
|
|
static void ide_init_packet_cmd(struct ide_cmd *cmd, u8 valid_tf,
|
2009-03-27 05:46:46 -06:00
|
|
|
u16 bcount, u8 dma)
|
2009-03-24 16:22:39 -06:00
|
|
|
{
|
2009-04-08 06:13:01 -06:00
|
|
|
cmd->protocol = dma ? ATAPI_PROT_DMA : ATAPI_PROT_PIO;
|
|
|
|
cmd->valid.out.tf = IDE_VALID_LBAH | IDE_VALID_LBAM |
|
|
|
|
IDE_VALID_FEATURE | valid_tf;
|
2009-03-27 05:46:47 -06:00
|
|
|
cmd->tf.command = ATA_CMD_PACKET;
|
2009-03-27 05:46:46 -06:00
|
|
|
cmd->tf.feature = dma; /* Use PIO/DMA */
|
|
|
|
cmd->tf.lbam = bcount & 0xff;
|
|
|
|
cmd->tf.lbah = (bcount >> 8) & 0xff;
|
2009-03-24 16:22:39 -06:00
|
|
|
}
|
|
|
|
|
2008-07-23 11:55:54 -06:00
|
|
|
static u8 ide_read_ireason(ide_drive_t *drive)
|
|
|
|
{
|
2009-04-08 06:13:03 -06:00
|
|
|
struct ide_taskfile tf;
|
2008-07-23 11:55:54 -06:00
|
|
|
|
2009-04-08 06:13:03 -06:00
|
|
|
drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_NSECT);
|
2008-07-23 11:55:54 -06:00
|
|
|
|
2009-04-08 06:13:03 -06:00
|
|
|
return tf.nsect & 3;
|
2008-07-23 11:55:54 -06:00
|
|
|
}
|
|
|
|
|
2008-07-15 13:21:58 -06:00
|
|
|
static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason)
|
|
|
|
{
|
|
|
|
int retries = 100;
|
|
|
|
|
2008-10-10 14:39:21 -06:00
|
|
|
while (retries-- && ((ireason & ATAPI_COD) == 0 ||
|
|
|
|
(ireason & ATAPI_IO))) {
|
2009-04-26 02:39:07 -06:00
|
|
|
printk(KERN_ERR PFX "%s: (IO,CoD != (0,1) while issuing "
|
2008-07-15 13:21:58 -06:00
|
|
|
"a packet command, retrying\n", drive->name);
|
|
|
|
udelay(100);
|
2008-07-23 11:55:54 -06:00
|
|
|
ireason = ide_read_ireason(drive);
|
2008-07-15 13:21:58 -06:00
|
|
|
if (retries == 0) {
|
2009-04-26 02:39:07 -06:00
|
|
|
printk(KERN_ERR PFX "%s: (IO,CoD != (0,1) while issuing"
|
|
|
|
" a packet command, ignoring\n",
|
2008-07-15 13:21:58 -06:00
|
|
|
drive->name);
|
2008-10-10 14:39:21 -06:00
|
|
|
ireason |= ATAPI_COD;
|
|
|
|
ireason &= ~ATAPI_IO;
|
2008-07-15 13:21:58 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ireason;
|
|
|
|
}
|
|
|
|
|
2008-10-13 13:39:32 -06:00
|
|
|
static int ide_delayed_transfer_pc(ide_drive_t *drive)
|
|
|
|
{
|
|
|
|
/* Send the actual packet */
|
|
|
|
drive->hwif->tp_ops->output_data(drive, NULL, drive->pc->c, 12);
|
|
|
|
|
|
|
|
/* Timeout for the packet command */
|
|
|
|
return WAIT_FLOPPY_CMD;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
|
2008-07-15 13:21:58 -06:00
|
|
|
{
|
2009-01-02 08:12:56 -07:00
|
|
|
struct ide_atapi_pc *uninitialized_var(pc);
|
2008-07-15 13:21:58 -06:00
|
|
|
ide_hwif_t *hwif = drive->hwif;
|
2009-01-06 09:20:50 -07:00
|
|
|
struct request *rq = hwif->rq;
|
2008-10-13 13:39:32 -06:00
|
|
|
ide_expiry_t *expiry;
|
|
|
|
unsigned int timeout;
|
2009-01-02 08:12:54 -07:00
|
|
|
int cmd_len;
|
2008-07-15 13:21:58 -06:00
|
|
|
ide_startstop_t startstop;
|
|
|
|
u8 ireason;
|
|
|
|
|
2008-10-10 14:39:21 -06:00
|
|
|
if (ide_wait_stat(&startstop, drive, ATA_DRQ, ATA_BUSY, WAIT_READY)) {
|
2009-04-26 02:39:07 -06:00
|
|
|
printk(KERN_ERR PFX "%s: Strange, packet command initiated yet "
|
2008-07-15 13:21:58 -06:00
|
|
|
"DRQ isn't asserted\n", drive->name);
|
|
|
|
return startstop;
|
|
|
|
}
|
|
|
|
|
2009-01-02 08:12:53 -07:00
|
|
|
if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
|
|
|
|
if (drive->dma)
|
|
|
|
drive->waiting_for_dma = 1;
|
|
|
|
}
|
|
|
|
|
2009-01-02 08:12:54 -07:00
|
|
|
if (dev_is_idecd(drive)) {
|
|
|
|
/* ATAPI commands get padded out to 12 bytes minimum */
|
|
|
|
cmd_len = COMMAND_SIZE(rq->cmd[0]);
|
|
|
|
if (cmd_len < ATAPI_MIN_CDB_BYTES)
|
|
|
|
cmd_len = ATAPI_MIN_CDB_BYTES;
|
|
|
|
|
2009-01-02 08:12:55 -07:00
|
|
|
timeout = rq->timeout;
|
|
|
|
expiry = ide_cd_expiry;
|
2008-10-13 13:39:32 -06:00
|
|
|
} else {
|
2009-01-02 08:12:56 -07:00
|
|
|
pc = drive->pc;
|
|
|
|
|
2009-01-02 08:12:55 -07:00
|
|
|
cmd_len = ATAPI_MIN_CDB_BYTES;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If necessary schedule the packet transfer to occur 'timeout'
|
2009-04-23 03:37:37 -06:00
|
|
|
* milliseconds later in ide_delayed_transfer_pc() after the
|
2009-01-02 08:12:55 -07:00
|
|
|
* device says it's ready for a packet.
|
|
|
|
*/
|
|
|
|
if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {
|
|
|
|
timeout = drive->pc_delay;
|
|
|
|
expiry = &ide_delayed_transfer_pc;
|
|
|
|
} else {
|
|
|
|
timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
|
|
|
|
: WAIT_TAPE_CMD;
|
|
|
|
expiry = NULL;
|
|
|
|
}
|
2009-01-02 08:12:56 -07:00
|
|
|
|
|
|
|
ireason = ide_read_ireason(drive);
|
|
|
|
if (drive->media == ide_tape)
|
|
|
|
ireason = ide_wait_ireason(drive, ireason);
|
|
|
|
|
|
|
|
if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) {
|
2009-04-26 02:39:07 -06:00
|
|
|
printk(KERN_ERR PFX "%s: (IO,CoD) != (0,1) while "
|
|
|
|
"issuing a packet command\n", drive->name);
|
2009-01-02 08:12:56 -07:00
|
|
|
|
|
|
|
return ide_do_reset(drive);
|
|
|
|
}
|
2008-10-13 13:39:32 -06:00
|
|
|
}
|
|
|
|
|
2009-03-27 05:46:46 -06:00
|
|
|
hwif->expiry = expiry;
|
|
|
|
|
2008-07-15 13:21:58 -06:00
|
|
|
/* Set the interrupt routine */
|
2009-01-06 09:20:58 -07:00
|
|
|
ide_set_handler(drive,
|
|
|
|
(dev_is_idecd(drive) ? drive->irq_handler
|
|
|
|
: ide_pc_intr),
|
2009-03-27 05:46:46 -06:00
|
|
|
timeout);
|
2008-07-15 13:21:58 -06:00
|
|
|
|
2009-03-31 12:14:58 -06:00
|
|
|
/* Send the actual packet */
|
|
|
|
if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0)
|
|
|
|
hwif->tp_ops->output_data(drive, NULL, rq->cmd, cmd_len);
|
|
|
|
|
2008-07-15 13:21:58 -06:00
|
|
|
/* Begin DMA, if necessary */
|
2009-01-02 08:12:56 -07:00
|
|
|
if (dev_is_idecd(drive)) {
|
|
|
|
if (drive->dma)
|
|
|
|
hwif->dma_ops->dma_start(drive);
|
|
|
|
} else {
|
|
|
|
if (pc->flags & PC_FLAG_DMA_OK) {
|
|
|
|
pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
|
|
|
|
hwif->dma_ops->dma_start(drive);
|
|
|
|
}
|
2008-07-15 13:21:58 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return ide_started;
|
|
|
|
}
|
2008-07-15 13:22:00 -06:00
|
|
|
|
2009-03-27 05:46:46 -06:00
|
|
|
ide_startstop_t ide_issue_pc(ide_drive_t *drive, struct ide_cmd *cmd)
|
2008-07-15 13:22:00 -06:00
|
|
|
{
|
2009-01-02 08:12:55 -07:00
|
|
|
struct ide_atapi_pc *pc;
|
2008-07-15 13:22:00 -06:00
|
|
|
ide_hwif_t *hwif = drive->hwif;
|
2009-01-02 08:12:53 -07:00
|
|
|
ide_expiry_t *expiry = NULL;
|
2009-03-27 05:46:37 -06:00
|
|
|
struct request *rq = hwif->rq;
|
2009-05-01 12:35:21 -06:00
|
|
|
unsigned int timeout, bytes;
|
2009-01-02 08:12:52 -07:00
|
|
|
u16 bcount;
|
2009-04-08 06:13:01 -06:00
|
|
|
u8 valid_tf;
|
2009-03-27 05:46:47 -06:00
|
|
|
u8 drq_int = !!(drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT);
|
2008-07-15 13:22:00 -06:00
|
|
|
|
2009-01-02 08:12:52 -07:00
|
|
|
if (dev_is_idecd(drive)) {
|
2009-04-08 06:13:01 -06:00
|
|
|
valid_tf = IDE_VALID_NSECT | IDE_VALID_LBAL;
|
2009-03-27 05:46:37 -06:00
|
|
|
bcount = ide_cd_get_xferlen(rq);
|
2009-01-02 08:12:53 -07:00
|
|
|
expiry = ide_cd_expiry;
|
2009-01-02 08:12:56 -07:00
|
|
|
timeout = ATAPI_WAIT_PC;
|
2009-01-02 08:12:55 -07:00
|
|
|
|
2009-03-31 12:15:20 -06:00
|
|
|
if (drive->dma)
|
|
|
|
drive->dma = !ide_dma_prepare(drive, cmd);
|
2009-01-02 08:12:52 -07:00
|
|
|
} else {
|
2009-01-02 08:12:55 -07:00
|
|
|
pc = drive->pc;
|
|
|
|
|
2009-04-08 06:13:01 -06:00
|
|
|
valid_tf = IDE_VALID_DEVICE;
|
2009-05-01 12:35:21 -06:00
|
|
|
bytes = blk_rq_bytes(rq);
|
|
|
|
bcount = ((drive->media == ide_tape) ? bytes
|
|
|
|
: min_t(unsigned int,
|
|
|
|
bytes, 63 * 1024));
|
2008-07-15 13:22:00 -06:00
|
|
|
|
2009-05-01 13:21:02 -06:00
|
|
|
/* We haven't transferred any data yet */
|
|
|
|
rq->resid_len = bcount;
|
2008-07-15 13:22:00 -06:00
|
|
|
|
2009-01-02 08:12:55 -07:00
|
|
|
if (pc->flags & PC_FLAG_DMA_ERROR) {
|
|
|
|
pc->flags &= ~PC_FLAG_DMA_ERROR;
|
|
|
|
ide_dma_off(drive);
|
|
|
|
}
|
2008-07-15 13:22:00 -06:00
|
|
|
|
2009-03-31 12:15:20 -06:00
|
|
|
if (pc->flags & PC_FLAG_DMA_OK)
|
|
|
|
drive->dma = !ide_dma_prepare(drive, cmd);
|
2008-07-15 13:22:00 -06:00
|
|
|
|
2009-01-02 08:12:55 -07:00
|
|
|
if (!drive->dma)
|
|
|
|
pc->flags &= ~PC_FLAG_DMA_OK;
|
2009-01-02 08:12:56 -07:00
|
|
|
|
|
|
|
timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
|
|
|
|
: WAIT_TAPE_CMD;
|
2009-01-02 08:12:55 -07:00
|
|
|
}
|
2008-07-15 13:22:00 -06:00
|
|
|
|
2009-04-08 06:13:01 -06:00
|
|
|
ide_init_packet_cmd(cmd, valid_tf, bcount, drive->dma);
|
2009-03-27 05:46:46 -06:00
|
|
|
|
|
|
|
(void)do_rw_taskfile(drive, cmd);
|
2008-07-15 13:22:00 -06:00
|
|
|
|
2009-03-27 05:46:47 -06:00
|
|
|
if (drq_int) {
|
2009-01-02 08:12:53 -07:00
|
|
|
if (drive->dma)
|
|
|
|
drive->waiting_for_dma = 0;
|
2009-03-27 05:46:47 -06:00
|
|
|
hwif->expiry = expiry;
|
2008-07-15 13:22:00 -06:00
|
|
|
}
|
2009-03-27 05:46:47 -06:00
|
|
|
|
|
|
|
ide_execute_command(drive, cmd, ide_transfer_pc, timeout);
|
|
|
|
|
|
|
|
return drq_int ? ide_started : ide_transfer_pc(drive);
|
2008-07-15 13:22:00 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_issue_pc);
|