← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/gpio/gpio-u300.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/gpio/gpio-u300.c
 
1
/*
 
2
 *
 
3
 * arch/arm/mach-u300/gpio.c
 
4
 *
 
5
 *
 
6
 * Copyright (C) 2007-2009 ST-Ericsson AB
 
7
 * License terms: GNU General Public License (GPL) version 2
 
8
 * U300 GPIO module.
 
9
 * This can driver either of the two basic GPIO cores
 
10
 * available in the U300 platforms:
 
11
 * COH 901 335   - Used in DB3150 (U300 1.0) and DB3200 (U330 1.0)
 
12
 * COH 901 571/3 - Used in DB3210 (U365 2.0) and DB3350 (U335 1.0)
 
13
 * Notice that you also have inline macros in <asm-arch/gpio.h>
 
14
 * Author: Linus Walleij <linus.walleij@stericsson.com>
 
15
 * Author: Jonas Aaberg <jonas.aberg@stericsson.com>
 
16
 *
 
17
 */
 
18
#include <linux/module.h>
 
19
#include <linux/interrupt.h>
 
20
#include <linux/delay.h>
 
21
#include <linux/errno.h>
 
22
#include <linux/io.h>
 
23
#include <linux/clk.h>
 
24
#include <linux/err.h>
 
25
#include <linux/platform_device.h>
 
26
#include <linux/gpio.h>
 
27
 
 
28
/* Reference to GPIO block clock */
 
29
static struct clk *clk;
 
30
 
 
31
/* Memory resource */
 
32
static struct resource *memres;
 
33
static void __iomem *virtbase;
 
34
static struct device *gpiodev;
 
35
 
 
36
struct u300_gpio_port {
 
37
        const char *name;
 
38
        int irq;
 
39
        int number;
 
40
};
 
41
 
 
42
 
 
43
static struct u300_gpio_port gpio_ports[] = {
 
44
        {
 
45
                .name = "gpio0",
 
46
                .number = 0,
 
47
        },
 
48
        {
 
49
                .name = "gpio1",
 
50
                .number = 1,
 
51
        },
 
52
        {
 
53
                .name = "gpio2",
 
54
                .number = 2,
 
55
        },
 
56
#ifdef U300_COH901571_3
 
57
        {
 
58
                .name = "gpio3",
 
59
                .number = 3,
 
60
        },
 
61
        {
 
62
                .name = "gpio4",
 
63
                .number = 4,
 
64
        },
 
65
#ifdef CONFIG_MACH_U300_BS335
 
66
        {
 
67
                .name = "gpio5",
 
68
                .number = 5,
 
69
        },
 
70
        {
 
71
                .name = "gpio6",
 
72
                .number = 6,
 
73
        },
 
74
#endif
 
75
#endif
 
76
 
 
77
};
 
78
 
 
79
 
 
80
#ifdef U300_COH901571_3
 
81
 
 
82
/* Default input value */
 
83
#define DEFAULT_OUTPUT_LOW   0
 
84
#define DEFAULT_OUTPUT_HIGH  1
 
85
 
 
86
/* GPIO Pull-Up status */
 
87
#define DISABLE_PULL_UP  0
 
88
#define ENABLE_PULL_UP  1
 
89
 
 
90
#define GPIO_NOT_USED 0
 
91
#define GPIO_IN       1
 
92
#define GPIO_OUT      2
 
93
 
 
94
struct u300_gpio_configuration_data {
 
95
        unsigned char pin_usage;
 
96
        unsigned char default_output_value;
 
97
        unsigned char pull_up;
 
98
};
 
99
 
 
100
/* Initial configuration */
 
101
const struct u300_gpio_configuration_data
 
102
u300_gpio_config[U300_GPIO_NUM_PORTS][U300_GPIO_PINS_PER_PORT] = {
 
103
#ifdef CONFIG_MACH_U300_BS335
 
104
        /* Port 0, pins 0-7 */
 
105
        {
 
106
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
107
                {GPIO_OUT, DEFAULT_OUTPUT_HIGH,  DISABLE_PULL_UP},
 
108
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
109
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
110
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
111
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
112
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
113
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
 
114
        },
 
115
        /* Port 1, pins 0-7 */
 
116
        {
 
117
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
118
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
119
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
120
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
121
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
122
                {GPIO_OUT, DEFAULT_OUTPUT_HIGH,  DISABLE_PULL_UP},
 
123
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
124
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
 
125
        },
 
126
        /* Port 2, pins 0-7 */
 
127
        {
 
128
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
129
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
130
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
131
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
132
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
133
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
134
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
135
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP}
 
136
        },
 
