fix-lid302dl-bitbang-all-the-way-baby.patch
[linux-2.6/openmoko-kernel/knife-kernel.git] / arch / arm / mach-s3c2440 / mach-gta02.c
blob0cc65d1a0f462a87e6df376514aad6b2b3e6f32f
1 /*
2 * linux/arch/arm/mach-s3c2440/mach-gta02.c
4 * S3C2440 Machine Support for the FIC GTA02 (Neo1973)
6 * Copyright (C) 2006-2007 by Openmoko, Inc.
7 * Author: Harald Welte <laforge@openmoko.org>
8 * All rights reserved.
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of
13 * the License, or (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23 * MA 02111-1307 USA
27 #include <linux/kernel.h>
28 #include <linux/types.h>
29 #include <linux/interrupt.h>
30 #include <linux/list.h>
31 #include <linux/delay.h>
32 #include <linux/timer.h>
33 #include <linux/init.h>
34 #include <linux/workqueue.h>
35 #include <linux/platform_device.h>
36 #include <linux/serial_core.h>
37 #include <linux/spi/spi.h>
38 #include <linux/spi/glamo.h>
39 #include <linux/spi/spi_bitbang.h>
40 #include <linux/mmc/host.h>
42 #include <linux/mtd/mtd.h>
43 #include <linux/mtd/nand.h>
44 #include <linux/mtd/nand_ecc.h>
45 #include <linux/mtd/partitions.h>
46 #include <linux/mtd/physmap.h>
48 #include <linux/pcf50633.h>
49 #include <linux/lis302dl.h>
51 #include <asm/mach/arch.h>
52 #include <asm/mach/map.h>
53 #include <asm/mach/irq.h>
55 #include <asm/hardware.h>
56 #include <asm/io.h>
57 #include <asm/irq.h>
58 #include <asm/mach-types.h>
60 #include <asm/arch-s3c2410/regs-irq.h>
61 #include <asm/arch/regs-gpio.h>
62 #include <asm/arch/regs-gpioj.h>
63 #include <asm/arch/fb.h>
64 #include <asm/arch/mci.h>
65 #include <asm/arch/ts.h>
66 #include <asm/arch/spi.h>
67 #include <asm/arch/spi-gpio.h>
68 #include <asm/arch/usb-control.h>
70 #include <asm/arch/gta02.h>
72 #include <asm/plat-s3c/regs-serial.h>
73 #include <asm/plat-s3c/nand.h>
74 #include <asm/plat-s3c24xx/devs.h>
75 #include <asm/plat-s3c24xx/cpu.h>
76 #include <asm/plat-s3c24xx/pm.h>
77 #include <asm/plat-s3c24xx/udc.h>
78 #include <asm/plat-s3c24xx/neo1973.h>
79 #include <asm/arch-s3c2410/neo1973-pm-gsm.h>
81 #include <linux/jbt6k74.h>
83 #include <linux/glamofb.h>
85 #include <asm/arch/fiq_ipc_gta02.h>
86 #include "fiq_c_isr.h"
87 #include <linux/gta02_hdq.h>
88 #include <linux/bq27000_battery.h>
89 #include <linux/neospy.h>
91 #include "../plat-s3c24xx/neo1973_pm_gps.h"
93 /* arbitrates which sensor IRQ owns the shared SPI bus */
94 static spinlock_t motion_irq_lock;
96 /* the dependency of jbt / LCM on pcf50633 resume */
97 struct resume_dependency resume_dep_jbt_pcf;
98 /* the dependency of jbt / LCM on glamo resume */
99 struct resume_dependency resume_dep_jbt_glamo;
100 /* the dependency of Glamo MCI on pcf50633 resume (has to power SD slot) */
101 struct resume_dependency resume_dep_glamo_mci_pcf;
104 static int gta02_charger_online_status;
105 static int gta02_charger_active_status;
107 /* define FIQ IPC struct */
109 * contains stuff FIQ ISR modifies and normal kernel code can see and use
110 * this is defined in <asm/arch/fiq_ipc_gta02.h>, you should customize
111 * the definition in there and include the same definition in your kernel
112 * module that wants to interoperate with your FIQ code.
114 struct fiq_ipc fiq_ipc;
115 EXPORT_SYMBOL(fiq_ipc);
117 #define DIVISOR_FROM_US(x) ((x) << 1)
119 #define FIQ_DIVISOR_VIBRATOR DIVISOR_FROM_US(100)
121 #ifdef CONFIG_GTA02_HDQ
122 /* HDQ specific */
123 #define HDQ_SAMPLE_PERIOD_US 20
124 /* private HDQ FSM state -- all other info interesting for caller in fiq_ipc */
125 static enum hdq_bitbang_states hdq_state;
126 static u8 hdq_ctr;
127 static u8 hdq_ctr2;
128 static u8 hdq_bit;
129 static u8 hdq_shifter;
130 static u8 hdq_tx_data_done;
132 #define FIQ_DIVISOR_HDQ DIVISOR_FROM_US(HDQ_SAMPLE_PERIOD_US)
133 #endif
134 /* define FIQ ISR */
136 FIQ_HANDLER_START()
137 /* define your locals here -- no initializers though */
138 u16 divisor;
139 FIQ_HANDLER_ENTRY(256, 512)
140 /* Your ISR here :-) */
141 divisor = 0xffff;
143 /* Vibrator servicing */
145 if (fiq_ipc.vib_pwm_latched || fiq_ipc.vib_pwm) { /* not idle */
146 if (((u8)_fiq_count_fiqs) == fiq_ipc.vib_pwm_latched)
147 neo1973_gpb_setpin(fiq_ipc.vib_gpio_pin, 0);
148 if (((u8)_fiq_count_fiqs) == 0) {
149 fiq_ipc.vib_pwm_latched = fiq_ipc.vib_pwm;
150 if (fiq_ipc.vib_pwm_latched)
151 neo1973_gpb_setpin(fiq_ipc.vib_gpio_pin, 1);
153 divisor = FIQ_DIVISOR_VIBRATOR;
156 #ifdef CONFIG_GTA02_HDQ
157 /* HDQ servicing */
159 switch (hdq_state) {
160 case HDQB_IDLE:
161 if (fiq_ipc.hdq_request_ctr == fiq_ipc.hdq_transaction_ctr)
162 break;
163 hdq_ctr = 210 / HDQ_SAMPLE_PERIOD_US;
164 s3c2410_gpio_setpin(fiq_ipc.hdq_gpio_pin, 0);
165 s3c2410_gpio_cfgpin(fiq_ipc.hdq_gpio_pin, S3C2410_GPIO_OUTPUT);
166 hdq_tx_data_done = 0;
167 hdq_state = HDQB_TX_BREAK;
168 break;
170 case HDQB_TX_BREAK: /* issue low for > 190us */
171 if (--hdq_ctr == 0) {
172 hdq_ctr = 60 / HDQ_SAMPLE_PERIOD_US;
173 hdq_state = HDQB_TX_BREAK_RECOVERY;
174 s3c2410_gpio_setpin(fiq_ipc.hdq_gpio_pin, 1);
176 break;
178 case HDQB_TX_BREAK_RECOVERY: /* issue low for > 40us */
179 if (--hdq_ctr)
180 break;
181 hdq_shifter = fiq_ipc.hdq_ads;
182 hdq_bit = 8; /* 8 bits of ads / rw */
183 hdq_tx_data_done = 0; /* doing ads */
184 /* fallthru on last one */
185 case HDQB_ADS_CALC:
186 if (hdq_shifter & 1)
187 hdq_ctr = 50 / HDQ_SAMPLE_PERIOD_US;
188 else
189 hdq_ctr = 120 / HDQ_SAMPLE_PERIOD_US;
190 /* carefully precompute the other phase length */
191 hdq_ctr2 = (210 - (hdq_ctr * HDQ_SAMPLE_PERIOD_US)) /
192 HDQ_SAMPLE_PERIOD_US;
193 hdq_state = HDQB_ADS_LOW;
194 hdq_shifter >>= 1;
195 hdq_bit--;
196 s3c2410_gpio_setpin(fiq_ipc.hdq_gpio_pin, 0);
197 break;
199 case HDQB_ADS_LOW:
200 if (--hdq_ctr)
201 break;
202 s3c2410_gpio_setpin(fiq_ipc.hdq_gpio_pin, 1);
203 hdq_state = HDQB_ADS_HIGH;
204 break;
206 case HDQB_ADS_HIGH:
207 if (--hdq_ctr2 > 1) /* account for HDQB_ADS_CALC */
208 break;
209 if (hdq_bit) { /* more bits to do */
210 hdq_state = HDQB_ADS_CALC;
211 break;
213 /* no more bits, wait it out until hdq_ctr2 exhausted */
214 if (hdq_ctr2)
215 break;
216 /* ok no more bits and very last state */
217 hdq_ctr = 60 / HDQ_SAMPLE_PERIOD_US;
218 /* FIXME 0 = read */
219 if (fiq_ipc.hdq_ads & 0x80) { /* write the byte out */
220 /* set delay before payload */
221 hdq_ctr = 300 / HDQ_SAMPLE_PERIOD_US;
222 /* already high, no need to write */
223 hdq_state = HDQB_WAIT_TX;
224 break;
226 /* read the next byte */
227 hdq_bit = 8; /* 8 bits of data */
228 hdq_ctr = 3000 / HDQ_SAMPLE_PERIOD_US;
229 hdq_state = HDQB_WAIT_RX;
230 s3c2410_gpio_cfgpin(fiq_ipc.hdq_gpio_pin, S3C2410_GPIO_INPUT);
231 break;
233 case HDQB_WAIT_TX: /* issue low for > 40us */
234 if (--hdq_ctr)
235 break;
236 if (!hdq_tx_data_done) { /* was that the data sent? */
237 hdq_tx_data_done++;
238 hdq_shifter = fiq_ipc.hdq_tx_data;
239 hdq_bit = 8; /* 8 bits of data */
240 hdq_state = HDQB_ADS_CALC; /* start sending */
241 break;
243 fiq_ipc.hdq_error = 0;
244 fiq_ipc.hdq_transaction_ctr++;
245 hdq_state = HDQB_IDLE; /* all tx is done */
246 /* idle in input mode, it's pulled up by 10K */
247 s3c2410_gpio_cfgpin(fiq_ipc.hdq_gpio_pin, S3C2410_GPIO_INPUT);
248 break;
250 case HDQB_WAIT_RX: /* wait for battery to talk to us */
251 if (s3c2410_gpio_getpin(fiq_ipc.hdq_gpio_pin) == 0) {
252 /* it talks to us! */
253 hdq_ctr2 = 1;
254 hdq_bit = 8; /* 8 bits of data */
255 /* timeout */
256 hdq_ctr = 300 / HDQ_SAMPLE_PERIOD_US;
257 hdq_state = HDQB_DATA_RX_LOW;
258 break;
260 if (--hdq_ctr == 0) { /* timed out, error */
261 fiq_ipc.hdq_error = 1;
262 fiq_ipc.hdq_transaction_ctr++;
263 hdq_state = HDQB_IDLE; /* abort */
265 break;
268 * HDQ basically works by measuring the low time of the bit cell
269 * 32-50us --> '1', 80 - 145us --> '0'
272 case HDQB_DATA_RX_LOW:
273 if (s3c2410_gpio_getpin(fiq_ipc.hdq_gpio_pin)) {
274 fiq_ipc.hdq_rx_data >>= 1;
275 if (hdq_ctr2 <= (65 / HDQ_SAMPLE_PERIOD_US))
276 fiq_ipc.hdq_rx_data |= 0x80;
278 if (--hdq_bit == 0) {
279 fiq_ipc.hdq_error = 0;
280 fiq_ipc.hdq_transaction_ctr++; /* done */
281 hdq_state = HDQB_IDLE;
282 } else
283 hdq_state = HDQB_DATA_RX_HIGH;
284 /* timeout */
285 hdq_ctr = 1000 / HDQ_SAMPLE_PERIOD_US;
286 hdq_ctr2 = 1;
287 break;
289 hdq_ctr2++;
290 if (--hdq_ctr)
291 break;
292 /* timed out, error */
293 fiq_ipc.hdq_error = 2;
294 fiq_ipc.hdq_transaction_ctr++;
295 hdq_state = HDQB_IDLE; /* abort */
296 break;
298 case HDQB_DATA_RX_HIGH:
299 if (!s3c2410_gpio_getpin(fiq_ipc.hdq_gpio_pin)) {
300 /* it talks to us! */
301 hdq_ctr2 = 1;
302 /* timeout */
303 hdq_ctr = 400 / HDQ_SAMPLE_PERIOD_US;
304 hdq_state = HDQB_DATA_RX_LOW;
305 break;
307 if (--hdq_ctr)
308 break;
309 /* timed out, error */
310 fiq_ipc.hdq_error = 3;
311 fiq_ipc.hdq_transaction_ctr++;
312 /* we're in input mode already */
313 hdq_state = HDQB_IDLE; /* abort */
314 break;
317 if (hdq_state != HDQB_IDLE) /* ie, not idle */
318 if (divisor > FIQ_DIVISOR_HDQ)
319 divisor = FIQ_DIVISOR_HDQ; /* keep us going */
320 #endif
322 /* disable further timer interrupts if nobody has any work
323 * or adjust rate according to who still has work
325 * CAUTION: it means forground code must disable FIQ around
326 * its own non-atomic S3C2410_INTMSK changes... not common
327 * thankfully and taken care of by the fiq-basis patch
329 if (divisor == 0xffff) /* mask the fiq irq source */
330 __raw_writel(__raw_readl(S3C2410_INTMSK) | _fiq_ack_mask,
331 S3C2410_INTMSK);
332 else /* still working, maybe at a different rate */
333 __raw_writel(divisor, S3C2410_TCNTB(_fiq_timer_index));
334 _fiq_timer_divisor = divisor;
336 FIQ_HANDLER_END()
340 * this gets called every 1ms when we paniced.
343 static long gta02_panic_blink(long count)
345 long delay = 0;
346 static long last_blink;
347 static char led;
349 if (count - last_blink < 100) /* 200ms period, fast blink */
350 return 0;
352 led ^= 1;
353 s3c2410_gpio_cfgpin(GTA02_GPIO_AUX_LED, S3C2410_GPIO_OUTPUT);
354 neo1973_gpb_setpin(GTA02_GPIO_AUX_LED, led);
356 last_blink = count;
357 return delay;
362 * returns PCB revision information in b9,b8 and b2,b1,b0
363 * Pre-GTA02 A6 returns 0x000
364 * GTA02 A6 returns 0x101
365 * ...
368 int gta02_get_pcb_revision(void)
370 int n;
371 int u = 0;
372 static unsigned long pinlist[] = {
373 GTA02_PCB_ID1_0,
374 GTA02_PCB_ID1_1,
375 GTA02_PCB_ID1_2,
376 GTA02_PCB_ID2_0,
377 GTA02_PCB_ID2_1,
379 static int pin_offset[] = {
380 0, 1, 2, 8, 9
383 for (n = 0 ; n < ARRAY_SIZE(pinlist); n++) {
385 * set the PCB version GPIO to be pulled-down input
386 * force low briefly first
388 s3c2410_gpio_cfgpin(pinlist[n], S3C2410_GPIO_OUTPUT);
389 s3c2410_gpio_setpin(pinlist[n], 0);
390 /* misnomer: it is a pullDOWN in 2442 */
391 s3c2410_gpio_pullup(pinlist[n], 1);
392 s3c2410_gpio_cfgpin(pinlist[n], S3C2410_GPIO_INPUT);
394 udelay(10);
396 if (s3c2410_gpio_getpin(pinlist[n]))
397 u |= 1 << pin_offset[n];
400 * when not being interrogated, all of the revision GPIO
401 * are set to output HIGH without pulldown so no current flows
402 * if they are NC or pulled up.
404 s3c2410_gpio_setpin(pinlist[n], 1);
405 s3c2410_gpio_cfgpin(pinlist[n], S3C2410_GPIO_OUTPUT);
406 /* misnomer: it is a pullDOWN in 2442 */
407 s3c2410_gpio_pullup(pinlist[n], 0);
410 return u;
413 struct platform_device gta02_version_device = {
414 .name = "neo1973-version",
415 .num_resources = 0,
418 struct platform_device gta02_resume_reason_device = {
419 .name = "neo1973-resume",
420 .num_resources = 0,
423 struct platform_device gta02_memconfig_device = {
424 .name = "neo1973-memconfig",
425 .num_resources = 0,
428 static struct map_desc gta02_iodesc[] __initdata = {
430 .virtual = 0xe0000000,
431 .pfn = __phys_to_pfn(S3C2410_CS3+0x01000000),
432 .length = SZ_1M,
433 .type = MT_DEVICE
437 #define UCON S3C2410_UCON_DEFAULT
438 #define ULCON S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB
439 #define UFCON S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_FIFOMODE
441 static struct s3c2410_uartcfg gta02_uartcfgs[] = {
442 [0] = {
443 .hwport = 0,
444 .flags = 0,
445 .ucon = UCON,
446 .ulcon = ULCON,
447 .ufcon = UFCON,
449 [1] = {
450 .hwport = 1,
451 .flags = 0,
452 .ucon = UCON,
453 .ulcon = ULCON,
454 .ufcon = UFCON,
456 [2] = {
457 .hwport = 2,
458 .flags = 0,
459 .ucon = UCON,
460 .ulcon = ULCON,
461 .ufcon = UFCON,
466 /* BQ27000 Battery */
468 static int gta02_get_charger_online_status(void)
470 return gta02_charger_online_status;
473 static int gta02_get_charger_active_status(void)
475 return gta02_charger_active_status;
479 struct bq27000_platform_data bq27000_pdata = {
480 .name = "bat",
481 .rsense_mohms = 20,
482 .hdq_read = gta02hdq_read,
483 .hdq_write = gta02hdq_write,
484 .hdq_initialized = gta02hdq_initialized,
485 .get_charger_online_status = gta02_get_charger_online_status,
486 .get_charger_active_status = gta02_get_charger_active_status
489 struct platform_device bq27000_battery_device = {
490 .name = "bq27000-battery",
491 .dev = {
492 .platform_data = &bq27000_pdata,
497 /* PMU driver info */
499 static int pmu_callback(struct device *dev, unsigned int feature,
500 enum pmu_event event)
502 switch (feature) {
503 case PCF50633_FEAT_MBC:
504 switch (event) {
505 case PMU_EVT_CHARGER_IDLE:
506 gta02_charger_active_status = 0;
507 break;
508 case PMU_EVT_CHARGER_ACTIVE:
509 gta02_charger_active_status = 1;
510 break;
511 case PMU_EVT_USB_INSERT:
512 gta02_charger_online_status = 1;
513 break;
514 case PMU_EVT_USB_REMOVE:
515 gta02_charger_online_status = 0;
516 break;
517 case PMU_EVT_INSERT: /* adapter is unsused */
518 case PMU_EVT_REMOVE: /* adapter is unused */
519 break;
520 default:
521 break;
523 break;
524 default:
525 break;
528 bq27000_charging_state_change(&bq27000_battery_device);
529 return 0;
532 static struct platform_device gta01_pm_gps_dev = {
533 .name = "neo1973-pm-gps",
536 static struct platform_device gta01_pm_bt_dev = {
537 .name = "neo1973-pm-bt",
540 /* this is called when pc50633 is probed, unfortunately quite late in the
541 * day since it is an I2C bus device. Here we can belatedly define some
542 * platform devices with the advantage that we can mark the pcf50633 as the
543 * parent. This makes them get suspended and resumed with their parent
544 * the pcf50633 still around.
547 static void gta02_pcf50633_attach_child_devices(struct device *parent_device)
549 gta01_pm_gps_dev.dev.parent = parent_device;
550 gta01_pm_bt_dev.dev.parent = parent_device;
551 platform_device_register(&gta01_pm_bt_dev);
552 platform_device_register(&gta01_pm_gps_dev);
555 static struct pcf50633_platform_data gta02_pcf_pdata = {
556 .used_features = PCF50633_FEAT_MBC |
557 PCF50633_FEAT_BBC |
558 PCF50633_FEAT_RTC |
559 PCF50633_FEAT_CHGCUR |
560 PCF50633_FEAT_BATVOLT |
561 PCF50633_FEAT_BATTEMP |
562 PCF50633_FEAT_PWM_BL,
563 .onkey_seconds_sig_init = 4,
564 .onkey_seconds_shutdown = 8,
565 .cb = &pmu_callback,
566 .r_fix_batt = 10000,
567 .r_fix_batt_par = 10000,
568 .r_sense_milli = 220,
569 .flag_use_apm_emulation = 0,
570 .resumers = {
571 [0] = PCF50633_INT1_USBINS |
572 PCF50633_INT1_USBREM |
573 PCF50633_INT1_ALARM,
574 [1] = PCF50633_INT2_ONKEYF,
575 [2] = PCF50633_INT3_ONKEY1S
577 /* warning: these get rewritten during machine init below
578 * depending on pcb variant
580 .rails = {
581 [PCF50633_REGULATOR_AUTO] = {
582 .name = "io_3v3",
583 .flags = PMU_VRAIL_F_SUSPEND_ON,
584 .voltage = {
585 .init = 3300,
586 .max = 3300,
589 [PCF50633_REGULATOR_DOWN1] = {
590 .name = "core_1v3",
591 /* Wow, when we are going into suspend, after pcf50633
592 * runs its suspend (which happens real early since it
593 * is an i2c device) we are running out of the 22uF cap
594 * on core_1v3 rail !!!!
596 .voltage = {
597 .init = 1300,
598 .max = 1600,
601 [PCF50633_REGULATOR_DOWN2] = {
602 .name = "core_1v8",
603 .flags = PMU_VRAIL_F_SUSPEND_ON,
604 .voltage = {
605 .init = 1800,
606 .max = 1800,
609 [PCF50633_REGULATOR_HCLDO] = {
610 .name = "sd_3v3",
611 .voltage = {
612 .init = 2000,
613 .max = 3300,
616 [PCF50633_REGULATOR_LDO1] = {
617 .name = "gsensor_3v3",
618 .voltage = {
619 .init = 1300,
620 .max = 1330,
623 [PCF50633_REGULATOR_LDO2] = {
624 .name = "codec_3v3",
625 .voltage = {
626 .init = 3300,
627 .max = 3300,
630 [PCF50633_REGULATOR_LDO3] = {
631 .name = "unused3",
632 .voltage = {
633 .init = 3000,
634 .max = 3000,
637 [PCF50633_REGULATOR_LDO4] = {
638 .name = "bt_3v2",
639 .voltage = {
640 .init = 2500,
641 .max = 3300,
644 [PCF50633_REGULATOR_LDO5] = {
645 .name = "rf3v",
646 .voltage = {
647 .init = 1500,
648 .max = 1500,
651 [PCF50633_REGULATOR_LDO6] = {
652 .name = "lcm_3v",
653 .flags = PMU_VRAIL_F_SUSPEND_ON,
654 .voltage = {
655 .init = 0,
656 .max = 3300,
659 [PCF50633_REGULATOR_MEMLDO] = {
660 .name = "memldo",
661 .flags = PMU_VRAIL_F_SUSPEND_ON,
662 .voltage = {
663 .init = 1800,
664 .max = 1800,
668 .defer_resume_backlight = 1,
669 .resume_backlight_ramp_speed = 5,
670 .attach_child_devices = gta02_pcf50633_attach_child_devices
674 #if 0 /* currently unused */
675 static void cfg_pmu_vrail(struct pmu_voltage_rail *vrail, char *name,
676 unsigned int flags, unsigned int init,
677 unsigned int max)
679 vrail->name = name;
680 vrail->flags = flags;
681 vrail->voltage.init = init;
682 vrail->voltage.max = max;
684 #endif
686 static void mangle_pmu_pdata_by_system_rev(void)
688 switch (system_rev) {
689 case GTA02v1_SYSTEM_REV:
690 /* FIXME: this is only in v1 due to wrong PMU variant */
691 gta02_pcf_pdata.rails[PCF50633_REGULATOR_DOWN2].flags =
692 PMU_VRAIL_F_SUSPEND_ON;
693 break;
694 case GTA02v2_SYSTEM_REV:
695 case GTA02v3_SYSTEM_REV:
696 case GTA02v4_SYSTEM_REV:
697 case GTA02v5_SYSTEM_REV:
698 case GTA02v6_SYSTEM_REV:
699 /* we need to keep the 1.8V going since this is the SDRAM
700 * self-refresh voltage */
701 gta02_pcf_pdata.rails[PCF50633_REGULATOR_DOWN2].flags =
702 PMU_VRAIL_F_SUSPEND_ON;
703 gta02_pcf_pdata.rails[PCF50633_REGULATOR_DOWN2].name =
704 "io_1v8",
705 gta02_pcf_pdata.rails[PCF50633_REGULATOR_LDO1].name =
706 "gsensor_3v3",
707 gta02_pcf_pdata.rails[PCF50633_REGULATOR_LDO1].voltage.init =
708 3300;
709 gta02_pcf_pdata.rails[PCF50633_REGULATOR_LDO1].voltage.max =
710 3300;
711 gta02_pcf_pdata.rails[PCF50633_REGULATOR_LDO1].flags &=
712 ~PMU_VRAIL_F_SUSPEND_ON;
713 gta02_pcf_pdata.rails[PCF50633_REGULATOR_LDO3].flags =
714 PMU_VRAIL_F_UNUSED;
715 gta02_pcf_pdata.rails[PCF50633_REGULATOR_LDO5] = ((struct pmu_voltage_rail) {
716 .name = "rf_3v",
717 .voltage = {
718 .init = 0,
719 .max = 3000,
722 gta02_pcf_pdata.rails[PCF50633_REGULATOR_LDO6] =
723 ((struct pmu_voltage_rail) {
724 .name = "lcm_3v",
725 .flags = PMU_VRAIL_F_SUSPEND_ON,
726 .voltage = {
727 .init = 3000,
728 .max = 3000,
731 break;
732 default:
733 break;
737 static struct resource gta02_pmu_resources[] = {
738 [0] = {
739 .flags = IORESOURCE_IRQ,
740 .start = GTA02_IRQ_PCF50633,
741 .end = GTA02_IRQ_PCF50633,
745 struct platform_device gta02_pmu_dev = {
746 .name = "pcf50633",
747 .num_resources = ARRAY_SIZE(gta02_pmu_resources),
748 .resource = gta02_pmu_resources,
749 .dev = {
750 .platform_data = &gta02_pcf_pdata,
754 /* FIQ */
756 static struct resource sc32440_fiq_resources[] = {
757 [0] = {
758 .flags = IORESOURCE_IRQ,
759 .start = IRQ_TIMER3,
760 .end = IRQ_TIMER3,
764 struct platform_device sc32440_fiq_device = {
765 .name = "sc32440_fiq",
766 .num_resources = 1,
767 .resource = sc32440_fiq_resources,
770 #ifdef CONFIG_GTA02_HDQ
771 /* HDQ */
773 static struct resource gta02_hdq_resources[] = {
774 [0] = {
775 .start = GTA02v5_GPIO_HDQ,
776 .end = GTA02v5_GPIO_HDQ,
780 struct platform_device gta02_hdq_device = {
781 .name = "gta02-hdq",
782 .num_resources = 1,
783 .resource = gta02_hdq_resources,
785 #endif
788 /* NOR Flash */
790 #define GTA02_FLASH_BASE 0x18000000 /* GCS3 */
791 #define GTA02_FLASH_SIZE 0x200000 /* 2MBytes */
793 static struct physmap_flash_data gta02_nor_flash_data = {
794 .width = 2,
797 static struct resource gta02_nor_flash_resource = {
798 .start = GTA02_FLASH_BASE,
799 .end = GTA02_FLASH_BASE + GTA02_FLASH_SIZE - 1,
800 .flags = IORESOURCE_MEM,
803 static struct platform_device gta02_nor_flash = {
804 .name = "physmap-flash",
805 .id = 0,
806 .dev = {
807 .platform_data = &gta02_nor_flash_data,
809 .resource = &gta02_nor_flash_resource,
810 .num_resources = 1,
815 static struct resource gta02_sdio_resources[] = {
816 [0] = {
817 .flags = IORESOURCE_IRQ,
818 .start = IRQ_SDI,
819 .end = IRQ_SDI,
821 [1] = {
822 .flags = IORESOURCE_MEM,
823 .start = S3C2410_PA_SDI,
824 .end = S3C2410_PA_SDI + S3C24XX_SZ_SDI - 1,
826 [2] = {
827 .flags = IORESOURCE_DMA,
828 .start = 0, /* Channel 0 for SDI */
829 .end = 0,
834 static struct platform_device gta02_sdio_dev = {
835 .name = "s3c24xx-sdio",
836 .id = -1,
837 .dev = {
838 .coherent_dma_mask = 0xffffffff,
840 .resource = gta02_sdio_resources,
841 .num_resources = ARRAY_SIZE(gta02_sdio_resources),
844 struct platform_device s3c24xx_pwm_device = {
845 .name = "s3c24xx_pwm",
846 .num_resources = 0,
850 static struct platform_device *gta02_devices[] __initdata = {
851 &s3c_device_usb,
852 &s3c_device_wdt,
853 &s3c_device_i2c,
854 &s3c_device_iis,
855 // &s3c_device_sdi, /* FIXME: temporary disable to avoid s3cmci bind */
856 &s3c_device_usbgadget,
857 &s3c_device_nand,
858 &s3c_device_ts,
859 &gta02_nor_flash,
860 &sc32440_fiq_device,
861 &gta02_version_device,
862 &gta02_memconfig_device,
863 &gta02_resume_reason_device,
864 &s3c24xx_pwm_device,
868 static struct s3c2410_nand_set gta02_nand_sets[] = {
869 [0] = {
870 .name = "neo1973-nand",
871 .nr_chips = 1,
872 .flags = S3C2410_NAND_BBT,
876 /* choose a set of timings which should suit most 512Mbit
877 * chips and beyond.
880 static struct s3c2410_platform_nand gta02_nand_info = {
881 .tacls = 20,
882 .twrph0 = 60,
883 .twrph1 = 20,
884 .nr_sets = ARRAY_SIZE(gta02_nand_sets),
885 .sets = gta02_nand_sets,
886 .software_ecc = 1,
889 static struct s3c24xx_mci_pdata gta02_mmc_cfg = {
890 .gpio_detect = GTA02v1_GPIO_nSD_DETECT,
891 .set_power = NULL,
892 .ocr_avail = MMC_VDD_32_33,
895 static void gta02_udc_command(enum s3c2410_udc_cmd_e cmd)
897 printk(KERN_DEBUG "%s(%d)\n", __func__, cmd);
899 switch (cmd) {
900 case S3C2410_UDC_P_ENABLE:
901 neo1973_gpb_setpin(GTA02_GPIO_USB_PULLUP, 1);
902 break;
903 case S3C2410_UDC_P_DISABLE:
904 neo1973_gpb_setpin(GTA02_GPIO_USB_PULLUP, 0);
905 break;
906 case S3C2410_UDC_P_RESET:
907 /* FIXME! */
908 break;
909 default:
910 break;
914 /* get PMU to set USB current limit accordingly */
916 static void gta02_udc_vbus_draw(unsigned int ma)
918 if (!pcf50633_global)
919 return;
921 pcf50633_notify_usb_current_limit_change(pcf50633_global, ma);
924 static struct s3c2410_udc_mach_info gta02_udc_cfg = {
925 .vbus_draw = gta02_udc_vbus_draw,
926 .udc_command = gta02_udc_command,
930 static struct s3c2410_ts_mach_info gta02_ts_cfg = {
931 .delay = 10000,
932 .presc = 50000000 / 1000000, /* 50 MHz PCLK / 1MHz */
933 /* simple averaging, 2^n samples */
934 .oversampling_shift = 5,
935 /* averaging filter length, 2^n */
936 .excursion_filter_len_bits = 5,
937 /* flagged for beauty contest on next sample if differs from
938 * average more than this
940 .reject_threshold_vs_avg = 2,
944 /* SPI: LCM control interface attached to Glamo3362 */
946 static void gta02_jbt6k74_reset(int devidx, int level)
948 glamo_lcm_reset(level);
951 /* finally bring up deferred backlight resume now LCM is resumed itself */
953 static void gta02_jbt6k74_resuming(int devidx)
955 pcf50633_backlight_resume(pcf50633_global);
958 static int gta02_jbt6k74_all_dependencies_resumed(int devidx)
960 if (!resume_dep_jbt_pcf.called_flag)
961 return 0;
963 if (!resume_dep_jbt_glamo.called_flag)
964 return 0;
966 return 1;
969 /* register jbt resume action to be dependent on pcf50633 and glamo resume */
971 static void gta02_jbt6k74_suspending(int devindex, struct spi_device *spi)
973 void jbt6k74_resume(void *spi); /* little white lies about types */
975 resume_dep_jbt_pcf.callback = jbt6k74_resume;
976 resume_dep_jbt_pcf.context = (void *)spi;
977 pcf50633_register_resume_dependency(pcf50633_global,
978 &resume_dep_jbt_pcf);
979 resume_dep_jbt_glamo.callback = jbt6k74_resume;
980 resume_dep_jbt_glamo.context = (void *)spi;
981 glamo_register_resume_dependency(&resume_dep_jbt_glamo);
985 const struct jbt6k74_platform_data jbt6k74_pdata = {
986 .reset = gta02_jbt6k74_reset,
987 .resuming = gta02_jbt6k74_resuming,
988 .suspending = gta02_jbt6k74_suspending,
989 .all_dependencies_resumed = gta02_jbt6k74_all_dependencies_resumed,
992 static struct spi_board_info gta02_spi_board_info[] = {
994 .modalias = "jbt6k74",
995 /* platform_data */
996 .platform_data = &jbt6k74_pdata,
997 /* controller_data */
998 /* irq */
999 .max_speed_hz = 10 * 1000 * 1000,
1000 .bus_num = 2,
1001 /* chip_select */
1005 #if 0 /* currently this is not used and we use gpio spi */
1006 static struct glamo_spi_info glamo_spi_cfg = {
1007 .board_size = ARRAY_SIZE(gta02_spi_board_info),
1008 .board_info = gta02_spi_board_info,
1010 #endif /* 0 */
1012 static struct glamo_spigpio_info glamo_spigpio_cfg = {
1013 .pin_clk = GLAMO_GPIO10_OUTPUT,
1014 .pin_mosi = GLAMO_GPIO11_OUTPUT,
1015 .pin_cs = GLAMO_GPIO12_OUTPUT,
1016 .pin_miso = 0,
1017 .board_size = ARRAY_SIZE(gta02_spi_board_info),
1018 .board_info = gta02_spi_board_info,
1021 static struct resource gta02_vibrator_resources[] = {
1022 [0] = {
1023 .start = GTA02_GPIO_VIBRATOR_ON,
1024 .end = GTA02_GPIO_VIBRATOR_ON,
1028 static struct platform_device gta02_vibrator_dev = {
1029 .name = "neo1973-vibrator",
1030 .num_resources = ARRAY_SIZE(gta02_vibrator_resources),
1031 .resource = gta02_vibrator_resources,
1034 /* SPI: Accelerometers attached to SPI of s3c244x */
1037 * Situation is that Linux SPI can't work in an interrupt context, so we
1038 * implement our own bitbang here. Arbitration is needed because not only
1039 * can this interrupt happen at any time even if foreground wants to use
1040 * the bitbang API from Linux, but multiple motion sensors can be on the
1041 * same SPI bus, and multiple interrupts can happen.
1043 * Foreground / interrupt arbitration is okay because the interrupts are
1044 * disabled around all the foreground SPI code.
1046 * Interrupt / Interrupt arbitration is evidently needed, otherwise we
1047 * lose edge-triggered service after a while due to the two sensors sharing
1048 * the SPI bus having irqs at the same time eventually.
1050 * Servicing is typ 75 - 100us at 400MHz.
1053 /* #define DEBUG_SPEW_MS */
1054 #define MG_PER_SAMPLE 18
1056 struct lis302dl_platform_data lis302_pdata_top;
1057 struct lis302dl_platform_data lis302_pdata_bottom;
1060 * generic SPI RX and TX bitbang
1061 * only call with interrupts off!
1064 static void __gta02_lis302dl_bitbang(struct lis302dl_info *lis, u8 *tx,
1065 int tx_bytes, u8 *rx, int rx_bytes)
1067 struct lis302dl_platform_data *pdata = lis->pdata;
1068 int n;
1069 u8 shifter = 0;
1070 unsigned long other_cs;
1073 * Huh.. "quirk"... CS on this device is not really "CS" like you can
1074 * expect. Instead when 1 it selects I2C interface mode. Because we
1075 * have 2 devices on one interface, the "disabled" device when we talk
1076 * to an "enabled" device sees the clocks as I2C clocks, creating
1077 * havoc.
1079 * I2C sees MOSI going LOW while CLK HIGH as a START action, we must
1080 * ensure this is never issued.
1083 if (&lis302_pdata_top == pdata)
1084 other_cs = lis302_pdata_bottom.pin_chip_select;
1085 else
1086 other_cs = lis302_pdata_top.pin_chip_select;
1088 s3c2410_gpio_setpin(other_cs, 1);
1089 s3c2410_gpio_setpin(pdata->pin_chip_select, 1);
1090 s3c2410_gpio_setpin(pdata->pin_clk, 1);
1091 s3c2410_gpio_setpin(pdata->pin_chip_select, 0);
1093 /* send the register index, r/w and autoinc bits */
1094 for (n = 0; n < (tx_bytes << 3); n++) {
1095 if (!(n & 7))
1096 shifter = tx[n >> 3];
1097 s3c2410_gpio_setpin(pdata->pin_clk, 0);
1098 s3c2410_gpio_setpin(pdata->pin_mosi, (shifter >> 7) & 1);
1099 s3c2410_gpio_setpin(pdata->pin_clk, 0);
1100 s3c2410_gpio_setpin(pdata->pin_clk, 1);
1101 s3c2410_gpio_setpin(pdata->pin_clk, 1);
1102 shifter <<= 1;
1105 for (n = 0; n < (rx_bytes << 3); n++) { /* 8 bits each */
1106 s3c2410_gpio_setpin(pdata->pin_clk, 0);
1107 s3c2410_gpio_setpin(pdata->pin_clk, 0);
1108 shifter <<= 1;
1109 if (s3c2410_gpio_getpin(pdata->pin_miso))
1110 shifter |= 1;
1111 if ((n & 7) == 7)
1112 rx[n >> 3] = shifter;
1113 s3c2410_gpio_setpin(pdata->pin_clk, 1);
1114 s3c2410_gpio_setpin(pdata->pin_clk, 1);
1116 s3c2410_gpio_setpin(pdata->pin_chip_select, 1);
1117 s3c2410_gpio_setpin(other_cs, 1);
1121 static int gta02_lis302dl_bitbang_read_reg(struct lis302dl_info *lis, u8 reg)
1123 u8 data = 0xc0 | reg; /* read, autoincrement */
1124 unsigned long flags;
1126 local_irq_save(flags);
1128 __gta02_lis302dl_bitbang(lis, &data, 1, &data, 1);
1130 local_irq_restore(flags);
1132 return data;
1135 static void gta02_lis302dl_bitbang_write_reg(struct lis302dl_info *lis, u8 reg,
1136 u8 val)
1138 u8 data[2] = { 0x00 | reg, val }; /* write, no autoincrement */
1139 unsigned long flags;
1141 local_irq_save(flags);
1143 __gta02_lis302dl_bitbang(lis, &data[0], 2, NULL, 0);
1145 local_irq_restore(flags);
1150 static void gta02_lis302dl_bitbang_sample(struct lis302dl_info *lis)
1152 u8 data = 0xc0 | LIS302DL_REG_OUT_X; /* read, autoincrement */
1153 u8 read[5];
1154 unsigned long flags;
1156 local_irq_save(flags);
1158 __gta02_lis302dl_bitbang(lis, &data, 1, &read[0], 5);
1160 local_irq_restore(flags);
1162 input_report_rel(lis->input_dev, REL_X, MG_PER_SAMPLE * (s8)read[0]);
1163 input_report_rel(lis->input_dev, REL_Y, MG_PER_SAMPLE * (s8)read[2]);
1164 input_report_rel(lis->input_dev, REL_Z, MG_PER_SAMPLE * (s8)read[4]);
1166 input_sync(lis->input_dev);
1167 #ifdef DEBUG_SPEW_MS
1168 printk(KERN_INFO "%s: %d %d %d\n", pdata->name, read[0], read[2],
1169 read[4]);
1170 #endif
1174 void gta02_lis302dl_suspend_io(struct lis302dl_info *lis, int resume)
1176 struct lis302dl_platform_data *pdata = lis->pdata;
1178 if (!resume) {
1180 * we don't want to power them with a high level
1181 * because GSENSOR_3V3 is not up during suspend
1183 s3c2410_gpio_setpin(pdata->pin_chip_select, 0);
1184 s3c2410_gpio_setpin(pdata->pin_clk, 0);
1185 s3c2410_gpio_setpin(pdata->pin_mosi, 0);
1186 /* misnomer: it is a pullDOWN in 2442 */
1187 s3c2410_gpio_pullup(pdata->pin_miso, 1);
1188 return;
1191 /* back to normal */
1192 s3c2410_gpio_setpin(pdata->pin_chip_select, 1);
1193 s3c2410_gpio_setpin(pdata->pin_clk, 1);
1194 /* misnomer: it is a pullDOWN in 2442 */
1195 s3c2410_gpio_pullup(pdata->pin_miso, 0);
1197 s3c2410_gpio_cfgpin(pdata->pin_chip_select, S3C2410_GPIO_OUTPUT);
1198 s3c2410_gpio_cfgpin(pdata->pin_clk, S3C2410_GPIO_OUTPUT);
1199 s3c2410_gpio_cfgpin(pdata->pin_mosi, S3C2410_GPIO_OUTPUT);
1200 s3c2410_gpio_cfgpin(pdata->pin_miso, S3C2410_GPIO_INPUT);
1206 struct lis302dl_platform_data lis302_pdata_top = {
1207 .name = "lis302-1 (top)",
1208 .pin_chip_select= S3C2410_GPD12,
1209 .pin_clk = S3C2410_GPG7,
1210 .pin_mosi = S3C2410_GPG6,
1211 .pin_miso = S3C2410_GPG5,
1212 .interrupt = GTA02_IRQ_GSENSOR_1,
1213 .open_drain = 1, /* altered at runtime by PCB rev */
1214 .lis302dl_bitbang_read_sample = gta02_lis302dl_bitbang_sample,
1215 .lis302dl_bitbang_reg_read = gta02_lis302dl_bitbang_read_reg,
1216 .lis302dl_bitbang_reg_write = gta02_lis302dl_bitbang_write_reg,
1217 .lis302dl_suspend_io = gta02_lis302dl_suspend_io,
1220 struct lis302dl_platform_data lis302_pdata_bottom = {
1221 .name = "lis302-2 (bottom)",
1222 .pin_chip_select= S3C2410_GPD13,
1223 .pin_clk = S3C2410_GPG7,
1224 .pin_mosi = S3C2410_GPG6,
1225 .pin_miso = S3C2410_GPG5,
1226 .interrupt = GTA02_IRQ_GSENSOR_2,
1227 .open_drain = 1, /* altered at runtime by PCB rev */
1228 .lis302dl_bitbang_read_sample = gta02_lis302dl_bitbang_sample,
1229 .lis302dl_bitbang_reg_read = gta02_lis302dl_bitbang_read_reg,
1230 .lis302dl_bitbang_reg_write = gta02_lis302dl_bitbang_write_reg,
1231 .lis302dl_suspend_io = gta02_lis302dl_suspend_io,
1235 static struct platform_device s3c_device_spi_acc1 = {
1236 .name = "lis302dl",
1237 .id = 1,
1238 .dev = {
1239 .platform_data = &lis302_pdata_top,
1243 static struct platform_device s3c_device_spi_acc2 = {
1244 .name = "lis302dl",
1245 .id = 2,
1246 .dev = {
1247 .platform_data = &lis302_pdata_bottom,
1251 static struct resource gta02_led_resources[] = {
1253 .name = "gta02-power:orange",
1254 .start = GTA02_GPIO_PWR_LED1,
1255 .end = GTA02_GPIO_PWR_LED1,
1256 }, {
1257 .name = "gta02-power:blue",
1258 .start = GTA02_GPIO_PWR_LED2,
1259 .end = GTA02_GPIO_PWR_LED2,
1260 }, {
1261 .name = "gta02-aux:red",
1262 .start = GTA02_GPIO_AUX_LED,
1263 .end = GTA02_GPIO_AUX_LED,
1267 struct platform_device gta02_led_dev = {
1268 .name = "gta02-led",
1269 .num_resources = ARRAY_SIZE(gta02_led_resources),
1270 .resource = gta02_led_resources,
1273 static struct resource gta02_button_resources[] = {
1274 [0] = {
1275 .start = GTA02_GPIO_AUX_KEY,
1276 .end = GTA02_GPIO_AUX_KEY,
1278 [1] = {
1279 .start = GTA02_GPIO_HOLD_KEY,
1280 .end = GTA02_GPIO_HOLD_KEY,
1282 [2] = {
1283 .start = GTA02_GPIO_JACK_INSERT,
1284 .end = GTA02_GPIO_JACK_INSERT,
1288 static struct platform_device gta02_button_dev = {
1289 .name = "neo1973-button",
1290 .num_resources = ARRAY_SIZE(gta02_button_resources),
1291 .resource = gta02_button_resources,
1294 static struct platform_device gta02_pm_gsm_dev = {
1295 .name = "neo1973-pm-gsm",
1298 static struct platform_device gta02_pm_usbhost_dev = {
1299 .name = "neo1973-pm-host",
1303 /* USB */
1304 static struct s3c2410_hcd_info gta02_usb_info = {
1305 .port[0] = {
1306 .flags = S3C_HCDFLG_USED,
1308 .port[1] = {
1309 .flags = 0,
1313 static int glamo_irq_is_wired(void)
1315 int rc;
1316 int count = 0;
1319 * GTA02 S-Media IRQs prior to A5 are broken due to a lack of
1320 * a pullup on the INT# line. Check for the bad behaviour.
1322 s3c2410_gpio_setpin(S3C2410_GPG4, 0);
1323 s3c2410_gpio_cfgpin(S3C2410_GPG4, S3C2410_GPG4_OUTP);
1324 s3c2410_gpio_cfgpin(S3C2410_GPG4, S3C2410_GPG4_INP);
1326 * we force it low ourselves for a moment and resume being input.
1327 * If there is a pullup, it won't stay low for long. But if the
1328 * level converter is there as on < A5 revision, the weak keeper
1329 * on the input of the LC will hold the line low indefinitiely
1332 rc = s3c2410_gpio_getpin(S3C2410_GPG4);
1333 while ((!rc) && ((count++) < 10));
1334 if (rc) { /* it got pulled back up, it's good */
1335 printk(KERN_INFO "Detected S-Media IRQ# pullup, "
1336 "enabling interrupt\n");
1337 return 0;
1338 } else /* Gah we can't work with this level converter */
1339 printk(KERN_WARNING "** Detected bad IRQ# circuit found"
1340 " on pre-A5 GTA02: S-Media interrupt disabled **\n");
1341 return -ENODEV;
1345 static void
1346 gta02_glamo_mmc_set_power(unsigned char power_mode, unsigned short vdd)
1348 int mv = 1650;
1349 int timeout = 500;
1351 printk(KERN_DEBUG "mmc_set_power(power_mode=%u, vdd=%u\n",
1352 power_mode, vdd);
1354 switch (system_rev) {
1355 case GTA02v1_SYSTEM_REV:
1356 case GTA02v2_SYSTEM_REV:
1357 break;
1358 case GTA02v3_SYSTEM_REV:
1359 case GTA02v4_SYSTEM_REV:
1360 case GTA02v5_SYSTEM_REV:
1361 case GTA02v6_SYSTEM_REV:
1362 switch (power_mode) {
1363 case MMC_POWER_ON:
1364 case MMC_POWER_UP:
1365 /* depend on pcf50633 driver init + not suspended */
1366 while (pcf50633_ready(pcf50633_global) && (timeout--))
1367 msleep(5);
1369 if (timeout < 0) {
1370 printk(KERN_ERR"gta02_glamo_mmc_set_power "
1371 "BAILING on timeout\n");
1372 return;
1374 /* select and set the voltage */
1375 if (vdd > 7)
1376 mv += 350 + 100 * (vdd - 8);
1377 printk(KERN_INFO "SD power -> %dmV\n", mv);
1378 pcf50633_voltage_set(pcf50633_global,
1379 PCF50633_REGULATOR_HCLDO, mv);
1380 pcf50633_onoff_set(pcf50633_global,
1381 PCF50633_REGULATOR_HCLDO, 1);
1382 break;
1383 case MMC_POWER_OFF:
1384 /* power off happens during suspend, when pcf50633 can
1385 * be already gone and not coming back... just forget
1386 * the action then because pcf50633 suspend already
1387 * dealt with it, otherwise we spin forever
1389 if (pcf50633_ready(pcf50633_global))
1390 return;
1391 pcf50633_onoff_set(pcf50633_global,
1392 PCF50633_REGULATOR_HCLDO, 0);
1393 break;
1395 break;
1400 static int gta02_glamo_mci_all_dependencies_resumed(struct platform_device *dev)
1402 return resume_dep_glamo_mci_pcf.called_flag;
1405 /* register jbt resume action to be dependent on pcf50633 and glamo resume */
1407 static void gta02_glamo_mci_suspending(struct platform_device *dev)
1409 int glamo_mci_resume(struct platform_device *dev);
1411 #if defined(CONFIG_MFD_GLAMO_MCI) && defined(CONFIG_PM)
1412 resume_dep_glamo_mci_pcf.callback = (void (*)(void *))glamo_mci_resume;
1413 resume_dep_glamo_mci_pcf.context = (void *)dev;
1414 pcf50633_register_resume_dependency(pcf50633_global,
1415 &resume_dep_glamo_mci_pcf);
1416 #endif
1421 /* Smedia Glamo 3362 */
1424 * we crank down SD Card clock dynamically when GPS is powered
1427 static int gta02_glamo_mci_use_slow(void)
1429 return neo1973_pm_gps_is_on();
1432 static struct glamofb_platform_data gta02_glamo_pdata = {
1433 .width = 43,
1434 .height = 58,
1435 /* 24.5MHz --> 40.816ns */
1436 .pixclock = 40816,
1437 .left_margin = 8,
1438 .right_margin = 16,
1439 .upper_margin = 2,
1440 .lower_margin = 16,
1441 .hsync_len = 8,
1442 .vsync_len = 2,
1443 .fb_mem_size = 0x400000, /* glamo has 8 megs of SRAM. we use 4 */
1444 .xres = {
1445 .min = 240,
1446 .max = 640,
1447 .defval = 480,
1449 .yres = {
1450 .min = 320,
1451 .max = 640,
1452 .defval = 640,
1454 .bpp = {
1455 .min = 16,
1456 .max = 16,
1457 .defval = 16,
1459 //.spi_info = &glamo_spi_cfg,
1460 .spigpio_info = &glamo_spigpio_cfg,
1462 /* glamo MMC function platform data */
1463 .glamo_set_mci_power = gta02_glamo_mmc_set_power,
1464 .glamo_mci_use_slow = gta02_glamo_mci_use_slow,
1465 .glamo_irq_is_wired = glamo_irq_is_wired,
1466 .mci_suspending = gta02_glamo_mci_suspending,
1467 .mci_all_dependencies_resumed =
1468 gta02_glamo_mci_all_dependencies_resumed,
1471 static struct resource gta02_glamo_resources[] = {
1472 [0] = {
1473 .start = S3C2410_CS1,
1474 .end = S3C2410_CS1 + 0x1000000 - 1,
1475 .flags = IORESOURCE_MEM,
1477 [1] = {
1478 .start = GTA02_IRQ_3D,
1479 .end = GTA02_IRQ_3D,
1480 .flags = IORESOURCE_IRQ,
1482 [2] = {
1483 .start = GTA02v1_GPIO_3D_RESET,
1484 .end = GTA02v1_GPIO_3D_RESET,
1488 static struct platform_device gta02_glamo_dev = {
1489 .name = "glamo3362",
1490 .num_resources = ARRAY_SIZE(gta02_glamo_resources),
1491 .resource = gta02_glamo_resources,
1492 .dev = {
1493 .platform_data = &gta02_glamo_pdata,
1497 static void mangle_glamo_res_by_system_rev(void)
1499 switch (system_rev) {
1500 case GTA02v1_SYSTEM_REV:
1501 break;
1502 default:
1503 gta02_glamo_resources[2].start = GTA02_GPIO_3D_RESET;
1504 gta02_glamo_resources[2].end = GTA02_GPIO_3D_RESET;
1505 break;
1508 switch (system_rev) {
1509 case GTA02v1_SYSTEM_REV:
1510 case GTA02v2_SYSTEM_REV:
1511 case GTA02v3_SYSTEM_REV:
1512 /* case GTA02v4_SYSTEM_REV: - FIXME: handle this later */
1513 /* The hardware is missing a pull-up resistor and thus can't
1514 * support the Smedia Glamo IRQ */
1515 gta02_glamo_resources[1].start = 0;
1516 gta02_glamo_resources[1].end = 0;
1517 break;
1521 static void __init gta02_map_io(void)
1523 s3c24xx_init_io(gta02_iodesc, ARRAY_SIZE(gta02_iodesc));
1524 s3c24xx_init_clocks(12000000);
1525 s3c24xx_init_uarts(gta02_uartcfgs, ARRAY_SIZE(gta02_uartcfgs));
1528 static irqreturn_t gta02_modem_irq(int irq, void *param)
1530 printk(KERN_DEBUG "modem wakeup interrupt\n");
1531 gta_gsm_interrupts++;
1532 nspy_add(NSPY_TYPE_SPECIAL, '*');
1533 return IRQ_HANDLED;
1536 static irqreturn_t ar6000_wow_irq(int irq, void *param)
1538 printk(KERN_DEBUG "ar6000_wow interrupt\n");
1539 return IRQ_HANDLED;
1543 * hardware_ecc=1|0
1545 static char hardware_ecc_str[4] __initdata = "";
1547 static int __init hardware_ecc_setup(char *str)
1549 if (str)
1550 strlcpy(hardware_ecc_str, str, sizeof(hardware_ecc_str));
1551 return 1;
1554 __setup("hardware_ecc=", hardware_ecc_setup);
1556 static void __init gta02_machine_init(void)
1558 int rc;
1560 /* set the panic callback to make AUX blink fast */
1561 panic_blink = gta02_panic_blink;
1563 switch (system_rev) {
1564 case GTA02v6_SYSTEM_REV:
1565 /* we need push-pull interrupt from motion sensors */
1566 lis302_pdata_top.open_drain = 0;
1567 lis302_pdata_bottom.open_drain = 0;
1568 break;
1569 default:
1570 break;
1573 spin_lock_init(&motion_irq_lock);
1575 /* do not force soft ecc if we are asked to use hardware_ecc */
1576 if (hardware_ecc_str[0] == '1')
1577 gta02_nand_info.software_ecc = 0;
1579 s3c_device_usb.dev.platform_data = &gta02_usb_info;
1580 s3c_device_nand.dev.platform_data = &gta02_nand_info;
1581 s3c_device_sdi.dev.platform_data = &gta02_mmc_cfg;
1583 /* Only GTA02v1 has a SD_DETECT GPIO. Since the slot is not
1584 * hot-pluggable, this is not required anyway */
1585 switch (system_rev) {
1586 case GTA02v1_SYSTEM_REV:
1587 break;
1588 default:
1589 gta02_mmc_cfg.gpio_detect = 0;
1590 break;
1593 /* acc sensor chip selects */
1594 s3c2410_gpio_setpin(S3C2410_GPD12, 1);
1595 s3c2410_gpio_cfgpin(S3C2410_GPD12, S3C2410_GPIO_OUTPUT);
1596 s3c2410_gpio_setpin(S3C2410_GPD13, 1);
1597 s3c2410_gpio_cfgpin(S3C2410_GPD13, S3C2410_GPIO_OUTPUT);
1599 s3c24xx_udc_set_platdata(&gta02_udc_cfg);
1600 set_s3c2410ts_info(&gta02_ts_cfg);
1602 /* FIXME: hardcoded WLAN module power-up */
1603 s3c2410_gpio_cfgpin(GTA02_CHIP_PWD, S3C2410_GPIO_OUTPUT);
1605 /* Power is down */
1606 s3c2410_gpio_setpin(GTA02_CHIP_PWD, 1);
1607 mdelay(100);
1609 switch (system_rev) {
1610 case GTA02v1_SYSTEM_REV:
1611 s3c2410_gpio_setpin(GTA02_CHIP_PWD, 0);
1612 break;
1613 default:
1614 /* Chip is in reset state */
1615 s3c2410_gpio_setpin(GTA02_GPIO_nWLAN_RESET, 0);
1616 s3c2410_gpio_cfgpin(GTA02_GPIO_nWLAN_RESET, S3C2410_GPIO_OUTPUT);
1617 mdelay(100);
1618 /* Power is up */
1619 s3c2410_gpio_setpin(GTA02_CHIP_PWD, 0);
1620 mdelay(100);
1621 /* Chip is out of reset */
1622 s3c2410_gpio_setpin(GTA02_GPIO_nWLAN_RESET, 1);
1623 break;
1625 mangle_glamo_res_by_system_rev();
1626 platform_device_register(&gta02_glamo_dev);
1628 platform_device_register(&s3c_device_spi_acc1);
1629 platform_device_register(&s3c_device_spi_acc2);
1630 platform_device_register(&gta02_button_dev);
1631 platform_device_register(&gta02_pm_gsm_dev);
1632 platform_device_register(&gta02_pm_usbhost_dev);
1634 mangle_pmu_pdata_by_system_rev();
1635 platform_device_register(&gta02_pmu_dev);
1636 platform_device_register(&gta02_vibrator_dev);
1637 platform_device_register(&gta02_led_dev);
1640 platform_device_register(&gta02_sdio_dev);
1642 platform_add_devices(gta02_devices, ARRAY_SIZE(gta02_devices));
1644 #ifdef CONFIG_GTA02_HDQ
1645 switch (system_rev) {
1646 case GTA02v5_SYSTEM_REV:
1647 case GTA02v6_SYSTEM_REV:
1648 platform_device_register(&gta02_hdq_device);
1649 platform_device_register(&bq27000_battery_device);
1650 break;
1651 default:
1652 break;
1654 #endif
1655 s3c2410_pm_init();
1657 /* Make sure the modem can wake us up */
1658 set_irq_type(GTA02_IRQ_MODEM, IRQT_RISING);
1659 rc = request_irq(GTA02_IRQ_MODEM, gta02_modem_irq, IRQF_DISABLED,
1660 "modem", NULL);
1661 if (rc < 0)
1662 printk(KERN_ERR "GTA02: can't request GSM modem wakeup IRQ\n");
1663 enable_irq_wake(GTA02_IRQ_MODEM);
1665 /* Make sure the wifi module can wake us up*/
1666 set_irq_type(GTA02_IRQ_WLAN_GPIO1, IRQT_RISING);
1667 rc = request_irq(GTA02_IRQ_WLAN_GPIO1, ar6000_wow_irq, IRQF_DISABLED,
1668 "ar6000", NULL);
1670 if (rc < 0)
1671 printk(KERN_ERR "GTA02: can't request ar6k wakeup IRQ\n");
1672 enable_irq_wake(GTA02_IRQ_WLAN_GPIO1);
1675 MACHINE_START(NEO1973_GTA02, "GTA02")
1676 .phys_io = S3C2410_PA_UART,
1677 .io_pg_offst = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
1678 .boot_params = S3C2410_SDRAM_PA + 0x100,
1679 .map_io = gta02_map_io,
1680 .init_irq = s3c24xx_init_irq,
1681 .init_machine = gta02_machine_init,
1682 .timer = &s3c24xx_timer,
1683 MACHINE_END