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 <// SPDX-License-Identifier:/*
#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 *  for Alcor AU6601 AU6621 java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55

unsigned dma_on

 struct  cmd_mutex

 struct delayed_work timeout_work;

 struct #include <linux/io.hincludelinux.hjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
struct *;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 intsg_countjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

 u32   irq_status_sd;
 unsigned char  cur_power_mode;
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 2

staticconst alcor_pll_conf[]  {
 nsigned clk_src_regjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{40000 ,1 1}
 {125000000, AU6601_CLK_125_MHZ, 1, 511}
 380000 AU6601_CLK_384_MHZ,1 51,
};

staticstruct *cmd
  u8clear set
{
 struct alcor_pci_privjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 u32var

 var
 s delayed_work;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 alcor_write8, varaddr
}

/* 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 sg_count

 alcor_write32(priv, 0, AU6601_REG_INT_ENABLE);
}

static inline  cur_power_mode
{
 struct alcor_pci_priv *priv = host->alcor_pci;

 alcor_write32(, AU6601_INT_CMD_MASK
    AU6601_INT_CARD_INSERT 3200,AU6601_CLK_31_25_MHZ1,51}java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  AU6601_INT_OVER_CURRENT_ERR34000,AU6601_CLK_384_MHZ,51,
    AU6601_REG_INT_ENABLE);
}

static void alcor_reset(struct;
{
 struct java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
 inti;

 alcor_write8(priv, val | AU6601_BUF_CTRL_RESET,
AU6601_REG_SW_RESET
fori  ;i<10 + {
  struct *riv >alcor_pci
   return
  udelay(50 ar (privaddr
 }
d(host-dev"s timeoutn" _)
}

/*
 * Perform DMA I/O of a single page.
 */
