1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * cb710/core.c 4 * 5 * Copyright by Michał Mirosław, 2008-2009 6 */ 7 #include <linux/kernel.h> 8 #include <linux/module.h> 9 #include <linux/pci.h> 10 #include <linux/spinlock.h> 11 #include <linux/idr.h> 12 #include <linux/cb710.h> 13 #include <linux/gfp.h> 14 15 static DEFINE_IDA(cb710_ida); 16 17 void cb710_pci_update_config_reg(struct pci_dev *pdev, 18 int reg, uint32_t mask, uint32_t xor) 19 { 20 u32 rval; 21 22 pci_read_config_dword(pdev, reg, &rval); 23 rval = (rval & mask) ^ xor; 24 pci_write_config_dword(pdev, reg, rval); 25 } 26 EXPORT_SYMBOL_GPL(cb710_pci_update_config_reg); 27 28 /* Some magic writes based on Windows driver init code */ 29 static int cb710_pci_configure(struct pci_dev *pdev) 30 { 31 unsigned int devfn = PCI_DEVFN(PCI_SLOT(pdev->devfn), 0); 32 struct pci_dev *pdev0; 33 u32 val; 34 35 cb710_pci_update_config_reg(pdev, 0x48, 36 ~0x000000FF, 0x0000003F); 37 38 pci_read_config_dword(pdev, 0x48, &val); 39 if (val & 0x80000000) 40 return 0; 41 42 pdev0 = pci_get_slot(pdev->bus, devfn); 43 if (!pdev0) 44 return -ENODEV; 45 46 if (pdev0->vendor == PCI_VENDOR_ID_ENE 47 && pdev0->device == PCI_DEVICE_ID_ENE_720) { 48 cb710_pci_update_config_reg(pdev0, 0x8C, 49 ~0x00F00000, 0x00100000); 50 cb710_pci_update_config_reg(pdev0, 0xB0, 51 ~0x08000000, 0x08000000); 52 } 53 54 cb710_pci_update_config_reg(pdev0, 0x8C, 55 ~0x00000F00, 0x00000200); 56 cb710_pci_update_config_reg(pdev0, 0x90, 57 ~0x00060000, 0x00040000); 58 59 pci_dev_put(pdev0); 60 61 return 0; 62 } 63 64 static irqreturn_t cb710_irq_handler(int irq, void *data) 65 { 66 struct cb710_chip *chip = data; 67 struct cb710_slot *slot = &chip->slot[0]; 68 irqreturn_t handled = IRQ_NONE; 69 unsigned nr; 70 71 spin_lock(&chip->irq_lock); /* incl. smp_rmb() */ 72 73 for (nr = chip->slots; nr; ++slot, --nr) { 74 cb710_irq_handler_t handler_func = slot->irq_handler; 75 if (handler_func && handler_func(slot)) 76 handled = IRQ_HANDLED; 77 } 78 79 spin_unlock(&chip->irq_lock); 80 81 return handled; 82 } 83 84 static void cb710_release_slot(struct device *dev) 85 { 86 #ifdef CONFIG_CB710_DEBUG_ASSUMPTIONS 87 struct cb710_slot *slot = cb710_pdev_to_slot(to_platform_device(dev)); 88 struct cb710_chip *chip = cb710_slot_to_chip(slot); 89 90 /* slot struct can be freed now */ 91 atomic_dec(&chip->slot_refs_count); 92 #endif 93 } 94 95 static int cb710_register_slot(struct cb710_chip *chip, 96 unsigned slot_mask, unsigned io_offset, const char *name) 97 { 98 int nr = chip->slots; 99 struct cb710_slot *slot = &chip->slot[nr]; 100 int err; 101 102 dev_dbg(cb710_chip_dev(chip), 103 "register: %s.%d; slot %d; mask %d; IO offset: 0x%02X\n", 104 name, chip->platform_id, nr, slot_mask, io_offset); 105 106 /* slot->irq_handler == NULL here; this needs to be 107 * seen before platform_device_register() */ 108 ++chip->slots; 109 smp_wmb(); 110 111 slot->iobase = chip->iobase + io_offset; 112 slot->pdev.name = name; 113 slot->pdev.id = chip->platform_id; 114 slot->pdev.dev.parent = &chip->pdev->dev; 115 slot->pdev.dev.release = cb710_release_slot; 116 117 err = platform_device_register(&slot->pdev); 118 119 #ifdef CONFIG_CB710_DEBUG_ASSUMPTIONS 120 atomic_inc(&chip->slot_refs_count); 121 #endif 122 123 if (err) { 124 /* device_initialize() called from platform_device_register() 125 * wants this on error path */ 126 platform_device_put(&slot->pdev); 127 128 /* slot->irq_handler == NULL here anyway, so no lock needed */ 129 --chip->slots; 130 return err; 131 } 132 133 chip->slot_mask |= slot_mask; 134 135 return 0; 136 } 137 138 static void cb710_unregister_slot(struct cb710_chip *chip, 139 unsigned slot_mask) 140 { 141 int nr = chip->slots - 1; 142 143 if (!(chip->slot_mask & slot_mask)) 144 return; 145 146 platform_device_unregister(&chip->slot[nr].pdev); 147 148 /* complementary to spin_unlock() in cb710_set_irq_handler() */ 149 smp_rmb(); 150 BUG_ON(chip->slot[nr].irq_handler != NULL); 151 152 /* slot->irq_handler == NULL here, so no lock needed */ 153 --chip->slots; 154 chip->slot_mask &= ~slot_mask; 155 } 156 157 void cb710_set_irq_handler(struct cb710_slot *slot, 158 cb710_irq_handler_t handler) 159 { 160 struct cb710_chip *chip = cb710_slot_to_chip(slot); 161 unsigned long flags; 162 163 spin_lock_irqsave(&chip->irq_lock, flags); 164 slot->irq_handler = handler; 165 spin_unlock_irqrestore(&chip->irq_lock, flags); 166 } 167 EXPORT_SYMBOL_GPL(cb710_set_irq_handler); 168 169 static int __maybe_unused cb710_suspend(struct device *dev_d) 170 { 171 struct pci_dev *pdev = to_pci_dev(dev_d); 172 struct cb710_chip *chip = pci_get_drvdata(pdev); 173 174 devm_free_irq(&pdev->dev, pdev->irq, chip); 175 return 0; 176 } 177 178 static int __maybe_unused cb710_resume(struct device *dev_d) 179 { 180 struct pci_dev *pdev = to_pci_dev(dev_d); 181 struct cb710_chip *chip = pci_get_drvdata(pdev); 182 183 return devm_request_irq(&pdev->dev, pdev->irq, 184 cb710_irq_handler, IRQF_SHARED, KBUILD_MODNAME, chip); 185 } 186 187 static int cb710_probe(struct pci_dev *pdev, 188 const struct pci_device_id *ent) 189 { 190 struct cb710_chip *chip; 191 u32 val; 192 int err; 193 int n = 0; 194 195 err = cb710_pci_configure(pdev); 196 if (err) 197 return err; 198 199 /* this is actually magic... */ 200 pci_read_config_dword(pdev, 0x48, &val); 201 if (!(val & 0x80000000)) { 202 pci_write_config_dword(pdev, 0x48, val|0x71000000); 203 pci_read_config_dword(pdev, 0x48, &val); 204 } 205 206 dev_dbg(&pdev->dev, "PCI config[0x48] = 0x%08X\n", val); 207 if (!(val & 0x70000000)) 208 return -ENODEV; 209 val = (val >> 28) & 7; 210 if (val & CB710_SLOT_MMC) 211 ++n; 212 if (val & CB710_SLOT_MS) 213 ++n; 214 if (val & CB710_SLOT_SM) 215 ++n; 216 217 chip = devm_kzalloc(&pdev->dev, struct_size(chip, slot, n), 218 GFP_KERNEL); 219 if (!chip) 220 return -ENOMEM; 221 222 err = pcim_enable_device(pdev); 223 if (err) 224 return err; 225 226 spin_lock_init(&chip->irq_lock); 227 chip->pdev = pdev; 228 chip->iobase = pcim_iomap_region(pdev, 0, KBUILD_MODNAME); 229 if (!chip->iobase) 230 return -ENOMEM; 231 232 pci_set_drvdata(pdev, chip); 233 234 err = devm_request_irq(&pdev->dev, pdev->irq, 235 cb710_irq_handler, IRQF_SHARED, KBUILD_MODNAME, chip); 236 if (err) 237 return err; 238 239 err = ida_alloc(&cb710_ida, GFP_KERNEL); 240 if (err < 0) 241 return err; 242 chip->platform_id = err; 243 244 dev_info(&pdev->dev, "id %d, IO 0x%p, IRQ %d\n", 245 chip->platform_id, chip->iobase, pdev->irq); 246 247 if (val & CB710_SLOT_MMC) { /* MMC/SD slot */ 248 err = cb710_register_slot(chip, 249 CB710_SLOT_MMC, 0x00, "cb710-mmc"); 250 if (err) 251 return err; 252 } 253 254 if (val & CB710_SLOT_MS) { /* MemoryStick slot */ 255 err = cb710_register_slot(chip, 256 CB710_SLOT_MS, 0x40, "cb710-ms"); 257 if (err) 258 goto unreg_mmc; 259 } 260 261 if (val & CB710_SLOT_SM) { /* SmartMedia slot */ 262 err = cb710_register_slot(chip, 263 CB710_SLOT_SM, 0x60, "cb710-sm"); 264 if (err) 265 goto unreg_ms; 266 } 267 268 return 0; 269 unreg_ms: 270 cb710_unregister_slot(chip, CB710_SLOT_MS); 271 unreg_mmc: 272 cb710_unregister_slot(chip, CB710_SLOT_MMC); 273 274 #ifdef CONFIG_CB710_DEBUG_ASSUMPTIONS 275 BUG_ON(atomic_read(&chip->slot_refs_count) != 0); 276 #endif 277 return err; 278 } 279 280 static void cb710_remove_one(struct pci_dev *pdev) 281 { 282 struct cb710_chip *chip = pci_get_drvdata(pdev); 283 284 cb710_unregister_slot(chip, CB710_SLOT_SM); 285 cb710_unregister_slot(chip, CB710_SLOT_MS); 286 cb710_unregister_slot(chip, CB710_SLOT_MMC); 287 #ifdef CONFIG_CB710_DEBUG_ASSUMPTIONS 288 BUG_ON(atomic_read(&chip->slot_refs_count) != 0); 289 #endif 290 291 ida_free(&cb710_ida, chip->platform_id); 292 } 293 294 static const struct pci_device_id cb710_pci_tbl[] = { 295 { PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_CB710_FLASH, 296 PCI_ANY_ID, PCI_ANY_ID, }, 297 { 0, } 298 }; 299 300 static SIMPLE_DEV_PM_OPS(cb710_pm_ops, cb710_suspend, cb710_resume); 301 302 static struct pci_driver cb710_driver = { 303 .name = KBUILD_MODNAME, 304 .id_table = cb710_pci_tbl, 305 .probe = cb710_probe, 306 .remove = cb710_remove_one, 307 .driver.pm = &cb710_pm_ops, 308 }; 309 310 static int __init cb710_init_module(void) 311 { 312 return pci_register_driver(&cb710_driver); 313 } 314 315 static void __exit cb710_cleanup_module(void) 316 { 317 pci_unregister_driver(&cb710_driver); 318 ida_destroy(&cb710_ida); 319 } 320 321 module_init(cb710_init_module); 322 module_exit(cb710_cleanup_module); 323 324 MODULE_AUTHOR("Michał Mirosław <mirq-linux@rere.qmqm.pl>"); 325 MODULE_DESCRIPTION("ENE CB710 memory card reader driver"); 326 MODULE_LICENSE("GPL"); 327 MODULE_DEVICE_TABLE(pci, cb710_pci_tbl); 328