linux-can-fixes-for-5.10-20201103
-----BEGIN PGP SIGNATURE----- iQFHBAABCgAxFiEEK3kIWJt9yTYMP3ehqclaivrt76kFAl+hzPwTHG1rbEBwZW5n dXRyb25peC5kZQAKCRCpyVqK+u3vqU8YB/9PBALnpZFDSyOE/8rKoBoqA2uPfj2i Yplu98jkFqhnb5I1KFPCNJiTQd+/aAzM2LzeGHVOBMIF6scPUclC12k1q4fdLtX0 6YMZ38w2I2hq8z1QIgOYo7jQ34NeonNt7T5CHEeBA7xXGnlo/WYDNDE0cruPnPRZ eFqM5f1/PVKKh4gFVTAqICC2ZMefL4rgAkFgFXj2rfiYr115OEGAwCav5Ys31p/y MI5SfQmNkfkE8HswMNBDQZ+8V5qkKvarHXwUcRfgUqkpqHQjzcOIJnCDh/ngIh50 imwxHaCerXvEj8MBUcF2fZV7w6QPTFIV3TQ0AiUjuVUE3HPuR+JPvSl4 =B3CC -----END PGP SIGNATURE----- Merge tag 'linux-can-fixes-for-5.10-20201103' of git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can Marc Kleine-Budde says: ==================== pull-request: can 2020-11-03 The first two patches are by Oleksij Rempel and they add a generic can-controller Device Tree yaml binding and convert the text based binding of the flexcan driver to a yaml based binding. Zhang Changzhong's patch fixes a remove_proc_entry warning in the AF_CAN core. A patch by me fixes a kfree_skb() call from IRQ context in the rx-offload helper. Vincent Mailhol contributes a patch to prevent a call to kfree_skb() in hard IRQ context in can_get_echo_skb(). Oliver Hartkopp's patch fixes the length calculation for RTR CAN frames in the __can_get_echo_skb() helper. Oleksij Rempel's patch fixes a use-after-free that shows up with j1939 in can_create_echo_skb(). Yegor Yefremov contributes 4 patches to enhance the j1939 documentation. Zhang Changzhong's patch fixes a hanging task problem in j1939_sk_bind() if the netdev is down. Then there are three patches for the newly added CAN_ISOTP protocol. Geert Uytterhoeven enhances the kconfig help text. Oliver Hartkopp's patch adds missing RX timeout handling in listen-only mode and Colin Ian King's patch decreases the generated object code by 926 bytes. Zhang Changzhong contributes a patch for the ti_hecc driver that fixes the error path in the probe function. Navid Emamdoost's patch for the xilinx_can driver fixes the error handling in case of failing pm_runtime_get_sync(). There are two patches for the peak_usb driver. Dan Carpenter adds range checking in decode operations and Stephane Grosjean's patch fixes a timestamp wrapping problem. Stephane Grosjean's patch for th peak_canfd driver fixes echo management if loopback is on. The next three patches all target the mcp251xfd driver. The first one is by me and it increased the severity of CRC read error messages. The kernel test robot removes an unneeded semicolon and Tom Rix removes unneeded break in several switch-cases. The last 4 patches are by Joakim Zhang and target the flexcan driver, the first three fix ECC related device specific quirks for the LS1021A, LX2160A and the VF610 SoC. The last patch disable wakeup completely upon driver remove. * tag 'linux-can-fixes-for-5.10-20201103' of git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can: (27 commits) can: flexcan: flexcan_remove(): disable wakeup completely can: flexcan: add ECC initialization for VF610 can: flexcan: add ECC initialization for LX2160A can: flexcan: remove FLEXCAN_QUIRK_DISABLE_MECR quirk for LS1021A can: mcp251xfd: remove unneeded break can: mcp251xfd: mcp251xfd_regmap_nocrc_read(): fix semicolon.cocci warnings can: mcp251xfd: mcp251xfd_regmap_crc_read(): increase severity of CRC read error messages can: peak_canfd: pucan_handle_can_rx(): fix echo management when loopback is on can: peak_usb: peak_usb_get_ts_time(): fix timestamp wrapping can: peak_usb: add range checking in decode operations can: xilinx_can: handle failure cases of pm_runtime_get_sync can: ti_hecc: ti_hecc_probe(): add missed clk_disable_unprepare() in error path can: isotp: padlen(): make const array static, makes object smaller can: isotp: isotp_rcv_cf(): enable RX timeout handling in listen-only mode can: isotp: Explain PDU in CAN_ISOTP help text can: j1939: j1939_sk_bind(): return failure if netdev is down can: j1939: use backquotes for code samples can: j1939: swap addr and pgn in the send example can: j1939: fix syntax and spelling can: j1939: rename jacd tool ... ==================== Link: https://lore.kernel.org/r/<20201103220636.972106-1-mkl@pengutronix.de> Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Jakub Kicinski
commit
ac6f929d74
|
|
@ -0,0 +1,18 @@
|
|||
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
|
||||
%YAML 1.2
|
||||
---
|
||||
$id: http://devicetree.org/schemas/net/can/can-controller.yaml#
|
||||
$schema: http://devicetree.org/meta-schemas/core.yaml#
|
||||
|
||||
title: CAN Controller Generic Binding
|
||||
|
||||
maintainers:
|
||||
- Marc Kleine-Budde <mkl@pengutronix.de>
|
||||
|
||||
properties:
|
||||
$nodename:
|
||||
pattern: "^can(@.*)?$"
|
||||
|
||||
additionalProperties: true
|
||||
|
||||
...
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
|
||||
%YAML 1.2
|
||||
---
|
||||
$id: http://devicetree.org/schemas/net/can/fsl,flexcan.yaml#
|
||||
$schema: http://devicetree.org/meta-schemas/core.yaml#
|
||||
|
||||
title:
|
||||
Flexcan CAN controller on Freescale's ARM and PowerPC system-on-a-chip (SOC).
|
||||
|
||||
maintainers:
|
||||
- Marc Kleine-Budde <mkl@pengutronix.de>
|
||||
|
||||
allOf:
|
||||
- $ref: can-controller.yaml#
|
||||
|
||||
properties:
|
||||
compatible:
|
||||
oneOf:
|
||||
- enum:
|
||||
- fsl,imx8qm-flexcan
|
||||
- fsl,imx8mp-flexcan
|
||||
- fsl,imx6q-flexcan
|
||||
- fsl,imx53-flexcan
|
||||
- fsl,imx35-flexcan
|
||||
- fsl,imx28-flexcan
|
||||
- fsl,imx25-flexcan
|
||||
- fsl,p1010-flexcan
|
||||
- fsl,vf610-flexcan
|
||||
- fsl,ls1021ar2-flexcan
|
||||
- fsl,lx2160ar1-flexcan
|
||||
- items:
|
||||
- enum:
|
||||
- fsl,imx7d-flexcan
|
||||
- fsl,imx6ul-flexcan
|
||||
- fsl,imx6sx-flexcan
|
||||
- const: fsl,imx6q-flexcan
|
||||
- items:
|
||||
- enum:
|
||||
- fsl,ls1028ar1-flexcan
|
||||
- const: fsl,lx2160ar1-flexcan
|
||||
|
||||
reg:
|
||||
maxItems: 1
|
||||
|
||||
interrupts:
|
||||
maxItems: 1
|
||||
|
||||
clocks:
|
||||
maxItems: 2
|
||||
|
||||
clock-names:
|
||||
items:
|
||||
- const: ipg
|
||||
- const: per
|
||||
|
||||
clock-frequency:
|
||||
description: |
|
||||
The oscillator frequency driving the flexcan device, filled in by the
|
||||
boot loader. This property should only be used the used operating system
|
||||
doesn't support the clocks and clock-names property.
|
||||
|
||||
xceiver-supply:
|
||||
description: Regulator that powers the CAN transceiver.
|
||||
|
||||
big-endian:
|
||||
$ref: /schemas/types.yaml#/definitions/flag
|
||||
description: |
|
||||
This means the registers of FlexCAN controller are big endian. This is
|
||||
optional property.i.e. if this property is not present in device tree
|
||||
node then controller is assumed to be little endian. If this property is
|
||||
present then controller is assumed to be big endian.
|
||||
|
||||
fsl,stop-mode:
|
||||
description: |
|
||||
Register bits of stop mode control.
|
||||
|
||||
The format should be as follows:
|
||||
<gpr req_gpr req_bit>
|
||||
gpr is the phandle to general purpose register node.
|
||||
req_gpr is the gpr register offset of CAN stop request.
|
||||
req_bit is the bit offset of CAN stop request.
|
||||
$ref: /schemas/types.yaml#/definitions/phandle-array
|
||||
items:
|
||||
- description: The 'gpr' is the phandle to general purpose register node.
|
||||
- description: The 'req_gpr' is the gpr register offset of CAN stop request.
|
||||
maximum: 0xff
|
||||
- description: The 'req_bit' is the bit offset of CAN stop request.
|
||||
maximum: 0x1f
|
||||
|
||||
fsl,clk-source:
|
||||
description: |
|
||||
Select the clock source to the CAN Protocol Engine (PE). It's SoC
|
||||
implementation dependent. Refer to RM for detailed definition. If this
|
||||
property is not set in device tree node then driver selects clock source 1
|
||||
by default.
|
||||
0: clock source 0 (oscillator clock)
|
||||
1: clock source 1 (peripheral clock)
|
||||
$ref: /schemas/types.yaml#/definitions/uint32
|
||||
default: 1
|
||||
minimum: 0
|
||||
maximum: 1
|
||||
|
||||
wakeup-source:
|
||||
$ref: /schemas/types.yaml#/definitions/flag
|
||||
description:
|
||||
Enable CAN remote wakeup.
|
||||
|
||||
required:
|
||||
- compatible
|
||||
- reg
|
||||
- interrupts
|
||||
|
||||
additionalProperties: false
|
||||
|
||||
examples:
|
||||
- |
|
||||
can@1c000 {
|
||||
compatible = "fsl,p1010-flexcan";
|
||||
reg = <0x1c000 0x1000>;
|
||||
interrupts = <48 0x2>;
|
||||
interrupt-parent = <&mpic>;
|
||||
clock-frequency = <200000000>;
|
||||
fsl,clk-source = <0>;
|
||||
};
|
||||
- |
|
||||
#include <dt-bindings/interrupt-controller/irq.h>
|
||||
|
||||
can@2090000 {
|
||||
compatible = "fsl,imx6q-flexcan";
|
||||
reg = <0x02090000 0x4000>;
|
||||
interrupts = <0 110 IRQ_TYPE_LEVEL_HIGH>;
|
||||
clocks = <&clks 1>, <&clks 2>;
|
||||
clock-names = "ipg", "per";
|
||||
fsl,stop-mode = <&gpr 0x34 28>;
|
||||
};
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
Flexcan CAN controller on Freescale's ARM and PowerPC system-on-a-chip (SOC).
|
||||
|
||||
Required properties:
|
||||
|
||||
- compatible : Should be "fsl,<processor>-flexcan"
|
||||
|
||||
where <processor> is imx8qm, imx6q, imx28, imx53, imx35, imx25, p1010,
|
||||
vf610, ls1021ar2, lx2160ar1, ls1028ar1.
|
||||
|
||||
The ls1028ar1 must be followed by lx2160ar1, e.g.
|
||||
- "fsl,ls1028ar1-flexcan", "fsl,lx2160ar1-flexcan"
|
||||
|
||||
An implementation should also claim any of the following compatibles
|
||||
that it is fully backwards compatible with:
|
||||
|
||||
- fsl,p1010-flexcan
|
||||
|
||||
- reg : Offset and length of the register set for this device
|
||||
- interrupts : Interrupt tuple for this device
|
||||
|
||||
Optional properties:
|
||||
|
||||
- clock-frequency : The oscillator frequency driving the flexcan device
|
||||
|
||||
- xceiver-supply: Regulator that powers the CAN transceiver
|
||||
|
||||
- big-endian: This means the registers of FlexCAN controller are big endian.
|
||||
This is optional property.i.e. if this property is not present in
|
||||
device tree node then controller is assumed to be little endian.
|
||||
if this property is present then controller is assumed to be big
|
||||
endian.
|
||||
|
||||
- fsl,stop-mode: register bits of stop mode control, the format is
|
||||
<&gpr req_gpr req_bit>.
|
||||
gpr is the phandle to general purpose register node.
|
||||
req_gpr is the gpr register offset of CAN stop request.
|
||||
req_bit is the bit offset of CAN stop request.
|
||||
|
||||
- fsl,clk-source: Select the clock source to the CAN Protocol Engine (PE).
|
||||
It's SoC Implementation dependent. Refer to RM for detailed
|
||||
definition. If this property is not set in device tree node
|
||||
then driver selects clock source 1 by default.
|
||||
0: clock source 0 (oscillator clock)
|
||||
1: clock source 1 (peripheral clock)
|
||||
|
||||
- wakeup-source: enable CAN remote wakeup
|
||||
|
||||
Example:
|
||||
|
||||
can@1c000 {
|
||||
compatible = "fsl,p1010-flexcan";
|
||||
reg = <0x1c000 0x1000>;
|
||||
interrupts = <48 0x2>;
|
||||
interrupt-parent = <&mpic>;
|
||||
clock-frequency = <200000000>; // filled in by bootloader
|
||||
fsl,clk-source = <0>; // select clock source 0 for PE
|
||||
};
|
||||
|
|
@ -10,9 +10,9 @@ Overview / What Is J1939
|
|||
SAE J1939 defines a higher layer protocol on CAN. It implements a more
|
||||
sophisticated addressing scheme and extends the maximum packet size above 8
|
||||
bytes. Several derived specifications exist, which differ from the original
|
||||
J1939 on the application level, like MilCAN A, NMEA2000 and especially
|
||||
J1939 on the application level, like MilCAN A, NMEA2000, and especially
|
||||
ISO-11783 (ISOBUS). This last one specifies the so-called ETP (Extended
|
||||
Transport Protocol) which is has been included in this implementation. This
|
||||
Transport Protocol), which has been included in this implementation. This
|
||||
results in a maximum packet size of ((2 ^ 24) - 1) * 7 bytes == 111 MiB.
|
||||
|
||||
Specifications used
|
||||
|
|
@ -32,15 +32,15 @@ sockets, we found some reasons to justify a kernel implementation for the
|
|||
addressing and transport methods used by J1939.
|
||||
|
||||
* **Addressing:** when a process on an ECU communicates via J1939, it should
|
||||
not necessarily know its source address. Although at least one process per
|
||||
not necessarily know its source address. Although, at least one process per
|
||||
ECU should know the source address. Other processes should be able to reuse
|
||||
that address. This way, address parameters for different processes
|
||||
cooperating for the same ECU, are not duplicated. This way of working is
|
||||
closely related to the UNIX concept where programs do just one thing, and do
|
||||
closely related to the UNIX concept, where programs do just one thing and do
|
||||
it well.
|
||||
|
||||
* **Dynamic addressing:** Address Claiming in J1939 is time critical.
|
||||
Furthermore data transport should be handled properly during the address
|
||||
Furthermore, data transport should be handled properly during the address
|
||||
negotiation. Putting this functionality in the kernel eliminates it as a
|
||||
requirement for _every_ user space process that communicates via J1939. This
|
||||
results in a consistent J1939 bus with proper addressing.
|
||||
|
|
@ -58,7 +58,7 @@ Therefore, these parts are left to user space.
|
|||
|
||||
The J1939 sockets operate on CAN network devices (see SocketCAN). Any J1939
|
||||
user space library operating on CAN raw sockets will still operate properly.
|
||||
Since such library does not communicate with the in-kernel implementation, care
|
||||
Since such a library does not communicate with the in-kernel implementation, care
|
||||
must be taken that these two do not interfere. In practice, this means they
|
||||
cannot share ECU addresses. A single ECU (or virtual ECU) address is used by
|
||||
the library exclusively, or by the in-kernel system exclusively.
|
||||
|
|
@ -77,13 +77,13 @@ is composed as follows:
|
|||
8 bits : PS (PDU Specific)
|
||||
|
||||
In J1939-21 distinction is made between PDU1 format (where PF < 240) and PDU2
|
||||
format (where PF >= 240). Furthermore, when using PDU2 format, the PS-field
|
||||
format (where PF >= 240). Furthermore, when using the PDU2 format, the PS-field
|
||||
contains a so-called Group Extension, which is part of the PGN. When using PDU2
|
||||
format, the Group Extension is set in the PS-field.
|
||||
|
||||
On the other hand, when using PDU1 format, the PS-field contains a so-called
|
||||
Destination Address, which is _not_ part of the PGN. When communicating a PGN
|
||||
from user space to kernel (or visa versa) and PDU2 format is used, the PS-field
|
||||
from user space to kernel (or vice versa) and PDU2 format is used, the PS-field
|
||||
of the PGN shall be set to zero. The Destination Address shall be set
|
||||
elsewhere.
|
||||
|
||||
|
|
@ -96,15 +96,15 @@ Addressing
|
|||
|
||||
Both static and dynamic addressing methods can be used.
|
||||
|
||||
For static addresses, no extra checks are made by the kernel, and provided
|
||||
For static addresses, no extra checks are made by the kernel and provided
|
||||
addresses are considered right. This responsibility is for the OEM or system
|
||||
integrator.
|
||||
|
||||
For dynamic addressing, so-called Address Claiming, extra support is foreseen
|
||||
in the kernel. In J1939 any ECU is known by it's 64-bit NAME. At the moment of
|
||||
in the kernel. In J1939 any ECU is known by its 64-bit NAME. At the moment of
|
||||
a successful address claim, the kernel keeps track of both NAME and source
|
||||
address being claimed. This serves as a base for filter schemes. By default,
|
||||
packets with a destination that is not locally, will be rejected.
|
||||
packets with a destination that is not locally will be rejected.
|
||||
|
||||
Mixed mode packets (from a static to a dynamic address or vice versa) are
|
||||
allowed. The BSD sockets define separate API calls for getting/setting the
|
||||
|
|
@ -131,31 +131,31 @@ API Calls
|
|||
---------
|
||||
|
||||
On CAN, you first need to open a socket for communicating over a CAN network.
|
||||
To use J1939, #include <linux/can/j1939.h>. From there, <linux/can.h> will be
|
||||
To use J1939, ``#include <linux/can/j1939.h>``. From there, ``<linux/can.h>`` will be
|
||||
included too. To open a socket, use:
|
||||
|
||||
.. code-block:: C
|
||||
|
||||
s = socket(PF_CAN, SOCK_DGRAM, CAN_J1939);
|
||||
|
||||
J1939 does use SOCK_DGRAM sockets. In the J1939 specification, connections are
|
||||
J1939 does use ``SOCK_DGRAM`` sockets. In the J1939 specification, connections are
|
||||
mentioned in the context of transport protocol sessions. These still deliver
|
||||
packets to the other end (using several CAN packets). SOCK_STREAM is not
|
||||
packets to the other end (using several CAN packets). ``SOCK_STREAM`` is not
|
||||
supported.
|
||||
|
||||
After the successful creation of the socket, you would normally use the bind(2)
|
||||
and/or connect(2) system call to bind the socket to a CAN interface. After
|
||||
binding and/or connecting the socket, you can read(2) and write(2) from/to the
|
||||
socket or use send(2), sendto(2), sendmsg(2) and the recv*() counterpart
|
||||
After the successful creation of the socket, you would normally use the ``bind(2)``
|
||||
and/or ``connect(2)`` system call to bind the socket to a CAN interface. After
|
||||
binding and/or connecting the socket, you can ``read(2)`` and ``write(2)`` from/to the
|
||||
socket or use ``send(2)``, ``sendto(2)``, ``sendmsg(2)`` and the ``recv*()`` counterpart
|
||||
operations on the socket as usual. There are also J1939 specific socket options
|
||||
described below.
|
||||
|
||||
In order to send data, a bind(2) must have been successful. bind(2) assigns a
|
||||
In order to send data, a ``bind(2)`` must have been successful. ``bind(2)`` assigns a
|
||||
local address to a socket.
|
||||
|
||||
Different from CAN is that the payload data is just the data that get send,
|
||||
without it's header info. The header info is derived from the sockaddr supplied
|
||||
to bind(2), connect(2), sendto(2) and recvfrom(2). A write(2) with size 4 will
|
||||
Different from CAN is that the payload data is just the data that get sends,
|
||||
without its header info. The header info is derived from the sockaddr supplied
|
||||
to ``bind(2)``, ``connect(2)``, ``sendto(2)`` and ``recvfrom(2)``. A ``write(2)`` with size 4 will
|
||||
result in a packet with 4 bytes.
|
||||
|
||||
The sockaddr structure has extensions for use with J1939 as specified below:
|
||||
|
|
@ -180,47 +180,47 @@ The sockaddr structure has extensions for use with J1939 as specified below:
|
|||
} can_addr;
|
||||
}
|
||||
|
||||
can_family & can_ifindex serve the same purpose as for other SocketCAN sockets.
|
||||
``can_family`` & ``can_ifindex`` serve the same purpose as for other SocketCAN sockets.
|
||||
|
||||
can_addr.j1939.pgn specifies the PGN (max 0x3ffff). Individual bits are
|
||||
``can_addr.j1939.pgn`` specifies the PGN (max 0x3ffff). Individual bits are
|
||||
specified above.
|
||||
|
||||
can_addr.j1939.name contains the 64-bit J1939 NAME.
|
||||
``can_addr.j1939.name`` contains the 64-bit J1939 NAME.
|
||||
|
||||
can_addr.j1939.addr contains the address.
|
||||
``can_addr.j1939.addr`` contains the address.
|
||||
|
||||
The bind(2) system call assigns the local address, i.e. the source address when
|
||||
sending packages. If a PGN during bind(2) is set, it's used as a RX filter.
|
||||
I.e. only packets with a matching PGN are received. If an ADDR or NAME is set
|
||||
The ``bind(2)`` system call assigns the local address, i.e. the source address when
|
||||
sending packages. If a PGN during ``bind(2)`` is set, it's used as a RX filter.
|
||||
I.e. only packets with a matching PGN are received. If an ADDR or NAME is set
|
||||
it is used as a receive filter, too. It will match the destination NAME or ADDR
|
||||
of the incoming packet. The NAME filter will work only if appropriate Address
|
||||
Claiming for this name was done on the CAN bus and registered/cached by the
|
||||
kernel.
|
||||
|
||||
On the other hand connect(2) assigns the remote address, i.e. the destination
|
||||
address. The PGN from connect(2) is used as the default PGN when sending
|
||||
On the other hand ``connect(2)`` assigns the remote address, i.e. the destination
|
||||
address. The PGN from ``connect(2)`` is used as the default PGN when sending
|
||||
packets. If ADDR or NAME is set it will be used as the default destination ADDR
|
||||
or NAME. Further a set ADDR or NAME during connect(2) is used as a receive
|
||||
or NAME. Further a set ADDR or NAME during ``connect(2)`` is used as a receive
|
||||
filter. It will match the source NAME or ADDR of the incoming packet.
|
||||
|
||||
Both write(2) and send(2) will send a packet with local address from bind(2) and
|
||||
the remote address from connect(2). Use sendto(2) to overwrite the destination
|
||||
Both ``write(2)`` and ``send(2)`` will send a packet with local address from ``bind(2)`` and the
|
||||
remote address from ``connect(2)``. Use ``sendto(2)`` to overwrite the destination
|
||||
address.
|
||||
|
||||
If can_addr.j1939.name is set (!= 0) the NAME is looked up by the kernel and
|
||||
the corresponding ADDR is used. If can_addr.j1939.name is not set (== 0),
|
||||
can_addr.j1939.addr is used.
|
||||
If ``can_addr.j1939.name`` is set (!= 0) the NAME is looked up by the kernel and
|
||||
the corresponding ADDR is used. If ``can_addr.j1939.name`` is not set (== 0),
|
||||
``can_addr.j1939.addr`` is used.
|
||||
|
||||
When creating a socket, reasonable defaults are set. Some options can be
|
||||
modified with setsockopt(2) & getsockopt(2).
|
||||
modified with ``setsockopt(2)`` & ``getsockopt(2)``.
|
||||
|
||||
RX path related options:
|
||||
|
||||
- SO_J1939_FILTER - configure array of filters
|
||||
- SO_J1939_PROMISC - disable filters set by bind(2) and connect(2)
|
||||
- ``SO_J1939_FILTER`` - configure array of filters
|
||||
- ``SO_J1939_PROMISC`` - disable filters set by ``bind(2)`` and ``connect(2)``
|
||||
|
||||
By default no broadcast packets can be send or received. To enable sending or
|
||||
receiving broadcast packets use the socket option SO_BROADCAST:
|
||||
receiving broadcast packets use the socket option ``SO_BROADCAST``:
|
||||
|
||||
.. code-block:: C
|
||||
|
||||
|
|
@ -261,26 +261,26 @@ The following diagram illustrates the RX path:
|
|||
+---------------------------+
|
||||
|
||||
TX path related options:
|
||||
SO_J1939_SEND_PRIO - change default send priority for the socket
|
||||
``SO_J1939_SEND_PRIO`` - change default send priority for the socket
|
||||
|
||||
Message Flags during send() and Related System Calls
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
send(2), sendto(2) and sendmsg(2) take a 'flags' argument. Currently
|
||||
``send(2)``, ``sendto(2)`` and ``sendmsg(2)`` take a 'flags' argument. Currently
|
||||
supported flags are:
|
||||
|
||||
* MSG_DONTWAIT, i.e. non-blocking operation.
|
||||
* ``MSG_DONTWAIT``, i.e. non-blocking operation.
|
||||
|
||||
recvmsg(2)
|
||||
^^^^^^^^^^
|
||||
|
||||
In most cases recvmsg(2) is needed if you want to extract more information than
|
||||
recvfrom(2) can provide. For example package priority and timestamp. The
|
||||
In most cases ``recvmsg(2)`` is needed if you want to extract more information than
|
||||
``recvfrom(2)`` can provide. For example package priority and timestamp. The
|
||||
Destination Address, name and packet priority (if applicable) are attached to
|
||||
the msghdr in the recvmsg(2) call. They can be extracted using cmsg(3) macros,
|
||||
with cmsg_level == SOL_J1939 && cmsg_type == SCM_J1939_DEST_ADDR,
|
||||
SCM_J1939_DEST_NAME or SCM_J1939_PRIO. The returned data is a uint8_t for
|
||||
priority and dst_addr, and uint64_t for dst_name.
|
||||
the msghdr in the ``recvmsg(2)`` call. They can be extracted using ``cmsg(3)`` macros,
|
||||
with ``cmsg_level == SOL_J1939 && cmsg_type == SCM_J1939_DEST_ADDR``,
|
||||
``SCM_J1939_DEST_NAME`` or ``SCM_J1939_PRIO``. The returned data is a ``uint8_t`` for
|
||||
``priority`` and ``dst_addr``, and ``uint64_t`` for ``dst_name``.
|
||||
|
||||
.. code-block:: C
|
||||
|
||||
|
|
@ -305,12 +305,12 @@ Dynamic Addressing
|
|||
|
||||
Distinction has to be made between using the claimed address and doing an
|
||||
address claim. To use an already claimed address, one has to fill in the
|
||||
j1939.name member and provide it to bind(2). If the name had claimed an address
|
||||
``j1939.name`` member and provide it to ``bind(2)``. If the name had claimed an address
|
||||
earlier, all further messages being sent will use that address. And the
|
||||
j1939.addr member will be ignored.
|
||||
``j1939.addr`` member will be ignored.
|
||||
|
||||
An exception on this is PGN 0x0ee00. This is the "Address Claim/Cannot Claim
|
||||
Address" message and the kernel will use the j1939.addr member for that PGN if
|
||||
Address" message and the kernel will use the ``j1939.addr`` member for that PGN if
|
||||
necessary.
|
||||
|
||||
To claim an address following code example can be used:
|
||||
|
|
@ -371,12 +371,12 @@ NAME can send packets.
|
|||
|
||||
If another ECU claims the address, the kernel will mark the NAME-SA expired.
|
||||
No socket bound to the NAME can send packets (other than address claims). To
|
||||
claim another address, some socket bound to NAME, must bind(2) again, but with
|
||||
only j1939.addr changed to the new SA, and must then send a valid address claim
|
||||
claim another address, some socket bound to NAME, must ``bind(2)`` again, but with
|
||||
only ``j1939.addr`` changed to the new SA, and must then send a valid address claim
|
||||
packet. This restarts the state machine in the kernel (and any other
|
||||
participant on the bus) for this NAME.
|
||||
|
||||
can-utils also include the jacd tool, so it can be used as code example or as
|
||||
``can-utils`` also include the ``j1939acd`` tool, so it can be used as code example or as
|
||||
default Address Claiming daemon.
|
||||
|
||||
Send Examples
|
||||
|
|
@ -403,8 +403,8 @@ Bind:
|
|||
|
||||
bind(sock, (struct sockaddr *)&baddr, sizeof(baddr));
|
||||
|
||||
Now, the socket 'sock' is bound to the SA 0x20. Since no connect(2) was called,
|
||||
at this point we can use only sendto(2) or sendmsg(2).
|
||||
Now, the socket 'sock' is bound to the SA 0x20. Since no ``connect(2)`` was called,
|
||||
at this point we can use only ``sendto(2)`` or ``sendmsg(2)``.
|
||||
|
||||
Send:
|
||||
|
||||
|
|
@ -414,8 +414,8 @@ Send:
|
|||
.can_family = AF_CAN,
|
||||
.can_addr.j1939 = {
|
||||
.name = J1939_NO_NAME;
|
||||
.pgn = 0x30,
|
||||
.addr = 0x12300,
|
||||
.addr = 0x30,
|
||||
.pgn = 0x12300,
|
||||
},
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -512,9 +512,13 @@ __can_get_echo_skb(struct net_device *dev, unsigned int idx, u8 *len_ptr)
|
|||
*/
|
||||
struct sk_buff *skb = priv->echo_skb[idx];
|
||||
struct canfd_frame *cf = (struct canfd_frame *)skb->data;
|
||||
u8 len = cf->len;
|
||||
|
||||
*len_ptr = len;
|
||||
/* get the real payload length for netdev statistics */
|
||||
if (cf->can_id & CAN_RTR_FLAG)
|
||||
*len_ptr = 0;
|
||||
else
|
||||
*len_ptr = cf->len;
|
||||
|
||||
priv->echo_skb[idx] = NULL;
|
||||
|
||||
return skb;
|
||||
|
|
@ -538,7 +542,11 @@ unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx)
|
|||
if (!skb)
|
||||
return 0;
|
||||
|
||||
netif_rx(skb);
|
||||
skb_get(skb);
|
||||
if (netif_rx(skb) == NET_RX_SUCCESS)
|
||||
dev_consume_skb_any(skb);
|
||||
else
|
||||
dev_kfree_skb_any(skb);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -217,7 +217,7 @@
|
|||
* MX8MP FlexCAN3 03.00.17.01 yes yes no yes yes yes
|
||||
* VF610 FlexCAN3 ? no yes no yes yes? no
|
||||
* LS1021A FlexCAN2 03.00.04.00 no yes no no yes no
|
||||
* LX2160A FlexCAN3 03.00.23.00 no yes no no yes yes
|
||||
* LX2160A FlexCAN3 03.00.23.00 no yes no yes yes yes
|
||||
*
|
||||
* Some SOCs do not have the RX_WARN & TX_WARN interrupt line connected.
|
||||
*/
|
||||
|
|
@ -400,19 +400,19 @@ static struct flexcan_devtype_data fsl_imx8mp_devtype_data = {
|
|||
static const struct flexcan_devtype_data fsl_vf610_devtype_data = {
|
||||
.quirks = FLEXCAN_QUIRK_DISABLE_RXFG | FLEXCAN_QUIRK_ENABLE_EACEN_RRS |
|
||||
FLEXCAN_QUIRK_DISABLE_MECR | FLEXCAN_QUIRK_USE_OFF_TIMESTAMP |
|
||||
FLEXCAN_QUIRK_BROKEN_PERR_STATE,
|
||||
FLEXCAN_QUIRK_BROKEN_PERR_STATE | FLEXCAN_QUIRK_SUPPORT_ECC,
|
||||
};
|
||||
|
||||
static const struct flexcan_devtype_data fsl_ls1021a_r2_devtype_data = {
|
||||
.quirks = FLEXCAN_QUIRK_DISABLE_RXFG | FLEXCAN_QUIRK_ENABLE_EACEN_RRS |
|
||||
FLEXCAN_QUIRK_DISABLE_MECR | FLEXCAN_QUIRK_BROKEN_PERR_STATE |
|
||||
FLEXCAN_QUIRK_USE_OFF_TIMESTAMP,
|
||||
FLEXCAN_QUIRK_BROKEN_PERR_STATE | FLEXCAN_QUIRK_USE_OFF_TIMESTAMP,
|
||||
};
|
||||
|
||||
static const struct flexcan_devtype_data fsl_lx2160a_r1_devtype_data = {
|
||||
.quirks = FLEXCAN_QUIRK_DISABLE_RXFG | FLEXCAN_QUIRK_ENABLE_EACEN_RRS |
|
||||
FLEXCAN_QUIRK_DISABLE_MECR | FLEXCAN_QUIRK_BROKEN_PERR_STATE |
|
||||
FLEXCAN_QUIRK_USE_OFF_TIMESTAMP | FLEXCAN_QUIRK_SUPPORT_FD,
|
||||
FLEXCAN_QUIRK_USE_OFF_TIMESTAMP | FLEXCAN_QUIRK_SUPPORT_FD |
|
||||
FLEXCAN_QUIRK_SUPPORT_ECC,
|
||||
};
|
||||
|
||||
static const struct can_bittiming_const flexcan_bittiming_const = {
|
||||
|
|
@ -2062,6 +2062,8 @@ static int flexcan_remove(struct platform_device *pdev)
|
|||
{
|
||||
struct net_device *dev = platform_get_drvdata(pdev);
|
||||
|
||||
device_set_wakeup_enable(&pdev->dev, false);
|
||||
device_set_wakeup_capable(&pdev->dev, false);
|
||||
unregister_flexcandev(dev);
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
free_candev(dev);
|
||||
|
|
|
|||
|
|
@ -262,8 +262,7 @@ static int pucan_handle_can_rx(struct peak_canfd_priv *priv,
|
|||
cf_len = get_can_dlc(pucan_msg_get_dlc(msg));
|
||||
|
||||
/* if this frame is an echo, */
|
||||
if ((rx_msg_flags & PUCAN_MSG_LOOPED_BACK) &&
|
||||
!(rx_msg_flags & PUCAN_MSG_SELF_RECEIVE)) {
|
||||
if (rx_msg_flags & PUCAN_MSG_LOOPED_BACK) {
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&priv->echo_lock, flags);
|
||||
|
|
@ -277,7 +276,13 @@ static int pucan_handle_can_rx(struct peak_canfd_priv *priv,
|
|||
netif_wake_queue(priv->ndev);
|
||||
|
||||
spin_unlock_irqrestore(&priv->echo_lock, flags);
|
||||
return 0;
|
||||
|
||||
/* if this frame is only an echo, stop here. Otherwise,
|
||||
* continue to push this application self-received frame into
|
||||
* its own rx queue.
|
||||
*/
|
||||
if (!(rx_msg_flags & PUCAN_MSG_SELF_RECEIVE))
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* otherwise, it should be pushed into rx fifo */
|
||||
|
|
|
|||
|
|
@ -245,7 +245,7 @@ int can_rx_offload_queue_sorted(struct can_rx_offload *offload,
|
|||
|
||||
if (skb_queue_len(&offload->skb_queue) >
|
||||
offload->skb_queue_len_max) {
|
||||
kfree_skb(skb);
|
||||
dev_kfree_skb_any(skb);
|
||||
return -ENOBUFS;
|
||||
}
|
||||
|
||||
|
|
@ -290,7 +290,7 @@ int can_rx_offload_queue_tail(struct can_rx_offload *offload,
|
|||
{
|
||||
if (skb_queue_len(&offload->skb_queue) >
|
||||
offload->skb_queue_len_max) {
|
||||
kfree_skb(skb);
|
||||
dev_kfree_skb_any(skb);
|
||||
return -ENOBUFS;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -75,11 +75,11 @@ static const char *__mcp251xfd_get_model_str(enum mcp251xfd_model model)
|
|||
{
|
||||
switch (model) {
|
||||
case MCP251XFD_MODEL_MCP2517FD:
|
||||
return "MCP2517FD"; break;
|
||||
return "MCP2517FD";
|
||||
case MCP251XFD_MODEL_MCP2518FD:
|
||||
return "MCP2518FD"; break;
|
||||
return "MCP2518FD";
|
||||
case MCP251XFD_MODEL_MCP251XFD:
|
||||
return "MCP251xFD"; break;
|
||||
return "MCP251xFD";
|
||||
}
|
||||
|
||||
return "<unknown>";
|
||||
|
|
@ -95,21 +95,21 @@ static const char *mcp251xfd_get_mode_str(const u8 mode)
|
|||
{
|
||||
switch (mode) {
|
||||
case MCP251XFD_REG_CON_MODE_MIXED:
|
||||
return "Mixed (CAN FD/CAN 2.0)"; break;
|
||||
return "Mixed (CAN FD/CAN 2.0)";
|
||||
case MCP251XFD_REG_CON_MODE_SLEEP:
|
||||
return "Sleep"; break;
|
||||
return "Sleep";
|
||||
case MCP251XFD_REG_CON_MODE_INT_LOOPBACK:
|
||||
return "Internal Loopback"; break;
|
||||
return "Internal Loopback";
|
||||
case MCP251XFD_REG_CON_MODE_LISTENONLY:
|
||||
return "Listen Only"; break;
|
||||
return "Listen Only";
|
||||
case MCP251XFD_REG_CON_MODE_CONFIG:
|
||||
return "Configuration"; break;
|
||||
return "Configuration";
|
||||
case MCP251XFD_REG_CON_MODE_EXT_LOOPBACK:
|
||||
return "External Loopback"; break;
|
||||
return "External Loopback";
|
||||
case MCP251XFD_REG_CON_MODE_CAN2_0:
|
||||
return "CAN 2.0"; break;
|
||||
return "CAN 2.0";
|
||||
case MCP251XFD_REG_CON_MODE_RESTRICTED:
|
||||
return "Restricted Operation"; break;
|
||||
return "Restricted Operation";
|
||||
}
|
||||
|
||||
return "<unknown>";
|
||||
|
|
|
|||
|
|
@ -173,7 +173,7 @@ mcp251xfd_regmap_nocrc_read(void *context,
|
|||
memcpy(&buf_tx->cmd, reg, sizeof(buf_tx->cmd));
|
||||
if (MCP251XFD_SANITIZE_SPI)
|
||||
memset(buf_tx->data, 0x0, val_len);
|
||||
};
|
||||
}
|
||||
|
||||
err = spi_sync(spi, &msg);
|
||||
if (err)
|
||||
|
|
@ -330,17 +330,17 @@ mcp251xfd_regmap_crc_read(void *context,
|
|||
goto out;
|
||||
}
|
||||
|
||||
netdev_dbg(priv->ndev,
|
||||
"CRC read error at address 0x%04x (length=%zd, data=%*ph, CRC=0x%04x) retrying.\n",
|
||||
reg, val_len, (int)val_len, buf_rx->data,
|
||||
get_unaligned_be16(buf_rx->data + val_len));
|
||||
netdev_info(priv->ndev,
|
||||
"CRC read error at address 0x%04x (length=%zd, data=%*ph, CRC=0x%04x) retrying.\n",
|
||||
reg, val_len, (int)val_len, buf_rx->data,
|
||||
get_unaligned_be16(buf_rx->data + val_len));
|
||||
}
|
||||
|
||||
if (err) {
|
||||
netdev_info(priv->ndev,
|
||||
"CRC read error at address 0x%04x (length=%zd, data=%*ph, CRC=0x%04x).\n",
|
||||
reg, val_len, (int)val_len, buf_rx->data,
|
||||
get_unaligned_be16(buf_rx->data + val_len));
|
||||
netdev_err(priv->ndev,
|
||||
"CRC read error at address 0x%04x (length=%zd, data=%*ph, CRC=0x%04x).\n",
|
||||
reg, val_len, (int)val_len, buf_rx->data,
|
||||
get_unaligned_be16(buf_rx->data + val_len));
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -933,7 +933,7 @@ static int ti_hecc_probe(struct platform_device *pdev)
|
|||
err = clk_prepare_enable(priv->clk);
|
||||
if (err) {
|
||||
dev_err(&pdev->dev, "clk_prepare_enable() failed\n");
|
||||
goto probe_exit_clk;
|
||||
goto probe_exit_release_clk;
|
||||
}
|
||||
|
||||
priv->offload.mailbox_read = ti_hecc_mailbox_read;
|
||||
|
|
@ -942,7 +942,7 @@ static int ti_hecc_probe(struct platform_device *pdev)
|
|||
err = can_rx_offload_add_timestamp(ndev, &priv->offload);
|
||||
if (err) {
|
||||
dev_err(&pdev->dev, "can_rx_offload_add_timestamp() failed\n");
|
||||
goto probe_exit_clk;
|
||||
goto probe_exit_disable_clk;
|
||||
}
|
||||
|
||||
err = register_candev(ndev);
|
||||
|
|
@ -960,7 +960,9 @@ static int ti_hecc_probe(struct platform_device *pdev)
|
|||
|
||||
probe_exit_offload:
|
||||
can_rx_offload_del(&priv->offload);
|
||||
probe_exit_clk:
|
||||
probe_exit_disable_clk:
|
||||
clk_disable_unprepare(priv->clk);
|
||||
probe_exit_release_clk:
|
||||
clk_put(priv->clk);
|
||||
probe_exit_candev:
|
||||
free_candev(ndev);
|
||||
|
|
|
|||
|
|
@ -130,14 +130,55 @@ void peak_usb_get_ts_time(struct peak_time_ref *time_ref, u32 ts, ktime_t *time)
|
|||
/* protect from getting time before setting now */
|
||||
if (ktime_to_ns(time_ref->tv_host)) {
|
||||
u64 delta_us;
|
||||
s64 delta_ts = 0;
|
||||
|
||||
delta_us = ts - time_ref->ts_dev_2;
|
||||
if (ts < time_ref->ts_dev_2)
|
||||
delta_us &= (1 << time_ref->adapter->ts_used_bits) - 1;
|
||||
/* General case: dev_ts_1 < dev_ts_2 < ts, with:
|
||||
*
|
||||
* - dev_ts_1 = previous sync timestamp
|
||||
* - dev_ts_2 = last sync timestamp
|
||||
* - ts = event timestamp
|
||||
* - ts_period = known sync period (theoretical)
|
||||
* ~ dev_ts2 - dev_ts1
|
||||
* *but*:
|
||||
*
|
||||
* - time counters wrap (see adapter->ts_used_bits)
|
||||
* - sometimes, dev_ts_1 < ts < dev_ts2
|
||||
*
|
||||
* "normal" case (sync time counters increase):
|
||||
* must take into account case when ts wraps (tsw)
|
||||
*
|
||||
* < ts_period > < >
|
||||
* | | |
|
||||
* ---+--------+----+-------0-+--+-->
|
||||
* ts_dev_1 | ts_dev_2 |
|
||||
* ts tsw
|
||||
*/
|
||||
if (time_ref->ts_dev_1 < time_ref->ts_dev_2) {
|
||||
/* case when event time (tsw) wraps */
|
||||
if (ts < time_ref->ts_dev_1)
|
||||
delta_ts = 1 << time_ref->adapter->ts_used_bits;
|
||||
|
||||
delta_us += time_ref->ts_total;
|
||||
/* Otherwise, sync time counter (ts_dev_2) has wrapped:
|
||||
* handle case when event time (tsn) hasn't.
|
||||
*
|
||||
* < ts_period > < >
|
||||
* | | |
|
||||
* ---+--------+--0-+---------+--+-->
|
||||
* ts_dev_1 | ts_dev_2 |
|
||||
* tsn ts
|
||||
*/
|
||||
} else if (time_ref->ts_dev_1 < ts) {
|
||||
delta_ts = -(1 << time_ref->adapter->ts_used_bits);
|
||||
}
|
||||
|
||||
delta_us *= time_ref->adapter->us_per_ts_scale;
|
||||
/* add delay between last sync and event timestamps */
|
||||
delta_ts += (signed int)(ts - time_ref->ts_dev_2);
|
||||
|
||||
/* add time from beginning to last sync */
|
||||
delta_ts += time_ref->ts_total;
|
||||
|
||||
/* convert ticks number into microseconds */
|
||||
delta_us = delta_ts * time_ref->adapter->us_per_ts_scale;
|
||||
delta_us >>= time_ref->adapter->us_per_ts_shift;
|
||||
|
||||
*time = ktime_add_us(time_ref->tv_host_0, delta_us);
|
||||
|
|
|
|||
|
|
@ -468,12 +468,18 @@ static int pcan_usb_fd_decode_canmsg(struct pcan_usb_fd_if *usb_if,
|
|||
struct pucan_msg *rx_msg)
|
||||
{
|
||||
struct pucan_rx_msg *rm = (struct pucan_rx_msg *)rx_msg;
|
||||
struct peak_usb_device *dev = usb_if->dev[pucan_msg_get_channel(rm)];
|
||||
struct net_device *netdev = dev->netdev;
|
||||
struct peak_usb_device *dev;
|
||||
struct net_device *netdev;
|
||||
struct canfd_frame *cfd;
|
||||
struct sk_buff *skb;
|
||||
const u16 rx_msg_flags = le16_to_cpu(rm->flags);
|
||||
|
||||
if (pucan_msg_get_channel(rm) >= ARRAY_SIZE(usb_if->dev))
|
||||
return -ENOMEM;
|
||||
|
||||
dev = usb_if->dev[pucan_msg_get_channel(rm)];
|
||||
netdev = dev->netdev;
|
||||
|
||||
if (rx_msg_flags & PUCAN_MSG_EXT_DATA_LEN) {
|
||||
/* CANFD frame case */
|
||||
skb = alloc_canfd_skb(netdev, &cfd);
|
||||
|
|
@ -519,15 +525,21 @@ static int pcan_usb_fd_decode_status(struct pcan_usb_fd_if *usb_if,
|
|||
struct pucan_msg *rx_msg)
|
||||
{
|
||||
struct pucan_status_msg *sm = (struct pucan_status_msg *)rx_msg;
|
||||
struct peak_usb_device *dev = usb_if->dev[pucan_stmsg_get_channel(sm)];
|
||||
struct pcan_usb_fd_device *pdev =
|
||||
container_of(dev, struct pcan_usb_fd_device, dev);
|
||||
struct pcan_usb_fd_device *pdev;
|
||||
enum can_state new_state = CAN_STATE_ERROR_ACTIVE;
|
||||
enum can_state rx_state, tx_state;
|
||||
struct net_device *netdev = dev->netdev;
|
||||
struct peak_usb_device *dev;
|
||||
struct net_device *netdev;
|
||||
struct can_frame *cf;
|
||||
struct sk_buff *skb;
|
||||
|
||||
if (pucan_stmsg_get_channel(sm) >= ARRAY_SIZE(usb_if->dev))
|
||||
return -ENOMEM;
|
||||
|
||||
dev = usb_if->dev[pucan_stmsg_get_channel(sm)];
|
||||
pdev = container_of(dev, struct pcan_usb_fd_device, dev);
|
||||
netdev = dev->netdev;
|
||||
|
||||
/* nothing should be sent while in BUS_OFF state */
|
||||
if (dev->can.state == CAN_STATE_BUS_OFF)
|
||||
return 0;
|
||||
|
|
@ -579,9 +591,14 @@ static int pcan_usb_fd_decode_error(struct pcan_usb_fd_if *usb_if,
|
|||
struct pucan_msg *rx_msg)
|
||||
{
|
||||
struct pucan_error_msg *er = (struct pucan_error_msg *)rx_msg;
|
||||
struct peak_usb_device *dev = usb_if->dev[pucan_ermsg_get_channel(er)];
|
||||
struct pcan_usb_fd_device *pdev =
|
||||
container_of(dev, struct pcan_usb_fd_device, dev);
|
||||
struct pcan_usb_fd_device *pdev;
|
||||
struct peak_usb_device *dev;
|
||||
|
||||
if (pucan_ermsg_get_channel(er) >= ARRAY_SIZE(usb_if->dev))
|
||||
return -EINVAL;
|
||||
|
||||
dev = usb_if->dev[pucan_ermsg_get_channel(er)];
|
||||
pdev = container_of(dev, struct pcan_usb_fd_device, dev);
|
||||
|
||||
/* keep a trace of tx and rx error counters for later use */
|
||||
pdev->bec.txerr = er->tx_err_cnt;
|
||||
|
|
@ -595,11 +612,17 @@ static int pcan_usb_fd_decode_overrun(struct pcan_usb_fd_if *usb_if,
|
|||
struct pucan_msg *rx_msg)
|
||||
{
|
||||
struct pcan_ufd_ovr_msg *ov = (struct pcan_ufd_ovr_msg *)rx_msg;
|
||||
struct peak_usb_device *dev = usb_if->dev[pufd_omsg_get_channel(ov)];
|
||||
struct net_device *netdev = dev->netdev;
|
||||
struct peak_usb_device *dev;
|
||||
struct net_device *netdev;
|
||||
struct can_frame *cf;
|
||||
struct sk_buff *skb;
|
||||
|
||||
if (pufd_omsg_get_channel(ov) >= ARRAY_SIZE(usb_if->dev))
|
||||
return -EINVAL;
|
||||
|
||||
dev = usb_if->dev[pufd_omsg_get_channel(ov)];
|
||||
netdev = dev->netdev;
|
||||
|
||||
/* allocate an skb to store the error frame */
|
||||
skb = alloc_can_err_skb(netdev, &cf);
|
||||
if (!skb)
|
||||
|
|
@ -716,6 +739,9 @@ static int pcan_usb_fd_encode_msg(struct peak_usb_device *dev,
|
|||
u16 tx_msg_size, tx_msg_flags;
|
||||
u8 can_dlc;
|
||||
|
||||
if (cfd->len > CANFD_MAX_DLEN)
|
||||
return -EINVAL;
|
||||
|
||||
tx_msg_size = ALIGN(sizeof(struct pucan_tx_msg) + cfd->len, 4);
|
||||
tx_msg->size = cpu_to_le16(tx_msg_size);
|
||||
tx_msg->type = cpu_to_le16(PUCAN_MSG_CAN_TX);
|
||||
|
|
|
|||
|
|
@ -1395,7 +1395,7 @@ static int xcan_open(struct net_device *ndev)
|
|||
if (ret < 0) {
|
||||
netdev_err(ndev, "%s: pm_runtime_get failed(%d)\n",
|
||||
__func__, ret);
|
||||
return ret;
|
||||
goto err;
|
||||
}
|
||||
|
||||
ret = request_irq(ndev->irq, xcan_interrupt, priv->irq_flags,
|
||||
|
|
@ -1479,6 +1479,7 @@ static int xcan_get_berr_counter(const struct net_device *ndev,
|
|||
if (ret < 0) {
|
||||
netdev_err(ndev, "%s: pm_runtime_get failed(%d)\n",
|
||||
__func__, ret);
|
||||
pm_runtime_put(priv->dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -1793,7 +1794,7 @@ static int xcan_probe(struct platform_device *pdev)
|
|||
if (ret < 0) {
|
||||
netdev_err(ndev, "%s: pm_runtime_get failed(%d)\n",
|
||||
__func__, ret);
|
||||
goto err_pmdisable;
|
||||
goto err_disableclks;
|
||||
}
|
||||
|
||||
if (priv->read_reg(priv, XCAN_SR_OFFSET) != XCAN_SR_CONFIG_MASK) {
|
||||
|
|
@ -1828,7 +1829,6 @@ static int xcan_probe(struct platform_device *pdev)
|
|||
|
||||
err_disableclks:
|
||||
pm_runtime_put(priv->dev);
|
||||
err_pmdisable:
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
err_free:
|
||||
free_candev(ndev);
|
||||
|
|
|
|||
|
|
@ -61,21 +61,17 @@ static inline void can_skb_set_owner(struct sk_buff *skb, struct sock *sk)
|
|||
*/
|
||||
static inline struct sk_buff *can_create_echo_skb(struct sk_buff *skb)
|
||||
{
|
||||
if (skb_shared(skb)) {
|
||||
struct sk_buff *nskb = skb_clone(skb, GFP_ATOMIC);
|
||||
struct sk_buff *nskb;
|
||||
|
||||
if (likely(nskb)) {
|
||||
can_skb_set_owner(nskb, skb->sk);
|
||||
consume_skb(skb);
|
||||
return nskb;
|
||||
} else {
|
||||
kfree_skb(skb);
|
||||
return NULL;
|
||||
}
|
||||
nskb = skb_clone(skb, GFP_ATOMIC);
|
||||
if (unlikely(!nskb)) {
|
||||
kfree_skb(skb);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* we can assume to have an unshared skb with proper owner */
|
||||
return skb;
|
||||
can_skb_set_owner(nskb, skb->sk);
|
||||
consume_skb(skb);
|
||||
return nskb;
|
||||
}
|
||||
|
||||
#endif /* !_CAN_SKB_H */
|
||||
|
|
|
|||
|
|
@ -62,8 +62,9 @@ config CAN_ISOTP
|
|||
communication between CAN nodes via two defined CAN Identifiers.
|
||||
As CAN frames can only transport a small amount of data bytes
|
||||
(max. 8 bytes for 'classic' CAN and max. 64 bytes for CAN FD) this
|
||||
segmentation is needed to transport longer PDUs as needed e.g. for
|
||||
vehicle diagnosis (UDS, ISO 14229) or IP-over-CAN traffic.
|
||||
segmentation is needed to transport longer Protocol Data Units (PDU)
|
||||
as needed e.g. for vehicle diagnosis (UDS, ISO 14229) or IP-over-CAN
|
||||
traffic.
|
||||
This protocol driver implements data transfers according to
|
||||
ISO 15765-2:2016 for 'classic' CAN and CAN FD frame types.
|
||||
If you want to perform automotive vehicle diagnostic services (UDS),
|
||||
|
|
|
|||
|
|
@ -252,14 +252,16 @@ static void isotp_rcv_skb(struct sk_buff *skb, struct sock *sk)
|
|||
|
||||
static u8 padlen(u8 datalen)
|
||||
{
|
||||
const u8 plen[] = {8, 8, 8, 8, 8, 8, 8, 8, 8, /* 0 - 8 */
|
||||
12, 12, 12, 12, /* 9 - 12 */
|
||||
16, 16, 16, 16, /* 13 - 16 */
|
||||
20, 20, 20, 20, /* 17 - 20 */
|
||||
24, 24, 24, 24, /* 21 - 24 */
|
||||
32, 32, 32, 32, 32, 32, 32, 32, /* 25 - 32 */
|
||||
48, 48, 48, 48, 48, 48, 48, 48, /* 33 - 40 */
|
||||
48, 48, 48, 48, 48, 48, 48, 48}; /* 41 - 48 */
|
||||
static const u8 plen[] = {
|
||||
8, 8, 8, 8, 8, 8, 8, 8, 8, /* 0 - 8 */
|
||||
12, 12, 12, 12, /* 9 - 12 */
|
||||
16, 16, 16, 16, /* 13 - 16 */
|
||||
20, 20, 20, 20, /* 17 - 20 */
|
||||
24, 24, 24, 24, /* 21 - 24 */
|
||||
32, 32, 32, 32, 32, 32, 32, 32, /* 25 - 32 */
|
||||
48, 48, 48, 48, 48, 48, 48, 48, /* 33 - 40 */
|
||||
48, 48, 48, 48, 48, 48, 48, 48 /* 41 - 48 */
|
||||
};
|
||||
|
||||
if (datalen > 48)
|
||||
return 64;
|
||||
|
|
@ -569,10 +571,6 @@ static int isotp_rcv_cf(struct sock *sk, struct canfd_frame *cf, int ae,
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* no creation of flow control frames */
|
||||
if (so->opt.flags & CAN_ISOTP_LISTEN_MODE)
|
||||
return 0;
|
||||
|
||||
/* perform blocksize handling, if enabled */
|
||||
if (!so->rxfc.bs || ++so->rx.bs < so->rxfc.bs) {
|
||||
/* start rx timeout watchdog */
|
||||
|
|
@ -581,6 +579,10 @@ static int isotp_rcv_cf(struct sock *sk, struct canfd_frame *cf, int ae,
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* no creation of flow control frames */
|
||||
if (so->opt.flags & CAN_ISOTP_LISTEN_MODE)
|
||||
return 0;
|
||||
|
||||
/* we reached the specified blocksize so->rxfc.bs */
|
||||
isotp_send_fc(sk, ae, ISOTP_FC_CTS);
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -475,6 +475,12 @@ static int j1939_sk_bind(struct socket *sock, struct sockaddr *uaddr, int len)
|
|||
goto out_release_sock;
|
||||
}
|
||||
|
||||
if (!(ndev->flags & IFF_UP)) {
|
||||
dev_put(ndev);
|
||||
ret = -ENETDOWN;
|
||||
goto out_release_sock;
|
||||
}
|
||||
|
||||
priv = j1939_netdev_start(ndev);
|
||||
dev_put(ndev);
|
||||
if (IS_ERR(priv)) {
|
||||
|
|
|
|||
|
|
@ -462,6 +462,9 @@ void can_init_proc(struct net *net)
|
|||
*/
|
||||
void can_remove_proc(struct net *net)
|
||||
{
|
||||
if (!net->can.proc_dir)
|
||||
return;
|
||||
|
||||
if (net->can.pde_stats)
|
||||
remove_proc_entry(CAN_PROC_STATS, net->can.proc_dir);
|
||||
|
||||
|
|
@ -486,6 +489,5 @@ void can_remove_proc(struct net *net)
|
|||
if (net->can.pde_rcvlist_sff)
|
||||
remove_proc_entry(CAN_PROC_RCVLIST_SFF, net->can.proc_dir);
|
||||
|
||||
if (net->can.proc_dir)
|
||||
remove_proc_entry("can", net->proc_net);
|
||||
remove_proc_entry("can", net->proc_net);
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue