sata_promise.c 16.7 KB
Newer Older
1 2 3
/*
 *  sata_promise.c - Promise SATA
 *
4 5 6 7
 *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
 *  		    Please ALWAYS copy linux-ide@vger.kernel.org
 *		    on emails.
 *
8
 *  Copyright 2003-2004 Red Hat, Inc.
9 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
 *
 *  The contents of this file are subject to the Open
 *  Software License version 1.1 that can be found at
 *  http://www.opensource.org/licenses/osl-1.1.txt and is included herein
 *  by reference.
 *
 *  Alternatively, the contents of this file may be used under the terms
 *  of the GNU General Public License version 2 (the "GPL") as distributed
 *  in the kernel source COPYING file, in which case the provisions of
 *  the GPL are applicable instead of the above.  If you wish to allow
 *  the use of your version of this file only under the terms of the
 *  GPL and not to allow others to use your version of this file under
 *  the OSL, indicate your decision by deleting the provisions above and
 *  replace them with the notice and other provisions required by the GPL.
 *  If you do not delete the provisions above, a recipient may use your
 *  version of this file under either the OSL or the GPL.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
35
#include <linux/sched.h>
36
#include "scsi.h"
37
#include <scsi/scsi_host.h>
38
#include <linux/libata.h>
Jeff Garzik's avatar
Jeff Garzik committed
39
#include <asm/io.h>
40
#include "sata_promise.h"
Jeff Garzik's avatar
Jeff Garzik committed
41

42
#define DRV_NAME	"sata_promise"
43
#define DRV_VERSION	"1.01"
44 45 46


enum {
47
	PDC_PKT_SUBMIT		= 0x40, /* Command packet pointer addr */
48 49 50
	PDC_INT_SEQMASK		= 0x40,	/* Mask of asserted SEQ INTs */
	PDC_TBG_MODE		= 0x41,	/* TBG mode */
	PDC_FLASH_CTL		= 0x44, /* Flash control register */
51
	PDC_PCI_CTL		= 0x48, /* PCI control and status register */
52 53
	PDC_GLOBAL_CTL		= 0x48, /* Global control/status (per port) */
	PDC_CTLSTAT		= 0x60,	/* IDE control and status (per port) */
54 55
	PDC_SATA_PLUG_CSR	= 0x6C, /* SATA Plug control/status reg */
	PDC_SLEW_CTL		= 0x470, /* slew rate control reg */
56

57 58 59
	PDC_ERR_MASK		= (1<<19) | (1<<20) | (1<<21) | (1<<22) |
				  (1<<8) | (1<<9) | (1<<10),

60 61 62
	board_2037x		= 0,	/* FastTrak S150 TX2plus */
	board_20319		= 1,	/* FastTrak S150 TX4 */

63 64
	PDC_HAS_PATA		= (1 << 1), /* PDC20375 has PATA */

65
	PDC_RESET		= (1 << 11), /* HDMA reset */
66 67 68
};


69 70 71
struct pdc_port_priv {
	u8			*pkt;
	dma_addr_t		pkt_dma;
72 73
};

74 75
static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg);
static void pdc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
76
static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
77 78
static irqreturn_t pdc_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
static void pdc_eng_timeout(struct ata_port *ap);
79 80
static int pdc_port_start(struct ata_port *ap);
static void pdc_port_stop(struct ata_port *ap);
81
static void pdc_phy_reset(struct ata_port *ap);
Jeff Garzik's avatar
Jeff Garzik committed
82
static void pdc_qc_prep(struct ata_queued_cmd *qc);
83 84
static void pdc_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf);
static void pdc_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf);
85
static void pdc_irq_clear(struct ata_port *ap);
86
static int pdc_qc_issue_prot(struct ata_queued_cmd *qc);
87

88
static Scsi_Host_Template pdc_ata_sht = {
89 90
	.module			= THIS_MODULE,
	.name			= DRV_NAME,
91
	.ioctl			= ata_scsi_ioctl,
92 93 94 95
	.queuecommand		= ata_scsi_queuecmd,
	.eh_strategy_handler	= ata_scsi_error,
	.can_queue		= ATA_DEF_QUEUE,
	.this_id		= ATA_SHT_THIS_ID,
96
	.sg_tablesize		= LIBATA_MAX_PRD,
97 98 99 100 101 102 103
	.max_sectors		= ATA_MAX_SECTORS,
	.cmd_per_lun		= ATA_SHT_CMD_PER_LUN,
	.emulated		= ATA_SHT_EMULATED,
	.use_clustering		= ATA_SHT_USE_CLUSTERING,
	.proc_name		= DRV_NAME,
	.dma_boundary		= ATA_DMA_BOUNDARY,
	.slave_configure	= ata_scsi_slave_config,
104
	.bios_param		= ata_std_bios_param,
105 106
};

107
static struct ata_port_operations pdc_ata_ops = {
108
	.port_disable		= ata_port_disable,
109
	.tf_load		= pdc_tf_load_mmio,
110 111
	.tf_read		= ata_tf_read,
	.check_status		= ata_check_status,
112
	.exec_command		= pdc_exec_command_mmio,
113
	.dev_select		= ata_std_dev_select,
114
	.phy_reset		= pdc_phy_reset,
Jeff Garzik's avatar
Jeff Garzik committed
115
	.qc_prep		= pdc_qc_prep,
116
	.qc_issue		= pdc_qc_issue_prot,
117 118
	.eng_timeout		= pdc_eng_timeout,
	.irq_handler		= pdc_interrupt,
119
	.irq_clear		= pdc_irq_clear,
120 121
	.scr_read		= pdc_sata_scr_read,
	.scr_write		= pdc_sata_scr_write,
122 123
	.port_start		= pdc_port_start,
	.port_stop		= pdc_port_stop,
124 125 126 127 128
};

static struct ata_port_info pdc_port_info[] = {
	/* board_2037x */
	{
129
		.sht		= &pdc_ata_sht,
130 131
		.host_flags	= ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
				  ATA_FLAG_SRST | ATA_FLAG_MMIO,
Jeff Garzik's avatar
Jeff Garzik committed
132 133
		.pio_mask	= 0x1f, /* pio0-4 */
		.mwdma_mask	= 0x07, /* mwdma0-2 */
134
		.udma_mask	= 0x7f, /* udma0-6 ; FIXME */
135
		.port_ops	= &pdc_ata_ops,
136 137 138 139
	},

	/* board_20319 */
	{
140
		.sht		= &pdc_ata_sht,
141 142
		.host_flags	= ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
				  ATA_FLAG_SRST | ATA_FLAG_MMIO,
Jeff Garzik's avatar
Jeff Garzik committed
143 144
		.pio_mask	= 0x1f, /* pio0-4 */
		.mwdma_mask	= 0x07, /* mwdma0-2 */
145
		.udma_mask	= 0x7f, /* udma0-6 ; FIXME */
146
		.port_ops	= &pdc_ata_ops,
147 148 149
	},
};

150
static struct pci_device_id pdc_ata_pci_tbl[] = {
151 152
	{ PCI_VENDOR_ID_PROMISE, 0x3371, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	  board_2037x },
153 154
	{ PCI_VENDOR_ID_PROMISE, 0x3373, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	  board_2037x },
155 156
	{ PCI_VENDOR_ID_PROMISE, 0x3375, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	  board_2037x },
157 158
	{ PCI_VENDOR_ID_PROMISE, 0x3376, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	  board_2037x },
159 160
	{ PCI_VENDOR_ID_PROMISE, 0x3574, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	  board_2037x },
161 162 163
	{ PCI_VENDOR_ID_PROMISE, 0x3d75, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	  board_2037x },

164 165 166 167
	{ PCI_VENDOR_ID_PROMISE, 0x3318, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	  board_20319 },
	{ PCI_VENDOR_ID_PROMISE, 0x3319, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	  board_20319 },
168 169 170
	{ PCI_VENDOR_ID_PROMISE, 0x3d18, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	  board_20319 },

171 172 173 174
	{ }	/* terminate list */
};


175
static struct pci_driver pdc_ata_pci_driver = {
176
	.name			= DRV_NAME,
177 178
	.id_table		= pdc_ata_pci_tbl,
	.probe			= pdc_ata_init_one,
179 180 181 182
	.remove			= ata_pci_remove_one,
};


