da8c362c3eb02432c941d677c167cd69ba9a32b9
[linux-2.6.git] / drivers / ata / sata_promise.c
1 /*
2  *  sata_promise.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 information only available under NDA.
30  *
31  */
32
33 #include <linux/kernel.h>
34 #include <linux/module.h>
35 #include <linux/pci.h>
36 #include <linux/init.h>
37 #include <linux/blkdev.h>
38 #include <linux/delay.h>
39 #include <linux/interrupt.h>
40 #include <linux/device.h>
41 #include <scsi/scsi.h>
42 #include <scsi/scsi_host.h>
43 #include <scsi/scsi_cmnd.h>
44 #include <linux/libata.h>
45 #include "sata_promise.h"
46
47 #define DRV_NAME        "sata_promise"
48 #define DRV_VERSION     "1.05"
49
50
51 enum {
52         PDC_MMIO_BAR            = 3,
53
54         /* register offsets */
55         PDC_FEATURE             = 0x04, /* Feature/Error reg (per port) */
56         PDC_SECTOR_COUNT        = 0x08, /* Sector count reg (per port) */
57         PDC_SECTOR_NUMBER       = 0x0C, /* Sector number reg (per port) */
58         PDC_CYLINDER_LOW        = 0x10, /* Cylinder low reg (per port) */
59         PDC_CYLINDER_HIGH       = 0x14, /* Cylinder high reg (per port) */
60         PDC_DEVICE              = 0x18, /* Device/Head reg (per port) */
61         PDC_COMMAND             = 0x1C, /* Command/status reg (per port) */
62         PDC_ALTSTATUS           = 0x38, /* Alternate-status/device-control reg (per port) */
63         PDC_PKT_SUBMIT          = 0x40, /* Command packet pointer addr */
64         PDC_INT_SEQMASK         = 0x40, /* Mask of asserted SEQ INTs */
65         PDC_FLASH_CTL           = 0x44, /* Flash control register */
66         PDC_GLOBAL_CTL          = 0x48, /* Global control/status (per port) */
67         PDC_CTLSTAT             = 0x60, /* IDE control and status (per port) */
68         PDC_SATA_PLUG_CSR       = 0x6C, /* SATA Plug control/status reg */
69         PDC2_SATA_PLUG_CSR      = 0x60, /* SATAII Plug control/status reg */
70         PDC_TBG_MODE            = 0x41C, /* TBG mode (not SATAII) */
71         PDC_SLEW_CTL            = 0x470, /* slew rate control reg (not SATAII) */
72
73         PDC_ERR_MASK            = (1<<19) | (1<<20) | (1<<21) | (1<<22) |
74                                   (1<<8) | (1<<9) | (1<<10),
75
76         board_2037x             = 0,    /* FastTrak S150 TX2plus */
77         board_20319             = 1,    /* FastTrak S150 TX4 */
78         board_20619             = 2,    /* FastTrak TX4000 */
79         board_2057x             = 3,    /* SATAII150 Tx2plus */
80         board_40518             = 4,    /* SATAII150 Tx4 */
81
82         PDC_HAS_PATA            = (1 << 1), /* PDC20375/20575 has PATA */
83
84         /* Sequence counter control registers bit definitions */
85         PDC_SEQCNTRL_INT_MASK   = (1 << 5), /* Sequence Interrupt Mask */
86
87         /* Feature register values */
88         PDC_FEATURE_ATAPI_PIO   = 0x00, /* ATAPI data xfer by PIO */
89         PDC_FEATURE_ATAPI_DMA   = 0x01, /* ATAPI data xfer by DMA */
90
91         /* Device/Head register values */
92         PDC_DEVICE_SATA         = 0xE0, /* Device/Head value for SATA devices */
93
94         /* PDC_CTLSTAT bit definitions */
95         PDC_DMA_ENABLE          = (1 << 7),
96         PDC_IRQ_DISABLE         = (1 << 10),
97         PDC_RESET               = (1 << 11), /* HDMA reset */
98
99         PDC_COMMON_FLAGS        = ATA_FLAG_NO_LEGACY |
100                                   ATA_FLAG_MMIO |
101                                   ATA_FLAG_PIO_POLLING,
102
103         /* hp->flags bits */
104         PDC_FLAG_GEN_II         = (1 << 0),
105 };
106
107
108 struct pdc_port_priv {
109         u8                      *pkt;
110         dma_addr_t              pkt_dma;
111 };
112
113 struct pdc_host_priv {
114         unsigned long           flags;
115         unsigned long           port_flags[ATA_MAX_PORTS];
116 };
117
118 static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg);
119 static void pdc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
120 static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
121 static irqreturn_t pdc_interrupt (int irq, void *dev_instance);
122 static void pdc_eng_timeout(struct ata_port *ap);
123 static int pdc_port_start(struct ata_port *ap);
124 static void pdc_pata_phy_reset(struct ata_port *ap);
125 static void pdc_qc_prep(struct ata_queued_cmd *qc);
126 static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
127 static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
128 static int pdc_check_atapi_dma(struct ata_queued_cmd *qc);
129 static int pdc_old_check_atapi_dma(struct ata_queued_cmd *qc);
130 static void pdc_irq_clear(struct ata_port *ap);
131 static unsigned int pdc_qc_issue_prot(struct ata_queued_cmd *qc);
132 static void pdc_freeze(struct ata_port *ap);
133 static void pdc_thaw(struct ata_port *ap);
134 static void pdc_error_handler(struct ata_port *ap);
135 static void pdc_post_internal_cmd(struct ata_queued_cmd *qc);
136
137
138 static struct scsi_host_template pdc_ata_sht = {
139         .module                 = THIS_MODULE,
140         .name                   = DRV_NAME,
141         .ioctl                  = ata_scsi_ioctl,
142         .queuecommand           = ata_scsi_queuecmd,
143         .can_queue              = ATA_DEF_QUEUE,
144         .this_id                = ATA_SHT_THIS_ID,
145         .sg_tablesize           = LIBATA_MAX_PRD,
146         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
147         .emulated               = ATA_SHT_EMULATED,
148         .use_clustering         = ATA_SHT_USE_CLUSTERING,
149         .proc_name              = DRV_NAME,
150         .dma_boundary           = ATA_DMA_BOUNDARY,
151         .slave_configure        = ata_scsi_slave_config,
152         .slave_destroy          = ata_scsi_slave_destroy,
153         .bios_param             = ata_std_bios_param,
154 };
155
156 static const struct ata_port_operations pdc_sata_ops = {
157         .port_disable           = ata_port_disable,
158         .tf_load                = pdc_tf_load_mmio,
159         .tf_read                = ata_tf_read,
160         .check_status           = ata_check_status,
161         .exec_command           = pdc_exec_command_mmio,
162         .dev_select             = ata_std_dev_select,
163         .check_atapi_dma        = pdc_check_atapi_dma,
164
165         .qc_prep                = pdc_qc_prep,
166         .qc_issue               = pdc_qc_issue_prot,
167         .freeze                 = pdc_freeze,
168         .thaw                   = pdc_thaw,
169         .error_handler          = pdc_error_handler,
170         .post_internal_cmd      = pdc_post_internal_cmd,
171         .data_xfer              = ata_data_xfer,
172         .irq_handler            = pdc_interrupt,
173         .irq_clear              = pdc_irq_clear,
174         .irq_on                 = ata_irq_on,
175         .irq_ack                = ata_irq_ack,
176
177         .scr_read               = pdc_sata_scr_read,
178         .scr_write              = pdc_sata_scr_write,
179         .port_start             = pdc_port_start,
180 };
181
182 /* First-generation chips need a more restrictive ->check_atapi_dma op */
183 static const struct ata_port_operations pdc_old_sata_ops = {
184         .port_disable           = ata_port_disable,
185         .tf_load                = pdc_tf_load_mmio,
186         .tf_read                = ata_tf_read,
187         .check_status           = ata_check_status,
188         .exec_command           = pdc_exec_command_mmio,
189         .dev_select             = ata_std_dev_select,
190         .check_atapi_dma        = pdc_old_check_atapi_dma,
191
192         .qc_prep                = pdc_qc_prep,
193         .qc_issue               = pdc_qc_issue_prot,
194         .freeze                 = pdc_freeze,
195         .thaw                   = pdc_thaw,
196         .error_handler          = pdc_error_handler,
197         .post_internal_cmd      = pdc_post_internal_cmd,
198         .data_xfer              = ata_data_xfer,
199         .irq_handler            = pdc_interrupt,
200         .irq_clear              = pdc_irq_clear,
201         .irq_on                 = ata_irq_on,
202         .irq_ack                = ata_irq_ack,
203
204         .scr_read               = pdc_sata_scr_read,
205         .scr_write              = pdc_sata_scr_write,
206         .port_start             = pdc_port_start,
207 };
208
209 static const struct ata_port_operations pdc_pata_ops = {
210         .port_disable           = ata_port_disable,
211         .tf_load                = pdc_tf_load_mmio,
212         .tf_read                = ata_tf_read,
213         .check_status           = ata_check_status,
214         .exec_command           = pdc_exec_command_mmio,
215         .dev_select             = ata_std_dev_select,
216         .check_atapi_dma        = pdc_check_atapi_dma,
217
218         .phy_reset              = pdc_pata_phy_reset,
219
220         .qc_prep                = pdc_qc_prep,
221         .qc_issue               = pdc_qc_issue_prot,
222         .data_xfer              = ata_data_xfer,
223         .eng_timeout            = pdc_eng_timeout,
224         .irq_handler            = pdc_interrupt,
225         .irq_clear              = pdc_irq_clear,
226         .irq_on                 = ata_irq_on,
227         .irq_ack                = ata_irq_ack,
228
229         .port_start             = pdc_port_start,
230 };
231
232 static const struct ata_port_info pdc_port_info[] = {
233         /* board_2037x */
234         {
235                 .sht            = &pdc_ata_sht,
236                 .flags          = PDC_COMMON_FLAGS,
237                 .pio_mask       = 0x1f, /* pio0-4 */
238                 .mwdma_mask     = 0x07, /* mwdma0-2 */
239                 .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
240                 .port_ops       = &pdc_old_sata_ops,
241         },
242
243         /* board_20319 */
244         {
245                 .sht            = &pdc_ata_sht,
246                 .flags          = PDC_COMMON_FLAGS | ATA_FLAG_SATA,
247                 .pio_mask       = 0x1f, /* pio0-4 */
248                 .mwdma_mask     = 0x07, /* mwdma0-2 */
249                 .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
250                 .port_ops       = &pdc_old_sata_ops,
251         },
252
253         /* board_20619 */
254         {
255                 .sht            = &pdc_ata_sht,
256                 .flags          = PDC_COMMON_FLAGS | ATA_FLAG_SRST | ATA_FLAG_SLAVE_POSS,
257                 .pio_mask       = 0x1f, /* pio0-4 */
258                 .mwdma_mask     = 0x07, /* mwdma0-2 */
259                 .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
260                 .port_ops       = &pdc_pata_ops,
261         },
262
263         /* board_2057x */
264         {
265                 .sht            = &pdc_ata_sht,
266                 .flags          = PDC_COMMON_FLAGS,
267                 .pio_mask       = 0x1f, /* pio0-4 */
268                 .mwdma_mask     = 0x07, /* mwdma0-2 */
269                 .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
270                 .port_ops       = &pdc_sata_ops,
271         },
272
273         /* board_40518 */
274         {
275                 .sht            = &pdc_ata_sht,
276                 .flags          = PDC_COMMON_FLAGS | ATA_FLAG_SATA,
277                 .pio_mask       = 0x1f, /* pio0-4 */
278                 .mwdma_mask     = 0x07, /* mwdma0-2 */
279                 .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
280                 .port_ops       = &pdc_sata_ops,
281         },
282 };
283
284 static const struct pci_device_id pdc_ata_pci_tbl[] = {
285         { PCI_VDEVICE(PROMISE, 0x3371), board_2037x },
286         { PCI_VDEVICE(PROMISE, 0x3373), board_2037x },
287         { PCI_VDEVICE(PROMISE, 0x3375), board_2037x },
288         { PCI_VDEVICE(PROMISE, 0x3376), board_2037x },
289         { PCI_VDEVICE(PROMISE, 0x3570), board_2057x },
290         { PCI_VDEVICE(PROMISE, 0x3571), board_2057x },
291         { PCI_VDEVICE(PROMISE, 0x3574), board_2057x },
292         { PCI_VDEVICE(PROMISE, 0x3577), board_2057x },
293         { PCI_VDEVICE(PROMISE, 0x3d73), board_2057x },
294         { PCI_VDEVICE(PROMISE, 0x3d75), board_2057x },
295
296         { PCI_VDEVICE(PROMISE, 0x3318), board_20319 },
297         { PCI_VDEVICE(PROMISE, 0x3319), board_20319 },
298         { PCI_VDEVICE(PROMISE, 0x3515), board_20319 },
299         { PCI_VDEVICE(PROMISE, 0x3519), board_20319 },
300         { PCI_VDEVICE(PROMISE, 0x3d17), board_40518 },
301         { PCI_VDEVICE(PROMISE, 0x3d18), board_40518 },
302
303         { PCI_VDEVICE(PROMISE, 0x6629), board_20619 },
304
305         { }     /* terminate list */
306 };
307
308
309 static struct pci_driver pdc_ata_pci_driver = {
310         .name                   = DRV_NAME,
311         .id_table               = pdc_ata_pci_tbl,
312         .probe                  = pdc_ata_init_one,
313         .remove                 = ata_pci_remove_one,
314 };
315
316
317 static int pdc_port_start(struct ata_port *ap)
318 {
319         struct device *dev = ap->host->dev;
320         struct pdc_host_priv *hp = ap->host->private_data;
321         struct pdc_port_priv *pp;
322         int rc;
323
324         /* fix up port flags and cable type for SATA+PATA chips */
325         ap->flags |= hp->port_flags[ap->port_no];
326         if (ap->flags & ATA_FLAG_SATA)
327                 ap->cbl = ATA_CBL_SATA;
328
329         rc = ata_port_start(ap);
330         if (rc)
331                 return rc;
332
333         pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
334         if (!pp)
335                 return -ENOMEM;
336
337         pp->pkt = dmam_alloc_coherent(dev, 128, &pp->pkt_dma, GFP_KERNEL);
338         if (!pp->pkt)
339                 return -ENOMEM;
340
341         ap->private_data = pp;
342
343         /* fix up PHYMODE4 align timing */
344         if ((hp->flags & PDC_FLAG_GEN_II) && sata_scr_valid(ap)) {
345                 void __iomem *mmio = (void __iomem *) ap->ioaddr.scr_addr;
346                 unsigned int tmp;
347
348                 tmp = readl(mmio + 0x014);
349                 tmp = (tmp & ~3) | 1;   /* set bits 1:0 = 0:1 */
350                 writel(tmp, mmio + 0x014);
351         }
352
353         return 0;
354 }
355
356 static void pdc_reset_port(struct ata_port *ap)
357 {
358         void __iomem *mmio = ap->ioaddr.cmd_addr + PDC_CTLSTAT;
359         unsigned int i;
360         u32 tmp;
361
362         for (i = 11; i > 0; i--) {
363                 tmp = readl(mmio);
364                 if (tmp & PDC_RESET)
365                         break;
366
367                 udelay(100);
368
369                 tmp |= PDC_RESET;
370                 writel(tmp, mmio);
371         }
372
373         tmp &= ~PDC_RESET;
374         writel(tmp, mmio);
375         readl(mmio);    /* flush */
376 }
377
378 static void pdc_pata_cbl_detect(struct ata_port *ap)
379 {
380         u8 tmp;
381         void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr + PDC_CTLSTAT + 0x03;
382
383         tmp = readb(mmio);
384
385         if (tmp & 0x01) {
386                 ap->cbl = ATA_CBL_PATA40;
387                 ap->udma_mask &= ATA_UDMA_MASK_40C;
388         } else
389                 ap->cbl = ATA_CBL_PATA80;
390 }
391
392 static void pdc_pata_phy_reset(struct ata_port *ap)
393 {
394         pdc_pata_cbl_detect(ap);
395         pdc_reset_port(ap);
396         ata_port_probe(ap);
397         ata_bus_reset(ap);
398 }
399
400 static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
401 {
402         if (sc_reg > SCR_CONTROL || ap->cbl != ATA_CBL_SATA)
403                 return 0xffffffffU;
404         return readl(ap->ioaddr.scr_addr + (sc_reg * 4));
405 }
406
407
408 static void pdc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg,
409                                u32 val)
410 {
411         if (sc_reg > SCR_CONTROL || ap->cbl != ATA_CBL_SATA)
412                 return;
413         writel(val, ap->ioaddr.scr_addr + (sc_reg * 4));
414 }
415
416 static void pdc_atapi_pkt(struct ata_queued_cmd *qc)
417 {
418         struct ata_port *ap = qc->ap;
419         dma_addr_t sg_table = ap->prd_dma;
420         unsigned int cdb_len = qc->dev->cdb_len;
421         u8 *cdb = qc->cdb;
422         struct pdc_port_priv *pp = ap->private_data;
423         u8 *buf = pp->pkt;
424         u32 *buf32 = (u32 *) buf;
425         unsigned int dev_sel, feature, nbytes;
426
427         /* set control bits (byte 0), zero delay seq id (byte 3),
428          * and seq id (byte 2)
429          */
430         switch (qc->tf.protocol) {
431         case ATA_PROT_ATAPI_DMA:
432                 if (!(qc->tf.flags & ATA_TFLAG_WRITE))
433                         buf32[0] = cpu_to_le32(PDC_PKT_READ);
434                 else
435                         buf32[0] = 0;
436                 break;
437         case ATA_PROT_ATAPI_NODATA:
438                 buf32[0] = cpu_to_le32(PDC_PKT_NODATA);
439                 break;
440         default:
441                 BUG();
442                 break;
443         }
444         buf32[1] = cpu_to_le32(sg_table);       /* S/G table addr */
445         buf32[2] = 0;                           /* no next-packet */
446
447         /* select drive */
448         if (sata_scr_valid(ap)) {
449                 dev_sel = PDC_DEVICE_SATA;
450         } else {
451                 dev_sel = ATA_DEVICE_OBS;
452                 if (qc->dev->devno != 0)
453                         dev_sel |= ATA_DEV1;
454         }
455         buf[12] = (1 << 5) | ATA_REG_DEVICE;
456         buf[13] = dev_sel;
457         buf[14] = (1 << 5) | ATA_REG_DEVICE | PDC_PKT_CLEAR_BSY;
458         buf[15] = dev_sel; /* once more, waiting for BSY to clear */
459
460         buf[16] = (1 << 5) | ATA_REG_NSECT;
461         buf[17] = 0x00;
462         buf[18] = (1 << 5) | ATA_REG_LBAL;
463         buf[19] = 0x00;
464
465         /* set feature and byte counter registers */
466         if (qc->tf.protocol != ATA_PROT_ATAPI_DMA) {
467                 feature = PDC_FEATURE_ATAPI_PIO;
468                 /* set byte counter register to real transfer byte count */
469                 nbytes = qc->nbytes;
470                 if (nbytes > 0xffff)
471                         nbytes = 0xffff;
472         } else {
473                 feature = PDC_FEATURE_ATAPI_DMA;
474                 /* set byte counter register to 0 */
475                 nbytes = 0;
476         }
477         buf[20] = (1 << 5) | ATA_REG_FEATURE;
478         buf[21] = feature;
479         buf[22] = (1 << 5) | ATA_REG_BYTEL;
480         buf[23] = nbytes & 0xFF;
481         buf[24] = (1 << 5) | ATA_REG_BYTEH;
482         buf[25] = (nbytes >> 8) & 0xFF;
483
484         /* send ATAPI packet command 0xA0 */
485         buf[26] = (1 << 5) | ATA_REG_CMD;
486         buf[27] = ATA_CMD_PACKET;
487
488         /* select drive and check DRQ */
489         buf[28] = (1 << 5) | ATA_REG_DEVICE | PDC_PKT_WAIT_DRDY;
490         buf[29] = dev_sel;
491
492         /* we can represent cdb lengths 2/4/6/8/10/12/14/16 */
493         BUG_ON(cdb_len & ~0x1E);
494
495         /* append the CDB as the final part */
496         buf[30] = (((cdb_len >> 1) & 7) << 5) | ATA_REG_DATA | PDC_LAST_REG;
497         memcpy(buf+31, cdb, cdb_len);
498 }
499
500 static void pdc_qc_prep(struct ata_queued_cmd *qc)
501 {
502         struct pdc_port_priv *pp = qc->ap->private_data;
503         unsigned int i;
504
505         VPRINTK("ENTER\n");
506
507         switch (qc->tf.protocol) {
508         case ATA_PROT_DMA:
509                 ata_qc_prep(qc);
510                 /* fall through */
511
512         case ATA_PROT_NODATA:
513                 i = pdc_pkt_header(&qc->tf, qc->ap->prd_dma,
514                                    qc->dev->devno, pp->pkt);
515
516                 if (qc->tf.flags & ATA_TFLAG_LBA48)
517                         i = pdc_prep_lba48(&qc->tf, pp->pkt, i);
518                 else
519                         i = pdc_prep_lba28(&qc->tf, pp->pkt, i);
520
521                 pdc_pkt_footer(&qc->tf, pp->pkt, i);
522                 break;
523
524         case ATA_PROT_ATAPI:
525                 ata_qc_prep(qc);
526                 break;
527
528         case ATA_PROT_ATAPI_DMA:
529                 ata_qc_prep(qc);
530                 /*FALLTHROUGH*/
531         case ATA_PROT_ATAPI_NODATA:
532                 pdc_atapi_pkt(qc);
533                 break;
534
535         default:
536                 break;
537         }
538 }
539
540 static void pdc_freeze(struct ata_port *ap)
541 {
542         void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr;
543         u32 tmp;
544
545         tmp = readl(mmio + PDC_CTLSTAT);
546         tmp |= PDC_IRQ_DISABLE;
547         tmp &= ~PDC_DMA_ENABLE;
548         writel(tmp, mmio + PDC_CTLSTAT);
549         readl(mmio + PDC_CTLSTAT); /* flush */
550 }
551
552 static void pdc_thaw(struct ata_port *ap)
553 {
554         void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr;
555         u32 tmp;
556
557         /* clear IRQ */
558         readl(mmio + PDC_INT_SEQMASK);
559
560         /* turn IRQ back on */
561         tmp = readl(mmio + PDC_CTLSTAT);
562         tmp &= ~PDC_IRQ_DISABLE;
563         writel(tmp, mmio + PDC_CTLSTAT);
564         readl(mmio + PDC_CTLSTAT); /* flush */
565 }
566
567 static int pdc_pre_reset(struct ata_port *ap)
568 {
569         if (!sata_scr_valid(ap))
570                 pdc_pata_cbl_detect(ap);
571         return ata_std_prereset(ap);
572 }
573
574 static void pdc_error_handler(struct ata_port *ap)
575 {
576         ata_reset_fn_t hardreset;
577
578         if (!(ap->pflags & ATA_PFLAG_FROZEN))
579                 pdc_reset_port(ap);
580
581         hardreset = NULL;
582         if (sata_scr_valid(ap))
583                 hardreset = sata_std_hardreset;
584
585         /* perform recovery */
586         ata_do_eh(ap, pdc_pre_reset, ata_std_softreset, hardreset,
587                   ata_std_postreset);
588 }
589
590 static void pdc_post_internal_cmd(struct ata_queued_cmd *qc)
591 {
592         struct ata_port *ap = qc->ap;
593
594         if (qc->flags & ATA_QCFLAG_FAILED)
595                 qc->err_mask |= AC_ERR_OTHER;
596
597         /* make DMA engine forget about the failed command */
598         if (qc->err_mask)
599                 pdc_reset_port(ap);
600 }
601
602 static void pdc_eng_timeout(struct ata_port *ap)
603 {
604         struct ata_host *host = ap->host;
605         u8 drv_stat;
606         struct ata_queued_cmd *qc;
607         unsigned long flags;
608
609         DPRINTK("ENTER\n");
610
611         spin_lock_irqsave(&host->lock, flags);
612
613         qc = ata_qc_from_tag(ap, ap->active_tag);
614
615         switch (qc->tf.protocol) {
616         case ATA_PROT_DMA:
617         case ATA_PROT_NODATA:
618                 ata_port_printk(ap, KERN_ERR, "command timeout\n");
619                 drv_stat = ata_wait_idle(ap);
620                 qc->err_mask |= __ac_err_mask(drv_stat);
621                 break;
622
623         default:
624                 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
625
626                 ata_port_printk(ap, KERN_ERR,
627                                 "unknown timeout, cmd 0x%x stat 0x%x\n",
628                                 qc->tf.command, drv_stat);
629
630                 qc->err_mask |= ac_err_mask(drv_stat);
631                 break;
632         }
633
634         spin_unlock_irqrestore(&host->lock, flags);
635         ata_eh_qc_complete(qc);
636         DPRINTK("EXIT\n");
637 }
638
639 static inline unsigned int pdc_host_intr( struct ata_port *ap,
640                                           struct ata_queued_cmd *qc)
641 {
642         unsigned int handled = 0;
643         u32 tmp;
644         void __iomem *mmio = ap->ioaddr.cmd_addr + PDC_GLOBAL_CTL;
645
646         tmp = readl(mmio);
647         if (tmp & PDC_ERR_MASK) {
648                 qc->err_mask |= AC_ERR_DEV;
649                 pdc_reset_port(ap);
650         }
651
652         switch (qc->tf.protocol) {
653         case ATA_PROT_DMA:
654         case ATA_PROT_NODATA:
655         case ATA_PROT_ATAPI_DMA:
656         case ATA_PROT_ATAPI_NODATA:
657                 qc->err_mask |= ac_err_mask(ata_wait_idle(ap));
658                 ata_qc_complete(qc);
659                 handled = 1;
660                 break;
661
662         default:
663                 ap->stats.idle_irq++;
664                 break;
665         }
666
667         return handled;
668 }
669
670 static void pdc_irq_clear(struct ata_port *ap)
671 {
672         struct ata_host *host = ap->host;
673         void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
674
675         readl(mmio + PDC_INT_SEQMASK);
676 }
677
678 static irqreturn_t pdc_interrupt (int irq, void *dev_instance)
679 {
680         struct ata_host *host = dev_instance;
681         struct ata_port *ap;
682         u32 mask = 0;
683         unsigned int i, tmp;
684         unsigned int handled = 0;
685         void __iomem *mmio_base;
686
687         VPRINTK("ENTER\n");
688
689         if (!host || !host->iomap[PDC_MMIO_BAR]) {
690                 VPRINTK("QUICK EXIT\n");
691                 return IRQ_NONE;
692         }
693
694         mmio_base = host->iomap[PDC_MMIO_BAR];
695
696         /* reading should also clear interrupts */
697         mask = readl(mmio_base + PDC_INT_SEQMASK);
698
699         if (mask == 0xffffffff) {
700                 VPRINTK("QUICK EXIT 2\n");
701                 return IRQ_NONE;
702         }
703
704         spin_lock(&host->lock);
705
706         mask &= 0xffff;         /* only 16 tags possible */
707         if (!mask) {
708                 VPRINTK("QUICK EXIT 3\n");
709                 goto done_irq;
710         }
711
712         writel(mask, mmio_base + PDC_INT_SEQMASK);
713
714         for (i = 0; i < host->n_ports; i++) {
715                 VPRINTK("port %u\n", i);
716                 ap = host->ports[i];
717                 tmp = mask & (1 << (i + 1));
718                 if (tmp && ap &&
719                     !(ap->flags & ATA_FLAG_DISABLED)) {
720                         struct ata_queued_cmd *qc;
721
722                         qc = ata_qc_from_tag(ap, ap->active_tag);
723                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
724                                 handled += pdc_host_intr(ap, qc);
725                 }
726         }
727
728         VPRINTK("EXIT\n");
729
730 done_irq:
731         spin_unlock(&host->lock);
732         return IRQ_RETVAL(handled);
733 }
734
735 static inline void pdc_packet_start(struct ata_queued_cmd *qc)
736 {
737         struct ata_port *ap = qc->ap;
738         struct pdc_port_priv *pp = ap->private_data;
739         void __iomem *mmio = ap->host->iomap[PDC_MMIO_BAR];
740         unsigned int port_no = ap->port_no;
741         u8 seq = (u8) (port_no + 1);
742
743         VPRINTK("ENTER, ap %p\n", ap);
744
745         writel(0x00000001, mmio + (seq * 4));
746         readl(mmio + (seq * 4));        /* flush */
747
748         pp->pkt[2] = seq;
749         wmb();                  /* flush PRD, pkt writes */
750         writel(pp->pkt_dma, ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
751         readl(ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT); /* flush */
752 }
753
754 static unsigned int pdc_qc_issue_prot(struct ata_queued_cmd *qc)
755 {
756         switch (qc->tf.protocol) {
757         case ATA_PROT_ATAPI_NODATA:
758                 if (qc->dev->flags & ATA_DFLAG_CDB_INTR)
759                         break;
760                 /*FALLTHROUGH*/
761         case ATA_PROT_ATAPI_DMA:
762         case ATA_PROT_DMA:
763         case ATA_PROT_NODATA:
764                 pdc_packet_start(qc);
765                 return 0;
766
767         default:
768                 break;
769         }
770
771         return ata_qc_issue_prot(qc);
772 }
773
774 static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
775 {
776         WARN_ON (tf->protocol == ATA_PROT_DMA ||
777                  tf->protocol == ATA_PROT_NODATA);
778         ata_tf_load(ap, tf);
779 }
780
781
782 static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
783 {
784         WARN_ON (tf->protocol == ATA_PROT_DMA ||
785                  tf->protocol == ATA_PROT_NODATA);
786         ata_exec_command(ap, tf);
787 }
788
789 static int pdc_check_atapi_dma(struct ata_queued_cmd *qc)
790 {
791         u8 *scsicmd = qc->scsicmd->cmnd;
792         int pio = 1; /* atapi dma off by default */
793
794         /* Whitelist commands that may use DMA. */
795         switch (scsicmd[0]) {
796         case WRITE_12:
797         case WRITE_10:
798         case WRITE_6:
799         case READ_12:
800         case READ_10:
801         case READ_6:
802         case 0xad: /* READ_DVD_STRUCTURE */
803         case 0xbe: /* READ_CD */
804                 pio = 0;
805         }
806         /* -45150 (FFFF4FA2) to -1 (FFFFFFFF) shall use PIO mode */
807         if (scsicmd[0] == WRITE_10) {
808                 unsigned int lba;
809                 lba = (scsicmd[2] << 24) | (scsicmd[3] << 16) | (scsicmd[4] << 8) | scsicmd[5];
810                 if (lba >= 0xFFFF4FA2)
811                         pio = 1;
812         }
813         return pio;
814 }
815
816 static int pdc_old_check_atapi_dma(struct ata_queued_cmd *qc)
817 {
818         struct ata_port *ap = qc->ap;
819
820         /* First generation chips cannot use ATAPI DMA on SATA ports */
821         if (sata_scr_valid(ap))
822                 return 1;
823         return pdc_check_atapi_dma(qc);
824 }
825
826 static void pdc_ata_setup_port(struct ata_ioports *port, void __iomem *base)
827 {
828         port->cmd_addr          = base;
829         port->data_addr         = base;
830         port->feature_addr      =
831         port->error_addr        = base + 0x4;
832         port->nsect_addr        = base + 0x8;
833         port->lbal_addr         = base + 0xc;
834         port->lbam_addr         = base + 0x10;
835         port->lbah_addr         = base + 0x14;
836         port->device_addr       = base + 0x18;
837         port->command_addr      =
838         port->status_addr       = base + 0x1c;
839         port->altstatus_addr    =
840         port->ctl_addr          = base + 0x38;
841 }
842
843
844 static void pdc_host_init(unsigned int chip_id, struct ata_probe_ent *pe)
845 {
846         void __iomem *mmio = pe->iomap[PDC_MMIO_BAR];
847         struct pdc_host_priv *hp = pe->private_data;
848         int hotplug_offset;
849         u32 tmp;
850
851         if (hp->flags & PDC_FLAG_GEN_II)
852                 hotplug_offset = PDC2_SATA_PLUG_CSR;
853         else
854                 hotplug_offset = PDC_SATA_PLUG_CSR;
855
856         /*
857          * Except for the hotplug stuff, this is voodoo from the
858          * Promise driver.  Label this entire section
859          * "TODO: figure out why we do this"
860          */
861
862         /* enable BMR_BURST, maybe change FIFO_SHD to 8 dwords */
863         tmp = readl(mmio + PDC_FLASH_CTL);
864         tmp |= 0x02000; /* bit 13 (enable bmr burst) */
865         if (!(hp->flags & PDC_FLAG_GEN_II))
866                 tmp |= 0x10000; /* bit 16 (fifo threshold at 8 dw) */
867         writel(tmp, mmio + PDC_FLASH_CTL);
868
869         /* clear plug/unplug flags for all ports */
870         tmp = readl(mmio + hotplug_offset);
871         writel(tmp | 0xff, mmio + hotplug_offset);
872
873         /* mask plug/unplug ints */
874         tmp = readl(mmio + hotplug_offset);
875         writel(tmp | 0xff0000, mmio + hotplug_offset);
876
877         /* don't initialise TBG or SLEW on 2nd generation chips */
878         if (hp->flags & PDC_FLAG_GEN_II)
879                 return;
880
881         /* reduce TBG clock to 133 Mhz. */
882         tmp = readl(mmio + PDC_TBG_MODE);
883         tmp &= ~0x30000; /* clear bit 17, 16*/
884         tmp |= 0x10000;  /* set bit 17:16 = 0:1 */
885         writel(tmp, mmio + PDC_TBG_MODE);
886
887         readl(mmio + PDC_TBG_MODE);     /* flush */
888         msleep(10);
889
890         /* adjust slew rate control register. */
891         tmp = readl(mmio + PDC_SLEW_CTL);
892         tmp &= 0xFFFFF03F; /* clear bit 11 ~ 6 */
893         tmp  |= 0x00000900; /* set bit 11-9 = 100b , bit 8-6 = 100 */
894         writel(tmp, mmio + PDC_SLEW_CTL);
895 }
896
897 static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
898 {
899         static int printed_version;
900         struct ata_probe_ent *probe_ent;
901         struct pdc_host_priv *hp;
902         void __iomem *base;
903         unsigned int board_idx = (unsigned int) ent->driver_data;
904         int rc;
905         u8 tmp;
906
907         if (!printed_version++)
908                 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
909
910         rc = pcim_enable_device(pdev);
911         if (rc)
912                 return rc;
913
914         rc = pcim_iomap_regions(pdev, 1 << PDC_MMIO_BAR, DRV_NAME);
915         if (rc == -EBUSY)
916                 pcim_pin_device(pdev);
917         if (rc)
918                 return rc;
919
920         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
921         if (rc)
922                 return rc;
923         rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
924         if (rc)
925                 return rc;
926
927         probe_ent = devm_kzalloc(&pdev->dev, sizeof(*probe_ent), GFP_KERNEL);
928         if (probe_ent == NULL)
929                 return -ENOMEM;
930
931         probe_ent->dev = pci_dev_to_dev(pdev);
932         INIT_LIST_HEAD(&probe_ent->node);
933
934         hp = devm_kzalloc(&pdev->dev, sizeof(*hp), GFP_KERNEL);
935         if (hp == NULL)
936                 return -ENOMEM;
937
938         probe_ent->private_data = hp;
939
940         probe_ent->sht          = pdc_port_info[board_idx].sht;
941         probe_ent->port_flags   = pdc_port_info[board_idx].flags;
942         probe_ent->pio_mask     = pdc_port_info[board_idx].pio_mask;
943         probe_ent->mwdma_mask   = pdc_port_info[board_idx].mwdma_mask;
944         probe_ent->udma_mask    = pdc_port_info[board_idx].udma_mask;
945         probe_ent->port_ops     = pdc_port_info[board_idx].port_ops;
946
947         probe_ent->irq = pdev->irq;
948         probe_ent->irq_flags = IRQF_SHARED;
949         probe_ent->iomap = pcim_iomap_table(pdev);
950
951         base = probe_ent->iomap[PDC_MMIO_BAR];
952
953         pdc_ata_setup_port(&probe_ent->port[0], base + 0x200);
954         pdc_ata_setup_port(&probe_ent->port[1], base + 0x280);
955
956         probe_ent->port[0].scr_addr = base + 0x400;
957         probe_ent->port[1].scr_addr = base + 0x500;
958
959         /* notice 4-port boards */
960         switch (board_idx) {
961         case board_40518:
962                 hp->flags |= PDC_FLAG_GEN_II;
963                 /* Fall through */
964         case board_20319:
965                 probe_ent->n_ports = 4;
966
967                 pdc_ata_setup_port(&probe_ent->port[2], base + 0x300);
968                 pdc_ata_setup_port(&probe_ent->port[3], base + 0x380);
969
970                 probe_ent->port[2].scr_addr = base + 0x600;
971                 probe_ent->port[3].scr_addr = base + 0x700;
972                 break;
973         case board_2057x:
974                 hp->flags |= PDC_FLAG_GEN_II;
975                 /* Fall through */
976         case board_2037x:
977                 /* TX2plus boards also have a PATA port */
978                 tmp = readb(base + PDC_FLASH_CTL+1);
979                 if (!(tmp & 0x80)) {
980                         probe_ent->n_ports = 3;
981                         pdc_ata_setup_port(&probe_ent->port[2], base + 0x300);
982                         hp->port_flags[2] = ATA_FLAG_SLAVE_POSS;
983                         printk(KERN_INFO DRV_NAME " PATA port found\n");
984                 } else
985                         probe_ent->n_ports = 2;
986                 hp->port_flags[0] = ATA_FLAG_SATA;
987                 hp->port_flags[1] = ATA_FLAG_SATA;
988                 break;
989         case board_20619:
990                 probe_ent->n_ports = 4;
991
992                 pdc_ata_setup_port(&probe_ent->port[2], base + 0x300);
993                 pdc_ata_setup_port(&probe_ent->port[3], base + 0x380);
994
995                 probe_ent->port[2].scr_addr = base + 0x600;
996                 probe_ent->port[3].scr_addr = base + 0x700;
997                 break;
998         default:
999                 BUG();
1000                 break;
1001         }
1002
1003         pci_set_master(pdev);
1004
1005         /* initialize adapter */
1006         pdc_host_init(board_idx, probe_ent);
1007
1008         if (!ata_device_add(probe_ent))
1009                 return -ENODEV;
1010
1011         devm_kfree(&pdev->dev, probe_ent);
1012         return 0;
1013 }
1014
1015
1016 static int __init pdc_ata_init(void)
1017 {
1018         return pci_register_driver(&pdc_ata_pci_driver);
1019 }
1020
1021
1022 static void __exit pdc_ata_exit(void)
1023 {
1024         pci_unregister_driver(&pdc_ata_pci_driver);
1025 }
1026
1027
1028 MODULE_AUTHOR("Jeff Garzik");
1029 MODULE_DESCRIPTION("Promise ATA TX2/TX4/TX4000 low-level driver");
1030 MODULE_LICENSE("GPL");
1031 MODULE_DEVICE_TABLE(pci, pdc_ata_pci_tbl);
1032 MODULE_VERSION(DRV_VERSION);
1033
1034 module_init(pdc_ata_init);
1035 module_exit(pdc_ata_exit);