can/sja1000/f81601.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Fintek F81601 PCIE to 2 CAN controller driver
0003  *
0004  * Copyright (C) 2019 Peter Hong <peter_hong@fintek.com.tw>
0005  * Copyright (C) 2019 Linux Foundation
0006  */
0007
0008 #include <linux/kernel.h>
0009 #include <linux/module.h>
0010 #include <linux/interrupt.h>
0011 #include <linux/netdevice.h>
0012 #include <linux/delay.h>
0013 #include <linux/slab.h>
0014 #include <linux/pci.h>
0015 #include <linux/can/dev.h>
0016 #include <linux/io.h>
0017
0018 #include "sja1000.h"
0019
0020 #define F81601_PCI_MAX_CHAN     2
0021
0022 #define F81601_DECODE_REG       0x209
0023 #define F81601_IO_MODE          BIT(7)
0024 #define F81601_MEM_MODE         BIT(6)
0025 #define F81601_CFG_MODE         BIT(5)
0026 #define F81601_CAN2_INTERNAL_CLK    BIT(3)
0027 #define F81601_CAN1_INTERNAL_CLK    BIT(2)
0028 #define F81601_CAN2_EN          BIT(1)
0029 #define F81601_CAN1_EN          BIT(0)
0030
0031 #define F81601_TRAP_REG         0x20a
0032 #define F81601_CAN2_HAS_EN      BIT(4)
0033
0034 struct f81601_pci_card {
0035     void __iomem *addr;
0036     spinlock_t lock;    /* use this spin lock only for write access */
0037     struct pci_dev *dev;
0038     struct net_device *net_dev[F81601_PCI_MAX_CHAN];
0039 };
0040
0041 static const struct pci_device_id f81601_pci_tbl[] = {
0042     { PCI_DEVICE(0x1c29, 0x1703) },
0043     { /* sentinel */ },
0044 };
0045
0046 MODULE_DEVICE_TABLE(pci, f81601_pci_tbl);
0047
0048 static bool internal_clk = true;
0049 module_param(internal_clk, bool, 0444);
0050 MODULE_PARM_DESC(internal_clk, "Use internal clock, default true (24MHz)");
0051
0052 static unsigned int external_clk;
0053 module_param(external_clk, uint, 0444);
0054 MODULE_PARM_DESC(external_clk, "External clock when internal_clk disabled");
0055
0056 static u8 f81601_pci_read_reg(const struct sja1000_priv *priv, int port)
0057 {
0058     return readb(priv->reg_base + port);
0059 }
0060
0061 static void f81601_pci_write_reg(const struct sja1000_priv *priv, int port,
0062                  u8 val)
0063 {
0064     struct f81601_pci_card *card = priv->priv;
0065     unsigned long flags;
0066
0067     spin_lock_irqsave(&card->lock, flags);
0068     writeb(val, priv->reg_base + port);
0069     readb(priv->reg_base);
0070     spin_unlock_irqrestore(&card->lock, flags);
0071 }
0072
0073 static void f81601_pci_remove(struct pci_dev *pdev)
0074 {
0075     struct f81601_pci_card *card = pci_get_drvdata(pdev);
0076     struct net_device *dev;
0077     int i;
0078
0079     for (i = 0; i < ARRAY_SIZE(card->net_dev); i++) {
0080         dev = card->net_dev[i];
0081         if (!dev)
0082             continue;
0083
0084         dev_info(&pdev->dev, "%s: Removing %s\n", __func__, dev->name);
0085
0086         unregister_sja1000dev(dev);
0087         free_sja1000dev(dev);
0088     }
0089 }
0090
0091 /* Probe F81601 based device for the SJA1000 chips and register each
0092  * available CAN channel to SJA1000 Socket-CAN subsystem.
0093  */
0094 static int f81601_pci_probe(struct pci_dev *pdev,
0095                 const struct pci_device_id *ent)
0096 {
0097     struct sja1000_priv *priv;
0098     struct net_device *dev;
0099     struct f81601_pci_card *card;
0100     int err, i, count;
0101     u8 tmp;
0102
0103     if (pcim_enable_device(pdev) < 0) {
0104         dev_err(&pdev->dev, "Failed to enable PCI device\n");
0105         return -ENODEV;
0106     }
0107
0108     dev_info(&pdev->dev, "Detected card at slot #%i\n",
0109          PCI_SLOT(pdev->devfn));
0110
0111     card = devm_kzalloc(&pdev->dev, sizeof(*card), GFP_KERNEL);
0112     if (!card)
0113         return -ENOMEM;
0114
0115     card->dev = pdev;
0116     spin_lock_init(&card->lock);
0117
0118     pci_set_drvdata(pdev, card);
0119
0120     tmp = F81601_IO_MODE | F81601_MEM_MODE | F81601_CFG_MODE |
0121         F81601_CAN2_EN | F81601_CAN1_EN;
0122
0123     if (internal_clk) {
0124         tmp |= F81601_CAN2_INTERNAL_CLK | F81601_CAN1_INTERNAL_CLK;
0125
0126         dev_info(&pdev->dev,
0127              "F81601 running with internal clock: 24Mhz\n");
0128     } else {
0129         dev_info(&pdev->dev,
0130              "F81601 running with external clock: %dMhz\n",
0131              external_clk / 1000000);
0132     }
0133
0134     pci_write_config_byte(pdev, F81601_DECODE_REG, tmp);
0135
0136     card->addr = pcim_iomap(pdev, 0, pci_resource_len(pdev, 0));
0137
0138     if (!card->addr) {
0139         err = -ENOMEM;
0140         dev_err(&pdev->dev, "%s: Failed to remap BAR\n", __func__);
0141         goto failure_cleanup;
0142     }
0143
0144     /* read CAN2_HW_EN strap pin to detect how many CANBUS do we have */
0145     count = ARRAY_SIZE(card->net_dev);
0146     pci_read_config_byte(pdev, F81601_TRAP_REG, &tmp);
0147     if (!(tmp & F81601_CAN2_HAS_EN))
0148         count = 1;
0149
0150     for (i = 0; i < count; i++) {
0151         dev = alloc_sja1000dev(0);
0152         if (!dev) {
0153             err = -ENOMEM;
0154             goto failure_cleanup;
0155         }
0156
0157         priv = netdev_priv(dev);
0158         priv->priv = card;
0159         priv->irq_flags = IRQF_SHARED;
0160         priv->reg_base = card->addr + 0x80 * i;
0161         priv->read_reg = f81601_pci_read_reg;
0162         priv->write_reg = f81601_pci_write_reg;
0163
0164         if (internal_clk)
0165             priv->can.clock.freq = 24000000 / 2;
0166         else
0167             priv->can.clock.freq = external_clk / 2;
0168
0169         priv->ocr = OCR_TX0_PUSHPULL | OCR_TX1_PUSHPULL;
0170         priv->cdr = CDR_CBP;
0171
0172         SET_NETDEV_DEV(dev, &pdev->dev);
0173         dev->dev_id = i;
0174         dev->irq = pdev->irq;
0175
0176         /* Register SJA1000 device */
0177         err = register_sja1000dev(dev);
0178         if (err) {
0179             dev_err(&pdev->dev,
0180                 "%s: Registering device failed: %x\n", __func__,
0181                 err);
0182             free_sja1000dev(dev);
0183             goto failure_cleanup;
0184         }
0185
0186         card->net_dev[i] = dev;
0187         dev_info(&pdev->dev, "Channel #%d, %s at 0x%p, irq %d\n", i,
0188              dev->name, priv->reg_base, dev->irq);
0189     }
0190
0191     return 0;
0192
0193  failure_cleanup:
0194     dev_err(&pdev->dev, "%s: failed: %d. Cleaning Up.\n", __func__, err);
0195     f81601_pci_remove(pdev);
0196
0197     return err;
0198 }
0199
0200 static struct pci_driver f81601_pci_driver = {
0201     .name = "f81601",
0202     .id_table = f81601_pci_tbl,
0203     .probe = f81601_pci_probe,
0204     .remove = f81601_pci_remove,
0205 };
0206
0207 MODULE_DESCRIPTION("Fintek F81601 PCIE to 2 CANBUS adaptor driver");
0208 MODULE_AUTHOR("Peter Hong <peter_hong@fintek.com.tw>");
0209 MODULE_LICENSE("GPL v2");
0210
0211 module_pci_driver(f81601_pci_driver);