lincan/src/unican.c

   1 /* unican.c
   2  * Linux CAN-bus device driver.
   3  * Written for new CAN driver version by Pavel Pisa - OCERA team member
   4  * email:pisa@cmp.felk.cvut.cz
   5  * This software is released under the GPL-License.
   6  * Version lincan-0.2  9 Jul 2003
   7  */
   8
   9 #include "../include/can.h"
  10 #include "../include/can_sysdep.h"
  11 #include "../include/main.h"
  12 #include "../include/unican_cl2.h"
  13 #include "../include/setup.h"
  14
  15 #ifdef CAN_WITH_RTL
  16
  17 #endif /*CAN_WITH_RTL*/
  18
  19
  20 static void unican_delay(long msdelay)
  21 {
  22     #ifdef CAN_WITH_RTL
  23         if(!rtl_rt_system_is_idle()) {
  24                 rtl_delay(1000000l*msdelay);
  25         }else
  26     #endif /*CAN_WITH_RTL*/
  27         {
  28                 set_current_state(TASK_UNINTERRUPTIBLE);
  29                 schedule_timeout((msdelay*HZ)/1000+1);
  30         }
  31
  32 }
  33
  34
  35 long unican_bus_latency(struct msgobj_t *obj)
  36 {
  37         long latency;
  38         latency=obj->hostchip->baudrate;
  39         if(latency){
  40                 latency=(long)HZ*1000/latency;
  41         }
  42         return latency;
  43 }
  44
  45
  46 /* * * unican Chip Functionality * * */
  47
  48 int unican_enable_configuration(struct chip_t *chip)
  49 {
  50         return 0;
  51 }
  52
  53 int unican_disable_configuration(struct chip_t *chip)
  54 {
  55         return 0;
  56 }
  57
  58 /**
  59  * unican_chip_config: - can chip configuration
  60  * @chip: pointer to chip state structure
  61  *
  62  * Return Value: negative value reports error.
  63  * File: src/unican.c
  64  */
  65 int unican_chip_config(struct chip_t *chip)
  66 {
  67         int ret;
  68         sCAN_CARD *chipext = (sCAN_CARD *)chip->chip_data;
  69
  70         unican_delay(10);
  71
  72         /* disable all card interrupts */
  73         ret = cl2_int_mode(chipext, INT_MODE_ALL*0);
  74         if(ret != CL2_OK) {
  75                 CANMSG("disable interrupts by cl2_iit_mode returned %d\n",ret);
  76                 return -ENODEV;
  77         }
  78         unican_delay(1);
  79
  80         if (chip->baudrate == 0)
  81                 chip->baudrate=1000000;
  82
  83         ret = chip->chipspecops->baud_rate(chip,chip->baudrate,chip->clock,0,75,0);
  84         if(ret < 0){
  85                 CANMSG("can not set baudrate\n");
  86                 return ret;
  87         }
  88
  89         unican_delay(2);
  90         /* set interrupt inhibit time to 1 ms */
  91         ret = cl2_set_iit(chipext, 10);
  92         if(ret != CL2_OK) {
  93                 CANMSG("cl2_set_iit returned %d\n",ret);
  94                 return -ENODEV;
  95         }
  96         unican_delay(1);
  97
  98         /* enable start interrupt inhibit time command */
  99         ret = cl2_iit_mode(chipext, 1);
 100         if(ret != CL2_OK) {
 101                 CANMSG("cl2_iit_mode returned %d\n",ret);
 102                 return -ENODEV;
 103         }
 104         unican_delay(1);
 105
 106         /* enable all card interrupts */
 107         ret = cl2_int_mode(chipext, INT_MODE_ALL);
 108         if(ret != CL2_OK) {
 109                 CANMSG("cl2_iit_mode returned %d\n",ret);
 110                 return -ENODEV;
 111         }
 112         unican_delay(1);
 113
 114         /* generate interrupt command */
 115         cl2_gen_interrupt(chipext);
 116
 117
 118         return 0;
 119 }
 120
 121 /**
 122  * unican_extended_mask: - setup of extended mask for message filtering
 123  * @chip: pointer to chip state structure
 124  * @code: can message acceptance code
 125  * @mask: can message acceptance mask
 126  *
 127  * Return Value: negative value reports error.
 128  * File: src/unican.c
 129  */
 130 int unican_extended_mask(struct chip_t *chip, unsigned long code, unsigned  long mask)
 131 {
 132         return 0;
 133 }
 134
 135 /**
 136  * unican_baud_rate: - set communication parameters.
 137  * @chip: pointer to chip state structure
 138  * @rate: baud rate in Hz
 139  * @clock: frequency of sja1000 clock in Hz (ISA osc is 14318000)
 140  * @sjw: synchronization jump width (0-3) prescaled clock cycles
 141  * @sampl_pt: sample point in % (0-100) sets (TSEG1+1)/(TSEG1+TSEG2+2) ratio
 142  * @flags: fields %BTR1_SAM, %OCMODE, %OCPOL, %OCTP, %OCTN, %CLK_OFF, %CBP
 143  *
 144  * Return Value: negative value reports error.
 145  * File: src/unican.c
 146  */
 147 int unican_baud_rate(struct chip_t *chip, int rate, int clock, int sjw,
 148                                                         int sampl_pt, int flags)
 149 {
 150         int ret;
 151         sCAN_CARD *chipext = (sCAN_CARD *)chip->chip_data;
 152         int bt_val;
 153
 154         switch (rate) {
 155                 case 5000:   bt_val = CL2_BITRATE_5K; break;
 156                 case 10000:  bt_val = CL2_BITRATE_10K; break;
 157                 case 20000:  bt_val = CL2_BITRATE_20K; break;
 158                 case 50000:  bt_val = CL2_BITRATE_50K; break;
 159                 case 100000: bt_val = CL2_BITRATE_100K; break;
 160                 case 125000: bt_val = CL2_BITRATE_125K; break;
 161                 case 200000: bt_val = CL2_BITRATE_200K; break;
 162                 case 250000: bt_val = CL2_BITRATE_250K; break;
 163                 case 500000: bt_val = CL2_BITRATE_500K; break;
 164                 case 800000: bt_val = CL2_BITRATE_800K; break;
 165                 case 1000000:bt_val = CL2_BITRATE_1M; break;
 166                 default: return -EINVAL;
 167         }
 168
 169         ret=cl2_set_bitrate(chipext,bt_val);
 170         if(ret == CL2_COMMAND_BUSY) return -EBUSY;
 171         if(ret != CL2_OK) return -EINVAL;
 172         unican_delay(2);
 173
 174         return 0;
 175 }
 176
 177 /**
 178  * unican_read: - reads and distributes one or more received messages
 179  * @chip: pointer to chip state structure
 180  * @obj: pinter to CAN message queue information
 181  *
 182  * This is rewritten cl2_receive_data function. The direct use of CL2
 183  * function would require one more message data copy to reformat message
 184  * data into different structure layout. Other way is to rewrite CL2 sources.
 185  * No of these solutions is perfect.
 186  *
 187  * File: src/unican.c
 188  */
 189 void unican_read(struct chip_t *chip, struct msgobj_t *obj) {
 190         sCAN_CARD *chipext = (sCAN_CARD *)chip->chip_data;
 191         __u16 *ptr16;
 192         __u16 u;
 193         unsigned long timestamp;
 194         int i;
 195
 196         do {
 197                 ptr16 = (__u16*)chipext->rxBufPtr;
 198                 u = readw(ptr16++);
 199                 if ( !(u & CL2_MESSAGE_VALID) ) break; /* No more messages in the queue */
 200
 201                 obj->rx_msg.id = ((__u32)(u & 0xFF00 )) << 16;
 202                 u = readw(ptr16++);
 203                 obj->rx_msg.id |= ((__u32)( u & 0x00FF )) << 16;
 204                 obj->rx_msg.id |= (__u32)( u & 0xFF00 );
 205                 u = readw(ptr16++);
 206                 obj->rx_msg.id |= (__u32)( u & 0x00FF );
 207
 208
 209                 u >>= 8;
 210
 211                 if ( u & CL2_EXT_FRAME ) {      /* 2.0B frame */
 212                         obj->rx_msg.id >>= 3;
 213                         obj->rx_msg.flags = MSG_EXT;
 214                 } else {                        /* 2.0A frame */
 215                         obj->rx_msg.id >>= 21;
 216                         obj->rx_msg.flags = 0;
 217                 }
 218
 219                 /*if ( !(u & (CL2_REMOTE_FRAME<<8)) )
 220                         obj->rx_msg.flags |= MSG_RTR;*/
 221
 222                 obj->rx_msg.length = ( (u >> 4) & 0x000F );
 223                 if(obj->rx_msg.length > CAN_MSG_LENGTH) obj->rx_msg.length = CAN_MSG_LENGTH;
 224
 225                 for ( i = 0; i < obj->rx_msg.length; ) {
 226                         u = readw(ptr16++);
 227                         obj->rx_msg.data[i++] = (__u8)( u );
 228                         obj->rx_msg.data[i++] = (__u8)( u >> 8 );
 229                 }
 230                 if ( obj->rx_msg.length & 0x01 ) {      /* odd */
 231                         timestamp = ( (readw(ptr16++) & 0x00FF) | (u & 0xFF00) );
 232                 } else {                                /* even */
 233                         u = readw(ptr16++);
 234                         timestamp = (u << 8) | (u >> 8);
 235                 }
 236                 writew(0x000,(__u16*)chipext->rxBufPtr);
 237
 238                #ifdef CAN_MSG_VERSION_2
 239                 obj->rx_msg.timestamp.tv_sec = 0;
 240                 obj->rx_msg.timestamp.tv_usec = timestamp;
 241                #else /* CAN_MSG_VERSION_2 */
 242                 obj->rx_msg.timestamp = timestamp;
 243                #endif /* CAN_MSG_VERSION_2 */
 244
 245                 /* increment rx-buffer pointer */
 246                 if ( (chipext->rxBufBase + chipext->rxBufSize*16 ) <= (chipext->rxBufPtr += 16) ) {
 247                         chipext->rxBufPtr = chipext->rxBufBase;
 248                 }
 249
 250                 canque_filter_msg2edges(obj->qends, &obj->rx_msg);
 251
 252         } while (1);
 253 }
 254
 255 /**
 256  * unican_pre_read_config: - prepares message object for message reception
 257  * @chip: pointer to chip state structure
 258  * @obj: pointer to message object state structure
 259  *
 260  * Return Value: negative value reports error.
 261  *      Positive value indicates immediate reception of message.
 262  * File: src/unican.c
 263  */
 264 int unican_pre_read_config(struct chip_t *chip, struct msgobj_t *obj)
 265 {
 266         return 0;
 267 }
 268
 269 #define MAX_TRANSMIT_WAIT_LOOPS 10
 270 /**
 271  * unican_pre_write_config: - prepares message object for message transmission
 272  * @chip: pointer to chip state structure
 273  * @obj: pointer to message object state structure
 274  * @msg: pointer to CAN message
 275  *
 276  * Return Value: negative value reports error.
 277  * File: src/unican.c
 278  */
 279 int unican_pre_write_config(struct chip_t *chip, struct msgobj_t *obj,
 280                                                         struct canmsg_t *msg)
 281 {
 282         return 0;
 283 }
 284
 285 /**
 286  * unican_send_msg: - initiate message transmission
 287  * @chip: pointer to chip state structure
 288  * @obj: pointer to message object state structure
 289  * @msg: pointer to CAN message
 290  *
 291  * This function is called after unican_pre_write_config() function,
 292  * which prepares data in chip buffer.
 293  * Return Value: negative value reports error.
 294  * File: src/unican.c
 295  */
 296 int unican_send_msg(struct chip_t *chip, struct msgobj_t *obj,
 297                                                         struct canmsg_t *msg)
 298 {
 299         return 0;
 300 }
 301
 302 /**
 303  * unican_check_tx_stat: - checks state of transmission engine
 304  * @chip: pointer to chip state structure
 305  *
 306  * Return Value: negative value reports error.
 307  *      Positive return value indicates transmission under way status.
 308  *      Zero value indicates finishing of all issued transmission requests.
 309  * File: src/unican.c
 310  */
 311 int unican_check_tx_stat(struct chip_t *chip)
 312 {
 313         return 0;
 314 }
 315
 316 /**
 317  * unican_set_btregs: -  configures bitrate registers
 318  * @chip: pointer to chip state structure
 319  * @btr0: bitrate register 0
 320  * @btr1: bitrate register 1
 321  *
 322  * Return Value: negative value reports error.
 323  * File: src/unican.c
 324  */
 325 int unican_set_btregs(struct chip_t *chip, unsigned short btr0,
 326                                                         unsigned short btr1)
 327 {
 328         int ret;
 329         sCAN_CARD *chipext = (sCAN_CARD *)chip->chip_data;
 330         int bt_val;
 331
 332         bt_val=btr0 | (btr1<<8);
 333         ret=cl2_set_bitrate(chipext,bt_val);
 334         if(ret == CL2_COMMAND_BUSY) return -EBUSY;
 335         if(ret != CL2_OK) return -EINVAL;
 336
 337         return 0;
 338 }
 339
 340 /**
 341  * unican_stop_chip: -  starts chip message processing
 342  * @chip: pointer to chip state structure
 343  *
 344  * Return Value: negative value reports error.
 345  * File: src/unican.c
 346  */
 347 int unican_start_chip(struct chip_t *chip)
 348 {
 349         return 0;
 350 }
 351
 352 /**
 353  * unican_stop_chip: -  stops chip message processing
 354  * @chip: pointer to chip state structure
 355  *
 356  * Return Value: negative value reports error.
 357  * File: src/unican.c
 358  */
 359 int unican_stop_chip(struct chip_t *chip)
 360 {
 361         return 0;
 362 }
 363
 364
 365 /**
 366  * unican_remote_request: - configures message object and asks for RTR message
 367  * @chip: pointer to chip state structure
 368  * @obj: pointer to message object structure
 369  *
 370  * Return Value: negative value reports error.
 371  * File: src/unican.c
 372  */
 373 int unican_remote_request(struct chip_t *chip, struct msgobj_t *obj)
 374 {
 375         CANMSG("unican_remote_request not implemented\n");
 376         return -ENOSYS;
 377 }
 378
 379 /**
 380  * unican_standard_mask: - setup of mask for message filtering
 381  * @chip: pointer to chip state structure
 382  * @code: can message acceptance code
 383  * @mask: can message acceptance mask
 384  *
 385  * Return Value: negative value reports error.
 386  * File: src/unican.c
 387  */
 388 int unican_standard_mask(struct chip_t *chip, unsigned short code,
 389                 unsigned short mask)
 390 {
 391         CANMSG("unican_standard_mask not implemented\n");
 392         return -ENOSYS;
 393 }
 394
 395 /**
 396  * unican_clear_objects: - clears state of all message object residing in chip
 397  * @chip: pointer to chip state structure
 398  *
 399  * Return Value: negative value reports error.
 400  * File: src/unican.c
 401  */
 402 int unican_clear_objects(struct chip_t *chip)
 403 {
 404         CANMSG("unican_clear_objects not implemented\n");
 405         return -ENOSYS;
 406 }
 407
 408 /**
 409  * unican_config_irqs: - tunes chip hardware interrupt delivery
 410  * @chip: pointer to chip state structure
 411  * @irqs: requested chip IRQ configuration
 412  *
 413  * Return Value: negative value reports error.
 414  * File: src/unican.c
 415  */
 416 int unican_config_irqs(struct chip_t *chip, short irqs)
 417 {
 418
 419         CANMSG("unican_config_irqs not implemented\n");
 420         return -ENOSYS;
 421 }
 422
 423 /**
 424  * unican_irq_write_handler: - part of ISR code responsible for transmit events
 425  * @chip: pointer to chip state structure
 426  * @obj: pointer to attached queue description
 427  *
 428  * The main purpose of this function is to read message from attached queues
 429  * and transfer message contents into CAN controller chip.
 430  * This subroutine is called by
 431  * unican_irq_write_handler() for transmit events.
 432  * File: src/unican.c
 433  */
 434 void unican_irq_write_handler(struct chip_t *chip, struct msgobj_t *obj)
 435 {
 436         int cmd;
 437         sCAN_CARD *chipext = (sCAN_CARD *)chip->chip_data;
 438         __u16 *ptr16 = (__u16*)chipext->rxBufPtr;
 439         __u16 u;
 440         unsigned long timestamp=0;
 441         unsigned long cobid;
 442         int i;
 443         int len;
 444
 445        #if 0
 446         if(obj->tx_slot){
 447                 /* Do local transmitted message distribution if enabled */
 448                 if (processlocal){
 449                         obj->tx_slot->msg.flags |= MSG_LOCAL;
 450                         canque_filter_msg2edges(obj->qends, &obj->tx_slot->msg);
 451                 }
 452                 /* Free transmitted slot */
 453                 canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
 454                 obj->tx_slot=NULL;
 455         }
 456        #endif
 457
 458         if ( chipext->asyncTxBufSize==0 ) {
 459                 canque_notify_inends(obj->tx_qedge, CANQUEUE_NOTIFY_ERRTX_PREP);
 460                 return; /* No asynchronous queue configured */
 461         }
 462
 463         do {
 464                 ptr16 = (__u16*)chipext->asyncTxBufPtr;
 465                 if(readw(ptr16) & CL2_MESSAGE_VALID)
 466                         return;         /* No free space in asynchronous Tx queue */
 467
 468                 cmd=canque_test_outslot(obj->qends, &obj->tx_qedge, &obj->tx_slot);
 469                 if(cmd<0)
 470                         return;         /* No more messages to send */
 471
 472
 473                 cobid = obj->tx_slot->msg.id;
 474
 475                 if ( (obj->tx_slot->msg.flags & MSG_EXT) ) {    /* 2.0B frame */
 476                         cobid <<= 3;
 477                 } else {                                        /* 2.0A frame */
 478                         cobid <<= 5+16;
 479                 }
 480                 ptr16++;
 481                 u = ((cobid>>16) & 0x00FF ) + (cobid & 0xFF00);
 482                 writew(u,ptr16++);
 483
 484                 len = obj->tx_slot->msg.length;
 485                 if(len > CAN_MSG_LENGTH)
 486                         len = CAN_MSG_LENGTH;
 487                 u = (len << 12) | (cobid & 0x00FF);
 488
 489                 if ( !(obj->tx_slot->msg.flags & MSG_RTR) )
 490                         u |= CL2_REMOTE_FRAME<<8;
 491                 if ( obj->tx_slot->msg.flags & MSG_EXT )
 492                         u |= CL2_EXT_FRAME<<8;
 493
 494                 writew(u,ptr16++);
 495
 496                 for ( i = 0; i < len-1; )       {
 497                         u = obj->tx_slot->msg.data[i++];
 498                         u |= ((__u16)obj->tx_slot->msg.data[i]<<8); i++;
 499                         writew(u,ptr16++);
 500                 }
 501                 if(i == len) {
 502                         writew(timestamp,ptr16);
 503                 } else {
 504                         u = obj->tx_slot->msg.data[i++];
 505                         u |= ((timestamp & 0x00FF)<<8);
 506                         writew(u,ptr16++);
 507                         writew(timestamp & 0x00FF, ptr16);
 508                 }
 509
 510                 u = ((cobid>>16) & 0xFF00) | CL2_MESSAGE_VALID;
 511                 writew(u,(__u16*)chipext->asyncTxBufPtr);
 512
 513                 if ( (chipext->asyncTxBufBase + chipext->asyncTxBufSize*16) <=
 514                                                 (chipext->asyncTxBufPtr += 16) ) {
 515                         chipext->asyncTxBufPtr = chipext->asyncTxBufBase;
 516                 }
 517
 518
 519                 /* Do local transmitted message distribution if enabled. */
 520                 /* This code should not be called directly there, because it breaks strict
 521                    behavior of queues if O_SYNC is set. */
 522                 if (processlocal){
 523                         obj->tx_slot->msg.flags |= MSG_LOCAL;
 524                         canque_filter_msg2edges(obj->qends, &obj->tx_slot->msg);
 525                 }
 526                 /* Free transmitted slot */
 527                 canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
 528                 obj->tx_slot=NULL;
 529
 530         }while(1);
 531
 532         return;
 533
 534 }
 535
 536 void unican_irq_sync_activities(struct chip_t *chip, struct msgobj_t *obj)
 537 {
 538         while(!can_msgobj_test_and_set_fl(obj,TX_LOCK)) {
 539
 540                 if(can_msgobj_test_and_clear_fl(obj,TX_REQUEST)) {
 541                         unican_irq_write_handler(chip, obj);
 542                 }
 543
 544                 /*if(can_msgobj_test_and_clear_fl(obj,FILTCH_REQUEST)) {
 545                         unican_irq_update_filter(chip, obj);
 546                 }*/
 547
 548                 can_msgobj_clear_fl(obj,TX_LOCK);
 549                 if(can_msgobj_test_fl(obj,TX_REQUEST))
 550                         continue;
 551                 if(can_msgobj_test_fl(obj,FILTCH_REQUEST) && !obj->tx_slot)
 552                         continue;
 553                 break;
 554         }
 555 }
 556
 557
 558 #define MAX_RETR 10
 559
 560 /**
 561  * unican_irq_handler: - interrupt service routine
 562  * @irq: interrupt vector number, this value is system specific
 563  * @dev_id: driver private pointer registered at time of request_irq() call.
 564  *      The CAN driver uses this pointer to store relationship of interrupt
 565  *      to chip state structure - @struct chip_t
 566  * @regs: system dependent value pointing to registers stored in exception frame
 567  *
 568  * Interrupt handler is activated when state of CAN controller chip changes,
 569  * there is message to be read or there is more space for new messages or
 570  * error occurs. The receive events results in reading of the message from
 571  * CAN controller chip and distribution of message through attached
 572  * message queues.
 573  * File: src/unican.c
 574  */
 575 can_irqreturn_t unican_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
 576 {
 577         struct chip_t *chip=(struct chip_t *)dev_id;
 578         sCAN_CARD *chipext = (sCAN_CARD *)chip->chip_data;
 579         struct msgobj_t *obj=chip->msgobj[0];
 580         __u16 status;
 581         __u16 error;
 582
 583         if(!(chip->flags&CHIP_CONFIGURED)) {
 584                 CANMSG("unican_irq_handler: called for non-configured device\n");
 585                 return CAN_IRQ_NONE;
 586         }
 587
 588         if (cl2_get_status(chipext, &status) == CL2_NO_REQUEST)
 589                 return CAN_IRQ_NONE;
 590
 591         cl2_clear_interrupt(chipext);
 592
 593
 594         if(status & CL2_CARD_ERROR) {
 595                 cl2_get_error(chipext, &error);
 596                 CANMSG("unican_irq_handler: card status=0x%04x error=0x%04x \n",status,error);
 597         }
 598         if(status & CL2_ASYNC_QUEUE_EMPTY) {
 599
 600         }
 601         if(status & CL2_SYNC_QUEUE_EMPTY) {
 602                 can_msgobj_set_fl(obj,TX_REQUEST);
 603
 604                 /* calls unican_irq_write_handler synchronized with other invocations */
 605                 unican_irq_sync_activities(chip, obj);
 606
 607         }
 608         if(status & CL2_DATA_IN_RBUF) {
 609                 unican_read(chip, obj);
 610         }
 611
 612         cl2_gen_interrupt(chipext);
 613
 614         return CAN_IRQ_HANDLED;
 615 }
 616
 617
 618 /*void unican_do_tx_timeout(unsigned long data)
 619 {
 620         struct msgobj_t *obj=(struct msgobj_t *)data;
 621
 622 }*/
 623
 624 /**
 625  * unican_wakeup_tx: - wakeups TX processing
 626  * @chip: pointer to chip state structure
 627  * @obj: pointer to message object structure
 628  *
 629  * Return Value: negative value reports error.
 630  * File: src/unican.c
 631  */
 632 int unican_wakeup_tx(struct chip_t *chip, struct msgobj_t *obj)
 633 {
 634         can_preempt_disable();
 635
 636         can_msgobj_set_fl(obj,TX_REQUEST);
 637
 638         /* calls unican_irq_write_handler synchronized with other invocations
 639           from kernel and IRQ context */
 640         unican_irq_sync_activities(chip, obj);
 641
 642         can_preempt_enable();
 643
 644         return 0;
 645 }
 646
 647
 648 /* * * unican Board Functionality * * */
 649
 650 #define IO_RANGE 0x1000
 651
 652 /**
 653  * unican_request_io: - reserve io or memory range for can board
 654  * @candev: pointer to candevice/board which asks for io. Field @io_addr
 655  *      of @candev is used in most cases to define start of the range
 656  *
 657  * Return Value: The function returns zero on success or %-ENODEV on failure
 658  * File: src/unican.c
 659  */
 660 int unican_request_io(struct candevice_t *candev)
 661 {
 662         unsigned long remap_addr;
 663         if (!can_request_mem_region(candev->io_addr,IO_RANGE,DEVICE_NAME " - unican")) {
 664                 CANMSG("Unable to request IO-memory: 0x%lx\n",candev->io_addr);
 665                 return -ENODEV;
 666         }
 667         if ( !( remap_addr = (long) ioremap( candev->io_addr, IO_RANGE ) ) ) {
 668                 CANMSG("Unable to access I/O memory at: 0x%lx\n", candev->io_addr);
 669                 can_release_mem_region(candev->io_addr,IO_RANGE);
 670                 return -ENODEV;
 671
 672         }
 673         can_base_addr_fixup(candev, remap_addr);
 674         DEBUGMSG("Registered IO-memory: 0x%lx - 0x%lx\n", candev->io_addr, candev->io_addr + IO_RANGE - 1);
 675         return 0;
 676 }
 677
 678 /**
 679  * unican_elease_io - free reserved io memory range
 680  * @candev: pointer to candevice/board which releases io
 681  *
 682  * Return Value: The function always returns zero
 683  * File: src/unican.c
 684  */
 685 int unican_release_io(struct candevice_t *candev)
 686 {
 687         iounmap((void*)candev->dev_base_addr);
 688         can_release_mem_region(candev->io_addr,IO_RANGE);
 689         return 0;
 690 }
 691
 692 /**
 693  * unican_reset - hardware reset routine
 694  * @candev: Pointer to candevice/board structure
 695  *
 696  * Return Value: The function returns zero on success or %-ENODEV on failure
 697  * File: src/unican.c
 698  */
 699 int unican_reset(struct candevice_t *candev)
 700 {
 701         int ret;
 702         int i;
 703         struct chip_t *chip = candev->chip[0];
 704         sCAN_CARD *chipext;
 705
 706
 707         if(chip->chip_data == NULL) {
 708                 chip->chip_data = can_checked_malloc(sizeof(sCAN_CARD));
 709                 if(!chip->chip_data) return -ENOMEM;
 710                 memset(chip->chip_data,0,sizeof(sCAN_CARD));
 711                 ret = cl2_init_card(chip->chip_data,(void*)chip->chip_base_addr,chip->chip_irq);
 712                 if(ret != CL2_OK){
 713                         CANMSG("cl2_init_card returned %d\n",ret);
 714                         return -ENODEV;
 715                 }
 716         }
 717
 718         chipext = (sCAN_CARD *)chip->chip_data;
 719
 720         i = 0;
 721         /* reset and test whether the card is present */
 722         do {
 723                 cl2_reset_card(chipext);
 724                 unican_delay(10);
 725                 i++;
 726                 ret = cl2_test_card(chipext);
 727         } while((ret != CL2_OK)&&(i<10));
 728
 729         if(ret != CL2_OK) {
 730                 CANMSG("card check failed %d\n",ret);
 731                 return -ENODEV;
 732         }
 733
 734         /* start card firmware */
 735         ret = cl2_start_firmware(chipext);
 736         if(ret != CL2_OK){
 737                 CANMSG("cl2_start_firmware returned %d\n",ret);
 738                 return -ENODEV;
 739         }
 740
 741         unican_delay(100);
 742
 743         return 0;
 744 }
 745
 746 /**
 747  * unican_init_hw_data - Initialize hardware cards
 748  * @candev: Pointer to candevice/board structure
 749  *
 750  * Return Value: The function always returns zero
 751  * File: src/unican.c
 752  */
 753 int unican_init_hw_data(struct candevice_t *candev)
 754 {
 755         candev->res_addr=0;
 756         candev->nr_82527_chips=0;
 757         candev->nr_sja1000_chips=0;
 758         candev->nr_all_chips=1;
 759         candev->flags |= CANDEV_PROGRAMMABLE_IRQ*0;
 760
 761         return 0;
 762 }
 763
 764 #define CHIP_TYPE "unican"
 765
 766 /**
 767  * unican_init_chip_data - Initialize chips
 768  * @candev: Pointer to candevice/board structure
 769  * @chipnr: Number of the CAN chip on the hardware card
 770  *
 771  * Return Value: The function always returns zero
 772  * File: src/unican.c
 773  */
 774 int unican_init_chip_data(struct candevice_t *candev, int chipnr)
 775 {
 776         struct chip_t *chip = candev->chip[chipnr];
 777         chip->chip_type = CHIP_TYPE;
 778         chip->chip_base_addr = 0;
 779         chip->clock = 10000000;
 780         chip->int_clk_reg = 0x0;
 781         chip->int_bus_reg = 0x0;
 782         chip->max_objects = 1;
 783         chip->chip_base_addr=candev->io_addr;
 784
 785         CANMSG("initializing unican chip operations\n");
 786         chip->chipspecops->chip_config=unican_chip_config;
 787         chip->chipspecops->baud_rate=unican_baud_rate;
 788         chip->chipspecops->standard_mask=unican_standard_mask;
 789         chip->chipspecops->extended_mask=unican_extended_mask;
 790         chip->chipspecops->message15_mask=unican_extended_mask;
 791         chip->chipspecops->clear_objects=unican_clear_objects;
 792         chip->chipspecops->config_irqs=unican_config_irqs;
 793         chip->chipspecops->pre_read_config=unican_pre_read_config;
 794         chip->chipspecops->pre_write_config=unican_pre_write_config;
 795         chip->chipspecops->send_msg=unican_send_msg;
 796         chip->chipspecops->check_tx_stat=unican_check_tx_stat;
 797         chip->chipspecops->wakeup_tx=unican_wakeup_tx;
 798         chip->chipspecops->remote_request=unican_remote_request;
 799         chip->chipspecops->enable_configuration=unican_enable_configuration;
 800         chip->chipspecops->disable_configuration=unican_disable_configuration;
 801         chip->chipspecops->set_btregs=unican_set_btregs;
 802         chip->chipspecops->start_chip=unican_start_chip;
 803         chip->chipspecops->stop_chip=unican_stop_chip;
 804         chip->chipspecops->irq_handler=unican_irq_handler;
 805
 806         return 0;
 807 }
 808
 809 /**
 810  * unican_init_obj_data - Initialize message buffers
 811  * @chip: Pointer to chip specific structure
 812  * @objnr: Number of the message buffer
 813  *
 814  * Return Value: The function always returns zero
 815  * File: src/unican.c
 816  */
 817 int unican_init_obj_data(struct chip_t *chip, int objnr)
 818 {
 819         struct msgobj_t *obj=chip->msgobj[objnr];
 820         obj->obj_base_addr=chip->chip_base_addr;
 821         /*obj->tx_timeout.function=unican_do_tx_timeout;
 822         obj->tx_timeout.data=(unsigned long)obj;*/
 823         return 0;
 824 }
 825
 826 /**
 827  * unican_program_irq - program interrupts
 828  * @candev: Pointer to candevice/board structure
 829  *
 830  * Return value: The function returns zero on success or %-ENODEV on failure
 831  * File: src/unican.c
 832  */
 833 int unican_program_irq(struct candevice_t *candev)
 834 {
 835         return 0;
 836 }
 837
 838 int unican_register(struct hwspecops_t *hwspecops)
 839 {
 840         hwspecops->request_io = unican_request_io;
 841         hwspecops->release_io = unican_release_io;
 842         hwspecops->reset = unican_reset;
 843         hwspecops->init_hw_data = unican_init_hw_data;
 844         hwspecops->init_chip_data = unican_init_chip_data;
 845         hwspecops->init_obj_data = unican_init_obj_data;
 846         hwspecops->write_register = NULL;
 847         hwspecops->read_register = NULL;
 848         hwspecops->program_irq = unican_program_irq;
 849         return 0;
 850 }