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