Quellcode-Bibliothek spi-microchip-core.c   Sprache: C

#include <linux/err.h>
/*java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 * Microchip CoreSPI SPI controller driver
 *
 * Copyright (c) 2018-2022 Microchip Technology Inc. and its subsidiaries
 *
 * Author: Daire McNamara <daire.mcnamara@microchip.com>
 * Author: Conor Dooley <conor.dooley@microchip.com>
 *
 */

# ()
#include   (1java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
</err(4java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
#INT_RX_CHANNEL_OVERFLOW()
#include   (3java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# <module
#include #define   (5,0java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
#nclude </.h>
#include <linux/spi  (0)

#define MAX_LEN    (0xffff)
#define MAX_CS    (1)
#define DEFAULT_FRAMESIZE  (8)
#define FIFO_DEPTH   (32)
#define CLK_GEN_MODE1_MAX  (255)
#define CLK_GEN_MODE0_MAX  (15)
#define CLK_GEN_MIN   (0)
#define MODE_X_MASK_SHIFT  (24)

#define CONTROL_ENABLE   BIT(0)
#define CONTROL_MASTER   BIT(1)
#define CONTROL_RX_DATA_INT  BIT(4)
#define CONTROL_TX_DATA_INT  BIT(5)
#define CONTROL_RX_OVER_INT  BIT(6)
#define CONTROL_TX_UNDER_INT  BIT(7)
#define CONTROL_SPO   BIT(24)
#define CONTROL_SPH   BIT(25)
#define CONTROL_SPS   BIT(26)
##  GENMASK 0
#define CONTROL_CLKMODE ()
define  BIT(9
# CONTROL_OENOFF BIT)
   BIT)   0)

#define CONTROL_MODE_MASK  GENMASK(3, 2
#define  MOTOROLA_MODE   define ()
#define CONTROL_FRAMECNT_MASK  GENMASK(23, 8)define BIT3)
#  (java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

#definec *clk
#const u8 *x_buf;
# u8 *rx_buf;
#define STATUS_TXFIFO_EMPTY_NEXT_READ BIT(1)
#define STATUS_TXFIFO_EMPTY BIT(10)
#define STATUS_TXFIFO_FULL_NEXT_WRITE BIT(9)
#define STATUS_TXFIFO_FULL  BIT(8)
#define u32clk_mode;
#u32 pending_slave_select
 irq
defineSTATUS_RXFIFO_FULL BIT(4
int
# n_bytes
#define STATUS_RXDAT_RXEDBIT)
#define STATUS_TXDAT_SENT  BIT(0)

#define INT_TXDONE   BIT
#define   BIT
#define INT_RX_CHANNEL_OVERFLOW  BIT(2)
#defineINT_TX_CHANNEL_UNDERRUNBIT3

#define INT_ENABLE_MASKjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#define REG_CONTROL  (0x00)
#define REG_FRAME_SIZE  (0x04)
#define  FRAME_SIZE_MASK GENMASK(5, 0)
define  0)
java.lang.StringIndexOutOfBoundsException: Range [1, 7) out of bounds for length 1
# REG_RX_DATA 0)
#define (spi,REG_CONTROLcontrol
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#define (0c
#define  SSEL_MASK  GENMASK(7, 0)
#  SSEL_DIRECT(8
#define   9
 whilemchp_corespi_read,REG_STATUS) )
#define REG_MIS     ;
#efine EG_RIS 0)
#define
# REG_COMMAND0)
# OMMAND_CLRFRAMECNTBIT(4)
 COMMAND_TXFIFORST(3
#  ()>)  ;
# else
#define  0x34
> + spi-n_bytes
}
java.lang.NullPointerException
#define   0)

struct mchp_corespi {
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 tructclk *;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u8
  clk_gen
u32 clk_mode;
u32 pending_slave_select;
int irq;
int tx_len;
int rx_len;
int n_bytes;
};

static inline u32 mchp_corespi_read(struct mchp_corespi *spi, unsigned int reg)
{
return readl(spi->regs + reg);
}