183 184
static int pdc_port_start(struct ata_port *ap)
{
185
	struct device *dev = ap->host_set->dev;
186 187 188 189 190 191
	struct pdc_port_priv *pp;
	int rc;

	rc = ata_port_start(ap);
	if (rc)
		return rc;
192

193 194 195 196 197
	pp = kmalloc(sizeof(*pp), GFP_KERNEL);
	if (!pp) {
		rc = -ENOMEM;
		goto err_out;
	}
198
	memset(pp, 0, sizeof(*pp));
199

200
	pp->pkt = dma_alloc_coherent(dev, 128, &pp->pkt_dma, GFP_KERNEL);
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
	if (!pp->pkt) {
		rc = -ENOMEM;
		goto err_out_kfree;
	}

	ap->private_data = pp;

	return 0;

err_out_kfree:
	kfree(pp);
err_out:
	ata_port_stop(ap);
	return rc;
}


static void pdc_port_stop(struct ata_port *ap)
{
220
	struct device *dev = ap->host_set->dev;
221 222 223
	struct pdc_port_priv *pp = ap->private_data;

	ap->private_data = NULL;
224
	dma_free_coherent(dev, 128, pp->pkt, pp->pkt_dma);
225 226 227 228 229
	kfree(pp);
	ata_port_stop(ap);
}


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
static void pdc_reset_port(struct ata_port *ap)
{
	void *mmio = (void *) ap->ioaddr.cmd_addr + PDC_CTLSTAT;
	unsigned int i;
	u32 tmp;

	for (i = 11; i > 0; i--) {
		tmp = readl(mmio);
		if (tmp & PDC_RESET)
			break;

		udelay(100);

		tmp |= PDC_RESET;
		writel(tmp, mmio);
	}

	tmp &= ~PDC_RESET;
	writel(tmp, mmio);
	readl(mmio);	/* flush */
}

static void pdc_phy_reset(struct ata_port *ap)
{
	pdc_reset_port(ap);
	sata_phy_reset(ap);
}

258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
{
	if (sc_reg > SCR_CONTROL)
		return 0xffffffffU;
	return readl((void *) ap->ioaddr.scr_addr + (sc_reg * 4));
}


static void pdc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg,
			       u32 val)
{
	if (sc_reg > SCR_CONTROL)
		return;
	writel(val, (void *) ap->ioaddr.scr_addr + (sc_reg * 4));
}

Jeff Garzik's avatar
Jeff Garzik committed
274
static void pdc_qc_prep(struct ata_queued_cmd *qc)
275 276 277 278
{
	struct pdc_port_priv *pp = qc->ap->private_data;
	unsigned int i;

Jeff Garzik's avatar
Jeff Garzik committed
279 280
	VPRINTK("ENTER\n");

281 282 283 284
	switch (qc->tf.protocol) {
	case ATA_PROT_DMA:
		ata_qc_prep(qc);
		/* fall through */
285

286 287 288
	case ATA_PROT_NODATA:
		i = pdc_pkt_header(&qc->tf, qc->ap->prd_dma,
				   qc->dev->devno, pp->pkt);
289

290 291 292 293
		if (qc->tf.flags & ATA_TFLAG_LBA48)
			i = pdc_prep_lba48(&qc->tf, pp->pkt, i);
		else
			i = pdc_prep_lba28(&qc->tf, pp->pkt, i);
294

295 296
		pdc_pkt_footer(&qc->tf, pp->pkt, i);
		break;
297

298 299 300
	default:
		break;
	}
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
}

static void pdc_eng_timeout(struct ata_port *ap)
{
	u8 drv_stat;
	struct ata_queued_cmd *qc;

	DPRINTK("ENTER\n");

	qc = ata_qc_from_tag(ap, ap->active_tag);
	if (!qc) {
		printk(KERN_ERR "ata%u: BUG: timeout without command\n",
		       ap->id);
		goto out;
	}

317 318 319 320 321 322 323 324
	/* hack alert!  We cannot use the supplied completion
	 * function from inside the ->eh_strategy_handler() thread.
	 * libata is the only user of ->eh_strategy_handler() in
	 * any kernel, so the default scsi_done() assumes it is
	 * not being called from the SCSI EH.
	 */
	qc->scsidone = scsi_finish_command;

325
	switch (qc->tf.protocol) {
326
	case ATA_PROT_DMA:
327
	case ATA_PROT_NODATA:
328
		printk(KERN_ERR "ata%u: command timeout\n", ap->id);
Jeff Garzik's avatar
Jeff Garzik committed
329
		ata_qc_complete(qc, ata_wait_idle(ap) | ATA_ERR);
330 331 332 333 334 335 336 337
		break;

	default:
		drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);

		printk(KERN_ERR "ata%u: unknown timeout, cmd 0x%x stat 0x%x\n",
		       ap->id, qc->tf.command, drv_stat);

Jeff Garzik's avatar
Jeff Garzik committed
338
		ata_qc_complete(qc, drv_stat);
339 340 341 342 343 344 345 346 347 348 349
		break;
	}

