Blame view
drivers/ata/pata_serverworks.c
13.1 KB
669a5db41
|
1 |
/* |
a0fcdc025
|
2 |
* pata_serverworks.c - Serverworks PATA for new ATA layer |
669a5db41
|
3 |
* (C) 2005 Red Hat Inc |
8490377ac
|
4 |
* (C) 2010 Bartlomiej Zolnierkiewicz |
669a5db41
|
5 6 7 8 |
* * based upon * * serverworks.c |
85cd7251b
|
9 |
* |
669a5db41
|
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
* Copyright (C) 1998-2000 Michel Aubry * Copyright (C) 1998-2000 Andrzej Krzysztofowicz * Copyright (C) 1998-2000 Andre Hedrick <andre@linux-ide.org> * Portions copyright (c) 2001 Sun Microsystems * * * RCC/ServerWorks IDE driver for Linux * * OSB4: `Open South Bridge' IDE Interface (fn 1) * supports UDMA mode 2 (33 MB/s) * * CSB5: `Champion South Bridge' IDE Interface (fn 1) * all revisions support UDMA mode 4 (66 MB/s) * revision A2.0 and up support UDMA mode 5 (100 MB/s) * * *** The CSB5 does not provide ANY register *** * *** to detect 80-conductor cable presence. *** * * CSB6: `Champion South Bridge' IDE Interface (optional: third channel) * * Documentation: * Available under NDA only. Errata info very hard to get. */ #include <linux/kernel.h> #include <linux/module.h> #include <linux/pci.h> |
669a5db41
|
37 38 39 40 41 42 |
#include <linux/blkdev.h> #include <linux/delay.h> #include <scsi/scsi_host.h> #include <linux/libata.h> #define DRV_NAME "pata_serverworks" |
0f069788c
|
43 |
#define DRV_VERSION "0.4.3" |
669a5db41
|
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
#define SVWKS_CSB5_REVISION_NEW 0x92 /* min PCI_REVISION_ID for UDMA5 (A2.0) */ #define SVWKS_CSB6_REVISION 0xa0 /* min PCI_REVISION_ID for UDMA4 (A1.0) */ /* Seagate Barracuda ATA IV Family drives in UDMA mode 5 * can overrun their FIFOs when used with the CSB5 */ static const char *csb_bad_ata100[] = { "ST320011A", "ST340016A", "ST360021A", "ST380021A", NULL }; /** |
e69a70d95
|
60 |
* oem_cable - Dell/Sun serverworks cable detection |
669a5db41
|
61 62 |
* @ap: ATA port to do cable detect * |
e69a70d95
|
63 64 |
* Dell PowerEdge and Sun Cobalt 'Alpine' hide the 40/80 pin select * for their interfaces in the top two bits of the subsystem ID. |
669a5db41
|
65 |
*/ |
85cd7251b
|
66 |
|
e69a70d95
|
67 |
static int oem_cable(struct ata_port *ap) |
5860a5545
|
68 |
{ |
669a5db41
|
69 |
struct pci_dev *pdev = to_pci_dev(ap->host->dev); |
85cd7251b
|
70 |
|
669a5db41
|
71 72 73 74 |
if (pdev->subsystem_device & (1 << (ap->port_no + 14))) return ATA_CBL_PATA80; return ATA_CBL_PATA40; } |
669a5db41
|
75 76 77 78 79 |
struct sv_cable_table { int device; int subvendor; int (*cable_detect)(struct ata_port *ap); }; |
669a5db41
|
80 |
static struct sv_cable_table cable_detect[] = { |
e69a70d95
|
81 82 83 |
{ PCI_DEVICE_ID_SERVERWORKS_CSB5IDE, PCI_VENDOR_ID_DELL, oem_cable }, { PCI_DEVICE_ID_SERVERWORKS_CSB6IDE, PCI_VENDOR_ID_DELL, oem_cable }, { PCI_DEVICE_ID_SERVERWORKS_CSB5IDE, PCI_VENDOR_ID_SUN, oem_cable }, |
5860a5545
|
84 85 86 87 88 |
{ PCI_DEVICE_ID_SERVERWORKS_OSB4IDE, PCI_ANY_ID, ata_cable_40wire }, { PCI_DEVICE_ID_SERVERWORKS_CSB5IDE, PCI_ANY_ID, ata_cable_unknown }, { PCI_DEVICE_ID_SERVERWORKS_CSB6IDE, PCI_ANY_ID, ata_cable_unknown }, { PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2, PCI_ANY_ID, ata_cable_unknown }, { PCI_DEVICE_ID_SERVERWORKS_HT1000IDE, PCI_ANY_ID, ata_cable_unknown }, |
669a5db41
|
89 90 91 92 |
{ } }; /** |
a0fcdc025
|
93 |
* serverworks_cable_detect - cable detection |
669a5db41
|
94 95 |
* @ap: ATA port * |
85cd7251b
|
96 |
* Perform cable detection according to the device and subvendor |
669a5db41
|
97 98 |
* identifications */ |
85cd7251b
|
99 |
|
d4b2bab4f
|
100 101 |
static int serverworks_cable_detect(struct ata_port *ap) { |
669a5db41
|
102 103 104 105 |
struct pci_dev *pdev = to_pci_dev(ap->host->dev); struct sv_cable_table *cb = cable_detect; while(cb->device) { |
85cd7251b
|
106 |
if (cb->device == pdev->device && |
669a5db41
|
107 108 |
(cb->subvendor == pdev->subsystem_vendor || cb->subvendor == PCI_ANY_ID)) { |
a0fcdc025
|
109 |
return cb->cable_detect(ap); |
669a5db41
|
110 111 112 113 114 115 116 |
} cb++; } BUG(); return -1; /* kill compiler warning */ } |
669a5db41
|
117 118 119 120 121 122 123 |
/** * serverworks_is_csb - Check for CSB or OSB * @pdev: PCI device to check * * Returns true if the device being checked is known to be a CSB * series device. */ |
85cd7251b
|
124 |
|
669a5db41
|
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 |
static u8 serverworks_is_csb(struct pci_dev *pdev) { switch (pdev->device) { case PCI_DEVICE_ID_SERVERWORKS_CSB5IDE: case PCI_DEVICE_ID_SERVERWORKS_CSB6IDE: case PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2: case PCI_DEVICE_ID_SERVERWORKS_HT1000IDE: return 1; default: break; } return 0; } /** * serverworks_osb4_filter - mode selection filter |
669a5db41
|
141 |
* @adev: ATA device |
a76b62ca7
|
142 |
* @mask: Mask of proposed modes |
669a5db41
|
143 144 145 146 147 |
* * Filter the offered modes for the device to apply controller * specific rules. OSB4 requires no UDMA for disks due to a FIFO * bug we hit. */ |
85cd7251b
|
148 |
|
a76b62ca7
|
149 |
static unsigned long serverworks_osb4_filter(struct ata_device *adev, unsigned long mask) |
669a5db41
|
150 151 152 |
{ if (adev->class == ATA_DEV_ATA) mask &= ~ATA_MASK_UDMA; |
c7087652e
|
153 |
return mask; |
669a5db41
|
154 155 156 157 158 |
} /** * serverworks_csb_filter - mode selection filter |
669a5db41
|
159 |
* @adev: ATA device |
a76b62ca7
|
160 |
* @mask: Mask of proposed modes |
669a5db41
|
161 162 163 |
* * Check the blacklist and disable UDMA5 if matched */ |
a76b62ca7
|
164 |
static unsigned long serverworks_csb_filter(struct ata_device *adev, unsigned long mask) |
669a5db41
|
165 166 |
{ const char *p; |
8bfa79fcb
|
167 168 |
char model_num[ATA_ID_PROD_LEN + 1]; int i; |
669a5db41
|
169 |
|
85cd7251b
|
170 |
/* Disk, UDMA */ |
669a5db41
|
171 |
if (adev->class != ATA_DEV_ATA) |
c7087652e
|
172 |
return mask; |
669a5db41
|
173 174 |
/* Actually do need to check */ |
8bfa79fcb
|
175 |
ata_id_c_string(adev->id, model_num, ATA_ID_PROD, sizeof(model_num)); |
85cd7251b
|
176 |
|
8bfa79fcb
|
177 178 |
for (i = 0; (p = csb_bad_ata100[i]) != NULL; i++) { if (!strcmp(p, model_num)) |
6ddd68615
|
179 |
mask &= ~(0xE0 << ATA_SHIFT_UDMA); |
669a5db41
|
180 |
} |
c7087652e
|
181 |
return mask; |
669a5db41
|
182 |
} |
669a5db41
|
183 184 185 186 187 188 189 190 191 192 193 |
/** * serverworks_set_piomode - set initial PIO mode data * @ap: ATA interface * @adev: ATA device * * Program the OSB4/CSB5 timing registers for PIO. The PIO register * load is done as a simple lookup. */ static void serverworks_set_piomode(struct ata_port *ap, struct ata_device *adev) { static const u8 pio_mode[] = { 0x5d, 0x47, 0x34, 0x22, 0x20 }; |
0f069788c
|
194 |
int offset = 1 + 2 * ap->port_no - adev->devno; |
669a5db41
|
195 196 197 198 199 200 |
int devbits = (2 * ap->port_no + adev->devno) * 4; u16 csb5_pio; struct pci_dev *pdev = to_pci_dev(ap->host->dev); int pio = adev->pio_mode - XFER_PIO_0; pci_write_config_byte(pdev, 0x40 + offset, pio_mode[pio]); |
85cd7251b
|
201 |
|
669a5db41
|
202 203 204 205 206 |
/* The OSB4 just requires the timing but the CSB series want the mode number as well */ if (serverworks_is_csb(pdev)) { pci_read_config_word(pdev, 0x4A, &csb5_pio); csb5_pio &= ~(0x0F << devbits); |
8490377ac
|
207 |
pci_write_config_word(pdev, 0x4A, csb5_pio | (pio << devbits)); |
669a5db41
|
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 |
} } /** * serverworks_set_dmamode - set initial DMA mode data * @ap: ATA interface * @adev: ATA device * * Program the MWDMA/UDMA modes for the serverworks OSB4/CSB5 * chipset. The MWDMA mode values are pulled from a lookup table * while the chipset uses mode number for UDMA. */ static void serverworks_set_dmamode(struct ata_port *ap, struct ata_device *adev) { static const u8 dma_mode[] = { 0x77, 0x21, 0x20 }; int offset = 1 + 2 * ap->port_no - adev->devno; |
36beb8239
|
225 |
int devbits = 2 * ap->port_no + adev->devno; |
669a5db41
|
226 227 228 229 230 |
u8 ultra; u8 ultra_cfg; struct pci_dev *pdev = to_pci_dev(ap->host->dev); pci_read_config_byte(pdev, 0x54, &ultra_cfg); |
36beb8239
|
231 232 |
pci_read_config_byte(pdev, 0x56 + ap->port_no, &ultra); ultra &= ~(0x0F << (adev->devno * 4)); |
669a5db41
|
233 234 235 |
if (adev->dma_mode >= XFER_UDMA_0) { pci_write_config_byte(pdev, 0x44 + offset, 0x20); |
669a5db41
|
236 |
ultra |= (adev->dma_mode - XFER_UDMA_0) |
36beb8239
|
237 |
<< (adev->devno * 4); |
669a5db41
|
238 239 |
ultra_cfg |= (1 << devbits); } else { |
85cd7251b
|
240 |
pci_write_config_byte(pdev, 0x44 + offset, |
669a5db41
|
241 242 243 |
dma_mode[adev->dma_mode - XFER_MW_DMA_0]); ultra_cfg &= ~(1 << devbits); } |
36beb8239
|
244 |
pci_write_config_byte(pdev, 0x56 + ap->port_no, ultra); |
669a5db41
|
245 246 |
pci_write_config_byte(pdev, 0x54, ultra_cfg); } |
37017ac68
|
247 248 249 250 251 252 |
static struct scsi_host_template serverworks_osb4_sht = { ATA_BMDMA_SHT(DRV_NAME), .sg_tablesize = LIBATA_DUMB_MAX_PRD, }; static struct scsi_host_template serverworks_csb_sht = { |
68d1d07b5
|
253 |
ATA_BMDMA_SHT(DRV_NAME), |
669a5db41
|
254 255 256 |
}; static struct ata_port_operations serverworks_osb4_port_ops = { |
029cfd6b7
|
257 |
.inherits = &ata_bmdma_port_ops, |
37017ac68
|
258 |
.qc_prep = ata_bmdma_dumb_qc_prep, |
029cfd6b7
|
259 260 |
.cable_detect = serverworks_cable_detect, .mode_filter = serverworks_osb4_filter, |
669a5db41
|
261 262 |
.set_piomode = serverworks_set_piomode, .set_dmamode = serverworks_set_dmamode, |
85cd7251b
|
263 |
}; |
669a5db41
|
264 265 |
static struct ata_port_operations serverworks_csb_port_ops = { |
029cfd6b7
|
266 |
.inherits = &serverworks_osb4_port_ops, |
37017ac68
|
267 |
.qc_prep = ata_bmdma_qc_prep, |
669a5db41
|
268 |
.mode_filter = serverworks_csb_filter, |
85cd7251b
|
269 |
}; |
669a5db41
|
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 |
static int serverworks_fixup_osb4(struct pci_dev *pdev) { u32 reg; struct pci_dev *isa_dev = pci_get_device(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_OSB4, NULL); if (isa_dev) { pci_read_config_dword(isa_dev, 0x64, ®); reg &= ~0x00002000; /* disable 600ns interrupt mask */ if (!(reg & 0x00004000)) printk(KERN_DEBUG DRV_NAME ": UDMA not BIOS enabled. "); reg |= 0x00004000; /* enable UDMA/33 support */ pci_write_config_dword(isa_dev, 0x64, reg); pci_dev_put(isa_dev); return 0; } |
cfcf9ee26
|
287 288 |
printk(KERN_WARNING DRV_NAME ": Unable to find bridge. "); |
669a5db41
|
289 290 291 292 293 |
return -ENODEV; } static int serverworks_fixup_csb(struct pci_dev *pdev) { |
669a5db41
|
294 |
u8 btr; |
85cd7251b
|
295 |
|
669a5db41
|
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 |
/* Third Channel Test */ if (!(PCI_FUNC(pdev->devfn) & 1)) { struct pci_dev * findev = NULL; u32 reg4c = 0; findev = pci_get_device(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB5, NULL); if (findev) { pci_read_config_dword(findev, 0x4C, ®4c); reg4c &= ~0x000007FF; reg4c |= 0x00000040; reg4c |= 0x00000020; pci_write_config_dword(findev, 0x4C, reg4c); pci_dev_put(findev); } } else { struct pci_dev * findev = NULL; u8 reg41 = 0; findev = pci_get_device(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6, NULL); if (findev) { pci_read_config_byte(findev, 0x41, ®41); reg41 &= ~0x40; pci_write_config_byte(findev, 0x41, reg41); pci_dev_put(findev); } } /* setup the UDMA Control register * * 1. clear bit 6 to enable DMA * 2. enable DMA modes with bits 0-1 * 00 : legacy * 01 : udma2 * 10 : udma2/udma4 * 11 : udma2/udma4/udma5 */ pci_read_config_byte(pdev, 0x5A, &btr); btr &= ~0x40; if (!(PCI_FUNC(pdev->devfn) & 1)) btr |= 0x2; else |
44c10138f
|
337 |
btr |= (pdev->revision >= SVWKS_CSB5_REVISION_NEW) ? 0x3 : 0x2; |
669a5db41
|
338 |
pci_write_config_byte(pdev, 0x5A, btr); |
85cd7251b
|
339 |
|
669a5db41
|
340 341 342 343 344 345 346 347 348 349 350 351 |
return btr; } static void serverworks_fixup_ht1000(struct pci_dev *pdev) { u8 btr; /* Setup HT1000 SouthBridge Controller - Single Channel Only */ pci_read_config_byte(pdev, 0x5A, &btr); btr &= ~0x40; btr |= 0x3; pci_write_config_byte(pdev, 0x5A, btr); } |
d912be2f3
|
352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 |
static int serverworks_fixup(struct pci_dev *pdev) { int rc = 0; /* Force master latency timer to 64 PCI clocks */ pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0x40); switch (pdev->device) { case PCI_DEVICE_ID_SERVERWORKS_OSB4IDE: rc = serverworks_fixup_osb4(pdev); break; case PCI_DEVICE_ID_SERVERWORKS_CSB5IDE: ata_pci_bmdma_clear_simplex(pdev); /* fall through */ case PCI_DEVICE_ID_SERVERWORKS_CSB6IDE: case PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2: rc = serverworks_fixup_csb(pdev); break; case PCI_DEVICE_ID_SERVERWORKS_HT1000IDE: serverworks_fixup_ht1000(pdev); break; } return rc; } |
669a5db41
|
377 378 379 |
static int serverworks_init_one(struct pci_dev *pdev, const struct pci_device_id *id) { |
1626aeb88
|
380 |
static const struct ata_port_info info[4] = { |
669a5db41
|
381 |
{ /* OSB4 */ |
1d2808fd3
|
382 |
.flags = ATA_FLAG_SLAVE_POSS, |
14bdef982
|
383 384 385 |
.pio_mask = ATA_PIO4, .mwdma_mask = ATA_MWDMA2, .udma_mask = ATA_UDMA2, |
669a5db41
|
386 387 |
.port_ops = &serverworks_osb4_port_ops }, { /* OSB4 no UDMA */ |
1d2808fd3
|
388 |
.flags = ATA_FLAG_SLAVE_POSS, |
14bdef982
|
389 390 391 |
.pio_mask = ATA_PIO4, .mwdma_mask = ATA_MWDMA2, /* No UDMA */ |
669a5db41
|
392 393 |
.port_ops = &serverworks_osb4_port_ops }, { /* CSB5 */ |
1d2808fd3
|
394 |
.flags = ATA_FLAG_SLAVE_POSS, |
14bdef982
|
395 396 |
.pio_mask = ATA_PIO4, .mwdma_mask = ATA_MWDMA2, |
bf6263a85
|
397 |
.udma_mask = ATA_UDMA4, |
669a5db41
|
398 399 |
.port_ops = &serverworks_csb_port_ops }, { /* CSB5 - later revisions*/ |
1d2808fd3
|
400 |
.flags = ATA_FLAG_SLAVE_POSS, |
14bdef982
|
401 402 |
.pio_mask = ATA_PIO4, .mwdma_mask = ATA_MWDMA2, |
bf6263a85
|
403 |
.udma_mask = ATA_UDMA5, |
669a5db41
|
404 405 406 |
.port_ops = &serverworks_csb_port_ops } }; |
1626aeb88
|
407 |
const struct ata_port_info *ppi[] = { &info[id->driver_data], NULL }; |
37017ac68
|
408 |
struct scsi_host_template *sht = &serverworks_csb_sht; |
f08048e94
|
409 410 411 412 413 |
int rc; rc = pcim_enable_device(pdev); if (rc) return rc; |
85cd7251b
|
414 |
|
d912be2f3
|
415 |
rc = serverworks_fixup(pdev); |
669a5db41
|
416 417 418 419 |
/* OSB4 : South Bridge and IDE */ if (pdev->device == PCI_DEVICE_ID_SERVERWORKS_OSB4IDE) { /* Select non UDMA capable OSB4 if we can't do fixups */ |
d912be2f3
|
420 |
if (rc < 0) |
1626aeb88
|
421 |
ppi[0] = &info[1]; |
37017ac68
|
422 |
sht = &serverworks_osb4_sht; |
669a5db41
|
423 424 425 426 427 |
} /* setup CSB5/CSB6 : South Bridge and IDE option RAID */ else if ((pdev->device == PCI_DEVICE_ID_SERVERWORKS_CSB5IDE) || (pdev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE) || (pdev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2)) { |
85cd7251b
|
428 |
|
669a5db41
|
429 430 |
/* If the returned btr is the newer revision then select the right info block */ |
d912be2f3
|
431 |
if (rc == 3) |
1626aeb88
|
432 |
ppi[0] = &info[3]; |
85cd7251b
|
433 |
|
669a5db41
|
434 435 |
/* Is this the 3rd channel CSB6 IDE ? */ if (pdev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2) |
1626aeb88
|
436 |
ppi[1] = &ata_dummy_port_info; |
669a5db41
|
437 |
} |
85cd7251b
|
438 |
|
37017ac68
|
439 |
return ata_pci_bmdma_init_one(pdev, ppi, sht, NULL, 0); |
669a5db41
|
440 |
} |
58eb8cd56
|
441 |
#ifdef CONFIG_PM_SLEEP |
38e0d56e6
|
442 443 |
static int serverworks_reinit_one(struct pci_dev *pdev) { |
0a86e1c85
|
444 |
struct ata_host *host = pci_get_drvdata(pdev); |
f08048e94
|
445 446 447 448 449 |
int rc; rc = ata_pci_device_do_resume(pdev); if (rc) return rc; |
d912be2f3
|
450 |
(void)serverworks_fixup(pdev); |
f08048e94
|
451 452 453 |
ata_host_resume(host); return 0; |
38e0d56e6
|
454 |
} |
438ac6d5e
|
455 |
#endif |
38e0d56e6
|
456 |
|
2d2744fc8
|
457 458 459 460 461 462 463 464 |
static const struct pci_device_id serverworks[] = { { PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_OSB4IDE), 0}, { PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB5IDE), 2}, { PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE), 2}, { PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2), 2}, { PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_HT1000IDE), 2}, { }, |
669a5db41
|
465 466 467 468 469 470 |
}; static struct pci_driver serverworks_pci_driver = { .name = DRV_NAME, .id_table = serverworks, .probe = serverworks_init_one, |
38e0d56e6
|
471 |
.remove = ata_pci_remove_one, |
58eb8cd56
|
472 |
#ifdef CONFIG_PM_SLEEP |
38e0d56e6
|
473 474 |
.suspend = ata_pci_device_suspend, .resume = serverworks_reinit_one, |
438ac6d5e
|
475 |
#endif |
669a5db41
|
476 |
}; |
2fc75da0c
|
477 |
module_pci_driver(serverworks_pci_driver); |
669a5db41
|
478 |
|
669a5db41
|
479 480 481 482 483 |
MODULE_AUTHOR("Alan Cox"); MODULE_DESCRIPTION("low-level driver for Serverworks OSB4/CSB5/CSB6"); MODULE_LICENSE("GPL"); MODULE_DEVICE_TABLE(pci, serverworks); MODULE_VERSION(DRV_VERSION); |