sata_sx4.c 39.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3
/*
 *  sata_sx4.c - Promise SATA
 *
4
 *  Maintained by:  Tejun Heo <tj@kernel.org>
Linus Torvalds's avatar
Linus Torvalds committed
5 6 7 8 9
 *  		    Please ALWAYS copy linux-ide@vger.kernel.org
 *		    on emails.
 *
 *  Copyright 2003-2004 Red Hat, Inc.
 *
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *
 *  libata documentation is available via 'make {ps|pdf}docs',
 *  as Documentation/DocBook/libata.*
 *
 *  Hardware documentation available under NDA.
Linus Torvalds's avatar
Linus Torvalds committed
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 64
/*
	Theory of operation
	-------------------

	The SX4 (PDC20621) chip features a single Host DMA (HDMA) copy
	engine, DIMM memory, and four ATA engines (one per SATA port).
	Data is copied to/from DIMM memory by the HDMA engine, before
	handing off to one (or more) of the ATA engines.  The ATA
	engines operate solely on DIMM memory.

	The SX4 behaves like a PATA chip, with no SATA controls or
	knowledge whatsoever, leading to the presumption that
	PATA<->SATA bridges exist on SX4 boards, external to the
	PDC20621 chip itself.

	The chip is quite capable, supporting an XOR engine and linked
	hardware commands (permits a string to transactions to be
	submitted and waited-on as a single unit), and an optional
	microprocessor.

	The limiting factor is largely software.  This Linux driver was
	written to multiplex the single HDMA engine to copy disk
	transactions into a fixed DIMM memory space, from where an ATA
	engine takes over.  As a result, each WRITE looks like this:

		submit HDMA packet to hardware
		hardware copies data from system memory to DIMM
		hardware raises interrupt

		submit ATA packet to hardware
		hardware executes ATA WRITE command, w/ data in DIMM
		hardware raises interrupt
65

66 67 68 69 70
	and each READ looks like this:

		submit ATA packet to hardware
		hardware executes ATA READ command, w/ data in DIMM
		hardware raises interrupt
71

72 73 74 75 76 77 78 79 80
		submit HDMA packet to hardware
		hardware copies data from DIMM to system memory
		hardware raises interrupt

	This is a very slow, lock-step way of doing things that can
	certainly be improved by motivated kernel hackers.

 */

Linus Torvalds's avatar
Linus Torvalds committed
81 82 83
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
84
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
85 86 87 88
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
89
#include <linux/device.h>
Linus Torvalds's avatar
Linus Torvalds committed
90
#include <scsi/scsi_host.h>
91
#include <scsi/scsi_cmnd.h>
Linus Torvalds's avatar
Linus Torvalds committed
92 93 94 95
#include <linux/libata.h>
#include "sata_promise.h"

#define DRV_NAME	"sata_sx4"
96
#define DRV_VERSION	"0.12"
Linus Torvalds's avatar
Linus Torvalds committed
97 98 99


enum {
Tejun Heo's avatar
Tejun Heo committed
100 101 102
	PDC_MMIO_BAR		= 3,
	PDC_DIMM_BAR		= 4,

Linus Torvalds's avatar
Linus Torvalds committed
103 104 105 106 107 108 109
	PDC_PRD_TBL		= 0x44,	/* Direct command DMA table addr */

	PDC_PKT_SUBMIT		= 0x40, /* Command packet pointer addr */
	PDC_HDMA_PKT_SUBMIT	= 0x100, /* Host DMA packet pointer addr */
	PDC_INT_SEQMASK		= 0x40,	/* Mask of asserted SEQ INTs */
	PDC_HDMA_CTLSTAT	= 0x12C, /* Host DMA control / status */

110 111
	PDC_CTLSTAT		= 0x60,	/* IDEn control / status */

Linus Torvalds's avatar
Linus Torvalds committed
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
	PDC_20621_SEQCTL	= 0x400,
	PDC_20621_SEQMASK	= 0x480,
	PDC_20621_GENERAL_CTL	= 0x484,
	PDC_20621_PAGE_SIZE	= (32 * 1024),

	/* chosen, not constant, values; we design our own DIMM mem map */
	PDC_20621_DIMM_WINDOW	= 0x0C,	/* page# for 32K DIMM window */
	PDC_20621_DIMM_BASE	= 0x00200000,
	PDC_20621_DIMM_DATA	= (64 * 1024),
	PDC_DIMM_DATA_STEP	= (256 * 1024),
	PDC_DIMM_WINDOW_STEP	= (8 * 1024),
	PDC_DIMM_HOST_PRD	= (6 * 1024),
	PDC_DIMM_HOST_PKT	= (128 * 0),
	PDC_DIMM_HPKT_PRD	= (128 * 1),
	PDC_DIMM_ATA_PKT	= (128 * 2),
	PDC_DIMM_APKT_PRD	= (128 * 3),
	PDC_DIMM_HEADER_SZ	= PDC_DIMM_APKT_PRD + 128,
	PDC_PAGE_WINDOW		= 0x40,
	PDC_PAGE_DATA		= PDC_PAGE_WINDOW +
				  (PDC_20621_DIMM_DATA / PDC_20621_PAGE_SIZE),
	PDC_PAGE_SET		= PDC_DIMM_DATA_STEP / PDC_20621_PAGE_SIZE,

	PDC_CHIP0_OFS		= 0xC0000, /* offset of chip #0 */

	PDC_20621_ERR_MASK	= (1<<19) | (1<<20) | (1<<21) | (1<<22) |
				  (1<<23),

	board_20621		= 0,	/* FastTrak S150 SX4 */

141 142
	PDC_MASK_INT		= (1 << 10), /* HDMA/ATA mask int */
	PDC_RESET		= (1 << 11), /* HDMA/ATA reset */
143
	PDC_DMA_ENABLE		= (1 << 7),  /* DMA start/stop */
Linus Torvalds's avatar
Linus Torvalds committed
144 145 146 147

	PDC_MAX_HDMA		= 32,
	PDC_HDMA_Q_MASK		= (PDC_MAX_HDMA - 1),

148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
	PDC_DIMM0_SPD_DEV_ADDRESS	= 0x50,
	PDC_DIMM1_SPD_DEV_ADDRESS	= 0x51,
	PDC_I2C_CONTROL			= 0x48,
	PDC_I2C_ADDR_DATA		= 0x4C,
	PDC_DIMM0_CONTROL		= 0x80,
	PDC_DIMM1_CONTROL		= 0x84,
	PDC_SDRAM_CONTROL		= 0x88,
	PDC_I2C_WRITE			= 0,		/* master -> slave */
	PDC_I2C_READ			= (1 << 6),	/* master <- slave */
	PDC_I2C_START			= (1 << 7),	/* start I2C proto */
	PDC_I2C_MASK_INT		= (1 << 5),	/* mask I2C interrupt */
	PDC_I2C_COMPLETE		= (1 << 16),	/* I2C normal compl. */
	PDC_I2C_NO_ACK			= (1 << 20),	/* slave no-ack addr */
	PDC_DIMM_SPD_SUBADDRESS_START	= 0x00,
	PDC_DIMM_SPD_SUBADDRESS_END	= 0x7F,
	PDC_DIMM_SPD_ROW_NUM		= 3,
	PDC_DIMM_SPD_COLUMN_NUM		= 4,
	PDC_DIMM_SPD_MODULE_ROW		= 5,
	PDC_DIMM_SPD_TYPE		= 11,
	PDC_DIMM_SPD_FRESH_RATE		= 12,
	PDC_DIMM_SPD_BANK_NUM		= 17,
	PDC_DIMM_SPD_CAS_LATENCY	= 18,
	PDC_DIMM_SPD_ATTRIBUTE		= 21,
	PDC_DIMM_SPD_ROW_PRE_CHARGE	= 27,
	PDC_DIMM_SPD_ROW_ACTIVE_DELAY	= 28,
	PDC_DIMM_SPD_RAS_CAS_DELAY	= 29,
	PDC_DIMM_SPD_ACTIVE_PRECHARGE	= 30,
	PDC_DIMM_SPD_SYSTEM_FREQ	= 126,
	PDC_CTL_STATUS			= 0x08,
	PDC_DIMM_WINDOW_CTLR		= 0x0C,
	PDC_TIME_CONTROL		= 0x3C,
	PDC_TIME_PERIOD			= 0x40,
	PDC_TIME_COUNTER		= 0x44,
	PDC_GENERAL_CTLR		= 0x484,
	PCI_PLL_INIT			= 0x8A531824,
	PCI_X_TCOUNT			= 0xEE1E5CFF,

	/* PDC_TIME_CONTROL bits */
	PDC_TIMER_BUZZER		= (1 << 10),
	PDC_TIMER_MODE_PERIODIC		= 0,		/* bits 9:8 == 00 */
	PDC_TIMER_MODE_ONCE		= (1 << 8),	/* bits 9:8 == 01 */
	PDC_TIMER_ENABLE		= (1 << 7),
	PDC_TIMER_MASK_INT		= (1 << 5),
	PDC_TIMER_SEQ_MASK		= 0x1f,		/* SEQ ID for timer */
	PDC_TIMER_DEFAULT		= PDC_TIMER_MODE_ONCE |
					  PDC_TIMER_ENABLE |
					  PDC_TIMER_MASK_INT,
Linus Torvalds's avatar
Linus Torvalds committed
195 196
};

