drivers/net/can/sja1000/peak_pcmcia.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com>
   4  *
   5  * CAN driver for PEAK-System PCAN-PC Card
   6  * Derived from the PCAN project file driver/src/pcan_pccard.c
   7  * Copyright (C) 2006-2010 PEAK System-Technik GmbH
   8  */
   9 #include <linux/kernel.h>
  10 #include <linux/module.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/netdevice.h>
  13 #include <linux/delay.h>
  14 #include <linux/timer.h>
  15 #include <linux/io.h>
  16 #include <pcmcia/cistpl.h>
  17 #include <pcmcia/ds.h>
  18 #include <linux/can.h>
  19 #include <linux/can/dev.h>
  20 #include "sja1000.h"
  21
  22 MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
  23 MODULE_DESCRIPTION("CAN driver for PEAK-System PCAN-PC Cards");
  24 MODULE_LICENSE("GPL v2");
  25 MODULE_SUPPORTED_DEVICE("PEAK PCAN-PC Card");
  26
  27 /* PEAK-System PCMCIA driver name */
  28 #define PCC_NAME                "peak_pcmcia"
  29
  30 #define PCC_CHAN_MAX            2
  31
  32 #define PCC_CAN_CLOCK           (16000000 / 2)
  33
  34 #define PCC_MANF_ID             0x0377
  35 #define PCC_CARD_ID             0x0001
  36
  37 #define PCC_CHAN_SIZE           0x20
  38 #define PCC_CHAN_OFF(c)         ((c) * PCC_CHAN_SIZE)
  39 #define PCC_COMN_OFF            (PCC_CHAN_OFF(PCC_CHAN_MAX))
  40 #define PCC_COMN_SIZE           0x40
  41
  42 /* common area registers */
  43 #define PCC_CCR                 0x00
  44 #define PCC_CSR                 0x02
  45 #define PCC_CPR                 0x04
  46 #define PCC_SPI_DIR             0x06
  47 #define PCC_SPI_DOR             0x08
  48 #define PCC_SPI_ADR             0x0a
  49 #define PCC_SPI_IR              0x0c
  50 #define PCC_FW_MAJOR            0x10
  51 #define PCC_FW_MINOR            0x12
  52
  53 /* CCR bits */
  54 #define PCC_CCR_CLK_16          0x00
  55 #define PCC_CCR_CLK_10          0x01
  56 #define PCC_CCR_CLK_21          0x02
  57 #define PCC_CCR_CLK_8           0x03
  58 #define PCC_CCR_CLK_MASK        PCC_CCR_CLK_8
  59
  60 #define PCC_CCR_RST_CHAN(c)     (0x01 << ((c) + 2))
  61 #define PCC_CCR_RST_ALL         (PCC_CCR_RST_CHAN(0) | PCC_CCR_RST_CHAN(1))
  62 #define PCC_CCR_RST_MASK        PCC_CCR_RST_ALL
  63
  64 /* led selection bits */
  65 #define PCC_LED(c)              (1 << (c))
  66 #define PCC_LED_ALL             (PCC_LED(0) | PCC_LED(1))
  67
  68 /* led state value */
  69 #define PCC_LED_ON              0x00
  70 #define PCC_LED_FAST            0x01
  71 #define PCC_LED_SLOW            0x02
  72 #define PCC_LED_OFF             0x03
  73
  74 #define PCC_CCR_LED_CHAN(s, c)  ((s) << (((c) + 2) << 1))
  75
  76 #define PCC_CCR_LED_ON_CHAN(c)          PCC_CCR_LED_CHAN(PCC_LED_ON, c)
  77 #define PCC_CCR_LED_FAST_CHAN(c)        PCC_CCR_LED_CHAN(PCC_LED_FAST, c)
  78 #define PCC_CCR_LED_SLOW_CHAN(c)        PCC_CCR_LED_CHAN(PCC_LED_SLOW, c)
  79 #define PCC_CCR_LED_OFF_CHAN(c)         PCC_CCR_LED_CHAN(PCC_LED_OFF, c)
  80 #define PCC_CCR_LED_MASK_CHAN(c)        PCC_CCR_LED_OFF_CHAN(c)
  81 #define PCC_CCR_LED_OFF_ALL             (PCC_CCR_LED_OFF_CHAN(0) | \
  82                                          PCC_CCR_LED_OFF_CHAN(1))
  83 #define PCC_CCR_LED_MASK                PCC_CCR_LED_OFF_ALL
  84
  85 #define PCC_CCR_INIT    (PCC_CCR_CLK_16 | PCC_CCR_RST_ALL | PCC_CCR_LED_OFF_ALL)
  86
  87 /* CSR bits */
  88 #define PCC_CSR_SPI_BUSY                0x04
  89
  90 /* time waiting for SPI busy (prevent from infinite loop) */
  91 #define PCC_SPI_MAX_BUSY_WAIT_MS        3
  92
  93 /* max count of reading the SPI status register waiting for a change */
  94 /* (prevent from infinite loop) */
  95 #define PCC_WRITE_MAX_LOOP              1000
  96
  97 /* max nb of int handled by that isr in one shot (prevent from infinite loop) */
  98 #define PCC_ISR_MAX_LOOP                10
  99
 100 /* EEPROM chip instruction set */
 101 /* note: EEPROM Read/Write instructions include A8 bit */
 102 #define PCC_EEP_WRITE(a)        (0x02 | (((a) & 0x100) >> 5))
 103 #define PCC_EEP_READ(a)         (0x03 | (((a) & 0x100) >> 5))
 104 #define PCC_EEP_WRDI            0x04    /* EEPROM Write Disable */
 105 #define PCC_EEP_RDSR            0x05    /* EEPROM Read Status Register */
 106 #define PCC_EEP_WREN            0x06    /* EEPROM Write Enable */
 107
 108 /* EEPROM Status Register bits */
 109 #define PCC_EEP_SR_WEN          0x02    /* EEPROM SR Write Enable bit */
 110 #define PCC_EEP_SR_WIP          0x01    /* EEPROM SR Write In Progress bit */
 111
 112 /*
 113  * The board configuration is probably following:
 114  * RX1 is connected to ground.
 115  * TX1 is not connected.
 116  * CLKO is not connected.
 117  * Setting the OCR register to 0xDA is a good idea.
 118  * This means normal output mode, push-pull and the correct polarity.
 119  */
 120 #define PCC_OCR                 (OCR_TX0_PUSHPULL | OCR_TX1_PUSHPULL)
 121
 122 /*
 123  * In the CDR register, you should set CBP to 1.
 124  * You will probably also want to set the clock divider value to 7
 125  * (meaning direct oscillator output) because the second SJA1000 chip
 126  * is driven by the first one CLKOUT output.
 127  */
 128 #define PCC_CDR                 (CDR_CBP | CDR_CLKOUT_MASK)
 129
 130 struct pcan_channel {
 131         struct net_device *netdev;
 132         unsigned long prev_rx_bytes;
 133         unsigned long prev_tx_bytes;
 134 };
 135
 136 /* PCAN-PC Card private structure */
 137 struct pcan_pccard {
 138         struct pcmcia_device *pdev;
 139         int chan_count;
 140         struct pcan_channel channel[PCC_CHAN_MAX];
 141         u8 ccr;
 142         u8 fw_major;
 143         u8 fw_minor;
 144         void __iomem *ioport_addr;
 145         struct timer_list led_timer;
 146 };
 147
 148 static struct pcmcia_device_id pcan_table[] = {
 149         PCMCIA_DEVICE_MANF_CARD(PCC_MANF_ID, PCC_CARD_ID),
 150         PCMCIA_DEVICE_NULL,
 151 };
 152
 153 MODULE_DEVICE_TABLE(pcmcia, pcan_table);
 154
 155 static void pcan_set_leds(struct pcan_pccard *card, u8 mask, u8 state);
 156
 157 /*
 158  * start timer which controls leds state
 159  */
 160 static void pcan_start_led_timer(struct pcan_pccard *card)
 161 {
 162         if (!timer_pending(&card->led_timer))
 163                 mod_timer(&card->led_timer, jiffies + HZ);
 164 }
 165
 166 /*
 167  * stop the timer which controls leds state
 168  */
 169 static void pcan_stop_led_timer(struct pcan_pccard *card)
 170 {
 171         del_timer_sync(&card->led_timer);
 172 }
 173
 174 /*
 175  * read a sja1000 register
 176  */
 177 static u8 pcan_read_canreg(const struct sja1000_priv *priv, int port)
 178 {
 179         return ioread8(priv->reg_base + port);
 180 }
 181
 182 /*
 183  * write a sja1000 register
 184  */
 185 static void pcan_write_canreg(const struct sja1000_priv *priv, int port, u8 v)
 186 {
 187         struct pcan_pccard *card = priv->priv;
 188         int c = (priv->reg_base - card->ioport_addr) / PCC_CHAN_SIZE;
 189
 190         /* sja1000 register changes control the leds state */
 191         if (port == SJA1000_MOD)
 192                 switch (v) {
 193                 case MOD_RM:
 194                         /* Reset Mode: set led on */
 195                         pcan_set_leds(card, PCC_LED(c), PCC_LED_ON);
 196                         break;
 197                 case 0x00:
 198                         /* Normal Mode: led slow blinking and start led timer */
 199                         pcan_set_leds(card, PCC_LED(c), PCC_LED_SLOW);
 200                         pcan_start_led_timer(card);
 201                         break;
 202                 default:
 203                         break;
 204                 }
 205
 206         iowrite8(v, priv->reg_base + port);
 207 }
 208
 209 /*
 210  * read a register from the common area
 211  */
 212 static u8 pcan_read_reg(struct pcan_pccard *card, int port)
 213 {
 214         return ioread8(card->ioport_addr + PCC_COMN_OFF + port);
 215 }
 216
 217 /*
 218  * write a register into the common area
 219  */
 220 static void pcan_write_reg(struct pcan_pccard *card, int port, u8 v)
 221 {
 222         /* cache ccr value */
 223         if (port == PCC_CCR) {
 224                 if (card->ccr == v)
 225                         return;
 226                 card->ccr = v;
 227         }
 228
 229         iowrite8(v, card->ioport_addr + PCC_COMN_OFF + port);
 230 }
 231
 232 /*
 233  * check whether the card is present by checking its fw version numbers
 234  * against values read at probing time.
 235  */
 236 static inline int pcan_pccard_present(struct pcan_pccard *card)
 237 {
 238         return ((pcan_read_reg(card, PCC_FW_MAJOR) == card->fw_major) &&
 239                 (pcan_read_reg(card, PCC_FW_MINOR) == card->fw_minor));
 240 }
 241
 242 /*
 243  * wait for SPI engine while it is busy
 244  */
 245 static int pcan_wait_spi_busy(struct pcan_pccard *card)
 246 {
 247         unsigned long timeout = jiffies +
 248                                 msecs_to_jiffies(PCC_SPI_MAX_BUSY_WAIT_MS) + 1;
 249
 250         /* be sure to read status at least once after sleeping */
 251         while (pcan_read_reg(card, PCC_CSR) & PCC_CSR_SPI_BUSY) {
 252                 if (time_after(jiffies, timeout))
 253                         return -EBUSY;
 254                 schedule();
 255         }
 256
 257         return 0;
 258 }
 259
 260 /*
 261  * write data in device eeprom
 262  */
 263 static int pcan_write_eeprom(struct pcan_pccard *card, u16 addr, u8 v)
 264 {
 265         u8 status;
 266         int err, i;
 267
 268         /* write instruction enabling write */
 269         pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_WREN);
 270         err = pcan_wait_spi_busy(card);
 271         if (err)
 272                 goto we_spi_err;
 273
 274         /* wait until write enabled */
 275         for (i = 0; i < PCC_WRITE_MAX_LOOP; i++) {
 276                 /* write instruction reading the status register */
 277                 pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_RDSR);
 278                 err = pcan_wait_spi_busy(card);
 279                 if (err)
 280                         goto we_spi_err;
 281
 282                 /* get status register value and check write enable bit */
 283                 status = pcan_read_reg(card, PCC_SPI_DIR);
 284                 if (status & PCC_EEP_SR_WEN)
 285                         break;
 286         }
 287
 288         if (i >= PCC_WRITE_MAX_LOOP) {
 289                 dev_err(&card->pdev->dev,
 290                         "stop waiting to be allowed to write in eeprom\n");
 291                 return -EIO;
 292         }
 293
 294         /* set address and data */
 295         pcan_write_reg(card, PCC_SPI_ADR, addr & 0xff);
 296         pcan_write_reg(card, PCC_SPI_DOR, v);
 297
 298         /*
 299          * write instruction with bit[3] set according to address value:
 300          * if addr refers to upper half of the memory array: bit[3] = 1
 301          */
 302         pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_WRITE(addr));
 303         err = pcan_wait_spi_busy(card);
 304         if (err)
 305                 goto we_spi_err;
 306
 307         /* wait while write in progress */
 308         for (i = 0; i < PCC_WRITE_MAX_LOOP; i++) {
 309                 /* write instruction reading the status register */
 310                 pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_RDSR);
 311                 err = pcan_wait_spi_busy(card);
 312                 if (err)
 313                         goto we_spi_err;
 314
 315                 /* get status register value and check write in progress bit */
 316                 status = pcan_read_reg(card, PCC_SPI_DIR);
 317                 if (!(status & PCC_EEP_SR_WIP))
 318                         break;
 319         }
 320
 321         if (i >= PCC_WRITE_MAX_LOOP) {
 322                 dev_err(&card->pdev->dev,
 323                         "stop waiting for write in eeprom to complete\n");
 324                 return -EIO;
 325         }
 326
 327         /* write instruction disabling write */
 328         pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_WRDI);
 329         err = pcan_wait_spi_busy(card);
 330         if (err)
 331                 goto we_spi_err;
 332
 333         return 0;
 334
 335 we_spi_err:
 336         dev_err(&card->pdev->dev,
 337                 "stop waiting (spi engine always busy) err %d\n", err);
 338
 339         return err;
 340 }
 341
 342 static void pcan_set_leds(struct pcan_pccard *card, u8 led_mask, u8 state)
 343 {
 344         u8 ccr = card->ccr;
 345         int i;
 346
 347         for (i = 0; i < card->chan_count; i++)
 348                 if (led_mask & PCC_LED(i)) {
 349                         /* clear corresponding led bits in ccr */
 350                         ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
 351                         /* then set new bits */
 352                         ccr |= PCC_CCR_LED_CHAN(state, i);
 353                 }
 354
 355         /* real write only if something has changed in ccr */
 356         pcan_write_reg(card, PCC_CCR, ccr);
 357 }
 358
 359 /*
 360  * enable/disable CAN connectors power
 361  */
 362 static inline void pcan_set_can_power(struct pcan_pccard *card, int onoff)
 363 {
 364         int err;
 365
 366         err = pcan_write_eeprom(card, 0, !!onoff);
 367         if (err)
 368                 dev_err(&card->pdev->dev,
 369                         "failed setting power %s to can connectors (err %d)\n",
 370                         (onoff) ? "on" : "off", err);
 371 }
 372
 373 /*
 374  * set leds state according to channel activity
 375  */
 376 static void pcan_led_timer(struct timer_list *t)
 377 {
 378         struct pcan_pccard *card = from_timer(card, t, led_timer);
 379         struct net_device *netdev;
 380         int i, up_count = 0;
 381         u8 ccr;
 382
 383         ccr = card->ccr;
 384         for (i = 0; i < card->chan_count; i++) {
 385                 /* default is: not configured */
 386                 ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
 387                 ccr |= PCC_CCR_LED_ON_CHAN(i);
 388
 389                 netdev = card->channel[i].netdev;
 390                 if (!netdev || !(netdev->flags & IFF_UP))
 391                         continue;
 392
 393                 up_count++;
 394
 395                 /* no activity (but configured) */
 396                 ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
 397                 ccr |= PCC_CCR_LED_SLOW_CHAN(i);
 398
 399                 /* if bytes counters changed, set fast blinking led */
 400                 if (netdev->stats.rx_bytes != card->channel[i].prev_rx_bytes) {
 401                         card->channel[i].prev_rx_bytes = netdev->stats.rx_bytes;
 402                         ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
 403                         ccr |= PCC_CCR_LED_FAST_CHAN(i);
 404                 }
 405                 if (netdev->stats.tx_bytes != card->channel[i].prev_tx_bytes) {
 406                         card->channel[i].prev_tx_bytes = netdev->stats.tx_bytes;
 407                         ccr &= ~PCC_CCR_LED_MASK_CHAN(i);
 408                         ccr |= PCC_CCR_LED_FAST_CHAN(i);
 409                 }
 410         }
 411
 412         /* write the new leds state */
 413         pcan_write_reg(card, PCC_CCR, ccr);
 414
 415         /* restart timer (except if no more configured channels) */
 416         if (up_count)
 417                 mod_timer(&card->led_timer, jiffies + HZ);
 418 }
 419
 420 /*
 421  * interrupt service routine
 422  */
 423 static irqreturn_t pcan_isr(int irq, void *dev_id)
 424 {
 425         struct pcan_pccard *card = dev_id;
 426         int irq_handled;
 427
 428         /* prevent from infinite loop */
 429         for (irq_handled = 0; irq_handled < PCC_ISR_MAX_LOOP; irq_handled++) {
 430                 /* handle shared interrupt and next loop */
 431                 int nothing_to_handle = 1;
 432                 int i;
 433
 434                 /* check interrupt for each channel */
 435                 for (i = 0; i < card->chan_count; i++) {
 436                         struct net_device *netdev;
 437
 438                         /*
 439                          * check whether the card is present before calling
 440                          * sja1000_interrupt() to speed up hotplug detection
 441                          */
 442                         if (!pcan_pccard_present(card)) {
 443                                 /* card unplugged during isr */
 444                                 return IRQ_NONE;
 445                         }
 446
 447                         /*
 448                          * should check whether all or SJA1000_MAX_IRQ
 449                          * interrupts have been handled: loop again to be sure.
 450                          */
 451                         netdev = card->channel[i].netdev;
 452                         if (netdev &&
 453                             sja1000_interrupt(irq, netdev) == IRQ_HANDLED)
 454                                 nothing_to_handle = 0;
 455                 }
 456
 457                 if (nothing_to_handle)
 458                         break;
 459         }
 460
 461         return (irq_handled) ? IRQ_HANDLED : IRQ_NONE;
 462 }
 463
 464 /*
 465  * free all resources used by the channels and switch off leds and can power
 466  */
 467 static void pcan_free_channels(struct pcan_pccard *card)
 468 {
 469         int i;
 470         u8 led_mask = 0;
 471
 472         for (i = 0; i < card->chan_count; i++) {
 473                 struct net_device *netdev;
 474                 char name[IFNAMSIZ];
 475
 476                 led_mask |= PCC_LED(i);
 477
 478                 netdev = card->channel[i].netdev;
 479                 if (!netdev)
 480                         continue;
 481
 482                 strlcpy(name, netdev->name, IFNAMSIZ);
 483
 484                 unregister_sja1000dev(netdev);
 485
 486                 free_sja1000dev(netdev);
 487
 488                 dev_info(&card->pdev->dev, "%s removed\n", name);
 489         }
 490
 491         /* do it only if device not removed */
 492         if (pcan_pccard_present(card)) {
 493                 pcan_set_leds(card, led_mask, PCC_LED_OFF);
 494                 pcan_set_can_power(card, 0);
 495         }
 496 }
 497
 498 /*
 499  * check if a CAN controller is present at the specified location
 500  */
 501 static inline int pcan_channel_present(struct sja1000_priv *priv)
 502 {
 503         /* make sure SJA1000 is in reset mode */
 504         pcan_write_canreg(priv, SJA1000_MOD, 1);
 505         pcan_write_canreg(priv, SJA1000_CDR, CDR_PELICAN);
 506
 507         /* read reset-values */
 508         if (pcan_read_canreg(priv, SJA1000_CDR) == CDR_PELICAN)
 509                 return 1;
 510
 511         return 0;
 512 }
 513
 514 static int pcan_add_channels(struct pcan_pccard *card)
 515 {
 516         struct pcmcia_device *pdev = card->pdev;
 517         int i, err = 0;
 518         u8 ccr = PCC_CCR_INIT;
 519
 520         /* init common registers (reset channels and leds off) */
 521         card->ccr = ~ccr;
 522         pcan_write_reg(card, PCC_CCR, ccr);
 523
 524         /* wait 2ms before unresetting channels */
 525         usleep_range(2000, 3000);
 526
 527         ccr &= ~PCC_CCR_RST_ALL;
 528         pcan_write_reg(card, PCC_CCR, ccr);
 529
 530         /* create one network device per channel detected */
 531         for (i = 0; i < ARRAY_SIZE(card->channel); i++) {
 532                 struct net_device *netdev;
 533                 struct sja1000_priv *priv;
 534
 535                 netdev = alloc_sja1000dev(0);
 536                 if (!netdev) {
 537                         err = -ENOMEM;
 538                         break;
 539                 }
 540
 541                 /* update linkages */
 542                 priv = netdev_priv(netdev);
 543                 priv->priv = card;
 544                 SET_NETDEV_DEV(netdev, &pdev->dev);
 545                 netdev->dev_id = i;
 546
 547                 priv->irq_flags = IRQF_SHARED;
 548                 netdev->irq = pdev->irq;
 549                 priv->reg_base = card->ioport_addr + PCC_CHAN_OFF(i);
 550
 551                 /* check if channel is present */
 552                 if (!pcan_channel_present(priv)) {
 553                         dev_err(&pdev->dev, "channel %d not present\n", i);
 554                         free_sja1000dev(netdev);
 555                         continue;
 556                 }
 557
 558                 priv->read_reg  = pcan_read_canreg;
 559                 priv->write_reg = pcan_write_canreg;
 560                 priv->can.clock.freq = PCC_CAN_CLOCK;
 561                 priv->ocr = PCC_OCR;
 562                 priv->cdr = PCC_CDR;
 563
 564                 /* Neither a slave device distributes the clock */
 565                 if (i > 0)
 566                         priv->cdr |= CDR_CLK_OFF;
 567
 568                 priv->flags |= SJA1000_CUSTOM_IRQ_HANDLER;
 569
 570                 /* register SJA1000 device */
 571                 err = register_sja1000dev(netdev);
 572                 if (err) {
 573                         free_sja1000dev(netdev);
 574                         continue;
 575                 }
 576
 577                 card->channel[i].netdev = netdev;
 578                 card->chan_count++;
 579
 580                 /* set corresponding led on in the new ccr */
 581                 ccr &= ~PCC_CCR_LED_OFF_CHAN(i);
 582
 583                 dev_info(&pdev->dev,
 584                         "%s on channel %d at 0x%p irq %d\n",
 585                         netdev->name, i, priv->reg_base, pdev->irq);
 586         }
 587
 588         /* write new ccr (change leds state) */
 589         pcan_write_reg(card, PCC_CCR, ccr);
 590
 591         return err;
 592 }
 593
 594 static int pcan_conf_check(struct pcmcia_device *pdev, void *priv_data)
 595 {
 596         pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 597         pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; /* only */
 598         pdev->io_lines = 10;
 599
 600         /* This reserves IO space but doesn't actually enable it */
 601         return pcmcia_request_io(pdev);
 602 }
 603
 604 /*
 605  * free all resources used by the device
 606  */
 607 static void pcan_free(struct pcmcia_device *pdev)
 608 {
 609         struct pcan_pccard *card = pdev->priv;
 610
 611         if (!card)
 612                 return;
 613
 614         free_irq(pdev->irq, card);
 615         pcan_stop_led_timer(card);
 616
 617         pcan_free_channels(card);
 618
 619         ioport_unmap(card->ioport_addr);
 620
 621         kfree(card);
 622         pdev->priv = NULL;
 623 }
 624
 625 /*
 626  * setup PCMCIA socket and probe for PEAK-System PC-CARD
 627  */
 628 static int pcan_probe(struct pcmcia_device *pdev)
 629 {
 630         struct pcan_pccard *card;
 631         int err;
 632
 633         pdev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 634
 635         err = pcmcia_loop_config(pdev, pcan_conf_check, NULL);
 636         if (err) {
 637                 dev_err(&pdev->dev, "pcmcia_loop_config() error %d\n", err);
 638                 goto probe_err_1;
 639         }
 640
 641         if (!pdev->irq) {
 642                 dev_err(&pdev->dev, "no irq assigned\n");
 643                 err = -ENODEV;
 644                 goto probe_err_1;
 645         }
 646
 647         err = pcmcia_enable_device(pdev);
 648         if (err) {
 649                 dev_err(&pdev->dev, "pcmcia_enable_device failed err=%d\n",
 650                         err);
 651                 goto probe_err_1;
 652         }
 653
 654         card = kzalloc(sizeof(struct pcan_pccard), GFP_KERNEL);
 655         if (!card) {
 656                 err = -ENOMEM;
 657                 goto probe_err_2;
 658         }
 659
 660         card->pdev = pdev;
 661         pdev->priv = card;
 662
 663         /* sja1000 api uses iomem */
 664         card->ioport_addr = ioport_map(pdev->resource[0]->start,
 665                                         resource_size(pdev->resource[0]));
 666         if (!card->ioport_addr) {
 667                 dev_err(&pdev->dev, "couldn't map io port into io memory\n");
 668                 err = -ENOMEM;
 669                 goto probe_err_3;
 670         }
 671         card->fw_major = pcan_read_reg(card, PCC_FW_MAJOR);
 672         card->fw_minor = pcan_read_reg(card, PCC_FW_MINOR);
 673
 674         /* display board name and firware version */
 675         dev_info(&pdev->dev, "PEAK-System pcmcia card %s fw %d.%d\n",
 676                 pdev->prod_id[1] ? pdev->prod_id[1] : "PCAN-PC Card",
 677                 card->fw_major, card->fw_minor);
 678
 679         /* detect available channels */
 680         pcan_add_channels(card);
 681         if (!card->chan_count) {
 682                 err = -ENOMEM;
 683                 goto probe_err_4;
 684         }
 685
 686         /* init the timer which controls the leds */
 687         timer_setup(&card->led_timer, pcan_led_timer, 0);
 688
 689         /* request the given irq */
 690         err = request_irq(pdev->irq, &pcan_isr, IRQF_SHARED, PCC_NAME, card);
 691         if (err) {
 692                 dev_err(&pdev->dev, "couldn't request irq%d\n", pdev->irq);
 693                 goto probe_err_5;
 694         }
 695
 696         /* power on the connectors */
 697         pcan_set_can_power(card, 1);
 698
 699         return 0;
 700
 701 probe_err_5:
 702         /* unregister can devices from network */
 703         pcan_free_channels(card);
 704
 705 probe_err_4:
 706         ioport_unmap(card->ioport_addr);
 707
 708 probe_err_3:
 709         kfree(card);
 710         pdev->priv = NULL;
 711
 712 probe_err_2:
 713         pcmcia_disable_device(pdev);
 714
 715 probe_err_1:
 716         return err;
 717 }
 718
 719 /*
 720  * release claimed resources
 721  */
 722 static void pcan_remove(struct pcmcia_device *pdev)
 723 {
 724         pcan_free(pdev);
 725         pcmcia_disable_device(pdev);
 726 }
 727
 728 static struct pcmcia_driver pcan_driver = {
 729         .name = PCC_NAME,
 730         .probe = pcan_probe,
 731         .remove = pcan_remove,
 732         .id_table = pcan_table,
 733 };
 734 module_pcmcia_driver(pcan_driver);