drivers/net/can/sja1000/ems_pcmcia.c

   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);