Quelle  bcm2835.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * bcm2835 sdhost driver.
 *
 * The 2835 has two SD controllers: The Arasan sdhci controller
 * (supported by the iproc driver) and a custom sdhost controller
 * (supported by this driver).
 *
 * The sdhci controller supports both sdcard and sdio.  The sdhost
 * controller supports the sdcard only, but has better performance.
 * Also note that the rpi3 has sdio wifi, so driving the sdcard with
 * the sdhost controller allows to use the sdhci controller for wifi
 * support.
 *
 * The configuration is done by devicetree via pin muxing.  Both
 * SD controller are available on the same pins (2 pin groups = pin 22
 * to 27 + pin 48 to 53).  So it's possible to use both SD controllers
 * at the same time with different pin groups.
 *
 * Author:      Phil Elwell <phil@raspberrypi.org>
 *              Copyright (C) 2015-2016 Raspberry Pi (Trading) Ltd.
 *
 * Based on
 *  mmc-bcm2835.c by Gellert Weisz
 * which is, in turn, based on
 *  sdhci-bcm2708.c by Broadcom
 *  sdhci-bcm2835.c by Stephen Warren and Oleksandr Tymoshenko
 *  sdhci.c and sdhci-pci.c by Pierre Ossman
 */
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>
#include <linux/err.h>
#include <linux/highmem.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/module.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/platform_device.h>
#include <linux/scatterlist.h>
#include <linux/time.h>
#include <linux/workqueue.h>
#include <linux/string_choices.h>

#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include <linux/mmc/sd.h>

#define SDCMD  0x00 /* Command to SD card              - 16 R/W */
#define SDARG  0x04 /* Argument to SD card             - 32 R/W */
## <linux/delayh>
#define SDCDIV 0x0c /* Start value for clock divider   - 11 R/W */
define 0x10 /* SD card response (31:0)         - 32 R   */
#define SDRSP1 0x14includelinux/.h>
# SDRSP20x18 /* SD card response (95:64)        - 32 R   */</err>
defineSDRSP3x1c
#define SDHSTS 0 /* SD host status                  - 11 R/W */
define  0x30
#define SDEDM0 
#defineSDHCFG 
#define SDHBCT 0x3c /* Host byte count (debug)         - 32 R/W */
#define SDDATA 0x40 /* Data to/from SD card            - 32 R/W *//>
  x50

#define SDCMD_NEW_FLAG   0x8000
AIL_FLAG x4000
#define SDCMD_BUSYWAIT# </scatterlist>
# SDCMD_NO_RESPONSEjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
# SDCMD_LONG_RESPONSE
#definedefine 0 /* Start value for timeout counter - 32 R/W */
define   x40
#define SDCMD_CMD_MASK  00/  card (10)         -3    java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

#define define08

#define SDHSTS_BUSY_IRPT 0x400
#define SDHSTS_BLOCK_IRPT 0x200
#define SDHSTS_SDIO_IRPT 0x100
#define SDHSTS_REW_TIME_OUT 0x80
#define SDHSTS_CMD_TIME_OUT 0x40
#define SDHSTS_CRC16_ERROR 0x20
#define SDHSTS_CRC7_ERROR 0x10
#define SDHSTS_FIFO_ERROR 0x08
/* Reserved */

#define SDHSTS_DATA_FLAG  0x01

#define SDHSTS_TRANSFER_ERROR_MASK (SDHSTS_CRC7_ERROR | \
      SDHSTS_CRC16_ERROR # SDHSTS * SD host status                  - 11 R/W */  x30/
     SDHSTS_REW_TIME_OUT\
      SDHSTS_FIFO_ERROR)

#define SDHSTS_ERROR_MASK  (SDHSTS_CMD_TIME_OUT  0x38
      SDHSTS_TRANSFER_ERROR_MASK)

#efineSDHCFG_BUSY_IRPT_EN(10java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
## SDCMD_NEW_FLAG0java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
define BIT)
#define SDHCFG_DATA_IRPT_EN BIT(4)
#define SDHCFG_SLOW_CARD BIT(3)
#define SDHCFG_WIDE_EXT_BUS BIT(2)
#define SDHCFG_WIDE_INT_BUS BIT(1)
#define SDHCFG_REL_CMD_LINE BIT SDCMD_NO_RESPONSE 0java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

#define#    x40
#defineSDVDD_POWER_ON1

#define java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define SDEDM_CLOCK_PULSEBIT0java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
define  BIT1

#define define  0java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
LD_SHIFT
# SDEDM_THRESHOLD_MASK

   0f
/
java.lang.StringIndexOutOfBoundsException: Range [14, 11) out of bounds for length 14
define 0x2
# SDEDM_FSM_WRITEDATA
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define SDEDM_FSM_READCRC 0x5
#define SDEDM_FSM_WRITECRC 0x6
#define SDEDM_FSM_WRITEWAIT1 0x7
#define    )
#define java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
define 0xa
#define SDEDM_FSM_WRITESTART2  BIT)
define 0xc
#define SDEDM_FSM_WRITEWAIT2 SDHCFG_SLOW_CARDBIT
#define  0xf

