kernel/2.6/drivers/net/can/sja1000/esd_pci.c

   1 /*
   2  * Copyright (C) 2007 Wolfgang Grandegger <wg@grandegger.com>
   3  * Copyright (C) 2008 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix
   4  * Copyright (C) 2009 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
   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  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <linux/kernel.h>
  21 #include <linux/module.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/netdevice.h>
  24 #include <linux/delay.h>
  25 #include <linux/pci.h>
  26 #include <linux/pci_ids.h>
  27 #include <linux/can.h>
  28 #include <linux/can/dev.h>
  29 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
  30 #include <linux/io.h>
  31 #else
  32 #include <asm/io.h>
  33 #endif
  34
  35 #include "sja1000.h"
  36
  37 #define DRV_NAME  "esd_pci"
  38
  39 MODULE_AUTHOR("Matthias Fuchs <matthias.fuchs@esd.eu");
  40 MODULE_DESCRIPTION("Socket-CAN driver for esd PCI/PMC/CPCI/PCIe/PCI104 " \
  41                    "CAN cards");
  42 MODULE_SUPPORTED_DEVICE("esd CAN-PCI/200, CAN-PCI/266, CAN-PMC266, " \
  43                         "CAN-PCIe/2000, CAN-CPCI/200, CAN-PCI104");
  44 MODULE_LICENSE("GPL v2");
  45
  46 /* Maximum number of interfaces supported on one card. */
  47 #define ESD_PCI_MAX_CAN 2
  48
  49 struct esd_pci {
  50         struct pci_dev *pci_dev;
  51         struct net_device *dev[ESD_PCI_MAX_CAN];
  52         void __iomem *conf_addr;
  53         void __iomem *base_addr;
  54 };
  55
  56 #define ESD_PCI_CAN_CLOCK       (16000000 / 2)
  57
  58 #define ESD_PCI_OCR             (OCR_TX0_PUSHPULL | OCR_TX1_PUSHPULL)
  59 #define ESD_PCI_CDR             0
  60
  61 #define CHANNEL_OFFSET          0x100
  62
  63 #define INTCSR_OFFSET           0x4c /* Offset in PLX9050 conf registers */
  64 #define INTCSR_LINTI1           (1 << 0)
  65 #define INTCSR_PCI              (1 << 6)
  66
  67 #define INTCSR9056_OFFSET       0x68 /* Offset in PLX9056 conf registers */
  68 #define INTCSR9056_LINTI        (1 << 11)
  69 #define INTCSR9056_PCI          (1 << 8)
  70
  71 #ifndef PCI_DEVICE_ID_PLX_9056
  72 # define PCI_DEVICE_ID_PLX_9056 0x9056
  73 #endif
  74
  75 /* PCI subsystem IDs of esd's SJA1000 based CAN cards */
  76
  77 /* CAN-PCI/200: PCI, 33MHz only, bridge: PLX9050 */
  78 #define ESD_PCI_SUB_SYS_ID_PCI200       0x0004
  79
  80 /* CAN-PCI/266: PCI, 33/66MHz, bridge: PLX9056 */
  81 #define ESD_PCI_SUB_SYS_ID_PCI266       0x0009
  82
  83 /* CAN-PMC/266: PMC module, 33/66MHz, bridge: PLX9056 */
  84 #define ESD_PCI_SUB_SYS_ID_PMC266       0x000e
  85
  86 /* CAN-CPCI/200: Compact PCI, 33MHz only, bridge: PLX9030 */
  87 #define ESD_PCI_SUB_SYS_ID_CPCI200      0x010b
  88
  89 /* CAN-PCIE/2000: PCI Express 1x, bridge: PEX8311 = PEX8111 + PLX9056 */
  90 #define ESD_PCI_SUB_SYS_ID_PCIE2000     0x0200
  91
  92 /* CAN-PCI/104: PCI104 module, 33MHz only, bridge: PLX9030 */
  93 #define ESD_PCI_SUB_SYS_ID_PCI104200    0x0501
  94
  95 static struct pci_device_id esd_pci_tbl[] = {
  96         {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
  97          PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCI200},
  98         {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9056,
  99          PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCI266},
 100         {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9056,
 101          PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PMC266},
 102         {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
 103          PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_CPCI200},
 104         {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9056,
 105          PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCIE2000},
 106         {PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
 107          PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCI104200},
 108         {0,}
 109 };
 110
 111 #define ESD_PCI_BASE_SIZE  0x200
 112
 113 MODULE_DEVICE_TABLE(pci, esd_pci_tbl);
 114
 115 static u8 esd_pci_read_reg(struct net_device *ndev, int port)
 116 {
 117         return readb((void __iomem *)(ndev->base_addr + port));
 118 }
 119
 120 static void esd_pci_write_reg(struct net_device *ndev, int port, u8 val)
 121 {
 122         writeb(val, (void __iomem *)(ndev->base_addr + port));
 123 }
 124
 125 static void esd_pci_del_chan(struct pci_dev *pdev, struct net_device *ndev)
 126 {
 127         dev_info(&pdev->dev, "Removing device %s\n", ndev->name);
 128
 129         unregister_sja1000dev(ndev);
 130
 131         free_sja1000dev(ndev);
 132 }
 133
 134 static struct net_device * __devinit esd_pci_add_chan(struct pci_dev *pdev,
 135                                                       void __iomem *base_addr)
 136 {
 137         struct net_device *ndev;
 138         struct sja1000_priv *priv;
 139         int err;
 140
 141         ndev = alloc_sja1000dev(0);
 142         if (ndev == NULL)
 143                 return ERR_PTR(-ENOMEM);
 144
 145         priv = netdev_priv(ndev);
 146
 147         ndev->base_addr = (unsigned long)base_addr;
 148
 149         priv->read_reg = esd_pci_read_reg;
 150         priv->write_reg = esd_pci_write_reg;
 151
 152         priv->can.bittiming.clock = ESD_PCI_CAN_CLOCK;
 153
 154         priv->ocr = ESD_PCI_OCR;
 155         priv->cdr = ESD_PCI_CDR;
 156
 157         /* Set and enable PCI interrupts */
 158         ndev->irq = pdev->irq;
 159
 160         dev_dbg(&pdev->dev, "base_addr=%#lx irq=%d\n",
 161                         ndev->base_addr, ndev->irq);
 162
 163         SET_NETDEV_DEV(ndev, &pdev->dev);
 164
 165         err = register_sja1000dev(ndev);
 166         if (err) {
 167                 dev_err(&pdev->dev, "Failed to register (err=%d)\n", err);
 168                 goto failure;
 169         }
 170
 171         return ndev;
 172
 173 failure:
 174         free_sja1000dev(ndev);
 175         return ERR_PTR(err);
 176 }
 177
 178 static int __devinit esd_pci_init_one(struct pci_dev *pdev,
 179                                        const struct pci_device_id *ent)
 180 {
 181         struct esd_pci *board;
 182         int err;
 183         void __iomem *base_addr;
 184         void __iomem *conf_addr;
 185
 186         dev_info(&pdev->dev,
 187                  "Initializing device %04x:%04x %04x:%04x\n",
 188                  pdev->vendor, pdev->device,
 189                  pdev->subsystem_vendor, pdev->subsystem_device);
 190
 191         board = kzalloc(sizeof(*board), GFP_KERNEL);
 192         if (!board)
 193                 return -ENOMEM;
 194
 195         err = pci_enable_device(pdev);
 196         if (err)
 197                 goto failure;
 198
 199         err = pci_request_regions(pdev, DRV_NAME);
 200         if (err)
 201                 goto failure;
 202
 203         conf_addr = pci_iomap(pdev, 0, ESD_PCI_BASE_SIZE);
 204         if (conf_addr == NULL) {
 205                 err = -ENODEV;
 206                 goto failure_release_pci;
 207         }
 208
 209         board->conf_addr = conf_addr;
 210
 211         base_addr = pci_iomap(pdev, 2, ESD_PCI_BASE_SIZE);
 212         if (base_addr == NULL) {
 213                 err = -ENODEV;
 214                 goto failure_iounmap_conf;
 215         }
 216
 217         board->base_addr = base_addr;
 218
 219         board->dev[0] = esd_pci_add_chan(pdev, base_addr);
 220         if (IS_ERR(board->dev[0]))
 221                 goto failure_iounmap_base;
 222
 223         /* Check if second channel is available */
 224         writeb(MOD_RM, base_addr + CHANNEL_OFFSET + REG_MOD);
 225         writeb(CDR_CBP, base_addr + CHANNEL_OFFSET + REG_CDR);
 226         writeb(MOD_RM, base_addr + CHANNEL_OFFSET + REG_MOD);
 227         if (readb(base_addr + CHANNEL_OFFSET + REG_MOD) == 0x21) {
 228                 writeb(MOD_SM | MOD_AFM | MOD_STM | MOD_LOM | MOD_RM,
 229                        base_addr + CHANNEL_OFFSET + REG_MOD);
 230                 if (readb(base_addr + CHANNEL_OFFSET + REG_MOD) == 0x3f) {
 231                         writeb(MOD_RM, base_addr + CHANNEL_OFFSET + REG_MOD);
 232                         board->dev[1] =
 233                                 esd_pci_add_chan(pdev,
 234                                                  base_addr + CHANNEL_OFFSET);
 235                         if (IS_ERR(board->dev[1]))
 236                                 goto failure_unreg_dev0;
 237                 } else
 238                         writeb(MOD_RM, base_addr + CHANNEL_OFFSET + REG_MOD);
 239         } else
 240                 writeb(MOD_RM, base_addr + CHANNEL_OFFSET + REG_MOD);
 241
 242         if ((pdev->device == PCI_DEVICE_ID_PLX_9050) ||
 243             (pdev->device == PCI_DEVICE_ID_PLX_9030)) {
 244                 /* Enable interrupts in PLX9050 */
 245                 writel(INTCSR_LINTI1 | INTCSR_PCI,
 246                        board->conf_addr + INTCSR_OFFSET);
 247         } else {
 248                 /* Enable interrupts in PLX9056*/
 249                 writel(INTCSR9056_LINTI | INTCSR9056_PCI,
 250                        board->conf_addr + INTCSR9056_OFFSET);
 251         }
 252
 253         pci_set_drvdata(pdev, board);
 254
 255         return 0;
 256
 257 failure_unreg_dev0:
 258         esd_pci_del_chan(pdev, board->dev[0]);
 259
 260 failure_iounmap_base:
 261         pci_iounmap(pdev, board->base_addr);
 262
 263 failure_iounmap_conf:
 264         pci_iounmap(pdev, board->conf_addr);
 265
 266 failure_release_pci:
 267         pci_release_regions(pdev);
 268
 269 failure:
 270         kfree(board);
 271
 272         return err;
 273 }
 274
 275 static void __devexit esd_pci_remove_one(struct pci_dev *pdev)
 276 {
 277         struct esd_pci *board = pci_get_drvdata(pdev);
 278         int i;
 279
 280         if ((pdev->device == PCI_DEVICE_ID_PLX_9050) ||
 281             (pdev->device == PCI_DEVICE_ID_PLX_9030)) {
 282                 /* Disable interrupts in PLX9050*/
 283                 writel(0, board->conf_addr + INTCSR_OFFSET);
 284         } else {
 285                 /* Disable interrupts in PLX9056*/
 286                 writel(0, board->conf_addr + INTCSR9056_OFFSET);
 287         }
 288
 289         for (i = 0; i < ESD_PCI_MAX_CAN; i++) {
 290                 if (!board->dev[i])
 291                         break;
 292                 esd_pci_del_chan(pdev, board->dev[i]);
 293         }
 294
 295         pci_iounmap(pdev, board->base_addr);
 296         pci_iounmap(pdev, board->conf_addr);
 297
 298         pci_release_regions(pdev);
 299         pci_disable_device(pdev);
 300         pci_set_drvdata(pdev, NULL);
 301
 302         kfree(board);
 303 }
 304
 305 static struct pci_driver esd_pci_driver = {
 306         .name = DRV_NAME,
 307         .id_table = esd_pci_tbl,
 308         .probe = esd_pci_init_one,
 309         .remove = __devexit_p(esd_pci_remove_one),
 310 };
 311
 312 static int __init esd_pci_init(void)
 313 {
 314         return pci_register_driver(&esd_pci_driver);
 315 }
 316
 317 static void __exit esd_pci_exit(void)
 318 {
 319         pci_unregister_driver(&esd_pci_driver);
 320 }
 321
 322 module_init(esd_pci_init);
 323 module_exit(esd_pci_exit);