| 1 |
// SPDX-License-Identifier: GPL-2.0-only |
| 2 |
/* |
| 3 |
* CAN driver for PEAK-System PCAN-PC Card |
| 4 |
* Derived from the PCAN project file driver/src/pcan_pccard.c |
| 5 |
* |
| 6 |
* Copyright (C) 2006-2025 PEAK System-Technik GmbH |
| 7 |
* Author: Stéphane Grosjean <[email protected]> |
| 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("Stéphane 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 |
timer_delete_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 = timer_container_of(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_obj(struct pcan_pccard); |
| 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); |