1021 lines · 23.7 KB · C
RawDownload
// SPDX-License-Identifier: GPL-2.0-only/* * CAN driver for "8 devices" USB2CAN converter * * Copyright (C) 2012 Bernd Krumboeck (krumboeck@universalnet.at) * * This driver is inspired by the 3.2.0 version of drivers/net/can/usb/ems_usb.c * and drivers/net/can/usb/esd_usb2.c * * Many thanks to Gerhard Bertelsmann (info@gerhard-bertelsmann.de) * for testing and fixing this driver. Also many thanks to "8 devices", * who were very cooperative and answered my questions. */ #include <linux/ethtool.h>#include <linux/signal.h>#include <linux/slab.h>#include <linux/module.h>#include <linux/netdevice.h>#include <linux/usb.h> #include <linux/can.h>#include <linux/can/dev.h>#include <linux/can/error.h> /* driver constants */#define MAX_RX_URBS			20#define MAX_TX_URBS			20#define RX_BUFFER_SIZE			64 /* vendor and product id */#define USB_8DEV_VENDOR_ID		0x0483#define USB_8DEV_PRODUCT_ID		0x1234 /* endpoints */enum usb_8dev_endpoint {	USB_8DEV_ENDP_DATA_RX = 1,	USB_8DEV_ENDP_DATA_TX,	USB_8DEV_ENDP_CMD_RX,	USB_8DEV_ENDP_CMD_TX}; /* device CAN clock */#define USB_8DEV_ABP_CLOCK		32000000 /* setup flags */#define USB_8DEV_SILENT			0x01#define USB_8DEV_LOOPBACK		0x02#define USB_8DEV_DISABLE_AUTO_RESTRANS	0x04#define USB_8DEV_STATUS_FRAME		0x08 /* commands */enum usb_8dev_cmd {	USB_8DEV_RESET = 1,	USB_8DEV_OPEN,	USB_8DEV_CLOSE,	USB_8DEV_SET_SPEED,	USB_8DEV_SET_MASK_FILTER,	USB_8DEV_GET_STATUS,	USB_8DEV_GET_STATISTICS,	USB_8DEV_GET_SERIAL,	USB_8DEV_GET_SOFTW_VER,	USB_8DEV_GET_HARDW_VER,	USB_8DEV_RESET_TIMESTAMP,	USB_8DEV_GET_SOFTW_HARDW_VER}; /* command options */#define USB_8DEV_BAUD_MANUAL		0x09#define USB_8DEV_CMD_START		0x11#define USB_8DEV_CMD_END		0x22 #define USB_8DEV_CMD_SUCCESS		0#define USB_8DEV_CMD_ERROR		255 #define USB_8DEV_CMD_TIMEOUT		1000 /* frames */#define USB_8DEV_DATA_START		0x55#define USB_8DEV_DATA_END		0xAA #define USB_8DEV_TYPE_CAN_FRAME		0#define USB_8DEV_TYPE_ERROR_FRAME	3 #define USB_8DEV_EXTID			0x01#define USB_8DEV_RTR			0x02#define USB_8DEV_ERR_FLAG		0x04 /* status */#define USB_8DEV_STATUSMSG_OK		0x00  /* Normal condition. */#define USB_8DEV_STATUSMSG_OVERRUN	0x01  /* Overrun occurred when sending */#define USB_8DEV_STATUSMSG_BUSLIGHT	0x02  /* Error counter has reached 96 */#define USB_8DEV_STATUSMSG_BUSHEAVY	0x03  /* Error count. has reached 128 */#define USB_8DEV_STATUSMSG_BUSOFF	0x04  /* Device is in BUSOFF */#define USB_8DEV_STATUSMSG_STUFF	0x20  /* Stuff Error */#define USB_8DEV_STATUSMSG_FORM		0x21  /* Form Error */#define USB_8DEV_STATUSMSG_ACK		0x23  /* Ack Error */#define USB_8DEV_STATUSMSG_BIT0		0x24  /* Bit1 Error */#define USB_8DEV_STATUSMSG_BIT1		0x25  /* Bit0 Error */#define USB_8DEV_STATUSMSG_CRC		0x27  /* CRC Error */ #define USB_8DEV_RP_MASK		0x7F  /* Mask for Receive Error Bit */  /* table of devices that work with this driver */static const struct usb_device_id usb_8dev_table[] = {	{ USB_DEVICE(USB_8DEV_VENDOR_ID, USB_8DEV_PRODUCT_ID) },	{ }					/* Terminating entry */}; MODULE_DEVICE_TABLE(usb, usb_8dev_table); struct usb_8dev_tx_urb_context {	struct usb_8dev_priv *priv; 	u32 echo_index;}; /* Structure to hold all of our device specific stuff */struct usb_8dev_priv {	struct can_priv can; /* must be the first member */ 	struct usb_device *udev;	struct net_device *netdev; 	atomic_t active_tx_urbs;	struct usb_anchor tx_submitted;	struct usb_8dev_tx_urb_context tx_contexts[MAX_TX_URBS]; 	struct usb_anchor rx_submitted; 	struct can_berr_counter bec; 	u8 *cmd_msg_buffer; 	struct mutex usb_8dev_cmd_lock;	void *rxbuf[MAX_RX_URBS];	dma_addr_t rxbuf_dma[MAX_RX_URBS];}; /* tx frame */struct __packed usb_8dev_tx_msg {	u8 begin;	u8 flags;	/* RTR and EXT_ID flag */	__be32 id;	/* upper 3 bits not used */	u8 dlc;		/* data length code 0-8 bytes */	u8 data[8];	/* 64-bit data */	u8 end;}; /* rx frame */struct __packed usb_8dev_rx_msg {	u8 begin;	u8 type;		/* frame type */	u8 flags;		/* RTR and EXT_ID flag */	__be32 id;		/* upper 3 bits not used */	u8 dlc;			/* data length code 0-8 bytes */	u8 data[8];		/* 64-bit data */	__be32 timestamp;	/* 32-bit timestamp */	u8 end;}; /* command frame */struct __packed usb_8dev_cmd_msg {	u8 begin;	u8 channel;	/* unknown - always 0 */	u8 command;	/* command to execute */	u8 opt1;	/* optional parameter / return value */	u8 opt2;	/* optional parameter 2 */	u8 data[10];	/* optional parameter and data */	u8 end;}; static int usb_8dev_send_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size){	int actual_length; 	return usb_bulk_msg(priv->udev,			    usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_TX),			    msg, size, &actual_length, USB_8DEV_CMD_TIMEOUT);} static int usb_8dev_wait_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size,				int *actual_length){	return usb_bulk_msg(priv->udev,			    usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_RX),			    msg, size, actual_length, USB_8DEV_CMD_TIMEOUT);} /* Send command to device and receive result. * Command was successful when opt1 = 0. */static int usb_8dev_send_cmd(struct usb_8dev_priv *priv,			     struct usb_8dev_cmd_msg *out,			     struct usb_8dev_cmd_msg *in){	int err;	int num_bytes_read;	struct net_device *netdev; 	netdev = priv->netdev; 	out->begin = USB_8DEV_CMD_START;	out->end = USB_8DEV_CMD_END; 	mutex_lock(&priv->usb_8dev_cmd_lock); 	memcpy(priv->cmd_msg_buffer, out,		sizeof(struct usb_8dev_cmd_msg)); 	err = usb_8dev_send_cmd_msg(priv, priv->cmd_msg_buffer,				    sizeof(struct usb_8dev_cmd_msg));	if (err < 0) {		netdev_err(netdev, "sending command message failed\n");		goto failed;	} 	err = usb_8dev_wait_cmd_msg(priv, priv->cmd_msg_buffer,				    sizeof(struct usb_8dev_cmd_msg),				    &num_bytes_read);	if (err < 0) {		netdev_err(netdev, "no command message answer\n");		goto failed;	} 	memcpy(in, priv->cmd_msg_buffer, sizeof(struct usb_8dev_cmd_msg)); 	if (in->begin != USB_8DEV_CMD_START || in->end != USB_8DEV_CMD_END ||			num_bytes_read != 16 || in->opt1 != 0)		err = -EPROTO; failed:	mutex_unlock(&priv->usb_8dev_cmd_lock);	return err;} /* Send open command to device */static int usb_8dev_cmd_open(struct usb_8dev_priv *priv){	struct can_bittiming *bt = &priv->can.bittiming;	struct usb_8dev_cmd_msg outmsg;	struct usb_8dev_cmd_msg inmsg;	u32 ctrlmode = priv->can.ctrlmode;	u32 flags = USB_8DEV_STATUS_FRAME;	__be32 beflags;	__be16 bebrp; 	memset(&outmsg, 0, sizeof(outmsg));	outmsg.command = USB_8DEV_OPEN;	outmsg.opt1 = USB_8DEV_BAUD_MANUAL;	outmsg.data[0] = bt->prop_seg + bt->phase_seg1;	outmsg.data[1] = bt->phase_seg2;	outmsg.data[2] = bt->sjw; 	/* BRP */	bebrp = cpu_to_be16((u16)bt->brp);	memcpy(&outmsg.data[3], &bebrp, sizeof(bebrp)); 	/* flags */	if (ctrlmode & CAN_CTRLMODE_LOOPBACK)		flags |= USB_8DEV_LOOPBACK;	if (ctrlmode & CAN_CTRLMODE_LISTENONLY)		flags |= USB_8DEV_SILENT;	if (ctrlmode & CAN_CTRLMODE_ONE_SHOT)		flags |= USB_8DEV_DISABLE_AUTO_RESTRANS; 	beflags = cpu_to_be32(flags);	memcpy(&outmsg.data[5], &beflags, sizeof(beflags)); 	return usb_8dev_send_cmd(priv, &outmsg, &inmsg);} /* Send close command to device */static int usb_8dev_cmd_close(struct usb_8dev_priv *priv){	struct usb_8dev_cmd_msg inmsg;	struct usb_8dev_cmd_msg outmsg = {		.channel = 0,		.command = USB_8DEV_CLOSE,		.opt1 = 0,		.opt2 = 0	}; 	return usb_8dev_send_cmd(priv, &outmsg, &inmsg);} /* Get firmware and hardware version */static int usb_8dev_cmd_version(struct usb_8dev_priv *priv, u32 *res){	struct usb_8dev_cmd_msg	inmsg;	struct usb_8dev_cmd_msg	outmsg = {		.channel = 0,		.command = USB_8DEV_GET_SOFTW_HARDW_VER,		.opt1 = 0,		.opt2 = 0	}; 	int err = usb_8dev_send_cmd(priv, &outmsg, &inmsg);	if (err)		return err; 	*res = be32_to_cpup((__be32 *)inmsg.data); 	return err;} /* Set network device mode * * Maybe we should leave this function empty, because the device * set mode variable with open command. */static int usb_8dev_set_mode(struct net_device *netdev, enum can_mode mode){	struct usb_8dev_priv *priv = netdev_priv(netdev);	int err = 0; 	switch (mode) {	case CAN_MODE_START:		err = usb_8dev_cmd_open(priv);		if (err)			netdev_warn(netdev, "couldn't start device");		break; 	default:		return -EOPNOTSUPP;	} 	return err;} /* Read error/status frames */static void usb_8dev_rx_err_msg(struct usb_8dev_priv *priv,				struct usb_8dev_rx_msg *msg){	struct can_frame *cf;	struct sk_buff *skb;	struct net_device_stats *stats = &priv->netdev->stats; 	/* Error message:	 * byte 0: Status	 * byte 1: bit   7: Receive Passive	 * byte 1: bit 0-6: Receive Error Counter	 * byte 2: Transmit Error Counter	 * byte 3: Always 0 (maybe reserved for future use)	 */ 	u8 state = msg->data[0];	u8 rxerr = msg->data[1] & USB_8DEV_RP_MASK;	u8 txerr = msg->data[2];	int rx_errors = 0;	int tx_errors = 0; 	skb = alloc_can_err_skb(priv->netdev, &cf);	if (!skb)		return; 	switch (state) {	case USB_8DEV_STATUSMSG_OK:		priv->can.state = CAN_STATE_ERROR_ACTIVE;		cf->can_id |= CAN_ERR_PROT;		cf->data[2] = CAN_ERR_PROT_ACTIVE;		break;	case USB_8DEV_STATUSMSG_BUSOFF:		priv->can.state = CAN_STATE_BUS_OFF;		cf->can_id |= CAN_ERR_BUSOFF;		priv->can.can_stats.bus_off++;		can_bus_off(priv->netdev);		break;	case USB_8DEV_STATUSMSG_OVERRUN:	case USB_8DEV_STATUSMSG_BUSLIGHT:	case USB_8DEV_STATUSMSG_BUSHEAVY:		cf->can_id |= CAN_ERR_CRTL;		break;	default:		priv->can.state = CAN_STATE_ERROR_WARNING;		cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;		priv->can.can_stats.bus_error++;		break;	} 	switch (state) {	case USB_8DEV_STATUSMSG_OK:	case USB_8DEV_STATUSMSG_BUSOFF:		break;	case USB_8DEV_STATUSMSG_ACK:		cf->can_id |= CAN_ERR_ACK;		tx_errors = 1;		break;	case USB_8DEV_STATUSMSG_CRC:		cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;		rx_errors = 1;		break;	case USB_8DEV_STATUSMSG_BIT0:		cf->data[2] |= CAN_ERR_PROT_BIT0;		tx_errors = 1;		break;	case USB_8DEV_STATUSMSG_BIT1:		cf->data[2] |= CAN_ERR_PROT_BIT1;		tx_errors = 1;		break;	case USB_8DEV_STATUSMSG_FORM:		cf->data[2] |= CAN_ERR_PROT_FORM;		rx_errors = 1;		break;	case USB_8DEV_STATUSMSG_STUFF:		cf->data[2] |= CAN_ERR_PROT_STUFF;		rx_errors = 1;		break;	case USB_8DEV_STATUSMSG_OVERRUN:		cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;		stats->rx_over_errors++;		rx_errors = 1;		break;	case USB_8DEV_STATUSMSG_BUSLIGHT:		priv->can.state = CAN_STATE_ERROR_WARNING;		cf->data[1] = (txerr > rxerr) ?			CAN_ERR_CRTL_TX_WARNING :			CAN_ERR_CRTL_RX_WARNING;		priv->can.can_stats.error_warning++;		break;	case USB_8DEV_STATUSMSG_BUSHEAVY:		priv->can.state = CAN_STATE_ERROR_PASSIVE;		cf->data[1] = (txerr > rxerr) ?			CAN_ERR_CRTL_TX_PASSIVE :			CAN_ERR_CRTL_RX_PASSIVE;		priv->can.can_stats.error_passive++;		break;	default:		netdev_warn(priv->netdev,			    "Unknown status/error message (%d)\n", state);		break;	} 	if (tx_errors) {		cf->data[2] |= CAN_ERR_PROT_TX;		stats->tx_errors++;	} 	if (rx_errors)		stats->rx_errors++;	if (priv->can.state != CAN_STATE_BUS_OFF) {		cf->can_id |= CAN_ERR_CNT;		cf->data[6] = txerr;		cf->data[7] = rxerr;	} 	priv->bec.txerr = txerr;	priv->bec.rxerr = rxerr; 	netif_rx(skb);} /* Read data and status frames */static void usb_8dev_rx_can_msg(struct usb_8dev_priv *priv,				struct usb_8dev_rx_msg *msg){	struct can_frame *cf;	struct sk_buff *skb;	struct net_device_stats *stats = &priv->netdev->stats; 	if (msg->type == USB_8DEV_TYPE_ERROR_FRAME &&		   msg->flags == USB_8DEV_ERR_FLAG) {		usb_8dev_rx_err_msg(priv, msg);	} else if (msg->type == USB_8DEV_TYPE_CAN_FRAME) {		skb = alloc_can_skb(priv->netdev, &cf);		if (!skb)			return; 		cf->can_id = be32_to_cpu(msg->id);		can_frame_set_cc_len(cf, msg->dlc & 0xF, priv->can.ctrlmode); 		if (msg->flags & USB_8DEV_EXTID)			cf->can_id |= CAN_EFF_FLAG; 		if (msg->flags & USB_8DEV_RTR) {			cf->can_id |= CAN_RTR_FLAG;		} else {			memcpy(cf->data, msg->data, cf->len);			stats->rx_bytes += cf->len;		}		stats->rx_packets++; 		netif_rx(skb);	} else {		netdev_warn(priv->netdev, "frame type %d unknown",			 msg->type);	} } /* Callback for reading data from device * * Check urb status, call read function and resubmit urb read operation. */static void usb_8dev_read_bulk_callback(struct urb *urb){	struct usb_8dev_priv *priv = urb->context;	struct net_device *netdev;	int retval;

Lines 1–500 of 1021.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t