Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
softing_fw.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2008-2010
3  *
4  * - Kurt Van Dijck, EIA Electronics
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the version 2 of the GNU General Public License
8  * as published by the Free Software Foundation
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  */
19 
20 #include <linux/firmware.h>
21 #include <linux/sched.h>
22 #include <asm/div64.h>
23 #include <asm/io.h>
24 
25 #include "softing.h"
26 
27 /*
28  * low level DPRAM command.
29  * Make sure that card->dpram[DPRAM_FCT_HOST] is preset
30  */
31 static int _softing_fct_cmd(struct softing *card, int16_t cmd, uint16_t vector,
32  const char *msg)
33 {
34  int ret;
35  unsigned long stamp;
36 
37  iowrite16(cmd, &card->dpram[DPRAM_FCT_PARAM]);
38  iowrite8(vector >> 8, &card->dpram[DPRAM_FCT_HOST + 1]);
39  iowrite8(vector, &card->dpram[DPRAM_FCT_HOST]);
40  /* be sure to flush this to the card */
41  wmb();
42  stamp = jiffies + 1 * HZ;
43  /* wait for card */
44  do {
45  /* DPRAM_FCT_HOST is _not_ aligned */
46  ret = ioread8(&card->dpram[DPRAM_FCT_HOST]) +
47  (ioread8(&card->dpram[DPRAM_FCT_HOST + 1]) << 8);
48  /* don't have any cached variables */
49  rmb();
50  if (ret == RES_OK)
51  /* read return-value now */
52  return ioread16(&card->dpram[DPRAM_FCT_RESULT]);
53 
54  if ((ret != vector) || time_after(jiffies, stamp))
55  break;
56  /* process context => relax */
57  usleep_range(500, 10000);
58  } while (1);
59 
60  ret = (ret == RES_NONE) ? -ETIMEDOUT : -ECANCELED;
61  dev_alert(&card->pdev->dev, "firmware %s failed (%i)\n", msg, ret);
62  return ret;
63 }
64 
65 static int softing_fct_cmd(struct softing *card, int16_t cmd, const char *msg)
66 {
67  int ret;
68 
69  ret = _softing_fct_cmd(card, cmd, 0, msg);
70  if (ret > 0) {
71  dev_alert(&card->pdev->dev, "%s returned %u\n", msg, ret);
72  ret = -EIO;
73  }
74  return ret;
75 }
76 
78  const char *msg)
79 {
80  int ret;
81  unsigned long stamp;
82 
84  iowrite16(cmd, &card->dpram[DPRAM_COMMAND]);
85  /* be sure to flush this to the card */
86  wmb();
87  stamp = jiffies + 3 * HZ;
88  /* wait for card */
89  do {
90  ret = ioread16(&card->dpram[DPRAM_RECEIPT]);
91  /* don't have any cached variables */
92  rmb();
93  if (ret == RES_OK)
94  return 0;
95  if (time_after(jiffies, stamp))
96  break;
97  /* process context => relax */
98  usleep_range(500, 10000);
99  } while (!signal_pending(current));
100 
101  ret = (ret == RES_NONE) ? -ETIMEDOUT : -ECANCELED;
102  dev_alert(&card->pdev->dev, "bootloader %s failed (%i)\n", msg, ret);
103  return ret;
104 }
105 
106 static int fw_parse(const uint8_t **pmem, uint16_t *ptype, uint32_t *paddr,
107  uint16_t *plen, const uint8_t **pdat)
108 {
109  uint16_t checksum[2];
110  const uint8_t *mem;
111  const uint8_t *end;
112 
113  /*
114  * firmware records are a binary, unaligned stream composed of:
115  * uint16_t type;
116  * uint32_t addr;
117  * uint16_t len;
118  * uint8_t dat[len];
119  * uint16_t checksum;
120  * all values in little endian.
121  * We could define a struct for this, with __attribute__((packed)),
122  * but would that solve the alignment in _all_ cases (cfr. the
123  * struct itself may be an odd address)?
124  *
125  * I chose to use leXX_to_cpup() since this solves both
126  * endianness & alignment.
127  */
128  mem = *pmem;
129  *ptype = le16_to_cpup((void *)&mem[0]);
130  *paddr = le32_to_cpup((void *)&mem[2]);
131  *plen = le16_to_cpup((void *)&mem[6]);
132  *pdat = &mem[8];
133  /* verify checksum */
134  end = &mem[8 + *plen];
135  checksum[0] = le16_to_cpup((void *)end);
136  for (checksum[1] = 0; mem < end; ++mem)
137  checksum[1] += *mem;
138  if (checksum[0] != checksum[1])
139  return -EINVAL;
140  /* increment */
141  *pmem += 10 + *plen;
142  return 0;
143 }
144 
145 int softing_load_fw(const char *file, struct softing *card,
146  __iomem uint8_t *dpram, unsigned int size, int offset)
147 {
148  const struct firmware *fw;
149  int ret;
150  const uint8_t *mem, *end, *dat;
151  uint16_t type, len;
152  uint32_t addr;
153  uint8_t *buf = NULL, *new_buf;
154  int buflen = 0;
155  int8_t type_end = 0;
156 
157  ret = request_firmware(&fw, file, &card->pdev->dev);
158  if (ret < 0)
159  return ret;
160  dev_dbg(&card->pdev->dev, "%s, firmware(%s) got %u bytes"
161  ", offset %c0x%04x\n",
162  card->pdat->name, file, (unsigned int)fw->size,
163  (offset >= 0) ? '+' : '-', (unsigned int)abs(offset));
164  /* parse the firmware */
165  mem = fw->data;
166  end = &mem[fw->size];
167  /* look for header record */
168  ret = fw_parse(&mem, &type, &addr, &len, &dat);
169  if (ret < 0)
170  goto failed;
171  if (type != 0xffff)
172  goto failed;
173  if (strncmp("Structured Binary Format, Softing GmbH" , dat, len)) {
174  ret = -EINVAL;
175  goto failed;
176  }
177  /* ok, we had a header */
178  while (mem < end) {
179  ret = fw_parse(&mem, &type, &addr, &len, &dat);
180  if (ret < 0)
181  goto failed;
182  if (type == 3) {
183  /* start address, not used here */
184  continue;
185  } else if (type == 1) {
186  /* eof */
187  type_end = 1;
188  break;
189  } else if (type != 0) {
190  ret = -EINVAL;
191  goto failed;
192  }
193 
194  if ((addr + len + offset) > size)
195  goto failed;
196  memcpy_toio(&dpram[addr + offset], dat, len);
197  /* be sure to flush caches from IO space */
198  mb();
199  if (len > buflen) {
200  /* align buflen */
201  buflen = (len + (1024-1)) & ~(1024-1);
202  new_buf = krealloc(buf, buflen, GFP_KERNEL);
203  if (!new_buf) {
204  ret = -ENOMEM;
205  goto failed;
206  }
207  buf = new_buf;
208  }
209  /* verify record data */
210  memcpy_fromio(buf, &dpram[addr + offset], len);
211  if (memcmp(buf, dat, len)) {
212  /* is not ok */
213  dev_alert(&card->pdev->dev, "DPRAM readback failed\n");
214  ret = -EIO;
215  goto failed;
216  }
217  }
218  if (!type_end)
219  /* no end record seen */
220  goto failed;
221  ret = 0;
222 failed:
223  kfree(buf);
224  release_firmware(fw);
225  if (ret < 0)
226  dev_info(&card->pdev->dev, "firmware %s failed\n", file);
227  return ret;
228 }
229 
230 int softing_load_app_fw(const char *file, struct softing *card)
231 {
232  const struct firmware *fw;
233  const uint8_t *mem, *end, *dat;
234  int ret, j;
235  uint16_t type, len;
236  uint32_t addr, start_addr = 0;
237  unsigned int sum, rx_sum;
238  int8_t type_end = 0, type_entrypoint = 0;
239 
240  ret = request_firmware(&fw, file, &card->pdev->dev);
241  if (ret) {
242  dev_alert(&card->pdev->dev, "request_firmware(%s) got %i\n",
243  file, ret);
244  return ret;
245  }
246  dev_dbg(&card->pdev->dev, "firmware(%s) got %lu bytes\n",
247  file, (unsigned long)fw->size);
248  /* parse the firmware */
249  mem = fw->data;
250  end = &mem[fw->size];
251  /* look for header record */
252  ret = fw_parse(&mem, &type, &addr, &len, &dat);
253  if (ret)
254  goto failed;
255  ret = -EINVAL;
256  if (type != 0xffff) {
257  dev_alert(&card->pdev->dev, "firmware starts with type 0x%x\n",
258  type);
259  goto failed;
260  }
261  if (strncmp("Structured Binary Format, Softing GmbH", dat, len)) {
262  dev_alert(&card->pdev->dev, "firmware string '%.*s' fault\n",
263  len, dat);
264  goto failed;
265  }
266  /* ok, we had a header */
267  while (mem < end) {
268  ret = fw_parse(&mem, &type, &addr, &len, &dat);
269  if (ret)
270  goto failed;
271 
272  if (type == 3) {
273  /* start address */
274  start_addr = addr;
275  type_entrypoint = 1;
276  continue;
277  } else if (type == 1) {
278  /* eof */
279  type_end = 1;
280  break;
281  } else if (type != 0) {
282  dev_alert(&card->pdev->dev,
283  "unknown record type 0x%04x\n", type);
284  ret = -EINVAL;
285  goto failed;
286  }
287 
288  /* regualar data */
289  for (sum = 0, j = 0; j < len; ++j)
290  sum += dat[j];
291  /* work in 16bit (target) */
292  sum &= 0xffff;
293 
294  memcpy_toio(&card->dpram[card->pdat->app.offs], dat, len);
295  iowrite32(card->pdat->app.offs + card->pdat->app.addr,
296  &card->dpram[DPRAM_COMMAND + 2]);
297  iowrite32(addr, &card->dpram[DPRAM_COMMAND + 6]);
298  iowrite16(len, &card->dpram[DPRAM_COMMAND + 10]);
299  iowrite8(1, &card->dpram[DPRAM_COMMAND + 12]);
300  ret = softing_bootloader_command(card, 1, "loading app.");
301  if (ret < 0)
302  goto failed;
303  /* verify checksum */
304  rx_sum = ioread16(&card->dpram[DPRAM_RECEIPT + 2]);
305  if (rx_sum != sum) {
306  dev_alert(&card->pdev->dev, "SRAM seems to be damaged"
307  ", wanted 0x%04x, got 0x%04x\n", sum, rx_sum);
308  ret = -EIO;
309  goto failed;
310  }
311  }
312  if (!type_end || !type_entrypoint)
313  goto failed;
314  /* start application in card */
315  iowrite32(start_addr, &card->dpram[DPRAM_COMMAND + 2]);
316  iowrite8(1, &card->dpram[DPRAM_COMMAND + 6]);
317  ret = softing_bootloader_command(card, 3, "start app.");
318  if (ret < 0)
319  goto failed;
320  ret = 0;
321 failed:
322  release_firmware(fw);
323  if (ret < 0)
324  dev_info(&card->pdev->dev, "firmware %s failed\n", file);
325  return ret;
326 }
327 
328 static int softing_reset_chip(struct softing *card)
329 {
330  int ret;
331 
332  do {
333  /* reset chip */
334  iowrite8(0, &card->dpram[DPRAM_RESET_RX_FIFO]);
335  iowrite8(0, &card->dpram[DPRAM_RESET_RX_FIFO+1]);
336  iowrite8(1, &card->dpram[DPRAM_RESET]);
337  iowrite8(0, &card->dpram[DPRAM_RESET+1]);
338 
339  ret = softing_fct_cmd(card, 0, "reset_can");
340  if (!ret)
341  break;
342  if (signal_pending(current))
343  /* don't wait any longer */
344  break;
345  } while (1);
346  card->tx.pending = 0;
347  return ret;
348 }
349 
350 int softing_chip_poweron(struct softing *card)
351 {
352  int ret;
353  /* sync */
354  ret = _softing_fct_cmd(card, 99, 0x55, "sync-a");
355  if (ret < 0)
356  goto failed;
357 
358  ret = _softing_fct_cmd(card, 99, 0xaa, "sync-b");
359  if (ret < 0)
360  goto failed;
361 
362  ret = softing_reset_chip(card);
363  if (ret < 0)
364  goto failed;
365  /* get_serial */
366  ret = softing_fct_cmd(card, 43, "get_serial_number");
367  if (ret < 0)
368  goto failed;
369  card->id.serial = ioread32(&card->dpram[DPRAM_FCT_PARAM]);
370  /* get_version */
371  ret = softing_fct_cmd(card, 12, "get_version");
372  if (ret < 0)
373  goto failed;
374  card->id.fw_version = ioread16(&card->dpram[DPRAM_FCT_PARAM + 2]);
375  card->id.hw_version = ioread16(&card->dpram[DPRAM_FCT_PARAM + 4]);
376  card->id.license = ioread16(&card->dpram[DPRAM_FCT_PARAM + 6]);
377  card->id.chip[0] = ioread16(&card->dpram[DPRAM_FCT_PARAM + 8]);
378  card->id.chip[1] = ioread16(&card->dpram[DPRAM_FCT_PARAM + 10]);
379  return 0;
380 failed:
381  return ret;
382 }
383 
384 static void softing_initialize_timestamp(struct softing *card)
385 {
386  uint64_t ovf;
387 
388  card->ts_ref = ktime_get();
389 
390  /* 16MHz is the reference */
391  ovf = 0x100000000ULL * 16;
392  do_div(ovf, card->pdat->freq ?: 16);
393 
394  card->ts_overflow = ktime_add_us(ktime_set(0, 0), ovf);
395 }
396 
398 {
399  uint64_t rawl;
400  ktime_t now, real_offset;
401  ktime_t target;
402  ktime_t tmp;
403 
404  now = ktime_get();
405  real_offset = ktime_sub(ktime_get_real(), now);
406 
407  /* find nsec from card */
408  rawl = raw * 16;
409  do_div(rawl, card->pdat->freq ?: 16);
410  target = ktime_add_us(card->ts_ref, rawl);
411  /* test for overflows */
412  tmp = ktime_add(target, card->ts_overflow);
413  while (unlikely(ktime_to_ns(tmp) > ktime_to_ns(now))) {
414  card->ts_ref = ktime_add(card->ts_ref, card->ts_overflow);
415  target = tmp;
416  tmp = ktime_add(target, card->ts_overflow);
417  }
418  return ktime_add(target, real_offset);
419 }
420 
421 static inline int softing_error_reporting(struct net_device *netdev)
422 {
423  struct softing_priv *priv = netdev_priv(netdev);
424 
425  return (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
426  ? 1 : 0;
427 }
428 
430 {
431  int ret;
432  struct softing *card;
433  struct softing_priv *priv;
434  struct net_device *netdev;
435  int bus_bitmask_start;
436  int j, error_reporting;
437  struct can_frame msg;
438  const struct can_bittiming *bt;
439 
440  priv = netdev_priv(dev);
441  card = priv->card;
442 
443  if (!card->fw.up)
444  return -EIO;
445 
446  ret = mutex_lock_interruptible(&card->fw.lock);
447  if (ret)
448  return ret;
449 
450  bus_bitmask_start = 0;
451  if (dev && up)
452  /* prepare to start this bus as well */
453  bus_bitmask_start |= (1 << priv->index);
454  /* bring netdevs down */
455  for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
456  netdev = card->net[j];
457  if (!netdev)
458  continue;
459  priv = netdev_priv(netdev);
460 
461  if (dev != netdev)
462  netif_stop_queue(netdev);
463 
464  if (netif_running(netdev)) {
465  if (dev != netdev)
466  bus_bitmask_start |= (1 << j);
467  priv->tx.pending = 0;
468  priv->tx.echo_put = 0;
469  priv->tx.echo_get = 0;
470  /*
471  * this bus' may just have called open_candev()
472  * which is rather stupid to call close_candev()
473  * already
474  * but we may come here from busoff recovery too
475  * in which case the echo_skb _needs_ flushing too.
476  * just be sure to call open_candev() again
477  */
478  close_candev(netdev);
479  }
480  priv->can.state = CAN_STATE_STOPPED;
481  }
482  card->tx.pending = 0;
483 
484  softing_enable_irq(card, 0);
485  ret = softing_reset_chip(card);
486  if (ret)
487  goto failed;
488  if (!bus_bitmask_start)
489  /* no busses to be brought up */
490  goto card_done;
491 
492  if ((bus_bitmask_start & 1) && (bus_bitmask_start & 2)
493  && (softing_error_reporting(card->net[0])
494  != softing_error_reporting(card->net[1]))) {
495  dev_alert(&card->pdev->dev,
496  "err_reporting flag differs for busses\n");
497  goto invalid;
498  }
499  error_reporting = 0;
500  if (bus_bitmask_start & 1) {
501  netdev = card->net[0];
502  priv = netdev_priv(netdev);
503  error_reporting += softing_error_reporting(netdev);
504  /* init chip 1 */
505  bt = &priv->can.bittiming;
506  iowrite16(bt->brp, &card->dpram[DPRAM_FCT_PARAM + 2]);
507  iowrite16(bt->sjw, &card->dpram[DPRAM_FCT_PARAM + 4]);
508  iowrite16(bt->phase_seg1 + bt->prop_seg,
509  &card->dpram[DPRAM_FCT_PARAM + 6]);
510  iowrite16(bt->phase_seg2, &card->dpram[DPRAM_FCT_PARAM + 8]);
511  iowrite16((priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 1 : 0,
512  &card->dpram[DPRAM_FCT_PARAM + 10]);
513  ret = softing_fct_cmd(card, 1, "initialize_chip[0]");
514  if (ret < 0)
515  goto failed;
516  /* set mode */
517  iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 2]);
518  iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 4]);
519  ret = softing_fct_cmd(card, 3, "set_mode[0]");
520  if (ret < 0)
521  goto failed;
522  /* set filter */
523  /* 11bit id & mask */
524  iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]);
525  iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]);
526  /* 29bit id.lo & mask.lo & id.hi & mask.hi */
527  iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 6]);
528  iowrite16(0xffff, &card->dpram[DPRAM_FCT_PARAM + 8]);
529  iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 10]);
530  iowrite16(0x1fff, &card->dpram[DPRAM_FCT_PARAM + 12]);
531  ret = softing_fct_cmd(card, 7, "set_filter[0]");
532  if (ret < 0)
533  goto failed;
534  /* set output control */
535  iowrite16(priv->output, &card->dpram[DPRAM_FCT_PARAM + 2]);
536  ret = softing_fct_cmd(card, 5, "set_output[0]");
537  if (ret < 0)
538  goto failed;
539  }
540  if (bus_bitmask_start & 2) {
541  netdev = card->net[1];
542  priv = netdev_priv(netdev);
543  error_reporting += softing_error_reporting(netdev);
544  /* init chip2 */
545  bt = &priv->can.bittiming;
546  iowrite16(bt->brp, &card->dpram[DPRAM_FCT_PARAM + 2]);
547  iowrite16(bt->sjw, &card->dpram[DPRAM_FCT_PARAM + 4]);
548  iowrite16(bt->phase_seg1 + bt->prop_seg,
549  &card->dpram[DPRAM_FCT_PARAM + 6]);
550  iowrite16(bt->phase_seg2, &card->dpram[DPRAM_FCT_PARAM + 8]);
551  iowrite16((priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 1 : 0,
552  &card->dpram[DPRAM_FCT_PARAM + 10]);
553  ret = softing_fct_cmd(card, 2, "initialize_chip[1]");
554  if (ret < 0)
555  goto failed;
556  /* set mode2 */
557  iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 2]);
558  iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 4]);
559  ret = softing_fct_cmd(card, 4, "set_mode[1]");
560  if (ret < 0)
561  goto failed;
562  /* set filter2 */
563  /* 11bit id & mask */
564  iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]);
565  iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]);
566  /* 29bit id.lo & mask.lo & id.hi & mask.hi */
567  iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 6]);
568  iowrite16(0xffff, &card->dpram[DPRAM_FCT_PARAM + 8]);
569  iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 10]);
570  iowrite16(0x1fff, &card->dpram[DPRAM_FCT_PARAM + 12]);
571  ret = softing_fct_cmd(card, 8, "set_filter[1]");
572  if (ret < 0)
573  goto failed;
574  /* set output control2 */
575  iowrite16(priv->output, &card->dpram[DPRAM_FCT_PARAM + 2]);
576  ret = softing_fct_cmd(card, 6, "set_output[1]");
577  if (ret < 0)
578  goto failed;
579  }
580  /* enable_error_frame */
581  /*
582  * Error reporting is switched off at the moment since
583  * the receiving of them is not yet 100% verified
584  * This should be enabled sooner or later
585  *
586  if (error_reporting) {
587  ret = softing_fct_cmd(card, 51, "enable_error_frame");
588  if (ret < 0)
589  goto failed;
590  }
591  */
592  /* initialize interface */
593  iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 2]);
594  iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 4]);
595  iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 6]);
596  iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 8]);
597  iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 10]);
598  iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 12]);
599  iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 14]);
600  iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 16]);
601  iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 18]);
602  iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 20]);
603  ret = softing_fct_cmd(card, 17, "initialize_interface");
604  if (ret < 0)
605  goto failed;
606  /* enable_fifo */
607  ret = softing_fct_cmd(card, 36, "enable_fifo");
608  if (ret < 0)
609  goto failed;
610  /* enable fifo tx ack */
611  ret = softing_fct_cmd(card, 13, "fifo_tx_ack[0]");
612  if (ret < 0)
613  goto failed;
614  /* enable fifo tx ack2 */
615  ret = softing_fct_cmd(card, 14, "fifo_tx_ack[1]");
616  if (ret < 0)
617  goto failed;
618  /* start_chip */
619  ret = softing_fct_cmd(card, 11, "start_chip");
620  if (ret < 0)
621  goto failed;
622  iowrite8(0, &card->dpram[DPRAM_INFO_BUSSTATE]);
623  iowrite8(0, &card->dpram[DPRAM_INFO_BUSSTATE2]);
624  if (card->pdat->generation < 2) {
625  iowrite8(0, &card->dpram[DPRAM_V2_IRQ_TOHOST]);
626  /* flush the DPRAM caches */
627  wmb();
628  }
629 
630  softing_initialize_timestamp(card);
631 
632  /*
633  * do socketcan notifications/status changes
634  * from here, no errors should occur, or the failed: part
635  * must be reviewed
636  */
637  memset(&msg, 0, sizeof(msg));
639  msg.can_dlc = CAN_ERR_DLC;
640  for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
641  if (!(bus_bitmask_start & (1 << j)))
642  continue;
643  netdev = card->net[j];
644  if (!netdev)
645  continue;
646  priv = netdev_priv(netdev);
647  priv->can.state = CAN_STATE_ERROR_ACTIVE;
648  open_candev(netdev);
649  if (dev != netdev) {
650  /* notify other busses on the restart */
651  softing_netdev_rx(netdev, &msg, ktime_set(0, 0));
652  ++priv->can.can_stats.restarts;
653  }
654  netif_wake_queue(netdev);
655  }
656 
657  /* enable interrupts */
658  ret = softing_enable_irq(card, 1);
659  if (ret)
660  goto failed;
661 card_done:
662  mutex_unlock(&card->fw.lock);
663  return 0;
664 invalid:
665  ret = -EINVAL;
666 failed:
667  softing_enable_irq(card, 0);
668  softing_reset_chip(card);
669  mutex_unlock(&card->fw.lock);
670  /* bring all other interfaces down */
671  for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
672  netdev = card->net[j];
673  if (!netdev)
674  continue;
675  dev_close(netdev);
676  }
677  return ret;
678 }
679 
681 {
682  struct softing_priv *priv = netdev_priv(netdev);
683  struct softing *card = priv->card;
684 
685  switch (priv->chip) {
686  case 1000:
687  return (card->pdat->generation < 2) ? 0xfb : 0xfa;
688  case 5:
689  return 0x60;
690  default:
691  return 0x40;
692  }
693 }