← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/mmc/host/mmci.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/mmc/host/mmci.c
 
1
/*
 
2
 *  linux/drivers/mmc/host/mmci.c - ARM PrimeCell MMCI PL180/1 driver
 
3
 *
 
4
 *  Copyright (C) 2003 Deep Blue Solutions, Ltd, All Rights Reserved.
 
5
 *  Copyright (C) 2010 ST-Ericsson SA
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or modify
 
8
 * it under the terms of the GNU General Public License version 2 as
 
9
 * published by the Free Software Foundation.
 
10
 */
 
11
#include <linux/module.h>
 
12
#include <linux/moduleparam.h>
 
13
#include <linux/init.h>
 
14
#include <linux/ioport.h>
 
15
#include <linux/device.h>
 
16
#include <linux/interrupt.h>
 
17
#include <linux/kernel.h>
 
18
#include <linux/delay.h>
 
19
#include <linux/err.h>
 
20
#include <linux/highmem.h>
 
21
#include <linux/log2.h>
 
22
#include <linux/mmc/host.h>
 
23
#include <linux/mmc/card.h>
 
24
#include <linux/amba/bus.h>
 
25
#include <linux/clk.h>
 
26
#include <linux/scatterlist.h>
 
27
#include <linux/gpio.h>
 
28
#include <linux/regulator/consumer.h>
 
29
#include <linux/dmaengine.h>
 
30
#include <linux/dma-mapping.h>
 
31
#include <linux/amba/mmci.h>
 
32
#include <linux/pm_runtime.h>
 
33
 
 
34
#include <asm/div64.h>
 
35
#include <asm/io.h>
 
36
#include <asm/sizes.h>
 
37
 
 
38
#include "mmci.h"
 
39
 
 
40
#define DRIVER_NAME "mmci-pl18x"
 
41
 
 
42
static unsigned int fmax = 515633;
 
43
 
 
44
/**
 
45
 * struct variant_data - MMCI variant-specific quirks
 
46
 * @clkreg: default value for MCICLOCK register
 
47
 * @clkreg_enable: enable value for MMCICLOCK register
 
48
 * @datalength_bits: number of bits in the MMCIDATALENGTH register
 
49
 * @fifosize: number of bytes that can be written when MMCI_TXFIFOEMPTY
 
50
 *            is asserted (likewise for RX)
 
51
 * @fifohalfsize: number of bytes that can be written when MCI_TXFIFOHALFEMPTY
 
52
 *                is asserted (likewise for RX)
 
53
 * @sdio: variant supports SDIO
 
54
 * @st_clkdiv: true if using a ST-specific clock divider algorithm
 
55
 * @blksz_datactrl16: true if Block size is at b16..b30 position in datactrl register
 
56
 */
 
57
struct variant_data {
 
58
        unsigned int            clkreg;
 
59
        unsigned int            clkreg_enable;
 
60
        unsigned int            datalength_bits;
 
61
        unsigned int            fifosize;
 
62
        unsigned int            fifohalfsize;
 
63
        bool                    sdio;
 
64
        bool                    st_clkdiv;
 
65
        bool                    blksz_datactrl16;
 
66
};
 
67
 
 
68
static struct variant_data variant_arm = {
 
69
        .fifosize               = 16 * 4,
 
70
        .fifohalfsize           = 8 * 4,
 
71
        .datalength_bits        = 16,
 
72
};
 
73
 
 
74
static struct variant_data variant_arm_extended_fifo = {
 
75
        .fifosize               = 128 * 4,
 
76
        .fifohalfsize           = 64 * 4,
 
77
        .datalength_bits        = 16,
 
78
};
 
79
 
 
80
static struct variant_data variant_u300 = {
 
81
        .fifosize               = 16 * 4,
 
82
        .fifohalfsize           = 8 * 4,
 
83
        .clkreg_enable          = MCI_ST_U300_HWFCEN,
 
84
        .datalength_bits        = 16,
 
85
        .sdio                   = true,
 
86
};
 
87
 
 
88
static struct variant_data variant_ux500 = {
 
89
        .fifosize               = 30 * 4,
 
90
        .fifohalfsize           = 8 * 4,
 
91
        .clkreg                 = MCI_CLK_ENABLE,
 
92
        .clkreg_enable          = MCI_ST_UX500_HWFCEN,
 
93
        .datalength_bits        = 24,
 
94
        .sdio                   = true,
 
95
        .st_clkdiv              = true,
 
96
};
 
97
 
 
98
static struct variant_data variant_ux500v2 = {
 
99
        .fifosize               = 30 * 4,
 
100
        .fifohalfsize           = 8 * 4,
 
101
        .clkreg                 = MCI_CLK_ENABLE,
 
102
        .clkreg_enable          = MCI_ST_UX500_HWFCEN,
 
103
        .datalength_bits        = 24,
 
104
        .sdio                   = true,
 
105
        .st_clkdiv              = true,
 
106
        .blksz_datactrl16       = true,
 
107
};
 
108
 
 
109
/*
 
110
 * This must be called with host->lock held
 
111
 */
 
112
static void mmci_set_clkreg(struct mmci_host *host, unsigned int desired)
 
113
{
 
114
        struct variant_data *variant = host->variant;
 
115
        u32 clk = variant->clkreg;
 
116
 
 
117
        if (desired) {
 
118
                if (desired >= host->mclk) {
 
119
                        clk = MCI_CLK_BYPASS;
 
120
                        if (variant->st_clkdiv)
 
121
                                clk |= MCI_ST_UX500_NEG_EDGE;
 
122
                        host->cclk = host->mclk;
 
123
                } else if (variant->st_clkdiv) {
 
124
                        /*
 
125
                         * DB8500 TRM says f = mclk / (clkdiv + 2)
 
126
                         * => clkdiv = (mclk / f) - 2
 
127
                         * Round the divider up so we don't exceed the max
 
128
                         * frequency
 
129
                         */
 
130
                        clk = DIV_ROUND_UP(host->mclk, desired) - 2;
 
131
                        if (clk >= 256)
 
132
                                clk = 255;
 
133
                        host->cclk = host->mclk / (clk + 2);
 
134
                } else {
 
135
                        /*
 
136
                         * PL180 TRM says f = mclk / (2 * (clkdiv + 1))
 
137
                         * => clkdiv = mclk / (2 * f) - 1
 
138
                         */
 
139
                        clk = host->mclk / (2 * desired) - 1;
 
140
                        if (clk >= 256)
 
141
                                clk = 255;
 
142
                        host->cclk = host->mclk / (2 * (clk + 1));
 
143
                }
 
144
 
 
145
                clk |= variant->clkreg_enable;
 
146
                clk |= MCI_CLK_ENABLE;
 
147
                /* This hasn't proven to be worthwhile */
 
148
                /* clk |= MCI_CLK_PWRSAVE; */
 
149
        }
 
150
 
 
151
        if (host->mmc->ios.bus_width == MMC_BUS_WIDTH_4)
 
152
                clk |= MCI_4BIT_BUS;
 
153
        if (host->mmc->ios.bus_width == MMC_BUS_WIDTH_8)
 
154
                clk |= MCI_ST_8BIT_BUS;
 
155
 
 
156
        writel(clk, host->base + MMCICLOCK);
 
157
}
 
158
 
 
159
static void
 
160
mmci_request_end(struct mmci_host *host, struct mmc_request *mrq)
 
161
{
 
162
        writel(0, host->base + MMCICOMMAND);
 
163
 
 
164
        BUG_ON(host->data);
 
165
 
 
166
        host->mrq = NULL;
 
167
        host->cmd = NULL;
 
168
 
 
169
        /*
 
170
         * Need to drop the host lock here; mmc_request_done may call
 
171
         * back into the driver...
 
172
         */
 
173
        spin_unlock(&host->lock);
 
174
        pm_runtime_put(mmc_dev(host->mmc));
 
175
        mmc_request_done(host->mmc, mrq);
 
176
        spin_lock(&host->lock);
 
177
}
 
178
 
 
179
static void mmci_set_mask1(struct mmci_host *host, unsigned int mask)
 