197
#define ECC_ERASE_BUF_SZ (128 * 1024)
Linus Torvalds's avatar
Linus Torvalds committed
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216

struct pdc_port_priv {
	u8			dimm_buf[(ATA_PRD_SZ * ATA_MAX_PRD) + 512];
	u8			*pkt;
	dma_addr_t		pkt_dma;
};

struct pdc_host_priv {
	unsigned int		doing_hdma;
	unsigned int		hdma_prod;
	unsigned int		hdma_cons;
	struct {
		struct ata_queued_cmd *qc;
		unsigned int	seq;
		unsigned long	pkt_ofs;
	} hdma[32];
};


217
static int pdc_sata_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
218 219 220
static void pdc_error_handler(struct ata_port *ap);
static void pdc_freeze(struct ata_port *ap);
static void pdc_thaw(struct ata_port *ap);
Linus Torvalds's avatar
Linus Torvalds committed
221 222
static int pdc_port_start(struct ata_port *ap);
static void pdc20621_qc_prep(struct ata_queued_cmd *qc);
223 224
static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
225 226 227
static unsigned int pdc20621_dimm_init(struct ata_host *host);
static int pdc20621_detect_dimm(struct ata_host *host);
static unsigned int pdc20621_i2c_read(struct ata_host *host,
Linus Torvalds's avatar
Linus Torvalds committed
228
				      u32 device, u32 subaddr, u32 *pdata);
229 230
static int pdc20621_prog_dimm0(struct ata_host *host);
static unsigned int pdc20621_prog_dimm_global(struct ata_host *host);
Linus Torvalds's avatar
Linus Torvalds committed
231
#ifdef ATA_VERBOSE_DEBUG
232
static void pdc20621_get_from_dimm(struct ata_host *host,
Linus Torvalds's avatar
Linus Torvalds committed
233 234
				   void *psource, u32 offset, u32 size);
#endif
235
static void pdc20621_put_to_dimm(struct ata_host *host,
Linus Torvalds's avatar
Linus Torvalds committed
236 237
				 void *psource, u32 offset, u32 size);
static void pdc20621_irq_clear(struct ata_port *ap);
Tejun Heo's avatar
Tejun Heo committed
238
static unsigned int pdc20621_qc_issue(struct ata_queued_cmd *qc);
239 240 241 242
static int pdc_softreset(struct ata_link *link, unsigned int *class,
			 unsigned long deadline);
static void pdc_post_internal_cmd(struct ata_queued_cmd *qc);
static int pdc_check_atapi_dma(struct ata_queued_cmd *qc);
Linus Torvalds's avatar
Linus Torvalds committed
243 244


245
static struct scsi_host_template pdc_sata_sht = {
246
	ATA_BASE_SHT(DRV_NAME),
Linus Torvalds's avatar
Linus Torvalds committed
247 248 249 250
	.sg_tablesize		= LIBATA_MAX_PRD,
	.dma_boundary		= ATA_DMA_BOUNDARY,
};

251 252
/* TODO: inherit from base port_ops after converting to new EH */
static struct ata_port_operations pdc_20621_ops = {
253 254 255
	.inherits		= &ata_sff_port_ops,

	.check_atapi_dma	= pdc_check_atapi_dma,
Linus Torvalds's avatar
Linus Torvalds committed
256
	.qc_prep		= pdc20621_qc_prep,
Tejun Heo's avatar
Tejun Heo committed
257
	.qc_issue		= pdc20621_qc_issue,
258 259 260 261 262 263 264 265

	.freeze			= pdc_freeze,
	.thaw			= pdc_thaw,
	.softreset		= pdc_softreset,
	.error_handler		= pdc_error_handler,
	.lost_interrupt		= ATA_OP_NULL,
	.post_internal_cmd	= pdc_post_internal_cmd,

Linus Torvalds's avatar
Linus Torvalds committed
266
	.port_start		= pdc_port_start,
267 268 269 270

	.sff_tf_load		= pdc_tf_load_mmio,
	.sff_exec_command	= pdc_exec_command_mmio,
	.sff_irq_clear		= pdc20621_irq_clear,
Linus Torvalds's avatar
Linus Torvalds committed
271 272
};

273
static const struct ata_port_info pdc_port_info[] = {
Linus Torvalds's avatar
Linus Torvalds committed
274 275
	/* board_20621 */
	{
276 277
		.flags		= ATA_FLAG_SATA | ATA_FLAG_NO_ATAPI |
				  ATA_FLAG_PIO_POLLING,
278 279
		.pio_mask	= ATA_PIO4,
		.mwdma_mask	= ATA_MWDMA2,
280
		.udma_mask	= ATA_UDMA6,
Linus Torvalds's avatar
Linus Torvalds committed
281 282 283 284 285
		.port_ops	= &pdc_20621_ops,
	},

};

286
static const struct pci_device_id pdc_sata_pci_tbl[] = {
287 288
	{ PCI_VDEVICE(PROMISE, 0x6622), board_20621 },

Linus Torvalds's avatar
Linus Torvalds committed
289 290 291 292 293 294 295 296 297 298 299 300 301
	{ }	/* terminate list */
};

static struct pci_driver pdc_sata_pci_driver = {
	.name			= DRV_NAME,
	.id_table		= pdc_sata_pci_tbl,
	.probe			= pdc_sata_init_one,
	.remove			= ata_pci_remove_one,
};


static int pdc_port_start(struct ata_port *ap)
{
Jeff Garzik's avatar
Jeff Garzik committed
302
	struct device *dev = ap->host->dev;
Linus Torvalds's avatar
Linus Torvalds committed
303 304
	struct pdc_port_priv *pp;

305 306 307
	pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
	if (!pp)
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
308

309 310 311
	pp->pkt = dmam_alloc_coherent(dev, 128, &pp->pkt_dma, GFP_KERNEL);
	if (!pp->pkt)
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
312 313 314 315 316 317

	ap->private_data = pp;

	return 0;
}

318 319
static inline void pdc20621_ata_sg(u8 *buf, unsigned int portno,
				   unsigned int total_len)
Linus Torvalds's avatar
Linus Torvalds committed
320 321 322
{
	u32 addr;
	unsigned int dw = PDC_DIMM_APKT_PRD >> 2;
Al Viro's avatar
Al Viro committed
323
	__le32 *buf32 = (__le32 *) buf;
Linus Torvalds's avatar
Linus Torvalds committed
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338

	/* output ATA packet S/G table */
	addr = PDC_20621_DIMM_BASE + PDC_20621_DIMM_DATA +
	       (PDC_DIMM_DATA_STEP * portno);
	VPRINTK("ATA sg addr 0x%x, %d\n", addr, addr);
	buf32[dw] = cpu_to_le32(addr);
	buf32[dw + 1] = cpu_to_le32(total_len | ATA_PRD_EOT);

	VPRINTK("ATA PSG @ %x == (0x%x, 0x%x)\n",
		PDC_20621_DIMM_BASE +
		       (PDC_DIMM_WINDOW_STEP * portno) +
		       PDC_DIMM_APKT_PRD,
		buf32[dw], buf32[dw + 1]);
}

339 340
static inline void pdc20621_host_sg(u8 *buf, unsigned int portno,
				    unsigned int total_len)
Linus Torvalds's avatar
Linus Torvalds committed
341 342 343
{
	u32 addr;
	unsigned int dw = PDC_DIMM_HPKT_PRD >> 2;
Al Viro's avatar
Al Viro committed
344
	__le32 *buf32 = (__le32 *) buf;
Linus Torvalds's avatar
Linus Torvalds committed
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364

	/* output Host DMA packet S/G table */
	addr = PDC_20621_DIMM_BASE + PDC_20621_DIMM_DATA +
	       (PDC_DIMM_DATA_STEP * portno);

	buf32[dw] = cpu_to_le32(addr);
	buf32[dw + 1] = cpu_to_le32(total_len | ATA_PRD_EOT);

	VPRINTK("HOST PSG @ %x == (0x%x, 0x%x)\n",
		PDC_20621_DIMM_BASE +
		       (PDC_DIMM_WINDOW_STEP * portno) +
		       PDC_DIMM_HPKT_PRD,
		buf32[dw], buf32[dw + 1]);
}

