From a6d355f1cf48f39eecb2f1bdead51817d1fd5989 Mon Sep 17 00:00:00 2001 From: Jan Kriz Date: Wed, 8 Oct 2008 09:44:48 +0200 Subject: [PATCH] changed usb vendor and product id. --- embedded/app/usbcan/can_quekern.c | 519 --------------------------- embedded/app/usbcan/can_quesysless.c | 2 +- embedded/app/usbcan/usb/usb_defs.h | 4 +- lincan/include/usbcan.h | 4 +- 4 files changed, 5 insertions(+), 524 deletions(-) delete mode 100644 embedded/app/usbcan/can_quekern.c diff --git a/embedded/app/usbcan/can_quekern.c b/embedded/app/usbcan/can_quekern.c deleted file mode 100644 index ac1554c..0000000 --- a/embedded/app/usbcan/can_quekern.c +++ /dev/null @@ -1,519 +0,0 @@ -/* can_quekern.c - CAN message queues functions for the Linux kernel - * Linux CAN-bus device driver. - * New CAN queues by Pavel Pisa - OCERA team member - * email:pisa@cmp.felk.cvut.cz - * This software is released under the GPL-License. - * Version lincan-0.3 17 Jun 2004 - */ - -#include "../include/can.h" -#include "../include/can_sysdep.h" -#include "../include/can_queue.h" - -//#define CAN_DEBUG - -extern atomic_t edge_num_cnt; - -#ifdef CAN_DEBUG - #define DEBUGQUE(fmt,args...) can_printk(KERN_ERR "can_quekern (debug): " fmt,\ - ##args) - -#else - #define DEBUGQUE(fmt,args...) -#endif - -#define ERRMSGQUE(fmt,args...) can_printk(KERN_ERR "can_quekern: " fmt,\ - ##args) - - -/* - * Modifies Tx message processing - * 0 .. local message processing disabled - * 1 .. local messages disabled by default but can be enabled by canque_set_filt - * 2 .. local messages enabled by default, can be disabled by canque_set_filt - */ -extern int processlocal; - -void canque_dead_func(unsigned long data); - -/* Support for dead ends structures left after client close */ -can_spinlock_t canque_dead_func_lock; -LIST_HEAD(canque_dead_ends); -/* retrieved by list_entry(canque_dead_ends.next,struct canque_ends_t,dead_peers) */ -LIST_HEAD(canque_dead_edges); -/* retrieved by list_entry(canque_dead_edges.next,struct canque_edge_t,inpeers) */ -DECLARE_TASKLET(canque_dead_tl, canque_dead_func, 0); -/* activated by tasklet_schedule(&canque_dead_tl) */ - - -static inline -struct canque_edge_t *canque_dead_edges_cut_first(void) -{ - can_spin_irqflags_t flags; - struct canque_edge_t *edge; - can_spin_lock_irqsave(&canque_dead_func_lock, flags); - if(list_empty(&canque_dead_edges)) - edge=NULL; - else{ - edge=list_entry(canque_dead_edges.next,struct canque_edge_t,inpeers); - list_del(&edge->inpeers); - } - can_spin_unlock_irqrestore(&canque_dead_func_lock, flags); - return edge; -} - -void canque_dead_func(unsigned long data) -{ - can_spin_irqflags_t flags; - struct canque_edge_t *qedge; - struct canque_ends_t *qends; - struct list_head *entry; - - 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(entry,struct canque_ends_t,dead_peers); - entry=entry->next; - if(!list_empty(&qends->inlist)) - continue; - if(!list_empty(&qends->outlist)) - continue; - can_spin_lock_irqsave(&canque_dead_func_lock, flags); - 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) -{ - can_spin_irqflags_t flags; - - canque_notify_bothends(edge,CANQUEUE_NOTIFY_NOUSR); - #ifdef CAN_WITH_RTL - /* The problem of the above call is, that in RT-Linux to Linux notify - case is edge scheduled for delayed notify delivery, this needs - to be reflected there */ - if(atomic_read(&edge->edge_used)>0){ - can_spin_lock_irqsave(&edge->inends->ends_lock, flags); - can_spin_lock(&edge->outends->ends_lock); - if(atomic_read(&edge->edge_used)>0){ - /* left edge to live for a while, banshee comes again in a while */ - canque_fifo_clear_fl(&edge->fifo,DEAD); - can_spin_unlock(&edge->outends->ends_lock); - can_spin_unlock_irqrestore(&edge->inends->ends_lock, flags); - can_printk(KERN_ERR "can_quertl (debug): canque_edge_do_dead postponed\n"); - return; - } - can_spin_unlock(&edge->outends->ends_lock); - can_spin_unlock_irqrestore(&edge->inends->ends_lock, flags); - } - #endif /*CAN_WITH_RTL*/ - - if(canqueue_disconnect_edge(edge)<0){ - ERRMSGQUE("canque_edge_do_dead: canqueue_disconnect_edge failed !!!\n"); - return; - } - - 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); - canque_dead_tasklet_schedule(); -} - - - -/*if(qends->ends_flags & CAN_ENDSF_DEAD){ - can_spin_lock_irqsave(&canque_dead_func_lock, flags); - list_del(&qends->dead_peers); - list_add(&qends->dead_peers,&canque_dead_ends); - can_spin_unlock_irqrestore(&canque_dead_func_lock, flags); - tasklet_schedule(&canque_dead_tl); -}*/ - - -/** - * canqueue_notify_kern - notification callback handler for Linux userspace clients - * @qends: pointer to the callback side ends structure - * @qedge: edge which invoked notification - * @what: notification type - * - * The notification event is handled directly by call of this function except case, - * when called from RT-Linux context in mixed mode Linux/RT-Linux compilation. - * It is not possible to directly call Linux kernel synchronization primitives - * in such case. The notification request is postponed and signaled by @pending_inops flags - * by call canqueue_rtl2lin_check_and_pend() function. - * The edge reference count is increased until until all pending notifications are processed. - */ -void canqueue_notify_kern(struct canque_ends_t *qends, struct canque_edge_t *qedge, int what) -{ - 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); - if(canque_fifo_test_and_clear_fl(&qedge->fifo, FREEONEMPTY)) - canque_edge_decref(qedge); - break; - case CANQUEUE_NOTIFY_SPACE: - wake_up(&qends->endinfo.fileinfo.writeq); - #ifdef CAN_ENABLE_KERN_FASYNC - /* Asynchronous I/O processing */ - kill_fasync(&qends->endinfo.fileinfo.fasync, SIGIO, POLL_OUT); - #endif /*CAN_ENABLE_KERN_FASYNC*/ - break; - case CANQUEUE_NOTIFY_PROC: - wake_up(&qends->endinfo.fileinfo.readq); - #ifdef CAN_ENABLE_KERN_FASYNC - /* Asynchronous I/O processing */ - kill_fasync(&qends->endinfo.fileinfo.fasync, SIGIO, POLL_IN); - #endif /*CAN_ENABLE_KERN_FASYNC*/ - break; - case CANQUEUE_NOTIFY_NOUSR: - wake_up(&qends->endinfo.fileinfo.readq); - wake_up(&qends->endinfo.fileinfo.writeq); - wake_up(&qends->endinfo.fileinfo.emptyq); - break; - case CANQUEUE_NOTIFY_DEAD_WANTED: - case CANQUEUE_NOTIFY_DEAD: - if(canque_fifo_test_and_clear_fl(&qedge->fifo, READY)) - canque_edge_decref(qedge); - break; - case CANQUEUE_NOTIFY_ATTACH: - break; - } -} - -/** - * canqueue_ends_init_kern - Linux userspace clients specific ends initialization - * @qends: pointer to the callback side ends structure - */ -int canqueue_ends_init_kern(struct canque_ends_t *qends) -{ - canqueue_ends_init_gen(qends); - qends->context=NULL; - init_waitqueue_head(&qends->endinfo.fileinfo.readq); - init_waitqueue_head(&qends->endinfo.fileinfo.writeq); - init_waitqueue_head(&qends->endinfo.fileinfo.emptyq); - #ifdef CAN_ENABLE_KERN_FASYNC - qends->endinfo.fileinfo.fasync=NULL; - #endif /*CAN_ENABLE_KERN_FASYNC*/ - - qends->notify=canqueue_notify_kern; - DEBUGQUE("canqueue_ends_init_kern\n"); - return 0; -} - - -/** - * canque_get_inslot4id_wait_kern - find or wait for best outgoing edge and slot for given ID - * @qends: ends structure belonging to calling communication object - * @qedgep: place to store pointer to found edge - * @slotp: place to store pointer to allocated slot - * @cmd: command type for slot - * @id: communication ID of message to send into edge - * @prio: optional priority of message - * - * Same as canque_get_inslot4id(), except, that it waits for free slot - * in case, that queue is full. Function is specific for Linux userspace clients. - * Return Value: If there is no usable edge negative value is returned. - */ -int canque_get_inslot4id_wait_kern(struct canque_ends_t *qends, - struct canque_edge_t **qedgep, struct canque_slot_t **slotp, - int cmd, unsigned long id, int prio) -{ - int ret=-1; - DEBUGQUE("canque_get_inslot4id_wait_kern for cmd %d, id %ld, prio %d\n",cmd,id,prio); - wait_event_interruptible((qends->endinfo.fileinfo.writeq), - (ret=canque_get_inslot4id(qends,qedgep,slotp,cmd,id,prio))!=-1); - return ret; -} - -/** - * canque_get_outslot_wait_kern - receive or wait for ready slot for given ends - * @qends: ends structure belonging to calling communication object - * @qedgep: place to store pointer to found edge - * @slotp: place to store pointer to received slot - * - * The same as canque_test_outslot(), except it waits in the case, that there is - * no ready slot for given ends. Function is specific for Linux userspace clients. - * Return Value: Negative value informs, that there is no ready output - * slot for given ends. Positive value is equal to the command - * slot has been allocated by the input side. - */ -int canque_get_outslot_wait_kern(struct canque_ends_t *qends, - struct canque_edge_t **qedgep, struct canque_slot_t **slotp) -{ - int ret=-1; - DEBUGQUE("canque_get_outslot_wait_kern\n"); - wait_event_interruptible((qends->endinfo.fileinfo.readq), - (ret=canque_test_outslot(qends,qedgep,slotp))!=-1); - return ret; -} - -/** - * canque_sync_wait_kern - wait for all slots processing - * @qends: ends structure belonging to calling communication object - * @qedge: pointer to edge - * - * Functions waits for ends transition into empty state. - * Return Value: Positive value indicates, that edge empty state has been reached. - * Negative or zero value informs about interrupted wait or other problem. - */ -int canque_sync_wait_kern(struct canque_ends_t *qends, struct canque_edge_t *qedge) -{ - int ret=-1; - DEBUGQUE("canque_sync_wait_kern\n"); - wait_event_interruptible((qends->endinfo.fileinfo.emptyq), - (ret=canque_fifo_test_fl(&qedge->fifo,EMPTY)?1:0)); - return ret; -} - - -/** - * 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 - * - * Return Value: Returns pointer to allocated slot structure or %NULL if - * there is not enough memory to process operation. - */ -struct canque_edge_t *canque_new_edge_kern(int slotsnr) -{ - struct canque_edge_t *qedge; - qedge = (struct canque_edge_t *)kmalloc(sizeof(struct canque_edge_t), GFP_KERNEL); - if(qedge == NULL) return NULL; - - memset(qedge,0,sizeof(struct canque_edge_t)); - can_spin_lock_init(&qedge->fifo.fifo_lock); - if(canque_fifo_init_kern(&qedge->fifo, slotsnr)<0){ - kfree(qedge); - DEBUGQUE("canque_new_edge_kern failed\n"); - return NULL; - } - atomic_set(&qedge->edge_used,1); - qedge->filtid = 0; - qedge->filtmask = canque_filtid2internal(0l, (processlocal<2)? MSG_LOCAL:0); - qedge->edge_prio = 0; - #ifdef CAN_DEBUG - /* not exactly clean, but enough for debugging */ - atomic_inc(&edge_num_cnt); - qedge->edge_num=atomic_read(&edge_num_cnt); - #endif /* CAN_DEBUG */ - DEBUGQUE("canque_new_edge_kern %d\n",qedge->edge_num); - return qedge; -} - -#ifdef USE_SYNC_DISCONNECT_EDGE_KERN - -/*not included in doc - * canqueue_disconnect_edge_kern - disconnect edge from communicating entities with wait - * @qends: ends structure belonging to calling communication object - * @qedge: pointer to edge - * - * Same as canqueue_disconnect_edge(), but tries to wait for state with zero - * use counter. - * Return Value: Negative value means, that edge is used and cannot - * be disconnected yet. Operation has to be delayed. - */ -int canqueue_disconnect_edge_kern(struct canque_ends_t *qends, struct canque_edge_t *qedge) -{ - canque_fifo_set_fl(&qedge->fifo,BLOCK); - DEBUGQUE("canqueue_disconnect_edge_kern %d called\n",qedge->edge_num); - if(!canque_fifo_test_and_set_fl(&qedge->fifo,DEAD)){ - canque_notify_bothends(qedge, CANQUEUE_NOTIFY_DEAD); - - if(atomic_read(&qedge->edge_used)>0) - atomic_dec(&qedge->edge_used); - - DEBUGQUE("canqueue_disconnect_edge_kern %d waiting\n",qedge->edge_num); - wait_event((qends->endinfo.fileinfo.emptyq), - (canqueue_disconnect_edge(qedge)>=0)); - - /*set_current_state(TASK_UNINTERRUPTIBLE);*/ - /*schedule_timeout(HZ);*/ - return 0; - } else { - DEBUGQUE("canqueue_disconnect_edge_kern cannot set DEAD\n"); - return -1; - } -} - - -int canqueue_disconnect_list_kern(struct canque_ends_t *qends, struct list_head *list) -{ - struct canque_edge_t *edge; - can_spin_irqflags_t flags; - for(;;){ - can_spin_lock_irqsave(&qends->ends_lock,flags); - if(list_empty(list)){ - can_spin_unlock_irqrestore(&qends->ends_lock,flags); - return 0; - } - if(list == &qends->inlist) - edge=list_entry(list->next,struct canque_edge_t,inpeers); - else - edge=list_entry(list->next,struct canque_edge_t,outpeers); - atomic_inc(&edge->edge_used); - can_spin_unlock_irqrestore(&qends->ends_lock,flags); - if(canqueue_disconnect_edge_kern(qends, edge)>=0) { - /* Free edge memory */ - canque_fifo_done_kern(&edge->fifo); - kfree(edge); - }else{ - canque_notify_bothends(edge, CANQUEUE_NOTIFY_DEAD_WANTED); - canque_edge_decref(edge); - DEBUGQUE("canqueue_disconnect_list_kern in troubles\n"); - DEBUGQUE("the edge %d has usage count %d and flags %ld\n",edge->edge_num,atomic_read(&edge->edge_used),edge->fifo.fifo_flags); - return -1; - } - } -} - -#endif /*USE_SYNC_DISCONNECT_EDGE_KERN*/ - - -int canqueue_ends_sync_all_kern(struct canque_ends_t *qends) -{ - struct canque_edge_t *qedge; - - canque_for_each_inedge(qends, qedge){ - DEBUGQUE("canque_sync_wait_kern called for edge %d\n",qedge->edge_num); - canque_sync_wait_kern(qends, qedge); - } - 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 - * @sync: flag indicating, that user wants to wait for processing of all remaining - * messages - * - * Return Value: Function should be designed such way to not fail. - */ -int canqueue_ends_dispose_kern(struct canque_ends_t *qends, int sync) -{ - int delayed; - - DEBUGQUE("canqueue_ends_dispose_kern\n"); - canqueue_block_inlist(qends); - canqueue_block_outlist(qends); - - /*Wait for sending of all pending messages in the output FIFOs*/ - if(sync) - canqueue_ends_sync_all_kern(qends); - - /* Finish or kill all outgoing edges listed in inends */ - delayed=canqueue_ends_kill_inlist(qends, 1); - /* Kill all incoming edges listed in outends */ - delayed|=canqueue_ends_kill_outlist(qends); - - wake_up(&qends->endinfo.fileinfo.readq); - wake_up(&qends->endinfo.fileinfo.writeq); - wake_up(&qends->endinfo.fileinfo.emptyq); - - if(delayed){ - canqueue_ends_dispose_postpone(qends); - - DEBUGQUE("canqueue_ends_dispose_kern delayed\n"); - return 1; - } - - kfree(qends); - DEBUGQUE("canqueue_ends_dispose_kern finished\n"); - return 0; -} - -void canqueue_kern_initialize() -{ - can_spin_lock_init(&canque_dead_func_lock); -} diff --git a/embedded/app/usbcan/can_quesysless.c b/embedded/app/usbcan/can_quesysless.c index 26c6db7..f11f90d 100644 --- a/embedded/app/usbcan/can_quesysless.c +++ b/embedded/app/usbcan/can_quesysless.c @@ -1,4 +1,4 @@ -/* can_quekern.c - CAN message queues functions for the Linux kernel +/* can_quesysless.c - CAN message queues functions for the Linux kernel * Linux CAN-bus device driver. * New CAN queues by Pavel Pisa - OCERA team member * email:pisa@cmp.felk.cvut.cz diff --git a/embedded/app/usbcan/usb/usb_defs.h b/embedded/app/usbcan/usb/usb_defs.h index 17fed74..48dde4e 100644 --- a/embedded/app/usbcan/usb/usb_defs.h +++ b/embedded/app/usbcan/usb/usb_defs.h @@ -28,10 +28,10 @@ /*** Static data structures for device descriptors ***/ /*****************************************************/ #ifndef USB_VENDOR_ID - #define USB_VENDOR_ID 0xDEAD /* vymyslene cislo ( snad ho nikdo nema ... ;-) */ + #define USB_VENDOR_ID 0x1669 /* vymyslene cislo ( snad ho nikdo nema ... ;-) */ #endif #ifndef USB_PRODUCT_ID - #define USB_PRODUCT_ID 0x1001 /* test code for ULAD21 */ + #define USB_PRODUCT_ID 0x1011 /* test code for ULAD21 */ #endif #define USB_RELEASE_VER 0x0010 diff --git a/lincan/include/usbcan.h b/lincan/include/usbcan.h index a7da77d..36c3753 100644 --- a/lincan/include/usbcan.h +++ b/lincan/include/usbcan.h @@ -28,8 +28,8 @@ /* arbitrarily chosen */ /* Define these values to match your devices */ -#define USBCAN_VENDOR_ID 0xDEAD -#define USBCAN_PRODUCT_ID 0x1001 +#define USBCAN_VENDOR_ID 0x1669 +#define USBCAN_PRODUCT_ID 0x1011 #define RESET_ADDR 0x0 -- 2.39.2