734 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com>4 *5 * CAN driver for PEAK-System PCAN-PC Card6 * Derived from the PCAN project file driver/src/pcan_pccard.c7 * Copyright (C) 2006-2010 PEAK System-Technik GmbH8 */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 230 31#define PCC_CAN_CLOCK (16000000 / 2)32 33#define PCC_MANF_ID 0x037734#define PCC_CARD_ID 0x000135 36#define PCC_CHAN_SIZE 0x2037#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 0x4040 41/* common area registers */42#define PCC_CCR 0x0043#define PCC_CSR 0x0244#define PCC_CPR 0x0445#define PCC_SPI_DIR 0x0646#define PCC_SPI_DOR 0x0847#define PCC_SPI_ADR 0x0a48#define PCC_SPI_IR 0x0c49#define PCC_FW_MAJOR 0x1050#define PCC_FW_MINOR 0x1251 52/* CCR bits */53#define PCC_CCR_CLK_16 0x0054#define PCC_CCR_CLK_10 0x0155#define PCC_CCR_CLK_21 0x0256#define PCC_CCR_CLK_8 0x0357#define PCC_CCR_CLK_MASK PCC_CCR_CLK_858 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_ALL62 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 0x0069#define PCC_LED_FAST 0x0170#define PCC_LED_SLOW 0x0271#define PCC_LED_OFF 0x0372 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_ALL83 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 0x0488 89/* time waiting for SPI busy (prevent from infinite loop) */90#define PCC_SPI_MAX_BUSY_WAIT_MS 391 92/* max count of reading the SPI status register waiting for a change */93/* (prevent from infinite loop) */94#define PCC_WRITE_MAX_LOOP 100095 96/* max nb of int handled by that isr in one shot (prevent from infinite loop) */97#define PCC_ISR_MAX_LOOP 1098 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 7124 * (meaning direct oscillator output) because the second SJA1000 chip125 * 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 state158 */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 state167 */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 register175 */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 register183 */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 area210 */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 area218 */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 numbers233 * 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 busy243 */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 eeprom261 */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] = 1300 */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 power360 */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 activity374 */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 routine421 */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 calling439 * sja1000_interrupt() to speed up hotplug detection440 */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_IRQ448 * 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 power465 */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 location499 */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 device605 */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-CARD626 */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 resources720 */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);734