137
        /* Port 3, pins 0-7 */
 
138
        {
 
139
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
140
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
141
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
142
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
143
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
144
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
145
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
146
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
 
147
        },
 
148
        /* Port 4, pins 0-7 */
 
149
        {
 
150
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
151
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
152
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
153
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
154
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
155
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
156
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
157
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
 
158
        },
 
159
        /* Port 5, pins 0-7 */
 
160
        {
 
161
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
162
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
163
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
164
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
165
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
166
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
167
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
168
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
 
169
        },
 
170
        /* Port 6, pind 0-7 */
 
171
        {
 
172
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
173
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
174
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
175
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
176
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
177
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
178
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
179
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
 
180
        }
 
181
#endif
 
182
 
 
183
#ifdef CONFIG_MACH_U300_BS365
 
184
        /* Port 0, pins 0-7 */
 
185
        {
 
186
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
187
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
188
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
189
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
190
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
191
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
192
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
193
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
 
194
        },
 
195
        /* Port 1, pins 0-7 */
 
196
        {
 
197
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
198
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
199
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
200
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
201
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
202
                {GPIO_OUT, DEFAULT_OUTPUT_HIGH,  DISABLE_PULL_UP},
 
203
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
204
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
 
205
        },
 
206
        /* Port 2, pins 0-7 */
 
207
        {
 
208
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
209
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
210
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
211
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
 
212
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
213
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
214
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
215
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP}
 
216
        },
 
217
        /* Port 3, pins 0-7 */
 
218
        {
 
219
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
220
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
221
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
222
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
223
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
224
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
225
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
226
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP}
 
227
        },
 
228
        /* Port 4, pins 0-7 */
 
229
        {
 
230
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
231
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
232
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
233
                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
234
                /* These 4 pins doesn't exist on DB3210 */
 
235
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
236
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
237
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
 
238
                {GPIO_OUT, DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP}
 
239
        }
 
240
#endif
 
241
};
 
242
#endif
 
243
 
 
244
 
 
245
/* No users == we can power down GPIO */
 
246
static int gpio_users;
 
247
 
 
248
struct gpio_struct {
 
249
        int (*callback)(void *);
 
250
        void *data;
 
251
        int users;
 
252
};
 
253
 
 
254
static struct gpio_struct gpio_pin[U300_GPIO_MAX];
 
255
 
 
256
/*
 
257
 * Let drivers register callback in order to get notified when there is
 
258
 * an interrupt on the gpio pin
 
259
 */
 
260
int gpio_register_callback(unsigned gpio, int (*func)(void *arg), void *data)
 
261
{
 
262
        if (gpio_pin[gpio].callback)
 
263
                dev_warn(gpiodev, "%s: WARNING: callback already "
 
264
                         "registered for gpio pin#%d\n", __func__, gpio);
 
265
        gpio_pin[gpio].callback = func;
 
266
        gpio_pin[gpio].data = data;
 
267
 
 
268
        return 0;
 
269
}
 
270
EXPORT_SYMBOL(gpio_register_callback);
 
271
 
 
272
int gpio_unregister_callback(unsigned gpio)
 
273
{
 
274
        if (!gpio_pin[gpio].callback)
 
275
                dev_warn(gpiodev, "%s: WARNING: callback already "
 
276
                         "unregistered for gpio pin#%d\n", __func__, gpio);
 
277
        gpio_pin[gpio].callback = NULL;
 
278
        gpio_pin[gpio].data = NULL;
 
279
 
 
280
        return 0;
 
281
}
 
282
EXPORT_SYMBOL(gpio_unregister_callback);
 
283
 
 
284
/* Non-zero means valid */
 
285
int gpio_is_valid(int number)
 
286
{
 
287
        if (number >= 0 &&
 
288
            number < (U300_GPIO_NUM_PORTS * U300_GPIO_PINS_PER_PORT))
 
289
                return 1;
 
290
        return 0;
 
291
}
 
292
EXPORT_SYMBOL(gpio_is_valid);
 
293
 
 
294
int gpio_request(unsigned gpio, const char *label)
 
295
{
 
296
        if (gpio_pin[gpio].users)
 
297
                return -EINVAL;
 
298
        else
 
299
                gpio_pin[gpio].users++;
 
300
 
 
301
        gpio_users++;
 
302
 
 
303
        return 0;
 
304
}
 