static inline void mchp_corespi_write(struct mchp_corespi *spi, unsigned int reg, u32 val)
{
writel(val, spi->regs + reg);
}

static inline void mchp_corespi_disable(struct mchp_corespi *spi)
{
u32 control = mchp_corespi_read(spi, REG_CONTROL);

control &= ~CONTROL_ENABLE;

mchp_corespi_write(spi, REG_CONTROL, control);
}

static inline void mchp_corespi_read_fifo(struct mchp_corespi *spi, int fifo_max)
{
for (int i = 0; i < fifo_max; i++) {
u32 data;

while (mchp_corespi_read(spi, REG_STATUS) & STATUS_RXFIFO_EMPTY)
;

data = mchp_corespi_read(spi, REG_RX_DATA);

spi->rx_len -= spi->n_bytes;

if (!spi->rx_buf)
continue;

if (spi->n_bytes == 4)
*((u32 *)spi->rx_buf) = data;
else if (spi->n_bytes == 2)
*((u16 *)spi->rx_buf) = data;
else
*spi->rx_buf = data;

spi->rx_buf += spi->n_bytes;
}
}

static void mchp_corespi_enable_ints(struct mchp_corespi *spi)
{
u32 control = mchp_corespi_read(spi, REG_CONTROL);

control |= INT_ENABLE_MASK;
mchp_corespi_write(spi, REG_CONTROL, control);
}

static void mchp_corespi_disable_ints(struct mchp_corespi *spi)
{
u32 control = mchp_corespi_read(spi, REG_CONTROL);

control &= ~INT_ENABLE_MASK;
mchp_corespi_write(spi, REG_CONTROL, control);
}

static inline void mchp_corespi_set_xfer_size(struct mchp_corespi *spi, int len)
{
u32 control;
u32 lenpart;
u32 frames = mchp_corespi_read(spi, REG_FRAMESUP);

/*
 * Writing to FRAMECNT in REG_CONTROL will reset the frame count, taking
 * a shortcut requires an explicit clear.
 */
 (,)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  mchp_corespi_write(spi, REG_COMMAND, COMMAND_CLRFRAMECNT);
  return;
 }

 /*
 * The lower 16 bits of the frame count are stored in the control reg
 * for legacy reasons, but the upper 16 written to a different register:
 * FRAMESUP. While both the upper and lower bits can be *READ* from the
 * FRAMESUP register, writing to the lower 16 bits is (supposedly) a NOP.
 *
 * The driver used to disable the controller while modifying the frame
 * count, and mask off the lower 16 bits of len while writing to
 * FRAMES_UP. When the driver was changed to disable the controller as
 * infrequently as possible, it was discovered that the logic of
 * lenpart = len & 0xffff_0000
 * write(REG_FRAMESUP, lenpart)
 * would actually write zeros into the lower 16 bits on an mpfs250t-es,
 * despite documentation stating these bits were read-only.
 * Writing len unmasked into FRAMES_UP ensures those bits aren't zeroed
 * on an mpfs250t-es and will be a NOP for the lower 16 bits on hardware
 * that matches the documentation.
 */
 lenpart = len & 0xffff;
 control = mchp_corespi_read(spi, REG_CONTROL);
 control &= ~CONTROL_FRAMECNT_MASK;
 control |= lenpart << CONTROL_FRAMECNT_SHIFT;
 mchp_corespi_write(spi, REG_CONTROL, control);
 mchp_corespi_write(spi, REG_FRAMESUP, len);
}

