Merge tag 'linux-can-next-for-5.4-20190903' of...

	- #size-cells: 0

	- spi-max-frequency: Maximum frequency of the SPI bus the chip can

			     operate at should be less than or equal to 18 MHz.

	- data-ready-gpios: Interrupt GPIO for data and error reporting.

	- device-wake-gpios: Wake up GPIO to wake up the TCAN device.

	- interrupt-parent: the phandle to the interrupt controller which provides

                    the interrupt.

	- interrupts: interrupt specification for data-ready.

See Documentation/devicetree/bindings/net/can/m_can.txt for additional

required property details.

		#size-cells = <1>;

		spi-max-frequency = <10000000>;

		bosch,mram-cfg = <0x0 0 0 32 0 0 1 1>;

		data-ready-gpios = <&gpio1 14 GPIO_ACTIVE_LOW>;

		interrupt-parent = <&gpio1>;

		interrupts = <14 GPIO_ACTIVE_LOW>;

		device-state-gpios = <&gpio3 21 GPIO_ACTIVE_HIGH>;

		device-wake-gpios = <&gpio1 15 GPIO_ACTIVE_HIGH>;

		reset-gpios = <&gpio1 27 GPIO_ACTIVE_LOW>;

// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (C) 2005 Marc Kleine-Budde, Pengutronix

/* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix

 * Copyright (C) 2006 Andrey Volkov, Varma Electronics

 * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com>

 */

#define CAN_CALC_MAX_ERROR 50 /* in one-tenth of a percent */

#define CAN_CALC_SYNC_SEG 1

/*

 * Bit-timing calculation derived from:

/* Bit-timing calculation derived from:

 *

 * Code based on LinCAN sources and H8S2638 project

 * Copyright 2004-2006 Pavel Pisa - DCE FELK CVUT cz

 * registers of the CAN controller. You can find more information

 * in the header file linux/can/netlink.h.

 */

static int can_update_sample_point(const struct can_bittiming_const *btc,

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)

	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 = 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) {

			tseg2 = tseg - tseg1;

		}

		sample_point = 1000 * (tseg + CAN_CALC_SYNC_SEG - tseg2) / (tseg + CAN_CALC_SYNC_SEG);

		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)) {

		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;

		/* 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))

		if (brp < btc->brp_min || brp > btc->brp_max)

			continue;

		bitrate = priv->clock.freq / (brp * tsegall);

		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);

		can_update_sample_point(btc, sample_point_nominal, tseg / 2,

					&tseg1, &tseg2, &sample_point_error);

		if (sample_point_error > best_sample_point_error)

			continue;

	}

	/* real sample point */

	bt->sample_point = can_update_sample_point(btc, sample_point_nominal, best_tseg,

					  &tseg1, &tseg2, NULL);

	bt->sample_point = can_update_sample_point(btc, sample_point_nominal,

						   best_tseg, &tseg1, &tseg2,

						   NULL);

	v64 = (u64)best_brp * 1000 * 1000 * 1000;

	do_div(v64, priv->clock.freq);

	bt->brp = best_brp;

	/* real bitrate */

	bt->bitrate = priv->clock.freq / (bt->brp * (CAN_CALC_SYNC_SEG + tseg1 + tseg2));

	bt->bitrate = priv->clock.freq /

		(bt->brp * (CAN_CALC_SYNC_SEG + tseg1 + tseg2));

	return 0;

}

}

#endif /* CONFIG_CAN_CALC_BITTIMING */

/*

 * Checks the validity of the specified bit-timing parameters prop_seg,

/* Checks the validity of the specified bit-timing parameters prop_seg,

 * phase_seg1, phase_seg2 and sjw and tries to determine the bitrate

 * prescaler value brp. You can find more information in the header

 * file linux/can/netlink.h.

}

/* Checks the validity of predefined bitrate settings */

