serverworks.c 13.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
/*
 * Copyright (C) 1998-2000 Michel Aubry
 * Copyright (C) 1998-2000 Andrzej Krzysztofowicz
 * Copyright (C) 1998-2000 Andre Hedrick <andre@linux-ide.org>
5
 * Copyright (C)      2007 Bartlomiej Zolnierkiewicz
Linus Torvalds's avatar
Linus Torvalds committed
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 * 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)
 *
23
24
25
 *   HT1000: AKA BCM5785 - Hypertransport Southbridge for Opteron systems. IDE
 *   controller same as the CSB6. Single channel ATA100 only.
 *
Linus Torvalds's avatar
Linus Torvalds committed
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 * Documentation:
 *	Available under NDA only. Errata info very hard to get.
 *
 */

#include <linux/types.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/hdreg.h>
#include <linux/ide.h>
#include <linux/init.h>

#include <asm/io.h>

#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 *svwks_bad_ata100[] = {
	"ST320011A",
	"ST340016A",
	"ST360021A",
	"ST380021A",
	NULL
};

static struct pci_dev *isa_dev;

static int check_in_drive_lists (ide_drive_t *drive, const char **list)
{
	while (*list)
		if (!strcmp(*list++, drive->id->model))
			return 1;
	return 0;
}

