Merge tag 'linux-can-next-for-6.16-20250522' of git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can-next

+128 -43

Documentation/devicetree/bindings/net/can/renesas,rcar-canfd.yaml

··· 42 42 - renesas,r9a07g054-canfd # RZ/V2L 43 43 - const: renesas,rzg2l-canfd # RZ/G2L family 44 44 45 + - const: renesas,r9a09g047-canfd # RZ/G3E 46 + 45 47 reg: 46 48 maxItems: 1 47 49 48 - interrupts: true 50 + interrupts: 51 + oneOf: 52 + - items: 53 + - description: Channel interrupt 54 + - description: Global interrupt 55 + - items: 56 + - description: CAN global error interrupt 57 + - description: CAN receive FIFO interrupt 58 + - description: CAN0 error interrupt 59 + - description: CAN0 transmit interrupt 60 + - description: CAN0 transmit/receive FIFO receive completion interrupt 61 + - description: CAN1 error interrupt 62 + - description: CAN1 transmit interrupt 63 + - description: CAN1 transmit/receive FIFO receive completion interrupt 64 + - description: CAN2 error interrupt 65 + - description: CAN2 transmit interrupt 66 + - description: CAN2 transmit/receive FIFO receive completion interrupt 67 + - description: CAN3 error interrupt 68 + - description: CAN3 transmit interrupt 69 + - description: CAN3 transmit/receive FIFO receive completion interrupt 70 + - description: CAN4 error interrupt 71 + - description: CAN4 transmit interrupt 72 + - description: CAN4 transmit/receive FIFO receive completion interrupt 73 + - description: CAN5 error interrupt 74 + - description: CAN5 transmit interrupt 75 + - description: CAN5 transmit/receive FIFO receive completion interrupt 76 + minItems: 8 77 + 78 + interrupt-names: 79 + oneOf: 80 + - items: 81 + - const: ch_int 82 + - const: g_int 83 + - items: 84 + - const: g_err 85 + - const: g_recc 86 + - const: ch0_err 87 + - const: ch0_rec 88 + - const: ch0_trx 89 + - const: ch1_err 90 + - const: ch1_rec 91 + - const: ch1_trx 92 + - const: ch2_err 93 + - const: ch2_rec 94 + - const: ch2_trx 95 + - const: ch3_err 96 + - const: ch3_rec 97 + - const: ch3_trx 98 + - const: ch4_err 99 + - const: ch4_rec 100 + - const: ch4_trx 101 + - const: ch5_err 102 + - const: ch5_rec 103 + - const: ch5_trx 104 + minItems: 8 49 105 50 106 clocks: 51 107 maxItems: 3 52 108 53 109 clock-names: 54 - items: 55 - - const: fck 56 - - const: canfd 57 - - const: can_clk 110 + oneOf: 111 + - items: 112 + - const: fck 113 + - const: canfd 114 + - const: can_clk 115 + - items: 116 + - const: fck 117 + - const: ram_clk 118 + - const: can_clk 58 119 59 120 power-domains: 60 121 maxItems: 1 ··· 178 117 then: 179 118 properties: 180 119 interrupts: 181 - items: 182 - - description: CAN global error interrupt 183 - - description: CAN receive FIFO interrupt 184 - - description: CAN0 error interrupt 185 - - description: CAN0 transmit interrupt 186 - - description: CAN0 transmit/receive FIFO receive completion interrupt 187 - - description: CAN1 error interrupt 188 - - description: CAN1 transmit interrupt 189 - - description: CAN1 transmit/receive FIFO receive completion interrupt 120 + maxItems: 8 190 121 191 122 interrupt-names: 192 - items: 193 - - const: g_err 194 - - const: g_recc 195 - - const: ch0_err 196 - - const: ch0_rec 197 - - const: ch0_trx 198 - - const: ch1_err 199 - - const: ch1_rec 200 - - const: ch1_trx 123 + maxItems: 8 201 124 202 125 resets: 126 + minItems: 2 203 127 maxItems: 2 204 128 205 129 reset-names: 206 - items: 207 - - const: rstp_n 208 - - const: rstc_n 130 + minItems: 2 131 + maxItems: 2 209 132 210 133 required: 211 134 - reset-names 212 - else: 135 + 136 + - if: 137 + properties: 138 + compatible: 139 + contains: 140 + enum: 141 + - renesas,rcar-gen3-canfd 142 + - renesas,rcar-gen4-canfd 143 + then: 213 144 properties: 214 145 interrupts: 215 - items: 216 - - description: Channel interrupt 217 - - description: Global interrupt 146 + minItems: 2 147 + maxItems: 2 218 148 219 149 interrupt-names: 220 - items: 221 - - const: ch_int 222 - - const: g_int 150 + minItems: 2 151 + maxItems: 2 223 152 224 153 resets: 225 154 maxItems: 1 155 + 156 + - if: 157 + properties: 158 + compatible: 159 + contains: 160 + const: renesas,r9a09g047-canfd 161 + then: 162 + properties: 163 + interrupts: 164 + minItems: 20 165 + 166 + interrupt-names: 167 + minItems: 20 168 + 169 + resets: 170 + minItems: 2 171 + maxItems: 2 172 + 173 + reset-names: 174 + minItems: 2 175 + maxItems: 2 176 + 177 + required: 178 + - reset-names 179 + 180 + - if: 181 + properties: 182 + compatible: 183 + contains: 184 + enum: 185 + - renesas,rcar-gen3-canfd 186 + - renesas,rzg2l-canfd 187 + then: 188 + patternProperties: 189 + "^channel[2-7]$": false 226 190 227 191 - if: 228 192 properties: ··· 257 171 then: 258 172 patternProperties: 259 173 "^channel[4-7]$": false 260 - else: 261 - if: 262 - not: 263 - properties: 264 - compatible: 265 - contains: 266 - const: renesas,rcar-gen4-canfd 267 - then: 268 - patternProperties: 269 - "^channel[2-7]$": false 174 + 175 + - if: 176 + properties: 177 + compatible: 178 + contains: 179 + const: renesas,r9a09g047-canfd 180 + then: 181 + patternProperties: 182 + "^channel[6-7]$": false 270 183 271 184 unevaluatedProperties: false 272 185

+2

MAINTAINERS

··· 5274 5274 F: include/uapi/linux/can/raw.h 5275 5275 F: net/can/ 5276 5276 F: net/sched/em_canid.c 5277 + F: tools/testing/selftests/net/can/ 5277 5278 5278 5279 CAN-J1939 NETWORK LAYER 5279 5280 M: Robin van der Gracht <robin@protonic.nl> ··· 17077 17076 X: net/mac80211/ 17078 17077 X: net/rfkill/ 17079 17078 X: net/wireless/ 17079 + X: tools/testing/selftests/net/can/ 17080 17080 17081 17081 NETWORKING [IPSEC] 17082 17082 M: Steffen Klassert <steffen.klassert@secunet.com>

+4 -4

drivers/net/can/ctucanfd/ctucanfd_base.c