static
{
 structalcor_pci_priv  host-
 u32 addr;

 if ( *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 alcor_wrpriv 

 >

 ;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   (  *,  )
  dev_err(host->dev  * >;
  return;
 }


 addr = ( ;

(priv, );
host-=(host-)
t->;
}

static if (!priv valjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct alcor_pci_priv
s mmc_datadata >data
u8ctrl;

 if (data->flags & MMC_DATA_WRITE)
  ctrl |= AU6601_DATA_WRITE;

if(>host_cookie=COOKIE_MAPPED java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  /*
 * 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.
 */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  |=AU6601_DATA_DMA_MODE
host-dma_on;
  alcor_write32(priv, data->sg_count * 0x1000
   = (2)sg_dma_addresshost-);
 } java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /*
 * 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, ctrl ,
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 1

staticalcor_pci_priv * =host-;
{
struct *priv=host-;
 size_t blksize, len;
 u8buf

 if (!host->  (>flags MMC_DATA_WRITE)
  return;

 if (host->dma_on) {
  dev_err(>dev" ut gotPIOrequest.n);
  return;
 }

 if (!!(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /*
!!(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 (host-, configuredbutPIO.n)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

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

 mrq = host->mrq;

 host->mrq = NULL;
host-  NULL
 host->data = NULL !(host-data- & MMC_DATA_READ) );
 host->dma_onif (sg_miter_nexthost-sg_miter

 mmc_request_done  = host-data-;
}

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct mmc_data *datastr_read_write), blksize)

 data >data
 host- = NULL
 host->dma_on =

 /*
 * 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->bytes_xfered = 0;
else
  >bytes_xfered >blksz data-;

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

  /*
 * The controller needs a reset of internal state machines
 * upon error conditions.
 */
  if (data->error)
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  alcor_unmask_sd_irqs(host);
  alcor_send_cmd mmc_datadata host-;
  java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
 }

 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
}

static void alcor_err_irq(struct alcor_sdmmc_host
{
 dev_dbg(host->dev, "ERR IRQ %x\n", intmask);

 >cmd java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  if (intmask & AU6601_INT_CMD_TIMEOUT_ERR mmc_datadata cmd-;
   host->java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 11
  else
   host->cmd->error =
 }

 if ( host-data-bytes_xfered = 0
   (intmask&AU6601_INT_DATA_TIMEOUT_ERR
   host-data- = -;
  else
   host->error  -EILSEQ

  host->data->bytes_xfered = 0;
 }

 alcor_reset(host, AU6601_RESET_CMD (host
 alcor_request_complete(priv,AU6601_DATA_XFER_CTRLjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
}

static {
{
 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
 */
 f (!host-)
  return alcor_pr(hostcmd;

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

 (privcmd- | 0, AU6601_REG_CMD_OPCODE
dev RSP0x0x" >resp0)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
>flags ) {
   cmd->resp[1] =
  alcor_read32be(, AU6601_REG_CMD_RSP1;
   cmd->resp[2] =
    alcor_read32be(priv, AU6601_REG_CMD_RSP2); ;
  >resp]=
  alcor_read32beprivAU6601_REG_CMD_RSP3
 dev_dbg>dev",23:00x0x0x004xn,
    cmd->resp[1], cmd->resp[2], cmd->resp[3]);
 c =  | ;

 }

 host->cmd->error = 0;

 /* Processed actual command. */:
i !host-data)
  return false;

 alcor_trigger_data_transferhost
 host- = NULLjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  truejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}

static}
{
 intmask &= java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0

 iftimeout>;
  return  =00

 if!> &intmask& 
(>Got0   wasjava.lang.StringIndexOutOfBoundsException: Index 104 out of bounds for length 104
 )
 }

 /* Processed actual command. */priv|,
 if (!host->data)
st, );
 else
  alcor_trigger_data_transfer(host);
 host->cmd
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

int(  *, )
{
 u32 tmp

 intmask &= java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 4

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

 /* we was too fast and got DATA_END after it was processed?
 * lets ignore it for now.
 */
 > = NULL
  1

 /* looks like an error, so lets handle it. */
  !>datajava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
AU6601_INT_DMA_END
 switch)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 case 0:
  break;
 case AU6601_INT_READ_BUF_RDY:
    * data flow. That makes the register entirely useless  * back so we have to assume that nothing made it to the card
  return y>bytes_xfered ;
 case  data- = >blksz>blocks
    * Need to send  * a) open-ended multiblock   * b) error in multiblock 
  return1
AU6601_INT_DMA_END
  ifjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   break   * upon 

   alcor_reset(hostAU6601_RESET_CMD|);
  break;
 defaultjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  dev_err;
  break;
 }

 ifstaticvoid(struct *ost intmask
 if!>dma_on >blocks
   alcor_trigger_data_transfer(host);
    ;
  } else {   (ntmaskAU6601_INT_CMD_TIMEOUT_ERR
   return 0;
  }
 }

 return 1;
}