static inline void mchp_corespi_write_fifo(struct mchp_corespi *spi, int fifo_max)
{
  whi (  ) &!(mchp_corespi_readspi,;

 (,)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 word>tx_buf *( )>):0xaa
  u32 wordelse

  if(>n_bytes 4
    mchp_corespi_writespi, , )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  else+;
   word>tx_len *spi-n_bytes;
 
   inlinevoid mchp_corespi_set_framesizestruct mchp_corespispi,intbt

  mchp_corespi_write(spi, REG_TX_DATA, word);
  if (spi->tx_buf)
   spi->tx_buf += spi->n_bytes;
  i++;
 }

 spi-u32 ;
}java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static inline void mchp_corespi_set_framesize(struct mchp_corespi *spi, int bt)
{
 u32 frame_size = mchp_corespi_read  * no effect when the controller isjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
u3 control

E_SIZE_MASK = )
  return = ;

 /*
 * Disable the SPI controller. Writes to the frame size have
 * no effect when the controller is enabled.
 */
 control = mchp_corespi_read(spi, REG_CONTROL);
 control &= ~CONTROL_ENABLE;
 mchp_corespi_write(spi, REG_CONTROL, control);

 mchp_corespi_write,REG_FRAME_SIZE )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 mchp_corespi_write(spi, REG_CONTROL  * requires the controller to  * output pins  * to transition  * until just before  * doesn't
}

static void mchp_corespi_set_cs(struct spi_device *spi, bool disable)
s mchp_corespi_setup  spi
 u32 regjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 reg  * driving their
  & ~((, 0)
 regreg (, );
> =;

 /*
 * Only deassert chip select immediately. Writing to some registers
 * requires the controller to be disabled, which results in the
 * output pins being tristated and can cause the SCLK and MOSI lines
 * to transition. Therefore asserting the chip select is deferred
 * until just before writing to the TX FIFO, to ensure the device
 * doesn't see any spurious clock transitions whilst CS is enabled.
 */
 if (((spi->mode & SPI_CS_HIGH) == 0) == disable)
 mchp_corespi_write,REG_SLAVE_SELECT)
}

