arch/arm/mach-omap2/mmc-am3517evm.c

   1 /*
   2  * linux/arch/arm/mach-omap2/mmc-am3517evm.c
   3  *
   4  * Copyright (C) 2007-2008 Texas Instruments
   5  * Copyright (C) 2008 Nokia Corporation
   6  * Author: Texas Instruments
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12 #include <linux/err.h>
  13 #include <linux/io.h>
  14 #include <linux/module.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/delay.h>
  18 #include <linux/gpio.h>
  19
  20 #include <mach/hardware.h>
  21 #include <plat/control.h>
  22 #include <plat/mmc.h>
  23 #include <plat/board.h>
  24 #include "mmc-am3517evm.h"
  25
  26 #define LDO_CLR                 0x00
  27 #define VSEL_S2_CLR             0x40
  28
  29 #define VMMC1_DEV_GRP           0x27
  30 #define VMMC1_CLR               0x00
  31 #define VMMC1_315V              0x03
  32 #define VMMC1_300V              0x02
  33 #define VMMC1_285V              0x01
  34 #define VMMC1_185V              0x00
  35 #define VMMC1_DEDICATED         0x2A
  36
  37 #define VMMC2_DEV_GRP           0x2B
  38 #define VMMC2_CLR               0x40
  39 #define VMMC2_315V              0x0c
  40 #define VMMC2_300V              0x0b
  41 #define VMMC2_285V              0x0a
  42 #define VMMC2_260V              0x08
  43 #define VMMC2_185V              0x06
  44 #define VMMC2_DEDICATED         0x2E
  45
  46 #define VMMC_DEV_GRP_P1         0x20
  47
  48 #define HSMMC_NAME_LEN  9
  49
  50 #if defined(CONFIG_REGULATOR) || \
  51         (defined(CONFIG_MMC_OMAP) || defined(CONFIG_MMC_OMAP_MODULE) || \
  52          defined(CONFIG_MMC_OMAP_HS) || defined(CONFIG_MMC_OMAP_HS_MODULE))
  53
  54 /*
  55  * MMC definitions
  56  *
  57  */
  58 static struct mmc_controller {
  59         struct omap_mmc_platform_data   *mmc;
  60         u8              vmmc_dev_grp;
  61         u8              vmmc_dedicated;
  62         char            name[HSMMC_NAME_LEN];
  63 } hsmmc[] = {
  64         {
  65                 .vmmc_dev_grp           = VMMC1_DEV_GRP,
  66                 .vmmc_dedicated         = VMMC1_DEDICATED,
  67         },
  68         {
  69                 .vmmc_dev_grp           = VMMC2_DEV_GRP,
  70                 .vmmc_dedicated         = VMMC2_DEDICATED,
  71         },
  72 };
  73
  74 static int mmc_card_detect(int irq)
  75 {
  76         unsigned i;
  77
  78         for (i = 0; i < ARRAY_SIZE(hsmmc); i++) {
  79                 struct omap_mmc_platform_data *mmc;
  80
  81                 mmc = hsmmc[i].mmc;
  82                 if (!mmc)
  83                         continue;
  84                 if (irq != mmc->slots[0].card_detect_irq)
  85                         continue;
  86
  87                 /* NOTE: assumes card detect signal is active-low */
  88                 return !gpio_get_value_cansleep(mmc->slots[0].switch_pin);
  89         }
  90         return -ENOSYS;
  91 }
  92
  93 static int mmc_get_ro(struct device *dev, int slot)
  94 {
  95         struct omap_mmc_platform_data *mmc = dev->platform_data;
  96
  97         /* NOTE: assumes write protect signal is active-high */
  98         return gpio_get_value_cansleep(mmc->slots[0].gpio_wp);
  99 }
 100
 101 /*
 102  * MMC Slot Initialization.
 103  */
 104 static int mmc_late_init(struct device *dev)
 105 {
 106         struct omap_mmc_platform_data *mmc = dev->platform_data;
 107         int ret = 0;
 108         int i;
 109
 110         ret = gpio_request(mmc->slots[0].switch_pin, "mmc_cd");
 111         if (ret)
 112                 goto done;
 113         ret = gpio_direction_input(mmc->slots[0].switch_pin);
 114         if (ret)
 115                 goto err;
 116
 117         for (i = 0; i < ARRAY_SIZE(hsmmc); i++) {
 118                 if (hsmmc[i].name == mmc->slots[0].name) {
 119                         hsmmc[i].mmc = mmc;
 120                         break;
 121                 }
 122         }
 123
 124         return 0;
 125
 126 err:
 127         gpio_free(mmc->slots[0].switch_pin);
 128 done:
 129         mmc->slots[0].card_detect_irq = 0;
 130         mmc->slots[0].card_detect = NULL;
 131
 132         dev_err(dev, "err %d configuring card detect\n", ret);
 133         return ret;
 134 }
 135
 136 static void mmc_cleanup(struct device *dev)
 137 {
 138         struct omap_mmc_platform_data *mmc = dev->platform_data;
 139
 140         gpio_free(mmc->slots[0].switch_pin);
 141 }
 142
 143 #ifdef CONFIG_PM
 144
 145 static int mmc_suspend(struct device *dev, int slot)
 146 {
 147         struct omap_mmc_platform_data *mmc = dev->platform_data;
 148
 149         disable_irq(mmc->slots[0].card_detect_irq);
 150         return 0;
 151 }
 152
 153 static int mmc_resume(struct device *dev, int slot)
 154 {
 155         struct omap_mmc_platform_data *mmc = dev->platform_data;
 156
 157         enable_irq(mmc->slots[0].card_detect_irq);
 158         return 0;
 159 }
 160
 161 #else
 162 #define mmc_suspend     NULL
 163 #define mmc_resume      NULL
 164 #endif
 165
 166 /*
 167  * the MMC power setting function
 168  */
 169
 170 static int mmc1_set_power(struct device *dev, int slot, int power_on,
 171                                 int vdd)
 172 {
 173         return 0;
 174 }
 175
 176 static int mmc2_set_power(struct device *dev, int slot, int power_on, int vdd)
 177 {
 178         return 0;
 179 }
 180
 181 static struct omap_mmc_platform_data *hsmmc_data[OMAP34XX_NR_MMC] __initdata;
 182
 183 void __init am3517_mmc_init(struct am3517_hsmmc_info *controllers)
 184 {
 185         struct am3517_hsmmc_info *c;
 186         int nr_hsmmc = ARRAY_SIZE(hsmmc_data);
 187
 188         for (c = controllers; c->mmc; c++) {
 189                 struct mmc_controller *mmc_control = hsmmc + c->mmc - 1;
 190                 struct omap_mmc_platform_data *mmc = hsmmc_data[c->mmc - 1];
 191
 192                 if (!c->mmc || c->mmc > nr_hsmmc) {
 193                         pr_debug("MMC%d: no such controller\n", c->mmc);
 194                         continue;
 195                 }
 196                 if (mmc) {
 197                         pr_debug("MMC%d: already configured\n", c->mmc);
 198                         continue;
 199                 }
 200
 201                 mmc = kzalloc(sizeof(struct omap_mmc_platform_data), GFP_KERNEL);
 202                 if (!mmc) {
 203                         pr_err("Cannot allocate memory for mmc device!\n");
 204                         return;
 205                 }
 206
 207                 sprintf(mmc_control->name, "mmc%islot%i", c->mmc, 1);
 208                 mmc->slots[0].name = mmc_control->name;
 209                 mmc->nr_slots = 1;
 210                 mmc->slots[0].ocr_mask = MMC_VDD_165_195 |
 211                                         MMC_VDD_26_27 | MMC_VDD_27_28 |
 212                                         MMC_VDD_29_30 |
 213                                         MMC_VDD_30_31 | MMC_VDD_31_32;
 214                 mmc->slots[0].wires = c->wires;
 215                 mmc->slots[0].internal_clock = !c->ext_clock;
 216                 mmc->dma_mask = 0xffffffff;
 217
 218                 if (1) {
 219                         mmc->init = mmc_late_init;
 220                         mmc->cleanup = mmc_cleanup;
 221                         mmc->suspend = mmc_suspend;
 222                         mmc->resume = mmc_resume;
 223
 224                         mmc->slots[0].switch_pin = c->gpio_cd;
 225                         mmc->slots[0].card_detect_irq = gpio_to_irq(c->gpio_cd);
 226                         mmc->slots[0].card_detect = mmc_card_detect;
 227                 } else
 228                         mmc->slots[0].switch_pin = -EINVAL;
 229
 230                 /* write protect normally uses an OMAP gpio */
 231                 if (gpio_is_valid(c->gpio_wp)) {
 232                         gpio_request(c->gpio_wp, "mmc_wp");
 233                         gpio_direction_input(c->gpio_wp);
 234
 235                         mmc->slots[0].gpio_wp = c->gpio_wp;
 236                         mmc->slots[0].get_ro = mmc_get_ro;
 237                 } else
 238                         mmc->slots[0].gpio_wp = -EINVAL;
 239
 240                 /* NOTE:  we assume OMAP's MMC1 and MMC2 use
 241                  * the TWL4030's VMMC1 and VMMC2, respectively;
 242                  * and that OMAP's MMC3 isn't used.
 243                  */
 244
 245                 switch (c->mmc) {
 246                 case 1:
 247                         mmc->slots[0].set_power = mmc1_set_power;
 248                         break;
 249                 case 2:
 250                         mmc->slots[0].set_power = mmc2_set_power;
 251                         break;
 252                 default:
 253                         pr_err("MMC%d configuration not supported!\n", c->mmc);
 254                         continue;
 255                 }
 256                 hsmmc_data[c->mmc - 1] = mmc;
 257         }
 258
 259         omap2_init_mmc(hsmmc_data, OMAP34XX_NR_MMC);
 260 }
 261 #else
 262 inline void am3517_mmc_init(struct am3517_hsmmc_info *info)
 263 {
 264 }
 265 #endif