History

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 ... ====================

Jakub Kicinski committed 1 year ago

Commit bb9a2422 parents ed6cfe8 896d52a29 files · +831 −566Browse files

Unified · Split

29 files
  1. .mailmap +3 −0
  2. MAINTAINERS +2 −2
  3. drivers/net/can/dev/calc_bittiming.c +6 −4
  4. drivers/net/can/dev/dev.c +75 −5
  5. drivers/net/can/dev/netlink.c +373 −219
  6. drivers/net/can/m_can/m_can.c +2 −4
  7. drivers/net/can/peak_canfd/peak_canfd.c +2 −2
  8. drivers/net/can/peak_canfd/peak_canfd_user.h +2 −2
  9. drivers/net/can/peak_canfd/peak_pciefd_main.c +3 −3
  10. drivers/net/can/rcar/rcar_can.c +149 −143
  11. drivers/net/can/rcar/rcar_canfd.c +47 −37
  12. drivers/net/can/sja1000/peak_pci.c +3 −3
  13. drivers/net/can/sja1000/peak_pcmcia.c +4 −4
  14. drivers/net/can/usb/esd_usb.c +43 −21
  15. drivers/net/can/usb/peak_usb/pcan_usb.c +3 −3
  16. drivers/net/can/usb/peak_usb/pcan_usb_core.c +3 −3
  17. drivers/net/can/usb/peak_usb/pcan_usb_core.h +2 −2
  18. drivers/net/can/usb/peak_usb/pcan_usb_fd.c +2 −1
  19. drivers/net/can/usb/peak_usb/pcan_usb_pro.c +2 −2
  20. drivers/net/can/usb/peak_usb/pcan_usb_pro.h +2 −2
  21. drivers/net/can/vcan.c +1 −1
  22. drivers/net/can/vxcan.c +1 −1
  23. include/linux/can/bittiming.h +46 −2
  24. include/linux/can/dev.h +5 −61
  25. include/linux/can/dev/peak_canfd.h +2 −2
  26. include/uapi/linux/can/netlink.h +7 −7
  27. net/can/af_can.c +1 −1
  28. net/can/isotp.c +1 −1
  29. net/can/raw.c +39 −28
