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 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 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_flex(&pdev->dev, *chip, slot, n); 218 if (!chip) 219 return -ENOMEM; 220 221 err = pcim_enable_device(pdev); 222 if (err) 223 return err; 224 225 spin_lock_init(&chip->irq_lock); 226 chip->pdev = pdev; 227 chip->iobase = pcim_iomap_region(pdev, 0, KBUILD_MODNAME); 228 if (IS_ERR(chip->iobase)) 229 return PTR_ERR(chip->iobase); 230 231 pci_set_drvdata(pdev, chip); 232 233 err = devm_request_irq(&pdev->dev, pdev->irq, 234 cb710_irq_handler, IRQF_SHARED, KBUILD_MODNAME, chip); 235 if (err) 236 return err; 237 238 err = ida_alloc(&cb710_ida, GFP_KERNEL); 239 if (err < 0) 240 return err; 241 chip->platform_id = err; 242 243 dev_info(&pdev->dev, "id %d, IO 0x%p, IRQ %d\n", 244 chip->platform_id, chip->iobase, pdev->irq); 245 246 if (val & CB710_SLOT_MMC) { /* MMC/SD slot */ 247 err = cb710_register_slot(chip, 248 CB710_SLOT_MMC, 0x00, "cb710-mmc"); 249 if (err) 250 return err; 251 } 252 253 if (val & CB710_SLOT_MS) { /* MemoryStick slot */ 254 err = cb710_register_slot(chip, 255 CB710_SLOT_MS, 0x40, "cb710-ms"); 256 if (err) 257 goto unreg_mmc; 258 } 259 260 if (val & CB710_SLOT_SM) { /* SmartMedia slot */ 261 err = cb710_register_slot(chip, 262 CB710_SLOT_SM, 0x60, "cb710-sm"); 263 if (err) 264 goto unreg_ms; 265 } 266 267 return 0; 268 unreg_ms: 269 cb710_unregister_slot(chip, CB710_SLOT_MS); 270 unreg_mmc: 271 cb710_unregister_slot(chip, CB710_SLOT_MMC); 272 273 #ifdef CONFIG_CB710_DEBUG_ASSUMPTIONS 274 BUG_ON(atomic_read(&chip->slot_refs_count) != 0); 275 #endif 276 return err; 277 } 278 279 static void cb710_remove_one(struct pci_dev *pdev) 280 { 281 struct cb710_chip *chip = pci_get_drvdata(pdev); 282 283 cb710_unregister_slot(chip, CB710_SLOT_SM); 284 cb710_unregister_slot(chip, CB710_SLOT_MS); 285 cb710_unregister_slot(chip, CB710_SLOT_MMC); 286 #ifdef CONFIG_CB710_DEBUG_ASSUMPTIONS 287 BUG_ON(atomic_read(&chip->slot_refs_count) != 0); 288 #endif 289 290 ida_free(&cb710_ida, chip->platform_id); 291 } 292 293 static const struct pci_device_id cb710_pci_tbl[] = { 294 { PCI_DEVICE(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_CB710_FLASH) }, 295 { } 296 }; 297 298 static DEFINE_SIMPLE_DEV_PM_OPS(cb710_pm_ops, cb710_suspend, cb710_resume); 299 300 static struct pci_driver cb710_driver = { 301 .name = KBUILD_MODNAME, 302 .id_table = cb710_pci_tbl, 303 .probe = cb710_probe, 304 .remove = cb710_remove_one, 305 .driver.pm = pm_sleep_ptr(&cb710_pm_ops), 306 }; 307 308 static int __init cb710_init_module(void) 309 { 310 return pci_register_driver(&cb710_driver); 311 } 312 313 static void __exit cb710_cleanup_module(void) 314 { 315 pci_unregister_driver(&cb710_driver); 316 ida_destroy(&cb710_ida); 317 } 318 319 module_init(cb710_init_module); 320 module_exit(cb710_cleanup_module); 321 322 MODULE_AUTHOR("Michał Mirosław <mirq-linux@rere.qmqm.pl>"); 323 MODULE_DESCRIPTION("ENE CB710 memory card reader driver"); 324 MODULE_LICENSE("GPL"); 325 MODULE_DEVICE_TABLE(pci, cb710_pci_tbl); 326