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-next-for-6.18-20250924' of git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can-next

Marc Kleine-Budde says:

====================
pull-request: can-next 2025-09-25

this is a pull request of 48 patches for net-next/main, which
supersedes tags/linux-can-next-for-6.18-20250923.

The 1st patch is by Xichao Zhao and converts ns_to_ktime() to
us_to_ktime() in the m_can driver.

Vincent Mailhol contributes 2 patches: Updating the MAINTAINERS and
mailmap files to Vincent's new email address and sorting the includes
in the CAN helper library alphabeticaly.

Stéphane Grosjean's patch modifies all peak CAN drivers and the
mailmap to reflect Stéphane's new email address.

4 patches by Biju Das update the CAN-FD handling in the rcar_canfd
driver.

Followed by 11 patches by Geert Uytterhoeven updating and improving
the rcar_can driver.

Stefan Mätje contributes 2 patches for the esd_usb driver updating the
error messages.

The next 3 patch series are all by Vincent Mailhol: 3 patches to
optimize the size of struct raw_sock and struct uniqframe. 4 patches
which rework the CAN MTU logic as preparation for CAN-XL interfaces.
And finally 20 patches that prepare and refactor the CAN netlink code
for the upcoming CAN-XL support.

* tag 'linux-can-next-for-6.18-20250924' of git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can-next: (48 commits)
can: netlink: add userland error messages
can: dev: add can_get_ctrlmode_str()
can: calc_bittiming: make can_calc_tdco() FD agnostic
can: netlink: make can_tdc_fill_info() FD agnostic
can: netlink: add can_bitrate_const_fill_info()
can: netlink: add can_bittiming_const_fill_info()
can: netlink: add can_bittiming_fill_info()
can: netlink: add can_data_bittiming_get_size()
can: netlink: make can_tdc_get_size() FD agnostic
can: netlink: add can_ctrlmode_changelink()
can: netlink: add can_dtb_changelink()
can: netlink: make can_tdc_changelink() FD agnostic
can: netlink: remove useless check in can_tdc_changelink()
can: netlink: refactor CAN_CTRLMODE_TDC_{AUTO,MANUAL} flag reset logic
can: netlink: add can_validate_databittiming()
can: netlink: add can_validate_tdc()
can: netlink: refactor can_validate_bittiming()
can: netlink: document which symbols are FD specific
can: dev: make can_get_relative_tdco() FD agnostic and move it to bittiming.h
can: dev: move struct data_bittiming_params to linux/can/bittiming.h
...
====================

Link: https://patch.msgid.link/20250925121332.848157-1-mkl@pengutronix.de
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

Jakub Kicinski bb9a242c ed6cfe86

