drivers/net/can/sja1000/sja1000_isa.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2009 Wolfgang Grandegger <wg@grandegger.com>
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/module.h>
   8 #include <linux/platform_device.h>
   9 #include <linux/interrupt.h>
  10 #include <linux/netdevice.h>
  11 #include <linux/delay.h>
  12 #include <linux/irq.h>
  13 #include <linux/io.h>
  14 #include <linux/can/dev.h>
  15 #include <linux/can/platform/sja1000.h>
  16
  17 #include "sja1000.h"
  18
  19 #define DRV_NAME "sja1000_isa"
  20
  21 #define MAXDEV 8
  22
  23 MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
  24 MODULE_DESCRIPTION("Socket-CAN driver for SJA1000 on the ISA bus");
  25 MODULE_LICENSE("GPL v2");
  26
  27 #define CLK_DEFAULT     16000000        /* 16 MHz */
  28 #define CDR_DEFAULT     (CDR_CBP | CDR_CLK_OFF)
  29 #define OCR_DEFAULT     OCR_TX0_PUSHPULL
  30
  31 static unsigned long port[MAXDEV];
  32 static unsigned long mem[MAXDEV];
  33 static int irq[MAXDEV];
  34 static int clk[MAXDEV];
  35 static unsigned char cdr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
  36 static unsigned char ocr[MAXDEV] = {[0 ... (MAXDEV - 1)] = 0xff};
  37 static int indirect[MAXDEV] = {[0 ... (MAXDEV - 1)] = -1};
  38 static spinlock_t indirect_lock[MAXDEV];  /* lock for indirect access mode */
  39
  40 module_param_hw_array(port, ulong, ioport, NULL, 0444);
  41 MODULE_PARM_DESC(port, "I/O port number");
  42
  43 module_param_hw_array(mem, ulong, iomem, NULL, 0444);
  44 MODULE_PARM_DESC(mem, "I/O memory address");
  45
  46 module_param_hw_array(indirect, int, ioport, NULL, 0444);
  47 MODULE_PARM_DESC(indirect, "Indirect access via address and data port");
  48
  49 module_param_hw_array(irq, int, irq, NULL, 0444);
  50 MODULE_PARM_DESC(irq, "IRQ number");
  51
  52 module_param_array(clk, int, NULL, 0444);
  53 MODULE_PARM_DESC(clk, "External oscillator clock frequency "
  54                  "(default=16000000 [16 MHz])");
  55
  56 module_param_array(cdr, byte, NULL, 0444);
  57 MODULE_PARM_DESC(cdr, "Clock divider register "
  58                  "(default=0x48 [CDR_CBP | CDR_CLK_OFF])");
  59
  60 module_param_array(ocr, byte, NULL, 0444);
  61 MODULE_PARM_DESC(ocr, "Output control register "
  62                  "(default=0x18 [OCR_TX0_PUSHPULL])");
  63
  64 #define SJA1000_IOSIZE          0x20
  65 #define SJA1000_IOSIZE_INDIRECT 0x02
  66
  67 static struct platform_device *sja1000_isa_devs[MAXDEV];
  68
  69 static u8 sja1000_isa_mem_read_reg(const struct sja1000_priv *priv, int reg)
  70 {
  71         return readb(priv->reg_base + reg);
  72 }
  73
  74 static void sja1000_isa_mem_write_reg(const struct sja1000_priv *priv,
  75                                       int reg, u8 val)
  76 {
  77         writeb(val, priv->reg_base + reg);
  78 }
  79
  80 static u8 sja1000_isa_port_read_reg(const struct sja1000_priv *priv, int reg)
  81 {
  82         return inb((unsigned long)priv->reg_base + reg);
  83 }
  84
  85 static void sja1000_isa_port_write_reg(const struct sja1000_priv *priv,
  86                                        int reg, u8 val)
  87 {
  88         outb(val, (unsigned long)priv->reg_base + reg);
  89 }
  90
  91 static u8 sja1000_isa_port_read_reg_indirect(const struct sja1000_priv *priv,
  92                                              int reg)
  93 {
  94         unsigned long flags, base = (unsigned long)priv->reg_base;
  95         u8 readval;
  96
  97         spin_lock_irqsave(&indirect_lock[priv->dev->dev_id], flags);
  98         outb(reg, base);
  99         readval = inb(base + 1);
 100         spin_unlock_irqrestore(&indirect_lock[priv->dev->dev_id], flags);
 101
 102         return readval;
 103 }
 104
 105 static void sja1000_isa_port_write_reg_indirect(const struct sja1000_priv *priv,
 106                                                 int reg, u8 val)
 107 {
 108         unsigned long flags, base = (unsigned long)priv->reg_base;
 109
 110         spin_lock_irqsave(&indirect_lock[priv->dev->dev_id], flags);
 111         outb(reg, base);
 112         outb(val, base + 1);
 113         spin_unlock_irqrestore(&indirect_lock[priv->dev->dev_id], flags);
 114 }
 115
 116 static int sja1000_isa_probe(struct platform_device *pdev)
 117 {
 118         struct net_device *dev;
 119         struct sja1000_priv *priv;
 120         void __iomem *base = NULL;
 121         int iosize = SJA1000_IOSIZE;
 122         int idx = pdev->id;
 123         int err;
 124
 125         dev_dbg(&pdev->dev, "probing idx=%d: port=%#lx, mem=%#lx, irq=%d\n",
 126                 idx, port[idx], mem[idx], irq[idx]);
 127
 128         if (mem[idx]) {
 129                 if (!request_mem_region(mem[idx], iosize, DRV_NAME)) {
 130                         err = -EBUSY;
 131                         goto exit;
 132                 }
 133                 base = ioremap(mem[idx], iosize);
 134                 if (!base) {
 135                         err = -ENOMEM;
 136                         goto exit_release;
 137                 }
 138         } else {
 139                 if (indirect[idx] > 0 ||
 140                     (indirect[idx] == -1 && indirect[0] > 0))
 141                         iosize = SJA1000_IOSIZE_INDIRECT;
 142                 if (!request_region(port[idx], iosize, DRV_NAME)) {
 143                         err = -EBUSY;
 144                         goto exit;
 145                 }
 146         }
 147
 148         dev = alloc_sja1000dev(0);
 149         if (!dev) {
 150                 err = -ENOMEM;
 151                 goto exit_unmap;
 152         }
 153         priv = netdev_priv(dev);
 154
 155         dev->irq = irq[idx];
 156         priv->irq_flags = IRQF_SHARED;
 157         if (mem[idx]) {
 158                 priv->reg_base = base;
 159                 dev->base_addr = mem[idx];
 160                 priv->read_reg = sja1000_isa_mem_read_reg;
 161                 priv->write_reg = sja1000_isa_mem_write_reg;
 162         } else {
 163                 priv->reg_base = (void __iomem *)port[idx];
 164                 dev->base_addr = port[idx];
 165
 166                 if (iosize == SJA1000_IOSIZE_INDIRECT) {
 167                         priv->read_reg = sja1000_isa_port_read_reg_indirect;
 168                         priv->write_reg = sja1000_isa_port_write_reg_indirect;
 169                         spin_lock_init(&indirect_lock[idx]);
 170                 } else {
 171                         priv->read_reg = sja1000_isa_port_read_reg;
 172                         priv->write_reg = sja1000_isa_port_write_reg;
 173                 }
 174         }
 175
 176         if (clk[idx])
 177                 priv->can.clock.freq = clk[idx] / 2;
 178         else if (clk[0])
 179                 priv->can.clock.freq = clk[0] / 2;
 180         else
 181                 priv->can.clock.freq = CLK_DEFAULT / 2;
 182
 183         if (ocr[idx] != 0xff)
 184                 priv->ocr = ocr[idx];
 185         else if (ocr[0] != 0xff)
 186                 priv->ocr = ocr[0];
 187         else
 188                 priv->ocr = OCR_DEFAULT;
 189
 190         if (cdr[idx] != 0xff)
 191                 priv->cdr = cdr[idx];
 192         else if (cdr[0] != 0xff)
 193                 priv->cdr = cdr[0];
 194         else
 195                 priv->cdr = CDR_DEFAULT;
 196
 197         platform_set_drvdata(pdev, dev);
 198         SET_NETDEV_DEV(dev, &pdev->dev);
 199         dev->dev_id = idx;
 200
 201         err = register_sja1000dev(dev);
 202         if (err) {
 203                 dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
 204                         DRV_NAME, err);
 205                 goto exit_free;
 206         }
 207
 208         dev_info(&pdev->dev, "%s device registered (reg_base=0x%p, irq=%d)\n",
 209                  DRV_NAME, priv->reg_base, dev->irq);
 210         return 0;
 211
 212 exit_free:
 213         free_sja1000dev(dev);
 214 exit_unmap:
 215         if (mem[idx])
 216                 iounmap(base);
 217 exit_release:
 218         if (mem[idx])
 219                 release_mem_region(mem[idx], iosize);
 220         else
 221                 release_region(port[idx], iosize);
 222 exit:
 223         return err;
 224 }
 225
 226 static void sja1000_isa_remove(struct platform_device *pdev)
 227 {
 228         struct net_device *dev = platform_get_drvdata(pdev);
 229         struct sja1000_priv *priv = netdev_priv(dev);
 230         int idx = pdev->id;
 231
 232         unregister_sja1000dev(dev);
 233
 234         if (mem[idx]) {
 235                 iounmap(priv->reg_base);
 236                 release_mem_region(mem[idx], SJA1000_IOSIZE);
 237         } else {
 238                 if (priv->read_reg == sja1000_isa_port_read_reg_indirect)
 239                         release_region(port[idx], SJA1000_IOSIZE_INDIRECT);
 240                 else
 241                         release_region(port[idx], SJA1000_IOSIZE);
 242         }
 243         free_sja1000dev(dev);
 244 }
 245
 246 static struct platform_driver sja1000_isa_driver = {
 247         .probe = sja1000_isa_probe,
 248         .remove = sja1000_isa_remove,
 249         .driver = {
 250                 .name = DRV_NAME,
 251         },
 252 };
 253
 254 static int __init sja1000_isa_init(void)
 255 {
 256         int idx, err;
 257
 258         for (idx = 0; idx < MAXDEV; idx++) {
 259                 if ((port[idx] || mem[idx]) && irq[idx]) {
 260                         sja1000_isa_devs[idx] =
 261                                 platform_device_alloc(DRV_NAME, idx);
 262                         if (!sja1000_isa_devs[idx]) {
 263                                 err = -ENOMEM;
 264                                 goto exit_free_devices;
 265                         }
 266                         err = platform_device_add(sja1000_isa_devs[idx]);
 267                         if (err) {
 268                                 platform_device_put(sja1000_isa_devs[idx]);
 269                                 goto exit_free_devices;
 270                         }
 271                         pr_debug("%s: platform device %d: port=%#lx, mem=%#lx, "
 272                                  "irq=%d\n",
 273                                  DRV_NAME, idx, port[idx], mem[idx], irq[idx]);
 274                 } else if (idx == 0 || port[idx] || mem[idx]) {
 275                                 pr_err("%s: insufficient parameters supplied\n",
 276                                        DRV_NAME);
 277                                 err = -EINVAL;
 278                                 goto exit_free_devices;
 279                 }
 280         }
 281
 282         err = platform_driver_register(&sja1000_isa_driver);
 283         if (err)
 284                 goto exit_free_devices;
 285
 286         pr_info("Legacy %s driver for max. %d devices registered\n",
 287                 DRV_NAME, MAXDEV);
 288
 289         return 0;
 290
 291 exit_free_devices:
 292         while (--idx >= 0) {
 293                 if (sja1000_isa_devs[idx])
 294                         platform_device_unregister(sja1000_isa_devs[idx]);
 295         }
 296
 297         return err;
 298 }
 299
 300 static void __exit sja1000_isa_exit(void)
 301 {
 302         int idx;
 303
 304         platform_driver_unregister(&sja1000_isa_driver);
 305         for (idx = 0; idx < MAXDEV; idx++) {
 306                 if (sja1000_isa_devs[idx])
 307                         platform_device_unregister(sja1000_isa_devs[idx]);
 308         }
 309 }
 310
 311 module_init(sja1000_isa_init);
 312 module_exit(sja1000_isa_exit);