1 /* can_quekern.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
9 #include "../include/can.h"
10 #include "../include/can_sysdep.h"
11 #include "../include/can_queue.h"
15 extern atomic_t edge_num_cnt;
18 #define DEBUGQUE(fmt,args...) can_printk(KERN_ERR "can_quekern (debug): " fmt,\
22 #define DEBUGQUE(fmt,args...)
25 #define ERRMSGQUE(fmt,args...) can_printk(KERN_ERR "can_quekern: " fmt,\
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
35 extern int processlocal;
37 void canque_dead_func(unsigned long data);
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) */
50 struct canque_edge_t *canque_dead_edges_cut_first(void)
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))
58 edge=list_entry(canque_dead_edges.next,struct canque_edge_t,inpeers);
59 list_del(&edge->inpeers);
61 can_spin_unlock_irqrestore(&canque_dead_func_lock, flags);
65 void canque_dead_func(unsigned long data)
67 can_spin_irqflags_t flags;
68 struct canque_edge_t *qedge;
69 struct canque_ends_t *qends;
70 struct list_head *entry;
72 while((qedge=canque_dead_edges_cut_first())){
73 DEBUGQUE("edge %d disposed\n",qedge->edge_num);
75 if(canque_fifo_test_fl(&qedge->fifo,RTL_MEM)){
76 canque_dispose_edge_rtl(qedge);
79 #endif /*CAN_WITH_RTL*/
80 canque_fifo_done_kern(&qedge->fifo);
84 can_spin_lock_irqsave(&canque_dead_func_lock, flags);
85 entry=canque_dead_ends.next;
86 can_spin_unlock_irqrestore(&canque_dead_func_lock,flags);
87 /* lock can be released there, because only one instance of canque_dead_tl
88 can run at once and all other functions add ends only to head */
89 while(entry!=&canque_dead_ends){
90 qends=list_entry(entry,struct canque_ends_t,dead_peers);
92 if(!list_empty(&qends->inlist))
94 if(!list_empty(&qends->outlist))
96 can_spin_lock_irqsave(&canque_dead_func_lock, flags);
97 list_del(&qends->dead_peers);
98 can_spin_unlock_irqrestore(&canque_dead_func_lock,flags);
99 DEBUGQUE("ends structure disposed\n");
101 if(qends->ends_flags&CAN_ENDSF_MEM_RTL){
102 canque_ends_free_rtl(qends);
105 #endif /*CAN_WITH_RTL*/
111 static inline void canque_dead_tasklet_schedule(void)
114 if(!rtl_rt_system_is_idle()){
115 set_bit(CAN_RTL2LIN_PEND_DEAD_b,&canqueue_rtl2lin_pend);
116 rtl_global_pend_irq (canqueue_rtl_irq);
119 #endif /*CAN_WITH_RTL*/
121 tasklet_schedule(&canque_dead_tl);
125 void canque_edge_do_dead(struct canque_edge_t *edge, int dead_fl)
127 can_spin_irqflags_t flags;
131 canque_notify_bothends(edge,CANQUEUE_NOTIFY_NOUSR);
133 /* The problem of the above call is, that in RT-Linux to Linux notify
134 case is edge scheduled for delayed notify delivery, this needs
135 to be reflected there */
136 if(atomic_read(&edge->edge_used)>0){
137 can_spin_lock_irqsave(&edge->inends->ends_lock, flags);
138 can_spin_lock(&edge->outends->ends_lock);
139 if(atomic_read(&edge->edge_used)>0){
140 /* left edge to live for a while, banshee comes again in a while */
141 canque_fifo_clear_fl(&edge->fifo,DEAD);
142 can_spin_unlock(&edge->outends->ends_lock);
143 can_spin_unlock_irqrestore(&edge->inends->ends_lock, flags);
144 can_printk(KERN_ERR "can_quertl (debug): canque_edge_do_dead postponed\n");
147 can_spin_unlock(&edge->outends->ends_lock);
148 can_spin_unlock_irqrestore(&edge->inends->ends_lock, flags);
150 #endif /*CAN_WITH_RTL*/
152 if(canqueue_disconnect_edge(edge)<0){
153 ERRMSGQUE("canque_edge_do_dead: canqueue_disconnect_edge failed !!!\n");
157 can_spin_lock_irqsave(&canque_dead_func_lock, flags);
158 list_add(&edge->inpeers,&canque_dead_edges);
159 can_spin_unlock_irqrestore(&canque_dead_func_lock, flags);
160 canque_dead_tasklet_schedule();
165 /*if(qends->ends_flags & CAN_ENDSF_DEAD){
166 can_spin_lock_irqsave(&canque_dead_func_lock, flags);
167 list_del(&qends->dead_peers);
168 list_add(&qends->dead_peers,&canque_dead_ends);
169 can_spin_unlock_irqrestore(&canque_dead_func_lock, flags);
170 tasklet_schedule(&canque_dead_tl);
175 * canqueue_notify_kern - notification callback handler for Linux userspace clients
176 * @qends: pointer to the callback side ends structure
177 * @qedge: edge which invoked notification
178 * @what: notification type
180 * The notification event is handled directly by call of this function except case,
181 * when called from RT-Linux context in mixed mode Linux/RT-Linux compilation.
182 * It is not possible to directly call Linux kernel synchronization primitives
183 * in such case. The notification request is postponed and signaled by @pending_inops flags
184 * by call canqueue_rtl2lin_check_and_pend() function.
185 * The edge reference count is increased until until all pending notifications are processed.
187 void canqueue_notify_kern(struct canque_ends_t *qends, struct canque_edge_t *qedge, int what)
189 DEBUGQUE("canqueue_notify_kern for edge %d, use %d and event %d\n",
190 qedge->edge_num,(int)atomic_read(&qedge->edge_used),what);
192 /* delay event delivery for RT-Linux -> kernel notifications */
193 if(canqueue_rtl2lin_check_and_pend(qends,qedge,what)){
194 DEBUGQUE("canqueue_notify_kern postponed\n");
199 case CANQUEUE_NOTIFY_EMPTY:
200 wake_up(&qends->endinfo.fileinfo.emptyq);
201 if(canque_fifo_test_and_clear_fl(&qedge->fifo, FREEONEMPTY))
202 canque_edge_decref(qedge);
204 case CANQUEUE_NOTIFY_SPACE:
205 wake_up(&qends->endinfo.fileinfo.writeq);
206 #ifdef CAN_ENABLE_KERN_FASYNC
207 /* Asynchronous I/O processing */
208 kill_fasync(&qends->endinfo.fileinfo.fasync, SIGIO, POLL_OUT);
209 #endif /*CAN_ENABLE_KERN_FASYNC*/
211 case CANQUEUE_NOTIFY_PROC:
212 wake_up(&qends->endinfo.fileinfo.readq);
213 #ifdef CAN_ENABLE_KERN_FASYNC
214 /* Asynchronous I/O processing */
215 kill_fasync(&qends->endinfo.fileinfo.fasync, SIGIO, POLL_IN);
216 #endif /*CAN_ENABLE_KERN_FASYNC*/
218 case CANQUEUE_NOTIFY_NOUSR:
219 wake_up(&qends->endinfo.fileinfo.readq);
220 wake_up(&qends->endinfo.fileinfo.writeq);
221 wake_up(&qends->endinfo.fileinfo.emptyq);
223 case CANQUEUE_NOTIFY_DEAD_WANTED:
224 case CANQUEUE_NOTIFY_DEAD:
225 if(canque_fifo_test_and_clear_fl(&qedge->fifo, READY))
226 canque_edge_decref(qedge);
228 case CANQUEUE_NOTIFY_ATTACH:
234 * canqueue_ends_init_kern - Linux userspace clients specific ends initialization
235 * @qends: pointer to the callback side ends structure
237 int canqueue_ends_init_kern(struct canque_ends_t *qends)
239 canqueue_ends_init_gen(qends);
241 init_waitqueue_head(&qends->endinfo.fileinfo.readq);
242 init_waitqueue_head(&qends->endinfo.fileinfo.writeq);
243 init_waitqueue_head(&qends->endinfo.fileinfo.emptyq);
244 #ifdef CAN_ENABLE_KERN_FASYNC
245 qends->endinfo.fileinfo.fasync=NULL;
246 #endif /*CAN_ENABLE_KERN_FASYNC*/
248 qends->notify=canqueue_notify_kern;
249 DEBUGQUE("canqueue_ends_init_kern\n");
255 * canque_get_inslot4id_wait_kern - find or wait for best outgoing edge and slot for given ID
256 * @qends: ends structure belonging to calling communication object
257 * @qedgep: place to store pointer to found edge
258 * @slotp: place to store pointer to allocated slot
259 * @cmd: command type for slot
260 * @id: communication ID of message to send into edge
261 * @prio: optional priority of message
263 * Same as canque_get_inslot4id(), except, that it waits for free slot
264 * in case, that queue is full. Function is specific for Linux userspace clients.
265 * Return Value: If there is no usable edge negative value is returned.
267 int canque_get_inslot4id_wait_kern(struct canque_ends_t *qends,
268 struct canque_edge_t **qedgep, struct canque_slot_t **slotp,
269 int cmd, unsigned long id, int prio)
272 DEBUGQUE("canque_get_inslot4id_wait_kern for cmd %d, id %ld, prio %d\n",cmd,id,prio);
273 wait_event_interruptible((qends->endinfo.fileinfo.writeq),
274 (ret=canque_get_inslot4id(qends,qedgep,slotp,cmd,id,prio))!=-1);
279 * canque_get_outslot_wait_kern - receive or wait for ready slot for given ends
280 * @qends: ends structure belonging to calling communication object
281 * @qedgep: place to store pointer to found edge
282 * @slotp: place to store pointer to received slot
284 * The same as canque_test_outslot(), except it waits in the case, that there is
285 * no ready slot for given ends. Function is specific for Linux userspace clients.
286 * Return Value: Negative value informs, that there is no ready output
287 * slot for given ends. Positive value is equal to the command
288 * slot has been allocated by the input side.
290 int canque_get_outslot_wait_kern(struct canque_ends_t *qends,
291 struct canque_edge_t **qedgep, struct canque_slot_t **slotp)
294 DEBUGQUE("canque_get_outslot_wait_kern\n");
295 wait_event_interruptible((qends->endinfo.fileinfo.readq),
296 (ret=canque_test_outslot(qends,qedgep,slotp))!=-1);
301 * canque_sync_wait_kern - wait for all slots processing
302 * @qends: ends structure belonging to calling communication object
303 * @qedge: pointer to edge
305 * Functions waits for ends transition into empty state.
306 * Return Value: Positive value indicates, that edge empty state has been reached.
307 * Negative or zero value informs about interrupted wait or other problem.
309 int canque_sync_wait_kern(struct canque_ends_t *qends, struct canque_edge_t *qedge)
312 DEBUGQUE("canque_sync_wait_kern\n");
313 wait_event_interruptible((qends->endinfo.fileinfo.emptyq),
314 (ret=canque_fifo_test_fl(&qedge->fifo,EMPTY)?1:0));
320 * canque_fifo_init_kern - initialize one CAN FIFO
321 * @fifo: pointer to the FIFO structure
322 * @slotsnr: number of requested slots
324 * Return Value: The negative value indicates, that there is no memory
325 * to allocate space for the requested number of the slots.
327 int canque_fifo_init_kern(struct canque_fifo_t *fifo, int slotsnr)
330 if(!slotsnr) slotsnr=MAX_BUF_LENGTH;
331 size=sizeof(struct canque_slot_t)*slotsnr;
332 fifo->entry=kmalloc(size,GFP_KERNEL);
333 if(!fifo->entry) return -1;
334 fifo->slotsnr=slotsnr;
335 return canque_fifo_init_slots(fifo);
339 * canque_fifo_done_kern - frees slots allocated for CAN FIFO
340 * @fifo: pointer to the FIFO structure
342 int canque_fifo_done_kern(struct canque_fifo_t *fifo)
352 * canque_new_edge_kern - allocate new edge structure in the Linux kernel context
353 * @slotsnr: required number of slots in the newly allocated edge structure
355 * Return Value: Returns pointer to allocated slot structure or %NULL if
356 * there is not enough memory to process operation.
358 struct canque_edge_t *canque_new_edge_kern(int slotsnr)
360 struct canque_edge_t *qedge;
361 qedge = (struct canque_edge_t *)kmalloc(sizeof(struct canque_edge_t), GFP_KERNEL);
362 if(qedge == NULL) return NULL;
364 memset(qedge,0,sizeof(struct canque_edge_t));
365 can_spin_lock_init(&qedge->fifo.fifo_lock);
366 if(canque_fifo_init_kern(&qedge->fifo, slotsnr)<0){
368 DEBUGQUE("canque_new_edge_kern failed\n");
371 atomic_set(&qedge->edge_used,1);
373 qedge->filtmask = canque_filtid2internal(0l, (processlocal<2)? MSG_LOCAL:0);
374 qedge->edge_prio = 0;
376 /* not exactly clean, but enough for debugging */
377 atomic_inc(&edge_num_cnt);
378 qedge->edge_num=atomic_read(&edge_num_cnt);
379 #endif /* CAN_DEBUG */
380 DEBUGQUE("canque_new_edge_kern %d\n",qedge->edge_num);
384 #ifdef USE_SYNC_DISCONNECT_EDGE_KERN
386 /*not included in doc
387 * canqueue_disconnect_edge_kern - disconnect edge from communicating entities with wait
388 * @qends: ends structure belonging to calling communication object
389 * @qedge: pointer to edge
391 * Same as canqueue_disconnect_edge(), but tries to wait for state with zero
393 * Return Value: Negative value means, that edge is used and cannot
394 * be disconnected yet. Operation has to be delayed.
396 int canqueue_disconnect_edge_kern(struct canque_ends_t *qends, struct canque_edge_t *qedge)
398 canque_fifo_set_fl(&qedge->fifo,BLOCK);
399 DEBUGQUE("canqueue_disconnect_edge_kern %d called\n",qedge->edge_num);
400 if(!canque_fifo_test_and_set_fl(&qedge->fifo,DEAD)){
401 canque_notify_bothends(qedge, CANQUEUE_NOTIFY_DEAD);
403 if(atomic_read(&qedge->edge_used)>0)
404 atomic_dec(&qedge->edge_used);
406 DEBUGQUE("canqueue_disconnect_edge_kern %d waiting\n",qedge->edge_num);
407 wait_event((qends->endinfo.fileinfo.emptyq),
408 (canqueue_disconnect_edge(qedge)>=0));
410 /*set_current_state(TASK_UNINTERRUPTIBLE);*/
411 /*schedule_timeout(HZ);*/
414 DEBUGQUE("canqueue_disconnect_edge_kern cannot set DEAD\n");
420 int canqueue_disconnect_list_kern(struct canque_ends_t *qends, struct list_head *list)
422 struct canque_edge_t *edge;
423 can_spin_irqflags_t flags;
425 can_spin_lock_irqsave(&qends->ends_lock,flags);
426 if(list_empty(list)){
427 can_spin_unlock_irqrestore(&qends->ends_lock,flags);
430 if(list == &qends->inlist)
431 edge=list_entry(list->next,struct canque_edge_t,inpeers);
433 edge=list_entry(list->next,struct canque_edge_t,outpeers);
434 atomic_inc(&edge->edge_used);
435 can_spin_unlock_irqrestore(&qends->ends_lock,flags);
436 if(canqueue_disconnect_edge_kern(qends, edge)>=0) {
437 /* Free edge memory */
438 canque_fifo_done_kern(&edge->fifo);
441 canque_notify_bothends(edge, CANQUEUE_NOTIFY_DEAD_WANTED);
442 canque_edge_decref(edge);
443 DEBUGQUE("canqueue_disconnect_list_kern in troubles\n");
444 DEBUGQUE("the edge %d has usage count %d and flags %ld\n",edge->edge_num,atomic_read(&edge->edge_used),edge->fifo.fifo_flags);
450 #endif /*USE_SYNC_DISCONNECT_EDGE_KERN*/
453 int canqueue_ends_sync_all_kern(struct canque_ends_t *qends)
455 struct canque_edge_t *qedge;
457 canque_for_each_inedge(qends, qedge){
458 DEBUGQUE("canque_sync_wait_kern called for edge %d\n",qedge->edge_num);
459 canque_sync_wait_kern(qends, qedge);
465 void canqueue_ends_dispose_postpone(struct canque_ends_t *qends)
467 can_spin_irqflags_t flags;
469 can_spin_lock_irqsave(&canque_dead_func_lock, flags);
470 qends->ends_flags |= CAN_ENDSF_DEAD;
471 list_add(&qends->dead_peers,&canque_dead_ends);
472 can_spin_unlock_irqrestore(&canque_dead_func_lock, flags);
473 canque_dead_tasklet_schedule();
478 * canqueue_ends_dispose_kern - finalizing of the ends structure for Linux kernel clients
479 * @qends: pointer to ends structure
480 * @sync: flag indicating, that user wants to wait for processing of all remaining
483 * Return Value: Function should be designed such way to not fail.
485 int canqueue_ends_dispose_kern(struct canque_ends_t *qends, int sync)
489 DEBUGQUE("canqueue_ends_dispose_kern\n");
490 canqueue_block_inlist(qends);
491 canqueue_block_outlist(qends);
493 /*Wait for sending of all pending messages in the output FIFOs*/
495 canqueue_ends_sync_all_kern(qends);
497 /* Finish or kill all outgoing edges listed in inends */
498 delayed=canqueue_ends_kill_inlist(qends, 1);
499 /* Kill all incoming edges listed in outends */
500 delayed|=canqueue_ends_kill_outlist(qends);
502 wake_up(&qends->endinfo.fileinfo.readq);
503 wake_up(&qends->endinfo.fileinfo.writeq);
504 wake_up(&qends->endinfo.fileinfo.emptyq);
507 canqueue_ends_dispose_postpone(qends);
509 DEBUGQUE("canqueue_ends_dispose_kern delayed\n");
514 DEBUGQUE("canqueue_ends_dispose_kern finished\n");
518 void canqueue_kern_initialize()
520 can_spin_lock_init(&canque_dead_func_lock);