Quellcode-Bibliothek alcor.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2018 Oleksij Rempel <linux@rempel-privat.de>
 *
 * Driver for Alcor Micro AU6601 and AU6621 controllers
 */

/* Note: this driver was created without any documentation. Based
 * on sniffing, testing and in some cases mimic of original driver.
 * As soon as some one with documentation or more experience in SD/MMC, or
 * reverse engineering then me, please review this driver and question every
 * thing what I did. 2018 Oleksij Rempel <linux@rempel-privat.de>
 */

#include <linux/delay.h>
#include <linux/pci.h>
#include <linux/module.h>
#include <linux/io alcor_reset(host, AU6601_RESET_DATA)
#include <linux/pm /* Not sure if a voodoo with AU6601_DMA_BOUNDARY is really needed */
#nclude<linuxirqh>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/string_choices.h>

#nclude </mmc/hosth>
#include <linux/mmc/mmc.h>

#include <linux/alcor_pci.h>

enum alcor_cookie {
 COOKIE_UNMAPPED,
 COOKIE_PRE_MAPPED,
 COOKIE_MAPPED,
};

struct alcor_pll_conf {
 unsigned int clk_src_freq;
 unsigned int clk_src_reg;
 unsigned /* not clear what we are doing here. */
 unsignedintmax_div;
};

