1/* 2 * SuperH Mobile SDHI 3 * 4 * Copyright (C) 2009 Magnus Damm 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 version 2 as 8 * published by the Free Software Foundation. 9 * 10 * Based on "Compaq ASIC3 support": 11 * 12 * Copyright 2001 Compaq Computer Corporation. 13 * Copyright 2004-2005 Phil Blundell 14 * Copyright 2007-2008 OpenedHand Ltd. 15 * 16 * Authors: Phil Blundell <pb@handhelds.org>, 17 * Samuel Ortiz <sameo@openedhand.com> 18 * 19 */ 20 21#include <linux/kernel.h> 22#include <linux/clk.h> 23#include <linux/slab.h> 24#include <linux/module.h> 25#include <linux/platform_device.h> 26#include <linux/mmc/host.h> 27#include <linux/mmc/sh_mobile_sdhi.h> 28#include <linux/mfd/tmio.h> 29#include <linux/sh_dma.h> 30#include <linux/delay.h> 31 32#include "tmio_mmc.h" 33 34struct sh_mobile_sdhi { 35 struct clk *clk; 36 struct tmio_mmc_data mmc_data; 37 struct sh_dmae_slave param_tx; 38 struct sh_dmae_slave param_rx; 39 struct tmio_mmc_dma dma_priv; 40}; 41 42static void sh_mobile_sdhi_set_pwr(struct platform_device *pdev, int state) 43{ 44 struct sh_mobile_sdhi_info *p = pdev->dev.platform_data; 45 46 if (p && p->set_pwr) 47 p->set_pwr(pdev, state); 48} 49 50static int sh_mobile_sdhi_get_cd(struct platform_device *pdev) 51{ 52 struct sh_mobile_sdhi_info *p = pdev->dev.platform_data; 53 54 if (p && p->get_cd) 55 return p->get_cd(pdev); 56 else 57 return -ENOSYS; 58} 59 60static int sh_mobile_sdhi_wait_idle(struct tmio_mmc_host *host) 61{ 62 int timeout = 1000; 63 64 while (--timeout && !(sd_ctrl_read16(host, CTL_STATUS2) & (1 << 13))) 65 udelay(1); 66 67 if (!timeout) { 68 dev_warn(host->pdata->dev, "timeout waiting for SD bus idle\n"); 69 return -EBUSY; 70 } 71 72 return 0; 73} 74 75static int sh_mobile_sdhi_write16_hook(struct tmio_mmc_host *host, int addr) 76{ 77 switch (addr) 78 { 79 case CTL_SD_CMD: 80 case CTL_STOP_INTERNAL_ACTION: 81 case CTL_XFER_BLK_COUNT: 82 case CTL_SD_CARD_CLK_CTL: 83 case CTL_SD_XFER_LEN: 84 case CTL_SD_MEM_CARD_OPT: 85 case CTL_TRANSACTION_CTL: 86 case CTL_DMA_ENABLE: 87 return sh_mobile_sdhi_wait_idle(host); 88 } 89 90 return 0; 91} 92 93static void sh_mobile_sdhi_cd_wakeup(const struct platform_device *pdev) 94{ 95 mmc_detect_change(dev_get_drvdata(&pdev->dev), msecs_to_jiffies(100)); 96} 97 98static const struct sh_mobile_sdhi_ops sdhi_ops = { 99 .cd_wakeup = sh_mobile_sdhi_cd_wakeup, 100}; 101 102static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev) 103{ 104 struct sh_mobile_sdhi *priv; 105 struct tmio_mmc_data *mmc_data; 106 struct sh_mobile_sdhi_info *p = pdev->dev.platform_data; 107 struct tmio_mmc_host *host; 108 char clk_name[8]; 109 int irq, ret, i = 0; 110 bool multiplexed_isr = true; 111 112 priv = kzalloc(sizeof(struct sh_mobile_sdhi), GFP_KERNEL); 113 if (priv == NULL) { 114 dev_err(&pdev->dev, "kzalloc failed\n"); 115 return -ENOMEM; 116 } 117 118 mmc_data = &priv->mmc_data; 119 p->pdata = mmc_data; 120 121 if (p->init) { 122 ret = p->init(pdev, &sdhi_ops); 123 if (ret) 124 goto einit; 125 } 126 127 snprintf(clk_name, sizeof(clk_name), "sdhi%d", pdev->id); 128 priv->clk = clk_get(&pdev->dev, clk_name); 129 if (IS_ERR(priv->clk)) { 130 dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name); 131 ret = PTR_ERR(priv->clk); 132 goto eclkget; 133 } 134 135 mmc_data->hclk = clk_get_rate(priv->clk); 136 mmc_data->set_pwr = sh_mobile_sdhi_set_pwr; 137 mmc_data->get_cd = sh_mobile_sdhi_get_cd; 138 mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED; 139 if (p) { 140 mmc_data->flags = p->tmio_flags; 141 if (mmc_data->flags & TMIO_MMC_HAS_IDLE_WAIT) 142 mmc_data->write16_hook = sh_mobile_sdhi_write16_hook; 143 mmc_data->ocr_mask = p->tmio_ocr_mask; 144 mmc_data->capabilities |= p->tmio_caps; 145 mmc_data->cd_gpio = p->cd_gpio; 146 147 if (p->dma_slave_tx > 0 && p->dma_slave_rx > 0) { 148 priv->param_tx.slave_id = p->dma_slave_tx; 149 priv->param_rx.slave_id = p->dma_slave_rx; 150 priv->dma_priv.chan_priv_tx = &priv->param_tx; 151 priv->dma_priv.chan_priv_rx = &priv->param_rx; 152 priv->dma_priv.alignment_shift = 1; /* 2-byte alignment */ 153 mmc_data->dma = &priv->dma_priv; 154 } 155 } 156 157 /* 158 * All SDHI blocks support 2-byte and larger block sizes in 4-bit 159 * bus width mode. 160 */ 161 mmc_data->flags |= TMIO_MMC_BLKSZ_2BYTES; 162 163 /* 164 * All SDHI blocks support SDIO IRQ signalling. 165 */ 166 mmc_data->flags |= TMIO_MMC_SDIO_IRQ; 167 168 ret = tmio_mmc_host_probe(&host, pdev, mmc_data); 169 if (ret < 0) 170 goto eprobe; 171 172 /* 173 * Allow one or more specific (named) ISRs or 174 * one or more multiplexed (un-named) ISRs. 175 */ 176 177 irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_CARD_DETECT); 178 if (irq >= 0) { 179 multiplexed_isr = false; 180 ret = request_irq(irq, tmio_mmc_card_detect_irq, 0, 181 dev_name(&pdev->dev), host); 182 if (ret) 183 goto eirq_card_detect; 184 } 185 186 irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_SDIO); 187 if (irq >= 0) { 188 multiplexed_isr = false; 189 ret = request_irq(irq, tmio_mmc_sdio_irq, 0, 190 dev_name(&pdev->dev), host); 191 if (ret) 192 goto eirq_sdio; 193 } 194 195 irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_SDCARD); 196 if (irq >= 0) { 197 multiplexed_isr = false; 198 ret = request_irq(irq, tmio_mmc_sdcard_irq, 0, 199 dev_name(&pdev->dev), host); 200 if (ret) 201 goto eirq_sdcard; 202 } else if (!multiplexed_isr) { 203 dev_err(&pdev->dev, 204 "Principal SD-card IRQ is missing among named interrupts\n"); 205 ret = irq; 206 goto eirq_sdcard; 207 } 208 209 if (multiplexed_isr) { 210 while (1) { 211 irq = platform_get_irq(pdev, i); 212 if (irq < 0) 213 break; 214 i++; 215 ret = request_irq(irq, tmio_mmc_irq, 0, 216 dev_name(&pdev->dev), host); 217 if (ret) 218 goto eirq_multiplexed; 219 } 220 221 /* There must be at least one IRQ source */ 222 if (!i) 223 goto eirq_multiplexed; 224 } 225 226 dev_info(&pdev->dev, "%s base at 0x%08lx clock rate %u MHz\n", 227 mmc_hostname(host->mmc), (unsigned long) 228 (platform_get_resource(pdev, IORESOURCE_MEM, 0)->start), 229 mmc_data->hclk / 1000000); 230 231 return ret; 232 233eirq_multiplexed: 234 while (i--) { 235 irq = platform_get_irq(pdev, i); 236 free_irq(irq, host); 237 } 238eirq_sdcard: 239 irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_SDIO); 240 if (irq >= 0) 241 free_irq(irq, host); 242eirq_sdio: 243 irq = platform_get_irq_byname(pdev, SH_MOBILE_SDHI_IRQ_CARD_DETECT); 244 if (irq >= 0) 245 free_irq(irq, host); 246eirq_card_detect: 247 tmio_mmc_host_remove(host); 248eprobe: 249 clk_put(priv->clk); 250eclkget: 251 if (p->cleanup) 252 p->cleanup(pdev); 253einit: 254 kfree(priv); 255 return ret; 256} 257 258static int sh_mobile_sdhi_remove(struct platform_device *pdev) 259{ 260 struct mmc_host *mmc = platform_get_drvdata(pdev); 261 struct tmio_mmc_host *host = mmc_priv(mmc); 262 struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data); 263 struct sh_mobile_sdhi_info *p = pdev->dev.platform_data; 264 int i = 0, irq; 265 266 p->pdata = NULL; 267 268 tmio_mmc_host_remove(host); 269 270 while (1) { 271 irq = platform_get_irq(pdev, i++); 272 if (irq < 0) 273 break; 274 free_irq(irq, host); 275 } 276 277 clk_put(priv->clk); 278 279 if (p->cleanup) 280 p->cleanup(pdev); 281 282 kfree(priv); 283 284 return 0; 285} 286 287static const struct dev_pm_ops tmio_mmc_dev_pm_ops = { 288 .suspend = tmio_mmc_host_suspend, 289 .resume = tmio_mmc_host_resume, 290 .runtime_suspend = tmio_mmc_host_runtime_suspend, 291 .runtime_resume = tmio_mmc_host_runtime_resume, 292}; 293 294static struct platform_driver sh_mobile_sdhi_driver = { 295 .driver = { 296 .name = "sh_mobile_sdhi", 297 .owner = THIS_MODULE, 298 .pm = &tmio_mmc_dev_pm_ops, 299 }, 300 .probe = sh_mobile_sdhi_probe, 301 .remove = __devexit_p(sh_mobile_sdhi_remove), 302}; 303 304module_platform_driver(sh_mobile_sdhi_driver); 305 306MODULE_DESCRIPTION("SuperH Mobile SDHI driver"); 307MODULE_AUTHOR("Magnus Damm"); 308MODULE_LICENSE("GPL v2"); 309MODULE_ALIAS("platform:sh_mobile_sdhi"); 310