]> rtime.felk.cvut.cz Git - lincan.git/blobdiff - lincan/src/usbcan.c
projects / lincan.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Minor variable type corrections (__u8 -> u8)
[lincan.git] / lincan / src / usbcan.c
diff --git a/lincan/src/usbcan.c b/lincan/src/usbcan.c
index 1f9c926687b4e0384a597a7f4ca0b2c3d3fd7db7..91807f77a669db1d2e5a8e4e248255adb5ca4952 100644 (file)
--- a/lincan/src/usbcan.c
+++ b/lincan/src/usbcan.c
@@ -47,6 +47,12 @@ int usbcan_request_io(struct candevice_t *candev)
 {
        struct usbcan_usb *dev = (struct usbcan_usb*)candev->sysdevptr.anydev;
 
+       if (!dev){
+               CANMSG("USBCAN_REQUEST_IO: Cannot register usbcan while usb device is not present.\n");
+               CANMSG("USBCAN_REQUEST_IO: Usbcan registers automatically on device insertion.\n");
+               return -ENODEV;
+       }
+
        /* start kernel thread */
        dev->rcvthread.arg = dev;
        start_kthread(usbcan_read_kthread, &dev->rcvthread);
@@ -177,7 +183,7 @@ int usbcan_register(struct hwspecops_t *hwspecops)
        return 0;
 }
 
-static int sja1000_report_error_limit_counter;
+// static int sja1000_report_error_limit_counter;
 
 static void sja1000_report_error(struct canchip_t *chip,
                                unsigned sr, unsigned ir, unsigned ecc)
