| 1 |
// SPDX-License-Identifier: GPL-2.0 |
| 2 |
/* Parts of this driver are based on the following: |
| 3 |
* - Kvaser linux leaf driver (version 4.78) |
| 4 |
* - CAN driver for esd CAN-USB/2 |
| 5 |
* - Kvaser linux usbcanII driver (version 5.3) |
| 6 |
* - Kvaser linux mhydra driver (version 5.24) |
| 7 |
* |
| 8 |
* Copyright (C) 2002-2018 KVASER AB, Sweden. All rights reserved. |
| 9 |
* Copyright (C) 2010 Matthias Fuchs <[email protected]>, esd gmbh |
| 10 |
* Copyright (C) 2012 Olivier Sobrie <[email protected]> |
| 11 |
* Copyright (C) 2015 Valeo S.A. |
| 12 |
*/ |
| 13 |
|
| 14 |
#include <linux/completion.h> |
| 15 |
#include <linux/device.h> |
| 16 |
#include <linux/ethtool.h> |
| 17 |
#include <linux/gfp.h> |
| 18 |
#include <linux/if.h> |
| 19 |
#include <linux/kernel.h> |
| 20 |
#include <linux/module.h> |
| 21 |
#include <linux/netdevice.h> |
| 22 |
#include <linux/spinlock.h> |
| 23 |
#include <linux/types.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 |
#include <linux/can/netlink.h> |
| 30 |
|
| 31 |
#include "kvaser_usb.h" |
| 32 |
|
| 33 |
/* Kvaser USB vendor id. */ |
| 34 |
#define KVASER_VENDOR_ID 0x0bfd |
| 35 |
|
| 36 |
/* Kvaser Leaf USB devices product ids */ |
| 37 |
#define USB_LEAF_DEVEL_PRODUCT_ID 0x000a |
| 38 |
#define USB_LEAF_LITE_PRODUCT_ID 0x000b |
| 39 |
#define USB_LEAF_PRO_PRODUCT_ID 0x000c |
| 40 |
#define USB_LEAF_SPRO_PRODUCT_ID 0x000e |
| 41 |
#define USB_LEAF_PRO_LS_PRODUCT_ID 0x000f |
| 42 |
#define USB_LEAF_PRO_SWC_PRODUCT_ID 0x0010 |
| 43 |
#define USB_LEAF_PRO_LIN_PRODUCT_ID 0x0011 |
| 44 |
#define USB_LEAF_SPRO_LS_PRODUCT_ID 0x0012 |
| 45 |
#define USB_LEAF_SPRO_SWC_PRODUCT_ID 0x0013 |
| 46 |
#define USB_MEMO2_DEVEL_PRODUCT_ID 0x0016 |
| 47 |
#define USB_MEMO2_HSHS_PRODUCT_ID 0x0017 |
| 48 |
#define USB_UPRO_HSHS_PRODUCT_ID 0x0018 |
| 49 |
#define USB_LEAF_LITE_GI_PRODUCT_ID 0x0019 |
| 50 |
#define USB_LEAF_PRO_OBDII_PRODUCT_ID 0x001a |
| 51 |
#define USB_MEMO2_HSLS_PRODUCT_ID 0x001b |
| 52 |
#define USB_LEAF_LITE_CH_PRODUCT_ID 0x001c |
| 53 |
#define USB_BLACKBIRD_SPRO_PRODUCT_ID 0x001d |
| 54 |
#define USB_OEM_MERCURY_PRODUCT_ID 0x0022 |
| 55 |
#define USB_OEM_LEAF_PRODUCT_ID 0x0023 |
| 56 |
#define USB_CAN_R_PRODUCT_ID 0x0027 |
| 57 |
#define USB_LEAF_LITE_V2_PRODUCT_ID 0x0120 |
| 58 |
#define USB_MINI_PCIE_HS_PRODUCT_ID 0x0121 |
| 59 |
#define USB_LEAF_LIGHT_HS_V2_OEM_PRODUCT_ID 0x0122 |
| 60 |
#define USB_USBCAN_LIGHT_2HS_PRODUCT_ID 0x0123 |
| 61 |
#define USB_MINI_PCIE_2HS_PRODUCT_ID 0x0124 |
| 62 |
#define USB_USBCAN_R_V2_PRODUCT_ID 0x0126 |
| 63 |
#define USB_LEAF_LIGHT_R_V2_PRODUCT_ID 0x0127 |
| 64 |
#define USB_LEAF_LIGHT_HS_V2_OEM2_PRODUCT_ID 0x0128 |
| 65 |
|
| 66 |
/* Kvaser USBCan-II devices product ids */ |
| 67 |
#define USB_USBCAN_REVB_PRODUCT_ID 0x0002 |
| 68 |
#define USB_VCI2_PRODUCT_ID 0x0003 |
| 69 |
#define USB_USBCAN2_PRODUCT_ID 0x0004 |
| 70 |
#define USB_MEMORATOR_PRODUCT_ID 0x0005 |
| 71 |
|
| 72 |
/* Kvaser Minihydra USB devices product ids */ |
| 73 |
#define USB_BLACKBIRD_V2_PRODUCT_ID 0x0102 |
| 74 |
#define USB_MEMO_PRO_5HS_PRODUCT_ID 0x0104 |
| 75 |
#define USB_USBCAN_PRO_5HS_PRODUCT_ID 0x0105 |
| 76 |
#define USB_USBCAN_LIGHT_4HS_PRODUCT_ID 0x0106 |
| 77 |
#define USB_LEAF_PRO_HS_V2_PRODUCT_ID 0x0107 |
| 78 |
#define USB_USBCAN_PRO_2HS_V2_PRODUCT_ID 0x0108 |
| 79 |
#define USB_MEMO_2HS_PRODUCT_ID 0x0109 |
| 80 |
#define USB_MEMO_PRO_2HS_V2_PRODUCT_ID 0x010a |
| 81 |
#define USB_HYBRID_2CANLIN_PRODUCT_ID 0x010b |
| 82 |
#define USB_ATI_USBCAN_PRO_2HS_V2_PRODUCT_ID 0x010c |
| 83 |
#define USB_ATI_MEMO_PRO_2HS_V2_PRODUCT_ID 0x010d |
| 84 |
#define USB_HYBRID_PRO_2CANLIN_PRODUCT_ID 0x010e |
| 85 |
#define USB_U100_PRODUCT_ID 0x0111 |
| 86 |
#define USB_U100P_PRODUCT_ID 0x0112 |
| 87 |
#define USB_U100S_PRODUCT_ID 0x0113 |
| 88 |
#define USB_USBCAN_PRO_4HS_PRODUCT_ID 0x0114 |
| 89 |
#define USB_HYBRID_CANLIN_PRODUCT_ID 0x0115 |
| 90 |
#define USB_HYBRID_PRO_CANLIN_PRODUCT_ID 0x0116 |
| 91 |
#define USB_LEAF_V3_PRODUCT_ID 0x0117 |
| 92 |
#define USB_VINING_800_PRODUCT_ID 0x0119 |
| 93 |
#define USB_USBCAN_PRO_5XCAN_PRODUCT_ID 0x011A |
| 94 |
#define USB_MINI_PCIE_1XCAN_PRODUCT_ID 0x011B |
| 95 |
|
| 96 |
static const struct kvaser_usb_driver_info kvaser_usb_driver_info_hydra = { |
| 97 |
.quirks = 0, |
| 98 |
.ops = &kvaser_usb_hydra_dev_ops, |
| 99 |
}; |
| 100 |
|
| 101 |
static const struct kvaser_usb_driver_info kvaser_usb_driver_info_usbcan = { |
| 102 |
.quirks = KVASER_USB_QUIRK_HAS_TXRX_ERRORS | |
| 103 |
KVASER_USB_QUIRK_HAS_SILENT_MODE, |
| 104 |
.family = KVASER_USBCAN, |
| 105 |
.ops = &kvaser_usb_leaf_dev_ops, |
| 106 |
}; |
| 107 |
|
| 108 |
static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leaf = { |
| 109 |
.quirks = KVASER_USB_QUIRK_IGNORE_CLK_FREQ, |
| 110 |
.family = KVASER_LEAF, |
| 111 |
.ops = &kvaser_usb_leaf_dev_ops, |
| 112 |
}; |
| 113 |
|
| 114 |
static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leaf_err = { |
| 115 |
.quirks = KVASER_USB_QUIRK_HAS_TXRX_ERRORS | |
| 116 |
KVASER_USB_QUIRK_IGNORE_CLK_FREQ, |
| 117 |
.family = KVASER_LEAF, |
| 118 |
.ops = &kvaser_usb_leaf_dev_ops, |
| 119 |
}; |
| 120 |
|
| 121 |
static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leaf_err_listen = { |
| 122 |
.quirks = KVASER_USB_QUIRK_HAS_TXRX_ERRORS | |
| 123 |
KVASER_USB_QUIRK_HAS_SILENT_MODE | |
| 124 |
KVASER_USB_QUIRK_IGNORE_CLK_FREQ, |
| 125 |
.family = KVASER_LEAF, |
| 126 |
.ops = &kvaser_usb_leaf_dev_ops, |
| 127 |
}; |
| 128 |
|
| 129 |
static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leafimx = { |
| 130 |
.quirks = 0, |
| 131 |
.family = KVASER_LEAF, |
| 132 |
.ops = &kvaser_usb_leaf_dev_ops, |
| 133 |
}; |
| 134 |
|
| 135 |
static const struct usb_device_id kvaser_usb_table[] = { |
| 136 |
/* Leaf M32C USB product IDs */ |
| 137 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_DEVEL_PRODUCT_ID), |
| 138 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf }, |
| 139 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_PRODUCT_ID), |
| 140 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf }, |
| 141 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_PRODUCT_ID), |
| 142 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, |
| 143 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_PRODUCT_ID), |
| 144 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, |
| 145 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LS_PRODUCT_ID), |
| 146 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, |
| 147 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_SWC_PRODUCT_ID), |
| 148 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, |
| 149 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LIN_PRODUCT_ID), |
| 150 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, |
| 151 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_LS_PRODUCT_ID), |
| 152 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, |
| 153 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_SWC_PRODUCT_ID), |
| 154 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, |
| 155 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_DEVEL_PRODUCT_ID), |
| 156 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, |
| 157 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSHS_PRODUCT_ID), |
| 158 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, |
| 159 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_UPRO_HSHS_PRODUCT_ID), |
| 160 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, |
| 161 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_GI_PRODUCT_ID), |
| 162 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf }, |
| 163 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_OBDII_PRODUCT_ID), |
| 164 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, |
| 165 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSLS_PRODUCT_ID), |
| 166 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, |
| 167 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_CH_PRODUCT_ID), |
| 168 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, |
| 169 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_SPRO_PRODUCT_ID), |
| 170 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, |
| 171 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_MERCURY_PRODUCT_ID), |
| 172 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, |
| 173 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_LEAF_PRODUCT_ID), |
| 174 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, |
| 175 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_CAN_R_PRODUCT_ID), |
| 176 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, |
| 177 |
|
| 178 |
/* Leaf i.MX28 USB product IDs */ |
| 179 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_V2_PRODUCT_ID), |
| 180 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, |
| 181 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_HS_PRODUCT_ID), |
| 182 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, |
| 183 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_HS_V2_OEM_PRODUCT_ID), |
| 184 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, |
| 185 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_LIGHT_2HS_PRODUCT_ID), |
| 186 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, |
| 187 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_2HS_PRODUCT_ID), |
| 188 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, |
| 189 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_R_V2_PRODUCT_ID), |
| 190 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, |
| 191 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_R_V2_PRODUCT_ID), |
| 192 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, |
| 193 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_HS_V2_OEM2_PRODUCT_ID), |
| 194 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, |
| 195 |
|
| 196 |
/* USBCANII USB product IDs */ |
| 197 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN2_PRODUCT_ID), |
| 198 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_usbcan }, |
| 199 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_REVB_PRODUCT_ID), |
| 200 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_usbcan }, |
| 201 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_MEMORATOR_PRODUCT_ID), |
| 202 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_usbcan }, |
| 203 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_VCI2_PRODUCT_ID), |
| 204 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_usbcan }, |
| 205 |
|
| 206 |
/* Minihydra USB product IDs */ |
| 207 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_V2_PRODUCT_ID), |
| 208 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 209 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_PRO_5HS_PRODUCT_ID), |
| 210 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 211 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_5HS_PRODUCT_ID), |
| 212 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 213 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_LIGHT_4HS_PRODUCT_ID), |
| 214 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 215 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_HS_V2_PRODUCT_ID), |
| 216 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 217 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_2HS_V2_PRODUCT_ID), |
| 218 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 219 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_2HS_PRODUCT_ID), |
| 220 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 221 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_PRO_2HS_V2_PRODUCT_ID), |
| 222 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 223 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_2CANLIN_PRODUCT_ID), |
| 224 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 225 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_ATI_USBCAN_PRO_2HS_V2_PRODUCT_ID), |
| 226 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 227 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_ATI_MEMO_PRO_2HS_V2_PRODUCT_ID), |
| 228 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 229 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_PRO_2CANLIN_PRODUCT_ID), |
| 230 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 231 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_U100_PRODUCT_ID), |
| 232 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 233 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_U100P_PRODUCT_ID), |
| 234 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 235 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_U100S_PRODUCT_ID), |
| 236 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 237 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_4HS_PRODUCT_ID), |
| 238 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 239 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_CANLIN_PRODUCT_ID), |
| 240 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 241 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_PRO_CANLIN_PRODUCT_ID), |
| 242 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 243 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_V3_PRODUCT_ID), |
| 244 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 245 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_VINING_800_PRODUCT_ID), |
| 246 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 247 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_5XCAN_PRODUCT_ID), |
| 248 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 249 |
{ USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_1XCAN_PRODUCT_ID), |
| 250 |
.driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, |
| 251 |
{ } |
| 252 |
}; |
| 253 |
MODULE_DEVICE_TABLE(usb, kvaser_usb_table); |
| 254 |
|
| 255 |
int kvaser_usb_send_cmd(const struct kvaser_usb *dev, void *cmd, int len) |
| 256 |
{ |
| 257 |
return usb_bulk_msg(dev->udev, |
| 258 |
usb_sndbulkpipe(dev->udev, |
| 259 |
dev->bulk_out->bEndpointAddress), |
| 260 |
cmd, len, NULL, KVASER_USB_TIMEOUT); |
| 261 |
} |
| 262 |
|
| 263 |
int kvaser_usb_recv_cmd(const struct kvaser_usb *dev, void *cmd, int len, |
| 264 |
int *actual_len) |
| 265 |
{ |
| 266 |
return usb_bulk_msg(dev->udev, |
| 267 |
usb_rcvbulkpipe(dev->udev, |
| 268 |
dev->bulk_in->bEndpointAddress), |
| 269 |
cmd, len, actual_len, KVASER_USB_TIMEOUT); |
| 270 |
} |
| 271 |
|
| 272 |
static void kvaser_usb_send_cmd_callback(struct urb *urb) |
| 273 |
{ |
| 274 |
struct net_device *netdev = urb->context; |
| 275 |
|
| 276 |
kfree(urb->transfer_buffer); |
| 277 |
|
| 278 |
if (urb->status) |
| 279 |
netdev_warn(netdev, "urb status received: %d\n", urb->status); |
| 280 |
} |
| 281 |
|
| 282 |
int kvaser_usb_send_cmd_async(struct kvaser_usb_net_priv *priv, void *cmd, |
| 283 |
int len) |
| 284 |
{ |
| 285 |
struct kvaser_usb *dev = priv->dev; |
| 286 |
struct net_device *netdev = priv->netdev; |
| 287 |
struct urb *urb; |
| 288 |
int err; |
| 289 |
|
| 290 |
urb = usb_alloc_urb(0, GFP_ATOMIC); |
| 291 |
if (!urb) |
| 292 |
return -ENOMEM; |
| 293 |
|
| 294 |
usb_fill_bulk_urb(urb, dev->udev, |
| 295 |
usb_sndbulkpipe(dev->udev, |
| 296 |
dev->bulk_out->bEndpointAddress), |
| 297 |
cmd, len, kvaser_usb_send_cmd_callback, netdev); |
| 298 |
usb_anchor_urb(urb, &priv->tx_submitted); |
| 299 |
|
| 300 |
err = usb_submit_urb(urb, GFP_ATOMIC); |
| 301 |
if (err) { |
| 302 |
netdev_err(netdev, "Error transmitting URB\n"); |
| 303 |
usb_unanchor_urb(urb); |
| 304 |
} |
| 305 |
usb_free_urb(urb); |
| 306 |
|
| 307 |
return err; |
| 308 |
} |
| 309 |
|
| 310 |
int kvaser_usb_can_rx_over_error(struct net_device *netdev) |
| 311 |
{ |
| 312 |
struct net_device_stats *stats = &netdev->stats; |
| 313 |
struct can_frame *cf; |
| 314 |
struct sk_buff *skb; |
| 315 |
|
| 316 |
stats->rx_over_errors++; |
| 317 |
stats->rx_errors++; |
| 318 |
|
| 319 |
skb = alloc_can_err_skb(netdev, &cf); |
| 320 |
if (!skb) { |
| 321 |
stats->rx_dropped++; |
| 322 |
netdev_warn(netdev, "No memory left for err_skb\n"); |
| 323 |
return -ENOMEM; |
| 324 |
} |
| 325 |
|
| 326 |
cf->can_id |= CAN_ERR_CRTL; |
| 327 |
cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; |
| 328 |
|
| 329 |
netif_rx(skb); |
| 330 |
|
| 331 |
return 0; |
| 332 |
} |
| 333 |
|
| 334 |
static void kvaser_usb_read_bulk_callback(struct urb *urb) |
| 335 |
{ |
| 336 |
struct kvaser_usb *dev = urb->context; |
| 337 |
const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; |
| 338 |
int err; |
| 339 |
unsigned int i; |
| 340 |
|
| 341 |
switch (urb->status) { |
| 342 |
case 0: |
| 343 |
break; |
| 344 |
case -ENOENT: |
| 345 |
case -EPIPE: |
| 346 |
case -EPROTO: |
| 347 |
case -ESHUTDOWN: |
| 348 |
return; |
| 349 |
default: |
| 350 |
dev_info(&dev->intf->dev, "Rx URB aborted (%d)\n", urb->status); |
| 351 |
goto resubmit_urb; |
| 352 |
} |
| 353 |
|
| 354 |
ops->dev_read_bulk_callback(dev, urb->transfer_buffer, |
| 355 |
urb->actual_length); |
| 356 |
|
| 357 |
resubmit_urb: |
| 358 |
usb_fill_bulk_urb(urb, dev->udev, |
| 359 |
usb_rcvbulkpipe(dev->udev, |
| 360 |
dev->bulk_in->bEndpointAddress), |
| 361 |
urb->transfer_buffer, KVASER_USB_RX_BUFFER_SIZE, |
| 362 |
kvaser_usb_read_bulk_callback, dev); |
| 363 |
|
| 364 |
usb_anchor_urb(urb, &dev->rx_submitted); |
| 365 |
|
| 366 |
err = usb_submit_urb(urb, GFP_ATOMIC); |
| 367 |
if (!err) |
| 368 |
return; |
| 369 |
|
| 370 |
usb_unanchor_urb(urb); |
| 371 |
|
| 372 |
if (err == -ENODEV) { |
| 373 |
for (i = 0; i < dev->nchannels; i++) { |
| 374 |
struct kvaser_usb_net_priv *priv; |
| 375 |
|
| 376 |
priv = dev->nets[i]; |
| 377 |
if (!priv) |
| 378 |
continue; |
| 379 |
|
| 380 |
netif_device_detach(priv->netdev); |
| 381 |
} |
| 382 |
} else { |
| 383 |
dev_err(&dev->intf->dev, |
| 384 |
"Failed resubmitting read bulk urb: %d\n", err); |
| 385 |
} |
| 386 |
} |
| 387 |
|
| 388 |
static int kvaser_usb_setup_rx_urbs(struct kvaser_usb *dev) |
| 389 |
{ |
| 390 |
int i, err = 0; |
| 391 |
|
| 392 |
if (dev->rxinitdone) |
| 393 |
return 0; |
| 394 |
|
| 395 |
for (i = 0; i < KVASER_USB_MAX_RX_URBS; i++) { |
| 396 |
struct urb *urb = NULL; |
| 397 |
u8 *buf = NULL; |
| 398 |
dma_addr_t buf_dma; |
| 399 |
|
| 400 |
urb = usb_alloc_urb(0, GFP_KERNEL); |
| 401 |
if (!urb) { |
| 402 |
err = -ENOMEM; |
| 403 |
break; |
| 404 |
} |
| 405 |
|
| 406 |
buf = usb_alloc_coherent(dev->udev, KVASER_USB_RX_BUFFER_SIZE, |
| 407 |
GFP_KERNEL, &buf_dma); |
| 408 |
if (!buf) { |
| 409 |
dev_warn(&dev->intf->dev, |
| 410 |
"No memory left for USB buffer\n"); |
| 411 |
usb_free_urb(urb); |
| 412 |
err = -ENOMEM; |
| 413 |
break; |
| 414 |
} |
| 415 |
|
| 416 |
usb_fill_bulk_urb(urb, dev->udev, |
| 417 |
usb_rcvbulkpipe |
| 418 |
(dev->udev, |
| 419 |
dev->bulk_in->bEndpointAddress), |
| 420 |
buf, KVASER_USB_RX_BUFFER_SIZE, |
| 421 |
kvaser_usb_read_bulk_callback, dev); |
| 422 |
urb->transfer_dma = buf_dma; |
| 423 |
urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
| 424 |
usb_anchor_urb(urb, &dev->rx_submitted); |
| 425 |
|
| 426 |
err = usb_submit_urb(urb, GFP_KERNEL); |
| 427 |
if (err) { |
| 428 |
usb_unanchor_urb(urb); |
| 429 |
usb_free_coherent(dev->udev, |
| 430 |
KVASER_USB_RX_BUFFER_SIZE, buf, |
| 431 |
buf_dma); |
| 432 |
usb_free_urb(urb); |
| 433 |
break; |
| 434 |
} |
| 435 |
|
| 436 |
dev->rxbuf[i] = buf; |
| 437 |
dev->rxbuf_dma[i] = buf_dma; |
| 438 |
|
| 439 |
usb_free_urb(urb); |
| 440 |
} |
| 441 |
|
| 442 |
if (i == 0) { |
| 443 |
dev_warn(&dev->intf->dev, "Cannot setup read URBs, error %d\n", |
| 444 |
err); |
| 445 |
return err; |
| 446 |
} else if (i < KVASER_USB_MAX_RX_URBS) { |
| 447 |
dev_warn(&dev->intf->dev, "RX performances may be slow\n"); |
| 448 |
} |
| 449 |
|
| 450 |
dev->rxinitdone = true; |
| 451 |
|
| 452 |
return 0; |
| 453 |
} |
| 454 |
|
| 455 |
static int kvaser_usb_open(struct net_device *netdev) |
| 456 |
{ |
| 457 |
struct kvaser_usb_net_priv *priv = netdev_priv(netdev); |
| 458 |
struct kvaser_usb *dev = priv->dev; |
| 459 |
const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; |
| 460 |
int err; |
| 461 |
|
| 462 |
err = open_candev(netdev); |
| 463 |
if (err) |
| 464 |
return err; |
| 465 |
|
| 466 |
err = ops->dev_set_opt_mode(priv); |
| 467 |
if (err) |
| 468 |
goto error; |
| 469 |
|
| 470 |
err = ops->dev_start_chip(priv); |
| 471 |
if (err) { |
| 472 |
netdev_warn(netdev, "Cannot start device, error %d\n", err); |
| 473 |
goto error; |
| 474 |
} |
| 475 |
|
| 476 |
priv->can.state = CAN_STATE_ERROR_ACTIVE; |
| 477 |
|
| 478 |
return 0; |
| 479 |
|
| 480 |
error: |
| 481 |
close_candev(netdev); |
| 482 |
return err; |
| 483 |
} |
| 484 |
|
| 485 |
static void kvaser_usb_reset_tx_urb_contexts(struct kvaser_usb_net_priv *priv) |
| 486 |
{ |
| 487 |
int i, max_tx_urbs; |
| 488 |
|
| 489 |
max_tx_urbs = priv->dev->max_tx_urbs; |
| 490 |
|
| 491 |
priv->active_tx_contexts = 0; |
| 492 |
for (i = 0; i < max_tx_urbs; i++) |
| 493 |
priv->tx_contexts[i].echo_index = max_tx_urbs; |
| 494 |
} |
| 495 |
|
| 496 |
/* This method might sleep. Do not call it in the atomic context |
| 497 |
* of URB completions. |
| 498 |
*/ |
| 499 |
void kvaser_usb_unlink_tx_urbs(struct kvaser_usb_net_priv *priv) |
| 500 |
{ |
| 501 |
usb_kill_anchored_urbs(&priv->tx_submitted); |
| 502 |
kvaser_usb_reset_tx_urb_contexts(priv); |
| 503 |
} |
| 504 |
|
| 505 |
static void kvaser_usb_unlink_all_urbs(struct kvaser_usb *dev) |
| 506 |
{ |
| 507 |
int i; |
| 508 |
|
| 509 |
usb_kill_anchored_urbs(&dev->rx_submitted); |
| 510 |
|
| 511 |
for (i = 0; i < KVASER_USB_MAX_RX_URBS; i++) |
| 512 |
usb_free_coherent(dev->udev, KVASER_USB_RX_BUFFER_SIZE, |
| 513 |
dev->rxbuf[i], dev->rxbuf_dma[i]); |
| 514 |
|
| 515 |
for (i = 0; i < dev->nchannels; i++) { |
| 516 |
struct kvaser_usb_net_priv *priv = dev->nets[i]; |
| 517 |
|
| 518 |
if (priv) |
| 519 |
kvaser_usb_unlink_tx_urbs(priv); |
| 520 |
} |
| 521 |
} |
| 522 |
|
| 523 |
static int kvaser_usb_close(struct net_device *netdev) |
| 524 |
{ |
| 525 |
struct kvaser_usb_net_priv *priv = netdev_priv(netdev); |
| 526 |
struct kvaser_usb *dev = priv->dev; |
| 527 |
const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; |
| 528 |
int err; |
| 529 |
|
| 530 |
netif_stop_queue(netdev); |
| 531 |
|
| 532 |
err = ops->dev_flush_queue(priv); |
| 533 |
if (err) |
| 534 |
netdev_warn(netdev, "Cannot flush queue, error %d\n", err); |
| 535 |
|
| 536 |
if (ops->dev_reset_chip) { |
| 537 |
err = ops->dev_reset_chip(dev, priv->channel); |
| 538 |
if (err) |
| 539 |
netdev_warn(netdev, "Cannot reset card, error %d\n", |
| 540 |
err); |
| 541 |
} |
| 542 |
|
| 543 |
err = ops->dev_stop_chip(priv); |
| 544 |
if (err) |
| 545 |
netdev_warn(netdev, "Cannot stop device, error %d\n", err); |
| 546 |
|
| 547 |
/* reset tx contexts */ |
| 548 |
kvaser_usb_unlink_tx_urbs(priv); |
| 549 |
|
| 550 |
priv->can.state = CAN_STATE_STOPPED; |
| 551 |
close_candev(priv->netdev); |
| 552 |
|
| 553 |
return 0; |
| 554 |
} |
| 555 |
|
| 556 |
static int kvaser_usb_set_bittiming(struct net_device *netdev) |
| 557 |
{ |
| 558 |
struct kvaser_usb_net_priv *priv = netdev_priv(netdev); |
| 559 |
struct kvaser_usb *dev = priv->dev; |
| 560 |
const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; |
| 561 |
struct can_bittiming *bt = &priv->can.bittiming; |
| 562 |
struct kvaser_usb_busparams busparams; |
| 563 |
int tseg1 = bt->prop_seg + bt->phase_seg1; |
| 564 |
int tseg2 = bt->phase_seg2; |
| 565 |
int sjw = bt->sjw; |
| 566 |
int err; |
| 567 |
|
| 568 |
busparams.bitrate = cpu_to_le32(bt->bitrate); |
| 569 |
busparams.sjw = (u8)sjw; |
| 570 |
busparams.tseg1 = (u8)tseg1; |
| 571 |
busparams.tseg2 = (u8)tseg2; |
| 572 |
if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) |
| 573 |
busparams.nsamples = 3; |
| 574 |
else |
| 575 |
busparams.nsamples = 1; |
| 576 |
|
| 577 |
err = ops->dev_set_bittiming(netdev, &busparams); |
| 578 |
if (err) |
| 579 |
return err; |
| 580 |
|
| 581 |
err = kvaser_usb_setup_rx_urbs(priv->dev); |
| 582 |
if (err) |
| 583 |
return err; |
| 584 |
|
| 585 |
err = ops->dev_get_busparams(priv); |
| 586 |
if (err) { |
| 587 |
/* Treat EOPNOTSUPP as success */ |
| 588 |
if (err == -EOPNOTSUPP) |
| 589 |
err = 0; |
| 590 |
return err; |
| 591 |
} |
| 592 |
|
| 593 |
if (memcmp(&busparams, &priv->busparams_nominal, |
| 594 |
sizeof(priv->busparams_nominal)) != 0) |
| 595 |
err = -EINVAL; |
| 596 |
|
| 597 |
return err; |
| 598 |
} |
| 599 |
|
| 600 |
static int kvaser_usb_set_data_bittiming(struct net_device *netdev) |
| 601 |
{ |
| 602 |
struct kvaser_usb_net_priv *priv = netdev_priv(netdev); |
| 603 |
struct kvaser_usb *dev = priv->dev; |
| 604 |
const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; |
| 605 |
struct can_bittiming *dbt = &priv->can.fd.data_bittiming; |
| 606 |
struct kvaser_usb_busparams busparams; |
| 607 |
int tseg1 = dbt->prop_seg + dbt->phase_seg1; |
| 608 |
int tseg2 = dbt->phase_seg2; |
| 609 |
int sjw = dbt->sjw; |
| 610 |
int err; |
| 611 |
|
| 612 |
if (!ops->dev_set_data_bittiming || |
| 613 |
!ops->dev_get_data_busparams) |
| 614 |
return -EOPNOTSUPP; |
| 615 |
|
| 616 |
busparams.bitrate = cpu_to_le32(dbt->bitrate); |
| 617 |
busparams.sjw = (u8)sjw; |
| 618 |
busparams.tseg1 = (u8)tseg1; |
| 619 |
busparams.tseg2 = (u8)tseg2; |
| 620 |
busparams.nsamples = 1; |
| 621 |
|
| 622 |
err = ops->dev_set_data_bittiming(netdev, &busparams); |
| 623 |
if (err) |
| 624 |
return err; |
| 625 |
|
| 626 |
err = kvaser_usb_setup_rx_urbs(priv->dev); |
| 627 |
if (err) |
| 628 |
return err; |
| 629 |
|
| 630 |
err = ops->dev_get_data_busparams(priv); |
| 631 |
if (err) |
| 632 |
return err; |
| 633 |
|
| 634 |
if (memcmp(&busparams, &priv->busparams_data, |
| 635 |
sizeof(priv->busparams_data)) != 0) |
| 636 |
err = -EINVAL; |
| 637 |
|
| 638 |
return err; |
| 639 |
} |
| 640 |
|
| 641 |
static void kvaser_usb_write_bulk_callback(struct urb *urb) |
| 642 |
{ |
| 643 |
struct kvaser_usb_tx_urb_context *context = urb->context; |
| 644 |
struct kvaser_usb_net_priv *priv; |
| 645 |
struct net_device *netdev; |
| 646 |
|
| 647 |
if (WARN_ON(!context)) |
| 648 |
return; |
| 649 |
|
| 650 |
priv = context->priv; |
| 651 |
netdev = priv->netdev; |
| 652 |
|
| 653 |
kfree(urb->transfer_buffer); |
| 654 |
|
| 655 |
if (!netif_device_present(netdev)) |
| 656 |
return; |
| 657 |
|
| 658 |
if (urb->status) |
| 659 |
netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status); |
| 660 |
} |
| 661 |
|
| 662 |
static netdev_tx_t kvaser_usb_start_xmit(struct sk_buff *skb, |
| 663 |
struct net_device *netdev) |
| 664 |
{ |
| 665 |
struct kvaser_usb_net_priv *priv = netdev_priv(netdev); |
| 666 |
struct kvaser_usb *dev = priv->dev; |
| 667 |
const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; |
| 668 |
struct net_device_stats *stats = &netdev->stats; |
| 669 |
struct kvaser_usb_tx_urb_context *context = NULL; |
| 670 |
struct urb *urb; |
| 671 |
void *buf; |
| 672 |
int cmd_len = 0; |
| 673 |
int err, ret = NETDEV_TX_OK; |
| 674 |
unsigned int i; |
| 675 |
unsigned long flags; |
| 676 |
|
| 677 |
if (can_dev_dropped_skb(netdev, skb)) |
| 678 |
return NETDEV_TX_OK; |
| 679 |
|
| 680 |
urb = usb_alloc_urb(0, GFP_ATOMIC); |
| 681 |
if (!urb) { |
| 682 |
stats->tx_dropped++; |
| 683 |
dev_kfree_skb(skb); |
| 684 |
return NETDEV_TX_OK; |
| 685 |
} |
| 686 |
|
| 687 |
spin_lock_irqsave(&priv->tx_contexts_lock, flags); |
| 688 |
for (i = 0; i < dev->max_tx_urbs; i++) { |
| 689 |
if (priv->tx_contexts[i].echo_index == dev->max_tx_urbs) { |
| 690 |
context = &priv->tx_contexts[i]; |
| 691 |
|
| 692 |
context->echo_index = i; |
| 693 |
++priv->active_tx_contexts; |
| 694 |
if (priv->active_tx_contexts >= (int)dev->max_tx_urbs) |
| 695 |
netif_stop_queue(netdev); |
| 696 |
|
| 697 |
break; |
| 698 |
} |
| 699 |
} |
| 700 |
spin_unlock_irqrestore(&priv->tx_contexts_lock, flags); |
| 701 |
|
| 702 |
/* This should never happen; it implies a flow control bug */ |
| 703 |
if (!context) { |
| 704 |
netdev_warn(netdev, "cannot find free context\n"); |
| 705 |
|
| 706 |
ret = NETDEV_TX_BUSY; |
| 707 |
goto freeurb; |
| 708 |
} |
| 709 |
|
| 710 |
buf = ops->dev_frame_to_cmd(priv, skb, &cmd_len, context->echo_index); |
| 711 |
if (!buf) { |
| 712 |
stats->tx_dropped++; |
| 713 |
dev_kfree_skb(skb); |
| 714 |
spin_lock_irqsave(&priv->tx_contexts_lock, flags); |
| 715 |
|
| 716 |
context->echo_index = dev->max_tx_urbs; |
| 717 |
--priv->active_tx_contexts; |
| 718 |
netif_wake_queue(netdev); |
| 719 |
|
| 720 |
spin_unlock_irqrestore(&priv->tx_contexts_lock, flags); |
| 721 |
goto freeurb; |
| 722 |
} |
| 723 |
|
| 724 |
context->priv = priv; |
| 725 |
|
| 726 |
can_put_echo_skb(skb, netdev, context->echo_index, 0); |
| 727 |
|
| 728 |
usb_fill_bulk_urb(urb, dev->udev, |
| 729 |
usb_sndbulkpipe(dev->udev, |
| 730 |
dev->bulk_out->bEndpointAddress), |
| 731 |
buf, cmd_len, kvaser_usb_write_bulk_callback, |
| 732 |
context); |
| 733 |
usb_anchor_urb(urb, &priv->tx_submitted); |
| 734 |
|
| 735 |
err = usb_submit_urb(urb, GFP_ATOMIC); |
| 736 |
if (unlikely(err)) { |
| 737 |
spin_lock_irqsave(&priv->tx_contexts_lock, flags); |
| 738 |
|
| 739 |
can_free_echo_skb(netdev, context->echo_index, NULL); |
| 740 |
context->echo_index = dev->max_tx_urbs; |
| 741 |
--priv->active_tx_contexts; |
| 742 |
netif_wake_queue(netdev); |
| 743 |
|
| 744 |
spin_unlock_irqrestore(&priv->tx_contexts_lock, flags); |
| 745 |
|
| 746 |
usb_unanchor_urb(urb); |
| 747 |
kfree(buf); |
| 748 |
|
| 749 |
stats->tx_dropped++; |
| 750 |
|
| 751 |
if (err == -ENODEV) |
| 752 |
netif_device_detach(netdev); |
| 753 |
else |
| 754 |
netdev_warn(netdev, "Failed tx_urb %d\n", err); |
| 755 |
|
| 756 |
goto freeurb; |
| 757 |
} |
| 758 |
|
| 759 |
ret = NETDEV_TX_OK; |
| 760 |
|
| 761 |
freeurb: |
| 762 |
usb_free_urb(urb); |
| 763 |
return ret; |
| 764 |
} |
| 765 |
|
| 766 |
static int kvaser_usb_set_phys_id(struct net_device *netdev, |
| 767 |
enum ethtool_phys_id_state state) |
| 768 |
{ |
| 769 |
struct kvaser_usb_net_priv *priv = netdev_priv(netdev); |
| 770 |
const struct kvaser_usb_dev_ops *ops = priv->dev->driver_info->ops; |
| 771 |
|
| 772 |
switch (state) { |
| 773 |
case ETHTOOL_ID_ACTIVE: |
| 774 |
return 3; /* 3 On/Off cycles per second */ |
| 775 |
|
| 776 |
case ETHTOOL_ID_ON: |
| 777 |
return ops->dev_set_led(priv, KVASER_USB_LED_ON, 1000); |
| 778 |
|
| 779 |
case ETHTOOL_ID_OFF: |
| 780 |
return ops->dev_set_led(priv, KVASER_USB_LED_OFF, 1000); |
| 781 |
|
| 782 |
case ETHTOOL_ID_INACTIVE: |
| 783 |
/* Turn LED off and restore standard function after 1ms */ |
| 784 |
return ops->dev_set_led(priv, KVASER_USB_LED_OFF, 1); |
| 785 |
|
| 786 |
default: |
| 787 |
return -EINVAL; |
| 788 |
} |
| 789 |
} |
| 790 |
|
| 791 |
static const struct net_device_ops kvaser_usb_netdev_ops = { |
| 792 |
.ndo_open = kvaser_usb_open, |
| 793 |
.ndo_stop = kvaser_usb_close, |
| 794 |
.ndo_start_xmit = kvaser_usb_start_xmit, |
| 795 |
.ndo_hwtstamp_get = can_hwtstamp_get, |
| 796 |
.ndo_hwtstamp_set = can_hwtstamp_set, |
| 797 |
}; |
| 798 |
|
| 799 |
static const struct ethtool_ops kvaser_usb_ethtool_ops = { |
| 800 |
.get_ts_info = can_ethtool_op_get_ts_info_hwts, |
| 801 |
.set_phys_id = kvaser_usb_set_phys_id, |
| 802 |
}; |
| 803 |
|
| 804 |
static void kvaser_usb_remove_interfaces(struct kvaser_usb *dev) |
| 805 |
{ |
| 806 |
const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; |
| 807 |
int i; |
| 808 |
struct kvaser_usb_net_priv *priv; |
| 809 |
|
| 810 |
for (i = 0; i < dev->nchannels; i++) { |
| 811 |
priv = dev->nets[i]; |
| 812 |
if (!priv) |
| 813 |
continue; |
| 814 |
|
| 815 |
unregister_candev(priv->netdev); |
| 816 |
} |
| 817 |
|
| 818 |
kvaser_usb_unlink_all_urbs(dev); |
| 819 |
|
| 820 |
for (i = 0; i < dev->nchannels; i++) { |
| 821 |
priv = dev->nets[i]; |
| 822 |
if (!priv) |
| 823 |
continue; |
| 824 |
|
| 825 |
if (ops->dev_remove_channel) |
| 826 |
ops->dev_remove_channel(priv); |
| 827 |
|
| 828 |
kvaser_usb_devlink_port_unregister(priv); |
| 829 |
free_candev(priv->netdev); |
| 830 |
} |
| 831 |
} |
| 832 |
|
| 833 |
static int kvaser_usb_init_one(struct kvaser_usb *dev, int channel) |
| 834 |
{ |
| 835 |
struct net_device *netdev; |
| 836 |
struct kvaser_usb_net_priv *priv; |
| 837 |
const struct kvaser_usb_driver_info *driver_info = dev->driver_info; |
| 838 |
const struct kvaser_usb_dev_ops *ops = driver_info->ops; |
| 839 |
int err; |
| 840 |
|
| 841 |
if (ops->dev_reset_chip) { |
| 842 |
err = ops->dev_reset_chip(dev, channel); |
| 843 |
if (err) |
| 844 |
return err; |
| 845 |
} |
| 846 |
|
| 847 |
netdev = alloc_candev(struct_size(priv, tx_contexts, dev->max_tx_urbs), |
| 848 |
dev->max_tx_urbs); |
| 849 |
if (!netdev) { |
| 850 |
dev_err(&dev->intf->dev, "Cannot alloc candev\n"); |
| 851 |
return -ENOMEM; |
| 852 |
} |
| 853 |
|
| 854 |
priv = netdev_priv(netdev); |
| 855 |
|
| 856 |
init_usb_anchor(&priv->tx_submitted); |
| 857 |
init_completion(&priv->start_comp); |
| 858 |
init_completion(&priv->stop_comp); |
| 859 |
init_completion(&priv->flush_comp); |
| 860 |
init_completion(&priv->get_busparams_comp); |
| 861 |
priv->can.ctrlmode_supported = CAN_CTRLMODE_CC_LEN8_DLC | |
| 862 |
CAN_CTRLMODE_BERR_REPORTING; |
| 863 |
|
| 864 |
priv->dev = dev; |
| 865 |
priv->netdev = netdev; |
| 866 |
priv->channel = channel; |
| 867 |
|
| 868 |
spin_lock_init(&priv->tx_contexts_lock); |
| 869 |
kvaser_usb_reset_tx_urb_contexts(priv); |
| 870 |
|
| 871 |
priv->can.state = CAN_STATE_STOPPED; |
| 872 |
priv->can.clock.freq = dev->cfg->clock.freq; |
| 873 |
priv->can.bittiming_const = dev->cfg->bittiming_const; |
| 874 |
priv->can.do_set_bittiming = kvaser_usb_set_bittiming; |
| 875 |
priv->can.do_set_mode = ops->dev_set_mode; |
| 876 |
if ((driver_info->quirks & KVASER_USB_QUIRK_HAS_TXRX_ERRORS) || |
| 877 |
(priv->dev->card_data.capabilities & KVASER_USB_CAP_BERR_CAP)) |
| 878 |
priv->can.do_get_berr_counter = ops->dev_get_berr_counter; |
| 879 |
if (driver_info->quirks & KVASER_USB_QUIRK_HAS_SILENT_MODE) |
| 880 |
priv->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY; |
| 881 |
|
| 882 |
priv->can.ctrlmode_supported |= dev->card_data.ctrlmode_supported; |
| 883 |
|
| 884 |
if (priv->can.ctrlmode_supported & CAN_CTRLMODE_FD) { |
| 885 |
priv->can.fd.data_bittiming_const = dev->cfg->data_bittiming_const; |
| 886 |
priv->can.fd.do_set_data_bittiming = kvaser_usb_set_data_bittiming; |
| 887 |
} |
| 888 |
|
| 889 |
netdev->flags |= IFF_ECHO; |
| 890 |
|
| 891 |
netdev->netdev_ops = &kvaser_usb_netdev_ops; |
| 892 |
netdev->ethtool_ops = &kvaser_usb_ethtool_ops; |
| 893 |
SET_NETDEV_DEV(netdev, &dev->intf->dev); |
| 894 |
netdev->dev_id = channel; |
| 895 |
netdev->dev_port = channel; |
| 896 |
|
| 897 |
dev->nets[channel] = priv; |
| 898 |
|
| 899 |
if (ops->dev_init_channel) { |
| 900 |
err = ops->dev_init_channel(priv); |
| 901 |
if (err) |
| 902 |
goto candev_free; |
| 903 |
} |
| 904 |
|
| 905 |
err = kvaser_usb_devlink_port_register(priv); |
| 906 |
if (err) { |
| 907 |
dev_err(&dev->intf->dev, "Failed to register devlink port\n"); |
| 908 |
goto candev_free; |
| 909 |
} |
| 910 |
|
| 911 |
err = register_candev(netdev); |
| 912 |
if (err) { |
| 913 |
dev_err(&dev->intf->dev, "Failed to register CAN device\n"); |
| 914 |
goto unregister_devlink_port; |
| 915 |
} |
| 916 |
|
| 917 |
netdev_dbg(netdev, "device registered\n"); |
| 918 |
|
| 919 |
return 0; |
| 920 |
|
| 921 |
unregister_devlink_port: |
| 922 |
kvaser_usb_devlink_port_unregister(priv); |
| 923 |
candev_free: |
| 924 |
free_candev(netdev); |
| 925 |
dev->nets[channel] = NULL; |
| 926 |
return err; |
| 927 |
} |
| 928 |
|
| 929 |
static int kvaser_usb_probe(struct usb_interface *intf, |
| 930 |
const struct usb_device_id *id) |
| 931 |
{ |
| 932 |
struct kvaser_usb *dev; |
| 933 |
struct devlink *devlink; |
| 934 |
int err; |
| 935 |
int i; |
| 936 |
const struct kvaser_usb_driver_info *driver_info; |
| 937 |
const struct kvaser_usb_dev_ops *ops; |
| 938 |
|
| 939 |
driver_info = (const struct kvaser_usb_driver_info *)id->driver_info; |
| 940 |
if (!driver_info) |
| 941 |
return -ENODEV; |
| 942 |
|
| 943 |
devlink = devlink_alloc(&kvaser_usb_devlink_ops, sizeof(*dev), &intf->dev); |
| 944 |
if (!devlink) |
| 945 |
return -ENOMEM; |
| 946 |
|
| 947 |
dev = devlink_priv(devlink); |
| 948 |
dev->intf = intf; |
| 949 |
dev->driver_info = driver_info; |
| 950 |
ops = driver_info->ops; |
| 951 |
|
| 952 |
err = ops->dev_setup_endpoints(dev); |
| 953 |
if (err) { |
| 954 |
dev_err_probe(&intf->dev, err, "Cannot get usb endpoint(s)"); |
| 955 |
goto free_devlink; |
| 956 |
} |
| 957 |
|
| 958 |
dev->udev = interface_to_usbdev(intf); |
| 959 |
|
| 960 |
init_usb_anchor(&dev->rx_submitted); |
| 961 |
|
| 962 |
usb_set_intfdata(intf, dev); |
| 963 |
|
| 964 |
dev->card_data.ctrlmode_supported = 0; |
| 965 |
dev->card_data.capabilities = 0; |
| 966 |
err = ops->dev_init_card(dev); |
| 967 |
if (err) { |
| 968 |
dev_err_probe(&intf->dev, err, |
| 969 |
"Failed to initialize card\n"); |
| 970 |
goto free_devlink; |
| 971 |
} |
| 972 |
|
| 973 |
err = ops->dev_get_software_info(dev); |
| 974 |
if (err) { |
| 975 |
dev_err_probe(&intf->dev, err, |
| 976 |
"Cannot get software info\n"); |
| 977 |
goto free_devlink; |
| 978 |
} |
| 979 |
|
| 980 |
if (ops->dev_get_software_details) { |
| 981 |
err = ops->dev_get_software_details(dev); |
| 982 |
if (err) { |
| 983 |
dev_err_probe(&intf->dev, err, |
| 984 |
"Cannot get software details\n"); |
| 985 |
goto free_devlink; |
| 986 |
} |
| 987 |
} |
| 988 |
|
| 989 |
if (WARN_ON(!dev->cfg)) { |
| 990 |
err = -ENODEV; |
| 991 |
goto free_devlink; |
| 992 |
} |
| 993 |
|
| 994 |
dev_dbg(&intf->dev, "Max outstanding tx = %d URBs\n", dev->max_tx_urbs); |
| 995 |
|
| 996 |
err = ops->dev_get_card_info(dev); |
| 997 |
if (err) { |
| 998 |
dev_err_probe(&intf->dev, err, |
| 999 |
"Cannot get card info\n"); |
| 1000 |
goto free_devlink; |
| 1001 |
} |
| 1002 |
|
| 1003 |
if (ops->dev_get_capabilities) { |
| 1004 |
err = ops->dev_get_capabilities(dev); |
| 1005 |
if (err) { |
| 1006 |
dev_err_probe(&intf->dev, err, |
| 1007 |
"Cannot get capabilities\n"); |
| 1008 |
goto remove_interfaces; |
| 1009 |
} |
| 1010 |
} |
| 1011 |
|
| 1012 |
for (i = 0; i < dev->nchannels; i++) { |
| 1013 |
err = kvaser_usb_init_one(dev, i); |
| 1014 |
if (err) |
| 1015 |
goto remove_interfaces; |
| 1016 |
} |
| 1017 |
devlink_register(devlink); |
| 1018 |
|
| 1019 |
return 0; |
| 1020 |
|
| 1021 |
remove_interfaces: |
| 1022 |
kvaser_usb_remove_interfaces(dev); |
| 1023 |
free_devlink: |
| 1024 |
devlink_free(devlink); |
| 1025 |
|
| 1026 |
return err; |
| 1027 |
} |
| 1028 |
|
| 1029 |
static void kvaser_usb_disconnect(struct usb_interface *intf) |
| 1030 |
{ |
| 1031 |
struct kvaser_usb *dev = usb_get_intfdata(intf); |
| 1032 |
|
| 1033 |
usb_set_intfdata(intf, NULL); |
| 1034 |
|
| 1035 |
if (!dev) |
| 1036 |
return; |
| 1037 |
|
| 1038 |
kvaser_usb_remove_interfaces(dev); |
| 1039 |
devlink_unregister(priv_to_devlink(dev)); |
| 1040 |
devlink_free(priv_to_devlink(dev)); |
| 1041 |
} |
| 1042 |
|
| 1043 |
static struct usb_driver kvaser_usb_driver = { |
| 1044 |
.name = KBUILD_MODNAME, |
| 1045 |
.probe = kvaser_usb_probe, |
| 1046 |
.disconnect = kvaser_usb_disconnect, |
| 1047 |
.id_table = kvaser_usb_table, |
| 1048 |
}; |
| 1049 |
|
| 1050 |
module_usb_driver(kvaser_usb_driver); |
| 1051 |
|
| 1052 |
MODULE_AUTHOR("Olivier Sobrie <[email protected]>"); |
| 1053 |
MODULE_AUTHOR("Kvaser AB <[email protected]>"); |
| 1054 |
MODULE_DESCRIPTION("CAN driver for Kvaser CAN/USB devices"); |
| 1055 |
MODULE_LICENSE("GPL v2"); |