305
EXPORT_SYMBOL(gpio_request);
 
306
 
 
307
void gpio_free(unsigned gpio)
 
308
{
 
309
        gpio_users--;
 
310
        gpio_pin[gpio].users--;
 
311
        if (unlikely(gpio_pin[gpio].users < 0)) {
 
312
                dev_warn(gpiodev, "warning: gpio#%d release mismatch\n",
 
313
                         gpio);
 
314
                gpio_pin[gpio].users = 0;
 
315
        }
 
316
 
 
317
        return;
 
318
}
 
319
EXPORT_SYMBOL(gpio_free);
 
320
 
 
321
/* This returns zero or nonzero */
 
322
int gpio_get_value(unsigned gpio)
 
323
{
 
324
        return readl(virtbase + U300_GPIO_PXPDIR +
 
325
          PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING) & (1 << (gpio & 0x07));
 
326
}
 
327
EXPORT_SYMBOL(gpio_get_value);
 
328
 
 
329
/*
 
330
 * We hope that the compiler will optimize away the unused branch
 
331
 * in case "value" is a constant
 
332
 */
 
333
void gpio_set_value(unsigned gpio, int value)
 
334
{
 
335
        u32 val;
 
336
        unsigned long flags;
 
337
 
 
338
        local_irq_save(flags);
 
339
        if (value) {
 
340
                /* set */
 
341
                val = readl(virtbase + U300_GPIO_PXPDOR +
 
342
                  PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING)
 
343
                  & (1 << (gpio & 0x07));
 
344
                writel(val | (1 << (gpio & 0x07)), virtbase +
 
345
                  U300_GPIO_PXPDOR +
 
346
                  PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING);
 
347
        } else {
 
348
                /* clear */
 
349
                val = readl(virtbase + U300_GPIO_PXPDOR +
 
350
                  PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING)
 
351
                  & (1 << (gpio & 0x07));
 
352
                writel(val & ~(1 << (gpio & 0x07)), virtbase +
 
353
                  U300_GPIO_PXPDOR +
 
354
                  PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING);
 
355
        }
 
356
        local_irq_restore(flags);
 
357
}
 
358
EXPORT_SYMBOL(gpio_set_value);
 
359
 
 
360
int gpio_direction_input(unsigned gpio)
 
361
{
 
362
        unsigned long flags;
 
363
        u32 val;
 
364
 
 
365
        if (gpio > U300_GPIO_MAX)
 
366
                return -EINVAL;
 
367
 
 
368
        local_irq_save(flags);
 
369
        val = readl(virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) *
 
370
                                U300_GPIO_PORTX_SPACING);
 
371
        /* Mask out this pin*/
 
372
        val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << ((gpio & 0x07) << 1));
 
373
        /* This is not needed since it sets the bits to zero.*/
 
374
        /* val |= (U300_GPIO_PXPCR_PIN_MODE_INPUT << (gpio*2)); */
 
375
        writel(val, virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) *
 
376
                                U300_GPIO_PORTX_SPACING);
 
377
        local_irq_restore(flags);
 
378
        return 0;
 
379
}
 
380
EXPORT_SYMBOL(gpio_direction_input);
 
381
 
 
382
int gpio_direction_output(unsigned gpio, int value)
 
383
{
 
384
        unsigned long flags;
 
385
        u32 val;
 
386
 
 
387
        if (gpio > U300_GPIO_MAX)
 
388
                return -EINVAL;
 
389
 
 
390
        local_irq_save(flags);
 
391
        val = readl(virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) *
 
392
                                U300_GPIO_PORTX_SPACING);
 
393
        /* Mask out this pin */
 
394
        val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << ((gpio & 0x07) << 1));
 
395
        /*
 
396
         * FIXME: configure for push/pull, open drain or open source per pin
 
397
         * in setup. The current driver will only support push/pull.
 
398
         */
 
399
        val |= (U300_GPIO_PXPCR_PIN_MODE_OUTPUT_PUSH_PULL
 
400
                        << ((gpio & 0x07) << 1));
 
401
        writel(val, virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) *
 
402
                                U300_GPIO_PORTX_SPACING);
 
403
        gpio_set_value(gpio, value);
 
404
        local_irq_restore(flags);
 
405
        return 0;
 
406
}
 
407
EXPORT_SYMBOL(gpio_direction_output);
 
408
 
 
409
/*
 
410
 * Enable an IRQ, edge is rising edge (!= 0) or falling edge (==0).
 
411
 */
 
