2 * Marvell MV88W8618 / Freecom MusicPal emulation.
4 * Copyright (c) 2008 Jan Kiszka
6 * This code is licenced under the GNU GPL v2.
16 #include "qemu-timer.h"
20 #include "audio/audio.h"
23 #define MP_MISC_BASE 0x80002000
24 #define MP_MISC_SIZE 0x00001000
26 #define MP_ETH_BASE 0x80008000
27 #define MP_ETH_SIZE 0x00001000
29 #define MP_WLAN_BASE 0x8000C000
30 #define MP_WLAN_SIZE 0x00000800
32 #define MP_UART1_BASE 0x8000C840
33 #define MP_UART2_BASE 0x8000C940
35 #define MP_GPIO_BASE 0x8000D000
36 #define MP_GPIO_SIZE 0x00001000
38 #define MP_FLASHCFG_BASE 0x90006000
39 #define MP_FLASHCFG_SIZE 0x00001000
41 #define MP_AUDIO_BASE 0x90007000
42 #define MP_AUDIO_SIZE 0x00001000
44 #define MP_PIC_BASE 0x90008000
45 #define MP_PIC_SIZE 0x00001000
47 #define MP_PIT_BASE 0x90009000
48 #define MP_PIT_SIZE 0x00001000
50 #define MP_LCD_BASE 0x9000c000
51 #define MP_LCD_SIZE 0x00001000
53 #define MP_SRAM_BASE 0xC0000000
54 #define MP_SRAM_SIZE 0x00020000
56 #define MP_RAM_DEFAULT_SIZE 32*1024*1024
57 #define MP_FLASH_SIZE_MAX 32*1024*1024
59 #define MP_TIMER1_IRQ 4
61 #define MP_TIMER4_IRQ 7
64 #define MP_UART1_IRQ 11
65 #define MP_UART2_IRQ 11
66 #define MP_GPIO_IRQ 12
68 #define MP_AUDIO_IRQ 30
70 static uint32_t gpio_in_state
= 0xffffffff;
71 static uint32_t gpio_isr
;
72 static uint32_t gpio_out_state
;
73 static ram_addr_t sram_off
;
75 typedef enum i2c_state
{
98 typedef struct i2c_interface
{
107 static void i2c_enter_stop(i2c_interface
*i2c
)
109 if (i2c
->current_addr
>= 0)
110 i2c_end_transfer(i2c
->bus
);
111 i2c
->current_addr
= -1;
112 i2c
->state
= STOPPED
;
115 static void i2c_state_update(i2c_interface
*i2c
, int data
, int clock
)
120 switch (i2c
->state
) {
122 if (data
== 0 && i2c
->last_data
== 1 && clock
== 1)
123 i2c
->state
= INITIALIZING
;
127 if (clock
== 0 && i2c
->last_clock
== 1 && data
== 0)
128 i2c
->state
= SENDING_BIT7
;
133 case SENDING_BIT7
... SENDING_BIT0
:
134 if (clock
== 0 && i2c
->last_clock
== 1) {
135 i2c
->buffer
= (i2c
->buffer
<< 1) | data
;
136 i2c
->state
++; /* will end up in WAITING_FOR_ACK */
137 } else if (data
== 1 && i2c
->last_data
== 0 && clock
== 1)
141 case WAITING_FOR_ACK
:
142 if (clock
== 0 && i2c
->last_clock
== 1) {
143 if (i2c
->current_addr
< 0) {
144 i2c
->current_addr
= i2c
->buffer
;
145 i2c_start_transfer(i2c
->bus
, i2c
->current_addr
& 0xfe,
148 i2c_send(i2c
->bus
, i2c
->buffer
);
149 if (i2c
->current_addr
& 1) {
150 i2c
->state
= RECEIVING_BIT7
;
151 i2c
->buffer
= i2c_recv(i2c
->bus
);
153 i2c
->state
= SENDING_BIT7
;
154 } else if (data
== 1 && i2c
->last_data
== 0 && clock
== 1)
158 case RECEIVING_BIT7
... RECEIVING_BIT0
:
159 if (clock
== 0 && i2c
->last_clock
== 1) {
160 i2c
->state
++; /* will end up in SENDING_ACK */
162 } else if (data
== 1 && i2c
->last_data
== 0 && clock
== 1)
167 if (clock
== 0 && i2c
->last_clock
== 1) {
168 i2c
->state
= RECEIVING_BIT7
;
170 i2c
->buffer
= i2c_recv(i2c
->bus
);
173 } else if (data
== 1 && i2c
->last_data
== 0 && clock
== 1)
178 i2c
->last_data
= data
;
179 i2c
->last_clock
= clock
;
182 static int i2c_get_data(i2c_interface
*i2c
)
187 switch (i2c
->state
) {
188 case RECEIVING_BIT7
... RECEIVING_BIT0
:
189 return (i2c
->buffer
>> 7);
191 case WAITING_FOR_ACK
:
197 static i2c_interface
*mixer_i2c
;
201 /* Audio register offsets */
202 #define MP_AUDIO_PLAYBACK_MODE 0x00
203 #define MP_AUDIO_CLOCK_DIV 0x18
204 #define MP_AUDIO_IRQ_STATUS 0x20
205 #define MP_AUDIO_IRQ_ENABLE 0x24
206 #define MP_AUDIO_TX_START_LO 0x28
207 #define MP_AUDIO_TX_THRESHOLD 0x2C
208 #define MP_AUDIO_TX_STATUS 0x38
209 #define MP_AUDIO_TX_START_HI 0x40
211 /* Status register and IRQ enable bits */
212 #define MP_AUDIO_TX_HALF (1 << 6)
213 #define MP_AUDIO_TX_FULL (1 << 7)
215 /* Playback mode bits */
216 #define MP_AUDIO_16BIT_SAMPLE (1 << 0)
217 #define MP_AUDIO_PLAYBACK_EN (1 << 7)
218 #define MP_AUDIO_CLOCK_24MHZ (1 << 9)
219 #define MP_AUDIO_MONO (1 << 14)
221 /* Wolfson 8750 I2C address */
222 #define MP_WM_ADDR 0x34
224 static const char audio_name
[] = "mv88w8618";
226 typedef struct musicpal_audio_state
{
228 uint32_t playback_mode
;
231 unsigned long phys_buf
;
232 uint32_t target_buffer
;
233 unsigned int threshold
;
234 unsigned int play_pos
;
235 unsigned int last_free
;
238 } musicpal_audio_state
;
240 static void audio_callback(void *opaque
, int free_out
, int free_in
)
242 musicpal_audio_state
*s
= opaque
;
243 int16_t *codec_buffer
;
248 if (!(s
->playback_mode
& MP_AUDIO_PLAYBACK_EN
))
251 if (s
->playback_mode
& MP_AUDIO_16BIT_SAMPLE
)
254 if (!(s
->playback_mode
& MP_AUDIO_MONO
))
257 block_size
= s
->threshold
/2;
258 if (free_out
- s
->last_free
< block_size
)
261 if (block_size
> 4096)
264 cpu_physical_memory_read(s
->target_buffer
+ s
->play_pos
, (void *)buf
,
267 if (s
->playback_mode
& MP_AUDIO_16BIT_SAMPLE
) {
268 if (s
->playback_mode
& MP_AUDIO_MONO
) {
269 codec_buffer
= wm8750_dac_buffer(s
->wm
, block_size
>> 1);
270 for (pos
= 0; pos
< block_size
; pos
+= 2) {
271 *codec_buffer
++ = *(int16_t *)mem_buffer
;
272 *codec_buffer
++ = *(int16_t *)mem_buffer
;
276 memcpy(wm8750_dac_buffer(s
->wm
, block_size
>> 2),
277 (uint32_t *)mem_buffer
, block_size
);
279 if (s
->playback_mode
& MP_AUDIO_MONO
) {
280 codec_buffer
= wm8750_dac_buffer(s
->wm
, block_size
);
281 for (pos
= 0; pos
< block_size
; pos
++) {
282 *codec_buffer
++ = cpu_to_le16(256 * *mem_buffer
);
283 *codec_buffer
++ = cpu_to_le16(256 * *mem_buffer
++);
286 codec_buffer
= wm8750_dac_buffer(s
->wm
, block_size
>> 1);
287 for (pos
= 0; pos
< block_size
; pos
+= 2) {
288 *codec_buffer
++ = cpu_to_le16(256 * *mem_buffer
++);
289 *codec_buffer
++ = cpu_to_le16(256 * *mem_buffer
++);
293 wm8750_dac_commit(s
->wm
);
295 s
->last_free
= free_out
- block_size
;
297 if (s
->play_pos
== 0) {
298 s
->status
|= MP_AUDIO_TX_HALF
;
299 s
->play_pos
= block_size
;
301 s
->status
|= MP_AUDIO_TX_FULL
;
305 if (s
->status
& s
->irq_enable
)
306 qemu_irq_raise(s
->irq
);
309 static void musicpal_audio_clock_update(musicpal_audio_state
*s
)
313 if (s
->playback_mode
& MP_AUDIO_CLOCK_24MHZ
)
314 rate
= 24576000 / 64; /* 24.576MHz */
316 rate
= 11289600 / 64; /* 11.2896MHz */
318 rate
/= ((s
->clock_div
>> 8) & 0xff) + 1;
320 wm8750_set_bclk_in(s
->wm
, rate
);
323 static uint32_t musicpal_audio_read(void *opaque
, target_phys_addr_t offset
)
325 musicpal_audio_state
*s
= opaque
;
328 case MP_AUDIO_PLAYBACK_MODE
:
329 return s
->playback_mode
;
331 case MP_AUDIO_CLOCK_DIV
:
334 case MP_AUDIO_IRQ_STATUS
:
337 case MP_AUDIO_IRQ_ENABLE
:
338 return s
->irq_enable
;
340 case MP_AUDIO_TX_STATUS
:
341 return s
->play_pos
>> 2;
348 static void musicpal_audio_write(void *opaque
, target_phys_addr_t offset
,
351 musicpal_audio_state
*s
= opaque
;
354 case MP_AUDIO_PLAYBACK_MODE
:
355 if (value
& MP_AUDIO_PLAYBACK_EN
&&
356 !(s
->playback_mode
& MP_AUDIO_PLAYBACK_EN
)) {
361 s
->playback_mode
= value
;
362 musicpal_audio_clock_update(s
);
365 case MP_AUDIO_CLOCK_DIV
:
366 s
->clock_div
= value
;
369 musicpal_audio_clock_update(s
);
372 case MP_AUDIO_IRQ_STATUS
:
376 case MP_AUDIO_IRQ_ENABLE
:
377 s
->irq_enable
= value
;
378 if (s
->status
& s
->irq_enable
)
379 qemu_irq_raise(s
->irq
);
382 case MP_AUDIO_TX_START_LO
:
383 s
->phys_buf
= (s
->phys_buf
& 0xFFFF0000) | (value
& 0xFFFF);
384 s
->target_buffer
= s
->phys_buf
;
389 case MP_AUDIO_TX_THRESHOLD
:
390 s
->threshold
= (value
+ 1) * 4;
393 case MP_AUDIO_TX_START_HI
:
394 s
->phys_buf
= (s
->phys_buf
& 0xFFFF) | (value
<< 16);
395 s
->target_buffer
= s
->phys_buf
;
402 static void musicpal_audio_reset(void *opaque
)
404 musicpal_audio_state
*s
= opaque
;
406 s
->playback_mode
= 0;
411 static CPUReadMemoryFunc
*musicpal_audio_readfn
[] = {
417 static CPUWriteMemoryFunc
*musicpal_audio_writefn
[] = {
418 musicpal_audio_write
,
419 musicpal_audio_write
,
423 static i2c_interface
*musicpal_audio_init(qemu_irq irq
)
426 musicpal_audio_state
*s
;
432 s
= qemu_mallocz(sizeof(musicpal_audio_state
));
435 i2c
= qemu_mallocz(sizeof(i2c_interface
));
436 i2c
->bus
= i2c_init_bus();
437 i2c
->current_addr
= -1;
439 s
->wm
= wm8750_init(i2c
->bus
, audio
);
442 i2c_set_slave_address(s
->wm
, MP_WM_ADDR
);
443 wm8750_data_req_set(s
->wm
, audio_callback
, s
);
445 iomemtype
= cpu_register_io_memory(0, musicpal_audio_readfn
,
446 musicpal_audio_writefn
, s
);
447 cpu_register_physical_memory(MP_AUDIO_BASE
, MP_AUDIO_SIZE
, iomemtype
);
449 qemu_register_reset(musicpal_audio_reset
, s
);
453 #else /* !HAS_AUDIO */
454 static i2c_interface
*musicpal_audio_init(qemu_irq irq
)
458 #endif /* !HAS_AUDIO */
460 /* Ethernet register offsets */
461 #define MP_ETH_SMIR 0x010
462 #define MP_ETH_PCXR 0x408
463 #define MP_ETH_SDCMR 0x448
464 #define MP_ETH_ICR 0x450
465 #define MP_ETH_IMR 0x458
466 #define MP_ETH_FRDP0 0x480
467 #define MP_ETH_FRDP1 0x484
468 #define MP_ETH_FRDP2 0x488
469 #define MP_ETH_FRDP3 0x48C
470 #define MP_ETH_CRDP0 0x4A0
471 #define MP_ETH_CRDP1 0x4A4
472 #define MP_ETH_CRDP2 0x4A8
473 #define MP_ETH_CRDP3 0x4AC
474 #define MP_ETH_CTDP0 0x4E0
475 #define MP_ETH_CTDP1 0x4E4
476 #define MP_ETH_CTDP2 0x4E8
477 #define MP_ETH_CTDP3 0x4EC
480 #define MP_ETH_SMIR_DATA 0x0000FFFF
481 #define MP_ETH_SMIR_ADDR 0x03FF0000
482 #define MP_ETH_SMIR_OPCODE (1 << 26) /* Read value */
483 #define MP_ETH_SMIR_RDVALID (1 << 27)
486 #define MP_ETH_PHY1_BMSR 0x00210000
487 #define MP_ETH_PHY1_PHYSID1 0x00410000
488 #define MP_ETH_PHY1_PHYSID2 0x00610000
490 #define MP_PHY_BMSR_LINK 0x0004
491 #define MP_PHY_BMSR_AUTONEG 0x0008
493 #define MP_PHY_88E3015 0x01410E20
495 /* TX descriptor status */
496 #define MP_ETH_TX_OWN (1 << 31)
498 /* RX descriptor status */
499 #define MP_ETH_RX_OWN (1 << 31)
501 /* Interrupt cause/mask bits */
502 #define MP_ETH_IRQ_RX_BIT 0
503 #define MP_ETH_IRQ_RX (1 << MP_ETH_IRQ_RX_BIT)
504 #define MP_ETH_IRQ_TXHI_BIT 2
505 #define MP_ETH_IRQ_TXLO_BIT 3
507 /* Port config bits */
508 #define MP_ETH_PCXR_2BSM_BIT 28 /* 2-byte incoming suffix */
510 /* SDMA command bits */
511 #define MP_ETH_CMD_TXHI (1 << 23)
512 #define MP_ETH_CMD_TXLO (1 << 22)
514 typedef struct mv88w8618_tx_desc
{
522 typedef struct mv88w8618_rx_desc
{
525 uint16_t buffer_size
;
530 typedef struct mv88w8618_eth_state
{
537 uint32_t tx_queue
[2];
538 uint32_t rx_queue
[4];
539 uint32_t frx_queue
[4];
542 } mv88w8618_eth_state
;
544 static void eth_rx_desc_put(uint32_t addr
, mv88w8618_rx_desc
*desc
)
546 cpu_to_le32s(&desc
->cmdstat
);
547 cpu_to_le16s(&desc
->bytes
);
548 cpu_to_le16s(&desc
->buffer_size
);
549 cpu_to_le32s(&desc
->buffer
);
550 cpu_to_le32s(&desc
->next
);
551 cpu_physical_memory_write(addr
, (void *)desc
, sizeof(*desc
));
554 static void eth_rx_desc_get(uint32_t addr
, mv88w8618_rx_desc
*desc
)
556 cpu_physical_memory_read(addr
, (void *)desc
, sizeof(*desc
));
557 le32_to_cpus(&desc
->cmdstat
);
558 le16_to_cpus(&desc
->bytes
);
559 le16_to_cpus(&desc
->buffer_size
);
560 le32_to_cpus(&desc
->buffer
);
561 le32_to_cpus(&desc
->next
);
564 static int eth_can_receive(void *opaque
)
569 static void eth_receive(void *opaque
, const uint8_t *buf
, int size
)
571 mv88w8618_eth_state
*s
= opaque
;
573 mv88w8618_rx_desc desc
;
576 for (i
= 0; i
< 4; i
++) {
577 desc_addr
= s
->cur_rx
[i
];
581 eth_rx_desc_get(desc_addr
, &desc
);
582 if ((desc
.cmdstat
& MP_ETH_RX_OWN
) && desc
.buffer_size
>= size
) {
583 cpu_physical_memory_write(desc
.buffer
+ s
->vlan_header
,
585 desc
.bytes
= size
+ s
->vlan_header
;
586 desc
.cmdstat
&= ~MP_ETH_RX_OWN
;
587 s
->cur_rx
[i
] = desc
.next
;
589 s
->icr
|= MP_ETH_IRQ_RX
;
591 qemu_irq_raise(s
->irq
);
592 eth_rx_desc_put(desc_addr
, &desc
);
595 desc_addr
= desc
.next
;
596 } while (desc_addr
!= s
->rx_queue
[i
]);
600 static void eth_tx_desc_put(uint32_t addr
, mv88w8618_tx_desc
*desc
)
602 cpu_to_le32s(&desc
->cmdstat
);
603 cpu_to_le16s(&desc
->res
);
604 cpu_to_le16s(&desc
->bytes
);
605 cpu_to_le32s(&desc
->buffer
);
606 cpu_to_le32s(&desc
->next
);
607 cpu_physical_memory_write(addr
, (void *)desc
, sizeof(*desc
));
610 static void eth_tx_desc_get(uint32_t addr
, mv88w8618_tx_desc
*desc
)
612 cpu_physical_memory_read(addr
, (void *)desc
, sizeof(*desc
));
613 le32_to_cpus(&desc
->cmdstat
);
614 le16_to_cpus(&desc
->res
);
615 le16_to_cpus(&desc
->bytes
);
616 le32_to_cpus(&desc
->buffer
);
617 le32_to_cpus(&desc
->next
);
620 static void eth_send(mv88w8618_eth_state
*s
, int queue_index
)
622 uint32_t desc_addr
= s
->tx_queue
[queue_index
];
623 mv88w8618_tx_desc desc
;
629 eth_tx_desc_get(desc_addr
, &desc
);
630 if (desc
.cmdstat
& MP_ETH_TX_OWN
) {
633 cpu_physical_memory_read(desc
.buffer
, buf
, len
);
634 qemu_send_packet(s
->vc
, buf
, len
);
636 desc
.cmdstat
&= ~MP_ETH_TX_OWN
;
637 s
->icr
|= 1 << (MP_ETH_IRQ_TXLO_BIT
- queue_index
);
638 eth_tx_desc_put(desc_addr
, &desc
);
640 desc_addr
= desc
.next
;
641 } while (desc_addr
!= s
->tx_queue
[queue_index
]);
644 static uint32_t mv88w8618_eth_read(void *opaque
, target_phys_addr_t offset
)
646 mv88w8618_eth_state
*s
= opaque
;
650 if (s
->smir
& MP_ETH_SMIR_OPCODE
) {
651 switch (s
->smir
& MP_ETH_SMIR_ADDR
) {
652 case MP_ETH_PHY1_BMSR
:
653 return MP_PHY_BMSR_LINK
| MP_PHY_BMSR_AUTONEG
|
655 case MP_ETH_PHY1_PHYSID1
:
656 return (MP_PHY_88E3015
>> 16) | MP_ETH_SMIR_RDVALID
;
657 case MP_ETH_PHY1_PHYSID2
:
658 return (MP_PHY_88E3015
& 0xFFFF) | MP_ETH_SMIR_RDVALID
;
660 return MP_ETH_SMIR_RDVALID
;
671 case MP_ETH_FRDP0
... MP_ETH_FRDP3
:
672 return s
->frx_queue
[(offset
- MP_ETH_FRDP0
)/4];
674 case MP_ETH_CRDP0
... MP_ETH_CRDP3
:
675 return s
->rx_queue
[(offset
- MP_ETH_CRDP0
)/4];
677 case MP_ETH_CTDP0
... MP_ETH_CTDP3
:
678 return s
->tx_queue
[(offset
- MP_ETH_CTDP0
)/4];
685 static void mv88w8618_eth_write(void *opaque
, target_phys_addr_t offset
,
688 mv88w8618_eth_state
*s
= opaque
;
696 s
->vlan_header
= ((value
>> MP_ETH_PCXR_2BSM_BIT
) & 1) * 2;
700 if (value
& MP_ETH_CMD_TXHI
)
702 if (value
& MP_ETH_CMD_TXLO
)
704 if (value
& (MP_ETH_CMD_TXHI
| MP_ETH_CMD_TXLO
) && s
->icr
& s
->imr
)
705 qemu_irq_raise(s
->irq
);
715 qemu_irq_raise(s
->irq
);
718 case MP_ETH_FRDP0
... MP_ETH_FRDP3
:
719 s
->frx_queue
[(offset
- MP_ETH_FRDP0
)/4] = value
;
722 case MP_ETH_CRDP0
... MP_ETH_CRDP3
:
723 s
->rx_queue
[(offset
- MP_ETH_CRDP0
)/4] =
724 s
->cur_rx
[(offset
- MP_ETH_CRDP0
)/4] = value
;
727 case MP_ETH_CTDP0
... MP_ETH_CTDP3
:
728 s
->tx_queue
[(offset
- MP_ETH_CTDP0
)/4] = value
;
733 static CPUReadMemoryFunc
*mv88w8618_eth_readfn
[] = {
739 static CPUWriteMemoryFunc
*mv88w8618_eth_writefn
[] = {
745 static void eth_cleanup(VLANClientState
*vc
)
747 mv88w8618_eth_state
*s
= vc
->opaque
;
749 cpu_unregister_io_memory(s
->mmio_index
);
754 static void mv88w8618_eth_init(NICInfo
*nd
, uint32_t base
, qemu_irq irq
)
756 mv88w8618_eth_state
*s
;
758 qemu_check_nic_model(nd
, "mv88w8618");
760 s
= qemu_mallocz(sizeof(mv88w8618_eth_state
));
762 s
->vc
= qemu_new_vlan_client(nd
->vlan
, nd
->model
, nd
->name
,
763 eth_receive
, eth_can_receive
,
765 s
->mmio_index
= cpu_register_io_memory(0, mv88w8618_eth_readfn
,
766 mv88w8618_eth_writefn
, s
);
767 cpu_register_physical_memory(base
, MP_ETH_SIZE
, s
->mmio_index
);
770 /* LCD register offsets */
771 #define MP_LCD_IRQCTRL 0x180
772 #define MP_LCD_IRQSTAT 0x184
773 #define MP_LCD_SPICTRL 0x1ac
774 #define MP_LCD_INST 0x1bc
775 #define MP_LCD_DATA 0x1c0
778 #define MP_LCD_SPI_DATA 0x00100011
779 #define MP_LCD_SPI_CMD 0x00104011
780 #define MP_LCD_SPI_INVALID 0x00000000
783 #define MP_LCD_INST_SETPAGE0 0xB0
785 #define MP_LCD_INST_SETPAGE7 0xB7
787 #define MP_LCD_TEXTCOLOR 0xe0e0ff /* RRGGBB */
789 typedef struct musicpal_lcd_state
{
795 uint8_t video_ram
[128*64/8];
796 } musicpal_lcd_state
;
798 static uint32_t lcd_brightness
;
800 static uint8_t scale_lcd_color(uint8_t col
)
804 switch (lcd_brightness
) {
805 case 0x00000007: /* 0 */
808 case 0x00020000: /* 1 */
809 return (tmp
* 1) / 7;
811 case 0x00020001: /* 2 */
812 return (tmp
* 2) / 7;
814 case 0x00040000: /* 3 */
815 return (tmp
* 3) / 7;
817 case 0x00010006: /* 4 */
818 return (tmp
* 4) / 7;
820 case 0x00020005: /* 5 */
821 return (tmp
* 5) / 7;
823 case 0x00040003: /* 6 */
824 return (tmp
* 6) / 7;
826 case 0x00030004: /* 7 */
832 #define SET_LCD_PIXEL(depth, type) \
833 static inline void glue(set_lcd_pixel, depth) \
834 (musicpal_lcd_state *s, int x, int y, type col) \
837 type *pixel = &((type *) ds_get_data(s->ds))[(y * 128 * 3 + x) * 3]; \
839 for (dy = 0; dy < 3; dy++, pixel += 127 * 3) \
840 for (dx = 0; dx < 3; dx++, pixel++) \
843 SET_LCD_PIXEL(8, uint8_t)
844 SET_LCD_PIXEL(16, uint16_t)
845 SET_LCD_PIXEL(32, uint32_t)
847 #include "pixel_ops.h"
849 static void lcd_refresh(void *opaque
)
851 musicpal_lcd_state
*s
= opaque
;
854 switch (ds_get_bits_per_pixel(s
->ds
)) {
857 #define LCD_REFRESH(depth, func) \
859 col = func(scale_lcd_color((MP_LCD_TEXTCOLOR >> 16) & 0xff), \
860 scale_lcd_color((MP_LCD_TEXTCOLOR >> 8) & 0xff), \
861 scale_lcd_color(MP_LCD_TEXTCOLOR & 0xff)); \
862 for (x = 0; x < 128; x++) \
863 for (y = 0; y < 64; y++) \
864 if (s->video_ram[x + (y/8)*128] & (1 << (y % 8))) \
865 glue(set_lcd_pixel, depth)(s, x, y, col); \
867 glue(set_lcd_pixel, depth)(s, x, y, 0); \
869 LCD_REFRESH(8, rgb_to_pixel8
)
870 LCD_REFRESH(16, rgb_to_pixel16
)
871 LCD_REFRESH(32, (is_surface_bgr(s
->ds
->surface
) ?
872 rgb_to_pixel32bgr
: rgb_to_pixel32
))
874 hw_error("unsupported colour depth %i\n",
875 ds_get_bits_per_pixel(s
->ds
));
878 dpy_update(s
->ds
, 0, 0, 128*3, 64*3);
881 static void lcd_invalidate(void *opaque
)
885 static uint32_t musicpal_lcd_read(void *opaque
, target_phys_addr_t offset
)
887 musicpal_lcd_state
*s
= opaque
;
898 static void musicpal_lcd_write(void *opaque
, target_phys_addr_t offset
,
901 musicpal_lcd_state
*s
= opaque
;
909 if (value
== MP_LCD_SPI_DATA
|| value
== MP_LCD_SPI_CMD
)
912 s
->mode
= MP_LCD_SPI_INVALID
;
916 if (value
>= MP_LCD_INST_SETPAGE0
&& value
<= MP_LCD_INST_SETPAGE7
) {
917 s
->page
= value
- MP_LCD_INST_SETPAGE0
;
923 if (s
->mode
== MP_LCD_SPI_CMD
) {
924 if (value
>= MP_LCD_INST_SETPAGE0
&&
925 value
<= MP_LCD_INST_SETPAGE7
) {
926 s
->page
= value
- MP_LCD_INST_SETPAGE0
;
929 } else if (s
->mode
== MP_LCD_SPI_DATA
) {
930 s
->video_ram
[s
->page
*128 + s
->page_off
] = value
;
931 s
->page_off
= (s
->page_off
+ 1) & 127;
937 static CPUReadMemoryFunc
*musicpal_lcd_readfn
[] = {
943 static CPUWriteMemoryFunc
*musicpal_lcd_writefn
[] = {
949 static void musicpal_lcd_init(void)
951 musicpal_lcd_state
*s
;
954 s
= qemu_mallocz(sizeof(musicpal_lcd_state
));
955 iomemtype
= cpu_register_io_memory(0, musicpal_lcd_readfn
,
956 musicpal_lcd_writefn
, s
);
957 cpu_register_physical_memory(MP_LCD_BASE
, MP_LCD_SIZE
, iomemtype
);
959 s
->ds
= graphic_console_init(lcd_refresh
, lcd_invalidate
,
961 qemu_console_resize(s
->ds
, 128*3, 64*3);
964 /* PIC register offsets */
965 #define MP_PIC_STATUS 0x00
966 #define MP_PIC_ENABLE_SET 0x08
967 #define MP_PIC_ENABLE_CLR 0x0C
969 typedef struct mv88w8618_pic_state
974 } mv88w8618_pic_state
;
976 static void mv88w8618_pic_update(mv88w8618_pic_state
*s
)
978 qemu_set_irq(s
->parent_irq
, (s
->level
& s
->enabled
));
981 static void mv88w8618_pic_set_irq(void *opaque
, int irq
, int level
)
983 mv88w8618_pic_state
*s
= opaque
;
986 s
->level
|= 1 << irq
;
988 s
->level
&= ~(1 << irq
);
989 mv88w8618_pic_update(s
);
992 static uint32_t mv88w8618_pic_read(void *opaque
, target_phys_addr_t offset
)
994 mv88w8618_pic_state
*s
= opaque
;
998 return s
->level
& s
->enabled
;
1005 static void mv88w8618_pic_write(void *opaque
, target_phys_addr_t offset
,
1008 mv88w8618_pic_state
*s
= opaque
;
1011 case MP_PIC_ENABLE_SET
:
1012 s
->enabled
|= value
;
1015 case MP_PIC_ENABLE_CLR
:
1016 s
->enabled
&= ~value
;
1020 mv88w8618_pic_update(s
);
1023 static void mv88w8618_pic_reset(void *opaque
)
1025 mv88w8618_pic_state
*s
= opaque
;
1031 static CPUReadMemoryFunc
*mv88w8618_pic_readfn
[] = {
1037 static CPUWriteMemoryFunc
*mv88w8618_pic_writefn
[] = {
1038 mv88w8618_pic_write
,
1039 mv88w8618_pic_write
,
1043 static qemu_irq
*mv88w8618_pic_init(uint32_t base
, qemu_irq parent_irq
)
1045 mv88w8618_pic_state
*s
;
1049 s
= qemu_mallocz(sizeof(mv88w8618_pic_state
));
1050 qi
= qemu_allocate_irqs(mv88w8618_pic_set_irq
, s
, 32);
1051 s
->parent_irq
= parent_irq
;
1052 iomemtype
= cpu_register_io_memory(0, mv88w8618_pic_readfn
,
1053 mv88w8618_pic_writefn
, s
);
1054 cpu_register_physical_memory(base
, MP_PIC_SIZE
, iomemtype
);
1056 qemu_register_reset(mv88w8618_pic_reset
, s
);
1061 /* PIT register offsets */
1062 #define MP_PIT_TIMER1_LENGTH 0x00
1064 #define MP_PIT_TIMER4_LENGTH 0x0C
1065 #define MP_PIT_CONTROL 0x10
1066 #define MP_PIT_TIMER1_VALUE 0x14
1068 #define MP_PIT_TIMER4_VALUE 0x20
1069 #define MP_BOARD_RESET 0x34
1071 /* Magic board reset value (probably some watchdog behind it) */
1072 #define MP_BOARD_RESET_MAGIC 0x10000
1074 typedef struct mv88w8618_timer_state
{
1075 ptimer_state
*timer
;
1079 } mv88w8618_timer_state
;
1081 typedef struct mv88w8618_pit_state
{
1084 } mv88w8618_pit_state
;
1086 static void mv88w8618_timer_tick(void *opaque
)
1088 mv88w8618_timer_state
*s
= opaque
;
1090 qemu_irq_raise(s
->irq
);
1093 static void *mv88w8618_timer_init(uint32_t freq
, qemu_irq irq
)
1095 mv88w8618_timer_state
*s
;
1098 s
= qemu_mallocz(sizeof(mv88w8618_timer_state
));
1102 bh
= qemu_bh_new(mv88w8618_timer_tick
, s
);
1103 s
->timer
= ptimer_init(bh
);
1108 static uint32_t mv88w8618_pit_read(void *opaque
, target_phys_addr_t offset
)
1110 mv88w8618_pit_state
*s
= opaque
;
1111 mv88w8618_timer_state
*t
;
1114 case MP_PIT_TIMER1_VALUE
... MP_PIT_TIMER4_VALUE
:
1115 t
= s
->timer
[(offset
-MP_PIT_TIMER1_VALUE
) >> 2];
1116 return ptimer_get_count(t
->timer
);
1123 static void mv88w8618_pit_write(void *opaque
, target_phys_addr_t offset
,
1126 mv88w8618_pit_state
*s
= opaque
;
1127 mv88w8618_timer_state
*t
;
1131 case MP_PIT_TIMER1_LENGTH
... MP_PIT_TIMER4_LENGTH
:
1132 t
= s
->timer
[offset
>> 2];
1134 ptimer_set_limit(t
->timer
, t
->limit
, 1);
1137 case MP_PIT_CONTROL
:
1138 for (i
= 0; i
< 4; i
++) {
1141 ptimer_set_limit(t
->timer
, t
->limit
, 0);
1142 ptimer_set_freq(t
->timer
, t
->freq
);
1143 ptimer_run(t
->timer
, 0);
1149 case MP_BOARD_RESET
:
1150 if (value
== MP_BOARD_RESET_MAGIC
)
1151 qemu_system_reset_request();
1156 static CPUReadMemoryFunc
*mv88w8618_pit_readfn
[] = {
1162 static CPUWriteMemoryFunc
*mv88w8618_pit_writefn
[] = {
1163 mv88w8618_pit_write
,
1164 mv88w8618_pit_write
,
1168 static void mv88w8618_pit_init(uint32_t base
, qemu_irq
*pic
, int irq
)
1171 mv88w8618_pit_state
*s
;
1173 s
= qemu_mallocz(sizeof(mv88w8618_pit_state
));
1175 /* Letting them all run at 1 MHz is likely just a pragmatic
1176 * simplification. */
1177 s
->timer
[0] = mv88w8618_timer_init(1000000, pic
[irq
]);
1178 s
->timer
[1] = mv88w8618_timer_init(1000000, pic
[irq
+ 1]);
1179 s
->timer
[2] = mv88w8618_timer_init(1000000, pic
[irq
+ 2]);
1180 s
->timer
[3] = mv88w8618_timer_init(1000000, pic
[irq
+ 3]);
1182 iomemtype
= cpu_register_io_memory(0, mv88w8618_pit_readfn
,
1183 mv88w8618_pit_writefn
, s
);
1184 cpu_register_physical_memory(base
, MP_PIT_SIZE
, iomemtype
);
1187 /* Flash config register offsets */
1188 #define MP_FLASHCFG_CFGR0 0x04
1190 typedef struct mv88w8618_flashcfg_state
{
1192 } mv88w8618_flashcfg_state
;
1194 static uint32_t mv88w8618_flashcfg_read(void *opaque
,
1195 target_phys_addr_t offset
)
1197 mv88w8618_flashcfg_state
*s
= opaque
;
1200 case MP_FLASHCFG_CFGR0
:
1208 static void mv88w8618_flashcfg_write(void *opaque
, target_phys_addr_t offset
,
1211 mv88w8618_flashcfg_state
*s
= opaque
;
1214 case MP_FLASHCFG_CFGR0
:
1220 static CPUReadMemoryFunc
*mv88w8618_flashcfg_readfn
[] = {
1221 mv88w8618_flashcfg_read
,
1222 mv88w8618_flashcfg_read
,
1223 mv88w8618_flashcfg_read
1226 static CPUWriteMemoryFunc
*mv88w8618_flashcfg_writefn
[] = {
1227 mv88w8618_flashcfg_write
,
1228 mv88w8618_flashcfg_write
,
1229 mv88w8618_flashcfg_write
1232 static void mv88w8618_flashcfg_init(uint32_t base
)
1235 mv88w8618_flashcfg_state
*s
;
1237 s
= qemu_mallocz(sizeof(mv88w8618_flashcfg_state
));
1239 s
->cfgr0
= 0xfffe4285; /* Default as set by U-Boot for 8 MB flash */
1240 iomemtype
= cpu_register_io_memory(0, mv88w8618_flashcfg_readfn
,
1241 mv88w8618_flashcfg_writefn
, s
);
1242 cpu_register_physical_memory(base
, MP_FLASHCFG_SIZE
, iomemtype
);
1245 /* Misc register offsets */
1246 #define MP_MISC_BOARD_REVISION 0x18
1248 #define MP_BOARD_REVISION 0x31
1250 static uint32_t musicpal_misc_read(void *opaque
, target_phys_addr_t offset
)
1253 case MP_MISC_BOARD_REVISION
:
1254 return MP_BOARD_REVISION
;
1261 static void musicpal_misc_write(void *opaque
, target_phys_addr_t offset
,
1266 static CPUReadMemoryFunc
*musicpal_misc_readfn
[] = {
1272 static CPUWriteMemoryFunc
*musicpal_misc_writefn
[] = {
1273 musicpal_misc_write
,
1274 musicpal_misc_write
,
1275 musicpal_misc_write
,
1278 static void musicpal_misc_init(void)
1282 iomemtype
= cpu_register_io_memory(0, musicpal_misc_readfn
,
1283 musicpal_misc_writefn
, NULL
);
1284 cpu_register_physical_memory(MP_MISC_BASE
, MP_MISC_SIZE
, iomemtype
);
1287 /* WLAN register offsets */
1288 #define MP_WLAN_MAGIC1 0x11c
1289 #define MP_WLAN_MAGIC2 0x124
1291 static uint32_t mv88w8618_wlan_read(void *opaque
, target_phys_addr_t offset
)
1294 /* Workaround to allow loading the binary-only wlandrv.ko crap
1295 * from the original Freecom firmware. */
1296 case MP_WLAN_MAGIC1
:
1298 case MP_WLAN_MAGIC2
:
1306 static void mv88w8618_wlan_write(void *opaque
, target_phys_addr_t offset
,
1311 static CPUReadMemoryFunc
*mv88w8618_wlan_readfn
[] = {
1312 mv88w8618_wlan_read
,
1313 mv88w8618_wlan_read
,
1314 mv88w8618_wlan_read
,
1317 static CPUWriteMemoryFunc
*mv88w8618_wlan_writefn
[] = {
1318 mv88w8618_wlan_write
,
1319 mv88w8618_wlan_write
,
1320 mv88w8618_wlan_write
,
1323 static void mv88w8618_wlan_init(uint32_t base
)
1327 iomemtype
= cpu_register_io_memory(0, mv88w8618_wlan_readfn
,
1328 mv88w8618_wlan_writefn
, NULL
);
1329 cpu_register_physical_memory(base
, MP_WLAN_SIZE
, iomemtype
);
1332 /* GPIO register offsets */
1333 #define MP_GPIO_OE_LO 0x008
1334 #define MP_GPIO_OUT_LO 0x00c
1335 #define MP_GPIO_IN_LO 0x010
1336 #define MP_GPIO_ISR_LO 0x020
1337 #define MP_GPIO_OE_HI 0x508
1338 #define MP_GPIO_OUT_HI 0x50c
1339 #define MP_GPIO_IN_HI 0x510
1340 #define MP_GPIO_ISR_HI 0x520
1342 /* GPIO bits & masks */
1343 #define MP_GPIO_WHEEL_VOL (1 << 8)
1344 #define MP_GPIO_WHEEL_VOL_INV (1 << 9)
1345 #define MP_GPIO_WHEEL_NAV (1 << 10)
1346 #define MP_GPIO_WHEEL_NAV_INV (1 << 11)
1347 #define MP_GPIO_LCD_BRIGHTNESS 0x00070000
1348 #define MP_GPIO_BTN_FAVORITS (1 << 19)
1349 #define MP_GPIO_BTN_MENU (1 << 20)
1350 #define MP_GPIO_BTN_VOLUME (1 << 21)
1351 #define MP_GPIO_BTN_NAVIGATION (1 << 22)
1352 #define MP_GPIO_I2C_DATA_BIT 29
1353 #define MP_GPIO_I2C_DATA (1 << MP_GPIO_I2C_DATA_BIT)
1354 #define MP_GPIO_I2C_CLOCK_BIT 30
1356 /* LCD brightness bits in GPIO_OE_HI */
1357 #define MP_OE_LCD_BRIGHTNESS 0x0007
1359 static uint32_t musicpal_gpio_read(void *opaque
, target_phys_addr_t offset
)
1362 case MP_GPIO_OE_HI
: /* used for LCD brightness control */
1363 return lcd_brightness
& MP_OE_LCD_BRIGHTNESS
;
1365 case MP_GPIO_OUT_LO
:
1366 return gpio_out_state
& 0xFFFF;
1367 case MP_GPIO_OUT_HI
:
1368 return gpio_out_state
>> 16;
1371 return gpio_in_state
& 0xFFFF;
1373 /* Update received I2C data */
1374 gpio_in_state
= (gpio_in_state
& ~MP_GPIO_I2C_DATA
) |
1375 (i2c_get_data(mixer_i2c
) << MP_GPIO_I2C_DATA_BIT
);
1376 return gpio_in_state
>> 16;
1378 case MP_GPIO_ISR_LO
:
1379 return gpio_isr
& 0xFFFF;
1380 case MP_GPIO_ISR_HI
:
1381 return gpio_isr
>> 16;
1388 static void musicpal_gpio_write(void *opaque
, target_phys_addr_t offset
,
1392 case MP_GPIO_OE_HI
: /* used for LCD brightness control */
1393 lcd_brightness
= (lcd_brightness
& MP_GPIO_LCD_BRIGHTNESS
) |
1394 (value
& MP_OE_LCD_BRIGHTNESS
);
1397 case MP_GPIO_OUT_LO
:
1398 gpio_out_state
= (gpio_out_state
& 0xFFFF0000) | (value
& 0xFFFF);
1400 case MP_GPIO_OUT_HI
:
1401 gpio_out_state
= (gpio_out_state
& 0xFFFF) | (value
<< 16);
1402 lcd_brightness
= (lcd_brightness
& 0xFFFF) |
1403 (gpio_out_state
& MP_GPIO_LCD_BRIGHTNESS
);
1404 i2c_state_update(mixer_i2c
,
1405 (gpio_out_state
>> MP_GPIO_I2C_DATA_BIT
) & 1,
1406 (gpio_out_state
>> MP_GPIO_I2C_CLOCK_BIT
) & 1);
1412 static CPUReadMemoryFunc
*musicpal_gpio_readfn
[] = {
1418 static CPUWriteMemoryFunc
*musicpal_gpio_writefn
[] = {
1419 musicpal_gpio_write
,
1420 musicpal_gpio_write
,
1421 musicpal_gpio_write
,
1424 static void musicpal_gpio_init(void)
1428 iomemtype
= cpu_register_io_memory(0, musicpal_gpio_readfn
,
1429 musicpal_gpio_writefn
, NULL
);
1430 cpu_register_physical_memory(MP_GPIO_BASE
, MP_GPIO_SIZE
, iomemtype
);
1433 /* Keyboard codes & masks */
1434 #define KEY_RELEASED 0x80
1435 #define KEY_CODE 0x7f
1437 #define KEYCODE_TAB 0x0f
1438 #define KEYCODE_ENTER 0x1c
1439 #define KEYCODE_F 0x21
1440 #define KEYCODE_M 0x32
1442 #define KEYCODE_EXTENDED 0xe0
1443 #define KEYCODE_UP 0x48
1444 #define KEYCODE_DOWN 0x50
1445 #define KEYCODE_LEFT 0x4b
1446 #define KEYCODE_RIGHT 0x4d
1448 static void musicpal_key_event(void *opaque
, int keycode
)
1450 qemu_irq irq
= opaque
;
1452 static int kbd_extended
;
1454 if (keycode
== KEYCODE_EXTENDED
) {
1460 switch (keycode
& KEY_CODE
) {
1462 event
= MP_GPIO_WHEEL_NAV
| MP_GPIO_WHEEL_NAV_INV
;
1466 event
= MP_GPIO_WHEEL_NAV
;
1470 event
= MP_GPIO_WHEEL_VOL
| MP_GPIO_WHEEL_VOL_INV
;
1474 event
= MP_GPIO_WHEEL_VOL
;
1478 switch (keycode
& KEY_CODE
) {
1480 event
= MP_GPIO_BTN_FAVORITS
;
1484 event
= MP_GPIO_BTN_VOLUME
;
1488 event
= MP_GPIO_BTN_NAVIGATION
;
1492 event
= MP_GPIO_BTN_MENU
;
1495 /* Do not repeat already pressed buttons */
1496 if (!(keycode
& KEY_RELEASED
) && !(gpio_in_state
& event
))
1501 if (keycode
& KEY_RELEASED
) {
1502 gpio_in_state
|= event
;
1504 gpio_in_state
&= ~event
;
1506 qemu_irq_raise(irq
);
1513 static struct arm_boot_info musicpal_binfo
= {
1514 .loader_start
= 0x0,
1518 static void musicpal_init(ram_addr_t ram_size
, int vga_ram_size
,
1519 const char *boot_device
,
1520 const char *kernel_filename
, const char *kernel_cmdline
,
1521 const char *initrd_filename
, const char *cpu_model
)
1526 unsigned long flash_size
;
1529 cpu_model
= "arm926";
1531 env
= cpu_init(cpu_model
);
1533 fprintf(stderr
, "Unable to find CPU definition\n");
1536 pic
= arm_pic_init_cpu(env
);
1538 /* For now we use a fixed - the original - RAM size */
1539 cpu_register_physical_memory(0, MP_RAM_DEFAULT_SIZE
,
1540 qemu_ram_alloc(MP_RAM_DEFAULT_SIZE
));
1542 sram_off
= qemu_ram_alloc(MP_SRAM_SIZE
);
1543 cpu_register_physical_memory(MP_SRAM_BASE
, MP_SRAM_SIZE
, sram_off
);
1545 pic
= mv88w8618_pic_init(MP_PIC_BASE
, pic
[ARM_PIC_CPU_IRQ
]);
1546 mv88w8618_pit_init(MP_PIT_BASE
, pic
, MP_TIMER1_IRQ
);
1549 serial_mm_init(MP_UART1_BASE
, 2, pic
[MP_UART1_IRQ
], 1825000,
1552 serial_mm_init(MP_UART2_BASE
, 2, pic
[MP_UART2_IRQ
], 1825000,
1555 /* Register flash */
1556 index
= drive_get_index(IF_PFLASH
, 0, 0);
1558 flash_size
= bdrv_getlength(drives_table
[index
].bdrv
);
1559 if (flash_size
!= 8*1024*1024 && flash_size
!= 16*1024*1024 &&
1560 flash_size
!= 32*1024*1024) {
1561 fprintf(stderr
, "Invalid flash image size\n");
1566 * The original U-Boot accesses the flash at 0xFE000000 instead of
1567 * 0xFF800000 (if there is 8 MB flash). So remap flash access if the
1568 * image is smaller than 32 MB.
1570 pflash_cfi02_register(0-MP_FLASH_SIZE_MAX
, qemu_ram_alloc(flash_size
),
1571 drives_table
[index
].bdrv
, 0x10000,
1572 (flash_size
+ 0xffff) >> 16,
1573 MP_FLASH_SIZE_MAX
/ flash_size
,
1574 2, 0x00BF, 0x236D, 0x0000, 0x0000,
1577 mv88w8618_flashcfg_init(MP_FLASHCFG_BASE
);
1579 musicpal_lcd_init();
1581 qemu_add_kbd_event_handler(musicpal_key_event
, pic
[MP_GPIO_IRQ
]);
1583 mv88w8618_eth_init(&nd_table
[0], MP_ETH_BASE
, pic
[MP_ETH_IRQ
]);
1585 mixer_i2c
= musicpal_audio_init(pic
[MP_AUDIO_IRQ
]);
1587 mv88w8618_wlan_init(MP_WLAN_BASE
);
1589 musicpal_misc_init();
1590 musicpal_gpio_init();
1592 musicpal_binfo
.ram_size
= MP_RAM_DEFAULT_SIZE
;
1593 musicpal_binfo
.kernel_filename
= kernel_filename
;
1594 musicpal_binfo
.kernel_cmdline
= kernel_cmdline
;
1595 musicpal_binfo
.initrd_filename
= initrd_filename
;
1596 arm_load_kernel(env
, &musicpal_binfo
);
1599 QEMUMachine musicpal_machine
= {
1601 .desc
= "Marvell 88w8618 / MusicPal (ARM926EJ-S)",
1602 .init
= musicpal_init
,