static inline unsigned int pdc20621_ata_pkt(struct ata_taskfile *tf,
					    unsigned int devno, u8 *buf,
					    unsigned int portno)
{
	unsigned int i, dw;
Al Viro's avatar
Al Viro committed
365
	__le32 *buf32 = (__le32 *) buf;
Linus Torvalds's avatar
Linus Torvalds committed
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416
	u8 dev_reg;

	unsigned int dimm_sg = PDC_20621_DIMM_BASE +
			       (PDC_DIMM_WINDOW_STEP * portno) +
			       PDC_DIMM_APKT_PRD;
	VPRINTK("ENTER, dimm_sg == 0x%x, %d\n", dimm_sg, dimm_sg);

	i = PDC_DIMM_ATA_PKT;

	/*
	 * Set up ATA packet
	 */
	if ((tf->protocol == ATA_PROT_DMA) && (!(tf->flags & ATA_TFLAG_WRITE)))
		buf[i++] = PDC_PKT_READ;
	else if (tf->protocol == ATA_PROT_NODATA)
		buf[i++] = PDC_PKT_NODATA;
	else
		buf[i++] = 0;
	buf[i++] = 0;			/* reserved */
	buf[i++] = portno + 1;		/* seq. id */
	buf[i++] = 0xff;		/* delay seq. id */

	/* dimm dma S/G, and next-pkt */
	dw = i >> 2;
	if (tf->protocol == ATA_PROT_NODATA)
		buf32[dw] = 0;
	else
		buf32[dw] = cpu_to_le32(dimm_sg);
	buf32[dw + 1] = 0;
	i += 8;

	if (devno == 0)
		dev_reg = ATA_DEVICE_OBS;
	else
		dev_reg = ATA_DEVICE_OBS | ATA_DEV1;

	/* select device */
	buf[i++] = (1 << 5) | PDC_PKT_CLEAR_BSY | ATA_REG_DEVICE;
	buf[i++] = dev_reg;

	/* device control register */
	buf[i++] = (1 << 5) | PDC_REG_DEVCTL;
	buf[i++] = tf->ctl;

	return i;
}

static inline void pdc20621_host_pkt(struct ata_taskfile *tf, u8 *buf,
				     unsigned int portno)
{
	unsigned int dw;
Al Viro's avatar
Al Viro committed
417 418
	u32 tmp;
	__le32 *buf32 = (__le32 *) buf;
Linus Torvalds's avatar
Linus Torvalds committed
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455

	unsigned int host_sg = PDC_20621_DIMM_BASE +
			       (PDC_DIMM_WINDOW_STEP * portno) +
			       PDC_DIMM_HOST_PRD;
	unsigned int dimm_sg = PDC_20621_DIMM_BASE +
			       (PDC_DIMM_WINDOW_STEP * portno) +
			       PDC_DIMM_HPKT_PRD;
	VPRINTK("ENTER, dimm_sg == 0x%x, %d\n", dimm_sg, dimm_sg);
	VPRINTK("host_sg == 0x%x, %d\n", host_sg, host_sg);

	dw = PDC_DIMM_HOST_PKT >> 2;

	/*
	 * Set up Host DMA packet
	 */
	if ((tf->protocol == ATA_PROT_DMA) && (!(tf->flags & ATA_TFLAG_WRITE)))
		tmp = PDC_PKT_READ;
	else
		tmp = 0;
	tmp |= ((portno + 1 + 4) << 16);	/* seq. id */
	tmp |= (0xff << 24);			/* delay seq. id */
	buf32[dw + 0] = cpu_to_le32(tmp);
	buf32[dw + 1] = cpu_to_le32(host_sg);
	buf32[dw + 2] = cpu_to_le32(dimm_sg);
	buf32[dw + 3] = 0;

	VPRINTK("HOST PKT @ %x == (0x%x 0x%x 0x%x 0x%x)\n",
		PDC_20621_DIMM_BASE + (PDC_DIMM_WINDOW_STEP * portno) +
			PDC_DIMM_HOST_PKT,
		buf32[dw + 0],
		buf32[dw + 1],
		buf32[dw + 2],
		buf32[dw + 3]);
}