+848 -583
+3
.mailmap
··· 741 741 Stanislav Fomichev <sdf@fomichev.me> <sdf@google.com> 742 742 Stanislav Fomichev <sdf@fomichev.me> <stfomichev@gmail.com> 743 743 Stefan Wahren <wahrenst@gmx.net> <stefan.wahren@i2se.com> 744 + Stéphane Grosjean <stephane.grosjean@hms-networks.com> <s.grosjean@peak-system.com> 745 + Stéphane Grosjean <stephane.grosjean@hms-networks.com> <stephane.grosjean@free.fr> 744 746 Stéphane Witzmann <stephane.witzmann@ubpmes.univ-bpclermont.fr> 745 747 Stephen Hemminger <stephen@networkplumber.org> <shemminger@linux-foundation.org> 746 748 Stephen Hemminger <stephen@networkplumber.org> <shemminger@osdl.org> ··· 819 817 Veerabhadrarao Badiganti <quic_vbadigan@quicinc.com> <vbadigan@codeaurora.org> 820 818 Venkateswara Naralasetty <quic_vnaralas@quicinc.com> <vnaralas@codeaurora.org> 821 819 Vikash Garodia <quic_vgarodia@quicinc.com> <vgarodia@codeaurora.org> 820 + Vincent Mailhol <mailhol@kernel.org> <mailhol.vincent@wanadoo.fr> 822 821 Vinod Koul <vkoul@kernel.org> <vinod.koul@intel.com> 823 822 Vinod Koul <vkoul@kernel.org> <vinod.koul@linux.intel.com> 824 823 Vinod Koul <vkoul@kernel.org> <vkoul@infradead.org>
+2 -2
MAINTAINERS
··· 5415 5415 5416 5416 CAN NETWORK DRIVERS 5417 5417 M: Marc Kleine-Budde <mkl@pengutronix.de> 5418 - M: Vincent Mailhol <mailhol.vincent@wanadoo.fr> 5418 + M: Vincent Mailhol <mailhol@kernel.org> 5419 5419 L: linux-can@vger.kernel.org 5420 5420 S: Maintained 5421 5421 W: https://github.com/linux-can ··· 9094 9094 F: drivers/net/ethernet/agere/ 9095 9095 9096 9096 ETAS ES58X CAN/USB DRIVER 9097 - M: Vincent Mailhol <mailhol.vincent@wanadoo.fr> 9097 + M: Vincent Mailhol <mailhol@kernel.org> 9098 9098 L: linux-can@vger.kernel.org 9099 9099 S: Maintained 9100 9100 F: Documentation/networking/devlink/etas_es58x.rst
+6 -4
drivers/net/can/dev/calc_bittiming.c
··· 173 173 174 174 void can_calc_tdco(struct can_tdc *tdc, const struct can_tdc_const *tdc_const, 175 175 const struct can_bittiming *dbt, 176 - u32 *ctrlmode, u32 ctrlmode_supported) 176 + u32 tdc_mask, u32 *ctrlmode, u32 ctrlmode_supported) 177 177 178 178 { 179 - if (!tdc_const || !(ctrlmode_supported & CAN_CTRLMODE_TDC_AUTO)) 179 + u32 tdc_auto = tdc_mask & CAN_CTRLMODE_TDC_AUTO_MASK; 180 + 181 + if (!tdc_const || !(ctrlmode_supported & tdc_auto)) 180 182 return; 181 183 182 - *ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK; 184 + *ctrlmode &= ~tdc_mask; 183 185 184 186 /* As specified in ISO 11898-1 section 11.3.3 "Transmitter 185 187 * delay compensation" (TDC) is only applicable if data BRP is ··· 195 193 if (sample_point_in_tc < tdc_const->tdco_min) 196 194 return; 197 195 tdc->tdco = min(sample_point_in_tc, tdc_const->tdco_max); 198 - *ctrlmode |= CAN_CTRLMODE_TDC_AUTO; 196 + *ctrlmode |= tdc_auto; 199 197 } 200 198 }
+75 -5
drivers/net/can/dev/dev.c
··· 4 4 * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com> 5 5 */ 6 6 7 - #include <linux/kernel.h> 8 - #include <linux/slab.h> 9 - #include <linux/netdevice.h> 10 - #include <linux/if_arp.h> 11 - #include <linux/workqueue.h> 12 7 #include <linux/can.h> 13 8 #include <linux/can/can-ml.h> 14 9 #include <linux/can/dev.h> 15 10 #include <linux/can/skb.h> 16 11 #include <linux/gpio/consumer.h> 12 + #include <linux/if_arp.h> 13 + #include <linux/kernel.h> 14 + #include <linux/netdevice.h> 17 15 #include <linux/of.h> 16 + #include <linux/slab.h> 17 + #include <linux/workqueue.h> 18 18 19 19 static void can_update_state_error_stats(struct net_device *dev, 20 20 enum can_state new_state) ··· 87 87 } 88 88 } 89 89 EXPORT_SYMBOL_GPL(can_get_state_str); 90 + 91 + const char *can_get_ctrlmode_str(u32 ctrlmode) 92 + { 93 + switch (ctrlmode & ~(ctrlmode - 1)) { 94 + case 0: 95 + return "none"; 96 + case CAN_CTRLMODE_LOOPBACK: 97 + return "loopback"; 98 + case CAN_CTRLMODE_LISTENONLY: 99 + return "listen-only"; 100 + case CAN_CTRLMODE_3_SAMPLES: 101 + return "triple-sampling"; 102 + case CAN_CTRLMODE_ONE_SHOT: 103 + return "one-shot"; 104 + case CAN_CTRLMODE_BERR_REPORTING: 105 + return "berr-reporting"; 106 + case CAN_CTRLMODE_FD: 107 + return "fd"; 108 + case CAN_CTRLMODE_PRESUME_ACK: 109 + return "presume-ack"; 110 + case CAN_CTRLMODE_FD_NON_ISO: 111 + return "fd-non-iso"; 112 + case CAN_CTRLMODE_CC_LEN8_DLC: 113 + return "cc-len8-dlc"; 114 + case CAN_CTRLMODE_TDC_AUTO: 115 + return "fd-tdc-auto"; 116 + case CAN_CTRLMODE_TDC_MANUAL: 117 + return "fd-tdc-manual"; 118 + default: 119 + return "<unknown>"; 120 + } 121 + } 122 + EXPORT_SYMBOL_GPL(can_get_ctrlmode_str); 90 123 91 124 static enum can_state can_state_err_to_state(u16 err) 92 125 { ··· 273 240 { 274 241 dev->type = ARPHRD_CAN; 275 242 dev->mtu = CAN_MTU; 243 + dev->min_mtu = CAN_MTU; 244 + dev->max_mtu = CAN_MTU; 276 245 dev->hard_header_len = 0; 277 246 dev->addr_len = 0; 278 247 dev->tx_queue_len = 10; ··· 344 309 } 345 310 EXPORT_SYMBOL_GPL(free_candev); 346 311 312 + void can_set_default_mtu(struct net_device *dev) 313 + { 314 + struct can_priv *priv = netdev_priv(dev); 315 + 316 + if (priv->ctrlmode & CAN_CTRLMODE_FD) { 317 + dev->mtu = CANFD_MTU; 318 + dev->min_mtu = CANFD_MTU; 319 + dev->max_mtu = CANFD_MTU; 320 + } else { 321 + dev->mtu = CAN_MTU; 322 + dev->min_mtu = CAN_MTU; 323 + dev->max_mtu = CAN_MTU; 324 + } 325 + } 326 + 347 327 /* changing MTU and control mode for CAN/CANFD devices */ 348 328 int can_change_mtu(struct net_device *dev, int new_mtu) 349 329 { ··· 396 346 return 0; 397 347 } 398 348 EXPORT_SYMBOL_GPL(can_change_mtu); 349 + 350 + /* helper to define static CAN controller features at device creation time */ 351 + int can_set_static_ctrlmode(struct net_device *dev, u32 static_mode) 352 + { 353 + struct can_priv *priv = netdev_priv(dev); 354 + 355 + /* alloc_candev() succeeded => netdev_priv() is valid at this point */ 356 + if (priv->ctrlmode_supported & static_mode) { 357 + netdev_warn(dev, 358 + "Controller features can not be supported and static at the same time\n"); 359 + return -EINVAL; 360 + } 361 + priv->ctrlmode = static_mode; 362 + 363 + /* override MTU which was set by default in can_setup()? */ 364 + can_set_default_mtu(dev); 365 + 366 + return 0; 367 + } 368 + EXPORT_SYMBOL_GPL(can_set_static_ctrlmode); 399 369 400 370 /* generic implementation of netdev_ops::ndo_eth_ioctl for CAN devices 401 371 * supporting hardware timestamps
+391 -237
drivers/net/can/dev/netlink.c
··· 36 36 [IFLA_CAN_TDC_TDCF] = { .type = NLA_U32 }, 37 37 }; 38 38 39 - static int can_validate_bittiming(const struct can_bittiming *bt, 40 - struct netlink_ext_ack *extack) 39 + static int can_validate_bittiming(struct nlattr *data[], 40 + struct netlink_ext_ack *extack, 41 + int ifla_can_bittiming) 41 42 { 43 + struct can_bittiming *bt; 44 + 45 + if (!data[ifla_can_bittiming]) 46 + return 0; 47 + 48 + static_assert(__alignof__(*bt) <= NLA_ALIGNTO); 49 + bt = nla_data(data[ifla_can_bittiming]); 50 + 42 51 /* sample point is in one-tenth of a percent */ 43 52 if (bt->sample_point >= 1000) { 44 53 NL_SET_ERR_MSG(extack, "sample point must be between 0 and 100%"); 45 - 46 54 return -EINVAL; 47 55 } 56 + 57 + return 0; 58 + } 59 + 60 + static int can_validate_tdc(struct nlattr *data_tdc, 61 + struct netlink_ext_ack *extack, u32 tdc_flags) 62 + { 63 + bool tdc_manual = tdc_flags & CAN_CTRLMODE_TDC_MANUAL_MASK; 64 + bool tdc_auto = tdc_flags & CAN_CTRLMODE_TDC_AUTO_MASK; 65 + int err; 66 + 67 + if (tdc_auto && tdc_manual) { 68 + NL_SET_ERR_MSG(extack, 69 + "TDC manual and auto modes are mutually exclusive"); 70 + return -EOPNOTSUPP; 71 + } 72 + 73 + /* If one of the CAN_CTRLMODE_TDC_* flag is set then TDC 74 + * must be set and vice-versa 75 + */ 76 + if ((tdc_auto || tdc_manual) && !data_tdc) { 77 + NL_SET_ERR_MSG(extack, "TDC parameters are missing"); 78 + return -EOPNOTSUPP; 79 + } 80 + if (!(tdc_auto || tdc_manual) && data_tdc) { 81 + NL_SET_ERR_MSG(extack, "TDC mode (auto or manual) is missing"); 82 + return -EOPNOTSUPP; 83 + } 84 + 85 + /* If providing TDC parameters, at least TDCO is needed. TDCV 86 + * is needed if and only if CAN_CTRLMODE_TDC_MANUAL is set 87 + */ 88 + if (data_tdc) { 89 + struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1]; 90 + 91 + err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, 92 + data_tdc, can_tdc_policy, extack); 93 + if (err) 94 + return err; 95 + 96 + if (tb_tdc[IFLA_CAN_TDC_TDCV]) { 97 + if (tdc_auto) { 98 + NL_SET_ERR_MSG(extack, 99 + "TDCV is incompatible with TDC auto mode"); 100 + return -EOPNOTSUPP; 101 + } 102 + } else { 103 + if (tdc_manual) { 104 + NL_SET_ERR_MSG(extack, 105 + "TDC manual mode requires TDCV"); 106 + return -EOPNOTSUPP; 107 + } 108 + } 109 + 110 + if (!tb_tdc[IFLA_CAN_TDC_TDCO]) { 111 + NL_SET_ERR_MSG(extack, "TDCO is missing"); 112 + return -EOPNOTSUPP; 113 + } 114 + } 115 + 116 + return 0; 117 + } 118 + 119 + static int can_validate_databittiming(struct nlattr *data[], 120 + struct netlink_ext_ack *extack, 121 + int ifla_can_data_bittiming, u32 flags) 122 + { 123 + struct nlattr *data_tdc; 124 + const char *type; 125 + u32 tdc_flags; 126 + bool is_on; 127 + int err; 128 + 129 + /* Make sure that valid CAN FD configurations always consist of 130 + * - nominal/arbitration bittiming 131 + * - data bittiming 132 + * - control mode with CAN_CTRLMODE_FD set 133 + * - TDC parameters are coherent (details in can_validate_tdc()) 134 + */ 135 + 136 + if (ifla_can_data_bittiming == IFLA_CAN_DATA_BITTIMING) { 137 + data_tdc = data[IFLA_CAN_TDC]; 138 + tdc_flags = flags & CAN_CTRLMODE_FD_TDC_MASK; 139 + is_on = flags & CAN_CTRLMODE_FD; 140 + type = "FD"; 141 + } else { 142 + return -EOPNOTSUPP; /* Place holder for CAN XL */ 143 + } 144 + 145 + if (is_on) { 146 + if (!data[IFLA_CAN_BITTIMING] || !data[ifla_can_data_bittiming]) { 147 + NL_SET_ERR_MSG_FMT(extack, 148 + "Provide both nominal and %s data bittiming", 149 + type); 150 + return -EOPNOTSUPP; 151 + } 152 + } else { 153 + if (data[ifla_can_data_bittiming]) { 154 + NL_SET_ERR_MSG_FMT(extack, 155 + "%s data bittiming requires CAN %s", 156 + type, type); 157 + return -EOPNOTSUPP; 158 + } 159 + if (data_tdc) { 160 + NL_SET_ERR_MSG_FMT(extack, 161 + "%s TDC requires CAN %s", 162 + type, type); 163 + return -EOPNOTSUPP; 164 + } 165 + } 166 + 167 + err = can_validate_bittiming(data, extack, ifla_can_data_bittiming); 168 + if (err) 169 + return err; 170 + 171 + err = can_validate_tdc(data_tdc, extack, tdc_flags); 172 + if (err) 173 + return err; 48 174 49 175 return 0; 50 176 } ··· 178 52 static int can_validate(struct nlattr *tb[], struct nlattr *data[], 179 53 struct netlink_ext_ack *extack) 180 54 { 181 - bool is_can_fd = false; 55 + u32 flags = 0; 182 56 int err; 183 - 184 - /* Make sure that valid CAN FD configurations always consist of 185 - * - nominal/arbitration bittiming 186 - * - data bittiming 187 - * - control mode with CAN_CTRLMODE_FD set 188 - * - TDC parameters are coherent (details below) 189 - */ 190 57 191 58 if (!data) 192 59 return 0; 193 60 194 61 if (data[IFLA_CAN_CTRLMODE]) { 195 62 struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]); 196 - u32 tdc_flags = cm->flags & CAN_CTRLMODE_FD_TDC_MASK; 197 63 198 - is_can_fd = cm->flags & cm->mask & CAN_CTRLMODE_FD; 199 - 200 - /* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually exclusive */ 201 - if (tdc_flags == CAN_CTRLMODE_FD_TDC_MASK) 202 - return -EOPNOTSUPP; 203 - /* If one of the CAN_CTRLMODE_TDC_* flag is set then 204 - * TDC must be set and vice-versa 205 - */ 206 - if (!!tdc_flags != !!data[IFLA_CAN_TDC]) 207 - return -EOPNOTSUPP; 208 - /* If providing TDC parameters, at least TDCO is 209 - * needed. TDCV is needed if and only if 210 - * CAN_CTRLMODE_TDC_MANUAL is set 211 - */ 212 - if (data[IFLA_CAN_TDC]) { 213 - struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1]; 214 - 215 - err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, 216 - data[IFLA_CAN_TDC], 217 - can_tdc_policy, extack); 218 - if (err) 219 - return err; 220 - 221 - if (tb_tdc[IFLA_CAN_TDC_TDCV]) { 222 - if (tdc_flags & CAN_CTRLMODE_TDC_AUTO) 223 - return -EOPNOTSUPP; 224 - } else { 225 - if (tdc_flags & CAN_CTRLMODE_TDC_MANUAL) 226 - return -EOPNOTSUPP; 227 - } 228 - 229 - if (!tb_tdc[IFLA_CAN_TDC_TDCO]) 230 - return -EOPNOTSUPP; 231 - } 64 + flags = cm->flags & cm->mask; 232 65 } 233 66 234 - if (data[IFLA_CAN_BITTIMING]) { 235 - struct can_bittiming bt; 67 + err = can_validate_bittiming(data, extack, IFLA_CAN_BITTIMING); 68 + if (err) 69 + return err; 236 70 237 - memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt)); 238 - err = can_validate_bittiming(&bt, extack); 239 - if (err) 240 - return err; 241 - } 242 - 243 - if (is_can_fd) { 244 - if (!data[IFLA_CAN_BITTIMING] || !data[IFLA_CAN_DATA_BITTIMING]) 245 - return -EOPNOTSUPP; 246 - } 247 - 248 - if (data[IFLA_CAN_DATA_BITTIMING] || data[IFLA_CAN_TDC]) { 249 - if (!is_can_fd) 250 - return -EOPNOTSUPP; 251 - } 252 - 253 - if (data[IFLA_CAN_DATA_BITTIMING]) { 254 - struct can_bittiming bt; 255 - 256 - memcpy(&bt, nla_data(data[IFLA_CAN_DATA_BITTIMING]), sizeof(bt)); 257 - err = can_validate_bittiming(&bt, extack); 258 - if (err) 259 - return err; 260 - } 71 + err = can_validate_databittiming(data, extack, 72 + IFLA_CAN_DATA_BITTIMING, flags); 73 + if (err) 74 + return err; 261 75 262 76 return 0; 263 77 } 264 78 265 - static int can_tdc_changelink(struct can_priv *priv, const struct nlattr *nla, 79 + static int can_ctrlmode_changelink(struct net_device *dev, 80 + struct nlattr *data[], 81 + struct netlink_ext_ack *extack) 82 + { 83 + struct can_priv *priv = netdev_priv(dev); 84 + struct can_ctrlmode *cm; 85 + u32 ctrlstatic, maskedflags, notsupp, ctrlstatic_missing; 86 + 87 + if (!data[IFLA_CAN_CTRLMODE]) 88 + return 0; 89 + 90 + /* Do not allow changing controller mode while running */ 91 + if (dev->flags & IFF_UP) 92 + return -EBUSY; 93 + 94 + cm = nla_data(data[IFLA_CAN_CTRLMODE]); 95 + ctrlstatic = can_get_static_ctrlmode(priv); 96 + maskedflags = cm->flags & cm->mask; 97 + notsupp = maskedflags & ~(priv->ctrlmode_supported | ctrlstatic); 98 + ctrlstatic_missing = (maskedflags & ctrlstatic) ^ ctrlstatic; 99 + 100 + if (notsupp) { 101 + NL_SET_ERR_MSG_FMT(extack, 102 + "requested control mode %s not supported", 103 + can_get_ctrlmode_str(notsupp)); 104 + return -EOPNOTSUPP; 105 + } 106 + 107 + /* do not check for static fd-non-iso if 'fd' is disabled */ 108 + if (!(maskedflags & CAN_CTRLMODE_FD)) 109 + ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO; 110 + 111 + if (ctrlstatic_missing) { 112 + NL_SET_ERR_MSG_FMT(extack, 113 + "missing required %s static control mode", 114 + can_get_ctrlmode_str(ctrlstatic_missing)); 115 + return -EOPNOTSUPP; 116 + } 117 + 118 + /* If a top dependency flag is provided, reset all its dependencies */ 119 + if (cm->mask & CAN_CTRLMODE_FD) 120 + priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK; 121 + 122 + /* clear bits to be modified and copy the flag values */ 123 + priv->ctrlmode &= ~cm->mask; 124 + priv->ctrlmode |= maskedflags; 125 + 126 + /* Wipe potential leftovers from previous CAN FD config */ 127 + if (!(priv->ctrlmode & CAN_CTRLMODE_FD)) { 128 + memset(&priv->fd.data_bittiming, 0, 129 + sizeof(priv->fd.data_bittiming)); 130 + priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK; 131 + memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc)); 132 + } 133 + 134 + can_set_default_mtu(dev); 135 + 136 + return 0; 137 + } 138 + 139 + static int can_tdc_changelink(struct data_bittiming_params *dbt_params, 140 + const struct nlattr *nla, 266 141 struct netlink_ext_ack *extack) 267 142 { 268 143 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1]; 269 144 struct can_tdc tdc = { 0 }; 270 - const struct can_tdc_const *tdc_const = priv->fd.tdc_const; 145 + const struct can_tdc_const *tdc_const = dbt_params->tdc_const; 271 146 int err; 272 147 273 - if (!tdc_const || !can_fd_tdc_is_enabled(priv)) 148 + if (!tdc_const) { 149 + NL_SET_ERR_MSG(extack, "The device does not support TDC"); 274 150 return -EOPNOTSUPP; 151 + } 275 152 276 153 err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, nla, 277 154 can_tdc_policy, extack); ··· 308 179 tdc.tdcf = tdcf; 309 180 } 310 181 311 - priv->fd.tdc = tdc; 182 + dbt_params->tdc = tdc; 183 + 184 + return 0; 185 + } 186 + 187 + static int can_dbt_changelink(struct net_device *dev, struct nlattr *data[], 188 + bool fd, struct netlink_ext_ack *extack) 189 + { 190 + struct nlattr *data_bittiming, *data_tdc; 191 + struct can_priv *priv = netdev_priv(dev); 192 + struct data_bittiming_params *dbt_params; 193 + struct can_bittiming dbt; 194 + bool need_tdc_calc = false; 195 + u32 tdc_mask; 196 + int err; 197 + 198 + if (fd) { 199 + data_bittiming = data[IFLA_CAN_DATA_BITTIMING]; 200 + data_tdc = data[IFLA_CAN_TDC]; 201 + dbt_params = &priv->fd; 202 + tdc_mask = CAN_CTRLMODE_FD_TDC_MASK; 203 + } else { 204 + return -EOPNOTSUPP; /* Place holder for CAN XL */ 205 + } 206 + 207 + if (!data_bittiming) 208 + return 0; 209 + 210 + /* Do not allow changing bittiming while running */ 211 + if (dev->flags & IFF_UP) 212 + return -EBUSY; 213 + 214 + /* Calculate bittiming parameters based on data_bittiming_const 215 + * if set, otherwise pass bitrate directly via do_set_bitrate(). 216 + * Bail out if neither is given. 217 + */ 218 + if (!dbt_params->data_bittiming_const && !dbt_params->do_set_data_bittiming && 219 + !dbt_params->data_bitrate_const) 220 + return -EOPNOTSUPP; 221 + 222 + memcpy(&dbt, nla_data(data_bittiming), sizeof(dbt)); 223 + err = can_get_bittiming(dev, &dbt, dbt_params->data_bittiming_const, 224 + dbt_params->data_bitrate_const, 225 + dbt_params->data_bitrate_const_cnt, extack); 226 + if (err) 227 + return err; 228 + 229 + if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) { 230 + NL_SET_ERR_MSG_FMT(extack, 231 + "CAN data bitrate %u bps surpasses transceiver capabilities of %u bps", 232 + dbt.bitrate, priv->bitrate_max); 233 + return -EINVAL; 234 + } 235 + 236 + memset(&dbt_params->tdc, 0, sizeof(dbt_params->tdc)); 237 + if (data[IFLA_CAN_CTRLMODE]) { 238 + struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]); 239 + 240 + need_tdc_calc = !(cm->mask & tdc_mask); 241 + } 242 + if (data_tdc) { 243 + /* TDC parameters are provided: use them */ 244 + err = can_tdc_changelink(dbt_params, data_tdc, extack); 245 + if (err) { 246 + priv->ctrlmode &= ~tdc_mask; 247 + return err; 248 + } 249 + } else if (need_tdc_calc) { 250 + /* Neither of TDC parameters nor TDC flags are provided: 251 + * do calculation 252 + */ 253 + can_calc_tdco(&dbt_params->tdc, dbt_params->tdc_const, &dbt, 254 + tdc_mask, &priv->ctrlmode, priv->ctrlmode_supported); 255 + } /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly 256 + * turned off. TDC is disabled: do nothing 257 + */ 258 + 259 + memcpy(&dbt_params->data_bittiming, &dbt, sizeof(dbt)); 260 + 261 + if (dbt_params->do_set_data_bittiming) { 262 + /* Finally, set the bit-timing registers */ 263 + err = dbt_params->do_set_data_bittiming(dev); 264 + if (err) 265 + return err; 266 + } 312 267 313 268 return 0; 314 269 } ··· 402 189 struct netlink_ext_ack *extack) 403 190 { 404 191 struct can_priv *priv = netdev_priv(dev); 405 - bool fd_tdc_flag_provided = false; 406 192 int err; 407 193 408 194 /* We need synchronization with dev->stop() */ 409 195 ASSERT_RTNL(); 410 196 411 - if (data[IFLA_CAN_CTRLMODE]) { 412 - struct can_ctrlmode *cm; 413 - u32 ctrlstatic; 414 - u32 maskedflags; 415 - 416 - /* Do not allow changing controller mode while running */ 417 - if (dev->flags & IFF_UP) 418 - return -EBUSY; 419 - cm = nla_data(data[IFLA_CAN_CTRLMODE]); 420 - ctrlstatic = can_get_static_ctrlmode(priv); 421 - maskedflags = cm->flags & cm->mask; 422 - 423 - /* check whether provided bits are allowed to be passed */ 424 - if (maskedflags & ~(priv->ctrlmode_supported | ctrlstatic)) 425 - return -EOPNOTSUPP; 426 - 427 - /* do not check for static fd-non-iso if 'fd' is disabled */ 428 - if (!(maskedflags & CAN_CTRLMODE_FD)) 429 - ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO; 430 - 431 - /* make sure static options are provided by configuration */ 432 - if ((maskedflags & ctrlstatic) != ctrlstatic) 433 - return -EOPNOTSUPP; 434 - 435 - /* clear bits to be modified and copy the flag values */ 436 - priv->ctrlmode &= ~cm->mask; 437 - priv->ctrlmode |= maskedflags; 438 - 439 - /* CAN_CTRLMODE_FD can only be set when driver supports FD */ 440 - if (priv->ctrlmode & CAN_CTRLMODE_FD) { 441 - dev->mtu = CANFD_MTU; 442 - } else { 443 - dev->mtu = CAN_MTU; 444 - memset(&priv->fd.data_bittiming, 0, 445 - sizeof(priv->fd.data_bittiming)); 446 - priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK; 447 - memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc)); 448 - } 449 - 450 - fd_tdc_flag_provided = cm->mask & CAN_CTRLMODE_FD_TDC_MASK; 451 - /* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually 452 - * exclusive: make sure to turn the other one off 453 - */ 454 - if (fd_tdc_flag_provided) 455 - priv->ctrlmode &= cm->flags | ~CAN_CTRLMODE_FD_TDC_MASK; 456 - } 197 + can_ctrlmode_changelink(dev, data, extack); 457 198 458 199 if (data[IFLA_CAN_BITTIMING]) { 459 200 struct can_bittiming bt; ··· 479 312 return err; 480 313 } 481 314 482 - if (data[IFLA_CAN_DATA_BITTIMING]) { 483 - struct can_bittiming dbt; 484 - 485 - /* Do not allow changing bittiming while running */ 486 - if (dev->flags & IFF_UP) 487 - return -EBUSY; 488 - 489 - /* Calculate bittiming parameters based on 490 - * data_bittiming_const if set, otherwise pass bitrate 491 - * directly via do_set_bitrate(). Bail out if neither 492 - * is given. 493 - */ 494 - if (!priv->fd.data_bittiming_const && !priv->fd.do_set_data_bittiming && 495 - !priv->fd.data_bitrate_const) 496 - return -EOPNOTSUPP; 497 - 498 - memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]), 499 - sizeof(dbt)); 500 - err = can_get_bittiming(dev, &dbt, 501 - priv->fd.data_bittiming_const, 502 - priv->fd.data_bitrate_const, 503 - priv->fd.data_bitrate_const_cnt, 504 - extack); 505 - if (err) 506 - return err; 507 - 508 - if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) { 509 - NL_SET_ERR_MSG_FMT(extack, 510 - "CANFD data bitrate %u bps surpasses transceiver capabilities of %u bps", 511 - dbt.bitrate, priv->bitrate_max); 512 - return -EINVAL; 513 - } 514 - 515 - memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc)); 516 - if (data[IFLA_CAN_TDC]) { 517 - /* TDC parameters are provided: use them */ 518 - err = can_tdc_changelink(priv, data[IFLA_CAN_TDC], 519 - extack); 520 - if (err) { 521 - priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK; 522 - return err; 523 - } 524 - } else if (!fd_tdc_flag_provided) { 525 - /* Neither of TDC parameters nor TDC flags are 526 - * provided: do calculation 527 - */ 528 - can_calc_tdco(&priv->fd.tdc, priv->fd.tdc_const, &dbt, 529 - &priv->ctrlmode, priv->ctrlmode_supported); 530 - } /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly 531 - * turned off. TDC is disabled: do nothing 532 - */ 533 - 534 - memcpy(&priv->fd.data_bittiming, &dbt, sizeof(dbt)); 535 - 536 - if (priv->fd.do_set_data_bittiming) { 537 - /* Finally, set the bit-timing registers */ 538 - err = priv->fd.do_set_data_bittiming(dev); 539 - if (err) 540 - return err; 541 - } 542 - } 315 + /* CAN FD */ 316 + err = can_dbt_changelink(dev, data, true, extack); 317 + if (err) 318 + return err; 543 319 544 320 if (data[IFLA_CAN_TERMINATION]) { 545 321 const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]); 546 322 const unsigned int num_term = priv->termination_const_cnt; 547 323 unsigned int i; 548 324 549 - if (!priv->do_set_termination) 325 + if (!priv->do_set_termination) { 326 + NL_SET_ERR_MSG(extack, 327 + "Termination is not configurable on this device"); 550 328 return -EOPNOTSUPP; 329 + } 551 330 552 331 /* check whether given value is supported by the interface */ 553 332 for (i = 0; i < num_term; i++) { ··· 514 401 return 0; 515 402 } 516 403 517 - static size_t can_tdc_get_size(const struct net_device *dev) 404 + static size_t can_tdc_get_size(struct data_bittiming_params *dbt_params, 405 + u32 tdc_flags) 518 406 { 519 - struct can_priv *priv = netdev_priv(dev); 407 + bool tdc_manual = tdc_flags & CAN_CTRLMODE_TDC_MANUAL_MASK; 520 408 size_t size; 521 409 522 - if (!priv->fd.tdc_const) 410 + if (!dbt_params->tdc_const) 523 411 return 0; 524 412 525 413 size = nla_total_size(0); /* nest IFLA_CAN_TDC */ 526 - if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL) { 414 + if (tdc_manual) { 527 415 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MIN */ 528 416 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MAX */ 529 417 } 530 418 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MIN */ 531 419 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MAX */ 532 - if (priv->fd.tdc_const->tdcf_max) { 420 + if (dbt_params->tdc_const->tdcf_max) { 533 421 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MIN */ 534 422 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MAX */ 535 423 } 536 424 537 - if (can_fd_tdc_is_enabled(priv)) { 538 - if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL || 539 - priv->fd.do_get_auto_tdcv) 425 + if (tdc_flags) { 426 + if (tdc_manual || dbt_params->do_get_auto_tdcv) 540 427 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV */ 541 428 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO */ 542 - if (priv->fd.tdc_const->tdcf_max) 429 + if (dbt_params->tdc_const->tdcf_max) 543 430 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF */ 544 431 } 432 + 433 + return size; 434 + } 435 + 436 + static size_t can_data_bittiming_get_size(struct data_bittiming_params *dbt_params, 437 + u32 tdc_flags) 438 + { 439 + size_t size = 0; 440 + 441 + if (dbt_params->data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */ 442 + size += nla_total_size(sizeof(dbt_params->data_bittiming)); 443 + if (dbt_params->data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */ 444 + size += nla_total_size(sizeof(*dbt_params->data_bittiming_const)); 445 + if (dbt_params->data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */ 446 + size += nla_total_size(sizeof(*dbt_params->data_bitrate_const) * 447 + dbt_params->data_bitrate_const_cnt); 448 + size += can_tdc_get_size(dbt_params, tdc_flags);/* IFLA_CAN_TDC */ 545 449 546 450 return size; 547 451 } ··· 584 454 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */ 585 455 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */ 586 456 size += nla_total_size(sizeof(struct can_berr_counter)); 587 - if (priv->fd.data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */ 588 - size += nla_total_size(sizeof(struct can_bittiming)); 589 - if (priv->fd.data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */ 590 - size += nla_total_size(sizeof(struct can_bittiming_const)); 591 457 if (priv->termination_const) { 592 458 size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */ 593 459 size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */ ··· 592 466 if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */ 593 467 size += nla_total_size(sizeof(*priv->bitrate_const) * 594 468 priv->bitrate_const_cnt); 595 - if (priv->fd.data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */ 596 - size += nla_total_size(sizeof(*priv->fd.data_bitrate_const) * 597 - priv->fd.data_bitrate_const_cnt); 598 469 size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */ 599 - size += can_tdc_get_size(dev); /* IFLA_CAN_TDC */ 600 470 size += can_ctrlmode_ext_get_size(); /* IFLA_CAN_CTRLMODE_EXT */ 471 + 472 + size += can_data_bittiming_get_size(&priv->fd, 473 + priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK); 601 474 602 475 return size; 603 476 } 604 477 605 - static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev) 478 + static int can_bittiming_fill_info(struct sk_buff *skb, int ifla_can_bittiming, 479 + struct can_bittiming *bittiming) 606 480 { 607 - struct nlattr *nest; 481 + return bittiming->bitrate != CAN_BITRATE_UNSET && 482 + bittiming->bitrate != CAN_BITRATE_UNKNOWN && 483 + nla_put(skb, ifla_can_bittiming, sizeof(*bittiming), bittiming); 484 + } 485 + 486 + static int can_bittiming_const_fill_info(struct sk_buff *skb, 487 + int ifla_can_bittiming_const, 488 + const struct can_bittiming_const *bittiming_const) 489 + { 490 + return bittiming_const && 491 + nla_put(skb, ifla_can_bittiming_const, 492 + sizeof(*bittiming_const), bittiming_const); 493 + } 494 + 495 + static int can_bitrate_const_fill_info(struct sk_buff *skb, 496 + int ifla_can_bitrate_const, 497 + const u32 *bitrate_const, unsigned int cnt) 498 + { 499 + return bitrate_const && 500 + nla_put(skb, ifla_can_bitrate_const, 501 + sizeof(*bitrate_const) * cnt, bitrate_const); 502 + } 503 + 504 + static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev, 505 + int ifla_can_tdc) 506 + { 608 507 struct can_priv *priv = netdev_priv(dev); 609 - struct can_tdc *tdc = &priv->fd.tdc; 610 - const struct can_tdc_const *tdc_const = priv->fd.tdc_const; 508 + struct data_bittiming_params *dbt_params; 509 + const struct can_tdc_const *tdc_const; 510 + struct can_tdc *tdc; 511 + struct nlattr *nest; 512 + bool tdc_is_enabled, tdc_manual; 513 + 514 + if (ifla_can_tdc == IFLA_CAN_TDC) { 515 + dbt_params = &priv->fd; 516 + tdc_is_enabled = can_fd_tdc_is_enabled(priv); 517 + tdc_manual = priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL; 518 + } else { 519 + return -EOPNOTSUPP; /* Place holder for CAN XL */ 520 + } 521 + tdc_const = dbt_params->tdc_const; 522 + tdc = &dbt_params->tdc; 611 523 612 524 if (!tdc_const) 613 525 return 0; 614 526 615 - nest = nla_nest_start(skb, IFLA_CAN_TDC); 527 + nest = nla_nest_start(skb, ifla_can_tdc); 616 528 if (!nest) 617 529 return -EMSGSIZE; 618 530 619 - if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL && 531 + if (tdc_manual && 620 532 (nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MIN, tdc_const->tdcv_min) || 621 533 nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MAX, tdc_const->tdcv_max))) 622 534 goto err_cancel; ··· 666 502 nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max))) 667 503 goto err_cancel; 668 504 669 - if (can_fd_tdc_is_enabled(priv)) { 505 + if (tdc_is_enabled) { 670 506 u32 tdcv; 671 507 int err = -EINVAL; 672 508 673 - if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL) { 509 + if (tdc_manual) { 674 510 tdcv = tdc->tdcv; 675 511 err = 0; 676 - } else if (priv->fd.do_get_auto_tdcv) { 677 - err = priv->fd.do_get_auto_tdcv(dev, &tdcv); 512 + } else if (dbt_params->do_get_auto_tdcv) { 513 + err = dbt_params->do_get_auto_tdcv(dev, &tdcv); 678 514 } 679 515 if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv)) 680 516 goto err_cancel; ··· 722 558 if (priv->do_get_state) 723 559 priv->do_get_state(dev, &state); 724 560 725 - if ((priv->bittiming.bitrate != CAN_BITRATE_UNSET && 726 - priv->bittiming.bitrate != CAN_BITRATE_UNKNOWN && 727 - nla_put(skb, IFLA_CAN_BITTIMING, 728 - sizeof(priv->bittiming), &priv->bittiming)) || 561 + if (can_bittiming_fill_info(skb, IFLA_CAN_BITTIMING, 562 + &priv->bittiming) || 729 563 730 - (priv->bittiming_const && 731 - nla_put(skb, IFLA_CAN_BITTIMING_CONST, 732 - sizeof(*priv->bittiming_const), priv->bittiming_const)) || 564 + can_bittiming_const_fill_info(skb, IFLA_CAN_BITTIMING_CONST, 565 + priv->bittiming_const) || 733 566 734 567 nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) || 735 568 nla_put_u32(skb, IFLA_CAN_STATE, state) || ··· 737 576 !priv->do_get_berr_counter(dev, &bec) && 738 577 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) || 739 578 740 - (priv->fd.data_bittiming.bitrate && 741 - nla_put(skb, IFLA_CAN_DATA_BITTIMING, 742 - sizeof(priv->fd.data_bittiming), &priv->fd.data_bittiming)) || 579 + can_bittiming_fill_info(skb, IFLA_CAN_DATA_BITTIMING, 580 + &priv->fd.data_bittiming) || 743 581 744 - (priv->fd.data_bittiming_const && 745 - nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST, 746 - sizeof(*priv->fd.data_bittiming_const), 747 - priv->fd.data_bittiming_const)) || 582 + can_bittiming_const_fill_info(skb, IFLA_CAN_DATA_BITTIMING_CONST, 583 + priv->fd.data_bittiming_const) || 748 584 749 585 (priv->termination_const && 750 586 (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) || ··· 750 592 priv->termination_const_cnt, 751 593 priv->termination_const))) || 752 594 753 - (priv->bitrate_const && 754 - nla_put(skb, IFLA_CAN_BITRATE_CONST, 755 - sizeof(*priv->bitrate_const) * 756 - priv->bitrate_const_cnt, 757 - priv->bitrate_const)) || 595 + can_bitrate_const_fill_info(skb, IFLA_CAN_BITRATE_CONST, 596 + priv->bitrate_const, 597 + priv->bitrate_const_cnt) || 758 598 759 - (priv->fd.data_bitrate_const && 760 - nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST, 761 - sizeof(*priv->fd.data_bitrate_const) * 762 - priv->fd.data_bitrate_const_cnt, 763 - priv->fd.data_bitrate_const)) || 599 + can_bitrate_const_fill_info(skb, IFLA_CAN_DATA_BITRATE_CONST, 600 + priv->fd.data_bitrate_const, 601 + priv->fd.data_bitrate_const_cnt) || 764 602 765 603 (nla_put(skb, IFLA_CAN_BITRATE_MAX, 766 604 sizeof(priv->bitrate_max), 767 605 &priv->bitrate_max)) || 768 606 769 - can_tdc_fill_info(skb, dev) || 607 + can_tdc_fill_info(skb, dev, IFLA_CAN_TDC) || 770 608 771 609 can_ctrlmode_ext_fill_info(skb, priv) 772 610 )
+2 -4
drivers/net/can/m_can/m_can.c
··· 2213 2213 cdev->tx_coalesce_usecs_irq = ec->tx_coalesce_usecs_irq; 2214 2214 2215 2215 if (cdev->rx_coalesce_usecs_irq) 2216 - cdev->irq_timer_wait = 2217 - ns_to_ktime(cdev->rx_coalesce_usecs_irq * NSEC_PER_USEC); 2216 + cdev->irq_timer_wait = us_to_ktime(cdev->rx_coalesce_usecs_irq); 2218 2217 else 2219 - cdev->irq_timer_wait = 2220 - ns_to_ktime(cdev->tx_coalesce_usecs_irq * NSEC_PER_USEC); 2218 + cdev->irq_timer_wait = us_to_ktime(cdev->tx_coalesce_usecs_irq); 2221 2219 2222 2220 return 0; 2223 2221 }
+2 -2
drivers/net/can/peak_canfd/peak_canfd.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 2 /* Copyright (C) 2007, 2011 Wolfgang Grandegger <wg@grandegger.com> 3 - * Copyright (C) 2012 Stephane Grosjean <s.grosjean@peak-system.com> 4 3 * 5 - * Copyright (C) 2016 PEAK System-Technik GmbH 4 + * Copyright (C) 2016-2025 PEAK System-Technik GmbH 5 + * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com> 6 6 */ 7 7 8 8 #include <linux/can.h>
+2 -2
drivers/net/can/peak_canfd/peak_canfd_user.h
··· 1 1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 /* CAN driver for PEAK System micro-CAN based adapters 3 3 * 4 - * Copyright (C) 2003-2011 PEAK System-Technik GmbH 5 - * Copyright (C) 2011-2013 Stephane Grosjean <s.grosjean@peak-system.com> 4 + * Copyright (C) 2003-2025 PEAK System-Technik GmbH 5 + * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com> 6 6 */ 7 7 #ifndef PEAK_CANFD_USER_H 8 8 #define PEAK_CANFD_USER_H
+3 -3
drivers/net/can/peak_canfd/peak_pciefd_main.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 2 /* Copyright (C) 2007, 2011 Wolfgang Grandegger <wg@grandegger.com> 3 - * Copyright (C) 2012 Stephane Grosjean <s.grosjean@peak-system.com> 4 3 * 5 4 * Derived from the PCAN project file driver/src/pcan_pci.c: 6 5 * 7 - * Copyright (C) 2001-2006 PEAK System-Technik GmbH 6 + * Copyright (C) 2001-2025 PEAK System-Technik GmbH 7 + * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com> 8 8 */ 9 9 10 10 #include <linux/kernel.h> ··· 19 19 20 20 #include "peak_canfd_user.h" 21 21 22 - MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>"); 22 + MODULE_AUTHOR("Stéphane Grosjean <stephane.grosjean@hms-networks.com>"); 23 23 MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCIe/M.2 FD family cards"); 24 24 MODULE_LICENSE("GPL v2"); 25 25
+148 -142
drivers/net/can/rcar/rcar_can.c
··· 5 5 * Copyright (C) 2013 Renesas Solutions Corp. 6 6 */ 7 7 8 + #include <linux/bitfield.h> 9 + #include <linux/bits.h> 8 10 #include <linux/module.h> 9 11 #include <linux/kernel.h> 10 12 #include <linux/types.h> ··· 18 16 #include <linux/can/dev.h> 19 17 #include <linux/clk.h> 20 18 #include <linux/of.h> 19 + #include <linux/pm_runtime.h> 21 20 22 21 #define RCAR_CAN_DRV_NAME "rcar_can" 23 22 ··· 95 92 struct net_device *ndev; 96 93 struct napi_struct napi; 97 94 struct rcar_can_regs __iomem *regs; 98 - struct clk *clk; 99 95 struct clk *can_clk; 100 96 u32 tx_head; 101 97 u32 tx_tail; ··· 115 113 }; 116 114 117 115 /* Control Register bits */ 118 - #define RCAR_CAN_CTLR_BOM (3 << 11) /* Bus-Off Recovery Mode Bits */ 119 - #define RCAR_CAN_CTLR_BOM_ENT (1 << 11) /* Entry to halt mode */ 120 - /* at bus-off entry */ 121 - #define RCAR_CAN_CTLR_SLPM (1 << 10) 122 - #define RCAR_CAN_CTLR_CANM (3 << 8) /* Operating Mode Select Bit */ 123 - #define RCAR_CAN_CTLR_CANM_HALT (1 << 9) 124 - #define RCAR_CAN_CTLR_CANM_RESET (1 << 8) 125 - #define RCAR_CAN_CTLR_CANM_FORCE_RESET (3 << 8) 126 - #define RCAR_CAN_CTLR_MLM (1 << 3) /* Message Lost Mode Select */ 127 - #define RCAR_CAN_CTLR_IDFM (3 << 1) /* ID Format Mode Select Bits */ 128 - #define RCAR_CAN_CTLR_IDFM_MIXED (1 << 2) /* Mixed ID mode */ 129 - #define RCAR_CAN_CTLR_MBM (1 << 0) /* Mailbox Mode select */ 116 + #define RCAR_CAN_CTLR_BOM GENMASK(12, 11) /* Bus-Off Recovery Mode Bits */ 117 + #define RCAR_CAN_CTLR_BOM_ENT 1 /* Entry to halt mode */ 118 + /* at bus-off entry */ 119 + #define RCAR_CAN_CTLR_SLPM BIT(10) /* Sleep Mode */ 120 + #define RCAR_CAN_CTLR_CANM GENMASK(9, 8) /* Operating Mode Select Bit */ 121 + #define RCAR_CAN_CTLR_CANM_OPER 0 /* Operation Mode */ 122 + #define RCAR_CAN_CTLR_CANM_RESET 1 /* Reset Mode */ 123 + #define RCAR_CAN_CTLR_CANM_HALT 2 /* Halt Mode */ 124 + #define RCAR_CAN_CTLR_CANM_FORCE_RESET 3 /* Reset Mode (forcible) */ 125 + #define RCAR_CAN_CTLR_MLM BIT(3) /* Message Lost Mode Select */ 126 + #define RCAR_CAN_CTLR_IDFM GENMASK(2, 1) /* ID Format Mode Select Bits */ 127 + #define RCAR_CAN_CTLR_IDFM_STD 0 /* Standard ID mode */ 128 + #define RCAR_CAN_CTLR_IDFM_EXT 1 /* Extended ID mode */ 129 + #define RCAR_CAN_CTLR_IDFM_MIXED 2 /* Mixed ID mode */ 130 + #define RCAR_CAN_CTLR_MBM BIT(0) /* Mailbox Mode select */ 130 131 131 132 /* Status Register bits */ 132 - #define RCAR_CAN_STR_RSTST (1 << 8) /* Reset Status Bit */ 133 + #define RCAR_CAN_STR_RSTST BIT(8) /* Reset Status Bit */ 133 134 134 135 /* FIFO Received ID Compare Registers 0 and 1 bits */ 135 - #define RCAR_CAN_FIDCR_IDE (1 << 31) /* ID Extension Bit */ 136 - #define RCAR_CAN_FIDCR_RTR (1 << 30) /* Remote Transmission Request Bit */ 136 + #define RCAR_CAN_FIDCR_IDE BIT(31) /* ID Extension Bit */ 137 + #define RCAR_CAN_FIDCR_RTR BIT(30) /* Remote Transmission Request Bit */ 137 138 138 139 /* Receive FIFO Control Register bits */ 139 - #define RCAR_CAN_RFCR_RFEST (1 << 7) /* Receive FIFO Empty Status Flag */ 140 - #define RCAR_CAN_RFCR_RFE (1 << 0) /* Receive FIFO Enable */ 140 + #define RCAR_CAN_RFCR_RFEST BIT(7) /* Receive FIFO Empty Status Flag */ 141 + #define RCAR_CAN_RFCR_RFE BIT(0) /* Receive FIFO Enable */ 141 142 142 143 /* Transmit FIFO Control Register bits */ 143 - #define RCAR_CAN_TFCR_TFUST (7 << 1) /* Transmit FIFO Unsent Message */ 144 - /* Number Status Bits */ 145 - #define RCAR_CAN_TFCR_TFUST_SHIFT 1 /* Offset of Transmit FIFO Unsent */ 146 - /* Message Number Status Bits */ 147 - #define RCAR_CAN_TFCR_TFE (1 << 0) /* Transmit FIFO Enable */ 144 + #define RCAR_CAN_TFCR_TFUST GENMASK(3, 1) /* Transmit FIFO Unsent Message */ 145 + /* Number Status Bits */ 146 + #define RCAR_CAN_TFCR_TFE BIT(0) /* Transmit FIFO Enable */ 148 147 149 - #define RCAR_CAN_N_RX_MKREGS1 2 /* Number of mask registers */ 150 - /* for Rx mailboxes 0-31 */ 148 + #define RCAR_CAN_N_RX_MKREGS1 2 /* Number of mask registers */ 149 + /* for Rx mailboxes 0-31 */ 151 150 #define RCAR_CAN_N_RX_MKREGS2 8 152 151 153 152 /* Bit Configuration Register settings */ 154 - #define RCAR_CAN_BCR_TSEG1(x) (((x) & 0x0f) << 20) 155 - #define RCAR_CAN_BCR_BPR(x) (((x) & 0x3ff) << 8) 156 - #define RCAR_CAN_BCR_SJW(x) (((x) & 0x3) << 4) 157 - #define RCAR_CAN_BCR_TSEG2(x) ((x) & 0x07) 153 + #define RCAR_CAN_BCR_TSEG1 GENMASK(23, 20) 154 + #define RCAR_CAN_BCR_BRP GENMASK(17, 8) 155 + #define RCAR_CAN_BCR_SJW GENMASK(5, 4) 156 + #define RCAR_CAN_BCR_TSEG2 GENMASK(2, 0) 158 157 159 158 /* Mailbox and Mask Registers bits */ 160 - #define RCAR_CAN_IDE (1 << 31) 161 - #define RCAR_CAN_RTR (1 << 30) 162 - #define RCAR_CAN_SID_SHIFT 18 159 + #define RCAR_CAN_IDE BIT(31) /* ID Extension */ 160 + #define RCAR_CAN_RTR BIT(30) /* Remote Transmission Request */ 161 + #define RCAR_CAN_SID GENMASK(28, 18) /* Standard ID */ 162 + #define RCAR_CAN_EID GENMASK(28, 0) /* Extended ID */ 163 163 164 164 /* Mailbox Interrupt Enable Register 1 bits */ 165 - #define RCAR_CAN_MIER1_RXFIE (1 << 28) /* Receive FIFO Interrupt Enable */ 166 - #define RCAR_CAN_MIER1_TXFIE (1 << 24) /* Transmit FIFO Interrupt Enable */ 165 + #define RCAR_CAN_MIER1_RXFIE BIT(28) /* Receive FIFO Interrupt Enable */ 166 + #define RCAR_CAN_MIER1_TXFIE BIT(24) /* Transmit FIFO Interrupt Enable */ 167 167 168 168 /* Interrupt Enable Register bits */ 169 - #define RCAR_CAN_IER_ERSIE (1 << 5) /* Error (ERS) Interrupt Enable Bit */ 170 - #define RCAR_CAN_IER_RXFIE (1 << 4) /* Reception FIFO Interrupt */ 171 - /* Enable Bit */ 172 - #define RCAR_CAN_IER_TXFIE (1 << 3) /* Transmission FIFO Interrupt */ 173 - /* Enable Bit */ 169 + #define RCAR_CAN_IER_ERSIE BIT(5) /* Error (ERS) Interrupt Enable Bit */ 170 + #define RCAR_CAN_IER_RXFIE BIT(4) /* Reception FIFO Interrupt */ 171 + /* Enable Bit */ 172 + #define RCAR_CAN_IER_TXFIE BIT(3) /* Transmission FIFO Interrupt */ 173 + /* Enable Bit */ 174 174 /* Interrupt Status Register bits */ 175 - #define RCAR_CAN_ISR_ERSF (1 << 5) /* Error (ERS) Interrupt Status Bit */ 176 - #define RCAR_CAN_ISR_RXFF (1 << 4) /* Reception FIFO Interrupt */ 177 - /* Status Bit */ 178 - #define RCAR_CAN_ISR_TXFF (1 << 3) /* Transmission FIFO Interrupt */ 179 - /* Status Bit */ 175 + #define RCAR_CAN_ISR_ERSF BIT(5) /* Error (ERS) Interrupt Status Bit */ 176 + #define RCAR_CAN_ISR_RXFF BIT(4) /* Reception FIFO Interrupt */ 177 + /* Status Bit */ 178 + #define RCAR_CAN_ISR_TXFF BIT(3) /* Transmission FIFO Interrupt */ 179 + /* Status Bit */ 180 180 181 181 /* Error Interrupt Enable Register bits */ 182 - #define RCAR_CAN_EIER_BLIE (1 << 7) /* Bus Lock Interrupt Enable */ 183 - #define RCAR_CAN_EIER_OLIE (1 << 6) /* Overload Frame Transmit */ 184 - /* Interrupt Enable */ 185 - #define RCAR_CAN_EIER_ORIE (1 << 5) /* Receive Overrun Interrupt Enable */ 186 - #define RCAR_CAN_EIER_BORIE (1 << 4) /* Bus-Off Recovery Interrupt Enable */ 187 - #define RCAR_CAN_EIER_BOEIE (1 << 3) /* Bus-Off Entry Interrupt Enable */ 188 - #define RCAR_CAN_EIER_EPIE (1 << 2) /* Error Passive Interrupt Enable */ 189 - #define RCAR_CAN_EIER_EWIE (1 << 1) /* Error Warning Interrupt Enable */ 190 - #define RCAR_CAN_EIER_BEIE (1 << 0) /* Bus Error Interrupt Enable */ 182 + #define RCAR_CAN_EIER_BLIE BIT(7) /* Bus Lock Interrupt Enable */ 183 + #define RCAR_CAN_EIER_OLIE BIT(6) /* Overload Frame Transmit */ 184 + /* Interrupt Enable */ 185 + #define RCAR_CAN_EIER_ORIE BIT(5) /* Receive Overrun Interrupt Enable */ 186 + #define RCAR_CAN_EIER_BORIE BIT(4) /* Bus-Off Recovery Interrupt Enable */ 187 + #define RCAR_CAN_EIER_BOEIE BIT(3) /* Bus-Off Entry Interrupt Enable */ 188 + #define RCAR_CAN_EIER_EPIE BIT(2) /* Error Passive Interrupt Enable */ 189 + #define RCAR_CAN_EIER_EWIE BIT(1) /* Error Warning Interrupt Enable */ 190 + #define RCAR_CAN_EIER_BEIE BIT(0) /* Bus Error Interrupt Enable */ 191 191 192 192 /* Error Interrupt Factor Judge Register bits */ 193 - #define RCAR_CAN_EIFR_BLIF (1 << 7) /* Bus Lock Detect Flag */ 194 - #define RCAR_CAN_EIFR_OLIF (1 << 6) /* Overload Frame Transmission */ 195 - /* Detect Flag */ 196 - #define RCAR_CAN_EIFR_ORIF (1 << 5) /* Receive Overrun Detect Flag */ 197 - #define RCAR_CAN_EIFR_BORIF (1 << 4) /* Bus-Off Recovery Detect Flag */ 198 - #define RCAR_CAN_EIFR_BOEIF (1 << 3) /* Bus-Off Entry Detect Flag */ 199 - #define RCAR_CAN_EIFR_EPIF (1 << 2) /* Error Passive Detect Flag */ 200 - #define RCAR_CAN_EIFR_EWIF (1 << 1) /* Error Warning Detect Flag */ 201 - #define RCAR_CAN_EIFR_BEIF (1 << 0) /* Bus Error Detect Flag */ 193 + #define RCAR_CAN_EIFR_BLIF BIT(7) /* Bus Lock Detect Flag */ 194 + #define RCAR_CAN_EIFR_OLIF BIT(6) /* Overload Frame Transmission */ 195 + /* Detect Flag */ 196 + #define RCAR_CAN_EIFR_ORIF BIT(5) /* Receive Overrun Detect Flag */ 197 + #define RCAR_CAN_EIFR_BORIF BIT(4) /* Bus-Off Recovery Detect Flag */ 198 + #define RCAR_CAN_EIFR_BOEIF BIT(3) /* Bus-Off Entry Detect Flag */ 199 + #define RCAR_CAN_EIFR_EPIF BIT(2) /* Error Passive Detect Flag */ 200 + #define RCAR_CAN_EIFR_EWIF BIT(1) /* Error Warning Detect Flag */ 201 + #define RCAR_CAN_EIFR_BEIF BIT(0) /* Bus Error Detect Flag */ 202 202 203 203 /* Error Code Store Register bits */ 204 - #define RCAR_CAN_ECSR_EDPM (1 << 7) /* Error Display Mode Select Bit */ 205 - #define RCAR_CAN_ECSR_ADEF (1 << 6) /* ACK Delimiter Error Flag */ 206 - #define RCAR_CAN_ECSR_BE0F (1 << 5) /* Bit Error (dominant) Flag */ 207 - #define RCAR_CAN_ECSR_BE1F (1 << 4) /* Bit Error (recessive) Flag */ 208 - #define RCAR_CAN_ECSR_CEF (1 << 3) /* CRC Error Flag */ 209 - #define RCAR_CAN_ECSR_AEF (1 << 2) /* ACK Error Flag */ 210 - #define RCAR_CAN_ECSR_FEF (1 << 1) /* Form Error Flag */ 211 - #define RCAR_CAN_ECSR_SEF (1 << 0) /* Stuff Error Flag */ 204 + #define RCAR_CAN_ECSR_EDPM BIT(7) /* Error Display Mode Select Bit */ 205 + #define RCAR_CAN_ECSR_ADEF BIT(6) /* ACK Delimiter Error Flag */ 206 + #define RCAR_CAN_ECSR_BE0F BIT(5) /* Bit Error (dominant) Flag */ 207 + #define RCAR_CAN_ECSR_BE1F BIT(4) /* Bit Error (recessive) Flag */ 208 + #define RCAR_CAN_ECSR_CEF BIT(3) /* CRC Error Flag */ 209 + #define RCAR_CAN_ECSR_AEF BIT(2) /* ACK Error Flag */ 210 + #define RCAR_CAN_ECSR_FEF BIT(1) /* Form Error Flag */ 211 + #define RCAR_CAN_ECSR_SEF BIT(0) /* Stuff Error Flag */ 212 212 213 213 #define RCAR_CAN_NAPI_WEIGHT 4 214 214 #define MAX_STR_READS 0x100 ··· 252 248 if (ecsr & RCAR_CAN_ECSR_ADEF) { 253 249 netdev_dbg(priv->ndev, "ACK Delimiter Error\n"); 254 250 tx_errors++; 255 - writeb(~RCAR_CAN_ECSR_ADEF, &priv->regs->ecsr); 251 + writeb((u8)~RCAR_CAN_ECSR_ADEF, &priv->regs->ecsr); 256 252 if (skb) 257 253 cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL; 258 254 } 259 255 if (ecsr & RCAR_CAN_ECSR_BE0F) { 260 256 netdev_dbg(priv->ndev, "Bit Error (dominant)\n"); 261 257 tx_errors++; 262 - writeb(~RCAR_CAN_ECSR_BE0F, &priv->regs->ecsr); 258 + writeb((u8)~RCAR_CAN_ECSR_BE0F, &priv->regs->ecsr); 263 259 if (skb) 264 260 cf->data[2] |= CAN_ERR_PROT_BIT0; 265 261 } 266 262 if (ecsr & RCAR_CAN_ECSR_BE1F) { 267 263 netdev_dbg(priv->ndev, "Bit Error (recessive)\n"); 268 264 tx_errors++; 269 - writeb(~RCAR_CAN_ECSR_BE1F, &priv->regs->ecsr); 265 + writeb((u8)~RCAR_CAN_ECSR_BE1F, &priv->regs->ecsr); 270 266 if (skb) 271 267 cf->data[2] |= CAN_ERR_PROT_BIT1; 272 268 } 273 269 if (ecsr & RCAR_CAN_ECSR_CEF) { 274 270 netdev_dbg(priv->ndev, "CRC Error\n"); 275 271 rx_errors++; 276 - writeb(~RCAR_CAN_ECSR_CEF, &priv->regs->ecsr); 272 + writeb((u8)~RCAR_CAN_ECSR_CEF, &priv->regs->ecsr); 277 273 if (skb) 278 274 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 279 275 } 280 276 if (ecsr & RCAR_CAN_ECSR_AEF) { 281 277 netdev_dbg(priv->ndev, "ACK Error\n"); 282 278 tx_errors++; 283 - writeb(~RCAR_CAN_ECSR_AEF, &priv->regs->ecsr); 279 + writeb((u8)~RCAR_CAN_ECSR_AEF, &priv->regs->ecsr); 284 280 if (skb) { 285 281 cf->can_id |= CAN_ERR_ACK; 286 282 cf->data[3] = CAN_ERR_PROT_LOC_ACK; ··· 289 285 if (ecsr & RCAR_CAN_ECSR_FEF) { 290 286 netdev_dbg(priv->ndev, "Form Error\n"); 291 287 rx_errors++; 292 - writeb(~RCAR_CAN_ECSR_FEF, &priv->regs->ecsr); 288 + writeb((u8)~RCAR_CAN_ECSR_FEF, &priv->regs->ecsr); 293 289 if (skb) 294 290 cf->data[2] |= CAN_ERR_PROT_FORM; 295 291 } 296 292 if (ecsr & RCAR_CAN_ECSR_SEF) { 297 293 netdev_dbg(priv->ndev, "Stuff Error\n"); 298 294 rx_errors++; 299 - writeb(~RCAR_CAN_ECSR_SEF, &priv->regs->ecsr); 295 + writeb((u8)~RCAR_CAN_ECSR_SEF, &priv->regs->ecsr); 300 296 if (skb) 301 297 cf->data[2] |= CAN_ERR_PROT_STUFF; 302 298 } ··· 304 300 priv->can.can_stats.bus_error++; 305 301 ndev->stats.rx_errors += rx_errors; 306 302 ndev->stats.tx_errors += tx_errors; 307 - writeb(~RCAR_CAN_EIFR_BEIF, &priv->regs->eifr); 303 + writeb((u8)~RCAR_CAN_EIFR_BEIF, &priv->regs->eifr); 308 304 } 309 305 if (eifr & RCAR_CAN_EIFR_EWIF) { 310 306 netdev_dbg(priv->ndev, "Error warning interrupt\n"); 311 307 priv->can.state = CAN_STATE_ERROR_WARNING; 312 308 priv->can.can_stats.error_warning++; 313 309 /* Clear interrupt condition */ 314 - writeb(~RCAR_CAN_EIFR_EWIF, &priv->regs->eifr); 310 + writeb((u8)~RCAR_CAN_EIFR_EWIF, &priv->regs->eifr); 315 311 if (skb) 316 312 cf->data[1] = txerr > rxerr ? CAN_ERR_CRTL_TX_WARNING : 317 313 CAN_ERR_CRTL_RX_WARNING; ··· 321 317 priv->can.state = CAN_STATE_ERROR_PASSIVE; 322 318 priv->can.can_stats.error_passive++; 323 319 /* Clear interrupt condition */ 324 - writeb(~RCAR_CAN_EIFR_EPIF, &priv->regs->eifr); 320 + writeb((u8)~RCAR_CAN_EIFR_EPIF, &priv->regs->eifr); 325 321 if (skb) 326 322 cf->data[1] = txerr > rxerr ? CAN_ERR_CRTL_TX_PASSIVE : 327 323 CAN_ERR_CRTL_RX_PASSIVE; ··· 333 329 writeb(priv->ier, &priv->regs->ier); 334 330 priv->can.state = CAN_STATE_BUS_OFF; 335 331 /* Clear interrupt condition */ 336 - writeb(~RCAR_CAN_EIFR_BOEIF, &priv->regs->eifr); 332 + writeb((u8)~RCAR_CAN_EIFR_BOEIF, &priv->regs->eifr); 337 333 priv->can.can_stats.bus_off++; 338 334 can_bus_off(ndev); 339 335 if (skb) ··· 347 343 netdev_dbg(priv->ndev, "Receive overrun error interrupt\n"); 348 344 ndev->stats.rx_over_errors++; 349 345 ndev->stats.rx_errors++; 350 - writeb(~RCAR_CAN_EIFR_ORIF, &priv->regs->eifr); 346 + writeb((u8)~RCAR_CAN_EIFR_ORIF, &priv->regs->eifr); 351 347 if (skb) { 352 348 cf->can_id |= CAN_ERR_CRTL; 353 349 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; ··· 358 354 "Overload Frame Transmission error interrupt\n"); 359 355 ndev->stats.rx_over_errors++; 360 356 ndev->stats.rx_errors++; 361 - writeb(~RCAR_CAN_EIFR_OLIF, &priv->regs->eifr); 357 + writeb((u8)~RCAR_CAN_EIFR_OLIF, &priv->regs->eifr); 362 358 if (skb) { 363 359 cf->can_id |= CAN_ERR_PROT; 364 360 cf->data[2] |= CAN_ERR_PROT_OVERLOAD; ··· 376 372 u8 isr; 377 373 378 374 while (1) { 379 - u8 unsent = readb(&priv->regs->tfcr); 375 + u8 unsent = FIELD_GET(RCAR_CAN_TFCR_TFUST, 376 + readb(&priv->regs->tfcr)); 380 377 381 - unsent = (unsent & RCAR_CAN_TFCR_TFUST) >> 382 - RCAR_CAN_TFCR_TFUST_SHIFT; 383 378 if (priv->tx_head - priv->tx_tail <= unsent) 384 379 break; 385 380 stats->tx_packets++; ··· 423 420 return IRQ_HANDLED; 424 421 } 425 422 426 - static void rcar_can_set_bittiming(struct net_device *dev) 423 + static void rcar_can_set_bittiming(struct net_device *ndev) 427 424 { 428 - struct rcar_can_priv *priv = netdev_priv(dev); 425 + struct rcar_can_priv *priv = netdev_priv(ndev); 429 426 struct can_bittiming *bt = &priv->can.bittiming; 430 427 u32 bcr; 431 428 432 - bcr = RCAR_CAN_BCR_TSEG1(bt->phase_seg1 + bt->prop_seg - 1) | 433 - RCAR_CAN_BCR_BPR(bt->brp - 1) | RCAR_CAN_BCR_SJW(bt->sjw - 1) | 434 - RCAR_CAN_BCR_TSEG2(bt->phase_seg2 - 1); 429 + bcr = FIELD_PREP(RCAR_CAN_BCR_TSEG1, bt->phase_seg1 + bt->prop_seg - 1) | 430 + FIELD_PREP(RCAR_CAN_BCR_BRP, bt->brp - 1) | 431 + FIELD_PREP(RCAR_CAN_BCR_SJW, bt->sjw - 1) | 432 + FIELD_PREP(RCAR_CAN_BCR_TSEG2, bt->phase_seg2 - 1); 435 433 /* Don't overwrite CLKR with 32-bit BCR access; CLKR has 8-bit access. 436 434 * All the registers are big-endian but they get byte-swapped on 32-bit 437 435 * read/write (but not on 8-bit, contrary to the manuals)... ··· 456 452 ctlr &= ~RCAR_CAN_CTLR_SLPM; 457 453 writew(ctlr, &priv->regs->ctlr); 458 454 /* Go to reset mode */ 459 - ctlr |= RCAR_CAN_CTLR_CANM_FORCE_RESET; 455 + ctlr |= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_FORCE_RESET); 460 456 writew(ctlr, &priv->regs->ctlr); 461 457 for (i = 0; i < MAX_STR_READS; i++) { 462 458 if (readw(&priv->regs->str) & RCAR_CAN_STR_RSTST) 463 459 break; 464 460 } 465 461 rcar_can_set_bittiming(ndev); 466 - ctlr |= RCAR_CAN_CTLR_IDFM_MIXED; /* Select mixed ID mode */ 467 - ctlr |= RCAR_CAN_CTLR_BOM_ENT; /* Entry to halt mode automatically */ 468 - /* at bus-off */ 462 + /* Select mixed ID mode */ 463 + ctlr |= FIELD_PREP(RCAR_CAN_CTLR_IDFM, RCAR_CAN_CTLR_IDFM_MIXED); 464 + /* Entry to halt mode automatically at bus-off */ 465 + ctlr |= FIELD_PREP(RCAR_CAN_CTLR_BOM, RCAR_CAN_CTLR_BOM_ENT); 469 466 ctlr |= RCAR_CAN_CTLR_MBM; /* Select FIFO mailbox mode */ 470 467 ctlr |= RCAR_CAN_CTLR_MLM; /* Overrun mode */ 471 468 writew(ctlr, &priv->regs->ctlr); ··· 496 491 priv->can.state = CAN_STATE_ERROR_ACTIVE; 497 492 498 493 /* Go to operation mode */ 499 - writew(ctlr & ~RCAR_CAN_CTLR_CANM, &priv->regs->ctlr); 494 + ctlr &= ~RCAR_CAN_CTLR_CANM; 495 + ctlr |= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_OPER); 496 + writew(ctlr, &priv->regs->ctlr); 500 497 for (i = 0; i < MAX_STR_READS; i++) { 501 498 if (!(readw(&priv->regs->str) & RCAR_CAN_STR_RSTST)) 502 499 break; ··· 513 506 struct rcar_can_priv *priv = netdev_priv(ndev); 514 507 int err; 515 508 516 - err = clk_prepare_enable(priv->clk); 509 + err = pm_runtime_resume_and_get(ndev->dev.parent); 517 510 if (err) { 518 - netdev_err(ndev, 519 - "failed to enable peripheral clock, error %d\n", 520 - err); 511 + netdev_err(ndev, "pm_runtime_resume_and_get() failed %pe\n", 512 + ERR_PTR(err)); 521 513 goto out; 522 514 } 523 515 err = clk_prepare_enable(priv->can_clk); 524 516 if (err) { 525 - netdev_err(ndev, "failed to enable CAN clock, error %d\n", 526 - err); 527 - goto out_clock; 517 + netdev_err(ndev, "failed to enable CAN clock: %pe\n", 518 + ERR_PTR(err)); 519 + goto out_rpm; 528 520 } 529 521 err = open_candev(ndev); 530 522 if (err) { 531 - netdev_err(ndev, "open_candev() failed, error %d\n", err); 523 + netdev_err(ndev, "open_candev() failed %pe\n", ERR_PTR(err)); 532 524 goto out_can_clock; 533 525 } 534 526 napi_enable(&priv->napi); 535 527 err = request_irq(ndev->irq, rcar_can_interrupt, 0, ndev->name, ndev); 536 528 if (err) { 537 - netdev_err(ndev, "request_irq(%d) failed, error %d\n", 538 - ndev->irq, err); 529 + netdev_err(ndev, "request_irq(%d) failed %pe\n", ndev->irq, 530 + ERR_PTR(err)); 539 531 goto out_close; 540 532 } 541 533 rcar_can_start(ndev); ··· 545 539 close_candev(ndev); 546 540 out_can_clock: 547 541 clk_disable_unprepare(priv->can_clk); 548 - out_clock: 549 - clk_disable_unprepare(priv->clk); 542 + out_rpm: 543 + pm_runtime_put(ndev->dev.parent); 550 544 out: 551 545 return err; 552 546 } ··· 559 553 560 554 /* Go to (force) reset mode */ 561 555 ctlr = readw(&priv->regs->ctlr); 562 - ctlr |= RCAR_CAN_CTLR_CANM_FORCE_RESET; 556 + ctlr |= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_FORCE_RESET); 563 557 writew(ctlr, &priv->regs->ctlr); 564 558 for (i = 0; i < MAX_STR_READS; i++) { 565 559 if (readw(&priv->regs->str) & RCAR_CAN_STR_RSTST) ··· 584 578 free_irq(ndev->irq, ndev); 585 579 napi_disable(&priv->napi); 586 580 clk_disable_unprepare(priv->can_clk); 587 - clk_disable_unprepare(priv->clk); 581 + pm_runtime_put(ndev->dev.parent); 588 582 close_candev(ndev); 589 583 return 0; 590 584 } ··· 600 594 return NETDEV_TX_OK; 601 595 602 596 if (cf->can_id & CAN_EFF_FLAG) /* Extended frame format */ 603 - data = (cf->can_id & CAN_EFF_MASK) | RCAR_CAN_IDE; 597 + data = FIELD_PREP(RCAR_CAN_EID, cf->can_id & CAN_EFF_MASK) | 598 + RCAR_CAN_IDE; 604 599 else /* Standard frame format */ 605 - data = (cf->can_id & CAN_SFF_MASK) << RCAR_CAN_SID_SHIFT; 600 + data = FIELD_PREP(RCAR_CAN_SID, cf->can_id & CAN_SFF_MASK); 606 601 607 602 if (cf->can_id & CAN_RTR_FLAG) { /* Remote transmission request */ 608 603 data |= RCAR_CAN_RTR; ··· 658 651 659 652 data = readl(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].id); 660 653 if (data & RCAR_CAN_IDE) 661 - cf->can_id = (data & CAN_EFF_MASK) | CAN_EFF_FLAG; 654 + cf->can_id = FIELD_GET(RCAR_CAN_EID, data) | CAN_EFF_FLAG; 662 655 else 663 - cf->can_id = (data >> RCAR_CAN_SID_SHIFT) & CAN_SFF_MASK; 656 + cf->can_id = FIELD_GET(RCAR_CAN_SID, data); 664 657 665 658 dlc = readb(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].dlc); 666 659 cf->len = can_cc_dlc2len(dlc); ··· 722 715 } 723 716 } 724 717 725 - static int rcar_can_get_berr_counter(const struct net_device *dev, 718 + static int rcar_can_get_berr_counter(const struct net_device *ndev, 726 719 struct can_berr_counter *bec) 727 720 { 728 - struct rcar_can_priv *priv = netdev_priv(dev); 721 + struct rcar_can_priv *priv = netdev_priv(ndev); 729 722 int err; 730 723 731 - err = clk_prepare_enable(priv->clk); 724 + err = pm_runtime_resume_and_get(ndev->dev.parent); 732 725 if (err) 733 726 return err; 727 + 734 728 bec->txerr = readb(&priv->regs->tecr); 735 729 bec->rxerr = readb(&priv->regs->recr); 736 - clk_disable_unprepare(priv->clk); 730 + 731 + pm_runtime_put(ndev->dev.parent); 732 + 737 733 return 0; 738 734 } 739 735 ··· 748 738 749 739 static int rcar_can_probe(struct platform_device *pdev) 750 740 { 741 + struct device *dev = &pdev->dev; 751 742 struct rcar_can_priv *priv; 752 743 struct net_device *ndev; 753 744 void __iomem *addr; ··· 756 745 int err = -ENODEV; 757 746 int irq; 758 747 759 - of_property_read_u32(pdev->dev.of_node, "renesas,can-clock-select", 748 + of_property_read_u32(dev->of_node, "renesas,can-clock-select", 760 749 &clock_select); 761 750 762 751 irq = platform_get_irq(pdev, 0); ··· 773 762 774 763 ndev = alloc_candev(sizeof(struct rcar_can_priv), RCAR_CAN_FIFO_DEPTH); 775 764 if (!ndev) { 776 - dev_err(&pdev->dev, "alloc_candev() failed\n"); 777 765 err = -ENOMEM; 778 766 goto fail; 779 767 } 780 768 781 769 priv = netdev_priv(ndev); 782 770 783 - priv->clk = devm_clk_get(&pdev->dev, "clkp1"); 784 - if (IS_ERR(priv->clk)) { 785 - err = PTR_ERR(priv->clk); 786 - dev_err(&pdev->dev, "cannot get peripheral clock, error %d\n", 787 - err); 788 - goto fail_clk; 789 - } 790 - 791 771 if (!(BIT(clock_select) & RCAR_SUPPORTED_CLOCKS)) { 792 772 err = -EINVAL; 793 - dev_err(&pdev->dev, "invalid CAN clock selected\n"); 773 + dev_err(dev, "invalid CAN clock selected\n"); 794 774 goto fail_clk; 795 775 } 796 - priv->can_clk = devm_clk_get(&pdev->dev, clock_names[clock_select]); 776 + priv->can_clk = devm_clk_get(dev, clock_names[clock_select]); 797 777 if (IS_ERR(priv->can_clk)) { 778 + dev_err(dev, "cannot get CAN clock: %pe\n", priv->can_clk); 798 779 err = PTR_ERR(priv->can_clk); 799 - dev_err(&pdev->dev, "cannot get CAN clock, error %d\n", err); 800 780 goto fail_clk; 801 781 } 802 782 ··· 804 802 priv->can.do_get_berr_counter = rcar_can_get_berr_counter; 805 803 priv->can.ctrlmode_supported = CAN_CTRLMODE_BERR_REPORTING; 806 804 platform_set_drvdata(pdev, ndev); 807 - SET_NETDEV_DEV(ndev, &pdev->dev); 805 + SET_NETDEV_DEV(ndev, dev); 808 806 809 807 netif_napi_add_weight(ndev, &priv->napi, rcar_can_rx_poll, 810 808 RCAR_CAN_NAPI_WEIGHT); 809 + 810 + pm_runtime_enable(dev); 811 + 811 812 err = register_candev(ndev); 812 813 if (err) { 813 - dev_err(&pdev->dev, "register_candev() failed, error %d\n", 814 - err); 815 - goto fail_candev; 814 + dev_err(dev, "register_candev() failed %pe\n", ERR_PTR(err)); 815 + goto fail_rpm; 816 816 } 817 817 818 - dev_info(&pdev->dev, "device registered (IRQ%d)\n", ndev->irq); 818 + dev_info(dev, "device registered (IRQ%d)\n", ndev->irq); 819 819 820 820 return 0; 821 - fail_candev: 821 + fail_rpm: 822 + pm_runtime_disable(dev); 822 823 netif_napi_del(&priv->napi); 823 824 fail_clk: 824 825 free_candev(ndev); ··· 835 830 struct rcar_can_priv *priv = netdev_priv(ndev); 836 831 837 832 unregister_candev(ndev); 833 + pm_runtime_disable(&pdev->dev); 838 834 netif_napi_del(&priv->napi); 839 835 free_candev(ndev); 840 836 } ··· 853 847 netif_device_detach(ndev); 854 848 855 849 ctlr = readw(&priv->regs->ctlr); 856 - ctlr |= RCAR_CAN_CTLR_CANM_HALT; 850 + ctlr |= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_HALT); 857 851 writew(ctlr, &priv->regs->ctlr); 858 852 ctlr |= RCAR_CAN_CTLR_SLPM; 859 853 writew(ctlr, &priv->regs->ctlr); 860 854 priv->can.state = CAN_STATE_SLEEPING; 861 855 862 - clk_disable(priv->clk); 856 + pm_runtime_put(dev); 863 857 return 0; 864 858 } 865 859 866 860 static int rcar_can_resume(struct device *dev) 867 861 { 868 862 struct net_device *ndev = dev_get_drvdata(dev); 869 - struct rcar_can_priv *priv = netdev_priv(ndev); 870 863 int err; 871 864 872 865 if (!netif_running(ndev)) 873 866 return 0; 874 867 875 - err = clk_enable(priv->clk); 868 + err = pm_runtime_resume_and_get(dev); 876 869 if (err) { 877 - netdev_err(ndev, "clk_enable() failed, error %d\n", err); 870 + netdev_err(ndev, "pm_runtime_resume_and_get() failed %pe\n", 871 + ERR_PTR(err)); 878 872 return err; 879 873 } 880 874
+47 -37
drivers/net/can/rcar/rcar_canfd.c
··· 103 103 /* Channel register bits */ 104 104 105 105 /* RSCFDnCmCFG - Classical CAN only */ 106 - #define RCANFD_CFG_SJW(x) (((x) & 0x3) << 24) 107 - #define RCANFD_CFG_TSEG2(x) (((x) & 0x7) << 20) 108 - #define RCANFD_CFG_TSEG1(x) (((x) & 0xf) << 16) 109 - #define RCANFD_CFG_BRP(x) (((x) & 0x3ff) << 0) 106 + #define RCANFD_CFG_SJW GENMASK(25, 24) 107 + #define RCANFD_CFG_TSEG2 GENMASK(22, 20) 108 + #define RCANFD_CFG_TSEG1 GENMASK(19, 16) 109 + #define RCANFD_CFG_BRP GENMASK(9, 0) 110 110 111 111 /* RSCFDnCFDCmNCFG - CAN FD only */ 112 - #define RCANFD_NCFG_NTSEG2(gpriv, x) \ 113 - (((x) & ((gpriv)->info->nom_bittiming->tseg2_max - 1)) << (gpriv)->info->sh->ntseg2) 114 - 115 - #define RCANFD_NCFG_NTSEG1(gpriv, x) \ 116 - (((x) & ((gpriv)->info->nom_bittiming->tseg1_max - 1)) << (gpriv)->info->sh->ntseg1) 117 - 118 - #define RCANFD_NCFG_NSJW(gpriv, x) \ 119 - (((x) & ((gpriv)->info->nom_bittiming->sjw_max - 1)) << (gpriv)->info->sh->nsjw) 120 - 121 - #define RCANFD_NCFG_NBRP(x) (((x) & 0x3ff) << 0) 112 + #define RCANFD_NCFG_NBRP GENMASK(9, 0) 122 113 123 114 /* RSCFDnCFDCmCTR / RSCFDnCmCTR */ 124 115 #define RCANFD_CCTR_CTME BIT(24) ··· 169 178 #define RCANFD_CERFL_ERR(x) ((x) & (0x7fff)) /* above bits 14:0 */ 170 179 171 180 /* RSCFDnCFDCmDCFG */ 172 - #define RCANFD_DCFG_DSJW(gpriv, x) (((x) & ((gpriv)->info->data_bittiming->sjw_max - 1)) << 24) 173 - 174 - #define RCANFD_DCFG_DTSEG2(gpriv, x) \ 175 - (((x) & ((gpriv)->info->data_bittiming->tseg2_max - 1)) << (gpriv)->info->sh->dtseg2) 176 - 177 - #define RCANFD_DCFG_DTSEG1(gpriv, x) \ 178 - (((x) & ((gpriv)->info->data_bittiming->tseg1_max - 1)) << (gpriv)->info->sh->dtseg1) 179 - 180 - #define RCANFD_DCFG_DBRP(x) (((x) & 0xff) << 0) 181 + #define RCANFD_DCFG_DBRP GENMASK(7, 0) 181 182 182 183 /* RSCFDnCFDCmFDCFG */ 183 184 #define RCANFD_GEN4_FDCFG_CLOE BIT(30) ··· 1372 1389 return IRQ_HANDLED; 1373 1390 } 1374 1391 1392 + static inline u32 rcar_canfd_compute_nominal_bit_rate_cfg(struct rcar_canfd_channel *priv, 1393 + u16 tseg1, u16 tseg2, u16 sjw, u16 brp) 1394 + { 1395 + struct rcar_canfd_global *gpriv = priv->gpriv; 1396 + const struct rcar_canfd_hw_info *info = gpriv->info; 1397 + u32 ntseg1, ntseg2, nsjw, nbrp; 1398 + 1399 + if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) || gpriv->info->shared_can_regs) { 1400 + ntseg1 = (tseg1 & (info->nom_bittiming->tseg1_max - 1)) << info->sh->ntseg1; 1401 + ntseg2 = (tseg2 & (info->nom_bittiming->tseg2_max - 1)) << info->sh->ntseg2; 1402 + nsjw = (sjw & (info->nom_bittiming->sjw_max - 1)) << info->sh->nsjw; 1403 + nbrp = FIELD_PREP(RCANFD_NCFG_NBRP, brp); 1404 + } else { 1405 + ntseg1 = FIELD_PREP(RCANFD_CFG_TSEG1, tseg1); 1406 + ntseg2 = FIELD_PREP(RCANFD_CFG_TSEG2, tseg2); 1407 + nsjw = FIELD_PREP(RCANFD_CFG_SJW, sjw); 1408 + nbrp = FIELD_PREP(RCANFD_CFG_BRP, brp); 1409 + } 1410 + 1411 + return (ntseg1 | ntseg2 | nsjw | nbrp); 1412 + } 1413 + 1414 + static inline u32 rcar_canfd_compute_data_bit_rate_cfg(const struct rcar_canfd_hw_info *info, 1415 + u16 tseg1, u16 tseg2, u16 sjw, u16 brp) 1416 + { 1417 + u32 dtseg1, dtseg2, dsjw, dbrp; 1418 + 1419 + dtseg1 = (tseg1 & (info->data_bittiming->tseg1_max - 1)) << info->sh->dtseg1; 1420 + dtseg2 = (tseg2 & (info->data_bittiming->tseg2_max - 1)) << info->sh->dtseg2; 1421 + dsjw = (sjw & (info->data_bittiming->sjw_max - 1)) << 24; 1422 + dbrp = FIELD_PREP(RCANFD_DCFG_DBRP, brp); 1423 + 1424 + return (dtseg1 | dtseg2 | dsjw | dbrp); 1425 + } 1426 + 1375 1427 static void rcar_canfd_set_bittiming(struct net_device *ndev) 1376 1428 { 1377 1429 u32 mask = RCANFD_FDCFG_TDCO | RCANFD_FDCFG_TDCE | RCANFD_FDCFG_TDCOC; ··· 1425 1407 sjw = bt->sjw - 1; 1426 1408 tseg1 = bt->prop_seg + bt->phase_seg1 - 1; 1427 1409 tseg2 = bt->phase_seg2 - 1; 1428 - 1429 - if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) || gpriv->info->shared_can_regs) { 1430 - cfg = (RCANFD_NCFG_NTSEG1(gpriv, tseg1) | RCANFD_NCFG_NBRP(brp) | 1431 - RCANFD_NCFG_NSJW(gpriv, sjw) | RCANFD_NCFG_NTSEG2(gpriv, tseg2)); 1432 - } else { 1433 - cfg = (RCANFD_CFG_TSEG1(tseg1) | RCANFD_CFG_BRP(brp) | 1434 - RCANFD_CFG_SJW(sjw) | RCANFD_CFG_TSEG2(tseg2)); 1435 - } 1436 - 1410 + cfg = rcar_canfd_compute_nominal_bit_rate_cfg(priv, tseg1, tseg2, sjw, brp); 1437 1411 rcar_canfd_write(priv->base, RCANFD_CCFG(ch), cfg); 1438 1412 1439 1413 if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD)) ··· 1436 1426 sjw = dbt->sjw - 1; 1437 1427 tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1; 1438 1428 tseg2 = dbt->phase_seg2 - 1; 1439 - 1440 - cfg = (RCANFD_DCFG_DTSEG1(gpriv, tseg1) | RCANFD_DCFG_DBRP(brp) | 1441 - RCANFD_DCFG_DSJW(gpriv, sjw) | RCANFD_DCFG_DTSEG2(gpriv, tseg2)); 1442 - 1429 + cfg = rcar_canfd_compute_data_bit_rate_cfg(gpriv->info, tseg1, tseg2, sjw, brp); 1443 1430 writel(cfg, &gpriv->fcbase[ch].dcfg); 1444 1431 1445 1432 /* Transceiver Delay Compensation */ ··· 1920 1913 priv->can.fd.do_get_auto_tdcv = rcar_canfd_get_auto_tdcv; 1921 1914 } else { 1922 1915 /* Controller starts in Classical CAN only mode */ 1923 - priv->can.bittiming_const = &rcar_canfd_bittiming_const; 1916 + if (gpriv->info->shared_can_regs) 1917 + priv->can.bittiming_const = gpriv->info->nom_bittiming; 1918 + else 1919 + priv->can.bittiming_const = &rcar_canfd_bittiming_const; 1924 1920 priv->can.ctrlmode_supported = CAN_CTRLMODE_BERR_REPORTING; 1925 1921 } 1926 1922
+3 -3
drivers/net/can/sja1000/peak_pci.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 2 /* 3 3 * Copyright (C) 2007, 2011 Wolfgang Grandegger <wg@grandegger.com> 4 - * Copyright (C) 2012 Stephane Grosjean <s.grosjean@peak-system.com> 5 4 * 6 5 * Derived from the PCAN project file driver/src/pcan_pci.c: 7 6 * 8 - * Copyright (C) 2001-2006 PEAK System-Technik GmbH 7 + * Copyright (C) 2001-2025 PEAK System-Technik GmbH 8 + * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com> 9 9 */ 10 10 11 11 #include <linux/kernel.h> ··· 22 22 23 23 #include "sja1000.h" 24 24 25 - MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>"); 25 + MODULE_AUTHOR("Stéphane Grosjean <stephane.grosjean@hms-networks.com>"); 26 26 MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCI family cards"); 27 27 MODULE_LICENSE("GPL v2"); 28 28
+4 -4
drivers/net/can/sja1000/peak_pcmcia.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 2 /* 3 - * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com> 4 - * 5 3 * CAN driver for PEAK-System PCAN-PC Card 6 4 * Derived from the PCAN project file driver/src/pcan_pccard.c 7 - * Copyright (C) 2006-2010 PEAK System-Technik GmbH 5 + * 6 + * Copyright (C) 2006-2025 PEAK System-Technik GmbH 7 + * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com> 8 8 */ 9 9 #include <linux/kernel.h> 10 10 #include <linux/module.h> ··· 19 19 #include <linux/can/dev.h> 20 20 #include "sja1000.h" 21 21 22 - MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>"); 22 + MODULE_AUTHOR("Stéphane Grosjean <stephane.grosjean@hms-networks.com>"); 23 23 MODULE_DESCRIPTION("CAN driver for PEAK-System PCAN-PC Cards"); 24 24 MODULE_LICENSE("GPL v2"); 25 25
+43 -21
drivers/net/can/usb/esd_usb.c
··· 9 9 #include <linux/can.h> 10 10 #include <linux/can/dev.h> 11 11 #include <linux/can/error.h> 12 + #include <linux/err.h> 12 13 #include <linux/ethtool.h> 13 14 #include <linux/module.h> 14 15 #include <linux/netdevice.h> ··· 275 274 int net_count; 276 275 u32 version; 277 276 int rxinitdone; 277 + int in_usb_disconnect; 278 278 void *rxbuf[ESD_USB_MAX_RX_URBS]; 279 279 dma_addr_t rxbuf_dma[ESD_USB_MAX_RX_URBS]; 280 280 }; ··· 482 480 static void esd_usb_read_bulk_callback(struct urb *urb) 483 481 { 484 482 struct esd_usb *dev = urb->context; 485 - int retval; 483 + int err; 486 484 int pos = 0; 487 485 int i; 488 486 ··· 498 496 499 497 default: 500 498 dev_info(dev->udev->dev.parent, 501 - "Rx URB aborted (%d)\n", urb->status); 499 + "Rx URB aborted (%pe)\n", ERR_PTR(urb->status)); 502 500 goto resubmit_urb; 503 501 } 504 502 ··· 541 539 urb->transfer_buffer, ESD_USB_RX_BUFFER_SIZE, 542 540 esd_usb_read_bulk_callback, dev); 543 541 544 - retval = usb_submit_urb(urb, GFP_ATOMIC); 545 - if (retval == -ENODEV) { 542 + err = usb_submit_urb(urb, GFP_ATOMIC); 543 + if (err == -ENODEV) { 546 544 for (i = 0; i < dev->net_count; i++) { 547 545 if (dev->nets[i]) 548 546 netif_device_detach(dev->nets[i]->netdev); 549 547 } 550 - } else if (retval) { 548 + } else if (err) { 551 549 dev_err(dev->udev->dev.parent, 552 - "failed resubmitting read bulk urb: %d\n", retval); 550 + "failed resubmitting read bulk urb: %pe\n", ERR_PTR(err)); 553 551 } 554 552 } 555 553 ··· 574 572 return; 575 573 576 574 if (urb->status) 577 - netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status); 575 + netdev_info(netdev, "Tx URB aborted (%pe)\n", ERR_PTR(urb->status)); 578 576 579 577 netif_trans_update(netdev); 580 578 } ··· 760 758 if (err == -ENODEV) 761 759 netif_device_detach(netdev); 762 760 if (err) 763 - netdev_err(netdev, "couldn't start device: %d\n", err); 761 + netdev_err(netdev, "couldn't start device: %pe\n", ERR_PTR(err)); 764 762 765 763 kfree(msg); 766 764 return err; ··· 802 800 /* finally start device */ 803 801 err = esd_usb_start(priv); 804 802 if (err) { 805 - netdev_warn(netdev, "couldn't start device: %d\n", err); 806 803 close_candev(netdev); 807 804 return err; 808 805 } ··· 924 923 if (err == -ENODEV) 925 924 netif_device_detach(netdev); 926 925 else 927 - netdev_warn(netdev, "failed tx_urb %d\n", err); 926 + netdev_warn(netdev, "failed tx_urb %pe\n", ERR_PTR(err)); 928 927 929 928 goto releasebuf; 930 929 } ··· 948 947 return ret; 949 948 } 950 949 951 - static int esd_usb_close(struct net_device *netdev) 950 + /* Stop interface */ 951 + static int esd_usb_stop(struct esd_usb_net_priv *priv) 952 952 { 953 - struct esd_usb_net_priv *priv = netdev_priv(netdev); 954 953 union esd_usb_msg *msg; 954 + int err; 955 955 int i; 956 956 957 957 msg = kmalloc(sizeof(*msg), GFP_KERNEL); ··· 966 964 msg->filter.option = ESD_USB_ID_ENABLE; /* start with segment 0 */ 967 965 for (i = 0; i <= ESD_USB_MAX_ID_SEGMENT; i++) 968 966 msg->filter.mask[i] = 0; 969 - if (esd_usb_send_msg(priv->usb, msg) < 0) 970 - netdev_err(netdev, "sending idadd message failed\n"); 967 + err = esd_usb_send_msg(priv->usb, msg); 968 + if (err < 0) { 969 + netdev_err(priv->netdev, "sending idadd message failed: %pe\n", ERR_PTR(err)); 970 + goto bail; 971 + } 971 972 972 973 /* set CAN controller to reset mode */ 973 974 msg->hdr.len = sizeof(struct esd_usb_set_baudrate_msg) / sizeof(u32); /* # of 32bit words */ ··· 978 973 msg->setbaud.net = priv->index; 979 974 msg->setbaud.rsvd = 0; 980 975 msg->setbaud.baud = cpu_to_le32(ESD_USB_NO_BAUDRATE); 981 - if (esd_usb_send_msg(priv->usb, msg) < 0) 982 - netdev_err(netdev, "sending setbaud message failed\n"); 976 + err = esd_usb_send_msg(priv->usb, msg); 977 + if (err < 0) 978 + netdev_err(priv->netdev, "sending setbaud message failed: %pe\n", ERR_PTR(err)); 979 + 980 + bail: 981 + kfree(msg); 982 + 983 + return err; 984 + } 985 + 986 + static int esd_usb_close(struct net_device *netdev) 987 + { 988 + struct esd_usb_net_priv *priv = netdev_priv(netdev); 989 + int err = 0; 990 + 991 + if (!priv->usb->in_usb_disconnect) { 992 + /* It's moot to try this in usb_disconnect()! */ 993 + err = esd_usb_stop(priv); 994 + } 983 995 984 996 priv->can.state = CAN_STATE_STOPPED; 985 997 ··· 1004 982 1005 983 close_candev(netdev); 1006 984 1007 - kfree(msg); 1008 - 1009 - return 0; 985 + return err; 1010 986 } 1011 987 1012 988 static const struct net_device_ops esd_usb_netdev_ops = { ··· 1271 1251 1272 1252 err = register_candev(netdev); 1273 1253 if (err) { 1274 - dev_err(&intf->dev, "couldn't register CAN device: %d\n", err); 1254 + dev_err(&intf->dev, "couldn't register CAN device: %pe\n", ERR_PTR(err)); 1275 1255 free_candev(netdev); 1276 1256 err = -ENOMEM; 1277 1257 goto done; 1278 1258 } 1279 1259 1280 1260 dev->nets[index] = priv; 1281 - netdev_info(netdev, "device %s registered\n", netdev->name); 1261 + netdev_info(netdev, "registered\n"); 1282 1262 1283 1263 done: 1284 1264 return err; ··· 1374 1354 usb_set_intfdata(intf, NULL); 1375 1355 1376 1356 if (dev) { 1357 + dev->in_usb_disconnect = 1; 1377 1358 for (i = 0; i < dev->net_count; i++) { 1378 1359 if (dev->nets[i]) { 1379 1360 netdev = dev->nets[i]->netdev; 1361 + netdev_info(netdev, "unregister\n"); 1380 1362 unregister_netdev(netdev); 1381 1363 free_candev(netdev); 1382 1364 }
+3 -3
drivers/net/can/usb/peak_usb/pcan_usb.c
··· 3 3 * CAN driver for PEAK System PCAN-USB adapter 4 4 * Derived from the PCAN project file driver/src/pcan_usb.c 5 5 * 6 - * Copyright (C) 2003-2010 PEAK System-Technik GmbH 7 - * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com> 6 + * Copyright (C) 2003-2025 PEAK System-Technik GmbH 7 + * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com> 8 8 * 9 9 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de> 10 10 */ ··· 919 919 CAN_CTRLMODE_LOOPBACK; 920 920 } else { 921 921 dev_info(dev->netdev->dev.parent, 922 - "Firmware update available. Please contact support@peak-system.com\n"); 922 + "Firmware update available. Please contact support.peak@hms-networks.com\n"); 923 923 } 924 924 925 925 return 0;
+3 -3
drivers/net/can/usb/peak_usb/pcan_usb_core.c
··· 3 3 * CAN driver for PEAK System USB adapters 4 4 * Derived from the PCAN project file driver/src/pcan_usb_core.c 5 5 * 6 - * Copyright (C) 2003-2010 PEAK System-Technik GmbH 7 - * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com> 6 + * Copyright (C) 2003-2025 PEAK System-Technik GmbH 7 + * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com> 8 8 * 9 9 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de> 10 10 */ ··· 24 24 25 25 #include "pcan_usb_core.h" 26 26 27 - MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>"); 27 + MODULE_AUTHOR("Stéphane Grosjean <stephane.grosjean@hms-networks.com>"); 28 28 MODULE_DESCRIPTION("CAN driver for PEAK-System USB adapters"); 29 29 MODULE_LICENSE("GPL v2"); 30 30
+2 -2
drivers/net/can/usb/peak_usb/pcan_usb_core.h
··· 3 3 * CAN driver for PEAK System USB adapters 4 4 * Derived from the PCAN project file driver/src/pcan_usb_core.c 5 5 * 6 - * Copyright (C) 2003-2010 PEAK System-Technik GmbH 7 - * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com> 6 + * Copyright (C) 2003-2025 PEAK System-Technik GmbH 7 + * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com> 8 8 * 9 9 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de> 10 10 */
+2 -1
drivers/net/can/usb/peak_usb/pcan_usb_fd.c
··· 2 2 /* 3 3 * CAN driver for PEAK System PCAN-USB FD / PCAN-USB Pro FD adapter 4 4 * 5 - * Copyright (C) 2013-2014 Stephane Grosjean <s.grosjean@peak-system.com> 5 + * Copyright (C) 2013-2025 PEAK System-Technik GmbH 6 + * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com> 6 7 */ 7 8 #include <linux/ethtool.h> 8 9 #include <linux/module.h>
+2 -2
drivers/net/can/usb/peak_usb/pcan_usb_pro.c
··· 3 3 * CAN driver for PEAK System PCAN-USB Pro adapter 4 4 * Derived from the PCAN project file driver/src/pcan_usbpro.c 5 5 * 6 - * Copyright (C) 2003-2011 PEAK System-Technik GmbH 7 - * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com> 6 + * Copyright (C) 2003-2025 PEAK System-Technik GmbH 7 + * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com> 8 8 */ 9 9 #include <linux/ethtool.h> 10 10 #include <linux/module.h>
+2 -2
drivers/net/can/usb/peak_usb/pcan_usb_pro.h
··· 3 3 * CAN driver for PEAK System PCAN-USB Pro adapter 4 4 * Derived from the PCAN project file driver/src/pcan_usbpro_fw.h 5 5 * 6 - * Copyright (C) 2003-2011 PEAK System-Technik GmbH 7 - * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com> 6 + * Copyright (C) 2003-2025 PEAK System-Technik GmbH 7 + * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com> 8 8 */ 9 9 #ifndef PCAN_USB_PRO_H 10 10 #define PCAN_USB_PRO_H
+1 -1
drivers/net/can/vcan.c
··· 156 156 static void vcan_setup(struct net_device *dev) 157 157 { 158 158 dev->type = ARPHRD_CAN; 159 - dev->mtu = CANFD_MTU; 159 + dev->mtu = CANXL_MTU; 160 160 dev->hard_header_len = 0; 161 161 dev->addr_len = 0; 162 162 dev->tx_queue_len = 0;
+1 -1
drivers/net/can/vxcan.c
··· 156 156 struct can_ml_priv *can_ml; 157 157 158 158 dev->type = ARPHRD_CAN; 159 - dev->mtu = CANFD_MTU; 159 + dev->mtu = CANXL_MTU; 160 160 dev->hard_header_len = 0; 161 161 dev->addr_len = 0; 162 162 dev->tx_queue_len = 0;
+46 -2
include/linux/can/bittiming.h
··· 16 16 17 17 #define CAN_CTRLMODE_FD_TDC_MASK \ 18 18 (CAN_CTRLMODE_TDC_AUTO | CAN_CTRLMODE_TDC_MANUAL) 19 + #define CAN_CTRLMODE_TDC_AUTO_MASK \ 20 + (CAN_CTRLMODE_TDC_AUTO) 21 + #define CAN_CTRLMODE_TDC_MANUAL_MASK \ 22 + (CAN_CTRLMODE_TDC_MANUAL) 19 23 20 24 /* 21 25 * struct can_tdc - CAN FD Transmission Delay Compensation parameters ··· 118 114 u32 tdcf_max; 119 115 }; 120 116 117 + struct data_bittiming_params { 118 + const struct can_bittiming_const *data_bittiming_const; 119 + struct can_bittiming data_bittiming; 120 + const struct can_tdc_const *tdc_const; 121 + struct can_tdc tdc; 122 + const u32 *data_bitrate_const; 123 + unsigned int data_bitrate_const_cnt; 124 + int (*do_set_data_bittiming)(struct net_device *dev); 125 + int (*do_get_auto_tdcv)(const struct net_device *dev, u32 *tdcv); 126 + }; 127 + 121 128 #ifdef CONFIG_CAN_CALC_BITTIMING 122 129 int can_calc_bittiming(const struct net_device *dev, struct can_bittiming *bt, 123 130 const struct can_bittiming_const *btc, struct netlink_ext_ack *extack); 124 131 125 132 void can_calc_tdco(struct can_tdc *tdc, const struct can_tdc_const *tdc_const, 126 133 const struct can_bittiming *dbt, 127 - u32 *ctrlmode, u32 ctrlmode_supported); 134 + u32 tdc_mask, u32 *ctrlmode, u32 ctrlmode_supported); 128 135 #else /* !CONFIG_CAN_CALC_BITTIMING */ 129 136 static inline int 130 137 can_calc_bittiming(const struct net_device *dev, struct can_bittiming *bt, ··· 148 133 static inline void 149 134 can_calc_tdco(struct can_tdc *tdc, const struct can_tdc_const *tdc_const, 150 135 const struct can_bittiming *dbt, 151 - u32 *ctrlmode, u32 ctrlmode_supported) 136 + u32 tdc_mask, u32 *ctrlmode, u32 ctrlmode_supported) 152 137 { 153 138 } 154 139 #endif /* CONFIG_CAN_CALC_BITTIMING */ ··· 163 148 const u32 *bitrate_const, 164 149 const unsigned int bitrate_const_cnt, 165 150 struct netlink_ext_ack *extack); 151 + 152 + /* 153 + * can_get_relative_tdco() - TDCO relative to the sample point 154 + * 155 + * struct can_tdc::tdco represents the absolute offset from TDCV. Some 156 + * controllers use instead an offset relative to the Sample Point (SP) 157 + * such that: 158 + * 159 + * SSP = TDCV + absolute TDCO 160 + * = TDCV + SP + relative TDCO 161 + * 162 + * -+----------- one bit ----------+-- TX pin 163 + * |<--- Sample Point --->| 164 + * 165 + * --+----------- one bit ----------+-- RX pin 166 + * |<-------- TDCV -------->| 167 + * |<------------------------>| absolute TDCO 168 + * |<--- Sample Point --->| 169 + * | |<->| relative TDCO 170 + * |<------------- Secondary Sample Point ------------>| 171 + */ 172 + static inline s32 can_get_relative_tdco(const struct data_bittiming_params *dbt_params) 173 + { 174 + const struct can_bittiming *dbt = &dbt_params->data_bittiming; 175 + s32 sample_point_in_tc = (CAN_SYNC_SEG + dbt->prop_seg + 176 + dbt->phase_seg1) * dbt->brp; 177 + 178 + return (s32)dbt_params->tdc.tdco - sample_point_in_tc; 179 + } 166 180 167 181 /* 168 182 * can_bit_time() - Duration of one bit
+5 -61
include/linux/can/dev.h
··· 38 38 CAN_TERMINATION_GPIO_MAX, 39 39 }; 40 40 41 - struct data_bittiming_params { 42 - const struct can_bittiming_const *data_bittiming_const; 43 - struct can_bittiming data_bittiming; 44 - const struct can_tdc_const *tdc_const; 45 - struct can_tdc tdc; 46 - const u32 *data_bitrate_const; 47 - unsigned int data_bitrate_const_cnt; 48 - int (*do_set_data_bittiming)(struct net_device *dev); 49 - int (*do_get_auto_tdcv)(const struct net_device *dev, u32 *tdcv); 50 - }; 51 - 52 41 /* 53 42 * CAN common private data 54 43 */ ··· 85 96 return !!(priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK); 86 97 } 87 98 88 - /* 89 - * can_get_relative_tdco() - TDCO relative to the sample point 90 - * 91 - * struct can_tdc::tdco represents the absolute offset from TDCV. Some 92 - * controllers use instead an offset relative to the Sample Point (SP) 93 - * such that: 94 - * 95 - * SSP = TDCV + absolute TDCO 96 - * = TDCV + SP + relative TDCO 97 - * 98 - * -+----------- one bit ----------+-- TX pin 99 - * |<--- Sample Point --->| 100 - * 101 - * --+----------- one bit ----------+-- RX pin 102 - * |<-------- TDCV -------->| 103 - * |<------------------------>| absolute TDCO 104 - * |<--- Sample Point --->| 105 - * | |<->| relative TDCO 106 - * |<------------- Secondary Sample Point ------------>| 107 - */ 108 - static inline s32 can_get_relative_tdco(const struct can_priv *priv) 109 - { 110 - const struct can_bittiming *dbt = &priv->fd.data_bittiming; 111 - s32 sample_point_in_tc = (CAN_SYNC_SEG + dbt->prop_seg + 112 - dbt->phase_seg1) * dbt->brp; 113 - 114 - return (s32)priv->fd.tdc.tdco - sample_point_in_tc; 115 - } 116 - 117 - /* helper to define static CAN controller features at device creation time */ 118 - static inline int __must_check can_set_static_ctrlmode(struct net_device *dev, 119 - u32 static_mode) 120 - { 121 - struct can_priv *priv = netdev_priv(dev); 122 - 123 - /* alloc_candev() succeeded => netdev_priv() is valid at this point */ 124 - if (priv->ctrlmode_supported & static_mode) { 125 - netdev_warn(dev, 126 - "Controller features can not be supported and static at the same time\n"); 127 - return -EINVAL; 128 - } 129 - priv->ctrlmode = static_mode; 130 - 131 - /* override MTU which was set by default in can_setup()? */ 132 - if (static_mode & CAN_CTRLMODE_FD) 133 - dev->mtu = CANFD_MTU; 134 - 135 - return 0; 136 - } 137 - 138 99 static inline u32 can_get_static_ctrlmode(struct can_priv *priv) 139 100 { 140 101 return priv->ctrlmode & ~priv->ctrlmode_supported; ··· 126 187 127 188 int open_candev(struct net_device *dev); 128 189 void close_candev(struct net_device *dev); 190 + void can_set_default_mtu(struct net_device *dev); 129 191 int can_change_mtu(struct net_device *dev, int new_mtu); 192 + int __must_check can_set_static_ctrlmode(struct net_device *dev, 193 + u32 static_mode); 130 194 int can_eth_ioctl_hwts(struct net_device *netdev, struct ifreq *ifr, int cmd); 131 195 int can_ethtool_op_get_ts_info_hwts(struct net_device *dev, 132 196 struct kernel_ethtool_ts_info *info); ··· 141 199 void can_bus_off(struct net_device *dev); 142 200 143 201 const char *can_get_state_str(const enum can_state state); 202 + const char *can_get_ctrlmode_str(u32 ctrlmode); 203 + 144 204 void can_state_get_by_berr_counter(const struct net_device *dev, 145 205 const struct can_berr_counter *bec, 146 206 enum can_state *tx_state,
+2 -2
include/linux/can/dev/peak_canfd.h
··· 2 2 /* 3 3 * CAN driver for PEAK System micro-CAN based adapters 4 4 * 5 - * Copyright (C) 2003-2011 PEAK System-Technik GmbH 6 - * Copyright (C) 2011-2013 Stephane Grosjean <s.grosjean@peak-system.com> 5 + * Copyright (C) 2003-2025 PEAK System-Technik GmbH 6 + * Author: Stéphane Grosjean <stephane.grosjean@hms-networks.com> 7 7 */ 8 8 #ifndef PUCAN_H 9 9 #define PUCAN_H
+7 -7
include/uapi/linux/can/netlink.h
··· 101 101 #define CAN_CTRLMODE_PRESUME_ACK 0x40 /* Ignore missing CAN ACKs */ 102 102 #define CAN_CTRLMODE_FD_NON_ISO 0x80 /* CAN FD in non-ISO mode */ 103 103 #define CAN_CTRLMODE_CC_LEN8_DLC 0x100 /* Classic CAN DLC option */ 104 - #define CAN_CTRLMODE_TDC_AUTO 0x200 /* CAN transiver automatically calculates TDCV */ 105 - #define CAN_CTRLMODE_TDC_MANUAL 0x400 /* TDCV is manually set up by user */ 104 + #define CAN_CTRLMODE_TDC_AUTO 0x200 /* FD transceiver automatically calculates TDCV */ 105 + #define CAN_CTRLMODE_TDC_MANUAL 0x400 /* FD TDCV is manually set up by user */ 106 106 107 107 /* 108 108 * CAN device statistics ··· 129 129 IFLA_CAN_RESTART_MS, 130 130 IFLA_CAN_RESTART, 131 131 IFLA_CAN_BERR_COUNTER, 132 - IFLA_CAN_DATA_BITTIMING, 133 - IFLA_CAN_DATA_BITTIMING_CONST, 132 + IFLA_CAN_DATA_BITTIMING, /* FD */ 133 + IFLA_CAN_DATA_BITTIMING_CONST, /* FD */ 134 134 IFLA_CAN_TERMINATION, 135 135 IFLA_CAN_TERMINATION_CONST, 136 136 IFLA_CAN_BITRATE_CONST, 137 - IFLA_CAN_DATA_BITRATE_CONST, 137 + IFLA_CAN_DATA_BITRATE_CONST, /* FD */ 138 138 IFLA_CAN_BITRATE_MAX, 139 - IFLA_CAN_TDC, 139 + IFLA_CAN_TDC, /* FD */ 140 140 IFLA_CAN_CTRLMODE_EXT, 141 141 142 142 /* add new constants above here */ ··· 145 145 }; 146 146 147 147 /* 148 - * CAN FD Transmitter Delay Compensation (TDC) 148 + * CAN FD/XL Transmitter Delay Compensation (TDC) 149 149 * 150 150 * Please refer to struct can_tdc_const and can_tdc in 151 151 * include/linux/can/bittiming.h for further details.
+1 -1
net/can/af_can.c
··· 221 221 } 222 222 223 223 /* Make sure the CAN frame can pass the selected CAN netdevice. */ 224 - if (unlikely(skb->len > skb->dev->mtu)) { 224 + if (unlikely(skb->len > READ_ONCE(skb->dev->mtu))) { 225 225 err = -EMSGSIZE; 226 226 goto inval_skb; 227 227 }
+1 -1
net/can/isotp.c
··· 1313 1313 err = -ENODEV; 1314 1314 goto out; 1315 1315 } 1316 - if (dev->mtu < so->ll.mtu) { 1316 + if (READ_ONCE(dev->mtu) < so->ll.mtu) { 1317 1317 dev_put(dev); 1318 1318 err = -EINVAL; 1319 1319 goto out;
+39 -28
net/can/raw.c
··· 75 75 */ 76 76 77 77 struct uniqframe { 78 - int skbcnt; 79 78 const struct sk_buff *skb; 79 + int skbcnt; 80 80 unsigned int join_rx_count; 81 81 }; 82 82 83 83 struct raw_sock { 84 84 struct sock sk; 85 - int bound; 86 - int ifindex; 87 85 struct net_device *dev; 88 86 netdevice_tracker dev_tracker; 89 87 struct list_head notifier; 90 - int loopback; 91 - int recv_own_msgs; 92 - int fd_frames; 93 - int xl_frames; 88 + int ifindex; 89 + unsigned int bound:1; 90 + unsigned int loopback:1; 91 + unsigned int recv_own_msgs:1; 92 + unsigned int fd_frames:1; 93 + unsigned int xl_frames:1; 94 + unsigned int join_filters:1; 94 95 struct can_raw_vcid_options raw_vcid_opts; 95 96 canid_t tx_vcid_shifted; 96 97 canid_t rx_vcid_shifted; 97 98 canid_t rx_vcid_mask_shifted; 98 - int join_filters; 99 + can_err_mask_t err_mask; 99 100 int count; /* number of active filters */ 100 101 struct can_filter dfilter; /* default/single filter */ 101 102 struct can_filter *filter; /* pointer to filter(s) */ 102 - can_err_mask_t err_mask; 103 103 struct uniqframe __percpu *uniq; 104 104 }; 105 105 ··· 560 560 struct can_filter sfilter; /* single filter */ 561 561 struct net_device *dev = NULL; 562 562 can_err_mask_t err_mask = 0; 563 - int fd_frames; 564 563 int count = 0; 564 + int flag; 565 565 int err = 0; 566 566 567 567 if (level != SOL_CAN_RAW) ··· 682 682 break; 683 683 684 684 case CAN_RAW_LOOPBACK: 685 - if (optlen != sizeof(ro->loopback)) 685 + if (optlen != sizeof(flag)) 686 686 return -EINVAL; 687 687 688 - if (copy_from_sockptr(&ro->loopback, optval, optlen)) 688 + if (copy_from_sockptr(&flag, optval, optlen)) 689 689 return -EFAULT; 690 690 691 + ro->loopback = !!flag; 691 692 break; 692 693 693 694 case CAN_RAW_RECV_OWN_MSGS: 694 - if (optlen != sizeof(ro->recv_own_msgs)) 695 + if (optlen != sizeof(flag)) 695 696 return -EINVAL; 696 697 697 - if (copy_from_sockptr(&ro->recv_own_msgs, optval, optlen)) 698 + if (copy_from_sockptr(&flag, optval, optlen)) 698 699 return -EFAULT; 699 700 701 + ro->recv_own_msgs = !!flag; 700 702 break; 701 703 702 704 case CAN_RAW_FD_FRAMES: 703 - if (optlen != sizeof(fd_frames)) 705 + if (optlen != sizeof(flag)) 704 706 return -EINVAL; 705 707 706 - if (copy_from_sockptr(&fd_frames, optval, optlen)) 708 + if (copy_from_sockptr(&flag, optval, optlen)) 707 709 return -EFAULT; 708 710 709 711 /* Enabling CAN XL includes CAN FD */ 710 - if (ro->xl_frames && !fd_frames) 712 + if (ro->xl_frames && !flag) 711 713 return -EINVAL; 712 714 713 - ro->fd_frames = fd_frames; 715 + ro->fd_frames = !!flag; 714 716 break; 715 717 716 718 case CAN_RAW_XL_FRAMES: 717 - if (optlen != sizeof(ro->xl_frames)) 719 + if (optlen != sizeof(flag)) 718 720 return -EINVAL; 719 721 720 - if (copy_from_sockptr(&ro->xl_frames, optval, optlen)) 722 + if (copy_from_sockptr(&flag, optval, optlen)) 721 723 return -EFAULT; 724 + 725 + ro->xl_frames = !!flag; 722 726 723 727 /* Enabling CAN XL includes CAN FD */ 724 728 if (ro->xl_frames) ··· 743 739 break; 744 740 745 741 case CAN_RAW_JOIN_FILTERS: 746 - if (optlen != sizeof(ro->join_filters)) 742 + if (optlen != sizeof(flag)) 747 743 return -EINVAL; 748 744 749 - if (copy_from_sockptr(&ro->join_filters, optval, optlen)) 745 + if (copy_from_sockptr(&flag, optval, optlen)) 750 746 return -EFAULT; 751 747 748 + ro->join_filters = !!flag; 752 749 break; 753 750 754 751 default: ··· 763 758 { 764 759 struct sock *sk = sock->sk; 765 760 struct raw_sock *ro = raw_sk(sk); 761 + int flag; 766 762 int len; 767 763 void *val; 768 764 ··· 812 806 case CAN_RAW_LOOPBACK: 813 807 if (len > sizeof(int)) 814 808 len = sizeof(int); 815 - val = &ro->loopback; 809 + flag = ro->loopback; 810 + val = &flag; 816 811 break; 817 812 818 813 case CAN_RAW_RECV_OWN_MSGS: 819 814 if (len > sizeof(int)) 820 815 len = sizeof(int); 821 - val = &ro->recv_own_msgs; 816 + flag = ro->recv_own_msgs; 817 + val = &flag; 822 818 break; 823 819 824 820 case CAN_RAW_FD_FRAMES: 825 821 if (len > sizeof(int)) 826 822 len = sizeof(int); 827 - val = &ro->fd_frames; 823 + flag = ro->fd_frames; 824 + val = &flag; 828 825 break; 829 826 830 827 case CAN_RAW_XL_FRAMES: 831 828 if (len > sizeof(int)) 832 829 len = sizeof(int); 833 - val = &ro->xl_frames; 830 + flag = ro->xl_frames; 831 + val = &flag; 834 832 break; 835 833 836 834 case CAN_RAW_XL_VCID_OPTS: { ··· 859 849 case CAN_RAW_JOIN_FILTERS: 860 850 if (len > sizeof(int)) 861 851 len = sizeof(int); 862 - val = &ro->join_filters; 852 + flag = ro->join_filters; 853 + val = &flag; 863 854 break; 864 855 865 856 default: ··· 961 950 err = -EINVAL; 962 951 963 952 /* check for valid CAN (CC/FD/XL) frame content */ 964 - txmtu = raw_check_txframe(ro, skb, dev->mtu); 953 + txmtu = raw_check_txframe(ro, skb, READ_ONCE(dev->mtu)); 965 954 if (!txmtu) 966 955 goto free_skb; 967 956