1 #include <linux/types.h>
2 #include <linux/string.h>
3 #include <linux/kernel.h>
4 #include <linux/interrupt.h>
6 #include <linux/bitops.h>
8 static const char *udma_str
[] =
9 { "UDMA/16", "UDMA/25", "UDMA/33", "UDMA/44",
10 "UDMA/66", "UDMA/100", "UDMA/133", "UDMA7" };
11 static const char *mwdma_str
[] =
12 { "MWDMA0", "MWDMA1", "MWDMA2" };
13 static const char *swdma_str
[] =
14 { "SWDMA0", "SWDMA1", "SWDMA2" };
15 static const char *pio_str
[] =
16 { "PIO0", "PIO1", "PIO2", "PIO3", "PIO4", "PIO5" };
19 * ide_xfer_verbose - return IDE mode names
20 * @mode: transfer mode
22 * Returns a constant string giving the name of the mode
26 const char *ide_xfer_verbose(u8 mode
)
31 if (mode
>= XFER_UDMA_0
&& mode
<= XFER_UDMA_7
)
33 else if (mode
>= XFER_MW_DMA_0
&& mode
<= XFER_MW_DMA_2
)
35 else if (mode
>= XFER_SW_DMA_0
&& mode
<= XFER_SW_DMA_2
)
37 else if (mode
>= XFER_PIO_0
&& mode
<= XFER_PIO_5
)
39 else if (mode
== XFER_PIO_SLOW
)
47 EXPORT_SYMBOL(ide_xfer_verbose
);
50 * ide_rate_filter - filter transfer mode
52 * @speed: desired speed
54 * Given the available transfer modes this function returns
55 * the best available speed at or below the speed requested.
57 * TODO: check device PIO capabilities
60 static u8
ide_rate_filter(ide_drive_t
*drive
, u8 speed
)
62 ide_hwif_t
*hwif
= drive
->hwif
;
63 u8 mode
= ide_find_dma_mode(drive
, speed
);
67 mode
= fls(hwif
->pio_mask
) - 1 + XFER_PIO_0
;
72 /* printk("%s: mode 0x%02x, speed 0x%02x\n", __func__, mode, speed); */
74 return min(speed
, mode
);
78 * ide_get_best_pio_mode - get PIO mode from drive
79 * @drive: drive to consider
80 * @mode_wanted: preferred mode
81 * @max_mode: highest allowed mode
83 * This routine returns the recommended PIO settings for a given drive,
84 * based on the drive->id information and the ide_pio_blacklist[].
86 * Drive PIO mode is auto-selected if 255 is passed as mode_wanted.
87 * This is used by most chipset support modules when "auto-tuning".
90 u8
ide_get_best_pio_mode (ide_drive_t
*drive
, u8 mode_wanted
, u8 max_mode
)
93 int pio_mode
= -1, overridden
= 0;
95 if (mode_wanted
!= 255)
96 return min_t(u8
, mode_wanted
, max_mode
);
98 if ((drive
->hwif
->host_flags
& IDE_HFLAG_PIO_NO_BLACKLIST
) == 0)
99 pio_mode
= ide_scan_pio_blacklist((char *)&id
[ATA_ID_PROD
]);
101 if (pio_mode
!= -1) {
102 printk(KERN_INFO
"%s: is on PIO blacklist\n", drive
->name
);
104 pio_mode
= id
[ATA_ID_OLD_PIO_MODES
] >> 8;
105 if (pio_mode
> 2) { /* 2 is maximum allowed tPIO value */
110 if (id
[ATA_ID_FIELD_VALID
] & 2) { /* ATA2? */
111 if (ata_id_has_iordy(id
)) {
112 if (id
[ATA_ID_PIO_MODES
] & 7) {
114 if (id
[ATA_ID_PIO_MODES
] & 4)
116 else if (id
[ATA_ID_PIO_MODES
] & 2)
125 printk(KERN_INFO
"%s: tPIO > 2, assuming tPIO = 2\n",
129 if (pio_mode
> max_mode
)
135 EXPORT_SYMBOL_GPL(ide_get_best_pio_mode
);
137 /* req_pio == "255" for auto-tune */
138 void ide_set_pio(ide_drive_t
*drive
, u8 req_pio
)
140 ide_hwif_t
*hwif
= drive
->hwif
;
141 const struct ide_port_ops
*port_ops
= hwif
->port_ops
;
144 if (port_ops
== NULL
|| port_ops
->set_pio_mode
== NULL
||
145 (hwif
->host_flags
& IDE_HFLAG_NO_SET_MODE
))
148 BUG_ON(hwif
->pio_mask
== 0x00);
150 host_pio
= fls(hwif
->pio_mask
) - 1;
152 pio
= ide_get_best_pio_mode(drive
, req_pio
, host_pio
);
156 * - report device max PIO mode
157 * - check req_pio != 255 against device max PIO mode
159 printk(KERN_DEBUG
"%s: host max PIO%d wanted PIO%d%s selected PIO%d\n",
160 drive
->name
, host_pio
, req_pio
,
161 req_pio
== 255 ? "(auto-tune)" : "", pio
);
163 (void)ide_set_pio_mode(drive
, XFER_PIO_0
+ pio
);
166 EXPORT_SYMBOL_GPL(ide_set_pio
);
169 * ide_toggle_bounce - handle bounce buffering
170 * @drive: drive to update
171 * @on: on/off boolean
173 * Enable or disable bounce buffering for the device. Drives move
174 * between PIO and DMA and that changes the rules we need.
177 void ide_toggle_bounce(ide_drive_t
*drive
, int on
)
179 u64 addr
= BLK_BOUNCE_HIGH
; /* dma64_addr_t */
181 if (!PCI_DMA_BUS_IS_PHYS
) {
182 addr
= BLK_BOUNCE_ANY
;
183 } else if (on
&& drive
->media
== ide_disk
) {
184 struct device
*dev
= drive
->hwif
->dev
;
186 if (dev
&& dev
->dma_mask
)
187 addr
= *dev
->dma_mask
;
191 blk_queue_bounce_limit(drive
->queue
, addr
);
194 int ide_set_pio_mode(ide_drive_t
*drive
, const u8 mode
)
196 ide_hwif_t
*hwif
= drive
->hwif
;
197 const struct ide_port_ops
*port_ops
= hwif
->port_ops
;
199 if (hwif
->host_flags
& IDE_HFLAG_NO_SET_MODE
)
202 if (port_ops
== NULL
|| port_ops
->set_pio_mode
== NULL
)
206 * TODO: temporary hack for some legacy host drivers that didn't
207 * set transfer mode on the device in ->set_pio_mode method...
209 if (port_ops
->set_dma_mode
== NULL
) {
210 port_ops
->set_pio_mode(drive
, mode
- XFER_PIO_0
);
214 if (hwif
->host_flags
& IDE_HFLAG_POST_SET_MODE
) {
215 if (ide_config_drive_speed(drive
, mode
))
217 port_ops
->set_pio_mode(drive
, mode
- XFER_PIO_0
);
220 port_ops
->set_pio_mode(drive
, mode
- XFER_PIO_0
);
221 return ide_config_drive_speed(drive
, mode
);
225 int ide_set_dma_mode(ide_drive_t
*drive
, const u8 mode
)
227 ide_hwif_t
*hwif
= drive
->hwif
;
228 const struct ide_port_ops
*port_ops
= hwif
->port_ops
;
230 if (hwif
->host_flags
& IDE_HFLAG_NO_SET_MODE
)
233 if (port_ops
== NULL
|| port_ops
->set_dma_mode
== NULL
)
236 if (hwif
->host_flags
& IDE_HFLAG_POST_SET_MODE
) {
237 if (ide_config_drive_speed(drive
, mode
))
239 port_ops
->set_dma_mode(drive
, mode
);
242 port_ops
->set_dma_mode(drive
, mode
);
243 return ide_config_drive_speed(drive
, mode
);
247 EXPORT_SYMBOL_GPL(ide_set_dma_mode
);
250 * ide_set_xfer_rate - set transfer rate
251 * @drive: drive to set
252 * @rate: speed to attempt to set
254 * General helper for setting the speed of an IDE device. This
255 * function knows about user enforced limits from the configuration
256 * which ->set_pio_mode/->set_dma_mode does not.
259 int ide_set_xfer_rate(ide_drive_t
*drive
, u8 rate
)
261 ide_hwif_t
*hwif
= drive
->hwif
;
262 const struct ide_port_ops
*port_ops
= hwif
->port_ops
;
264 if (port_ops
== NULL
|| port_ops
->set_dma_mode
== NULL
||
265 (hwif
->host_flags
& IDE_HFLAG_NO_SET_MODE
))
268 rate
= ide_rate_filter(drive
, rate
);
270 BUG_ON(rate
< XFER_PIO_0
);
272 if (rate
>= XFER_PIO_0
&& rate
<= XFER_PIO_5
)
273 return ide_set_pio_mode(drive
, rate
);
275 return ide_set_dma_mode(drive
, rate
);
278 static void ide_dump_opcode(ide_drive_t
*drive
)
281 ide_task_t
*task
= NULL
;
283 spin_lock(&ide_lock
);
286 rq
= HWGROUP(drive
)->rq
;
287 spin_unlock(&ide_lock
);
291 if (rq
->cmd_type
== REQ_TYPE_ATA_TASKFILE
)
294 printk("ide: failed opcode was: ");
296 printk(KERN_CONT
"unknown\n");
298 printk(KERN_CONT
"0x%02x\n", task
->tf
.command
);
301 u64
ide_get_lba_addr(struct ide_taskfile
*tf
, int lba48
)
306 high
= (tf
->hob_lbah
<< 16) | (tf
->hob_lbam
<< 8) |
309 high
= tf
->device
& 0xf;
310 low
= (tf
->lbah
<< 16) | (tf
->lbam
<< 8) | tf
->lbal
;
312 return ((u64
)high
<< 24) | low
;
314 EXPORT_SYMBOL_GPL(ide_get_lba_addr
);
316 static void ide_dump_sector(ide_drive_t
*drive
)
319 struct ide_taskfile
*tf
= &task
.tf
;
320 int lba48
= (drive
->addressing
== 1) ? 1 : 0;
322 memset(&task
, 0, sizeof(task
));
324 task
.tf_flags
= IDE_TFLAG_IN_LBA
| IDE_TFLAG_IN_HOB_LBA
|
327 task
.tf_flags
= IDE_TFLAG_IN_LBA
| IDE_TFLAG_IN_DEVICE
;
329 drive
->hwif
->tp_ops
->tf_read(drive
, &task
);
331 if (lba48
|| (tf
->device
& ATA_LBA
))
332 printk(", LBAsect=%llu",
333 (unsigned long long)ide_get_lba_addr(tf
, lba48
));
335 printk(", CHS=%d/%d/%d", (tf
->lbah
<< 8) + tf
->lbam
,
336 tf
->device
& 0xf, tf
->lbal
);
339 static void ide_dump_ata_error(ide_drive_t
*drive
, u8 err
)
342 if (err
& ATA_ABORTED
) printk("DriveStatusError ");
344 printk((err
& ATA_ABORTED
) ? "BadCRC " : "BadSector ");
345 if (err
& ATA_UNC
) printk("UncorrectableError ");
346 if (err
& ATA_IDNF
) printk("SectorIdNotFound ");
347 if (err
& ATA_TRK0NF
) printk("TrackZeroNotFound ");
348 if (err
& ATA_AMNF
) printk("AddrMarkNotFound ");
350 if ((err
& (ATA_BBK
| ATA_ABORTED
)) == ATA_BBK
||
351 (err
& (ATA_UNC
| ATA_IDNF
| ATA_AMNF
))) {
352 ide_dump_sector(drive
);
353 if (HWGROUP(drive
) && HWGROUP(drive
)->rq
)
354 printk(", sector=%llu",
355 (unsigned long long)HWGROUP(drive
)->rq
->sector
);
360 static void ide_dump_atapi_error(ide_drive_t
*drive
, u8 err
)
363 if (err
& ATAPI_ILI
) printk("IllegalLengthIndication ");
364 if (err
& ATAPI_EOM
) printk("EndOfMedia ");
365 if (err
& ATA_ABORTED
) printk("AbortedCommand ");
366 if (err
& ATA_MCR
) printk("MediaChangeRequested ");
367 if (err
& ATAPI_LFS
) printk("LastFailedSense=0x%02x ",
368 (err
& ATAPI_LFS
) >> 4);
373 * ide_dump_status - translate ATA/ATAPI error
374 * @drive: drive that status applies to
375 * @msg: text message to print
376 * @stat: status byte to decode
378 * Error reporting, in human readable form (luxurious, but a memory hog).
379 * Combines the drive name, message and status byte to provide a
380 * user understandable explanation of the device error.
383 u8
ide_dump_status(ide_drive_t
*drive
, const char *msg
, u8 stat
)
388 local_irq_save(flags
);
389 printk("%s: %s: status=0x%02x { ", drive
->name
, msg
, stat
);
393 if (stat
& ATA_DRDY
) printk("DriveReady ");
394 if (stat
& ATA_DF
) printk("DeviceFault ");
395 if (stat
& ATA_DSC
) printk("SeekComplete ");
396 if (stat
& ATA_DRQ
) printk("DataRequest ");
397 if (stat
& ATA_CORR
) printk("CorrectedError ");
398 if (stat
& ATA_IDX
) printk("Index ");
399 if (stat
& ATA_ERR
) printk("Error ");
402 if ((stat
& (ATA_BUSY
| ATA_ERR
)) == ATA_ERR
) {
403 err
= ide_read_error(drive
);
404 printk("%s: %s: error=0x%02x ", drive
->name
, msg
, err
);
405 if (drive
->media
== ide_disk
)
406 ide_dump_ata_error(drive
, err
);
408 ide_dump_atapi_error(drive
, err
);
410 ide_dump_opcode(drive
);
411 local_irq_restore(flags
);
415 EXPORT_SYMBOL(ide_dump_status
);