blob: 222c1ef65fb94f0dbc84e18d64b04feb9cba1285 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Copyright (C) 2000-2002 Andre Hedrick <andre@linux-ide.org>
Alan Coxccd32e22008-11-02 21:40:08 +01003 * Copyright (C) 2003 Red Hat
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 */
6
Linus Torvalds1da177e2005-04-16 15:20:36 -07007#include <linux/module.h>
8#include <linux/types.h>
9#include <linux/string.h>
10#include <linux/kernel.h>
11#include <linux/timer.h>
12#include <linux/mm.h>
13#include <linux/interrupt.h>
14#include <linux/major.h>
15#include <linux/errno.h>
16#include <linux/genhd.h>
17#include <linux/blkpg.h>
18#include <linux/slab.h>
19#include <linux/pci.h>
20#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/ide.h>
22#include <linux/bitops.h>
Michal Schmidt1e862402006-07-30 03:03:29 -070023#include <linux/nmi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25#include <asm/byteorder.h>
26#include <asm/irq.h>
27#include <asm/uaccess.h>
28#include <asm/io.h>
29
Bartlomiej Zolnierkiewiczed4af482008-07-15 21:21:48 +020030void SELECT_MASK(ide_drive_t *drive, int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -070031{
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +020032 const struct ide_port_ops *port_ops = drive->hwif->port_ops;
33
34 if (port_ops && port_ops->maskproc)
35 port_ops->maskproc(drive, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -070036}
37
Bartlomiej Zolnierkiewicz92eb4382008-07-23 19:55:53 +020038u8 ide_read_error(ide_drive_t *drive)
39{
Sergei Shtylyov3153c262009-04-08 14:13:03 +020040 struct ide_taskfile tf;
Bartlomiej Zolnierkiewicz92eb4382008-07-23 19:55:53 +020041
Sergei Shtylyov3153c262009-04-08 14:13:03 +020042 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_ERROR);
Bartlomiej Zolnierkiewicz92eb4382008-07-23 19:55:53 +020043
Sergei Shtylyov3153c262009-04-08 14:13:03 +020044 return tf.error;
Bartlomiej Zolnierkiewicz92eb4382008-07-23 19:55:53 +020045}
46EXPORT_SYMBOL_GPL(ide_read_error);
47
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +020048void ide_fix_driveid(u16 *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -070049{
50#ifndef __LITTLE_ENDIAN
51# ifdef __BIG_ENDIAN
52 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Bartlomiej Zolnierkiewicz48fb2682008-10-10 22:39:19 +020054 for (i = 0; i < 256; i++)
Bartlomiej Zolnierkiewicz5b90e992008-10-10 22:39:18 +020055 id[i] = __le16_to_cpu(id[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056# else
57# error "Please fix <asm/byteorder.h>"
58# endif
59#endif
60}
61
Bartlomiej Zolnierkiewicz01745112007-11-05 21:42:29 +010062/*
63 * ide_fixstring() cleans up and (optionally) byte-swaps a text string,
64 * removing leading/trailing blanks and compressing internal blanks.
65 * It is primarily used to tidy up the model name/number fields as
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +020066 * returned by the ATA_CMD_ID_ATA[PI] commands.
Bartlomiej Zolnierkiewicz01745112007-11-05 21:42:29 +010067 */
68
Bartlomiej Zolnierkiewicz122f06f2009-03-24 23:22:47 +010069void ide_fixstring(u8 *s, const int bytecount, const int byteswap)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{
Linus Torvalds1a7809e2008-10-10 22:39:22 +020071 u8 *p, *end = &s[bytecount & ~1]; /* bytecount must be even */
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
73 if (byteswap) {
74 /* convert from big-endian to host byte order */
Linus Torvalds1a7809e2008-10-10 22:39:22 +020075 for (p = s ; p != end ; p += 2)
76 be16_to_cpus((u16 *) p);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 }
Linus Torvalds1a7809e2008-10-10 22:39:22 +020078
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 /* strip leading blanks */
Linus Torvalds1a7809e2008-10-10 22:39:22 +020080 p = s;
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 while (s != end && *s == ' ')
82 ++s;
83 /* compress internal blanks and strip trailing blanks */
84 while (s != end && *s) {
85 if (*s++ != ' ' || (s != end && *s && *s != ' '))
86 *p++ = *(s-1);
87 }
88 /* wipe out trailing garbage */
89 while (p != end)
90 *p++ = '\0';
91}
Linus Torvalds1da177e2005-04-16 15:20:36 -070092EXPORT_SYMBOL(ide_fixstring);
93
Linus Torvalds1da177e2005-04-16 15:20:36 -070094/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 * This routine busy-waits for the drive status to be not "busy".
96 * It then checks the status for all of the "good" bits and none
97 * of the "bad" bits, and if all is okay it returns 0. All other
Bartlomiej Zolnierkiewicz74af21c2007-10-13 17:47:49 +020098 * cases return error -- caller may then invoke ide_error().
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 *
100 * This routine should get fixed to not hog the cpu during extra long waits..
101 * That could be done by busy-waiting for the first jiffy or two, and then
102 * setting a timer to wake up at half second intervals thereafter,
103 * until timeout is achieved, before timing out.
104 */
Bartlomiej Zolnierkiewiczfa56d4c2009-06-23 11:29:11 +0000105int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad,
106 unsigned long timeout, u8 *rstat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107{
Bartlomiej Zolnierkiewiczb73c7ee2008-07-23 19:55:52 +0200108 ide_hwif_t *hwif = drive->hwif;
Bartlomiej Zolnierkiewicz374e0422008-07-23 19:55:56 +0200109 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 unsigned long flags;
Bartlomiej Zolnierkiewicz74af21c2007-10-13 17:47:49 +0200111 int i;
112 u8 stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113
114 udelay(1); /* spec allows drive 400ns to assert "BUSY" */
Bartlomiej Zolnierkiewicz374e0422008-07-23 19:55:56 +0200115 stat = tp_ops->read_status(hwif);
Bartlomiej Zolnierkiewiczc47137a2008-02-06 02:57:51 +0100116
Bartlomiej Zolnierkiewicz3a7d2482008-10-10 22:39:21 +0200117 if (stat & ATA_BUSY) {
Bartlomiej Zolnierkiewicz9b896032009-01-14 19:19:02 +0100118 local_save_flags(flags);
Bartlomiej Zolnierkiewicz54cc1422009-01-06 17:20:52 +0100119 local_irq_enable_in_hardirq();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 timeout += jiffies;
Bartlomiej Zolnierkiewicz3a7d2482008-10-10 22:39:21 +0200121 while ((stat = tp_ops->read_status(hwif)) & ATA_BUSY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 if (time_after(jiffies, timeout)) {
123 /*
124 * One last read after the timeout in case
125 * heavy interrupt load made us not make any
126 * progress during the timeout..
127 */
Bartlomiej Zolnierkiewicz374e0422008-07-23 19:55:56 +0200128 stat = tp_ops->read_status(hwif);
Bartlomiej Zolnierkiewicz3a7d2482008-10-10 22:39:21 +0200129 if ((stat & ATA_BUSY) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 break;
131
132 local_irq_restore(flags);
Bartlomiej Zolnierkiewicz74af21c2007-10-13 17:47:49 +0200133 *rstat = stat;
134 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 }
136 }
137 local_irq_restore(flags);
138 }
139 /*
140 * Allow status to settle, then read it again.
141 * A few rare drives vastly violate the 400ns spec here,
142 * so we'll wait up to 10usec for a "good" status
143 * rather than expensively fail things immediately.
144 * This fix courtesy of Matthew Faupel & Niccolo Rigacci.
145 */
146 for (i = 0; i < 10; i++) {
147 udelay(1);
Bartlomiej Zolnierkiewicz374e0422008-07-23 19:55:56 +0200148 stat = tp_ops->read_status(hwif);
Bartlomiej Zolnierkiewiczc47137a2008-02-06 02:57:51 +0100149
150 if (OK_STAT(stat, good, bad)) {
Bartlomiej Zolnierkiewicz74af21c2007-10-13 17:47:49 +0200151 *rstat = stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 return 0;
Bartlomiej Zolnierkiewicz74af21c2007-10-13 17:47:49 +0200153 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 }
Bartlomiej Zolnierkiewicz74af21c2007-10-13 17:47:49 +0200155 *rstat = stat;
156 return -EFAULT;
157}
158
159/*
160 * In case of error returns error value after doing "*startstop = ide_error()".
161 * The caller should return the updated value of "startstop" in this case,
162 * "startstop" is unchanged when the function returns 0.
163 */
Bartlomiej Zolnierkiewicz122f06f2009-03-24 23:22:47 +0100164int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good,
165 u8 bad, unsigned long timeout)
Bartlomiej Zolnierkiewicz74af21c2007-10-13 17:47:49 +0200166{
167 int err;
168 u8 stat;
169
170 /* bail early if we've exceeded max_failures */
171 if (drive->max_failures && (drive->failures > drive->max_failures)) {
172 *startstop = ide_stopped;
173 return 1;
174 }
175
176 err = __ide_wait_stat(drive, good, bad, timeout, &stat);
177
178 if (err) {
179 char *s = (err == -EBUSY) ? "status timeout" : "status error";
180 *startstop = ide_error(drive, s, stat);
181 }
182
183 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185EXPORT_SYMBOL(ide_wait_stat);
186
Bartlomiej Zolnierkiewicza5b7e702007-08-20 22:42:56 +0200187/**
188 * ide_in_drive_list - look for drive in black/white list
189 * @id: drive identifier
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200190 * @table: list to inspect
Bartlomiej Zolnierkiewicza5b7e702007-08-20 22:42:56 +0200191 *
192 * Look for a drive in the blacklist and the whitelist tables
193 * Returns 1 if the drive is found in the table.
194 */
195
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200196int ide_in_drive_list(u16 *id, const struct drive_list_entry *table)
Bartlomiej Zolnierkiewicza5b7e702007-08-20 22:42:56 +0200197{
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200198 for ( ; table->id_model; table++)
199 if ((!strcmp(table->id_model, (char *)&id[ATA_ID_PROD])) &&
200 (!table->id_firmware ||
201 strstr((char *)&id[ATA_ID_FW_REV], table->id_firmware)))
Bartlomiej Zolnierkiewicza5b7e702007-08-20 22:42:56 +0200202 return 1;
203 return 0;
204}
Bartlomiej Zolnierkiewiczb0244a02007-08-20 22:42:57 +0200205EXPORT_SYMBOL_GPL(ide_in_drive_list);
206
Bartlomiej Zolnierkiewicza5b7e702007-08-20 22:42:56 +0200207/*
208 * Early UDMA66 devices don't set bit14 to 1, only bit13 is valid.
Bartlomiej Zolnierkiewicz8588a2b72007-10-26 20:31:16 +0200209 * Some optical devices with the buggy firmwares have the same problem.
Bartlomiej Zolnierkiewicza5b7e702007-08-20 22:42:56 +0200210 */
211static const struct drive_list_entry ivb_list[] = {
212 { "QUANTUM FIREBALLlct10 05" , "A03.0900" },
Bartlomiej Zolnierkiewiczba9413b2009-06-23 16:11:10 -0700213 { "QUANTUM FIREBALLlct20 30" , "APL.0900" },
Bartlomiej Zolnierkiewicz8588a2b72007-10-26 20:31:16 +0200214 { "TSSTcorp CDDVDW SH-S202J" , "SB00" },
Peter Missele97564f2007-11-27 21:35:57 +0100215 { "TSSTcorp CDDVDW SH-S202J" , "SB01" },
216 { "TSSTcorp CDDVDW SH-S202N" , "SB00" },
217 { "TSSTcorp CDDVDW SH-S202N" , "SB01" },
Alexander Smal3ced5c42008-04-28 23:44:43 +0200218 { "TSSTcorp CDDVDW SH-S202H" , "SB00" },
219 { "TSSTcorp CDDVDW SH-S202H" , "SB01" },
Bartlomiej Zolnierkiewiczc7b997b2008-12-02 20:40:03 +0100220 { "SAMSUNG SP0822N" , "WA100-10" },
Bartlomiej Zolnierkiewicza5b7e702007-08-20 22:42:56 +0200221 { NULL , NULL }
222};
223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224/*
225 * All hosts that use the 80c ribbon must use!
226 * The name is derived from upper byte of word 93 and the 80c ribbon.
227 */
Bartlomiej Zolnierkiewicz122f06f2009-03-24 23:22:47 +0100228u8 eighty_ninty_three(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229{
Bartlomiej Zolnierkiewicz7f8f48a2007-05-10 00:01:10 +0200230 ide_hwif_t *hwif = drive->hwif;
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200231 u16 *id = drive->id;
Bartlomiej Zolnierkiewicza5b7e702007-08-20 22:42:56 +0200232 int ivb = ide_in_drive_list(id, ivb_list);
Bartlomiej Zolnierkiewicz7f8f48a2007-05-10 00:01:10 +0200233
Bartlomiej Zolnierkiewicz49521f92007-07-09 23:17:58 +0200234 if (hwif->cbl == ATA_CBL_PATA40_SHORT)
235 return 1;
236
Bartlomiej Zolnierkiewicza5b7e702007-08-20 22:42:56 +0200237 if (ivb)
238 printk(KERN_DEBUG "%s: skipping word 93 validity check\n",
239 drive->name);
240
Bartlomiej Zolnierkiewicz367d7e72008-10-10 22:39:30 +0200241 if (ata_id_is_sata(id) && !ivb)
George Kibardinb98f8802008-01-10 23:03:42 +0100242 return 1;
243
Bartlomiej Zolnierkiewicza5b7e702007-08-20 22:42:56 +0200244 if (hwif->cbl != ATA_CBL_PATA80 && !ivb)
Bartlomiej Zolnierkiewicz7f8f48a2007-05-10 00:01:10 +0200245 goto no_80w;
Alan Cox1a1276e2006-06-28 04:26:58 -0700246
Bartlomiej Zolnierkiewiczf68d9322007-03-26 23:03:18 +0200247 /*
248 * FIXME:
Bartlomiej Zolnierkiewiczf367bed2008-03-29 19:48:21 +0100249 * - change master/slave IDENTIFY order
Bartlomiej Zolnierkiewicza5b7e702007-08-20 22:42:56 +0200250 * - force bit13 (80c cable present) check also for !ivb devices
Bartlomiej Zolnierkiewiczf68d9322007-03-26 23:03:18 +0200251 * (unless the slave device is pre-ATA3)
252 */
Bartlomiej Zolnierkiewicz8369d5f2009-05-22 16:23:36 +0200253 if (id[ATA_ID_HW_CONFIG] & 0x4000)
Bartlomiej Zolnierkiewicz7f8f48a2007-05-10 00:01:10 +0200254 return 1;
255
Bartlomiej Zolnierkiewicz8369d5f2009-05-22 16:23:36 +0200256 if (ivb) {
257 const char *model = (char *)&id[ATA_ID_PROD];
258
259 if (strstr(model, "TSSTcorp CDDVDW SH-S202")) {
260 /*
261 * These ATAPI devices always report 80c cable
262 * so we have to depend on the host in this case.
263 */
264 if (hwif->cbl == ATA_CBL_PATA80)
265 return 1;
266 } else {
267 /* Depend on the device side cable detection. */
268 if (id[ATA_ID_HW_CONFIG] & 0x2000)
269 return 1;
270 }
271 }
Bartlomiej Zolnierkiewicz7f8f48a2007-05-10 00:01:10 +0200272no_80w:
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200273 if (drive->dev_flags & IDE_DFLAG_UDMA33_WARNED)
Bartlomiej Zolnierkiewicz7f8f48a2007-05-10 00:01:10 +0200274 return 0;
275
276 printk(KERN_WARNING "%s: %s side 80-wire cable detection failed, "
277 "limiting max speed to UDMA33\n",
Bartlomiej Zolnierkiewicz49521f92007-07-09 23:17:58 +0200278 drive->name,
279 hwif->cbl == ATA_CBL_PATA80 ? "drive" : "host");
Bartlomiej Zolnierkiewicz7f8f48a2007-05-10 00:01:10 +0200280
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200281 drive->dev_flags |= IDE_DFLAG_UDMA33_WARNED;
Bartlomiej Zolnierkiewicz7f8f48a2007-05-10 00:01:10 +0200282
283 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284}
285
Bartlomiej Zolnierkiewicz8bc1e5a2009-06-07 15:37:09 +0200286static const char *nien_quirk_list[] = {
287 "QUANTUM FIREBALLlct08 08",
288 "QUANTUM FIREBALLP KA6.4",
289 "QUANTUM FIREBALLP KA9.1",
290 "QUANTUM FIREBALLP KX13.6",
291 "QUANTUM FIREBALLP KX20.5",
292 "QUANTUM FIREBALLP KX27.3",
293 "QUANTUM FIREBALLP LM20.4",
294 "QUANTUM FIREBALLP LM20.5",
Wu Zhangjina2d10562009-09-15 01:36:25 -0700295 "FUJITSU MHZ2160BH G2",
Bartlomiej Zolnierkiewicz8bc1e5a2009-06-07 15:37:09 +0200296 NULL
297};
298
299void ide_check_nien_quirk_list(ide_drive_t *drive)
300{
301 const char **list, *m = (char *)&drive->id[ATA_ID_PROD];
302
303 for (list = nien_quirk_list; *list != NULL; list++)
304 if (strstr(m, *list) != NULL) {
Bartlomiej Zolnierkiewicz734affd2009-06-07 15:37:10 +0200305 drive->dev_flags |= IDE_DFLAG_NIEN_QUIRK;
Bartlomiej Zolnierkiewicz8bc1e5a2009-06-07 15:37:09 +0200306 return;
307 }
Bartlomiej Zolnierkiewicz8bc1e5a2009-06-07 15:37:09 +0200308}
309
Bartlomiej Zolnierkiewicz8a455132007-10-20 00:32:36 +0200310int ide_driveid_update(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311{
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200312 u16 *id;
Bartlomiej Zolnierkiewicz2ebe1d92009-03-24 23:22:59 +0100313 int rc;
Bartlomiej Zolnierkiewicz2f40c9b2009-03-24 23:22:54 +0100314
315 id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
316 if (id == NULL)
317 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 SELECT_MASK(drive, 1);
Bartlomiej Zolnierkiewiczfa56d4c2009-06-23 11:29:11 +0000320 rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id, 1);
Bartlomiej Zolnierkiewiczf323b802009-03-24 23:22:58 +0100321 SELECT_MASK(drive, 0);
322
Bartlomiej Zolnierkiewicz2ebe1d92009-03-24 23:22:59 +0100323 if (rc)
324 goto out_err;
325
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200326 drive->id[ATA_ID_UDMA_MODES] = id[ATA_ID_UDMA_MODES];
327 drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES];
328 drive->id[ATA_ID_SWDMA_MODES] = id[ATA_ID_SWDMA_MODES];
Sergei Shtylyov74638c82009-03-31 20:15:28 +0200329 drive->id[ATA_ID_CFA_MODES] = id[ATA_ID_CFA_MODES];
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200330 /* anything more ? */
331
332 kfree(id);
333
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 return 1;
Bartlomiej Zolnierkiewicz2f40c9b2009-03-24 23:22:54 +0100335out_err:
Bartlomiej Zolnierkiewicz2f40c9b2009-03-24 23:22:54 +0100336 if (rc == 2)
337 printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__);
338 kfree(id);
339 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340}
341
Bartlomiej Zolnierkiewicz74af21c2007-10-13 17:47:49 +0200342int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
Bartlomiej Zolnierkiewicz74af21c2007-10-13 17:47:49 +0200344 ide_hwif_t *hwif = drive->hwif;
Bartlomiej Zolnierkiewicz374e0422008-07-23 19:55:56 +0200345 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
Sergei Shtylyovc9ff9e72009-04-08 14:13:03 +0200346 struct ide_taskfile tf;
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200347 u16 *id = drive->id, i;
Sergei Shtylyov89613e62007-11-27 21:35:52 +0100348 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 u8 stat;
350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351#ifdef CONFIG_BLK_DEV_IDEDMA
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200352 if (hwif->dma_ops) /* check if host supports DMA */
353 hwif->dma_ops->dma_host_set(drive, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354#endif
355
Sergei Shtylyov89613e62007-11-27 21:35:52 +0100356 /* Skip setting PIO flow-control modes on pre-EIDE drives */
Bartlomiej Zolnierkiewicz48fb2682008-10-10 22:39:19 +0200357 if ((speed & 0xf8) == XFER_PIO_0 && ata_id_has_iordy(drive->id) == 0)
Sergei Shtylyov89613e62007-11-27 21:35:52 +0100358 goto skip;
359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 /*
361 * Don't use ide_wait_cmd here - it will
362 * attempt to set_geometry and recalibrate,
363 * but for some reason these don't work at
364 * this point (lost interrupt).
365 */
Bartlomiej Zolnierkiewiczee1b1cc2009-03-24 23:22:47 +0100366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 udelay(1);
Sergei Shtylyovfdd88f02009-03-31 20:15:33 +0200368 tp_ops->dev_select(drive);
Sergei Shtylyove5403bf2008-10-17 18:09:15 +0200369 SELECT_MASK(drive, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 udelay(1);
Sergei Shtylyovecf3a312009-03-31 20:15:30 +0200371 tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
Bartlomiej Zolnierkiewicz59be2c82008-07-23 19:55:52 +0200372
Sergei Shtylyovc9ff9e72009-04-08 14:13:03 +0200373 memset(&tf, 0, sizeof(tf));
374 tf.feature = SETFEATURES_XFER;
375 tf.nsect = speed;
Bartlomiej Zolnierkiewicz59be2c82008-07-23 19:55:52 +0200376
Sergei Shtylyovc9ff9e72009-04-08 14:13:03 +0200377 tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE | IDE_VALID_NSECT);
Bartlomiej Zolnierkiewicz59be2c82008-07-23 19:55:52 +0200378
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200379 tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);
Bartlomiej Zolnierkiewicz59be2c82008-07-23 19:55:52 +0200380
Bartlomiej Zolnierkiewicz734affd2009-06-07 15:37:10 +0200381 if (drive->dev_flags & IDE_DFLAG_NIEN_QUIRK)
Sergei Shtylyovecf3a312009-03-31 20:15:30 +0200382 tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
Bartlomiej Zolnierkiewicz74af21c2007-10-13 17:47:49 +0200384 error = __ide_wait_stat(drive, drive->ready_stat,
Bartlomiej Zolnierkiewicz3a7d2482008-10-10 22:39:21 +0200385 ATA_BUSY | ATA_DRQ | ATA_ERR,
Bartlomiej Zolnierkiewicz74af21c2007-10-13 17:47:49 +0200386 WAIT_CMD, &stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
388 SELECT_MASK(drive, 0);
389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 if (error) {
391 (void) ide_dump_status(drive, "set_drive_speed_status", stat);
392 return error;
393 }
394
Sergei Shtylyovc4199932009-03-31 20:15:27 +0200395 if (speed >= XFER_SW_DMA_0) {
396 id[ATA_ID_UDMA_MODES] &= ~0xFF00;
397 id[ATA_ID_MWDMA_MODES] &= ~0x0700;
398 id[ATA_ID_SWDMA_MODES] &= ~0x0700;
Sergei Shtylyov74638c82009-03-31 20:15:28 +0200399 if (ata_id_is_cfa(id))
400 id[ATA_ID_CFA_MODES] &= ~0x0E00;
401 } else if (ata_id_is_cfa(id))
402 id[ATA_ID_CFA_MODES] &= ~0x01C0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Sergei Shtylyov89613e62007-11-27 21:35:52 +0100404 skip:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405#ifdef CONFIG_BLK_DEV_IDEDMA
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200406 if (speed >= XFER_SW_DMA_0 && (drive->dev_flags & IDE_DFLAG_USING_DMA))
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200407 hwif->dma_ops->dma_host_set(drive, 1);
408 else if (hwif->dma_ops) /* check if host supports DMA */
Bartlomiej Zolnierkiewicz4a546e02008-01-26 20:13:01 +0100409 ide_dma_off_quietly(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410#endif
411
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200412 if (speed >= XFER_UDMA_0) {
413 i = 1 << (speed - XFER_UDMA_0);
414 id[ATA_ID_UDMA_MODES] |= (i << 8 | i);
Sergei Shtylyov74638c82009-03-31 20:15:28 +0200415 } else if (ata_id_is_cfa(id) && speed >= XFER_MW_DMA_3) {
416 i = speed - XFER_MW_DMA_2;
417 id[ATA_ID_CFA_MODES] |= i << 9;
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200418 } else if (speed >= XFER_MW_DMA_0) {
419 i = 1 << (speed - XFER_MW_DMA_0);
420 id[ATA_ID_MWDMA_MODES] |= (i << 8 | i);
421 } else if (speed >= XFER_SW_DMA_0) {
422 i = 1 << (speed - XFER_SW_DMA_0);
423 id[ATA_ID_SWDMA_MODES] |= (i << 8 | i);
Sergei Shtylyov74638c82009-03-31 20:15:28 +0200424 } else if (ata_id_is_cfa(id) && speed >= XFER_PIO_5) {
425 i = speed - XFER_PIO_4;
426 id[ATA_ID_CFA_MODES] |= i << 6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 }
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200428
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 if (!drive->init_speed)
430 drive->init_speed = speed;
431 drive->current_speed = speed;
432 return error;
433}
434
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435/*
436 * This should get invoked any time we exit the driver to
437 * wait for an interrupt response from a drive. handler() points
438 * at the appropriate code to handle the next interrupt, and a
439 * timer is started to prevent us from waiting forever in case
440 * something goes wrong (see the ide_timer_expiry() handler later on).
441 *
442 * See also ide_execute_command
443 */
Bartlomiej Zolnierkiewicz327fa1c2009-03-24 23:22:47 +0100444void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
Bartlomiej Zolnierkiewicz60c0cd02009-03-27 12:46:46 +0100445 unsigned int timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446{
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100447 ide_hwif_t *hwif = drive->hwif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100449 BUG_ON(hwif->handler);
450 hwif->handler = handler;
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100451 hwif->timer.expires = jiffies + timeout;
452 hwif->req_gen_timer = hwif->req_gen;
453 add_timer(&hwif->timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454}
455
Bartlomiej Zolnierkiewicz60c0cd02009-03-27 12:46:46 +0100456void ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
457 unsigned int timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458{
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100459 ide_hwif_t *hwif = drive->hwif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 unsigned long flags;
Bartlomiej Zolnierkiewicz2a2ca6a2008-12-29 20:27:31 +0100461
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100462 spin_lock_irqsave(&hwif->lock, flags);
Bartlomiej Zolnierkiewicz60c0cd02009-03-27 12:46:46 +0100463 __ide_set_handler(drive, handler, timeout);
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100464 spin_unlock_irqrestore(&hwif->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466EXPORT_SYMBOL(ide_set_handler);
Bartlomiej Zolnierkiewicz122f06f2009-03-24 23:22:47 +0100467
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468/**
469 * ide_execute_command - execute an IDE command
470 * @drive: IDE drive to issue the command against
Bartlomiej Zolnierkiewicz35b5d0b2009-03-27 12:46:47 +0100471 * @cmd: command
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 * @handler: handler for next phase
473 * @timeout: timeout for command
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 *
475 * Helper function to issue an IDE command. This handles the
Bartlomiej Zolnierkiewicz122f06f2009-03-24 23:22:47 +0100476 * atomicity requirements, command timing and ensures that the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 * handler and IRQ setup do not race. All IDE command kick off
478 * should go via this function or do equivalent locking.
479 */
Bartlomiej Zolnierkiewiczcd2a2d92008-01-25 22:17:06 +0100480
Bartlomiej Zolnierkiewicz35b5d0b2009-03-27 12:46:47 +0100481void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd,
482 ide_handler_t *handler, unsigned timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483{
Bartlomiej Zolnierkiewicz2a2ca6a2008-12-29 20:27:31 +0100484 ide_hwif_t *hwif = drive->hwif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 unsigned long flags;
Bartlomiej Zolnierkiewicz629f9442008-02-02 19:56:46 +0100486
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100487 spin_lock_irqsave(&hwif->lock, flags);
Bartlomiej Zolnierkiewicz35b5d0b2009-03-27 12:46:47 +0100488 if ((cmd->protocol != ATAPI_PROT_DMA &&
489 cmd->protocol != ATAPI_PROT_PIO) ||
490 (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT))
491 __ide_set_handler(drive, handler, timeout);
492 hwif->tp_ops->exec_command(hwif, cmd->tf.command);
Bartlomiej Zolnierkiewicz629f9442008-02-02 19:56:46 +0100493 /*
494 * Drive takes 400nS to respond, we must avoid the IRQ being
495 * serviced before that.
496 *
497 * FIXME: we could skip this delay with care on non shared devices
498 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 ndelay(400);
Bartlomiej Zolnierkiewiczb65fac32009-01-06 17:20:50 +0100500 spin_unlock_irqrestore(&hwif->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503/*
504 * ide_wait_not_busy() waits for the currently selected device on the hwif
Bartlomiej Zolnierkiewicz9d501522008-02-01 23:09:36 +0100505 * to report a non-busy status, see comments in ide_probe_port().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 */
507int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
508{
509 u8 stat = 0;
510
Bartlomiej Zolnierkiewicz122f06f2009-03-24 23:22:47 +0100511 while (timeout--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 /*
513 * Turn this into a schedule() sleep once I'm sure
514 * about locking issues (2.5 work ?).
515 */
516 mdelay(1);
Bartlomiej Zolnierkiewicz374e0422008-07-23 19:55:56 +0200517 stat = hwif->tp_ops->read_status(hwif);
Bartlomiej Zolnierkiewicz3a7d2482008-10-10 22:39:21 +0200518 if ((stat & ATA_BUSY) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 return 0;
520 /*
521 * Assume a value of 0xff means nothing is connected to
522 * the interface and it doesn't implement the pull-down
523 * resistor on D7.
524 */
525 if (stat == 0xff)
526 return -ENODEV;
Ingo Molnar6842f8c2006-02-03 03:04:55 -0800527 touch_softlockup_watchdog();
Michal Schmidt1e862402006-07-30 03:03:29 -0700528 touch_nmi_watchdog();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 }
530 return -EBUSY;
531}