lincan/src/usbcan.c

   1 /* usbcan.h
   2  * Header file for the Linux CAN-bus driver.
   3  * Written by Jan Kriz email:johen@post.cz
   4  * This software is released under the GPL-License.
   5  * Version lincan-0.3  17 Jul 2008
   6  */
   7
   8 #include "../include/can.h"
   9 #include "../include/can_sysdep.h"
  10 #include "../include/main.h"
  11 #include "../include/usbcan.h"
  12
  13 /*
  14  * IO_RANGE is the io-memory range that gets reserved, please adjust according
  15  * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
  16  * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
  17  */
  18 #define IO_RANGE 0x100
  19
  20 /**
  21  * usbcan_request_io: - reserve io or memory range for can board
  22  * @candev: pointer to candevice/board which asks for io. Field @io_addr
  23  *      of @candev is used in most cases to define start of the range
  24  *
  25  * The function usbcan_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  * %IO_RANGE is the io-memory range that gets reserved, please adjust according
  29  * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
  30  * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
  31  * Return Value: The function returns zero on success or %-ENODEV on failure
  32  * File: src/usbcan.c
  33  */
  34 int usbcan_request_io(struct candevice_t *candev)
  35 {
  36         if (!can_request_io_region(candev->io_addr,IO_RANGE,DEVICE_NAME)) {
  37                 CANMSG("Unable to open port: 0x%lx\n",candev->io_addr);
  38                 return -ENODEV;
  39         }else {
  40                 DEBUGMSG("Registered IO-memory: 0x%lx - 0x%lx\n", candev->io_addr, candev->io_addr + IO_RANGE - 1);
  41         }
  42         return 0;
  43 }
  44
  45 /**
  46  * usbcan_release_io - free reserved io memory range
  47  * @candev: pointer to candevice/board which releases io
  48  *
  49  * The function usbcan_release_io() is used to free reserved io-memory.
  50  * In case you have reserved more io memory, don't forget to free it here.
  51  * IO_RANGE is the io-memory range that gets released, please adjust according
  52  * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
  53  * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
  54  * Return Value: The function always returns zero
  55  * File: src/usbcan.c
  56  */
  57 int usbcan_release_io(struct candevice_t *candev)
  58 {
  59         can_release_io_region(candev->io_addr,IO_RANGE);
  60
  61         return 0;
  62 }
  63
  64 /**
  65  * usbcan_reset - hardware reset routine
  66  * @candev: Pointer to candevice/board structure
  67  *
  68  * The function usbcan_reset() is used to give a hardware reset. This is
  69  * rather hardware specific so I haven't included example code. Don't forget to
  70  * check the reset status of the chip before returning.
  71  * Return Value: The function returns zero on success or %-ENODEV on failure
  72  * File: src/usbcan.c
  73  */
  74 int usbcan_reset(struct candevice_t *candev)
  75 {
  76         return 0;
  77 }
  78
  79 #define RESET_ADDR 0x0
  80
  81 /**
  82  * usbcan_init_hw_data - Initialize hardware cards
  83  * @candev: Pointer to candevice/board structure
  84  *
  85  * The function usbcan_init_hw_data() is used to initialize the hardware
  86  * structure containing information about the installed CAN-board.
  87  * %RESET_ADDR represents the io-address of the hardware reset register.
  88  * %NR_82527 represents the number of Intel 82527 chips on the board.
  89  * %NR_SJA1000 represents the number of Philips sja1000 chips on the board.
  90  * The flags entry can currently only be %CANDEV_PROGRAMMABLE_IRQ to indicate that
  91  * the hardware uses programmable interrupts.
  92  * Return Value: The function always returns zero
  93  * File: src/usbcan.c
  94  */
  95 int usbcan_init_hw_data(struct candevice_t *candev)
  96 {
  97         candev->res_addr=RESET_ADDR;
  98         candev->nr_82527_chips=0;
  99         candev->nr_sja1000_chips=0;
 100         candev->nr_all_chips=1;
 101         candev->flags |= CANDEV_PROGRAMMABLE_IRQ*0;
 102
 103         return 0;
 104 }
 105
 106 /**
 107  * usbcan_init_chip_data - Initialize chips
 108  * @candev: Pointer to candevice/board structure
 109  * @chipnr: Number of the CAN chip on the hardware card
 110  *
 111  * The function usbcan_init_chip_data() is used to initialize the hardware
 112  * structure containing information about the CAN chips.
 113  * %CHIP_TYPE represents the type of CAN chip. %CHIP_TYPE can be "i82527" or
 114  * "sja1000".
 115  * The @chip_base_addr entry represents the start of the 'official' memory map
 116  * of the installed chip. It's likely that this is the same as the @io_addr
 117  * argument supplied at module loading time.
 118  * The @clock entry holds the chip clock value in Hz.
 119  * The entry @sja_cdr_reg holds hardware specific options for the Clock Divider
 120  * register. Options defined in the %sja1000.h file:
 121  * %sjaCDR_CLKOUT_MASK, %sjaCDR_CLK_OFF, %sjaCDR_RXINPEN, %sjaCDR_CBP, %sjaCDR_PELICAN
 122  * The entry @sja_ocr_reg holds hardware specific options for the Output Control
 123  * register. Options defined in the %sja1000.h file:
 124  * %sjaOCR_MODE_BIPHASE, %sjaOCR_MODE_TEST, %sjaOCR_MODE_NORMAL, %sjaOCR_MODE_CLOCK,
 125  * %sjaOCR_TX0_LH, %sjaOCR_TX1_ZZ.
 126  * The entry @int_clk_reg holds hardware specific options for the Clock Out
 127  * register. Options defined in the %i82527.h file:
 128  * %iCLK_CD0, %iCLK_CD1, %iCLK_CD2, %iCLK_CD3, %iCLK_SL0, %iCLK_SL1.
 129  * The entry @int_bus_reg holds hardware specific options for the Bus
 130  * Configuration register. Options defined in the %i82527.h file:
 131  * %iBUS_DR0, %iBUS_DR1, %iBUS_DT1, %iBUS_POL, %iBUS_CBY.
 132  * The entry @int_cpu_reg holds hardware specific options for the cpu interface
 133  * register. Options defined in the %i82527.h file:
 134  * %iCPU_CEN, %iCPU_MUX, %iCPU_SLP, %iCPU_PWD, %iCPU_DMC, %iCPU_DSC, %iCPU_RST.
 135  * Return Value: The function always returns zero
 136  * File: src/usbcan.c
 137  */
 138 int usbcan_init_chip_data(struct candevice_t *candev, int chipnr)
 139 {
 140         canchip_t chip=candev->chip[chipnr];
 141
 142         chip->chip_type="usbcan";
 143         chip->max_objects=1;
 144         usbcan_register(chip->chipspecops);
 145
 146         CANMSG("initializing usbcan chip operations\n");
 147         chipspecops->chip_config=usbcan_chip_config;
 148         chipspecops->baud_rate=usbcan_baud_rate;
 149         chipspecops->standard_mask=usbcan_standard_mask;
 150         chipspecops->extended_mask=usbcan_extended_mask;
 151         chipspecops->message15_mask=usbcan_extended_mask;
 152         chipspecops->clear_objects=usbcan_clear_objects;
 153         chipspecops->config_irqs=usbcan_config_irqs;
 154         chipspecops->pre_read_config=usbcan_pre_read_config;
 155         chipspecops->pre_write_config=usbcan_pre_write_config;
 156         chipspecops->send_msg=usbcan_send_msg;
 157         chipspecops->check_tx_stat=usbcan_check_tx_stat;
 158         chipspecops->wakeup_tx=usbcan_wakeup_tx;
 159         chipspecops->remote_request=usbcan_remote_request;
 160         chipspecops->enable_configuration=usbcan_enable_configuration;
 161         chipspecops->disable_configuration=usbcan_disable_configuration;
 162         chipspecops->attach_to_chip=usbcan_attach_to_chip;
 163         chipspecops->release_chip=usbcan_release_chip;
 164         chipspecops->set_btregs=usbcan_set_btregs;
 165         chipspecops->start_chip=usbcan_start_chip;
 166         chipspecops->stop_chip=usbcan_stop_chip;
 167         chipspecops->irq_handler=usbcan_irq_handler;
 168         chipspecops->irq_accept=NULL;
 169
 170         candev->chip[chipnr]->chip_base_addr=candev->io_addr;
 171         candev->chip[chipnr]->clock = 16000000;
 172         candev->chip[chipnr]->int_cpu_reg = iCPU_DSC;
 173         candev->chip[chipnr]->int_clk_reg = iCLK_SL1;
 174         candev->chip[chipnr]->int_bus_reg = iBUS_CBY;
 175         candev->chip[chipnr]->sja_cdr_reg = sjaCDR_CBP | sjaCDR_CLK_OFF;
 176         candev->chip[chipnr]->sja_ocr_reg = sjaOCR_MODE_NORMAL |
 177                                                                 sjaOCR_TX0_LH;
 178
 179         return 0;
 180 }
 181
 182 /**
 183  * usbcan_init_obj_data - Initialize message buffers
 184  * @chip: Pointer to chip specific structure
 185  * @objnr: Number of the message buffer
 186  *
 187  * The function usbcan_init_obj_data() is used to initialize the hardware
 188  * structure containing information about the different message objects on the
 189  * CAN chip. In case of the sja1000 there's only one message object but on the
 190  * i82527 chip there are 15.
 191  * The code below is for a i82527 chip and initializes the object base addresses
 192  * The entry @obj_base_addr represents the first memory address of the message
 193  * object. In case of the sja1000 @obj_base_addr is taken the same as the chips
 194  * base address.
 195  * Unless the hardware uses a segmented memory map, flags can be set zero.
 196  * Return Value: The function always returns zero
 197  * File: src/usbcan.c
 198  */
 199 int usbcan_init_obj_data(struct canchip_t *chip, int objnr)
 200 {
 201         chip->msgobj[objnr]->obj_base_addr=chip->chip_base_addr+(objnr+1)*0x10;
 202
 203         return 0;
 204 }
 205
 206 /**
 207  * usbcan_program_irq - program interrupts
 208  * @candev: Pointer to candevice/board structure
 209  *
 210  * The function usbcan_program_irq() is used for hardware that uses
 211  * programmable interrupts. If your hardware doesn't use programmable interrupts
 212  * you should not set the @candevices_t->flags entry to %CANDEV_PROGRAMMABLE_IRQ and
 213  * leave this function unedited. Again this function is hardware specific so
 214  * there's no example code.
 215  * Return value: The function returns zero on success or %-ENODEV on failure
 216  * File: src/usbcan.c
 217  */
 218 int usbcan_program_irq(struct candevice_t *candev)
 219 {
 220         return 0;
 221 }
 222
 223 /**
 224  * usbcan_write_register - Low level write register routine
 225  * @data: data to be written
 226  * @address: memory address to write to
 227  *
 228  * The function usbcan_write_register() is used to write to hardware registers
 229  * on the CAN chip. You should only have to edit this function if your hardware
 230  * uses some specific write process.
 231  * Return Value: The function does not return a value
 232  * File: src/usbcan.c
 233  */
 234 void usbcan_write_register(unsigned data, unsigned long address)
 235 {
 236         outb(data,address);
 237 }
 238
 239 /**
 240  * usbcan_read_register - Low level read register routine
 241  * @address: memory address to read from
 242  *
 243  * The function usbcan_read_register() is used to read from hardware registers
 244  * on the CAN chip. You should only have to edit this function if your hardware
 245  * uses some specific read process.
 246  * Return Value: The function returns the value stored in @address
 247  * File: src/usbcan.c
 248  */
 249 unsigned usbcan_read_register(unsigned long address)
 250 {
 251         return inb(address);
 252 }
 253
 254 /* !!! Don't change this function !!! */
 255 int usbcan_register(struct hwspecops_t *hwspecops)
 256 {
 257         hwspecops->request_io = usbcan_request_io;
 258         hwspecops->release_io = usbcan_release_io;
 259         hwspecops->reset = usbcan_reset;
 260         hwspecops->init_hw_data = usbcan_init_hw_data;
 261         hwspecops->init_chip_data = usbcan_init_chip_data;
 262         hwspecops->init_obj_data = usbcan_init_obj_data;
 263         hwspecops->write_register = usbcan_write_register;
 264         hwspecops->read_register = usbcan_read_register;
 265         hwspecops->program_irq = usbcan_program_irq;
 266         return 0;
 267 }
 268
 269 static const char *sja1000_ecc_errc_str[]={
 270         "bit error",
 271         "form error",
 272         "stuff error",
 273         "other type of error"
 274 };
 275
 276 static const char *sja1000_ecc_seg_str[]={
 277         "?0?",
 278         "?1?",
 279         "ID.28 to ID.21",
 280         "start of frame",
 281         "bit SRTR",
 282         "bit IDE",
 283         "ID.20 to ID.18",
 284         "ID.17 to ID.13",
 285         "CRC sequence",
 286         "reserved bit 0",
 287         "data field",
 288         "data length code",
 289         "bit RTR",
 290         "reserved bit 1",
 291         "ID.4 to ID.0",
 292         "ID.12 to ID.5",
 293         "?16?"
 294         "active error flag",
 295         "intermission",
 296         "tolerate dominant bits",
 297         "?20?",
 298         "?21?",
 299         "passive error flag",
 300         "error delimiter",
 301         "CRC delimiter",
 302         "acknowledge slot",
 303         "end of frame",
 304         "acknowledge delimiter",
 305         "overload flag",
 306         "?29?",
 307         "?30?",
 308         "?31?"
 309 };
 310
 311 #endif /*CONFIG_OC_LINCAN_DETAILED_ERRORS*/
 312
 313 static int sja1000_report_error_limit_counter;
 314
 315 static void sja1000_report_error(struct canchip_t *chip,
 316                                 unsigned sr, unsigned ir, unsigned ecc)
 317 {
 318         if(sja1000_report_error_limit_counter>=100)
 319                 return;
 320
 321         CANMSG("Error: status register: 0x%x irq_register: 0x%02x error: 0x%02x\n",
 322                 sr, ir, ecc);
 323
 324         sja1000_report_error_limit_counter+=10;
 325
 326         if(sja1000_report_error_limit_counter>=100){
 327                 sja1000_report_error_limit_counter+=10;
 328                 CANMSG("Error: too many errors, reporting disabled\n");
 329                 return;
 330         }
 331
 332 #ifdef CONFIG_OC_LINCAN_DETAILED_ERRORS
 333         CANMSG("SR: BS=%c  ES=%c  TS=%c  RS=%c  TCS=%c TBS=%c DOS=%c RBS=%c\n",
 334                 sr&sjaSR_BS?'1':'0',sr&sjaSR_ES?'1':'0',
 335                 sr&sjaSR_TS?'1':'0',sr&sjaSR_RS?'1':'0',
 336                 sr&sjaSR_TCS?'1':'0',sr&sjaSR_TBS?'1':'0',
 337                 sr&sjaSR_DOS?'1':'0',sr&sjaSR_RBS?'1':'0');
 338         CANMSG("IR: BEI=%c ALI=%c EPI=%c WUI=%c DOI=%c EI=%c  TI=%c  RI=%c\n",
 339                 sr&sjaIR_BEI?'1':'0',sr&sjaIR_ALI?'1':'0',
 340                 sr&sjaIR_EPI?'1':'0',sr&sjaIR_WUI?'1':'0',
 341                 sr&sjaIR_DOI?'1':'0',sr&sjaIR_EI?'1':'0',
 342                 sr&sjaIR_TI?'1':'0',sr&sjaIR_RI?'1':'0');
 343         if((sr&sjaIR_EI) || 1){
 344                 CANMSG("EI: %s %s %s\n",
 345                        sja1000_ecc_errc_str[(ecc&(sjaECC_ERCC1|sjaECC_ERCC0))/sjaECC_ERCC0],
 346                        ecc&sjaECC_DIR?"RX":"TX",
 347                        sja1000_ecc_seg_str[ecc&sjaECC_SEG_M]
 348                       );
 349         }
 350 #endif /*CONFIG_OC_LINCAN_DETAILED_ERRORS*/
 351 }
 352
 353
 354 /**
 355  * usbcan_enable_configuration - enable chip configuration mode
 356  * @chip: pointer to chip state structure
 357  */
 358 int usbcan_enable_configuration(struct canchip_t *chip)
 359 {
 360         int i=0;
 361         enum sja1000_PeliCAN_MOD flags;
 362
 363         can_disable_irq(chip->chip_irq);
 364
 365         flags=can_read_reg(chip,SJAMOD);
 366
 367         while ((!(flags & sjaMOD_RM)) && (i<=10)) {
 368                 can_write_reg(chip, sjaMOD_RM, SJAMOD);
 369 // TODO: configurable sjaMOD_AFM (32/16 bit acceptance filter)
 370 // config sjaMOD_LOM (listen only)
 371                 udelay(100);
 372                 i++;
 373                 flags=can_read_reg(chip, SJAMOD);
 374         }
 375         if (i>=10) {
 376                 CANMSG("Reset error\n");
 377                 can_enable_irq(chip->chip_irq);
 378                 return -ENODEV;
 379         }
 380
 381         return 0;
 382 }
 383
 384 /**
 385  * usbcan_disable_configuration - disable chip configuration mode
 386  * @chip: pointer to chip state structure
 387  */
 388 int usbcan_disable_configuration(struct canchip_t *chip)
 389 {
 390         int i=0;
 391         enum sja1000_PeliCAN_MOD flags;
 392
 393         flags=can_read_reg(chip,SJAMOD);
 394
 395         while ( (flags & sjaMOD_RM) && (i<=50) ) {
 396 // could be as long as 11*128 bit times after buss-off
 397                 can_write_reg(chip, 0, SJAMOD);
 398 // TODO: configurable sjaMOD_AFM (32/16 bit acceptance filter)
 399 // config sjaMOD_LOM (listen only)
 400                 udelay(100);
 401                 i++;
 402                 flags=can_read_reg(chip, SJAMOD);
 403         }
 404         if (i>=10) {
 405                 CANMSG("Error leaving reset status\n");
 406                 return -ENODEV;
 407         }
 408
 409         can_enable_irq(chip->chip_irq);
 410
 411         return 0;
 412 }
 413
 414 /**
 415  * usbcan_chip_config: - can chip configuration
 416  * @chip: pointer to chip state structure
 417  *
 418  * This function configures chip and prepares it for message
 419  * transmission and reception. The function resets chip,
 420  * resets mask for acceptance of all messages by call to
 421  * usbcan_extended_mask() function and then
 422  * computes and sets baudrate with use of function usbcan_baud_rate().
 423  * Return Value: negative value reports error.
 424  * File: src/usbcan.c
 425  */
 426 int usbcan_chip_config(struct canchip_t *chip)
 427 {
 428         int i;
 429         unsigned char n, r;
 430
 431         if (usbcan_enable_configuration(chip))
 432                 return -ENODEV;
 433
 434         /* Set mode, clock out, comparator */
 435         can_write_reg(chip,sjaCDR_PELICAN|chip->sja_cdr_reg,SJACDR);
 436
 437         /* Ensure, that interrupts are disabled even on the chip level now */
 438         can_write_reg(chip, sjaDISABLE_INTERRUPTS, SJAIER);
 439
 440         /* Set driver output configuration */
 441         can_write_reg(chip,chip->sja_ocr_reg,SJAOCR);
 442
 443         /* Simple check for chip presence */
 444         for (i=0, n=0x5a; i<8; i++, n+=0xf) {
 445                 can_write_reg(chip,n,SJAACR0+i);
 446         }
 447         for (i=0, n=0x5a; i<8; i++, n+=0xf) {
 448                 r = n^can_read_reg(chip,SJAACR0+i);
 449                 if (r) {
 450                         CANMSG("usbcan_chip_config: chip connection broken,"
 451                                 " readback differ 0x%02x\n", r);
 452                         return -ENODEV;
 453                 }
 454         }
 455
 456
 457         if (usbcan_extended_mask(chip,0x00000000, 0xffffffff))
 458                 return -ENODEV;
 459
 460         if (!chip->baudrate)
 461                 chip->baudrate=1000000;
 462         if (usbcan_baud_rate(chip,chip->baudrate,chip->clock,0,75,0))
 463                 return -ENODEV;
 464
 465         /* Enable hardware interrupts */
 466         can_write_reg(chip, sjaENABLE_INTERRUPTS, SJAIER);
 467
 468         usbcan_disable_configuration(chip);
 469
 470         return 0;
 471 }
 472
 473 /**
 474  * usbcan_extended_mask: - setup of extended mask for message filtering
 475  * @chip: pointer to chip state structure
 476  * @code: can message acceptance code
 477  * @mask: can message acceptance mask
 478  *
 479  * Return Value: negative value reports error.
 480  * File: src/usbcan.c
 481  */
 482 int usbcan_extended_mask(struct canchip_t *chip, unsigned long code, unsigned  long mask)
 483 {
 484         int i;
 485
 486         if (usbcan_enable_configuration(chip))
 487                 return -ENODEV;
 488
 489 // LSB to +3, MSB to +0
 490         for(i=SJA_PeliCAN_AC_LEN; --i>=0;) {
 491                 can_write_reg(chip,code&0xff,SJAACR0+i);
 492                 can_write_reg(chip,mask&0xff,SJAAMR0+i);
 493                 code >>= 8;
 494                 mask >>= 8;
 495         }
 496
 497         DEBUGMSG("Setting acceptance code to 0x%lx\n",(unsigned long)code);
 498         DEBUGMSG("Setting acceptance mask to 0x%lx\n",(unsigned long)mask);
 499
 500         usbcan_disable_configuration(chip);
 501
 502         return 0;
 503 }
 504
 505 /**
 506  * usbcan_baud_rate: - set communication parameters.
 507  * @chip: pointer to chip state structure
 508  * @rate: baud rate in Hz
 509  * @clock: frequency of sja1000 clock in Hz (ISA osc is 14318000)
 510  * @sjw: synchronization jump width (0-3) prescaled clock cycles
 511  * @sampl_pt: sample point in % (0-100) sets (TSEG1+1)/(TSEG1+TSEG2+2) ratio
 512  * @flags: fields %BTR1_SAM, %OCMODE, %OCPOL, %OCTP, %OCTN, %CLK_OFF, %CBP
 513  *
 514  * Return Value: negative value reports error.
 515  * File: src/usbcan.c
 516  */
 517 int usbcan_baud_rate(struct canchip_t *chip, int rate, int clock, int sjw,
 518                                                         int sampl_pt, int flags)
 519 {
 520         int best_error = 1000000000, error;
 521         int best_tseg=0, best_brp=0, best_rate=0, brp=0;
 522         int tseg=0, tseg1=0, tseg2=0;
 523
 524         if (usbcan_enable_configuration(chip))
 525                 return -ENODEV;
 526
 527         clock /=2;
 528
 529         /* tseg even = round down, odd = round up */
 530         for (tseg=(0+0+2)*2; tseg<=(sjaMAX_TSEG2+sjaMAX_TSEG1+2)*2+1; tseg++) {
 531                 brp = clock/((1+tseg/2)*rate)+tseg%2;
 532                 if (brp == 0 || brp > 64)
 533                         continue;
 534                 error = rate - clock/(brp*(1+tseg/2));
 535                 if (error < 0)
 536                         error = -error;
 537                 if (error <= best_error) {
 538                         best_error = error;
 539                         best_tseg = tseg/2;
 540                         best_brp = brp-1;
 541                         best_rate = clock/(brp*(1+tseg/2));
 542                 }
 543         }
 544         if (best_error && (rate/best_error < 10)) {
 545                 CANMSG("baud rate %d is not possible with %d Hz clock\n",
 546                                                                 rate, 2*clock);
 547                 CANMSG("%d bps. brp=%d, best_tseg=%d, tseg1=%d, tseg2=%d\n",
 548                                 best_rate, best_brp, best_tseg, tseg1, tseg2);
 549                 return -EINVAL;
 550         }
 551         tseg2 = best_tseg-(sampl_pt*(best_tseg+1))/100;
 552         if (tseg2 < 0)
 553                 tseg2 = 0;
 554         if (tseg2 > sjaMAX_TSEG2)
 555                 tseg2 = sjaMAX_TSEG2;
 556         tseg1 = best_tseg-tseg2-2;
 557         if (tseg1>sjaMAX_TSEG1) {
 558                 tseg1 = sjaMAX_TSEG1;
 559                 tseg2 = best_tseg-tseg1-2;
 560         }
 561
 562         DEBUGMSG("Setting %d bps.\n", best_rate);
 563         DEBUGMSG("brp=%d, best_tseg=%d, tseg1=%d, tseg2=%d, sampl_pt=%d\n",
 564                                         best_brp, best_tseg, tseg1, tseg2,
 565                                         (100*(best_tseg-tseg2)/(best_tseg+1)));
 566
 567
 568         can_write_reg(chip, sjw<<6 | best_brp, SJABTR0);
 569         can_write_reg(chip, ((flags & BTR1_SAM) != 0)<<7 | (tseg2<<4)
 570                                         | tseg1, SJABTR1);
 571
 572         usbcan_disable_configuration(chip);
 573
 574         return 0;
 575 }
 576
 577 /**
 578  * usbcan_read: - reads and distributes one or more received messages
 579  * @chip: pointer to chip state structure
 580  * @obj: pinter to CAN message queue information
 581  *
 582  * File: src/usbcan.c
 583  */
 584 void usbcan_read(struct canchip_t *chip, struct msgobj_t *obj) {
 585         int i, flags, len, datastart;
 586         do {
 587                 flags = can_read_reg(chip,SJAFRM);
 588                 if(flags&sjaFRM_FF) {
 589                         obj->rx_msg.id =
 590                                 (can_read_reg(chip,SJAID0)<<21) +
 591                                 (can_read_reg(chip,SJAID1)<<13) +
 592                                 (can_read_reg(chip,SJAID2)<<5) +
 593                                 (can_read_reg(chip,SJAID3)>>3);
 594                         datastart = SJADATE;
 595                 } else {
 596                         obj->rx_msg.id =
 597                                 (can_read_reg(chip,SJAID0)<<3) +
 598                                 (can_read_reg(chip,SJAID1)>>5);
 599                         datastart = SJADATS;
 600                 }
 601                 obj->rx_msg.flags =
 602                         ((flags & sjaFRM_RTR) ? MSG_RTR : 0) |
 603                         ((flags & sjaFRM_FF) ? MSG_EXT : 0);
 604                 len = flags & sjaFRM_DLC_M;
 605                 obj->rx_msg.length = len;
 606                 if(len > CAN_MSG_LENGTH) len = CAN_MSG_LENGTH;
 607                 for(i=0; i< len; i++) {
 608                         obj->rx_msg.data[i]=can_read_reg(chip,datastart+i);
 609                 }
 610
 611                 /* fill CAN message timestamp */
 612                 can_filltimestamp(&obj->rx_msg.timestamp);
 613
 614                 canque_filter_msg2edges(obj->qends, &obj->rx_msg);
 615
 616                 can_write_reg(chip, sjaCMR_RRB, SJACMR);
 617
 618         } while (can_read_reg(chip, SJASR) & sjaSR_RBS);
 619 }
 620
 621 /**
 622  * usbcan_pre_read_config: - prepares message object for message reception
 623  * @chip: pointer to chip state structure
 624  * @obj: pointer to message object state structure
 625  *
 626  * Return Value: negative value reports error.
 627  *      Positive value indicates immediate reception of message.
 628  * File: src/usbcan.c
 629  */
 630 int usbcan_pre_read_config(struct canchip_t *chip, struct msgobj_t *obj)
 631 {
 632         int status;
 633         status=can_read_reg(chip,SJASR);
 634
 635         if(status  & sjaSR_BS) {
 636                 /* Try to recover from error condition */
 637                 DEBUGMSG("usbcan_pre_read_config bus-off recover 0x%x\n",status);
 638                 usbcan_enable_configuration(chip);
 639                 can_write_reg(chip, 0, SJARXERR);
 640                 can_write_reg(chip, 0, SJATXERR1);
 641                 can_read_reg(chip, SJAECC);
 642                 usbcan_disable_configuration(chip);
 643         }
 644
 645         if (!(status&sjaSR_RBS)) {
 646                 return 0;
 647         }
 648
 649         can_write_reg(chip, sjaDISABLE_INTERRUPTS, SJAIER); //disable interrupts for a moment
 650         usbcan_read(chip, obj);
 651         can_write_reg(chip, sjaENABLE_INTERRUPTS, SJAIER); //enable interrupts
 652         return 1;
 653 }
 654
 655 #define MAX_TRANSMIT_WAIT_LOOPS 10
 656 /**
 657  * usbcan_pre_write_config: - prepares message object for message transmission
 658  * @chip: pointer to chip state structure
 659  * @obj: pointer to message object state structure
 660  * @msg: pointer to CAN message
 661  *
 662  * This function prepares selected message object for future initiation
 663  * of message transmission by usbcan_send_msg() function.
 664  * The CAN message data and message ID are transfered from @msg slot
 665  * into chip buffer in this function.
 666  * Return Value: negative value reports error.
 667  * File: src/usbcan.c
 668  */
 669 int usbcan_pre_write_config(struct canchip_t *chip, struct msgobj_t *obj,
 670                                                         struct canmsg_t *msg)
 671 {
 672         int i=0;
 673         unsigned int id;
 674         int status;
 675         int len;
 676
 677         /* Wait until Transmit Buffer Status is released */
 678         while ( !((status=can_read_reg(chip, SJASR)) & sjaSR_TBS) &&
 679                                                 i++<MAX_TRANSMIT_WAIT_LOOPS) {
 680                 udelay(i);
 681         }
 682
 683         if(status & sjaSR_BS) {
 684                 /* Try to recover from error condition */
 685                 DEBUGMSG("usbcan_pre_write_config bus-off recover 0x%x\n",status);
 686                 usbcan_enable_configuration(chip);
 687                 can_write_reg(chip, 0, SJARXERR);
 688                 can_write_reg(chip, 0, SJATXERR1);
 689                 can_read_reg(chip, SJAECC);
 690                 usbcan_disable_configuration(chip);
 691         }
 692         if (!(can_read_reg(chip, SJASR) & sjaSR_TBS)) {
 693                 CANMSG("Transmit timed out, cancelling\n");
 694 // here we should check if there is no write/select waiting for this
 695 // transmit. If so, set error ret and wake up.
 696 // CHECKME: if we do not disable sjaIER_TIE (TX IRQ) here we get interrupt
 697 // immediately
 698                 can_write_reg(chip, sjaCMR_AT, SJACMR);
 699                 i=0;
 700                 while ( !(can_read_reg(chip, SJASR) & sjaSR_TBS) &&
 701                                                 i++<MAX_TRANSMIT_WAIT_LOOPS) {
 702                         udelay(i);
 703                 }
 704                 if (!(can_read_reg(chip, SJASR) & sjaSR_TBS)) {
 705                         CANMSG("Could not cancel, please reset\n");
 706                         return -EIO;
 707                 }
 708         }
 709         len = msg->length;
 710         if(len > CAN_MSG_LENGTH) len = CAN_MSG_LENGTH;
 711         /* len &= sjaFRM_DLC_M; ensured by above condition already */
 712         can_write_reg(chip, ((msg->flags&MSG_EXT)?sjaFRM_FF:0) |
 713                 ((msg->flags & MSG_RTR) ? sjaFRM_RTR : 0) | len, SJAFRM);
 714         if(msg->flags&MSG_EXT) {
 715                 id=msg->id<<3;
 716                 can_write_reg(chip, id & 0xff, SJAID3);
 717                 id >>= 8;
 718                 can_write_reg(chip, id & 0xff, SJAID2);
 719                 id >>= 8;
 720                 can_write_reg(chip, id & 0xff, SJAID1);
 721                 id >>= 8;
 722                 can_write_reg(chip, id, SJAID0);
 723                 for(i=0; i < len; i++) {
 724                         can_write_reg(chip, msg->data[i], SJADATE+i);
 725                 }
 726         } else {
 727                 id=msg->id<<5;
 728                 can_write_reg(chip, (id >> 8) & 0xff, SJAID0);
 729                 can_write_reg(chip, id & 0xff, SJAID1);
 730                 for(i=0; i < len; i++) {
 731                         can_write_reg(chip, msg->data[i], SJADATS+i);
 732                 }
 733         }
 734         return 0;
 735 }
 736
 737 /**
 738  * usbcan_send_msg: - initiate message transmission
 739  * @chip: pointer to chip state structure
 740  * @obj: pointer to message object state structure
 741  * @msg: pointer to CAN message
 742  *
 743  * This function is called after usbcan_pre_write_config() function,
 744  * which prepares data in chip buffer.
 745  * Return Value: negative value reports error.
 746  * File: src/usbcan.c
 747  */
 748 int usbcan_send_msg(struct canchip_t *chip, struct msgobj_t *obj,
 749                                                         struct canmsg_t *msg)
 750 {
 751         can_write_reg(chip, sjaCMR_TR, SJACMR);
 752
 753         return 0;
 754 }
 755
 756 /**
 757  * usbcan_check_tx_stat: - checks state of transmission engine
 758  * @chip: pointer to chip state structure
 759  *
 760  * Return Value: negative value reports error.
 761  *      Positive return value indicates transmission under way status.
 762  *      Zero value indicates finishing of all issued transmission requests.
 763  * File: src/usbcan.c
 764  */
 765 int usbcan_check_tx_stat(struct canchip_t *chip)
 766 {
 767         if (can_read_reg(chip,SJASR) & sjaSR_TCS)
 768                 return 0;
 769         else
 770                 return 1;
 771 }
 772
 773 /**
 774  * usbcan_set_btregs: -  configures bitrate registers
 775  * @chip: pointer to chip state structure
 776  * @btr0: bitrate register 0
 777  * @btr1: bitrate register 1
 778  *
 779  * Return Value: negative value reports error.
 780  * File: src/usbcan.c
 781  */
 782 int usbcan_set_btregs(struct canchip_t *chip, unsigned short btr0,
 783                                                         unsigned short btr1)
 784 {
 785         if (usbcan_enable_configuration(chip))
 786                 return -ENODEV;
 787
 788         can_write_reg(chip, btr0, SJABTR0);
 789         can_write_reg(chip, btr1, SJABTR1);
 790
 791         usbcan_disable_configuration(chip);
 792
 793         return 0;
 794 }
 795
 796 /**
 797  * usbcan_start_chip: -  starts chip message processing
 798  * @chip: pointer to chip state structure
 799  *
 800  * Return Value: negative value reports error.
 801  * File: src/usbcan.c
 802  */
 803 int usbcan_start_chip(struct canchip_t *chip)
 804 {
 805         enum sja1000_PeliCAN_MOD flags;
 806
 807         flags = can_read_reg(chip, SJAMOD) & (sjaMOD_LOM|sjaMOD_STM|sjaMOD_AFM|sjaMOD_SM);
 808         can_write_reg(chip, flags, SJAMOD);
 809
 810         sja1000_report_error_limit_counter=0;
 811
 812         return 0;
 813 }
 814
 815 /**
 816  * usbcan_stop_chip: -  stops chip message processing
 817  * @chip: pointer to chip state structure
 818  *
 819  * Return Value: negative value reports error.
 820  * File: src/usbcan.c
 821  */
 822 int usbcan_stop_chip(struct canchip_t *chip)
 823 {
 824         enum sja1000_PeliCAN_MOD flags;
 825
 826         flags = can_read_reg(chip, SJAMOD) & (sjaMOD_LOM|sjaMOD_STM|sjaMOD_AFM|sjaMOD_SM);
 827         can_write_reg(chip, flags|sjaMOD_RM, SJAMOD);
 828
 829         return 0;
 830 }
 831
 832 /**
 833  * usbcan_attach_to_chip: - attaches to the chip, setups registers and state
 834  * @chip: pointer to chip state structure
 835  *
 836  * Return Value: negative value reports error.
 837  * File: src/usbcan.c
 838  */
 839 int usbcan_attach_to_chip(struct canchip_t *chip)
 840 {
 841         return 0;
 842 }
 843
 844 /**
 845  * usbcan_release_chip: - called before chip structure removal if %CHIP_ATTACHED is set
 846  * @chip: pointer to chip state structure
 847  *
 848  * Return Value: negative value reports error.
 849  * File: src/usbcan.c
 850  */
 851 int usbcan_release_chip(struct canchip_t *chip)
 852 {
 853         usbcan_stop_chip(chip);
 854         can_write_reg(chip, sjaDISABLE_INTERRUPTS, SJAIER);
 855
 856         return 0;
 857 }
 858
 859 /**
 860  * usbcan_remote_request: - configures message object and asks for RTR message
 861  * @chip: pointer to chip state structure
 862  * @obj: pointer to message object structure
 863  *
 864  * Return Value: negative value reports error.
 865  * File: src/usbcan.c
 866  */
 867 int usbcan_remote_request(struct canchip_t *chip, struct msgobj_t *obj)
 868 {
 869         CANMSG("usbcan_remote_request not implemented\n");
 870         return -ENOSYS;
 871 }
 872
 873 /**
 874  * usbcan_standard_mask: - setup of mask for message filtering
 875  * @chip: pointer to chip state structure
 876  * @code: can message acceptance code
 877  * @mask: can message acceptance mask
 878  *
 879  * Return Value: negative value reports error.
 880  * File: src/usbcan.c
 881  */
 882 int usbcan_standard_mask(struct canchip_t *chip, unsigned short code,
 883                 unsigned short mask)
 884 {
 885         CANMSG("usbcan_standard_mask not implemented\n");
 886         return -ENOSYS;
 887 }
 888
 889 /**
 890  * usbcan_clear_objects: - clears state of all message object residing in chip
 891  * @chip: pointer to chip state structure
 892  *
 893  * Return Value: negative value reports error.
 894  * File: src/usbcan.c
 895  */
 896 int usbcan_clear_objects(struct canchip_t *chip)
 897 {
 898         CANMSG("usbcan_clear_objects not implemented\n");
 899         return -ENOSYS;
 900 }
 901
 902 /**
 903  * usbcan_config_irqs: - tunes chip hardware interrupt delivery
 904  * @chip: pointer to chip state structure
 905  * @irqs: requested chip IRQ configuration
 906  *
 907  * Return Value: negative value reports error.
 908  * File: src/usbcan.c
 909  */
 910 int usbcan_config_irqs(struct canchip_t *chip, short irqs)
 911 {
 912         CANMSG("usbcan_config_irqs not implemented\n");
 913         return -ENOSYS;
 914 }
 915
 916 /**
 917  * usbcan_irq_write_handler: - part of ISR code responsible for transmit events
 918  * @chip: pointer to chip state structure
 919  * @obj: pointer to attached queue description
 920  *
 921  * The main purpose of this function is to read message from attached queues
 922  * and transfer message contents into CAN controller chip.
 923  * This subroutine is called by
 924  * usbcan_irq_write_handler() for transmit events.
 925  * File: src/usbcan.c
 926  */
 927 void usbcan_irq_write_handler(struct canchip_t *chip, struct msgobj_t *obj)
 928 {
 929         int cmd;
 930
 931         if(obj->tx_slot){
 932                 /* Do local transmitted message distribution if enabled */
 933                 if (processlocal){
 934                         /* fill CAN message timestamp */
 935                         can_filltimestamp(&obj->tx_slot->msg.timestamp);
 936
 937                         obj->tx_slot->msg.flags |= MSG_LOCAL;
 938                         canque_filter_msg2edges(obj->qends, &obj->tx_slot->msg);
 939                 }
 940                 /* Free transmitted slot */
 941                 canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
 942                 obj->tx_slot=NULL;
 943         }
 944
 945         can_msgobj_clear_fl(obj,TX_PENDING);
 946         cmd=canque_test_outslot(obj->qends, &obj->tx_qedge, &obj->tx_slot);
 947         if(cmd<0)
 948                 return;
 949         can_msgobj_set_fl(obj,TX_PENDING);
 950
 951         if (chip->chipspecops->pre_write_config(chip, obj, &obj->tx_slot->msg)) {
 952                 obj->ret = -1;
 953                 canque_notify_inends(obj->tx_qedge, CANQUEUE_NOTIFY_ERRTX_PREP);
 954                 canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
 955                 obj->tx_slot=NULL;
 956                 return;
 957         }
 958         if (chip->chipspecops->send_msg(chip, obj, &obj->tx_slot->msg)) {
 959                 obj->ret = -1;
 960                 canque_notify_inends(obj->tx_qedge, CANQUEUE_NOTIFY_ERRTX_SEND);
 961                 canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
 962                 obj->tx_slot=NULL;
 963                 return;
 964         }
 965
 966 }
 967
 968 #define MAX_RETR 10
 969
 970 /**
 971  * usbcan_irq_handler: - interrupt service routine
 972  * @irq: interrupt vector number, this value is system specific
 973  * @chip: pointer to chip state structure
 974  *
 975  * Interrupt handler is activated when state of CAN controller chip changes,
 976  * there is message to be read or there is more space for new messages or
 977  * error occurs. The receive events results in reading of the message from
 978  * CAN controller chip and distribution of message through attached
 979  * message queues.
 980  * File: src/usbcan.c
 981  */
 982 int usbcan_irq_handler(int irq, struct canchip_t *chip)
 983 {
 984         int irq_register, status, error_code;
 985         struct msgobj_t *obj=chip->msgobj[0];
 986         int loop_cnt=CHIP_MAX_IRQLOOP;
 987
 988         irq_register=can_read_reg(chip,SJAIR);
 989 //      DEBUGMSG("sja1000_irq_handler: SJAIR:%02x\n",irq_register);
 990 //      DEBUGMSG("sja1000_irq_handler: SJASR:%02x\n",
 991 //                                      can_read_reg(chip,SJASR));
 992
 993         if ((irq_register & (sjaIR_BEI|sjaIR_EPI|sjaIR_DOI|sjaIR_EI|sjaIR_TI|sjaIR_RI)) == 0)
 994                 return CANCHIP_IRQ_NONE;
 995
 996         if(!(chip->flags&CHIP_CONFIGURED)) {
 997                 CANMSG("usbcan_irq_handler: called for non-configured device, irq_register 0x%02x\n", irq_register);
 998                 return CANCHIP_IRQ_NONE;
 999         }
1000
1001         status=can_read_reg(chip,SJASR);
1002
1003         do {
1004
1005                 if(!loop_cnt--) {
1006                         CANMSG("usbcan_irq_handler IRQ %d stuck\n",irq);
1007                         return CANCHIP_IRQ_STUCK;
1008                 }
1009
1010                 /* (irq_register & sjaIR_RI) */
1011                 /*      old variant using SJAIR, collides with intended use with irq_accept */
1012                 if (status & sjaSR_RBS) {
1013                         DEBUGMSG("sja1000_irq_handler: RI or RBS\n");
1014                         usbcan_read(chip,obj);
1015                         obj->ret = 0;
1016                 }
1017
1018                 /* (irq_register & sjaIR_TI) */
1019                 /*      old variant using SJAIR, collides with intended use with irq_accept */
1020                 if (((status & sjaSR_TBS) && can_msgobj_test_fl(obj,TX_PENDING))||
1021                     (can_msgobj_test_fl(obj,TX_REQUEST))) {
1022                         DEBUGMSG("sja1000_irq_handler: TI or TX_PENDING and TBS\n");
1023                         obj->ret = 0;
1024                         can_msgobj_set_fl(obj,TX_REQUEST);
1025                         while(!can_msgobj_test_and_set_fl(obj,TX_LOCK)){
1026                                 can_msgobj_clear_fl(obj,TX_REQUEST);
1027
1028                                 if (can_read_reg(chip, SJASR) & sjaSR_TBS)
1029                                         usbcan_irq_write_handler(chip, obj);
1030
1031                                 can_msgobj_clear_fl(obj,TX_LOCK);
1032                                 if(!can_msgobj_test_fl(obj,TX_REQUEST)) break;
1033                                 DEBUGMSG("TX looping in sja1000_irq_handler\n");
1034                         }
1035                 }
1036                 if ((irq_register & (sjaIR_EI|sjaIR_BEI|sjaIR_EPI|sjaIR_DOI)) != 0) {
1037                         // Some error happened
1038                         error_code=can_read_reg(chip,SJAECC);
1039                         sja1000_report_error(chip, status, irq_register, error_code);
1040 // FIXME: chip should be brought to usable state. Transmission cancelled if in progress.
1041 // Reset flag set to 0 if chip is already off the bus. Full state report
1042                         obj->ret=-1;
1043
1044                         if(error_code == 0xd9) {
1045                                 obj->ret= -ENXIO;
1046                                 /* no such device or address - no ACK received */
1047                         }
1048                         if(obj->tx_retry_cnt++>MAX_RETR) {
1049                                 can_write_reg(chip, sjaCMR_AT, SJACMR); // cancel any transmition
1050                                 obj->tx_retry_cnt = 0;
1051                         }
1052                         if(status&sjaSR_BS) {
1053                                 CANMSG("bus-off, resetting usbcan\n");
1054                                 can_write_reg(chip, 0, SJAMOD);
1055                         }
1056
1057                         if(obj->tx_slot){
1058                                 canque_notify_inends(obj->tx_qedge, CANQUEUE_NOTIFY_ERRTX_BUS);
1059                                 /*canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
1060                                 obj->tx_slot=NULL;*/
1061                         }
1062
1063                 } else {
1064                         if(sja1000_report_error_limit_counter)
1065                                 sja1000_report_error_limit_counter--;
1066                         obj->tx_retry_cnt=0;
1067                 }
1068
1069                 irq_register=can_read_reg(chip,SJAIR);
1070
1071                 status=can_read_reg(chip,SJASR);
1072
1073                 if(((status & sjaSR_TBS) && can_msgobj_test_fl(obj,TX_PENDING)) ||
1074                    (irq_register & sjaIR_TI))
1075                          can_msgobj_set_fl(obj,TX_REQUEST);
1076
1077         } while((irq_register & (sjaIR_BEI|sjaIR_EPI|sjaIR_DOI|sjaIR_EI|sjaIR_RI)) ||
1078                 (can_msgobj_test_fl(obj,TX_REQUEST) && !can_msgobj_test_fl(obj,TX_LOCK)) ||
1079                 (status & sjaSR_RBS));
1080
1081         return CANCHIP_IRQ_HANDLED;
1082 }
1083
1084 /**
1085  * usbcan_wakeup_tx: - wakeups TX processing
1086  * @chip: pointer to chip state structure
1087  * @obj: pointer to message object structure
1088  *
1089  * Function is responsible for initiating message transmition.
1090  * It is responsible for clearing of object TX_REQUEST flag
1091  *
1092  * Return Value: negative value reports error.
1093  * File: src/usbcan.c
1094  */
1095 int usbcan_wakeup_tx(struct canchip_t *chip, struct msgobj_t *obj)
1096 {
1097
1098         can_preempt_disable();
1099
1100         can_msgobj_set_fl(obj,TX_PENDING);
1101         can_msgobj_set_fl(obj,TX_REQUEST);
1102         while(!can_msgobj_test_and_set_fl(obj,TX_LOCK)){
1103                 can_msgobj_clear_fl(obj,TX_REQUEST);
1104
1105                 if (can_read_reg(chip, SJASR) & sjaSR_TBS){
1106                         obj->tx_retry_cnt=0;
1107                         usbcan_irq_write_handler(chip, obj);
1108                 }
1109
1110                 can_msgobj_clear_fl(obj,TX_LOCK);
1111                 if(!can_msgobj_test_fl(obj,TX_REQUEST)) break;
1112                 DEBUGMSG("TX looping in usbcan_wakeup_tx\n");
1113         }
1114
1115         can_preempt_enable();
1116         return 0;
1117 }
1118
1119 int usbcan_register(struct chipspecops_t *chipspecops)
1120 {
1121         return 0;
1122 }
1123
1124 /**
1125  * usbcan_fill_chipspecops - fills chip specific operations
1126  * @chip: pointer to chip representation structure
1127  *
1128  * The function fills chip specific operations for sja1000 (PeliCAN) chip.
1129  *
1130  * Return Value: returns negative number in the case of fail
1131  */
1132 int usbcan_fill_chipspecops(struct canchip_t *chip)
1133 {
1134         return 0;
1135 }