2 * Promise TX2/TX4/TX2000/133 IDE driver
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
10 * linux/drivers/ide/pdc202xx.c Version 0.35 Mar. 30, 2002
11 * Copyright (C) 1998-2002 Andre Hedrick <andre@linux-ide.org>
12 * Copyright (C) 2005-2007 MontaVista Software, Inc.
13 * Portions Copyright (C) 1999 Promise Technology, Inc.
14 * Author: Frank Tiernan (frankt@promise.com)
15 * Released under terms of General Public License
18 #include <linux/module.h>
19 #include <linux/types.h>
20 #include <linux/kernel.h>
21 #include <linux/delay.h>
22 #include <linux/hdreg.h>
23 #include <linux/pci.h>
24 #include <linux/init.h>
25 #include <linux/ide.h>
29 #ifdef CONFIG_PPC_PMAC
31 #include <asm/pci-bridge.h>
34 #define DRV_NAME "pdc202xx_new"
39 #define DBG(fmt, args...) printk("%s: " fmt, __func__, ## args)
41 #define DBG(fmt, args...)
44 static const char *pdc_quirk_drives[] = {
45 "QUANTUM FIREBALLlct08 08",
46 "QUANTUM FIREBALLP KA6.4",
47 "QUANTUM FIREBALLP KA9.1",
48 "QUANTUM FIREBALLP LM20.4",
49 "QUANTUM FIREBALLP KX13.6",
50 "QUANTUM FIREBALLP KX20.5",
51 "QUANTUM FIREBALLP KX27.3",
52 "QUANTUM FIREBALLP LM20.5",
56 static u8 max_dma_rate(struct pci_dev *pdev)
60 switch(pdev->device) {
61 case PCI_DEVICE_ID_PROMISE_20277:
62 case PCI_DEVICE_ID_PROMISE_20276:
63 case PCI_DEVICE_ID_PROMISE_20275:
64 case PCI_DEVICE_ID_PROMISE_20271:
65 case PCI_DEVICE_ID_PROMISE_20269:
68 case PCI_DEVICE_ID_PROMISE_20270:
69 case PCI_DEVICE_ID_PROMISE_20268:
80 * get_indexed_reg - Get indexed register
81 * @hwif: for the port address
82 * @index: index of the indexed register
84 static u8 get_indexed_reg(ide_hwif_t *hwif, u8 index)
88 outb(index, hwif->dma_base + 1);
89 value = inb(hwif->dma_base + 3);
91 DBG("index[%02X] value[%02X]\n", index, value);
96 * set_indexed_reg - Set indexed register
97 * @hwif: for the port address
98 * @index: index of the indexed register
100 static void set_indexed_reg(ide_hwif_t *hwif, u8 index, u8 value)
102 outb(index, hwif->dma_base + 1);
103 outb(value, hwif->dma_base + 3);
104 DBG("index[%02X] value[%02X]\n", index, value);
108 * ATA Timing Tables based on 133 MHz PLL output clock.
110 * If the PLL outputs 100 MHz clock, the ASIC hardware will set
111 * the timing registers automatically when "set features" command is
112 * issued to the device. However, if the PLL output clock is 133 MHz,
113 * the following tables must be used.
115 static struct pio_timing {
116 u8 reg0c, reg0d, reg13;
118 { 0xfb, 0x2b, 0xac }, /* PIO mode 0, IORDY off, Prefetch off */
119 { 0x46, 0x29, 0xa4 }, /* PIO mode 1, IORDY off, Prefetch off */
120 { 0x23, 0x26, 0x64 }, /* PIO mode 2, IORDY off, Prefetch off */
121 { 0x27, 0x0d, 0x35 }, /* PIO mode 3, IORDY on, Prefetch off */
122 { 0x23, 0x09, 0x25 }, /* PIO mode 4, IORDY on, Prefetch off */
125 static struct mwdma_timing {
127 } mwdma_timings [] = {
128 { 0xdf, 0x5f }, /* MWDMA mode 0 */
129 { 0x6b, 0x27 }, /* MWDMA mode 1 */
130 { 0x69, 0x25 }, /* MWDMA mode 2 */
133 static struct udma_timing {
134 u8 reg10, reg11, reg12;
135 } udma_timings [] = {
136 { 0x4a, 0x0f, 0xd5 }, /* UDMA mode 0 */
137 { 0x3a, 0x0a, 0xd0 }, /* UDMA mode 1 */
138 { 0x2a, 0x07, 0xcd }, /* UDMA mode 2 */
139 { 0x1a, 0x05, 0xcd }, /* UDMA mode 3 */
140 { 0x1a, 0x03, 0xcd }, /* UDMA mode 4 */
141 { 0x1a, 0x02, 0xcb }, /* UDMA mode 5 */
142 { 0x1a, 0x01, 0xcb }, /* UDMA mode 6 */
145 static void pdcnew_set_dma_mode(ide_drive_t *drive, const u8 speed)
147 ide_hwif_t *hwif = HWIF(drive);
148 struct pci_dev *dev = to_pci_dev(hwif->dev);
149 u8 adj = (drive->dn & 1) ? 0x08 : 0x00;
152 * IDE core issues SETFEATURES_XFER to the drive first (thanks to
153 * IDE_HFLAG_POST_SET_MODE in ->host_flags). PDC202xx hardware will
154 * automatically set the timing registers based on 100 MHz PLL output.
156 * As we set up the PLL to output 133 MHz for UltraDMA/133 capable
157 * chips, we must override the default register settings...
159 if (max_dma_rate(dev) == 4) {
160 u8 mode = speed & 0x07;
162 if (speed >= XFER_UDMA_0) {
163 set_indexed_reg(hwif, 0x10 + adj,
164 udma_timings[mode].reg10);
165 set_indexed_reg(hwif, 0x11 + adj,
166 udma_timings[mode].reg11);
167 set_indexed_reg(hwif, 0x12 + adj,
168 udma_timings[mode].reg12);
170 set_indexed_reg(hwif, 0x0e + adj,
171 mwdma_timings[mode].reg0e);
172 set_indexed_reg(hwif, 0x0f + adj,
173 mwdma_timings[mode].reg0f);
175 } else if (speed == XFER_UDMA_2) {
176 /* Set tHOLD bit to 0 if using UDMA mode 2 */
177 u8 tmp = get_indexed_reg(hwif, 0x10 + adj);
179 set_indexed_reg(hwif, 0x10 + adj, tmp & 0x7f);
183 static void pdcnew_set_pio_mode(ide_drive_t *drive, const u8 pio)
185 ide_hwif_t *hwif = drive->hwif;
186 struct pci_dev *dev = to_pci_dev(hwif->dev);
187 u8 adj = (drive->dn & 1) ? 0x08 : 0x00;
189 if (max_dma_rate(dev) == 4) {
190 set_indexed_reg(hwif, 0x0c + adj, pio_timings[pio].reg0c);
191 set_indexed_reg(hwif, 0x0d + adj, pio_timings[pio].reg0d);
192 set_indexed_reg(hwif, 0x13 + adj, pio_timings[pio].reg13);
196 static u8 __devinit pdcnew_cable_detect(ide_hwif_t *hwif)
198 if (get_indexed_reg(hwif, 0x0b) & 0x04)
199 return ATA_CBL_PATA40;
201 return ATA_CBL_PATA80;
204 static void pdcnew_quirkproc(ide_drive_t *drive)
206 const char **list, *model = drive->id->model;
208 for (list = pdc_quirk_drives; *list != NULL; list++)
209 if (strstr(model, *list) != NULL) {
210 drive->quirk_list = 2;
214 drive->quirk_list = 0;
217 static void pdcnew_reset(ide_drive_t *drive)
220 * Deleted this because it is redundant from the caller.
222 printk(KERN_WARNING "pdc202xx_new: %s channel reset.\n",
223 HWIF(drive)->channel ? "Secondary" : "Primary");
227 * read_counter - Read the byte count registers
228 * @dma_base: for the port address
230 static long __devinit read_counter(u32 dma_base)
232 u32 pri_dma_base = dma_base, sec_dma_base = dma_base + 0x08;
233 u8 cnt0, cnt1, cnt2, cnt3;
234 long count = 0, last;
240 /* Read the current count */
241 outb(0x20, pri_dma_base + 0x01);
242 cnt0 = inb(pri_dma_base + 0x03);
243 outb(0x21, pri_dma_base + 0x01);
244 cnt1 = inb(pri_dma_base + 0x03);
245 outb(0x20, sec_dma_base + 0x01);
246 cnt2 = inb(sec_dma_base + 0x03);
247 outb(0x21, sec_dma_base + 0x01);
248 cnt3 = inb(sec_dma_base + 0x03);
250 count = (cnt3 << 23) | (cnt2 << 15) | (cnt1 << 8) | cnt0;
253 * The 30-bit decrementing counter is read in 4 pieces.
254 * Incorrect value may be read when the most significant bytes
257 } while (retry-- && (((last ^ count) & 0x3fff8000) || last < count));
259 DBG("cnt0[%02X] cnt1[%02X] cnt2[%02X] cnt3[%02X]\n",
260 cnt0, cnt1, cnt2, cnt3);
266 * detect_pll_input_clock - Detect the PLL input clock in Hz.
267 * @dma_base: for the port address
268 * E.g. 16949000 on 33 MHz PCI bus, i.e. half of the PCI clock.
270 static long __devinit detect_pll_input_clock(unsigned long dma_base)
272 struct timeval start_time, end_time;
273 long start_count, end_count;
274 long pll_input, usec_elapsed;
277 start_count = read_counter(dma_base);
278 do_gettimeofday(&start_time);
280 /* Start the test mode */
281 outb(0x01, dma_base + 0x01);
282 scr1 = inb(dma_base + 0x03);
283 DBG("scr1[%02X]\n", scr1);
284 outb(scr1 | 0x40, dma_base + 0x03);
286 /* Let the counter run for 10 ms. */
289 end_count = read_counter(dma_base);
290 do_gettimeofday(&end_time);
292 /* Stop the test mode */
293 outb(0x01, dma_base + 0x01);
294 scr1 = inb(dma_base + 0x03);
295 DBG("scr1[%02X]\n", scr1);
296 outb(scr1 & ~0x40, dma_base + 0x03);
299 * Calculate the input clock in Hz
300 * (the clock counter is 30 bit wide and counts down)
302 usec_elapsed = (end_time.tv_sec - start_time.tv_sec) * 1000000 +
303 (end_time.tv_usec - start_time.tv_usec);
304 pll_input = ((start_count - end_count) & 0x3fffffff) / 10 *
305 (10000000 / usec_elapsed);
307 DBG("start[%ld] end[%ld]\n", start_count, end_count);
312 #ifdef CONFIG_PPC_PMAC
313 static void __devinit apple_kiwi_init(struct pci_dev *pdev)
315 struct device_node *np = pci_device_to_OF_node(pdev);
318 if (np == NULL || !of_device_is_compatible(np, "kiwi-root"))
321 if (pdev->revision >= 0x03) {
322 /* Setup chip magic config stuff (from darwin) */
323 pci_read_config_byte (pdev, 0x40, &conf);
324 pci_write_config_byte(pdev, 0x40, (conf | 0x01));
327 #endif /* CONFIG_PPC_PMAC */
329 static unsigned int __devinit init_chipset_pdcnew(struct pci_dev *dev, const char *name)
331 unsigned long dma_base = pci_resource_start(dev, 4);
332 unsigned long sec_dma_base = dma_base + 0x08;
333 long pll_input, pll_output, ratio;
335 u8 pll_ctl0, pll_ctl1;
340 #ifdef CONFIG_PPC_PMAC
341 apple_kiwi_init(dev);
344 /* Calculate the required PLL output frequency */
345 switch(max_dma_rate(dev)) {
346 case 4: /* it's 133 MHz for Ultra133 chips */
347 pll_output = 133333333;
349 case 3: /* and 100 MHz for Ultra100 chips */
351 pll_output = 100000000;
356 * Detect PLL input clock.
357 * On some systems, where PCI bus is running at non-standard clock rate
358 * (e.g. 25 or 40 MHz), we have to adjust the cycle time.
359 * PDC20268 and newer chips employ PLL circuit to help correct timing
362 pll_input = detect_pll_input_clock(dma_base);
363 printk(KERN_INFO "%s %s: PLL input clock is %ld kHz\n",
364 name, pci_name(dev), pll_input / 1000);
367 if (unlikely(pll_input < 5000000L || pll_input > 70000000L)) {
368 printk(KERN_ERR "%s %s: Bad PLL input clock %ld Hz, giving up!"
369 "\n", name, pci_name(dev), pll_input);
374 DBG("pll_output is %ld Hz\n", pll_output);
376 /* Show the current clock value of PLL control register
377 * (maybe already configured by the BIOS)
379 outb(0x02, sec_dma_base + 0x01);
380 pll_ctl0 = inb(sec_dma_base + 0x03);
381 outb(0x03, sec_dma_base + 0x01);
382 pll_ctl1 = inb(sec_dma_base + 0x03);
384 DBG("pll_ctl[%02X][%02X]\n", pll_ctl0, pll_ctl1);
388 * Calculate the ratio of F, R and NO
389 * POUT = (F + 2) / (( R + 2) * NO)
391 ratio = pll_output / (pll_input / 1000);
392 if (ratio < 8600L) { /* 8.6x */
393 /* Using NO = 0x01, R = 0x0d */
395 } else if (ratio < 12900L) { /* 12.9x */
396 /* Using NO = 0x01, R = 0x08 */
398 } else if (ratio < 16100L) { /* 16.1x */
399 /* Using NO = 0x01, R = 0x06 */
401 } else if (ratio < 64000L) { /* 64x */
405 printk(KERN_ERR "%s %s: Bad ratio %ld, giving up!\n",
406 name, pci_name(dev), ratio);
410 f = (ratio * (r + 2)) / 1000 - 2;
412 DBG("F[%d] R[%d] ratio*1000[%ld]\n", f, r, ratio);
414 if (unlikely(f < 0 || f > 127)) {
416 printk(KERN_ERR "%s %s: F[%d] invalid!\n",
417 name, pci_name(dev), f);
424 DBG("Writing pll_ctl[%02X][%02X]\n", pll_ctl0, pll_ctl1);
426 outb(0x02, sec_dma_base + 0x01);
427 outb(pll_ctl0, sec_dma_base + 0x03);
428 outb(0x03, sec_dma_base + 0x01);
429 outb(pll_ctl1, sec_dma_base + 0x03);
431 /* Wait the PLL circuit to be stable */
436 * Show the current clock value of PLL control register
438 outb(0x02, sec_dma_base + 0x01);
439 pll_ctl0 = inb(sec_dma_base + 0x03);
440 outb(0x03, sec_dma_base + 0x01);
441 pll_ctl1 = inb(sec_dma_base + 0x03);
443 DBG("pll_ctl[%02X][%02X]\n", pll_ctl0, pll_ctl1);
450 static struct pci_dev * __devinit pdc20270_get_dev2(struct pci_dev *dev)
452 struct pci_dev *dev2;
454 dev2 = pci_get_slot(dev->bus, PCI_DEVFN(PCI_SLOT(dev->devfn) + 1,
455 PCI_FUNC(dev->devfn)));
458 dev2->vendor == dev->vendor &&
459 dev2->device == dev->device) {
461 if (dev2->irq != dev->irq) {
462 dev2->irq = dev->irq;
463 printk(KERN_INFO DRV_NAME " %s: PCI config space "
464 "interrupt fixed\n", pci_name(dev));
473 static const struct ide_port_ops pdcnew_port_ops = {
474 .set_pio_mode = pdcnew_set_pio_mode,
475 .set_dma_mode = pdcnew_set_dma_mode,
476 .quirkproc = pdcnew_quirkproc,
477 .resetproc = pdcnew_reset,
478 .cable_detect = pdcnew_cable_detect,
481 #define DECLARE_PDCNEW_DEV(udma) \
484 .init_chipset = init_chipset_pdcnew, \
485 .port_ops = &pdcnew_port_ops, \
486 .host_flags = IDE_HFLAG_POST_SET_MODE | \
487 IDE_HFLAG_ERROR_STOPS_FIFO | \
488 IDE_HFLAG_OFF_BOARD, \
489 .pio_mask = ATA_PIO4, \
490 .mwdma_mask = ATA_MWDMA2, \
494 static const struct ide_port_info pdcnew_chipsets[] __devinitdata = {
495 /* 0: PDC202{68,70} */ DECLARE_PDCNEW_DEV(ATA_UDMA5),
496 /* 1: PDC202{69,71,75,76,77} */ DECLARE_PDCNEW_DEV(ATA_UDMA6),
500 * pdc202new_init_one - called when a pdc202xx is found
501 * @dev: the pdc202new device
502 * @id: the matching pci id
504 * Called when the PCI registration layer (or the IDE initialization)
505 * finds a device matching our IDE device tables.
508 static int __devinit pdc202new_init_one(struct pci_dev *dev, const struct pci_device_id *id)
510 const struct ide_port_info *d = &pdcnew_chipsets[id->driver_data];
511 struct pci_dev *bridge = dev->bus->self;
513 if (dev->device == PCI_DEVICE_ID_PROMISE_20270 && bridge &&
514 bridge->vendor == PCI_VENDOR_ID_DEC &&
515 bridge->device == PCI_DEVICE_ID_DEC_21150) {
516 struct pci_dev *dev2;
518 if (PCI_SLOT(dev->devfn) & 2)
521 dev2 = pdc20270_get_dev2(dev);
524 int ret = ide_pci_init_two(dev, dev2, d, NULL);
531 if (dev->device == PCI_DEVICE_ID_PROMISE_20276 && bridge &&
532 bridge->vendor == PCI_VENDOR_ID_INTEL &&
533 (bridge->device == PCI_DEVICE_ID_INTEL_I960 ||
534 bridge->device == PCI_DEVICE_ID_INTEL_I960RM)) {
535 printk(KERN_INFO DRV_NAME " %s: attached to I2O RAID controller,"
536 " skipping\n", pci_name(dev));
540 return ide_pci_init_one(dev, d, NULL);
543 static void __devexit pdc202new_remove(struct pci_dev *dev)
545 struct ide_host *host = pci_get_drvdata(dev);
546 struct pci_dev *dev2 = host->dev[1] ? to_pci_dev(host->dev[1]) : NULL;
552 static const struct pci_device_id pdc202new_pci_tbl[] = {
553 { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20268), 0 },
554 { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20269), 1 },
555 { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20270), 0 },
556 { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20271), 1 },
557 { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20275), 1 },
558 { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20276), 1 },
559 { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20277), 1 },
562 MODULE_DEVICE_TABLE(pci, pdc202new_pci_tbl);
564 static struct pci_driver driver = {
565 .name = "Promise_IDE",
566 .id_table = pdc202new_pci_tbl,
567 .probe = pdc202new_init_one,
568 .remove = pdc202new_remove,
571 static int __init pdc202new_ide_init(void)
573 return ide_pci_register_driver(&driver);
576 static void __exit pdc202new_ide_exit(void)
578 pci_unregister_driver(&driver);
581 module_init(pdc202new_ide_init);
582 module_exit(pdc202new_ide_exit);
584 MODULE_AUTHOR("Andre Hedrick, Frank Tiernan");
585 MODULE_DESCRIPTION("PCI driver module for Promise PDC20268 and higher");
586 MODULE_LICENSE("GPL");