| /* |
| * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com> |
| * |
| * CAN driver for PEAK-System PCAN-PC Card |
| * Derived from the PCAN project file driver/src/pcan_pccard.c |
| * Copyright (C) 2006-2010 PEAK System-Technik GmbH |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the version 2 of the GNU General Public License |
| * as published by the Free Software Foundation |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| */ |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/interrupt.h> |
| #include <linux/netdevice.h> |
| #include <linux/delay.h> |
| #include <linux/timer.h> |
| #include <linux/io.h> |
| #include <pcmcia/cistpl.h> |
| #include <pcmcia/ds.h> |
| #include <linux/can.h> |
| #include <linux/can/dev.h> |
| #include "sja1000.h" |
| |
| MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>"); |
| MODULE_DESCRIPTION("CAN driver for PEAK-System PCAN-PC Cards"); |
| MODULE_LICENSE("GPL v2"); |
| MODULE_SUPPORTED_DEVICE("PEAK PCAN-PC Card"); |
| |
| /* PEAK-System PCMCIA driver name */ |
| #define PCC_NAME "peak_pcmcia" |
| |
| #define PCC_CHAN_MAX 2 |
| |
| #define PCC_CAN_CLOCK (16000000 / 2) |
| |
| #define PCC_MANF_ID 0x0377 |
| #define PCC_CARD_ID 0x0001 |
| |
| #define PCC_CHAN_SIZE 0x20 |
| #define PCC_CHAN_OFF(c) ((c) * PCC_CHAN_SIZE) |
| #define PCC_COMN_OFF (PCC_CHAN_OFF(PCC_CHAN_MAX)) |
| #define PCC_COMN_SIZE 0x40 |
| |
| /* common area registers */ |
| #define PCC_CCR 0x00 |
| #define PCC_CSR 0x02 |
| #define PCC_CPR 0x04 |
| #define PCC_SPI_DIR 0x06 |
| #define PCC_SPI_DOR 0x08 |
| #define PCC_SPI_ADR 0x0a |
| #define PCC_SPI_IR 0x0c |
| #define PCC_FW_MAJOR 0x10 |
| #define PCC_FW_MINOR 0x12 |
| |
| /* CCR bits */ |
| #define PCC_CCR_CLK_16 0x00 |
| #define PCC_CCR_CLK_10 0x01 |
| #define PCC_CCR_CLK_21 0x02 |
| #define PCC_CCR_CLK_8 0x03 |
| #define PCC_CCR_CLK_MASK PCC_CCR_CLK_8 |
| |
| #define PCC_CCR_RST_CHAN(c) (0x01 << ((c) + 2)) |
| #define PCC_CCR_RST_ALL (PCC_CCR_RST_CHAN(0) | PCC_CCR_RST_CHAN(1)) |
| #define PCC_CCR_RST_MASK PCC_CCR_RST_ALL |
| |
| /* led selection bits */ |
| #define PCC_LED(c) (1 << (c)) |
| #define PCC_LED_ALL (PCC_LED(0) | PCC_LED(1)) |
| |
| /* led state value */ |
| #define PCC_LED_ON 0x00 |
| #define PCC_LED_FAST 0x01 |
| #define PCC_LED_SLOW 0x02 |
| #define PCC_LED_OFF 0x03 |
| |
| #define PCC_CCR_LED_CHAN(s, c) ((s) << (((c) + 2) << 1)) |
| |
| #define PCC_CCR_LED_ON_CHAN(c) PCC_CCR_LED_CHAN(PCC_LED_ON, c) |
| #define PCC_CCR_LED_FAST_CHAN(c) PCC_CCR_LED_CHAN(PCC_LED_FAST, c) |
| #define PCC_CCR_LED_SLOW_CHAN(c) PCC_CCR_LED_CHAN(PCC_LED_SLOW, c) |
| #define PCC_CCR_LED_OFF_CHAN(c) PCC_CCR_LED_CHAN(PCC_LED_OFF, c) |
| #define PCC_CCR_LED_MASK_CHAN(c) PCC_CCR_LED_OFF_CHAN(c) |
| #define PCC_CCR_LED_OFF_ALL (PCC_CCR_LED_OFF_CHAN(0) | \ |
| PCC_CCR_LED_OFF_CHAN(1)) |
| #define PCC_CCR_LED_MASK PCC_CCR_LED_OFF_ALL |
| |
| #define PCC_CCR_INIT (PCC_CCR_CLK_16 | PCC_CCR_RST_ALL | PCC_CCR_LED_OFF_ALL) |
| |
| /* CSR bits */ |
| #define PCC_CSR_SPI_BUSY 0x04 |
| |
| /* time waiting for SPI busy (prevent from infinite loop) */ |
| #define PCC_SPI_MAX_BUSY_WAIT_MS 3 |
| |
| /* max count of reading the SPI status register waiting for a change */ |
| /* (prevent from infinite loop) */ |
| #define PCC_WRITE_MAX_LOOP 1000 |
| |
| /* max nb of int handled by that isr in one shot (prevent from infinite loop) */ |
| #define PCC_ISR_MAX_LOOP 10 |
| |
| /* EEPROM chip instruction set */ |
| /* note: EEPROM Read/Write instructions include A8 bit */ |
| #define PCC_EEP_WRITE(a) (0x02 | (((a) & 0x100) >> 5)) |
| #define PCC_EEP_READ(a) (0x03 | (((a) & 0x100) >> 5)) |
| #define PCC_EEP_WRDI 0x04 /* EEPROM Write Disable */ |
| #define PCC_EEP_RDSR 0x05 /* EEPROM Read Status Register */ |
| #define PCC_EEP_WREN 0x06 /* EEPROM Write Enable */ |
| |
| /* EEPROM Status Register bits */ |
| #define PCC_EEP_SR_WEN 0x02 /* EEPROM SR Write Enable bit */ |
| #define PCC_EEP_SR_WIP 0x01 /* EEPROM SR Write In Progress bit */ |
| |
| /* |
| * The board configuration is probably following: |
| * RX1 is connected to ground. |
| * TX1 is not connected. |
| * CLKO is not connected. |
| * Setting the OCR register to 0xDA is a good idea. |
| * This means normal output mode, push-pull and the correct polarity. |
| */ |
| #define PCC_OCR (OCR_TX0_PUSHPULL | OCR_TX1_PUSHPULL) |
| |
| /* |
| * In the CDR register, you should set CBP to 1. |
| * You will probably also want to set the clock divider value to 7 |
| * (meaning direct oscillator output) because the second SJA1000 chip |
| * is driven by the first one CLKOUT output. |
| */ |
| #define PCC_CDR (CDR_CBP | CDR_CLKOUT_MASK) |
| |
| struct pcan_channel { |
| struct net_device *netdev; |
| unsigned long prev_rx_bytes; |
| unsigned long prev_tx_bytes; |
| }; |
| |
| /* PCAN-PC Card private structure */ |
| struct pcan_pccard { |
| struct pcmcia_device *pdev; |
| int chan_count; |
| struct pcan_channel channel[PCC_CHAN_MAX]; |
| u8 ccr; |
| u8 fw_major; |
| u8 fw_minor; |
| void __iomem *ioport_addr; |
| struct timer_list led_timer; |
| }; |
| |
| static struct pcmcia_device_id pcan_table[] = { |
| PCMCIA_DEVICE_MANF_CARD(PCC_MANF_ID, PCC_CARD_ID), |
| PCMCIA_DEVICE_NULL, |
| }; |
| |
| MODULE_DEVICE_TABLE(pcmcia, pcan_table); |
| |
| static void pcan_set_leds(struct pcan_pccard *card, u8 mask, u8 state); |
| |
| /* |
| * start timer which controls leds state |
| */ |
| static void pcan_start_led_timer(struct pcan_pccard *card) |
| { |
| if (!timer_pending(&card->led_timer)) |
| mod_timer(&card->led_timer, jiffies + HZ); |
| } |
| |
| /* |
| * stop the timer which controls leds state |
| */ |
| static void pcan_stop_led_timer(struct pcan_pccard *card) |
| { |
| del_timer_sync(&card->led_timer); |
| } |
| |
| /* |
| * read a sja1000 register |
| */ |
| static u8 pcan_read_canreg(const struct sja1000_priv *priv, int port) |
| { |
| return ioread8(priv->reg_base + port); |
| } |
| |
| /* |
| * write a sja1000 register |
| */ |
| static void pcan_write_canreg(const struct sja1000_priv *priv, int port, u8 v) |
| { |
| struct pcan_pccard *card = priv->priv; |
| int c = (priv->reg_base - card->ioport_addr) / PCC_CHAN_SIZE; |
| |
| /* sja1000 register changes control the leds state */ |
| if (port == REG_MOD) |
| switch (v) { |
| case MOD_RM: |
| /* Reset Mode: set led on */ |
| pcan_set_leds(card, PCC_LED(c), PCC_LED_ON); |
| break; |
| case 0x00: |
| /* Normal Mode: led slow blinking and start led timer */ |
| pcan_set_leds(card, PCC_LED(c), PCC_LED_SLOW); |
| pcan_start_led_timer(card); |
| break; |
| default: |
| break; |
| } |
| |
| iowrite8(v, priv->reg_base + port); |
| } |
| |
| /* |
| * read a register from the common area |
| */ |
| static u8 pcan_read_reg(struct pcan_pccard *card, int port) |
| { |
| return ioread8(card->ioport_addr + PCC_COMN_OFF + port); |
| } |
| |
| /* |
| * write a register into the common area |
| */ |
| static void pcan_write_reg(struct pcan_pccard *card, int port, u8 v) |
| { |
| /* cache ccr value */ |
| if (port == PCC_CCR) { |
| if (card->ccr == v) |
| return; |
| card->ccr = v; |
| } |
| |
| iowrite8(v, card->ioport_addr + PCC_COMN_OFF + port); |
| } |
| |
| /* |
| * check whether the card is present by checking its fw version numbers |
| * against values read at probing time. |
| */ |
| static inline int pcan_pccard_present(struct pcan_pccard *card) |
| { |
| return ((pcan_read_reg(card, PCC_FW_MAJOR) == card->fw_major) && |
| (pcan_read_reg(card, PCC_FW_MINOR) == card->fw_minor)); |
| } |
| |
| /* |
| * wait for SPI engine while it is busy |
| */ |
| static int pcan_wait_spi_busy(struct pcan_pccard *card) |
| { |
| unsigned long timeout = jiffies + |
| msecs_to_jiffies(PCC_SPI_MAX_BUSY_WAIT_MS) + 1; |
| |
| /* be sure to read status at least once after sleeping */ |
| while (pcan_read_reg(card, PCC_CSR) & PCC_CSR_SPI_BUSY) { |
| if (time_after(jiffies, timeout)) |
| return -EBUSY; |
| schedule(); |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * write data in device eeprom |
| */ |
| static int pcan_write_eeprom(struct pcan_pccard *card, u16 addr, u8 v) |
| { |
| u8 status; |
| int err, i; |
| |
| /* write instruction enabling write */ |
| pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_WREN); |
| err = pcan_wait_spi_busy(card); |
| if (err) |
| goto we_spi_err; |
| |
| /* wait until write enabled */ |
| for (i = 0; i < PCC_WRITE_MAX_LOOP; i++) { |
| /* write instruction reading the status register */ |
| pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_RDSR); |
| err = pcan_wait_spi_busy(card); |
| if (err) |
| goto we_spi_err; |
| |
| /* get status register value and check write enable bit */ |
| status = pcan_read_reg(card, PCC_SPI_DIR); |
| if (status & PCC_EEP_SR_WEN) |
| break; |
| } |
| |
| if (i >= PCC_WRITE_MAX_LOOP) { |
| dev_err(&card->pdev->dev, |
| "stop waiting to be allowed to write in eeprom\n"); |
| return -EIO; |
| } |
| |
| /* set address and data */ |
| pcan_write_reg(card, PCC_SPI_ADR, addr & 0xff); |
| pcan_write_reg(card, PCC_SPI_DOR, v); |
| |
| /* |
| * write instruction with bit[3] set according to address value: |
| * if addr refers to upper half of the memory array: bit[3] = 1 |
| */ |
| pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_WRITE(addr)); |
| err = pcan_wait_spi_busy(card); |
| if (err) |
| goto we_spi_err; |
| |
| /* wait while write in progress */ |
| for (i = 0; i < PCC_WRITE_MAX_LOOP; i++) { |
| /* write instruction reading the status register */ |
| pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_RDSR); |
| err = pcan_wait_spi_busy(card); |
| if (err) |
| goto we_spi_err; |
| |
| /* get status register value and check write in progress bit */ |
| status = pcan_read_reg(card, PCC_SPI_DIR); |
| if (!(status & PCC_EEP_SR_WIP)) |
| break; |
| } |
| |
| if (i >= PCC_WRITE_MAX_LOOP) { |
| dev_err(&card->pdev->dev, |
| "stop waiting for write in eeprom to complete\n"); |
| return -EIO; |
| } |
| |
| /* write instruction disabling write */ |
| pcan_write_reg(card, PCC_SPI_IR, PCC_EEP_WRDI); |
| err = pcan_wait_spi_busy(card); |
| if (err) |
| goto we_spi_err; |
| |
| return 0; |
| |
| we_spi_err: |
| dev_err(&card->pdev->dev, |
| "stop waiting (spi engine always busy) err %d\n", err); |
| |
| return err; |
| } |
| |
| static void pcan_set_leds(struct pcan_pccard *card, u8 led_mask, u8 state) |
| { |
| u8 ccr = card->ccr; |
| int i; |
| |
| for (i = 0; i < card->chan_count; i++) |
| if (led_mask & PCC_LED(i)) { |
| /* clear corresponding led bits in ccr */ |
| ccr &= ~PCC_CCR_LED_MASK_CHAN(i); |
| /* then set new bits */ |
| ccr |= PCC_CCR_LED_CHAN(state, i); |
| } |
| |
| /* real write only if something has changed in ccr */ |
| pcan_write_reg(card, PCC_CCR, ccr); |
| } |
| |
| /* |
| * enable/disable CAN connectors power |
| */ |
| static inline void pcan_set_can_power(struct pcan_pccard *card, int onoff) |
| { |
| int err; |
| |
| err = pcan_write_eeprom(card, 0, !!onoff); |
| if (err) |
| dev_err(&card->pdev->dev, |
| "failed setting power %s to can connectors (err %d)\n", |
| (onoff) ? "on" : "off", err); |
| } |
| |
| /* |
| * set leds state according to channel activity |
| */ |
| static void pcan_led_timer(unsigned long arg) |
| { |
| struct pcan_pccard *card = (struct pcan_pccard *)arg; |
| struct net_device *netdev; |
| int i, up_count = 0; |
| u8 ccr; |
| |
| ccr = card->ccr; |
| for (i = 0; i < card->chan_count; i++) { |
| /* default is: not configured */ |
| ccr &= ~PCC_CCR_LED_MASK_CHAN(i); |
| ccr |= PCC_CCR_LED_ON_CHAN(i); |
| |
| netdev = card->channel[i].netdev; |
| if (!netdev || !(netdev->flags & IFF_UP)) |
| continue; |
| |
| up_count++; |
| |
| /* no activity (but configured) */ |
| ccr &= ~PCC_CCR_LED_MASK_CHAN(i); |
| ccr |= PCC_CCR_LED_SLOW_CHAN(i); |
| |
| /* if bytes counters changed, set fast blinking led */ |
| if (netdev->stats.rx_bytes != card->channel[i].prev_rx_bytes) { |
| card->channel[i].prev_rx_bytes = netdev->stats.rx_bytes; |
| ccr &= ~PCC_CCR_LED_MASK_CHAN(i); |
| ccr |= PCC_CCR_LED_FAST_CHAN(i); |
| } |
| if (netdev->stats.tx_bytes != card->channel[i].prev_tx_bytes) { |
| card->channel[i].prev_tx_bytes = netdev->stats.tx_bytes; |
| ccr &= ~PCC_CCR_LED_MASK_CHAN(i); |
| ccr |= PCC_CCR_LED_FAST_CHAN(i); |
| } |
| } |
| |
| /* write the new leds state */ |
| pcan_write_reg(card, PCC_CCR, ccr); |
| |
| /* restart timer (except if no more configured channels) */ |
| if (up_count) |
| mod_timer(&card->led_timer, jiffies + HZ); |
| } |
| |
| /* |
| * interrupt service routine |
| */ |
| static irqreturn_t pcan_isr(int irq, void *dev_id) |
| { |
| struct pcan_pccard *card = dev_id; |
| int irq_handled; |
| |
| /* prevent from infinite loop */ |
| for (irq_handled = 0; irq_handled < PCC_ISR_MAX_LOOP; irq_handled++) { |
| /* handle shared interrupt and next loop */ |
| int nothing_to_handle = 1; |
| int i; |
| |
| /* check interrupt for each channel */ |
| for (i = 0; i < card->chan_count; i++) { |
| struct net_device *netdev; |
| |
| /* |
| * check whether the card is present before calling |
| * sja1000_interrupt() to speed up hotplug detection |
| */ |
| if (!pcan_pccard_present(card)) { |
| /* card unplugged during isr */ |
| return IRQ_NONE; |
| } |
| |
| /* |
| * should check whether all or SJA1000_MAX_IRQ |
| * interrupts have been handled: loop again to be sure. |
| */ |
| netdev = card->channel[i].netdev; |
| if (netdev && |
| sja1000_interrupt(irq, netdev) == IRQ_HANDLED) |
| nothing_to_handle = 0; |
| } |
| |
| if (nothing_to_handle) |
| break; |
| } |
| |
| return (irq_handled) ? IRQ_HANDLED : IRQ_NONE; |
| } |
| |
| /* |
| * free all resources used by the channels and switch off leds and can power |
| */ |
| static void pcan_free_channels(struct pcan_pccard *card) |
| { |
| int i; |
| u8 led_mask = 0; |
| |
| for (i = 0; i < card->chan_count; i++) { |
| struct net_device *netdev; |
| char name[IFNAMSIZ]; |
| |
| led_mask |= PCC_LED(i); |
| |
| netdev = card->channel[i].netdev; |
| if (!netdev) |
| continue; |
| |
| strncpy(name, netdev->name, IFNAMSIZ); |
| |
| unregister_sja1000dev(netdev); |
| |
| free_sja1000dev(netdev); |
| |
| dev_info(&card->pdev->dev, "%s removed\n", name); |
| } |
| |
| /* do it only if device not removed */ |
| if (pcan_pccard_present(card)) { |
| pcan_set_leds(card, led_mask, PCC_LED_OFF); |
| pcan_set_can_power(card, 0); |
| } |
| } |
| |
| /* |
| * check if a CAN controller is present at the specified location |
| */ |
| static inline int pcan_channel_present(struct sja1000_priv *priv) |
| { |
| /* make sure SJA1000 is in reset mode */ |
| pcan_write_canreg(priv, REG_MOD, 1); |
| pcan_write_canreg(priv, REG_CDR, CDR_PELICAN); |
| |
| /* read reset-values */ |
| if (pcan_read_canreg(priv, REG_CDR) == CDR_PELICAN) |
| return 1; |
| |
| return 0; |
| } |
| |
| static int pcan_add_channels(struct pcan_pccard *card) |
| { |
| struct pcmcia_device *pdev = card->pdev; |
| int i, err = 0; |
| u8 ccr = PCC_CCR_INIT; |
| |
| /* init common registers (reset channels and leds off) */ |
| card->ccr = ~ccr; |
| pcan_write_reg(card, PCC_CCR, ccr); |
| |
| /* wait 2ms before unresetting channels */ |
| mdelay(2); |
| |
| ccr &= ~PCC_CCR_RST_ALL; |
| pcan_write_reg(card, PCC_CCR, ccr); |
| |
| /* create one network device per channel detected */ |
| for (i = 0; i < ARRAY_SIZE(card->channel); i++) { |
| struct net_device *netdev; |
| struct sja1000_priv *priv; |
| |
| netdev = alloc_sja1000dev(0); |
| if (!netdev) { |
| err = -ENOMEM; |
| break; |
| } |
| |
| /* update linkages */ |
| priv = netdev_priv(netdev); |
| priv->priv = card; |
| SET_NETDEV_DEV(netdev, &pdev->dev); |
| |
| priv->irq_flags = IRQF_SHARED; |
| netdev->irq = pdev->irq; |
| priv->reg_base = card->ioport_addr + PCC_CHAN_OFF(i); |
| |
| /* check if channel is present */ |
| if (!pcan_channel_present(priv)) { |
| dev_err(&pdev->dev, "channel %d not present\n", i); |
| free_sja1000dev(netdev); |
| continue; |
| } |
| |
| priv->read_reg = pcan_read_canreg; |
| priv->write_reg = pcan_write_canreg; |
| priv->can.clock.freq = PCC_CAN_CLOCK; |
| priv->ocr = PCC_OCR; |
| priv->cdr = PCC_CDR; |
| |
| /* Neither a slave device distributes the clock */ |
| if (i > 0) |
| priv->cdr |= CDR_CLK_OFF; |
| |
| priv->flags |= SJA1000_CUSTOM_IRQ_HANDLER; |
| |
| /* register SJA1000 device */ |
| err = register_sja1000dev(netdev); |
| if (err) { |
| free_sja1000dev(netdev); |
| continue; |
| } |
| |
| card->channel[i].netdev = netdev; |
| card->chan_count++; |
| |
| /* set corresponding led on in the new ccr */ |
| ccr &= ~PCC_CCR_LED_OFF_CHAN(i); |
| |
| dev_info(&pdev->dev, |
| "%s on channel %d at 0x%p irq %d\n", |
| netdev->name, i, priv->reg_base, pdev->irq); |
| } |
| |
| /* write new ccr (change leds state) */ |
| pcan_write_reg(card, PCC_CCR, ccr); |
| |
| return err; |
| } |
| |
| static int pcan_conf_check(struct pcmcia_device *pdev, void *priv_data) |
| { |
| pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH; |
| pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; /* only */ |
| pdev->io_lines = 10; |
| |
| /* This reserves IO space but doesn't actually enable it */ |
| return pcmcia_request_io(pdev); |
| } |
| |
| /* |
| * free all resources used by the device |
| */ |
| static void pcan_free(struct pcmcia_device *pdev) |
| { |
| struct pcan_pccard *card = pdev->priv; |
| |
| if (!card) |
| return; |
| |
| free_irq(pdev->irq, card); |
| pcan_stop_led_timer(card); |
| |
| pcan_free_channels(card); |
| |
| ioport_unmap(card->ioport_addr); |
| |
| kfree(card); |
| pdev->priv = NULL; |
| } |
| |
| /* |
| * setup PCMCIA socket and probe for PEAK-System PC-CARD |
| */ |
| static int __devinit pcan_probe(struct pcmcia_device *pdev) |
| { |
| struct pcan_pccard *card; |
| int err; |
| |
| pdev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO; |
| |
| err = pcmcia_loop_config(pdev, pcan_conf_check, NULL); |
| if (err) { |
| dev_err(&pdev->dev, "pcmcia_loop_config() error %d\n", err); |
| goto probe_err_1; |
| } |
| |
| if (!pdev->irq) { |
| dev_err(&pdev->dev, "no irq assigned\n"); |
| err = -ENODEV; |
| goto probe_err_1; |
| } |
| |
| err = pcmcia_enable_device(pdev); |
| if (err) { |
| dev_err(&pdev->dev, "pcmcia_enable_device failed err=%d\n", |
| err); |
| goto probe_err_1; |
| } |
| |
| card = kzalloc(sizeof(struct pcan_pccard), GFP_KERNEL); |
| if (!card) { |
| dev_err(&pdev->dev, "couldn't allocate card memory\n"); |
| err = -ENOMEM; |
| goto probe_err_2; |
| } |
| |
| card->pdev = pdev; |
| pdev->priv = card; |
| |
| /* sja1000 api uses iomem */ |
| card->ioport_addr = ioport_map(pdev->resource[0]->start, |
| resource_size(pdev->resource[0])); |
| if (!card->ioport_addr) { |
| dev_err(&pdev->dev, "couldn't map io port into io memory\n"); |
| err = -ENOMEM; |
| goto probe_err_3; |
| } |
| card->fw_major = pcan_read_reg(card, PCC_FW_MAJOR); |
| card->fw_minor = pcan_read_reg(card, PCC_FW_MINOR); |
| |
| /* display board name and firware version */ |
| dev_info(&pdev->dev, "PEAK-System pcmcia card %s fw %d.%d\n", |
| pdev->prod_id[1] ? pdev->prod_id[1] : "PCAN-PC Card", |
| card->fw_major, card->fw_minor); |
| |
| /* detect available channels */ |
| pcan_add_channels(card); |
| if (!card->chan_count) { |
| err = -ENOMEM; |
| goto probe_err_4; |
| } |
| |
| /* init the timer which controls the leds */ |
| init_timer(&card->led_timer); |
| card->led_timer.function = pcan_led_timer; |
| card->led_timer.data = (unsigned long)card; |
| |
| /* request the given irq */ |
| err = request_irq(pdev->irq, &pcan_isr, IRQF_SHARED, PCC_NAME, card); |
| if (err) { |
| dev_err(&pdev->dev, "couldn't request irq%d\n", pdev->irq); |
| goto probe_err_5; |
| } |
| |
| /* power on the connectors */ |
| pcan_set_can_power(card, 1); |
| |
| return 0; |
| |
| probe_err_5: |
| /* unregister can devices from network */ |
| pcan_free_channels(card); |
| |
| probe_err_4: |
| ioport_unmap(card->ioport_addr); |
| |
| probe_err_3: |
| kfree(card); |
| pdev->priv = NULL; |
| |
| probe_err_2: |
| pcmcia_disable_device(pdev); |
| |
| probe_err_1: |
| return err; |
| } |
| |
| /* |
| * release claimed resources |
| */ |
| static void pcan_remove(struct pcmcia_device *pdev) |
| { |
| pcan_free(pdev); |
| pcmcia_disable_device(pdev); |
| } |
| |
| static struct pcmcia_driver pcan_driver = { |
| .name = PCC_NAME, |
| .probe = pcan_probe, |
| .remove = pcan_remove, |
| .id_table = pcan_table, |
| }; |
| |
| static int __init pcan_init(void) |
| { |
| return pcmcia_register_driver(&pcan_driver); |
| } |
| module_init(pcan_init); |
| |
| static void __exit pcan_exit(void) |
| { |
| pcmcia_unregister_driver(&pcan_driver); |
| } |
| module_exit(pcan_exit); |