Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/ata/sata_svw.c

  1 /*
  2  *  sata_svw.c - ServerWorks / Apple K2 SATA
  3  *
  4  *  Maintained by: Benjamin Herrenschmidt <benh@kernel.crashing.org> and
  5  *                 Jeff Garzik <jgarzik@pobox.com>
  6  *                  Please ALWAYS copy linux-ide@vger.kernel.org
  7  *                  on emails.
  8  *
  9  *  Copyright 2003 Benjamin Herrenschmidt <benh@kernel.crashing.org>
 10  *
 11  *  Bits from Jeff Garzik, Copyright RedHat, Inc.
 12  *
 13  *  This driver probably works with non-Apple versions of the
 14  *  Broadcom chipset...
 15  *
 16  *
 17  *  This program is free software; you can redistribute it and/or modify
 18  *  it under the terms of the GNU General Public License as published by
 19  *  the Free Software Foundation; either version 2, or (at your option)
 20  *  any later version.
 21  *
 22  *  This program is distributed in the hope that it will be useful,
 23  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 24  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 25  *  GNU General Public License for more details.
 26  *
 27  *  You should have received a copy of the GNU General Public License
 28  *  along with this program; see the file COPYING.  If not, write to
 29  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 30  *
 31  *
 32  *  libata documentation is available via 'make {ps|pdf}docs',
 33  *  as Documentation/DocBook/libata.*
 34  *
 35  *  Hardware documentation available under NDA.
 36  *
 37  */
 38 
 39 #include <linux/kernel.h>
 40 #include <linux/module.h>
 41 #include <linux/pci.h>
 42 #include <linux/init.h>
 43 #include <linux/blkdev.h>
 44 #include <linux/delay.h>
 45 #include <linux/interrupt.h>
 46 #include <linux/device.h>
 47 #include <scsi/scsi_host.h>
 48 #include <scsi/scsi_cmnd.h>
 49 #include <scsi/scsi.h>
 50 #include <linux/libata.h>
 51 
 52 #ifdef CONFIG_PPC_OF
 53 #include <asm/prom.h>
 54 #include <asm/pci-bridge.h>
 55 #endif /* CONFIG_PPC_OF */
 56 
 57 #define DRV_NAME        "sata_svw"
 58 #define DRV_VERSION     "2.3"
 59 
 60 enum {
 61         /* ap->flags bits */
 62         K2_FLAG_SATA_8_PORTS            = (1 << 24),
 63         K2_FLAG_NO_ATAPI_DMA            = (1 << 25),
 64         K2_FLAG_BAR_POS_3                       = (1 << 26),
 65 
 66         /* Taskfile registers offsets */
 67         K2_SATA_TF_CMD_OFFSET           = 0x00,
 68         K2_SATA_TF_DATA_OFFSET          = 0x00,
 69         K2_SATA_TF_ERROR_OFFSET         = 0x04,
 70         K2_SATA_TF_NSECT_OFFSET         = 0x08,
 71         K2_SATA_TF_LBAL_OFFSET          = 0x0c,
 72         K2_SATA_TF_LBAM_OFFSET          = 0x10,
 73         K2_SATA_TF_LBAH_OFFSET          = 0x14,
 74         K2_SATA_TF_DEVICE_OFFSET        = 0x18,
 75         K2_SATA_TF_CMDSTAT_OFFSET       = 0x1c,
 76         K2_SATA_TF_CTL_OFFSET           = 0x20,
 77 
 78         /* DMA base */
 79         K2_SATA_DMA_CMD_OFFSET          = 0x30,
 80 
 81         /* SCRs base */
 82         K2_SATA_SCR_STATUS_OFFSET       = 0x40,
 83         K2_SATA_SCR_ERROR_OFFSET        = 0x44,
 84         K2_SATA_SCR_CONTROL_OFFSET      = 0x48,
 85 
 86         /* Others */
 87         K2_SATA_SICR1_OFFSET            = 0x80,
 88         K2_SATA_SICR2_OFFSET            = 0x84,
 89         K2_SATA_SIM_OFFSET              = 0x88,
 90 
 91         /* Port stride */
 92         K2_SATA_PORT_OFFSET             = 0x100,
 93 
 94         chip_svw4                       = 0,
 95         chip_svw8                       = 1,
 96         chip_svw42                      = 2,    /* bar 3 */
 97         chip_svw43                      = 3,    /* bar 5 */
 98 };
 99 
