* Re: [PATCH v5] can: add Renesas R-Car CAN driver
From: Marc Kleine-Budde @ 2014-01-20 9:18 UTC (permalink / raw)
To: Sergei Shtylyov, netdev, wg, linux-can; +Cc: linux-sh, vksavl
In-Reply-To: <201312270037.15822.sergei.shtylyov@cogentembedded.com>
[-- Attachment #1: Type: text/plain, Size: 37958 bytes --]
On 12/26/2013 10:37 PM, Sergei Shtylyov wrote:
> Add support for the CAN controller found in Renesas R-Car SoCs.
>
> Signed-off-by: Sergei Shtylyov <sergei.shtylyov@cogentembedded.com>
>
> ---
> The patch is against the 'linux-can-next.git' repo.
>
> Changes in version 5:
> - removed the code specific to the mailbox mode handling and added the code
> for the FIFO mode, dropping support for CAN_CTRLMODE_ONE_SHOT;
> - stop accumulating errors in the byte 1 of an error frame;
> - added #define RCAR_CAN_CTLR_CANM for CTLR.CANM field, added 'CANM_' infix to
> all its values;
> - replaced ~RCAR_CAN_CTLR_CANM_FORCE_RESET with ~RCAR_CAN_CTLR_CANM;
> - added polling for the CAN reset status bit when going from/to CAN reset.
>
> Changes in version 4:
> - added 'RCAR_CAN_' prefix to all #define's;
> - replaced all BIT(N) invocations with (1 << N) which allowed to remove casts
> to 'u8';
> - called rcar_can_set_bittiming() from rcar_can_start() again and stopped
> registering it as do_set_bittiming() method which allowed to remove clock
> API calls and control register writes from this function and make it *void*;
> - added #define RCAR_CAN_CTLR_IDFM for more clarity;
> - clarified comment to #define RCAR_CAN_IER_TXMIE;
> - did some whitespace cleanups.
>
> Changes in version 3:
> - replaced the register #define's with 'struct rcar_can_regs' fields, replaced
> rcar_can_{read|write}[bwl]() with mere {read|write}[bwl]();
> - removed hardware bus-off recovery support which allowed to also remove
> rcar_can_start() prototype;
> - added RX/TX error count to error data frame for error warning/passive;
> - moved TX completion interrupt handling into separate function;
> - added '__packed' to 'struct rcar_can_mbox_regs' and 'struct rcar_can_regs';
> - removed unneeded type cast in the probe() method.
>
> Changes in version 2:
> - added function to clean up TX mailboxes after bus error and bus-off;
> - added module parameter to enable hardware recovery from bus-off, added handler
> for the bus-off recovery interrupt, and set the control register according to
> the parameter value and the restart timer setting in rcar_can_start();
> - changed the way CAN_ERR_CRTL_[RT]X_{PASSIVE|WARNING} flags are set to a more
> realistic one;
> - replaced MBX_* macros and rcar_can_mbx_{read|write}[bl]() functions with
> 'struct rcar_can_mbox_regs', 'struct rcar_can_regs', and {read|write}[bl](),
> replaced 'reg_base' field of 'struct rcar_can_priv' with 'struct rcar_can_regs
> __iomem *regs';
> - added 'ier' field to 'struct rcar_can_priv' to cache the current value of the
> interrupt enable register;
> - added a check for enabled interrupts on entry to rcar_can_interrupt();
> - limited transmit mailbox search loop in rcar_can_interrupt();
> - decoupled TX byte count increment from can_get_echo_skb() call;
> - removed netif_queue_stopped() call from rcar_can_interrupt();
> - added clk_prepare_enable()/clk_disable_unprepare() to ndo_{open|close}(),
> do_set_bittiming(), and do_get_berr_counter() methods, removed clk_enable()
> call from the probe() method and clk_disable() call from the remove() method;
> - allowed rcar_can_set_bittiming() to be called when the device is closed and
> remove explicit call to it from rcar_can_start();
> - switched to using mailbox number priority transmit mode, and switched to the
> sequential mailbox use in ndo_start_xmit() method;
> - stopped reading the message control registers in ndo_start_xmit() method;
> - avoided returning NETDEV_TX_BUSY from ndo_start_xmit() method;
> - stopped reading data when RTR bit is set in the CAN frame;
> - made 'num_pkts' variable *int* and moved its check to the *while* condition in
> rcar_can_rx_poll();
> - used dev_get_platdata() in the probe() method;
> - enabled bus error interrupt only if CAN_CTRLMODE_BERR_REPORTING flag is set;
> - started reporting CAN_CTRLMODE_BERR_REPORTING support and stopped reporting
> CAN_CTRLMODE_3_SAMPLES support;
> - set CAN_ERR_ACK flag on ACK error;
> - switched to incrementing bus error counter only once per bus error interrupt;
> - started switching to CAN sleep mode in rcar_can_stop() and stopped switching
> to it in the remove() method;
> - removed netdev_err() calls on allocation failure in rcar_can_error() and
> rcar_can_rx_pkt();
> - removed "CANi" from the register offset macro comments.
>
> drivers/net/can/Kconfig | 9
> drivers/net/can/Makefile | 1
> drivers/net/can/rcar_can.c | 857 ++++++++++++++++++++++++++++++++++
> include/linux/can/platform/rcar_can.h | 15
> 4 files changed, 882 insertions(+)
>
> Index: linux-can-next/drivers/net/can/Kconfig
> ===================================================================
> --- linux-can-next.orig/drivers/net/can/Kconfig
> +++ linux-can-next/drivers/net/can/Kconfig
> @@ -125,6 +125,15 @@ config CAN_GRCAN
> endian syntheses of the cores would need some modifications on
> the hardware level to work.
>
> +config CAN_RCAR
> + tristate "Renesas R-Car CAN controller"
> + ---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.
> +
> source "drivers/net/can/mscan/Kconfig"
>
> source "drivers/net/can/sja1000/Kconfig"
> Index: linux-can-next/drivers/net/can/Makefile
> ===================================================================
> --- linux-can-next.orig/drivers/net/can/Makefile
> +++ linux-can-next/drivers/net/can/Makefile
> @@ -25,5 +25,6 @@ obj-$(CONFIG_CAN_JANZ_ICAN3) += janz-ica
> obj-$(CONFIG_CAN_FLEXCAN) += flexcan.o
> obj-$(CONFIG_PCH_CAN) += pch_can.o
> obj-$(CONFIG_CAN_GRCAN) += grcan.o
> +obj-$(CONFIG_CAN_RCAR) += rcar_can.o
>
> ccflags-$(CONFIG_CAN_DEBUG_DEVICES) := -DDEBUG
> Index: linux-can-next/drivers/net/can/rcar_can.c
> ===================================================================
> --- /dev/null
> +++ linux-can-next/drivers/net/can/rcar_can.c
> @@ -0,0 +1,857 @@
> +/*
> + * Renesas R-Car CAN device driver
> + *
> + * Copyright (C) 2013 Cogent Embedded, Inc. <source@cogentembedded.com>
> + * Copyright (C) 2013 Renesas Solutions Corp.
> + *
> + * This program is free software; you can redistribute it and/or modify it
> + * under the terms of the GNU General Public License as published by the
> + * Free Software Foundation; either version 2 of the License, or (at your
> + * option) any later version.
> + */
> +
> +#include <linux/module.h>
> +#include <linux/kernel.h>
> +#include <linux/types.h>
> +#include <linux/interrupt.h>
> +#include <linux/errno.h>
> +#include <linux/netdevice.h>
> +#include <linux/platform_device.h>
> +#include <linux/can/led.h>
> +#include <linux/can/dev.h>
> +#include <linux/clk.h>
> +#include <linux/can/platform/rcar_can.h>
> +
> +#define RCAR_CAN_DRV_NAME "rcar_can"
> +
> +/* Mailbox configuration:
> + * mailbox 60 - 63 - Rx FIFO mailboxes
> + * mailbox 56 - 59 - Tx FIFO mailboxes
> + * non-FIFO mailboxes are not used
> + */
> +#define RCAR_CAN_N_MBX 64 /* Number of mailboxes in non-FIFO mode */
> +#define RCAR_CAN_RX_FIFO_MBX 60 /* Mailbox - window to Rx FIFO */
> +#define RCAR_CAN_TX_FIFO_MBX 56 /* Mailbox - window to Tx FIFO */
> +#define RCAR_CAN_N_ECHO_SKB 10
> +
> +/* Mailbox registers structure */
> +struct rcar_can_mbox_regs {
> + u32 id; /* IDE and RTR bits, SID and EID */
> + u8 stub; /* Not used */
> + u8 dlc; /* Data Length Code - bits [0..3] */
> + u8 data[8]; /* Data Bytes */
> + u8 tsh; /* Time Stamp Higher Byte */
> + u8 tsl; /* Time Stamp Lower Byte */
> +} __packed;
If you have contact to the hardware designer please blame him for
placing the data register unaligned into the register space. :)
> +
> +struct rcar_can_regs {
> + struct rcar_can_mbox_regs mb[RCAR_CAN_N_MBX]; /* Mailbox registers */
> + u32 mkr_2_9[8]; /* Mask Registers 2-9 */
> + u32 fidcr[2]; /* FIFO Received ID Compare Register */
> + u32 mkivlr1; /* Mask Invalid Register 1 */
> + u32 mier1; /* Mailbox Interrupt Enable Register 1 */
> + u32 mkr_0_1[2]; /* Mask Registers 0-1 */
> + u32 mkivlr0; /* Mask Invalid Register 0*/
> + u32 mier0; /* Mailbox Interrupt Enable Register 0 */
> + u8 pad_440[0x3c0];
> + u8 mctl[64]; /* Message Control Registers */
> + u16 ctlr; /* Control Register */
> + u16 str; /* Status register */
> + u8 bcr[3]; /* Bit Configuration Register */
> + u8 clkr; /* Clock Select Register */
bcr[3] and clkr looks broken, see comment where the register is used.
> + u8 rfcr; /* Receive FIFO Control Register */
> + u8 rfpcr; /* Receive FIFO Pointer Control Register */
> + u8 tfcr; /* Transmit FIFO Control Register */
> + u8 tfpcr; /* Transmit FIFO Pointer Control Register */
> + u8 eier; /* Error Interrupt Enable Register */
> + u8 eifr; /* Error Interrupt Factor Judge Register */
> + u8 recr; /* Receive Error Count Register */
> + u8 tecr; /* Transmit Error Count Register */
> + u8 ecsr; /* Error Code Store Register */
> + u8 cssr; /* Channel Search Support Register */
> + u8 mssr; /* Mailbox Search Status Register */
> + u8 msmr; /* Mailbox Search Mode Register */
> + u16 tsr; /* Time Stamp Register */
> + u8 afsr; /* Acceptance Filter Support Register */
> + u8 pad_857;
> + u8 tcr; /* Test Control Register */
> + u8 pad_859[7];
> + u8 ier; /* Interrupt Enable Register */
> + u8 isr; /* Interrupt Status Register */
> + u8 pad_862;
> + u8 mbsmr; /* Mailbox Search Mask Register */
> +} __packed;
> +
> +struct rcar_can_priv {
> + struct can_priv can; /* Must be the first member! */
> + struct net_device *ndev;
> + struct napi_struct napi;
> + struct rcar_can_regs __iomem *regs;
> + struct clk *clk;
> + spinlock_t skb_lock;
> + u32 frames_queued;
> + u32 bytes_queued;
> + u8 clock_select;
> + u8 ier;
> +};
> +
> +static const struct can_bittiming_const rcar_can_bittiming_const = {
> + .name = RCAR_CAN_DRV_NAME,
> + .tseg1_min = 4,
> + .tseg1_max = 16,
> + .tseg2_min = 2,
> + .tseg2_max = 8,
> + .sjw_max = 4,
> + .brp_min = 1,
> + .brp_max = 1024,
> + .brp_inc = 1,
> +};
> +
> +/* Control Register bits */
> +#define RCAR_CAN_CTLR_BOM (3 << 11) /* Bus-Off Recovery Mode Bits */
> +#define RCAR_CAN_CTLR_BOM_ENT (1 << 11) /* Entry to halt mode */
> + /* at bus-off entry */
> +#define RCAR_CAN_CTLR_SLPM (1 << 10)
> +#define RCAR_CAN_CTLR_CANM (3 << 8) /* Operating Mode Select Bit */
> +#define RCAR_CAN_CTLR_CANM_HALT (1 << 9)
> +#define RCAR_CAN_CTLR_CANM_RESET (1 << 8)
> +#define RCAR_CAN_CTLR_CANM_FORCE_RESET (3 << 8)
> +#define RCAR_CAN_CTLR_MLM (1 << 3) /* Message Lost Mode Select */
> +#define RCAR_CAN_CTLR_IDFM (3 << 1) /* ID Format Mode Select Bits */
> +#define RCAR_CAN_CTLR_IDFM_MIXED (1 << 2) /* Mixed ID mode */
> +#define RCAR_CAN_CTLR_MBM (1 << 0) /* Mailbox Mode select */
> +
> +/* Status Register bits */
> +#define RCAR_CAN_STR_RSTST (1 << 8) /* Reset Status Bit */
> +
> +/* FIFO Received ID Compare Registers 0 and 1 bits */
> +#define RCAR_CAN_FIDCR_IDE (1 << 31) /* ID Extension Bit */
> +#define RCAR_CAN_FIDCR_RTR (1 << 30) /* Remote Transmission Request Bit */
> +
> +/* Receive FIFO Control Register bits */
> +#define RCAR_CAN_RFCR_RFEST (1 << 7) /* Receive FIFO Empty Status Flag */
> +#define RCAR_CAN_RFCR_RFUST (7 << 1) /* Receive FIFO Unread Message */
> + /* Number Status Bits */
> +#define RCAR_CAN_RFCR_RFUST_SHIFT 1 /* Offset of Receive FIFO Unread */
> + /* Message Number Status Bits */
> +#define RCAR_CAN_RFCR_RFE (1 << 0) /* Receive FIFO Enable */
> +
> +/* Transmit FIFO Control Register bits */
> +#define RCAR_CAN_TFCR_TFUST (7 << 1) /* Transmit FIFO Unsent Message */
> + /* Number Status Bits */
> +#define RCAR_CAN_TFCR_TFUST_SHIFT 1 /* Offset of Transmit FIFO Unsent */
> + /* Message Number Status Bits */
> +#define RCAR_CAN_TFCR_TFE (1 << 0) /* Transmit FIFO Enable */
> +
> +#define RCAR_CAN_N_RX_MKREGS1 2 /* Number of mask registers */
> + /* for Rx mailboxes 0-31 */
> +#define RCAR_CAN_N_RX_MKREGS2 8
> +
> +/* Bit Configuration Register settings */
> +#define RCAR_CAN_BCR_TSEG1(x) (((x) & 0x0f) << 28)
> +#define RCAR_CAN_BCR_BPR(x) (((x) & 0x3ff) << 16)
> +#define RCAR_CAN_BCR_SJW(x) (((x) & 0x3) << 12)
> +#define RCAR_CAN_BCR_TSEG2(x) (((x) & 0x07) << 8)
> +
> +/* Mailbox and Mask Registers bits */
> +#define RCAR_CAN_IDE (1 << 31)
> +#define RCAR_CAN_RTR (1 << 30)
> +#define RCAR_CAN_SID_SHIFT 18
> +
> +/* Mailbox Interrupt Enable Register 1 bits */
> +#define RCAR_CAN_MIER1_RXFIE (1 << 28) /* Receive FIFO Interrupt Enable */
> +#define RCAR_CAN_MIER1_TXFIT (1 << 25) /* Transmit FIFO Interrupt Timing */
> + /* Generate interrupt when */
> + /* Tx FIFO becomes empty due to */
> + /* completion of transmission */
> +#define RCAR_CAN_MIER1_TXFIE (1 << 24) /* Transmit FIFO Interrupt Enable */
> +
> +/* Interrupt Enable Register bits */
> +#define RCAR_CAN_IER_ERSIE (1 << 5) /* Error (ERS) Interrupt Enable Bit */
> +#define RCAR_CAN_IER_RXFIE (1 << 4) /* Reception FIFO Interrupt */
> + /* Enable Bit */
> +#define RCAR_CAN_IER_TXFIE (1 << 3) /* Transmission FIFO Interrupt */
> + /* Enable Bit */
> +/* Interrupt Status Register bits */
> +#define RCAR_CAN_ISR_ERSF (1 << 5) /* Error (ERS) Interrupt Status Bit */
> +#define RCAR_CAN_ISR_RXFF (1 << 4) /* Reception FIFO Interrupt */
> + /* Status Bit */
> +#define RCAR_CAN_ISR_TXFF (1 << 3) /* Transmission FIFO Interrupt */
> + /* Status Bit */
> +
> +/* Error Interrupt Enable Register bits */
> +#define RCAR_CAN_EIER_BLIE (1 << 7) /* Bus Lock Interrupt Enable */
> +#define RCAR_CAN_EIER_OLIE (1 << 6) /* Overload Frame Transmit */
> + /* Interrupt Enable */
> +#define RCAR_CAN_EIER_ORIE (1 << 5) /* Receive Overrun Interrupt Enable */
> +#define RCAR_CAN_EIER_BORIE (1 << 4) /* Bus-Off Recovery Interrupt Enable */
> +#define RCAR_CAN_EIER_BOEIE (1 << 3) /* Bus-Off Entry Interrupt Enable */
> +#define RCAR_CAN_EIER_EPIE (1 << 2) /* Error Passive Interrupt Enable */
> +#define RCAR_CAN_EIER_EWIE (1 << 1) /* Error Warning Interrupt Enable */
> +#define RCAR_CAN_EIER_BEIE (1 << 0) /* Bus Error Interrupt Enable */
> +
> +/* Error Interrupt Factor Judge Register bits */
> +#define RCAR_CAN_EIFR_BLIF (1 << 7) /* Bus Lock Detect Flag */
> +#define RCAR_CAN_EIFR_OLIF (1 << 6) /* Overload Frame Transmission */
> + /* Detect Flag */
> +#define RCAR_CAN_EIFR_ORIF (1 << 5) /* Receive Overrun Detect Flag */
> +#define RCAR_CAN_EIFR_BORIF (1 << 4) /* Bus-Off Recovery Detect Flag */
> +#define RCAR_CAN_EIFR_BOEIF (1 << 3) /* Bus-Off Entry Detect Flag */
> +#define RCAR_CAN_EIFR_EPIF (1 << 2) /* Error Passive Detect Flag */
> +#define RCAR_CAN_EIFR_EWIF (1 << 1) /* Error Warning Detect Flag */
> +#define RCAR_CAN_EIFR_BEIF (1 << 0) /* Bus Error Detect Flag */
> +
> +/* Error Code Store Register bits */
> +#define RCAR_CAN_ECSR_EDPM (1 << 7) /* Error Display Mode Select Bit */
> +#define RCAR_CAN_ECSR_ADEF (1 << 6) /* ACK Delimiter Error Flag */
> +#define RCAR_CAN_ECSR_BE0F (1 << 5) /* Bit Error (dominant) Flag */
> +#define RCAR_CAN_ECSR_BE1F (1 << 4) /* Bit Error (recessive) Flag */
> +#define RCAR_CAN_ECSR_CEF (1 << 3) /* CRC Error Flag */
> +#define RCAR_CAN_ECSR_AEF (1 << 2) /* ACK Error Flag */
> +#define RCAR_CAN_ECSR_FEF (1 << 1) /* Form Error Flag */
> +#define RCAR_CAN_ECSR_SEF (1 << 0) /* Stuff Error Flag */
> +
> +#define RCAR_CAN_NAPI_WEIGHT 4
> +
> +static void tx_failure_cleanup(struct net_device *ndev)
> +{
> + u32 i;
> +
> + for (i = 0; i < RCAR_CAN_N_ECHO_SKB; i++)
> + can_free_echo_skb(ndev, i);
> +}
> +
> +static void rcar_can_error(struct net_device *ndev)
> +{
> + struct rcar_can_priv *priv = netdev_priv(ndev);
> + struct net_device_stats *stats = &ndev->stats;
> + struct can_frame *cf;
> + struct sk_buff *skb;
> + u8 eifr, txerr = 0, rxerr = 0;
> +
> + /* Propagate the error condition to the CAN stack */
> + skb = alloc_can_err_skb(ndev, &cf);
> + if (!skb)
> + return;
> +
> + eifr = readb(&priv->regs->eifr);
> + if (eifr & (RCAR_CAN_EIFR_EWIF | RCAR_CAN_EIFR_EPIF)) {
> + cf->can_id |= CAN_ERR_CRTL;
> + txerr = readb(&priv->regs->tecr);
> + rxerr = readb(&priv->regs->recr);
> + cf->data[6] = txerr;
> + cf->data[7] = rxerr;
> + }
> + if (eifr & RCAR_CAN_EIFR_BEIF) {
> + int rx_errors = 0, tx_errors = 0;
> + u8 ecsr;
> +
> + netdev_dbg(priv->ndev, "Bus error interrupt:\n");
> + cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT;
> + cf->data[2] = CAN_ERR_PROT_UNSPEC;
> +
> + ecsr = readb(&priv->regs->ecsr);
> + if (ecsr & RCAR_CAN_ECSR_ADEF) {
> + netdev_dbg(priv->ndev, "ACK Delimiter Error\n");
> + cf->data[3] |= CAN_ERR_PROT_LOC_ACK_DEL;
> + tx_errors++;
> + writeb(~RCAR_CAN_ECSR_ADEF, &priv->regs->ecsr);
> + }
> + if (ecsr & RCAR_CAN_ECSR_BE0F) {
> + netdev_dbg(priv->ndev, "Bit Error (dominant)\n");
> + cf->data[2] |= CAN_ERR_PROT_BIT0;
> + tx_errors++;
> + writeb(~RCAR_CAN_ECSR_BE0F, &priv->regs->ecsr);
> + }
> + if (ecsr & RCAR_CAN_ECSR_BE1F) {
> + netdev_dbg(priv->ndev, "Bit Error (recessive)\n");
> + cf->data[2] |= CAN_ERR_PROT_BIT1;
> + tx_errors++;
> + writeb(~RCAR_CAN_ECSR_BE1F, &priv->regs->ecsr);
> + }
> + if (ecsr & RCAR_CAN_ECSR_CEF) {
> + netdev_dbg(priv->ndev, "CRC Error\n");
> + cf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ;
> + rx_errors++;
> + writeb(~RCAR_CAN_ECSR_CEF, &priv->regs->ecsr);
> + }
> + if (ecsr & RCAR_CAN_ECSR_AEF) {
> + netdev_dbg(priv->ndev, "ACK Error\n");
> + cf->can_id |= CAN_ERR_ACK;
> + cf->data[3] |= CAN_ERR_PROT_LOC_ACK;
> + tx_errors++;
> + writeb(~RCAR_CAN_ECSR_AEF, &priv->regs->ecsr);
> + }
> + if (ecsr & RCAR_CAN_ECSR_FEF) {
> + netdev_dbg(priv->ndev, "Form Error\n");
> + cf->data[2] |= CAN_ERR_PROT_FORM;
> + rx_errors++;
> + writeb(~RCAR_CAN_ECSR_FEF, &priv->regs->ecsr);
> + }
> + if (ecsr & RCAR_CAN_ECSR_SEF) {
> + netdev_dbg(priv->ndev, "Stuff Error\n");
> + cf->data[2] |= CAN_ERR_PROT_STUFF;
> + rx_errors++;
> + writeb(~RCAR_CAN_ECSR_SEF, &priv->regs->ecsr);
> + }
> +
> + priv->can.can_stats.bus_error++;
> + ndev->stats.rx_errors += rx_errors;
> + ndev->stats.tx_errors += tx_errors;
> + writeb(~RCAR_CAN_EIFR_BEIF, &priv->regs->eifr);
> + }
> + if (eifr & RCAR_CAN_EIFR_EWIF) {
> + netdev_dbg(priv->ndev, "Error warning interrupt\n");
> + priv->can.state = CAN_STATE_ERROR_WARNING;
> + priv->can.can_stats.error_warning++;
> + cf->data[1] = txerr > rxerr ? CAN_ERR_CRTL_TX_WARNING :
> + CAN_ERR_CRTL_RX_WARNING;
> + /* Clear interrupt condition */
> + writeb(~RCAR_CAN_EIFR_EWIF, &priv->regs->eifr);
> + }
> + if (eifr & RCAR_CAN_EIFR_EPIF) {
> + netdev_dbg(priv->ndev, "Error passive interrupt\n");
> + priv->can.state = CAN_STATE_ERROR_PASSIVE;
> + priv->can.can_stats.error_passive++;
> + cf->data[1] = txerr > rxerr ? CAN_ERR_CRTL_TX_PASSIVE :
> + CAN_ERR_CRTL_RX_PASSIVE;
> + /* Clear interrupt condition */
> + writeb(~RCAR_CAN_EIFR_EPIF, &priv->regs->eifr);
> + }
> + if (eifr & RCAR_CAN_EIFR_BOEIF) {
> + netdev_dbg(priv->ndev, "Bus-off entry interrupt\n");
> + tx_failure_cleanup(ndev);
> + priv->ier = RCAR_CAN_IER_ERSIE;
> + writeb(priv->ier, &priv->regs->ier);
> + priv->can.state = CAN_STATE_BUS_OFF;
> + cf->can_id |= CAN_ERR_BUSOFF;
> + /* Clear interrupt condition */
> + writeb(~RCAR_CAN_EIFR_BOEIF, &priv->regs->eifr);
> + can_bus_off(ndev);
> + }
> + if (eifr & RCAR_CAN_EIFR_ORIF) {
> + netdev_dbg(priv->ndev, "Receive overrun error interrupt\n");
> + cf->can_id |= CAN_ERR_CRTL;
> + cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
> + ndev->stats.rx_over_errors++;
> + ndev->stats.rx_errors++;
> + writeb(~RCAR_CAN_EIFR_ORIF, &priv->regs->eifr);
> + }
> + if (eifr & RCAR_CAN_EIFR_OLIF) {
> + netdev_dbg(priv->ndev,
> + "Overload Frame Transmission error interrupt\n");
> + cf->can_id |= CAN_ERR_PROT;
> + cf->data[2] |= CAN_ERR_PROT_OVERLOAD;
> + ndev->stats.rx_over_errors++;
> + ndev->stats.rx_errors++;
> + writeb(~RCAR_CAN_EIFR_OLIF, &priv->regs->eifr);
> + }
> +
> + netif_rx(skb);
> + stats->rx_packets++;
> + stats->rx_bytes += cf->can_dlc;
> +}
> +
> +static void rcar_can_tx_done(struct net_device *ndev)
> +{
> + struct rcar_can_priv *priv = netdev_priv(ndev);
> + struct net_device_stats *stats = &ndev->stats;
> + int i;
> +
> + spin_lock(&priv->skb_lock);
> + for (i = 0; i < priv->frames_queued; i++)
> + can_get_echo_skb(ndev, i);
> + stats->tx_bytes += priv->bytes_queued;
> + stats->tx_packets += priv->frames_queued;
> + priv->bytes_queued = 0;
> + priv->frames_queued = 0;
> + spin_unlock(&priv->skb_lock);
This looks broken. What happens if you send 2 CAN frames in a row, the
first one is send, a TX complete interrupt is issued and you handle it
here? You assume, that all CAN frames have been sent.
> + can_led_event(ndev, CAN_LED_EVENT_TX);
> + netif_wake_queue(ndev);
> +}
> +
> +static irqreturn_t rcar_can_interrupt(int irq, void *dev_id)
> +{
> + struct net_device *ndev = (struct net_device *)dev_id;
the cast is not needed
> + struct rcar_can_priv *priv = netdev_priv(ndev);
> + u8 isr;
> +
> + isr = readb(&priv->regs->isr);
> + if (!(isr & priv->ier))
> + return IRQ_NONE;
> +
> + if (isr & RCAR_CAN_ISR_ERSF)
> + rcar_can_error(ndev);
> +
> + if (isr & RCAR_CAN_ISR_TXFF) {
> + /* Clear interrupt */
> + writeb(isr & ~RCAR_CAN_ISR_TXFF, &priv->regs->isr);
> + rcar_can_tx_done(ndev);
> + }
> +
> + if (isr & RCAR_CAN_ISR_RXFF) {
> + if (napi_schedule_prep(&priv->napi)) {
> + /* Disable Rx FIFO interrupts */
> + priv->ier &= ~RCAR_CAN_IER_RXFIE;
> + writeb(priv->ier, &priv->regs->ier);
> + __napi_schedule(&priv->napi);
> + }
> + }
> +
> + return IRQ_HANDLED;
> +}
> +
> +static void rcar_can_set_bittiming(struct net_device *dev)
> +{
> + struct rcar_can_priv *priv = netdev_priv(dev);
> + struct can_bittiming *bt = &priv->can.bittiming;
> + u32 bcr;
> + u8 clkr;
> +
> + /* Don't overwrite CLKR with 32-bit BCR access */
> + /* CLKR has 8-bit access */
Can you explain the register layout here? Why do you access BCR with 32
bits when the register is defined as 3x8 bit? Can't you make it a
standard 32 bit register?
> + clkr = readb(&priv->regs->clkr);
> + bcr = RCAR_CAN_BCR_TSEG1(bt->phase_seg1 + bt->prop_seg - 1) |
> + RCAR_CAN_BCR_BPR(bt->brp - 1) | RCAR_CAN_BCR_SJW(bt->sjw - 1) |
> + RCAR_CAN_BCR_TSEG2(bt->phase_seg2 - 1);
> + writel(bcr, &priv->regs->bcr);
> + writeb(clkr, &priv->regs->clkr);
> +}
> +
> +static void rcar_can_start(struct net_device *ndev)
> +{
> + struct rcar_can_priv *priv = netdev_priv(ndev);
> + u16 ctlr, str;
> +
> + /* Set controller to known mode:
> + * - FIFO mailbox mode
> + * - accept all messages
> + * - overrun mode
> + * CAN is in sleep mode after MCU hardware or software reset.
> + */
> + ctlr = readw(&priv->regs->ctlr);
> + ctlr &= ~RCAR_CAN_CTLR_SLPM;
> + writew(ctlr, &priv->regs->ctlr);
> + /* Go to reset mode */
> + ctlr |= RCAR_CAN_CTLR_CANM_FORCE_RESET;
> + writew(ctlr, &priv->regs->ctlr);
> + do {
> + str = readw(&priv->regs->str);
> + } while (!(str & RCAR_CAN_STR_RSTST));
Please add a timeout for this loop and the loop below.
> + rcar_can_set_bittiming(ndev);
> + ctlr |= RCAR_CAN_CTLR_IDFM_MIXED; /* Select mixed ID mode */
> + ctlr |= RCAR_CAN_CTLR_BOM_ENT; /* Entry to halt mode automatically */
> + /* at bus-off */
> + ctlr |= RCAR_CAN_CTLR_MBM; /* Select FIFO mailbox mode */
> + ctlr |= RCAR_CAN_CTLR_MLM; /* Overrun mode */
> + writew(ctlr, &priv->regs->ctlr);
> +
> + writeb(priv->clock_select, &priv->regs->clkr);
> +
> + /* Accept all SID and EID */
> + writel(0, &priv->regs->mkr_2_9[6]);
> + writel(0, &priv->regs->mkr_2_9[7]);
> + /* In FIFO mailbox mode, write "0" to bits 24 to 31 */
> + writel(0, &priv->regs->mkivlr1);
> + /* Accept all frames */
> + writel(0, &priv->regs->fidcr[0]);
> + writel(RCAR_CAN_FIDCR_IDE | RCAR_CAN_FIDCR_RTR, &priv->regs->fidcr[1]);
> + /* Enable and configure FIFO mailbox interrupts */
> + writel(RCAR_CAN_MIER1_RXFIE | RCAR_CAN_MIER1_TXFIT |
> + RCAR_CAN_MIER1_TXFIE, &priv->regs->mier1);
> +
> + priv->ier = RCAR_CAN_IER_ERSIE | RCAR_CAN_IER_RXFIE |
> + RCAR_CAN_IER_TXFIE;
> + writeb(priv->ier, &priv->regs->ier);
> +
> + /* Accumulate error codes */
> + writeb(RCAR_CAN_ECSR_EDPM, &priv->regs->ecsr);
> + /* Enable error interrupts */
> + writeb(RCAR_CAN_EIER_EWIE | RCAR_CAN_EIER_EPIE | RCAR_CAN_EIER_BOEIE |
> + (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING ?
> + RCAR_CAN_EIER_BEIE : 0) | RCAR_CAN_EIER_ORIE |
> + RCAR_CAN_EIER_OLIE, &priv->regs->eier);
> + priv->can.state = CAN_STATE_ERROR_ACTIVE;
> +
> + /* Go to operation mode */
> + writew(ctlr & ~RCAR_CAN_CTLR_CANM, &priv->regs->ctlr);
> + do {
> + str = readw(&priv->regs->str);
> + } while (str & RCAR_CAN_STR_RSTST);
> + /* Enable Rx and Tx FIFO */
> + writeb(RCAR_CAN_RFCR_RFE, &priv->regs->rfcr);
> + writeb(RCAR_CAN_TFCR_TFE, &priv->regs->tfcr);
> +}
> +
> +static int rcar_can_open(struct net_device *ndev)
> +{
> + struct rcar_can_priv *priv = netdev_priv(ndev);
> + int err;
> +
> + clk_prepare_enable(priv->clk);
clk_prepare_enable can fail
> + err = open_candev(ndev);
> + if (err) {
> + netdev_err(ndev, "open_candev() failed %d\n", err);
> + goto out;
please adjust the jump label, you have to disable the clock.
> + }
> + napi_enable(&priv->napi);
> + err = request_irq(ndev->irq, rcar_can_interrupt, 0, ndev->name, ndev);
> + if (err) {
> + netdev_err(ndev, "error requesting interrupt %x\n", ndev->irq);
> + goto out_close;
> + }
> + can_led_event(ndev, CAN_LED_EVENT_OPEN);
> + rcar_can_start(ndev);
> + netif_start_queue(ndev);
> + return 0;
> +out_close:
> + napi_disable(&priv->napi);
> + close_candev(ndev);
> + clk_disable_unprepare(priv->clk);
> +out:
> + return err;
> +}
> +
> +static void rcar_can_stop(struct net_device *ndev)
> +{
> + struct rcar_can_priv *priv = netdev_priv(ndev);
> + u16 ctlr, str;
> +
> + /* Go to (force) reset mode */
> + ctlr = readw(&priv->regs->ctlr);
> + ctlr |= RCAR_CAN_CTLR_CANM_FORCE_RESET;
> + writew(ctlr, &priv->regs->ctlr);
> + do {
> + str = readw(&priv->regs->str);
> + } while (!(str & RCAR_CAN_STR_RSTST));
please add a timeout to the loop
> + writel(0, &priv->regs->mier0);
> + writel(0, &priv->regs->mier1);
> + writeb(0, &priv->regs->ier);
> + writeb(0, &priv->regs->eier);
> + /* Go to sleep mode */
> + ctlr |= RCAR_CAN_CTLR_SLPM;
> + writew(ctlr, &priv->regs->ctlr);
> + priv->can.state = CAN_STATE_STOPPED;
> +}
> +
> +static int rcar_can_close(struct net_device *ndev)
> +{
> + struct rcar_can_priv *priv = netdev_priv(ndev);
> +
> + netif_stop_queue(ndev);
> + rcar_can_stop(ndev);
> + free_irq(ndev->irq, ndev);
> + napi_disable(&priv->napi);
> + clk_disable_unprepare(priv->clk);
> + close_candev(ndev);
> + can_led_event(ndev, CAN_LED_EVENT_STOP);
> + return 0;
> +}
> +
> +static netdev_tx_t rcar_can_start_xmit(struct sk_buff *skb,
> + struct net_device *ndev)
> +{
> + struct rcar_can_priv *priv = netdev_priv(ndev);
> + struct can_frame *cf = (struct can_frame *)skb->data;
> + u32 data, i;
> + unsigned long flags;
> + u8 tfcr;
> +
> + if (can_dropped_invalid_skb(ndev, skb))
> + return NETDEV_TX_OK;
> + tfcr = readb(&priv->regs->tfcr);
> + if ((tfcr & RCAR_CAN_TFCR_TFUST) >> RCAR_CAN_TFCR_TFUST_SHIFT > 2)
> + netif_stop_queue(ndev);
Can you explain what's checked here?
> +
> + if (cf->can_id & CAN_EFF_FLAG) {
> + /* Extended frame format */
> + data = (cf->can_id & CAN_EFF_MASK) | RCAR_CAN_IDE;
> + } else {
> + /* Standard frame format */
> + data = (cf->can_id & CAN_SFF_MASK) << RCAR_CAN_SID_SHIFT;
> + }
> + if (cf->can_id & CAN_RTR_FLAG) {
> + /* Remote transmission request */
> + data |= RCAR_CAN_RTR;
> + }
You can move the comments into the line of if and else and remove the {
& } as there is only one line after if and else.
> + writel(data, &priv->regs->mb[RCAR_CAN_TX_FIFO_MBX].id);
> +
> + writeb(cf->can_dlc, &priv->regs->mb[RCAR_CAN_TX_FIFO_MBX].dlc);
> +
> + for (i = 0; i < cf->can_dlc; i++)
> + writeb(cf->data[i],
> + &priv->regs->mb[RCAR_CAN_TX_FIFO_MBX].data[i]);
> +
> + spin_lock_irqsave(&priv->skb_lock, flags);
> + can_put_echo_skb(skb, ndev, priv->frames_queued++);
> + priv->bytes_queued += cf->can_dlc;
How does the frames_queued and bytes_queued mechanism work?
> + spin_unlock_irqrestore(&priv->skb_lock, flags);
> + /* Start Tx: write 0xFF to the TFPCR register to increment
> + * the CPU-side pointer for the transmit FIFO to the next
> + * mailbox location
> + */
> + writeb(0xFF, &priv->regs->tfpcr);
please use lowercase for hex.
> +
> + return NETDEV_TX_OK;
I'm missing flow control here. You have to stop the queue if there isn't
any room in the tx fifo.
> +}
> +
> +static const struct net_device_ops rcar_can_netdev_ops = {
> + .ndo_open = rcar_can_open,
> + .ndo_stop = rcar_can_close,
> + .ndo_start_xmit = rcar_can_start_xmit,
> +};
> +
> +static void rcar_can_rx_pkt(struct rcar_can_priv *priv)
> +{
> + struct net_device_stats *stats = &priv->ndev->stats;
> + struct can_frame *cf;
> + struct sk_buff *skb;
> + u32 data;
> + u8 dlc;
> +
> + skb = alloc_can_skb(priv->ndev, &cf);
> + if (!skb) {
> + stats->rx_dropped++;
> + return;
> + }
> +
> + data = readl(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].id);
> + if (data & RCAR_CAN_IDE)
> + cf->can_id = (data & CAN_EFF_MASK) | CAN_EFF_FLAG;
> + else
> + cf->can_id = (data >> RCAR_CAN_SID_SHIFT) & CAN_SFF_MASK;
> +
> + dlc = readb(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].dlc);
> + cf->can_dlc = get_can_dlc(dlc);
> + if (data & RCAR_CAN_RTR) {
> + cf->can_id |= CAN_RTR_FLAG;
> + } else {
> + for (dlc = 0; dlc < cf->can_dlc; dlc++)
> + cf->data[dlc] =
> + readb(&priv->regs->mb[RCAR_CAN_RX_FIFO_MBX].data[dlc]);
> + }
> +
> + can_led_event(priv->ndev, CAN_LED_EVENT_RX);
> +
> + netif_receive_skb(skb);
> + stats->rx_bytes += cf->can_dlc;
> + stats->rx_packets++;
> +}
> +
> +static int rcar_can_rx_poll(struct napi_struct *napi, int quota)
> +{
> + struct rcar_can_priv *priv = container_of(napi,
> + struct rcar_can_priv, napi);
> + int num_pkts = 0;
> +
> + while (num_pkts < quota) {
> + u8 i, rfcr, nframes, isr;
> +
> + isr = readb(&priv->regs->isr);
> + /* Clear interrupt bit */
> + if (isr & RCAR_CAN_ISR_RXFF)
> + writeb(isr & ~RCAR_CAN_ISR_RXFF, &priv->regs->isr);
> + rfcr = readb(&priv->regs->rfcr);
> + if (rfcr & RCAR_CAN_RFCR_RFEST)
> + break;
> + nframes = (rfcr & RCAR_CAN_RFCR_RFUST) >>
> + RCAR_CAN_RFCR_RFUST_SHIFT;
> + for (i = 0; i < nframes; i++) {
> + rcar_can_rx_pkt(priv);
> + /* Write 0xFF to the RFPCR register to increment
> + * the CPU-side pointer for the receive FIFO
> + * to the next mailbox location
> + */
> + writeb(0xFF, &priv->regs->rfpcr);
> + ++num_pkts;
> + }
The for loop inside the while loop makes no sense if you increment
num_pkts. You are not allowed to receive more than quota CAN frames.
> + }
> + /* All packets processed */
> + if (num_pkts < quota) {
> + napi_complete(napi);
> + priv->ier |= RCAR_CAN_IER_RXFIE;
> + writeb(priv->ier, &priv->regs->ier);
> + }
> + return num_pkts;
> +}
> +
> +static int rcar_can_do_set_mode(struct net_device *ndev, enum can_mode mode)
> +{
> + switch (mode) {
> + case CAN_MODE_START:
> + rcar_can_start(ndev);
> + netif_wake_queue(ndev);
> + return 0;
> + default:
> + return -EOPNOTSUPP;
> + }
> +}
> +
> +static int rcar_can_get_berr_counter(const struct net_device *dev,
> + struct can_berr_counter *bec)
> +{
> + struct rcar_can_priv *priv = netdev_priv(dev);
> +
> + clk_prepare_enable(priv->clk);
clk_prepare_enable can fail
> + bec->txerr = readb(&priv->regs->tecr);
> + bec->rxerr = readb(&priv->regs->recr);
> + clk_disable_unprepare(priv->clk);
> + return 0;
> +}
> +
> +static int rcar_can_probe(struct platform_device *pdev)
> +{
> + struct rcar_can_platform_data *pdata;
> + struct rcar_can_priv *priv;
> + struct net_device *ndev;
> + struct resource *mem;
> + void __iomem *addr;
> + int err = -ENODEV;
> + int irq;
> +
> + pdata = dev_get_platdata(&pdev->dev);
> + if (!pdata) {
> + dev_err(&pdev->dev, "No platform data provided!\n");
> + goto fail;
> + }
> +
> + irq = platform_get_irq(pdev, 0);
> + if (!irq) {
> + dev_err(&pdev->dev, "No IRQ resource\n");
> + goto fail;
> + }
> +
> + mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> + addr = devm_ioremap_resource(&pdev->dev, mem);
> + if (IS_ERR(addr)) {
> + err = PTR_ERR(addr);
> + goto fail;
> + }
> +
> + ndev = alloc_candev(sizeof(struct rcar_can_priv), RCAR_CAN_N_ECHO_SKB);
> + if (!ndev) {
> + dev_err(&pdev->dev, "alloc_candev failed\n");
> + err = -ENOMEM;
> + goto fail;
> + }
> +
> + priv = netdev_priv(ndev);
> +
> + priv->clk = devm_clk_get(&pdev->dev, NULL);
> + if (IS_ERR(priv->clk)) {
> + err = PTR_ERR(priv->clk);
> + dev_err(&pdev->dev, "cannot get clock: %d\n", err);
> + goto fail_clk;
> + }
> +
> + ndev->netdev_ops = &rcar_can_netdev_ops;
> + ndev->irq = irq;
> + ndev->flags |= IFF_ECHO;
> + priv->ndev = ndev;
> + priv->regs = addr;
> + priv->clock_select = pdata->clock_select;
> + priv->can.clock.freq = clk_get_rate(priv->clk);
> + priv->can.bittiming_const = &rcar_can_bittiming_const;
> + priv->can.do_set_mode = rcar_can_do_set_mode;
> + priv->can.do_get_berr_counter = rcar_can_get_berr_counter;
> + priv->can.ctrlmode_supported = CAN_CTRLMODE_BERR_REPORTING;
> + platform_set_drvdata(pdev, ndev);
> + SET_NETDEV_DEV(ndev, &pdev->dev);
> + spin_lock_init(&priv->skb_lock);
> +
> + netif_napi_add(ndev, &priv->napi, rcar_can_rx_poll,
> + RCAR_CAN_NAPI_WEIGHT);
> + err = register_candev(ndev);
> + if (err) {
> + dev_err(&pdev->dev, "register_candev() failed\n");
> + goto fail_candev;
> + }
> +
> + devm_can_led_init(ndev);
> +
> + dev_info(&pdev->dev, "device registered (reg_base=%p, irq=%u)\n",
> + priv->regs, ndev->irq);
> +
> + return 0;
> +fail_candev:
> + netif_napi_del(&priv->napi);
> +fail_clk:
> + free_candev(ndev);
> +fail:
> + return err;
> +}
> +
> +static int rcar_can_remove(struct platform_device *pdev)
> +{
> + struct net_device *ndev = platform_get_drvdata(pdev);
> + struct rcar_can_priv *priv = netdev_priv(ndev);
> +
> + unregister_candev(ndev);
> + netif_napi_del(&priv->napi);
> + free_candev(ndev);
> + return 0;
> +}
> +
> +#ifdef CONFIG_PM_SLEEP
> +static int rcar_can_suspend(struct device *dev)
> +{
> + struct net_device *ndev = dev_get_drvdata(dev);
> + struct rcar_can_priv *priv = netdev_priv(ndev);
> + u16 ctlr;
> +
> + if (netif_running(ndev)) {
> + netif_stop_queue(ndev);
> + netif_device_detach(ndev);
> + }
> + ctlr = readw(&priv->regs->ctlr);
> + ctlr |= RCAR_CAN_CTLR_CANM_HALT;
> + writew(ctlr, &priv->regs->ctlr);
> + ctlr |= RCAR_CAN_CTLR_SLPM;
> + writew(ctlr, &priv->regs->ctlr);
> + priv->can.state = CAN_STATE_SLEEPING;
> +
> + clk_disable(priv->clk);
> + return 0;
> +}
> +
> +static int rcar_can_resume(struct device *dev)
> +{
> + struct net_device *ndev = dev_get_drvdata(dev);
> + struct rcar_can_priv *priv = netdev_priv(ndev);
> + u16 ctlr;
> +
> + clk_enable(priv->clk);
> +
> + ctlr = readw(&priv->regs->ctlr);
> + ctlr &= ~RCAR_CAN_CTLR_SLPM;
> + writew(ctlr, &priv->regs->ctlr);
> + ctlr &= ~RCAR_CAN_CTLR_CANM;
> + writew(ctlr, &priv->regs->ctlr);
> + priv->can.state = CAN_STATE_ERROR_ACTIVE;
> +
> + if (netif_running(ndev)) {
> + netif_device_attach(ndev);
> + netif_start_queue(ndev);
> + }
> + return 0;
> +}
> +#endif
> +
> +static SIMPLE_DEV_PM_OPS(rcar_can_pm_ops, rcar_can_suspend, rcar_can_resume);
> +
> +static struct platform_driver rcar_can_driver = {
> + .driver = {
> + .name = RCAR_CAN_DRV_NAME,
> + .owner = THIS_MODULE,
> + .pm = &rcar_can_pm_ops,
> + },
> + .probe = rcar_can_probe,
> + .remove = rcar_can_remove,
> +};
> +
> +module_platform_driver(rcar_can_driver);
> +
> +MODULE_AUTHOR("Cogent Embedded, Inc.");
> +MODULE_LICENSE("GPL");
> +MODULE_DESCRIPTION("CAN driver for Renesas R-Car SoC");
> +MODULE_ALIAS("platform:" RCAR_CAN_DRV_NAME);
> Index: linux-can-next/include/linux/can/platform/rcar_can.h
> ===================================================================
> --- /dev/null
> +++ linux-can-next/include/linux/can/platform/rcar_can.h
> @@ -0,0 +1,15 @@
> +#ifndef _CAN_PLATFORM_RCAR_CAN_H_
> +#define _CAN_PLATFORM_RCAR_CAN_H_
> +
> +#include <linux/types.h>
> +
> +/* Clock Select Register settings */
> +#define CLKR_CLKEXT 3 /* Externally input clock */
> +#define CLKR_CLKP2 1 /* Peripheral clock (clkp2) */
> +#define CLKR_CLKP1 0 /* Peripheral clock (clkp1) */
Please make it an enum
> +
> +struct rcar_can_platform_data {
> + u8 clock_select; /* Clock source select */
> +};
> +
> +#endif /* !_CAN_PLATFORM_RCAR_CAN_H_ */
>
Marc
--
Pengutronix e.K. | Marc Kleine-Budde |
Industrial Linux Solutions | Phone: +49-231-2826-924 |
Vertretung West/Dortmund | Fax: +49-5121-206917-5555 |
Amtsgericht Hildesheim, HRA 2686 | http://www.pengutronix.de |
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 242 bytes --]
^ permalink raw reply
* Re: [PATCH net] tun: handle copy failure in tun_put_user()
From: Michael S. Tsirkin @ 2014-01-20 8:43 UTC (permalink / raw)
To: David Miller
Cc: jasowang-H+wXaHxf7aLQT0dZR+AlfA, netdev-u79uwXL29TY76Z2rM5mHXA,
linux-kernel-u79uwXL29TY76Z2rM5mHXA,
mtk.manpages-Re5JQEeQqe8AvxtiuMwx3w,
linux-man-u79uwXL29TY76Z2rM5mHXA
In-Reply-To: <20140119.194856.491294439635992592.davem-fT/PcQaiUtIeIZ0/mPfg9Q@public.gmane.org>
On Sun, Jan 19, 2014 at 07:48:56PM -0800, David Miller wrote:
> From: Jason Wang <jasowang-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org>
> Date: Mon, 20 Jan 2014 11:16:48 +0800
>
> > This patch return the error code of copy helpers in tun_put_user() instead of
> > ignoring them.
> >
> > Cc: Michael S. Tsirkin <mst-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org>
> > Signed-off-by: Jason Wang <jasowang-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org>
I'm not sure we need to worry about this too much.
But if yes, a bunch of places besides tun should be
changed. Consider for example udp_recvmsg: it
never seems to return any error except -EAGAIN.
Is this a bug? Man page for recvmsg says:
EFAULT The receive buffer pointer(s) point outside the process's address
space.
this isn't very clear: does this mean "all pointers are invalid"
or "some pointers are invalid"?
Also, what if pointers themselves are valid but length
makes us go outside the address space?
I'm guessing the simplest way is to clarify in the man page that
passing invalid pointers / lengths is not guaranteed
to result in EFAULT and that Linux makes no guarantees
about the returned length in this case.
Cc linux-man in case they can suggest some insights on this.
> If you perform some of the copy successfully, you have to report that
> length rather than just an error.
>
> Otherwise userland has no way to determine how much of the data was
> successfully sourced.
>
> I'm not applying this, sorry.
--
To unsubscribe from this list: send the line "unsubscribe linux-man" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH RFC 4/6] net: rfkill: gpio: add device tree support
From: Heikki Krogerus @ 2014-01-20 8:10 UTC (permalink / raw)
To: Linus Walleij
Cc: Chen-Yu Tsai, Mika Westerberg, Alexandre Courbot, Arnd Bergmann,
linux-arm-kernel, Johannes Berg, David S. Miller, devicetree,
netdev, linux-wireless, linux-sunxi, linux-kernel, Maxime Ripard
In-Reply-To: <CACRpkdZOD4zeA8T5kbJ4c5NsnuzHCg1mw8rRMYNT9c4R-Qnc6A-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org>
Hi,
On Sat, Jan 18, 2014 at 12:11:56AM +0100, Linus Walleij wrote:
> On Fri, Jan 17, 2014 at 6:43 PM, Chen-Yu Tsai <wens-jdAy2FN1RRM@public.gmane.org> wrote:
> > On Sat, Jan 18, 2014 at 12:47 AM, Arnd Bergmann <arnd-r2nGTMty4D4@public.gmane.org> wrote:
>
> >>> +- NAME_shutdown-gpios : GPIO phandle to shutdown control
> >>> + (phandle must be the second)
> >>> +- NAME_reset-gpios : GPIO phandle to reset control
> >>> +
> >>> +NAME must match the rfkill-name property. NAME_shutdown-gpios or
> >>> +NAME_reset-gpios, or both, must be defined.
> >>> +
> >>
> >> I don't understand this part. Why do you include the name in the
> >> gpios property, rather than just hardcoding the property strings
> >> to "shutdown-gpios" and "reset-gpios"?
> >
> > This quirk is a result of how gpiod_get_index implements device tree
> > lookup.
>
> Why can't it just have a single property "gpios", where the first
> element is the reset GPIO and the second is the shutdown GPIO?
>
> rfkill-gpio does this:
>
> gpio = devm_gpiod_get_index(&pdev->dev, rfkill->reset_name, 0);
> gpio = devm_gpiod_get_index(&pdev->dev, rfkill->shutdown_name, 1);
>
> The passed con ID name parameter is only there for the device
> tree case it seems. (ACPI ignores it.) So what about you just
> don't pass it at all and patch it to do like this instead:
>
> gpio = devm_gpiod_get_index(&pdev->dev, NULL, 0);
> gpio = devm_gpiod_get_index(&pdev->dev, NULL, 1);
>
> Heikki, are you OK with this change?
Yes, definitely. That is much cleaner.
Thanks,
--
heikki
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* [PATCH] SUNRPC: Allow one callback request to be received from two sk_buff
From: shaobingqing @ 2014-01-20 6:59 UTC (permalink / raw)
To: trond.myklebust, bfields, davem
Cc: linux-nfs, netdev, linux-kernel, shaobingqing
In current code, there only one struct rpc_rqst is prealloced. If one
callback request is received from two sk_buff, the xprt_alloc_bc_request
would be execute two times with the same transport->xid. The first time
xprt_alloc_bc_request will alloc one struct rpc_rqst and the TCP_RCV_COPY_DATA
bit of transport->tcp_flags will not be cleared. The second time
xprt_alloc_bc_request could not alloc struct rpc_rqst any more and NULL
pointer will be returned, then xprt_force_disconnect occur. I think one
callback request can be allowed to be received from two sk_buff.
Signed-off-by: shaobingqing <shaobingqing@bwstor.com.cn>
---
net/sunrpc/xprtsock.c | 11 +++++++++--
1 files changed, 9 insertions(+), 2 deletions(-)
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index ee03d35..606950d 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -1271,8 +1271,13 @@ static inline int xs_tcp_read_callback(struct rpc_xprt *xprt,
struct sock_xprt *transport =
container_of(xprt, struct sock_xprt, xprt);
struct rpc_rqst *req;
+ static struct rpc_rqst *req_partial;
+
+ if (req_partial == NULL)
+ req = xprt_alloc_bc_request(xprt);
+ else if (req_partial->rq_xid == transport->tcp_xid)
+ req = req_partial;
- req = xprt_alloc_bc_request(xprt);
if (req == NULL) {
printk(KERN_WARNING "Callback slot table overflowed\n");
xprt_force_disconnect(xprt);
@@ -1285,6 +1290,7 @@ static inline int xs_tcp_read_callback(struct rpc_xprt *xprt,
if (!(transport->tcp_flags & TCP_RCV_COPY_DATA)) {
struct svc_serv *bc_serv = xprt->bc_serv;
+ req_partial = NULL;
/*
* Add callback request to callback list. The callback
@@ -1297,7 +1303,8 @@ static inline int xs_tcp_read_callback(struct rpc_xprt *xprt,
list_add(&req->rq_bc_list, &bc_serv->sv_cb_list);
spin_unlock(&bc_serv->sv_cb_lock);
wake_up(&bc_serv->sv_cb_waitq);
- }
+ } else
+ req_partial = req;
req->rq_private_buf.len = transport->tcp_copied;
--
1.7.4.2
^ permalink raw reply related
* Re: ping [PATCH v3] WAN: Adding support for Lantiq PEF2256 E1 chipset (FALC56)
From: Joe Perches @ 2014-01-20 6:22 UTC (permalink / raw)
To: Rob Landley
Cc: Christophe Leroy, Rob Herring, Pawel Moll, Mark Rutland,
Stephen Warren, Ian Campbell, Grant Likely, Krzysztof Halasa,
devicetree, linux-doc, linux-kernel, netdev, marc.balemboy
In-Reply-To: <52DC72CA.3090403@landley.net>
On Sun, 2014-01-19 at 18:50 -0600, Rob Landley wrote:
> On 01/19/14 13:34, Joe Perches wrote:
> > On Sun, 2014-01-19 at 19:07 +0100, Christophe Leroy wrote:
> >> Pinging this watch as we got no feedback since 22 Nov, although we have taken
> >> into account reviews from v1 and v2.
> >>
> >> The patch adds WAN support for Lantiq FALC56 - PEF2256 E1 Chipset.
> ...
> >> +static ssize_t fs_attr_Tx_TS_store(struct device *dev,
> >> + struct device_attribute *attr, const char *buf,
> >> + size_t count)
> >> +{
> >> + struct net_device *ndev = dev_get_drvdata(dev);
> >> + struct pef2256_dev_priv *priv = dev_to_hdlc(ndev)->priv;
> >> + unsigned long value;
> >> + int ret = kstrtoul(buf, 16, (long int *)&value);
> >
> > unportable cast
> How is that not portable? It's long == pointer on Linux, which supports
> LP64 on all targets. (As do BSD, MacOSX, android, and iOS.)
Sorry, I read it wrong.
long int is the same size as long and is fine.
I thought it was just int.
Still, declaring
unsigned long foo;
and using
(long int *)&foo;
is mixing implicit and explicit styles and perhaps
should be avoided.
> Do you mean it's not portable to Windows?
> http://blogs.msdn.com/oldnewthing/archive/2005/01/31/363790.aspx
I hardly remember that stuff anymore.
cheers, Joe
^ permalink raw reply
* Re: [PATCH net] tun: handle copy failure in tun_put_user()
From: Jason Wang @ 2014-01-20 5:02 UTC (permalink / raw)
To: David Miller; +Cc: netdev, linux-kernel, mst
In-Reply-To: <20140119.194856.491294439635992592.davem@davemloft.net>
On 01/20/2014 11:48 AM, David Miller wrote:
> From: Jason Wang <jasowang@redhat.com>
> Date: Mon, 20 Jan 2014 11:16:48 +0800
>
>> This patch return the error code of copy helpers in tun_put_user() instead of
>> ignoring them.
>>
>> Cc: Michael S. Tsirkin <mst@redhat.com>
>> Signed-off-by: Jason Wang <jasowang@redhat.com>
> If you perform some of the copy successfully, you have to report that
> length rather than just an error.
>
> Otherwise userland has no way to determine how much of the data was
> successfully sourced.
>
> I'm not applying this, sorry.
Right, looks like we need more changes in tun to return the accurate
length copied in this case.
^ permalink raw reply
* [PATCH net] ipv6: protect protocols not handling ipv4 from v4 connection/bind attempts
From: Hannes Frederic Sowa @ 2014-01-20 4:16 UTC (permalink / raw)
To: netdev
Some ipv6 protocols cannot handle ipv4 addresses, so we must not allow
connecting and binding to them. sendmsg logic does already check msg->name
for this but must trust already connected sockets which could be set up
for connection to ipv4 address family.
Per-socket flag ipv6only is of no use here, as it is under users control
by setsockopt.
Signed-off-by: Hannes Frederic Sowa <hannes@stressinduktion.org>
---
include/net/ipv6.h | 2 ++
net/ipv4/ping.c | 3 +++
net/ipv6/datagram.c | 10 ++++++++++
net/ipv6/ping.c | 2 +-
net/ipv6/raw.c | 6 +++++-
net/l2tp/l2tp_ip6.c | 3 +++
6 files changed, 24 insertions(+), 2 deletions(-)
diff --git a/include/net/ipv6.h b/include/net/ipv6.h
index 6d80f51..5b0f1d2 100644
--- a/include/net/ipv6.h
+++ b/include/net/ipv6.h
@@ -782,6 +782,8 @@ int compat_ipv6_getsockopt(struct sock *sk, int level, int optname,
char __user *optval, int __user *optlen);
int ip6_datagram_connect(struct sock *sk, struct sockaddr *addr, int addr_len);
+int ip6_datagram_connect_v6_only(struct sock *sk, struct sockaddr *addr,
+ int addr_len);
int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len,
int *addr_len);
diff --git a/net/ipv4/ping.c b/net/ipv4/ping.c
index e09e883..ba59d6f 100644
--- a/net/ipv4/ping.c
+++ b/net/ipv4/ping.c
@@ -320,6 +320,9 @@ static int ping_check_bind_addr(struct sock *sk, struct inet_sock *isk,
if (addr_len < sizeof(*addr))
return -EINVAL;
+ if (addr->sin6_family != AF_INET6)
+ return -EINVAL;
+
pr_debug("ping_check_bind_addr(sk=%p,addr=%pI6c,port=%d)\n",
sk, addr->sin6_addr.s6_addr, ntohs(addr->sin6_port));
diff --git a/net/ipv6/datagram.c b/net/ipv6/datagram.c
index bce73cb..86c705f 100644
--- a/net/ipv6/datagram.c
+++ b/net/ipv6/datagram.c
@@ -205,6 +205,16 @@ out:
}
EXPORT_SYMBOL_GPL(ip6_datagram_connect);
+int ip6_datagram_connect_v6_only(struct sock *sk, struct sockaddr *uaddr,
+ int addr_len)
+{
+ DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, uaddr);
+ if (sin6->sin6_family != AF_INET6)
+ return -EAFNOSUPPORT;
+ return ip6_datagram_connect(sk, uaddr, addr_len);
+}
+EXPORT_SYMBOL_GPL(ip6_datagram_connect_v6_only);
+
void ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
__be16 port, u32 info, u8 *payload)
{
diff --git a/net/ipv6/ping.c b/net/ipv6/ping.c
index cd71f3a..b19214e 100644
--- a/net/ipv6/ping.c
+++ b/net/ipv6/ping.c
@@ -31,7 +31,7 @@ struct proto pingv6_prot = {
.owner = THIS_MODULE,
.init = ping_init_sock,
.close = ping_close,
- .connect = ip6_datagram_connect,
+ .connect = ip6_datagram_connect_v6_only,
.disconnect = udp_disconnect,
.setsockopt = ipv6_setsockopt,
.getsockopt = ipv6_getsockopt,
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index b452311..1f29996 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -250,6 +250,10 @@ static int rawv6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
if (addr_len < SIN6_LEN_RFC2133)
return -EINVAL;
+
+ if (addr->sin6_family != AF_INET6)
+ return -EINVAL;
+
addr_type = ipv6_addr_type(&addr->sin6_addr);
/* Raw sockets are IPv6 only */
@@ -1209,7 +1213,7 @@ struct proto rawv6_prot = {
.owner = THIS_MODULE,
.close = rawv6_close,
.destroy = raw6_destroy,
- .connect = ip6_datagram_connect,
+ .connect = ip6_datagram_connect_v6_only,
.disconnect = udp_disconnect,
.ioctl = rawv6_ioctl,
.init = rawv6_init_sk,
diff --git a/net/l2tp/l2tp_ip6.c b/net/l2tp/l2tp_ip6.c
index aab5f74..7704ea9 100644
--- a/net/l2tp/l2tp_ip6.c
+++ b/net/l2tp/l2tp_ip6.c
@@ -371,6 +371,9 @@ static int l2tp_ip6_connect(struct sock *sk, struct sockaddr *uaddr,
if (addr_len < sizeof(*lsa))
return -EINVAL;
+ if (usin->sin6_family != AF_INET6)
+ return -EINVAL;
+
addr_type = ipv6_addr_type(&usin->sin6_addr);
if (addr_type & IPV6_ADDR_MULTICAST)
return -EINVAL;
--
1.8.4.2
^ permalink raw reply related
* Re: [PATCH] net: fix "queues" uevent between network namespaces
From: David Miller @ 2014-01-20 4:04 UTC (permalink / raw)
To: chenweilong; +Cc: gregkh, netdev
In-Reply-To: <1389864271-24212-1-git-send-email-chenweilong@huawei.com>
From: Chen Weilong <chenweilong@huawei.com>
Date: Thu, 16 Jan 2014 17:24:31 +0800
> From: Weilong Chen <chenweilong@huawei.com>
>
> When I create a new namespace with 'ip netns add net0', or add/remove
> new links in a namespace with 'ip link add/delete type veth', rx/tx
> queues events can be got in all namespaces. That is because rx/tx queue
> ktypes do not have namespace support, and their kobj parents are setted to
> NULL. This patch is to fix it.
>
> Reported-by: Libo Chen <chenlibo@huawei.com>
> Signed-off-by: Libo Chen <chenlibo@huawei.com>
> Signed-off-by: Weilong Chen <chenweilong@huawei.com>
Applied to net-next, thanks.
^ permalink raw reply
* Re: [PATCH net-next v5 0/2] stmmac: fix kernel crashes for jumbo frames
From: David Miller @ 2014-01-20 4:04 UTC (permalink / raw)
To: vbridgers2013-Re5JQEeQqe8AvxtiuMwx3w
Cc: devicetree-u79uwXL29TY76Z2rM5mHXA, netdev-u79uwXL29TY76Z2rM5mHXA,
peppe.cavallaro-qxv4g6HH51o, robh+dt-DgEjT+Ai2ygdnm+yROfE0A,
pawel.moll-5wv7dgnIgG8, mark.rutland-5wv7dgnIgG8,
ijc+devicetree-KcIKpvwj1kUDXYZnReoRVg,
galak-sgV2jX0FEOL9JmXXK+q4OQ, dinguyen-EIB2kfCEclfQT0dZR+AlfA,
rayagond-AmucfkJibqKGw+nKnLezzg
In-Reply-To: <1389903026-12064-1-git-send-email-vbridgers2013-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
From: Vince Bridgers <vbridgers2013-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
Date: Thu, 16 Jan 2014 14:10:24 -0600
> These patches address two kernel crashes seen when using jumbo frames on
> the Synopsys stmmac driver, and adds device tree configurability for the
> maximum mtu. The Synopsys emac fifo sizes can be configured when a logic
> design is synthesized, but does not provide a way for a driver to query the
> exact fifo size.
These patches do not apply to the current net-next tree, please respin.
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH] DT: net: davinci_emac: "phy-handle" property is actually optional
From: David Miller @ 2014-01-20 4:04 UTC (permalink / raw)
To: sergei.shtylyov
Cc: netdev, robh+dt, pawel.moll, mark.rutland, ijc+devicetree, galak,
rob, devicetree, linux-doc, davinci-linux-open-source
In-Reply-To: <201401170132.14479.sergei.shtylyov@cogentembedded.com>
From: Sergei Shtylyov <sergei.shtylyov@cogentembedded.com>
Date: Fri, 17 Jan 2014 01:32:13 +0300
> Though described as required, the "phy-handle" property for the DaVinci EMAC
> binding is actually optional, as the driver will happily function without it,
> assuming 100/FULL link; the property is not specified either in the example
> device node, or in the actual EMAC device nodes for DA850 and AM3517 device
> trees.
>
> Signed-off-by: Sergei Shtylyov <sergei.shtylyov@cogentembedded.com>
Applied.
^ permalink raw reply
* Re: [PATCH] [PATCH net-next v2] net: stmmac: fix NULL pointer dereference in stmmac_get_tx_hwtstamp
From: David Miller @ 2014-01-20 4:03 UTC (permalink / raw)
To: damuzi000; +Cc: peppe.cavallaro, netdev, linux-kernel
In-Reply-To: <1389973679-2755-1-git-send-email-damuzi000@gmail.com>
From: Bruce Liu <damuzi000@gmail.com>
Date: Fri, 17 Jan 2014 23:47:59 +0800
> When timestamping is enabled, stmmac_tx_clean will call
> stmmac_get_tx_hwtstamp to get tx TS.
> But the skb can be NULL because the last of its tx_skbuff is NULL
> if this packet frame is filled in more than one descriptors.
>
> To fix the issue, change the code:
> - Store TX skb to the tx_skbuff[] of frame's last segment.
> - Check skb is not NULL in stmmac_get_tx_hwtstamp.
>
> Signed-off-by: Bruce Liu <damuzi000@gmail.com>
Looks a lot better, applied, thanks.
^ permalink raw reply
* Re: [PATCH net-next v3 0/8] net: stmmac: Add Allwinner A20 GMAC ethernet
From: David Miller @ 2014-01-20 4:03 UTC (permalink / raw)
To: wens-jdAy2FN1RRM
Cc: netdev-u79uwXL29TY76Z2rM5mHXA, peppe.cavallaro-qxv4g6HH51o,
srinivas.kandagatla-qxv4g6HH51o, vapier-aBrp7R+bbdUdnm+yROfE0A,
uclinux-dist-devel-ZG0+EudsQA8dtHy/vicBwGD2FQJk+8+b,
linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r,
linux-sunxi-/JYPxA39Uh5TLH3MbocFFw,
linux-kernel-u79uwXL29TY76Z2rM5mHXA,
devicetree-u79uwXL29TY76Z2rM5mHXA
In-Reply-To: <1389965087-21971-1-git-send-email-wens-jdAy2FN1RRM@public.gmane.org>
From: Chen-Yu Tsai <wens-jdAy2FN1RRM@public.gmane.org>
Date: Fri, 17 Jan 2014 21:24:39 +0800
> This is v3 of the Allwinner A20 GMAC glue layer for stmmac.
> I have split the series into stmmac driver changes for net-next,
> and clock and DT patches for their respective trees.
Series applied, thanks.
^ permalink raw reply
* Re: [Patch net-next] net_sched: act: remove capab from struct tc_action_ops
From: David Miller @ 2014-01-20 3:58 UTC (permalink / raw)
To: xiyou.wangcong; +Cc: netdev, jhs
In-Reply-To: <1389829770-811-1-git-send-email-xiyou.wangcong@gmail.com>
From: Cong Wang <xiyou.wangcong@gmail.com>
Date: Wed, 15 Jan 2014 15:49:30 -0800
> It is not actually implemented.
>
> Cc: Jamal Hadi Salim <jhs@mojatatu.com>
> Cc: David S. Miller <davem@davemloft.net>
> Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Applied, we shouldn't keep something around which was added more than
a decade ago but never actually used.
If we find a use for it, we can add it back.
^ permalink raw reply
* Re: [PATCH net] net: document accel_priv parameter for __dev_queue_xmit()
From: David Miller @ 2014-01-20 3:56 UTC (permalink / raw)
To: jasowang; +Cc: netdev, linux-kernel
In-Reply-To: <1390188313-9275-1-git-send-email-jasowang@redhat.com>
From: Jason Wang <jasowang@redhat.com>
Date: Mon, 20 Jan 2014 11:25:13 +0800
> To silent "make htmldocs" warning.
>
> Reported-by: kbuild test robot <fengguang.wu@intel.com>
> Signed-off-by: Jason Wang <jasowang@redhat.com>
Applied to net-next.
^ permalink raw reply
* Re: [PATCH net-next] sctp: fix missing SCTP mailing list address update
From: David Miller @ 2014-01-20 3:56 UTC (permalink / raw)
To: sakiwit; +Cc: vyasevich, nhorman, linux-sctp, netdev, dborkman
In-Reply-To: <1390170293-15851-1-git-send-email-sakiwit@gmail.com>
From: Jean Sacren <sakiwit@gmail.com>
Date: Sun, 19 Jan 2014 15:24:53 -0700
> The commit 91705c61b5202 ("net: sctp: trivial: update mailing list
> address") updated almost all the SCTP mailing list address from
>
> "lksctp-developers@lists.sourceforge.net"
> to
> "linux-sctp@vger.kernel.org"
>
> except for the one in include/linux/sctp.h file. Fix this way trivial
> one so that all is updated.
>
> Signed-off-by: Jean Sacren <sakiwit@gmail.com>
Applied.
^ permalink raw reply
* Re: [PATCH net-next] ipv6: optimize link local address search
From: David Miller @ 2014-01-20 3:56 UTC (permalink / raw)
To: hannes; +Cc: netdev, brian.haley
In-Reply-To: <20140119205819.GD16462@order.stressinduktion.org>
From: Hannes Frederic Sowa <hannes@stressinduktion.org>
Date: Sun, 19 Jan 2014 21:58:19 +0100
> ipv6_link_dev_addr sorts newly added addresses by scope in
> ifp->addr_list. Smaller scope addresses are added to the tail of the
> list. Use this fact to iterate in reverse over addr_list and break out
> as soon as a higher scoped one showes up, so we can spare some cycles
> on machines with lot's of addresses.
>
> The ordering of the addresses is not relevant and we are more likely to
> get the eui64 generated address with this change anyway.
>
> Suggested-by: Brian Haley <brian.haley@hp.com>
> Signed-off-by: Hannes Frederic Sowa <hannes@stressinduktion.org>
Applied.
^ permalink raw reply
* Re: [PATCH net-next] phy: cleanup 10g code
From: David Miller @ 2014-01-20 3:56 UTC (permalink / raw)
To: stephen; +Cc: afleming, netdev
In-Reply-To: <20140119114820.028fa940@nehalam.linuxnetplumber.net>
From: Stephen Hemminger <stephen@networkplumber.org>
Date: Sun, 19 Jan 2014 11:48:20 -0800
> Code should avoid needless exports, don't export something unless it used.
> Make local functions static and remove unused stubs.
>
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Applied.
^ permalink raw reply
* Re: [ PATCH net-next vw] qlcnic: fix sparse warnings
From: David Miller @ 2014-01-20 3:56 UTC (permalink / raw)
To: stephen; +Cc: netdev
In-Reply-To: <20140119113712.18f75ba9@nehalam.linuxnetplumber.net>
From: Stephen Hemminger <stephen@networkplumber.org>
Date: Sun, 19 Jan 2014 11:37:12 -0800
> From: Fengguang Wu <fengguang.wu@intel.com>
> Subject: [PATCH net-next] qlcnic: fix sparse warnings
>
> Previous patch changed prototypes, but forgot functions.
>
> Signed-off-by: Fengguang Wu <fengguang.wu@intel.com>
> Acked-by: Stephen Hemminger <stephen@networkplumber.org>
Applied.
^ permalink raw reply
* Re: [PATCH] ipv6: udp: check sk->sk_no_check when sending udpv6 packet
From: Hannes Frederic Sowa @ 2014-01-20 3:54 UTC (permalink / raw)
To: Duan Jiong; +Cc: David Miller, netdev
In-Reply-To: <52DC9D25.9070809@cn.fujitsu.com>
On Mon, Jan 20, 2014 at 11:51:01AM +0800, Duan Jiong wrote:
>
> According to the user's intention, if SO_NO_CHECK option is
> set to true, the udpv6 packet should be out with no checksum.
Nak, UDP checksumming is mandatory when used with IPv6.
Greetings,
Hannes
^ permalink raw reply
* Re: [PATCH] ipv6: udp: check sk->sk_no_check when sending udpv6 packet
From: David Miller @ 2014-01-20 3:54 UTC (permalink / raw)
To: duanj.fnst; +Cc: netdev
In-Reply-To: <52DC9D25.9070809@cn.fujitsu.com>
From: Duan Jiong <duanj.fnst@cn.fujitsu.com>
Date: Mon, 20 Jan 2014 11:51:01 +0800
> According to the user's intention, if SO_NO_CHECK option is
> set to true, the udpv6 packet should be out with no checksum.
>
> Signed-off-by: Duan Jiong <duanj.fnst@cn.fujitsu.com>
This is intentionally not supported in ipv6.
^ permalink raw reply
* Re: [PATCH net-next] ipv6: make IPV6_RECVPKTINFO work for ipv4 datagrams
From: David Miller @ 2014-01-20 3:53 UTC (permalink / raw)
To: hannes; +Cc: netdev, gert
In-Reply-To: <20140120024308.GE16462@order.stressinduktion.org>
From: Hannes Frederic Sowa <hannes@stressinduktion.org>
Date: Mon, 20 Jan 2014 03:43:08 +0100
> We currently don't report IPV6_RECVPKTINFO in cmsg access ancillary data
> for IPv4 datagrams on IPv6 sockets.
>
> This patch splits the ip6_datagram_recv_ctl into two functions, one
> which handles both protocol families, AF_INET and AF_INET6, while the
> ip6_datagram_recv_specific_ctl only handles IPv6 cmsg data.
>
> ip6_datagram_recv_*_ctl never reported back any errors, so we can make
> them return void. Also provide a helper for protocols which don't offer dual
> personality to further use ip6_datagram_recv_ctl, which is exported to
> modules.
>
> I needed to shuffle the code for ping around a bit to make it easier to
> implement dual personality for ping ipv6 sockets in future.
>
> Reported-by: Gert Doering <gert@space.net>
> Signed-off-by: Hannes Frederic Sowa <hannes@stressinduktion.org>
Looks good, applied, thanks.
^ permalink raw reply
* [PATCH] ipv6: udp: check sk->sk_no_check when sending udpv6 packet
From: Duan Jiong @ 2014-01-20 3:51 UTC (permalink / raw)
To: David Miller; +Cc: netdev
According to the user's intention, if SO_NO_CHECK option is
set to true, the udpv6 packet should be out with no checksum.
Signed-off-by: Duan Jiong <duanj.fnst@cn.fujitsu.com>
---
net/ipv6/udp.c | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index 089c741..8808c69 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -1001,6 +1001,10 @@ static int udp_v6_push_pending_frames(struct sock *sk)
if (is_udplite)
csum = udplite_csum_outgoing(sk, skb);
+ else if (sk->sk_no_check == UDP_CSUM_NOXMIT) {
+ skb->ip_summed = CHECKSUM_NONE;
+ goto send;
+ }
else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
udp6_hwcsum_outgoing(sk, skb, &fl6->saddr, &fl6->daddr,
up->len);
--
1.8.3.1
^ permalink raw reply related
* Re: [PATCH net] net: document accel_priv parameter for __dev_queue_xmit()
From: David Miller @ 2014-01-20 3:49 UTC (permalink / raw)
To: jasowang; +Cc: netdev, linux-kernel
In-Reply-To: <1390188313-9275-1-git-send-email-jasowang@redhat.com>
From: Jason Wang <jasowang@redhat.com>
Date: Mon, 20 Jan 2014 11:25:13 +0800
> To silent "make htmldocs" warning.
>
> Reported-by: kbuild test robot <fengguang.wu@intel.com>
> Signed-off-by: Jason Wang <jasowang@redhat.com>
This is certainly not such a catastrophic error that it should be
targetted at the 'net' tree.
^ permalink raw reply
* Re: [PATCH 2/2] net/cxgb4: Don't retrieve stats during recovery
From: Ben Hutchings @ 2014-01-20 3:49 UTC (permalink / raw)
To: Gavin Shan; +Cc: netdev, dm
In-Reply-To: <1390187144-15495-2-git-send-email-shangw@linux.vnet.ibm.com>
[-- Attachment #1: Type: text/plain, Size: 1754 bytes --]
On Mon, 2014-01-20 at 11:05 +0800, Gavin Shan wrote:
> We possiblly retrieve the adapter's statistics during EEH recovery
> and that should be disallowed. Otherwise, it would possibly incur
> replicate EEH error and EEH recovery is going to fail eventually.
> The patch checks if the PCI device is off-line before statistic
> retrieval.
>
> Signed-off-by: Gavin Shan <shangw@linux.vnet.ibm.com>
> ---
> drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c | 11 +++++++++++
> 1 file changed, 11 insertions(+)
>
> diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
> index c8eafbf..b0e72fb 100644
> --- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
> +++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
> @@ -4288,6 +4288,17 @@ static struct rtnl_link_stats64 *cxgb_get_stats(struct net_device *dev,
> struct port_info *p = netdev_priv(dev);
> struct adapter *adapter = p->adapter;
>
> + /*
> + * We possibly retrieve the statistics while the PCI
> + * device is off-line. That would cause the recovery
> + * on off-lined PCI device going to fail. So it's
> + * reasonable to block it during the recovery period.
> + */
> + if (pci_channel_offline(adapter->pdev)) {
> + memset(ns, 0, sizeof(*ns));
> + return ns;
> + }
The buffer is already zero-initialised so there's no need for this
memset().
> spin_lock(&adapter->stats_lock);
> t4_get_port_stats(adapter, p->tx_chan, &stats);
> spin_unlock(&adapter->stats_lock);
Is there anything to stop this running just after pci_channel_offline()
becomes true?
Ben.
--
Ben Hutchings
One of the nice things about standards is that there are so many of them.
[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 828 bytes --]
^ permalink raw reply
* Re: [PATCH net] tun: handle copy failure in tun_put_user()
From: David Miller @ 2014-01-20 3:48 UTC (permalink / raw)
To: jasowang; +Cc: netdev, linux-kernel, mst
In-Reply-To: <1390187808-5462-1-git-send-email-jasowang@redhat.com>
From: Jason Wang <jasowang@redhat.com>
Date: Mon, 20 Jan 2014 11:16:48 +0800
> This patch return the error code of copy helpers in tun_put_user() instead of
> ignoring them.
>
> Cc: Michael S. Tsirkin <mst@redhat.com>
> Signed-off-by: Jason Wang <jasowang@redhat.com>
If you perform some of the copy successfully, you have to report that
length rather than just an error.
Otherwise userland has no way to determine how much of the data was
successfully sourced.
I'm not applying this, sorry.
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox