/arch/arm/mach-fsm/board-trout.c

https://bitbucket.org/sammyz/iscream_thunderc-2.6.35-rebase · C · 881 lines · 752 code · 101 blank · 28 comment · 18 complexity · 85504ef419dca79703d2018dfdcf69cd MD5 · raw file 

    

  1. /* arch/arm/mach-msm/board-trout.c
    2. 

  2.  *
    3. 

  3.  * Copyright (C) 2008 Google, Inc.
    4. 

  4.  * Copyright (c) 2009, Code Aurora Forum. All rights reserved.
    5. 

  5.  *
    6. 

  6.  * This software is licensed under the terms of the GNU General Public
    7. 

  7.  * License version 2, as published by the Free Software Foundation, and
    8. 

  8.  * may be copied, distributed, and modified under those terms.
    9. 

  9.  *
    10. 

  10.  * This program is distributed in the hope that it will be useful,
    11. 

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    12. 

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13. 

  13.  * GNU General Public License for more details.
    14. 

  14.  *
    15. 

  15.  */
    16. 

  16. 

  17. #include <linux/kernel.h>
    18. 

  18. #include <linux/init.h>
    19. 

  19. #include <linux/platform_device.h>
    20. 

  20. #include <linux/input.h>
    21. 

  21. #include <linux/interrupt.h>
    22. 

  22. #include <linux/i2c.h>
    23. 

  23. #include <linux/irq.h>
    24. 

  24. #include <linux/keyreset.h>
    25. 

  25. #include <linux/leds.h>
    26. 

  26. #include <linux/switch.h>
    27. 

  27. #include <linux/../../../drivers/staging/android/timed_gpio.h>
    28. 

  28. #include <linux/synaptics_i2c_rmi.h>
    29. 

  29. #include <linux/akm8976.h>
    30. 

  30. #include <linux/sysdev.h>
    31. 

  31. #include <linux/android_pmem.h>
    32. 

  32. 

  33. #include <linux/delay.h>
    34. 

  34. 

  35. #include <asm/gpio.h>
    36. 

  36. #include <mach/hardware.h>
    37. 

  37. #include <asm/mach-types.h>
    38. 

  38. #include <asm/mach/arch.h>
    39. 

  39. #include <asm/mach/map.h>
    40. 

  40. #include <asm/mach/flash.h>
    41. 

  41. #include <asm/system.h>
    42. 

  42. #include <mach/system.h>
    43. 

  43. #include <mach/vreg.h>
    44. 

  44. 

  45. #include <asm/io.h>
    46. 

  46. #include <asm/delay.h>
    47. 

  47. #include <asm/setup.h>
    48. 

  48. 

  49. #include <linux/gpio_event.h>
    50. 

  50. #include <linux/mtd/nand.h>
    51. 

  51. #include <linux/mtd/partitions.h>
    52. 

  52. 

  53. #include <asm/mach/mmc.h>
    54. 

  54. #include <linux/mmc/sdio_ids.h>
    55. 

  55. #include <linux/msm_audio.h>
    56. 

  56. 

  57. #include "board-trout.h"
    58. 

  58. 

  59. #include "gpio_chip.h"
    60. 

  60. #include "pm.h"
    61. 

  61. 

  62. #include <mach/board.h>
    63. 

  63. #include <mach/board_htc.h>
    64. 

  64. #include <mach/msm_serial_hs.h>
    65. 

  65. #include <mach/htc_pwrsink.h>
    66. 

  66. #ifdef CONFIG_HTC_HEADSET
    67. 

  67. #include <mach/htc_headset.h>
    68. 

  68. #endif
    69. 

  69. #ifdef CONFIG_WIFI_CONTROL_FUNC
    70. 

  70. #include <linux/wifi_tiwlan.h>
    71. 

  71. #endif
    72. 

  72. 

  73. #include "proc_comm.h"
    74. 

  74. #include "devices.h"
    75. 

  75. 

  76. void msm_init_irq(void);
    77. 

  77. void msm_init_gpio(void);
    78. 

  78. 

  79. extern int trout_init_mmc(unsigned int);
    80. 

  80. #ifdef CONFIG_WIFI_CONTROL_FUNC
    81. 

  81. #ifdef CONFIG_WIFI_MEM_PREALLOC
    82. 

  82. extern int trout_init_wifi_mem(void);
    83. 

  83. #endif
    84. 

  84. extern struct wifi_platform_data trout_wifi_control;
    85. 

  85. #endif
    86. 

  86. 

  87. struct trout_axis_info {
    88. 

  88. 	struct gpio_event_axis_info info;
    89. 

  89. 	uint16_t in_state;
    90. 

  90. 	uint16_t out_state;
    91. 

  91. };
    92. 

  92. static bool nav_just_on;
    93. 

  93. static int nav_on_jiffies;
    94. 

  94. 

  95. uint16_t trout_axis_map(struct gpio_event_axis_info *info, uint16_t in)
    96. 

  96. {
    97. 

  97. 	struct trout_axis_info *ai = container_of(info, struct trout_axis_info, info);
    98. 

  98. 	uint16_t out = ai->out_state;
    99. 

  99. 

  100. 	if (nav_just_on) {
    101. 

  101. 		if (jiffies == nav_on_jiffies || jiffies == nav_on_jiffies + 1)
    102. 

  102. 			goto ignore;
    103. 

  103. 		nav_just_on = 0;
    104. 

  104. 	}
    105. 

  105. 	if((ai->in_state ^ in) & 1)
    106. 

  106. 		out--;
    107. 

  107. 	if((ai->in_state ^ in) & 2)
    108. 

  108. 		out++;
    109. 

  109. 	ai->out_state = out;
    110. 

  110. ignore:
    111. 

  111. 	ai->in_state = in;
    112. 

  112. 	return out;
    113. 

  113. }
    114. 

  114. 

  115. int trout_nav_power(const struct gpio_event_platform_data *pdata, bool on)
    116. 

  116. {
    117. 

  117. 	gpio_set_value(TROUT_GPIO_JOG_EN, on);
    118. 

  118. 	if (on) {
    119. 

  119. 		nav_just_on = 1;
    120. 

  120. 		nav_on_jiffies = jiffies;
    121. 

  121. 	}
    122. 

  122. 	return 0;
    123. 

  123. }
    124. 

  124. 

  125. static uint32_t trout_4_x_axis_gpios[] = {
    126. 

  126. 	TROUT_4_BALL_LEFT_0, TROUT_4_BALL_RIGHT_0
    127. 

  127. };
    128. 

  128. static uint32_t trout_5_x_axis_gpios[] = {
    129. 

  129. 	TROUT_5_BALL_LEFT_0, TROUT_5_BALL_RIGHT_0
    130. 

  130. };
    131. 

  131. 

  132. static struct trout_axis_info trout_x_axis = {
    133. 

  133. 	.info = {
    134. 

  134. 		.info.func = gpio_event_axis_func,
    135. 

  135. 		.count = ARRAY_SIZE(trout_5_x_axis_gpios),
    136. 

  136. 		.type = EV_REL,
    137. 

  137. 		.code = REL_X,
    138. 

  138. 		.decoded_size = 1U << ARRAY_SIZE(trout_5_x_axis_gpios),
    139. 

  139. 		.map = trout_axis_map,
    140. 

  140. 		.gpio = trout_5_x_axis_gpios,
    141. 

  141. 		.flags = GPIOEAF_PRINT_UNKNOWN_DIRECTION /*| GPIOEAF_PRINT_RAW | GPIOEAF_PRINT_EVENT */
    142. 

  142. 	}
    143. 

  143. };
    144. 

  144. 

  145. static uint32_t trout_4_y_axis_gpios[] = {
    146. 

  146. 	TROUT_4_BALL_UP_0, TROUT_4_BALL_DOWN_0
    147. 

  147. };
    148. 

  148. static uint32_t trout_5_y_axis_gpios[] = {
    149. 

  149. 	TROUT_5_BALL_UP_0, TROUT_5_BALL_DOWN_0
    150. 

  150. };
    151. 

  151. 

  152. static struct trout_axis_info trout_y_axis = {
    153. 

  153. 	.info = {
    154. 

  154. 		.info.func = gpio_event_axis_func,
    155. 

  155. 		.count = ARRAY_SIZE(trout_5_y_axis_gpios),
    156. 

  156. 		.type = EV_REL,
    157. 

  157. 		.code = REL_Y,
    158. 

  158. 		.decoded_size = 1U << ARRAY_SIZE(trout_5_y_axis_gpios),
    159. 

  159. 		.map = trout_axis_map,
    160. 

  160. 		.gpio = trout_5_y_axis_gpios,
    161. 

  161. 		.flags = GPIOEAF_PRINT_UNKNOWN_DIRECTION /*| GPIOEAF_PRINT_RAW | GPIOEAF_PRINT_EVENT */
    162. 

  162. 	}
    163. 

  163. };
    164. 

  164. 

  165. static struct gpio_event_direct_entry trout_nav_buttons[] = {
    166. 

  166. 	{ TROUT_GPIO_NAVI_ACT_N, BTN_MOUSE }
    167. 

  167. };
    168. 

  168. 

  169. static struct gpio_event_input_info trout_nav_button_info = {
    170. 

  170. 	.info.func = gpio_event_input_func,
    171. 

  171. 	.flags = 0,
    172. 

  172. 	.type = EV_KEY,
    173. 

  173. 	.keymap = trout_nav_buttons,
    174. 

  174. 	.keymap_size = ARRAY_SIZE(trout_nav_buttons)
    175. 

  175. };
    176. 

  176. 

  177. static struct gpio_event_info *trout_nav_info[] = {
    178. 

  178. 	&trout_x_axis.info.info,
    179. 

  179. 	&trout_y_axis.info.info,
    180. 

  180. 	&trout_nav_button_info.info
    181. 

  181. };
    182. 

  182. 

  183. static struct gpio_event_platform_data trout_nav_data = {
    184. 

  184. 	.name = "trout-nav",
    185. 

  185. 	.info = trout_nav_info,
    186. 

  186. 	.info_count = ARRAY_SIZE(trout_nav_info),
    187. 

  187. 	.power = trout_nav_power,
    188. 

  188. };
    189. 

  189. 

  190. static struct platform_device trout_nav_device = {
    191. 

  191. 	.name = GPIO_EVENT_DEV_NAME,
    192. 

  192. 	.id = 2,
    193. 

  193. 	.dev = {
    194. 

  194. 		.platform_data = &trout_nav_data,
    195. 

  195. 	},
    196. 

  196. };
    197. 

  197. 

  198. static int trout_reset_keys_up[] = {
    199. 

  199. 	BTN_MOUSE,
    200. 

  200. 	0
    201. 

  201. };
    202. 

  202. 

  203. static struct keyreset_platform_data trout_reset_keys_pdata = {
    204. 

  204. 	.keys_up = trout_reset_keys_up,
    205. 

  205. 	.keys_down = {
    206. 

  206. 		KEY_SEND,
    207. 

  207. 		KEY_MENU,
    208. 

  208. 		KEY_END,
    209. 

  209. 		0
    210. 

  210. 	},
    211. 

  211. };
    212. 

  212. 

  213. struct platform_device trout_reset_keys_device = {
    214. 

  214. 	.name = KEYRESET_NAME,
    215. 

  215. 	.dev.platform_data = &trout_reset_keys_pdata,
    216. 

  216. };
    217. 

  217. 

  218. static int trout_ts_power(int on)
    219. 

  219. {
    220. 

  220. 	int tp_ls_gpio = system_rev < 5 ? TROUT_4_TP_LS_EN : TROUT_5_TP_LS_EN;
    221. 

  221. 	if (on) {
    222. 

  222. 		gpio_set_value(TROUT_GPIO_TP_I2C_PULL, 1);
    223. 

  223. 		gpio_set_value(TROUT_GPIO_TP_EN, 1);
    224. 

  224. 		/* touchscreen must be powered before we enable i2c pullup */
    225. 

  225. 		msleep(2);
    226. 

  226. 		/* enable touch panel level shift */
    227. 

  227. 		gpio_set_value(tp_ls_gpio, 1);
    228. 

  228. 		msleep(2);
    229. 

  229. 	}
    230. 

  230. 	else {
    231. 

  231. 		gpio_set_value(tp_ls_gpio, 0);
    232. 

  232. 		udelay(50);
    233. 

  233. 		gpio_set_value(TROUT_GPIO_TP_EN, 0);
    234. 

  234. 		gpio_set_value(TROUT_GPIO_TP_I2C_PULL, 0);
    235. 

  235. 	}
    236. 

  236. 	return 0;
    237. 

  237. }
    238. 

  238. 

  239. static struct synaptics_i2c_rmi_platform_data trout_ts_data[] = {
    240. 

  240. 	{
    241. 

  241. 		.version = 0x010c,
    242. 

  242. 		.power = trout_ts_power,
    243. 

  243. 		.flags = SYNAPTICS_FLIP_Y | SYNAPTICS_SNAP_TO_INACTIVE_EDGE,
    244. 

  244. 		.inactive_left = -100 * 0x10000 / 4334,
    245. 

  245. 		.inactive_right = -100 * 0x10000 / 4334,
    246. 

  246. 		.inactive_top = -40 * 0x10000 / 6696,
    247. 

  247. 		.inactive_bottom = -40 * 0x10000 / 6696,
    248. 

  248. 		.snap_left_on = 300 * 0x10000 / 4334,
    249. 

  249. 		.snap_left_off = 310 * 0x10000 / 4334,
    250. 

  250. 		.snap_right_on = 300 * 0x10000 / 4334,
    251. 

  251. 		.snap_right_off = 310 * 0x10000 / 4334,
    252. 

  252. 		.snap_top_on = 100 * 0x10000 / 6696,
    253. 

  253. 		.snap_top_off = 110 * 0x10000 / 6696,
    254. 

  254. 		.snap_bottom_on = 100 * 0x10000 / 6696,
    255. 

  255. 		.snap_bottom_off = 110 * 0x10000 / 6696,
    256. 

  256. 	},
    257. 

  257. 	{
    258. 

  258. 		.flags = SYNAPTICS_FLIP_Y | SYNAPTICS_SNAP_TO_INACTIVE_EDGE,
    259. 

  259. 		.inactive_left = ((4674 - 4334) / 2 + 200) * 0x10000 / 4334,
    260. 

  260. 		.inactive_right = ((4674 - 4334) / 2 + 200) * 0x10000 / 4334,
    261. 

  261. 		.inactive_top = ((6946 - 6696) / 2) * 0x10000 / 6696,
    262. 

  262. 		.inactive_bottom = ((6946 - 6696) / 2) * 0x10000 / 6696,
    263. 

  263. 	}
    264. 

  264. };
    265. 

  265. 

  266. static struct akm8976_platform_data compass_platform_data = {
    267. 

  267. 	.reset = TROUT_GPIO_COMPASS_RST_N,
    268. 

  268. 	.clk_on = TROUT_GPIO_COMPASS_32K_EN,
    269. 

  269. 	.intr = TROUT_GPIO_COMPASS_IRQ,
    270. 

  270. };
    271. 

  271. 

  272. static struct i2c_board_info i2c_devices[] = {
    273. 

  273. 	{
    274. 

  274. 		I2C_BOARD_INFO(SYNAPTICS_I2C_RMI_NAME, 0x20),
    275. 

  275. 		.platform_data = trout_ts_data,
    276. 

  276. 		.irq = TROUT_GPIO_TO_INT(TROUT_GPIO_TP_ATT_N)
    277. 

  277. 	},
    278. 

  278. 	{
    279. 

  279. 		I2C_BOARD_INFO("elan-touch", 0x10),
    280. 

  280. 		.irq = TROUT_GPIO_TO_INT(TROUT_GPIO_TP_ATT_N),
    281. 

  281. 	},
    282. 

  282. 	{
    283. 

  283. 		I2C_BOARD_INFO("akm8976", 0x1C),
    284. 

  284. 		.platform_data = &compass_platform_data,
    285. 

  285. 		.irq = TROUT_GPIO_TO_INT(TROUT_GPIO_COMPASS_IRQ),
    286. 

  286. 	},
    287. 

  287. 	{
    288. 

  288. 		I2C_BOARD_INFO("pca963x", 0x62),
    289. 

  289. 	},
    290. 

  290. #if defined(CONFIG_MSM_CAMERA) && defined(CONFIG_MT9T013)
    291. 

  291. 	{
    292. 

  292. 		I2C_BOARD_INFO("mt9t013", 0x6C),
    293. 

  293. 	},
    294. 

  294. #endif
    295. 

  295. #ifdef CONFIG_SENSORS_MT9T013
    296. 

  296. 	{
    297. 

  297. 		I2C_BOARD_INFO("mt9t013", 0x6C >> 1),
    298. 

  298. 	},
    299. 

  299. #endif
    300. 

  300. };
    301. 

  301. 

  302. static struct timed_gpio timed_gpios[] = {
    303. 

  303. 	{
    304. 

  304. 		.name = "vibrator",
    305. 

  305. 		.gpio = TROUT_GPIO_HAPTIC_PWM,
    306. 

  306. 		.max_timeout = 15000,
    307. 

  307. 	},
    308. 

  308. 	{
    309. 

  309. 		.name = "flash",
    310. 

  310. 		.gpio = TROUT_GPIO_FLASH_EN,
    311. 

  311. 		.max_timeout = 400,
    312. 

  312. 	},
    313. 

  313. };
    314. 

  314. 

  315. static struct timed_gpio_platform_data timed_gpio_data = {
    316. 

  316. 	.num_gpios	= ARRAY_SIZE(timed_gpios),
    317. 

  317. 	.gpios		= timed_gpios,
    318. 

  318. };
    319. 

  319. 

  320. static struct platform_device android_timed_gpios = {
    321. 

  321. 	.name		= "timed-gpio",
    322. 

  322. 	.id		= -1,
    323. 

  323. 	.dev		= {
    324. 

  324. 		.platform_data = &timed_gpio_data,
    325. 

  325. 	},
    326. 

  326. };
    327. 

  327. 

  328. static struct gpio_led android_led_list[] = {
    329. 

  329. 	{
    330. 

  330. 		.name = "spotlight",
    331. 

  331. 		.gpio = TROUT_GPIO_SPOTLIGHT_EN,
    332. 

  332. 	},
    333. 

  333. 	{
    334. 

  334. 		.name = "keyboard-backlight",
    335. 

  335. 		.gpio = TROUT_GPIO_QTKEY_LED_EN,
    336. 

  336. 	},
    337. 

  337. 	{
    338. 

  338. 		.name = "button-backlight",
    339. 

  339. 		.gpio = TROUT_GPIO_UI_LED_EN,
    340. 

  340. 	},
    341. 

  341. };
    342. 

  342. 

  343. static struct gpio_led_platform_data android_leds_data = {
    344. 

  344. 	.num_leds	= ARRAY_SIZE(android_led_list),
    345. 

  345. 	.leds		= android_led_list,
    346. 

  346. };
    347. 

  347. 

  348. static struct platform_device android_leds = {
    349. 

  349. 	.name		= "leds-gpio",
    350. 

  350. 	.id		= -1,
    351. 

  351. 	.dev		= {
    352. 

  352. 		.platform_data = &android_leds_data,
    353. 

  353. 	},
    354. 

  354. };
    355. 

  355. 

  356. static struct gpio_switch_platform_data sd_door_switch_data = {
    357. 

  357. 	.name		= "sd-door",
    358. 

  358. 	.gpio		= TROUT_GPIO_SD_DOOR_N,
    359. 

  359. 	.state_on	= "open",
    360. 

  360. 	.state_off	= "closed",
    361. 

  361. };
    362. 

  362. 

  363. static struct platform_device sd_door_switch = {
    364. 

  364. 	.name		= "switch-gpio",
    365. 

  365. 	.id		= -1,
    366. 

  366. 	.dev		= {
    367. 

  367. 		.platform_data = &sd_door_switch_data,
    368. 

  368. 	},
    369. 

  369. };
    370. 

  370. 

  371. #ifdef CONFIG_HTC_HEADSET
    372. 

  372. static void h2w_config_cpld(int route)
    373. 

  373. {
    374. 

  374. 	switch (route) {
    375. 

  375. 	case H2W_UART3:
    376. 

  376. 		gpio_set_value(TROUT_GPIO_H2W_SEL0, 0);
    377. 

  377. 		gpio_set_value(TROUT_GPIO_H2W_SEL1, 1);
    378. 

  378. 		break;
    379. 

  379. 	case H2W_GPIO:
    380. 

  380. 		gpio_set_value(TROUT_GPIO_H2W_SEL0, 0);
    381. 

  381. 		gpio_set_value(TROUT_GPIO_H2W_SEL1, 0);
    382. 

  382. 		break;
    383. 

  383. 	}
    384. 

  384. }
    385. 

  385. 

  386. static void h2w_init_cpld(void)
    387. 

  387. {
    388. 

  388. 	h2w_config_cpld(H2W_UART3);
    389. 

  389. 	gpio_set_value(TROUT_GPIO_H2W_CLK_DIR, 0);
    390. 

  390. 	gpio_set_value(TROUT_GPIO_H2W_DAT_DIR, 0);
    391. 

  391. }
    392. 

  392. 

  393. static struct h2w_platform_data trout_h2w_data = {
    394. 

  394. 	.cable_in1		= TROUT_GPIO_CABLE_IN1,
    395. 

  395. 	.cable_in2		= TROUT_GPIO_CABLE_IN2,
    396. 

  396. 	.h2w_clk		= TROUT_GPIO_H2W_CLK_GPI,
    397. 

  397. 	.h2w_data		= TROUT_GPIO_H2W_DAT_GPI,
    398. 

  398. 	.debug_uart 		= H2W_UART3,
    399. 

  399. 	.config_cpld 		= h2w_config_cpld,
    400. 

  400. 	.init_cpld 		= h2w_init_cpld,
    401. 

  401. };
    402. 

  402. 

  403. static struct platform_device trout_h2w = {
    404. 

  404. 	.name		= "h2w",
    405. 

  405. 	.id		= -1,
    406. 

  406. 	.dev		= {
    407. 

  407. 		.platform_data	= &trout_h2w_data,
    408. 

  408. 	},
    409. 

  409. };
    410. 

  410. #endif
    411. 

  411. 

  412. static void trout_phy_reset(void)
    413. 

  413. {
    414. 

  414. 	gpio_set_value(TROUT_GPIO_USB_PHY_RST_N, 0);
    415. 

  415. 	mdelay(10);
    416. 

  416. 	gpio_set_value(TROUT_GPIO_USB_PHY_RST_N, 1);
    417. 

  417. 	mdelay(10);
    418. 

  418. }
    419. 

  419. 

  420. static void config_camera_on_gpios(void);
    421. 

  421. static void config_camera_off_gpios(void);
    422. 

  422. 

  423. #ifdef CONFIG_MSM_CAMERA
    424. 

  424. static struct msm_camera_device_platform_data msm_camera_device_data = {
    425. 

  425. 	.camera_gpio_on  = config_camera_on_gpios,
    426. 

  426. 	.camera_gpio_off = config_camera_off_gpios,
    427. 

  427. 	.ioext.mdcphy = MSM_MDC_PHYS,
    428. 

  428. 	.ioext.mdcsz  = MSM_MDC_SIZE,
    429. 

  429. 	.ioext.appphy = MSM_CLK_CTL_PHYS,
    430. 

  430. 	.ioext.appsz  = MSM_CLK_CTL_SIZE,
    431. 

  431. };
    432. 

  432. 

  433. #ifdef CONFIG_MT9T013
    434. 

  434. static struct msm_camera_sensor_info msm_camera_sensor_mt9t013_data = {
    435. 

  435. 	.sensor_name    = "mt9t013",
    436. 

  436. 	.sensor_reset   = 108,
    437. 

  437. 	.sensor_pwd     = 85,
    438. 

  438. 	.vcm_pwd        = TROUT_GPIO_VCM_PWDN,
    439. 

  439. 	.pdata          = &msm_camera_device_data,
    440. 

  440. 	.flash_type     = MSM_CAMERA_FLASH_NONE
    441. 

  441. };
    442. 

  442. 

  443. static struct platform_device msm_camera_sensor_mt9t013 = {
    444. 

  444. 	.name           = "msm_camera_mt9t013",
    445. 

  445. 	.dev            = {
    446. 

  446. 		.platform_data = &msm_camera_sensor_mt9t013_data,
    447. 

  447. 	},
    448. 

  448. };
    449. 

  449. #endif
    450. 

  450. #endif
    451. 

  451. 

  452. #ifdef CONFIG_SENSORS_MT9T013
    453. 

  453. static struct msm_camera_legacy_device_platform_data msm_camera_device_mt9t013 = {
    454. 

  454. 	.sensor_reset	= 108,
    455. 

  455. 	.sensor_pwd	= 85,
    456. 

  456. 	.vcm_pwd	= TROUT_GPIO_VCM_PWDN,
    457. 

  457. 	.config_gpio_on = config_camera_on_gpios,
    458. 

  458. 	.config_gpio_off = config_camera_off_gpios,
    459. 

  459. };
    460. 

  460. 

  461. static struct platform_device trout_camera = {
    462. 

  462. 	.name           = "camera",
    463. 

  463. 	.dev            = {
    464. 

  464. 		.platform_data = &msm_camera_device_mt9t013,
    465. 

  465. 	},
    466. 

  466. };
    467. 

  467. #endif
    468. 

  468. 

  469. static struct pwr_sink trout_pwrsink_table[] = {
    470. 

  470. 	{
    471. 

  471. 		.id	= PWRSINK_AUDIO,
    472. 

  472. 		.ua_max	= 90000,
    473. 

  473. 	},
    474. 

  474. 	{
    475. 

  475. 		.id	= PWRSINK_BACKLIGHT,
    476. 

  476. 		.ua_max	= 128000,
    477. 

  477. 	},
    478. 

  478. 	{
    479. 

  479. 		.id	= PWRSINK_LED_BUTTON,
    480. 

  480. 		.ua_max	= 17000,
    481. 

  481. 	},
    482. 

  482. 	{
    483. 

  483. 		.id	= PWRSINK_LED_KEYBOARD,
    484. 

  484. 		.ua_max	= 22000,
    485. 

  485. 	},
    486. 

  486. 	{
    487. 

  487. 		.id	= PWRSINK_GP_CLK,
    488. 

  488. 		.ua_max	= 30000,
    489. 

  489. 	},
    490. 

  490. 	{
    491. 

  491. 		.id	= PWRSINK_BLUETOOTH,
    492. 

  492. 		.ua_max	= 15000,
    493. 

  493. 	},	
    494. 

  494. 	{
    495. 

  495. 		.id	= PWRSINK_CAMERA,
    496. 

  496. 		.ua_max	= 0,
    497. 

  497. 	},
    498. 

  498. 	{
    499. 

  499. 		.id	= PWRSINK_SDCARD,
    500. 

  500. 		.ua_max	= 0,
    501. 

  501. 	},	
    502. 

  502. 	{
    503. 

  503. 		.id	= PWRSINK_VIDEO,
    504. 

  504. 		.ua_max	= 0,
    505. 

  505. 	},
    506. 

  506. 	{
    507. 

  507. 		.id	= PWRSINK_WIFI,
    508. 

  508. 		.ua_max = 200000,
    509. 

  509. 	},
    510. 

  510. 	{
    511. 

  511. 		.id	= PWRSINK_SYSTEM_LOAD,
    512. 

  512. 		.ua_max	= 63000,
    513. 

  513. 		.percent_util = 100,
    514. 

  514. 	},
    515. 

  515. };
    516. 

  516. 

  517. static struct pwr_sink_platform_data trout_pwrsink_data = {
    518. 

  518. 	.num_sinks	= ARRAY_SIZE(trout_pwrsink_table),
    519. 

  519. 	.sinks		= trout_pwrsink_table,
    520. 

  520. 	.suspend_late	= NULL,
    521. 

  521. 	.resume_early	= NULL,
    522. 

  522. 	.suspend_early	= NULL,
    523. 

  523. 	.resume_late	= NULL,
    524. 

  524. };
    525. 

  525. 

  526. static struct platform_device trout_pwr_sink = {
    527. 

  527. 	.name = "htc_pwrsink",
    528. 

  528. 	.id = -1,
    529. 

  529. 	.dev	= {
    530. 

  530. 		.platform_data = &trout_pwrsink_data,
    531. 

  531. 	},
    532. 

  532. };
    533. 

  533. 

  534. static struct platform_device trout_rfkill = {
    535. 

  535. 	.name = "trout_rfkill",
    536. 

  536. 	.id = -1,
    537. 

  537. };
    538. 

  538. 

  539. static struct msm_pmem_setting pmem_setting = {
    540. 

  540. 	.pmem_start = MSM_PMEM_MDP_BASE,
    541. 

  541. 	.pmem_size = MSM_PMEM_MDP_SIZE,
    542. 

  542. 	.pmem_adsp_start = MSM_PMEM_ADSP_BASE,
    543. 

  543. 	.pmem_adsp_size = MSM_PMEM_ADSP_SIZE,
    544. 

  544. 	.pmem_gpu0_start = MSM_PMEM_GPU0_BASE,
    545. 

  545. 	.pmem_gpu0_size = MSM_PMEM_GPU0_SIZE,
    546. 

  546. 	.pmem_gpu1_start = MSM_PMEM_GPU1_BASE,
    547. 

  547. 	.pmem_gpu1_size = MSM_PMEM_GPU1_SIZE,
    548. 

  548. 	.pmem_camera_start = MSM_PMEM_CAMERA_BASE,
    549. 

  549. 	.pmem_camera_size = MSM_PMEM_CAMERA_SIZE,
    550. 

  550. 	.ram_console_start = MSM_RAM_CONSOLE_BASE,
    551. 

  551. 	.ram_console_size = MSM_RAM_CONSOLE_SIZE,
    552. 

  552. };
    553. 

  553. 

  554. #ifdef CONFIG_WIFI_CONTROL_FUNC
    555. 

  555. static struct platform_device trout_wifi = {
    556. 

  556. 	.name		= "msm_wifi",
    557. 

  557. 	.id		= 1,
    558. 

  558. 	.num_resources	= 0,
    559. 

  559. 	.resource	= NULL,
    560. 

  560. 	.dev		= {
    561. 

  561. 		.platform_data = &trout_wifi_control,
    562. 

  562. 	},
    563. 

  563. };
    564. 

  564. #endif
    565. 

  565. 

  566. #define SND(num, desc) { .name = desc, .id = num }
    567. 

  567. static struct snd_endpoint snd_endpoints_list[] = {
    568. 

  568. 	SND(0, "HANDSET"),
    569. 

  569. 	SND(1, "SPEAKER"),
    570. 

  570. 	SND(2, "HEADSET"),
    571. 

  571. 	SND(3, "BT"),
    572. 

  572. 	SND(44, "BT_EC_OFF"),
    573. 

  573. 	SND(10, "HEADSET_AND_SPEAKER"),
    574. 

  574. 	SND(256, "CURRENT"),
    575. 

  575. 

  576. 	/* Bluetooth accessories. */
    577. 

  577. 

  578. 	SND(12, "HTC BH S100"),
    579. 

  579. 	SND(13, "HTC BH M100"),
    580. 

  580. 	SND(14, "Motorola H500"),
    581. 

  581. 	SND(15, "Nokia HS-36W"),
    582. 

  582. 	SND(16, "PLT 510v.D"),
    583. 

  583. 	SND(17, "M2500 by Plantronics"),
    584. 

  584. 	SND(18, "Nokia HDW-3"),
    585. 

  585. 	SND(19, "HBH-608"),
    586. 

  586. 	SND(20, "HBH-DS970"),
    587. 

  587. 	SND(21, "i.Tech BlueBAND"),
    588. 

  588. 	SND(22, "Nokia BH-800"),
    589. 

  589. 	SND(23, "Motorola H700"),
    590. 

  590. 	SND(24, "HTC BH M200"),
    591. 

  591. 	SND(25, "Jabra JX10"),
    592. 

  592. 	SND(26, "320Plantronics"),
    593. 

  593. 	SND(27, "640Plantronics"),
    594. 

  594. 	SND(28, "Jabra BT500"),
    595. 

  595. 	SND(29, "Motorola HT820"),
    596. 

  596. 	SND(30, "HBH-IV840"),
    597. 

  597. 	SND(31, "6XXPlantronics"),
    598. 

  598. 	SND(32, "3XXPlantronics"),
    599. 

  599. 	SND(33, "HBH-PV710"),
    600. 

  600. 	SND(34, "Motorola H670"),
    601. 

  601. 	SND(35, "HBM-300"),
    602. 

  602. 	SND(36, "Nokia BH-208"),
    603. 

  603. 	SND(37, "Samsung WEP410"),
    604. 

  604. 	SND(38, "Jabra BT8010"),
    605. 

  605. 	SND(39, "Motorola S9"),
    606. 

  606. 	SND(40, "Jabra BT620s"),
    607. 

  607. 	SND(41, "Nokia BH-902"),
    608. 

  608. 	SND(42, "HBH-DS220"),
    609. 

  609. 	SND(43, "HBH-DS980"),
    610. 

  610. };
    611. 

  611. #undef SND
    612. 

  612. 

  613. static struct msm_snd_endpoints trout_snd_endpoints = {
    614. 

  614. 	.endpoints = snd_endpoints_list,
    615. 

  615. 	.num = ARRAY_SIZE(snd_endpoints_list),
    616. 

  616. };
    617. 

  617. 

  618. static struct platform_device trout_snd = {
    619. 

  619. 	.name = "msm_snd",
    620. 

  620. 	.id = -1,
    621. 

  621. 	.dev	= {
    622. 

  622. 		.platform_data = &trout_snd_endpoints,
    623. 

  623. 	},
    624. 

  624. };
    625. 

  625. 

  626. static struct platform_device *devices[] __initdata = {
    627. 

  627. 	&msm_device_smd,
    628. 

  628. 	&msm_device_dmov,
    629. 

  629. 	&msm_device_nand,
    630. 

  630. 	&msm_device_i2c,
    631. 

  631. 	&msm_device_uart1,
    632. 

  632. #if !defined(CONFIG_MSM_SERIAL_DEBUGGER) && !defined(CONFIG_TROUT_H2W)
    633. 

  633. 	&msm_device_uart3,
    634. 

  634. #endif
    635. 

  635. #ifdef CONFIG_SERIAL_MSM_HS
    636. 

  636. 	&msm_device_uart_dm1,
    637. 

  637. #endif
    638. 

  638. 	&trout_nav_device,
    639. 

  639. 	&trout_reset_keys_device,
    640. 

  640. 	&android_leds,
    641. 

  641. 	&sd_door_switch,
    642. 

  642. 	&android_timed_gpios,
    643. 

  643. #ifdef CONFIG_MT9T013
    644. 

  644. 	&msm_camera_sensor_mt9t013,
    645. 

  645. #endif
    646. 

  646. #ifdef CONFIG_SENSORS_MT9T013
    647. 

  647. 	&trout_camera,
    648. 

  648. #endif
    649. 

  649. 	&trout_rfkill,
    650. 

  650. #ifdef CONFIG_WIFI_CONTROL_FUNC
    651. 

  651. 	&trout_wifi,
    652. 

  652. #endif
    653. 

  653. #ifdef CONFIG_HTC_HEADSET
    654. 

  654. 	&trout_h2w,
    655. 

  655. #endif
    656. 

  656. #ifdef CONFIG_HTC_PWRSINK
    657. 

  657. 	&trout_pwr_sink,
    658. 

  658. #endif
    659. 

  659. 	&trout_snd,
    660. 

  660. };
    661. 

  661. 

  662. extern struct sys_timer msm_timer;
    663. 

  663. 

  664. static void __init trout_init_irq(void)
    665. 

  665. {
    666. 

  666. 	printk("trout_init_irq()\n");
    667. 

  667. 	msm_init_irq();
    668. 

  668. }
    669. 

  669. 

  670. static uint opt_disable_uart3;
    671. 

  671. 

  672. module_param_named(disable_uart3, opt_disable_uart3, uint, 0);
    673. 

  673. 

  674. static void trout_reset(void)
    675. 

  675. {
    676. 

  676. 	gpio_set_value(TROUT_GPIO_PS_HOLD, 0);
    677. 

  677. }
    678. 

  678. 

  679. static uint32_t gpio_table[] = {
    680. 

  680. 	/* BLUETOOTH */
    681. 

  681. #ifdef CONFIG_SERIAL_MSM_HS
    682. 

  682. 	PCOM_GPIO_CFG(43, 2, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* RTS */
    683. 

  683. 	PCOM_GPIO_CFG(44, 2, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* CTS */
    684. 

  684. 	PCOM_GPIO_CFG(45, 2, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* RX */
    685. 

  685. 	PCOM_GPIO_CFG(46, 3, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* TX */
    686. 

  686. #else
    687. 

  687. 	PCOM_GPIO_CFG(43, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* RTS */
    688. 

  688. 	PCOM_GPIO_CFG(44, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* CTS */
    689. 

  689. 	PCOM_GPIO_CFG(45, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* RX */
    690. 

  690. 	PCOM_GPIO_CFG(46, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* TX */
    691. 

  691. #endif
    692. 

  692. };
    693. 

  693. 

  694. 

  695. static uint32_t camera_off_gpio_table[] = {
    696. 

  696. 	/* CAMERA */
    697. 

  697. 	PCOM_GPIO_CFG(2, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* DAT2 */
    698. 

  698. 	PCOM_GPIO_CFG(3, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* DAT3 */
    699. 

  699. 	PCOM_GPIO_CFG(4, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* DAT4 */
    700. 

  700. 	PCOM_GPIO_CFG(5, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* DAT5 */
    701. 

  701. 	PCOM_GPIO_CFG(6, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* DAT6 */
    702. 

  702. 	PCOM_GPIO_CFG(7, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* DAT7 */
    703. 

  703. 	PCOM_GPIO_CFG(8, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* DAT8 */
    704. 

  704. 	PCOM_GPIO_CFG(9, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* DAT9 */
    705. 

  705. 	PCOM_GPIO_CFG(10, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* DAT10 */
    706. 

  706. 	PCOM_GPIO_CFG(11, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* DAT11 */
    707. 

  707. 	PCOM_GPIO_CFG(12, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* PCLK */
    708. 

  708. 	PCOM_GPIO_CFG(13, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* HSYNC_IN */
    709. 

  709. 	PCOM_GPIO_CFG(14, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* VSYNC_IN */
    710. 

  710. 	PCOM_GPIO_CFG(15, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* MCLK */
    711. 

  711. };
    712. 

  712. 

  713. static uint32_t camera_on_gpio_table[] = {
    714. 

  714. 	/* CAMERA */
    715. 

  715. 	PCOM_GPIO_CFG(2, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* DAT2 */
    716. 

  716. 	PCOM_GPIO_CFG(3, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* DAT3 */
    717. 

  717. 	PCOM_GPIO_CFG(4, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* DAT4 */
    718. 

  718. 	PCOM_GPIO_CFG(5, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* DAT5 */
    719. 

  719. 	PCOM_GPIO_CFG(6, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* DAT6 */
    720. 

  720. 	PCOM_GPIO_CFG(7, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* DAT7 */
    721. 

  721. 	PCOM_GPIO_CFG(8, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* DAT8 */
    722. 

  722. 	PCOM_GPIO_CFG(9, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* DAT9 */
    723. 

  723. 	PCOM_GPIO_CFG(10, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* DAT10 */
    724. 

  724. 	PCOM_GPIO_CFG(11, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* DAT11 */
    725. 

  725. 	PCOM_GPIO_CFG(12, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_16MA), /* PCLK */
    726. 

  726. 	PCOM_GPIO_CFG(13, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* HSYNC_IN */
    727. 

  727. 	PCOM_GPIO_CFG(14, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* VSYNC_IN */
    728. 

  728. 	PCOM_GPIO_CFG(15, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_16MA), /* MCLK */
    729. 

  729. };
    730. 

  730. 

  731. static void config_gpio_table(uint32_t *table, int len)
    732. 

  732. {
    733. 

  733. 	int n;
    734. 

  734. 	unsigned id;
    735. 

  735. 	for(n = 0; n < len; n++) {
    736. 

  736. 		id = table[n];
    737. 

  737. 		msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &id, 0);
    738. 

  738. 	}
    739. 

  739. }
    740. 

  740. 

  741. static void config_camera_on_gpios(void)
    742. 

  742. {
    743. 

  743. 	config_gpio_table(camera_on_gpio_table,
    744. 

  744. 		ARRAY_SIZE(camera_on_gpio_table));
    745. 

  745. }
    746. 

  746. 

  747. static void config_camera_off_gpios(void)
    748. 

  748. {
    749. 

  749. 	config_gpio_table(camera_off_gpio_table,
    750. 

  750. 		ARRAY_SIZE(camera_off_gpio_table));
    751. 

  751. }
    752. 

  752. 

  753. static void __init config_gpios(void)
    754. 

  754. {
    755. 

  755. 	config_gpio_table(gpio_table, ARRAY_SIZE(gpio_table));
    756. 

  756. 	config_camera_off_gpios();
    757. 

  757. }
    758. 

  758. 

  759. void msm_serial_debug_init(unsigned int base, int irq,
    760. 

  760. 			   struct device *clk_device, int signal_irq);
    761. 

  761. 

  762. static struct msm_acpu_clock_platform_data trout_clock_data = {
    763. 

  763. 	.acpu_switch_time_us = 20,
    764. 

  764. 	.max_speed_delta_khz = 256000,
    765. 

  765. 	.vdd_switch_time_us = 62,
    766. 

  766. };
    767. 

  767. 

  768. #ifdef CONFIG_SERIAL_MSM_HS
    769. 

  769. static struct msm_serial_hs_platform_data msm_uart_dm1_pdata = {
    770. 

  770. 	.wakeup_irq = MSM_GPIO_TO_INT(45),
    771. 

  771. 	.inject_rx_on_wakeup = 1,
    772. 

  772. 	.rx_to_inject = 0x32,
    773. 

  773. };
    774. 

  774. #endif
    775. 

  775. 

  776. static struct msm_pm_platform_data msm_pm_data[MSM_PM_SLEEP_MODE_NR] = {
    777. 

  777. 	[MSM_PM_SLEEP_MODE_POWER_COLLAPSE].latency = 16000,
    778. 

  778. 	[MSM_PM_SLEEP_MODE_POWER_COLLAPSE_NO_XO_SHUTDOWN].latency = 12000,
    779. 

  779. 	[MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].latency = 2000,
    780. 

  780. };
    781. 

  781. 

  782. static void __init trout_init(void)
    783. 

  783. {
    784. 

  784. 	int rc;
    785. 

  785. 

  786. 	printk("trout_init() revision=%d\n", system_rev);
    787. 

  787. 

  788. 	/*
    789. 

  789. 	 * Setup common MSM GPIOS
    790. 

  790. 	 */
    791. 

  791. 	config_gpios();
    792. 

  792. 

  793. 	msm_hw_reset_hook = trout_reset;
    794. 

  794. 

  795. 	gpio_direction_output(system_rev < 5 ?
    796. 

  796. 			TROUT_4_TP_LS_EN : TROUT_5_TP_LS_EN, 0);
    797. 

  797. 

  798. 	msm_acpu_clock_init(&trout_clock_data);
    799. 

  799. 

  800. #if defined(CONFIG_MSM_SERIAL_DEBUGGER)
    801. 

  801. 	if (!opt_disable_uart3)
    802. 

  802. 		msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
    803. 

  803. 				      &msm_device_uart3.dev, 1);
    804. 

  804. #endif
    805. 

  805. 

  806. 	/* gpio_configure(108, IRQF_TRIGGER_LOW); */
    807. 

  807. 

  808. 	/* put the AF VCM in powerdown mode to avoid noise */
    809. 

  809. 	gpio_set_value(TROUT_GPIO_VCM_PWDN, 1);
    810. 

  810. 	mdelay(100);
    811. 

  811. 

  812. 	if (system_rev < 5) {
    813. 

  813. 		trout_x_axis.info.gpio = trout_4_x_axis_gpios;
    814. 

  814. 		trout_y_axis.info.gpio = trout_4_y_axis_gpios;
    815. 

  815. 	}
    816. 

  816. 

  817. #ifdef CONFIG_SERIAL_MSM_HS
    818. 

  818. 	msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
    819. 

  819. #endif
    820. 

  820. 	msm_add_usb_devices(trout_phy_reset);
    821. 

  821. 

  822. 	msm_add_mem_devices(&pmem_setting);
    823. 

  823. 

  824. 	rc = trout_init_mmc(system_rev);
    825. 

  825. 	if (rc)
    826. 

  826. 		printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
    827. 

  827. 

  828. #ifdef CONFIG_WIFI_MEM_PREALLOC
    829. 

  829. 	rc = trout_init_wifi_mem();
    830. 

  830. 	if (rc)
    831. 

  831. 		printk(KERN_CRIT "%s: WiFi Memory init failure (%d)\n", __func__, rc);
    832. 

  832. #endif
    833. 

  833. 

  834. 	platform_add_devices(devices, ARRAY_SIZE(devices));
    835. 

  835. 	i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
    836. 

  836. 	msm_pm_set_platform_data(msm_pm_data, ARRAY_SIZE(msm_pm_data));
    837. 

  837. 

  838. 	/* SD card door should wake the device */
    839. 

  839. 	set_irq_wake(TROUT_GPIO_TO_INT(TROUT_GPIO_SD_DOOR_N), 1);
    840. 

  840. }
    841. 

  841. 

  842. static struct map_desc trout_io_desc[] __initdata = {
    843. 

  843. 	{
    844. 

  844. 		.virtual = TROUT_CPLD_BASE,
    845. 

  845. 		.pfn     = __phys_to_pfn(TROUT_CPLD_START),
    846. 

  846. 		.length  = TROUT_CPLD_SIZE,
    847. 

  847. 		.type    = MT_DEVICE_NONSHARED
    848. 

  848. 	}
    849. 

  849. };
    850. 

  850. 

  851. static void __init trout_fixup(struct machine_desc *desc, struct tag *tags,
    852. 

  852. 				char **cmdline, struct meminfo *mi)
    853. 

  853. {
    854. 

  854. 	mi->nr_banks=1;
    855. 

  855. 	mi->bank[0].start = PHYS_OFFSET;
    856. 

  856. 	mi->bank[0].node = PHYS_TO_NID(PHYS_OFFSET);
    857. 

  857. 	mi->bank[0].size = (101*1024*1024);
    858. 

  858. }
    859. 

  859. 

  860. static void __init trout_map_io(void)
    861. 

  861. {
    862. 

  862. 	msm_shared_ram_phys = 0x01F00000;
    863. 

  863. 

  864. 	msm_map_common_io();
    865. 

  865. 	iotable_init(trout_io_desc, ARRAY_SIZE(trout_io_desc));
    866. 

  866. 	msm_clock_init(msm_clocks_7x01a, msm_num_clocks_7x01a);
    867. 

  867. }
    868. 

  868. 

  869. MACHINE_START(TROUT, "trout")
    870. 

  870. /* Maintainer: Brian Swetland <swetland@google.com> */
    871. 

  871. #ifdef CONFIG_MSM_DEBUG_UART
    872. 

  872. 	.phys_io        = MSM_DEBUG_UART_PHYS,
    873. 

  873. 	.io_pg_offst    = ((MSM_DEBUG_UART_BASE) >> 18) & 0xfffc,
    874. 

  874. #endif
    875. 

  875. 	.boot_params    = PHYS_OFFSET + 0x100,
    876. 

  876. 	.fixup          = trout_fixup,
    877. 

  877. 	.map_io         = trout_map_io,
    878. 

  878. 	.init_irq       = trout_init_irq,
    879. 

  879. 	.init_machine   = trout_init,
    880. 

  880. 	.timer          = &msm_timer,
    881. 

  881. MACHINE_END
    882.