412
void enable_irq_on_gpio_pin(unsigned gpio, int edge)
 
413
{
 
414
        u32 val;
 
415
        unsigned long flags;
 
416
        local_irq_save(flags);
 
417
 
 
418
        val = readl(virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) *
 
419
                                U300_GPIO_PORTX_SPACING);
 
420
        val |= (1 << (gpio & 0x07));
 
421
        writel(val, virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) *
 
422
                                U300_GPIO_PORTX_SPACING);
 
423
        val = readl(virtbase + U300_GPIO_PXICR + PIN_TO_PORT(gpio) *
 
424
                                U300_GPIO_PORTX_SPACING);
 
425
        if (edge)
 
426
                val |= (1 << (gpio & 0x07));
 
427
        else
 
428
                val &= ~(1 << (gpio & 0x07));
 
429
        writel(val, virtbase + U300_GPIO_PXICR + PIN_TO_PORT(gpio) *
 
430
                                U300_GPIO_PORTX_SPACING);
 
431
        local_irq_restore(flags);
 
432
}
 
433
EXPORT_SYMBOL(enable_irq_on_gpio_pin);
 
434
 
 
435
void disable_irq_on_gpio_pin(unsigned gpio)
 
436
{
 
437
        u32 val;
 
438
        unsigned long flags;
 
439
 
 
440
        local_irq_save(flags);
 
441
        val = readl(virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) *
 
442
                                U300_GPIO_PORTX_SPACING);
 
443
        val &= ~(1 << (gpio & 0x07));
 
444
        writel(val, virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) *
 
445
                                U300_GPIO_PORTX_SPACING);
 
446
        local_irq_restore(flags);
 
447
}
 
448
EXPORT_SYMBOL(disable_irq_on_gpio_pin);
 
449
 
 
450
/* Enable (value == 0) or disable (value == 1) internal pullup */
 
451
void gpio_pullup(unsigned gpio, int value)
 
452
{
 
453
        u32 val;
 
454
        unsigned long flags;
 
455
 
 
456
        local_irq_save(flags);
 
457
        if (value) {
 
458
                val = readl(virtbase + U300_GPIO_PXPER + PIN_TO_PORT(gpio) *
 
459
                                        U300_GPIO_PORTX_SPACING);
 
460
                writel(val | (1 << (gpio & 0x07)), virtbase + U300_GPIO_PXPER +
 
461
                                PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING);
 
462
        } else {
 
463
                val = readl(virtbase + U300_GPIO_PXPER + PIN_TO_PORT(gpio) *
 
464
                                        U300_GPIO_PORTX_SPACING);
 
465
                writel(val & ~(1 << (gpio & 0x07)), virtbase + U300_GPIO_PXPER +
 
466
                                PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING);
 
467
        }
 
468
        local_irq_restore(flags);
 
469
}
 
470
EXPORT_SYMBOL(gpio_pullup);
 
471
 
 
472
static irqreturn_t gpio_irq_handler(int irq, void *dev_id)
 
473
{
 
474
        struct u300_gpio_port *port = dev_id;
 
475
        u32 val;
 
476
        int pin;
 
477
 
 
478
        /* Read event register */
 
479
        val = readl(virtbase + U300_GPIO_PXIEV + port->number *
 
480
                                U300_GPIO_PORTX_SPACING);
 
481
        /* Mask with enable register */
 
482
        val &= readl(virtbase + U300_GPIO_PXIEV + port->number *
 
483
                                U300_GPIO_PORTX_SPACING);
 
484
        /* Mask relevant bits */
 
485
        val &= U300_GPIO_PXIEV_ALL_IRQ_EVENT_MASK;
 
486
        /* ACK IRQ (clear event) */
 
487
        writel(val, virtbase + U300_GPIO_PXIEV + port->number *
 
488
                                U300_GPIO_PORTX_SPACING);
 
489
        /* Print message */
 
490
        while (val != 0) {
 
491
                unsigned gpio;
 
492
 
 
493
                pin = __ffs(val);
 
494
                /* mask off this pin */
 
495
                val &= ~(1 << pin);
 
496
                gpio = (port->number << 3) + pin;
 
497
 
 
498
                if (gpio_pin[gpio].callback)
 
499
                        (void)gpio_pin[gpio].callback(gpio_pin[gpio].data);
 
500
                else
 
501
                        dev_dbg(gpiodev, "stray GPIO IRQ on line %d\n",
 
502
                               gpio);
 
503
        }
 
504
        return IRQ_HANDLED;
 
505
}
 
