git.oblomov.eu Git - linux-2.6/blob - drivers/mmc/core/sdio_ops.c

   1 /*
   2  *  linux/drivers/mmc/sdio_ops.c
   3  *
   4  *  Copyright 2006-2007 Pierre Ossman
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or (at
   9  * your option) any later version.
  10  */
  11
  12 #include <asm/scatterlist.h>
  13 #include <linux/scatterlist.h>
  14
  15 #include <linux/mmc/host.h>
  16 #include <linux/mmc/card.h>
  17 #include <linux/mmc/mmc.h>
  18 #include <linux/mmc/sdio.h>
  19
  20 #include "core.h"
  21
  22 int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
  23 {
  24         struct mmc_command cmd;
  25         int i, err = 0;
  26
  27         BUG_ON(!host);
  28
  29         memset(&cmd, 0, sizeof(struct mmc_command));
  30
  31         cmd.opcode = SD_IO_SEND_OP_COND;
  32         cmd.arg = ocr;
  33         cmd.flags = MMC_RSP_R4 | MMC_CMD_BCR;
  34
  35         for (i = 100; i; i--) {
  36                 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
  37                 if (err)
  38                         break;
  39
  40                 if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0)
  41                         break;
  42
  43                 err = -ETIMEDOUT;
  44
  45                 mmc_delay(10);
  46         }
  47
  48         if (rocr)
  49                 *rocr = cmd.resp[0];
  50
  51         return err;
  52 }
  53
  54 int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
  55         unsigned addr, u8 in, u8* out)
  56 {
  57         struct mmc_command cmd;
  58         int err;
  59
  60         BUG_ON(!card);
  61         BUG_ON(fn > 7);
  62
  63         memset(&cmd, 0, sizeof(struct mmc_command));
  64
  65         cmd.opcode = SD_IO_RW_DIRECT;
  66         cmd.arg = write ? 0x80000000 : 0x00000000;
  67         cmd.arg |= fn << 28;
  68         cmd.arg |= (write && out) ? 0x08000000 : 0x00000000;
  69         cmd.arg |= addr << 9;
  70         cmd.arg |= in;
  71         cmd.flags = MMC_RSP_R5 | MMC_CMD_AC;
  72
  73         err = mmc_wait_for_cmd(card->host, &cmd, 0);
  74         if (err)
  75                 return err;
  76
  77         if (cmd.resp[0] & R5_ERROR)
  78                 return -EIO;
  79         if (cmd.resp[0] & R5_FUNCTION_NUMBER)
  80                 return -EINVAL;
  81         if (cmd.resp[0] & R5_OUT_OF_RANGE)
  82                 return -ERANGE;
  83
  84         if (out)
  85                 *out = cmd.resp[0] & 0xFF;
  86
  87         return 0;
  88 }
  89
  90 int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
  91         unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz)
  92 {
  93         struct mmc_request mrq;
  94         struct mmc_command cmd;
  95         struct mmc_data data;
  96         struct scatterlist sg;
  97
  98         BUG_ON(!card);
  99         BUG_ON(fn > 7);
 100         BUG_ON(blocks == 1 && blksz > 512);
 101         WARN_ON(blocks == 0);
 102         WARN_ON(blksz == 0);
 103
 104         memset(&mrq, 0, sizeof(struct mmc_request));
 105         memset(&cmd, 0, sizeof(struct mmc_command));
 106         memset(&data, 0, sizeof(struct mmc_data));
 107
 108         mrq.cmd = &cmd;
 109         mrq.data = &data;
 110
 111         cmd.opcode = SD_IO_RW_EXTENDED;
 112         cmd.arg = write ? 0x80000000 : 0x00000000;
 113         cmd.arg |= fn << 28;
 114         cmd.arg |= incr_addr ? 0x04000000 : 0x00000000;
 115         cmd.arg |= addr << 9;
 116         if (blocks == 1 && blksz <= 512)
 117                 cmd.arg |= (blksz == 512) ? 0 : blksz;  /* byte mode */
 118         else
 119                 cmd.arg |= 0x08000000 | blocks;         /* block mode */
 120         cmd.flags = MMC_RSP_R5 | MMC_CMD_ADTC;
 121
 122         data.blksz = blksz;
 123         data.blocks = blocks;
 124         data.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
 125         data.sg = &sg;
 126         data.sg_len = 1;
 127
 128         sg_init_one(&sg, buf, blksz * blocks);
 129
 130         mmc_set_data_timeout(&data, card);
 131
 132         mmc_wait_for_req(card->host, &mrq);
 133
 134         if (cmd.error)
 135                 return cmd.error;
 136         if (data.error)
 137                 return data.error;
 138
 139         if (cmd.resp[0] & R5_ERROR)
 140                 return -EIO;
 141         if (cmd.resp[0] & R5_FUNCTION_NUMBER)
 142                 return -EINVAL;
 143         if (cmd.resp[0] & R5_OUT_OF_RANGE)
 144                 return -ERANGE;
 145
 146         return 0;
 147 }
 148