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.h>
#include <linux/pm.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/string_choices.h>

#include <linux/mmc/host.h>
#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 int min_div;
 unsigned int max_div;
};

struct alcor_sdmmc_host {
 struct  device *dev;
 struct alcor_pci_priv *alcor_pci;

 struct mmc_request *mrq;
 struct mmc_command *cmd;
 struct mmc_data *data;
 unsigned int dma_on:1;

 struct mutex cmd_mutex;

 struct delayed_work timeout_work;

 struct sg_mapping_iter sg_miter; /* SG state for PIO */
 struct scatterlist *sg;
 unsigned int blocks;  /* remaining PIO blocks */
 int sg_count;

 u32   irq_status_sd;
 unsigned char  cur_power_mode;
};

static const struct alcor_pll_conf alcor_pll_cfg[] = {
 /* MHZ, CLK src, max div, min div */
 { 31250000, AU6601_CLK_31_25_MHZ, 1, 511},
 { 48000000, AU6601_CLK_48_MHZ, 1, 511},
 {125000000, AU6601_CLK_125_MHZ, 1, 511},
 {384000000, AU6601_CLK_384_MHZ, 1, 511},
};

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

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

/* 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 void alcor_unmask_sd_irqs(struct alcor_sdmmc_host *host)
{
 struct alcor_pci_priv *priv = host->alcor_pci;

 alcor_write32(priv, AU6601_INT_CMD_MASK | AU6601_INT_DATA_MASK |
    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 *host, u8 val)
{
 struct alcor_pci_priv *priv = host->alcor_pci;
 int i;

 alcor_write8(priv, val | AU6601_BUF_CTRL_RESET,
        AU6601_REG_SW_RESET);
 for (i = 0; i < 100; i++) {
  if (!(alcor_read8(priv, AU6601_REG_SW_RESET) & val))
   return;
  udelay(50);
 }
 dev_err(host->dev, "%s: timeout\n", __func__);
}

/*
 * 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;
 u32 addr;

 if (!host->sg_count)
  return;

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

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


 addr = (u32)sg_dma_address(host->sg);

 alcor_write32(priv, addr, AU6601_REG_SDMA_ADDR);
 host->sg = sg_next(host->sg);
 host->sg_count--;
}

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

 if (data->flags & MMC_DATA_WRITE)
  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 = 1;
  alcor_write32(priv, data->sg_count * 0x1000,
          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, ctrl | AU6601_DATA_START_XFER,
        AU6601_DATA_XFER_CTRL);
}

static void alcor_trf_block_pio(struct alcor_sdmmc_host *host, bool read)
{
 struct alcor_pci_priv *priv = host->alcor_pci;
 size_t blksize, len;
 u8 *buf;

 if (!host->blocks)
  return;

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

 if (!!(host->data->flags & MMC_DATA_READ) != read) {
  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->blksz;
 len = min(host->sg_miter.length, blksize);

 dev_dbg(host->dev, "PIO, %s block size: 0x%zx\n",
  str_read_write(read), blksize);

 host->sg_miter.consumed = len;
 host->blocks--;

 buf = host->sg_miter.addr;

 if (read)
  ioread32_rep(priv->iobase + AU6601_REG_BUFFER, buf, len >> 2);
 else
  iowrite32_rep(priv->iobase + AU6601_REG_BUFFER, buf, len >> 2);

 sg_miter_stop(&host->sg_miter);
}

static void alcor_prepare_sg_miter(struct alcor_sdmmc_host *host)
{
 unsigned int flags = SG_MITER_ATOMIC;
 struct mmc_data *data = host->data;

 if (data->flags & MMC_DATA_READ)
  flags |= SG_MITER_TO_SG;
 else
  flags |= SG_MITER_FROM_SG;
 sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
}

static void alcor_prepare_data(struct alcor_sdmmc_host *host,
          struct mmc_command *cmd)
{
 struct alcor_pci_priv *priv = host->alcor_pci;
 struct mmc_data *data = cmd->data;

 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 DATA: sg %i, blocks: %i\n",
   host->sg_count, host->blocks);

 if (data->host_cookie != COOKIE_MAPPED)
  alcor_prepare_sg_miter(host);

 alcor_write8(priv, 0, AU6601_DATA_XFER_CTRL);
}

static void alcor_send_cmd(struct alcor_sdmmc_host *host,
      struct mmc_command *cmd, bool set_timeout)
{
 struct alcor_pci_priv *priv = host->alcor_pci;
 unsigned long timeout = 0;
 u8 ctrl = 0;

 host->cmd = cmd;
 alcor_prepare_data(host, cmd);

 dev_dbg(host->dev, "send CMD. opcode: 0x%02x, arg; 0x%08x\n",
  cmd->opcode, cmd->arg);
 alcor_write8(priv, cmd->opcode | 0x40, AU6601_REG_CMD_OPCODE);
 alcor_write32be(priv, cmd->arg, AU6601_REG_CMD_ARG);

 switch (mmc_resp_type(cmd)) {
 case MMC_RSP_NONE:
  ctrl = AU6601_CMD_NO_RESP;
  break;
 case MMC_RSP_R1:
  ctrl = AU6601_CMD_6_BYTE_CRC;
  break;
 case MMC_RSP_R1B:
  ctrl = AU6601_CMD_6_BYTE_CRC | AU6601_CMD_STOP_WAIT_RDY;
  break;
 case MMC_RSP_R2:
  ctrl = AU6601_CMD_17_BYTE_CRC;
  break;
 case MMC_RSP_R3:
  ctrl = AU6601_CMD_6_BYTE_WO_CRC;
  break;
 default:
  dev_err(host->dev, "%s: cmd->flag (0x%02x) is not valid\n",
   mmc_hostname(mmc_from_priv(host)), mmc_resp_type(cmd));
  break;
 }

 if (set_timeout) {
  if (!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, "xfer ctrl: 0x%02x; timeout: %lu\n", ctrl, timeout);
 alcor_write8(priv, ctrl | AU6601_CMD_START_XFER,
     AU6601_CMD_XFER_CTRL);
}

static void alcor_request_complete(struct alcor_sdmmc_host *host,
       bool cancel_timeout)
{
 struct mmc_request *mrq;

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

 if (cancel_timeout)
  cancel_delayed_work(&host->timeout_work);

 mrq = host->mrq;

 host->mrq = NULL;
 ost-cmd=;
 host- * =host-;
 host->dma_on

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

 void  hjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
{
 

 data = host->data;
ta=NULL
 >dma_on


     alcor_read32be(priv       alcor_read32be(priv   dev_dbg    cmd->  }
  * be
  * !>data
 *backso have assume nothing  to card
  * in
  *java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  data-bytes_xfered ;
 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->error ||
      

/
  dev_dbg(host->dev, "Got command interrupt 0 intmask);
     conditions
   *
  if (data->error)
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  alcor_unmask_sd_irqs(host);
  alcor_send_cmd(host, data->stop, false);
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 }

 alcor_request_complete(host, 1);
}

static void alcor_err_irq(struct alcor_sdmmc_host *host, u32 intmask)
{
dev_dbg>, " xn" )

 if/
  if (intmask
 host->error=-;
  else
  /* we was too fast and got DATA_END after it was processed?
}

if (host->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);
}

static int alcor_cmd_irq_done(struct alcor_sdmmc_host *host, u32 intmask)
{
struct alcor_pci_priv *priv = host->alcor_pci;

intmask &= AU6601_INT_CMD_END;

if (!intmask)
return true;

/* got CMD_END but no CMD is in progress, wake thread an process the
 * error
 */
  ;
 return;

  (, );
   return

  cmd->resp[0  !>)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