static void pdc20621_dma_prep(struct ata_queued_cmd *qc)
{
456
	struct scatterlist *sg;
Linus Torvalds's avatar
Linus Torvalds committed
457 458
	struct ata_port *ap = qc->ap;
	struct pdc_port_priv *pp = ap->private_data;
Tejun Heo's avatar
Tejun Heo committed
459 460
	void __iomem *mmio = ap->host->iomap[PDC_MMIO_BAR];
	void __iomem *dimm_mmio = ap->host->iomap[PDC_DIMM_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
461
	unsigned int portno = ap->port_no;
462
	unsigned int i, si, idx, total_len = 0, sgt_len;
Al Viro's avatar
Al Viro committed
463
	__le32 *buf = (__le32 *) &pp->dimm_buf[PDC_DIMM_HEADER_SZ];
Linus Torvalds's avatar
Linus Torvalds committed
464

465
	WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
Linus Torvalds's avatar
Linus Torvalds committed
466

467
	VPRINTK("ata%u: ENTER\n", ap->print_id);
Linus Torvalds's avatar
Linus Torvalds committed
468 469 470 471 472 473 474 475

	/* hard-code chip #0 */
	mmio += PDC_CHIP0_OFS;

	/*
	 * Build S/G table
	 */
	idx = 0;
476
	for_each_sg(qc->sg, sg, qc->n_elem, si) {
477 478 479
		buf[idx++] = cpu_to_le32(sg_dma_address(sg));
		buf[idx++] = cpu_to_le32(sg_dma_len(sg));
		total_len += sg_dma_len(sg);
Linus Torvalds's avatar
Linus Torvalds committed
480 481 482 483 484 485 486
	}
	buf[idx - 1] |= cpu_to_le32(ATA_PRD_EOT);
	sgt_len = idx * 4;

	/*
	 * Build ATA, host DMA packets
	 */
487
	pdc20621_host_sg(&pp->dimm_buf[0], portno, total_len);
Linus Torvalds's avatar
Linus Torvalds committed
488 489
	pdc20621_host_pkt(&qc->tf, &pp->dimm_buf[0], portno);

490
	pdc20621_ata_sg(&pp->dimm_buf[0], portno, total_len);
Linus Torvalds's avatar
Linus Torvalds committed
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
	i = pdc20621_ata_pkt(&qc->tf, qc->dev->devno, &pp->dimm_buf[0], portno);

	if (qc->tf.flags & ATA_TFLAG_LBA48)
		i = pdc_prep_lba48(&qc->tf, &pp->dimm_buf[0], i);
	else
		i = pdc_prep_lba28(&qc->tf, &pp->dimm_buf[0], i);

	pdc_pkt_footer(&qc->tf, &pp->dimm_buf[0], i);

	/* copy three S/G tables and two packets to DIMM MMIO window */
	memcpy_toio(dimm_mmio + (portno * PDC_DIMM_WINDOW_STEP),
		    &pp->dimm_buf, PDC_DIMM_HEADER_SZ);
	memcpy_toio(dimm_mmio + (portno * PDC_DIMM_WINDOW_STEP) +
		    PDC_DIMM_HOST_PRD,
		    &pp->dimm_buf[PDC_DIMM_HEADER_SZ], sgt_len);

	/* force host FIFO dump */
	writel(0x00000001, mmio + PDC_20621_GENERAL_CTL);

	readl(dimm_mmio);	/* MMIO PCI posting flush */

	VPRINTK("ata pkt buf ofs %u, prd size %u, mmio copied\n", i, sgt_len);
}

static void pdc20621_nodata_prep(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
	struct pdc_port_priv *pp = ap->private_data;
Tejun Heo's avatar
Tejun Heo committed
519 520
	void __iomem *mmio = ap->host->iomap[PDC_MMIO_BAR];
	void __iomem *dimm_mmio = ap->host->iomap[PDC_DIMM_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
521 522 523
	unsigned int portno = ap->port_no;
	unsigned int i;

524
	VPRINTK("ata%u: ENTER\n", ap->print_id);
Linus Torvalds's avatar
Linus Torvalds committed
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568

	/* hard-code chip #0 */
	mmio += PDC_CHIP0_OFS;

	i = pdc20621_ata_pkt(&qc->tf, qc->dev->devno, &pp->dimm_buf[0], portno);

	if (qc->tf.flags & ATA_TFLAG_LBA48)
		i = pdc_prep_lba48(&qc->tf, &pp->dimm_buf[0], i);
	else
		i = pdc_prep_lba28(&qc->tf, &pp->dimm_buf[0], i);

	pdc_pkt_footer(&qc->tf, &pp->dimm_buf[0], i);

	/* copy three S/G tables and two packets to DIMM MMIO window */
	memcpy_toio(dimm_mmio + (portno * PDC_DIMM_WINDOW_STEP),
		    &pp->dimm_buf, PDC_DIMM_HEADER_SZ);

	/* force host FIFO dump */
	writel(0x00000001, mmio + PDC_20621_GENERAL_CTL);

	readl(dimm_mmio);	/* MMIO PCI posting flush */

	VPRINTK("ata pkt buf ofs %u, mmio copied\n", i);
}

static void pdc20621_qc_prep(struct ata_queued_cmd *qc)
{
	switch (qc->tf.protocol) {
	case ATA_PROT_DMA:
		pdc20621_dma_prep(qc);
		break;
	case ATA_PROT_NODATA:
		pdc20621_nodata_prep(qc);
		break;
	default:
		break;
	}
}

static void __pdc20621_push_hdma(struct ata_queued_cmd *qc,
				 unsigned int seq,
				 u32 pkt_ofs)
{
	struct ata_port *ap = qc->ap;
Jeff Garzik's avatar
Jeff Garzik committed
569
	struct ata_host *host = ap->host;
Tejun Heo's avatar
Tejun Heo committed
570
	void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586

	/* hard-code chip #0 */
	mmio += PDC_CHIP0_OFS;

	writel(0x00000001, mmio + PDC_20621_SEQCTL + (seq * 4));
	readl(mmio + PDC_20621_SEQCTL + (seq * 4));	/* flush */

	writel(pkt_ofs, mmio + PDC_HDMA_PKT_SUBMIT);
	readl(mmio + PDC_HDMA_PKT_SUBMIT);	/* flush */
}

static void pdc20621_push_hdma(struct ata_queued_cmd *qc,
				unsigned int seq,
				u32 pkt_ofs)
{
	struct ata_port *ap = qc->ap;
Jeff Garzik's avatar
Jeff Garzik committed
587
	struct pdc_host_priv *pp = ap->host->private_data;
Linus Torvalds's avatar
Linus Torvalds committed
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604
	unsigned int idx = pp->hdma_prod & PDC_HDMA_Q_MASK;

	if (!pp->doing_hdma) {
		__pdc20621_push_hdma(qc, seq, pkt_ofs);
		pp->doing_hdma = 1;
		return;
	}

	pp->hdma[idx].qc = qc;
	pp->hdma[idx].seq = seq;
	pp->hdma[idx].pkt_ofs = pkt_ofs;
	pp->hdma_prod++;
}

static void pdc20621_pop_hdma(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
Jeff Garzik's avatar
Jeff Garzik committed
605
	struct pdc_host_priv *pp = ap->host->private_data;
Linus Torvalds's avatar
Linus Torvalds committed
606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623
	unsigned int idx = pp->hdma_cons & PDC_HDMA_Q_MASK;

	/* if nothing on queue, we're done */
	if (pp->hdma_prod == pp->hdma_cons) {
		pp->doing_hdma = 0;
		return;
	}

	__pdc20621_push_hdma(pp->hdma[idx].qc, pp->hdma[idx].seq,
			     pp->hdma[idx].pkt_ofs);
	pp->hdma_cons++;
}

#ifdef ATA_VERBOSE_DEBUG
static void pdc20621_dump_hdma(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
	unsigned int port_no = ap->port_no;
Tejun Heo's avatar
Tejun Heo committed
624
	void __iomem *dimm_mmio = ap->host->iomap[PDC_DIMM_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640

	dimm_mmio += (port_no * PDC_DIMM_WINDOW_STEP);
	dimm_mmio += PDC_DIMM_HOST_PKT;

	printk(KERN_ERR "HDMA[0] == 0x%08X\n", readl(dimm_mmio));
	printk(KERN_ERR "HDMA[1] == 0x%08X\n", readl(dimm_mmio + 4));
	printk(KERN_ERR "HDMA[2] == 0x%08X\n", readl(dimm_mmio + 8));
	printk(KERN_ERR "HDMA[3] == 0x%08X\n", readl(dimm_mmio + 12));
}
#else
static inline void pdc20621_dump_hdma(struct ata_queued_cmd *qc) { }
#endif /* ATA_VERBOSE_DEBUG */

static void pdc20621_packet_start(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
Jeff Garzik's avatar
Jeff Garzik committed
641
	struct ata_host *host = ap->host;
Linus Torvalds's avatar
Linus Torvalds committed
642
	unsigned int port_no = ap->port_no;
Tejun Heo's avatar
Tejun Heo committed
643
	void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
644 645 646 647 648 649 650
	unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
	u8 seq = (u8) (port_no + 1);
	unsigned int port_ofs;

	/* hard-code chip #0 */
	mmio += PDC_CHIP0_OFS;

651
	VPRINTK("ata%u: ENTER\n", ap->print_id);
Linus Torvalds's avatar
Linus Torvalds committed
652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671

	wmb();			/* flush PRD, pkt writes */

	port_ofs = PDC_20621_DIMM_BASE + (PDC_DIMM_WINDOW_STEP * port_no);

	/* if writing, we (1) DMA to DIMM, then (2) do ATA command */
	if (rw && qc->tf.protocol == ATA_PROT_DMA) {
		seq += 4;

		pdc20621_dump_hdma(qc);
		pdc20621_push_hdma(qc, seq, port_ofs + PDC_DIMM_HOST_PKT);
		VPRINTK("queued ofs 0x%x (%u), seq %u\n",
			port_ofs + PDC_DIMM_HOST_PKT,
			port_ofs + PDC_DIMM_HOST_PKT,
			seq);
	} else {
		writel(0x00000001, mmio + PDC_20621_SEQCTL + (seq * 4));
		readl(mmio + PDC_20621_SEQCTL + (seq * 4));	/* flush */

		writel(port_ofs + PDC_DIMM_ATA_PKT,
Tejun Heo's avatar
Tejun Heo committed
672 673
		       ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
		readl(ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
Linus Torvalds's avatar
Linus Torvalds committed
674 675 676 677 678 679 680
		VPRINTK("submitted ofs 0x%x (%u), seq %u\n",
			port_ofs + PDC_DIMM_ATA_PKT,
			port_ofs + PDC_DIMM_ATA_PKT,
			seq);
	}
}

Tejun Heo's avatar
Tejun Heo committed
681
static unsigned int pdc20621_qc_issue(struct ata_queued_cmd *qc)
Linus Torvalds's avatar
Linus Torvalds committed
682 683 684
{
	switch (qc->tf.protocol) {
	case ATA_PROT_NODATA:
685 686 687 688
		if (qc->tf.flags & ATA_TFLAG_POLLING)
			break;
		/*FALLTHROUGH*/
	case ATA_PROT_DMA:
Linus Torvalds's avatar
Linus Torvalds committed
689 690 691
		pdc20621_packet_start(qc);
		return 0;

692
	case ATAPI_PROT_DMA:
Linus Torvalds's avatar
Linus Torvalds committed
693 694 695 696 697 698 699
		BUG();
		break;

	default:
		break;
	}

Tejun Heo's avatar
Tejun Heo committed
700
	return ata_sff_qc_issue(qc);
Linus Torvalds's avatar
Linus Torvalds committed
701 702
}

703 704
static inline unsigned int pdc20621_host_intr(struct ata_port *ap,
					  struct ata_queued_cmd *qc,
Linus Torvalds's avatar
Linus Torvalds committed
705
					  unsigned int doing_hdma,
706
					  void __iomem *mmio)
Linus Torvalds's avatar
Linus Torvalds committed
707 708 709 710 711 712 713 714 715 716 717 718 719 720
{
	unsigned int port_no = ap->port_no;
	unsigned int port_ofs =
		PDC_20621_DIMM_BASE + (PDC_DIMM_WINDOW_STEP * port_no);
	u8 status;
	unsigned int handled = 0;

	VPRINTK("ENTER\n");

	if ((qc->tf.protocol == ATA_PROT_DMA) &&	/* read */
	    (!(qc->tf.flags & ATA_TFLAG_WRITE))) {

		/* step two - DMA from DIMM to host */
		if (doing_hdma) {
721
			VPRINTK("ata%u: read hdma, 0x%x 0x%x\n", ap->print_id,
Linus Torvalds's avatar
Linus Torvalds committed
722 723
				readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));
			/* get drive status; clear intr; complete txn */
724 725
			qc->err_mask |= ac_err_mask(ata_wait_idle(ap));
			ata_qc_complete(qc);
Linus Torvalds's avatar
Linus Torvalds committed
726 727 728 729 730 731
			pdc20621_pop_hdma(qc);
		}

		/* step one - exec ATA command */
		else {
			u8 seq = (u8) (port_no + 1 + 4);
732
			VPRINTK("ata%u: read ata, 0x%x 0x%x\n", ap->print_id,
Linus Torvalds's avatar
Linus Torvalds committed
733 734 735 736 737 738 739 740 741 742 743 744 745 746
				readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));

			/* submit hdma pkt */
			pdc20621_dump_hdma(qc);
			pdc20621_push_hdma(qc, seq,
					   port_ofs + PDC_DIMM_HOST_PKT);
		}
		handled = 1;

	} else if (qc->tf.protocol == ATA_PROT_DMA) {	/* write */

		/* step one - DMA from host to DIMM */
		if (doing_hdma) {
			u8 seq = (u8) (port_no + 1);
747
			VPRINTK("ata%u: write hdma, 0x%x 0x%x\n", ap->print_id,
Linus Torvalds's avatar
Linus Torvalds committed
748 749 750 751 752 753
				readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));

			/* submit ata pkt */
			writel(0x00000001, mmio + PDC_20621_SEQCTL + (seq * 4));
			readl(mmio + PDC_20621_SEQCTL + (seq * 4));
			writel(port_ofs + PDC_DIMM_ATA_PKT,
Tejun Heo's avatar
Tejun Heo committed
754 755
			       ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
			readl(ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
Linus Torvalds's avatar
Linus Torvalds committed
756 757 758 759
		}

		/* step two - execute ATA command */
		else {
760
			VPRINTK("ata%u: write ata, 0x%x 0x%x\n", ap->print_id,
Linus Torvalds's avatar
Linus Torvalds committed
761 762
				readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));
			/* get drive status; clear intr; complete txn */
763 764
			qc->err_mask |= ac_err_mask(ata_wait_idle(ap));
			ata_qc_complete(qc);
Linus Torvalds's avatar
Linus Torvalds committed
765 766 767 768 769 770 771
			pdc20621_pop_hdma(qc);
		}
		handled = 1;

	/* command completion, but no data xfer */
	} else if (qc->tf.protocol == ATA_PROT_NODATA) {

Tejun Heo's avatar
Tejun Heo committed
772
		status = ata_sff_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
Linus Torvalds's avatar
Linus Torvalds committed
773
		DPRINTK("BUS_NODATA (drv_stat 0x%X)\n", status);
774 775
		qc->err_mask |= ac_err_mask(status);
		ata_qc_complete(qc);
Linus Torvalds's avatar
Linus Torvalds committed
776 777 778 779 780 781 782 783 784 785 786
		handled = 1;

	} else {
		ap->stats.idle_irq++;
	}

	return handled;
}

static void pdc20621_irq_clear(struct ata_port *ap)
{
787
	ioread8(ap->ioaddr.status_addr);
Linus Torvalds's avatar
Linus Torvalds committed
788 789
}

790
static irqreturn_t pdc20621_interrupt(int irq, void *dev_instance)
Linus Torvalds's avatar
Linus Torvalds committed
791
{
Jeff Garzik's avatar
Jeff Garzik committed
792
	struct ata_host *host = dev_instance;
Linus Torvalds's avatar
Linus Torvalds committed
793 794 795 796
	struct ata_port *ap;
	u32 mask = 0;
	unsigned int i, tmp, port_no;
	unsigned int handled = 0;
797
	void __iomem *mmio_base;
Linus Torvalds's avatar
Linus Torvalds committed
798 799 800

	VPRINTK("ENTER\n");

Tejun Heo's avatar
Tejun Heo committed
801
	if (!host || !host->iomap[PDC_MMIO_BAR]) {
Linus Torvalds's avatar
Linus Torvalds committed
802 803 804 805
		VPRINTK("QUICK EXIT\n");
		return IRQ_NONE;
	}

Tejun Heo's avatar
Tejun Heo committed
806
	mmio_base = host->iomap[PDC_MMIO_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822

	/* reading should also clear interrupts */
	mmio_base += PDC_CHIP0_OFS;
	mask = readl(mmio_base + PDC_20621_SEQMASK);
	VPRINTK("mask == 0x%x\n", mask);

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

823
	spin_lock(&host->lock);
Linus Torvalds's avatar
Linus Torvalds committed
824

825
	for (i = 1; i < 9; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
826 827 828
		port_no = i - 1;
		if (port_no > 3)
			port_no -= 4;
Jeff Garzik's avatar
Jeff Garzik committed
829
		if (port_no >= host->n_ports)
Linus Torvalds's avatar
Linus Torvalds committed
830 831
			ap = NULL;
		else
Jeff Garzik's avatar
Jeff Garzik committed
832
			ap = host->ports[port_no];
Linus Torvalds's avatar
Linus Torvalds committed
833 834
		tmp = mask & (1 << i);
		VPRINTK("seq %u, port_no %u, ap %p, tmp %x\n", i, port_no, ap, tmp);
835
		if (tmp && ap) {
Linus Torvalds's avatar
Linus Torvalds committed
836 837
			struct ata_queued_cmd *qc;

838
			qc = ata_qc_from_tag(ap, ap->link.active_tag);
839
			if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
Linus Torvalds's avatar
Linus Torvalds committed
840 841 842 843 844
				handled += pdc20621_host_intr(ap, qc, (i > 4),
							      mmio_base);
		}
	}

845
	spin_unlock(&host->lock);
Linus Torvalds's avatar
Linus Torvalds committed
846 847 848 849 850 851 852 853

	VPRINTK("mask == 0x%x\n", mask);

	VPRINTK("EXIT\n");

	return IRQ_RETVAL(handled);
}

854
static void pdc_freeze(struct ata_port *ap)
Linus Torvalds's avatar
Linus Torvalds committed
855
{
856 857
	void __iomem *mmio = ap->ioaddr.cmd_addr;
	u32 tmp;
Linus Torvalds's avatar
Linus Torvalds committed
858

859
	/* FIXME: if all 4 ATA engines are stopped, also stop HDMA engine */
Linus Torvalds's avatar
Linus Torvalds committed
860

861 862 863 864 865 866
	tmp = readl(mmio + PDC_CTLSTAT);
	tmp |= PDC_MASK_INT;
	tmp &= ~PDC_DMA_ENABLE;
	writel(tmp, mmio + PDC_CTLSTAT);
	readl(mmio + PDC_CTLSTAT); /* flush */
}
Jeff Garzik's avatar
Jeff Garzik committed
867

868 869 870 871
static void pdc_thaw(struct ata_port *ap)
{
	void __iomem *mmio = ap->ioaddr.cmd_addr;
	u32 tmp;
Linus Torvalds's avatar
Linus Torvalds committed
872

873
	/* FIXME: start HDMA engine, if zero ATA engines running */
Linus Torvalds's avatar
Linus Torvalds committed
874

875 876
	/* clear IRQ */
	ioread8(ap->ioaddr.status_addr);
Linus Torvalds's avatar
Linus Torvalds committed
877

878 879 880 881 882 883
	/* turn IRQ back on */
	tmp = readl(mmio + PDC_CTLSTAT);
	tmp &= ~PDC_MASK_INT;
	writel(tmp, mmio + PDC_CTLSTAT);
	readl(mmio + PDC_CTLSTAT); /* flush */
}
Linus Torvalds's avatar
Linus Torvalds committed
884

885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901
static void pdc_reset_port(struct ata_port *ap)
{
	void __iomem *mmio = ap->ioaddr.cmd_addr + PDC_CTLSTAT;
	unsigned int i;
	u32 tmp;

	/* FIXME: handle HDMA copy engine */

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

		udelay(100);

		tmp |= PDC_RESET;
		writel(tmp, mmio);
Linus Torvalds's avatar
Linus Torvalds committed
902 903
	}

904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920
	tmp &= ~PDC_RESET;
	writel(tmp, mmio);
	readl(mmio);	/* flush */
}

static int pdc_softreset(struct ata_link *link, unsigned int *class,
			 unsigned long deadline)
{
	pdc_reset_port(link->ap);
	return ata_sff_softreset(link, class, deadline);
}

static void pdc_error_handler(struct ata_port *ap)
{
	if (!(ap->pflags & ATA_PFLAG_FROZEN))
		pdc_reset_port(ap);

921
	ata_sff_error_handler(ap);
922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960
}

static void pdc_post_internal_cmd(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;

	/* make DMA engine forget about the failed command */
	if (qc->flags & ATA_QCFLAG_FAILED)
		pdc_reset_port(ap);
}

static int pdc_check_atapi_dma(struct ata_queued_cmd *qc)
{
	u8 *scsicmd = qc->scsicmd->cmnd;
	int pio = 1; /* atapi dma off by default */

	/* Whitelist commands that may use DMA. */
	switch (scsicmd[0]) {
	case WRITE_12:
	case WRITE_10:
	case WRITE_6:
	case READ_12:
	case READ_10:
	case READ_6:
	case 0xad: /* READ_DVD_STRUCTURE */
	case 0xbe: /* READ_CD */
		pio = 0;
	}
	/* -45150 (FFFF4FA2) to -1 (FFFFFFFF) shall use PIO mode */
	if (scsicmd[0] == WRITE_10) {
		unsigned int lba =
			(scsicmd[2] << 24) |
			(scsicmd[3] << 16) |
			(scsicmd[4] << 8) |
			scsicmd[5];
		if (lba >= 0xFFFF4FA2)
			pio = 1;
	}
	return pio;
Linus Torvalds's avatar
Linus Torvalds committed
961 962
}

963
static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
Linus Torvalds's avatar
Linus Torvalds committed
964
{
965
	WARN_ON(tf->protocol == ATA_PROT_DMA ||
966
		tf->protocol == ATAPI_PROT_DMA);
Tejun Heo's avatar
Tejun Heo committed
967
	ata_sff_tf_load(ap, tf);
Linus Torvalds's avatar
Linus Torvalds committed
968 969 970
}


971
static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
Linus Torvalds's avatar
Linus Torvalds committed
972
{
973
	WARN_ON(tf->protocol == ATA_PROT_DMA ||
974
		tf->protocol == ATAPI_PROT_DMA);
Tejun Heo's avatar
Tejun Heo committed
975
	ata_sff_exec_command(ap, tf);
Linus Torvalds's avatar
Linus Torvalds committed
976 977 978
}


Tejun Heo's avatar
Tejun Heo committed
979
static void pdc_sata_setup_port(struct ata_ioports *port, void __iomem *base)
Linus Torvalds's avatar
Linus Torvalds committed
980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997
{
	port->cmd_addr		= base;
	port->data_addr		= base;
	port->feature_addr	=
	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;
	port->command_addr	=
	port->status_addr	= base + 0x1c;
	port->altstatus_addr	=
	port->ctl_addr		= base + 0x38;
}


#ifdef ATA_VERBOSE_DEBUG
998
static void pdc20621_get_from_dimm(struct ata_host *host, void *psource,
Linus Torvalds's avatar
Linus Torvalds committed
999 1000 1001 1002 1003 1004
				   u32 offset, u32 size)
{
	u32 window_size;
	u16 idx;
	u8 page_mask;
	long dist;
1005 1006
	void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
	void __iomem *dimm_mmio = host->iomap[PDC_DIMM_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
1007 1008 1009 1010

	/* hard-code chip #0 */
	mmio += PDC_CHIP0_OFS;

1011
	page_mask = 0x00;
1012
	window_size = 0x2000 * 4; /* 32K byte uchar size */
1013
	idx = (u16) (offset / window_size);
Linus Torvalds's avatar
Linus Torvalds committed
1014 1015 1016 1017 1018 1019 1020 1021

	writel(0x01, mmio + PDC_GENERAL_CTLR);
	readl(mmio + PDC_GENERAL_CTLR);
	writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
	readl(mmio + PDC_DIMM_WINDOW_CTLR);

	offset -= (idx * window_size);
	idx++;
1022
	dist = ((long) (window_size - (offset + size))) >= 0 ? size :
Linus Torvalds's avatar
Linus Torvalds committed
1023
		(long) (window_size - offset);
1024
	memcpy_fromio((char *) psource, (char *) (dimm_mmio + offset / 4),
Linus Torvalds's avatar
Linus Torvalds committed
1025 1026
		      dist);

1027
	psource += dist;
Linus Torvalds's avatar
Linus Torvalds committed
1028 1029 1030 1031 1032 1033
	size -= dist;
	for (; (long) size >= (long) window_size ;) {
		writel(0x01, mmio + PDC_GENERAL_CTLR);
		readl(mmio + PDC_GENERAL_CTLR);
		writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
		readl(mmio + PDC_DIMM_WINDOW_CTLR);
1034
		memcpy_fromio((char *) psource, (char *) (dimm_mmio),
Linus Torvalds's avatar
Linus Torvalds committed
1035 1036 1037
			      window_size / 4);
		psource += window_size;
		size -= window_size;
1038
		idx++;
Linus Torvalds's avatar
Linus Torvalds committed
1039 1040 1041 1042 1043 1044 1045
	}

	if (size) {
		writel(0x01, mmio + PDC_GENERAL_CTLR);
		readl(mmio + PDC_GENERAL_CTLR);
		writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
		readl(mmio + PDC_DIMM_WINDOW_CTLR);
1046
		memcpy_fromio((char *) psource, (char *) (dimm_mmio),
Linus Torvalds's avatar
Linus Torvalds committed
1047 1048 1049 1050 1051 1052
			      size / 4);
	}
}
#endif


1053
static void pdc20621_put_to_dimm(struct ata_host *host, void *psource,
Linus Torvalds's avatar
Linus Torvalds committed
1054 1055 1056 1057 1058 1059
				 u32 offset, u32 size)
{
	u32 window_size;
	u16 idx;
	u8 page_mask;
	long dist;
1060 1061
	void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
	void __iomem *dimm_mmio = host->iomap[PDC_DIMM_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
1062

1063
	/* hard-code chip #0 */
Linus Torvalds's avatar
Linus Torvalds committed
1064 1065
	mmio += PDC_CHIP0_OFS;

1066
	page_mask = 0x00;
1067
	window_size = 0x2000 * 4;       /* 32K byte uchar size */
Linus Torvalds's avatar
Linus Torvalds committed
1068 1069 1070 1071
	idx = (u16) (offset / window_size);

	writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
	readl(mmio + PDC_DIMM_WINDOW_CTLR);
1072
	offset -= (idx * window_size);
Linus Torvalds's avatar
Linus Torvalds committed
1073 1074 1075
	idx++;
	dist = ((long)(s32)(window_size - (offset + size))) >= 0 ? size :
		(long) (window_size - offset);
1076
	memcpy_toio(dimm_mmio + offset / 4, psource, dist);
Linus Torvalds's avatar
Linus Torvalds committed
1077 1078 1079
	writel(0x01, mmio + PDC_GENERAL_CTLR);
	readl(mmio + PDC_GENERAL_CTLR);

1080
	psource += dist;
Linus Torvalds's avatar
Linus Torvalds committed
1081 1082 1083 1084
	size -= dist;
	for (; (long) size >= (long) window_size ;) {
		writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
		readl(mmio + PDC_DIMM_WINDOW_CTLR);
1085
		memcpy_toio(dimm_mmio, psource, window_size / 4);
Linus Torvalds's avatar
Linus Torvalds committed
1086 1087 1088 1089
		writel(0x01, mmio + PDC_GENERAL_CTLR);
		readl(mmio + PDC_GENERAL_CTLR);
		psource += window_size;
		size -= window_size;
1090
		idx++;
Linus Torvalds's avatar
Linus Torvalds committed
1091
	}
1092

Linus Torvalds's avatar
Linus Torvalds committed
1093 1094 1095
	if (size) {
		writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
		readl(mmio + PDC_DIMM_WINDOW_CTLR);
1096
		memcpy_toio(dimm_mmio, psource, size / 4);
Linus Torvalds's avatar
Linus Torvalds committed
1097 1098 1099 1100 1101 1102
		writel(0x01, mmio + PDC_GENERAL_CTLR);
		readl(mmio + PDC_GENERAL_CTLR);
	}
}


1103
static unsigned int pdc20621_i2c_read(struct ata_host *host, u32 device,
Linus Torvalds's avatar
Linus Torvalds committed
1104 1105
				      u32 subaddr, u32 *pdata)
{
1106
	void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
1107
	u32 i2creg  = 0;
1108
	u32 status;
1109
	u32 count = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1110 1111 1112 1113 1114 1115 1116 1117

	/* hard-code chip #0 */
	mmio += PDC_CHIP0_OFS;

	i2creg |= device << 24;
	i2creg |= subaddr << 16;

	/* Set the device and subaddress */
1118 1119
	writel(i2creg, mmio + PDC_I2C_ADDR_DATA);
	readl(mmio + PDC_I2C_ADDR_DATA);
Linus Torvalds's avatar
Linus Torvalds committed
1120 1121

	/* Write Control to perform read operation, mask int */
1122
	writel(PDC_I2C_READ | PDC_I2C_START | PDC_I2C_MASK_INT,
1123
	       mmio + PDC_I2C_CONTROL);
Linus Torvalds's avatar
Linus Torvalds committed
1124 1125

	for (count = 0; count <= 1000; count ++) {
1126
		status = readl(mmio + PDC_I2C_CONTROL);
Linus Torvalds's avatar
Linus Torvalds committed
1127
		if (status & PDC_I2C_COMPLETE) {
1128
			status = readl(mmio + PDC_I2C_ADDR_DATA);
Linus Torvalds's avatar
Linus Torvalds committed
1129 1130 1131 1132 1133 1134
			break;
		} else if (count == 1000)
			return 0;
	}

	*pdata = (status >> 8) & 0x000000ff;
1135
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
1136 1137 1138
}


1139
static int pdc20621_detect_dimm(struct ata_host *host)
Linus Torvalds's avatar
Linus Torvalds committed
1140
{
1141
	u32 data = 0;
1142
	if (pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
Linus Torvalds's avatar
Linus Torvalds committed
1143
			     PDC_DIMM_SPD_SYSTEM_FREQ, &data)) {
1144
		if (data == 100)
Linus Torvalds's avatar
Linus Torvalds committed
1145
			return 100;
1146
	} else
Linus Torvalds's avatar
Linus Torvalds committed
1147
		return 0;
1148

1149
	if (pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS, 9, &data)) {
1150
		if (data <= 0x75)
Linus Torvalds's avatar
Linus Torvalds committed
1151
			return 133;
1152
	} else
Linus Torvalds's avatar
Linus Torvalds committed
1153
		return 0;
1154

1155
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1156 1157 1158
}


1159
static int pdc20621_prog_dimm0(struct ata_host *host)
Linus Torvalds's avatar
Linus Torvalds committed
1160 1161 1162
{
	u32 spd0[50];
	u32 data = 0;
1163 1164
	int size, i;
	u8 bdimmsize;
1165
	void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
1166 1167 1168 1169
	static const struct {
		unsigned int reg;
		unsigned int ofs;
	} pdc_i2c_read_data [] = {
1170
		{ PDC_DIMM_SPD_TYPE, 11 },
Linus Torvalds's avatar
Linus Torvalds committed
1171
		{ PDC_DIMM_SPD_FRESH_RATE, 12 },
1172
		{ PDC_DIMM_SPD_COLUMN_NUM, 4 },
Linus Torvalds's avatar
Linus Torvalds committed
1173 1174 1175 1176 1177 1178 1179 1180
		{ PDC_DIMM_SPD_ATTRIBUTE, 21 },
		{ PDC_DIMM_SPD_ROW_NUM, 3 },
		{ PDC_DIMM_SPD_BANK_NUM, 17 },
		{ PDC_DIMM_SPD_MODULE_ROW, 5 },
		{ PDC_DIMM_SPD_ROW_PRE_CHARGE, 27 },
		{ PDC_DIMM_SPD_ROW_ACTIVE_DELAY, 28 },
		{ PDC_DIMM_SPD_RAS_CAS_DELAY, 29 },
		{ PDC_DIMM_SPD_ACTIVE_PRECHARGE, 30 },
1181
		{ PDC_DIMM_SPD_CAS_LATENCY, 18 },
Linus Torvalds's avatar
Linus Torvalds committed
1182 1183 1184 1185 1186
	};

	/* hard-code chip #0 */
	mmio += PDC_CHIP0_OFS;

1187
	for (i = 0; i < ARRAY_SIZE(pdc_i2c_read_data); i++)
1188
		pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
1189
				  pdc_i2c_read_data[i].reg,
Linus Torvalds's avatar
Linus Torvalds committed
1190
				  &spd0[pdc_i2c_read_data[i].ofs]);
1191

1192 1193
	data |= (spd0[4] - 8) | ((spd0[21] != 0) << 3) | ((spd0[3]-11) << 4);
	data |= ((spd0[17] / 4) << 6) | ((spd0[5] / 2) << 7) |
Linus Torvalds's avatar
Linus Torvalds committed
1194
		((((spd0[27] + 9) / 10) - 1) << 8) ;
1195
	data |= (((((spd0[29] > spd0[28])
1196
		    ? spd0[29] : spd0[28]) + 9) / 10) - 1) << 10;
1197
	data |= ((spd0[30] - spd0[29] + 9) / 10 - 2) << 12;
1198

1199
	if (spd0[18] & 0x08)
Linus Torvalds's avatar
Linus Torvalds committed
1200
		data |= ((0x03) << 14);
1201
	else if (spd0[18] & 0x04)
Linus Torvalds's avatar
Linus Torvalds committed
1202
		data |= ((0x02) << 14);
1203
	else if (spd0[18] & 0x01)
Linus Torvalds's avatar
Linus Torvalds committed
1204
		data |= ((0x01) << 14);
1205
	else
Linus Torvalds's avatar
Linus Torvalds committed
1206 1207
		data |= (0 << 14);

1208
	/*
Linus Torvalds's avatar
Linus Torvalds committed
1209 1210 1211 1212
	   Calculate the size of bDIMMSize (power of 2) and
	   merge the DIMM size by program start/end address.
	*/

1213 1214 1215 1216
	bdimmsize = spd0[4] + (spd0[5] / 2) + spd0[3] + (spd0[17] / 2) + 3;
	size = (1 << bdimmsize) >> 20;	/* size = xxx(MB) */
	data |= (((size / 16) - 1) << 16);
	data |= (0 << 23);
Linus Torvalds's avatar
Linus Torvalds committed
1217
	data |= 8;
1218
	writel(data, mmio + PDC_DIMM0_CONTROL);
1219
	readl(mmio + PDC_DIMM0_CONTROL);
1220
	return size;
Linus Torvalds's avatar
Linus Torvalds committed
1221 1222 1223
}


1224
static unsigned int pdc20621_prog_dimm_global(struct ata_host *host)
Linus Torvalds's avatar
Linus Torvalds committed
1225 1226
{
	u32 data, spd0;
Tejun Heo's avatar
Tejun Heo committed
1227
	int error, i;
1228
	void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
1229 1230

	/* hard-code chip #0 */
1231
	mmio += PDC_CHIP0_OFS;
Linus Torvalds's avatar
Linus Torvalds committed
1232

1233
	/*
Linus Torvalds's avatar
Linus Torvalds committed
1234 1235 1236 1237 1238 1239
	  Set To Default : DIMM Module Global Control Register (0x022259F1)
	  DIMM Arbitration Disable (bit 20)
	  DIMM Data/Control Output Driving Selection (bit12 - bit15)
	  Refresh Enable (bit 17)
	*/

1240
	data = 0x022259F1;
1241 1242
	writel(data, mmio + PDC_SDRAM_CONTROL);
	readl(mmio + PDC_SDRAM_CONTROL);
Linus Torvalds's avatar
Linus Torvalds committed
1243 1244

	/* Turn on for ECC */
1245
	pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
Linus Torvalds's avatar
Linus Torvalds committed
1246 1247 1248
			  PDC_DIMM_SPD_TYPE, &spd0);
	if (spd0 == 0x02) {
		data |= (0x01 << 16);
1249 1250
		writel(data, mmio + PDC_SDRAM_CONTROL);
		readl(mmio + PDC_SDRAM_CONTROL);
Linus Torvalds's avatar
Linus Torvalds committed
1251
		printk(KERN_ERR "Local DIMM ECC Enabled\n");
1252
	}
Linus Torvalds's avatar
Linus Torvalds committed
1253

1254 1255 1256 1257
	/* DIMM Initialization Select/Enable (bit 18/19) */
	data &= (~(1<<18));
	data |= (1<<19);
	writel(data, mmio + PDC_SDRAM_CONTROL);
Linus Torvalds's avatar
Linus Torvalds committed
1258

1259 1260
	error = 1;
	for (i = 1; i <= 10; i++) {   /* polling ~5 secs */
1261
		data = readl(mmio + PDC_SDRAM_CONTROL);
Linus Torvalds's avatar
Linus Torvalds committed
1262
		if (!(data & (1<<19))) {
1263 1264
			error = 0;
			break;
Linus Torvalds's avatar
Linus Torvalds committed
1265 1266
		}
		msleep(i*100);
1267 1268
	}
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
1269
}
1270

Linus Torvalds's avatar
Linus Torvalds committed
1271

1272
static unsigned int pdc20621_dimm_init(struct ata_host *host)
Linus Torvalds's avatar
Linus Torvalds committed
1273
{
1274
	int speed, size, length;
1275 1276 1277 1278 1279 1280
	u32 addr, spd0, pci_status;
	u32 time_period = 0;
	u32 tcount = 0;
	u32 ticks = 0;
	u32 clock = 0;
	u32 fparam = 0;
1281
	void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
1282 1283

	/* hard-code chip #0 */
1284
	mmio += PDC_CHIP0_OFS;
Linus Torvalds's avatar
Linus Torvalds committed
1285 1286 1287 1288 1289 1290 1291 1292 1293

	/* Initialize PLL based upon PCI Bus Frequency */

	/* Initialize Time Period Register */
	writel(0xffffffff, mmio + PDC_TIME_PERIOD);
	time_period = readl(mmio + PDC_TIME_PERIOD);
	VPRINTK("Time Period Register (0x40): 0x%x\n", time_period);

	/* Enable timer */
1294
	writel(PDC_TIMER_DEFAULT, mmio + PDC_TIME_CONTROL);
Linus Torvalds's avatar
Linus Torvalds committed
1295 1296 1297 1298 1299
	readl(mmio + PDC_TIME_CONTROL);

	/* Wait 3 seconds */
	msleep(3000);

1300
	/*
Linus Torvalds's avatar
Linus Torvalds committed
1301 1302 1303 1304 1305 1306 1307
	   When timer is enabled, counter is decreased every internal
	   clock cycle.
	*/

	tcount = readl(mmio + PDC_TIME_COUNTER);
	VPRINTK("Time Counter Register (0x44): 0x%x\n", tcount);

1308
	/*
Linus Torvalds's avatar
Linus Torvalds committed
1309 1310 1311
	   If SX4 is on PCI-X bus, after 3 seconds, the timer counter
	   register should be >= (0xffffffff - 3x10^8).
	*/
1312
	if (tcount >= PCI_X_TCOUNT) {
Linus Torvalds's avatar
Linus Torvalds committed
1313 1314
		ticks = (time_period - tcount);
		VPRINTK("Num counters 0x%x (%d)\n", ticks, ticks);
1315

Linus Torvalds's avatar
Linus Torvalds committed
1316 1317
		clock = (ticks / 300000);
		VPRINTK("10 * Internal clk = 0x%x (%d)\n", clock, clock);
1318

Linus Torvalds's avatar
Linus Torvalds committed
1319 1320 1321 1322 1323 1324
		clock = (clock * 33);
		VPRINTK("10 * Internal clk * 33 = 0x%x (%d)\n", clock, clock);

		/* PLL F Param (bit 22:16) */
		fparam = (1400000 / clock) - 2;
		VPRINTK("PLL F Param: 0x%x (%d)\n", fparam, fparam);
1325

Linus Torvalds's avatar
Linus Torvalds committed
1326 1327 1328 1329 1330 1331 1332 1333 1334 1335
		/* OD param = 0x2 (bit 31:30), R param = 0x5 (bit 29:25) */
		pci_status = (0x8a001824 | (fparam << 16));
	} else
		pci_status = PCI_PLL_INIT;

	/* Initialize PLL. */
	VPRINTK("pci_status: 0x%x\n", pci_status);
	writel(pci_status, mmio + PDC_CTL_STATUS);
	readl(mmio + PDC_CTL_STATUS);

1336
	/*
Linus Torvalds's avatar
Linus Torvalds committed
1337 1338 1339
	   Read SPD of DIMM by I2C interface,
	   and program the DIMM Module Controller.
	*/
1340
	if (!(speed = pdc20621_detect_dimm(host))) {
1341
		printk(KERN_ERR "Detect Local DIMM Fail\n");
Linus Torvalds's avatar
Linus Torvalds committed
1342
		return 1;	/* DIMM error */
1343 1344
	}
	VPRINTK("Local DIMM Speed = %d\n", speed);
Linus Torvalds's avatar
Linus Torvalds committed
1345

1346
	/* Programming DIMM0 Module Control Register (index_CID0:80h) */
1347
	size = pdc20621_prog_dimm0(host);
1348
	VPRINTK("Local DIMM Size = %dMB\n", size);
Linus Torvalds's avatar
Linus Torvalds committed
1349

1350
	/* Programming DIMM Module Global Control Register (index_CID0:88h) */
1351
	if (pdc20621_prog_dimm_global(host)) {
Linus Torvalds's avatar
Linus Torvalds committed
1352 1353
		printk(KERN_ERR "Programming DIMM Module Global Control Register Fail\n");
		return 1;
1354
	}
Linus Torvalds's avatar
Linus Torvalds committed
1355 1356 1357

#ifdef ATA_VERBOSE_DEBUG
	{
1358 1359 1360 1361 1362 1363
		u8 test_parttern1[40] =
			{0x55,0xAA,'P','r','o','m','i','s','e',' ',
			'N','o','t',' ','Y','e','t',' ',
			'D','e','f','i','n','e','d',' ',
			'1','.','1','0',
			'9','8','0','3','1','6','1','2',0,0};
Linus Torvalds's avatar
Linus Torvalds committed
1364 1365
		u8 test_parttern2[40] = {0};

1366 1367
		pdc20621_put_to_dimm(host, test_parttern2, 0x10040, 40);
		pdc20621_put_to_dimm(host, test_parttern2, 0x40, 40);
Linus Torvalds's avatar
Linus Torvalds committed
1368

1369 1370
		pdc20621_put_to_dimm(host, test_parttern1, 0x10040, 40);
		pdc20621_get_from_dimm(host, test_parttern2, 0x40, 40);
1371
		printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0],
Linus Torvalds's avatar
Linus Torvalds committed
1372
		       test_parttern2[1], &(test_parttern2[2]));
1373
		pdc20621_get_from_dimm(host, test_parttern2, 0x10040,
Linus Torvalds's avatar
Linus Torvalds committed
1374
				       40);
1375
		printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0],
