arch/arm/mach-omap1/board-sx1.c

   1 /*
   2 * linux/arch/arm/mach-omap1/board-sx1.c
   3 *
   4 * Modified from board-generic.c
   5 *
   6 * Support for the Siemens SX1 mobile phone.
   7 *
   8 * Original version : Vladimir Ananiev (Vovan888-at-gmail com)
   9 *
  10 * Maintainters : Vladimir Ananiev (aka Vovan888), Sergge
  11 *               oslik.ru
  12 *
  13 * This program is free software; you can redistribute it and/or modify
  14 * it under the terms of the GNU General Public License version 2 as
  15 * published by the Free Software Foundation.
  16 */
  17 #include <linux/gpio.h>
  18 #include <linux/kernel.h>
  19 #include <linux/init.h>
  20 #include <linux/input.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/notifier.h>
  23 #include <linux/mtd/mtd.h>
  24 #include <linux/mtd/partitions.h>
  25 #include <linux/mtd/physmap.h>
  26 #include <linux/types.h>
  27 #include <linux/i2c.h>
  28 #include <linux/errno.h>
  29 #include <linux/export.h>
  30 #include <linux/omapfb.h>
  31 #include <linux/platform_data/keypad-omap.h>
  32
  33 #include <asm/mach-types.h>
  34 #include <asm/mach/arch.h>
  35 #include <asm/mach/map.h>
  36
  37 #include <mach/flash.h>
  38 #include <mach/mux.h>
  39 #include <linux/omap-dma.h>
  40 #include <mach/tc.h>
  41 #include <mach/board-sx1.h>
  42
  43 #include <mach/hardware.h>
  44 #include <mach/usb.h>
  45
  46 #include "common.h"
  47
  48 /* Write to I2C device */
  49 int sx1_i2c_write_byte(u8 devaddr, u8 regoffset, u8 value)
  50 {
  51         struct i2c_adapter *adap;
  52         int err;
  53         struct i2c_msg msg[1];
  54         unsigned char data[2];
  55
  56         adap = i2c_get_adapter(0);
  57         if (!adap)
  58                 return -ENODEV;
  59         msg->addr = devaddr;    /* I2C address of chip */
  60         msg->flags = 0;
  61         msg->len = 2;
  62         msg->buf = data;
  63         data[0] = regoffset;    /* register num */
  64         data[1] = value;                /* register data */
  65         err = i2c_transfer(adap, msg, 1);
  66         i2c_put_adapter(adap);
  67         if (err >= 0)
  68                 return 0;
  69         return err;
  70 }
  71
  72 /* Read from I2C device */
  73 int sx1_i2c_read_byte(u8 devaddr, u8 regoffset, u8 *value)
  74 {
  75         struct i2c_adapter *adap;
  76         int err;
  77         struct i2c_msg msg[1];
  78         unsigned char data[2];
  79
  80         adap = i2c_get_adapter(0);
  81         if (!adap)
  82                 return -ENODEV;
  83
  84         msg->addr = devaddr;    /* I2C address of chip */
  85         msg->flags = 0;
  86         msg->len = 1;
  87         msg->buf = data;
  88         data[0] = regoffset;    /* register num */
  89         err = i2c_transfer(adap, msg, 1);
  90
  91         msg->addr = devaddr;    /* I2C address */
  92         msg->flags = I2C_M_RD;
  93         msg->len = 1;
  94         msg->buf = data;
  95         err = i2c_transfer(adap, msg, 1);
  96         *value = data[0];
  97         i2c_put_adapter(adap);
  98
  99         if (err >= 0)
 100                 return 0;
 101         return err;
 102 }
 103 /* set keyboard backlight intensity */
 104 int sx1_setkeylight(u8 keylight)
 105 {
 106         if (keylight > SOFIA_MAX_LIGHT_VAL)
 107                 keylight = SOFIA_MAX_LIGHT_VAL;
 108         return sx1_i2c_write_byte(SOFIA_I2C_ADDR, SOFIA_KEYLIGHT_REG, keylight);
 109 }
 110 /* get current keylight intensity */
 111 int sx1_getkeylight(u8 * keylight)
 112 {
 113         return sx1_i2c_read_byte(SOFIA_I2C_ADDR, SOFIA_KEYLIGHT_REG, keylight);
 114 }
 115 /* set LCD backlight intensity */
 116 int sx1_setbacklight(u8 backlight)
 117 {
 118         if (backlight > SOFIA_MAX_LIGHT_VAL)
 119                 backlight = SOFIA_MAX_LIGHT_VAL;
 120         return sx1_i2c_write_byte(SOFIA_I2C_ADDR, SOFIA_BACKLIGHT_REG,
 121                                   backlight);
 122 }
 123 /* get current LCD backlight intensity */
 124 int sx1_getbacklight (u8 * backlight)
 125 {
 126         return sx1_i2c_read_byte(SOFIA_I2C_ADDR, SOFIA_BACKLIGHT_REG,
 127                                  backlight);
 128 }
 129 /* set LCD backlight power on/off */
 130 int sx1_setmmipower(u8 onoff)
 131 {
 132         int err;
 133         u8 dat = 0;
 134         err = sx1_i2c_read_byte(SOFIA_I2C_ADDR, SOFIA_POWER1_REG, &dat);
 135         if (err < 0)
 136                 return err;
 137         if (onoff)
 138                 dat |= SOFIA_MMILIGHT_POWER;
 139         else
 140                 dat &= ~SOFIA_MMILIGHT_POWER;
 141         return sx1_i2c_write_byte(SOFIA_I2C_ADDR, SOFIA_POWER1_REG, dat);
 142 }
 143
 144 /* set USB power on/off */
 145 int sx1_setusbpower(u8 onoff)
 146 {
 147         int err;
 148         u8 dat = 0;
 149         err = sx1_i2c_read_byte(SOFIA_I2C_ADDR, SOFIA_POWER1_REG, &dat);
 150         if (err < 0)
 151                 return err;
 152         if (onoff)
 153                 dat |= SOFIA_USB_POWER;
 154         else
 155                 dat &= ~SOFIA_USB_POWER;
 156         return sx1_i2c_write_byte(SOFIA_I2C_ADDR, SOFIA_POWER1_REG, dat);
 157 }
 158
 159 EXPORT_SYMBOL(sx1_setkeylight);
 160 EXPORT_SYMBOL(sx1_getkeylight);
 161 EXPORT_SYMBOL(sx1_setbacklight);
 162 EXPORT_SYMBOL(sx1_getbacklight);
 163 EXPORT_SYMBOL(sx1_setmmipower);
 164 EXPORT_SYMBOL(sx1_setusbpower);
 165
 166 /*----------- Keypad -------------------------*/
 167
 168 static const unsigned int sx1_keymap[] = {
 169         KEY(3, 5, GROUP_0 | 117), /* camera Qt::Key_F17 */
 170         KEY(4, 0, GROUP_0 | 114), /* voice memo Qt::Key_F14 */
 171         KEY(4, 1, GROUP_2 | 114), /* voice memo */
 172         KEY(4, 2, GROUP_3 | 114), /* voice memo */
 173         KEY(0, 0, GROUP_1 | KEY_F12),   /* red button Qt::Key_Hangup */
 174         KEY(3, 4, GROUP_1 | KEY_LEFT),
 175         KEY(3, 2, GROUP_1 | KEY_DOWN),
 176         KEY(3, 1, GROUP_1 | KEY_RIGHT),
 177         KEY(3, 0, GROUP_1 | KEY_UP),
 178         KEY(3, 3, GROUP_1 | KEY_POWER), /* joystick press or Qt::Key_Select */
 179         KEY(0, 5, GROUP_1 | KEY_1),
 180         KEY(0, 4, GROUP_1 | KEY_2),
 181         KEY(0, 3, GROUP_1 | KEY_3),
 182         KEY(4, 3, GROUP_1 | KEY_4),
 183         KEY(4, 4, GROUP_1 | KEY_5),
 184         KEY(4, 5, GROUP_1 | KEY_KPASTERISK),/* "*" */
 185         KEY(1, 4, GROUP_1 | KEY_6),
 186         KEY(1, 5, GROUP_1 | KEY_7),
 187         KEY(1, 3, GROUP_1 | KEY_8),
 188         KEY(2, 3, GROUP_1 | KEY_9),
 189         KEY(2, 5, GROUP_1 | KEY_0),
 190         KEY(2, 4, GROUP_1 | 113), /* # F13 Toggle input method Qt::Key_F13 */
 191         KEY(1, 0, GROUP_1 | KEY_F11),   /* green button Qt::Key_Call */
 192         KEY(2, 1, GROUP_1 | KEY_YEN),   /* left soft Qt::Key_Context1 */
 193         KEY(2, 2, GROUP_1 | KEY_F8),    /* right soft Qt::Key_Back */
 194         KEY(1, 2, GROUP_1 | KEY_LEFTSHIFT), /* shift */
 195         KEY(1, 1, GROUP_1 | KEY_BACKSPACE), /* C (clear) */
 196         KEY(2, 0, GROUP_1 | KEY_F7),    /* menu Qt::Key_Menu */
 197 };
 198
 199 static struct resource sx1_kp_resources[] = {
 200         [0] = {
 201                 .start  = INT_KEYBOARD,
 202                 .end    = INT_KEYBOARD,
 203                 .flags  = IORESOURCE_IRQ,
 204         },
 205 };
 206
 207 static const struct matrix_keymap_data sx1_keymap_data = {
 208         .keymap         = sx1_keymap,
 209         .keymap_size    = ARRAY_SIZE(sx1_keymap),
 210 };
 211
 212 static struct omap_kp_platform_data sx1_kp_data = {
 213         .rows           = 6,
 214         .cols           = 6,
 215         .keymap_data    = &sx1_keymap_data,
 216         .delay  = 80,
 217 };
 218
 219 static struct platform_device sx1_kp_device = {
 220         .name           = "omap-keypad",
 221         .id             = -1,
 222         .dev            = {
 223                 .platform_data = &sx1_kp_data,
 224         },
 225         .num_resources  = ARRAY_SIZE(sx1_kp_resources),
 226         .resource       = sx1_kp_resources,
 227 };
 228
 229 /*----------- MTD -------------------------*/
 230
 231 static struct mtd_partition sx1_partitions[] = {
 232         /* bootloader (U-Boot, etc) in first sector */
 233         {
 234                 .name           = "bootloader",
 235                 .offset         = 0x01800000,
 236                 .size           = SZ_128K,
 237                 .mask_flags     = MTD_WRITEABLE, /* force read-only */
 238         },
 239         /* bootloader params in the next sector */
 240         {
 241                 .name           = "params",
 242                 .offset         = MTDPART_OFS_APPEND,
 243                 .size           = SZ_128K,
 244                 .mask_flags     = 0,
 245         },
 246         /* kernel */
 247         {
 248                 .name           = "kernel",
 249                 .offset         = MTDPART_OFS_APPEND,
 250                 .size           = SZ_2M - 2 * SZ_128K,
 251                 .mask_flags     = 0
 252         },
 253         /* file system */
 254         {
 255                 .name           = "filesystem",
 256                 .offset         = MTDPART_OFS_APPEND,
 257                 .size           = MTDPART_SIZ_FULL,
 258                 .mask_flags     = 0
 259         }
 260 };
 261
 262 static struct physmap_flash_data sx1_flash_data = {
 263         .width          = 2,
 264         .set_vpp        = omap1_set_vpp,
 265         .parts          = sx1_partitions,
 266         .nr_parts       = ARRAY_SIZE(sx1_partitions),
 267 };
 268
 269 #ifdef CONFIG_SX1_OLD_FLASH
 270 /* MTD Intel StrataFlash - old flashes */
 271 static struct resource sx1_old_flash_resource[] = {
 272         [0] = {
 273                 .start  = OMAP_CS0_PHYS,        /* Physical */
 274                 .end    = OMAP_CS0_PHYS + SZ_16M - 1,,
 275                 .flags  = IORESOURCE_MEM,
 276         },
 277         [1] = {
 278                 .start  = OMAP_CS1_PHYS,
 279                 .end    = OMAP_CS1_PHYS + SZ_8M - 1,
 280                 .flags  = IORESOURCE_MEM,
 281         },
 282 };
 283
 284 static struct platform_device sx1_flash_device = {
 285         .name           = "physmap-flash",
 286         .id             = 0,
 287         .dev            = {
 288                 .platform_data  = &sx1_flash_data,
 289         },
 290         .num_resources  = 2,
 291         .resource       = &sx1_old_flash_resource,
 292 };
 293 #else
 294 /* MTD Intel 4000 flash - new flashes */
 295 static struct resource sx1_new_flash_resource = {
 296         .start          = OMAP_CS0_PHYS,
 297         .end            = OMAP_CS0_PHYS + SZ_32M - 1,
 298         .flags          = IORESOURCE_MEM,
 299 };
 300
 301 static struct platform_device sx1_flash_device = {
 302         .name           = "physmap-flash",
 303         .id             = 0,
 304         .dev            = {
 305                 .platform_data  = &sx1_flash_data,
 306         },
 307         .num_resources  = 1,
 308         .resource       = &sx1_new_flash_resource,
 309 };
 310 #endif
 311
 312 /*----------- USB -------------------------*/
 313
 314 static struct omap_usb_config sx1_usb_config __initdata = {
 315         .otg            = 0,
 316         .register_dev   = 1,
 317         .register_host  = 0,
 318         .hmc_mode       = 0,
 319         .pins[0]        = 2,
 320         .pins[1]        = 0,
 321         .pins[2]        = 0,
 322 };
 323
 324 /*----------- LCD -------------------------*/
 325
 326 static struct omap_lcd_config sx1_lcd_config __initdata = {
 327         .ctrl_name      = "internal",
 328 };
 329
 330 /*-----------------------------------------*/
 331 static struct platform_device *sx1_devices[] __initdata = {
 332         &sx1_flash_device,
 333         &sx1_kp_device,
 334 };
 335
 336 /*-----------------------------------------*/
 337
 338 static void __init omap_sx1_init(void)
 339 {
 340         /* mux pins for uarts */
 341         omap_cfg_reg(UART1_TX);
 342         omap_cfg_reg(UART1_RTS);
 343         omap_cfg_reg(UART2_TX);
 344         omap_cfg_reg(UART2_RTS);
 345         omap_cfg_reg(UART3_TX);
 346         omap_cfg_reg(UART3_RX);
 347
 348         platform_add_devices(sx1_devices, ARRAY_SIZE(sx1_devices));
 349
 350         omap_serial_init();
 351         omap_register_i2c_bus(1, 100, NULL, 0);
 352         omap1_usb_init(&sx1_usb_config);
 353         sx1_mmc_init();
 354
 355         /* turn on USB power */
 356         /* sx1_setusbpower(1); can't do it here because i2c is not ready */
 357         gpio_request(1, "A_IRDA_OFF");
 358         gpio_request(11, "A_SWITCH");
 359         gpio_request(15, "A_USB_ON");
 360         gpio_direction_output(1, 1);    /*A_IRDA_OFF = 1 */
 361         gpio_direction_output(11, 0);   /*A_SWITCH = 0 */
 362         gpio_direction_output(15, 0);   /*A_USB_ON = 0 */
 363
 364         omapfb_set_lcd_config(&sx1_lcd_config);
 365 }
 366
 367 MACHINE_START(SX1, "OMAP310 based Siemens SX1")
 368         .atag_offset    = 0x100,
 369         .map_io         = omap15xx_map_io,
 370         .init_early     = omap1_init_early,
 371         .init_irq       = omap1_init_irq,
 372         .init_machine   = omap_sx1_init,
 373         .init_late      = omap1_init_late,
 374         .init_time      = omap1_timer_init,
 375         .restart        = omap1_restart,
 376 MACHINE_END