#include "../include/devcommon.h"
#include "../include/setup.h"
#include "../include/usbcan.h"
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
+ #include <linux/freezer.h>
+#endif
+#include <linux/smp_lock.h>
static int usbcan_probe(struct usb_interface *interface, const struct usb_device_id *id);
static void usbcan_disconnect(struct usb_interface *interface);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
+void release_device(struct kref *refcount);
+#else
+void release_device(struct candevice_t *candev);
+#endif
volatile int usbcan_chip_count=0;
return 0;
}
-/* !!! Don't change this function !!! */
int usbcan_register(struct hwspecops_t *hwspecops)
{
hwspecops->request_io = usbcan_request_io;
hwspecops->write_register = NULL;
hwspecops->read_register = NULL;
hwspecops->program_irq = usbcan_program_irq;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
+ hwspecops->release_device = release_device;
+#endif
return 0;
}
// static int sja1000_report_error_limit_counter;
-static void sja1000_report_error(struct canchip_t *chip,
+static void usbcan_report_error(struct canchip_t *chip,
unsigned sr, unsigned ir, unsigned ecc)
{
/*TODO : Error reporting from device */
-/* if(sja1000_report_error_limit_counter>=100)
+#if 0
+ if(sja1000_report_error_limit_counter>=100)
return;
CANMSG("Error: status register: 0x%x irq_register: 0x%02x error: 0x%02x\n",
);
}
#endif /*CONFIG_OC_LINCAN_DETAILED_ERRORS*/
+#endif
}
int retval;
struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
- u8 usbbuf[16];
+ u8 usbbuf[USBCAN_TRANSFER_SIZE];
if (!dev)
return -ENODEV;
USBCAN_VENDOR_EXT_MASK_SET,
USB_TYPE_VENDOR,
cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
- &usbbuf, 16,
+ &usbbuf, USBCAN_TRANSFER_SIZE,
10000);
if (retval<0)
return -ENODEV;
USBCAN_VENDOR_EXT_MASK_STATUS,
USB_TYPE_VENDOR,
cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
- &usbbuf, 16,
+ &usbbuf, USBCAN_TRANSFER_SIZE,
10000);
if (retval==1){
int retval;
struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
- u8 usbbuf[16];
+ u8 usbbuf[USBCAN_TRANSFER_SIZE];
if (!dev)
return -ENODEV;
USBCAN_VENDOR_BAUD_RATE_SET,
USB_TYPE_VENDOR,
cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
- &usbbuf, 16,
+ &usbbuf, USBCAN_TRANSFER_SIZE,
10000);
if (retval<0)
return -ENODEV;
USBCAN_VENDOR_BAUD_RATE_STATUS,
USB_TYPE_VENDOR,
cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
- usbbuf, 16,
+ usbbuf, USBCAN_TRANSFER_SIZE,
10000);
if (retval==1){
int usbcan_pre_write_config(struct canchip_t *chip, struct msgobj_t *obj,
struct canmsg_t *msg)
{
- struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
- int i=0;
- int len;
- u8 *ptr;
-
- if (!dev)
- return -ENODEV;
- /* Wait until Transmit Buffer Status is released */
- while ( usbcan_chip_queue_status(chip) &&
- i++<MAX_TRANSMIT_WAIT_LOOPS) {
- udelay(i);
- }
- if (usbcan_chip_queue_status(chip)){
- CANMSG("Buffer full, cannot send message\n");
- return -EIO;
- }
-
- *(uint8_t *)(dev->tx_msg)=chip->chip_idx & 0xFF;
-
- len = msg->length;
- if(len > CAN_MSG_LENGTH) len = CAN_MSG_LENGTH;
-
- *(uint8_t *)(dev->tx_msg+1)=len & 0xFF;
- *(uint16_t *)(dev->tx_msg+2)=cpu_to_le16(msg->flags);
- *(uint32_t *)(dev->tx_msg+4)=cpu_to_le32(msg->id);
-
- for(ptr=dev->tx_msg+8,i=0; i < len; ptr++,i++) {
- *ptr=msg->data[i] & 0xFF;
- }
- for(; i < 8; ptr++,i++) {
- *ptr=0;
- }
return 0;
}
int usbcan_send_msg(struct canchip_t *chip, struct msgobj_t *obj,
struct canmsg_t *msg)
{
- struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
- int len,retval;
-
- if (!dev)
- return -ENODEV;
-
- set_bit(USBCAN_TX_PENDING,&dev->flags);
- retval=usb_bulk_msg(dev->udev,
- usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
- &dev->tx_msg, 16,
- &len,10000);
- clear_bit(USBCAN_TX_PENDING,&dev->flags);
- if (retval){
- CANMSG("URB error %d\n",retval);
- return -EIO;
- }
- if (len!=16){
- CANMSG("CAN message not sent\n");
- return -EIO;
- }
- CANMSG("Message sent\n");
-
- if(obj->tx_slot){
- // Do local transmitted message distribution if enabled
- if (processlocal){
- // fill CAN message timestamp
- can_filltimestamp(&obj->tx_slot->msg.timestamp);
-
- obj->tx_slot->msg.flags |= MSG_LOCAL;
- canque_filter_msg2edges(obj->qends, &obj->tx_slot->msg);
- }
- // Free transmitted slot
- canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
- obj->tx_slot=NULL;
- }
-
- can_msgobj_clear_fl(obj,TX_PENDING);
return 0;
}
unsigned short btr1)
{
int retval;
- u8 buf[16];
+ u8 buf[USBCAN_TRANSFER_SIZE];
struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
uint16_t value=(btr1&0xFF)<<8 | (btr0&0xFF);
USBCAN_VENDOR_SET_BTREGS,
USB_TYPE_VENDOR,
cpu_to_le16(value), cpu_to_le16(chip->chip_idx),
- &buf, 16,
+ &buf, USBCAN_TRANSFER_SIZE,
10000);
if (retval==1){
int usbcan_start_chip(struct canchip_t *chip)
{
int retval;
- u8 buf[16];
+ u8 buf[USBCAN_TRANSFER_SIZE];
struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
if (!dev)
USBCAN_VENDOR_START_CHIP,
USB_TYPE_VENDOR,
cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
- &buf, 16,
+ &buf, USBCAN_TRANSFER_SIZE,
10000);
if (retval==1){
int usbcan_chip_queue_status(struct canchip_t *chip)
{
int retval;
- u8 buf[16];
+ u8 buf[USBCAN_TRANSFER_SIZE];
struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
if (!dev)
USBCAN_VENDOR_CHECK_TX_STAT,
USB_TYPE_VENDOR,
cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
- &buf, 16,
+ &buf, USBCAN_TRANSFER_SIZE,
10000);
if (retval==1){
- CANMSG("Chip_queue_status: %d\n",buf[0]);
+ DEBUGMSG("Chip_queue_status: %d\n",buf[0]);
if(buf[0]==1)
return 0;
if(buf[0]==0)
int usbcan_stop_chip(struct canchip_t *chip)
{
int retval;
- u8 buf[16];
+ u8 buf[USBCAN_TRANSFER_SIZE];
struct usbcan_usb *dev=(struct usbcan_usb*)chip->chip_data;
if (!dev)
USBCAN_VENDOR_STOP_CHIP,
USB_TYPE_VENDOR,
cpu_to_le16(0), cpu_to_le16(chip->chip_idx),
- &buf, 16,
+ &buf, USBCAN_TRANSFER_SIZE,
10000);
if (retval==1){
*
* File: src/usbcan.c
*/
-void usbcan_register_devs(struct canchip_t *chip,void *data){
+int usbcan_register_devs(struct canchip_t *chip,void *data){
struct usbcan_devs *usbdevs=(struct usbcan_devs *)data;
if (!usbdevs){
CANMSG("Bad structure given\n");
- return;
+ return -1;
}
if (chip->chip_idx>=usbdevs->count) {
CANMSG("Requested chip number is bigger than chip count\n");
- return;
+ return -1;
}
usbdevs->devs[chip->chip_idx]->chip=chip;
chip->chip_data=(void *)usbdevs->devs[chip->chip_idx];
+ return 0;
}
/**
struct usbcan_usb *dev = (struct usbcan_usb *)chip->chip_data;
/* start kernel thread */
- dev->comthread=can_kthread_run(usbcan_read_kthread, (void *)dev, "usbcan_%d",chip->chip_idx);
+ dev->comthread=can_kthread_run(usbcan_kthread, (void *)dev, "usbcan_%d",chip->chip_idx);
return 0;
}
usbcan_stop_chip(chip);
/* terminate the kernel thread */
- can_kthread_stop(dev->comthread);
+ set_bit(USBCAN_TERMINATE,&dev->flags);
+// wake_up_process(dev->comthread);
+ can_kthread_stop(dev->comthread);
return 0;
}
return -ENOSYS;
}
+
+static void usbcan_usb_message_move_list(struct usbcan_usb *dev,
+ struct usbcan_message *m, struct list_head *head)
+{
+ can_spin_irqflags_t flags;
+ can_spin_lock_irqsave(&dev->list_lock, flags);
+ list_del(&m->list_node);
+ list_add_tail(&m->list_node, head);
+ can_spin_unlock_irqrestore(&dev->list_lock, flags);
+}
+
+
/**
- * usbcan_irq_write_handler: - part of ISR code responsible for transmit events
- * @chip: pointer to chip state structure
- * @obj: pointer to attached queue description
+ * usbcan_kthread_read_handler: - part of kthread code responsible for receive completed events
+ * @dev: pointer to usb device related structure
+ * @obj: pointer to attached message object description
*
- * The main purpose of this function is to read message from attached queues
- * and transfer message contents into CAN controller chip.
+ * The main purpose of this function is to read message from usb urb
+ * and transfer message contents to CAN queue ends.
* This subroutine is called by
- * usbcan_irq_write_handler() for transmit events.
+ * usbcan_kthread().
* File: src/usbcan.c
*/
-void usbcan_irq_write_handler(struct canchip_t *chip, struct msgobj_t *obj)
+void usbcan_kthread_read_handler(struct usbcan_usb *dev, struct usbcan_message *m,
+ struct msgobj_t *obj)
{
- int cmd;
+ int i, len, retval;
+ u8 *ptr;
+
+ DEBUGMSG("USBCAN RX handler\n");
+
+ if (!test_and_clear_bit(USBCAN_MESSAGE_DATA_OK,&m->flags)) {
+ CANMSG("Strange, Rx handler USBCAN_MESSAGE_DATA_OK not set\n");
+ goto skip_msg;
+ }
+
+ if (!(dev->chip)||!(dev->chip->flags & CHIP_CONFIGURED)) {
+ CANMSG("Destination chip not found\n");
+ goto skip_msg;
+ }
+
+
+ DEBUGMSG("USBCAN Thread has received a message\n");
+
+ len=*(u8 *)(m->msg+1);
+ if(len > CAN_MSG_LENGTH) len = CAN_MSG_LENGTH;
+ obj->rx_msg.length = len;
+
+ obj->rx_msg.flags=le16_to_cpu(*(u16 *)(m->msg+2));
+ obj->rx_msg.id=le32_to_cpu((*(u32 *)(m->msg+4)));
+
+ for(ptr=m->msg+8,i=0; i < len; ptr++,i++) {
+ obj->rx_msg.data[i]=*ptr;
+ }
- if(obj->tx_slot){
+ // fill CAN message timestamp
+ can_filltimestamp(&obj->rx_msg.timestamp);
+ canque_filter_msg2edges(obj->qends, &obj->rx_msg);
+
+skip_msg:
+ DEBUGMSG("Renewing RX urb\n");
+
+ usbcan_usb_message_move_list(dev, m, &dev->rx_pend_list);
+ retval = usb_submit_urb (m->u, GFP_KERNEL);
+ if (retval<0) {
+ CANMSG("URB error %d\n", retval);
+ set_bit(USBCAN_ERROR,&dev->flags);
+ }
+}
+
+/**
+ * usbcan_kthread_write_handler: - part of kthread code responsible for transmit done events
+ * @dev: pointer to usb device related structure
+ * @obj: pointer to attached message object description
+ *
+ * The main purpose of this function is to free allocated resources on transmit done event
+ * This subroutine is called by
+ * usbcan_kthread().
+ * File: src/usbcan.c
+ */
+void usbcan_kthread_write_handler(struct usbcan_usb *dev, struct usbcan_message *m,
+ struct msgobj_t *obj)
+{
+ if (!test_and_clear_bit(USBCAN_MESSAGE_DATA_OK,&m->flags)) {
+ CANMSG("Strange, Tx handler USBCAN_MESSAGE_DATA_OK not set\n");
+ goto skip_msg;
+ }
+
+ DEBUGMSG("USBCAN Message successfully sent\n");
+
+ if(m->slot){
// Do local transmitted message distribution if enabled
if (processlocal){
// fill CAN message timestamp
- can_filltimestamp(&obj->tx_slot->msg.timestamp);
+ can_filltimestamp(&m->slot->msg.timestamp);
- obj->tx_slot->msg.flags |= MSG_LOCAL;
- canque_filter_msg2edges(obj->qends, &obj->tx_slot->msg);
+ m->slot->msg.flags |= MSG_LOCAL;
+ canque_filter_msg2edges(obj->qends, &m->slot->msg);
}
// Free transmitted slot
- canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
- obj->tx_slot=NULL;
+ canque_free_outslot(obj->qends, m->qedge, m->slot);
+ m->slot=NULL;
}
+ /*FIXME - why there*/
can_msgobj_clear_fl(obj,TX_PENDING);
- cmd=canque_test_outslot(obj->qends, &obj->tx_qedge, &obj->tx_slot);
- if(cmd<0)
- return;
- can_msgobj_set_fl(obj,TX_PENDING);
- if (chip->chipspecops->pre_write_config(chip, obj, &obj->tx_slot->msg)) {
- obj->ret = -1;
- canque_notify_inends(obj->tx_qedge, CANQUEUE_NOTIFY_ERRTX_PREP);
- canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
- obj->tx_slot=NULL;
+skip_msg:
+ set_bit(USBCAN_FREE_TX_URB,&dev->flags);
+
+ set_bit(USBCAN_TX_PENDING,&dev->flags);
+
+ usbcan_usb_message_move_list(dev, m, &dev->tx_idle_list);
+}
+
+/**
+ * usbcan_kthread_write_request_handler: - part of kthread code responsible for sending transmit urbs
+ * @dev: pointer to usb device related structure
+ * @obj: pointer to attached message object description
+ *
+ * The main purpose of this function is to create a usb transmit safe object
+ * and send it via free transmit usb urb
+ * This subroutine is called by
+ * usbcan_kthread().
+ * File: src/usbcan.c
+ */
+void usbcan_kthread_write_request_handler(struct usbcan_usb *dev, struct msgobj_t *obj){
+ int i, cmd, len, retval;
+ u8 *ptr;
+ struct usbcan_message *m;
+
+ if(list_empty(&dev->tx_idle_list)) {
+ clear_bit(USBCAN_FREE_TX_URB,&dev->flags);
return;
}
- if (chip->chipspecops->send_msg(chip, obj, &obj->tx_slot->msg)) {
- obj->ret = -1;
- canque_notify_inends(obj->tx_qedge, CANQUEUE_NOTIFY_ERRTX_SEND);
- canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
- obj->tx_slot=NULL;
- return;
+
+ m = list_first_entry(&dev->tx_idle_list, typeof(*m), list_node);
+
+ cmd=canque_test_outslot(obj->qends, &m->qedge, &m->slot);
+ if(cmd>=0){
+ DEBUGMSG("USBCAN Sending a message\n");
+
+ can_msgobj_set_fl(obj,TX_PENDING);
+ clear_bit(USBCAN_FREE_TX_URB,&dev->flags);
+
+ *(u8 *)(m->msg)=0;
+ len = m->slot->msg.length;
+ if(len > CAN_MSG_LENGTH)
+ len = CAN_MSG_LENGTH;
+ *(u8 *)(m->msg+1)=len & 0xFF;
+ *(u16 *)(m->msg+2)=cpu_to_le16(m->slot->msg.flags);
+ *(u32 *)(m->msg+4)=cpu_to_le32(m->slot->msg.id);
+
+ for(ptr=m->msg+8, i=0; i < len; ptr++,i++) {
+ *ptr=m->slot->msg.data[i] & 0xFF;
+ }
+ for(; i < 8; ptr++,i++) {
+ *ptr=0;
+ }
+
+
+ usbcan_usb_message_move_list(dev, m, &dev->tx_pend_list);
+
+ retval = usb_submit_urb (m->u, GFP_KERNEL);
+ if (retval){
+ CANMSG("%d. URB error %d\n",i,retval);
+ set_bit(USBCAN_FREE_TX_URB,&dev->flags);
+ obj->ret = -1;
+ canque_notify_inends(m->qedge, CANQUEUE_NOTIFY_ERRTX_SEND);
+ canque_free_outslot(obj->qends, m->qedge, m->slot);
+ m->slot=NULL;
+ usbcan_usb_message_move_list(dev, m, &dev->tx_idle_list);
+ } else {
+ set_bit(USBCAN_TX_PENDING,&dev->flags);
+ }
+ } else {
+ set_bit(USBCAN_FREE_TX_URB,&dev->flags);
}
}
*/
int usbcan_irq_handler(int irq, struct canchip_t *chip)
{
-/* int irq_register, status, error_code;
- struct msgobj_t *obj=chip->msgobj[0];
- int loop_cnt=CHIP_MAX_IRQLOOP;
-
- irq_register=can_read_reg(chip,SJAIR);
-// DEBUGMSG("sja1000_irq_handler: SJAIR:%02x\n",irq_register);
-// DEBUGMSG("sja1000_irq_handler: SJASR:%02x\n",
-// can_read_reg(chip,SJASR));
-
- if ((irq_register & (sjaIR_BEI|sjaIR_EPI|sjaIR_DOI|sjaIR_EI|sjaIR_TI|sjaIR_RI)) == 0)
- return CANCHIP_IRQ_NONE;
-
- if(!(chip->flags&CHIP_CONFIGURED)) {
- CANMSG("usbcan_irq_handler: called for non-configured device, irq_register 0x%02x\n", irq_register);
- return CANCHIP_IRQ_NONE;
- }
-
- status=can_read_reg(chip,SJASR);
-
- do {
-
- if(!loop_cnt--) {
- CANMSG("usbcan_irq_handler IRQ %d stuck\n",irq);
- return CANCHIP_IRQ_STUCK;
- }
-
- // (irq_register & sjaIR_TI)
- // old variant using SJAIR, collides with intended use with irq_accept
- if (((status & sjaSR_TBS) && can_msgobj_test_fl(obj,TX_PENDING))||
- (can_msgobj_test_fl(obj,TX_REQUEST))) {
- DEBUGMSG("sja1000_irq_handler: TI or TX_PENDING and TBS\n");
- obj->ret = 0;
- can_msgobj_set_fl(obj,TX_REQUEST);
- while(!can_msgobj_test_and_set_fl(obj,TX_LOCK)){
- can_msgobj_clear_fl(obj,TX_REQUEST);
-
- if (can_read_reg(chip, SJASR) & sjaSR_TBS)
- usbcan_irq_write_handler(chip, obj);
-
- can_msgobj_clear_fl(obj,TX_LOCK);
- if(!can_msgobj_test_fl(obj,TX_REQUEST)) break;
- DEBUGMSG("TX looping in sja1000_irq_handler\n");
- }
- }
- if ((irq_register & (sjaIR_EI|sjaIR_BEI|sjaIR_EPI|sjaIR_DOI)) != 0) {
- // Some error happened
- error_code=can_read_reg(chip,SJAECC);
- sja1000_report_error(chip, status, irq_register, error_code);
-// FIXME: chip should be brought to usable state. Transmission cancelled if in progress.
-// Reset flag set to 0 if chip is already off the bus. Full state report
- obj->ret=-1;
-
- if(error_code == 0xd9) {
- obj->ret= -ENXIO;
- // no such device or address - no ACK received
- }
- if(obj->tx_retry_cnt++>MAX_RETR) {
- can_write_reg(chip, sjaCMR_AT, SJACMR); // cancel any transmition
- obj->tx_retry_cnt = 0;
- }
- if(status&sjaSR_BS) {
- CANMSG("bus-off, resetting usbcan\n");
- can_write_reg(chip, 0, SJAMOD);
- }
-
- if(obj->tx_slot){
- canque_notify_inends(obj->tx_qedge, CANQUEUE_NOTIFY_ERRTX_BUS);
- //canque_free_outslot(obj->qends, obj->tx_qedge, obj->tx_slot);
- //obj->tx_slot=NULL;
- }
-
- } else {
- if(sja1000_report_error_limit_counter)
- sja1000_report_error_limit_counter--;
- obj->tx_retry_cnt=0;
- }
-
- irq_register=can_read_reg(chip,SJAIR);
-
- status=can_read_reg(chip,SJASR);
-
- if(((status & sjaSR_TBS) && can_msgobj_test_fl(obj,TX_PENDING)) ||
- (irq_register & sjaIR_TI))
- can_msgobj_set_fl(obj,TX_REQUEST);
-
- } while((irq_register & (sjaIR_BEI|sjaIR_EPI|sjaIR_DOI|sjaIR_EI|sjaIR_RI)) ||
- (can_msgobj_test_fl(obj,TX_REQUEST) && !can_msgobj_test_fl(obj,TX_LOCK)) ||
- (status & sjaSR_RBS));
-*/
return CANCHIP_IRQ_HANDLED;
}
*/
int usbcan_wakeup_tx(struct canchip_t *chip, struct msgobj_t *obj)
{
- CANMSG("Trying to send message\n");
+ struct usbcan_usb *dev=(struct usbcan_usb *)chip->chip_data;
+
+ DEBUGMSG("Trying to send message\n");
can_preempt_disable();
can_msgobj_set_fl(obj,TX_PENDING);
while(!can_msgobj_test_and_set_fl(obj,TX_LOCK)){
can_msgobj_clear_fl(obj,TX_REQUEST);
- if (!usbcan_chip_queue_status(chip)){
+ if (test_and_clear_bit(USBCAN_FREE_TX_URB,&dev->flags)){
obj->tx_retry_cnt=0;
- usbcan_irq_write_handler(chip, obj);
+ set_bit(USBCAN_TX_PENDING,&dev->flags);
+ if (test_bit(USBCAN_THREAD_RUNNING,&dev->flags))
+ wake_up_process(dev->comthread);
}
can_msgobj_clear_fl(obj,TX_LOCK);
if(!can_msgobj_test_fl(obj,TX_REQUEST)) break;
- DEBUGMSG("TX looping in usbcan_wakeup_tx\n");
+ CANMSG("TX looping in usbcan_wakeup_tx\n");
}
can_preempt_enable();
usbcan_fill_chipspecops(chip);
- candev->chip[chipnr]->flags|=CHIP_IRQ_CUSTOM;
+ candev->chip[chipnr]->flags|=CHIP_IRQ_CUSTOM|CHIP_KEEP_DATA;
candev->chip[chipnr]->chip_base_addr=0;
candev->chip[chipnr]->clock = 0;
}
+/** *********************************
+ * USB related functions
+ * ********************************* */
-/* --------------------------------------------------------------------------------------------------- */
static int usbcan_sleep_thread(struct usbcan_usb *dev)
{
int rc = 0;
}
if (
can_kthread_should_stop() ||
- test_bit(USBCAN_DATA_READ,&dev->flags) ||
+ test_bit(USBCAN_DATA_OK,&dev->flags) ||
+ test_bit(USBCAN_TX_PENDING,&dev->flags) ||
test_bit(USBCAN_TERMINATE,&dev->flags) ||
test_bit(USBCAN_ERROR,&dev->flags)
)
return rc;
}
-static void usbcan_rcv(struct urb *urb)
+static void usbcan_tx_callback(struct urb *urb)
{
- struct usbcan_usb *dev = urb->context;
+ struct usbcan_message *m = urb->context;
int retval;
- if (!test_bit(USBCAN_THREAD_RUNNING,&dev->flags))
+ if (!test_bit(USBCAN_THREAD_RUNNING,&m->dev->flags))
+ return;
+ if (test_bit(USBCAN_MESSAGE_TERMINATE,&m->flags))
return;
switch (urb->status) {
case 0:
/* success */
- set_bit(USBCAN_DATA_READ,&dev->flags);
- CANMSG("Message received\n");
- if (test_bit(USBCAN_THREAD_RUNNING,&dev->flags))
- wake_up_process(dev->comthread);
+ DEBUGMSG("%s > Message OK\n", __FUNCTION__);
+ set_bit(USBCAN_DATA_OK,&m->dev->flags);
+ set_bit(USBCAN_MESSAGE_DATA_OK,&m->flags);
+ DEBUGMSG("%s > TX flag set\n", __FUNCTION__);
+ set_bit(USBCAN_DATA_TX,&m->dev->flags);
+ usbcan_usb_message_move_list(m->dev, m, &m->dev->tx_ready_list);
+ if (test_bit(USBCAN_THREAD_RUNNING,&m->dev->flags))
+ wake_up_process(m->dev->comthread);
+ else
+ CANMSG("%s > USBCAN thread not running\n", __FUNCTION__);
return;
case -ECONNRESET:
case -ENOENT:
case -ESHUTDOWN:
/* this urb is terminated, clean up */
- CANMSG("%s - urb shutting down with status: %d\n", __FUNCTION__, urb->status);
- set_bit(USBCAN_TERMINATE,&dev->flags);
+ CANMSG("%s > Urb shutting down with status: %d\n", __FUNCTION__, urb->status);
+// set_bit(USBCAN_TERMINATE,&m->dev->flags);
+ set_bit(USBCAN_MESSAGE_TERMINATE,&m->flags);
return;
default:
-// CANMSG("%s - nonzero urb status received: %d\n", __FUNCTION__, urb->status);
+ //CANMSG("%s > Nonzero status received: %d\n", __FUNCTION__, urb->status);
break;
}
+ // Try to send urb again on non significant errors
retval = usb_submit_urb (urb, GFP_ATOMIC);
if (retval<0){
- CANMSG("%s - usb_submit_urb failed with result %d ... retrying\n",
- __FUNCTION__, retval);
- set_bit(USBCAN_ERROR,&dev->flags);
- if (test_bit(USBCAN_THREAD_RUNNING,&dev->flags))
- wake_up_process(dev->comthread);
+ CANMSG("%s > Retrying urb failed with result %d\n", __FUNCTION__, retval);
+ set_bit(USBCAN_ERROR,&m->dev->flags);
+ usbcan_usb_message_move_list(m->dev, m, &m->dev->tx_ready_list);
+ if (test_bit(USBCAN_THREAD_RUNNING,&m->dev->flags))
+ wake_up_process(m->dev->comthread);
+ }
+}
+
+static void usbcan_rx_callback(struct urb *urb)
+{
+ struct usbcan_message *m = urb->context;
+ int retval;
+
+ if (!test_bit(USBCAN_THREAD_RUNNING,&m->dev->flags))
+ return;
+ if (test_bit(USBCAN_MESSAGE_TERMINATE,&m->flags))
+ return;
+
+ switch (urb->status) {
+ case 0:
+ /* success */
+ DEBUGMSG("%s > Message OK\n", __FUNCTION__);
+ set_bit(USBCAN_DATA_OK,&m->dev->flags);
+ set_bit(USBCAN_MESSAGE_DATA_OK,&m->flags);
+ DEBUGMSG("%s > RX flag set\n", __FUNCTION__);
+ set_bit(USBCAN_DATA_RX,&m->dev->flags);
+ usbcan_usb_message_move_list(m->dev, m, &m->dev->rx_ready_list);
+ if (test_bit(USBCAN_THREAD_RUNNING,&m->dev->flags))
+ wake_up_process(m->dev->comthread);
+ else
+ CANMSG("%s > USBCAN thread not running\n", __FUNCTION__);
+ return;
+ case -ECONNRESET:
+ case -ENOENT:
+ case -ESHUTDOWN:
+ /* this urb is terminated, clean up */
+ CANMSG("%s > Urb shutting down with status: %d\n", __FUNCTION__, urb->status);
+// set_bit(USBCAN_TERMINATE,&m->dev->flags);
+ set_bit(USBCAN_MESSAGE_TERMINATE,&m->flags);
+ return;
+ default:
+ //CANMSG("%s > Nonzero status received: %d\n", __FUNCTION__, urb->status);
+ break;
+ }
+
+ // Try to send urb again on non significant errors
+ retval = usb_submit_urb (urb, GFP_ATOMIC);
+ if (retval<0){
+ CANMSG("%s > Retrying urb failed with result %d\n", __FUNCTION__, retval);
+ set_bit(USBCAN_ERROR,&m->dev->flags);
+ usbcan_usb_message_move_list(m->dev, m, &m->dev->rx_ready_list);
+ if (test_bit(USBCAN_THREAD_RUNNING,&m->dev->flags))
+ wake_up_process(m->dev->comthread);
+ }
+}
+
+
+static void usbcan_kthread_free_urbs(struct usbcan_usb *dev)
+{
+ while(!list_empty(&dev->rx_pend_list)) {
+ struct usbcan_message *m;
+ m = list_first_entry(&dev->rx_pend_list, typeof(*m), list_node);
+ set_bit(USBCAN_MESSAGE_TERMINATE,&m->flags);
+ usb_kill_urb(m->u);
+ usbcan_usb_message_move_list(dev, m, &dev->rx_ready_list);
+ }
+
+ while(!list_empty(&dev->tx_pend_list)) {
+ struct usbcan_message *m;
+ m = list_first_entry(&dev->tx_pend_list, typeof(*m), list_node);
+ set_bit(USBCAN_MESSAGE_TERMINATE,&m->flags);
+ usb_kill_urb(m->u);
+ usbcan_usb_message_move_list(dev, m, &dev->tx_idle_list);
+ }
+
+ while(!list_empty(&dev->rx_ready_list)) {
+ struct usbcan_message *m;
+ m = list_first_entry(&dev->rx_ready_list, typeof(*m), list_node);
+ list_del(&m->list_node);
+ usb_free_urb(m->u);
+ kfree(m);
}
+
+ while(!list_empty(&dev->tx_ready_list)) {
+ struct usbcan_message *m;
+ m = list_first_entry(&dev->tx_ready_list, typeof(*m), list_node);
+ list_del(&m->list_node);
+ usb_free_urb(m->u);
+ kfree(m);
+ }
+
+ while(!list_empty(&dev->tx_idle_list)) {
+ struct usbcan_message *m;
+ m = list_first_entry(&dev->tx_idle_list, typeof(*m), list_node);
+ list_del(&m->list_node);
+ usb_free_urb(m->u);
+ kfree(m);
+ }
+
}
-int usbcan_read_kthread(void *data)
+int usbcan_kthread(void *data)
{
- int retval=0;
+ int i,retval=0;
struct usbcan_usb *dev=(struct usbcan_usb *)data;
struct msgobj_t *obj;
- /* this is normal work to do */
- CANMSG ("usbcan thread started!\n");
+ CANMSG("Usbcan thread started...\n");
- dev->rx = usb_alloc_urb(0, GFP_KERNEL);
- if (!dev->rx){
- CANMSG("Error allocating usb urb\n");
+ if (!dev->chip)
goto error;
+ obj=dev->chip->msgobj[0];
+
+ INIT_LIST_HEAD(&dev->rx_pend_list);
+ INIT_LIST_HEAD(&dev->rx_ready_list);
+ INIT_LIST_HEAD(&dev->tx_idle_list);
+ INIT_LIST_HEAD(&dev->tx_pend_list);
+ INIT_LIST_HEAD(&dev->tx_ready_list);
+
+ if (1) {
+ struct sched_param param = { .sched_priority = 1 };
+ sched_setscheduler(current, SCHED_FIFO, ¶m);
+ }
+
+
+ /* Prepare receive urbs */
+ for (i=0;i<USBCAN_TOT_RX_URBS;i++){
+ struct usbcan_message *m;
+ struct urb *u = usb_alloc_urb(0, GFP_KERNEL);
+ if (!u){
+ CANMSG("Error allocating %d. usb receive urb\n",i);
+ goto error;
+ }
+ m = kzalloc(sizeof(struct usbcan_message), GFP_KERNEL);
+ if(!m) {
+ usb_free_urb(u);
+ CANMSG("Error allocating %d. receive usbcan_message\n",i);
+ goto error;
+ }
+ m->u = u;
+ u->dev = dev->udev;
+ m->dev = dev;
+ usb_fill_bulk_urb(u, dev->udev,
+ usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
+ m->msg, USBCAN_TRANSFER_SIZE, usbcan_rx_callback, m);
+
+ list_add_tail(&m->list_node, &dev->rx_ready_list);
+ }
+
+ /* Prepare transmit urbs */
+ for (i=0;i<USBCAN_TOT_TX_URBS;i++){
+ struct usbcan_message *m;
+ struct urb *u = usb_alloc_urb(0, GFP_KERNEL);
+ if (!u){
+ CANMSG("Error allocating %d. usb transmit urb\n",i);
+ goto error;
+ }
+ m = kzalloc(sizeof(struct usbcan_message), GFP_KERNEL);
+ if(!m) {
+ usb_free_urb(u);
+ CANMSG("Error allocating %d. transmit usbcan_message\n",i);
+ goto error;
+ }
+ m->u = u;
+ u->dev = dev->udev;
+ m->dev = dev;
+ usb_fill_bulk_urb(u, dev->udev,
+ usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
+ m->msg, USBCAN_TRANSFER_SIZE, usbcan_tx_callback, m);
+
+ list_add_tail(&m->list_node, &dev->tx_idle_list);
+
}
- dev->rx->dev = dev->udev;
- usb_fill_bulk_urb(dev->rx, dev->udev,
- usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
- &dev->rx_msg, 16,
- usbcan_rcv, dev);
set_bit(USBCAN_THREAD_RUNNING,&dev->flags);
- /* an endless loop in which we are doing our work */
- for(;;)
- {
- retval=usb_submit_urb(dev->rx, GFP_ATOMIC);
+ set_bit(USBCAN_FREE_TX_URB,&dev->flags);
+
+ for (i=0;i<USBCAN_TOT_RX_URBS;i++){
+ struct usbcan_message *m;
+ m = list_first_entry(&dev->rx_ready_list, typeof(*m), list_node);
+ usbcan_usb_message_move_list(dev, m, &dev->rx_pend_list);
+
+ retval=usb_submit_urb(m->u, GFP_KERNEL);
if (retval){
- CANMSG("URB error %d\n",retval);
+ CANMSG("%d. URB error %d\n",i,retval);
set_bit(USBCAN_ERROR,&dev->flags);
- break;
+ usbcan_usb_message_move_list(dev, m, &dev->rx_ready_list);
+ goto exit;
}
+ }
+ /* an endless loop in which we are doing our work */
+ for(;;)
+ {
/* We need to do a memory barrier here to be sure that
the flags are visible on all CPUs. */
mb();
/* fall asleep */
- usbcan_sleep_thread(dev);
- /* We need to do a memory barrier here to be sure that
- the flags are visible on all CPUs. */
+ if (!can_kthread_should_stop() && !test_bit(USBCAN_TERMINATE,&dev->flags) && (usbcan_sleep_thread(dev)<0)){
+ break;
+ }
+ /* We need to do a memory barrier here to be sure that the flags are visible on all CPUs. */
mb();
- /* here we are back from sleep because we caught a signal. */
- if (can_kthread_should_stop())
- {
- /* we received a request to terminate ourself */
+ if (can_kthread_should_stop() || test_bit(USBCAN_TERMINATE,&dev->flags)){
break;
}
- { /* Normal work to do */
- if (test_bit(USBCAN_DATA_READ,&dev->flags)){
- int i, len;
- clear_bit(USBCAN_DATA_READ,&dev->flags);
- CANMSG("Thread got received message\n");
+ clear_bit(USBCAN_DATA_OK,&dev->flags);
- if ((dev->chip)&&
- (dev->chip->flags & CHIP_CONFIGURED)
- ){
- u8 *ptr;
+ mb();
- obj=dev->chip->msgobj[0];
+ while(!list_empty(&dev->rx_ready_list)) {
+ struct usbcan_message *m;
+ m = list_first_entry(&dev->rx_ready_list, typeof(*m), list_node);
+ usbcan_kthread_read_handler(dev, m, obj);
+ }
- len=*(uint8_t *)(dev->rx_msg+1);
- if(len > CAN_MSG_LENGTH) len = CAN_MSG_LENGTH;
- obj->rx_msg.length = len;
+ while(!list_empty(&dev->tx_ready_list)) {
+ struct usbcan_message *m;
+ m = list_first_entry(&dev->tx_ready_list, typeof(*m), list_node);
+ usbcan_kthread_write_handler(dev, m, obj);
+ }
- obj->rx_msg.flags=le16_to_cpu(*(uint16_t *)(dev->rx_msg+2));
- obj->rx_msg.id=le32_to_cpu((*(uint32_t *)(dev->rx_msg+4)));
+ if (test_and_clear_bit(USBCAN_TX_PENDING,&dev->flags)) {
+ usbcan_kthread_write_request_handler(dev, obj);
+ }
+ }
- for(ptr=dev->rx_msg+8,i=0; i < len; ptr++,i++) {
- obj->rx_msg.data[i]=*ptr;
- }
+ set_bit(USBCAN_TERMINATE,&dev->flags);
+exit:
- // fill CAN message timestamp
- can_filltimestamp(&obj->rx_msg.timestamp);
- canque_filter_msg2edges(obj->qends, &obj->rx_msg);
- }
- else
- CANMSG("Destination chip not found\n");
- }
- }
- }
+ usbcan_kthread_free_urbs(dev);
clear_bit(USBCAN_THREAD_RUNNING,&dev->flags);
- /* here we go only in case of termination of the thread */
- if (dev->rx){
- usb_kill_urb(dev->rx);
- usb_free_urb(dev->rx);
- }
-
- CANMSG ("usbcan thread finished!\n");
- return 0;
+ CANMSG ("usbcan thread finished!\n");
+ return 0;
error:
- /* cleanup the thread, leave */
- CANMSG ("kernel thread terminated!\n");
- return -ENOMEM;
+ /* cleanup the thread, leave */
+ usbcan_kthread_free_urbs(dev);
+
+ CANMSG ("kernel thread terminated!\n");
+ return -ENOMEM;
}
static int usbcan_probe(struct usb_interface *interface, const struct usb_device_id *id)
iface_desc = interface->cur_altsetting;
if (iface_desc->desc.bNumEndpoints % 2){
- err("Endpoint count must be even");
+ CANMSG("Endpoint count must be even");
goto noalloc;
}
usbdevs = (struct usbcan_devs *) can_checked_malloc(sizeof(struct usbcan_devs));
if (!usbdevs) {
- err("Out of memory");
- goto error;
+ goto noalloc;
}
memset(usbdevs, 0, sizeof(struct usbcan_devs));
- usbdevs->count=usbcan_chip_count;
+ usbdevs->count = usbcan_chip_count;
+ usbdevs->udev = interface_to_usbdev(interface);
usbdevs->devs = (struct usbcan_usb **) can_checked_malloc(usbcan_chip_count * sizeof(struct usbcan_usb *));
if (!usbdevs->devs) {
- err("Out of memory");
goto error;
}
memset(usbdevs->devs, 0, usbcan_chip_count * sizeof(struct usbcan_usb *));
/* allocate memory for our device state and initialize it */
usbdevs->devs[j] = (struct usbcan_usb *) can_checked_malloc(sizeof(struct usbcan_usb));
if (!usbdevs->devs[j]) {
- err("Out of memory");
goto error;
}
memset(usbdevs->devs[j], 0, sizeof(struct usbcan_usb));
dev=usbdevs->devs[j];
+ spin_lock_init(&dev->list_lock);
mutex_init(&dev->io_mutex);
- dev->udev = interface_to_usbdev(interface);
+ init_waitqueue_head(&dev->queue);
+ dev->udev = usbdevs->udev;
dev->interface = interface;
/* set up the endpoint information */
dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
dev->bulk_in_buffer = can_checked_malloc(buffer_size);
if (!dev->bulk_in_buffer) {
- err("Could not allocate bulk_in_buffer");
+ CANMSG("Could not allocate bulk_in_buffer");
goto error;
}
}
}
if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
- err("Could not find all bulk-in and bulk-out endpoints for chip %d",j);
+ CANMSG("Could not find all bulk-in and bulk-out endpoints for chip %d",j);
goto error;
}
}
+
+ usb_get_dev(usbdevs->udev);
+
/* save our data pointer in this interface device */
usb_set_intfdata(interface, usbdevs);
- if (!(usbdevs->candev=register_usbdev("usbcan",(void *) usbdevs, usbcan_register_devs)))
+ usbdevs->candev=register_hotplug_dev("usbcan", usbcan_register_devs,(void *) usbdevs);
+ if (!(usbdevs->candev)){
+ CANMSG("register_hotplug_dev() failed\n");
goto register_error;
+ }
/* let the user know what node this device is now attached to */
- DEBUGMSG("USBCAN device now attached");
+ CANMSG("USBCAN device now attached\n");
return 0;
register_error:
- cleanup_usbdev(usbdevs->candev);
+// cleanup_hotplug_dev(usbdevs->candev);
+ usb_put_dev(usbdevs->udev);
error:
if (usbdevs){
if (usbdevs->devs){
- if (usbdevs->devs[0]){
- usb_put_dev(usbdevs->devs[0]->udev);
- }
for (j=0;j<usbdevs->count;j++){
if (!usbdevs->devs[j]) continue;
return retval;
}
-// Physically disconnected device
-static void usbcan_disconnect(struct usb_interface *interface)
-{
- struct usbcan_devs *usbdevs;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
+void release_device(struct kref *refcount){
+ struct candevice_t *candev = container_of(refcount,struct candevice_t,refcount);
+#else
+void release_device(struct candevice_t *candev){
+#endif
+ struct usbcan_devs *usbdevs = (struct usbcan_devs *)candev->sysdevptr.anydev;
int j;
- usbdevs = usb_get_intfdata(interface);
- if (usbdevs==NULL){
- CANMSG("USBCAN device seems to be removed\n");
+
+ if (!usbdevs)
return;
- }
- usb_set_intfdata(interface, NULL);
+
+ cleanup_hotplug_dev(usbdevs->candev);
if (usbdevs->devs){
- usb_put_dev((*usbdevs->devs)->udev);
- }
- cleanup_usbdev(usbdevs->candev);
- if (usbdevs->devs){
+ /* Finally, release all structures in USB subsystem */
+ if (!usbdevs->udev)
+ panic("udev is already null on device release");
+ usb_put_dev(usbdevs->udev);
+
for (j=0;j<usbdevs->count;j++){
if (!usbdevs->devs[j]) continue;
- /* prevent more I/O from starting */
- mutex_lock(&usbdevs->devs[j]->io_mutex);
- usbdevs->devs[j]->interface = NULL;
- mutex_unlock(&usbdevs->devs[j]->io_mutex);
-
if (usbdevs->devs[j]->bulk_in_buffer)
can_checked_free(usbdevs->devs[j]->bulk_in_buffer);
- // if (usbdevs->devs[j]->chip){
- // usbdevs->devs[j]->chip->chip_data=NULL;
- // }
can_checked_free(usbdevs->devs[j]);
usbdevs->devs[j]=NULL;
}
}
can_checked_free(usbdevs);
- DEBUGMSG("USBCAN now disconnected");
+ CANMSG("USBCAN now disconnected\n");
+}
+
+// Physically disconnected device
+static void usbcan_disconnect(struct usb_interface *interface)
+{
+ struct usbcan_devs *usbdevs;
+ int j;
+
+ /* prevent more I/O from starting */
+ lock_kernel();
+
+ usbdevs = usb_get_intfdata(interface);
+ if (usbdevs==NULL){
+ CANMSG("USBCAN device seems to be already removed\n");
+ unlock_kernel();
+ return;
+ }
+ usb_set_intfdata(interface, NULL);
+ deregister_hotplug_dev(usbdevs->candev);
+
+ for (j=0;j<usbdevs->count;j++){
+ if (!usbdevs->devs[j]) continue;
+ mutex_lock(&usbdevs->devs[j]->io_mutex);
+ usbdevs->devs[j]->interface = NULL;
+ mutex_unlock(&usbdevs->devs[j]->io_mutex);
+ }
+
+ unlock_kernel();
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
+ kref_put(&usbdevs->candev->refcount,release_device);
+#else
+ release_device(&usbdevs->candev);
+#endif
}
int usbcan_init(void){
projects / lincan.git / blobdiff