100 static u8 k2_stat_check_status(struct ata_port *ap);
101 
102 
103 static int k2_sata_check_atapi_dma(struct ata_queued_cmd *qc)
104 {
105         u8 cmnd = qc->scsicmd->cmnd[0];
106 
107         if (qc->ap->flags & K2_FLAG_NO_ATAPI_DMA)
108                 return -1;      /* ATAPI DMA not supported */
109         else {
110                 switch (cmnd) {
111                 case READ_10:
112                 case READ_12:
113                 case READ_16:
114                 case WRITE_10:
115                 case WRITE_12:
116                 case WRITE_16:
117                         return 0;
118 
119                 default:
120                         return -1;
121                 }
122 
123         }
124 }
125 
126 static int k2_sata_scr_read(struct ata_link *link,
127                             unsigned int sc_reg, u32 *val)
128 {
129         if (sc_reg > SCR_CONTROL)
130                 return -EINVAL;
131         *val = readl(link->ap->ioaddr.scr_addr + (sc_reg * 4));
132         return 0;
133 }
134 
135 
136 static int k2_sata_scr_write(struct ata_link *link,
137                              unsigned int sc_reg, u32 val)
138 {
139         if (sc_reg > SCR_CONTROL)
140                 return -EINVAL;
141         writel(val, link->ap->ioaddr.scr_addr + (sc_reg * 4));
142         return 0;
143 }
144 
145 static int k2_sata_softreset(struct ata_link *link,
146                              unsigned int *class, unsigned long deadline)
147 {
148         u8 dmactl;
149         void __iomem *mmio = link->ap->ioaddr.bmdma_addr;
150 
151         dmactl = readb(mmio + ATA_DMA_CMD);
152 
153         /* Clear the start bit */
154         if (dmactl & ATA_DMA_START) {
155                 dmactl &= ~ATA_DMA_START;
156                 writeb(dmactl, mmio + ATA_DMA_CMD);
157         }
158 
159         return ata_sff_softreset(link, class, deadline);
160 }
161 
162 static int k2_sata_hardreset(struct ata_link *link,
163                              unsigned int *class, unsigned long deadline)
164 {
165         u8 dmactl;
166         void __iomem *mmio = link->ap->ioaddr.bmdma_addr;
167 
168         dmactl = readb(mmio + ATA_DMA_CMD);
169 
170         /* Clear the start bit */
171         if (dmactl & ATA_DMA_START) {
172                 dmactl &= ~ATA_DMA_START;
173                 writeb(dmactl, mmio + ATA_DMA_CMD);
174         }
175 
176         return sata_sff_hardreset(link, class, deadline);
177 }
178 
179 static void k2_sata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
180 {
181         struct ata_ioports *ioaddr = &ap->ioaddr;
182         unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
183 
184         if (tf->ctl != ap->last_ctl) {
185                 writeb(tf->ctl, ioaddr->ctl_addr);
186                 ap->last_ctl = tf->ctl;
187                 ata_wait_idle(ap);
188         }
189         if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
190                 writew(tf->feature | (((u16)tf->hob_feature) << 8),
191                        ioaddr->feature_addr);
192                 writew(tf->nsect | (((u16)tf->hob_nsect) << 8),
193                        ioaddr->nsect_addr);
194                 writew(tf->lbal | (((u16)tf->hob_lbal) << 8),
195                        ioaddr->lbal_addr);
196                 writew(tf->lbam | (((u16)tf->hob_lbam) << 8),
197                        ioaddr->lbam_addr);
198                 writew(tf->lbah | (((u16)tf->hob_lbah) << 8),
199                        ioaddr->lbah_addr);
200         } else if (is_addr) {
201                 writew(tf->feature, ioaddr->feature_addr);
202                 writew(tf->nsect, ioaddr->nsect_addr);
203                 writew(tf->lbal, ioaddr->lbal_addr);
204                 writew(tf->lbam, ioaddr->lbam_addr);
205                 writew(tf->lbah, ioaddr->lbah_addr);
206         }
207 
208         if (tf->flags & ATA_TFLAG_DEVICE)
209                 writeb(tf->device, ioaddr->device_addr);
210 
211         ata_wait_idle(ap);
212 }
213 
214 
215 static void k2_sata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
216 {
217         struct ata_ioports *ioaddr = &ap->ioaddr;
218         u16 nsect, lbal, lbam, lbah, feature;
219 
220         tf->command = k2_stat_check_status(ap);
221         tf->device = readw(ioaddr->device_addr);
222         feature = readw(ioaddr->error_addr);
223         nsect = readw(ioaddr->nsect_addr);
224         lbal = readw(ioaddr->lbal_addr);
225         lbam = readw(ioaddr->lbam_addr);
226         lbah = readw(ioaddr->lbah_addr);
227 
228         tf->feature = feature;
229         tf->nsect = nsect;
230         tf->lbal = lbal;
231         tf->lbam = lbam;
232         tf->lbah = lbah;
233 
234         if (tf->flags & ATA_TFLAG_LBA48) {
235                 tf->hob_feature = feature >> 8;
236                 tf->hob_nsect = nsect >> 8;
237                 tf->hob_lbal = lbal >> 8;
238                 tf->hob_lbam = lbam >> 8;
239                 tf->hob_lbah = lbah >> 8;
240         }
241 }
242 
243 /**
244  *      k2_bmdma_setup_mmio - Set up PCI IDE BMDMA transaction (MMIO)
245  *      @qc: Info associated with this ATA transaction.
246  *
247  *      LOCKING:
248  *      spin_lock_irqsave(host lock)
249  */
250 
251 static void k2_bmdma_setup_mmio(struct ata_queued_cmd *qc)
252 {
253         struct ata_port *ap = qc->ap;
254         unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
255         u8 dmactl;
256         void __iomem *mmio = ap->ioaddr.bmdma_addr;
257 
258         /* load PRD table addr. */
259         mb();   /* make sure PRD table writes are visible to controller */
260         writel(ap->bmdma_prd_dma, mmio + ATA_DMA_TABLE_OFS);
261 
262         /* specify data direction, triple-check start bit is clear */
263         dmactl = readb(mmio + ATA_DMA_CMD);
264         dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
265         if (!rw)
266                 dmactl |= ATA_DMA_WR;
267         writeb(dmactl, mmio + ATA_DMA_CMD);
268 
269         /* issue r/w command if this is not a ATA DMA command*/
270         if (qc->tf.protocol != ATA_PROT_DMA)
271                 ap->ops->sff_exec_command(ap, &qc->tf);
272 }
273 
274 /**
275  *      k2_bmdma_start_mmio - Start a PCI IDE BMDMA transaction (MMIO)
276  *      @qc: Info associated with this ATA transaction.
277  *
278  *      LOCKING:
279  *      spin_lock_irqsave(host lock)
280  */
281 
282 static void k2_bmdma_start_mmio(struct ata_queued_cmd *qc)
283 {
284         struct ata_port *ap = qc->ap;
285         void __iomem *mmio = ap->ioaddr.bmdma_addr;
286         u8 dmactl;
287 
288         /* start host DMA transaction */
289         dmactl = readb(mmio + ATA_DMA_CMD);
290         writeb(dmactl | ATA_DMA_START, mmio + ATA_DMA_CMD);
291         /* This works around possible data corruption.
292 
293            On certain SATA controllers that can be seen when the r/w
294            command is given to the controller before the host DMA is
295            started.
296 
297            On a Read command, the controller would initiate the
298            command to the drive even before it sees the DMA
299            start. When there are very fast drives connected to the
300            controller, or when the data request hits in the drive
301            cache, there is the possibility that the drive returns a
302            part or all of the requested data to the controller before
303            the DMA start is issued.  In this case, the controller
304            would become confused as to what to do with the data.  In
305            the worst case when all the data is returned back to the
306            controller, the controller could hang. In other cases it
307            could return partial data returning in data
308            corruption. This problem has been seen in PPC systems and
309            can also appear on an system with very fast disks, where
310            the SATA controller is sitting behind a number of bridges,
311            and hence there is significant latency between the r/w
312            command and the start command. */
313         /* issue r/w command if the access is to ATA */
314         if (qc->tf.protocol == ATA_PROT_DMA)
315                 ap->ops->sff_exec_command(ap, &qc->tf);
316 }
317 
318 
319 static u8 k2_stat_check_status(struct ata_port *ap)
320 {
321         return readl(ap->ioaddr.status_addr);
322 }
323 
324 #ifdef CONFIG_PPC_OF
325 static int k2_sata_show_info(struct seq_file *m, struct Scsi_Host *shost)
326 {
327         struct ata_port *ap;
328         struct device_node *np;
329         int index;
330 
331         /* Find  the ata_port */
332         ap = ata_shost_to_port(shost);
333         if (ap == NULL)
334                 return 0;
335 
336         /* Find the OF node for the PCI device proper */
337         np = pci_device_to_OF_node(to_pci_dev(ap->host->dev));
338         if (np == NULL)
339                 return 0;
340 
341         /* Match it to a port node */
342         index = (ap == ap->host->ports[0]) ? 0 : 1;
343         for (np = np->child; np != NULL; np = np->sibling) {
344                 const u32 *reg = of_get_property(np, "reg", NULL);
345                 if (!reg)
346                         continue;
347                 if (index == *reg) {
348                         seq_printf(m, "devspec: %s\n", np->full_name);
349                         break;
350                 }
351         }
352         return 0;
353 }
354 #endif /* CONFIG_PPC_OF */
355 
356 
357 static struct scsi_host_template k2_sata_sht = {
358         ATA_BMDMA_SHT(DRV_NAME),
359 #ifdef CONFIG_PPC_OF
360         .show_info              = k2_sata_show_info,
361 #endif
362 };
363 
364 
365 static struct ata_port_operations k2_sata_ops = {
366         .inherits               = &ata_bmdma_port_ops,
367         .softreset              = k2_sata_softreset,
368         .hardreset              = k2_sata_hardreset,
369         .sff_tf_load            = k2_sata_tf_load,
370         .sff_tf_read            = k2_sata_tf_read,
371         .sff_check_status       = k2_stat_check_status,
372         .check_atapi_dma        = k2_sata_check_atapi_dma,
373         .bmdma_setup            = k2_bmdma_setup_mmio,
374         .bmdma_start            = k2_bmdma_start_mmio,
375         .scr_read               = k2_sata_scr_read,
376         .scr_write              = k2_sata_scr_write,
377 };
378 
379 static const struct ata_port_info k2_port_info[] = {
380         /* chip_svw4 */
381         {
382                 .flags          = ATA_FLAG_SATA | K2_FLAG_NO_ATAPI_DMA,
383                 .pio_mask       = ATA_PIO4,
384                 .mwdma_mask     = ATA_MWDMA2,
385                 .udma_mask      = ATA_UDMA6,
386                 .port_ops       = &k2_sata_ops,
387         },
388         /* chip_svw8 */
389         {
390                 .flags          = ATA_FLAG_SATA | K2_FLAG_NO_ATAPI_DMA |
391                                   K2_FLAG_SATA_8_PORTS,
392                 .pio_mask       = ATA_PIO4,
393                 .mwdma_mask     = ATA_MWDMA2,
394                 .udma_mask      = ATA_UDMA6,
395                 .port_ops       = &k2_sata_ops,
396         },
397         /* chip_svw42 */
398         {
399                 .flags          = ATA_FLAG_SATA | K2_FLAG_BAR_POS_3,
400                 .pio_mask       = ATA_PIO4,
401                 .mwdma_mask     = ATA_MWDMA2,
402                 .udma_mask      = ATA_UDMA6,
403                 .port_ops       = &k2_sata_ops,
404         },
405         /* chip_svw43 */
406         {
407                 .flags          = ATA_FLAG_SATA,
408                 .pio_mask       = ATA_PIO4,
409                 .mwdma_mask     = ATA_MWDMA2,
410                 .udma_mask      = ATA_UDMA6,
411                 .port_ops       = &k2_sata_ops,
412         },
413 };
414 
415 static void k2_sata_setup_port(struct ata_ioports *port, void __iomem *base)
416 {
417         port->cmd_addr          = base + K2_SATA_TF_CMD_OFFSET;
418         port->data_addr         = base + K2_SATA_TF_DATA_OFFSET;
419         port->feature_addr      =
420         port->error_addr        = base + K2_SATA_TF_ERROR_OFFSET;
421         port->nsect_addr        = base + K2_SATA_TF_NSECT_OFFSET;
422         port->lbal_addr         = base + K2_SATA_TF_LBAL_OFFSET;
423         port->lbam_addr         = base + K2_SATA_TF_LBAM_OFFSET;
424         port->lbah_addr         = base + K2_SATA_TF_LBAH_OFFSET;
425         port->device_addr       = base + K2_SATA_TF_DEVICE_OFFSET;
426         port->command_addr      =
427         port->status_addr       = base + K2_SATA_TF_CMDSTAT_OFFSET;
428         port->altstatus_addr    =
429         port->ctl_addr          = base + K2_SATA_TF_CTL_OFFSET;
430         port->bmdma_addr        = base + K2_SATA_DMA_CMD_OFFSET;
431         port->scr_addr          = base + K2_SATA_SCR_STATUS_OFFSET;
432 }
433 
434 
435 static int k2_sata_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
436 {
437         const struct ata_port_info *ppi[] =
438                 { &k2_port_info[ent->driver_data], NULL };
439         struct ata_host *host;
440         void __iomem *mmio_base;
441         int n_ports, i, rc, bar_pos;
442 
443         ata_print_version_once(&pdev->dev, DRV_VERSION);
444 
445         /* allocate host */
446         n_ports = 4;
447         if (ppi[0]->flags & K2_FLAG_SATA_8_PORTS)
448                 n_ports = 8;
449 
450         host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
451         if (!host)
452                 return -ENOMEM;
453 
454         bar_pos = 5;
455         if (ppi[0]->flags & K2_FLAG_BAR_POS_3)
456                 bar_pos = 3;
457         /*
458          * If this driver happens to only be useful on Apple's K2, then
459          * we should check that here as it has a normal Serverworks ID
460          */
461         rc = pcim_enable_device(pdev);
462         if (rc)
463                 return rc;
464 
465         /*
466          * Check if we have resources mapped at all (second function may
467          * have been disabled by firmware)
468          */
469         if (pci_resource_len(pdev, bar_pos) == 0) {
470                 /* In IDE mode we need to pin the device to ensure that
471                         pcim_release does not clear the busmaster bit in config
472                         space, clearing causes busmaster DMA to fail on
473                         ports 3 & 4 */
474                 pcim_pin_device(pdev);
475                 return -ENODEV;
476         }
477 
478         /* Request and iomap PCI regions */
479         rc = pcim_iomap_regions(pdev, 1 << bar_pos, DRV_NAME);
480         if (rc == -EBUSY)
481                 pcim_pin_device(pdev);
482         if (rc)
483                 return rc;
484         host->iomap = pcim_iomap_table(pdev);
485         mmio_base = host->iomap[bar_pos];
486 
487         /* different controllers have different number of ports - currently 4 or 8 */
488         /* All ports are on the same function. Multi-function device is no
489          * longer available. This should not be seen in any system. */
490         for (i = 0; i < host->n_ports; i++) {
491                 struct ata_port *ap = host->ports[i];
492                 unsigned int offset = i * K2_SATA_PORT_OFFSET;
493 
494                 k2_sata_setup_port(&ap->ioaddr, mmio_base + offset);
495 
496                 ata_port_pbar_desc(ap, 5, -1, "mmio");
497                 ata_port_pbar_desc(ap, 5, offset, "port");
498         }
499 
500         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
501         if (rc)
502                 return rc;
503         rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
504         if (rc)
505                 return rc;
506 
507         /* Clear a magic bit in SCR1 according to Darwin, those help
508          * some funky seagate drives (though so far, those were already
509          * set by the firmware on the machines I had access to)
510          */
511         writel(readl(mmio_base + K2_SATA_SICR1_OFFSET) & ~0x00040000,
512                mmio_base + K2_SATA_SICR1_OFFSET);
513 
514         /* Clear SATA error & interrupts we don't use */
515         writel(0xffffffff, mmio_base + K2_SATA_SCR_ERROR_OFFSET);
516         writel(0x0, mmio_base + K2_SATA_SIM_OFFSET);
517 
518         pci_set_master(pdev);
519         return ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
520                                  IRQF_SHARED, &k2_sata_sht);
521 }
522 
523 /* 0x240 is device ID for Apple K2 device
524  * 0x241 is device ID for Serverworks Frodo4
525  * 0x242 is device ID for Serverworks Frodo8
526  * 0x24a is device ID for BCM5785 (aka HT1000) HT southbridge integrated SATA
527  * controller
528  * */
529 static const struct pci_device_id k2_sata_pci_tbl[] = {
530         { PCI_VDEVICE(SERVERWORKS, 0x0240), chip_svw4 },
531         { PCI_VDEVICE(SERVERWORKS, 0x0241), chip_svw8 },
532         { PCI_VDEVICE(SERVERWORKS, 0x0242), chip_svw4 },
533         { PCI_VDEVICE(SERVERWORKS, 0x024a), chip_svw4 },
534         { PCI_VDEVICE(SERVERWORKS, 0x024b), chip_svw4 },
535         { PCI_VDEVICE(SERVERWORKS, 0x0410), chip_svw42 },
536         { PCI_VDEVICE(SERVERWORKS, 0x0411), chip_svw43 },
537 
538         { }
539 };
540 
541 static struct pci_driver k2_sata_pci_driver = {
542         .name                   = DRV_NAME,
543         .id_table               = k2_sata_pci_tbl,
544         .probe                  = k2_sata_init_one,
545         .remove                 = ata_pci_remove_one,
546 };
547 
548 module_pci_driver(k2_sata_pci_driver);
549 
550 MODULE_AUTHOR("Benjamin Herrenschmidt");
551 MODULE_DESCRIPTION("low-level driver for K2 SATA controller");
552 MODULE_LICENSE("GPL");
553 MODULE_DEVICE_TABLE(pci, k2_sata_pci_tbl);
554 MODULE_VERSION(DRV_VERSION);
555 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us