.mailmap+3−0
@@ -741,6 +741,8 @@ Sriram Yagnaraman <sriram.yagnaraman@ericsson.com> <sriram.yagnaraman@est.tech> · 740 unmodified lines
741741 Stanislav Fomichev <sdf@fomichev.me> <sdf@google.com>
742742 Stanislav Fomichev <sdf@fomichev.me> <stfomichev@gmail.com>
743743 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>
744746 Stéphane Witzmann <stephane.witzmann@ubpmes.univ-bpclermont.fr>
745747 Stephen Hemminger <stephen@networkplumber.org> <shemminger@linux-foundation.org>
746748 Stephen Hemminger <stephen@networkplumber.org> <shemminger@osdl.org>
@@ -817,6 +819,7 @@ Veera Sundaram Sankaran <quic_veeras@quicinc.com> <veeras@codeaurora.org> · 70 unmodified lines
817819 Veerabhadrarao Badiganti <quic_vbadigan@quicinc.com> <vbadigan@codeaurora.org>
818820 Venkateswara Naralasetty <quic_vnaralas@quicinc.com> <vnaralas@codeaurora.org>
819821 Vikash Garodia <quic_vgarodia@quicinc.com> <vgarodia@codeaurora.org>
822+Vincent Mailhol <mailhol@kernel.org> <mailhol.vincent@wanadoo.fr>
820823 Vinod Koul <vkoul@kernel.org> <vinod.koul@intel.com>
821824 Vinod Koul <vkoul@kernel.org> <vinod.koul@linux.intel.com>
822825 Vinod Koul <vkoul@kernel.org> <vkoul@infradead.org>
MAINTAINERS+2−2
@@ -5415,7 +5415,7 @@ F: net/sched/sch_cake.c · 5414 unmodified lines
54155415
54165416 CAN NETWORK DRIVERS
54175417 M: Marc Kleine-Budde <mkl@pengutronix.de>
5418−M: Vincent Mailhol <mailhol.vincent@wanadoo.fr>
5418+M: Vincent Mailhol <mailhol@kernel.org>
54195419 L: linux-can@vger.kernel.org
54205420 S: Maintained
54215421 W: https://github.com/linux-can
@@ -9094,7 +9094,7 @@ S: Odd Fixes · 3672 unmodified lines
90949094 F: drivers/net/ethernet/agere/
90959095
90969096 ETAS ES58X CAN/USB DRIVER
9097−M: Vincent Mailhol <mailhol.vincent@wanadoo.fr>
9097+M: Vincent Mailhol <mailhol@kernel.org>
90989098 L: linux-can@vger.kernel.org
90999099 S: Maintained
91009100 F: Documentation/networking/devlink/etas_es58x.rst
drivers/net/can/dev/calc_bittiming.c+6−4
@@ -173,13 +173,15 @@ int can_calc_bittiming(const struct net_device *dev, struct can_bittiming *bt, · 172 unmodified lines
173173
174174 void can_calc_tdco(struct can_tdc *tdc, const struct can_tdc_const *tdc_const,
175175 const struct can_bittiming *dbt,
176− u32 *ctrlmode, u32 ctrlmode_supported)
176+ u32 tdc_mask, u32 *ctrlmode, u32 ctrlmode_supported)
177177
178178 {
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))
180182 return;
181183
182− *ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
184+ *ctrlmode &= ~tdc_mask;
183185
184186 /* As specified in ISO 11898-1 section 11.3.3 "Transmitter
185187 * delay compensation" (TDC) is only applicable if data BRP is
@@ -193,6 +195,6 @@ void can_calc_tdco(struct can_tdc *tdc, const struct can_tdc_const *tdc_const, · 7 unmodified lines
193195 if (sample_point_in_tc < tdc_const->tdco_min)
194196 return;
195197 tdc->tdco = min(sample_point_in_tc, tdc_const->tdco_max);
196− *ctrlmode |= CAN_CTRLMODE_TDC_AUTO;
198+ *ctrlmode |= tdc_auto;
197199 }
198200 }
drivers/net/can/dev/dev.c+75−5
@@ -4,17 +4,17 @@ · 3 unmodified lines
44 * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com>
55 */
66
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>
127 #include <linux/can.h>
138 #include <linux/can/can-ml.h>
149 #include <linux/can/dev.h>
1510 #include <linux/can/skb.h>
1611 #include <linux/gpio/consumer.h>
12+#include <linux/if_arp.h>
13+#include <linux/kernel.h>
14+#include <linux/netdevice.h>
1715 #include <linux/of.h>
16+#include <linux/slab.h>
17+#include <linux/workqueue.h>
1818
1919 static void can_update_state_error_stats(struct net_device *dev,
2020 enum can_state new_state)
@@ -88,6 +88,39 @@ const char *can_get_state_str(const enum can_state state) · 67 unmodified lines
8888 }
8989 EXPORT_SYMBOL_GPL(can_get_state_str);
9090
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);
123+
91124 static enum can_state can_state_err_to_state(u16 err)
92125 {
93126 if (err < CAN_ERROR_WARNING_THRESHOLD)
@@ -240,6 +273,8 @@ void can_setup(struct net_device *dev) · 146 unmodified lines
240273 {
241274 dev->type = ARPHRD_CAN;
242275 dev->mtu = CAN_MTU;
276+ dev->min_mtu = CAN_MTU;
277+ dev->max_mtu = CAN_MTU;
243278 dev->hard_header_len = 0;
244279 dev->addr_len = 0;
245280 dev->tx_queue_len = 10;
@@ -309,6 +344,21 @@ void free_candev(struct net_device *dev) · 63 unmodified lines
309344 }
310345 EXPORT_SYMBOL_GPL(free_candev);
311346
347+void can_set_default_mtu(struct net_device *dev)
348+{
349+ struct can_priv *priv = netdev_priv(dev);
350+
351+ if (priv->ctrlmode & CAN_CTRLMODE_FD) {
352+ dev->mtu = CANFD_MTU;
353+ dev->min_mtu = CANFD_MTU;
354+ dev->max_mtu = CANFD_MTU;
355+ } else {
356+ dev->mtu = CAN_MTU;
357+ dev->min_mtu = CAN_MTU;
358+ dev->max_mtu = CAN_MTU;
359+ }
360+}
361+
312362 /* changing MTU and control mode for CAN/CANFD devices */
313363 int can_change_mtu(struct net_device *dev, int new_mtu)
314364 {
@@ -347,6 +397,26 @@ int can_change_mtu(struct net_device *dev, int new_mtu) · 32 unmodified lines
347397 }
348398 EXPORT_SYMBOL_GPL(can_change_mtu);
349399
400+/* helper to define static CAN controller features at device creation time */
401+int can_set_static_ctrlmode(struct net_device *dev, u32 static_mode)
402+{
403+ struct can_priv *priv = netdev_priv(dev);
404+
405+ /* alloc_candev() succeeded => netdev_priv() is valid at this point */
406+ if (priv->ctrlmode_supported & static_mode) {
407+ netdev_warn(dev,
408+ "Controller features can not be supported and static at the same time\n");
409+ return -EINVAL;
410+ }
411+ priv->ctrlmode = static_mode;
412+
413+ /* override MTU which was set by default in can_setup()? */
414+ can_set_default_mtu(dev);
415+
416+ return 0;
417+}
418+EXPORT_SYMBOL_GPL(can_set_static_ctrlmode);
419+
350420 /* generic implementation of netdev_ops::ndo_eth_ioctl for CAN devices
351421 * supporting hardware timestamps
352422 */
drivers/net/can/dev/netlink.c+373−219
@@ -36,116 +36,245 @@ static const struct nla_policy can_tdc_policy[IFLA_CAN_TDC_MAX + 1] = { · 35 unmodified lines
3636 [IFLA_CAN_TDC_TDCF] = { .type = NLA_U32 },
3737 };
3838
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)
4142 {
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+
4251 /* sample point is in one-tenth of a percent */
4352 if (bt->sample_point >= 1000) {
4453 NL_SET_ERR_MSG(extack, "sample point must be between 0 and 100%");
45−
4654 return -EINVAL;
4755 }
4856
4957 return 0;
5058 }
5159
52−static int can_validate(struct nlattr *tb[], struct nlattr *data[],
53− struct netlink_ext_ack *extack)
60+static int can_validate_tdc(struct nlattr *data_tdc,
61+ struct netlink_ext_ack *extack, u32 tdc_flags)
5462 {
55− bool is_can_fd = false;
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;
56127 int err;
57128
58129 /* Make sure that valid CAN FD configurations always consist of
59130 * - nominal/arbitration bittiming
60131 * - data bittiming
61132 * - control mode with CAN_CTRLMODE_FD set
62− * - TDC parameters are coherent (details below)
133+ * - TDC parameters are coherent (details in can_validate_tdc())
63134 */
64135
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;
174+
175+ return 0;
176+}
177+
178+static int can_validate(struct nlattr *tb[], struct nlattr *data[],
179+ struct netlink_ext_ack *extack)
180+{
181+ u32 flags = 0;
182+ int err;
183+
65184 if (!data)
66185 return 0;
67186
68187 if (data[IFLA_CAN_CTRLMODE]) {
69188 struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
70− u32 tdc_flags = cm->flags & CAN_CTRLMODE_FD_TDC_MASK;
71189
72− is_can_fd = cm->flags & cm->mask & CAN_CTRLMODE_FD;
190+ flags = cm->flags & cm->mask;
191+ }
73192
74− /* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually exclusive */
75− if (tdc_flags == CAN_CTRLMODE_FD_TDC_MASK)
76− return -EOPNOTSUPP;
77− /* If one of the CAN_CTRLMODE_TDC_* flag is set then
78− * TDC must be set and vice-versa
79− */
80− if (!!tdc_flags != !!data[IFLA_CAN_TDC])
81− return -EOPNOTSUPP;
82− /* If providing TDC parameters, at least TDCO is
83− * needed. TDCV is needed if and only if
84− * CAN_CTRLMODE_TDC_MANUAL is set
85− */
86− if (data[IFLA_CAN_TDC]) {
87− struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];
193+ err = can_validate_bittiming(data, extack, IFLA_CAN_BITTIMING);
194+ if (err)
195+ return err;
88196
89− err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX,
90− data[IFLA_CAN_TDC],
91− can_tdc_policy, extack);
92− if (err)
93− return err;
197+ err = can_validate_databittiming(data, extack,
198+ IFLA_CAN_DATA_BITTIMING, flags);
199+ if (err)
200+ return err;
94201
95− if (tb_tdc[IFLA_CAN_TDC_TDCV]) {
96− if (tdc_flags & CAN_CTRLMODE_TDC_AUTO)
97− return -EOPNOTSUPP;
98− } else {
99− if (tdc_flags & CAN_CTRLMODE_TDC_MANUAL)
100− return -EOPNOTSUPP;
101− }
202+ return 0;
203+}
102204
103− if (!tb_tdc[IFLA_CAN_TDC_TDCO])
104− return -EOPNOTSUPP;
105− }
106− }
205+static int can_ctrlmode_changelink(struct net_device *dev,
206+ struct nlattr *data[],
207+ struct netlink_ext_ack *extack)
208+{
209+ struct can_priv *priv = netdev_priv(dev);
210+ struct can_ctrlmode *cm;
211+ u32 ctrlstatic, maskedflags, notsupp, ctrlstatic_missing;
107212
108− if (data[IFLA_CAN_BITTIMING]) {
109− struct can_bittiming bt;
213+ if (!data[IFLA_CAN_CTRLMODE])
214+ return 0;
110215
111− memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
112− err = can_validate_bittiming(&bt, extack);
113− if (err)
114− return err;
115− }
216+ /* Do not allow changing controller mode while running */
217+ if (dev->flags & IFF_UP)
218+ return -EBUSY;
116219
117− if (is_can_fd) {
118− if (!data[IFLA_CAN_BITTIMING] || !data[IFLA_CAN_DATA_BITTIMING])
119− return -EOPNOTSUPP;
220+ cm = nla_data(data[IFLA_CAN_CTRLMODE]);
221+ ctrlstatic = can_get_static_ctrlmode(priv);
222+ maskedflags = cm->flags & cm->mask;
223+ notsupp = maskedflags & ~(priv->ctrlmode_supported | ctrlstatic);
224+ ctrlstatic_missing = (maskedflags & ctrlstatic) ^ ctrlstatic;
225+
226+ if (notsupp) {
227+ NL_SET_ERR_MSG_FMT(extack,
228+ "requested control mode %s not supported",
229+ can_get_ctrlmode_str(notsupp));
230+ return -EOPNOTSUPP;
120231 }
121232
122− if (data[IFLA_CAN_DATA_BITTIMING] || data[IFLA_CAN_TDC]) {
123− if (!is_can_fd)
124− return -EOPNOTSUPP;
233+ /* do not check for static fd-non-iso if 'fd' is disabled */
234+ if (!(maskedflags & CAN_CTRLMODE_FD))
235+ ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO;
236+
237+ if (ctrlstatic_missing) {
238+ NL_SET_ERR_MSG_FMT(extack,
239+ "missing required %s static control mode",
240+ can_get_ctrlmode_str(ctrlstatic_missing));
241+ return -EOPNOTSUPP;
125242 }
126243
127− if (data[IFLA_CAN_DATA_BITTIMING]) {
128− struct can_bittiming bt;
244+ /* If a top dependency flag is provided, reset all its dependencies */
245+ if (cm->mask & CAN_CTRLMODE_FD)
246+ priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
129247
130− memcpy(&bt, nla_data(data[IFLA_CAN_DATA_BITTIMING]), sizeof(bt));
131− err = can_validate_bittiming(&bt, extack);
132− if (err)
133− return err;
248+ /* clear bits to be modified and copy the flag values */
249+ priv->ctrlmode &= ~cm->mask;
250+ priv->ctrlmode |= maskedflags;
251+
252+ /* Wipe potential leftovers from previous CAN FD config */
253+ if (!(priv->ctrlmode & CAN_CTRLMODE_FD)) {
254+ memset(&priv->fd.data_bittiming, 0,
255+ sizeof(priv->fd.data_bittiming));
256+ priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
257+ memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc));
134258 }
135259
260+ can_set_default_mtu(dev);
261+
136262 return 0;
137263 }
138264
139−static int can_tdc_changelink(struct can_priv *priv, const struct nlattr *nla,
265+static int can_tdc_changelink(struct data_bittiming_params *dbt_params,
266+ const struct nlattr *nla,
140267 struct netlink_ext_ack *extack)
141268 {
142269 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];
143270 struct can_tdc tdc = { 0 };
144− const struct can_tdc_const *tdc_const = priv->fd.tdc_const;
271+ const struct can_tdc_const *tdc_const = dbt_params->tdc_const;
145272 int err;
146273
147− if (!tdc_const || !can_fd_tdc_is_enabled(priv))
274+ if (!tdc_const) {
275+ NL_SET_ERR_MSG(extack, "The device does not support TDC");
148276 return -EOPNOTSUPP;
277+ }
149278
150279 err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, nla,
151280 can_tdc_policy, extack);
@@ -179,69 +308,107 @@ static int can_tdc_changelink(struct can_priv *priv, const struct nlattr *nla, · 27 unmodified lines
179308 tdc.tdcf = tdcf;
180309 }
181310
182− priv->fd.tdc = tdc;
311+ dbt_params->tdc = tdc;
183312
184313 return 0;
185314 }
186315
187−static int can_changelink(struct net_device *dev, struct nlattr *tb[],
188− struct nlattr *data[],
189− struct netlink_ext_ack *extack)
316+static int can_dbt_changelink(struct net_device *dev, struct nlattr *data[],
317+ bool fd, struct netlink_ext_ack *extack)
190318 {
319+ struct nlattr *data_bittiming, *data_tdc;
191320 struct can_priv *priv = netdev_priv(dev);
192− bool fd_tdc_flag_provided = false;
321+ struct data_bittiming_params *dbt_params;
322+ struct can_bittiming dbt;
323+ bool need_tdc_calc = false;
324+ u32 tdc_mask;
193325 int err;
194326
195− /* We need synchronization with dev->stop() */
196− ASSERT_RTNL();
327+ if (fd) {
328+ data_bittiming = data[IFLA_CAN_DATA_BITTIMING];
329+ data_tdc = data[IFLA_CAN_TDC];
330+ dbt_params = &priv->fd;
331+ tdc_mask = CAN_CTRLMODE_FD_TDC_MASK;
332+ } else {
333+ return -EOPNOTSUPP; /* Place holder for CAN XL */
334+ }
197335
198− if (data[IFLA_CAN_CTRLMODE]) {
199− struct can_ctrlmode *cm;
200− u32 ctrlstatic;
201− u32 maskedflags;
336+ if (!data_bittiming)
337+ return 0;
202338
203− /* Do not allow changing controller mode while running */
204− if (dev->flags & IFF_UP)
205− return -EBUSY;
206− cm = nla_data(data[IFLA_CAN_CTRLMODE]);
207− ctrlstatic = can_get_static_ctrlmode(priv);
208− maskedflags = cm->flags & cm->mask;
339+ /* Do not allow changing bittiming while running */
340+ if (dev->flags & IFF_UP)
341+ return -EBUSY;
209342
210− /* check whether provided bits are allowed to be passed */
211− if (maskedflags & ~(priv->ctrlmode_supported | ctrlstatic))
212− return -EOPNOTSUPP;
343+ /* Calculate bittiming parameters based on data_bittiming_const
344+ * if set, otherwise pass bitrate directly via do_set_bitrate().
345+ * Bail out if neither is given.
346+ */
347+ if (!dbt_params->data_bittiming_const && !dbt_params->do_set_data_bittiming &&
348+ !dbt_params->data_bitrate_const)
349+ return -EOPNOTSUPP;
213350
214− /* do not check for static fd-non-iso if 'fd' is disabled */
215− if (!(maskedflags & CAN_CTRLMODE_FD))
216− ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO;
351+ memcpy(&dbt, nla_data(data_bittiming), sizeof(dbt));
352+ err = can_get_bittiming(dev, &dbt, dbt_params->data_bittiming_const,
353+ dbt_params->data_bitrate_const,
354+ dbt_params->data_bitrate_const_cnt, extack);
355+ if (err)
356+ return err;
217357
218− /* make sure static options are provided by configuration */
219− if ((maskedflags & ctrlstatic) != ctrlstatic)
220− return -EOPNOTSUPP;
358+ if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
359+ NL_SET_ERR_MSG_FMT(extack,
360+ "CAN data bitrate %u bps surpasses transceiver capabilities of %u bps",
361+ dbt.bitrate, priv->bitrate_max);
362+ return -EINVAL;
363+ }
221364
222− /* clear bits to be modified and copy the flag values */
223− priv->ctrlmode &= ~cm->mask;
224− priv->ctrlmode |= maskedflags;
365+ memset(&dbt_params->tdc, 0, sizeof(dbt_params->tdc));
366+ if (data[IFLA_CAN_CTRLMODE]) {
367+ struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
225368
226− /* CAN_CTRLMODE_FD can only be set when driver supports FD */
227− if (priv->ctrlmode & CAN_CTRLMODE_FD) {
228− dev->mtu = CANFD_MTU;
229− } else {
230− dev->mtu = CAN_MTU;
231− memset(&priv->fd.data_bittiming, 0,
232− sizeof(priv->fd.data_bittiming));
233− priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
234− memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc));
369+ need_tdc_calc = !(cm->mask & tdc_mask);
370+ }
371+ if (data_tdc) {
372+ /* TDC parameters are provided: use them */
373+ err = can_tdc_changelink(dbt_params, data_tdc, extack);
374+ if (err) {
375+ priv->ctrlmode &= ~tdc_mask;
376+ return err;
235377 }
236−
237− fd_tdc_flag_provided = cm->mask & CAN_CTRLMODE_FD_TDC_MASK;
238− /* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually
239− * exclusive: make sure to turn the other one off
378+ } else if (need_tdc_calc) {
379+ /* Neither of TDC parameters nor TDC flags are provided:
380+ * do calculation
240381 */
241− if (fd_tdc_flag_provided)
242− priv->ctrlmode &= cm->flags | ~CAN_CTRLMODE_FD_TDC_MASK;
382+ can_calc_tdco(&dbt_params->tdc, dbt_params->tdc_const, &dbt,
383+ tdc_mask, &priv->ctrlmode, priv->ctrlmode_supported);
384+ } /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly
385+ * turned off. TDC is disabled: do nothing
386+ */
387+
388+ memcpy(&dbt_params->data_bittiming, &dbt, sizeof(dbt));
389+
390+ if (dbt_params->do_set_data_bittiming) {
391+ /* Finally, set the bit-timing registers */
392+ err = dbt_params->do_set_data_bittiming(dev);
393+ if (err)
394+ return err;
243395 }
244396
397+ return 0;
398+}
399+
400+static int can_changelink(struct net_device *dev, struct nlattr *tb[],
401+ struct nlattr *data[],
402+ struct netlink_ext_ack *extack)
403+{
404+ struct can_priv *priv = netdev_priv(dev);
405+ int err;
406+
407+ /* We need synchronization with dev->stop() */
408+ ASSERT_RTNL();
409+
410+ can_ctrlmode_changelink(dev, data, extack);
411+
245412 if (data[IFLA_CAN_BITTIMING]) {
246413 struct can_bittiming bt;
247414
@@ -312,75 +479,21 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[], · 64 unmodified lines
312479 return err;
313480 }
314481
315− if (data[IFLA_CAN_DATA_BITTIMING]) {
316− struct can_bittiming dbt;
317−
318− /* Do not allow changing bittiming while running */
319− if (dev->flags & IFF_UP)
320− return -EBUSY;
321−
322− /* Calculate bittiming parameters based on
323− * data_bittiming_const if set, otherwise pass bitrate
324− * directly via do_set_bitrate(). Bail out if neither
325− * is given.
326− */
327− if (!priv->fd.data_bittiming_const && !priv->fd.do_set_data_bittiming &&
328− !priv->fd.data_bitrate_const)
329− return -EOPNOTSUPP;
330−
331− memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]),
332− sizeof(dbt));
333− err = can_get_bittiming(dev, &dbt,
334− priv->fd.data_bittiming_const,
335− priv->fd.data_bitrate_const,
336− priv->fd.data_bitrate_const_cnt,
337− extack);
338− if (err)
339− return err;
340−
341− if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
342− NL_SET_ERR_MSG_FMT(extack,
343− "CANFD data bitrate %u bps surpasses transceiver capabilities of %u bps",
344− dbt.bitrate, priv->bitrate_max);
345− return -EINVAL;
346− }
347−
348− memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc));
349− if (data[IFLA_CAN_TDC]) {
350− /* TDC parameters are provided: use them */
351− err = can_tdc_changelink(priv, data[IFLA_CAN_TDC],
352− extack);
353− if (err) {
354− priv->ctrlmode &= ~CAN_CTRLMODE_FD_TDC_MASK;
355− return err;
356− }
357− } else if (!fd_tdc_flag_provided) {
358− /* Neither of TDC parameters nor TDC flags are
359− * provided: do calculation
360− */
361− can_calc_tdco(&priv->fd.tdc, priv->fd.tdc_const, &dbt,
362− &priv->ctrlmode, priv->ctrlmode_supported);
363− } /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly
364− * turned off. TDC is disabled: do nothing
365− */
366−
367− memcpy(&priv->fd.data_bittiming, &dbt, sizeof(dbt));
368−
369− if (priv->fd.do_set_data_bittiming) {
370− /* Finally, set the bit-timing registers */
371− err = priv->fd.do_set_data_bittiming(dev);
372− if (err)
373− return err;
374− }
375− }
482+ /* CAN FD */
483+ err = can_dbt_changelink(dev, data, true, extack);
484+ if (err)
485+ return err;
376486
377487 if (data[IFLA_CAN_TERMINATION]) {
378488 const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]);
379489 const unsigned int num_term = priv->termination_const_cnt;
380490 unsigned int i;
381491
382− if (!priv->do_set_termination)
492+ if (!priv->do_set_termination) {
493+ NL_SET_ERR_MSG(extack,
494+ "Termination is not configurable on this device");
383495 return -EOPNOTSUPP;
496+ }
384497
385498 /* check whether given value is supported by the interface */
386499 for (i = 0; i < num_term; i++) {
@@ -401,38 +514,55 @@ static int can_changelink(struct net_device *dev, struct nlattr *tb[], · 14 unmodified lines
401514 return 0;
402515 }
403516
404−static size_t can_tdc_get_size(const struct net_device *dev)
517+static size_t can_tdc_get_size(struct data_bittiming_params *dbt_params,
518+ u32 tdc_flags)
405519 {
406− struct can_priv *priv = netdev_priv(dev);
520+ bool tdc_manual = tdc_flags & CAN_CTRLMODE_TDC_MANUAL_MASK;
407521 size_t size;
408522
409− if (!priv->fd.tdc_const)
523+ if (!dbt_params->tdc_const)
410524 return 0;
411525
412526 size = nla_total_size(0); /* nest IFLA_CAN_TDC */
413− if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL) {
527+ if (tdc_manual) {
414528 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MIN */
415529 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MAX */
416530 }
417531 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MIN */
418532 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MAX */
419− if (priv->fd.tdc_const->tdcf_max) {
533+ if (dbt_params->tdc_const->tdcf_max) {
420534 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MIN */
421535 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MAX */
422536 }
423537
424− if (can_fd_tdc_is_enabled(priv)) {
425− if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL ||
426− priv->fd.do_get_auto_tdcv)
538+ if (tdc_flags) {
539+ if (tdc_manual || dbt_params->do_get_auto_tdcv)
427540 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV */
428541 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO */
429− if (priv->fd.tdc_const->tdcf_max)
542+ if (dbt_params->tdc_const->tdcf_max)
430543 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF */
431544 }
432545
433546 return size;
434547 }
435548
549+static size_t can_data_bittiming_get_size(struct data_bittiming_params *dbt_params,
550+ u32 tdc_flags)
551+{
552+ size_t size = 0;
553+
554+ if (dbt_params->data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */
555+ size += nla_total_size(sizeof(dbt_params->data_bittiming));
556+ if (dbt_params->data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */
557+ size += nla_total_size(sizeof(*dbt_params->data_bittiming_const));
558+ if (dbt_params->data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */
559+ size += nla_total_size(sizeof(*dbt_params->data_bitrate_const) *
560+ dbt_params->data_bitrate_const_cnt);
561+ size += can_tdc_get_size(dbt_params, tdc_flags);/* IFLA_CAN_TDC */
562+
563+ return size;
564+}
565+
436566 static size_t can_ctrlmode_ext_get_size(void)
437567 {
438568 return nla_total_size(0) + /* nest IFLA_CAN_CTRLMODE_EXT */
@@ -454,10 +584,6 @@ static size_t can_get_size(const struct net_device *dev) · 15 unmodified lines
454584 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */
455585 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */
456586 size += nla_total_size(sizeof(struct can_berr_counter));
457− if (priv->fd.data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */
458− size += nla_total_size(sizeof(struct can_bittiming));
459− if (priv->fd.data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */
460− size += nla_total_size(sizeof(struct can_bittiming_const));
461587 if (priv->termination_const) {
462588 size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */
463589 size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */
@@ -466,31 +592,69 @@ static size_t can_get_size(const struct net_device *dev) · 2 unmodified lines
466592 if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */
467593 size += nla_total_size(sizeof(*priv->bitrate_const) *
468594 priv->bitrate_const_cnt);
469− if (priv->fd.data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */
470− size += nla_total_size(sizeof(*priv->fd.data_bitrate_const) *
471− priv->fd.data_bitrate_const_cnt);
472595 size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */
473− size += can_tdc_get_size(dev); /* IFLA_CAN_TDC */
474596 size += can_ctrlmode_ext_get_size(); /* IFLA_CAN_CTRLMODE_EXT */
475597
598+ size += can_data_bittiming_get_size(&priv->fd,
599+ priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK);
600+
476601 return size;
477602 }
478603
479−static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev)
604+static int can_bittiming_fill_info(struct sk_buff *skb, int ifla_can_bittiming,
605+ struct can_bittiming *bittiming)
606+{
607+ return bittiming->bitrate != CAN_BITRATE_UNSET &&
608+ bittiming->bitrate != CAN_BITRATE_UNKNOWN &&
609+ nla_put(skb, ifla_can_bittiming, sizeof(*bittiming), bittiming);
610+}
611+
612+static int can_bittiming_const_fill_info(struct sk_buff *skb,
613+ int ifla_can_bittiming_const,
614+ const struct can_bittiming_const *bittiming_const)
615+{
616+ return bittiming_const &&
617+ nla_put(skb, ifla_can_bittiming_const,
618+ sizeof(*bittiming_const), bittiming_const);
619+}
620+
621+static int can_bitrate_const_fill_info(struct sk_buff *skb,
622+ int ifla_can_bitrate_const,
623+ const u32 *bitrate_const, unsigned int cnt)
624+{
625+ return bitrate_const &&
626+ nla_put(skb, ifla_can_bitrate_const,
627+ sizeof(*bitrate_const) * cnt, bitrate_const);
628+}
629+
630+static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev,
631+ int ifla_can_tdc)
480632 {
481− struct nlattr *nest;
482633 struct can_priv *priv = netdev_priv(dev);
483− struct can_tdc *tdc = &priv->fd.tdc;
484− const struct can_tdc_const *tdc_const = priv->fd.tdc_const;
634+ struct data_bittiming_params *dbt_params;
635+ const struct can_tdc_const *tdc_const;
636+ struct can_tdc *tdc;
637+ struct nlattr *nest;
638+ bool tdc_is_enabled, tdc_manual;
639+
640+ if (ifla_can_tdc == IFLA_CAN_TDC) {
641+ dbt_params = &priv->fd;
642+ tdc_is_enabled = can_fd_tdc_is_enabled(priv);
643+ tdc_manual = priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL;
644+ } else {
645+ return -EOPNOTSUPP; /* Place holder for CAN XL */
646+ }
647+ tdc_const = dbt_params->tdc_const;
648+ tdc = &dbt_params->tdc;
485649
486650 if (!tdc_const)
487651 return 0;
488652
489− nest = nla_nest_start(skb, IFLA_CAN_TDC);
653+ nest = nla_nest_start(skb, ifla_can_tdc);
490654 if (!nest)
491655 return -EMSGSIZE;
492656
493− if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL &&
657+ if (tdc_manual &&
494658 (nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MIN, tdc_const->tdcv_min) ||
495659 nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MAX, tdc_const->tdcv_max)))
496660 goto err_cancel;
@@ -502,15 +666,15 @@ static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev) · 5 unmodified lines
502666 nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max)))
503667 goto err_cancel;
504668
505− if (can_fd_tdc_is_enabled(priv)) {
669+ if (tdc_is_enabled) {
506670 u32 tdcv;
507671 int err = -EINVAL;
508672
509− if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL) {
673+ if (tdc_manual) {
510674 tdcv = tdc->tdcv;
511675 err = 0;
512− } else if (priv->fd.do_get_auto_tdcv) {
513− err = priv->fd.do_get_auto_tdcv(dev, &tdcv);
676+ } else if (dbt_params->do_get_auto_tdcv) {
677+ err = dbt_params->do_get_auto_tdcv(dev, &tdcv);
514678 }
515679 if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv))
516680 goto err_cancel;
@@ -558,14 +722,11 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) · 41 unmodified lines
558722 if (priv->do_get_state)
559723 priv->do_get_state(dev, &state);
560724
561− if ((priv->bittiming.bitrate != CAN_BITRATE_UNSET &&
562− priv->bittiming.bitrate != CAN_BITRATE_UNKNOWN &&
563− nla_put(skb, IFLA_CAN_BITTIMING,
564− sizeof(priv->bittiming), &priv->bittiming)) ||
725+ if (can_bittiming_fill_info(skb, IFLA_CAN_BITTIMING,
726+ &priv->bittiming) ||
565727
566− (priv->bittiming_const &&
567− nla_put(skb, IFLA_CAN_BITTIMING_CONST,
568− sizeof(*priv->bittiming_const), priv->bittiming_const)) ||
728+ can_bittiming_const_fill_info(skb, IFLA_CAN_BITTIMING_CONST,
729+ priv->bittiming_const) ||
569730
570731 nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) ||
571732 nla_put_u32(skb, IFLA_CAN_STATE, state) ||
@@ -576,14 +737,11 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) · 4 unmodified lines
576737 !priv->do_get_berr_counter(dev, &bec) &&
577738 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) ||
578739
579− (priv->fd.data_bittiming.bitrate &&
580− nla_put(skb, IFLA_CAN_DATA_BITTIMING,
581− sizeof(priv->fd.data_bittiming), &priv->fd.data_bittiming)) ||
740+ can_bittiming_fill_info(skb, IFLA_CAN_DATA_BITTIMING,
741+ &priv->fd.data_bittiming) ||
582742
583− (priv->fd.data_bittiming_const &&
584− nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST,
585− sizeof(*priv->fd.data_bittiming_const),
586− priv->fd.data_bittiming_const)) ||
743+ can_bittiming_const_fill_info(skb, IFLA_CAN_DATA_BITTIMING_CONST,
744+ priv->fd.data_bittiming_const) ||
587745
588746 (priv->termination_const &&
589747 (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) ||
@@ -592,23 +750,19 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev) · 2 unmodified lines
592750 priv->termination_const_cnt,
593751 priv->termination_const))) ||
594752
595− (priv->bitrate_const &&
596− nla_put(skb, IFLA_CAN_BITRATE_CONST,
597− sizeof(*priv->bitrate_const) *
598− priv->bitrate_const_cnt,
599− priv->bitrate_const)) ||
753+ can_bitrate_const_fill_info(skb, IFLA_CAN_BITRATE_CONST,
754+ priv->bitrate_const,
755+ priv->bitrate_const_cnt) ||
600756
601− (priv->fd.data_bitrate_const &&
602− nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST,
603− sizeof(*priv->fd.data_bitrate_const) *
604− priv->fd.data_bitrate_const_cnt,
605− priv->fd.data_bitrate_const)) ||
757+ can_bitrate_const_fill_info(skb, IFLA_CAN_DATA_BITRATE_CONST,
758+ priv->fd.data_bitrate_const,
759+ priv->fd.data_bitrate_const_cnt) ||
606760
607761 (nla_put(skb, IFLA_CAN_BITRATE_MAX,
608762 sizeof(priv->bitrate_max),
609763 &priv->bitrate_max)) ||
610764
611− can_tdc_fill_info(skb, dev) ||
765+ can_tdc_fill_info(skb, dev, IFLA_CAN_TDC) ||
612766
613767 can_ctrlmode_ext_fill_info(skb, priv)
614768 )
drivers/net/can/m_can/m_can.c+2−4
@@ -2213,11 +2213,9 @@ static int m_can_set_coalesce(struct net_device *dev, · 2212 unmodified lines
22132213 cdev->tx_coalesce_usecs_irq = ec->tx_coalesce_usecs_irq;
22142214
22152215 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);
22182217 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);
22212219
22222220 return 0;
22232221 }
drivers/net/can/peak_canfd/peak_canfd.c+2−2
@@ -1,8 +1,8 @@
11 // SPDX-License-Identifier: GPL-2.0-only
22 /* Copyright (C) 2007, 2011 Wolfgang Grandegger <wg@grandegger.com>
3− * Copyright (C) 2012 Stephane Grosjean <s.grosjean@peak-system.com>
43 *
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>
66 */
77
88 #include <linux/can.h>
drivers/net/can/peak_canfd/peak_canfd_user.h+2−2
@@ -1,8 +1,8 @@
11 /* SPDX-License-Identifier: GPL-2.0-only */
22 /* CAN driver for PEAK System micro-CAN based adapters
33 *
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>
66 */
77 #ifndef PEAK_CANFD_USER_H
88 #define PEAK_CANFD_USER_H
drivers/net/can/peak_canfd/peak_pciefd_main.c+3−3
@@ -1,10 +1,10 @@
11 // SPDX-License-Identifier: GPL-2.0-only
22 /* Copyright (C) 2007, 2011 Wolfgang Grandegger <wg@grandegger.com>
3− * Copyright (C) 2012 Stephane Grosjean <s.grosjean@peak-system.com>
43 *
54 * Derived from the PCAN project file driver/src/pcan_pci.c:
65 *
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>
88 */
99
1010 #include <linux/kernel.h>
@@ -19,7 +19,7 @@ · 8 unmodified lines
1919
2020 #include "peak_canfd_user.h"
2121
22−MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
22+MODULE_AUTHOR("Stéphane Grosjean <stephane.grosjean@hms-networks.com>");
2323 MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCIe/M.2 FD family cards");
2424 MODULE_LICENSE("GPL v2");
2525
drivers/net/can/rcar/rcar_can.c+149−143
@@ -5,6 +5,8 @@ · 4 unmodified lines
55 * Copyright (C) 2013 Renesas Solutions Corp.
66 */
77
8+#include <linux/bitfield.h>
9+#include <linux/bits.h>
810 #include <linux/module.h>
911 #include <linux/kernel.h>
1012 #include <linux/types.h>
@@ -16,6 +18,7 @@ · 5 unmodified lines
1618 #include <linux/can/dev.h>
1719 #include <linux/clk.h>
1820 #include <linux/of.h>
21+#include <linux/pm_runtime.h>
1922
2023 #define RCAR_CAN_DRV_NAME "rcar_can"
2124
@@ -92,7 +95,6 @@ struct rcar_can_priv { · 70 unmodified lines
9295 struct net_device *ndev;
9396 struct napi_struct napi;
9497 struct rcar_can_regs __iomem *regs;
95− struct clk *clk;
9698 struct clk *can_clk;
9799 u32 tx_head;
98100 u32 tx_tail;
@@ -113,100 +115,102 @@ static const struct can_bittiming_const rcar_can_bittiming_const = { · 14 unmodified lines
113115 };
114116
115117 /* Control Register bits */
116−#define RCAR_CAN_CTLR_BOM (3 << 11) /* Bus-Off Recovery Mode Bits */
117−#define RCAR_CAN_CTLR_BOM_ENT (1 << 11) /* Entry to halt mode */
118− /* at bus-off entry */
119−#define RCAR_CAN_CTLR_SLPM (1 << 10)
120−#define RCAR_CAN_CTLR_CANM (3 << 8) /* Operating Mode Select Bit */
121−#define RCAR_CAN_CTLR_CANM_HALT (1 << 9)
122−#define RCAR_CAN_CTLR_CANM_RESET (1 << 8)
123−#define RCAR_CAN_CTLR_CANM_FORCE_RESET (3 << 8)
124−#define RCAR_CAN_CTLR_MLM (1 << 3) /* Message Lost Mode Select */
125−#define RCAR_CAN_CTLR_IDFM (3 << 1) /* ID Format Mode Select Bits */
126−#define RCAR_CAN_CTLR_IDFM_MIXED (1 << 2) /* Mixed ID mode */
127−#define RCAR_CAN_CTLR_MBM (1 << 0) /* Mailbox Mode select */
118+#define RCAR_CAN_CTLR_BOM GENMASK(12, 11) /* Bus-Off Recovery Mode Bits */
119+#define RCAR_CAN_CTLR_BOM_ENT 1 /* Entry to halt mode */
120+ /* at bus-off entry */
121+#define RCAR_CAN_CTLR_SLPM BIT(10) /* Sleep Mode */
122+#define RCAR_CAN_CTLR_CANM GENMASK(9, 8) /* Operating Mode Select Bit */
123+#define RCAR_CAN_CTLR_CANM_OPER 0 /* Operation Mode */
124+#define RCAR_CAN_CTLR_CANM_RESET 1 /* Reset Mode */
125+#define RCAR_CAN_CTLR_CANM_HALT 2 /* Halt Mode */
126+#define RCAR_CAN_CTLR_CANM_FORCE_RESET 3 /* Reset Mode (forcible) */
127+#define RCAR_CAN_CTLR_MLM BIT(3) /* Message Lost Mode Select */
128+#define RCAR_CAN_CTLR_IDFM GENMASK(2, 1) /* ID Format Mode Select Bits */
129+#define RCAR_CAN_CTLR_IDFM_STD 0 /* Standard ID mode */
130+#define RCAR_CAN_CTLR_IDFM_EXT 1 /* Extended ID mode */
131+#define RCAR_CAN_CTLR_IDFM_MIXED 2 /* Mixed ID mode */
132+#define RCAR_CAN_CTLR_MBM BIT(0) /* Mailbox Mode select */
128133
129134 /* Status Register bits */
130−#define RCAR_CAN_STR_RSTST (1 << 8) /* Reset Status Bit */
135+#define RCAR_CAN_STR_RSTST BIT(8) /* Reset Status Bit */
131136
132137 /* FIFO Received ID Compare Registers 0 and 1 bits */
133−#define RCAR_CAN_FIDCR_IDE (1 << 31) /* ID Extension Bit */
134−#define RCAR_CAN_FIDCR_RTR (1 << 30) /* Remote Transmission Request Bit */
138+#define RCAR_CAN_FIDCR_IDE BIT(31) /* ID Extension Bit */
139+#define RCAR_CAN_FIDCR_RTR BIT(30) /* Remote Transmission Request Bit */
135140
136141 /* Receive FIFO Control Register bits */
137−#define RCAR_CAN_RFCR_RFEST (1 << 7) /* Receive FIFO Empty Status Flag */
138−#define RCAR_CAN_RFCR_RFE (1 << 0) /* Receive FIFO Enable */
142+#define RCAR_CAN_RFCR_RFEST BIT(7) /* Receive FIFO Empty Status Flag */
143+#define RCAR_CAN_RFCR_RFE BIT(0) /* Receive FIFO Enable */
139144
140145 /* Transmit FIFO Control Register bits */
141−#define RCAR_CAN_TFCR_TFUST (7 << 1) /* Transmit FIFO Unsent Message */
142− /* Number Status Bits */
143−#define RCAR_CAN_TFCR_TFUST_SHIFT 1 /* Offset of Transmit FIFO Unsent */
144− /* Message Number Status Bits */
145−#define RCAR_CAN_TFCR_TFE (1 << 0) /* Transmit FIFO Enable */
146−
147−#define RCAR_CAN_N_RX_MKREGS1 2 /* Number of mask registers */
148− /* for Rx mailboxes 0-31 */
146+#define RCAR_CAN_TFCR_TFUST GENMASK(3, 1) /* Transmit FIFO Unsent Message */
147+ /* Number Status Bits */
148+#define RCAR_CAN_TFCR_TFE BIT(0) /* Transmit FIFO Enable */
149+
150+#define RCAR_CAN_N_RX_MKREGS1 2 /* Number of mask registers */
151+ /* for Rx mailboxes 0-31 */
149152 #define RCAR_CAN_N_RX_MKREGS2 8
150153
151154 /* Bit Configuration Register settings */
152−#define RCAR_CAN_BCR_TSEG1(x) (((x) & 0x0f) << 20)
153−#define RCAR_CAN_BCR_BPR(x) (((x) & 0x3ff) << 8)
154−#define RCAR_CAN_BCR_SJW(x) (((x) & 0x3) << 4)
155−#define RCAR_CAN_BCR_TSEG2(x) ((x) & 0x07)
155+#define RCAR_CAN_BCR_TSEG1 GENMASK(23, 20)
156+#define RCAR_CAN_BCR_BRP GENMASK(17, 8)
157+#define RCAR_CAN_BCR_SJW GENMASK(5, 4)
158+#define RCAR_CAN_BCR_TSEG2 GENMASK(2, 0)
156159
157160 /* Mailbox and Mask Registers bits */
158−#define RCAR_CAN_IDE (1 << 31)
159−#define RCAR_CAN_RTR (1 << 30)
160−#define RCAR_CAN_SID_SHIFT 18
161+#define RCAR_CAN_IDE BIT(31) /* ID Extension */
162+#define RCAR_CAN_RTR BIT(30) /* Remote Transmission Request */
163+#define RCAR_CAN_SID GENMASK(28, 18) /* Standard ID */
164+#define RCAR_CAN_EID GENMASK(28, 0) /* Extended ID */
161165
162166 /* Mailbox Interrupt Enable Register 1 bits */
163−#define RCAR_CAN_MIER1_RXFIE (1 << 28) /* Receive FIFO Interrupt Enable */
164−#define RCAR_CAN_MIER1_TXFIE (1 << 24) /* Transmit FIFO Interrupt Enable */
167+#define RCAR_CAN_MIER1_RXFIE BIT(28) /* Receive FIFO Interrupt Enable */
168+#define RCAR_CAN_MIER1_TXFIE BIT(24) /* Transmit FIFO Interrupt Enable */
165169
166170 /* Interrupt Enable Register bits */
167−#define RCAR_CAN_IER_ERSIE (1 << 5) /* Error (ERS) Interrupt Enable Bit */
168−#define RCAR_CAN_IER_RXFIE (1 << 4) /* Reception FIFO Interrupt */
169− /* Enable Bit */
170−#define RCAR_CAN_IER_TXFIE (1 << 3) /* Transmission FIFO Interrupt */
171− /* Enable Bit */
171+#define RCAR_CAN_IER_ERSIE BIT(5) /* Error (ERS) Interrupt Enable Bit */
172+#define RCAR_CAN_IER_RXFIE BIT(4) /* Reception FIFO Interrupt */
173+ /* Enable Bit */
174+#define RCAR_CAN_IER_TXFIE BIT(3) /* Transmission FIFO Interrupt */
175+ /* Enable Bit */
172176 /* Interrupt Status Register bits */
173−#define RCAR_CAN_ISR_ERSF (1 << 5) /* Error (ERS) Interrupt Status Bit */
174−#define RCAR_CAN_ISR_RXFF (1 << 4) /* Reception FIFO Interrupt */
175− /* Status Bit */
176−#define RCAR_CAN_ISR_TXFF (1 << 3) /* Transmission FIFO Interrupt */
177− /* Status Bit */
177+#define RCAR_CAN_ISR_ERSF BIT(5) /* Error (ERS) Interrupt Status Bit */
178+#define RCAR_CAN_ISR_RXFF BIT(4) /* Reception FIFO Interrupt */
179+ /* Status Bit */
180+#define RCAR_CAN_ISR_TXFF BIT(3) /* Transmission FIFO Interrupt */
181+ /* Status Bit */
178182
179183 /* Error Interrupt Enable Register bits */
180−#define RCAR_CAN_EIER_BLIE (1 << 7) /* Bus Lock Interrupt Enable */
181−#define RCAR_CAN_EIER_OLIE (1 << 6) /* Overload Frame Transmit */
182− /* Interrupt Enable */
183−#define RCAR_CAN_EIER_ORIE (1 << 5) /* Receive Overrun Interrupt Enable */
184−#define RCAR_CAN_EIER_BORIE (1 << 4) /* Bus-Off Recovery Interrupt Enable */
185−#define RCAR_CAN_EIER_BOEIE (1 << 3) /* Bus-Off Entry Interrupt Enable */
186−#define RCAR_CAN_EIER_EPIE (1 << 2) /* Error Passive Interrupt Enable */
187−#define RCAR_CAN_EIER_EWIE (1 << 1) /* Error Warning Interrupt Enable */
188−#define RCAR_CAN_EIER_BEIE (1 << 0) /* Bus Error Interrupt Enable */
184+#define RCAR_CAN_EIER_BLIE BIT(7) /* Bus Lock Interrupt Enable */
185+#define RCAR_CAN_EIER_OLIE BIT(6) /* Overload Frame Transmit */
186+ /* Interrupt Enable */
187+#define RCAR_CAN_EIER_ORIE BIT(5) /* Receive Overrun Interrupt Enable */
188+#define RCAR_CAN_EIER_BORIE BIT(4) /* Bus-Off Recovery Interrupt Enable */
189+#define RCAR_CAN_EIER_BOEIE BIT(3) /* Bus-Off Entry Interrupt Enable */
190+#define RCAR_CAN_EIER_EPIE BIT(2) /* Error Passive Interrupt Enable */
191+#define RCAR_CAN_EIER_EWIE BIT(1) /* Error Warning Interrupt Enable */
192+#define RCAR_CAN_EIER_BEIE BIT(0) /* Bus Error Interrupt Enable */
189193
190194 /* Error Interrupt Factor Judge Register bits */
191−#define RCAR_CAN_EIFR_BLIF (1 << 7) /* Bus Lock Detect Flag */
192−#define RCAR_CAN_EIFR_OLIF (1 << 6) /* Overload Frame Transmission */
193− /* Detect Flag */
194−#define RCAR_CAN_EIFR_ORIF (1 << 5) /* Receive Overrun Detect Flag */
195−#define RCAR_CAN_EIFR_BORIF (1 << 4) /* Bus-Off Recovery Detect Flag */
196−#define RCAR_CAN_EIFR_BOEIF (1 << 3) /* Bus-Off Entry Detect Flag */
197−#define RCAR_CAN_EIFR_EPIF (1 << 2) /* Error Passive Detect Flag */
198−#define RCAR_CAN_EIFR_EWIF (1 << 1) /* Error Warning Detect Flag */
199−#define RCAR_CAN_EIFR_BEIF (1 << 0) /* Bus Error Detect Flag */
195+#define RCAR_CAN_EIFR_BLIF BIT(7) /* Bus Lock Detect Flag */
196+#define RCAR_CAN_EIFR_OLIF BIT(6) /* Overload Frame Transmission */
197+ /* Detect Flag */
198+#define RCAR_CAN_EIFR_ORIF BIT(5) /* Receive Overrun Detect Flag */
199+#define RCAR_CAN_EIFR_BORIF BIT(4) /* Bus-Off Recovery Detect Flag */
200+#define RCAR_CAN_EIFR_BOEIF BIT(3) /* Bus-Off Entry Detect Flag */
201+#define RCAR_CAN_EIFR_EPIF BIT(2) /* Error Passive Detect Flag */
202+#define RCAR_CAN_EIFR_EWIF BIT(1) /* Error Warning Detect Flag */
203+#define RCAR_CAN_EIFR_BEIF BIT(0) /* Bus Error Detect Flag */
200204
201205 /* Error Code Store Register bits */
202−#define RCAR_CAN_ECSR_EDPM (1 << 7) /* Error Display Mode Select Bit */
203−#define RCAR_CAN_ECSR_ADEF (1 << 6) /* ACK Delimiter Error Flag */
204−#define RCAR_CAN_ECSR_BE0F (1 << 5) /* Bit Error (dominant) Flag */
205−#define RCAR_CAN_ECSR_BE1F (1 << 4) /* Bit Error (recessive) Flag */
206−#define RCAR_CAN_ECSR_CEF (1 << 3) /* CRC Error Flag */
207−#define RCAR_CAN_ECSR_AEF (1 << 2) /* ACK Error Flag */
208−#define RCAR_CAN_ECSR_FEF (1 << 1) /* Form Error Flag */
209−#define RCAR_CAN_ECSR_SEF (1 << 0) /* Stuff Error Flag */
206+#define RCAR_CAN_ECSR_EDPM BIT(7) /* Error Display Mode Select Bit */
207+#define RCAR_CAN_ECSR_ADEF BIT(6) /* ACK Delimiter Error Flag */
208+#define RCAR_CAN_ECSR_BE0F BIT(5) /* Bit Error (dominant) Flag */
209+#define RCAR_CAN_ECSR_BE1F BIT(4) /* Bit Error (recessive) Flag */
210+#define RCAR_CAN_ECSR_CEF BIT(3) /* CRC Error Flag */
211+#define RCAR_CAN_ECSR_AEF BIT(2) /* ACK Error Flag */
212+#define RCAR_CAN_ECSR_FEF BIT(1) /* Form Error Flag */
213+#define RCAR_CAN_ECSR_SEF BIT(0) /* Stuff Error Flag */
210214
211215 #define RCAR_CAN_NAPI_WEIGHT 4
212216 #define MAX_STR_READS 0x100
@@ -248,35 +252,35 @@ static void rcar_can_error(struct net_device *ndev) · 35 unmodified lines
248252 if (ecsr & RCAR_CAN_ECSR_ADEF) {
249253 netdev_dbg(priv->ndev, "ACK Delimiter Error\n");
250254 tx_errors++;
251− writeb(~RCAR_CAN_ECSR_ADEF, &priv->regs->ecsr);
255+ writeb((u8)~RCAR_CAN_ECSR_ADEF, &priv->regs->ecsr);
252256 if (skb)
253257 cf->data[3] = CAN_ERR_PROT_LOC_ACK_DEL;
254258 }
255259 if (ecsr & RCAR_CAN_ECSR_BE0F) {
256260 netdev_dbg(priv->ndev, "Bit Error (dominant)\n");
257261 tx_errors++;
258− writeb(~RCAR_CAN_ECSR_BE0F, &priv->regs->ecsr);
262+ writeb((u8)~RCAR_CAN_ECSR_BE0F, &priv->regs->ecsr);
259263 if (skb)
260264 cf->data[2] |= CAN_ERR_PROT_BIT0;
261265 }
262266 if (ecsr & RCAR_CAN_ECSR_BE1F) {
263267 netdev_dbg(priv->ndev, "Bit Error (recessive)\n");
264268 tx_errors++;
265− writeb(~RCAR_CAN_ECSR_BE1F, &priv->regs->ecsr);
269+ writeb((u8)~RCAR_CAN_ECSR_BE1F, &priv->regs->ecsr);
266270 if (skb)
267271 cf->data[2] |= CAN_ERR_PROT_BIT1;
268272 }
269273 if (ecsr & RCAR_CAN_ECSR_CEF) {
270274 netdev_dbg(priv->ndev, "CRC Error\n");
271275 rx_errors++;
272− writeb(~RCAR_CAN_ECSR_CEF, &priv->regs->ecsr);
276+ writeb((u8)~RCAR_CAN_ECSR_CEF, &priv->regs->ecsr);
273277 if (skb)
274278 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
275279 }
276280 if (ecsr & RCAR_CAN_ECSR_AEF) {
277281 netdev_dbg(priv->ndev, "ACK Error\n");
278282 tx_errors++;
279− writeb(~RCAR_CAN_ECSR_AEF, &priv->regs->ecsr);
283+ writeb((u8)~RCAR_CAN_ECSR_AEF, &priv->regs->ecsr);
280284 if (skb) {
281285 cf->can_id |= CAN_ERR_ACK;
282286 cf->data[3] = CAN_ERR_PROT_LOC_ACK;
@@ -285,14 +289,14 @@ static void rcar_can_error(struct net_device *ndev) · 2 unmodified lines
285289 if (ecsr & RCAR_CAN_ECSR_FEF) {
286290 netdev_dbg(priv->ndev, "Form Error\n");
287291 rx_errors++;
288− writeb(~RCAR_CAN_ECSR_FEF, &priv->regs->ecsr);
292+ writeb((u8)~RCAR_CAN_ECSR_FEF, &priv->regs->ecsr);
289293 if (skb)
290294 cf->data[2] |= CAN_ERR_PROT_FORM;
291295 }
292296 if (ecsr & RCAR_CAN_ECSR_SEF) {
293297 netdev_dbg(priv->ndev, "Stuff Error\n");
294298 rx_errors++;
295− writeb(~RCAR_CAN_ECSR_SEF, &priv->regs->ecsr);
299+ writeb((u8)~RCAR_CAN_ECSR_SEF, &priv->regs->ecsr);
296300 if (skb)
297301 cf->data[2] |= CAN_ERR_PROT_STUFF;
298302 }
@@ -300,14 +304,14 @@ static void rcar_can_error(struct net_device *ndev) · 1 unmodified line
300304 priv->can.can_stats.bus_error++;
301305 ndev->stats.rx_errors += rx_errors;
302306 ndev->stats.tx_errors += tx_errors;
303− writeb(~RCAR_CAN_EIFR_BEIF, &priv->regs->eifr);
307+ writeb((u8)~RCAR_CAN_EIFR_BEIF, &priv->regs->eifr);
304308 }
305309 if (eifr & RCAR_CAN_EIFR_EWIF) {
306310 netdev_dbg(priv->ndev, "Error warning interrupt\n");
307311 priv->can.state = CAN_STATE_ERROR_WARNING;
308312 priv->can.can_stats.error_warning++;
309313 /* Clear interrupt condition */
310− writeb(~RCAR_CAN_EIFR_EWIF, &priv->regs->eifr);
314+ writeb((u8)~RCAR_CAN_EIFR_EWIF, &priv->regs->eifr);
311315 if (skb)
312316 cf->data[1] = txerr > rxerr ? CAN_ERR_CRTL_TX_WARNING :
313317 CAN_ERR_CRTL_RX_WARNING;
@@ -317,7 +321,7 @@ static void rcar_can_error(struct net_device *ndev) · 3 unmodified lines
317321 priv->can.state = CAN_STATE_ERROR_PASSIVE;
318322 priv->can.can_stats.error_passive++;
319323 /* Clear interrupt condition */
320− writeb(~RCAR_CAN_EIFR_EPIF, &priv->regs->eifr);
324+ writeb((u8)~RCAR_CAN_EIFR_EPIF, &priv->regs->eifr);
321325 if (skb)
322326 cf->data[1] = txerr > rxerr ? CAN_ERR_CRTL_TX_PASSIVE :
323327 CAN_ERR_CRTL_RX_PASSIVE;
@@ -329,7 +333,7 @@ static void rcar_can_error(struct net_device *ndev) · 5 unmodified lines
329333 writeb(priv->ier, &priv->regs->ier);
330334 priv->can.state = CAN_STATE_BUS_OFF;
331335 /* Clear interrupt condition */
332− writeb(~RCAR_CAN_EIFR_BOEIF, &priv->regs->eifr);
336+ writeb((u8)~RCAR_CAN_EIFR_BOEIF, &priv->regs->eifr);
333337 priv->can.can_stats.bus_off++;
334338 can_bus_off(ndev);
335339 if (skb)
@@ -343,7 +347,7 @@ static void rcar_can_error(struct net_device *ndev) · 7 unmodified lines
343347 netdev_dbg(priv->ndev, "Receive overrun error interrupt\n");
344348 ndev->stats.rx_over_errors++;
345349 ndev->stats.rx_errors++;
346− writeb(~RCAR_CAN_EIFR_ORIF, &priv->regs->eifr);
350+ writeb((u8)~RCAR_CAN_EIFR_ORIF, &priv->regs->eifr);
347351 if (skb) {
348352 cf->can_id |= CAN_ERR_CRTL;
349353 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
@@ -354,7 +358,7 @@ static void rcar_can_error(struct net_device *ndev) · 4 unmodified lines
354358 "Overload Frame Transmission error interrupt\n");
355359 ndev->stats.rx_over_errors++;
356360 ndev->stats.rx_errors++;
357− writeb(~RCAR_CAN_EIFR_OLIF, &priv->regs->eifr);
361+ writeb((u8)~RCAR_CAN_EIFR_OLIF, &priv->regs->eifr);
358362 if (skb) {
359363 cf->can_id |= CAN_ERR_PROT;
360364 cf->data[2] |= CAN_ERR_PROT_OVERLOAD;
@@ -372,10 +376,9 @@ static void rcar_can_tx_done(struct net_device *ndev) · 11 unmodified lines
372376 u8 isr;
373377
374378 while (1) {
375− u8 unsent = readb(&priv->regs->tfcr);
379+ u8 unsent = FIELD_GET(RCAR_CAN_TFCR_TFUST,
380+ readb(&priv->regs->tfcr));
376381
377− unsent = (unsent & RCAR_CAN_TFCR_TFUST) >>
378− RCAR_CAN_TFCR_TFUST_SHIFT;
379382 if (priv->tx_head - priv->tx_tail <= unsent)
380383 break;
381384 stats->tx_packets++;
@@ -420,15 +423,16 @@ static irqreturn_t rcar_can_interrupt(int irq, void *dev_id) · 38 unmodified lines
420423 return IRQ_HANDLED;
421424 }
422425
423−static void rcar_can_set_bittiming(struct net_device *dev)
426+static void rcar_can_set_bittiming(struct net_device *ndev)
424427 {
425− struct rcar_can_priv *priv = netdev_priv(dev);
428+ struct rcar_can_priv *priv = netdev_priv(ndev);
426429 struct can_bittiming *bt = &priv->can.bittiming;
427430 u32 bcr;
428431
429− bcr = RCAR_CAN_BCR_TSEG1(bt->phase_seg1 + bt->prop_seg - 1) |
430− RCAR_CAN_BCR_BPR(bt->brp - 1) | RCAR_CAN_BCR_SJW(bt->sjw - 1) |
431− RCAR_CAN_BCR_TSEG2(bt->phase_seg2 - 1);
432+ bcr = FIELD_PREP(RCAR_CAN_BCR_TSEG1, bt->phase_seg1 + bt->prop_seg - 1) |
433+ FIELD_PREP(RCAR_CAN_BCR_BRP, bt->brp - 1) |
434+ FIELD_PREP(RCAR_CAN_BCR_SJW, bt->sjw - 1) |
435+ FIELD_PREP(RCAR_CAN_BCR_TSEG2, bt->phase_seg2 - 1);
432436 /* Don't overwrite CLKR with 32-bit BCR access; CLKR has 8-bit access.
433437 * All the registers are big-endian but they get byte-swapped on 32-bit
434438 * read/write (but not on 8-bit, contrary to the manuals)...
@@ -452,16 +456,17 @@ static void rcar_can_start(struct net_device *ndev) · 17 unmodified lines
452456 ctlr &= ~RCAR_CAN_CTLR_SLPM;
453457 writew(ctlr, &priv->regs->ctlr);
454458 /* Go to reset mode */
455− ctlr |= RCAR_CAN_CTLR_CANM_FORCE_RESET;
459+ ctlr |= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_FORCE_RESET);
456460 writew(ctlr, &priv->regs->ctlr);
457461 for (i = 0; i < MAX_STR_READS; i++) {
458462 if (readw(&priv->regs->str) & RCAR_CAN_STR_RSTST)
459463 break;
460464 }
461465 rcar_can_set_bittiming(ndev);
462− ctlr |= RCAR_CAN_CTLR_IDFM_MIXED; /* Select mixed ID mode */
463− ctlr |= RCAR_CAN_CTLR_BOM_ENT; /* Entry to halt mode automatically */
464− /* at bus-off */
466+ /* Select mixed ID mode */
467+ ctlr |= FIELD_PREP(RCAR_CAN_CTLR_IDFM, RCAR_CAN_CTLR_IDFM_MIXED);
468+ /* Entry to halt mode automatically at bus-off */
469+ ctlr |= FIELD_PREP(RCAR_CAN_CTLR_BOM, RCAR_CAN_CTLR_BOM_ENT);
465470 ctlr |= RCAR_CAN_CTLR_MBM; /* Select FIFO mailbox mode */
466471 ctlr |= RCAR_CAN_CTLR_MLM; /* Overrun mode */
467472 writew(ctlr, &priv->regs->ctlr);
@@ -491,7 +496,9 @@ static void rcar_can_start(struct net_device *ndev) · 23 unmodified lines
491496 priv->can.state = CAN_STATE_ERROR_ACTIVE;
492497
493498 /* Go to operation mode */
494− writew(ctlr & ~RCAR_CAN_CTLR_CANM, &priv->regs->ctlr);
499+ ctlr &= ~RCAR_CAN_CTLR_CANM;
500+ ctlr |= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_OPER);
501+ writew(ctlr, &priv->regs->ctlr);
495502 for (i = 0; i < MAX_STR_READS; i++) {
496503 if (!(readw(&priv->regs->str) & RCAR_CAN_STR_RSTST))
497504 break;
@@ -506,29 +513,28 @@ static int rcar_can_open(struct net_device *ndev) · 8 unmodified lines
506513 struct rcar_can_priv *priv = netdev_priv(ndev);
507514 int err;
508515
509− err = clk_prepare_enable(priv->clk);
516+ err = pm_runtime_resume_and_get(ndev->dev.parent);
510517 if (err) {
511− netdev_err(ndev,
512− "failed to enable peripheral clock, error %d\n",
513− err);
518+ netdev_err(ndev, "pm_runtime_resume_and_get() failed %pe\n",
519+ ERR_PTR(err));
514520 goto out;
515521 }
516522 err = clk_prepare_enable(priv->can_clk);
517523 if (err) {
518− netdev_err(ndev, "failed to enable CAN clock, error %d\n",
519− err);
520− goto out_clock;
524+ netdev_err(ndev, "failed to enable CAN clock: %pe\n",
525+ ERR_PTR(err));
526+ goto out_rpm;
521527 }
522528 err = open_candev(ndev);
523529 if (err) {
524− netdev_err(ndev, "open_candev() failed, error %d\n", err);
530+ netdev_err(ndev, "open_candev() failed %pe\n", ERR_PTR(err));
525531 goto out_can_clock;
526532 }
527533 napi_enable(&priv->napi);
528534 err = request_irq(ndev->irq, rcar_can_interrupt, 0, ndev->name, ndev);
529535 if (err) {
530− netdev_err(ndev, "request_irq(%d) failed, error %d\n",
531− ndev->irq, err);
536+ netdev_err(ndev, "request_irq(%d) failed %pe\n", ndev->irq,
537+ ERR_PTR(err));
532538 goto out_close;
533539 }
534540 rcar_can_start(ndev);
@@ -539,8 +545,8 @@ out_close: · 4 unmodified lines
539545 close_candev(ndev);
540546 out_can_clock:
541547 clk_disable_unprepare(priv->can_clk);
542−out_clock:
543− clk_disable_unprepare(priv->clk);
548+out_rpm:
549+ pm_runtime_put(ndev->dev.parent);
544550 out:
545551 return err;
546552 }
@@ -553,7 +559,7 @@ static void rcar_can_stop(struct net_device *ndev) · 6 unmodified lines
553559
554560 /* Go to (force) reset mode */
555561 ctlr = readw(&priv->regs->ctlr);
556− ctlr |= RCAR_CAN_CTLR_CANM_FORCE_RESET;
562+ ctlr |= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_FORCE_RESET);
557563 writew(ctlr, &priv->regs->ctlr);
558564 for (i = 0; i < MAX_STR_READS; i++) {
559565 if (readw(&priv->regs->str) & RCAR_CAN_STR_RSTST)
@@ -578,7 +584,7 @@ static int rcar_can_close(struct net_device *ndev) · 18 unmodified lines
578584 free_irq(ndev->irq, ndev);
579585 napi_disable(&priv->napi);
580586 clk_disable_unprepare(priv->can_clk);
581− clk_disable_unprepare(priv->clk);
587+ pm_runtime_put(ndev->dev.parent);
582588 close_candev(ndev);
583589 return 0;
584590 }
@@ -594,9 +600,10 @@ static netdev_tx_t rcar_can_start_xmit(struct sk_buff *skb, · 9 unmodified lines
594600 return NETDEV_TX_OK;
595601
596602 if (cf->can_id & CAN_EFF_FLAG) /* Extended frame format */
597− data = (cf->can_id & CAN_EFF_MASK) | RCAR_CAN_IDE;
603+ data = FIELD_PREP(RCAR_CAN_EID, cf->can_id & CAN_EFF_MASK) |
604+ RCAR_CAN_IDE;
598605 else /* Standard frame format */
599− data = (cf->can_id & CAN_SFF_MASK) << RCAR_CAN_SID_SHIFT;
606+ data = FIELD_PREP(RCAR_CAN_SID, cf->can_id & CAN_SFF_MASK);
600607
601608 if (cf->can_id & CAN_RTR_FLAG) { /* Remote transmission request */
602609 data |= RCAR_CAN_RTR;
@@ -651,9 +658,9 @@ static void rcar_can_rx_pkt(struct rcar_can_priv *priv) · 48 unmodified lines
651658
652659 data = readl(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].id);
653660 if (data & RCAR_CAN_IDE)
654− cf->can_id = (data & CAN_EFF_MASK) | CAN_EFF_FLAG;
661+ cf->can_id = FIELD_GET(RCAR_CAN_EID, data) | CAN_EFF_FLAG;
655662 else
656− cf->can_id = (data >> RCAR_CAN_SID_SHIFT) & CAN_SFF_MASK;
663+ cf->can_id = FIELD_GET(RCAR_CAN_SID, data);
657664
658665 dlc = readb(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].dlc);
659666 cf->len = can_cc_dlc2len(dlc);
@@ -715,18 +722,21 @@ static int rcar_can_do_set_mode(struct net_device *ndev, enum can_mode mode) · 55 unmodified lines
715722 }
716723 }
717724
718−static int rcar_can_get_berr_counter(const struct net_device *dev,
725+static int rcar_can_get_berr_counter(const struct net_device *ndev,
719726 struct can_berr_counter *bec)
720727 {
721− struct rcar_can_priv *priv = netdev_priv(dev);
728+ struct rcar_can_priv *priv = netdev_priv(ndev);
722729 int err;
723730
724− err = clk_prepare_enable(priv->clk);
731+ err = pm_runtime_resume_and_get(ndev->dev.parent);
725732 if (err)
726733 return err;
734+
727735 bec->txerr = readb(&priv->regs->tecr);
728736 bec->rxerr = readb(&priv->regs->recr);
729− clk_disable_unprepare(priv->clk);
737+
738+ pm_runtime_put(ndev->dev.parent);
739+
730740 return 0;
731741 }
732742
@@ -738,6 +748,7 @@ static const char * const clock_names[] = { · 5 unmodified lines
738748
739749 static int rcar_can_probe(struct platform_device *pdev)
740750 {
751+ struct device *dev = &pdev->dev;
741752 struct rcar_can_priv *priv;
742753 struct net_device *ndev;
743754 void __iomem *addr;
@@ -745,7 +756,7 @@ static int rcar_can_probe(struct platform_device *pdev) · 1 unmodified line
745756 int err = -ENODEV;
746757 int irq;
747758
748− of_property_read_u32(pdev->dev.of_node, "renesas,can-clock-select",
759+ of_property_read_u32(dev->of_node, "renesas,can-clock-select",
749760 &clock_select);
750761
751762 irq = platform_get_irq(pdev, 0);
@@ -762,30 +773,21 @@ static int rcar_can_probe(struct platform_device *pdev) · 10 unmodified lines
762773
763774 ndev = alloc_candev(sizeof(struct rcar_can_priv), RCAR_CAN_FIFO_DEPTH);
764775 if (!ndev) {
765− dev_err(&pdev->dev, "alloc_candev() failed\n");
766776 err = -ENOMEM;
767777 goto fail;
768778 }
769779
770780 priv = netdev_priv(ndev);
771781
772− priv->clk = devm_clk_get(&pdev->dev, "clkp1");
773− if (IS_ERR(priv->clk)) {
774− err = PTR_ERR(priv->clk);
775− dev_err(&pdev->dev, "cannot get peripheral clock, error %d\n",
776− err);
777− goto fail_clk;
778− }
779−
780782 if (!(BIT(clock_select) & RCAR_SUPPORTED_CLOCKS)) {
781783 err = -EINVAL;
782− dev_err(&pdev->dev, "invalid CAN clock selected\n");
784+ dev_err(dev, "invalid CAN clock selected\n");
783785 goto fail_clk;
784786 }
785− priv->can_clk = devm_clk_get(&pdev->dev, clock_names[clock_select]);
787+ priv->can_clk = devm_clk_get(dev, clock_names[clock_select]);
786788 if (IS_ERR(priv->can_clk)) {
789+ dev_err(dev, "cannot get CAN clock: %pe\n", priv->can_clk);
787790 err = PTR_ERR(priv->can_clk);
788− dev_err(&pdev->dev, "cannot get CAN clock, error %d\n", err);
789791 goto fail_clk;
790792 }
791793
@@ -802,21 +804,24 @@ static int rcar_can_probe(struct platform_device *pdev) · 10 unmodified lines
802804 priv->can.do_get_berr_counter = rcar_can_get_berr_counter;
803805 priv->can.ctrlmode_supported = CAN_CTRLMODE_BERR_REPORTING;
804806 platform_set_drvdata(pdev, ndev);
805− SET_NETDEV_DEV(ndev, &pdev->dev);
807+ SET_NETDEV_DEV(ndev, dev);
806808
807809 netif_napi_add_weight(ndev, &priv->napi, rcar_can_rx_poll,
808810 RCAR_CAN_NAPI_WEIGHT);
811+
812+ pm_runtime_enable(dev);
813+
809814 err = register_candev(ndev);
810815 if (err) {
811− dev_err(&pdev->dev, "register_candev() failed, error %d\n",
812− err);
813− goto fail_candev;
816+ dev_err(dev, "register_candev() failed %pe\n", ERR_PTR(err));
817+ goto fail_rpm;
814818 }
815819
816− dev_info(&pdev->dev, "device registered (IRQ%d)\n", ndev->irq);
820+ dev_info(dev, "device registered (IRQ%d)\n", ndev->irq);
817821
818822 return 0;
819−fail_candev:
823+fail_rpm:
824+ pm_runtime_disable(dev);
820825 netif_napi_del(&priv->napi);
821826 fail_clk:
822827 free_candev(ndev);
@@ -830,6 +835,7 @@ static void rcar_can_remove(struct platform_device *pdev) · 7 unmodified lines
830835 struct rcar_can_priv *priv = netdev_priv(ndev);
831836
832837 unregister_candev(ndev);
838+ pm_runtime_disable(&pdev->dev);
833839 netif_napi_del(&priv->napi);
834840 free_candev(ndev);
835841 }
@@ -847,28 +853,28 @@ static int rcar_can_suspend(struct device *dev) · 11 unmodified lines
847853 netif_device_detach(ndev);
848854
849855 ctlr = readw(&priv->regs->ctlr);
850− ctlr |= RCAR_CAN_CTLR_CANM_HALT;
856+ ctlr |= FIELD_PREP(RCAR_CAN_CTLR_CANM, RCAR_CAN_CTLR_CANM_HALT);
851857 writew(ctlr, &priv->regs->ctlr);
852858 ctlr |= RCAR_CAN_CTLR_SLPM;
853859 writew(ctlr, &priv->regs->ctlr);
854860 priv->can.state = CAN_STATE_SLEEPING;
855861
856− clk_disable(priv->clk);
862+ pm_runtime_put(dev);
857863 return 0;
858864 }
859865
860866 static int rcar_can_resume(struct device *dev)
861867 {
862868 struct net_device *ndev = dev_get_drvdata(dev);
863− struct rcar_can_priv *priv = netdev_priv(ndev);
864869 int err;
865870
866871 if (!netif_running(ndev))
867872 return 0;
868873
869− err = clk_enable(priv->clk);
874+ err = pm_runtime_resume_and_get(dev);
870875 if (err) {
871− netdev_err(ndev, "clk_enable() failed, error %d\n", err);
876+ netdev_err(ndev, "pm_runtime_resume_and_get() failed %pe\n",
877+ ERR_PTR(err));
872878 return err;
873879 }
874880
drivers/net/can/rcar/rcar_canfd.c+47−37
@@ -103,22 +103,13 @@ · 102 unmodified lines
103103 /* Channel register bits */
104104
105105 /* 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)
110110
111111 /* 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)
122113
123114 /* RSCFDnCFDCmCTR / RSCFDnCmCTR */
124115 #define RCANFD_CCTR_CTME BIT(24)
@@ -178,15 +169,7 @@ · 53 unmodified lines
178169 #define RCANFD_CERFL_ERR(x) ((x) & (0x7fff)) /* above bits 14:0 */
179170
180171 /* RSCFDnCFDCmDCFG */
181−#define RCANFD_DCFG_DSJW(gpriv, x) (((x) & ((gpriv)->info->data_bittiming->sjw_max - 1)) << 24)
182−
183−#define RCANFD_DCFG_DTSEG2(gpriv, x) \
184− (((x) & ((gpriv)->info->data_bittiming->tseg2_max - 1)) << (gpriv)->info->sh->dtseg2)
185−
186−#define RCANFD_DCFG_DTSEG1(gpriv, x) \
187− (((x) & ((gpriv)->info->data_bittiming->tseg1_max - 1)) << (gpriv)->info->sh->dtseg1)
188−
189−#define RCANFD_DCFG_DBRP(x) (((x) & 0xff) << 0)
172+#define RCANFD_DCFG_DBRP GENMASK(7, 0)
190173
191174 /* RSCFDnCFDCmFDCFG */
192175 #define RCANFD_GEN4_FDCFG_CLOE BIT(30)
@@ -1389,6 +1372,41 @@ static irqreturn_t rcar_canfd_channel_interrupt(int irq, void *dev_id) · 1196 unmodified lines
13891372 return IRQ_HANDLED;
13901373 }
13911374
1375+static inline u32 rcar_canfd_compute_nominal_bit_rate_cfg(struct rcar_canfd_channel *priv,
1376+ u16 tseg1, u16 tseg2, u16 sjw, u16 brp)
1377+{
1378+ struct rcar_canfd_global *gpriv = priv->gpriv;
1379+ const struct rcar_canfd_hw_info *info = gpriv->info;
1380+ u32 ntseg1, ntseg2, nsjw, nbrp;
1381+
1382+ if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) || gpriv->info->shared_can_regs) {
1383+ ntseg1 = (tseg1 & (info->nom_bittiming->tseg1_max - 1)) << info->sh->ntseg1;
1384+ ntseg2 = (tseg2 & (info->nom_bittiming->tseg2_max - 1)) << info->sh->ntseg2;
1385+ nsjw = (sjw & (info->nom_bittiming->sjw_max - 1)) << info->sh->nsjw;
1386+ nbrp = FIELD_PREP(RCANFD_NCFG_NBRP, brp);
1387+ } else {
1388+ ntseg1 = FIELD_PREP(RCANFD_CFG_TSEG1, tseg1);
1389+ ntseg2 = FIELD_PREP(RCANFD_CFG_TSEG2, tseg2);
1390+ nsjw = FIELD_PREP(RCANFD_CFG_SJW, sjw);
1391+ nbrp = FIELD_PREP(RCANFD_CFG_BRP, brp);
1392+ }
1393+
1394+ return (ntseg1 | ntseg2 | nsjw | nbrp);
1395+}
1396+
1397+static inline u32 rcar_canfd_compute_data_bit_rate_cfg(const struct rcar_canfd_hw_info *info,
1398+ u16 tseg1, u16 tseg2, u16 sjw, u16 brp)
1399+{
1400+ u32 dtseg1, dtseg2, dsjw, dbrp;
1401+
1402+ dtseg1 = (tseg1 & (info->data_bittiming->tseg1_max - 1)) << info->sh->dtseg1;
1403+ dtseg2 = (tseg2 & (info->data_bittiming->tseg2_max - 1)) << info->sh->dtseg2;
1404+ dsjw = (sjw & (info->data_bittiming->sjw_max - 1)) << 24;
1405+ dbrp = FIELD_PREP(RCANFD_DCFG_DBRP, brp);
1406+
1407+ return (dtseg1 | dtseg2 | dsjw | dbrp);
1408+}
1409+
13921410 static void rcar_canfd_set_bittiming(struct net_device *ndev)
13931411 {
13941412 u32 mask = RCANFD_FDCFG_TDCO | RCANFD_FDCFG_TDCE | RCANFD_FDCFG_TDCOC;
@@ -1407,15 +1425,7 @@ static void rcar_canfd_set_bittiming(struct net_device *ndev) · 12 unmodified lines
14071425 sjw = bt->sjw - 1;
14081426 tseg1 = bt->prop_seg + bt->phase_seg1 - 1;
14091427 tseg2 = bt->phase_seg2 - 1;
1410−
1411− if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) || gpriv->info->shared_can_regs) {
1412− cfg = (RCANFD_NCFG_NTSEG1(gpriv, tseg1) | RCANFD_NCFG_NBRP(brp) |
1413− RCANFD_NCFG_NSJW(gpriv, sjw) | RCANFD_NCFG_NTSEG2(gpriv, tseg2));
1414− } else {
1415− cfg = (RCANFD_CFG_TSEG1(tseg1) | RCANFD_CFG_BRP(brp) |
1416− RCANFD_CFG_SJW(sjw) | RCANFD_CFG_TSEG2(tseg2));
1417− }
1418−
1428+ cfg = rcar_canfd_compute_nominal_bit_rate_cfg(priv, tseg1, tseg2, sjw, brp);
14191429 rcar_canfd_write(priv->base, RCANFD_CCFG(ch), cfg);
14201430
14211431 if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD))
@@ -1426,10 +1436,7 @@ static void rcar_canfd_set_bittiming(struct net_device *ndev) · 4 unmodified lines
14261436 sjw = dbt->sjw - 1;
14271437 tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1;
14281438 tseg2 = dbt->phase_seg2 - 1;
1429−
1430− cfg = (RCANFD_DCFG_DTSEG1(gpriv, tseg1) | RCANFD_DCFG_DBRP(brp) |
1431− RCANFD_DCFG_DSJW(gpriv, sjw) | RCANFD_DCFG_DTSEG2(gpriv, tseg2));
1432−
1439+ cfg = rcar_canfd_compute_data_bit_rate_cfg(gpriv->info, tseg1, tseg2, sjw, brp);
14331440 writel(cfg, &gpriv->fcbase[ch].dcfg);
14341441
14351442 /* Transceiver Delay Compensation */
@@ -1913,7 +1920,10 @@ static int rcar_canfd_channel_probe(struct rcar_canfd_global *gpriv, u32 ch, · 477 unmodified lines
19131920 priv->can.fd.do_get_auto_tdcv = rcar_canfd_get_auto_tdcv;
19141921 } else {
19151922 /* Controller starts in Classical CAN only mode */
1916− priv->can.bittiming_const = &rcar_canfd_bittiming_const;
1923+ if (gpriv->info->shared_can_regs)
1924+ priv->can.bittiming_const = gpriv->info->nom_bittiming;
1925+ else
1926+ priv->can.bittiming_const = &rcar_canfd_bittiming_const;
19171927 priv->can.ctrlmode_supported = CAN_CTRLMODE_BERR_REPORTING;
19181928 }
19191929
drivers/net/can/sja1000/peak_pci.c+3−3
@@ -1,11 +1,11 @@
11 // SPDX-License-Identifier: GPL-2.0-only
22 /*
33 * Copyright (C) 2007, 2011 Wolfgang Grandegger <wg@grandegger.com>
4− * Copyright (C) 2012 Stephane Grosjean <s.grosjean@peak-system.com>
54 *
65 * Derived from the PCAN project file driver/src/pcan_pci.c:
76 *
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>
99 */
1010
1111 #include <linux/kernel.h>
@@ -22,7 +22,7 @@ · 10 unmodified lines
2222
2323 #include "sja1000.h"
2424
25−MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
25+MODULE_AUTHOR("Stéphane Grosjean <stephane.grosjean@hms-networks.com>");
2626 MODULE_DESCRIPTION("Socket-CAN driver for PEAK PCAN PCI family cards");
2727 MODULE_LICENSE("GPL v2");
2828
drivers/net/can/sja1000/peak_pcmcia.c+4−4
@@ -1,10 +1,10 @@
11 // SPDX-License-Identifier: GPL-2.0-only
22 /*
3− * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com>
4− *
53 * CAN driver for PEAK-System PCAN-PC Card
64 * 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>
88 */
99 #include <linux/kernel.h>
1010 #include <linux/module.h>
@@ -19,7 +19,7 @@ · 8 unmodified lines
1919 #include <linux/can/dev.h>
2020 #include "sja1000.h"
2121
22−MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
22+MODULE_AUTHOR("Stéphane Grosjean <stephane.grosjean@hms-networks.com>");
2323 MODULE_DESCRIPTION("CAN driver for PEAK-System PCAN-PC Cards");
2424 MODULE_LICENSE("GPL v2");
2525
drivers/net/can/usb/esd_usb.c+43−21
@@ -9,6 +9,7 @@ · 8 unmodified lines
99 #include <linux/can.h>
1010 #include <linux/can/dev.h>
1111 #include <linux/can/error.h>
12+#include <linux/err.h>
1213 #include <linux/ethtool.h>
1314 #include <linux/module.h>
1415 #include <linux/netdevice.h>
@@ -274,6 +275,7 @@ struct esd_usb { · 259 unmodified lines
274275 int net_count;
275276 u32 version;
276277 int rxinitdone;
278+ int in_usb_disconnect;
277279 void *rxbuf[ESD_USB_MAX_RX_URBS];
278280 dma_addr_t rxbuf_dma[ESD_USB_MAX_RX_URBS];
279281 };
@@ -480,7 +482,7 @@ static void esd_usb_tx_done_msg(struct esd_usb_net_priv *priv, · 200 unmodified lines
480482 static void esd_usb_read_bulk_callback(struct urb *urb)
481483 {
482484 struct esd_usb *dev = urb->context;
483− int retval;
485+ int err;
484486 int pos = 0;
485487 int i;
486488
@@ -496,7 +498,7 @@ static void esd_usb_read_bulk_callback(struct urb *urb) · 9 unmodified lines
496498
497499 default:
498500 dev_info(dev->udev->dev.parent,
499− "Rx URB aborted (%d)\n", urb->status);
501+ "Rx URB aborted (%pe)\n", ERR_PTR(urb->status));
500502 goto resubmit_urb;
501503 }
502504
@@ -539,15 +541,15 @@ resubmit_urb: · 36 unmodified lines
539541 urb->transfer_buffer, ESD_USB_RX_BUFFER_SIZE,
540542 esd_usb_read_bulk_callback, dev);
541543
542− retval = usb_submit_urb(urb, GFP_ATOMIC);
543− if (retval == -ENODEV) {
544+ err = usb_submit_urb(urb, GFP_ATOMIC);
545+ if (err == -ENODEV) {
544546 for (i = 0; i < dev->net_count; i++) {
545547 if (dev->nets[i])
546548 netif_device_detach(dev->nets[i]->netdev);
547549 }
548− } else if (retval) {
550+ } else if (err) {
549551 dev_err(dev->udev->dev.parent,
550− "failed resubmitting read bulk urb: %d\n", retval);
552+ "failed resubmitting read bulk urb: %pe\n", ERR_PTR(err));
551553 }
552554 }
553555
@@ -572,7 +574,7 @@ static void esd_usb_write_bulk_callback(struct urb *urb) · 18 unmodified lines
572574 return;
573575
574576 if (urb->status)
575− netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status);
577+ netdev_info(netdev, "Tx URB aborted (%pe)\n", ERR_PTR(urb->status));
576578
577579 netif_trans_update(netdev);
578580 }
@@ -758,7 +760,7 @@ out: · 179 unmodified lines
758760 if (err == -ENODEV)
759761 netif_device_detach(netdev);
760762 if (err)
761− netdev_err(netdev, "couldn't start device: %d\n", err);
763+ netdev_err(netdev, "couldn't start device: %pe\n", ERR_PTR(err));
762764
763765 kfree(msg);
764766 return err;
@@ -800,7 +802,6 @@ static int esd_usb_open(struct net_device *netdev) · 35 unmodified lines
800802 /* finally start device */
801803 err = esd_usb_start(priv);
802804 if (err) {
803− netdev_warn(netdev, "couldn't start device: %d\n", err);
804805 close_candev(netdev);
805806 return err;
806807 }
@@ -923,7 +924,7 @@ static netdev_tx_t esd_usb_start_xmit(struct sk_buff *skb, · 116 unmodified lines
923924 if (err == -ENODEV)
924925 netif_device_detach(netdev);
925926 else
926− netdev_warn(netdev, "failed tx_urb %d\n", err);
927+ netdev_warn(netdev, "failed tx_urb %pe\n", ERR_PTR(err));
927928
928929 goto releasebuf;
929930 }
@@ -947,10 +948,11 @@ nourbmem: · 17 unmodified lines
947948 return ret;
948949 }
949950
950−static int esd_usb_close(struct net_device *netdev)
951+/* Stop interface */
952+static int esd_usb_stop(struct esd_usb_net_priv *priv)
951953 {
952− struct esd_usb_net_priv *priv = netdev_priv(netdev);
953954 union esd_usb_msg *msg;
955+ int err;
954956 int i;
955957
956958 msg = kmalloc(sizeof(*msg), GFP_KERNEL);
@@ -964,8 +966,11 @@ static int esd_usb_close(struct net_device *netdev) · 7 unmodified lines
964966 msg->filter.option = ESD_USB_ID_ENABLE; /* start with segment 0 */
965967 for (i = 0; i <= ESD_USB_MAX_ID_SEGMENT; i++)
966968 msg->filter.mask[i] = 0;
967− if (esd_usb_send_msg(priv->usb, msg) < 0)
968− netdev_err(netdev, "sending idadd message failed\n");
969+ err = esd_usb_send_msg(priv->usb, msg);
970+ if (err < 0) {
971+ netdev_err(priv->netdev, "sending idadd message failed: %pe\n", ERR_PTR(err));
972+ goto bail;
973+ }
969974
970975 /* set CAN controller to reset mode */
971976 msg->hdr.len = sizeof(struct esd_usb_set_baudrate_msg) / sizeof(u32); /* # of 32bit words */
@@ -973,8 +978,25 @@ static int esd_usb_close(struct net_device *netdev) · 1 unmodified line
973978 msg->setbaud.net = priv->index;
974979 msg->setbaud.rsvd = 0;
975980 msg->setbaud.baud = cpu_to_le32(ESD_USB_NO_BAUDRATE);
976− if (esd_usb_send_msg(priv->usb, msg) < 0)
977− netdev_err(netdev, "sending setbaud message failed\n");
981+ err = esd_usb_send_msg(priv->usb, msg);
982+ if (err < 0)
983+ netdev_err(priv->netdev, "sending setbaud message failed: %pe\n", ERR_PTR(err));
984+
985+bail:
986+ kfree(msg);
987+
988+ return err;
989+}
990+
991+static int esd_usb_close(struct net_device *netdev)
992+{
993+ struct esd_usb_net_priv *priv = netdev_priv(netdev);
994+ int err = 0;
995+
996+ if (!priv->usb->in_usb_disconnect) {
997+ /* It's moot to try this in usb_disconnect()! */
998+ err = esd_usb_stop(priv);
999+ }
9781000
9791001 priv->can.state = CAN_STATE_STOPPED;
9801002
@@ -982,9 +1004,7 @@ static int esd_usb_close(struct net_device *netdev) · 1 unmodified line
9821004
9831005 close_candev(netdev);
9841006
985− kfree(msg);
986−
987− return 0;
1007+ return err;
9881008 }
9891009
9901010 static const struct net_device_ops esd_usb_netdev_ops = {
@@ -1251,14 +1271,14 @@ static int esd_usb_probe_one_net(struct usb_interface *intf, int index) · 260 unmodified lines
12511271
12521272 err = register_candev(netdev);
12531273 if (err) {
1254− dev_err(&intf->dev, "couldn't register CAN device: %d\n", err);
1274+ dev_err(&intf->dev, "couldn't register CAN device: %pe\n", ERR_PTR(err));
12551275 free_candev(netdev);
12561276 err = -ENOMEM;
12571277 goto done;
12581278 }
12591279
12601280 dev->nets[index] = priv;
1261− netdev_info(netdev, "device %s registered\n", netdev->name);
1281+ netdev_info(netdev, "registered\n");
12621282
12631283 done:
12641284 return err;
@@ -1354,9 +1374,11 @@ static void esd_usb_disconnect(struct usb_interface *intf) · 89 unmodified lines
13541374 usb_set_intfdata(intf, NULL);
13551375
13561376 if (dev) {
1377+ dev->in_usb_disconnect = 1;
13571378 for (i = 0; i < dev->net_count; i++) {
13581379 if (dev->nets[i]) {
13591380 netdev = dev->nets[i]->netdev;
1381+ netdev_info(netdev, "unregister\n");
13601382 unregister_netdev(netdev);
13611383 free_candev(netdev);
13621384 }
drivers/net/can/usb/peak_usb/pcan_usb.c+3−3
@@ -3,8 +3,8 @@ · 2 unmodified lines
33 * CAN driver for PEAK System PCAN-USB adapter
44 * Derived from the PCAN project file driver/src/pcan_usb.c
55 *
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>
88 *
99 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
1010 */
@@ -919,7 +919,7 @@ static int pcan_usb_init(struct peak_usb_device *dev) · 908 unmodified lines
919919 CAN_CTRLMODE_LOOPBACK;
920920 } else {
921921 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");
923923 }
924924
925925 return 0;
drivers/net/can/usb/peak_usb/pcan_usb_core.c+3−3
@@ -3,8 +3,8 @@ · 2 unmodified lines
33 * CAN driver for PEAK System USB adapters
44 * Derived from the PCAN project file driver/src/pcan_usb_core.c
55 *
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>
88 *
99 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
1010 */
@@ -24,7 +24,7 @@ · 13 unmodified lines
2424
2525 #include "pcan_usb_core.h"
2626
27−MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>");
27+MODULE_AUTHOR("Stéphane Grosjean <stephane.grosjean@hms-networks.com>");
2828 MODULE_DESCRIPTION("CAN driver for PEAK-System USB adapters");
2929 MODULE_LICENSE("GPL v2");
3030
drivers/net/can/usb/peak_usb/pcan_usb_core.h+2−2
@@ -3,8 +3,8 @@ · 2 unmodified lines
33 * CAN driver for PEAK System USB adapters
44 * Derived from the PCAN project file driver/src/pcan_usb_core.c
55 *
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>
88 *
99 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
1010 */
drivers/net/can/usb/peak_usb/pcan_usb_fd.c+2−1
@@ -2,7 +2,8 @@ · 1 unmodified line
22 /*
33 * CAN driver for PEAK System PCAN-USB FD / PCAN-USB Pro FD adapter
44 *
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>
67 */
78 #include <linux/ethtool.h>
89 #include <linux/module.h>
drivers/net/can/usb/peak_usb/pcan_usb_pro.c+2−2
@@ -3,8 +3,8 @@ · 2 unmodified lines
33 * CAN driver for PEAK System PCAN-USB Pro adapter
44 * Derived from the PCAN project file driver/src/pcan_usbpro.c
55 *
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>
88 */
99 #include <linux/ethtool.h>
1010 #include <linux/module.h>
drivers/net/can/usb/peak_usb/pcan_usb_pro.h+2−2
@@ -3,8 +3,8 @@ · 2 unmodified lines
33 * CAN driver for PEAK System PCAN-USB Pro adapter
44 * Derived from the PCAN project file driver/src/pcan_usbpro_fw.h
55 *
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>
88 */
99 #ifndef PCAN_USB_PRO_H
1010 #define PCAN_USB_PRO_H
drivers/net/can/vcan.c+1−1
@@ -156,7 +156,7 @@ static const struct ethtool_ops vcan_ethtool_ops = { · 155 unmodified lines
156156 static void vcan_setup(struct net_device *dev)
157157 {
158158 dev->type = ARPHRD_CAN;
159− dev->mtu = CANFD_MTU;
159+ dev->mtu = CANXL_MTU;
160160 dev->hard_header_len = 0;
161161 dev->addr_len = 0;
162162 dev->tx_queue_len = 0;
drivers/net/can/vxcan.c+1−1
@@ -156,7 +156,7 @@ static void vxcan_setup(struct net_device *dev) · 155 unmodified lines
156156 struct can_ml_priv *can_ml;
157157
158158 dev->type = ARPHRD_CAN;
159− dev->mtu = CANFD_MTU;
159+ dev->mtu = CANXL_MTU;
160160 dev->hard_header_len = 0;
161161 dev->addr_len = 0;
162162 dev->tx_queue_len = 0;
include/linux/can/bittiming.h+46−2
@@ -16,6 +16,10 @@ · 15 unmodified lines
1616
1717 #define CAN_CTRLMODE_FD_TDC_MASK \
1818 (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)
1923
2024 /*
2125 * struct can_tdc - CAN FD Transmission Delay Compensation parameters
@@ -114,13 +118,24 @@ struct can_tdc_const { · 92 unmodified lines
114118 u32 tdcf_max;
115119 };
116120
121+struct data_bittiming_params {
122+ const struct can_bittiming_const *data_bittiming_const;
123+ struct can_bittiming data_bittiming;
124+ const struct can_tdc_const *tdc_const;
125+ struct can_tdc tdc;
126+ const u32 *data_bitrate_const;
127+ unsigned int data_bitrate_const_cnt;
128+ int (*do_set_data_bittiming)(struct net_device *dev);
129+ int (*do_get_auto_tdcv)(const struct net_device *dev, u32 *tdcv);
130+};
131+
117132 #ifdef CONFIG_CAN_CALC_BITTIMING
118133 int can_calc_bittiming(const struct net_device *dev, struct can_bittiming *bt,
119134 const struct can_bittiming_const *btc, struct netlink_ext_ack *extack);
120135
121136 void can_calc_tdco(struct can_tdc *tdc, const struct can_tdc_const *tdc_const,
122137 const struct can_bittiming *dbt,
123− u32 *ctrlmode, u32 ctrlmode_supported);
138+ u32 tdc_mask, u32 *ctrlmode, u32 ctrlmode_supported);
124139 #else /* !CONFIG_CAN_CALC_BITTIMING */
125140 static inline int
126141 can_calc_bittiming(const struct net_device *dev, struct can_bittiming *bt,
@@ -133,7 +148,7 @@ can_calc_bittiming(const struct net_device *dev, struct can_bittiming *bt, · 6 unmodified lines
133148 static inline void
134149 can_calc_tdco(struct can_tdc *tdc, const struct can_tdc_const *tdc_const,
135150 const struct can_bittiming *dbt,
136− u32 *ctrlmode, u32 ctrlmode_supported)
151+ u32 tdc_mask, u32 *ctrlmode, u32 ctrlmode_supported)
137152 {
138153 }
139154 #endif /* CONFIG_CAN_CALC_BITTIMING */
@@ -149,6 +164,35 @@ int can_get_bittiming(const struct net_device *dev, struct can_bittiming *bt, · 9 unmodified lines
149164 const unsigned int bitrate_const_cnt,
150165 struct netlink_ext_ack *extack);
151166
167+/*
168+ * can_get_relative_tdco() - TDCO relative to the sample point
169+ *
170+ * struct can_tdc::tdco represents the absolute offset from TDCV. Some
171+ * controllers use instead an offset relative to the Sample Point (SP)
172+ * such that:
173+ *
174+ * SSP = TDCV + absolute TDCO
175+ * = TDCV + SP + relative TDCO
176+ *
177+ * -+----------- one bit ----------+-- TX pin
178+ * |<--- Sample Point --->|
179+ *
180+ * --+----------- one bit ----------+-- RX pin
181+ * |<-------- TDCV -------->|
182+ * |<------------------------>| absolute TDCO
183+ * |<--- Sample Point --->|
184+ * | |<->| relative TDCO
185+ * |<------------- Secondary Sample Point ------------>|
186+ */
187+static inline s32 can_get_relative_tdco(const struct data_bittiming_params *dbt_params)
188+{
189+ const struct can_bittiming *dbt = &dbt_params->data_bittiming;
190+ s32 sample_point_in_tc = (CAN_SYNC_SEG + dbt->prop_seg +
191+ dbt->phase_seg1) * dbt->brp;
192+
193+ return (s32)dbt_params->tdc.tdco - sample_point_in_tc;
194+}
195+
152196 /*
153197 * can_bit_time() - Duration of one bit
154198 *
include/linux/can/dev.h+5−61
@@ -38,17 +38,6 @@ enum can_termination_gpio { · 37 unmodified lines
3838 CAN_TERMINATION_GPIO_MAX,
3939 };
4040
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−
5241 /*
5342 * CAN common private data
5443 */
@@ -96,56 +85,6 @@ static inline bool can_fd_tdc_is_enabled(const struct can_priv *priv) · 41 unmodified lines
9685 return !!(priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK);
9786 }
9887
99−/*
100− * can_get_relative_tdco() - TDCO relative to the sample point
101− *
102− * struct can_tdc::tdco represents the absolute offset from TDCV. Some
103− * controllers use instead an offset relative to the Sample Point (SP)
104− * such that:
105− *
106− * SSP = TDCV + absolute TDCO
107− * = TDCV + SP + relative TDCO
108− *
109− * -+----------- one bit ----------+-- TX pin
110− * |<--- Sample Point --->|
111− *
112− * --+----------- one bit ----------+-- RX pin
113− * |<-------- TDCV -------->|
114− * |<------------------------>| absolute TDCO
115− * |<--- Sample Point --->|
116− * | |<->| relative TDCO
117− * |<------------- Secondary Sample Point ------------>|
118− */
119−static inline s32 can_get_relative_tdco(const struct can_priv *priv)
120−{
121− const struct can_bittiming *dbt = &priv->fd.data_bittiming;
122− s32 sample_point_in_tc = (CAN_SYNC_SEG + dbt->prop_seg +
123− dbt->phase_seg1) * dbt->brp;
124−
125− return (s32)priv->fd.tdc.tdco - sample_point_in_tc;
126−}
127−
128−/* helper to define static CAN controller features at device creation time */
129−static inline int __must_check can_set_static_ctrlmode(struct net_device *dev,
130− u32 static_mode)
131−{
132− struct can_priv *priv = netdev_priv(dev);
133−
134− /* alloc_candev() succeeded => netdev_priv() is valid at this point */
135− if (priv->ctrlmode_supported & static_mode) {
136− netdev_warn(dev,
137− "Controller features can not be supported and static at the same time\n");
138− return -EINVAL;
139− }
140− priv->ctrlmode = static_mode;
141−
142− /* override MTU which was set by default in can_setup()? */
143− if (static_mode & CAN_CTRLMODE_FD)
144− dev->mtu = CANFD_MTU;
145−
146− return 0;
147−}
148−
14988 static inline u32 can_get_static_ctrlmode(struct can_priv *priv)
15089 {
15190 return priv->ctrlmode & ~priv->ctrlmode_supported;
@@ -187,7 +126,10 @@ struct can_priv *safe_candev_priv(struct net_device *dev); · 35 unmodified lines
187126
188127 int open_candev(struct net_device *dev);
189128 void close_candev(struct net_device *dev);
129+void can_set_default_mtu(struct net_device *dev);
190130 int can_change_mtu(struct net_device *dev, int new_mtu);
131+int __must_check can_set_static_ctrlmode(struct net_device *dev,
132+ u32 static_mode);
191133 int can_eth_ioctl_hwts(struct net_device *netdev, struct ifreq *ifr, int cmd);
192134 int can_ethtool_op_get_ts_info_hwts(struct net_device *dev,
193135 struct kernel_ethtool_ts_info *info);
@@ -199,6 +141,8 @@ int can_restart_now(struct net_device *dev); · 5 unmodified lines
199141 void can_bus_off(struct net_device *dev);
200142
201143 const char *can_get_state_str(const enum can_state state);
144+const char *can_get_ctrlmode_str(u32 ctrlmode);
145+
202146 void can_state_get_by_berr_counter(const struct net_device *dev,
203147 const struct can_berr_counter *bec,
204148 enum can_state *tx_state,
include/linux/can/dev/peak_canfd.h+2−2
@@ -2,8 +2,8 @@ · 1 unmodified line
22 /*
33 * CAN driver for PEAK System micro-CAN based adapters
44 *
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>
77 */
88 #ifndef PUCAN_H
99 #define PUCAN_H
include/uapi/linux/can/netlink.h+7−7
@@ -101,8 +101,8 @@ struct can_ctrlmode { · 100 unmodified lines
101101 #define CAN_CTRLMODE_PRESUME_ACK 0x40 /* Ignore missing CAN ACKs */
102102 #define CAN_CTRLMODE_FD_NON_ISO 0x80 /* CAN FD in non-ISO mode */
103103 #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 */
106106
107107 /*
108108 * CAN device statistics
@@ -129,14 +129,14 @@ enum { · 20 unmodified lines
129129 IFLA_CAN_RESTART_MS,
130130 IFLA_CAN_RESTART,
131131 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 */
134134 IFLA_CAN_TERMINATION,
135135 IFLA_CAN_TERMINATION_CONST,
136136 IFLA_CAN_BITRATE_CONST,
137− IFLA_CAN_DATA_BITRATE_CONST,
137+ IFLA_CAN_DATA_BITRATE_CONST, /* FD */
138138 IFLA_CAN_BITRATE_MAX,
139− IFLA_CAN_TDC,
139+ IFLA_CAN_TDC, /* FD */
140140 IFLA_CAN_CTRLMODE_EXT,
141141
142142 /* add new constants above here */
@@ -145,7 +145,7 @@ enum { · 2 unmodified lines
145145 };
146146
147147 /*
148− * CAN FD Transmitter Delay Compensation (TDC)
148+ * CAN FD/XL Transmitter Delay Compensation (TDC)
149149 *
150150 * Please refer to struct can_tdc_const and can_tdc in
151151 * include/linux/can/bittiming.h for further details.
net/can/af_can.c+1−1
@@ -221,7 +221,7 @@ int can_send(struct sk_buff *skb, int loop) · 220 unmodified lines
221221 }
222222
223223 /* 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))) {
225225 err = -EMSGSIZE;
226226 goto inval_skb;
227227 }
net/can/isotp.c+1−1
@@ -1313,7 +1313,7 @@ static int isotp_bind(struct socket *sock, struct sockaddr *uaddr, int len) · 1312 unmodified lines
13131313 err = -ENODEV;
13141314 goto out;
13151315 }
1316− if (dev->mtu < so->ll.mtu) {
1316+ if (READ_ONCE(dev->mtu) < so->ll.mtu) {
13171317 dev_put(dev);
13181318 err = -EINVAL;
13191319 goto out;
net/can/raw.c+39−28
@@ -75,31 +75,31 @@ MODULE_ALIAS("can-proto-1"); · 74 unmodified lines
7575 */
7676
7777 struct uniqframe {
78− int skbcnt;
7978 const struct sk_buff *skb;
79+ int skbcnt;
8080 unsigned int join_rx_count;
8181 };
8282
8383 struct raw_sock {
8484 struct sock sk;
85− int bound;
86− int ifindex;
8785 struct net_device *dev;
8886 netdevice_tracker dev_tracker;
8987 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;
9495 struct can_raw_vcid_options raw_vcid_opts;
9596 canid_t tx_vcid_shifted;
9697 canid_t rx_vcid_shifted;
9798 canid_t rx_vcid_mask_shifted;
98− int join_filters;
99+ can_err_mask_t err_mask;
99100 int count; /* number of active filters */
100101 struct can_filter dfilter; /* default/single filter */
101102 struct can_filter *filter; /* pointer to filter(s) */
102− can_err_mask_t err_mask;
103103 struct uniqframe __percpu *uniq;
104104 };
105105
@@ -560,8 +560,8 @@ static int raw_setsockopt(struct socket *sock, int level, int optname, · 454 unmodified lines
560560 struct can_filter sfilter; /* single filter */
561561 struct net_device *dev = NULL;
562562 can_err_mask_t err_mask = 0;
563− int fd_frames;
564563 int count = 0;
564+ int flag;
565565 int err = 0;
566566
567567 if (level != SOL_CAN_RAW)
@@ -682,44 +682,48 @@ static int raw_setsockopt(struct socket *sock, int level, int optname, · 114 unmodified lines
682682 break;
683683
684684 case CAN_RAW_LOOPBACK:
685− if (optlen != sizeof(ro->loopback))
685+ if (optlen != sizeof(flag))
686686 return -EINVAL;
687687
688− if (copy_from_sockptr(&ro->loopback, optval, optlen))
688+ if (copy_from_sockptr(&flag, optval, optlen))
689689 return -EFAULT;
690690
691+ ro->loopback = !!flag;
691692 break;
692693
693694 case CAN_RAW_RECV_OWN_MSGS:
694− if (optlen != sizeof(ro->recv_own_msgs))
695+ if (optlen != sizeof(flag))
695696 return -EINVAL;
696697
697− if (copy_from_sockptr(&ro->recv_own_msgs, optval, optlen))
698+ if (copy_from_sockptr(&flag, optval, optlen))
698699 return -EFAULT;
699700
701+ ro->recv_own_msgs = !!flag;
700702 break;
701703
702704 case CAN_RAW_FD_FRAMES:
703− if (optlen != sizeof(fd_frames))
705+ if (optlen != sizeof(flag))
704706 return -EINVAL;
705707
706− if (copy_from_sockptr(&fd_frames, optval, optlen))
708+ if (copy_from_sockptr(&flag, optval, optlen))
707709 return -EFAULT;
708710
709711 /* Enabling CAN XL includes CAN FD */
710− if (ro->xl_frames && !fd_frames)
712+ if (ro->xl_frames && !flag)
711713 return -EINVAL;
712714
713− ro->fd_frames = fd_frames;
715+ ro->fd_frames = !!flag;
714716 break;
715717
716718 case CAN_RAW_XL_FRAMES:
717− if (optlen != sizeof(ro->xl_frames))
719+ if (optlen != sizeof(flag))
718720 return -EINVAL;
719721
720− if (copy_from_sockptr(&ro->xl_frames, optval, optlen))
722+ if (copy_from_sockptr(&flag, optval, optlen))
721723 return -EFAULT;
722724
725+ ro->xl_frames = !!flag;
726+
723727 /* Enabling CAN XL includes CAN FD */
724728 if (ro->xl_frames)
725729 ro->fd_frames = ro->xl_frames;
@@ -739,12 +743,13 @@ static int raw_setsockopt(struct socket *sock, int level, int optname, · 13 unmodified lines
739743 break;
740744
741745 case CAN_RAW_JOIN_FILTERS:
742− if (optlen != sizeof(ro->join_filters))
746+ if (optlen != sizeof(flag))
743747 return -EINVAL;
744748
745− if (copy_from_sockptr(&ro->join_filters, optval, optlen))
749+ if (copy_from_sockptr(&flag, optval, optlen))
746750 return -EFAULT;
747751
752+ ro->join_filters = !!flag;
748753 break;
749754
750755 default:
@@ -758,6 +763,7 @@ static int raw_getsockopt(struct socket *sock, int level, int optname, · 7 unmodified lines
758763 {
759764 struct sock *sk = sock->sk;
760765 struct raw_sock *ro = raw_sk(sk);
766+ int flag;
761767 int len;
762768 void *val;
763769
@@ -806,25 +812,29 @@ static int raw_getsockopt(struct socket *sock, int level, int optname, · 42 unmodified lines
806812 case CAN_RAW_LOOPBACK:
807813 if (len > sizeof(int))
808814 len = sizeof(int);
809− val = &ro->loopback;
815+ flag = ro->loopback;
816+ val = &flag;
810817 break;
811818
812819 case CAN_RAW_RECV_OWN_MSGS:
813820 if (len > sizeof(int))
814821 len = sizeof(int);
815− val = &ro->recv_own_msgs;
822+ flag = ro->recv_own_msgs;
823+ val = &flag;
816824 break;
817825
818826 case CAN_RAW_FD_FRAMES:
819827 if (len > sizeof(int))
820828 len = sizeof(int);
821− val = &ro->fd_frames;
829+ flag = ro->fd_frames;
830+ val = &flag;
822831 break;
823832
824833 case CAN_RAW_XL_FRAMES:
825834 if (len > sizeof(int))
826835 len = sizeof(int);
827− val = &ro->xl_frames;
836+ flag = ro->xl_frames;
837+ val = &flag;
828838 break;
829839
830840 case CAN_RAW_XL_VCID_OPTS: {
@@ -849,7 +859,8 @@ static int raw_getsockopt(struct socket *sock, int level, int optname, · 18 unmodified lines
849859 case CAN_RAW_JOIN_FILTERS:
850860 if (len > sizeof(int))
851861 len = sizeof(int);
852− val = &ro->join_filters;
862+ flag = ro->join_filters;
863+ val = &flag;
853864 break;
854865
855866 default:
@@ -950,7 +961,7 @@ static int raw_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) · 94 unmodified lines
950961 err = -EINVAL;
951962
952963 /* check for valid CAN (CC/FD/XL) frame content */
953− txmtu = raw_check_txframe(ro, skb, dev->mtu);
964+ txmtu = raw_check_txframe(ro, skb, READ_ONCE(dev->mtu));
954965 if (!txmtu)
955966 goto free_skb;
956967

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t