← Back to branch summary

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

« back to all changes in this revision

Viewing changes to arch/arm/mach-omap2/board-igep0030.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:
arch/arm/mach-omap2/board-igep0030.c
1
 
/*
2
 
 * Copyright (C) 2010 - ISEE 2007 SL
3
 
 *
4
 
 * Modified from mach-omap2/board-generic.c
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
 
 
11
 
#include <linux/kernel.h>
12
 
#include <linux/init.h>
13
 
#include <linux/platform_device.h>
14
 
#include <linux/delay.h>
15
 
#include <linux/err.h>
16
 
#include <linux/clk.h>
17
 
#include <linux/io.h>
18
 
#include <linux/gpio.h>
19
 
#include <linux/interrupt.h>
20
 
 
21
 
#include <linux/regulator/machine.h>
22
 
#include <linux/regulator/fixed.h>
23
 
#include <linux/i2c/twl.h>
24
 
#include <linux/mmc/host.h>
25
 
 
26
 
#include <asm/mach-types.h>
27
 
#include <asm/mach/arch.h>
28
 
 
29
 
#include <plat/board.h>
30
 
#include <plat/common.h>
31
 
#include <plat/gpmc.h>
32
 
#include <plat/usb.h>
33
 
#include <plat/onenand.h>
34
 
 
35
 
#include "mux.h"
36
 
#include "hsmmc.h"
37
 
#include "sdram-numonyx-m65kxxxxam.h"
38
 
 
39
 
#define IGEP3_GPIO_LED0_GREEN   54
40
 
#define IGEP3_GPIO_LED0_RED     53
41
 
#define IGEP3_GPIO_LED1_RED     16
42
 
 
43
 
#define IGEP3_GPIO_WIFI_NPD     138
44
 
#define IGEP3_GPIO_WIFI_NRESET  139
45
 
#define IGEP3_GPIO_BT_NRESET    137
46
 
 
47
 
#define IGEP3_GPIO_USBH_NRESET  183
48
 
 
49
 
 
50
 
#if defined(CONFIG_MTD_ONENAND_OMAP2) || \
51
 
        defined(CONFIG_MTD_ONENAND_OMAP2_MODULE)
52
 
 
53
 
#define ONENAND_MAP             0x20000000
54
 
 
55
 
/*
56
 
 * x2 Flash built-in COMBO POP MEMORY
57
 
 * Since the device is equipped with two DataRAMs, and two-plane NAND
58
 
 * Flash memory array, these two component enables simultaneous program
59
 
 * of 4KiB. Plane1 has only even blocks such as block0, block2, block4
60
 
 * while Plane2 has only odd blocks such as block1, block3, block5.
61
 
 * So MTD regards it as 4KiB page size and 256KiB block size 64*(2*2048)
62
 
 */
63
 
 
64
 
static struct mtd_partition igep3_onenand_partitions[] = {
65
 
        {
66
 
                .name           = "X-Loader",
67
 
                .offset         = 0,
68
 
                .size           = 2 * (64*(2*2048))
69
 
        },
70
 
        {
71
 
                .name           = "U-Boot",
72
 
                .offset         = MTDPART_OFS_APPEND,
73
 
                .size           = 6 * (64*(2*2048)),
74
 
        },
75
 
        {
76
 
                .name           = "Environment",
77
 
                .offset         = MTDPART_OFS_APPEND,
78
 
                .size           = 2 * (64*(2*2048)),
79
 
        },
80
 
        {
81
 
                .name           = "Kernel",
82
 
                .offset         = MTDPART_OFS_APPEND,
83
 
                .size           = 12 * (64*(2*2048)),
84
 
        },
85
 
        {
86
 
                .name           = "File System",
87
 
                .offset         = MTDPART_OFS_APPEND,
88
 
                .size           = MTDPART_SIZ_FULL,
89
 
        },
90
 
};
91
 
 
92
 
static struct omap_onenand_platform_data igep3_onenand_pdata = {
93
 
        .parts = igep3_onenand_partitions,
94
 
        .nr_parts = ARRAY_SIZE(igep3_onenand_partitions),
95
 
        .onenand_setup = NULL,
96
 
        .dma_channel    = -1,   /* disable DMA in OMAP OneNAND driver */
97
 
};
98
 
 
99
 
static struct platform_device igep3_onenand_device = {
100
 
        .name           = "omap2-onenand",
101
 
