tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'linux-can-fixes-for-5.19-20220704' of git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can

Marc Kleine-Budde says:

====================
can 2022-07-04

The 1st patch is by Oliver Hartkopp, targets the BCM CAN protocol and
converts a costly synchronize_rcu() to call_rcu() to fix a performance
regression.

Srinivas Neeli's patch for the xilinx_can driver drops the brp limit
down to 1, as only the pre-production silicon have an issue with a brp
of 1.

The next patch is by Duy Nguyen and fixes the data transmission on
R-Car V3U SoCs in the rcar_canfd driver.

Rhett Aultman's patch fixes a DMA memory leak in the gs_usb driver.

Liang He's patch removes an extra of_node_get() in the grcan driver.

The next 2 patches are by me, target the m_can driver and fix the
timestamp handling used for peripheral devices like the tcan4x5x.

Jimmy Assarsson contributes 3 patches for the kvaser_usb driver and
fixes CAN clock and bit timing related issues.

The remaining 5 patches target the mcp251xfd driver. Thomas Kopp
contributes 2 patches to improve the workaround for broken CRC when
reading the TBC register. 3 patches by me add a missing
hrtimer_cancel() during the ndo_stop() callback, and fix the reading
of the Device ID register.

* tag 'linux-can-fixes-for-5.19-20220704' of git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can:
can: mcp251xfd: mcp251xfd_register_get_dev_id(): fix endianness conversion
can: mcp251xfd: mcp251xfd_register_get_dev_id(): use correct length to read dev_id
can: mcp251xfd: mcp251xfd_stop(): add missing hrtimer_cancel()
can: mcp251xfd: mcp251xfd_regmap_crc_read(): update workaround broken CRC on TBC register
can: mcp251xfd: mcp251xfd_regmap_crc_read(): improve workaround handling for mcp2517fd
can: kvaser_usb: kvaser_usb_leaf: fix bittiming limits
can: kvaser_usb: kvaser_usb_leaf: fix CAN clock frequency regression
can: kvaser_usb: replace run-time checks with struct kvaser_usb_driver_info
can: m_can: m_can_{read_fifo,echo_tx_event}(): shift timestamp to full 32 bits
can: m_can: m_can_chip_config(): actually enable internal timestamping
can: grcan: grcan_probe(): remove extra of_node_get()
can: gs_usb: gs_usb_open/close(): fix memory leak
can: rcar_canfd: Fix data transmission failed on R-Car V3U
Revert "can: xilinx_can: Limit CANFD brp to 2"
can: bcm: use call_rcu() instead of costly synchronize_rcu()
====================

Link: https://lore.kernel.org/r/20220704122613.1551119-1-mkl@pengutronix.de
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

Jakub Kicinski 7e8c182c 1b18f09d

