poodle.c 9.19 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*
 * linux/arch/arm/mach-pxa/poodle.c
 *
 *  Support for the SHARP Poodle Board.
 *
 * Based on:
 *  linux/arch/arm/mach-pxa/lubbock.c Author:	Nicolas Pitre
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 *
 * Change Log
 *  12-Dec-2002 Sharp Corporation for Poodle
 *  John Lenz <lenz@cs.wisc.edu> updates to 2.6
 */
#include <linux/kernel.h>
#include <linux/init.h>
19
#include <linux/platform_device.h>
Linus Torvalds's avatar
Linus Torvalds committed
20
#include <linux/fb.h>
21
#include <linux/pm.h>
22
#include <linux/delay.h>
Linus Torvalds's avatar
Linus Torvalds committed
23

24
#include <mach/hardware.h>
Linus Torvalds's avatar
Linus Torvalds committed
25
26
27
#include <asm/mach-types.h>
#include <asm/irq.h>
#include <asm/setup.h>
28
#include <asm/system.h>
Linus Torvalds's avatar
Linus Torvalds committed
29
30
31
32
33

#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <asm/mach/irq.h>

34
35
36
37
38
#include <mach/pxa-regs.h>
#include <mach/pxa2xx-regs.h>
#include <mach/pxa2xx-gpio.h>
#include <mach/mmc.h>
#include <mach/udc.h>
39
#include <mach/i2c.h>
40
41
42
43
44
#include <mach/irda.h>
#include <mach/poodle.h>
#include <mach/pxafb.h>
#include <mach/sharpsl.h>
#include <mach/ssp.h>
Linus Torvalds's avatar
Linus Torvalds committed
45
46
47
48
49
50

#include <asm/hardware/scoop.h>
#include <asm/hardware/locomo.h>
#include <asm/mach/sharpsl_param.h>

#include "generic.h"
51
#include "devices.h"
52
#include "sharpsl.h"
Linus Torvalds's avatar
Linus Torvalds committed
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

static struct resource poodle_scoop_resources[] = {
	[0] = {
		.start		= 0x10800000,
		.end		= 0x10800fff,
		.flags		= IORESOURCE_MEM,
	},
};

static struct scoop_config poodle_scoop_setup = {
	.io_dir		= POODLE_SCOOP_IO_DIR,
	.io_out		= POODLE_SCOOP_IO_OUT,
};

struct platform_device poodle_scoop_device = {
	.name		= "sharp-scoop",
	.id		= -1,
	.dev		= {
		.platform_data	= &poodle_scoop_setup,
	},
	.num_resources	= ARRAY_SIZE(poodle_scoop_resources),
	.resource	= poodle_scoop_resources,
};

77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
static void poodle_pcmcia_init(void)
{
	/* Setup default state of GPIO outputs
	   before we enable them as outputs. */
	GPSR(GPIO48_nPOE) = GPIO_bit(GPIO48_nPOE) |
		GPIO_bit(GPIO49_nPWE) | GPIO_bit(GPIO50_nPIOR) |
		GPIO_bit(GPIO51_nPIOW) | GPIO_bit(GPIO52_nPCE_1) |
		GPIO_bit(GPIO53_nPCE_2);

	pxa_gpio_mode(GPIO48_nPOE_MD);
	pxa_gpio_mode(GPIO49_nPWE_MD);
	pxa_gpio_mode(GPIO50_nPIOR_MD);
	pxa_gpio_mode(GPIO51_nPIOW_MD);
	pxa_gpio_mode(GPIO55_nPREG_MD);
	pxa_gpio_mode(GPIO56_nPWAIT_MD);
	pxa_gpio_mode(GPIO57_nIOIS16_MD);
	pxa_gpio_mode(GPIO52_nPCE_1_MD);
	pxa_gpio_mode(GPIO53_nPCE_2_MD);
	pxa_gpio_mode(GPIO54_pSKTSEL_MD);
}

98
99
100
101
102
103
104
105
106
static struct scoop_pcmcia_dev poodle_pcmcia_scoop[] = {
{
	.dev        = &poodle_scoop_device.dev,
	.irq        = POODLE_IRQ_GPIO_CF_IRQ,
	.cd_irq     = POODLE_IRQ_GPIO_CF_CD,
	.cd_irq_str = "PCMCIA0 CD",
},
};