180
{
 
181
        void __iomem *base = host->base;
 
182
 
 
183
        if (host->singleirq) {
 
184
                unsigned int mask0 = readl(base + MMCIMASK0);
 
185
 
 
186
                mask0 &= ~MCI_IRQ1MASK;
 
187
                mask0 |= mask;
 
188
 
 
189
                writel(mask0, base + MMCIMASK0);
 
190
        }
 
191
 
 
192
        writel(mask, base + MMCIMASK1);
 
193
}
 
194
 
 
195
static void mmci_stop_data(struct mmci_host *host)
 
196
{
 
197
        writel(0, host->base + MMCIDATACTRL);
 
198
        mmci_set_mask1(host, 0);
 
199
        host->data = NULL;
 
200
}
 
201
 
 
202
static void mmci_init_sg(struct mmci_host *host, struct mmc_data *data)
 
203
{
 
204
        unsigned int flags = SG_MITER_ATOMIC;
 
205
 
 
206
        if (data->flags & MMC_DATA_READ)
 
207
                flags |= SG_MITER_TO_SG;
 
208
        else
 
209
                flags |= SG_MITER_FROM_SG;
 
210
 
 
211
        sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
 
212
}
 
213
 
 
214
/*
 
215
 * All the DMA operation mode stuff goes inside this ifdef.
 
216
 * This assumes that you have a generic DMA device interface,
 
217
 * no custom DMA interfaces are supported.
 
218
 */
 
219
#ifdef CONFIG_DMA_ENGINE
 
220
static void __devinit mmci_dma_setup(struct mmci_host *host)
 
221
{
 
222
        struct mmci_platform_data *plat = host->plat;
 
223
        const char *rxname, *txname;
 
224
        dma_cap_mask_t mask;
 
225
 
 
226
        if (!plat || !plat->dma_filter) {
 
227
                dev_info(mmc_dev(host->mmc), "no DMA platform data\n");
 
228
                return;
 
229
        }
 
230
 
 
231
        /* initialize pre request cookie */
 
232
        host->next_data.cookie = 1;
 
233
 
 
234
        /* Try to acquire a generic DMA engine slave channel */
 
235
        dma_cap_zero(mask);
 
236
        dma_cap_set(DMA_SLAVE, mask);
 
237
 
 
238
        /*
 
239
         * If only an RX channel is specified, the driver will
 
240
         * attempt to use it bidirectionally, however if it is
 
241
         * is specified but cannot be located, DMA will be disabled.
 
242
         */
 
243
        if (plat->dma_rx_param) {
 
244
                host->dma_rx_channel = dma_request_channel(mask,
 
245
                                                           plat->dma_filter,
 
246
                                                           plat->dma_rx_param);
 
247
                /* E.g if no DMA hardware is present */
 
248
                if (!host->dma_rx_channel)
 
249
                        dev_err(mmc_dev(host->mmc), "no RX DMA channel\n");
 
250
        }
 
251
 
 
252
        if (plat->dma_tx_param) {
 
253
                host->dma_tx_channel = dma_request_channel(mask,
 
254
                                                           plat->dma_filter,
 
255
                                                           plat->dma_tx_param);
 
256
                if (!host->dma_tx_channel)
 
257
                        dev_warn(mmc_dev(host->mmc), "no TX DMA channel\n");
 
258
        } else {
 
259
                host->dma_tx_channel = host->dma_rx_channel;
 
260
        }
 
261
 
 
262
        if (host->dma_rx_channel)
 
263
                rxname = dma_chan_name(host->dma_rx_channel);
 
264
        else
 
265
                rxname = "none";
 
266
 
 
267
        if (host->dma_tx_channel)
 
268
                txname = dma_chan_name(host->dma_tx_channel);
 
269
        else
 
270
                txname = "none";
 
271
 
 
272
        dev_info(mmc_dev(host->mmc), "DMA channels RX %s, TX %s\n",
 
273
                 rxname, txname);
 
274
 
 
275
        /*
 
276
         * Limit the maximum segment size in any SG entry according to
 
277
         * the parameters of the DMA engine device.
 
278
         */
 
279
        if (host->dma_tx_channel) {
 
280
                struct device *dev = host->dma_tx_channel->device->dev;
 
281
                unsigned int max_seg_size = dma_get_max_seg_size(dev);
 
282
 
 
283
                if (max_seg_size < host->mmc->max_seg_size)
 
284
                        host->mmc->max_seg_size = max_seg_size;
 
285
        }
 
286
        if (host->dma_rx_channel) {
 
287
                struct device *dev = host->dma_rx_channel->device->dev;
 
288
                unsigned int max_seg_size = dma_get_max_seg_size(dev);
 
289
 
 
290
                if (max_seg_size < host->mmc->max_seg_size)
 
291
                        host->mmc->max_seg_size = max_seg_size;
 
292
        }
 
293
}
 
294
 
 
295
/*
 
296
 * This is used in __devinit or __devexit so inline it
 
297
 * so it can be discarded.
 
298
 */
 
299
static inline void mmci_dma_release(struct mmci_host *host)
 
300
{
 
301
        struct mmci_platform_data *plat = host->plat;
 
302
 
 
303
        if (host->dma_rx_channel)
 
304
                dma_release_channel(host->dma_rx_channel);
 
305
        if (host->dma_tx_channel && plat->dma_tx_param)
 
306
                dma_release_channel(host->dma_tx_channel);
 
307
        host->dma_rx_channel = host->dma_tx_channel = NULL;
 
308
}
 
309
 
 
310
static void mmci_dma_unmap(struct mmci_host *host, struct mmc_data *data)
 
311
{
 
312
        struct dma_chan *chan = host->dma_current;
 
313
        enum dma_data_direction dir;
 
314
        u32 status;
 
315
        int i;
 
316
 
 
317
        /* Wait up to 1ms for the DMA to complete */
 
318
        for (i = 0; ; i++) {
 
319
                status = readl(host->base + MMCISTATUS);
 
320
                if (!(status & MCI_RXDATAAVLBLMASK) || i >= 100)
 
321
                        break;
 
322
                udelay(10);
 
323
        }
 
324
 
 
325
        /*
 
326
         * Check to see whether we still have some data left in the FIFO -
 
327
         * this catches DMA controllers which are unable to monitor the
 
328
         * DMALBREQ and DMALSREQ signals while allowing us to DMA to non-
 
329
         * contiguous buffers.  On TX, we'll get a FIFO underrun error.
 
330
         */
 
331
        if (status & MCI_RXDATAAVLBLMASK) {
 
332
                dmaengine_terminate_all(chan);
 
333
                if (!data->error)
 
334
                        data->error = -EIO;
 
335
        }
 
336
 
 
337
        if (data->flags & MMC_DATA_WRITE) {
 
338
                dir = DMA_TO_DEVICE;
 
339
        } else {
 
340
                dir = DMA_FROM_DEVICE;
 
341
        }
 
342
 
 
343
        if (!data->host_cookie)
 
344
                dma_unmap_sg(chan->device->dev, data->sg, data->sg_len, dir);
 
345
 
 
346
        /*
 
347
         * Use of DMA with scatter-gather is impossible.
 
348
         * Give up with DMA and switch back to PIO mode.
 
349
         */
 
350
        if (status & MCI_RXDATAAVLBLMASK) {
 
351
                dev_err(mmc_dev(host->mmc), "buggy DMA detected. Taking evasive action.\n");
 
352
                mmci_dma_release(host);
 
353
        }
 
354
}
 
355
 
 
356
static void mmci_dma_data_error(struct mmci_host *host)
 
357
{
 
358
        dev_err(mmc_dev(host->mmc), "error during DMA transfer!\n");
 
359
        dmaengine_terminate_all(host->dma_current);
 
360
}
 
361
 
 
362
static int mmci_dma_prep_data(struct mmci_host *host, struct mmc_data *data,
 
363
                              struct mmci_host_next *next)
 
364
{
 
365
        struct variant_data *variant = host->variant;
 
366
        struct dma_slave_config conf = {
 
367
                .src_addr = host->phybase + MMCIFIFO,
 
368
                .dst_addr = host->phybase + MMCIFIFO,
 
369
                .src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES,
 
370
                .dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES,
 
371
                .src_maxburst = variant->fifohalfsize >> 2, /* # of words */
 
372
                .dst_maxburst = variant->fifohalfsize >> 2, /* # of words */
 
373
        };
 
374
        struct dma_chan *chan;
 
375
        struct dma_device *device;
 
376
        struct dma_async_tx_descriptor *desc;
 
377
        int nr_sg;
 
378
 
 
379
        /* Check if next job is already prepared */
 
380
        if (data->host_cookie && !next &&
 
381
            host->dma_current && host->dma_desc_current)
 
382
                return 0;
 
383
 
 
384
        if (!next) {
 
385
                host->dma_current = NULL;
 
386
                host->dma_desc_current = NULL;
 
387
        }
 
388
 
 
389
        if (data->flags & MMC_DATA_READ) {
 
390
                conf.direction = DMA_FROM_DEVICE;
 
391
                chan = host->dma_rx_channel;
 
392
        } else {
 
393
                conf.direction = DMA_TO_DEVICE;
 
394
                chan = host->dma_tx_channel;
 
395
        }
 
396
 
 
397
        /* If there's no DMA channel, fall back to PIO */
 
398
        if (!chan)
 
399
                return -EINVAL;
 
400
 
 
401
        /* If less than or equal to the fifo size, don't bother with DMA */
 
402
        if (data->blksz * data->blocks <= variant->fifosize)
 
403
                return -EINVAL;
 
404
 
 
405
        device = chan->device;
 
406
        nr_sg = dma_map_sg(device->dev, data->sg, data->sg_len, conf.direction);
 
407
        if (nr_sg == 0)
 
408
                return -EINVAL;
 
409
 
 
410
        dmaengine_slave_config(chan, &conf);
 
411
        desc = device->device_prep_slave_sg(chan, data->sg, nr_sg,
 
412
                                            conf.direction, DMA_CTRL_ACK);
 
413
        if (!desc)
 
414
                goto unmap_exit;
 
415
 
 
416
        if (next) {
 
417
                next->dma_chan = chan;
 
418
                next->dma_desc = desc;
 
419
        } else {
 
420
                host->dma_current = chan;
 
421
                host->dma_desc_current = desc;
 
422
        }
 
423
 
 
424
        return 0;
 
425
 
 
426
 unmap_exit:
 
427
        if (!next)
 
428
                dmaengine_terminate_all(chan);
 
429
        dma_unmap_sg(device->dev, data->sg, data->sg_len, conf.direction);
 
430
        return -ENOMEM;
 
431
}
 
432
 
 
433
static int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl)
 
434
{
 
435
        int ret;
 
436
        struct mmc_data *data = host->data;
 
437
 
 
438
        ret = mmci_dma_prep_data(host, host->data, NULL);
 
439
        if (ret)
 
440
                return ret;
 
441
 
 
442
        /* Okay, go for it. */
 
443
        dev_vdbg(mmc_dev(host->mmc),
 
444
                 "Submit MMCI DMA job, sglen %d blksz %04x blks %04x flags %08x\n",
 
445
                 data->sg_len, data->blksz, data->blocks, data->flags);
 
446
        dmaengine_submit(host->dma_desc_current);
 
447
        dma_async_issue_pending(host->dma_current);
 
448
 
 
449
        datactrl |= MCI_DPSM_DMAENABLE;
 
450
 
 
451
        /* Trigger the DMA transfer */
 
452
        writel(datactrl, host->base + MMCIDATACTRL);
 
453
 
 
454
        /*
 
455
         * Let the MMCI say when the data is ended and it's time
 
456
         * to fire next DMA request. When that happens, MMCI will
 
457
         * call mmci_data_end()
 
458
         */
 
459
        writel(readl(host->base + MMCIMASK0) | MCI_DATAENDMASK,
 
460
               host->base + MMCIMASK0);
 
461
        return 0;
 
462
}
 
463
 
 
464
static void mmci_get_next_data(struct mmci_host *host, struct mmc_data *data)
 
465
{
 
466
        struct mmci_host_next *next = &host->next_data;
 
467
 
 
468
        if (data->host_cookie && data->host_cookie != next->cookie) {
 
469
                pr_warning("[%s] invalid cookie: data->host_cookie %d"
 
470
                       " host->next_data.cookie %d\n",
 
471
                       __func__, data->host_cookie, host->next_data.cookie);
 
472
                data->host_cookie = 0;
 
473
        }
 
474
 
 
475
        if (!data->host_cookie)
 
476
                return;
 
477
 
 
478
        host->dma_desc_current = next->dma_desc;
 
479
        host->dma_current = next->dma_chan;
 
480
 
 
481
        next->dma_desc = NULL;
 
482
        next->dma_chan = NULL;
 
483
}
 
484
 
 
485
static void mmci_pre_request(struct mmc_host *mmc, struct mmc_request *mrq,
 
486
                             bool is_first_req)
 
487
{
 
488
        struct mmci_host *host = mmc_priv(mmc);
 
489
        struct mmc_data *data = mrq->data;
 
490
        struct mmci_host_next *nd = &host->next_data;
 
491
 
 
492
        if (!data)
 
493
                return;
 
494
 
 
495
        if (data->host_cookie) {
 
496
                data->host_cookie = 0;
 
497
                return;
 
498
        }
 
499
 
 
500
        /* if config for dma */
 
501
        if (((data->flags & MMC_DATA_WRITE) && host->dma_tx_channel) ||
 
502
            ((data->flags & MMC_DATA_READ) && host->dma_rx_channel)) {
 
503
                if (mmci_dma_prep_data(host, data, nd))
 
504
                        data->host_cookie = 0;
 
505
                else
 
506
                        data->host_cookie = ++nd->cookie < 0 ? 1 : nd->cookie;
 
507
        }
 
508
}
 
509
 
 
510
static void mmci_post_request(struct mmc_host *mmc, struct mmc_request *mrq,
 
511
                              int err)
 
512
{
 
513
        struct mmci_host *host = mmc_priv(mmc);
 
514
        struct mmc_data *data = mrq->data;
 
515
        struct dma_chan *chan;
 
516
        enum dma_data_direction dir;
 
517
 
 
518
        if (!data)
 
519
                return;
 
520
 
 
521
        if (data->flags & MMC_DATA_READ) {
 
522
                dir = DMA_FROM_DEVICE;
 
523
                chan = host->dma_rx_channel;
 
524
        } else {
 
525
                dir = DMA_TO_DEVICE;
 
526
                chan = host->dma_tx_channel;
 
527
        }
 
528
 
 
529
 
 
530
        /* if config for dma */
 
531
        if (chan) {
 
532
                if (err)
 
533
                        dmaengine_terminate_all(chan);
 
534
                if (data->host_cookie)
 
535
                        dma_unmap_sg(mmc_dev(host->mmc), data->sg,
 
536
                                     data->sg_len, dir);
 
537
                mrq->data->host_cookie = 0;
 
538
        }
 
539
}
 
540
 
 
541
#else
 
542
/* Blank functions if the DMA engine is not available */
 
543
static void mmci_get_next_data(struct mmci_host *host, struct mmc_data *data)
 
544
{
 
545
}
 
546
static inline void mmci_dma_setup(struct mmci_host *host)
 
547
{
 
548
}
 
549
 
 
550
static inline void mmci_dma_release(struct mmci_host *host)
 
551
{
 
552
}
 
553
 
 
554
static inline void mmci_dma_unmap(struct mmci_host *host, struct mmc_data *data)
 
555
{
 
556
}
 
557
 
 
558
static inline void mmci_dma_data_error(struct mmci_host *host)
 
559
{
 
560
}
 
561
 
 
562
static inline int mmci_dma_start_data(struct mmci_host *host, unsigned int datactrl)
 
563
{
 
564
        return -ENOSYS;
 
565
}
 
566
 
 
567
#define mmci_pre_request NULL
 
568
#define mmci_post_request NULL
 
569
 
 
570
#endif
 
571
 
 
572
static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
 
573
{
 
574
        struct variant_data *variant = host->variant;
 
575
        unsigned int datactrl, timeout, irqmask;
 
576
        unsigned long long clks;
 
577
        void __iomem *base;
 
578
        int blksz_bits;
 
579
 
 
580
        dev_dbg(mmc_dev(host->mmc), "blksz %04x blks %04x flags %08x\n",
 
581
                data->blksz, data->blocks, data->flags);
 
582
 
 
583
        host->data = data;
 
584
        host->size = data->blksz * data->blocks;
 
585
        data->bytes_xfered = 0;
 
586
 
 
587
        clks = (unsigned long long)data->timeout_ns * host->cclk;
 
588
        do_div(clks, 1000000000UL);
 
589
 
 
590
        timeout = data->timeout_clks + (unsigned int)clks;
 
591
 
 
592
        base = host->base;
 
593
        writel(timeout, base + MMCIDATATIMER);
 
594
        writel(host->size, base + MMCIDATALENGTH);
 
595
 
 
596
        blksz_bits = ffs(data->blksz) - 1;
 
597
        BUG_ON(1 << blksz_bits != data->blksz);
 
598
 
 
599
        if (variant->blksz_datactrl16)
 
600
                datactrl = MCI_DPSM_ENABLE | (data->blksz << 16);
 
601
        else
 
602
                datactrl = MCI_DPSM_ENABLE | blksz_bits << 4;
 
603
 
 
604
        if (data->flags & MMC_DATA_READ)
 
605
                datactrl |= MCI_DPSM_DIRECTION;
 
606
 
 
607
        /*
 
608
         * Attempt to use DMA operation mode, if this
 
609
         * should fail, fall back to PIO mode
 
610
         */
 
611
        if (!mmci_dma_start_data(host, datactrl))
 
612
                return;
 
613
 
 
614
        /* IRQ mode, map the SG list for CPU reading/writing */
 
615
        mmci_init_sg(host, data);
 
616
 
 
617
        if (data->flags & MMC_DATA_READ) {
 
618
                irqmask = MCI_RXFIFOHALFFULLMASK;
 
619
 
 
620
                /*
 
621
                 * If we have less than the fifo 'half-full' threshold to
 
622
                 * transfer, trigger a PIO interrupt as soon as any data
 
623
                 * is available.
 
624
                 */
 
625
                if (host->size < variant->fifohalfsize)
 
626
                        irqmask |= MCI_RXDATAAVLBLMASK;
 
627
        } else {
 
628
                /*
 
629
                 * We don't actually need to include "FIFO empty" here
 
630
                 * since its implicit in "FIFO half empty".
 
631
                 */
 
632
                irqmask = MCI_TXFIFOHALFEMPTYMASK;
 
633
        }
 
634
 
 
635
        /* The ST Micro variants has a special bit to enable SDIO */
 
636
        if (variant->sdio && host->mmc->card)
 
637
                if (mmc_card_sdio(host->mmc->card))
 
638
                        datactrl |= MCI_ST_DPSM_SDIOEN;
 
639
 
 
640
        writel(datactrl, base + MMCIDATACTRL);
 
641
        writel(readl(base + MMCIMASK0) & ~MCI_DATAENDMASK, base + MMCIMASK0);
 
642
        mmci_set_mask1(host, irqmask);
 
643
}
 
644
 
 
645
static void
 
646
mmci_start_command(struct mmci_host *host, struct mmc_command *cmd, u32 c)
 
647
{
 
648
        void __iomem *base = host->base;
 
649
 
 
650
        dev_dbg(mmc_dev(host->mmc), "op %02x arg %08x flags %08x\n",
 
651
            cmd->opcode, cmd->arg, cmd->flags);
 
652
 
 
653
        if (readl(base + MMCICOMMAND) & MCI_CPSM_ENABLE) {
 
654
                writel(0, base + MMCICOMMAND);
 
655
                udelay(1);
 
656
        }
 
657
 
 
658
        c |= cmd->opcode | MCI_CPSM_ENABLE;
 
659
        if (cmd->flags & MMC_RSP_PRESENT) {
 
660
                if (cmd->flags & MMC_RSP_136)
 
661
                        c |= MCI_CPSM_LONGRSP;
 
662
                c |= MCI_CPSM_RESPONSE;
 
663
        }
 
664
        if (/*interrupt*/0)
 
665
                c |= MCI_CPSM_INTERRUPT;
 
666
 
 
667
        host->cmd = cmd;
 
668
 
 
669
        writel(cmd->arg, base + MMCIARGUMENT);
 
670
        writel(c, base + MMCICOMMAND);
 
671
}
 
672
 
 
673
static void
 
674
mmci_data_irq(struct mmci_host *host, struct mmc_data *data,
 
675
              unsigned int status)
 
676
{
 
677
        /* First check for errors */
 
678
        if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_STARTBITERR|
 
679
                      MCI_TXUNDERRUN|MCI_RXOVERRUN)) {
 
680
                u32 remain, success;
 
681
 
 
682
                /* Terminate the DMA transfer */
 
683
                if (dma_inprogress(host))
 
684
                        mmci_dma_data_error(host);
 
685
 
 
686
                /*
 
687
                 * Calculate how far we are into the transfer.  Note that
 
688
                 * the data counter gives the number of bytes transferred
 
689
                 * on the MMC bus, not on the host side.  On reads, this
 
690
                 * can be as much as a FIFO-worth of data ahead.  This
 
691
                 * matters for FIFO overruns only.
 
692
                 */
 
693
                remain = readl(host->base + MMCIDATACNT);
 
694
                success = data->blksz * data->blocks - remain;
 
695
 
 
696
                dev_dbg(mmc_dev(host->mmc), "MCI ERROR IRQ, status 0x%08x at 0x%08x\n",
 
697
                        status, success);
 
698
                if (status & MCI_DATACRCFAIL) {
 
699
                        /* Last block was not successful */
 
700
                        success -= 1;
 
701
                        data->error = -EILSEQ;
 
702
                } else if (status & MCI_DATATIMEOUT) {
 
703
                        data->error = -ETIMEDOUT;
 
704
                } else if (status & MCI_STARTBITERR) {
 
705
                        data->error = -ECOMM;
 
706
                } else if (status & MCI_TXUNDERRUN) {
 
707
                        data->error = -EIO;
 
708
                } else if (status & MCI_RXOVERRUN) {
 
709
                        if (success > host->variant->fifosize)
 
710
                                success -= host->variant->fifosize;
 
711
                        else
 
712
                                success = 0;
 
713
                        data->error = -EIO;
 
714
                }
 
715
                data->bytes_xfered = round_down(success, data->blksz);
 
716
        }
 
717
 
 
718
        if (status & MCI_DATABLOCKEND)
 
719
                dev_err(mmc_dev(host->mmc), "stray MCI_DATABLOCKEND interrupt\n");
 
720
 
 
721
        if (status & MCI_DATAEND || data->error) {
 
722
                if (dma_inprogress(host))
 
723
                        mmci_dma_unmap(host, data);
 
724
                mmci_stop_data(host);
 
725
 
 
726
                if (!data->error)
 
727
                        /* The error clause is handled above, success! */
 
728
                        data->bytes_xfered = data->blksz * data->blocks;
 
729
 
 
730
                if (!data->stop) {
 
731
                        mmci_request_end(host, data->mrq);
 
732
                } else {
 
733
                        mmci_start_command(host, data->stop, 0);
 
734
                }
 
735
        }
 
736
}
 
737
 
 
738
static void
 
739
mmci_cmd_irq(struct mmci_host *host, struct mmc_command *cmd,
 
740
             unsigned int status)
 
741
{
 
742
        void __iomem *base = host->base;
 
743
 
 
744
        host->cmd = NULL;
 
745
 
 
746
        if (status & MCI_CMDTIMEOUT) {
 
747
                cmd->error = -ETIMEDOUT;
 
748
        } else if (status & MCI_CMDCRCFAIL && cmd->flags & MMC_RSP_CRC) {
 
749
                cmd->error = -EILSEQ;
 
750
        } else {
 
751
                cmd->resp[0] = readl(base + MMCIRESPONSE0);
 
752
                cmd->resp[1] = readl(base + MMCIRESPONSE1);
 
753
                cmd->resp[2] = readl(base + MMCIRESPONSE2);
 
754
                cmd->resp[3] = readl(base + MMCIRESPONSE3);
 
755
        }
 
756
 
 
757
        if (!cmd->data || cmd->error) {
 
758
                if (host->data) {
 
759
                        /* Terminate the DMA transfer */
 
760
                        if (dma_inprogress(host))
 
761
                                mmci_dma_data_error(host);
 
762
                        mmci_stop_data(host);
 
763
                }
 
764
                mmci_request_end(host, cmd->mrq);
 
765
        } else if (!(cmd->data->flags & MMC_DATA_READ)) {
 
766
                mmci_start_data(host, cmd->data);
 
767
        }
 
768
}
 
769
 
 
770
static int mmci_pio_read(struct mmci_host *host, char *buffer, unsigned int remain)
 
771
{
 
772
        void __iomem *base = host->base;
 
773
        char *ptr = buffer;
 
774
        u32 status;
 
775
        int host_remain = host->size;
 
776
 
 
777
        do {
 
778
                int count = host_remain - (readl(base + MMCIFIFOCNT) << 2);
 
779
 
 
780
                if (count > remain)
 
781
                        count = remain;
 
782
 
 
783
                if (count <= 0)
 
784
                        break;
 
785
 
 
786
                readsl(base + MMCIFIFO, ptr, count >> 2);
 
787
 
 
788
                ptr += count;
 
789
                remain -= count;
 
790
                host_remain -= count;
 
791
 
 
792
                if (remain == 0)
 
793
                        break;
 
794
 
 
795
                status = readl(base + MMCISTATUS);
 
796
        } while (status & MCI_RXDATAAVLBL);
 
797
 
 
798
        return ptr - buffer;
 
799
}
 
800
 
 
801
static int mmci_pio_write(struct mmci_host *host, char *buffer, unsigned int remain, u32 status)
 
802
{
 
803
        struct variant_data *variant = host->variant;
 
804
        void __iomem *base = host->base;
 
805
        char *ptr = buffer;
 
806
 
 
807
        do {
 
808
                unsigned int count, maxcnt;
 
809
 
 
810
                maxcnt = status & MCI_TXFIFOEMPTY ?
 
811
                         variant->fifosize : variant->fifohalfsize;
 
812
                count = min(remain, maxcnt);
 
813
 
 
814
                /*
 
815
                 * The ST Micro variant for SDIO transfer sizes
 
816
                 * less then 8 bytes should have clock H/W flow
 
817
                 * control disabled.
 
818
                 */
 
819
                if (variant->sdio &&
 
820
                    mmc_card_sdio(host->mmc->card)) {
 
821
                        if (count < 8)
 
822
                                writel(readl(host->base + MMCICLOCK) &
 
823
                                        ~variant->clkreg_enable,
 
824
                                        host->base + MMCICLOCK);
 
825
                        else
 
826
                                writel(readl(host->base + MMCICLOCK) |
 
827
                                        variant->clkreg_enable,
 
828
                                        host->base + MMCICLOCK);
 
829
                }
 
830
 
 
831
                /*
 
832
                 * SDIO especially may want to send something that is
 
833
                 * not divisible by 4 (as opposed to card sectors
 
834
                 * etc), and the FIFO only accept full 32-bit writes.
 
835
                 * So compensate by adding +3 on the count, a single
 
836
                 * byte become a 32bit write, 7 bytes will be two
 
837
                 * 32bit writes etc.
 
838
                 */
 
839
                writesl(base + MMCIFIFO, ptr, (count + 3) >> 2);
 
840
 
 
841
                ptr += count;
 
842
                remain -= count;
 
843
 
 
844
                if (remain == 0)
 
845
                        break;
 
846
 
 
847
                status = readl(base + MMCISTATUS);
 
848
        } while (status & MCI_TXFIFOHALFEMPTY);
 
849
 
 
850
        return ptr - buffer;
 
851
}
 
852
 
 
853
/*
 
854
 * PIO data transfer IRQ handler.
 
855
 */
 
856
static irqreturn_t mmci_pio_irq(int irq, void *dev_id)
 
857
{
 
858
        struct mmci_host *host = dev_id;
 
859
        struct sg_mapping_iter *sg_miter = &host->sg_miter;
 
860
        struct variant_data *variant = host->variant;
 
861
        void __iomem *base = host->base;
 
862
        unsigned long flags;
 
863
        u32 status;
 
864
 
 
865
        status = readl(base + MMCISTATUS);
 
866
 
 
867
        dev_dbg(mmc_dev(host->mmc), "irq1 (pio) %08x\n", status);
 
868
 
 
869
        local_irq_save(flags);
 
870
 
 
871
        do {
 
872
                unsigned int remain, len;
 
873
                char *buffer;
 
874
 
 
875
                /*
 
876
                 * For write, we only need to test the half-empty flag
 
877
                 * here - if the FIFO is completely empty, then by
 
878
                 * definition it is more than half empty.
 
879
                 *
 
880
                 * For read, check for data available.
 
881
                 */
 
882
                if (!(status & (MCI_TXFIFOHALFEMPTY|MCI_RXDATAAVLBL)))
 
883
                        break;
 
884
 
 
885
                if (!sg_miter_next(sg_miter))
 
886
                        break;
 
887
 
 
888
                buffer = sg_miter->addr;
 
889
                remain = sg_miter->length;
 
890
 
 
891
                len = 0;
 
892
                if (status & MCI_RXACTIVE)
 
893
                        len = mmci_pio_read(host, buffer, remain);
 
894
                if (status & MCI_TXACTIVE)
 
895
                        len = mmci_pio_write(host, buffer, remain, status);
 
896
 
 
897
                sg_miter->consumed = len;
 
898
 
 
899
                host->size -= len;
 
900
                remain -= len;
 
901
 
 
902
                if (remain)
 
903
                        break;
 
904
 
 
905
                status = readl(base + MMCISTATUS);
 
906
        } while (1);
 
907
 
 
908
        sg_miter_stop(sg_miter);
 
909
 
 
910
        local_irq_restore(flags);
 
911
 
 
912
        /*
 
913
         * If we have less than the fifo 'half-full' threshold to transfer,
 
914
         * trigger a PIO interrupt as soon as any data is available.
 
915
         */
 
916
        if (status & MCI_RXACTIVE && host->size < variant->fifohalfsize)
 
917
                mmci_set_mask1(host, MCI_RXDATAAVLBLMASK);
 
918
 
 
919
        /*
 
920
         * If we run out of data, disable the data IRQs; this
 
921
         * prevents a race where the FIFO becomes empty before
 
922
         * the chip itself has disabled the data path, and
 
923
         * stops us racing with our data end IRQ.
 
924
         */
 
925
        if (host->size == 0) {
 
926
                mmci_set_mask1(host, 0);
 
927
                writel(readl(base + MMCIMASK0) | MCI_DATAENDMASK, base + MMCIMASK0);
 
928
        }
 
929
 
 
930
        return IRQ_HANDLED;
 
931
}
 
932
 
 
933
/*
 
934
 * Handle completion of command and data transfers.
 
935
 */
 
936
static irqreturn_t mmci_irq(int irq, void *dev_id)
 
937
{
 
938
        struct mmci_host *host = dev_id;
 
939
        u32 status;
 
940
        int ret = 0;
 
941
 
 
942
        spin_lock(&host->lock);
 
943
 
 
944
        do {
 
945
                struct mmc_command *cmd;
 
946
                struct mmc_data *data;
 
947
 
 
948
                status = readl(host->base + MMCISTATUS);
 
949
 
 
950
                if (host->singleirq) {
 
951
                        if (status & readl(host->base + MMCIMASK1))
 
952
                                mmci_pio_irq(irq, dev_id);
 
953
 
 
954
                        status &= ~MCI_IRQ1MASK;
 
955
                }
 
956
 
 
957
                status &= readl(host->base + MMCIMASK0);
 
958
                writel(status, host->base + MMCICLEAR);
 
959
 
 
960
                dev_dbg(mmc_dev(host->mmc), "irq0 (data+cmd) %08x\n", status);
 
961
 
 
962
                data = host->data;
 
963
                if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_STARTBITERR|
 
964
                              MCI_TXUNDERRUN|MCI_RXOVERRUN|MCI_DATAEND|
 
965
                              MCI_DATABLOCKEND) && data)
 
966
                        mmci_data_irq(host, data, status);
 
967
 
 
968
                cmd = host->cmd;
 
969
                if (status & (MCI_CMDCRCFAIL|MCI_CMDTIMEOUT|MCI_CMDSENT|MCI_CMDRESPEND) && cmd)
 
970
                        mmci_cmd_irq(host, cmd, status);
 
971
 
 
972
                ret = 1;
 
973
        } while (status);
 
974
 
 
975
        spin_unlock(&host->lock);
 
976
 
 
977
        return IRQ_RETVAL(ret);
 
978
}
 
979
 
 
980
static void mmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 
981
{
 
982
        struct mmci_host *host = mmc_priv(mmc);
 
983
        unsigned long flags;
 
984
 
 
985
        WARN_ON(host->mrq != NULL);
 
986
 
 
987
        if (mrq->data && !is_power_of_2(mrq->data->blksz)) {
 
988
                dev_err(mmc_dev(mmc), "unsupported block size (%d bytes)\n",
 
989
                        mrq->data->blksz);
 
990
                mrq->cmd->error = -EINVAL;
 
991
                mmc_request_done(mmc, mrq);
 
992
                return;
 
993
        }
 
994
 
 
995
        pm_runtime_get_sync(mmc_dev(mmc));
 
996
 
 
997
        spin_lock_irqsave(&host->lock, flags);
 
998
 
 
999
        host->mrq = mrq;
 
1000
 
 
1001
        if (mrq->data)
 
1002
                mmci_get_next_data(host, mrq->data);
 
1003
 
 
1004
        if (mrq->data && mrq->data->flags & MMC_DATA_READ)
 
1005
                mmci_start_data(host, mrq->data);
 
1006
 
 
1007
        mmci_start_command(host, mrq->cmd, 0);
 
1008
 
 
1009
        spin_unlock_irqrestore(&host->lock, flags);
 
1010
}
 
1011
 
 
1012
static void mmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
1013
{
 
1014
        struct mmci_host *host = mmc_priv(mmc);
 
1015
        u32 pwr = 0;
 
1016
        unsigned long flags;
 
1017
        int ret;
 
1018
 
 
1019
        switch (ios->power_mode) {
 
1020
        case MMC_POWER_OFF:
 
1021
                if (host->vcc)
 
1022
                        ret = mmc_regulator_set_ocr(mmc, host->vcc, 0);
 
1023
                break;
 
1024
        case MMC_POWER_UP:
 
1025
                if (host->vcc) {
 
1026
                        ret = mmc_regulator_set_ocr(mmc, host->vcc, ios->vdd);
 
1027
                        if (ret) {
 
1028
                                dev_err(mmc_dev(mmc), "unable to set OCR\n");
 
1029
                                /*
 
1030
                                 * The .set_ios() function in the mmc_host_ops
 
1031
                                 * struct return void, and failing to set the
 
1032
                                 * power should be rare so we print an error
 
1033
                                 * and return here.
 
1034
                                 */
 
1035
                                return;
 
1036
                        }
 
1037
                }
 
1038
                if (host->plat->vdd_handler)
 
1039
                        pwr |= host->plat->vdd_handler(mmc_dev(mmc), ios->vdd,
 
1040
                                                       ios->power_mode);
 
1041
                /* The ST version does not have this, fall through to POWER_ON */
 
1042
                if (host->hw_designer != AMBA_VENDOR_ST) {
 
1043
                        pwr |= MCI_PWR_UP;
 
1044
                        break;
 
1045
                }
 
1046
        case MMC_POWER_ON:
 
1047
                pwr |= MCI_PWR_ON;
 
1048
                break;
 
1049
        }
 
1050
 
 
1051
        if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN) {
 
1052
                if (host->hw_designer != AMBA_VENDOR_ST)
 
1053
                        pwr |= MCI_ROD;
 
1054
                else {
 
1055
                        /*
 
1056
                         * The ST Micro variant use the ROD bit for something
 
1057
                         * else and only has OD (Open Drain).
 
1058
                         */
 
1059
                        pwr |= MCI_OD;
 
1060
                }
 
1061
        }
 
1062
 
 
1063
        spin_lock_irqsave(&host->lock, flags);
 
1064
 
 
1065
        mmci_set_clkreg(host, ios->clock);
 
1066
 
 
1067
        if (host->pwr != pwr) {
 
1068
                host->pwr = pwr;
 
1069
                writel(pwr, host->base + MMCIPOWER);
 
1070
        }
 
1071
 
 
1072
        spin_unlock_irqrestore(&host->lock, flags);
 
1073
}
 
1074
 
 
1075
static int mmci_get_ro(struct mmc_host *mmc)
 
1076
{
 
1077
        struct mmci_host *host = mmc_priv(mmc);
 
1078
 
 
1079
        if (host->gpio_wp == -ENOSYS)
 
1080
                return -ENOSYS;
 
1081
 
 
1082
        return gpio_get_value_cansleep(host->gpio_wp);
 
1083
}
 
1084
 
 
1085
static int mmci_get_cd(struct mmc_host *mmc)
 
1086
{
 
1087
        struct mmci_host *host = mmc_priv(mmc);
 
1088
        struct mmci_platform_data *plat = host->plat;
 
1089
        unsigned int status;
 
1090
 
 
1091
        if (host->gpio_cd == -ENOSYS) {
 
1092
                if (!plat->status)
 
1093
                        return 1; /* Assume always present */
 
1094
 
 
1095
                status = plat->status(mmc_dev(host->mmc));
 
1096
        } else
 
1097
                status = !!gpio_get_value_cansleep(host->gpio_cd)
 
1098
                        ^ plat->cd_invert;
 
1099
 
 
1100
        /*
 
1101
         * Use positive logic throughout - status is zero for no card,
 
1102
         * non-zero for card inserted.
 
1103
         */
 
1104
        return status;
 
1105
}
 
1106
 
 
1107
static irqreturn_t mmci_cd_irq(int irq, void *dev_id)
 
1108
{
 
1109
        struct mmci_host *host = dev_id;
 
1110
 
 
1111
        mmc_detect_change(host->mmc, msecs_to_jiffies(500));
 
1112
 
 
1113
        return IRQ_HANDLED;
 
1114
}
 
1115
 
 
1116
static const struct mmc_host_ops mmci_ops = {
 
1117
        .request        = mmci_request,
 
1118
        .pre_req        = mmci_pre_request,
 
1119
        .post_req       = mmci_post_request,
 
1120
        .set_ios        = mmci_set_ios,
 
1121
        .get_ro         = mmci_get_ro,
 
1122
        .get_cd         = mmci_get_cd,
 
1123
};
 
1124
 
 
1125
static int __devinit mmci_probe(struct amba_device *dev,
 
1126
        const struct amba_id *id)
 
1127
{
 
1128
        struct mmci_platform_data *plat = dev->dev.platform_data;
 
1129
        struct variant_data *variant = id->data;
 
1130
        struct mmci_host *host;
 
1131
        struct mmc_host *mmc;
 
1132
        int ret;
 
1133
 
 
1134
        /* must have platform data */
 
1135
        if (!plat) {
 
1136
                ret = -EINVAL;
 
1137
                goto out;
 
1138
        }
 
1139
 
 
1140
        ret = amba_request_regions(dev, DRIVER_NAME);
 
1141
        if (ret)
 
1142
                goto out;
 
1143
 
 
1144
        mmc = mmc_alloc_host(sizeof(struct mmci_host), &dev->dev);
 
1145
        if (!mmc) {
 
1146
                ret = -ENOMEM;
 
1147
                goto rel_regions;
 
1148
        }
 
1149
 
 
1150
        host = mmc_priv(mmc);
 
1151
        host->mmc = mmc;
 
1152
 
 
1153
        host->gpio_wp = -ENOSYS;
 
1154
        host->gpio_cd = -ENOSYS;
 
1155
        host->gpio_cd_irq = -1;
 
1156
 
 
1157
        host->hw_designer = amba_manf(dev);
 
1158
        host->hw_revision = amba_rev(dev);
 
1159
        dev_dbg(mmc_dev(mmc), "designer ID = 0x%02x\n", host->hw_designer);
 
1160
        dev_dbg(mmc_dev(mmc), "revision = 0x%01x\n", host->hw_revision);
 
1161
 
 
1162
        host->clk = clk_get(&dev->dev, NULL);
 
1163
        if (IS_ERR(host->clk)) {
 
1164
                ret = PTR_ERR(host->clk);
 
1165
                host->clk = NULL;
 
1166
                goto host_free;
 
1167
        }
 
1168
 
 
1169
        ret = clk_prepare(host->clk);
 
1170
        if (ret)
 
1171
                goto clk_free;
 
1172
 
 
1173
        ret = clk_enable(host->clk);
 
1174
        if (ret)
 
1175
                goto clk_unprep;
 
1176
 
 
1177
        host->plat = plat;
 
1178
        host->variant = variant;
 
1179
        host->mclk = clk_get_rate(host->clk);
 
1180
        /*
 
1181
         * According to the spec, mclk is max 100 MHz,
 
1182
         * so we try to adjust the clock down to this,
 
1183
         * (if possible).
 
1184
         */
 
1185
        if (host->mclk > 100000000) {
 
1186
                ret = clk_set_rate(host->clk, 100000000);
 
1187
                if (ret < 0)
 
1188
                        goto clk_disable;
 
1189
                host->mclk = clk_get_rate(host->clk);
 
1190
                dev_dbg(mmc_dev(mmc), "eventual mclk rate: %u Hz\n",
 
1191
                        host->mclk);
 
1192
        }
 
1193
        host->phybase = dev->res.start;
 
1194
        host->base = ioremap(dev->res.start, resource_size(&dev->res));
 
1195
        if (!host->base) {
 
1196
                ret = -ENOMEM;
 
1197
                goto clk_disable;
 
1198
        }
 
1199
 
 
1200
        mmc->ops = &mmci_ops;
 
1201
        /*
 
1202
         * The ARM and ST versions of the block have slightly different
 
1203
         * clock divider equations which means that the minimum divider
 
1204
         * differs too.
 
1205
         */
 
1206
        if (variant->st_clkdiv)
 
1207
                mmc->f_min = DIV_ROUND_UP(host->mclk, 257);
 
1208
        else
 
1209
                mmc->f_min = DIV_ROUND_UP(host->mclk, 512);
 
1210
        /*
 
1211
         * If the platform data supplies a maximum operating
 
1212
         * frequency, this takes precedence. Else, we fall back
 
1213
         * to using the module parameter, which has a (low)
 
1214
         * default value in case it is not specified. Either
 
1215
         * value must not exceed the clock rate into the block,
 
1216
         * of course.
 
1217
         */
 
1218
        if (plat->f_max)
 
1219
                mmc->f_max = min(host->mclk, plat->f_max);
 
1220
        else
 
1221
                mmc->f_max = min(host->mclk, fmax);
 
1222
        dev_dbg(mmc_dev(mmc), "clocking block at %u Hz\n", mmc->f_max);
 
1223
 
 
1224
#ifdef CONFIG_REGULATOR
 
1225
        /* If we're using the regulator framework, try to fetch a regulator */
 
1226
        host->vcc = regulator_get(&dev->dev, "vmmc");
 
1227
        if (IS_ERR(host->vcc))
 
1228
                host->vcc = NULL;
 
1229
        else {
 
1230
                int mask = mmc_regulator_get_ocrmask(host->vcc);
 
1231
 
 
1232
                if (mask < 0)
 
1233
                        dev_err(&dev->dev, "error getting OCR mask (%d)\n",
 
1234
                                mask);
 
1235
                else {
 
1236
                        host->mmc->ocr_avail = (u32) mask;
 
1237
                        if (plat->ocr_mask)
 
1238
                                dev_warn(&dev->dev,
 
1239
                                 "Provided ocr_mask/setpower will not be used "
 
1240
                                 "(using regulator instead)\n");
 
1241
                }
 
1242
        }
 
1243
#endif
 
1244
        /* Fall back to platform data if no regulator is found */
 
1245
        if (host->vcc == NULL)
 
1246
                mmc->ocr_avail = plat->ocr_mask;
 
1247
        mmc->caps = plat->capabilities;
 
1248
 
 
1249
        /*
 
1250
         * We can do SGIO
 
1251
         */
 
1252
        mmc->max_segs = NR_SG;
 
1253
 
 
1254
        /*
 
1255
         * Since only a certain number of bits are valid in the data length
 
1256
         * register, we must ensure that we don't exceed 2^num-1 bytes in a
 
1257
         * single request.
 
1258
         */
 
1259
        mmc->max_req_size = (1 << variant->datalength_bits) - 1;
 
1260
 
 
1261
        /*
 
1262
         * Set the maximum segment size.  Since we aren't doing DMA
 
1263
         * (yet) we are only limited by the data length register.
 
1264
         */
 
1265
        mmc->max_seg_size = mmc->max_req_size;
 
1266
 
 
1267
        /*
 
1268
         * Block size can be up to 2048 bytes, but must be a power of two.
 
1269
         */
 
1270
        mmc->max_blk_size = 2048;
 
1271
 
 
1272
        /*
 
1273
         * No limit on the number of blocks transferred.
 
1274
         */
 
1275
        mmc->max_blk_count = mmc->max_req_size;
 
1276
 
 
1277
        spin_lock_init(&host->lock);
 
1278
 
 
1279
        writel(0, host->base + MMCIMASK0);
 
1280
        writel(0, host->base + MMCIMASK1);
 
1281
        writel(0xfff, host->base + MMCICLEAR);
 
1282
 
 
1283
        if (gpio_is_valid(plat->gpio_cd)) {
 
1284
                ret = gpio_request(plat->gpio_cd, DRIVER_NAME " (cd)");
 
1285
                if (ret == 0)
 
1286
                        ret = gpio_direction_input(plat->gpio_cd);
 
1287
                if (ret == 0)
 
1288
                        host->gpio_cd = plat->gpio_cd;
 
1289
                else if (ret != -ENOSYS)
 
1290
                        goto err_gpio_cd;
 
1291
 
 
1292
                /*
 
1293
                 * A gpio pin that will detect cards when inserted and removed
 
1294
                 * will most likely want to trigger on the edges if it is
 
1295
                 * 0 when ejected and 1 when inserted (or mutatis mutandis
 
1296
                 * for the inverted case) so we request triggers on both
 
1297
                 * edges.
 
1298
                 */
 
1299
                ret = request_any_context_irq(gpio_to_irq(plat->gpio_cd),
 
1300
                                mmci_cd_irq,
 
1301
                                IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
 
1302
                                DRIVER_NAME " (cd)", host);
 
1303
                if (ret >= 0)
 
1304
                        host->gpio_cd_irq = gpio_to_irq(plat->gpio_cd);
 
1305
        }
 
1306
        if (gpio_is_valid(plat->gpio_wp)) {
 
1307
                ret = gpio_request(plat->gpio_wp, DRIVER_NAME " (wp)");
 
1308
                if (ret == 0)
 
1309
                        ret = gpio_direction_input(plat->gpio_wp);
 
1310
                if (ret == 0)
 
1311
                        host->gpio_wp = plat->gpio_wp;
 
1312
                else if (ret != -ENOSYS)
 
1313
                        goto err_gpio_wp;
 
1314
        }
 
1315
 
 
1316
        if ((host->plat->status || host->gpio_cd != -ENOSYS)
 
1317
            && host->gpio_cd_irq < 0)
 
1318
                mmc->caps |= MMC_CAP_NEEDS_POLL;
 
1319
 
 
1320
        ret = request_irq(dev->irq[0], mmci_irq, IRQF_SHARED, DRIVER_NAME " (cmd)", host);
 
1321
        if (ret)
 
1322
                goto unmap;
 
1323
 
 
1324
        if (dev->irq[1] == NO_IRQ)
 
1325
                host->singleirq = true;
 
1326
        else {
 
1327
                ret = request_irq(dev->irq[1], mmci_pio_irq, IRQF_SHARED,
 
1328
                                  DRIVER_NAME " (pio)", host);
 
1329
                if (ret)
 
1330
                        goto irq0_free;
 
1331
        }
 
1332
 
 
1333
        writel(MCI_IRQENABLE, host->base + MMCIMASK0);
 
1334
 
 
1335
        amba_set_drvdata(dev, mmc);
 
1336
 
 
1337
        dev_info(&dev->dev, "%s: PL%03x manf %x rev%u at 0x%08llx irq %d,%d (pio)\n",
 
1338
                 mmc_hostname(mmc), amba_part(dev), amba_manf(dev),
 
1339
                 amba_rev(dev), (unsigned long long)dev->res.start,
 
1340
                 dev->irq[0], dev->irq[1]);
 
1341
 
 
1342
        mmci_dma_setup(host);
 
1343
 
 
1344
        pm_runtime_put(&dev->dev);
 
1345
 
 
1346
        mmc_add_host(mmc);
 
1347
 
 
1348
        return 0;
 
1349
 
 
1350
 irq0_free:
 
1351
        free_irq(dev->irq[0], host);
 
1352
 unmap:
 
1353
        if (host->gpio_wp != -ENOSYS)
 
1354
                gpio_free(host->gpio_wp);
 
1355
 err_gpio_wp:
 
1356
        if (host->gpio_cd_irq >= 0)
 
1357
                free_irq(host->gpio_cd_irq, host);
 
1358
        if (host->gpio_cd != -ENOSYS)
 
1359
                gpio_free(host->gpio_cd);
 
1360
 err_gpio_cd:
 
1361
        iounmap(host->base);
 
1362
 clk_disable:
 
1363
        clk_disable(host->clk);
 
1364
 clk_unprep:
 
1365
        clk_unprepare(host->clk);
 
1366
 clk_free:
 
1367
        clk_put(host->clk);
 
1368
 host_free:
 
1369
        mmc_free_host(mmc);
 
1370
 rel_regions:
 
1371
        amba_release_regions(dev);
 
1372
 out:
 
1373
        return ret;
 
1374
}
 
