Commit 82f19183 authored by David S. Miller's avatar David S. Miller
Browse files

Merge tag 'linux-can-fixes-for-3.14-20140303' of git://gitorious.org/linux-can/linux-can 



linux-can-fixes-for-3.14-20140303

Marc Kleine-Budde says:

====================
this is a pull request of 8 patches. Oliver Hartkopp contributes a patch which
removes the CAN FD compatibility for CAN 2.0 sockets, as it turns out that this
compatibility has some conceptual cornercases. The remaining 7 patches are by
me, they address a problem in the flexcan driver. When shutting down the
interface ("ifconfig can0 down") under heavy network load the whole system will
hang. This series reworks the actual sequence in close() and the transition
from and to the low power modes of the CAN controller.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 10ddceb2 821047c4

Documentation/networking/can.txt

+0 −6
Original line number Diff line number Diff line
@@ -554,12 +554,6 @@ solution for a couple of reasons: 
  not specified in the struct can_frame and therefore it is only valid in

  CANFD_MTU sized CAN FD frames.



  As long as the payload length is <=8 the received CAN frames from CAN FD

  capable CAN devices can be received and read by legacy sockets too. When

  user-generated CAN FD frames have a payload length <=8 these can be send

  by legacy CAN network interfaces too. Sending CAN FD frames with payload

  length > 8 to a legacy CAN network interface returns an -EMSGSIZE error.



  Implementation hint for new CAN applications:



  To build a CAN FD aware application use struct canfd_frame as basic CAN

drivers/net/can/flexcan.c

+131 −41
Original line number Diff line number Diff line
@@ -144,6 +144,8 @@ 


#define FLEXCAN_MB_CODE_MASK		(0xf0ffffff)



#define FLEXCAN_TIMEOUT_US             (50)



/*

 * FLEXCAN hardware feature flags

 *
@@ -262,6 +264,22 @@ static inline void flexcan_write(u32 val, void __iomem *addr) 
}

#endif



static inline int flexcan_transceiver_enable(const struct flexcan_priv *priv)

{

	if (!priv->reg_xceiver)

		return 0;



	return regulator_enable(priv->reg_xceiver);

}



static inline int flexcan_transceiver_disable(const struct flexcan_priv *priv)

{

	if (!priv->reg_xceiver)

		return 0;



	return regulator_disable(priv->reg_xceiver);

}



static inline int flexcan_has_and_handle_berr(const struct flexcan_priv *priv,

					      u32 reg_esr)

{
@@ -269,26 +287,95 @@ static inline int flexcan_has_and_handle_berr(const struct flexcan_priv *priv, 
		(reg_esr & FLEXCAN_ESR_ERR_BUS);

}



static inline void flexcan_chip_enable(struct flexcan_priv *priv)

static int flexcan_chip_enable(struct flexcan_priv *priv)

{

	struct flexcan_regs __iomem *regs = priv->base;

	unsigned int timeout = FLEXCAN_TIMEOUT_US / 10;

	u32 reg;



	reg = flexcan_read(&regs->mcr);

	reg &= ~FLEXCAN_MCR_MDIS;

	flexcan_write(reg, &regs->mcr);



	udelay(10);

	while (timeout-- && (flexcan_read(&regs->mcr) & FLEXCAN_MCR_LPM_ACK))

		usleep_range(10, 20);



	if (flexcan_read(&regs->mcr) & FLEXCAN_MCR_LPM_ACK)

		return -ETIMEDOUT;



	return 0;

}



static inline void flexcan_chip_disable(struct flexcan_priv *priv)

static int flexcan_chip_disable(struct flexcan_priv *priv)

{

	struct flexcan_regs __iomem *regs = priv->base;

	unsigned int timeout = FLEXCAN_TIMEOUT_US / 10;

	u32 reg;



	reg = flexcan_read(&regs->mcr);

	reg |= FLEXCAN_MCR_MDIS;

	flexcan_write(reg, &regs->mcr);



	while (timeout-- && !(flexcan_read(&regs->mcr) & FLEXCAN_MCR_LPM_ACK))

		usleep_range(10, 20);



	if (!(flexcan_read(&regs->mcr) & FLEXCAN_MCR_LPM_ACK))

		return -ETIMEDOUT;



	return 0;

}



static int flexcan_chip_freeze(struct flexcan_priv *priv)

{

	struct flexcan_regs __iomem *regs = priv->base;

	unsigned int timeout = 1000 * 1000 * 10 / priv->can.bittiming.bitrate;

	u32 reg;



	reg = flexcan_read(&regs->mcr);

	reg |= FLEXCAN_MCR_HALT;

	flexcan_write(reg, &regs->mcr);



	while (timeout-- && !(flexcan_read(&regs->mcr) & FLEXCAN_MCR_FRZ_ACK))

		usleep_range(100, 200);



	if (!(flexcan_read(&regs->mcr) & FLEXCAN_MCR_FRZ_ACK))

		return -ETIMEDOUT;



	return 0;

}



static int flexcan_chip_unfreeze(struct flexcan_priv *priv)

{

	struct flexcan_regs __iomem *regs = priv->base;

	unsigned int timeout = FLEXCAN_TIMEOUT_US / 10;

	u32 reg;



	reg = flexcan_read(&regs->mcr);

	reg &= ~FLEXCAN_MCR_HALT;

	flexcan_write(reg, &regs->mcr);



	while (timeout-- && (flexcan_read(&regs->mcr) & FLEXCAN_MCR_FRZ_ACK))

		usleep_range(10, 20);



	if (flexcan_read(&regs->mcr) & FLEXCAN_MCR_FRZ_ACK)

		return -ETIMEDOUT;



	return 0;

}



static int flexcan_chip_softreset(struct flexcan_priv *priv)

{

	struct flexcan_regs __iomem *regs = priv->base;

	unsigned int timeout = FLEXCAN_TIMEOUT_US / 10;



	flexcan_write(FLEXCAN_MCR_SOFTRST, &regs->mcr);

	while (timeout-- && (flexcan_read(&regs->mcr) & FLEXCAN_MCR_SOFTRST))

		usleep_range(10, 20);



	if (flexcan_read(&regs->mcr) & FLEXCAN_MCR_SOFTRST)

		return -ETIMEDOUT;



	return 0;

}



static int flexcan_get_berr_counter(const struct net_device *dev,
@@ -709,19 +796,14 @@ static int flexcan_chip_start(struct net_device *dev) 
	u32 reg_mcr, reg_ctrl;



	/* enable module */

	flexcan_chip_enable(priv);

	err = flexcan_chip_enable(priv);

	if (err)

		return err;



	/* soft reset */

	flexcan_write(FLEXCAN_MCR_SOFTRST, &regs->mcr);

	udelay(10);



	reg_mcr = flexcan_read(&regs->mcr);

	if (reg_mcr & FLEXCAN_MCR_SOFTRST) {

		netdev_err(dev, "Failed to softreset can module (mcr=0x%08x)\n",

			   reg_mcr);

		err = -ENODEV;

		goto out;

	}

	err = flexcan_chip_softreset(priv);

	if (err)

		goto out_chip_disable;



	flexcan_set_bittiming(dev);