107
108
109
110
111
112
113
114
static struct scoop_pcmcia_config poodle_pcmcia_config = {
	.devs         = &poodle_pcmcia_scoop[0],
	.num_devs     = 1,
	.pcmcia_init  = poodle_pcmcia_init,
};

EXPORT_SYMBOL(poodle_scoop_device);

Linus Torvalds's avatar
Linus Torvalds committed
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

/* LoCoMo device */
static struct resource locomo_resources[] = {
	[0] = {
		.start		= 0x10000000,
		.end		= 0x10001fff,
		.flags		= IORESOURCE_MEM,
	},
	[1] = {
		.start		= IRQ_GPIO(10),
		.end		= IRQ_GPIO(10),
		.flags		= IORESOURCE_IRQ,
	},
};

130
struct platform_device poodle_locomo_device = {
Linus Torvalds's avatar
Linus Torvalds committed
131
132
133
134
135
136
	.name		= "locomo",
	.id		= 0,
	.num_resources	= ARRAY_SIZE(locomo_resources),
	.resource	= locomo_resources,
};

137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
EXPORT_SYMBOL(poodle_locomo_device);

/*
 * Poodle SSP Device
 */

struct platform_device poodle_ssp_device = {
	.name		= "corgi-ssp",
	.id		= -1,
};

struct corgissp_machinfo poodle_ssp_machinfo = {
	.port		= 1,
	.cs_lcdcon	= -1,
	.cs_ads7846	= -1,
	.cs_max1111	= -1,
	.clk_lcdcon	= 2,
	.clk_ads7846	= 36,
	.clk_max1111	= 2,
};


/*
 * Poodle Touch Screen Device
 */
static struct resource poodlets_resources[] = {
	[0] = {
		.start		= POODLE_IRQ_GPIO_TP_INT,
		.end		= POODLE_IRQ_GPIO_TP_INT,
		.flags		= IORESOURCE_IRQ,
	},
};

170
static unsigned long poodle_get_hsync_invperiod(void)
171
172
173
174
175
176
177
178
179
{
	return 0;
}

static void poodle_null_hsync(void)
{
}

static struct corgits_machinfo  poodle_ts_machinfo = {
180
181
182
	.get_hsync_invperiod	= poodle_get_hsync_invperiod,
	.put_hsync       	= poodle_null_hsync,
	.wait_hsync      	= poodle_null_hsync,
183
184
185
186
187
188
189
190
191
192
193
194
};

static struct platform_device poodle_ts_device = {
	.name		= "corgi-ts",
	.dev		= {
		.platform_data	= &poodle_ts_machinfo,
	},
	.id		= -1,
	.num_resources	= ARRAY_SIZE(poodlets_resources),
	.resource	= poodlets_resources,
};

195
196
197
198
199
200
201
202
203

/*
 * MMC/SD Device
 *
 * The card detect interrupt isn't debounced so we delay it by 250ms
 * to give the card a chance to fully insert/eject.
 */
static struct pxamci_platform_data poodle_mci_platform_data;

204
static int poodle_mci_init(struct device *dev, irq_handler_t poodle_detect_int, void *data)
205
206
207
208
209
210
211
{
	int err;

	/* setup GPIO for PXA25x MMC controller	*/
	pxa_gpio_mode(GPIO6_MMCCLK_MD);
	pxa_gpio_mode(GPIO8_MMCCS0_MD);
	pxa_gpio_mode(POODLE_GPIO_nSD_DETECT | GPIO_IN);
212
	pxa_gpio_mode(POODLE_GPIO_nSD_WP | GPIO_IN);
213
	pxa_gpio_mode(POODLE_GPIO_SD_PWR | GPIO_OUT);
214
	pxa_gpio_mode(POODLE_GPIO_SD_PWR1 | GPIO_OUT);
215
216
217

	poodle_mci_platform_data.detect_delay = msecs_to_jiffies(250);

Russell King's avatar
Russell King committed
218
	err = request_irq(POODLE_IRQ_GPIO_nSD_DETECT, poodle_detect_int,
219
			  IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
Russell King's avatar
Russell King committed
220
			  "MMC card detect", data);
221
	if (err)
222
223
		printk(KERN_ERR "poodle_mci_init: MMC/SD: can't request MMC card detect IRQ\n");

224
	return err;
225
226
227
228
229
230
}