static int can_validate_bitrate(struct net_device *dev, struct can_bittiming *bt,

static int

can_validate_bitrate(struct net_device *dev, struct can_bittiming *bt,

		     const u32 *bitrate_const,

		     const unsigned int bitrate_const_cnt)

{

{

	int err;

	/*

	 * Depending on the given can_bittiming parameter structure the CAN

	/* Depending on the given can_bittiming parameter structure the CAN

	 * timing parameters are calculated based on the provided bitrate OR

	 * alternatively the CAN timing parameters (tq, prop_seg, etc.) are

	 * provided directly which are then checked and fixed up.

}

EXPORT_SYMBOL_GPL(can_change_state);

/*

 * Local echo of CAN messages

/* Local echo of CAN messages

 *

 * CAN network devices *should* support a local echo functionality

 * (see Documentation/networking/can.rst). To test the handling of CAN

	}

}

/*

 * Put the skb on the stack to be looped backed locally lateron

/* Put the skb on the stack to be looped backed locally lateron

 *

 * The function is typically called in the start_xmit function

 * of the device driver. The driver must protect access to

	}

	if (!priv->echo_skb[idx]) {

		skb = can_create_echo_skb(skb);

		if (!skb)

			return;

}

EXPORT_SYMBOL_GPL(can_put_echo_skb);

struct sk_buff *__can_get_echo_skb(struct net_device *dev, unsigned int idx, u8 *len_ptr)

struct sk_buff *

__can_get_echo_skb(struct net_device *dev, unsigned int idx, u8 *len_ptr)

{

	struct can_priv *priv = netdev_priv(dev);

	return NULL;

}

/*

 * Get the skb from the stack and loop it back locally

/* Get the skb from the stack and loop it back locally

 *

 * The function is typically called when the TX done interrupt

 * is handled in the device driver. The driver must protect

}

EXPORT_SYMBOL_GPL(can_get_echo_skb);

/*

  * Remove the skb from the stack and free it.

/* Remove the skb from the stack and free it.

 *

 * The function is typically called when TX failed.

 */

}

EXPORT_SYMBOL_GPL(can_free_echo_skb);

/*

 * CAN device restart for bus-off recovery

 */

/* CAN device restart for bus-off recovery */

static void can_restart(struct net_device *dev)

{

	struct can_priv *priv = netdev_priv(dev);

	BUG_ON(netif_carrier_ok(dev));

	/*

	 * No synchronization needed because the device is bus-off and

	/* No synchronization needed because the device is bus-off and

	 * no messages can come in or go out.

	 */

	can_flush_echo_skb(dev);

	/* send restart message upstream */

	skb = alloc_can_err_skb(dev, &cf);

	if (skb == NULL) {

	if (!skb) {

		err = -ENOMEM;

		goto restart;

	}

static void can_restart_work(struct work_struct *work)

{

	struct delayed_work *dwork = to_delayed_work(work);

	struct can_priv *priv = container_of(dwork, struct can_priv, restart_work);

	struct can_priv *priv = container_of(dwork, struct can_priv,

					     restart_work);

	can_restart(priv->dev);

}

{

	struct can_priv *priv = netdev_priv(dev);

	/*

	 * A manual restart is only permitted if automatic restart is

	/* A manual restart is only permitted if automatic restart is

	 * disabled and the device is in the bus-off state

	 */

	if (priv->restart_ms)

	return 0;

}

/*

 * CAN bus-off

/* CAN bus-off

 *

 * This functions should be called when the device goes bus-off to

 * tell the netif layer that no more packets can be sent or received.

}

EXPORT_SYMBOL_GPL(alloc_can_err_skb);

/*

 * Allocate and setup space for the CAN network device

 */

/* Allocate and setup space for the CAN network device */

struct net_device *alloc_candev_mqs(int sizeof_priv, unsigned int echo_skb_max,

				    unsigned int txqs, unsigned int rxqs)

{

}

EXPORT_SYMBOL_GPL(alloc_candev_mqs);

/*

 * Free space of the CAN network device

 */

/* Free space of the CAN network device */

void free_candev(struct net_device *dev)

{

	free_netdev(dev);

}

EXPORT_SYMBOL_GPL(free_candev);

/*

 * changing MTU and control mode for CAN/CANFD devices

 */

/* changing MTU and control mode for CAN/CANFD devices */

int can_change_mtu(struct net_device *dev, int new_mtu)

{

	struct can_priv *priv = netdev_priv(dev);

}

EXPORT_SYMBOL_GPL(can_change_mtu);

/*

 * Common open function when the device gets opened.

/* Common open function when the device gets opened.

 *

 * This function should be called in the open function of the device

 * driver.

	/* For CAN FD the data bitrate has to be >= the arbitration bitrate */

	if ((priv->ctrlmode & CAN_CTRLMODE_FD) &&

	    (!priv->data_bittiming.bitrate ||

	     (priv->data_bittiming.bitrate < priv->bittiming.bitrate))) {

	     priv->data_bittiming.bitrate < priv->bittiming.bitrate)) {

		netdev_err(dev, "incorrect/missing data bit-timing\n");

		return -EINVAL;

	}

EXPORT_SYMBOL_GPL(of_can_transceiver);

#endif

/*

 * Common close function for cleanup before the device gets closed.

/* Common close function for cleanup before the device gets closed.

 *

 * This function should be called in the close function of the device

 * driver.

}

EXPORT_SYMBOL_GPL(close_candev);

/*

 * CAN netlink interface

 */

/* CAN netlink interface */

static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = {

	[IFLA_CAN_STATE]	= { .type = NLA_U32 },

	[IFLA_CAN_CTRLMODE]	= { .len = sizeof(struct can_ctrlmode) },

static void can_dellink(struct net_device *dev, struct list_head *head)

{

	return;

}

static struct rtnl_link_ops can_link_ops __read_mostly = {

	.fill_xstats	= can_fill_xstats,

};

/*

 * Register the CAN network device

 */

/* Register the CAN network device */

int register_candev(struct net_device *dev)

{

	struct can_priv *priv = netdev_priv(dev);

}

EXPORT_SYMBOL_GPL(register_candev);

/*

 * Unregister the CAN network device

 */

/* Unregister the CAN network device */

void unregister_candev(struct net_device *dev)

{

	unregister_netdev(dev);

}

EXPORT_SYMBOL_GPL(unregister_candev);

/*

 * Test if a network device is a candev based device

/* Test if a network device is a candev based device

 * and return the can_priv* if so.

 */

struct can_priv *safe_candev_priv(struct net_device *dev)

{

	if ((dev->type != ARPHRD_CAN) || (dev->rtnl_link_ops != &can_link_ops))

	if (dev->type != ARPHRD_CAN || dev->rtnl_link_ops != &can_link_ops)

		return NULL;

	return netdev_priv(dev);

	err = rtnl_link_register(&can_link_ops);

	if (!err)

		printk(KERN_INFO MOD_DESC "\n");

		pr_info(MOD_DESC "\n");

	return err;

}

#define KVASER_PCIEFD_SYSID_BASE 0x1f020

#define KVASER_PCIEFD_SYSID_VERSION_REG (KVASER_PCIEFD_SYSID_BASE + 0x8)

#define KVASER_PCIEFD_SYSID_CANFREQ_REG (KVASER_PCIEFD_SYSID_BASE + 0xc)

#define KVASER_PCIEFD_SYSID_BUSFREQ_REG (KVASER_PCIEFD_SYSID_BASE + 0x10)

#define KVASER_PCIEFD_SYSID_BUILD_REG (KVASER_PCIEFD_SYSID_BASE + 0x14)

/* Shared receive buffer registers */

#define KVASER_PCIEFD_SRB_BASE 0x1f200

	struct kvaser_pciefd_can *can[KVASER_PCIEFD_MAX_CAN_CHANNELS];

	void *dma_data[KVASER_PCIEFD_DMA_COUNT];

	u8 nr_channels;

	u32 bus_freq;

	u32 freq;

	u32 freq_to_ticks_div;

};

	spin_lock_irqsave(&can->lock, irq);

	/* Set frequency to 500 KHz*/

	top = can->can.clock.freq / (2 * 500000) - 1;

	top = can->kv_pcie->bus_freq / (2 * 500000) - 1;

	pwm_ctrl = top & 0xff;

	pwm_ctrl |= (top & 0xff) << KVASER_PCIEFD_KCAN_PWM_TOP_SHIFT;

		return -ENODEV;

	}

	pcie->bus_freq = ioread32(pcie->reg_base +

				  KVASER_PCIEFD_SYSID_BUSFREQ_REG);

	pcie->freq = ioread32(pcie->reg_base + KVASER_PCIEFD_SYSID_CANFREQ_REG);

	pcie->freq_to_ticks_div = pcie->freq / 1000000;

	if (pcie->freq_to_ticks_div == 0)

	struct m_can_classdev *mcan_dev;

	struct gpio_desc *reset_gpio;

	struct gpio_desc *interrupt_gpio;

	struct gpio_desc *device_wake_gpio;

	struct gpio_desc *device_state_gpio;

	struct regulator *power;

	struct tcan4x5x_priv *priv = cdev->device_data;

	u32 val;

	tcan4x5x_check_wake(priv);

	regmap_read(priv->regmap, priv->reg_offset + reg, &val);

	return val;

	struct tcan4x5x_priv *priv = cdev->device_data;

	u32 val;

	tcan4x5x_check_wake(priv);

	regmap_read(priv->regmap, priv->mram_start + addr_offset, &val);

	return val;

{

	struct tcan4x5x_priv *priv = cdev->device_data;

	tcan4x5x_check_wake(priv);

	return regmap_write(priv->regmap, priv->reg_offset + reg, val);

}

{

	struct tcan4x5x_priv *priv = cdev->device_data;

	tcan4x5x_check_wake(priv);

	return regmap_write(priv->regmap, priv->mram_start + addr_offset, val);

}

{

	struct tcan4x5x_priv *priv = cdev->device_data;

	tcan4x5x_check_wake(priv);

	return regmap_write(priv->regmap, reg, val);

}

static int tcan4x5x_clear_interrupts(struct m_can_classdev *cdev)

{

	struct tcan4x5x_priv *tcan4x5x = cdev->device_data;

	int ret;

	tcan4x5x_check_wake(tcan4x5x);

	ret = tcan4x5x_write_tcan_reg(cdev, TCAN4X5X_STATUS,

				      TCAN4X5X_CLEAR_ALL_INT);

	if (ret)

{

	struct tcan4x5x_priv *tcan4x5x = cdev->device_data;

	tcan4x5x->interrupt_gpio = devm_gpiod_get(cdev->dev, "data-ready",

						  GPIOD_IN);

	if (IS_ERR(tcan4x5x->interrupt_gpio)) {

		dev_err(cdev->dev, "data-ready gpio not defined\n");

		return -EINVAL;

	}

	tcan4x5x->device_wake_gpio = devm_gpiod_get(cdev->dev, "device-wake",

						    GPIOD_OUT_HIGH);

	if (IS_ERR(tcan4x5x->device_wake_gpio)) {

	if (IS_ERR(tcan4x5x->device_state_gpio))

		tcan4x5x->device_state_gpio = NULL;

	cdev->net->irq = gpiod_to_irq(tcan4x5x->interrupt_gpio);

	tcan4x5x->power = devm_regulator_get_optional(cdev->dev,

						      "vsup");

	if (PTR_ERR(tcan4x5x->power) == -EPROBE_DEFER)

	mcan_class->is_peripheral = true;

	mcan_class->bit_timing = &tcan4x5x_bittiming_const;

	mcan_class->data_timing = &tcan4x5x_data_bittiming_const;

	mcan_class->net->irq = spi->irq;

	spi_set_drvdata(spi, priv);

 * - Sascha Hauer, Marc Kleine-Budde, Pengutronix

 * - Simon Kallweit, intefo AG

 * Copyright 2007

 *

 * Your platform definition file should specify something like:

 *

 * static struct mcp251x_platform_data mcp251x_info = {

 *         .oscillator_frequency = 8000000,

 * };

 *

 * static struct spi_board_info spi_board_info[] = {

 *         {

 *                 .modalias = "mcp2510",

 *			// "mcp2515" or "mcp25625" depending on your controller

 *                 .platform_data = &mcp251x_info,

 *                 .irq = IRQ_EINT13,

 *                 .max_speed_hz = 2*1000*1000,

 *                 .chip_select = 2,

 *         },

 * };

 *

 * Please see mcp251x.h for a description of the fields in

 * struct mcp251x_platform_data.

 */

#include <linux/can/core.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/netdevice.h>

#include <linux/of.h>

#include <linux/of_device.h>

#include <linux/property.h>

#include <linux/platform_device.h>

#include <linux/slab.h>

#include <linux/spi/spi.h>

	priv->tx_skb = NULL;

	priv->tx_len = 0;

	if (!spi->dev.of_node)

	if (!dev_fwnode(&spi->dev))

		flags = IRQF_TRIGGER_FALLING;

	ret = request_threaded_irq(spi->irq, NULL, mcp251x_can_ist,

static int mcp251x_can_probe(struct spi_device *spi)

{

	const struct of_device_id *of_id = of_match_device(mcp251x_of_match,

							   &spi->dev);

	const void *match = device_get_match_data(&spi->dev);

	struct mcp251x_platform_data *pdata = dev_get_platdata(&spi->dev);

	struct net_device *net;

	struct mcp251x_priv *priv;

	struct clk *clk;

	int freq, ret;

	clk = devm_clk_get(&spi->dev, NULL);

	if (IS_ERR(clk)) {

		if (pdata)

			freq = pdata->oscillator_frequency;

		else

	clk = devm_clk_get_optional(&spi->dev, NULL);

	if (IS_ERR(clk))

		return PTR_ERR(clk);

	} else {

	freq = clk_get_rate(clk);

	}

	if (freq == 0 && pdata)

		freq = pdata->oscillator_frequency;

	/* Sanity check */

	if (freq < 1000000 || freq > 25000000)

	if (!net)

		return -ENOMEM;

	if (!IS_ERR(clk)) {

	ret = clk_prepare_enable(clk);

	if (ret)

		goto out_free;

	}

	net->netdev_ops = &mcp251x_netdev_ops;

	net->flags |= IFF_ECHO;

	priv->can.clock.freq = freq / 2;

	priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES |

		CAN_CTRLMODE_LOOPBACK | CAN_CTRLMODE_LISTENONLY;

	if (of_id)

		priv->model = (enum mcp251x_model)of_id->data;

	if (match)

		priv->model = (enum mcp251x_model)match;

	else

		priv->model = spi_get_device_id(spi)->driver_data;

	priv->net = net;

	mcp251x_power_enable(priv->power, 0);

out_clk:

	if (!IS_ERR(clk))

	clk_disable_unprepare(clk);

out_free:

	mcp251x_power_enable(priv->power, 0);

	if (!IS_ERR(priv->clk))

	clk_disable_unprepare(priv->clk);

	free_candev(net);

		priv->after_suspend = AFTER_SUSPEND_DOWN;

	}

	if (!IS_ERR_OR_NULL(priv->power)) {

		regulator_disable(priv->power);

	mcp251x_power_enable(priv->power, 0);

	priv->after_suspend |= AFTER_SUSPEND_POWER;

	}

	return 0;

}