@@ -269,17 +275,17 @@ int usbcan_extended_mask(struct canchip_t *chip, unsigned long code, unsigned  l
        int retval;
        struct usbcan_usb *dev=(struct usbcan_usb*)chip->hostdevice->sysdevptr.anydev;
 
-       struct usbcan_mask_t usbmask = {
-               .code=code,
-               .mask=mask,
-       };
+       u8 usbbuf[16];
+
+       *(uint32_t *)(usbbuf)=cpu_to_le32(mask);
+       *(uint32_t *)(usbbuf+4)=cpu_to_le32(code);
 
        retval=usb_control_msg(dev->udev,
                usb_sndctrlpipe(dev->udev, dev->ctl_out_endpointAddr),
                USBCAN_VENDOR_EXT_MASK_SET,
                USB_TYPE_VENDOR,
                0, chip->chip_idx,
-               &usbmask, sizeof(struct usbcan_mask_t),
+               &usbbuf, 16,
                10000);
        if (retval<0)
                return -ENODEV;
@@ -289,11 +295,11 @@ int usbcan_extended_mask(struct canchip_t *chip, unsigned long code, unsigned  l
                USBCAN_VENDOR_EXT_MASK_STATUS,
                USB_TYPE_VENDOR,
                0, chip->chip_idx,
-               dev->ctl_in_buffer, dev->ctl_in_size,
+               &usbbuf, 16,
                10000);
 
        if (retval==1){
-               if(dev->ctl_in_buffer[0]==1){
+               if(usbbuf[0]==1){
                        DEBUGMSG("Setting acceptance code to 0x%lx\n",(unsigned long)code);
                        DEBUGMSG("Setting acceptance mask to 0x%lx\n",(unsigned long)mask);
                        return 0;
@@ -322,21 +328,19 @@ int usbcan_baud_rate(struct canchip_t *chip, int rate, int clock, int sjw,
        int retval;
        struct usbcan_usb *dev=(struct usbcan_usb*)chip->hostdevice->sysdevptr.anydev;
 
-       // Data too big to use single receive control message
-       struct can_baudparams_t baud={
-               .flags=flags,
-               .baudrate=rate,
-               .sjw=sjw,
-               .sample_pt=sampl_pt,
-       };
+       u8 usbbuf[16];
 
+       *(int32_t *)(usbbuf)=cpu_to_le32(rate);
+       *(int32_t *)(usbbuf+4)=cpu_to_le32(sjw);
+       *(int32_t *)(usbbuf+8)=cpu_to_le32(sampl_pt);
+       *(int32_t *)(usbbuf+12)=cpu_to_le32(flags);
 
        retval=usb_control_msg(dev->udev,
                usb_sndctrlpipe(dev->udev, dev->ctl_out_endpointAddr),
                USBCAN_VENDOR_BAUD_RATE_SET,
                USB_TYPE_VENDOR,
                0, chip->chip_idx,
-               &baud, sizeof(struct can_baudparams_t),
+               &usbbuf, 16,
                10000);
        if (retval<0)
                return -ENODEV;
@@ -346,11 +350,11 @@ int usbcan_baud_rate(struct canchip_t *chip, int rate, int clock, int sjw,
                USBCAN_VENDOR_BAUD_RATE_STATUS,
                USB_TYPE_VENDOR,
                0, chip->chip_idx,
-               dev->ctl_in_buffer, dev->ctl_in_size,
+               usbbuf, 16,
                10000);
 
        if (retval==1){
-               if(dev->ctl_in_buffer[0]==1)
+               if(usbbuf[0]==1)
                        return 0;
        }
 
@@ -393,6 +397,7 @@ int usbcan_pre_write_config(struct canchip_t *chip, struct msgobj_t *obj,
        struct usbcan_usb *dev=(struct usbcan_usb*)chip->hostdevice->sysdevptr.anydev;
        int i=0;
        int len;
+       u8 *ptr;
 
        /* Wait until Transmit Buffer Status is released */
        while ( usbcan_chip_queue_status(chip) &&
@@ -404,29 +409,20 @@ int usbcan_pre_write_config(struct canchip_t *chip, struct msgobj_t *obj,
                return -EIO;
        }
 
-       dev->tx_msg.chip_id=(__u8)chip->chip_idx;
+       *(uint8_t *)(dev->tx_msg)=chip->chip_idx & 0xFF;
 
        len = msg->length;
        if(len > CAN_MSG_LENGTH) len = CAN_MSG_LENGTH;
-       dev->tx_msg.length=(__u8)len;
-       dev->tx_msg.flags=(__u16)msg->flags;
-
-       if(msg->flags&MSG_EXT) {
-               dev->tx_msg.id[0]=(msg->id) & 0xff;
-               dev->tx_msg.id[1]=(msg->id>>8) & 0xff;
-               dev->tx_msg.id[2]=(msg->id>>16) & 0xff;
-               dev->tx_msg.id[3]=(msg->id>>24) & 0xff;
-       } else {
-               dev->tx_msg.id[0]=(msg->id) & 0xff;
-               dev->tx_msg.id[1]=(msg->id>>8) & 0xff;
-               dev->tx_msg.id[2]=0;
-               dev->tx_msg.id[3]=0;
-       }
-       for(i=0; i < len; i++) {
-               dev->tx_msg.data[i]=(__u8) msg->data[i];
+
+       *(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; i < 8; i++) {
-               dev->tx_msg.data[i]=0;
+       for(; i < 8; ptr++,i++) {
+               *ptr=0;
        }
        return 0;
 }
@@ -451,14 +447,14 @@ int usbcan_send_msg(struct canchip_t *chip, struct msgobj_t *obj,
        set_bit(USBCAN_TX_PENDING,&dev->flags);
        retval=usb_bulk_msg(dev->udev,
                        usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
-                       &dev->tx_msg, sizeof(struct usbcan_canmsg_t),
+                       &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!=sizeof(struct usbcan_canmsg_t)){
+       if (len!=16){
                CANMSG("CAN message not sent\n");
                return -EIO;
        }
@@ -496,12 +492,13 @@ int usbcan_set_btregs(struct canchip_t *chip, unsigned short btr0,
 {
        int retval;
        struct usbcan_usb *dev=(struct usbcan_usb*)chip->hostdevice->sysdevptr.anydev;
+       uint16_t value=(btr1&0xFF)<<8 | (btr0&0xFF);
 
        retval = usb_control_msg(dev->udev,
        usb_rcvctrlpipe(dev->udev, dev->ctl_in_endpointAddr),
        USBCAN_VENDOR_SET_BTREGS,
        USB_TYPE_VENDOR,
-       btr1<<8 | btr0, chip->chip_idx,
+       cpu_to_le16(value), chip->chip_idx,
        dev->ctl_in_buffer, dev->ctl_in_size,
        10000);
 
@@ -563,9 +560,9 @@ int usbcan_chip_queue_status(struct canchip_t *chip)
 
        if (retval==1){
                if(dev->ctl_in_buffer[0]==1)
-                       return 1;
-               if(dev->ctl_in_buffer[0]==0)
                        return 0;
+               if(dev->ctl_in_buffer[0]==0)
+                       return 1;
        }
        return -ENODEV;
 }
@@ -1019,7 +1016,7 @@ void usbcan_read_kthread(kthread_t *kthread)
        dev->rcv->dev = dev->udev;
        usb_fill_bulk_urb(dev->rcv, dev->udev,
                         usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
-                        &dev->rcv_msg, sizeof(struct usbcan_canmsg_t),
+                        &dev->rcv_msg, 16,
                         usbcan_rcv, dev);
 
   /* an endless loop in which we are doing our work */
@@ -1050,7 +1047,7 @@ void usbcan_read_kthread(kthread_t *kthread)
 
                if (test_bit(USBCAN_ERROR,&dev->flags)){
                        CANMSG("URB error %d\n",retval);
-                       break;
+                       clear_bit(USBCAN_ERROR,&dev->flags);
                }
 
                { /* Normal work to do */
@@ -1058,27 +1055,22 @@ void usbcan_read_kthread(kthread_t *kthread)
                                int i, len;
                                clear_bit(USBCAN_DATA_READ,&dev->flags);
 
-                               if ((dev->candev->chip[dev->rcv_msg.chip_id])&&
-                                       (dev->candev->chip[dev->rcv_msg.chip_id]->flags & CHIP_CONFIGURED)){
-
-                                       obj=dev->candev->chip[dev->rcv_msg.chip_id]->msgobj[0];
-                                       if (dev->rcv_msg.flags & MSG_EXT) {
-                                               obj->rx_msg.id =
-                                                       (dev->rcv_msg.id[0]) +
-                                                       (dev->rcv_msg.id[1]<<8) +
-                                                       (dev->rcv_msg.id[2]<<16) +
-                                                       (dev->rcv_msg.id[3]<<24);
-                                       } else {
-                                               obj->rx_msg.id =
-                                                       (dev->rcv_msg.id[0]) +
-                                                       (dev->rcv_msg.id[1]<<8);
-                                       }
-                                       obj->rx_msg.flags = dev->rcv_msg.flags;
-                                       len=dev->rcv_msg.length;
+                               if ((dev->candev->chip[dev->rcv_msg[0]])&&
+                                       (dev->candev->chip[dev->rcv_msg[0]]->flags & CHIP_CONFIGURED)
+                               ){
+                                       u8 *ptr;
+
+                                       obj=dev->candev->chip[dev->rcv_msg[0]]->msgobj[0];
+
+                                       len=*(uint8_t *)(dev->rcv_msg+1);
                                        if(len > CAN_MSG_LENGTH) len = CAN_MSG_LENGTH;
                                        obj->rx_msg.length = len;
-                                       for(i=0; i< len; i++) {
-                                               obj->rx_msg.data[i]=obj->rx_msg.data[i];
+
+                                       obj->rx_msg.flags=le16_to_cpu(*(uint16_t *)(dev->rcv_msg+2));
+                                       obj->rx_msg.id=le32_to_cpu((*(uint32_t *)(dev->rcv_msg+4)));
+
+                                       for(ptr=dev->rcv_msg+8,i=0; i < len; ptr++,i++) {
+                                               obj->rx_msg.data[i]=*ptr;
                                        }
 
                                        // fill CAN message timestamp
@@ -1112,6 +1104,7 @@ static int usbcan_probe(struct usb_interface *interface, const struct usb_device
                err("Out of memory");
                goto error;
        }
+       memset(dev, 0, sizeof(struct usbcan_usb));
 
        sema_init(&dev->limit_sem, WRITES_IN_FLIGHT);
        spin_lock_init(&dev->err_lock);
@@ -1202,6 +1195,8 @@ static void usbcan_disconnect(struct usb_interface *interface)
        int minor = interface->minor;
 
        dev = usb_get_intfdata(interface);
+       if (!dev)
+               return;
        usb_set_intfdata(interface, NULL);
 
        /* prevent more I/O from starting */
LinCAN driver development repository