1/*
2 * Support for Sharp SL-Cxx00 Series of PDAs
3 * Models: SL-C3000 (Spitz), SL-C1000 (Akita) and SL-C3100 (Borzoi)
4 *
5 * Copyright (c) 2005 Richard Purdie
6 *
7 * Based on Sharp's 2.4 kernel patches/lubbock.c
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 *
13 */
14
15#include <linux/kernel.h>
16#include <linux/init.h>
17#include <linux/platform_device.h>
18#include <linux/delay.h>
19#include <linux/major.h>
20#include <linux/fs.h>
21#include <linux/interrupt.h>
22#include <linux/mmc/host.h>
23#include <linux/pm.h>
24
25#include <asm/setup.h>
26#include <asm/memory.h>
27#include <asm/mach-types.h>
28#include <asm/hardware.h>
29#include <asm/irq.h>
30#include <asm/io.h>
31#include <asm/system.h>
32
33#include <asm/mach/arch.h>
34#include <asm/mach/map.h>
35#include <asm/mach/irq.h>
36
37#include <asm/arch/pxa-regs.h>
38#include <asm/arch/irda.h>
39#include <asm/arch/mmc.h>
40#include <asm/arch/ohci.h>
41#include <asm/arch/udc.h>
42#include <asm/arch/pxafb.h>
43#include <asm/arch/akita.h>
44#include <asm/arch/spitz.h>
45#include <asm/arch/sharpsl.h>
46
47#include <asm/mach/sharpsl_param.h>
48#include <asm/hardware/scoop.h>
49
50#include "generic.h"
51#include "sharpsl.h"
52
53/*
54 * Spitz SCOOP Device #1
55 */
56static struct resource spitz_scoop_resources[] = {
57	[0] = {
58		.start		= 0x10800000,
59		.end		= 0x10800fff,
60		.flags		= IORESOURCE_MEM,
61	},
62};
63
64static struct scoop_config spitz_scoop_setup = {
65	.io_dir 	= SPITZ_SCP_IO_DIR,
66	.io_out		= SPITZ_SCP_IO_OUT,
67	.suspend_clr = SPITZ_SCP_SUS_CLR,
68	.suspend_set = SPITZ_SCP_SUS_SET,
69};
70
71struct platform_device spitzscoop_device = {
72	.name		= "sharp-scoop",
73	.id		= 0,
74	.dev		= {
75 		.platform_data	= &spitz_scoop_setup,
76	},
77	.num_resources	= ARRAY_SIZE(spitz_scoop_resources),
78	.resource	= spitz_scoop_resources,
79};
80
81/*
82 * Spitz SCOOP Device #2
83 */
84static struct resource spitz_scoop2_resources[] = {
85	[0] = {
86		.start		= 0x08800040,
87		.end		= 0x08800fff,
88		.flags		= IORESOURCE_MEM,
89	},
90};
91
92static struct scoop_config spitz_scoop2_setup = {
93	.io_dir 	= SPITZ_SCP2_IO_DIR,
94	.io_out		= SPITZ_SCP2_IO_OUT,
95	.suspend_clr = SPITZ_SCP2_SUS_CLR,
96	.suspend_set = SPITZ_SCP2_SUS_SET,
97};
98
99struct platform_device spitzscoop2_device = {
100	.name		= "sharp-scoop",
101	.id		= 1,
102	.dev		= {
103 		.platform_data	= &spitz_scoop2_setup,
104	},
105	.num_resources	= ARRAY_SIZE(spitz_scoop2_resources),
106	.resource	= spitz_scoop2_resources,
107};
108
109#define SPITZ_PWR_SD 0x01
110#define SPITZ_PWR_CF 0x02
111
112/* Power control is shared with between one of the CF slots and SD */
113static void spitz_card_pwr_ctrl(int device, unsigned short new_cpr)
114{
115	unsigned short cpr = read_scoop_reg(&spitzscoop_device.dev, SCOOP_CPR);
116
117	if (new_cpr & 0x0007) {
118	        set_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_CF_POWER);
119		if (!(cpr & 0x0002) && !(cpr & 0x0004))
120		        mdelay(5);
121		if (device == SPITZ_PWR_CF)
122		        cpr |= 0x0002;
123		if (device == SPITZ_PWR_SD)
124		        cpr |= 0x0004;
125	        write_scoop_reg(&spitzscoop_device.dev, SCOOP_CPR, cpr | new_cpr);
126	} else {
127		if (device == SPITZ_PWR_CF)
128		        cpr &= ~0x0002;
129		if (device == SPITZ_PWR_SD)
130		        cpr &= ~0x0004;
131		if (!(cpr & 0x0002) && !(cpr & 0x0004)) {
132			write_scoop_reg(&spitzscoop_device.dev, SCOOP_CPR, 0x0000);
133		        mdelay(1);
134		        reset_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_CF_POWER);
135		} else {
136		        write_scoop_reg(&spitzscoop_device.dev, SCOOP_CPR, cpr | new_cpr);
137		}
138	}
139}
140
141static void spitz_pcmcia_init(void)
142{
143	/* Setup default state of GPIO outputs
144	   before we enable them as outputs. */
145	GPSR(GPIO48_nPOE) = GPIO_bit(GPIO48_nPOE) |
146		GPIO_bit(GPIO49_nPWE) |	GPIO_bit(GPIO50_nPIOR) |
147		GPIO_bit(GPIO51_nPIOW) | GPIO_bit(GPIO54_nPCE_2);
148	GPSR(GPIO85_nPCE_1) = GPIO_bit(GPIO85_nPCE_1);
149
150	pxa_gpio_mode(GPIO48_nPOE_MD);
151	pxa_gpio_mode(GPIO49_nPWE_MD);
152	pxa_gpio_mode(GPIO50_nPIOR_MD);
153	pxa_gpio_mode(GPIO51_nPIOW_MD);
154	pxa_gpio_mode(GPIO55_nPREG_MD);
155	pxa_gpio_mode(GPIO56_nPWAIT_MD);
156	pxa_gpio_mode(GPIO57_nIOIS16_MD);
157	pxa_gpio_mode(GPIO85_nPCE_1_MD);
158	pxa_gpio_mode(GPIO54_nPCE_2_MD);
159	pxa_gpio_mode(GPIO104_pSKTSEL_MD);
160}
161
162static void spitz_pcmcia_pwr(struct device *scoop, unsigned short cpr, int nr)
163{
164	/* Only need to override behaviour for slot 0 */
165	if (nr == 0)
166		spitz_card_pwr_ctrl(SPITZ_PWR_CF, cpr);
167	else
168		write_scoop_reg(scoop, SCOOP_CPR, cpr);
169}
170
171static struct scoop_pcmcia_dev spitz_pcmcia_scoop[] = {
172{
173	.dev        = &spitzscoop_device.dev,
174	.irq        = SPITZ_IRQ_GPIO_CF_IRQ,
175	.cd_irq     = SPITZ_IRQ_GPIO_CF_CD,
176	.cd_irq_str = "PCMCIA0 CD",
177},{
178	.dev        = &spitzscoop2_device.dev,
179	.irq        = SPITZ_IRQ_GPIO_CF2_IRQ,
180	.cd_irq     = -1,
181},
182};
183
184static struct scoop_pcmcia_config spitz_pcmcia_config = {
185	.devs         = &spitz_pcmcia_scoop[0],
186	.num_devs     = 2,
187	.pcmcia_init  = spitz_pcmcia_init,
188	.power_ctrl   = spitz_pcmcia_pwr,
189};
190
191EXPORT_SYMBOL(spitzscoop_device);
192EXPORT_SYMBOL(spitzscoop2_device);
193
194
195/*
196 * Spitz SSP Device
197 *
198 * Set the parent as the scoop device because a lot of SSP devices
199 * also use scoop functions and this makes the power up/down order
200 * work correctly.
201 */
202struct platform_device spitzssp_device = {
203	.name		= "corgi-ssp",
204	.dev		= {
205 		.parent = &spitzscoop_device.dev,
206	},
207	.id		= -1,
208};
209
210struct corgissp_machinfo spitz_ssp_machinfo = {
211	.port		= 2,
212	.cs_lcdcon	= SPITZ_GPIO_LCDCON_CS,
213	.cs_ads7846	= SPITZ_GPIO_ADS7846_CS,
214	.cs_max1111	= SPITZ_GPIO_MAX1111_CS,
215	.clk_lcdcon	= 520,
216	.clk_ads7846	= 14,
217	.clk_max1111	= 56,
218};
219
220
221/*
222 * Spitz Backlight Device
223 */
224static struct corgibl_machinfo spitz_bl_machinfo = {
225	.default_intensity = 0x1f,
226	.limit_mask = 0x0b,
227	.max_intensity = 0x2f,
228};
229
230static struct platform_device spitzbl_device = {
231	.name		= "corgi-bl",
232	.dev		= {
233 		.platform_data	= &spitz_bl_machinfo,
234	},
235	.id		= -1,
236};
237
238
239/*
240 * Spitz Keyboard Device
241 */
242static struct platform_device spitzkbd_device = {
243	.name		= "spitz-keyboard",
244	.id		= -1,
245};
246
247
248/*
249 * Spitz LEDs
250 */
251static struct platform_device spitzled_device = {
252	.name		= "spitz-led",
253	.id		= -1,
254};
255
256/*
257 * Spitz Touch Screen Device
258 */
259static struct resource spitzts_resources[] = {
260	[0] = {
261		.start		= SPITZ_IRQ_GPIO_TP_INT,
262		.end		= SPITZ_IRQ_GPIO_TP_INT,
263		.flags		= IORESOURCE_IRQ,
264	},
265};
266
267static struct corgits_machinfo  spitz_ts_machinfo = {
268	.get_hsync_len   = spitz_get_hsync_len,
269	.put_hsync       = spitz_put_hsync,
270	.wait_hsync      = spitz_wait_hsync,
271};
272
273static struct platform_device spitzts_device = {
274	.name		= "corgi-ts",
275	.dev		= {
276 		.parent = &spitzssp_device.dev,
277		.platform_data	= &spitz_ts_machinfo,
278	},
279	.id		= -1,
280	.num_resources	= ARRAY_SIZE(spitzts_resources),
281	.resource	= spitzts_resources,
282};
283
284
285/*
286 * MMC/SD Device
287 *
288 * The card detect interrupt isn't debounced so we delay it by 250ms
289 * to give the card a chance to fully insert/eject.
290 */
291
292static struct pxamci_platform_data spitz_mci_platform_data;
293
294static int spitz_mci_init(struct device *dev, irq_handler_t spitz_detect_int, void *data)
295{
296	int err;
297
298	/* setup GPIO for PXA27x MMC controller	*/
299	pxa_gpio_mode(GPIO32_MMCCLK_MD);
300	pxa_gpio_mode(GPIO112_MMCCMD_MD);
301	pxa_gpio_mode(GPIO92_MMCDAT0_MD);
302	pxa_gpio_mode(GPIO109_MMCDAT1_MD);
303	pxa_gpio_mode(GPIO110_MMCDAT2_MD);
304	pxa_gpio_mode(GPIO111_MMCDAT3_MD);
305	pxa_gpio_mode(SPITZ_GPIO_nSD_DETECT | GPIO_IN);
306	pxa_gpio_mode(SPITZ_GPIO_nSD_WP | GPIO_IN);
307
308	spitz_mci_platform_data.detect_delay = msecs_to_jiffies(250);
309
310	err = request_irq(SPITZ_IRQ_GPIO_nSD_DETECT, spitz_detect_int,
311			  IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
312			  "MMC card detect", data);
313	if (err) {
314		printk(KERN_ERR "spitz_mci_init: MMC/SD: can't request MMC card detect IRQ\n");
315		return -1;
316	}
317
318	return 0;
319}
320
321static void spitz_mci_setpower(struct device *dev, unsigned int vdd)
322{
323	struct pxamci_platform_data* p_d = dev->platform_data;
324
325	if (( 1 << vdd) & p_d->ocr_mask)
326		spitz_card_pwr_ctrl(SPITZ_PWR_SD, 0x0004);
327	else
328		spitz_card_pwr_ctrl(SPITZ_PWR_SD, 0x0000);
329}
330
331static int spitz_mci_get_ro(struct device *dev)
332{
333	return GPLR(SPITZ_GPIO_nSD_WP) & GPIO_bit(SPITZ_GPIO_nSD_WP);
334}
335
336static void spitz_mci_exit(struct device *dev, void *data)
337{
338	free_irq(SPITZ_IRQ_GPIO_nSD_DETECT, data);
339}
340
341static struct pxamci_platform_data spitz_mci_platform_data = {
342	.ocr_mask	= MMC_VDD_32_33|MMC_VDD_33_34,
343	.init 		= spitz_mci_init,
344	.get_ro		= spitz_mci_get_ro,
345	.setpower 	= spitz_mci_setpower,
346	.exit		= spitz_mci_exit,
347};
348
349
350/*
351 * USB Host (OHCI)
352 */
353static int spitz_ohci_init(struct device *dev)
354{
355	/* Only Port 2 is connected */
356	pxa_gpio_mode(SPITZ_GPIO_USB_CONNECT | GPIO_IN);
357	pxa_gpio_mode(SPITZ_GPIO_USB_HOST | GPIO_OUT);
358	pxa_gpio_mode(SPITZ_GPIO_USB_DEVICE | GPIO_IN);
359
360	/* Setup USB Port 2 Output Control Register */
361	UP2OCR = UP2OCR_HXS | UP2OCR_HXOE | UP2OCR_DPPDE | UP2OCR_DMPDE;
362
363	GPSR(SPITZ_GPIO_USB_HOST) = GPIO_bit(SPITZ_GPIO_USB_HOST);
364
365	UHCHR = (UHCHR) &
366		~(UHCHR_SSEP1 | UHCHR_SSEP2 | UHCHR_SSEP3 | UHCHR_SSE);
367
368	UHCRHDA |= UHCRHDA_NOCP;
369
370	return 0;
371}
372
373static struct pxaohci_platform_data spitz_ohci_platform_data = {
374	.port_mode	= PMM_NPS_MODE,
375	.init		= spitz_ohci_init,
376	.power_budget	= 150,
377};
378
379
380/*
381 * Irda
382 */
383static void spitz_irda_transceiver_mode(struct device *dev, int mode)
384{
385	if (mode & IR_OFF)
386		set_scoop_gpio(&spitzscoop2_device.dev, SPITZ_SCP2_IR_ON);
387	else
388		reset_scoop_gpio(&spitzscoop2_device.dev, SPITZ_SCP2_IR_ON);
389}
390
391#ifdef CONFIG_MACH_AKITA
392static void akita_irda_transceiver_mode(struct device *dev, int mode)
393{
394	if (mode & IR_OFF)
395		akita_set_ioexp(&akitaioexp_device.dev, AKITA_IOEXP_IR_ON);
396	else
397		akita_reset_ioexp(&akitaioexp_device.dev, AKITA_IOEXP_IR_ON);
398}
399#endif
400
401static struct pxaficp_platform_data spitz_ficp_platform_data = {
402	.transceiver_cap  = IR_SIRMODE | IR_OFF,
403	.transceiver_mode = spitz_irda_transceiver_mode,
404};
405
406
407/*
408 * Spitz PXA Framebuffer
409 */
410
411static struct pxafb_mode_info spitz_pxafb_modes[] = {
412{
413	.pixclock       = 19231,
414	.xres           = 480,
415	.yres           = 640,
416	.bpp            = 16,
417	.hsync_len      = 40,
418	.left_margin    = 46,
419	.right_margin   = 125,
420	.vsync_len      = 3,
421	.upper_margin   = 1,
422	.lower_margin   = 0,
423	.sync           = 0,
424},{
425	.pixclock       = 134617,
426	.xres           = 240,
427	.yres           = 320,
428	.bpp            = 16,
429	.hsync_len      = 20,
430	.left_margin    = 20,
431	.right_margin   = 46,
432	.vsync_len      = 2,
433	.upper_margin   = 1,
434	.lower_margin   = 0,
435	.sync           = 0,
436},
437};
438
439static struct pxafb_mach_info spitz_pxafb_info = {
440	.modes          = &spitz_pxafb_modes[0],
441	.num_modes      = 2,
442	.fixed_modes    = 1,
443	.lccr0          = LCCR0_Color | LCCR0_Sngl | LCCR0_Act | LCCR0_LDDALT | LCCR0_OUC | LCCR0_CMDIM | LCCR0_RDSTM,
444	.lccr3          = LCCR3_PixRsEdg | LCCR3_OutEnH,
445	.pxafb_lcd_power = spitz_lcd_power,
446};
447
448
449static struct platform_device *devices[] __initdata = {
450	&spitzscoop_device,
451	&spitzssp_device,
452	&spitzkbd_device,
453	&spitzts_device,
454	&spitzbl_device,
455	&spitzled_device,
456};
457
458static void spitz_poweroff(void)
459{
460	RCSR = RCSR_HWR | RCSR_WDR | RCSR_SMR | RCSR_GPR;
461
462	pxa_gpio_mode(SPITZ_GPIO_ON_RESET | GPIO_OUT);
463	GPSR(SPITZ_GPIO_ON_RESET) = GPIO_bit(SPITZ_GPIO_ON_RESET);
464
465	mdelay(1000);
466	arm_machine_restart('h');
467}
468
469static void spitz_restart(char mode)
470{
471	/* Bootloader magic for a reboot */
472	if((MSC0 & 0xffff0000) == 0x7ff00000)
473		MSC0 = (MSC0 & 0xffff) | 0x7ee00000;
474
475	spitz_poweroff();
476}
477
478static void __init common_init(void)
479{
480	pm_power_off = spitz_poweroff;
481	arm_pm_restart = spitz_restart;
482
483	PMCR = 0x00;
484
485	/* setup sleep mode values */
486	PWER  = 0x00000002;
487	PFER  = 0x00000000;
488	PRER  = 0x00000002;
489	PGSR0 = 0x0158C000;
490	PGSR1 = 0x00FF0080;
491	PGSR2 = 0x0001C004;
492
493	/* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
494	PCFR |= PCFR_OPDE;
495
496	corgi_ssp_set_machinfo(&spitz_ssp_machinfo);
497
498	pxa_gpio_mode(SPITZ_GPIO_HSYNC | GPIO_IN);
499
500	platform_add_devices(devices, ARRAY_SIZE(devices));
501	pxa_set_mci_info(&spitz_mci_platform_data);
502	pxa_set_ohci_info(&spitz_ohci_platform_data);
503	pxa_set_ficp_info(&spitz_ficp_platform_data);
504	set_pxa_fb_parent(&spitzssp_device.dev);
505	set_pxa_fb_info(&spitz_pxafb_info);
506}
507
508static void __init spitz_init(void)
509{
510	platform_scoop_config = &spitz_pcmcia_config;
511
512	spitz_bl_machinfo.set_bl_intensity = spitz_bl_set_intensity;
513
514	common_init();
515
516	platform_device_register(&spitzscoop2_device);
517}
518
519#ifdef CONFIG_MACH_AKITA
520/*
521 * Akita IO Expander
522 */
523struct platform_device akitaioexp_device = {
524	.name		= "akita-ioexp",
525	.id		= -1,
526};
527
528EXPORT_SYMBOL_GPL(akitaioexp_device);
529
530static void __init akita_init(void)
531{
532	spitz_ficp_platform_data.transceiver_mode = akita_irda_transceiver_mode;
533
534	/* We just pretend the second element of the array doesn't exist */
535	spitz_pcmcia_config.num_devs = 1;
536	platform_scoop_config = &spitz_pcmcia_config;
537	spitz_bl_machinfo.set_bl_intensity = akita_bl_set_intensity;
538
539	platform_device_register(&akitaioexp_device);
540
541	spitzscoop_device.dev.parent = &akitaioexp_device.dev;
542	common_init();
543}
544#endif
545
546
547static void __init fixup_spitz(struct machine_desc *desc,
548		struct tag *tags, char **cmdline, struct meminfo *mi)
549{
550	sharpsl_save_param();
551	mi->nr_banks = 1;
552	mi->bank[0].start = 0xa0000000;
553	mi->bank[0].node = 0;
554	mi->bank[0].size = (64*1024*1024);
555}
556
557#ifdef CONFIG_MACH_SPITZ
558MACHINE_START(SPITZ, "SHARP Spitz")
559	.phys_io	= 0x40000000,
560	.io_pg_offst	= (io_p2v(0x40000000) >> 18) & 0xfffc,
561	.fixup		= fixup_spitz,
562	.map_io		= pxa_map_io,
563	.init_irq	= pxa_init_irq,
564	.init_machine	= spitz_init,
565	.timer		= &pxa_timer,
566MACHINE_END
567#endif
568
569#ifdef CONFIG_MACH_BORZOI
570MACHINE_START(BORZOI, "SHARP Borzoi")
571	.phys_io	= 0x40000000,
572	.io_pg_offst	= (io_p2v(0x40000000) >> 18) & 0xfffc,
573	.fixup		= fixup_spitz,
574	.map_io		= pxa_map_io,
575	.init_irq	= pxa_init_irq,
576	.init_machine	= spitz_init,
577	.timer		= &pxa_timer,
578MACHINE_END
579#endif
580
581#ifdef CONFIG_MACH_AKITA
582MACHINE_START(AKITA, "SHARP Akita")
583	.phys_io	= 0x40000000,
584	.io_pg_offst	= (io_p2v(0x40000000) >> 18) & 0xfffc,
585	.fixup		= fixup_spitz,
586	.map_io		= pxa_map_io,
587	.init_irq	= pxa_init_irq,
588	.init_machine	= akita_init,
589	.timer		= &pxa_timer,
590MACHINE_END
591#endif
592