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