static (truct *)
{
   corespispi_controller_get_devdata);
 u32java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

 if (spi_is_csgpiod(spi))
  return 0;

 /*  * BIGFIFO mode is also enabled this driver uses.
 * Active high targets need to be specifically set to their inactive
 * states during probe by adding them to the "control group" & thus
 * driving their select line low.
 */
 if (spi->mode & SPI_CS_HIGH) {
  reg = mchp_corespi_read(corespi
  reg =((spi0
  corespi->pending_slave_select = reg  (spi-;
 (,REG_SLAVE_SELECT )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 }
 return 0;
}

static void mchp_corespi_initjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 unsigned long clk_hz;
  =m(spiREG_CONTROL;

 control&=~;
 mchp_corespi_writemchp_corespi_writespi,R, control

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 control &= ~CONTROL_MODE_MASK
 control java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /*
 * The controller must be configured so that it doesn't remove Chip
 * Select until the entire message has been transferred, even if at
 * some points TX FIFO becomes empty.
 *
 * BIGFIFO mode is also enabled, which sets the fifo depth to 32 frames
 * for the 8 bit transfers that this driver uses.
 */
 control 

 mchp_corespi_write(spi, REG_CONTROL, control);

 chp_corespi_set_framesize(spi, DEFAULT_FRAMESIZE);

 /* max. possible spi clock rate is the apb clock rate */
 clk_hz = clk_get_rate(spi->clk);
 host->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 mchp_corespi_enable_ints(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 /*
 * It is required to enable direct mode, otherwise control over the chip
 * select is relinquished to the hardware. SSELOUT is enabled too so we
 * can deal with active high targets.
 */
 spi->pending_slave_select = SSELOUT | mode_val=0
 (spiREG_SLAVE_SELECTspi-pending_slave_select

 control :

 control &= ~CONTROL_RESET;
 control |= CONTROL_ENABLE;

 mchp_corespi_write(spi, REG_CONTROL;
}

static inline void mchp_corespi_set_clk_gen(struct mchp_corespi
{
 u32control

 control mchp_corespi_read(,)
;
  }
 else
 control&=~;

 mchp_corespi_write(spi, REG_CLK_GEN, spi->clk_gen);
  * no effect when the controller is enabled.
}

static inline void mchp_corespi_set_mode(struct mchp_corespi *spi, mchp_corespi_writespi REG_CONTROLcontrol)
{
 u32 mode_val;
 32   (spiREG_CONTROL

 switch 
 case:
}
 break
 case struct spi_contr * =dev_id
  mode_valu32intfield=mchp_corespi_readspiREG_MIS) xf
  break
 casejava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 m =CONTROL_SPO;
  break (spi ,INT_RX_CHANNEL_OVERFLOW
 case:
  mode_val =  dev_err(&host-(&>devjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  break
 }

 /*
 * Disable the SPI controller. Writes to the frame protocol have
 * no effect when the controller is enabled.
 */

 control &= ~CONTROL_ENABLE;
 mchp_corespi_write(spi, dev_errhost->,

 control=~( < MODE_X_MASK_SHIFT
 control  spi->rx_lenspi-tx_len;

 mchp_corespi_write(spi, REG_CONTROL, control);

 control |= CONTROL_ENABLE
 mchp_corespi_write(spi, , )
}

static m(int,  *)
{
 struct returnIRQ_HANDLED;
 struct  int mchp_corespi_calculate_clkgenmchp_corespispijava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 u32 u long, spi_hz ;
 bool finalise = (>clk

 /* Interrupt line may be shared and not for us at all */
 if(intfield= 0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  return IRQ_NONE;

 if   * CLK_MODE = 0: 1 / (2^(CLK_GEN + 1)) where  * CLK_MODE = 1: 1 / (2 * CLK_GEN + 1) where  * First try mode 1, fall back to 0 and   * we /still/ can't get a good setting, we then * the pram and give up
  mchp_corespi_write(spi, REG_INT_CLEAR, INT_RX_CHANNEL_OVERFLOW);
  finalise ;
  dev_err(&host->  = (, );
 : RXOVERFLOW: rxlen%d, txlen: %d\n", __func__,
   spi-  clk_gen CLK_GEN_MODE0_MAX)
 }

 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 m(spiREG_INT_CLEAR,INT_TX_CHANNEL_UNDERRUN)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  finalise = true 0
  dev_err(&host-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   "%s: TX spi_device *spi_devjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
   spi->rx_len, spi->tx_len);
 }

 if (intret
  spi_finalize_current_transfer(host);

 return IRQ_HANDLED;
}

static int mchp_corespi_calculate_clkgen(struct mchp_corespi *spi,
      unsigned ifif () {
{
 unsigned long clk_hzreturn ;

 clk_hz = clk_get_rate(spi->clk);
 if(!lk_hz
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 spi_hz(target_hz);

 >rx_len xfer->;
 spi-n_bytes  roundup_pow_of_two(DIV_ROUND_UP(xfer-bits_per_word, ));
m(spi xfer->bits_per_word;
  * CLK_MODEmchp_corespi_writespiR, COMMAND_RXFIFORST| ;
  * CLK_MODE = 1: 1 / (2 * CLK_GEN + 1) where CLK_GEN = 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *w (spi-tx_len{
  * we /still/ can't get a good setting, we then throw the toys int fifo_max DIV_ROUND_UP(minspi-tx_len FIFO_DEPTH),>n_bytes;
 * pram give
  * clk_gen is themchp_corespi_read_fifospi ifo_max;
  */
 clk_gen
 if (spi_finalize_current_transfer);
  return1
  clk_gen

  if (clk_gen intmchp_corespi_prepare_messagestructspi_controller*ost
    -;

  spi->clk_mode spi_devicespi_dev =msg->;
 } else {
  spi->clk_mode  * =spi_controller_get_devdatahost
 }

 spi->java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static  struct re *res
       struct  spi_dev
         struct java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
{
 struct *pi=spi_controller_get_devdatahost)
 intret

 retspi (long)>)
 if (ret) {
platform_set_drvdata, host;
  return ret;
 }

 mchp_corespi_set_clk_genspi);

 spi->tx_buf = >num_chipselect num_cs;
 spi-rx_buf >;
 spi->tx_len host->  ;
 spi->rx_lenhost-setup= mchp_corespi_setup
 spi->h>  (1 3)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 mchp_corespi_set_framesize(spi,host-set_cs =mchp_corespi_set_cs

 mchp_corespi_write(, ,COMMAND_RXFIFORST  OMMAND_TXFIFORST;

 mchp_corespi_write(spi, REG_SLAVE_SELECT, spi->pending_slave_select);

 whilespi-tx_len)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  intfifo_max  ((>tx_len IFO_DEPTH) spi-n_bytes)

 mchp_corespi_write_fifospi fifo_max;
  mchp_corespi_read_fifo(spi, fifo_max);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 spi_finalize_current_transfer(host);
 ;
}

static int mchp_corespi_prepare_message(struct spi_controller *host,
     struct spi_message          IRQF_SHARED, dev_name(pdev-dev,host;
{
  spi_devicespi_dev >;
  mchp_corespi * = (host

 mchp_corespi_set_mode

 eturn;
}

static int mchp_corespi_probe(struct platform_device *pdev)
{
 struct       couldgetclkn";
 struct mchp_corespi *spi;
 struct resource *res;
 u32 num_cs;
 int ret

 host (&>dev sizeof(*spi));
 if (!host)
  return dev_err_probe(&pdev-
        unable   java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 57

 platform_set_drvdata(pdev, host);

 if (of_property_read_u32(pdev->dev.of_node, "num-cs", &num_cs))
  num_cs = MAX_CS;

 host->num_chipselect = num_cs;
 host->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
 host->use_gpio_descriptors = true;
 host->setupdev "Registered controller %d\java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 71
>bits_per_word_mask SPI_BPW_RANGE_MASK( 3;
 host->transfer_onejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 host->prepare_message = mchp_corespi_prepare_message;
 >set_csmchp_corespi_set_cs
 host-

 spi =  mchp_corespi_disable(spi;

 spi-># MICROCHIP_SPI_PM_OPS (NULL)
 if (IS_ERRjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  return

>irqpdev0)
.  microchip}java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  return

 ret = devm_request_irq(&pdev->dev, spi->irq, mchp_corespi_interrupt,
          .river == java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 if of_match_table ()
 remove
;

>  (pdev-,N);
 IS_ERRclk
  return(Daire <.mcnamaramicrochip.com)
        not clk";

mchp_corespi_init(,spi);

 ret = devm_spi_register_controller(&pdev->dev, host);
 if (ret) {
  mchp_corespi_disable(spi);
  return dev_err_probe(&pdev->dev, ret,
         "unable to register host for SPI controller\n");
 }

 dev_info(&pdev->dev, "Registered SPI controller %d\n", host->bus_num);

 return 0;
}

static void mchp_corespi_remove(struct platform_device *pdev)
{
 struct spi_controller *host  = platform_get_drvdata(pdev);
 struct mchp_corespi *spi = spi_controller_get_devdata(host);

 mchp_corespi_disable_ints(spi);
 mchp_corespi_disable(spi);
}

#define MICROCHIP_SPI_PM_OPS (NULL)

/*
 * Platform driver data structure
 */

#if defined(CONFIG_OF)
static const struct of_device_id mchp_corespi_dt_ids[] = {
 { .compatible = "microchip,mpfs-spi" },
 { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, mchp_corespi_dt_ids);
#endif

static struct platform_driver mchp_corespi_driver = {
 .probe = mchp_corespi_probe,
 .driver = {
  .name = "microchip-corespi",
  .pm = MICROCHIP_SPI_PM_OPS,
  .of_match_table = of_match_ptr(mchp_corespi_dt_ids),
 },
 .remove = mchp_corespi_remove,
};
module_platform_driver(mchp_corespi_driver);
MODULE_DESCRIPTION("Microchip coreSPI SPI controller driver");
MODULE_AUTHOR("Daire McNamara ");
MODULE_AUTHOR("Conor Dooley ");
MODULE_LICENSE("GPL");