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