drivers/net/can/sja1000/peak_pcmcia.c

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