extern atomic_t edge_num_cnt;
#ifdef CAN_DEBUG
- #define DEBUGQUE(fmt,args...) printk(KERN_ERR "can_queue (debug): " fmt,\
+ #define DEBUGQUE(fmt,args...) can_printk(KERN_ERR "can_queue (debug): " fmt,\
##args)
#else
#define DEBUGQUE(fmt,args...)
#endif
-#define ERRMSGQUE(fmt,args...) printk(KERN_ERR "can_queue: " fmt,\
+#define ERRMSGQUE(fmt,args...) can_printk(KERN_ERR "can_queue: " fmt,\
##args)
while((qedge=canque_dead_edges_cut_first())){
DEBUGQUE("edge %d disposed\n",qedge->edge_num);
+ #ifdef CAN_WITH_RTL
+ if(canque_fifo_test_fl(&qedge->fifo,RTL_MEM)){
+ canque_dispose_edge_rtl(qedge);
+ continue;
+ }
+ #endif /*CAN_WITH_RTL*/
+ canque_fifo_done_kern(&qedge->fifo);
kfree(qedge);
}
can_spin_lock_irqsave(&canque_dead_func_lock, flags);
entry=canque_dead_ends.next;
can_spin_unlock_irqrestore(&canque_dead_func_lock,flags);
+ /* lock can be released there, because only one instance of canque_dead_tl
+ can run at once and all other functions add ends only to head */
while(entry!=&canque_dead_ends){
- qends=list_entry(canque_dead_ends.next,struct canque_ends_t,dead_peers);
+ qends=list_entry(entry,struct canque_ends_t,dead_peers);
entry=entry->next;
if(!list_empty(&qends->inlist))
continue;
list_del(&qends->dead_peers);
can_spin_unlock_irqrestore(&canque_dead_func_lock,flags);
DEBUGQUE("ends structure disposed\n");
+ #ifdef CAN_WITH_RTL
+ if(qends->ends_flags&CAN_ENDSF_MEM_RTL){
+ canque_ends_free_rtl(qends);
+ continue;
+ }
+ #endif /*CAN_WITH_RTL*/
kfree(qends);
}
}
+static inline void canque_dead_tasklet_schedule(void)
+{
+ #ifdef CAN_WITH_RTL
+ if(!rtl_rt_system_is_idle()){
+ set_bit(CAN_RTL2LIN_PEND_DEAD_b,&canqueue_rtl2lin_pend);
+ rtl_global_pend_irq (canqueue_rtl_irq);
+ return;
+ }
+ #endif /*CAN_WITH_RTL*/
+
+ tasklet_schedule(&canque_dead_tl);
+}
+
void canque_edge_do_dead(struct canque_edge_t *edge, int dead_fl)
{
can_spin_lock_irqsave(&canque_dead_func_lock, flags);
list_add(&edge->inpeers,&canque_dead_edges);
can_spin_unlock_irqrestore(&canque_dead_func_lock, flags);
- tasklet_schedule(&canque_dead_tl);
+ canque_dead_tasklet_schedule();
}
{
DEBUGQUE("canqueue_notify_kern for edge %d, use %d and event %d\n",
qedge->edge_num,(int)atomic_read(&qedge->edge_used),what);
+
+ /* delay event delivery for RT-Linux -> kernel notifications */
+ if(canqueue_rtl2lin_check_and_pend(qends,qedge,what)){
+ DEBUGQUE("canqueue_notify_kern postponed\n");
+ return;
+ }
+
switch(what){
case CANQUEUE_NOTIFY_EMPTY:
wake_up(&qends->endinfo.fileinfo.emptyq);
}
+/**
+ * canque_fifo_init_kern - initialize one CAN FIFO
+ * @fifo: pointer to the FIFO structure
+ * @slotsnr: number of requested slots
+ *
+ * Return Value: The negative value indicates, that there is no memory
+ * to allocate space for the requested number of the slots.
+ */
+int canque_fifo_init_kern(struct canque_fifo_t *fifo, int slotsnr)
+{
+ int size;
+ if(!slotsnr) slotsnr=MAX_BUF_LENGTH;
+ size=sizeof(struct canque_slot_t)*slotsnr;
+ fifo->entry=kmalloc(size,GFP_KERNEL);
+ if(!fifo->entry) return -1;
+ fifo->slotsnr=slotsnr;
+ return canque_fifo_init_slots(fifo);
+}
+
+/**
+ * canque_fifo_done_kern - frees slots allocated for CAN FIFO
+ * @fifo: pointer to the FIFO structure
+ */
+int canque_fifo_done_kern(struct canque_fifo_t *fifo)
+{
+ if(fifo->entry)
+ kfree(fifo->entry);
+ fifo->entry=NULL;
+ return 1;
+}
+
+
/**
* canque_new_edge_kern - allocate new edge structure in the Linux kernel context
* @slotsnr: required number of slots in the newly allocated edge structure
memset(qedge,0,sizeof(struct canque_edge_t));
can_spin_lock_init(&qedge->fifo.fifo_lock);
- if(canque_fifo_init_slots(&qedge->fifo, slotsnr)<0){
+ if(canque_fifo_init_kern(&qedge->fifo, slotsnr)<0){
kfree(qedge);
DEBUGQUE("canque_new_edge_kern failed\n");
return NULL;
can_spin_unlock_irqrestore(&qends->ends_lock,flags);
if(canqueue_disconnect_edge_kern(qends, edge)>=0) {
/* Free edge memory */
- canque_fifo_done(&edge->fifo);
+ canque_fifo_done_kern(&edge->fifo);
kfree(edge);
}else{
canque_notify_bothends(edge, CANQUEUE_NOTIFY_DEAD_WANTED);
return 0;
}
+
+void canqueue_ends_dispose_postpone(struct canque_ends_t *qends)
+{
+ can_spin_irqflags_t flags;
+
+ can_spin_lock_irqsave(&canque_dead_func_lock, flags);
+ qends->ends_flags |= CAN_ENDSF_DEAD;
+ list_add(&qends->dead_peers,&canque_dead_ends);
+ can_spin_unlock_irqrestore(&canque_dead_func_lock, flags);
+ canque_dead_tasklet_schedule();
+}
+
+
/**
* canqueue_ends_dispose_kern - finalizing of the ends structure for Linux kernel clients
* @qends: pointer to ends structure
*/
int canqueue_ends_dispose_kern(struct canque_ends_t *qends, int sync)
{
- can_spin_irqflags_t flags;
int delayed;
DEBUGQUE("canqueue_ends_dispose_kern\n");
wake_up(&qends->endinfo.fileinfo.emptyq);
if(delayed){
- can_spin_lock_irqsave(&canque_dead_func_lock, flags);
- qends->ends_flags |= CAN_ENDSF_DEAD;
- list_add(&qends->dead_peers,&canque_dead_ends);
- can_spin_unlock_irqrestore(&canque_dead_func_lock, flags);
- tasklet_schedule(&canque_dead_tl);
+ canqueue_ends_dispose_postpone(qends);
DEBUGQUE("canqueue_ends_dispose_kern delayed\n");
return 1;
void canqueue_kern_initialize()
{
-
-
+ can_spin_lock_init(&canque_dead_func_lock);
}