1/*
2 *  Copyright (C) 2000-2002	Andre Hedrick <andre@linux-ide.org>
3 *  Copyright (C) 2003		Red Hat
4 *
5 */
6
7#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>
21#include <linux/ide.h>
22#include <linux/bitops.h>
23#include <linux/nmi.h>
24
25#include <asm/byteorder.h>
26#include <asm/irq.h>
27#include <asm/uaccess.h>
28#include <asm/io.h>
29
30void SELECT_MASK(ide_drive_t *drive, int mask)
31{
32	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);
36}
37
38u8 ide_read_error(ide_drive_t *drive)
39{
40	struct ide_taskfile tf;
41
42	drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_ERROR);
43
44	return tf.error;
45}
46EXPORT_SYMBOL_GPL(ide_read_error);
47
48void ide_fix_driveid(u16 *id)
49{
50#ifndef __LITTLE_ENDIAN
51# ifdef __BIG_ENDIAN
52	int i;
53
54	for (i = 0; i < 256; i++)
55		id[i] = __le16_to_cpu(id[i]);
56# else
57#  error "Please fix <asm/byteorder.h>"
58# endif
59#endif
60}
61
62/*
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
66 * returned by the ATA_CMD_ID_ATA[PI] commands.
67 */
68
69void ide_fixstring(u8 *s, const int bytecount, const int byteswap)
70{
71	u8 *p, *end = &s[bytecount & ~1]; /* bytecount must be even */
72
73	if (byteswap) {
74		/* convert from big-endian to host byte order */
75		for (p = s ; p != end ; p += 2)
76			be16_to_cpus((u16 *) p);
77	}
78
79	/* strip leading blanks */
80	p = s;
81	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}
92EXPORT_SYMBOL(ide_fixstring);
93
94/*
95 * 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
98 * cases return error -- caller may then invoke ide_error().
99 *
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 */
105int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad,
106		    unsigned long timeout, u8 *rstat)
107{
108	ide_hwif_t *hwif = drive->hwif;
109	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
110	unsigned long flags;
111	int i;
112	u8 stat;
113
114	udelay(1);	/* spec allows drive 400ns to assert "BUSY" */
115	stat = tp_ops->read_status(hwif);
116
117	if (stat & ATA_BUSY) {
118		local_save_flags(flags);
119		local_irq_enable_in_hardirq();
120		timeout += jiffies;
121		while ((stat = tp_ops->read_status(hwif)) & ATA_BUSY) {
122			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				 */
128				stat = tp_ops->read_status(hwif);
129				if ((stat & ATA_BUSY) == 0)
130					break;
131
132				local_irq_restore(flags);
133				*rstat = stat;
134				return -EBUSY;
135			}
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);
148		stat = tp_ops->read_status(hwif);
149
150		if (OK_STAT(stat, good, bad)) {
151			*rstat = stat;
152			return 0;
153		}
154	}
155	*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 */
164int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good,
165		  u8 bad, unsigned long timeout)
166{
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;
184}
185EXPORT_SYMBOL(ide_wait_stat);
186
187/**
188 *	ide_in_drive_list	-	look for drive in black/white list
189 *	@id: drive identifier
190 *	@table: list to inspect
191 *
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
196int ide_in_drive_list(u16 *id, const struct drive_list_entry *table)
197{
198	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)))
202			return 1;
203	return 0;
204}
205EXPORT_SYMBOL_GPL(ide_in_drive_list);
206
207/*
208 * Early UDMA66 devices don't set bit14 to 1, only bit13 is valid.
209 * Some optical devices with the buggy firmwares have the same problem.
210 */
211static const struct drive_list_entry ivb_list[] = {
212	{ "QUANTUM FIREBALLlct10 05"	, "A03.0900"	},
213	{ "QUANTUM FIREBALLlct20 30"	, "APL.0900"	},
214	{ "TSSTcorp CDDVDW SH-S202J"	, "SB00"	},
215	{ "TSSTcorp CDDVDW SH-S202J"	, "SB01"	},
216	{ "TSSTcorp CDDVDW SH-S202N"	, "SB00"	},
217	{ "TSSTcorp CDDVDW SH-S202N"	, "SB01"	},
218	{ "TSSTcorp CDDVDW SH-S202H"	, "SB00"	},
219	{ "TSSTcorp CDDVDW SH-S202H"	, "SB01"	},
220	{ "SAMSUNG SP0822N"		, "WA100-10"	},
221	{ NULL				, NULL		}
222};
223
224/*
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 */
228u8 eighty_ninty_three(ide_drive_t *drive)
229{
230	ide_hwif_t *hwif = drive->hwif;
231	u16 *id = drive->id;
232	int ivb = ide_in_drive_list(id, ivb_list);
233
234	if (hwif->cbl == ATA_CBL_SATA || hwif->cbl == ATA_CBL_PATA40_SHORT)
235		return 1;
236
237	if (ivb)
238		printk(KERN_DEBUG "%s: skipping word 93 validity check\n",
239				  drive->name);
240
241	if (ata_id_is_sata(id) && !ivb)
242		return 1;
243
244	if (hwif->cbl != ATA_CBL_PATA80 && !ivb)
245		goto no_80w;
246
247	/*
248	 * FIXME:
249	 * - change master/slave IDENTIFY order
250	 * - force bit13 (80c cable present) check also for !ivb devices
251	 *   (unless the slave device is pre-ATA3)
252	 */
253	if (id[ATA_ID_HW_CONFIG] & 0x4000)
254		return 1;
255
256	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	}
272no_80w:
273	if (drive->dev_flags & IDE_DFLAG_UDMA33_WARNED)
274		return 0;
275
276	printk(KERN_WARNING "%s: %s side 80-wire cable detection failed, "
277			    "limiting max speed to UDMA33\n",
278			    drive->name,
279			    hwif->cbl == ATA_CBL_PATA80 ? "drive" : "host");
280
281	drive->dev_flags |= IDE_DFLAG_UDMA33_WARNED;
282
283	return 0;
284}
285
286static 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",
295	"FUJITSU MHZ2160BH G2",
296	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) {
305			drive->dev_flags |= IDE_DFLAG_NIEN_QUIRK;
306			return;
307		}
308}
309
310int ide_driveid_update(ide_drive_t *drive)
311{
312	u16 *id;
313	int rc;
314
315	id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
316	if (id == NULL)
317		return 0;
318
319	SELECT_MASK(drive, 1);
320	rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id, 1);
321	SELECT_MASK(drive, 0);
322
323	if (rc)
324		goto out_err;
325
326	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];
329	drive->id[ATA_ID_CFA_MODES]   = id[ATA_ID_CFA_MODES];
330	/* anything more ? */
331
332	kfree(id);
333
334	return 1;
335out_err:
336	if (rc == 2)
337		printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__);
338	kfree(id);
339	return 0;
340}
341
342int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
343{
344	ide_hwif_t *hwif = drive->hwif;
345	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
346	struct ide_taskfile tf;
347	u16 *id = drive->id, i;
348	int error = 0;
349	u8 stat;
350
351#ifdef CONFIG_BLK_DEV_IDEDMA
352	if (hwif->dma_ops)	/* check if host supports DMA */
353		hwif->dma_ops->dma_host_set(drive, 0);
354#endif
355
356	/* Skip setting PIO flow-control modes on pre-EIDE drives */
357	if ((speed & 0xf8) == XFER_PIO_0 && ata_id_has_iordy(drive->id) == 0)
358		goto skip;
359
360	/*
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	 */
366
367	udelay(1);
368	tp_ops->dev_select(drive);
369	SELECT_MASK(drive, 1);
370	udelay(1);
371	tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
372
373	memset(&tf, 0, sizeof(tf));
374	tf.feature = SETFEATURES_XFER;
375	tf.nsect   = speed;
376
377	tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE | IDE_VALID_NSECT);
378
379	tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);
380
381	if (drive->dev_flags & IDE_DFLAG_NIEN_QUIRK)
382		tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
383
384	error = __ide_wait_stat(drive, drive->ready_stat,
385				ATA_BUSY | ATA_DRQ | ATA_ERR,
386				WAIT_CMD, &stat);
387
388	SELECT_MASK(drive, 0);
389
390	if (error) {
391		(void) ide_dump_status(drive, "set_drive_speed_status", stat);
392		return error;
393	}
394
395	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;
399		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;
403
404 skip:
405#ifdef CONFIG_BLK_DEV_IDEDMA
406	if (speed >= XFER_SW_DMA_0 && (drive->dev_flags & IDE_DFLAG_USING_DMA))
407		hwif->dma_ops->dma_host_set(drive, 1);
408	else if (hwif->dma_ops)	/* check if host supports DMA */
409		ide_dma_off_quietly(drive);
410#endif
411
412	if (speed >= XFER_UDMA_0) {
413		i = 1 << (speed - XFER_UDMA_0);
414		id[ATA_ID_UDMA_MODES] |= (i << 8 | i);
415	} 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;
418	} 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);
424	} 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;
427	}
428
429	if (!drive->init_speed)
430		drive->init_speed = speed;
431	drive->current_speed = speed;
432	return error;
433}
434
435/*
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 */
444void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
445		       unsigned int timeout)
446{
447	ide_hwif_t *hwif = drive->hwif;
448
449	BUG_ON(hwif->handler);
450	hwif->handler		= handler;
451	hwif->timer.expires	= jiffies + timeout;
452	hwif->req_gen_timer	= hwif->req_gen;
453	add_timer(&hwif->timer);
454}
455
456void ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
457		     unsigned int timeout)
458{
459	ide_hwif_t *hwif = drive->hwif;
460	unsigned long flags;
461
462	spin_lock_irqsave(&hwif->lock, flags);
463	__ide_set_handler(drive, handler, timeout);
464	spin_unlock_irqrestore(&hwif->lock, flags);
465}
466EXPORT_SYMBOL(ide_set_handler);
467
468/**
469 *	ide_execute_command	-	execute an IDE command
470 *	@drive: IDE drive to issue the command against
471 *	@cmd: command
472 *	@handler: handler for next phase
473 *	@timeout: timeout for command
474 *
475 *	Helper function to issue an IDE command. This handles the
476 *	atomicity requirements, command timing and ensures that the
477 *	handler and IRQ setup do not race. All IDE command kick off
478 *	should go via this function or do equivalent locking.
479 */
480
481void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd,
482			 ide_handler_t *handler, unsigned timeout)
483{
484	ide_hwif_t *hwif = drive->hwif;
485	unsigned long flags;
486
487	spin_lock_irqsave(&hwif->lock, flags);
488	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);
493	/*
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	 */
499	ndelay(400);
500	spin_unlock_irqrestore(&hwif->lock, flags);
501}
502
503/*
504 * ide_wait_not_busy() waits for the currently selected device on the hwif
505 * to report a non-busy status, see comments in ide_probe_port().
506 */
507int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
508{
509	u8 stat = 0;
510
511	while (timeout--) {
512		/*
513		 * Turn this into a schedule() sleep once I'm sure
514		 * about locking issues (2.5 work ?).
515		 */
516		mdelay(1);
517		stat = hwif->tp_ops->read_status(hwif);
518		if ((stat & ATA_BUSY) == 0)
519			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;
527		touch_softlockup_watchdog();
528		touch_nmi_watchdog();
529	}
530	return -EBUSY;
531}
532