]>
Commit | Line | Data |
---|---|---|
1 | /* vim:set shiftwidth=4 ts=4 et: */ | |
2 | /* | |
3 | * PXA255 Sharp Zaurus SL-6000 PDA platform | |
4 | * | |
5 | * Copyright (c) 2008 Dmitry Baryshkov | |
6 | * | |
7 | * Code based on spitz platform by Andrzej Zaborowski <balrog@zabor.org> | |
8 | * This code is licensed under the GNU GPL v2. | |
9 | * | |
10 | * Contributions after 2012-01-13 are licensed under the terms of the | |
11 | * GNU GPL, version 2 or (at your option) any later version. | |
12 | */ | |
13 | ||
14 | #include "hw/hw.h" | |
15 | #include "hw/arm/pxa.h" | |
16 | #include "hw/arm/arm.h" | |
17 | #include "hw/devices.h" | |
18 | #include "hw/arm/sharpsl.h" | |
19 | #include "hw/pcmcia.h" | |
20 | #include "block/block.h" | |
21 | #include "hw/boards.h" | |
22 | #include "hw/i2c/i2c.h" | |
23 | #include "hw/ssi.h" | |
24 | #include "sysemu/blockdev.h" | |
25 | #include "hw/sysbus.h" | |
26 | #include "exec/address-spaces.h" | |
27 | ||
28 | #define TOSA_RAM 0x04000000 | |
29 | #define TOSA_ROM 0x00800000 | |
30 | ||
31 | #define TOSA_GPIO_USB_IN (5) | |
32 | #define TOSA_GPIO_nSD_DETECT (9) | |
33 | #define TOSA_GPIO_ON_RESET (19) | |
34 | #define TOSA_GPIO_CF_IRQ (21) /* CF slot0 Ready */ | |
35 | #define TOSA_GPIO_CF_CD (13) | |
36 | #define TOSA_GPIO_TC6393XB_INT (15) | |
37 | #define TOSA_GPIO_JC_CF_IRQ (36) /* CF slot1 Ready */ | |
38 | ||
39 | #define TOSA_SCOOP_GPIO_BASE 1 | |
40 | #define TOSA_GPIO_IR_POWERDWN (TOSA_SCOOP_GPIO_BASE + 2) | |
41 | #define TOSA_GPIO_SD_WP (TOSA_SCOOP_GPIO_BASE + 3) | |
42 | #define TOSA_GPIO_PWR_ON (TOSA_SCOOP_GPIO_BASE + 4) | |
43 | ||
44 | #define TOSA_SCOOP_JC_GPIO_BASE 1 | |
45 | #define TOSA_GPIO_BT_LED (TOSA_SCOOP_JC_GPIO_BASE + 0) | |
46 | #define TOSA_GPIO_NOTE_LED (TOSA_SCOOP_JC_GPIO_BASE + 1) | |
47 | #define TOSA_GPIO_CHRG_ERR_LED (TOSA_SCOOP_JC_GPIO_BASE + 2) | |
48 | #define TOSA_GPIO_TC6393XB_L3V_ON (TOSA_SCOOP_JC_GPIO_BASE + 5) | |
49 | #define TOSA_GPIO_WLAN_LED (TOSA_SCOOP_JC_GPIO_BASE + 7) | |
50 | ||
51 | #define DAC_BASE 0x4e | |
52 | #define DAC_CH1 0 | |
53 | #define DAC_CH2 1 | |
54 | ||
55 | static void tosa_microdrive_attach(PXA2xxState *cpu) | |
56 | { | |
57 | PCMCIACardState *md; | |
58 | DriveInfo *dinfo; | |
59 | ||
60 | dinfo = drive_get(IF_IDE, 0, 0); | |
61 | if (!dinfo || dinfo->media_cd) | |
62 | return; | |
63 | md = dscm1xxxx_init(dinfo); | |
64 | pxa2xx_pcmcia_attach(cpu->pcmcia[0], md); | |
65 | } | |
66 | ||
67 | static void tosa_out_switch(void *opaque, int line, int level) | |
68 | { | |
69 | switch (line) { | |
70 | case 0: | |
71 | fprintf(stderr, "blue LED %s.\n", level ? "on" : "off"); | |
72 | break; | |
73 | case 1: | |
74 | fprintf(stderr, "green LED %s.\n", level ? "on" : "off"); | |
75 | break; | |
76 | case 2: | |
77 | fprintf(stderr, "amber LED %s.\n", level ? "on" : "off"); | |
78 | break; | |
79 | case 3: | |
80 | fprintf(stderr, "wlan LED %s.\n", level ? "on" : "off"); | |
81 | break; | |
82 | default: | |
83 | fprintf(stderr, "Uhandled out event: %d = %d\n", line, level); | |
84 | break; | |
85 | } | |
86 | } | |
87 | ||
88 | ||
89 | static void tosa_gpio_setup(PXA2xxState *cpu, | |
90 | DeviceState *scp0, | |
91 | DeviceState *scp1, | |
92 | TC6393xbState *tmio) | |
93 | { | |
94 | qemu_irq *outsignals = qemu_allocate_irqs(tosa_out_switch, cpu, 4); | |
95 | /* MMC/SD host */ | |
96 | pxa2xx_mmci_handlers(cpu->mmc, | |
97 | qdev_get_gpio_in(scp0, TOSA_GPIO_SD_WP), | |
98 | qemu_irq_invert(qdev_get_gpio_in(cpu->gpio, TOSA_GPIO_nSD_DETECT))); | |
99 | ||
100 | /* Handle reset */ | |
101 | qdev_connect_gpio_out(cpu->gpio, TOSA_GPIO_ON_RESET, cpu->reset); | |
102 | ||
103 | /* PCMCIA signals: card's IRQ and Card-Detect */ | |
104 | pxa2xx_pcmcia_set_irq_cb(cpu->pcmcia[0], | |
105 | qdev_get_gpio_in(cpu->gpio, TOSA_GPIO_CF_IRQ), | |
106 | qdev_get_gpio_in(cpu->gpio, TOSA_GPIO_CF_CD)); | |
107 | ||
108 | pxa2xx_pcmcia_set_irq_cb(cpu->pcmcia[1], | |
109 | qdev_get_gpio_in(cpu->gpio, TOSA_GPIO_JC_CF_IRQ), | |
110 | NULL); | |
111 | ||
112 | qdev_connect_gpio_out(scp1, TOSA_GPIO_BT_LED, outsignals[0]); | |
113 | qdev_connect_gpio_out(scp1, TOSA_GPIO_NOTE_LED, outsignals[1]); | |
114 | qdev_connect_gpio_out(scp1, TOSA_GPIO_CHRG_ERR_LED, outsignals[2]); | |
115 | qdev_connect_gpio_out(scp1, TOSA_GPIO_WLAN_LED, outsignals[3]); | |
116 | ||
117 | qdev_connect_gpio_out(scp1, TOSA_GPIO_TC6393XB_L3V_ON, tc6393xb_l3v_get(tmio)); | |
118 | ||
119 | /* UDC Vbus */ | |
120 | qemu_irq_raise(qdev_get_gpio_in(cpu->gpio, TOSA_GPIO_USB_IN)); | |
121 | } | |
122 | ||
123 | static uint32_t tosa_ssp_tansfer(SSISlave *dev, uint32_t value) | |
124 | { | |
125 | fprintf(stderr, "TG: %d %02x\n", value >> 5, value & 0x1f); | |
126 | return 0; | |
127 | } | |
128 | ||
129 | static int tosa_ssp_init(SSISlave *dev) | |
130 | { | |
131 | /* Nothing to do. */ | |
132 | return 0; | |
133 | } | |
134 | ||
135 | typedef struct { | |
136 | I2CSlave i2c; | |
137 | int len; | |
138 | char buf[3]; | |
139 | } TosaDACState; | |
140 | ||
141 | static int tosa_dac_send(I2CSlave *i2c, uint8_t data) | |
142 | { | |
143 | TosaDACState *s = FROM_I2C_SLAVE(TosaDACState, i2c); | |
144 | s->buf[s->len] = data; | |
145 | if (s->len ++ > 2) { | |
146 | #ifdef VERBOSE | |
147 | fprintf(stderr, "%s: message too long (%i bytes)\n", __FUNCTION__, s->len); | |
148 | #endif | |
149 | return 1; | |
150 | } | |
151 | ||
152 | if (s->len == 2) { | |
153 | fprintf(stderr, "dac: channel %d value 0x%02x\n", | |
154 | s->buf[0], s->buf[1]); | |
155 | } | |
156 | ||
157 | return 0; | |
158 | } | |
159 | ||
160 | static void tosa_dac_event(I2CSlave *i2c, enum i2c_event event) | |
161 | { | |
162 | TosaDACState *s = FROM_I2C_SLAVE(TosaDACState, i2c); | |
163 | s->len = 0; | |
164 | switch (event) { | |
165 | case I2C_START_SEND: | |
166 | break; | |
167 | case I2C_START_RECV: | |
168 | printf("%s: recv not supported!!!\n", __FUNCTION__); | |
169 | break; | |
170 | case I2C_FINISH: | |
171 | #ifdef VERBOSE | |
172 | if (s->len < 2) | |
173 | printf("%s: message too short (%i bytes)\n", __FUNCTION__, s->len); | |
174 | if (s->len > 2) | |
175 | printf("%s: message too long\n", __FUNCTION__); | |
176 | #endif | |
177 | break; | |
178 | default: | |
179 | break; | |
180 | } | |
181 | } | |
182 | ||
183 | static int tosa_dac_recv(I2CSlave *s) | |
184 | { | |
185 | printf("%s: recv not supported!!!\n", __FUNCTION__); | |
186 | return -1; | |
187 | } | |
188 | ||
189 | static int tosa_dac_init(I2CSlave *i2c) | |
190 | { | |
191 | /* Nothing to do. */ | |
192 | return 0; | |
193 | } | |
194 | ||
195 | static void tosa_tg_init(PXA2xxState *cpu) | |
196 | { | |
197 | i2c_bus *bus = pxa2xx_i2c_bus(cpu->i2c[0]); | |
198 | i2c_create_slave(bus, "tosa_dac", DAC_BASE); | |
199 | ssi_create_slave(cpu->ssp[1], "tosa-ssp"); | |
200 | } | |
201 | ||
202 | ||
203 | static struct arm_boot_info tosa_binfo = { | |
204 | .loader_start = PXA2XX_SDRAM_BASE, | |
205 | .ram_size = 0x04000000, | |
206 | }; | |
207 | ||
208 | static void tosa_init(QEMUMachineInitArgs *args) | |
209 | { | |
210 | const char *cpu_model = args->cpu_model; | |
211 | const char *kernel_filename = args->kernel_filename; | |
212 | const char *kernel_cmdline = args->kernel_cmdline; | |
213 | const char *initrd_filename = args->initrd_filename; | |
214 | MemoryRegion *address_space_mem = get_system_memory(); | |
215 | MemoryRegion *rom = g_new(MemoryRegion, 1); | |
216 | PXA2xxState *mpu; | |
217 | TC6393xbState *tmio; | |
218 | DeviceState *scp0, *scp1; | |
219 | ||
220 | if (!cpu_model) | |
221 | cpu_model = "pxa255"; | |
222 | ||
223 | mpu = pxa255_init(address_space_mem, tosa_binfo.ram_size); | |
224 | ||
225 | memory_region_init_ram(rom, NULL, "tosa.rom", TOSA_ROM); | |
226 | vmstate_register_ram_global(rom); | |
227 | memory_region_set_readonly(rom, true); | |
228 | memory_region_add_subregion(address_space_mem, 0, rom); | |
229 | ||
230 | tmio = tc6393xb_init(address_space_mem, 0x10000000, | |
231 | qdev_get_gpio_in(mpu->gpio, TOSA_GPIO_TC6393XB_INT)); | |
232 | ||
233 | scp0 = sysbus_create_simple("scoop", 0x08800000, NULL); | |
234 | scp1 = sysbus_create_simple("scoop", 0x14800040, NULL); | |
235 | ||
236 | tosa_gpio_setup(mpu, scp0, scp1, tmio); | |
237 | ||
238 | tosa_microdrive_attach(mpu); | |
239 | ||
240 | tosa_tg_init(mpu); | |
241 | ||
242 | tosa_binfo.kernel_filename = kernel_filename; | |
243 | tosa_binfo.kernel_cmdline = kernel_cmdline; | |
244 | tosa_binfo.initrd_filename = initrd_filename; | |
245 | tosa_binfo.board_id = 0x208; | |
246 | arm_load_kernel(mpu->cpu, &tosa_binfo); | |
247 | sl_bootparam_write(SL_PXA_PARAM_BASE); | |
248 | } | |
249 | ||
250 | static QEMUMachine tosapda_machine = { | |
251 | .name = "tosa", | |
252 | .desc = "Tosa PDA (PXA255)", | |
253 | .init = tosa_init, | |
254 | }; | |
255 | ||
256 | static void tosapda_machine_init(void) | |
257 | { | |
258 | qemu_register_machine(&tosapda_machine); | |
259 | } | |
260 | ||
261 | machine_init(tosapda_machine_init); | |
262 | ||
263 | static void tosa_dac_class_init(ObjectClass *klass, void *data) | |
264 | { | |
265 | I2CSlaveClass *k = I2C_SLAVE_CLASS(klass); | |
266 | ||
267 | k->init = tosa_dac_init; | |
268 | k->event = tosa_dac_event; | |
269 | k->recv = tosa_dac_recv; | |
270 | k->send = tosa_dac_send; | |
271 | } | |
272 | ||
273 | static const TypeInfo tosa_dac_info = { | |
274 | .name = "tosa_dac", | |
275 | .parent = TYPE_I2C_SLAVE, | |
276 | .instance_size = sizeof(TosaDACState), | |
277 | .class_init = tosa_dac_class_init, | |
278 | }; | |
279 | ||
280 | static void tosa_ssp_class_init(ObjectClass *klass, void *data) | |
281 | { | |
282 | SSISlaveClass *k = SSI_SLAVE_CLASS(klass); | |
283 | ||
284 | k->init = tosa_ssp_init; | |
285 | k->transfer = tosa_ssp_tansfer; | |
286 | } | |
287 | ||
288 | static const TypeInfo tosa_ssp_info = { | |
289 | .name = "tosa-ssp", | |
290 | .parent = TYPE_SSI_SLAVE, | |
291 | .instance_size = sizeof(SSISlave), | |
292 | .class_init = tosa_ssp_class_init, | |
293 | }; | |
294 | ||
295 | static void tosa_register_types(void) | |
296 | { | |
297 | type_register_static(&tosa_dac_info); | |
298 | type_register_static(&tosa_ssp_info); | |
299 | } | |
300 | ||
301 | type_init(tosa_register_types) |