@@ -788,16 +870,14 @@ static int flexcan_chip_start(struct net_device *dev) 
	if (priv->devtype_data->features & FLEXCAN_HAS_V10_FEATURES)

		flexcan_write(0x0, &regs->rxfgmask);



	if (priv->reg_xceiver)	{

		err = regulator_enable(priv->reg_xceiver);

	err = flexcan_transceiver_enable(priv);

	if (err)

			goto out;

	}

		goto out_chip_disable;



	/* synchronize with the can bus */

	reg_mcr = flexcan_read(&regs->mcr);

	reg_mcr &= ~FLEXCAN_MCR_HALT;

	flexcan_write(reg_mcr, &regs->mcr);

	err = flexcan_chip_unfreeze(priv);

	if (err)

		goto out_transceiver_disable;



	priv->can.state = CAN_STATE_ERROR_ACTIVE;
@@ -810,7 +890,9 @@ static int flexcan_chip_start(struct net_device *dev) 


	return 0;



 out:

 out_transceiver_disable:

	flexcan_transceiver_disable(priv);

 out_chip_disable:

	flexcan_chip_disable(priv);

	return err;

}
@@ -825,18 +907,17 @@ static void flexcan_chip_stop(struct net_device *dev) 
{

	struct flexcan_priv *priv = netdev_priv(dev);

	struct flexcan_regs __iomem *regs = priv->base;

	u32 reg;



	/* freeze + disable module */

	flexcan_chip_freeze(priv);

	flexcan_chip_disable(priv);



	/* Disable all interrupts */

	flexcan_write(0, &regs->imask1);

	flexcan_write(priv->reg_ctrl_default & ~FLEXCAN_CTRL_ERR_ALL,

		      &regs->ctrl);



	/* Disable + halt module */

	reg = flexcan_read(&regs->mcr);

	reg |= FLEXCAN_MCR_MDIS | FLEXCAN_MCR_HALT;

	flexcan_write(reg, &regs->mcr);



	if (priv->reg_xceiver)

		regulator_disable(priv->reg_xceiver);

	flexcan_transceiver_disable(priv);

	priv->can.state = CAN_STATE_STOPPED;



	return;
@@ -866,7 +947,7 @@ static int flexcan_open(struct net_device *dev) 
	/* start chip and queuing */

	err = flexcan_chip_start(dev);

	if (err)

		goto out_close;

		goto out_free_irq;



	can_led_event(dev, CAN_LED_EVENT_OPEN);
@@ -875,6 +956,8 @@ static int flexcan_open(struct net_device *dev) 


	return 0;



 out_free_irq:

	free_irq(dev->irq, dev);

 out_close:

	close_candev(dev);

 out_disable_per:
@@ -945,12 +1028,16 @@ static int register_flexcandev(struct net_device *dev) 
		goto out_disable_ipg;



	/* select "bus clock", chip must be disabled */

	flexcan_chip_disable(priv);

	err = flexcan_chip_disable(priv);

	if (err)

		goto out_disable_per;

	reg = flexcan_read(&regs->ctrl);

	reg |= FLEXCAN_CTRL_CLK_SRC;

	flexcan_write(reg, &regs->ctrl);



	flexcan_chip_enable(priv);

	err = flexcan_chip_enable(priv);

	if (err)

		goto out_chip_disable;



	/* set freeze, halt and activate FIFO, restrict register access */

	reg = flexcan_read(&regs->mcr);
@@ -967,14 +1054,15 @@ static int register_flexcandev(struct net_device *dev) 
	if (!(reg & FLEXCAN_MCR_FEN)) {

		netdev_err(dev, "Could not enable RX FIFO, unsupported core\n");

		err = -ENODEV;

		goto out_disable_per;

		goto out_chip_disable;

	}



	err = register_candev(dev);



 out_disable_per:

	/* disable core and turn off clocks */

 out_chip_disable:

	flexcan_chip_disable(priv);

 out_disable_per:

	clk_disable_unprepare(priv->clk_per);

 out_disable_ipg:

	clk_disable_unprepare(priv->clk_ipg);
@@ -1104,9 +1192,10 @@ static int flexcan_probe(struct platform_device *pdev) 
static int flexcan_remove(struct platform_device *pdev)

{

	struct net_device *dev = platform_get_drvdata(pdev);

	struct flexcan_priv *priv = netdev_priv(dev);



	unregister_flexcandev(dev);



	netif_napi_del(&priv->napi);

	free_candev(dev);



	return 0;
@@ -1117,8 +1206,11 @@ static int flexcan_suspend(struct device *device) 
{

	struct net_device *dev = dev_get_drvdata(device);

	struct flexcan_priv *priv = netdev_priv(dev);

	int err;



	flexcan_chip_disable(priv);

	err = flexcan_chip_disable(priv);

	if (err)

		return err;



	if (netif_running(dev)) {

		netif_stop_queue(dev);
@@ -1139,9 +1231,7 @@ static int flexcan_resume(struct device *device) 
		netif_device_attach(dev);

		netif_start_queue(dev);

	}

	flexcan_chip_enable(priv);



	return 0;

	return flexcan_chip_enable(priv);

}

#endif /* CONFIG_PM_SLEEP */

net/can/raw.c

+5 −21
Original line number Diff line number Diff line
@@ -121,13 +121,9 @@ static void raw_rcv(struct sk_buff *oskb, void *data) 
	if (!ro->recv_own_msgs && oskb->sk == sk)

		return;



	/* do not pass frames with DLC > 8 to a legacy socket */

	if (!ro->fd_frames) {

		struct canfd_frame *cfd = (struct canfd_frame *)oskb->data;



		if (unlikely(cfd->len > CAN_MAX_DLEN))

	/* do not pass non-CAN2.0 frames to a legacy socket */

	if (!ro->fd_frames && oskb->len != CAN_MTU)

		return;

	}



	/* clone the given skb to be able to enqueue it into the rcv queue */

	skb = skb_clone(oskb, GFP_ATOMIC);
@@ -738,9 +734,7 @@ static int raw_recvmsg(struct kiocb *iocb, struct socket *sock, 
		       struct msghdr *msg, size_t size, int flags)

{

	struct sock *sk = sock->sk;

	struct raw_sock *ro = raw_sk(sk);

	struct sk_buff *skb;

	int rxmtu;

	int err = 0;

	int noblock;
@@ -751,20 +745,10 @@ static int raw_recvmsg(struct kiocb *iocb, struct socket *sock, 
	if (!skb)

		return err;



	/*

	 * when serving a legacy socket the DLC <= 8 is already checked inside

	 * raw_rcv(). Now check if we need to pass a canfd_frame to a legacy

	 * socket and cut the possible CANFD_MTU/CAN_MTU length to CAN_MTU

	 */

	if (!ro->fd_frames)

		rxmtu = CAN_MTU;

	else

		rxmtu = skb->len;



	if (size < rxmtu)

	if (size < skb->len)

		msg->msg_flags |= MSG_TRUNC;

	else

		size = rxmtu;

		size = skb->len;



	err = memcpy_toiovec(msg->msg_iov, skb->data, size);

	if (err < 0) {

CRA Git | Maintained and supported by SUSTech CRA and CCSE