lincan/include/can_queue.h

   1 #ifndef _CAN_QUEUE_H
   2 #define _CAN_QUEUE_H
   3
   4 #include "./can.h"
   5 #include "./constants.h"
   6 #include "./can_sysdep.h"
   7
   8 /**
   9  * struct canque_slot_t - one CAN message slot in the CAN FIFO queue
  10  * @next: pointer to the next/younger slot
  11  * @slot_flags: space for flags and optional command describing action
  12  *      associated with slot data
  13  * @msg: space for one CAN message
  14  *
  15  * This structure is used to store CAN messages in the CAN FIFO queue.
  16  */
  17  struct canque_slot_t {
  18         struct canque_slot_t *next;
  19         unsigned long slot_flags;
  20         struct canmsg_t msg;
  21 };
  22
  23 #define CAN_SLOTF_CMD   0x00ff  /*  */
  24
  25 /**
  26  * struct canque_fifo_t - CAN FIFO queue representation
  27  * @fifo_flags: this field holds global flags describing state of the FIFO.
  28  *      %CAN_FIFOF_ERROR is set when some error condition occurs.
  29  *      %CAN_FIFOF_ERR2BLOCK defines, that error should lead to the FIFO block state.
  30  *      %CAN_FIFOF_BLOCK state blocks insertion of the next messages.
  31  *      %CAN_FIFOF_OVERRUN attempt to acquire new slot, when FIFO is full.
  32  *      %CAN_FIFOF_FULL indicates FIFO full state.
  33  *      %CAN_FIFOF_EMPTY indicates no allocated slot in the FIFO.
  34  *      %CAN_FIFOF_DEAD condition indication. Used when FIFO is beeing destroyed.
  35  * @error_code: futher description of error condition
  36  * @head: pointer to the FIFO head, oldest slot
  37  * @tail: pointer to the location, where pointer to newly inserted slot
  38  *      should be added
  39  * @flist: pointer to list of the free slots associated with queue
  40  * @entry: pointer to the memory allocated for the list slots.
  41  * @fifo_lock: the lock to ensure atomicity of slot manipulation operations.
  42  *
  43  * This structure represents CAN FIFO queue. It is implemented as
  44  * a single linked list of slots prepared for processing. The empty slots
  45  * are stored in single linked list (@flist).
  46  */
  47 struct canque_fifo_t {
  48         unsigned long fifo_flags;
  49         unsigned long error_code;
  50         struct canque_slot_t *head;     /* points to the oldest entry */
  51         struct canque_slot_t **tail;    /* points to NULL pointer for chaining */
  52         struct canque_slot_t *flist;    /* points the first entry in the free list */
  53         struct canque_slot_t *entry;    /* points to first allocated entry */
  54         spinlock_t fifo_lock;   /* spin_lock_irqsave / spin_lock_irqrestore */
  55 };
  56
  57 #define CAN_FIFOF_DESTROY_b     15
  58 #define CAN_FIFOF_ERROR_b       14
  59 #define CAN_FIFOF_ERR2BLOCK_b   13
  60 #define CAN_FIFOF_BLOCK_b       12
  61 #define CAN_FIFOF_OVERRUN_b     11
  62 #define CAN_FIFOF_FULL_b        10
  63 #define CAN_FIFOF_EMPTY_b       9
  64 #define CAN_FIFOF_DEAD_b        8
  65 #define CAN_FIFOF_INACTIVE_b    7
  66 #define CAN_FIFOF_FREEONEMPTY_b 6
  67 #define CAN_FIFOF_READY_b       5
  68
  69 #define CAN_FIFOF_DESTROY       (1<<CAN_FIFOF_DESTROY_b)
  70 #define CAN_FIFOF_ERROR         (1<<CAN_FIFOF_ERROR_b)
  71 #define CAN_FIFOF_ERR2BLOCK     (1<<CAN_FIFOF_ERR2BLOCK_b)
  72 #define CAN_FIFOF_BLOCK         (1<<CAN_FIFOF_BLOCK_b)
  73 #define CAN_FIFOF_OVERRUN       (1<<CAN_FIFOF_OVERRUN_b)
  74 #define CAN_FIFOF_FULL          (1<<CAN_FIFOF_FULL_b)
  75 #define CAN_FIFOF_EMPTY         (1<<CAN_FIFOF_EMPTY_b)
  76 #define CAN_FIFOF_DEAD          (1<<CAN_FIFOF_DEAD_b)
  77 #define CAN_FIFOF_INACTIVE      (1<<CAN_FIFOF_INACTIVE_b)
  78 #define CAN_FIFOF_FREEONEMPTY   (1<<CAN_FIFOF_FREEONEMPTY_b)
  79 #define CAN_FIFOF_READY         (1<<CAN_FIFOF_READY_b)
  80
  81 #define canque_fifo_test_fl(fifo,fifo_fl) \
  82   test_bit(CAN_FIFOF_##fifo_fl##_b,&(fifo)->fifo_flags)
  83 #define canque_fifo_set_fl(fifo,fifo_fl) \
  84   set_bit(CAN_FIFOF_##fifo_fl##_b,&(fifo)->fifo_flags)
  85 #define canque_fifo_clear_fl(fifo,fifo_fl) \
  86   clear_bit(CAN_FIFOF_##fifo_fl##_b,&(fifo)->fifo_flags)
  87 #define canque_fifo_test_and_set_fl(fifo,fifo_fl) \
  88   test_and_set_bit(CAN_FIFOF_##fifo_fl##_b,&(fifo)->fifo_flags)
  89 #define canque_fifo_test_and_clear_fl(fifo,fifo_fl) \
  90   test_and_clear_bit(CAN_FIFOF_##fifo_fl##_b,&(fifo)->fifo_flags)
  91
  92
  93 /**
  94  * canque_fifo_get_inslot - allocate slot for the input of one CAN message
  95  * @fifo: pointer to the FIFO structure
  96  * @slotp: pointer to location to store pointer to the allocated slot.
  97  * @cmd: optional command associated with allocated slot.
  98  *
  99  * Return Value: The function returns negative value if there is no
 100  *      free slot in the FIFO queue.
 101  */
 102 static inline
 103 int canque_fifo_get_inslot(struct canque_fifo_t *fifo, struct canque_slot_t **slotp, int cmd)
 104 {
 105         unsigned long flags;
 106         struct canque_slot_t *slot;
 107         spin_lock_irqsave(&fifo->fifo_lock, flags);
 108         /* get the first free slot slot from flist */
 109         if(!(slot=fifo->flist)) {
 110                 canque_fifo_set_fl(fifo,OVERRUN);
 111                 canque_fifo_set_fl(fifo,FULL);
 112                 spin_unlock_irqrestore(&fifo->fifo_lock, flags);
 113                 *slotp=NULL;
 114                 return -1;
 115         }
 116         /* adjust free slot list */
 117         if(!(fifo->flist=slot->next))
 118                 canque_fifo_set_fl(fifo,FULL);
 119         spin_unlock_irqrestore(&fifo->fifo_lock, flags);
 120         *slotp=slot;
 121         slot->slot_flags=cmd&CAN_SLOTF_CMD;
 122         return 1;
 123 }
 124
 125 /**
 126  * canque_fifo_put_inslot - releases slot to further processing
 127  * @fifo: pointer to the FIFO structure
 128  * @slot: pointer to the slot previously acquired by canque_fifo_get_inslot().
 129  *
 130  * Return Value: The nonzero return value indicates, that the queue was empty
 131  *      before call to the function. The caller should wake-up output side of the queue.
 132  */
 133 static inline
 134 int canque_fifo_put_inslot(struct canque_fifo_t *fifo, struct canque_slot_t *slot)
 135 {
 136         int ret;
 137         unsigned long flags;
 138         slot->next=NULL;
 139         spin_lock_irqsave(&fifo->fifo_lock, flags);
 140         if(*fifo->tail) printk(KERN_CRIT "canque_fifo_put_inslot: fifo->tail != NULL\n");
 141         *fifo->tail=slot;
 142         fifo->tail=&slot->next;
 143         ret=0;
 144         if(canque_fifo_test_and_clear_fl(fifo,EMPTY))
 145           ret=CAN_FIFOF_EMPTY;  /* Fifo has been empty before put */
 146         if(canque_fifo_test_and_clear_fl(fifo,INACTIVE))
 147           ret=CAN_FIFOF_INACTIVE; /* Fifo has been empty before put */
 148         spin_unlock_irqrestore(&fifo->fifo_lock, flags);
 149         return ret;
 150 }
 151
 152 /**
 153  * canque_fifo_abort_inslot - release and abort slot
 154  * @fifo: pointer to the FIFO structure
 155  * @slot: pointer to the slot previously acquired by canque_fifo_get_inslot().
 156  *
 157  * Return Value: The nonzero value indicates, that fifo was full
 158  */
 159 static inline
 160 int canque_fifo_abort_inslot(struct canque_fifo_t *fifo, struct canque_slot_t *slot)
 161 {
 162         int ret=0;
 163         unsigned long flags;
 164         spin_lock_irqsave(&fifo->fifo_lock, flags);
 165         slot->next=fifo->flist;
 166         fifo->flist=slot;
 167         if(canque_fifo_test_and_clear_fl(fifo,FULL))
 168                 ret=CAN_FIFOF_FULL;
 169         spin_unlock_irqrestore(&fifo->fifo_lock, flags);
 170         return ret;
 171 }
 172
 173 /**
 174  * canque_fifo_test_outslot - test and get ready slot from the FIFO
 175  * @fifo: pointer to the FIFO structure
 176  * @slotp: pointer to location to store pointer to the oldest slot from the FIFO.
 177  *
 178  * Return Value: The negative value indicates, that queue is empty.
 179  *      The positive or zero value represents command stored into slot by
 180  *      the call to the function canque_fifo_get_inslot().
 181  *      The successfully acquired FIFO output slot has to be released by
 182  *      the call canque_fifo_free_outslot() or canque_fifo_again_outslot().
 183  */
 184 static inline
 185 int canque_fifo_test_outslot(struct canque_fifo_t *fifo, struct canque_slot_t **slotp)
 186 {
 187         unsigned long flags;
 188         int cmd;
 189         struct canque_slot_t *slot;
 190         spin_lock_irqsave(&fifo->fifo_lock, flags);
 191         if(!(slot=fifo->head)){;
 192                 canque_fifo_set_fl(fifo,EMPTY);
 193                 spin_unlock_irqrestore(&fifo->fifo_lock, flags);
 194                 *slotp=NULL;
 195                 return -1;
 196         }
 197         if(!(fifo->head=slot->next))
 198                 fifo->tail=&fifo->head;
 199         spin_unlock_irqrestore(&fifo->fifo_lock, flags);
 200
 201         *slotp=slot;
 202         cmd=slot->slot_flags;
 203         return cmd&CAN_SLOTF_CMD;
 204 }
 205
 206
 207 /**
 208  * canque_fifo_free_outslot - free processed FIFO slot
 209  * @fifo: pointer to the FIFO structure
 210  * @slot: pointer to the slot previously acquired by canque_fifo_test_outslot().
 211  *
 212  * Return Value: The returned value informs about FIFO state change.
 213  *      The mask %CAN_FIFOF_FULL indicates, that the FIFO was full before
 214  *      the function call. The mask %CAN_FIFOF_EMPTY informs, that last ready slot
 215  *      has been processed.
 216  */
 217 static inline
 218 int canque_fifo_free_outslot(struct canque_fifo_t *fifo, struct canque_slot_t *slot)
 219 {
 220         int ret=0;
 221         unsigned long flags;
 222         spin_lock_irqsave(&fifo->fifo_lock, flags);
 223         slot->next=fifo->flist;
 224         fifo->flist=slot;
 225         if(canque_fifo_test_and_clear_fl(fifo,FULL))
 226                 ret=CAN_FIFOF_FULL;
 227         if(!(fifo->head)){
 228                 canque_fifo_set_fl(fifo,EMPTY);
 229                 ret|=CAN_FIFOF_EMPTY;
 230         }
 231         spin_unlock_irqrestore(&fifo->fifo_lock, flags);
 232         return ret;
 233 }
 234
 235 /**
 236  * canque_fifo_again_outslot - interrupt and postpone processing of the slot
 237  * @fifo: pointer to the FIFO structure
 238  * @slot: pointer to the slot previously acquired by canque_fifo_test_outslot().
 239  *
 240  * Return Value: The function cannot fail..
 241  */
 242 static inline
 243 int canque_fifo_again_outslot(struct canque_fifo_t *fifo, struct canque_slot_t *slot)
 244 {
 245         unsigned long flags;
 246         spin_lock_irqsave(&fifo->fifo_lock, flags);
 247         if(!(slot->next=fifo->head))
 248                 fifo->tail=&slot->next;
 249         fifo->head=slot;
 250         spin_unlock_irqrestore(&fifo->fifo_lock, flags);
 251         return 1;
 252 }
 253
 254 int canque_fifo_flush_slots(struct canque_fifo_t *fifo);
 255
 256 int canque_fifo_init_slots(struct canque_fifo_t *fifo, int slotsnr);
 257
 258 int canque_fifo_done(struct canque_fifo_t *fifo);
 259
 260 #define CANQUEUE_PRIO_NR  3
 261
 262 /* Forward declarations for external types */
 263 struct msgobj_t;
 264 struct chip_t;
 265
 266 /**
 267  * struct canque_edge_t - CAN message delivery subsystem graph edge
 268  * @fifo: place where primitive @struct canque_fifo_t FIFO is located.
 269  * @filtid: the possible CAN message identifiers filter.
 270  * @filtmask: the filter mask, the comparison considers only
 271  *      @filtid bits corresponding to set bits in the @filtmask field.
 272  * @inpeers: the lists of all peers FIFOs connected by their
 273  *      input side (@inends) to the same terminal (@struct canque_ends_t).
 274  * @outpeers: the lists of all peers FIFOs connected by their
 275  *      output side (@outends) to the same terminal (@struct canque_ends_t).
 276  * @activepeers: the lists of peers FIFOs connected by their
 277  *      output side (@outends) to the same terminal (@struct canque_ends_t)
 278  *      with same priority and active state.
 279  * @inends: the pointer to the FIFO input side terminal (@struct canque_ends_t).
 280  * @outends: the pointer to the FIFO output side terminal (@struct canque_ends_t).
 281  * @edge_used: the atomic usage counter, mainly used for safe destruction of the edge.
 282  * @edge_prio: the assigned queue priority from the range 0 to %CANQUEUE_PRIO_NR-1
 283  * @edge_num: edge sequential number intended for debugging purposes only
 284  *
 285  * This structure represents one direction connection from messages source
 286  * (@inends) to message consumer (@outends) fifo ends hub. The edge contains
 287  * &struct canque_fifo_t for message fifo implementation.
 288  */
 289 struct canque_edge_t {
 290         struct canque_fifo_t fifo;
 291         unsigned long filtid;
 292         unsigned long filtmask;
 293         struct list_head inpeers;
 294         struct list_head outpeers;
 295         struct list_head activepeers;
 296         struct canque_ends_t *inends;
 297         struct canque_ends_t *outends;
 298         atomic_t edge_used;
 299         int edge_prio;
 300         int edge_num;
 301 };
 302
 303 /**
 304  * struct canque_ends_t - CAN message delivery subsystem graph vertex (FIFO ends)
 305  * @ends_flags: this field holds flags describing state of the ENDS structure.
 306  * @active: the array of the lists of active edges directed to the ends structure
 307  *      with ready messages. The array is indexed by the edges priorities.
 308  * @idle: the list of the edges directed to the ends structure with empty FIFOs.
 309  * @inlist: the list of outgoing edges input sides.
 310  * @ends_lock: the lock synchronizing operations between threads accessing
 311  *      same ends structure.
 312  * @notify: pointer to notify procedure. The next state changes are notified.
 313  *      %CANQUEUE_NOTIFY_EMPTY (out->in call) - all slots are processed by FIFO out side.
 314  *      %CANQUEUE_NOTIFY_SPACE (out->in call) - full state negated => there is space for new message.
 315  *      %CANQUEUE_NOTIFY_PROC  (in->out call) - empty state negated => out side is requested to process slots.
 316  *      %CANQUEUE_NOTIFY_NOUSR (both) - notify, that the last user has released the edge usage
 317  *              called with some lock to prevent edge disappear.
 318  *      %CANQUEUE_NOTIFY_DEAD  (both) - edge is in progress of deletion.
 319  *      %CANQUEUE_NOTIFY_ATACH (both) - new edge has been attached to end.
 320  *      %CANQUEUE_NOTIFY_FILTCH (out->in call) - edge filter rules changed
 321  *      %CANQUEUE_NOTIFY_ERROR  (out->in call) - error in messages processing.
 322  * @context: space to store ends user specific information
 323  * @endinfo: space to store some other ends usage specific informations
 324  *      mainly for waking-up by the notify calls.
 325  *
 326  * Structure represents place to connect edges to for CAN communication entity.
 327  * The zero, one or more incoming and outgoing edges can be connected to
 328  * this structure.
 329  */
 330 struct canque_ends_t {
 331         unsigned long ends_flags;
 332         struct list_head active[CANQUEUE_PRIO_NR];
 333         struct list_head idle;
 334         struct list_head inlist;
 335         struct list_head outlist;
 336         spinlock_t ends_lock;   /* spin_lock_irqsave / spin_lock_irqrestore */
 337         void (*notify)(struct canque_ends_t *qends, struct canque_edge_t *qedge, int what);
 338         void *context;
 339         union {
 340                 struct {
 341                         wait_queue_head_t readq;
 342                         wait_queue_head_t writeq;
 343                         wait_queue_head_t emptyq;
 344                 } fileinfo;
 345                 struct {
 346                         wait_queue_head_t daemonq;
 347                         struct msgobj_t *msgobj;
 348                         struct chip_t *chip;
 349                 } chipinfo;
 350         } endinfo;
 351         struct list_head dead_peers;
 352 };
 353
 354 #define CANQUEUE_NOTIFY_EMPTY  1 /* out -> in - all slots are processed by FIFO out side */
 355 #define CANQUEUE_NOTIFY_SPACE  2 /* out -> in - full state negated => there is space for new message */
 356 #define CANQUEUE_NOTIFY_PROC   3 /* in -> out - empty state negated => out side is requested to process slots */
 357 #define CANQUEUE_NOTIFY_NOUSR  4 /* called with some lock to prevent edge disappear */
 358 #define CANQUEUE_NOTIFY_DEAD   5 /*  */
 359 #define CANQUEUE_NOTIFY_DEAD_WANTED 6 /*  */
 360 #define CANQUEUE_NOTIFY_ATTACH 7 /*  */
 361 #define CANQUEUE_NOTIFY_FILTCH 8 /* filter changed */
 362 #define CANQUEUE_NOTIFY_ERROR      0x10000 /* error notifiers */
 363 #define CANQUEUE_NOTIFY_ERRTX_PREP 0x11001 /* tx preparation error */
 364 #define CANQUEUE_NOTIFY_ERRTX_SEND 0x11002 /* tx send error */
 365 #define CANQUEUE_NOTIFY_ERRTX_BUS  0x11003 /* tx bus error */
 366
 367 #define CAN_ENDSF_DEAD  (1<<0)
 368
 369 /**
 370  * canque_notify_inends - request to send notification to the input ends
 371  * @qedge: pointer to the edge structure
 372  * @what: notification type
 373  */
 374 static inline
 375 void canque_notify_inends(struct canque_edge_t *qedge, int what)
 376 {
 377         if(qedge->inends)
 378                 if(qedge->inends->notify)
 379                         qedge->inends->notify(qedge->inends,qedge,what);
 380 }
 381
 382 /**
 383  * canque_notify_outends - request to send notification to the output ends
 384  * @qedge: pointer to the edge structure
 385  * @what: notification type
 386  */
 387 static inline
 388 void canque_notify_outends(struct canque_edge_t *qedge, int what)
 389 {
 390         if(qedge->outends)
 391                 if(qedge->outends->notify)
 392                         qedge->outends->notify(qedge->outends,qedge,what);
 393 }
 394
 395 /**
 396  * canque_notify_bothends - request to send notification to the both ends
 397  * @qedge: pointer to the edge structure
 398  * @what: notification type
 399  */
 400 static inline
 401 void canque_notify_bothends(struct canque_edge_t *qedge, int what)
 402 {
 403         canque_notify_inends(qedge, what);
 404         canque_notify_outends(qedge, what);
 405 }
 406
 407 /**
 408  * canque_activate_edge - mark output end of the edge as active
 409  * @qedge: pointer to the edge structure
 410  * @inends: input side of the edge
 411  *
 412  * Function call moves output side of the edge from idle onto active edges
 413  * list.
 414  */
 415 static inline
 416 void canque_activate_edge(struct canque_ends_t *inends, struct canque_edge_t *qedge)
 417 {
 418         unsigned long flags;
 419         struct canque_ends_t *outends;
 420         if(qedge->edge_prio>=CANQUEUE_PRIO_NR)
 421                 qedge->edge_prio=CANQUEUE_PRIO_NR-1;
 422         spin_lock_irqsave(&inends->ends_lock, flags);
 423         if((outends=qedge->outends)){
 424                 spin_lock(&outends->ends_lock);
 425                 spin_lock(&qedge->fifo.fifo_lock);
 426                 if(!canque_fifo_test_fl(&qedge->fifo,EMPTY)){
 427                         list_del(&qedge->activepeers);
 428                         list_add_tail(&qedge->activepeers,&outends->active[qedge->edge_prio]);
 429                 }
 430                 spin_unlock(&qedge->fifo.fifo_lock);
 431                 spin_unlock(&outends->ends_lock);
 432
 433         }
 434         spin_unlock_irqrestore(&inends->ends_lock, flags);
 435 }
 436
 437 /**
 438  * canque_filtid2internal - converts message ID and filter flags into internal format
 439  * @id: CAN message 11 or 29 bit identifier
 440  * @filtflags: CAN message flags
 441  *
 442  * This function maps message ID and %MSG_RTR, %MSG_EXT and %MSG_LOCAL into one 32 bit number
 443  */
 444 static inline
 445 unsigned int canque_filtid2internal(unsigned long id, int filtflags)
 446 {
 447         filtflags &= MSG_RTR|MSG_EXT|MSG_LOCAL;
 448         filtflags += filtflags&MSG_RTR;
 449         return (id&MSG_ID_MASK) | (filtflags<<28);
 450 }
 451
 452 int canque_get_inslot(struct canque_ends_t *qends,
 453         struct canque_edge_t **qedgep, struct canque_slot_t **slotp, int cmd);
 454
 455 int canque_get_inslot4id(struct canque_ends_t *qends,
 456         struct canque_edge_t **qedgep, struct canque_slot_t **slotp,
 457         int cmd, unsigned long id, int prio);
 458
 459 int canque_put_inslot(struct canque_ends_t *qends,
 460         struct canque_edge_t *qedge, struct canque_slot_t *slot);
 461
 462 int canque_abort_inslot(struct canque_ends_t *qends,
 463         struct canque_edge_t *qedge, struct canque_slot_t *slot);
 464
 465 int canque_filter_msg2edges(struct canque_ends_t *qends, struct canmsg_t *msg);
 466
 467 int canque_test_outslot(struct canque_ends_t *qends,
 468         struct canque_edge_t **qedgep, struct canque_slot_t **slotp);
 469
 470 int canque_free_outslot(struct canque_ends_t *qends,
 471         struct canque_edge_t *qedge, struct canque_slot_t *slot);
 472
 473 int canque_again_outslot(struct canque_ends_t *qends,
 474         struct canque_edge_t *qedge, struct canque_slot_t *slot);
 475
 476 int canque_set_filt(struct canque_edge_t *qedge,
 477         unsigned long filtid, unsigned long filtmask, int flags);
 478
 479 int canque_flush(struct canque_edge_t *qedge);
 480
 481 int canqueue_disconnect_edge(struct canque_edge_t *qedge);
 482
 483 int canqueue_connect_edge(struct canque_edge_t *qedge, struct canque_ends_t *inends, struct canque_ends_t *outends);
 484
 485 int canqueue_ends_init_gen(struct canque_ends_t *qends);
 486
 487 void canqueue_block_inlist(struct canque_ends_t *qends);
 488
 489 void canqueue_block_outlist(struct canque_ends_t *qends);
 490
 491 /* edge reference and traversal functions */
 492
 493 void canque_edge_do_dead(struct canque_edge_t *edge, int dead_fl);
 494
 495 static inline
 496 void canque_edge_incref(struct canque_edge_t *edge)
 497 {
 498         atomic_inc(&edge->edge_used);
 499 }
 500
 501 static inline
 502 void canque_edge_decref(struct canque_edge_t *edge)
 503 {
 504         unsigned long flags;
 505         struct canque_ends_t *inends=edge->inends;
 506         struct canque_ends_t *outends=edge->outends;
 507         int dead_fl;
 508
 509         spin_lock_irqsave(&inends->ends_lock, flags);
 510         spin_lock(&outends->ends_lock);
 511         if(atomic_dec_and_test(&edge->edge_used)) {
 512                 dead_fl=canque_fifo_test_and_set_fl(&edge->fifo,DEAD);
 513                 /*This should not be there, but it cannot be outside of the lock :-(*/
 514                 canque_notify_bothends(edge,CANQUEUE_NOTIFY_NOUSR);
 515                 spin_unlock(&outends->ends_lock);
 516                 spin_unlock_irqrestore(&inends->ends_lock, flags);
 517                 canque_edge_do_dead(edge, dead_fl);
 518         } else {
 519                 spin_unlock(&outends->ends_lock);
 520                 spin_unlock_irqrestore(&inends->ends_lock, flags);
 521         }
 522 }
 523
 524 static inline
 525 struct canque_edge_t *canque_first_inedge(struct canque_ends_t *qends)
 526 {
 527         unsigned long flags;
 528         struct list_head *entry;
 529         struct canque_edge_t *edge;
 530
 531         spin_lock_irqsave(&qends->ends_lock, flags);
 532         entry=qends->inlist.next;
 533     skip_dead:
 534         if(entry != &qends->inlist) {
 535                 edge=list_entry(entry,struct canque_edge_t,inpeers);
 536                 if(canque_fifo_test_fl(&edge->fifo,DEAD)) {
 537                         entry=entry->next;
 538                         goto skip_dead;
 539                 }
 540                 canque_edge_incref(edge);
 541         } else {
 542                 edge=NULL;
 543         }
 544         spin_unlock_irqrestore(&qends->ends_lock, flags);
 545         return edge;
 546 }
 547
 548
 549 static inline
 550 struct canque_edge_t *canque_next_inedge(struct canque_ends_t *qends, struct canque_edge_t *edge)
 551 {
 552         unsigned long flags;
 553         struct list_head *entry;
 554         struct canque_edge_t *next;
 555
 556         spin_lock_irqsave(&qends->ends_lock, flags);
 557         entry=edge->inpeers.next;
 558     skip_dead:
 559         if(entry != &qends->inlist) {
 560                 next=list_entry(entry,struct canque_edge_t,inpeers);
 561                 if(canque_fifo_test_fl(&edge->fifo,DEAD)) {
 562                         entry=entry->next;
 563                         goto skip_dead;
 564                 }
 565                 canque_edge_incref(next);
 566         } else {
 567                 next=NULL;
 568         }
 569         spin_unlock_irqrestore(&qends->ends_lock, flags);
 570         canque_edge_decref(edge);
 571         return next;
 572 }
 573
 574 #define canque_for_each_inedge(qends, edge) \
 575             for(edge=canque_first_inedge(qends);edge;edge=canque_next_inedge(qends, edge))
 576
 577 static inline
 578 struct canque_edge_t *canque_first_outedge(struct canque_ends_t *qends)
 579 {
 580         unsigned long flags;
 581         struct list_head *entry;
 582         struct canque_edge_t *edge;
 583
 584         spin_lock_irqsave(&qends->ends_lock, flags);
 585         entry=qends->outlist.next;
 586     skip_dead:
 587         if(entry != &qends->outlist) {
 588                 edge=list_entry(entry,struct canque_edge_t,outpeers);
 589                 if(canque_fifo_test_fl(&edge->fifo,DEAD)) {
 590                         entry=entry->next;
 591                         goto skip_dead;
 592                 }
 593                 canque_edge_incref(edge);
 594         } else {
 595                 edge=NULL;
 596         }
 597         spin_unlock_irqrestore(&qends->ends_lock, flags);
 598         return edge;
 599 }
 600
 601
 602 static inline
 603 struct canque_edge_t *canque_next_outedge(struct canque_ends_t *qends, struct canque_edge_t *edge)
 604 {
 605         unsigned long flags;
 606         struct list_head *entry;
 607         struct canque_edge_t *next;
 608
 609         spin_lock_irqsave(&qends->ends_lock, flags);
 610         entry=edge->outpeers.next;
 611     skip_dead:
 612         if(entry != &qends->outlist) {
 613                 next=list_entry(entry,struct canque_edge_t,outpeers);
 614                 if(canque_fifo_test_fl(&edge->fifo,DEAD)) {
 615                         entry=entry->next;
 616                         goto skip_dead;
 617                 }
 618                 canque_edge_incref(next);
 619         } else {
 620                 next=NULL;
 621         }
 622         spin_unlock_irqrestore(&qends->ends_lock, flags);
 623         canque_edge_decref(edge);
 624         return next;
 625 }
 626
 627 #define canque_for_each_outedge(qends, edge) \
 628             for(edge=canque_first_outedge(qends);edge;edge=canque_next_outedge(qends, edge))
 629
 630 /* Linux kernel specific functions */
 631
 632 struct canque_edge_t *canque_new_edge_kern(int slotsnr);
 633
 634 int canque_get_inslot4id_wait_kern(struct canque_ends_t *qends,
 635         struct canque_edge_t **qedgep, struct canque_slot_t **slotp,
 636         int cmd, unsigned long id, int prio);
 637
 638 int canque_get_outslot_wait_kern(struct canque_ends_t *qends,
 639         struct canque_edge_t **qedgep, struct canque_slot_t **slotp);
 640
 641 int canque_sync_wait_kern(struct canque_ends_t *qends, struct canque_edge_t *qedge);
 642
 643 int canqueue_ends_init_kern(struct canque_ends_t *qends);
 644
 645 int canqueue_ends_dispose_kern(struct canque_ends_t *qends, int sync);
 646
 647 void canqueue_kern_initialize(void);
 648
 649
 650 #endif /*_CAN_QUEUE_H*/