static void poodle_mci_setpower(struct device *dev, unsigned int vdd)
{
	struct pxamci_platform_data* p_d = dev->platform_data;

231
232
233
234
235
236
237
238
239
240
241
242
243
	if (( 1 << vdd) & p_d->ocr_mask) {
		GPSR(POODLE_GPIO_SD_PWR) = GPIO_bit(POODLE_GPIO_SD_PWR);
		mdelay(2);
		GPSR(POODLE_GPIO_SD_PWR1) = GPIO_bit(POODLE_GPIO_SD_PWR1);
	} else {
		GPCR(POODLE_GPIO_SD_PWR1) = GPIO_bit(POODLE_GPIO_SD_PWR1);
		GPCR(POODLE_GPIO_SD_PWR) = GPIO_bit(POODLE_GPIO_SD_PWR);
	}
}

static int poodle_mci_get_ro(struct device *dev)
{
	return GPLR(POODLE_GPIO_nSD_WP) & GPIO_bit(POODLE_GPIO_nSD_WP);
244
245
}

246

247
248
249
250
251
252
253
254
static void poodle_mci_exit(struct device *dev, void *data)
{
	free_irq(POODLE_IRQ_GPIO_nSD_DETECT, data);
}

static struct pxamci_platform_data poodle_mci_platform_data = {
	.ocr_mask	= MMC_VDD_32_33|MMC_VDD_33_34,
	.init 		= poodle_mci_init,
255
	.get_ro		= poodle_mci_get_ro,
256
257
258
259
260
	.setpower 	= poodle_mci_setpower,
	.exit		= poodle_mci_exit,
};


261
262
263
264
265
266
267
268
269
270
/*
 * Irda
 */
static void poodle_irda_transceiver_mode(struct device *dev, int mode)
{
	if (mode & IR_OFF) {
		GPSR(POODLE_GPIO_IR_ON) = GPIO_bit(POODLE_GPIO_IR_ON);
	} else {
		GPCR(POODLE_GPIO_IR_ON) = GPIO_bit(POODLE_GPIO_IR_ON);
	}
271
	pxa2xx_transceiver_mode(dev, mode);
272
273
274
275
276
277
278
279
}

static struct pxaficp_platform_data poodle_ficp_platform_data = {
	.transceiver_cap  = IR_SIRMODE | IR_OFF,
	.transceiver_mode = poodle_irda_transceiver_mode,
};


280
281
282
283
284
/*
 * USB Device Controller
 */
static struct pxa2xx_udc_mach_info udc_info __initdata = {
	/* no connect GPIO; poodle can't tell connection status */
285
	.gpio_pullup	= POODLE_GPIO_USB_PULLUP,
286
287
288
};


Linus Torvalds's avatar
Linus Torvalds committed
289
/* PXAFB device */
290
static struct pxafb_mode_info poodle_fb_mode = {
Linus Torvalds's avatar
Linus Torvalds committed
291
292
293
294
295
296
297
298
299
300
301
	.pixclock	= 144700,
	.xres		= 320,
	.yres		= 240,
	.bpp		= 16,
	.hsync_len	= 7,
	.left_margin	= 11,
	.right_margin	= 30,
	.vsync_len	= 2,
	.upper_margin	= 2,
	.lower_margin	= 0,
	.sync		= FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
302
};
Linus Torvalds's avatar
Linus Torvalds committed
303

304
305
306
static struct pxafb_mach_info poodle_fb_info = {
	.modes		= &poodle_fb_mode,
	.num_modes	= 1,
307
	.lcd_conn	= LCD_COLOR_TFT_16BPP,
Linus Torvalds's avatar
Linus Torvalds committed
308
309
310
};