506
 
 
507
static void gpio_set_initial_values(void)
 
508
{
 
509
#ifdef U300_COH901571_3
 
510
        int i, j;
 
511
        unsigned long flags;
 
512
        u32 val;
 
513
 
 
514
        /* Write default values to all pins */
 
515
        for (i = 0; i < U300_GPIO_NUM_PORTS; i++) {
 
516
                val = 0;
 
517
                for (j = 0; j < 8; j++)
 
518
                        val |= (u32) (u300_gpio_config[i][j].default_output_value != DEFAULT_OUTPUT_LOW) << j;
 
519
                local_irq_save(flags);
 
520
                writel(val, virtbase + U300_GPIO_PXPDOR + i * U300_GPIO_PORTX_SPACING);
 
521
                local_irq_restore(flags);
 
522
        }
 
523
 
 
524
        /*
 
525
         * Put all pins that are set to either 'GPIO_OUT' or 'GPIO_NOT_USED'
 
526
         * to output and 'GPIO_IN' to input for each port. And initialize
 
527
         * default value on outputs.
 
528
         */
 
529
        for (i = 0; i < U300_GPIO_NUM_PORTS; i++) {
 
530
                for (j = 0; j < U300_GPIO_PINS_PER_PORT; j++) {
 
531
                        local_irq_save(flags);
 
532
                        val = readl(virtbase + U300_GPIO_PXPCR +
 
533
                                         i * U300_GPIO_PORTX_SPACING);
 
534
                        /* Mask out this pin */
 
535
                        val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << (j << 1));
 
536
 
 
537
                        if (u300_gpio_config[i][j].pin_usage != GPIO_IN)
 
538
                                val |= (U300_GPIO_PXPCR_PIN_MODE_OUTPUT_PUSH_PULL << (j << 1));
 
539
                        writel(val, virtbase + U300_GPIO_PXPCR +
 
540
                                         i * U300_GPIO_PORTX_SPACING);
 
541
                        local_irq_restore(flags);
 
542
                }
 
543
        }
 
544
 
 
545
        /* Enable or disable the internal pull-ups in the GPIO ASIC block */
 
546
        for (i = 0; i < U300_GPIO_MAX; i++) {
 
547
                val = 0;
 
548
                for (j = 0; j < 8; j++)
 
549
                        val |= (u32)((u300_gpio_config[i][j].pull_up == DISABLE_PULL_UP) << j);
 
550
                local_irq_save(flags);
 
551
                writel(val, virtbase + U300_GPIO_PXPER + i * U300_GPIO_PORTX_SPACING);
 
552
                local_irq_restore(flags);
 
553
        }
 
554
#endif
 
555
}
 
556
 
 
557
static int __init gpio_probe(struct platform_device *pdev)
 
