?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
efivars: Use string functions in pstore_write
[linux-2.6/next.git] / drivers / ata / sata_sx4.c
blob8fd3b7252bda029baf14fca9741c21f08448e6ef
1 /*
2 * sata_sx4.c - Promise SATA
3 *
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
6 * on emails.
7 *
8 * Copyright 2003-2004 Red Hat, Inc.
9 *
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2, or (at your option)
14 * any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; see the file COPYING. If not, write to
23 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
24 *
25 *
26 * libata documentation is available via 'make {ps|pdf}docs',
27 * as Documentation/DocBook/libata.*
28 *
29 * Hardware documentation available under NDA.
30 *
31 */
32
33 /*
34 Theory of operation
35 -------------------
36
37 The SX4 (PDC20621) chip features a single Host DMA (HDMA) copy
38 engine, DIMM memory, and four ATA engines (one per SATA port).
39 Data is copied to/from DIMM memory by the HDMA engine, before
40 handing off to one (or more) of the ATA engines. The ATA
41 engines operate solely on DIMM memory.
42
43 The SX4 behaves like a PATA chip, with no SATA controls or
44 knowledge whatsoever, leading to the presumption that
45 PATA<->SATA bridges exist on SX4 boards, external to the
46 PDC20621 chip itself.
47
48 The chip is quite capable, supporting an XOR engine and linked
49 hardware commands (permits a string to transactions to be
50 submitted and waited-on as a single unit), and an optional
51 microprocessor.
52
53 The limiting factor is largely software. This Linux driver was
54 written to multiplex the single HDMA engine to copy disk
55 transactions into a fixed DIMM memory space, from where an ATA
56 engine takes over. As a result, each WRITE looks like this:
57
58 submit HDMA packet to hardware
59 hardware copies data from system memory to DIMM
60 hardware raises interrupt
61
62 submit ATA packet to hardware
63 hardware executes ATA WRITE command, w/ data in DIMM
64 hardware raises interrupt
65
66 and each READ looks like this:
67
68 submit ATA packet to hardware
69 hardware executes ATA READ command, w/ data in DIMM
70 hardware raises interrupt
71
72 submit HDMA packet to hardware
73 hardware copies data from DIMM to system memory
74 hardware raises interrupt
75
76 This is a very slow, lock-step way of doing things that can
77 certainly be improved by motivated kernel hackers.
78
79 */
80
81 #include <linux/kernel.h>
82 #include <linux/module.h>
83 #include <linux/pci.h>
84 #include <linux/slab.h>
85 #include <linux/init.h>
86 #include <linux/blkdev.h>
87 #include <linux/delay.h>
88 #include <linux/interrupt.h>
89 #include <linux/device.h>
90 #include <scsi/scsi_host.h>
91 #include <scsi/scsi_cmnd.h>
92 #include <linux/libata.h>
93 #include "sata_promise.h"
94
95 #define DRV_NAME "sata_sx4"
96 #define DRV_VERSION "0.12"
97
98
99 enum {
100 PDC_MMIO_BAR = 3,
101 PDC_DIMM_BAR = 4,
102
103 PDC_PRD_TBL = 0x44, /* Direct command DMA table addr */
104
105 PDC_PKT_SUBMIT = 0x40, /* Command packet pointer addr */
106 PDC_HDMA_PKT_SUBMIT = 0x100, /* Host DMA packet pointer addr */
107 PDC_INT_SEQMASK = 0x40, /* Mask of asserted SEQ INTs */
108 PDC_HDMA_CTLSTAT = 0x12C, /* Host DMA control / status */
109
110 PDC_CTLSTAT = 0x60, /* IDEn control / status */
111
112 PDC_20621_SEQCTL = 0x400,
113 PDC_20621_SEQMASK = 0x480,
114 PDC_20621_GENERAL_CTL = 0x484,
115 PDC_20621_PAGE_SIZE = (32 * 1024),
116
117 /* chosen, not constant, values; we design our own DIMM mem map */
118 PDC_20621_DIMM_WINDOW = 0x0C, /* page# for 32K DIMM window */
119 PDC_20621_DIMM_BASE = 0x00200000,
120 PDC_20621_DIMM_DATA = (64 * 1024),
121 PDC_DIMM_DATA_STEP = (256 * 1024),
122 PDC_DIMM_WINDOW_STEP = (8 * 1024),
123 PDC_DIMM_HOST_PRD = (6 * 1024),
124 PDC_DIMM_HOST_PKT = (128 * 0),
125 PDC_DIMM_HPKT_PRD = (128 * 1),
126 PDC_DIMM_ATA_PKT = (128 * 2),
127 PDC_DIMM_APKT_PRD = (128 * 3),
128 PDC_DIMM_HEADER_SZ = PDC_DIMM_APKT_PRD + 128,
129 PDC_PAGE_WINDOW = 0x40,
130 PDC_PAGE_DATA = PDC_PAGE_WINDOW +
131 (PDC_20621_DIMM_DATA / PDC_20621_PAGE_SIZE),
132 PDC_PAGE_SET = PDC_DIMM_DATA_STEP / PDC_20621_PAGE_SIZE,
133
134 PDC_CHIP0_OFS = 0xC0000, /* offset of chip #0 */
135
136 PDC_20621_ERR_MASK = (1<<19) | (1<<20) | (1<<21) | (1<<22) |
137 (1<<23),
138
139 board_20621 = 0, /* FastTrak S150 SX4 */
140
141 PDC_MASK_INT = (1 << 10), /* HDMA/ATA mask int */
142 PDC_RESET = (1 << 11), /* HDMA/ATA reset */
143 PDC_DMA_ENABLE = (1 << 7), /* DMA start/stop */
144
145 PDC_MAX_HDMA = 32,
146 PDC_HDMA_Q_MASK = (PDC_MAX_HDMA - 1),
147
148 PDC_DIMM0_SPD_DEV_ADDRESS = 0x50,
149 PDC_DIMM1_SPD_DEV_ADDRESS = 0x51,
150 PDC_I2C_CONTROL = 0x48,
151 PDC_I2C_ADDR_DATA = 0x4C,
152 PDC_DIMM0_CONTROL = 0x80,
153 PDC_DIMM1_CONTROL = 0x84,
154 PDC_SDRAM_CONTROL = 0x88,
155 PDC_I2C_WRITE = 0, /* master -> slave */
156 PDC_I2C_READ = (1 << 6), /* master <- slave */
157 PDC_I2C_START = (1 << 7), /* start I2C proto */
158 PDC_I2C_MASK_INT = (1 << 5), /* mask I2C interrupt */
159 PDC_I2C_COMPLETE = (1 << 16), /* I2C normal compl. */
160 PDC_I2C_NO_ACK = (1 << 20), /* slave no-ack addr */
161 PDC_DIMM_SPD_SUBADDRESS_START = 0x00,
162 PDC_DIMM_SPD_SUBADDRESS_END = 0x7F,
163 PDC_DIMM_SPD_ROW_NUM = 3,
164 PDC_DIMM_SPD_COLUMN_NUM = 4,
165 PDC_DIMM_SPD_MODULE_ROW = 5,
166 PDC_DIMM_SPD_TYPE = 11,
167 PDC_DIMM_SPD_FRESH_RATE = 12,
168 PDC_DIMM_SPD_BANK_NUM = 17,
169 PDC_DIMM_SPD_CAS_LATENCY = 18,
170 PDC_DIMM_SPD_ATTRIBUTE = 21,
171 PDC_DIMM_SPD_ROW_PRE_CHARGE = 27,
172 PDC_DIMM_SPD_ROW_ACTIVE_DELAY = 28,
173 PDC_DIMM_SPD_RAS_CAS_DELAY = 29,
174 PDC_DIMM_SPD_ACTIVE_PRECHARGE = 30,
175 PDC_DIMM_SPD_SYSTEM_FREQ = 126,
176 PDC_CTL_STATUS = 0x08,
177 PDC_DIMM_WINDOW_CTLR = 0x0C,
178 PDC_TIME_CONTROL = 0x3C,
179 PDC_TIME_PERIOD = 0x40,
180 PDC_TIME_COUNTER = 0x44,
181 PDC_GENERAL_CTLR = 0x484,
182 PCI_PLL_INIT = 0x8A531824,
183 PCI_X_TCOUNT = 0xEE1E5CFF,
184
185 /* PDC_TIME_CONTROL bits */
186 PDC_TIMER_BUZZER = (1 << 10),
187 PDC_TIMER_MODE_PERIODIC = 0, /* bits 9:8 == 00 */
188 PDC_TIMER_MODE_ONCE = (1 << 8), /* bits 9:8 == 01 */
189 PDC_TIMER_ENABLE = (1 << 7),
190 PDC_TIMER_MASK_INT = (1 << 5),
191 PDC_TIMER_SEQ_MASK = 0x1f, /* SEQ ID for timer */
192 PDC_TIMER_DEFAULT = PDC_TIMER_MODE_ONCE |
193 PDC_TIMER_ENABLE |
194 PDC_TIMER_MASK_INT,
195 };
196
197 #define ECC_ERASE_BUF_SZ (128 * 1024)
198
199 struct pdc_port_priv {
200 u8 dimm_buf[(ATA_PRD_SZ * ATA_MAX_PRD) + 512];
201 u8 *pkt;
202 dma_addr_t pkt_dma;
203 };
204
205 struct pdc_host_priv {
206 unsigned int doing_hdma;
207 unsigned int hdma_prod;
208 unsigned int hdma_cons;
209 struct {
210 struct ata_queued_cmd *qc;
211 unsigned int seq;
212 unsigned long pkt_ofs;
213 } hdma[32];
214 };
215
216
217 static int pdc_sata_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
218 static void pdc_error_handler(struct ata_port *ap);
219 static void pdc_freeze(struct ata_port *ap);
220 static void pdc_thaw(struct ata_port *ap);
221 static int pdc_port_start(struct ata_port *ap);
222 static void pdc20621_qc_prep(struct ata_queued_cmd *qc);
223 static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
224 static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
225 static unsigned int pdc20621_dimm_init(struct ata_host *host);
226 static int pdc20621_detect_dimm(struct ata_host *host);
227 static unsigned int pdc20621_i2c_read(struct ata_host *host,
228 u32 device, u32 subaddr, u32 *pdata);
229 static int pdc20621_prog_dimm0(struct ata_host *host);
230 static unsigned int pdc20621_prog_dimm_global(struct ata_host *host);
231 #ifdef ATA_VERBOSE_DEBUG
232 static void pdc20621_get_from_dimm(struct ata_host *host,
233 void *psource, u32 offset, u32 size);
234 #endif
235 static void pdc20621_put_to_dimm(struct ata_host *host,
236 void *psource, u32 offset, u32 size);
237 static void pdc20621_irq_clear(struct ata_port *ap);
238 static unsigned int pdc20621_qc_issue(struct ata_queued_cmd *qc);
239 static int pdc_softreset(struct ata_link *link, unsigned int *class,
240 unsigned long deadline);
241 static void pdc_post_internal_cmd(struct ata_queued_cmd *qc);
242 static int pdc_check_atapi_dma(struct ata_queued_cmd *qc);
243
244
245 static struct scsi_host_template pdc_sata_sht = {
246 ATA_BASE_SHT(DRV_NAME),
247 .sg_tablesize = LIBATA_MAX_PRD,
248 .dma_boundary = ATA_DMA_BOUNDARY,
249 };
250
251 /* TODO: inherit from base port_ops after converting to new EH */
252 static struct ata_port_operations pdc_20621_ops = {
253 .inherits = &ata_sff_port_ops,
254
255 .check_atapi_dma = pdc_check_atapi_dma,
256 .qc_prep = pdc20621_qc_prep,
257 .qc_issue = pdc20621_qc_issue,
258
259 .freeze = pdc_freeze,
260 .thaw = pdc_thaw,
261 .softreset = pdc_softreset,
262 .error_handler = pdc_error_handler,
263 .lost_interrupt = ATA_OP_NULL,
264 .post_internal_cmd = pdc_post_internal_cmd,
265
266 .port_start = pdc_port_start,
267
268 .sff_tf_load = pdc_tf_load_mmio,
269 .sff_exec_command = pdc_exec_command_mmio,
270 .sff_irq_clear = pdc20621_irq_clear,
271 };
272
273 static const struct ata_port_info pdc_port_info[] = {
274 /* board_20621 */
275 {
276 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_ATAPI |
277 ATA_FLAG_PIO_POLLING,
278 .pio_mask = ATA_PIO4,
279 .mwdma_mask = ATA_MWDMA2,
280 .udma_mask = ATA_UDMA6,
281 .port_ops = &pdc_20621_ops,
282 },
283
284 };
285
286 static const struct pci_device_id pdc_sata_pci_tbl[] = {
287 { PCI_VDEVICE(PROMISE, 0x6622), board_20621 },
288
289 { } /* terminate list */
290 };
291
292 static struct pci_driver pdc_sata_pci_driver = {
293 .name = DRV_NAME,
294 .id_table = pdc_sata_pci_tbl,
295 .probe = pdc_sata_init_one,
296 .remove = ata_pci_remove_one,
297 };
298
299
300 static int pdc_port_start(struct ata_port *ap)
301 {
302 struct device *dev = ap->host->dev;
303 struct pdc_port_priv *pp;
304
305 pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
306 if (!pp)
307 return -ENOMEM;
308
309 pp->pkt = dmam_alloc_coherent(dev, 128, &pp->pkt_dma, GFP_KERNEL);
310 if (!pp->pkt)
311 return -ENOMEM;
312
313 ap->private_data = pp;
314
315 return 0;
316 }
317
318 static inline void pdc20621_ata_sg(struct ata_taskfile *tf, u8 *buf,
319 unsigned int portno,
320 unsigned int total_len)
321 {
322 u32 addr;
323 unsigned int dw = PDC_DIMM_APKT_PRD >> 2;
324 __le32 *buf32 = (__le32 *) buf;
325
326 /* output ATA packet S/G table */
327 addr = PDC_20621_DIMM_BASE + PDC_20621_DIMM_DATA +
328 (PDC_DIMM_DATA_STEP * portno);
329 VPRINTK("ATA sg addr 0x%x, %d\n", addr, addr);
330 buf32[dw] = cpu_to_le32(addr);
331 buf32[dw + 1] = cpu_to_le32(total_len | ATA_PRD_EOT);
332
333 VPRINTK("ATA PSG @ %x == (0x%x, 0x%x)\n",
334 PDC_20621_DIMM_BASE +
335 (PDC_DIMM_WINDOW_STEP * portno) +
336 PDC_DIMM_APKT_PRD,
337 buf32[dw], buf32[dw + 1]);
338 }
339
340 static inline void pdc20621_host_sg(struct ata_taskfile *tf, u8 *buf,
341 unsigned int portno,
342 unsigned int total_len)
343 {
344 u32 addr;
345 unsigned int dw = PDC_DIMM_HPKT_PRD >> 2;
346 __le32 *buf32 = (__le32 *) buf;
347
348 /* output Host DMA packet S/G table */
349 addr = PDC_20621_DIMM_BASE + PDC_20621_DIMM_DATA +
350 (PDC_DIMM_DATA_STEP * portno);
351
352 buf32[dw] = cpu_to_le32(addr);
353 buf32[dw + 1] = cpu_to_le32(total_len | ATA_PRD_EOT);
354
355 VPRINTK("HOST PSG @ %x == (0x%x, 0x%x)\n",
356 PDC_20621_DIMM_BASE +
357 (PDC_DIMM_WINDOW_STEP * portno) +
358 PDC_DIMM_HPKT_PRD,
359 buf32[dw], buf32[dw + 1]);
360 }
361
362 static inline unsigned int pdc20621_ata_pkt(struct ata_taskfile *tf,
363 unsigned int devno, u8 *buf,
364 unsigned int portno)
365 {
366 unsigned int i, dw;
367 __le32 *buf32 = (__le32 *) buf;
368 u8 dev_reg;
369
370 unsigned int dimm_sg = PDC_20621_DIMM_BASE +
371 (PDC_DIMM_WINDOW_STEP * portno) +
372 PDC_DIMM_APKT_PRD;
373 VPRINTK("ENTER, dimm_sg == 0x%x, %d\n", dimm_sg, dimm_sg);
374
375 i = PDC_DIMM_ATA_PKT;
376
377 /*
378 * Set up ATA packet
379 */
380 if ((tf->protocol == ATA_PROT_DMA) && (!(tf->flags & ATA_TFLAG_WRITE)))
381 buf[i++] = PDC_PKT_READ;
382 else if (tf->protocol == ATA_PROT_NODATA)
383 buf[i++] = PDC_PKT_NODATA;
384 else
385 buf[i++] = 0;
386 buf[i++] = 0; /* reserved */
387 buf[i++] = portno + 1; /* seq. id */
388 buf[i++] = 0xff; /* delay seq. id */
389
390 /* dimm dma S/G, and next-pkt */
391 dw = i >> 2;
392 if (tf->protocol == ATA_PROT_NODATA)
393 buf32[dw] = 0;
394 else
395 buf32[dw] = cpu_to_le32(dimm_sg);
396 buf32[dw + 1] = 0;
397 i += 8;
398
399 if (devno == 0)
400 dev_reg = ATA_DEVICE_OBS;
401 else
402 dev_reg = ATA_DEVICE_OBS | ATA_DEV1;
403
404 /* select device */
405 buf[i++] = (1 << 5) | PDC_PKT_CLEAR_BSY | ATA_REG_DEVICE;
406 buf[i++] = dev_reg;
407
408 /* device control register */
409 buf[i++] = (1 << 5) | PDC_REG_DEVCTL;
410 buf[i++] = tf->ctl;
411
412 return i;
413 }
414
415 static inline void pdc20621_host_pkt(struct ata_taskfile *tf, u8 *buf,
416 unsigned int portno)
417 {
418 unsigned int dw;
419 u32 tmp;
420 __le32 *buf32 = (__le32 *) buf;
421
422 unsigned int host_sg = PDC_20621_DIMM_BASE +
423 (PDC_DIMM_WINDOW_STEP * portno) +
424 PDC_DIMM_HOST_PRD;
425 unsigned int dimm_sg = PDC_20621_DIMM_BASE +
426 (PDC_DIMM_WINDOW_STEP * portno) +
427 PDC_DIMM_HPKT_PRD;
428 VPRINTK("ENTER, dimm_sg == 0x%x, %d\n", dimm_sg, dimm_sg);
429 VPRINTK("host_sg == 0x%x, %d\n", host_sg, host_sg);
430
431 dw = PDC_DIMM_HOST_PKT >> 2;
432
433 /*
434 * Set up Host DMA packet
435 */
436 if ((tf->protocol == ATA_PROT_DMA) && (!(tf->flags & ATA_TFLAG_WRITE)))
437 tmp = PDC_PKT_READ;
438 else
439 tmp = 0;
440 tmp |= ((portno + 1 + 4) << 16); /* seq. id */
441 tmp |= (0xff << 24); /* delay seq. id */
442 buf32[dw + 0] = cpu_to_le32(tmp);
443 buf32[dw + 1] = cpu_to_le32(host_sg);
444 buf32[dw + 2] = cpu_to_le32(dimm_sg);
445 buf32[dw + 3] = 0;
446
447 VPRINTK("HOST PKT @ %x == (0x%x 0x%x 0x%x 0x%x)\n",
448 PDC_20621_DIMM_BASE + (PDC_DIMM_WINDOW_STEP * portno) +
449 PDC_DIMM_HOST_PKT,
450 buf32[dw + 0],
451 buf32[dw + 1],
452 buf32[dw + 2],
453 buf32[dw + 3]);
454 }
455
456 static void pdc20621_dma_prep(struct ata_queued_cmd *qc)
457 {
458 struct scatterlist *sg;
459 struct ata_port *ap = qc->ap;
460 struct pdc_port_priv *pp = ap->private_data;
461 void __iomem *mmio = ap->host->iomap[PDC_MMIO_BAR];
462 void __iomem *dimm_mmio = ap->host->iomap[PDC_DIMM_BAR];
463 unsigned int portno = ap->port_no;
464 unsigned int i, si, idx, total_len = 0, sgt_len;
465 __le32 *buf = (__le32 *) &pp->dimm_buf[PDC_DIMM_HEADER_SZ];
466
467 WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
468
469 VPRINTK("ata%u: ENTER\n", ap->print_id);
470
471 /* hard-code chip #0 */
472 mmio += PDC_CHIP0_OFS;
473
474 /*
475 * Build S/G table
476 */
477 idx = 0;
478 for_each_sg(qc->sg, sg, qc->n_elem, si) {
479 buf[idx++] = cpu_to_le32(sg_dma_address(sg));
480 buf[idx++] = cpu_to_le32(sg_dma_len(sg));
481 total_len += sg_dma_len(sg);
482 }
483 buf[idx - 1] |= cpu_to_le32(ATA_PRD_EOT);
484 sgt_len = idx * 4;
485
486 /*
487 * Build ATA, host DMA packets
488 */
489 pdc20621_host_sg(&qc->tf, &pp->dimm_buf[0], portno, total_len);
490 pdc20621_host_pkt(&qc->tf, &pp->dimm_buf[0], portno);
491
492 pdc20621_ata_sg(&qc->tf, &pp->dimm_buf[0], portno, total_len);
493 i = pdc20621_ata_pkt(&qc->tf, qc->dev->devno, &pp->dimm_buf[0], portno);
494
495 if (qc->tf.flags & ATA_TFLAG_LBA48)
496 i = pdc_prep_lba48(&qc->tf, &pp->dimm_buf[0], i);
497 else
498 i = pdc_prep_lba28(&qc->tf, &pp->dimm_buf[0], i);
499
500 pdc_pkt_footer(&qc->tf, &pp->dimm_buf[0], i);
501
502 /* copy three S/G tables and two packets to DIMM MMIO window */
503 memcpy_toio(dimm_mmio + (portno * PDC_DIMM_WINDOW_STEP),
504 &pp->dimm_buf, PDC_DIMM_HEADER_SZ);
505 memcpy_toio(dimm_mmio + (portno * PDC_DIMM_WINDOW_STEP) +
506 PDC_DIMM_HOST_PRD,
507 &pp->dimm_buf[PDC_DIMM_HEADER_SZ], sgt_len);
508
509 /* force host FIFO dump */
510 writel(0x00000001, mmio + PDC_20621_GENERAL_CTL);
511
512 readl(dimm_mmio); /* MMIO PCI posting flush */
513
514 VPRINTK("ata pkt buf ofs %u, prd size %u, mmio copied\n", i, sgt_len);
515 }
516
517 static void pdc20621_nodata_prep(struct ata_queued_cmd *qc)
518 {
519 struct ata_port *ap = qc->ap;
520 struct pdc_port_priv *pp = ap->private_data;
521 void __iomem *mmio = ap->host->iomap[PDC_MMIO_BAR];
522 void __iomem *dimm_mmio = ap->host->iomap[PDC_DIMM_BAR];
523 unsigned int portno = ap->port_no;
524 unsigned int i;
525
526 VPRINTK("ata%u: ENTER\n", ap->print_id);
527
528 /* hard-code chip #0 */
529 mmio += PDC_CHIP0_OFS;
530
531 i = pdc20621_ata_pkt(&qc->tf, qc->dev->devno, &pp->dimm_buf[0], portno);
532
533 if (qc->tf.flags & ATA_TFLAG_LBA48)
534 i = pdc_prep_lba48(&qc->tf, &pp->dimm_buf[0], i);
535 else
536 i = pdc_prep_lba28(&qc->tf, &pp->dimm_buf[0], i);
537
538 pdc_pkt_footer(&qc->tf, &pp->dimm_buf[0], i);
539
540 /* copy three S/G tables and two packets to DIMM MMIO window */
541 memcpy_toio(dimm_mmio + (portno * PDC_DIMM_WINDOW_STEP),
542 &pp->dimm_buf, PDC_DIMM_HEADER_SZ);
543
544 /* force host FIFO dump */
545 writel(0x00000001, mmio + PDC_20621_GENERAL_CTL);
546
547 readl(dimm_mmio); /* MMIO PCI posting flush */
548
549 VPRINTK("ata pkt buf ofs %u, mmio copied\n", i);
550 }
551
552 static void pdc20621_qc_prep(struct ata_queued_cmd *qc)
553 {
554 switch (qc->tf.protocol) {
555 case ATA_PROT_DMA:
556 pdc20621_dma_prep(qc);
557 break;
558 case ATA_PROT_NODATA:
559 pdc20621_nodata_prep(qc);
560 break;
561 default:
562 break;
563 }
564 }
565
566 static void __pdc20621_push_hdma(struct ata_queued_cmd *qc,
567 unsigned int seq,
568 u32 pkt_ofs)
569 {
570 struct ata_port *ap = qc->ap;
571 struct ata_host *host = ap->host;
572 void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
573
574 /* hard-code chip #0 */
575 mmio += PDC_CHIP0_OFS;
576
577 writel(0x00000001, mmio + PDC_20621_SEQCTL + (seq * 4));
578 readl(mmio + PDC_20621_SEQCTL + (seq * 4)); /* flush */
579
580 writel(pkt_ofs, mmio + PDC_HDMA_PKT_SUBMIT);
581 readl(mmio + PDC_HDMA_PKT_SUBMIT); /* flush */
582 }
583
584 static void pdc20621_push_hdma(struct ata_queued_cmd *qc,
585 unsigned int seq,
586 u32 pkt_ofs)
587 {
588 struct ata_port *ap = qc->ap;
589 struct pdc_host_priv *pp = ap->host->private_data;
590 unsigned int idx = pp->hdma_prod & PDC_HDMA_Q_MASK;
591
592 if (!pp->doing_hdma) {
593 __pdc20621_push_hdma(qc, seq, pkt_ofs);
594 pp->doing_hdma = 1;
595 return;
596 }
597
598 pp->hdma[idx].qc = qc;
599 pp->hdma[idx].seq = seq;
600 pp->hdma[idx].pkt_ofs = pkt_ofs;
601 pp->hdma_prod++;
602 }
603
604 static void pdc20621_pop_hdma(struct ata_queued_cmd *qc)
605 {
606 struct ata_port *ap = qc->ap;
607 struct pdc_host_priv *pp = ap->host->private_data;
608 unsigned int idx = pp->hdma_cons & PDC_HDMA_Q_MASK;
609
610 /* if nothing on queue, we're done */
611 if (pp->hdma_prod == pp->hdma_cons) {
612 pp->doing_hdma = 0;
613 return;
614 }
615
616 __pdc20621_push_hdma(pp->hdma[idx].qc, pp->hdma[idx].seq,
617 pp->hdma[idx].pkt_ofs);
618 pp->hdma_cons++;
619 }
620
621 #ifdef ATA_VERBOSE_DEBUG
622 static void pdc20621_dump_hdma(struct ata_queued_cmd *qc)
623 {
624 struct ata_port *ap = qc->ap;
625 unsigned int port_no = ap->port_no;
626 void __iomem *dimm_mmio = ap->host->iomap[PDC_DIMM_BAR];
627
628 dimm_mmio += (port_no * PDC_DIMM_WINDOW_STEP);
629 dimm_mmio += PDC_DIMM_HOST_PKT;
630
631 printk(KERN_ERR "HDMA[0] == 0x%08X\n", readl(dimm_mmio));
632 printk(KERN_ERR "HDMA[1] == 0x%08X\n", readl(dimm_mmio + 4));
633 printk(KERN_ERR "HDMA[2] == 0x%08X\n", readl(dimm_mmio + 8));
634 printk(KERN_ERR "HDMA[3] == 0x%08X\n", readl(dimm_mmio + 12));
635 }
636 #else
637 static inline void pdc20621_dump_hdma(struct ata_queued_cmd *qc) { }
638 #endif /* ATA_VERBOSE_DEBUG */
639
640 static void pdc20621_packet_start(struct ata_queued_cmd *qc)
641 {
642 struct ata_port *ap = qc->ap;
643 struct ata_host *host = ap->host;
644 unsigned int port_no = ap->port_no;
645 void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
646 unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
647 u8 seq = (u8) (port_no + 1);
648 unsigned int port_ofs;
649
650 /* hard-code chip #0 */
651 mmio += PDC_CHIP0_OFS;
652
653 VPRINTK("ata%u: ENTER\n", ap->print_id);
654
655 wmb(); /* flush PRD, pkt writes */
656
657 port_ofs = PDC_20621_DIMM_BASE + (PDC_DIMM_WINDOW_STEP * port_no);
658
659 /* if writing, we (1) DMA to DIMM, then (2) do ATA command */
660 if (rw && qc->tf.protocol == ATA_PROT_DMA) {
661 seq += 4;
662
663 pdc20621_dump_hdma(qc);
664 pdc20621_push_hdma(qc, seq, port_ofs + PDC_DIMM_HOST_PKT);
665 VPRINTK("queued ofs 0x%x (%u), seq %u\n",
666 port_ofs + PDC_DIMM_HOST_PKT,
667 port_ofs + PDC_DIMM_HOST_PKT,
668 seq);
669 } else {
670 writel(0x00000001, mmio + PDC_20621_SEQCTL + (seq * 4));
671 readl(mmio + PDC_20621_SEQCTL + (seq * 4)); /* flush */
672
673 writel(port_ofs + PDC_DIMM_ATA_PKT,
674 ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
675 readl(ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
676 VPRINTK("submitted ofs 0x%x (%u), seq %u\n",
677 port_ofs + PDC_DIMM_ATA_PKT,
678 port_ofs + PDC_DIMM_ATA_PKT,
679 seq);
680 }
681 }
682
683 static unsigned int pdc20621_qc_issue(struct ata_queued_cmd *qc)
684 {
685 switch (qc->tf.protocol) {
686 case ATA_PROT_NODATA:
687 if (qc->tf.flags & ATA_TFLAG_POLLING)
688 break;
689 /*FALLTHROUGH*/
690 case ATA_PROT_DMA:
691 pdc20621_packet_start(qc);
692 return 0;
693
694 case ATAPI_PROT_DMA:
695 BUG();
696 break;
697
698 default:
699 break;
700 }
701
702 return ata_sff_qc_issue(qc);
703 }
704
705 static inline unsigned int pdc20621_host_intr(struct ata_port *ap,
706 struct ata_queued_cmd *qc,
707 unsigned int doing_hdma,
708 void __iomem *mmio)
709 {
710 unsigned int port_no = ap->port_no;
711 unsigned int port_ofs =
712 PDC_20621_DIMM_BASE + (PDC_DIMM_WINDOW_STEP * port_no);
713 u8 status;
714 unsigned int handled = 0;
715
716 VPRINTK("ENTER\n");
717
718 if ((qc->tf.protocol == ATA_PROT_DMA) && /* read */
719 (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
720
721 /* step two - DMA from DIMM to host */
722 if (doing_hdma) {
723 VPRINTK("ata%u: read hdma, 0x%x 0x%x\n", ap->print_id,
724 readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));
725 /* get drive status; clear intr; complete txn */
726 qc->err_mask |= ac_err_mask(ata_wait_idle(ap));
727 ata_qc_complete(qc);
728 pdc20621_pop_hdma(qc);
729 }
730
731 /* step one - exec ATA command */
732 else {
733 u8 seq = (u8) (port_no + 1 + 4);
734 VPRINTK("ata%u: read ata, 0x%x 0x%x\n", ap->print_id,
735 readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));
736
737 /* submit hdma pkt */
738 pdc20621_dump_hdma(qc);
739 pdc20621_push_hdma(qc, seq,
740 port_ofs + PDC_DIMM_HOST_PKT);
741 }
742 handled = 1;
743
744 } else if (qc->tf.protocol == ATA_PROT_DMA) { /* write */
745
746 /* step one - DMA from host to DIMM */
747 if (doing_hdma) {
748 u8 seq = (u8) (port_no + 1);
749 VPRINTK("ata%u: write hdma, 0x%x 0x%x\n", ap->print_id,
750 readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));
751
752 /* submit ata pkt */
753 writel(0x00000001, mmio + PDC_20621_SEQCTL + (seq * 4));
754 readl(mmio + PDC_20621_SEQCTL + (seq * 4));
755 writel(port_ofs + PDC_DIMM_ATA_PKT,
756 ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
757 readl(ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
758 }
759
760 /* step two - execute ATA command */
761 else {
762 VPRINTK("ata%u: write ata, 0x%x 0x%x\n", ap->print_id,
763 readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT));
764 /* get drive status; clear intr; complete txn */
765 qc->err_mask |= ac_err_mask(ata_wait_idle(ap));
766 ata_qc_complete(qc);
767 pdc20621_pop_hdma(qc);
768 }
769 handled = 1;
770
771 /* command completion, but no data xfer */
772 } else if (qc->tf.protocol == ATA_PROT_NODATA) {
773
774 status = ata_sff_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
775 DPRINTK("BUS_NODATA (drv_stat 0x%X)\n", status);
776 qc->err_mask |= ac_err_mask(status);
777 ata_qc_complete(qc);
778 handled = 1;
779
780 } else {
781 ap->stats.idle_irq++;
782 }
783
784 return handled;
785 }
786
787 static void pdc20621_irq_clear(struct ata_port *ap)
788 {
789 ioread8(ap->ioaddr.status_addr);
790 }
791
792 static irqreturn_t pdc20621_interrupt(int irq, void *dev_instance)
793 {
794 struct ata_host *host = dev_instance;
795 struct ata_port *ap;
796 u32 mask = 0;
797 unsigned int i, tmp, port_no;
798 unsigned int handled = 0;
799 void __iomem *mmio_base;
800
801 VPRINTK("ENTER\n");
802
803 if (!host || !host->iomap[PDC_MMIO_BAR]) {
804 VPRINTK("QUICK EXIT\n");
805 return IRQ_NONE;
806 }
807
808 mmio_base = host->iomap[PDC_MMIO_BAR];
809
810 /* reading should also clear interrupts */
811 mmio_base += PDC_CHIP0_OFS;
812 mask = readl(mmio_base + PDC_20621_SEQMASK);
813 VPRINTK("mask == 0x%x\n", mask);
814
815 if (mask == 0xffffffff) {
816 VPRINTK("QUICK EXIT 2\n");
817 return IRQ_NONE;
818 }
819 mask &= 0xffff; /* only 16 tags possible */
820 if (!mask) {
821 VPRINTK("QUICK EXIT 3\n");
822 return IRQ_NONE;
823 }
824
825 spin_lock(&host->lock);
826
827 for (i = 1; i < 9; i++) {
828 port_no = i - 1;
829 if (port_no > 3)
830 port_no -= 4;
831 if (port_no >= host->n_ports)
832 ap = NULL;
833 else
834 ap = host->ports[port_no];
835 tmp = mask & (1 << i);
836 VPRINTK("seq %u, port_no %u, ap %p, tmp %x\n", i, port_no, ap, tmp);
837 if (tmp && ap) {
838 struct ata_queued_cmd *qc;
839
840 qc = ata_qc_from_tag(ap, ap->link.active_tag);
841 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
842 handled += pdc20621_host_intr(ap, qc, (i > 4),
843 mmio_base);
844 }
845 }
846
847 spin_unlock(&host->lock);
848
849 VPRINTK("mask == 0x%x\n", mask);
850
851 VPRINTK("EXIT\n");
852
853 return IRQ_RETVAL(handled);
854 }
855
856 static void pdc_freeze(struct ata_port *ap)
857 {
858 void __iomem *mmio = ap->ioaddr.cmd_addr;
859 u32 tmp;
860
861 /* FIXME: if all 4 ATA engines are stopped, also stop HDMA engine */
862
863 tmp = readl(mmio + PDC_CTLSTAT);
864 tmp |= PDC_MASK_INT;
865 tmp &= ~PDC_DMA_ENABLE;
866 writel(tmp, mmio + PDC_CTLSTAT);
867 readl(mmio + PDC_CTLSTAT); /* flush */
868 }
869
870 static void pdc_thaw(struct ata_port *ap)
871 {
872 void __iomem *mmio = ap->ioaddr.cmd_addr;
873 u32 tmp;
874
875 /* FIXME: start HDMA engine, if zero ATA engines running */
876
877 /* clear IRQ */
878 ioread8(ap->ioaddr.status_addr);
879
880 /* turn IRQ back on */
881 tmp = readl(mmio + PDC_CTLSTAT);
882 tmp &= ~PDC_MASK_INT;
883 writel(tmp, mmio + PDC_CTLSTAT);
884 readl(mmio + PDC_CTLSTAT); /* flush */
885 }
886
887 static void pdc_reset_port(struct ata_port *ap)
888 {
889 void __iomem *mmio = ap->ioaddr.cmd_addr + PDC_CTLSTAT;
890 unsigned int i;
891 u32 tmp;
892
893 /* FIXME: handle HDMA copy engine */
894
895 for (i = 11; i > 0; i--) {
896 tmp = readl(mmio);
897 if (tmp & PDC_RESET)
898 break;
899
900 udelay(100);
901
902 tmp |= PDC_RESET;
903 writel(tmp, mmio);
904 }
905
906 tmp &= ~PDC_RESET;
907 writel(tmp, mmio);
908 readl(mmio); /* flush */
909 }
910
911 static int pdc_softreset(struct ata_link *link, unsigned int *class,
912 unsigned long deadline)
913 {
914 pdc_reset_port(link->ap);
915 return ata_sff_softreset(link, class, deadline);
916 }
917
918 static void pdc_error_handler(struct ata_port *ap)
919 {
920 if (!(ap->pflags & ATA_PFLAG_FROZEN))
921 pdc_reset_port(ap);
922
923 ata_sff_error_handler(ap);
924 }
925
926 static void pdc_post_internal_cmd(struct ata_queued_cmd *qc)
927 {
928 struct ata_port *ap = qc->ap;
929
930 /* make DMA engine forget about the failed command */
931 if (qc->flags & ATA_QCFLAG_FAILED)
932 pdc_reset_port(ap);
933 }
934
935 static int pdc_check_atapi_dma(struct ata_queued_cmd *qc)
936 {
937 u8 *scsicmd = qc->scsicmd->cmnd;
938 int pio = 1; /* atapi dma off by default */
939
940 /* Whitelist commands that may use DMA. */
941 switch (scsicmd[0]) {
942 case WRITE_12:
943 case WRITE_10:
944 case WRITE_6:
945 case READ_12:
946 case READ_10:
947 case READ_6:
948 case 0xad: /* READ_DVD_STRUCTURE */
949 case 0xbe: /* READ_CD */
950 pio = 0;
951 }
952 /* -45150 (FFFF4FA2) to -1 (FFFFFFFF) shall use PIO mode */
953 if (scsicmd[0] == WRITE_10) {
954 unsigned int lba =
955 (scsicmd[2] << 24) |
956 (scsicmd[3] << 16) |
957 (scsicmd[4] << 8) |
958 scsicmd[5];
959 if (lba >= 0xFFFF4FA2)
960 pio = 1;
961 }
962 return pio;
963 }
964
965 static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
966 {
967 WARN_ON(tf->protocol == ATA_PROT_DMA ||
968 tf->protocol == ATAPI_PROT_DMA);
969 ata_sff_tf_load(ap, tf);
970 }
971
972
973 static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
974 {
975 WARN_ON(tf->protocol == ATA_PROT_DMA ||
976 tf->protocol == ATAPI_PROT_DMA);
977 ata_sff_exec_command(ap, tf);
978 }
979
980
981 static void pdc_sata_setup_port(struct ata_ioports *port, void __iomem *base)
982 {
983 port->cmd_addr = base;
984 port->data_addr = base;
985 port->feature_addr =
986 port->error_addr = base + 0x4;
987 port->nsect_addr = base + 0x8;
988 port->lbal_addr = base + 0xc;
989 port->lbam_addr = base + 0x10;
990 port->lbah_addr = base + 0x14;
991 port->device_addr = base + 0x18;
992 port->command_addr =
993 port->status_addr = base + 0x1c;
994 port->altstatus_addr =
995 port->ctl_addr = base + 0x38;
996 }
997
998
999 #ifdef ATA_VERBOSE_DEBUG
1000 static void pdc20621_get_from_dimm(struct ata_host *host, void *psource,
1001 u32 offset, u32 size)
1002 {
1003 u32 window_size;
1004 u16 idx;
1005 u8 page_mask;
1006 long dist;
1007 void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
1008 void __iomem *dimm_mmio = host->iomap[PDC_DIMM_BAR];
1009
1010 /* hard-code chip #0 */
1011 mmio += PDC_CHIP0_OFS;
1012
1013 page_mask = 0x00;
1014 window_size = 0x2000 * 4; /* 32K byte uchar size */
1015 idx = (u16) (offset / window_size);
1016
1017 writel(0x01, mmio + PDC_GENERAL_CTLR);
1018 readl(mmio + PDC_GENERAL_CTLR);
1019 writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
1020 readl(mmio + PDC_DIMM_WINDOW_CTLR);
1021
1022 offset -= (idx * window_size);
1023 idx++;
1024 dist = ((long) (window_size - (offset + size))) >= 0 ? size :
1025 (long) (window_size - offset);
1026 memcpy_fromio((char *) psource, (char *) (dimm_mmio + offset / 4),
1027 dist);
1028
1029 psource += dist;
1030 size -= dist;
1031 for (; (long) size >= (long) window_size ;) {
1032 writel(0x01, mmio + PDC_GENERAL_CTLR);
1033 readl(mmio + PDC_GENERAL_CTLR);
1034 writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
1035 readl(mmio + PDC_DIMM_WINDOW_CTLR);
1036 memcpy_fromio((char *) psource, (char *) (dimm_mmio),
1037 window_size / 4);
1038 psource += window_size;
1039 size -= window_size;
1040 idx++;
1041 }
1042
1043 if (size) {
1044 writel(0x01, mmio + PDC_GENERAL_CTLR);
1045 readl(mmio + PDC_GENERAL_CTLR);
1046 writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
1047 readl(mmio + PDC_DIMM_WINDOW_CTLR);
1048 memcpy_fromio((char *) psource, (char *) (dimm_mmio),
1049 size / 4);
1050 }
1051 }
1052 #endif
1053
1054
1055 static void pdc20621_put_to_dimm(struct ata_host *host, void *psource,
1056 u32 offset, u32 size)
1057 {
1058 u32 window_size;
1059 u16 idx;
1060 u8 page_mask;
1061 long dist;
1062 void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
1063 void __iomem *dimm_mmio = host->iomap[PDC_DIMM_BAR];
1064
1065 /* hard-code chip #0 */
1066 mmio += PDC_CHIP0_OFS;
1067
1068 page_mask = 0x00;
1069 window_size = 0x2000 * 4; /* 32K byte uchar size */
1070 idx = (u16) (offset / window_size);
1071
1072 writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
1073 readl(mmio + PDC_DIMM_WINDOW_CTLR);
1074 offset -= (idx * window_size);
1075 idx++;
1076 dist = ((long)(s32)(window_size - (offset + size))) >= 0 ? size :
1077 (long) (window_size - offset);
1078 memcpy_toio(dimm_mmio + offset / 4, psource, dist);
1079 writel(0x01, mmio + PDC_GENERAL_CTLR);
1080 readl(mmio + PDC_GENERAL_CTLR);
1081
1082 psource += dist;
1083 size -= dist;
1084 for (; (long) size >= (long) window_size ;) {
1085 writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
1086 readl(mmio + PDC_DIMM_WINDOW_CTLR);
1087 memcpy_toio(dimm_mmio, psource, window_size / 4);
1088 writel(0x01, mmio + PDC_GENERAL_CTLR);
1089 readl(mmio + PDC_GENERAL_CTLR);
1090 psource += window_size;
1091 size -= window_size;
1092 idx++;
1093 }
1094
1095 if (size) {
1096 writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
1097 readl(mmio + PDC_DIMM_WINDOW_CTLR);
1098 memcpy_toio(dimm_mmio, psource, size / 4);
1099 writel(0x01, mmio + PDC_GENERAL_CTLR);
1100 readl(mmio + PDC_GENERAL_CTLR);
1101 }
1102 }
1103
1104
1105 static unsigned int pdc20621_i2c_read(struct ata_host *host, u32 device,
1106 u32 subaddr, u32 *pdata)
1107 {
1108 void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
1109 u32 i2creg = 0;
1110 u32 status;
1111 u32 count = 0;
1112
1113 /* hard-code chip #0 */
1114 mmio += PDC_CHIP0_OFS;
1115
1116 i2creg |= device << 24;
1117 i2creg |= subaddr << 16;
1118
1119 /* Set the device and subaddress */
1120 writel(i2creg, mmio + PDC_I2C_ADDR_DATA);
1121 readl(mmio + PDC_I2C_ADDR_DATA);
1122
1123 /* Write Control to perform read operation, mask int */
1124 writel(PDC_I2C_READ | PDC_I2C_START | PDC_I2C_MASK_INT,
1125 mmio + PDC_I2C_CONTROL);
1126
1127 for (count = 0; count <= 1000; count ++) {
1128 status = readl(mmio + PDC_I2C_CONTROL);
1129 if (status & PDC_I2C_COMPLETE) {
1130 status = readl(mmio + PDC_I2C_ADDR_DATA);
1131 break;
1132 } else if (count == 1000)
1133 return 0;
1134 }
1135
1136 *pdata = (status >> 8) & 0x000000ff;
1137 return 1;
1138 }
1139
1140
1141 static int pdc20621_detect_dimm(struct ata_host *host)
1142 {
1143 u32 data = 0;
1144 if (pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
1145 PDC_DIMM_SPD_SYSTEM_FREQ, &data)) {
1146 if (data == 100)
1147 return 100;
1148 } else
1149 return 0;
1150
1151 if (pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS, 9, &data)) {
1152 if (data <= 0x75)
1153 return 133;
1154 } else
1155 return 0;
1156
1157 return 0;
1158 }
1159
1160
1161 static int pdc20621_prog_dimm0(struct ata_host *host)
1162 {
1163 u32 spd0[50];
1164 u32 data = 0;
1165 int size, i;
1166 u8 bdimmsize;
1167 void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
1168 static const struct {
1169 unsigned int reg;
1170 unsigned int ofs;
1171 } pdc_i2c_read_data [] = {
1172 { PDC_DIMM_SPD_TYPE, 11 },
1173 { PDC_DIMM_SPD_FRESH_RATE, 12 },
1174 { PDC_DIMM_SPD_COLUMN_NUM, 4 },
1175 { PDC_DIMM_SPD_ATTRIBUTE, 21 },
1176 { PDC_DIMM_SPD_ROW_NUM, 3 },
1177 { PDC_DIMM_SPD_BANK_NUM, 17 },
1178 { PDC_DIMM_SPD_MODULE_ROW, 5 },
1179 { PDC_DIMM_SPD_ROW_PRE_CHARGE, 27 },
1180 { PDC_DIMM_SPD_ROW_ACTIVE_DELAY, 28 },
1181 { PDC_DIMM_SPD_RAS_CAS_DELAY, 29 },
1182 { PDC_DIMM_SPD_ACTIVE_PRECHARGE, 30 },
1183 { PDC_DIMM_SPD_CAS_LATENCY, 18 },
1184 };
1185
1186 /* hard-code chip #0 */
1187 mmio += PDC_CHIP0_OFS;
1188
1189 for (i = 0; i < ARRAY_SIZE(pdc_i2c_read_data); i++)
1190 pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
1191 pdc_i2c_read_data[i].reg,
1192 &spd0[pdc_i2c_read_data[i].ofs]);
1193
1194 data |= (spd0[4] - 8) | ((spd0[21] != 0) << 3) | ((spd0[3]-11) << 4);
1195 data |= ((spd0[17] / 4) << 6) | ((spd0[5] / 2) << 7) |
1196 ((((spd0[27] + 9) / 10) - 1) << 8) ;
1197 data |= (((((spd0[29] > spd0[28])
1198 ? spd0[29] : spd0[28]) + 9) / 10) - 1) << 10;
1199 data |= ((spd0[30] - spd0[29] + 9) / 10 - 2) << 12;
1200
1201 if (spd0[18] & 0x08)
1202 data |= ((0x03) << 14);
1203 else if (spd0[18] & 0x04)
1204 data |= ((0x02) << 14);
1205 else if (spd0[18] & 0x01)
1206 data |= ((0x01) << 14);
1207 else
1208 data |= (0 << 14);
1209
1210 /*
1211 Calculate the size of bDIMMSize (power of 2) and
1212 merge the DIMM size by program start/end address.
1213 */
1214
1215 bdimmsize = spd0[4] + (spd0[5] / 2) + spd0[3] + (spd0[17] / 2) + 3;
1216 size = (1 << bdimmsize) >> 20; /* size = xxx(MB) */
1217 data |= (((size / 16) - 1) << 16);
1218 data |= (0 << 23);
1219 data |= 8;
1220 writel(data, mmio + PDC_DIMM0_CONTROL);
1221 readl(mmio + PDC_DIMM0_CONTROL);
1222 return size;
1223 }
1224
1225
1226 static unsigned int pdc20621_prog_dimm_global(struct ata_host *host)
1227 {
1228 u32 data, spd0;
1229 int error, i;
1230 void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
1231
1232 /* hard-code chip #0 */
1233 mmio += PDC_CHIP0_OFS;
1234
1235 /*
1236 Set To Default : DIMM Module Global Control Register (0x022259F1)
1237 DIMM Arbitration Disable (bit 20)
1238 DIMM Data/Control Output Driving Selection (bit12 - bit15)
1239 Refresh Enable (bit 17)
1240 */
1241
1242 data = 0x022259F1;
1243 writel(data, mmio + PDC_SDRAM_CONTROL);
1244 readl(mmio + PDC_SDRAM_CONTROL);
1245
1246 /* Turn on for ECC */
1247 pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
1248 PDC_DIMM_SPD_TYPE, &spd0);
1249 if (spd0 == 0x02) {
1250 data |= (0x01 << 16);
1251 writel(data, mmio + PDC_SDRAM_CONTROL);
1252 readl(mmio + PDC_SDRAM_CONTROL);
1253 printk(KERN_ERR "Local DIMM ECC Enabled\n");
1254 }
1255
1256 /* DIMM Initialization Select/Enable (bit 18/19) */
1257 data &= (~(1<<18));
1258 data |= (1<<19);
1259 writel(data, mmio + PDC_SDRAM_CONTROL);
1260
1261 error = 1;
1262 for (i = 1; i <= 10; i++) { /* polling ~5 secs */
1263 data = readl(mmio + PDC_SDRAM_CONTROL);
1264 if (!(data & (1<<19))) {
1265 error = 0;
1266 break;
1267 }
1268 msleep(i*100);
1269 }
1270 return error;
1271 }
1272
1273
1274 static unsigned int pdc20621_dimm_init(struct ata_host *host)
1275 {
1276 int speed, size, length;
1277 u32 addr, spd0, pci_status;
1278 u32 time_period = 0;
1279 u32 tcount = 0;
1280 u32 ticks = 0;
1281 u32 clock = 0;
1282 u32 fparam = 0;
1283 void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
1284
1285 /* hard-code chip #0 */
1286 mmio += PDC_CHIP0_OFS;
1287
1288 /* Initialize PLL based upon PCI Bus Frequency */
1289
1290 /* Initialize Time Period Register */
1291 writel(0xffffffff, mmio + PDC_TIME_PERIOD);
1292 time_period = readl(mmio + PDC_TIME_PERIOD);
1293 VPRINTK("Time Period Register (0x40): 0x%x\n", time_period);
1294
1295 /* Enable timer */
1296 writel(PDC_TIMER_DEFAULT, mmio + PDC_TIME_CONTROL);
1297 readl(mmio + PDC_TIME_CONTROL);
1298
1299 /* Wait 3 seconds */
1300 msleep(3000);
1301
1302 /*
1303 When timer is enabled, counter is decreased every internal
1304 clock cycle.
1305 */
1306
1307 tcount = readl(mmio + PDC_TIME_COUNTER);
1308 VPRINTK("Time Counter Register (0x44): 0x%x\n", tcount);
1309
1310 /*
1311 If SX4 is on PCI-X bus, after 3 seconds, the timer counter
1312 register should be >= (0xffffffff - 3x10^8).
1313 */
1314 if (tcount >= PCI_X_TCOUNT) {
1315 ticks = (time_period - tcount);
1316 VPRINTK("Num counters 0x%x (%d)\n", ticks, ticks);
1317
1318 clock = (ticks / 300000);
1319 VPRINTK("10 * Internal clk = 0x%x (%d)\n", clock, clock);
1320
1321 clock = (clock * 33);
1322 VPRINTK("10 * Internal clk * 33 = 0x%x (%d)\n", clock, clock);
1323
1324 /* PLL F Param (bit 22:16) */
1325 fparam = (1400000 / clock) - 2;
1326 VPRINTK("PLL F Param: 0x%x (%d)\n", fparam, fparam);
1327
1328 /* OD param = 0x2 (bit 31:30), R param = 0x5 (bit 29:25) */
1329 pci_status = (0x8a001824 | (fparam << 16));
1330 } else
1331 pci_status = PCI_PLL_INIT;
1332
1333 /* Initialize PLL. */
1334 VPRINTK("pci_status: 0x%x\n", pci_status);
1335 writel(pci_status, mmio + PDC_CTL_STATUS);
1336 readl(mmio + PDC_CTL_STATUS);
1337
1338 /*
1339 Read SPD of DIMM by I2C interface,
1340 and program the DIMM Module Controller.
1341 */
1342 if (!(speed = pdc20621_detect_dimm(host))) {
1343 printk(KERN_ERR "Detect Local DIMM Fail\n");
1344 return 1; /* DIMM error */
1345 }
1346 VPRINTK("Local DIMM Speed = %d\n", speed);
1347
1348 /* Programming DIMM0 Module Control Register (index_CID0:80h) */
1349 size = pdc20621_prog_dimm0(host);
1350 VPRINTK("Local DIMM Size = %dMB\n", size);
1351
1352 /* Programming DIMM Module Global Control Register (index_CID0:88h) */
1353 if (pdc20621_prog_dimm_global(host)) {
1354 printk(KERN_ERR "Programming DIMM Module Global Control Register Fail\n");
1355 return 1;
1356 }
1357
1358 #ifdef ATA_VERBOSE_DEBUG
1359 {
1360 u8 test_parttern1[40] =
1361 {0x55,0xAA,'P','r','o','m','i','s','e',' ',
1362 'N','o','t',' ','Y','e','t',' ',
1363 'D','e','f','i','n','e','d',' ',
1364 '1','.','1','0',
1365 '9','8','0','3','1','6','1','2',0,0};
1366 u8 test_parttern2[40] = {0};
1367
1368 pdc20621_put_to_dimm(host, test_parttern2, 0x10040, 40);
1369 pdc20621_put_to_dimm(host, test_parttern2, 0x40, 40);
1370
1371 pdc20621_put_to_dimm(host, test_parttern1, 0x10040, 40);
1372 pdc20621_get_from_dimm(host, test_parttern2, 0x40, 40);
1373 printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0],
1374 test_parttern2[1], &(test_parttern2[2]));
1375 pdc20621_get_from_dimm(host, test_parttern2, 0x10040,
1376 40);
1377 printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0],
1378 test_parttern2[1], &(test_parttern2[2]));
1379
1380 pdc20621_put_to_dimm(host, test_parttern1, 0x40, 40);
1381 pdc20621_get_from_dimm(host, test_parttern2, 0x40, 40);
1382 printk(KERN_ERR "%x, %x, %s\n", test_parttern2[0],
1383 test_parttern2[1], &(test_parttern2[2]));
1384 }
1385 #endif
1386
1387 /* ECC initiliazation. */
1388
1389 pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
1390 PDC_DIMM_SPD_TYPE, &spd0);
1391 if (spd0 == 0x02) {
1392 void *buf;
1393 VPRINTK("Start ECC initialization\n");
1394 addr = 0;
1395 length = size * 1024 * 1024;
1396 buf = kzalloc(ECC_ERASE_BUF_SZ, GFP_KERNEL);
1397 while (addr < length) {
1398 pdc20621_put_to_dimm(host, buf, addr,
1399 ECC_ERASE_BUF_SZ);
1400 addr += ECC_ERASE_BUF_SZ;
1401 }
1402 kfree(buf);
1403 VPRINTK("Finish ECC initialization\n");
1404 }
1405 return 0;
1406 }
1407
1408
1409 static void pdc_20621_init(struct ata_host *host)
1410 {
1411 u32 tmp;
1412 void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
1413
1414 /* hard-code chip #0 */
1415 mmio += PDC_CHIP0_OFS;
1416
1417 /*
1418 * Select page 0x40 for our 32k DIMM window
1419 */
1420 tmp = readl(mmio + PDC_20621_DIMM_WINDOW) & 0xffff0000;
1421 tmp |= PDC_PAGE_WINDOW; /* page 40h; arbitrarily selected */
1422 writel(tmp, mmio + PDC_20621_DIMM_WINDOW);
1423
1424 /*
1425 * Reset Host DMA
1426 */
1427 tmp = readl(mmio + PDC_HDMA_CTLSTAT);
1428 tmp |= PDC_RESET;
1429 writel(tmp, mmio + PDC_HDMA_CTLSTAT);
1430 readl(mmio + PDC_HDMA_CTLSTAT); /* flush */
1431
1432 udelay(10);
1433
1434 tmp = readl(mmio + PDC_HDMA_CTLSTAT);
1435 tmp &= ~PDC_RESET;
1436 writel(tmp, mmio + PDC_HDMA_CTLSTAT);
1437 readl(mmio + PDC_HDMA_CTLSTAT); /* flush */
1438 }
1439
1440 static int pdc_sata_init_one(struct pci_dev *pdev,
1441 const struct pci_device_id *ent)
1442 {
1443 static int printed_version;
1444 const struct ata_port_info *ppi[] =
1445 { &pdc_port_info[ent->driver_data], NULL };
1446 struct ata_host *host;
1447 struct pdc_host_priv *hpriv;
1448 int i, rc;
1449
1450 if (!printed_version++)
1451 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
1452
1453 /* allocate host */
1454 host = ata_host_alloc_pinfo(&pdev->dev, ppi, 4);
1455 hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
1456 if (!host || !hpriv)
1457 return -ENOMEM;
1458
1459 host->private_data = hpriv;
1460
1461 /* acquire resources and fill host */
1462 rc = pcim_enable_device(pdev);
1463 if (rc)
1464 return rc;
1465
1466 rc = pcim_iomap_regions(pdev, (1 << PDC_MMIO_BAR) | (1 << PDC_DIMM_BAR),
1467 DRV_NAME);
1468 if (rc == -EBUSY)
1469 pcim_pin_device(pdev);
1470 if (rc)
1471 return rc;
1472 host->iomap = pcim_iomap_table(pdev);
1473
1474 for (i = 0; i < 4; i++) {
1475 struct ata_port *ap = host->ports[i];
1476 void __iomem *base = host->iomap[PDC_MMIO_BAR] + PDC_CHIP0_OFS;
1477 unsigned int offset = 0x200 + i * 0x80;
1478
1479 pdc_sata_setup_port(&ap->ioaddr, base + offset);
1480
1481 ata_port_pbar_desc(ap, PDC_MMIO_BAR, -1, "mmio");
1482 ata_port_pbar_desc(ap, PDC_DIMM_BAR, -1, "dimm");
1483 ata_port_pbar_desc(ap, PDC_MMIO_BAR, offset, "port");
1484 }
1485
1486 /* configure and activate */
1487 rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
1488 if (rc)
1489 return rc;
1490 rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
1491 if (rc)
1492 return rc;
1493
1494 if (pdc20621_dimm_init(host))
1495 return -ENOMEM;
1496 pdc_20621_init(host);
1497
1498 pci_set_master(pdev);
1499 return ata_host_activate(host, pdev->irq, pdc20621_interrupt,
1500 IRQF_SHARED, &pdc_sata_sht);
1501 }
1502
1503
1504 static int __init pdc_sata_init(void)
1505 {
1506 return pci_register_driver(&pdc_sata_pci_driver);
1507 }
1508
1509
1510 static void __exit pdc_sata_exit(void)
1511 {
1512 pci_unregister_driver(&pdc_sata_pci_driver);
1513 }
1514
1515
1516 MODULE_AUTHOR("Jeff Garzik");
1517 MODULE_DESCRIPTION("Promise SATA low-level driver");
1518 MODULE_LICENSE("GPL");
1519 MODULE_DEVICE_TABLE(pci, pdc_sata_pci_tbl);
1520 MODULE_VERSION(DRV_VERSION);
1521
1522 module_init(pdc_sata_init);
1523 module_exit(pdc_sata_exit);
linux-next