flexcan.c revision 871d33725545ca2e402b4526f38f89d041ba930f
11da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 21da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * flexcan.c - FLEXCAN CAN controller driver 31da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 41da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Copyright (c) 2005-2006 Varma Electronics Oy 51da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Copyright (c) 2009 Sascha Hauer, Pengutronix 61da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Copyright (c) 2010 Marc Kleine-Budde, Pengutronix 71da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 81da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Based on code originally by Andrey Volkov <avolkov@varma-el.com> 91da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1058d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust * LICENCE: 111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This program is free software; you can redistribute it and/or 121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * modify it under the terms of the GNU General Public License as 131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * published by the Free Software Foundation version 2. 141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This program is distributed in the hope that it will be useful, 161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * but WITHOUT ANY WARRANTY; without even the implied warranty of 171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * GNU General Public License for more details. 194ce79717ce32a9f88c1ddce4b9658556cb59d37aTrond Myklebust * 201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 2124c8dbbb5f777187d660393599641ab3307b4b97David Howells 221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/netdevice.h> 231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/can.h> 241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/can/dev.h> 251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/can/error.h> 261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/can/platform/flexcan.h> 271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/clk.h> 281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/delay.h> 291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/if_arp.h> 30888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#include <linux/if_ether.h> 31888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#include <linux/interrupt.h> 32888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#include <linux/io.h> 33888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#include <linux/kernel.h> 34888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#include <linux/list.h> 35888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#include <linux/module.h> 36888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#include <linux/of.h> 37888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#include <linux/platform_device.h> 38888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust 39888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define DRV_NAME "flexcan" 40888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust 41888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust/* 8 for RX fifo and 2 error handling */ 42888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_NAPI_WEIGHT (8 + 2) 43888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust 44888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust/* FLEXCAN module configuration register (CANMCR) bits */ 45888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_MDIS BIT(31) 46888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_FRZ BIT(30) 47888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_FEN BIT(29) 48888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_HALT BIT(28) 49888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_NOT_RDY BIT(27) 50888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_WAK_MSK BIT(26) 517539bbab8062aadc1db95a22b377146843cfa88fDavid Howells#define FLEXCAN_MCR_SOFTRST BIT(25) 52888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_FRZ_ACK BIT(24) 53888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_SUPV BIT(23) 54888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_SLF_WAK BIT(22) 55888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_WRN_EN BIT(21) 56888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_LPM_ACK BIT(20) 57888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_WAK_SRC BIT(19) 58888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_DOZE BIT(18) 59888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_SRX_DIS BIT(17) 60901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust#define FLEXCAN_MCR_BCC BIT(16) 611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MCR_LPRIO_EN BIT(13) 621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MCR_AEN BIT(12) 631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MCR_MAXMB(x) ((x) & 0xf) 641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MCR_IDAM_A (0 << 8) 65888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_MCR_IDAM_B (1 << 8) 661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MCR_IDAM_C (2 << 8) 671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MCR_IDAM_D (3 << 8) 681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* FLEXCAN control register (CANCTRL) bits */ 701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_CTRL_PRESDIV(x) (((x) & 0xff) << 24) 711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_CTRL_RJW(x) (((x) & 0x03) << 22) 721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_CTRL_PSEG1(x) (((x) & 0x07) << 19) 731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_CTRL_PSEG2(x) (((x) & 0x07) << 16) 741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_CTRL_BOFF_MSK BIT(15) 75901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust#define FLEXCAN_CTRL_ERR_MSK BIT(14) 76901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust#define FLEXCAN_CTRL_CLK_SRC BIT(13) 771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_CTRL_LPB BIT(12) 781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_CTRL_TWRN_MSK BIT(11) 79539cd03a5708c9861a3e738e6f363ad743c85ddfTrond Myklebust#define FLEXCAN_CTRL_RWRN_MSK BIT(10) 80888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_CTRL_SMP BIT(7) 81888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_CTRL_BOFF_REC BIT(6) 821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_CTRL_TSYN BIT(5) 83888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_CTRL_LBUF BIT(4) 84888e694c167975709f17526dbbed2d98f84e8f85Trond Myklebust#define FLEXCAN_CTRL_LOM BIT(3) 851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_CTRL_PROPSEG(x) ((x) & 0x07) 861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_CTRL_ERR_BUS (FLEXCAN_CTRL_ERR_MSK) 871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_CTRL_ERR_STATE \ 881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (FLEXCAN_CTRL_TWRN_MSK | FLEXCAN_CTRL_RWRN_MSK | \ 891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds FLEXCAN_CTRL_BOFF_MSK) 901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_CTRL_ERR_ALL \ 911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (FLEXCAN_CTRL_ERR_BUS | FLEXCAN_CTRL_ERR_STATE) 921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* FLEXCAN error and status register (ESR) bits */ 941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_TWRN_INT BIT(17) 951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_RWRN_INT BIT(16) 961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_BIT1_ERR BIT(15) 971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_BIT0_ERR BIT(14) 981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_ACK_ERR BIT(13) 991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_CRC_ERR BIT(12) 1001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_FRM_ERR BIT(11) 1011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_STF_ERR BIT(10) 1021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_TX_WRN BIT(9) 1031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_RX_WRN BIT(8) 1041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_IDLE BIT(7) 1051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_TXRX BIT(6) 1061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_EST_FLT_CONF_SHIFT (4) 1071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_FLT_CONF_MASK (0x3 << FLEXCAN_EST_FLT_CONF_SHIFT) 1081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_FLT_CONF_ACTIVE (0x0 << FLEXCAN_EST_FLT_CONF_SHIFT) 1091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_FLT_CONF_PASSIVE (0x1 << FLEXCAN_EST_FLT_CONF_SHIFT) 1101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_BOFF_INT BIT(2) 1111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_ERR_INT BIT(1) 1121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_WAK_INT BIT(0) 1131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_ERR_BUS \ 1141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (FLEXCAN_ESR_BIT1_ERR | FLEXCAN_ESR_BIT0_ERR | \ 1157539bbab8062aadc1db95a22b377146843cfa88fDavid Howells FLEXCAN_ESR_ACK_ERR | FLEXCAN_ESR_CRC_ERR | \ 1161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds FLEXCAN_ESR_FRM_ERR | FLEXCAN_ESR_STF_ERR) 1171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_ERR_STATE \ 1181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (FLEXCAN_ESR_TWRN_INT | FLEXCAN_ESR_RWRN_INT | FLEXCAN_ESR_BOFF_INT) 1191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_ESR_ERR_ALL \ 120b3c52da33ce95747b1bff86cce716d4f1397f14aTrond Myklebust (FLEXCAN_ESR_ERR_BUS | FLEXCAN_ESR_ERR_STATE) 121b3c52da33ce95747b1bff86cce716d4f1397f14aTrond Myklebust 122b3c52da33ce95747b1bff86cce716d4f1397f14aTrond Myklebust/* FLEXCAN interrupt flag register (IFLAG) bits */ 123b3c52da33ce95747b1bff86cce716d4f1397f14aTrond Myklebust#define FLEXCAN_TX_BUF_ID 8 124f52720ca5f48574e347dff35ffe6b389ace61537Panagiotis Issaris#define FLEXCAN_IFLAG_BUF(x) BIT(x) 1251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_IFLAG_RX_FIFO_OVERFLOW BIT(7) 1261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_IFLAG_RX_FIFO_WARN BIT(6) 1271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_IFLAG_RX_FIFO_AVAILABLE BIT(5) 1281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_IFLAG_DEFAULT \ 1291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (FLEXCAN_IFLAG_RX_FIFO_OVERFLOW | FLEXCAN_IFLAG_RX_FIFO_AVAILABLE | \ 1301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds FLEXCAN_IFLAG_BUF(FLEXCAN_TX_BUF_ID)) 131beb2a5ec386e5ce6891ebd1c06b913da04354b40Trond Myklebust 1321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* FLEXCAN message buffers */ 1331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MB_CNT_CODE(x) (((x) & 0xf) << 24) 1341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MB_CNT_SRR BIT(22) 1351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MB_CNT_IDE BIT(21) 1361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MB_CNT_RTR BIT(20) 1371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MB_CNT_LENGTH(x) (((x) & 0xf) << 16) 1381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MB_CNT_TIMESTAMP(x) ((x) & 0xffff) 1391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FLEXCAN_MB_CODE_MASK (0xf0ffffff) 1411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Structure of the message buffer */ 1431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct flexcan_mb { 1441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 can_ctrl; 1451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 can_id; 14624c8dbbb5f777187d660393599641ab3307b4b97David Howells u32 data[2]; 1471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 1481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Structure of the hardware registers */ 1501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct flexcan_regs { 151f99d49adf527fa6f7a9c42257fa76bca6b8df1e3Jesper Juhl u32 mcr; /* 0x00 */ 1521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 ctrl; /* 0x04 */ 1531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 timer; /* 0x08 */ 1541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 _reserved1; /* 0x0c */ 1551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rxgmask; /* 0x10 */ 1561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rx14mask; /* 0x14 */ 1571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 rx15mask; /* 0x18 */ 1581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 ecr; /* 0x1c */ 1591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 esr; /* 0x20 */ 1601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 imask2; /* 0x24 */ 1611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 imask1; /* 0x28 */ 1621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 iflag2; /* 0x2c */ 1631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 iflag1; /* 0x30 */ 1641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 _reserved2[19]; 1651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct flexcan_mb cantxfg[64]; 1661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 1671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct flexcan_priv { 1691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct can_priv can; 1701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct net_device *dev; 1711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct napi_struct napi; 1721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds void __iomem *base; 1741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 reg_esr; 175901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust u32 reg_ctrl_default; 1761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1777539bbab8062aadc1db95a22b377146843cfa88fDavid Howells struct clk *clk; 1781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct flexcan_platform_data *pdata; 1791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 1801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct can_bittiming_const flexcan_bittiming_const = { 1821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .name = DRV_NAME, 1831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .tseg1_min = 4, 184901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust .tseg1_max = 16, 1851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .tseg2_min = 2, 1861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .tseg2_max = 8, 1871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .sjw_max = 4, 1881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .brp_min = 1, 189901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust .brp_max = 256, 190901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust .brp_inc = 1, 191901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust}; 192901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust 193901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust/* 194901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust * Abstract off the read/write for arm versus ppc. 195901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust */ 196901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust#if defined(__BIG_ENDIAN) 197901630278469c0d7610554227f39ed2d02d0d270Trond Myklebuststatic inline u32 flexcan_read(void __iomem *addr) 198901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust{ 199901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust return in_be32(addr); 200901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust} 201901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust 202901630278469c0d7610554227f39ed2d02d0d270Trond Myklebuststatic inline void flexcan_write(u32 val, void __iomem *addr) 203901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust{ 204901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust out_be32(addr, val); 205901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust} 206901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust#else 207901630278469c0d7610554227f39ed2d02d0d270Trond Myklebuststatic inline u32 flexcan_read(void __iomem *addr) 208901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust{ 209901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust return readl(addr); 210901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust} 211901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust 212901630278469c0d7610554227f39ed2d02d0d270Trond Myklebuststatic inline void flexcan_write(u32 val, void __iomem *addr) 213901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust{ 214901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust writel(val, addr); 215901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust} 216901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust#endif 217901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust 218901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust/* 219901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust * Swtich transceiver on or off 220901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust */ 221901630278469c0d7610554227f39ed2d02d0d270Trond Myklebuststatic void flexcan_transceiver_switch(const struct flexcan_priv *priv, int on) 222901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust{ 223901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust if (priv->pdata && priv->pdata->transceiver_switch) 2241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds priv->pdata->transceiver_switch(on); 2251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline int flexcan_has_and_handle_berr(const struct flexcan_priv *priv, 2281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 reg_esr) 2291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 2301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) && 2317539bbab8062aadc1db95a22b377146843cfa88fDavid Howells (reg_esr & FLEXCAN_ESR_ERR_BUS); 2321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void flexcan_chip_enable(struct flexcan_priv *priv) 2351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 2361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct flexcan_regs __iomem *regs = priv->base; 2371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 reg; 2381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = flexcan_read(®s->mcr); 2401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg &= ~FLEXCAN_MCR_MDIS; 2411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flexcan_write(reg, ®s->mcr); 2421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(10); 2441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 245901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust 2461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void flexcan_chip_disable(struct flexcan_priv *priv) 247901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust{ 2481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct flexcan_regs __iomem *regs = priv->base; 2491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 reg; 2501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg = flexcan_read(®s->mcr); 2521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg |= FLEXCAN_MCR_MDIS; 2531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flexcan_write(reg, ®s->mcr); 25410afec9081fee7e48995fa396fba22c7de4b99d4Trond Myklebust} 25558d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust 256adfa6f980bd46974e6b32b22dd0c45e3f52063f4David Howellsstatic int flexcan_get_berr_counter(const struct net_device *dev, 25758d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust struct can_berr_counter *bec) 25858d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust{ 25958d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust const struct flexcan_priv *priv = netdev_priv(dev); 26058d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust struct flexcan_regs __iomem *regs = priv->base; 26158d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust u32 reg = flexcan_read(®s->ecr); 26258d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust 26358d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust bec->txerr = (reg >> 0) & 0xff; 26458d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust bec->rxerr = (reg >> 8) & 0xff; 26558d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust 26658d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust return 0; 26758d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust} 26858d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust 26958d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebuststatic int flexcan_start_xmit(struct sk_buff *skb, struct net_device *dev) 27058d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust{ 271901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust const struct flexcan_priv *priv = netdev_priv(dev); 27258d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust struct net_device_stats *stats = &dev->stats; 273901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust struct flexcan_regs __iomem *regs = priv->base; 27458d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust struct can_frame *cf = (struct can_frame *)skb->data; 27526c78e156b1d1b2387ec33b5f2fb62d6e0a186a3Trond Myklebust u32 can_id; 27658d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust u32 ctrl = FLEXCAN_MB_CNT_CODE(0xc) | (cf->can_dlc << 16); 27758d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust 27858d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust if (can_dropped_invalid_skb(dev, skb)) 27924c8dbbb5f777187d660393599641ab3307b4b97David Howells return NETDEV_TX_OK; 28058d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust 28158d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust netif_stop_queue(dev); 28258d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust 283adfa6f980bd46974e6b32b22dd0c45e3f52063f4David Howells if (cf->can_id & CAN_EFF_FLAG) { 28458d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust can_id = cf->can_id & CAN_EFF_MASK; 28558d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust ctrl |= FLEXCAN_MB_CNT_IDE | FLEXCAN_MB_CNT_SRR; 28658d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust } else { 28758d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust can_id = (cf->can_id & CAN_SFF_MASK) << 18; 28858d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust } 28958d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust 29058d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust if (cf->can_id & CAN_RTR_FLAG) 29124c8dbbb5f777187d660393599641ab3307b4b97David Howells ctrl |= FLEXCAN_MB_CNT_RTR; 29258d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust 29358d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust if (cf->can_dlc > 0) { 29424c8dbbb5f777187d660393599641ab3307b4b97David Howells u32 data = be32_to_cpup((__be32 *)&cf->data[0]); 29558d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust flexcan_write(data, ®s->cantxfg[FLEXCAN_TX_BUF_ID].data[0]); 29658d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust } 29758d9714a44a79bba9b414da3ffbf3c753dc5915fTrond Myklebust if (cf->can_dlc > 3) { 2981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 data = be32_to_cpup((__be32 *)&cf->data[4]); 2991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flexcan_write(data, ®s->cantxfg[FLEXCAN_TX_BUF_ID].data[1]); 3001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 301adfa6f980bd46974e6b32b22dd0c45e3f52063f4David Howells 3021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flexcan_write(can_id, ®s->cantxfg[FLEXCAN_TX_BUF_ID].can_id); 3031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flexcan_write(ctrl, ®s->cantxfg[FLEXCAN_TX_BUF_ID].can_ctrl); 3041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kfree_skb(skb); 3061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* tx_packets is incremented in flexcan_irq */ 3081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds stats->tx_bytes += cf->can_dlc; 3091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NETDEV_TX_OK; 3111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void do_bus_err(struct net_device *dev, 314901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust struct can_frame *cf, u32 reg_esr) 3151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 316901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust struct flexcan_priv *priv = netdev_priv(dev); 3171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rx_errors = 0, tx_errors = 0; 3181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 3201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (reg_esr & FLEXCAN_ESR_BIT1_ERR) { 3221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev_dbg(dev->dev.parent, "BIT1_ERR irq\n"); 3231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->data[2] |= CAN_ERR_PROT_BIT1; 3241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tx_errors = 1; 325adfa6f980bd46974e6b32b22dd0c45e3f52063f4David Howells } 3261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (reg_esr & FLEXCAN_ESR_BIT0_ERR) { 3271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev_dbg(dev->dev.parent, "BIT0_ERR irq\n"); 3281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->data[2] |= CAN_ERR_PROT_BIT0; 3291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tx_errors = 1; 3301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (reg_esr & FLEXCAN_ESR_ACK_ERR) { 3321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev_dbg(dev->dev.parent, "ACK_ERR irq\n"); 3331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->can_id |= CAN_ERR_ACK; 3341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->data[3] |= CAN_ERR_PROT_LOC_ACK; 3351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tx_errors = 1; 3367539bbab8062aadc1db95a22b377146843cfa88fDavid Howells } 3371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (reg_esr & FLEXCAN_ESR_CRC_ERR) { 3381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev_dbg(dev->dev.parent, "CRC_ERR irq\n"); 3391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->data[2] |= CAN_ERR_PROT_BIT; 3401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ; 3411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rx_errors = 1; 3421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (reg_esr & FLEXCAN_ESR_FRM_ERR) { 3441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev_dbg(dev->dev.parent, "FRM_ERR irq\n"); 3451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->data[2] |= CAN_ERR_PROT_FORM; 346901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust rx_errors = 1; 347901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust } 3481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (reg_esr & FLEXCAN_ESR_STF_ERR) { 349901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust dev_dbg(dev->dev.parent, "STF_ERR irq\n"); 3501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->data[2] |= CAN_ERR_PROT_STUFF; 3511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rx_errors = 1; 3521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 353901630278469c0d7610554227f39ed2d02d0d270Trond Myklebust 3541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds priv->can.can_stats.bus_error++; 3551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rx_errors) 3561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev->stats.rx_errors++; 3571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tx_errors) 3581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev->stats.tx_errors++; 3591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int flexcan_poll_bus_err(struct net_device *dev, u32 reg_esr) 3621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 3631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct sk_buff *skb; 3641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct can_frame *cf; 3651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds skb = alloc_can_err_skb(dev, &cf); 3671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (unlikely(!skb)) 3681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 3691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do_bus_err(dev, cf, reg_esr); 3711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds netif_receive_skb(skb); 3721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev->stats.rx_packets++; 3741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev->stats.rx_bytes += cf->can_dlc; 3751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 3771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void do_state(struct net_device *dev, 3801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct can_frame *cf, enum can_state new_state) 3811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 3821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct flexcan_priv *priv = netdev_priv(dev); 3831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct can_berr_counter bec; 3841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flexcan_get_berr_counter(dev, &bec); 3861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch (priv->can.state) { 3881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case CAN_STATE_ERROR_ACTIVE: 3891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* 390adfa6f980bd46974e6b32b22dd0c45e3f52063f4David Howells * from: ERROR_ACTIVE 3911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to : ERROR_WARNING, ERROR_PASSIVE, BUS_OFF 3921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * => : there was a warning int 3931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 3941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (new_state >= CAN_STATE_ERROR_WARNING && 3951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_state <= CAN_STATE_BUS_OFF) { 3961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev_dbg(dev->dev.parent, "Error Warning IRQ\n"); 3971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds priv->can.can_stats.error_warning++; 3981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->can_id |= CAN_ERR_CRTL; 4001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->data[1] = (bec.txerr > bec.rxerr) ? 4011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds CAN_ERR_CRTL_TX_WARNING : 4021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds CAN_ERR_CRTL_RX_WARNING; 4031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case CAN_STATE_ERROR_WARNING: /* fallthrough */ 4051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* 4061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * from: ERROR_ACTIVE, ERROR_WARNING 4071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to : ERROR_PASSIVE, BUS_OFF 408adfa6f980bd46974e6b32b22dd0c45e3f52063f4David Howells * => : error passive int 4091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 4101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (new_state >= CAN_STATE_ERROR_PASSIVE && 4111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds new_state <= CAN_STATE_BUS_OFF) { 4121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev_dbg(dev->dev.parent, "Error Passive IRQ\n"); 4131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds priv->can.can_stats.error_passive++; 4141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->can_id |= CAN_ERR_CRTL; 4161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->data[1] = (bec.txerr > bec.rxerr) ? 4171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds CAN_ERR_CRTL_TX_PASSIVE : 4181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds CAN_ERR_CRTL_RX_PASSIVE; 4191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 420adfa6f980bd46974e6b32b22dd0c45e3f52063f4David Howells break; 4211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case CAN_STATE_BUS_OFF: 4221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev_err(dev->dev.parent, 4231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "BUG! hardware recovered automatically from BUS_OFF\n"); 4241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 4251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds default: 4261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 4271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* process state changes depending on the new state */ 4301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch (new_state) { 4311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case CAN_STATE_ERROR_ACTIVE: 4321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev_dbg(dev->dev.parent, "Error Active\n"); 4331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->can_id |= CAN_ERR_PROT; 4341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->data[2] = CAN_ERR_PROT_ACTIVE; 4351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 4361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case CAN_STATE_BUS_OFF: 4371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cf->can_id |= CAN_ERR_BUSOFF; 4381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds can_bus_off(dev); 4393e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust break; 4403e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust default: 4413e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust break; 4427539bbab8062aadc1db95a22b377146843cfa88fDavid Howells } 4433e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust} 4443e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust 4453e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebuststatic int flexcan_poll_state(struct net_device *dev, u32 reg_esr) 4463e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust{ 4473e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust struct flexcan_priv *priv = netdev_priv(dev); 4483e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust struct sk_buff *skb; 4493e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust struct can_frame *cf; 4503e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust enum can_state new_state; 4513e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust int flt; 4523e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust 4533e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust flt = reg_esr & FLEXCAN_ESR_FLT_CONF_MASK; 4543e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust if (likely(flt == FLEXCAN_ESR_FLT_CONF_ACTIVE)) { 4553e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust if (likely(!(reg_esr & (FLEXCAN_ESR_TX_WRN | 4563e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust FLEXCAN_ESR_RX_WRN)))) 4573e4f6290ca4df7464ee066123f2bca4298c2dab4Trond Myklebust new_state = CAN_STATE_ERROR_ACTIVE; 458 else 459 new_state = CAN_STATE_ERROR_WARNING; 460 } else if (unlikely(flt == FLEXCAN_ESR_FLT_CONF_PASSIVE)) 461 new_state = CAN_STATE_ERROR_PASSIVE; 462 else 463 new_state = CAN_STATE_BUS_OFF; 464 465 /* state hasn't changed */ 466 if (likely(new_state == priv->can.state)) 467 return 0; 468 469 skb = alloc_can_err_skb(dev, &cf); 470 if (unlikely(!skb)) 471 return 0; 472 473 do_state(dev, cf, new_state); 474 priv->can.state = new_state; 475 netif_receive_skb(skb); 476 477 dev->stats.rx_packets++; 478 dev->stats.rx_bytes += cf->can_dlc; 479 480 return 1; 481} 482 483static void flexcan_read_fifo(const struct net_device *dev, 484 struct can_frame *cf) 485{ 486 const struct flexcan_priv *priv = netdev_priv(dev); 487 struct flexcan_regs __iomem *regs = priv->base; 488 struct flexcan_mb __iomem *mb = ®s->cantxfg[0]; 489 u32 reg_ctrl, reg_id; 490 491 reg_ctrl = flexcan_read(&mb->can_ctrl); 492 reg_id = flexcan_read(&mb->can_id); 493 if (reg_ctrl & FLEXCAN_MB_CNT_IDE) 494 cf->can_id = ((reg_id >> 0) & CAN_EFF_MASK) | CAN_EFF_FLAG; 495 else 496 cf->can_id = (reg_id >> 18) & CAN_SFF_MASK; 497 498 if (reg_ctrl & FLEXCAN_MB_CNT_RTR) 499 cf->can_id |= CAN_RTR_FLAG; 500 cf->can_dlc = get_can_dlc((reg_ctrl >> 16) & 0xf); 501 502 *(__be32 *)(cf->data + 0) = cpu_to_be32(flexcan_read(&mb->data[0])); 503 *(__be32 *)(cf->data + 4) = cpu_to_be32(flexcan_read(&mb->data[1])); 504 505 /* mark as read */ 506 flexcan_write(FLEXCAN_IFLAG_RX_FIFO_AVAILABLE, ®s->iflag1); 507 flexcan_read(®s->timer); 508} 509 510static int flexcan_read_frame(struct net_device *dev) 511{ 512 struct net_device_stats *stats = &dev->stats; 513 struct can_frame *cf; 514 struct sk_buff *skb; 515 516 skb = alloc_can_skb(dev, &cf); 517 if (unlikely(!skb)) { 518 stats->rx_dropped++; 519 return 0; 520 } 521 522 flexcan_read_fifo(dev, cf); 523 netif_receive_skb(skb); 524 525 stats->rx_packets++; 526 stats->rx_bytes += cf->can_dlc; 527 528 return 1; 529} 530 531static int flexcan_poll(struct napi_struct *napi, int quota) 532{ 533 struct net_device *dev = napi->dev; 534 const struct flexcan_priv *priv = netdev_priv(dev); 535 struct flexcan_regs __iomem *regs = priv->base; 536 u32 reg_iflag1, reg_esr; 537 int work_done = 0; 538 539 /* 540 * The error bits are cleared on read, 541 * use saved value from irq handler. 542 */ 543 reg_esr = flexcan_read(®s->esr) | priv->reg_esr; 544 545 /* handle state changes */ 546 work_done += flexcan_poll_state(dev, reg_esr); 547 548 /* handle RX-FIFO */ 549 reg_iflag1 = flexcan_read(®s->iflag1); 550 while (reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_AVAILABLE && 551 work_done < quota) { 552 work_done += flexcan_read_frame(dev); 553 reg_iflag1 = flexcan_read(®s->iflag1); 554 } 555 556 /* report bus errors */ 557 if (flexcan_has_and_handle_berr(priv, reg_esr) && work_done < quota) 558 work_done += flexcan_poll_bus_err(dev, reg_esr); 559 560 if (work_done < quota) { 561 napi_complete(napi); 562 /* enable IRQs */ 563 flexcan_write(FLEXCAN_IFLAG_DEFAULT, ®s->imask1); 564 flexcan_write(priv->reg_ctrl_default, ®s->ctrl); 565 } 566 567 return work_done; 568} 569 570static irqreturn_t flexcan_irq(int irq, void *dev_id) 571{ 572 struct net_device *dev = dev_id; 573 struct net_device_stats *stats = &dev->stats; 574 struct flexcan_priv *priv = netdev_priv(dev); 575 struct flexcan_regs __iomem *regs = priv->base; 576 u32 reg_iflag1, reg_esr; 577 578 reg_iflag1 = flexcan_read(®s->iflag1); 579 reg_esr = flexcan_read(®s->esr); 580 flexcan_write(FLEXCAN_ESR_ERR_INT, ®s->esr); /* ACK err IRQ */ 581 582 /* 583 * schedule NAPI in case of: 584 * - rx IRQ 585 * - state change IRQ 586 * - bus error IRQ and bus error reporting is activated 587 */ 588 if ((reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_AVAILABLE) || 589 (reg_esr & FLEXCAN_ESR_ERR_STATE) || 590 flexcan_has_and_handle_berr(priv, reg_esr)) { 591 /* 592 * The error bits are cleared on read, 593 * save them for later use. 594 */ 595 priv->reg_esr = reg_esr & FLEXCAN_ESR_ERR_BUS; 596 flexcan_write(FLEXCAN_IFLAG_DEFAULT & 597 ~FLEXCAN_IFLAG_RX_FIFO_AVAILABLE, ®s->imask1); 598 flexcan_write(priv->reg_ctrl_default & ~FLEXCAN_CTRL_ERR_ALL, 599 ®s->ctrl); 600 napi_schedule(&priv->napi); 601 } 602 603 /* FIFO overflow */ 604 if (reg_iflag1 & FLEXCAN_IFLAG_RX_FIFO_OVERFLOW) { 605 flexcan_write(FLEXCAN_IFLAG_RX_FIFO_OVERFLOW, ®s->iflag1); 606 dev->stats.rx_over_errors++; 607 dev->stats.rx_errors++; 608 } 609 610 /* transmission complete interrupt */ 611 if (reg_iflag1 & (1 << FLEXCAN_TX_BUF_ID)) { 612 /* tx_bytes is incremented in flexcan_start_xmit */ 613 stats->tx_packets++; 614 flexcan_write((1 << FLEXCAN_TX_BUF_ID), ®s->iflag1); 615 netif_wake_queue(dev); 616 } 617 618 return IRQ_HANDLED; 619} 620 621static void flexcan_set_bittiming(struct net_device *dev) 622{ 623 const struct flexcan_priv *priv = netdev_priv(dev); 624 const struct can_bittiming *bt = &priv->can.bittiming; 625 struct flexcan_regs __iomem *regs = priv->base; 626 u32 reg; 627 628 reg = flexcan_read(®s->ctrl); 629 reg &= ~(FLEXCAN_CTRL_PRESDIV(0xff) | 630 FLEXCAN_CTRL_RJW(0x3) | 631 FLEXCAN_CTRL_PSEG1(0x7) | 632 FLEXCAN_CTRL_PSEG2(0x7) | 633 FLEXCAN_CTRL_PROPSEG(0x7) | 634 FLEXCAN_CTRL_LPB | 635 FLEXCAN_CTRL_SMP | 636 FLEXCAN_CTRL_LOM); 637 638 reg |= FLEXCAN_CTRL_PRESDIV(bt->brp - 1) | 639 FLEXCAN_CTRL_PSEG1(bt->phase_seg1 - 1) | 640 FLEXCAN_CTRL_PSEG2(bt->phase_seg2 - 1) | 641 FLEXCAN_CTRL_RJW(bt->sjw - 1) | 642 FLEXCAN_CTRL_PROPSEG(bt->prop_seg - 1); 643 644 if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) 645 reg |= FLEXCAN_CTRL_LPB; 646 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 647 reg |= FLEXCAN_CTRL_LOM; 648 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) 649 reg |= FLEXCAN_CTRL_SMP; 650 651 dev_info(dev->dev.parent, "writing ctrl=0x%08x\n", reg); 652 flexcan_write(reg, ®s->ctrl); 653 654 /* print chip status */ 655 dev_dbg(dev->dev.parent, "%s: mcr=0x%08x ctrl=0x%08x\n", __func__, 656 flexcan_read(®s->mcr), flexcan_read(®s->ctrl)); 657} 658 659/* 660 * flexcan_chip_start 661 * 662 * this functions is entered with clocks enabled 663 * 664 */ 665static int flexcan_chip_start(struct net_device *dev) 666{ 667 struct flexcan_priv *priv = netdev_priv(dev); 668 struct flexcan_regs __iomem *regs = priv->base; 669 unsigned int i; 670 int err; 671 u32 reg_mcr, reg_ctrl; 672 673 /* enable module */ 674 flexcan_chip_enable(priv); 675 676 /* soft reset */ 677 flexcan_write(FLEXCAN_MCR_SOFTRST, ®s->mcr); 678 udelay(10); 679 680 reg_mcr = flexcan_read(®s->mcr); 681 if (reg_mcr & FLEXCAN_MCR_SOFTRST) { 682 dev_err(dev->dev.parent, 683 "Failed to softreset can module (mcr=0x%08x)\n", 684 reg_mcr); 685 err = -ENODEV; 686 goto out; 687 } 688 689 flexcan_set_bittiming(dev); 690 691 /* 692 * MCR 693 * 694 * enable freeze 695 * enable fifo 696 * halt now 697 * only supervisor access 698 * enable warning int 699 * choose format C 700 * 701 */ 702 reg_mcr = flexcan_read(®s->mcr); 703 reg_mcr |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_FEN | FLEXCAN_MCR_HALT | 704 FLEXCAN_MCR_SUPV | FLEXCAN_MCR_WRN_EN | 705 FLEXCAN_MCR_IDAM_C; 706 dev_dbg(dev->dev.parent, "%s: writing mcr=0x%08x", __func__, reg_mcr); 707 flexcan_write(reg_mcr, ®s->mcr); 708 709 /* 710 * CTRL 711 * 712 * disable timer sync feature 713 * 714 * disable auto busoff recovery 715 * transmit lowest buffer first 716 * 717 * enable tx and rx warning interrupt 718 * enable bus off interrupt 719 * (== FLEXCAN_CTRL_ERR_STATE) 720 * 721 * _note_: we enable the "error interrupt" 722 * (FLEXCAN_CTRL_ERR_MSK), too. Otherwise we don't get any 723 * warning or bus passive interrupts. 724 */ 725 reg_ctrl = flexcan_read(®s->ctrl); 726 reg_ctrl &= ~FLEXCAN_CTRL_TSYN; 727 reg_ctrl |= FLEXCAN_CTRL_BOFF_REC | FLEXCAN_CTRL_LBUF | 728 FLEXCAN_CTRL_ERR_STATE | FLEXCAN_CTRL_ERR_MSK; 729 730 /* save for later use */ 731 priv->reg_ctrl_default = reg_ctrl; 732 dev_dbg(dev->dev.parent, "%s: writing ctrl=0x%08x", __func__, reg_ctrl); 733 flexcan_write(reg_ctrl, ®s->ctrl); 734 735 for (i = 0; i < ARRAY_SIZE(regs->cantxfg); i++) { 736 flexcan_write(0, ®s->cantxfg[i].can_ctrl); 737 flexcan_write(0, ®s->cantxfg[i].can_id); 738 flexcan_write(0, ®s->cantxfg[i].data[0]); 739 flexcan_write(0, ®s->cantxfg[i].data[1]); 740 741 /* put MB into rx queue */ 742 flexcan_write(FLEXCAN_MB_CNT_CODE(0x4), 743 ®s->cantxfg[i].can_ctrl); 744 } 745 746 /* acceptance mask/acceptance code (accept everything) */ 747 flexcan_write(0x0, ®s->rxgmask); 748 flexcan_write(0x0, ®s->rx14mask); 749 flexcan_write(0x0, ®s->rx15mask); 750 751 flexcan_transceiver_switch(priv, 1); 752 753 /* synchronize with the can bus */ 754 reg_mcr = flexcan_read(®s->mcr); 755 reg_mcr &= ~FLEXCAN_MCR_HALT; 756 flexcan_write(reg_mcr, ®s->mcr); 757 758 priv->can.state = CAN_STATE_ERROR_ACTIVE; 759 760 /* enable FIFO interrupts */ 761 flexcan_write(FLEXCAN_IFLAG_DEFAULT, ®s->imask1); 762 763 /* print chip status */ 764 dev_dbg(dev->dev.parent, "%s: reading mcr=0x%08x ctrl=0x%08x\n", 765 __func__, flexcan_read(®s->mcr), flexcan_read(®s->ctrl)); 766 767 return 0; 768 769 out: 770 flexcan_chip_disable(priv); 771 return err; 772} 773 774/* 775 * flexcan_chip_stop 776 * 777 * this functions is entered with clocks enabled 778 * 779 */ 780static void flexcan_chip_stop(struct net_device *dev) 781{ 782 struct flexcan_priv *priv = netdev_priv(dev); 783 struct flexcan_regs __iomem *regs = priv->base; 784 u32 reg; 785 786 /* Disable all interrupts */ 787 flexcan_write(0, ®s->imask1); 788 789 /* Disable + halt module */ 790 reg = flexcan_read(®s->mcr); 791 reg |= FLEXCAN_MCR_MDIS | FLEXCAN_MCR_HALT; 792 flexcan_write(reg, ®s->mcr); 793 794 flexcan_transceiver_switch(priv, 0); 795 priv->can.state = CAN_STATE_STOPPED; 796 797 return; 798} 799 800static int flexcan_open(struct net_device *dev) 801{ 802 struct flexcan_priv *priv = netdev_priv(dev); 803 int err; 804 805 clk_enable(priv->clk); 806 807 err = open_candev(dev); 808 if (err) 809 goto out; 810 811 err = request_irq(dev->irq, flexcan_irq, IRQF_SHARED, dev->name, dev); 812 if (err) 813 goto out_close; 814 815 /* start chip and queuing */ 816 err = flexcan_chip_start(dev); 817 if (err) 818 goto out_close; 819 napi_enable(&priv->napi); 820 netif_start_queue(dev); 821 822 return 0; 823 824 out_close: 825 close_candev(dev); 826 out: 827 clk_disable(priv->clk); 828 829 return err; 830} 831 832static int flexcan_close(struct net_device *dev) 833{ 834 struct flexcan_priv *priv = netdev_priv(dev); 835 836 netif_stop_queue(dev); 837 napi_disable(&priv->napi); 838 flexcan_chip_stop(dev); 839 840 free_irq(dev->irq, dev); 841 clk_disable(priv->clk); 842 843 close_candev(dev); 844 845 return 0; 846} 847 848static int flexcan_set_mode(struct net_device *dev, enum can_mode mode) 849{ 850 int err; 851 852 switch (mode) { 853 case CAN_MODE_START: 854 err = flexcan_chip_start(dev); 855 if (err) 856 return err; 857 858 netif_wake_queue(dev); 859 break; 860 861 default: 862 return -EOPNOTSUPP; 863 } 864 865 return 0; 866} 867 868static const struct net_device_ops flexcan_netdev_ops = { 869 .ndo_open = flexcan_open, 870 .ndo_stop = flexcan_close, 871 .ndo_start_xmit = flexcan_start_xmit, 872}; 873 874static int __devinit register_flexcandev(struct net_device *dev) 875{ 876 struct flexcan_priv *priv = netdev_priv(dev); 877 struct flexcan_regs __iomem *regs = priv->base; 878 u32 reg, err; 879 880 clk_enable(priv->clk); 881 882 /* select "bus clock", chip must be disabled */ 883 flexcan_chip_disable(priv); 884 reg = flexcan_read(®s->ctrl); 885 reg |= FLEXCAN_CTRL_CLK_SRC; 886 flexcan_write(reg, ®s->ctrl); 887 888 flexcan_chip_enable(priv); 889 890 /* set freeze, halt and activate FIFO, restrict register access */ 891 reg = flexcan_read(®s->mcr); 892 reg |= FLEXCAN_MCR_FRZ | FLEXCAN_MCR_HALT | 893 FLEXCAN_MCR_FEN | FLEXCAN_MCR_SUPV; 894 flexcan_write(reg, ®s->mcr); 895 896 /* 897 * Currently we only support newer versions of this core 898 * featuring a RX FIFO. Older cores found on some Coldfire 899 * derivates are not yet supported. 900 */ 901 reg = flexcan_read(®s->mcr); 902 if (!(reg & FLEXCAN_MCR_FEN)) { 903 dev_err(dev->dev.parent, 904 "Could not enable RX FIFO, unsupported core\n"); 905 err = -ENODEV; 906 goto out; 907 } 908 909 err = register_candev(dev); 910 911 out: 912 /* disable core and turn off clocks */ 913 flexcan_chip_disable(priv); 914 clk_disable(priv->clk); 915 916 return err; 917} 918 919static void __devexit unregister_flexcandev(struct net_device *dev) 920{ 921 unregister_candev(dev); 922} 923 924static int __devinit flexcan_probe(struct platform_device *pdev) 925{ 926 struct net_device *dev; 927 struct flexcan_priv *priv; 928 struct resource *mem; 929 struct clk *clk = NULL; 930 void __iomem *base; 931 resource_size_t mem_size; 932 int err, irq; 933 u32 clock_freq = 0; 934 935 if (pdev->dev.of_node) { 936 const u32 *clock_freq_p; 937 938 clock_freq_p = of_get_property(pdev->dev.of_node, 939 "clock-frequency", NULL); 940 if (clock_freq_p) 941 clock_freq = *clock_freq_p; 942 } 943 944 if (!clock_freq) { 945 clk = clk_get(&pdev->dev, NULL); 946 if (IS_ERR(clk)) { 947 dev_err(&pdev->dev, "no clock defined\n"); 948 err = PTR_ERR(clk); 949 goto failed_clock; 950 } 951 clock_freq = clk_get_rate(clk); 952 } 953 954 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 955 irq = platform_get_irq(pdev, 0); 956 if (!mem || irq <= 0) { 957 err = -ENODEV; 958 goto failed_get; 959 } 960 961 mem_size = resource_size(mem); 962 if (!request_mem_region(mem->start, mem_size, pdev->name)) { 963 err = -EBUSY; 964 goto failed_get; 965 } 966 967 base = ioremap(mem->start, mem_size); 968 if (!base) { 969 err = -ENOMEM; 970 goto failed_map; 971 } 972 973 dev = alloc_candev(sizeof(struct flexcan_priv), 0); 974 if (!dev) { 975 err = -ENOMEM; 976 goto failed_alloc; 977 } 978 979 dev->netdev_ops = &flexcan_netdev_ops; 980 dev->irq = irq; 981 dev->flags |= IFF_ECHO; /* we support local echo in hardware */ 982 983 priv = netdev_priv(dev); 984 priv->can.clock.freq = clock_freq; 985 priv->can.bittiming_const = &flexcan_bittiming_const; 986 priv->can.do_set_mode = flexcan_set_mode; 987 priv->can.do_get_berr_counter = flexcan_get_berr_counter; 988 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | 989 CAN_CTRLMODE_LISTENONLY | CAN_CTRLMODE_3_SAMPLES | 990 CAN_CTRLMODE_BERR_REPORTING; 991 priv->base = base; 992 priv->dev = dev; 993 priv->clk = clk; 994 priv->pdata = pdev->dev.platform_data; 995 996 netif_napi_add(dev, &priv->napi, flexcan_poll, FLEXCAN_NAPI_WEIGHT); 997 998 dev_set_drvdata(&pdev->dev, dev); 999 SET_NETDEV_DEV(dev, &pdev->dev); 1000 1001 err = register_flexcandev(dev); 1002 if (err) { 1003 dev_err(&pdev->dev, "registering netdev failed\n"); 1004 goto failed_register; 1005 } 1006 1007 dev_info(&pdev->dev, "device registered (reg_base=%p, irq=%d)\n", 1008 priv->base, dev->irq); 1009 1010 return 0; 1011 1012 failed_register: 1013 free_candev(dev); 1014 failed_alloc: 1015 iounmap(base); 1016 failed_map: 1017 release_mem_region(mem->start, mem_size); 1018 failed_get: 1019 if (clk) 1020 clk_put(clk); 1021 failed_clock: 1022 return err; 1023} 1024 1025static int __devexit flexcan_remove(struct platform_device *pdev) 1026{ 1027 struct net_device *dev = platform_get_drvdata(pdev); 1028 struct flexcan_priv *priv = netdev_priv(dev); 1029 struct resource *mem; 1030 1031 unregister_flexcandev(dev); 1032 platform_set_drvdata(pdev, NULL); 1033 iounmap(priv->base); 1034 1035 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1036 release_mem_region(mem->start, resource_size(mem)); 1037 1038 if (priv->clk) 1039 clk_put(priv->clk); 1040 1041 free_candev(dev); 1042 1043 return 0; 1044} 1045 1046static struct of_device_id flexcan_of_match[] = { 1047 { 1048 .compatible = "fsl,p1010-flexcan", 1049 }, 1050 {}, 1051}; 1052 1053static struct platform_driver flexcan_driver = { 1054 .driver = { 1055 .name = DRV_NAME, 1056 .owner = THIS_MODULE, 1057 .of_match_table = flexcan_of_match, 1058 }, 1059 .probe = flexcan_probe, 1060 .remove = __devexit_p(flexcan_remove), 1061}; 1062 1063module_platform_driver(flexcan_driver); 1064 1065MODULE_AUTHOR("Sascha Hauer <kernel@pengutronix.de>, " 1066 "Marc Kleine-Budde <kernel@pengutronix.de>"); 1067MODULE_LICENSE("GPL v2"); 1068MODULE_DESCRIPTION("CAN port driver for flexcan based chip"); 1069