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);
745