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