1044 lines · c
1/*2 * CAN bus driver for IFI CANFD controller3 *4 * Copyright (C) 2016 Marek Vasut <marex@denx.de>5 *6 * Details about this controller can be found at7 * http://www.ifi-pld.de/IP/CANFD/canfd.html8 *9 * This file is licensed under the terms of the GNU General Public10 * License version 2. This program is licensed "as is" without any11 * warranty of any kind, whether express or implied.12 */13 14#include <linux/clk.h>15#include <linux/delay.h>16#include <linux/ethtool.h>17#include <linux/interrupt.h>18#include <linux/io.h>19#include <linux/kernel.h>20#include <linux/module.h>21#include <linux/netdevice.h>22#include <linux/of.h>23#include <linux/platform_device.h>24 25#include <linux/can/dev.h>26 27#define IFI_CANFD_STCMD 0x028#define IFI_CANFD_STCMD_HARDRESET 0xDEADCAFD29#define IFI_CANFD_STCMD_ENABLE BIT(0)30#define IFI_CANFD_STCMD_ERROR_ACTIVE BIT(2)31#define IFI_CANFD_STCMD_ERROR_PASSIVE BIT(3)32#define IFI_CANFD_STCMD_BUSOFF BIT(4)33#define IFI_CANFD_STCMD_ERROR_WARNING BIT(5)34#define IFI_CANFD_STCMD_BUSMONITOR BIT(16)35#define IFI_CANFD_STCMD_LOOPBACK BIT(18)36#define IFI_CANFD_STCMD_DISABLE_CANFD BIT(24)37#define IFI_CANFD_STCMD_ENABLE_ISO BIT(25)38#define IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING BIT(26)39#define IFI_CANFD_STCMD_NORMAL_MODE ((u32)BIT(31))40 41#define IFI_CANFD_RXSTCMD 0x442#define IFI_CANFD_RXSTCMD_REMOVE_MSG BIT(0)43#define IFI_CANFD_RXSTCMD_RESET BIT(7)44#define IFI_CANFD_RXSTCMD_EMPTY BIT(8)45#define IFI_CANFD_RXSTCMD_OVERFLOW BIT(13)46 47#define IFI_CANFD_TXSTCMD 0x848#define IFI_CANFD_TXSTCMD_ADD_MSG BIT(0)49#define IFI_CANFD_TXSTCMD_HIGH_PRIO BIT(1)50#define IFI_CANFD_TXSTCMD_RESET BIT(7)51#define IFI_CANFD_TXSTCMD_EMPTY BIT(8)52#define IFI_CANFD_TXSTCMD_FULL BIT(12)53#define IFI_CANFD_TXSTCMD_OVERFLOW BIT(13)54 55#define IFI_CANFD_INTERRUPT 0xc56#define IFI_CANFD_INTERRUPT_ERROR_BUSOFF BIT(0)57#define IFI_CANFD_INTERRUPT_ERROR_WARNING BIT(1)58#define IFI_CANFD_INTERRUPT_ERROR_STATE_CHG BIT(2)59#define IFI_CANFD_INTERRUPT_ERROR_REC_TEC_INC BIT(3)60#define IFI_CANFD_INTERRUPT_ERROR_COUNTER BIT(10)61#define IFI_CANFD_INTERRUPT_TXFIFO_EMPTY BIT(16)62#define IFI_CANFD_INTERRUPT_TXFIFO_REMOVE BIT(22)63#define IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY BIT(24)64#define IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER BIT(25)65#define IFI_CANFD_INTERRUPT_SET_IRQ ((u32)BIT(31))66 67#define IFI_CANFD_IRQMASK 0x1068#define IFI_CANFD_IRQMASK_ERROR_BUSOFF BIT(0)69#define IFI_CANFD_IRQMASK_ERROR_WARNING BIT(1)70#define IFI_CANFD_IRQMASK_ERROR_STATE_CHG BIT(2)71#define IFI_CANFD_IRQMASK_ERROR_REC_TEC_INC BIT(3)72#define IFI_CANFD_IRQMASK_SET_ERR BIT(7)73#define IFI_CANFD_IRQMASK_SET_TS BIT(15)74#define IFI_CANFD_IRQMASK_TXFIFO_EMPTY BIT(16)75#define IFI_CANFD_IRQMASK_SET_TX BIT(23)76#define IFI_CANFD_IRQMASK_RXFIFO_NEMPTY BIT(24)77#define IFI_CANFD_IRQMASK_SET_RX ((u32)BIT(31))78 79#define IFI_CANFD_TIME 0x1480#define IFI_CANFD_FTIME 0x1881#define IFI_CANFD_TIME_TIMEB_OFF 082#define IFI_CANFD_TIME_TIMEA_OFF 883#define IFI_CANFD_TIME_PRESCALE_OFF 1684#define IFI_CANFD_TIME_SJW_OFF_7_9_8_8 2585#define IFI_CANFD_TIME_SJW_OFF_4_12_6_6 2886#define IFI_CANFD_TIME_SET_SJW_4_12_6_6 BIT(6)87#define IFI_CANFD_TIME_SET_TIMEB_4_12_6_6 BIT(7)88#define IFI_CANFD_TIME_SET_PRESC_4_12_6_6 BIT(14)89#define IFI_CANFD_TIME_SET_TIMEA_4_12_6_6 BIT(15)90 91#define IFI_CANFD_TDELAY 0x1c92#define IFI_CANFD_TDELAY_DEFAULT 0xb93#define IFI_CANFD_TDELAY_MASK 0x3fff94#define IFI_CANFD_TDELAY_ABS BIT(14)95#define IFI_CANFD_TDELAY_EN BIT(15)96 97#define IFI_CANFD_ERROR 0x2098#define IFI_CANFD_ERROR_TX_OFFSET 099#define IFI_CANFD_ERROR_TX_MASK 0xff100#define IFI_CANFD_ERROR_RX_OFFSET 16101#define IFI_CANFD_ERROR_RX_MASK 0xff102 103#define IFI_CANFD_ERRCNT 0x24104 105#define IFI_CANFD_SUSPEND 0x28106 107#define IFI_CANFD_REPEAT 0x2c108 109#define IFI_CANFD_TRAFFIC 0x30110 111#define IFI_CANFD_TSCONTROL 0x34112 113#define IFI_CANFD_TSC 0x38114 115#define IFI_CANFD_TST 0x3c116 117#define IFI_CANFD_RES1 0x40118 119#define IFI_CANFD_ERROR_CTR 0x44120#define IFI_CANFD_ERROR_CTR_UNLOCK_MAGIC 0x21302899121#define IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST BIT(0)122#define IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST BIT(1)123#define IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST BIT(2)124#define IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST BIT(3)125#define IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST BIT(4)126#define IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST BIT(5)127#define IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST BIT(6)128#define IFI_CANFD_ERROR_CTR_OVERLOAD_ALL BIT(8)129#define IFI_CANFD_ERROR_CTR_ACK_ERROR_ALL BIT(9)130#define IFI_CANFD_ERROR_CTR_BIT0_ERROR_ALL BIT(10)131#define IFI_CANFD_ERROR_CTR_BIT1_ERROR_ALL BIT(11)132#define IFI_CANFD_ERROR_CTR_STUFF_ERROR_ALL BIT(12)133#define IFI_CANFD_ERROR_CTR_CRC_ERROR_ALL BIT(13)134#define IFI_CANFD_ERROR_CTR_FORM_ERROR_ALL BIT(14)135#define IFI_CANFD_ERROR_CTR_BITPOSITION_OFFSET 16136#define IFI_CANFD_ERROR_CTR_BITPOSITION_MASK 0xff137#define IFI_CANFD_ERROR_CTR_ER_RESET BIT(30)138#define IFI_CANFD_ERROR_CTR_ER_ENABLE ((u32)BIT(31))139 140#define IFI_CANFD_PAR 0x48141 142#define IFI_CANFD_CANCLOCK 0x4c143 144#define IFI_CANFD_SYSCLOCK 0x50145 146#define IFI_CANFD_VER 0x54147#define IFI_CANFD_VER_REV_MASK 0xff148#define IFI_CANFD_VER_REV_MIN_SUPPORTED 0x15149 150#define IFI_CANFD_IP_ID 0x58151#define IFI_CANFD_IP_ID_VALUE 0xD073CAFD152 153#define IFI_CANFD_TEST 0x5c154 155#define IFI_CANFD_RXFIFO_TS_63_32 0x60156 157#define IFI_CANFD_RXFIFO_TS_31_0 0x64158 159#define IFI_CANFD_RXFIFO_DLC 0x68160#define IFI_CANFD_RXFIFO_DLC_DLC_OFFSET 0161#define IFI_CANFD_RXFIFO_DLC_DLC_MASK 0xf162#define IFI_CANFD_RXFIFO_DLC_RTR BIT(4)163#define IFI_CANFD_RXFIFO_DLC_EDL BIT(5)164#define IFI_CANFD_RXFIFO_DLC_BRS BIT(6)165#define IFI_CANFD_RXFIFO_DLC_ESI BIT(7)166#define IFI_CANFD_RXFIFO_DLC_OBJ_OFFSET 8167#define IFI_CANFD_RXFIFO_DLC_OBJ_MASK 0x1ff168#define IFI_CANFD_RXFIFO_DLC_FNR_OFFSET 24169#define IFI_CANFD_RXFIFO_DLC_FNR_MASK 0xff170 171#define IFI_CANFD_RXFIFO_ID 0x6c172#define IFI_CANFD_RXFIFO_ID_ID_OFFSET 0173#define IFI_CANFD_RXFIFO_ID_ID_STD_MASK CAN_SFF_MASK174#define IFI_CANFD_RXFIFO_ID_ID_STD_OFFSET 0175#define IFI_CANFD_RXFIFO_ID_ID_STD_WIDTH 10176#define IFI_CANFD_RXFIFO_ID_ID_XTD_MASK CAN_EFF_MASK177#define IFI_CANFD_RXFIFO_ID_ID_XTD_OFFSET 11178#define IFI_CANFD_RXFIFO_ID_ID_XTD_WIDTH 18179#define IFI_CANFD_RXFIFO_ID_IDE BIT(29)180 181#define IFI_CANFD_RXFIFO_DATA 0x70 /* 0x70..0xac */182 183#define IFI_CANFD_TXFIFO_SUSPEND_US 0xb0184 185#define IFI_CANFD_TXFIFO_REPEATCOUNT 0xb4186 187#define IFI_CANFD_TXFIFO_DLC 0xb8188#define IFI_CANFD_TXFIFO_DLC_DLC_OFFSET 0189#define IFI_CANFD_TXFIFO_DLC_DLC_MASK 0xf190#define IFI_CANFD_TXFIFO_DLC_RTR BIT(4)191#define IFI_CANFD_TXFIFO_DLC_EDL BIT(5)192#define IFI_CANFD_TXFIFO_DLC_BRS BIT(6)193#define IFI_CANFD_TXFIFO_DLC_FNR_OFFSET 24194#define IFI_CANFD_TXFIFO_DLC_FNR_MASK 0xff195 196#define IFI_CANFD_TXFIFO_ID 0xbc197#define IFI_CANFD_TXFIFO_ID_ID_OFFSET 0198#define IFI_CANFD_TXFIFO_ID_ID_STD_MASK CAN_SFF_MASK199#define IFI_CANFD_TXFIFO_ID_ID_STD_OFFSET 0200#define IFI_CANFD_TXFIFO_ID_ID_STD_WIDTH 10201#define IFI_CANFD_TXFIFO_ID_ID_XTD_MASK CAN_EFF_MASK202#define IFI_CANFD_TXFIFO_ID_ID_XTD_OFFSET 11203#define IFI_CANFD_TXFIFO_ID_ID_XTD_WIDTH 18204#define IFI_CANFD_TXFIFO_ID_IDE BIT(29)205 206#define IFI_CANFD_TXFIFO_DATA 0xc0 /* 0xb0..0xfc */207 208#define IFI_CANFD_FILTER_MASK(n) (0x800 + ((n) * 8) + 0)209#define IFI_CANFD_FILTER_MASK_EXT BIT(29)210#define IFI_CANFD_FILTER_MASK_EDL BIT(30)211#define IFI_CANFD_FILTER_MASK_VALID ((u32)BIT(31))212 213#define IFI_CANFD_FILTER_IDENT(n) (0x800 + ((n) * 8) + 4)214#define IFI_CANFD_FILTER_IDENT_IDE BIT(29)215#define IFI_CANFD_FILTER_IDENT_CANFD BIT(30)216#define IFI_CANFD_FILTER_IDENT_VALID ((u32)BIT(31))217 218/* IFI CANFD private data structure */219struct ifi_canfd_priv {220 struct can_priv can; /* must be the first member */221 struct napi_struct napi;222 struct net_device *ndev;223 void __iomem *base;224};225 226static void ifi_canfd_irq_enable(struct net_device *ndev, bool enable)227{228 struct ifi_canfd_priv *priv = netdev_priv(ndev);229 u32 enirq = 0;230 231 if (enable) {232 enirq = IFI_CANFD_IRQMASK_TXFIFO_EMPTY |233 IFI_CANFD_IRQMASK_RXFIFO_NEMPTY |234 IFI_CANFD_IRQMASK_ERROR_STATE_CHG |235 IFI_CANFD_IRQMASK_ERROR_WARNING |236 IFI_CANFD_IRQMASK_ERROR_BUSOFF;237 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)238 enirq |= IFI_CANFD_INTERRUPT_ERROR_COUNTER;239 }240 241 writel(IFI_CANFD_IRQMASK_SET_ERR |242 IFI_CANFD_IRQMASK_SET_TS |243 IFI_CANFD_IRQMASK_SET_TX |244 IFI_CANFD_IRQMASK_SET_RX | enirq,245 priv->base + IFI_CANFD_IRQMASK);246}247 248static void ifi_canfd_read_fifo(struct net_device *ndev)249{250 struct net_device_stats *stats = &ndev->stats;251 struct ifi_canfd_priv *priv = netdev_priv(ndev);252 struct canfd_frame *cf;253 struct sk_buff *skb;254 const u32 rx_irq_mask = IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY |255 IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER;256 u32 rxdlc, rxid;257 u32 dlc, id;258 int i;259 260 rxdlc = readl(priv->base + IFI_CANFD_RXFIFO_DLC);261 if (rxdlc & IFI_CANFD_RXFIFO_DLC_EDL)262 skb = alloc_canfd_skb(ndev, &cf);263 else264 skb = alloc_can_skb(ndev, (struct can_frame **)&cf);265 266 if (!skb) {267 stats->rx_dropped++;268 return;269 }270 271 dlc = (rxdlc >> IFI_CANFD_RXFIFO_DLC_DLC_OFFSET) &272 IFI_CANFD_RXFIFO_DLC_DLC_MASK;273 if (rxdlc & IFI_CANFD_RXFIFO_DLC_EDL)274 cf->len = can_fd_dlc2len(dlc);275 else276 cf->len = can_cc_dlc2len(dlc);277 278 rxid = readl(priv->base + IFI_CANFD_RXFIFO_ID);279 id = (rxid >> IFI_CANFD_RXFIFO_ID_ID_OFFSET);280 if (id & IFI_CANFD_RXFIFO_ID_IDE) {281 id &= IFI_CANFD_RXFIFO_ID_ID_XTD_MASK;282 /*283 * In case the Extended ID frame is received, the standard284 * and extended part of the ID are swapped in the register,285 * so swap them back to obtain the correct ID.286 */287 id = (id >> IFI_CANFD_RXFIFO_ID_ID_XTD_OFFSET) |288 ((id & IFI_CANFD_RXFIFO_ID_ID_STD_MASK) <<289 IFI_CANFD_RXFIFO_ID_ID_XTD_WIDTH);290 id |= CAN_EFF_FLAG;291 } else {292 id &= IFI_CANFD_RXFIFO_ID_ID_STD_MASK;293 }294 cf->can_id = id;295 296 if (rxdlc & IFI_CANFD_RXFIFO_DLC_ESI) {297 cf->flags |= CANFD_ESI;298 netdev_dbg(ndev, "ESI Error\n");299 }300 301 if (!(rxdlc & IFI_CANFD_RXFIFO_DLC_EDL) &&302 (rxdlc & IFI_CANFD_RXFIFO_DLC_RTR)) {303 cf->can_id |= CAN_RTR_FLAG;304 } else {305 if (rxdlc & IFI_CANFD_RXFIFO_DLC_BRS)306 cf->flags |= CANFD_BRS;307 308 for (i = 0; i < cf->len; i += 4) {309 *(u32 *)(cf->data + i) =310 readl(priv->base + IFI_CANFD_RXFIFO_DATA + i);311 }312 313 stats->rx_bytes += cf->len;314 }315 stats->rx_packets++;316 317 /* Remove the packet from FIFO */318 writel(IFI_CANFD_RXSTCMD_REMOVE_MSG, priv->base + IFI_CANFD_RXSTCMD);319 writel(rx_irq_mask, priv->base + IFI_CANFD_INTERRUPT);320 321 netif_receive_skb(skb);322}323 324static int ifi_canfd_do_rx_poll(struct net_device *ndev, int quota)325{326 struct ifi_canfd_priv *priv = netdev_priv(ndev);327 u32 pkts = 0;328 u32 rxst;329 330 rxst = readl(priv->base + IFI_CANFD_RXSTCMD);331 if (rxst & IFI_CANFD_RXSTCMD_EMPTY) {332 netdev_dbg(ndev, "No messages in RX FIFO\n");333 return 0;334 }335 336 for (;;) {337 if (rxst & IFI_CANFD_RXSTCMD_EMPTY)338 break;339 if (quota <= 0)340 break;341 342 ifi_canfd_read_fifo(ndev);343 quota--;344 pkts++;345 rxst = readl(priv->base + IFI_CANFD_RXSTCMD);346 }347 348 return pkts;349}350 351static int ifi_canfd_handle_lost_msg(struct net_device *ndev)352{353 struct net_device_stats *stats = &ndev->stats;354 struct sk_buff *skb;355 struct can_frame *frame;356 357 netdev_err(ndev, "RX FIFO overflow, message(s) lost.\n");358 359 stats->rx_errors++;360 stats->rx_over_errors++;361 362 skb = alloc_can_err_skb(ndev, &frame);363 if (unlikely(!skb))364 return 0;365 366 frame->can_id |= CAN_ERR_CRTL;367 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;368 369 netif_receive_skb(skb);370 371 return 1;372}373 374static int ifi_canfd_handle_lec_err(struct net_device *ndev)375{376 struct ifi_canfd_priv *priv = netdev_priv(ndev);377 struct net_device_stats *stats = &ndev->stats;378 struct can_frame *cf;379 struct sk_buff *skb;380 u32 errctr = readl(priv->base + IFI_CANFD_ERROR_CTR);381 const u32 errmask = IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST |382 IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST |383 IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST |384 IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST |385 IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST |386 IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST |387 IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST;388 389 if (!(errctr & errmask)) /* No error happened. */390 return 0;391 392 priv->can.can_stats.bus_error++;393 stats->rx_errors++;394 395 /* Propagate the error condition to the CAN stack. */396 skb = alloc_can_err_skb(ndev, &cf);397 if (unlikely(!skb))398 return 0;399 400 /* Read the error counter register and check for new errors. */401 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;402 403 if (errctr & IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST)404 cf->data[2] |= CAN_ERR_PROT_OVERLOAD;405 406 if (errctr & IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST)407 cf->data[3] = CAN_ERR_PROT_LOC_ACK;408 409 if (errctr & IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST)410 cf->data[2] |= CAN_ERR_PROT_BIT0;411 412 if (errctr & IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST)413 cf->data[2] |= CAN_ERR_PROT_BIT1;414 415 if (errctr & IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST)416 cf->data[2] |= CAN_ERR_PROT_STUFF;417 418 if (errctr & IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST)419 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;420 421 if (errctr & IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST)422 cf->data[2] |= CAN_ERR_PROT_FORM;423 424 /* Reset the error counter, ack the IRQ and re-enable the counter. */425 writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR);426 writel(IFI_CANFD_INTERRUPT_ERROR_COUNTER,427 priv->base + IFI_CANFD_INTERRUPT);428 writel(IFI_CANFD_ERROR_CTR_ER_ENABLE, priv->base + IFI_CANFD_ERROR_CTR);429 430 netif_receive_skb(skb);431 432 return 1;433}434 435static int ifi_canfd_get_berr_counter(const struct net_device *ndev,436 struct can_berr_counter *bec)437{438 struct ifi_canfd_priv *priv = netdev_priv(ndev);439 u32 err;440 441 err = readl(priv->base + IFI_CANFD_ERROR);442 bec->rxerr = (err >> IFI_CANFD_ERROR_RX_OFFSET) &443 IFI_CANFD_ERROR_RX_MASK;444 bec->txerr = (err >> IFI_CANFD_ERROR_TX_OFFSET) &445 IFI_CANFD_ERROR_TX_MASK;446 447 return 0;448}449 450static int ifi_canfd_handle_state_change(struct net_device *ndev,451 enum can_state new_state)452{453 struct ifi_canfd_priv *priv = netdev_priv(ndev);454 struct can_frame *cf;455 struct sk_buff *skb;456 struct can_berr_counter bec;457 458 switch (new_state) {459 case CAN_STATE_ERROR_ACTIVE:460 /* error active state */461 priv->can.can_stats.error_warning++;462 priv->can.state = CAN_STATE_ERROR_ACTIVE;463 break;464 case CAN_STATE_ERROR_WARNING:465 /* error warning state */466 priv->can.can_stats.error_warning++;467 priv->can.state = CAN_STATE_ERROR_WARNING;468 break;469 case CAN_STATE_ERROR_PASSIVE:470 /* error passive state */471 priv->can.can_stats.error_passive++;472 priv->can.state = CAN_STATE_ERROR_PASSIVE;473 break;474 case CAN_STATE_BUS_OFF:475 /* bus-off state */476 priv->can.state = CAN_STATE_BUS_OFF;477 ifi_canfd_irq_enable(ndev, 0);478 priv->can.can_stats.bus_off++;479 can_bus_off(ndev);480 break;481 default:482 break;483 }484 485 /* propagate the error condition to the CAN stack */486 skb = alloc_can_err_skb(ndev, &cf);487 if (unlikely(!skb))488 return 0;489 490 ifi_canfd_get_berr_counter(ndev, &bec);491 492 switch (new_state) {493 case CAN_STATE_ERROR_WARNING:494 /* error warning state */495 cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT;496 cf->data[1] = (bec.txerr > bec.rxerr) ?497 CAN_ERR_CRTL_TX_WARNING :498 CAN_ERR_CRTL_RX_WARNING;499 cf->data[6] = bec.txerr;500 cf->data[7] = bec.rxerr;501 break;502 case CAN_STATE_ERROR_PASSIVE:503 /* error passive state */504 cf->can_id |= CAN_ERR_CRTL | CAN_ERR_CNT;505 cf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE;506 if (bec.txerr > 127)507 cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE;508 cf->data[6] = bec.txerr;509 cf->data[7] = bec.rxerr;510 break;511 case CAN_STATE_BUS_OFF:512 /* bus-off state */513 cf->can_id |= CAN_ERR_BUSOFF;514 break;515 default:516 break;517 }518 519 netif_receive_skb(skb);520 521 return 1;522}523 524static int ifi_canfd_handle_state_errors(struct net_device *ndev)525{526 struct ifi_canfd_priv *priv = netdev_priv(ndev);527 u32 stcmd = readl(priv->base + IFI_CANFD_STCMD);528 int work_done = 0;529 530 if ((stcmd & IFI_CANFD_STCMD_ERROR_ACTIVE) &&531 (priv->can.state != CAN_STATE_ERROR_ACTIVE)) {532 netdev_dbg(ndev, "Error, entered active state\n");533 work_done += ifi_canfd_handle_state_change(ndev,534 CAN_STATE_ERROR_ACTIVE);535 }536 537 if ((stcmd & IFI_CANFD_STCMD_ERROR_WARNING) &&538 (priv->can.state != CAN_STATE_ERROR_WARNING)) {539 netdev_dbg(ndev, "Error, entered warning state\n");540 work_done += ifi_canfd_handle_state_change(ndev,541 CAN_STATE_ERROR_WARNING);542 }543 544 if ((stcmd & IFI_CANFD_STCMD_ERROR_PASSIVE) &&545 (priv->can.state != CAN_STATE_ERROR_PASSIVE)) {546 netdev_dbg(ndev, "Error, entered passive state\n");547 work_done += ifi_canfd_handle_state_change(ndev,548 CAN_STATE_ERROR_PASSIVE);549 }550 551 if ((stcmd & IFI_CANFD_STCMD_BUSOFF) &&552 (priv->can.state != CAN_STATE_BUS_OFF)) {553 netdev_dbg(ndev, "Error, entered bus-off state\n");554 work_done += ifi_canfd_handle_state_change(ndev,555 CAN_STATE_BUS_OFF);556 }557 558 return work_done;559}560 561static int ifi_canfd_poll(struct napi_struct *napi, int quota)562{563 struct net_device *ndev = napi->dev;564 struct ifi_canfd_priv *priv = netdev_priv(ndev);565 u32 rxstcmd = readl(priv->base + IFI_CANFD_RXSTCMD);566 int work_done = 0;567 568 /* Handle bus state changes */569 work_done += ifi_canfd_handle_state_errors(ndev);570 571 /* Handle lost messages on RX */572 if (rxstcmd & IFI_CANFD_RXSTCMD_OVERFLOW)573 work_done += ifi_canfd_handle_lost_msg(ndev);574 575 /* Handle lec errors on the bus */576 if (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)577 work_done += ifi_canfd_handle_lec_err(ndev);578 579 /* Handle normal messages on RX */580 if (!(rxstcmd & IFI_CANFD_RXSTCMD_EMPTY))581 work_done += ifi_canfd_do_rx_poll(ndev, quota - work_done);582 583 if (work_done < quota) {584 napi_complete_done(napi, work_done);585 ifi_canfd_irq_enable(ndev, 1);586 }587 588 return work_done;589}590 591static irqreturn_t ifi_canfd_isr(int irq, void *dev_id)592{593 struct net_device *ndev = (struct net_device *)dev_id;594 struct ifi_canfd_priv *priv = netdev_priv(ndev);595 struct net_device_stats *stats = &ndev->stats;596 const u32 rx_irq_mask = IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY |597 IFI_CANFD_INTERRUPT_RXFIFO_NEMPTY_PER |598 IFI_CANFD_INTERRUPT_ERROR_COUNTER |599 IFI_CANFD_INTERRUPT_ERROR_STATE_CHG |600 IFI_CANFD_INTERRUPT_ERROR_WARNING |601 IFI_CANFD_INTERRUPT_ERROR_BUSOFF;602 const u32 tx_irq_mask = IFI_CANFD_INTERRUPT_TXFIFO_EMPTY |603 IFI_CANFD_INTERRUPT_TXFIFO_REMOVE;604 const u32 clr_irq_mask = ~((u32)IFI_CANFD_INTERRUPT_SET_IRQ);605 u32 isr;606 607 isr = readl(priv->base + IFI_CANFD_INTERRUPT);608 609 /* No interrupt */610 if (isr == 0)611 return IRQ_NONE;612 613 /* Clear all pending interrupts but ErrWarn */614 writel(clr_irq_mask, priv->base + IFI_CANFD_INTERRUPT);615 616 /* RX IRQ or bus warning, start NAPI */617 if (isr & rx_irq_mask) {618 ifi_canfd_irq_enable(ndev, 0);619 napi_schedule(&priv->napi);620 }621 622 /* TX IRQ */623 if (isr & IFI_CANFD_INTERRUPT_TXFIFO_REMOVE) {624 stats->tx_bytes += can_get_echo_skb(ndev, 0, NULL);625 stats->tx_packets++;626 }627 628 if (isr & tx_irq_mask)629 netif_wake_queue(ndev);630 631 return IRQ_HANDLED;632}633 634static const struct can_bittiming_const ifi_canfd_bittiming_const = {635 .name = KBUILD_MODNAME,636 .tseg1_min = 1, /* Time segment 1 = prop_seg + phase_seg1 */637 .tseg1_max = 256,638 .tseg2_min = 2, /* Time segment 2 = phase_seg2 */639 .tseg2_max = 256,640 .sjw_max = 128,641 .brp_min = 2,642 .brp_max = 512,643 .brp_inc = 1,644};645 646static void ifi_canfd_set_bittiming(struct net_device *ndev)647{648 struct ifi_canfd_priv *priv = netdev_priv(ndev);649 const struct can_bittiming *bt = &priv->can.bittiming;650 const struct can_bittiming *dbt = &priv->can.data_bittiming;651 u16 brp, sjw, tseg1, tseg2, tdc;652 653 /* Configure bit timing */654 brp = bt->brp - 2;655 sjw = bt->sjw - 1;656 tseg1 = bt->prop_seg + bt->phase_seg1 - 1;657 tseg2 = bt->phase_seg2 - 2;658 writel((tseg2 << IFI_CANFD_TIME_TIMEB_OFF) |659 (tseg1 << IFI_CANFD_TIME_TIMEA_OFF) |660 (brp << IFI_CANFD_TIME_PRESCALE_OFF) |661 (sjw << IFI_CANFD_TIME_SJW_OFF_7_9_8_8),662 priv->base + IFI_CANFD_TIME);663 664 /* Configure data bit timing */665 brp = dbt->brp - 2;666 sjw = dbt->sjw - 1;667 tseg1 = dbt->prop_seg + dbt->phase_seg1 - 1;668 tseg2 = dbt->phase_seg2 - 2;669 writel((tseg2 << IFI_CANFD_TIME_TIMEB_OFF) |670 (tseg1 << IFI_CANFD_TIME_TIMEA_OFF) |671 (brp << IFI_CANFD_TIME_PRESCALE_OFF) |672 (sjw << IFI_CANFD_TIME_SJW_OFF_7_9_8_8),673 priv->base + IFI_CANFD_FTIME);674 675 /* Configure transmitter delay */676 tdc = dbt->brp * (dbt->prop_seg + dbt->phase_seg1);677 tdc &= IFI_CANFD_TDELAY_MASK;678 writel(IFI_CANFD_TDELAY_EN | tdc, priv->base + IFI_CANFD_TDELAY);679}680 681static void ifi_canfd_set_filter(struct net_device *ndev, const u32 id,682 const u32 mask, const u32 ident)683{684 struct ifi_canfd_priv *priv = netdev_priv(ndev);685 686 writel(mask, priv->base + IFI_CANFD_FILTER_MASK(id));687 writel(ident, priv->base + IFI_CANFD_FILTER_IDENT(id));688}689 690static void ifi_canfd_set_filters(struct net_device *ndev)691{692 /* Receive all CAN frames (standard ID) */693 ifi_canfd_set_filter(ndev, 0,694 IFI_CANFD_FILTER_MASK_VALID |695 IFI_CANFD_FILTER_MASK_EXT,696 IFI_CANFD_FILTER_IDENT_VALID);697 698 /* Receive all CAN frames (extended ID) */699 ifi_canfd_set_filter(ndev, 1,700 IFI_CANFD_FILTER_MASK_VALID |701 IFI_CANFD_FILTER_MASK_EXT,702 IFI_CANFD_FILTER_IDENT_VALID |703 IFI_CANFD_FILTER_IDENT_IDE);704 705 /* Receive all CANFD frames */706 ifi_canfd_set_filter(ndev, 2,707 IFI_CANFD_FILTER_MASK_VALID |708 IFI_CANFD_FILTER_MASK_EDL |709 IFI_CANFD_FILTER_MASK_EXT,710 IFI_CANFD_FILTER_IDENT_VALID |711 IFI_CANFD_FILTER_IDENT_CANFD |712 IFI_CANFD_FILTER_IDENT_IDE);713}714 715static void ifi_canfd_start(struct net_device *ndev)716{717 struct ifi_canfd_priv *priv = netdev_priv(ndev);718 u32 stcmd;719 720 /* Reset the IP */721 writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD);722 writel(IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING,723 priv->base + IFI_CANFD_STCMD);724 725 ifi_canfd_set_bittiming(ndev);726 ifi_canfd_set_filters(ndev);727 728 /* Reset FIFOs */729 writel(IFI_CANFD_RXSTCMD_RESET, priv->base + IFI_CANFD_RXSTCMD);730 writel(0, priv->base + IFI_CANFD_RXSTCMD);731 writel(IFI_CANFD_TXSTCMD_RESET, priv->base + IFI_CANFD_TXSTCMD);732 writel(0, priv->base + IFI_CANFD_TXSTCMD);733 734 /* Repeat transmission until successful */735 writel(0, priv->base + IFI_CANFD_REPEAT);736 writel(0, priv->base + IFI_CANFD_SUSPEND);737 738 /* Clear all pending interrupts */739 writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ),740 priv->base + IFI_CANFD_INTERRUPT);741 742 stcmd = IFI_CANFD_STCMD_ENABLE | IFI_CANFD_STCMD_NORMAL_MODE |743 IFI_CANFD_STCMD_ENABLE_7_9_8_8_TIMING;744 745 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)746 stcmd |= IFI_CANFD_STCMD_BUSMONITOR;747 748 if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)749 stcmd |= IFI_CANFD_STCMD_LOOPBACK;750 751 if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) &&752 !(priv->can.ctrlmode & CAN_CTRLMODE_FD_NON_ISO))753 stcmd |= IFI_CANFD_STCMD_ENABLE_ISO;754 755 if (!(priv->can.ctrlmode & CAN_CTRLMODE_FD))756 stcmd |= IFI_CANFD_STCMD_DISABLE_CANFD;757 758 priv->can.state = CAN_STATE_ERROR_ACTIVE;759 760 ifi_canfd_irq_enable(ndev, 1);761 762 /* Unlock, reset and enable the error counter. */763 writel(IFI_CANFD_ERROR_CTR_UNLOCK_MAGIC,764 priv->base + IFI_CANFD_ERROR_CTR);765 writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR);766 writel(IFI_CANFD_ERROR_CTR_ER_ENABLE, priv->base + IFI_CANFD_ERROR_CTR);767 768 /* Enable controller */769 writel(stcmd, priv->base + IFI_CANFD_STCMD);770}771 772static void ifi_canfd_stop(struct net_device *ndev)773{774 struct ifi_canfd_priv *priv = netdev_priv(ndev);775 776 /* Reset and disable the error counter. */777 writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR);778 writel(0, priv->base + IFI_CANFD_ERROR_CTR);779 780 /* Reset the IP */781 writel(IFI_CANFD_STCMD_HARDRESET, priv->base + IFI_CANFD_STCMD);782 783 /* Mask all interrupts */784 writel(~0, priv->base + IFI_CANFD_IRQMASK);785 786 /* Clear all pending interrupts */787 writel((u32)(~IFI_CANFD_INTERRUPT_SET_IRQ),788 priv->base + IFI_CANFD_INTERRUPT);789 790 /* Set the state as STOPPED */791 priv->can.state = CAN_STATE_STOPPED;792}793 794static int ifi_canfd_set_mode(struct net_device *ndev, enum can_mode mode)795{796 switch (mode) {797 case CAN_MODE_START:798 ifi_canfd_start(ndev);799 netif_wake_queue(ndev);800 break;801 default:802 return -EOPNOTSUPP;803 }804 805 return 0;806}807 808static int ifi_canfd_open(struct net_device *ndev)809{810 struct ifi_canfd_priv *priv = netdev_priv(ndev);811 int ret;812 813 ret = open_candev(ndev);814 if (ret) {815 netdev_err(ndev, "Failed to open CAN device\n");816 return ret;817 }818 819 /* Register interrupt handler */820 ret = request_irq(ndev->irq, ifi_canfd_isr, IRQF_SHARED,821 ndev->name, ndev);822 if (ret < 0) {823 netdev_err(ndev, "Failed to request interrupt\n");824 goto err_irq;825 }826 827 ifi_canfd_start(ndev);828 829 napi_enable(&priv->napi);830 netif_start_queue(ndev);831 832 return 0;833err_irq:834 close_candev(ndev);835 return ret;836}837 838static int ifi_canfd_close(struct net_device *ndev)839{840 struct ifi_canfd_priv *priv = netdev_priv(ndev);841 842 netif_stop_queue(ndev);843 napi_disable(&priv->napi);844 845 ifi_canfd_stop(ndev);846 847 free_irq(ndev->irq, ndev);848 849 close_candev(ndev);850 851 return 0;852}853 854static netdev_tx_t ifi_canfd_start_xmit(struct sk_buff *skb,855 struct net_device *ndev)856{857 struct ifi_canfd_priv *priv = netdev_priv(ndev);858 struct canfd_frame *cf = (struct canfd_frame *)skb->data;859 u32 txst, txid, txdlc;860 int i;861 862 if (can_dev_dropped_skb(ndev, skb))863 return NETDEV_TX_OK;864 865 /* Check if the TX buffer is full */866 txst = readl(priv->base + IFI_CANFD_TXSTCMD);867 if (txst & IFI_CANFD_TXSTCMD_FULL) {868 netif_stop_queue(ndev);869 netdev_err(ndev, "BUG! TX FIFO full when queue awake!\n");870 return NETDEV_TX_BUSY;871 }872 873 netif_stop_queue(ndev);874 875 if (cf->can_id & CAN_EFF_FLAG) {876 txid = cf->can_id & CAN_EFF_MASK;877 /*878 * In case the Extended ID frame is transmitted, the879 * standard and extended part of the ID are swapped880 * in the register, so swap them back to send the881 * correct ID.882 */883 txid = (txid >> IFI_CANFD_TXFIFO_ID_ID_XTD_WIDTH) |884 ((txid & IFI_CANFD_TXFIFO_ID_ID_XTD_MASK) <<885 IFI_CANFD_TXFIFO_ID_ID_XTD_OFFSET);886 txid |= IFI_CANFD_TXFIFO_ID_IDE;887 } else {888 txid = cf->can_id & CAN_SFF_MASK;889 }890 891 txdlc = can_fd_len2dlc(cf->len);892 if ((priv->can.ctrlmode & CAN_CTRLMODE_FD) && can_is_canfd_skb(skb)) {893 txdlc |= IFI_CANFD_TXFIFO_DLC_EDL;894 if (cf->flags & CANFD_BRS)895 txdlc |= IFI_CANFD_TXFIFO_DLC_BRS;896 }897 898 if (cf->can_id & CAN_RTR_FLAG)899 txdlc |= IFI_CANFD_TXFIFO_DLC_RTR;900 901 /* message ram configuration */902 writel(txid, priv->base + IFI_CANFD_TXFIFO_ID);903 writel(txdlc, priv->base + IFI_CANFD_TXFIFO_DLC);904 905 for (i = 0; i < cf->len; i += 4) {906 writel(*(u32 *)(cf->data + i),907 priv->base + IFI_CANFD_TXFIFO_DATA + i);908 }909 910 writel(0, priv->base + IFI_CANFD_TXFIFO_REPEATCOUNT);911 writel(0, priv->base + IFI_CANFD_TXFIFO_SUSPEND_US);912 913 can_put_echo_skb(skb, ndev, 0, 0);914 915 /* Start the transmission */916 writel(IFI_CANFD_TXSTCMD_ADD_MSG, priv->base + IFI_CANFD_TXSTCMD);917 918 return NETDEV_TX_OK;919}920 921static const struct net_device_ops ifi_canfd_netdev_ops = {922 .ndo_open = ifi_canfd_open,923 .ndo_stop = ifi_canfd_close,924 .ndo_start_xmit = ifi_canfd_start_xmit,925 .ndo_change_mtu = can_change_mtu,926};927 928static const struct ethtool_ops ifi_canfd_ethtool_ops = {929 .get_ts_info = ethtool_op_get_ts_info,930};931 932static int ifi_canfd_plat_probe(struct platform_device *pdev)933{934 struct device *dev = &pdev->dev;935 struct net_device *ndev;936 struct ifi_canfd_priv *priv;937 void __iomem *addr;938 int irq, ret;939 u32 id, rev;940 941 addr = devm_platform_ioremap_resource(pdev, 0);942 if (IS_ERR(addr))943 return PTR_ERR(addr);944 945 irq = platform_get_irq(pdev, 0);946 if (irq < 0)947 return -EINVAL;948 949 id = readl(addr + IFI_CANFD_IP_ID);950 if (id != IFI_CANFD_IP_ID_VALUE) {951 dev_err(dev, "This block is not IFI CANFD, id=%08x\n", id);952 return -EINVAL;953 }954 955 rev = readl(addr + IFI_CANFD_VER) & IFI_CANFD_VER_REV_MASK;956 if (rev < IFI_CANFD_VER_REV_MIN_SUPPORTED) {957 dev_err(dev, "This block is too old (rev %i), minimum supported is rev %i\n",958 rev, IFI_CANFD_VER_REV_MIN_SUPPORTED);959 return -EINVAL;960 }961 962 ndev = alloc_candev(sizeof(*priv), 1);963 if (!ndev)964 return -ENOMEM;965 966 ndev->irq = irq;967 ndev->flags |= IFF_ECHO; /* we support local echo */968 ndev->netdev_ops = &ifi_canfd_netdev_ops;969 ndev->ethtool_ops = &ifi_canfd_ethtool_ops;970 971 priv = netdev_priv(ndev);972 priv->ndev = ndev;973 priv->base = addr;974 975 netif_napi_add(ndev, &priv->napi, ifi_canfd_poll);976 977 priv->can.state = CAN_STATE_STOPPED;978 979 priv->can.clock.freq = readl(addr + IFI_CANFD_CANCLOCK);980 981 priv->can.bittiming_const = &ifi_canfd_bittiming_const;982 priv->can.data_bittiming_const = &ifi_canfd_bittiming_const;983 priv->can.do_set_mode = ifi_canfd_set_mode;984 priv->can.do_get_berr_counter = ifi_canfd_get_berr_counter;985 986 /* IFI CANFD can do both Bosch FD and ISO FD */987 priv->can.ctrlmode = CAN_CTRLMODE_FD;988 989 /* IFI CANFD can do both Bosch FD and ISO FD */990 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |991 CAN_CTRLMODE_LISTENONLY |992 CAN_CTRLMODE_FD |993 CAN_CTRLMODE_FD_NON_ISO |994 CAN_CTRLMODE_BERR_REPORTING;995 996 platform_set_drvdata(pdev, ndev);997 SET_NETDEV_DEV(ndev, dev);998 999 ret = register_candev(ndev);1000 if (ret) {1001 dev_err(dev, "Failed to register (ret=%d)\n", ret);1002 goto err_reg;1003 }1004 1005 dev_info(dev, "Driver registered: regs=%p, irq=%d, clock=%d\n",1006 priv->base, ndev->irq, priv->can.clock.freq);1007 1008 return 0;1009 1010err_reg:1011 free_candev(ndev);1012 return ret;1013}1014 1015static void ifi_canfd_plat_remove(struct platform_device *pdev)1016{1017 struct net_device *ndev = platform_get_drvdata(pdev);1018 1019 unregister_candev(ndev);1020 platform_set_drvdata(pdev, NULL);1021 free_candev(ndev);1022}1023 1024static const struct of_device_id ifi_canfd_of_table[] = {1025 { .compatible = "ifi,canfd-1.0", .data = NULL },1026 { /* sentinel */ },1027};1028MODULE_DEVICE_TABLE(of, ifi_canfd_of_table);1029 1030static struct platform_driver ifi_canfd_plat_driver = {1031 .driver = {1032 .name = KBUILD_MODNAME,1033 .of_match_table = ifi_canfd_of_table,1034 },1035 .probe = ifi_canfd_plat_probe,1036 .remove = ifi_canfd_plat_remove,1037};1038 1039module_platform_driver(ifi_canfd_plat_driver);1040 1041MODULE_AUTHOR("Marek Vasut <marex@denx.de>");1042MODULE_LICENSE("GPL v2");1043MODULE_DESCRIPTION("CAN bus driver for IFI CANFD controller");1044