1 /* 2 * ACPI PATA driver 3 * 4 * (c) 2007 Red Hat <alan@redhat.com> 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/module.h> 9 #include <linux/pci.h> 10 #include <linux/init.h> 11 #include <linux/blkdev.h> 12 #include <linux/delay.h> 13 #include <linux/device.h> 14 #include <scsi/scsi_host.h> 15 #include <acpi/acpi_bus.h> 16 #include <acpi/acnames.h> 17 #include <acpi/acnamesp.h> 18 #include <acpi/acparser.h> 19 #include <acpi/acexcep.h> 20 #include <acpi/acmacros.h> 21 #include <acpi/actypes.h> 22 23 #include <linux/libata.h> 24 #include <linux/ata.h> 25 26 #define DRV_NAME "pata_acpi" 27 #define DRV_VERSION "0.2.3" 28 29 struct pata_acpi { 30 struct ata_acpi_gtm gtm; 31 void *last; 32 unsigned long mask[2]; 33 }; 34 35 /** 36 * pacpi_pre_reset - check for 40/80 pin 37 * @ap: Port 38 * @deadline: deadline jiffies for the operation 39 * 40 * Perform the PATA port setup we need. 41 */ 42 43 static int pacpi_pre_reset(struct ata_link *link, unsigned long deadline) 44 { 45 struct ata_port *ap = link->ap; 46 struct pata_acpi *acpi = ap->private_data; 47 if (ap->acpi_handle == NULL || ata_acpi_gtm(ap, &acpi->gtm) < 0) 48 return -ENODEV; 49 50 return ata_std_prereset(link, deadline); 51 } 52 53 /** 54 * pacpi_cable_detect - cable type detection 55 * @ap: port to detect 56 * 57 * Perform device specific cable detection 58 */ 59 60 static int pacpi_cable_detect(struct ata_port *ap) 61 { 62 struct pata_acpi *acpi = ap->private_data; 63 64 if ((acpi->mask[0] | acpi->mask[1]) & (0xF8 << ATA_SHIFT_UDMA)) 65 return ATA_CBL_PATA80; 66 else 67 return ATA_CBL_PATA40; 68 } 69 70 /** 71 * pacpi_error_handler - Setup and error handler 72 * @ap: Port to handle 73 * 74 * LOCKING: 75 * None (inherited from caller). 76 */ 77 78 static void pacpi_error_handler(struct ata_port *ap) 79 { 80 return ata_bmdma_drive_eh(ap, pacpi_pre_reset, ata_std_softreset, 81 NULL, ata_std_postreset); 82 } 83 84 /* Welcome to ACPI, bring a bucket */ 85 static const unsigned int pio_cycle[7] = { 86 600, 383, 240, 180, 120, 100, 80 87 }; 88 static const unsigned int mwdma_cycle[5] = { 89 480, 150, 120, 100, 80 90 }; 91 static const unsigned int udma_cycle[7] = { 92 120, 80, 60, 45, 30, 20, 15 93 }; 94 95 /** 96 * pacpi_discover_modes - filter non ACPI modes 97 * @adev: ATA device 98 * @mask: proposed modes 99 * 100 * Try the modes available and see which ones the ACPI method will 101 * set up sensibly. From this we get a mask of ACPI modes we can use 102 */ 103 104 static unsigned long pacpi_discover_modes(struct ata_port *ap, struct ata_device *adev) 105 { 106 int unit = adev->devno; 107 struct pata_acpi *acpi = ap->private_data; 108 int i; 109 u32 t; 110 unsigned long mask = (0x7f << ATA_SHIFT_UDMA) | (0x7 << ATA_SHIFT_MWDMA) | (0x1F << ATA_SHIFT_PIO); 111 112 struct ata_acpi_gtm probe; 113 114 probe = acpi->gtm; 115 116 /* We always use the 0 slot for crap hardware */ 117 if (!(probe.flags & 0x10)) 118 unit = 0; 119 120 ata_acpi_gtm(ap, &probe); 121 122 /* Start by scanning for PIO modes */ 123 for (i = 0; i < 7; i++) { 124 t = probe.drive[unit].pio; 125 if (t <= pio_cycle[i]) { 126 mask |= (2 << (ATA_SHIFT_PIO + i)) - 1; 127 break; 128 } 129 } 130 131 /* See if we have MWDMA or UDMA data. We don't bother with MWDMA 132 if UDMA is availabe as this means the BIOS set UDMA and our 133 error changedown if it works is UDMA to PIO anyway */ 134 if (probe.flags & (1 << (2 * unit))) { 135 /* MWDMA */ 136 for (i = 0; i < 5; i++) { 137 t = probe.drive[unit].dma; 138 if (t <= mwdma_cycle[i]) { 139 mask |= (2 << (ATA_SHIFT_MWDMA + i)) - 1; 140 break; 141 } 142 } 143 } else { 144 /* UDMA */ 145 for (i = 0; i < 7; i++) { 146 t = probe.drive[unit].dma; 147 if (t <= udma_cycle[i]) { 148 mask |= (2 << (ATA_SHIFT_UDMA + i)) - 1; 149 break; 150 } 151 } 152 } 153 if (mask & (0xF8 << ATA_SHIFT_UDMA)) 154 ap->cbl = ATA_CBL_PATA80; 155 return mask; 156 } 157 158 /** 159 * pacpi_mode_filter - mode filter for ACPI 160 * @adev: device 161 * @mask: mask of valid modes 162 * 163 * Filter the valid mode list according to our own specific rules, in 164 * this case the list of discovered valid modes obtained by ACPI probing 165 */ 166 167 static unsigned long pacpi_mode_filter(struct ata_device *adev, unsigned long mask) 168 { 169 struct pata_acpi *acpi = adev->link->ap->private_data; 170 return ata_pci_default_filter(adev, mask & acpi->mask[adev->devno]); 171 } 172 173 /** 174 * pacpi_set_piomode - set initial PIO mode data 175 * @ap: ATA interface 176 * @adev: ATA device 177 */ 178 179 static void pacpi_set_piomode(struct ata_port *ap, struct ata_device *adev) 180 { 181 int unit = adev->devno; 182 struct pata_acpi *acpi = ap->private_data; 183 184 if(!(acpi->gtm.flags & 0x10)) 185 unit = 0; 186 187 /* Now stuff the nS values into the structure */ 188 acpi->gtm.drive[unit].pio = pio_cycle[adev->pio_mode - XFER_PIO_0]; 189 ata_acpi_stm(ap, &acpi->gtm); 190 /* See what mode we actually got */ 191 ata_acpi_gtm(ap, &acpi->gtm); 192 } 193 194 /** 195 * pacpi_set_dmamode - set initial DMA mode data 196 * @ap: ATA interface 197 * @adev: ATA device 198 */ 199 200 static void pacpi_set_dmamode(struct ata_port *ap, struct ata_device *adev) 201 { 202 int unit = adev->devno; 203 struct pata_acpi *acpi = ap->private_data; 204 205 if(!(acpi->gtm.flags & 0x10)) 206 unit = 0; 207 208 /* Now stuff the nS values into the structure */ 209 if (adev->dma_mode >= XFER_UDMA_0) { 210 acpi->gtm.drive[unit].dma = udma_cycle[adev->dma_mode - XFER_UDMA_0]; 211 acpi->gtm.flags |= (1 << (2 * unit)); 212 } else { 213 acpi->gtm.drive[unit].dma = mwdma_cycle[adev->dma_mode - XFER_MW_DMA_0]; 214 acpi->gtm.flags &= ~(1 << (2 * unit)); 215 } 216 ata_acpi_stm(ap, &acpi->gtm); 217 /* See what mode we actually got */ 218 ata_acpi_gtm(ap, &acpi->gtm); 219 } 220 221 /** 222 * pacpi_qc_issue_prot - command issue 223 * @qc: command pending 224 * 225 * Called when the libata layer is about to issue a command. We wrap 226 * this interface so that we can load the correct ATA timings if 227 * neccessary. 228 */ 229 230 static unsigned int pacpi_qc_issue_prot(struct ata_queued_cmd *qc) 231 { 232 struct ata_port *ap = qc->ap; 233 struct ata_device *adev = qc->dev; 234 struct pata_acpi *acpi = ap->private_data; 235 236 if (acpi->gtm.flags & 0x10) 237 return ata_qc_issue_prot(qc); 238 239 if (adev != acpi->last) { 240 pacpi_set_piomode(ap, adev); 241 if (adev->dma_mode) 242 pacpi_set_dmamode(ap, adev); 243 acpi->last = adev; 244 } 245 return ata_qc_issue_prot(qc); 246 } 247 248 /** 249 * pacpi_port_start - port setup 250 * @ap: ATA port being set up 251 * 252 * Use the port_start hook to maintain private control structures 253 */ 254 255 static int pacpi_port_start(struct ata_port *ap) 256 { 257 struct pci_dev *pdev = to_pci_dev(ap->host->dev); 258 struct pata_acpi *acpi; 259 260 int ret; 261 262 if (ap->acpi_handle == NULL) 263 return -ENODEV; 264 265 acpi = ap->private_data = devm_kzalloc(&pdev->dev, sizeof(struct pata_acpi), GFP_KERNEL); 266 if (ap->private_data == NULL) 267 return -ENOMEM; 268 acpi->mask[0] = pacpi_discover_modes(ap, &ap->link.device[0]); 269 acpi->mask[1] = pacpi_discover_modes(ap, &ap->link.device[1]); 270 ret = ata_sff_port_start(ap); 271 if (ret < 0) 272 return ret; 273 274 return ret; 275 } 276 277 static struct scsi_host_template pacpi_sht = { 278 .module = THIS_MODULE, 279 .name = DRV_NAME, 280 .ioctl = ata_scsi_ioctl, 281 .queuecommand = ata_scsi_queuecmd, 282 .can_queue = ATA_DEF_QUEUE, 283 .this_id = ATA_SHT_THIS_ID, 284 .sg_tablesize = LIBATA_MAX_PRD, 285 .cmd_per_lun = ATA_SHT_CMD_PER_LUN, 286 .emulated = ATA_SHT_EMULATED, 287 .use_clustering = ATA_SHT_USE_CLUSTERING, 288 .proc_name = DRV_NAME, 289 .dma_boundary = ATA_DMA_BOUNDARY, 290 .slave_configure = ata_scsi_slave_config, 291 .slave_destroy = ata_scsi_slave_destroy, 292 /* Use standard CHS mapping rules */ 293 .bios_param = ata_std_bios_param, 294 }; 295 296 static const struct ata_port_operations pacpi_ops = { 297 .set_piomode = pacpi_set_piomode, 298 .set_dmamode = pacpi_set_dmamode, 299 .mode_filter = pacpi_mode_filter, 300 301 /* Task file is PCI ATA format, use helpers */ 302 .tf_load = ata_tf_load, 303 .tf_read = ata_tf_read, 304 .check_status = ata_check_status, 305 .exec_command = ata_exec_command, 306 .dev_select = ata_std_dev_select, 307 308 .freeze = ata_bmdma_freeze, 309 .thaw = ata_bmdma_thaw, 310 .error_handler = pacpi_error_handler, 311 .post_internal_cmd = ata_bmdma_post_internal_cmd, 312 .cable_detect = pacpi_cable_detect, 313 314 /* BMDMA handling is PCI ATA format, use helpers */ 315 .bmdma_setup = ata_bmdma_setup, 316 .bmdma_start = ata_bmdma_start, 317 .bmdma_stop = ata_bmdma_stop, 318 .bmdma_status = ata_bmdma_status, 319 .qc_prep = ata_qc_prep, 320 .qc_issue = pacpi_qc_issue_prot, 321 .data_xfer = ata_data_xfer, 322 323 /* Timeout handling */ 324 .irq_handler = ata_interrupt, 325 .irq_clear = ata_bmdma_irq_clear, 326 .irq_on = ata_irq_on, 327 328 /* Generic PATA PCI ATA helpers */ 329 .port_start = pacpi_port_start, 330 }; 331 332 333 /** 334 * pacpi_init_one - Register ACPI ATA PCI device with kernel services 335 * @pdev: PCI device to register 336 * @ent: Entry in pacpi_pci_tbl matching with @pdev 337 * 338 * Called from kernel PCI layer. 339 * 340 * LOCKING: 341 * Inherited from PCI layer (may sleep). 342 * 343 * RETURNS: 344 * Zero on success, or -ERRNO value. 345 */ 346 347 static int pacpi_init_one (struct pci_dev *pdev, const struct pci_device_id *id) 348 { 349 static const struct ata_port_info info = { 350 .sht = &pacpi_sht, 351 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST, 352 353 .pio_mask = 0x1f, 354 .mwdma_mask = 0x07, 355 .udma_mask = 0x7f, 356 357 .port_ops = &pacpi_ops, 358 }; 359 const struct ata_port_info *ppi[] = { &info, NULL }; 360 return ata_pci_init_one(pdev, ppi); 361 } 362 363 static const struct pci_device_id pacpi_pci_tbl[] = { 364 { PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xFFFFFF00UL, 1}, 365 { } /* terminate list */ 366 }; 367 368 static struct pci_driver pacpi_pci_driver = { 369 .name = DRV_NAME, 370 .id_table = pacpi_pci_tbl, 371 .probe = pacpi_init_one, 372 .remove = ata_pci_remove_one, 373 .suspend = ata_pci_device_suspend, 374 .resume = ata_pci_device_resume, 375 }; 376 377 static int __init pacpi_init(void) 378 { 379 return pci_register_driver(&pacpi_pci_driver); 380 } 381 382 static void __exit pacpi_exit(void) 383 { 384 pci_unregister_driver(&pacpi_pci_driver); 385 } 386 387 module_init(pacpi_init); 388 module_exit(pacpi_exit); 389 390 MODULE_AUTHOR("Alan Cox"); 391 MODULE_DESCRIPTION("SCSI low-level driver for ATA in ACPI mode"); 392 MODULE_LICENSE("GPL"); 393 MODULE_DEVICE_TABLE(pci, pacpi_pci_tbl); 394 MODULE_VERSION(DRV_VERSION); 395 396