        .id             = -1,
102
 
        .dev = {
103
 
                .platform_data = &igep3_onenand_pdata,
104
 
        },
105
 
};
106
 
 
107
 
static void __init igep3_flash_init(void)
108
 
{
109
 
        u8 cs = 0;
110
 
        u8 onenandcs = GPMC_CS_NUM + 1;
111
 
 
112
 
        for (cs = 0; cs < GPMC_CS_NUM; cs++) {
113
 
                u32 ret;
114
 
                ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
115
 
 
116
 
                /* Check if NAND/oneNAND is configured */
117
 
                if ((ret & 0xC00) == 0x800)
118
 
                        /* NAND found */
119
 
                        pr_err("IGEP3: Unsupported NAND found\n");
120
 
                else {
121
 
                        ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
122
 
 
123
 
                        if ((ret & 0x3F) == (ONENAND_MAP >> 24))
124
 
                                /* OneNAND found */
125
 
                                onenandcs = cs;
126
 
                }
127
 
        }
128
 
 
129
 
        if (onenandcs > GPMC_CS_NUM) {
130
 
                pr_err("IGEP3: Unable to find configuration in GPMC\n");
131
 
                return;
132
 
        }
133
 
 
134
 
        igep3_onenand_pdata.cs = onenandcs;
135
 
 
136
 
        if (platform_device_register(&igep3_onenand_device) < 0)
137
 
                pr_err("IGEP3: Unable to register OneNAND device\n");
138
 
}
139
 
 
140
 
#else
141
 
static void __init igep3_flash_init(void) {}
142
 
#endif
143
 
 
144
 
static struct regulator_consumer_supply igep3_vmmc1_supply =
145
 
        REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0");
146
 
 
147
 
/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
148
 
static struct regulator_init_data igep3_vmmc1 = {
149
 
        .constraints = {
150
 
                .min_uV                 = 1850000,
151
 
                .max_uV                 = 3150000,
152
 
                .valid_modes_mask       = REGULATOR_MODE_NORMAL
153
 
                                        | REGULATOR_MODE_STANDBY,
154
 
                .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
155
 
                                        | REGULATOR_CHANGE_MODE
156
 
                                        | REGULATOR_CHANGE_STATUS,
157
 
        },
158
 
        .num_consumer_supplies  = 1,
159
 
        .consumer_supplies      = &igep3_vmmc1_supply,
160
 
};
161
 
 
162
 
static struct regulator_consumer_supply igep3_vio_supply =
163
 
        REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.1");
164
 
 
165
 
static struct regulator_init_data igep3_vio = {
166
 
        .constraints = {
167
 
                .min_uV                 = 1800000,
168
 
                .max_uV                 = 1800000,
169
 
                .apply_uV               = 1,
170
 
                .valid_modes_mask       = REGULATOR_MODE_NORMAL
171
 
                                        | REGULATOR_MODE_STANDBY,
172
 
                .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
173
 
                                        | REGULATOR_CHANGE_MODE
174
 
                                        | REGULATOR_CHANGE_STATUS,
175
 
        },
176
 
        .num_consumer_supplies  = 1,
177
 
        .consumer_supplies      = &igep3_vio_supply,
178
 
};
179
 
 
180
 
static struct regulator_consumer_supply igep3_vmmc2_supply =
181
 
        REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1");
182
 
 
183
 
static struct regulator_init_data igep3_vmmc2 = {
184
 
        .constraints    = {
185
 
                .valid_modes_mask       = REGULATOR_MODE_NORMAL,
186
 
                .always_on              = 1,
187
 
        },
188
 
        .num_consumer_supplies  = 1,
189
 
        .consumer_supplies      = &igep3_vmmc2_supply,
190
 
};
191
 
 
192
 
static struct fixed_voltage_config igep3_vwlan = {
193
 
        .supply_name            = "vwlan",
194
 
        .microvolts             = 3300000,
195
 
        .gpio                   = -EINVAL,
196
 
        .enabled_at_boot        = 1,
197
 
        .init_data              = &igep3_vmmc2,
198
 
};
199
 
 
200
 
static struct platform_device igep3_vwlan_device = {
201
 
        .name   = "reg-fixed-voltage",
202
 
        .id     = 0,
203
 
        .dev    = {
204
 
                .platform_data = &igep3_vwlan,
205
 
        },
206
 
};
207
 
 
208
 
