Correction of spinlock acquire order.
[lincan.git] / lincan / include / can_queue.h
1 /* can_queue.h - CAN queues and message passing infrastructure 
2  * Linux CAN-bus device driver.
3  * Written 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 #ifndef _CAN_QUEUE_H
10 #define _CAN_QUEUE_H
11
12 #include "./canmsg.h"
13 #include "./constants.h"
14 #include "./can_sysdep.h"
15
16 /**
17  * struct canque_slot_t - one CAN message slot in the CAN FIFO queue 
18  * @next: pointer to the next/younger slot
19  * @slot_flags: space for flags and optional command describing action
20  *      associated with slot data
21  * @msg: space for one CAN message
22  *
23  * This structure is used to store CAN messages in the CAN FIFO queue.
24  */
25  struct canque_slot_t {
26         struct canque_slot_t *next;
27         unsigned long slot_flags;
28         struct canmsg_t msg;
29 };
30
31 #define CAN_SLOTF_CMD   0x00ff  /*  */
32
33 /**
34  * struct canque_fifo_t - CAN FIFO queue representation
35  * @fifo_flags: this field holds global flags describing state of the FIFO.
36  *      %CAN_FIFOF_ERROR is set when some error condition occurs.
37  *      %CAN_FIFOF_ERR2BLOCK defines, that error should lead to the FIFO block state.
38  *      %CAN_FIFOF_BLOCK state blocks insertion of the next messages. 
39  *      %CAN_FIFOF_OVERRUN attempt to acquire new slot, when FIFO is full. 
40  *      %CAN_FIFOF_FULL indicates FIFO full state. 
41  *      %CAN_FIFOF_EMPTY indicates no allocated slot in the FIFO.
42  *      %CAN_FIFOF_DEAD condition indication. Used when FIFO is beeing destroyed.
43  * @error_code: futher description of error condition
44  * @head: pointer to the FIFO head, oldest slot
45  * @tail: pointer to the location, where pointer to newly inserted slot
46  *      should be added
47  * @flist: pointer to list of the free slots associated with queue
48  * @entry: pointer to the memory allocated for the list slots.
49  * @fifo_lock: the lock to ensure atomicity of slot manipulation operations.
50  * @slotsnr:  number of allocated slots
51  *
52  * This structure represents CAN FIFO queue. It is implemented as 
53  * a single linked list of slots prepared for processing. The empty slots
54  * are stored in single linked list (@flist).
55  */
56 struct canque_fifo_t {
57         unsigned long fifo_flags;
58         unsigned long error_code;
59         struct canque_slot_t *head;     /* points to the oldest entry */
60         struct canque_slot_t **tail;    /* points to NULL pointer for chaining */
61         struct canque_slot_t *flist;    /* points the first entry in the free list */
62         struct canque_slot_t *entry;    /* points to first allocated entry */
63         can_spinlock_t fifo_lock;       /* can_spin_lock_irqsave / can_spin_unlock_irqrestore */
64         int    slotsnr;
65 };
66
67 #define CAN_FIFOF_DESTROY_b     15
68 #define CAN_FIFOF_ERROR_b       14
69 #define CAN_FIFOF_ERR2BLOCK_b   13
70 #define CAN_FIFOF_BLOCK_b       12
71 #define CAN_FIFOF_OVERRUN_b     11
72 #define CAN_FIFOF_FULL_b        10
73 #define CAN_FIFOF_EMPTY_b       9
74 #define CAN_FIFOF_DEAD_b        8
75 #define CAN_FIFOF_INACTIVE_b    7
76 #define CAN_FIFOF_FREEONEMPTY_b 6
77 #define CAN_FIFOF_READY_b       5
78 #define CAN_FIFOF_NOTIFYPEND_b  4
79 #define CAN_FIFOF_RTL_MEM_b     3
80
81 #define CAN_FIFOF_DESTROY       (1<<CAN_FIFOF_DESTROY_b)
82 #define CAN_FIFOF_ERROR         (1<<CAN_FIFOF_ERROR_b)
83 #define CAN_FIFOF_ERR2BLOCK     (1<<CAN_FIFOF_ERR2BLOCK_b)
84 #define CAN_FIFOF_BLOCK         (1<<CAN_FIFOF_BLOCK_b)
85 #define CAN_FIFOF_OVERRUN       (1<<CAN_FIFOF_OVERRUN_b)
86 #define CAN_FIFOF_FULL          (1<<CAN_FIFOF_FULL_b)
87 #define CAN_FIFOF_EMPTY         (1<<CAN_FIFOF_EMPTY_b)
88 #define CAN_FIFOF_DEAD          (1<<CAN_FIFOF_DEAD_b)
89 #define CAN_FIFOF_INACTIVE      (1<<CAN_FIFOF_INACTIVE_b)
90 #define CAN_FIFOF_FREEONEMPTY   (1<<CAN_FIFOF_FREEONEMPTY_b)
91 #define CAN_FIFOF_READY         (1<<CAN_FIFOF_READY_b)
92 #define CAN_FIFOF_NOTIFYPEND    (1<<CAN_FIFOF_NOTIFYPEND_b)
93 #define CAN_FIFOF_RTL_MEM       (1<<CAN_FIFOF_RTL_MEM_b)
94
95 #define canque_fifo_test_fl(fifo,fifo_fl) \
96   test_bit(CAN_FIFOF_##fifo_fl##_b,&(fifo)->fifo_flags)
97 #define canque_fifo_set_fl(fifo,fifo_fl) \
98   set_bit(CAN_FIFOF_##fifo_fl##_b,&(fifo)->fifo_flags)
99 #define canque_fifo_clear_fl(fifo,fifo_fl) \
100   clear_bit(CAN_FIFOF_##fifo_fl##_b,&(fifo)->fifo_flags)
101 #define canque_fifo_test_and_set_fl(fifo,fifo_fl) \
102   test_and_set_bit(CAN_FIFOF_##fifo_fl##_b,&(fifo)->fifo_flags)
103 #define canque_fifo_test_and_clear_fl(fifo,fifo_fl) \
104   test_and_clear_bit(CAN_FIFOF_##fifo_fl##_b,&(fifo)->fifo_flags)
105
106
107 /**
108  * canque_fifo_get_inslot - allocate slot for the input of one CAN message 
109  * @fifo: pointer to the FIFO structure
110  * @slotp: pointer to location to store pointer to the allocated slot.
111  * @cmd: optional command associated with allocated slot.
112  *
113  * Return Value: The function returns negative value if there is no
114  *      free slot in the FIFO queue.
115  */
116 static inline
117 int canque_fifo_get_inslot(struct canque_fifo_t *fifo, struct canque_slot_t **slotp, int cmd)
118 {
119         can_spin_irqflags_t flags;
120         struct canque_slot_t *slot;
121         can_spin_lock_irqsave(&fifo->fifo_lock, flags);
122         /* get the first free slot slot from flist */
123         if(!(slot=fifo->flist)) {
124                 canque_fifo_set_fl(fifo,OVERRUN);
125                 canque_fifo_set_fl(fifo,FULL);
126                 can_spin_unlock_irqrestore(&fifo->fifo_lock, flags);
127                 *slotp=NULL;
128                 return -1;
129         }
130         /* adjust free slot list */
131         if(!(fifo->flist=slot->next))
132                 canque_fifo_set_fl(fifo,FULL);
133         can_spin_unlock_irqrestore(&fifo->fifo_lock, flags);
134         *slotp=slot;
135         slot->slot_flags=cmd&CAN_SLOTF_CMD;
136         return 1;
137 }
138
139 /**
140  * canque_fifo_put_inslot - releases slot to further processing
141  * @fifo: pointer to the FIFO structure
142  * @slot: pointer to the slot previously acquired by canque_fifo_get_inslot().
143  *
144  * Return Value: The nonzero return value indicates, that the queue was empty
145  *      before call to the function. The caller should wake-up output side of the queue.
146  */
147 static inline
148 int canque_fifo_put_inslot(struct canque_fifo_t *fifo, struct canque_slot_t *slot)
149 {
150         int ret;
151         can_spin_irqflags_t flags;
152         slot->next=NULL;
153         can_spin_lock_irqsave(&fifo->fifo_lock, flags);
154         if(*fifo->tail) can_printk(KERN_CRIT "canque_fifo_put_inslot: fifo->tail != NULL\n");
155         *fifo->tail=slot;
156         fifo->tail=&slot->next;
157         ret=0;
158         if(canque_fifo_test_and_clear_fl(fifo,EMPTY))
159           ret=CAN_FIFOF_EMPTY;  /* Fifo has been empty before put */
160         if(canque_fifo_test_and_clear_fl(fifo,INACTIVE))
161           ret=CAN_FIFOF_INACTIVE; /* Fifo has been empty before put */
162         can_spin_unlock_irqrestore(&fifo->fifo_lock, flags);
163         return ret;
164 }
165
166 /**
167  * canque_fifo_abort_inslot - release and abort slot
168  * @fifo: pointer to the FIFO structure
169  * @slot: pointer to the slot previously acquired by canque_fifo_get_inslot().
170  *
171  * Return Value: The nonzero value indicates, that fifo was full
172  */
173 static inline
174 int canque_fifo_abort_inslot(struct canque_fifo_t *fifo, struct canque_slot_t *slot)
175 {
176         int ret=0;
177         can_spin_irqflags_t flags;
178         can_spin_lock_irqsave(&fifo->fifo_lock, flags);
179         slot->next=fifo->flist;
180         fifo->flist=slot;
181         if(canque_fifo_test_and_clear_fl(fifo,FULL))
182                 ret=CAN_FIFOF_FULL;
183         can_spin_unlock_irqrestore(&fifo->fifo_lock, flags);
184         return ret;
185 }
186
187 /**
188  * canque_fifo_test_outslot - test and get ready slot from the FIFO
189  * @fifo: pointer to the FIFO structure
190  * @slotp: pointer to location to store pointer to the oldest slot from the FIFO.
191  *
192  * Return Value: The negative value indicates, that queue is empty.
193  *      The positive or zero value represents command stored into slot by
194  *      the call to the function canque_fifo_get_inslot().
195  *      The successfully acquired FIFO output slot has to be released by
196  *      the call canque_fifo_free_outslot() or canque_fifo_again_outslot().
197  */
198 static inline
199 int canque_fifo_test_outslot(struct canque_fifo_t *fifo, struct canque_slot_t **slotp)
200 {
201         can_spin_irqflags_t flags;
202         int cmd;
203         struct canque_slot_t *slot;
204         can_spin_lock_irqsave(&fifo->fifo_lock, flags);
205         if(!(slot=fifo->head)){;
206                 canque_fifo_set_fl(fifo,EMPTY);
207                 can_spin_unlock_irqrestore(&fifo->fifo_lock, flags);
208                 *slotp=NULL;
209                 return -1;
210         }
211         if(!(fifo->head=slot->next))
212                 fifo->tail=&fifo->head;
213         can_spin_unlock_irqrestore(&fifo->fifo_lock, flags);
214
215         *slotp=slot;
216         cmd=slot->slot_flags;
217         return cmd&CAN_SLOTF_CMD;
218 }
219
220
221 /**
222  * canque_fifo_free_outslot - free processed FIFO slot
223  * @fifo: pointer to the FIFO structure
224  * @slot: pointer to the slot previously acquired by canque_fifo_test_outslot().
225  *
226  * Return Value: The returned value informs about FIFO state change.
227  *      The mask %CAN_FIFOF_FULL indicates, that the FIFO was full before
228  *      the function call. The mask %CAN_FIFOF_EMPTY informs, that last ready slot
229  *      has been processed.
230  */
231 static inline
232 int canque_fifo_free_outslot(struct canque_fifo_t *fifo, struct canque_slot_t *slot)
233 {
234         int ret=0;
235         can_spin_irqflags_t flags;
236         can_spin_lock_irqsave(&fifo->fifo_lock, flags);
237         slot->next=fifo->flist;
238         fifo->flist=slot;
239         if(canque_fifo_test_and_clear_fl(fifo,FULL))
240                 ret=CAN_FIFOF_FULL;
241         if(!(fifo->head)){
242                 canque_fifo_set_fl(fifo,EMPTY);
243                 ret|=CAN_FIFOF_EMPTY;
244         }
245         can_spin_unlock_irqrestore(&fifo->fifo_lock, flags);
246         return ret;
247 }
248
249 /**
250  * canque_fifo_again_outslot - interrupt and postpone processing of the slot
251  * @fifo: pointer to the FIFO structure
252  * @slot: pointer to the slot previously acquired by canque_fifo_test_outslot().
253  *
254  * Return Value: The function cannot fail..
255  */
256 static inline
257 int canque_fifo_again_outslot(struct canque_fifo_t *fifo, struct canque_slot_t *slot)
258 {
259         can_spin_irqflags_t flags;
260         can_spin_lock_irqsave(&fifo->fifo_lock, flags);
261         if(!(slot->next=fifo->head))
262                 fifo->tail=&slot->next;
263         fifo->head=slot;
264         can_spin_unlock_irqrestore(&fifo->fifo_lock, flags);
265         return 1;
266 }
267
268 int canque_fifo_flush_slots(struct canque_fifo_t *fifo);
269
270 int canque_fifo_init_slots(struct canque_fifo_t *fifo);
271
272 #define CANQUEUE_PRIO_NR  3
273
274 /* Forward declarations for external types */
275 struct msgobj_t;
276 struct chip_t;
277
278 /**
279  * struct canque_edge_t - CAN message delivery subsystem graph edge
280  * @fifo: place where primitive @struct canque_fifo_t FIFO is located.
281  * @filtid: the possible CAN message identifiers filter.
282  * @filtmask: the filter mask, the comparison considers only
283  *      @filtid bits corresponding to set bits in the @filtmask field.
284  * @inpeers: the lists of all peers FIFOs connected by their
285  *      input side (@inends) to the same terminal (@struct canque_ends_t).
286  * @outpeers: the lists of all peers FIFOs connected by their
287  *      output side (@outends) to the same terminal (@struct canque_ends_t).
288  * @activepeers: the lists of peers FIFOs connected by their
289  *      output side (@outends) to the same terminal (@struct canque_ends_t)
290  *      with same priority and active state.
291  * @inends: the pointer to the FIFO input side terminal (@struct canque_ends_t).
292  * @outends: the pointer to the FIFO output side terminal (@struct canque_ends_t).
293  * @edge_used: the atomic usage counter, mainly used for safe destruction of the edge.
294  * @edge_prio: the assigned queue priority from the range 0 to %CANQUEUE_PRIO_NR-1
295  * @edge_num: edge sequential number intended for debugging purposes only
296  * @pending_peers: edges with pending delayed events (RTL->Linux calls)
297  * @pending_inops: bitmask of pending operations
298  * @pending_outops: bitmask of pending operations
299  *
300  * This structure represents one direction connection from messages source 
301  * (@inends) to message consumer (@outends) fifo ends hub. The edge contains
302  * &struct canque_fifo_t for message fifo implementation.
303  */
304 struct canque_edge_t {
305         struct canque_fifo_t fifo;
306         unsigned long filtid;
307         unsigned long filtmask;
308         struct list_head inpeers;
309         struct list_head outpeers;
310         struct list_head activepeers;
311         struct canque_ends_t *inends;
312         struct canque_ends_t *outends;
313         atomic_t edge_used;
314         int edge_prio;
315         int edge_num;
316     #ifdef CAN_WITH_RTL
317         struct list_head pending_peers;
318         unsigned long pending_inops;
319         unsigned long pending_outops;
320     #endif /*CAN_WITH_RTL*/
321 };
322
323 /**
324  * struct canque_ends_t - CAN message delivery subsystem graph vertex (FIFO ends)
325  * @ends_flags: this field holds flags describing state of the ENDS structure.
326  * @active: the array of the lists of active edges directed to the ends structure
327  *      with ready messages. The array is indexed by the edges priorities. 
328  * @idle: the list of the edges directed to the ends structure with empty FIFOs.
329  * @inlist: the list of outgoing edges input sides.
330  * @outlist: the list of all incoming edges output sides. Each of there edges
331  *      is listed on one of @active or @idle lists.
332  * @ends_lock: the lock synchronizing operations between threads accessing
333  *      same ends structure.
334  * @notify: pointer to notify procedure. The next state changes are notified.
335  *      %CANQUEUE_NOTIFY_EMPTY (out->in call) - all slots are processed by FIFO out side. 
336  *      %CANQUEUE_NOTIFY_SPACE (out->in call) - full state negated => there is space for new message.
337  *      %CANQUEUE_NOTIFY_PROC  (in->out call) - empty state negated => out side is requested to process slots.
338  *      %CANQUEUE_NOTIFY_NOUSR (both) - notify, that the last user has released the edge usage
339  *              called with some lock to prevent edge disappear.
340  *      %CANQUEUE_NOTIFY_DEAD  (both) - edge is in progress of deletion.
341  *      %CANQUEUE_NOTIFY_ATACH (both) - new edge has been attached to end.
342  *      %CANQUEUE_NOTIFY_FILTCH (out->in call) - edge filter rules changed
343  *      %CANQUEUE_NOTIFY_ERROR  (out->in call) - error in messages processing.
344  * @context: space to store ends user specific information
345  * @endinfo: space to store some other ends usage specific informations
346  *      mainly for waking-up by the notify calls.
347  * @dead_peers: used to chain ends wanting for postponed destruction
348  *
349  * Structure represents place to connect edges to for CAN communication entity.
350  * The zero, one or more incoming and outgoing edges can be connected to
351  * this structure.
352  */
353 struct canque_ends_t {
354         unsigned long ends_flags;
355         struct list_head active[CANQUEUE_PRIO_NR];
356         struct list_head idle;
357         struct list_head inlist;
358         struct list_head outlist;
359         can_spinlock_t ends_lock;       /* can_spin_lock_irqsave / can_spin_unlock_irqrestore */
360         void (*notify)(struct canque_ends_t *qends, struct canque_edge_t *qedge, int what);
361         void *context;
362         union {
363                 struct {
364                         wait_queue_head_t readq;
365                         wait_queue_head_t writeq;
366                         wait_queue_head_t emptyq;
367                     #ifdef CAN_ENABLE_KERN_FASYNC
368                         struct fasync_struct *fasync;
369                     #endif /*CAN_ENABLE_KERN_FASYNC*/
370                 } fileinfo;
371             #ifdef CAN_WITH_RTL
372                 struct {
373                         rtl_spinlock_t rtl_lock;
374                         rtl_wait_t rtl_readq;
375                         atomic_t   rtl_readq_age;
376                         rtl_wait_t rtl_writeq;
377                         atomic_t   rtl_writeq_age;
378                         rtl_wait_t rtl_emptyq;
379                         atomic_t   rtl_emptyq_age;
380                         unsigned long pend_flags;
381                 } rtlinfo;
382             #endif /*CAN_WITH_RTL*/
383                 struct {
384                         struct msgobj_t *msgobj;
385                         struct chip_t *chip;
386                     #ifndef CAN_WITH_RTL
387                         wait_queue_head_t daemonq;
388                     #else /*CAN_WITH_RTL*/
389                         pthread_t worker_thread;
390                     #endif /*CAN_WITH_RTL*/
391                 } chipinfo;
392         } endinfo;
393         struct list_head dead_peers;
394 };
395
396 #define CANQUEUE_NOTIFY_EMPTY  1 /* out -> in - all slots are processed by FIFO out side */
397 #define CANQUEUE_NOTIFY_SPACE  2 /* out -> in - full state negated => there is space for new message */
398 #define CANQUEUE_NOTIFY_PROC   3 /* in -> out - empty state negated => out side is requested to process slots */
399 #define CANQUEUE_NOTIFY_NOUSR  4 /* called with some lock to prevent edge disappear */
400 #define CANQUEUE_NOTIFY_DEAD   5 /*  */
401 #define CANQUEUE_NOTIFY_DEAD_WANTED 6 /*  */
402 #define CANQUEUE_NOTIFY_ATTACH 7 /*  */
403 #define CANQUEUE_NOTIFY_FILTCH 8 /* filter changed */
404 #define CANQUEUE_NOTIFY_ERROR      0x10000 /* error notifiers */
405 #define CANQUEUE_NOTIFY_ERRTX_PREP 0x11001 /* tx preparation error */
406 #define CANQUEUE_NOTIFY_ERRTX_SEND 0x11002 /* tx send error */
407 #define CANQUEUE_NOTIFY_ERRTX_BUS  0x11003 /* tx bus error */
408
409 #define CAN_ENDSF_DEAD    (1<<0)
410 #define CAN_ENDSF_MEM_RTL (1<<1)
411
412 /**
413  * canque_notify_inends - request to send notification to the input ends
414  * @qedge: pointer to the edge structure
415  * @what: notification type
416  */
417 static inline
418 void canque_notify_inends(struct canque_edge_t *qedge, int what)
419 {
420         if(qedge->inends)
421                 if(qedge->inends->notify)
422                         qedge->inends->notify(qedge->inends,qedge,what);
423 }
424
425 /**
426  * canque_notify_outends - request to send notification to the output ends
427  * @qedge: pointer to the edge structure
428  * @what: notification type
429  */
430 static inline
431 void canque_notify_outends(struct canque_edge_t *qedge, int what)
432 {
433         if(qedge->outends)
434                 if(qedge->outends->notify)
435                         qedge->outends->notify(qedge->outends,qedge,what);
436 }
437
438 /**
439  * canque_notify_bothends - request to send notification to the both ends
440  * @qedge: pointer to the edge structure
441  * @what: notification type
442  */
443 static inline
444 void canque_notify_bothends(struct canque_edge_t *qedge, int what)
445 {
446         canque_notify_inends(qedge, what);
447         canque_notify_outends(qedge, what);
448 }
449
450 /**
451  * canque_activate_edge - mark output end of the edge as active
452  * @qedge: pointer to the edge structure
453  * @inends: input side of the edge
454  *
455  * Function call moves output side of the edge from idle onto active edges
456  * list. This function has to be called with edge reference count held.
457  * that is same as for most of other edge functions.
458  */
459 static inline
460 void canque_activate_edge(struct canque_ends_t *inends, struct canque_edge_t *qedge)
461 {
462         can_spin_irqflags_t flags;
463         struct canque_ends_t *outends;
464         if(qedge->edge_prio>=CANQUEUE_PRIO_NR)
465                 qedge->edge_prio=CANQUEUE_PRIO_NR-1;
466         if((outends=qedge->outends)){
467                 can_spin_lock_irqsave(&outends->ends_lock, flags);
468                 can_spin_lock(&qedge->fifo.fifo_lock);
469                 if(!canque_fifo_test_fl(&qedge->fifo,EMPTY)){
470                         list_del(&qedge->activepeers);
471                         list_add_tail(&qedge->activepeers,&outends->active[qedge->edge_prio]);
472                 }
473                 can_spin_unlock(&qedge->fifo.fifo_lock);
474                 can_spin_unlock_irqrestore(&outends->ends_lock, flags);
475         }
476 }
477
478 /**
479  * canque_filtid2internal - converts message ID and filter flags into internal format
480  * @id: CAN message 11 or 29 bit identifier
481  * @filtflags: CAN message flags
482  *
483  * This function maps message ID and %MSG_RTR, %MSG_EXT and %MSG_LOCAL into one 32 bit number
484  */
485 static inline
486 unsigned int canque_filtid2internal(unsigned long id, int filtflags)
487 {
488         filtflags &= MSG_RTR|MSG_EXT|MSG_LOCAL;
489         filtflags += filtflags&MSG_RTR;
490         return (id&MSG_ID_MASK) | (filtflags<<28);
491 }
492
493 int canque_get_inslot(struct canque_ends_t *qends,
494         struct canque_edge_t **qedgep, struct canque_slot_t **slotp, int cmd);
495         
496 int canque_get_inslot4id(struct canque_ends_t *qends,
497         struct canque_edge_t **qedgep, struct canque_slot_t **slotp,
498         int cmd, unsigned long id, int prio);
499         
500 int canque_put_inslot(struct canque_ends_t *qends,
501         struct canque_edge_t *qedge, struct canque_slot_t *slot);
502
503 int canque_abort_inslot(struct canque_ends_t *qends,
504         struct canque_edge_t *qedge, struct canque_slot_t *slot);
505
506 int canque_filter_msg2edges(struct canque_ends_t *qends, struct canmsg_t *msg);
507
508 int canque_test_outslot(struct canque_ends_t *qends,
509         struct canque_edge_t **qedgep, struct canque_slot_t **slotp);
510
511 int canque_free_outslot(struct canque_ends_t *qends,
512         struct canque_edge_t *qedge, struct canque_slot_t *slot);
513
514 int canque_again_outslot(struct canque_ends_t *qends,
515         struct canque_edge_t *qedge, struct canque_slot_t *slot);
516
517 int canque_set_filt(struct canque_edge_t *qedge,
518         unsigned long filtid, unsigned long filtmask, int flags);
519         
520 int canque_flush(struct canque_edge_t *qedge);
521
522 int canqueue_disconnect_edge(struct canque_edge_t *qedge);
523
524 int canqueue_connect_edge(struct canque_edge_t *qedge, struct canque_ends_t *inends, struct canque_ends_t *outends);
525
526 int canqueue_ends_init_gen(struct canque_ends_t *qends);
527
528 void canqueue_block_inlist(struct canque_ends_t *qends);
529
530 void canqueue_block_outlist(struct canque_ends_t *qends);
531
532 int canqueue_ends_kill_inlist(struct canque_ends_t *qends, int send_rest);
533
534 int canqueue_ends_kill_outlist(struct canque_ends_t *qends);
535
536 int canqueue_ends_filt_conjuction(struct canque_ends_t *qends, struct canfilt_t *filt);
537
538 int canqueue_ends_flush_inlist(struct canque_ends_t *qends);
539
540 int canqueue_ends_flush_outlist(struct canque_ends_t *qends);
541
542 /* edge reference and traversal functions */
543
544 void canque_edge_do_dead(struct canque_edge_t *edge);
545
546 /**
547  * canque_edge_incref - increments edge reference count
548  * @qedg: pointer to the edge structure
549  */
550 static inline
551 void canque_edge_incref(struct canque_edge_t *edge)
552 {
553         atomic_inc(&edge->edge_used);
554 }
555
556 static inline
557 can_spin_irqflags_t canque_edge_lock_both_ends(struct canque_edge_t *edge)
558 {
559         can_spin_irqflags_t  flags;
560         if(edge->inends<edge->outends) {
561                 can_spin_lock_irqsave(&edge->inends->ends_lock, flags);
562                 can_spin_lock(&edge->outends->ends_lock);
563         }else{
564                 can_spin_lock_irqsave(&edge->outends->ends_lock, flags);
565                 if(edge->outends!=edge->inends) can_spin_lock(&edge->inends->ends_lock);
566         }
567         return flags;   
568 }
569
570 static inline
571 void canque_edge_unlock_both_ends(struct canque_edge_t *edge, can_spin_irqflags_t flags)
572 {
573         if(edge->outends!=edge->inends) can_spin_unlock(&edge->outends->ends_lock);
574         can_spin_unlock_irqrestore(&edge->inends->ends_lock, flags);
575 }
576
577 /* Non-inlined version of edge reference decrement */
578 void __canque_edge_decref(struct canque_edge_t *edge);
579
580 static inline
581 void __canque_edge_decref_body(struct canque_edge_t *edge)
582 {
583         can_spin_irqflags_t flags;
584         int dead_fl=0;
585         
586         flags=canque_edge_lock_both_ends(edge);
587         if(atomic_dec_and_test(&edge->edge_used)) {
588                 dead_fl=!canque_fifo_test_and_set_fl(&edge->fifo,DEAD);
589                 /* Because of former evolution of edge references 
590                    management notify of CANQUEUE_NOTIFY_NOUSR could
591                    be moved to canque_edge_do_dead :-) */
592         }
593         canque_edge_unlock_both_ends(edge, flags);
594         if(dead_fl) canque_edge_do_dead(edge);
595 }
596
597 #ifndef CAN_HAVE_ARCH_CMPXCHG
598 /**
599  * canque_edge_decref - decrements edge reference count
600  * @qedg: pointer to the edge structure
601  *
602  * This function has to be called without lock held for both ends of edge.
603  * If reference count drops to 0, function canque_edge_do_dead()
604  * is called.
605  */
606 static inline
607 void canque_edge_decref(struct canque_edge_t *edge)
608 {
609         __canque_edge_decref_body(edge);
610 }
611 #else
612 static inline
613 void canque_edge_decref(struct canque_edge_t *edge)
614 {
615         int x, y;
616         
617         x = atomic_read(&edge->edge_used);
618         do{
619                 if(x<=1)
620                         return __canque_edge_decref(edge);
621                 y=x;
622                 /* This code strongly depends on the definition of atomic_t !!!! */
623                 /* x=cmpxchg(&edge->edge_used, x, x-1); */
624                 /* Next alternative could be more portable */
625                 x=__cmpxchg(&edge->edge_used, x, x-1, sizeof(atomic_t));
626                 /* If even this does not help, comment out CAN_HAVE_ARCH_CMPXCHG in can_sysdep.h */
627         } while(x!=y);
628 }
629 #endif
630
631 static inline
632 struct canque_edge_t *canque_first_inedge(struct canque_ends_t *qends)
633 {
634         can_spin_irqflags_t flags;
635         struct list_head *entry;
636         struct canque_edge_t *edge;
637         
638         can_spin_lock_irqsave(&qends->ends_lock, flags);
639         entry=qends->inlist.next;
640     skip_dead:
641         if(entry != &qends->inlist) {
642                 edge=list_entry(entry,struct canque_edge_t,inpeers);
643                 if(canque_fifo_test_fl(&edge->fifo,DEAD)) {
644                         entry=entry->next;
645                         goto skip_dead;
646                 }
647                 canque_edge_incref(edge);
648         } else {
649                 edge=NULL;
650         }
651         can_spin_unlock_irqrestore(&qends->ends_lock, flags);
652         return edge;
653 }
654
655
656 static inline
657 struct canque_edge_t *canque_next_inedge(struct canque_ends_t *qends, struct canque_edge_t *edge)
658 {
659         can_spin_irqflags_t flags;
660         struct list_head *entry;
661         struct canque_edge_t *next;
662         
663         can_spin_lock_irqsave(&qends->ends_lock, flags);
664         entry=edge->inpeers.next;
665     skip_dead:
666         if(entry != &qends->inlist) {
667                 next=list_entry(entry,struct canque_edge_t,inpeers);
668                 if(canque_fifo_test_fl(&edge->fifo,DEAD)) {
669                         entry=entry->next;
670                         goto skip_dead;
671                 }
672                 canque_edge_incref(next);
673         } else {
674                 next=NULL;
675         }
676         can_spin_unlock_irqrestore(&qends->ends_lock, flags);
677         canque_edge_decref(edge);
678         return next;
679 }
680
681 #define canque_for_each_inedge(qends, edge) \
682             for(edge=canque_first_inedge(qends);edge;edge=canque_next_inedge(qends, edge))
683
684 static inline
685 struct canque_edge_t *canque_first_outedge(struct canque_ends_t *qends)
686 {
687         can_spin_irqflags_t flags;
688         struct list_head *entry;
689         struct canque_edge_t *edge;
690         
691         can_spin_lock_irqsave(&qends->ends_lock, flags);
692         entry=qends->outlist.next;
693     skip_dead:
694         if(entry != &qends->outlist) {
695                 edge=list_entry(entry,struct canque_edge_t,outpeers);
696                 if(canque_fifo_test_fl(&edge->fifo,DEAD)) {
697                         entry=entry->next;
698                         goto skip_dead;
699                 }
700                 canque_edge_incref(edge);
701         } else {
702                 edge=NULL;
703         }
704         can_spin_unlock_irqrestore(&qends->ends_lock, flags);
705         return edge;
706 }
707
708
709 static inline
710 struct canque_edge_t *canque_next_outedge(struct canque_ends_t *qends, struct canque_edge_t *edge)
711 {
712         can_spin_irqflags_t flags;
713         struct list_head *entry;
714         struct canque_edge_t *next;
715         
716         can_spin_lock_irqsave(&qends->ends_lock, flags);
717         entry=edge->outpeers.next;
718     skip_dead:
719         if(entry != &qends->outlist) {
720                 next=list_entry(entry,struct canque_edge_t,outpeers);
721                 if(canque_fifo_test_fl(&edge->fifo,DEAD)) {
722                         entry=entry->next;
723                         goto skip_dead;
724                 }
725                 canque_edge_incref(next);
726         } else {
727                 next=NULL;
728         }
729         can_spin_unlock_irqrestore(&qends->ends_lock, flags);
730         canque_edge_decref(edge);
731         return next;
732 }
733
734 #define canque_for_each_outedge(qends, edge) \
735             for(edge=canque_first_outedge(qends);edge;edge=canque_next_outedge(qends, edge))
736
737 /* Linux kernel specific functions */
738
739 int canque_fifo_init_kern(struct canque_fifo_t *fifo, int slotsnr);
740
741 int canque_fifo_done_kern(struct canque_fifo_t *fifo);
742
743 struct canque_edge_t *canque_new_edge_kern(int slotsnr);
744
745 int canque_get_inslot4id_wait_kern(struct canque_ends_t *qends,
746         struct canque_edge_t **qedgep, struct canque_slot_t **slotp,
747         int cmd, unsigned long id, int prio);
748
749 int canque_get_outslot_wait_kern(struct canque_ends_t *qends,
750         struct canque_edge_t **qedgep, struct canque_slot_t **slotp);
751
752 int canque_sync_wait_kern(struct canque_ends_t *qends, struct canque_edge_t *qedge);
753
754 int canqueue_ends_init_kern(struct canque_ends_t *qends);
755
756 int canqueue_ends_dispose_kern(struct canque_ends_t *qends, int sync);
757
758 void canqueue_ends_dispose_postpone(struct canque_ends_t *qends);
759
760 void canqueue_kern_initialize(void);
761
762 #ifdef CAN_WITH_RTL
763
764 extern struct tasklet_struct canque_dead_tl;    /*publication required only for RTL*/
765
766 /* RT-Linux specific functions and variables */
767
768 extern int canqueue_rtl_irq;
769
770 extern unsigned long canqueue_rtl2lin_pend;
771
772 #define CAN_RTL2LIN_PEND_DEAD_b 0
773
774 void canqueue_rtl_initialize(void);
775 void canqueue_rtl_done(void);
776
777 int canqueue_rtl2lin_check_and_pend(struct canque_ends_t *qends,
778                          struct canque_edge_t *qedge, int what);
779
780 struct canque_edge_t *canque_new_edge_rtl(int slotsnr);
781
782 void canque_dispose_edge_rtl(struct canque_edge_t *qedge);
783
784 int canque_get_inslot4id_wait_rtl(struct canque_ends_t *qends,
785         struct canque_edge_t **qedgep, struct canque_slot_t **slotp,
786         int cmd, unsigned long id, int prio);
787
788 int canque_get_outslot_wait_rtl(struct canque_ends_t *qends,
789         struct canque_edge_t **qedgep, struct canque_slot_t **slotp);
790
791 int canque_sync_wait_rtl(struct canque_ends_t *qends, struct canque_edge_t *qedge);
792
793 void canque_ends_free_rtl(struct canque_ends_t *qends);
794
795 int canqueue_ends_init_rtl(struct canque_ends_t *qends);
796
797 int canqueue_ends_dispose_rtl(struct canque_ends_t *qends, int sync);
798
799 #else /*CAN_WITH_RTL*/
800
801 static inline int canqueue_rtl2lin_check_and_pend(struct canque_ends_t *qends,
802                         struct canque_edge_t *qedge, int what) { return 0; }
803
804 #endif /*CAN_WITH_RTL*/
805
806
807 #endif /*_CAN_QUEUE_H*/