1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * pata_pcmcia.c - PCMCIA PATA controller driver. 4 * Copyright 2005-2006 Red Hat Inc, all rights reserved. 5 * PCMCIA ident update Copyright 2006 Marcin Juszkiewicz 6 * <openembedded@hrw.one.pl> 7 * 8 * Heavily based upon ide-cs.c 9 * The initial developer of the original code is David A. Hinds 10 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds 11 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/blkdev.h> 17 #include <linux/delay.h> 18 #include <linux/slab.h> 19 #include <scsi/scsi_host.h> 20 #include <linux/ata.h> 21 #include <linux/libata.h> 22 23 #include <pcmcia/cistpl.h> 24 #include <pcmcia/ds.h> 25 #include <pcmcia/cisreg.h> 26 #include <pcmcia/ciscode.h> 27 28 29 #define DRV_NAME "pata_pcmcia" 30 #define DRV_VERSION "0.3.5" 31 32 /** 33 * pcmcia_set_mode - PCMCIA specific mode setup 34 * @link: link 35 * @r_failed_dev: Return pointer for failed device 36 * 37 * Perform the tuning and setup of the devices and timings, which 38 * for PCMCIA is the same as any other controller. We wrap it however 39 * as we need to spot hardware with incorrect or missing master/slave 40 * decode, which alas is embarrassingly common in the PC world 41 */ 42 43 static int pcmcia_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 44 { 45 struct ata_device *master = &link->device[0]; 46 struct ata_device *slave = &link->device[1]; 47 48 if (!ata_dev_enabled(master) || !ata_dev_enabled(slave)) 49 return ata_do_set_mode(link, r_failed_dev); 50 51 if (memcmp(master->id + ATA_ID_FW_REV, slave->id + ATA_ID_FW_REV, 52 ATA_ID_FW_REV_LEN + ATA_ID_PROD_LEN) == 0) { 53 /* Suspicious match, but could be two cards from 54 the same vendor - check serial */ 55 if (memcmp(master->id + ATA_ID_SERNO, slave->id + ATA_ID_SERNO, 56 ATA_ID_SERNO_LEN) == 0 && master->id[ATA_ID_SERNO] >> 8) { 57 ata_dev_warn(slave, "is a ghost device, ignoring\n"); 58 ata_dev_disable(slave); 59 } 60 } 61 return ata_do_set_mode(link, r_failed_dev); 62 } 63 64 /** 65 * pcmcia_set_mode_8bit - PCMCIA specific mode setup 66 * @link: link 67 * @r_failed_dev: Return pointer for failed device 68 * 69 * For the simple emulated 8bit stuff the less we do the better. 70 */ 71 72 static int pcmcia_set_mode_8bit(struct ata_link *link, 73 struct ata_device **r_failed_dev) 74 { 75 return 0; 76 } 77 78 /** 79 * ata_data_xfer_8bit - Transfer data by 8bit PIO 80 * @qc: queued command 81 * @buf: data buffer 82 * @buflen: buffer length 83 * @rw: read/write 84 * 85 * Transfer data from/to the device data register by 8 bit PIO. 86 * 87 * LOCKING: 88 * Inherited from caller. 89 */ 90 91 static unsigned int ata_data_xfer_8bit(struct ata_queued_cmd *qc, 92 unsigned char *buf, unsigned int buflen, int rw) 93 { 94 struct ata_port *ap = qc->dev->link->ap; 95 96 if (rw == READ) 97 ioread8_rep(ap->ioaddr.data_addr, buf, buflen); 98 else 99 iowrite8_rep(ap->ioaddr.data_addr, buf, buflen); 100 101 return buflen; 102 } 103 104 /** 105 * pcmcia_8bit_drain_fifo - Stock FIFO drain logic for SFF controllers 106 * @qc: command 107 * 108 * Drain the FIFO and device of any stuck data following a command 109 * failing to complete. In some cases this is necessary before a 110 * reset will recover the device. 111 * 112 */ 113 114 static void pcmcia_8bit_drain_fifo(struct ata_queued_cmd *qc) 115 { 116 int count; 117 struct ata_port *ap; 118 119 /* We only need to flush incoming data when a command was running */ 120 if (qc == NULL || qc->dma_dir == DMA_TO_DEVICE) 121 return; 122 123 ap = qc->ap; 124 125 /* Drain up to 64K of data before we give up this recovery method */ 126 for (count = 0; (ap->ops->sff_check_status(ap) & ATA_DRQ) 127 && count++ < 65536;) 128 ioread8(ap->ioaddr.data_addr); 129 130 if (count) 131 ata_port_warn(ap, "drained %d bytes to clear DRQ\n", count); 132 133 } 134 135 static const struct scsi_host_template pcmcia_sht = { 136 ATA_PIO_SHT(DRV_NAME), 137 }; 138 139 static struct ata_port_operations pcmcia_port_ops = { 140 .inherits = &ata_sff_port_ops, 141 .sff_data_xfer = ata_sff_data_xfer32, 142 .cable_detect = ata_cable_40wire, 143 .set_mode = pcmcia_set_mode, 144 }; 145 146 static struct ata_port_operations pcmcia_8bit_port_ops = { 147 .inherits = &ata_sff_port_ops, 148 .sff_data_xfer = ata_data_xfer_8bit, 149 .cable_detect = ata_cable_40wire, 150 .set_mode = pcmcia_set_mode_8bit, 151 .sff_drain_fifo = pcmcia_8bit_drain_fifo, 152 }; 153 154 155 static int pcmcia_check_one_config(struct pcmcia_device *pdev, void *priv_data) 156 { 157 int *is_kme = priv_data; 158 159 if ((pdev->resource[0]->flags & IO_DATA_PATH_WIDTH) 160 != IO_DATA_PATH_WIDTH_8) { 161 pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH; 162 pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO; 163 } 164 pdev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH; 165 pdev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8; 166 167 if (pdev->resource[1]->end) { 168 pdev->resource[0]->end = 8; 169 pdev->resource[1]->end = (*is_kme) ? 2 : 1; 170 } else { 171 if (pdev->resource[0]->end < 16) 172 return -ENODEV; 173 } 174 175 return pcmcia_request_io(pdev); 176 } 177 178 /** 179 * pcmcia_init_one - attach a PCMCIA interface 180 * @pdev: pcmcia device 181 * 182 * Register a PCMCIA IDE interface. Such interfaces are PIO 0 and 183 * shared IRQ. 184 */ 185 186 static int pcmcia_init_one(struct pcmcia_device *pdev) 187 { 188 struct ata_host *host; 189 struct ata_port *ap; 190 int is_kme = 0, ret = -ENOMEM, p; 191 unsigned long io_base, ctl_base; 192 void __iomem *io_addr, *ctl_addr; 193 int n_ports = 1; 194 struct ata_port_operations *ops = &pcmcia_port_ops; 195 196 /* Set up attributes in order to probe card and get resources */ 197 pdev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO | 198 CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC; 199 200 /* See if we have a manufacturer identifier. Use it to set is_kme for 201 vendor quirks */ 202 is_kme = ((pdev->manf_id == MANFID_KME) && 203 ((pdev->card_id == PRODID_KME_KXLC005_A) || 204 (pdev->card_id == PRODID_KME_KXLC005_B))); 205 206 if (pcmcia_loop_config(pdev, pcmcia_check_one_config, &is_kme)) { 207 pdev->config_flags &= ~CONF_AUTO_CHECK_VCC; 208 if (pcmcia_loop_config(pdev, pcmcia_check_one_config, &is_kme)) 209 goto failed; /* No suitable config found */ 210 } 211 io_base = pdev->resource[0]->start; 212 if (pdev->resource[1]->end) 213 ctl_base = pdev->resource[1]->start; 214 else 215 ctl_base = pdev->resource[0]->start + 0x0e; 216 217 if (!pdev->irq) 218 goto failed; 219 220 ret = pcmcia_enable_device(pdev); 221 if (ret) 222 goto failed; 223 224 /* iomap */ 225 ret = -ENOMEM; 226 io_addr = devm_ioport_map(&pdev->dev, io_base, 8); 227 ctl_addr = devm_ioport_map(&pdev->dev, ctl_base, 1); 228 if (!io_addr || !ctl_addr) 229 goto failed; 230 231 /* Success. Disable the IRQ nIEN line, do quirks */ 232 iowrite8(0x02, ctl_addr); 233 if (is_kme) 234 iowrite8(0x81, ctl_addr + 0x01); 235 236 /* FIXME: Could be more ports at base + 0x10 but we only deal with 237 one right now */ 238 if (resource_size(pdev->resource[0]) >= 0x20) 239 n_ports = 2; 240 241 if (pdev->manf_id == 0x0097 && pdev->card_id == 0x1620) 242 ops = &pcmcia_8bit_port_ops; 243 /* 244 * Having done the PCMCIA plumbing the ATA side is relatively 245 * sane. 246 */ 247 ret = -ENOMEM; 248 host = ata_host_alloc(&pdev->dev, n_ports); 249 if (!host) 250 goto failed; 251 252 for (p = 0; p < n_ports; p++) { 253 ap = host->ports[p]; 254 255 ap->ops = ops; 256 ap->pio_mask = ATA_PIO0; /* ISA so PIO 0 cycles */ 257 ap->flags |= ATA_FLAG_SLAVE_POSS; 258 ap->ioaddr.cmd_addr = io_addr + 0x10 * p; 259 ap->ioaddr.altstatus_addr = ctl_addr + 0x10 * p; 260 ap->ioaddr.ctl_addr = ctl_addr + 0x10 * p; 261 ata_sff_std_ports(&ap->ioaddr); 262 263 ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", io_base, ctl_base); 264 } 265 266 /* activate */ 267 ret = ata_host_activate(host, pdev->irq, ata_sff_interrupt, 268 IRQF_SHARED, &pcmcia_sht); 269 if (ret) 270 goto failed; 271 272 pdev->priv = host; 273 return 0; 274 275 failed: 276 pcmcia_disable_device(pdev); 277 return ret; 278 } 279 280 /** 281 * pcmcia_remove_one - unplug an pcmcia interface 282 * @pdev: pcmcia device 283 * 284 * A PCMCIA ATA device has been unplugged. Perform the needed 285 * cleanup. Also called on module unload for any active devices. 286 */ 287 288 static void pcmcia_remove_one(struct pcmcia_device *pdev) 289 { 290 struct ata_host *host = pdev->priv; 291 292 if (host) 293 ata_host_detach(host); 294 295 pcmcia_disable_device(pdev); 296 } 297 298 static const struct pcmcia_device_id pcmcia_devices[] = { 299 PCMCIA_DEVICE_FUNC_ID(4), 300 PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000), /* Corsair */ 301 PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000), /* Hitachi */ 302 PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000), /* I-O Data CFA */ 303 PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001), /* Mitsubishi CFA */ 304 PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704), 305 PCMCIA_DEVICE_MANF_CARD(0x0032, 0x2904), 306 PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401), /* SanDisk CFA */ 307 PCMCIA_DEVICE_MANF_CARD(0x004f, 0x0000), /* Kingston */ 308 PCMCIA_DEVICE_MANF_CARD(0x0097, 0x1620), /* TI emulated */ 309 PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000), /* Toshiba */ 310 PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d), 311 PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000), /* Samsung */ 312 PCMCIA_DEVICE_MANF_CARD(0x00f1, 0x0101), /* SanDisk High (>8G) CFA */ 313 PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000), /* Hitachi */ 314 PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001), 315 PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0100), /* Viking CFA */ 316 PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200), /* Lexar, Viking CFA */ 317 PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0), 318 PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74), 319 PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9), 320 PCMCIA_DEVICE_PROD_ID12("ARGOSY", "CD-ROM", 0x78f308dc, 0x66536591), 321 PCMCIA_DEVICE_PROD_ID12("ARGOSY", "PnPIDE", 0x78f308dc, 0x0c694728), 322 PCMCIA_DEVICE_PROD_ID12("CNF ", "CD-ROM", 0x46d7db81, 0x66536591), 323 PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591), 324 PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4), 325 PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde), 326 PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf), 327 PCMCIA_DEVICE_PROD_ID12("EXP ", "CD-ROM", 0x0a5c52fd, 0x66536591), 328 PCMCIA_DEVICE_PROD_ID12("EXP ", "PnPIDE", 0x0a5c52fd, 0x0c694728), 329 PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e), 330 PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae), 331 PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178), 332 PCMCIA_DEVICE_PROD_ID12("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420), 333 PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178), 334 PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753), 335 PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF CARD 1GB", 0x2e6d1829, 0x55d5bffb), 336 PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF CARD 4GB", 0x2e6d1829, 0x531e7d10), 337 PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e), 338 PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2 ", 0x547e66dc, 0x8671043b), 339 PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149), 340 PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674), 341 PCMCIA_DEVICE_PROD_ID12("LOOKMEET", "CBIDE2 ", 0xe37be2b5, 0x8671043b), 342 PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF300", 0x7ed2ad87, 0x7e9e78ee), 343 PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c), 344 PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79), 345 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591), 346 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728), 347 PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1), 348 PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883), 349 PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d), 350 PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6), 351 PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003), 352 PCMCIA_DEVICE_PROD_ID1("TRANSCEND 512M ", 0xd0909443), 353 PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF45", 0x709b1bf1, 0xf68b6f32), 354 PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1), 355 PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2), 356 PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8), 357 PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF133", 0x709b1bf1, 0x7558f133), 358 PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS8GCF133", 0x709b1bf1, 0xb2f89b47), 359 PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852), 360 PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918), 361 PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209), 362 PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e), 363 PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6), 364 PCMCIA_DEVICE_PROD_ID2("Flash Card", 0x5a362506), 365 PCMCIA_DEVICE_NULL, 366 }; 367 368 MODULE_DEVICE_TABLE(pcmcia, pcmcia_devices); 369 370 static struct pcmcia_driver pcmcia_driver = { 371 .owner = THIS_MODULE, 372 .name = DRV_NAME, 373 .id_table = pcmcia_devices, 374 .probe = pcmcia_init_one, 375 .remove = pcmcia_remove_one, 376 }; 377 module_pcmcia_driver(pcmcia_driver); 378 379 MODULE_AUTHOR("Alan Cox"); 380 MODULE_DESCRIPTION("low-level driver for PCMCIA ATA"); 381 MODULE_LICENSE("GPL"); 382 MODULE_VERSION(DRV_VERSION); 383