static struct omap2_hsmmc_info mmc[] = {
209
 
        [0] = {
210
 
                .mmc            = 1,
211
 
                .caps           = MMC_CAP_4_BIT_DATA,
212
 
                .gpio_cd        = -EINVAL,
213
 
                .gpio_wp        = -EINVAL,
214
 
        },
215
 
#if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
216
 
        [1] = {
217
 
                .mmc            = 2,
218
 
                .caps           = MMC_CAP_4_BIT_DATA,
219
 
                .gpio_cd        = -EINVAL,
220
 
                .gpio_wp        = -EINVAL,
221
 
        },
222
 
#endif
223
 
        {}      /* Terminator */
224
 
};
225
 
 
226
 
#if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
227
 
#include <linux/leds.h>
228
 
 
229
 
static struct gpio_led igep3_gpio_leds[] = {
230
 
        [0] = {
231
 
                .name                   = "gpio-led:red:d0",
232
 
                .gpio                   = IGEP3_GPIO_LED0_RED,
233
 
                .default_trigger        = "default-off"
234
 
        },
235
 
        [1] = {
236
 
                .name                   = "gpio-led:green:d0",
237
 
                .gpio                   = IGEP3_GPIO_LED0_GREEN,
238
 
                .default_trigger        = "default-off",
239
 
        },
240
 
        [2] = {
241
 
                .name                   = "gpio-led:red:d1",
242
 
                .gpio                   = IGEP3_GPIO_LED1_RED,
243
 
                .default_trigger        = "default-off",
244
 
        },
245
 
        [3] = {
246
 
                .name                   = "gpio-led:green:d1",
247
 
                .default_trigger        = "heartbeat",
248
 
                .gpio                   = -EINVAL, /* gets replaced */
249
 
        },
250
 
};
251
 
 
252
 
static struct gpio_led_platform_data igep3_led_pdata = {
253
 
        .leds           = igep3_gpio_leds,
254
 
        .num_leds       = ARRAY_SIZE(igep3_gpio_leds),
255
 
};
256
 
 
257
 
static struct platform_device igep3_led_device = {
258
 
         .name   = "leds-gpio",
259
 
         .id     = -1,
260
 
         .dev    = {
261
 
                 .platform_data = &igep3_led_pdata,
262
 
        },
263
 
};
264
 
 
265
 
static void __init igep3_leds_init(void)
266
 
{
267
 
        platform_device_register(&igep3_led_device);
268
 
}
269
 
 
270
 
#else
271
 
static inline void igep3_leds_init(void)
272
 
{
273
 
        if ((gpio_request(IGEP3_GPIO_LED0_RED, "gpio-led:red:d0") == 0) &&
274
 
            (gpio_direction_output(IGEP3_GPIO_LED0_RED, 1) == 0)) {
275
 
                gpio_export(IGEP3_GPIO_LED0_RED, 0);
276
 
                gpio_set_value(IGEP3_GPIO_LED0_RED, 1);
277
 
        } else
278
 
                pr_warning("IGEP3: Could not obtain gpio GPIO_LED0_RED\n");
279
 
 
280
 
        if ((gpio_request(IGEP3_GPIO_LED0_GREEN, "gpio-led:green:d0") == 0) &&
281
 
            (gpio_direction_output(IGEP3_GPIO_LED0_GREEN, 1) == 0)) {
282
 
                gpio_export(IGEP3_GPIO_LED0_GREEN, 0);
283
 
                gpio_set_value(IGEP3_GPIO_LED0_GREEN, 1);
284
 
        } else
285
 
                pr_warning("IGEP3: Could not obtain gpio GPIO_LED0_GREEN\n");
286
 
 
287
 
        if ((gpio_request(IGEP3_GPIO_LED1_RED, "gpio-led:red:d1") == 0) &&
288
 
                (gpio_direction_output(IGEP3_GPIO_LED1_RED, 1) == 0)) {
289
 
                gpio_export(IGEP3_GPIO_LED1_RED, 0);
290
 
                gpio_set_value(IGEP3_GPIO_LED1_RED, 1);
291
 
        } else
292
 
                pr_warning("IGEP3: Could not obtain gpio GPIO_LED1_RED\n");
293
 
}
294
 
#endif
295
 
 
296
 
static int igep3_twl4030_gpio_setup(struct device *dev,
297
 
                unsigned gpio, unsigned ngpio)
