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
 */
# *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
include.hjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
#include <linux# SDRSP0java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
#include <linuxdmaengine
#include <define x18
#include linux.hjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
#include <linux#  0 /* SD card response (127:96)       - 32 R   */ x20
# SDVDD /* SD card power control           -  1 R/W */  0x34/* Emergency Debug Mode            - 13 R/W */  0x38 /* Host configuration              -  2 R/W */
#include <linux/o.h>
#include <linux/iopoll.h>
#include <linux/module.h>
#include <linux/of_address.h>
#include <#define SDHBLC0x50 /* Host block count (SDIO/SDHC)    -  9 R/W */
#include <#define SDCMD_F   0
includelinux.h>
#include <linux/time.hdefine  0x400
#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 SDARGdefine  0x200
# SDTOUTx08/* Start value for timeout counter - 32 R/W */
#define# SDCMD_READ_CMD0
#defineSDRSP001 *SD response3:)          2R*/
#define SDRSP1 0x14 /* SD card response (63:32)        - 32 R   */
# SDRSP2 01 /* SD card response (95:64)        - 32 R   */
#define SDRSP3#define SDHSTS_BLOCK_IRPT#define SDHSTS_SDIO_IRPT#define #define SDHSTS_CMD_TIME_OUT#define SDHSTS_CRC16_ERROR#define SDHSTS_CRC7_ERROR  0x10#define SDHSTS_FIFO_ERROR /* Reserved *//* Reserved */
define 0x20/
#define SDVDD0x30 /* SD card power control           -  1 R/W */
#define SDEDM  0x34 /* Emergency Debug Mode            - 13 R/W */  | \
#defineSDHCFG /* Host configuration              -  2 R/W */
##  BIT)
#define SDDATA 0x40 /* Data to/from SD card            - 32 R/W */
#define SDHBLC 0x50 /* Host block count (SDIO/SDHC)    -  9 R/W */

define   x8000
#define SDCMD_FAIL_FLAG   0x4000
#define SDCMD_BUSYWAIT   # SDHCFG_SDIO_IRPT_EN(5java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
#defineSDCMD_NO_RESPONSE  x400
#define SDCMD_LONG_RESPONSE  0x200
#define SDCMD_WRITE_CMD   0x80
#efineSDCMD_READ_CMD 0x40
#define SDCMD_CMD_MASK   0x3f   1

#define SDCDIV_MAX_CDIV   0x7ff

#define SDHSTS_BUSY_IRPT SDEDM_CLOCK_PULSE (2)
#define SDHSTS_BLOCK_IRPT  0x200
#define # SDEDM_BYPASS(2)
# SDHSTS_REW_TIME_OUTx80
#define SDHSTS_CMD_TIME_OUT  0x40
#define SDHSTS_CRC16_ERROR 14
#definedefine  0x1f
#defineSDEDM_FSM_MASK 0
/* Reserved */
/* Reserved */
#define SDHSTS_DATA_FLAG  0x01

#define SDHSTS_TRANSFER_ERROR_MASK (SDHSTS_CRC7_ERROR | \
      SDHSTS_CRC16_ERROR | \
 # SDEDM_FSM_READDATAx2
   define 0x3

#define SDHSTS_ERROR_MASK  (SDHSTS_CMD_TIME_OUTjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 29
   SDHSTS_TRANSFER_ERROR_MASK

#define SDHCFG_BUSY_IRPT_EN BIT(10)
#define# SDEDM_FSM_WRITESTART1
#defineSDHCFG_SDIO_IRPT_EN(5
#define SDHCFG_DATA_IRPT_EN# SDEDM_FSM_GENPULSES
#define SDHCFG_SLOW_CARD (3)
#define SDHCFG_WIDE_EXT_BUSSDEDM_FSM_STARTPOWDOWN
#define # FIFO_WRITE_THRESHOLD
#define SDHCFG_REL_CMD_LINE BIT

# SDVDD_POWER_OFF 0
#definejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#structmutex;
#void_  ioaddr
defineBIT1

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define SDEDM_READ_THRESHOLD_SHIFT 14
#define   x1f

#define SDEDM_FSM_MASK  0xf
#define SDEDM_FSM_IDENTMODE 0x0
define 0x1
# delayed_worktimeout_work /* Timer for timeouts */
defineSDEDM_FSM_WRITEDATA0java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
#define SDEDM_FSM_READWAIT 0x4int; /
java.lang.NullPointerException
#define SDEDM_FSM_WRITECRC
#define SDEDM_FSM_WRITEWAIT1 0x7
#define SDEDM_FSM_POWERDOWN 0x8
# 0x9
#define SDEDM_FSM_WRITESTART1 0xa
#define SDEDM_FSM_WRITESTART2 0xb
#define java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
#define SDEDM_FSM_WRITEWAIT2 0xdstruct *; /* Current command */
define 0xf

#define SDDATA_FIFO_WORDS 1bool:;/* Data finished before cmd */

