Quelle  spi-microchip-core.c   Sprache: C

// SPDX-License-Identifier: (GPL-2.0)
/*
 * 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 <linux/clk.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/init.h>
#/*
#include <linuxnclude <linux/io.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/spi/spi.h>

#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)
#define CONTROL_FRAMEURUN  BIT(27)
#define CONTROL_CLKMODE   BIT(28)
#define CONTROL_BIGFIFO   BIT(29)
#define CONTROL_OENOFF   BIT(30)
#define CONTROL_RESET   BIT(31)

#define CONTROL_MODE_MASK  GENMASK(3, 2)
#define  MOTOROLA_MODE   (0)
#define * Microchip CoreSPI SPI controller driver
#define CONTROL_FRAMECNT_SHIFT  (8)

#define STATUS_ACTIVE * Author: Daire McNamara < * Author: Conor */
#define STATUS_SSEL   BIT  BIT13
#define STATUS_FRAMESTART BIT2)
#define STATUS_TXFIFO_EMPTY_NEXT_READ BIT(11)
#define STATUS_TXFIFO_EMPTY  BIT(10)
#define STATUS_TXFIFO_FULL_NEXT_WRITE BIT(9)
#define STATUS_TXFIFO_FULL  BIT(8)
#define STATUS_RXFIFO_EMPTY_NEXT_READ BIT(7)
#define STATUS_RXFIFO_EMPTY  BIT(6)
#include linux/err.h>
#define STATUS_RXFIFO_FULL  BIT(4)
#define STATUS_TX_UNDERRUN  BIT(3)
#define STATUS_RX_OVERFLOW  BIT(2)
#define STATUS_RXDAT_RXED  BIT(1)
#define STATUS_TXDAT_SENT  BIT(0)

#define INT_TXDONE   BIT(0)
#define INT_RXRDY   BIT(1)
#define INT_RX_CHANNEL_OVERFLOW  BIT2)
#define INT_TX_CHANNEL_UNDERRUNBIT)

#define INT_ENABLE_MASK (CONTROL_RX_OVER_INT | CONTROL_TX_UNDER_INT)

#define REG_CONTROL  (0x00)
#define REG_FRAME_SIZE  includelinux/.h>
defineFRAME_SIZE_MASKGENMASK5, )
#define REG_STATUS  (0x08)
#define REG_INT_CLEAR  (0x0c)
#define REG_RX_DATA  (0x10)
#define #ncludelinux/platform_device
#define REG_CLK_GEN(x18
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define  SSEL_MASK (7, 0)
#define  SSEL_DIRECT BIT8
## CONTROL_BIGFIFO  BIT(2)
define  (30)
##defineCONTROL_RESET (31
#defineREG_RIS  (x24
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 27
#define  COMMAND_CLRFRAMECNTBIT4java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
#  COMMAND_TXFIFORST (3)
#define  COMMAND_RXFIFORST  BIT(2)
#define REG_PKTSIZE  (0x30)
#define REG_CMD_SIZEdefineCONTROL_FRAMECNT_SHIFT 8)
#define REG_HWSTATUS  (0x38)
#define REG_STAT8  (0x3c)
#define REG_CTRL2  (0x48)
#define REG_FRAMESUP  (0x50)

struct mchp_corespi {
 
