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