Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com>
0004  *
0005  * CAN driver for PEAK-System PCAN-PC Card
0006  * Derived from the PCAN project file driver/src/pcan_pccard.c
0007  * Copyright (C) 2006-2010 PEAK System-Technik GmbH
0008  */
0009 #include <linux/kernel.h>
0010 #include <linux/module.h>
0011 #include <linux/interrupt.h>
0012 #include <linux/netdevice.h>
0013 #include <linux/delay.h>
0014 #include <linux/timer.h>
0015 #include <linux/io.h>
0016 #include <pcmcia/cistpl.h>
0017 #include <pcmcia/ds.h>
0018 #include <linux/can.h>
0019 #include <linux/can/dev.h>
0020 #include "sja1000.h"
0021 
0022 MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
0023 MODULE_DESCRIPTION("CAN driver for PEAK-System PCAN-PC Cards");
0024 MODULE_LICENSE("GPL v2");
0025 
0026 /* PEAK-System PCMCIA driver name */
0027 #define PCC_NAME        "peak_pcmcia"
0028 
0029 #define PCC_CHAN_MAX        2
0030 
0031 #define PCC_CAN_CLOCK       (16000000 / 2)
0032 
0033 #define PCC_MANF_ID     0x0377
0034 #define PCC_CARD_ID     0x0001
0035 
0036 #define PCC_CHAN_SIZE       0x20
0037 #define PCC_CHAN_OFF(c)     ((c) * PCC_CHAN_SIZE)
0038 #define PCC_COMN_OFF        (PCC_CHAN_OFF(PCC_CHAN_MAX))
0039 #define PCC_COMN_SIZE       0x40
0040 
0041 /* common area registers */
0042 #define PCC_CCR         0x00
0043 #define PCC_CSR         0x02
0044 #define PCC_CPR         0x04
0045 #define PCC_SPI_DIR     0x06
0046 #define PCC_SPI_DOR     0x08
0047 #define PCC_SPI_ADR     0x0a
0048 #define PCC_SPI_IR      0x0c
0049 #define PCC_FW_MAJOR        0x10
0050 #define PCC_FW_MINOR        0x12
0051 
0052 /* CCR bits */
0053 #define PCC_CCR_CLK_16      0x00
0054 #define PCC_CCR_CLK_10      0x01
0055 #define PCC_CCR_CLK_21      0x02
0056 #define PCC_CCR_CLK_8       0x03
0057 #define PCC_CCR_CLK_MASK    PCC_CCR_CLK_8
0058 
0059 #define PCC_CCR_RST_CHAN(c) (0x01 << ((c) + 2))
0060 #define PCC_CCR_RST_ALL     (PCC_CCR_RST_CHAN(0) | PCC_CCR_RST_CHAN(1))
0061 #define PCC_CCR_RST_MASK    PCC_CCR_RST_ALL
0062 
0063 /* led selection bits */
0064 #define PCC_LED(c)      (1 << (c))
0065 #define PCC_LED_ALL     (PCC_LED(0) | PCC_LED(1))
0066 
0067 /* led state value */
0068 #define PCC_LED_ON      0x00
0069 #define PCC_LED_FAST        0x01
0070 #define PCC_LED_SLOW        0x02
0071 #define PCC_LED_OFF     0x03
0072 
0073 #define PCC_CCR_LED_CHAN(s, c)  ((s) << (((c) + 2) << 1))
0074 
0075 #define PCC_CCR_LED_ON_CHAN(c)      PCC_CCR_LED_CHAN(PCC_LED_ON, c)
0076 #define PCC_CCR_LED_FAST_CHAN(c)    PCC_CCR_LED_CHAN(PCC_LED_FAST, c)
0077 #define PCC_CCR_LED_SLOW_CHAN(c)    PCC_CCR_LED_CHAN(PCC_LED_SLOW, c)
0078 #define PCC_CCR_LED_OFF_CHAN(c)     PCC_CCR_LED_CHAN(PCC_LED_OFF, c)
0079 #define PCC_CCR_LED_MASK_CHAN(c)    PCC_CCR_LED_OFF_CHAN(c)
0080 #define PCC_CCR_LED_OFF_ALL     (PCC_CCR_LED_OFF_CHAN(0) | \
0081                      PCC_CCR_LED_OFF_CHAN(1))
0082 #define PCC_CCR_LED_MASK        PCC_CCR_LED_OFF_ALL
0083 
0084 #define PCC_CCR_INIT    (PCC_CCR_CLK_16 | PCC_CCR_RST_ALL | PCC_CCR_LED_OFF_ALL)
0085 
0086 /* CSR bits */
0087 #define PCC_CSR_SPI_BUSY        0x04
0088 
0089 /* time waiting for SPI busy (prevent from infinite loop) */
0090 #define PCC_SPI_MAX_BUSY_WAIT_MS    3
0091 
0092 /* max count of reading the SPI status register waiting for a change */
0093 /* (prevent from infinite loop) */
0094 #define PCC_WRITE_MAX_LOOP      1000
0095 
0096 /* max nb of int handled by that isr in one shot (prevent from infinite loop) */
0097 #define PCC_ISR_MAX_LOOP        10
0098 
0099 /* EEPROM chip instruction set */
0100 /* note: EEPROM Read/Write instructions include A8 bit */
0101 #define PCC_EEP_WRITE(a)    (0x02 | (((a) & 0x100) >> 5))
0102 #define PCC_EEP_READ(a)     (0x03 | (((a) & 0x100) >> 5))
0103 #define PCC_EEP_WRDI        0x04    /* EEPROM Write Disable */
0104 #define PCC_EEP_RDSR        0x05    /* EEPROM Read Status Register */
0105 #define PCC_EEP_WREN        0x06    /* EEPROM Write Enable */
0106 
0107 /* EEPROM Status Register bits */
0108 #define PCC_EEP_SR_WEN      0x02    /* EEPROM SR Write Enable bit */
0109 #define PCC_EEP_SR_WIP      0x01    /* EEPROM SR Write In Progress bit */
0110 
0111 /*
0112  * The board configuration is probably following:
0113  * RX1 is connected to ground.
0114  * TX1 is not connected.
0115  * CLKO is not connected.
0116  * Setting the OCR register to 0xDA is a good idea.
0117  * This means normal output mode, push-pull and the correct polarity.
0118  */
0119 #define PCC_OCR         (OCR_TX0_PUSHPULL | OCR_TX1_PUSHPULL)
0120 
0121 /*
0122  * In the CDR register, you should set CBP to 1.
0123  * You will probably also want to set the clock divider value to 7
0124  * (meaning direct oscillator output) because the second SJA1000 chip
0125  * is driven by the first one CLKOUT output.
0126  */
0127 #define PCC_CDR         (CDR_CBP | CDR_CLKOUT_MASK)
0128 
0129 struct pcan_channel {
0130     struct net_device *netdev;
0131     unsigned long prev_rx_bytes;
0132     unsigned long prev_tx_bytes;
0133 };
0134 
0135 /* PCAN-PC Card private structure */
0136 struct pcan_pccard {
0137     struct pcmcia_device *pdev;
0138     int chan_count;
0139     struct pcan_channel channel[PCC_CHAN_MAX];
0140     u8 ccr;
0141     u8 fw_major;
0142     u8 fw_minor;
0143     void __iomem *ioport_addr;
0144     struct timer_list led_timer;
0145 };
0146 
0147 static struct pcmcia_device_id pcan_table[] = {
0148     PCMCIA_DEVICE_MANF_CARD(PCC_MANF_ID, PCC_CARD_ID),
0149     PCMCIA_DEVICE_NULL,
0150 };
0151 
0152 MODULE_DEVICE_TABLE(pcmcia, pcan_table);
0153 
0154 static void pcan_set_leds(struct pcan_pccard *card, u8 mask, u8 state);
0155 
0156 /*
0157  * start timer which controls leds state
0158  */
0159 static void pcan_start_led_timer(struct pcan_pccard *card)
0160 {
0161     if (!timer_pending(&card->led_timer))
0162         mod_timer(&card->led_timer, jiffies + HZ);
0163 }
0164 
0165 /*
0166  * stop the timer which controls leds state
0167  */
0168 static void pcan_stop_led_timer(struct pcan_pccard *card)
0169 {
0170     del_timer_sync(&card->led_timer);
0171 }
0172 
0173 /*
0174  * read a sja1000 register
0175  */
0176 static u8 pcan_read_canreg(const struct sja1000_priv *priv, int port)
0177 {
0178     return ioread8(priv->reg_base + port);
0179 }
0180 
0181 /*
0182  * write a sja1000 register
0183  */
0184 static void pcan_write_canreg(const struct sja1000_priv *priv, int port, u8 v)
0185 {
0186     struct pcan_pccard *card = priv->priv;
0187     int c = (priv->reg_base - card->ioport_addr) / PCC_CHAN_SIZE;
0188 
0189     /* sja1000 register changes control the leds state */
0190     if (port == SJA1000_MOD)
0191         switch (v) {
0192         case MOD_RM:
0193             /* Reset Mode: set led on */
0194             pcan_set_leds(card, PCC_LED(c), PCC_LED_ON);
0195             break;
0196         case 0x00:
0197             /* Normal Mode: led slow blinking and start led timer */
0198             pcan_set_leds(card, PCC_LED(c), PCC_LED_SLOW);
0199             pcan_start_led_timer(card);
0200             break;
0201         default:
0202             break;
0203         }
0204 
0205     iowrite8(v, priv->reg_base + port);
0206 }
0207 
0208 /*
0209  * read a register from the common area
0210  */
0211 static u8 pcan_read_reg(struct pcan_pccard *card, int port)
0212 {
0213     return ioread8(card->ioport_addr + PCC_COMN_OFF + port);
0214 }
0215 
0216 /*
0217  * write a register into the common area
0218  */
0219 static void pcan_write_reg(struct pcan_pccard *card, int port, u8 v)
0220 {
0221     /* cache ccr value */
0222     if (port == PCC_CCR) {
0223         if (card->ccr == v)
0224             return;
0225         card->ccr = v;
0226     }
0227 
0228     iowrite8(v, card->ioport_addr + PCC_COMN_OFF + port);
0229 }
0230 
0231 /*
0232  * check whether the card is present by checking its fw version numbers
0233  * against values read at probing time.
0234  */
0235 static inline int pcan_pccard_present(struct pcan_pccard *card)
0236 {
0237     return ((pcan_read_reg(card, PCC_FW_MAJOR) == card->fw_major) &&
0238         (pcan_read_reg(card, PCC_FW_MINOR) == card->fw_minor));
0239 }
0240 
0241 /*
0242  * wait for SPI engine while it is busy
0243  */
0244 static int pcan_wait_spi_busy(struct pcan_pccard *card)
0245 {
0246     unsigned long timeout = jiffies +
0247                 msecs_to_jiffies(PCC_SPI_MAX_BUSY_WAIT_MS) + 1;
0248 
0249     /* be sure to read status at least once after sleeping */
0250     while (pcan_read_reg(card, PCC_CSR) & PCC_CSR_SPI_BUSY) {
0251         if (time_after(jiffies, timeout))
0252             return -EBUSY;
0253         schedule();
0254     }
0255 
0256     return 0;
0257 }
0258 
0259 /*
0260  * write data in device eeprom
0261  */
0262 static int pcan_write_eeprom(struct pcan_pccard *card, u16 addr, u8 v)
0263 {
0264     u8 status;
0265     int err, i;
0266 
0267     /* write instruction enabling write */
0268     pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_WREN);
0269     err = pcan_wait_spi_busy(card);
0270     if (err)
0271         goto we_spi_err;
0272 
0273     /* wait until write enabled */
0274     for (i = 0; i < PCC_WRITE_MAX_LOOP; i++) {
0275         /* write instruction reading the status register */
0276         pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_RDSR);
0277         err = pcan_wait_spi_busy(card);
0278         if (err)
0279             goto we_spi_err;
0280 
0281         /* get status register value and check write enable bit */
0282         status = pcan_read_reg(card, PCC_SPI_DIR);
0283         if (status & PCC_EEP_SR_WEN)
0284             break;
0285     }
0286 
0287     if (i >= PCC_WRITE_MAX_LOOP) {
0288         dev_err(&card->pdev->dev,
0289             "stop waiting to be allowed to write in eeprom\n");
0290         return -EIO;
0291     }
0292 
0293     /* set address and data */
0294     pcan_write_reg(card, PCC_SPI_ADR, addr & 0xff);
0295     pcan_write_reg(card, PCC_SPI_DOR, v);
0296 
0297     /*
0298      * write instruction with bit[3] set according to address value:
0299      * if addr refers to upper half of the memory array: bit[3] = 1
0300      */
0301     pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_WRITE(addr));
0302     err = pcan_wait_spi_busy(card);
0303     if (err)
0304         goto we_spi_err;
0305 
0306     /* wait while write in progress */
0307     for (i = 0; i < PCC_WRITE_MAX_LOOP; i++) {
0308         /* write instruction reading the status register */
0309         pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_RDSR);
0310         err = pcan_wait_spi_busy(card);
0311         if (err)
0312             goto we_spi_err;
0313 
0314         /* get status register value and check write in progress bit */
0315         status = pcan_read_reg(card, PCC_SPI_DIR);
0316         if (!(status & PCC_EEP_SR_WIP))
0317             break;
0318     }
0319 
0320     if (i >= PCC_WRITE_MAX_LOOP) {
0321         dev_err(&card->pdev->dev,
0322             "stop waiting for write in eeprom to complete\n");
0323         return -EIO;
0324     }
0325 
0326     /* write instruction disabling write */
0327     pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_WRDI);
0328     err = pcan_wait_spi_busy(card);
0329     if (err)
0330         goto we_spi_err;
0331 
0332     return 0;
0333 
0334 we_spi_err:
0335     dev_err(&card->pdev->dev,
0336         "stop waiting (spi engine always busy) err %d\n", err);
0337 
0338     return err;
0339 }
0340 
0341 static void pcan_set_leds(struct pcan_pccard *card, u8 led_mask, u8 state)
0342 {
0343     u8 ccr = card->ccr;
0344     int i;
0345 
0346     for (i = 0; i < card->chan_count; i++)
0347         if (led_mask & PCC_LED(i)) {
0348             /* clear corresponding led bits in ccr */
0349             ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
0350             /* then set new bits */
0351             ccr |= PCC_CCR_LED_CHAN(state, i);
0352         }
0353 
0354     /* real write only if something has changed in ccr */
0355     pcan_write_reg(card, PCC_CCR, ccr);
0356 }
0357 
0358 /*
0359  * enable/disable CAN connectors power
0360  */
0361 static inline void pcan_set_can_power(struct pcan_pccard *card, int onoff)
0362 {
0363     int err;
0364 
0365     err = pcan_write_eeprom(card, 0, !!onoff);
0366     if (err)
0367         dev_err(&card->pdev->dev,
0368             "failed setting power %s to can connectors (err %d)\n",
0369             (onoff) ? "on" : "off", err);
0370 }
0371 
0372 /*
0373  * set leds state according to channel activity
0374  */
0375 static void pcan_led_timer(struct timer_list *t)
0376 {
0377     struct pcan_pccard *card = from_timer(card, t, led_timer);
0378     struct net_device *netdev;
0379     int i, up_count = 0;
0380     u8 ccr;
0381 
0382     ccr = card->ccr;
0383     for (i = 0; i < card->chan_count; i++) {
0384         /* default is: not configured */
0385         ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
0386         ccr |= PCC_CCR_LED_ON_CHAN(i);
0387 
0388         netdev = card->channel[i].netdev;
0389         if (!netdev || !(netdev->flags & IFF_UP))
0390             continue;
0391 
0392         up_count++;
0393 
0394         /* no activity (but configured) */
0395         ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
0396         ccr |= PCC_CCR_LED_SLOW_CHAN(i);
0397 
0398         /* if bytes counters changed, set fast blinking led */
0399         if (netdev->stats.rx_bytes != card->channel[i].prev_rx_bytes) {
0400             card->channel[i].prev_rx_bytes = netdev->stats.rx_bytes;
0401             ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
0402             ccr |= PCC_CCR_LED_FAST_CHAN(i);
0403         }
0404         if (netdev->stats.tx_bytes != card->channel[i].prev_tx_bytes) {
0405             card->channel[i].prev_tx_bytes = netdev->stats.tx_bytes;
0406             ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
0407             ccr |= PCC_CCR_LED_FAST_CHAN(i);
0408         }
0409     }
0410 
0411     /* write the new leds state */
0412     pcan_write_reg(card, PCC_CCR, ccr);
0413 
0414     /* restart timer (except if no more configured channels) */
0415     if (up_count)
0416         mod_timer(&card->led_timer, jiffies + HZ);
0417 }
0418 
0419 /*
0420  * interrupt service routine
0421  */
0422 static irqreturn_t pcan_isr(int irq, void *dev_id)
0423 {
0424     struct pcan_pccard *card = dev_id;
0425     int irq_handled;
0426 
0427     /* prevent from infinite loop */
0428     for (irq_handled = 0; irq_handled < PCC_ISR_MAX_LOOP; irq_handled++) {
0429         /* handle shared interrupt and next loop */
0430         int nothing_to_handle = 1;
0431         int i;
0432 
0433         /* check interrupt for each channel */
0434         for (i = 0; i < card->chan_count; i++) {
0435             struct net_device *netdev;
0436 
0437             /*
0438              * check whether the card is present before calling
0439              * sja1000_interrupt() to speed up hotplug detection
0440              */
0441             if (!pcan_pccard_present(card)) {
0442                 /* card unplugged during isr */
0443                 return IRQ_NONE;
0444             }
0445 
0446             /*
0447              * should check whether all or SJA1000_MAX_IRQ
0448              * interrupts have been handled: loop again to be sure.
0449              */
0450             netdev = card->channel[i].netdev;
0451             if (netdev &&
0452                 sja1000_interrupt(irq, netdev) == IRQ_HANDLED)
0453                 nothing_to_handle = 0;
0454         }
0455 
0456         if (nothing_to_handle)
0457             break;
0458     }
0459 
0460     return (irq_handled) ? IRQ_HANDLED : IRQ_NONE;
0461 }
0462 
0463 /*
0464  * free all resources used by the channels and switch off leds and can power
0465  */
0466 static void pcan_free_channels(struct pcan_pccard *card)
0467 {
0468     int i;
0469     u8 led_mask = 0;
0470 
0471     for (i = 0; i < card->chan_count; i++) {
0472         struct net_device *netdev;
0473         char name[IFNAMSIZ];
0474 
0475         led_mask |= PCC_LED(i);
0476 
0477         netdev = card->channel[i].netdev;
0478         if (!netdev)
0479             continue;
0480 
0481         strlcpy(name, netdev->name, IFNAMSIZ);
0482 
0483         unregister_sja1000dev(netdev);
0484 
0485         free_sja1000dev(netdev);
0486 
0487         dev_info(&card->pdev->dev, "%s removed\n", name);
0488     }
0489 
0490     /* do it only if device not removed */
0491     if (pcan_pccard_present(card)) {
0492         pcan_set_leds(card, led_mask, PCC_LED_OFF);
0493         pcan_set_can_power(card, 0);
0494     }
0495 }
0496 
0497 /*
0498  * check if a CAN controller is present at the specified location
0499  */
0500 static inline int pcan_channel_present(struct sja1000_priv *priv)
0501 {
0502     /* make sure SJA1000 is in reset mode */
0503     pcan_write_canreg(priv, SJA1000_MOD, 1);
0504     pcan_write_canreg(priv, SJA1000_CDR, CDR_PELICAN);
0505 
0506     /* read reset-values */
0507     if (pcan_read_canreg(priv, SJA1000_CDR) == CDR_PELICAN)
0508         return 1;
0509 
0510     return 0;
0511 }
0512 
0513 static int pcan_add_channels(struct pcan_pccard *card)
0514 {
0515     struct pcmcia_device *pdev = card->pdev;
0516     int i, err = 0;
0517     u8 ccr = PCC_CCR_INIT;
0518 
0519     /* init common registers (reset channels and leds off) */
0520     card->ccr = ~ccr;
0521     pcan_write_reg(card, PCC_CCR, ccr);
0522 
0523     /* wait 2ms before unresetting channels */
0524     usleep_range(2000, 3000);
0525 
0526     ccr &= ~PCC_CCR_RST_ALL;
0527     pcan_write_reg(card, PCC_CCR, ccr);
0528 
0529     /* create one network device per channel detected */
0530     for (i = 0; i < ARRAY_SIZE(card->channel); i++) {
0531         struct net_device *netdev;
0532         struct sja1000_priv *priv;
0533 
0534         netdev = alloc_sja1000dev(0);
0535         if (!netdev) {
0536             err = -ENOMEM;
0537             break;
0538         }
0539 
0540         /* update linkages */
0541         priv = netdev_priv(netdev);
0542         priv->priv = card;
0543         SET_NETDEV_DEV(netdev, &pdev->dev);
0544         netdev->dev_id = i;
0545 
0546         priv->irq_flags = IRQF_SHARED;
0547         netdev->irq = pdev->irq;
0548         priv->reg_base = card->ioport_addr + PCC_CHAN_OFF(i);
0549 
0550         /* check if channel is present */
0551         if (!pcan_channel_present(priv)) {
0552             dev_err(&pdev->dev, "channel %d not present\n", i);
0553             free_sja1000dev(netdev);
0554             continue;
0555         }
0556 
0557         priv->read_reg  = pcan_read_canreg;
0558         priv->write_reg = pcan_write_canreg;
0559         priv->can.clock.freq = PCC_CAN_CLOCK;
0560         priv->ocr = PCC_OCR;
0561         priv->cdr = PCC_CDR;
0562 
0563         /* Neither a slave device distributes the clock */
0564         if (i > 0)
0565             priv->cdr |= CDR_CLK_OFF;
0566 
0567         priv->flags |= SJA1000_CUSTOM_IRQ_HANDLER;
0568 
0569         /* register SJA1000 device */
0570         err = register_sja1000dev(netdev);
0571         if (err) {
0572             free_sja1000dev(netdev);
0573             continue;
0574         }
0575 
0576         card->channel[i].netdev = netdev;
0577         card->chan_count++;
0578 
0579         /* set corresponding led on in the new ccr */
0580         ccr &= ~PCC_CCR_LED_OFF_CHAN(i);
0581 
0582         dev_info(&pdev->dev,
0583             "%s on channel %d at 0x%p irq %d\n",
0584             netdev->name, i, priv->reg_base, pdev->irq);
0585     }
0586 
0587     /* write new ccr (change leds state) */
0588     pcan_write_reg(card, PCC_CCR, ccr);
0589 
0590     return err;
0591 }
0592 
0593 static int pcan_conf_check(struct pcmcia_device *pdev, void *priv_data)
0594 {
0595     pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
0596     pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; /* only */
0597     pdev->io_lines = 10;
0598 
0599     /* This reserves IO space but doesn't actually enable it */
0600     return pcmcia_request_io(pdev);
0601 }
0602 
0603 /*
0604  * free all resources used by the device
0605  */
0606 static void pcan_free(struct pcmcia_device *pdev)
0607 {
0608     struct pcan_pccard *card = pdev->priv;
0609 
0610     if (!card)
0611         return;
0612 
0613     free_irq(pdev->irq, card);
0614     pcan_stop_led_timer(card);
0615 
0616     pcan_free_channels(card);
0617 
0618     ioport_unmap(card->ioport_addr);
0619 
0620     kfree(card);
0621     pdev->priv = NULL;
0622 }
0623 
0624 /*
0625  * setup PCMCIA socket and probe for PEAK-System PC-CARD
0626  */
0627 static int pcan_probe(struct pcmcia_device *pdev)
0628 {
0629     struct pcan_pccard *card;
0630     int err;
0631 
0632     pdev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
0633 
0634     err = pcmcia_loop_config(pdev, pcan_conf_check, NULL);
0635     if (err) {
0636         dev_err(&pdev->dev, "pcmcia_loop_config() error %d\n", err);
0637         goto probe_err_1;
0638     }
0639 
0640     if (!pdev->irq) {
0641         dev_err(&pdev->dev, "no irq assigned\n");
0642         err = -ENODEV;
0643         goto probe_err_1;
0644     }
0645 
0646     err = pcmcia_enable_device(pdev);
0647     if (err) {
0648         dev_err(&pdev->dev, "pcmcia_enable_device failed err=%d\n",
0649             err);
0650         goto probe_err_1;
0651     }
0652 
0653     card = kzalloc(sizeof(struct pcan_pccard), GFP_KERNEL);
0654     if (!card) {
0655         err = -ENOMEM;
0656         goto probe_err_2;
0657     }
0658 
0659     card->pdev = pdev;
0660     pdev->priv = card;
0661 
0662     /* sja1000 api uses iomem */
0663     card->ioport_addr = ioport_map(pdev->resource[0]->start,
0664                     resource_size(pdev->resource[0]));
0665     if (!card->ioport_addr) {
0666         dev_err(&pdev->dev, "couldn't map io port into io memory\n");
0667         err = -ENOMEM;
0668         goto probe_err_3;
0669     }
0670     card->fw_major = pcan_read_reg(card, PCC_FW_MAJOR);
0671     card->fw_minor = pcan_read_reg(card, PCC_FW_MINOR);
0672 
0673     /* display board name and firmware version */
0674     dev_info(&pdev->dev, "PEAK-System pcmcia card %s fw %d.%d\n",
0675         pdev->prod_id[1] ? pdev->prod_id[1] : "PCAN-PC Card",
0676         card->fw_major, card->fw_minor);
0677 
0678     /* detect available channels */
0679     pcan_add_channels(card);
0680     if (!card->chan_count) {
0681         err = -ENOMEM;
0682         goto probe_err_4;
0683     }
0684 
0685     /* init the timer which controls the leds */
0686     timer_setup(&card->led_timer, pcan_led_timer, 0);
0687 
0688     /* request the given irq */
0689     err = request_irq(pdev->irq, &pcan_isr, IRQF_SHARED, PCC_NAME, card);
0690     if (err) {
0691         dev_err(&pdev->dev, "couldn't request irq%d\n", pdev->irq);
0692         goto probe_err_5;
0693     }
0694 
0695     /* power on the connectors */
0696     pcan_set_can_power(card, 1);
0697 
0698     return 0;
0699 
0700 probe_err_5:
0701     /* unregister can devices from network */
0702     pcan_free_channels(card);
0703 
0704 probe_err_4:
0705     ioport_unmap(card->ioport_addr);
0706 
0707 probe_err_3:
0708     kfree(card);
0709     pdev->priv = NULL;
0710 
0711 probe_err_2:
0712     pcmcia_disable_device(pdev);
0713 
0714 probe_err_1:
0715     return err;
0716 }
0717 
0718 /*
0719  * release claimed resources
0720  */
0721 static void pcan_remove(struct pcmcia_device *pdev)
0722 {
0723     pcan_free(pdev);
0724     pcmcia_disable_device(pdev);
0725 }
0726 
0727 static struct pcmcia_driver pcan_driver = {
0728     .name = PCC_NAME,
0729     .probe = pcan_probe,
0730     .remove = pcan_remove,
0731     .id_table = pcan_table,
0732 };
0733 module_pcmcia_driver(pcan_driver);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!