64
static u8 svwks_udma_filter(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
65
{
66
	struct pci_dev *dev = to_pci_dev(drive->hwif->dev);
67
	u8 mask = 0;
Linus Torvalds's avatar
Linus Torvalds committed
68

69
	if (dev->device == PCI_DEVICE_ID_SERVERWORKS_HT1000IDE)
70
		return 0x1f;
Linus Torvalds's avatar
Linus Torvalds committed
71
72
73
74
75
76
77
78
79
80
81
	if (dev->device == PCI_DEVICE_ID_SERVERWORKS_OSB4IDE) {
		u32 reg = 0;
		if (isa_dev)
			pci_read_config_dword(isa_dev, 0x64, &reg);
			
		/*
		 *	Don't enable UDMA on disk devices for the moment
		 */
		if(drive->media == ide_disk)
			return 0;
		/* Check the OSB4 DMA33 enable bit */
82
		return ((reg & 0x00004000) == 0x00004000) ? 0x07 : 0;
83
	} else if (dev->revision < SVWKS_CSB5_REVISION_NEW) {
84
		return 0x07;
85
	} else if (dev->revision >= SVWKS_CSB5_REVISION_NEW) {
86
		u8 btr = 0, mode;
Linus Torvalds's avatar
Linus Torvalds committed
87
88
		pci_read_config_byte(dev, 0x5A, &btr);
		mode = btr & 0x3;
89

Linus Torvalds's avatar
Linus Torvalds committed
90
91
92
93
		/* If someone decides to do UDMA133 on CSB5 the same
		   issue will bite so be inclusive */
		if (mode > 2 && check_in_drive_lists(drive, svwks_bad_ata100))
			mode = 2;
94
95

		switch(mode) {
96
		case 3:	 mask = 0x3f; break;
97
98
99
100
		case 2:	 mask = 0x1f; break;
		case 1:	 mask = 0x07; break;
		default: mask = 0x00; break;
		}
Linus Torvalds's avatar
Linus Torvalds committed
101
102
103
104
	}
	if (((dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE) ||
	     (dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2)) &&
	    (!(PCI_FUNC(dev->devfn) & 1)))
105
106
107
		mask = 0x1f;

	return mask;
Linus Torvalds's avatar
Linus Torvalds committed
108
109
110
111
112
113
114
115
}

static u8 svwks_csb_check (struct pci_dev *dev)
{
	switch (dev->device) {
		case PCI_DEVICE_ID_SERVERWORKS_CSB5IDE:
		case PCI_DEVICE_ID_SERVERWORKS_CSB6IDE:
		case PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2:
116
		case PCI_DEVICE_ID_SERVERWORKS_HT1000IDE:
Linus Torvalds's avatar
Linus Torvalds committed
117
118
119
120
121
122
			return 1;
		default:
			break;
	}
	return 0;
}
123

124
static void svwks_set_pio_mode(ide_drive_t *drive, const u8 pio)
125
126
127
128
{
	static const u8 pio_modes[] = { 0x5d, 0x47, 0x34, 0x22, 0x20 };
	static const u8 drive_pci[] = { 0x41, 0x40, 0x43, 0x42 };

129
	struct pci_dev *dev = to_pci_dev(drive->hwif->dev);
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

	pci_write_config_byte(dev, drive_pci[drive->dn], pio_modes[pio]);

	if (svwks_csb_check(dev)) {
		u16 csb_pio = 0;

		pci_read_config_word(dev, 0x4a, &csb_pio);

		csb_pio &= ~(0x0f << (4 * drive->dn));
		csb_pio |= (pio << (4 * drive->dn));

		pci_write_config_word(dev, 0x4a, csb_pio);
	}
}

145
static void svwks_set_dma_mode(ide_drive_t *drive, const u8 speed)
Linus Torvalds's avatar
Linus Torvalds committed
146
{
147
148
149
	static const u8 udma_modes[]		= { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
	static const u8 dma_modes[]		= { 0x77, 0x21, 0x20 };
	static const u8 drive_pci2[]		= { 0x45, 0x44, 0x47, 0x46 };
Linus Torvalds's avatar
Linus Torvalds committed
150
151

	ide_hwif_t *hwif	= HWIF(drive);
152
	struct pci_dev *dev	= to_pci_dev(hwif->dev);
Linus Torvalds's avatar
Linus Torvalds committed
153
	u8 unit			= (drive->select.b.unit & 0x01);
154
155
156

	u8 ultra_enable	 = 0, ultra_timing = 0, dma_timing = 0;

Linus Torvalds's avatar
Linus Torvalds committed
157
158
159
160
161
162
	pci_read_config_byte(dev, (0x56|hwif->channel), &ultra_timing);
	pci_read_config_byte(dev, 0x54, &ultra_enable);

	ultra_timing	&= ~(0x0F << (4*unit));
	ultra_enable	&= ~(0x01 << drive->dn);

163
164
165
166
167
168
	if (speed >= XFER_UDMA_0) {
		dma_timing   |= dma_modes[2];
		ultra_timing |= (udma_modes[speed - XFER_UDMA_0] << (4 * unit));
		ultra_enable |= (0x01 << drive->dn);
	} else if (speed >= XFER_MW_DMA_0)
		dma_timing   |= dma_modes[speed - XFER_MW_DMA_0];
Linus Torvalds's avatar
Linus Torvalds committed
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

	pci_write_config_byte(dev, drive_pci2[drive->dn], dma_timing);
	pci_write_config_byte(dev, (0x56|hwif->channel), ultra_timing);
	pci_write_config_byte(dev, 0x54, ultra_enable);
}

static unsigned int __devinit init_chipset_svwks (struct pci_dev *dev, const char *name)
{
	unsigned int reg;
	u8 btr;

	/* force Master Latency Timer value to 64 PCICLKs */
	pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x40);

	/* OSB4 : South Bridge and IDE */
	if (dev->device == PCI_DEVICE_ID_SERVERWORKS_OSB4IDE) {
185
		isa_dev = pci_get_device(PCI_VENDOR_ID_SERVERWORKS,
Linus Torvalds's avatar
Linus Torvalds committed
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
			  PCI_DEVICE_ID_SERVERWORKS_OSB4, NULL);
		if (isa_dev) {
			pci_read_config_dword(isa_dev, 0x64, &reg);
			reg &= ~0x00002000; /* disable 600ns interrupt mask */
			if(!(reg & 0x00004000))
				printk(KERN_DEBUG "%s: UDMA not BIOS enabled.\n", name);
			reg |=  0x00004000; /* enable UDMA/33 support */
			pci_write_config_dword(isa_dev, 0x64, reg);
		}
	}

	/* setup CSB5/CSB6 : South Bridge and IDE option RAID */
	else if ((dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB5IDE) ||
		 (dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE) ||
		 (dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2)) {

		/* Third Channel Test */
		if (!(PCI_FUNC(dev->devfn) & 1)) {
			struct pci_dev * findev = NULL;
			u32 reg4c = 0;
206
			findev = pci_get_device(PCI_VENDOR_ID_SERVERWORKS,
Linus Torvalds's avatar
Linus Torvalds committed
207
208
209
210
211
212
213
				PCI_DEVICE_ID_SERVERWORKS_CSB5, NULL);
			if (findev) {
				pci_read_config_dword(findev, 0x4C, &reg4c);
				reg4c &= ~0x000007FF;
				reg4c |=  0x00000040;
				reg4c |=  0x00000020;
				pci_write_config_dword(findev, 0x4C, reg4c);
214
				pci_dev_put(findev);
Linus Torvalds's avatar
Linus Torvalds committed
215
216
217
218
219
220
221
			}
			outb_p(0x06, 0x0c00);
			dev->irq = inb_p(0x0c01);
		} else {
			struct pci_dev * findev = NULL;
			u8 reg41 = 0;

222
			findev = pci_get_device(PCI_VENDOR_ID_SERVERWORKS,
Linus Torvalds's avatar
Linus Torvalds committed
223
224
225
226
227
					PCI_DEVICE_ID_SERVERWORKS_CSB6, NULL);
			if (findev) {
				pci_read_config_byte(findev, 0x41, &reg41);
				reg41 &= ~0x40;
				pci_write_config_byte(findev, 0x41, reg41);
228
				pci_dev_put(findev);
Linus Torvalds's avatar
Linus Torvalds committed
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
			}
			/*
			 * This is a device pin issue on CSB6.
			 * Since there will be a future raid mode,
			 * early versions of the chipset require the
			 * interrupt pin to be set, and it is a compatibility
			 * mode issue.
			 */
			if ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE)
				dev->irq = 0;
		}
//		pci_read_config_dword(dev, 0x40, &pioreg)
//		pci_write_config_dword(dev, 0x40, 0x99999999);
//		pci_read_config_dword(dev, 0x44, &dmareg);
//		pci_write_config_dword(dev, 0x44, 0xFFFFFFFF);
		/* 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(dev, 0x5A, &btr);
		btr &= ~0x40;
		if (!(PCI_FUNC(dev->devfn) & 1))
			btr |= 0x2;
		else
258
			btr |= (dev->revision >= SVWKS_CSB5_REVISION_NEW) ? 0x3 : 0x2;
Linus Torvalds's avatar
Linus Torvalds committed
259
260
		pci_write_config_byte(dev, 0x5A, btr);
	}
261
262
263
264
265
266
267
	/* Setup HT1000 SouthBridge Controller - Single Channel Only */
	else if (dev->device == PCI_DEVICE_ID_SERVERWORKS_HT1000IDE) {
		pci_read_config_byte(dev, 0x5A, &btr);
		btr &= ~0x40;
		btr |= 0x3;
		pci_write_config_byte(dev, 0x5A, btr);
	}
Linus Torvalds's avatar
Linus Torvalds committed
268

269
	return dev->irq;
Linus Torvalds's avatar
Linus Torvalds committed
270
271
}

272
static u8 __devinit ata66_svwks_svwks(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
273
{
274
	return ATA_CBL_PATA80;
Linus Torvalds's avatar
Linus Torvalds committed
275
276
277
278
279
280
281
282
283
}

/* On Dell PowerEdge servers with a CSB5/CSB6, the top two bits
 * of the subsystem device ID indicate presence of an 80-pin cable.
 * Bit 15 clear = secondary IDE channel does not have 80-pin cable.
 * Bit 15 set   = secondary IDE channel has 80-pin cable.
 * Bit 14 clear = primary IDE channel does not have 80-pin cable.
 * Bit 14 set   = primary IDE channel has 80-pin cable.
 */
284
static u8 __devinit ata66_svwks_dell(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
285
{
286
287
	struct pci_dev *dev = to_pci_dev(hwif->dev);

Linus Torvalds's avatar
Linus Torvalds committed
288
289
290
291
292
	if (dev->subsystem_vendor == PCI_VENDOR_ID_DELL &&
	    dev->vendor	== PCI_VENDOR_ID_SERVERWORKS &&
	    (dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB5IDE ||
	     dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE))
		return ((1 << (hwif->channel + 14)) &
293
294
			dev->subsystem_device) ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
	return ATA_CBL_PATA40;
Linus Torvalds's avatar
Linus Torvalds committed
295
296
297
298
299
300
301
302
}

/* Sun Cobalt Alpine hardware avoids the 80-pin cable
 * detect issue by attaching the drives directly to the board.
 * This check follows the Dell precedent (how scary is that?!)
 *
 * WARNING: this only works on Alpine hardware!
 */
303
static u8 __devinit ata66_svwks_cobalt(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
304
{
305
306
	struct pci_dev *dev = to_pci_dev(hwif->dev);

Linus Torvalds's avatar
Linus Torvalds committed
307
308
309
310
	if (dev->subsystem_vendor == PCI_VENDOR_ID_SUN &&
	    dev->vendor	== PCI_VENDOR_ID_SERVERWORKS &&
	    dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB5IDE)
		return ((1 << (hwif->channel + 14)) &
311
312
			dev->subsystem_device) ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
	return ATA_CBL_PATA40;
Linus Torvalds's avatar
Linus Torvalds committed
313
314
}

315
static u8 __devinit svwks_cable_detect(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
316
{
317
	struct pci_dev *dev = to_pci_dev(hwif->dev);
Linus Torvalds's avatar
Linus Torvalds committed
318
319
320
321
322
323
324
325
326
327
328
329
330

	/* Server Works */
	if (dev->subsystem_vendor == PCI_VENDOR_ID_SERVERWORKS)
		return ata66_svwks_svwks (hwif);
	
	/* Dell PowerEdge */
	if (dev->subsystem_vendor == PCI_VENDOR_ID_DELL)
		return ata66_svwks_dell (hwif);

	/* Cobalt Alpine */
	if (dev->subsystem_vendor == PCI_VENDOR_ID_SUN)
		return ata66_svwks_cobalt (hwif);

331
332
333
	/* Per Specified Design by OEM, and ASIC Architect */
	if ((dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE) ||
	    (dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2))
334
		return ATA_CBL_PATA80;
335

336
	return ATA_CBL_PATA40;
Linus Torvalds's avatar
Linus Torvalds committed
337
338
}

339
340
341
342
343
static const struct ide_port_ops osb4_port_ops = {
	.set_pio_mode		= svwks_set_pio_mode,
	.set_dma_mode		= svwks_set_dma_mode,
	.udma_filter		= svwks_udma_filter,
};
Linus Torvalds's avatar
Linus Torvalds committed
344

345
346
347
348
349
350
static const struct ide_port_ops svwks_port_ops = {
	.set_pio_mode		= svwks_set_pio_mode,
	.set_dma_mode		= svwks_set_dma_mode,
	.udma_filter		= svwks_udma_filter,
	.cable_detect		= svwks_cable_detect,
};
Linus Torvalds's avatar
Linus Torvalds committed
351

352
#define IDE_HFLAGS_SVWKS IDE_HFLAG_LEGACY_IRQS
353

354
static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
Linus Torvalds's avatar
Linus Torvalds committed
355
356
357
	{	/* 0 */
		.name		= "SvrWks OSB4",
		.init_chipset	= init_chipset_svwks,
358
		.port_ops	= &osb4_port_ops,
359
		.host_flags	= IDE_HFLAGS_SVWKS,
Bartlomiej Zolnierkiewicz's avatar
Bartlomiej Zolnierkiewicz committed
360
		.pio_mask	= ATA_PIO4,
361
362
		.mwdma_mask	= ATA_MWDMA2,
		.udma_mask	= 0x00, /* UDMA is problematic on OSB4 */
Linus Torvalds's avatar
Linus Torvalds committed
363
364
365
	},{	/* 1 */
		.name		= "SvrWks CSB5",
		.init_chipset	= init_chipset_svwks,
366
		.port_ops	= &svwks_port_ops,
367
		.host_flags	= IDE_HFLAGS_SVWKS,
Bartlomiej Zolnierkiewicz's avatar
Bartlomiej Zolnierkiewicz committed
368
		.pio_mask	= ATA_PIO4,
369
370
		.mwdma_mask	= ATA_MWDMA2,
		.udma_mask	= ATA_UDMA5,
Linus Torvalds's avatar
Linus Torvalds committed
371
372
373
	},{	/* 2 */
		.name		= "SvrWks CSB6",
		.init_chipset	= init_chipset_svwks,
374
		.port_ops	= &svwks_port_ops,
375
		.host_flags	= IDE_HFLAGS_SVWKS,
Bartlomiej Zolnierkiewicz's avatar
Bartlomiej Zolnierkiewicz committed
376
		.pio_mask	= ATA_PIO4,
377
378
		.mwdma_mask	= ATA_MWDMA2,
		.udma_mask	= ATA_UDMA5,
Linus Torvalds's avatar
Linus Torvalds committed
379
380
381
	},{	/* 3 */
		.name		= "SvrWks CSB6",
		.init_chipset	= init_chipset_svwks,
382
		.port_ops	= &svwks_port_ops,
383
		.host_flags	= IDE_HFLAGS_SVWKS | IDE_HFLAG_SINGLE,
Bartlomiej Zolnierkiewicz's avatar
Bartlomiej Zolnierkiewicz committed
384
		.pio_mask	= ATA_PIO4,
385
386
		.mwdma_mask	= ATA_MWDMA2,
		.udma_mask	= ATA_UDMA5,
387
388
389
	},{	/* 4 */
		.name		= "SvrWks HT1000",
		.init_chipset	= init_chipset_svwks,
390
		.port_ops	= &svwks_port_ops,
391
		.host_flags	= IDE_HFLAGS_SVWKS | IDE_HFLAG_SINGLE,
Bartlomiej Zolnierkiewicz's avatar
Bartlomiej Zolnierkiewicz committed
392
		.pio_mask	= ATA_PIO4,
393
394
		.mwdma_mask	= ATA_MWDMA2,
		.udma_mask	= ATA_UDMA5,
Linus Torvalds's avatar
Linus Torvalds committed
395
396
397
398
399
400
401
402
403
404
405
406
407
408
	}
};

/**
 *	svwks_init_one	-	called when a OSB/CSB is found
 *	@dev: the svwks device
 *	@id: the matching pci id
 *
 *	Called when the PCI registration layer (or the IDE initialization)
 *	finds a device matching our IDE device tables.
 */
 
static int __devinit svwks_init_one(struct pci_dev *dev, const struct pci_device_id *id)
{
409
	struct ide_port_info d;
410
411
412
413
	u8 idx = id->driver_data;

	d = serverworks_chipsets[idx];

414
415
416
	if (idx == 1)
		d.host_flags |= IDE_HFLAG_CLEAR_SIMPLEX;
	else if (idx == 2 || idx == 3) {
417
418
		if ((PCI_FUNC(dev->devfn) & 1) == 0) {
			if (pci_resource_start(dev, 0) != 0x01f1)
419
				d.host_flags |= IDE_HFLAG_NON_BOOTABLE;
420
421
422
423
			d.host_flags |= IDE_HFLAG_SINGLE;
		} else
			d.host_flags &= ~IDE_HFLAG_SINGLE;
	}
Linus Torvalds's avatar
Linus Torvalds committed
424

425
	return ide_pci_init_one(dev, &d, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
426
427
}

428
429
430
431
432
433
static const struct pci_device_id svwks_pci_tbl[] = {
	{ PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_OSB4IDE),   0 },
	{ PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB5IDE),   1 },
	{ PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE),   2 },
	{ PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2),  3 },
	{ PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_HT1000IDE), 4 },
Linus Torvalds's avatar
Linus Torvalds committed
434
435
436
437
438
439
440
441
	{ 0, },
};
MODULE_DEVICE_TABLE(pci, svwks_pci_tbl);

static struct pci_driver driver = {
	.name		= "Serverworks_IDE",
	.id_table	= svwks_pci_tbl,
	.probe		= svwks_init_one,
442
	.remove		= ide_pci_remove,
Linus Torvalds's avatar
Linus Torvalds committed
443
444
};

445
static int __init svwks_ide_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
446
447
448
449
{
	return ide_pci_register_driver(&driver);
}

450
451
452
453
454
static void __exit svwks_ide_exit(void)
{
	pci_unregister_driver(&driver);
}

Linus Torvalds's avatar
Linus Torvalds committed
455
module_init(svwks_ide_init);
456
module_exit(svwks_ide_exit);
Linus Torvalds's avatar
Linus Torvalds committed
457
458
459
460

MODULE_AUTHOR("Michael Aubry. Andrzej Krzysztofowicz, Andre Hedrick");
MODULE_DESCRIPTION("PCI driver module for Serverworks OSB4/CSB5/CSB6 IDE");
MODULE_LICENSE("GPL");