This source file includes following definitions.
- SELECT_MASK
- ide_read_error
- ide_fix_driveid
- ide_fixstring
- __ide_wait_stat
- ide_wait_stat
- ide_in_drive_list
- eighty_ninty_three
- ide_check_nien_quirk_list
- ide_driveid_update
- ide_config_drive_speed
- __ide_set_handler
- ide_set_handler
- ide_execute_command
- ide_wait_not_busy
1
2
3
4
5
6
7
8 #include <linux/module.h>
9 #include <linux/types.h>
10 #include <linux/string.h>
11 #include <linux/kernel.h>
12 #include <linux/timer.h>
13 #include <linux/mm.h>
14 #include <linux/interrupt.h>
15 #include <linux/major.h>
16 #include <linux/errno.h>
17 #include <linux/genhd.h>
18 #include <linux/blkpg.h>
19 #include <linux/slab.h>
20 #include <linux/pci.h>
21 #include <linux/delay.h>
22 #include <linux/ide.h>
23 #include <linux/bitops.h>
24 #include <linux/nmi.h>
25
26 #include <asm/byteorder.h>
27 #include <asm/irq.h>
28 #include <linux/uaccess.h>
29 #include <asm/io.h>
30
31 void SELECT_MASK(ide_drive_t *drive, int mask)
32 {
33 const struct ide_port_ops *port_ops = drive->hwif->port_ops;
34
35 if (port_ops && port_ops->maskproc)
36 port_ops->maskproc(drive, mask);
37 }
38
39 u8 ide_read_error(ide_drive_t *drive)
40 {
41 struct ide_taskfile tf;
42
43 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_ERROR);
44
45 return tf.error;
46 }
47 EXPORT_SYMBOL_GPL(ide_read_error);
48
49 void ide_fix_driveid(u16 *id)
50 {
51 #ifndef __LITTLE_ENDIAN
52 # ifdef __BIG_ENDIAN
53 int i;
54
55 for (i = 0; i < 256; i++)
56 id[i] = __le16_to_cpu(id[i]);
57 # else
58 # error "Please fix <asm/byteorder.h>"
59 # endif
60 #endif
61 }
62
63
64
65
66
67
68
69
70 void ide_fixstring(u8 *s, const int bytecount, const int byteswap)
71 {
72 u8 *p, *end = &s[bytecount & ~1];
73
74 if (byteswap) {
75
76 for (p = s ; p != end ; p += 2)
77 be16_to_cpus((u16 *) p);
78 }
79
80
81 p = s;
82 while (s != end && *s == ' ')
83 ++s;
84
85 while (s != end && *s) {
86 if (*s++ != ' ' || (s != end && *s && *s != ' '))
87 *p++ = *(s-1);
88 }
89
90 while (p != end)
91 *p++ = '\0';
92 }
93 EXPORT_SYMBOL(ide_fixstring);
94
95
96
97
98
99
100
101
102
103
104
105
106 int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad,
107 unsigned long timeout, u8 *rstat)
108 {
109 ide_hwif_t *hwif = drive->hwif;
110 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
111 unsigned long flags;
112 bool irqs_threaded = force_irqthreads;
113 int i;
114 u8 stat;
115
116 udelay(1);
117 stat = tp_ops->read_status(hwif);
118
119 if (stat & ATA_BUSY) {
120 if (!irqs_threaded) {
121 local_save_flags(flags);
122 local_irq_enable_in_hardirq();
123 }
124 timeout += jiffies;
125 while ((stat = tp_ops->read_status(hwif)) & ATA_BUSY) {
126 if (time_after(jiffies, timeout)) {
127
128
129
130
131
132 stat = tp_ops->read_status(hwif);
133 if ((stat & ATA_BUSY) == 0)
134 break;
135
136 if (!irqs_threaded)
137 local_irq_restore(flags);
138 *rstat = stat;
139 return -EBUSY;
140 }
141 }
142 if (!irqs_threaded)
143 local_irq_restore(flags);
144 }
145
146
147
148
149
150
151
152 for (i = 0; i < 10; i++) {
153 udelay(1);
154 stat = tp_ops->read_status(hwif);
155
156 if (OK_STAT(stat, good, bad)) {
157 *rstat = stat;
158 return 0;
159 }
160 }
161 *rstat = stat;
162 return -EFAULT;
163 }
164
165
166
167
168
169
170 int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good,
171 u8 bad, unsigned long timeout)
172 {
173 int err;
174 u8 stat;
175
176
177 if (drive->max_failures && (drive->failures > drive->max_failures)) {
178 *startstop = ide_stopped;
179 return 1;
180 }
181
182 err = __ide_wait_stat(drive, good, bad, timeout, &stat);
183
184 if (err) {
185 char *s = (err == -EBUSY) ? "status timeout" : "status error";
186 *startstop = ide_error(drive, s, stat);
187 }
188
189 return err;
190 }
191 EXPORT_SYMBOL(ide_wait_stat);
192
193
194
195
196
197
198
199
200
201
202 int ide_in_drive_list(u16 *id, const struct drive_list_entry *table)
203 {
204 for ( ; table->id_model; table++)
205 if ((!strcmp(table->id_model, (char *)&id[ATA_ID_PROD])) &&
206 (!table->id_firmware ||
207 strstr((char *)&id[ATA_ID_FW_REV], table->id_firmware)))
208 return 1;
209 return 0;
210 }
211 EXPORT_SYMBOL_GPL(ide_in_drive_list);
212
213
214
215
216
217 static const struct drive_list_entry ivb_list[] = {
218 { "QUANTUM FIREBALLlct10 05" , "A03.0900" },
219 { "QUANTUM FIREBALLlct20 30" , "APL.0900" },
220 { "TSSTcorp CDDVDW SH-S202J" , "SB00" },
221 { "TSSTcorp CDDVDW SH-S202J" , "SB01" },
222 { "TSSTcorp CDDVDW SH-S202N" , "SB00" },
223 { "TSSTcorp CDDVDW SH-S202N" , "SB01" },
224 { "TSSTcorp CDDVDW SH-S202H" , "SB00" },
225 { "TSSTcorp CDDVDW SH-S202H" , "SB01" },
226 { "SAMSUNG SP0822N" , "WA100-10" },
227 { NULL , NULL }
228 };
229
230
231
232
233
234 u8 eighty_ninty_three(ide_drive_t *drive)
235 {
236 ide_hwif_t *hwif = drive->hwif;
237 u16 *id = drive->id;
238 int ivb = ide_in_drive_list(id, ivb_list);
239
240 if (hwif->cbl == ATA_CBL_SATA || hwif->cbl == ATA_CBL_PATA40_SHORT)
241 return 1;
242
243 if (ivb)
244 printk(KERN_DEBUG "%s: skipping word 93 validity check\n",
245 drive->name);
246
247 if (ata_id_is_sata(id) && !ivb)
248 return 1;
249
250 if (hwif->cbl != ATA_CBL_PATA80 && !ivb)
251 goto no_80w;
252
253
254
255
256
257
258
259 if (id[ATA_ID_HW_CONFIG] & 0x4000)
260 return 1;
261
262 if (ivb) {
263 const char *model = (char *)&id[ATA_ID_PROD];
264
265 if (strstr(model, "TSSTcorp CDDVDW SH-S202")) {
266
267
268
269
270 if (hwif->cbl == ATA_CBL_PATA80)
271 return 1;
272 } else {
273
274 if (id[ATA_ID_HW_CONFIG] & 0x2000)
275 return 1;
276 }
277 }
278 no_80w:
279 if (drive->dev_flags & IDE_DFLAG_UDMA33_WARNED)
280 return 0;
281
282 printk(KERN_WARNING "%s: %s side 80-wire cable detection failed, "
283 "limiting max speed to UDMA33\n",
284 drive->name,
285 hwif->cbl == ATA_CBL_PATA80 ? "drive" : "host");
286
287 drive->dev_flags |= IDE_DFLAG_UDMA33_WARNED;
288
289 return 0;
290 }
291
292 static const char *nien_quirk_list[] = {
293 "QUANTUM FIREBALLlct08 08",
294 "QUANTUM FIREBALLP KA6.4",
295 "QUANTUM FIREBALLP KA9.1",
296 "QUANTUM FIREBALLP KX13.6",
297 "QUANTUM FIREBALLP KX20.5",
298 "QUANTUM FIREBALLP KX27.3",
299 "QUANTUM FIREBALLP LM20.4",
300 "QUANTUM FIREBALLP LM20.5",
301 "FUJITSU MHZ2160BH G2",
302 NULL
303 };
304
305 void ide_check_nien_quirk_list(ide_drive_t *drive)
306 {
307 const char **list, *m = (char *)&drive->id[ATA_ID_PROD];
308
309 for (list = nien_quirk_list; *list != NULL; list++)
310 if (strstr(m, *list) != NULL) {
311 drive->dev_flags |= IDE_DFLAG_NIEN_QUIRK;
312 return;
313 }
314 }
315
316 int ide_driveid_update(ide_drive_t *drive)
317 {
318 u16 *id;
319 int rc;
320
321 id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
322 if (id == NULL)
323 return 0;
324
325 SELECT_MASK(drive, 1);
326 rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id, 1);
327 SELECT_MASK(drive, 0);
328
329 if (rc)
330 goto out_err;
331
332 drive->id[ATA_ID_UDMA_MODES] = id[ATA_ID_UDMA_MODES];
333 drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES];
334 drive->id[ATA_ID_SWDMA_MODES] = id[ATA_ID_SWDMA_MODES];
335 drive->id[ATA_ID_CFA_MODES] = id[ATA_ID_CFA_MODES];
336
337
338 kfree(id);
339
340 return 1;
341 out_err:
342 if (rc == 2)
343 printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__);
344 kfree(id);
345 return 0;
346 }
347
348 int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
349 {
350 ide_hwif_t *hwif = drive->hwif;
351 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
352 struct ide_taskfile tf;
353 u16 *id = drive->id, i;
354 int error = 0;
355 u8 stat;
356
357 #ifdef CONFIG_BLK_DEV_IDEDMA
358 if (hwif->dma_ops)
359 hwif->dma_ops->dma_host_set(drive, 0);
360 #endif
361
362
363 if ((speed & 0xf8) == XFER_PIO_0 && ata_id_has_iordy(drive->id) == 0)
364 goto skip;
365
366
367
368
369
370
371
372
373 udelay(1);
374 tp_ops->dev_select(drive);
375 SELECT_MASK(drive, 1);
376 udelay(1);
377 tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
378
379 memset(&tf, 0, sizeof(tf));
380 tf.feature = SETFEATURES_XFER;
381 tf.nsect = speed;
382
383 tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE | IDE_VALID_NSECT);
384
385 tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);
386
387 if (drive->dev_flags & IDE_DFLAG_NIEN_QUIRK)
388 tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
389
390 error = __ide_wait_stat(drive, drive->ready_stat,
391 ATA_BUSY | ATA_DRQ | ATA_ERR,
392 WAIT_CMD, &stat);
393
394 SELECT_MASK(drive, 0);
395
396 if (error) {
397 (void) ide_dump_status(drive, "set_drive_speed_status", stat);
398 return error;
399 }
400
401 if (speed >= XFER_SW_DMA_0) {
402 id[ATA_ID_UDMA_MODES] &= ~0xFF00;
403 id[ATA_ID_MWDMA_MODES] &= ~0x0700;
404 id[ATA_ID_SWDMA_MODES] &= ~0x0700;
405 if (ata_id_is_cfa(id))
406 id[ATA_ID_CFA_MODES] &= ~0x0E00;
407 } else if (ata_id_is_cfa(id))
408 id[ATA_ID_CFA_MODES] &= ~0x01C0;
409
410 skip:
411 #ifdef CONFIG_BLK_DEV_IDEDMA
412 if (speed >= XFER_SW_DMA_0 && (drive->dev_flags & IDE_DFLAG_USING_DMA))
413 hwif->dma_ops->dma_host_set(drive, 1);
414 else if (hwif->dma_ops)
415 ide_dma_off_quietly(drive);
416 #endif
417
418 if (speed >= XFER_UDMA_0) {
419 i = 1 << (speed - XFER_UDMA_0);
420 id[ATA_ID_UDMA_MODES] |= (i << 8 | i);
421 } else if (ata_id_is_cfa(id) && speed >= XFER_MW_DMA_3) {
422 i = speed - XFER_MW_DMA_2;
423 id[ATA_ID_CFA_MODES] |= i << 9;
424 } else if (speed >= XFER_MW_DMA_0) {
425 i = 1 << (speed - XFER_MW_DMA_0);
426 id[ATA_ID_MWDMA_MODES] |= (i << 8 | i);
427 } else if (speed >= XFER_SW_DMA_0) {
428 i = 1 << (speed - XFER_SW_DMA_0);
429 id[ATA_ID_SWDMA_MODES] |= (i << 8 | i);
430 } else if (ata_id_is_cfa(id) && speed >= XFER_PIO_5) {
431 i = speed - XFER_PIO_4;
432 id[ATA_ID_CFA_MODES] |= i << 6;
433 }
434
435 if (!drive->init_speed)
436 drive->init_speed = speed;
437 drive->current_speed = speed;
438 return error;
439 }
440
441
442
443
444
445
446
447
448
449
450 void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
451 unsigned int timeout)
452 {
453 ide_hwif_t *hwif = drive->hwif;
454
455 BUG_ON(hwif->handler);
456 hwif->handler = handler;
457 hwif->timer.expires = jiffies + timeout;
458 hwif->req_gen_timer = hwif->req_gen;
459 add_timer(&hwif->timer);
460 }
461
462 void ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
463 unsigned int timeout)
464 {
465 ide_hwif_t *hwif = drive->hwif;
466 unsigned long flags;
467
468 spin_lock_irqsave(&hwif->lock, flags);
469 __ide_set_handler(drive, handler, timeout);
470 spin_unlock_irqrestore(&hwif->lock, flags);
471 }
472 EXPORT_SYMBOL(ide_set_handler);
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487 void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd,
488 ide_handler_t *handler, unsigned timeout)
489 {
490 ide_hwif_t *hwif = drive->hwif;
491 unsigned long flags;
492
493 spin_lock_irqsave(&hwif->lock, flags);
494 if ((cmd->protocol != ATAPI_PROT_DMA &&
495 cmd->protocol != ATAPI_PROT_PIO) ||
496 (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT))
497 __ide_set_handler(drive, handler, timeout);
498 hwif->tp_ops->exec_command(hwif, cmd->tf.command);
499
500
501
502
503
504
505 ndelay(400);
506 spin_unlock_irqrestore(&hwif->lock, flags);
507 }
508
509
510
511
512
513 int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
514 {
515 u8 stat = 0;
516
517 while (timeout--) {
518
519
520
521
522 mdelay(1);
523 stat = hwif->tp_ops->read_status(hwif);
524 if ((stat & ATA_BUSY) == 0)
525 return 0;
526
527
528
529
530
531 if (stat == 0xff)
532 return -ENODEV;
533 touch_softlockup_watchdog();
534 touch_nmi_watchdog();
535 }
536 return -EBUSY;
537 }