298
 
{
299
 
        /* gpio + 0 is "mmc0_cd" (input/IRQ) */
300
 
        mmc[0].gpio_cd = gpio + 0;
301
 
        omap2_hsmmc_init(mmc);
302
 
 
303
 
        /* TWL4030_GPIO_MAX + 1 == ledB (out, active low LED) */
304
 
#if !defined(CONFIG_LEDS_GPIO) && !defined(CONFIG_LEDS_GPIO_MODULE)
305
 
        if ((gpio_request(gpio+TWL4030_GPIO_MAX+1, "gpio-led:green:d1") == 0)
306
 
            && (gpio_direction_output(gpio + TWL4030_GPIO_MAX + 1, 1) == 0)) {
307
 
                gpio_export(gpio + TWL4030_GPIO_MAX + 1, 0);
308
 
                gpio_set_value(gpio + TWL4030_GPIO_MAX + 1, 0);
309
 
        } else
310
 
                pr_warning("IGEP3: Could not obtain gpio GPIO_LED1_GREEN\n");
311
 
#else
312
 
        igep3_gpio_leds[3].gpio = gpio + TWL4030_GPIO_MAX + 1;
313
 
#endif
314
 
 
315
 
        return 0;
316
 
};
317
 
 
318
 
static struct twl4030_gpio_platform_data igep3_twl4030_gpio_pdata = {
319
 
        .gpio_base      = OMAP_MAX_GPIO_LINES,
320
 
        .irq_base       = TWL4030_GPIO_IRQ_BASE,
321
 
        .irq_end        = TWL4030_GPIO_IRQ_END,
322
 
        .use_leds       = true,
323
 
        .setup          = igep3_twl4030_gpio_setup,
324
 
};
325
 
 
326
 
static struct twl4030_usb_data igep3_twl4030_usb_data = {
327
 
        .usb_mode       = T2_USB_MODE_ULPI,
328
 
};
329
 
 
330
 
static struct platform_device *igep3_devices[] __initdata = {
331
 
        &igep3_vwlan_device,
332
 
};
333
 
 
334
 
static void __init igep3_init_early(void)
335
 
{
336
 
        omap2_init_common_infrastructure();
337
 
        omap2_init_common_devices(m65kxxxxam_sdrc_params,
338
 
                                  m65kxxxxam_sdrc_params);
339
 
}
340
 
 
341
 
static struct twl4030_platform_data igep3_twl4030_pdata = {
342
 
        .irq_base       = TWL4030_IRQ_BASE,
343
 
        .irq_end        = TWL4030_IRQ_END,
344
 
 
345
 
        /* platform_data for children goes here */
346
 
        .usb            = &igep3_twl4030_usb_data,
347
 
        .gpio           = &igep3_twl4030_gpio_pdata,
348
 
        .vmmc1          = &igep3_vmmc1,
349
 
        .vio            = &igep3_vio,
350
 
};
351
 
 
352
 
static struct i2c_board_info __initdata igep3_i2c_boardinfo[] = {
353
 
        {
354
 
                I2C_BOARD_INFO("twl4030", 0x48),
355
 
                .flags          = I2C_CLIENT_WAKE,
356
 
                .irq            = INT_34XX_SYS_NIRQ,
357
 
                .platform_data  = &igep3_twl4030_pdata,
358
 
        },
359
 
};
360
 
 
361
 
static int __init igep3_i2c_init(void)
362
 
{
363
 
        omap_register_i2c_bus(1, 2600, igep3_i2c_boardinfo,
364
 
                        ARRAY_SIZE(igep3_i2c_boardinfo));
365
 
 
366
 
        return 0;
367
 
}
368
 
 
369
 
static struct omap_musb_board_data musb_board_data = {
370
 
        .interface_type = MUSB_INTERFACE_ULPI,
371
 
        .mode           = MUSB_OTG,
372
 
        .power          = 100,
373
 
};
374
 
 
375
 
#if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
376
 
 
377
 
static void __init igep3_wifi_bt_init(void)
378
 