··· 275 275 static int ctucan_set_data_bittiming(struct net_device *ndev) 276 276 { 277 277 struct ctucan_priv *priv = netdev_priv(ndev); 278 - struct can_bittiming *dbt = &priv->can.data_bittiming; 278 + struct can_bittiming *dbt = &priv->can.fd.data_bittiming; 279 279 280 280 /* Note that dbt may be modified here */ 281 281 return ctucan_set_btr(ndev, dbt, false); ··· 290 290 static int ctucan_set_secondary_sample_point(struct net_device *ndev) 291 291 { 292 292 struct ctucan_priv *priv = netdev_priv(ndev); 293 - struct can_bittiming *dbt = &priv->can.data_bittiming; 293 + struct can_bittiming *dbt = &priv->can.fd.data_bittiming; 294 294 int ssp_offset = 0; 295 295 u32 ssp_cfg = 0; /* No SSP by default */ 296 296 ··· 1358 1358 priv->ntxbufs = ntxbufs; 1359 1359 priv->dev = dev; 1360 1360 priv->can.bittiming_const = &ctu_can_fd_bit_timing_max; 1361 - priv->can.data_bittiming_const = &ctu_can_fd_bit_timing_data_max; 1361 + priv->can.fd.data_bittiming_const = &ctu_can_fd_bit_timing_data_max; 1362 1362 priv->can.do_set_mode = ctucan_do_set_mode; 1363 1363 1364 1364 /* Needed for timing adjustment to be performed as soon as possible */ 1365 1365 priv->can.do_set_bittiming = ctucan_set_bittiming; 1366 - priv->can.do_set_data_bittiming = ctucan_set_data_bittiming; 1366 + priv->can.fd.do_set_data_bittiming = ctucan_set_data_bittiming; 1367 1367 1368 1368 priv->can.do_get_berr_counter = ctucan_get_berr_counter; 1369 1369 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK

+6 -6

drivers/net/can/dev/dev.c

··· 404 404 405 405 /* For CAN FD the data bitrate has to be >= the arbitration bitrate */ 406 406 if ((priv->ctrlmode & CAN_CTRLMODE_FD) && 407 - (!priv->data_bittiming.bitrate || 408 - priv->data_bittiming.bitrate < priv->bittiming.bitrate)) { 407 + (!priv->fd.data_bittiming.bitrate || 408 + priv->fd.data_bittiming.bitrate < priv->bittiming.bitrate)) { 409 409 netdev_err(dev, "incorrect/missing data bit-timing\n"); 410 410 return -EINVAL; 411 411 } ··· 543 543 if (!priv->bitrate_const != !priv->bitrate_const_cnt) 544 544 return -EINVAL; 545 545 546 - if (!priv->data_bitrate_const != !priv->data_bitrate_const_cnt) 546 + if (!priv->fd.data_bitrate_const != !priv->fd.data_bitrate_const_cnt) 547 547 return -EINVAL; 548 548 549 549 /* We only support either fixed bit rates or bit timing const. */ 550 - if ((priv->bitrate_const || priv->data_bitrate_const) && 551 - (priv->bittiming_const || priv->data_bittiming_const)) 550 + if ((priv->bitrate_const || priv->fd.data_bitrate_const) && 551 + (priv->bittiming_const || priv->fd.data_bittiming_const)) 552 552 return -EINVAL; 553 553 554 554 if (!can_bittiming_const_valid(priv->bittiming_const) || 555 - !can_bittiming_const_valid(priv->data_bittiming_const)) 555 + !can_bittiming_const_valid(priv->fd.data_bittiming_const)) 556 556 return -EINVAL; 557 557 558 558 if (!priv->termination_const) {

+37 -37

drivers/net/can/dev/netlink.c

··· 141 141 { 142 142 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1]; 143 143 struct can_tdc tdc = { 0 }; 144 - const struct can_tdc_const *tdc_const = priv->tdc_const; 144 + const struct can_tdc_const *tdc_const = priv->fd.tdc_const; 145 145 int err; 146 146 147 147 if (!tdc_const || !can_tdc_is_enabled(priv)) ··· 179 179 tdc.tdcf = tdcf; 180 180 } 181 181 182 - priv->tdc = tdc; 182 + priv->fd.tdc = tdc; 183 183 184 184 return 0; 185 185 } ··· 228 228 dev->mtu = CANFD_MTU; 229 229 } else { 230 230 dev->mtu = CAN_MTU; 231 - memset(&priv->data_bittiming, 0, 232 - sizeof(priv->data_bittiming)); 231 + memset(&priv->fd.data_bittiming, 0, 232 + sizeof(priv->fd.data_bittiming)); 233 233 priv->ctrlmode &= ~CAN_CTRLMODE_TDC_MASK; 234 - memset(&priv->tdc, 0, sizeof(priv->tdc)); 234 + memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc)); 235 235 } 236 236 237 237 tdc_mask = cm->mask & CAN_CTRLMODE_TDC_MASK; ··· 312 312 * directly via do_set_bitrate(). Bail out if neither 313 313 * is given. 314 314 */ 315 - if (!priv->data_bittiming_const && !priv->do_set_data_bittiming && 316 - !priv->data_bitrate_const) 315 + if (!priv->fd.data_bittiming_const && !priv->fd.do_set_data_bittiming && 316 + !priv->fd.data_bitrate_const) 317 317 return -EOPNOTSUPP; 318 318 319 319 memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]), 320 320 sizeof(dbt)); 321 321 err = can_get_bittiming(dev, &dbt, 322 - priv->data_bittiming_const, 323 - priv->data_bitrate_const, 324 - priv->data_bitrate_const_cnt, 322 + priv->fd.data_bittiming_const, 323 + priv->fd.data_bitrate_const, 324 + priv->fd.data_bitrate_const_cnt, 325 325 extack); 326 326 if (err) 327 327 return err; ··· 333 333 return -EINVAL; 334 334 } 335 335 336 - memset(&priv->tdc, 0, sizeof(priv->tdc)); 336 + memset(&priv->fd.tdc, 0, sizeof(priv->fd.tdc)); 337 337 if (data[IFLA_CAN_TDC]) { 338 338 /* TDC parameters are provided: use them */ 339 339 err = can_tdc_changelink(priv, data[IFLA_CAN_TDC], ··· 346 346 /* Neither of TDC parameters nor TDC flags are 347 347 * provided: do calculation 348 348 */ 349 - can_calc_tdco(&priv->tdc, priv->tdc_const, &dbt, 349 + can_calc_tdco(&priv->fd.tdc, priv->fd.tdc_const, &dbt, 350 350 &priv->ctrlmode, priv->ctrlmode_supported); 351 351 } /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly 352 352 * turned off. TDC is disabled: do nothing 353 353 */ 354 354 355 - memcpy(&priv->data_bittiming, &dbt, sizeof(dbt)); 355 + memcpy(&priv->fd.data_bittiming, &dbt, sizeof(dbt)); 356 356 357 - if (priv->do_set_data_bittiming) { 357 + if (priv->fd.do_set_data_bittiming) { 358 358 /* Finally, set the bit-timing registers */ 359 - err = priv->do_set_data_bittiming(dev); 359 + err = priv->fd.do_set_data_bittiming(dev); 360 360 if (err) 361 361 return err; 362 362 } ··· 394 394 struct can_priv *priv = netdev_priv(dev); 395 395 size_t size; 396 396 397 - if (!priv->tdc_const) 397 + if (!priv->fd.tdc_const) 398 398 return 0; 399 399 400 400 size = nla_total_size(0); /* nest IFLA_CAN_TDC */ ··· 404 404 } 405 405 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MIN */ 406 406 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MAX */ 407 - if (priv->tdc_const->tdcf_max) { 407 + if (priv->fd.tdc_const->tdcf_max) { 408 408 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MIN */ 409 409 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MAX */ 410 410 } 411 411 412 412 if (can_tdc_is_enabled(priv)) { 413 413 if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL || 414 - priv->do_get_auto_tdcv) 414 + priv->fd.do_get_auto_tdcv) 415 415 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV */ 416 416 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO */ 417 - if (priv->tdc_const->tdcf_max) 417 + if (priv->fd.tdc_const->tdcf_max) 418 418 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF */ 419 419 } 420 420 ··· 442 442 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */ 443 443 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */ 444 444 size += nla_total_size(sizeof(struct can_berr_counter)); 445 - if (priv->data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */ 445 + if (priv->fd.data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */ 446 446 size += nla_total_size(sizeof(struct can_bittiming)); 447 - if (priv->data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */ 447 + if (priv->fd.data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */ 448 448 size += nla_total_size(sizeof(struct can_bittiming_const)); 449 449 if (priv->termination_const) { 450 450 size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */ ··· 454 454 if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */ 455 455 size += nla_total_size(sizeof(*priv->bitrate_const) * 456 456 priv->bitrate_const_cnt); 457 - if (priv->data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */ 458 - size += nla_total_size(sizeof(*priv->data_bitrate_const) * 459 - priv->data_bitrate_const_cnt); 457 + if (priv->fd.data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */ 458 + size += nla_total_size(sizeof(*priv->fd.data_bitrate_const) * 459 + priv->fd.data_bitrate_const_cnt); 460 460 size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */ 461 461 size += can_tdc_get_size(dev); /* IFLA_CAN_TDC */ 462 462 size += can_ctrlmode_ext_get_size(); /* IFLA_CAN_CTRLMODE_EXT */ ··· 468 468 { 469 469 struct nlattr *nest; 470 470 struct can_priv *priv = netdev_priv(dev); 471 - struct can_tdc *tdc = &priv->tdc; 472 - const struct can_tdc_const *tdc_const = priv->tdc_const; 471 + struct can_tdc *tdc = &priv->fd.tdc; 472 + const struct can_tdc_const *tdc_const = priv->fd.tdc_const; 473 473 474 474 if (!tdc_const) 475 475 return 0; ··· 497 497 if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL) { 498 498 tdcv = tdc->tdcv; 499 499 err = 0; 500 - } else if (priv->do_get_auto_tdcv) { 501 - err = priv->do_get_auto_tdcv(dev, &tdcv); 500 + } else if (priv->fd.do_get_auto_tdcv) { 501 + err = priv->fd.do_get_auto_tdcv(dev, &tdcv); 502 502 } 503 503 if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv)) 504 504 goto err_cancel; ··· 564 564 !priv->do_get_berr_counter(dev, &bec) && 565 565 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) || 566 566 567 - (priv->data_bittiming.bitrate && 567 + (priv->fd.data_bittiming.bitrate && 568 568 nla_put(skb, IFLA_CAN_DATA_BITTIMING, 569 - sizeof(priv->data_bittiming), &priv->data_bittiming)) || 569 + sizeof(priv->fd.data_bittiming), &priv->fd.data_bittiming)) || 570 570 571 - (priv->data_bittiming_const && 571 + (priv->fd.data_bittiming_const && 572 572 nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST, 573 - sizeof(*priv->data_bittiming_const), 574 - priv->data_bittiming_const)) || 573 + sizeof(*priv->fd.data_bittiming_const), 574 + priv->fd.data_bittiming_const)) || 575 575 576 576 (priv->termination_const && 577 577 (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) || ··· 586 586 priv->bitrate_const_cnt, 587 587 priv->bitrate_const)) || 588 588 589 - (priv->data_bitrate_const && 589 + (priv->fd.data_bitrate_const && 590 590 nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST, 591 - sizeof(*priv->data_bitrate_const) * 592 - priv->data_bitrate_const_cnt, 593 - priv->data_bitrate_const)) || 591 + sizeof(*priv->fd.data_bitrate_const) * 592 + priv->fd.data_bitrate_const_cnt, 593 + priv->fd.data_bitrate_const)) || 594 594 595 595 (nla_put(skb, IFLA_CAN_BITRATE_MAX, 596 596 sizeof(priv->bitrate_max),

+2 -2

drivers/net/can/flexcan/flexcan-core.c

··· 1226 1226 { 1227 1227 struct flexcan_priv *priv = netdev_priv(dev); 1228 1228 struct can_bittiming *bt = &priv->can.bittiming; 1229 - struct can_bittiming *dbt = &priv->can.data_bittiming; 1229 + struct can_bittiming *dbt = &priv->can.fd.data_bittiming; 1230 1230 struct flexcan_regs __iomem *regs = priv->regs; 1231 1231 u32 reg_cbt, reg_fdctrl; 1232 1232 ··· 2239 2239 priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD | 2240 2240 CAN_CTRLMODE_FD_NON_ISO; 2241 2241 priv->can.bittiming_const = &flexcan_fd_bittiming_const; 2242 - priv->can.data_bittiming_const = 2242 + priv->can.fd.data_bittiming_const = 2243 2243 &flexcan_fd_data_bittiming_const; 2244 2244 } else { 2245 2245 priv->can.bittiming_const = &flexcan_bittiming_const;

+5 -5

drivers/net/can/ifi_canfd/ifi_canfd.c

··· 669 669 { 670 670 struct ifi_canfd_priv *priv = netdev_priv(ndev); 671 671 const struct can_bittiming *bt = &priv->can.bittiming; 672 - const struct can_bittiming *dbt = &priv->can.data_bittiming; 672 + const struct can_bittiming *dbt = &priv->can.fd.data_bittiming; 673 673 u16 brp, sjw, tseg1, tseg2, tdc; 674 674 675 675 /* Configure bit timing */ ··· 1000 1000 1001 1001 priv->can.clock.freq = readl(addr + IFI_CANFD_CANCLOCK); 1002 1002 1003 - priv->can.bittiming_const = &ifi_canfd_bittiming_const; 1004 - priv->can.data_bittiming_const = &ifi_canfd_bittiming_const; 1005 - priv->can.do_set_mode = ifi_canfd_set_mode; 1006 - priv->can.do_get_berr_counter = ifi_canfd_get_berr_counter; 1003 + priv->can.bittiming_const = &ifi_canfd_bittiming_const; 1004 + priv->can.fd.data_bittiming_const = &ifi_canfd_bittiming_const; 1005 + priv->can.do_set_mode = ifi_canfd_set_mode; 1006 + priv->can.do_get_berr_counter = ifi_canfd_get_berr_counter; 1007 1007 1008 1008 /* IFI CANFD can do both Bosch FD and ISO FD */ 1009 1009 priv->can.ctrlmode = CAN_CTRLMODE_FD;

+3 -3

drivers/net/can/kvaser_pciefd.c

··· 863 863 struct can_bittiming *bt; 864 864 865 865 if (data) 866 - bt = &can->can.data_bittiming; 866 + bt = &can->can.fd.data_bittiming; 867 867 else 868 868 bt = &can->can.bittiming; 869 869 ··· 999 999 spin_lock_init(&can->lock); 1000 1000 1001 1001 can->can.bittiming_const = &kvaser_pciefd_bittiming_const; 1002 - can->can.data_bittiming_const = &kvaser_pciefd_bittiming_const; 1002 + can->can.fd.data_bittiming_const = &kvaser_pciefd_bittiming_const; 1003 1003 can->can.do_set_bittiming = kvaser_pciefd_set_nominal_bittiming; 1004 - can->can.do_set_data_bittiming = kvaser_pciefd_set_data_bittiming; 1004 + can->can.fd.do_set_data_bittiming = kvaser_pciefd_set_data_bittiming; 1005 1005 can->can.do_set_mode = kvaser_pciefd_set_mode; 1006 1006 can->can.do_get_berr_counter = kvaser_pciefd_get_berr_counter; 1007 1007 can->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY |

+4 -4

drivers/net/can/m_can/m_can.c

··· 1372 1372 { 1373 1373 struct m_can_classdev *cdev = netdev_priv(dev); 1374 1374 const struct can_bittiming *bt = &cdev->can.bittiming; 1375 - const struct can_bittiming *dbt = &cdev->can.data_bittiming; 1375 + const struct can_bittiming *dbt = &cdev->can.fd.data_bittiming; 1376 1376 u16 brp, sjw, tseg1, tseg2; 1377 1377 u32 reg_btp; 1378 1378 ··· 1738 1738 if (err) 1739 1739 return err; 1740 1740 cdev->can.bittiming_const = &m_can_bittiming_const_30X; 1741 - cdev->can.data_bittiming_const = &m_can_data_bittiming_const_30X; 1741 + cdev->can.fd.data_bittiming_const = &m_can_data_bittiming_const_30X; 1742 1742 break; 1743 1743 case 31: 1744 1744 /* CAN_CTRLMODE_FD_NON_ISO is fixed with M_CAN IP v3.1.x */ ··· 1746 1746 if (err) 1747 1747 return err; 1748 1748 cdev->can.bittiming_const = &m_can_bittiming_const_31X; 1749 - cdev->can.data_bittiming_const = &m_can_data_bittiming_const_31X; 1749 + cdev->can.fd.data_bittiming_const = &m_can_data_bittiming_const_31X; 1750 1750 break; 1751 1751 case 32: 1752 1752 case 33: 1753 1753 /* Support both MCAN version v3.2.x and v3.3.0 */ 1754 1754 cdev->can.bittiming_const = &m_can_bittiming_const_31X; 1755 - cdev->can.data_bittiming_const = &m_can_data_bittiming_const_31X; 1755 + cdev->can.fd.data_bittiming_const = &m_can_data_bittiming_const_31X; 1756 1756 1757 1757 niso = m_can_niso_supported(cdev); 1758 1758 if (niso < 0)

+3 -3

drivers/net/can/peak_canfd/peak_canfd.c

··· 624 624 { 625 625 struct peak_canfd_priv *priv = netdev_priv(ndev); 626 626 627 - return pucan_set_timing_fast(priv, &priv->can.data_bittiming); 627 + return pucan_set_timing_fast(priv, &priv->can.fd.data_bittiming); 628 628 } 629 629 630 630 static int peak_canfd_close(struct net_device *ndev) ··· 813 813 /* complete now socket-can initialization side */ 814 814 priv->can.state = CAN_STATE_STOPPED; 815 815 priv->can.bittiming_const = &peak_canfd_nominal_const; 816 - priv->can.data_bittiming_const = &peak_canfd_data_const; 816 + priv->can.fd.data_bittiming_const = &peak_canfd_data_const; 817 817 818 818 priv->can.do_set_mode = peak_canfd_set_mode; 819 819 priv->can.do_get_berr_counter = peak_canfd_get_berr_counter; 820 820 priv->can.do_set_bittiming = peak_canfd_set_bittiming; 821 - priv->can.do_set_data_bittiming = peak_canfd_set_data_bittiming; 821 + priv->can.fd.do_set_data_bittiming = peak_canfd_set_data_bittiming; 822 822 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | 823 823 CAN_CTRLMODE_LISTENONLY | 824 824 CAN_CTRLMODE_3_SAMPLES |

+213 -67

drivers/net/can/rcar/rcar_canfd.c

··· 21 21 * wherever it is modified to a readable name. 22 22 */ 23 23 24 + #include <linux/bitfield.h> 24 25 #include <linux/bitmap.h> 25 26 #include <linux/bitops.h> 26 27 #include <linux/can/dev.h> ··· 75 74 #define RCANFD_GSTS_GNOPM (BIT(0) | BIT(1) | BIT(2) | BIT(3)) 76 75 77 76 /* RSCFDnCFDGERFL / RSCFDnGERFL */ 78 - #define RCANFD_GERFL_EEF0_7 GENMASK(23, 16) 79 - #define RCANFD_GERFL_EEF(ch) BIT(16 + (ch)) 77 + #define RCANFD_GERFL_EEF GENMASK(23, 16) 80 78 #define RCANFD_GERFL_CMPOF BIT(3) /* CAN FD only */ 81 79 #define RCANFD_GERFL_THLES BIT(2) 82 80 #define RCANFD_GERFL_MES BIT(1) 83 81 #define RCANFD_GERFL_DEF BIT(0) 84 82 85 83 #define RCANFD_GERFL_ERR(gpriv, x) \ 86 - ((x) & (reg_gen4(gpriv, RCANFD_GERFL_EEF0_7, \ 87 - RCANFD_GERFL_EEF(0) | RCANFD_GERFL_EEF(1)) | \ 88 - RCANFD_GERFL_MES | \ 89 - ((gpriv)->fdmode ? RCANFD_GERFL_CMPOF : 0))) 84 + ({\ 85 + typeof(gpriv) (_gpriv) = (gpriv); \ 86 + ((x) & ((FIELD_PREP(RCANFD_GERFL_EEF, (_gpriv)->channels_mask)) | \ 87 + RCANFD_GERFL_MES | ((_gpriv)->fdmode ? RCANFD_GERFL_CMPOF : 0))); \ 88 + }) 90 89 91 90 /* AFL Rx rules registers */ 92 91 93 - /* RSCFDnCFDGAFLCFG0 / RSCFDnGAFLCFG0 */ 94 - #define RCANFD_GAFLCFG_SETRNC(gpriv, n, x) \ 95 - (((x) & reg_gen4(gpriv, 0x1ff, 0xff)) << \ 96 - (reg_gen4(gpriv, 16, 24) - ((n) & 1) * reg_gen4(gpriv, 16, 8))) 97 - 98 - #define RCANFD_GAFLCFG_GETRNC(gpriv, n, x) \ 99 - (((x) >> (reg_gen4(gpriv, 16, 24) - ((n) & 1) * reg_gen4(gpriv, 16, 8))) & \ 100 - reg_gen4(gpriv, 0x1ff, 0xff)) 101 - 102 92 /* RSCFDnCFDGAFLECTR / RSCFDnGAFLECTR */ 103 93 #define RCANFD_GAFLECTR_AFLDAE BIT(8) 104 - #define RCANFD_GAFLECTR_AFLPN(gpriv, x) ((x) & reg_gen4(gpriv, 0x7f, 0x1f)) 94 + #define RCANFD_GAFLECTR_AFLPN(gpriv, page_num) ((page_num) & (gpriv)->info->max_aflpn) 105 95 106 96 /* RSCFDnCFDGAFLIDj / RSCFDnGAFLIDj */ 107 97 #define RCANFD_GAFLID_GAFLLB BIT(29) ··· 110 118 111 119 /* RSCFDnCFDCmNCFG - CAN FD only */ 112 120 #define RCANFD_NCFG_NTSEG2(gpriv, x) \ 113 - (((x) & reg_gen4(gpriv, 0x7f, 0x1f)) << reg_gen4(gpriv, 25, 24)) 121 + (((x) & ((gpriv)->info->nom_bittiming->tseg2_max - 1)) << (gpriv)->info->sh->ntseg2) 114 122 115 123 #define RCANFD_NCFG_NTSEG1(gpriv, x) \ 116 - (((x) & reg_gen4(gpriv, 0xff, 0x7f)) << reg_gen4(gpriv, 17, 16)) 124 + (((x) & ((gpriv)->info->nom_bittiming->tseg1_max - 1)) << (gpriv)->info->sh->ntseg1) 117 125 118 126 #define RCANFD_NCFG_NSJW(gpriv, x) \ 119 - (((x) & reg_gen4(gpriv, 0x7f, 0x1f)) << reg_gen4(gpriv, 10, 11)) 127 + (((x) & ((gpriv)->info->nom_bittiming->sjw_max - 1)) << (gpriv)->info->sh->nsjw) 120 128 121 129 #define RCANFD_NCFG_NBRP(x) (((x) & 0x3ff) << 0) 122 130 ··· 178 186 #define RCANFD_CERFL_ERR(x) ((x) & (0x7fff)) /* above bits 14:0 */ 179 187 180 188 /* RSCFDnCFDCmDCFG */ 181 - #define RCANFD_DCFG_DSJW(gpriv, x) (((x) & reg_gen4(gpriv, 0xf, 0x7)) << 24) 189 + #define RCANFD_DCFG_DSJW(gpriv, x) (((x) & ((gpriv)->info->data_bittiming->sjw_max - 1)) << 24) 182 190 183 191 #define RCANFD_DCFG_DTSEG2(gpriv, x) \ 184 - (((x) & reg_gen4(gpriv, 0x0f, 0x7)) << reg_gen4(gpriv, 16, 20)) 192 + (((x) & ((gpriv)->info->data_bittiming->tseg2_max - 1)) << (gpriv)->info->sh->dtseg2) 185 193 186 194 #define RCANFD_DCFG_DTSEG1(gpriv, x) \ 187 - (((x) & reg_gen4(gpriv, 0x1f, 0xf)) << reg_gen4(gpriv, 8, 16)) 195 + (((x) & ((gpriv)->info->data_bittiming->tseg1_max - 1)) << (gpriv)->info->sh->dtseg1) 188 196 189 197 #define RCANFD_DCFG_DBRP(x) (((x) & 0xff) << 0) 190 198 ··· 225 233 /* Common FIFO bits */ 226 234 227 235 /* RSCFDnCFDCFCCk */ 228 - #define RCANFD_CFCC_CFTML(gpriv, x) \ 229 - (((x) & reg_gen4(gpriv, 0x1f, 0xf)) << reg_gen4(gpriv, 16, 20)) 230 - #define RCANFD_CFCC_CFM(gpriv, x) (((x) & 0x3) << reg_gen4(gpriv, 8, 16)) 236 + #define RCANFD_CFCC_CFTML(gpriv, cftml) \ 237 + ({\ 238 + typeof(gpriv) (_gpriv) = (gpriv); \ 239 + (((cftml) & (_gpriv)->info->max_cftml) << (_gpriv)->info->sh->cftml); \ 240 + }) 241 + #define RCANFD_CFCC_CFM(gpriv, x) (((x) & 0x3) << (gpriv)->info->sh->cfm) 231 242 #define RCANFD_CFCC_CFIM BIT(12) 232 - #define RCANFD_CFCC_CFDC(gpriv, x) (((x) & 0x7) << reg_gen4(gpriv, 21, 8)) 243 + #define RCANFD_CFCC_CFDC(gpriv, x) (((x) & 0x7) << (gpriv)->info->sh->cfdc) 233 244 #define RCANFD_CFCC_CFPLS(x) (((x) & 0x7) << 4) 234 245 #define RCANFD_CFCC_CFTXIE BIT(2) 235 246 #define RCANFD_CFCC_CFE BIT(0) ··· 293 298 /* RSCFDnCFDGAFLECTR / RSCFDnGAFLECTR */ 294 299 #define RCANFD_GAFLECTR (0x0098) 295 300 /* RSCFDnCFDGAFLCFG / RSCFDnGAFLCFG */ 296 - #define RCANFD_GAFLCFG(ch) (0x009c + (0x04 * ((ch) / 2))) 301 + #define RCANFD_GAFLCFG(w) (0x009c + (0x04 * (w))) 297 302 /* RSCFDnCFDRMNB / RSCFDnRMNB */ 298 303 #define RCANFD_RMNB (0x00a4) 299 304 /* RSCFDnCFDRMND / RSCFDnRMND */ 300 305 #define RCANFD_RMND(y) (0x00a8 + (0x04 * (y))) 301 306 302 307 /* RSCFDnCFDRFCCx / RSCFDnRFCCx */ 303 - #define RCANFD_RFCC(gpriv, x) (reg_gen4(gpriv, 0x00c0, 0x00b8) + (0x04 * (x))) 308 + #define RCANFD_RFCC(gpriv, x) ((gpriv)->info->regs->rfcc + (0x04 * (x))) 304 309 /* RSCFDnCFDRFSTSx / RSCFDnRFSTSx */ 305 310 #define RCANFD_RFSTS(gpriv, x) (RCANFD_RFCC(gpriv, x) + 0x20) 306 311 /* RSCFDnCFDRFPCTRx / RSCFDnRFPCTRx */ ··· 310 315 311 316 /* RSCFDnCFDCFCCx / RSCFDnCFCCx */ 312 317 #define RCANFD_CFCC(gpriv, ch, idx) \ 313 - (reg_gen4(gpriv, 0x0120, 0x0118) + (0x0c * (ch)) + (0x04 * (idx))) 318 + ((gpriv)->info->regs->cfcc + (0x0c * (ch)) + (0x04 * (idx))) 314 319 /* RSCFDnCFDCFSTSx / RSCFDnCFSTSx */ 315 320 #define RCANFD_CFSTS(gpriv, ch, idx) \ 316 - (reg_gen4(gpriv, 0x01e0, 0x0178) + (0x0c * (ch)) + (0x04 * (idx))) 321 + ((gpriv)->info->regs->cfsts + (0x0c * (ch)) + (0x04 * (idx))) 317 322 /* RSCFDnCFDCFPCTRx / RSCFDnCFPCTRx */ 318 323 #define RCANFD_CFPCTR(gpriv, ch, idx) \ 319 - (reg_gen4(gpriv, 0x0240, 0x01d8) + (0x0c * (ch)) + (0x04 * (idx))) 324 + ((gpriv)->info->regs->cfpctr + (0x0c * (ch)) + (0x04 * (idx))) 320 325 321 326 /* RSCFDnCFDFESTS / RSCFDnFESTS */ 322 327 #define RCANFD_FESTS (0x0238) ··· 432 437 /* CAN FD mode specific register map */ 433 438 434 439 /* RSCFDnCFDCmXXX -> RCANFD_F_XXX(m) */ 435 - #define RCANFD_F_DCFG(gpriv, m) (reg_gen4(gpriv, 0x1400, 0x0500) + (0x20 * (m))) 440 + #define RCANFD_F_DCFG(gpriv, m) ((gpriv)->info->regs->f_dcfg + (0x20 * (m))) 436 441 #define RCANFD_F_CFDCFG(m) (0x0504 + (0x20 * (m))) 437 442 #define RCANFD_F_CFDCTR(m) (0x0508 + (0x20 * (m))) 438 443 #define RCANFD_F_CFDSTS(m) (0x050c + (0x20 * (m))) ··· 448 453 #define RCANFD_F_RMDF(q, b) (0x200c + (0x04 * (b)) + (0x20 * (q))) 449 454 450 455 /* RSCFDnCFDRFXXx -> RCANFD_F_RFXX(x) */ 451 - #define RCANFD_F_RFOFFSET(gpriv) reg_gen4(gpriv, 0x6000, 0x3000) 456 + #define RCANFD_F_RFOFFSET(gpriv) ((gpriv)->info->regs->rfoffset) 452 457 #define RCANFD_F_RFID(gpriv, x) (RCANFD_F_RFOFFSET(gpriv) + (0x80 * (x))) 453 458 #define RCANFD_F_RFPTR(gpriv, x) (RCANFD_F_RFOFFSET(gpriv) + 0x04 + (0x80 * (x))) 454 459 #define RCANFD_F_RFFDSTS(gpriv, x) (RCANFD_F_RFOFFSET(gpriv) + 0x08 + (0x80 * (x))) ··· 456 461 (RCANFD_F_RFOFFSET(gpriv) + 0x0c + (0x80 * (x)) + (0x04 * (df))) 457 462 458 463 /* RSCFDnCFDCFXXk -> RCANFD_F_CFXX(ch, k) */ 459 - #define RCANFD_F_CFOFFSET(gpriv) reg_gen4(gpriv, 0x6400, 0x3400) 464 + #define RCANFD_F_CFOFFSET(gpriv) ((gpriv)->info->regs->cfoffset) 460 465 461 466 #define RCANFD_F_CFID(gpriv, ch, idx) \ 462 467 (RCANFD_F_CFOFFSET(gpriv) + (0x180 * (ch)) + (0x80 * (idx))) ··· 505 510 506 511 struct rcar_canfd_global; 507 512 513 + struct rcar_canfd_regs { 514 + u16 rfcc; /* RX FIFO Configuration/Control Register */ 515 + u16 cfcc; /* Common FIFO Configuration/Control Register */ 516 + u16 cfsts; /* Common FIFO Status Register */ 517 + u16 cfpctr; /* Common FIFO Pointer Control Register */ 518 + u16 f_dcfg; /* Global FD Configuration Register */ 519 + u16 rfoffset; /* Receive FIFO buffer access ID register */ 520 + u16 cfoffset; /* Transmit/receive FIFO buffer access ID register */ 521 + }; 522 + 523 + struct rcar_canfd_shift_data { 524 + u8 ntseg2; /* Nominal Bit Rate Time Segment 2 Control */ 525 + u8 ntseg1; /* Nominal Bit Rate Time Segment 1 Control */ 526 + u8 nsjw; /* Nominal Bit Rate Resynchronization Jump Width Control */ 527 + u8 dtseg2; /* Data Bit Rate Time Segment 2 Control */ 528 + u8 dtseg1; /* Data Bit Rate Time Segment 1 Control */ 529 + u8 cftml; /* Common FIFO TX Message Buffer Link */ 530 + u8 cfm; /* Common FIFO Mode */ 531 + u8 cfdc; /* Common FIFO Depth Configuration */ 532 + }; 533 + 508 534 struct rcar_canfd_hw_info { 535 + const struct can_bittiming_const *nom_bittiming; 536 + const struct can_bittiming_const *data_bittiming; 537 + const struct rcar_canfd_regs *regs; 538 + const struct rcar_canfd_shift_data *sh; 539 + u8 rnc_field_width; 540 + u8 max_aflpn; 541 + u8 max_cftml; 509 542 u8 max_channels; 510 543 u8 postdiv; 511 544 /* hardware features */ 512 545 unsigned shared_global_irqs:1; /* Has shared global irqs */ 513 546 unsigned multi_channel_irqs:1; /* Has multiple channel irqs */ 547 + unsigned ch_interface_mode:1; /* Has channel interface mode */ 548 + unsigned shared_can_regs:1; /* Has shared classical can registers */ 549 + unsigned external_clk:1; /* Has external clock */ 514 550 }; 515 551 516 552 /* Channel priv data */ ··· 574 548 }; 575 549 576 550 /* CAN FD mode nominal rate constants */ 577 - static const struct can_bittiming_const rcar_canfd_nom_bittiming_const = { 551 + static const struct can_bittiming_const rcar_canfd_gen3_nom_bittiming_const = { 578 552 .name = RCANFD_DRV_NAME, 579 553 .tseg1_min = 2, 580 554 .tseg1_max = 128, ··· 586 560 .brp_inc = 1, 587 561 }; 588 562 563 + static const struct can_bittiming_const rcar_canfd_gen4_nom_bittiming_const = { 564 + .name = RCANFD_DRV_NAME, 565 + .tseg1_min = 2, 566 + .tseg1_max = 256, 567 + .tseg2_min = 2, 568 + .tseg2_max = 128, 569 + .sjw_max = 128, 570 + .brp_min = 1, 571 + .brp_max = 1024, 572 + .brp_inc = 1, 573 + }; 574 + 589 575 /* CAN FD mode data rate constants */ 590 - static const struct can_bittiming_const rcar_canfd_data_bittiming_const = { 576 + static const struct can_bittiming_const rcar_canfd_gen3_data_bittiming_const = { 591 577 .name = RCANFD_DRV_NAME, 592 578 .tseg1_min = 2, 593 579 .tseg1_max = 16, 594 580 .tseg2_min = 2, 595 581 .tseg2_max = 8, 596 582 .sjw_max = 8, 583 + .brp_min = 1, 584 + .brp_max = 256, 585 + .brp_inc = 1, 586 + }; 587 + 588 + static const struct can_bittiming_const rcar_canfd_gen4_data_bittiming_const = { 589 + .name = RCANFD_DRV_NAME, 590 + .tseg1_min = 2, 591 + .tseg1_max = 32, 592 + .tseg2_min = 2, 593 + .tseg2_max = 16, 594 + .sjw_max = 16, 597 595 .brp_min = 1, 598 596 .brp_max = 256, 599 597 .brp_inc = 1, ··· 636 586 .brp_inc = 1, 637 587 }; 638 588 589 + static const struct rcar_canfd_regs rcar_gen3_regs = { 590 + .rfcc = 0x00b8, 591 + .cfcc = 0x0118, 592 + .cfsts = 0x0178, 593 + .cfpctr = 0x01d8, 594 + .f_dcfg = 0x0500, 595 + .rfoffset = 0x3000, 596 + .cfoffset = 0x3400, 597 + }; 598 + 599 + static const struct rcar_canfd_regs rcar_gen4_regs = { 600 + .rfcc = 0x00c0, 601 + .cfcc = 0x0120, 602 + .cfsts = 0x01e0, 603 + .cfpctr = 0x0240, 604 + .f_dcfg = 0x1400, 605 + .rfoffset = 0x6000, 606 + .cfoffset = 0x6400, 607 + }; 608 + 609 + static const struct rcar_canfd_shift_data rcar_gen3_shift_data = { 610 + .ntseg2 = 24, 611 + .ntseg1 = 16, 612 + .nsjw = 11, 613 + .dtseg2 = 20, 614 + .dtseg1 = 16, 615 + .cftml = 20, 616 + .cfm = 16, 617 + .cfdc = 8, 618 + }; 619 + 620 + static const struct rcar_canfd_shift_data rcar_gen4_shift_data = { 621 + .ntseg2 = 25, 622 + .ntseg1 = 17, 623 + .nsjw = 10, 624 + .dtseg2 = 16, 625 + .dtseg1 = 8, 626 + .cftml = 16, 627 + .cfm = 8, 628 + .cfdc = 21, 629 + }; 630 + 639 631 static const struct rcar_canfd_hw_info rcar_gen3_hw_info = { 632 + .nom_bittiming = &rcar_canfd_gen3_nom_bittiming_const, 633 + .data_bittiming = &rcar_canfd_gen3_data_bittiming_const, 634 + .regs = &rcar_gen3_regs, 635 + .sh = &rcar_gen3_shift_data, 636 + .rnc_field_width = 8, 637 + .max_aflpn = 31, 638 + .max_cftml = 15, 640 639 .max_channels = 2, 641 640 .postdiv = 2, 642 641 .shared_global_irqs = 1, 642 + .ch_interface_mode = 0, 643 + .shared_can_regs = 0, 644 + .external_clk = 1, 643 645 }; 644 646 645 647 static const struct rcar_canfd_hw_info rcar_gen4_hw_info = { 648 + .nom_bittiming = &rcar_canfd_gen4_nom_bittiming_const, 649 + .data_bittiming = &rcar_canfd_gen4_data_bittiming_const, 650 + .regs = &rcar_gen4_regs, 651 + .sh = &rcar_gen4_shift_data, 652 + .rnc_field_width = 16, 653 + .max_aflpn = 127, 654 + .max_cftml = 31, 646 655 .max_channels = 8, 647 656 .postdiv = 2, 648 657 .shared_global_irqs = 1, 658 + .ch_interface_mode = 1, 659 + .shared_can_regs = 1, 660 + .external_clk = 1, 649 661 }; 650 662 651 663 static const struct rcar_canfd_hw_info rzg2l_hw_info = { 664 + .nom_bittiming = &rcar_canfd_gen3_nom_bittiming_const, 665 + .data_bittiming = &rcar_canfd_gen3_data_bittiming_const, 666 + .regs = &rcar_gen3_regs, 667 + .sh = &rcar_gen3_shift_data, 668 + .rnc_field_width = 8, 669 + .max_aflpn = 31, 670 + .max_cftml = 15, 652 671 .max_channels = 2, 653 672 .postdiv = 1, 654 673 .multi_channel_irqs = 1, 674 + .ch_interface_mode = 0, 675 + .shared_can_regs = 0, 676 + .external_clk = 1, 677 + }; 678 + 679 + static const struct rcar_canfd_hw_info r9a09g047_hw_info = { 680 + .nom_bittiming = &rcar_canfd_gen4_nom_bittiming_const, 681 + .data_bittiming = &rcar_canfd_gen4_data_bittiming_const, 682 + .regs = &rcar_gen4_regs, 683 + .sh = &rcar_gen4_shift_data, 684 + .rnc_field_width = 16, 685 + .max_aflpn = 63, 686 + .max_cftml = 31, 687 + .max_channels = 6, 688 + .postdiv = 1, 689 + .multi_channel_irqs = 1, 690 + .ch_interface_mode = 1, 691 + .shared_can_regs = 1, 692 + .external_clk = 0, 655 693 }; 656 694 657 695 /* Helper functions */ 658 - static inline bool is_gen4(struct rcar_canfd_global *gpriv) 659 - { 660 - return gpriv->info == &rcar_gen4_hw_info; 661 - } 662 - 663 - static inline u32 reg_gen4(struct rcar_canfd_global *gpriv, 664 - u32 gen4, u32 not_gen4) 665 - { 666 - return is_gen4(gpriv) ? gen4 : not_gen4; 667 - } 668 - 669 696 static inline void rcar_canfd_update(u32 mask, u32 val, u32 __iomem *reg) 670 697 { 671 698 u32 data = readl(reg); ··· 808 681 can_free_echo_skb(ndev, i, NULL); 809 682 } 810 683 684 + static void rcar_canfd_setrnc(struct rcar_canfd_global *gpriv, unsigned int ch, 685 + unsigned int num_rules) 686 + { 687 + unsigned int rnc_stride = 32 / gpriv->info->rnc_field_width; 688 + unsigned int shift = 32 - (ch % rnc_stride + 1) * gpriv->info->rnc_field_width; 689 + unsigned int w = ch / rnc_stride; 690 + u32 rnc = num_rules << shift; 691 + 692 + rcar_canfd_set_bit(gpriv->base, RCANFD_GAFLCFG(w), rnc); 693 + } 694 + 811 695 static void rcar_canfd_set_mode(struct rcar_canfd_global *gpriv) 812 696 { 813 - if (is_gen4(gpriv)) { 697 + if (gpriv->info->ch_interface_mode) { 814 698 u32 ch, val = gpriv->fdmode ? RCANFD_GEN4_FDCFG_FDOE 815 699 : RCANFD_GEN4_FDCFG_CLOE; 816 700 ··· 927 789 static void rcar_canfd_configure_afl_rules(struct rcar_canfd_global *gpriv, 928 790 u32 ch, u32 rule_entry) 929 791 { 930 - int offset, page, num_rules = RCANFD_CHANNEL_NUMRULES; 792 + unsigned int offset, page, num_rules = RCANFD_CHANNEL_NUMRULES; 931 793 u32 rule_entry_index = rule_entry % 16; 932 794 u32 ridx = ch + RCANFD_RFFIFO_IDX; 933 795 ··· 938 800 RCANFD_GAFLECTR_AFLDAE)); 939 801 940 802 /* Write number of rules for channel */ 941 - rcar_canfd_set_bit(gpriv->base, RCANFD_GAFLCFG(ch), 942 - RCANFD_GAFLCFG_SETRNC(gpriv, ch, num_rules)); 943 - if (is_gen4(gpriv)) 803 + rcar_canfd_setrnc(gpriv, ch, num_rules); 804 + if (gpriv->info->shared_can_regs) 944 805 offset = RCANFD_GEN4_GAFL_OFFSET; 945 806 else if (gpriv->fdmode) 946 807 offset = RCANFD_F_GAFL_OFFSET; ··· 1079 942 u32 ridx = ch + RCANFD_RFFIFO_IDX; 1080 943 1081 944 gerfl = rcar_canfd_read(priv->base, RCANFD_GERFL); 1082 - if (gerfl & RCANFD_GERFL_EEF(ch)) { 945 + if (gerfl & FIELD_PREP(RCANFD_GERFL_EEF, BIT(ch))) { 1083 946 netdev_dbg(ndev, "Ch%u: ECC Error flag\n", ch); 1084 947 stats->tx_dropped++; 1085 948 } ··· 1441 1304 struct rcar_canfd_channel *priv = netdev_priv(dev); 1442 1305 struct rcar_canfd_global *gpriv = priv->gpriv; 1443 1306 const struct can_bittiming *bt = &priv->can.bittiming; 1444 - const struct can_bittiming *dbt = &priv->can.data_bittiming; 1307 + const struct can_bittiming *dbt = &priv->can.fd.data_bittiming; 1445 1308 u16 brp, sjw, tseg1, tseg2; 1446 1309 u32 cfg; 1447 1310 u32 ch = priv->channel; ··· 1475 1338 brp, sjw, tseg1, tseg2); 1476 1339 } else { 1477 1340 /* Classical CAN only mode */ 1478 - if (is_gen4(gpriv)) { 1341 + if (gpriv->info->shared_can_regs) { 1479 1342 cfg = (RCANFD_NCFG_NTSEG1(gpriv, tseg1) | 1480 1343 RCANFD_NCFG_NBRP(brp) | 1481 1344 RCANFD_NCFG_NSJW(gpriv, sjw) | ··· 1640 1503 1641 1504 dlc = RCANFD_CFPTR_CFDLC(can_fd_len2dlc(cf->len)); 1642 1505 1643 - if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) || is_gen4(gpriv)) { 1506 + if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) || gpriv->info->shared_can_regs) { 1644 1507 rcar_canfd_write(priv->base, 1645 1508 RCANFD_F_CFID(gpriv, ch, RCANFD_CFFIFO_IDX), id); 1646 1509 rcar_canfd_write(priv->base, ··· 1699 1562 u32 ch = priv->channel; 1700 1563 u32 ridx = ch + RCANFD_RFFIFO_IDX; 1701 1564 1702 - if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) || is_gen4(gpriv)) { 1565 + if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) || gpriv->info->shared_can_regs) { 1703 1566 id = rcar_canfd_read(priv->base, RCANFD_F_RFID(gpriv, ridx)); 1704 1567 dlc = rcar_canfd_read(priv->base, RCANFD_F_RFPTR(gpriv, ridx)); 1705 1568 ··· 1750 1613 cf->len = can_cc_dlc2len(RCANFD_RFPTR_RFDLC(dlc)); 1751 1614 if (id & RCANFD_RFID_RFRTR) 1752 1615 cf->can_id |= CAN_RTR_FLAG; 1753 - else if (is_gen4(gpriv)) 1616 + else if (gpriv->info->shared_can_regs) 1754 1617 rcar_canfd_get_data(priv, cf, RCANFD_F_RFDF(gpriv, ridx, 0)); 1755 1618 else 1756 1619 rcar_canfd_get_data(priv, cf, RCANFD_C_RFDF(ridx, 0)); ··· 1873 1736 1874 1737 if (info->multi_channel_irqs) { 1875 1738 char *irq_name; 1739 + char name[10]; 1876 1740 int err_irq; 1877 1741 int tx_irq; 1878 1742 1879 - err_irq = platform_get_irq_byname(pdev, ch == 0 ? "ch0_err" : "ch1_err"); 1743 + scnprintf(name, sizeof(name), "ch%u_err", ch); 1744 + err_irq = platform_get_irq_byname(pdev, name); 1880 1745 if (err_irq < 0) { 1881 1746 err = err_irq; 1882 1747 goto fail; 1883 1748 } 1884 1749 1885 - tx_irq = platform_get_irq_byname(pdev, ch == 0 ? "ch0_trx" : "ch1_trx"); 1750 + scnprintf(name, sizeof(name), "ch%u_trx", ch); 1751 + tx_irq = platform_get_irq_byname(pdev, name); 1886 1752 if (tx_irq < 0) { 1887 1753 err = tx_irq; 1888 1754 goto fail; ··· 1922 1782 } 1923 1783 1924 1784 if (gpriv->fdmode) { 1925 - priv->can.bittiming_const = &rcar_canfd_nom_bittiming_const; 1926 - priv->can.data_bittiming_const = 1927 - &rcar_canfd_data_bittiming_const; 1785 + priv->can.bittiming_const = gpriv->info->nom_bittiming; 1786 + priv->can.fd.data_bittiming_const = gpriv->info->data_bittiming; 1928 1787 1929 1788 /* Controller starts in CAN FD only mode */ 1930 1789 err = can_set_static_ctrlmode(ndev, CAN_CTRLMODE_FD); ··· 1985 1846 u32 rule_entry = 0; 1986 1847 bool fdmode = true; /* CAN FD only mode - default */ 1987 1848 char name[9] = "channelX"; 1849 + struct clk *clk_ram; 1988 1850 int i; 1989 1851 1990 1852 info = of_device_get_match_data(dev); ··· 1995 1855 1996 1856 for (i = 0; i < info->max_channels; ++i) { 1997 1857 name[7] = '0' + i; 1998 - of_child = of_get_child_by_name(dev->of_node, name); 1999 - if (of_child && of_device_is_available(of_child)) { 1858 + of_child = of_get_available_child_by_name(dev->of_node, name); 1859 + if (of_child) { 2000 1860 channels_mask |= BIT(i); 2001 1861 transceivers[i] = devm_of_phy_optional_get(dev, 2002 1862 of_child, NULL); 1863 + of_node_put(of_child); 2003 1864 } 2004 - of_node_put(of_child); 2005 1865 if (IS_ERR(transceivers[i])) 2006 1866 return PTR_ERR(transceivers[i]); 2007 1867 } ··· 2072 1932 fcan_freq = clk_get_rate(gpriv->can_clk) / info->postdiv; 2073 1933 } else { 2074 1934 fcan_freq = clk_get_rate(gpriv->can_clk); 2075 - gpriv->extclk = true; 1935 + gpriv->extclk = gpriv->info->external_clk; 2076 1936 } 1937 + 1938 + clk_ram = devm_clk_get_optional_enabled(dev, "ram_clk"); 1939 + if (IS_ERR(clk_ram)) 1940 + return dev_err_probe(dev, PTR_ERR(clk_ram), 1941 + "cannot get enabled ram clock\n"); 2077 1942 2078 1943 addr = devm_platform_ioremap_resource(pdev, 0); 2079 1944 if (IS_ERR(addr)) { ··· 2242 2097 2243 2098 static const __maybe_unused struct of_device_id rcar_canfd_of_table[] = { 2244 2099 { .compatible = "renesas,r8a779a0-canfd", .data = &rcar_gen4_hw_info }, 2100 + { .compatible = "renesas,r9a09g047-canfd", .data = &r9a09g047_hw_info }, 2245 2101 { .compatible = "renesas,rcar-gen3-canfd", .data = &rcar_gen3_hw_info }, 2246 2102 { .compatible = "renesas,rcar-gen4-canfd", .data = &rcar_gen4_hw_info }, 2247 2103 { .compatible = "renesas,rzg2l-canfd", .data = &rzg2l_hw_info },

+2 -2

drivers/net/can/rockchip/rockchip_canfd-core.c

··· 118 118 119 119 static int rkcanfd_set_bittiming(struct rkcanfd_priv *priv) 120 120 { 121 - const struct can_bittiming *dbt = &priv->can.data_bittiming; 121 + const struct can_bittiming *dbt = &priv->can.fd.data_bittiming; 122 122 const struct can_bittiming *bt = &priv->can.bittiming; 123 123 u32 reg_nbt, reg_dbt, reg_tdc; 124 124 u32 tdco; ··· 899 899 platform_set_drvdata(pdev, priv); 900 900 priv->can.clock.freq = clk_get_rate(priv->clks[0].clk); 901 901 priv->can.bittiming_const = &rkcanfd_bittiming_const; 902 - priv->can.data_bittiming_const = &rkcanfd_data_bittiming_const; 902 + priv->can.fd.data_bittiming_const = &rkcanfd_data_bittiming_const; 903 903 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | 904 904 CAN_CTRLMODE_BERR_REPORTING; 905 905 priv->can.do_set_mode = rkcanfd_set_mode;

+1 -1

drivers/net/can/rockchip/rockchip_canfd-timestamp.c

··· 39 39 40 40 void rkcanfd_timestamp_init(struct rkcanfd_priv *priv) 41 41 { 42 - const struct can_bittiming *dbt = &priv->can.data_bittiming; 42 + const struct can_bittiming *dbt = &priv->can.fd.data_bittiming; 43 43 const struct can_bittiming *bt = &priv->can.bittiming; 44 44 struct cyclecounter *cc = &priv->cc; 45 45 u32 bitrate, div, reg, rate;

+5 -5

drivers/net/can/spi/mcp251xfd/mcp251xfd-core.c

··· 527 527 static int mcp251xfd_set_bittiming(const struct mcp251xfd_priv *priv) 528 528 { 529 529 const struct can_bittiming *bt = &priv->can.bittiming; 530 - const struct can_bittiming *dbt = &priv->can.data_bittiming; 530 + const struct can_bittiming *dbt = &priv->can.fd.data_bittiming; 531 531 u32 tdcmod, val = 0; 532 532 int err; 533 533 ··· 600 600 tdcmod = MCP251XFD_REG_TDC_TDCMOD_DISABLED; 601 601 602 602 val = FIELD_PREP(MCP251XFD_REG_TDC_TDCMOD_MASK, tdcmod) | 603 - FIELD_PREP(MCP251XFD_REG_TDC_TDCV_MASK, priv->can.tdc.tdcv) | 604 - FIELD_PREP(MCP251XFD_REG_TDC_TDCO_MASK, priv->can.tdc.tdco); 603 + FIELD_PREP(MCP251XFD_REG_TDC_TDCV_MASK, priv->can.fd.tdc.tdcv) | 604 + FIELD_PREP(MCP251XFD_REG_TDC_TDCO_MASK, priv->can.fd.tdc.tdco); 605 605 606 606 return regmap_write(priv->map_reg, MCP251XFD_REG_TDC, val); 607 607 } ··· 2104 2104 priv->can.do_set_mode = mcp251xfd_set_mode; 2105 2105 priv->can.do_get_berr_counter = mcp251xfd_get_berr_counter; 2106 2106 priv->can.bittiming_const = &mcp251xfd_bittiming_const; 2107 - priv->can.data_bittiming_const = &mcp251xfd_data_bittiming_const; 2108 - priv->can.tdc_const = &mcp251xfd_tdc_const; 2107 + priv->can.fd.data_bittiming_const = &mcp251xfd_data_bittiming_const; 2108 + priv->can.fd.tdc_const = &mcp251xfd_tdc_const; 2109 2109 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | 2110 2110 CAN_CTRLMODE_LISTENONLY | CAN_CTRLMODE_BERR_REPORTING | 2111 2111 CAN_CTRLMODE_FD | CAN_CTRLMODE_FD_NON_ISO |

+3 -3

drivers/net/can/usb/esd_usb.c

··· 1098 1098 const struct can_bittiming_const *data_btc = &esd_usb_3_data_bittiming_const; 1099 1099 struct esd_usb_net_priv *priv = netdev_priv(netdev); 1100 1100 struct can_bittiming *nom_bt = &priv->can.bittiming; 1101 - struct can_bittiming *data_bt = &priv->can.data_bittiming; 1101 + struct can_bittiming *data_bt = &priv->can.fd.data_bittiming; 1102 1102 struct esd_usb_3_set_baudrate_msg_x *baud_x; 1103 1103 union esd_usb_msg *msg; 1104 1104 u16 flags = 0; ··· 1218 1218 priv->can.clock.freq = ESD_USB_3_CAN_CLOCK; 1219 1219 priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD; 1220 1220 priv->can.bittiming_const = &esd_usb_3_nom_bittiming_const; 1221 - priv->can.data_bittiming_const = &esd_usb_3_data_bittiming_const; 1221 + priv->can.fd.data_bittiming_const = &esd_usb_3_data_bittiming_const; 1222 1222 priv->can.do_set_bittiming = esd_usb_3_set_bittiming; 1223 - priv->can.do_set_data_bittiming = esd_usb_3_set_bittiming; 1223 + priv->can.fd.do_set_data_bittiming = esd_usb_3_set_bittiming; 1224 1224 break; 1225 1225 1226 1226 case ESD_USB_CANUSBM_PRODUCT_ID:

+2 -2

drivers/net/can/usb/etas_es58x/es58x_core.c

··· 2059 2059 2060 2060 can->bittiming_const = param->bittiming_const; 2061 2061 if (param->ctrlmode_supported & CAN_CTRLMODE_FD) { 2062 - can->data_bittiming_const = param->data_bittiming_const; 2063 - can->tdc_const = param->tdc_const; 2062 + can->fd.data_bittiming_const = param->data_bittiming_const; 2063 + can->fd.tdc_const = param->tdc_const; 2064 2064 } 2065 2065 can->bitrate_max = param->bitrate_max; 2066 2066 can->clock = param->clock;

+3 -3

drivers/net/can/usb/etas_es58x/es58x_fd.c

··· 427 427 428 428 if (tx_conf_msg.canfd_enabled) { 429 429 es58x_fd_convert_bittiming(&tx_conf_msg.data_bittiming, 430 - &priv->can.data_bittiming); 430 + &priv->can.fd.data_bittiming); 431 431 432 432 if (can_tdc_is_enabled(&priv->can)) { 433 433 tx_conf_msg.tdc_enabled = 1; 434 - tx_conf_msg.tdco = cpu_to_le16(priv->can.tdc.tdco); 435 - tx_conf_msg.tdcf = cpu_to_le16(priv->can.tdc.tdcf); 434 + tx_conf_msg.tdco = cpu_to_le16(priv->can.fd.tdc.tdco); 435 + tx_conf_msg.tdcf = cpu_to_le16(priv->can.fd.tdc.tdcf); 436 436 } 437 437 438 438 conf_len = ES58X_FD_CANFD_CONF_LEN;

+4 -4

drivers/net/can/usb/gs_usb.c

··· 728 728 static int gs_usb_set_data_bittiming(struct net_device *netdev) 729 729 { 730 730 struct gs_can *dev = netdev_priv(netdev); 731 - struct can_bittiming *bt = &dev->can.data_bittiming; 731 + struct can_bittiming *bt = &dev->can.fd.data_bittiming; 732 732 struct gs_device_bittiming dbt = { 733 733 .prop_seg = cpu_to_le32(bt->prop_seg), 734 734 .phase_seg1 = cpu_to_le32(bt->phase_seg1), ··· 1300 1300 /* The data bit timing will be overwritten, if 1301 1301 * GS_CAN_FEATURE_BT_CONST_EXT is set. 1302 1302 */ 1303 - dev->can.data_bittiming_const = &dev->bt_const; 1304 - dev->can.do_set_data_bittiming = gs_usb_set_data_bittiming; 1303 + dev->can.fd.data_bittiming_const = &dev->bt_const; 1304 + dev->can.fd.do_set_data_bittiming = gs_usb_set_data_bittiming; 1305 1305 } 1306 1306 1307 1307 if (feature & GS_CAN_FEATURE_TERMINATION) { ··· 1381 1381 dev->data_bt_const.brp_max = le32_to_cpu(bt_const_extended.dbrp_max); 1382 1382 dev->data_bt_const.brp_inc = le32_to_cpu(bt_const_extended.dbrp_inc); 1383 1383 1384 - dev->can.data_bittiming_const = &dev->data_bt_const; 1384 + dev->can.fd.data_bittiming_const = &dev->data_bt_const; 1385 1385 } 1386 1386 1387 1387 can_rx_offload_add_manual(netdev, &dev->offload, GS_NAPI_WEIGHT);

+1 -1

drivers/net/can/usb/kvaser_usb/kvaser_usb.h

··· 137 137 * @dev_set_mode: used for can.do_set_mode 138 138 * @dev_set_bittiming: used for can.do_set_bittiming 139 139 * @dev_get_busparams: readback arbitration busparams 140 - * @dev_set_data_bittiming: used for can.do_set_data_bittiming 140 + * @dev_set_data_bittiming: used for can.fd.do_set_data_bittiming 141 141 * @dev_get_data_busparams: readback data busparams 142 142 * @dev_get_berr_counter: used for can.do_get_berr_counter 143 143 *

+3 -3

drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c

··· 592 592 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 593 593 struct kvaser_usb *dev = priv->dev; 594 594 const struct kvaser_usb_dev_ops *ops = dev->driver_info->ops; 595 - struct can_bittiming *dbt = &priv->can.data_bittiming; 595 + struct can_bittiming *dbt = &priv->can.fd.data_bittiming; 596 596 struct kvaser_usb_busparams busparams; 597 597 int tseg1 = dbt->prop_seg + dbt->phase_seg1; 598 598 int tseg2 = dbt->phase_seg2; ··· 842 842 priv->can.ctrlmode_supported |= dev->card_data.ctrlmode_supported; 843 843 844 844 if (priv->can.ctrlmode_supported & CAN_CTRLMODE_FD) { 845 - priv->can.data_bittiming_const = dev->cfg->data_bittiming_const; 846 - priv->can.do_set_data_bittiming = kvaser_usb_set_data_bittiming; 845 + priv->can.fd.data_bittiming_const = dev->cfg->data_bittiming_const; 846 + priv->can.fd.do_set_data_bittiming = kvaser_usb_set_data_bittiming; 847 847 } 848 848 849 849 netdev->flags |= IFF_ECHO;

+3 -3

drivers/net/can/usb/peak_usb/pcan_usb_core.c

··· 770 770 const struct peak_usb_adapter *pa = dev->adapter; 771 771 772 772 if (pa->dev_set_data_bittiming) { 773 - struct can_bittiming *bt = &dev->can.data_bittiming; 773 + struct can_bittiming *bt = &dev->can.fd.data_bittiming; 774 774 int err = pa->dev_set_data_bittiming(dev, bt); 775 775 776 776 if (err) ··· 954 954 dev->can.clock = peak_usb_adapter->clock; 955 955 dev->can.bittiming_const = peak_usb_adapter->bittiming_const; 956 956 dev->can.do_set_bittiming = peak_usb_set_bittiming; 957 - dev->can.data_bittiming_const = peak_usb_adapter->data_bittiming_const; 958 - dev->can.do_set_data_bittiming = peak_usb_set_data_bittiming; 957 + dev->can.fd.data_bittiming_const = peak_usb_adapter->data_bittiming_const; 958 + dev->can.fd.do_set_data_bittiming = peak_usb_set_data_bittiming; 959 959 dev->can.do_set_mode = peak_usb_set_mode; 960 960 dev->can.do_get_berr_counter = peak_usb_adapter->do_get_berr_counter; 961 961 dev->can.ctrlmode_supported = peak_usb_adapter->ctrlmode_supported;

+8 -8

drivers/net/can/xilinx_can.c

··· 481 481 { 482 482 struct xcan_priv *priv = netdev_priv(ndev); 483 483 struct can_bittiming *bt = &priv->can.bittiming; 484 - struct can_bittiming *dbt = &priv->can.data_bittiming; 484 + struct can_bittiming *dbt = &priv->can.fd.data_bittiming; 485 485 u32 btr0, btr1; 486 486 u32 is_config_mode; 487 487 ··· 517 517 btr0 = dbt->brp - 1; 518 518 if (can_tdc_is_enabled(&priv->can)) { 519 519 if (priv->devtype.cantype == XAXI_CANFD) 520 - btr0 |= FIELD_PREP(XCAN_BRPR_TDCO_MASK, priv->can.tdc.tdco) | 520 + btr0 |= FIELD_PREP(XCAN_BRPR_TDCO_MASK, priv->can.fd.tdc.tdco) | 521 521 XCAN_BRPR_TDC_ENABLE; 522 522 else 523 - btr0 |= FIELD_PREP(XCAN_2_BRPR_TDCO_MASK, priv->can.tdc.tdco) | 523 + btr0 |= FIELD_PREP(XCAN_2_BRPR_TDCO_MASK, priv->can.fd.tdc.tdco) | 524 524 XCAN_BRPR_TDC_ENABLE; 525 525 } 526 526 ··· 1967 1967 goto err_free; 1968 1968 1969 1969 if (devtype->cantype == XAXI_CANFD) { 1970 - priv->can.data_bittiming_const = 1970 + priv->can.fd.data_bittiming_const = 1971 1971 &xcan_data_bittiming_const_canfd; 1972 - priv->can.tdc_const = &xcan_tdc_const_canfd; 1972 + priv->can.fd.tdc_const = &xcan_tdc_const_canfd; 1973 1973 } 1974 1974 1975 1975 if (devtype->cantype == XAXI_CANFD_2_0) { 1976 - priv->can.data_bittiming_const = 1976 + priv->can.fd.data_bittiming_const = 1977 1977 &xcan_data_bittiming_const_canfd2; 1978 - priv->can.tdc_const = &xcan_tdc_const_canfd2; 1978 + priv->can.fd.tdc_const = &xcan_tdc_const_canfd2; 1979 1979 } 1980 1980 1981 1981 if (devtype->cantype == XAXI_CANFD || 1982 1982 devtype->cantype == XAXI_CANFD_2_0) { 1983 1983 priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD | 1984 1984 CAN_CTRLMODE_TDC_AUTO; 1985 - priv->can.do_get_auto_tdcv = xcan_get_auto_tdcv; 1985 + priv->can.fd.do_get_auto_tdcv = xcan_get_auto_tdcv; 1986 1986 } 1987 1987 1988 1988 priv->reg_base = addr;

+16 -12

include/linux/can/dev.h

··· 38 38 CAN_TERMINATION_GPIO_MAX, 39 39 }; 40 40 41 + struct data_bittiming_params { 42 + const struct can_bittiming_const *data_bittiming_const; 43 + struct can_bittiming data_bittiming; 44 + const struct can_tdc_const *tdc_const; 45 + struct can_tdc tdc; 46 + const u32 *data_bitrate_const; 47 + unsigned int data_bitrate_const_cnt; 48 + int (*do_set_data_bittiming)(struct net_device *dev); 49 + int (*do_get_auto_tdcv)(const struct net_device *dev, u32 *tdcv); 50 + }; 51 + 41 52 /* 42 53 * CAN common private data 43 54 */ ··· 56 45 struct net_device *dev; 57 46 struct can_device_stats can_stats; 58 47 59 - const struct can_bittiming_const *bittiming_const, 60 - *data_bittiming_const; 61 - struct can_bittiming bittiming, data_bittiming; 62 - const struct can_tdc_const *tdc_const; 63 - struct can_tdc tdc; 64 - 48 + const struct can_bittiming_const *bittiming_const; 49 + struct can_bittiming bittiming; 50 + struct data_bittiming_params fd; 65 51 unsigned int bitrate_const_cnt; 66 52 const u32 *bitrate_const; 67 - const u32 *data_bitrate_const; 68 - unsigned int data_bitrate_const_cnt; 69 53 u32 bitrate_max; 70 54 struct can_clock clock; 71 55 ··· 83 77 struct delayed_work restart_work; 84 78 85 79 int (*do_set_bittiming)(struct net_device *dev); 86 - int (*do_set_data_bittiming)(struct net_device *dev); 87 80 int (*do_set_mode)(struct net_device *dev, enum can_mode mode); 88 81 int (*do_set_termination)(struct net_device *dev, u16 term); 89 82 int (*do_get_state)(const struct net_device *dev, 90 83 enum can_state *state); 91 84 int (*do_get_berr_counter)(const struct net_device *dev, 92 85 struct can_berr_counter *bec); 93 - int (*do_get_auto_tdcv)(const struct net_device *dev, u32 *tdcv); 94 86 }; 95 87 96 88 static inline bool can_tdc_is_enabled(const struct can_priv *priv) ··· 118 114 */ 119 115 static inline s32 can_get_relative_tdco(const struct can_priv *priv) 120 116 { 121 - const struct can_bittiming *dbt = &priv->data_bittiming; 117 + const struct can_bittiming *dbt = &priv->fd.data_bittiming; 122 118 s32 sample_point_in_tc = (CAN_SYNC_SEG + dbt->prop_seg + 123 119 dbt->phase_seg1) * dbt->brp; 124 120 125 - return (s32)priv->tdc.tdco - sample_point_in_tc; 121 + return (s32)priv->fd.tdc.tdco - sample_point_in_tc; 126 122 } 127 123 128 124 /* helper to define static CAN controller features at device creation time */

+1

tools/testing/selftests/Makefile

··· 66 66 TARGETS += nci 67 67 TARGETS += net 68 68 TARGETS += net/af_unix 69 + TARGETS += net/can 69 70 TARGETS += net/forwarding 70 71 TARGETS += net/hsr 71 72 TARGETS += net/mptcp

+2

tools/testing/selftests/net/can/.gitignore

··· 1 + # SPDX-License-Identifier: GPL-2.0-only 2 + test_raw_filter

+11

tools/testing/selftests/net/can/Makefile

··· 1 + # SPDX-License-Identifier: GPL-2.0 2 + 3 + top_srcdir = ../../../../.. 4 + 5 + CFLAGS += -Wall -Wl,--no-as-needed -O2 -g -I$(top_srcdir)/usr/include $(KHDR_INCLUDES) 6 + 7 + TEST_PROGS := test_raw_filter.sh 8 + 9 + TEST_GEN_FILES := test_raw_filter 10 + 11 + include ../../lib.mk

+405

tools/testing/selftests/net/can/test_raw_filter.c

··· 1 + // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) 2 + /* 3 + * Copyright (c) 2011 Volkswagen Group Electronic Research 4 + * All rights reserved. 5 + */ 6 + 7 + #include <stdio.h> 8 + #include <stdlib.h> 9 + #include <unistd.h> 10 + #include <string.h> 11 + 12 + #include <sys/types.h> 13 + #include <sys/socket.h> 14 + #include <sys/ioctl.h> 15 + #include <sys/time.h> 16 + #include <net/if.h> 17 + #include <linux/if.h> 18 + 19 + #include <linux/can.h> 20 + #include <linux/can/raw.h> 21 + 22 + #include "../../kselftest_harness.h" 23 + 24 + #define ID 0x123 25 + 26 + char CANIF[IFNAMSIZ]; 27 + 28 + static int send_can_frames(int sock, int testcase) 29 + { 30 + struct can_frame frame; 31 + 32 + frame.can_dlc = 1; 33 + frame.data[0] = testcase; 34 + 35 + frame.can_id = ID; 36 + if (write(sock, &frame, sizeof(frame)) < 0) 37 + goto write_err; 38 + 39 + frame.can_id = (ID | CAN_RTR_FLAG); 40 + if (write(sock, &frame, sizeof(frame)) < 0) 41 + goto write_err; 42 + 43 + frame.can_id = (ID | CAN_EFF_FLAG); 44 + if (write(sock, &frame, sizeof(frame)) < 0) 45 + goto write_err; 46 + 47 + frame.can_id = (ID | CAN_EFF_FLAG | CAN_RTR_FLAG); 48 + if (write(sock, &frame, sizeof(frame)) < 0) 49 + goto write_err; 50 + 51 + return 0; 52 + 53 + write_err: 54 + perror("write"); 55 + return 1; 56 + } 57 + 58 + FIXTURE(can_filters) { 59 + int sock; 60 + }; 61 + 62 + FIXTURE_SETUP(can_filters) 63 + { 64 + struct sockaddr_can addr; 65 + struct ifreq ifr; 66 + int recv_own_msgs = 1; 67 + int s, ret; 68 + 69 + s = socket(PF_CAN, SOCK_RAW, CAN_RAW); 70 + ASSERT_GE(s, 0) 71 + TH_LOG("failed to create CAN_RAW socket: %d", errno); 72 + 73 + strncpy(ifr.ifr_name, CANIF, sizeof(ifr.ifr_name)); 74 + ret = ioctl(s, SIOCGIFINDEX, &ifr); 75 + ASSERT_GE(ret, 0) 76 + TH_LOG("failed SIOCGIFINDEX: %d", errno); 77 + 78 + addr.can_family = AF_CAN; 79 + addr.can_ifindex = ifr.ifr_ifindex; 80 + 81 + setsockopt(s, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS, 82 + &recv_own_msgs, sizeof(recv_own_msgs)); 83 + 84 + ret = bind(s, (struct sockaddr *)&addr, sizeof(addr)); 85 + ASSERT_EQ(ret, 0) 86 + TH_LOG("failed bind socket: %d", errno); 87 + 88 + self->sock = s; 89 + } 90 + 91 + FIXTURE_TEARDOWN(can_filters) 92 + { 93 + close(self->sock); 94 + } 95 + 96 + FIXTURE_VARIANT(can_filters) { 97 + int testcase; 98 + canid_t id; 99 + canid_t mask; 100 + int exp_num_rx; 101 + canid_t exp_flags[]; 102 + }; 103 + 104 + /* Receive all frames when filtering for the ID in standard frame format */ 105 + FIXTURE_VARIANT_ADD(can_filters, base) { 106 + .testcase = 1, 107 + .id = ID, 108 + .mask = CAN_SFF_MASK, 109 + .exp_num_rx = 4, 110 + .exp_flags = { 111 + 0, 112 + CAN_RTR_FLAG, 113 + CAN_EFF_FLAG, 114 + CAN_EFF_FLAG | CAN_RTR_FLAG, 115 + }, 116 + }; 117 + 118 + /* Ignore EFF flag in filter ID if not covered by filter mask */ 119 + FIXTURE_VARIANT_ADD(can_filters, base_eff) { 120 + .testcase = 2, 121 + .id = ID | CAN_EFF_FLAG, 122 + .mask = CAN_SFF_MASK, 123 + .exp_num_rx = 4, 124 + .exp_flags = { 125 + 0, 126 + CAN_RTR_FLAG, 127 + CAN_EFF_FLAG, 128 + CAN_EFF_FLAG | CAN_RTR_FLAG, 129 + }, 130 + }; 131 + 132 + /* Ignore RTR flag in filter ID if not covered by filter mask */ 133 + FIXTURE_VARIANT_ADD(can_filters, base_rtr) { 134 + .testcase = 3, 135 + .id = ID | CAN_RTR_FLAG, 136 + .mask = CAN_SFF_MASK, 137 + .exp_num_rx = 4, 138 + .exp_flags = { 139 + 0, 140 + CAN_RTR_FLAG, 141 + CAN_EFF_FLAG, 142 + CAN_EFF_FLAG | CAN_RTR_FLAG, 143 + }, 144 + }; 145 + 146 + /* Ignore EFF and RTR flags in filter ID if not covered by filter mask */ 147 + FIXTURE_VARIANT_ADD(can_filters, base_effrtr) { 148 + .testcase = 4, 149 + .id = ID | CAN_EFF_FLAG | CAN_RTR_FLAG, 150 + .mask = CAN_SFF_MASK, 151 + .exp_num_rx = 4, 152 + .exp_flags = { 153 + 0, 154 + CAN_RTR_FLAG, 155 + CAN_EFF_FLAG, 156 + CAN_EFF_FLAG | CAN_RTR_FLAG, 157 + }, 158 + }; 159 + 160 + /* Receive only SFF frames when expecting no EFF flag */ 161 + FIXTURE_VARIANT_ADD(can_filters, filter_eff) { 162 + .testcase = 5, 163 + .id = ID, 164 + .mask = CAN_SFF_MASK | CAN_EFF_FLAG, 165 + .exp_num_rx = 2, 166 + .exp_flags = { 167 + 0, 168 + CAN_RTR_FLAG, 169 + }, 170 + }; 171 + 172 + /* Receive only EFF frames when filter id and filter mask include EFF flag */ 173 + FIXTURE_VARIANT_ADD(can_filters, filter_eff_eff) { 174 + .testcase = 6, 175 + .id = ID | CAN_EFF_FLAG, 176 + .mask = CAN_SFF_MASK | CAN_EFF_FLAG, 177 + .exp_num_rx = 2, 178 + .exp_flags = { 179 + CAN_EFF_FLAG, 180 + CAN_EFF_FLAG | CAN_RTR_FLAG, 181 + }, 182 + }; 183 + 184 + /* Receive only SFF frames when expecting no EFF flag, ignoring RTR flag */ 185 + FIXTURE_VARIANT_ADD(can_filters, filter_eff_rtr) { 186 + .testcase = 7, 187 + .id = ID | CAN_RTR_FLAG, 188 + .mask = CAN_SFF_MASK | CAN_EFF_FLAG, 189 + .exp_num_rx = 2, 190 + .exp_flags = { 191 + 0, 192 + CAN_RTR_FLAG, 193 + }, 194 + }; 195 + 196 + /* Receive only EFF frames when filter id and filter mask include EFF flag, 197 + * ignoring RTR flag 198 + */ 199 + FIXTURE_VARIANT_ADD(can_filters, filter_eff_effrtr) { 200 + .testcase = 8, 201 + .id = ID | CAN_EFF_FLAG | CAN_RTR_FLAG, 202 + .mask = CAN_SFF_MASK | CAN_EFF_FLAG, 203 + .exp_num_rx = 2, 204 + .exp_flags = { 205 + CAN_EFF_FLAG, 206 + CAN_EFF_FLAG | CAN_RTR_FLAG, 207 + }, 208 + }; 209 + 210 + /* Receive no remote frames when filtering for no RTR flag */ 211 + FIXTURE_VARIANT_ADD(can_filters, filter_rtr) { 212 + .testcase = 9, 213 + .id = ID, 214 + .mask = CAN_SFF_MASK | CAN_RTR_FLAG, 215 + .exp_num_rx = 2, 216 + .exp_flags = { 217 + 0, 218 + CAN_EFF_FLAG, 219 + }, 220 + }; 221 + 222 + /* Receive no remote frames when filtering for no RTR flag, ignoring EFF flag */ 223 + FIXTURE_VARIANT_ADD(can_filters, filter_rtr_eff) { 224 + .testcase = 10, 225 + .id = ID | CAN_EFF_FLAG, 226 + .mask = CAN_SFF_MASK | CAN_RTR_FLAG, 227 + .exp_num_rx = 2, 228 + .exp_flags = { 229 + 0, 230 + CAN_EFF_FLAG, 231 + }, 232 + }; 233 + 234 + /* Receive only remote frames when filter includes RTR flag */ 235 + FIXTURE_VARIANT_ADD(can_filters, filter_rtr_rtr) { 236 + .testcase = 11, 237 + .id = ID | CAN_RTR_FLAG, 238 + .mask = CAN_SFF_MASK | CAN_RTR_FLAG, 239 + .exp_num_rx = 2, 240 + .exp_flags = { 241 + CAN_RTR_FLAG, 242 + CAN_EFF_FLAG | CAN_RTR_FLAG, 243 + }, 244 + }; 245 + 246 + /* Receive only remote frames when filter includes RTR flag, ignoring EFF 247 + * flag 248 + */ 249 + FIXTURE_VARIANT_ADD(can_filters, filter_rtr_effrtr) { 250 + .testcase = 12, 251 + .id = ID | CAN_EFF_FLAG | CAN_RTR_FLAG, 252 + .mask = CAN_SFF_MASK | CAN_RTR_FLAG, 253 + .exp_num_rx = 2, 254 + .exp_flags = { 255 + CAN_RTR_FLAG, 256 + CAN_EFF_FLAG | CAN_RTR_FLAG, 257 + }, 258 + }; 259 + 260 + /* Receive only SFF data frame when filtering for no flags */ 261 + FIXTURE_VARIANT_ADD(can_filters, filter_effrtr) { 262 + .testcase = 13, 263 + .id = ID, 264 + .mask = CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG, 265 + .exp_num_rx = 1, 266 + .exp_flags = { 267 + 0, 268 + }, 269 + }; 270 + 271 + /* Receive only EFF data frame when filtering for EFF but no RTR flag */ 272 + FIXTURE_VARIANT_ADD(can_filters, filter_effrtr_eff) { 273 + .testcase = 14, 274 + .id = ID | CAN_EFF_FLAG, 275 + .mask = CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG, 276 + .exp_num_rx = 1, 277 + .exp_flags = { 278 + CAN_EFF_FLAG, 279 + }, 280 + }; 281 + 282 + /* Receive only SFF remote frame when filtering for RTR but no EFF flag */ 283 + FIXTURE_VARIANT_ADD(can_filters, filter_effrtr_rtr) { 284 + .testcase = 15, 285 + .id = ID | CAN_RTR_FLAG, 286 + .mask = CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG, 287 + .exp_num_rx = 1, 288 + .exp_flags = { 289 + CAN_RTR_FLAG, 290 + }, 291 + }; 292 + 293 + /* Receive only EFF remote frame when filtering for EFF and RTR flag */ 294 + FIXTURE_VARIANT_ADD(can_filters, filter_effrtr_effrtr) { 295 + .testcase = 16, 296 + .id = ID | CAN_EFF_FLAG | CAN_RTR_FLAG, 297 + .mask = CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG, 298 + .exp_num_rx = 1, 299 + .exp_flags = { 300 + CAN_EFF_FLAG | CAN_RTR_FLAG, 301 + }, 302 + }; 303 + 304 + /* Receive only SFF data frame when filtering for no EFF flag and no RTR flag 305 + * but based on EFF mask 306 + */ 307 + FIXTURE_VARIANT_ADD(can_filters, eff) { 308 + .testcase = 17, 309 + .id = ID, 310 + .mask = CAN_EFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG, 311 + .exp_num_rx = 1, 312 + .exp_flags = { 313 + 0, 314 + }, 315 + }; 316 + 317 + /* Receive only EFF data frame when filtering for EFF flag and no RTR flag but 318 + * based on EFF mask 319 + */ 320 + FIXTURE_VARIANT_ADD(can_filters, eff_eff) { 321 + .testcase = 18, 322 + .id = ID | CAN_EFF_FLAG, 323 + .mask = CAN_EFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG, 324 + .exp_num_rx = 1, 325 + .exp_flags = { 326 + CAN_EFF_FLAG, 327 + }, 328 + }; 329 + 330 + /* This test verifies that the raw CAN filters work, by checking if only frames 331 + * with the expected set of flags are received. For each test case, the given 332 + * filter (id and mask) is added and four CAN frames are sent with every 333 + * combination of set/unset EFF/RTR flags. 334 + */ 335 + TEST_F(can_filters, test_filter) 336 + { 337 + struct can_filter rfilter; 338 + int ret; 339 + 340 + rfilter.can_id = variant->id; 341 + rfilter.can_mask = variant->mask; 342 + setsockopt(self->sock, SOL_CAN_RAW, CAN_RAW_FILTER, 343 + &rfilter, sizeof(rfilter)); 344 + 345 + TH_LOG("filters: can_id = 0x%08X can_mask = 0x%08X", 346 + rfilter.can_id, rfilter.can_mask); 347 + 348 + ret = send_can_frames(self->sock, variant->testcase); 349 + ASSERT_EQ(ret, 0) 350 + TH_LOG("failed to send CAN frames"); 351 + 352 + for (int i = 0; i <= variant->exp_num_rx; i++) { 353 + struct can_frame frame; 354 + struct timeval tv = { 355 + .tv_sec = 0, 356 + .tv_usec = 50000, /* 50ms timeout */ 357 + }; 358 + fd_set rdfs; 359 + 360 + FD_ZERO(&rdfs); 361 + FD_SET(self->sock, &rdfs); 362 + 363 + ret = select(self->sock + 1, &rdfs, NULL, NULL, &tv); 364 + ASSERT_GE(ret, 0) 365 + TH_LOG("failed select for frame %d, err: %d)", i, errno); 366 + 367 + ret = FD_ISSET(self->sock, &rdfs); 368 + if (i == variant->exp_num_rx) { 369 + ASSERT_EQ(ret, 0) 370 + TH_LOG("too many frames received"); 371 + } else { 372 + ASSERT_NE(ret, 0) 373 + TH_LOG("too few frames received"); 374 + 375 + ret = read(self->sock, &frame, sizeof(frame)); 376 + ASSERT_GE(ret, 0) 377 + TH_LOG("failed to read frame %d, err: %d", i, errno); 378 + 379 + TH_LOG("rx: can_id = 0x%08X rx = %d", frame.can_id, i); 380 + 381 + ASSERT_EQ(ID, frame.can_id & CAN_SFF_MASK) 382 + TH_LOG("received wrong can_id"); 383 + ASSERT_EQ(variant->testcase, frame.data[0]) 384 + TH_LOG("received wrong test case"); 385 + 386 + ASSERT_EQ(frame.can_id & ~CAN_ERR_MASK, 387 + variant->exp_flags[i]) 388 + TH_LOG("received unexpected flags"); 389 + } 390 + } 391 + } 392 + 393 + int main(int argc, char **argv) 394 + { 395 + char *ifname = getenv("CANIF"); 396 + 397 + if (!ifname) { 398 + printf("CANIF environment variable must contain the test interface\n"); 399 + return KSFT_FAIL; 400 + } 401 + 402 + strncpy(CANIF, ifname, sizeof(CANIF) - 1); 403 + 404 + return test_harness_run(argc, argv); 405 + }

+45

tools/testing/selftests/net/can/test_raw_filter.sh

··· 1 + #!/bin/bash 2 + # SPDX-License-Identifier: GPL-2.0 3 + 4 + ALL_TESTS=" 5 + test_raw_filter 6 + " 7 + 8 + net_dir=$(dirname $0)/.. 9 + source $net_dir/lib.sh 10 + 11 + export CANIF=${CANIF:-"vcan0"} 12 + BITRATE=${BITRATE:-500000} 13 + 14 + setup() 15 + { 16 + if [[ $CANIF == vcan* ]]; then 17 + ip link add name $CANIF type vcan || exit $ksft_skip 18 + else 19 + ip link set dev $CANIF type can bitrate $BITRATE || exit $ksft_skip 20 + fi 21 + ip link set dev $CANIF up 22 + pwd 23 + } 24 + 25 + cleanup() 26 + { 27 + ip link set dev $CANIF down 28 + if [[ $CANIF == vcan* ]]; then 29 + ip link delete $CANIF 30 + fi 31 + } 32 + 33 + test_raw_filter() 34 + { 35 + ./test_raw_filter 36 + check_err $? 37 + log_test "test_raw_filter" 38 + } 39 + 40 + trap cleanup EXIT 41 + setup 42 + 43 + tests_run 44 + 45 + exit $EXIT_STATUS

Configure Feed

Configure Feed