out:
	DPRINTK("EXIT\n");
}

static inline unsigned int pdc_host_intr( struct ata_port *ap,
                                          struct ata_queued_cmd *qc)
{
	u8 status;
350 351 352 353 354 355 356 357 358
	unsigned int handled = 0, have_err = 0;
	u32 tmp;
	void *mmio = (void *) ap->ioaddr.cmd_addr + PDC_GLOBAL_CTL;

	tmp = readl(mmio);
	if (tmp & PDC_ERR_MASK) {
		have_err = 1;
		pdc_reset_port(ap);
	}
359 360

	switch (qc->tf.protocol) {
361
	case ATA_PROT_DMA:
362 363
	case ATA_PROT_NODATA:
		status = ata_wait_idle(ap);
364 365
		if (have_err)
			status |= ATA_ERR;
Jeff Garzik's avatar
Jeff Garzik committed
366
		ata_qc_complete(qc, status);
367 368 369 370 371 372 373 374 375 376 377
		handled = 1;
		break;

        default:
                ap->stats.idle_irq++;
                break;
        }

        return handled;
}

378 379 380 381 382 383 384 385
static void pdc_irq_clear(struct ata_port *ap)
{
	struct ata_host_set *host_set = ap->host_set;
	void *mmio = host_set->mmio_base;

	readl(mmio + PDC_INT_SEQMASK);
}

386 387 388 389 390 391
static irqreturn_t pdc_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
{
	struct ata_host_set *host_set = dev_instance;
	struct ata_port *ap;
	u32 mask = 0;
	unsigned int i, tmp;
392
	unsigned int handled = 0;
393 394 395 396 397 398 399 400 401 402 403 404
	void *mmio_base;

	VPRINTK("ENTER\n");

	if (!host_set || !host_set->mmio_base) {
		VPRINTK("QUICK EXIT\n");
		return IRQ_NONE;
	}

	mmio_base = host_set->mmio_base;

	/* reading should also clear interrupts */
405
	mask = readl(mmio_base + PDC_INT_SEQMASK);
406 407 408 409 410

	if (mask == 0xffffffff) {
		VPRINTK("QUICK EXIT 2\n");
		return IRQ_NONE;
	}
411
	mask &= 0xffff;		/* only 16 tags possible */
412 413 414 415 416
	if (!mask) {
		VPRINTK("QUICK EXIT 3\n");
		return IRQ_NONE;
	}

417 418 419
	spin_lock(&host_set->lock);

	writel(mask, mmio_base + PDC_INT_SEQMASK);
420

421
	for (i = 0; i < host_set->n_ports; i++) {
422 423 424 425 426 427 428
		VPRINTK("port %u\n", i);
		ap = host_set->ports[i];
		tmp = mask & (1 << (i + 1));
		if (tmp && ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
			struct ata_queued_cmd *qc;

			qc = ata_qc_from_tag(ap, ap->active_tag);
429
			if (qc && (!(qc->tf.ctl & ATA_NIEN)))
430 431 432 433
				handled += pdc_host_intr(ap, qc);
		}
	}

434
        spin_unlock(&host_set->lock);
435 436 437 438 439 440

	VPRINTK("EXIT\n");

	return IRQ_RETVAL(handled);
}

