2009-11-02 16:07:00 -07:00
|
|
|
/*
|
|
|
|
* CAN bus driver for Microchip 251x CAN Controller with SPI Interface
|
|
|
|
*
|
|
|
|
* MCP2510 support and bug fixes by Christian Pellegrin
|
|
|
|
* <chripell@evolware.org>
|
|
|
|
*
|
|
|
|
* Copyright 2009 Christian Pellegrin EVOL S.r.l.
|
|
|
|
*
|
|
|
|
* Copyright 2007 Raymarine UK, Ltd. All Rights Reserved.
|
|
|
|
* Written under contract by:
|
|
|
|
* Chris Elston, Katalix Systems, Ltd.
|
|
|
|
*
|
|
|
|
* Based on Microchip MCP251x CAN controller driver written by
|
|
|
|
* David Vrabel, Copyright 2006 Arcom Control Systems Ltd.
|
|
|
|
*
|
|
|
|
* Based on CAN bus driver for the CCAN controller written by
|
|
|
|
* - Sascha Hauer, Marc Kleine-Budde, Pengutronix
|
|
|
|
* - Simon Kallweit, intefo AG
|
|
|
|
* Copyright 2007
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the version 2 of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2013-12-06 07:28:45 -07:00
|
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
2009-11-02 16:07:00 -07:00
|
|
|
*
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* 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[] = {
|
|
|
|
* {
|
2010-10-18 07:00:18 -06:00
|
|
|
* .modalias = "mcp2510",
|
|
|
|
* // or "mcp2515" depending on your controller
|
2009-11-02 16:07:00 -07:00
|
|
|
* .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/can/dev.h>
|
2012-12-18 10:51:02 -07:00
|
|
|
#include <linux/can/led.h>
|
2009-11-02 16:07:00 -07:00
|
|
|
#include <linux/can/platform/mcp251x.h>
|
2013-12-20 22:01:41 -07:00
|
|
|
#include <linux/clk.h>
|
2009-11-02 16:07:00 -07:00
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/freezer.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/netdevice.h>
|
2013-12-20 22:01:41 -07:00
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/of_device.h>
|
2009-11-02 16:07:00 -07:00
|
|
|
#include <linux/platform_device.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2009-11-02 16:07:00 -07:00
|
|
|
#include <linux/spi/spi.h>
|
|
|
|
#include <linux/uaccess.h>
|
2013-08-19 05:39:19 -06:00
|
|
|
#include <linux/regulator/consumer.h>
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
/* SPI interface instruction set */
|
|
|
|
#define INSTRUCTION_WRITE 0x02
|
|
|
|
#define INSTRUCTION_READ 0x03
|
|
|
|
#define INSTRUCTION_BIT_MODIFY 0x05
|
|
|
|
#define INSTRUCTION_LOAD_TXB(n) (0x40 + 2 * (n))
|
|
|
|
#define INSTRUCTION_READ_RXB(n) (((n) == 0) ? 0x90 : 0x94)
|
|
|
|
#define INSTRUCTION_RESET 0xC0
|
2012-08-27 07:02:45 -06:00
|
|
|
#define RTS_TXB0 0x01
|
|
|
|
#define RTS_TXB1 0x02
|
|
|
|
#define RTS_TXB2 0x04
|
|
|
|
#define INSTRUCTION_RTS(n) (0x80 | ((n) & 0x07))
|
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
/* MPC251x registers */
|
|
|
|
#define CANSTAT 0x0e
|
|
|
|
#define CANCTRL 0x0f
|
|
|
|
# define CANCTRL_REQOP_MASK 0xe0
|
|
|
|
# define CANCTRL_REQOP_CONF 0x80
|
|
|
|
# define CANCTRL_REQOP_LISTEN_ONLY 0x60
|
|
|
|
# define CANCTRL_REQOP_LOOPBACK 0x40
|
|
|
|
# define CANCTRL_REQOP_SLEEP 0x20
|
|
|
|
# define CANCTRL_REQOP_NORMAL 0x00
|
|
|
|
# define CANCTRL_OSM 0x08
|
|
|
|
# define CANCTRL_ABAT 0x10
|
|
|
|
#define TEC 0x1c
|
|
|
|
#define REC 0x1d
|
|
|
|
#define CNF1 0x2a
|
|
|
|
# define CNF1_SJW_SHIFT 6
|
|
|
|
#define CNF2 0x29
|
|
|
|
# define CNF2_BTLMODE 0x80
|
|
|
|
# define CNF2_SAM 0x40
|
|
|
|
# define CNF2_PS1_SHIFT 3
|
|
|
|
#define CNF3 0x28
|
|
|
|
# define CNF3_SOF 0x08
|
|
|
|
# define CNF3_WAKFIL 0x04
|
|
|
|
# define CNF3_PHSEG2_MASK 0x07
|
|
|
|
#define CANINTE 0x2b
|
|
|
|
# define CANINTE_MERRE 0x80
|
|
|
|
# define CANINTE_WAKIE 0x40
|
|
|
|
# define CANINTE_ERRIE 0x20
|
|
|
|
# define CANINTE_TX2IE 0x10
|
|
|
|
# define CANINTE_TX1IE 0x08
|
|
|
|
# define CANINTE_TX0IE 0x04
|
|
|
|
# define CANINTE_RX1IE 0x02
|
|
|
|
# define CANINTE_RX0IE 0x01
|
|
|
|
#define CANINTF 0x2c
|
|
|
|
# define CANINTF_MERRF 0x80
|
|
|
|
# define CANINTF_WAKIF 0x40
|
|
|
|
# define CANINTF_ERRIF 0x20
|
|
|
|
# define CANINTF_TX2IF 0x10
|
|
|
|
# define CANINTF_TX1IF 0x08
|
|
|
|
# define CANINTF_TX0IF 0x04
|
|
|
|
# define CANINTF_RX1IF 0x02
|
|
|
|
# define CANINTF_RX0IF 0x01
|
2010-10-19 18:02:25 -06:00
|
|
|
# define CANINTF_RX (CANINTF_RX0IF | CANINTF_RX1IF)
|
|
|
|
# define CANINTF_TX (CANINTF_TX2IF | CANINTF_TX1IF | CANINTF_TX0IF)
|
|
|
|
# define CANINTF_ERR (CANINTF_ERRIF)
|
2009-11-02 16:07:00 -07:00
|
|
|
#define EFLG 0x2d
|
|
|
|
# define EFLG_EWARN 0x01
|
|
|
|
# define EFLG_RXWAR 0x02
|
|
|
|
# define EFLG_TXWAR 0x04
|
|
|
|
# define EFLG_RXEP 0x08
|
|
|
|
# define EFLG_TXEP 0x10
|
|
|
|
# define EFLG_TXBO 0x20
|
|
|
|
# define EFLG_RX0OVR 0x40
|
|
|
|
# define EFLG_RX1OVR 0x80
|
|
|
|
#define TXBCTRL(n) (((n) * 0x10) + 0x30 + TXBCTRL_OFF)
|
|
|
|
# define TXBCTRL_ABTF 0x40
|
|
|
|
# define TXBCTRL_MLOA 0x20
|
|
|
|
# define TXBCTRL_TXERR 0x10
|
|
|
|
# define TXBCTRL_TXREQ 0x08
|
|
|
|
#define TXBSIDH(n) (((n) * 0x10) + 0x30 + TXBSIDH_OFF)
|
|
|
|
# define SIDH_SHIFT 3
|
|
|
|
#define TXBSIDL(n) (((n) * 0x10) + 0x30 + TXBSIDL_OFF)
|
|
|
|
# define SIDL_SID_MASK 7
|
|
|
|
# define SIDL_SID_SHIFT 5
|
|
|
|
# define SIDL_EXIDE_SHIFT 3
|
|
|
|
# define SIDL_EID_SHIFT 16
|
|
|
|
# define SIDL_EID_MASK 3
|
|
|
|
#define TXBEID8(n) (((n) * 0x10) + 0x30 + TXBEID8_OFF)
|
|
|
|
#define TXBEID0(n) (((n) * 0x10) + 0x30 + TXBEID0_OFF)
|
|
|
|
#define TXBDLC(n) (((n) * 0x10) + 0x30 + TXBDLC_OFF)
|
|
|
|
# define DLC_RTR_SHIFT 6
|
|
|
|
#define TXBCTRL_OFF 0
|
|
|
|
#define TXBSIDH_OFF 1
|
|
|
|
#define TXBSIDL_OFF 2
|
|
|
|
#define TXBEID8_OFF 3
|
|
|
|
#define TXBEID0_OFF 4
|
|
|
|
#define TXBDLC_OFF 5
|
|
|
|
#define TXBDAT_OFF 6
|
|
|
|
#define RXBCTRL(n) (((n) * 0x10) + 0x60 + RXBCTRL_OFF)
|
|
|
|
# define RXBCTRL_BUKT 0x04
|
|
|
|
# define RXBCTRL_RXM0 0x20
|
|
|
|
# define RXBCTRL_RXM1 0x40
|
|
|
|
#define RXBSIDH(n) (((n) * 0x10) + 0x60 + RXBSIDH_OFF)
|
|
|
|
# define RXBSIDH_SHIFT 3
|
|
|
|
#define RXBSIDL(n) (((n) * 0x10) + 0x60 + RXBSIDL_OFF)
|
|
|
|
# define RXBSIDL_IDE 0x08
|
2010-10-21 00:37:10 -06:00
|
|
|
# define RXBSIDL_SRR 0x10
|
2009-11-02 16:07:00 -07:00
|
|
|
# define RXBSIDL_EID 3
|
|
|
|
# define RXBSIDL_SHIFT 5
|
|
|
|
#define RXBEID8(n) (((n) * 0x10) + 0x60 + RXBEID8_OFF)
|
|
|
|
#define RXBEID0(n) (((n) * 0x10) + 0x60 + RXBEID0_OFF)
|
|
|
|
#define RXBDLC(n) (((n) * 0x10) + 0x60 + RXBDLC_OFF)
|
|
|
|
# define RXBDLC_LEN_MASK 0x0f
|
|
|
|
# define RXBDLC_RTR 0x40
|
|
|
|
#define RXBCTRL_OFF 0
|
|
|
|
#define RXBSIDH_OFF 1
|
|
|
|
#define RXBSIDL_OFF 2
|
|
|
|
#define RXBEID8_OFF 3
|
|
|
|
#define RXBEID0_OFF 4
|
|
|
|
#define RXBDLC_OFF 5
|
|
|
|
#define RXBDAT_OFF 6
|
2010-02-03 00:39:54 -07:00
|
|
|
#define RXFSIDH(n) ((n) * 4)
|
|
|
|
#define RXFSIDL(n) ((n) * 4 + 1)
|
|
|
|
#define RXFEID8(n) ((n) * 4 + 2)
|
|
|
|
#define RXFEID0(n) ((n) * 4 + 3)
|
|
|
|
#define RXMSIDH(n) ((n) * 4 + 0x20)
|
|
|
|
#define RXMSIDL(n) ((n) * 4 + 0x21)
|
|
|
|
#define RXMEID8(n) ((n) * 4 + 0x22)
|
|
|
|
#define RXMEID0(n) ((n) * 4 + 0x23)
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
#define GET_BYTE(val, byte) \
|
|
|
|
(((val) >> ((byte) * 8)) & 0xff)
|
|
|
|
#define SET_BYTE(val, byte) \
|
|
|
|
(((val) & 0xff) << ((byte) * 8))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Buffer size required for the largest SPI transfer (i.e., reading a
|
|
|
|
* frame)
|
|
|
|
*/
|
|
|
|
#define CAN_FRAME_MAX_DATA_LEN 8
|
|
|
|
#define SPI_TRANSFER_BUF_LEN (6 + CAN_FRAME_MAX_DATA_LEN)
|
|
|
|
#define CAN_FRAME_MAX_BITS 128
|
|
|
|
|
|
|
|
#define TX_ECHO_SKB_MAX 1
|
|
|
|
|
|
|
|
#define DEVICE_NAME "mcp251x"
|
|
|
|
|
|
|
|
static int mcp251x_enable_dma; /* Enable SPI DMA. Default: 0 (Off) */
|
|
|
|
module_param(mcp251x_enable_dma, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(mcp251x_enable_dma, "Enable SPI DMA. Default: 0 (Off)");
|
|
|
|
|
2012-07-16 04:58:31 -06:00
|
|
|
static const struct can_bittiming_const mcp251x_bittiming_const = {
|
2009-11-02 16:07:00 -07:00
|
|
|
.name = DEVICE_NAME,
|
|
|
|
.tseg1_min = 3,
|
|
|
|
.tseg1_max = 16,
|
|
|
|
.tseg2_min = 2,
|
|
|
|
.tseg2_max = 8,
|
|
|
|
.sjw_max = 4,
|
|
|
|
.brp_min = 1,
|
|
|
|
.brp_max = 64,
|
|
|
|
.brp_inc = 1,
|
|
|
|
};
|
|
|
|
|
2010-10-18 07:00:18 -06:00
|
|
|
enum mcp251x_model {
|
|
|
|
CAN_MCP251X_MCP2510 = 0x2510,
|
|
|
|
CAN_MCP251X_MCP2515 = 0x2515,
|
|
|
|
};
|
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
struct mcp251x_priv {
|
|
|
|
struct can_priv can;
|
|
|
|
struct net_device *net;
|
|
|
|
struct spi_device *spi;
|
2010-10-18 07:00:18 -06:00
|
|
|
enum mcp251x_model model;
|
2009-11-02 16:07:00 -07:00
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
struct mutex mcp_lock; /* SPI device lock */
|
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
u8 *spi_tx_buf;
|
|
|
|
u8 *spi_rx_buf;
|
|
|
|
dma_addr_t spi_tx_dma;
|
|
|
|
dma_addr_t spi_rx_dma;
|
|
|
|
|
|
|
|
struct sk_buff *tx_skb;
|
|
|
|
int tx_len;
|
2010-02-03 00:39:54 -07:00
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
struct workqueue_struct *wq;
|
|
|
|
struct work_struct tx_work;
|
2010-02-03 00:39:54 -07:00
|
|
|
struct work_struct restart_work;
|
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
int force_quit;
|
|
|
|
int after_suspend;
|
|
|
|
#define AFTER_SUSPEND_UP 1
|
|
|
|
#define AFTER_SUSPEND_DOWN 2
|
|
|
|
#define AFTER_SUSPEND_POWER 4
|
|
|
|
#define AFTER_SUSPEND_RESTART 8
|
|
|
|
int restart_tx;
|
2013-08-19 05:39:19 -06:00
|
|
|
struct regulator *power;
|
|
|
|
struct regulator *transceiver;
|
2013-12-20 22:01:41 -07:00
|
|
|
struct clk *clk;
|
2009-11-02 16:07:00 -07:00
|
|
|
};
|
|
|
|
|
2010-09-23 13:34:28 -06:00
|
|
|
#define MCP251X_IS(_model) \
|
|
|
|
static inline int mcp251x_is_##_model(struct spi_device *spi) \
|
|
|
|
{ \
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi); \
|
2010-09-23 13:34:28 -06:00
|
|
|
return priv->model == CAN_MCP251X_MCP##_model; \
|
|
|
|
}
|
|
|
|
|
|
|
|
MCP251X_IS(2510);
|
|
|
|
MCP251X_IS(2515);
|
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
static void mcp251x_clean(struct net_device *net)
|
|
|
|
{
|
|
|
|
struct mcp251x_priv *priv = netdev_priv(net);
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
if (priv->tx_skb || priv->tx_len)
|
|
|
|
net->stats.tx_errors++;
|
2009-11-02 16:07:00 -07:00
|
|
|
if (priv->tx_skb)
|
|
|
|
dev_kfree_skb(priv->tx_skb);
|
|
|
|
if (priv->tx_len)
|
|
|
|
can_free_echo_skb(priv->net, 0);
|
|
|
|
priv->tx_skb = NULL;
|
|
|
|
priv->tx_len = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note about handling of error return of mcp251x_spi_trans: accessing
|
|
|
|
* registers via SPI is not really different conceptually than using
|
|
|
|
* normal I/O assembler instructions, although it's much more
|
|
|
|
* complicated from a practical POV. So it's not advisable to always
|
|
|
|
* check the return value of this function. Imagine that every
|
|
|
|
* read{b,l}, write{b,l} and friends would be bracketed in "if ( < 0)
|
|
|
|
* error();", it would be a great mess (well there are some situation
|
|
|
|
* when exception handling C++ like could be useful after all). So we
|
|
|
|
* just check that transfers are OK at the beginning of our
|
|
|
|
* conversation with the chip and to avoid doing really nasty things
|
|
|
|
* (like injecting bogus packets in the network stack).
|
|
|
|
*/
|
|
|
|
static int mcp251x_spi_trans(struct spi_device *spi, int len)
|
|
|
|
{
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
struct spi_transfer t = {
|
|
|
|
.tx_buf = priv->spi_tx_buf,
|
|
|
|
.rx_buf = priv->spi_rx_buf,
|
|
|
|
.len = len,
|
|
|
|
.cs_change = 0,
|
|
|
|
};
|
|
|
|
struct spi_message m;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spi_message_init(&m);
|
|
|
|
|
|
|
|
if (mcp251x_enable_dma) {
|
|
|
|
t.tx_dma = priv->spi_tx_dma;
|
|
|
|
t.rx_dma = priv->spi_rx_dma;
|
|
|
|
m.is_dma_mapped = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
spi_message_add_tail(&t, &m);
|
|
|
|
|
|
|
|
ret = spi_sync(spi, &m);
|
|
|
|
if (ret)
|
|
|
|
dev_err(&spi->dev, "spi transfer failed: ret = %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u8 mcp251x_read_reg(struct spi_device *spi, uint8_t reg)
|
|
|
|
{
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
u8 val = 0;
|
|
|
|
|
|
|
|
priv->spi_tx_buf[0] = INSTRUCTION_READ;
|
|
|
|
priv->spi_tx_buf[1] = reg;
|
|
|
|
|
|
|
|
mcp251x_spi_trans(spi, 3);
|
|
|
|
val = priv->spi_rx_buf[2];
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2010-09-28 01:53:35 -06:00
|
|
|
static void mcp251x_read_2regs(struct spi_device *spi, uint8_t reg,
|
|
|
|
uint8_t *v1, uint8_t *v2)
|
|
|
|
{
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2010-09-28 01:53:35 -06:00
|
|
|
|
|
|
|
priv->spi_tx_buf[0] = INSTRUCTION_READ;
|
|
|
|
priv->spi_tx_buf[1] = reg;
|
|
|
|
|
|
|
|
mcp251x_spi_trans(spi, 4);
|
|
|
|
|
|
|
|
*v1 = priv->spi_rx_buf[2];
|
|
|
|
*v2 = priv->spi_rx_buf[3];
|
|
|
|
}
|
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
static void mcp251x_write_reg(struct spi_device *spi, u8 reg, uint8_t val)
|
|
|
|
{
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
priv->spi_tx_buf[0] = INSTRUCTION_WRITE;
|
|
|
|
priv->spi_tx_buf[1] = reg;
|
|
|
|
priv->spi_tx_buf[2] = val;
|
|
|
|
|
|
|
|
mcp251x_spi_trans(spi, 3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mcp251x_write_bits(struct spi_device *spi, u8 reg,
|
|
|
|
u8 mask, uint8_t val)
|
|
|
|
{
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
priv->spi_tx_buf[0] = INSTRUCTION_BIT_MODIFY;
|
|
|
|
priv->spi_tx_buf[1] = reg;
|
|
|
|
priv->spi_tx_buf[2] = mask;
|
|
|
|
priv->spi_tx_buf[3] = val;
|
|
|
|
|
|
|
|
mcp251x_spi_trans(spi, 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mcp251x_hw_tx_frame(struct spi_device *spi, u8 *buf,
|
|
|
|
int len, int tx_buf_idx)
|
|
|
|
{
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
2010-09-23 13:34:28 -06:00
|
|
|
if (mcp251x_is_2510(spi)) {
|
2009-11-02 16:07:00 -07:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 1; i < TXBDAT_OFF + len; i++)
|
|
|
|
mcp251x_write_reg(spi, TXBCTRL(tx_buf_idx) + i,
|
|
|
|
buf[i]);
|
|
|
|
} else {
|
|
|
|
memcpy(priv->spi_tx_buf, buf, TXBDAT_OFF + len);
|
|
|
|
mcp251x_spi_trans(spi, TXBDAT_OFF + len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mcp251x_hw_tx(struct spi_device *spi, struct can_frame *frame,
|
|
|
|
int tx_buf_idx)
|
|
|
|
{
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
u32 sid, eid, exide, rtr;
|
|
|
|
u8 buf[SPI_TRANSFER_BUF_LEN];
|
|
|
|
|
|
|
|
exide = (frame->can_id & CAN_EFF_FLAG) ? 1 : 0; /* Extended ID Enable */
|
|
|
|
if (exide)
|
|
|
|
sid = (frame->can_id & CAN_EFF_MASK) >> 18;
|
|
|
|
else
|
|
|
|
sid = frame->can_id & CAN_SFF_MASK; /* Standard ID */
|
|
|
|
eid = frame->can_id & CAN_EFF_MASK; /* Extended ID */
|
|
|
|
rtr = (frame->can_id & CAN_RTR_FLAG) ? 1 : 0; /* Remote transmission */
|
|
|
|
|
|
|
|
buf[TXBCTRL_OFF] = INSTRUCTION_LOAD_TXB(tx_buf_idx);
|
|
|
|
buf[TXBSIDH_OFF] = sid >> SIDH_SHIFT;
|
|
|
|
buf[TXBSIDL_OFF] = ((sid & SIDL_SID_MASK) << SIDL_SID_SHIFT) |
|
|
|
|
(exide << SIDL_EXIDE_SHIFT) |
|
|
|
|
((eid >> SIDL_EID_SHIFT) & SIDL_EID_MASK);
|
|
|
|
buf[TXBEID8_OFF] = GET_BYTE(eid, 1);
|
|
|
|
buf[TXBEID0_OFF] = GET_BYTE(eid, 0);
|
|
|
|
buf[TXBDLC_OFF] = (rtr << DLC_RTR_SHIFT) | frame->can_dlc;
|
|
|
|
memcpy(buf + TXBDAT_OFF, frame->data, frame->can_dlc);
|
|
|
|
mcp251x_hw_tx_frame(spi, buf, frame->can_dlc, tx_buf_idx);
|
2012-08-27 07:02:45 -06:00
|
|
|
|
|
|
|
/* use INSTRUCTION_RTS, to avoid "repeated frame problem" */
|
|
|
|
priv->spi_tx_buf[0] = INSTRUCTION_RTS(1 << tx_buf_idx);
|
|
|
|
mcp251x_spi_trans(priv->spi, 1);
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mcp251x_hw_rx_frame(struct spi_device *spi, u8 *buf,
|
|
|
|
int buf_idx)
|
|
|
|
{
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
2010-09-23 13:34:28 -06:00
|
|
|
if (mcp251x_is_2510(spi)) {
|
2009-11-02 16:07:00 -07:00
|
|
|
int i, len;
|
|
|
|
|
|
|
|
for (i = 1; i < RXBDAT_OFF; i++)
|
|
|
|
buf[i] = mcp251x_read_reg(spi, RXBCTRL(buf_idx) + i);
|
2009-12-11 21:13:21 -07:00
|
|
|
|
|
|
|
len = get_can_dlc(buf[RXBDLC_OFF] & RXBDLC_LEN_MASK);
|
2009-11-02 16:07:00 -07:00
|
|
|
for (; i < (RXBDAT_OFF + len); i++)
|
|
|
|
buf[i] = mcp251x_read_reg(spi, RXBCTRL(buf_idx) + i);
|
|
|
|
} else {
|
|
|
|
priv->spi_tx_buf[RXBCTRL_OFF] = INSTRUCTION_READ_RXB(buf_idx);
|
|
|
|
mcp251x_spi_trans(spi, SPI_TRANSFER_BUF_LEN);
|
|
|
|
memcpy(buf, priv->spi_rx_buf, SPI_TRANSFER_BUF_LEN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mcp251x_hw_rx(struct spi_device *spi, int buf_idx)
|
|
|
|
{
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
struct sk_buff *skb;
|
|
|
|
struct can_frame *frame;
|
|
|
|
u8 buf[SPI_TRANSFER_BUF_LEN];
|
|
|
|
|
|
|
|
skb = alloc_can_skb(priv->net, &frame);
|
|
|
|
if (!skb) {
|
|
|
|
dev_err(&spi->dev, "cannot allocate RX skb\n");
|
|
|
|
priv->net->stats.rx_dropped++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mcp251x_hw_rx_frame(spi, buf, buf_idx);
|
|
|
|
if (buf[RXBSIDL_OFF] & RXBSIDL_IDE) {
|
|
|
|
/* Extended ID format */
|
|
|
|
frame->can_id = CAN_EFF_FLAG;
|
|
|
|
frame->can_id |=
|
|
|
|
/* Extended ID part */
|
|
|
|
SET_BYTE(buf[RXBSIDL_OFF] & RXBSIDL_EID, 2) |
|
|
|
|
SET_BYTE(buf[RXBEID8_OFF], 1) |
|
|
|
|
SET_BYTE(buf[RXBEID0_OFF], 0) |
|
|
|
|
/* Standard ID part */
|
|
|
|
(((buf[RXBSIDH_OFF] << RXBSIDH_SHIFT) |
|
|
|
|
(buf[RXBSIDL_OFF] >> RXBSIDL_SHIFT)) << 18);
|
|
|
|
/* Remote transmission request */
|
|
|
|
if (buf[RXBDLC_OFF] & RXBDLC_RTR)
|
|
|
|
frame->can_id |= CAN_RTR_FLAG;
|
|
|
|
} else {
|
|
|
|
/* Standard ID format */
|
|
|
|
frame->can_id =
|
|
|
|
(buf[RXBSIDH_OFF] << RXBSIDH_SHIFT) |
|
|
|
|
(buf[RXBSIDL_OFF] >> RXBSIDL_SHIFT);
|
2010-10-21 00:37:10 -06:00
|
|
|
if (buf[RXBSIDL_OFF] & RXBSIDL_SRR)
|
|
|
|
frame->can_id |= CAN_RTR_FLAG;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
/* Data length */
|
2009-12-11 21:13:21 -07:00
|
|
|
frame->can_dlc = get_can_dlc(buf[RXBDLC_OFF] & RXBDLC_LEN_MASK);
|
2009-11-02 16:07:00 -07:00
|
|
|
memcpy(frame->data, buf + RXBDAT_OFF, frame->can_dlc);
|
|
|
|
|
|
|
|
priv->net->stats.rx_packets++;
|
|
|
|
priv->net->stats.rx_bytes += frame->can_dlc;
|
2012-12-18 10:51:02 -07:00
|
|
|
|
|
|
|
can_led_event(priv->net, CAN_LED_EVENT_RX);
|
|
|
|
|
2010-10-04 02:50:51 -06:00
|
|
|
netif_rx_ni(skb);
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mcp251x_hw_sleep(struct spi_device *spi)
|
|
|
|
{
|
|
|
|
mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_SLEEP);
|
|
|
|
}
|
|
|
|
|
|
|
|
static netdev_tx_t mcp251x_hard_start_xmit(struct sk_buff *skb,
|
|
|
|
struct net_device *net)
|
|
|
|
{
|
|
|
|
struct mcp251x_priv *priv = netdev_priv(net);
|
|
|
|
struct spi_device *spi = priv->spi;
|
|
|
|
|
|
|
|
if (priv->tx_skb || priv->tx_len) {
|
|
|
|
dev_warn(&spi->dev, "hard_xmit called while tx busy\n");
|
|
|
|
return NETDEV_TX_BUSY;
|
|
|
|
}
|
|
|
|
|
2010-01-12 03:00:46 -07:00
|
|
|
if (can_dropped_invalid_skb(net, skb))
|
2009-11-02 16:07:00 -07:00
|
|
|
return NETDEV_TX_OK;
|
|
|
|
|
|
|
|
netif_stop_queue(net);
|
|
|
|
priv->tx_skb = skb;
|
|
|
|
queue_work(priv->wq, &priv->tx_work);
|
|
|
|
|
|
|
|
return NETDEV_TX_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mcp251x_do_set_mode(struct net_device *net, enum can_mode mode)
|
|
|
|
{
|
|
|
|
struct mcp251x_priv *priv = netdev_priv(net);
|
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
case CAN_MODE_START:
|
2010-02-03 00:39:54 -07:00
|
|
|
mcp251x_clean(net);
|
2009-11-02 16:07:00 -07:00
|
|
|
/* We have to delay work since SPI I/O may sleep */
|
|
|
|
priv->can.state = CAN_STATE_ERROR_ACTIVE;
|
|
|
|
priv->restart_tx = 1;
|
|
|
|
if (priv->can.restart_ms == 0)
|
|
|
|
priv->after_suspend = AFTER_SUSPEND_RESTART;
|
2010-02-03 00:39:54 -07:00
|
|
|
queue_work(priv->wq, &priv->restart_work);
|
2009-11-02 16:07:00 -07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
static int mcp251x_set_normal_mode(struct spi_device *spi)
|
2009-11-02 16:07:00 -07:00
|
|
|
{
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
unsigned long timeout;
|
|
|
|
|
|
|
|
/* Enable interrupts */
|
|
|
|
mcp251x_write_reg(spi, CANINTE,
|
|
|
|
CANINTE_ERRIE | CANINTE_TX2IE | CANINTE_TX1IE |
|
2010-02-03 00:39:54 -07:00
|
|
|
CANINTE_TX0IE | CANINTE_RX1IE | CANINTE_RX0IE);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) {
|
|
|
|
/* Put device into loopback mode */
|
|
|
|
mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_LOOPBACK);
|
2010-01-14 00:08:34 -07:00
|
|
|
} else if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) {
|
|
|
|
/* Put device into listen-only mode */
|
|
|
|
mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_LISTEN_ONLY);
|
2009-11-02 16:07:00 -07:00
|
|
|
} else {
|
|
|
|
/* Put device into normal mode */
|
2010-02-03 00:39:54 -07:00
|
|
|
mcp251x_write_reg(spi, CANCTRL, CANCTRL_REQOP_NORMAL);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
/* Wait for the device to enter normal mode */
|
|
|
|
timeout = jiffies + HZ;
|
|
|
|
while (mcp251x_read_reg(spi, CANSTAT) & CANCTRL_REQOP_MASK) {
|
|
|
|
schedule();
|
|
|
|
if (time_after(jiffies, timeout)) {
|
|
|
|
dev_err(&spi->dev, "MCP251x didn't"
|
|
|
|
" enter in normal mode\n");
|
2010-02-03 00:39:54 -07:00
|
|
|
return -EBUSY;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
priv->can.state = CAN_STATE_ERROR_ACTIVE;
|
2010-02-03 00:39:54 -07:00
|
|
|
return 0;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mcp251x_do_set_bittiming(struct net_device *net)
|
|
|
|
{
|
|
|
|
struct mcp251x_priv *priv = netdev_priv(net);
|
|
|
|
struct can_bittiming *bt = &priv->can.bittiming;
|
|
|
|
struct spi_device *spi = priv->spi;
|
|
|
|
|
|
|
|
mcp251x_write_reg(spi, CNF1, ((bt->sjw - 1) << CNF1_SJW_SHIFT) |
|
|
|
|
(bt->brp - 1));
|
|
|
|
mcp251x_write_reg(spi, CNF2, CNF2_BTLMODE |
|
|
|
|
(priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES ?
|
|
|
|
CNF2_SAM : 0) |
|
|
|
|
((bt->phase_seg1 - 1) << CNF2_PS1_SHIFT) |
|
|
|
|
(bt->prop_seg - 1));
|
|
|
|
mcp251x_write_bits(spi, CNF3, CNF3_PHSEG2_MASK,
|
|
|
|
(bt->phase_seg2 - 1));
|
2014-03-05 10:31:56 -07:00
|
|
|
dev_dbg(&spi->dev, "CNF: 0x%02x 0x%02x 0x%02x\n",
|
|
|
|
mcp251x_read_reg(spi, CNF1),
|
|
|
|
mcp251x_read_reg(spi, CNF2),
|
|
|
|
mcp251x_read_reg(spi, CNF3));
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mcp251x_setup(struct net_device *net, struct mcp251x_priv *priv,
|
|
|
|
struct spi_device *spi)
|
|
|
|
{
|
2009-11-16 23:20:44 -07:00
|
|
|
mcp251x_do_set_bittiming(net);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
mcp251x_write_reg(spi, RXBCTRL(0),
|
|
|
|
RXBCTRL_BUKT | RXBCTRL_RXM0 | RXBCTRL_RXM1);
|
|
|
|
mcp251x_write_reg(spi, RXBCTRL(1),
|
|
|
|
RXBCTRL_RXM0 | RXBCTRL_RXM1);
|
2009-11-02 16:07:00 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
static int mcp251x_hw_reset(struct spi_device *spi)
|
2009-11-02 16:07:00 -07:00
|
|
|
{
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
int ret;
|
2010-02-03 00:39:54 -07:00
|
|
|
unsigned long timeout;
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
priv->spi_tx_buf[0] = INSTRUCTION_RESET;
|
|
|
|
ret = spi_write(spi, priv->spi_tx_buf, 1);
|
2010-02-03 00:39:54 -07:00
|
|
|
if (ret) {
|
2009-11-02 16:07:00 -07:00
|
|
|
dev_err(&spi->dev, "reset failed: ret = %d\n", ret);
|
2010-02-03 00:39:54 -07:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
/* Wait for reset to finish */
|
2010-02-03 00:39:54 -07:00
|
|
|
timeout = jiffies + HZ;
|
2009-11-02 16:07:00 -07:00
|
|
|
mdelay(10);
|
2010-02-03 00:39:54 -07:00
|
|
|
while ((mcp251x_read_reg(spi, CANSTAT) & CANCTRL_REQOP_MASK)
|
|
|
|
!= CANCTRL_REQOP_CONF) {
|
|
|
|
schedule();
|
|
|
|
if (time_after(jiffies, timeout)) {
|
|
|
|
dev_err(&spi->dev, "MCP251x didn't"
|
|
|
|
" enter in conf mode after reset\n");
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mcp251x_hw_probe(struct spi_device *spi)
|
|
|
|
{
|
|
|
|
int st1, st2;
|
|
|
|
|
|
|
|
mcp251x_hw_reset(spi);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Please note that these are "magic values" based on after
|
|
|
|
* reset defaults taken from data sheet which allows us to see
|
|
|
|
* if we really have a chip on the bus (we avoid common all
|
|
|
|
* zeroes or all ones situations)
|
|
|
|
*/
|
|
|
|
st1 = mcp251x_read_reg(spi, CANSTAT) & 0xEE;
|
|
|
|
st2 = mcp251x_read_reg(spi, CANCTRL) & 0x17;
|
|
|
|
|
|
|
|
dev_dbg(&spi->dev, "CANSTAT 0x%02x CANCTRL 0x%02x\n", st1, st2);
|
|
|
|
|
|
|
|
/* Check for power up default values */
|
|
|
|
return (st1 == 0x80 && st2 == 0x07) ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
2013-08-19 05:39:19 -06:00
|
|
|
static int mcp251x_power_enable(struct regulator *reg, int enable)
|
|
|
|
{
|
2014-03-14 02:46:20 -06:00
|
|
|
if (IS_ERR_OR_NULL(reg))
|
2013-08-19 05:39:19 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (enable)
|
|
|
|
return regulator_enable(reg);
|
|
|
|
else
|
|
|
|
return regulator_disable(reg);
|
|
|
|
}
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
static void mcp251x_open_clean(struct net_device *net)
|
2009-11-02 16:07:00 -07:00
|
|
|
{
|
|
|
|
struct mcp251x_priv *priv = netdev_priv(net);
|
|
|
|
struct spi_device *spi = priv->spi;
|
2009-11-16 23:20:44 -07:00
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
free_irq(spi->irq, priv);
|
|
|
|
mcp251x_hw_sleep(spi);
|
2013-08-19 05:39:19 -06:00
|
|
|
mcp251x_power_enable(priv->transceiver, 0);
|
2010-02-03 00:39:54 -07:00
|
|
|
close_candev(net);
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mcp251x_stop(struct net_device *net)
|
|
|
|
{
|
|
|
|
struct mcp251x_priv *priv = netdev_priv(net);
|
|
|
|
struct spi_device *spi = priv->spi;
|
|
|
|
|
|
|
|
close_candev(net);
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
priv->force_quit = 1;
|
|
|
|
free_irq(spi->irq, priv);
|
|
|
|
destroy_workqueue(priv->wq);
|
|
|
|
priv->wq = NULL;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mcp_lock);
|
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
/* Disable and clear pending interrupts */
|
|
|
|
mcp251x_write_reg(spi, CANINTE, 0x00);
|
|
|
|
mcp251x_write_reg(spi, CANINTF, 0x00);
|
|
|
|
|
|
|
|
mcp251x_write_reg(spi, TXBCTRL(0), 0);
|
2010-02-03 00:39:54 -07:00
|
|
|
mcp251x_clean(net);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
mcp251x_hw_sleep(spi);
|
|
|
|
|
2013-08-19 05:39:19 -06:00
|
|
|
mcp251x_power_enable(priv->transceiver, 0);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
priv->can.state = CAN_STATE_STOPPED;
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
mutex_unlock(&priv->mcp_lock);
|
|
|
|
|
2012-12-18 10:51:02 -07:00
|
|
|
can_led_event(net, CAN_LED_EVENT_STOP);
|
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
static void mcp251x_error_skb(struct net_device *net, int can_id, int data1)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct can_frame *frame;
|
|
|
|
|
|
|
|
skb = alloc_can_err_skb(net, &frame);
|
|
|
|
if (skb) {
|
2010-10-19 18:02:26 -06:00
|
|
|
frame->can_id |= can_id;
|
2010-02-03 00:39:54 -07:00
|
|
|
frame->data[1] = data1;
|
2010-10-04 02:50:51 -06:00
|
|
|
netif_rx_ni(skb);
|
2010-02-03 00:39:54 -07:00
|
|
|
} else {
|
2012-02-01 03:02:05 -07:00
|
|
|
netdev_err(net, "cannot allocate error skb\n");
|
2010-02-03 00:39:54 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
static void mcp251x_tx_work_handler(struct work_struct *ws)
|
|
|
|
{
|
|
|
|
struct mcp251x_priv *priv = container_of(ws, struct mcp251x_priv,
|
|
|
|
tx_work);
|
|
|
|
struct spi_device *spi = priv->spi;
|
|
|
|
struct net_device *net = priv->net;
|
|
|
|
struct can_frame *frame;
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
mutex_lock(&priv->mcp_lock);
|
2009-11-02 16:07:00 -07:00
|
|
|
if (priv->tx_skb) {
|
|
|
|
if (priv->can.state == CAN_STATE_BUS_OFF) {
|
|
|
|
mcp251x_clean(net);
|
2010-02-03 00:39:54 -07:00
|
|
|
} else {
|
|
|
|
frame = (struct can_frame *)priv->tx_skb->data;
|
|
|
|
|
|
|
|
if (frame->can_dlc > CAN_FRAME_MAX_DATA_LEN)
|
|
|
|
frame->can_dlc = CAN_FRAME_MAX_DATA_LEN;
|
|
|
|
mcp251x_hw_tx(spi, frame, 0);
|
|
|
|
priv->tx_len = 1 + frame->can_dlc;
|
|
|
|
can_put_echo_skb(priv->tx_skb, net, 0);
|
|
|
|
priv->tx_skb = NULL;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
}
|
2010-02-03 00:39:54 -07:00
|
|
|
mutex_unlock(&priv->mcp_lock);
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
static void mcp251x_restart_work_handler(struct work_struct *ws)
|
2009-11-02 16:07:00 -07:00
|
|
|
{
|
|
|
|
struct mcp251x_priv *priv = container_of(ws, struct mcp251x_priv,
|
2010-02-03 00:39:54 -07:00
|
|
|
restart_work);
|
2009-11-02 16:07:00 -07:00
|
|
|
struct spi_device *spi = priv->spi;
|
|
|
|
struct net_device *net = priv->net;
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
mutex_lock(&priv->mcp_lock);
|
2009-11-02 16:07:00 -07:00
|
|
|
if (priv->after_suspend) {
|
|
|
|
mdelay(10);
|
|
|
|
mcp251x_hw_reset(spi);
|
|
|
|
mcp251x_setup(net, priv, spi);
|
|
|
|
if (priv->after_suspend & AFTER_SUSPEND_RESTART) {
|
|
|
|
mcp251x_set_normal_mode(spi);
|
|
|
|
} else if (priv->after_suspend & AFTER_SUSPEND_UP) {
|
|
|
|
netif_device_attach(net);
|
2010-02-03 00:39:54 -07:00
|
|
|
mcp251x_clean(net);
|
2009-11-02 16:07:00 -07:00
|
|
|
mcp251x_set_normal_mode(spi);
|
2010-02-03 00:39:54 -07:00
|
|
|
netif_wake_queue(net);
|
2009-11-02 16:07:00 -07:00
|
|
|
} else {
|
|
|
|
mcp251x_hw_sleep(spi);
|
|
|
|
}
|
|
|
|
priv->after_suspend = 0;
|
2010-02-03 00:39:54 -07:00
|
|
|
priv->force_quit = 0;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
if (priv->restart_tx) {
|
|
|
|
priv->restart_tx = 0;
|
|
|
|
mcp251x_write_reg(spi, TXBCTRL(0), 0);
|
|
|
|
mcp251x_clean(net);
|
|
|
|
netif_wake_queue(net);
|
|
|
|
mcp251x_error_skb(net, CAN_ERR_RESTARTED, 0);
|
|
|
|
}
|
|
|
|
mutex_unlock(&priv->mcp_lock);
|
|
|
|
}
|
2009-11-02 16:07:00 -07:00
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
static irqreturn_t mcp251x_can_ist(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
struct mcp251x_priv *priv = dev_id;
|
|
|
|
struct spi_device *spi = priv->spi;
|
|
|
|
struct net_device *net = priv->net;
|
2009-11-02 16:07:00 -07:00
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
mutex_lock(&priv->mcp_lock);
|
|
|
|
while (!priv->force_quit) {
|
|
|
|
enum can_state new_state;
|
2010-09-28 01:53:35 -06:00
|
|
|
u8 intf, eflag;
|
2010-09-28 02:18:34 -06:00
|
|
|
u8 clear_intf = 0;
|
2010-02-03 00:39:54 -07:00
|
|
|
int can_id = 0, data1 = 0;
|
2009-11-02 16:07:00 -07:00
|
|
|
|
2010-09-28 01:53:35 -06:00
|
|
|
mcp251x_read_2regs(spi, CANINTF, &intf, &eflag);
|
|
|
|
|
2010-10-19 18:02:25 -06:00
|
|
|
/* mask out flags we don't care about */
|
|
|
|
intf &= CANINTF_RX | CANINTF_TX | CANINTF_ERR;
|
|
|
|
|
2010-09-28 02:18:34 -06:00
|
|
|
/* receive buffer 0 */
|
2010-02-03 00:39:54 -07:00
|
|
|
if (intf & CANINTF_RX0IF) {
|
|
|
|
mcp251x_hw_rx(spi, 0);
|
2010-10-04 04:09:31 -06:00
|
|
|
/*
|
|
|
|
* Free one buffer ASAP
|
|
|
|
* (The MCP2515 does this automatically.)
|
|
|
|
*/
|
|
|
|
if (mcp251x_is_2510(spi))
|
|
|
|
mcp251x_write_bits(spi, CANINTF, CANINTF_RX0IF, 0x00);
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
|
2010-09-28 02:18:34 -06:00
|
|
|
/* receive buffer 1 */
|
|
|
|
if (intf & CANINTF_RX1IF) {
|
2010-02-03 00:39:54 -07:00
|
|
|
mcp251x_hw_rx(spi, 1);
|
2010-10-04 04:09:31 -06:00
|
|
|
/* the MCP2515 does this automatically */
|
|
|
|
if (mcp251x_is_2510(spi))
|
|
|
|
clear_intf |= CANINTF_RX1IF;
|
2010-09-28 02:18:34 -06:00
|
|
|
}
|
2009-11-02 16:07:00 -07:00
|
|
|
|
2010-09-28 02:18:34 -06:00
|
|
|
/* any error or tx interrupt we need to clear? */
|
2010-10-19 18:02:25 -06:00
|
|
|
if (intf & (CANINTF_ERR | CANINTF_TX))
|
|
|
|
clear_intf |= intf & (CANINTF_ERR | CANINTF_TX);
|
2010-09-28 02:18:34 -06:00
|
|
|
if (clear_intf)
|
|
|
|
mcp251x_write_bits(spi, CANINTF, clear_intf, 0x00);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
2010-09-28 02:00:47 -06:00
|
|
|
if (eflag)
|
|
|
|
mcp251x_write_bits(spi, EFLG, eflag, 0x00);
|
2010-02-03 00:39:54 -07:00
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
/* Update can state */
|
|
|
|
if (eflag & EFLG_TXBO) {
|
|
|
|
new_state = CAN_STATE_BUS_OFF;
|
|
|
|
can_id |= CAN_ERR_BUSOFF;
|
|
|
|
} else if (eflag & EFLG_TXEP) {
|
|
|
|
new_state = CAN_STATE_ERROR_PASSIVE;
|
|
|
|
can_id |= CAN_ERR_CRTL;
|
|
|
|
data1 |= CAN_ERR_CRTL_TX_PASSIVE;
|
|
|
|
} else if (eflag & EFLG_RXEP) {
|
|
|
|
new_state = CAN_STATE_ERROR_PASSIVE;
|
|
|
|
can_id |= CAN_ERR_CRTL;
|
|
|
|
data1 |= CAN_ERR_CRTL_RX_PASSIVE;
|
|
|
|
} else if (eflag & EFLG_TXWAR) {
|
|
|
|
new_state = CAN_STATE_ERROR_WARNING;
|
|
|
|
can_id |= CAN_ERR_CRTL;
|
|
|
|
data1 |= CAN_ERR_CRTL_TX_WARNING;
|
|
|
|
} else if (eflag & EFLG_RXWAR) {
|
|
|
|
new_state = CAN_STATE_ERROR_WARNING;
|
|
|
|
can_id |= CAN_ERR_CRTL;
|
|
|
|
data1 |= CAN_ERR_CRTL_RX_WARNING;
|
|
|
|
} else {
|
|
|
|
new_state = CAN_STATE_ERROR_ACTIVE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update can state statistics */
|
|
|
|
switch (priv->can.state) {
|
|
|
|
case CAN_STATE_ERROR_ACTIVE:
|
|
|
|
if (new_state >= CAN_STATE_ERROR_WARNING &&
|
|
|
|
new_state <= CAN_STATE_BUS_OFF)
|
|
|
|
priv->can.can_stats.error_warning++;
|
|
|
|
case CAN_STATE_ERROR_WARNING: /* fallthrough */
|
|
|
|
if (new_state >= CAN_STATE_ERROR_PASSIVE &&
|
|
|
|
new_state <= CAN_STATE_BUS_OFF)
|
|
|
|
priv->can.can_stats.error_passive++;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
priv->can.state = new_state;
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
if (intf & CANINTF_ERRIF) {
|
|
|
|
/* Handle overflow counters */
|
|
|
|
if (eflag & (EFLG_RX0OVR | EFLG_RX1OVR)) {
|
2010-09-30 01:46:00 -06:00
|
|
|
if (eflag & EFLG_RX0OVR) {
|
2010-02-03 00:39:54 -07:00
|
|
|
net->stats.rx_over_errors++;
|
2010-09-30 01:46:00 -06:00
|
|
|
net->stats.rx_errors++;
|
|
|
|
}
|
|
|
|
if (eflag & EFLG_RX1OVR) {
|
2010-02-03 00:39:54 -07:00
|
|
|
net->stats.rx_over_errors++;
|
2010-09-30 01:46:00 -06:00
|
|
|
net->stats.rx_errors++;
|
|
|
|
}
|
2010-02-03 00:39:54 -07:00
|
|
|
can_id |= CAN_ERR_CRTL;
|
|
|
|
data1 |= CAN_ERR_CRTL_RX_OVERFLOW;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
2010-02-03 00:39:54 -07:00
|
|
|
mcp251x_error_skb(net, can_id, data1);
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->can.state == CAN_STATE_BUS_OFF) {
|
|
|
|
if (priv->can.restart_ms == 0) {
|
2010-02-03 00:39:54 -07:00
|
|
|
priv->force_quit = 1;
|
2009-11-02 16:07:00 -07:00
|
|
|
can_bus_off(net);
|
|
|
|
mcp251x_hw_sleep(spi);
|
2010-02-03 00:39:54 -07:00
|
|
|
break;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (intf == 0)
|
|
|
|
break;
|
|
|
|
|
2010-10-19 18:02:25 -06:00
|
|
|
if (intf & CANINTF_TX) {
|
2009-11-02 16:07:00 -07:00
|
|
|
net->stats.tx_packets++;
|
|
|
|
net->stats.tx_bytes += priv->tx_len - 1;
|
2012-12-18 10:51:02 -07:00
|
|
|
can_led_event(net, CAN_LED_EVENT_TX);
|
2009-11-02 16:07:00 -07:00
|
|
|
if (priv->tx_len) {
|
|
|
|
can_get_echo_skb(net, 0);
|
|
|
|
priv->tx_len = 0;
|
|
|
|
}
|
|
|
|
netif_wake_queue(net);
|
|
|
|
}
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
}
|
|
|
|
mutex_unlock(&priv->mcp_lock);
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
2009-11-02 16:07:00 -07:00
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
static int mcp251x_open(struct net_device *net)
|
|
|
|
{
|
|
|
|
struct mcp251x_priv *priv = netdev_priv(net);
|
|
|
|
struct spi_device *spi = priv->spi;
|
2013-08-19 05:39:20 -06:00
|
|
|
unsigned long flags = IRQF_ONESHOT | IRQF_TRIGGER_FALLING;
|
2010-02-03 00:39:54 -07:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = open_candev(net);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&spi->dev, "unable to set initial baudrate!\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(&priv->mcp_lock);
|
2013-08-19 05:39:19 -06:00
|
|
|
mcp251x_power_enable(priv->transceiver, 1);
|
2010-02-03 00:39:54 -07:00
|
|
|
|
|
|
|
priv->force_quit = 0;
|
|
|
|
priv->tx_skb = NULL;
|
|
|
|
priv->tx_len = 0;
|
|
|
|
|
|
|
|
ret = request_threaded_irq(spi->irq, NULL, mcp251x_can_ist,
|
2013-04-11 02:08:27 -06:00
|
|
|
flags, DEVICE_NAME, priv);
|
2010-02-03 00:39:54 -07:00
|
|
|
if (ret) {
|
|
|
|
dev_err(&spi->dev, "failed to acquire irq %d\n", spi->irq);
|
2013-08-19 05:39:19 -06:00
|
|
|
mcp251x_power_enable(priv->transceiver, 0);
|
2010-02-03 00:39:54 -07:00
|
|
|
close_candev(net);
|
|
|
|
goto open_unlock;
|
|
|
|
}
|
|
|
|
|
2011-02-16 01:25:31 -07:00
|
|
|
priv->wq = create_freezable_workqueue("mcp251x_wq");
|
2010-02-03 00:39:54 -07:00
|
|
|
INIT_WORK(&priv->tx_work, mcp251x_tx_work_handler);
|
|
|
|
INIT_WORK(&priv->restart_work, mcp251x_restart_work_handler);
|
|
|
|
|
|
|
|
ret = mcp251x_hw_reset(spi);
|
|
|
|
if (ret) {
|
|
|
|
mcp251x_open_clean(net);
|
|
|
|
goto open_unlock;
|
|
|
|
}
|
|
|
|
ret = mcp251x_setup(net, priv, spi);
|
|
|
|
if (ret) {
|
|
|
|
mcp251x_open_clean(net);
|
|
|
|
goto open_unlock;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
2010-02-03 00:39:54 -07:00
|
|
|
ret = mcp251x_set_normal_mode(spi);
|
|
|
|
if (ret) {
|
|
|
|
mcp251x_open_clean(net);
|
|
|
|
goto open_unlock;
|
|
|
|
}
|
2012-12-18 10:51:02 -07:00
|
|
|
|
|
|
|
can_led_event(net, CAN_LED_EVENT_OPEN);
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
netif_wake_queue(net);
|
|
|
|
|
|
|
|
open_unlock:
|
|
|
|
mutex_unlock(&priv->mcp_lock);
|
|
|
|
return ret;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct net_device_ops mcp251x_netdev_ops = {
|
|
|
|
.ndo_open = mcp251x_open,
|
|
|
|
.ndo_stop = mcp251x_stop,
|
|
|
|
.ndo_start_xmit = mcp251x_hard_start_xmit,
|
2014-03-07 01:23:41 -07:00
|
|
|
.ndo_change_mtu = can_change_mtu,
|
2009-11-02 16:07:00 -07:00
|
|
|
};
|
|
|
|
|
2013-12-20 22:01:41 -07:00
|
|
|
static const struct of_device_id mcp251x_of_match[] = {
|
|
|
|
{
|
|
|
|
.compatible = "microchip,mcp2510",
|
|
|
|
.data = (void *)CAN_MCP251X_MCP2510,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.compatible = "microchip,mcp2515",
|
|
|
|
.data = (void *)CAN_MCP251X_MCP2515,
|
|
|
|
},
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, mcp251x_of_match);
|
|
|
|
|
|
|
|
static const struct spi_device_id mcp251x_id_table[] = {
|
|
|
|
{
|
|
|
|
.name = "mcp2510",
|
|
|
|
.driver_data = (kernel_ulong_t)CAN_MCP251X_MCP2510,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "mcp2515",
|
|
|
|
.driver_data = (kernel_ulong_t)CAN_MCP251X_MCP2515,
|
|
|
|
},
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(spi, mcp251x_id_table);
|
|
|
|
|
2012-12-03 07:22:44 -07:00
|
|
|
static int mcp251x_can_probe(struct spi_device *spi)
|
2009-11-02 16:07:00 -07:00
|
|
|
{
|
2013-12-20 22:01:41 -07:00
|
|
|
const struct of_device_id *of_id = of_match_device(mcp251x_of_match,
|
|
|
|
&spi->dev);
|
|
|
|
struct mcp251x_platform_data *pdata = dev_get_platdata(&spi->dev);
|
2009-11-02 16:07:00 -07:00
|
|
|
struct net_device *net;
|
|
|
|
struct mcp251x_priv *priv;
|
2013-12-20 22:01:41 -07:00
|
|
|
int freq, ret = -ENODEV;
|
|
|
|
struct clk *clk;
|
|
|
|
|
|
|
|
clk = devm_clk_get(&spi->dev, NULL);
|
|
|
|
if (IS_ERR(clk)) {
|
|
|
|
if (pdata)
|
|
|
|
freq = pdata->oscillator_frequency;
|
|
|
|
else
|
|
|
|
return PTR_ERR(clk);
|
|
|
|
} else {
|
|
|
|
freq = clk_get_rate(clk);
|
|
|
|
}
|
2009-11-02 16:07:00 -07:00
|
|
|
|
2013-12-20 22:01:41 -07:00
|
|
|
/* Sanity check */
|
|
|
|
if (freq < 1000000 || freq > 25000000)
|
|
|
|
return -ERANGE;
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
/* Allocate can/net device */
|
|
|
|
net = alloc_candev(sizeof(struct mcp251x_priv), TX_ECHO_SKB_MAX);
|
2013-12-20 22:01:41 -07:00
|
|
|
if (!net)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (!IS_ERR(clk)) {
|
|
|
|
ret = clk_prepare_enable(clk);
|
|
|
|
if (ret)
|
|
|
|
goto out_free;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
net->netdev_ops = &mcp251x_netdev_ops;
|
|
|
|
net->flags |= IFF_ECHO;
|
|
|
|
|
|
|
|
priv = netdev_priv(net);
|
|
|
|
priv->can.bittiming_const = &mcp251x_bittiming_const;
|
|
|
|
priv->can.do_set_mode = mcp251x_do_set_mode;
|
2013-12-20 22:01:41 -07:00
|
|
|
priv->can.clock.freq = freq / 2;
|
2010-01-14 00:08:34 -07:00
|
|
|
priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES |
|
|
|
|
CAN_CTRLMODE_LOOPBACK | CAN_CTRLMODE_LISTENONLY;
|
2013-12-20 22:01:41 -07:00
|
|
|
if (of_id)
|
|
|
|
priv->model = (enum mcp251x_model)of_id->data;
|
|
|
|
else
|
|
|
|
priv->model = spi_get_device_id(spi)->driver_data;
|
2009-11-02 16:07:00 -07:00
|
|
|
priv->net = net;
|
2013-12-20 22:01:41 -07:00
|
|
|
priv->clk = clk;
|
2013-08-19 05:39:19 -06:00
|
|
|
|
|
|
|
priv->power = devm_regulator_get(&spi->dev, "vdd");
|
|
|
|
priv->transceiver = devm_regulator_get(&spi->dev, "xceiver");
|
|
|
|
if ((PTR_ERR(priv->power) == -EPROBE_DEFER) ||
|
|
|
|
(PTR_ERR(priv->transceiver) == -EPROBE_DEFER)) {
|
|
|
|
ret = -EPROBE_DEFER;
|
2013-12-20 22:01:41 -07:00
|
|
|
goto out_clk;
|
2013-08-19 05:39:19 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = mcp251x_power_enable(priv->power, 1);
|
|
|
|
if (ret)
|
2013-12-20 22:01:41 -07:00
|
|
|
goto out_clk;
|
2013-08-19 05:39:19 -06:00
|
|
|
|
2013-04-05 14:35:14 -06:00
|
|
|
spi_set_drvdata(spi, priv);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
priv->spi = spi;
|
2010-02-03 00:39:54 -07:00
|
|
|
mutex_init(&priv->mcp_lock);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
/* If requested, allocate DMA buffers */
|
|
|
|
if (mcp251x_enable_dma) {
|
|
|
|
spi->dev.coherent_dma_mask = ~0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Minimum coherent DMA allocation is PAGE_SIZE, so allocate
|
|
|
|
* that much and share it between Tx and Rx DMA buffers.
|
|
|
|
*/
|
|
|
|
priv->spi_tx_buf = dma_alloc_coherent(&spi->dev,
|
|
|
|
PAGE_SIZE,
|
|
|
|
&priv->spi_tx_dma,
|
|
|
|
GFP_DMA);
|
|
|
|
|
|
|
|
if (priv->spi_tx_buf) {
|
2012-06-04 06:44:18 -06:00
|
|
|
priv->spi_rx_buf = (priv->spi_tx_buf + (PAGE_SIZE / 2));
|
2009-11-02 16:07:00 -07:00
|
|
|
priv->spi_rx_dma = (dma_addr_t)(priv->spi_tx_dma +
|
|
|
|
(PAGE_SIZE / 2));
|
|
|
|
} else {
|
|
|
|
/* Fall back to non-DMA */
|
|
|
|
mcp251x_enable_dma = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate non-DMA buffers */
|
|
|
|
if (!mcp251x_enable_dma) {
|
2013-12-15 07:16:00 -07:00
|
|
|
priv->spi_tx_buf = devm_kzalloc(&spi->dev, SPI_TRANSFER_BUF_LEN,
|
|
|
|
GFP_KERNEL);
|
2009-11-02 16:07:00 -07:00
|
|
|
if (!priv->spi_tx_buf) {
|
|
|
|
ret = -ENOMEM;
|
2013-12-15 07:16:00 -07:00
|
|
|
goto error_probe;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
2013-12-15 07:16:00 -07:00
|
|
|
priv->spi_rx_buf = devm_kzalloc(&spi->dev, SPI_TRANSFER_BUF_LEN,
|
|
|
|
GFP_KERNEL);
|
2009-12-27 04:27:44 -07:00
|
|
|
if (!priv->spi_rx_buf) {
|
2009-11-02 16:07:00 -07:00
|
|
|
ret = -ENOMEM;
|
2013-12-15 07:16:00 -07:00
|
|
|
goto error_probe;
|
2009-11-02 16:07:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SET_NETDEV_DEV(net, &spi->dev);
|
|
|
|
|
|
|
|
/* Configure the SPI bus */
|
2013-08-19 05:39:21 -06:00
|
|
|
spi->mode = spi->mode ? : SPI_MODE_0;
|
|
|
|
if (mcp251x_is_2510(spi))
|
|
|
|
spi->max_speed_hz = spi->max_speed_hz ? : 5 * 1000 * 1000;
|
|
|
|
else
|
|
|
|
spi->max_speed_hz = spi->max_speed_hz ? : 10 * 1000 * 1000;
|
2009-11-02 16:07:00 -07:00
|
|
|
spi->bits_per_word = 8;
|
|
|
|
spi_setup(spi);
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
/* Here is OK to not lock the MCP, no one knows about it yet */
|
2009-11-02 16:07:00 -07:00
|
|
|
if (!mcp251x_hw_probe(spi)) {
|
2013-08-19 05:39:19 -06:00
|
|
|
ret = -ENODEV;
|
2009-11-02 16:07:00 -07:00
|
|
|
goto error_probe;
|
|
|
|
}
|
|
|
|
mcp251x_hw_sleep(spi);
|
|
|
|
|
|
|
|
ret = register_candev(net);
|
2012-12-18 10:51:02 -07:00
|
|
|
if (ret)
|
|
|
|
goto error_probe;
|
|
|
|
|
|
|
|
devm_can_led_init(net);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
error_probe:
|
|
|
|
if (mcp251x_enable_dma)
|
|
|
|
dma_free_coherent(&spi->dev, PAGE_SIZE,
|
|
|
|
priv->spi_tx_buf, priv->spi_tx_dma);
|
2013-08-19 05:39:19 -06:00
|
|
|
mcp251x_power_enable(priv->power, 0);
|
2013-12-20 22:01:41 -07:00
|
|
|
|
|
|
|
out_clk:
|
|
|
|
if (!IS_ERR(clk))
|
|
|
|
clk_disable_unprepare(clk);
|
|
|
|
|
|
|
|
out_free:
|
2013-08-19 05:39:19 -06:00
|
|
|
free_candev(net);
|
2013-12-20 22:01:41 -07:00
|
|
|
|
2009-11-02 16:07:00 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-12-03 07:22:44 -07:00
|
|
|
static int mcp251x_can_remove(struct spi_device *spi)
|
2009-11-02 16:07:00 -07:00
|
|
|
{
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
struct net_device *net = priv->net;
|
|
|
|
|
|
|
|
unregister_candev(net);
|
|
|
|
|
|
|
|
if (mcp251x_enable_dma) {
|
|
|
|
dma_free_coherent(&spi->dev, PAGE_SIZE,
|
|
|
|
priv->spi_tx_buf, priv->spi_tx_dma);
|
|
|
|
}
|
|
|
|
|
2013-08-19 05:39:19 -06:00
|
|
|
mcp251x_power_enable(priv->power, 0);
|
|
|
|
|
2013-12-20 22:01:41 -07:00
|
|
|
if (!IS_ERR(priv->clk))
|
|
|
|
clk_disable_unprepare(priv->clk);
|
|
|
|
|
2013-08-19 05:39:19 -06:00
|
|
|
free_candev(net);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-21 22:51:14 -07:00
|
|
|
static int __maybe_unused mcp251x_can_suspend(struct device *dev)
|
2009-11-02 16:07:00 -07:00
|
|
|
{
|
2013-03-12 06:13:53 -06:00
|
|
|
struct spi_device *spi = to_spi_device(dev);
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
struct net_device *net = priv->net;
|
|
|
|
|
2010-02-03 00:39:54 -07:00
|
|
|
priv->force_quit = 1;
|
|
|
|
disable_irq(spi->irq);
|
|
|
|
/*
|
|
|
|
* Note: at this point neither IST nor workqueues are running.
|
|
|
|
* open/stop cannot be called anyway so locking is not needed
|
|
|
|
*/
|
2009-11-02 16:07:00 -07:00
|
|
|
if (netif_running(net)) {
|
|
|
|
netif_device_detach(net);
|
|
|
|
|
|
|
|
mcp251x_hw_sleep(spi);
|
2013-08-19 05:39:19 -06:00
|
|
|
mcp251x_power_enable(priv->transceiver, 0);
|
2009-11-02 16:07:00 -07:00
|
|
|
priv->after_suspend = AFTER_SUSPEND_UP;
|
|
|
|
} else {
|
|
|
|
priv->after_suspend = AFTER_SUSPEND_DOWN;
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:46:20 -06:00
|
|
|
if (!IS_ERR_OR_NULL(priv->power)) {
|
2013-08-19 05:39:19 -06:00
|
|
|
regulator_disable(priv->power);
|
2009-11-02 16:07:00 -07:00
|
|
|
priv->after_suspend |= AFTER_SUSPEND_POWER;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-21 22:51:14 -07:00
|
|
|
static int __maybe_unused mcp251x_can_resume(struct device *dev)
|
2009-11-02 16:07:00 -07:00
|
|
|
{
|
2013-03-12 06:13:53 -06:00
|
|
|
struct spi_device *spi = to_spi_device(dev);
|
2013-04-05 14:35:14 -06:00
|
|
|
struct mcp251x_priv *priv = spi_get_drvdata(spi);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
if (priv->after_suspend & AFTER_SUSPEND_POWER) {
|
2013-08-19 05:39:19 -06:00
|
|
|
mcp251x_power_enable(priv->power, 1);
|
2010-02-03 00:39:54 -07:00
|
|
|
queue_work(priv->wq, &priv->restart_work);
|
2009-11-02 16:07:00 -07:00
|
|
|
} else {
|
|
|
|
if (priv->after_suspend & AFTER_SUSPEND_UP) {
|
2013-08-19 05:39:19 -06:00
|
|
|
mcp251x_power_enable(priv->transceiver, 1);
|
2010-02-03 00:39:54 -07:00
|
|
|
queue_work(priv->wq, &priv->restart_work);
|
2009-11-02 16:07:00 -07:00
|
|
|
} else {
|
|
|
|
priv->after_suspend = 0;
|
|
|
|
}
|
|
|
|
}
|
2010-02-03 00:39:54 -07:00
|
|
|
priv->force_quit = 0;
|
|
|
|
enable_irq(spi->irq);
|
2009-11-02 16:07:00 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2013-03-12 06:13:53 -06:00
|
|
|
|
|
|
|
static SIMPLE_DEV_PM_OPS(mcp251x_can_pm_ops, mcp251x_can_suspend,
|
|
|
|
mcp251x_can_resume);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
static struct spi_driver mcp251x_can_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = DEVICE_NAME,
|
|
|
|
.owner = THIS_MODULE,
|
2013-12-20 22:01:41 -07:00
|
|
|
.of_match_table = mcp251x_of_match,
|
2013-04-16 03:28:27 -06:00
|
|
|
.pm = &mcp251x_can_pm_ops,
|
2009-11-02 16:07:00 -07:00
|
|
|
},
|
2010-03-29 02:57:56 -06:00
|
|
|
.id_table = mcp251x_id_table,
|
2009-11-02 16:07:00 -07:00
|
|
|
.probe = mcp251x_can_probe,
|
2012-12-03 07:22:44 -07:00
|
|
|
.remove = mcp251x_can_remove,
|
2009-11-02 16:07:00 -07:00
|
|
|
};
|
2013-03-12 06:13:52 -06:00
|
|
|
module_spi_driver(mcp251x_can_driver);
|
2009-11-02 16:07:00 -07:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Chris Elston <celston@katalix.com>, "
|
|
|
|
"Christian Pellegrin <chripell@evolware.org>");
|
|
|
|
MODULE_DESCRIPTION("Microchip 251x CAN driver");
|
|
|
|
MODULE_LICENSE("GPL v2");
|