558
{
 
559
        u32 val;
 
560
        int err = 0;
 
561
        int i;
 
562
        int num_irqs;
 
563
 
 
564
        gpiodev = &pdev->dev;
 
565
        memset(gpio_pin, 0, sizeof(gpio_pin));
 
566
 
 
567
        /* Get GPIO clock */
 
568
        clk = clk_get(&pdev->dev, NULL);
 
569
        if (IS_ERR(clk)) {
 
570
                err = PTR_ERR(clk);
 
571
                dev_err(gpiodev, "could not get GPIO clock\n");
 
572
                goto err_no_clk;
 
573
        }
 
574
        err = clk_enable(clk);
 
575
        if (err) {
 
576
                dev_err(gpiodev, "could not enable GPIO clock\n");
 
577
                goto err_no_clk_enable;
 
578
        }
 
579
 
 
580
        memres = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
581
        if (!memres)
 
582
                goto err_no_resource;
 
583
 
 
584
        if (request_mem_region(memres->start, memres->end - memres->start, "GPIO Controller")
 
585
            == NULL) {
 
586
                err = -ENODEV;
 
587
                goto err_no_ioregion;
 
588
        }
 
589
 
 
590
        virtbase = ioremap(memres->start, resource_size(memres));
 
591
        if (!virtbase) {
 
592
                err = -ENOMEM;
 
593
                goto err_no_ioremap;
 
594
        }
 
595
        dev_info(gpiodev, "remapped 0x%08x to %p\n",
 
596
                 memres->start, virtbase);
 
597
 
 
598
#ifdef U300_COH901335
 
599
        dev_info(gpiodev, "initializing GPIO Controller COH 901 335\n");
 
600
        /* Turn on the GPIO block */
 
601
        writel(U300_GPIO_CR_BLOCK_CLOCK_ENABLE, virtbase + U300_GPIO_CR);
 
602
#endif
 
603
 
 
604
#ifdef U300_COH901571_3
 
605
        dev_info(gpiodev, "initializing GPIO Controller COH 901 571/3\n");
 
606
        val = readl(virtbase + U300_GPIO_CR);
 
607
        dev_info(gpiodev, "COH901571/3 block version: %d, " \
 
608
               "number of cores: %d\n",
 
609
               ((val & 0x0000FE00) >> 9),
 
610
               ((val & 0x000001FC) >> 2));
 
611
        writel(U300_GPIO_CR_BLOCK_CLKRQ_ENABLE, virtbase + U300_GPIO_CR);
 
612
#endif
 
613
 
 
614
        gpio_set_initial_values();
 
615
 
 
616
        for (num_irqs = 0 ; num_irqs < U300_GPIO_NUM_PORTS; num_irqs++) {
 
617
 
 
618
                gpio_ports[num_irqs].irq =
 
619
                        platform_get_irq_byname(pdev,
 
620
                                                gpio_ports[num_irqs].name);
 
621
 
 
622
                err = request_irq(gpio_ports[num_irqs].irq,
 
623
                                  gpio_irq_handler, IRQF_DISABLED,
 
624
                                  gpio_ports[num_irqs].name,
 
625
                                  &gpio_ports[num_irqs]);
 
626
                if (err) {
 
627
                        dev_err(gpiodev, "cannot allocate IRQ for %s!\n",
 
628
                                gpio_ports[num_irqs].name);
 
629
                        goto err_no_irq;
 
630
                }
 
631
                /* Turns off PortX_irq_force */
 
632
                writel(0x0, virtbase + U300_GPIO_PXIFR +
 
633
                                 num_irqs * U300_GPIO_PORTX_SPACING);
 
634
        }
 
635
 
 
636
        return 0;
 
637
 
 
638
 err_no_irq:
 
639
        for (i = 0; i < num_irqs; i++)
 
640
                free_irq(gpio_ports[i].irq, &gpio_ports[i]);
 
641
        iounmap(virtbase);
 
642
 err_no_ioremap:
 
643
        release_mem_region(memres->start, memres->end - memres->start);
 
644
 err_no_ioregion:
 
645
 err_no_resource:
 
646
        clk_disable(clk);
 
647
 err_no_clk_enable:
 
648
        clk_put(clk);
 
649
 err_no_clk:
 
650
        dev_info(gpiodev, "module ERROR:%d\n", err);
 
651
        return err;
 
652
}
 
653
 
 
654
static int __exit gpio_remove(struct platform_device *pdev)
 
655
{
 
656
        int i;
 
657
 
 
658
        /* Turn off the GPIO block */
 
659
        writel(0x00000000U, virtbase + U300_GPIO_CR);
 
660
        for (i = 0 ; i < U300_GPIO_NUM_PORTS; i++)
 
661
                free_irq(gpio_ports[i].irq, &gpio_ports[i]);
 
662
        iounmap(virtbase);
 
663
        release_mem_region(memres->start, memres->end - memres->start);
 
664
        clk_disable(clk);
 
665
        clk_put(clk);
 
666
        return 0;
 
667
}
 
668
 
 
669
static struct platform_driver gpio_driver = {
 
670
        .driver         = {
 
671
                .name   = "u300-gpio",
 
672
        },
 
673
        .remove         = __exit_p(gpio_remove),
 
674
};
 
675
 
 
676
 
 
677
static int __init u300_gpio_init(void)
 
678
{
 
679
        return platform_driver_probe(&gpio_driver, gpio_probe);
 
680
}
 
681
 
 
682
static void __exit u300_gpio_exit(void)
 
683
{
 
684
        platform_driver_unregister(&gpio_driver);
 
685
}
 
686
 
 
687
arch_initcall(u300_gpio_init);
 
688
module_exit(u300_gpio_exit);
 
689
 
 
690
MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
 
691
 
 
692
#ifdef U300_COH901571_3
 
693
MODULE_DESCRIPTION("ST-Ericsson AB COH 901 571/3 GPIO driver");
 
694
#endif
 
695
 
 
696
#ifdef U300_COH901335
 
697
MODULE_DESCRIPTION("ST-Ericsson AB COH 901 335 GPIO driver");
 
698
#endif
 
699
 
 
700
MODULE_LICENSE("GPL");