embedded/app/usbcan/can_quesysless.c

   1 /* can_quesysless.c - CAN message queues functions for the Linux kernel
   2  * Linux CAN-bus device driver.
   3  * New CAN queues 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.3  17 Jun 2004
   7  */
   8
   9 #include "./can/can.h"
  10 #include "./can/can_sysdep.h"
  11 #include "./can/can_queue.h"
  12
  13 // #define CAN_DEBUG
  14
  15 extern atomic_t edge_num_cnt;
  16
  17 #ifdef CAN_DEBUG
  18         #define DEBUGQUE(fmt,args...) can_printk(KERN_ERR "can_quesysless (debug): " fmt,\
  19         ##args)
  20
  21 #else
  22         #define DEBUGQUE(fmt,args...)
  23 #endif
  24
  25 #define ERRMSGQUE(fmt,args...) can_printk(KERN_ERR "can_quesysless: " fmt,\
  26         ##args)
  27
  28
  29 /*
  30  * Modifies Tx message processing
  31  *  0 .. local message processing disabled
  32  *  1 .. local messages disabled by default but can be enabled by canque_set_filt
  33  *  2 .. local messages enabled by default, can be disabled by canque_set_filt
  34  */
  35 extern int processlocal;
  36
  37 void canque_dead_func(unsigned long data);
  38
  39 /* Support for dead ends structures left after client close */
  40 can_spinlock_t canque_dead_func_lock;
  41 LIST_HEAD(canque_dead_ends);
  42 /* retrieved by list_entry(canque_dead_ends.next,struct canque_ends_t,dead_peers) */
  43 LIST_HEAD(canque_dead_edges);
  44 /* retrieved by list_entry(canque_dead_edges.next,struct canque_edge_t,inpeers) */
  45 // DECLARE_TASKLET(canque_dead_tl, canque_dead_func, 0);
  46 /* activated by tasklet_schedule(&canque_dead_tl) */
  47
  48
  49 static inline
  50 struct canque_edge_t *canque_dead_edges_cut_first(void)
  51 {
  52         can_spin_irqflags_t flags;
  53         struct canque_edge_t *edge;
  54         can_spin_lock_irqsave(&canque_dead_func_lock, flags);
  55         if(list_empty(&canque_dead_edges))
  56                 edge=NULL;
  57         else{
  58                 edge=list_entry(canque_dead_edges.next,struct canque_edge_t,inpeers);
  59                 list_del(&edge->inpeers);
  60         }
  61         can_spin_unlock_irqrestore(&canque_dead_func_lock, flags);
  62         return edge;
  63 }
  64
  65 void canque_dead_func(unsigned long data)
  66 {
  67         can_spin_irqflags_t flags;
  68         struct canque_edge_t *qedge;
  69         struct canque_ends_t *qends;
  70         struct list_head *entry;
  71
  72         while((qedge=canque_dead_edges_cut_first())){
  73                 DEBUGQUE("edge %d disposed\n",qedge->edge_num);
  74             #ifdef CAN_WITH_RTL
  75                 if(canque_fifo_test_fl(&qedge->fifo,RTL_MEM)){
  76                         canque_dispose_edge_rtl(qedge);
  77                         continue;
  78                 }
  79             #endif /*CAN_WITH_RTL*/
  80                 canque_fifo_done_kern(&qedge->fifo);
  81                 free(qedge);
  82         }
  83
  84         can_spin_lock_irqsave(&canque_dead_func_lock, flags);
  85         entry=canque_dead_ends.next;
  86         while(entry!=&canque_dead_ends){
  87                 qends=list_entry(entry,struct canque_ends_t,dead_peers);
  88                 entry=entry->next;
  89                 if(!list_empty(&qends->inlist))
  90                         continue;
  91                 if(!list_empty(&qends->outlist))
  92                         continue;
  93                 can_spin_lock_irqsave(&canque_dead_func_lock, flags);
  94                 list_del(&qends->dead_peers);
  95                 can_spin_unlock_irqrestore(&canque_dead_func_lock,flags);
  96                 DEBUGQUE("ends structure disposed\n");
  97             #ifdef CAN_WITH_RTL
  98                 if(qends->ends_flags&CAN_ENDSF_MEM_RTL){
  99                         canque_ends_free_rtl(qends);
 100                         continue;
 101                 }
 102             #endif /*CAN_WITH_RTL*/
 103                 free(qends);
 104         }
 105         can_spin_unlock_irqrestore(&canque_dead_func_lock,flags);
 106 }
 107
 108 // static inline void canque_dead_tasklet_schedule(void)
 109 // {
 110 //     #ifdef CAN_WITH_RTL
 111 //      if(!rtl_rt_system_is_idle()){
 112 //              set_bit(CAN_RTL2LIN_PEND_DEAD_b,&canqueue_rtl2lin_pend);
 113 //              rtl_global_pend_irq (canqueue_rtl_irq);
 114 //              return;
 115 //      }
 116 //     #endif /*CAN_WITH_RTL*/
 117 //
 118 //      tasklet_schedule(&canque_dead_tl);
 119 // }
 120
 121
 122 void canque_edge_do_dead(struct canque_edge_t *edge)
 123 {
 124         can_spin_irqflags_t flags;
 125
 126         canque_notify_bothends(edge,CANQUEUE_NOTIFY_NOUSR);
 127     #ifdef CAN_WITH_RTL
 128         /* The problem of the above call is, that in RT-Linux to Linux notify
 129            case is edge scheduled for delayed notify delivery, this needs
 130            to be reflected there */
 131         if(atomic_read(&edge->edge_used)>0){
 132                 can_spin_lock_irqsave(&edge->inends->ends_lock, flags);
 133                 can_spin_lock(&edge->outends->ends_lock);
 134                 if(atomic_read(&edge->edge_used)>0){
 135                         /* left edge to live for a while, banshee comes again in a while */
 136                         canque_fifo_clear_fl(&edge->fifo,DEAD);
 137                         can_spin_unlock(&edge->outends->ends_lock);
 138                         can_spin_unlock_irqrestore(&edge->inends->ends_lock, flags);
 139                         can_printk(KERN_ERR "can_quertl (debug): canque_edge_do_dead postponed\n");
 140                         return;
 141                 }
 142                 can_spin_unlock(&edge->outends->ends_lock);
 143                 can_spin_unlock_irqrestore(&edge->inends->ends_lock, flags);
 144         }
 145     #endif /*CAN_WITH_RTL*/
 146
 147         if(canqueue_disconnect_edge(edge)<0){
 148                 ERRMSGQUE("canque_edge_do_dead: canqueue_disconnect_edge failed !!!\n");
 149                 return;
 150         }
 151
 152         can_spin_lock_irqsave(&canque_dead_func_lock, flags);
 153         list_add(&edge->inpeers,&canque_dead_edges);
 154         can_spin_unlock_irqrestore(&canque_dead_func_lock, flags);
 155 //      canque_dead_tasklet_schedule();
 156         canque_dead_func(0);
 157 }
 158
 159
 160
 161 /*if(qends->ends_flags & CAN_ENDSF_DEAD){
 162         can_spin_lock_irqsave(&canque_dead_func_lock, flags);
 163         list_del(&qends->dead_peers);
 164         list_add(&qends->dead_peers,&canque_dead_ends);
 165         can_spin_unlock_irqrestore(&canque_dead_func_lock, flags);
 166         tasklet_schedule(&canque_dead_tl);
 167 }*/
 168
 169
 170 /**
 171  * canqueue_notify_kern - notification callback handler for Linux userspace clients
 172  * @qends: pointer to the callback side ends structure
 173  * @qedge: edge which invoked notification
 174  * @what: notification type
 175  *
 176  * The notification event is handled directly by call of this function except case,
 177  * when called from RT-Linux context in mixed mode Linux/RT-Linux compilation.
 178  * It is not possible to directly call Linux kernel synchronization primitives
 179  * in such case. The notification request is postponed and signaled by @pending_inops flags
 180  * by call canqueue_rtl2lin_check_and_pend() function.
 181  * The edge reference count is increased until until all pending notifications are processed.
 182  */
 183 void canqueue_notify_kern(struct canque_ends_t *qends, struct canque_edge_t *qedge, int what)
 184 {
 185         DEBUGQUE("canqueue_notify_kern for edge %d, use %d and event %d\n",
 186                         qedge->edge_num,(int)atomic_read(&qedge->edge_used),what);
 187
 188         /* delay event delivery for RT-Linux -> kernel notifications */
 189         if(canqueue_rtl2lin_check_and_pend(qends,qedge,what)){
 190                 DEBUGQUE("canqueue_notify_kern postponed\n");
 191                 return;
 192         }
 193
 194         switch(what){
 195                 case CANQUEUE_NOTIFY_EMPTY:
 196 //                      wake_up(&qends->endinfo.fileinfo.emptyq);
 197                         if(canque_fifo_test_and_clear_fl(&qedge->fifo, FREEONEMPTY))
 198                                 canque_edge_decref(qedge);
 199                         break;
 200                 case CANQUEUE_NOTIFY_SPACE:
 201 //                      wake_up(&qends->endinfo.fileinfo.writeq);
 202                     #ifdef CAN_ENABLE_KERN_FASYNC
 203                         /* Asynchronous I/O processing */
 204                         kill_fasync(&qends->endinfo.fileinfo.fasync, SIGIO, POLL_OUT);
 205                     #endif /*CAN_ENABLE_KERN_FASYNC*/
 206                         break;
 207                 case CANQUEUE_NOTIFY_PROC:
 208 //                      wake_up(&qends->endinfo.fileinfo.readq);
 209                     #ifdef CAN_ENABLE_KERN_FASYNC
 210                         /* Asynchronous I/O processing */
 211                         kill_fasync(&qends->endinfo.fileinfo.fasync, SIGIO, POLL_IN);
 212                     #endif /*CAN_ENABLE_KERN_FASYNC*/
 213                         break;
 214                 case CANQUEUE_NOTIFY_NOUSR:
 215 //                      wake_up(&qends->endinfo.fileinfo.readq);
 216 //                      wake_up(&qends->endinfo.fileinfo.writeq);
 217 //                      wake_up(&qends->endinfo.fileinfo.emptyq);
 218                         break;
 219                 case CANQUEUE_NOTIFY_DEAD_WANTED:
 220                 case CANQUEUE_NOTIFY_DEAD:
 221                         if(canque_fifo_test_and_clear_fl(&qedge->fifo, READY))
 222                                 canque_edge_decref(qedge);
 223                         break;
 224                 case CANQUEUE_NOTIFY_ATTACH:
 225                         break;
 226         }
 227 }
 228
 229 /**
 230  * canqueue_ends_init_kern - Linux userspace clients specific ends initialization
 231  * @qends: pointer to the callback side ends structure
 232  */
 233 int canqueue_ends_init_kern(struct canque_ends_t *qends)
 234 {
 235         canqueue_ends_init_gen(qends);
 236         qends->context=NULL;
 237         init_waitqueue_head(&qends->endinfo.fileinfo.readq);
 238         init_waitqueue_head(&qends->endinfo.fileinfo.writeq);
 239         init_waitqueue_head(&qends->endinfo.fileinfo.emptyq);
 240     #ifdef CAN_ENABLE_KERN_FASYNC
 241         qends->endinfo.fileinfo.fasync=NULL;
 242     #endif /*CAN_ENABLE_KERN_FASYNC*/
 243
 244         qends->notify=canqueue_notify_kern;
 245         DEBUGQUE("canqueue_ends_init_kern\n");
 246         return 0;
 247 }
 248
 249
 250 /**
 251  * canque_get_inslot4id_wait_kern - find or wait for best outgoing edge and slot for given ID
 252  * @qends: ends structure belonging to calling communication object
 253  * @qedgep: place to store pointer to found edge
 254  * @slotp: place to store pointer to  allocated slot
 255  * @cmd: command type for slot
 256  * @id: communication ID of message to send into edge
 257  * @prio: optional priority of message
 258  *
 259  * Same as canque_get_inslot4id(), except, that it waits for free slot
 260  * in case, that queue is full. Function is specific for Linux userspace clients.
 261  * Return Value: If there is no usable edge negative value is returned.
 262  */
 263 // int canque_get_inslot4id_wait_kern(struct canque_ends_t *qends,
 264 //      struct canque_edge_t **qedgep, struct canque_slot_t **slotp,
 265 //      int cmd, unsigned long id, int prio)
 266 // {
 267 //      int ret=-1;
 268 //      DEBUGQUE("canque_get_inslot4id_wait_kern for cmd %d, id %ld, prio %d\n",cmd,id,prio);
 269 //      wait_event_interruptible((qends->endinfo.fileinfo.writeq),
 270 //              (ret=canque_get_inslot4id(qends,qedgep,slotp,cmd,id,prio))!=-1);
 271 //      return ret;
 272 // }
 273
 274 /**
 275  * canque_get_outslot_wait_kern - receive or wait for ready slot for given ends
 276  * @qends: ends structure belonging to calling communication object
 277  * @qedgep: place to store pointer to found edge
 278  * @slotp: place to store pointer to received slot
 279  *
 280  * The same as canque_test_outslot(), except it waits in the case, that there is
 281  * no ready slot for given ends. Function is specific for Linux userspace clients.
 282  * Return Value: Negative value informs, that there is no ready output
 283  *      slot for given ends. Positive value is equal to the command
 284  *      slot has been allocated by the input side.
 285  */
 286 // int canque_get_outslot_wait_kern(struct canque_ends_t *qends,
 287 //      struct canque_edge_t **qedgep, struct canque_slot_t **slotp)
 288 // {
 289 //      int ret=-1;
 290 //      DEBUGQUE("canque_get_outslot_wait_kern\n");
 291 //      wait_event_interruptible((qends->endinfo.fileinfo.readq),
 292 //              (ret=canque_test_outslot(qends,qedgep,slotp))!=-1);
 293 //      return ret;
 294 // }
 295
 296 /**
 297  * canque_sync_wait_kern - wait for all slots processing
 298  * @qends: ends structure belonging to calling communication object
 299  * @qedge: pointer to edge
 300  *
 301  * Functions waits for ends transition into empty state.
 302  * Return Value: Positive value indicates, that edge empty state has been reached.
 303  *      Negative or zero value informs about interrupted wait or other problem.
 304  */
 305 // int canque_sync_wait_kern(struct canque_ends_t *qends, struct canque_edge_t *qedge)
 306 // {
 307 //      int ret=-1;
 308 //      DEBUGQUE("canque_sync_wait_kern\n");
 309 //      wait_event_interruptible((qends->endinfo.fileinfo.emptyq),
 310 //              (ret=canque_fifo_test_fl(&qedge->fifo,EMPTY)?1:0));
 311 //      return ret;
 312 // }
 313
 314
 315 /**
 316  * canque_fifo_init_kern - initialize one CAN FIFO
 317  * @fifo: pointer to the FIFO structure
 318  * @slotsnr: number of requested slots
 319  *
 320  * Return Value: The negative value indicates, that there is no memory
 321  *      to allocate space for the requested number of the slots.
 322  */
 323 int canque_fifo_init_kern(struct canque_fifo_t *fifo, int slotsnr)
 324 {
 325         int size;
 326         if(!slotsnr) slotsnr=MAX_BUF_LENGTH;
 327         size=sizeof(struct canque_slot_t)*slotsnr;
 328         fifo->entry=malloc(size);
 329         if(!fifo->entry) return -1;
 330         fifo->slotsnr=slotsnr;
 331         return canque_fifo_init_slots(fifo);
 332 }
 333
 334 /**
 335  * canque_fifo_done_kern - frees slots allocated for CAN FIFO
 336  * @fifo: pointer to the FIFO structure
 337  */
 338 int canque_fifo_done_kern(struct canque_fifo_t *fifo)
 339 {
 340         if(fifo->entry)
 341                 free(fifo->entry);
 342         fifo->entry=NULL;
 343         return 1;
 344 }
 345
 346
 347 /**
 348  * canque_new_edge_kern - allocate new edge structure in the Linux kernel context
 349  * @slotsnr: required number of slots in the newly allocated edge structure
 350  *
 351  * Return Value: Returns pointer to allocated slot structure or %NULL if
 352  *      there is not enough memory to process operation.
 353  */
 354 struct canque_edge_t *canque_new_edge_kern(int slotsnr)
 355 {
 356         struct canque_edge_t *qedge;
 357         qedge = (struct canque_edge_t *)malloc(sizeof(struct canque_edge_t));
 358         if(qedge == NULL) return NULL;
 359
 360         memset(qedge,0,sizeof(struct canque_edge_t));
 361         can_spin_lock_init(&qedge->fifo.fifo_lock);
 362         if(canque_fifo_init_kern(&qedge->fifo, slotsnr)<0){
 363                 free(qedge);
 364                 DEBUGQUE("canque_new_edge_kern failed\n");
 365                 return NULL;
 366         }
 367         atomic_set(&qedge->edge_used,1);
 368         qedge->filtid = 0;
 369         qedge->filtmask = canque_filtid2internal(0l, (processlocal<2)? MSG_LOCAL:0);
 370         qedge->edge_prio = 0;
 371     #ifdef CAN_DEBUG
 372         /* not exactly clean, but enough for debugging */
 373         atomic_inc(&edge_num_cnt);
 374         qedge->edge_num=atomic_read(&edge_num_cnt);
 375     #endif /* CAN_DEBUG */
 376         DEBUGQUE("canque_new_edge_kern %d\n",qedge->edge_num);
 377         return qedge;
 378 }
 379
 380 #ifdef USE_SYNC_DISCONNECT_EDGE_KERN
 381
 382 /*not included in doc
 383  * canqueue_disconnect_edge_kern - disconnect edge from communicating entities with wait
 384  * @qends: ends structure belonging to calling communication object
 385  * @qedge: pointer to edge
 386  *
 387  * Same as canqueue_disconnect_edge(), but tries to wait for state with zero
 388  * use counter.
 389  * Return Value: Negative value means, that edge is used and cannot
 390  *      be disconnected yet. Operation has to be delayed.
 391  */
 392 int canqueue_disconnect_edge_kern(struct canque_ends_t *qends, struct canque_edge_t *qedge)
 393 {
 394         canque_fifo_set_fl(&qedge->fifo,BLOCK);
 395         DEBUGQUE("canqueue_disconnect_edge_kern %d called\n",qedge->edge_num);
 396         if(!canque_fifo_test_and_set_fl(&qedge->fifo,DEAD)){
 397                 canque_notify_bothends(qedge, CANQUEUE_NOTIFY_DEAD);
 398
 399                 if(atomic_read(&qedge->edge_used)>0)
 400                         atomic_dec(&qedge->edge_used);
 401
 402                 DEBUGQUE("canqueue_disconnect_edge_kern %d waiting\n",qedge->edge_num);
 403                 wait_event((qends->endinfo.fileinfo.emptyq),
 404                         (canqueue_disconnect_edge(qedge)>=0));
 405
 406                 /*set_current_state(TASK_UNINTERRUPTIBLE);*/
 407                 /*schedule_timeout(HZ);*/
 408                 return 0;
 409         } else {
 410                 DEBUGQUE("canqueue_disconnect_edge_kern cannot set DEAD\n");
 411                 return -1;
 412         }
 413 }
 414
 415
 416 int canqueue_disconnect_list_kern(struct canque_ends_t *qends, struct list_head *list)
 417 {
 418         struct canque_edge_t *edge;
 419         can_spin_irqflags_t flags;
 420         for(;;){
 421                 can_spin_lock_irqsave(&qends->ends_lock,flags);
 422                 if(list_empty(list)){
 423                         can_spin_unlock_irqrestore(&qends->ends_lock,flags);
 424                         return 0;
 425                 }
 426                 if(list == &qends->inlist)
 427                         edge=list_entry(list->next,struct canque_edge_t,inpeers);
 428                 else
 429                         edge=list_entry(list->next,struct canque_edge_t,outpeers);
 430                 atomic_inc(&edge->edge_used);
 431                 can_spin_unlock_irqrestore(&qends->ends_lock,flags);
 432                 if(canqueue_disconnect_edge_kern(qends, edge)>=0) {
 433                         /* Free edge memory */
 434                         canque_fifo_done_kern(&edge->fifo);
 435                         free(edge);
 436                 }else{
 437                         canque_notify_bothends(edge, CANQUEUE_NOTIFY_DEAD_WANTED);
 438                         canque_edge_decref(edge);
 439                         DEBUGQUE("canqueue_disconnect_list_kern in troubles\n");
 440                         DEBUGQUE("the edge %d has usage count %d and flags %ld\n",edge->edge_num,atomic_read(&edge->edge_used),edge->fifo.fifo_flags);
 441                         return -1;
 442                 }
 443         }
 444 }
 445
 446 #endif /*USE_SYNC_DISCONNECT_EDGE_KERN*/
 447
 448
 449 // int canqueue_ends_sync_all_kern(struct canque_ends_t *qends)
 450 // {
 451 //      struct canque_edge_t *qedge;
 452 //
 453 //      canque_for_each_inedge(qends, qedge){
 454 //              DEBUGQUE("canque_sync_wait_kern called for edge %d\n",qedge->edge_num);
 455 //              canque_sync_wait_kern(qends, qedge);
 456 //      }
 457 //      return 0;
 458 // }
 459
 460
 461 void canqueue_ends_dispose_postpone(struct canque_ends_t *qends)
 462 {
 463         can_spin_irqflags_t flags;
 464
 465         can_spin_lock_irqsave(&canque_dead_func_lock, flags);
 466         qends->ends_flags |= CAN_ENDSF_DEAD;
 467         list_add(&qends->dead_peers,&canque_dead_ends);
 468         can_spin_unlock_irqrestore(&canque_dead_func_lock, flags);
 469         canque_dead_func(0);
 470 //      canque_dead_tasklet_schedule();
 471 }
 472
 473
 474 /**
 475  * canqueue_ends_dispose_kern - finalizing of the ends structure for Linux kernel clients
 476  * @qends: pointer to ends structure
 477  * @sync: flag indicating, that user wants to wait for processing of all remaining
 478  *      messages
 479  *
 480  * Return Value: Function should be designed such way to not fail.
 481  */
 482 // int canqueue_ends_dispose_kern(struct canque_ends_t *qends, int sync)
 483 // {
 484 //      int delayed;
 485 //
 486 //      DEBUGQUE("canqueue_ends_dispose_kern\n");
 487 //      canqueue_block_inlist(qends);
 488 //      canqueue_block_outlist(qends);
 489 //
 490 //      /*Wait for sending of all pending messages in the output FIFOs*/
 491 //      if(sync)
 492 //              canqueue_ends_sync_all_kern(qends);
 493 //
 494 //      /* Finish or kill all outgoing edges listed in inends */
 495 //      delayed=canqueue_ends_kill_inlist(qends, 1);
 496 //      /* Kill all incoming edges listed in outends */
 497 //      delayed|=canqueue_ends_kill_outlist(qends);
 498 //
 499 // //   wake_up(&qends->endinfo.fileinfo.readq);
 500 // //   wake_up(&qends->endinfo.fileinfo.writeq);
 501 // //   wake_up(&qends->endinfo.fileinfo.emptyq);
 502 //
 503 //      if(delayed){
 504 //              canqueue_ends_dispose_postpone(qends);
 505 //
 506 //              DEBUGQUE("canqueue_ends_dispose_kern delayed\n");
 507 //              return 1;
 508 //      }
 509 //
 510 //      free(qends);
 511 //      DEBUGQUE("canqueue_ends_dispose_kern finished\n");
 512 //      return 0;
 513 // }
 514
 515 void canqueue_kern_initialize()
 516 {
 517         can_spin_lock_init(&canque_dead_func_lock);
 518 }