source: trunk/target/linux/xburst/patches-2.6.35/020-add-qi_lb60-board-support.patch @ 22524

Last change on this file since 22524 was 22524, checked in by lars, 6 years ago

[xburst] qi_lb60: Fix keyboard gpio pins

File size: 14.0 KB
  • arch/mips/jz4740/Kconfig

    From e0548316a6aa5b9fa0df8126a4f0f749fdc5176a Mon Sep 17 00:00:00 2001
    From: Lars-Peter Clausen <lars@metafoo.de>
    Date: Sat, 17 Jul 2010 11:16:29 +0000
    Subject: [PATCH] MIPS: JZ4740: Add qi_lb60 board support
    
    Add support for the qi_lb60 (a.k.a QI Ben NanoNote) clamshell device.
    
    Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
    Cc: linux-mips@linux-mips.org
    Cc: linux-kernel@vger.kernel.org
    Patchwork: https://patchwork.linux-mips.org/patch/1472/
    Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
    ---
     arch/mips/jz4740/Kconfig         |    4 +
     arch/mips/jz4740/Makefile        |    2 +
     arch/mips/jz4740/board-qi_lb60.c |  495 ++++++++++++++++++++++++++++++++++++++
     3 files changed, 501 insertions(+), 0 deletions(-)
     create mode 100644 arch/mips/jz4740/board-qi_lb60.c
    
    diff --git a/arch/mips/jz4740/Kconfig b/arch/mips/jz4740/Kconfig
    index 8a5e850..3e7141f 100644
    a b  
    11choice 
    22        prompt "Machine type" 
    33        depends on MACH_JZ4740 
     4        default JZ4740_QI_LB60 
     5 
     6config JZ4740_QI_LB60 
     7        bool "Qi Hardware Ben NanoNote" 
    48 
    59endchoice 
    610 
  • arch/mips/jz4740/Makefile

    diff --git a/arch/mips/jz4740/Makefile b/arch/mips/jz4740/Makefile
    index a803ccb..a604eae 100644
    a b obj-$(CONFIG_DEBUG_FS) += clock-debugfs.o 
    1111 
    1212# board specific support 
    1313 
     14obj-$(CONFIG_JZ4740_QI_LB60)    += board-qi_lb60.o 
     15 
    1416# PM support 
    1517 
    1618obj-$(CONFIG_PM) += pm.o 
  • new file arch/mips/jz4740/board-qi_lb60.c

    diff --git a/arch/mips/jz4740/board-qi_lb60.c b/arch/mips/jz4740/board-qi_lb60.c
    new file mode 100644
    index 0000000..d19732a
    - +  
     1/* 
     2 * linux/arch/mips/jz4740/board-qi_lb60.c 
     3 * 
     4 * QI_LB60 board support 
     5 * 
     6 * Copyright (c) 2009 Qi Hardware inc., 
     7 * Author: Xiangfu Liu <xiangfu@qi-hardware.com> 
     8 * Copyright 2010, Lars-Petrer Clausen <lars@metafoo.de> 
     9 * 
     10 * This program is free software; you can redistribute it and/or modify 
     11 * it under the terms of the GNU General Public License version 2 or later 
     12 * as published by the Free Software Foundation. 
     13 */ 
     14 
     15#include <linux/kernel.h> 
     16#include <linux/init.h> 
     17#include <linux/gpio.h> 
     18 
     19#include <linux/input.h> 
     20#include <linux/gpio_keys.h> 
     21#include <linux/input/matrix_keypad.h> 
     22#include <linux/spi/spi.h> 
     23#include <linux/spi/spi_gpio.h> 
     24#include <linux/power_supply.h> 
     25#include <linux/power/jz4740-battery.h> 
     26#include <linux/power/gpio-charger.h> 
     27 
     28#include <asm/mach-jz4740/jz4740_fb.h> 
     29#include <asm/mach-jz4740/jz4740_mmc.h> 
     30#include <asm/mach-jz4740/jz4740_nand.h> 
     31 
     32#include <linux/regulator/fixed.h> 
     33#include <linux/regulator/machine.h> 
     34 
     35#include <linux/leds_pwm.h> 
     36 
     37#include <asm/mach-jz4740/platform.h> 
     38 
     39#include "clock.h" 
     40 
     41static bool is_avt2; 
     42 
     43/* GPIOs */ 
     44#define QI_LB60_GPIO_SD_CD              JZ_GPIO_PORTD(0) 
     45#define QI_LB60_GPIO_SD_VCC_EN_N        JZ_GPIO_PORTD(2) 
     46 
     47#define QI_LB60_GPIO_KEYOUT(x)          (JZ_GPIO_PORTC(10) + (x)) 
     48#define QI_LB60_GPIO_KEYIN(x)           (JZ_GPIO_PORTD(18) + (x)) 
     49#define QI_LB60_GPIO_KEYIN8             JZ_GPIO_PORTD(26) 
     50 
     51/* NAND */ 
     52static struct nand_ecclayout qi_lb60_ecclayout_1gb = { 
     53/*      .eccbytes = 36, 
     54        .eccpos = { 
     55                6,  7,  8,  9,  10, 11, 12, 13, 
     56                14, 15, 16, 17, 18, 19, 20, 21, 
     57                22, 23, 24, 25, 26, 27, 28, 29, 
     58                30, 31, 32, 33, 34, 35, 36, 37, 
     59                38, 39, 40, 41 
     60        },*/ 
     61        .oobfree = { 
     62                { .offset = 2, .length = 4 }, 
     63                { .offset = 42, .length = 22 } 
     64        }, 
     65}; 
     66 
     67/* Early prototypes of the QI LB60 had only 1GB of NAND. 
     68 * In order to support these devices aswell the partition and ecc layout is 
     69 * initalized depending on the NAND size */ 
     70static struct mtd_partition qi_lb60_partitions_1gb[] = { 
     71        { 
     72                .name = "NAND BOOT partition", 
     73                .offset = 0 * 0x100000, 
     74                .size = 4 * 0x100000, 
     75        }, 
     76        { 
     77                .name = "NAND KERNEL partition", 
     78                .offset = 4 * 0x100000, 
     79                .size = 4 * 0x100000, 
     80        }, 
     81        { 
     82                .name = "NAND ROOTFS partition", 
     83                .offset = 8 * 0x100000, 
     84                .size = (504 + 512) * 0x100000, 
     85        }, 
     86}; 
     87 
     88static struct nand_ecclayout qi_lb60_ecclayout_2gb = { 
     89/*      .eccbytes = 72, 
     90        .eccpos = { 
     91                12, 13, 14, 15, 16, 17, 18, 19, 
     92                20, 21, 22, 23, 24, 25, 26, 27, 
     93                28, 29, 30, 31, 32, 33, 34, 35, 
     94                36, 37, 38, 39, 40, 41, 42, 43, 
     95                44, 45, 46, 47, 48, 49, 50, 51, 
     96                52, 53, 54, 55, 56, 57, 58, 59, 
     97                60, 61, 62, 63, 64, 65, 66, 67, 
     98                68, 69, 70, 71, 72, 73, 74, 75, 
     99                76, 77, 78, 79, 80, 81, 82, 83 
     100        },*/ 
     101        .oobfree = { 
     102                { .offset = 2, .length = 10 }, 
     103                { .offset = 84, .length = 44 }, 
     104        }, 
     105}; 
     106 
     107static struct mtd_partition qi_lb60_partitions_2gb[] = { 
     108        { 
     109                .name = "NAND BOOT partition", 
     110                .offset = 0 * 0x100000, 
     111                .size = 4 * 0x100000, 
     112        }, 
     113        { 
     114                .name = "NAND KERNEL partition", 
     115                .offset = 4 * 0x100000, 
     116                .size = 4 * 0x100000, 
     117        }, 
     118        { 
     119                .name = "NAND ROOTFS partition", 
     120                .offset = 8 * 0x100000, 
     121                .size = (504 + 512 + 1024) * 0x100000, 
     122        }, 
     123}; 
     124 
     125static void qi_lb60_nand_ident(struct platform_device *pdev, 
     126                struct nand_chip *chip, struct mtd_partition **partitions, 
     127                int *num_partitions) 
     128{ 
     129        if (chip->page_shift == 12) { 
     130                chip->ecc.layout = &qi_lb60_ecclayout_2gb; 
     131                *partitions = qi_lb60_partitions_2gb; 
     132                *num_partitions = ARRAY_SIZE(qi_lb60_partitions_2gb); 
     133        } else { 
     134                chip->ecc.layout = &qi_lb60_ecclayout_1gb; 
     135                *partitions = qi_lb60_partitions_1gb; 
     136                *num_partitions = ARRAY_SIZE(qi_lb60_partitions_1gb); 
     137        } 
     138} 
     139 
     140static struct jz_nand_platform_data qi_lb60_nand_pdata = { 
     141        .ident_callback = qi_lb60_nand_ident, 
     142        .busy_gpio = 94, 
     143}; 
     144 
     145/* Keyboard*/ 
     146 
     147#define KEY_QI_QI       KEY_F13 
     148#define KEY_QI_UPRED    KEY_RIGHTALT 
     149#define KEY_QI_VOLUP    KEY_VOLUMEUP 
     150#define KEY_QI_VOLDOWN  KEY_VOLUMEDOWN 
     151#define KEY_QI_FN       KEY_LEFTCTRL 
     152 
     153static const uint32_t qi_lb60_keymap[] = { 
     154        KEY(0, 0, KEY_F1),      /* S2 */ 
     155        KEY(0, 1, KEY_F2),      /* S3 */ 
     156        KEY(0, 2, KEY_F3),      /* S4 */ 
     157        KEY(0, 3, KEY_F4),      /* S5 */ 
     158        KEY(0, 4, KEY_F5),      /* S6 */ 
     159        KEY(0, 5, KEY_F6),      /* S7 */ 
     160        KEY(0, 6, KEY_F7),      /* S8 */ 
     161 
     162        KEY(1, 0, KEY_Q),       /* S10 */ 
     163        KEY(1, 1, KEY_W),       /* S11 */ 
     164        KEY(1, 2, KEY_E),       /* S12 */ 
     165        KEY(1, 3, KEY_R),       /* S13 */ 
     166        KEY(1, 4, KEY_T),       /* S14 */ 
     167        KEY(1, 5, KEY_Y),       /* S15 */ 
     168        KEY(1, 6, KEY_U),       /* S16 */ 
     169        KEY(1, 7, KEY_I),       /* S17 */ 
     170        KEY(2, 0, KEY_A),       /* S18 */ 
     171        KEY(2, 1, KEY_S),       /* S19 */ 
     172        KEY(2, 2, KEY_D),       /* S20 */ 
     173        KEY(2, 3, KEY_F),       /* S21 */ 
     174        KEY(2, 4, KEY_G),       /* S22 */ 
     175        KEY(2, 5, KEY_H),       /* S23 */ 
     176        KEY(2, 6, KEY_J),       /* S24 */ 
     177        KEY(2, 7, KEY_K),       /* S25 */ 
     178        KEY(3, 0, KEY_ESC),     /* S26 */ 
     179        KEY(3, 1, KEY_Z),       /* S27 */ 
     180        KEY(3, 2, KEY_X),       /* S28 */ 
     181        KEY(3, 3, KEY_C),       /* S29 */ 
     182        KEY(3, 4, KEY_V),       /* S30 */ 
     183        KEY(3, 5, KEY_B),       /* S31 */ 
     184        KEY(3, 6, KEY_N),       /* S32 */ 
     185        KEY(3, 7, KEY_M),       /* S33 */ 
     186        KEY(4, 0, KEY_TAB),     /* S34 */ 
     187        KEY(4, 1, KEY_CAPSLOCK),        /* S35 */ 
     188        KEY(4, 2, KEY_BACKSLASH),       /* S36 */ 
     189        KEY(4, 3, KEY_APOSTROPHE),      /* S37 */ 
     190        KEY(4, 4, KEY_COMMA),   /* S38 */ 
     191        KEY(4, 5, KEY_DOT),     /* S39 */ 
     192        KEY(4, 6, KEY_SLASH),   /* S40 */ 
     193        KEY(4, 7, KEY_UP),      /* S41 */ 
     194        KEY(5, 0, KEY_O),       /* S42 */ 
     195        KEY(5, 1, KEY_L),       /* S43 */ 
     196        KEY(5, 2, KEY_EQUAL),   /* S44 */ 
     197        KEY(5, 3, KEY_QI_UPRED),        /* S45 */ 
     198        KEY(5, 4, KEY_SPACE),   /* S46 */ 
     199        KEY(5, 5, KEY_QI_QI),   /* S47 */ 
     200        KEY(5, 6, KEY_RIGHTCTRL),       /* S48 */ 
     201        KEY(5, 7, KEY_LEFT),    /* S49 */ 
     202        KEY(6, 0, KEY_F8),      /* S50 */ 
     203        KEY(6, 1, KEY_P),       /* S51 */ 
     204        KEY(6, 2, KEY_BACKSPACE),/* S52 */ 
     205        KEY(6, 3, KEY_ENTER),   /* S53 */ 
     206        KEY(6, 4, KEY_QI_VOLUP),        /* S54 */ 
     207        KEY(6, 5, KEY_QI_VOLDOWN),      /* S55 */ 
     208        KEY(6, 6, KEY_DOWN),    /* S56 */ 
     209        KEY(6, 7, KEY_RIGHT),   /* S57 */ 
     210 
     211        KEY(7, 0, KEY_LEFTSHIFT),       /* S58 */ 
     212        KEY(7, 1, KEY_LEFTALT), /* S59 */ 
     213        KEY(7, 2, KEY_QI_FN),   /* S60 */ 
     214}; 
     215 
     216static const struct matrix_keymap_data qi_lb60_keymap_data = { 
     217        .keymap         = qi_lb60_keymap, 
     218        .keymap_size    = ARRAY_SIZE(qi_lb60_keymap), 
     219}; 
     220 
     221static const unsigned int qi_lb60_keypad_cols[] = { 
     222        QI_LB60_GPIO_KEYOUT(0), 
     223        QI_LB60_GPIO_KEYOUT(1), 
     224        QI_LB60_GPIO_KEYOUT(2), 
     225        QI_LB60_GPIO_KEYOUT(3), 
     226        QI_LB60_GPIO_KEYOUT(4), 
     227        QI_LB60_GPIO_KEYOUT(5), 
     228        QI_LB60_GPIO_KEYOUT(6), 
     229        QI_LB60_GPIO_KEYOUT(7), 
     230}; 
     231 
     232static const unsigned int qi_lb60_keypad_rows[] = { 
     233        QI_LB60_GPIO_KEYIN(0), 
     234        QI_LB60_GPIO_KEYIN(1), 
     235        QI_LB60_GPIO_KEYIN(2), 
     236        QI_LB60_GPIO_KEYIN(3), 
     237        QI_LB60_GPIO_KEYIN(4), 
     238        QI_LB60_GPIO_KEYIN(5), 
     239        QI_LB60_GPIO_KEYIN(6), 
     240        QI_LB60_GPIO_KEYIN8, 
     241}; 
     242 
     243static struct matrix_keypad_platform_data qi_lb60_pdata = { 
     244        .keymap_data = &qi_lb60_keymap_data, 
     245        .col_gpios      = qi_lb60_keypad_cols, 
     246        .row_gpios      = qi_lb60_keypad_rows, 
     247        .num_col_gpios  = ARRAY_SIZE(qi_lb60_keypad_cols), 
     248        .num_row_gpios  = ARRAY_SIZE(qi_lb60_keypad_rows), 
     249        .col_scan_delay_us      = 10, 
     250        .debounce_ms            = 10, 
     251        .wakeup                 = 1, 
     252        .active_low             = 1, 
     253}; 
     254 
     255static struct platform_device qi_lb60_keypad = { 
     256        .name           = "matrix-keypad", 
     257        .id             = -1, 
     258        .dev            = { 
     259                .platform_data = &qi_lb60_pdata, 
     260        }, 
     261}; 
     262 
     263/* Display */ 
     264static struct fb_videomode qi_lb60_video_modes[] = { 
     265        { 
     266                .name = "320x240", 
     267                .xres = 320, 
     268                .yres = 240, 
     269                .refresh = 30, 
     270                .left_margin = 140, 
     271                .right_margin = 273, 
     272                .upper_margin = 20, 
     273                .lower_margin = 2, 
     274                .hsync_len = 1, 
     275                .vsync_len = 1, 
     276                .sync = 0, 
     277                .vmode = FB_VMODE_NONINTERLACED, 
     278        }, 
     279}; 
     280 
     281static struct jz4740_fb_platform_data qi_lb60_fb_pdata = { 
     282        .width          = 60, 
     283        .height         = 45, 
     284        .num_modes      = ARRAY_SIZE(qi_lb60_video_modes), 
     285        .modes          = qi_lb60_video_modes, 
     286        .bpp            = 24, 
     287        .lcd_type       = JZ_LCD_TYPE_8BIT_SERIAL, 
     288        .pixclk_falling_edge = 1, 
     289}; 
     290 
     291struct spi_gpio_platform_data spigpio_platform_data = { 
     292        .sck = JZ_GPIO_PORTC(23), 
     293        .mosi = JZ_GPIO_PORTC(22), 
     294        .miso = -1, 
     295        .num_chipselect = 1, 
     296}; 
     297 
     298static struct platform_device spigpio_device = { 
     299        .name = "spi_gpio", 
     300        .id   = 1, 
     301        .dev = { 
     302                .platform_data = &spigpio_platform_data, 
     303        }, 
     304}; 
     305 
     306static struct spi_board_info qi_lb60_spi_board_info[] = { 
     307        { 
     308                .modalias = "ili8960", 
     309                .controller_data = (void *)JZ_GPIO_PORTC(21), 
     310                .chip_select = 0, 
     311                .bus_num = 1, 
     312                .max_speed_hz = 30 * 1000, 
     313                .mode = SPI_3WIRE, 
     314        }, 
     315}; 
     316 
     317/* Battery */ 
     318static struct jz_battery_platform_data qi_lb60_battery_pdata = { 
     319        .gpio_charge =  JZ_GPIO_PORTC(27), 
     320        .gpio_charge_active_low = 1, 
     321        .info = { 
     322                .name = "battery", 
     323                .technology = POWER_SUPPLY_TECHNOLOGY_LIPO, 
     324                .voltage_max_design = 4200000, 
     325                .voltage_min_design = 3600000, 
     326        }, 
     327}; 
     328 
     329/* GPIO Key: power */ 
     330static struct gpio_keys_button qi_lb60_gpio_keys_buttons[] = { 
     331        [0] = { 
     332                .code           = KEY_POWER, 
     333                .gpio           = JZ_GPIO_PORTD(29), 
     334                .active_low     = 1, 
     335                .desc           = "Power", 
     336                .wakeup         = 1, 
     337        }, 
     338}; 
     339 
     340static struct gpio_keys_platform_data qi_lb60_gpio_keys_data = { 
     341        .nbuttons = ARRAY_SIZE(qi_lb60_gpio_keys_buttons), 
     342        .buttons = qi_lb60_gpio_keys_buttons, 
     343}; 
     344 
     345static struct platform_device qi_lb60_gpio_keys = { 
     346        .name = "gpio-keys", 
     347        .id =   -1, 
     348        .dev = { 
     349                .platform_data = &qi_lb60_gpio_keys_data, 
     350        } 
     351}; 
     352 
     353static struct jz4740_mmc_platform_data qi_lb60_mmc_pdata = { 
     354        .gpio_card_detect       = QI_LB60_GPIO_SD_CD, 
     355        .gpio_read_only         = -1, 
     356        .gpio_power             = QI_LB60_GPIO_SD_VCC_EN_N, 
     357        .power_active_low       = 1, 
     358}; 
     359 
     360/* OHCI */ 
     361static struct regulator_consumer_supply avt2_usb_regulator_consumer = 
     362        REGULATOR_SUPPLY("vbus", "jz4740-ohci"); 
     363 
     364static struct regulator_init_data avt2_usb_regulator_init_data = { 
     365        .num_consumer_supplies = 1, 
     366        .consumer_supplies = &avt2_usb_regulator_consumer, 
     367        .constraints = { 
     368                .name = "USB power", 
     369                .min_uV = 5000000, 
     370                .max_uV = 5000000, 
     371                .valid_modes_mask = REGULATOR_MODE_NORMAL, 
     372                .valid_ops_mask = REGULATOR_CHANGE_STATUS, 
     373        }, 
     374}; 
     375 
     376static struct fixed_voltage_config avt2_usb_regulator_data = { 
     377        .supply_name = "USB power", 
     378        .microvolts = 5000000, 
     379        .gpio = JZ_GPIO_PORTB(17), 
     380        .init_data = &avt2_usb_regulator_init_data, 
     381}; 
     382 
     383static struct platform_device avt2_usb_regulator_device = { 
     384        .name = "reg-fixed-voltage", 
     385        .id = -1, 
     386        .dev = { 
     387                .platform_data = &avt2_usb_regulator_data, 
     388        } 
     389}; 
     390 
     391/* beeper */ 
     392static struct platform_device qi_lb60_pwm_beeper = { 
     393        .name = "pwm-beeper", 
     394        .id = -1, 
     395        .dev = { 
     396                .platform_data = (void *)4, 
     397        }, 
     398}; 
     399 
     400/* charger */ 
     401static char *qi_lb60_batteries[] = { 
     402        "battery", 
     403}; 
     404 
     405static struct gpio_charger_platform_data qi_lb60_charger_pdata = { 
     406        .name = "usb", 
     407        .type = POWER_SUPPLY_TYPE_USB, 
     408        .gpio = JZ_GPIO_PORTD(28), 
     409        .gpio_active_low = 1, 
     410        .batteries = qi_lb60_batteries, 
     411        .num_batteries = ARRAY_SIZE(qi_lb60_batteries), 
     412}; 
     413 
     414static struct platform_device qi_lb60_charger_device = { 
     415        .name = "gpio-charger", 
     416        .dev = { 
     417                .platform_data = &qi_lb60_charger_pdata, 
     418        }, 
     419}; 
     420 
     421 
     422static struct platform_device *jz_platform_devices[] __initdata = { 
     423        &jz4740_udc_device, 
     424        &jz4740_mmc_device, 
     425        &jz4740_nand_device, 
     426        &qi_lb60_keypad, 
     427        &spigpio_device, 
     428        &jz4740_framebuffer_device, 
     429        &jz4740_pcm_device, 
     430        &jz4740_i2s_device, 
     431        &jz4740_codec_device, 
     432        &jz4740_rtc_device, 
     433        &jz4740_adc_device, 
     434        &qi_lb60_gpio_keys, 
     435        &qi_lb60_pwm_beeper, 
     436        &qi_lb60_charger_device, 
     437}; 
     438 
     439static void __init board_gpio_setup(void) 
     440{ 
     441        /* We only need to enable/disable pullup here for pins used in generic 
     442         * drivers. Everything else is done by the drivers themselfs. */ 
     443        jz_gpio_disable_pullup(QI_LB60_GPIO_SD_VCC_EN_N); 
     444        jz_gpio_disable_pullup(QI_LB60_GPIO_SD_CD); 
     445} 
     446 
     447static int __init qi_lb60_init_platform_devices(void) 
     448{ 
     449        jz4740_framebuffer_device.dev.platform_data = &qi_lb60_fb_pdata; 
     450        jz4740_nand_device.dev.platform_data = &qi_lb60_nand_pdata; 
     451        jz4740_adc_device.dev.platform_data = &qi_lb60_battery_pdata; 
     452        jz4740_mmc_device.dev.platform_data = &qi_lb60_mmc_pdata; 
     453 
     454        jz4740_serial_device_register(); 
     455 
     456        spi_register_board_info(qi_lb60_spi_board_info, 
     457                                ARRAY_SIZE(qi_lb60_spi_board_info)); 
     458 
     459        if (is_avt2) { 
     460                platform_device_register(&avt2_usb_regulator_device); 
     461                platform_device_register(&jz4740_usb_ohci_device); 
     462        } 
     463 
     464        return platform_add_devices(jz_platform_devices, 
     465                                        ARRAY_SIZE(jz_platform_devices)); 
     466 
     467} 
     468 
     469struct jz4740_clock_board_data jz4740_clock_bdata = { 
     470        .ext_rate = 12000000, 
     471        .rtc_rate = 32768, 
     472}; 
     473 
     474static __init int board_avt2(char *str) 
     475{ 
     476        qi_lb60_mmc_pdata.card_detect_active_low = 1; 
     477        is_avt2 = true; 
     478 
     479        return 1; 
     480} 
     481__setup("avt2", board_avt2); 
     482 
     483static int __init qi_lb60_board_setup(void) 
     484{ 
     485        printk(KERN_INFO "Qi Hardware JZ4740 QI %s setup\n", 
     486                is_avt2 ? "AVT2" : "LB60"); 
     487 
     488        board_gpio_setup(); 
     489 
     490        if (qi_lb60_init_platform_devices()) 
     491                panic("Failed to initalize platform devices\n"); 
     492 
     493        return 0; 
     494} 
     495arch_initcall(qi_lb60_board_setup); 
Note: See TracBrowser for help on using the repository browser.