X-Git-Url: http://rtime.felk.cvut.cz/gitweb/lincan.git/blobdiff_plain/91dfab84182937b62ef64cb12d8e4f89e6d5c3ec..9c8ab08d7e8fca3916a7f91a3c001d151989137c:/lincan/src/devcommon.c diff --git a/lincan/src/devcommon.c b/lincan/src/devcommon.c index c26a36f..b97c9ba 100644 --- a/lincan/src/devcommon.c +++ b/lincan/src/devcommon.c @@ -1,10 +1,35 @@ -/* devcommon.c - common device code - * 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.2 9 Jul 2003 - */ +/**************************************************************************/ +/* File: devcommon.c - common device code */ +/* */ +/* LinCAN - (Not only) Linux CAN bus driver */ +/* Copyright (C) 2002-2009 DCE FEE CTU Prague */ +/* Copyright (C) 2002-2009 Pavel Pisa */ +/* Funded by OCERA and FRESCOR IST projects */ +/* */ +/* LinCAN is free software; you can redistribute it and/or modify it */ +/* under terms of the GNU General Public License as published by the */ +/* Free Software Foundation; either version 2, or (at your option) any */ +/* later version. LinCAN is distributed in the hope that it will be */ +/* useful, but WITHOUT ANY WARRANTY; without even the implied warranty */ +/* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU */ +/* General Public License for more details. You should have received a */ +/* copy of the GNU General Public License along with LinCAN; see file */ +/* COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, */ +/* Cambridge, MA 02139, USA. */ +/* */ +/* To allow use of LinCAN in the compact embedded systems firmware */ +/* and RT-executives (RTEMS for example), main authors agree with next */ +/* special exception: */ +/* */ +/* Including LinCAN header files in a file, instantiating LinCAN generics */ +/* or templates, or linking other files with LinCAN objects to produce */ +/* an application image/executable, does not by itself cause the */ +/* resulting application image/executable to be covered by */ +/* the GNU General Public License. */ +/* This exception does not however invalidate any other reasons */ +/* why the executable file might be covered by the GNU Public License. */ +/* Publication of enhanced or derived LinCAN files is required although. */ +/**************************************************************************/ #include "../include/can.h" #include "../include/can_sysdep.h" @@ -12,9 +37,41 @@ #include "../include/main.h" #include "../include/devcommon.h" +#ifdef CAN_WITH_RTL +static inline +void canqueue_wake_chip_worker(struct canque_ends_t *qends, struct canchip_t *chip, struct msgobj_t *obj) +{ + if(qends->endinfo.chipinfo.worker_thread){ + can_msgobj_set_fl(obj,WORKER_WAKE); + pthread_kill(qends->endinfo.chipinfo.worker_thread,RTL_SIGNAL_WAKEUP); + rtl_schedule(); + } else { + set_bit(MSGOBJ_TX_REQUEST_b,&chip->pend_flags); + if(chip->worker_thread) { + set_bit(MSGOBJ_WORKER_WAKE_b,&chip->pend_flags); + pthread_kill(chip->worker_thread,RTL_SIGNAL_WAKEUP); + rtl_schedule(); + } + } +} + +#endif /*CAN_WITH_RTL*/ + + +/** + * canqueue_notify_chip - notification callback handler for CAN chips ends of queues + * @qends: pointer to the callback side ends structure + * @qedge: edge which invoked notification + * @what: notification type + * + * This function has to deal with more possible cases. It can be called from + * the kernel or interrupt context for Linux only compilation of driver. + * The function can be called from kernel context or RT-Linux thread context + * for mixed mode Linux/RT-Linux compilation. + */ void canqueue_notify_chip(struct canque_ends_t *qends, struct canque_edge_t *qedge, int what) { - struct chip_t *chip=qends->endinfo.chipinfo.chip; + struct canchip_t *chip=qends->endinfo.chipinfo.chip; struct msgobj_t *obj=qends->endinfo.chipinfo.msgobj; DEBUGMSG("canqueue_notify_chip for edge %d and event %d\n",qedge->edge_num,what); @@ -25,8 +82,16 @@ void canqueue_notify_chip(struct canque_ends_t *qends, struct canque_edge_t *qed wake_up(&qends->endinfo.chipinfo.daemonq); break;*/ case CANQUEUE_NOTIFY_PROC: + #ifndef CAN_WITH_RTL /*wake_up(&qends->endinfo.chipinfo.daemonq);*/ - chip->chipspecops->wakeup_tx(chip, obj); + if(canque_fifo_test_fl(&qedge->fifo, READY)){ + if ((chip) && (chip->flags & CHIP_ATTACHED)) + chip->chipspecops->wakeup_tx(chip, obj); + } + #else /*CAN_WITH_RTL*/ + can_msgobj_set_fl(obj,TX_REQUEST); + canqueue_wake_chip_worker(qends, chip, obj); + #endif /*CAN_WITH_RTL*/ break; case CANQUEUE_NOTIFY_DEAD_WANTED: case CANQUEUE_NOTIFY_DEAD: @@ -34,19 +99,38 @@ void canqueue_notify_chip(struct canque_ends_t *qends, struct canque_edge_t *qed canque_edge_decref(qedge); break; case CANQUEUE_NOTIFY_ATTACH: + break; + case CANQUEUE_NOTIFY_FILTCH: + if(!chip->chipspecops->filtch_rq) + break; + #ifndef CAN_WITH_RTL + chip->chipspecops->filtch_rq(chip, obj); + #else /*CAN_WITH_RTL*/ + can_msgobj_set_fl(obj,FILTCH_REQUEST); + canqueue_wake_chip_worker(qends, chip, obj); + #endif /*CAN_WITH_RTL*/ + break; } } -int canqueue_ends_init_chip(struct canque_ends_t *qends, struct chip_t *chip, struct msgobj_t *obj) +/** + * canqueue_ends_init_chip - CAN chip specific ends initialization + * @qends: pointer to the ends structure + * @chip: pointer to the corresponding CAN chip structure + * @obj: pointer to the corresponding message object structure + */ +int canqueue_ends_init_chip(struct canque_ends_t *qends, struct canchip_t *chip, struct msgobj_t *obj) { int ret; ret=canqueue_ends_init_gen(qends); if(ret<0) return ret; - + qends->context=NULL; + #ifndef CAN_WITH_RTL init_waitqueue_head(&qends->endinfo.chipinfo.daemonq); + #endif /*CAN_WITH_RTL*/ qends->endinfo.chipinfo.chip=chip; qends->endinfo.chipinfo.msgobj=obj; qends->notify=canqueue_notify_chip; @@ -56,10 +140,16 @@ int canqueue_ends_init_chip(struct canque_ends_t *qends, struct chip_t *chip, st } +/** + * canqueue_ends_done_chip - finalizing of the ends structure for CAN chips + * @qends: pointer to ends structure + * + * Return Value: Function should be designed such way to not fail. + */ int canqueue_ends_done_chip(struct canque_ends_t *qends) { int delayed; - + /* Finish or kill all outgoing edges listed in inends */ delayed=canqueue_ends_kill_inlist(qends, 1); /* Kill all incoming edges listed in outends */