{
379
 
        /* Configure MUX values for W-LAN + Bluetooth GPIO's */
380
 
        omap_mux_init_gpio(IGEP3_GPIO_WIFI_NPD, OMAP_PIN_OUTPUT);
381
 
        omap_mux_init_gpio(IGEP3_GPIO_WIFI_NRESET, OMAP_PIN_OUTPUT);
382
 
        omap_mux_init_gpio(IGEP3_GPIO_BT_NRESET, OMAP_PIN_OUTPUT);
383
 
 
384
 
        /* Set GPIO's for  W-LAN + Bluetooth combo module */
385
 
        if ((gpio_request(IGEP3_GPIO_WIFI_NPD, "GPIO_WIFI_NPD") == 0) &&
386
 
            (gpio_direction_output(IGEP3_GPIO_WIFI_NPD, 1) == 0)) {
387
 
                gpio_export(IGEP3_GPIO_WIFI_NPD, 0);
388
 
        } else
389
 
                pr_warning("IGEP3: Could not obtain gpio GPIO_WIFI_NPD\n");
390
 
 
391
 
        if ((gpio_request(IGEP3_GPIO_WIFI_NRESET, "GPIO_WIFI_NRESET") == 0) &&
392
 
            (gpio_direction_output(IGEP3_GPIO_WIFI_NRESET, 1) == 0)) {
393
 
                gpio_export(IGEP3_GPIO_WIFI_NRESET, 0);
394
 
                gpio_set_value(IGEP3_GPIO_WIFI_NRESET, 0);
395
 
                udelay(10);
396
 
                gpio_set_value(IGEP3_GPIO_WIFI_NRESET, 1);
397
 
        } else
398
 
                pr_warning("IGEP3: Could not obtain gpio GPIO_WIFI_NRESET\n");
399
 
 
400
 
        if ((gpio_request(IGEP3_GPIO_BT_NRESET, "GPIO_BT_NRESET") == 0) &&
401
 
            (gpio_direction_output(IGEP3_GPIO_BT_NRESET, 1) == 0)) {
402
 
                gpio_export(IGEP3_GPIO_BT_NRESET, 0);
403
 
        } else
404
 
                pr_warning("IGEP3: Could not obtain gpio GPIO_BT_NRESET\n");
405
 
}
406
 
#else
407
 
void __init igep3_wifi_bt_init(void) {}
408
 
#endif
409
 
 
410
 
static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
411
 
        .port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED,
412
 
        .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
413
 
        .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
414
 
 
415
 
        .phy_reset = true,
416
 
        .reset_gpio_port[0] = -EINVAL,
417
 
        .reset_gpio_port[1] = IGEP3_GPIO_USBH_NRESET,
418
 
        .reset_gpio_port[2] = -EINVAL,
419
 
};
420
 
 
421
 
#ifdef CONFIG_OMAP_MUX
422
 
static struct omap_board_mux board_mux[] __initdata = {
423
 
        OMAP3_MUX(I2C2_SDA, OMAP_MUX_MODE4 | OMAP_PIN_OUTPUT),
424
 
        { .reg_offset = OMAP_MUX_TERMINATOR },
425
 
};
426
 
#endif
427
 
 
428
 
static void __init igep3_init(void)
429
 
{
430
 
        omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
431
 
 
432
 
        /* Register I2C busses and drivers */
433
 
        igep3_i2c_init();
434
 
        platform_add_devices(igep3_devices, ARRAY_SIZE(igep3_devices));
435
 
        omap_serial_init();
436
 
        usb_musb_init(&musb_board_data);
437
 
        usbhs_init(&usbhs_bdata);
438
 
 
439
 
        igep3_flash_init();
440
 
        igep3_leds_init();
441
 
 
442
 
        /*
443
 
         * WLAN-BT combo module from MuRata wich has a Marvell WLAN
444
 
         * (88W8686) + CSR Bluetooth chipset. Uses SDIO interface.
445
 
         */
446
 
        igep3_wifi_bt_init();
447
 
 
448
 
}
449
 
 
450
 
static const char *igep3_dt_compat[] __initdata = {
451
 
        "ISEE,igep-v3",
452
 
        NULL
453
 
};
454
 
 
455
 
MACHINE_START(IGEP0030, "IGEP OMAP3 module")
456
 
        .boot_params    = 0x80000100,
457
 
        .reserve        = omap_reserve,
458
 
        .map_io         = omap3_map_io,
459
 
        .init_early     = igep3_init_early,
460
 
        .init_irq       = omap_init_irq,
461
 
        .init_machine   = igep3_init,
462
 
        .timer          = &omap_timer,
463
 
        .dt_compat      = &igep3_dt_compat,
464
 
MACHINE_END