1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2008 Sebastian Haas (initial chardev implementation) 4 * Copyright (C) 2010 Markus Plessing <plessing@ems-wuensche.com> 5 * Rework for mainline by Oliver Hartkopp <socketcan@hartkopp.net> 6 */ 7 8 #include <linux/kernel.h> 9 #include <linux/module.h> 10 #include <linux/interrupt.h> 11 #include <linux/netdevice.h> 12 #include <linux/delay.h> 13 #include <linux/io.h> 14 #include <pcmcia/cistpl.h> 15 #include <pcmcia/ds.h> 16 #include <linux/can.h> 17 #include <linux/can/dev.h> 18 #include "sja1000.h" 19 20 #define DRV_NAME "ems_pcmcia" 21 22 MODULE_AUTHOR("Markus Plessing <plessing@ems-wuensche.com>"); 23 MODULE_DESCRIPTION("Socket-CAN driver for EMS CPC-CARD cards"); 24 MODULE_LICENSE("GPL v2"); 25 26 #define EMS_PCMCIA_MAX_CHAN 2 27 28 struct ems_pcmcia_card { 29 int channels; 30 struct pcmcia_device *pcmcia_dev; 31 struct net_device *net_dev[EMS_PCMCIA_MAX_CHAN]; 32 void __iomem *base_addr; 33 }; 34 35 #define EMS_PCMCIA_CAN_CLOCK (16000000 / 2) 36 37 /* 38 * The board configuration is probably following: 39 * RX1 is connected to ground. 40 * TX1 is not connected. 41 * CLKO is not connected. 42 * Setting the OCR register to 0xDA is a good idea. 43 * This means normal output mode , push-pull and the correct polarity. 44 */ 45 #define EMS_PCMCIA_OCR (OCR_TX0_PUSHPULL | OCR_TX1_PUSHPULL) 46 47 /* 48 * In the CDR register, you should set CBP to 1. 49 * You will probably also want to set the clock divider value to 7 50 * (meaning direct oscillator output) because the second SJA1000 chip 51 * is driven by the first one CLKOUT output. 52 */ 53 #define EMS_PCMCIA_CDR (CDR_CBP | CDR_CLKOUT_MASK) 54 #define EMS_PCMCIA_MEM_SIZE 4096 /* Size of the remapped io-memory */ 55 #define EMS_PCMCIA_CAN_BASE_OFFSET 0x100 /* Offset where controllers starts */ 56 #define EMS_PCMCIA_CAN_CTRL_SIZE 0x80 /* Memory size for each controller */ 57 58 #define EMS_CMD_RESET 0x00 /* Perform a reset of the card */ 59 #define EMS_CMD_MAP 0x03 /* Map CAN controllers into card' memory */ 60 #define EMS_CMD_UMAP 0x02 /* Unmap CAN controllers from card' memory */ 61 62 static struct pcmcia_device_id ems_pcmcia_tbl[] = { 63 PCMCIA_DEVICE_PROD_ID123("EMS_T_W", "CPC-Card", "V2.0", 0xeab1ea23, 64 0xa338573f, 0xe4575800), 65 PCMCIA_DEVICE_NULL, 66 }; 67 68 MODULE_DEVICE_TABLE(pcmcia, ems_pcmcia_tbl); 69 70 static u8 ems_pcmcia_read_reg(const struct sja1000_priv *priv, int port) 71 { 72 return readb(priv->reg_base + port); 73 } 74 75 static void ems_pcmcia_write_reg(const struct sja1000_priv *priv, int port, 76 u8 val) 77 { 78 writeb(val, priv->reg_base + port); 79 } 80 81 static irqreturn_t ems_pcmcia_interrupt(int irq, void *dev_id) 82 { 83 struct ems_pcmcia_card *card = dev_id; 84 struct net_device *dev; 85 irqreturn_t retval = IRQ_NONE; 86 int i, again; 87 88 /* Card not present */ 89 if (readw(card->base_addr) != 0xAA55) 90 return IRQ_HANDLED; 91 92 do { 93 again = 0; 94 95 /* Check interrupt for each channel */ 96 for (i = 0; i < card->channels; i++) { 97 dev = card->net_dev[i]; 98 if (!dev) 99 continue; 100 101 if (sja1000_interrupt(irq, dev) == IRQ_HANDLED) 102 again = 1; 103 } 104 /* At least one channel handled the interrupt */ 105 if (again) 106 retval = IRQ_HANDLED; 107 108 } while (again); 109 110 return retval; 111 } 112 113 /* 114 * Check if a CAN controller is present at the specified location 115 * by trying to set 'em into the PeliCAN mode 116 */ 117 static inline int ems_pcmcia_check_chan(struct sja1000_priv *priv) 118 { 119 /* Make sure SJA1000 is in reset mode */ 120 ems_pcmcia_write_reg(priv, SJA1000_MOD, 1); 121 ems_pcmcia_write_reg(priv, SJA1000_CDR, CDR_PELICAN); 122 123 /* read reset-values */ 124 if (ems_pcmcia_read_reg(priv, SJA1000_CDR) == CDR_PELICAN) 125 return 1; 126 127 return 0; 128 } 129 130 static void ems_pcmcia_del_card(struct pcmcia_device *pdev) 131 { 132 struct ems_pcmcia_card *card = pdev->priv; 133 struct net_device *dev; 134 int i; 135 136 free_irq(pdev->irq, card); 137 138 for (i = 0; i < card->channels; i++) { 139 dev = card->net_dev[i]; 140 if (!dev) 141 continue; 142 143 printk(KERN_INFO "%s: removing %s on channel #%d\n", 144 DRV_NAME, dev->name, i); 145 unregister_sja1000dev(dev); 146 free_sja1000dev(dev); 147 } 148 149 writeb(EMS_CMD_UMAP, card->base_addr); 150 iounmap(card->base_addr); 151 kfree(card); 152 153 pdev->priv = NULL; 154 } 155 156 /* 157 * Probe PCI device for EMS CAN signature and register each available 158 * CAN channel to SJA1000 Socket-CAN subsystem. 159 */ 160 static int ems_pcmcia_add_card(struct pcmcia_device *pdev, unsigned long base) 161 { 162 struct sja1000_priv *priv; 163 struct net_device *dev; 164 struct ems_pcmcia_card *card; 165 int err, i; 166 167 /* Allocating card structures to hold addresses, ... */ 168 card = kzalloc(sizeof(struct ems_pcmcia_card), GFP_KERNEL); 169 if (!card) 170 return -ENOMEM; 171 172 pdev->priv = card; 173 card->channels = 0; 174 175 card->base_addr = ioremap(base, EMS_PCMCIA_MEM_SIZE); 176 if (!card->base_addr) { 177 err = -ENOMEM; 178 goto failure_cleanup; 179 } 180 181 /* Check for unique EMS CAN signature */ 182 if (readw(card->base_addr) != 0xAA55) { 183 err = -ENODEV; 184 goto failure_cleanup; 185 } 186 187 /* Request board reset */ 188 writeb(EMS_CMD_RESET, card->base_addr); 189 190 /* Make sure CAN controllers are mapped into card's memory space */ 191 writeb(EMS_CMD_MAP, card->base_addr); 192 193 /* Detect available channels */ 194 for (i = 0; i < EMS_PCMCIA_MAX_CHAN; i++) { 195 dev = alloc_sja1000dev(0); 196 if (!dev) { 197 err = -ENOMEM; 198 goto failure_cleanup; 199 } 200 201 card->net_dev[i] = dev; 202 priv = netdev_priv(dev); 203 priv->priv = card; 204 SET_NETDEV_DEV(dev, &pdev->dev); 205 dev->dev_id = i; 206 207 priv->irq_flags = IRQF_SHARED; 208 dev->irq = pdev->irq; 209 priv->reg_base = card->base_addr + EMS_PCMCIA_CAN_BASE_OFFSET + 210 (i * EMS_PCMCIA_CAN_CTRL_SIZE); 211 212 /* Check if channel is present */ 213 if (ems_pcmcia_check_chan(priv)) { 214 priv->read_reg = ems_pcmcia_read_reg; 215 priv->write_reg = ems_pcmcia_write_reg; 216 priv->can.clock.freq = EMS_PCMCIA_CAN_CLOCK; 217 priv->ocr = EMS_PCMCIA_OCR; 218 priv->cdr = EMS_PCMCIA_CDR; 219 priv->flags |= SJA1000_CUSTOM_IRQ_HANDLER; 220 221 /* Register SJA1000 device */ 222 err = register_sja1000dev(dev); 223 if (err) { 224 free_sja1000dev(dev); 225 goto failure_cleanup; 226 } 227 228 card->channels++; 229 230 printk(KERN_INFO "%s: registered %s on channel " 231 "#%d at 0x%p, irq %d\n", DRV_NAME, dev->name, 232 i, priv->reg_base, dev->irq); 233 } else 234 free_sja1000dev(dev); 235 } 236 237 if (!card->channels) { 238 err = -ENODEV; 239 goto failure_cleanup; 240 } 241 242 err = request_irq(pdev->irq, &ems_pcmcia_interrupt, IRQF_SHARED, 243 DRV_NAME, card); 244 if (!err) 245 return 0; 246 247 failure_cleanup: 248 ems_pcmcia_del_card(pdev); 249 return err; 250 } 251 252 /* 253 * Setup PCMCIA socket and probe for EMS CPC-CARD 254 */ 255 static int ems_pcmcia_probe(struct pcmcia_device *dev) 256 { 257 int csval; 258 259 /* General socket configuration */ 260 dev->config_flags |= CONF_ENABLE_IRQ; 261 dev->config_index = 1; 262 dev->config_regs = PRESENT_OPTION; 263 264 /* The io structure describes IO port mapping */ 265 dev->resource[0]->end = 16; 266 dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; 267 dev->resource[1]->end = 16; 268 dev->resource[1]->flags |= IO_DATA_PATH_WIDTH_16; 269 dev->io_lines = 5; 270 271 /* Allocate a memory window */ 272 dev->resource[2]->flags = 273 (WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_CM | WIN_ENABLE); 274 dev->resource[2]->start = dev->resource[2]->end = 0; 275 276 csval = pcmcia_request_window(dev, dev->resource[2], 0); 277 if (csval) { 278 dev_err(&dev->dev, "pcmcia_request_window failed (err=%d)\n", 279 csval); 280 return 0; 281 } 282 283 csval = pcmcia_map_mem_page(dev, dev->resource[2], dev->config_base); 284 if (csval) { 285 dev_err(&dev->dev, "pcmcia_map_mem_page failed (err=%d)\n", 286 csval); 287 return 0; 288 } 289 290 csval = pcmcia_enable_device(dev); 291 if (csval) { 292 dev_err(&dev->dev, "pcmcia_enable_device failed (err=%d)\n", 293 csval); 294 return 0; 295 } 296 297 ems_pcmcia_add_card(dev, dev->resource[2]->start); 298 return 0; 299 } 300 301 /* 302 * Release claimed resources 303 */ 304 static void ems_pcmcia_remove(struct pcmcia_device *dev) 305 { 306 ems_pcmcia_del_card(dev); 307 pcmcia_disable_device(dev); 308 } 309 310 static struct pcmcia_driver ems_pcmcia_driver = { 311 .name = DRV_NAME, 312 .probe = ems_pcmcia_probe, 313 .remove = ems_pcmcia_remove, 314 .id_table = ems_pcmcia_tbl, 315 }; 316 module_pcmcia_driver(ems_pcmcia_driver); 317