lpc17xx embedded: new function for obtaining chip bittiming constant parameters.
[lincan.git] / embedded / app / usbcan / main.c
1 /**************************************************************************/
2 /* File: main.c - setup and main loop of USB<->CAN converter              */
3 /*                                                                        */
4 /* LinCAN - (Not only) Linux CAN bus driver                               */
5 /* Copyright (C) 2002-2011 DCE FEE CTU Prague <http://dce.felk.cvut.cz>   */
6 /* Copyright (C) 2008 Jan Kriz email:johen@post.cz                        */
7 /*                                                                        */
8 /* LinCAN is free software; you can redistribute it and/or modify it      */
9 /* under terms of the GNU General Public License as published by the      */
10 /* Free Software Foundation; either version 2, or (at your option) any    */
11 /* later version.  LinCAN is distributed in the hope that it will be      */
12 /* useful, but WITHOUT ANY WARRANTY; without even the implied warranty    */
13 /* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU    */
14 /* General Public License for more details. You should have received a    */
15 /* copy of the GNU General Public License along with LinCAN; see file     */
16 /* COPYING. If not, write to the Free Software Foundation, 675 Mass Ave,  */
17 /* Cambridge, MA 02139, USA.                                              */
18 /*                                                                        */
19 /* To allow use of LinCAN in the compact embedded systems firmware        */
20 /* and RT-executives (RTEMS for example), main authors agree with next    */
21 /* special exception:                                                     */
22 /*                                                                        */
23 /* Including LinCAN header files in a file, instantiating LinCAN generics */
24 /* or templates, or linking other files with LinCAN objects to produce    */
25 /* an application image/executable, does not by itself cause the          */
26 /* resulting application image/executable to be covered by                */
27 /* the GNU General Public License.                                        */
28 /* This exception does not however invalidate any other reasons           */
29 /* why the executable file might be covered by the GNU Public License.    */
30 /* Publication of enhanced or derived LinCAN files is required although.  */
31 /**************************************************************************/
32
33 #include <stdio.h>
34 #include <string.h>
35 #include <cpu_def.h>
36 #include <system_def.h>
37 #include <lt_timer.h>
38 #include <local_config.h>
39 #include <usb/usbdebug.h>
40 #include <usb/usb.h>
41 #include <usb/lpc.h>
42 #include <usb/usb_srq.h>
43 #include <mem_loc.h>
44 #include <keyval_id.h>
45 #include <hal_machperiph.h>
46 #include <keyval_loc.h>
47 #include <lpciap.h>
48 #include <lpciap_kvpb.h>
49
50 #include <endian.h>
51 #if __BYTE_ORDER == __BIG_ENDIAN
52   #include <byteswap.h>
53 #endif
54
55 #include "./can/can.h"
56 #include "./can/sja1000p.h"
57 #include "./can/main.h"
58
59 // #include "./can/can_sysdep.h"
60 #include "./can/modparms.h"
61 #include "./can/devcommon.h"
62
63 //#include "./can/ul_usb1.h"
64
65 #include "./can/setup.h"
66
67 #include "./usb/usb_defs.h"
68 #include "./usb/usb_vend.h"
69
70 extern int can_lmc1_register(struct hwspecops_t *hwspecops);
71
72 #define MASK_EP1RX  0x01
73 #define MASK_EP1TX  0x02
74
75 #define CAN_OP_MASK 0x80
76 #define CAN_OP_READ 0x80
77 #define CAN_OP_WRITE 0x00
78
79 #ifdef USB_MAX_PACKET
80         #undef USB_MAX_PACKET
81         #define USB_MAX_PACKET 16
82 #endif
83 /***********************************************************************
84  * Note:
85  * Comparing to LinCAN, there is no need to sleep for processes
86  * because the degree of filling of fifo from the client side
87  * is solved in main cycle (no new messages are accepted when full)
88  * and on the server side by speed of USB interface. FIFO in edge
89  * from SJA chip to USB interface should never be filled.
90  ***********************************************************************/
91
92 /***********************************************************************
93  * Note:
94  * Code is wittingly complex in order to ease future changes in hardware
95  *¬†configuration and to make it as much similar as the code of LinCAN
96  ***********************************************************************/
97
98 LT_TIMER_DEC(lt_10msec)
99 LT_TIMER_IMP(lt_10msec)
100 LT_TIMER_DEC(lt_100msec)
101 LT_TIMER_IMP(lt_100msec)
102 LT_TIMER_DEC(lt_2sec)
103 LT_TIMER_IMP(lt_2sec)
104
105 typedef void (*FNC)(); //function ptr
106
107 /***********************************************************************
108  * global variables
109  ***********************************************************************/
110
111 usb_device_t usb_device;
112
113 usb_ep_t eps[NUM_ENDPOINTS];
114 unsigned char ep1_rx_buff[USB_MAX_PACKET];
115 unsigned char ep1_tx_buff[USB_MAX_PACKET];
116 uint8_t timer_str,timer_rx_off,timer_tx_off,timer_configured;
117 volatile uint8_t bootloader_run;
118
119 uint8_t vendor_ret;
120
121 int processlocal;
122
123 int baudrate[MAX_TOT_CHIPS];
124 struct canhardware_t canhardware;
125 struct canhardware_t *hardware_p=&canhardware;
126 struct canchip_t *chips_p[MAX_TOT_CHIPS];
127 struct msgobj_t *objects_p[MAX_TOT_MSGOBJS];
128
129 struct canuser_t *canuser;
130
131 extern int init_chip_struct(struct candevice_t *candev, int chipnr, int irq, long baudrate);
132 extern int register_chip_struct(struct canchip_t *chip, int minorbase);
133 extern int register_obj_struct(struct msgobj_t *obj, int minorbase);
134
135 /***********************************************************************
136  * IF SOMETHING BAD HAPPENED
137  ***********************************************************************/
138
139 int sys_err(){
140   
141   unsigned char i=0;
142
143   while(1) {
144     if (lt_100msec_expired(100)) {
145       i++;
146       if (i&1) {
147         SET_OUT_PIN(LED_PORT,LED_ERR);
148       } else {
149         CLR_OUT_PIN(LED_PORT,LED_ERR);
150       }
151      #ifdef WATCHDOG_ENABLED
152       watchdog_feed();
153      #endif /* WATCHDOG_ENABLED */
154     }
155   }
156 }
157
158 /***********************************************************************
159  * Microsecond delay routine
160  ***********************************************************************/
161 /*
162 void udelay(long time)
163 {
164   volatile long ticks=(time * CCLK) / 2000000;
165   do{
166     ticks--;
167   } while(ticks>0);
168 }
169 */
170
171 /***********************************************************************
172  * Routine for visible LED blinking (on USB transmission)
173  ***********************************************************************/
174
175 void timer_10ms(void)
176 {
177   if (timer_tx_off!=0) timer_tx_off--;
178   else SET_OUT_PIN(LED_PORT,LED1_BIT);
179   if (timer_rx_off!=0) timer_rx_off--;
180   else SET_OUT_PIN(LED_PORT,LED2_BIT);
181
182 /*  if (timer_configured!=0) timer_configured--;
183   else {
184     timer_configured=20;
185                 CLR_OUT_PIN(LED_PORT,LED1_BIT);
186                 CLR_OUT_PIN(LED_PORT,LED2_BIT);
187                 timer_rx_off=timer_tx_off=5;
188   }*/
189 }
190
191 /***********************************************************************
192  * Main routine
193  ***********************************************************************/
194
195 int main(void)
196 {
197         struct candevice_t *candev;
198         struct canchip_t *chip=NULL;
199         struct msgobj_t *obj;
200         struct canque_ends_t *qends;
201         struct canque_edge_t *edge,*qedge;
202         struct canque_slot_t *slot;
203         struct canmsg_t canmsg;
204         can_spin_irqflags_t iflags;
205
206         int chipnr,bd;
207         int i,size,m=0;
208
209         CANMSG("Starting USBCAN module firmware...\n");
210
211 //      volatile int i=0;
212         bootloader_run=0;
213         /***********************************/
214
215         lt_10msec_init();
216         lt_100msec_init();
217         lt_2sec_init();
218
219         // DEBUG
220         //SET_OUT_PIN(LED_PORT,LED_ERR);
221         //CLR_OUT_PIN(LED_PORT,LED_GP);
222
223         if (USB_MAX_PACKET<16){
224                 CANMSG("Maximum packet size less than 16B (is %dB)\n",USB_MAX_PACKET);
225                 sys_err();
226         }
227
228
229         // ***********************************************************************
230         // * CAN device initialization - device side (adapted from LinCAN setup.c)
231         // ***********************************************************************
232
233 //      useless with lpc17xx (defined in can_lpcbusemu.c)
234 //      can_init();
235
236
237         DEBUGMSG("Initiating CAN device initialization\n");
238         baudrate[0]=1000;
239
240         canqueue_kern_initialize();
241
242         hardware_p->nr_boards=1;
243
244         candev=(struct candevice_t *)malloc(sizeof(struct candevice_t));
245         if (!candev){
246                 CANMSG("No space left in memory\n");
247                 sys_err();
248         }
249         memset(candev, 0, sizeof(struct candevice_t));
250
251         hardware_p->candevice[0]=candev;
252         candev->candev_idx=0;
253         candev->io_addr=0;
254         candev->dev_base_addr=0;
255
256         candev->hwspecops=(struct hwspecops_t *)malloc(sizeof(struct hwspecops_t));
257         if (!candev->hwspecops){
258                 CANMSG("No space left in memory\n");
259                 sys_err();
260         }
261         memset(candev->hwspecops, 0, sizeof(struct hwspecops_t));
262
263         
264
265         // DEBUG
266         //ul_usb1_register(candev->hwspecops);  //(defined in ul_usb1.c)
267         // register for another board:
268         can_lmc1_register(candev->hwspecops);
269
270         
271
272         bd=baudrate[0];
273         if (candev->hwspecops->init_hw_data(candev)){
274                 CANMSG("HW data could not be initialized\n");
275                 sys_err();
276         }
277
278         // Alocate and initialize the chip structures
279         for (chipnr=0; chipnr < candev->nr_all_chips; chipnr++) {
280 //              if(chipnr<irqnum)
281 //                      irqsig=irq[*irq_param_idx_p+chipnr];
282                 if (init_chip_struct(candev, chipnr, 0, bd*1000)){
283                         CANMSG("Chip structure could not be initialized\n");
284                         sys_err();
285                 }
286         }
287
288
289
290         for (chipnr=0; chipnr < candev->nr_all_chips; chipnr++) {
291                 struct canchip_t *chip=candev->chip[chipnr];
292                 int objnr;
293
294                 register_chip_struct(chip, m);
295
296                 for (objnr=0; objnr<chip->max_objects; objnr++) {
297                         register_obj_struct(chip->msgobj[objnr], m);
298                         if(m>=0) m++;
299                 }
300         }
301
302
303         if (candev->hwspecops->request_io(candev))
304                 sys_err();
305         candev->flags|=CANDEV_IO_RESERVED;
306
307
308         if (candev->hwspecops->reset(candev))
309                 sys_err();
310
311
312         for(chipnr=0; chipnr<candev->nr_all_chips; chipnr++) {
313                 if((chip=candev->chip[chipnr])==NULL)
314                         continue;
315
316                 if(chip->chipspecops->attach_to_chip(chip)<0) {
317 //                      CANMSG("Initial attach to the chip HW failed\n");
318                         sys_err();
319                 }
320
321                 chip->flags |= CHIP_ATTACHED;
322
323                 // used with lpc17xx:
324                 if(can_chip_setup_irq(chip)<0) {
325                         CANMSG("Error to setup chip IRQ\n");
326                         sys_err();
327                 }
328
329         }
330
331         if (candev->flags & CANDEV_PROGRAMMABLE_IRQ)
332                 if (candev->hwspecops->program_irq(candev)){
333 //                      CANMSG("Error to program board interrupt\n");
334                         sys_err();
335                 }
336
337         //***********************************************************************
338         // * CAN device initialization - client side (adapted from LinCAN open.c)
339         // ***********************************************************************
340
341
342         chip=candev->chip[0];
343         obj=chip->msgobj[0];
344         atomic_inc(&obj->obj_used);
345         can_msgobj_set_fl(obj,OPENED);
346
347         if (chip->flags & CHIP_CONFIGURED)
348                 DEBUGMSG("Device is already configured.\n");
349         else {
350                 if (chip->chipspecops->chip_config(chip))
351                         CANMSG("Error configuring chip.\n");
352                 else
353                         chip->flags |= CHIP_CONFIGURED;
354
355                 if (chip->chipspecops->pre_read_config(chip,obj)<0)
356                         CANMSG("Error initializing chip for receiving\n");
357
358         } // End of chip configuration
359
360
361         canuser = (struct canuser_t *)malloc(sizeof(struct canuser_t));
362         if(canuser == NULL) sys_err();
363         canuser->flags=0;
364 //      canuser->userinfo.fileinfo.file = file;
365         canuser->msgobj = obj;
366 //      canuser->magic = CAN_USER_MAGIC;
367 //      file->private_data = canuser;
368
369         qends = (struct canque_ends_t *)malloc(sizeof(struct canque_ends_t));
370         if(qends == NULL) sys_err();
371         canqueue_ends_init_kern(qends);
372         canuser->qends = qends;
373
374         //required to synchronize with RT-Linux context
375         can_spin_lock_irqsave(&canuser_manipulation_lock, iflags);
376         list_add(&canuser->peers, &obj->obj_users);
377         can_spin_unlock_irqrestore(&canuser_manipulation_lock, iflags);
378
379         if(canqueue_connect_edge(edge=canque_new_edge_kern(MAX_BUF_LENGTH),
380                 canuser->qends, obj->qends)<0) sys_err();
381
382         if(canqueue_connect_edge(canuser->rx_edge0=canque_new_edge_kern(MAX_BUF_LENGTH),
383                 obj->qends, canuser->qends)<0) sys_err();
384         //FIXME: more generic model should be used there
385         canque_edge_decref(canuser->rx_edge0);
386         canque_edge_decref(edge);
387
388
389
390         /***********************************************************************
391          * USB Init
392          ***********************************************************************/
393
394         memset( &usb_device, 0, sizeof( usb_device));
395         usb_device.id = 1;
396         usb_device.devdes_table = &usb_devdes_table;
397         usb_device.init = usb_lpc_init;
398         usb_debug_set_level(DEBUG_LEVEL_NONE);
399         usb_device.cntep = NUM_ENDPOINTS;
400         usb_device.ep = eps;
401
402         eps[0].max_packet_size = USB_MAX_PACKET;
403         eps[1].max_packet_size = USB_MAX_PACKET;
404         eps[0].epnum = 0x01;
405         eps[1].epnum = 0x81;
406         eps[0].event_mask = 0x04;
407         eps[1].event_mask = 0x08;
408         eps[0].udev = &usb_device;
409         eps[1].udev = &usb_device;
410
411         usb_device.vendor_fnc=usbcan_vendor;
412
413         usb_init(&usb_device);
414         usb_connect(&usb_device);
415         usb_device.ep_events |= MASK_EP1TX;
416
417         /***********************************************************************
418          * Start
419          ***********************************************************************/
420
421         timer_rx_off=timer_tx_off=timer_str=timer_configured=0;
422
423
424         printf("Main loop\n");
425
426         while (1) {
427
428                 usb_check_events(&usb_device);
429                 usb_control_response(&usb_device);
430
431 // useless with lpc17xx:
432 //              if (!(IO0PIN&P0_SJA1000_INT_PIN)) //INT PIN is inverted
433 //                      chip->chipspecops->irq_handler(0,chip);
434
435                 if (usb_device.ep_events & MASK_EP1RX) {  //EP1RX - data waiting to receive
436                         
437                         if (canque_get_inslot(qends, &qedge, &slot, 0)>=0){ //Free slot obtained
438
439                                 size=usb_udev_read_endpoint(&eps[0],ep1_rx_buff,16);
440                                 if (size==16){
441                                         uint16_t msgflags;
442                                         uint32_t msgid;
443                                         canmsg.cob=0;
444                                         canmsg.length=*(uint8_t *)(ep1_rx_buff+1);
445                                         if (canmsg.length > CAN_MSG_LENGTH)
446                                                 canmsg.length=CAN_MSG_LENGTH;
447                                         msgflags=*(uint16_t *)(ep1_rx_buff+2);
448                                         msgid=*(uint32_t *)(ep1_rx_buff+4);
449                                         #if __BYTE_ORDER == __BIG_ENDIAN
450                                                 msgflags  = bswap_16( msgflags);
451                                                 msgid  = bswap_32( msgid);
452                                         #endif
453                                         canmsg.flags=msgflags;
454                                         canmsg.id=msgid;
455
456                                         for (i=0;i<canmsg.length;i++){
457                                                 canmsg.data[i]=*(unsigned char*)(ep1_rx_buff+8+i);
458                                         }
459                                         for (;i<CAN_MSG_LENGTH;i++){
460                                                 canmsg.data[i]=0;
461                                         }
462                                         /* Automatic selection of extended format if ID>2047 */
463                                         if (canmsg.id & ~0x7ffl & MSG_ID_MASK ) canmsg.flags |= MSG_EXT;
464                                         /* has been dependent on "extended" option */
465                         
466                                         slot->msg=canmsg;
467                                         canque_put_inslot(qends, qedge, slot);
468
469                                 }
470                                 else
471                                         canque_abort_inslot(qends,qedge,slot);
472                                         
473
474                                 timer_rx_off=50;        //rosviceni diody pri prijmu
475                                 CLR_OUT_PIN(LED_PORT,LED2_BIT);
476                                 usb_device.ep_events &= ~MASK_EP1RX;
477                         
478                                         
479                         }
480                         
481
482 /*                      if (size==2){
483                                 uint8_t val;
484                                 if ((data[0]&CAN_OP_MASK)==CAN_OP_READ){ // Get data from CAN device and return to caller
485                                         val = can_read(data[0] & ~CAN_OP_MASK);
486                                         *(data+1)=val;
487                                         usb_udev_write_endpoint(&eps[1],(unsigned char *)data,size);
488                                         timer_rx_off=50;        //rosviceni diody pri prijmu
489                                         CLR_OUT_PIN(LED_PORT,LED2_BIT);
490                                         usb_can_send=0;
491                                 }
492                                 if ((data[0]&CAN_OP_MASK)==CAN_OP_WRITE){ // Save data to CAN device
493                                         can_write(data[1], data[0] & ~CAN_OP_MASK);
494                                         timer_tx_off=50;                //rozsviceni diod pri vysilani
495                                         CLR_OUT_PIN(LED_PORT,LED1_BIT);
496                                 }
497                         }*/
498                 }
499
500                 
501                 if(usb_device.ep_events & MASK_EP1TX){ //EP1TX - data transmitted
502                         if(canque_test_outslot(qends, &qedge, &slot)>=0){
503                                 DEBUGMSG("CAN message ready to send over usb\n");
504                                 uint16_t msgflags;
505                                 uint32_t msgid;
506
507                                 *(uint8_t *)(ep1_tx_buff)=0;
508                                 *(uint8_t *)(ep1_tx_buff+1)=slot->msg.length;
509
510                                 msgflags=slot->msg.flags;
511                                 msgid=slot->msg.id;
512                                 #if __BYTE_ORDER == __BIG_ENDIAN
513                                         msgflags  = bswap_16( msgflags);
514                                         msgid  = bswap_32( msgid);
515                                 #endif
516
517                                 *(uint16_t *)(ep1_tx_buff+2)=msgflags;
518                                 *(uint32_t *)(ep1_tx_buff+4)=msgid;
519                                 for (i=0;i<slot->msg.length;i++){
520                                         *(uint8_t *)(ep1_tx_buff+8+i)=slot->msg.data[i];
521                                 }
522                                 for (;i<CAN_MSG_LENGTH;i++){
523                                         *(uint8_t *)(ep1_tx_buff+8+i)=0;
524                                 }
525                                 usb_udev_write_endpoint(&eps[1],ep1_tx_buff,16);
526
527                                 canque_free_outslot(qends, qedge, slot);
528                                 timer_tx_off=50;                //rozsviceni diod pri vysilani
529                                 CLR_OUT_PIN(LED_PORT,LED1_BIT);
530                                 usb_device.ep_events &= ~MASK_EP1TX;
531
532                         }
533                         
534
535                 }
536                 
537
538                 //if (usb_can_send && )
539
540 #ifdef WATCHDOG_ENABLED
541                 watchdog_feed();
542 #endif /* WATCHDOG_ENABLED */
543
544                 /* 10ms timer */
545                 if (lt_10msec_expired(10))
546                         timer_10ms();
547         }
548
549         SET_OUT_PIN(LED_PORT,LED_GP);
550         SET_OUT_PIN(LED_PORT,LED_ERR);
551
552         /* unreachable code */
553 #ifdef SDCC
554         vec_jmp(0x0);  /* need to call a function from misc to correct linking */
555 #endif
556         return 0;
557 }