korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-11-26 21:54:11 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge git://git.kernel.org/pub/scm/linux/kernel/git/bart/linux-hdreg-h-cleanup

Browse Source 
* git://git.kernel.org/pub/scm/linux/kernel/git/bart/linux-hdreg-h-cleanup:
  remove <linux/ata.h> include from <linux/hdreg.h>
  include/linux/hdreg.h: remove unused defines
  isd200: use ATA_* defines instead of *_STAT and *_ERR ones
  include/linux/hdreg.h: cover WIN_* and friends with #ifndef/#endif __KERNEL__
  aoe: WIN_* -> ATA_CMD_*
  isd200: WIN_* -> ATA_CMD_*
  include/linux/hdreg.h: cover struct hd_driveid with #ifndef/#endif __KERNEL__
  xsysace: make it 'struct hd_driveid'-free
  ubd_kern: make it 'struct hd_driveid'-free
  isd200: make it 'struct hd_driveid'-free
This commit is contained in:
Linus Torvalds 2009-04-03 09:02:32 -07:00
commit ea02259fdf
6 changed files with 116 additions and 254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
arch/um/drivers/ubd_kern.c
View File

@ -22,6 +22,7 @@
#include "linux/kernel.h" #include "linux/kernel.h"
#include "linux/module.h" #include "linux/module.h"
#include "linux/blkdev.h" #include "linux/blkdev.h"
#include "linux/ata.h"
#include "linux/hdreg.h" #include "linux/hdreg.h"
#include "linux/init.h" #include "linux/init.h"
#include "linux/cdrom.h" #include "linux/cdrom.h"
@ -1308,16 +1309,15 @@ static int ubd_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
struct ubd *ubd_dev = bdev->bd_disk->private_data; struct ubd *ubd_dev = bdev->bd_disk->private_data;
struct hd_driveid ubd_id = { u16 ubd_id[ATA_ID_WORDS];
.cyls = 0,
.heads = 128,
.sectors = 32,
};
switch (cmd) { switch (cmd) {
struct cdrom_volctrl volume; struct cdrom_volctrl volume;
case HDIO_GET_IDENTITY: case HDIO_GET_IDENTITY:
ubd_id.cyls = ubd_dev->size / (128 * 32 * 512); memset(&ubd_id, 0, ATA_ID_WORDS * 2);
ubd_id[ATA_ID_CYLS] = ubd_dev->size / (128 * 32 * 512);
ubd_id[ATA_ID_HEADS] = 128;
ubd_id[ATA_ID_SECTORS] = 32;
if(copy_to_user((char __user *) arg, (char *) &ubd_id, if(copy_to_user((char __user *) arg, (char *) &ubd_id,
sizeof(ubd_id))) sizeof(ubd_id)))
return -EFAULT; return -EFAULT;

23
drivers/block/aoe/aoecmd.c
View File

@ -4,6 +4,7 @@
* Filesystem request handling methods * Filesystem request handling methods
*/ */
#include <linux/ata.h>
#include <linux/hdreg.h> #include <linux/hdreg.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/skbuff.h> #include <linux/skbuff.h>
@ -267,7 +268,7 @@ aoecmd_ata_rw(struct aoedev *d)
writebit = 0; writebit = 0;
} }
ah->cmdstat = WIN_READ | writebit | extbit; ah->cmdstat = ATA_CMD_PIO_READ | writebit | extbit;
/* mark all tracking fields and load out */ /* mark all tracking fields and load out */
buf->nframesout += 1; buf->nframesout += 1;
@ -362,10 +363,10 @@ resend(struct aoedev *d, struct aoetgt *t, struct frame *f)
switch (ah->cmdstat) { switch (ah->cmdstat) {
default: default:
break; break;
case WIN_READ: case ATA_CMD_PIO_READ:
case WIN_READ_EXT: case ATA_CMD_PIO_READ_EXT:
case WIN_WRITE: case ATA_CMD_PIO_WRITE:
case WIN_WRITE_EXT: case ATA_CMD_PIO_WRITE_EXT:
put_lba(ah, f->lba); put_lba(ah, f->lba);
n = f->bcnt; n = f->bcnt;
@ -812,8 +813,8 @@ aoecmd_ata_rsp(struct sk_buff *skb)
d->htgt = NULL; d->htgt = NULL;
n = ahout->scnt << 9; n = ahout->scnt << 9;
switch (ahout->cmdstat) { switch (ahout->cmdstat) {
case WIN_READ: case ATA_CMD_PIO_READ:
case WIN_READ_EXT: case ATA_CMD_PIO_READ_EXT:
if (skb->len - sizeof *hin - sizeof *ahin < n) { if (skb->len - sizeof *hin - sizeof *ahin < n) {
printk(KERN_ERR printk(KERN_ERR
"aoe: %s. skb->len=%d need=%ld\n", "aoe: %s. skb->len=%d need=%ld\n",
@ -823,8 +824,8 @@ aoecmd_ata_rsp(struct sk_buff *skb)
return; return;
} }
memcpy(f->bufaddr, ahin+1, n); memcpy(f->bufaddr, ahin+1, n);
case WIN_WRITE: case ATA_CMD_PIO_WRITE:
case WIN_WRITE_EXT: case ATA_CMD_PIO_WRITE_EXT:
ifp = getif(t, skb->dev); ifp = getif(t, skb->dev);
if (ifp) { if (ifp) {
ifp->lost = 0; ifp->lost = 0;
@ -838,7 +839,7 @@ aoecmd_ata_rsp(struct sk_buff *skb)
goto xmit; goto xmit;
} }
break; break;
case WIN_IDENTIFY: case ATA_CMD_ID_ATA:
if (skb->len - sizeof *hin - sizeof *ahin < 512) { if (skb->len - sizeof *hin - sizeof *ahin < 512) {
printk(KERN_INFO printk(KERN_INFO
"aoe: runt data size in ataid. skb->len=%d\n", "aoe: runt data size in ataid. skb->len=%d\n",
@ -914,7 +915,7 @@ aoecmd_ata_id(struct aoedev *d)
/* set up ata header */ /* set up ata header */
ah->scnt = 1; ah->scnt = 1;
ah->cmdstat = WIN_IDENTIFY; ah->cmdstat = ATA_CMD_ID_ATA;
ah->lba3 = 0xa0; ah->lba3 = 0xa0;
skb->dev = t->ifp->nd; skb->dev = t->ifp->nd;

2
drivers/block/hd.c
View File

@ -42,6 +42,8 @@
#include <linux/ata.h> #include <linux/ata.h>
#include <linux/hdreg.h> #include <linux/hdreg.h>
#define HD_IRQ 14
#define REALLY_SLOW_IO #define REALLY_SLOW_IO
#include <asm/system.h> #include <asm/system.h>
#include <asm/io.h> #include <asm/io.h>

30
drivers/block/xsysace.c
View File

@ -89,6 +89,7 @@
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/ata.h>
#include <linux/hdreg.h> #include <linux/hdreg.h>
#include <linux/platform_device.h> #include <linux/platform_device.h>
#if defined(CONFIG_OF) #if defined(CONFIG_OF)
@ -208,7 +209,7 @@ struct ace_device {
struct gendisk *gd; struct gendisk *gd;
/* Inserted CF card parameters */ /* Inserted CF card parameters */
struct hd_driveid cf_id; u16 cf_id[ATA_ID_WORDS];
}; };
static int ace_major; static int ace_major;
@ -402,21 +403,14 @@ static void ace_dump_regs(struct ace_device *ace)
ace_in32(ace, ACE_CFGLBA), ace_in(ace, ACE_FATSTAT)); ace_in32(ace, ACE_CFGLBA), ace_in(ace, ACE_FATSTAT));
} }
void ace_fix_driveid(struct hd_driveid *id) void ace_fix_driveid(u16 *id)
{ {
#if defined(__BIG_ENDIAN) #if defined(__BIG_ENDIAN)
u16 *buf = (void *)id;
int i; int i;
/* All half words have wrong byte order; swap the bytes */ /* All half words have wrong byte order; swap the bytes */
for (i = 0; i < sizeof(struct hd_driveid); i += 2, buf++) for (i = 0; i < ATA_ID_WORDS; i++, id++)
*buf = le16_to_cpu(*buf); *id = le16_to_cpu(*id);
/* Some of the data values are 32bit; swap the half words */
id->lba_capacity = ((id->lba_capacity >> 16) & 0x0000FFFF) |
((id->lba_capacity << 16) & 0xFFFF0000);
id->spg = ((id->spg >> 16) & 0x0000FFFF) |
((id->spg << 16) & 0xFFFF0000);
#endif #endif
} }
@ -614,7 +608,7 @@ static void ace_fsm_dostate(struct ace_device *ace)
break; break;
case ACE_FSM_STATE_IDENTIFY_COMPLETE: case ACE_FSM_STATE_IDENTIFY_COMPLETE:
ace_fix_driveid(&ace->cf_id); ace_fix_driveid(&ace->cf_id[0]);
ace_dump_mem(&ace->cf_id, 512); /* Debug: Dump out disk ID */ ace_dump_mem(&ace->cf_id, 512); /* Debug: Dump out disk ID */
if (ace->data_result) { if (ace->data_result) {
@ -627,9 +621,10 @@ static void ace_fsm_dostate(struct ace_device *ace)
ace->media_change = 0; ace->media_change = 0;
/* Record disk parameters */ /* Record disk parameters */
set_capacity(ace->gd, ace->cf_id.lba_capacity); set_capacity(ace->gd,
ata_id_u32(&ace->cf_id, ATA_ID_LBA_CAPACITY));
dev_info(ace->dev, "capacity: %i sectors\n", dev_info(ace->dev, "capacity: %i sectors\n",
ace->cf_id.lba_capacity); ata_id_u32(&ace->cf_id, ATA_ID_LBA_CAPACITY));
} }
/* We're done, drop to IDLE state and notify waiters */ /* We're done, drop to IDLE state and notify waiters */
@ -928,12 +923,13 @@ static int ace_release(struct gendisk *disk, fmode_t mode)
static int ace_getgeo(struct block_device *bdev, struct hd_geometry *geo) static int ace_getgeo(struct block_device *bdev, struct hd_geometry *geo)
{ {
struct ace_device *ace = bdev->bd_disk->private_data; struct ace_device *ace = bdev->bd_disk->private_data;
u16 *cf_id = &ace->cf_id[0];
dev_dbg(ace->dev, "ace_getgeo()\n"); dev_dbg(ace->dev, "ace_getgeo()\n");
geo->heads = ace->cf_id.heads; geo->heads = cf_id[ATA_ID_HEADS];
geo->sectors = ace->cf_id.sectors; geo->sectors = cf_id[ATA_ID_SECTORS];
geo->cylinders = ace->cf_id.cyls; geo->cylinders = cf_id[ATA_ID_CYLS];
return 0; return 0;
} }

237
drivers/usb/storage/isd200.c
View File

@ -46,6 +46,7 @@
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/ata.h>
#include <linux/hdreg.h> #include <linux/hdreg.h>
#include <linux/scatterlist.h> #include <linux/scatterlist.h>
@ -328,7 +329,7 @@ struct isd200_config {
struct isd200_info { struct isd200_info {
struct inquiry_data InquiryData; struct inquiry_data InquiryData;
struct hd_driveid *id; u16 *id;
struct isd200_config ConfigData; struct isd200_config ConfigData;
unsigned char *RegsBuf; unsigned char *RegsBuf;
unsigned char ATARegs[8]; unsigned char ATARegs[8];
@ -419,19 +420,19 @@ static void isd200_build_sense(struct us_data *us, struct scsi_cmnd *srb)
buf->Flags = UNIT_ATTENTION; buf->Flags = UNIT_ATTENTION;
buf->AdditionalSenseCode = 0; buf->AdditionalSenseCode = 0;
buf->AdditionalSenseCodeQualifier = 0; buf->AdditionalSenseCodeQualifier = 0;
} else if(error & MCR_ERR) { } else if (error & ATA_MCR) {
buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID; buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID;
buf->AdditionalSenseLength = 0xb; buf->AdditionalSenseLength = 0xb;
buf->Flags = UNIT_ATTENTION; buf->Flags = UNIT_ATTENTION;
buf->AdditionalSenseCode = 0; buf->AdditionalSenseCode = 0;
buf->AdditionalSenseCodeQualifier = 0; buf->AdditionalSenseCodeQualifier = 0;
} else if(error & TRK0_ERR) { } else if (error & ATA_TRK0NF) {
buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID; buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID;
buf->AdditionalSenseLength = 0xb; buf->AdditionalSenseLength = 0xb;
buf->Flags = NOT_READY; buf->Flags = NOT_READY;
buf->AdditionalSenseCode = 0; buf->AdditionalSenseCode = 0;
buf->AdditionalSenseCodeQualifier = 0; buf->AdditionalSenseCodeQualifier = 0;
} else if(error & ECC_ERR) { } else if (error & ATA_UNC) {
buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID; buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID;
buf->AdditionalSenseLength = 0xb; buf->AdditionalSenseLength = 0xb;
buf->Flags = DATA_PROTECT; buf->Flags = DATA_PROTECT;
@ -547,16 +548,16 @@ static int isd200_action( struct us_data *us, int action,
ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_5; ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_5;
ata.generic.RegisterSelect = REG_DEVICE_HEAD | REG_COMMAND; ata.generic.RegisterSelect = REG_DEVICE_HEAD | REG_COMMAND;
ata.write.DeviceHeadByte = info->DeviceHead; ata.write.DeviceHeadByte = info->DeviceHead;
ata.write.CommandByte = WIN_SRST; ata.write.CommandByte = ATA_CMD_DEV_RESET;
isd200_set_srb(info, DMA_NONE, NULL, 0); isd200_set_srb(info, DMA_NONE, NULL, 0);
break; break;
case ACTION_IDENTIFY: case ACTION_IDENTIFY:
US_DEBUGP(" isd200_action(IDENTIFY)\n"); US_DEBUGP(" isd200_action(IDENTIFY)\n");
ata.generic.RegisterSelect = REG_COMMAND; ata.generic.RegisterSelect = REG_COMMAND;
ata.write.CommandByte = WIN_IDENTIFY; ata.write.CommandByte = ATA_CMD_ID_ATA;
isd200_set_srb(info, DMA_FROM_DEVICE, info->id, isd200_set_srb(info, DMA_FROM_DEVICE, info->id,
sizeof(struct hd_driveid)); ATA_ID_WORDS * 2);
break; break;
default: default:
@ -944,22 +945,22 @@ static int isd200_try_enum(struct us_data *us, unsigned char master_slave,
break; break;
if (!detect) { if (!detect) {
if (regs[ATA_REG_STATUS_OFFSET] & BUSY_STAT) { if (regs[ATA_REG_STATUS_OFFSET] & ATA_BUSY) {
US_DEBUGP(" %s status is still BSY, try again...\n",mstr); US_DEBUGP(" %s status is still BSY, try again...\n",mstr);
} else { } else {
US_DEBUGP(" %s status !BSY, continue with next operation\n",mstr); US_DEBUGP(" %s status !BSY, continue with next operation\n",mstr);
break; break;
} }
} }
/* check for BUSY_STAT and */ /* check for ATA_BUSY and */
/* WRERR_STAT (workaround ATA Zip drive) and */ /* ATA_DF (workaround ATA Zip drive) and */
/* ERR_STAT (workaround for Archos CD-ROM) */ /* ATA_ERR (workaround for Archos CD-ROM) */
else if (regs[ATA_REG_STATUS_OFFSET] & else if (regs[ATA_REG_STATUS_OFFSET] &
(BUSY_STAT | WRERR_STAT | ERR_STAT )) { (ATA_BUSY | ATA_DF | ATA_ERR)) {
US_DEBUGP(" Status indicates it is not ready, try again...\n"); US_DEBUGP(" Status indicates it is not ready, try again...\n");
} }
/* check for DRDY, ATA devices set DRDY after SRST */ /* check for DRDY, ATA devices set DRDY after SRST */
else if (regs[ATA_REG_STATUS_OFFSET] & READY_STAT) { else if (regs[ATA_REG_STATUS_OFFSET] & ATA_DRDY) {
US_DEBUGP(" Identified ATA device\n"); US_DEBUGP(" Identified ATA device\n");
info->DeviceFlags |= DF_ATA_DEVICE; info->DeviceFlags |= DF_ATA_DEVICE;
info->DeviceHead = master_slave; info->DeviceHead = master_slave;
@ -1053,103 +1054,50 @@ static int isd200_manual_enum(struct us_data *us)
return(retStatus); return(retStatus);
} }
static void isd200_fix_driveid (struct hd_driveid *id) static void isd200_fix_driveid(u16 *id)
{ {
#ifndef __LITTLE_ENDIAN #ifndef __LITTLE_ENDIAN
# ifdef __BIG_ENDIAN # ifdef __BIG_ENDIAN
int i; int i;
u16 *stringcast;
id->config = __le16_to_cpu(id->config); for (i = 0; i < ATA_ID_WORDS; i++)
id->cyls = __le16_to_cpu(id->cyls); id[i] = __le16_to_cpu(id[i]);
id->reserved2 = __le16_to_cpu(id->reserved2);
id->heads = __le16_to_cpu(id->heads);
id->track_bytes = __le16_to_cpu(id->track_bytes);
id->sector_bytes = __le16_to_cpu(id->sector_bytes);
id->sectors = __le16_to_cpu(id->sectors);
id->vendor0 = __le16_to_cpu(id->vendor0);
id->vendor1 = __le16_to_cpu(id->vendor1);
id->vendor2 = __le16_to_cpu(id->vendor2);
stringcast = (u16 *)&id->serial_no[0];
for (i = 0; i < (20/2); i++)
stringcast[i] = __le16_to_cpu(stringcast[i]);
id->buf_type = __le16_to_cpu(id->buf_type);
id->buf_size = __le16_to_cpu(id->buf_size);
id->ecc_bytes = __le16_to_cpu(id->ecc_bytes);
stringcast = (u16 *)&id->fw_rev[0];
for (i = 0; i < (8/2); i++)
stringcast[i] = __le16_to_cpu(stringcast[i]);
stringcast = (u16 *)&id->model[0];
for (i = 0; i < (40/2); i++)
stringcast[i] = __le16_to_cpu(stringcast[i]);
id->dword_io = __le16_to_cpu(id->dword_io);
id->reserved50 = __le16_to_cpu(id->reserved50);
id->field_valid = __le16_to_cpu(id->field_valid);
id->cur_cyls = __le16_to_cpu(id->cur_cyls);
id->cur_heads = __le16_to_cpu(id->cur_heads);
id->cur_sectors = __le16_to_cpu(id->cur_sectors);
id->cur_capacity0 = __le16_to_cpu(id->cur_capacity0);
id->cur_capacity1 = __le16_to_cpu(id->cur_capacity1);
id->lba_capacity = __le32_to_cpu(id->lba_capacity);
id->dma_1word = __le16_to_cpu(id->dma_1word);
id->dma_mword = __le16_to_cpu(id->dma_mword);
id->eide_pio_modes = __le16_to_cpu(id->eide_pio_modes);
id->eide_dma_min = __le16_to_cpu(id->eide_dma_min);
id->eide_dma_time = __le16_to_cpu(id->eide_dma_time);
id->eide_pio = __le16_to_cpu(id->eide_pio);
id->eide_pio_iordy = __le16_to_cpu(id->eide_pio_iordy);
for (i = 0; i < 2; ++i)
id->words69_70[i] = __le16_to_cpu(id->words69_70[i]);
for (i = 0; i < 4; ++i)
id->words71_74[i] = __le16_to_cpu(id->words71_74[i]);
id->queue_depth = __le16_to_cpu(id->queue_depth);
for (i = 0; i < 4; ++i)
id->words76_79[i] = __le16_to_cpu(id->words76_79[i]);
id->major_rev_num = __le16_to_cpu(id->major_rev_num);
id->minor_rev_num = __le16_to_cpu(id->minor_rev_num);
id->command_set_1 = __le16_to_cpu(id->command_set_1);
id->command_set_2 = __le16_to_cpu(id->command_set_2);
id->cfsse = __le16_to_cpu(id->cfsse);
id->cfs_enable_1 = __le16_to_cpu(id->cfs_enable_1);
id->cfs_enable_2 = __le16_to_cpu(id->cfs_enable_2);
id->csf_default = __le16_to_cpu(id->csf_default);
id->dma_ultra = __le16_to_cpu(id->dma_ultra);
id->trseuc = __le16_to_cpu(id->trseuc);
id->trsEuc = __le16_to_cpu(id->trsEuc);
id->CurAPMvalues = __le16_to_cpu(id->CurAPMvalues);
id->mprc = __le16_to_cpu(id->mprc);
id->hw_config = __le16_to_cpu(id->hw_config);
id->acoustic = __le16_to_cpu(id->acoustic);
id->msrqs = __le16_to_cpu(id->msrqs);
id->sxfert = __le16_to_cpu(id->sxfert);
id->sal = __le16_to_cpu(id->sal);
id->spg = __le32_to_cpu(id->spg);
id->lba_capacity_2 = __le64_to_cpu(id->lba_capacity_2);
for (i = 0; i < 22; i++)
id->words104_125[i] = __le16_to_cpu(id->words104_125[i]);
id->last_lun = __le16_to_cpu(id->last_lun);
id->word127 = __le16_to_cpu(id->word127);
id->dlf = __le16_to_cpu(id->dlf);
id->csfo = __le16_to_cpu(id->csfo);
for (i = 0; i < 26; i++)
id->words130_155[i] = __le16_to_cpu(id->words130_155[i]);
id->word156 = __le16_to_cpu(id->word156);
for (i = 0; i < 3; i++)
id->words157_159[i] = __le16_to_cpu(id->words157_159[i]);
id->cfa_power = __le16_to_cpu(id->cfa_power);
for (i = 0; i < 14; i++)
id->words161_175[i] = __le16_to_cpu(id->words161_175[i]);
for (i = 0; i < 31; i++)
id->words176_205[i] = __le16_to_cpu(id->words176_205[i]);
for (i = 0; i < 48; i++)
id->words206_254[i] = __le16_to_cpu(id->words206_254[i]);
id->integrity_word = __le16_to_cpu(id->integrity_word);
# else # else
# error "Please fix <asm/byteorder.h>" # error "Please fix <asm/byteorder.h>"
# endif # endif
#endif #endif
} }
static void isd200_dump_driveid(u16 *id)
{
US_DEBUGP(" Identify Data Structure:\n");
US_DEBUGP(" config = 0x%x\n", id[ATA_ID_CONFIG]);
US_DEBUGP(" cyls = 0x%x\n", id[ATA_ID_CYLS]);
US_DEBUGP(" heads = 0x%x\n", id[ATA_ID_HEADS]);
US_DEBUGP(" track_bytes = 0x%x\n", id[4]);
US_DEBUGP(" sector_bytes = 0x%x\n", id[5]);
US_DEBUGP(" sectors = 0x%x\n", id[ATA_ID_SECTORS]);
US_DEBUGP(" serial_no[0] = 0x%x\n", *(char *)&id[ATA_ID_SERNO]);
US_DEBUGP(" buf_type = 0x%x\n", id[20]);
US_DEBUGP(" buf_size = 0x%x\n", id[ATA_ID_BUF_SIZE]);
US_DEBUGP(" ecc_bytes = 0x%x\n", id[22]);
US_DEBUGP(" fw_rev[0] = 0x%x\n", *(char *)&id[ATA_ID_FW_REV]);
US_DEBUGP(" model[0] = 0x%x\n", *(char *)&id[ATA_ID_PROD]);
US_DEBUGP(" max_multsect = 0x%x\n", id[ATA_ID_MAX_MULTSECT] & 0xff);
US_DEBUGP(" dword_io = 0x%x\n", id[ATA_ID_DWORD_IO]);
US_DEBUGP(" capability = 0x%x\n", id[ATA_ID_CAPABILITY] >> 8);
US_DEBUGP(" tPIO = 0x%x\n", id[ATA_ID_OLD_PIO_MODES] >> 8);
US_DEBUGP(" tDMA = 0x%x\n", id[ATA_ID_OLD_DMA_MODES] >> 8);
US_DEBUGP(" field_valid = 0x%x\n", id[ATA_ID_FIELD_VALID]);
US_DEBUGP(" cur_cyls = 0x%x\n", id[ATA_ID_CUR_CYLS]);
US_DEBUGP(" cur_heads = 0x%x\n", id[ATA_ID_CUR_HEADS]);
US_DEBUGP(" cur_sectors = 0x%x\n", id[ATA_ID_CUR_SECTORS]);
US_DEBUGP(" cur_capacity = 0x%x\n", ata_id_u32(id, 57));
US_DEBUGP(" multsect = 0x%x\n", id[ATA_ID_MULTSECT] & 0xff);
US_DEBUGP(" lba_capacity = 0x%x\n", ata_id_u32(id, ATA_ID_LBA_CAPACITY));
US_DEBUGP(" command_set_1 = 0x%x\n", id[ATA_ID_COMMAND_SET_1]);
US_DEBUGP(" command_set_2 = 0x%x\n", id[ATA_ID_COMMAND_SET_2]);
}
/************************************************************************** /**************************************************************************
* isd200_get_inquiry_data * isd200_get_inquiry_data
@ -1163,7 +1111,7 @@ static int isd200_get_inquiry_data( struct us_data *us )
{ {
struct isd200_info *info = (struct isd200_info *)us->extra; struct isd200_info *info = (struct isd200_info *)us->extra;
int retStatus = ISD200_GOOD; int retStatus = ISD200_GOOD;
struct hd_driveid *id = info->id; u16 *id = info->id;
US_DEBUGP("Entering isd200_get_inquiry_data\n"); US_DEBUGP("Entering isd200_get_inquiry_data\n");
@ -1180,8 +1128,7 @@ static int isd200_get_inquiry_data( struct us_data *us )
/* this must be an ATA device */ /* this must be an ATA device */
/* perform an ATA Command Identify */ /* perform an ATA Command Identify */
transferStatus = isd200_action( us, ACTION_IDENTIFY, transferStatus = isd200_action( us, ACTION_IDENTIFY,
id, id, ATA_ID_WORDS * 2);
sizeof(struct hd_driveid) );
if (transferStatus != ISD200_TRANSPORT_GOOD) { if (transferStatus != ISD200_TRANSPORT_GOOD) {
/* Error issuing ATA Command Identify */ /* Error issuing ATA Command Identify */
US_DEBUGP(" Error issuing ATA Command Identify\n"); US_DEBUGP(" Error issuing ATA Command Identify\n");
@ -1191,35 +1138,9 @@ static int isd200_get_inquiry_data( struct us_data *us )
int i; int i;
__be16 *src; __be16 *src;
__u16 *dest; __u16 *dest;
isd200_fix_driveid(id);
US_DEBUGP(" Identify Data Structure:\n"); isd200_fix_driveid(id);
US_DEBUGP(" config = 0x%x\n", id->config); isd200_dump_driveid(id);
US_DEBUGP(" cyls = 0x%x\n", id->cyls);
US_DEBUGP(" heads = 0x%x\n", id->heads);
US_DEBUGP(" track_bytes = 0x%x\n", id->track_bytes);
US_DEBUGP(" sector_bytes = 0x%x\n", id->sector_bytes);
US_DEBUGP(" sectors = 0x%x\n", id->sectors);
US_DEBUGP(" serial_no[0] = 0x%x\n", id->serial_no[0]);
US_DEBUGP(" buf_type = 0x%x\n", id->buf_type);
US_DEBUGP(" buf_size = 0x%x\n", id->buf_size);
US_DEBUGP(" ecc_bytes = 0x%x\n", id->ecc_bytes);
US_DEBUGP(" fw_rev[0] = 0x%x\n", id->fw_rev[0]);
US_DEBUGP(" model[0] = 0x%x\n", id->model[0]);
US_DEBUGP(" max_multsect = 0x%x\n", id->max_multsect);
US_DEBUGP(" dword_io = 0x%x\n", id->dword_io);
US_DEBUGP(" capability = 0x%x\n", id->capability);
US_DEBUGP(" tPIO = 0x%x\n", id->tPIO);
US_DEBUGP(" tDMA = 0x%x\n", id->tDMA);
US_DEBUGP(" field_valid = 0x%x\n", id->field_valid);
US_DEBUGP(" cur_cyls = 0x%x\n", id->cur_cyls);
US_DEBUGP(" cur_heads = 0x%x\n", id->cur_heads);
US_DEBUGP(" cur_sectors = 0x%x\n", id->cur_sectors);
US_DEBUGP(" cur_capacity = 0x%x\n", (id->cur_capacity1 << 16) + id->cur_capacity0 );
US_DEBUGP(" multsect = 0x%x\n", id->multsect);
US_DEBUGP(" lba_capacity = 0x%x\n", id->lba_capacity);
US_DEBUGP(" command_set_1 = 0x%x\n", id->command_set_1);
US_DEBUGP(" command_set_2 = 0x%x\n", id->command_set_2);
memset(&info->InquiryData, 0, sizeof(info->InquiryData)); memset(&info->InquiryData, 0, sizeof(info->InquiryData));
@ -1229,30 +1150,30 @@ static int isd200_get_inquiry_data( struct us_data *us )
/* The length must be at least 36 (5 + 31) */ /* The length must be at least 36 (5 + 31) */
info->InquiryData.AdditionalLength = 0x1F; info->InquiryData.AdditionalLength = 0x1F;
if (id->command_set_1 & COMMANDSET_MEDIA_STATUS) { if (id[ATA_ID_COMMAND_SET_1] & COMMANDSET_MEDIA_STATUS) {
/* set the removable bit */ /* set the removable bit */
info->InquiryData.DeviceTypeModifier = DEVICE_REMOVABLE; info->InquiryData.DeviceTypeModifier = DEVICE_REMOVABLE;
info->DeviceFlags |= DF_REMOVABLE_MEDIA; info->DeviceFlags |= DF_REMOVABLE_MEDIA;
} }
/* Fill in vendor identification fields */ /* Fill in vendor identification fields */
src = (__be16*)id->model; src = (__be16 *)&id[ATA_ID_PROD];
dest = (__u16*)info->InquiryData.VendorId; dest = (__u16*)info->InquiryData.VendorId;
for (i=0;i<4;i++) for (i=0;i<4;i++)
dest[i] = be16_to_cpu(src[i]); dest[i] = be16_to_cpu(src[i]);
src = (__be16*)(id->model+8); src = (__be16 *)&id[ATA_ID_PROD + 8/2];
dest = (__u16*)info->InquiryData.ProductId; dest = (__u16*)info->InquiryData.ProductId;
for (i=0;i<8;i++) for (i=0;i<8;i++)
dest[i] = be16_to_cpu(src[i]); dest[i] = be16_to_cpu(src[i]);
src = (__be16*)id->fw_rev; src = (__be16 *)&id[ATA_ID_FW_REV];
dest = (__u16*)info->InquiryData.ProductRevisionLevel; dest = (__u16*)info->InquiryData.ProductRevisionLevel;
for (i=0;i<2;i++) for (i=0;i<2;i++)
dest[i] = be16_to_cpu(src[i]); dest[i] = be16_to_cpu(src[i]);
/* determine if it supports Media Status Notification */ /* determine if it supports Media Status Notification */
if (id->command_set_2 & COMMANDSET_MEDIA_STATUS) { if (id[ATA_ID_COMMAND_SET_2] & COMMANDSET_MEDIA_STATUS) {
US_DEBUGP(" Device supports Media Status Notification\n"); US_DEBUGP(" Device supports Media Status Notification\n");
/* Indicate that it is enabled, even though it is not /* Indicate that it is enabled, even though it is not
@ -1301,7 +1222,7 @@ static int isd200_scsi_to_ata(struct scsi_cmnd *srb, struct us_data *us,
union ata_cdb * ataCdb) union ata_cdb * ataCdb)
{ {
struct isd200_info *info = (struct isd200_info *)us->extra; struct isd200_info *info = (struct isd200_info *)us->extra;
struct hd_driveid *id = info->id; u16 *id = info->id;
int sendToTransport = 1; int sendToTransport = 1;
unsigned char sectnum, head; unsigned char sectnum, head;
unsigned short cylinder; unsigned short cylinder;
@ -1369,13 +1290,12 @@ static int isd200_scsi_to_ata(struct scsi_cmnd *srb, struct us_data *us,
US_DEBUGP(" ATA OUT - SCSIOP_READ_CAPACITY\n"); US_DEBUGP(" ATA OUT - SCSIOP_READ_CAPACITY\n");
if (id->capability & CAPABILITY_LBA ) { if (ata_id_has_lba(id))
capacity = id->lba_capacity - 1; capacity = ata_id_u32(id, ATA_ID_LBA_CAPACITY) - 1;
} else { else
capacity = (id->heads * capacity = (id[ATA_ID_HEADS] * id[ATA_ID_CYLS] *
id->cyls * id[ATA_ID_SECTORS]) - 1;
id->sectors) - 1;
}
readCapacityData.LogicalBlockAddress = cpu_to_be32(capacity); readCapacityData.LogicalBlockAddress = cpu_to_be32(capacity);
readCapacityData.BytesPerBlock = cpu_to_be32(0x200); readCapacityData.BytesPerBlock = cpu_to_be32(0x200);
@ -1392,16 +1312,16 @@ static int isd200_scsi_to_ata(struct scsi_cmnd *srb, struct us_data *us,
lba = be32_to_cpu(*(__be32 *)&srb->cmnd[2]); lba = be32_to_cpu(*(__be32 *)&srb->cmnd[2]);
blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8]; blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8];
if (id->capability & CAPABILITY_LBA) { if (ata_id_has_lba(id)) {
sectnum = (unsigned char)(lba); sectnum = (unsigned char)(lba);
cylinder = (unsigned short)(lba>>8); cylinder = (unsigned short)(lba>>8);
head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F); head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F);
} else { } else {
sectnum = (unsigned char)((lba % id->sectors) + 1); sectnum = (u8)((lba % id[ATA_ID_SECTORS]) + 1);
cylinder = (unsigned short)(lba / (id->sectors * cylinder = (u16)(lba / (id[ATA_ID_SECTORS] *
id->heads)); id[ATA_ID_HEADS]));
head = (unsigned char)((lba / id->sectors) % head = (u8)((lba / id[ATA_ID_SECTORS]) %
id->heads); id[ATA_ID_HEADS]);
} }
ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
@ -1415,7 +1335,7 @@ static int isd200_scsi_to_ata(struct scsi_cmnd *srb, struct us_data *us,
ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8); ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8);
ataCdb->write.CylinderLowByte = (unsigned char)cylinder; ataCdb->write.CylinderLowByte = (unsigned char)cylinder;
ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD); ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD);
ataCdb->write.CommandByte = WIN_READ; ataCdb->write.CommandByte = ATA_CMD_PIO_READ;
break; break;
case WRITE_10: case WRITE_10:
@ -1424,14 +1344,16 @@ static int isd200_scsi_to_ata(struct scsi_cmnd *srb, struct us_data *us,
lba = be32_to_cpu(*(__be32 *)&srb->cmnd[2]); lba = be32_to_cpu(*(__be32 *)&srb->cmnd[2]);
blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8]; blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8];
if (id->capability & CAPABILITY_LBA) { if (ata_id_has_lba(id)) {
sectnum = (unsigned char)(lba); sectnum = (unsigned char)(lba);
cylinder = (unsigned short)(lba>>8); cylinder = (unsigned short)(lba>>8);
head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F); head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F);
} else { } else {
sectnum = (unsigned char)((lba % id->sectors) + 1); sectnum = (u8)((lba % id[ATA_ID_SECTORS]) + 1);
cylinder = (unsigned short)(lba / (id->sectors * id->heads)); cylinder = (u16)(lba / (id[ATA_ID_SECTORS] *
head = (unsigned char)((lba / id->sectors) % id->heads); id[ATA_ID_HEADS]));
head = (u8)((lba / id[ATA_ID_SECTORS]) %
id[ATA_ID_HEADS]);
} }
ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
@ -1445,7 +1367,7 @@ static int isd200_scsi_to_ata(struct scsi_cmnd *srb, struct us_data *us,
ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8); ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8);
ataCdb->write.CylinderLowByte = (unsigned char)cylinder; ataCdb->write.CylinderLowByte = (unsigned char)cylinder;
ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD); ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD);
ataCdb->write.CommandByte = WIN_WRITE; ataCdb->write.CommandByte = ATA_CMD_PIO_WRITE;
break; break;
case ALLOW_MEDIUM_REMOVAL: case ALLOW_MEDIUM_REMOVAL:
@ -1459,7 +1381,7 @@ static int isd200_scsi_to_ata(struct scsi_cmnd *srb, struct us_data *us,
ataCdb->generic.TransferBlockSize = 1; ataCdb->generic.TransferBlockSize = 1;
ataCdb->generic.RegisterSelect = REG_COMMAND; ataCdb->generic.RegisterSelect = REG_COMMAND;
ataCdb->write.CommandByte = (srb->cmnd[4] & 0x1) ? ataCdb->write.CommandByte = (srb->cmnd[4] & 0x1) ?
WIN_DOORLOCK : WIN_DOORUNLOCK; ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
isd200_srb_set_bufflen(srb, 0); isd200_srb_set_bufflen(srb, 0);
} else { } else {
US_DEBUGP(" Not removeable media, just report okay\n"); US_DEBUGP(" Not removeable media, just report okay\n");
@ -1539,8 +1461,7 @@ static int isd200_init_info(struct us_data *us)
if (!info) if (!info)
retStatus = ISD200_ERROR; retStatus = ISD200_ERROR;
else { else {
info->id = (struct hd_driveid *) info->id = kzalloc(ATA_ID_WORDS * 2, GFP_KERNEL);
kzalloc(sizeof(struct hd_driveid), GFP_KERNEL);
info->RegsBuf = (unsigned char *) info->RegsBuf = (unsigned char *)
kmalloc(sizeof(info->ATARegs), GFP_KERNEL); kmalloc(sizeof(info->ATARegs), GFP_KERNEL);
info->srb.sense_buffer = info->srb.sense_buffer =

66
include/linux/hdreg.h
View File

@ -1,68 +1,6 @@
#ifndef _LINUX_HDREG_H #ifndef _LINUX_HDREG_H
#define _LINUX_HDREG_H #define _LINUX_HDREG_H
#ifdef __KERNEL__
#include <linux/ata.h>
/*
* This file contains some defines for the AT-hd-controller.
* Various sources.
*/
/* ide.c has its own port definitions in "ide.h" */
#define HD_IRQ 14
/* Hd controller regs. Ref: IBM AT Bios-listing */
#define HD_DATA 0x1f0 /* _CTL when writing */
#define HD_ERROR 0x1f1 /* see err-bits */
#define HD_NSECTOR 0x1f2 /* nr of sectors to read/write */
#define HD_SECTOR 0x1f3 /* starting sector */
#define HD_LCYL 0x1f4 /* starting cylinder */
#define HD_HCYL 0x1f5 /* high byte of starting cyl */
#define HD_CURRENT 0x1f6 /* 101dhhhh , d=drive, hhhh=head */
#define HD_STATUS 0x1f7 /* see status-bits */
#define HD_FEATURE HD_ERROR /* same io address, read=error, write=feature */
#define HD_PRECOMP HD_FEATURE /* obsolete use of this port - predates IDE */
#define HD_COMMAND HD_STATUS /* same io address, read=status, write=cmd */
#define HD_CMD 0x3f6 /* used for resets */
#define HD_ALTSTATUS 0x3f6 /* same as HD_STATUS but doesn't clear irq */
/* remainder is shared between hd.c, ide.c, ide-cd.c, and the hdparm utility */
/* Bits of HD_STATUS */
#define ERR_STAT 0x01
#define INDEX_STAT 0x02
#define ECC_STAT 0x04 /* Corrected error */
#define DRQ_STAT 0x08
#define SEEK_STAT 0x10
#define SRV_STAT 0x10
#define WRERR_STAT 0x20
#define READY_STAT 0x40
#define BUSY_STAT 0x80
/* Bits for HD_ERROR */
#define MARK_ERR 0x01 /* Bad address mark */
#define ILI_ERR 0x01 /* Illegal Length Indication (ATAPI) */
#define TRK0_ERR 0x02 /* couldn't find track 0 */
#define EOM_ERR 0x02 /* End Of Media (ATAPI) */
#define ABRT_ERR 0x04 /* Command aborted */
#define MCR_ERR 0x08 /* media change request */
#define ID_ERR 0x10 /* ID field not found */
#define MC_ERR 0x20 /* media changed */
#define ECC_ERR 0x40 /* Uncorrectable ECC error */
#define BBD_ERR 0x80 /* pre-EIDE meaning: block marked bad */
#define ICRC_ERR 0x80 /* new meaning: CRC error during transfer */
#define LFS_ERR 0xf0 /* Last Failed Sense (ATAPI) */
/* Bits of HD_NSECTOR */
#define CD 0x01
#define IO 0x02
#define REL 0x04
#define TAG_MASK 0xf8
#endif /* __KERNEL__ */
#include <linux/types.h> #include <linux/types.h>
/* /*
@ -191,6 +129,7 @@ typedef struct hd_drive_hob_hdr {
#define TASKFILE_INVALID 0x7fff #define TASKFILE_INVALID 0x7fff
#endif #endif
#ifndef __KERNEL__
/* ATA/ATAPI Commands pre T13 Spec */ /* ATA/ATAPI Commands pre T13 Spec */
#define WIN_NOP 0x00 #define WIN_NOP 0x00
/* /*
@ -379,6 +318,7 @@ typedef struct hd_drive_hob_hdr {
#define SECURITY_ERASE_UNIT 0xBD #define SECURITY_ERASE_UNIT 0xBD
#define SECURITY_FREEZE_LOCK 0xBE #define SECURITY_FREEZE_LOCK 0xBE
#define SECURITY_DISABLE_PASSWORD 0xBF #define SECURITY_DISABLE_PASSWORD 0xBF
#endif /* __KERNEL__ */
struct hd_geometry { struct hd_geometry {
unsigned char heads; unsigned char heads;
@ -448,6 +388,7 @@ enum {
#define __NEW_HD_DRIVE_ID #define __NEW_HD_DRIVE_ID
#ifndef __KERNEL__
/* /*
* Structure returned by HDIO_GET_IDENTITY, as per ANSI NCITS ATA6 rev.1b spec. * Structure returned by HDIO_GET_IDENTITY, as per ANSI NCITS ATA6 rev.1b spec.
* *
@ -699,6 +640,7 @@ struct hd_driveid {
* 7:0 Signature * 7:0 Signature
*/ */
}; };
#endif /* __KERNEL__ */
/* /*
* IDE "nice" flags. These are used on a per drive basis to determine * IDE "nice" flags. These are used on a per drive basis to determine