#include <linux/usb.h>
#include <linux/mutex.h>
+#include "../include/kthread.h"
+
/* our private defines. if this grows any larger, use your own .h file */
#define MAX_TRANSFER (PAGE_SIZE - 512)
/* MAX_TRANSFER is chosen so that the VM is not stressed by
int usbcan_fill_chipspecops(struct canchip_t *chip);
int usbcan_irq_handler(int irq, struct canchip_t *chip);
-void usbcan_read_kthread(kthread_t *kthread);
-int usbcan_chip_queue_status(struct canchip_t *chip);
-
int usbcan_init(void);
void usbcan_exit(void);
-static int usbcan_probe(struct usb_interface *interface, const struct usb_device_id *id);
-static void usbcan_disconnect(struct usb_interface *interface);
+
+void usbcan_read_kthread(kthread_t *kthread);
+int usbcan_chip_queue_status(struct canchip_t *chip);
#ifdef CONFIG_OC_LINCAN_DETAILED_ERRORS
#define USBCAN_VENDOR_CHECK_TX_STAT (4)
#define USBCAN_VENDOR_START_CHIP (5)
#define USBCAN_VENDOR_STOP_CHIP (6)
-
-/* table of devices that work with this driver */
-static struct usb_device_id usbcan_table [] = {
- { USB_DEVICE(USBCAN_VENDOR_ID, USBCAN_PRODUCT_ID) },
- { } /* Terminating entry */
-};
-MODULE_DEVICE_TABLE(usb, usbcan_table);
-
-static struct usb_driver usbcan_driver = {
- .name = "usbcan",
- .id_table = usbcan_table,
- .probe = usbcan_probe,
- .disconnect = usbcan_disconnect,
-};
-
+#define USBCAN_VENDOR_EXT_MASK_SET (7)
+#define USBCAN_VENDOR_EXT_MASK_STATUS (8)
#endif /*USBCAN_H*/
-#include <linux/config.h>
#include <linux/version.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
+ #include <linux/config.h>
+#endif
#if defined(MODVERSIONS)
#include <linux/modversions.h>
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,40))
#include <linux/tqueue.h>
-#else
+#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
#include <linux/devfs_fs_kernel.h>
#endif
init_MUTEX_LOCKED(&kthread->startstop_sem);
/* We need to do a memory barrier here to be sure that
- the flags are visible on all CPUs.
+ the flags are visible on all CPUs.
*/
mb();
kthread->terminate = 1;
/* We need to do a memory barrier here to be sure that
- the flags are visible on all CPUs.
+ the flags are visible on all CPUs.
*/
mb();
kill_proc(kthread->thread->pid, SIGKILL, 1);
* Version lincan-0.3 17 Jul 2008
*/
-#include "../include/kthread.h"
#include "../include/can.h"
#include "../include/can_sysdep.h"
#include "../include/main.h"
#include "../include/setup.h"
#include "../include/usbcan.h"
+static int usbcan_probe(struct usb_interface *interface, const struct usb_device_id *id);
+static void usbcan_disconnect(struct usb_interface *interface);
+
+/* table of devices that work with this driver */
+static struct usb_device_id usbcan_table [] = {
+ { USB_DEVICE(USBCAN_VENDOR_ID, USBCAN_PRODUCT_ID) },
+ { } /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, usbcan_table);
+
+static struct usb_driver usbcan_driver = {
+ .name = "usbcan",
+ .id_table = usbcan_table,
+ .probe = usbcan_probe,
+ .disconnect = usbcan_disconnect,
+};
+
/**
* usbcan_request_io: - reserve io or memory range for can board
* @candev: pointer to candevice/board which asks for io. Field @io_addr
int retval;
struct usbcan_usb *dev=(struct usbcan_usb*)chip->hostdevice->sysdevptr.anydev;
- struct usbcan_mask_t mask={
- .code=code;
- .mask=mask;
+ struct usbcan_mask_t usbmask = {
+ .code=code,
+ .mask=mask,
};
retval=usb_control_msg(dev->udev,
USBCAN_VENDOR_EXT_MASK_SET,
USB_TYPE_VENDOR,
0, chip->chip_idx,
- &mask, sizeof(usbcan_mask_t),
+ &usbmask, sizeof(struct usbcan_mask_t),
10000);
if (retval<0)
return -ENODEV;
USBCAN_VENDOR_BAUD_RATE_SET,
USB_TYPE_VENDOR,
0, chip->chip_idx,
- &baud, sizeof(can_baudparams_t),
+ &baud, sizeof(struct can_baudparams_t),
10000);
if (retval<0)
return -ENODEV;
struct canmsg_t *msg)
{
struct usbcan_usb *dev=(struct usbcan_usb*)chip->hostdevice->sysdevptr.anydev;
- int len;
+ int len,retval;
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(usbcan_canmsg_t),
+ &dev->tx_msg, sizeof(struct usbcan_canmsg_t),
&len,10000);
clear_bit(USBCAN_TX_PENDING,&dev->flags);
if (retval){
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(usbcan_canmsg_t),
+ &dev->rcv_msg, sizeof(struct usbcan_canmsg_t),
usbcan_rcv, dev);
/* an endless loop in which we are doing our work */
}
/* fall asleep */
wait_event_interruptible(kthread->queue,
- test_bit(USBCAN_CHIP_DATA_READ,&chip_data->flags)
- || test_bit(USBCAN_CHIP_TERMINATE,&chip_data->flags)
- || test_bit(USBCAN_CHIP_ERROR,&chip_data->flags)
+ test_bit(USBCAN_DATA_READ,&dev->flags)
+ || test_bit(USBCAN_TERMINATE,&dev->flags)
+ || test_bit(USBCAN_ERROR,&dev->flags)
);
/* We need to do a memory barrier here to be sure that
break;
}
- if (test_bit(USBCAN_CHIP_ERROR,&chip_data->flags)){
+ if (test_bit(USBCAN_ERROR,&dev->flags)){
CANMSG("URB error %d\n",retval);
break;
}
{ /* Normal work to do */
- if (test_bit(USBCAN_CHIP_DATA_READ,&chip_data->flags)){
+ if (test_bit(USBCAN_DATA_READ,&dev->flags)){
int i, len;
- clear_bit(USBCAN_CHIP_DATA_READ,&chip_data->flags);
+ 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)){
+ (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) {