lincan/src/ems_cpcpci.c

   1 /* ems_cpcpci.c - support for EMS-WUENSCHE CPC-PCI card
   2  * Linux CAN-bus device driver.
   3  * The card support added by Paolo Grisleri <grisleri@ce.unipr.it>
   4  * This software is released under the GPL-License.
   5  * Version lincan-0.2  9 Jul 2003
   6  */
   7
   8 #include "../include/can.h"
   9 #include "../include/can_sysdep.h"
  10 #include "../include/main.h"
  11 #include "../include/sja1000p.h"
  12
  13 #ifdef CAN_ENABLE_PCI_SUPPORT
  14
  15
  16 /* the only one supported: EMS CPC-PCI */
  17 // PGX: check identifiers name
  18 # define EMS_CPCPCI_PCICAN_VENDOR 0x110a
  19 # define EMS_CPCPCI_PCICAN_ID 0x2104
  20
  21 /*AMCC 5920*/
  22 #define S5920_OMB    0x0C
  23 #define S5920_IMB    0x1C
  24 #define S5920_MBEF   0x34
  25 #define S5920_INTCSR 0x38
  26 #define S5920_RCR    0x3C
  27 #define S5920_PTCR   0x60
  28
  29 #define INTCSR_ADDON_INTENABLE_M        0x2000
  30 #define INTCSR_INTERRUPT_ASSERTED_M     0x800000
  31
  32 #define EMS_CPCPCI_BYTES_PER_CIRCUIT 0x200
  33 /* Each CPC register occupies 4 bytes */
  34 #define EMS_CPCPCI_BYTES_PER_REG     0x4
  35
  36 // Standard value: Pushpull  (OCTP1|OCTN1|OCTP0|OCTN0|OCM1)
  37 #define EMS_CPCPCI_OCR_DEFAULT_STD 0xDA
  38 // For Galathea piggyback.
  39 #define EMS_CPCPCI_OCR_DEFAULT_GAL 0xDB
  40
  41 /*
  42
  43 You need to know the following:
  44 " RX1 is connected to ground.
  45 " TX1 is not connected.
  46 " CLKO is not connected.
  47 " Setting the OCR register to 0xDA is a good idea.
  48   This means  normal output mode , push-pull and the correct polarity.
  49 " In the CDR register, you should set CBP to 1.
  50   You will probably also want to set the clock divider value to 0 (meaning divide-by-2),
  51   the Pelican bit, and the clock-off bit (you have no need for CLKOUT anyway.)
  52
  53 */
  54
  55
  56
  57 void ems_cpcpci_disconnect_irq(struct candevice_t *candev)
  58 {
  59         unsigned long tmp;
  60         /* Disable interrupts from card */
  61         tmp = inl(candev->dev_base_addr + S5920_INTCSR);
  62         tmp &= ~INTCSR_ADDON_INTENABLE_M;
  63         outl(tmp, candev->dev_base_addr + S5920_INTCSR);
  64 }
  65
  66 void ems_cpcpci_connect_irq(struct candevice_t *candev)
  67 {
  68         unsigned long tmp;
  69         /* Enable interrupts from card */
  70         tmp = inl(candev->dev_base_addr + S5920_INTCSR);
  71         tmp |= INTCSR_ADDON_INTENABLE_M;
  72         outl(tmp, candev->dev_base_addr + S5920_INTCSR);
  73 }
  74
  75
  76 int ems_cpcpci_request_io(struct candevice_t *candev)
  77 {
  78     #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,21))
  79         if(pci_request_region(candev->sysdevptr.pcidev, 0, "ems_cpcpci_s5920") != 0){
  80                 CANMSG("Request of ems_cpcpci_s5920 range failed\n");
  81                 return -ENODEV;
  82         }else if(pci_request_region(candev->sysdevptr.pcidev, 1, "ems_cpcpci_io") != 0){
  83                 CANMSG("Request of ems_cpcpci_io range failed\n");
  84                 goto error_io;
  85         }else if(pci_request_region(candev->sysdevptr.pcidev, 2, "ems_cpcpci_xilinx") != 0){
  86                 CANMSG("Request of ems_cpcpci_xilinx range failed\n");
  87                 goto error_xilinx;
  88         }
  89     #else /*(LINUX_VERSION_CODE > KERNEL_VERSION(2,4,21))*/
  90         if(pci_request_regions(candev->sysdevptr.pcidev, "EMS_CPCPCI") != 0){
  91                 CANMSG("Request of ems_cpcpci_s5920 regions failed\n");
  92                 return -ENODEV;
  93         }
  94     #endif /*(LINUX_VERSION_CODE > KERNEL_VERSION(2,4,21))*/
  95
  96         ems_cpcpci_disconnect_irq(candev);
  97
  98         return 0;
  99
 100     #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,21))
 101     error_xilinx:
 102         pci_release_region(candev->sysdevptr.pcidev, 1);
 103     error_io:
 104         pci_release_region(candev->sysdevptr.pcidev, 0);
 105     #endif /*(LINUX_VERSION_CODE > KERNEL_VERSION(2,4,21))*/
 106
 107         return -ENODEV;
 108 }
 109
 110 int ems_cpcpci_release_io(struct candevice_t *candev)
 111 {
 112         ems_cpcpci_disconnect_irq(candev);
 113
 114     #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,21))
 115         pci_release_region(candev->sysdevptr.pcidev, 2);
 116         pci_release_region(candev->sysdevptr.pcidev, 1);
 117         pci_release_region(candev->sysdevptr.pcidev, 0);
 118     #else /*(LINUX_VERSION_CODE > KERNEL_VERSION(2,4,21))*/
 119         pci_release_regions(candev->sysdevptr.pcidev);
 120     #endif /*(LINUX_VERSION_CODE > KERNEL_VERSION(2,4,21))*/
 121
 122         return 0;
 123 }
 124
 125
 126 void ems_cpcpci_write_register(unsigned char data, unsigned long address)
 127 {
 128         address += ((address&(EMS_CPCPCI_BYTES_PER_CIRCUIT-1))
 129                             *(EMS_CPCPCI_BYTES_PER_REG-1));
 130         readb(data,address);
 131 }
 132
 133 unsigned ems_cpcpci_read_register(unsigned long address)
 134 {
 135         address += ((address&(EMS_CPCPCI_BYTES_PER_CIRCUIT-1))
 136                             *(EMS_CPCPCI_BYTES_PER_REG-1));
 137         return inb(address);
 138 }
 139
 140 int ems_cpcpci_reset(struct candevice_t *candev)
 141 {
 142         int i=0,chip_nr;
 143         struct chip_t *chip;
 144         unsigned cdr;
 145
 146         DEBUGMSG("Resetting EMS_CPCPCI hardware ...\n");
 147
 148         /* Assert PTADR# - we're in passive mode so the other bits are not important */
 149         outl(0x80808080L, candev->dev_base_addr + S5920_PTCR);
 150
 151         ems_cpcpci_disconnect_irq(candev);
 152
 153         for(chip_nr=0;chip_nr<candev->nr_all_chips;chip_nr++){
 154                 if(!candev->chip[chip_nr]) continue;
 155                 chip=candev->chip[chip_nr];
 156
 157                 ems_cpcpci_write_register(MOD_RM, chip->chip_base_addr+SJAMOD);
 158                 udelay(1000);
 159
 160                 cdr=ems_cpcpci_read_register(chip->chip_base_addr+SJACDR);
 161                 ems_cpcpci_write_register(cdr|CDR_PELICAN, chip->chip_base_addr+SJACDR);
 162
 163                 ems_cpcpci_write_register(0, chip->chip_base_addr+SJAIER);
 164
 165                 i=20;
 166                 ems_cpcpci_write_register(0, chip->chip_base_addr+SJAMOD);
 167                 while (ems_cpcpci_read_register(chip->chip_base_addr+SJAMOD)&MOD_RM){
 168                         if(!i--) return -ENODEV;
 169                         udelay(1000);
 170                         ems_cpcpci_write_register(0, chip->chip_base_addr+SJAMOD);
 171                 }
 172
 173                 cdr=ems_cpcpci_read_register(chip->chip_base_addr+SJACDR);
 174                 ems_cpcpci_write_register(cdr|CDR_PELICAN, chip->chip_base_addr+SJACDR);
 175
 176                 ems_cpcpci_write_register(0, chip->chip_base_addr+SJAIER);
 177
 178                 ems_cpcpci_read_register(chip->chip_base_addr+SJAIR);
 179         }
 180
 181
 182         ems_cpcpci_connect_irq(candev);
 183
 184         return 0;
 185 }
 186
 187 int ems_cpcpci_init_hw_data(struct candevice_t *candev)
 188 {
 189         struct pci_dev *pcidev = NULL;
 190         int i;
 191
 192         pcidev = pci_find_device(EMS_CPCPCI_PCICAN_VENDOR, EMS_CPCPCI_PCICAN_ID, pcidev);
 193         if(pcidev == NULL) return -ENODEV;
 194
 195         if (pci_enable_device (pcidev)){
 196                 printk(KERN_CRIT "Setup of EMS_CPCPCI failed\n");
 197                 return -EIO;
 198         }
 199         candev->sysdevptr.pcidev=pcidev;
 200
 201         for(i=0;i<2;i++){
 202                 if(!(pci_resource_flags(pcidev,0)&IORESOURCE_MEM)){
 203                         printk(KERN_CRIT "EMS_CPCPCI region %d is not memory\n",i);
 204                         return -EIO;
 205                 }
 206         }
 207         candev->dev_base_addr=pci_resource_start(pcidev,0); /*S5920*/
 208         /* some control registers */
 209         candev->io_addr=pci_resource_start(pcidev,1);
 210         /* 0 more EMS control registers
 211          * 0x400 the first SJA1000
 212          * 0x600 the second SJA1000
 213          * each register occupies 4 bytes
 214          */
 215
 216         /*candev->flags |= CANDEV_PROGRAMMABLE_IRQ;*/
 217
 218         if (!strcmp(candev->hwname,"ems_cpcpci")) {
 219                 candev->nr_82527_chips=0;
 220                 candev->nr_sja1000_chips=2;
 221                 candev->nr_all_chips=2;
 222         }
 223
 224         return 0;
 225 }
 226
 227 int ems_cpcpci_init_chip_data(struct candevice_t *candev, int chipnr)
 228 {
 229
 230         if(candev->sysdevptr.pcidev==NULL)
 231                 return -ENODEV;
 232
 233         candev->chip[chipnr]->chip_irq=candev->sysdevptr.pcidev->irq;
 234
 235         candev->chip[chipnr]->chip_type="sja1000p";
 236         candev->chip[chipnr]->chip_base_addr = candev->io_addr+
 237                         0x400 + chipnr*EMS_CPCPCI_BYTES_PER_CIRCUIT;
 238         candev->chip[chipnr]->flags = 0;
 239         candev->chip[chipnr]->int_cpu_reg = 0;
 240         candev->chip[chipnr]->int_clk_reg = 0;
 241         candev->chip[chipnr]->int_bus_reg = 0;
 242         candev->chip[chipnr]->sja_cdr_reg = CDR_CBP | CDR_CLK_OFF;
 243         candev->chip[chipnr]->sja_ocr_reg = EMS_CPCPCI_OCR_DEFAULT_STD;
 244         candev->chip[chipnr]->clock = 8000000;
 245         candev->chip[chipnr]->flags |= CHIP_IRQ_PCI;
 246
 247         return 0;
 248 }
 249
 250 int ems_cpcpci_init_obj_data(struct chip_t *chip, int objnr)
 251 {
 252         chip->msgobj[objnr]->obj_base_addr=chip->chip_base_addr;
 253         return 0;
 254 }
 255
 256 int ems_cpcpci_program_irq(struct candevice_t *candev)
 257 {
 258
 259         return 0;
 260 }
 261
 262 int ems_cpcpci_register(struct hwspecops_t *hwspecops)
 263 {
 264         hwspecops->request_io = ems_cpcpci_request_io;
 265         hwspecops->release_io = ems_cpcpci_release_io;
 266         hwspecops->reset = ems_cpcpci_reset;
 267         hwspecops->init_hw_data = ems_cpcpci_init_hw_data;
 268         hwspecops->init_chip_data = ems_cpcpci_init_chip_data;
 269         hwspecops->init_obj_data = ems_cpcpci_init_obj_data;
 270         hwspecops->write_register = ems_cpcpci_write_register;
 271         hwspecops->read_register = ems_cpcpci_read_register;
 272         hwspecops->program_irq = ems_cpcpci_program_irq;
 273         return 0;
 274 }
 275
 276
 277 #endif /*CAN_ENABLE_PCI_SUPPORT*/