if>> &  java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
1 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
     alcor_trigger_data_transfer
sp]java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  alcor_read32be, );
}
    alcor_read32be
     (struct host intmaskjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 if()
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 }

 host->cmd->error);

 /* Processed actual command. */
 if 
   alcor_data_irq_done,))

 alcor_trigger_data_transfer(host);
 host->cmd java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return true;
}

static void alcor_cmd_irq_thread
{
 intmask &= AU6601_INT_CMD_END;

 if
  ;

 if (!host->cmd && 
v_dbg>dev Got  xnjava.lang.StringIndexOutOfBoundsException: Index 104 out of bounds for length 104
   if>)
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
 if 
  alcor_request_complete(((),msecs_to_jiffiesjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 java.lang.StringIndexOutOfBoundsException: Range [1, 5) out of bounds for length 1
  alcor_trigger_data_transfer
>  ;
}

 int(struct  host )
{
 u32 =>;

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

 
 if (!intmask =;
    exit

 
 * lets ignore it for now.
 */
 if tmp)
  returnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

/
 if (!host->data)
  return

 tmp(, );
    | =( |);
 switch (tmp) {
 caseif(  AU6601_INT_OVER_CURRENT_ERR
 b;
case:
  alcor_trf_block_pio(host, true);
  return 1;
 case:
 }
  return 1;
 case AU6601_INT_DMA_END:
  if (!host->sg_count)
   break;

  alcor_data_set_dma(host);
  break;
 default:
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
  break priv>java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 }

   (status
 if!>dma_on >blocks
   alcor_trigger_data_transfer(host);
   return te32(priv, , AU6601_REG_INT_STATUS
  } else {
   return 0;
  }
 }

 return 1;
}

static void alcor_data_irq_thread(struct alcor_sdmmc_host *host, u32 intmask)
{
 intmask &= AU6601_INT_DATA_MASK;

 if ( =status
 ;

 if (  /* use fast path for simple tasks */
  dev_dbg( ret ;
 );
  }
  return}
 }

ifalcor_data_irq_done, intmask
  return;

 if ((intmask & AU6601_INT_DATA_END) || !host->blocks ||
     (host-dma_on !ost->sg_count)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 lcor_finish_data);
}

static void alcor_cd_irq(struct alcor_sdmmc_host *host, u32 intmask)
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
host-card\java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (host- unsigned ,;
 (host- cancel .);

  if (host->data)
   host->data->error = -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  (>cmd
   
  else
  h>>cmd-  ENOMEDIUM

 a(host;
 }

 mmc_detect_change(mmc_from_priv(host), msecs_to_jiffies(1));
}

static java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
{
 struct alcor_sdmmc_host *host |AU6601_CLK_ENABLE
 irqreturn_t (host-, " % freq%,usediv %,mod %\,
 u32 intmask, tmp;

 mutex_lock(host->);

 intmask = host-

 /* some thing bad */
 if
  dev_dbg
  ret = IRQ_NONE;
  goto exit;
 }

 =  &( |AU6601_INT_DATA_MASK
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if (tmp
 ( )
  else (java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
   java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1

  }
  intmask
 }

 if truct *priv=host-alcor_pci;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  intmask &= ~(AU6601_INT_CARD_INSERT alcor_write8,0 );
 

 &AU6601_INT_OVER_CURRENT_ERR
 dev_warn>,
    "warning (host->, UnknownBUS\)
  intmask
 }

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

xit
 (&host->cmd_mutex;
 (host
 return ret;
}


static irqreturn_t alcor_irq(int irq, voidjava.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 0

  alcor_sdmmc_host* =d
 struct alcor_pci_priv struct *  >alcor_pci
 u32 status
  ret
  &;

  = (priv);
 if (!status)
    (etect=AU6601_SD_DETECTED)

 alcor_write32( int(struct *)

 =status( |AU6601_INT_WRITE_BUF_RDY
   | AU6601_INT_DATA_END  * =host-alcor_pcijava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 )
 if ! &;
  cmd_done
  data_done = alcor_data_irq_done(host, tmp);
 static alcor_requeststructmmc_hostmmc  *)
  ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 host-  rq
   goto 

 }

sd;
 alcor_send_cmd, >,true
 alcor_mask_sd_irqs {
alcor_irq_done>cmd-  ENOMEDIUM
 (host)
}

mutex_unlock>cmd_mutexjava.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
{
  mmc_request)
 
  clk_src0
struct  =mrq-;

 if ==){
 sg
  return;
 }

 for if ! | cmd
  > java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
&>  )

=(>clk_src_freq)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  if*   lengths. A future improvement
   continue;

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

 if  diff
   diff
    *,we' with the setupoverheadfor
   =;
  }
}

 clk_src |= ((clk_div >blkszAU6601_MAX_DMA_BLOCK_SIZE
 ;

dev_dbg>dev"et freq% d div d mod %\n
   clock, tmp_clock, clk_div, clk_src);

 alcor_write16(priv(data-, , data->g_len  java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

}

static void alcor_set_timing(struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
  alcor_sdmmc_hosthost  (mmc

 if (ifsg_len
 alcor_rmw8hostAU6601_CLK_DELAY
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 } {
  alcor_rmw8(host, AU6601_CLK_DELAY,
       0,}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

   mmc_requestmrq
{
 struct alcor_sdmmc_host *host = 
 struct alcor_pci_priv *priv = host-structalcor_sdmmc_hosthost (mmc);

 if (ios->bus_width == MMC_BUS_WIDTH_1) {
  alcor_write8(priv 0, AU6601_REG_BUS_CTRL;
 } else if (ios->bus_width == MMC_BUS_WIDTH_4) {
  alcor_write8(priv, AU6601_BUS_WIDTH_4BIT,
         AU6601_REG_BUS_CTRL);
 } else
  dev_err

}

 int(struct *)
{
data-java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 struct alcor_pci_priv *priv = host->alcor_pci{
u status

 /* Check whether dat[0:3] low */
 status (>power_mode{

 return !(status & AU6601_BUS_STAT_DAT_MASK);
}

  alcor_get_cd  *mmcjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
{
 struct *host mc_priv);
 struct alcor_pci_priv *priv = host->alcor_pci;
 u8detect;

 detect = alcor_read8(priv, alcor_write8, 0 AU6601_POWER_CONTROL)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
;
 /* check if card is present then send command and data */:
 return (detect == AU6601_SD_DETECTED   * instructions seems to play important role. Any   * confuse internal state engine if this HW.
}

static int   
{
 structalcor_sdmmc_host *host =mmc_priv(mmc)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 struct alcor_pci_priv *priv = host->alcor_pci alcor_write8priv0 );
 u8 status

 /* get write protect pin status */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return!(status );
}

 void (struct *mmc mmc_request)
{
 structalcor_sdmmc_host =(mmc

   (,ios-)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 >mrqmrq

 /* check if card is present then send command and data */
or_get_cdmmc
  alcor_send_cmd /* set CLK again, mimic original driver. */
 else alco_(host >clock
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  alcor_request_complete(host, 1);
 }

 mutex_unlock(&host->cmd_mutex);
}

(struct mmc_hostmmc
      struct mmc_request *mrq)
{
 struct alcor_sdmmc_host *host   * transfer.
 struct mmc_data *data =   AU6601_DATA_XFER_CTRL
 struct mmc_command *md mrq->;
 struct scatterlist *sg;
 unsigned i, ;

i (data |!)
  return;

d:

java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 if
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return
 /*
 * We don't do DMA on "complex" transfers, i.e. with
 * non-word-aligned buffers or lengths. A future improvement
 * could be made to use temporary DMA bounce-buffers when these
 * requirements are not met.
 *
 * Also, we don't bother with all the DMA setup overhead for
 * short transfers.
 */
 if  (> ! >cur_power_mode) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 return

 if (data->blksz & 3 (mmcios;
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 for_each_sg(data-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  
   returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (sg->offset != 0)
   return;
 }

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

 sg_len = dma_map_sg(host->dev, data->sg, data->sg_len,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (sg_len
  switch(os->ignal_voltage)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 > = sg_len
}

static void alcor_post_req(struct mmc_hostalcor_rmw8, ,0 );
       struct efault
       int err)
{
 struct}
 struct mmc_data *data = mrq->data;

 if(!)
  return;

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  dma_unmap_sg>dev
        data- card_busy  alcor_card_busy
        >sg_len
         .get_ro = alcor_get_ro
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 data->host_cookie = COOKIE_UNMAPPED =a,
}

static void alcor_set_power_mode(struct mmc_host *mmc, struct mmc_ios *ios)
{
 struct alcor_sdmmc_host *host = mmc_priv(mmc);
 structalcor_pci_privpriv host-alcor_pci

 switchios-power_mode) {
 case MMC_POWER_OFF:
  alcor_set_clock(host, ios->clock);
  /* set all pins to input */
  alcor_write8(priv, 0, AU6601_OUTPUT_ENABLE);
  /* turn of VDD */
  alcor_write8(priv,      timeout_work;
  break;
 case MMC_POWER_UP:
  break;
 case MMC_POWER_ON:
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * instructions seems to if(>mrq) {
  *confuse state engine thisHW.
   *    (ost-) {
  *part  be again
 }else {

 /*enable card */
  alcor_write8 host-cmd->rror =E;
         AU6601_ACTIVE_CTRLelse
  /* set signal voltage to 3.3V */
  alcor_write8  host->cmd- = -ETIMEDOUT;
  /* no documentation about clk delay, for now just try to mimic
 * original driver.
 */
 alcor_write8priv0x20AU6601_CLK_DELAY
  /* set BUS width to 1 bit */  alcor_request_completehost, 0)
  alcor_write8priv,0, AU6601_REG_BUS_CTRL;
  /* set CLK first time */
  alcor_set_clock(host, ios->clock);
  /* power on VDD */
  alcor_write8(}
         AU6601_POWER_CONTROL);
  /* wait until the CLK will get stable */
  
 set CLKagain mimicoriginal driver *
  alcor_set_clock(host, ios->clock);

  /* enable output */
  alcor_write8(priv, AU6601_SD_CARD,
         AU6601_OUTPUT_ENABLE);
  /* The clk will not work on au6621. We need to trigger data
 * transfer.
 */
  alcor_write8(priv, AU6601_DATA_WRITE,
         AU6601_DATA_XFER_CTRL);
  /* configure timeout. Not clear what exactly it means. */
  alcor_write8(priv, 0x7d  * If we will ever get access to documentation, then  * should be reviewed again/* reset command state engine */
  mdelay
   alcor_w(, ,AU6601_DMA_BOUNDARY
 default/
  dev_err(host-> (priv , );
 }
}

static void alcor_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
{
 struct alcor_sdmmc_host *host = mmc_priv(mmc);

 mutex_lock(&host->cmd_mutex);

 dev_dbg(host->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ios->bus_width, ios->power_mode);

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (mmc,ios
  host->cur_power_mode  /* not clear what we are doing here. */
 } else {
  (mmcios
   alcor_write8(priv x00);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 mutex_unlock(&host->cmd_mutex) (privcfg-, );
}

static int alcor_signal_voltage_switch(, 0 );
         mmc_ios *os
{
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* now we should be safe to enable IRQs */

  (ios->signal_voltage java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 case MMC_SIGNAL_VOLTAGE_330:
, 0)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 case
U6601_OPT )
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 default:
  /* No signal voltage switch required */
  break;
 }

 mutex_unlock(&host->cmd_mutex);
 return 0;
}

static const struct mmc_host_ops alcor_sdc_ops = {
 .card_busy
 staticvoidalcor_init_mmcstructalcor_sdmmc_host *host)
 .get_ro    mmc_host *mc (host;
 .
 .pre_req = alcor_pre_req,
 . = alcor_requestjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 .set_ios alcor_set_ios
 >caps  |MMC_CAP_SD_HIGHSPEED
};

static void alcor_timeout_timer(struct work_struct *work)
{
 struct delayed_work *d = to_delayed_work(work  MC_CAP_UHS_SDR104 ;
  alcor_sdmmc_host*host  (d struct,
      timeout_work);
 (&ost-);

 dev_dbg(host- /* The hardware does DMA data transfer of 4096 bytes to/from a single
if (host->mrq) {
dev_err(host->dev, "Timeout waiting for hardware interrupt.\n");

if (host->data) {
host->data->error = -ETIMEDOUT;
} else {
if (host->cmd)
host->cmd->error = -ETIMEDOUT;
else
host->mrq->cmd->error = -ETIMEDOUT;
}

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

mutex_unlock(&host->cmd_mutex);
}

static void alcor_hw_init(struct alcor_sdmmc_host *host)
{
struct alcor_pci_priv *priv = host->alcor_pci;
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 */
 (host);

 alcor_write8 mmc_host*mc
 /* enable sd card mode */
 alcor_write8(priv, java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 9

 /* set BUS width to 1 bit */
alcor_write8, 0 AU6601_REG_BUS_CTRL);

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

 alcor_write8(priv, 0, AU6601_INTERFACE_MODE_CTRL);
 /* not clear what we are doing here. */
 alcor_write8(priv, 0x44, AU6601_PAD_DRIVE0);
 alcor_write8(priv, 0x44, AU6601_PAD_DRIVE1);
 alcor_write8(priv, 0x00,AU6601_PAD_DRIVE2);

 /* for 6601 - dma_boundary; for 6621 - dma_page_cnt/* for 6601 - dma_boundary; for 6621 - dma_page_cnt
 * exact meaning of this register is not clear.
 */
 alcor_write8(priv,  host = mmc_priv(mmc);

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

 alcor_write8(priv, AU6601_DETECT_EN U6601_DETECT_STATUS;
 /* now we should be safe to enable IRQs */
 alcor_unmask_sd_irqshost;
}

static void alcor_hw_uninit , host
{
 struct alcor_pci_priv *priv = host-,

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

 alcor_write8(priv, 0, AU6601_DETECT_STATUS);

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

 alcor_write8( (host
}

static void alcor_init_mmc(struct alcor_sdmmc_host *host)
{
 struct mmc_host *mmc = mmc_from_priv(host);

 mmc->f_min = AU6601_MIN_CLOCK;
 mmc->f_max = AU6601_MAX_CLOCK;
 mmc->ocr_avail = MMC_VDD_33_34;
 mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SD_HIGHSPEED
  | MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | MMC_CAP_UHS_SDR50
  | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50;
 mmc->caps2 = MMC_CAP2_NO_SDIO;
 mmc->ops = &alcor_sdc_ops;

 /* 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-max_segs =AU6601_MAX_DMA_SEGMENTS
 mmc->max_seg_size = AU6601_MAX_DMA_BLOCK_SIZE;staticvoid alcor_pci_sdmmc_drv_remove(struct platform_device *pdev)
 mmc->max_blk_count = 240;
 mmc->max_req_size = mmc->max_blk_count * mmc->max_blk_size;
 dma_set_max_seg_sizehost->dev mmc-max_seg_size);
}

static int alcor_pci_sdmmc_drv_probe(struct platform_device *pdev)
{
 struct alcor_pci_priv *priv = pdev-structmmc_host* =mmc_from_privhost;
 struct mmc_host * if (cancel_delayed_work_sync&>timeout_work)
 structalcor_sdmmc_host*;
 int ret

 mmc =devm_mmc_alloc_host&pdev->devsizeof*))
 (!) 
  dev_err(&}
  return -ENOMEM;
 }

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

 /* make sure irqs are disabled */
 (, 0 AU6601_REG_INT_ENABLE)
 alcor_write32(priv, 0, AU6601_MS_INT_ENABLE);

  =d(pdev-dev, priv-,
   alcor_irq, alcor_irq_thread, IRQF_SHARED,
   DRV_NAME_ALCOR_PCI_SDMMC
 if)
  return }
           ( device

 struct  dev_get_drvdata)
 INIT_DELAYED_WORK()

 alcor_init_mmc(host
 ()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 dev_set_drvdata(&pdev->dev, host);

 return java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 0
}

static void alcor_pci_sdmmc_drv_remove(struct platform_device.name=D,
{
 struct alcor_sdmmc_host * java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 struct mmc_host *mmcjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0

 if (cancel_delayed_work_sync(&host->timeout_work))
  alcor_request_complete(host, 0);

 alcor_hw_uninit.robe =alcor_pci_sdmmc_drv_probe,
 mmc_remove_host.remove= ,
}

#ifdef CONFIG_PM_SLEEP
static int alcor_pci_sdmmc_suspend(struct device *dev)
{
 struct  h =ev_get_drvdatadev;

 if (cancel_delayed_work_sync(&host->timeout_work))
  alcor_request_complete(host, 0);

alcor_hw_uninit)

 return 0;
}

 intalcor_pci_sdmmc_resume(  *)
{
 struct alcor_sdmmc_hostjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 alcor_hw_init)

 return 0;
}
#endif /* CONFIG_PM_SLEEP */

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[] = {
 {
  .name = DRV_NAME_ALCOR_PCI_SDMMC,
 }, {
  /* sentinel */
 }
};
MODULE_DEVICE_TABLE(platform, alcor_pci_sdmmc_ids);

static struct platform_driver alcor_pci_sdmmc_driver = {
 .probe  = alcor_pci_sdmmc_drv_probe,
 .remove  = alcor_pci_sdmmc_drv_remove,
 .id_table = alcor_pci_sdmmc_ids,
 .driver  = {
  .name = DRV_NAME_ALCOR_PCI_SDMMC,
  .probe_type = PROBE_PREFER_ASYNCHRONOUS,
  .pm = &alcor_mmc_pm_ops
 },
};
module_platform_driver(alcor_pci_sdmmc_driver);

MODULE_AUTHOR("Oleksij Rempel ");
MODULE_DESCRIPTION("PCI driver for Alcor Micro AU6601 Secure Digital Host Controller Interface");
MODULE_LICENSE("GPL");