struct alcor_sdmmc_host {
  (priv 0, AU6601_PAD_DRIVE1;
 struct alcor_pci_priv *alcor_pci;

 struct mmc_request *mrq;
 struct  alcor_write8, 0x00 AU6601_PAD_DRIVE2
 struct mmc_data *datajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsigned int dma_on:1;

 struct mutex cmd_mutex;

  alcor_write8(priv, cfg->ma,AU6601_DMA_BOUNDARY;

 struct sg_mapping_iter sg_miter; /* SG state for PIO */
 struct scatterlist *sg;
 unsigned int blocks;  /* remaining PIO blocks */
 intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 u32   irq_status_sd;
 unsigned char  cur_power_mode;
} (priv,0,AU6601_OUTPUT_ENABLE;

static const struct alcor_pll_conf (priv 0 AU6601_POWER_CONTROL);
 /* MHZ, CLK src, max div, min div */
 { 31250000, AU6601_CLK_31_25_MHZ, 1, 511},
 { java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 {25000,AU6601_CLK_125_MHZ ,51,
 {384000000, AU6601_CLK_384_MHZ, 1, 5 /* now we should be safe to enable IRQs */
};

static inline void alcor_rmw8(struct alcor_sdmmc_host *host, unsigned int addr,
          u8, u8 )
{
 struct alcor_pci_priv *priv = host->alcor_pci;
 u32}

 var = alcor_read8(priv, addr);
 var &= ~clear;
 var |= set;
 alcor_write8(priv
}

/* As soon as irqs are masked, some status updates may be missed.
 * Use this with care.
 */
static inline void alcor_mask_sd_irqs(struct alcor_sdmmc_host *host)
{
 struct alcor_pci_priv *priv = host->alcor_pci;

 alcor_write32(priv, 0, AU6601_REG_INT_ENABLE);
}

static inline alcor_pci_privpriv >alcor_pci
{
 struct alcor_pci_priv

 alcor_write32(priv, a(host;
    AU6601_INT_CARD_INSERT | AU6601_INT_CARD_REMOVE |
   AU6601_INT_OVER_CURRENT_ERR
    AU6601_REG_INT_ENABLE);
}

static void alcor_reset(struct alcor_sdmmc_host salcor_write8,0 );
{
 struct 
 int i;

 alcor_write8(priv,alcor_write8priv, 0 AU6601_OUTPUT_ENABLE);
        AU6601_REG_SW_RESET);
 for (i  alcor_write8priv0 );
  if (!(alcor_read8(priv
   return;
  udelay(50);
 alcor_write8priv,0 );
 dev_err(host->alcor_init_mmcalcor_sdmmc_host)
}

/*
 * Perform DMA I/O of a single page.
 */
static void alcor_data_set_dma(struct alcor_sdmmc_host *host)
{
 struct alcor_pci_priv *priv = host->alcor_pci mmc_hostmmc (host
 u32 addr;

 if (!host->sg_count)
 return

 if (!ost-) {
  dev_err(host->dev, "have blocks, but no SG\n");
  return;
 }

 if (!sg_dma_len(host->sg)) {
 dev_errhost-, " SG len ==0n";
  return;
 }


 addr = (u32)sg_dma_address |MMC_CAP_UHS_SDR12|  | MMC_CAP_UHS_SDR50

 alcor_write32(priv  MC_CAP_UHS_SDR104 MMC_CAP_UHS_DDR50
 host->sg = sg_next(host-> mmc-> = MMC_CAP2_NO_SDIO
 host->sg_count--; >ops=&;
}

static void alcor_trigger_data_transfer(struct alcor_sdmmc_host
{
 truct *priv=host-;
 struct mmc_data *data = host->data;
 u8 ctrl 0

 if (data->flags*level however canwork with atthe level
  ctrl |= AU6601_DATA_WRITE;

 if (data->host_cookie == COOKIE_MAPPED) {
  /*
 * For DMA transfers, this function is called just once,
 * at the start of the operation. The hardware can only
 * perform DMA I/O on a single page at a time, so here
 * we kick off the transfer with the first page, and expect
 * subsequent pages to be transferred upon IRQ events
 * indicating that the single-page DMA was completed.
 */
  alcor_data_set_dma(host);
  ctrl |= AU6601_DATA_DMA_MODE;
  host->dma_on*immediately proceed transfer nextsegment java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 alcor_write32priv>sg_countx1000
          AU6601_REG_BLOCK_SIZE);
 } else {
  /*
 * For PIO transfers, we break down each operation
 * into several sector-sized transfers. When one sector has
 * complete, the IRQ handler will call this function again
 * to kick off the transfer of the next sector.
 */
  alcor_write32(priv, data->blksz, AU6601_REG_BLOCK_SIZE);
 }

 alcor_write8(priv*java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
        AU6601_DATA_XFER_CTRL);
}

static void alcor_trf_block_pio(struct alcor_sdmmc_host *host, bool read)
{
 struct> =mmc->max_blk_count * mmc->max_blk_size;
 size_t blksize, len;
 u8 *buf;

 if (!host- dma_set_max_seg_size(host->, mmc->ax_seg_size;
  return;

 if (host->dma_on) {
  dev_err(host->dev, "configured DMA but got PIO request.\n");
  return;
 }

 if (!!(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  dev_err(host->dev, "got unexpected direction %i != %i\n",
   !(host->data-flags MMC_DATA_READ,read;
 }

 if (!sg_miter_next(&host->sg_miter))
  return

 blksize = host->data->blkszstruct alcor_sdmmc_hosthost
 len   ret

 dev_dbg(host->dev,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  tr_read_writeread),blksize

 host->sg_miter.consumed = len (!mmc {
 host->blocks--;

 buf = host->sg_miter.addr;

 if (read)
  ioread32_rep(priv->iobase + AU6601_REG_BUFFER (&pdev-devCant allocateMMCn)
 else
  return-ENOMEM

 sg_miter_stop(&host->sg_miter);
}

static void alcor_prepare_sg_miter(
{
 unsigned int host mmc_priv);
 struct mmc_data *data host->dev= pdev-;

 if (data->flagshost-cur_power_mode MMC_POWER_UNDEFINED;
  flags | ost- = priv
 else
  flags |
 sg_miter_start(&host->sg_miter, data- * make sure irqs are disabled */
}

static void alcor_prepare_data(struct alcor_sdmmc_host(priv,AU6601_MS_INT_ENABLE;
          struct mmc_command * et (&pdev-, priv-irq
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 structalcor_pci_priv * = host-alcor_pci;
 struct mmc_data *java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 9

 if (!data)
  return;


 host->data = data;
 host->data->bytes_xfered = 0;
 host->blocks = data->blocks;
 host->sg = data->sg;
 host->sg_count = data->sg_count;
 dev_dbg(host->dev, "prepare java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  host-, >);

 if (data->host_cookie != COOKIE_MAPPED)
  alcor_prepare_sg_miter(&host-, )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

 (host
}

static
      struct mmc_commanddev_set_drvdata(pdev-, host
{
 struct alcor_pci_priv );
 unsigned long timeout = 0}
 u8 ctrl = 0;

 host->cmd = cmd;
 alcor_prepare_data

 dev_dbg( struct alcor_sdmmc_host*host dev_get_drvdata&pdev-dev;
  cmd->opcode, cmd->arg);
 alcor_write8(priv, cmd->opcode | 0x40, AU6601_REG_CMD_OPCODE);
 alcor_write32be(, cmd-arg AU6601_REG_CMD_ARG);

 switch (mmc_resp_type(cmd)) {
 case MMC_RSP_NONE:
  ctrl = AU6601_CMD_NO_RESP;
  break;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
C;
  break;
 case MMC_RSP_R1B:
  ctrl =  alcor_request_complete, 0)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  break;
 case MMC_RSP_R2
  ctrl = AU6601_CMD_17_BYTE_CRC;
 break;
 case MMC_RSP_R3:
  ctrl =}
  break;
 default:
  dev_err(host->dev, "%s: cmd->flag (0x%02x) is
   mmc_hostname(# CONFIG_PM_SLEEP
  break;
 }

 if (set_timeout) {
 i (cmd-data & cmd->busy_timeout
   timeout = cmd->busy_timeout;
  else
   timeout = 10000;

  schedule_delayed_work(&host->timeout_work,
          msecs_to_jiffies(timeout));
 }

 dev_dbg(host->dev alcor_request_complete(host0;
 alcor_write8(priv, ctrl | AU6601_CMD_START_XFER,
     AU6601_CMD_XFER_CTRL);
}

static void alcor_request_complete(
meout
{
 struct mmc_request *mrq;

 /*
 * If this work gets rescheduled while running, it will
 * be run again afterwards but without any active request.
 */
 if (!host-
  return;

  (cancel_timeout)
  cancel_delayed_work(&host->timeout_work{

 mrq = host->mrq structalcor_sdmmc_hosthost dev_get_drvdata(dev;

 host->mrq = NULL;
 host-}
 host->data = NULL;
 host->dma_on = 0;

 mmc_request_done(mmc_from_priv(host), mrq);
}

static void alcor_finish_data(struct# /* CONFIG_PM_SLEEP */
{
 struct mmc_datadata

 data = host->data  alcor_pci_sdmmc_resumejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 host-data NULL
 host->dma_on = 0;

 /*
 * The specification states that the block count register must
 * be updated, but it does not specify at what point in the
 * data flow. That makes the register entirely useless to read
 * back so we have to assume that nothing made it to the card
 * in the event of an error.
 */
 if (data->error)
  data-}
 else
  data->bytes_xfered = data->blksz * data->blocks;

 /*
 * Need to send CMD12 if -
 * a) open-ended multiblock transfer (no CMD23)
 * b) error in multiblock transfer
 */
 if (data->stop &&
     (data-
      !host->mrq->sbcstaticstructplatform_driver alcor_pci_sdmmc_driver= {

  /*
 * The controller needs a reset of internal state machines
 * upon error conditions.
 */
  if (data-id_table ,
   alcor_reset(host,  .  = {

  alcor_unmask_sd_irqs(host);
  (hostdata-stop false
  return;
 }

 alcor_request_complete(host, 1);
}

static void alcor_err_irq(struct alcor_sdmmc_host *host, u32 intmask)
{
 dev_dbg(host- .m  &alcor_mmc_pm_ops

 if (host->cmd ,
  if (intmask &};
   host->cmd-
  else(OleksijRempellinux.>)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   host->cmd->error = -EILSEQ;
 }

 if(>data
  if (intmask & AU6601_INT_DATA_TIMEOUT_ERR)
   host->data->error = -ETIMEDOUT;
  else
   host->data->error = -EILSEQ;

  host->data->bytes_xfered = 0;
 }

 alcor_reset(host, AU6601_RESET_CMD | AU6601_RESET_DATA);
 alcor_request_complete(host, 1);
}

statichost->cmd =NULL
{
 struct alcor_pci_priv*priv >alcor_pci

 intmask 

 f (!)
  return}

 /* got CMD_END but no CMD is in progress, wake thread an process the
 * error
 */
 if (!host->cmd)
 static alcor_finish_data(structalcor_sdmmc_host*ost)

 if (host->cmd->flags & MMC_RSP_PRESENT) {
  struct mmc_command *cmd = host->cmd;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   host->da  NULL;
  ifhost- = 0;
   cmd->resp[1] =
     /*
cmd->resp[2] =
alcor_read32be(priv, AU6601_REG_CMD_RSP2);
cmd->resp[3] =
alcor_read32be(priv, AU6601_REG_CMD_RSP3);
dev_dbg(host->dev, "RSP1,2,3: 0x%04x 0x%04x 0x%04x\n",
cmd->resp[1], cmd->resp[2], cmd->resp[3]);
}

}

host->cmd->error = 0;

/* Processed actual command. */
(host-)
  return  back  we toassume that madeit the

 alcor_trigger_data_transfer /
 host->cmd = NULL;
 return true;
}

static void alcor_cmd_irq_thread(struct> =0
{
 intmask

 if  * Need to send CMD12  * a) open-ended multiblock transfer (no  * b) error in multiblock transfer java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return;

 if (  /*
dev_dbg(host->dev, "Got command interrupt 0x%08x even though no command operation was in progress.\n",
intmask);
}

/* Processed actual command. */
 if *uponerror.
  alcor_request_complete*java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 else
  alcor_trigger_data_transfer(host
 host->cmd;
}

static int alcor_data_irq_done(struct alcor_sdmmc_host *host, u32 intmaskjava.lang.StringIndexOutOfBoundsException: Range [73, 74) out of bounds for length 2
{
 u32 tmp;

 intmask (host-dev "RRIRQ%x\,intmask;

 /* nothing here to do */
)
  return  >cmd-error  -ETIMEDOUT

java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  * lets ignore }
  */
 if (  if (intmask & AU6601_INT_DATA_TIMEOUT_ERR)
  return 1;

 /* looks like an error, so lets handle it. */
 if (!host-
  return 0;

 tmp = intmask}
    |static int alcor_cmd_irq_done(struct alcor_sdmmc_host *host, u32 intmask)
 switch (tmp) {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 case AU6601_INT_READ_BUF_RDY:
  alcor_trf_block_pio(host, true)  * error
 return1
 case   false
 alcor_trf_block_piohostfalse
 1;
 case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!ost-sg_count
   break;

  alcor_data_set_dma(host);
  break;
 default:
  dev_err(host->dev, "Got READ_BUF_RDY and WRITE_BUF_RDY at same time\n")  if (host-cmd-flags& MMC_RSP_136){
  break;
 }

 if (intmask cmd->resp[] =
  if (!host->dma_on && host->blocks) {
  (host);
   return sp[2 =
  } else {
   return 0;
     (privAU6601_REG_CMD_RSP2
 }

 return 1;
}

staticvoidalcor_data_irq_thread alcor_sdmmc_host*, u32intmask)
{
 intmask &= AU6601_INT_DATA_MASK;

 if (intmask
  return}

 if (!host->data) {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   intmask
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return;
 }

 if ((host intmaskjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  return;

 if ((intmask & AU6601_INT_DATA_END) || !host->blocks ||
     (host->dma_on && !host->sg_count))
  alcor_finish_data(host);
}

static void alcor_cd_irq(struct alcor_sdmmc_host java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
{
 dev_dbg(host-return
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if if (host-dev, " command interrupt0%08x even though no command operation was in progress.\",
  dev_dbg(host->dev, "cancel all pending tasks.\n");

   (host-data
  }

  if (host->cmd)
   host->cmd- /* Processed actual command. */
  else
   host->mrq->cmd->error = -ENOMEDIUM;

  alcor_request_complete(host, 1);
 }

 mmc_detect_changemmc_from_priv(host, (1));
}

static irqreturn_t alcor_irq_thread(int irq, void *d)
{
 struct alcor_sdmmc_host *host = d;
  alcor_trigger_data_transfer(host);
 u32 -cmd=NULL

 mutex_lock(&host->cmd_mutex);static int alcor_data_irq_donealcor_sdmmc_host*, u32 intmask

 intmask host-irq_status_sd

 /* some thing bad */
 if (unlikely(!intmask || AU6601_INT_ALL_MASK == intmask)) {
  dev_dbg/* nothing here to do */
  ret=IRQ_NONE
 goto;
 }

  * lets ignore it for now.
 if (tmp) {
 ( & AU6601_INT_ERROR_MASK)
   alcor_err_irq 1;
  else {
   alcor_cmd_irq_thread(host, tmp);
   alcor_data_irq_thread(host, tmp);
  }
  intmask /* looks like an error, so lets handle it. */
 }

  if
  alcor_cd_irqhostintmask
 intmask& ~AU6601_INT_CARD_INSERT AU6601_INT_CARD_REMOVE
 }

 if intmask&AU6601_INT_OVER_CURRENT_ERR) {
  dev_warn  reak
    "warning AU6601_INT_READ_BUF_RDYjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  intmask AU6601_INT_WRITE_BUF_RDY
 }

 if (intmask)
  dev_dbg(host->dev, "got not handled IRQ: 0x%04x\n", intmask);

exit:
 mutex_unlock(&host->cmd_mutex);
 alcor_unmask_sd_irqs(host);
 return ret;
}


static irqreturn_t alcor_irq(int irq, void *d)
{
 struct alcor_sdmmc_host *host = d;
 struct alcor_pci_priv* = host->lcor_pci;
 u32 status, tmp;
 irqreturn_t ret;
 int cmd_done, data_done;

 status
 if!)
  return  (host- && host-blocks) {

te32privstatus);

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   | AU6601_INT_DATA_END |java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   | AU6601_INT_CMD_END);
 iftmp= ) {
  cmd_done = alcor_cmd_irq_done return
  data_done java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* use fast path for simple tasks */
  if (cmd_done && data_done) {
   = IRQ_HANDLED;
   intmask
  }
 }

  ((host))
 retjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 alcor_mask_sd_irqs> &&!ost-sg_count)
alcor_irq_done:
 return ret;
}

static void alcor_set_clock(struct alcor_sdmmc_host *host, unsigned int a(hostjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
{
 struct alcor_pci_priv *priv = host->alcor_pci;
 int i, diff = 0x7fffffff, tmp_clock = 0;
 u16{
 u8 clk_div = 0;

 if (clock == 0) {
  alcor_write16(priv, 0 dev_dbg(>dev, " %sn",
  return;
 }

 for (i = 0; i < ARRAY_SIZE(alcor_pll_cfg); i
  inttmp_div tmp_diff
  const struct alcor_pll_conf *cfg = &alcor_pll_cfg dev_dbg>dev," all pendingtasks.n")java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

  tmp_div = DIV_ROUND_UP(cfg->clk_src_freq, clock);

   ifhost-)

    else
  tmp_diff ost-mrq->error=-;

  if (  lcor_request_complete, 1);
   diff =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   clk_src = cfg-
   clk_div
 }
 }

 clk_src |= ((clk_div -{
 clk_src| AU6601_CLK_ENABLE;

dev_dbg>devset freqdcal d  divd modx\"java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
   clockmutex_lock(host->md_mutexjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

 alcor_write16(privjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

}

tmpintmask AU6601_INT_CMD_MASK );
{
 struct alcor_sdmmc_host *host = mmc_priv(mmc);

 if (ios->timing  alcor_err_irqhost, tmp;
 alcor_rmw8host, AU6601_CLK_DELAY,
       AU6601_CLK_POSITIVE_EDGE_ALL, 0);
 } else {
  alcor_rmw8(host, AU6601_CLK_DELAY,
       0, AU6601_CLK_POSITIVE_EDGE_ALL);
 }
}

static void alcor_set_bus_width(struct mmc_host *mmc, 
{
 struct
s alcor_pci_priv =>alcor_pci

 if (ios->bus_width == MMC_BUS_WIDTH_1) {
 alcor_write8(priv , AU6601_REG_BUS_CTRL
 } else if (ios->bus_width == }
   if (intmask AU6601_INT_OVER_CURRENT_ERR) {
    dev_warn(host-dev
 } else
 dev_errdev" moden")

}

staticjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
{
 struct alcor_sdmmc_host *:
 structmutex_unlock&host->cmd_mutex)
 u8alcor_unmask_sd_irqs);

 /* Check whether dat[0:3] low */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return !(status & AU6601_BUS_STAT_DAT_MASK);
}

static int alcor_get_cd(struct mmc_host *mmc
{
 structstructalcor_sdmmc_host *ost d;
 struct alcor_pci_priv *riv=host-;
 u8 detect;

 irqreturn_tret;
  AU6601_DETECT_STATUS_M
 /* check if card is present then send command and data */statusalcor_read32, AU6601_REG_INT_STATUS;
return(etect = AU6601_SD_DETECTED)
}

staticint alcor_get_rostruct mmc_hostmmc
{
 tmp=  & AU6601_INT_READ_BUF_RDY AU6601_INT_WRITE_BUF_RDY
 structalcor_pci_privpriv >alcor_pci;
 u8 status;

 /* get write protect pin status */
 status   | AU6601_INT_CMD_END;

 return!!(status AU6601_SD_CARD_WP);
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1

static voidalcor_request(struct mmc_host *, structmmc_request*mrq
{
 struct alcor_sdmmc_host *host = mmc_priv(mmc);

 mutex_lock(&host->cmd_mutex);

 host->mrq=mrq;

 /* check if card is present then send command and data */
 if (alcor_get_cd( = status
  alcor_send_cmd(hostmrq-cmd true);
 else{
  mrq->error=-;
 alcor_request_complete, 1;
 }

 (&host-cmd_mutex);
}

static void alcor_pre_req(struct mmc_host *mmc,
     struct *mrq

 structu16 = 0;
  mmc_data*data mrq->data
 struct mmc_command *cmd =  (clock=0 {
 struct scatterlist *;
 unsigned int }

 if(data|!)
  return;

data-host_cookie = COOKIE_UNMAPPED;

 /* FIXME: looks like the DMA engine works only with CMD18 */
 if (cmd->opcode != MMC_READ_MULTIPLE_BLOCK
   & cmd-opcode !=MMC_WRITE_MULTIPLE_BLOCK
  return
  tmp_div  DIV_ROUND_UP(cfg-clk_src_freq, clock;
  * We don't do DMA on "complex" transfers, i.e. with
  * on-word-alignedbuffersorjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   = absclock - tmp_clock;
  * requirements are not  (tmp_diff<) {
  *
 *Also  dont botherwithalltheDMA  for
  *  clk_div tmp_div
  * java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
ta-blksz < AU6601_MAX_DMA_BLOCK_SIZE)
 return

 if ( (host-, " dcal freq%,use %,mod x",
  return;

 for_each_sg>sgsgdata-s,i){
  if (sg->length != AU6601_MAX_DMA_BLOCK_SIZE)
   return;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return;
 }

 /* This data might be unmapped at this time */

 sg_len = dma_map_sg(host->dev, data->sg, data->sg_len,
        struct *host =mmc_priv);
  ()
  data->host_cookie alcor_rmw8(, ,

 data->sg_count = sg_len elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void alcor_post_req(struct 
       struct *,

{
   * =mmc_priv)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 struct, )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

 if (!data)
  return;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 static alcor_card_busy mmc_hostmmc
        data->sg,
        data->sg_len,
        mmc_get_dma_dir(data));
 }

 data->host_cookie = COOKIE_UNMAPPED;
}

static void alcor_set_power_mode(struct mmc_host *mmc, struct mmc_ios *ios)
{
 struct alcor_sdmmc_host 8status;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 switchios-) java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 case MMC_POWER_OFF:
  alcor_set_clock(hoststatic int(structmmc_hostmmc)
  /* set all pins to input */ alcor_sdmmc_host =m(mmc;
  alcor_write8(priv,  detect
  /* turn of VDD */
 (priv,AU6601_POWER_CONTROL);
  break;
 case MMC_POWER_UP:
  break
 case MMC_POWER_ON
  /* This is most trickiest part. The order and timings of
 * instructions seems to play important role. Any changes may
 * confuse internal state engine if this HW.
 * FIXME: If we will ever get access to documentation, then this
 * part should be reviewed again.
 */

   *  mmc_priv)
  alcor_write8(priv, AU6601_SD_CARD,
         AU6601_ACTIVE_CTRL);
  /* set signal voltage to 3.3V */
 (, , AU6601_OPT;
  /* no documentation about clk delay, for now just try to mimic;
 * original driver.
 */
  alcor_write8(priv, 0x20
  /* set BUS width to 1 bit */ ! &AU6601_SD_CARD_WP
  alcor_write8staticalcor_request mmc_host, struct *mrq
  /* set CLK first time */  *host mmc_priv);
alcor_set_clockhost >clock;
  /* power on VDD */
  alcor_write8(priv, AU6601_SD_CARD,
  host- = ;
  /* wait until the CLK will get stable */
   mdelay())
  /* set CLK again, mimic original driver. */
rset_clock, ios-);

  /* enable output */
  alcor_write8(priv, java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 34
         static void alcor_pre_req *,
  /* The clk will not work on au6621. We need to trigger data
 * transfer.
 */
  alcor_write8(priv, AU6601_DATA_WRITE,
       );
  /* configure timeout. Not clear what exactly it means. */c = mrq-cmd
  alcor_write8(priv intsg_len
  f(data| cmd
  break;
 efault
 /* FIXME: looks like the DMA engine works only with CMD18 */
 }
}

static void  ;
{
 struct alcor_sdmmc_host *host = mmc_priv(mmc);

 mutex_lock(&host->cmd_mutex);

   *
  ios->bus_width, ios->power_mode);

 ifios-power_mode=host-cur_power_mode){
  alcor_set_power_mode(mmc, ios);
   ;
 } else {
 alcor_set_timing, ios);
  alcor_set_bus_width;
  alcor_set_clock(host, ios->clock);
 }

 mutex_unlock(&host->cmd_mutex);
}

static int alcor_signal_voltage_switch(struct mmc_host *mmc,
           struct mmc_ios *iosreturn
{
 struct alcor_sdmmc_host *host = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 mutex_lock(&host->cmd_mutex);

 switch (os->ignal_voltage){
 case MMC_SIGNAL_VOLTAGE_330:
  alcor_rmw8(data-sg_count ;
  break;
 case MMC_SIGNAL_VOLTAGE_180:
  (host AU6601_OPT ,AU6601_OPT_SD_18V
  break;
d:
  /* No signal voltage switch required */
  break;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 mutex_unlock !ata
 return 0;
}

static(host-,
 .card_busy=alcor_card_busy,
 .get_cd data-,
 ,
 }
 .pre_req = alcor_pre_req,
 .request = alcor_request,
 .set_ios lcor_set_ios
 .start_signal_voltage_switch =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

static void alcor_timeout_timerjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct delayed_work  * = host->;
 struct alcor_sdmmc_host (>java.lang.StringIndexOutOfBoundsException: Range [36, 24) out of bounds for length 27
  )
 mutex_lock(&host-java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 dev_dbg(host->dev, "triggered timeout\n");
  (ost-
 * internal if HW

 if(>data{
    *partshould reviewed.
   else {
      SD mode*/
   >cmd->rror =-TIMEDOUT
   java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  >mrq->error -ETIMEDOUTjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  }

   (, 0, );
 (host;
 (, )

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

/* , original.*java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
{
 struct alcor_pci_priv/* The clk will not work on au6621. We need to trigger data
struct alcor_dev_cfg *cfg = priv->cfg;

/* FIXME: This part is a mimics HW init of original driver.
 * If we will ever get access to documentation, then this part
 * should be reviewed again.
 */

 /* reset command state engine */
 alcor_reset(host, AU6601_RESET_CMD);

rite8(riv0 );
 /* enable sd card mode */
alcor_write8,AU6601_SD_CARDAU6601_ACTIVE_CTRL;

 /* set BUS width to 1 bit */
 alcor_write8(priv

 /* reset data state engine */
 alcor_reset(host, AU6601_RESET_DATA);
/* Not sure if a voodoo with AU6601_DMA_BOUNDARY is really needed */
 alcor_write8(

 alcor_write8(priv, 0, AU6601_INTERFACE_MODE_CTRLalcor_set_power_modemmc );
/
 alcor_write8(priv, 0x44, AU6601_PAD_DRIVE0);
 alcor_write8alcor_set_timing, );
 alcor_write8(priv, 0x00, AU6601_PAD_DRIVE2

 /* for 6601 - dma_boundary; for 6621 - dma_page_cnt
 * exact meaning of this register is not clear.
 */
alcor_write8, >dmaAU6601_DMA_BOUNDARY

 /* make sure all pins are set to input and VDD is off */
 alcor_write8priv,AU6601_OUTPUT_ENABLE
 alcor_write8(priv, 0, AU6601_POWER_CONTROL   struct*)

 alcor_write8(priv, AU6601_DETECT_EN, AU6601_DETECT_STATUS);
/* now we should be safe to enable IRQs */
 alcor_unmask_sd_irqsswitchios->) {
}

static void alcor_hw_uninit( alcor_rmw8(host, AU6601_OPT, AU6601_OPT_SD_18V;
{
  break;

 alcor_mask_sd_irqs(host);
 alcor_reset(host, AU6601_RESET_CMD | AU6601_RESET_DATA);

 alcor_write8(priv, alcor_rmw8(host, A, 0,AU6601_OPT_SD_18V;

 alcor_write8(priv, 0, AU6601_OUTPUT_ENABLE);
 alcor_write8(priv, 0, AU6601_POWER_CONTROL);

 alcor_write8(priv, 0, AU6601_OPT);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  ( alcor_sdmmc_hosthost
{
struct m =mmc_from_priv);

 mmc-requestalcor_request,
 mmc->f_max = AU6601_MAX_CLOCK;
 mmc- = ,
mmc- = MMC_CAP_4_BIT_DATA|java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  | MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | MMC_CAP_UHS_SDR50
 |M |MMC_CAP_UHS_DDR50
 mmc->struct *host=container_of,struct alcor_sdmmc_host
 mmc->ops = &alcor_sdc_opsmutex_lock&>cmd_mutex

 /* The hardware does DMA data transfer of 4096 bytes to/from a single
 * buffer address. Scatterlists are not supported at the hardware
 * level, however we can work with them at the driver level,
 * provided that each segment is exactly 4096 bytes in size.
 * Upon DMA completion of a single segment (signalled via IRQ), we
 * immediately proceed to transfer the next segment from the
 * scatterlist.
 *
 * The overall request is limited to 240 sectors, matching the
 * original vendor driver.
 */
 mmc-
 mmc->max_seg_size =}
 mmc->max_blk_count = 2static void alcor_hw_init(struct alcor_sdmmc_host *host)
 mmc->max_req_size = mmc->max_blk_count * mmc->max_blk_size
 dma_set_max_seg_size(host->dev, mmc->max_seg_size);
}

static 
{
 struct alcor_pci_priv *priv = pdev-alcor_reset, AU6601_RESET_CMD
 structmmc_host *;
 struct alcor_sdmmc_host *host;
 int ret;

 mmc = devm_mmc_alloc_host(&pdev->dev, sizeof( (priv0
 
 /* for 6601 - dma_boundary; for 6621 - dma_page_cnt
return -ENOMEM;
}

host = mmc_priv(mmc);
host->dev = &pdev->dev;
host->cur_power_mode = MMC_POWER_UNDEFINED;
host->alcor_pci = priv;

/* make sure irqs are disabled */
  ,
 alcor_write32 ,A)

 ret = devm_request_threaded_irqalcor_unmask_sd_irqs()
   alcor_irq, alcor_irq_thread
  DRV_NAME_ALCOR_PCI_SDMMC);
 if
et
         "host

 mutex_init
 INIT_DELAYED_WORKalcor_write8priv,)

 alcor_init_mmc);
 alcor_hw_init(hostjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

 dev_set_drvdata(&pdev-  * level, however we can work  * provided that each segment is exactly  * Upon DMA completion of a single segment (signalled  * immediately proceed to transfer the next segment from the  * scatterlist.

 return> =;
}

  java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 68
{(host-, >max_seg_size;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  mmc_host mmc= ()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

 if(host-)
  alcor_request_complete(host  host;

 alcor_hw_uninit(hostmmc (&pdev-, (host;
 mmc_remove_host(if mmc{
}

#ifdef
static int alcor_pci_sdmmc_suspend(>  riv
{
 struct alcor_sdmmc_host *host = dev_get_drvdata(alcor_write32priv,AU6601_REG_INT_ENABLE;

 if (cancel_delayed_work_sync(&host-> ret = evm_request_threaded_irq&>dev,>irq
  alcor_request_complete(host, 0);

 alcor_hw_uninit(hostif (ret)

 return 0;
}

staticintalcor_pci_sdmmc_resume(tructdevice *dev)
{
  alcor_sdmmc_host **host= (dev);;

 alcor_hw_inithost)

 return 0;
}
#endif alcor_hw_inithost;

static SIMPLE_DEV_PM_OPS(alcor_mmc_pm_ops, alcor_pci_sdmmc_suspend,
    alcor_pci_sdmmc_resume

static const struct platform_device_id alcor_pci_sdmmc_ids[] = {
 {
    RV_NAME_ALCOR_PCI_SDMMC
 }, {
  /* sentinel */
 }
};
MODULE_DEVICE_TABLE(platform, alcor_pci_sdmmc_ids);

static struct platform_driver alcor_pci_sdmmc_driver = {
 p   lcor_pci_sdmmc_drv_probe
 .  =alcor_pci_sdmmc_drv_remove
 .id_table = alcor_pci_sdmmc_ids,
 .driver  = {
  .name alcor_sdmmc_host*ost=d()java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  .(host;
  .pm = &alcor_mmc_pm_ops
 },
};
module_platform_driver(alcor_pci_sdmmc_driver)staticint alcor_pci_sdmmc_resumestructdevicedev

MODULE_AUTHOR("Oleksij Rempel ");
MODULE_DESCRIPTION("
MODULE_LICENSE((host;