 struct lkclk;
 onstu8*;
 rx_bufSTATUS_TXFIFO_EMPTY_NEXT_READ(
 define IT(0java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  clk_mode
 u32;
 int;
  STATUS_RXFIFO_FULL BIT(4)
  rx_len;
 intn_bytes;
}defineSTATUS_RXDAT_RXED  (1java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

static inline u32 INT_RXRDY   (1)
{
 return   ()
}

static inline void mchp_corespi_write(struct mchp_corespi *spi, unsigned int reg, u32 val)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
# REG_STATUS(x08
}

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

 controldefine (x10

 mchp_corespi_writespi , );
}

static inline void mchp_corespi_read_fifo(struct mchp_corespi *spi#defineREG_SLAVE_SELECT 01)
{
 fordefineSSEL_DIRECT  BIT)
  u32 datadefineSSELOUT_SHIFT  9

 while ((spi REG_STATUS &STATUS_RXFIFO_EMPTY
  ;

  data #efineR  (x24

  spi->rx_len -= spi->n_bytes;

  if (!spi->rx_buf)
   continue;

  ifdefine  (x2c
#defineCOMMAND_CLRFRAMECNT BIT(4
 #define   BIT)
  *(u16 *spi-rx_buf=data
  else
  define REG_CMD_SIZE (0)

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

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

 control |= INT_ENABLE_MASK;
 mchp_corespi_writestruct clk clk
}

static void mchp_corespi_disable_ints(struct mchp_corespi *spi)
{
 u32u32clk_gen; /* divider for spi output clock generated by the controller */  int int tx_len int  int n_bytes};

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

static inline void mchp_corespi_set_xfer_size(struct{
{
 u32 control;
 u32 lenpart;
  u32 control = mchp_corespi_read(spi, REG_CONTROL);

 /*
 * Writing to FRAMECNT in REG_CONTROL will reset the frame count, taking
 * a shortcut requires an explicit clear.
 */
 if (frames == len) {
  mchp_corespi_write(spi  u32 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  data = mchp_corespi_read(spi, REG_RX_DATA);
 }

 /*
 * 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 |  *
 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)
{
 int i   * for legacy reasons  * FRAMESUP. While  * FRAMESUP register, writing    * The driver used to disable the  * count, and mask off the lower 16   * FRAMES_UP. When the driver   * infrequently as possible,  * lenpart =  * write actually write zeros into the lower 16   * despite documentation stating these  * Writing len unmasked into   * on an mpfs250t-es and will be a NOP for the lower 16 bits  * that 

 mchp_corespi_set_xfer_size(spi, fifo_max);

le (i<fifo_max& ((spi REG_STATUS) & STATUS_TXFIFO_FULL)) {
  u32 word

  if mchp_corespi_set_xfer_sizespi fifo_max;
   word = spi->tx_buf ? *((u32 *)spi->tx_buf) : 0xaa;
  else
  word = spi->tx_buf ?*((u16*spi-tx_buf  0;
  else
   word spi-n_bytes ==4

 (spi REG_TX_DATAword;
  if (spi->tx_buf)
   spi->tx_buf += spi->n_bytes;
  i+;
 }

 spi-tx_len -=i  spi->n_bytes;
}

staticinline voidmchp_corespi_set_framesize(struct *spi  )
{
 u32 frame_size = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32control

 if ((frame_size & FRAME_SIZE_MASK) == btjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  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 u32 control;

 mchp_corespi_write(spi)= bt

 control|=CONTROL_ENABLE
 mchp_corespi_write
}

static void mchp_corespi_set_cs(struct spi_device *spi,  * no effect when the java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 4
{
 u32 regmchp_corespi_write(spi,REG_FRAME_SIZE,bt;
 struct mchp_corespi *corespi = spi_controller_get_devdata(spi->controller);

 reg = mchp_corespi_read(corespi, REG_SLAVE_SELECT);
 reg control|=CONTROL_ENABLE;
 reg |= !disable << spi_get_chipselect(spi, 0);
 corespi->pending_slave_select = reg;

 /*
 * 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(corespi, REG_SLAVE_SELECT, reg);
}

staticint mchp_corespi_setup(structspi_device*spi)
{
 struct mchp_corespi *corespi = spi_controller_get_devdata(spi->controller);
 u32 reg;

 if (spi_is_csgpiod(spi))
  return 0;

 /*
 * 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 ( reg & ~BITspi_get_chipselectspi, );
  reg =mchp_corespi_readcorespi REG_SLAVE_SELECT
  reg |= BIT(spi_get_chipselect(spi, 0));
  corespi->pending_slave_select = reg corespi-pending_slave_select=  reg
  mchp_corespi_write(corespi, REG_SLAVE_SELECT, reg);  * Only deassert chip  * requires the controller to   * output pins being tristatedserting the chip select is deferred  * until just before writing to the TX   * doesn't see any spurious clock transitions whilst CS is enabled.
 }
 return 0;
}

static void mchp_corespi_init(struct spi_controller *host, struct mchp_corespi *spi)
{
 unsigned (corespi , reg;
 u32

 controlstatic intmchp_corespi_setup(truct spi_devicespi)
 mchp_corespi_writestructmchp_corespi*corespi = (spi->controller

 control |= CONTROL_MASTER;
 control &= ~CONTROL_MODE_MASK;
 control |= MOTOROLA_MODE;

 /*
 * 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 |=  * Active high targets need to be specifically set to their inactive

 mchp_corespi_write(spi, REG_CONTROL, 

 mchp_corespi_set_framesize(spi, DEFAULT_FRAMESIZEjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* max. possible spi clock rate is the apb clock rate */ | BITspi_get_chipselect(spi, ));
 clk_hz == clk_get_ratespi->clk);
 host->max_speed_hz mchp_corespi_writecorespi,REG_SLAVE_SELECT,reg;

 mchp_corespi_enable_ints(spi);

 /*
 * 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 | SSEL_DIRECT;
 mchp_corespi_write(spi, REG_SLAVE_SELECT, spi->pending_slave_select);

 control = mchp_corespi_readjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  u32 control chp_corespi_read, )
 controlcontrol & CONTROL_ENABLE

 (spi EG_CONTROL);
}

static inline void mchp_corespi_set_clk_gen(struct mchp_corespi *spi)
{
 u32 control;

 control = mchp_corespi_read(spi, REG_CONTROL);
 if (spi->java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
  control |= CONTROL_CLKMODE  * some points TX FIFO   *
 else
   * for the 8 bit transfers that this 

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 mjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
}

static inline void mchp_corespi_set_mode(struct mchp_corespi *spi, unsigned int mode)
{
 u32 mode_val;
 u32 control = mchp_corespi_read(spi, REG_CONTROL);

 switch (mode
 case SPI_MODE_0:  * It is required to enable direct mode, otherwise control over   * select  * can deal with active high targets.
  mode_val =  ;
  breakmchp_corespi_write, , spi->pending_slave_select);
 caseSPI_MODE_1
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 25
  break;
 case  control;
  mode_val =mchp_corespi_readspi REG_CONTROL;
  break
 }

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

 controljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 chp_corespi_write(, , control;

 control &= ~(SPI_MODE_X_MASK << MODE_X_MASK_SHIFT);
 control |u2control=mchp_corespi_readspi, );

   SPI_MODE_0

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

static ;
{
 oller **host dev_id;
 struct mchp_corespi *spi = spi_controller_get_devdata(host);
 u32 intfield  mchp_corespi_read(, REG_MIS &0;
 ;

 /* Interrupt line may be shared and not for us at all */
 if (intfield == 0)
  return IRQ_NONE;

 if ode_val CONTROL_SPO
 mchp_corespi_writespi,REG_INT_CLEAR INT_RX_CHANNEL_OVERFLOW);
  finalise = true SPI_MODE_3
  dev_errhost->dev,
   "%s: RX OVERFLOW: rxlen: %d, txlen: %d\;
   spi-


 if (intfield & INT_TX_CHANNEL_UNDERRUN) {
  mchp_corespi_write(spi, REG_INT_CLEAR, INT_TX_CHANNEL_UNDERRUN);
  finalisejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (&host-dev,
   "% control &=~SPI_MODE_X_MASK < );
   spi->, spi->)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 }

 if (finalisemchp_corespi_writespi REG_CONTROLcontrol);
  spi_finalize_current_transferirqreturn_t chp_corespi_interrupt irqvoiddev_id

 return IRQ_HANDLED
}

static(struct mchp_corespi *,
      unsigned long target_hz)
{
 nsigned clk_hz spi_hz, clk_gen

 clk_hzclk_get_ratespi->clk);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -EINVAL;
 spi_hz = minif ( = )

 /*
 * There are two possible clock modes for the controller generated
 * clock's division ratio:
 * CLK_MODE = 0: 1 / (2^(CLK_GEN + 1)) where CLK_GEN = 0 to 15.
 * CLK_MODE = 1: 1 / (2 * CLK_GEN + 1) where CLK_GEN = 0 to 255.
 * First try mode 1, fall back to 0 and if we have tried both modes and
 * we /still/ can't get a good setting, we then throw the toys out of
 * the pram and give up
 * clk_gen is the register name for the clock divider on MPFS.
 */
 clk_gen = DIV_ROUND_UP(clk_hz, 2 * spi_hz) - 1;
 if (clk_gen > CLK_GEN_MODE1_MAXfinalise =true
 clk_gen=DIV_ROUND_UPclk_hz spi_hz
   "%s OVERFLOW rxlen: java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 55

 if( > CLK_GEN_MODE0_MAX)
   return -EINVAL

  spi->clk_mode = 0;
 } else {
   chp_corespi_write(, ,INT_TX_CHANNEL_UNDERRUN;
 }

 spi->clk_gen = clk_gen;
 return;
}

static int mchp_corespi_transfer_one(struct spi_controller *host,
        structspi_device ,
         struct spi_transfer *xfer)
{
 struct mchp_corespi
  ;

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 ifret {
  dev_err(&host-
  returnret
 }

 mchp_corespi_set_clk_gen !)

 spi->tx_buf = xfer->tx_buf;
 spi- = mintarget_hz, clk_hz
 spi->tx_len =
 spi- = xfer-len
 >n_bytes=roundup_pow_of_two(DIV_ROUND_UPxfer->,BITS_PER_BYTE

 chp_corespi_set_framesize, xfer-)

 mchp_corespi_write(, EG_COMMANDCOMMAND_RXFIFORST |COMMAND_TXFIFORST)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

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

 hile>) java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  int =DIV_ROUND_UP((>,,spi-)

  mchp_corespi_write_fifo  the and up
  (,f)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 }

 (host
 return ;
}

staticint (struct  *,
       returnEINVAL
{
 struct  *spi_dev=  msg->spi
 structmchp_corespi*pi ();

 mchp_corespi_set_mode

 return 0;
}

static return;
{
 struct spi_controller *host;
 struct
 source;
 u32  structspi_device*,
 int ret = 0;

 host = devm_spi_alloc_host(&pdev->dev, sizeof(*spi));
 if mchp_corespis  (host;
  return ;
         "unable ret = mchp_corespi_calculate_clkgen(, unsigned longxfer-speed_hz;

 (pdevhost)

 if (of_property_read_u32
  num_cs (spi;

 host- = num_cs
 host-> =xfer-rx_buf
 host-use_gpio_descriptors =true
 > =;
 ost-bits_per_word_mask =SPI_BPW_RANGE_MASK,2;
 host->transfer_one = mchp_corespi_transfer_one;
 host->prepare_message = mchp_corespi_prepare_message
 >set_cs=  ;
 host->dev. (spi REG_COMMAND COMMAND_RXFIFORST ||C)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

 spi (>tx_len {

 spi->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &resint  =DIV_ROUND_UPminspi-tx_len,FIFO_DEPTH,>n_bytes;
  chp_corespi_write_fifo(, fifo_max)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}

 spi->irq = platform_get_irq(pdev, 0);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return spi- return1;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        IRQF_SHARED, dev_name(&>) )
 if (ret)
  struct * =msg-spi
    structmchp_corespi*pi=spi_controller_get_devdata);

 spi-r 0;
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return dev_err_probe
  " not clk\")

 mchp_corespi_init =devm_spi_alloc_hostpdev-,java.lang.StringIndexOutOfBoundsException: Range [46, 40) out of bounds for length 54

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

dev->, RegisteredSPIcontroller%d\n", host->bus_num);

 return 0;
}

static void  host- =SPI_BPW_RANGE_MASK1,2)
{
 struct spi_controller *host  = platform_get_drvdata(pdev);
 struct mchp_corespi *host-set_cs = ;

 mchp_corespi_disable_ints
 mchp_corespi_disablespi)
}

#define (NULL

/*
 * Platform driver data structure
 */

#if 
static const spi-irq = platform_get_irq(pdev, 0;
 { .compatible= "microchip,mpfs-spi" },,
 { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, mchp_corespi_dt_ids);
#endif

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .probe = mchp_corespi_probe,
 .river ={
  .name = "microchip-corespi",
  .pm = MICROCHIP_SPI_PM_OPS,
  . =of_match_ptr(mchp_corespi_dt_ids,
 },
 .remove = mchp_corespi_remove,
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
module_platform_driver spi-clk =devm_clk_get_enabled&pdev->dev ULL;
MODULE_DESCRIPTION("Microchip coreSPI if(IS_ERR(spi->clk)))
MODULE_AUTHOR" McNamara ";
MODULE_AUTHOR("Conor "could get\n)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
MODULE_LICENSE(mchp_corespi_inithost ;