static struct platform_device *devices[] __initdata = {
311
	&poodle_locomo_device,
Linus Torvalds's avatar
Linus Torvalds committed
312
	&poodle_scoop_device,
313
314
	&poodle_ssp_device,
	&poodle_ts_device,
Linus Torvalds's avatar
Linus Torvalds committed
315
316
};

317
318
319
320
321
322
323
324
325
326
static void poodle_poweroff(void)
{
	arm_machine_restart('h');
}

static void poodle_restart(char mode)
{
	arm_machine_restart('h');
}

Linus Torvalds's avatar
Linus Torvalds committed
327
328
329
330
static void __init poodle_init(void)
{
	int ret = 0;

331
332
333
	pm_power_off = poodle_poweroff;
	arm_pm_restart = poodle_restart;

334
335
336
337
338
339
340
341
342
	/* setup sleep mode values */
	PWER  = 0x00000002;
	PFER  = 0x00000000;
	PRER  = 0x00000002;
	PGSR0 = 0x00008000;
	PGSR1 = 0x003F0202;
	PGSR2 = 0x0001C000;
	PCFR |= PCFR_OPDE;

Linus Torvalds's avatar
Linus Torvalds committed
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
	/* cpu initialize */
	/* Pgsr Register */
  	PGSR0 = 0x0146dd80;
  	PGSR1 = 0x03bf0890;
  	PGSR2 = 0x0001c000;

	/* Alternate Register */
  	GAFR0_L = 0x01001000;
  	GAFR0_U = 0x591a8010;
  	GAFR1_L = 0x900a8451;
  	GAFR1_U = 0xaaa5aaaa;
  	GAFR2_L = 0x8aaaaaaa;
  	GAFR2_U = 0x00000002;

	/* Direction Register */
  	GPDR0 = 0xd3f0904c;
  	GPDR1 = 0xfcffb7d3;
  	GPDR2 = 0x0001ffff;

	/* Output Register */
  	GPCR0 = 0x00000000;
  	GPCR1 = 0x00000000;
  	GPCR2 = 0x00000000;

  	GPSR0 = 0x00400000;
  	GPSR1 = 0x00000000;
        GPSR2 = 0x00000000;

371
372
373
374
375
376
377
	platform_scoop_config = &poodle_pcmcia_config;
	corgi_ssp_set_machinfo(&poodle_ssp_machinfo);

	ret = platform_add_devices(devices, ARRAY_SIZE(devices));
	if (ret)
		pr_warning("poodle: Unable to register LoCoMo device\n");

378
	set_pxa_fb_parent(&poodle_locomo_device.dev);
Linus Torvalds's avatar
Linus Torvalds committed
379
	set_pxa_fb_info(&poodle_fb_info);
380
	pxa_gpio_mode(POODLE_GPIO_USB_PULLUP | GPIO_OUT);
381
	pxa_gpio_mode(POODLE_GPIO_IR_ON | GPIO_OUT);
382
383
	pxa_set_udc_info(&udc_info);
	pxa_set_mci_info(&poodle_mci_platform_data);
384
	pxa_set_ficp_info(&poodle_ficp_platform_data);
385
	pxa_set_i2c_info(NULL);
Linus Torvalds's avatar
Linus Torvalds committed
386
387
388
389
390
391
}

static void __init fixup_poodle(struct machine_desc *desc,
		struct tag *tags, char **cmdline, struct meminfo *mi)
{
	sharpsl_save_param();
392
393
394
395
	mi->nr_banks=1;
	mi->bank[0].start = 0xa0000000;
	mi->bank[0].node = 0;
	mi->bank[0].size = (32*1024*1024);
Linus Torvalds's avatar
Linus Torvalds committed
396
397
398
}

MACHINE_START(POODLE, "SHARP Poodle")
399
	.phys_io	= 0x40000000,
400
	.io_pg_offst	= (io_p2v(0x40000000) >> 18) & 0xfffc,
401
	.fixup		= fixup_poodle,
402
	.map_io		= pxa_map_io,
403
	.init_irq	= pxa25x_init_irq,
404
405
	.timer		= &pxa_timer,
	.init_machine	= poodle_init,
Linus Torvalds's avatar
Linus Torvalds committed
406
MACHINE_END