1 /* 2 * tscan1.c: driver for Technologic Systems TS-CAN1 PC104 boards 3 * 4 * Copyright 2010 Andre B. Oliveira 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 2 9 * of the License, or (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program. If not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 /* 21 * References: 22 * - Getting started with TS-CAN1, Technologic Systems, Jun 2009 23 * http://www.embeddedarm.com/documentation/ts-can1-manual.pdf 24 */ 25 26 #include <linux/init.h> 27 #include <linux/io.h> 28 #include <linux/ioport.h> 29 #include <linux/isa.h> 30 #include <linux/module.h> 31 #include <linux/netdevice.h> 32 #include "sja1000.h" 33 34 MODULE_DESCRIPTION("Driver for Technologic Systems TS-CAN1 PC104 boards"); 35 MODULE_AUTHOR("Andre B. Oliveira <anbadeol@gmail.com>"); 36 MODULE_LICENSE("GPL"); 37 38 /* Maximum number of boards (one in each JP1:JP2 setting of IO address) */ 39 #define TSCAN1_MAXDEV 4 40 41 /* PLD registers address offsets */ 42 #define TSCAN1_ID1 0 43 #define TSCAN1_ID2 1 44 #define TSCAN1_VERSION 2 45 #define TSCAN1_LED 3 46 #define TSCAN1_PAGE 4 47 #define TSCAN1_MODE 5 48 #define TSCAN1_JUMPERS 6 49 50 /* PLD board identifier registers magic values */ 51 #define TSCAN1_ID1_VALUE 0xf6 52 #define TSCAN1_ID2_VALUE 0xb9 53 54 /* PLD mode register SJA1000 IO enable bit */ 55 #define TSCAN1_MODE_ENABLE 0x40 56 57 /* PLD jumpers register bits */ 58 #define TSCAN1_JP4 0x10 59 #define TSCAN1_JP5 0x20 60 61 /* PLD IO base addresses start */ 62 #define TSCAN1_PLD_ADDRESS 0x150 63 64 /* PLD register space size */ 65 #define TSCAN1_PLD_SIZE 8 66 67 /* SJA1000 register space size */ 68 #define TSCAN1_SJA1000_SIZE 32 69 70 /* SJA1000 crystal frequency (16MHz) */ 71 #define TSCAN1_SJA1000_XTAL 16000000 72 73 /* SJA1000 IO base addresses */ 74 static const unsigned short tscan1_sja1000_addresses[] = { 75 0x100, 0x120, 0x180, 0x1a0, 0x200, 0x240, 0x280, 0x320 76 }; 77 78 /* Read SJA1000 register */ 79 static u8 tscan1_read(const struct sja1000_priv *priv, int reg) 80 { 81 return inb((unsigned long)priv->reg_base + reg); 82 } 83 84 /* Write SJA1000 register */ 85 static void tscan1_write(const struct sja1000_priv *priv, int reg, u8 val) 86 { 87 outb(val, (unsigned long)priv->reg_base + reg); 88 } 89 90 /* Probe for a TS-CAN1 board with JP2:JP1 jumper setting ID */ 91 static int tscan1_probe(struct device *dev, unsigned id) 92 { 93 struct net_device *netdev; 94 struct sja1000_priv *priv; 95 unsigned long pld_base, sja1000_base; 96 int irq, i; 97 98 pld_base = TSCAN1_PLD_ADDRESS + id * TSCAN1_PLD_SIZE; 99 if (!request_region(pld_base, TSCAN1_PLD_SIZE, dev_name(dev))) 100 return -EBUSY; 101 102 if (inb(pld_base + TSCAN1_ID1) != TSCAN1_ID1_VALUE || 103 inb(pld_base + TSCAN1_ID2) != TSCAN1_ID2_VALUE) { 104 release_region(pld_base, TSCAN1_PLD_SIZE); 105 return -ENODEV; 106 } 107 108 switch (inb(pld_base + TSCAN1_JUMPERS) & (TSCAN1_JP4 | TSCAN1_JP5)) { 109 case TSCAN1_JP4: 110 irq = 6; 111 break; 112 case TSCAN1_JP5: 113 irq = 7; 114 break; 115 case TSCAN1_JP4 | TSCAN1_JP5: 116 irq = 5; 117 break; 118 default: 119 dev_err(dev, "invalid JP4:JP5 setting (no IRQ)\n"); 120 release_region(pld_base, TSCAN1_PLD_SIZE); 121 return -EINVAL; 122 } 123 124 netdev = alloc_sja1000dev(0); 125 if (!netdev) { 126 release_region(pld_base, TSCAN1_PLD_SIZE); 127 return -ENOMEM; 128 } 129 130 dev_set_drvdata(dev, netdev); 131 SET_NETDEV_DEV(netdev, dev); 132 133 netdev->base_addr = pld_base; 134 netdev->irq = irq; 135 136 priv = netdev_priv(netdev); 137 priv->read_reg = tscan1_read; 138 priv->write_reg = tscan1_write; 139 priv->can.clock.freq = TSCAN1_SJA1000_XTAL / 2; 140 priv->cdr = CDR_CBP | CDR_CLK_OFF; 141 priv->ocr = OCR_TX0_PUSHPULL; 142 143 /* Select the first SJA1000 IO address that is free and that works */ 144 for (i = 0; i < ARRAY_SIZE(tscan1_sja1000_addresses); i++) { 145 sja1000_base = tscan1_sja1000_addresses[i]; 146 if (!request_region(sja1000_base, TSCAN1_SJA1000_SIZE, 147 dev_name(dev))) 148 continue; 149 150 /* Set SJA1000 IO base address and enable it */ 151 outb(TSCAN1_MODE_ENABLE | i, pld_base + TSCAN1_MODE); 152 153 priv->reg_base = (void __iomem *)sja1000_base; 154 if (!register_sja1000dev(netdev)) { 155 /* SJA1000 probe succeeded; turn LED off and return */ 156 outb(0, pld_base + TSCAN1_LED); 157 netdev_info(netdev, "TS-CAN1 at 0x%lx 0x%lx irq %d\n", 158 pld_base, sja1000_base, irq); 159 return 0; 160 } 161 162 /* SJA1000 probe failed; release and try next address */ 163 outb(0, pld_base + TSCAN1_MODE); 164 release_region(sja1000_base, TSCAN1_SJA1000_SIZE); 165 } 166 167 dev_err(dev, "failed to assign SJA1000 IO address\n"); 168 dev_set_drvdata(dev, NULL); 169 free_sja1000dev(netdev); 170 release_region(pld_base, TSCAN1_PLD_SIZE); 171 return -ENXIO; 172 } 173 174 static int tscan1_remove(struct device *dev, unsigned id /*unused*/) 175 { 176 struct net_device *netdev; 177 struct sja1000_priv *priv; 178 unsigned long pld_base, sja1000_base; 179 180 netdev = dev_get_drvdata(dev); 181 unregister_sja1000dev(netdev); 182 dev_set_drvdata(dev, NULL); 183 184 priv = netdev_priv(netdev); 185 pld_base = netdev->base_addr; 186 sja1000_base = (unsigned long)priv->reg_base; 187 188 outb(0, pld_base + TSCAN1_MODE); /* disable SJA1000 IO space */ 189 190 release_region(sja1000_base, TSCAN1_SJA1000_SIZE); 191 release_region(pld_base, TSCAN1_PLD_SIZE); 192 193 free_sja1000dev(netdev); 194 195 return 0; 196 } 197 198 static struct isa_driver tscan1_isa_driver = { 199 .probe = tscan1_probe, 200 .remove = tscan1_remove, 201 .driver = { 202 .name = "tscan1", 203 }, 204 }; 205 206 static int __init tscan1_init(void) 207 { 208 return isa_register_driver(&tscan1_isa_driver, TSCAN1_MAXDEV); 209 } 210 module_init(tscan1_init); 211 212 static void __exit tscan1_exit(void) 213 { 214 isa_unregister_driver(&tscan1_isa_driver); 215 } 216 module_exit(tscan1_exit); 217