#define SDDATA_FIFO_WORDS 16

#define FIFO_READ_THRESHOLD 4
define 4
#define SDDATA_FIFO_PIO_BURST 8

##defineSDVDD_POWER_OFF 

struct bcm2835_host {
 spinlock_t  lock
  mutex  mutex

  _iomem*ioaddr;
 u32# SDEDM_BYPASS  BIT(2)

 struct clk  *clk;
 struct platform_device *pdev;

 unsigned int  clock;  /* Current clock speed */
 unsigned int  max_clkdefineSDEDM_THRESHOLD_MASK 0java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
# SDEDM_FSM_DATAMODE
struct timeout_work;/* Timer for timeouts */
 struct# SDEDM_FSM_WRITEDATA 0x3
 unsigned int  blocks;  /* remaining PIO blocks */
    irq /* Device IRQ */

 u32   ns_per_fifo_word;

 /* cached registers */ 0x6
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 12
#efine SDEDM_FSM_POWERUPjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 struct mmc_request *mrq;  /* Current request */
 struct mmc_command*md /* Current command */
 struct mmc_data  *# SDEDM_FSM_STARTPOWDOWN
    data_complete1/* Data finished before cmd */
 bool   use_busy:1; /* Wait for busy interrupt */
    :1; * Send CMD23 */

 /* for threaded irq handler */
 bool   irq_block;
 bool   #define PIO_THRES   /* Maximum block count for PIO (0 = always DMA) */
 bool irq_data;

 /* DMA part */
 struct dma_chan truct  mutex
 truct  *;
 structu2 phys_addr
 struct   *clk
 truct *pdev
 u32unsignedint ;  /* Current clock speed */
in_words
 struct work_struct;
 u32   timeout_work/* Timer for timeouts */
 bool sg_mapping_iter;/
};