#define FIFO_READ_THRESHOLD 4
#definebooluse_sbc/
#define java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0

HOLD1java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75

struct   irq_data
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
s mutex;

 voids dma_chandma_chan
 3  ;

clk;
s platform_device;

    clock/* Current clock speed */
 unsigned ;
 struct dma_work
 structdelayed_work; /* Timer for timeouts */
 structsg_mapping_iter sg_miter /* SG state for PIO */
 unsigned   blocks java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 int        constchar*)

 32 ns_per_fifo_word;

 /* cached registers */
 u32   hcfg;
 u32   cdiv;

 struct mmc_request *mrq;  /* Current request */
structmmc_commandcmd /* Current command */
 structmmc_data*;  /* Current data request */
 bool   data_complete:1;/* Data finished before cmd */return;
 bool   use_busy
 bool  :1;/* Send CMD23 */

 /* for threaded irq handler */
 bool   irq_block;
 bool   irq_busy;
 bool   irq_data

 /* DMA part */
 struct cmd-);
 struct }
 struct java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 structdma_slave_config dma_cfg_tx
 struct dma_async_tx_descriptor *dma_desc;
 u32
 u32 struct mmc_request*rq=host-
 struct
 u32;
 bool(host>sbcsbc";
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static void bcm2835_dumpcmd(struct bcm2835_host *host, struct mmc_command *cmd
  mrq-data-error
{
 struct device *dev  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

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

(dev, %%s op%  xxflags-resp0x%8 0x 0x, errd"
  ( =host-  >  ',
opcodecmd->rg>flags
 cmd-resp] >[1,cmd-resp,cmd-[3,
 (, 0%8\,readl>ioaddr SDRSP0
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1

static void bcm2835_dumpregs(struct bcm2835_host *host)
{
 struct mmc_request *mrq = host->mrq;
 struct *dev &ost->>dev

dev_dbgdev, "SDEDM 0x%08x\n", readl(host->ioaddr + SDEDM));
  bcm2835_dumpcmd(host, mrq->sbc, "sbc");
  bcm2835_dumpcmd(host, mrq->cmd,  dev_dbgdev SDHCFG0%8\" (host->ioaddr + SDHCFG);
  if(mrq-data{
   dev_dbg(dev, "data blocks %x blksz %x - err %d\n",
   >data-,
    mrq-(dev "=========================n")
    mrq-staticvoid(struct bcm2835_host*)
  }
  bcm2835_dumpcmd(host, mrq->stop, "stop");
 }

  (SDVDD_POWER_OFF host->ioaddrSDVDD
 (0,host- + SDCMD;
 dev_dbg(devwritel0 >ioaddr);
  writelxf00000>ioaddr );
dev_dbg, SDCDIVx0x\" (>+SDCDIV)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 dev_dbg(dev, "SDRSP0 0x%08x\n", readl(host->ioaddrwritelx7f8,host-ioaddr );/* Write 1s to clear */
dev_dbg, SDRSP10xn" readl(>ioaddr SDRSP1));
 dev_dbg(dev, "SDRSP2 0x%08x\n", readl(host->ioaddr  (0 >ioaddr SDHBCT;
 dev_dbg(dev, "SDRSP3 0x%08x\n", (0,host-ioaddrSDHBLC
  /* Limit fifo usage due to silicon bug */temp=readl(>ioaddr );
 ev_dbg, " 0%x\n,readl(host-ioaddr +));
 dev_dbg(dev ( <<SDEDM_WRITE_THRESHOLD_SHIFT
dev_dbg, SDHCFGx%8\" (> +SDHCFG
d(dev SDHBCT%8\n,readl>ioaddr DHBCT
 dev_dbg(dev,  (temphost- + );
  msleep;
}

static void bcm2835_reset_internal(struct bcm2835_host *host
{
 u32 temp;

 writel (host-hcfg host-ioaddr SDHCFG)
writel >ioaddr SDCMD)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 (0,>ioaddr );
 writel(0xf00000, host->java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 writel
 writel
 writelstatic bcm2835_finish_command( bcm2835_host);
 writel
 writel, host- + );

 /* Limit fifo usage due to silicon bug */
 temp (host- + );
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   SDEDM_THRESHOLD_MASK< ));
 temp |=  SDEDM_FSM_READWAIT ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
writel,>ioaddr );
 msleep  edmfsm
 writel(SDVDD_POWER_ON, host->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 msleep( fsm =  &SDEDM_FSM_MASK
 >clock0;
 writel(host->hcfg, host->ioaddr + SDHCFG);
 writel    fsm=SDEDM_FSM_DATAMODE
}

static void bcm2835_reset(struct  if(sm = ) {
{
 struct *hostmmc_priv();

 if(host->)
  dmaengine_terminate_sync(host->java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 9
 host-iftimediff=100){
 d(&host-pdev-,
}

static void bcm2835_finish_command(struct bcm2835_host *host);

static void bcm2835_wait_transfer_complete   bcm2835_dumpregs);
{
 int timediff;
 u32 alternate_idle;

 alternate_idle = (host->mrq->data->flags & MMC_DATA_READ) ?
  SDEDM_FSM_READWAIT: ;

 timediff = 0  }

 while(){
  u32 edm, fsm;

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

  if ((fsm =}
      (fsm == SDEDM_FSM_DATAMODE)
  break
 if( == alternate_idle{
   writel(edm | SDEDM_FORCE_DATA_MODE,
           struct *host ;
   reak
  }

  imediff+
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   dev_err(&host->pdev->devjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  wait_transfer_complete-still dretriesn"
    timediff
   (host;
   host-mrq->>error=-ETIMEDOUT;
   return;
  }
  cpu_relaxsize_t len;
 }
}

static void bcm2835_dma_complete(void * u32buf
{
 struct bcm2835_host *host = param;

 schedule_work(&host->dma_work);
}

static void bcm2835_transfer_block_pio
{
 size_t  len min(host->sg_miter., blksize
unsignedlong;

blksizehost->blksz

 it_max=jiffies msecs_to_jiffies(0)

   blksize -=len
  int;
 u32 = ;
  size_t len;
  u32 *buf;

  (!(&host-)) {
   host->data->error = -EINVAL;
   break;
  }

  len = min(host->sg_miter.length, blksize) int, words
  if (len
 h>data-  EINVAL
  ;
 }

  blksize  (  ) 0)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 >. = ;

 bufu32*>sg_miter;

   =len/;

  while ( &&
   int burst_words, words;
 u32;

   burst_words = min(       fsm_state != SDEDM_FSM_READCRC
   edm ( !  &&
   if (         !  &&
   = (( > 4  x1f
   else
   =SDDATA_FIFO_WORDS( > )&0);

   ifwordsburst_words 
    int    , );
     *dev &>pdev-;

    if    breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  ( !  &&
       ! SDEDM_FSM_READWAIT
  fsm_state=SDEDM_FSM_READCRC|java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  (!s_read &
       fsm_state  &&
          fsm_state !  continue
          != ))) {
     hsts = readl(host->ioaddr + SDHSTS  = copy_words
     dev_err
       copy_words - words;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      break   ()
  

     (*(buf) host-ioaddrSDDATA;
      words--
   }
     hsts = SDHSTS_REW_TIME_OUT;
     break;
    }
  }
            if (hsts & SDHSTS_ERROR_MASK
    continue;
   } elsesg_miter_stop(&ost-);
    static void bcm2835_transfer_pio( bcm2835_hosthost)
   }

   copy_words -= words;

   (ords{
    if
     *(buf++) = readl(host->ioaddr + SDDATA);
    else
     writel(*(buf++), host->ioaddr + SDDATA bcm2835_transfer_block_pio(host, is_read;
    words-- sdhsts=readl>ioaddr +SDHSTS;
   }  (sdhsts SDHSTS_CRC16_ERROR
  }        |

         SDHSTS_FIFO_ERROR)){
   break; dev_errdev "s transfer error -HSTS %0xn",
 }

 sg_miter_stop(&host->sg_miter);
}

static void   str_read_writeis_read sdhsts);
{
 struct device *dev = &host->pdev->dev;
 u32 sdhsts} elseif(sdhsts SDHSTS_CMD_TIME_OUT
 bool;

 is_read = (host-  (dev, "stimeouterror- HSTS %8x\"java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 bcm2835_transfer_block_pio

 sdhsts = readl(host->ioaddr + SDHSTS);
 if
        SDHSTS_CRC7_ERROR|
        SDHSTS_FIFO_ERROR)) {
  dev_err(dev, "%s transfer error - HSTS %08x\n",
   str_read_writeis_read, sdhsts
  {
 } else if ((sdhsts & (SDHSTS_CMD_TIME_OUT |
        SDHSTS_REW_TIME_OUT 
  dev_err(s  *  ;
 (is_read);
  host->data->error = -ETIMEDOUT;
 }d =host-;
}

static  ;
 bcm2835_prepare_dma  *ost mmc_data*ata
{
 int   ;
  dma_async_tx_descriptordesc=;
 struct dma_chan *dma_chan

 dma_chan = host->dma_chan_rxtx;
  * few words.  Unfortunately this   * to be trimmed.  N.  * is contained in  
  ;
  dir_slave  *;
   {
  =;
  dir_slave  ((3( - )*java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


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

>=;
  &>java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
       d;
  u32;
  int;

  len =min((u32(FIFO_READ_THRESHOLD 1  4,
     (u32data-blocks>blksz

  for_each_sg(data->sg, sg, data->sg_len, i)  dma_unmap_sg>>dev>sg>sg_len
   sg_is_last) 
    }
    sg-desc-  ;
  host-  (sg
  >drain_offsetsg-> + >length
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  }
  host->drain_words = len{
 dmaengine_submit(host-dma_descjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 (void;
         ifhost-) java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    } else
  &>dma_cfg_tx;

 sg_len = dma_map_sg(dma_chan->device->dev, data->sg, data->sg_len,
   dir_data
   ;
  return

  =dmaengine_prep_slave_sg,data-sgsg_len,
           java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 if (!desc) {
  dma_unmap_sg(  mmc_data =cmd-;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return;
}

 desc->callback = bcm2835_dma_complete;
 > =host
 host->dma_desc =  host->data_complete;
 >dma_chan=dma_chan
 host->dma_dir  if(>dma_desc
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static  ifdata-flags )
{
  dmaengine_submit
_pending>);
}

static void(host
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     |
  SDHCFG_BUSY_IRPT_EN;

 if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  host-
 SDHCFG_BUSY_IRPT_EN
   {
  >  host-hcfg all_irqs java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  |
 ;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 writel>,host-  );
}

static
void bcm2835_prepare_data(struct bcm2835_host *host, struct value
{
 struct mmc_data *data = cmd->data;

 WARN_ON(host->data);struct *;

 >datadata
 if   =host-;
  return;

 host- ost-mrq;
 host- ost-> = NULL

 if (!host-
  /* Use PIO */
   terminate_chan=host-dma_chan

   host-dma_chan NULL
   flags |= SG_MITER_TO_SG  (terminate_chan){
  else
   flags
  sg_miter_start(&host->sg_miter, data-sg data-, flags;
  host- = data-;
 }

bcm2835_set_transfer_irqs();

 mmc_request_donemmc_from_priv) );
 writel
}

static u32 bcm2835_read_wait_sdcmd(struct  sdcmd,sdhsts
{
 struct device *dev = &host-
 u32value
 int

 if(  )java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   false
  ( =-)
  /* if it takes a while make poll interval bigger */!>data > >90java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
r =(>ioaddr ,java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 )
      1/
 if (ret (>  );
dev_errdev, "%s: timeout (%d ms)\n", __func__, max_ms, "%s:timeout (d ms)n, _func__ max_ms);

  value
}

static void bcm2835_finish_request(struct bcm2835_host dev_err, unsupported !n";
{
s dma_chanterminate_chan ;
 struct bcm2835_finish_request();

 cancel_delayed_work(&host->timeout_work);

 mrq = host-

 host->mrq = NULL;
host- =NULL
 host->data  dcmd >opcode SDCMD_CMD_MASK;

host-dma_desc ;
 terminate_chan s  MMC_RSP_PRESENT) java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 host->dma_chan = NULL;

 if ( if(>flags ) java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
  int err = dmaengine_terminate_all

  (>data{
   dev_err(&host->pdev->dev,
    "failed to if(md-data->lags & )
}

 (mmc_from_priv), mrq
}

static
bool (struct *ost mmc_command)
{
 struct device java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32 sdcmd, static void(structbcm2835_host)
 unsigned mmc_data;

(host->cmd)

  =(host0)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 if (sdcmd /* Need to send CMD12 if -
dev_err(dev, "previous command never completed.\n");
bcm2835_dumpregs(host);
cmd->error = -EILSEQ;
bcm2835_finish_request(host);
return false;
}

if (!cmd->data && cmd->busy_timeout > 9000)
timeout = DIV_ROUND_UP(cmd->busy_timeout, 1000) * HZ + HZ;
else
timeout = 10 * HZ;
schedule_delayed_work(&host->timeout_work, timeout);

host->cmd = cmd;

/* Clear any error flags */
 sdhsts = readl(host-  (host
 if (}else{
  writel(sdhsts, host->ioaddr + SDHSTS);

 (host
 }
  cmd->error = -EINVAL;
  bcm2835_finish_request(host);
  return false;


 bcm2835_prepare_data(host, cmd);

 writel(cmd->arg, host->ioaddr + SDARG);

code & SDCMD_CMD_MASK

 host->use_busy = data =host-;
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  |=SDCMD_NO_RESPONSE

 ifcmd- & )
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  cmd- & ) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   sdcmd |= SDCMD_BUSYWAIT   * command completed. Make sure we    * things in the proper order.
 host-  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 }
 }

 ifcmd-) {
 if(md->>flagsMMC_DATA_WRITE
   sdcmd |=
  (>data-> &MMC_DATA_READ
   sdcmd |= SDCMD_READ_CMD;
   devicedev host-pdev-;

 writelsdcmd  SDCMD_NEW_FLAG >ioaddr );

  true
}

static void bcm2835_transfer_complete
{
 struct mmc_data *dataif ( & ) {

 WARN_ON(host

  (host
>data ;

 /* Need to send CMD12 if -
 * a) open-ended multiblock transfer (no CMD23)
 * b) error in multiblock transfer
 */
 if (host->mrq->stop && (data->error || !host->use_sbc)) {
  if (bcm2835_send_command(host, writel(SDHSTS_ERROR_MASK, host-  );
 java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   if (!host->java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 16
    bcm2835_finish_command(host);
 }
 } else {
  bcm2835_wait_transfer_complete(host);
  bcm2835_finish_request(host  (dev unexpected derror"
 }
}

static void bcm2835_finish_data(struct bcm2835_host * }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  device =&>pdev-;
  mmc_data;

 data = host->data;

 host-  host-ioaddr );
 writel  (host

 data->bytes_xfered java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

>data_complete  ;

    (md-> & ) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  i=0;   ;i+){
   * command   >resp[ - ] =
   *   readl>ioaddr+SDRSP0i*4);
   */
  dev_dbg(dev, "Finished early - HSTS %08x\n",
   readl(host->ioaddr + SDHSTS));
  else {
  java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 10
 }
}

static void bcm2835_finish_command(struct bcm2835_host *host)
{
struct device*dev = &host->pdev->dev
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 u32 sdcmd;

 sdcmd = bcm2835_read_wait_sdcmdhost10);

 /* Check for errors */
if ( & SDCMD_NEW_FLAG java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  dev_errdev"ommand nevercompleted.\";
  bcm2835_dumpregs(host);
>>  EIO
  bcm2835_finish_request(host     * after
 (>)
   (host
  u32 } if = >mrq-)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

  /* Clear the errors */
 ost- =NULLjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

  if (!(sdhsts  ifhost-)
 (host->> ! )) {
   u32 edm, fsm;

   if (sdhsts java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    host->
  struct *  to_delayed_workwork
  dev_err, " %d \"
     host->cmd-> container_of,s bcm2835_hosttimeout_work)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    bcm2835_dumpregs(host)
    mutex_lock(host-);
   }
   edm = readl(host->ioaddr + SDEDM);
   fsm = edm if (host-mrq {
   if (fsm == SDEDM_FSM_READWAIT ||
       fsm == SDEDM_FSM_WRITESTART1)
  /
    writel(edm | SDEDM_FORCE_DATA_MODE,
            bcm2835_dumpregshost);
   bcm2835_finish_request(host); bcm2835_resetmmc_from_priv));
   return;
 }
 }

& MMC_RSP_PRESENT{
  if (cmd->flags & MMC_RSP_136) {
    ijava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

   else
  cmd-[3-i]=
     readl(host->ioaddr + SDRSP0 + i * 4
   }
  } else {
   cmd->resp
  }
}

 if (cmd == host->mrq->sbc}
 static bool(structb *host  intmask
 host-> =NULL
  if (bcm2835_send_command(host, if !intmask  ))
   if (host->data && host->dma_desc)
  /java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
     * after
     dev_err(dev, "sdhost_busy_irq: intmask %08x\n", intmask);
    bcm2835_start_dma  host->cmd->error } else if (intmask & (SDHSTS_CRC16_ERROR |

   if (!host->  else
    bcm2835_finish_command(hostW_TIME_OUT) {
  }
 } else  else
  /* Finished CMD12 */ } else if (intmask   host->cmd->error = -ETIMEDOUT;
  bcm2835_finish_request(host);
 } else {
  /* Processed actual command. */static void bcm2835_check_data_error(struct bcm2835_host *host, u32 intmask)
  host->cmd if (intmask & (SDHSTS_CRC16_ERROR | SDHSTS_FIFO_ERROR  host->data->error S_REW_TIME_OUT)
  if (}
   bcm2835_finish_request(host);
  else if (host->data_complete{
   bcm2835_transfer_complete  bcm2835_dumpregs(host);
 }
}

static void bcm2835_timeout(struct  bcm2835_dumpregs(host);
{
  host->use_busy = false;
 struct bcm2835_host *host bcm2835_finish_command(host);
  container_of(d,
 structstatic void bcm2835_data_irq(struct bcm2835_host *host, u32 intmask)

 mutex_lock(&host-o it is necessary to use the single shared

 if (host->mrq) {
  dev_err(dev, "timeout java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bcm2835_dumpregs

  bcm2835_reset  (host-data-)

  if (host->data) {
   host- (host-data- &MMC_DATA_WRITE
   bcm2835_finish_data /* Use the block interrupt for writes after the first block */
    {
   host- | ;
      (host-hcfg,host- + );
   bcm2835_transfer_pio);
    host-  else{

   bcm2835_finish_request(host);
  }
 }

 mutex_unlock(&host->mutex);
}

static  if((>blocks 0)| >data-)
{
 struct device *dev = &host- return

 if >hcfg= ~SDHCFG_DATA_IRPT_EN );
 return;

 if 
 returntrue;

 dev_err(dev, "sdhost_busy_irq: intmask %08x\n", intmask);
 if( & SDHSTS_CRC7_ERROR{
   returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 } else if (intmask & (SDHSTS_CRC16_ERROR |
         SDHSTS_FIFO_ERROR)) {
  if (host->mrq-
 host->data- =-;
  ();
   r;
 }java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 2
  host->data
  host->data- =-;
  else
  host->error  -;
 } else if (intmask(host
 host-cmd- =-;
 }
 cm2835_dumpregs();
 return true;
}

staticvoid(structbcm2835_hosthost,u32intmask
{
 if (!host->irqreturn_tresultIRQ_NONE
 return;
 if (intmask & (SDHSTS_CRC16_ERROR | SDHSTS_FIFO_ERROR))
 >data-  EILSEQ
 if (intmask & SDHSTS_REW_TIME_OUT(&host-lock
 java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
}

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

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

 bcm2835_finish_command(host);
}

static void bcm2835_data_irq(struct bcm2835_host bcm2835_check_data_error, intmask
{
  result = IRQ_WAKE_THREAD;
 * 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.
 */
ifhost-data)
  return;

 bcm2835_check_data_error, intmask
 if (host->data->errorjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 gotofinished

 if (host-  * necessary to qualify the data flag with the interrupt  * enable bit.
  /* Use the block interrupt for writes after the first block */
  host->hcfg &=  (host, intmask
 host->rq_data ;
  writelresult;
  bcm2835_transfer_pio(host);
 }  pin_unlockhost-);
  
 host->blocks--;
  if ((host->blocks == 0) ||host->data->error)
   goto finished;
 }
 return;

finished:
 host- irqreturn_tbcm2835_threaded_irqint , void*dev_id)
 writel(host- truct *host=dev_id;
}

static void bcm2835_data_threaded_irq(struct   blockbusy,data
{
 if(host-)
  return;
 if ((host-block host->;
     =>;
}

static  bcm2835_block_irq bcm2835_hosthost
{
  >irq_busyfalse
  bcm2835_dumpregs);
  returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 if
  (!host-);
  if ( bcm2835_block_irq);
  bcm2835_finish_data);
  else
   bcm2835_transfer_pio(host);
 } else if (
  bcm2835_finish_data(host);
 }
}

static irqreturn_t bcm2835_irq(int irqstaticvoid(struct *)
{
  container_of,  , );
  structmmc_data;
 u32 intmask

 spin_lock>lock

 intmask =host-;

 writel(SDHSTS_BUSY_IRPT host-) {
  SDHSTS_BLOCK_IRPT |
SDHSTS_SDIO_IRPT
        SDHSTS_DATA_FLAG,
        host->ioaddr + SDHSTS);

 if( &SDHSTS_BLOCK_IRPT
  bcm2835_check_data_error(host, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  host->irq_block = true;
  result ;
 }

 if ( & SDHSTS_BUSY_IRPT{
  if (!bcm2835_check_cmd_error(host, intmask)) {
   host->  host-drain_page+ >drain_offset>PAGE_SHIFT
   result java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 3
  } else {
  result=IRQ_HANDLED;
  }
 }

 /* There is no true data interrupt status bit, so it is
 * necessary to qualify the data flag with the interrupt
 * enable bit.
 */
 if ((intmask   edm=readlhost-ioaddr SDEDM;
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bcm2835_data_irq(host, intmask);
  host-irq_data  ;
  result   host-;
 }

 spin_unlock(&host->lock);

 return result;
}

static irqreturn_t
{
 struct }
 unsigned long flags;
 bool block, busy

 spin_lock_irqsavehost-, flags

 block = host->irq_block;
 busy=host-;
 data  = host-> int;
 host->irq_block = false;
 host->irq_busy  = false;
 host->irq_data  = false;

 spin_unlock_irqrestore(&host->lock, flags);

 mutex_lock(&host->mutex);

 if (block)
  bcm2835_block_irq(host);
 if (busy)
  bcm2835_busy_irq(host);
 if (data)
  bcm2835_data_threaded_irq(host);

 mutex_unlock(&host->mutex);

 return IRQ_HANDLED;
}

static void bcm2835_dma_complete_work(struct work_struct *work)
{
 struct bcm2835_host *host =
  container_of(work, struct bcm2835_host, dma_work);
 struct

 mutex_lock&>mutex;

 data = host->data;

 if (host-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 dma_unmap_sg>dma_chan-device->,
        data->sg, data->sg_len,
        host->dma_dir

  host->dma_chan = NULL;
 }

 if (host->drain_words f (iv < 2)
  void *page;
  u32 *buf;

  if (host->drain_offset & PAGE_MASK) {
>drain_page= host-drain_offset> PAGE_SHIFT;
   host->drain_offset &= ~PAGE_MASK;
  }
  page = kmap_local_page(host->drain_page);
  buf  + host-drain_offset;

   (host-) {
   u32 edm =  ( >SDCDIV_MAX_CDIV

   > =clock
    /* Calibrate some delays */
drain_words--
  }

  kunmap_local(page);
 }

 bcm2835_finish_data(host);

 mutex_unlock(&host->mutex);
}

static
{
 structmmc_hostmmc mmc_from_priv();
 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 < 100000) {
  /* Can't stop the clock, but make it as slow as possible
 * to show willing
 */
  host->cdiv = SDCDIV_MAX_CDIV;
  writel( mmc_request_donemmcmrq;
  ;
 }

 div = host->max_clk(&host-);
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  div = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if ((host->max_clk f =edm ;
  div++;
div ;

 if (div > SDCDIV_MAX_CDIV)
  div dev_err, previous(d)not(EDM0x)n"

 clock = host->max_clk / (div + 2);
 mmc->actual_clock = clockjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

  mrq->cmd->error = -EILSEQ;

host->ns_per_fifo_word = (1000000000 / clock) *
((mmc->caps & MMC_CAP_4_BIT_DATA) ? 8 : 32);

host->cdiv = div;
writel(host->cdiv, host->ioaddr + SDCDIV);

/* Set the timeout to 500ms */
 writel(mmc->actual_clock /
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static host-) {
{
 struct bcm2835_host *host = mmc_priv(mmc);
struct * = &ost->dev
 u32 edm,  if!>use_busy

java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 if (}elseifmrq- & (hostmrq-)){
  mrq->sbc->error = 0;
 if(>cmd
  mrq->cmd-  /* DMA transfer starts now, PIO starts after irq */
 if (mrq->data) }
  mrq-
if(rq->stop
  mrq-stop- =0

 if 
 mutex_unlockhost-);
   mrq-

   (rq-)
   mrq->cmd->error = -EINVAL;

  mmc_request_done(mmc, mrq);
  return;
 }

 mutex_lock(&host->mutex);


 > = >clock

 edm = readl(host-
fsm = edm & SDEDM_FSM_MASK;

if ((fsm != SDEDM_FSM_IDENTMODE) &&
    (fsm != SDEDM_FSM_DATAMODE)) {
dev_err(dev, "previous command (%d) not complete (EDM %08x)\n",
readl(host->ioaddr + SDCMD) & SDCMD_CMD_MASK,
edm);
bcm2835_dumpregs(host);

if (mrq->cmd)
mrq->cmd->error = -EILSEQ;

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

if (host->use_dma && mrq->data && (mrq->data->blocks > PIO_THRESHOLD))
bcm2835_prepare_dma(host, mrq->data);

host->use_sbc = !!mrq->sbc && host->mrq->data &&
(host->mrq->data->flags & MMC_DATA_READ);
if (host->use_sbc) {
if (bcm2835_send_command(host, mrq->sbc)) {
if (!host->use_busy)
bcm2835_finish_command(host);
}
} else if (mrq->cmd && bcm2835_send_command(host, mrq->cmd)) {
if (host->data && host->dma_desc) {
/* DMA transfer starts now, PIO starts after irq */
   bcm2835_start_dma(host);
  }

  if (!host->use_busy)
   bcm2835_finish_command(host);
 }

 mutex_unlock(&host->mutex);
}

static void bcm2835_set_ios(struct mmc_host *mmc,java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
{
 struct bcm2835_host *host = mmc_priv(mmc);

 mutex_lock(&host->mutex);

  (!ios->lock|| ios- != host-) {
  bcm2835_set_clock(host, ios->clock);
  host->clock = ios->clock;
 }

 /* set bus width */
 mmc-> =~  (>f_max/10)
 if
 > =;

 host->hcfg |= SDHCFG_WIDE_INT_BUS =   |

 /* Disable clever clock switching, to cope with fast core clocks */>)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 host->hcfg |= SDHCFG_SLOW_CARD;

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

 mutex_unlock(&host->mutex);
}

static const struct mmc_host_ops bcm2835_ops = {
 .request = bcm2835_request,
 .set_ios ==bcm2835_set_ios,
 .card_hw_resethost-use_dma = falsejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
};

static int bcm2835_add_host(struct bcm2835_host *hostjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct mmc_host *mmc = mmc_from_priv(host);
 struct device *dev = &host->pdev->dev;
 char pio_limit_string[20];
 int;

if (mmc- || >f_max >max_clk
  mmc->f_max  host-.dst_addr >phys_addr ;
 mmc-

 mmc- >dma_cfg_rx  ;

 host-.src_addr >phys_addr ;
   host->.dst_addr0;

/java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
      host-) ! 0|java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
      &>dma_cfg_rx! )

 spin_lock_init(&host->lock);
   host- = false;

 if (!host->dma_chan_rxtx
 /* report supported voltage ranges */
  > =false
 } else {
h>use_dmatrue;

  host->dma_cfg_tx.src_addr_widthINIT_DELAYED_WORK&>timeout_workbcm2835_timeout
 host->ma_cfg_txdst_addr_width=;
 >dma_cfg_txdirection ;
  
 >.dst_addrhost- + ;

  host->
  ret (host-irq,bcm2835_irq
  host-  bcm2835_threaded_irq
 host-. = >phys_addr ;
  host->dma_cfg_rx.dst_addr =  (ret)java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

  if (dmaengine_slave_config(host->
        &host->dma_cfg_tx retjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
      dmaengine_slave_config(host->dma_chan_rxtx,
        &host->
   host-> pio_limit_string0  \0;
 }

 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  104;
 mmc->max_blk_count =  65535;

 /* report supported voltage ranges */dev_infodev" -DMA %%\,
 >ocr_avail=MMC_VDD_32_33 MMC_VDD_33_34;

 INIT_WORK(&host->dma_work, bcm2835_dma_complete_work
 (&host-, );

 /* Set interrupt enables */
 host->hcfg = SDHCFG_BUSY_IRPT_EN;

 bcm2835_reset_internal(host);

35irq
       bcm2835_threaded_irq,
     clk_d(host-clk
 
r(, failed IRQ dn" >,ret;
  return ret;
 }

 ret intbcm2835_resume  *)
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  free_irq(
  return ret;
}

 pio_limit_string[0] = 
ifhost- &  >0)
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 dev_info host
  host- ?"":"isabled,;

 return 0;
}

static int java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 9
{
 struct bcm2835_host *host  =d(dev(*))java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 clk_disable_unprepare

 return ;
}

static int bcm2835_resume(struct device *dev)
{
 struct bcm2835_host spin_lock_init(host-lock;

 return clk_prepare_enable(host->clk);
}

staticDEFINE_SIMPLE_DEV_PM_OPSbcm2835_pm_ops,bcm2835_suspend,
   bcm2835_resume;

static int bcm2835_probe(struct platform_device *pdev)
{
 struct
 struct bcm2835_host ers.
 struct mmc_host  (pdev-,,,NULLjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 const __be32  gotoerr
 int ret;

 dev_dbg(dev, "%s\
mmcdevm_mmc_alloc_hostdevsizeof(host)
 if (!mmc)
  return -ENOMEM;

m>ops= bcm2835_ops;
 host = mmc_priv(mmc);
 host->pdev = pdev;
 spin_lock_init(host-);

 host- =devm_platform_ioremap_resource, 0);
 if (IS_ERR(host->ioaddr)) {
  ret = PTR_ERR(host->ioaddr);
  goto err;
 }

 /* Parse OF address directly to get the physical address for>dma_chan_rxtx =NULL;
 * DMA to our registers.
 */
 regaddr_p = of_get_address(pdev->
 if (!regaddr_p
  dev_err(dev, "Can't get phys /* Ignore errors to fall back to PIO mode */
  ret = -EINVAL;
  goto err;
 }

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

 host- =NULL
 host- = NULL;

 }
 if (IS_ERR(host->dma_chan_rxtx)) {
  ret = PTR_ERR(host-ret mmc_of_parse();
 >dma_chan_rxtx ;

  if (ret 
o ;

  /* Ignore errors to fall back to PIO mode */
}

 host->irq = platform_get_irq(pdev gotoerr
 if (host->irq < 0) {
  ret = host-if)
  goto;
 }

 ret = mmc_of_parse(mmc);
 if (ret)
  goto err;

 host->clk = devm_clk_getgoto;
 if (IS_ERR(host->clk)) {
  ret
 goto ;
 }

 ret = clk_prepare_enable(
 if (err_clk
  goto err;

 host->max_clk = clk_get_rate(host-> ev_dbg, %s > err%\" _ et;

 ret = bcm2835_add_hostdma_release_channel>dma_chan_rxtx
 if (ret)
  goto err_clk;

 platform_set_drvdata(pdev, host void(struct *)

dev_dbg, %s- OK" __func__)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 return 0;

err_clkSDVDD_POWER_OFF>ioaddrSDVDD
 clk_disable_unprepare(host->clk);
err:
 dev_dbg(dev, "%s -> err % cancel_work_sync(&host->ma_work;
 if (host->dma_chan_rxtx)
   cancel_delayed_work_sync(&host-);

r ret
}

static void bcm2835_remove dma_release_channel>);
{
 struct bcm2835_host *host = platform_get_drvdata(pdev const struct bcm2835_match  
   mmcmmc_from_priv;

 mmc_remove_host(mmc);

 ;

 free_irq(   =java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

 cancel_work_sync(&host->dma_work);
 cancel_delayed_work_sync(&host->timeout_work);

 clk_disable_unprepare(host->clk);

 if  . = pm_ptr&)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  dma_release_channelmodule_platform_driverbcm2835_driver
}

static const struct of_device_id bcm2835_match[] = {
 { .compatible (" ")
 {}
};
MODULE_DEVICE_TABLE(of, bcm2835_match);

static struct platform_driver bcm2835_driver = {
 .probe      = bcm2835_probe,
 .remove     = bcm2835_remove,
 .driver     = {
  .name  = "sdhost-bcm2835",
  .probe_type = PROBE_PREFER_ASYNCHRONOUS,
  .of_match_table = bcm2835_match,
  .pm = pm_ptr(&bcm2835_pm_ops),
 },
};
module_platform_driver(bcm2835_driver);

MODULE_ALIAS("platform:sdhost-bcm2835");
MODULE_DESCRIPTION("BCM2835 SDHost driver");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Phil Elwell");