lincan/src/ssv.c

   1 /* ssv.c
   2  * Linux CAN-bus device driver.
   3  * Written by Arnaud Westenberg email:arnaud@casema.net
   4  * This software is released under the GPL-License.
   5  * Version lincan-0.3  17 Jun 2004
   6  */
   7
   8 #include "../include/can.h"
   9 #include "../include/can_sysdep.h"
  10 #include "../include/main.h"
  11 #include "../include/ssv.h"
  12 #include "../include/i82527.h"
  13
  14 int ssvcan_irq[2]={-1,-1};
  15 unsigned long ssvcan_base=0x0;
  16
  17 static CAN_DEFINE_SPINLOCK(ssv_port_lock);
  18
  19 /* IO_RANGE is the io-memory range that gets reserved, please adjust according
  20  * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
  21  * #define IO_RANGE 0x20 for sja1000 chips.
  22  */
  23 #define IO_RANGE 0x04
  24
  25 /* The function template_request_io is used to reserve the io-memory. If your
  26  * hardware uses a dedicated memory range as hardware control registers you
  27  * will have to add the code to reserve this memory as well.
  28  * The reserved memory starts at io_addr, wich is the module parameter io.
  29  */
  30 int ssv_request_io(struct candevice_t *candev)
  31 {
  32
  33         if (!can_request_io_region(candev->io_addr,IO_RANGE,DEVICE_NAME)) {
  34                 CANMSG("Unable to open port: 0x%lx\n",candev->io_addr);
  35                 return -ENODEV;
  36         } else {
  37                 DEBUGMSG("Registered IO-memory: 0x%lx - 0x%lx\n", candev->io_addr,
  38                          candev->io_addr + IO_RANGE - 1);
  39         }
  40         return 0;
  41 }
  42
  43 /* The function template_release_io is used to free the previously reserved
  44  * io-memory. In case you reserved more memory, don't forget to free it here.
  45  */
  46 int ssv_release_io(struct candevice_t *candev)
  47 {
  48
  49         can_release_io_region(candev->io_addr,IO_RANGE);
  50
  51         return 0;
  52 }
  53
  54 /* The function template_reset is used to give a hardware reset. This is rather
  55  * hardware specific so I haven't included example code. Don't forget to check
  56  * the reset status of the chip before returning.
  57  */
  58 int ssv_reset(struct candevice_t *candev)
  59 {
  60     int i;
  61
  62     DEBUGMSG("Resetting ssv hardware ...\n");
  63     ssv_write_register(1,ssvcan_base+iCPU);
  64     ssv_write_register(0,ssvcan_base+iCPU);
  65     ssv_write_register(1,ssvcan_base+0x100+iCPU);
  66     ssv_write_register(0,ssvcan_base+0x100+iCPU);
  67
  68     for (i = 1; i < 1000; i++)
  69         udelay (1000);
  70
  71     /* Check hardware reset status */
  72     i=0;
  73     while ( (ssv_read_register(ssvcan_base+iCPU) & iCPU_RST) && (i<=15)) {
  74         udelay(20000);
  75         i++;
  76     }
  77     if (i>=15) {
  78         CANMSG("Reset status timeout!\n");
  79         CANMSG("Please check your hardware.\n");
  80         return -ENODEV;
  81     }
  82     else
  83         DEBUGMSG("Chip0 reset status ok.\n");
  84
  85     /* Check hardware reset status */
  86     i=0;
  87     while ( (ssv_read_register(ssvcan_base+0x100+iCPU) & iCPU_RST) && (i<=15)) {
  88         udelay(20000);
  89         i++;
  90     }
  91     if (i>=15) {
  92         CANMSG("Reset status timeout!\n");
  93         CANMSG("Please check your hardware.\n");
  94         return -ENODEV;
  95     }
  96     else
  97         DEBUGMSG("Chip1 reset status ok.\n");
  98
  99
 100
 101     return 0;
 102 }
 103
 104 /* The function template_init_hw_data is used to initialize the hardware
 105  * structure containing information about the installed CAN-board.
 106  * RESET_ADDR represents the io-address of the hardware reset register.
 107  * NR_82527 represents the number of intel 82527 chips on the board.
 108  * NR_SJA1000 represents the number of philips sja1000 chips on the board.
 109  * The flags entry can currently only be CANDEV_PROGRAMMABLE_IRQ to indicate that
 110  * the hardware uses programmable interrupts.
 111  */
 112 #define RESET_ADDR 0x02
 113 #define NR_82527 2
 114 #define NR_SJA1000 0
 115
 116 int ssv_init_hw_data(struct candevice_t *candev)
 117 {
 118     candev->res_addr=RESET_ADDR;
 119     candev->nr_82527_chips=NR_82527;
 120     candev->nr_sja1000_chips=0;
 121     candev->nr_all_chips=NR_82527;
 122     candev->flags |= CANDEV_PROGRAMMABLE_IRQ;
 123
 124     return 0;
 125 }
 126
 127 /* The function template_init_chip_data is used to initialize the hardware
 128  * structure containing information about the CAN chips.
 129  * CHIP_TYPE represents the type of CAN chip. CHIP_TYPE can be "i82527" or
 130  * "sja1000".
 131  * The chip_base_addr entry represents the start of the 'official' memory map
 132  * of the installed chip. It's likely that this is the same as the io_addr
 133  * argument supplied at module loading time.
 134  * The clock argument holds the chip clock value in Hz.
 135  */
 136 int ssv_init_chip_data(struct candevice_t *candev, int chipnr)
 137 {
 138     i82527_fill_chipspecops(candev->chip[chipnr]);
 139     candev->chip[chipnr]->chip_base_addr=
 140         candev->io_addr+0x100*chipnr;
 141     candev->chip[chipnr]->clock = 16000000;
 142     ssvcan_irq[chipnr]=candev->chip[chipnr]->chip_irq;
 143
 144     ssvcan_base=candev->io_addr;
 145
 146     candev->chip[chipnr]->int_cpu_reg = iCPU_DSC;
 147     candev->chip[chipnr]->int_clk_reg = iCLK_SL1;
 148     candev->chip[chipnr]->int_bus_reg = iBUS_CBY;
 149     return 0;
 150 }
 151
 152  /* The function template_init_obj_data is used to initialize the hardware
 153  * structure containing information about the different message objects on the
 154  * CAN chip. In case of the sja1000 there's only one message object but on the
 155  * i82527 chip there are 15.
 156  * The code below is for a i82527 chip and initializes the object base addresses
 157  * The entry obj_base_addr represents the first memory address of the message
 158  * object. In case of the sja1000 obj_base_addr is taken the same as the chips
 159  * base address.
 160  * Unless the hardware uses a segmented memory map, flags can be set zero.
 161  */
 162 int ssv_init_obj_data(struct canchip_t *chip, int objnr)
 163 {
 164
 165     chip->msgobj[objnr]->obj_base_addr=
 166         chip->chip_base_addr+(objnr+1)*0x10;
 167
 168     return 0;
 169 }
 170
 171 /* The function template_program_irq is used for hardware that uses programmable
 172  * interrupts. If your hardware doesn't use programmable interrupts you should
 173  * not set the candevices_t->flags entry to CANDEV_PROGRAMMABLE_IRQ and leave this
 174  * function unedited. Again this function is hardware specific so there's no
 175  * example code.
 176  */
 177 int ssv_program_irq(struct candevice_t *candev)
 178 {
 179     return 0;
 180 }
 181
 182 /* The function template_write_register is used to write to hardware registers
 183  * on the CAN chip. You should only have to edit this function if your hardware
 184  * uses some specific write process.
 185  */
 186 void ssv_write_register(unsigned data, unsigned long address)
 187 {
 188     /* address is an absolute address */
 189
 190     /* the ssv card has two registers, the address register at 0x0
 191        and the data register at 0x01 */
 192
 193     /* write the relative address on the eight LSB bits
 194      and the data on the eight MSB bits in one time */
 195     if((address-ssvcan_base)<0x100)
 196         outw(address-ssvcan_base + (256 * data), ssvcan_base);
 197     else
 198         outw(address-ssvcan_base-0x100 + (256 * data), ssvcan_base+0x02);
 199 }
 200
 201 /* The function template_read_register is used to read from hardware registers
 202  * on the CAN chip. You should only have to edit this function if your hardware
 203  * uses some specific read process.
 204  */
 205 unsigned ssv_read_register(unsigned long address)
 206 {
 207     /* this is the same thing that the function write_register.
 208        We use the two register, we write the address where we
 209        want to read in a first time. In a second time we read the
 210        data */
 211     unsigned char ret;
 212     can_spin_irqflags_t flags;
 213
 214
 215     if((address-ssvcan_base)<0x100)
 216     {
 217         can_spin_lock_irqsave(&ssv_port_lock,flags);
 218         outb(address-ssvcan_base, ssvcan_base);
 219         ret=inb(ssvcan_base+1);
 220         can_spin_unlock_irqrestore(&ssv_port_lock,flags);
 221     }
 222     else
 223     {
 224         can_spin_lock_irqsave(&ssv_port_lock,flags);
 225         outb(address-ssvcan_base-0x100, ssvcan_base+0x02);
 226         ret=inb(ssvcan_base+1+0x02);
 227         can_spin_unlock_irqrestore(&ssv_port_lock,flags);
 228     }
 229
 230     return ret;
 231 }
 232
 233
 234  /* !!! Don't change this function !!! */
 235 int ssv_register(struct hwspecops_t *hwspecops)
 236 {
 237     hwspecops->request_io = ssv_request_io;
 238     hwspecops->release_io = ssv_release_io;
 239     hwspecops->reset = ssv_reset;
 240     hwspecops->init_hw_data = ssv_init_hw_data;
 241     hwspecops->init_chip_data = ssv_init_chip_data;
 242     hwspecops->init_obj_data = ssv_init_obj_data;
 243     hwspecops->write_register = ssv_write_register;
 244     hwspecops->read_register = ssv_read_register;
 245     hwspecops->program_irq = ssv_program_irq;
 246     return 0;
 247 }