441
static inline void pdc_packet_start(struct ata_queued_cmd *qc)
442 443
{
	struct ata_port *ap = qc->ap;
444
	struct pdc_port_priv *pp = ap->private_data;
445 446 447
	unsigned int port_no = ap->port_no;
	u8 seq = (u8) (port_no + 1);

448
	VPRINTK("ENTER, ap %p\n", ap);
449

450
	writel(0x00000001, ap->host_set->mmio_base + (seq * 4));
451
	readl(ap->host_set->mmio_base + (seq * 4));	/* flush */
452

453 454 455
	pp->pkt[2] = seq;
	wmb();			/* flush PRD, pkt writes */
	writel(pp->pkt_dma, (void *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
456
	readl((void *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT); /* flush */
457 458
}

459 460 461 462
static int pdc_qc_issue_prot(struct ata_queued_cmd *qc)
{
	switch (qc->tf.protocol) {
	case ATA_PROT_DMA:
463 464
	case ATA_PROT_NODATA:
		pdc_packet_start(qc);
465 466 467 468 469 470 471 472 473 474 475 476 477
		return 0;

	case ATA_PROT_ATAPI_DMA:
		BUG();
		break;

	default:
		break;
	}

	return ata_qc_issue_prot(qc);
}

478 479
static void pdc_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
{
480 481
	WARN_ON (tf->protocol == ATA_PROT_DMA ||
		 tf->protocol == ATA_PROT_NODATA);
482
	ata_tf_load(ap, tf);
483 484 485 486 487
}


static void pdc_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
{
488 489
	WARN_ON (tf->protocol == ATA_PROT_DMA ||
		 tf->protocol == ATA_PROT_NODATA);
490
	ata_exec_command(ap, tf);
491 492
}

493

494
static void pdc_ata_setup_port(struct ata_ioports *port, unsigned long base)
495 496 497
{
	port->cmd_addr		= base;
	port->data_addr		= base;
498
	port->feature_addr	=
499 500 501 502 503 504
	port->error_addr	= base + 0x4;
	port->nsect_addr	= base + 0x8;
	port->lbal_addr		= base + 0xc;
	port->lbam_addr		= base + 0x10;
	port->lbah_addr		= base + 0x14;
	port->device_addr	= base + 0x18;
505 506 507
	port->command_addr	=
	port->status_addr	= base + 0x1c;
	port->altstatus_addr	=
508 509 510
	port->ctl_addr		= base + 0x38;
}

511

512 513 514 515 516
static void pdc_host_init(unsigned int chip_id, struct ata_probe_ent *pe)
{
	void *mmio = pe->mmio_base;
	u32 tmp;

517 518 519 520
	/*
	 * Except for the hotplug stuff, this is voodoo from the
	 * Promise driver.  Label this entire section
	 * "TODO: figure out why we do this"
521
	 */
522 523

	/* change FIFO_SHD to 8 dwords, enable BMR_BURST */
524
	tmp = readl(mmio + PDC_FLASH_CTL);
525 526
	tmp |= 0x12000;	/* bit 16 (fifo 8 dw) and 13 (bmr burst?) */
	writel(tmp, mmio + PDC_FLASH_CTL);
527 528 529 530 531 532 533 534 535

	/* clear plug/unplug flags for all ports */
	tmp = readl(mmio + PDC_SATA_PLUG_CSR);
	writel(tmp | 0xff, mmio + PDC_SATA_PLUG_CSR);

	/* mask plug/unplug ints */
	tmp = readl(mmio + PDC_SATA_PLUG_CSR);
	writel(tmp | 0xff0000, mmio + PDC_SATA_PLUG_CSR);

536
	/* reduce TBG clock to 133 Mhz. */
537 538 539 540 541
	tmp = readl(mmio + PDC_TBG_MODE);
	tmp &= ~0x30000; /* clear bit 17, 16*/
	tmp |= 0x10000;  /* set bit 17:16 = 0:1 */
	writel(tmp, mmio + PDC_TBG_MODE);

542
	readl(mmio + PDC_TBG_MODE);	/* flush */
543
	msleep(10);
544 545

	/* adjust slew rate control register. */
546 547 548 549 550 551
	tmp = readl(mmio + PDC_SLEW_CTL);
	tmp &= 0xFFFFF03F; /* clear bit 11 ~ 6 */
	tmp  |= 0x00000900; /* set bit 11-9 = 100b , bit 8-6 = 100 */
	writel(tmp, mmio + PDC_SLEW_CTL);
}

552
static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
553 554 555 556
{
	static int printed_version;
	struct ata_probe_ent *probe_ent = NULL;
	unsigned long base;
557
	void *mmio_base;
558
	unsigned int board_idx = (unsigned int) ent->driver_data;
559
	int pci_dev_busy = 0;
560 561 562 563 564 565 566 567 568 569 570 571 572 573
	int rc;

	if (!printed_version++)
		printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");

	/*
	 * If this driver happens to only be useful on Apple's K2, then
	 * we should check that here as it has a normal Serverworks ID
	 */
	rc = pci_enable_device(pdev);
	if (rc)
		return rc;

	rc = pci_request_regions(pdev, DRV_NAME);
574 575
	if (rc) {
		pci_dev_busy = 1;
576
		goto err_out;
577
	}
578 579

	rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
580 581 582
	if (rc)
		goto err_out_regions;
	rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
583 584 585 586 587 588 589 590 591 592
	if (rc)
		goto err_out_regions;

	probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
	if (probe_ent == NULL) {
		rc = -ENOMEM;
		goto err_out_regions;
	}

	memset(probe_ent, 0, sizeof(*probe_ent));
593
	probe_ent->dev = pci_dev_to_dev(pdev);
594 595 596 597 598 599 600 601 602 603 604 605 606
	INIT_LIST_HEAD(&probe_ent->node);

	mmio_base = ioremap(pci_resource_start(pdev, 3),
		            pci_resource_len(pdev, 3));
	if (mmio_base == NULL) {
		rc = -ENOMEM;
		goto err_out_free_ent;
	}
	base = (unsigned long) mmio_base;

	probe_ent->sht		= pdc_port_info[board_idx].sht;
	probe_ent->host_flags	= pdc_port_info[board_idx].host_flags;
	probe_ent->pio_mask	= pdc_port_info[board_idx].pio_mask;
Jeff Garzik's avatar
Jeff Garzik committed
607
	probe_ent->mwdma_mask	= pdc_port_info[board_idx].mwdma_mask;
608 609 610 611 612 613 614
	probe_ent->udma_mask	= pdc_port_info[board_idx].udma_mask;
	probe_ent->port_ops	= pdc_port_info[board_idx].port_ops;

       	probe_ent->irq = pdev->irq;
       	probe_ent->irq_flags = SA_SHIRQ;
	probe_ent->mmio_base = mmio_base;

615 616
	pdc_ata_setup_port(&probe_ent->port[0], base + 0x200);
	pdc_ata_setup_port(&probe_ent->port[1], base + 0x280);
617

618 619
	probe_ent->port[0].scr_addr = base + 0x400;
	probe_ent->port[1].scr_addr = base + 0x500;
620 621 622 623 624 625

	/* notice 4-port boards */
	switch (board_idx) {
	case board_20319:
       		probe_ent->n_ports = 4;

626 627
		pdc_ata_setup_port(&probe_ent->port[2], base + 0x300);
		pdc_ata_setup_port(&probe_ent->port[3], base + 0x380);
628

629 630
		probe_ent->port[2].scr_addr = base + 0x600;
		probe_ent->port[3].scr_addr = base + 0x700;
631 632 633 634 635 636 637 638 639 640 641 642
		break;
	case board_2037x:
       		probe_ent->n_ports = 2;
		break;
	default:
		BUG();
		break;
	}

	pci_set_master(pdev);

	/* initialize adapter */
643
	pdc_host_init(board_idx, probe_ent);
644 645 646 647 648 649 650 651 652 653 654 655

	/* FIXME: check ata_device_add return value */
	ata_device_add(probe_ent);
	kfree(probe_ent);

	return 0;

err_out_free_ent:
	kfree(probe_ent);
err_out_regions:
	pci_release_regions(pdev);
err_out:
656 657
	if (!pci_dev_busy)
		pci_disable_device(pdev);
658 659 660 661
	return rc;
}


662
static int __init pdc_ata_init(void)
663
{
664
	return pci_module_init(&pdc_ata_pci_driver);
665 666 667
}


668
static void __exit pdc_ata_exit(void)
669
{
670
	pci_unregister_driver(&pdc_ata_pci_driver);
671 672 673 674
}


MODULE_AUTHOR("Jeff Garzik");
675
MODULE_DESCRIPTION("Promise SATA TX2/TX4 low-level driver");
676
MODULE_LICENSE("GPL");
677
MODULE_DEVICE_TABLE(pci, pdc_ata_pci_tbl);
678
MODULE_VERSION(DRV_VERSION);
679

680 681
module_init(pdc_ata_init);
module_exit(pdc_ata_exit);