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/config.h>
40 #include <linux/kernel.h>
41 #include <linux/module.h>
42 #include <linux/pci.h>
43 #include <linux/init.h>
44 #include <linux/blkdev.h>
45 #include <linux/delay.h>
46 #include <linux/interrupt.h>
47 #include "scsi.h"
48 #include <scsi/scsi_host.h>
49 #include <linux/libata.h>
50
51 #ifdef CONFIG_PPC_OF
52 #include <asm/prom.h>
53 #include <asm/pci-bridge.h>
54 #endif /* CONFIG_PPC_OF */
55
56 #define DRV_NAME "sata_svw"
57 #define DRV_VERSION "1.07"
58
59 /* Taskfile registers offsets */
60 #define K2_SATA_TF_CMD_OFFSET 0x00
61 #define K2_SATA_TF_DATA_OFFSET 0x00
62 #define K2_SATA_TF_ERROR_OFFSET 0x04
63 #define K2_SATA_TF_NSECT_OFFSET 0x08
64 #define K2_SATA_TF_LBAL_OFFSET 0x0c
65 #define K2_SATA_TF_LBAM_OFFSET 0x10
66 #define K2_SATA_TF_LBAH_OFFSET 0x14
67 #define K2_SATA_TF_DEVICE_OFFSET 0x18
68 #define K2_SATA_TF_CMDSTAT_OFFSET 0x1c
69 #define K2_SATA_TF_CTL_OFFSET 0x20
70
71 /* DMA base */
72 #define K2_SATA_DMA_CMD_OFFSET 0x30
73
74 /* SCRs base */
75 #define K2_SATA_SCR_STATUS_OFFSET 0x40
76 #define K2_SATA_SCR_ERROR_OFFSET 0x44
77 #define K2_SATA_SCR_CONTROL_OFFSET 0x48
78
79 /* Others */
80 #define K2_SATA_SICR1_OFFSET 0x80
81 #define K2_SATA_SICR2_OFFSET 0x84
82 #define K2_SATA_SIM_OFFSET 0x88
83
84 /* Port stride */
85 #define K2_SATA_PORT_OFFSET 0x100
86
87 static u8 k2_stat_check_status(struct ata_port *ap);
88
89
k2_sata_scr_read(struct ata_port * ap,unsigned int sc_reg)90 static u32 k2_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
91 {
92 if (sc_reg > SCR_CONTROL)
93 return 0xffffffffU;
94 return readl((void *) ap->ioaddr.scr_addr + (sc_reg * 4));
95 }
96
97
k2_sata_scr_write(struct ata_port * ap,unsigned int sc_reg,u32 val)98 static void k2_sata_scr_write (struct ata_port *ap, unsigned int sc_reg,
99 u32 val)
100 {
101 if (sc_reg > SCR_CONTROL)
102 return;
103 writel(val, (void *) ap->ioaddr.scr_addr + (sc_reg * 4));
104 }
105
106
k2_sata_tf_load(struct ata_port * ap,const struct ata_taskfile * tf)107 static void k2_sata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
108 {
109 struct ata_ioports *ioaddr = &ap->ioaddr;
110 unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
111
112 if (tf->ctl != ap->last_ctl) {
113 writeb(tf->ctl, ioaddr->ctl_addr);
114 ap->last_ctl = tf->ctl;
115 ata_wait_idle(ap);
116 }
117 if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
118 writew(tf->feature | (((u16)tf->hob_feature) << 8), ioaddr->feature_addr);
119 writew(tf->nsect | (((u16)tf->hob_nsect) << 8), ioaddr->nsect_addr);
120 writew(tf->lbal | (((u16)tf->hob_lbal) << 8), ioaddr->lbal_addr);
121 writew(tf->lbam | (((u16)tf->hob_lbam) << 8), ioaddr->lbam_addr);
122 writew(tf->lbah | (((u16)tf->hob_lbah) << 8), ioaddr->lbah_addr);
123 } else if (is_addr) {
124 writew(tf->feature, ioaddr->feature_addr);
125 writew(tf->nsect, ioaddr->nsect_addr);
126 writew(tf->lbal, ioaddr->lbal_addr);
127 writew(tf->lbam, ioaddr->lbam_addr);
128 writew(tf->lbah, ioaddr->lbah_addr);
129 }
130
131 if (tf->flags & ATA_TFLAG_DEVICE)
132 writeb(tf->device, ioaddr->device_addr);
133
134 ata_wait_idle(ap);
135 }
136
137
k2_sata_tf_read(struct ata_port * ap,struct ata_taskfile * tf)138 static void k2_sata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
139 {
140 struct ata_ioports *ioaddr = &ap->ioaddr;
141 u16 nsect, lbal, lbam, lbah, feature;
142
143 tf->command = k2_stat_check_status(ap);
144 tf->device = readw(ioaddr->device_addr);
145 feature = readw(ioaddr->error_addr);
146 nsect = readw(ioaddr->nsect_addr);
147 lbal = readw(ioaddr->lbal_addr);
148 lbam = readw(ioaddr->lbam_addr);
149 lbah = readw(ioaddr->lbah_addr);
150
151 tf->feature = feature;
152 tf->nsect = nsect;
153 tf->lbal = lbal;
154 tf->lbam = lbam;
155 tf->lbah = lbah;
156
157 if (tf->flags & ATA_TFLAG_LBA48) {
158 tf->hob_feature = feature >> 8;
159 tf->hob_nsect = nsect >> 8;
160 tf->hob_lbal = lbal >> 8;
161 tf->hob_lbam = lbam >> 8;
162 tf->hob_lbah = lbah >> 8;
163 }
164 }
165
166 /**
167 * k2_bmdma_setup_mmio - Set up PCI IDE BMDMA transaction (MMIO)
168 * @qc: Info associated with this ATA transaction.
169 *
170 * LOCKING:
171 * spin_lock_irqsave(host_set lock)
172 */
173
k2_bmdma_setup_mmio(struct ata_queued_cmd * qc)174 static void k2_bmdma_setup_mmio (struct ata_queued_cmd *qc)
175 {
176 struct ata_port *ap = qc->ap;
177 unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
178 u8 dmactl;
179 void *mmio = (void *) ap->ioaddr.bmdma_addr;
180 /* load PRD table addr. */
181 mb(); /* make sure PRD table writes are visible to controller */
182 writel(ap->prd_dma, mmio + ATA_DMA_TABLE_OFS);
183
184 /* specify data direction, triple-check start bit is clear */
185 dmactl = readb(mmio + ATA_DMA_CMD);
186 dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
187 if (!rw)
188 dmactl |= ATA_DMA_WR;
189 writeb(dmactl, mmio + ATA_DMA_CMD);
190
191 /* issue r/w command if this is not a ATA DMA command*/
192 if (qc->tf.protocol != ATA_PROT_DMA)
193 ap->ops->exec_command(ap, &qc->tf);
194 }
195
196 /**
197 * k2_bmdma_start_mmio - Start a PCI IDE BMDMA transaction (MMIO)
198 * @qc: Info associated with this ATA transaction.
199 *
200 * LOCKING:
201 * spin_lock_irqsave(host_set lock)
202 */
203
k2_bmdma_start_mmio(struct ata_queued_cmd * qc)204 static void k2_bmdma_start_mmio (struct ata_queued_cmd *qc)
205 {
206 struct ata_port *ap = qc->ap;
207 void *mmio = (void *) ap->ioaddr.bmdma_addr;
208 u8 dmactl;
209
210 /* start host DMA transaction */
211 dmactl = readb(mmio + ATA_DMA_CMD);
212 writeb(dmactl | ATA_DMA_START, mmio + ATA_DMA_CMD);
213 /* There is a race condition in certain SATA controllers that can
214 be seen when the r/w command is given to the controller before the
215 host DMA is started. On a Read command, the controller would initiate
216 the command to the drive even before it sees the DMA start. When there
217 are very fast drives connected to the controller, or when the data request
218 hits in the drive cache, there is the possibility that the drive returns a part
219 or all of the requested data to the controller before the DMA start is issued.
220 In this case, the controller would become confused as to what to do with the data.
221 In the worst case when all the data is returned back to the controller, the
222 controller could hang. In other cases it could return partial data returning
223 in data corruption. This problem has been seen in PPC systems and can also appear
224 on an system with very fast disks, where the SATA controller is sitting behind a
225 number of bridges, and hence there is significant latency between the r/w command
226 and the start command. */
227 /* issue r/w command if the access is to ATA*/
228 if (qc->tf.protocol == ATA_PROT_DMA)
229 ap->ops->exec_command(ap, &qc->tf);
230 }
231
232
k2_stat_check_status(struct ata_port * ap)233 static u8 k2_stat_check_status(struct ata_port *ap)
234 {
235 return readl((void *) ap->ioaddr.status_addr);
236 }
237
238 #ifdef CONFIG_PPC_OF
239 /*
240 * k2_sata_proc_info
241 * inout : decides on the direction of the dataflow and the meaning of the
242 * variables
243 * buffer: If inout==FALSE data is being written to it else read from it
244 * *start: If inout==FALSE start of the valid data in the buffer
245 * offset: If inout==FALSE offset from the beginning of the imaginary file
246 * from which we start writing into the buffer
247 * length: If inout==FALSE max number of bytes to be written into the buffer
248 * else number of bytes in the buffer
249 */
k2_sata_proc_info(struct Scsi_Host * shost,char * page,char ** start,off_t offset,int count,int inout)250 static int k2_sata_proc_info(struct Scsi_Host *shost, char *page, char **start,
251 off_t offset, int count, int inout)
252 {
253 struct ata_port *ap;
254 struct device_node *np;
255 int len, index;
256
257 /* Find the ata_port */
258 ap = (struct ata_port *) &shost->hostdata[0];
259 if (ap == NULL)
260 return 0;
261
262 /* Find the OF node for the PCI device proper */
263 np = pci_device_to_OF_node(to_pci_dev(ap->host_set->dev));
264 if (np == NULL)
265 return 0;
266
267 /* Match it to a port node */
268 index = (ap == ap->host_set->ports[0]) ? 0 : 1;
269 for (np = np->child; np != NULL; np = np->sibling) {
270 u32 *reg = (u32 *)get_property(np, "reg", NULL);
271 if (!reg)
272 continue;
273 if (index == *reg)
274 break;
275 }
276 if (np == NULL)
277 return 0;
278
279 len = sprintf(page, "devspec: %s\n", np->full_name);
280
281 return len;
282 }
283 #endif /* CONFIG_PPC_OF */
284
285
286 static Scsi_Host_Template k2_sata_sht = {
287 .module = THIS_MODULE,
288 .name = DRV_NAME,
289 .detect = ata_scsi_detect,
290 .release = ata_scsi_release,
291 .ioctl = ata_scsi_ioctl,
292 .queuecommand = ata_scsi_queuecmd,
293 .eh_strategy_handler = ata_scsi_error,
294 .can_queue = ATA_DEF_QUEUE,
295 .this_id = ATA_SHT_THIS_ID,
296 .sg_tablesize = LIBATA_MAX_PRD,
297 .max_sectors = ATA_MAX_SECTORS,
298 .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
299 .use_new_eh_code = ATA_SHT_NEW_EH_CODE,
300 .emulated = ATA_SHT_EMULATED,
301 .use_clustering = ATA_SHT_USE_CLUSTERING,
302 .proc_name = DRV_NAME,
303 #ifdef CONFIG_PPC_OF
304 .proc_info = k2_sata_proc_info,
305 #endif
306 .bios_param = ata_std_bios_param,
307 };
308
309
310 static const struct ata_port_operations k2_sata_ops = {
311 .port_disable = ata_port_disable,
312 .tf_load = k2_sata_tf_load,
313 .tf_read = k2_sata_tf_read,
314 .check_status = k2_stat_check_status,
315 .exec_command = ata_exec_command,
316 .dev_select = ata_std_dev_select,
317 .phy_reset = sata_phy_reset,
318 .bmdma_setup = k2_bmdma_setup_mmio,
319 .bmdma_start = k2_bmdma_start_mmio,
320 .bmdma_stop = ata_bmdma_stop,
321 .bmdma_status = ata_bmdma_status,
322 .qc_prep = ata_qc_prep,
323 .qc_issue = ata_qc_issue_prot,
324 .eng_timeout = ata_eng_timeout,
325 .irq_handler = ata_interrupt,
326 .irq_clear = ata_bmdma_irq_clear,
327 .scr_read = k2_sata_scr_read,
328 .scr_write = k2_sata_scr_write,
329 .port_start = ata_port_start,
330 .port_stop = ata_port_stop,
331 .host_stop = ata_pci_host_stop,
332 };
333
k2_sata_setup_port(struct ata_ioports * port,unsigned long base)334 static void k2_sata_setup_port(struct ata_ioports *port, unsigned long base)
335 {
336 port->cmd_addr = base + K2_SATA_TF_CMD_OFFSET;
337 port->data_addr = base + K2_SATA_TF_DATA_OFFSET;
338 port->feature_addr =
339 port->error_addr = base + K2_SATA_TF_ERROR_OFFSET;
340 port->nsect_addr = base + K2_SATA_TF_NSECT_OFFSET;
341 port->lbal_addr = base + K2_SATA_TF_LBAL_OFFSET;
342 port->lbam_addr = base + K2_SATA_TF_LBAM_OFFSET;
343 port->lbah_addr = base + K2_SATA_TF_LBAH_OFFSET;
344 port->device_addr = base + K2_SATA_TF_DEVICE_OFFSET;
345 port->command_addr =
346 port->status_addr = base + K2_SATA_TF_CMDSTAT_OFFSET;
347 port->altstatus_addr =
348 port->ctl_addr = base + K2_SATA_TF_CTL_OFFSET;
349 port->bmdma_addr = base + K2_SATA_DMA_CMD_OFFSET;
350 port->scr_addr = base + K2_SATA_SCR_STATUS_OFFSET;
351 }
352
353
k2_sata_init_one(struct pci_dev * pdev,const struct pci_device_id * ent)354 static int k2_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
355 {
356 static int printed_version;
357 struct ata_probe_ent *probe_ent = NULL;
358 unsigned long base;
359 void __iomem *mmio_base;
360 int pci_dev_busy = 0;
361 int rc;
362 int i;
363
364 if (!printed_version++)
365 pdev_printk(KERN_DEBUG, pdev, "version " DRV_VERSION "\n");
366
367 /*
368 * If this driver happens to only be useful on Apple's K2, then
369 * we should check that here as it has a normal Serverworks ID
370 */
371 rc = pci_enable_device(pdev);
372 if (rc)
373 return rc;
374 /*
375 * Check if we have resources mapped at all (second function may
376 * have been disabled by firmware)
377 */
378 if (pci_resource_len(pdev, 5) == 0)
379 return -ENODEV;
380
381 /* Request PCI regions */
382 rc = pci_request_regions(pdev, DRV_NAME);
383 if (rc) {
384 pci_dev_busy = 1;
385 goto err_out;
386 }
387
388 rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
389 if (rc)
390 goto err_out_regions;
391 rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
392 if (rc)
393 goto err_out_regions;
394
395 probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
396 if (probe_ent == NULL) {
397 rc = -ENOMEM;
398 goto err_out_regions;
399 }
400
401 memset(probe_ent, 0, sizeof(*probe_ent));
402 probe_ent->dev = pci_dev_to_dev(pdev);
403 INIT_LIST_HEAD(&probe_ent->node);
404
405 mmio_base = pci_iomap(pdev, 5, 0);
406 if (mmio_base == NULL) {
407 rc = -ENOMEM;
408 goto err_out_free_ent;
409 }
410 base = (unsigned long) mmio_base;
411
412 /* Clear a magic bit in SCR1 according to Darwin, those help
413 * some funky seagate drives (though so far, those were already
414 * set by the firmware on the machines I had access to)
415 */
416 writel(readl(mmio_base + K2_SATA_SICR1_OFFSET) & ~0x00040000,
417 mmio_base + K2_SATA_SICR1_OFFSET);
418
419 /* Clear SATA error & interrupts we don't use */
420 writel(0xffffffff, mmio_base + K2_SATA_SCR_ERROR_OFFSET);
421 writel(0x0, mmio_base + K2_SATA_SIM_OFFSET);
422
423 probe_ent->sht = &k2_sata_sht;
424 probe_ent->host_flags = ATA_FLAG_SATA | ATA_FLAG_SATA_RESET |
425 ATA_FLAG_NO_LEGACY | ATA_FLAG_MMIO;
426 probe_ent->port_ops = &k2_sata_ops;
427 probe_ent->n_ports = 4;
428 probe_ent->irq = pdev->irq;
429 probe_ent->irq_flags = SA_SHIRQ;
430 probe_ent->mmio_base = mmio_base;
431
432 /* We don't care much about the PIO/UDMA masks, but the core won't like us
433 * if we don't fill these
434 */
435 probe_ent->pio_mask = 0x1f;
436 probe_ent->mwdma_mask = 0x7;
437 probe_ent->udma_mask = 0x7f;
438
439 /* different controllers have different number of ports - currently 4 or 8 */
440 /* All ports are on the same function. Multi-function device is no
441 * longer available. This should not be seen in any system. */
442 for (i = 0; i < ent->driver_data; i++)
443 k2_sata_setup_port(&probe_ent->port[i], base + i * K2_SATA_PORT_OFFSET);
444
445 pci_set_master(pdev);
446
447 ata_add_to_probe_list(probe_ent);
448
449 return 0;
450
451 err_out_free_ent:
452 kfree(probe_ent);
453 err_out_regions:
454 pci_release_regions(pdev);
455 err_out:
456 if (!pci_dev_busy)
457 pci_disable_device(pdev);
458 return rc;
459 }
460
461 /* 0x240 is device ID for Apple K2 device
462 * 0x241 is device ID for Serverworks Frodo4
463 * 0x242 is device ID for Serverworks Frodo8
464 * 0x24a is device ID for BCM5785 (aka HT1000) HT southbridge integrated SATA
465 * controller
466 * */
467 static const struct pci_device_id k2_sata_pci_tbl[] = {
468 { 0x1166, 0x0240, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
469 { 0x1166, 0x0241, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
470 { 0x1166, 0x0242, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
471 { 0x1166, 0x024a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
472 { }
473 };
474
475
476 static struct pci_driver k2_sata_pci_driver = {
477 .name = DRV_NAME,
478 .id_table = k2_sata_pci_tbl,
479 .probe = k2_sata_init_one,
480 .remove = ata_pci_remove_one,
481 };
482
483
k2_sata_init(void)484 static int __init k2_sata_init(void)
485 {
486 int rc;
487
488 rc = pci_module_init(&k2_sata_pci_driver);
489 if (rc)
490 return rc;
491
492 rc = scsi_register_module(MODULE_SCSI_HA, &k2_sata_sht);
493 if (rc) {
494 rc = -ENODEV;
495 goto err_out;
496 }
497
498 return 0;
499
500 err_out:
501 pci_unregister_driver(&k2_sata_pci_driver);
502 return rc;
503 }
504
505
k2_sata_exit(void)506 static void __exit k2_sata_exit(void)
507 {
508 scsi_unregister_module(MODULE_SCSI_HA, &k2_sata_sht);
509 pci_unregister_driver(&k2_sata_pci_driver);
510 }
511
512
513 MODULE_AUTHOR("Benjamin Herrenschmidt");
514 MODULE_DESCRIPTION("low-level driver for K2 SATA controller");
515 MODULE_LICENSE("GPL");
516 MODULE_DEVICE_TABLE(pci, k2_sata_pci_tbl);
517 MODULE_VERSION(DRV_VERSION);
518
519 module_init(k2_sata_init);
520 module_exit(k2_sata_exit);
521