kernel/drivers/net/can/c_can/c_can_pci.c

   1 /*
   2  * PCI bus driver for Bosch C_CAN/D_CAN controller
   3  *
   4  * Copyright (C) 2012 Federico Vaga <federico.vaga@gmail.com>
   5  *
   6  * Borrowed from c_can_platform.c
   7  *
   8  * This file is licensed under the terms of the GNU General Public
   9  * License version 2. This program is licensed "as is" without any
  10  * warranty of any kind, whether express or implied.
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/netdevice.h>
  16 #include <linux/pci.h>
  17
  18 #include <linux/can/dev.h>
  19
  20 #include "c_can.h"
  21
  22 #define PCI_DEVICE_ID_PCH_CAN   0x8818
  23 #define PCH_PCI_SOFT_RESET      0x01fc
  24
  25 enum c_can_pci_reg_align {
  26         C_CAN_REG_ALIGN_16,
  27         C_CAN_REG_ALIGN_32,
  28         C_CAN_REG_32,
  29 };
  30
  31 struct c_can_pci_data {
  32         /* Specify if is C_CAN or D_CAN */
  33         enum c_can_dev_id type;
  34         /* Set the register alignment in the memory */
  35         enum c_can_pci_reg_align reg_align;
  36         /* Set the frequency */
  37         unsigned int freq;
  38         /* PCI bar number */
  39         int bar;
  40         /* Callback for reset */
  41         void (*init)(const struct c_can_priv *priv, bool enable);
  42 };
  43
  44 /*
  45  * 16-bit c_can registers can be arranged differently in the memory
  46  * architecture of different implementations. For example: 16-bit
  47  * registers can be aligned to a 16-bit boundary or 32-bit boundary etc.
  48  * Handle the same by providing a common read/write interface.
  49  */
  50 static u16 c_can_pci_read_reg_aligned_to_16bit(const struct c_can_priv *priv,
  51                                                 enum reg index)
  52 {
  53         return readw(priv->base + priv->regs[index]);
  54 }
  55
  56 static void c_can_pci_write_reg_aligned_to_16bit(const struct c_can_priv *priv,
  57                                                 enum reg index, u16 val)
  58 {
  59         writew(val, priv->base + priv->regs[index]);
  60 }
  61
  62 static u16 c_can_pci_read_reg_aligned_to_32bit(const struct c_can_priv *priv,
  63                                                 enum reg index)
  64 {
  65         return readw(priv->base + 2 * priv->regs[index]);
  66 }
  67
  68 static void c_can_pci_write_reg_aligned_to_32bit(const struct c_can_priv *priv,
  69                                                 enum reg index, u16 val)
  70 {
  71         writew(val, priv->base + 2 * priv->regs[index]);
  72 }
  73
  74 static u16 c_can_pci_read_reg_32bit(const struct c_can_priv *priv,
  75                                     enum reg index)
  76 {
  77         return (u16)ioread32(priv->base + 2 * priv->regs[index]);
  78 }
  79
  80 static void c_can_pci_write_reg_32bit(const struct c_can_priv *priv,
  81                                       enum reg index, u16 val)
  82 {
  83         iowrite32((u32)val, priv->base + 2 * priv->regs[index]);
  84 }
  85
  86 static u32 c_can_pci_read_reg32(const struct c_can_priv *priv, enum reg index)
  87 {
  88         u32 val;
  89
  90         val = priv->read_reg(priv, index);
  91         val |= ((u32) priv->read_reg(priv, index + 1)) << 16;
  92
  93         return val;
  94 }
  95
  96 static void c_can_pci_write_reg32(const struct c_can_priv *priv, enum reg index,
  97                 u32 val)
  98 {
  99         priv->write_reg(priv, index + 1, val >> 16);
 100         priv->write_reg(priv, index, val);
 101 }
 102
 103 static void c_can_pci_reset_pch(const struct c_can_priv *priv, bool enable)
 104 {
 105         if (enable) {
 106                 u32 __iomem *addr = priv->base + PCH_PCI_SOFT_RESET;
 107
 108                 /* write to sw reset register */
 109                 iowrite32(1, addr);
 110                 iowrite32(0, addr);
 111         }
 112 }
 113
 114 static int c_can_pci_probe(struct pci_dev *pdev,
 115                            const struct pci_device_id *ent)
 116 {
 117         struct c_can_pci_data *c_can_pci_data = (void *)ent->driver_data;
 118         struct c_can_priv *priv;
 119         struct net_device *dev;
 120         void __iomem *addr;
 121         int ret;
 122
 123         ret = pci_enable_device(pdev);
 124         if (ret) {
 125                 dev_err(&pdev->dev, "pci_enable_device FAILED\n");
 126                 goto out;
 127         }
 128
 129         ret = pci_request_regions(pdev, KBUILD_MODNAME);
 130         if (ret) {
 131                 dev_err(&pdev->dev, "pci_request_regions FAILED\n");
 132                 goto out_disable_device;
 133         }
 134
 135         ret = pci_enable_msi(pdev);
 136         if (!ret) {
 137                 dev_info(&pdev->dev, "MSI enabled\n");
 138                 pci_set_master(pdev);
 139         }
 140
 141         addr = pci_iomap(pdev, c_can_pci_data->bar,
 142                          pci_resource_len(pdev, c_can_pci_data->bar));
 143         if (!addr) {
 144                 dev_err(&pdev->dev,
 145                         "device has no PCI memory resources, "
 146                         "failing adapter\n");
 147                 ret = -ENOMEM;
 148                 goto out_release_regions;
 149         }
 150
 151         /* allocate the c_can device */
 152         dev = alloc_c_can_dev();
 153         if (!dev) {
 154                 ret = -ENOMEM;
 155                 goto out_iounmap;
 156         }
 157
 158         priv = netdev_priv(dev);
 159         pci_set_drvdata(pdev, dev);
 160         SET_NETDEV_DEV(dev, &pdev->dev);
 161
 162         dev->irq = pdev->irq;
 163         priv->base = addr;
 164         priv->device = &pdev->dev;
 165
 166         if (!c_can_pci_data->freq) {
 167                 dev_err(&pdev->dev, "no clock frequency defined\n");
 168                 ret = -ENODEV;
 169                 goto out_free_c_can;
 170         } else {
 171                 priv->can.clock.freq = c_can_pci_data->freq;
 172         }
 173
 174         /* Configure CAN type */
 175         switch (c_can_pci_data->type) {
 176         case BOSCH_C_CAN:
 177                 priv->regs = reg_map_c_can;
 178                 break;
 179         case BOSCH_D_CAN:
 180                 priv->regs = reg_map_d_can;
 181                 priv->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
 182                 break;
 183         default:
 184                 ret = -EINVAL;
 185                 goto out_free_c_can;
 186         }
 187
 188         priv->type = c_can_pci_data->type;
 189
 190         /* Configure access to registers */
 191         switch (c_can_pci_data->reg_align) {
 192         case C_CAN_REG_ALIGN_32:
 193                 priv->read_reg = c_can_pci_read_reg_aligned_to_32bit;
 194                 priv->write_reg = c_can_pci_write_reg_aligned_to_32bit;
 195                 break;
 196         case C_CAN_REG_ALIGN_16:
 197                 priv->read_reg = c_can_pci_read_reg_aligned_to_16bit;
 198                 priv->write_reg = c_can_pci_write_reg_aligned_to_16bit;
 199                 break;
 200         case C_CAN_REG_32:
 201                 priv->read_reg = c_can_pci_read_reg_32bit;
 202                 priv->write_reg = c_can_pci_write_reg_32bit;
 203                 break;
 204         default:
 205                 ret = -EINVAL;
 206                 goto out_free_c_can;
 207         }
 208         priv->read_reg32 = c_can_pci_read_reg32;
 209         priv->write_reg32 = c_can_pci_write_reg32;
 210
 211         priv->raminit = c_can_pci_data->init;
 212
 213         ret = register_c_can_dev(dev);
 214         if (ret) {
 215                 dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
 216                         KBUILD_MODNAME, ret);
 217                 goto out_free_c_can;
 218         }
 219
 220         dev_dbg(&pdev->dev, "%s device registered (regs=%p, irq=%d)\n",
 221                  KBUILD_MODNAME, priv->regs, dev->irq);
 222
 223         return 0;
 224
 225 out_free_c_can:
 226         free_c_can_dev(dev);
 227 out_iounmap:
 228         pci_iounmap(pdev, addr);
 229 out_release_regions:
 230         pci_disable_msi(pdev);
 231         pci_clear_master(pdev);
 232         pci_release_regions(pdev);
 233 out_disable_device:
 234         pci_disable_device(pdev);
 235 out:
 236         return ret;
 237 }
 238
 239 static void c_can_pci_remove(struct pci_dev *pdev)
 240 {
 241         struct net_device *dev = pci_get_drvdata(pdev);
 242         struct c_can_priv *priv = netdev_priv(dev);
 243
 244         unregister_c_can_dev(dev);
 245
 246         free_c_can_dev(dev);
 247
 248         pci_iounmap(pdev, priv->base);
 249         pci_disable_msi(pdev);
 250         pci_clear_master(pdev);
 251         pci_release_regions(pdev);
 252         pci_disable_device(pdev);
 253 }
 254
 255 static struct c_can_pci_data c_can_sta2x11= {
 256         .type = BOSCH_C_CAN,
 257         .reg_align = C_CAN_REG_ALIGN_32,
 258         .freq = 52000000, /* 52 Mhz */
 259         .bar = 0,
 260 };
 261
 262 static struct c_can_pci_data c_can_pch = {
 263         .type = BOSCH_C_CAN,
 264         .reg_align = C_CAN_REG_32,
 265         .freq = 50000000, /* 50 MHz */
 266         .init = c_can_pci_reset_pch,
 267         .bar = 1,
 268 };
 269
 270 #define C_CAN_ID(_vend, _dev, _driverdata) {            \
 271         PCI_DEVICE(_vend, _dev),                        \
 272         .driver_data = (unsigned long)&_driverdata,     \
 273 }
 274
 275 static const struct pci_device_id c_can_pci_tbl[] = {
 276         C_CAN_ID(PCI_VENDOR_ID_STMICRO, PCI_DEVICE_ID_STMICRO_CAN,
 277                  c_can_sta2x11),
 278         C_CAN_ID(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PCH_CAN,
 279                  c_can_pch),
 280         {},
 281 };
 282 static struct pci_driver c_can_pci_driver = {
 283         .name = KBUILD_MODNAME,
 284         .id_table = c_can_pci_tbl,
 285         .probe = c_can_pci_probe,
 286         .remove = c_can_pci_remove,
 287 };
 288
 289 module_pci_driver(c_can_pci_driver);
 290
 291 MODULE_AUTHOR("Federico Vaga <federico.vaga@gmail.com>");
 292 MODULE_LICENSE("GPL v2");
 293 MODULE_DESCRIPTION("PCI CAN bus driver for Bosch C_CAN/D_CAN controller");
 294 MODULE_DEVICE_TABLE(pci, c_can_pci_tbl);