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