linux-can-next-for-4.8-20160617
-----BEGIN PGP SIGNATURE----- iQEcBAABCgAGBQJXZAIqAAoJED07qiWsqSVqW0YH/RMgC6CDlJUtHr7+B8YLpi0e BZOzAHH7mQdP+Z2kIXZp8Dnziq5G8heWNjRwTMPLHvOel+oms+0ZK6VY/kJYArdb ViGGgi/gQ334JGqJYi2utkyIIIRH7ZxwcblF1aaaFVfFy7tZMVuppIWVzR/V0Gje /5FftT1f04/6iumEq4es+Jb0OC9azoebSs1DUZTIvYOz3XrnCbB1FdmDN+a3xZKC Qyav6QVnp/m2InzGSN+Kd/W++EP6YckdBp/++2hizsOvSIOfe8GRqkc0r7fLbfZ8 rucDJNi+GrLat4wNza4t3FKf3rBenBFzii14OEUTE0JgpY90fGUF3n/i0duaB/k= =90Ns -----END PGP SIGNATURE----- Merge tag 'linux-can-next-for-4.8-20160617' of git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can-next Marc Kleine-Budde says: ==================== pull-request: can-next 2016-06-17 this is a pull request of 14 patches for net-next/master. Geert Uytterhoeven contributes a patch that adds a file patterns for CAN device tree bindings to MAINTAINERS. A patch by Alexander Aring fixes warnings when building without proc support. A patch by me improves the sample point calculation. Marek Vasut's patch converts the slcan driver to use CAN_MTU. A patch by William Breathitt Gray converts the tscan1 driver to use module_isa_driver. Two patches by Maximilian Schneider for the gs_usb driver fix coding style and add support for set_phys_id callback. 5 patches by Oliver Hartkopp add support for CANFD to the bcm. And finally two patches by Ramesh Shanmugasundaram, which add support for the rcar_canfd driver. ==================== Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller
Коммит
6762ef35e0
|
|
@ -0,0 +1,89 @@
|
|||
Renesas R-Car CAN FD controller Device Tree Bindings
|
||||
----------------------------------------------------
|
||||
|
||||
Required properties:
|
||||
- compatible: Must contain one or more of the following:
|
||||
- "renesas,rcar-gen3-canfd" for R-Car Gen3 compatible controller.
|
||||
- "renesas,r8a7795-canfd" for R8A7795 (R-Car H3) compatible controller.
|
||||
|
||||
When compatible with the generic version, nodes must list the
|
||||
SoC-specific version corresponding to the platform first, followed by the
|
||||
family-specific and/or generic versions.
|
||||
|
||||
- reg: physical base address and size of the R-Car CAN FD register map.
|
||||
- interrupts: interrupt specifier for the Global & Channel interrupts
|
||||
- clocks: phandles and clock specifiers for 3 clock inputs.
|
||||
- clock-names: 3 clock input name strings: "fck", "canfd", "can_clk".
|
||||
- pinctrl-0: pin control group to be used for this controller.
|
||||
- pinctrl-names: must be "default".
|
||||
|
||||
Required child nodes:
|
||||
The controller supports two channels and each is represented as a child node.
|
||||
The name of the child nodes are "channel0" and "channel1" respectively. Each
|
||||
child node supports the "status" property only, which is used to
|
||||
enable/disable the respective channel.
|
||||
|
||||
Required properties for "renesas,r8a7795-canfd" compatible:
|
||||
In R8A7795 SoC, canfd clock is a div6 clock and can be used by both CAN
|
||||
and CAN FD controller at the same time. It needs to be scaled to maximum
|
||||
frequency if any of these controllers use it. This is done using the
|
||||
below properties.
|
||||
|
||||
- assigned-clocks: phandle of canfd clock.
|
||||
- assigned-clock-rates: maximum frequency of this clock.
|
||||
|
||||
Example
|
||||
-------
|
||||
|
||||
SoC common .dtsi file:
|
||||
|
||||
canfd: can@e66c0000 {
|
||||
compatible = "renesas,r8a7795-canfd",
|
||||
"renesas,rcar-gen3-canfd";
|
||||
reg = <0 0xe66c0000 0 0x8000>;
|
||||
interrupts = <GIC_SPI 29 IRQ_TYPE_LEVEL_HIGH>,
|
||||
<GIC_SPI 30 IRQ_TYPE_LEVEL_HIGH>;
|
||||
clocks = <&cpg CPG_MOD 914>,
|
||||
<&cpg CPG_CORE R8A7795_CLK_CANFD>,
|
||||
<&can_clk>;
|
||||
clock-names = "fck", "canfd", "can_clk";
|
||||
assigned-clocks = <&cpg CPG_CORE R8A7795_CLK_CANFD>;
|
||||
assigned-clock-rates = <40000000>;
|
||||
power-domains = <&cpg>;
|
||||
status = "disabled";
|
||||
|
||||
channel0 {
|
||||
status = "disabled";
|
||||
};
|
||||
|
||||
channel1 {
|
||||
status = "disabled";
|
||||
};
|
||||
};
|
||||
|
||||
Board specific .dts file:
|
||||
|
||||
E.g. below enables Channel 1 alone in the board.
|
||||
|
||||
&canfd {
|
||||
pinctrl-0 = <&canfd1_pins>;
|
||||
pinctrl-names = "default";
|
||||
status = "okay";
|
||||
|
||||
channel1 {
|
||||
status = "okay";
|
||||
};
|
||||
};
|
||||
|
||||
E.g. below enables Channel 0 alone in the board using External clock
|
||||
as fCAN clock.
|
||||
|
||||
&canfd {
|
||||
pinctrl-0 = <&canfd0_pins &can_clk_pins>;
|
||||
pinctrl-names = "default";
|
||||
status = "okay";
|
||||
|
||||
channel0 {
|
||||
status = "okay";
|
||||
};
|
||||
};
|
||||
|
|
@ -31,6 +31,7 @@ This file contains
|
|||
4.2.4 Broadcast Manager message sequence transmission
|
||||
4.2.5 Broadcast Manager receive filter timers
|
||||
4.2.6 Broadcast Manager multiplex message receive filter
|
||||
4.2.7 Broadcast Manager CAN FD support
|
||||
4.3 connected transport protocols (SOCK_SEQPACKET)
|
||||
4.4 unconnected transport protocols (SOCK_DGRAM)
|
||||
|
||||
|
|
@ -799,7 +800,7 @@ solution for a couple of reasons:
|
|||
} mytxmsg;
|
||||
|
||||
(..)
|
||||
mytxmsg.nframes = 4;
|
||||
mytxmsg.msg_head.nframes = 4;
|
||||
(..)
|
||||
|
||||
write(s, &mytxmsg, sizeof(mytxmsg));
|
||||
|
|
@ -852,6 +853,28 @@ solution for a couple of reasons:
|
|||
|
||||
write(s, &msg, sizeof(msg));
|
||||
|
||||
4.2.7 Broadcast Manager CAN FD support
|
||||
|
||||
The programming API of the CAN_BCM depends on struct can_frame which is
|
||||
given as array directly behind the bcm_msg_head structure. To follow this
|
||||
schema for the CAN FD frames a new flag 'CAN_FD_FRAME' in the bcm_msg_head
|
||||
flags indicates that the concatenated CAN frame structures behind the
|
||||
bcm_msg_head are defined as struct canfd_frame.
|
||||
|
||||
struct {
|
||||
struct bcm_msg_head msg_head;
|
||||
struct canfd_frame frame[5];
|
||||
} msg;
|
||||
|
||||
msg.msg_head.opcode = RX_SETUP;
|
||||
msg.msg_head.can_id = 0x42;
|
||||
msg.msg_head.flags = CAN_FD_FRAME;
|
||||
msg.msg_head.nframes = 5;
|
||||
(..)
|
||||
|
||||
When using CAN FD frames for multiplex filtering the MUX mask is still
|
||||
expected in the first 64 bit of the struct canfd_frame data section.
|
||||
|
||||
4.3 connected transport protocols (SOCK_SEQPACKET)
|
||||
4.4 unconnected transport protocols (SOCK_DGRAM)
|
||||
|
||||
|
|
|
|||
|
|
@ -2814,6 +2814,7 @@ W: https://github.com/linux-can
|
|||
T: git git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can.git
|
||||
T: git git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can-next.git
|
||||
S: Maintained
|
||||
F: Documentation/devicetree/bindings/net/can/
|
||||
F: drivers/net/can/
|
||||
F: include/linux/can/dev.h
|
||||
F: include/linux/can/platform/
|
||||
|
|
|
|||
|
|
@ -104,16 +104,6 @@ config CAN_JANZ_ICAN3
|
|||
This driver can also be built as a module. If so, the module will be
|
||||
called janz-ican3.ko.
|
||||
|
||||
config CAN_RCAR
|
||||
tristate "Renesas R-Car CAN controller"
|
||||
depends on ARCH_RENESAS || ARM
|
||||
---help---
|
||||
Say Y here if you want to use CAN controller found on Renesas R-Car
|
||||
SoCs.
|
||||
|
||||
To compile this driver as a module, choose M here: the module will
|
||||
be called rcar_can.
|
||||
|
||||
config CAN_SUN4I
|
||||
tristate "Allwinner A10 CAN controller"
|
||||
depends on MACH_SUN4I || MACH_SUN7I || COMPILE_TEST
|
||||
|
|
@ -152,6 +142,7 @@ source "drivers/net/can/cc770/Kconfig"
|
|||
source "drivers/net/can/ifi_canfd/Kconfig"
|
||||
source "drivers/net/can/m_can/Kconfig"
|
||||
source "drivers/net/can/mscan/Kconfig"
|
||||
source "drivers/net/can/rcar/Kconfig"
|
||||
source "drivers/net/can/sja1000/Kconfig"
|
||||
source "drivers/net/can/softing/Kconfig"
|
||||
source "drivers/net/can/spi/Kconfig"
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ can-dev-y := dev.o
|
|||
|
||||
can-dev-$(CONFIG_CAN_LEDS) += led.o
|
||||
|
||||
obj-y += rcar/
|
||||
obj-y += spi/
|
||||
obj-y += usb/
|
||||
obj-y += softing/
|
||||
|
|
@ -24,7 +25,6 @@ obj-$(CONFIG_CAN_IFI_CANFD) += ifi_canfd/
|
|||
obj-$(CONFIG_CAN_JANZ_ICAN3) += janz-ican3.o
|
||||
obj-$(CONFIG_CAN_MSCAN) += mscan/
|
||||
obj-$(CONFIG_CAN_M_CAN) += m_can/
|
||||
obj-$(CONFIG_CAN_RCAR) += rcar_can.o
|
||||
obj-$(CONFIG_CAN_SJA1000) += sja1000/
|
||||
obj-$(CONFIG_CAN_SUN4I) += sun4i_can.o
|
||||
obj-$(CONFIG_CAN_TI_HECC) += ti_hecc.o
|
||||
|
|
|
|||
|
|
@ -69,6 +69,7 @@ EXPORT_SYMBOL_GPL(can_len2dlc);
|
|||
|
||||
#ifdef CONFIG_CAN_CALC_BITTIMING
|
||||
#define CAN_CALC_MAX_ERROR 50 /* in one-tenth of a percent */
|
||||
#define CAN_CALC_SYNC_SEG 1
|
||||
|
||||
/*
|
||||
* Bit-timing calculation derived from:
|
||||
|
|
@ -83,98 +84,126 @@ EXPORT_SYMBOL_GPL(can_len2dlc);
|
|||
* registers of the CAN controller. You can find more information
|
||||
* in the header file linux/can/netlink.h.
|
||||
*/
|
||||
static int can_update_spt(const struct can_bittiming_const *btc,
|
||||
int sampl_pt, int tseg, int *tseg1, int *tseg2)
|
||||
static int can_update_sample_point(const struct can_bittiming_const *btc,
|
||||
unsigned int sample_point_nominal, unsigned int tseg,
|
||||
unsigned int *tseg1_ptr, unsigned int *tseg2_ptr,
|
||||
unsigned int *sample_point_error_ptr)
|
||||
{
|
||||
*tseg2 = tseg + 1 - (sampl_pt * (tseg + 1)) / 1000;
|
||||
if (*tseg2 < btc->tseg2_min)
|
||||
*tseg2 = btc->tseg2_min;
|
||||
if (*tseg2 > btc->tseg2_max)
|
||||
*tseg2 = btc->tseg2_max;
|
||||
*tseg1 = tseg - *tseg2;
|
||||
if (*tseg1 > btc->tseg1_max) {
|
||||
*tseg1 = btc->tseg1_max;
|
||||
*tseg2 = tseg - *tseg1;
|
||||
unsigned int sample_point_error, best_sample_point_error = UINT_MAX;
|
||||
unsigned int sample_point, best_sample_point = 0;
|
||||
unsigned int tseg1, tseg2;
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= 1; i++) {
|
||||
tseg2 = tseg + CAN_CALC_SYNC_SEG - (sample_point_nominal * (tseg + CAN_CALC_SYNC_SEG)) / 1000 - i;
|
||||
tseg2 = clamp(tseg2, btc->tseg2_min, btc->tseg2_max);
|
||||
tseg1 = tseg - tseg2;
|
||||
if (tseg1 > btc->tseg1_max) {
|
||||
tseg1 = btc->tseg1_max;
|
||||
tseg2 = tseg - tseg1;
|
||||
}
|
||||
|
||||
sample_point = 1000 * (tseg + CAN_CALC_SYNC_SEG - tseg2) / (tseg + CAN_CALC_SYNC_SEG);
|
||||
sample_point_error = abs(sample_point_nominal - sample_point);
|
||||
|
||||
if ((sample_point <= sample_point_nominal) && (sample_point_error < best_sample_point_error)) {
|
||||
best_sample_point = sample_point;
|
||||
best_sample_point_error = sample_point_error;
|
||||
*tseg1_ptr = tseg1;
|
||||
*tseg2_ptr = tseg2;
|
||||
}
|
||||
}
|
||||
return 1000 * (tseg + 1 - *tseg2) / (tseg + 1);
|
||||
|
||||
if (sample_point_error_ptr)
|
||||
*sample_point_error_ptr = best_sample_point_error;
|
||||
|
||||
return best_sample_point;
|
||||
}
|
||||
|
||||
static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt,
|
||||
const struct can_bittiming_const *btc)
|
||||
{
|
||||
struct can_priv *priv = netdev_priv(dev);
|
||||
long best_error = 1000000000, error = 0;
|
||||
int best_tseg = 0, best_brp = 0, brp = 0;
|
||||
int tsegall, tseg = 0, tseg1 = 0, tseg2 = 0;
|
||||
int spt_error = 1000, spt = 0, sampl_pt;
|
||||
long rate;
|
||||
unsigned int bitrate; /* current bitrate */
|
||||
unsigned int bitrate_error; /* difference between current and nominal value */
|
||||
unsigned int best_bitrate_error = UINT_MAX;
|
||||
unsigned int sample_point_error; /* difference between current and nominal value */
|
||||
unsigned int best_sample_point_error = UINT_MAX;
|
||||
unsigned int sample_point_nominal; /* nominal sample point */
|
||||
unsigned int best_tseg = 0; /* current best value for tseg */
|
||||
unsigned int best_brp = 0; /* current best value for brp */
|
||||
unsigned int brp, tsegall, tseg, tseg1 = 0, tseg2 = 0;
|
||||
u64 v64;
|
||||
|
||||
/* Use CiA recommended sample points */
|
||||
if (bt->sample_point) {
|
||||
sampl_pt = bt->sample_point;
|
||||
sample_point_nominal = bt->sample_point;
|
||||
} else {
|
||||
if (bt->bitrate > 800000)
|
||||
sampl_pt = 750;
|
||||
sample_point_nominal = 750;
|
||||
else if (bt->bitrate > 500000)
|
||||
sampl_pt = 800;
|
||||
sample_point_nominal = 800;
|
||||
else
|
||||
sampl_pt = 875;
|
||||
sample_point_nominal = 875;
|
||||
}
|
||||
|
||||
/* tseg even = round down, odd = round up */
|
||||
for (tseg = (btc->tseg1_max + btc->tseg2_max) * 2 + 1;
|
||||
tseg >= (btc->tseg1_min + btc->tseg2_min) * 2; tseg--) {
|
||||
tsegall = 1 + tseg / 2;
|
||||
tsegall = CAN_CALC_SYNC_SEG + tseg / 2;
|
||||
|
||||
/* Compute all possible tseg choices (tseg=tseg1+tseg2) */
|
||||
brp = priv->clock.freq / (tsegall * bt->bitrate) + tseg % 2;
|
||||
/* chose brp step which is possible in system */
|
||||
|
||||
/* choose brp step which is possible in system */
|
||||
brp = (brp / btc->brp_inc) * btc->brp_inc;
|
||||
if ((brp < btc->brp_min) || (brp > btc->brp_max))
|
||||
continue;
|
||||
rate = priv->clock.freq / (brp * tsegall);
|
||||
error = bt->bitrate - rate;
|
||||
|
||||
bitrate = priv->clock.freq / (brp * tsegall);
|
||||
bitrate_error = abs(bt->bitrate - bitrate);
|
||||
|
||||
/* tseg brp biterror */
|
||||
if (error < 0)
|
||||
error = -error;
|
||||
if (error > best_error)
|
||||
if (bitrate_error > best_bitrate_error)
|
||||
continue;
|
||||
best_error = error;
|
||||
if (error == 0) {
|
||||
spt = can_update_spt(btc, sampl_pt, tseg / 2,
|
||||
&tseg1, &tseg2);
|
||||
error = sampl_pt - spt;
|
||||
if (error < 0)
|
||||
error = -error;
|
||||
if (error > spt_error)
|
||||
continue;
|
||||
spt_error = error;
|
||||
}
|
||||
|
||||
/* reset sample point error if we have a better bitrate */
|
||||
if (bitrate_error < best_bitrate_error)
|
||||
best_sample_point_error = UINT_MAX;
|
||||
|
||||
can_update_sample_point(btc, sample_point_nominal, tseg / 2, &tseg1, &tseg2, &sample_point_error);
|
||||
if (sample_point_error > best_sample_point_error)
|
||||
continue;
|
||||
|
||||
best_sample_point_error = sample_point_error;
|
||||
best_bitrate_error = bitrate_error;
|
||||
best_tseg = tseg / 2;
|
||||
best_brp = brp;
|
||||
if (error == 0)
|
||||
|
||||
if (bitrate_error == 0 && sample_point_error == 0)
|
||||
break;
|
||||
}
|
||||
|
||||
if (best_error) {
|
||||
if (best_bitrate_error) {
|
||||
/* Error in one-tenth of a percent */
|
||||
error = (best_error * 1000) / bt->bitrate;
|
||||
if (error > CAN_CALC_MAX_ERROR) {
|
||||
v64 = (u64)best_bitrate_error * 1000;
|
||||
do_div(v64, bt->bitrate);
|
||||
bitrate_error = (u32)v64;
|
||||
if (bitrate_error > CAN_CALC_MAX_ERROR) {
|
||||
netdev_err(dev,
|
||||
"bitrate error %ld.%ld%% too high\n",
|
||||
error / 10, error % 10);
|
||||
"bitrate error %d.%d%% too high\n",
|
||||
bitrate_error / 10, bitrate_error % 10);
|
||||
return -EDOM;
|
||||
} else {
|
||||
netdev_warn(dev, "bitrate error %ld.%ld%%\n",
|
||||
error / 10, error % 10);
|
||||
}
|
||||
netdev_warn(dev, "bitrate error %d.%d%%\n",
|
||||
bitrate_error / 10, bitrate_error % 10);
|
||||
}
|
||||
|
||||
/* real sample point */
|
||||
bt->sample_point = can_update_spt(btc, sampl_pt, best_tseg,
|
||||
&tseg1, &tseg2);
|
||||
bt->sample_point = can_update_sample_point(btc, sample_point_nominal, best_tseg,
|
||||
&tseg1, &tseg2, NULL);
|
||||
|
||||
v64 = (u64)best_brp * 1000000000UL;
|
||||
v64 = (u64)best_brp * 1000 * 1000 * 1000;
|
||||
do_div(v64, priv->clock.freq);
|
||||
bt->tq = (u32)v64;
|
||||
bt->prop_seg = tseg1 / 2;
|
||||
|
|
@ -182,9 +211,9 @@ static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt,
|
|||
bt->phase_seg2 = tseg2;
|
||||
|
||||
/* check for sjw user settings */
|
||||
if (!bt->sjw || !btc->sjw_max)
|
||||
if (!bt->sjw || !btc->sjw_max) {
|
||||
bt->sjw = 1;
|
||||
else {
|
||||
} else {
|
||||
/* bt->sjw is at least 1 -> sanitize upper bound to sjw_max */
|
||||
if (bt->sjw > btc->sjw_max)
|
||||
bt->sjw = btc->sjw_max;
|
||||
|
|
@ -194,8 +223,9 @@ static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt,
|
|||
}
|
||||
|
||||
bt->brp = best_brp;
|
||||
/* real bit-rate */
|
||||
bt->bitrate = priv->clock.freq / (bt->brp * (tseg1 + tseg2 + 1));
|
||||
|
||||
/* real bitrate */
|
||||
bt->bitrate = priv->clock.freq / (bt->brp * (CAN_CALC_SYNC_SEG + tseg1 + tseg2));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,21 @@
|
|||
config CAN_RCAR
|
||||
tristate "Renesas R-Car CAN controller"
|
||||
depends on ARCH_RENESAS || ARM
|
||||
---help---
|
||||
Say Y here if you want to use CAN controller found on Renesas R-Car
|
||||
SoCs.
|
||||
|
||||
To compile this driver as a module, choose M here: the module will
|
||||
be called rcar_can.
|
||||
|
||||
config CAN_RCAR_CANFD
|
||||
tristate "Renesas R-Car CAN FD controller"
|
||||
depends on ARCH_RENESAS || ARM
|
||||
---help---
|
||||
Say Y here if you want to use CAN FD controller found on
|
||||
Renesas R-Car SoCs. The driver puts the controller in CAN FD only
|
||||
mode, which can interoperate with CAN2.0 nodes but does not support
|
||||
dedicated CAN 2.0 mode.
|
||||
|
||||
To compile this driver as a module, choose M here: the module will
|
||||
be called rcar_canfd.
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
#
|
||||
# Makefile for the Renesas R-Car CAN & CAN FD controller drivers
|
||||
#
|
||||
|
||||
obj-$(CONFIG_CAN_RCAR) += rcar_can.o
|
||||
obj-$(CONFIG_CAN_RCAR_CANFD) += rcar_canfd.o
|
||||
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
|
@ -203,14 +203,4 @@ static struct isa_driver tscan1_isa_driver = {
|
|||
},
|
||||
};
|
||||
|
||||
static int __init tscan1_init(void)
|
||||
{
|
||||
return isa_register_driver(&tscan1_isa_driver, TSCAN1_MAXDEV);
|
||||
}
|
||||
module_init(tscan1_init);
|
||||
|
||||
static void __exit tscan1_exit(void)
|
||||
{
|
||||
isa_unregister_driver(&tscan1_isa_driver);
|
||||
}
|
||||
module_exit(tscan1_exit);
|
||||
module_isa_driver(tscan1_isa_driver, TSCAN1_MAXDEV);
|
||||
|
|
|
|||
|
|
@ -354,7 +354,7 @@ static netdev_tx_t slc_xmit(struct sk_buff *skb, struct net_device *dev)
|
|||
{
|
||||
struct slcan *sl = netdev_priv(dev);
|
||||
|
||||
if (skb->len != sizeof(struct can_frame))
|
||||
if (skb->len != CAN_MTU)
|
||||
goto out;
|
||||
|
||||
spin_lock(&sl->lock);
|
||||
|
|
@ -442,7 +442,7 @@ static void slc_setup(struct net_device *dev)
|
|||
dev->addr_len = 0;
|
||||
dev->tx_queue_len = 10;
|
||||
|
||||
dev->mtu = sizeof(struct can_frame);
|
||||
dev->mtu = CAN_MTU;
|
||||
dev->type = ARPHRD_CAN;
|
||||
|
||||
/* New-style flags. */
|
||||
|
|
|
|||
|
|
@ -39,7 +39,9 @@ enum gs_usb_breq {
|
|||
GS_USB_BREQ_MODE,
|
||||
GS_USB_BREQ_BERR,
|
||||
GS_USB_BREQ_BT_CONST,
|
||||
GS_USB_BREQ_DEVICE_CONFIG
|
||||
GS_USB_BREQ_DEVICE_CONFIG,
|
||||
GS_USB_BREQ_TIMESTAMP,
|
||||
GS_USB_BREQ_IDENTIFY,
|
||||
};
|
||||
|
||||
enum gs_can_mode {
|
||||
|
|
@ -58,6 +60,11 @@ enum gs_can_state {
|
|||
GS_CAN_STATE_SLEEPING
|
||||
};
|
||||
|
||||
enum gs_can_identify_mode {
|
||||
GS_CAN_IDENTIFY_OFF = 0,
|
||||
GS_CAN_IDENTIFY_ON
|
||||
};
|
||||
|
||||
/* data types passed between host and device */
|
||||
struct gs_host_config {
|
||||
u32 byte_order;
|
||||
|
|
@ -77,10 +84,10 @@ struct gs_device_config {
|
|||
} __packed;
|
||||
|
||||
#define GS_CAN_MODE_NORMAL 0
|
||||
#define GS_CAN_MODE_LISTEN_ONLY (1<<0)
|
||||
#define GS_CAN_MODE_LOOP_BACK (1<<1)
|
||||
#define GS_CAN_MODE_TRIPLE_SAMPLE (1<<2)
|
||||
#define GS_CAN_MODE_ONE_SHOT (1<<3)
|
||||
#define GS_CAN_MODE_LISTEN_ONLY BIT(0)
|
||||
#define GS_CAN_MODE_LOOP_BACK BIT(1)
|
||||
#define GS_CAN_MODE_TRIPLE_SAMPLE BIT(2)
|
||||
#define GS_CAN_MODE_ONE_SHOT BIT(3)
|
||||
|
||||
struct gs_device_mode {
|
||||
u32 mode;
|
||||
|
|
@ -101,10 +108,16 @@ struct gs_device_bittiming {
|
|||
u32 brp;
|
||||
} __packed;
|
||||
|
||||
#define GS_CAN_FEATURE_LISTEN_ONLY (1<<0)
|
||||
#define GS_CAN_FEATURE_LOOP_BACK (1<<1)
|
||||
#define GS_CAN_FEATURE_TRIPLE_SAMPLE (1<<2)
|
||||
#define GS_CAN_FEATURE_ONE_SHOT (1<<3)
|
||||
struct gs_identify_mode {
|
||||
u32 mode;
|
||||
} __packed;
|
||||
|
||||
#define GS_CAN_FEATURE_LISTEN_ONLY BIT(0)
|
||||
#define GS_CAN_FEATURE_LOOP_BACK BIT(1)
|
||||
#define GS_CAN_FEATURE_TRIPLE_SAMPLE BIT(2)
|
||||
#define GS_CAN_FEATURE_ONE_SHOT BIT(3)
|
||||
#define GS_CAN_FEATURE_HW_TIMESTAMP BIT(4)
|
||||
#define GS_CAN_FEATURE_IDENTIFY BIT(5)
|
||||
|
||||
struct gs_device_bt_const {
|
||||
u32 feature;
|
||||
|
|
@ -209,7 +222,8 @@ static void gs_free_tx_context(struct gs_tx_context *txc)
|
|||
|
||||
/* Get a tx context by id.
|
||||
*/
|
||||
static struct gs_tx_context *gs_get_tx_context(struct gs_can *dev, unsigned int id)
|
||||
static struct gs_tx_context *gs_get_tx_context(struct gs_can *dev,
|
||||
unsigned int id)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
||||
|
|
@ -452,7 +466,8 @@ static void gs_usb_xmit_callback(struct urb *urb)
|
|||
netif_wake_queue(netdev);
|
||||
}
|
||||
|
||||
static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb, struct net_device *netdev)
|
||||
static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb,
|
||||
struct net_device *netdev)
|
||||
{
|
||||
struct gs_can *dev = netdev_priv(netdev);
|
||||
struct net_device_stats *stats = &dev->netdev->stats;
|
||||
|
|
@ -658,7 +673,8 @@ static int gs_can_open(struct net_device *netdev)
|
|||
rc = usb_control_msg(interface_to_usbdev(dev->iface),
|
||||
usb_sndctrlpipe(interface_to_usbdev(dev->iface), 0),
|
||||
GS_USB_BREQ_MODE,
|
||||
USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
|
||||
USB_DIR_OUT | USB_TYPE_VENDOR |
|
||||
USB_RECIP_INTERFACE,
|
||||
dev->channel,
|
||||
0,
|
||||
dm,
|
||||
|
|
@ -721,7 +737,59 @@ static const struct net_device_ops gs_usb_netdev_ops = {
|
|||
.ndo_change_mtu = can_change_mtu,
|
||||
};
|
||||
|
||||
static struct gs_can *gs_make_candev(unsigned int channel, struct usb_interface *intf)
|
||||
static int gs_usb_set_identify(struct net_device *netdev, bool do_identify)
|
||||
{
|
||||
struct gs_can *dev = netdev_priv(netdev);
|
||||
struct gs_identify_mode imode;
|
||||
int rc;
|
||||
|
||||
if (do_identify)
|
||||
imode.mode = GS_CAN_IDENTIFY_ON;
|
||||
else
|
||||
imode.mode = GS_CAN_IDENTIFY_OFF;
|
||||
|
||||
rc = usb_control_msg(interface_to_usbdev(dev->iface),
|
||||
usb_sndctrlpipe(interface_to_usbdev(dev->iface),
|
||||
0),
|
||||
GS_USB_BREQ_IDENTIFY,
|
||||
USB_DIR_OUT | USB_TYPE_VENDOR |
|
||||
USB_RECIP_INTERFACE,
|
||||
dev->channel,
|
||||
0,
|
||||
&imode,
|
||||
sizeof(imode),
|
||||
100);
|
||||
|
||||
return (rc > 0) ? 0 : rc;
|
||||
}
|
||||
|
||||
/* blink LED's for finding the this interface */
|
||||
static int gs_usb_set_phys_id(struct net_device *dev,
|
||||
enum ethtool_phys_id_state state)
|
||||
{
|
||||
int rc = 0;
|
||||
|
||||
switch (state) {
|
||||
case ETHTOOL_ID_ACTIVE:
|
||||
rc = gs_usb_set_identify(dev, GS_CAN_IDENTIFY_ON);
|
||||
break;
|
||||
case ETHTOOL_ID_INACTIVE:
|
||||
rc = gs_usb_set_identify(dev, GS_CAN_IDENTIFY_OFF);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
static const struct ethtool_ops gs_usb_ethtool_ops = {
|
||||
.set_phys_id = gs_usb_set_phys_id,
|
||||
};
|
||||
|
||||
static struct gs_can *gs_make_candev(unsigned int channel,
|
||||
struct usb_interface *intf,
|
||||
struct gs_device_config *dconf)
|
||||
{
|
||||
struct gs_can *dev;
|
||||
struct net_device *netdev;
|
||||
|
|
@ -809,10 +877,14 @@ static struct gs_can *gs_make_candev(unsigned int channel, struct usb_interface
|
|||
if (bt_const->feature & GS_CAN_FEATURE_ONE_SHOT)
|
||||
dev->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT;
|
||||
|
||||
kfree(bt_const);
|
||||
|
||||
SET_NETDEV_DEV(netdev, &intf->dev);
|
||||
|
||||
if (dconf->sw_version > 1)
|
||||
if (bt_const->feature & GS_CAN_FEATURE_IDENTIFY)
|
||||
netdev->ethtool_ops = &gs_usb_ethtool_ops;
|
||||
|
||||
kfree(bt_const);
|
||||
|
||||
rc = register_candev(dev->netdev);
|
||||
if (rc) {
|
||||
free_candev(dev->netdev);
|
||||
|
|
@ -830,19 +902,16 @@ static void gs_destroy_candev(struct gs_can *dev)
|
|||
free_candev(dev->netdev);
|
||||
}
|
||||
|
||||
static int gs_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
|
||||
static int gs_usb_probe(struct usb_interface *intf,
|
||||
const struct usb_device_id *id)
|
||||
{
|
||||
struct gs_usb *dev;
|
||||
int rc = -ENOMEM;
|
||||
unsigned int icount, i;
|
||||
struct gs_host_config *hconf;
|
||||
struct gs_device_config *dconf;
|
||||
|
||||
hconf = kmalloc(sizeof(*hconf), GFP_KERNEL);
|
||||
if (!hconf)
|
||||
return -ENOMEM;
|
||||
|
||||
hconf->byte_order = 0x0000beef;
|
||||
struct gs_host_config hconf = {
|
||||
.byte_order = 0x0000beef,
|
||||
};
|
||||
struct gs_device_config dconf;
|
||||
|
||||
/* send host config */
|
||||
rc = usb_control_msg(interface_to_usbdev(intf),
|
||||
|
|
@ -851,22 +920,16 @@ static int gs_usb_probe(struct usb_interface *intf, const struct usb_device_id *
|
|||
USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
|
||||
1,
|
||||
intf->altsetting[0].desc.bInterfaceNumber,
|
||||
hconf,
|
||||
sizeof(*hconf),
|
||||
&hconf,
|
||||
sizeof(hconf),
|
||||
1000);
|
||||
|
||||
kfree(hconf);
|
||||
|
||||
if (rc < 0) {
|
||||
dev_err(&intf->dev, "Couldn't send data format (err=%d)\n",
|
||||
rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
dconf = kmalloc(sizeof(*dconf), GFP_KERNEL);
|
||||
if (!dconf)
|
||||
return -ENOMEM;
|
||||
|
||||
/* read device config */
|
||||
rc = usb_control_msg(interface_to_usbdev(intf),
|
||||
usb_rcvctrlpipe(interface_to_usbdev(intf), 0),
|
||||
|
|
@ -874,22 +937,16 @@ static int gs_usb_probe(struct usb_interface *intf, const struct usb_device_id *
|
|||
USB_DIR_IN|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
|
||||
1,
|
||||
intf->altsetting[0].desc.bInterfaceNumber,
|
||||
dconf,
|
||||
sizeof(*dconf),
|
||||
&dconf,
|
||||
sizeof(dconf),
|
||||
1000);
|
||||
if (rc < 0) {
|
||||
dev_err(&intf->dev, "Couldn't get device config: (err=%d)\n",
|
||||
rc);
|
||||
|
||||
kfree(dconf);
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
icount = dconf->icount+1;
|
||||
|
||||
kfree(dconf);
|
||||
|
||||
icount = dconf.icount + 1;
|
||||
dev_info(&intf->dev, "Configuring for %d interfaces\n", icount);
|
||||
|
||||
if (icount > GS_MAX_INTF) {
|
||||
|
|
@ -910,7 +967,7 @@ static int gs_usb_probe(struct usb_interface *intf, const struct usb_device_id *
|
|||
dev->udev = interface_to_usbdev(intf);
|
||||
|
||||
for (i = 0; i < icount; i++) {
|
||||
dev->canch[i] = gs_make_candev(i, intf);
|
||||
dev->canch[i] = gs_make_candev(i, intf, &dconf);
|
||||
if (IS_ERR_OR_NULL(dev->canch[i])) {
|
||||
/* save error code to return later */
|
||||
rc = PTR_ERR(dev->canch[i]);
|
||||
|
|
|
|||
|
|
@ -99,5 +99,6 @@ enum {
|
|||
#define RX_ANNOUNCE_RESUME 0x0100
|
||||
#define TX_RESET_MULTI_IDX 0x0200
|
||||
#define RX_RTR_FRAME 0x0400
|
||||
#define CAN_FD_FRAME 0x0800
|
||||
|
||||
#endif /* !_UAPI_CAN_BCM_H */
|
||||
|
|
|
|||
|
|
@ -3,7 +3,8 @@
|
|||
#
|
||||
|
||||
obj-$(CONFIG_CAN) += can.o
|
||||
can-y := af_can.o proc.o
|
||||
can-y := af_can.o
|
||||
can-$(CONFIG_PROC_FS) += proc.o
|
||||
|
||||
obj-$(CONFIG_CAN_RAW) += can-raw.o
|
||||
can-raw-y := raw.o
|
||||
|
|
|
|||
|
|
@ -113,8 +113,19 @@ struct s_pstats {
|
|||
extern struct dev_rcv_lists can_rx_alldev_list;
|
||||
|
||||
/* function prototypes for the CAN networklayer procfs (proc.c) */
|
||||
#ifdef CONFIG_PROC_FS
|
||||
void can_init_proc(void);
|
||||
void can_remove_proc(void);
|
||||
#else
|
||||
static inline void can_init_proc(void)
|
||||
{
|
||||
pr_info("can: Can't create /proc/net/can. CONFIG_PROC_FS missing!\n");
|
||||
}
|
||||
|
||||
static inline void can_remove_proc(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
void can_stat_update(unsigned long data);
|
||||
|
||||
/* structures and variables from af_can.c needed in proc.c for reading */
|
||||
|
|
|
|||
309
net/can/bcm.c
309
net/can/bcm.c
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
* bcm.c - Broadcast Manager to filter/send (cyclic) CAN content
|
||||
*
|
||||
* Copyright (c) 2002-2007 Volkswagen Group Electronic Research
|
||||
* Copyright (c) 2002-2016 Volkswagen Group Electronic Research
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
|
|
@ -67,27 +67,31 @@
|
|||
*/
|
||||
#define MAX_NFRAMES 256
|
||||
|
||||
/* use of last_frames[index].can_dlc */
|
||||
/* use of last_frames[index].flags */
|
||||
#define RX_RECV 0x40 /* received data for this element */
|
||||
#define RX_THR 0x80 /* element not been sent due to throttle feature */
|
||||
#define BCM_CAN_DLC_MASK 0x0F /* clean private flags in can_dlc by masking */
|
||||
#define BCM_CAN_FLAGS_MASK 0x3F /* to clean private flags after usage */
|
||||
|
||||
/* get best masking value for can_rx_register() for a given single can_id */
|
||||
#define REGMASK(id) ((id & CAN_EFF_FLAG) ? \
|
||||
(CAN_EFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG) : \
|
||||
(CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG))
|
||||
|
||||
#define CAN_BCM_VERSION CAN_VERSION
|
||||
#define CAN_BCM_VERSION "20160617"
|
||||
|
||||
MODULE_DESCRIPTION("PF_CAN broadcast manager protocol");
|
||||
MODULE_LICENSE("Dual BSD/GPL");
|
||||
MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
|
||||
MODULE_ALIAS("can-proto-2");
|
||||
|
||||
/* easy access to can_frame payload */
|
||||
static inline u64 GET_U64(const struct can_frame *cp)
|
||||
/*
|
||||
* easy access to the first 64 bit of can(fd)_frame payload. cp->data is
|
||||
* 64 bit aligned so the offset has to be multiples of 8 which is ensured
|
||||
* by the only callers in bcm_rx_cmp_to_index() bcm_rx_handler().
|
||||
*/
|
||||
static inline u64 get_u64(const struct canfd_frame *cp, int offset)
|
||||
{
|
||||
return *(u64 *)cp->data;
|
||||
return *(u64 *)(cp->data + offset);
|
||||
}
|
||||
|
||||
struct bcm_op {
|
||||
|
|
@ -101,13 +105,14 @@ struct bcm_op {
|
|||
struct tasklet_struct tsklet, thrtsklet;
|
||||
ktime_t rx_stamp, kt_ival1, kt_ival2, kt_lastmsg;
|
||||
int rx_ifindex;
|
||||
int cfsiz;
|
||||
u32 count;
|
||||
u32 nframes;
|
||||
u32 currframe;
|
||||
struct can_frame *frames;
|
||||
struct can_frame *last_frames;
|
||||
struct can_frame sframe;
|
||||
struct can_frame last_sframe;
|
||||
struct canfd_frame *frames;
|
||||
struct canfd_frame *last_frames;
|
||||
struct canfd_frame sframe;
|
||||
struct canfd_frame last_sframe;
|
||||
struct sock *sk;
|
||||
struct net_device *rx_reg_dev;
|
||||
};
|
||||
|
|
@ -136,7 +141,7 @@ static inline ktime_t bcm_timeval_to_ktime(struct bcm_timeval tv)
|
|||
return ktime_set(tv.tv_sec, tv.tv_usec * NSEC_PER_USEC);
|
||||
}
|
||||
|
||||
#define CFSIZ sizeof(struct can_frame)
|
||||
#define CFSIZ(flags) ((flags & CAN_FD_FRAME) ? CANFD_MTU : CAN_MTU)
|
||||
#define OPSIZ sizeof(struct bcm_op)
|
||||
#define MHSIZ sizeof(struct bcm_msg_head)
|
||||
|
||||
|
|
@ -183,43 +188,50 @@ static int bcm_proc_show(struct seq_file *m, void *v)
|
|||
if (!op->frames_abs)
|
||||
continue;
|
||||
|
||||
seq_printf(m, "rx_op: %03X %-5s ",
|
||||
op->can_id, bcm_proc_getifname(ifname, op->ifindex));
|
||||
seq_printf(m, "[%u]%c ", op->nframes,
|
||||
(op->flags & RX_CHECK_DLC)?'d':' ');
|
||||
seq_printf(m, "rx_op: %03X %-5s ", op->can_id,
|
||||
bcm_proc_getifname(ifname, op->ifindex));
|
||||
|
||||
if (op->flags & CAN_FD_FRAME)
|
||||
seq_printf(m, "(%u)", op->nframes);
|
||||
else
|
||||
seq_printf(m, "[%u]", op->nframes);
|
||||
|
||||
seq_printf(m, "%c ", (op->flags & RX_CHECK_DLC) ? 'd' : ' ');
|
||||
|
||||
if (op->kt_ival1.tv64)
|
||||
seq_printf(m, "timeo=%lld ",
|
||||
(long long)
|
||||
ktime_to_us(op->kt_ival1));
|
||||
(long long)ktime_to_us(op->kt_ival1));
|
||||
|
||||
if (op->kt_ival2.tv64)
|
||||
seq_printf(m, "thr=%lld ",
|
||||
(long long)
|
||||
ktime_to_us(op->kt_ival2));
|
||||
(long long)ktime_to_us(op->kt_ival2));
|
||||
|
||||
seq_printf(m, "# recv %ld (%ld) => reduction: ",
|
||||
op->frames_filtered, op->frames_abs);
|
||||
op->frames_filtered, op->frames_abs);
|
||||
|
||||
reduction = 100 - (op->frames_filtered * 100) / op->frames_abs;
|
||||
|
||||
seq_printf(m, "%s%ld%%\n",
|
||||
(reduction == 100)?"near ":"", reduction);
|
||||
(reduction == 100) ? "near " : "", reduction);
|
||||
}
|
||||
|
||||
list_for_each_entry(op, &bo->tx_ops, list) {
|
||||
|
||||
seq_printf(m, "tx_op: %03X %s [%u] ",
|
||||
op->can_id,
|
||||
bcm_proc_getifname(ifname, op->ifindex),
|
||||
op->nframes);
|
||||
seq_printf(m, "tx_op: %03X %s ", op->can_id,
|
||||
bcm_proc_getifname(ifname, op->ifindex));
|
||||
|
||||
if (op->flags & CAN_FD_FRAME)
|
||||
seq_printf(m, "(%u) ", op->nframes);
|
||||
else
|
||||
seq_printf(m, "[%u] ", op->nframes);
|
||||
|
||||
if (op->kt_ival1.tv64)
|
||||
seq_printf(m, "t1=%lld ",
|
||||
(long long) ktime_to_us(op->kt_ival1));
|
||||
(long long)ktime_to_us(op->kt_ival1));
|
||||
|
||||
if (op->kt_ival2.tv64)
|
||||
seq_printf(m, "t2=%lld ",
|
||||
(long long) ktime_to_us(op->kt_ival2));
|
||||
(long long)ktime_to_us(op->kt_ival2));
|
||||
|
||||
seq_printf(m, "# sent %ld\n", op->frames_abs);
|
||||
}
|
||||
|
|
@ -248,7 +260,7 @@ static void bcm_can_tx(struct bcm_op *op)
|
|||
{
|
||||
struct sk_buff *skb;
|
||||
struct net_device *dev;
|
||||
struct can_frame *cf = &op->frames[op->currframe];
|
||||
struct canfd_frame *cf = op->frames + op->cfsiz * op->currframe;
|
||||
|
||||
/* no target device? => exit */
|
||||
if (!op->ifindex)
|
||||
|
|
@ -260,7 +272,7 @@ static void bcm_can_tx(struct bcm_op *op)
|
|||
return;
|
||||
}
|
||||
|
||||
skb = alloc_skb(CFSIZ + sizeof(struct can_skb_priv), gfp_any());
|
||||
skb = alloc_skb(op->cfsiz + sizeof(struct can_skb_priv), gfp_any());
|
||||
if (!skb)
|
||||
goto out;
|
||||
|
||||
|
|
@ -268,7 +280,7 @@ static void bcm_can_tx(struct bcm_op *op)
|
|||
can_skb_prv(skb)->ifindex = dev->ifindex;
|
||||
can_skb_prv(skb)->skbcnt = 0;
|
||||
|
||||
memcpy(skb_put(skb, CFSIZ), cf, CFSIZ);
|
||||
memcpy(skb_put(skb, op->cfsiz), cf, op->cfsiz);
|
||||
|
||||
/* send with loopback */
|
||||
skb->dev = dev;
|
||||
|
|
@ -282,7 +294,7 @@ static void bcm_can_tx(struct bcm_op *op)
|
|||
/* reached last frame? */
|
||||
if (op->currframe >= op->nframes)
|
||||
op->currframe = 0;
|
||||
out:
|
||||
out:
|
||||
dev_put(dev);
|
||||
}
|
||||
|
||||
|
|
@ -291,13 +303,13 @@ static void bcm_can_tx(struct bcm_op *op)
|
|||
* (consisting of bcm_msg_head + x CAN frames)
|
||||
*/
|
||||
static void bcm_send_to_user(struct bcm_op *op, struct bcm_msg_head *head,
|
||||
struct can_frame *frames, int has_timestamp)
|
||||
struct canfd_frame *frames, int has_timestamp)
|
||||
{
|
||||
struct sk_buff *skb;
|
||||
struct can_frame *firstframe;
|
||||
struct canfd_frame *firstframe;
|
||||
struct sockaddr_can *addr;
|
||||
struct sock *sk = op->sk;
|
||||
unsigned int datalen = head->nframes * CFSIZ;
|
||||
unsigned int datalen = head->nframes * op->cfsiz;
|
||||
int err;
|
||||
|
||||
skb = alloc_skb(sizeof(*head) + datalen, gfp_any());
|
||||
|
|
@ -307,19 +319,19 @@ static void bcm_send_to_user(struct bcm_op *op, struct bcm_msg_head *head,
|
|||
memcpy(skb_put(skb, sizeof(*head)), head, sizeof(*head));
|
||||
|
||||
if (head->nframes) {
|
||||
/* can_frames starting here */
|
||||
firstframe = (struct can_frame *)skb_tail_pointer(skb);
|
||||
/* CAN frames starting here */
|
||||
firstframe = (struct canfd_frame *)skb_tail_pointer(skb);
|
||||
|
||||
memcpy(skb_put(skb, datalen), frames, datalen);
|
||||
|
||||
/*
|
||||
* the BCM uses the can_dlc-element of the can_frame
|
||||
* the BCM uses the flags-element of the canfd_frame
|
||||
* structure for internal purposes. This is only
|
||||
* relevant for updates that are generated by the
|
||||
* BCM, where nframes is 1
|
||||
*/
|
||||
if (head->nframes == 1)
|
||||
firstframe->can_dlc &= BCM_CAN_DLC_MASK;
|
||||
firstframe->flags &= BCM_CAN_FLAGS_MASK;
|
||||
}
|
||||
|
||||
if (has_timestamp) {
|
||||
|
|
@ -406,7 +418,7 @@ static enum hrtimer_restart bcm_tx_timeout_handler(struct hrtimer *hrtimer)
|
|||
/*
|
||||
* bcm_rx_changed - create a RX_CHANGED notification due to changed content
|
||||
*/
|
||||
static void bcm_rx_changed(struct bcm_op *op, struct can_frame *data)
|
||||
static void bcm_rx_changed(struct bcm_op *op, struct canfd_frame *data)
|
||||
{
|
||||
struct bcm_msg_head head;
|
||||
|
||||
|
|
@ -418,7 +430,7 @@ static void bcm_rx_changed(struct bcm_op *op, struct can_frame *data)
|
|||
op->frames_filtered = op->frames_abs = 0;
|
||||
|
||||
/* this element is not throttled anymore */
|
||||
data->can_dlc &= (BCM_CAN_DLC_MASK|RX_RECV);
|
||||
data->flags &= (BCM_CAN_FLAGS_MASK|RX_RECV);
|
||||
|
||||
head.opcode = RX_CHANGED;
|
||||
head.flags = op->flags;
|
||||
|
|
@ -437,13 +449,13 @@ static void bcm_rx_changed(struct bcm_op *op, struct can_frame *data)
|
|||
* 2. send a notification to the user (if possible)
|
||||
*/
|
||||
static void bcm_rx_update_and_send(struct bcm_op *op,
|
||||
struct can_frame *lastdata,
|
||||
const struct can_frame *rxdata)
|
||||
struct canfd_frame *lastdata,
|
||||
const struct canfd_frame *rxdata)
|
||||
{
|
||||
memcpy(lastdata, rxdata, CFSIZ);
|
||||
memcpy(lastdata, rxdata, op->cfsiz);
|
||||
|
||||
/* mark as used and throttled by default */
|
||||
lastdata->can_dlc |= (RX_RECV|RX_THR);
|
||||
lastdata->flags |= (RX_RECV|RX_THR);
|
||||
|
||||
/* throttling mode inactive ? */
|
||||
if (!op->kt_ival2.tv64) {
|
||||
|
|
@ -481,33 +493,36 @@ rx_changed_settime:
|
|||
* received data stored in op->last_frames[]
|
||||
*/
|
||||
static void bcm_rx_cmp_to_index(struct bcm_op *op, unsigned int index,
|
||||
const struct can_frame *rxdata)
|
||||
const struct canfd_frame *rxdata)
|
||||
{
|
||||
struct canfd_frame *cf = op->frames + op->cfsiz * index;
|
||||
struct canfd_frame *lcf = op->last_frames + op->cfsiz * index;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* no one uses the MSBs of can_dlc for comparison,
|
||||
* no one uses the MSBs of flags for comparison,
|
||||
* so we use it here to detect the first time of reception
|
||||
*/
|
||||
|
||||
if (!(op->last_frames[index].can_dlc & RX_RECV)) {
|
||||
if (!(lcf->flags & RX_RECV)) {
|
||||
/* received data for the first time => send update to user */
|
||||
bcm_rx_update_and_send(op, &op->last_frames[index], rxdata);
|
||||
bcm_rx_update_and_send(op, lcf, rxdata);
|
||||
return;
|
||||
}
|
||||
|
||||
/* do a real check in can_frame data section */
|
||||
|
||||
if ((GET_U64(&op->frames[index]) & GET_U64(rxdata)) !=
|
||||
(GET_U64(&op->frames[index]) & GET_U64(&op->last_frames[index]))) {
|
||||
bcm_rx_update_and_send(op, &op->last_frames[index], rxdata);
|
||||
return;
|
||||
/* do a real check in CAN frame data section */
|
||||
for (i = 0; i < rxdata->len; i += 8) {
|
||||
if ((get_u64(cf, i) & get_u64(rxdata, i)) !=
|
||||
(get_u64(cf, i) & get_u64(lcf, i))) {
|
||||
bcm_rx_update_and_send(op, lcf, rxdata);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (op->flags & RX_CHECK_DLC) {
|
||||
/* do a real check in can_frame dlc */
|
||||
if (rxdata->can_dlc != (op->last_frames[index].can_dlc &
|
||||
BCM_CAN_DLC_MASK)) {
|
||||
bcm_rx_update_and_send(op, &op->last_frames[index],
|
||||
rxdata);
|
||||
/* do a real check in CAN frame length */
|
||||
if (rxdata->len != lcf->len) {
|
||||
bcm_rx_update_and_send(op, lcf, rxdata);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
|
@ -556,8 +571,8 @@ static enum hrtimer_restart bcm_rx_timeout_handler(struct hrtimer *hrtimer)
|
|||
|
||||
/* if user wants to be informed, when cyclic CAN-Messages come back */
|
||||
if ((op->flags & RX_ANNOUNCE_RESUME) && op->last_frames) {
|
||||
/* clear received can_frames to indicate 'nothing received' */
|
||||
memset(op->last_frames, 0, op->nframes * CFSIZ);
|
||||
/* clear received CAN frames to indicate 'nothing received' */
|
||||
memset(op->last_frames, 0, op->nframes * op->cfsiz);
|
||||
}
|
||||
|
||||
return HRTIMER_NORESTART;
|
||||
|
|
@ -569,9 +584,11 @@ static enum hrtimer_restart bcm_rx_timeout_handler(struct hrtimer *hrtimer)
|
|||
static inline int bcm_rx_do_flush(struct bcm_op *op, int update,
|
||||
unsigned int index)
|
||||
{
|
||||
if ((op->last_frames) && (op->last_frames[index].can_dlc & RX_THR)) {
|
||||
struct canfd_frame *lcf = op->last_frames + op->cfsiz * index;
|
||||
|
||||
if ((op->last_frames) && (lcf->flags & RX_THR)) {
|
||||
if (update)
|
||||
bcm_rx_changed(op, &op->last_frames[index]);
|
||||
bcm_rx_changed(op, lcf);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
|
|
@ -636,15 +653,19 @@ static enum hrtimer_restart bcm_rx_thr_handler(struct hrtimer *hrtimer)
|
|||
static void bcm_rx_handler(struct sk_buff *skb, void *data)
|
||||
{
|
||||
struct bcm_op *op = (struct bcm_op *)data;
|
||||
const struct can_frame *rxframe = (struct can_frame *)skb->data;
|
||||
const struct canfd_frame *rxframe = (struct canfd_frame *)skb->data;
|
||||
unsigned int i;
|
||||
|
||||
/* disable timeout */
|
||||
hrtimer_cancel(&op->timer);
|
||||
|
||||
if (op->can_id != rxframe->can_id)
|
||||
return;
|
||||
|
||||
/* make sure to handle the correct frame type (CAN / CAN FD) */
|
||||
if (skb->len != op->cfsiz)
|
||||
return;
|
||||
|
||||
/* disable timeout */
|
||||
hrtimer_cancel(&op->timer);
|
||||
|
||||
/* save rx timestamp */
|
||||
op->rx_stamp = skb->tstamp;
|
||||
/* save originator for recvfrom() */
|
||||
|
|
@ -675,13 +696,14 @@ static void bcm_rx_handler(struct sk_buff *skb, void *data)
|
|||
* multiplex compare
|
||||
*
|
||||
* find the first multiplex mask that fits.
|
||||
* Remark: The MUX-mask is stored in index 0
|
||||
* Remark: The MUX-mask is stored in index 0 - but only the
|
||||
* first 64 bits of the frame data[] are relevant (CAN FD)
|
||||
*/
|
||||
|
||||
for (i = 1; i < op->nframes; i++) {
|
||||
if ((GET_U64(&op->frames[0]) & GET_U64(rxframe)) ==
|
||||
(GET_U64(&op->frames[0]) &
|
||||
GET_U64(&op->frames[i]))) {
|
||||
if ((get_u64(op->frames, 0) & get_u64(rxframe, 0)) ==
|
||||
(get_u64(op->frames, 0) &
|
||||
get_u64(op->frames + op->cfsiz * i, 0))) {
|
||||
bcm_rx_cmp_to_index(op, i, rxframe);
|
||||
break;
|
||||
}
|
||||
|
|
@ -695,13 +717,14 @@ rx_starttimer:
|
|||
/*
|
||||
* helpers for bcm_op handling: find & delete bcm [rx|tx] op elements
|
||||
*/
|
||||
static struct bcm_op *bcm_find_op(struct list_head *ops, canid_t can_id,
|
||||
int ifindex)
|
||||
static struct bcm_op *bcm_find_op(struct list_head *ops,
|
||||
struct bcm_msg_head *mh, int ifindex)
|
||||
{
|
||||
struct bcm_op *op;
|
||||
|
||||
list_for_each_entry(op, ops, list) {
|
||||
if ((op->can_id == can_id) && (op->ifindex == ifindex))
|
||||
if ((op->can_id == mh->can_id) && (op->ifindex == ifindex) &&
|
||||
(op->flags & CAN_FD_FRAME) == (mh->flags & CAN_FD_FRAME))
|
||||
return op;
|
||||
}
|
||||
|
||||
|
|
@ -744,12 +767,14 @@ static void bcm_rx_unreg(struct net_device *dev, struct bcm_op *op)
|
|||
/*
|
||||
* bcm_delete_rx_op - find and remove a rx op (returns number of removed ops)
|
||||
*/
|
||||
static int bcm_delete_rx_op(struct list_head *ops, canid_t can_id, int ifindex)
|
||||
static int bcm_delete_rx_op(struct list_head *ops, struct bcm_msg_head *mh,
|
||||
int ifindex)
|
||||
{
|
||||
struct bcm_op *op, *n;
|
||||
|
||||
list_for_each_entry_safe(op, n, ops, list) {
|
||||
if ((op->can_id == can_id) && (op->ifindex == ifindex)) {
|
||||
if ((op->can_id == mh->can_id) && (op->ifindex == ifindex) &&
|
||||
(op->flags & CAN_FD_FRAME) == (mh->flags & CAN_FD_FRAME)) {
|
||||
|
||||
/*
|
||||
* Don't care if we're bound or not (due to netdev
|
||||
|
|
@ -789,12 +814,14 @@ static int bcm_delete_rx_op(struct list_head *ops, canid_t can_id, int ifindex)
|
|||
/*
|
||||
* bcm_delete_tx_op - find and remove a tx op (returns number of removed ops)
|
||||
*/
|
||||
static int bcm_delete_tx_op(struct list_head *ops, canid_t can_id, int ifindex)
|
||||
static int bcm_delete_tx_op(struct list_head *ops, struct bcm_msg_head *mh,
|
||||
int ifindex)
|
||||
{
|
||||
struct bcm_op *op, *n;
|
||||
|
||||
list_for_each_entry_safe(op, n, ops, list) {
|
||||
if ((op->can_id == can_id) && (op->ifindex == ifindex)) {
|
||||
if ((op->can_id == mh->can_id) && (op->ifindex == ifindex) &&
|
||||
(op->flags & CAN_FD_FRAME) == (mh->flags & CAN_FD_FRAME)) {
|
||||
list_del(&op->list);
|
||||
bcm_remove_op(op);
|
||||
return 1; /* done */
|
||||
|
|
@ -810,7 +837,7 @@ static int bcm_delete_tx_op(struct list_head *ops, canid_t can_id, int ifindex)
|
|||
static int bcm_read_op(struct list_head *ops, struct bcm_msg_head *msg_head,
|
||||
int ifindex)
|
||||
{
|
||||
struct bcm_op *op = bcm_find_op(ops, msg_head->can_id, ifindex);
|
||||
struct bcm_op *op = bcm_find_op(ops, msg_head, ifindex);
|
||||
|
||||
if (!op)
|
||||
return -EINVAL;
|
||||
|
|
@ -835,6 +862,7 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
{
|
||||
struct bcm_sock *bo = bcm_sk(sk);
|
||||
struct bcm_op *op;
|
||||
struct canfd_frame *cf;
|
||||
unsigned int i;
|
||||
int err;
|
||||
|
||||
|
|
@ -842,39 +870,46 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
if (!ifindex)
|
||||
return -ENODEV;
|
||||
|
||||
/* check nframes boundaries - we need at least one can_frame */
|
||||
/* check nframes boundaries - we need at least one CAN frame */
|
||||
if (msg_head->nframes < 1 || msg_head->nframes > MAX_NFRAMES)
|
||||
return -EINVAL;
|
||||
|
||||
/* check the given can_id */
|
||||
op = bcm_find_op(&bo->tx_ops, msg_head->can_id, ifindex);
|
||||
|
||||
op = bcm_find_op(&bo->tx_ops, msg_head, ifindex);
|
||||
if (op) {
|
||||
/* update existing BCM operation */
|
||||
|
||||
/*
|
||||
* Do we need more space for the can_frames than currently
|
||||
* Do we need more space for the CAN frames than currently
|
||||
* allocated? -> This is a _really_ unusual use-case and
|
||||
* therefore (complexity / locking) it is not supported.
|
||||
*/
|
||||
if (msg_head->nframes > op->nframes)
|
||||
return -E2BIG;
|
||||
|
||||
/* update can_frames content */
|
||||
/* update CAN frames content */
|
||||
for (i = 0; i < msg_head->nframes; i++) {
|
||||
err = memcpy_from_msg((u8 *)&op->frames[i], msg, CFSIZ);
|
||||
|
||||
if (op->frames[i].can_dlc > 8)
|
||||
err = -EINVAL;
|
||||
cf = op->frames + op->cfsiz * i;
|
||||
err = memcpy_from_msg((u8 *)cf, msg, op->cfsiz);
|
||||
|
||||
if (op->flags & CAN_FD_FRAME) {
|
||||
if (cf->len > 64)
|
||||
err = -EINVAL;
|
||||
} else {
|
||||
if (cf->len > 8)
|
||||
err = -EINVAL;
|
||||
}
|
||||
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
if (msg_head->flags & TX_CP_CAN_ID) {
|
||||
/* copy can_id into frame */
|
||||
op->frames[i].can_id = msg_head->can_id;
|
||||
cf->can_id = msg_head->can_id;
|
||||
}
|
||||
}
|
||||
op->flags = msg_head->flags;
|
||||
|
||||
} else {
|
||||
/* insert new BCM operation for the given can_id */
|
||||
|
|
@ -883,11 +918,13 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
if (!op)
|
||||
return -ENOMEM;
|
||||
|
||||
op->can_id = msg_head->can_id;
|
||||
op->can_id = msg_head->can_id;
|
||||
op->cfsiz = CFSIZ(msg_head->flags);
|
||||
op->flags = msg_head->flags;
|
||||
|
||||
/* create array for can_frames and copy the data */
|
||||
/* create array for CAN frames and copy the data */
|
||||
if (msg_head->nframes > 1) {
|
||||
op->frames = kmalloc(msg_head->nframes * CFSIZ,
|
||||
op->frames = kmalloc(msg_head->nframes * op->cfsiz,
|
||||
GFP_KERNEL);
|
||||
if (!op->frames) {
|
||||
kfree(op);
|
||||
|
|
@ -897,10 +934,17 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
op->frames = &op->sframe;
|
||||
|
||||
for (i = 0; i < msg_head->nframes; i++) {
|
||||
err = memcpy_from_msg((u8 *)&op->frames[i], msg, CFSIZ);
|
||||
|
||||
if (op->frames[i].can_dlc > 8)
|
||||
err = -EINVAL;
|
||||
cf = op->frames + op->cfsiz * i;
|
||||
err = memcpy_from_msg((u8 *)cf, msg, op->cfsiz);
|
||||
|
||||
if (op->flags & CAN_FD_FRAME) {
|
||||
if (cf->len > 64)
|
||||
err = -EINVAL;
|
||||
} else {
|
||||
if (cf->len > 8)
|
||||
err = -EINVAL;
|
||||
}
|
||||
|
||||
if (err < 0) {
|
||||
if (op->frames != &op->sframe)
|
||||
|
|
@ -911,7 +955,7 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
|
||||
if (msg_head->flags & TX_CP_CAN_ID) {
|
||||
/* copy can_id into frame */
|
||||
op->frames[i].can_id = msg_head->can_id;
|
||||
cf->can_id = msg_head->can_id;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -946,8 +990,6 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
|
||||
/* check flags */
|
||||
|
||||
op->flags = msg_head->flags;
|
||||
|
||||
if (op->flags & TX_RESET_MULTI_IDX) {
|
||||
/* start multiple frame transmission with index 0 */
|
||||
op->currframe = 0;
|
||||
|
|
@ -968,7 +1010,7 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
|
||||
if (op->flags & STARTTIMER) {
|
||||
hrtimer_cancel(&op->timer);
|
||||
/* spec: send can_frame when starting timer */
|
||||
/* spec: send CAN frame when starting timer */
|
||||
op->flags |= TX_ANNOUNCE;
|
||||
}
|
||||
|
||||
|
|
@ -981,7 +1023,7 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
if (op->flags & STARTTIMER)
|
||||
bcm_tx_start_timer(op);
|
||||
|
||||
return msg_head->nframes * CFSIZ + MHSIZ;
|
||||
return msg_head->nframes * op->cfsiz + MHSIZ;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1012,12 +1054,12 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
return -EINVAL;
|
||||
|
||||
/* check the given can_id */
|
||||
op = bcm_find_op(&bo->rx_ops, msg_head->can_id, ifindex);
|
||||
op = bcm_find_op(&bo->rx_ops, msg_head, ifindex);
|
||||
if (op) {
|
||||
/* update existing BCM operation */
|
||||
|
||||
/*
|
||||
* Do we need more space for the can_frames than currently
|
||||
* Do we need more space for the CAN frames than currently
|
||||
* allocated? -> This is a _really_ unusual use-case and
|
||||
* therefore (complexity / locking) it is not supported.
|
||||
*/
|
||||
|
|
@ -1025,17 +1067,18 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
return -E2BIG;
|
||||
|
||||
if (msg_head->nframes) {
|
||||
/* update can_frames content */
|
||||
/* update CAN frames content */
|
||||
err = memcpy_from_msg((u8 *)op->frames, msg,
|
||||
msg_head->nframes * CFSIZ);
|
||||
msg_head->nframes * op->cfsiz);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
/* clear last_frames to indicate 'nothing received' */
|
||||
memset(op->last_frames, 0, msg_head->nframes * CFSIZ);
|
||||
memset(op->last_frames, 0, msg_head->nframes * op->cfsiz);
|
||||
}
|
||||
|
||||
op->nframes = msg_head->nframes;
|
||||
op->flags = msg_head->flags;
|
||||
|
||||
/* Only an update -> do not call can_rx_register() */
|
||||
do_rx_register = 0;
|
||||
|
|
@ -1046,20 +1089,22 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
if (!op)
|
||||
return -ENOMEM;
|
||||
|
||||
op->can_id = msg_head->can_id;
|
||||
op->nframes = msg_head->nframes;
|
||||
op->can_id = msg_head->can_id;
|
||||
op->nframes = msg_head->nframes;
|
||||
op->cfsiz = CFSIZ(msg_head->flags);
|
||||
op->flags = msg_head->flags;
|
||||
|
||||
if (msg_head->nframes > 1) {
|
||||
/* create array for can_frames and copy the data */
|
||||
op->frames = kmalloc(msg_head->nframes * CFSIZ,
|
||||
/* create array for CAN frames and copy the data */
|
||||
op->frames = kmalloc(msg_head->nframes * op->cfsiz,
|
||||
GFP_KERNEL);
|
||||
if (!op->frames) {
|
||||
kfree(op);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/* create and init array for received can_frames */
|
||||
op->last_frames = kzalloc(msg_head->nframes * CFSIZ,
|
||||
/* create and init array for received CAN frames */
|
||||
op->last_frames = kzalloc(msg_head->nframes * op->cfsiz,
|
||||
GFP_KERNEL);
|
||||
if (!op->last_frames) {
|
||||
kfree(op->frames);
|
||||
|
|
@ -1074,7 +1119,7 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
|
||||
if (msg_head->nframes) {
|
||||
err = memcpy_from_msg((u8 *)op->frames, msg,
|
||||
msg_head->nframes * CFSIZ);
|
||||
msg_head->nframes * op->cfsiz);
|
||||
if (err < 0) {
|
||||
if (op->frames != &op->sframe)
|
||||
kfree(op->frames);
|
||||
|
|
@ -1116,7 +1161,6 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
} /* if ((op = bcm_find_op(&bo->rx_ops, msg_head->can_id, ifindex))) */
|
||||
|
||||
/* check flags */
|
||||
op->flags = msg_head->flags;
|
||||
|
||||
if (op->flags & RX_RTR_FRAME) {
|
||||
|
||||
|
|
@ -1188,13 +1232,14 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
|
|||
}
|
||||
}
|
||||
|
||||
return msg_head->nframes * CFSIZ + MHSIZ;
|
||||
return msg_head->nframes * op->cfsiz + MHSIZ;
|
||||
}
|
||||
|
||||
/*
|
||||
* bcm_tx_send - send a single CAN frame to the CAN interface (for bcm_sendmsg)
|
||||
*/
|
||||
static int bcm_tx_send(struct msghdr *msg, int ifindex, struct sock *sk)
|
||||
static int bcm_tx_send(struct msghdr *msg, int ifindex, struct sock *sk,
|
||||
int cfsiz)
|
||||
{
|
||||
struct sk_buff *skb;
|
||||
struct net_device *dev;
|
||||
|
|
@ -1204,13 +1249,13 @@ static int bcm_tx_send(struct msghdr *msg, int ifindex, struct sock *sk)
|
|||
if (!ifindex)
|
||||
return -ENODEV;
|
||||
|
||||
skb = alloc_skb(CFSIZ + sizeof(struct can_skb_priv), GFP_KERNEL);
|
||||
skb = alloc_skb(cfsiz + sizeof(struct can_skb_priv), GFP_KERNEL);
|
||||
if (!skb)
|
||||
return -ENOMEM;
|
||||
|
||||
can_skb_reserve(skb);
|
||||
|
||||
err = memcpy_from_msg(skb_put(skb, CFSIZ), msg, CFSIZ);
|
||||
err = memcpy_from_msg(skb_put(skb, cfsiz), msg, cfsiz);
|
||||
if (err < 0) {
|
||||
kfree_skb(skb);
|
||||
return err;
|
||||
|
|
@ -1232,7 +1277,7 @@ static int bcm_tx_send(struct msghdr *msg, int ifindex, struct sock *sk)
|
|||
if (err)
|
||||
return err;
|
||||
|
||||
return CFSIZ + MHSIZ;
|
||||
return cfsiz + MHSIZ;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1244,13 +1289,23 @@ static int bcm_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
|
|||
struct bcm_sock *bo = bcm_sk(sk);
|
||||
int ifindex = bo->ifindex; /* default ifindex for this bcm_op */
|
||||
struct bcm_msg_head msg_head;
|
||||
int cfsiz;
|
||||
int ret; /* read bytes or error codes as return value */
|
||||
|
||||
if (!bo->bound)
|
||||
return -ENOTCONN;
|
||||
|
||||
/* check for valid message length from userspace */
|
||||
if (size < MHSIZ || (size - MHSIZ) % CFSIZ)
|
||||
if (size < MHSIZ)
|
||||
return -EINVAL;
|
||||
|
||||
/* read message head information */
|
||||
ret = memcpy_from_msg((u8 *)&msg_head, msg, MHSIZ);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
cfsiz = CFSIZ(msg_head.flags);
|
||||
if ((size - MHSIZ) % cfsiz)
|
||||
return -EINVAL;
|
||||
|
||||
/* check for alternative ifindex for this bcm_op */
|
||||
|
|
@ -1284,12 +1339,6 @@ static int bcm_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
|
|||
}
|
||||
}
|
||||
|
||||
/* read message head information */
|
||||
|
||||
ret = memcpy_from_msg((u8 *)&msg_head, msg, MHSIZ);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
lock_sock(sk);
|
||||
|
||||
switch (msg_head.opcode) {
|
||||
|
|
@ -1303,14 +1352,14 @@ static int bcm_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
|
|||
break;
|
||||
|
||||
case TX_DELETE:
|
||||
if (bcm_delete_tx_op(&bo->tx_ops, msg_head.can_id, ifindex))
|
||||
if (bcm_delete_tx_op(&bo->tx_ops, &msg_head, ifindex))
|
||||
ret = MHSIZ;
|
||||
else
|
||||
ret = -EINVAL;
|
||||
break;
|
||||
|
||||
case RX_DELETE:
|
||||
if (bcm_delete_rx_op(&bo->rx_ops, msg_head.can_id, ifindex))
|
||||
if (bcm_delete_rx_op(&bo->rx_ops, &msg_head, ifindex))
|
||||
ret = MHSIZ;
|
||||
else
|
||||
ret = -EINVAL;
|
||||
|
|
@ -1329,11 +1378,11 @@ static int bcm_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
|
|||
break;
|
||||
|
||||
case TX_SEND:
|
||||
/* we need exactly one can_frame behind the msg head */
|
||||
if ((msg_head.nframes != 1) || (size != CFSIZ + MHSIZ))
|
||||
/* we need exactly one CAN frame behind the msg head */
|
||||
if ((msg_head.nframes != 1) || (size != cfsiz + MHSIZ))
|
||||
ret = -EINVAL;
|
||||
else
|
||||
ret = bcm_tx_send(msg, ifindex, sk);
|
||||
ret = bcm_tx_send(msg, ifindex, sk, cfsiz);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -517,8 +517,7 @@ void can_init_proc(void)
|
|||
can_dir = proc_mkdir("can", init_net.proc_net);
|
||||
|
||||
if (!can_dir) {
|
||||
printk(KERN_INFO "can: failed to create /proc/net/can . "
|
||||
"CONFIG_PROC_FS missing?\n");
|
||||
pr_info("can: failed to create /proc/net/can.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче