PageRenderTime 96ms CodeModel.GetById 12ms app.highlight 77ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/net/can/usb/ems_usb.c

http://github.com/mirrors/linux
C | 1075 lines | 731 code | 237 blank | 107 comment | 96 complexity | 6892da05adaba124597782db7801e859 MD5 | raw file
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * CAN driver for EMS Dr. Thomas Wuensche CPC-USB/ARM7
   4 *
   5 * Copyright (C) 2004-2009 EMS Dr. Thomas Wuensche
   6 */
   7#include <linux/signal.h>
   8#include <linux/slab.h>
   9#include <linux/module.h>
  10#include <linux/netdevice.h>
  11#include <linux/usb.h>
  12
  13#include <linux/can.h>
  14#include <linux/can/dev.h>
  15#include <linux/can/error.h>
  16
  17MODULE_AUTHOR("Sebastian Haas <haas@ems-wuensche.com>");
  18MODULE_DESCRIPTION("CAN driver for EMS Dr. Thomas Wuensche CAN/USB interfaces");
  19MODULE_LICENSE("GPL v2");
  20
  21/* Control-Values for CPC_Control() Command Subject Selection */
  22#define CONTR_CAN_MESSAGE 0x04
  23#define CONTR_CAN_STATE   0x0C
  24#define CONTR_BUS_ERROR   0x1C
  25
  26/* Control Command Actions */
  27#define CONTR_CONT_OFF 0
  28#define CONTR_CONT_ON  1
  29#define CONTR_ONCE     2
  30
  31/* Messages from CPC to PC */
  32#define CPC_MSG_TYPE_CAN_FRAME       1  /* CAN data frame */
  33#define CPC_MSG_TYPE_RTR_FRAME       8  /* CAN remote frame */
  34#define CPC_MSG_TYPE_CAN_PARAMS      12 /* Actual CAN parameters */
  35#define CPC_MSG_TYPE_CAN_STATE       14 /* CAN state message */
  36#define CPC_MSG_TYPE_EXT_CAN_FRAME   16 /* Extended CAN data frame */
  37#define CPC_MSG_TYPE_EXT_RTR_FRAME   17 /* Extended remote frame */
  38#define CPC_MSG_TYPE_CONTROL         19 /* change interface behavior */
  39#define CPC_MSG_TYPE_CONFIRM         20 /* command processed confirmation */
  40#define CPC_MSG_TYPE_OVERRUN         21 /* overrun events */
  41#define CPC_MSG_TYPE_CAN_FRAME_ERROR 23 /* detected bus errors */
  42#define CPC_MSG_TYPE_ERR_COUNTER     25 /* RX/TX error counter */
  43
  44/* Messages from the PC to the CPC interface  */
  45#define CPC_CMD_TYPE_CAN_FRAME     1   /* CAN data frame */
  46#define CPC_CMD_TYPE_CONTROL       3   /* control of interface behavior */
  47#define CPC_CMD_TYPE_CAN_PARAMS    6   /* set CAN parameters */
  48#define CPC_CMD_TYPE_RTR_FRAME     13  /* CAN remote frame */
  49#define CPC_CMD_TYPE_CAN_STATE     14  /* CAN state message */
  50#define CPC_CMD_TYPE_EXT_CAN_FRAME 15  /* Extended CAN data frame */
  51#define CPC_CMD_TYPE_EXT_RTR_FRAME 16  /* Extended CAN remote frame */
  52#define CPC_CMD_TYPE_CAN_EXIT      200 /* exit the CAN */
  53
  54#define CPC_CMD_TYPE_INQ_ERR_COUNTER 25 /* request the CAN error counters */
  55#define CPC_CMD_TYPE_CLEAR_MSG_QUEUE 8  /* clear CPC_MSG queue */
  56#define CPC_CMD_TYPE_CLEAR_CMD_QUEUE 28 /* clear CPC_CMD queue */
  57
  58#define CPC_CC_TYPE_SJA1000 2 /* Philips basic CAN controller */
  59
  60#define CPC_CAN_ECODE_ERRFRAME 0x01 /* Ecode type */
  61
  62/* Overrun types */
  63#define CPC_OVR_EVENT_CAN       0x01
  64#define CPC_OVR_EVENT_CANSTATE  0x02
  65#define CPC_OVR_EVENT_BUSERROR  0x04
  66
  67/*
  68 * If the CAN controller lost a message we indicate it with the highest bit
  69 * set in the count field.
  70 */
  71#define CPC_OVR_HW 0x80
  72
  73/* Size of the "struct ems_cpc_msg" without the union */
  74#define CPC_MSG_HEADER_LEN   11
  75#define CPC_CAN_MSG_MIN_SIZE 5
  76
  77/* Define these values to match your devices */
  78#define USB_CPCUSB_VENDOR_ID 0x12D6
  79
  80#define USB_CPCUSB_ARM7_PRODUCT_ID 0x0444
  81
  82/* Mode register NXP LPC2119/SJA1000 CAN Controller */
  83#define SJA1000_MOD_NORMAL 0x00
  84#define SJA1000_MOD_RM     0x01
  85
  86/* ECC register NXP LPC2119/SJA1000 CAN Controller */
  87#define SJA1000_ECC_SEG   0x1F
  88#define SJA1000_ECC_DIR   0x20
  89#define SJA1000_ECC_ERR   0x06
  90#define SJA1000_ECC_BIT   0x00
  91#define SJA1000_ECC_FORM  0x40
  92#define SJA1000_ECC_STUFF 0x80
  93#define SJA1000_ECC_MASK  0xc0
  94
  95/* Status register content */
  96#define SJA1000_SR_BS 0x80
  97#define SJA1000_SR_ES 0x40
  98
  99#define SJA1000_DEFAULT_OUTPUT_CONTROL 0xDA
 100
 101/*
 102 * The device actually uses a 16MHz clock to generate the CAN clock
 103 * but it expects SJA1000 bit settings based on 8MHz (is internally
 104 * converted).
 105 */
 106#define EMS_USB_ARM7_CLOCK 8000000
 107
 108#define CPC_TX_QUEUE_TRIGGER_LOW	25
 109#define CPC_TX_QUEUE_TRIGGER_HIGH	35
 110
 111/*
 112 * CAN-Message representation in a CPC_MSG. Message object type is
 113 * CPC_MSG_TYPE_CAN_FRAME or CPC_MSG_TYPE_RTR_FRAME or
 114 * CPC_MSG_TYPE_EXT_CAN_FRAME or CPC_MSG_TYPE_EXT_RTR_FRAME.
 115 */
 116struct cpc_can_msg {
 117	__le32 id;
 118	u8 length;
 119	u8 msg[8];
 120};
 121
 122/* Representation of the CAN parameters for the SJA1000 controller */
 123struct cpc_sja1000_params {
 124	u8 mode;
 125	u8 acc_code0;
 126	u8 acc_code1;
 127	u8 acc_code2;
 128	u8 acc_code3;
 129	u8 acc_mask0;
 130	u8 acc_mask1;
 131	u8 acc_mask2;
 132	u8 acc_mask3;
 133	u8 btr0;
 134	u8 btr1;
 135	u8 outp_contr;
 136};
 137
 138/* CAN params message representation */
 139struct cpc_can_params {
 140	u8 cc_type;
 141
 142	/* Will support M16C CAN controller in the future */
 143	union {
 144		struct cpc_sja1000_params sja1000;
 145	} cc_params;
 146};
 147
 148/* Structure for confirmed message handling */
 149struct cpc_confirm {
 150	u8 error; /* error code */
 151};
 152
 153/* Structure for overrun conditions */
 154struct cpc_overrun {
 155	u8 event;
 156	u8 count;
 157};
 158
 159/* SJA1000 CAN errors (compatible to NXP LPC2119) */
 160struct cpc_sja1000_can_error {
 161	u8 ecc;
 162	u8 rxerr;
 163	u8 txerr;
 164};
 165
 166/* structure for CAN error conditions */
 167struct cpc_can_error {
 168	u8 ecode;
 169
 170	struct {
 171		u8 cc_type;
 172
 173		/* Other controllers may also provide error code capture regs */
 174		union {
 175			struct cpc_sja1000_can_error sja1000;
 176		} regs;
 177	} cc;
 178};
 179
 180/*
 181 * Structure containing RX/TX error counter. This structure is used to request
 182 * the values of the CAN controllers TX and RX error counter.
 183 */
 184struct cpc_can_err_counter {
 185	u8 rx;
 186	u8 tx;
 187};
 188
 189/* Main message type used between library and application */
 190struct __packed ems_cpc_msg {
 191	u8 type;	/* type of message */
 192	u8 length;	/* length of data within union 'msg' */
 193	u8 msgid;	/* confirmation handle */
 194	__le32 ts_sec;	/* timestamp in seconds */
 195	__le32 ts_nsec;	/* timestamp in nano seconds */
 196
 197	union {
 198		u8 generic[64];
 199		struct cpc_can_msg can_msg;
 200		struct cpc_can_params can_params;
 201		struct cpc_confirm confirmation;
 202		struct cpc_overrun overrun;
 203		struct cpc_can_error error;
 204		struct cpc_can_err_counter err_counter;
 205		u8 can_state;
 206	} msg;
 207};
 208
 209/*
 210 * Table of devices that work with this driver
 211 * NOTE: This driver supports only CPC-USB/ARM7 (LPC2119) yet.
 212 */
 213static struct usb_device_id ems_usb_table[] = {
 214	{USB_DEVICE(USB_CPCUSB_VENDOR_ID, USB_CPCUSB_ARM7_PRODUCT_ID)},
 215	{} /* Terminating entry */
 216};
 217
 218MODULE_DEVICE_TABLE(usb, ems_usb_table);
 219
 220#define RX_BUFFER_SIZE      64
 221#define CPC_HEADER_SIZE     4
 222#define INTR_IN_BUFFER_SIZE 4
 223
 224#define MAX_RX_URBS 10
 225#define MAX_TX_URBS 10
 226
 227struct ems_usb;
 228
 229struct ems_tx_urb_context {
 230	struct ems_usb *dev;
 231
 232	u32 echo_index;
 233	u8 dlc;
 234};
 235
 236struct ems_usb {
 237	struct can_priv can; /* must be the first member */
 238
 239	struct sk_buff *echo_skb[MAX_TX_URBS];
 240
 241	struct usb_device *udev;
 242	struct net_device *netdev;
 243
 244	atomic_t active_tx_urbs;
 245	struct usb_anchor tx_submitted;
 246	struct ems_tx_urb_context tx_contexts[MAX_TX_URBS];
 247
 248	struct usb_anchor rx_submitted;
 249
 250	struct urb *intr_urb;
 251
 252	u8 *tx_msg_buffer;
 253
 254	u8 *intr_in_buffer;
 255	unsigned int free_slots; /* remember number of available slots */
 256
 257	struct ems_cpc_msg active_params; /* active controller parameters */
 258};
 259
 260static void ems_usb_read_interrupt_callback(struct urb *urb)
 261{
 262	struct ems_usb *dev = urb->context;
 263	struct net_device *netdev = dev->netdev;
 264	int err;
 265
 266	if (!netif_device_present(netdev))
 267		return;
 268
 269	switch (urb->status) {
 270	case 0:
 271		dev->free_slots = dev->intr_in_buffer[1];
 272		if (dev->free_slots > CPC_TX_QUEUE_TRIGGER_HIGH &&
 273		    netif_queue_stopped(netdev))
 274			netif_wake_queue(netdev);
 275		break;
 276
 277	case -ECONNRESET: /* unlink */
 278	case -ENOENT:
 279	case -EPIPE:
 280	case -EPROTO:
 281	case -ESHUTDOWN:
 282		return;
 283
 284	default:
 285		netdev_info(netdev, "Rx interrupt aborted %d\n", urb->status);
 286		break;
 287	}
 288
 289	err = usb_submit_urb(urb, GFP_ATOMIC);
 290
 291	if (err == -ENODEV)
 292		netif_device_detach(netdev);
 293	else if (err)
 294		netdev_err(netdev, "failed resubmitting intr urb: %d\n", err);
 295}
 296
 297static void ems_usb_rx_can_msg(struct ems_usb *dev, struct ems_cpc_msg *msg)
 298{
 299	struct can_frame *cf;
 300	struct sk_buff *skb;
 301	int i;
 302	struct net_device_stats *stats = &dev->netdev->stats;
 303
 304	skb = alloc_can_skb(dev->netdev, &cf);
 305	if (skb == NULL)
 306		return;
 307
 308	cf->can_id = le32_to_cpu(msg->msg.can_msg.id);
 309	cf->can_dlc = get_can_dlc(msg->msg.can_msg.length & 0xF);
 310
 311	if (msg->type == CPC_MSG_TYPE_EXT_CAN_FRAME ||
 312	    msg->type == CPC_MSG_TYPE_EXT_RTR_FRAME)
 313		cf->can_id |= CAN_EFF_FLAG;
 314
 315	if (msg->type == CPC_MSG_TYPE_RTR_FRAME ||
 316	    msg->type == CPC_MSG_TYPE_EXT_RTR_FRAME) {
 317		cf->can_id |= CAN_RTR_FLAG;
 318	} else {
 319		for (i = 0; i < cf->can_dlc; i++)
 320			cf->data[i] = msg->msg.can_msg.msg[i];
 321	}
 322
 323	stats->rx_packets++;
 324	stats->rx_bytes += cf->can_dlc;
 325	netif_rx(skb);
 326}
 327
 328static void ems_usb_rx_err(struct ems_usb *dev, struct ems_cpc_msg *msg)
 329{
 330	struct can_frame *cf;
 331	struct sk_buff *skb;
 332	struct net_device_stats *stats = &dev->netdev->stats;
 333
 334	skb = alloc_can_err_skb(dev->netdev, &cf);
 335	if (skb == NULL)
 336		return;
 337
 338	if (msg->type == CPC_MSG_TYPE_CAN_STATE) {
 339		u8 state = msg->msg.can_state;
 340
 341		if (state & SJA1000_SR_BS) {
 342			dev->can.state = CAN_STATE_BUS_OFF;
 343			cf->can_id |= CAN_ERR_BUSOFF;
 344
 345			dev->can.can_stats.bus_off++;
 346			can_bus_off(dev->netdev);
 347		} else if (state & SJA1000_SR_ES) {
 348			dev->can.state = CAN_STATE_ERROR_WARNING;
 349			dev->can.can_stats.error_warning++;
 350		} else {
 351			dev->can.state = CAN_STATE_ERROR_ACTIVE;
 352			dev->can.can_stats.error_passive++;
 353		}
 354	} else if (msg->type == CPC_MSG_TYPE_CAN_FRAME_ERROR) {
 355		u8 ecc = msg->msg.error.cc.regs.sja1000.ecc;
 356		u8 txerr = msg->msg.error.cc.regs.sja1000.txerr;
 357		u8 rxerr = msg->msg.error.cc.regs.sja1000.rxerr;
 358
 359		/* bus error interrupt */
 360		dev->can.can_stats.bus_error++;
 361		stats->rx_errors++;
 362
 363		cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
 364
 365		switch (ecc & SJA1000_ECC_MASK) {
 366		case SJA1000_ECC_BIT:
 367			cf->data[2] |= CAN_ERR_PROT_BIT;
 368			break;
 369		case SJA1000_ECC_FORM:
 370			cf->data[2] |= CAN_ERR_PROT_FORM;
 371			break;
 372		case SJA1000_ECC_STUFF:
 373			cf->data[2] |= CAN_ERR_PROT_STUFF;
 374			break;
 375		default:
 376			cf->data[3] = ecc & SJA1000_ECC_SEG;
 377			break;
 378		}
 379
 380		/* Error occurred during transmission? */
 381		if ((ecc & SJA1000_ECC_DIR) == 0)
 382			cf->data[2] |= CAN_ERR_PROT_TX;
 383
 384		if (dev->can.state == CAN_STATE_ERROR_WARNING ||
 385		    dev->can.state == CAN_STATE_ERROR_PASSIVE) {
 386			cf->can_id |= CAN_ERR_CRTL;
 387			cf->data[1] = (txerr > rxerr) ?
 388			    CAN_ERR_CRTL_TX_PASSIVE : CAN_ERR_CRTL_RX_PASSIVE;
 389		}
 390	} else if (msg->type == CPC_MSG_TYPE_OVERRUN) {
 391		cf->can_id |= CAN_ERR_CRTL;
 392		cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 393
 394		stats->rx_over_errors++;
 395		stats->rx_errors++;
 396	}
 397
 398	stats->rx_packets++;
 399	stats->rx_bytes += cf->can_dlc;
 400	netif_rx(skb);
 401}
 402
 403/*
 404 * callback for bulk IN urb
 405 */
 406static void ems_usb_read_bulk_callback(struct urb *urb)
 407{
 408	struct ems_usb *dev = urb->context;
 409	struct net_device *netdev;
 410	int retval;
 411
 412	netdev = dev->netdev;
 413
 414	if (!netif_device_present(netdev))
 415		return;
 416
 417	switch (urb->status) {
 418	case 0: /* success */
 419		break;
 420
 421	case -ENOENT:
 422		return;
 423
 424	default:
 425		netdev_info(netdev, "Rx URB aborted (%d)\n", urb->status);
 426		goto resubmit_urb;
 427	}
 428
 429	if (urb->actual_length > CPC_HEADER_SIZE) {
 430		struct ems_cpc_msg *msg;
 431		u8 *ibuf = urb->transfer_buffer;
 432		u8 msg_count, start;
 433
 434		msg_count = ibuf[0] & ~0x80;
 435
 436		start = CPC_HEADER_SIZE;
 437
 438		while (msg_count) {
 439			msg = (struct ems_cpc_msg *)&ibuf[start];
 440
 441			switch (msg->type) {
 442			case CPC_MSG_TYPE_CAN_STATE:
 443				/* Process CAN state changes */
 444				ems_usb_rx_err(dev, msg);
 445				break;
 446
 447			case CPC_MSG_TYPE_CAN_FRAME:
 448			case CPC_MSG_TYPE_EXT_CAN_FRAME:
 449			case CPC_MSG_TYPE_RTR_FRAME:
 450			case CPC_MSG_TYPE_EXT_RTR_FRAME:
 451				ems_usb_rx_can_msg(dev, msg);
 452				break;
 453
 454			case CPC_MSG_TYPE_CAN_FRAME_ERROR:
 455				/* Process errorframe */
 456				ems_usb_rx_err(dev, msg);
 457				break;
 458
 459			case CPC_MSG_TYPE_OVERRUN:
 460				/* Message lost while receiving */
 461				ems_usb_rx_err(dev, msg);
 462				break;
 463			}
 464
 465			start += CPC_MSG_HEADER_LEN + msg->length;
 466			msg_count--;
 467
 468			if (start > urb->transfer_buffer_length) {
 469				netdev_err(netdev, "format error\n");
 470				break;
 471			}
 472		}
 473	}
 474
 475resubmit_urb:
 476	usb_fill_bulk_urb(urb, dev->udev, usb_rcvbulkpipe(dev->udev, 2),
 477			  urb->transfer_buffer, RX_BUFFER_SIZE,
 478			  ems_usb_read_bulk_callback, dev);
 479
 480	retval = usb_submit_urb(urb, GFP_ATOMIC);
 481
 482	if (retval == -ENODEV)
 483		netif_device_detach(netdev);
 484	else if (retval)
 485		netdev_err(netdev,
 486			   "failed resubmitting read bulk urb: %d\n", retval);
 487}
 488
 489/*
 490 * callback for bulk IN urb
 491 */
 492static void ems_usb_write_bulk_callback(struct urb *urb)
 493{
 494	struct ems_tx_urb_context *context = urb->context;
 495	struct ems_usb *dev;
 496	struct net_device *netdev;
 497
 498	BUG_ON(!context);
 499
 500	dev = context->dev;
 501	netdev = dev->netdev;
 502
 503	/* free up our allocated buffer */
 504	usb_free_coherent(urb->dev, urb->transfer_buffer_length,
 505			  urb->transfer_buffer, urb->transfer_dma);
 506
 507	atomic_dec(&dev->active_tx_urbs);
 508
 509	if (!netif_device_present(netdev))
 510		return;
 511
 512	if (urb->status)
 513		netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status);
 514
 515	netif_trans_update(netdev);
 516
 517	/* transmission complete interrupt */
 518	netdev->stats.tx_packets++;
 519	netdev->stats.tx_bytes += context->dlc;
 520
 521	can_get_echo_skb(netdev, context->echo_index);
 522
 523	/* Release context */
 524	context->echo_index = MAX_TX_URBS;
 525
 526}
 527
 528/*
 529 * Send the given CPC command synchronously
 530 */
 531static int ems_usb_command_msg(struct ems_usb *dev, struct ems_cpc_msg *msg)
 532{
 533	int actual_length;
 534
 535	/* Copy payload */
 536	memcpy(&dev->tx_msg_buffer[CPC_HEADER_SIZE], msg,
 537	       msg->length + CPC_MSG_HEADER_LEN);
 538
 539	/* Clear header */
 540	memset(&dev->tx_msg_buffer[0], 0, CPC_HEADER_SIZE);
 541
 542	return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2),
 543			    &dev->tx_msg_buffer[0],
 544			    msg->length + CPC_MSG_HEADER_LEN + CPC_HEADER_SIZE,
 545			    &actual_length, 1000);
 546}
 547
 548/*
 549 * Change CAN controllers' mode register
 550 */
 551static int ems_usb_write_mode(struct ems_usb *dev, u8 mode)
 552{
 553	dev->active_params.msg.can_params.cc_params.sja1000.mode = mode;
 554
 555	return ems_usb_command_msg(dev, &dev->active_params);
 556}
 557
 558/*
 559 * Send a CPC_Control command to change behaviour when interface receives a CAN
 560 * message, bus error or CAN state changed notifications.
 561 */
 562static int ems_usb_control_cmd(struct ems_usb *dev, u8 val)
 563{
 564	struct ems_cpc_msg cmd;
 565
 566	cmd.type = CPC_CMD_TYPE_CONTROL;
 567	cmd.length = CPC_MSG_HEADER_LEN + 1;
 568
 569	cmd.msgid = 0;
 570
 571	cmd.msg.generic[0] = val;
 572
 573	return ems_usb_command_msg(dev, &cmd);
 574}
 575
 576/*
 577 * Start interface
 578 */
 579static int ems_usb_start(struct ems_usb *dev)
 580{
 581	struct net_device *netdev = dev->netdev;
 582	int err, i;
 583
 584	dev->intr_in_buffer[0] = 0;
 585	dev->free_slots = 50; /* initial size */
 586
 587	for (i = 0; i < MAX_RX_URBS; i++) {
 588		struct urb *urb = NULL;
 589		u8 *buf = NULL;
 590
 591		/* create a URB, and a buffer for it */
 592		urb = usb_alloc_urb(0, GFP_KERNEL);
 593		if (!urb) {
 594			err = -ENOMEM;
 595			break;
 596		}
 597
 598		buf = usb_alloc_coherent(dev->udev, RX_BUFFER_SIZE, GFP_KERNEL,
 599					 &urb->transfer_dma);
 600		if (!buf) {
 601			netdev_err(netdev, "No memory left for USB buffer\n");
 602			usb_free_urb(urb);
 603			err = -ENOMEM;
 604			break;
 605		}
 606
 607		usb_fill_bulk_urb(urb, dev->udev, usb_rcvbulkpipe(dev->udev, 2),
 608				  buf, RX_BUFFER_SIZE,
 609				  ems_usb_read_bulk_callback, dev);
 610		urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 611		usb_anchor_urb(urb, &dev->rx_submitted);
 612
 613		err = usb_submit_urb(urb, GFP_KERNEL);
 614		if (err) {
 615			usb_unanchor_urb(urb);
 616			usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf,
 617					  urb->transfer_dma);
 618			usb_free_urb(urb);
 619			break;
 620		}
 621
 622		/* Drop reference, USB core will take care of freeing it */
 623		usb_free_urb(urb);
 624	}
 625
 626	/* Did we submit any URBs */
 627	if (i == 0) {
 628		netdev_warn(netdev, "couldn't setup read URBs\n");
 629		return err;
 630	}
 631
 632	/* Warn if we've couldn't transmit all the URBs */
 633	if (i < MAX_RX_URBS)
 634		netdev_warn(netdev, "rx performance may be slow\n");
 635
 636	/* Setup and start interrupt URB */
 637	usb_fill_int_urb(dev->intr_urb, dev->udev,
 638			 usb_rcvintpipe(dev->udev, 1),
 639			 dev->intr_in_buffer,
 640			 INTR_IN_BUFFER_SIZE,
 641			 ems_usb_read_interrupt_callback, dev, 1);
 642
 643	err = usb_submit_urb(dev->intr_urb, GFP_KERNEL);
 644	if (err) {
 645		netdev_warn(netdev, "intr URB submit failed: %d\n", err);
 646
 647		return err;
 648	}
 649
 650	/* CPC-USB will transfer received message to host */
 651	err = ems_usb_control_cmd(dev, CONTR_CAN_MESSAGE | CONTR_CONT_ON);
 652	if (err)
 653		goto failed;
 654
 655	/* CPC-USB will transfer CAN state changes to host */
 656	err = ems_usb_control_cmd(dev, CONTR_CAN_STATE | CONTR_CONT_ON);
 657	if (err)
 658		goto failed;
 659
 660	/* CPC-USB will transfer bus errors to host */
 661	err = ems_usb_control_cmd(dev, CONTR_BUS_ERROR | CONTR_CONT_ON);
 662	if (err)
 663		goto failed;
 664
 665	err = ems_usb_write_mode(dev, SJA1000_MOD_NORMAL);
 666	if (err)
 667		goto failed;
 668
 669	dev->can.state = CAN_STATE_ERROR_ACTIVE;
 670
 671	return 0;
 672
 673failed:
 674	netdev_warn(netdev, "couldn't submit control: %d\n", err);
 675
 676	return err;
 677}
 678
 679static void unlink_all_urbs(struct ems_usb *dev)
 680{
 681	int i;
 682
 683	usb_unlink_urb(dev->intr_urb);
 684
 685	usb_kill_anchored_urbs(&dev->rx_submitted);
 686
 687	usb_kill_anchored_urbs(&dev->tx_submitted);
 688	atomic_set(&dev->active_tx_urbs, 0);
 689
 690	for (i = 0; i < MAX_TX_URBS; i++)
 691		dev->tx_contexts[i].echo_index = MAX_TX_URBS;
 692}
 693
 694static int ems_usb_open(struct net_device *netdev)
 695{
 696	struct ems_usb *dev = netdev_priv(netdev);
 697	int err;
 698
 699	err = ems_usb_write_mode(dev, SJA1000_MOD_RM);
 700	if (err)
 701		return err;
 702
 703	/* common open */
 704	err = open_candev(netdev);
 705	if (err)
 706		return err;
 707
 708	/* finally start device */
 709	err = ems_usb_start(dev);
 710	if (err) {
 711		if (err == -ENODEV)
 712			netif_device_detach(dev->netdev);
 713
 714		netdev_warn(netdev, "couldn't start device: %d\n", err);
 715
 716		close_candev(netdev);
 717
 718		return err;
 719	}
 720
 721
 722	netif_start_queue(netdev);
 723
 724	return 0;
 725}
 726
 727static netdev_tx_t ems_usb_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 728{
 729	struct ems_usb *dev = netdev_priv(netdev);
 730	struct ems_tx_urb_context *context = NULL;
 731	struct net_device_stats *stats = &netdev->stats;
 732	struct can_frame *cf = (struct can_frame *)skb->data;
 733	struct ems_cpc_msg *msg;
 734	struct urb *urb;
 735	u8 *buf;
 736	int i, err;
 737	size_t size = CPC_HEADER_SIZE + CPC_MSG_HEADER_LEN
 738			+ sizeof(struct cpc_can_msg);
 739
 740	if (can_dropped_invalid_skb(netdev, skb))
 741		return NETDEV_TX_OK;
 742
 743	/* create a URB, and a buffer for it, and copy the data to the URB */
 744	urb = usb_alloc_urb(0, GFP_ATOMIC);
 745	if (!urb)
 746		goto nomem;
 747
 748	buf = usb_alloc_coherent(dev->udev, size, GFP_ATOMIC, &urb->transfer_dma);
 749	if (!buf) {
 750		netdev_err(netdev, "No memory left for USB buffer\n");
 751		usb_free_urb(urb);
 752		goto nomem;
 753	}
 754
 755	msg = (struct ems_cpc_msg *)&buf[CPC_HEADER_SIZE];
 756
 757	msg->msg.can_msg.id = cpu_to_le32(cf->can_id & CAN_ERR_MASK);
 758	msg->msg.can_msg.length = cf->can_dlc;
 759
 760	if (cf->can_id & CAN_RTR_FLAG) {
 761		msg->type = cf->can_id & CAN_EFF_FLAG ?
 762			CPC_CMD_TYPE_EXT_RTR_FRAME : CPC_CMD_TYPE_RTR_FRAME;
 763
 764		msg->length = CPC_CAN_MSG_MIN_SIZE;
 765	} else {
 766		msg->type = cf->can_id & CAN_EFF_FLAG ?
 767			CPC_CMD_TYPE_EXT_CAN_FRAME : CPC_CMD_TYPE_CAN_FRAME;
 768
 769		for (i = 0; i < cf->can_dlc; i++)
 770			msg->msg.can_msg.msg[i] = cf->data[i];
 771
 772		msg->length = CPC_CAN_MSG_MIN_SIZE + cf->can_dlc;
 773	}
 774
 775	for (i = 0; i < MAX_TX_URBS; i++) {
 776		if (dev->tx_contexts[i].echo_index == MAX_TX_URBS) {
 777			context = &dev->tx_contexts[i];
 778			break;
 779		}
 780	}
 781
 782	/*
 783	 * May never happen! When this happens we'd more URBs in flight as
 784	 * allowed (MAX_TX_URBS).
 785	 */
 786	if (!context) {
 787		usb_free_coherent(dev->udev, size, buf, urb->transfer_dma);
 788		usb_free_urb(urb);
 789
 790		netdev_warn(netdev, "couldn't find free context\n");
 791
 792		return NETDEV_TX_BUSY;
 793	}
 794
 795	context->dev = dev;
 796	context->echo_index = i;
 797	context->dlc = cf->can_dlc;
 798
 799	usb_fill_bulk_urb(urb, dev->udev, usb_sndbulkpipe(dev->udev, 2), buf,
 800			  size, ems_usb_write_bulk_callback, context);
 801	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 802	usb_anchor_urb(urb, &dev->tx_submitted);
 803
 804	can_put_echo_skb(skb, netdev, context->echo_index);
 805
 806	atomic_inc(&dev->active_tx_urbs);
 807
 808	err = usb_submit_urb(urb, GFP_ATOMIC);
 809	if (unlikely(err)) {
 810		can_free_echo_skb(netdev, context->echo_index);
 811
 812		usb_unanchor_urb(urb);
 813		usb_free_coherent(dev->udev, size, buf, urb->transfer_dma);
 814		dev_kfree_skb(skb);
 815
 816		atomic_dec(&dev->active_tx_urbs);
 817
 818		if (err == -ENODEV) {
 819			netif_device_detach(netdev);
 820		} else {
 821			netdev_warn(netdev, "failed tx_urb %d\n", err);
 822
 823			stats->tx_dropped++;
 824		}
 825	} else {
 826		netif_trans_update(netdev);
 827
 828		/* Slow down tx path */
 829		if (atomic_read(&dev->active_tx_urbs) >= MAX_TX_URBS ||
 830		    dev->free_slots < CPC_TX_QUEUE_TRIGGER_LOW) {
 831			netif_stop_queue(netdev);
 832		}
 833	}
 834
 835	/*
 836	 * Release our reference to this URB, the USB core will eventually free
 837	 * it entirely.
 838	 */
 839	usb_free_urb(urb);
 840
 841	return NETDEV_TX_OK;
 842
 843nomem:
 844	dev_kfree_skb(skb);
 845	stats->tx_dropped++;
 846
 847	return NETDEV_TX_OK;
 848}
 849
 850static int ems_usb_close(struct net_device *netdev)
 851{
 852	struct ems_usb *dev = netdev_priv(netdev);
 853
 854	/* Stop polling */
 855	unlink_all_urbs(dev);
 856
 857	netif_stop_queue(netdev);
 858
 859	/* Set CAN controller to reset mode */
 860	if (ems_usb_write_mode(dev, SJA1000_MOD_RM))
 861		netdev_warn(netdev, "couldn't stop device");
 862
 863	close_candev(netdev);
 864
 865	return 0;
 866}
 867
 868static const struct net_device_ops ems_usb_netdev_ops = {
 869	.ndo_open = ems_usb_open,
 870	.ndo_stop = ems_usb_close,
 871	.ndo_start_xmit = ems_usb_start_xmit,
 872	.ndo_change_mtu = can_change_mtu,
 873};
 874
 875static const struct can_bittiming_const ems_usb_bittiming_const = {
 876	.name = "ems_usb",
 877	.tseg1_min = 1,
 878	.tseg1_max = 16,
 879	.tseg2_min = 1,
 880	.tseg2_max = 8,
 881	.sjw_max = 4,
 882	.brp_min = 1,
 883	.brp_max = 64,
 884	.brp_inc = 1,
 885};
 886
 887static int ems_usb_set_mode(struct net_device *netdev, enum can_mode mode)
 888{
 889	struct ems_usb *dev = netdev_priv(netdev);
 890
 891	switch (mode) {
 892	case CAN_MODE_START:
 893		if (ems_usb_write_mode(dev, SJA1000_MOD_NORMAL))
 894			netdev_warn(netdev, "couldn't start device");
 895
 896		if (netif_queue_stopped(netdev))
 897			netif_wake_queue(netdev);
 898		break;
 899
 900	default:
 901		return -EOPNOTSUPP;
 902	}
 903
 904	return 0;
 905}
 906
 907static int ems_usb_set_bittiming(struct net_device *netdev)
 908{
 909	struct ems_usb *dev = netdev_priv(netdev);
 910	struct can_bittiming *bt = &dev->can.bittiming;
 911	u8 btr0, btr1;
 912
 913	btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6);
 914	btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) |
 915		(((bt->phase_seg2 - 1) & 0x7) << 4);
 916	if (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
 917		btr1 |= 0x80;
 918
 919	netdev_info(netdev, "setting BTR0=0x%02x BTR1=0x%02x\n", btr0, btr1);
 920
 921	dev->active_params.msg.can_params.cc_params.sja1000.btr0 = btr0;
 922	dev->active_params.msg.can_params.cc_params.sja1000.btr1 = btr1;
 923
 924	return ems_usb_command_msg(dev, &dev->active_params);
 925}
 926
 927static void init_params_sja1000(struct ems_cpc_msg *msg)
 928{
 929	struct cpc_sja1000_params *sja1000 =
 930		&msg->msg.can_params.cc_params.sja1000;
 931
 932	msg->type = CPC_CMD_TYPE_CAN_PARAMS;
 933	msg->length = sizeof(struct cpc_can_params);
 934	msg->msgid = 0;
 935
 936	msg->msg.can_params.cc_type = CPC_CC_TYPE_SJA1000;
 937
 938	/* Acceptance filter open */
 939	sja1000->acc_code0 = 0x00;
 940	sja1000->acc_code1 = 0x00;
 941	sja1000->acc_code2 = 0x00;
 942	sja1000->acc_code3 = 0x00;
 943
 944	/* Acceptance filter open */
 945	sja1000->acc_mask0 = 0xFF;
 946	sja1000->acc_mask1 = 0xFF;
 947	sja1000->acc_mask2 = 0xFF;
 948	sja1000->acc_mask3 = 0xFF;
 949
 950	sja1000->btr0 = 0;
 951	sja1000->btr1 = 0;
 952
 953	sja1000->outp_contr = SJA1000_DEFAULT_OUTPUT_CONTROL;
 954	sja1000->mode = SJA1000_MOD_RM;
 955}
 956
 957/*
 958 * probe function for new CPC-USB devices
 959 */
 960static int ems_usb_probe(struct usb_interface *intf,
 961			 const struct usb_device_id *id)
 962{
 963	struct net_device *netdev;
 964	struct ems_usb *dev;
 965	int i, err = -ENOMEM;
 966
 967	netdev = alloc_candev(sizeof(struct ems_usb), MAX_TX_URBS);
 968	if (!netdev) {
 969		dev_err(&intf->dev, "ems_usb: Couldn't alloc candev\n");
 970		return -ENOMEM;
 971	}
 972
 973	dev = netdev_priv(netdev);
 974
 975	dev->udev = interface_to_usbdev(intf);
 976	dev->netdev = netdev;
 977
 978	dev->can.state = CAN_STATE_STOPPED;
 979	dev->can.clock.freq = EMS_USB_ARM7_CLOCK;
 980	dev->can.bittiming_const = &ems_usb_bittiming_const;
 981	dev->can.do_set_bittiming = ems_usb_set_bittiming;
 982	dev->can.do_set_mode = ems_usb_set_mode;
 983	dev->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
 984
 985	netdev->netdev_ops = &ems_usb_netdev_ops;
 986
 987	netdev->flags |= IFF_ECHO; /* we support local echo */
 988
 989	init_usb_anchor(&dev->rx_submitted);
 990
 991	init_usb_anchor(&dev->tx_submitted);
 992	atomic_set(&dev->active_tx_urbs, 0);
 993
 994	for (i = 0; i < MAX_TX_URBS; i++)
 995		dev->tx_contexts[i].echo_index = MAX_TX_URBS;
 996
 997	dev->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
 998	if (!dev->intr_urb)
 999		goto cleanup_candev;
1000
1001	dev->intr_in_buffer = kzalloc(INTR_IN_BUFFER_SIZE, GFP_KERNEL);
1002	if (!dev->intr_in_buffer)
1003		goto cleanup_intr_urb;
1004
1005	dev->tx_msg_buffer = kzalloc(CPC_HEADER_SIZE +
1006				     sizeof(struct ems_cpc_msg), GFP_KERNEL);
1007	if (!dev->tx_msg_buffer)
1008		goto cleanup_intr_in_buffer;
1009
1010	usb_set_intfdata(intf, dev);
1011
1012	SET_NETDEV_DEV(netdev, &intf->dev);
1013
1014	init_params_sja1000(&dev->active_params);
1015
1016	err = ems_usb_command_msg(dev, &dev->active_params);
1017	if (err) {
1018		netdev_err(netdev, "couldn't initialize controller: %d\n", err);
1019		goto cleanup_tx_msg_buffer;
1020	}
1021
1022	err = register_candev(netdev);
1023	if (err) {
1024		netdev_err(netdev, "couldn't register CAN device: %d\n", err);
1025		goto cleanup_tx_msg_buffer;
1026	}
1027
1028	return 0;
1029
1030cleanup_tx_msg_buffer:
1031	kfree(dev->tx_msg_buffer);
1032
1033cleanup_intr_in_buffer:
1034	kfree(dev->intr_in_buffer);
1035
1036cleanup_intr_urb:
1037	usb_free_urb(dev->intr_urb);
1038
1039cleanup_candev:
1040	free_candev(netdev);
1041
1042	return err;
1043}
1044
1045/*
1046 * called by the usb core when the device is removed from the system
1047 */
1048static void ems_usb_disconnect(struct usb_interface *intf)
1049{
1050	struct ems_usb *dev = usb_get_intfdata(intf);
1051
1052	usb_set_intfdata(intf, NULL);
1053
1054	if (dev) {
1055		unregister_netdev(dev->netdev);
1056		free_candev(dev->netdev);
1057
1058		unlink_all_urbs(dev);
1059
1060		usb_free_urb(dev->intr_urb);
1061
1062		kfree(dev->intr_in_buffer);
1063		kfree(dev->tx_msg_buffer);
1064	}
1065}
1066
1067/* usb specific object needed to register this driver with the usb subsystem */
1068static struct usb_driver ems_usb_driver = {
1069	.name = "ems_usb",
1070	.probe = ems_usb_probe,
1071	.disconnect = ems_usb_disconnect,
1072	.id_table = ems_usb_table,
1073};
1074
1075module_usb_driver(ems_usb_driver);