| 1 |
// SPDX-License-Identifier: GPL-2.0-only |
| 2 |
/* |
| 3 |
* Copyright (C) 2008-2010 |
| 4 |
* |
| 5 |
* - Kurt Van Dijck, EIA Electronics |
| 6 |
*/ |
| 7 |
|
| 8 |
#include <linux/ethtool.h> |
| 9 |
#include <linux/module.h> |
| 10 |
#include <linux/interrupt.h> |
| 11 |
#include <asm/io.h> |
| 12 |
|
| 13 |
#include "softing.h" |
| 14 |
|
| 15 |
#define TX_ECHO_SKB_MAX (((TXMAX+1)/2)-1) |
| 16 |
|
| 17 |
/* |
| 18 |
* test is a specific CAN netdev |
| 19 |
* is online (ie. up 'n running, not sleeping, not busoff |
| 20 |
*/ |
| 21 |
static inline int canif_is_active(struct net_device *netdev) |
| 22 |
{ |
| 23 |
struct can_priv *can = netdev_priv(netdev); |
| 24 |
|
| 25 |
if (!netif_running(netdev)) |
| 26 |
return 0; |
| 27 |
return (can->state <= CAN_STATE_ERROR_PASSIVE); |
| 28 |
} |
| 29 |
|
| 30 |
/* reset DPRAM */ |
| 31 |
static inline void softing_set_reset_dpram(struct softing *card) |
| 32 |
{ |
| 33 |
if (card->pdat->generation >= 2) { |
| 34 |
spin_lock_bh(&card->spin); |
| 35 |
iowrite8(ioread8(&card->dpram[DPRAM_V2_RESET]) & ~1, |
| 36 |
&card->dpram[DPRAM_V2_RESET]); |
| 37 |
spin_unlock_bh(&card->spin); |
| 38 |
} |
| 39 |
} |
| 40 |
|
| 41 |
static inline void softing_clr_reset_dpram(struct softing *card) |
| 42 |
{ |
| 43 |
if (card->pdat->generation >= 2) { |
| 44 |
spin_lock_bh(&card->spin); |
| 45 |
iowrite8(ioread8(&card->dpram[DPRAM_V2_RESET]) | 1, |
| 46 |
&card->dpram[DPRAM_V2_RESET]); |
| 47 |
spin_unlock_bh(&card->spin); |
| 48 |
} |
| 49 |
} |
| 50 |
|
| 51 |
/* trigger the tx queue-ing */ |
| 52 |
static netdev_tx_t softing_netdev_start_xmit(struct sk_buff *skb, |
| 53 |
struct net_device *dev) |
| 54 |
{ |
| 55 |
struct softing_priv *priv = netdev_priv(dev); |
| 56 |
struct softing *card = priv->card; |
| 57 |
int ret; |
| 58 |
uint8_t *ptr; |
| 59 |
uint8_t fifo_wr, fifo_rd; |
| 60 |
struct can_frame *cf = (struct can_frame *)skb->data; |
| 61 |
uint8_t buf[DPRAM_TX_SIZE]; |
| 62 |
|
| 63 |
if (can_dev_dropped_skb(dev, skb)) |
| 64 |
return NETDEV_TX_OK; |
| 65 |
|
| 66 |
spin_lock(&card->spin); |
| 67 |
|
| 68 |
ret = NETDEV_TX_BUSY; |
| 69 |
if (!card->fw.up || |
| 70 |
(card->tx.pending >= TXMAX) || |
| 71 |
(priv->tx.pending >= TX_ECHO_SKB_MAX)) |
| 72 |
goto xmit_done; |
| 73 |
fifo_wr = ioread8(&card->dpram[DPRAM_TX_WR]); |
| 74 |
fifo_rd = ioread8(&card->dpram[DPRAM_TX_RD]); |
| 75 |
if (fifo_wr == fifo_rd) |
| 76 |
/* fifo full */ |
| 77 |
goto xmit_done; |
| 78 |
memset(buf, 0, sizeof(buf)); |
| 79 |
ptr = buf; |
| 80 |
*ptr = CMD_TX; |
| 81 |
if (cf->can_id & CAN_RTR_FLAG) |
| 82 |
*ptr |= CMD_RTR; |
| 83 |
if (cf->can_id & CAN_EFF_FLAG) |
| 84 |
*ptr |= CMD_XTD; |
| 85 |
if (priv->index) |
| 86 |
*ptr |= CMD_BUS2; |
| 87 |
++ptr; |
| 88 |
*ptr++ = cf->len; |
| 89 |
*ptr++ = (cf->can_id >> 0); |
| 90 |
*ptr++ = (cf->can_id >> 8); |
| 91 |
if (cf->can_id & CAN_EFF_FLAG) { |
| 92 |
*ptr++ = (cf->can_id >> 16); |
| 93 |
*ptr++ = (cf->can_id >> 24); |
| 94 |
} else { |
| 95 |
/* increment 1, not 2 as you might think */ |
| 96 |
ptr += 1; |
| 97 |
} |
| 98 |
if (!(cf->can_id & CAN_RTR_FLAG)) |
| 99 |
memcpy(ptr, &cf->data[0], cf->len); |
| 100 |
memcpy_toio(&card->dpram[DPRAM_TX + DPRAM_TX_SIZE * fifo_wr], |
| 101 |
buf, DPRAM_TX_SIZE); |
| 102 |
if (++fifo_wr >= DPRAM_TX_CNT) |
| 103 |
fifo_wr = 0; |
| 104 |
iowrite8(fifo_wr, &card->dpram[DPRAM_TX_WR]); |
| 105 |
card->tx.last_bus = priv->index; |
| 106 |
++card->tx.pending; |
| 107 |
++priv->tx.pending; |
| 108 |
can_put_echo_skb(skb, dev, priv->tx.echo_put, 0); |
| 109 |
++priv->tx.echo_put; |
| 110 |
if (priv->tx.echo_put >= TX_ECHO_SKB_MAX) |
| 111 |
priv->tx.echo_put = 0; |
| 112 |
/* can_put_echo_skb() saves the skb, safe to return TX_OK */ |
| 113 |
ret = NETDEV_TX_OK; |
| 114 |
xmit_done: |
| 115 |
spin_unlock(&card->spin); |
| 116 |
if (card->tx.pending >= TXMAX) { |
| 117 |
int j; |
| 118 |
for (j = 0; j < ARRAY_SIZE(card->net); ++j) { |
| 119 |
if (card->net[j]) |
| 120 |
netif_stop_queue(card->net[j]); |
| 121 |
} |
| 122 |
} |
| 123 |
if (ret != NETDEV_TX_OK) |
| 124 |
netif_stop_queue(dev); |
| 125 |
|
| 126 |
return ret; |
| 127 |
} |
| 128 |
|
| 129 |
/* |
| 130 |
* shortcut for skb delivery |
| 131 |
*/ |
| 132 |
int softing_netdev_rx(struct net_device *netdev, const struct can_frame *msg, |
| 133 |
ktime_t ktime) |
| 134 |
{ |
| 135 |
struct sk_buff *skb; |
| 136 |
struct can_frame *cf; |
| 137 |
|
| 138 |
skb = alloc_can_skb(netdev, &cf); |
| 139 |
if (!skb) |
| 140 |
return -ENOMEM; |
| 141 |
memcpy(cf, msg, sizeof(*msg)); |
| 142 |
skb->tstamp = ktime; |
| 143 |
return netif_rx(skb); |
| 144 |
} |
| 145 |
|
| 146 |
/* |
| 147 |
* softing_handle_1 |
| 148 |
* pop 1 entry from the DPRAM queue, and process |
| 149 |
*/ |
| 150 |
static int softing_handle_1(struct softing *card) |
| 151 |
{ |
| 152 |
struct net_device *netdev; |
| 153 |
struct softing_priv *priv; |
| 154 |
ktime_t ktime; |
| 155 |
struct can_frame msg; |
| 156 |
int cnt = 0, lost_msg; |
| 157 |
uint8_t fifo_rd, fifo_wr, cmd; |
| 158 |
uint8_t *ptr; |
| 159 |
uint32_t tmp_u32; |
| 160 |
uint8_t buf[DPRAM_RX_SIZE]; |
| 161 |
|
| 162 |
memset(&msg, 0, sizeof(msg)); |
| 163 |
/* test for lost msgs */ |
| 164 |
lost_msg = ioread8(&card->dpram[DPRAM_RX_LOST]); |
| 165 |
if (lost_msg) { |
| 166 |
int j; |
| 167 |
/* reset condition */ |
| 168 |
iowrite8(0, &card->dpram[DPRAM_RX_LOST]); |
| 169 |
/* prepare msg */ |
| 170 |
msg.can_id = CAN_ERR_FLAG | CAN_ERR_CRTL; |
| 171 |
msg.len = CAN_ERR_DLC; |
| 172 |
msg.data[1] = CAN_ERR_CRTL_RX_OVERFLOW; |
| 173 |
/* |
| 174 |
* service to all buses, we don't know which it was applicable |
| 175 |
* but only service buses that are online |
| 176 |
*/ |
| 177 |
for (j = 0; j < ARRAY_SIZE(card->net); ++j) { |
| 178 |
netdev = card->net[j]; |
| 179 |
if (!netdev) |
| 180 |
continue; |
| 181 |
if (!canif_is_active(netdev)) |
| 182 |
/* a dead bus has no overflows */ |
| 183 |
continue; |
| 184 |
++netdev->stats.rx_over_errors; |
| 185 |
softing_netdev_rx(netdev, &msg, 0); |
| 186 |
} |
| 187 |
/* prepare for other use */ |
| 188 |
memset(&msg, 0, sizeof(msg)); |
| 189 |
++cnt; |
| 190 |
} |
| 191 |
|
| 192 |
fifo_rd = ioread8(&card->dpram[DPRAM_RX_RD]); |
| 193 |
fifo_wr = ioread8(&card->dpram[DPRAM_RX_WR]); |
| 194 |
|
| 195 |
if (++fifo_rd >= DPRAM_RX_CNT) |
| 196 |
fifo_rd = 0; |
| 197 |
if (fifo_wr == fifo_rd) |
| 198 |
return cnt; |
| 199 |
|
| 200 |
memcpy_fromio(buf, &card->dpram[DPRAM_RX + DPRAM_RX_SIZE*fifo_rd], |
| 201 |
DPRAM_RX_SIZE); |
| 202 |
mb(); |
| 203 |
/* trigger dual port RAM */ |
| 204 |
iowrite8(fifo_rd, &card->dpram[DPRAM_RX_RD]); |
| 205 |
|
| 206 |
ptr = buf; |
| 207 |
cmd = *ptr++; |
| 208 |
if (cmd == 0xff) |
| 209 |
/* not quite useful, probably the card has got out */ |
| 210 |
return 0; |
| 211 |
netdev = card->net[0]; |
| 212 |
if (cmd & CMD_BUS2) |
| 213 |
netdev = card->net[1]; |
| 214 |
priv = netdev_priv(netdev); |
| 215 |
|
| 216 |
if (cmd & CMD_ERR) { |
| 217 |
uint8_t can_state, state; |
| 218 |
|
| 219 |
state = *ptr++; |
| 220 |
|
| 221 |
msg.can_id = CAN_ERR_FLAG; |
| 222 |
msg.len = CAN_ERR_DLC; |
| 223 |
|
| 224 |
if (state & SF_MASK_BUSOFF) { |
| 225 |
can_state = CAN_STATE_BUS_OFF; |
| 226 |
msg.can_id |= CAN_ERR_BUSOFF; |
| 227 |
state = STATE_BUSOFF; |
| 228 |
} else if (state & SF_MASK_EPASSIVE) { |
| 229 |
can_state = CAN_STATE_ERROR_PASSIVE; |
| 230 |
msg.can_id |= CAN_ERR_CRTL; |
| 231 |
msg.data[1] = CAN_ERR_CRTL_TX_PASSIVE; |
| 232 |
state = STATE_EPASSIVE; |
| 233 |
} else { |
| 234 |
can_state = CAN_STATE_ERROR_ACTIVE; |
| 235 |
msg.can_id |= CAN_ERR_CRTL; |
| 236 |
state = STATE_EACTIVE; |
| 237 |
} |
| 238 |
/* update DPRAM */ |
| 239 |
iowrite8(state, &card->dpram[priv->index ? |
| 240 |
DPRAM_INFO_BUSSTATE2 : DPRAM_INFO_BUSSTATE]); |
| 241 |
/* timestamp */ |
| 242 |
tmp_u32 = le32_to_cpup((void *)ptr); |
| 243 |
ktime = softing_raw2ktime(card, tmp_u32); |
| 244 |
|
| 245 |
++netdev->stats.rx_errors; |
| 246 |
/* update internal status */ |
| 247 |
if (can_state != priv->can.state) { |
| 248 |
priv->can.state = can_state; |
| 249 |
if (can_state == CAN_STATE_ERROR_PASSIVE) |
| 250 |
++priv->can.can_stats.error_passive; |
| 251 |
else if (can_state == CAN_STATE_BUS_OFF) { |
| 252 |
/* this calls can_close_cleanup() */ |
| 253 |
++priv->can.can_stats.bus_off; |
| 254 |
can_bus_off(netdev); |
| 255 |
netif_stop_queue(netdev); |
| 256 |
} |
| 257 |
/* trigger socketcan */ |
| 258 |
softing_netdev_rx(netdev, &msg, ktime); |
| 259 |
} |
| 260 |
|
| 261 |
} else { |
| 262 |
if (cmd & CMD_RTR) |
| 263 |
msg.can_id |= CAN_RTR_FLAG; |
| 264 |
msg.len = can_cc_dlc2len(*ptr++); |
| 265 |
if (cmd & CMD_XTD) { |
| 266 |
msg.can_id |= CAN_EFF_FLAG; |
| 267 |
msg.can_id |= le32_to_cpup((void *)ptr); |
| 268 |
ptr += 4; |
| 269 |
} else { |
| 270 |
msg.can_id |= le16_to_cpup((void *)ptr); |
| 271 |
ptr += 2; |
| 272 |
} |
| 273 |
/* timestamp */ |
| 274 |
tmp_u32 = le32_to_cpup((void *)ptr); |
| 275 |
ptr += 4; |
| 276 |
ktime = softing_raw2ktime(card, tmp_u32); |
| 277 |
if (!(msg.can_id & CAN_RTR_FLAG)) |
| 278 |
memcpy(&msg.data[0], ptr, 8); |
| 279 |
/* update socket */ |
| 280 |
if (cmd & CMD_ACK) { |
| 281 |
/* acknowledge, was tx msg */ |
| 282 |
struct sk_buff *skb; |
| 283 |
skb = priv->can.echo_skb[priv->tx.echo_get]; |
| 284 |
if (skb) |
| 285 |
skb->tstamp = ktime; |
| 286 |
++netdev->stats.tx_packets; |
| 287 |
netdev->stats.tx_bytes += |
| 288 |
can_get_echo_skb(netdev, priv->tx.echo_get, |
| 289 |
NULL); |
| 290 |
++priv->tx.echo_get; |
| 291 |
if (priv->tx.echo_get >= TX_ECHO_SKB_MAX) |
| 292 |
priv->tx.echo_get = 0; |
| 293 |
if (priv->tx.pending) |
| 294 |
--priv->tx.pending; |
| 295 |
if (card->tx.pending) |
| 296 |
--card->tx.pending; |
| 297 |
} else { |
| 298 |
int ret; |
| 299 |
|
| 300 |
ret = softing_netdev_rx(netdev, &msg, ktime); |
| 301 |
if (ret == NET_RX_SUCCESS) { |
| 302 |
++netdev->stats.rx_packets; |
| 303 |
if (!(msg.can_id & CAN_RTR_FLAG)) |
| 304 |
netdev->stats.rx_bytes += msg.len; |
| 305 |
} else { |
| 306 |
++netdev->stats.rx_dropped; |
| 307 |
} |
| 308 |
} |
| 309 |
} |
| 310 |
++cnt; |
| 311 |
return cnt; |
| 312 |
} |
| 313 |
|
| 314 |
/* |
| 315 |
* real interrupt handler |
| 316 |
*/ |
| 317 |
static irqreturn_t softing_irq_thread(int irq, void *dev_id) |
| 318 |
{ |
| 319 |
struct softing *card = (struct softing *)dev_id; |
| 320 |
struct net_device *netdev; |
| 321 |
struct softing_priv *priv; |
| 322 |
int j, offset, work_done; |
| 323 |
|
| 324 |
work_done = 0; |
| 325 |
spin_lock_bh(&card->spin); |
| 326 |
while (softing_handle_1(card) > 0) { |
| 327 |
++card->irq.svc_count; |
| 328 |
++work_done; |
| 329 |
} |
| 330 |
spin_unlock_bh(&card->spin); |
| 331 |
/* resume tx queue's */ |
| 332 |
offset = card->tx.last_bus; |
| 333 |
for (j = 0; j < ARRAY_SIZE(card->net); ++j) { |
| 334 |
if (card->tx.pending >= TXMAX) |
| 335 |
break; |
| 336 |
netdev = card->net[(j + offset + 1) % card->pdat->nbus]; |
| 337 |
if (!netdev) |
| 338 |
continue; |
| 339 |
priv = netdev_priv(netdev); |
| 340 |
if (!canif_is_active(netdev)) |
| 341 |
/* it makes no sense to wake dead buses */ |
| 342 |
continue; |
| 343 |
if (priv->tx.pending >= TX_ECHO_SKB_MAX) |
| 344 |
continue; |
| 345 |
++work_done; |
| 346 |
netif_wake_queue(netdev); |
| 347 |
} |
| 348 |
return work_done ? IRQ_HANDLED : IRQ_NONE; |
| 349 |
} |
| 350 |
|
| 351 |
/* |
| 352 |
* interrupt routines: |
| 353 |
* schedule the 'real interrupt handler' |
| 354 |
*/ |
| 355 |
static irqreturn_t softing_irq_v2(int irq, void *dev_id) |
| 356 |
{ |
| 357 |
struct softing *card = (struct softing *)dev_id; |
| 358 |
uint8_t ir; |
| 359 |
|
| 360 |
ir = ioread8(&card->dpram[DPRAM_V2_IRQ_TOHOST]); |
| 361 |
iowrite8(0, &card->dpram[DPRAM_V2_IRQ_TOHOST]); |
| 362 |
return (1 == ir) ? IRQ_WAKE_THREAD : IRQ_NONE; |
| 363 |
} |
| 364 |
|
| 365 |
static irqreturn_t softing_irq_v1(int irq, void *dev_id) |
| 366 |
{ |
| 367 |
struct softing *card = (struct softing *)dev_id; |
| 368 |
uint8_t ir; |
| 369 |
|
| 370 |
ir = ioread8(&card->dpram[DPRAM_IRQ_TOHOST]); |
| 371 |
iowrite8(0, &card->dpram[DPRAM_IRQ_TOHOST]); |
| 372 |
return ir ? IRQ_WAKE_THREAD : IRQ_NONE; |
| 373 |
} |
| 374 |
|
| 375 |
/* |
| 376 |
* netdev/candev interoperability |
| 377 |
*/ |
| 378 |
static int softing_netdev_open(struct net_device *ndev) |
| 379 |
{ |
| 380 |
int ret; |
| 381 |
|
| 382 |
/* check or determine and set bittime */ |
| 383 |
ret = open_candev(ndev); |
| 384 |
if (ret) |
| 385 |
return ret; |
| 386 |
|
| 387 |
ret = softing_startstop(ndev, 1); |
| 388 |
if (ret < 0) |
| 389 |
close_candev(ndev); |
| 390 |
|
| 391 |
return ret; |
| 392 |
} |
| 393 |
|
| 394 |
static int softing_netdev_stop(struct net_device *ndev) |
| 395 |
{ |
| 396 |
netif_stop_queue(ndev); |
| 397 |
|
| 398 |
/* softing cycle does close_candev() */ |
| 399 |
return softing_startstop(ndev, 0); |
| 400 |
} |
| 401 |
|
| 402 |
static int softing_candev_set_mode(struct net_device *ndev, enum can_mode mode) |
| 403 |
{ |
| 404 |
int ret; |
| 405 |
|
| 406 |
switch (mode) { |
| 407 |
case CAN_MODE_START: |
| 408 |
/* softing_startstop does close_candev() */ |
| 409 |
ret = softing_startstop(ndev, 1); |
| 410 |
return ret; |
| 411 |
case CAN_MODE_STOP: |
| 412 |
case CAN_MODE_SLEEP: |
| 413 |
return -EOPNOTSUPP; |
| 414 |
} |
| 415 |
return 0; |
| 416 |
} |
| 417 |
|
| 418 |
/* |
| 419 |
* Softing device management helpers |
| 420 |
*/ |
| 421 |
int softing_enable_irq(struct softing *card, int enable) |
| 422 |
{ |
| 423 |
int ret; |
| 424 |
|
| 425 |
if (!card->irq.nr) { |
| 426 |
return 0; |
| 427 |
} else if (card->irq.requested && !enable) { |
| 428 |
free_irq(card->irq.nr, card); |
| 429 |
card->irq.requested = 0; |
| 430 |
} else if (!card->irq.requested && enable) { |
| 431 |
ret = request_threaded_irq(card->irq.nr, |
| 432 |
(card->pdat->generation >= 2) ? |
| 433 |
softing_irq_v2 : softing_irq_v1, |
| 434 |
softing_irq_thread, IRQF_SHARED, |
| 435 |
dev_name(&card->pdev->dev), card); |
| 436 |
if (ret) { |
| 437 |
dev_alert(&card->pdev->dev, |
| 438 |
"request_threaded_irq(%u) failed\n", |
| 439 |
card->irq.nr); |
| 440 |
return ret; |
| 441 |
} |
| 442 |
card->irq.requested = 1; |
| 443 |
} |
| 444 |
return 0; |
| 445 |
} |
| 446 |
|
| 447 |
static void softing_card_shutdown(struct softing *card) |
| 448 |
{ |
| 449 |
int fw_up = 0; |
| 450 |
|
| 451 |
if (mutex_lock_interruptible(&card->fw.lock)) { |
| 452 |
/* return -ERESTARTSYS */; |
| 453 |
} |
| 454 |
fw_up = card->fw.up; |
| 455 |
card->fw.up = 0; |
| 456 |
|
| 457 |
if (card->irq.requested && card->irq.nr) { |
| 458 |
free_irq(card->irq.nr, card); |
| 459 |
card->irq.requested = 0; |
| 460 |
} |
| 461 |
if (fw_up) { |
| 462 |
if (card->pdat->enable_irq) |
| 463 |
card->pdat->enable_irq(card->pdev, 0); |
| 464 |
softing_set_reset_dpram(card); |
| 465 |
if (card->pdat->reset) |
| 466 |
card->pdat->reset(card->pdev, 1); |
| 467 |
} |
| 468 |
mutex_unlock(&card->fw.lock); |
| 469 |
} |
| 470 |
|
| 471 |
static int softing_card_boot(struct softing *card) |
| 472 |
{ |
| 473 |
int ret, j; |
| 474 |
static const uint8_t stream[] = { |
| 475 |
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, }; |
| 476 |
unsigned char back[sizeof(stream)]; |
| 477 |
|
| 478 |
if (mutex_lock_interruptible(&card->fw.lock)) |
| 479 |
return -ERESTARTSYS; |
| 480 |
if (card->fw.up) { |
| 481 |
mutex_unlock(&card->fw.lock); |
| 482 |
return 0; |
| 483 |
} |
| 484 |
/* reset board */ |
| 485 |
if (card->pdat->enable_irq) |
| 486 |
card->pdat->enable_irq(card->pdev, 1); |
| 487 |
/* boot card */ |
| 488 |
softing_set_reset_dpram(card); |
| 489 |
if (card->pdat->reset) |
| 490 |
card->pdat->reset(card->pdev, 1); |
| 491 |
for (j = 0; (j + sizeof(stream)) < card->dpram_size; |
| 492 |
j += sizeof(stream)) { |
| 493 |
|
| 494 |
memcpy_toio(&card->dpram[j], stream, sizeof(stream)); |
| 495 |
/* flush IO cache */ |
| 496 |
mb(); |
| 497 |
memcpy_fromio(back, &card->dpram[j], sizeof(stream)); |
| 498 |
|
| 499 |
if (!memcmp(back, stream, sizeof(stream))) |
| 500 |
continue; |
| 501 |
/* memory is not equal */ |
| 502 |
dev_alert(&card->pdev->dev, "dpram failed at 0x%04x\n", j); |
| 503 |
ret = -EIO; |
| 504 |
goto failed; |
| 505 |
} |
| 506 |
wmb(); |
| 507 |
/* load boot firmware */ |
| 508 |
ret = softing_load_fw(card->pdat->boot.fw, card, card->dpram, |
| 509 |
card->dpram_size, |
| 510 |
card->pdat->boot.offs - card->pdat->boot.addr); |
| 511 |
if (ret < 0) |
| 512 |
goto failed; |
| 513 |
/* load loader firmware */ |
| 514 |
ret = softing_load_fw(card->pdat->load.fw, card, card->dpram, |
| 515 |
card->dpram_size, |
| 516 |
card->pdat->load.offs - card->pdat->load.addr); |
| 517 |
if (ret < 0) |
| 518 |
goto failed; |
| 519 |
|
| 520 |
if (card->pdat->reset) |
| 521 |
card->pdat->reset(card->pdev, 0); |
| 522 |
softing_clr_reset_dpram(card); |
| 523 |
ret = softing_bootloader_command(card, 0, "card boot"); |
| 524 |
if (ret < 0) |
| 525 |
goto failed; |
| 526 |
ret = softing_load_app_fw(card->pdat->app.fw, card); |
| 527 |
if (ret < 0) |
| 528 |
goto failed; |
| 529 |
|
| 530 |
ret = softing_chip_poweron(card); |
| 531 |
if (ret < 0) |
| 532 |
goto failed; |
| 533 |
|
| 534 |
card->fw.up = 1; |
| 535 |
mutex_unlock(&card->fw.lock); |
| 536 |
return 0; |
| 537 |
failed: |
| 538 |
card->fw.up = 0; |
| 539 |
if (card->pdat->enable_irq) |
| 540 |
card->pdat->enable_irq(card->pdev, 0); |
| 541 |
softing_set_reset_dpram(card); |
| 542 |
if (card->pdat->reset) |
| 543 |
card->pdat->reset(card->pdev, 1); |
| 544 |
mutex_unlock(&card->fw.lock); |
| 545 |
return ret; |
| 546 |
} |
| 547 |
|
| 548 |
/* |
| 549 |
* netdev sysfs |
| 550 |
*/ |
| 551 |
static ssize_t show_chip(struct device *dev, struct device_attribute *attr, |
| 552 |
char *buf) |
| 553 |
{ |
| 554 |
struct net_device *ndev = to_net_dev(dev); |
| 555 |
struct softing_priv *priv = netdev2softing(ndev); |
| 556 |
|
| 557 |
return sprintf(buf, "%i\n", priv->chip); |
| 558 |
} |
| 559 |
|
| 560 |
static ssize_t show_output(struct device *dev, struct device_attribute *attr, |
| 561 |
char *buf) |
| 562 |
{ |
| 563 |
struct net_device *ndev = to_net_dev(dev); |
| 564 |
struct softing_priv *priv = netdev2softing(ndev); |
| 565 |
|
| 566 |
return sprintf(buf, "0x%02x\n", priv->output); |
| 567 |
} |
| 568 |
|
| 569 |
static ssize_t store_output(struct device *dev, struct device_attribute *attr, |
| 570 |
const char *buf, size_t count) |
| 571 |
{ |
| 572 |
struct net_device *ndev = to_net_dev(dev); |
| 573 |
struct softing_priv *priv = netdev2softing(ndev); |
| 574 |
struct softing *card = priv->card; |
| 575 |
unsigned long val; |
| 576 |
int ret; |
| 577 |
|
| 578 |
ret = kstrtoul(buf, 0, &val); |
| 579 |
if (ret < 0) |
| 580 |
return ret; |
| 581 |
val &= 0xFF; |
| 582 |
|
| 583 |
ret = mutex_lock_interruptible(&card->fw.lock); |
| 584 |
if (ret) |
| 585 |
return -ERESTARTSYS; |
| 586 |
if (netif_running(ndev)) { |
| 587 |
mutex_unlock(&card->fw.lock); |
| 588 |
return -EBUSY; |
| 589 |
} |
| 590 |
priv->output = val; |
| 591 |
mutex_unlock(&card->fw.lock); |
| 592 |
return count; |
| 593 |
} |
| 594 |
|
| 595 |
static const DEVICE_ATTR(chip, 0444, show_chip, NULL); |
| 596 |
static const DEVICE_ATTR(output, 0644, show_output, store_output); |
| 597 |
|
| 598 |
static const struct attribute *const netdev_sysfs_attrs[] = { |
| 599 |
&dev_attr_chip.attr, |
| 600 |
&dev_attr_output.attr, |
| 601 |
NULL, |
| 602 |
}; |
| 603 |
static const struct attribute_group netdev_sysfs_group = { |
| 604 |
.name = NULL, |
| 605 |
.attrs = (struct attribute **)netdev_sysfs_attrs, |
| 606 |
}; |
| 607 |
|
| 608 |
static const struct net_device_ops softing_netdev_ops = { |
| 609 |
.ndo_open = softing_netdev_open, |
| 610 |
.ndo_stop = softing_netdev_stop, |
| 611 |
.ndo_start_xmit = softing_netdev_start_xmit, |
| 612 |
}; |
| 613 |
|
| 614 |
static const struct ethtool_ops softing_ethtool_ops = { |
| 615 |
.get_ts_info = ethtool_op_get_ts_info, |
| 616 |
}; |
| 617 |
|
| 618 |
static const struct can_bittiming_const softing_btr_const = { |
| 619 |
.name = KBUILD_MODNAME, |
| 620 |
.tseg1_min = 1, |
| 621 |
.tseg1_max = 16, |
| 622 |
.tseg2_min = 1, |
| 623 |
.tseg2_max = 8, |
| 624 |
.sjw_max = 4, /* overruled */ |
| 625 |
.brp_min = 1, |
| 626 |
.brp_max = 32, /* overruled */ |
| 627 |
.brp_inc = 1, |
| 628 |
}; |
| 629 |
|
| 630 |
|
| 631 |
static struct net_device *softing_netdev_create(struct softing *card, |
| 632 |
uint16_t chip_id) |
| 633 |
{ |
| 634 |
struct net_device *netdev; |
| 635 |
struct softing_priv *priv; |
| 636 |
|
| 637 |
netdev = alloc_candev(sizeof(*priv), TX_ECHO_SKB_MAX); |
| 638 |
if (!netdev) { |
| 639 |
dev_alert(&card->pdev->dev, "alloc_candev failed\n"); |
| 640 |
return NULL; |
| 641 |
} |
| 642 |
priv = netdev_priv(netdev); |
| 643 |
priv->netdev = netdev; |
| 644 |
priv->card = card; |
| 645 |
memcpy(&priv->btr_const, &softing_btr_const, sizeof(priv->btr_const)); |
| 646 |
priv->btr_const.brp_max = card->pdat->max_brp; |
| 647 |
priv->btr_const.sjw_max = card->pdat->max_sjw; |
| 648 |
priv->can.bittiming_const = &priv->btr_const; |
| 649 |
priv->can.clock.freq = 8000000; |
| 650 |
priv->chip = chip_id; |
| 651 |
priv->output = softing_default_output(netdev); |
| 652 |
SET_NETDEV_DEV(netdev, &card->pdev->dev); |
| 653 |
|
| 654 |
netdev->flags |= IFF_ECHO; |
| 655 |
netdev->netdev_ops = &softing_netdev_ops; |
| 656 |
netdev->ethtool_ops = &softing_ethtool_ops; |
| 657 |
priv->can.do_set_mode = softing_candev_set_mode; |
| 658 |
priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES; |
| 659 |
|
| 660 |
return netdev; |
| 661 |
} |
| 662 |
|
| 663 |
static int softing_netdev_register(struct net_device *netdev) |
| 664 |
{ |
| 665 |
int ret; |
| 666 |
|
| 667 |
ret = register_candev(netdev); |
| 668 |
if (ret) { |
| 669 |
dev_alert(&netdev->dev, "register failed\n"); |
| 670 |
return ret; |
| 671 |
} |
| 672 |
if (sysfs_create_group(&netdev->dev.kobj, &netdev_sysfs_group) < 0) |
| 673 |
netdev_alert(netdev, "sysfs group failed\n"); |
| 674 |
|
| 675 |
return 0; |
| 676 |
} |
| 677 |
|
| 678 |
static void softing_netdev_cleanup(struct net_device *netdev) |
| 679 |
{ |
| 680 |
sysfs_remove_group(&netdev->dev.kobj, &netdev_sysfs_group); |
| 681 |
unregister_candev(netdev); |
| 682 |
free_candev(netdev); |
| 683 |
} |
| 684 |
|
| 685 |
/* |
| 686 |
* sysfs for Platform device |
| 687 |
*/ |
| 688 |
#define DEV_ATTR_RO(name, member) \ |
| 689 |
static ssize_t show_##name(struct device *dev, \ |
| 690 |
struct device_attribute *attr, char *buf) \ |
| 691 |
{ \ |
| 692 |
struct softing *card = dev_get_drvdata(dev); \ |
| 693 |
return sprintf(buf, "%u\n", card->member); \ |
| 694 |
} \ |
| 695 |
static DEVICE_ATTR(name, 0444, show_##name, NULL) |
| 696 |
|
| 697 |
#define DEV_ATTR_RO_STR(name, member) \ |
| 698 |
static ssize_t show_##name(struct device *dev, \ |
| 699 |
struct device_attribute *attr, char *buf) \ |
| 700 |
{ \ |
| 701 |
struct softing *card = dev_get_drvdata(dev); \ |
| 702 |
return sprintf(buf, "%s\n", card->member); \ |
| 703 |
} \ |
| 704 |
static DEVICE_ATTR(name, 0444, show_##name, NULL) |
| 705 |
|
| 706 |
DEV_ATTR_RO(serial, id.serial); |
| 707 |
DEV_ATTR_RO_STR(firmware, pdat->app.fw); |
| 708 |
DEV_ATTR_RO(firmware_version, id.fw_version); |
| 709 |
DEV_ATTR_RO_STR(hardware, pdat->name); |
| 710 |
DEV_ATTR_RO(hardware_version, id.hw_version); |
| 711 |
DEV_ATTR_RO(license, id.license); |
| 712 |
|
| 713 |
static struct attribute *softing_pdev_attrs[] = { |
| 714 |
&dev_attr_serial.attr, |
| 715 |
&dev_attr_firmware.attr, |
| 716 |
&dev_attr_firmware_version.attr, |
| 717 |
&dev_attr_hardware.attr, |
| 718 |
&dev_attr_hardware_version.attr, |
| 719 |
&dev_attr_license.attr, |
| 720 |
NULL, |
| 721 |
}; |
| 722 |
|
| 723 |
static const struct attribute_group softing_pdev_group = { |
| 724 |
.name = NULL, |
| 725 |
.attrs = softing_pdev_attrs, |
| 726 |
}; |
| 727 |
|
| 728 |
/* |
| 729 |
* platform driver |
| 730 |
*/ |
| 731 |
static void softing_pdev_remove(struct platform_device *pdev) |
| 732 |
{ |
| 733 |
struct softing *card = platform_get_drvdata(pdev); |
| 734 |
int j; |
| 735 |
|
| 736 |
/* first, disable card*/ |
| 737 |
softing_card_shutdown(card); |
| 738 |
|
| 739 |
for (j = 0; j < ARRAY_SIZE(card->net); ++j) { |
| 740 |
if (!card->net[j]) |
| 741 |
continue; |
| 742 |
softing_netdev_cleanup(card->net[j]); |
| 743 |
card->net[j] = NULL; |
| 744 |
} |
| 745 |
sysfs_remove_group(&pdev->dev.kobj, &softing_pdev_group); |
| 746 |
|
| 747 |
iounmap(card->dpram); |
| 748 |
kfree(card); |
| 749 |
} |
| 750 |
|
| 751 |
static int softing_pdev_probe(struct platform_device *pdev) |
| 752 |
{ |
| 753 |
const struct softing_platform_data *pdat = dev_get_platdata(&pdev->dev); |
| 754 |
struct softing *card; |
| 755 |
struct net_device *netdev; |
| 756 |
struct softing_priv *priv; |
| 757 |
struct resource *pres; |
| 758 |
int ret; |
| 759 |
int j; |
| 760 |
|
| 761 |
if (!pdat) { |
| 762 |
dev_warn(&pdev->dev, "no platform data\n"); |
| 763 |
return -EINVAL; |
| 764 |
} |
| 765 |
if (pdat->nbus > ARRAY_SIZE(card->net)) { |
| 766 |
dev_warn(&pdev->dev, "%u nets??\n", pdat->nbus); |
| 767 |
return -EINVAL; |
| 768 |
} |
| 769 |
|
| 770 |
card = kzalloc_obj(*card); |
| 771 |
if (!card) |
| 772 |
return -ENOMEM; |
| 773 |
card->pdat = pdat; |
| 774 |
card->pdev = pdev; |
| 775 |
platform_set_drvdata(pdev, card); |
| 776 |
mutex_init(&card->fw.lock); |
| 777 |
spin_lock_init(&card->spin); |
| 778 |
|
| 779 |
ret = -EINVAL; |
| 780 |
pres = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 781 |
if (!pres) |
| 782 |
goto platform_resource_failed; |
| 783 |
card->dpram_phys = pres->start; |
| 784 |
card->dpram_size = resource_size(pres); |
| 785 |
card->dpram = ioremap(card->dpram_phys, card->dpram_size); |
| 786 |
if (!card->dpram) { |
| 787 |
dev_alert(&card->pdev->dev, "dpram ioremap failed\n"); |
| 788 |
goto ioremap_failed; |
| 789 |
} |
| 790 |
|
| 791 |
pres = platform_get_resource(pdev, IORESOURCE_IRQ, 0); |
| 792 |
if (pres) |
| 793 |
card->irq.nr = pres->start; |
| 794 |
|
| 795 |
/* reset card */ |
| 796 |
ret = softing_card_boot(card); |
| 797 |
if (ret < 0) { |
| 798 |
dev_alert(&pdev->dev, "failed to boot\n"); |
| 799 |
goto boot_failed; |
| 800 |
} |
| 801 |
|
| 802 |
/* only now, the chip's are known */ |
| 803 |
card->id.freq = card->pdat->freq; |
| 804 |
|
| 805 |
ret = sysfs_create_group(&pdev->dev.kobj, &softing_pdev_group); |
| 806 |
if (ret < 0) { |
| 807 |
dev_alert(&card->pdev->dev, "sysfs failed\n"); |
| 808 |
goto sysfs_failed; |
| 809 |
} |
| 810 |
|
| 811 |
for (j = 0; j < ARRAY_SIZE(card->net); ++j) { |
| 812 |
card->net[j] = netdev = |
| 813 |
softing_netdev_create(card, card->id.chip[j]); |
| 814 |
if (!netdev) { |
| 815 |
dev_alert(&pdev->dev, "failed to make can[%i]", j); |
| 816 |
ret = -ENOMEM; |
| 817 |
goto netdev_failed; |
| 818 |
} |
| 819 |
netdev->dev_id = j; |
| 820 |
priv = netdev_priv(card->net[j]); |
| 821 |
priv->index = j; |
| 822 |
ret = softing_netdev_register(netdev); |
| 823 |
if (ret) { |
| 824 |
free_candev(netdev); |
| 825 |
card->net[j] = NULL; |
| 826 |
dev_alert(&card->pdev->dev, |
| 827 |
"failed to register can[%i]\n", j); |
| 828 |
goto netdev_failed; |
| 829 |
} |
| 830 |
} |
| 831 |
dev_info(&card->pdev->dev, "%s ready.\n", card->pdat->name); |
| 832 |
return 0; |
| 833 |
|
| 834 |
netdev_failed: |
| 835 |
for (j = 0; j < ARRAY_SIZE(card->net); ++j) { |
| 836 |
if (!card->net[j]) |
| 837 |
continue; |
| 838 |
softing_netdev_cleanup(card->net[j]); |
| 839 |
} |
| 840 |
sysfs_remove_group(&pdev->dev.kobj, &softing_pdev_group); |
| 841 |
sysfs_failed: |
| 842 |
softing_card_shutdown(card); |
| 843 |
boot_failed: |
| 844 |
iounmap(card->dpram); |
| 845 |
ioremap_failed: |
| 846 |
platform_resource_failed: |
| 847 |
kfree(card); |
| 848 |
return ret; |
| 849 |
} |
| 850 |
|
| 851 |
static struct platform_driver softing_driver = { |
| 852 |
.driver = { |
| 853 |
.name = KBUILD_MODNAME, |
| 854 |
}, |
| 855 |
.probe = softing_pdev_probe, |
| 856 |
.remove = softing_pdev_remove, |
| 857 |
}; |
| 858 |
|
| 859 |
module_platform_driver(softing_driver); |
| 860 |
|
| 861 |
MODULE_ALIAS("platform:softing"); |
| 862 |
MODULE_DESCRIPTION("Softing DPRAM CAN driver"); |
| 863 |
MODULE_AUTHOR("Kurt Van Dijck <[email protected]>"); |
| 864 |
MODULE_LICENSE("GPL v2"); |