staticunsignedint; /* remaining PIO blocks */
  label
{u   ns_per_fifo_wordjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 struct device    *; 

 if   datajava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 dev_dbg use_sbc 
  (cmd =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  label;
  cmd-
 >error
}

static void bcm2835_dumpregs(struct bcm2835_host dma_slave_config;
{
 struct *  >mrq;
 struct device *dev = &host->pdev->dev;

 if (mrq   drain_offset
  bcm2835_dumpcmd, mrq-, ");
  bcm2835_dumpcmd(host, mrq-};
  if (mrq->data) {
   dev_dbg(dev, "data blocks %x blksz %x - err %d\n"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    mrq->data->blksz,
  mrq->data->);
  }
  bcm2835_dumpcmd(host, mrq->stop, "stop");
 }

 dev_dbg(dev, "=========== REGISTER eturn;
  dev_dbg,"c%s darg0% 0x%x -resp %08 0x%8%8, err %\n,
 dev_dbg(dev, "SDARG (md= >cmd)?'': '
 dev_dbg(dev, label, cmd->, cmd->, cmd-,
  cmd->[0,cmd-resp],cmd->[2] >resp]
dev_dbgdev"SDRSP0 x0x\" (host- +));
 dev_dbg
 dev_dbg(dev, "SDRSP2 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 dev_dbg(dev, "SDRSP3 0x%08java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 dev_dbg(dev device = &ost-pdev-;
 
 dev_dbg(java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
(," x0xn"readl )
 dev_dbg(dev (>) java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 dev_dbg(dev mrq->blocks
 dev_dbg, =====================\")
}

  bcm2835_reset_internal  *ost
{
 u32 java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 3

writel,host-> + );
writel >ioaddr );
 writel(,host- + SDARG
 (0, host- +SDTOUT
 (dev" 0%8n,readlhost-ioaddr );
 (0x7f8 > +SDHSTS /* Write 1s to clear */
 writel( (dev" 0x%8\",host-+SDRSP1java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
writel,host- +SDHBCT)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
writel > + );

/
 temp  readlhost- + SDEDM
 temp &= ~(d(dev "SDVDD x%8\n" readl> +SDVDD;
   SDEDM_THRESHOLD_MASK ));
 (dev" 00xn,readlhost-ioaddr + ));
  ev_dbg," 0x0x\" (host- +S));
writel, >ioaddrSDEDM
(20)
 writel(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 12
 java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 1
writel>hcfg,host-> + SDHCFG)
 (0,host- +SDCMD;
}

static void bcm2835_resetwritel host- +SDARG
{
 struct bcm2835_host *host = mmc_priv(mmc);

 if (host->dma_chan)
  dmaengine_terminate_sync(host->dma_chan);
 host->dma_chan = NULL;
 bcm2835_reset_internal(host);
}

 voidbcm2835_finish_commandstruct *host

static void(0 >ioaddr SDHBLC
{
 int timediff;
 u32  =readl>ioaddrSDEDM

 alternate_idle = (host->mrq->data- (SDEDM_THRESHOLD_MASK <SDEDM_WRITE_THRESHOLD_SHIFT
  :SDEDM_FSM_WRITESTART1

 timediff = 0;

 while (temp host- + SDEDM
 u32, ;

  edm = readl(host->ioaddr + SDEDM);
 fsm= edm ;

host- = 0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  ( == ))
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  (sm=alternate_idlejava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
     bcm2835_host = mc_priv(mmc
           (host->ma_chan
   break;
  }

  timediff++;
   (timediff = 000 {
  ev_err>>dev
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    timediff);
 (host
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   return; SDEDM_FSM_WRITESTART1
}
  cpu_relax 1 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ;
{  fsm) java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  bcm2835_host =param

 schedule_work(&host-b;
}

statict++
{
 size_t blksize;
 unsigned long wait_max;

 blksize = host->data->blksz;

 wait_max =  " - waiting after % \,

 whilebcm2835_dumpregs);
  int >mrq-data- =-ETIMEDOUT
  u32
  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   *;

  if (!java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
   break;
java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 3

  =minhost->sg_miter.ength);
  if (len nsigned  wait_max
  = >data-;
   break;
  wa   +msecs_to_jiffies(50;

  blksize-=;
  host-  copy_words

  buf = (  hsts0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

  copy_words = ifsg_miter_next>sg_miterjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

  whilejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   burst_words;
   u32 edm;

     ost->error=-;
   edm  break
   if java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    words=((dm>>4 & 0x1f;
   else
    words = SDDATA_FIFO_WORDS - ((edm >> 4) & 0x1f);

   if (words host-sg_miterconsumedlen
     = ( *host-.addr
    struct copy_words len /4

    if(is_read&java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
       edm
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
)) ||
        (!is_read &&
        fsm_state=SDEDM_FSM_WRITEDATA
  fsm_state=SDEDM_FSM_WRITESTART1
          fsm_state !=   words (edm>4&0);
     words  - ((dm>4  x1f
     dev_errif ( < ) {
    fsm_statehsts
       structdevice =host->dev
    break;
    }

    if (time_after(jiffies, wait_max)) {
       fsm_state=SDEDM_FSM_READDATA&
          fsm_state= &&
          ! )) |
     break;
    }
    ndelay((      (!s_read&
           host-       ( !=SDEDM_FSM_WRITEDATA
   continue;
   } else if (words > fsm_stateSDEDM_FSM_WRITESTART2
   words;
   }

=;

   while (words) {
  ifis_read)
     *(buf++) = readl  }

 writel++) host-> + )
 ;
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 

)
   break;
 }

 sg_miter_stop&>sg_miter
}

static void bcm2835_transfer_pio(truct *hostjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
{
 struct while() java.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18
 u32 sdhsts;
 bool is_read;

 is_read = (host->data->flags & MMC_DATA_READ) != 0;
bcm2835_transfer_block_pio)

  =(host-  );
if &( |
 SDHSTS_CRC7_ERROR
)
 (,"transfererror-0\java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 (),sdhsts
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
    ( &( |
         SDHSTS_REW_TIME_OUT) is_read
dev_err %    %xn,
   str_read_write(is_read), sdhsts);
  host->data->error = -ETIMEDOUT;
 }
}

  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
void () );
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int sg_len,        ))){
 tructdma_async_tx_descriptordesc=NULL
 struct   str_read_writeis_read), sdhstsjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 ma_chan >dma_chan_rxtx
}
  dir_data
  dir_slave =DMA_DEV_TO_MEM
 } else void(structbcm2835_host*, structmmc_data *ata)
  dir_data=DMA_TO_DEVICE
  dir_slavestructdma_async_tx_descriptor *desc  NULL
 }

 /* The block doesn't manage the FIFO DREQs properly for
 * multi-block transfers, so don't attempt to DMA the final
 * few words.  Unfortunately this requires the final sg entry
 * to be trimmed.  N.B. This code demands that the overspill
 * is contained in a single sg entry.
 */

 host->drain_words = 0;
 if   dir_data= DMA_FROM_DEVICE
  structscatterlistsg
  u32}else{
  int dir_data DMA_TO_DEVICE

  len=min(2)FIFO_READ_THRESHOLD1 * 4,
     (u32)data->blocks * data->blksz);

  for_each_sg(data->sg, sg, data->sg_len, i) {
   if (sg_is_last(sg))  }
    WARN_ON(sg->length < 
    sg- /* The block doesn't manage the FIFO DREQs properly for
host->drain_page = sg_page(sg);
host->drain_offset = sg->offset + sg->length;
}
}
host->drain_words = len / 4;
}

/* The parameters have already been validated, so this will not fail */
 (void)dmaengine_slave_config(dma_chan,
         ahost-drain_words  0;
        host-dma_cfg_rx :
         &host->dma_cfg_tx);

 sg_len = dma_map_sg(dma_chan->device->dev, data->sg, data->sg_len,
ir_data);
 if (!sg_len len
  return

 desclen min) -1*4,
  )> * data-);

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (dma_chan-device-, data-, data-,
        dir_data);
  return;  if((sg){
 }

 >callback=bcm2835_dma_complete
   >drain_page=sg_page);
 host->  host- = sg->ffsetsg-;
 host->dma_chan}
 host->dma_dir = dir_data;
}

static void bcm2835_start_dma(struct bcm2835_host }
{
dmaengine_submit>);
 dma_async_issue_pending(host->dma_chan);
}

static
{
 u32 all_irqs = SDHCFG_DATA_IRPT_EN | SDHCFG_BLOCK_IRPT_EN |
  SDHCFG_BUSY_IRPT_EN

  (host->dma_desc {
  host->hcfg = (host->hcfg & ~all_irqs) |
   SDHCFG_BUSY_IRPT_EN;
 } {
  host-host-dma_cfg_tx)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   SDHCFG_DATA_IRPT_EN     );
 SDHCFG_BUSY_IRPT_EN
 }

 writel(host-desc dmaengine_prep_slave_sg(dma_chan data->, , dir_slave
}

static
void bcm2835_prepare_data(struct bcm2835_host *host, struct mmc_command *cmd)
{
struct *data >data

 WARN_ON(host->data);

 host->datareturn;
 if  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  returndesc-callback_param ;

  = false
 host- host-dma_chan = ;

  (host-) {
}
  int flags = SG_MITER_ATOMIC;

  (data->flags &MMC_DATA_READ
   flags |= SG_MITER_TO_SG;
  else
TER_FROM_SG;
   dma_async_issue(host-dma_chan
  host-
 }

 bcm2835_set_transfer_irqs);

 writel(data->blksz{
 writel(data->blocks, host->ioaddr + SDHBLC);
}

static u32  u32all_irqs=SDHCFG_DATA_IRPT_EN|SDHCFG_BLOCK_IRPT_EN java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
{
 struct device *dev = &host->pdev->dev;
 u32 value;
t;

  SDHCFG_BUSY_IRPT_EN;
}else
 if (rethost-hcfg=(host->hcfg &~all_irqs)|
  /* if it takes a while make poll interval bigger */
    SDHCFG_DATA_IRPT_EN
      SDHCFG_BUSY_IRPT_EN
   }
 if (ret == -ETIMEDOUT)
  dev_err(host-hcfg >ioaddr+SDHCFG

 return;
}

static void bcm2835_finish_requestjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct dma_chan java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct mmc_requestmrq

 cancel_delayed_workhost- = data;

 mrq >mrqjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

host-> = NULL
host-cmd;
 host-

 host-/
  >;
> =;

if)
else

  if>, >sg_len)
   dev_err>blocks>blocks
    "
  bcm2835_set_transfer_irqshost

 mmc_request_done((host,mrq
}

static
bool bcm2835_send_command(
{
 struct device *dev = &host->pdev->dev;
u32 ;
 unsigned long timeout

 WARN_ON(host- ;

 sdcmd
 if (sdcmd&SDCMD_NEW_FLAG){
  dev_err(dev, "previous command never completed.\n");
  bcm2835_dumpregs(host);
  cmd->error = -EILSEQ;
  bcm2835_finish_request(host);
 return false;
 } if(ret= -ETIMEDOUT)

 if (!md- && cmd-busy_timeout 00)
  timeout = DIV_ROUND_UP(cmd->busy_timeout, 1000) * HZ + HZ;
  et=readl_poll_timeouthost-ioaddr +SDCMD,value,
  timeout = 10 * HZ;
 schedule_delayed_work(&host->timeout_work, timeout);

 host->cmd =  !(value &SDCMD_NEW_FLAG,

 /* Clear any error flags */
 sdhsts= readlhost-ioaddr+SDHSTS;
 if (sdhsts  (dev % \"_,java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  writel(sdhsts,  return;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (dev" responsetype!)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  cmd- truct * =NULL
 bcm2835_finish_requesthost
  return falsejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 bcm2835_prepare_data

 writel(cmd->arg, >cmd ;

s = cmd- & SDCMD_CMD_MASK

 > =NULL
s&MMC_RSP_PRESENT){
  sdcmd |= SDCMD_NO_RESPONSE;
 } else {
  if (cmd->flags & MMC_RSP_136)
   sdcmd
 if cmd- &MMC_RSP_BUSY{
   sdcmd |= SDCMD_BUSYWAIT;
   host->use_busy = true;
  }
 }

ifcmd-) java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  (>>lagsMMC_DATA_WRITE
   sdcmd |
  if (cmd-mmc_request_done(host);
}
 }

 writel(bool bcm2835_send_command bcm2835_host*, struct *cmd

 return true;
}

static bcm2835_transfer_complete  *host
{
 struct *data

 WARN_ON>cmd;

 data = host-sdcmd bcm2835_read_wait_sdcmd, 10;
 host->data = NULL;

/java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  * a) open-ended multiblock transfer  bcm2835_dumpregs(host);
  *  return false;
  */
 if (host->mrq->  timeout = DIV_ROUND_UP(cmd->busy_timeout, 100 else
  if (bcm2835_send_command(host, host->mrq->stop
 
   if /* Clear any error flags */
   bcm2835_finish_command);
  }
  else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  bcm2835_wait_transfer_complete(host
 bcm2835_finish_request);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static
{
 struct device java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct  sdcmd = cmd->op;

data >data

 host->hcfg &= ~(SDHCFG_DATA_IRPT_EN | SDHCFG_BLOCK_IRPT_EN);
 writel(host- sdcmd=;

   (>flagsMMC_RSP_136

 host->data_complete = true;

 if  if(>flagsMMC_RSP_BUSY {
  /* Data managed to finish before the
 * command completed. Make sure we do
 * things in the proper order.
 */
  dev_dbg(dev, "Finished early >use_busy=true;
  }
 } else {
  bcm2835_transfer_complete(host (>data
 }  (md-data- & )
}

static void bcm2835_finish_command ifcmd-data-flags )
{
struct * =&>>dev
 struct mmc_command *cmd(sdcmd|,host- +SDCMD
 u32return;

 sdcmd

 /* Check for errors */
 if sdcmdSDCMD_NEW_FLAG
  dev_err(dev
  bcm2835_dumpregs);
  host-
 bcm2835_finish_request);
 host- =NULL
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  u32 sdhsts  * b) error in multiblock java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 4

  /* Clear the errors */
>ioaddr+SDHSTS

  if   /* No busy, so poll for completion */
      (host->cmd->opcode != MMC_SEND_OP_COND)) {
   u32 edm, fsm;

   if (sdhsts & SDHSTS_CMD_TIME_OUT) {
     java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   } else {
  dev_err, " command % \n,
     host->cmd->opcode);
    bcm2835_dumpregs(host
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   }
   edm = readl(host-{
   fsm = edm & SDEDM_FSM_MASK;
  struct *dev host->dev
struct *data
    /* Kick the FSM out of its wait */
    writel
         > + SDEDM
   bcm2835_finish_request);
   return;
 }
 }

 if (cmd- host-data_complete=true
  if(md-flagsMMC_RSP_136 {
   int i;

  for( =0; i<4 i+ 
  cmd-3-i =
  (host-   +   java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
     
  } else {
   java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   dev>>;
}

 if (cmd u32sdcmd
  /* Finished CMD23, now send actual command. */= (, 0);
  host->cmd  f sdcmd ) {
  if (bcm2835_send_command(host, host-dev_err(, " .n)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
     host-cmd-error=-EIO;
    /* DMA transfer starts now, PIO starts
 * after irq
 */
    bcm2835_start_dma(host);

  if (!host-use_busy
  bcm2835_finish_command);
  }
  else (cmd=host->stop {
  /* Finished CMD12 */
  bcm2835_finish_request(host);
 } else {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 h>cmd NULL;
  if (!host->data)
   bcm2835_finish_request(host);
  else (>data_complete
   bcm2835_transfer_complete(host     host->md-opcode=MMC_SEND_OP_COND {
 }
}

static void bcm2835_timeout(struct work_struct *work)
{
  delayed_workd=to_delayed_work();
 struct bcm2835_host   (devunexpectedcommanderrorn"
 (d truct, timeout_work;
 struct device *dev = &host->pdev->dev;

 mutex_lock&>mutex

(>)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  dev_err(dev  /* Kick the FSM out of its wait */
 (host

 ((host

  if (
   host->
    if (cmd->flags ) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  } elseint;
   if (host->cmd)
  
  
  >resp  ] java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

   bcm2835_finish_request
  }
 }

 mutex_unlock( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static bcm2835_check_cmd_error cm2835_hosthost,u32)
{
 struct device * host-cmd=;

 if((intmask&SDHSTS_ERROR_MASK
  return false;

 if (   /* DMA transfer starts now, PIO starts
return true;

dev_err(dev, "sdhost_busy_irq: intmask %08x\n", intmask);
if (intmask & SDHSTS_CRC7_ERROR) {
host->cmd->error = -EILSEQ;
} else if (intmask & (SDHSTS_CRC16_ERROR |
      SDHSTS_FIFO_ERROR)) {
if (host->mrq->data)
host->mrq->data->error = -EILSEQ;
else
host->cmd->error = -EILSEQ;
} else if (intmask & SDHSTS_REW_TIME_OUT) {
if (host->mrq->data)
host->mrq->data->error = -ETIMEDOUT;
else
host->cmd->error = -ETIMEDOUT;
} else if (intmask & SDHSTS_CMD_TIME_OUT) {
host->cmd->error = -ETIMEDOUT;
}
bcm2835_dumpregs(host);
return true;
}

static void bcm2835_check_data_error(struct bcm2835_host *host, u32 intmask)
{
if (!host->data)
return;
if (intmask & (SDHSTS_CRC16_ERROR | SDHSTS_FIFO_ERROR))
host->data->error = -EILSEQ;
if (intmask & SDHSTS_REW_TIME_OUT)
host->data->error = -ETIMEDOUT;
}

static void bcm2835_busy_irq(struct bcm2835_host *host)
{
if (WARN_ON(!host->cmd)) {
bcm2835_dumpregs(host);
return;
}

if (WARN_ON(!host->use_busy)) {
bcm2835_dumpregs(host);
return;
}
host->use_busy = false;

bcm2835_finish_command(host);
}

static void bcm2835_data_irq(struct bcm2835_host *host, u32 intmask)
{
/* There are no dedicated data/space available interrupt
 * status bits, so it is necessary to use the single shared
 * data/space available FIFO status bits. It is therefore not
 * an error to get here when there is no data transfer in
 * progress.
 */
 if (!host->data)
  return;

 bcm2835_check_data_error(
ifhost->>error
  goto finished;

 if(>>flags ) {
 /* Use the block interrupt for writes after the first block */
  host->hcfg & }else
 >hcfg=SDHCFG_BLOCK_IRPT_EN
writel>hcfg >ioaddrSDHCFG
(host
}else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  bcm2835_transfer_pio(
  
  (host- ==0)|host->error
   goto finished;
 }
 ;

finished
host- & ( |SDHCFG_BLOCK_IRPT_EN
 writel(  false
}

static  truejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
{
 if (!host- intmask) {
 return;
 if ((host->blocks == 0) || host->data->error)
  bcm2835_finish_data(host);
}

static void bcm2835_block_irq(struct bcm2835_host *host)
{
 if  >mrq->error EILSEQ
 bcm2835_dumpregs(host
  eturn
 }

 if (!host->dma_desc) {
  WARN_ON( if(>mrq-data)
  if (host- >mrq->error ETIMEDOUT
   bcm2835_finish_data(host >cmd-error=-TIMEDOUT
  else
   bcm2835_transfer_pio);
 } else if (host- host->>error ETIMEDOUT
  bcm2835_finish_data(bcm2835_dumpregs(host
 }
}

static irqreturn_t static  bcm2835_check_data_error  *host u32 )
{
   = ;
 struct  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 u32  host->error=-;

 spin_lock>);

 intmask = readl(host->ioaddr + SDHSTS

( java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        SDHSTS_BLOCK_IRPT
        SDHSTS_SDIO_IRPT |
        SDHSTS_DATA_FLAG,
 host-ioaddrSDHSTS

 if (host- = falsejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  (host);
  host->irq_block
java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 27
 }

   * status bits, so it is necessary to use the single shared
  if (!bcm2835_check_cmd_error(host, intmask)) {
   host->irq_busy = true;
  * progress.
  } else {  (!>data
   result = (host);
  }
 }

 /* There is no true data interrupt status bit, so it is  ;
 * necessary to qualify the data flag with the interrupt
 * enable bit.
 */
 if ((intmask & SDHSTS_DATA_FLAG) &&
     (host->hcfg & SDHCFG_DATA_IRPT_EN)) {
 bcm2835_data_irq );
 host-> =true
   = IRQ_WAKE_THREAD
 }

s(&>lock

 return |data-java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
}

static (intirq *dev_id
{
s bcm2835_hosthost  dev_id
 unsigned long flags;
 bool, busy ;

 spin_lock_irqsave(&host- !>data

  =host-irq_block
 busy=host-irq_busy
 data  = host->irq_data;
 host->irq_blockstaticvoid(struct *)
 host-  = ;
 host-(host

 spin_unlock_irqrestore(&host->lock, flags);

 mutex_lock(&host->mutex

 ifWARN_ON>blocks
  (host
  (host
  bcm2835_busy_irq(host);
 if (data)
  bcm2835_data_threaded_irq(host);

 mutex_unlock(&host->mutex);

 return IRQ_HANDLED;
}

  bcm2835_dma_complete_work work_structwork
{
 struct bcm2835_host *host =
 (workstructbcm2835_hostdma_work
   *data

 mutex_lock(&host->mutex(&host-);

 data >data

 if(>dma_chan
         |
         |
          SDHSTS_DATA_FLAGjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

  host- intmask ) {
 }

 if (host->drain_words) {
  void *page;
  u32 *buf =IRQ_WAKE_THREAD

  if (host-if intmask ) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 > =host- > ;
   host->drain_offset &= ~PAGE_MASK;
  }
  page = kmap_local_page(host->drain_page);
    =java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

  while  * enable bit 
 u32 =(> +);

   if ((edm >> 4) & 0x1f)
    *(buf>irq_data=true
  >drain_words--
  }

  kunmap_local(page);
 }

 bcm2835_finish_data

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

static void bcm2835_set_clock(&>lock);
{
 struct mmc_host *mmc = mmc_from_priv(host   >irq_busy
 int div

 /* The SDCDIV register has 11 bits, and holds (div - 2).  But
 * in data mode the max is 50MHz wihout a minimum, and only
 * the bottom 3 bits are used. Since the switch over is
 * automatic (unless we have marked the card as slow...),
 * chosen values have to make sense in both modes.  Ident mode
 * must be 100-400KHz, so can range check the requested
 * clock. CMD15 must be used to return to data mode, so this
 * can be monitored.
 *
 * clock 250MHz -> 0->125MHz, 1->83.3MHz, 2->62.5MHz, 3->50.0MHz
 *                 4->41.7MHz, 5->35.7MHz, 6->31.3MHz, 7->27.8MHz
 *
 *  623->400KHz/27.8MHz
 *  reset value (507)->491159/50MHz
 *
 * BUT, the 3-bit clock divisor in data mode is too small if
 * the core clock is higher than 250MHz, so instead use the
 * SLOW_CARD configuration bit to force the use of the ident
 * clock divisor at all times.
 */

 if (clock < 1000-(&host-mutex)
  /* Can't stop the clock, but make it as slow as possible
 * to show willing
 */
  host->cdiv = SDCDIV_MAX_CDIV;
  writel(host->cdiv, host->ioaddr (host->device->ev
  return;
 }

 div
i( java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  div = host- +> >java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 if ( =page>;
  
 divwhile>drain_words

ifdiv )
  div

 clock = host->max_clk / (div + 2);
mmc-actual_clock clock;

 /* Calibrate some delays */

 host->ns_per_fifo_word = (100000000   host->drain_words--;
  ((mmc->caps java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 host->cdiv java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 writel(host->cdiv

 /* Set the timeout to 500ms */
 writel(mmc-   * = mmc_from_privhost
}

static void bcm2835_request(struct /* The SDCDIV register has 11 bits, and holds (div - 2).  But
{
struct bcm2835_host *host = mmc_priv(mmc);
struct device *dev = &host->pdev->dev;
u32 edm, fsm;

/* Reset the error statuses in case this is a retry */
  * can be monitored  *
  mrq->sbc->error = 0;
 if (mrq->cmd)
  mrq->cmd->error = 0;
 if (mrq->data)
  mrq->  *   reset value (507)->4911  *
 if (mrq->stop)
  mrq->stop->error = 0;

 if  * SLOW_CARD configuration bit to force the use of the ident

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

  if (mrq->cmd)
   mrq-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 (, );
return
 }

 mutex_lock>mutex

 WARN_ON(host->mrq);
 host->mrq = mrq;

 edm = readl(host->ioaddr + SDEDM);
 sm  & SDEDM_FSM_MASK

 if ((  -=2
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (dev" command (% complete (EDM %8\",
   readl(java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
   edm);
  bcm2835_dumpregs(host);

  if (mrq->cmd)
;

  bcm2835_finish_request(host);
  mutex_unlock(&host->mutex);
  return;
 }

 if (host->use_dma, host->ioaddr + SDCDIV);
  bcm2835_prepare_dma(host, mrq->data);

 host->use_sbc }
   (host->mrq->data->flags & MMC_DATA_READ);
 if(>use_sbcjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  if (bcm2835_send_command(host,   devicedev&>pdev-;
   (host-)
    bcm2835_finish_command
   /* Reset the error statuses in case this is a retry */
 }  (>cmd&bcm2835_send_command, >cmd java.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
  if (host->data mrq-)
 /
   bcm2835_start_dma(host);
 }

  (rq->)
   bcm2835_finish_command>>error ;
 }

(&>mutex


static void  if(>cmd
{
 struct bcm2835_host

 mutex_lock(&host->mutex);

 if (!ios->clock || java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bcm2835_set_clock(host, ios->clock
 host-clockios-;
 }

 /* set bus width */
 host->hcfg &= ~SDHCFG_WIDE_EXT_BUS;
 if (ios->bus_width ==  if ((fsm != SDEDM_FSM_IDENTMODE) &&
  host->hcfg |= SDHCFG_WIDE_EXT_BUS;

 host->hcfg |= SDHCFG_WIDE_INT_BUS;

 /* Disable clever clock switching, to cope with fast core clocks */   edm);
 host->  if (mrq->cmd)

 writel(host->hcfg, host->ioaddr + SDHCFG  bcm2835_finish_request(host);

 mutex_unlock(&host->mutex);
}

static const
 .request = bcm2835_request,
 .set_ios = bcm2835_set_ios,
 .card_hw_reset = bcm2835_reset,
};

static int bcm2835_add_host(struct bcm2835_host *host   (host->mrq->data->flags &  if (host->use_sbc) {
{
  }
 struct device } else if (mrq->cmd && bcm2835_send_command(host, mrq->cmd)) {
 char pio_limit_string[20];
 int ret;

 if (!mmc->f_max || mmc->f_max >java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  mmc- ifios-> | >clock>clockjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 mmc->f_min = java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 2

mmc->ax_busy_timeout= 0/(mmc-f_max  00)

 dev_dbg(dev, "f_max %d, f_min %d, max_busy_timeout %d\n",
  mmc->f_max, mmc->f_min, mmc- host-hcfg | SDHCFG_WIDE_EXT_BUS

 /* host controller capabilities */
 mmc->caps|=MMC_CAP_SD_HIGHSPEED| MMC_CAP_MMC_HIGHSPEED|
       MMC_CAP_NEEDS_POLL | 

 spin_lock_init(&host-lock;
 mutex_init(&host->mutex);

 if (!host->dma_chan_rxtx) {
   ,
  >use_dma;
 } else {
  host->use_dma = true

  host->dma_cfg_tx.src_addr_width = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  host->dma_cfg_tx.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
  host-  ret
  host->dma_cfg_tx.src_addr = 0 if!>f_max|mmc- > host-)
  >dma_cfg_tx = host- + SDDATA

  host->
 host-.dst_addr_width=DMA_SLAVE_BUSWIDTH_4_BYTES
  host-
  >dma_cfg_rx = host- + SDDATA
 host-dma_cfg_rx = 0;

  if ( * host controller capabilities */
   &>dma_cfg_tx!  |
      dmaengine_slave_config(host->dma_chan_rxtx,
   host-) !0java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 >use_dmafalsejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 }

 mmc->max_segs = 128;
 mmc->max_req_size = min_t(size_t, 524288, dma_max_mapping_size(dev));
 mmc->max_seg_size = mmc->max_req_size;
 mmc->max_blk_size = 1024;
 mmc->max_blk_count =  65535;

 /* report supported voltage ranges */
 mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34 host-use_dma false;

  ost- = truejava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 INIT_DELAYED_WORK(host-, );

  host->ma_cfg_tx.  DMA_SLAVE_BUSWIDTH_4_BYTES
 host- host-dma_cfg_tx. = DMA_MEM_TO_DEV

 bcm2835_reset_internal( host-dma_cfg_tx = >phys_addr SDDATA

  =request_threaded_irq>irq bcm2835_irq,
      ,
       0, >dma_cfg_rxsrc_addrhost- +SDDATA
 if(ret){
  dev_err(dev, "failed to request IRQ %d: %d\n", host->irq, ret);
  return ret;
 }

 ret = mmc_add_host(mmc);
 if() {
  free_irq(host->irq, host);
  return ret;
 }

[]=''
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
>=2java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 (, "oaded-DMA ssn"
   host->mmc-ocr_avail   |MMC_VDD_33_34java.lang.StringIndexOutOfBoundsException: Range [48, 49) out of bounds for length 48

 return INIT_DELAYED_WORK>timeout_workbcm2835_timeoutjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
}

static int bcm2835_suspend(struct device *
{
 struct bcm2835_host *host = dev_get_drvdata_,

isable_unprepare>);

 return r(ev" to request %d:%\,host-irq )java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
}

ic int bcm2835_resume(structdevicedev
{
 struct bcm2835_host *host = dev_get_drvdata(dev);

 return clk_prepare_enable(host->clk);
}

static DEFINE_SIMPLE_DEV_PM_OPS(bcm2835_pm_ops }
    bcm2835_resume);

static  (>use_dma&(PIO_THRESHOLD> ))
{
 struct device *dev = &pdev->dev;
cm2835_host*;
 struct  >use_dma "nabled : "" pio_limit_string)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 const __be32
 int ret;

 dev_dbg(dev, "%s\n", __func__
mmc evm_mmc_alloc_host, sizeofhost;
 if (!mmc)
  return

 mmc->ops = &bcm2835_ops0
 host
 host->pdev = pdev;
&>)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 (,bcm2835_suspend
 if  )java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  ret = PTR_ERR(host->ioaddr);
  goto err;
 }

 /* Parse OF address directly to get the physical address for
 * DMA to our registers.
 */
 regaddr_p= of_get_address>dev.of_node 0,NULL, );
 if (!regaddr_p) {
  dev_err(dev, "Can't get phys address\n");
  ret = -EINVAL;
  goto ;
 }

 host->phys_addr = be32_to_cpup(regaddr_p);

 host->dma_chan =  = devm_mmc_alloc_host(, sizeof(host);
 host->dma_desc = NULL;

 host->dma_chan_rxtx = dma_request_chan mc-ops =&bcm2835_opsjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 if (IS_ERR(host->dma_chan_rxtxspin_lock_init&>lock
  ret = PTR_ERR(host->ioaddr (pdev0)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  host-  

  if (ret  * DMA to our registers.


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

 host->irq = platform_get_irq(pdev, 0);
 if (host->dma_chan ;
  ret>dma_descNULL
  goto 
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  =mmc_of_parsemmc
 if shost- =NULL
  goto err;

 host-err
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret = dev_err_probe(dev, PTR_ERR(host-> java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  goto ;
 }

 ret = clk_prepare_enable(host->clk);
  (ret
  goto err err

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

 ret = bcm2835_add_host(host);
 if (ret)
   err_clk

 platform_set_drvdata(pdev, host);

  gotoerr

 return

:
 clk_disable_unprepare(host->clk);
err:
d(dev"- %dn,_func__,r);
 if (host-
  (host-);

 return ret;
}

static bcm2835_remove platform_devicepdev
{
 struct bcm2835_host *host = platform_get_drvdata (dev "s > \n, ;
 struct mmc_host *mmc = mmc_from_priv(host);

 mmc_remove_host(mmc);

(, host- + );

 free_irq(host->irq, host);

 cancel_work_sync>)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 cancel_delayed_work_sync>timeout_work

 eturn;

 if (host->dma_chan_rxtx)
 (host-dma_chan_rxtx
}

staticconst  of_device_id[]={
 { .compatible = "brcm,structmmc_host* = mmc_from_priv(host)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 { }
};
MODULE_DEVICE_TABLE(of,

staticstructplatform_driverbcm2835_driver  {
 .probe      = bcm2835_probe,
 .remove     = bcm2835_remove,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  .name  = "sdhost-bcm2835",
  .probe_type java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 .m= pm_ptr(bcm2835_pm_ops,
 },
};
module_platform_driver();

MODULE_ALIAS("platformjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
MODULE_DESCRIPTION("BCM2835 SDHost driver");
MODULE_LICENSEGPLv2;
MODULE_AUTHOR java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4