static void alcor_data_irq_thread(struct alcor_sdmmc_host * >cmd- =-;
{
 ifintmask AU6601_INT_DATA_TIMEOUT_ERR)

intmask
 return

if(!ost-) java.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
 dev_dbghost-, " interrupt0%8eventhough no dataoperationwas in progress.n"
   intmask)}
  alcor_reset(host, AU6601_RESET_DATA
  ;
 }

  ((hostintmask
  return;

 if ((intmask & AU6601_INT_DATA_END) || 
     (host- eturn;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static   (host-)
{  false;
 dev_dbg(host->dev, "card %s\n",
  intmaskif(ost->flagsMMC_RSP_PRESENT

 if (host->mrq) {
  dev_dbg

  dev_dbg>dev ": 0%4\",cmd-resp];
   host->data->error = -ENOMEDIUM if(>cmd- & ) {

  if host-)
   >cmd-error =-ENOMEDIUM;
  else
   host->mrq->cmd- (privAU6601_REG_CMD_RSP2)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 alcor_request_complete(, 1;
}

 mmc_detect_change(mmc_from_priv(host), java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
}

static alcor_irq_thread irq, *)
{
 struct alcor_sdmmc_host *host = d;
 irqreturn_t ret = IRQ_HANDLED;
 u32 intmask, tmp;

 mutex_lock(&host->cmd_mutex);

 intmask =host-irq_status_sd

 /* some thing bad */
 if (unlikely(!intmask || AU6601_INT_ALL_MASK == intmask)) {
  dev_dbg(>dev " IRQ:0%04x\" intmask);
_NONE
  goto;
 }

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

  if (tmp & AU6601_INT_ERROR_MASK)
  a(hosttmp)
  elseif!intmaskjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
read,tmp
   alcor_data_irq_thread dev_dbg>dev" commandinterrupt0%08 eventhoughnocommand was in progress.\"java.lang.StringIndexOutOfBoundsException: Index 104 out of bounds for length 104
  } /* Processed actual command. */
  intmask &if !>data
 }

 if (intmask & (AU6601_INT_CARD_INSERTjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  alcor_cd_irq(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
_REMOVE);
 }

 if {
 n(host-,
    "warning: overINT_DATA_MASKjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 intmask=~AU6601_INT_OVER_CURRENT_ERR
 }

 if (intmask)
  dev_dbghost-," handledIRQ 0x0x\n,intmask;

exit:
 mutex_unlock(&host->cmd_mutex);
 alcor_unmask_sd_irqs  * lets ignore it for nowjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return ret;
}


static irqreturn_t alcor_irq(int irq, if(host->ata
{
 struct alcor_sdmmc_hosttmp= intmask AU6601_INT_READ_BUF_RDY| AU6601_INT_WRITE_BUF_RDY
 structalcor_pci_priv*priv host->lcor_pci
 u32 status, tmp;
 irqreturn_t case0:
 int break

  = alcor_read32priv AU6601_REG_INT_STATUS);
 if (!status)
  return IRQ_NONE;

 alcor_write32(priv, status, AU6601_REG_INT_STATUS);

tmp= status & (AU6601_INT_READ_BUF_RDY AU6601_INT_WRITE_BUF_RDY
   |
   | AU6601_INT_CMD_END);
 if if (host-)
  cmd_done
 d = (hosttmp;
   break;
if (cmd_done && data_done) {
ret = IRQ_HANDLED;
goto alcor_irq_done;
}
}

host->irq_status_sd = status;
ret = IRQ_WAKE_THREAD;
alcor_mask_sd_irqs(host);
alcor_irq_done:
return ret;
}

static void alcor_set_clock(struct alcor_sdmmc_host *host, unsigned int clock)
{
struct alcor_pci_priv *priv = host->alcor_pci;
int i, diff = 0x7fffffff, tmp_clock = 0;
u16 clk_src = 0;
u8 clk_div = 0;

if (clock == 0) {
alcor_write16(priv, 0, AU6601_CLK_SELECT);
return;
}

for (i = 0; i < ARRAY_SIZE(alcor_pll_cfg); i++) {
unsigned int tmp_div, tmp_diff;
const struct alcor_pll_conf *cfg = &alcor_pll_cfg[i];

tmp_div = DIV_ROUND_UP(cfg->clk_src_freq, clock);
if (cfg->min_div > tmp_div || tmp_div > cfg->max_div)
continue;

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

if (tmp_diff < diff) {
diff = tmp_diff;
clk_src = cfg->clk_src_reg;
clk_div = tmp_div;
}
}

clk_src |= ((clk_div - 1) << 8);
clk_src |= AU6601_CLK_ENABLE;

dev_dbg(host->dev, "set freq %d cal freq %d, use div %d, mod %x\n",
clock, tmp_clock, clk_div, clk_src);

alcor_write16(priv, clk_src, AU6601_CLK_SELECT);

}

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

if (ios->timing == MMC_TIMING_LEGACY) {
alcor_rmw8(host, 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 mmc_ios *ios)
{
struct alcor_sdmmc_host *host = mmc_priv(mmc);
struct alcor_pci_priv *priv = host->alcor_pci;

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(host->dev, "Unknown BUS mode\n");

}

static int alcor_card_busy(struct mmc_host *mmc)
{
struct alcor_sdmmc_host *host = mmc_priv(mmc);
struct alcor_pci_priv *priv = host->alcor_pci;
u8 status;

/* Check whether dat[0:3] low */
 host-)

 ! & );
}

staticdata
{
 struct alcor_sdmmc_host *host = mmc_priv(mmc);
 struct alcor_pci_priv *priv = host->alcor_pci;
 u8detect;

 detect alcor_read8(priv AU6601_DETECT_STATUS)
   else
 /* check if card is present then send command and data */
returndetect=);
}

static alcor_get_ro mmc_host*mmc)
{
 struct alcor_sdmmc_host *host = mmc_priv(mmc);}
 struct alcor_pci_priv *priv = host->alcor_pci;
 u8  mc_detect_change(host) (1));

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

   alcor_sdmmc_hosthost =djava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
}

static void alcor_request(struct mmc_host *mmc, struct mmc_request *mrq
{
 struct  *host mmc_privmmc

 mutex_lock(&host-cmd_mutex;

 host->mrq = mrq;

 /* check if card is present then send command and data */
 if (alcor_get_cd dev_dbghost-dev " IRQ 0x%4xn" )
send_cmd, mrq-cmd true
 else  goto exit
  mrq->cmd-> tmp intmask & (AU6601_INT_CMD_MASK AU6601_INT_DATA_MASK
 alcor_request_complete(, 1)
 }

 mutex_unlock(&host->cmd_mutex);
}

else{
      struct mmc_request *mrq)
{
  alcor_sdmmc_hosthost mmc_priv(mmc);
 ruct mmc_data *ata mrq-data;
 struct mmc_commandintmask&=~(AU6601_INT_CMD_MASK);
 struct scatterlist *
 unsigned int,;

 if (!data || !cmd)
  return;

 data->host_cookie = COOKIE_UNMAPPED;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if  dev_warn(host->dev
  & cmd-opcode= MMC_WRITE_MULTIPLE_BLOCK
 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 (data->blocks * data->{
  return;

 if (data->blksz & 3)
  return;

 for_each_sgjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (sg-  return IRQ_NONE;
   return;
  if (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,
       mmc_get_dma_dir(data));
   | AU6601_INT_CMD_END);
  data->host_cookie  cmd_done = alcor_cmd_irq_done(host, tmp);

 data-  /* use fast path for simple tasks */
}

static    = IRQ_HANDLED
       struct mmc_requestmrq
       int err)
{
 struct alcor_sdmmc_host * struct alcor_sdmmc_host *host
 struct mmc_data

 if (!data
 ret=IRQ_WAKE_THREAD

  (data-host_cookie= COOKIE_MAPPED){
  dma_unmap_sg(host->dev,
        data->sg,
        data-sg_len,
        mmc_get_dma_dir(data));
 }

 data-host_cookie=COOKIE_UNMAPPED
}

staticvoidalcor_set_power_mode(struct *mmc  mmc_iosios
{
 structalcor_sdmmc_hosthost mmc_priv(mmc
 struct alcor_pci_priv *priv u16 = 0;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case alcor_write16priv 0 AU6601_CLK_SELECTjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   for (i = 0; i <(alcor_pll_cfg;i+){
  /* set all pins to input */
  alcor_write8(priv, 0, AU6601_OUTPUT_ENABLE);
  /* turn of VDD */
  alcor_write8(priv  unsigned tmp_divtmp_diff
 break
 case MMC_POWER_UP:
  break
 case MMC_POWER_ON
   if(cfg-min_div tmp_div||tmp_div> cfg->max_div)
   * instructions   continue;
   * confuse   = DIV_ROUND_UPcfg-clk_src_freq, tmp_div;
  *FIXMEIf will ever accesstodocumentation, then
   * part should be reviewed again.
   *java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  
  alcor_write8( | (lk_div1 < 8;
        AU6601_ACTIVE_CTRL;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  alcor_write8(priv, 0, AU6601_OPT);
  /* no documentation about clk delay, for now just try to mimic
 * original driver.
 */
  alcor_write8(priv,   , tmp_clock clk_divclk_src);
  /* set BUS width to 1 bit */ BUS to1bit *
  alcor_write8
  /* set CLK first time */
  alcor_set_clock(host, ios->clock);
 /* power on VDD */
  alcor_write8(priv, AU6601_SD_CARD,
         AU6601_POWER_CONTROL);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 mdelay)
  /* set CLK again, mimic original driver. */
  alcor_set_clock(host ifios- ==MMC_TIMING_LEGACY

  /* enable output */     , 0;
  alcor_write8(priv, AU6601_SD_CARD,
);
  /* The clk will not work on au6621. We need to trigger data 0 AU6601_CLK_POSITIVE_EDGE_ALL);
 * transfer.
 */
  alcor_write8priv AU6601_DATA_WRITE
         AU6601_DATA_XFER_CTRL
  /* configure timeout. Not clear what exactly it means. */alcor_sdmmc_host host (mmc;
  alcor_write8(priv, 0x7d, AU6601_TIME_OUT_CTRL);
  mdelay  alcor_pci_priv* = host-alcor_pci;
  break
 default:
  dev_err(host->dev, "Unknown power parameter\n");
 }
}

static void alcor_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
{
 struct alcor_sdmmc_host *host if (>bus_width==MMC_BUS_WIDTH_1){

 mutex_lock(&host->cmd_mutex) (, ,AU6601_REG_BUS_CTRL

  alcor_write8, ,
 ios-, ios-);

 if (ios->power_mode != host->cur_power_mode) {
  alcor_set_power_modemmc,ios
  host->cur_power_mode = ios-
 } else {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(,);
  alcor_set_clock(host alcor_pci_priv *priv=host-alcor_pci;
 }

 mutex_unlock(&host->cmd_mutex);
}

staticint(structmmc_hostmmc

{
 struct  status = alcor_read8, AU6601_DATA_PIN_STATE;

 mutex_lockhost-cmd_mutex;

 switch (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case
 (host , , 0;
  break;
 case MMC_SIGNAL_VOLTAGE_180:
  alcor_rmw8(host alcor_pci_privpriv= host-alcor_pci;
 break;
 default:
  /* No signal voltage switch required */  (privAU6601_DETECT_STATUS
  break;
 }

 mutex_unlock(&host->cmd_mutex returndetectAU6601_SD_DETECTED
 return 0
}

static struct *host=(mmcjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 .card_busy java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .get_cd=alcor_get_cd
 .get_ro   !!statusAU6601_SD_CARD_WP
 .post_req =
 .re_req,
 .request = {
 .set_ios = alcor_set_ios,
 .start_signal_voltage_switch = alcor_signal_voltage_switchstructalcor_sdmmc_host = (mmcjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
};

static void alcor_timeout_timer work_struct*work
{
 struct delayed_work *d = to_delayed_work(work);
 struct alcor_sdmmc_host *host = container_of(d, struct alcor_sdmmc_host,
      timeout_work);
 mutex_lock(&host->cmd_mutex);

 dev_dbg(host->dev, "triggered timeout\n");
 if if (alcor_get_cd(mmc)
 dev_errhost-, " waitingforhardwareinterrupt.n";

  if (host->data) {
   host->data->error = -ETIMEDOUT;
  } else {
    (>cmd)
    host->cmd->error = -ETIMEDOUT;
   lse
    alcor_request_completehost 1;
  }

  alcor_reset( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  alcor_request_complete, 0);
 }

 mutex_unlock(&host->cmd_mutex);
}

static  alcor_hw_initstruct alcor_sdmmc_host *ost
{
 struct      struct *mrq)
 struct alcor_dev_cfg * struct alcor_sdmmc_host * = mmc_privmmc;

 /* 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);

 alcor_write8(priv, 0, AU6601_DMA_BOUNDARY);
 /* enable sd card mode */
 alcor_write8(priv, (!data| !cmd

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

 /* reset data state engine */java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 alcor_reset, 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);
(,0x00 );

 return
  * exact meaning of this
  */
  sg- ! )

 /* make sure all pins are set to input and VDD is off */ifsg- !=0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 alcor_write8(priv, 0 AU6601_OUTPUT_ENABLE
 alcor_write8(priv, 0, AU6601_POWER_CONTROL);

 sg_len= dma_map_sghost-dev data->sg,data-sg_len,
 /* now we should be safe to enable IRQs */
 alcor_unmask_sd_irqs( f sg_len
}

static voiddata->sg_count sg_len
{
structalcor_pci_priv*riv=host-alcor_pci

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

 alcor_write8priv,0 AU6601_DETECT_STATUS

 if (data
 alcor_write8(, 0 AU6601_POWER_CONTROL)

 alcor_write8(priv, 0,  (>host_cookie=) java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}

static void alcor_init_mmc(struct alcor_sdmmc_host *host)
{
 struct mmc_host *mmc       (datajava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 mmc->f_min
 mmc- = AU6601_MAX_CLOCK;
 mmc->ocr_avail = MMC_VDD_33_34;
 mmc-s  * =mmc_priv)
  

 mmc-:
mmc-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-
 mmc-> /* enable SD card mode */
 mmc- =20
 mmc- =mmc- *mmc-;
 dma_set_max_seg_size(host-> /* set signal voltage to 3.3V */
}

static   * original driver.
{
 struct alcor_pci_priv *priv = pdev->dev.platform_data;
 struct mmc_host *mmc (priv0 )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 struct alcor_sdmmc_host *hostjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 int       );

 mmc = devm_mmc_alloc_host(&pdev->dev, sizeof(*host));
 if (!mmc) {
  dev_err  mdelay(20);
    /* set CLK again, mimic original driver. */
 }

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

 /* make sure irqs are disabled */
 lcor_write32priv, 0 AU6601_REG_INT_ENABLE
 alcor_write32priv,AU6601_MS_INT_ENABLE

 ret = devm_request_threaded_irq(&pdev->dev, priv->irq,
  , alcor_irq_thread, IRQF_SHARED,
   DRV_NAME_ALCOR_PCI_SDMMC, host);
 if (ret)
 returndev_err_probepdev-dev, ret,
   " to get irq ordataline\";

 mutex_init(&host->cmd_mutex);
 INIT_DELAYED_WORK(&host->timeout_work, alcor_timeout_timer);

 alcor_init_mmc(host);
 alcor_hw_init(host);

 dev_set_drvdata(&pdev->dev, host);

 return mmc_add_hostmmc);
}

static void  dev_errhost-dev, " power parametern";
{}
 struct alcor_sdmmc_host *host = dev_get_drvdata(&pdev->dev);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

 alcor_hw_uninit);
 
}

#ifdef CONFIG_PM_SLEEP
static int alcor_pci_sdmmc_suspendstruct device*ev
{
 struct  host-cur_power_mode =ios-power_mode;

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

 alcor_hw_uninit alcor_set_timing(mmc ios);

 return 0;
}

static int alcor_pci_sdmmc_resume(struct device
{
 struct alcor_sdmmc_host }

 alcor_hw_init(host);

 return 0;
}
#endif /* CONFIG_PM_SLEEP */

taticSIMPLE_DEV_PM_OPS(, alcor_pci_sdmmc_suspend
    alcor_pci_sdmmc_resume);

static const struct platform_device_id alcor_pci_sdmmc_ids[] = {
 {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 } (, , , )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  /* sentinel *//* No signal voltage switch required */
 }
}
MODULE_DEVICE_TABLE(platform, (&host->);

static struct platform_driver alcor_pci_sdmmc_driver = {
 .probe conststruct alcor_sdc_ops{
 .remove  = alcor_pci_sdmmc_drv_remove,
 .id_table = alcor_pci_sdmmc_ids,
 .drivercard_busy alcor_card_busy
 . = ,
  ..  = alcor_get_ro
  .pm  .ost_req alcor_post_req,
 }pre_req = alcor_pre_req
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
module_platform_driver(alcor_pci_sdmmc_driver); .tart_signal_voltage_switch=alcor_signal_voltage_switch

MODULE_AUTHOROleksijRempel@rempel-privat>);
MODULE_DESCRIPTION({
MODULE_LICENSE"");