+304 -216
-1
drivers/net/can/grcan.c
··· 1646 1646 */ 1647 1647 sysid_parent = of_find_node_by_path("/ambapp0"); 1648 1648 if (sysid_parent) { 1649 - of_node_get(sysid_parent); 1650 1649 err = of_property_read_u32(sysid_parent, "systemid", &sysid); 1651 1650 if (!err && ((sysid & GRLIB_VERSION_MASK) >= 1652 1651 GRCAN_TXBUG_SAFE_GRLIB_VERSION))
+5 -3
drivers/net/can/m_can/m_can.c
··· 529 529 /* acknowledge rx fifo 0 */ 530 530 m_can_write(cdev, M_CAN_RXF0A, fgi); 531 531 532 - timestamp = FIELD_GET(RX_BUF_RXTS_MASK, fifo_header.dlc); 532 + timestamp = FIELD_GET(RX_BUF_RXTS_MASK, fifo_header.dlc) << 16; 533 533 534 534 m_can_receive_skb(cdev, skb, timestamp); 535 535 ··· 1030 1030 } 1031 1031 1032 1032 msg_mark = FIELD_GET(TX_EVENT_MM_MASK, txe); 1033 - timestamp = FIELD_GET(TX_EVENT_TXTS_MASK, txe); 1033 + timestamp = FIELD_GET(TX_EVENT_TXTS_MASK, txe) << 16; 1034 1034 1035 1035 /* ack txe element */ 1036 1036 m_can_write(cdev, M_CAN_TXEFA, FIELD_PREP(TXEFA_EFAI_MASK, ··· 1351 1351 /* enable internal timestamp generation, with a prescalar of 16. The 1352 1352 * prescalar is applied to the nominal bit timing 1353 1353 */ 1354 - m_can_write(cdev, M_CAN_TSCC, FIELD_PREP(TSCC_TCP_MASK, 0xf)); 1354 + m_can_write(cdev, M_CAN_TSCC, 1355 + FIELD_PREP(TSCC_TCP_MASK, 0xf) | 1356 + FIELD_PREP(TSCC_TSS_MASK, TSCC_TSS_INTERNAL)); 1355 1357 1356 1358 m_can_config_endisable(cdev, false); 1357 1359
+4 -1
drivers/net/can/rcar/rcar_canfd.c
··· 1332 1332 cfg = (RCANFD_DCFG_DTSEG1(gpriv, tseg1) | RCANFD_DCFG_DBRP(brp) | 1333 1333 RCANFD_DCFG_DSJW(sjw) | RCANFD_DCFG_DTSEG2(gpriv, tseg2)); 1334 1334 1335 - rcar_canfd_write(priv->base, RCANFD_F_DCFG(ch), cfg); 1335 + if (is_v3u(gpriv)) 1336 + rcar_canfd_write(priv->base, RCANFD_V3U_DCFG(ch), cfg); 1337 + else 1338 + rcar_canfd_write(priv->base, RCANFD_F_DCFG(ch), cfg); 1336 1339 netdev_dbg(priv->ndev, "drate: brp %u, sjw %u, tseg1 %u, tseg2 %u\n", 1337 1340 brp, sjw, tseg1, tseg2); 1338 1341 } else {
+4 -2
drivers/net/can/spi/mcp251xfd/mcp251xfd-core.c
··· 12 12 // Copyright (c) 2019 Martin Sperl <kernel@martin.sperl.org> 13 13 // 14 14 15 + #include <asm/unaligned.h> 15 16 #include <linux/bitfield.h> 16 17 #include <linux/clk.h> 17 18 #include <linux/device.h> ··· 1651 1650 netif_stop_queue(ndev); 1652 1651 set_bit(MCP251XFD_FLAGS_DOWN, priv->flags); 1653 1652 hrtimer_cancel(&priv->rx_irq_timer); 1653 + hrtimer_cancel(&priv->tx_irq_timer); 1654 1654 mcp251xfd_chip_interrupts_disable(priv); 1655 1655 free_irq(ndev->irq, priv); 1656 1656 can_rx_offload_disable(&priv->offload); ··· 1779 1777 xfer[0].len = sizeof(buf_tx->cmd); 1780 1778 xfer[0].speed_hz = priv->spi_max_speed_hz_slow; 1781 1779 xfer[1].rx_buf = buf_rx->data; 1782 - xfer[1].len = sizeof(dev_id); 1780 + xfer[1].len = sizeof(*dev_id); 1783 1781 xfer[1].speed_hz = priv->spi_max_speed_hz_fast; 1784 1782 1785 1783 mcp251xfd_spi_cmd_read_nocrc(&buf_tx->cmd, MCP251XFD_REG_DEVID); ··· 1788 1786 if (err) 1789 1787 goto out_kfree_buf_tx; 1790 1788 1791 - *dev_id = be32_to_cpup((__be32 *)buf_rx->data); 1789 + *dev_id = get_unaligned_le32(buf_rx->data); 1792 1790 *effective_speed_hz_slow = xfer[0].effective_speed_hz; 1793 1791 *effective_speed_hz_fast = xfer[1].effective_speed_hz; 1794 1792
+11 -11
drivers/net/can/spi/mcp251xfd/mcp251xfd-regmap.c
··· 334 334 * register. It increments once per SYS clock tick, 335 335 * which is 20 or 40 MHz. 336 336 * 337 - * Observation shows that if the lowest byte (which is 338 - * transferred first on the SPI bus) of that register 339 - * is 0x00 or 0x80 the calculated CRC doesn't always 340 - * match the transferred one. 337 + * Observation on the mcp2518fd shows that if the 338 + * lowest byte (which is transferred first on the SPI 339 + * bus) of that register is 0x00 or 0x80 the 340 + * calculated CRC doesn't always match the transferred 341 + * one. On the mcp2517fd this problem is not limited 342 + * to the first byte being 0x00 or 0x80. 341 343 * 342 344 * If the highest bit in the lowest byte is flipped 343 345 * the transferred CRC matches the calculated one. We 344 - * assume for now the CRC calculation in the chip 345 - * works on wrong data and the transferred data is 346 - * correct. 346 + * assume for now the CRC operates on the correct 347 + * data. 347 348 */ 348 349 if (reg == MCP251XFD_REG_TBC && 349 - (buf_rx->data[0] == 0x0 || buf_rx->data[0] == 0x80)) { 350 + ((buf_rx->data[0] & 0xf8) == 0x0 || 351 + (buf_rx->data[0] & 0xf8) == 0x80)) { 350 352 /* Flip highest bit in lowest byte of le32 */ 351 353 buf_rx->data[0] ^= 0x80; 352 354 ··· 358 356 val_len); 359 357 if (!err) { 360 358 /* If CRC is now correct, assume 361 - * transferred data was OK, flip bit 362 - * back to original value. 359 + * flipped data is OK. 363 360 */ 364 - buf_rx->data[0] ^= 0x80; 365 361 goto out; 366 362 } 367 363 }
+21 -2
drivers/net/can/usb/gs_usb.c
··· 268 268 269 269 struct usb_anchor tx_submitted; 270 270 atomic_t active_tx_urbs; 271 + void *rxbuf[GS_MAX_RX_URBS]; 272 + dma_addr_t rxbuf_dma[GS_MAX_RX_URBS]; 271 273 }; 272 274 273 275 /* usb interface struct */ ··· 744 742 for (i = 0; i < GS_MAX_RX_URBS; i++) { 745 743 struct urb *urb; 746 744 u8 *buf; 745 + dma_addr_t buf_dma; 747 746 748 747 /* alloc rx urb */ 749 748 urb = usb_alloc_urb(0, GFP_KERNEL); ··· 755 752 buf = usb_alloc_coherent(dev->udev, 756 753 dev->parent->hf_size_rx, 757 754 GFP_KERNEL, 758 - &urb->transfer_dma); 755 + &buf_dma); 759 756 if (!buf) { 760 757 netdev_err(netdev, 761 758 "No memory left for USB buffer\n"); 762 759 usb_free_urb(urb); 763 760 return -ENOMEM; 764 761 } 762 + 763 + urb->transfer_dma = buf_dma; 765 764 766 765 /* fill, anchor, and submit rx urb */ 767 766 usb_fill_bulk_urb(urb, ··· 786 781 "usb_submit failed (err=%d)\n", rc); 787 782 788 783 usb_unanchor_urb(urb); 784 + usb_free_coherent(dev->udev, 785 + sizeof(struct gs_host_frame), 786 + buf, 787 + buf_dma); 789 788 usb_free_urb(urb); 790 789 break; 791 790 } 791 + 792 + dev->rxbuf[i] = buf; 793 + dev->rxbuf_dma[i] = buf_dma; 792 794 793 795 /* Drop reference, 794 796 * USB core will take care of freeing it ··· 854 842 int rc; 855 843 struct gs_can *dev = netdev_priv(netdev); 856 844 struct gs_usb *parent = dev->parent; 845 + unsigned int i; 857 846 858 847 netif_stop_queue(netdev); 859 848 860 849 /* Stop polling */ 861 850 parent->active_channels--; 862 - if (!parent->active_channels) 851 + if (!parent->active_channels) { 863 852 usb_kill_anchored_urbs(&parent->rx_submitted); 853 + for (i = 0; i < GS_MAX_RX_URBS; i++) 854 + usb_free_coherent(dev->udev, 855 + sizeof(struct gs_host_frame), 856 + dev->rxbuf[i], 857 + dev->rxbuf_dma[i]); 858 + } 864 859 865 860 /* Stop sending URBs */ 866 861 usb_kill_anchored_urbs(&dev->tx_submitted);
+15 -10
drivers/net/can/usb/kvaser_usb/kvaser_usb.h
··· 35 35 #define KVASER_USB_RX_BUFFER_SIZE 3072 36 36 #define KVASER_USB_MAX_NET_DEVICES 5 37 37 38 - /* USB devices features */ 39 - #define KVASER_USB_HAS_SILENT_MODE BIT(0) 40 - #define KVASER_USB_HAS_TXRX_ERRORS BIT(1) 38 + /* Kvaser USB device quirks */ 39 + #define KVASER_USB_QUIRK_HAS_SILENT_MODE BIT(0) 40 + #define KVASER_USB_QUIRK_HAS_TXRX_ERRORS BIT(1) 41 + #define KVASER_USB_QUIRK_IGNORE_CLK_FREQ BIT(2) 41 42 42 43 /* Device capabilities */ 43 44 #define KVASER_USB_CAP_BERR_CAP 0x01 ··· 66 65 struct kvaser_usb_dev_card_data { 67 66 u32 ctrlmode_supported; 68 67 u32 capabilities; 69 - union { 70 - struct { 71 - enum kvaser_usb_leaf_family family; 72 - } leaf; 73 - struct kvaser_usb_dev_card_data_hydra hydra; 74 - }; 68 + struct kvaser_usb_dev_card_data_hydra hydra; 75 69 }; 76 70 77 71 /* Context for an outstanding, not yet ACKed, transmission */ ··· 79 83 struct usb_device *udev; 80 84 struct usb_interface *intf; 81 85 struct kvaser_usb_net_priv *nets[KVASER_USB_MAX_NET_DEVICES]; 82 - const struct kvaser_usb_dev_ops *ops; 86 + const struct kvaser_usb_driver_info *driver_info; 83 87 const struct kvaser_usb_dev_cfg *cfg; 84 88 85 89 struct usb_endpoint_descriptor *bulk_in, *bulk_out; ··· 161 165 u16 transid); 162 166 }; 163 167 168 + struct kvaser_usb_driver_info { 169 + u32 quirks; 170 + enum kvaser_usb_leaf_family family; 171 + const struct kvaser_usb_dev_ops *ops; 172 + }; 173 + 164 174 struct kvaser_usb_dev_cfg { 165 175 const struct can_clock clock; 166 176 const unsigned int timestamp_freq; ··· 186 184 int len); 187 185 188 186 int kvaser_usb_can_rx_over_error(struct net_device *netdev); 187 + 188 + extern const struct can_bittiming_const kvaser_usb_flexc_bittiming_const; 189 + 189 190 #endif /* KVASER_USB_H */
+158 -127
drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c
··· 61 61 #define USB_USBCAN_R_V2_PRODUCT_ID 294 62 62 #define USB_LEAF_LIGHT_R_V2_PRODUCT_ID 295 63 63 #define USB_LEAF_LIGHT_HS_V2_OEM2_PRODUCT_ID 296 64 - #define USB_LEAF_PRODUCT_ID_END \ 65 - USB_LEAF_LIGHT_HS_V2_OEM2_PRODUCT_ID 66 64 67 65 /* Kvaser USBCan-II devices product ids */ 68 66 #define USB_USBCAN_REVB_PRODUCT_ID 2 ··· 87 89 #define USB_USBCAN_PRO_4HS_PRODUCT_ID 276 88 90 #define USB_HYBRID_CANLIN_PRODUCT_ID 277 89 91 #define USB_HYBRID_PRO_CANLIN_PRODUCT_ID 278 90 - #define USB_HYDRA_PRODUCT_ID_END \ 91 - USB_HYBRID_PRO_CANLIN_PRODUCT_ID 92 92 93 - static inline bool kvaser_is_leaf(const struct usb_device_id *id) 94 - { 95 - return (id->idProduct >= USB_LEAF_DEVEL_PRODUCT_ID && 96 - id->idProduct <= USB_CAN_R_PRODUCT_ID) || 97 - (id->idProduct >= USB_LEAF_LITE_V2_PRODUCT_ID && 98 - id->idProduct <= USB_LEAF_PRODUCT_ID_END); 99 - } 93 + static const struct kvaser_usb_driver_info kvaser_usb_driver_info_hydra = { 94 + .quirks = 0, 95 + .ops = &kvaser_usb_hydra_dev_ops, 96 + }; 100 97 101 - static inline bool kvaser_is_usbcan(const struct usb_device_id *id) 102 - { 103 - return id->idProduct >= USB_USBCAN_REVB_PRODUCT_ID && 104 - id->idProduct <= USB_MEMORATOR_PRODUCT_ID; 105 - } 98 + static const struct kvaser_usb_driver_info kvaser_usb_driver_info_usbcan = { 99 + .quirks = KVASER_USB_QUIRK_HAS_TXRX_ERRORS | 100 + KVASER_USB_QUIRK_HAS_SILENT_MODE, 101 + .family = KVASER_USBCAN, 102 + .ops = &kvaser_usb_leaf_dev_ops, 103 + }; 106 104 107 - static inline bool kvaser_is_hydra(const struct usb_device_id *id) 108 - { 109 - return id->idProduct >= USB_BLACKBIRD_V2_PRODUCT_ID && 110 - id->idProduct <= USB_HYDRA_PRODUCT_ID_END; 111 - } 105 + static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leaf = { 106 + .quirks = KVASER_USB_QUIRK_IGNORE_CLK_FREQ, 107 + .family = KVASER_LEAF, 108 + .ops = &kvaser_usb_leaf_dev_ops, 109 + }; 110 + 111 + static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leaf_err = { 112 + .quirks = KVASER_USB_QUIRK_HAS_TXRX_ERRORS | 113 + KVASER_USB_QUIRK_IGNORE_CLK_FREQ, 114 + .family = KVASER_LEAF, 115 + .ops = &kvaser_usb_leaf_dev_ops, 116 + }; 117 + 118 + static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leaf_err_listen = { 119 + .quirks = KVASER_USB_QUIRK_HAS_TXRX_ERRORS | 120 + KVASER_USB_QUIRK_HAS_SILENT_MODE | 121 + KVASER_USB_QUIRK_IGNORE_CLK_FREQ, 122 + .family = KVASER_LEAF, 123 + .ops = &kvaser_usb_leaf_dev_ops, 124 + }; 125 + 126 + static const struct kvaser_usb_driver_info kvaser_usb_driver_info_leafimx = { 127 + .quirks = 0, 128 + .ops = &kvaser_usb_leaf_dev_ops, 129 + }; 112 130 113 131 static const struct usb_device_id kvaser_usb_table[] = { 114 - /* Leaf USB product IDs */ 115 - { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_DEVEL_PRODUCT_ID) }, 116 - { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_PRODUCT_ID) }, 132 + /* Leaf M32C USB product IDs */ 133 + { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_DEVEL_PRODUCT_ID), 134 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf }, 135 + { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_PRODUCT_ID), 136 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf }, 117 137 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_PRODUCT_ID), 118 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS | 119 - KVASER_USB_HAS_SILENT_MODE }, 138 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 120 139 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_PRODUCT_ID), 121 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS | 122 - KVASER_USB_HAS_SILENT_MODE }, 140 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 123 141 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LS_PRODUCT_ID), 124 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS | 125 - KVASER_USB_HAS_SILENT_MODE }, 142 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 126 143 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_SWC_PRODUCT_ID), 127 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS | 128 - KVASER_USB_HAS_SILENT_MODE }, 144 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 129 145 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LIN_PRODUCT_ID), 130 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS | 131 - KVASER_USB_HAS_SILENT_MODE }, 146 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 132 147 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_LS_PRODUCT_ID), 133 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS | 134 - KVASER_USB_HAS_SILENT_MODE }, 148 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 135 149 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_SWC_PRODUCT_ID), 136 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS | 137 - KVASER_USB_HAS_SILENT_MODE }, 150 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 138 151 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_DEVEL_PRODUCT_ID), 139 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS | 140 - KVASER_USB_HAS_SILENT_MODE }, 152 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 141 153 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSHS_PRODUCT_ID), 142 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS | 143 - KVASER_USB_HAS_SILENT_MODE }, 154 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 144 155 { USB_DEVICE(KVASER_VENDOR_ID, USB_UPRO_HSHS_PRODUCT_ID), 145 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS }, 146 - { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_GI_PRODUCT_ID) }, 156 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 157 + { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_GI_PRODUCT_ID), 158 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf }, 147 159 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_OBDII_PRODUCT_ID), 148 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS | 149 - KVASER_USB_HAS_SILENT_MODE }, 160 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err_listen }, 150 161 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSLS_PRODUCT_ID), 151 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS }, 162 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 152 163 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_CH_PRODUCT_ID), 153 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS }, 164 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 154 165 { USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_SPRO_PRODUCT_ID), 155 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS }, 166 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 156 167 { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_MERCURY_PRODUCT_ID), 157 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS }, 168 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 158 169 { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_LEAF_PRODUCT_ID), 159 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS }, 170 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 160 171 { USB_DEVICE(KVASER_VENDOR_ID, USB_CAN_R_PRODUCT_ID), 161 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS }, 162 - { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_V2_PRODUCT_ID) }, 163 - { USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_HS_PRODUCT_ID) }, 164 - { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_HS_V2_OEM_PRODUCT_ID) }, 165 - { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_LIGHT_2HS_PRODUCT_ID) }, 166 - { USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_2HS_PRODUCT_ID) }, 167 - { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_R_V2_PRODUCT_ID) }, 168 - { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_R_V2_PRODUCT_ID) }, 169 - { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_HS_V2_OEM2_PRODUCT_ID) }, 172 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leaf_err }, 173 + 174 + /* Leaf i.MX28 USB product IDs */ 175 + { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_V2_PRODUCT_ID), 176 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 177 + { USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_HS_PRODUCT_ID), 178 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 179 + { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_HS_V2_OEM_PRODUCT_ID), 180 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 181 + { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_LIGHT_2HS_PRODUCT_ID), 182 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 183 + { USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_2HS_PRODUCT_ID), 184 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 185 + { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_R_V2_PRODUCT_ID), 186 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 187 + { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_R_V2_PRODUCT_ID), 188 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 189 + { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_HS_V2_OEM2_PRODUCT_ID), 190 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_leafimx }, 170 191 171 192 /* USBCANII USB product IDs */ 172 193 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN2_PRODUCT_ID), 173 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS }, 194 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_usbcan }, 174 195 { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_REVB_PRODUCT_ID), 175 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS }, 196 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_usbcan }, 176 197 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMORATOR_PRODUCT_ID), 177 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS }, 198 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_usbcan }, 178 199 { USB_DEVICE(KVASER_VENDOR_ID, USB_VCI2_PRODUCT_ID), 179 - .driver_info = KVASER_USB_HAS_TXRX_ERRORS }, 200 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_usbcan }, 180 201 181 202 /* Minihydra USB product IDs */ 182 - { USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_V2_PRODUCT_ID) }, 183 - { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_PRO_5HS_PRODUCT_ID) }, 184 - { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_5HS_PRODUCT_ID) }, 185 - { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_LIGHT_4HS_PRODUCT_ID) }, 186 - { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_HS_V2_PRODUCT_ID) }, 187 - { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_2HS_V2_PRODUCT_ID) }, 188 - { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_2HS_PRODUCT_ID) }, 189 - { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_PRO_2HS_V2_PRODUCT_ID) }, 190 - { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_2CANLIN_PRODUCT_ID) }, 191 - { USB_DEVICE(KVASER_VENDOR_ID, USB_ATI_USBCAN_PRO_2HS_V2_PRODUCT_ID) }, 192 - { USB_DEVICE(KVASER_VENDOR_ID, USB_ATI_MEMO_PRO_2HS_V2_PRODUCT_ID) }, 193 - { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_PRO_2CANLIN_PRODUCT_ID) }, 194 - { USB_DEVICE(KVASER_VENDOR_ID, USB_U100_PRODUCT_ID) }, 195 - { USB_DEVICE(KVASER_VENDOR_ID, USB_U100P_PRODUCT_ID) }, 196 - { USB_DEVICE(KVASER_VENDOR_ID, USB_U100S_PRODUCT_ID) }, 197 - { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_4HS_PRODUCT_ID) }, 198 - { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_CANLIN_PRODUCT_ID) }, 199 - { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_PRO_CANLIN_PRODUCT_ID) }, 203 + { USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_V2_PRODUCT_ID), 204 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 205 + { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_PRO_5HS_PRODUCT_ID), 206 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 207 + { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_5HS_PRODUCT_ID), 208 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 209 + { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_LIGHT_4HS_PRODUCT_ID), 210 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 211 + { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_HS_V2_PRODUCT_ID), 212 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 213 + { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_2HS_V2_PRODUCT_ID), 214 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 215 + { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_2HS_PRODUCT_ID), 216 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 217 + { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO_PRO_2HS_V2_PRODUCT_ID), 218 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 219 + { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_2CANLIN_PRODUCT_ID), 220 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 221 + { USB_DEVICE(KVASER_VENDOR_ID, USB_ATI_USBCAN_PRO_2HS_V2_PRODUCT_ID), 222 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 223 + { USB_DEVICE(KVASER_VENDOR_ID, USB_ATI_MEMO_PRO_2HS_V2_PRODUCT_ID), 224 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 225 + { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_PRO_2CANLIN_PRODUCT_ID), 226 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 227 + { USB_DEVICE(KVASER_VENDOR_ID, USB_U100_PRODUCT_ID), 228 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 229 + { USB_DEVICE(KVASER_VENDOR_ID, USB_U100P_PRODUCT_ID), 230 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 231 + { USB_DEVICE(KVASER_VENDOR_ID, USB_U100S_PRODUCT_ID), 232 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 233 + { USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_PRO_4HS_PRODUCT_ID), 234 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 235 + { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_CANLIN_PRODUCT_ID), 236 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 237 + { USB_DEVICE(KVASER_VENDOR_ID, USB_HYBRID_PRO_CANLIN_PRODUCT_ID), 238 + .driver_info = (kernel_ulong_t)&kvaser_usb_driver_info_hydra }, 200 239 { } 201 240 }; 202 241 MODULE_DEVICE_TABLE(usb, kvaser_usb_table); ··· 320 285 static void kvaser_usb_read_bulk_callback(struct urb *urb) 321 286 { 322 287 struct kvaser_usb *dev = urb->context; 288 + const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; 323 289 int err; 324 290 unsigned int i; 325 291 ··· 337 301 goto resubmit_urb; 338 302 } 339 303 340 - dev->ops->dev_read_bulk_callback(dev, urb->transfer_buffer, 341 - urb->actual_length); 304 + ops->dev_read_bulk_callback(dev, urb->transfer_buffer, 305 + urb->actual_length); 342 306 343 307 resubmit_urb: 344 308 usb_fill_bulk_urb(urb, dev->udev, ··· 432 396 { 433 397 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 434 398 struct kvaser_usb *dev = priv->dev; 399 + const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; 435 400 int err; 436 401 437 402 err = open_candev(netdev); ··· 443 406 if (err) 444 407 goto error; 445 408 446 - err = dev->ops->dev_set_opt_mode(priv); 409 + err = ops->dev_set_opt_mode(priv); 447 410 if (err) 448 411 goto error; 449 412 450 - err = dev->ops->dev_start_chip(priv); 413 + err = ops->dev_start_chip(priv); 451 414 if (err) { 452 415 netdev_warn(netdev, "Cannot start device, error %d\n", err); 453 416 goto error; ··· 504 467 { 505 468 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 506 469 struct kvaser_usb *dev = priv->dev; 470 + const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; 507 471 int err; 508 472 509 473 netif_stop_queue(netdev); 510 474 511 - err = dev->ops->dev_flush_queue(priv); 475 + err = ops->dev_flush_queue(priv); 512 476 if (err) 513 477 netdev_warn(netdev, "Cannot flush queue, error %d\n", err); 514 478 515 - if (dev->ops->dev_reset_chip) { 516 - err = dev->ops->dev_reset_chip(dev, priv->channel); 479 + if (ops->dev_reset_chip) { 480 + err = ops->dev_reset_chip(dev, priv->channel); 517 481 if (err) 518 482 netdev_warn(netdev, "Cannot reset card, error %d\n", 519 483 err); 520 484 } 521 485 522 - err = dev->ops->dev_stop_chip(priv); 486 + err = ops->dev_stop_chip(priv); 523 487 if (err) 524 488 netdev_warn(netdev, "Cannot stop device, error %d\n", err); 525 489 ··· 559 521 { 560 522 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 561 523 struct kvaser_usb *dev = priv->dev; 524 + const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; 562 525 struct net_device_stats *stats = &netdev->stats; 563 526 struct kvaser_usb_tx_urb_context *context = NULL; 564 527 struct urb *urb; ··· 602 563 goto freeurb; 603 564 } 604 565 605 - buf = dev->ops->dev_frame_to_cmd(priv, skb, &cmd_len, 606 - context->echo_index); 566 + buf = ops->dev_frame_to_cmd(priv, skb, &cmd_len, context->echo_index); 607 567 if (!buf) { 608 568 stats->tx_dropped++; 609 569 dev_kfree_skb(skb); ··· 686 648 } 687 649 } 688 650 689 - static int kvaser_usb_init_one(struct kvaser_usb *dev, 690 - const struct usb_device_id *id, int channel) 651 + static int kvaser_usb_init_one(struct kvaser_usb *dev, int channel) 691 652 { 692 653 struct net_device *netdev; 693 654 struct kvaser_usb_net_priv *priv; 655 + const struct kvaser_usb_driver_info *driver_info = dev->driver_info; 656 + const struct kvaser_usb_dev_ops *ops = driver_info->ops; 694 657 int err; 695 658 696 - if (dev->ops->dev_reset_chip) { 697 - err = dev->ops->dev_reset_chip(dev, channel); 659 + if (ops->dev_reset_chip) { 660 + err = ops->dev_reset_chip(dev, channel); 698 661 if (err) 699 662 return err; 700 663 } ··· 724 685 priv->can.state = CAN_STATE_STOPPED; 725 686 priv->can.clock.freq = dev->cfg->clock.freq; 726 687 priv->can.bittiming_const = dev->cfg->bittiming_const; 727 - priv->can.do_set_bittiming = dev->ops->dev_set_bittiming; 728 - priv->can.do_set_mode = dev->ops->dev_set_mode; 729 - if ((id->driver_info & KVASER_USB_HAS_TXRX_ERRORS) || 688 + priv->can.do_set_bittiming = ops->dev_set_bittiming; 689 + priv->can.do_set_mode = ops->dev_set_mode; 690 + if ((driver_info->quirks & KVASER_USB_QUIRK_HAS_TXRX_ERRORS) || 730 691 (priv->dev->card_data.capabilities & KVASER_USB_CAP_BERR_CAP)) 731 - priv->can.do_get_berr_counter = dev->ops->dev_get_berr_counter; 732 - if (id->driver_info & KVASER_USB_HAS_SILENT_MODE) 692 + priv->can.do_get_berr_counter = ops->dev_get_berr_counter; 693 + if (driver_info->quirks & KVASER_USB_QUIRK_HAS_SILENT_MODE) 733 694 priv->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY; 734 695 735 696 priv->can.ctrlmode_supported |= dev->card_data.ctrlmode_supported; 736 697 737 698 if (priv->can.ctrlmode_supported & CAN_CTRLMODE_FD) { 738 699 priv->can.data_bittiming_const = dev->cfg->data_bittiming_const; 739 - priv->can.do_set_data_bittiming = 740 - dev->ops->dev_set_data_bittiming; 700 + priv->can.do_set_data_bittiming = ops->dev_set_data_bittiming; 741 701 } 742 702 743 703 netdev->flags |= IFF_ECHO; ··· 767 729 struct kvaser_usb *dev; 768 730 int err; 769 731 int i; 732 + const struct kvaser_usb_driver_info *driver_info; 733 + const struct kvaser_usb_dev_ops *ops; 734 + 735 + driver_info = (const struct kvaser_usb_driver_info *)id->driver_info; 736 + if (!driver_info) 737 + return -ENODEV; 770 738 771 739 dev = devm_kzalloc(&intf->dev, sizeof(*dev), GFP_KERNEL); 772 740 if (!dev) 773 741 return -ENOMEM; 774 742 775 - if (kvaser_is_leaf(id)) { 776 - dev->card_data.leaf.family = KVASER_LEAF; 777 - dev->ops = &kvaser_usb_leaf_dev_ops; 778 - } else if (kvaser_is_usbcan(id)) { 779 - dev->card_data.leaf.family = KVASER_USBCAN; 780 - dev->ops = &kvaser_usb_leaf_dev_ops; 781 - } else if (kvaser_is_hydra(id)) { 782 - dev->ops = &kvaser_usb_hydra_dev_ops; 783 - } else { 784 - dev_err(&intf->dev, 785 - "Product ID (%d) is not a supported Kvaser USB device\n", 786 - id->idProduct); 787 - return -ENODEV; 788 - } 789 - 790 743 dev->intf = intf; 744 + dev->driver_info = driver_info; 745 + ops = driver_info->ops; 791 746 792 - err = dev->ops->dev_setup_endpoints(dev); 747 + err = ops->dev_setup_endpoints(dev); 793 748 if (err) { 794 749 dev_err(&intf->dev, "Cannot get usb endpoint(s)"); 795 750 return err; ··· 796 765 797 766 dev->card_data.ctrlmode_supported = 0; 798 767 dev->card_data.capabilities = 0; 799 - err = dev->ops->dev_init_card(dev); 768 + err = ops->dev_init_card(dev); 800 769 if (err) { 801 770 dev_err(&intf->dev, 802 771 "Failed to initialize card, error %d\n", err); 803 772 return err; 804 773 } 805 774 806 - err = dev->ops->dev_get_software_info(dev); 775 + err = ops->dev_get_software_info(dev); 807 776 if (err) { 808 777 dev_err(&intf->dev, 809 778 "Cannot get software info, error %d\n", err); 810 779 return err; 811 780 } 812 781 813 - if (dev->ops->dev_get_software_details) { 814 - err = dev->ops->dev_get_software_details(dev); 782 + if (ops->dev_get_software_details) { 783 + err = ops->dev_get_software_details(dev); 815 784 if (err) { 816 785 dev_err(&intf->dev, 817 786 "Cannot get software details, error %d\n", err); ··· 829 798 830 799 dev_dbg(&intf->dev, "Max outstanding tx = %d URBs\n", dev->max_tx_urbs); 831 800 832 - err = dev->ops->dev_get_card_info(dev); 801 + err = ops->dev_get_card_info(dev); 833 802 if (err) { 834 803 dev_err(&intf->dev, "Cannot get card info, error %d\n", err); 835 804 return err; 836 805 } 837 806 838 - if (dev->ops->dev_get_capabilities) { 839 - err = dev->ops->dev_get_capabilities(dev); 807 + if (ops->dev_get_capabilities) { 808 + err = ops->dev_get_capabilities(dev); 840 809 if (err) { 841 810 dev_err(&intf->dev, 842 811 "Cannot get capabilities, error %d\n", err); ··· 846 815 } 847 816 848 817 for (i = 0; i < dev->nchannels; i++) { 849 - err = kvaser_usb_init_one(dev, id, i); 818 + err = kvaser_usb_init_one(dev, i); 850 819 if (err) { 851 820 kvaser_usb_remove_interfaces(dev); 852 821 return err;
+2 -2
drivers/net/can/usb/kvaser_usb/kvaser_usb_hydra.c
··· 375 375 .brp_inc = 1, 376 376 }; 377 377 378 - static const struct can_bittiming_const kvaser_usb_hydra_flexc_bittiming_c = { 378 + const struct can_bittiming_const kvaser_usb_flexc_bittiming_const = { 379 379 .name = "kvaser_usb_flex", 380 380 .tseg1_min = 4, 381 381 .tseg1_max = 16, ··· 2052 2052 .freq = 24 * MEGA /* Hz */, 2053 2053 }, 2054 2054 .timestamp_freq = 1, 2055 - .bittiming_const = &kvaser_usb_hydra_flexc_bittiming_c, 2055 + .bittiming_const = &kvaser_usb_flexc_bittiming_const, 2056 2056 }; 2057 2057 2058 2058 static const struct kvaser_usb_dev_cfg kvaser_usb_hydra_dev_cfg_rt = {
+68 -51
drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c
··· 101 101 #define USBCAN_ERROR_STATE_RX_ERROR BIT(1) 102 102 #define USBCAN_ERROR_STATE_BUSERROR BIT(2) 103 103 104 - /* bittiming parameters */ 105 - #define KVASER_USB_TSEG1_MIN 1 106 - #define KVASER_USB_TSEG1_MAX 16 107 - #define KVASER_USB_TSEG2_MIN 1 108 - #define KVASER_USB_TSEG2_MAX 8 109 - #define KVASER_USB_SJW_MAX 4 110 - #define KVASER_USB_BRP_MIN 1 111 - #define KVASER_USB_BRP_MAX 64 112 - #define KVASER_USB_BRP_INC 1 113 - 114 104 /* ctrl modes */ 115 105 #define KVASER_CTRL_MODE_NORMAL 1 116 106 #define KVASER_CTRL_MODE_SILENT 2 ··· 333 343 }; 334 344 }; 335 345 336 - static const struct can_bittiming_const kvaser_usb_leaf_bittiming_const = { 337 - .name = "kvaser_usb", 338 - .tseg1_min = KVASER_USB_TSEG1_MIN, 339 - .tseg1_max = KVASER_USB_TSEG1_MAX, 340 - .tseg2_min = KVASER_USB_TSEG2_MIN, 341 - .tseg2_max = KVASER_USB_TSEG2_MAX, 342 - .sjw_max = KVASER_USB_SJW_MAX, 343 - .brp_min = KVASER_USB_BRP_MIN, 344 - .brp_max = KVASER_USB_BRP_MAX, 345 - .brp_inc = KVASER_USB_BRP_INC, 346 + static const struct can_bittiming_const kvaser_usb_leaf_m16c_bittiming_const = { 347 + .name = "kvaser_usb_ucii", 348 + .tseg1_min = 4, 349 + .tseg1_max = 16, 350 + .tseg2_min = 2, 351 + .tseg2_max = 8, 352 + .sjw_max = 4, 353 + .brp_min = 1, 354 + .brp_max = 16, 355 + .brp_inc = 1, 346 356 }; 347 357 348 - static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg_8mhz = { 358 + static const struct can_bittiming_const kvaser_usb_leaf_m32c_bittiming_const = { 359 + .name = "kvaser_usb_leaf", 360 + .tseg1_min = 3, 361 + .tseg1_max = 16, 362 + .tseg2_min = 2, 363 + .tseg2_max = 8, 364 + .sjw_max = 4, 365 + .brp_min = 2, 366 + .brp_max = 128, 367 + .brp_inc = 2, 368 + }; 369 + 370 + static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_usbcan_dev_cfg = { 349 371 .clock = { 350 372 .freq = 8 * MEGA /* Hz */, 351 373 }, 352 374 .timestamp_freq = 1, 353 - .bittiming_const = &kvaser_usb_leaf_bittiming_const, 375 + .bittiming_const = &kvaser_usb_leaf_m16c_bittiming_const, 354 376 }; 355 377 356 - static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg_16mhz = { 378 + static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_m32c_dev_cfg = { 357 379 .clock = { 358 380 .freq = 16 * MEGA /* Hz */, 359 381 }, 360 382 .timestamp_freq = 1, 361 - .bittiming_const = &kvaser_usb_leaf_bittiming_const, 383 + .bittiming_const = &kvaser_usb_leaf_m32c_bittiming_const, 362 384 }; 363 385 364 - static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg_24mhz = { 386 + static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_imx_dev_cfg_16mhz = { 387 + .clock = { 388 + .freq = 16 * MEGA /* Hz */, 389 + }, 390 + .timestamp_freq = 1, 391 + .bittiming_const = &kvaser_usb_flexc_bittiming_const, 392 + }; 393 + 394 + static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_imx_dev_cfg_24mhz = { 365 395 .clock = { 366 396 .freq = 24 * MEGA /* Hz */, 367 397 }, 368 398 .timestamp_freq = 1, 369 - .bittiming_const = &kvaser_usb_leaf_bittiming_const, 399 + .bittiming_const = &kvaser_usb_flexc_bittiming_const, 370 400 }; 371 401 372 - static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg_32mhz = { 402 + static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_imx_dev_cfg_32mhz = { 373 403 .clock = { 374 404 .freq = 32 * MEGA /* Hz */, 375 405 }, 376 406 .timestamp_freq = 1, 377 - .bittiming_const = &kvaser_usb_leaf_bittiming_const, 407 + .bittiming_const = &kvaser_usb_flexc_bittiming_const, 378 408 }; 379 409 380 410 static void * ··· 414 404 sizeof(struct kvaser_cmd_tx_can); 415 405 cmd->u.tx_can.channel = priv->channel; 416 406 417 - switch (dev->card_data.leaf.family) { 407 + switch (dev->driver_info->family) { 418 408 case KVASER_LEAF: 419 409 cmd_tx_can_flags = &cmd->u.tx_can.leaf.flags; 420 410 break; ··· 534 524 dev->fw_version = le32_to_cpu(softinfo->fw_version); 535 525 dev->max_tx_urbs = le16_to_cpu(softinfo->max_outstanding_tx); 536 526 537 - switch (sw_options & KVASER_USB_LEAF_SWOPTION_FREQ_MASK) { 538 - case KVASER_USB_LEAF_SWOPTION_FREQ_16_MHZ_CLK: 539 - dev->cfg = &kvaser_usb_leaf_dev_cfg_16mhz; 540 - break; 541 - case KVASER_USB_LEAF_SWOPTION_FREQ_24_MHZ_CLK: 542 - dev->cfg = &kvaser_usb_leaf_dev_cfg_24mhz; 543 - break; 544 - case KVASER_USB_LEAF_SWOPTION_FREQ_32_MHZ_CLK: 545 - dev->cfg = &kvaser_usb_leaf_dev_cfg_32mhz; 546 - break; 527 + if (dev->driver_info->quirks & KVASER_USB_QUIRK_IGNORE_CLK_FREQ) { 528 + /* Firmware expects bittiming parameters calculated for 16MHz 529 + * clock, regardless of the actual clock 530 + */ 531 + dev->cfg = &kvaser_usb_leaf_m32c_dev_cfg; 532 + } else { 533 + switch (sw_options & KVASER_USB_LEAF_SWOPTION_FREQ_MASK) { 534 + case KVASER_USB_LEAF_SWOPTION_FREQ_16_MHZ_CLK: 535 + dev->cfg = &kvaser_usb_leaf_imx_dev_cfg_16mhz; 536 + break; 537 + case KVASER_USB_LEAF_SWOPTION_FREQ_24_MHZ_CLK: 538 + dev->cfg = &kvaser_usb_leaf_imx_dev_cfg_24mhz; 539 + break; 540 + case KVASER_USB_LEAF_SWOPTION_FREQ_32_MHZ_CLK: 541 + dev->cfg = &kvaser_usb_leaf_imx_dev_cfg_32mhz; 542 + break; 543 + } 547 544 } 548 545 } 549 546 ··· 567 550 if (err) 568 551 return err; 569 552 570 - switch (dev->card_data.leaf.family) { 553 + switch (dev->driver_info->family) { 571 554 case KVASER_LEAF: 572 555 kvaser_usb_leaf_get_software_info_leaf(dev, &cmd.u.leaf.softinfo); 573 556 break; ··· 575 558 dev->fw_version = le32_to_cpu(cmd.u.usbcan.softinfo.fw_version); 576 559 dev->max_tx_urbs = 577 560 le16_to_cpu(cmd.u.usbcan.softinfo.max_outstanding_tx); 578 - dev->cfg = &kvaser_usb_leaf_dev_cfg_8mhz; 561 + dev->cfg = &kvaser_usb_leaf_usbcan_dev_cfg; 579 562 break; 580 563 } 581 564 ··· 614 597 615 598 dev->nchannels = cmd.u.cardinfo.nchannels; 616 599 if (dev->nchannels > KVASER_USB_MAX_NET_DEVICES || 617 - (dev->card_data.leaf.family == KVASER_USBCAN && 600 + (dev->driver_info->family == KVASER_USBCAN && 618 601 dev->nchannels > MAX_USBCAN_NET_DEVICES)) 619 602 return -EINVAL; 620 603 ··· 747 730 new_state < CAN_STATE_BUS_OFF) 748 731 priv->can.can_stats.restarts++; 749 732 750 - switch (dev->card_data.leaf.family) { 733 + switch (dev->driver_info->family) { 751 734 case KVASER_LEAF: 752 735 if (es->leaf.error_factor) { 753 736 priv->can.can_stats.bus_error++; ··· 826 809 } 827 810 } 828 811 829 - switch (dev->card_data.leaf.family) { 812 + switch (dev->driver_info->family) { 830 813 case KVASER_LEAF: 831 814 if (es->leaf.error_factor) { 832 815 cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT; ··· 1016 999 stats = &priv->netdev->stats; 1017 1000 1018 1001 if ((cmd->u.rx_can_header.flag & MSG_FLAG_ERROR_FRAME) && 1019 - (dev->card_data.leaf.family == KVASER_LEAF && 1002 + (dev->driver_info->family == KVASER_LEAF && 1020 1003 cmd->id == CMD_LEAF_LOG_MESSAGE)) { 1021 1004 kvaser_usb_leaf_leaf_rx_error(dev, cmd); 1022 1005 return; ··· 1032 1015 return; 1033 1016 } 1034 1017 1035 - switch (dev->card_data.leaf.family) { 1018 + switch (dev->driver_info->family) { 1036 1019 case KVASER_LEAF: 1037 1020 rx_data = cmd->u.leaf.rx_can.data; 1038 1021 break; ··· 1047 1030 return; 1048 1031 } 1049 1032 1050 - if (dev->card_data.leaf.family == KVASER_LEAF && cmd->id == 1033 + if (dev->driver_info->family == KVASER_LEAF && cmd->id == 1051 1034 CMD_LEAF_LOG_MESSAGE) { 1052 1035 cf->can_id = le32_to_cpu(cmd->u.leaf.log_message.id); 1053 1036 if (cf->can_id & KVASER_EXTENDED_FRAME) ··· 1145 1128 break; 1146 1129 1147 1130 case CMD_LEAF_LOG_MESSAGE: 1148 - if (dev->card_data.leaf.family != KVASER_LEAF) 1131 + if (dev->driver_info->family != KVASER_LEAF) 1149 1132 goto warn; 1150 1133 kvaser_usb_leaf_rx_can_msg(dev, cmd); 1151 1134 break; 1152 1135 1153 1136 case CMD_CHIP_STATE_EVENT: 1154 1137 case CMD_CAN_ERROR_EVENT: 1155 - if (dev->card_data.leaf.family == KVASER_LEAF) 1138 + if (dev->driver_info->family == KVASER_LEAF) 1156 1139 kvaser_usb_leaf_leaf_rx_error(dev, cmd); 1157 1140 else 1158 1141 kvaser_usb_leaf_usbcan_rx_error(dev, cmd); ··· 1164 1147 1165 1148 /* Ignored commands */ 1166 1149 case CMD_USBCAN_CLOCK_OVERFLOW_EVENT: 1167 - if (dev->card_data.leaf.family != KVASER_USBCAN) 1150 + if (dev->driver_info->family != KVASER_USBCAN) 1168 1151 goto warn; 1169 1152 break; 1170 1153 1171 1154 case CMD_FLUSH_QUEUE_REPLY: 1172 - if (dev->card_data.leaf.family != KVASER_LEAF) 1155 + if (dev->driver_info->family != KVASER_LEAF) 1173 1156 goto warn; 1174 1157 break; 1175 1158
+2 -2
drivers/net/can/xilinx_can.c
··· 258 258 .tseg2_min = 1, 259 259 .tseg2_max = 128, 260 260 .sjw_max = 128, 261 - .brp_min = 2, 261 + .brp_min = 1, 262 262 .brp_max = 256, 263 263 .brp_inc = 1, 264 264 }; ··· 271 271 .tseg2_min = 1, 272 272 .tseg2_max = 16, 273 273 .sjw_max = 16, 274 - .brp_min = 2, 274 + .brp_min = 1, 275 275 .brp_max = 256, 276 276 .brp_inc = 1, 277 277 };
+14 -4
net/can/bcm.c
··· 100 100 101 101 struct bcm_op { 102 102 struct list_head list; 103 + struct rcu_head rcu; 103 104 int ifindex; 104 105 canid_t can_id; 105 106 u32 flags; ··· 719 718 return NULL; 720 719 } 721 720 722 - static void bcm_remove_op(struct bcm_op *op) 721 + static void bcm_free_op_rcu(struct rcu_head *rcu_head) 723 722 { 724 - hrtimer_cancel(&op->timer); 725 - hrtimer_cancel(&op->thrtimer); 723 + struct bcm_op *op = container_of(rcu_head, struct bcm_op, rcu); 726 724 727 725 if ((op->frames) && (op->frames != &op->sframe)) 728 726 kfree(op->frames); ··· 730 730 kfree(op->last_frames); 731 731 732 732 kfree(op); 733 + } 734 + 735 + static void bcm_remove_op(struct bcm_op *op) 736 + { 737 + hrtimer_cancel(&op->timer); 738 + hrtimer_cancel(&op->thrtimer); 739 + 740 + call_rcu(&op->rcu, bcm_free_op_rcu); 733 741 } 734 742 735 743 static void bcm_rx_unreg(struct net_device *dev, struct bcm_op *op) ··· 764 756 list_for_each_entry_safe(op, n, ops, list) { 765 757 if ((op->can_id == mh->can_id) && (op->ifindex == ifindex) && 766 758 (op->flags & CAN_FD_FRAME) == (mh->flags & CAN_FD_FRAME)) { 759 + 760 + /* disable automatic timer on frame reception */ 761 + op->flags |= RX_NO_AUTOTIMER; 767 762 768 763 /* 769 764 * Don't care if we're bound or not (due to netdev ··· 796 785 bcm_rx_handler, op); 797 786 798 787 list_del(&op->list); 799 - synchronize_rcu(); 800 788 bcm_remove_op(op); 801 789 return 1; /* done */ 802 790 }