Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 //
0003 // Copyright 2008 Openmoko, Inc.
0004 // Copyright 2008 Simtec Electronics
0005 //  Ben Dooks <ben@simtec.co.uk>
0006 //  http://armlinux.simtec.co.uk/
0007 
0008 #include <linux/kernel.h>
0009 #include <linux/types.h>
0010 #include <linux/interrupt.h>
0011 #include <linux/list.h>
0012 #include <linux/timer.h>
0013 #include <linux/init.h>
0014 #include <linux/input.h>
0015 #include <linux/serial_core.h>
0016 #include <linux/serial_s3c.h>
0017 #include <linux/platform_device.h>
0018 #include <linux/io.h>
0019 #include <linux/i2c.h>
0020 #include <linux/leds.h>
0021 #include <linux/fb.h>
0022 #include <linux/gpio.h>
0023 #include <linux/delay.h>
0024 #include <linux/smsc911x.h>
0025 #include <linux/regulator/fixed.h>
0026 #include <linux/regulator/machine.h>
0027 #include <linux/pwm.h>
0028 #include <linux/pwm_backlight.h>
0029 #include <linux/platform_data/s3c-hsotg.h>
0030 
0031 #ifdef CONFIG_SMDK6410_WM1190_EV1
0032 #include <linux/mfd/wm8350/core.h>
0033 #include <linux/mfd/wm8350/pmic.h>
0034 #endif
0035 
0036 #ifdef CONFIG_SMDK6410_WM1192_EV1
0037 #include <linux/mfd/wm831x/core.h>
0038 #include <linux/mfd/wm831x/pdata.h>
0039 #endif
0040 
0041 #include <video/platform_lcd.h>
0042 #include <video/samsung_fimd.h>
0043 
0044 #include <asm/mach/arch.h>
0045 #include <asm/mach/map.h>
0046 #include <asm/mach/irq.h>
0047 
0048 #include "irqs.h"
0049 #include "map.h"
0050 
0051 #include <asm/irq.h>
0052 #include <asm/mach-types.h>
0053 
0054 #include "regs-gpio.h"
0055 #include "gpio-samsung.h"
0056 #include <linux/platform_data/ata-samsung_cf.h>
0057 #include <linux/platform_data/i2c-s3c2410.h>
0058 #include "fb.h"
0059 #include "gpio-cfg.h"
0060 
0061 #include "devs.h"
0062 #include "cpu.h"
0063 #include <linux/soc/samsung/s3c-adc.h>
0064 #include <linux/platform_data/touchscreen-s3c2410.h>
0065 #include "keypad.h"
0066 
0067 #include "backlight-s3c64xx.h"
0068 #include "s3c64xx.h"
0069 #include "regs-modem-s3c64xx.h"
0070 #include "regs-srom-s3c64xx.h"
0071 #include "regs-sys-s3c64xx.h"
0072 
0073 #define UCON S3C2410_UCON_DEFAULT | S3C2410_UCON_UCLK
0074 #define ULCON S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB
0075 #define UFCON S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_FIFOMODE
0076 
0077 static struct s3c2410_uartcfg smdk6410_uartcfgs[] __initdata = {
0078     [0] = {
0079         .hwport      = 0,
0080         .flags       = 0,
0081         .ucon        = UCON,
0082         .ulcon       = ULCON,
0083         .ufcon       = UFCON,
0084     },
0085     [1] = {
0086         .hwport      = 1,
0087         .flags       = 0,
0088         .ucon        = UCON,
0089         .ulcon       = ULCON,
0090         .ufcon       = UFCON,
0091     },
0092     [2] = {
0093         .hwport      = 2,
0094         .flags       = 0,
0095         .ucon        = UCON,
0096         .ulcon       = ULCON,
0097         .ufcon       = UFCON,
0098     },
0099     [3] = {
0100         .hwport      = 3,
0101         .flags       = 0,
0102         .ucon        = UCON,
0103         .ulcon       = ULCON,
0104         .ufcon       = UFCON,
0105     },
0106 };
0107 
0108 /* framebuffer and LCD setup. */
0109 
0110 /* GPF15 = LCD backlight control
0111  * GPF13 => Panel power
0112  * GPN5 = LCD nRESET signal
0113  * PWM_TOUT1 => backlight brightness
0114  */
0115 
0116 static void smdk6410_lcd_power_set(struct plat_lcd_data *pd,
0117                    unsigned int power)
0118 {
0119     if (power) {
0120         gpio_direction_output(S3C64XX_GPF(13), 1);
0121 
0122         /* fire nRESET on power up */
0123         gpio_direction_output(S3C64XX_GPN(5), 0);
0124         msleep(10);
0125         gpio_direction_output(S3C64XX_GPN(5), 1);
0126         msleep(1);
0127     } else {
0128         gpio_direction_output(S3C64XX_GPF(13), 0);
0129     }
0130 }
0131 
0132 static struct plat_lcd_data smdk6410_lcd_power_data = {
0133     .set_power  = smdk6410_lcd_power_set,
0134 };
0135 
0136 static struct platform_device smdk6410_lcd_powerdev = {
0137     .name           = "platform-lcd",
0138     .dev.parent     = &s3c_device_fb.dev,
0139     .dev.platform_data  = &smdk6410_lcd_power_data,
0140 };
0141 
0142 static struct s3c_fb_pd_win smdk6410_fb_win0 = {
0143     .max_bpp    = 32,
0144     .default_bpp    = 16,
0145     .xres       = 800,
0146     .yres       = 480,
0147     .virtual_y  = 480 * 2,
0148     .virtual_x  = 800,
0149 };
0150 
0151 static struct fb_videomode smdk6410_lcd_timing = {
0152     .left_margin    = 8,
0153     .right_margin   = 13,
0154     .upper_margin   = 7,
0155     .lower_margin   = 5,
0156     .hsync_len  = 3,
0157     .vsync_len  = 1,
0158     .xres       = 800,
0159     .yres       = 480,
0160 };
0161 
0162 /* 405566 clocks per frame => 60Hz refresh requires 24333960Hz clock */
0163 static struct s3c_fb_platdata smdk6410_lcd_pdata __initdata = {
0164     .setup_gpio = s3c64xx_fb_gpio_setup_24bpp,
0165     .vtiming    = &smdk6410_lcd_timing,
0166     .win[0]     = &smdk6410_fb_win0,
0167     .vidcon0    = VIDCON0_VIDOUT_RGB | VIDCON0_PNRMODE_RGB,
0168     .vidcon1    = VIDCON1_INV_HSYNC | VIDCON1_INV_VSYNC,
0169 };
0170 
0171 /*
0172  * Configuring Ethernet on SMDK6410
0173  *
0174  * Both CS8900A and LAN9115 chips share one chip select mediated by CFG6.
0175  * The constant address below corresponds to nCS1
0176  *
0177  *  1) Set CFGB2 p3 ON others off, no other CFGB selects "ethernet"
0178  *  2) CFG6 needs to be switched to "LAN9115" side
0179  */
0180 
0181 static struct resource smdk6410_smsc911x_resources[] = {
0182     [0] = DEFINE_RES_MEM(S3C64XX_PA_XM0CSN1, SZ_64K),
0183     [1] = DEFINE_RES_NAMED(S3C_EINT(10), 1, NULL, IORESOURCE_IRQ \
0184                     | IRQ_TYPE_LEVEL_LOW),
0185 };
0186 
0187 static struct smsc911x_platform_config smdk6410_smsc911x_pdata = {
0188     .irq_polarity  = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
0189     .irq_type      = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
0190     .flags         = SMSC911X_USE_32BIT | SMSC911X_FORCE_INTERNAL_PHY,
0191     .phy_interface = PHY_INTERFACE_MODE_MII,
0192 };
0193 
0194 
0195 static struct platform_device smdk6410_smsc911x = {
0196     .name          = "smsc911x",
0197     .id            = -1,
0198     .num_resources = ARRAY_SIZE(smdk6410_smsc911x_resources),
0199     .resource      = &smdk6410_smsc911x_resources[0],
0200     .dev = {
0201         .platform_data = &smdk6410_smsc911x_pdata,
0202     },
0203 };
0204 
0205 #ifdef CONFIG_REGULATOR
0206 static struct regulator_consumer_supply smdk6410_b_pwr_5v_consumers[] = {
0207     REGULATOR_SUPPLY("PVDD", "0-001b"),
0208     REGULATOR_SUPPLY("AVDD", "0-001b"),
0209 };
0210 
0211 static struct regulator_init_data __maybe_unused smdk6410_b_pwr_5v_data = {
0212     .constraints = {
0213         .always_on = 1,
0214     },
0215     .num_consumer_supplies = ARRAY_SIZE(smdk6410_b_pwr_5v_consumers),
0216     .consumer_supplies = smdk6410_b_pwr_5v_consumers,
0217 };
0218 
0219 static struct fixed_voltage_config smdk6410_b_pwr_5v_pdata = {
0220     .supply_name = "B_PWR_5V",
0221     .microvolts = 5000000,
0222     .init_data = &smdk6410_b_pwr_5v_data,
0223 };
0224 
0225 static struct platform_device smdk6410_b_pwr_5v = {
0226     .name          = "reg-fixed-voltage",
0227     .id            = -1,
0228     .dev = {
0229         .platform_data = &smdk6410_b_pwr_5v_pdata,
0230     },
0231 };
0232 #endif
0233 
0234 static struct s3c_ide_platdata smdk6410_ide_pdata __initdata = {
0235     .setup_gpio = s3c64xx_ide_setup_gpio,
0236 };
0237 
0238 static uint32_t smdk6410_keymap[] __initdata = {
0239     /* KEY(row, col, keycode) */
0240     KEY(0, 3, KEY_1), KEY(0, 4, KEY_2), KEY(0, 5, KEY_3),
0241     KEY(0, 6, KEY_4), KEY(0, 7, KEY_5),
0242     KEY(1, 3, KEY_A), KEY(1, 4, KEY_B), KEY(1, 5, KEY_C),
0243     KEY(1, 6, KEY_D), KEY(1, 7, KEY_E)
0244 };
0245 
0246 static struct matrix_keymap_data smdk6410_keymap_data __initdata = {
0247     .keymap     = smdk6410_keymap,
0248     .keymap_size    = ARRAY_SIZE(smdk6410_keymap),
0249 };
0250 
0251 static struct samsung_keypad_platdata smdk6410_keypad_data __initdata = {
0252     .keymap_data    = &smdk6410_keymap_data,
0253     .rows       = 2,
0254     .cols       = 8,
0255 };
0256 
0257 static struct map_desc smdk6410_iodesc[] = {};
0258 
0259 static struct platform_device *smdk6410_devices[] __initdata = {
0260 #ifdef CONFIG_SMDK6410_SD_CH0
0261     &s3c_device_hsmmc0,
0262 #endif
0263 #ifdef CONFIG_SMDK6410_SD_CH1
0264     &s3c_device_hsmmc1,
0265 #endif
0266     &s3c_device_i2c0,
0267     &s3c_device_i2c1,
0268     &s3c_device_fb,
0269     &s3c_device_ohci,
0270     &samsung_device_pwm,
0271     &s3c_device_usb_hsotg,
0272     &s3c64xx_device_iisv4,
0273     &samsung_device_keypad,
0274 
0275 #ifdef CONFIG_REGULATOR
0276     &smdk6410_b_pwr_5v,
0277 #endif
0278     &smdk6410_lcd_powerdev,
0279 
0280     &smdk6410_smsc911x,
0281     &s3c_device_adc,
0282     &s3c_device_cfcon,
0283     &s3c_device_rtc,
0284     &s3c_device_wdt,
0285 };
0286 
0287 #ifdef CONFIG_REGULATOR
0288 /* ARM core */
0289 static struct regulator_consumer_supply smdk6410_vddarm_consumers[] = {
0290     REGULATOR_SUPPLY("vddarm", NULL),
0291 };
0292 
0293 /* VDDARM, BUCK1 on J5 */
0294 static struct regulator_init_data __maybe_unused smdk6410_vddarm = {
0295     .constraints = {
0296         .name = "PVDD_ARM",
0297         .min_uV = 1000000,
0298         .max_uV = 1300000,
0299         .always_on = 1,
0300         .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
0301     },
0302     .num_consumer_supplies = ARRAY_SIZE(smdk6410_vddarm_consumers),
0303     .consumer_supplies = smdk6410_vddarm_consumers,
0304 };
0305 
0306 /* VDD_INT, BUCK2 on J5 */
0307 static struct regulator_init_data __maybe_unused smdk6410_vddint = {
0308     .constraints = {
0309         .name = "PVDD_INT",
0310         .min_uV = 1000000,
0311         .max_uV = 1200000,
0312         .always_on = 1,
0313         .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
0314     },
0315 };
0316 
0317 /* VDD_HI, LDO3 on J5 */
0318 static struct regulator_init_data __maybe_unused smdk6410_vddhi = {
0319     .constraints = {
0320         .name = "PVDD_HI",
0321         .always_on = 1,
0322     },
0323 };
0324 
0325 /* VDD_PLL, LDO2 on J5 */
0326 static struct regulator_init_data __maybe_unused smdk6410_vddpll = {
0327     .constraints = {
0328         .name = "PVDD_PLL",
0329         .always_on = 1,
0330     },
0331 };
0332 
0333 /* VDD_UH_MMC, LDO5 on J5 */
0334 static struct regulator_init_data __maybe_unused smdk6410_vdduh_mmc = {
0335     .constraints = {
0336         .name = "PVDD_UH+PVDD_MMC",
0337         .always_on = 1,
0338     },
0339 };
0340 
0341 /* VCCM3BT, LDO8 on J5 */
0342 static struct regulator_init_data __maybe_unused smdk6410_vccmc3bt = {
0343     .constraints = {
0344         .name = "PVCCM3BT",
0345         .always_on = 1,
0346     },
0347 };
0348 
0349 /* VCCM2MTV, LDO11 on J5 */
0350 static struct regulator_init_data __maybe_unused smdk6410_vccm2mtv = {
0351     .constraints = {
0352         .name = "PVCCM2MTV",
0353         .always_on = 1,
0354     },
0355 };
0356 
0357 /* VDD_LCD, LDO12 on J5 */
0358 static struct regulator_init_data __maybe_unused smdk6410_vddlcd = {
0359     .constraints = {
0360         .name = "PVDD_LCD",
0361         .always_on = 1,
0362     },
0363 };
0364 
0365 /* VDD_OTGI, LDO9 on J5 */
0366 static struct regulator_init_data __maybe_unused smdk6410_vddotgi = {
0367     .constraints = {
0368         .name = "PVDD_OTGI",
0369         .always_on = 1,
0370     },
0371 };
0372 
0373 /* VDD_OTG, LDO14 on J5 */
0374 static struct regulator_init_data __maybe_unused smdk6410_vddotg = {
0375     .constraints = {
0376         .name = "PVDD_OTG",
0377         .always_on = 1,
0378     },
0379 };
0380 
0381 /* VDD_ALIVE, LDO15 on J5 */
0382 static struct regulator_init_data __maybe_unused smdk6410_vddalive = {
0383     .constraints = {
0384         .name = "PVDD_ALIVE",
0385         .always_on = 1,
0386     },
0387 };
0388 
0389 /* VDD_AUDIO, VLDO_AUDIO on J5 */
0390 static struct regulator_init_data __maybe_unused smdk6410_vddaudio = {
0391     .constraints = {
0392         .name = "PVDD_AUDIO",
0393         .always_on = 1,
0394     },
0395 };
0396 #endif
0397 
0398 #ifdef CONFIG_SMDK6410_WM1190_EV1
0399 /* S3C64xx internal logic & PLL */
0400 static struct regulator_init_data __maybe_unused wm8350_dcdc1_data = {
0401     .constraints = {
0402         .name = "PVDD_INT+PVDD_PLL",
0403         .min_uV = 1200000,
0404         .max_uV = 1200000,
0405         .always_on = 1,
0406         .apply_uV = 1,
0407     },
0408 };
0409 
0410 /* Memory */
0411 static struct regulator_init_data __maybe_unused wm8350_dcdc3_data = {
0412     .constraints = {
0413         .name = "PVDD_MEM",
0414         .min_uV = 1800000,
0415         .max_uV = 1800000,
0416         .always_on = 1,
0417         .state_mem = {
0418              .uV = 1800000,
0419              .mode = REGULATOR_MODE_NORMAL,
0420              .enabled = 1,
0421         },
0422         .initial_state = PM_SUSPEND_MEM,
0423     },
0424 };
0425 
0426 /* USB, EXT, PCM, ADC/DAC, USB, MMC */
0427 static struct regulator_consumer_supply wm8350_dcdc4_consumers[] = {
0428     REGULATOR_SUPPLY("DVDD", "0-001b"),
0429 };
0430 
0431 static struct regulator_init_data __maybe_unused wm8350_dcdc4_data = {
0432     .constraints = {
0433         .name = "PVDD_HI+PVDD_EXT+PVDD_SYS+PVCCM2MTV",
0434         .min_uV = 3000000,
0435         .max_uV = 3000000,
0436         .always_on = 1,
0437     },
0438     .num_consumer_supplies = ARRAY_SIZE(wm8350_dcdc4_consumers),
0439     .consumer_supplies = wm8350_dcdc4_consumers,
0440 };
0441 
0442 /* OTGi/1190-EV1 HPVDD & AVDD */
0443 static struct regulator_init_data __maybe_unused wm8350_ldo4_data = {
0444     .constraints = {
0445         .name = "PVDD_OTGI+HPVDD+AVDD",
0446         .min_uV = 1200000,
0447         .max_uV = 1200000,
0448         .apply_uV = 1,
0449         .always_on = 1,
0450     },
0451 };
0452 
0453 static struct {
0454     int regulator;
0455     struct regulator_init_data *initdata;
0456 } wm1190_regulators[] = {
0457     { WM8350_DCDC_1, &wm8350_dcdc1_data },
0458     { WM8350_DCDC_3, &wm8350_dcdc3_data },
0459     { WM8350_DCDC_4, &wm8350_dcdc4_data },
0460     { WM8350_DCDC_6, &smdk6410_vddarm },
0461     { WM8350_LDO_1, &smdk6410_vddalive },
0462     { WM8350_LDO_2, &smdk6410_vddotg },
0463     { WM8350_LDO_3, &smdk6410_vddlcd },
0464     { WM8350_LDO_4, &wm8350_ldo4_data },
0465 };
0466 
0467 static int __init smdk6410_wm8350_init(struct wm8350 *wm8350)
0468 {
0469     int i;
0470 
0471     /* Configure the IRQ line */
0472     s3c_gpio_setpull(S3C64XX_GPN(12), S3C_GPIO_PULL_UP);
0473 
0474     /* Instantiate the regulators */
0475     for (i = 0; i < ARRAY_SIZE(wm1190_regulators); i++)
0476         wm8350_register_regulator(wm8350,
0477                       wm1190_regulators[i].regulator,
0478                       wm1190_regulators[i].initdata);
0479 
0480     return 0;
0481 }
0482 
0483 static struct wm8350_platform_data __initdata smdk6410_wm8350_pdata = {
0484     .init = smdk6410_wm8350_init,
0485     .irq_high = 1,
0486     .irq_base = IRQ_BOARD_START,
0487 };
0488 #endif
0489 
0490 #ifdef CONFIG_SMDK6410_WM1192_EV1
0491 static struct gpio_led wm1192_pmic_leds[] = {
0492     {
0493         .name = "PMIC:red:power",
0494         .gpio = GPIO_BOARD_START + 3,
0495         .default_state = LEDS_GPIO_DEFSTATE_ON,
0496     },
0497 };
0498 
0499 static struct gpio_led_platform_data wm1192_pmic_led = {
0500     .num_leds = ARRAY_SIZE(wm1192_pmic_leds),
0501     .leds = wm1192_pmic_leds,
0502 };
0503 
0504 static struct platform_device wm1192_pmic_led_dev = {
0505     .name          = "leds-gpio",
0506     .id            = -1,
0507     .dev = {
0508         .platform_data = &wm1192_pmic_led,
0509     },
0510 };
0511 
0512 static int wm1192_pre_init(struct wm831x *wm831x)
0513 {
0514     int ret;
0515 
0516     /* Configure the IRQ line */
0517     s3c_gpio_setpull(S3C64XX_GPN(12), S3C_GPIO_PULL_UP);
0518 
0519     ret = platform_device_register(&wm1192_pmic_led_dev);
0520     if (ret != 0)
0521         dev_err(wm831x->dev, "Failed to add PMIC LED: %d\n", ret);
0522 
0523     return 0;
0524 }
0525 
0526 static struct wm831x_backlight_pdata wm1192_backlight_pdata = {
0527     .isink = 1,
0528     .max_uA = 27554,
0529 };
0530 
0531 static struct regulator_init_data __maybe_unused wm1192_dcdc3 = {
0532     .constraints = {
0533         .name = "PVDD_MEM+PVDD_GPS",
0534         .always_on = 1,
0535     },
0536 };
0537 
0538 static struct regulator_consumer_supply wm1192_ldo1_consumers[] = {
0539     REGULATOR_SUPPLY("DVDD", "0-001b"),   /* WM8580 */
0540 };
0541 
0542 static struct regulator_init_data __maybe_unused wm1192_ldo1 = {
0543     .constraints = {
0544         .name = "PVDD_LCD+PVDD_EXT",
0545         .always_on = 1,
0546     },
0547     .consumer_supplies = wm1192_ldo1_consumers,
0548     .num_consumer_supplies = ARRAY_SIZE(wm1192_ldo1_consumers),
0549 };
0550 
0551 static struct wm831x_status_pdata wm1192_led7_pdata = {
0552     .name = "LED7:green:",
0553 };
0554 
0555 static struct wm831x_status_pdata wm1192_led8_pdata = {
0556     .name = "LED8:green:",
0557 };
0558 
0559 static struct wm831x_pdata smdk6410_wm1192_pdata = {
0560     .pre_init = wm1192_pre_init,
0561 
0562     .backlight = &wm1192_backlight_pdata,
0563     .dcdc = {
0564         &smdk6410_vddarm,  /* DCDC1 */
0565         &smdk6410_vddint,  /* DCDC2 */
0566         &wm1192_dcdc3,
0567     },
0568     .gpio_base = GPIO_BOARD_START,
0569     .ldo = {
0570          &wm1192_ldo1,        /* LDO1 */
0571          &smdk6410_vdduh_mmc, /* LDO2 */
0572          NULL,                /* LDO3 NC */
0573          &smdk6410_vddotgi,   /* LDO4 */
0574          &smdk6410_vddotg,    /* LDO5 */
0575          &smdk6410_vddhi,     /* LDO6 */
0576          &smdk6410_vddaudio,  /* LDO7 */
0577          &smdk6410_vccm2mtv,  /* LDO8 */
0578          &smdk6410_vddpll,    /* LDO9 */
0579          &smdk6410_vccmc3bt,  /* LDO10 */
0580          &smdk6410_vddalive,  /* LDO11 */
0581     },
0582     .status = {
0583         &wm1192_led7_pdata,
0584         &wm1192_led8_pdata,
0585     },
0586 };
0587 #endif
0588 
0589 static struct i2c_board_info i2c_devs0[] __initdata = {
0590     { I2C_BOARD_INFO("24c08", 0x50), },
0591     { I2C_BOARD_INFO("wm8580", 0x1b), },
0592 
0593 #ifdef CONFIG_SMDK6410_WM1192_EV1
0594     { I2C_BOARD_INFO("wm8312", 0x34),
0595       .platform_data = &smdk6410_wm1192_pdata,
0596       .irq = S3C_EINT(12),
0597     },
0598 #endif
0599 
0600 #ifdef CONFIG_SMDK6410_WM1190_EV1
0601     { I2C_BOARD_INFO("wm8350", 0x1a),
0602       .platform_data = &smdk6410_wm8350_pdata,
0603       .irq = S3C_EINT(12),
0604     },
0605 #endif
0606 };
0607 
0608 static struct i2c_board_info i2c_devs1[] __initdata = {
0609     { I2C_BOARD_INFO("24c128", 0x57), },    /* Samsung S524AD0XD1 */
0610 };
0611 
0612 /* LCD Backlight data */
0613 static struct samsung_bl_gpio_info smdk6410_bl_gpio_info = {
0614     .no = S3C64XX_GPF(15),
0615     .func = S3C_GPIO_SFN(2),
0616 };
0617 
0618 static struct pwm_lookup smdk6410_pwm_lookup[] = {
0619     PWM_LOOKUP("samsung-pwm", 1, "pwm-backlight.0", NULL, 78770,
0620            PWM_POLARITY_NORMAL),
0621 };
0622 
0623 static struct platform_pwm_backlight_data smdk6410_bl_data = {
0624     /* Intentionally blank */
0625 };
0626 
0627 static struct dwc2_hsotg_plat smdk6410_hsotg_pdata;
0628 
0629 static void __init smdk6410_map_io(void)
0630 {
0631     u32 tmp;
0632 
0633     s3c64xx_init_io(smdk6410_iodesc, ARRAY_SIZE(smdk6410_iodesc));
0634     s3c64xx_set_xtal_freq(12000000);
0635     s3c24xx_init_uarts(smdk6410_uartcfgs, ARRAY_SIZE(smdk6410_uartcfgs));
0636     s3c64xx_set_timer_source(S3C64XX_PWM3, S3C64XX_PWM4);
0637 
0638     /* set the LCD type */
0639 
0640     tmp = __raw_readl(S3C64XX_SPCON);
0641     tmp &= ~S3C64XX_SPCON_LCD_SEL_MASK;
0642     tmp |= S3C64XX_SPCON_LCD_SEL_RGB;
0643     __raw_writel(tmp, S3C64XX_SPCON);
0644 
0645     /* remove the lcd bypass */
0646     tmp = __raw_readl(S3C64XX_MODEM_MIFPCON);
0647     tmp &= ~MIFPCON_LCD_BYPASS;
0648     __raw_writel(tmp, S3C64XX_MODEM_MIFPCON);
0649 }
0650 
0651 static void __init smdk6410_machine_init(void)
0652 {
0653     u32 cs1;
0654 
0655     s3c_i2c0_set_platdata(NULL);
0656     s3c_i2c1_set_platdata(NULL);
0657     s3c_fb_set_platdata(&smdk6410_lcd_pdata);
0658     dwc2_hsotg_set_platdata(&smdk6410_hsotg_pdata);
0659 
0660     samsung_keypad_set_platdata(&smdk6410_keypad_data);
0661 
0662     s3c64xx_ts_set_platdata(NULL);
0663 
0664     /* configure nCS1 width to 16 bits */
0665 
0666     cs1 = __raw_readl(S3C64XX_SROM_BW) &
0667             ~(S3C64XX_SROM_BW__CS_MASK << S3C64XX_SROM_BW__NCS1__SHIFT);
0668     cs1 |= ((1 << S3C64XX_SROM_BW__DATAWIDTH__SHIFT) |
0669         (1 << S3C64XX_SROM_BW__WAITENABLE__SHIFT) |
0670         (1 << S3C64XX_SROM_BW__BYTEENABLE__SHIFT)) <<
0671                            S3C64XX_SROM_BW__NCS1__SHIFT;
0672     __raw_writel(cs1, S3C64XX_SROM_BW);
0673 
0674     /* set timing for nCS1 suitable for ethernet chip */
0675 
0676     __raw_writel((0 << S3C64XX_SROM_BCX__PMC__SHIFT) |
0677              (6 << S3C64XX_SROM_BCX__TACP__SHIFT) |
0678              (4 << S3C64XX_SROM_BCX__TCAH__SHIFT) |
0679              (1 << S3C64XX_SROM_BCX__TCOH__SHIFT) |
0680              (0xe << S3C64XX_SROM_BCX__TACC__SHIFT) |
0681              (4 << S3C64XX_SROM_BCX__TCOS__SHIFT) |
0682              (0 << S3C64XX_SROM_BCX__TACS__SHIFT), S3C64XX_SROM_BC1);
0683 
0684     gpio_request(S3C64XX_GPN(5), "LCD power");
0685     gpio_request(S3C64XX_GPF(13), "LCD power");
0686 
0687     i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
0688     i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));
0689 
0690     s3c_ide_set_platdata(&smdk6410_ide_pdata);
0691 
0692     platform_add_devices(smdk6410_devices, ARRAY_SIZE(smdk6410_devices));
0693 
0694     pwm_add_table(smdk6410_pwm_lookup, ARRAY_SIZE(smdk6410_pwm_lookup));
0695     samsung_bl_set(&smdk6410_bl_gpio_info, &smdk6410_bl_data);
0696 }
0697 
0698 MACHINE_START(SMDK6410, "SMDK6410")
0699     /* Maintainer: Ben Dooks <ben-linux@fluff.org> */
0700     .atag_offset    = 0x100,
0701     .nr_irqs    = S3C64XX_NR_IRQS,
0702     .init_irq   = s3c6410_init_irq,
0703     .map_io     = smdk6410_map_io,
0704     .init_machine   = smdk6410_machine_init,
0705     .init_time  = s3c64xx_timer_init,
0706 MACHINE_END
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!