Linus Torvalds's avatar
Linus Torvalds committed
1376 1377
		       test_parttern2[1], &(test_parttern2[2]));

1378 1379
		pdc20621_put_to_dimm(host, test_parttern1, 0x40, 40);
		pdc20621_get_from_dimm(host, test_parttern2, 0x40, 40);
1380
		printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0],
Linus Torvalds's avatar
Linus Torvalds committed
1381 1382 1383 1384 1385 1386
		       test_parttern2[1], &(test_parttern2[2]));
	}
#endif

	/* ECC initiliazation. */

1387
	pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
Linus Torvalds's avatar
Linus Torvalds committed
1388 1389
			  PDC_DIMM_SPD_TYPE, &spd0);
	if (spd0 == 0x02) {
1390
		void *buf;
Linus Torvalds's avatar
Linus Torvalds committed
1391 1392 1393
		VPRINTK("Start ECC initialization\n");
		addr = 0;
		length = size * 1024 * 1024;
1394
		buf = kzalloc(ECC_ERASE_BUF_SZ, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
1395
		while (addr < length) {
1396 1397 1398
			pdc20621_put_to_dimm(host, buf, addr,
					     ECC_ERASE_BUF_SZ);
			addr += ECC_ERASE_BUF_SZ;
Linus Torvalds's avatar
Linus Torvalds committed
1399
		}
1400
		kfree(buf);
Linus Torvalds's avatar
Linus Torvalds committed
1401 1402 1403 1404 1405 1406
		VPRINTK("Finish ECC initialization\n");
	}
	return 0;
}


