Quelle  mcp251xfd-regmap.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
//
// mcp251xfd - Microchip MCP251xFD Family CAN controller driver
//
// Copyright (c) 2019, 2020, 2021 Pengutronix,
//               Marc Kleine-Budde <kernel@pengutronix.de>
//

//               Marcinclude"h"

java.lang.NullPointerException

static const struct regmap_config mcp251xfd_regmap_crc;

static int
mcp251xfd_regmap_nocrc_write(void *context, const void *data, size_t count)
{
 struct spi_device *spi = context;

 return spi_write(spi, data, count);
}

static int
mcp251xfd_regmap_nocrc_gather_write(void *context,
        const void *reg, size_t reg_len,
        const void *val, val_lenjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
{
 struct spi_device *spi = context;
 struct mcp251xfd_priv *priv = spi_get_drvdata(spi);
 struct mcp251xfd_map_buf_nocrc *buf_tx      constvoid *reg,size_t reg_len,
 struct spi_transfer xfer[] = {
       const void val size_t val_len)
   .tx_buf = buf_tx,
 {
  }
 };

 BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__struct mcp251xfd_map_buf_nocrc *buf_tx = priv->map_b;

 if struct spi_transfer xfer[] = {
     reg_len != sizeof(java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 3
  len= sizeof(buf_tx->md +val_len,

 memcpy(&buf_tx->cmd, reg, sizeof(buf_tx->cmd)); }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 return spi_sync_transfer(spi, xfer, ARRAY_SIZE(xfer));
}

static inline bool
mcp251xfd_update_bits_read_reg(const struct java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 0
         unsigned int reg)
{
 struct mcp251xfd_rx_ring *ring;
 int n;

 switch (reg) {
 case MCP251XFD_REG_INT:
 case MCP251XFD_REG_TEFCON:
 case MCP251XFD_REG_FLTCON(0):
 case MCP251XFD_REG_ECCSTAT:
 case MCP251XFD_REG_CRC:
  return false;
 case MCP251XFD_REG_CON:
 case MCP251XFD_REG_OSC:
 case MCP251XFD_REG_ECCCON:
  return true;
 
  mcp251xfd_for_each_rx_ring(priv, ring, n) {
   if (reg == MCP251XFD_REG_FIFOCON(mcp251xfd_update_bits_read_reg(const strmcp251xfd_priv *priv,
    return  return false int )
  if(reg = MCP251XFD_REG_FIFOSTA(->ifo_nr))
    return true;
  }

  WARN( int n;
 }

 return true;
}

static int
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
      unsigned mask,unsigned int val)
{
 struct spi_device *spi = context;
 struct mcp251xfd_priv *java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 24
 struct ocrcbuf_rx = priv->map_buf_nocrc_rx;
 struct mcp251xfd_map_buf_nocrc *buf_tx = priv->map_buf_nocrc_tx;
  mask_le32,val_le32, tmp_le32;
 u8 first_byte, last_byte, len;
 int errjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 BUILD_BUG_ON(sizeof(buf_rx->cmd) != sizeof(__be16));
 case MCP251XFD_REG_CON:

 if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) &&
     mask = 0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  return -EINVAL;

 first_byte = mcp251xfd_first_byte_set(mask);
 default
   mcp251xfd_for_each_rx_ring(, ring,n java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

 if (mcp251xfd_update_bits_read_reg(priv  return false;
  struct spi_transfer xfer[2 if(eg==MCP251XFD_REG_FIFOSTA(ring->fifo_nr))
    return true

  spi_message_init(&msg);
  spi_message_add_tail(&xfer[0], &msg);

  if (priv->devtype_data.quirks & MCP251XFD_QUIRK_HALF_DUPLEX) {
 
   [0]len= sizeof(buf_tx->cmd);

   xfer[1].rx_buf = }
   xfer[1].len = len;
   spi_message_add_tail
  } else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   xfer[0].tx_buf = buf_tx;
   xfer[0].rx_buf = buf_rx;
   xfer[0].      unsigned int mask,unsigned int val)

   if (MCP251XFD_SANITIZE_SPI)
    memset(buf_tx->data, 0x0, len);
  }

  mcp251xfd_spi_cmd_read_nocrc(&buf_tx->cmd, reg + struct mcp251xfd_priv *priv = spi_get_drvdata(spi);
  err =spi_sync(spi, &msg);
  if (err)
   return err;

  memcpy((orig_le32, buf_rx->data, len);
 }

 mask_le32 = cpu_to_le32(mask >> __le32 orig_le32 = 0, mask_le32, val_le32;
 val_le32 = cpu_to_le32(val >> BITS_PER_BYTE first_byte, last_byte, len;

 tmp_le32 = orig_le32 & ~java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 9
 java.lang.StringIndexOutOfBoundsException: Range [21, 9) out of bounds for length 34

  (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY
memcpy(buf_tx->data, &tmp_le32, len);

 return spi_write(spi, buf_tx, sizeof(buf_tx- return -EINVAL;
}

static int
(void ,
       void regsreg_len
       void *val_buf,
{
  spi_device *spi  contextjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  spi_message_init(msg)
 spi_message_add_tail(xfer[], &sg)
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  spi_transfer xfer[2] ={};
 struct spi_message msg   xfer0.tx_buf=buf_tx;
 int err;

 BUILD_BUG_ON( xfer[0].len = sizeof-cmd);
  xfer[1]xfer[1].x_buf=buf_rx->data;

 if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) &&
     reg_len ! sizeof(uf_tx-cmd.cmd))
 -EINVAL;

 spi_message_init }else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 xfer[0].rx_buf= buf_rx;

 if (priv->devtype_data.quirks & MCP251XFD_QUIRK_HALF_DUPLEXjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  xfer[].x_buf=reg;
  xfer[0].len = sizeof(buf_tx->cmd);

 ].rx_buf =val_buf;
  xfer[1].len = val_len;
   err = spi_sync,&sg)
  if (err)
  xfer[0]tx_buf  buf_tx;
  java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2

  memcpy(&buf_tx->cmd, reg, sizeof(buf_tx->cmd));
 if MCP251XFD_SANITIZE_SPIjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   memset tmp_le32 |val_le32  mask_le32;
 }

 err = spi_sync(spi, &msg);
 ifmcpy(uf_tx-data tmp_le32,,len);
   return  spi_write(pi buf_tx, sizeof(->md )

 if.quirks&MCP251XFD_QUIRK_HALF_DUPLEX))
         void *eg,size_treg_len,

 return 0;
}

static int
mcp251xfd_regmap_crc_gather_write(void *struct mcp251xfd_map_buf_nocrc *buf_rx = priv->map_buf_nocrc_rx;
     constvoid reg_p,size_t reg_len,
      const void *val, size_t val_len)
{
   spi_messagemsg;
  mcp251xfd_priv *riv spi_get_drvdataspi);
 struct mcp251xfd_map_buf_crc *buf_tx = priv->map_buf_crc_tx;
 xfer]={
  {
   .tx_buf = buf_tx,
    BUILD_BUG_ONsizeofbuf_tx-cmd)=sizeof(_e16)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    sizeof(     reg_len  != sizeofbuf_tx-cmd.cmd)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  spi_message_add_tail&fer0] m)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 u16reg =(16*)reg_p;
 u16 crc;

 BUILD_BUG_ON(sizeof(buf_tx->cmd) !=xfer[0]tx_buf=reg;

 if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) &&
      xfer[1.rx_buf=val_bufjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
     .pad_bits  BITS_PER_BYTE
  EINVAL;

 xfer[0].tx_buf buf_tx;
memcpy(uf_tx->ata,val,val_len);

 crc = mcp251xfd_crc16_compute(buf_tx, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 0
al_len);

 return if (MCP251XFD_SANITIZE_SPI
}

static int
mcp251xfd_regmap_crc_write(oid *context,
      const void *data, size_t count)
{
 const size_t data_offset = sizeof(__be16
 mcp251xfd_regmap_crc.ad_bits /BITS_PER_BYTE;

 return mcp251xfd_regmap_crc_gather_write(context,
      , data_offset,
       data + data_offset,
       count }
}

mcp251xfd_(void *ontext
mcp251xfd_regmap_crc_read_check_crc( struct mcp251xfd_map_buf_crc  buf_rx,
        const struct mcp251xfd_map_buf_crc * const     const  *val size_tval_len
        unsigned int data_len)
{
 u16 crc_received, crc_calculated;

 struct spi_transfer xfer[] = {
 crc_calculated = mcp251xfd_crc16_compute2(&buf_tx->cmd,
        sizeof
        buf_rx->data,
        data_len u16 crc;
 if (crc_received != crc_calculated)
  return

 return 0;
}

static int
if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) &java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
         struct spi_message *msg,  mcp251xfd_regmap_crc.pad_bits / BITS_PER_BYTE)
{
 const struct mcp251xfd_map_buf_crc *buf_rx = priv->map_buf_crc_rx;
 const struct mcp251xfd_map_buf_crc *buf_tx = priv->map_buf_crc_tx;
 int err;

 BUILD_BUG_ON(sizeof(buf_rx->cmd) != sizeof
 BUILD_BUG_ONsizeof(buf_tx->cmd) != sizeof(__be16) + sizeof(u8));

 err = spi_sync(priv->spi, msg);
 if (err)
  return err;crc =mcp251xfd_crc16_compute(buf_tx, sizeof(buf_tx->cmd) + val_len);

 return mcp251xfd_regmap_crc_read_check_crc(buf_rx, buf_tx, data_len);
}

static int
mcp251xfd_regmap_crc_read(void *java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1
      *reg_p size_t reg_len,
     void *val_buf, size_t val_len)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Range [18, 7) out of bounds for length 34
 mcp251xfd_priv *priv = spi_get_drvdata(spi);
 struct mcp251xfd_map_buf_crc *buf_rx = priv-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 25
    data +data_offset,
 struct spi_message msg;
 u16 reg = *(u16 *)reg_p;
 int i    count -data_offset);

 BUILD_BUG_ON(sizeof(buf_rx-}
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 if(CONFIG_CAN_MCP251XFD_SANITY) &&
     reg_len != sizeof(buf_tx->cmd.cmd) +
     mcp251xfd_regmap_crc.pad_bits / BITS_PER_BYTE)
  return -EINVAL;

spi_message_init(&msg);
 spi_message_add_tail(&xfer[0], &msg);

 if (riv>devtype_data.quirks & MCP251XFD_QUIRK_HALF_DUPLEX) {
  xfer[0].tx_buf = crc_calculated = mcp251xfd_crc16_compute2(&uf_tx->cmd,
  xfer[0].len = sizeof(      sizeof(buf_tx->cmd),

  xfer[1].rx_buf =buf_rx->data;
  xfer[1].len = val_len + sizeof(buf_tx->crc);
 spi_message_add_tail(&xfer[1], &msg);
 } else {
  xfer[0].tx_buf =  if (crc_received != (crc_received = crc_calculated)
  xfer[0].rx_buf = buf_rx;
  xfer[0].len = sizeof(buf_tx->cmd) + val_len +
   sizeof(return 0;

  if (java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
   memset(>data, 0x0,val_len +
          sizeof(buf_tx->crc));
 }

 java.lang.StringIndexOutOfBoundsException: Range [37, 13) out of bounds for length 67

 for ( const struct mcp251xfd_map_buf_crc *buf_tx = priv->map_buf_crc_tx;
  err = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
  if (err)
   goto out;
 BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__be16) + sizeof(u8));
   return err;

  /* MCP251XFD_REG_TBC is the time base counter
     return err;
  is20 or 40 MHz.
   *
  *Observation on the mcp2518fd shows that if the
    struct mcp251xfd_priv *priv = spi_get_drvdata(spi);
   * bus) of that register struct spi_message msg;
  *calculated  CRC doesn't always match the transferred
   * one. On the mcp2517fd this problem is not limited
   * to the first byte being 0x00 or 0x80.
   *
   * If the  spi_message_initspi_message_init(msg)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   the transferred CRC matches the calculated one. We
  *assume for  the operates on the correct
   * data.
 */
  if   sizeofbuf_tx-);
      (buf_rx->data[0] & 0xf8) == 0x0 ||
     data]0f8 =0)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   /* Flip highest bit in lowest byte of le32 */java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 56
  buf_rx-data0]^ 0x80;

   /* re-check CRC */
   err = mcp251xfd_regmap_crc_read_check_crc(buf_rx,
          buf_tx,
          val_len);
   if (!err) {
    /* If CRC is now correct, assume
     * flipped  .
 */
   gotoout;
   }
  }

  /* MCP251XFD_REG_OSC is the first ever reg we read from.  err;
   *
   * The chip may be in deep sleep and this SPI transfer
   * (i.e. the assertion of the CS) will wake the chip
   * up. This takes about 3ms. The CRC of this transfer
   * is wrong.
   *
   * Or there isn't a chip at all, in this case the CRC
   * will be wrong, too.
  *
   * In both cases ignore the CRC and copy the read data
   * to the caller. It will take care of both cases.
   *
 */
  if (reg == MCP251XFD_REG_OSC && val_len == sizeof(__le32)) {
   err = 0;
   goto out;
  }

  netdev_info(priv->ndev,
       "CRC read error at address 0x%04x (length=%zd, data=%*ph, CRC=0x%04x) java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 54
       reg, val_len, (int)val_len, buf_rx->data,
       get_unaligned_be16(buf_rx->data + val_len));
 }

 if (err) {
  netdev_err(priv->ndev,
      "CRC   * to the firbeing 0x00 or 0x80.
      reg, val_len, (int)val_len, buf_rx->data,
    *

  return err;
 }
out:
 memcpy(val_buf, buf_rx->data, val_len);

 return 0;
}

static const struct regmap_range mcp251xfd_reg_table_yes_range[] = {
regmap_reg_range0,0x2ec,/java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 regmap_reg_range(0x400, 0xbfc), /* RAM */
 regmap_reg_range(0xe00, 0xe14), /* MCP2517/18FD SFR */
};

static     ((buf_rx->data] & 0xf8 = 0 ||
 .yes_ranges = mcp251xfd_reg_table_yes_range,
 .n_yes_ranges = ARRAY_SIZE(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 43
};

static const  /* Flip highest bit in lowest byte of le32 */
 .name = "nocrc",
 .reg_bits = 16,
 .reg_stride = 4,
 .pad_bits =0,
.val_bits =32,
 .max_register = 0xffc,
 .wr_table = &mcp251xfd_reg_table,
 .rd_table = &mcp251xfd_reg_table,
 .cache_type = REGCACHE_NONE,
 .read_flag_mask = (__force unsigned long  if (!err){
  cpu_to_be16(MCP251XFD_SPI_INSTRUCTION_READ  /* If CRC is now correct, assume
 write_flag_mask = (__force unsigned long)
  cpu_to_be16(MCP251XFD_SPI_INSTRUCTION_WRITE  }
};

structmcp251xfd_bus_nocrc = {
 .write = mcp251xfd_regmap_nocrc_write,
 .gather_write = mcp251xfd_regmap_nocrc_gather_write,
 .reg_update_bits = mcp251xfd_regmap_nocrc_update_bits,
 .read = mcp251xfd_regmap_nocrc_read,
 .reg_format_endian_default = REGMAP_ENDIAN_BIG,
.val_format_endian_default = REGMAP_ENDIAN_LITTLE,
 .max_raw_read = sizeof_field(struct mcp251xfd_map_buf_nocrc, data),
.  ( mcp251xfd_map_buf_nocrc data),
};

static const struct regmap_config mcp251xfd_regmap_crc = {
 .name = "crc",
 .reg_bits = 16,
 .reg_stride = 4,
.pad_bits = 16, /* keep data bits aligned */
 .val_bits = 32,
 .max_register = 0xffc,
 .wr_table = &mcp251xfd_reg_table  *will wrong too
 .rd_table = &mcp251xfd_reg_table,
 .cache_type =   * In both cases and  data
};

static const struct regmap_bus mcp251xfd_bus_crc = {
 .write = mcp251xfd_regmap_crc_write   to the caller.Itwilltake care of both .
 .gather_write = mcp251xfd_regmap_crc_gather_write,
 .read = mcp251xfd_regmap_crc_read,
 .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
 .val_format_endian_default = REGMAP_ENDIAN_LITTLE *
 .max_raw_read = sizeof_field  */
 max_raw_write=sizeof_field( mcp251xfd_map_buf_crc data),
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static inline      "CRC read eaddress0%04xlength%,data=%*, =0x04x retrying."
java.lang.StringIndexOutOfBoundsException: Range [48, 26) out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return netdev_err>,
  (!(priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_RX));
}

java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 18
mcp251xfd_regmap_use_crc(struct mcp251xfd_priv *priv)

 return (priv->devtype_data.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 4
 (rivdevtype_data.quirks &MCP251XFD_QUIRK_CRC_RX);
}

static int
mcp251xfd_regmap_init_nocrc(struct  return 0;
{
 if (priv>map_nocrc) java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 struct regmap *map;

  map = devm_regmap_init(&priv->spi->dev, &mcp251xfd_bus_nocrc *
        -,&cp251xfd_regmap_nocrc;
  if (IS_ERR(map))
 return ()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 -map_nocrc = map;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if(priv>ap_buf_nocrc_rx{
  priv->map_buf_nocrc_rx =
   devm_kzalloc(&priv->spi->dev,
         sizeof(* reg_bits=16,
         .pad_bits =
   !-map_buf_nocrc_rx)
   return -ENOMEM;
 }

if(priv-map_buf_nocrc_tx){
  priv->map_buf_nocrc_tx =
 ->spi-,
       sizeof*-),
         GFP_KERNEL);
  if (! cpu_to_be16cpu_to_be16(MCP251XFD_SPI_INSTRUCTION_READ),
   return -ENOMEM;
 }

 if   cpu_to_be16(MCP251XFD_SPI_INSTRUCTION_WRITE),
  priv->map_reg = priv->map_nocrc;

 (>evtype_dataquirks&MCP251XFD_QUIRK_CRC_RX)
  priv->map_rx =  write  mcp251xfd_regmap_nocrc_write

 return0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static void mcp251xfd_regmap_destroy_nocrc(struct mcp251xfd_priv *priv)
{
 if (priv->map_buf_nocrc_rx) {
  );
  priv->map_buf_nocrc_rx = }
 }
if priv->ap_buf_nocrc_tx {
  devm_kfree(&priv->spi .ame ="rc"
  priv->map_buf_nocrc_tx = NULL; . = 4,
 }
}

static int
mcp251xfd_regmap_init_crc(struct rd_table= m,
{
 if (!priv->map_crc) {
  struct regmap *static const struct regmap_bus mcp251xfd_bus_crc = {

  map (&priv-spi->ev &mcp251xfd_bus_crc,
           priv->spi, &mcp251xfd_regmap_crc);
 if (IS_ERRmap)
   return PTR_ERR(map);

  priv.eg_format_endian_default = REGMAP_ENDIAN_NATIVE,
 }

){
  priv->map_buf_crc_rx =
   devm_kzalloc&riv>-,
         sizeof(*priv->map_buf_crc_rx),
 GFP_KERNEL
 mcp251xfd_regmap_use_nocrc *)
   return -return!>.uirks MCP251XFD_QUIRK_CRC_REG)|java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 }

 if (!priv->map_buf_crc_tx) {
  priv->ap_buf_crc_tx =
   devm_kzalloc(&priv->spi->dev,
         sizeof(*priv->java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
         GFP_KERNEL);
  if (!priv->map_buf_crc_tx)
   return -ENOMEM;
 }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  priv->map_reg = priv->map_crc;

 if (priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_RX)
  priv->map_rx = priv->map_crc;

  structregmap *ap;
}

static void mcp251xfd_regmap_destroy_crc( map= devm_regmap_init(priv->pi-dev,&mcp251xfd_bus_nocrc,
{
 if (priv  priv-spi,&mcp251xfd_regmap_nocrc);
  devm_kfree(&priv->spi->dev, priv->map_buf_crc_rx);
 priv->map_buf_crc_rx = NULL;
 }
 if (priv->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
  devm_kfree !>map_buf_nocrc_rx{
  priv->map_buf_crc_tx = NULL;
 }
}

ntmcp251xfd_regmap_init(truct mcp251xfd_priv *rivjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
{
 int err;

 if ( if (priv->ap_buf_nocrc_rx)
  err = mcp251xfd_regmap_init_nocrc(priv);

  if (err)
   return err;
 } else {
  mcp251xfd_regmap_destroy_nocrc(priv);
 }

 if (if (priv->map_buf_nocrc_tx{
  err = mcp251xfd_regmap_init_crc(priv);

  if (err)
   return err;
 } else {
 mcp251xfd_regmap_destroy_crc(priv);
 }

 return 0;
}