1375
 
 
1376
static int __devexit mmci_remove(struct amba_device *dev)
 
1377
{
 
1378
        struct mmc_host *mmc = amba_get_drvdata(dev);
 
1379
 
 
1380
        amba_set_drvdata(dev, NULL);
 
1381
 
 
1382
        if (mmc) {
 
1383
                struct mmci_host *host = mmc_priv(mmc);
 
1384
 
 
1385
                /*
 
1386
                 * Undo pm_runtime_put() in probe.  We use the _sync
 
1387
                 * version here so that we can access the primecell.
 
1388
                 */
 
1389
                pm_runtime_get_sync(&dev->dev);
 
1390
 
 
1391
                mmc_remove_host(mmc);
 
1392
 
 
1393
                writel(0, host->base + MMCIMASK0);
 
1394
                writel(0, host->base + MMCIMASK1);
 
1395
 
 
1396
                writel(0, host->base + MMCICOMMAND);
 
1397
                writel(0, host->base + MMCIDATACTRL);
 
1398
 
 
1399
                mmci_dma_release(host);
 
1400
                free_irq(dev->irq[0], host);
 
1401
                if (!host->singleirq)
 
1402
                        free_irq(dev->irq[1], host);
 
1403
 
 
1404
                if (host->gpio_wp != -ENOSYS)
 
1405
                        gpio_free(host->gpio_wp);
 
1406
                if (host->gpio_cd_irq >= 0)
 
1407
                        free_irq(host->gpio_cd_irq, host);
 
1408
                if (host->gpio_cd != -ENOSYS)
 
1409
                        gpio_free(host->gpio_cd);
 
1410
 
 
1411
                iounmap(host->base);
 
1412
                clk_disable(host->clk);
 
1413
                clk_unprepare(host->clk);
 
1414
                clk_put(host->clk);
 
1415
 
 
1416
                if (host->vcc)
 
1417
                        mmc_regulator_set_ocr(mmc, host->vcc, 0);
 
1418
                regulator_put(host->vcc);
 
1419
 
 
1420
                mmc_free_host(mmc);
 
1421
 
 
1422
                amba_release_regions(dev);
 
1423
        }
 
1424
 
 
1425
        return 0;
 
1426
}
 
1427
 
 
1428
#ifdef CONFIG_PM
 
1429
static int mmci_suspend(struct amba_device *dev, pm_message_t state)
 
1430
{
 
1431
        struct mmc_host *mmc = amba_get_drvdata(dev);
 
1432
        int ret = 0;
 
1433
 
 
1434
        if (mmc) {
 
1435
                struct mmci_host *host = mmc_priv(mmc);
 
1436
 
 
1437
                ret = mmc_suspend_host(mmc);
 
1438
                if (ret == 0)
 
1439
                        writel(0, host->base + MMCIMASK0);
 
1440
        }
 
1441
 
 
1442
        return ret;
 
1443
}
 
1444
 
 
1445
static int mmci_resume(struct amba_device *dev)
 
1446
{
 
1447
        struct mmc_host *mmc = amba_get_drvdata(dev);
 
1448
        int ret = 0;
 
1449
 
 
1450
        if (mmc) {
 
1451
                struct mmci_host *host = mmc_priv(mmc);
 
1452
 
 
1453
                writel(MCI_IRQENABLE, host->base + MMCIMASK0);
 
1454
 
 
1455
                ret = mmc_resume_host(mmc);
 
1456
        }
 
1457
 
 
1458
        return ret;
 
1459
}
 
1460
#else
 
1461
#define mmci_suspend    NULL
 
1462
#define mmci_resume     NULL
 
1463
#endif
 
1464
 
 
1465
static struct amba_id mmci_ids[] = {
 
1466
        {
 
1467
                .id     = 0x00041180,
 
1468
                .mask   = 0xff0fffff,
 
1469
                .data   = &variant_arm,
 
1470
        },
 
1471
        {
 
1472
                .id     = 0x01041180,
 
1473
                .mask   = 0xff0fffff,
 
1474
                .data   = &variant_arm_extended_fifo,
 
1475
        },
 
1476
        {
 
1477
                .id     = 0x00041181,
 
1478
                .mask   = 0x000fffff,
 
1479
                .data   = &variant_arm,
 
1480
        },
 
1481
        /* ST Micro variants */
 
1482
        {
 
1483
                .id     = 0x00180180,
 
1484
                .mask   = 0x00ffffff,
 
1485
                .data   = &variant_u300,
 
1486
        },
 
1487
        {
 
1488
                .id     = 0x00280180,
 
1489
                .mask   = 0x00ffffff,
 
1490
                .data   = &variant_u300,
 
1491
        },
 
1492
        {
 
1493
                .id     = 0x00480180,
 
1494
                .mask   = 0xf0ffffff,
 
1495
                .data   = &variant_ux500,
 
1496
        },
 
1497
        {
 
1498
                .id     = 0x10480180,
 
1499
                .mask   = 0xf0ffffff,
 
1500
                .data   = &variant_ux500v2,
 
1501
        },
 
1502
        { 0, 0 },
 
1503
};
 
1504
 
 
1505
static struct amba_driver mmci_driver = {
 
1506
        .drv            = {
 
1507
                .name   = DRIVER_NAME,
 
1508
        },
 
1509
        .probe          = mmci_probe,
 
1510
        .remove         = __devexit_p(mmci_remove),
 
1511
        .suspend        = mmci_suspend,
 
1512
        .resume         = mmci_resume,
 
1513
        .id_table       = mmci_ids,
 
1514
};
 
1515
 
 
1516
static int __init mmci_init(void)
 
1517
{
 
1518
        return amba_driver_register(&mmci_driver);
 
1519
}
 
1520
 
 
1521
static void __exit mmci_exit(void)
 
1522
{
 
1523
        amba_driver_unregister(&mmci_driver);
 
1524
}
 
1525
 
 
1526
module_init(mmci_init);
 
1527
module_exit(mmci_exit);
 
1528
module_param(fmax, uint, 0444);
 
1529
 
 
1530
MODULE_DESCRIPTION("ARM PrimeCell PL180/181 Multimedia Card Interface driver");
 
1531
MODULE_LICENSE("GPL");