1 /* Xilinx CAN device driver 2 * 3 * Copyright (C) 2012 - 2014 Xilinx, Inc. 4 * Copyright (C) 2009 PetaLogix. All rights reserved. 5 * 6 * Description: 7 * This driver is developed for Axi CAN IP and for Zynq CANPS Controller. 8 * This program is free software: you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation, either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 */ 18 19 #include <linux/clk.h> 20 #include <linux/errno.h> 21 #include <linux/init.h> 22 #include <linux/interrupt.h> 23 #include <linux/io.h> 24 #include <linux/kernel.h> 25 #include <linux/module.h> 26 #include <linux/netdevice.h> 27 #include <linux/of.h> 28 #include <linux/platform_device.h> 29 #include <linux/skbuff.h> 30 #include <linux/string.h> 31 #include <linux/types.h> 32 #include <linux/can/dev.h> 33 #include <linux/can/error.h> 34 #include <linux/can/led.h> 35 36 #define DRIVER_NAME "xilinx_can" 37 38 /* CAN registers set */ 39 enum xcan_reg { 40 XCAN_SRR_OFFSET = 0x00, /* Software reset */ 41 XCAN_MSR_OFFSET = 0x04, /* Mode select */ 42 XCAN_BRPR_OFFSET = 0x08, /* Baud rate prescaler */ 43 XCAN_BTR_OFFSET = 0x0C, /* Bit timing */ 44 XCAN_ECR_OFFSET = 0x10, /* Error counter */ 45 XCAN_ESR_OFFSET = 0x14, /* Error status */ 46 XCAN_SR_OFFSET = 0x18, /* Status */ 47 XCAN_ISR_OFFSET = 0x1C, /* Interrupt status */ 48 XCAN_IER_OFFSET = 0x20, /* Interrupt enable */ 49 XCAN_ICR_OFFSET = 0x24, /* Interrupt clear */ 50 XCAN_TXFIFO_ID_OFFSET = 0x30,/* TX FIFO ID */ 51 XCAN_TXFIFO_DLC_OFFSET = 0x34, /* TX FIFO DLC */ 52 XCAN_TXFIFO_DW1_OFFSET = 0x38, /* TX FIFO Data Word 1 */ 53 XCAN_TXFIFO_DW2_OFFSET = 0x3C, /* TX FIFO Data Word 2 */ 54 XCAN_RXFIFO_ID_OFFSET = 0x50, /* RX FIFO ID */ 55 XCAN_RXFIFO_DLC_OFFSET = 0x54, /* RX FIFO DLC */ 56 XCAN_RXFIFO_DW1_OFFSET = 0x58, /* RX FIFO Data Word 1 */ 57 XCAN_RXFIFO_DW2_OFFSET = 0x5C, /* RX FIFO Data Word 2 */ 58 }; 59 60 /* CAN register bit masks - XCAN_<REG>_<BIT>_MASK */ 61 #define XCAN_SRR_CEN_MASK 0x00000002 /* CAN enable */ 62 #define XCAN_SRR_RESET_MASK 0x00000001 /* Soft Reset the CAN core */ 63 #define XCAN_MSR_LBACK_MASK 0x00000002 /* Loop back mode select */ 64 #define XCAN_MSR_SLEEP_MASK 0x00000001 /* Sleep mode select */ 65 #define XCAN_BRPR_BRP_MASK 0x000000FF /* Baud rate prescaler */ 66 #define XCAN_BTR_SJW_MASK 0x00000180 /* Synchronous jump width */ 67 #define XCAN_BTR_TS2_MASK 0x00000070 /* Time segment 2 */ 68 #define XCAN_BTR_TS1_MASK 0x0000000F /* Time segment 1 */ 69 #define XCAN_ECR_REC_MASK 0x0000FF00 /* Receive error counter */ 70 #define XCAN_ECR_TEC_MASK 0x000000FF /* Transmit error counter */ 71 #define XCAN_ESR_ACKER_MASK 0x00000010 /* ACK error */ 72 #define XCAN_ESR_BERR_MASK 0x00000008 /* Bit error */ 73 #define XCAN_ESR_STER_MASK 0x00000004 /* Stuff error */ 74 #define XCAN_ESR_FMER_MASK 0x00000002 /* Form error */ 75 #define XCAN_ESR_CRCER_MASK 0x00000001 /* CRC error */ 76 #define XCAN_SR_TXFLL_MASK 0x00000400 /* TX FIFO is full */ 77 #define XCAN_SR_ESTAT_MASK 0x00000180 /* Error status */ 78 #define XCAN_SR_ERRWRN_MASK 0x00000040 /* Error warning */ 79 #define XCAN_SR_NORMAL_MASK 0x00000008 /* Normal mode */ 80 #define XCAN_SR_LBACK_MASK 0x00000002 /* Loop back mode */ 81 #define XCAN_SR_CONFIG_MASK 0x00000001 /* Configuration mode */ 82 #define XCAN_IXR_TXFEMP_MASK 0x00004000 /* TX FIFO Empty */ 83 #define XCAN_IXR_WKUP_MASK 0x00000800 /* Wake up interrupt */ 84 #define XCAN_IXR_SLP_MASK 0x00000400 /* Sleep interrupt */ 85 #define XCAN_IXR_BSOFF_MASK 0x00000200 /* Bus off interrupt */ 86 #define XCAN_IXR_ERROR_MASK 0x00000100 /* Error interrupt */ 87 #define XCAN_IXR_RXNEMP_MASK 0x00000080 /* RX FIFO NotEmpty intr */ 88 #define XCAN_IXR_RXOFLW_MASK 0x00000040 /* RX FIFO Overflow intr */ 89 #define XCAN_IXR_RXOK_MASK 0x00000010 /* Message received intr */ 90 #define XCAN_IXR_TXFLL_MASK 0x00000004 /* Tx FIFO Full intr */ 91 #define XCAN_IXR_TXOK_MASK 0x00000002 /* TX successful intr */ 92 #define XCAN_IXR_ARBLST_MASK 0x00000001 /* Arbitration lost intr */ 93 #define XCAN_IDR_ID1_MASK 0xFFE00000 /* Standard msg identifier */ 94 #define XCAN_IDR_SRR_MASK 0x00100000 /* Substitute remote TXreq */ 95 #define XCAN_IDR_IDE_MASK 0x00080000 /* Identifier extension */ 96 #define XCAN_IDR_ID2_MASK 0x0007FFFE /* Extended message ident */ 97 #define XCAN_IDR_RTR_MASK 0x00000001 /* Remote TX request */ 98 #define XCAN_DLCR_DLC_MASK 0xF0000000 /* Data length code */ 99 100 #define XCAN_INTR_ALL (XCAN_IXR_TXOK_MASK | XCAN_IXR_BSOFF_MASK |\ 101 XCAN_IXR_WKUP_MASK | XCAN_IXR_SLP_MASK | \ 102 XCAN_IXR_RXNEMP_MASK | XCAN_IXR_ERROR_MASK | \ 103 XCAN_IXR_ARBLST_MASK | XCAN_IXR_RXOK_MASK) 104 105 /* CAN register bit shift - XCAN_<REG>_<BIT>_SHIFT */ 106 #define XCAN_BTR_SJW_SHIFT 7 /* Synchronous jump width */ 107 #define XCAN_BTR_TS2_SHIFT 4 /* Time segment 2 */ 108 #define XCAN_IDR_ID1_SHIFT 21 /* Standard Messg Identifier */ 109 #define XCAN_IDR_ID2_SHIFT 1 /* Extended Message Identifier */ 110 #define XCAN_DLCR_DLC_SHIFT 28 /* Data length code */ 111 #define XCAN_ESR_REC_SHIFT 8 /* Rx Error Count */ 112 113 /* CAN frame length constants */ 114 #define XCAN_FRAME_MAX_DATA_LEN 8 115 #define XCAN_TIMEOUT (1 * HZ) 116 117 /** 118 * struct xcan_priv - This definition define CAN driver instance 119 * @can: CAN private data structure. 120 * @tx_head: Tx CAN packets ready to send on the queue 121 * @tx_tail: Tx CAN packets successfully sended on the queue 122 * @tx_max: Maximum number packets the driver can send 123 * @napi: NAPI structure 124 * @read_reg: For reading data from CAN registers 125 * @write_reg: For writing data to CAN registers 126 * @dev: Network device data structure 127 * @reg_base: Ioremapped address to registers 128 * @irq_flags: For request_irq() 129 * @bus_clk: Pointer to struct clk 130 * @can_clk: Pointer to struct clk 131 */ 132 struct xcan_priv { 133 struct can_priv can; 134 unsigned int tx_head; 135 unsigned int tx_tail; 136 unsigned int tx_max; 137 struct napi_struct napi; 138 u32 (*read_reg)(const struct xcan_priv *priv, enum xcan_reg reg); 139 void (*write_reg)(const struct xcan_priv *priv, enum xcan_reg reg, 140 u32 val); 141 struct net_device *dev; 142 void __iomem *reg_base; 143 unsigned long irq_flags; 144 struct clk *bus_clk; 145 struct clk *can_clk; 146 }; 147 148 /* CAN Bittiming constants as per Xilinx CAN specs */ 149 static const struct can_bittiming_const xcan_bittiming_const = { 150 .name = DRIVER_NAME, 151 .tseg1_min = 1, 152 .tseg1_max = 16, 153 .tseg2_min = 1, 154 .tseg2_max = 8, 155 .sjw_max = 4, 156 .brp_min = 1, 157 .brp_max = 256, 158 .brp_inc = 1, 159 }; 160 161 /** 162 * xcan_write_reg_le - Write a value to the device register little endian 163 * @priv: Driver private data structure 164 * @reg: Register offset 165 * @val: Value to write at the Register offset 166 * 167 * Write data to the paricular CAN register 168 */ 169 static void xcan_write_reg_le(const struct xcan_priv *priv, enum xcan_reg reg, 170 u32 val) 171 { 172 iowrite32(val, priv->reg_base + reg); 173 } 174 175 /** 176 * xcan_read_reg_le - Read a value from the device register little endian 177 * @priv: Driver private data structure 178 * @reg: Register offset 179 * 180 * Read data from the particular CAN register 181 * Return: value read from the CAN register 182 */ 183 static u32 xcan_read_reg_le(const struct xcan_priv *priv, enum xcan_reg reg) 184 { 185 return ioread32(priv->reg_base + reg); 186 } 187 188 /** 189 * xcan_write_reg_be - Write a value to the device register big endian 190 * @priv: Driver private data structure 191 * @reg: Register offset 192 * @val: Value to write at the Register offset 193 * 194 * Write data to the paricular CAN register 195 */ 196 static void xcan_write_reg_be(const struct xcan_priv *priv, enum xcan_reg reg, 197 u32 val) 198 { 199 iowrite32be(val, priv->reg_base + reg); 200 } 201 202 /** 203 * xcan_read_reg_be - Read a value from the device register big endian 204 * @priv: Driver private data structure 205 * @reg: Register offset 206 * 207 * Read data from the particular CAN register 208 * Return: value read from the CAN register 209 */ 210 static u32 xcan_read_reg_be(const struct xcan_priv *priv, enum xcan_reg reg) 211 { 212 return ioread32be(priv->reg_base + reg); 213 } 214 215 /** 216 * set_reset_mode - Resets the CAN device mode 217 * @ndev: Pointer to net_device structure 218 * 219 * This is the driver reset mode routine.The driver 220 * enters into configuration mode. 221 * 222 * Return: 0 on success and failure value on error 223 */ 224 static int set_reset_mode(struct net_device *ndev) 225 { 226 struct xcan_priv *priv = netdev_priv(ndev); 227 unsigned long timeout; 228 229 priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_RESET_MASK); 230 231 timeout = jiffies + XCAN_TIMEOUT; 232 while (!(priv->read_reg(priv, XCAN_SR_OFFSET) & XCAN_SR_CONFIG_MASK)) { 233 if (time_after(jiffies, timeout)) { 234 netdev_warn(ndev, "timed out for config mode\n"); 235 return -ETIMEDOUT; 236 } 237 usleep_range(500, 10000); 238 } 239 240 return 0; 241 } 242 243 /** 244 * xcan_set_bittiming - CAN set bit timing routine 245 * @ndev: Pointer to net_device structure 246 * 247 * This is the driver set bittiming routine. 248 * Return: 0 on success and failure value on error 249 */ 250 static int xcan_set_bittiming(struct net_device *ndev) 251 { 252 struct xcan_priv *priv = netdev_priv(ndev); 253 struct can_bittiming *bt = &priv->can.bittiming; 254 u32 btr0, btr1; 255 u32 is_config_mode; 256 257 /* Check whether Xilinx CAN is in configuration mode. 258 * It cannot set bit timing if Xilinx CAN is not in configuration mode. 259 */ 260 is_config_mode = priv->read_reg(priv, XCAN_SR_OFFSET) & 261 XCAN_SR_CONFIG_MASK; 262 if (!is_config_mode) { 263 netdev_alert(ndev, 264 "BUG! Cannot set bittiming - CAN is not in config mode\n"); 265 return -EPERM; 266 } 267 268 /* Setting Baud Rate prescalar value in BRPR Register */ 269 btr0 = (bt->brp - 1); 270 271 /* Setting Time Segment 1 in BTR Register */ 272 btr1 = (bt->prop_seg + bt->phase_seg1 - 1); 273 274 /* Setting Time Segment 2 in BTR Register */ 275 btr1 |= (bt->phase_seg2 - 1) << XCAN_BTR_TS2_SHIFT; 276 277 /* Setting Synchronous jump width in BTR Register */ 278 btr1 |= (bt->sjw - 1) << XCAN_BTR_SJW_SHIFT; 279 280 priv->write_reg(priv, XCAN_BRPR_OFFSET, btr0); 281 priv->write_reg(priv, XCAN_BTR_OFFSET, btr1); 282 283 netdev_dbg(ndev, "BRPR=0x%08x, BTR=0x%08x\n", 284 priv->read_reg(priv, XCAN_BRPR_OFFSET), 285 priv->read_reg(priv, XCAN_BTR_OFFSET)); 286 287 return 0; 288 } 289 290 /** 291 * xcan_chip_start - This the drivers start routine 292 * @ndev: Pointer to net_device structure 293 * 294 * This is the drivers start routine. 295 * Based on the State of the CAN device it puts 296 * the CAN device into a proper mode. 297 * 298 * Return: 0 on success and failure value on error 299 */ 300 static int xcan_chip_start(struct net_device *ndev) 301 { 302 struct xcan_priv *priv = netdev_priv(ndev); 303 u32 reg_msr, reg_sr_mask; 304 int err; 305 unsigned long timeout; 306 307 /* Check if it is in reset mode */ 308 err = set_reset_mode(ndev); 309 if (err < 0) 310 return err; 311 312 err = xcan_set_bittiming(ndev); 313 if (err < 0) 314 return err; 315 316 /* Enable interrupts */ 317 priv->write_reg(priv, XCAN_IER_OFFSET, XCAN_INTR_ALL); 318 319 /* Check whether it is loopback mode or normal mode */ 320 if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) { 321 reg_msr = XCAN_MSR_LBACK_MASK; 322 reg_sr_mask = XCAN_SR_LBACK_MASK; 323 } else { 324 reg_msr = 0x0; 325 reg_sr_mask = XCAN_SR_NORMAL_MASK; 326 } 327 328 priv->write_reg(priv, XCAN_MSR_OFFSET, reg_msr); 329 priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_CEN_MASK); 330 331 timeout = jiffies + XCAN_TIMEOUT; 332 while (!(priv->read_reg(priv, XCAN_SR_OFFSET) & reg_sr_mask)) { 333 if (time_after(jiffies, timeout)) { 334 netdev_warn(ndev, 335 "timed out for correct mode\n"); 336 return -ETIMEDOUT; 337 } 338 } 339 netdev_dbg(ndev, "status:#x%08x\n", 340 priv->read_reg(priv, XCAN_SR_OFFSET)); 341 342 priv->can.state = CAN_STATE_ERROR_ACTIVE; 343 return 0; 344 } 345 346 /** 347 * xcan_do_set_mode - This sets the mode of the driver 348 * @ndev: Pointer to net_device structure 349 * @mode: Tells the mode of the driver 350 * 351 * This check the drivers state and calls the 352 * the corresponding modes to set. 353 * 354 * Return: 0 on success and failure value on error 355 */ 356 static int xcan_do_set_mode(struct net_device *ndev, enum can_mode mode) 357 { 358 int ret; 359 360 switch (mode) { 361 case CAN_MODE_START: 362 ret = xcan_chip_start(ndev); 363 if (ret < 0) { 364 netdev_err(ndev, "xcan_chip_start failed!\n"); 365 return ret; 366 } 367 netif_wake_queue(ndev); 368 break; 369 default: 370 ret = -EOPNOTSUPP; 371 break; 372 } 373 374 return ret; 375 } 376 377 /** 378 * xcan_start_xmit - Starts the transmission 379 * @skb: sk_buff pointer that contains data to be Txed 380 * @ndev: Pointer to net_device structure 381 * 382 * This function is invoked from upper layers to initiate transmission. This 383 * function uses the next available free txbuff and populates their fields to 384 * start the transmission. 385 * 386 * Return: 0 on success and failure value on error 387 */ 388 static int xcan_start_xmit(struct sk_buff *skb, struct net_device *ndev) 389 { 390 struct xcan_priv *priv = netdev_priv(ndev); 391 struct net_device_stats *stats = &ndev->stats; 392 struct can_frame *cf = (struct can_frame *)skb->data; 393 u32 id, dlc, data[2] = {0, 0}; 394 395 if (can_dropped_invalid_skb(ndev, skb)) 396 return NETDEV_TX_OK; 397 398 /* Check if the TX buffer is full */ 399 if (unlikely(priv->read_reg(priv, XCAN_SR_OFFSET) & 400 XCAN_SR_TXFLL_MASK)) { 401 netif_stop_queue(ndev); 402 netdev_err(ndev, "BUG!, TX FIFO full when queue awake!\n"); 403 return NETDEV_TX_BUSY; 404 } 405 406 /* Watch carefully on the bit sequence */ 407 if (cf->can_id & CAN_EFF_FLAG) { 408 /* Extended CAN ID format */ 409 id = ((cf->can_id & CAN_EFF_MASK) << XCAN_IDR_ID2_SHIFT) & 410 XCAN_IDR_ID2_MASK; 411 id |= (((cf->can_id & CAN_EFF_MASK) >> 412 (CAN_EFF_ID_BITS-CAN_SFF_ID_BITS)) << 413 XCAN_IDR_ID1_SHIFT) & XCAN_IDR_ID1_MASK; 414 415 /* The substibute remote TX request bit should be "1" 416 * for extended frames as in the Xilinx CAN datasheet 417 */ 418 id |= XCAN_IDR_IDE_MASK | XCAN_IDR_SRR_MASK; 419 420 if (cf->can_id & CAN_RTR_FLAG) 421 /* Extended frames remote TX request */ 422 id |= XCAN_IDR_RTR_MASK; 423 } else { 424 /* Standard CAN ID format */ 425 id = ((cf->can_id & CAN_SFF_MASK) << XCAN_IDR_ID1_SHIFT) & 426 XCAN_IDR_ID1_MASK; 427 428 if (cf->can_id & CAN_RTR_FLAG) 429 /* Standard frames remote TX request */ 430 id |= XCAN_IDR_SRR_MASK; 431 } 432 433 dlc = cf->can_dlc << XCAN_DLCR_DLC_SHIFT; 434 435 if (cf->can_dlc > 0) 436 data[0] = be32_to_cpup((__be32 *)(cf->data + 0)); 437 if (cf->can_dlc > 4) 438 data[1] = be32_to_cpup((__be32 *)(cf->data + 4)); 439 440 can_put_echo_skb(skb, ndev, priv->tx_head % priv->tx_max); 441 priv->tx_head++; 442 443 /* Write the Frame to Xilinx CAN TX FIFO */ 444 priv->write_reg(priv, XCAN_TXFIFO_ID_OFFSET, id); 445 /* If the CAN frame is RTR frame this write triggers tranmission */ 446 priv->write_reg(priv, XCAN_TXFIFO_DLC_OFFSET, dlc); 447 if (!(cf->can_id & CAN_RTR_FLAG)) { 448 priv->write_reg(priv, XCAN_TXFIFO_DW1_OFFSET, data[0]); 449 /* If the CAN frame is Standard/Extended frame this 450 * write triggers tranmission 451 */ 452 priv->write_reg(priv, XCAN_TXFIFO_DW2_OFFSET, data[1]); 453 stats->tx_bytes += cf->can_dlc; 454 } 455 456 /* Check if the TX buffer is full */ 457 if ((priv->tx_head - priv->tx_tail) == priv->tx_max) 458 netif_stop_queue(ndev); 459 460 return NETDEV_TX_OK; 461 } 462 463 /** 464 * xcan_rx - Is called from CAN isr to complete the received 465 * frame processing 466 * @ndev: Pointer to net_device structure 467 * 468 * This function is invoked from the CAN isr(poll) to process the Rx frames. It 469 * does minimal processing and invokes "netif_receive_skb" to complete further 470 * processing. 471 * Return: 1 on success and 0 on failure. 472 */ 473 static int xcan_rx(struct net_device *ndev) 474 { 475 struct xcan_priv *priv = netdev_priv(ndev); 476 struct net_device_stats *stats = &ndev->stats; 477 struct can_frame *cf; 478 struct sk_buff *skb; 479 u32 id_xcan, dlc, data[2] = {0, 0}; 480 481 skb = alloc_can_skb(ndev, &cf); 482 if (unlikely(!skb)) { 483 stats->rx_dropped++; 484 return 0; 485 } 486 487 /* Read a frame from Xilinx zynq CANPS */ 488 id_xcan = priv->read_reg(priv, XCAN_RXFIFO_ID_OFFSET); 489 dlc = priv->read_reg(priv, XCAN_RXFIFO_DLC_OFFSET) >> 490 XCAN_DLCR_DLC_SHIFT; 491 492 /* Change Xilinx CAN data length format to socketCAN data format */ 493 cf->can_dlc = get_can_dlc(dlc); 494 495 /* Change Xilinx CAN ID format to socketCAN ID format */ 496 if (id_xcan & XCAN_IDR_IDE_MASK) { 497 /* The received frame is an Extended format frame */ 498 cf->can_id = (id_xcan & XCAN_IDR_ID1_MASK) >> 3; 499 cf->can_id |= (id_xcan & XCAN_IDR_ID2_MASK) >> 500 XCAN_IDR_ID2_SHIFT; 501 cf->can_id |= CAN_EFF_FLAG; 502 if (id_xcan & XCAN_IDR_RTR_MASK) 503 cf->can_id |= CAN_RTR_FLAG; 504 } else { 505 /* The received frame is a standard format frame */ 506 cf->can_id = (id_xcan & XCAN_IDR_ID1_MASK) >> 507 XCAN_IDR_ID1_SHIFT; 508 if (id_xcan & XCAN_IDR_SRR_MASK) 509 cf->can_id |= CAN_RTR_FLAG; 510 } 511 512 /* DW1/DW2 must always be read to remove message from RXFIFO */ 513 data[0] = priv->read_reg(priv, XCAN_RXFIFO_DW1_OFFSET); 514 data[1] = priv->read_reg(priv, XCAN_RXFIFO_DW2_OFFSET); 515 516 if (!(cf->can_id & CAN_RTR_FLAG)) { 517 /* Change Xilinx CAN data format to socketCAN data format */ 518 if (cf->can_dlc > 0) 519 *(__be32 *)(cf->data) = cpu_to_be32(data[0]); 520 if (cf->can_dlc > 4) 521 *(__be32 *)(cf->data + 4) = cpu_to_be32(data[1]); 522 } 523 524 stats->rx_bytes += cf->can_dlc; 525 stats->rx_packets++; 526 netif_receive_skb(skb); 527 528 return 1; 529 } 530 531 /** 532 * xcan_err_interrupt - error frame Isr 533 * @ndev: net_device pointer 534 * @isr: interrupt status register value 535 * 536 * This is the CAN error interrupt and it will 537 * check the the type of error and forward the error 538 * frame to upper layers. 539 */ 540 static void xcan_err_interrupt(struct net_device *ndev, u32 isr) 541 { 542 struct xcan_priv *priv = netdev_priv(ndev); 543 struct net_device_stats *stats = &ndev->stats; 544 struct can_frame *cf; 545 struct sk_buff *skb; 546 u32 err_status, status, txerr = 0, rxerr = 0; 547 548 skb = alloc_can_err_skb(ndev, &cf); 549 550 err_status = priv->read_reg(priv, XCAN_ESR_OFFSET); 551 priv->write_reg(priv, XCAN_ESR_OFFSET, err_status); 552 txerr = priv->read_reg(priv, XCAN_ECR_OFFSET) & XCAN_ECR_TEC_MASK; 553 rxerr = ((priv->read_reg(priv, XCAN_ECR_OFFSET) & 554 XCAN_ECR_REC_MASK) >> XCAN_ESR_REC_SHIFT); 555 status = priv->read_reg(priv, XCAN_SR_OFFSET); 556 557 if (isr & XCAN_IXR_BSOFF_MASK) { 558 priv->can.state = CAN_STATE_BUS_OFF; 559 priv->can.can_stats.bus_off++; 560 /* Leave device in Config Mode in bus-off state */ 561 priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_RESET_MASK); 562 can_bus_off(ndev); 563 if (skb) 564 cf->can_id |= CAN_ERR_BUSOFF; 565 } else if ((status & XCAN_SR_ESTAT_MASK) == XCAN_SR_ESTAT_MASK) { 566 priv->can.state = CAN_STATE_ERROR_PASSIVE; 567 priv->can.can_stats.error_passive++; 568 if (skb) { 569 cf->can_id |= CAN_ERR_CRTL; 570 cf->data[1] = (rxerr > 127) ? 571 CAN_ERR_CRTL_RX_PASSIVE : 572 CAN_ERR_CRTL_TX_PASSIVE; 573 cf->data[6] = txerr; 574 cf->data[7] = rxerr; 575 } 576 } else if (status & XCAN_SR_ERRWRN_MASK) { 577 priv->can.state = CAN_STATE_ERROR_WARNING; 578 priv->can.can_stats.error_warning++; 579 if (skb) { 580 cf->can_id |= CAN_ERR_CRTL; 581 cf->data[1] |= (txerr > rxerr) ? 582 CAN_ERR_CRTL_TX_WARNING : 583 CAN_ERR_CRTL_RX_WARNING; 584 cf->data[6] = txerr; 585 cf->data[7] = rxerr; 586 } 587 } 588 589 /* Check for Arbitration lost interrupt */ 590 if (isr & XCAN_IXR_ARBLST_MASK) { 591 priv->can.can_stats.arbitration_lost++; 592 if (skb) { 593 cf->can_id |= CAN_ERR_LOSTARB; 594 cf->data[0] = CAN_ERR_LOSTARB_UNSPEC; 595 } 596 } 597 598 /* Check for RX FIFO Overflow interrupt */ 599 if (isr & XCAN_IXR_RXOFLW_MASK) { 600 stats->rx_over_errors++; 601 stats->rx_errors++; 602 priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_RESET_MASK); 603 if (skb) { 604 cf->can_id |= CAN_ERR_CRTL; 605 cf->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW; 606 } 607 } 608 609 /* Check for error interrupt */ 610 if (isr & XCAN_IXR_ERROR_MASK) { 611 if (skb) 612 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 613 614 /* Check for Ack error interrupt */ 615 if (err_status & XCAN_ESR_ACKER_MASK) { 616 stats->tx_errors++; 617 if (skb) { 618 cf->can_id |= CAN_ERR_ACK; 619 cf->data[3] = CAN_ERR_PROT_LOC_ACK; 620 } 621 } 622 623 /* Check for Bit error interrupt */ 624 if (err_status & XCAN_ESR_BERR_MASK) { 625 stats->tx_errors++; 626 if (skb) { 627 cf->can_id |= CAN_ERR_PROT; 628 cf->data[2] = CAN_ERR_PROT_BIT; 629 } 630 } 631 632 /* Check for Stuff error interrupt */ 633 if (err_status & XCAN_ESR_STER_MASK) { 634 stats->rx_errors++; 635 if (skb) { 636 cf->can_id |= CAN_ERR_PROT; 637 cf->data[2] = CAN_ERR_PROT_STUFF; 638 } 639 } 640 641 /* Check for Form error interrupt */ 642 if (err_status & XCAN_ESR_FMER_MASK) { 643 stats->rx_errors++; 644 if (skb) { 645 cf->can_id |= CAN_ERR_PROT; 646 cf->data[2] = CAN_ERR_PROT_FORM; 647 } 648 } 649 650 /* Check for CRC error interrupt */ 651 if (err_status & XCAN_ESR_CRCER_MASK) { 652 stats->rx_errors++; 653 if (skb) { 654 cf->can_id |= CAN_ERR_PROT; 655 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 656 } 657 } 658 priv->can.can_stats.bus_error++; 659 } 660 661 if (skb) { 662 stats->rx_packets++; 663 stats->rx_bytes += cf->can_dlc; 664 netif_rx(skb); 665 } 666 667 netdev_dbg(ndev, "%s: error status register:0x%x\n", 668 __func__, priv->read_reg(priv, XCAN_ESR_OFFSET)); 669 } 670 671 /** 672 * xcan_state_interrupt - It will check the state of the CAN device 673 * @ndev: net_device pointer 674 * @isr: interrupt status register value 675 * 676 * This will checks the state of the CAN device 677 * and puts the device into appropriate state. 678 */ 679 static void xcan_state_interrupt(struct net_device *ndev, u32 isr) 680 { 681 struct xcan_priv *priv = netdev_priv(ndev); 682 683 /* Check for Sleep interrupt if set put CAN device in sleep state */ 684 if (isr & XCAN_IXR_SLP_MASK) 685 priv->can.state = CAN_STATE_SLEEPING; 686 687 /* Check for Wake up interrupt if set put CAN device in Active state */ 688 if (isr & XCAN_IXR_WKUP_MASK) 689 priv->can.state = CAN_STATE_ERROR_ACTIVE; 690 } 691 692 /** 693 * xcan_rx_poll - Poll routine for rx packets (NAPI) 694 * @napi: napi structure pointer 695 * @quota: Max number of rx packets to be processed. 696 * 697 * This is the poll routine for rx part. 698 * It will process the packets maximux quota value. 699 * 700 * Return: number of packets received 701 */ 702 static int xcan_rx_poll(struct napi_struct *napi, int quota) 703 { 704 struct net_device *ndev = napi->dev; 705 struct xcan_priv *priv = netdev_priv(ndev); 706 u32 isr, ier; 707 int work_done = 0; 708 709 isr = priv->read_reg(priv, XCAN_ISR_OFFSET); 710 while ((isr & XCAN_IXR_RXNEMP_MASK) && (work_done < quota)) { 711 if (isr & XCAN_IXR_RXOK_MASK) { 712 priv->write_reg(priv, XCAN_ICR_OFFSET, 713 XCAN_IXR_RXOK_MASK); 714 work_done += xcan_rx(ndev); 715 } else { 716 priv->write_reg(priv, XCAN_ICR_OFFSET, 717 XCAN_IXR_RXNEMP_MASK); 718 break; 719 } 720 priv->write_reg(priv, XCAN_ICR_OFFSET, XCAN_IXR_RXNEMP_MASK); 721 isr = priv->read_reg(priv, XCAN_ISR_OFFSET); 722 } 723 724 if (work_done) 725 can_led_event(ndev, CAN_LED_EVENT_RX); 726 727 if (work_done < quota) { 728 napi_complete(napi); 729 ier = priv->read_reg(priv, XCAN_IER_OFFSET); 730 ier |= (XCAN_IXR_RXOK_MASK | XCAN_IXR_RXNEMP_MASK); 731 priv->write_reg(priv, XCAN_IER_OFFSET, ier); 732 } 733 return work_done; 734 } 735 736 /** 737 * xcan_tx_interrupt - Tx Done Isr 738 * @ndev: net_device pointer 739 * @isr: Interrupt status register value 740 */ 741 static void xcan_tx_interrupt(struct net_device *ndev, u32 isr) 742 { 743 struct xcan_priv *priv = netdev_priv(ndev); 744 struct net_device_stats *stats = &ndev->stats; 745 746 while ((priv->tx_head - priv->tx_tail > 0) && 747 (isr & XCAN_IXR_TXOK_MASK)) { 748 priv->write_reg(priv, XCAN_ICR_OFFSET, XCAN_IXR_TXOK_MASK); 749 can_get_echo_skb(ndev, priv->tx_tail % 750 priv->tx_max); 751 priv->tx_tail++; 752 stats->tx_packets++; 753 isr = priv->read_reg(priv, XCAN_ISR_OFFSET); 754 } 755 can_led_event(ndev, CAN_LED_EVENT_TX); 756 netif_wake_queue(ndev); 757 } 758 759 /** 760 * xcan_interrupt - CAN Isr 761 * @irq: irq number 762 * @dev_id: device id poniter 763 * 764 * This is the xilinx CAN Isr. It checks for the type of interrupt 765 * and invokes the corresponding ISR. 766 * 767 * Return: 768 * IRQ_NONE - If CAN device is in sleep mode, IRQ_HANDLED otherwise 769 */ 770 static irqreturn_t xcan_interrupt(int irq, void *dev_id) 771 { 772 struct net_device *ndev = (struct net_device *)dev_id; 773 struct xcan_priv *priv = netdev_priv(ndev); 774 u32 isr, ier; 775 776 /* Get the interrupt status from Xilinx CAN */ 777 isr = priv->read_reg(priv, XCAN_ISR_OFFSET); 778 if (!isr) 779 return IRQ_NONE; 780 781 /* Check for the type of interrupt and Processing it */ 782 if (isr & (XCAN_IXR_SLP_MASK | XCAN_IXR_WKUP_MASK)) { 783 priv->write_reg(priv, XCAN_ICR_OFFSET, (XCAN_IXR_SLP_MASK | 784 XCAN_IXR_WKUP_MASK)); 785 xcan_state_interrupt(ndev, isr); 786 } 787 788 /* Check for Tx interrupt and Processing it */ 789 if (isr & XCAN_IXR_TXOK_MASK) 790 xcan_tx_interrupt(ndev, isr); 791 792 /* Check for the type of error interrupt and Processing it */ 793 if (isr & (XCAN_IXR_ERROR_MASK | XCAN_IXR_RXOFLW_MASK | 794 XCAN_IXR_BSOFF_MASK | XCAN_IXR_ARBLST_MASK)) { 795 priv->write_reg(priv, XCAN_ICR_OFFSET, (XCAN_IXR_ERROR_MASK | 796 XCAN_IXR_RXOFLW_MASK | XCAN_IXR_BSOFF_MASK | 797 XCAN_IXR_ARBLST_MASK)); 798 xcan_err_interrupt(ndev, isr); 799 } 800 801 /* Check for the type of receive interrupt and Processing it */ 802 if (isr & (XCAN_IXR_RXNEMP_MASK | XCAN_IXR_RXOK_MASK)) { 803 ier = priv->read_reg(priv, XCAN_IER_OFFSET); 804 ier &= ~(XCAN_IXR_RXNEMP_MASK | XCAN_IXR_RXOK_MASK); 805 priv->write_reg(priv, XCAN_IER_OFFSET, ier); 806 napi_schedule(&priv->napi); 807 } 808 return IRQ_HANDLED; 809 } 810 811 /** 812 * xcan_chip_stop - Driver stop routine 813 * @ndev: Pointer to net_device structure 814 * 815 * This is the drivers stop routine. It will disable the 816 * interrupts and put the device into configuration mode. 817 */ 818 static void xcan_chip_stop(struct net_device *ndev) 819 { 820 struct xcan_priv *priv = netdev_priv(ndev); 821 u32 ier; 822 823 /* Disable interrupts and leave the can in configuration mode */ 824 ier = priv->read_reg(priv, XCAN_IER_OFFSET); 825 ier &= ~XCAN_INTR_ALL; 826 priv->write_reg(priv, XCAN_IER_OFFSET, ier); 827 priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_RESET_MASK); 828 priv->can.state = CAN_STATE_STOPPED; 829 } 830 831 /** 832 * xcan_open - Driver open routine 833 * @ndev: Pointer to net_device structure 834 * 835 * This is the driver open routine. 836 * Return: 0 on success and failure value on error 837 */ 838 static int xcan_open(struct net_device *ndev) 839 { 840 struct xcan_priv *priv = netdev_priv(ndev); 841 int ret; 842 843 ret = request_irq(ndev->irq, xcan_interrupt, priv->irq_flags, 844 ndev->name, ndev); 845 if (ret < 0) { 846 netdev_err(ndev, "irq allocation for CAN failed\n"); 847 goto err; 848 } 849 850 ret = clk_prepare_enable(priv->can_clk); 851 if (ret) { 852 netdev_err(ndev, "unable to enable device clock\n"); 853 goto err_irq; 854 } 855 856 ret = clk_prepare_enable(priv->bus_clk); 857 if (ret) { 858 netdev_err(ndev, "unable to enable bus clock\n"); 859 goto err_can_clk; 860 } 861 862 /* Set chip into reset mode */ 863 ret = set_reset_mode(ndev); 864 if (ret < 0) { 865 netdev_err(ndev, "mode resetting failed!\n"); 866 goto err_bus_clk; 867 } 868 869 /* Common open */ 870 ret = open_candev(ndev); 871 if (ret) 872 goto err_bus_clk; 873 874 ret = xcan_chip_start(ndev); 875 if (ret < 0) { 876 netdev_err(ndev, "xcan_chip_start failed!\n"); 877 goto err_candev; 878 } 879 880 can_led_event(ndev, CAN_LED_EVENT_OPEN); 881 napi_enable(&priv->napi); 882 netif_start_queue(ndev); 883 884 return 0; 885 886 err_candev: 887 close_candev(ndev); 888 err_bus_clk: 889 clk_disable_unprepare(priv->bus_clk); 890 err_can_clk: 891 clk_disable_unprepare(priv->can_clk); 892 err_irq: 893 free_irq(ndev->irq, ndev); 894 err: 895 return ret; 896 } 897 898 /** 899 * xcan_close - Driver close routine 900 * @ndev: Pointer to net_device structure 901 * 902 * Return: 0 always 903 */ 904 static int xcan_close(struct net_device *ndev) 905 { 906 struct xcan_priv *priv = netdev_priv(ndev); 907 908 netif_stop_queue(ndev); 909 napi_disable(&priv->napi); 910 xcan_chip_stop(ndev); 911 clk_disable_unprepare(priv->bus_clk); 912 clk_disable_unprepare(priv->can_clk); 913 free_irq(ndev->irq, ndev); 914 close_candev(ndev); 915 916 can_led_event(ndev, CAN_LED_EVENT_STOP); 917 918 return 0; 919 } 920 921 /** 922 * xcan_get_berr_counter - error counter routine 923 * @ndev: Pointer to net_device structure 924 * @bec: Pointer to can_berr_counter structure 925 * 926 * This is the driver error counter routine. 927 * Return: 0 on success and failure value on error 928 */ 929 static int xcan_get_berr_counter(const struct net_device *ndev, 930 struct can_berr_counter *bec) 931 { 932 struct xcan_priv *priv = netdev_priv(ndev); 933 int ret; 934 935 ret = clk_prepare_enable(priv->can_clk); 936 if (ret) 937 goto err; 938 939 ret = clk_prepare_enable(priv->bus_clk); 940 if (ret) 941 goto err_clk; 942 943 bec->txerr = priv->read_reg(priv, XCAN_ECR_OFFSET) & XCAN_ECR_TEC_MASK; 944 bec->rxerr = ((priv->read_reg(priv, XCAN_ECR_OFFSET) & 945 XCAN_ECR_REC_MASK) >> XCAN_ESR_REC_SHIFT); 946 947 clk_disable_unprepare(priv->bus_clk); 948 clk_disable_unprepare(priv->can_clk); 949 950 return 0; 951 952 err_clk: 953 clk_disable_unprepare(priv->can_clk); 954 err: 955 return ret; 956 } 957 958 959 static const struct net_device_ops xcan_netdev_ops = { 960 .ndo_open = xcan_open, 961 .ndo_stop = xcan_close, 962 .ndo_start_xmit = xcan_start_xmit, 963 .ndo_change_mtu = can_change_mtu, 964 }; 965 966 /** 967 * xcan_suspend - Suspend method for the driver 968 * @dev: Address of the platform_device structure 969 * 970 * Put the driver into low power mode. 971 * Return: 0 always 972 */ 973 static int __maybe_unused xcan_suspend(struct device *dev) 974 { 975 struct platform_device *pdev = dev_get_drvdata(dev); 976 struct net_device *ndev = platform_get_drvdata(pdev); 977 struct xcan_priv *priv = netdev_priv(ndev); 978 979 if (netif_running(ndev)) { 980 netif_stop_queue(ndev); 981 netif_device_detach(ndev); 982 } 983 984 priv->write_reg(priv, XCAN_MSR_OFFSET, XCAN_MSR_SLEEP_MASK); 985 priv->can.state = CAN_STATE_SLEEPING; 986 987 clk_disable(priv->bus_clk); 988 clk_disable(priv->can_clk); 989 990 return 0; 991 } 992 993 /** 994 * xcan_resume - Resume from suspend 995 * @dev: Address of the platformdevice structure 996 * 997 * Resume operation after suspend. 998 * Return: 0 on success and failure value on error 999 */ 1000 static int __maybe_unused xcan_resume(struct device *dev) 1001 { 1002 struct platform_device *pdev = dev_get_drvdata(dev); 1003 struct net_device *ndev = platform_get_drvdata(pdev); 1004 struct xcan_priv *priv = netdev_priv(ndev); 1005 int ret; 1006 1007 ret = clk_enable(priv->bus_clk); 1008 if (ret) { 1009 dev_err(dev, "Cannot enable clock.\n"); 1010 return ret; 1011 } 1012 ret = clk_enable(priv->can_clk); 1013 if (ret) { 1014 dev_err(dev, "Cannot enable clock.\n"); 1015 clk_disable_unprepare(priv->bus_clk); 1016 return ret; 1017 } 1018 1019 priv->write_reg(priv, XCAN_MSR_OFFSET, 0); 1020 priv->write_reg(priv, XCAN_SRR_OFFSET, XCAN_SRR_CEN_MASK); 1021 priv->can.state = CAN_STATE_ERROR_ACTIVE; 1022 1023 if (netif_running(ndev)) { 1024 netif_device_attach(ndev); 1025 netif_start_queue(ndev); 1026 } 1027 1028 return 0; 1029 } 1030 1031 static SIMPLE_DEV_PM_OPS(xcan_dev_pm_ops, xcan_suspend, xcan_resume); 1032 1033 /** 1034 * xcan_probe - Platform registration call 1035 * @pdev: Handle to the platform device structure 1036 * 1037 * This function does all the memory allocation and registration for the CAN 1038 * device. 1039 * 1040 * Return: 0 on success and failure value on error 1041 */ 1042 static int xcan_probe(struct platform_device *pdev) 1043 { 1044 struct resource *res; /* IO mem resources */ 1045 struct net_device *ndev; 1046 struct xcan_priv *priv; 1047 void __iomem *addr; 1048 int ret, rx_max, tx_max; 1049 1050 /* Get the virtual base address for the device */ 1051 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1052 addr = devm_ioremap_resource(&pdev->dev, res); 1053 if (IS_ERR(addr)) { 1054 ret = PTR_ERR(addr); 1055 goto err; 1056 } 1057 1058 ret = of_property_read_u32(pdev->dev.of_node, "tx-fifo-depth", &tx_max); 1059 if (ret < 0) 1060 goto err; 1061 1062 ret = of_property_read_u32(pdev->dev.of_node, "rx-fifo-depth", &rx_max); 1063 if (ret < 0) 1064 goto err; 1065 1066 /* Create a CAN device instance */ 1067 ndev = alloc_candev(sizeof(struct xcan_priv), tx_max); 1068 if (!ndev) 1069 return -ENOMEM; 1070 1071 priv = netdev_priv(ndev); 1072 priv->dev = ndev; 1073 priv->can.bittiming_const = &xcan_bittiming_const; 1074 priv->can.do_set_mode = xcan_do_set_mode; 1075 priv->can.do_get_berr_counter = xcan_get_berr_counter; 1076 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | 1077 CAN_CTRLMODE_BERR_REPORTING; 1078 priv->reg_base = addr; 1079 priv->tx_max = tx_max; 1080 1081 /* Get IRQ for the device */ 1082 ndev->irq = platform_get_irq(pdev, 0); 1083 ndev->flags |= IFF_ECHO; /* We support local echo */ 1084 1085 platform_set_drvdata(pdev, ndev); 1086 SET_NETDEV_DEV(ndev, &pdev->dev); 1087 ndev->netdev_ops = &xcan_netdev_ops; 1088 1089 /* Getting the CAN can_clk info */ 1090 priv->can_clk = devm_clk_get(&pdev->dev, "can_clk"); 1091 if (IS_ERR(priv->can_clk)) { 1092 dev_err(&pdev->dev, "Device clock not found.\n"); 1093 ret = PTR_ERR(priv->can_clk); 1094 goto err_free; 1095 } 1096 /* Check for type of CAN device */ 1097 if (of_device_is_compatible(pdev->dev.of_node, 1098 "xlnx,zynq-can-1.0")) { 1099 priv->bus_clk = devm_clk_get(&pdev->dev, "pclk"); 1100 if (IS_ERR(priv->bus_clk)) { 1101 dev_err(&pdev->dev, "bus clock not found\n"); 1102 ret = PTR_ERR(priv->bus_clk); 1103 goto err_free; 1104 } 1105 } else { 1106 priv->bus_clk = devm_clk_get(&pdev->dev, "s_axi_aclk"); 1107 if (IS_ERR(priv->bus_clk)) { 1108 dev_err(&pdev->dev, "bus clock not found\n"); 1109 ret = PTR_ERR(priv->bus_clk); 1110 goto err_free; 1111 } 1112 } 1113 1114 ret = clk_prepare_enable(priv->can_clk); 1115 if (ret) { 1116 dev_err(&pdev->dev, "unable to enable device clock\n"); 1117 goto err_free; 1118 } 1119 1120 ret = clk_prepare_enable(priv->bus_clk); 1121 if (ret) { 1122 dev_err(&pdev->dev, "unable to enable bus clock\n"); 1123 goto err_unprepare_disable_dev; 1124 } 1125 1126 priv->write_reg = xcan_write_reg_le; 1127 priv->read_reg = xcan_read_reg_le; 1128 1129 if (priv->read_reg(priv, XCAN_SR_OFFSET) != XCAN_SR_CONFIG_MASK) { 1130 priv->write_reg = xcan_write_reg_be; 1131 priv->read_reg = xcan_read_reg_be; 1132 } 1133 1134 priv->can.clock.freq = clk_get_rate(priv->can_clk); 1135 1136 netif_napi_add(ndev, &priv->napi, xcan_rx_poll, rx_max); 1137 1138 ret = register_candev(ndev); 1139 if (ret) { 1140 dev_err(&pdev->dev, "fail to register failed (err=%d)\n", ret); 1141 goto err_unprepare_disable_busclk; 1142 } 1143 1144 devm_can_led_init(ndev); 1145 clk_disable_unprepare(priv->bus_clk); 1146 clk_disable_unprepare(priv->can_clk); 1147 netdev_dbg(ndev, "reg_base=0x%p irq=%d clock=%d, tx fifo depth:%d\n", 1148 priv->reg_base, ndev->irq, priv->can.clock.freq, 1149 priv->tx_max); 1150 1151 return 0; 1152 1153 err_unprepare_disable_busclk: 1154 clk_disable_unprepare(priv->bus_clk); 1155 err_unprepare_disable_dev: 1156 clk_disable_unprepare(priv->can_clk); 1157 err_free: 1158 free_candev(ndev); 1159 err: 1160 return ret; 1161 } 1162 1163 /** 1164 * xcan_remove - Unregister the device after releasing the resources 1165 * @pdev: Handle to the platform device structure 1166 * 1167 * This function frees all the resources allocated to the device. 1168 * Return: 0 always 1169 */ 1170 static int xcan_remove(struct platform_device *pdev) 1171 { 1172 struct net_device *ndev = platform_get_drvdata(pdev); 1173 struct xcan_priv *priv = netdev_priv(ndev); 1174 1175 if (set_reset_mode(ndev) < 0) 1176 netdev_err(ndev, "mode resetting failed!\n"); 1177 1178 unregister_candev(ndev); 1179 netif_napi_del(&priv->napi); 1180 free_candev(ndev); 1181 1182 return 0; 1183 } 1184 1185 /* Match table for OF platform binding */ 1186 static const struct of_device_id xcan_of_match[] = { 1187 { .compatible = "xlnx,zynq-can-1.0", }, 1188 { .compatible = "xlnx,axi-can-1.00.a", }, 1189 { /* end of list */ }, 1190 }; 1191 MODULE_DEVICE_TABLE(of, xcan_of_match); 1192 1193 static struct platform_driver xcan_driver = { 1194 .probe = xcan_probe, 1195 .remove = xcan_remove, 1196 .driver = { 1197 .name = DRIVER_NAME, 1198 .pm = &xcan_dev_pm_ops, 1199 .of_match_table = xcan_of_match, 1200 }, 1201 }; 1202 1203 module_platform_driver(xcan_driver); 1204 1205 MODULE_LICENSE("GPL"); 1206 MODULE_AUTHOR("Xilinx Inc"); 1207 MODULE_DESCRIPTION("Xilinx CAN interface"); 1208