Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2008-2010
0004  *
0005  * - Kurt Van Dijck, EIA Electronics
0006  */
0007 
0008 #include <linux/firmware.h>
0009 #include <linux/sched/signal.h>
0010 #include <asm/div64.h>
0011 #include <asm/io.h>
0012 
0013 #include "softing.h"
0014 
0015 /*
0016  * low level DPRAM command.
0017  * Make sure that card->dpram[DPRAM_FCT_HOST] is preset
0018  */
0019 static int _softing_fct_cmd(struct softing *card, int16_t cmd, uint16_t vector,
0020         const char *msg)
0021 {
0022     int ret;
0023     unsigned long stamp;
0024 
0025     iowrite16(cmd, &card->dpram[DPRAM_FCT_PARAM]);
0026     iowrite8(vector >> 8, &card->dpram[DPRAM_FCT_HOST + 1]);
0027     iowrite8(vector, &card->dpram[DPRAM_FCT_HOST]);
0028     /* be sure to flush this to the card */
0029     wmb();
0030     stamp = jiffies + 1 * HZ;
0031     /* wait for card */
0032     do {
0033         /* DPRAM_FCT_HOST is _not_ aligned */
0034         ret = ioread8(&card->dpram[DPRAM_FCT_HOST]) +
0035             (ioread8(&card->dpram[DPRAM_FCT_HOST + 1]) << 8);
0036         /* don't have any cached variables */
0037         rmb();
0038         if (ret == RES_OK)
0039             /* read return-value now */
0040             return ioread16(&card->dpram[DPRAM_FCT_RESULT]);
0041 
0042         if ((ret != vector) || time_after(jiffies, stamp))
0043             break;
0044         /* process context => relax */
0045         usleep_range(500, 10000);
0046     } while (1);
0047 
0048     ret = (ret == RES_NONE) ? -ETIMEDOUT : -ECANCELED;
0049     dev_alert(&card->pdev->dev, "firmware %s failed (%i)\n", msg, ret);
0050     return ret;
0051 }
0052 
0053 static int softing_fct_cmd(struct softing *card, int16_t cmd, const char *msg)
0054 {
0055     int ret;
0056 
0057     ret = _softing_fct_cmd(card, cmd, 0, msg);
0058     if (ret > 0) {
0059         dev_alert(&card->pdev->dev, "%s returned %u\n", msg, ret);
0060         ret = -EIO;
0061     }
0062     return ret;
0063 }
0064 
0065 int softing_bootloader_command(struct softing *card, int16_t cmd,
0066         const char *msg)
0067 {
0068     int ret;
0069     unsigned long stamp;
0070 
0071     iowrite16(RES_NONE, &card->dpram[DPRAM_RECEIPT]);
0072     iowrite16(cmd, &card->dpram[DPRAM_COMMAND]);
0073     /* be sure to flush this to the card */
0074     wmb();
0075     stamp = jiffies + 3 * HZ;
0076     /* wait for card */
0077     do {
0078         ret = ioread16(&card->dpram[DPRAM_RECEIPT]);
0079         /* don't have any cached variables */
0080         rmb();
0081         if (ret == RES_OK)
0082             return 0;
0083         if (time_after(jiffies, stamp))
0084             break;
0085         /* process context => relax */
0086         usleep_range(500, 10000);
0087     } while (!signal_pending(current));
0088 
0089     ret = (ret == RES_NONE) ? -ETIMEDOUT : -ECANCELED;
0090     dev_alert(&card->pdev->dev, "bootloader %s failed (%i)\n", msg, ret);
0091     return ret;
0092 }
0093 
0094 static int fw_parse(const uint8_t **pmem, uint16_t *ptype, uint32_t *paddr,
0095         uint16_t *plen, const uint8_t **pdat)
0096 {
0097     uint16_t checksum[2];
0098     const uint8_t *mem;
0099     const uint8_t *end;
0100 
0101     /*
0102      * firmware records are a binary, unaligned stream composed of:
0103      * uint16_t type;
0104      * uint32_t addr;
0105      * uint16_t len;
0106      * uint8_t dat[len];
0107      * uint16_t checksum;
0108      * all values in little endian.
0109      * We could define a struct for this, with __attribute__((packed)),
0110      * but would that solve the alignment in _all_ cases (cfr. the
0111      * struct itself may be an odd address)?
0112      *
0113      * I chose to use leXX_to_cpup() since this solves both
0114      * endianness & alignment.
0115      */
0116     mem = *pmem;
0117     *ptype = le16_to_cpup((void *)&mem[0]);
0118     *paddr = le32_to_cpup((void *)&mem[2]);
0119     *plen = le16_to_cpup((void *)&mem[6]);
0120     *pdat = &mem[8];
0121     /* verify checksum */
0122     end = &mem[8 + *plen];
0123     checksum[0] = le16_to_cpup((void *)end);
0124     for (checksum[1] = 0; mem < end; ++mem)
0125         checksum[1] += *mem;
0126     if (checksum[0] != checksum[1])
0127         return -EINVAL;
0128     /* increment */
0129     *pmem += 10 + *plen;
0130     return 0;
0131 }
0132 
0133 int softing_load_fw(const char *file, struct softing *card,
0134         __iomem uint8_t *dpram, unsigned int size, int offset)
0135 {
0136     const struct firmware *fw;
0137     int ret;
0138     const uint8_t *mem, *end, *dat;
0139     uint16_t type, len;
0140     uint32_t addr;
0141     uint8_t *buf = NULL, *new_buf;
0142     int buflen = 0;
0143     int8_t type_end = 0;
0144 
0145     ret = request_firmware(&fw, file, &card->pdev->dev);
0146     if (ret < 0)
0147         return ret;
0148     dev_dbg(&card->pdev->dev, "%s, firmware(%s) got %u bytes"
0149         ", offset %c0x%04x\n",
0150         card->pdat->name, file, (unsigned int)fw->size,
0151         (offset >= 0) ? '+' : '-', (unsigned int)abs(offset));
0152     /* parse the firmware */
0153     mem = fw->data;
0154     end = &mem[fw->size];
0155     /* look for header record */
0156     ret = fw_parse(&mem, &type, &addr, &len, &dat);
0157     if (ret < 0)
0158         goto failed;
0159     if (type != 0xffff)
0160         goto failed;
0161     if (strncmp("Structured Binary Format, Softing GmbH" , dat, len)) {
0162         ret = -EINVAL;
0163         goto failed;
0164     }
0165     /* ok, we had a header */
0166     while (mem < end) {
0167         ret = fw_parse(&mem, &type, &addr, &len, &dat);
0168         if (ret < 0)
0169             goto failed;
0170         if (type == 3) {
0171             /* start address, not used here */
0172             continue;
0173         } else if (type == 1) {
0174             /* eof */
0175             type_end = 1;
0176             break;
0177         } else if (type != 0) {
0178             ret = -EINVAL;
0179             goto failed;
0180         }
0181 
0182         if ((addr + len + offset) > size)
0183             goto failed;
0184         memcpy_toio(&dpram[addr + offset], dat, len);
0185         /* be sure to flush caches from IO space */
0186         mb();
0187         if (len > buflen) {
0188             /* align buflen */
0189             buflen = (len + (1024-1)) & ~(1024-1);
0190             new_buf = krealloc(buf, buflen, GFP_KERNEL);
0191             if (!new_buf) {
0192                 ret = -ENOMEM;
0193                 goto failed;
0194             }
0195             buf = new_buf;
0196         }
0197         /* verify record data */
0198         memcpy_fromio(buf, &dpram[addr + offset], len);
0199         if (memcmp(buf, dat, len)) {
0200             /* is not ok */
0201             dev_alert(&card->pdev->dev, "DPRAM readback failed\n");
0202             ret = -EIO;
0203             goto failed;
0204         }
0205     }
0206     if (!type_end)
0207         /* no end record seen */
0208         goto failed;
0209     ret = 0;
0210 failed:
0211     kfree(buf);
0212     release_firmware(fw);
0213     if (ret < 0)
0214         dev_info(&card->pdev->dev, "firmware %s failed\n", file);
0215     return ret;
0216 }
0217 
0218 int softing_load_app_fw(const char *file, struct softing *card)
0219 {
0220     const struct firmware *fw;
0221     const uint8_t *mem, *end, *dat;
0222     int ret, j;
0223     uint16_t type, len;
0224     uint32_t addr, start_addr = 0;
0225     unsigned int sum, rx_sum;
0226     int8_t type_end = 0, type_entrypoint = 0;
0227 
0228     ret = request_firmware(&fw, file, &card->pdev->dev);
0229     if (ret) {
0230         dev_alert(&card->pdev->dev, "request_firmware(%s) got %i\n",
0231             file, ret);
0232         return ret;
0233     }
0234     dev_dbg(&card->pdev->dev, "firmware(%s) got %lu bytes\n",
0235         file, (unsigned long)fw->size);
0236     /* parse the firmware */
0237     mem = fw->data;
0238     end = &mem[fw->size];
0239     /* look for header record */
0240     ret = fw_parse(&mem, &type, &addr, &len, &dat);
0241     if (ret)
0242         goto failed;
0243     ret = -EINVAL;
0244     if (type != 0xffff) {
0245         dev_alert(&card->pdev->dev, "firmware starts with type 0x%x\n",
0246             type);
0247         goto failed;
0248     }
0249     if (strncmp("Structured Binary Format, Softing GmbH", dat, len)) {
0250         dev_alert(&card->pdev->dev, "firmware string '%.*s' fault\n",
0251                 len, dat);
0252         goto failed;
0253     }
0254     /* ok, we had a header */
0255     while (mem < end) {
0256         ret = fw_parse(&mem, &type, &addr, &len, &dat);
0257         if (ret)
0258             goto failed;
0259 
0260         if (type == 3) {
0261             /* start address */
0262             start_addr = addr;
0263             type_entrypoint = 1;
0264             continue;
0265         } else if (type == 1) {
0266             /* eof */
0267             type_end = 1;
0268             break;
0269         } else if (type != 0) {
0270             dev_alert(&card->pdev->dev,
0271                     "unknown record type 0x%04x\n", type);
0272             ret = -EINVAL;
0273             goto failed;
0274         }
0275 
0276         /* regular data */
0277         for (sum = 0, j = 0; j < len; ++j)
0278             sum += dat[j];
0279         /* work in 16bit (target) */
0280         sum &= 0xffff;
0281 
0282         memcpy_toio(&card->dpram[card->pdat->app.offs], dat, len);
0283         iowrite32(card->pdat->app.offs + card->pdat->app.addr,
0284                 &card->dpram[DPRAM_COMMAND + 2]);
0285         iowrite32(addr, &card->dpram[DPRAM_COMMAND + 6]);
0286         iowrite16(len, &card->dpram[DPRAM_COMMAND + 10]);
0287         iowrite8(1, &card->dpram[DPRAM_COMMAND + 12]);
0288         ret = softing_bootloader_command(card, 1, "loading app.");
0289         if (ret < 0)
0290             goto failed;
0291         /* verify checksum */
0292         rx_sum = ioread16(&card->dpram[DPRAM_RECEIPT + 2]);
0293         if (rx_sum != sum) {
0294             dev_alert(&card->pdev->dev, "SRAM seems to be damaged"
0295                 ", wanted 0x%04x, got 0x%04x\n", sum, rx_sum);
0296             ret = -EIO;
0297             goto failed;
0298         }
0299     }
0300     if (!type_end || !type_entrypoint)
0301         goto failed;
0302     /* start application in card */
0303     iowrite32(start_addr, &card->dpram[DPRAM_COMMAND + 2]);
0304     iowrite8(1, &card->dpram[DPRAM_COMMAND + 6]);
0305     ret = softing_bootloader_command(card, 3, "start app.");
0306     if (ret < 0)
0307         goto failed;
0308     ret = 0;
0309 failed:
0310     release_firmware(fw);
0311     if (ret < 0)
0312         dev_info(&card->pdev->dev, "firmware %s failed\n", file);
0313     return ret;
0314 }
0315 
0316 static int softing_reset_chip(struct softing *card)
0317 {
0318     int ret;
0319 
0320     do {
0321         /* reset chip */
0322         iowrite8(0, &card->dpram[DPRAM_RESET_RX_FIFO]);
0323         iowrite8(0, &card->dpram[DPRAM_RESET_RX_FIFO+1]);
0324         iowrite8(1, &card->dpram[DPRAM_RESET]);
0325         iowrite8(0, &card->dpram[DPRAM_RESET+1]);
0326 
0327         ret = softing_fct_cmd(card, 0, "reset_can");
0328         if (!ret)
0329             break;
0330         if (signal_pending(current))
0331             /* don't wait any longer */
0332             break;
0333     } while (1);
0334     card->tx.pending = 0;
0335     return ret;
0336 }
0337 
0338 int softing_chip_poweron(struct softing *card)
0339 {
0340     int ret;
0341     /* sync */
0342     ret = _softing_fct_cmd(card, 99, 0x55, "sync-a");
0343     if (ret < 0)
0344         goto failed;
0345 
0346     ret = _softing_fct_cmd(card, 99, 0xaa, "sync-b");
0347     if (ret < 0)
0348         goto failed;
0349 
0350     ret = softing_reset_chip(card);
0351     if (ret < 0)
0352         goto failed;
0353     /* get_serial */
0354     ret = softing_fct_cmd(card, 43, "get_serial_number");
0355     if (ret < 0)
0356         goto failed;
0357     card->id.serial = ioread32(&card->dpram[DPRAM_FCT_PARAM]);
0358     /* get_version */
0359     ret = softing_fct_cmd(card, 12, "get_version");
0360     if (ret < 0)
0361         goto failed;
0362     card->id.fw_version = ioread16(&card->dpram[DPRAM_FCT_PARAM + 2]);
0363     card->id.hw_version = ioread16(&card->dpram[DPRAM_FCT_PARAM + 4]);
0364     card->id.license = ioread16(&card->dpram[DPRAM_FCT_PARAM + 6]);
0365     card->id.chip[0] = ioread16(&card->dpram[DPRAM_FCT_PARAM + 8]);
0366     card->id.chip[1] = ioread16(&card->dpram[DPRAM_FCT_PARAM + 10]);
0367     return 0;
0368 failed:
0369     return ret;
0370 }
0371 
0372 static void softing_initialize_timestamp(struct softing *card)
0373 {
0374     uint64_t ovf;
0375 
0376     card->ts_ref = ktime_get();
0377 
0378     /* 16MHz is the reference */
0379     ovf = 0x100000000ULL * 16;
0380     do_div(ovf, card->pdat->freq ?: 16);
0381 
0382     card->ts_overflow = ktime_add_us(0, ovf);
0383 }
0384 
0385 ktime_t softing_raw2ktime(struct softing *card, u32 raw)
0386 {
0387     uint64_t rawl;
0388     ktime_t now, real_offset;
0389     ktime_t target;
0390     ktime_t tmp;
0391 
0392     now = ktime_get();
0393     real_offset = ktime_sub(ktime_get_real(), now);
0394 
0395     /* find nsec from card */
0396     rawl = raw * 16;
0397     do_div(rawl, card->pdat->freq ?: 16);
0398     target = ktime_add_us(card->ts_ref, rawl);
0399     /* test for overflows */
0400     tmp = ktime_add(target, card->ts_overflow);
0401     while (unlikely(ktime_to_ns(tmp) > ktime_to_ns(now))) {
0402         card->ts_ref = ktime_add(card->ts_ref, card->ts_overflow);
0403         target = tmp;
0404         tmp = ktime_add(target, card->ts_overflow);
0405     }
0406     return ktime_add(target, real_offset);
0407 }
0408 
0409 static inline int softing_error_reporting(struct net_device *netdev)
0410 {
0411     struct softing_priv *priv = netdev_priv(netdev);
0412 
0413     return (priv->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
0414         ? 1 : 0;
0415 }
0416 
0417 int softing_startstop(struct net_device *dev, int up)
0418 {
0419     int ret;
0420     struct softing *card;
0421     struct softing_priv *priv;
0422     struct net_device *netdev;
0423     int bus_bitmask_start;
0424     int j, error_reporting;
0425     struct can_frame msg;
0426     const struct can_bittiming *bt;
0427 
0428     priv = netdev_priv(dev);
0429     card = priv->card;
0430 
0431     if (!card->fw.up)
0432         return -EIO;
0433 
0434     ret = mutex_lock_interruptible(&card->fw.lock);
0435     if (ret)
0436         return ret;
0437 
0438     bus_bitmask_start = 0;
0439     if (dev && up)
0440         /* prepare to start this bus as well */
0441         bus_bitmask_start |= (1 << priv->index);
0442     /* bring netdevs down */
0443     for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
0444         netdev = card->net[j];
0445         if (!netdev)
0446             continue;
0447         priv = netdev_priv(netdev);
0448 
0449         if (dev != netdev)
0450             netif_stop_queue(netdev);
0451 
0452         if (netif_running(netdev)) {
0453             if (dev != netdev)
0454                 bus_bitmask_start |= (1 << j);
0455             priv->tx.pending = 0;
0456             priv->tx.echo_put = 0;
0457             priv->tx.echo_get = 0;
0458             /*
0459              * this bus' may just have called open_candev()
0460              * which is rather stupid to call close_candev()
0461              * already
0462              * but we may come here from busoff recovery too
0463              * in which case the echo_skb _needs_ flushing too.
0464              * just be sure to call open_candev() again
0465              */
0466             close_candev(netdev);
0467         }
0468         priv->can.state = CAN_STATE_STOPPED;
0469     }
0470     card->tx.pending = 0;
0471 
0472     softing_enable_irq(card, 0);
0473     ret = softing_reset_chip(card);
0474     if (ret)
0475         goto failed;
0476     if (!bus_bitmask_start)
0477         /* no buses to be brought up */
0478         goto card_done;
0479 
0480     if ((bus_bitmask_start & 1) && (bus_bitmask_start & 2)
0481             && (softing_error_reporting(card->net[0])
0482                 != softing_error_reporting(card->net[1]))) {
0483         dev_alert(&card->pdev->dev,
0484                 "err_reporting flag differs for buses\n");
0485         goto invalid;
0486     }
0487     error_reporting = 0;
0488     if (bus_bitmask_start & 1) {
0489         netdev = card->net[0];
0490         priv = netdev_priv(netdev);
0491         error_reporting += softing_error_reporting(netdev);
0492         /* init chip 1 */
0493         bt = &priv->can.bittiming;
0494         iowrite16(bt->brp, &card->dpram[DPRAM_FCT_PARAM + 2]);
0495         iowrite16(bt->sjw, &card->dpram[DPRAM_FCT_PARAM + 4]);
0496         iowrite16(bt->phase_seg1 + bt->prop_seg,
0497                 &card->dpram[DPRAM_FCT_PARAM + 6]);
0498         iowrite16(bt->phase_seg2, &card->dpram[DPRAM_FCT_PARAM + 8]);
0499         iowrite16((priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 1 : 0,
0500                 &card->dpram[DPRAM_FCT_PARAM + 10]);
0501         ret = softing_fct_cmd(card, 1, "initialize_chip[0]");
0502         if (ret < 0)
0503             goto failed;
0504         /* set mode */
0505         iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 2]);
0506         iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 4]);
0507         ret = softing_fct_cmd(card, 3, "set_mode[0]");
0508         if (ret < 0)
0509             goto failed;
0510         /* set filter */
0511         /* 11bit id & mask */
0512         iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]);
0513         iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]);
0514         /* 29bit id.lo & mask.lo & id.hi & mask.hi */
0515         iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 6]);
0516         iowrite16(0xffff, &card->dpram[DPRAM_FCT_PARAM + 8]);
0517         iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 10]);
0518         iowrite16(0x1fff, &card->dpram[DPRAM_FCT_PARAM + 12]);
0519         ret = softing_fct_cmd(card, 7, "set_filter[0]");
0520         if (ret < 0)
0521             goto failed;
0522         /* set output control */
0523         iowrite16(priv->output, &card->dpram[DPRAM_FCT_PARAM + 2]);
0524         ret = softing_fct_cmd(card, 5, "set_output[0]");
0525         if (ret < 0)
0526             goto failed;
0527     }
0528     if (bus_bitmask_start & 2) {
0529         netdev = card->net[1];
0530         priv = netdev_priv(netdev);
0531         error_reporting += softing_error_reporting(netdev);
0532         /* init chip2 */
0533         bt = &priv->can.bittiming;
0534         iowrite16(bt->brp, &card->dpram[DPRAM_FCT_PARAM + 2]);
0535         iowrite16(bt->sjw, &card->dpram[DPRAM_FCT_PARAM + 4]);
0536         iowrite16(bt->phase_seg1 + bt->prop_seg,
0537                 &card->dpram[DPRAM_FCT_PARAM + 6]);
0538         iowrite16(bt->phase_seg2, &card->dpram[DPRAM_FCT_PARAM + 8]);
0539         iowrite16((priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 1 : 0,
0540                 &card->dpram[DPRAM_FCT_PARAM + 10]);
0541         ret = softing_fct_cmd(card, 2, "initialize_chip[1]");
0542         if (ret < 0)
0543             goto failed;
0544         /* set mode2 */
0545         iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 2]);
0546         iowrite16(0, &card->dpram[DPRAM_FCT_PARAM + 4]);
0547         ret = softing_fct_cmd(card, 4, "set_mode[1]");
0548         if (ret < 0)
0549             goto failed;
0550         /* set filter2 */
0551         /* 11bit id & mask */
0552         iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 2]);
0553         iowrite16(0x07ff, &card->dpram[DPRAM_FCT_PARAM + 4]);
0554         /* 29bit id.lo & mask.lo & id.hi & mask.hi */
0555         iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 6]);
0556         iowrite16(0xffff, &card->dpram[DPRAM_FCT_PARAM + 8]);
0557         iowrite16(0x0000, &card->dpram[DPRAM_FCT_PARAM + 10]);
0558         iowrite16(0x1fff, &card->dpram[DPRAM_FCT_PARAM + 12]);
0559         ret = softing_fct_cmd(card, 8, "set_filter[1]");
0560         if (ret < 0)
0561             goto failed;
0562         /* set output control2 */
0563         iowrite16(priv->output, &card->dpram[DPRAM_FCT_PARAM + 2]);
0564         ret = softing_fct_cmd(card, 6, "set_output[1]");
0565         if (ret < 0)
0566             goto failed;
0567     }
0568 
0569     /* enable_error_frame
0570      *
0571      * Error reporting is switched off at the moment since
0572      * the receiving of them is not yet 100% verified
0573      * This should be enabled sooner or later
0574      */
0575     if (0 && error_reporting) {
0576         ret = softing_fct_cmd(card, 51, "enable_error_frame");
0577         if (ret < 0)
0578             goto failed;
0579     }
0580 
0581     /* initialize interface */
0582     iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 2]);
0583     iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 4]);
0584     iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 6]);
0585     iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 8]);
0586     iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 10]);
0587     iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 12]);
0588     iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 14]);
0589     iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 16]);
0590     iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 18]);
0591     iowrite16(1, &card->dpram[DPRAM_FCT_PARAM + 20]);
0592     ret = softing_fct_cmd(card, 17, "initialize_interface");
0593     if (ret < 0)
0594         goto failed;
0595     /* enable_fifo */
0596     ret = softing_fct_cmd(card, 36, "enable_fifo");
0597     if (ret < 0)
0598         goto failed;
0599     /* enable fifo tx ack */
0600     ret = softing_fct_cmd(card, 13, "fifo_tx_ack[0]");
0601     if (ret < 0)
0602         goto failed;
0603     /* enable fifo tx ack2 */
0604     ret = softing_fct_cmd(card, 14, "fifo_tx_ack[1]");
0605     if (ret < 0)
0606         goto failed;
0607     /* start_chip */
0608     ret = softing_fct_cmd(card, 11, "start_chip");
0609     if (ret < 0)
0610         goto failed;
0611     iowrite8(0, &card->dpram[DPRAM_INFO_BUSSTATE]);
0612     iowrite8(0, &card->dpram[DPRAM_INFO_BUSSTATE2]);
0613     if (card->pdat->generation < 2) {
0614         iowrite8(0, &card->dpram[DPRAM_V2_IRQ_TOHOST]);
0615         /* flush the DPRAM caches */
0616         wmb();
0617     }
0618 
0619     softing_initialize_timestamp(card);
0620 
0621     /*
0622      * do socketcan notifications/status changes
0623      * from here, no errors should occur, or the failed: part
0624      * must be reviewed
0625      */
0626     memset(&msg, 0, sizeof(msg));
0627     msg.can_id = CAN_ERR_FLAG | CAN_ERR_RESTARTED;
0628     msg.len = CAN_ERR_DLC;
0629     for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
0630         if (!(bus_bitmask_start & (1 << j)))
0631             continue;
0632         netdev = card->net[j];
0633         if (!netdev)
0634             continue;
0635         priv = netdev_priv(netdev);
0636         priv->can.state = CAN_STATE_ERROR_ACTIVE;
0637         open_candev(netdev);
0638         if (dev != netdev) {
0639             /* notify other buses on the restart */
0640             softing_netdev_rx(netdev, &msg, 0);
0641             ++priv->can.can_stats.restarts;
0642         }
0643         netif_wake_queue(netdev);
0644     }
0645 
0646     /* enable interrupts */
0647     ret = softing_enable_irq(card, 1);
0648     if (ret)
0649         goto failed;
0650 card_done:
0651     mutex_unlock(&card->fw.lock);
0652     return 0;
0653 invalid:
0654     ret = -EINVAL;
0655 failed:
0656     softing_enable_irq(card, 0);
0657     softing_reset_chip(card);
0658     mutex_unlock(&card->fw.lock);
0659     /* bring all other interfaces down */
0660     for (j = 0; j < ARRAY_SIZE(card->net); ++j) {
0661         netdev = card->net[j];
0662         if (!netdev)
0663             continue;
0664         dev_close(netdev);
0665     }
0666     return ret;
0667 }
0668 
0669 int softing_default_output(struct net_device *netdev)
0670 {
0671     struct softing_priv *priv = netdev_priv(netdev);
0672     struct softing *card = priv->card;
0673 
0674     switch (priv->chip) {
0675     case 1000:
0676         return (card->pdat->generation < 2) ? 0xfb : 0xfa;
0677     case 5:
0678         return 0x60;
0679     default:
0680         return 0x40;
0681     }
0682 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!