1/* 2 * linux/arch/arm/mach-s3c64xx/mach-smartq.c 3 * 4 * Copyright (C) 2010 Maurus Cuelenaere 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 12#include <linux/delay.h> 13#include <linux/fb.h> 14#include <linux/gpio.h> 15#include <linux/init.h> 16#include <linux/platform_device.h> 17#include <linux/pwm_backlight.h> 18#include <linux/serial_core.h> 19#include <linux/spi/spi_gpio.h> 20#include <linux/usb/gpio_vbus.h> 21 22#include <asm/mach-types.h> 23#include <asm/mach/map.h> 24 25#include <mach/map.h> 26#include <mach/regs-gpio.h> 27#include <mach/regs-modem.h> 28 29#include <plat/clock.h> 30#include <plat/cpu.h> 31#include <plat/devs.h> 32#include <plat/iic.h> 33#include <plat/gpio-cfg.h> 34#include <plat/hwmon.h> 35#include <plat/regs-serial.h> 36#include <plat/udc-hs.h> 37#include <plat/usb-control.h> 38#include <plat/sdhci.h> 39#include <plat/ts.h> 40 41#include <video/platform_lcd.h> 42 43#include "common.h" 44 45#define UCON S3C2410_UCON_DEFAULT 46#define ULCON (S3C2410_LCON_CS8 | S3C2410_LCON_PNONE) 47#define UFCON (S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_FIFOMODE) 48 49static struct s3c2410_uartcfg smartq_uartcfgs[] __initdata = { 50 [0] = { 51 .hwport = 0, 52 .flags = 0, 53 .ucon = UCON, 54 .ulcon = ULCON, 55 .ufcon = UFCON, 56 }, 57 [1] = { 58 .hwport = 1, 59 .flags = 0, 60 .ucon = UCON, 61 .ulcon = ULCON, 62 .ufcon = UFCON, 63 }, 64 [2] = { 65 .hwport = 2, 66 .flags = 0, 67 .ucon = UCON, 68 .ulcon = ULCON, 69 .ufcon = UFCON, 70 }, 71}; 72 73static void smartq_usb_host_powercontrol(int port, int to) 74{ 75 pr_debug("%s(%d, %d)\n", __func__, port, to); 76 77 if (port == 0) { 78 gpio_set_value(S3C64XX_GPL(0), to); 79 gpio_set_value(S3C64XX_GPL(1), to); 80 } 81} 82 83static irqreturn_t smartq_usb_host_ocirq(int irq, void *pw) 84{ 85 struct s3c2410_hcd_info *info = pw; 86 87 if (gpio_get_value(S3C64XX_GPL(10)) == 0) { 88 pr_debug("%s: over-current irq (oc detected)\n", __func__); 89 s3c2410_usb_report_oc(info, 3); 90 } else { 91 pr_debug("%s: over-current irq (oc cleared)\n", __func__); 92 s3c2410_usb_report_oc(info, 0); 93 } 94 95 return IRQ_HANDLED; 96} 97 98static void smartq_usb_host_enableoc(struct s3c2410_hcd_info *info, int on) 99{ 100 int ret; 101 102 /* This isn't present on a SmartQ 5 board */ 103 if (machine_is_smartq5()) 104 return; 105 106 if (on) { 107 ret = request_irq(gpio_to_irq(S3C64XX_GPL(10)), 108 smartq_usb_host_ocirq, IRQF_DISABLED | 109 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, 110 "USB host overcurrent", info); 111 if (ret != 0) 112 pr_err("failed to request usb oc irq: %d\n", ret); 113 } else { 114 free_irq(gpio_to_irq(S3C64XX_GPL(10)), info); 115 } 116} 117 118static struct s3c2410_hcd_info smartq_usb_host_info = { 119 .port[0] = { 120 .flags = S3C_HCDFLG_USED 121 }, 122 .port[1] = { 123 .flags = 0 124 }, 125 126 .power_control = smartq_usb_host_powercontrol, 127 .enable_oc = smartq_usb_host_enableoc, 128}; 129 130static struct gpio_vbus_mach_info smartq_usb_otg_vbus_pdata = { 131 .gpio_vbus = S3C64XX_GPL(9), 132 .gpio_pullup = -1, 133 .gpio_vbus_inverted = true, 134}; 135 136static struct platform_device smartq_usb_otg_vbus_dev = { 137 .name = "gpio-vbus", 138 .dev.platform_data = &smartq_usb_otg_vbus_pdata, 139}; 140 141static int smartq_bl_init(struct device *dev) 142{ 143 s3c_gpio_cfgpin(S3C64XX_GPF(15), S3C_GPIO_SFN(2)); 144 145 return 0; 146} 147 148static struct platform_pwm_backlight_data smartq_backlight_data = { 149 .pwm_id = 1, 150 .max_brightness = 1000, 151 .dft_brightness = 600, 152 .pwm_period_ns = 1000000000 / (1000 * 20), 153 .init = smartq_bl_init, 154}; 155 156static struct platform_device smartq_backlight_device = { 157 .name = "pwm-backlight", 158 .dev = { 159 .parent = &s3c_device_timer[1].dev, 160 .platform_data = &smartq_backlight_data, 161 }, 162}; 163 164static struct s3c2410_ts_mach_info smartq_touchscreen_pdata __initdata = { 165 .delay = 65535, 166 .presc = 99, 167 .oversampling_shift = 4, 168}; 169 170static struct s3c_sdhci_platdata smartq_internal_hsmmc_pdata = { 171 .max_width = 4, 172 .cd_type = S3C_SDHCI_CD_PERMANENT, 173}; 174 175static struct s3c_hwmon_pdata smartq_hwmon_pdata __initdata = { 176 /* Battery voltage (?-4.2V) */ 177 .in[0] = &(struct s3c_hwmon_chcfg) { 178 .name = "smartq:battery-voltage", 179 .mult = 3300, 180 .div = 2048, 181 }, 182 /* Reference voltage (1.2V) */ 183 .in[1] = &(struct s3c_hwmon_chcfg) { 184 .name = "smartq:reference-voltage", 185 .mult = 3300, 186 .div = 4096, 187 }, 188}; 189 190static struct s3c_hsotg_plat smartq_hsotg_pdata; 191 192static int __init smartq_lcd_setup_gpio(void) 193{ 194 int ret; 195 196 ret = gpio_request(S3C64XX_GPM(3), "LCD power"); 197 if (ret < 0) 198 return ret; 199 200 /* turn power off */ 201 gpio_direction_output(S3C64XX_GPM(3), 0); 202 203 return 0; 204} 205 206/* GPM0 -> CS */ 207static struct spi_gpio_platform_data smartq_lcd_control = { 208 .sck = S3C64XX_GPM(1), 209 .mosi = S3C64XX_GPM(2), 210 .miso = S3C64XX_GPM(2), 211}; 212 213static struct platform_device smartq_lcd_control_device = { 214 .name = "spi-gpio", 215 .id = 1, 216 .dev.platform_data = &smartq_lcd_control, 217}; 218 219static void smartq_lcd_power_set(struct plat_lcd_data *pd, unsigned int power) 220{ 221 gpio_direction_output(S3C64XX_GPM(3), power); 222} 223 224static struct plat_lcd_data smartq_lcd_power_data = { 225 .set_power = smartq_lcd_power_set, 226}; 227 228static struct platform_device smartq_lcd_power_device = { 229 .name = "platform-lcd", 230 .dev.parent = &s3c_device_fb.dev, 231 .dev.platform_data = &smartq_lcd_power_data, 232}; 233 234static struct i2c_board_info smartq_i2c_devs[] __initdata = { 235 { I2C_BOARD_INFO("wm8987", 0x1a), }, 236}; 237 238static struct platform_device *smartq_devices[] __initdata = { 239 &s3c_device_hsmmc1, /* Init iNAND first, ... */ 240 &s3c_device_hsmmc0, /* ... then the external SD card */ 241 &s3c_device_hsmmc2, 242 &s3c_device_adc, 243 &s3c_device_fb, 244 &s3c_device_hwmon, 245 &s3c_device_i2c0, 246 &s3c_device_ohci, 247 &s3c_device_rtc, 248 &s3c_device_timer[1], 249 &s3c_device_ts, 250 &s3c_device_usb_hsotg, 251 &s3c64xx_device_iis0, 252 &smartq_backlight_device, 253 &smartq_lcd_control_device, 254 &smartq_lcd_power_device, 255 &smartq_usb_otg_vbus_dev, 256}; 257 258static void __init smartq_lcd_mode_set(void) 259{ 260 u32 tmp; 261 262 /* set the LCD type */ 263 tmp = __raw_readl(S3C64XX_SPCON); 264 tmp &= ~S3C64XX_SPCON_LCD_SEL_MASK; 265 tmp |= S3C64XX_SPCON_LCD_SEL_RGB; 266 __raw_writel(tmp, S3C64XX_SPCON); 267 268 /* remove the LCD bypass */ 269 tmp = __raw_readl(S3C64XX_MODEM_MIFPCON); 270 tmp &= ~MIFPCON_LCD_BYPASS; 271 __raw_writel(tmp, S3C64XX_MODEM_MIFPCON); 272} 273 274static void smartq_power_off(void) 275{ 276 gpio_direction_output(S3C64XX_GPK(15), 1); 277} 278 279static int __init smartq_power_off_init(void) 280{ 281 int ret; 282 283 ret = gpio_request(S3C64XX_GPK(15), "Power control"); 284 if (ret < 0) { 285 pr_err("%s: failed to get GPK15\n", __func__); 286 return ret; 287 } 288 289 /* leave power on */ 290 gpio_direction_output(S3C64XX_GPK(15), 0); 291 292 pm_power_off = smartq_power_off; 293 294 return ret; 295} 296 297static int __init smartq_usb_host_init(void) 298{ 299 int ret; 300 301 ret = gpio_request(S3C64XX_GPL(0), "USB power control"); 302 if (ret < 0) { 303 pr_err("%s: failed to get GPL0\n", __func__); 304 return ret; 305 } 306 307 ret = gpio_request(S3C64XX_GPL(1), "USB host power control"); 308 if (ret < 0) { 309 pr_err("%s: failed to get GPL1\n", __func__); 310 goto err; 311 } 312 313 if (!machine_is_smartq5()) { 314 /* This isn't present on a SmartQ 5 board */ 315 ret = gpio_request(S3C64XX_GPL(10), "USB host overcurrent"); 316 if (ret < 0) { 317 pr_err("%s: failed to get GPL10\n", __func__); 318 goto err2; 319 } 320 } 321 322 /* turn power off */ 323 gpio_direction_output(S3C64XX_GPL(0), 0); 324 gpio_direction_output(S3C64XX_GPL(1), 0); 325 if (!machine_is_smartq5()) 326 gpio_direction_input(S3C64XX_GPL(10)); 327 328 s3c_device_ohci.dev.platform_data = &smartq_usb_host_info; 329 330 return 0; 331 332err2: 333 gpio_free(S3C64XX_GPL(1)); 334err: 335 gpio_free(S3C64XX_GPL(0)); 336 return ret; 337} 338 339static int __init smartq_usb_otg_init(void) 340{ 341 clk_xusbxti.rate = 12000000; 342 343 return 0; 344} 345 346static int __init smartq_wifi_init(void) 347{ 348 int ret; 349 350 ret = gpio_request(S3C64XX_GPK(1), "wifi control"); 351 if (ret < 0) { 352 pr_err("%s: failed to get GPK1\n", __func__); 353 return ret; 354 } 355 356 ret = gpio_request(S3C64XX_GPK(2), "wifi reset"); 357 if (ret < 0) { 358 pr_err("%s: failed to get GPK2\n", __func__); 359 gpio_free(S3C64XX_GPK(1)); 360 return ret; 361 } 362 363 /* turn power on */ 364 gpio_direction_output(S3C64XX_GPK(1), 1); 365 366 /* reset device */ 367 gpio_direction_output(S3C64XX_GPK(2), 0); 368 mdelay(100); 369 gpio_set_value(S3C64XX_GPK(2), 1); 370 gpio_direction_input(S3C64XX_GPK(2)); 371 372 return 0; 373} 374 375static struct map_desc smartq_iodesc[] __initdata = {}; 376void __init smartq_map_io(void) 377{ 378 s3c64xx_init_io(smartq_iodesc, ARRAY_SIZE(smartq_iodesc)); 379 s3c24xx_init_clocks(12000000); 380 s3c24xx_init_uarts(smartq_uartcfgs, ARRAY_SIZE(smartq_uartcfgs)); 381 382 smartq_lcd_mode_set(); 383} 384 385void __init smartq_machine_init(void) 386{ 387 s3c_i2c0_set_platdata(NULL); 388 s3c_hsotg_set_platdata(&smartq_hsotg_pdata); 389 s3c_hwmon_set_platdata(&smartq_hwmon_pdata); 390 s3c_sdhci1_set_platdata(&smartq_internal_hsmmc_pdata); 391 s3c_sdhci2_set_platdata(&smartq_internal_hsmmc_pdata); 392 s3c24xx_ts_set_platdata(&smartq_touchscreen_pdata); 393 394 i2c_register_board_info(0, smartq_i2c_devs, 395 ARRAY_SIZE(smartq_i2c_devs)); 396 397 WARN_ON(smartq_lcd_setup_gpio()); 398 WARN_ON(smartq_power_off_init()); 399 WARN_ON(smartq_usb_host_init()); 400 WARN_ON(smartq_usb_otg_init()); 401 WARN_ON(smartq_wifi_init()); 402 403 platform_add_devices(smartq_devices, ARRAY_SIZE(smartq_devices)); 404} 405