1407
static void pdc_20621_init(struct ata_host *host)
Linus Torvalds's avatar
Linus Torvalds committed
1408 1409
{
	u32 tmp;
1410
	void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
Linus Torvalds's avatar
Linus Torvalds committed
1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437

	/* hard-code chip #0 */
	mmio += PDC_CHIP0_OFS;

	/*
	 * Select page 0x40 for our 32k DIMM window
	 */
	tmp = readl(mmio + PDC_20621_DIMM_WINDOW) & 0xffff0000;
	tmp |= PDC_PAGE_WINDOW;	/* page 40h; arbitrarily selected */
	writel(tmp, mmio + PDC_20621_DIMM_WINDOW);

	/*
	 * Reset Host DMA
	 */
	tmp = readl(mmio + PDC_HDMA_CTLSTAT);
	tmp |= PDC_RESET;
	writel(tmp, mmio + PDC_HDMA_CTLSTAT);
	readl(mmio + PDC_HDMA_CTLSTAT);		/* flush */

	udelay(10);

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

1438 1439
static int pdc_sata_init_one(struct pci_dev *pdev,
			     const struct pci_device_id *ent)
Linus Torvalds's avatar
Linus Torvalds committed
1440
{
1441 1442 1443
	const struct ata_port_info *ppi[] =
		{ &pdc_port_info[ent->driver_data], NULL };
	struct ata_host *host;
1444
	struct pdc_host_priv *hpriv;
1445
	int i, rc;
Linus Torvalds's avatar
Linus Torvalds committed
1446

1447
	ata_print_version_once(&pdev->dev, DRV_VERSION);
Linus Torvalds's avatar
Linus Torvalds committed
1448

1449 1450 1451 1452 1453 1454 1455 1456 1457
	/* allocate host */
	host = ata_host_alloc_pinfo(&pdev->dev, ppi, 4);
	hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
	if (!host || !hpriv)
		return -ENOMEM;

	host->private_data = hpriv;

	/* acquire resources and fill host */
1458
	rc = pcim_enable_device(pdev);
Linus Torvalds's avatar
Linus Torvalds committed
1459 1460 1461
	if (rc)
		return rc;

Tejun Heo's avatar
Tejun Heo committed
1462 1463 1464
	rc = pcim_iomap_regions(pdev, (1 << PDC_MMIO_BAR) | (1 << PDC_DIMM_BAR),
				DRV_NAME);
	if (rc == -EBUSY)
1465
		pcim_pin_device(pdev);
Tejun Heo's avatar
Tejun Heo committed
1466
	if (rc)
1467
		return rc;
1468 1469
	host->iomap = pcim_iomap_table(pdev);

1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
	for (i = 0; i < 4; i++) {
		struct ata_port *ap = host->ports[i];
		void __iomem *base = host->iomap[PDC_MMIO_BAR] + PDC_CHIP0_OFS;
		unsigned int offset = 0x200 + i * 0x80;

		pdc_sata_setup_port(&ap->ioaddr, base + offset);

		ata_port_pbar_desc(ap, PDC_MMIO_BAR, -1, "mmio");
		ata_port_pbar_desc(ap, PDC_DIMM_BAR, -1, "dimm");
		ata_port_pbar_desc(ap, PDC_MMIO_BAR, offset, "port");
	}
Linus Torvalds's avatar
Linus Torvalds committed
1481

1482
	/* configure and activate */
Linus Torvalds's avatar
Linus Torvalds committed
1483 1484
	rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
	if (rc)
1485
		return rc;
Linus Torvalds's avatar
Linus Torvalds committed
1486 1487
	rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
	if (rc)
1488
		return rc;
Linus Torvalds's avatar
Linus Torvalds committed
1489

1490
	if (pdc20621_dimm_init(host))
1491
		return -ENOMEM;
1492
	pdc_20621_init(host);
Linus Torvalds's avatar
Linus Torvalds committed
1493 1494

	pci_set_master(pdev);
1495 1496
	return ata_host_activate(host, pdev->irq, pdc20621_interrupt,
				 IRQF_SHARED, &pdc_sata_sht);
Linus Torvalds's avatar
Linus Torvalds committed
1497 1498
}