Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
can: rename CAN FD related can_len2dlc and can_dlc2len helpers
The helper functions can_len2dlc and can_dlc2len are only relevant for
CAN FD data length code (DLC) conversion.
To fit the introduced can_cc_dlc2len for Classical CAN we rename:
can_dlc2len -> can_fd_dlc2len to get the payload length from the DLC
can_len2dlc -> can_fd_len2dlc to get the DLC from the payload length
Suggested-by: Vincent Mailhol <mailhol.vincent@wanadoo.fr>
Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>
Link: https://lore.kernel.org/r/20201110101852.1973-6-socketcan@hartkopp.net
Signed-off-by: Marc Kleine-Budde <mkl@pengutronix.de>
authored by
Oliver Hartkopp
and committed by
Marc Kleine-Budde
3ab4ce0d
c7b74967
+32
-32
+1
-1
Documentation/networking/can.rst
+1
-1
Documentation/networking/can.rst
···
1332
1332
The data length code was a 1:1 mapping to the payload length in the legacy
1333
1333
CAN frames anyway. The payload length to the bus-relevant DLC mapping is
1334
1334
only performed inside the CAN drivers, preferably with the helper
1335
-
functions can_dlc2len() and can_len2dlc().
1335
+
functions can_fd_dlc2len() and can_fd_len2dlc().
1336
1336
1337
1337
The CAN netdevice driver capabilities can be distinguished by the network
1338
1338
devices maximum transfer unit (MTU)::
+4
-4
drivers/net/can/dev.c
+4
-4
drivers/net/can/dev.c
···
31
31
8, 12, 16, 20, 24, 32, 48, 64};
32
32
33
33
/* get data length from raw data length code (DLC) */
34
-
u8 can_dlc2len(u8 dlc)
34
+
u8 can_fd_dlc2len(u8 dlc)
35
35
{
36
36
return dlc2len[dlc & 0x0F];
37
37
}
38
-
EXPORT_SYMBOL_GPL(can_dlc2len);
38
+
EXPORT_SYMBOL_GPL(can_fd_dlc2len);
39
39
40
40
static const u8 len2dlc[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, /* 0 - 8 */
41
41
9, 9, 9, 9, /* 9 - 12 */
···
49
49
15, 15, 15, 15, 15, 15, 15, 15}; /* 57 - 64 */
50
50
51
51
/* map the sanitized data length to an appropriate data length code */
52
-
u8 can_len2dlc(u8 len)
52
+
u8 can_fd_len2dlc(u8 len)
53
53
{
54
54
if (unlikely(len > 64))
55
55
return 0xF;
56
56
57
57
return len2dlc[len];
58
58
}
59
-
EXPORT_SYMBOL_GPL(can_len2dlc);
59
+
EXPORT_SYMBOL_GPL(can_fd_len2dlc);
60
60
61
61
#ifdef CONFIG_CAN_CALC_BITTIMING
62
62
#define CAN_CALC_MAX_ERROR 50 /* in one-tenth of a percent */
+2
-2
drivers/net/can/flexcan.c
+2
-2
drivers/net/can/flexcan.c
···
746
746
struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
747
747
u32 can_id;
748
748
u32 data;
749
-
u32 ctrl = FLEXCAN_MB_CODE_TX_DATA | ((can_len2dlc(cfd->len)) << 16);
749
+
u32 ctrl = FLEXCAN_MB_CODE_TX_DATA | ((can_fd_len2dlc(cfd->len)) << 16);
750
750
int i;
751
751
752
752
if (can_dropped_invalid_skb(dev, skb))
···
1000
1000
cfd->can_id = (reg_id >> 18) & CAN_SFF_MASK;
1001
1001
1002
1002
if (reg_ctrl & FLEXCAN_MB_CNT_EDL) {
1003
-
cfd->len = can_dlc2len((reg_ctrl >> 16) & 0xf);
1003
+
cfd->len = can_fd_dlc2len((reg_ctrl >> 16) & 0xf);
1004
1004
1005
1005
if (reg_ctrl & FLEXCAN_MB_CNT_BRS)
1006
1006
cfd->flags |= CANFD_BRS;
+2
-2
drivers/net/can/ifi_canfd/ifi_canfd.c
+2
-2
drivers/net/can/ifi_canfd/ifi_canfd.c
···
271
271
dlc = (rxdlc >> IFI_CANFD_RXFIFO_DLC_DLC_OFFSET) &
272
272
IFI_CANFD_RXFIFO_DLC_DLC_MASK;
273
273
if (rxdlc & IFI_CANFD_RXFIFO_DLC_EDL)
274
-
cf->len = can_dlc2len(dlc);
274
+
cf->len = can_fd_dlc2len(dlc);
275
275
else
276
276
cf->len = can_cc_dlc2len(dlc);
277
277
···
900
900
txid = cf->can_id & CAN_SFF_MASK;
901
901
}
902
902
903
-
txdlc = can_len2dlc(cf->len);
903
+
txdlc = can_fd_len2dlc(cf->len);
904
904
if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) && can_is_canfd_skb(skb)) {
905
905
txdlc |= IFI_CANFD_TXFIFO_DLC_EDL;
906
906
if (cf->flags & CANFD_BRS)
+3
-3
drivers/net/can/kvaser_pciefd.c
+3
-3
drivers/net/can/kvaser_pciefd.c
···
740
740
p->header[0] |= KVASER_PCIEFD_RPACKET_IDE;
741
741
742
742
p->header[0] |= cf->can_id & CAN_EFF_MASK;
743
-
p->header[1] |= can_len2dlc(cf->len) << KVASER_PCIEFD_RPACKET_DLC_SHIFT;
743
+
p->header[1] |= can_fd_len2dlc(cf->len) << KVASER_PCIEFD_RPACKET_DLC_SHIFT;
744
744
p->header[1] |= KVASER_PCIEFD_TPACKET_AREQ;
745
745
746
746
if (can_is_canfd_skb(skb)) {
···
1174
1174
if (p->header[0] & KVASER_PCIEFD_RPACKET_IDE)
1175
1175
cf->can_id |= CAN_EFF_FLAG;
1176
1176
1177
-
cf->len = can_dlc2len(p->header[1] >> KVASER_PCIEFD_RPACKET_DLC_SHIFT);
1177
+
cf->len = can_fd_dlc2len(p->header[1] >> KVASER_PCIEFD_RPACKET_DLC_SHIFT);
1178
1178
1179
1179
if (p->header[0] & KVASER_PCIEFD_RPACKET_RTR)
1180
1180
cf->can_id |= CAN_RTR_FLAG;
···
1600
1600
if (!(p->header[0] & KVASER_PCIEFD_RPACKET_RTR)) {
1601
1601
u8 data_len;
1602
1602
1603
-
data_len = can_dlc2len(p->header[1] >>
1603
+
data_len = can_fd_dlc2len(p->header[1] >>
1604
1604
KVASER_PCIEFD_RPACKET_DLC_SHIFT);
1605
1605
pos += DIV_ROUND_UP(data_len, 4);
1606
1606
}
+3
-3
drivers/net/can/m_can/m_can.c
+3
-3
drivers/net/can/m_can/m_can.c
···
457
457
}
458
458
459
459
if (dlc & RX_BUF_FDF)
460
-
cf->len = can_dlc2len((dlc >> 16) & 0x0F);
460
+
cf->len = can_fd_dlc2len((dlc >> 16) & 0x0F);
461
461
else
462
462
cf->len = can_cc_dlc2len((dlc >> 16) & 0x0F);
463
463
···
1489
1489
/* message ram configuration */
1490
1490
m_can_fifo_write(cdev, 0, M_CAN_FIFO_ID, id);
1491
1491
m_can_fifo_write(cdev, 0, M_CAN_FIFO_DLC,
1492
-
can_len2dlc(cf->len) << 16);
1492
+
can_fd_len2dlc(cf->len) << 16);
1493
1493
1494
1494
for (i = 0; i < cf->len; i += 4)
1495
1495
m_can_fifo_write(cdev, 0,
···
1557
1557
m_can_fifo_write(cdev, putidx, M_CAN_FIFO_DLC,
1558
1558
((putidx << TX_BUF_MM_SHIFT) &
1559
1559
TX_BUF_MM_MASK) |
1560
-
(can_len2dlc(cf->len) << 16) |
1560
+
(can_fd_len2dlc(cf->len) << 16) |
1561
1561
fdflags | TX_BUF_EFC);
1562
1562
1563
1563
for (i = 0; i < cf->len; i += 4)
+2
-2
drivers/net/can/peak_canfd/peak_canfd.c
+2
-2
drivers/net/can/peak_canfd/peak_canfd.c
···
257
257
u8 cf_len;
258
258
259
259
if (rx_msg_flags & PUCAN_MSG_EXT_DATA_LEN)
260
-
cf_len = can_dlc2len(pucan_msg_get_dlc(msg));
260
+
cf_len = can_fd_dlc2len(pucan_msg_get_dlc(msg));
261
261
else
262
262
cf_len = can_cc_dlc2len(pucan_msg_get_dlc(msg));
263
263
···
682
682
683
683
if (can_is_canfd_skb(skb)) {
684
684
/* CAN FD frame format */
685
-
len = can_len2dlc(cf->len);
685
+
len = can_fd_len2dlc(cf->len);
686
686
687
687
msg_flags |= PUCAN_MSG_EXT_DATA_LEN;
688
688
+2
-2
drivers/net/can/rcar/rcar_canfd.c
+2
-2
drivers/net/can/rcar/rcar_canfd.c
···
1357
1357
if (cf->can_id & CAN_RTR_FLAG)
1358
1358
id |= RCANFD_CFID_CFRTR;
1359
1359
1360
-
dlc = RCANFD_CFPTR_CFDLC(can_len2dlc(cf->len));
1360
+
dlc = RCANFD_CFPTR_CFDLC(can_fd_len2dlc(cf->len));
1361
1361
1362
1362
if (priv->can.ctrlmode & CAN_CTRLMODE_FD) {
1363
1363
rcar_canfd_write(priv->base,
···
1446
1446
1447
1447
if (priv->can.ctrlmode & CAN_CTRLMODE_FD) {
1448
1448
if (sts & RCANFD_RFFDSTS_RFFDF)
1449
-
cf->len = can_dlc2len(RCANFD_RFPTR_RFDLC(dlc));
1449
+
cf->len = can_fd_dlc2len(RCANFD_RFPTR_RFDLC(dlc));
1450
1450
else
1451
1451
cf->len = can_cc_dlc2len(RCANFD_RFPTR_RFDLC(dlc));
1452
1452
+4
-4
drivers/net/can/spi/mcp251xfd/mcp251xfd-core.c
+4
-4
drivers/net/can/spi/mcp251xfd/mcp251xfd-core.c
···
1405
1405
cfd->flags |= CANFD_BRS;
1406
1406
1407
1407
dlc = FIELD_GET(MCP251XFD_OBJ_FLAGS_DLC, hw_rx_obj->flags);
1408
-
cfd->len = can_dlc2len(dlc);
1408
+
cfd->len = can_fd_dlc2len(dlc);
1409
1409
} else {
1410
1410
if (hw_rx_obj->flags & MCP251XFD_OBJ_FLAGS_RTR)
1411
1411
cfd->can_id |= CAN_RTR_FLAG;
···
2244
2244
* harm, only the lower 7 bits will be transferred into the
2245
2245
* TEF object.
2246
2246
*/
2247
-
dlc = can_len2dlc(cfd->len);
2247
+
dlc = can_fd_len2dlc(cfd->len);
2248
2248
flags |= FIELD_PREP(MCP251XFD_OBJ_FLAGS_SEQ_MCP2518FD_MASK, seq) |
2249
2249
FIELD_PREP(MCP251XFD_OBJ_FLAGS_DLC, dlc);
2250
2250
···
2273
2273
2274
2274
/* Clear data at end of CAN frame */
2275
2275
offset = round_down(cfd->len, sizeof(u32));
2276
-
len = round_up(can_dlc2len(dlc), sizeof(u32)) - offset;
2276
+
len = round_up(can_fd_dlc2len(dlc), sizeof(u32)) - offset;
2277
2277
if (MCP251XFD_SANITIZE_CAN && len)
2278
2278
memset(hw_tx_obj->data + offset, 0x0, len);
2279
2279
memcpy(hw_tx_obj->data, cfd->data, cfd->len);
···
2281
2281
/* Number of bytes to be written into the RAM of the controller */
2282
2282
len = sizeof(hw_tx_obj->id) + sizeof(hw_tx_obj->flags);
2283
2283
if (MCP251XFD_SANITIZE_CAN)
2284
-
len += round_up(can_dlc2len(dlc), sizeof(u32));
2284
+
len += round_up(can_fd_dlc2len(dlc), sizeof(u32));
2285
2285
else
2286
2286
len += round_up(cfd->len, sizeof(u32));
2287
2287
+3
-3
drivers/net/can/usb/kvaser_usb/kvaser_usb_hydra.c
+3
-3
drivers/net/can/usb/kvaser_usb/kvaser_usb_hydra.c
···
1120
1120
struct net_device_stats *stats = &priv->netdev->stats;
1121
1121
1122
1122
stats->tx_packets++;
1123
-
stats->tx_bytes += can_dlc2len(context->dlc);
1123
+
stats->tx_bytes += can_fd_dlc2len(context->dlc);
1124
1124
}
1125
1125
1126
1126
spin_lock_irqsave(&priv->tx_contexts_lock, irq_flags);
···
1251
1251
kvaser_usb_can_rx_over_error(priv->netdev);
1252
1252
1253
1253
if (flags & KVASER_USB_HYDRA_CF_FLAG_FDF) {
1254
-
cf->len = can_dlc2len(dlc);
1254
+
cf->len = can_fd_dlc2len(dlc);
1255
1255
if (flags & KVASER_USB_HYDRA_CF_FLAG_BRS)
1256
1256
cf->flags |= CANFD_BRS;
1257
1257
if (flags & KVASER_USB_HYDRA_CF_FLAG_ESI)
···
1351
1351
struct kvaser_usb *dev = priv->dev;
1352
1352
struct kvaser_cmd_ext *cmd;
1353
1353
struct canfd_frame *cf = (struct canfd_frame *)skb->data;
1354
-
u8 dlc = can_len2dlc(cf->len);
1354
+
u8 dlc = can_fd_len2dlc(cf->len);
1355
1355
u8 nbr_of_bytes = cf->len;
1356
1356
u32 flags;
1357
1357
u32 id;
+2
-2
drivers/net/can/usb/peak_usb/pcan_usb_fd.c
+2
-2
drivers/net/can/usb/peak_usb/pcan_usb_fd.c
···
492
492
if (rx_msg_flags & PUCAN_MSG_ERROR_STATE_IND)
493
493
cfd->flags |= CANFD_ESI;
494
494
495
-
cfd->len = can_dlc2len(pucan_msg_get_dlc(rm));
495
+
cfd->len = can_fd_dlc2len(pucan_msg_get_dlc(rm));
496
496
} else {
497
497
/* CAN 2.0 frame case */
498
498
skb = alloc_can_skb(netdev, (struct can_frame **)&cfd);
···
756
756
757
757
if (can_is_canfd_skb(skb)) {
758
758
/* considering a CANFD frame */
759
-
len = can_len2dlc(cfd->len);
759
+
len = can_fd_len2dlc(cfd->len);
760
760
761
761
tx_msg_flags |= PUCAN_MSG_EXT_DATA_LEN;
762
762
+2
-2
drivers/net/can/xilinx_can.c
+2
-2
drivers/net/can/xilinx_can.c
···
583
583
id |= XCAN_IDR_SRR_MASK;
584
584
}
585
585
586
-
dlc = can_len2dlc(cf->len) << XCAN_DLCR_DLC_SHIFT;
586
+
dlc = can_fd_len2dlc(cf->len) << XCAN_DLCR_DLC_SHIFT;
587
587
if (can_is_canfd_skb(skb)) {
588
588
if (cf->flags & CANFD_BRS)
589
589
dlc |= XCAN_DLCR_BRS_MASK;
···
832
832
* format
833
833
*/
834
834
if (dlc & XCAN_DLCR_EDL_MASK)
835
-
cf->len = can_dlc2len((dlc & XCAN_DLCR_DLC_MASK) >>
835
+
cf->len = can_fd_dlc2len((dlc & XCAN_DLCR_DLC_MASK) >>
836
836
XCAN_DLCR_DLC_SHIFT);
837
837
else
838
838
cf->len = can_cc_dlc2len((dlc & XCAN_DLCR_DLC_MASK) >>
+2
-2
include/linux/can/dev.h
+2
-2
include/linux/can/dev.h
···
186
186
}
187
187
188
188
/* get data length from raw data length code (DLC) */
189
-
u8 can_dlc2len(u8 dlc);
189
+
u8 can_fd_dlc2len(u8 dlc);
190
190
191
191
/* map the sanitized data length to an appropriate data length code */
192
-
u8 can_len2dlc(u8 len);
192
+
u8 can_fd_len2dlc(u8 len);
193
193
194
194
struct net_device *alloc_candev_mqs(int sizeof_priv, unsigned int echo_skb_max,
195
195
unsigned int txqs, unsigned int rxqs);