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/devcommon.h"
  12 #include "../include/setup.h"
  13 #include "../include/usbcan.h"
  14
  15 static int usbcan_probe(struct usb_interface *interface, const struct usb_device_id *id);
  16 static void usbcan_disconnect(struct usb_interface *interface);
  17
  18 volatile int usbcan_chip_count=0;
  19
  20 /* table of devices that work with this driver */
  21 static struct usb_device_id usbcan_table [] = {
  22         { USB_DEVICE(USBCAN_VENDOR_ID, USBCAN_PRODUCT_ID) },
  23         { }                                     /* Terminating entry */
  24 };
  25 MODULE_DEVICE_TABLE(usb, usbcan_table);
  26
  27 static struct usb_driver usbcan_driver = {
  28         .name =         "usbcan",
  29         .id_table = usbcan_table,
  30         .probe =        usbcan_probe,
  31         .disconnect =   usbcan_disconnect,
  32 };
  33
  34 /**
  35  * usbcan_request_io: - reserve io or memory range for can board
  36  * @candev: pointer to candevice/board which asks for io. Field @io_addr
  37  *      of @candev is used in most cases to define start of the range
  38  *
  39  * The function usbcan_request_io() is used to reserve the io-memory. If your
  40  * hardware uses a dedicated memory range as hardware control registers you
  41  * will have to add the code to reserve this memory as well.
  42  * %IO_RANGE is the io-memory range that gets reserved, please adjust according
  43  * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
  44  * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
  45  * Return Value: The function returns zero on success or %-ENODEV on failure
  46  * File: src/usbcan.c
  47  */
  48 int usbcan_request_io(struct candevice_t *candev)
  49 {
  50         struct usbcan_devs *usbdevs = (struct usbcan_devs *)candev->sysdevptr.anydev;
  51
  52         if (!usbdevs){
  53                 CANMSG("USBCAN_REQUEST_IO: Cannot register usbcan while usb device is not present.\n");
  54                 CANMSG("USBCAN_REQUEST_IO: Usbcan registers automatically on device insertion.\n");
  55                 return -ENODEV;
  56         }
  57
  58         return 0;
  59 }
  60
  61 /**
  62  * usbcan_release_io - free reserved io memory range
  63  * @candev: pointer to candevice/board which releases io
  64  *
  65  * The function usbcan_release_io() is used to free reserved io-memory.
  66  * In case you have reserved more io memory, don't forget to free it here.
  67  * IO_RANGE is the io-memory range that gets released, please adjust according
  68  * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
  69  * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
  70  * Return Value: The function always returns zero
  71  * File: src/usbcan.c
  72  */
  73 int usbcan_release_io(struct candevice_t *candev)
  74 {
  75         return 0;
  76 }
  77
  78 /**
  79  * usbcan_reset - hardware reset routine
  80  * @candev: Pointer to candevice/board structure
  81  *
  82  * The function usbcan_reset() is used to give a hardware reset. This is
  83  * rather hardware specific so I haven't included example code. Don't forget to
  84  * check the reset status of the chip before returning.
  85  * Return Value: The function returns zero on success or %-ENODEV on failure
  86  * File: src/usbcan.c
  87  */
  88 int usbcan_reset(struct candevice_t *candev)
  89 {
  90         return 0;
  91 }
  92
  93 /**
  94  * usbcan_init_hw_data - Initialize hardware cards
  95  * @candev: Pointer to candevice/board structure
  96  *
  97  * The function usbcan_init_hw_data() is used to initialize the hardware
  98  * structure containing information about the installed CAN-board.
  99  * %RESET_ADDR represents the io-address of the hardware reset register.
 100  * %NR_82527 represents the number of Intel 82527 chips on the board.
 101  * %NR_SJA1000 represents the number of Philips sja1000 chips on the board.
 102  * The flags entry can currently only be %CANDEV_PROGRAMMABLE_IRQ to indicate that
 103  * the hardware uses programmable interrupts.
 104  * Return Value: The function always returns zero
 105  * File: src/usbcan.c
 106  */
 107 int usbcan_init_hw_data(struct candevice_t *candev)
 108 {
 109         candev->res_addr=RESET_ADDR;
 110         candev->nr_82527_chips=0;
 111         candev->nr_sja1000_chips=0;
 112         candev->nr_all_chips=usbcan_chip_count;
 113         candev->flags |= CANDEV_PROGRAMMABLE_IRQ*0;
 114
 115         return 0;
 116 }
 117
 118 /**
 119  * usbcan_init_obj_data - Initialize message buffers
 120  * @chip: Pointer to chip specific structure
 121  * @objnr: Number of the message buffer
 122  *
 123  * The function usbcan_init_obj_data() is used to initialize the hardware
 124  * structure containing information about the different message objects on the
 125  * CAN chip. In case of the sja1000 there's only one message object but on the
 126  * i82527 chip there are 15.
 127  * The code below is for a i82527 chip and initializes the object base addresses
 128  * The entry @obj_base_addr represents the first memory address of the message
 129  * object. In case of the sja1000 @obj_base_addr is taken the same as the chips
 130  * base address.
 131  * Unless the hardware uses a segmented memory map, flags can be set zero.
 132  * Return Value: The function always returns zero
 133  * File: src/usbcan.c
 134  */
 135 int usbcan_init_obj_data(struct canchip_t *chip, int objnr)
 136 {
 137         chip->msgobj[objnr]->obj_base_addr=0;
 138
 139         return 0;
 140 }
 141
 142 /**
 143  * usbcan_program_irq - program interrupts
 144  * @candev: Pointer to candevice/board structure
 145  *
 146  * The function usbcan_program_irq() is used for hardware that uses
 147  * programmable interrupts. If your hardware doesn't use programmable interrupts
 148  * you should not set the @candevices_t->flags entry to %CANDEV_PROGRAMMABLE_IRQ and
 149  * leave this function unedited. Again this function is hardware specific so
 150  * there's no example code.
 151  * Return value: The function returns zero on success or %-ENODEV on failure
 152  * File: src/usbcan.c
 153  */
 154 int usbcan_program_irq(struct candevice_t *candev)
 155 {
 156         return 0;
 157 }
 158
 159 /* !!! Don't change this function !!! */
 160 int usbcan_register(struct hwspecops_t *hwspecops)
 161 {
 162         hwspecops->request_io = usbcan_request_io;
 163         hwspecops->release_io = usbcan_release_io;
 164         hwspecops->reset = usbcan_reset;
 165         hwspecops->init_hw_data = usbcan_init_hw_data;
 166         hwspecops->init_chip_data = usbcan_init_chip_data;
 167         hwspecops->init_obj_data = usbcan_init_obj_data;
 168         hwspecops->write_register = NULL;
 169         hwspecops->read_register = NULL;
 170         hwspecops->program_irq = usbcan_program_irq;
 171         return 0;
 172 }
 173
 174 // static int sja1000_report_error_limit_counter;
 175
 176 static void sja1000_report_error(struct canchip_t *chip,
 177                                 unsigned sr, unsigned ir, unsigned ecc)
 178 {
 179         /*TODO : Error reporting from device */
 180
 181 /*      if(sja1000_report_error_limit_counter>=100)
 182                 return;
 183
 184         CANMSG("Error: status register: 0x%x irq_register: 0x%02x error: 0x%02x\n",
 185                 sr, ir, ecc);
 186
 187         sja1000_report_error_limit_counter+=10;
 188
 189         if(sja1000_report_error_limit_counter>=100){
 190                 sja1000_report_error_limit_counter+=10;
 191                 CANMSG("Error: too many errors, reporting disabled\n");
 192                 return;
 193         }
 194
 195 #ifdef CONFIG_OC_LINCAN_DETAILED_ERRORS
 196         CANMSG("SR: BS=%c  ES=%c  TS=%c  RS=%c  TCS=%c TBS=%c DOS=%c RBS=%c\n",
 197                 sr&sjaSR_BS?'1':'0',sr&sjaSR_ES?'1':'0',
 198                 sr&sjaSR_TS?'1':'0',sr&sjaSR_RS?'1':'0',
 199                 sr&sjaSR_TCS?'1':'0',sr&sjaSR_TBS?'1':'0',
 200                 sr&sjaSR_DOS?'1':'0',sr&sjaSR_RBS?'1':'0');
 201         CANMSG("IR: BEI=%c ALI=%c EPI=%c WUI=%c DOI=%c EI=%c  TI=%c  RI=%c\n",
 202                 sr&sjaIR_BEI?'1':'0',sr&sjaIR_ALI?'1':'0',
 203                 sr&sjaIR_EPI?'1':'0',sr&sjaIR_WUI?'1':'0',
 204                 sr&sjaIR_DOI?'1':'0',sr&sjaIR_EI?'1':'0',
 205                 sr&sjaIR_TI?'1':'0',sr&sjaIR_RI?'1':'0');
 206         if((sr&sjaIR_EI) || 1){
 207                 CANMSG("EI: %s %s %s\n",
 208                        sja1000_ecc_errc_str[(ecc&(sjaECC_ERCC1|sjaECC_ERCC0))/sjaECC_ERCC0],
 209                        ecc&sjaECC_DIR?"RX":"TX",
 210                        sja1000_ecc_seg_str[ecc&sjaECC_SEG_M]
 211                       );
 212         }
 213 #endif /*CONFIG_OC_LINCAN_DETAILED_ERRORS*/
 214 }
 215
 216
 217 /**
 218  * usbcan_enable_configuration - enable chip configuration mode
 219  * @chip: pointer to chip state structure
 220  */
 221 int usbcan_enable_configuration(struct canchip_t *chip)
 222 {
 223         return 0;
 224 }
 225
 226 /**
 227  * usbcan_disable_configuration - disable chip configuration mode
 228  * @chip: pointer to chip state structure
 229  */
 230 int usbcan_disable_configuration(struct canchip_t *chip)
 231 {
 232         return 0;
 233 }
 234
 235 /**
 236  * usbcan_chip_config: - can chip configuration
 237  * @chip: pointer to chip state structure
 238  *
 239  * This function configures chip and prepares it for message
 240  * transmission and reception. The function resets chip,
 241  * resets mask for acceptance of all messages by call to
 242  * usbcan_extended_mask() function and then
 243  * computes and sets baudrate with use of function usbcan_baud_rate().
 244  * Return Value: negative value reports error.
 245  * File: src/usbcan.c
 246  */
 247 int usbcan_chip_config(struct canchip_t *chip)
 248 {
 249         return 0;
 250 }
 251
 252 /**
 253  * usbcan_extended_mask: - setup of extended mask for message filtering
 254  * @chip: pointer to chip state structure
 255  * @code: can message acceptance code
 256  * @mask: can message acceptance mask
 257  *
 258  * Return Value: negative value reports error.
 259  * File: src/usbcan.c
 260  */
 261 int usbcan_extended_mask(struct canchip_t *chip, unsigned long code, unsigned  long mask)
 262 {
 263         int retval;
 264         struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
 265
 266         u8 usbbuf[USBCAN_TRANSFER_SIZE];
 267
 268         if (!dev)
 269                 return -ENODEV;
 270
 271         *(uint32_t *)(usbbuf)=cpu_to_le32(mask);
 272         *(uint32_t *)(usbbuf+4)=cpu_to_le32(code);
 273
 274         retval=usb_control_msg(dev->udev,
 275                 usb_sndctrlpipe(dev->udev, 0),
 276                 USBCAN_VENDOR_EXT_MASK_SET,
 277                 USB_TYPE_VENDOR,
 278                 cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
 279                 &usbbuf, USBCAN_TRANSFER_SIZE,
 280                 10000);
 281         if (retval<0)
 282                 return -ENODEV;
 283
 284         retval = usb_control_msg(dev->udev,
 285                 usb_rcvctrlpipe(dev->udev, 0),
 286                 USBCAN_VENDOR_EXT_MASK_STATUS,
 287                 USB_TYPE_VENDOR,
 288                 cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
 289                 &usbbuf, USBCAN_TRANSFER_SIZE,
 290                 10000);
 291
 292         if (retval==1){
 293                 if(usbbuf[0]==1){
 294                         DEBUGMSG("Setting acceptance code to 0x%lx\n",(unsigned long)code);
 295                         DEBUGMSG("Setting acceptance mask to 0x%lx\n",(unsigned long)mask);
 296                         return 0;
 297                 }
 298         }
 299
 300         CANMSG("Setting extended mask failed\n");
 301         return -EINVAL;
 302 }
 303
 304 /**
 305  * usbcan_baud_rate: - set communication parameters.
 306  * @chip: pointer to chip state structure
 307  * @rate: baud rate in Hz
 308  * @clock: frequency of sja1000 clock in Hz (ISA osc is 14318000)
 309  * @sjw: synchronization jump width (0-3) prescaled clock cycles
 310  * @sampl_pt: sample point in % (0-100) sets (TSEG1+1)/(TSEG1+TSEG2+2) ratio
 311  * @flags: fields %BTR1_SAM, %OCMODE, %OCPOL, %OCTP, %OCTN, %CLK_OFF, %CBP
 312  *
 313  * Return Value: negative value reports error.
 314  * File: src/usbcan.c
 315  */
 316 int usbcan_baud_rate(struct canchip_t *chip, int rate, int clock, int sjw,
 317                                                         int sampl_pt, int flags)
 318 {
 319         int retval;
 320         struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
 321
 322         u8 usbbuf[USBCAN_TRANSFER_SIZE];
 323
 324         if (!dev)
 325                 return -ENODEV;
 326
 327         *(int32_t *)(usbbuf)=cpu_to_le32(rate);
 328         *(int32_t *)(usbbuf+4)=cpu_to_le32(sjw);
 329         *(int32_t *)(usbbuf+8)=cpu_to_le32(sampl_pt);
 330         *(int32_t *)(usbbuf+12)=cpu_to_le32(flags);
 331
 332         retval=usb_control_msg(dev->udev,
 333                 usb_sndctrlpipe(dev->udev, 0),
 334                 USBCAN_VENDOR_BAUD_RATE_SET,
 335                 USB_TYPE_VENDOR,
 336                 cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
 337                 &usbbuf, USBCAN_TRANSFER_SIZE,
 338                 10000);
 339         if (retval<0)
 340                 return -ENODEV;
 341
 342         retval = usb_control_msg(dev->udev,
 343                 usb_rcvctrlpipe(dev->udev, 0),
 344                 USBCAN_VENDOR_BAUD_RATE_STATUS,
 345                 USB_TYPE_VENDOR,
 346                 cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
 347                 usbbuf, USBCAN_TRANSFER_SIZE,
 348                 10000);
 349
 350         if (retval==1){
 351                 if(usbbuf[0]==1)
 352                         return 0;
 353         }
 354
 355         CANMSG("baud rate %d is not possible to set\n",
 356                 rate);
 357         return -EINVAL;
 358 }
 359
 360 /**
 361  * usbcan_pre_read_config: - prepares message object for message reception
 362  * @chip: pointer to chip state structure
 363  * @obj: pointer to message object state structure
 364  *
 365  * Return Value: negative value reports error.
 366  *      Positive value indicates immediate reception of message.
 367  * File: src/usbcan.c
 368  */
 369 int usbcan_pre_read_config(struct canchip_t *chip, struct msgobj_t *obj)
 370 {
 371         return 0;
 372 }
 373
 374 #define MAX_TRANSMIT_WAIT_LOOPS 10
 375 /**
 376  * usbcan_pre_write_config: - prepares message object for message transmission
 377  * @chip: pointer to chip state structure
 378  * @obj: pointer to message object state structure
 379  * @msg: pointer to CAN message
 380  *
 381  * This function prepares selected message object for future initiation
 382  * of message transmission by usbcan_send_msg() function.
 383  * The CAN message data and message ID are transfered from @msg slot
 384  * into chip buffer in this function.
 385  * Return Value: negative value reports error.
 386  * File: src/usbcan.c
 387  */
 388 int usbcan_pre_write_config(struct canchip_t *chip, struct msgobj_t *obj,
 389                                                         struct canmsg_t *msg)
 390 {
 391         return 0;
 392 }
 393
 394 /**
 395  * usbcan_send_msg: - initiate message transmission
 396  * @chip: pointer to chip state structure
 397  * @obj: pointer to message object state structure
 398  * @msg: pointer to CAN message
 399  *
 400  * This function is called after usbcan_pre_write_config() function,
 401  * which prepares data in chip buffer.
 402  * Return Value: negative value reports error.
 403  * File: src/usbcan.c
 404  */
 405 int usbcan_send_msg(struct canchip_t *chip, struct msgobj_t *obj,
 406                                                         struct canmsg_t *msg)
 407 {
 408         return 0;
 409 }
 410
 411 /**
 412  * usbcan_check_tx_stat: - checks state of transmission engine
 413  * @chip: pointer to chip state structure
 414  *
 415  * Return Value: negative value reports error.
 416  *      Positive return value indicates transmission under way status.
 417  *      Zero value indicates finishing of all issued transmission requests.
 418  * File: src/usbcan.c
 419  */
 420 int usbcan_check_tx_stat(struct canchip_t *chip)
 421 {
 422         struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
 423         if (!dev)
 424                 return 0;
 425         if (test_bit(USBCAN_TX_PENDING,&dev->flags))
 426                 return 1;
 427         return 0;
 428 }
 429
 430 /**
 431  * usbcan_set_btregs: -  configures bitrate registers
 432  * @chip: pointer to chip state structure
 433  * @btr0: bitrate register 0
 434  * @btr1: bitrate register 1
 435  *
 436  * Return Value: negative value reports error.
 437  * File: src/usbcan.c
 438  */
 439 int usbcan_set_btregs(struct canchip_t *chip, unsigned short btr0,
 440                                                         unsigned short btr1)
 441 {
 442         int retval;
 443         u8      buf[USBCAN_TRANSFER_SIZE];
 444         struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
 445         uint16_t value=(btr1&0xFF)<<8 | (btr0&0xFF);
 446
 447         if (!dev)
 448                 return -ENODEV;
 449
 450         retval = usb_control_msg(dev->udev,
 451         usb_rcvctrlpipe(dev->udev, 0),
 452         USBCAN_VENDOR_SET_BTREGS,
 453         USB_TYPE_VENDOR,
 454         cpu_to_le16(value), cpu_to_le16(chip->chip_idx),
 455         &buf, USBCAN_TRANSFER_SIZE,
 456         10000);
 457
 458         if (retval==1){
 459                 if(buf[0]==1)
 460                         return 0;
 461         }
 462         return -ENODEV;
 463 }
 464
 465 /**
 466  * usbcan_start_chip: -  starts chip message processing
 467  * @chip: pointer to chip state structure
 468  *
 469  * Return Value: negative value reports error.
 470  * File: src/usbcan.c
 471  */
 472 int usbcan_start_chip(struct canchip_t *chip)
 473 {
 474         int retval;
 475         u8      buf[USBCAN_TRANSFER_SIZE];
 476         struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
 477
 478         if (!dev)
 479                 return -ENODEV;
 480
 481         retval = usb_control_msg(dev->udev,
 482         usb_rcvctrlpipe(dev->udev, 0),
 483         USBCAN_VENDOR_START_CHIP,
 484         USB_TYPE_VENDOR,
 485         cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
 486         &buf, USBCAN_TRANSFER_SIZE,
 487         10000);
 488
 489         if (retval==1){
 490                 if(buf[0]==1)
 491                         return 0;
 492         }
 493         return -ENODEV;
 494 }
 495
 496 /**
 497  * usbcan_chip_queue_status: -  gets queue status from usb device
 498  * @chip: pointer to chip state structure
 499  *
 500  * Return Value: negative value reports error.
 501  * 0 means queue is not full
 502  * 1 means queue is full
 503  * File: src/usbcan.c
 504  */
 505 int usbcan_chip_queue_status(struct canchip_t *chip)
 506 {
 507         int retval;
 508         u8      buf[USBCAN_TRANSFER_SIZE];
 509         struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
 510
 511         if (!dev)
 512                 return -ENODEV;
 513         retval = usb_control_msg(dev->udev,
 514         usb_rcvctrlpipe(dev->udev, 0),
 515         USBCAN_VENDOR_CHECK_TX_STAT,
 516         USB_TYPE_VENDOR,
 517         cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
 518         &buf, USBCAN_TRANSFER_SIZE,
 519         10000);
 520
 521         if (retval==1){
 522                 CANMSG("Chip_queue_status: %d\n",buf[0]);
 523                 if(buf[0]==1)
 524                         return 0;
 525                 if(buf[0]==0)
 526                         return 1;
 527         }
 528         CANMSG("Chip_queue_status error: %d\n",retval);
 529         return -ENODEV;
 530 }
 531
 532 /**
 533  * usbcan_stop_chip: -  stops chip message processing
 534  * @chip: pointer to chip state structure
 535  *
 536  * Return Value: negative value reports error.
 537  * File: src/usbcan.c
 538  */
 539 int usbcan_stop_chip(struct canchip_t *chip)
 540 {
 541         int retval;
 542         u8      buf[USBCAN_TRANSFER_SIZE];
 543         struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
 544
 545         if (!dev)
 546                 return -ENODEV;
 547
 548         retval = usb_control_msg(dev->udev,
 549         usb_rcvctrlpipe(dev->udev, 0),
 550         USBCAN_VENDOR_STOP_CHIP,
 551         USB_TYPE_VENDOR,
 552         cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
 553         &buf, USBCAN_TRANSFER_SIZE,
 554         10000);
 555
 556         if (retval==1){
 557                 if(buf[0]==1)
 558                         return 0;
 559         }
 560         return -ENODEV;
 561 }
 562
 563 /**
 564  * usbcan_register_devs: - attaches usb device data to the chip structure
 565  * @chip: pointer to chip state structure
 566  * @data: usb device data
 567  *
 568  * File: src/usbcan.c
 569  */
 570 void usbcan_register_devs(struct canchip_t *chip,void *data){
 571         struct usbcan_devs *usbdevs=(struct usbcan_devs *)data;
 572         if (!usbdevs){
 573             CANMSG("Bad structure given\n");
 574             return;
 575         }
 576         if (chip->chip_idx>=usbdevs->count) {
 577             CANMSG("Requested chip number is bigger than chip count\n");
 578             return;
 579         }
 580
 581         usbdevs->devs[chip->chip_idx]->chip=chip;
 582         chip->chip_data=(void *)usbdevs->devs[chip->chip_idx];
 583 }
 584
 585 /**
 586  * usbcan_attach_to_chip: - attaches to the chip, setups registers and state
 587  * @chip: pointer to chip state structure
 588  *
 589  * Return Value: negative value reports error.
 590  * File: src/usbcan.c
 591  */
 592 int usbcan_attach_to_chip(struct canchip_t *chip)
 593 {
 594         struct usbcan_usb *dev = (struct usbcan_usb *)chip->chip_data;
 595
 596         /* start kernel thread */
 597         dev->comthread=can_kthread_run(usbcan_kthread, (void *)dev, "usbcan_%d",chip->chip_idx);
 598
 599         return 0;
 600 }
 601
 602 /**
 603  * usbcan_release_chip: - called before chip structure removal if %CHIP_ATTACHED is set
 604  * @chip: pointer to chip state structure
 605  *
 606  * Return Value: negative value reports error.
 607  * File: src/usbcan.c
 608  */
 609 int usbcan_release_chip(struct canchip_t *chip)
 610 {
 611         struct usbcan_usb *dev = (struct usbcan_usb *)chip->chip_data;
 612
 613         usbcan_stop_chip(chip);
 614
 615         /* terminate the kernel thread */
 616         set_bit(USBCAN_TERMINATE,&dev->flags);
 617         wake_up_process(dev->comthread);
 618 //      can_kthread_stop(dev->comthread);
 619
 620         return 0;
 621 }
 622
 623 /**
 624  * usbcan_remote_request: - configures message object and asks for RTR message
 625  * @chip: pointer to chip state structure
 626  * @obj: pointer to message object structure
 627  *
 628  * Return Value: negative value reports error.
 629  * File: src/usbcan.c
 630  */
 631 int usbcan_remote_request(struct canchip_t *chip, struct msgobj_t *obj)
 632 {
 633         CANMSG("usbcan_remote_request not implemented\n");
 634         return -ENOSYS;
 635 }
 636
 637 /**
 638  * usbcan_standard_mask: - setup of mask for message filtering
 639  * @chip: pointer to chip state structure
 640  * @code: can message acceptance code
 641  * @mask: can message acceptance mask
 642  *
 643  * Return Value: negative value reports error.
 644  * File: src/usbcan.c
 645  */
 646 int usbcan_standard_mask(struct canchip_t *chip, unsigned short code,
 647                 unsigned short mask)
 648 {
 649         CANMSG("usbcan_standard_mask not implemented\n");
 650         return -ENOSYS;
 651 }
 652
 653 /**
 654  * usbcan_clear_objects: - clears state of all message object residing in chip
 655  * @chip: pointer to chip state structure
 656  *
 657  * Return Value: negative value reports error.
 658  * File: src/usbcan.c
 659  */
 660 int usbcan_clear_objects(struct canchip_t *chip)
 661 {
 662         CANMSG("usbcan_clear_objects not implemented\n");
 663         return -ENOSYS;
 664 }
 665
 666 /**
 667  * usbcan_config_irqs: - tunes chip hardware interrupt delivery
 668  * @chip: pointer to chip state structure
 669  * @irqs: requested chip IRQ configuration
 670  *
 671  * Return Value: negative value reports error.
 672  * File: src/usbcan.c
 673  */
 674 int usbcan_config_irqs(struct canchip_t *chip, short irqs)
 675 {
 676         CANMSG("usbcan_config_irqs not implemented\n");
 677         return -ENOSYS;
 678 }
 679
 680 /**
 681  * usbcan_irq_write_handler: - part of ISR code responsible for transmit events
 682  * @chip: pointer to chip state structure
 683  * @obj: pointer to attached queue description
 684  *
 685  * The main purpose of this function is to read message from attached queues
 686  * and transfer message contents into CAN controller chip.
 687  * This subroutine is called by
 688  * usbcan_irq_write_handler() for transmit events.
 689  * File: src/usbcan.c
 690  */
 691 void usbcan_irq_write_handler(struct canchip_t *chip, struct msgobj_t *obj)
 692 {
 693         int cmd;
 694
 695         if(obj->tx_slot){
 696                 // Do local transmitted message distribution if enabled
 697                 if (processlocal){
 698                         // fill CAN message timestamp
 699                         can_filltimestamp(&obj->tx_slot->msg.timestamp);
 700
 701                         obj->tx_slot->msg.flags |= MSG_LOCAL;
 702                         canque_filter_msg2edges(obj->qends, &obj->tx_slot->msg);
 703                 }
 704                 // Free transmitted slot
 705                 canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
 706                 obj->tx_slot=NULL;
 707         }
 708
 709         can_msgobj_clear_fl(obj,TX_PENDING);
 710         cmd=canque_test_outslot(obj->qends, &obj->tx_qedge, &obj->tx_slot);
 711         if(cmd<0)
 712                 return;
 713         can_msgobj_set_fl(obj,TX_PENDING);
 714
 715         if (chip->chipspecops->pre_write_config(chip, obj, &obj->tx_slot->msg)) {
 716                 obj->ret = -1;
 717                 canque_notify_inends(obj->tx_qedge, CANQUEUE_NOTIFY_ERRTX_PREP);
 718                 canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
 719                 obj->tx_slot=NULL;
 720                 return;
 721         }
 722         if (chip->chipspecops->send_msg(chip, obj, &obj->tx_slot->msg)) {
 723                 obj->ret = -1;
 724                 canque_notify_inends(obj->tx_qedge, CANQUEUE_NOTIFY_ERRTX_SEND);
 725                 canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
 726                 obj->tx_slot=NULL;
 727                 return;
 728         }
 729 }
 730
 731 #define MAX_RETR 10
 732
 733 /**
 734  * usbcan_irq_handler: - interrupt service routine
 735  * @irq: interrupt vector number, this value is system specific
 736  * @chip: pointer to chip state structure
 737  *
 738  * Interrupt handler is activated when state of CAN controller chip changes,
 739  * there is message to be read or there is more space for new messages or
 740  * error occurs. The receive events results in reading of the message from
 741  * CAN controller chip and distribution of message through attached
 742  * message queues.
 743  * File: src/usbcan.c
 744  */
 745 int usbcan_irq_handler(int irq, struct canchip_t *chip)
 746 {
 747         return CANCHIP_IRQ_HANDLED;
 748 }
 749
 750 /**
 751  * usbcan_wakeup_tx: - wakeups TX processing
 752  * @chip: pointer to chip state structure
 753  * @obj: pointer to message object structure
 754  *
 755  * Function is responsible for initiating message transmition.
 756  * It is responsible for clearing of object TX_REQUEST flag
 757  *
 758  * Return Value: negative value reports error.
 759  * File: src/usbcan.c
 760  */
 761 int usbcan_wakeup_tx(struct canchip_t *chip, struct msgobj_t *obj)
 762 {
 763         struct usbcan_usb *dev=(struct usbcan_usb *)chip->chip_data;
 764
 765         CANMSG("Trying to send message\n");
 766         can_preempt_disable();
 767
 768         can_msgobj_set_fl(obj,TX_PENDING);
 769         can_msgobj_set_fl(obj,TX_REQUEST);
 770         while(!can_msgobj_test_and_set_fl(obj,TX_LOCK)){
 771                 can_msgobj_clear_fl(obj,TX_REQUEST);
 772
 773                 if (test_and_clear_bit(USBCAN_FREE_TX_URB,&dev->flags)){
 774                         obj->tx_retry_cnt=0;
 775                         set_bit(USBCAN_TX_PENDING,&dev->flags);
 776                         if (test_bit(USBCAN_THREAD_RUNNING,&dev->flags))
 777                                 wake_up_process(dev->comthread);
 778                 }
 779
 780                 can_msgobj_clear_fl(obj,TX_LOCK);
 781                 if(!can_msgobj_test_fl(obj,TX_REQUEST)) break;
 782                 CANMSG("TX looping in usbcan_wakeup_tx\n");
 783         }
 784
 785         can_preempt_enable();
 786         return 0;
 787 }
 788
 789 int usbcan_chipregister(struct chipspecops_t *chipspecops)
 790 {
 791         CANMSG("initializing usbcan chip operations\n");
 792         chipspecops->chip_config=usbcan_chip_config;
 793         chipspecops->baud_rate=usbcan_baud_rate;
 794         chipspecops->standard_mask=usbcan_standard_mask;
 795         chipspecops->extended_mask=usbcan_extended_mask;
 796         chipspecops->message15_mask=usbcan_extended_mask;
 797         chipspecops->clear_objects=usbcan_clear_objects;
 798         chipspecops->config_irqs=usbcan_config_irqs;
 799         chipspecops->pre_read_config=usbcan_pre_read_config;
 800         chipspecops->pre_write_config=usbcan_pre_write_config;
 801         chipspecops->send_msg=usbcan_send_msg;
 802         chipspecops->check_tx_stat=usbcan_check_tx_stat;
 803         chipspecops->wakeup_tx=usbcan_wakeup_tx;
 804         chipspecops->remote_request=usbcan_remote_request;
 805         chipspecops->enable_configuration=usbcan_enable_configuration;
 806         chipspecops->disable_configuration=usbcan_disable_configuration;
 807         chipspecops->attach_to_chip=usbcan_attach_to_chip;
 808         chipspecops->release_chip=usbcan_release_chip;
 809         chipspecops->set_btregs=usbcan_set_btregs;
 810         chipspecops->start_chip=usbcan_start_chip;
 811         chipspecops->stop_chip=usbcan_stop_chip;
 812         chipspecops->irq_handler=usbcan_irq_handler;
 813         chipspecops->irq_accept=NULL;
 814         return 0;
 815 }
 816
 817 /**
 818  * usbcan_fill_chipspecops - fills chip specific operations
 819  * @chip: pointer to chip representation structure
 820  *
 821  * The function fills chip specific operations for sja1000 (PeliCAN) chip.
 822  *
 823  * Return Value: returns negative number in the case of fail
 824  */
 825 int usbcan_fill_chipspecops(struct canchip_t *chip)
 826 {
 827         chip->chip_type="usbcan";
 828         chip->max_objects=1;
 829         usbcan_chipregister(chip->chipspecops);
 830         return 0;
 831 }
 832
 833 /**
 834  * usbcan_init_chip_data - Initialize chips
 835  * @candev: Pointer to candevice/board structure
 836  * @chipnr: Number of the CAN chip on the hardware card
 837  *
 838  * The function usbcan_init_chip_data() is used to initialize the hardware
 839  * structure containing information about the CAN chips.
 840  * %CHIP_TYPE represents the type of CAN chip. %CHIP_TYPE can be "i82527" or
 841  * "sja1000".
 842  * The @chip_base_addr entry represents the start of the 'official' memory map
 843  * of the installed chip. It's likely that this is the same as the @io_addr
 844  * argument supplied at module loading time.
 845  * The @clock entry holds the chip clock value in Hz.
 846  * The entry @sja_cdr_reg holds hardware specific options for the Clock Divider
 847  * register. Options defined in the %sja1000.h file:
 848  * %sjaCDR_CLKOUT_MASK, %sjaCDR_CLK_OFF, %sjaCDR_RXINPEN, %sjaCDR_CBP, %sjaCDR_PELICAN
 849  * The entry @sja_ocr_reg holds hardware specific options for the Output Control
 850  * register. Options defined in the %sja1000.h file:
 851  * %sjaOCR_MODE_BIPHASE, %sjaOCR_MODE_TEST, %sjaOCR_MODE_NORMAL, %sjaOCR_MODE_CLOCK,
 852  * %sjaOCR_TX0_LH, %sjaOCR_TX1_ZZ.
 853  * The entry @int_clk_reg holds hardware specific options for the Clock Out
 854  * register. Options defined in the %i82527.h file:
 855  * %iCLK_CD0, %iCLK_CD1, %iCLK_CD2, %iCLK_CD3, %iCLK_SL0, %iCLK_SL1.
 856  * The entry @int_bus_reg holds hardware specific options for the Bus
 857  * Configuration register. Options defined in the %i82527.h file:
 858  * %iBUS_DR0, %iBUS_DR1, %iBUS_DT1, %iBUS_POL, %iBUS_CBY.
 859  * The entry @int_cpu_reg holds hardware specific options for the cpu interface
 860  * register. Options defined in the %i82527.h file:
 861  * %iCPU_CEN, %iCPU_MUX, %iCPU_SLP, %iCPU_PWD, %iCPU_DMC, %iCPU_DSC, %iCPU_RST.
 862  * Return Value: The function always returns zero
 863  * File: src/usbcan.c
 864  */
 865 int usbcan_init_chip_data(struct candevice_t *candev, int chipnr)
 866 {
 867         struct canchip_t *chip=candev->chip[chipnr];
 868
 869         usbcan_fill_chipspecops(chip);
 870
 871         candev->chip[chipnr]->flags|=CHIP_IRQ_CUSTOM;
 872         candev->chip[chipnr]->chip_base_addr=0;
 873         candev->chip[chipnr]->clock = 0;
 874
 875         return 0;
 876 }
 877
 878
 879
 880 /* --------------------------------------------------------------------------------------------------- */
 881 static int usbcan_sleep_thread(struct usbcan_usb *dev)
 882 {
 883         int     rc = 0;
 884
 885         /* Wait until a signal arrives or we are woken up */
 886         for (;;) {
 887                 try_to_freeze();
 888                 set_current_state(TASK_INTERRUPTIBLE);
 889                 if (signal_pending(current)) {
 890                         rc = -EINTR;
 891                         break;
 892                 }
 893                 if (
 894                         can_kthread_should_stop() ||
 895                         test_bit(USBCAN_DATA_OK,&dev->flags) ||
 896                         test_bit(USBCAN_TX_PENDING,&dev->flags) ||
 897                         test_bit(USBCAN_TERMINATE,&dev->flags) ||
 898                         test_bit(USBCAN_ERROR,&dev->flags)
 899                 )
 900                         break;
 901                 schedule();
 902         }
 903         __set_current_state(TASK_RUNNING);
 904         return rc;
 905 }
 906
 907 static void usbcan_callback(struct urb *urb)
 908 {
 909         struct usbcan_message *mess = urb->context;
 910         int retval;
 911
 912         if (!test_bit(USBCAN_THREAD_RUNNING,&mess->dev->flags))
 913                 return;
 914         if (test_bit(USBCAN_MESSAGE_TERMINATE,&mess->flags))
 915                 return;
 916
 917         switch (urb->status) {
 918         case 0:
 919                 /* success */
 920                 CANMSG("%s > Message OK\n", __FUNCTION__);
 921                 set_bit(USBCAN_DATA_OK,&mess->dev->flags);
 922                 set_bit(USBCAN_MESSAGE_DATA_OK,&mess->flags);
 923                 if (test_bit(USBCAN_MESSAGE_TYPE_RX,&mess->flags)){
 924                         CANMSG("%s > RX flag set\n", __FUNCTION__);
 925                         set_bit(USBCAN_DATA_RX,&mess->dev->flags);
 926                 }
 927                 if (test_bit(USBCAN_MESSAGE_TYPE_TX,&mess->flags))
 928                         CANMSG("%s > TX flag set\n", __FUNCTION__);
 929                         set_bit(USBCAN_DATA_TX,&mess->dev->flags);
 930                 clear_bit(USBCAN_MESSAGE_URB_PENDING,&mess->flags);
 931                 if (test_bit(USBCAN_THREAD_RUNNING,&mess->dev->flags))
 932                         wake_up_process(mess->dev->comthread);
 933                 else
 934                         CANMSG("%s > USBCAN thread not running\n", __FUNCTION__);
 935 //                      wake_up(&mess->dev->queue);
 936                 return;
 937         case -ECONNRESET:
 938         case -ENOENT:
 939         case -ESHUTDOWN:
 940                 /* this urb is terminated, clean up */
 941                 CANMSG("%s > Urb shutting down with status: %d\n", __FUNCTION__, urb->status);
 942                 set_bit(USBCAN_TERMINATE,&mess->dev->flags);
 943                 set_bit(USBCAN_MESSAGE_TERMINATE,&mess->flags);
 944                 clear_bit(USBCAN_MESSAGE_URB_PENDING,&mess->flags);
 945                 return;
 946         default:
 947                 //CANMSG("%s > Nonzero status received: %d\n", __FUNCTION__, urb->status);
 948                 break;
 949         }
 950
 951         // Try to send urb again on non significant errors
 952         retval = usb_submit_urb (urb, GFP_ATOMIC);
 953         if (retval<0){
 954                 CANMSG("%s > Retrying urb failed with result %d\n", __FUNCTION__, retval);
 955                 set_bit(USBCAN_ERROR,&mess->dev->flags);
 956                 clear_bit(USBCAN_MESSAGE_URB_PENDING,&mess->flags);
 957                 if (test_bit(USBCAN_THREAD_RUNNING,&mess->dev->flags))
 958                         wake_up_process(mess->dev->comthread);
 959 //                      wake_up(&mess->dev->queue);
 960         }
 961 }
 962
 963 int usbcan_kthread(void *data)
 964 {
 965         int i,retval=0;
 966         struct usbcan_usb *dev=(struct usbcan_usb *)data;
 967         struct msgobj_t *obj;
 968
 969   CANMSG("Usbcan thread started...\n");
 970
 971         if (!dev->chip)
 972                 goto error;
 973         obj=dev->chip->msgobj[0];
 974
 975         /* Prepare receive urbs  */
 976         for (i=0;i<USBCAN_TOT_RX_URBS;i++){
 977                 dev->rx[i].u = usb_alloc_urb(0, GFP_KERNEL);
 978                 if (!dev->rx[i].u){
 979                         CANMSG("Error allocating %d. usb receive urb\n",i);
 980                         goto error;
 981                 }
 982                 dev->rx[i].u->dev = dev->udev;
 983                 dev->rx[i].dev = dev;
 984                 usb_fill_bulk_urb(dev->rx[i].u, dev->udev,
 985                                 usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
 986                                 dev->rx[i].msg, USBCAN_TRANSFER_SIZE,
 987                                 usbcan_callback, &dev->rx[i]);
 988                 set_bit(USBCAN_MESSAGE_TYPE_RX,&dev->rx[i].flags);
 989         }
 990
 991         /* Prepare transmit urbs  */
 992         for (i=0;i<USBCAN_TOT_TX_URBS;i++){
 993                 dev->tx[i].u = usb_alloc_urb(0, GFP_KERNEL);
 994                 if (!dev->tx[i].u){
 995                         CANMSG("Error allocating %d. usb transmit urb\n",i);
 996                         goto error;
 997                 }
 998                 dev->tx[i].u->dev = dev->udev;
 999                 dev->tx[i].dev = dev;
1000                 usb_fill_bulk_urb(dev->tx[i].u, dev->udev,
1001                                 usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
1002                                 dev->tx[i].msg, USBCAN_TRANSFER_SIZE,
1003                                 usbcan_callback, &dev->tx[i]);
1004                 set_bit(USBCAN_MESSAGE_FREE,&dev->tx[i].flags);
1005                 set_bit(USBCAN_MESSAGE_TYPE_TX,&dev->tx[i].flags);
1006         }
1007
1008         set_bit(USBCAN_THREAD_RUNNING,&dev->flags);
1009         set_bit(USBCAN_FREE_TX_URB,&dev->flags);
1010
1011         for (i=0;i<USBCAN_TOT_RX_URBS;i++){
1012                 retval=usb_submit_urb(dev->rx[i].u, GFP_KERNEL);
1013                 if (retval){
1014                         CANMSG("%d. URB error %d\n",i,retval);
1015                         set_bit(USBCAN_ERROR,&dev->flags);
1016                         goto exit;
1017                 }
1018                 else
1019                         set_bit(USBCAN_MESSAGE_URB_PENDING,&dev->rx[i].flags);
1020         }
1021   /* an endless loop in which we are doing our work */
1022   for(;;)
1023   {
1024                 /* We need to do a memory barrier here to be sure that
1025                 the flags are visible on all CPUs. */
1026                 mb();
1027                 /* fall asleep */
1028                 if (!(can_kthread_should_stop() || test_bit(USBCAN_TERMINATE,&dev->flags))){
1029                         if (usbcan_sleep_thread(dev)<0)
1030                                 break;
1031 /*                      wait_event_interruptible(dev->queue,
1032                                 can_kthread_should_stop() ||
1033                                 test_bit(USBCAN_DATA_OK,&dev->flags) ||
1034                                 test_bit(USBCAN_TX_PENDING,&dev->flags) ||
1035                                 test_bit(USBCAN_TERMINATE,&dev->flags) ||
1036                                 test_bit(USBCAN_ERROR,&dev->flags)
1037                         );*/
1038                 }
1039                 /* We need to do a memory barrier here to be sure that
1040                 the flags are visible on all CPUs. */
1041                 mb();
1042
1043                 /* here we are back from sleep because we caught a signal. */
1044                 if (can_kthread_should_stop()){
1045                         /* we received a request to terminate ourself */
1046                         break;
1047                 }
1048
1049                 /* here we are back from sleep because we caught a signal. */
1050                 if (test_bit(USBCAN_TERMINATE,&dev->flags)){
1051                         /* we received a request to terminate ourself */
1052                         break;
1053                 }
1054
1055                 { /* Normal work to do */
1056                         if (test_and_clear_bit(USBCAN_DATA_OK,&dev->flags)){
1057                                 int j, len;
1058                                 CANMSG("USBCAN Succesfull data transfer\n");
1059                                 if (test_and_clear_bit(USBCAN_DATA_RX,&dev->flags)){
1060                                         CANMSG("USBCAN RX handler\n");
1061                                         for (i=0;i<USBCAN_TOT_RX_URBS;i++){
1062                                                 if (test_and_clear_bit(USBCAN_MESSAGE_DATA_OK,&dev->rx[i].flags)){
1063                                                         CANMSG("USBCAN Thread has received a message\n");
1064                                                         if ((dev->chip)&&(dev->chip->flags & CHIP_CONFIGURED)){
1065                                                                 u8 *ptr;
1066                                                                 struct usbcan_message *mess=&dev->rx[i];
1067
1068                                                                 len=*(u8 *)(mess->msg+1);
1069                                                                 if(len > CAN_MSG_LENGTH) len = CAN_MSG_LENGTH;
1070                                                                 obj->rx_msg.length = len;
1071
1072                                                                 obj->rx_msg.flags=le16_to_cpu(*(u16 *)(mess->msg+2));
1073                                                                 obj->rx_msg.id=le32_to_cpu((*(u32 *)(mess->msg+4)));
1074
1075                                                                 for(ptr=mess->msg+8,j=0; j < len; ptr++,j++) {
1076                                                                         obj->rx_msg.data[j]=*ptr;
1077                                                                 }
1078
1079                                                                 // fill CAN message timestamp
1080                                                                 can_filltimestamp(&obj->rx_msg.timestamp);
1081                                                                 canque_filter_msg2edges(obj->qends, &obj->rx_msg);
1082                                                         }
1083                                                         else
1084                                                                 CANMSG("Destination chip not found\n");
1085                                                 }
1086                                                 if (!test_bit(USBCAN_MESSAGE_URB_PENDING,&dev->rx[i].flags)){
1087                                                         CANMSG("Renewing RX urb\n");
1088                                                         retval = usb_submit_urb (dev->rx[i].u, GFP_KERNEL);
1089                                                         if (retval<0){
1090                                                                 CANMSG("%d. URB error %d\n", i, retval);
1091                                                                 set_bit(USBCAN_ERROR,&dev->flags);
1092                                                         }
1093                                                         else
1094                                                                 set_bit(USBCAN_MESSAGE_URB_PENDING,&dev->rx[i].flags);
1095                                                 }
1096                                         }
1097                                 }
1098                                 if (test_and_clear_bit(USBCAN_DATA_TX,&dev->flags)){
1099                                         CANMSG("USBCAN TX handler\n");
1100                                         for (i=0;i<USBCAN_TOT_TX_URBS;i++){
1101                                                 if (test_and_clear_bit(USBCAN_MESSAGE_DATA_OK,&dev->tx[i].flags)){
1102                                                         struct usbcan_message *mess=&dev->tx[i];
1103                                                         CANMSG("USBCAN Message successfully sent\n");
1104
1105                                                         if(mess->slot){
1106                                                                 // Do local transmitted message distribution if enabled
1107                                                                 if (processlocal){
1108                                                                         // fill CAN message timestamp
1109                                                                         can_filltimestamp(&mess->slot->msg.timestamp);
1110
1111                                                                         mess->slot->msg.flags |= MSG_LOCAL;
1112                                                                         canque_filter_msg2edges(obj->qends, &mess->slot->msg);
1113                                                                 }
1114                                                                 // Free transmitted slot
1115                                                                 canque_free_outslot(obj->qends, mess->qedge, mess->slot);
1116                                                                 mess->slot=NULL;
1117                                                         }
1118                                                         can_msgobj_clear_fl(obj,TX_PENDING);
1119
1120                                                         set_bit(USBCAN_FREE_TX_URB,&dev->flags);
1121                                                         set_bit(USBCAN_MESSAGE_FREE,&dev->tx[i].flags);
1122
1123                                                         // Test if some new messages arrived
1124                                                         set_bit(USBCAN_TX_PENDING,&dev->flags);
1125                                                 }
1126                                         }
1127                                 }
1128                         }
1129                         if (test_and_clear_bit(USBCAN_TX_PENDING,&dev->flags)){
1130                                 int i, cmd,j,len;
1131                                 for (i=0;i<USBCAN_TOT_TX_URBS;i++){
1132                                         if (test_bit(USBCAN_MESSAGE_FREE,&dev->tx[i].flags)){
1133                                                 struct usbcan_message *mess=&dev->tx[i];
1134                                                 u8 *ptr;
1135                                                 cmd=canque_test_outslot(obj->qends, &mess->qedge, &mess->slot);
1136                                                 if(cmd>=0){
1137                                                         CANMSG("USBCAN Sending a message\n");
1138
1139                                                         can_msgobj_set_fl(obj,TX_PENDING);
1140                                                         clear_bit(USBCAN_FREE_TX_URB,&dev->flags);
1141                                                         clear_bit(USBCAN_MESSAGE_FREE,&dev->tx[i].flags);
1142
1143                                                         *(u8 *)(mess->msg)=0;
1144                                                         len = mess->slot->msg.length;
1145                                                         if(len > CAN_MSG_LENGTH)
1146                                                                 len = CAN_MSG_LENGTH;
1147                                                         *(u8 *)(mess->msg+1)=len & 0xFF;
1148                                                         *(u16 *)(mess->msg+2)=cpu_to_le16(mess->slot->msg.flags);
1149                                                         *(u32 *)(mess->msg+4)=cpu_to_le32(mess->slot->msg.id);
1150
1151                                                         for(ptr=mess->msg+8,j=0; j < len; ptr++,j++) {
1152                                                                 *ptr=mess->slot->msg.data[j] & 0xFF;
1153                                                         }
1154                                                         for(; j < 8; ptr++,j++) {
1155                                                                 *ptr=0;
1156                                                         }
1157
1158                                                         set_bit(USBCAN_MESSAGE_URB_PENDING,&mess->flags);
1159                                                         retval = usb_submit_urb (dev->tx[i].u, GFP_KERNEL);
1160                                                         if (retval){
1161                                                                 CANMSG("%d. URB error %d\n",i,retval);
1162                                                                 clear_bit(USBCAN_MESSAGE_URB_PENDING,&mess->flags);
1163                                                                 set_bit(USBCAN_FREE_TX_URB,&dev->flags);
1164                                                                 set_bit(USBCAN_MESSAGE_FREE,&dev->tx[i].flags);
1165                                                                 obj->ret = -1;
1166                                                                 canque_notify_inends(mess->qedge, CANQUEUE_NOTIFY_ERRTX_SEND);
1167                                                                 canque_free_outslot(obj->qends, mess->qedge, mess->slot);
1168                                                                 mess->slot=NULL;
1169                                                         }
1170                                                 }
1171                                                 else{
1172                                                         set_bit(USBCAN_FREE_TX_URB,&dev->flags);
1173                                                         break;
1174                                                 }
1175                                         }
1176                                 }
1177                         }
1178     }
1179   }
1180         set_bit(USBCAN_TERMINATE,&dev->flags);
1181 exit:
1182   /* here we go only in case of termination of the thread */
1183         for (i=0;i<USBCAN_TOT_RX_URBS;i++){
1184                 if (dev->rx[i].u){
1185                         set_bit(USBCAN_MESSAGE_TERMINATE,&dev->rx[i].flags);
1186                         usb_kill_urb(dev->rx[i].u);
1187                         usb_free_urb(dev->rx[i].u);
1188                 }
1189         }
1190         for (i=0;i<USBCAN_TOT_TX_URBS;i++){
1191                 if (dev->tx[i].u){
1192                         set_bit(USBCAN_MESSAGE_TERMINATE,&dev->tx[i].flags);
1193                         usb_kill_urb(dev->tx[i].u);
1194                         usb_free_urb(dev->tx[i].u);
1195                 }
1196         }
1197         clear_bit(USBCAN_THREAD_RUNNING,&dev->flags);
1198
1199   CANMSG ("usbcan thread finished!\n");
1200   return 0;
1201 error:
1202   /* cleanup the thread, leave */
1203   CANMSG ("kernel thread terminated!\n");
1204   return -ENOMEM;
1205 }
1206
1207 static int usbcan_probe(struct usb_interface *interface, const struct usb_device_id *id)
1208 {
1209         struct usbcan_devs *usbdevs=NULL;
1210         struct usb_host_interface *iface_desc;
1211         struct usb_endpoint_descriptor *endpoint;
1212         size_t buffer_size;
1213         int i,j,k;
1214         int retval = -ENOMEM;
1215
1216         iface_desc = interface->cur_altsetting;
1217         if (iface_desc->desc.bNumEndpoints % 2){
1218                 err("Endpoint count must be even");
1219                 goto noalloc;
1220         }
1221
1222         usbcan_chip_count = iface_desc->desc.bNumEndpoints / 2;
1223
1224         usbdevs = (struct usbcan_devs *) can_checked_malloc(sizeof(struct usbcan_devs));
1225         if (!usbdevs) {
1226                 err("Out of memory");
1227                 goto error;
1228         }
1229         memset(usbdevs, 0, sizeof(struct usbcan_devs));
1230
1231         usbdevs->count=usbcan_chip_count;
1232
1233         usbdevs->devs = (struct usbcan_usb **) can_checked_malloc(usbcan_chip_count * sizeof(struct usbcan_usb *));
1234         if (!usbdevs->devs) {
1235                 err("Out of memory");
1236                 goto error;
1237         }
1238         memset(usbdevs->devs, 0, usbcan_chip_count * sizeof(struct usbcan_usb *));
1239
1240         for (j=0;j<usbcan_chip_count;j++){
1241                 struct usbcan_usb *dev;
1242                 int epnum=-1,was;
1243
1244                 /* allocate memory for our device state and initialize it */
1245                 usbdevs->devs[j] = (struct usbcan_usb *) can_checked_malloc(sizeof(struct usbcan_usb));
1246                 if (!usbdevs->devs[j]) {
1247                         err("Out of memory");
1248                         goto error;
1249                 }
1250                 memset(usbdevs->devs[j], 0, sizeof(struct usbcan_usb));
1251                 dev=usbdevs->devs[j];
1252
1253                 mutex_init(&dev->io_mutex);
1254                 init_waitqueue_head(&dev->queue);
1255                 dev->udev = interface_to_usbdev(interface);
1256                 dev->interface = interface;
1257
1258                 /* set up the endpoint information */
1259                 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1260                         endpoint = &iface_desc->endpoint[i].desc;
1261
1262                         if (epnum==-1){
1263                                 was=0;
1264                                 for (k=0;k<j;k++){
1265                                         if ((usbdevs->devs[k]->bulk_in_endpointAddr & USB_ENDPOINT_NUMBER_MASK) == (endpoint->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK))
1266                                                 was=1;
1267                                 }
1268                                 if (was) continue;
1269                                 epnum=endpoint->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
1270                         }
1271
1272                         if (!dev->bulk_in_endpointAddr &&
1273                                         usb_endpoint_is_bulk_in(endpoint)) {
1274                                 if (epnum == (endpoint->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK)){
1275                                         /* we found a bulk in endpoint */
1276                                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1277                                         dev->bulk_in_size = buffer_size;
1278                                         dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
1279                                         dev->bulk_in_buffer = can_checked_malloc(buffer_size);
1280                                         if (!dev->bulk_in_buffer) {
1281                                                 err("Could not allocate bulk_in_buffer");
1282                                                 goto error;
1283                                         }
1284                                 }
1285                         }
1286
1287                         if (!dev->bulk_out_endpointAddr &&
1288                                         usb_endpoint_is_bulk_out(endpoint)) {
1289                                 if (epnum == (endpoint->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK)){
1290                                 /* we found a bulk out endpoint */
1291                                         dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
1292                                 }
1293                         }
1294
1295                 }
1296                 if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
1297                         err("Could not find all bulk-in and bulk-out endpoints for chip %d",j);
1298                         goto error;
1299                 }
1300         }
1301         /* save our data pointer in this interface device */
1302         usb_set_intfdata(interface, usbdevs);
1303
1304         if (!(usbdevs->candev=register_usbdev("usbcan",(void *) usbdevs, usbcan_register_devs)))
1305                 goto register_error;
1306
1307         /* let the user know what node this device is now attached to */
1308         CANMSG("USBCAN device now attached\n");
1309         return 0;
1310
1311 register_error:
1312         cleanup_usbdev(usbdevs->candev);
1313 error:
1314         if (usbdevs){
1315                 if (usbdevs->devs){
1316                         if (usbdevs->devs[0]){
1317                                 usb_put_dev(usbdevs->devs[0]->udev);
1318                         }
1319                         for (j=0;j<usbdevs->count;j++){
1320                                 if (!usbdevs->devs[j])  continue;
1321
1322                                 if (usbdevs->devs[j]->bulk_in_buffer)
1323                                         can_checked_free(usbdevs->devs[j]->bulk_in_buffer);
1324                                 if (usbdevs->devs[j]->chip){
1325                                         usbdevs->devs[j]->chip->chip_data=NULL;
1326                                 }
1327                                 can_checked_free(usbdevs->devs[j]);
1328                         }
1329                         can_checked_free(usbdevs->devs);
1330                 }
1331                 can_checked_free(usbdevs);
1332         }
1333 noalloc:
1334         return retval;
1335 }
1336
1337 // Physically disconnected device
1338 static void usbcan_disconnect(struct usb_interface *interface)
1339 {
1340         struct usbcan_devs *usbdevs;
1341         int j;
1342         usbdevs = usb_get_intfdata(interface);
1343         if (usbdevs==NULL){
1344                 CANMSG("USBCAN device seems to be removed\n");
1345                 return;
1346         }
1347         usb_set_intfdata(interface, NULL);
1348
1349         if (usbdevs->devs){
1350                 usb_put_dev((*usbdevs->devs)->udev);
1351         }
1352         cleanup_usbdev(usbdevs->candev);
1353         if (usbdevs->devs){
1354                 for (j=0;j<usbdevs->count;j++){
1355                         if (!usbdevs->devs[j])  continue;
1356
1357                         /* prevent more I/O from starting */
1358                         mutex_lock(&usbdevs->devs[j]->io_mutex);
1359                         usbdevs->devs[j]->interface = NULL;
1360                         mutex_unlock(&usbdevs->devs[j]->io_mutex);
1361
1362                         while (test_bit(USBCAN_THREAD_RUNNING,&usbdevs->devs[j]->flags))
1363                         {
1364                                 CANMSG("USBCAN thread has not stopped, trying to wake...\n");
1365                                 set_bit(USBCAN_TERMINATE,&usbdevs->devs[j]->flags);
1366                                 wake_up_process(usbdevs->devs[j]->comthread);
1367                                 schedule();
1368 //                      can_kthread_stop(dev->comthread);
1369                         }
1370
1371                         if (usbdevs->devs[j]->bulk_in_buffer)
1372                                 can_checked_free(usbdevs->devs[j]->bulk_in_buffer);
1373                         // if (usbdevs->devs[j]->chip){
1374                         //      usbdevs->devs[j]->chip->chip_data=NULL;
1375                         // }
1376                         can_checked_free(usbdevs->devs[j]);
1377                         usbdevs->devs[j]=NULL;
1378                 }
1379                 can_checked_free(usbdevs->devs);
1380         }
1381         can_checked_free(usbdevs);
1382
1383         CANMSG("USBCAN now disconnected\n");
1384 }
1385
1386 int usbcan_init(void){
1387         return usb_register(&usbcan_driver);
1388 }
1389
1390 void usbcan_exit(void){
1391         usb_deregister(&usbcan_driver);
1392 }