?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix 64 bit issue in slirp
[qemu/mini2440/sniper_sniper_test.git] / hw / omap1.c
blob97d2234bcb71326f5735ad779a47ef11f5e0fb9e
1 /*
2 * TI OMAP processors emulation.
3 *
4 * Copyright (C) 2006-2008 Andrzej Zaborowski <balrog@zabor.org>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation; either version 2 or
9 * (at your option) version 3 of the License.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20 #include "hw.h"
21 #include "arm-misc.h"
22 #include "omap.h"
23 #include "sysemu.h"
24 #include "qemu-timer.h"
25 #include "qemu-char.h"
26 #include "soc_dma.h"
27 /* We use pc-style serial ports. */
28 #include "pc.h"
29
30 /* Should signal the TCMI/GPMC */
31 uint32_t omap_badwidth_read8(void *opaque, target_phys_addr_t addr)
32 {
33 uint8_t ret;
34
35 OMAP_8B_REG(addr);
36 cpu_physical_memory_read(addr, (void *) &ret, 1);
37 return ret;
38 }
39
40 void omap_badwidth_write8(void *opaque, target_phys_addr_t addr,
41 uint32_t value)
42 {
43 uint8_t val8 = value;
44
45 OMAP_8B_REG(addr);
46 cpu_physical_memory_write(addr, (void *) &val8, 1);
47 }
48
49 uint32_t omap_badwidth_read16(void *opaque, target_phys_addr_t addr)
50 {
51 uint16_t ret;
52
53 OMAP_16B_REG(addr);
54 cpu_physical_memory_read(addr, (void *) &ret, 2);
55 return ret;
56 }
57
58 void omap_badwidth_write16(void *opaque, target_phys_addr_t addr,
59 uint32_t value)
60 {
61 uint16_t val16 = value;
62
63 OMAP_16B_REG(addr);
64 cpu_physical_memory_write(addr, (void *) &val16, 2);
65 }
66
67 uint32_t omap_badwidth_read32(void *opaque, target_phys_addr_t addr)
68 {
69 uint32_t ret;
70
71 OMAP_32B_REG(addr);
72 cpu_physical_memory_read(addr, (void *) &ret, 4);
73 return ret;
74 }
75
76 void omap_badwidth_write32(void *opaque, target_phys_addr_t addr,
77 uint32_t value)
78 {
79 OMAP_32B_REG(addr);
80 cpu_physical_memory_write(addr, (void *) &value, 4);
81 }
82
83 /* Interrupt Handlers */
84 struct omap_intr_handler_bank_s {
85 uint32_t irqs;
86 uint32_t inputs;
87 uint32_t mask;
88 uint32_t fiq;
89 uint32_t sens_edge;
90 uint32_t swi;
91 unsigned char priority[32];
92 };
93
94 struct omap_intr_handler_s {
95 qemu_irq *pins;
96 qemu_irq parent_intr[2];
97 unsigned char nbanks;
98 int level_only;
99
100 /* state */
101 uint32_t new_agr[2];
102 int sir_intr[2];
103 int autoidle;
104 uint32_t mask;
105 struct omap_intr_handler_bank_s bank[];
106 };
107
108 static void omap_inth_sir_update(struct omap_intr_handler_s *s, int is_fiq)
109 {
110 int i, j, sir_intr, p_intr, p, f;
111 uint32_t level;
112 sir_intr = 0;
113 p_intr = 255;
114
115 /* Find the interrupt line with the highest dynamic priority.
116 * Note: 0 denotes the hightest priority.
117 * If all interrupts have the same priority, the default order is IRQ_N,
118 * IRQ_N-1,...,IRQ_0. */
119 for (j = 0; j < s->nbanks; ++j) {
120 level = s->bank[j].irqs & ~s->bank[j].mask &
121 (is_fiq ? s->bank[j].fiq : ~s->bank[j].fiq);
122 for (f = ffs(level), i = f - 1, level >>= f - 1; f; i += f,
123 level >>= f) {
124 p = s->bank[j].priority[i];
125 if (p <= p_intr) {
126 p_intr = p;
127 sir_intr = 32 * j + i;
128 }
129 f = ffs(level >> 1);
130 }
131 }
132 s->sir_intr[is_fiq] = sir_intr;
133 }
134
135 static inline void omap_inth_update(struct omap_intr_handler_s *s, int is_fiq)
136 {
137 int i;
138 uint32_t has_intr = 0;
139
140 for (i = 0; i < s->nbanks; ++i)
141 has_intr |= s->bank[i].irqs & ~s->bank[i].mask &
142 (is_fiq ? s->bank[i].fiq : ~s->bank[i].fiq);
143
144 if (s->new_agr[is_fiq] & has_intr & s->mask) {
145 s->new_agr[is_fiq] = 0;
146 omap_inth_sir_update(s, is_fiq);
147 qemu_set_irq(s->parent_intr[is_fiq], 1);
148 }
149 }
150
151 #define INT_FALLING_EDGE 0
152 #define INT_LOW_LEVEL 1
153
154 static void omap_set_intr(void *opaque, int irq, int req)
155 {
156 struct omap_intr_handler_s *ih = (struct omap_intr_handler_s *) opaque;
157 uint32_t rise;
158
159 struct omap_intr_handler_bank_s *bank = &ih->bank[irq >> 5];
160 int n = irq & 31;
161
162 if (req) {
163 rise = ~bank->irqs & (1 << n);
164 if (~bank->sens_edge & (1 << n))
165 rise &= ~bank->inputs;
166
167 bank->inputs |= (1 << n);
168 if (rise) {
169 bank->irqs |= rise;
170 omap_inth_update(ih, 0);
171 omap_inth_update(ih, 1);
172 }
173 } else {
174 rise = bank->sens_edge & bank->irqs & (1 << n);
175 bank->irqs &= ~rise;
176 bank->inputs &= ~(1 << n);
177 }
178 }
179
180 /* Simplified version with no edge detection */
181 static void omap_set_intr_noedge(void *opaque, int irq, int req)
182 {
183 struct omap_intr_handler_s *ih = (struct omap_intr_handler_s *) opaque;
184 uint32_t rise;
185
186 struct omap_intr_handler_bank_s *bank = &ih->bank[irq >> 5];
187 int n = irq & 31;
188
189 if (req) {
190 rise = ~bank->inputs & (1 << n);
191 if (rise) {
192 bank->irqs |= bank->inputs |= rise;
193 omap_inth_update(ih, 0);
194 omap_inth_update(ih, 1);
195 }
196 } else
197 bank->irqs = (bank->inputs &= ~(1 << n)) | bank->swi;
198 }
199
200 static uint32_t omap_inth_read(void *opaque, target_phys_addr_t addr)
201 {
202 struct omap_intr_handler_s *s = (struct omap_intr_handler_s *) opaque;
203 int i, offset = addr;
204 int bank_no = offset >> 8;
205 int line_no;
206 struct omap_intr_handler_bank_s *bank = &s->bank[bank_no];
207 offset &= 0xff;
208
209 switch (offset) {
210 case 0x00: /* ITR */
211 return bank->irqs;
212
213 case 0x04: /* MIR */
214 return bank->mask;
215
216 case 0x10: /* SIR_IRQ_CODE */
217 case 0x14: /* SIR_FIQ_CODE */
218 if (bank_no != 0)
219 break;
220 line_no = s->sir_intr[(offset - 0x10) >> 2];
221 bank = &s->bank[line_no >> 5];
222 i = line_no & 31;
223 if (((bank->sens_edge >> i) & 1) == INT_FALLING_EDGE)
224 bank->irqs &= ~(1 << i);
225 return line_no;
226
227 case 0x18: /* CONTROL_REG */
228 if (bank_no != 0)
229 break;
230 return 0;
231
232 case 0x1c: /* ILR0 */
233 case 0x20: /* ILR1 */
234 case 0x24: /* ILR2 */
235 case 0x28: /* ILR3 */
236 case 0x2c: /* ILR4 */
237 case 0x30: /* ILR5 */
238 case 0x34: /* ILR6 */
239 case 0x38: /* ILR7 */
240 case 0x3c: /* ILR8 */
241 case 0x40: /* ILR9 */
242 case 0x44: /* ILR10 */
243 case 0x48: /* ILR11 */
244 case 0x4c: /* ILR12 */
245 case 0x50: /* ILR13 */
246 case 0x54: /* ILR14 */
247 case 0x58: /* ILR15 */
248 case 0x5c: /* ILR16 */
249 case 0x60: /* ILR17 */
250 case 0x64: /* ILR18 */
251 case 0x68: /* ILR19 */
252 case 0x6c: /* ILR20 */
253 case 0x70: /* ILR21 */
254 case 0x74: /* ILR22 */
255 case 0x78: /* ILR23 */
256 case 0x7c: /* ILR24 */
257 case 0x80: /* ILR25 */
258 case 0x84: /* ILR26 */
259 case 0x88: /* ILR27 */
260 case 0x8c: /* ILR28 */
261 case 0x90: /* ILR29 */
262 case 0x94: /* ILR30 */
263 case 0x98: /* ILR31 */
264 i = (offset - 0x1c) >> 2;
265 return (bank->priority[i] << 2) |
266 (((bank->sens_edge >> i) & 1) << 1) |
267 ((bank->fiq >> i) & 1);
268
269 case 0x9c: /* ISR */
270 return 0x00000000;
271
272 }
273 OMAP_BAD_REG(addr);
274 return 0;
275 }
276
277 static void omap_inth_write(void *opaque, target_phys_addr_t addr,
278 uint32_t value)
279 {
280 struct omap_intr_handler_s *s = (struct omap_intr_handler_s *) opaque;
281 int i, offset = addr;
282 int bank_no = offset >> 8;
283 struct omap_intr_handler_bank_s *bank = &s->bank[bank_no];
284 offset &= 0xff;
285
286 switch (offset) {
287 case 0x00: /* ITR */
288 /* Important: ignore the clearing if the IRQ is level-triggered and
289 the input bit is 1 */
290 bank->irqs &= value | (bank->inputs & bank->sens_edge);
291 return;
292
293 case 0x04: /* MIR */
294 bank->mask = value;
295 omap_inth_update(s, 0);
296 omap_inth_update(s, 1);
297 return;
298
299 case 0x10: /* SIR_IRQ_CODE */
300 case 0x14: /* SIR_FIQ_CODE */
301 OMAP_RO_REG(addr);
302 break;
303
304 case 0x18: /* CONTROL_REG */
305 if (bank_no != 0)
306 break;
307 if (value & 2) {
308 qemu_set_irq(s->parent_intr[1], 0);
309 s->new_agr[1] = ~0;
310 omap_inth_update(s, 1);
311 }
312 if (value & 1) {
313 qemu_set_irq(s->parent_intr[0], 0);
314 s->new_agr[0] = ~0;
315 omap_inth_update(s, 0);
316 }
317 return;
318
319 case 0x1c: /* ILR0 */
320 case 0x20: /* ILR1 */
321 case 0x24: /* ILR2 */
322 case 0x28: /* ILR3 */
323 case 0x2c: /* ILR4 */
324 case 0x30: /* ILR5 */
325 case 0x34: /* ILR6 */
326 case 0x38: /* ILR7 */
327 case 0x3c: /* ILR8 */
328 case 0x40: /* ILR9 */
329 case 0x44: /* ILR10 */
330 case 0x48: /* ILR11 */
331 case 0x4c: /* ILR12 */
332 case 0x50: /* ILR13 */
333 case 0x54: /* ILR14 */
334 case 0x58: /* ILR15 */
335 case 0x5c: /* ILR16 */
336 case 0x60: /* ILR17 */
337 case 0x64: /* ILR18 */
338 case 0x68: /* ILR19 */
339 case 0x6c: /* ILR20 */
340 case 0x70: /* ILR21 */
341 case 0x74: /* ILR22 */
342 case 0x78: /* ILR23 */
343 case 0x7c: /* ILR24 */
344 case 0x80: /* ILR25 */
345 case 0x84: /* ILR26 */
346 case 0x88: /* ILR27 */
347 case 0x8c: /* ILR28 */
348 case 0x90: /* ILR29 */
349 case 0x94: /* ILR30 */
350 case 0x98: /* ILR31 */
351 i = (offset - 0x1c) >> 2;
352 bank->priority[i] = (value >> 2) & 0x1f;
353 bank->sens_edge &= ~(1 << i);
354 bank->sens_edge |= ((value >> 1) & 1) << i;
355 bank->fiq &= ~(1 << i);
356 bank->fiq |= (value & 1) << i;
357 return;
358
359 case 0x9c: /* ISR */
360 for (i = 0; i < 32; i ++)
361 if (value & (1 << i)) {
362 omap_set_intr(s, 32 * bank_no + i, 1);
363 return;
364 }
365 return;
366 }
367 OMAP_BAD_REG(addr);
368 }
369
370 static CPUReadMemoryFunc *omap_inth_readfn[] = {
371 omap_badwidth_read32,
372 omap_badwidth_read32,
373 omap_inth_read,
374 };
375
376 static CPUWriteMemoryFunc *omap_inth_writefn[] = {
377 omap_inth_write,
378 omap_inth_write,
379 omap_inth_write,
380 };
381
382 void omap_inth_reset(struct omap_intr_handler_s *s)
383 {
384 int i;
385
386 for (i = 0; i < s->nbanks; ++i){
387 s->bank[i].irqs = 0x00000000;
388 s->bank[i].mask = 0xffffffff;
389 s->bank[i].sens_edge = 0x00000000;
390 s->bank[i].fiq = 0x00000000;
391 s->bank[i].inputs = 0x00000000;
392 s->bank[i].swi = 0x00000000;
393 memset(s->bank[i].priority, 0, sizeof(s->bank[i].priority));
394
395 if (s->level_only)
396 s->bank[i].sens_edge = 0xffffffff;
397 }
398
399 s->new_agr[0] = ~0;
400 s->new_agr[1] = ~0;
401 s->sir_intr[0] = 0;
402 s->sir_intr[1] = 0;
403 s->autoidle = 0;
404 s->mask = ~0;
405
406 qemu_set_irq(s->parent_intr[0], 0);
407 qemu_set_irq(s->parent_intr[1], 0);
408 }
409
410 struct omap_intr_handler_s *omap_inth_init(target_phys_addr_t base,
411 unsigned long size, unsigned char nbanks, qemu_irq **pins,
412 qemu_irq parent_irq, qemu_irq parent_fiq, omap_clk clk)
413 {
414 int iomemtype;
415 struct omap_intr_handler_s *s = (struct omap_intr_handler_s *)
416 qemu_mallocz(sizeof(struct omap_intr_handler_s) +
417 sizeof(struct omap_intr_handler_bank_s) * nbanks);
418
419 s->parent_intr[0] = parent_irq;
420 s->parent_intr[1] = parent_fiq;
421 s->nbanks = nbanks;
422 s->pins = qemu_allocate_irqs(omap_set_intr, s, nbanks * 32);
423 if (pins)
424 *pins = s->pins;
425
426 omap_inth_reset(s);
427
428 iomemtype = cpu_register_io_memory(0, omap_inth_readfn,
429 omap_inth_writefn, s);
430 cpu_register_physical_memory(base, size, iomemtype);
431
432 return s;
433 }
434
435 static uint32_t omap2_inth_read(void *opaque, target_phys_addr_t addr)
436 {
437 struct omap_intr_handler_s *s = (struct omap_intr_handler_s *) opaque;
438 int offset = addr;
439 int bank_no, line_no;
440 struct omap_intr_handler_bank_s *bank = 0;
441
442 if ((offset & 0xf80) == 0x80) {
443 bank_no = (offset & 0x60) >> 5;
444 if (bank_no < s->nbanks) {
445 offset &= ~0x60;
446 bank = &s->bank[bank_no];
447 }
448 }
449
450 switch (offset) {
451 case 0x00: /* INTC_REVISION */
452 return 0x21;
453
454 case 0x10: /* INTC_SYSCONFIG */
455 return (s->autoidle >> 2) & 1;
456
457 case 0x14: /* INTC_SYSSTATUS */
458 return 1; /* RESETDONE */
459
460 case 0x40: /* INTC_SIR_IRQ */
461 return s->sir_intr[0];
462
463 case 0x44: /* INTC_SIR_FIQ */
464 return s->sir_intr[1];
465
466 case 0x48: /* INTC_CONTROL */
467 return (!s->mask) << 2; /* GLOBALMASK */
468
469 case 0x4c: /* INTC_PROTECTION */
470 return 0;
471
472 case 0x50: /* INTC_IDLE */
473 return s->autoidle & 3;
474
475 /* Per-bank registers */
476 case 0x80: /* INTC_ITR */
477 return bank->inputs;
478
479 case 0x84: /* INTC_MIR */
480 return bank->mask;
481
482 case 0x88: /* INTC_MIR_CLEAR */
483 case 0x8c: /* INTC_MIR_SET */
484 return 0;
485
486 case 0x90: /* INTC_ISR_SET */
487 return bank->swi;
488
489 case 0x94: /* INTC_ISR_CLEAR */
490 return 0;
491
492 case 0x98: /* INTC_PENDING_IRQ */
493 return bank->irqs & ~bank->mask & ~bank->fiq;
494
495 case 0x9c: /* INTC_PENDING_FIQ */
496 return bank->irqs & ~bank->mask & bank->fiq;
497
498 /* Per-line registers */
499 case 0x100 ... 0x300: /* INTC_ILR */
500 bank_no = (offset - 0x100) >> 7;
501 if (bank_no > s->nbanks)
502 break;
503 bank = &s->bank[bank_no];
504 line_no = (offset & 0x7f) >> 2;
505 return (bank->priority[line_no] << 2) |
506 ((bank->fiq >> line_no) & 1);
507 }
508 OMAP_BAD_REG(addr);
509 return 0;
510 }
511
512 static void omap2_inth_write(void *opaque, target_phys_addr_t addr,
513 uint32_t value)
514 {
515 struct omap_intr_handler_s *s = (struct omap_intr_handler_s *) opaque;
516 int offset = addr;
517 int bank_no, line_no;
518 struct omap_intr_handler_bank_s *bank = 0;
519
520 if ((offset & 0xf80) == 0x80) {
521 bank_no = (offset & 0x60) >> 5;
522 if (bank_no < s->nbanks) {
523 offset &= ~0x60;
524 bank = &s->bank[bank_no];
525 }
526 }
527
528 switch (offset) {
529 case 0x10: /* INTC_SYSCONFIG */
530 s->autoidle &= 4;
531 s->autoidle |= (value & 1) << 2;
532 if (value & 2) /* SOFTRESET */
533 omap_inth_reset(s);
534 return;
535
536 case 0x48: /* INTC_CONTROL */
537 s->mask = (value & 4) ? 0 : ~0; /* GLOBALMASK */
538 if (value & 2) { /* NEWFIQAGR */
539 qemu_set_irq(s->parent_intr[1], 0);
540 s->new_agr[1] = ~0;
541 omap_inth_update(s, 1);
542 }
543 if (value & 1) { /* NEWIRQAGR */
544 qemu_set_irq(s->parent_intr[0], 0);
545 s->new_agr[0] = ~0;
546 omap_inth_update(s, 0);
547 }
548 return;
549
550 case 0x4c: /* INTC_PROTECTION */
551 /* TODO: Make a bitmap (or sizeof(char)map) of access privileges
552 * for every register, see Chapter 3 and 4 for privileged mode. */
553 if (value & 1)
554 fprintf(stderr, "%s: protection mode enable attempt\n",
555 __FUNCTION__);
556 return;
557
558 case 0x50: /* INTC_IDLE */
559 s->autoidle &= ~3;
560 s->autoidle |= value & 3;
561 return;
562
563 /* Per-bank registers */
564 case 0x84: /* INTC_MIR */
565 bank->mask = value;
566 omap_inth_update(s, 0);
567 omap_inth_update(s, 1);
568 return;
569
570 case 0x88: /* INTC_MIR_CLEAR */
571 bank->mask &= ~value;
572 omap_inth_update(s, 0);
573 omap_inth_update(s, 1);
574 return;
575
576 case 0x8c: /* INTC_MIR_SET */
577 bank->mask |= value;
578 return;
579
580 case 0x90: /* INTC_ISR_SET */
581 bank->irqs |= bank->swi |= value;
582 omap_inth_update(s, 0);
583 omap_inth_update(s, 1);
584 return;
585
586 case 0x94: /* INTC_ISR_CLEAR */
587 bank->swi &= ~value;
588 bank->irqs = bank->swi & bank->inputs;
589 return;
590
591 /* Per-line registers */
592 case 0x100 ... 0x300: /* INTC_ILR */
593 bank_no = (offset - 0x100) >> 7;
594 if (bank_no > s->nbanks)
595 break;
596 bank = &s->bank[bank_no];
597 line_no = (offset & 0x7f) >> 2;
598 bank->priority[line_no] = (value >> 2) & 0x3f;
599 bank->fiq &= ~(1 << line_no);
600 bank->fiq |= (value & 1) << line_no;
601 return;
602
603 case 0x00: /* INTC_REVISION */
604 case 0x14: /* INTC_SYSSTATUS */
605 case 0x40: /* INTC_SIR_IRQ */
606 case 0x44: /* INTC_SIR_FIQ */
607 case 0x80: /* INTC_ITR */
608 case 0x98: /* INTC_PENDING_IRQ */
609 case 0x9c: /* INTC_PENDING_FIQ */
610 OMAP_RO_REG(addr);
611 return;
612 }
613 OMAP_BAD_REG(addr);
614 }
615
616 static CPUReadMemoryFunc *omap2_inth_readfn[] = {
617 omap_badwidth_read32,
618 omap_badwidth_read32,
619 omap2_inth_read,
620 };
621
622 static CPUWriteMemoryFunc *omap2_inth_writefn[] = {
623 omap2_inth_write,
624 omap2_inth_write,
625 omap2_inth_write,
626 };
627
628 struct omap_intr_handler_s *omap2_inth_init(target_phys_addr_t base,
629 int size, int nbanks, qemu_irq **pins,
630 qemu_irq parent_irq, qemu_irq parent_fiq,
631 omap_clk fclk, omap_clk iclk)
632 {
633 int iomemtype;
634 struct omap_intr_handler_s *s = (struct omap_intr_handler_s *)
635 qemu_mallocz(sizeof(struct omap_intr_handler_s) +
636 sizeof(struct omap_intr_handler_bank_s) * nbanks);
637
638 s->parent_intr[0] = parent_irq;
639 s->parent_intr[1] = parent_fiq;
640 s->nbanks = nbanks;
641 s->level_only = 1;
642 s->pins = qemu_allocate_irqs(omap_set_intr_noedge, s, nbanks * 32);
643 if (pins)
644 *pins = s->pins;
645
646 omap_inth_reset(s);
647
648 iomemtype = cpu_register_io_memory(0, omap2_inth_readfn,
649 omap2_inth_writefn, s);
650 cpu_register_physical_memory(base, size, iomemtype);
651
652 return s;
653 }
654
655 /* MPU OS timers */
656 struct omap_mpu_timer_s {
657 qemu_irq irq;
658 omap_clk clk;
659 uint32_t val;
660 int64_t time;
661 QEMUTimer *timer;
662 QEMUBH *tick;
663 int64_t rate;
664 int it_ena;
665
666 int enable;
667 int ptv;
668 int ar;
669 int st;
670 uint32_t reset_val;
671 };
672
673 static inline uint32_t omap_timer_read(struct omap_mpu_timer_s *timer)
674 {
675 uint64_t distance = qemu_get_clock(vm_clock) - timer->time;
676
677 if (timer->st && timer->enable && timer->rate)
678 return timer->val - muldiv64(distance >> (timer->ptv + 1),
679 timer->rate, ticks_per_sec);
680 else
681 return timer->val;
682 }
683
684 static inline void omap_timer_sync(struct omap_mpu_timer_s *timer)
685 {
686 timer->val = omap_timer_read(timer);
687 timer->time = qemu_get_clock(vm_clock);
688 }
689
690 static inline void omap_timer_update(struct omap_mpu_timer_s *timer)
691 {
692 int64_t expires;
693
694 if (timer->enable && timer->st && timer->rate) {
695 timer->val = timer->reset_val; /* Should skip this on clk enable */
696 expires = muldiv64((uint64_t) timer->val << (timer->ptv + 1),
697 ticks_per_sec, timer->rate);
698
699 /* If timer expiry would be sooner than in about 1 ms and
700 * auto-reload isn't set, then fire immediately. This is a hack
701 * to make systems like PalmOS run in acceptable time. PalmOS
702 * sets the interval to a very low value and polls the status bit
703 * in a busy loop when it wants to sleep just a couple of CPU
704 * ticks. */
705 if (expires > (ticks_per_sec >> 10) || timer->ar)
706 qemu_mod_timer(timer->timer, timer->time + expires);
707 else
708 qemu_bh_schedule(timer->tick);
709 } else
710 qemu_del_timer(timer->timer);
711 }
712
713 static void omap_timer_fire(void *opaque)
714 {
715 struct omap_mpu_timer_s *timer = opaque;
716
717 if (!timer->ar) {
718 timer->val = 0;
719 timer->st = 0;
720 }
721
722 if (timer->it_ena)
723 /* Edge-triggered irq */
724 qemu_irq_pulse(timer->irq);
725 }
726
727 static void omap_timer_tick(void *opaque)
728 {
729 struct omap_mpu_timer_s *timer = (struct omap_mpu_timer_s *) opaque;
730
731 omap_timer_sync(timer);
732 omap_timer_fire(timer);
733 omap_timer_update(timer);
734 }
735
736 static void omap_timer_clk_update(void *opaque, int line, int on)
737 {
738 struct omap_mpu_timer_s *timer = (struct omap_mpu_timer_s *) opaque;
739
740 omap_timer_sync(timer);
741 timer->rate = on ? omap_clk_getrate(timer->clk) : 0;
742 omap_timer_update(timer);
743 }
744
745 static void omap_timer_clk_setup(struct omap_mpu_timer_s *timer)
746 {
747 omap_clk_adduser(timer->clk,
748 qemu_allocate_irqs(omap_timer_clk_update, timer, 1)[0]);
749 timer->rate = omap_clk_getrate(timer->clk);
750 }
751
752 static uint32_t omap_mpu_timer_read(void *opaque, target_phys_addr_t addr)
753 {
754 struct omap_mpu_timer_s *s = (struct omap_mpu_timer_s *) opaque;
755
756 switch (addr) {
757 case 0x00: /* CNTL_TIMER */
758 return (s->enable << 5) | (s->ptv << 2) | (s->ar << 1) | s->st;
759
760 case 0x04: /* LOAD_TIM */
761 break;
762
763 case 0x08: /* READ_TIM */
764 return omap_timer_read(s);
765 }
766
767 OMAP_BAD_REG(addr);
768 return 0;
769 }
770
771 static void omap_mpu_timer_write(void *opaque, target_phys_addr_t addr,
772 uint32_t value)
773 {
774 struct omap_mpu_timer_s *s = (struct omap_mpu_timer_s *) opaque;
775
776 switch (addr) {
777 case 0x00: /* CNTL_TIMER */
778 omap_timer_sync(s);
779 s->enable = (value >> 5) & 1;
780 s->ptv = (value >> 2) & 7;
781 s->ar = (value >> 1) & 1;
782 s->st = value & 1;
783 omap_timer_update(s);
784 return;
785
786 case 0x04: /* LOAD_TIM */
787 s->reset_val = value;
788 return;
789
790 case 0x08: /* READ_TIM */
791 OMAP_RO_REG(addr);
792 break;
793
794 default:
795 OMAP_BAD_REG(addr);
796 }
797 }
798
799 static CPUReadMemoryFunc *omap_mpu_timer_readfn[] = {
800 omap_badwidth_read32,
801 omap_badwidth_read32,
802 omap_mpu_timer_read,
803 };
804
805 static CPUWriteMemoryFunc *omap_mpu_timer_writefn[] = {
806 omap_badwidth_write32,
807 omap_badwidth_write32,
808 omap_mpu_timer_write,
809 };
810
811 static void omap_mpu_timer_reset(struct omap_mpu_timer_s *s)
812 {
813 qemu_del_timer(s->timer);
814 s->enable = 0;
815 s->reset_val = 31337;
816 s->val = 0;
817 s->ptv = 0;
818 s->ar = 0;
819 s->st = 0;
820 s->it_ena = 1;
821 }
822
823 struct omap_mpu_timer_s *omap_mpu_timer_init(target_phys_addr_t base,
824 qemu_irq irq, omap_clk clk)
825 {
826 int iomemtype;
827 struct omap_mpu_timer_s *s = (struct omap_mpu_timer_s *)
828 qemu_mallocz(sizeof(struct omap_mpu_timer_s));
829
830 s->irq = irq;
831 s->clk = clk;
832 s->timer = qemu_new_timer(vm_clock, omap_timer_tick, s);
833 s->tick = qemu_bh_new(omap_timer_fire, s);
834 omap_mpu_timer_reset(s);
835 omap_timer_clk_setup(s);
836
837 iomemtype = cpu_register_io_memory(0, omap_mpu_timer_readfn,
838 omap_mpu_timer_writefn, s);
839 cpu_register_physical_memory(base, 0x100, iomemtype);
840
841 return s;
842 }
843
844 /* Watchdog timer */
845 struct omap_watchdog_timer_s {
846 struct omap_mpu_timer_s timer;
847 uint8_t last_wr;
848 int mode;
849 int free;
850 int reset;
851 };
852
853 static uint32_t omap_wd_timer_read(void *opaque, target_phys_addr_t addr)
854 {
855 struct omap_watchdog_timer_s *s = (struct omap_watchdog_timer_s *) opaque;
856
857 switch (addr) {
858 case 0x00: /* CNTL_TIMER */
859 return (s->timer.ptv << 9) | (s->timer.ar << 8) |
860 (s->timer.st << 7) | (s->free << 1);
861
862 case 0x04: /* READ_TIMER */
863 return omap_timer_read(&s->timer);
864
865 case 0x08: /* TIMER_MODE */
866 return s->mode << 15;
867 }
868
869 OMAP_BAD_REG(addr);
870 return 0;
871 }
872
873 static void omap_wd_timer_write(void *opaque, target_phys_addr_t addr,
874 uint32_t value)
875 {
876 struct omap_watchdog_timer_s *s = (struct omap_watchdog_timer_s *) opaque;
877
878 switch (addr) {
879 case 0x00: /* CNTL_TIMER */
880 omap_timer_sync(&s->timer);
881 s->timer.ptv = (value >> 9) & 7;
882 s->timer.ar = (value >> 8) & 1;
883 s->timer.st = (value >> 7) & 1;
884 s->free = (value >> 1) & 1;
885 omap_timer_update(&s->timer);
886 break;
887
888 case 0x04: /* LOAD_TIMER */
889 s->timer.reset_val = value & 0xffff;
890 break;
891
892 case 0x08: /* TIMER_MODE */
893 if (!s->mode && ((value >> 15) & 1))
894 omap_clk_get(s->timer.clk);
895 s->mode |= (value >> 15) & 1;
896 if (s->last_wr == 0xf5) {
897 if ((value & 0xff) == 0xa0) {
898 if (s->mode) {
899 s->mode = 0;
900 omap_clk_put(s->timer.clk);
901 }
902 } else {
903 /* XXX: on T|E hardware somehow this has no effect,
904 * on Zire 71 it works as specified. */
905 s->reset = 1;
906 qemu_system_reset_request();
907 }
908 }
909 s->last_wr = value & 0xff;
910 break;
911
912 default:
913 OMAP_BAD_REG(addr);
914 }
915 }
916
917 static CPUReadMemoryFunc *omap_wd_timer_readfn[] = {
918 omap_badwidth_read16,
919 omap_wd_timer_read,
920 omap_badwidth_read16,
921 };
922
923 static CPUWriteMemoryFunc *omap_wd_timer_writefn[] = {
924 omap_badwidth_write16,
925 omap_wd_timer_write,
926 omap_badwidth_write16,
927 };
928
929 static void omap_wd_timer_reset(struct omap_watchdog_timer_s *s)
930 {
931 qemu_del_timer(s->timer.timer);
932 if (!s->mode)
933 omap_clk_get(s->timer.clk);
934 s->mode = 1;
935 s->free = 1;
936 s->reset = 0;
937 s->timer.enable = 1;
938 s->timer.it_ena = 1;
939 s->timer.reset_val = 0xffff;
940 s->timer.val = 0;
941 s->timer.st = 0;
942 s->timer.ptv = 0;
943 s->timer.ar = 0;
944 omap_timer_update(&s->timer);
945 }
946
947 struct omap_watchdog_timer_s *omap_wd_timer_init(target_phys_addr_t base,
948 qemu_irq irq, omap_clk clk)
949 {
950 int iomemtype;
951 struct omap_watchdog_timer_s *s = (struct omap_watchdog_timer_s *)
952 qemu_mallocz(sizeof(struct omap_watchdog_timer_s));
953
954 s->timer.irq = irq;
955 s->timer.clk = clk;
956 s->timer.timer = qemu_new_timer(vm_clock, omap_timer_tick, &s->timer);
957 omap_wd_timer_reset(s);
958 omap_timer_clk_setup(&s->timer);
959
960 iomemtype = cpu_register_io_memory(0, omap_wd_timer_readfn,
961 omap_wd_timer_writefn, s);
962 cpu_register_physical_memory(base, 0x100, iomemtype);
963
964 return s;
965 }
966
967 /* 32-kHz timer */
968 struct omap_32khz_timer_s {
969 struct omap_mpu_timer_s timer;
970 };
971
972 static uint32_t omap_os_timer_read(void *opaque, target_phys_addr_t addr)
973 {
974 struct omap_32khz_timer_s *s = (struct omap_32khz_timer_s *) opaque;
975 int offset = addr & OMAP_MPUI_REG_MASK;
976
977 switch (offset) {
978 case 0x00: /* TVR */
979 return s->timer.reset_val;
980
981 case 0x04: /* TCR */
982 return omap_timer_read(&s->timer);
983
984 case 0x08: /* CR */
985 return (s->timer.ar << 3) | (s->timer.it_ena << 2) | s->timer.st;
986
987 default:
988 break;
989 }
990 OMAP_BAD_REG(addr);
991 return 0;
992 }
993
994 static void omap_os_timer_write(void *opaque, target_phys_addr_t addr,
995 uint32_t value)
996 {
997 struct omap_32khz_timer_s *s = (struct omap_32khz_timer_s *) opaque;
998 int offset = addr & OMAP_MPUI_REG_MASK;
999
1000 switch (offset) {
1001 case 0x00: /* TVR */
1002 s->timer.reset_val = value & 0x00ffffff;
1003 break;
1004
1005 case 0x04: /* TCR */
1006 OMAP_RO_REG(addr);
1007 break;
1008
1009 case 0x08: /* CR */
1010 s->timer.ar = (value >> 3) & 1;
1011 s->timer.it_ena = (value >> 2) & 1;
1012 if (s->timer.st != (value & 1) || (value & 2)) {
1013 omap_timer_sync(&s->timer);
1014 s->timer.enable = value & 1;
1015 s->timer.st = value & 1;
1016 omap_timer_update(&s->timer);
1017 }
1018 break;
1019
1020 default:
1021 OMAP_BAD_REG(addr);
1022 }
1023 }
1024
1025 static CPUReadMemoryFunc *omap_os_timer_readfn[] = {
1026 omap_badwidth_read32,
1027 omap_badwidth_read32,
1028 omap_os_timer_read,
1029 };
1030
1031 static CPUWriteMemoryFunc *omap_os_timer_writefn[] = {
1032 omap_badwidth_write32,
1033 omap_badwidth_write32,
1034 omap_os_timer_write,
1035 };
1036
1037 static void omap_os_timer_reset(struct omap_32khz_timer_s *s)
1038 {
1039 qemu_del_timer(s->timer.timer);
1040 s->timer.enable = 0;
1041 s->timer.it_ena = 0;
1042 s->timer.reset_val = 0x00ffffff;
1043 s->timer.val = 0;
1044 s->timer.st = 0;
1045 s->timer.ptv = 0;
1046 s->timer.ar = 1;
1047 }
1048
1049 struct omap_32khz_timer_s *omap_os_timer_init(target_phys_addr_t base,
1050 qemu_irq irq, omap_clk clk)
1051 {
1052 int iomemtype;
1053 struct omap_32khz_timer_s *s = (struct omap_32khz_timer_s *)
1054 qemu_mallocz(sizeof(struct omap_32khz_timer_s));
1055
1056 s->timer.irq = irq;
1057 s->timer.clk = clk;
1058 s->timer.timer = qemu_new_timer(vm_clock, omap_timer_tick, &s->timer);
1059 omap_os_timer_reset(s);
1060 omap_timer_clk_setup(&s->timer);
1061
1062 iomemtype = cpu_register_io_memory(0, omap_os_timer_readfn,
1063 omap_os_timer_writefn, s);
1064 cpu_register_physical_memory(base, 0x800, iomemtype);
1065
1066 return s;
1067 }
1068
1069 /* Ultra Low-Power Device Module */
1070 static uint32_t omap_ulpd_pm_read(void *opaque, target_phys_addr_t addr)
1071 {
1072 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
1073 uint16_t ret;
1074
1075 switch (addr) {
1076 case 0x14: /* IT_STATUS */
1077 ret = s->ulpd_pm_regs[addr >> 2];
1078 s->ulpd_pm_regs[addr >> 2] = 0;
1079 qemu_irq_lower(s->irq[1][OMAP_INT_GAUGE_32K]);
1080 return ret;
1081
1082 case 0x18: /* Reserved */
1083 case 0x1c: /* Reserved */
1084 case 0x20: /* Reserved */
1085 case 0x28: /* Reserved */
1086 case 0x2c: /* Reserved */
1087 OMAP_BAD_REG(addr);
1088 case 0x00: /* COUNTER_32_LSB */
1089 case 0x04: /* COUNTER_32_MSB */
1090 case 0x08: /* COUNTER_HIGH_FREQ_LSB */
1091 case 0x0c: /* COUNTER_HIGH_FREQ_MSB */
1092 case 0x10: /* GAUGING_CTRL */
1093 case 0x24: /* SETUP_ANALOG_CELL3_ULPD1 */
1094 case 0x30: /* CLOCK_CTRL */
1095 case 0x34: /* SOFT_REQ */
1096 case 0x38: /* COUNTER_32_FIQ */
1097 case 0x3c: /* DPLL_CTRL */
1098 case 0x40: /* STATUS_REQ */
1099 /* XXX: check clk::usecount state for every clock */
1100 case 0x48: /* LOCL_TIME */
1101 case 0x4c: /* APLL_CTRL */
1102 case 0x50: /* POWER_CTRL */
1103 return s->ulpd_pm_regs[addr >> 2];
1104 }
1105
1106 OMAP_BAD_REG(addr);
1107 return 0;
1108 }
1109
1110 static inline void omap_ulpd_clk_update(struct omap_mpu_state_s *s,
1111 uint16_t diff, uint16_t value)
1112 {
1113 if (diff & (1 << 4)) /* USB_MCLK_EN */
1114 omap_clk_onoff(omap_findclk(s, "usb_clk0"), (value >> 4) & 1);
1115 if (diff & (1 << 5)) /* DIS_USB_PVCI_CLK */
1116 omap_clk_onoff(omap_findclk(s, "usb_w2fc_ck"), (~value >> 5) & 1);
1117 }
1118
1119 static inline void omap_ulpd_req_update(struct omap_mpu_state_s *s,
1120 uint16_t diff, uint16_t value)
1121 {
1122 if (diff & (1 << 0)) /* SOFT_DPLL_REQ */
1123 omap_clk_canidle(omap_findclk(s, "dpll4"), (~value >> 0) & 1);
1124 if (diff & (1 << 1)) /* SOFT_COM_REQ */
1125 omap_clk_canidle(omap_findclk(s, "com_mclk_out"), (~value >> 1) & 1);
1126 if (diff & (1 << 2)) /* SOFT_SDW_REQ */
1127 omap_clk_canidle(omap_findclk(s, "bt_mclk_out"), (~value >> 2) & 1);
1128 if (diff & (1 << 3)) /* SOFT_USB_REQ */
1129 omap_clk_canidle(omap_findclk(s, "usb_clk0"), (~value >> 3) & 1);
1130 }
1131
1132 static void omap_ulpd_pm_write(void *opaque, target_phys_addr_t addr,
1133 uint32_t value)
1134 {
1135 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
1136 int64_t now, ticks;
1137 int div, mult;
1138 static const int bypass_div[4] = { 1, 2, 4, 4 };
1139 uint16_t diff;
1140
1141 switch (addr) {
1142 case 0x00: /* COUNTER_32_LSB */
1143 case 0x04: /* COUNTER_32_MSB */
1144 case 0x08: /* COUNTER_HIGH_FREQ_LSB */
1145 case 0x0c: /* COUNTER_HIGH_FREQ_MSB */
1146 case 0x14: /* IT_STATUS */
1147 case 0x40: /* STATUS_REQ */
1148 OMAP_RO_REG(addr);
1149 break;
1150
1151 case 0x10: /* GAUGING_CTRL */
1152 /* Bits 0 and 1 seem to be confused in the OMAP 310 TRM */
1153 if ((s->ulpd_pm_regs[addr >> 2] ^ value) & 1) {
1154 now = qemu_get_clock(vm_clock);
1155
1156 if (value & 1)
1157 s->ulpd_gauge_start = now;
1158 else {
1159 now -= s->ulpd_gauge_start;
1160
1161 /* 32-kHz ticks */
1162 ticks = muldiv64(now, 32768, ticks_per_sec);
1163 s->ulpd_pm_regs[0x00 >> 2] = (ticks >> 0) & 0xffff;
1164 s->ulpd_pm_regs[0x04 >> 2] = (ticks >> 16) & 0xffff;
1165 if (ticks >> 32) /* OVERFLOW_32K */
1166 s->ulpd_pm_regs[0x14 >> 2] |= 1 << 2;
1167
1168 /* High frequency ticks */
1169 ticks = muldiv64(now, 12000000, ticks_per_sec);
1170 s->ulpd_pm_regs[0x08 >> 2] = (ticks >> 0) & 0xffff;
1171 s->ulpd_pm_regs[0x0c >> 2] = (ticks >> 16) & 0xffff;
1172 if (ticks >> 32) /* OVERFLOW_HI_FREQ */
1173 s->ulpd_pm_regs[0x14 >> 2] |= 1 << 1;
1174
1175 s->ulpd_pm_regs[0x14 >> 2] |= 1 << 0; /* IT_GAUGING */
1176 qemu_irq_raise(s->irq[1][OMAP_INT_GAUGE_32K]);
1177 }
1178 }
1179 s->ulpd_pm_regs[addr >> 2] = value;
1180 break;
1181
1182 case 0x18: /* Reserved */
1183 case 0x1c: /* Reserved */
1184 case 0x20: /* Reserved */
1185 case 0x28: /* Reserved */
1186 case 0x2c: /* Reserved */
1187 OMAP_BAD_REG(addr);
1188 case 0x24: /* SETUP_ANALOG_CELL3_ULPD1 */
1189 case 0x38: /* COUNTER_32_FIQ */
1190 case 0x48: /* LOCL_TIME */
1191 case 0x50: /* POWER_CTRL */
1192 s->ulpd_pm_regs[addr >> 2] = value;
1193 break;
1194
1195 case 0x30: /* CLOCK_CTRL */
1196 diff = s->ulpd_pm_regs[addr >> 2] ^ value;
1197 s->ulpd_pm_regs[addr >> 2] = value & 0x3f;
1198 omap_ulpd_clk_update(s, diff, value);
1199 break;
1200
1201 case 0x34: /* SOFT_REQ */
1202 diff = s->ulpd_pm_regs[addr >> 2] ^ value;
1203 s->ulpd_pm_regs[addr >> 2] = value & 0x1f;
1204 omap_ulpd_req_update(s, diff, value);
1205 break;
1206
1207 case 0x3c: /* DPLL_CTRL */
1208 /* XXX: OMAP310 TRM claims bit 3 is PLL_ENABLE, and bit 4 is
1209 * omitted altogether, probably a typo. */
1210 /* This register has identical semantics with DPLL(1:3) control
1211 * registers, see omap_dpll_write() */
1212 diff = s->ulpd_pm_regs[addr >> 2] & value;
1213 s->ulpd_pm_regs[addr >> 2] = value & 0x2fff;
1214 if (diff & (0x3ff << 2)) {
1215 if (value & (1 << 4)) { /* PLL_ENABLE */
1216 div = ((value >> 5) & 3) + 1; /* PLL_DIV */
1217 mult = MIN((value >> 7) & 0x1f, 1); /* PLL_MULT */
1218 } else {
1219 div = bypass_div[((value >> 2) & 3)]; /* BYPASS_DIV */
1220 mult = 1;
1221 }
1222 omap_clk_setrate(omap_findclk(s, "dpll4"), div, mult);
1223 }
1224
1225 /* Enter the desired mode. */
1226 s->ulpd_pm_regs[addr >> 2] =
1227 (s->ulpd_pm_regs[addr >> 2] & 0xfffe) |
1228 ((s->ulpd_pm_regs[addr >> 2] >> 4) & 1);
1229
1230 /* Act as if the lock is restored. */
1231 s->ulpd_pm_regs[addr >> 2] |= 2;
1232 break;
1233
1234 case 0x4c: /* APLL_CTRL */
1235 diff = s->ulpd_pm_regs[addr >> 2] & value;
1236 s->ulpd_pm_regs[addr >> 2] = value & 0xf;
1237 if (diff & (1 << 0)) /* APLL_NDPLL_SWITCH */
1238 omap_clk_reparent(omap_findclk(s, "ck_48m"), omap_findclk(s,
1239 (value & (1 << 0)) ? "apll" : "dpll4"));
1240 break;
1241
1242 default:
1243 OMAP_BAD_REG(addr);
1244 }
1245 }
1246
1247 static CPUReadMemoryFunc *omap_ulpd_pm_readfn[] = {
1248 omap_badwidth_read16,
1249 omap_ulpd_pm_read,
1250 omap_badwidth_read16,
1251 };
1252
1253 static CPUWriteMemoryFunc *omap_ulpd_pm_writefn[] = {
1254 omap_badwidth_write16,
1255 omap_ulpd_pm_write,
1256 omap_badwidth_write16,
1257 };
1258
1259 static void omap_ulpd_pm_reset(struct omap_mpu_state_s *mpu)
1260 {
1261 mpu->ulpd_pm_regs[0x00 >> 2] = 0x0001;
1262 mpu->ulpd_pm_regs[0x04 >> 2] = 0x0000;
1263 mpu->ulpd_pm_regs[0x08 >> 2] = 0x0001;
1264 mpu->ulpd_pm_regs[0x0c >> 2] = 0x0000;
1265 mpu->ulpd_pm_regs[0x10 >> 2] = 0x0000;
1266 mpu->ulpd_pm_regs[0x18 >> 2] = 0x01;
1267 mpu->ulpd_pm_regs[0x1c >> 2] = 0x01;
1268 mpu->ulpd_pm_regs[0x20 >> 2] = 0x01;
1269 mpu->ulpd_pm_regs[0x24 >> 2] = 0x03ff;
1270 mpu->ulpd_pm_regs[0x28 >> 2] = 0x01;
1271 mpu->ulpd_pm_regs[0x2c >> 2] = 0x01;
1272 omap_ulpd_clk_update(mpu, mpu->ulpd_pm_regs[0x30 >> 2], 0x0000);
1273 mpu->ulpd_pm_regs[0x30 >> 2] = 0x0000;
1274 omap_ulpd_req_update(mpu, mpu->ulpd_pm_regs[0x34 >> 2], 0x0000);
1275 mpu->ulpd_pm_regs[0x34 >> 2] = 0x0000;
1276 mpu->ulpd_pm_regs[0x38 >> 2] = 0x0001;
1277 mpu->ulpd_pm_regs[0x3c >> 2] = 0x2211;
1278 mpu->ulpd_pm_regs[0x40 >> 2] = 0x0000; /* FIXME: dump a real STATUS_REQ */
1279 mpu->ulpd_pm_regs[0x48 >> 2] = 0x960;
1280 mpu->ulpd_pm_regs[0x4c >> 2] = 0x08;
1281 mpu->ulpd_pm_regs[0x50 >> 2] = 0x08;
1282 omap_clk_setrate(omap_findclk(mpu, "dpll4"), 1, 4);
1283 omap_clk_reparent(omap_findclk(mpu, "ck_48m"), omap_findclk(mpu, "dpll4"));
1284 }
1285
1286 static void omap_ulpd_pm_init(target_phys_addr_t base,
1287 struct omap_mpu_state_s *mpu)
1288 {
1289 int iomemtype = cpu_register_io_memory(0, omap_ulpd_pm_readfn,
1290 omap_ulpd_pm_writefn, mpu);
1291
1292 cpu_register_physical_memory(base, 0x800, iomemtype);
1293 omap_ulpd_pm_reset(mpu);
1294 }
1295
1296 /* OMAP Pin Configuration */
1297 static uint32_t omap_pin_cfg_read(void *opaque, target_phys_addr_t addr)
1298 {
1299 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
1300
1301 switch (addr) {
1302 case 0x00: /* FUNC_MUX_CTRL_0 */
1303 case 0x04: /* FUNC_MUX_CTRL_1 */
1304 case 0x08: /* FUNC_MUX_CTRL_2 */
1305 return s->func_mux_ctrl[addr >> 2];
1306
1307 case 0x0c: /* COMP_MODE_CTRL_0 */
1308 return s->comp_mode_ctrl[0];
1309
1310 case 0x10: /* FUNC_MUX_CTRL_3 */
1311 case 0x14: /* FUNC_MUX_CTRL_4 */
1312 case 0x18: /* FUNC_MUX_CTRL_5 */
1313 case 0x1c: /* FUNC_MUX_CTRL_6 */
1314 case 0x20: /* FUNC_MUX_CTRL_7 */
1315 case 0x24: /* FUNC_MUX_CTRL_8 */
1316 case 0x28: /* FUNC_MUX_CTRL_9 */
1317 case 0x2c: /* FUNC_MUX_CTRL_A */
1318 case 0x30: /* FUNC_MUX_CTRL_B */
1319 case 0x34: /* FUNC_MUX_CTRL_C */
1320 case 0x38: /* FUNC_MUX_CTRL_D */
1321 return s->func_mux_ctrl[(addr >> 2) - 1];
1322
1323 case 0x40: /* PULL_DWN_CTRL_0 */
1324 case 0x44: /* PULL_DWN_CTRL_1 */
1325 case 0x48: /* PULL_DWN_CTRL_2 */
1326 case 0x4c: /* PULL_DWN_CTRL_3 */
1327 return s->pull_dwn_ctrl[(addr & 0xf) >> 2];
1328
1329 case 0x50: /* GATE_INH_CTRL_0 */
1330 return s->gate_inh_ctrl[0];
1331
1332 case 0x60: /* VOLTAGE_CTRL_0 */
1333 return s->voltage_ctrl[0];
1334
1335 case 0x70: /* TEST_DBG_CTRL_0 */
1336 return s->test_dbg_ctrl[0];
1337
1338 case 0x80: /* MOD_CONF_CTRL_0 */
1339 return s->mod_conf_ctrl[0];
1340 }
1341
1342 OMAP_BAD_REG(addr);
1343 return 0;
1344 }
1345
1346 static inline void omap_pin_funcmux0_update(struct omap_mpu_state_s *s,
1347 uint32_t diff, uint32_t value)
1348 {
1349 if (s->compat1509) {
1350 if (diff & (1 << 9)) /* BLUETOOTH */
1351 omap_clk_onoff(omap_findclk(s, "bt_mclk_out"),
1352 (~value >> 9) & 1);
1353 if (diff & (1 << 7)) /* USB.CLKO */
1354 omap_clk_onoff(omap_findclk(s, "usb.clko"),
1355 (value >> 7) & 1);
1356 }
1357 }
1358
1359 static inline void omap_pin_funcmux1_update(struct omap_mpu_state_s *s,
1360 uint32_t diff, uint32_t value)
1361 {
1362 if (s->compat1509) {
1363 if (diff & (1 << 31)) /* MCBSP3_CLK_HIZ_DI */
1364 omap_clk_onoff(omap_findclk(s, "mcbsp3.clkx"),
1365 (value >> 31) & 1);
1366 if (diff & (1 << 1)) /* CLK32K */
1367 omap_clk_onoff(omap_findclk(s, "clk32k_out"),
1368 (~value >> 1) & 1);
1369 }
1370 }
1371
1372 static inline void omap_pin_modconf1_update(struct omap_mpu_state_s *s,
1373 uint32_t diff, uint32_t value)
1374 {
1375 if (diff & (1 << 31)) /* CONF_MOD_UART3_CLK_MODE_R */
1376 omap_clk_reparent(omap_findclk(s, "uart3_ck"),
1377 omap_findclk(s, ((value >> 31) & 1) ?
1378 "ck_48m" : "armper_ck"));
1379 if (diff & (1 << 30)) /* CONF_MOD_UART2_CLK_MODE_R */
1380 omap_clk_reparent(omap_findclk(s, "uart2_ck"),
1381 omap_findclk(s, ((value >> 30) & 1) ?
1382 "ck_48m" : "armper_ck"));
1383 if (diff & (1 << 29)) /* CONF_MOD_UART1_CLK_MODE_R */
1384 omap_clk_reparent(omap_findclk(s, "uart1_ck"),
1385 omap_findclk(s, ((value >> 29) & 1) ?
1386 "ck_48m" : "armper_ck"));
1387 if (diff & (1 << 23)) /* CONF_MOD_MMC_SD_CLK_REQ_R */
1388 omap_clk_reparent(omap_findclk(s, "mmc_ck"),
1389 omap_findclk(s, ((value >> 23) & 1) ?
1390 "ck_48m" : "armper_ck"));
1391 if (diff & (1 << 12)) /* CONF_MOD_COM_MCLK_12_48_S */
1392 omap_clk_reparent(omap_findclk(s, "com_mclk_out"),
1393 omap_findclk(s, ((value >> 12) & 1) ?
1394 "ck_48m" : "armper_ck"));
1395 if (diff & (1 << 9)) /* CONF_MOD_USB_HOST_HHC_UHO */
1396 omap_clk_onoff(omap_findclk(s, "usb_hhc_ck"), (value >> 9) & 1);
1397 }
1398
1399 static void omap_pin_cfg_write(void *opaque, target_phys_addr_t addr,
1400 uint32_t value)
1401 {
1402 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
1403 uint32_t diff;
1404
1405 switch (addr) {
1406 case 0x00: /* FUNC_MUX_CTRL_0 */
1407 diff = s->func_mux_ctrl[addr >> 2] ^ value;
1408 s->func_mux_ctrl[addr >> 2] = value;
1409 omap_pin_funcmux0_update(s, diff, value);
1410 return;
1411
1412 case 0x04: /* FUNC_MUX_CTRL_1 */
1413 diff = s->func_mux_ctrl[addr >> 2] ^ value;
1414 s->func_mux_ctrl[addr >> 2] = value;
1415 omap_pin_funcmux1_update(s, diff, value);
1416 return;
1417
1418 case 0x08: /* FUNC_MUX_CTRL_2 */
1419 s->func_mux_ctrl[addr >> 2] = value;
1420 return;
1421
1422 case 0x0c: /* COMP_MODE_CTRL_0 */
1423 s->comp_mode_ctrl[0] = value;
1424 s->compat1509 = (value != 0x0000eaef);
1425 omap_pin_funcmux0_update(s, ~0, s->func_mux_ctrl[0]);
1426 omap_pin_funcmux1_update(s, ~0, s->func_mux_ctrl[1]);
1427 return;
1428
1429 case 0x10: /* FUNC_MUX_CTRL_3 */
1430 case 0x14: /* FUNC_MUX_CTRL_4 */
1431 case 0x18: /* FUNC_MUX_CTRL_5 */
1432 case 0x1c: /* FUNC_MUX_CTRL_6 */
1433 case 0x20: /* FUNC_MUX_CTRL_7 */
1434 case 0x24: /* FUNC_MUX_CTRL_8 */
1435 case 0x28: /* FUNC_MUX_CTRL_9 */
1436 case 0x2c: /* FUNC_MUX_CTRL_A */
1437 case 0x30: /* FUNC_MUX_CTRL_B */
1438 case 0x34: /* FUNC_MUX_CTRL_C */
1439 case 0x38: /* FUNC_MUX_CTRL_D */
1440 s->func_mux_ctrl[(addr >> 2) - 1] = value;
1441 return;
1442
1443 case 0x40: /* PULL_DWN_CTRL_0 */
1444 case 0x44: /* PULL_DWN_CTRL_1 */
1445 case 0x48: /* PULL_DWN_CTRL_2 */
1446 case 0x4c: /* PULL_DWN_CTRL_3 */
1447 s->pull_dwn_ctrl[(addr & 0xf) >> 2] = value;
1448 return;
1449
1450 case 0x50: /* GATE_INH_CTRL_0 */
1451 s->gate_inh_ctrl[0] = value;
1452 return;
1453
1454 case 0x60: /* VOLTAGE_CTRL_0 */
1455 s->voltage_ctrl[0] = value;
1456 return;
1457
1458 case 0x70: /* TEST_DBG_CTRL_0 */
1459 s->test_dbg_ctrl[0] = value;
1460 return;
1461
1462 case 0x80: /* MOD_CONF_CTRL_0 */
1463 diff = s->mod_conf_ctrl[0] ^ value;
1464 s->mod_conf_ctrl[0] = value;
1465 omap_pin_modconf1_update(s, diff, value);
1466 return;
1467
1468 default:
1469 OMAP_BAD_REG(addr);
1470 }
1471 }
1472
1473 static CPUReadMemoryFunc *omap_pin_cfg_readfn[] = {
1474 omap_badwidth_read32,
1475 omap_badwidth_read32,
1476 omap_pin_cfg_read,
1477 };
1478
1479 static CPUWriteMemoryFunc *omap_pin_cfg_writefn[] = {
1480 omap_badwidth_write32,
1481 omap_badwidth_write32,
1482 omap_pin_cfg_write,
1483 };
1484
1485 static void omap_pin_cfg_reset(struct omap_mpu_state_s *mpu)
1486 {
1487 /* Start in Compatibility Mode. */
1488 mpu->compat1509 = 1;
1489 omap_pin_funcmux0_update(mpu, mpu->func_mux_ctrl[0], 0);
1490 omap_pin_funcmux1_update(mpu, mpu->func_mux_ctrl[1], 0);
1491 omap_pin_modconf1_update(mpu, mpu->mod_conf_ctrl[0], 0);
1492 memset(mpu->func_mux_ctrl, 0, sizeof(mpu->func_mux_ctrl));
1493 memset(mpu->comp_mode_ctrl, 0, sizeof(mpu->comp_mode_ctrl));
1494 memset(mpu->pull_dwn_ctrl, 0, sizeof(mpu->pull_dwn_ctrl));
1495 memset(mpu->gate_inh_ctrl, 0, sizeof(mpu->gate_inh_ctrl));
1496 memset(mpu->voltage_ctrl, 0, sizeof(mpu->voltage_ctrl));
1497 memset(mpu->test_dbg_ctrl, 0, sizeof(mpu->test_dbg_ctrl));
1498 memset(mpu->mod_conf_ctrl, 0, sizeof(mpu->mod_conf_ctrl));
1499 }
1500
1501 static void omap_pin_cfg_init(target_phys_addr_t base,
1502 struct omap_mpu_state_s *mpu)
1503 {
1504 int iomemtype = cpu_register_io_memory(0, omap_pin_cfg_readfn,
1505 omap_pin_cfg_writefn, mpu);
1506
1507 cpu_register_physical_memory(base, 0x800, iomemtype);
1508 omap_pin_cfg_reset(mpu);
1509 }
1510
1511 /* Device Identification, Die Identification */
1512 static uint32_t omap_id_read(void *opaque, target_phys_addr_t addr)
1513 {
1514 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
1515
1516 switch (addr) {
1517 case 0xfffe1800: /* DIE_ID_LSB */
1518 return 0xc9581f0e;
1519 case 0xfffe1804: /* DIE_ID_MSB */
1520 return 0xa8858bfa;
1521
1522 case 0xfffe2000: /* PRODUCT_ID_LSB */
1523 return 0x00aaaafc;
1524 case 0xfffe2004: /* PRODUCT_ID_MSB */
1525 return 0xcafeb574;
1526
1527 case 0xfffed400: /* JTAG_ID_LSB */
1528 switch (s->mpu_model) {
1529 case omap310:
1530 return 0x03310315;
1531 case omap1510:
1532 return 0x03310115;
1533 default:
1534 cpu_abort(cpu_single_env, "%s: bad mpu model\n", __FUNCTION__);
1535 }
1536 break;
1537
1538 case 0xfffed404: /* JTAG_ID_MSB */
1539 switch (s->mpu_model) {
1540 case omap310:
1541 return 0xfb57402f;
1542 case omap1510:
1543 return 0xfb47002f;
1544 default:
1545 cpu_abort(cpu_single_env, "%s: bad mpu model\n", __FUNCTION__);
1546 }
1547 break;
1548 }
1549
1550 OMAP_BAD_REG(addr);
1551 return 0;
1552 }
1553
1554 static void omap_id_write(void *opaque, target_phys_addr_t addr,
1555 uint32_t value)
1556 {
1557 OMAP_BAD_REG(addr);
1558 }
1559
1560 static CPUReadMemoryFunc *omap_id_readfn[] = {
1561 omap_badwidth_read32,
1562 omap_badwidth_read32,
1563 omap_id_read,
1564 };
1565
1566 static CPUWriteMemoryFunc *omap_id_writefn[] = {
1567 omap_badwidth_write32,
1568 omap_badwidth_write32,
1569 omap_id_write,
1570 };
1571
1572 static void omap_id_init(struct omap_mpu_state_s *mpu)
1573 {
1574 int iomemtype = cpu_register_io_memory(0, omap_id_readfn,
1575 omap_id_writefn, mpu);
1576 cpu_register_physical_memory_offset(0xfffe1800, 0x800, iomemtype, 0xfffe1800);
1577 cpu_register_physical_memory_offset(0xfffed400, 0x100, iomemtype, 0xfffed400);
1578 if (!cpu_is_omap15xx(mpu))
1579 cpu_register_physical_memory_offset(0xfffe2000, 0x800, iomemtype, 0xfffe2000);
1580 }
1581
1582 /* MPUI Control (Dummy) */
1583 static uint32_t omap_mpui_read(void *opaque, target_phys_addr_t addr)
1584 {
1585 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
1586
1587 switch (addr) {
1588 case 0x00: /* CTRL */
1589 return s->mpui_ctrl;
1590 case 0x04: /* DEBUG_ADDR */
1591 return 0x01ffffff;
1592 case 0x08: /* DEBUG_DATA */
1593 return 0xffffffff;
1594 case 0x0c: /* DEBUG_FLAG */
1595 return 0x00000800;
1596 case 0x10: /* STATUS */
1597 return 0x00000000;
1598
1599 /* Not in OMAP310 */
1600 case 0x14: /* DSP_STATUS */
1601 case 0x18: /* DSP_BOOT_CONFIG */
1602 return 0x00000000;
1603 case 0x1c: /* DSP_MPUI_CONFIG */
1604 return 0x0000ffff;
1605 }
1606
1607 OMAP_BAD_REG(addr);
1608 return 0;
1609 }
1610
1611 static void omap_mpui_write(void *opaque, target_phys_addr_t addr,
1612 uint32_t value)
1613 {
1614 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
1615
1616 switch (addr) {
1617 case 0x00: /* CTRL */
1618 s->mpui_ctrl = value & 0x007fffff;
1619 break;
1620
1621 case 0x04: /* DEBUG_ADDR */
1622 case 0x08: /* DEBUG_DATA */
1623 case 0x0c: /* DEBUG_FLAG */
1624 case 0x10: /* STATUS */
1625 /* Not in OMAP310 */
1626 case 0x14: /* DSP_STATUS */
1627 OMAP_RO_REG(addr);
1628 case 0x18: /* DSP_BOOT_CONFIG */
1629 case 0x1c: /* DSP_MPUI_CONFIG */
1630 break;
1631
1632 default:
1633 OMAP_BAD_REG(addr);
1634 }
1635 }
1636
1637 static CPUReadMemoryFunc *omap_mpui_readfn[] = {
1638 omap_badwidth_read32,
1639 omap_badwidth_read32,
1640 omap_mpui_read,
1641 };
1642
1643 static CPUWriteMemoryFunc *omap_mpui_writefn[] = {
1644 omap_badwidth_write32,
1645 omap_badwidth_write32,
1646 omap_mpui_write,
1647 };
1648
1649 static void omap_mpui_reset(struct omap_mpu_state_s *s)
1650 {
1651 s->mpui_ctrl = 0x0003ff1b;
1652 }
1653
1654 static void omap_mpui_init(target_phys_addr_t base,
1655 struct omap_mpu_state_s *mpu)
1656 {
1657 int iomemtype = cpu_register_io_memory(0, omap_mpui_readfn,
1658 omap_mpui_writefn, mpu);
1659
1660 cpu_register_physical_memory(base, 0x100, iomemtype);
1661
1662 omap_mpui_reset(mpu);
1663 }
1664
1665 /* TIPB Bridges */
1666 struct omap_tipb_bridge_s {
1667 qemu_irq abort;
1668
1669 int width_intr;
1670 uint16_t control;
1671 uint16_t alloc;
1672 uint16_t buffer;
1673 uint16_t enh_control;
1674 };
1675
1676 static uint32_t omap_tipb_bridge_read(void *opaque, target_phys_addr_t addr)
1677 {
1678 struct omap_tipb_bridge_s *s = (struct omap_tipb_bridge_s *) opaque;
1679
1680 switch (addr) {
1681 case 0x00: /* TIPB_CNTL */
1682 return s->control;
1683 case 0x04: /* TIPB_BUS_ALLOC */
1684 return s->alloc;
1685 case 0x08: /* MPU_TIPB_CNTL */
1686 return s->buffer;
1687 case 0x0c: /* ENHANCED_TIPB_CNTL */
1688 return s->enh_control;
1689 case 0x10: /* ADDRESS_DBG */
1690 case 0x14: /* DATA_DEBUG_LOW */
1691 case 0x18: /* DATA_DEBUG_HIGH */
1692 return 0xffff;
1693 case 0x1c: /* DEBUG_CNTR_SIG */
1694 return 0x00f8;
1695 }
1696
1697 OMAP_BAD_REG(addr);
1698 return 0;
1699 }
1700
1701 static void omap_tipb_bridge_write(void *opaque, target_phys_addr_t addr,
1702 uint32_t value)
1703 {
1704 struct omap_tipb_bridge_s *s = (struct omap_tipb_bridge_s *) opaque;
1705
1706 switch (addr) {
1707 case 0x00: /* TIPB_CNTL */
1708 s->control = value & 0xffff;
1709 break;
1710
1711 case 0x04: /* TIPB_BUS_ALLOC */
1712 s->alloc = value & 0x003f;
1713 break;
1714
1715 case 0x08: /* MPU_TIPB_CNTL */
1716 s->buffer = value & 0x0003;
1717 break;
1718
1719 case 0x0c: /* ENHANCED_TIPB_CNTL */
1720 s->width_intr = !(value & 2);
1721 s->enh_control = value & 0x000f;
1722 break;
1723
1724 case 0x10: /* ADDRESS_DBG */
1725 case 0x14: /* DATA_DEBUG_LOW */
1726 case 0x18: /* DATA_DEBUG_HIGH */
1727 case 0x1c: /* DEBUG_CNTR_SIG */
1728 OMAP_RO_REG(addr);
1729 break;
1730
1731 default:
1732 OMAP_BAD_REG(addr);
1733 }
1734 }
1735
1736 static CPUReadMemoryFunc *omap_tipb_bridge_readfn[] = {
1737 omap_badwidth_read16,
1738 omap_tipb_bridge_read,
1739 omap_tipb_bridge_read,
1740 };
1741
1742 static CPUWriteMemoryFunc *omap_tipb_bridge_writefn[] = {
1743 omap_badwidth_write16,
1744 omap_tipb_bridge_write,
1745 omap_tipb_bridge_write,
1746 };
1747
1748 static void omap_tipb_bridge_reset(struct omap_tipb_bridge_s *s)
1749 {
1750 s->control = 0xffff;
1751 s->alloc = 0x0009;
1752 s->buffer = 0x0000;
1753 s->enh_control = 0x000f;
1754 }
1755
1756 struct omap_tipb_bridge_s *omap_tipb_bridge_init(target_phys_addr_t base,
1757 qemu_irq abort_irq, omap_clk clk)
1758 {
1759 int iomemtype;
1760 struct omap_tipb_bridge_s *s = (struct omap_tipb_bridge_s *)
1761 qemu_mallocz(sizeof(struct omap_tipb_bridge_s));
1762
1763 s->abort = abort_irq;
1764 omap_tipb_bridge_reset(s);
1765
1766 iomemtype = cpu_register_io_memory(0, omap_tipb_bridge_readfn,
1767 omap_tipb_bridge_writefn, s);
1768 cpu_register_physical_memory(base, 0x100, iomemtype);
1769
1770 return s;
1771 }
1772
1773 /* Dummy Traffic Controller's Memory Interface */
1774 static uint32_t omap_tcmi_read(void *opaque, target_phys_addr_t addr)
1775 {
1776 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
1777 uint32_t ret;
1778
1779 switch (addr) {
1780 case 0x00: /* IMIF_PRIO */
1781 case 0x04: /* EMIFS_PRIO */
1782 case 0x08: /* EMIFF_PRIO */
1783 case 0x0c: /* EMIFS_CONFIG */
1784 case 0x10: /* EMIFS_CS0_CONFIG */
1785 case 0x14: /* EMIFS_CS1_CONFIG */
1786 case 0x18: /* EMIFS_CS2_CONFIG */
1787 case 0x1c: /* EMIFS_CS3_CONFIG */
1788 case 0x24: /* EMIFF_MRS */
1789 case 0x28: /* TIMEOUT1 */
1790 case 0x2c: /* TIMEOUT2 */
1791 case 0x30: /* TIMEOUT3 */
1792 case 0x3c: /* EMIFF_SDRAM_CONFIG_2 */
1793 case 0x40: /* EMIFS_CFG_DYN_WAIT */
1794 return s->tcmi_regs[addr >> 2];
1795
1796 case 0x20: /* EMIFF_SDRAM_CONFIG */
1797 ret = s->tcmi_regs[addr >> 2];
1798 s->tcmi_regs[addr >> 2] &= ~1; /* XXX: Clear SLRF on SDRAM access */
1799 /* XXX: We can try using the VGA_DIRTY flag for this */
1800 return ret;
1801 }
1802
1803 OMAP_BAD_REG(addr);
1804 return 0;
1805 }
1806
1807 static void omap_tcmi_write(void *opaque, target_phys_addr_t addr,
1808 uint32_t value)
1809 {
1810 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
1811
1812 switch (addr) {
1813 case 0x00: /* IMIF_PRIO */
1814 case 0x04: /* EMIFS_PRIO */
1815 case 0x08: /* EMIFF_PRIO */
1816 case 0x10: /* EMIFS_CS0_CONFIG */
1817 case 0x14: /* EMIFS_CS1_CONFIG */
1818 case 0x18: /* EMIFS_CS2_CONFIG */
1819 case 0x1c: /* EMIFS_CS3_CONFIG */
1820 case 0x20: /* EMIFF_SDRAM_CONFIG */
1821 case 0x24: /* EMIFF_MRS */
1822 case 0x28: /* TIMEOUT1 */
1823 case 0x2c: /* TIMEOUT2 */
1824 case 0x30: /* TIMEOUT3 */
1825 case 0x3c: /* EMIFF_SDRAM_CONFIG_2 */
1826 case 0x40: /* EMIFS_CFG_DYN_WAIT */
1827 s->tcmi_regs[addr >> 2] = value;
1828 break;
1829 case 0x0c: /* EMIFS_CONFIG */
1830 s->tcmi_regs[addr >> 2] = (value & 0xf) | (1 << 4);
1831 break;
1832
1833 default:
1834 OMAP_BAD_REG(addr);
1835 }
1836 }
1837
1838 static CPUReadMemoryFunc *omap_tcmi_readfn[] = {
1839 omap_badwidth_read32,
1840 omap_badwidth_read32,
1841 omap_tcmi_read,
1842 };
1843
1844 static CPUWriteMemoryFunc *omap_tcmi_writefn[] = {
1845 omap_badwidth_write32,
1846 omap_badwidth_write32,
1847 omap_tcmi_write,
1848 };
1849
1850 static void omap_tcmi_reset(struct omap_mpu_state_s *mpu)
1851 {
1852 mpu->tcmi_regs[0x00 >> 2] = 0x00000000;
1853 mpu->tcmi_regs[0x04 >> 2] = 0x00000000;
1854 mpu->tcmi_regs[0x08 >> 2] = 0x00000000;
1855 mpu->tcmi_regs[0x0c >> 2] = 0x00000010;
1856 mpu->tcmi_regs[0x10 >> 2] = 0x0010fffb;
1857 mpu->tcmi_regs[0x14 >> 2] = 0x0010fffb;
1858 mpu->tcmi_regs[0x18 >> 2] = 0x0010fffb;
1859 mpu->tcmi_regs[0x1c >> 2] = 0x0010fffb;
1860 mpu->tcmi_regs[0x20 >> 2] = 0x00618800;
1861 mpu->tcmi_regs[0x24 >> 2] = 0x00000037;
1862 mpu->tcmi_regs[0x28 >> 2] = 0x00000000;
1863 mpu->tcmi_regs[0x2c >> 2] = 0x00000000;
1864 mpu->tcmi_regs[0x30 >> 2] = 0x00000000;
1865 mpu->tcmi_regs[0x3c >> 2] = 0x00000003;
1866 mpu->tcmi_regs[0x40 >> 2] = 0x00000000;
1867 }
1868
1869 static void omap_tcmi_init(target_phys_addr_t base,
1870 struct omap_mpu_state_s *mpu)
1871 {
1872 int iomemtype = cpu_register_io_memory(0, omap_tcmi_readfn,
1873 omap_tcmi_writefn, mpu);
1874
1875 cpu_register_physical_memory(base, 0x100, iomemtype);
1876 omap_tcmi_reset(mpu);
1877 }
1878
1879 /* Digital phase-locked loops control */
1880 static uint32_t omap_dpll_read(void *opaque, target_phys_addr_t addr)
1881 {
1882 struct dpll_ctl_s *s = (struct dpll_ctl_s *) opaque;
1883
1884 if (addr == 0x00) /* CTL_REG */
1885 return s->mode;
1886
1887 OMAP_BAD_REG(addr);
1888 return 0;
1889 }
1890
1891 static void omap_dpll_write(void *opaque, target_phys_addr_t addr,
1892 uint32_t value)
1893 {
1894 struct dpll_ctl_s *s = (struct dpll_ctl_s *) opaque;
1895 uint16_t diff;
1896 static const int bypass_div[4] = { 1, 2, 4, 4 };
1897 int div, mult;
1898
1899 if (addr == 0x00) { /* CTL_REG */
1900 /* See omap_ulpd_pm_write() too */
1901 diff = s->mode & value;
1902 s->mode = value & 0x2fff;
1903 if (diff & (0x3ff << 2)) {
1904 if (value & (1 << 4)) { /* PLL_ENABLE */
1905 div = ((value >> 5) & 3) + 1; /* PLL_DIV */
1906 mult = MIN((value >> 7) & 0x1f, 1); /* PLL_MULT */
1907 } else {
1908 div = bypass_div[((value >> 2) & 3)]; /* BYPASS_DIV */
1909 mult = 1;
1910 }
1911 omap_clk_setrate(s->dpll, div, mult);
1912 }
1913
1914 /* Enter the desired mode. */
1915 s->mode = (s->mode & 0xfffe) | ((s->mode >> 4) & 1);
1916
1917 /* Act as if the lock is restored. */
1918 s->mode |= 2;
1919 } else {
1920 OMAP_BAD_REG(addr);
1921 }
1922 }
1923
1924 static CPUReadMemoryFunc *omap_dpll_readfn[] = {
1925 omap_badwidth_read16,
1926 omap_dpll_read,
1927 omap_badwidth_read16,
1928 };
1929
1930 static CPUWriteMemoryFunc *omap_dpll_writefn[] = {
1931 omap_badwidth_write16,
1932 omap_dpll_write,
1933 omap_badwidth_write16,
1934 };
1935
1936 static void omap_dpll_reset(struct dpll_ctl_s *s)
1937 {
1938 s->mode = 0x2002;
1939 omap_clk_setrate(s->dpll, 1, 1);
1940 }
1941
1942 static void omap_dpll_init(struct dpll_ctl_s *s, target_phys_addr_t base,
1943 omap_clk clk)
1944 {
1945 int iomemtype = cpu_register_io_memory(0, omap_dpll_readfn,
1946 omap_dpll_writefn, s);
1947
1948 s->dpll = clk;
1949 omap_dpll_reset(s);
1950
1951 cpu_register_physical_memory(base, 0x100, iomemtype);
1952 }
1953
1954 /* UARTs */
1955 struct omap_uart_s {
1956 target_phys_addr_t base;
1957 SerialState *serial; /* TODO */
1958 struct omap_target_agent_s *ta;
1959 omap_clk fclk;
1960 qemu_irq irq;
1961
1962 uint8_t eblr;
1963 uint8_t syscontrol;
1964 uint8_t wkup;
1965 uint8_t cfps;
1966 uint8_t mdr[2];
1967 uint8_t scr;
1968 uint8_t clksel;
1969 };
1970
1971 void omap_uart_reset(struct omap_uart_s *s)
1972 {
1973 s->eblr = 0x00;
1974 s->syscontrol = 0;
1975 s->wkup = 0x3f;
1976 s->cfps = 0x69;
1977 s->clksel = 0;
1978 }
1979
1980 struct omap_uart_s *omap_uart_init(target_phys_addr_t base,
1981 qemu_irq irq, omap_clk fclk, omap_clk iclk,
1982 qemu_irq txdma, qemu_irq rxdma, CharDriverState *chr)
1983 {
1984 struct omap_uart_s *s = (struct omap_uart_s *)
1985 qemu_mallocz(sizeof(struct omap_uart_s));
1986
1987 s->base = base;
1988 s->fclk = fclk;
1989 s->irq = irq;
1990 s->serial = serial_mm_init(base, 2, irq, omap_clk_getrate(fclk)/16,
1991 chr ?: qemu_chr_open("null", "null"), 1);
1992
1993 return s;
1994 }
1995
1996 static uint32_t omap_uart_read(void *opaque, target_phys_addr_t addr)
1997 {
1998 struct omap_uart_s *s = (struct omap_uart_s *) opaque;
1999
2000 addr &= 0xff;
2001 switch (addr) {
2002 case 0x20: /* MDR1 */
2003 return s->mdr[0];
2004 case 0x24: /* MDR2 */
2005 return s->mdr[1];
2006 case 0x40: /* SCR */
2007 return s->scr;
2008 case 0x44: /* SSR */
2009 return 0x0;
2010 case 0x48: /* EBLR (OMAP2) */
2011 return s->eblr;
2012 case 0x4C: /* OSC_12M_SEL (OMAP1) */
2013 return s->clksel;
2014 case 0x50: /* MVR */
2015 return 0x30;
2016 case 0x54: /* SYSC (OMAP2) */
2017 return s->syscontrol;
2018 case 0x58: /* SYSS (OMAP2) */
2019 return 1;
2020 case 0x5c: /* WER (OMAP2) */
2021 return s->wkup;
2022 case 0x60: /* CFPS (OMAP2) */
2023 return s->cfps;
2024 }
2025
2026 OMAP_BAD_REG(addr);
2027 return 0;
2028 }
2029
2030 static void omap_uart_write(void *opaque, target_phys_addr_t addr,
2031 uint32_t value)
2032 {
2033 struct omap_uart_s *s = (struct omap_uart_s *) opaque;
2034
2035 addr &= 0xff;
2036 switch (addr) {
2037 case 0x20: /* MDR1 */
2038 s->mdr[0] = value & 0x7f;
2039 break;
2040 case 0x24: /* MDR2 */
2041 s->mdr[1] = value & 0xff;
2042 break;
2043 case 0x40: /* SCR */
2044 s->scr = value & 0xff;
2045 break;
2046 case 0x48: /* EBLR (OMAP2) */
2047 s->eblr = value & 0xff;
2048 break;
2049 case 0x4C: /* OSC_12M_SEL (OMAP1) */
2050 s->clksel = value & 1;
2051 break;
2052 case 0x44: /* SSR */
2053 case 0x50: /* MVR */
2054 case 0x58: /* SYSS (OMAP2) */
2055 OMAP_RO_REG(addr);
2056 break;
2057 case 0x54: /* SYSC (OMAP2) */
2058 s->syscontrol = value & 0x1d;
2059 if (value & 2)
2060 omap_uart_reset(s);
2061 break;
2062 case 0x5c: /* WER (OMAP2) */
2063 s->wkup = value & 0x7f;
2064 break;
2065 case 0x60: /* CFPS (OMAP2) */
2066 s->cfps = value & 0xff;
2067 break;
2068 default:
2069 OMAP_BAD_REG(addr);
2070 }
2071 }
2072
2073 static CPUReadMemoryFunc *omap_uart_readfn[] = {
2074 omap_uart_read,
2075 omap_uart_read,
2076 omap_badwidth_read8,
2077 };
2078
2079 static CPUWriteMemoryFunc *omap_uart_writefn[] = {
2080 omap_uart_write,
2081 omap_uart_write,
2082 omap_badwidth_write8,
2083 };
2084
2085 struct omap_uart_s *omap2_uart_init(struct omap_target_agent_s *ta,
2086 qemu_irq irq, omap_clk fclk, omap_clk iclk,
2087 qemu_irq txdma, qemu_irq rxdma, CharDriverState *chr)
2088 {
2089 target_phys_addr_t base = omap_l4_attach(ta, 0, 0);
2090 struct omap_uart_s *s = omap_uart_init(base, irq,
2091 fclk, iclk, txdma, rxdma, chr);
2092 int iomemtype = cpu_register_io_memory(0, omap_uart_readfn,
2093 omap_uart_writefn, s);
2094
2095 s->ta = ta;
2096
2097 cpu_register_physical_memory(base + 0x20, 0x100, iomemtype);
2098
2099 return s;
2100 }
2101
2102 void omap_uart_attach(struct omap_uart_s *s, CharDriverState *chr)
2103 {
2104 /* TODO: Should reuse or destroy current s->serial */
2105 s->serial = serial_mm_init(s->base, 2, s->irq,
2106 omap_clk_getrate(s->fclk) / 16,
2107 chr ?: qemu_chr_open("null", "null"), 1);
2108 }
2109
2110 /* MPU Clock/Reset/Power Mode Control */
2111 static uint32_t omap_clkm_read(void *opaque, target_phys_addr_t addr)
2112 {
2113 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
2114
2115 switch (addr) {
2116 case 0x00: /* ARM_CKCTL */
2117 return s->clkm.arm_ckctl;
2118
2119 case 0x04: /* ARM_IDLECT1 */
2120 return s->clkm.arm_idlect1;
2121
2122 case 0x08: /* ARM_IDLECT2 */
2123 return s->clkm.arm_idlect2;
2124
2125 case 0x0c: /* ARM_EWUPCT */
2126 return s->clkm.arm_ewupct;
2127
2128 case 0x10: /* ARM_RSTCT1 */
2129 return s->clkm.arm_rstct1;
2130
2131 case 0x14: /* ARM_RSTCT2 */
2132 return s->clkm.arm_rstct2;
2133
2134 case 0x18: /* ARM_SYSST */
2135 return (s->clkm.clocking_scheme << 11) | s->clkm.cold_start;
2136
2137 case 0x1c: /* ARM_CKOUT1 */
2138 return s->clkm.arm_ckout1;
2139
2140 case 0x20: /* ARM_CKOUT2 */
2141 break;
2142 }
2143
2144 OMAP_BAD_REG(addr);
2145 return 0;
2146 }
2147
2148 static inline void omap_clkm_ckctl_update(struct omap_mpu_state_s *s,
2149 uint16_t diff, uint16_t value)
2150 {
2151 omap_clk clk;
2152
2153 if (diff & (1 << 14)) { /* ARM_INTHCK_SEL */
2154 if (value & (1 << 14))
2155 /* Reserved */;
2156 else {
2157 clk = omap_findclk(s, "arminth_ck");
2158 omap_clk_reparent(clk, omap_findclk(s, "tc_ck"));
2159 }
2160 }
2161 if (diff & (1 << 12)) { /* ARM_TIMXO */
2162 clk = omap_findclk(s, "armtim_ck");
2163 if (value & (1 << 12))
2164 omap_clk_reparent(clk, omap_findclk(s, "clkin"));
2165 else
2166 omap_clk_reparent(clk, omap_findclk(s, "ck_gen1"));
2167 }
2168 /* XXX: en_dspck */
2169 if (diff & (3 << 10)) { /* DSPMMUDIV */
2170 clk = omap_findclk(s, "dspmmu_ck");
2171 omap_clk_setrate(clk, 1 << ((value >> 10) & 3), 1);
2172 }
2173 if (diff & (3 << 8)) { /* TCDIV */
2174 clk = omap_findclk(s, "tc_ck");
2175 omap_clk_setrate(clk, 1 << ((value >> 8) & 3), 1);
2176 }
2177 if (diff & (3 << 6)) { /* DSPDIV */
2178 clk = omap_findclk(s, "dsp_ck");
2179 omap_clk_setrate(clk, 1 << ((value >> 6) & 3), 1);
2180 }
2181 if (diff & (3 << 4)) { /* ARMDIV */
2182 clk = omap_findclk(s, "arm_ck");
2183 omap_clk_setrate(clk, 1 << ((value >> 4) & 3), 1);
2184 }
2185 if (diff & (3 << 2)) { /* LCDDIV */
2186 clk = omap_findclk(s, "lcd_ck");
2187 omap_clk_setrate(clk, 1 << ((value >> 2) & 3), 1);
2188 }
2189 if (diff & (3 << 0)) { /* PERDIV */
2190 clk = omap_findclk(s, "armper_ck");
2191 omap_clk_setrate(clk, 1 << ((value >> 0) & 3), 1);
2192 }
2193 }
2194
2195 static inline void omap_clkm_idlect1_update(struct omap_mpu_state_s *s,
2196 uint16_t diff, uint16_t value)
2197 {
2198 omap_clk clk;
2199
2200 if (value & (1 << 11)) /* SETARM_IDLE */
2201 cpu_interrupt(s->env, CPU_INTERRUPT_HALT);
2202 if (!(value & (1 << 10))) /* WKUP_MODE */
2203 qemu_system_shutdown_request(); /* XXX: disable wakeup from IRQ */
2204
2205 #define SET_CANIDLE(clock, bit) \
2206 if (diff & (1 << bit)) { \
2207 clk = omap_findclk(s, clock); \
2208 omap_clk_canidle(clk, (value >> bit) & 1); \
2209 }
2210 SET_CANIDLE("mpuwd_ck", 0) /* IDLWDT_ARM */
2211 SET_CANIDLE("armxor_ck", 1) /* IDLXORP_ARM */
2212 SET_CANIDLE("mpuper_ck", 2) /* IDLPER_ARM */
2213 SET_CANIDLE("lcd_ck", 3) /* IDLLCD_ARM */
2214 SET_CANIDLE("lb_ck", 4) /* IDLLB_ARM */
2215 SET_CANIDLE("hsab_ck", 5) /* IDLHSAB_ARM */
2216 SET_CANIDLE("tipb_ck", 6) /* IDLIF_ARM */
2217 SET_CANIDLE("dma_ck", 6) /* IDLIF_ARM */
2218 SET_CANIDLE("tc_ck", 6) /* IDLIF_ARM */
2219 SET_CANIDLE("dpll1", 7) /* IDLDPLL_ARM */
2220 SET_CANIDLE("dpll2", 7) /* IDLDPLL_ARM */
2221 SET_CANIDLE("dpll3", 7) /* IDLDPLL_ARM */
2222 SET_CANIDLE("mpui_ck", 8) /* IDLAPI_ARM */
2223 SET_CANIDLE("armtim_ck", 9) /* IDLTIM_ARM */
2224 }
2225
2226 static inline void omap_clkm_idlect2_update(struct omap_mpu_state_s *s,
2227 uint16_t diff, uint16_t value)
2228 {
2229 omap_clk clk;
2230
2231 #define SET_ONOFF(clock, bit) \
2232 if (diff & (1 << bit)) { \
2233 clk = omap_findclk(s, clock); \
2234 omap_clk_onoff(clk, (value >> bit) & 1); \
2235 }
2236 SET_ONOFF("mpuwd_ck", 0) /* EN_WDTCK */
2237 SET_ONOFF("armxor_ck", 1) /* EN_XORPCK */
2238 SET_ONOFF("mpuper_ck", 2) /* EN_PERCK */
2239 SET_ONOFF("lcd_ck", 3) /* EN_LCDCK */
2240 SET_ONOFF("lb_ck", 4) /* EN_LBCK */
2241 SET_ONOFF("hsab_ck", 5) /* EN_HSABCK */
2242 SET_ONOFF("mpui_ck", 6) /* EN_APICK */
2243 SET_ONOFF("armtim_ck", 7) /* EN_TIMCK */
2244 SET_CANIDLE("dma_ck", 8) /* DMACK_REQ */
2245 SET_ONOFF("arm_gpio_ck", 9) /* EN_GPIOCK */
2246 SET_ONOFF("lbfree_ck", 10) /* EN_LBFREECK */
2247 }
2248
2249 static inline void omap_clkm_ckout1_update(struct omap_mpu_state_s *s,
2250 uint16_t diff, uint16_t value)
2251 {
2252 omap_clk clk;
2253
2254 if (diff & (3 << 4)) { /* TCLKOUT */
2255 clk = omap_findclk(s, "tclk_out");
2256 switch ((value >> 4) & 3) {
2257 case 1:
2258 omap_clk_reparent(clk, omap_findclk(s, "ck_gen3"));
2259 omap_clk_onoff(clk, 1);
2260 break;
2261 case 2:
2262 omap_clk_reparent(clk, omap_findclk(s, "tc_ck"));
2263 omap_clk_onoff(clk, 1);
2264 break;
2265 default:
2266 omap_clk_onoff(clk, 0);
2267 }
2268 }
2269 if (diff & (3 << 2)) { /* DCLKOUT */
2270 clk = omap_findclk(s, "dclk_out");
2271 switch ((value >> 2) & 3) {
2272 case 0:
2273 omap_clk_reparent(clk, omap_findclk(s, "dspmmu_ck"));
2274 break;
2275 case 1:
2276 omap_clk_reparent(clk, omap_findclk(s, "ck_gen2"));
2277 break;
2278 case 2:
2279 omap_clk_reparent(clk, omap_findclk(s, "dsp_ck"));
2280 break;
2281 case 3:
2282 omap_clk_reparent(clk, omap_findclk(s, "ck_ref14"));
2283 break;
2284 }
2285 }
2286 if (diff & (3 << 0)) { /* ACLKOUT */
2287 clk = omap_findclk(s, "aclk_out");
2288 switch ((value >> 0) & 3) {
2289 case 1:
2290 omap_clk_reparent(clk, omap_findclk(s, "ck_gen1"));
2291 omap_clk_onoff(clk, 1);
2292 break;
2293 case 2:
2294 omap_clk_reparent(clk, omap_findclk(s, "arm_ck"));
2295 omap_clk_onoff(clk, 1);
2296 break;
2297 case 3:
2298 omap_clk_reparent(clk, omap_findclk(s, "ck_ref14"));
2299 omap_clk_onoff(clk, 1);
2300 break;
2301 default:
2302 omap_clk_onoff(clk, 0);
2303 }
2304 }
2305 }
2306
2307 static void omap_clkm_write(void *opaque, target_phys_addr_t addr,
2308 uint32_t value)
2309 {
2310 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
2311 uint16_t diff;
2312 omap_clk clk;
2313 static const char *clkschemename[8] = {
2314 "fully synchronous", "fully asynchronous", "synchronous scalable",
2315 "mix mode 1", "mix mode 2", "bypass mode", "mix mode 3", "mix mode 4",
2316 };
2317
2318 switch (addr) {
2319 case 0x00: /* ARM_CKCTL */
2320 diff = s->clkm.arm_ckctl ^ value;
2321 s->clkm.arm_ckctl = value & 0x7fff;
2322 omap_clkm_ckctl_update(s, diff, value);
2323 return;
2324
2325 case 0x04: /* ARM_IDLECT1 */
2326 diff = s->clkm.arm_idlect1 ^ value;
2327 s->clkm.arm_idlect1 = value & 0x0fff;
2328 omap_clkm_idlect1_update(s, diff, value);
2329 return;
2330
2331 case 0x08: /* ARM_IDLECT2 */
2332 diff = s->clkm.arm_idlect2 ^ value;
2333 s->clkm.arm_idlect2 = value & 0x07ff;
2334 omap_clkm_idlect2_update(s, diff, value);
2335 return;
2336
2337 case 0x0c: /* ARM_EWUPCT */
2338 diff = s->clkm.arm_ewupct ^ value;
2339 s->clkm.arm_ewupct = value & 0x003f;
2340 return;
2341
2342 case 0x10: /* ARM_RSTCT1 */
2343 diff = s->clkm.arm_rstct1 ^ value;
2344 s->clkm.arm_rstct1 = value & 0x0007;
2345 if (value & 9) {
2346 qemu_system_reset_request();
2347 s->clkm.cold_start = 0xa;
2348 }
2349 if (diff & ~value & 4) { /* DSP_RST */
2350 omap_mpui_reset(s);
2351 omap_tipb_bridge_reset(s->private_tipb);
2352 omap_tipb_bridge_reset(s->public_tipb);
2353 }
2354 if (diff & 2) { /* DSP_EN */
2355 clk = omap_findclk(s, "dsp_ck");
2356 omap_clk_canidle(clk, (~value >> 1) & 1);
2357 }
2358 return;
2359
2360 case 0x14: /* ARM_RSTCT2 */
2361 s->clkm.arm_rstct2 = value & 0x0001;
2362 return;
2363
2364 case 0x18: /* ARM_SYSST */
2365 if ((s->clkm.clocking_scheme ^ (value >> 11)) & 7) {
2366 s->clkm.clocking_scheme = (value >> 11) & 7;
2367 printf("%s: clocking scheme set to %s\n", __FUNCTION__,
2368 clkschemename[s->clkm.clocking_scheme]);
2369 }
2370 s->clkm.cold_start &= value & 0x3f;
2371 return;
2372
2373 case 0x1c: /* ARM_CKOUT1 */
2374 diff = s->clkm.arm_ckout1 ^ value;
2375 s->clkm.arm_ckout1 = value & 0x003f;
2376 omap_clkm_ckout1_update(s, diff, value);
2377 return;
2378
2379 case 0x20: /* ARM_CKOUT2 */
2380 default:
2381 OMAP_BAD_REG(addr);
2382 }
2383 }
2384
2385 static CPUReadMemoryFunc *omap_clkm_readfn[] = {
2386 omap_badwidth_read16,
2387 omap_clkm_read,
2388 omap_badwidth_read16,
2389 };
2390
2391 static CPUWriteMemoryFunc *omap_clkm_writefn[] = {
2392 omap_badwidth_write16,
2393 omap_clkm_write,
2394 omap_badwidth_write16,
2395 };
2396
2397 static uint32_t omap_clkdsp_read(void *opaque, target_phys_addr_t addr)
2398 {
2399 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
2400
2401 switch (addr) {
2402 case 0x04: /* DSP_IDLECT1 */
2403 return s->clkm.dsp_idlect1;
2404
2405 case 0x08: /* DSP_IDLECT2 */
2406 return s->clkm.dsp_idlect2;
2407
2408 case 0x14: /* DSP_RSTCT2 */
2409 return s->clkm.dsp_rstct2;
2410
2411 case 0x18: /* DSP_SYSST */
2412 return (s->clkm.clocking_scheme << 11) | s->clkm.cold_start |
2413 (s->env->halted << 6); /* Quite useless... */
2414 }
2415
2416 OMAP_BAD_REG(addr);
2417 return 0;
2418 }
2419
2420 static inline void omap_clkdsp_idlect1_update(struct omap_mpu_state_s *s,
2421 uint16_t diff, uint16_t value)
2422 {
2423 omap_clk clk;
2424
2425 SET_CANIDLE("dspxor_ck", 1); /* IDLXORP_DSP */
2426 }
2427
2428 static inline void omap_clkdsp_idlect2_update(struct omap_mpu_state_s *s,
2429 uint16_t diff, uint16_t value)
2430 {
2431 omap_clk clk;
2432
2433 SET_ONOFF("dspxor_ck", 1); /* EN_XORPCK */
2434 }
2435
2436 static void omap_clkdsp_write(void *opaque, target_phys_addr_t addr,
2437 uint32_t value)
2438 {
2439 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
2440 uint16_t diff;
2441
2442 switch (addr) {
2443 case 0x04: /* DSP_IDLECT1 */
2444 diff = s->clkm.dsp_idlect1 ^ value;
2445 s->clkm.dsp_idlect1 = value & 0x01f7;
2446 omap_clkdsp_idlect1_update(s, diff, value);
2447 break;
2448
2449 case 0x08: /* DSP_IDLECT2 */
2450 s->clkm.dsp_idlect2 = value & 0x0037;
2451 diff = s->clkm.dsp_idlect1 ^ value;
2452 omap_clkdsp_idlect2_update(s, diff, value);
2453 break;
2454
2455 case 0x14: /* DSP_RSTCT2 */
2456 s->clkm.dsp_rstct2 = value & 0x0001;
2457 break;
2458
2459 case 0x18: /* DSP_SYSST */
2460 s->clkm.cold_start &= value & 0x3f;
2461 break;
2462
2463 default:
2464 OMAP_BAD_REG(addr);
2465 }
2466 }
2467
2468 static CPUReadMemoryFunc *omap_clkdsp_readfn[] = {
2469 omap_badwidth_read16,
2470 omap_clkdsp_read,
2471 omap_badwidth_read16,
2472 };
2473
2474 static CPUWriteMemoryFunc *omap_clkdsp_writefn[] = {
2475 omap_badwidth_write16,
2476 omap_clkdsp_write,
2477 omap_badwidth_write16,
2478 };
2479
2480 static void omap_clkm_reset(struct omap_mpu_state_s *s)
2481 {
2482 if (s->wdt && s->wdt->reset)
2483 s->clkm.cold_start = 0x6;
2484 s->clkm.clocking_scheme = 0;
2485 omap_clkm_ckctl_update(s, ~0, 0x3000);
2486 s->clkm.arm_ckctl = 0x3000;
2487 omap_clkm_idlect1_update(s, s->clkm.arm_idlect1 ^ 0x0400, 0x0400);
2488 s->clkm.arm_idlect1 = 0x0400;
2489 omap_clkm_idlect2_update(s, s->clkm.arm_idlect2 ^ 0x0100, 0x0100);
2490 s->clkm.arm_idlect2 = 0x0100;
2491 s->clkm.arm_ewupct = 0x003f;
2492 s->clkm.arm_rstct1 = 0x0000;
2493 s->clkm.arm_rstct2 = 0x0000;
2494 s->clkm.arm_ckout1 = 0x0015;
2495 s->clkm.dpll1_mode = 0x2002;
2496 omap_clkdsp_idlect1_update(s, s->clkm.dsp_idlect1 ^ 0x0040, 0x0040);
2497 s->clkm.dsp_idlect1 = 0x0040;
2498 omap_clkdsp_idlect2_update(s, ~0, 0x0000);
2499 s->clkm.dsp_idlect2 = 0x0000;
2500 s->clkm.dsp_rstct2 = 0x0000;
2501 }
2502
2503 static void omap_clkm_init(target_phys_addr_t mpu_base,
2504 target_phys_addr_t dsp_base, struct omap_mpu_state_s *s)
2505 {
2506 int iomemtype[2] = {
2507 cpu_register_io_memory(0, omap_clkm_readfn, omap_clkm_writefn, s),
2508 cpu_register_io_memory(0, omap_clkdsp_readfn, omap_clkdsp_writefn, s),
2509 };
2510
2511 s->clkm.arm_idlect1 = 0x03ff;
2512 s->clkm.arm_idlect2 = 0x0100;
2513 s->clkm.dsp_idlect1 = 0x0002;
2514 omap_clkm_reset(s);
2515 s->clkm.cold_start = 0x3a;
2516
2517 cpu_register_physical_memory(mpu_base, 0x100, iomemtype[0]);
2518 cpu_register_physical_memory(dsp_base, 0x1000, iomemtype[1]);
2519 }
2520
2521 /* MPU I/O */
2522 struct omap_mpuio_s {
2523 qemu_irq irq;
2524 qemu_irq kbd_irq;
2525 qemu_irq *in;
2526 qemu_irq handler[16];
2527 qemu_irq wakeup;
2528
2529 uint16_t inputs;
2530 uint16_t outputs;
2531 uint16_t dir;
2532 uint16_t edge;
2533 uint16_t mask;
2534 uint16_t ints;
2535
2536 uint16_t debounce;
2537 uint16_t latch;
2538 uint8_t event;
2539
2540 uint8_t buttons[5];
2541 uint8_t row_latch;
2542 uint8_t cols;
2543 int kbd_mask;
2544 int clk;
2545 };
2546
2547 static void omap_mpuio_set(void *opaque, int line, int level)
2548 {
2549 struct omap_mpuio_s *s = (struct omap_mpuio_s *) opaque;
2550 uint16_t prev = s->inputs;
2551
2552 if (level)
2553 s->inputs |= 1 << line;
2554 else
2555 s->inputs &= ~(1 << line);
2556
2557 if (((1 << line) & s->dir & ~s->mask) && s->clk) {
2558 if ((s->edge & s->inputs & ~prev) | (~s->edge & ~s->inputs & prev)) {
2559 s->ints |= 1 << line;
2560 qemu_irq_raise(s->irq);
2561 /* TODO: wakeup */
2562 }
2563 if ((s->event & (1 << 0)) && /* SET_GPIO_EVENT_MODE */
2564 (s->event >> 1) == line) /* PIN_SELECT */
2565 s->latch = s->inputs;
2566 }
2567 }
2568
2569 static void omap_mpuio_kbd_update(struct omap_mpuio_s *s)
2570 {
2571 int i;
2572 uint8_t *row, rows = 0, cols = ~s->cols;
2573
2574 for (row = s->buttons + 4, i = 1 << 4; i; row --, i >>= 1)
2575 if (*row & cols)
2576 rows |= i;
2577
2578 qemu_set_irq(s->kbd_irq, rows && !s->kbd_mask && s->clk);
2579 s->row_latch = ~rows;
2580 }
2581
2582 static uint32_t omap_mpuio_read(void *opaque, target_phys_addr_t addr)
2583 {
2584 struct omap_mpuio_s *s = (struct omap_mpuio_s *) opaque;
2585 int offset = addr & OMAP_MPUI_REG_MASK;
2586 uint16_t ret;
2587
2588 switch (offset) {
2589 case 0x00: /* INPUT_LATCH */
2590 return s->inputs;
2591
2592 case 0x04: /* OUTPUT_REG */
2593 return s->outputs;
2594
2595 case 0x08: /* IO_CNTL */
2596 return s->dir;
2597
2598 case 0x10: /* KBR_LATCH */
2599 return s->row_latch;
2600
2601 case 0x14: /* KBC_REG */
2602 return s->cols;
2603
2604 case 0x18: /* GPIO_EVENT_MODE_REG */
2605 return s->event;
2606
2607 case 0x1c: /* GPIO_INT_EDGE_REG */
2608 return s->edge;
2609
2610 case 0x20: /* KBD_INT */
2611 return (~s->row_latch & 0x1f) && !s->kbd_mask;
2612
2613 case 0x24: /* GPIO_INT */
2614 ret = s->ints;
2615 s->ints &= s->mask;
2616 if (ret)
2617 qemu_irq_lower(s->irq);
2618 return ret;
2619
2620 case 0x28: /* KBD_MASKIT */
2621 return s->kbd_mask;
2622
2623 case 0x2c: /* GPIO_MASKIT */
2624 return s->mask;
2625
2626 case 0x30: /* GPIO_DEBOUNCING_REG */
2627 return s->debounce;
2628
2629 case 0x34: /* GPIO_LATCH_REG */
2630 return s->latch;
2631 }
2632
2633 OMAP_BAD_REG(addr);
2634 return 0;
2635 }
2636
2637 static void omap_mpuio_write(void *opaque, target_phys_addr_t addr,
2638 uint32_t value)
2639 {
2640 struct omap_mpuio_s *s = (struct omap_mpuio_s *) opaque;
2641 int offset = addr & OMAP_MPUI_REG_MASK;
2642 uint16_t diff;
2643 int ln;
2644
2645 switch (offset) {
2646 case 0x04: /* OUTPUT_REG */
2647 diff = (s->outputs ^ value) & ~s->dir;
2648 s->outputs = value;
2649 while ((ln = ffs(diff))) {
2650 ln --;
2651 if (s->handler[ln])
2652 qemu_set_irq(s->handler[ln], (value >> ln) & 1);
2653 diff &= ~(1 << ln);
2654 }
2655 break;
2656
2657 case 0x08: /* IO_CNTL */
2658 diff = s->outputs & (s->dir ^ value);
2659 s->dir = value;
2660
2661 value = s->outputs & ~s->dir;
2662 while ((ln = ffs(diff))) {
2663 ln --;
2664 if (s->handler[ln])
2665 qemu_set_irq(s->handler[ln], (value >> ln) & 1);
2666 diff &= ~(1 << ln);
2667 }
2668 break;
2669
2670 case 0x14: /* KBC_REG */
2671 s->cols = value;
2672 omap_mpuio_kbd_update(s);
2673 break;
2674
2675 case 0x18: /* GPIO_EVENT_MODE_REG */
2676 s->event = value & 0x1f;
2677 break;
2678
2679 case 0x1c: /* GPIO_INT_EDGE_REG */
2680 s->edge = value;
2681 break;
2682
2683 case 0x28: /* KBD_MASKIT */
2684 s->kbd_mask = value & 1;
2685 omap_mpuio_kbd_update(s);
2686 break;
2687
2688 case 0x2c: /* GPIO_MASKIT */
2689 s->mask = value;
2690 break;
2691
2692 case 0x30: /* GPIO_DEBOUNCING_REG */
2693 s->debounce = value & 0x1ff;
2694 break;
2695
2696 case 0x00: /* INPUT_LATCH */
2697 case 0x10: /* KBR_LATCH */
2698 case 0x20: /* KBD_INT */
2699 case 0x24: /* GPIO_INT */
2700 case 0x34: /* GPIO_LATCH_REG */
2701 OMAP_RO_REG(addr);
2702 return;
2703
2704 default:
2705 OMAP_BAD_REG(addr);
2706 return;
2707 }
2708 }
2709
2710 static CPUReadMemoryFunc *omap_mpuio_readfn[] = {
2711 omap_badwidth_read16,
2712 omap_mpuio_read,
2713 omap_badwidth_read16,
2714 };
2715
2716 static CPUWriteMemoryFunc *omap_mpuio_writefn[] = {
2717 omap_badwidth_write16,
2718 omap_mpuio_write,
2719 omap_badwidth_write16,
2720 };
2721
2722 static void omap_mpuio_reset(struct omap_mpuio_s *s)
2723 {
2724 s->inputs = 0;
2725 s->outputs = 0;
2726 s->dir = ~0;
2727 s->event = 0;
2728 s->edge = 0;
2729 s->kbd_mask = 0;
2730 s->mask = 0;
2731 s->debounce = 0;
2732 s->latch = 0;
2733 s->ints = 0;
2734 s->row_latch = 0x1f;
2735 s->clk = 1;
2736 }
2737
2738 static void omap_mpuio_onoff(void *opaque, int line, int on)
2739 {
2740 struct omap_mpuio_s *s = (struct omap_mpuio_s *) opaque;
2741
2742 s->clk = on;
2743 if (on)
2744 omap_mpuio_kbd_update(s);
2745 }
2746
2747 struct omap_mpuio_s *omap_mpuio_init(target_phys_addr_t base,
2748 qemu_irq kbd_int, qemu_irq gpio_int, qemu_irq wakeup,
2749 omap_clk clk)
2750 {
2751 int iomemtype;
2752 struct omap_mpuio_s *s = (struct omap_mpuio_s *)
2753 qemu_mallocz(sizeof(struct omap_mpuio_s));
2754
2755 s->irq = gpio_int;
2756 s->kbd_irq = kbd_int;
2757 s->wakeup = wakeup;
2758 s->in = qemu_allocate_irqs(omap_mpuio_set, s, 16);
2759 omap_mpuio_reset(s);
2760
2761 iomemtype = cpu_register_io_memory(0, omap_mpuio_readfn,
2762 omap_mpuio_writefn, s);
2763 cpu_register_physical_memory(base, 0x800, iomemtype);
2764
2765 omap_clk_adduser(clk, qemu_allocate_irqs(omap_mpuio_onoff, s, 1)[0]);
2766
2767 return s;
2768 }
2769
2770 qemu_irq *omap_mpuio_in_get(struct omap_mpuio_s *s)
2771 {
2772 return s->in;
2773 }
2774
2775 void omap_mpuio_out_set(struct omap_mpuio_s *s, int line, qemu_irq handler)
2776 {
2777 if (line >= 16 || line < 0)
2778 cpu_abort(cpu_single_env, "%s: No GPIO line %i\n", __FUNCTION__, line);
2779 s->handler[line] = handler;
2780 }
2781
2782 void omap_mpuio_key(struct omap_mpuio_s *s, int row, int col, int down)
2783 {
2784 if (row >= 5 || row < 0)
2785 cpu_abort(cpu_single_env, "%s: No key %i-%i\n",
2786 __FUNCTION__, col, row);
2787
2788 if (down)
2789 s->buttons[row] |= 1 << col;
2790 else
2791 s->buttons[row] &= ~(1 << col);
2792
2793 omap_mpuio_kbd_update(s);
2794 }
2795
2796 /* General-Purpose I/O */
2797 struct omap_gpio_s {
2798 qemu_irq irq;
2799 qemu_irq *in;
2800 qemu_irq handler[16];
2801
2802 uint16_t inputs;
2803 uint16_t outputs;
2804 uint16_t dir;
2805 uint16_t edge;
2806 uint16_t mask;
2807 uint16_t ints;
2808 uint16_t pins;
2809 };
2810
2811 static void omap_gpio_set(void *opaque, int line, int level)
2812 {
2813 struct omap_gpio_s *s = (struct omap_gpio_s *) opaque;
2814 uint16_t prev = s->inputs;
2815
2816 if (level)
2817 s->inputs |= 1 << line;
2818 else
2819 s->inputs &= ~(1 << line);
2820
2821 if (((s->edge & s->inputs & ~prev) | (~s->edge & ~s->inputs & prev)) &
2822 (1 << line) & s->dir & ~s->mask) {
2823 s->ints |= 1 << line;
2824 qemu_irq_raise(s->irq);
2825 }
2826 }
2827
2828 static uint32_t omap_gpio_read(void *opaque, target_phys_addr_t addr)
2829 {
2830 struct omap_gpio_s *s = (struct omap_gpio_s *) opaque;
2831 int offset = addr & OMAP_MPUI_REG_MASK;
2832
2833 switch (offset) {
2834 case 0x00: /* DATA_INPUT */
2835 return s->inputs & s->pins;
2836
2837 case 0x04: /* DATA_OUTPUT */
2838 return s->outputs;
2839
2840 case 0x08: /* DIRECTION_CONTROL */
2841 return s->dir;
2842
2843 case 0x0c: /* INTERRUPT_CONTROL */
2844 return s->edge;
2845
2846 case 0x10: /* INTERRUPT_MASK */
2847 return s->mask;
2848
2849 case 0x14: /* INTERRUPT_STATUS */
2850 return s->ints;
2851
2852 case 0x18: /* PIN_CONTROL (not in OMAP310) */
2853 OMAP_BAD_REG(addr);
2854 return s->pins;
2855 }
2856
2857 OMAP_BAD_REG(addr);
2858 return 0;
2859 }
2860
2861 static void omap_gpio_write(void *opaque, target_phys_addr_t addr,
2862 uint32_t value)
2863 {
2864 struct omap_gpio_s *s = (struct omap_gpio_s *) opaque;
2865 int offset = addr & OMAP_MPUI_REG_MASK;
2866 uint16_t diff;
2867 int ln;
2868
2869 switch (offset) {
2870 case 0x00: /* DATA_INPUT */
2871 OMAP_RO_REG(addr);
2872 return;
2873
2874 case 0x04: /* DATA_OUTPUT */
2875 diff = (s->outputs ^ value) & ~s->dir;
2876 s->outputs = value;
2877 while ((ln = ffs(diff))) {
2878 ln --;
2879 if (s->handler[ln])
2880 qemu_set_irq(s->handler[ln], (value >> ln) & 1);
2881 diff &= ~(1 << ln);
2882 }
2883 break;
2884
2885 case 0x08: /* DIRECTION_CONTROL */
2886 diff = s->outputs & (s->dir ^ value);
2887 s->dir = value;
2888
2889 value = s->outputs & ~s->dir;
2890 while ((ln = ffs(diff))) {
2891 ln --;
2892 if (s->handler[ln])
2893 qemu_set_irq(s->handler[ln], (value >> ln) & 1);
2894 diff &= ~(1 << ln);
2895 }
2896 break;
2897
2898 case 0x0c: /* INTERRUPT_CONTROL */
2899 s->edge = value;
2900 break;
2901
2902 case 0x10: /* INTERRUPT_MASK */
2903 s->mask = value;
2904 break;
2905
2906 case 0x14: /* INTERRUPT_STATUS */
2907 s->ints &= ~value;
2908 if (!s->ints)
2909 qemu_irq_lower(s->irq);
2910 break;
2911
2912 case 0x18: /* PIN_CONTROL (not in OMAP310 TRM) */
2913 OMAP_BAD_REG(addr);
2914 s->pins = value;
2915 break;
2916
2917 default:
2918 OMAP_BAD_REG(addr);
2919 return;
2920 }
2921 }
2922
2923 /* *Some* sources say the memory region is 32-bit. */
2924 static CPUReadMemoryFunc *omap_gpio_readfn[] = {
2925 omap_badwidth_read16,
2926 omap_gpio_read,
2927 omap_badwidth_read16,
2928 };
2929
2930 static CPUWriteMemoryFunc *omap_gpio_writefn[] = {
2931 omap_badwidth_write16,
2932 omap_gpio_write,
2933 omap_badwidth_write16,
2934 };
2935
2936 static void omap_gpio_reset(struct omap_gpio_s *s)
2937 {
2938 s->inputs = 0;
2939 s->outputs = ~0;
2940 s->dir = ~0;
2941 s->edge = ~0;
2942 s->mask = ~0;
2943 s->ints = 0;
2944 s->pins = ~0;
2945 }
2946
2947 struct omap_gpio_s *omap_gpio_init(target_phys_addr_t base,
2948 qemu_irq irq, omap_clk clk)
2949 {
2950 int iomemtype;
2951 struct omap_gpio_s *s = (struct omap_gpio_s *)
2952 qemu_mallocz(sizeof(struct omap_gpio_s));
2953
2954 s->irq = irq;
2955 s->in = qemu_allocate_irqs(omap_gpio_set, s, 16);
2956 omap_gpio_reset(s);
2957
2958 iomemtype = cpu_register_io_memory(0, omap_gpio_readfn,
2959 omap_gpio_writefn, s);
2960 cpu_register_physical_memory(base, 0x1000, iomemtype);
2961
2962 return s;
2963 }
2964
2965 qemu_irq *omap_gpio_in_get(struct omap_gpio_s *s)
2966 {
2967 return s->in;
2968 }
2969
2970 void omap_gpio_out_set(struct omap_gpio_s *s, int line, qemu_irq handler)
2971 {
2972 if (line >= 16 || line < 0)
2973 cpu_abort(cpu_single_env, "%s: No GPIO line %i\n", __FUNCTION__, line);
2974 s->handler[line] = handler;
2975 }
2976
2977 /* MicroWire Interface */
2978 struct omap_uwire_s {
2979 qemu_irq txirq;
2980 qemu_irq rxirq;
2981 qemu_irq txdrq;
2982
2983 uint16_t txbuf;
2984 uint16_t rxbuf;
2985 uint16_t control;
2986 uint16_t setup[5];
2987
2988 struct uwire_slave_s *chip[4];
2989 };
2990
2991 static void omap_uwire_transfer_start(struct omap_uwire_s *s)
2992 {
2993 int chipselect = (s->control >> 10) & 3; /* INDEX */
2994 struct uwire_slave_s *slave = s->chip[chipselect];
2995
2996 if ((s->control >> 5) & 0x1f) { /* NB_BITS_WR */
2997 if (s->control & (1 << 12)) /* CS_CMD */
2998 if (slave && slave->send)
2999 slave->send(slave->opaque,
3000 s->txbuf >> (16 - ((s->control >> 5) & 0x1f)));
3001 s->control &= ~(1 << 14); /* CSRB */
3002 /* TODO: depending on s->setup[4] bits [1:0] assert an IRQ or
3003 * a DRQ. When is the level IRQ supposed to be reset? */
3004 }
3005
3006 if ((s->control >> 0) & 0x1f) { /* NB_BITS_RD */
3007 if (s->control & (1 << 12)) /* CS_CMD */
3008 if (slave && slave->receive)
3009 s->rxbuf = slave->receive(slave->opaque);
3010 s->control |= 1 << 15; /* RDRB */
3011 /* TODO: depending on s->setup[4] bits [1:0] assert an IRQ or
3012 * a DRQ. When is the level IRQ supposed to be reset? */
3013 }
3014 }
3015
3016 static uint32_t omap_uwire_read(void *opaque, target_phys_addr_t addr)
3017 {
3018 struct omap_uwire_s *s = (struct omap_uwire_s *) opaque;
3019 int offset = addr & OMAP_MPUI_REG_MASK;
3020
3021 switch (offset) {
3022 case 0x00: /* RDR */
3023 s->control &= ~(1 << 15); /* RDRB */
3024 return s->rxbuf;
3025
3026 case 0x04: /* CSR */
3027 return s->control;
3028
3029 case 0x08: /* SR1 */
3030 return s->setup[0];
3031 case 0x0c: /* SR2 */
3032 return s->setup[1];
3033 case 0x10: /* SR3 */
3034 return s->setup[2];
3035 case 0x14: /* SR4 */
3036 return s->setup[3];
3037 case 0x18: /* SR5 */
3038 return s->setup[4];
3039 }
3040
3041 OMAP_BAD_REG(addr);
3042 return 0;
3043 }
3044
3045 static void omap_uwire_write(void *opaque, target_phys_addr_t addr,
3046 uint32_t value)
3047 {
3048 struct omap_uwire_s *s = (struct omap_uwire_s *) opaque;
3049 int offset = addr & OMAP_MPUI_REG_MASK;
3050
3051 switch (offset) {
3052 case 0x00: /* TDR */
3053 s->txbuf = value; /* TD */
3054 if ((s->setup[4] & (1 << 2)) && /* AUTO_TX_EN */
3055 ((s->setup[4] & (1 << 3)) || /* CS_TOGGLE_TX_EN */
3056 (s->control & (1 << 12)))) { /* CS_CMD */
3057 s->control |= 1 << 14; /* CSRB */
3058 omap_uwire_transfer_start(s);
3059 }
3060 break;
3061
3062 case 0x04: /* CSR */
3063 s->control = value & 0x1fff;
3064 if (value & (1 << 13)) /* START */
3065 omap_uwire_transfer_start(s);
3066 break;
3067
3068 case 0x08: /* SR1 */
3069 s->setup[0] = value & 0x003f;
3070 break;
3071
3072 case 0x0c: /* SR2 */
3073 s->setup[1] = value & 0x0fc0;
3074 break;
3075
3076 case 0x10: /* SR3 */
3077 s->setup[2] = value & 0x0003;
3078 break;
3079
3080 case 0x14: /* SR4 */
3081 s->setup[3] = value & 0x0001;
3082 break;
3083
3084 case 0x18: /* SR5 */
3085 s->setup[4] = value & 0x000f;
3086 break;
3087
3088 default:
3089 OMAP_BAD_REG(addr);
3090 return;
3091 }
3092 }
3093
3094 static CPUReadMemoryFunc *omap_uwire_readfn[] = {
3095 omap_badwidth_read16,
3096 omap_uwire_read,
3097 omap_badwidth_read16,
3098 };
3099
3100 static CPUWriteMemoryFunc *omap_uwire_writefn[] = {
3101 omap_badwidth_write16,
3102 omap_uwire_write,
3103 omap_badwidth_write16,
3104 };
3105
3106 static void omap_uwire_reset(struct omap_uwire_s *s)
3107 {
3108 s->control = 0;
3109 s->setup[0] = 0;
3110 s->setup[1] = 0;
3111 s->setup[2] = 0;
3112 s->setup[3] = 0;
3113 s->setup[4] = 0;
3114 }
3115
3116 struct omap_uwire_s *omap_uwire_init(target_phys_addr_t base,
3117 qemu_irq *irq, qemu_irq dma, omap_clk clk)
3118 {
3119 int iomemtype;
3120 struct omap_uwire_s *s = (struct omap_uwire_s *)
3121 qemu_mallocz(sizeof(struct omap_uwire_s));
3122
3123 s->txirq = irq[0];
3124 s->rxirq = irq[1];
3125 s->txdrq = dma;
3126 omap_uwire_reset(s);
3127
3128 iomemtype = cpu_register_io_memory(0, omap_uwire_readfn,
3129 omap_uwire_writefn, s);
3130 cpu_register_physical_memory(base, 0x800, iomemtype);
3131
3132 return s;
3133 }
3134
3135 void omap_uwire_attach(struct omap_uwire_s *s,
3136 struct uwire_slave_s *slave, int chipselect)
3137 {
3138 if (chipselect < 0 || chipselect > 3) {
3139 fprintf(stderr, "%s: Bad chipselect %i\n", __FUNCTION__, chipselect);
3140 exit(-1);
3141 }
3142
3143 s->chip[chipselect] = slave;
3144 }
3145
3146 /* Pseudonoise Pulse-Width Light Modulator */
3147 static void omap_pwl_update(struct omap_mpu_state_s *s)
3148 {
3149 int output = (s->pwl.clk && s->pwl.enable) ? s->pwl.level : 0;
3150
3151 if (output != s->pwl.output) {
3152 s->pwl.output = output;
3153 printf("%s: Backlight now at %i/256\n", __FUNCTION__, output);
3154 }
3155 }
3156
3157 static uint32_t omap_pwl_read(void *opaque, target_phys_addr_t addr)
3158 {
3159 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
3160 int offset = addr & OMAP_MPUI_REG_MASK;
3161
3162 switch (offset) {
3163 case 0x00: /* PWL_LEVEL */
3164 return s->pwl.level;
3165 case 0x04: /* PWL_CTRL */
3166 return s->pwl.enable;
3167 }
3168 OMAP_BAD_REG(addr);
3169 return 0;
3170 }
3171
3172 static void omap_pwl_write(void *opaque, target_phys_addr_t addr,
3173 uint32_t value)
3174 {
3175 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
3176 int offset = addr & OMAP_MPUI_REG_MASK;
3177
3178 switch (offset) {
3179 case 0x00: /* PWL_LEVEL */
3180 s->pwl.level = value;
3181 omap_pwl_update(s);
3182 break;
3183 case 0x04: /* PWL_CTRL */
3184 s->pwl.enable = value & 1;
3185 omap_pwl_update(s);
3186 break;
3187 default:
3188 OMAP_BAD_REG(addr);
3189 return;
3190 }
3191 }
3192
3193 static CPUReadMemoryFunc *omap_pwl_readfn[] = {
3194 omap_pwl_read,
3195 omap_badwidth_read8,
3196 omap_badwidth_read8,
3197 };
3198
3199 static CPUWriteMemoryFunc *omap_pwl_writefn[] = {
3200 omap_pwl_write,
3201 omap_badwidth_write8,
3202 omap_badwidth_write8,
3203 };
3204
3205 static void omap_pwl_reset(struct omap_mpu_state_s *s)
3206 {
3207 s->pwl.output = 0;
3208 s->pwl.level = 0;
3209 s->pwl.enable = 0;
3210 s->pwl.clk = 1;
3211 omap_pwl_update(s);
3212 }
3213
3214 static void omap_pwl_clk_update(void *opaque, int line, int on)
3215 {
3216 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
3217
3218 s->pwl.clk = on;
3219 omap_pwl_update(s);
3220 }
3221
3222 static void omap_pwl_init(target_phys_addr_t base, struct omap_mpu_state_s *s,
3223 omap_clk clk)
3224 {
3225 int iomemtype;
3226
3227 omap_pwl_reset(s);
3228
3229 iomemtype = cpu_register_io_memory(0, omap_pwl_readfn,
3230 omap_pwl_writefn, s);
3231 cpu_register_physical_memory(base, 0x800, iomemtype);
3232
3233 omap_clk_adduser(clk, qemu_allocate_irqs(omap_pwl_clk_update, s, 1)[0]);
3234 }
3235
3236 /* Pulse-Width Tone module */
3237 static uint32_t omap_pwt_read(void *opaque, target_phys_addr_t addr)
3238 {
3239 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
3240 int offset = addr & OMAP_MPUI_REG_MASK;
3241
3242 switch (offset) {
3243 case 0x00: /* FRC */
3244 return s->pwt.frc;
3245 case 0x04: /* VCR */
3246 return s->pwt.vrc;
3247 case 0x08: /* GCR */
3248 return s->pwt.gcr;
3249 }
3250 OMAP_BAD_REG(addr);
3251 return 0;
3252 }
3253
3254 static void omap_pwt_write(void *opaque, target_phys_addr_t addr,
3255 uint32_t value)
3256 {
3257 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
3258 int offset = addr & OMAP_MPUI_REG_MASK;
3259
3260 switch (offset) {
3261 case 0x00: /* FRC */
3262 s->pwt.frc = value & 0x3f;
3263 break;
3264 case 0x04: /* VRC */
3265 if ((value ^ s->pwt.vrc) & 1) {
3266 if (value & 1)
3267 printf("%s: %iHz buzz on\n", __FUNCTION__, (int)
3268 /* 1.5 MHz from a 12-MHz or 13-MHz PWT_CLK */
3269 ((omap_clk_getrate(s->pwt.clk) >> 3) /
3270 /* Pre-multiplexer divider */
3271 ((s->pwt.gcr & 2) ? 1 : 154) /
3272 /* Octave multiplexer */
3273 (2 << (value & 3)) *
3274 /* 101/107 divider */
3275 ((value & (1 << 2)) ? 101 : 107) *
3276 /* 49/55 divider */
3277 ((value & (1 << 3)) ? 49 : 55) *
3278 /* 50/63 divider */
3279 ((value & (1 << 4)) ? 50 : 63) *
3280 /* 80/127 divider */
3281 ((value & (1 << 5)) ? 80 : 127) /
3282 (107 * 55 * 63 * 127)));
3283 else
3284 printf("%s: silence!\n", __FUNCTION__);
3285 }
3286 s->pwt.vrc = value & 0x7f;
3287 break;
3288 case 0x08: /* GCR */
3289 s->pwt.gcr = value & 3;
3290 break;
3291 default:
3292 OMAP_BAD_REG(addr);
3293 return;
3294 }
3295 }
3296
3297 static CPUReadMemoryFunc *omap_pwt_readfn[] = {
3298 omap_pwt_read,
3299 omap_badwidth_read8,
3300 omap_badwidth_read8,
3301 };
3302
3303 static CPUWriteMemoryFunc *omap_pwt_writefn[] = {
3304 omap_pwt_write,
3305 omap_badwidth_write8,
3306 omap_badwidth_write8,
3307 };
3308
3309 static void omap_pwt_reset(struct omap_mpu_state_s *s)
3310 {
3311 s->pwt.frc = 0;
3312 s->pwt.vrc = 0;
3313 s->pwt.gcr = 0;
3314 }
3315
3316 static void omap_pwt_init(target_phys_addr_t base, struct omap_mpu_state_s *s,
3317 omap_clk clk)
3318 {
3319 int iomemtype;
3320
3321 s->pwt.clk = clk;
3322 omap_pwt_reset(s);
3323
3324 iomemtype = cpu_register_io_memory(0, omap_pwt_readfn,
3325 omap_pwt_writefn, s);
3326 cpu_register_physical_memory(base, 0x800, iomemtype);
3327 }
3328
3329 /* Real-time Clock module */
3330 struct omap_rtc_s {
3331 qemu_irq irq;
3332 qemu_irq alarm;
3333 QEMUTimer *clk;
3334
3335 uint8_t interrupts;
3336 uint8_t status;
3337 int16_t comp_reg;
3338 int running;
3339 int pm_am;
3340 int auto_comp;
3341 int round;
3342 struct tm alarm_tm;
3343 time_t alarm_ti;
3344
3345 struct tm current_tm;
3346 time_t ti;
3347 uint64_t tick;
3348 };
3349
3350 static void omap_rtc_interrupts_update(struct omap_rtc_s *s)
3351 {
3352 /* s->alarm is level-triggered */
3353 qemu_set_irq(s->alarm, (s->status >> 6) & 1);
3354 }
3355
3356 static void omap_rtc_alarm_update(struct omap_rtc_s *s)
3357 {
3358 s->alarm_ti = mktimegm(&s->alarm_tm);
3359 if (s->alarm_ti == -1)
3360 printf("%s: conversion failed\n", __FUNCTION__);
3361 }
3362
3363 static inline uint8_t omap_rtc_bcd(int num)
3364 {
3365 return ((num / 10) << 4) | (num % 10);
3366 }
3367
3368 static inline int omap_rtc_bin(uint8_t num)
3369 {
3370 return (num & 15) + 10 * (num >> 4);
3371 }
3372
3373 static uint32_t omap_rtc_read(void *opaque, target_phys_addr_t addr)
3374 {
3375 struct omap_rtc_s *s = (struct omap_rtc_s *) opaque;
3376 int offset = addr & OMAP_MPUI_REG_MASK;
3377 uint8_t i;
3378
3379 switch (offset) {
3380 case 0x00: /* SECONDS_REG */
3381 return omap_rtc_bcd(s->current_tm.tm_sec);
3382
3383 case 0x04: /* MINUTES_REG */
3384 return omap_rtc_bcd(s->current_tm.tm_min);
3385
3386 case 0x08: /* HOURS_REG */
3387 if (s->pm_am)
3388 return ((s->current_tm.tm_hour > 11) << 7) |
3389 omap_rtc_bcd(((s->current_tm.tm_hour - 1) % 12) + 1);
3390 else
3391 return omap_rtc_bcd(s->current_tm.tm_hour);
3392
3393 case 0x0c: /* DAYS_REG */
3394 return omap_rtc_bcd(s->current_tm.tm_mday);
3395
3396 case 0x10: /* MONTHS_REG */
3397 return omap_rtc_bcd(s->current_tm.tm_mon + 1);
3398
3399 case 0x14: /* YEARS_REG */
3400 return omap_rtc_bcd(s->current_tm.tm_year % 100);
3401
3402 case 0x18: /* WEEK_REG */
3403 return s->current_tm.tm_wday;
3404
3405 case 0x20: /* ALARM_SECONDS_REG */
3406 return omap_rtc_bcd(s->alarm_tm.tm_sec);
3407
3408 case 0x24: /* ALARM_MINUTES_REG */
3409 return omap_rtc_bcd(s->alarm_tm.tm_min);
3410
3411 case 0x28: /* ALARM_HOURS_REG */
3412 if (s->pm_am)
3413 return ((s->alarm_tm.tm_hour > 11) << 7) |
3414 omap_rtc_bcd(((s->alarm_tm.tm_hour - 1) % 12) + 1);
3415 else
3416 return omap_rtc_bcd(s->alarm_tm.tm_hour);
3417
3418 case 0x2c: /* ALARM_DAYS_REG */
3419 return omap_rtc_bcd(s->alarm_tm.tm_mday);
3420
3421 case 0x30: /* ALARM_MONTHS_REG */
3422 return omap_rtc_bcd(s->alarm_tm.tm_mon + 1);
3423
3424 case 0x34: /* ALARM_YEARS_REG */
3425 return omap_rtc_bcd(s->alarm_tm.tm_year % 100);
3426
3427 case 0x40: /* RTC_CTRL_REG */
3428 return (s->pm_am << 3) | (s->auto_comp << 2) |
3429 (s->round << 1) | s->running;
3430
3431 case 0x44: /* RTC_STATUS_REG */
3432 i = s->status;
3433 s->status &= ~0x3d;
3434 return i;
3435
3436 case 0x48: /* RTC_INTERRUPTS_REG */
3437 return s->interrupts;
3438
3439 case 0x4c: /* RTC_COMP_LSB_REG */
3440 return ((uint16_t) s->comp_reg) & 0xff;
3441
3442 case 0x50: /* RTC_COMP_MSB_REG */
3443 return ((uint16_t) s->comp_reg) >> 8;
3444 }
3445
3446 OMAP_BAD_REG(addr);
3447 return 0;
3448 }
3449
3450 static void omap_rtc_write(void *opaque, target_phys_addr_t addr,
3451 uint32_t value)
3452 {
3453 struct omap_rtc_s *s = (struct omap_rtc_s *) opaque;
3454 int offset = addr & OMAP_MPUI_REG_MASK;
3455 struct tm new_tm;
3456 time_t ti[2];
3457
3458 switch (offset) {
3459 case 0x00: /* SECONDS_REG */
3460 #ifdef ALMDEBUG
3461 printf("RTC SEC_REG <-- %02x\n", value);
3462 #endif
3463 s->ti -= s->current_tm.tm_sec;
3464 s->ti += omap_rtc_bin(value);
3465 return;
3466
3467 case 0x04: /* MINUTES_REG */
3468 #ifdef ALMDEBUG
3469 printf("RTC MIN_REG <-- %02x\n", value);
3470 #endif
3471 s->ti -= s->current_tm.tm_min * 60;
3472 s->ti += omap_rtc_bin(value) * 60;
3473 return;
3474
3475 case 0x08: /* HOURS_REG */
3476 #ifdef ALMDEBUG
3477 printf("RTC HRS_REG <-- %02x\n", value);
3478 #endif
3479 s->ti -= s->current_tm.tm_hour * 3600;
3480 if (s->pm_am) {
3481 s->ti += (omap_rtc_bin(value & 0x3f) & 12) * 3600;
3482 s->ti += ((value >> 7) & 1) * 43200;
3483 } else
3484 s->ti += omap_rtc_bin(value & 0x3f) * 3600;
3485 return;
3486
3487 case 0x0c: /* DAYS_REG */
3488 #ifdef ALMDEBUG
3489 printf("RTC DAY_REG <-- %02x\n", value);
3490 #endif
3491 s->ti -= s->current_tm.tm_mday * 86400;
3492 s->ti += omap_rtc_bin(value) * 86400;
3493 return;
3494
3495 case 0x10: /* MONTHS_REG */
3496 #ifdef ALMDEBUG
3497 printf("RTC MTH_REG <-- %02x\n", value);
3498 #endif
3499 memcpy(&new_tm, &s->current_tm, sizeof(new_tm));
3500 new_tm.tm_mon = omap_rtc_bin(value);
3501 ti[0] = mktimegm(&s->current_tm);
3502 ti[1] = mktimegm(&new_tm);
3503
3504 if (ti[0] != -1 && ti[1] != -1) {
3505 s->ti -= ti[0];
3506 s->ti += ti[1];
3507 } else {
3508 /* A less accurate version */
3509 s->ti -= s->current_tm.tm_mon * 2592000;
3510 s->ti += omap_rtc_bin(value) * 2592000;
3511 }
3512 return;
3513
3514 case 0x14: /* YEARS_REG */
3515 #ifdef ALMDEBUG
3516 printf("RTC YRS_REG <-- %02x\n", value);
3517 #endif
3518 memcpy(&new_tm, &s->current_tm, sizeof(new_tm));
3519 new_tm.tm_year += omap_rtc_bin(value) - (new_tm.tm_year % 100);
3520 ti[0] = mktimegm(&s->current_tm);
3521 ti[1] = mktimegm(&new_tm);
3522
3523 if (ti[0] != -1 && ti[1] != -1) {
3524 s->ti -= ti[0];
3525 s->ti += ti[1];
3526 } else {
3527 /* A less accurate version */
3528 s->ti -= (s->current_tm.tm_year % 100) * 31536000;
3529 s->ti += omap_rtc_bin(value) * 31536000;
3530 }
3531 return;
3532
3533 case 0x18: /* WEEK_REG */
3534 return; /* Ignored */
3535
3536 case 0x20: /* ALARM_SECONDS_REG */
3537 #ifdef ALMDEBUG
3538 printf("ALM SEC_REG <-- %02x\n", value);
3539 #endif
3540 s->alarm_tm.tm_sec = omap_rtc_bin(value);
3541 omap_rtc_alarm_update(s);
3542 return;
3543
3544 case 0x24: /* ALARM_MINUTES_REG */
3545 #ifdef ALMDEBUG
3546 printf("ALM MIN_REG <-- %02x\n", value);
3547 #endif
3548 s->alarm_tm.tm_min = omap_rtc_bin(value);
3549 omap_rtc_alarm_update(s);
3550 return;
3551
3552 case 0x28: /* ALARM_HOURS_REG */
3553 #ifdef ALMDEBUG
3554 printf("ALM HRS_REG <-- %02x\n", value);
3555 #endif
3556 if (s->pm_am)
3557 s->alarm_tm.tm_hour =
3558 ((omap_rtc_bin(value & 0x3f)) % 12) +
3559 ((value >> 7) & 1) * 12;
3560 else
3561 s->alarm_tm.tm_hour = omap_rtc_bin(value);
3562 omap_rtc_alarm_update(s);
3563 return;
3564
3565 case 0x2c: /* ALARM_DAYS_REG */
3566 #ifdef ALMDEBUG
3567 printf("ALM DAY_REG <-- %02x\n", value);
3568 #endif
3569 s->alarm_tm.tm_mday = omap_rtc_bin(value);
3570 omap_rtc_alarm_update(s);
3571 return;
3572
3573 case 0x30: /* ALARM_MONTHS_REG */
3574 #ifdef ALMDEBUG
3575 printf("ALM MON_REG <-- %02x\n", value);
3576 #endif
3577 s->alarm_tm.tm_mon = omap_rtc_bin(value);
3578 omap_rtc_alarm_update(s);
3579 return;
3580
3581 case 0x34: /* ALARM_YEARS_REG */
3582 #ifdef ALMDEBUG
3583 printf("ALM YRS_REG <-- %02x\n", value);
3584 #endif
3585 s->alarm_tm.tm_year = omap_rtc_bin(value);
3586 omap_rtc_alarm_update(s);
3587 return;
3588
3589 case 0x40: /* RTC_CTRL_REG */
3590 #ifdef ALMDEBUG
3591 printf("RTC CONTROL <-- %02x\n", value);
3592 #endif
3593 s->pm_am = (value >> 3) & 1;
3594 s->auto_comp = (value >> 2) & 1;
3595 s->round = (value >> 1) & 1;
3596 s->running = value & 1;
3597 s->status &= 0xfd;
3598 s->status |= s->running << 1;
3599 return;
3600
3601 case 0x44: /* RTC_STATUS_REG */
3602 #ifdef ALMDEBUG
3603 printf("RTC STATUSL <-- %02x\n", value);
3604 #endif
3605 s->status &= ~((value & 0xc0) ^ 0x80);
3606 omap_rtc_interrupts_update(s);
3607 return;
3608
3609 case 0x48: /* RTC_INTERRUPTS_REG */
3610 #ifdef ALMDEBUG
3611 printf("RTC INTRS <-- %02x\n", value);
3612 #endif
3613 s->interrupts = value;
3614 return;
3615
3616 case 0x4c: /* RTC_COMP_LSB_REG */
3617 #ifdef ALMDEBUG
3618 printf("RTC COMPLSB <-- %02x\n", value);
3619 #endif
3620 s->comp_reg &= 0xff00;
3621 s->comp_reg |= 0x00ff & value;
3622 return;
3623
3624 case 0x50: /* RTC_COMP_MSB_REG */
3625 #ifdef ALMDEBUG
3626 printf("RTC COMPMSB <-- %02x\n", value);
3627 #endif
3628 s->comp_reg &= 0x00ff;
3629 s->comp_reg |= 0xff00 & (value << 8);
3630 return;
3631
3632 default:
3633 OMAP_BAD_REG(addr);
3634 return;
3635 }
3636 }
3637
3638 static CPUReadMemoryFunc *omap_rtc_readfn[] = {
3639 omap_rtc_read,
3640 omap_badwidth_read8,
3641 omap_badwidth_read8,
3642 };
3643
3644 static CPUWriteMemoryFunc *omap_rtc_writefn[] = {
3645 omap_rtc_write,
3646 omap_badwidth_write8,
3647 omap_badwidth_write8,
3648 };
3649
3650 static void omap_rtc_tick(void *opaque)
3651 {
3652 struct omap_rtc_s *s = opaque;
3653
3654 if (s->round) {
3655 /* Round to nearest full minute. */
3656 if (s->current_tm.tm_sec < 30)
3657 s->ti -= s->current_tm.tm_sec;
3658 else
3659 s->ti += 60 - s->current_tm.tm_sec;
3660
3661 s->round = 0;
3662 }
3663
3664 memcpy(&s->current_tm, localtime(&s->ti), sizeof(s->current_tm));
3665
3666 if ((s->interrupts & 0x08) && s->ti == s->alarm_ti) {
3667 s->status |= 0x40;
3668 omap_rtc_interrupts_update(s);
3669 }
3670
3671 if (s->interrupts & 0x04)
3672 switch (s->interrupts & 3) {
3673 case 0:
3674 s->status |= 0x04;
3675 qemu_irq_pulse(s->irq);
3676 break;
3677 case 1:
3678 if (s->current_tm.tm_sec)
3679 break;
3680 s->status |= 0x08;
3681 qemu_irq_pulse(s->irq);
3682 break;
3683 case 2:
3684 if (s->current_tm.tm_sec || s->current_tm.tm_min)
3685 break;
3686 s->status |= 0x10;
3687 qemu_irq_pulse(s->irq);
3688 break;
3689 case 3:
3690 if (s->current_tm.tm_sec ||
3691 s->current_tm.tm_min || s->current_tm.tm_hour)
3692 break;
3693 s->status |= 0x20;
3694 qemu_irq_pulse(s->irq);
3695 break;
3696 }
3697
3698 /* Move on */
3699 if (s->running)
3700 s->ti ++;
3701 s->tick += 1000;
3702
3703 /*
3704 * Every full hour add a rough approximation of the compensation
3705 * register to the 32kHz Timer (which drives the RTC) value.
3706 */
3707 if (s->auto_comp && !s->current_tm.tm_sec && !s->current_tm.tm_min)
3708 s->tick += s->comp_reg * 1000 / 32768;
3709
3710 qemu_mod_timer(s->clk, s->tick);
3711 }
3712
3713 static void omap_rtc_reset(struct omap_rtc_s *s)
3714 {
3715 struct tm tm;
3716
3717 s->interrupts = 0;
3718 s->comp_reg = 0;
3719 s->running = 0;
3720 s->pm_am = 0;
3721 s->auto_comp = 0;
3722 s->round = 0;
3723 s->tick = qemu_get_clock(rt_clock);
3724 memset(&s->alarm_tm, 0, sizeof(s->alarm_tm));
3725 s->alarm_tm.tm_mday = 0x01;
3726 s->status = 1 << 7;
3727 qemu_get_timedate(&tm, 0);
3728 s->ti = mktimegm(&tm);
3729
3730 omap_rtc_alarm_update(s);
3731 omap_rtc_tick(s);
3732 }
3733
3734 struct omap_rtc_s *omap_rtc_init(target_phys_addr_t base,
3735 qemu_irq *irq, omap_clk clk)
3736 {
3737 int iomemtype;
3738 struct omap_rtc_s *s = (struct omap_rtc_s *)
3739 qemu_mallocz(sizeof(struct omap_rtc_s));
3740
3741 s->irq = irq[0];
3742 s->alarm = irq[1];
3743 s->clk = qemu_new_timer(rt_clock, omap_rtc_tick, s);
3744
3745 omap_rtc_reset(s);
3746
3747 iomemtype = cpu_register_io_memory(0, omap_rtc_readfn,
3748 omap_rtc_writefn, s);
3749 cpu_register_physical_memory(base, 0x800, iomemtype);
3750
3751 return s;
3752 }
3753
3754 /* Multi-channel Buffered Serial Port interfaces */
3755 struct omap_mcbsp_s {
3756 qemu_irq txirq;
3757 qemu_irq rxirq;
3758 qemu_irq txdrq;
3759 qemu_irq rxdrq;
3760
3761 uint16_t spcr[2];
3762 uint16_t rcr[2];
3763 uint16_t xcr[2];
3764 uint16_t srgr[2];
3765 uint16_t mcr[2];
3766 uint16_t pcr;
3767 uint16_t rcer[8];
3768 uint16_t xcer[8];
3769 int tx_rate;
3770 int rx_rate;
3771 int tx_req;
3772 int rx_req;
3773
3774 struct i2s_codec_s *codec;
3775 QEMUTimer *source_timer;
3776 QEMUTimer *sink_timer;
3777 };
3778
3779 static void omap_mcbsp_intr_update(struct omap_mcbsp_s *s)
3780 {
3781 int irq;
3782
3783 switch ((s->spcr[0] >> 4) & 3) { /* RINTM */
3784 case 0:
3785 irq = (s->spcr[0] >> 1) & 1; /* RRDY */
3786 break;
3787 case 3:
3788 irq = (s->spcr[0] >> 3) & 1; /* RSYNCERR */
3789 break;
3790 default:
3791 irq = 0;
3792 break;
3793 }
3794
3795 if (irq)
3796 qemu_irq_pulse(s->rxirq);
3797
3798 switch ((s->spcr[1] >> 4) & 3) { /* XINTM */
3799 case 0:
3800 irq = (s->spcr[1] >> 1) & 1; /* XRDY */
3801 break;
3802 case 3:
3803 irq = (s->spcr[1] >> 3) & 1; /* XSYNCERR */
3804 break;
3805 default:
3806 irq = 0;
3807 break;
3808 }
3809
3810 if (irq)
3811 qemu_irq_pulse(s->txirq);
3812 }
3813
3814 static void omap_mcbsp_rx_newdata(struct omap_mcbsp_s *s)
3815 {
3816 if ((s->spcr[0] >> 1) & 1) /* RRDY */
3817 s->spcr[0] |= 1 << 2; /* RFULL */
3818 s->spcr[0] |= 1 << 1; /* RRDY */
3819 qemu_irq_raise(s->rxdrq);
3820 omap_mcbsp_intr_update(s);
3821 }
3822
3823 static void omap_mcbsp_source_tick(void *opaque)
3824 {
3825 struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque;
3826 static const int bps[8] = { 0, 1, 1, 2, 2, 2, -255, -255 };
3827
3828 if (!s->rx_rate)
3829 return;
3830 if (s->rx_req)
3831 printf("%s: Rx FIFO overrun\n", __FUNCTION__);
3832
3833 s->rx_req = s->rx_rate << bps[(s->rcr[0] >> 5) & 7];
3834
3835 omap_mcbsp_rx_newdata(s);
3836 qemu_mod_timer(s->source_timer, qemu_get_clock(vm_clock) + ticks_per_sec);
3837 }
3838
3839 static void omap_mcbsp_rx_start(struct omap_mcbsp_s *s)
3840 {
3841 if (!s->codec || !s->codec->rts)
3842 omap_mcbsp_source_tick(s);
3843 else if (s->codec->in.len) {
3844 s->rx_req = s->codec->in.len;
3845 omap_mcbsp_rx_newdata(s);
3846 }
3847 }
3848
3849 static void omap_mcbsp_rx_stop(struct omap_mcbsp_s *s)
3850 {
3851 qemu_del_timer(s->source_timer);
3852 }
3853
3854 static void omap_mcbsp_rx_done(struct omap_mcbsp_s *s)
3855 {
3856 s->spcr[0] &= ~(1 << 1); /* RRDY */
3857 qemu_irq_lower(s->rxdrq);
3858 omap_mcbsp_intr_update(s);
3859 }
3860
3861 static void omap_mcbsp_tx_newdata(struct omap_mcbsp_s *s)
3862 {
3863 s->spcr[1] |= 1 << 1; /* XRDY */
3864 qemu_irq_raise(s->txdrq);
3865 omap_mcbsp_intr_update(s);
3866 }
3867
3868 static void omap_mcbsp_sink_tick(void *opaque)
3869 {
3870 struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque;
3871 static const int bps[8] = { 0, 1, 1, 2, 2, 2, -255, -255 };
3872
3873 if (!s->tx_rate)
3874 return;
3875 if (s->tx_req)
3876 printf("%s: Tx FIFO underrun\n", __FUNCTION__);
3877
3878 s->tx_req = s->tx_rate << bps[(s->xcr[0] >> 5) & 7];
3879
3880 omap_mcbsp_tx_newdata(s);
3881 qemu_mod_timer(s->sink_timer, qemu_get_clock(vm_clock) + ticks_per_sec);
3882 }
3883
3884 static void omap_mcbsp_tx_start(struct omap_mcbsp_s *s)
3885 {
3886 if (!s->codec || !s->codec->cts)
3887 omap_mcbsp_sink_tick(s);
3888 else if (s->codec->out.size) {
3889 s->tx_req = s->codec->out.size;
3890 omap_mcbsp_tx_newdata(s);
3891 }
3892 }
3893
3894 static void omap_mcbsp_tx_done(struct omap_mcbsp_s *s)
3895 {
3896 s->spcr[1] &= ~(1 << 1); /* XRDY */
3897 qemu_irq_lower(s->txdrq);
3898 omap_mcbsp_intr_update(s);
3899 if (s->codec && s->codec->cts)
3900 s->codec->tx_swallow(s->codec->opaque);
3901 }
3902
3903 static void omap_mcbsp_tx_stop(struct omap_mcbsp_s *s)
3904 {
3905 s->tx_req = 0;
3906 omap_mcbsp_tx_done(s);
3907 qemu_del_timer(s->sink_timer);
3908 }
3909
3910 static void omap_mcbsp_req_update(struct omap_mcbsp_s *s)
3911 {
3912 int prev_rx_rate, prev_tx_rate;
3913 int rx_rate = 0, tx_rate = 0;
3914 int cpu_rate = 1500000; /* XXX */
3915
3916 /* TODO: check CLKSTP bit */
3917 if (s->spcr[1] & (1 << 6)) { /* GRST */
3918 if (s->spcr[0] & (1 << 0)) { /* RRST */
3919 if ((s->srgr[1] & (1 << 13)) && /* CLKSM */
3920 (s->pcr & (1 << 8))) { /* CLKRM */
3921 if (~s->pcr & (1 << 7)) /* SCLKME */
3922 rx_rate = cpu_rate /
3923 ((s->srgr[0] & 0xff) + 1); /* CLKGDV */
3924 } else
3925 if (s->codec)
3926 rx_rate = s->codec->rx_rate;
3927 }
3928
3929 if (s->spcr[1] & (1 << 0)) { /* XRST */
3930 if ((s->srgr[1] & (1 << 13)) && /* CLKSM */
3931 (s->pcr & (1 << 9))) { /* CLKXM */
3932 if (~s->pcr & (1 << 7)) /* SCLKME */
3933 tx_rate = cpu_rate /
3934 ((s->srgr[0] & 0xff) + 1); /* CLKGDV */
3935 } else
3936 if (s->codec)
3937 tx_rate = s->codec->tx_rate;
3938 }
3939 }
3940 prev_tx_rate = s->tx_rate;
3941 prev_rx_rate = s->rx_rate;
3942 s->tx_rate = tx_rate;
3943 s->rx_rate = rx_rate;
3944
3945 if (s->codec)
3946 s->codec->set_rate(s->codec->opaque, rx_rate, tx_rate);
3947
3948 if (!prev_tx_rate && tx_rate)
3949 omap_mcbsp_tx_start(s);
3950 else if (s->tx_rate && !tx_rate)
3951 omap_mcbsp_tx_stop(s);
3952
3953 if (!prev_rx_rate && rx_rate)
3954 omap_mcbsp_rx_start(s);
3955 else if (prev_tx_rate && !tx_rate)
3956 omap_mcbsp_rx_stop(s);
3957 }
3958
3959 static uint32_t omap_mcbsp_read(void *opaque, target_phys_addr_t addr)
3960 {
3961 struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque;
3962 int offset = addr & OMAP_MPUI_REG_MASK;
3963 uint16_t ret;
3964
3965 switch (offset) {
3966 case 0x00: /* DRR2 */
3967 if (((s->rcr[0] >> 5) & 7) < 3) /* RWDLEN1 */
3968 return 0x0000;
3969 /* Fall through. */
3970 case 0x02: /* DRR1 */
3971 if (s->rx_req < 2) {
3972 printf("%s: Rx FIFO underrun\n", __FUNCTION__);
3973 omap_mcbsp_rx_done(s);
3974 } else {
3975 s->tx_req -= 2;
3976 if (s->codec && s->codec->in.len >= 2) {
3977 ret = s->codec->in.fifo[s->codec->in.start ++] << 8;
3978 ret |= s->codec->in.fifo[s->codec->in.start ++];
3979 s->codec->in.len -= 2;
3980 } else
3981 ret = 0x0000;
3982 if (!s->tx_req)
3983 omap_mcbsp_rx_done(s);
3984 return ret;
3985 }
3986 return 0x0000;
3987
3988 case 0x04: /* DXR2 */
3989 case 0x06: /* DXR1 */
3990 return 0x0000;
3991
3992 case 0x08: /* SPCR2 */
3993 return s->spcr[1];
3994 case 0x0a: /* SPCR1 */
3995 return s->spcr[0];
3996 case 0x0c: /* RCR2 */
3997 return s->rcr[1];
3998 case 0x0e: /* RCR1 */
3999 return s->rcr[0];
4000 case 0x10: /* XCR2 */
4001 return s->xcr[1];
4002 case 0x12: /* XCR1 */
4003 return s->xcr[0];
4004 case 0x14: /* SRGR2 */
4005 return s->srgr[1];
4006 case 0x16: /* SRGR1 */
4007 return s->srgr[0];
4008 case 0x18: /* MCR2 */
4009 return s->mcr[1];
4010 case 0x1a: /* MCR1 */
4011 return s->mcr[0];
4012 case 0x1c: /* RCERA */
4013 return s->rcer[0];
4014 case 0x1e: /* RCERB */
4015 return s->rcer[1];
4016 case 0x20: /* XCERA */
4017 return s->xcer[0];
4018 case 0x22: /* XCERB */
4019 return s->xcer[1];
4020 case 0x24: /* PCR0 */
4021 return s->pcr;
4022 case 0x26: /* RCERC */
4023 return s->rcer[2];
4024 case 0x28: /* RCERD */
4025 return s->rcer[3];
4026 case 0x2a: /* XCERC */
4027 return s->xcer[2];
4028 case 0x2c: /* XCERD */
4029 return s->xcer[3];
4030 case 0x2e: /* RCERE */
4031 return s->rcer[4];
4032 case 0x30: /* RCERF */
4033 return s->rcer[5];
4034 case 0x32: /* XCERE */
4035 return s->xcer[4];
4036 case 0x34: /* XCERF */
4037 return s->xcer[5];
4038 case 0x36: /* RCERG */
4039 return s->rcer[6];
4040 case 0x38: /* RCERH */
4041 return s->rcer[7];
4042 case 0x3a: /* XCERG */
4043 return s->xcer[6];
4044 case 0x3c: /* XCERH */
4045 return s->xcer[7];
4046 }
4047
4048 OMAP_BAD_REG(addr);
4049 return 0;
4050 }
4051
4052 static void omap_mcbsp_writeh(void *opaque, target_phys_addr_t addr,
4053 uint32_t value)
4054 {
4055 struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque;
4056 int offset = addr & OMAP_MPUI_REG_MASK;
4057
4058 switch (offset) {
4059 case 0x00: /* DRR2 */
4060 case 0x02: /* DRR1 */
4061 OMAP_RO_REG(addr);
4062 return;
4063
4064 case 0x04: /* DXR2 */
4065 if (((s->xcr[0] >> 5) & 7) < 3) /* XWDLEN1 */
4066 return;
4067 /* Fall through. */
4068 case 0x06: /* DXR1 */
4069 if (s->tx_req > 1) {
4070 s->tx_req -= 2;
4071 if (s->codec && s->codec->cts) {
4072 s->codec->out.fifo[s->codec->out.len ++] = (value >> 8) & 0xff;
4073 s->codec->out.fifo[s->codec->out.len ++] = (value >> 0) & 0xff;
4074 }
4075 if (s->tx_req < 2)
4076 omap_mcbsp_tx_done(s);
4077 } else
4078 printf("%s: Tx FIFO overrun\n", __FUNCTION__);
4079 return;
4080
4081 case 0x08: /* SPCR2 */
4082 s->spcr[1] &= 0x0002;
4083 s->spcr[1] |= 0x03f9 & value;
4084 s->spcr[1] |= 0x0004 & (value << 2); /* XEMPTY := XRST */
4085 if (~value & 1) /* XRST */
4086 s->spcr[1] &= ~6;
4087 omap_mcbsp_req_update(s);
4088 return;
4089 case 0x0a: /* SPCR1 */
4090 s->spcr[0] &= 0x0006;
4091 s->spcr[0] |= 0xf8f9 & value;
4092 if (value & (1 << 15)) /* DLB */
4093 printf("%s: Digital Loopback mode enable attempt\n", __FUNCTION__);
4094 if (~value & 1) { /* RRST */
4095 s->spcr[0] &= ~6;
4096 s->rx_req = 0;
4097 omap_mcbsp_rx_done(s);
4098 }
4099 omap_mcbsp_req_update(s);
4100 return;
4101
4102 case 0x0c: /* RCR2 */
4103 s->rcr[1] = value & 0xffff;
4104 return;
4105 case 0x0e: /* RCR1 */
4106 s->rcr[0] = value & 0x7fe0;
4107 return;
4108 case 0x10: /* XCR2 */
4109 s->xcr[1] = value & 0xffff;
4110 return;
4111 case 0x12: /* XCR1 */
4112 s->xcr[0] = value & 0x7fe0;
4113 return;
4114 case 0x14: /* SRGR2 */
4115 s->srgr[1] = value & 0xffff;
4116 omap_mcbsp_req_update(s);
4117 return;
4118 case 0x16: /* SRGR1 */
4119 s->srgr[0] = value & 0xffff;
4120 omap_mcbsp_req_update(s);
4121 return;
4122 case 0x18: /* MCR2 */
4123 s->mcr[1] = value & 0x03e3;
4124 if (value & 3) /* XMCM */
4125 printf("%s: Tx channel selection mode enable attempt\n",
4126 __FUNCTION__);
4127 return;
4128 case 0x1a: /* MCR1 */
4129 s->mcr[0] = value & 0x03e1;
4130 if (value & 1) /* RMCM */
4131 printf("%s: Rx channel selection mode enable attempt\n",
4132 __FUNCTION__);
4133 return;
4134 case 0x1c: /* RCERA */
4135 s->rcer[0] = value & 0xffff;
4136 return;
4137 case 0x1e: /* RCERB */
4138 s->rcer[1] = value & 0xffff;
4139 return;
4140 case 0x20: /* XCERA */
4141 s->xcer[0] = value & 0xffff;
4142 return;
4143 case 0x22: /* XCERB */
4144 s->xcer[1] = value & 0xffff;
4145 return;
4146 case 0x24: /* PCR0 */
4147 s->pcr = value & 0x7faf;
4148 return;
4149 case 0x26: /* RCERC */
4150 s->rcer[2] = value & 0xffff;
4151 return;
4152 case 0x28: /* RCERD */
4153 s->rcer[3] = value & 0xffff;
4154 return;
4155 case 0x2a: /* XCERC */
4156 s->xcer[2] = value & 0xffff;
4157 return;
4158 case 0x2c: /* XCERD */
4159 s->xcer[3] = value & 0xffff;
4160 return;
4161 case 0x2e: /* RCERE */
4162 s->rcer[4] = value & 0xffff;
4163 return;
4164 case 0x30: /* RCERF */
4165 s->rcer[5] = value & 0xffff;
4166 return;
4167 case 0x32: /* XCERE */
4168 s->xcer[4] = value & 0xffff;
4169 return;
4170 case 0x34: /* XCERF */
4171 s->xcer[5] = value & 0xffff;
4172 return;
4173 case 0x36: /* RCERG */
4174 s->rcer[6] = value & 0xffff;
4175 return;
4176 case 0x38: /* RCERH */
4177 s->rcer[7] = value & 0xffff;
4178 return;
4179 case 0x3a: /* XCERG */
4180 s->xcer[6] = value & 0xffff;
4181 return;
4182 case 0x3c: /* XCERH */
4183 s->xcer[7] = value & 0xffff;
4184 return;
4185 }
4186
4187 OMAP_BAD_REG(addr);
4188 }
4189
4190 static void omap_mcbsp_writew(void *opaque, target_phys_addr_t addr,
4191 uint32_t value)
4192 {
4193 struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque;
4194 int offset = addr & OMAP_MPUI_REG_MASK;
4195
4196 if (offset == 0x04) { /* DXR */
4197 if (((s->xcr[0] >> 5) & 7) < 3) /* XWDLEN1 */
4198 return;
4199 if (s->tx_req > 3) {
4200 s->tx_req -= 4;
4201 if (s->codec && s->codec->cts) {
4202 s->codec->out.fifo[s->codec->out.len ++] =
4203 (value >> 24) & 0xff;
4204 s->codec->out.fifo[s->codec->out.len ++] =
4205 (value >> 16) & 0xff;
4206 s->codec->out.fifo[s->codec->out.len ++] =
4207 (value >> 8) & 0xff;
4208 s->codec->out.fifo[s->codec->out.len ++] =
4209 (value >> 0) & 0xff;
4210 }
4211 if (s->tx_req < 4)
4212 omap_mcbsp_tx_done(s);
4213 } else
4214 printf("%s: Tx FIFO overrun\n", __FUNCTION__);
4215 return;
4216 }
4217
4218 omap_badwidth_write16(opaque, addr, value);
4219 }
4220
4221 static CPUReadMemoryFunc *omap_mcbsp_readfn[] = {
4222 omap_badwidth_read16,
4223 omap_mcbsp_read,
4224 omap_badwidth_read16,
4225 };
4226
4227 static CPUWriteMemoryFunc *omap_mcbsp_writefn[] = {
4228 omap_badwidth_write16,
4229 omap_mcbsp_writeh,
4230 omap_mcbsp_writew,
4231 };
4232
4233 static void omap_mcbsp_reset(struct omap_mcbsp_s *s)
4234 {
4235 memset(&s->spcr, 0, sizeof(s->spcr));
4236 memset(&s->rcr, 0, sizeof(s->rcr));
4237 memset(&s->xcr, 0, sizeof(s->xcr));
4238 s->srgr[0] = 0x0001;
4239 s->srgr[1] = 0x2000;
4240 memset(&s->mcr, 0, sizeof(s->mcr));
4241 memset(&s->pcr, 0, sizeof(s->pcr));
4242 memset(&s->rcer, 0, sizeof(s->rcer));
4243 memset(&s->xcer, 0, sizeof(s->xcer));
4244 s->tx_req = 0;
4245 s->rx_req = 0;
4246 s->tx_rate = 0;
4247 s->rx_rate = 0;
4248 qemu_del_timer(s->source_timer);
4249 qemu_del_timer(s->sink_timer);
4250 }
4251
4252 struct omap_mcbsp_s *omap_mcbsp_init(target_phys_addr_t base,
4253 qemu_irq *irq, qemu_irq *dma, omap_clk clk)
4254 {
4255 int iomemtype;
4256 struct omap_mcbsp_s *s = (struct omap_mcbsp_s *)
4257 qemu_mallocz(sizeof(struct omap_mcbsp_s));
4258
4259 s->txirq = irq[0];
4260 s->rxirq = irq[1];
4261 s->txdrq = dma[0];
4262 s->rxdrq = dma[1];
4263 s->sink_timer = qemu_new_timer(vm_clock, omap_mcbsp_sink_tick, s);
4264 s->source_timer = qemu_new_timer(vm_clock, omap_mcbsp_source_tick, s);
4265 omap_mcbsp_reset(s);
4266
4267 iomemtype = cpu_register_io_memory(0, omap_mcbsp_readfn,
4268 omap_mcbsp_writefn, s);
4269 cpu_register_physical_memory(base, 0x800, iomemtype);
4270
4271 return s;
4272 }
4273
4274 static void omap_mcbsp_i2s_swallow(void *opaque, int line, int level)
4275 {
4276 struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque;
4277
4278 if (s->rx_rate) {
4279 s->rx_req = s->codec->in.len;
4280 omap_mcbsp_rx_newdata(s);
4281 }
4282 }
4283
4284 static void omap_mcbsp_i2s_start(void *opaque, int line, int level)
4285 {
4286 struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque;
4287
4288 if (s->tx_rate) {
4289 s->tx_req = s->codec->out.size;
4290 omap_mcbsp_tx_newdata(s);
4291 }
4292 }
4293
4294 void omap_mcbsp_i2s_attach(struct omap_mcbsp_s *s, struct i2s_codec_s *slave)
4295 {
4296 s->codec = slave;
4297 slave->rx_swallow = qemu_allocate_irqs(omap_mcbsp_i2s_swallow, s, 1)[0];
4298 slave->tx_start = qemu_allocate_irqs(omap_mcbsp_i2s_start, s, 1)[0];
4299 }
4300
4301 /* LED Pulse Generators */
4302 struct omap_lpg_s {
4303 QEMUTimer *tm;
4304
4305 uint8_t control;
4306 uint8_t power;
4307 int64_t on;
4308 int64_t period;
4309 int clk;
4310 int cycle;
4311 };
4312
4313 static void omap_lpg_tick(void *opaque)
4314 {
4315 struct omap_lpg_s *s = opaque;
4316
4317 if (s->cycle)
4318 qemu_mod_timer(s->tm, qemu_get_clock(rt_clock) + s->period - s->on);
4319 else
4320 qemu_mod_timer(s->tm, qemu_get_clock(rt_clock) + s->on);
4321
4322 s->cycle = !s->cycle;
4323 printf("%s: LED is %s\n", __FUNCTION__, s->cycle ? "on" : "off");
4324 }
4325
4326 static void omap_lpg_update(struct omap_lpg_s *s)
4327 {
4328 int64_t on, period = 1, ticks = 1000;
4329 static const int per[8] = { 1, 2, 4, 8, 12, 16, 20, 24 };
4330
4331 if (~s->control & (1 << 6)) /* LPGRES */
4332 on = 0;
4333 else if (s->control & (1 << 7)) /* PERM_ON */
4334 on = period;
4335 else {
4336 period = muldiv64(ticks, per[s->control & 7], /* PERCTRL */
4337 256 / 32);
4338 on = (s->clk && s->power) ? muldiv64(ticks,
4339 per[(s->control >> 3) & 7], 256) : 0; /* ONCTRL */
4340 }
4341
4342 qemu_del_timer(s->tm);
4343 if (on == period && s->on < s->period)
4344 printf("%s: LED is on\n", __FUNCTION__);
4345 else if (on == 0 && s->on)
4346 printf("%s: LED is off\n", __FUNCTION__);
4347 else if (on && (on != s->on || period != s->period)) {
4348 s->cycle = 0;
4349 s->on = on;
4350 s->period = period;
4351 omap_lpg_tick(s);
4352 return;
4353 }
4354
4355 s->on = on;
4356 s->period = period;
4357 }
4358
4359 static void omap_lpg_reset(struct omap_lpg_s *s)
4360 {
4361 s->control = 0x00;
4362 s->power = 0x00;
4363 s->clk = 1;
4364 omap_lpg_update(s);
4365 }
4366
4367 static uint32_t omap_lpg_read(void *opaque, target_phys_addr_t addr)
4368 {
4369 struct omap_lpg_s *s = (struct omap_lpg_s *) opaque;
4370 int offset = addr & OMAP_MPUI_REG_MASK;
4371
4372 switch (offset) {
4373 case 0x00: /* LCR */
4374 return s->control;
4375
4376 case 0x04: /* PMR */
4377 return s->power;
4378 }
4379
4380 OMAP_BAD_REG(addr);
4381 return 0;
4382 }
4383
4384 static void omap_lpg_write(void *opaque, target_phys_addr_t addr,
4385 uint32_t value)
4386 {
4387 struct omap_lpg_s *s = (struct omap_lpg_s *) opaque;
4388 int offset = addr & OMAP_MPUI_REG_MASK;
4389
4390 switch (offset) {
4391 case 0x00: /* LCR */
4392 if (~value & (1 << 6)) /* LPGRES */
4393 omap_lpg_reset(s);
4394 s->control = value & 0xff;
4395 omap_lpg_update(s);
4396 return;
4397
4398 case 0x04: /* PMR */
4399 s->power = value & 0x01;
4400 omap_lpg_update(s);
4401 return;
4402
4403 default:
4404 OMAP_BAD_REG(addr);
4405 return;
4406 }
4407 }
4408
4409 static CPUReadMemoryFunc *omap_lpg_readfn[] = {
4410 omap_lpg_read,
4411 omap_badwidth_read8,
4412 omap_badwidth_read8,
4413 };
4414
4415 static CPUWriteMemoryFunc *omap_lpg_writefn[] = {
4416 omap_lpg_write,
4417 omap_badwidth_write8,
4418 omap_badwidth_write8,
4419 };
4420
4421 static void omap_lpg_clk_update(void *opaque, int line, int on)
4422 {
4423 struct omap_lpg_s *s = (struct omap_lpg_s *) opaque;
4424
4425 s->clk = on;
4426 omap_lpg_update(s);
4427 }
4428
4429 struct omap_lpg_s *omap_lpg_init(target_phys_addr_t base, omap_clk clk)
4430 {
4431 int iomemtype;
4432 struct omap_lpg_s *s = (struct omap_lpg_s *)
4433 qemu_mallocz(sizeof(struct omap_lpg_s));
4434
4435 s->tm = qemu_new_timer(rt_clock, omap_lpg_tick, s);
4436
4437 omap_lpg_reset(s);
4438
4439 iomemtype = cpu_register_io_memory(0, omap_lpg_readfn,
4440 omap_lpg_writefn, s);
4441 cpu_register_physical_memory(base, 0x800, iomemtype);
4442
4443 omap_clk_adduser(clk, qemu_allocate_irqs(omap_lpg_clk_update, s, 1)[0]);
4444
4445 return s;
4446 }
4447
4448 /* MPUI Peripheral Bridge configuration */
4449 static uint32_t omap_mpui_io_read(void *opaque, target_phys_addr_t addr)
4450 {
4451 if (addr == OMAP_MPUI_BASE) /* CMR */
4452 return 0xfe4d;
4453
4454 OMAP_BAD_REG(addr);
4455 return 0;
4456 }
4457
4458 static CPUReadMemoryFunc *omap_mpui_io_readfn[] = {
4459 omap_badwidth_read16,
4460 omap_mpui_io_read,
4461 omap_badwidth_read16,
4462 };
4463
4464 static CPUWriteMemoryFunc *omap_mpui_io_writefn[] = {
4465 omap_badwidth_write16,
4466 omap_badwidth_write16,
4467 omap_badwidth_write16,
4468 };
4469
4470 static void omap_setup_mpui_io(struct omap_mpu_state_s *mpu)
4471 {
4472 int iomemtype = cpu_register_io_memory(0, omap_mpui_io_readfn,
4473 omap_mpui_io_writefn, mpu);
4474 cpu_register_physical_memory(OMAP_MPUI_BASE, 0x7fff, iomemtype);
4475 }
4476
4477 /* General chip reset */
4478 static void omap1_mpu_reset(void *opaque)
4479 {
4480 struct omap_mpu_state_s *mpu = (struct omap_mpu_state_s *) opaque;
4481
4482 omap_inth_reset(mpu->ih[0]);
4483 omap_inth_reset(mpu->ih[1]);
4484 omap_dma_reset(mpu->dma);
4485 omap_mpu_timer_reset(mpu->timer[0]);
4486 omap_mpu_timer_reset(mpu->timer[1]);
4487 omap_mpu_timer_reset(mpu->timer[2]);
4488 omap_wd_timer_reset(mpu->wdt);
4489 omap_os_timer_reset(mpu->os_timer);
4490 omap_lcdc_reset(mpu->lcd);
4491 omap_ulpd_pm_reset(mpu);
4492 omap_pin_cfg_reset(mpu);
4493 omap_mpui_reset(mpu);
4494 omap_tipb_bridge_reset(mpu->private_tipb);
4495 omap_tipb_bridge_reset(mpu->public_tipb);
4496 omap_dpll_reset(&mpu->dpll[0]);
4497 omap_dpll_reset(&mpu->dpll[1]);
4498 omap_dpll_reset(&mpu->dpll[2]);
4499 omap_uart_reset(mpu->uart[0]);
4500 omap_uart_reset(mpu->uart[1]);
4501 omap_uart_reset(mpu->uart[2]);
4502 omap_mmc_reset(mpu->mmc);
4503 omap_mpuio_reset(mpu->mpuio);
4504 omap_gpio_reset(mpu->gpio);
4505 omap_uwire_reset(mpu->microwire);
4506 omap_pwl_reset(mpu);
4507 omap_pwt_reset(mpu);
4508 omap_i2c_reset(mpu->i2c[0]);
4509 omap_rtc_reset(mpu->rtc);
4510 omap_mcbsp_reset(mpu->mcbsp1);
4511 omap_mcbsp_reset(mpu->mcbsp2);
4512 omap_mcbsp_reset(mpu->mcbsp3);
4513 omap_lpg_reset(mpu->led[0]);
4514 omap_lpg_reset(mpu->led[1]);
4515 omap_clkm_reset(mpu);
4516 cpu_reset(mpu->env);
4517 }
4518
4519 static const struct omap_map_s {
4520 target_phys_addr_t phys_dsp;
4521 target_phys_addr_t phys_mpu;
4522 uint32_t size;
4523 const char *name;
4524 } omap15xx_dsp_mm[] = {
4525 /* Strobe 0 */
4526 { 0xe1010000, 0xfffb0000, 0x800, "UART1 BT" }, /* CS0 */
4527 { 0xe1010800, 0xfffb0800, 0x800, "UART2 COM" }, /* CS1 */
4528 { 0xe1011800, 0xfffb1800, 0x800, "McBSP1 audio" }, /* CS3 */
4529 { 0xe1012000, 0xfffb2000, 0x800, "MCSI2 communication" }, /* CS4 */
4530 { 0xe1012800, 0xfffb2800, 0x800, "MCSI1 BT u-Law" }, /* CS5 */
4531 { 0xe1013000, 0xfffb3000, 0x800, "uWire" }, /* CS6 */
4532 { 0xe1013800, 0xfffb3800, 0x800, "I^2C" }, /* CS7 */
4533 { 0xe1014000, 0xfffb4000, 0x800, "USB W2FC" }, /* CS8 */
4534 { 0xe1014800, 0xfffb4800, 0x800, "RTC" }, /* CS9 */
4535 { 0xe1015000, 0xfffb5000, 0x800, "MPUIO" }, /* CS10 */
4536 { 0xe1015800, 0xfffb5800, 0x800, "PWL" }, /* CS11 */
4537 { 0xe1016000, 0xfffb6000, 0x800, "PWT" }, /* CS12 */
4538 { 0xe1017000, 0xfffb7000, 0x800, "McBSP3" }, /* CS14 */
4539 { 0xe1017800, 0xfffb7800, 0x800, "MMC" }, /* CS15 */
4540 { 0xe1019000, 0xfffb9000, 0x800, "32-kHz timer" }, /* CS18 */
4541 { 0xe1019800, 0xfffb9800, 0x800, "UART3" }, /* CS19 */
4542 { 0xe101c800, 0xfffbc800, 0x800, "TIPB switches" }, /* CS25 */
4543 /* Strobe 1 */
4544 { 0xe101e000, 0xfffce000, 0x800, "GPIOs" }, /* CS28 */
4545
4546 { 0 }
4547 };
4548
4549 static void omap_setup_dsp_mapping(const struct omap_map_s *map)
4550 {
4551 int io;
4552
4553 for (; map->phys_dsp; map ++) {
4554 io = cpu_get_physical_page_desc(map->phys_mpu);
4555
4556 cpu_register_physical_memory(map->phys_dsp, map->size, io);
4557 }
4558 }
4559
4560 void omap_mpu_wakeup(void *opaque, int irq, int req)
4561 {
4562 struct omap_mpu_state_s *mpu = (struct omap_mpu_state_s *) opaque;
4563
4564 if (mpu->env->halted)
4565 cpu_interrupt(mpu->env, CPU_INTERRUPT_EXITTB);
4566 }
4567
4568 static const struct dma_irq_map omap1_dma_irq_map[] = {
4569 { 0, OMAP_INT_DMA_CH0_6 },
4570 { 0, OMAP_INT_DMA_CH1_7 },
4571 { 0, OMAP_INT_DMA_CH2_8 },
4572 { 0, OMAP_INT_DMA_CH3 },
4573 { 0, OMAP_INT_DMA_CH4 },
4574 { 0, OMAP_INT_DMA_CH5 },
4575 { 1, OMAP_INT_1610_DMA_CH6 },
4576 { 1, OMAP_INT_1610_DMA_CH7 },
4577 { 1, OMAP_INT_1610_DMA_CH8 },
4578 { 1, OMAP_INT_1610_DMA_CH9 },
4579 { 1, OMAP_INT_1610_DMA_CH10 },
4580 { 1, OMAP_INT_1610_DMA_CH11 },
4581 { 1, OMAP_INT_1610_DMA_CH12 },
4582 { 1, OMAP_INT_1610_DMA_CH13 },
4583 { 1, OMAP_INT_1610_DMA_CH14 },
4584 { 1, OMAP_INT_1610_DMA_CH15 }
4585 };
4586
4587 /* DMA ports for OMAP1 */
4588 static int omap_validate_emiff_addr(struct omap_mpu_state_s *s,
4589 target_phys_addr_t addr)
4590 {
4591 return addr >= OMAP_EMIFF_BASE && addr < OMAP_EMIFF_BASE + s->sdram_size;
4592 }
4593
4594 static int omap_validate_emifs_addr(struct omap_mpu_state_s *s,
4595 target_phys_addr_t addr)
4596 {
4597 return addr >= OMAP_EMIFS_BASE && addr < OMAP_EMIFF_BASE;
4598 }
4599
4600 static int omap_validate_imif_addr(struct omap_mpu_state_s *s,
4601 target_phys_addr_t addr)
4602 {
4603 return addr >= OMAP_IMIF_BASE && addr < OMAP_IMIF_BASE + s->sram_size;
4604 }
4605
4606 static int omap_validate_tipb_addr(struct omap_mpu_state_s *s,
4607 target_phys_addr_t addr)
4608 {
4609 return addr >= 0xfffb0000 && addr < 0xffff0000;
4610 }
4611
4612 static int omap_validate_local_addr(struct omap_mpu_state_s *s,
4613 target_phys_addr_t addr)
4614 {
4615 return addr >= OMAP_LOCALBUS_BASE && addr < OMAP_LOCALBUS_BASE + 0x1000000;
4616 }
4617
4618 static int omap_validate_tipb_mpui_addr(struct omap_mpu_state_s *s,
4619 target_phys_addr_t addr)
4620 {
4621 return addr >= 0xe1010000 && addr < 0xe1020004;
4622 }
4623
4624 struct omap_mpu_state_s *omap310_mpu_init(unsigned long sdram_size,
4625 DisplayState *ds, const char *core)
4626 {
4627 int i;
4628 struct omap_mpu_state_s *s = (struct omap_mpu_state_s *)
4629 qemu_mallocz(sizeof(struct omap_mpu_state_s));
4630 ram_addr_t imif_base, emiff_base;
4631 qemu_irq *cpu_irq;
4632 qemu_irq dma_irqs[6];
4633 int sdindex;
4634
4635 if (!core)
4636 core = "ti925t";
4637
4638 /* Core */
4639 s->mpu_model = omap310;
4640 s->env = cpu_init(core);
4641 if (!s->env) {
4642 fprintf(stderr, "Unable to find CPU definition\n");
4643 exit(1);
4644 }
4645 s->sdram_size = sdram_size;
4646 s->sram_size = OMAP15XX_SRAM_SIZE;
4647
4648 s->wakeup = qemu_allocate_irqs(omap_mpu_wakeup, s, 1)[0];
4649
4650 /* Clocks */
4651 omap_clk_init(s);
4652
4653 /* Memory-mapped stuff */
4654 cpu_register_physical_memory(OMAP_EMIFF_BASE, s->sdram_size,
4655 (emiff_base = qemu_ram_alloc(s->sdram_size)) | IO_MEM_RAM);
4656 cpu_register_physical_memory(OMAP_IMIF_BASE, s->sram_size,
4657 (imif_base = qemu_ram_alloc(s->sram_size)) | IO_MEM_RAM);
4658
4659 omap_clkm_init(0xfffece00, 0xe1008000, s);
4660
4661 cpu_irq = arm_pic_init_cpu(s->env);
4662 s->ih[0] = omap_inth_init(0xfffecb00, 0x100, 1, &s->irq[0],
4663 cpu_irq[ARM_PIC_CPU_IRQ], cpu_irq[ARM_PIC_CPU_FIQ],
4664 omap_findclk(s, "arminth_ck"));
4665 s->ih[1] = omap_inth_init(0xfffe0000, 0x800, 1, &s->irq[1],
4666 s->ih[0]->pins[OMAP_INT_15XX_IH2_IRQ], NULL,
4667 omap_findclk(s, "arminth_ck"));
4668
4669 for (i = 0; i < 6; i ++)
4670 dma_irqs[i] =
4671 s->irq[omap1_dma_irq_map[i].ih][omap1_dma_irq_map[i].intr];
4672 s->dma = omap_dma_init(0xfffed800, dma_irqs, s->irq[0][OMAP_INT_DMA_LCD],
4673 s, omap_findclk(s, "dma_ck"), omap_dma_3_1);
4674
4675 s->port[emiff ].addr_valid = omap_validate_emiff_addr;
4676 s->port[emifs ].addr_valid = omap_validate_emifs_addr;
4677 s->port[imif ].addr_valid = omap_validate_imif_addr;
4678 s->port[tipb ].addr_valid = omap_validate_tipb_addr;
4679 s->port[local ].addr_valid = omap_validate_local_addr;
4680 s->port[tipb_mpui].addr_valid = omap_validate_tipb_mpui_addr;
4681
4682 /* Register SDRAM and SRAM DMA ports for fast transfers. */
4683 soc_dma_port_add_mem_ram(s->dma,
4684 emiff_base, OMAP_EMIFF_BASE, s->sdram_size);
4685 soc_dma_port_add_mem_ram(s->dma,
4686 imif_base, OMAP_IMIF_BASE, s->sram_size);
4687
4688 s->timer[0] = omap_mpu_timer_init(0xfffec500,
4689 s->irq[0][OMAP_INT_TIMER1],
4690 omap_findclk(s, "mputim_ck"));
4691 s->timer[1] = omap_mpu_timer_init(0xfffec600,
4692 s->irq[0][OMAP_INT_TIMER2],
4693 omap_findclk(s, "mputim_ck"));
4694 s->timer[2] = omap_mpu_timer_init(0xfffec700,
4695 s->irq[0][OMAP_INT_TIMER3],
4696 omap_findclk(s, "mputim_ck"));
4697
4698 s->wdt = omap_wd_timer_init(0xfffec800,
4699 s->irq[0][OMAP_INT_WD_TIMER],
4700 omap_findclk(s, "armwdt_ck"));
4701
4702 s->os_timer = omap_os_timer_init(0xfffb9000,
4703 s->irq[1][OMAP_INT_OS_TIMER],
4704 omap_findclk(s, "clk32-kHz"));
4705
4706 s->lcd = omap_lcdc_init(0xfffec000, s->irq[0][OMAP_INT_LCD_CTRL],
4707 omap_dma_get_lcdch(s->dma), ds, imif_base, emiff_base,
4708 omap_findclk(s, "lcd_ck"));
4709
4710 omap_ulpd_pm_init(0xfffe0800, s);
4711 omap_pin_cfg_init(0xfffe1000, s);
4712 omap_id_init(s);
4713
4714 omap_mpui_init(0xfffec900, s);
4715
4716 s->private_tipb = omap_tipb_bridge_init(0xfffeca00,
4717 s->irq[0][OMAP_INT_BRIDGE_PRIV],
4718 omap_findclk(s, "tipb_ck"));
4719 s->public_tipb = omap_tipb_bridge_init(0xfffed300,
4720 s->irq[0][OMAP_INT_BRIDGE_PUB],
4721 omap_findclk(s, "tipb_ck"));
4722
4723 omap_tcmi_init(0xfffecc00, s);
4724
4725 s->uart[0] = omap_uart_init(0xfffb0000, s->irq[1][OMAP_INT_UART1],
4726 omap_findclk(s, "uart1_ck"),
4727 omap_findclk(s, "uart1_ck"),
4728 s->drq[OMAP_DMA_UART1_TX], s->drq[OMAP_DMA_UART1_RX],
4729 serial_hds[0]);
4730 s->uart[1] = omap_uart_init(0xfffb0800, s->irq[1][OMAP_INT_UART2],
4731 omap_findclk(s, "uart2_ck"),
4732 omap_findclk(s, "uart2_ck"),
4733 s->drq[OMAP_DMA_UART2_TX], s->drq[OMAP_DMA_UART2_RX],
4734 serial_hds[0] ? serial_hds[1] : 0);
4735 s->uart[2] = omap_uart_init(0xfffb9800, s->irq[0][OMAP_INT_UART3],
4736 omap_findclk(s, "uart3_ck"),
4737 omap_findclk(s, "uart3_ck"),
4738 s->drq[OMAP_DMA_UART3_TX], s->drq[OMAP_DMA_UART3_RX],
4739 serial_hds[0] && serial_hds[1] ? serial_hds[2] : 0);
4740
4741 omap_dpll_init(&s->dpll[0], 0xfffecf00, omap_findclk(s, "dpll1"));
4742 omap_dpll_init(&s->dpll[1], 0xfffed000, omap_findclk(s, "dpll2"));
4743 omap_dpll_init(&s->dpll[2], 0xfffed100, omap_findclk(s, "dpll3"));
4744
4745 sdindex = drive_get_index(IF_SD, 0, 0);
4746 if (sdindex == -1) {
4747 fprintf(stderr, "qemu: missing SecureDigital device\n");
4748 exit(1);
4749 }
4750 s->mmc = omap_mmc_init(0xfffb7800, drives_table[sdindex].bdrv,
4751 s->irq[1][OMAP_INT_OQN], &s->drq[OMAP_DMA_MMC_TX],
4752 omap_findclk(s, "mmc_ck"));
4753
4754 s->mpuio = omap_mpuio_init(0xfffb5000,
4755 s->irq[1][OMAP_INT_KEYBOARD], s->irq[1][OMAP_INT_MPUIO],
4756 s->wakeup, omap_findclk(s, "clk32-kHz"));
4757
4758 s->gpio = omap_gpio_init(0xfffce000, s->irq[0][OMAP_INT_GPIO_BANK1],
4759 omap_findclk(s, "arm_gpio_ck"));
4760
4761 s->microwire = omap_uwire_init(0xfffb3000, &s->irq[1][OMAP_INT_uWireTX],
4762 s->drq[OMAP_DMA_UWIRE_TX], omap_findclk(s, "mpuper_ck"));
4763
4764 omap_pwl_init(0xfffb5800, s, omap_findclk(s, "armxor_ck"));
4765 omap_pwt_init(0xfffb6000, s, omap_findclk(s, "armxor_ck"));
4766
4767 s->i2c[0] = omap_i2c_init(0xfffb3800, s->irq[1][OMAP_INT_I2C],
4768 &s->drq[OMAP_DMA_I2C_RX], omap_findclk(s, "mpuper_ck"));
4769
4770 s->rtc = omap_rtc_init(0xfffb4800, &s->irq[1][OMAP_INT_RTC_TIMER],
4771 omap_findclk(s, "clk32-kHz"));
4772
4773 s->mcbsp1 = omap_mcbsp_init(0xfffb1800, &s->irq[1][OMAP_INT_McBSP1TX],
4774 &s->drq[OMAP_DMA_MCBSP1_TX], omap_findclk(s, "dspxor_ck"));
4775 s->mcbsp2 = omap_mcbsp_init(0xfffb1000, &s->irq[0][OMAP_INT_310_McBSP2_TX],
4776 &s->drq[OMAP_DMA_MCBSP2_TX], omap_findclk(s, "mpuper_ck"));
4777 s->mcbsp3 = omap_mcbsp_init(0xfffb7000, &s->irq[1][OMAP_INT_McBSP3TX],
4778 &s->drq[OMAP_DMA_MCBSP3_TX], omap_findclk(s, "dspxor_ck"));
4779
4780 s->led[0] = omap_lpg_init(0xfffbd000, omap_findclk(s, "clk32-kHz"));
4781 s->led[1] = omap_lpg_init(0xfffbd800, omap_findclk(s, "clk32-kHz"));
4782
4783 /* Register mappings not currenlty implemented:
4784 * MCSI2 Comm fffb2000 - fffb27ff (not mapped on OMAP310)
4785 * MCSI1 Bluetooth fffb2800 - fffb2fff (not mapped on OMAP310)
4786 * USB W2FC fffb4000 - fffb47ff
4787 * Camera Interface fffb6800 - fffb6fff
4788 * USB Host fffba000 - fffba7ff
4789 * FAC fffba800 - fffbafff
4790 * HDQ/1-Wire fffbc000 - fffbc7ff
4791 * TIPB switches fffbc800 - fffbcfff
4792 * Mailbox fffcf000 - fffcf7ff
4793 * Local bus IF fffec100 - fffec1ff
4794 * Local bus MMU fffec200 - fffec2ff
4795 * DSP MMU fffed200 - fffed2ff
4796 */
4797
4798 omap_setup_dsp_mapping(omap15xx_dsp_mm);
4799 omap_setup_mpui_io(s);
4800
4801 qemu_register_reset(omap1_mpu_reset, s);
4802
4803 return s;
4804 }