2008-11-05 21:24:35 +01:00
|
|
|
/*
|
|
|
|
* QEMU SM501 Device
|
|
|
|
*
|
|
|
|
* Copyright (c) 2008 Shin-ichiro KAWASAKI
|
2020-05-21 21:39:44 +02:00
|
|
|
* Copyright (c) 2016-2020 BALATON Zoltan
|
2008-11-05 21:24:35 +01:00
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2016-01-26 19:17:13 +01:00
|
|
|
#include "qemu/osdep.h"
|
2018-06-25 14:41:58 +02:00
|
|
|
#include "qemu/units.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2018-07-04 11:40:58 +02:00
|
|
|
#include "qemu/log.h"
|
2019-05-23 16:35:07 +02:00
|
|
|
#include "qemu/module.h"
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/char/serial.h"
|
2012-11-28 12:06:30 +01:00
|
|
|
#include "ui/console.h"
|
2013-02-04 15:40:22 +01:00
|
|
|
#include "hw/sysbus.h"
|
2019-08-12 07:23:45 +02:00
|
|
|
#include "migration/vmstate.h"
|
2017-04-21 17:18:09 +02:00
|
|
|
#include "hw/pci/pci.h"
|
2019-08-12 07:23:51 +02:00
|
|
|
#include "hw/qdev-properties.h"
|
2018-07-04 11:40:58 +02:00
|
|
|
#include "hw/i2c/i2c.h"
|
2019-03-25 16:59:23 +01:00
|
|
|
#include "hw/display/i2c-ddc.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/range.h"
|
2012-11-28 12:06:30 +01:00
|
|
|
#include "ui/pixel_ops.h"
|
2018-09-19 14:31:14 +02:00
|
|
|
#include "qemu/bswap.h"
|
2020-06-20 22:56:28 +02:00
|
|
|
#include "trace.h"
|
2020-09-03 22:43:22 +02:00
|
|
|
#include "qom/object.h"
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
#define MMIO_BASE_OFFSET 0x3e00000
|
2017-04-21 17:18:09 +02:00
|
|
|
#define MMIO_SIZE 0x200000
|
2017-04-21 17:18:09 +02:00
|
|
|
#define DC_PALETTE_ENTRIES (0x400 * 3)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* SM501 register definitions taken from "linux/include/linux/sm501-regs.h" */
|
|
|
|
|
|
|
|
/* System Configuration area */
|
|
|
|
/* System config base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_SYS_CONFIG (0x000000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* config 1 */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_SYSTEM_CONTROL (0x000000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_SYSCTRL_PANEL_TRISTATE (1 << 0)
|
|
|
|
#define SM501_SYSCTRL_MEM_TRISTATE (1 << 1)
|
|
|
|
#define SM501_SYSCTRL_CRT_TRISTATE (1 << 2)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_SYSCTRL_PCI_SLAVE_BURST_MASK (3 << 4)
|
|
|
|
#define SM501_SYSCTRL_PCI_SLAVE_BURST_1 (0 << 4)
|
|
|
|
#define SM501_SYSCTRL_PCI_SLAVE_BURST_2 (1 << 4)
|
|
|
|
#define SM501_SYSCTRL_PCI_SLAVE_BURST_4 (2 << 4)
|
|
|
|
#define SM501_SYSCTRL_PCI_SLAVE_BURST_8 (3 << 4)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_SYSCTRL_PCI_CLOCK_RUN_EN (1 << 6)
|
|
|
|
#define SM501_SYSCTRL_PCI_RETRY_DISABLE (1 << 7)
|
|
|
|
#define SM501_SYSCTRL_PCI_SUBSYS_LOCK (1 << 11)
|
|
|
|
#define SM501_SYSCTRL_PCI_BURST_READ_EN (1 << 15)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* miscellaneous control */
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_MISC_CONTROL (0x000004)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_MISC_BUS_SH (0x0)
|
|
|
|
#define SM501_MISC_BUS_PCI (0x1)
|
|
|
|
#define SM501_MISC_BUS_XSCALE (0x2)
|
|
|
|
#define SM501_MISC_BUS_NEC (0x6)
|
|
|
|
#define SM501_MISC_BUS_MASK (0x7)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_MISC_VR_62MB (1 << 3)
|
|
|
|
#define SM501_MISC_CDR_RESET (1 << 7)
|
|
|
|
#define SM501_MISC_USB_LB (1 << 8)
|
|
|
|
#define SM501_MISC_USB_SLAVE (1 << 9)
|
|
|
|
#define SM501_MISC_BL_1 (1 << 10)
|
|
|
|
#define SM501_MISC_MC (1 << 11)
|
|
|
|
#define SM501_MISC_DAC_POWER (1 << 12)
|
|
|
|
#define SM501_MISC_IRQ_INVERT (1 << 16)
|
|
|
|
#define SM501_MISC_SH (1 << 17)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_MISC_HOLD_EMPTY (0 << 18)
|
|
|
|
#define SM501_MISC_HOLD_8 (1 << 18)
|
|
|
|
#define SM501_MISC_HOLD_16 (2 << 18)
|
|
|
|
#define SM501_MISC_HOLD_24 (3 << 18)
|
|
|
|
#define SM501_MISC_HOLD_32 (4 << 18)
|
|
|
|
#define SM501_MISC_HOLD_MASK (7 << 18)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_MISC_FREQ_12 (1 << 24)
|
|
|
|
#define SM501_MISC_PNL_24BIT (1 << 25)
|
|
|
|
#define SM501_MISC_8051_LE (1 << 26)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_GPIO31_0_CONTROL (0x000008)
|
|
|
|
#define SM501_GPIO63_32_CONTROL (0x00000C)
|
|
|
|
#define SM501_DRAM_CONTROL (0x000010)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* command list */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_ARBTRTN_CONTROL (0x000014)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* command list */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_COMMAND_LIST_STATUS (0x000024)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* interrupt debug */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_RAW_IRQ_STATUS (0x000028)
|
|
|
|
#define SM501_RAW_IRQ_CLEAR (0x000028)
|
|
|
|
#define SM501_IRQ_STATUS (0x00002C)
|
|
|
|
#define SM501_IRQ_MASK (0x000030)
|
|
|
|
#define SM501_DEBUG_CONTROL (0x000034)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* power management */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_POWERMODE_P2X_SRC (1 << 29)
|
|
|
|
#define SM501_POWERMODE_V2X_SRC (1 << 20)
|
|
|
|
#define SM501_POWERMODE_M_SRC (1 << 12)
|
|
|
|
#define SM501_POWERMODE_M1_SRC (1 << 4)
|
|
|
|
|
|
|
|
#define SM501_CURRENT_GATE (0x000038)
|
|
|
|
#define SM501_CURRENT_CLOCK (0x00003C)
|
|
|
|
#define SM501_POWER_MODE_0_GATE (0x000040)
|
|
|
|
#define SM501_POWER_MODE_0_CLOCK (0x000044)
|
|
|
|
#define SM501_POWER_MODE_1_GATE (0x000048)
|
|
|
|
#define SM501_POWER_MODE_1_CLOCK (0x00004C)
|
|
|
|
#define SM501_SLEEP_MODE_GATE (0x000050)
|
|
|
|
#define SM501_POWER_MODE_CONTROL (0x000054)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* power gates for units within the 501 */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_GATE_HOST (0)
|
|
|
|
#define SM501_GATE_MEMORY (1)
|
|
|
|
#define SM501_GATE_DISPLAY (2)
|
|
|
|
#define SM501_GATE_2D_ENGINE (3)
|
|
|
|
#define SM501_GATE_CSC (4)
|
|
|
|
#define SM501_GATE_ZVPORT (5)
|
|
|
|
#define SM501_GATE_GPIO (6)
|
|
|
|
#define SM501_GATE_UART0 (7)
|
|
|
|
#define SM501_GATE_UART1 (8)
|
|
|
|
#define SM501_GATE_SSP (10)
|
|
|
|
#define SM501_GATE_USB_HOST (11)
|
|
|
|
#define SM501_GATE_USB_GADGET (12)
|
|
|
|
#define SM501_GATE_UCONTROLLER (17)
|
|
|
|
#define SM501_GATE_AC97 (18)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* panel clock */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_CLOCK_P2XCLK (24)
|
2008-11-05 21:24:35 +01:00
|
|
|
/* crt clock */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_CLOCK_V2XCLK (16)
|
2008-11-05 21:24:35 +01:00
|
|
|
/* main clock */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_CLOCK_MCLK (8)
|
2008-11-05 21:24:35 +01:00
|
|
|
/* SDRAM controller clock */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_CLOCK_M1XCLK (0)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* config 2 */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_PCI_MASTER_BASE (0x000058)
|
|
|
|
#define SM501_ENDIAN_CONTROL (0x00005C)
|
|
|
|
#define SM501_DEVICEID (0x000060)
|
2008-11-05 21:24:35 +01:00
|
|
|
/* 0x050100A0 */
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_DEVICEID_SM501 (0x05010000)
|
|
|
|
#define SM501_DEVICEID_IDMASK (0xffff0000)
|
|
|
|
#define SM501_DEVICEID_REVMASK (0x000000ff)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_PLLCLOCK_COUNT (0x000064)
|
|
|
|
#define SM501_MISC_TIMING (0x000068)
|
|
|
|
#define SM501_CURRENT_SDRAM_CLOCK (0x00006C)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_PROGRAMMABLE_PLL_CONTROL (0x000074)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* GPIO base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_GPIO (0x010000)
|
|
|
|
#define SM501_GPIO_DATA_LOW (0x00)
|
|
|
|
#define SM501_GPIO_DATA_HIGH (0x04)
|
|
|
|
#define SM501_GPIO_DDR_LOW (0x08)
|
|
|
|
#define SM501_GPIO_DDR_HIGH (0x0C)
|
|
|
|
#define SM501_GPIO_IRQ_SETUP (0x10)
|
|
|
|
#define SM501_GPIO_IRQ_STATUS (0x14)
|
|
|
|
#define SM501_GPIO_IRQ_RESET (0x14)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* I2C controller base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_I2C (0x010040)
|
|
|
|
#define SM501_I2C_BYTE_COUNT (0x00)
|
|
|
|
#define SM501_I2C_CONTROL (0x01)
|
|
|
|
#define SM501_I2C_STATUS (0x02)
|
|
|
|
#define SM501_I2C_RESET (0x02)
|
|
|
|
#define SM501_I2C_SLAVE_ADDRESS (0x03)
|
|
|
|
#define SM501_I2C_DATA (0x04)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2018-07-04 11:40:58 +02:00
|
|
|
#define SM501_I2C_CONTROL_START (1 << 2)
|
|
|
|
#define SM501_I2C_CONTROL_ENABLE (1 << 0)
|
|
|
|
|
|
|
|
#define SM501_I2C_STATUS_COMPLETE (1 << 3)
|
|
|
|
#define SM501_I2C_STATUS_ERROR (1 << 2)
|
|
|
|
|
|
|
|
#define SM501_I2C_RESET_ERROR (1 << 2)
|
|
|
|
|
2008-11-05 21:24:35 +01:00
|
|
|
/* SSP base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_SSP (0x020000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* Uart 0 base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_UART0 (0x030000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* Uart 1 base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_UART1 (0x030020)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* USB host port base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_USB_HOST (0x040000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* USB slave/gadget base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_USB_GADGET (0x060000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* USB slave/gadget data port base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_USB_GADGET_DATA (0x070000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* Display controller/video engine base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_DC (0x080000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* common defines for the SM501 address registers */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_ADDR_FLIP (1 << 31)
|
|
|
|
#define SM501_ADDR_EXT (1 << 27)
|
|
|
|
#define SM501_ADDR_CS1 (1 << 26)
|
|
|
|
#define SM501_ADDR_MASK (0x3f << 26)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_FIFO_MASK (0x3 << 16)
|
|
|
|
#define SM501_FIFO_1 (0x0 << 16)
|
|
|
|
#define SM501_FIFO_3 (0x1 << 16)
|
|
|
|
#define SM501_FIFO_7 (0x2 << 16)
|
|
|
|
#define SM501_FIFO_11 (0x3 << 16)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* common registers for panel and the crt */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_OFF_DC_H_TOT (0x000)
|
|
|
|
#define SM501_OFF_DC_V_TOT (0x008)
|
|
|
|
#define SM501_OFF_DC_H_SYNC (0x004)
|
|
|
|
#define SM501_OFF_DC_V_SYNC (0x00C)
|
|
|
|
|
|
|
|
#define SM501_DC_PANEL_CONTROL (0x000)
|
|
|
|
|
|
|
|
#define SM501_DC_PANEL_CONTROL_FPEN (1 << 27)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_BIAS (1 << 26)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_DATA (1 << 25)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_VDD (1 << 24)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_DP (1 << 23)
|
|
|
|
|
|
|
|
#define SM501_DC_PANEL_CONTROL_TFT_888 (0 << 21)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_TFT_333 (1 << 21)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_TFT_444 (2 << 21)
|
|
|
|
|
|
|
|
#define SM501_DC_PANEL_CONTROL_DE (1 << 20)
|
|
|
|
|
|
|
|
#define SM501_DC_PANEL_CONTROL_LCD_TFT (0 << 18)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_LCD_STN8 (1 << 18)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_LCD_STN12 (2 << 18)
|
|
|
|
|
|
|
|
#define SM501_DC_PANEL_CONTROL_CP (1 << 14)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_VSP (1 << 13)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_HSP (1 << 12)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_CK (1 << 9)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_TE (1 << 8)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_VPD (1 << 7)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_VP (1 << 6)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_HPD (1 << 5)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_HP (1 << 4)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_GAMMA (1 << 3)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_EN (1 << 2)
|
|
|
|
|
|
|
|
#define SM501_DC_PANEL_CONTROL_8BPP (0 << 0)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_16BPP (1 << 0)
|
|
|
|
#define SM501_DC_PANEL_CONTROL_32BPP (2 << 0)
|
|
|
|
|
|
|
|
|
|
|
|
#define SM501_DC_PANEL_PANNING_CONTROL (0x004)
|
|
|
|
#define SM501_DC_PANEL_COLOR_KEY (0x008)
|
|
|
|
#define SM501_DC_PANEL_FB_ADDR (0x00C)
|
|
|
|
#define SM501_DC_PANEL_FB_OFFSET (0x010)
|
|
|
|
#define SM501_DC_PANEL_FB_WIDTH (0x014)
|
|
|
|
#define SM501_DC_PANEL_FB_HEIGHT (0x018)
|
|
|
|
#define SM501_DC_PANEL_TL_LOC (0x01C)
|
|
|
|
#define SM501_DC_PANEL_BR_LOC (0x020)
|
|
|
|
#define SM501_DC_PANEL_H_TOT (0x024)
|
|
|
|
#define SM501_DC_PANEL_H_SYNC (0x028)
|
|
|
|
#define SM501_DC_PANEL_V_TOT (0x02C)
|
|
|
|
#define SM501_DC_PANEL_V_SYNC (0x030)
|
|
|
|
#define SM501_DC_PANEL_CUR_LINE (0x034)
|
|
|
|
|
|
|
|
#define SM501_DC_VIDEO_CONTROL (0x040)
|
|
|
|
#define SM501_DC_VIDEO_FB0_ADDR (0x044)
|
|
|
|
#define SM501_DC_VIDEO_FB_WIDTH (0x048)
|
|
|
|
#define SM501_DC_VIDEO_FB0_LAST_ADDR (0x04C)
|
|
|
|
#define SM501_DC_VIDEO_TL_LOC (0x050)
|
|
|
|
#define SM501_DC_VIDEO_BR_LOC (0x054)
|
|
|
|
#define SM501_DC_VIDEO_SCALE (0x058)
|
|
|
|
#define SM501_DC_VIDEO_INIT_SCALE (0x05C)
|
|
|
|
#define SM501_DC_VIDEO_YUV_CONSTANTS (0x060)
|
|
|
|
#define SM501_DC_VIDEO_FB1_ADDR (0x064)
|
|
|
|
#define SM501_DC_VIDEO_FB1_LAST_ADDR (0x068)
|
|
|
|
|
|
|
|
#define SM501_DC_VIDEO_ALPHA_CONTROL (0x080)
|
|
|
|
#define SM501_DC_VIDEO_ALPHA_FB_ADDR (0x084)
|
|
|
|
#define SM501_DC_VIDEO_ALPHA_FB_OFFSET (0x088)
|
|
|
|
#define SM501_DC_VIDEO_ALPHA_FB_LAST_ADDR (0x08C)
|
|
|
|
#define SM501_DC_VIDEO_ALPHA_TL_LOC (0x090)
|
|
|
|
#define SM501_DC_VIDEO_ALPHA_BR_LOC (0x094)
|
|
|
|
#define SM501_DC_VIDEO_ALPHA_SCALE (0x098)
|
|
|
|
#define SM501_DC_VIDEO_ALPHA_INIT_SCALE (0x09C)
|
|
|
|
#define SM501_DC_VIDEO_ALPHA_CHROMA_KEY (0x0A0)
|
|
|
|
#define SM501_DC_VIDEO_ALPHA_COLOR_LOOKUP (0x0A4)
|
|
|
|
|
|
|
|
#define SM501_DC_PANEL_HWC_BASE (0x0F0)
|
|
|
|
#define SM501_DC_PANEL_HWC_ADDR (0x0F0)
|
|
|
|
#define SM501_DC_PANEL_HWC_LOC (0x0F4)
|
|
|
|
#define SM501_DC_PANEL_HWC_COLOR_1_2 (0x0F8)
|
|
|
|
#define SM501_DC_PANEL_HWC_COLOR_3 (0x0FC)
|
|
|
|
|
|
|
|
#define SM501_HWC_EN (1 << 31)
|
|
|
|
|
|
|
|
#define SM501_OFF_HWC_ADDR (0x00)
|
|
|
|
#define SM501_OFF_HWC_LOC (0x04)
|
|
|
|
#define SM501_OFF_HWC_COLOR_1_2 (0x08)
|
|
|
|
#define SM501_OFF_HWC_COLOR_3 (0x0C)
|
|
|
|
|
|
|
|
#define SM501_DC_ALPHA_CONTROL (0x100)
|
|
|
|
#define SM501_DC_ALPHA_FB_ADDR (0x104)
|
|
|
|
#define SM501_DC_ALPHA_FB_OFFSET (0x108)
|
|
|
|
#define SM501_DC_ALPHA_TL_LOC (0x10C)
|
|
|
|
#define SM501_DC_ALPHA_BR_LOC (0x110)
|
|
|
|
#define SM501_DC_ALPHA_CHROMA_KEY (0x114)
|
|
|
|
#define SM501_DC_ALPHA_COLOR_LOOKUP (0x118)
|
|
|
|
|
|
|
|
#define SM501_DC_CRT_CONTROL (0x200)
|
|
|
|
|
|
|
|
#define SM501_DC_CRT_CONTROL_TVP (1 << 15)
|
|
|
|
#define SM501_DC_CRT_CONTROL_CP (1 << 14)
|
|
|
|
#define SM501_DC_CRT_CONTROL_VSP (1 << 13)
|
|
|
|
#define SM501_DC_CRT_CONTROL_HSP (1 << 12)
|
|
|
|
#define SM501_DC_CRT_CONTROL_VS (1 << 11)
|
|
|
|
#define SM501_DC_CRT_CONTROL_BLANK (1 << 10)
|
|
|
|
#define SM501_DC_CRT_CONTROL_SEL (1 << 9)
|
|
|
|
#define SM501_DC_CRT_CONTROL_TE (1 << 8)
|
2008-11-05 21:24:35 +01:00
|
|
|
#define SM501_DC_CRT_CONTROL_PIXEL_MASK (0xF << 4)
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_DC_CRT_CONTROL_GAMMA (1 << 3)
|
|
|
|
#define SM501_DC_CRT_CONTROL_ENABLE (1 << 2)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_DC_CRT_CONTROL_8BPP (0 << 0)
|
|
|
|
#define SM501_DC_CRT_CONTROL_16BPP (1 << 0)
|
|
|
|
#define SM501_DC_CRT_CONTROL_32BPP (2 << 0)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_DC_CRT_FB_ADDR (0x204)
|
|
|
|
#define SM501_DC_CRT_FB_OFFSET (0x208)
|
|
|
|
#define SM501_DC_CRT_H_TOT (0x20C)
|
|
|
|
#define SM501_DC_CRT_H_SYNC (0x210)
|
|
|
|
#define SM501_DC_CRT_V_TOT (0x214)
|
|
|
|
#define SM501_DC_CRT_V_SYNC (0x218)
|
|
|
|
#define SM501_DC_CRT_SIGNATURE_ANALYZER (0x21C)
|
|
|
|
#define SM501_DC_CRT_CUR_LINE (0x220)
|
|
|
|
#define SM501_DC_CRT_MONITOR_DETECT (0x224)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_DC_CRT_HWC_BASE (0x230)
|
|
|
|
#define SM501_DC_CRT_HWC_ADDR (0x230)
|
|
|
|
#define SM501_DC_CRT_HWC_LOC (0x234)
|
|
|
|
#define SM501_DC_CRT_HWC_COLOR_1_2 (0x238)
|
|
|
|
#define SM501_DC_CRT_HWC_COLOR_3 (0x23C)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_DC_PANEL_PALETTE (0x400)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_DC_VIDEO_PALETTE (0x800)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_DC_CRT_PALETTE (0xC00)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* Zoom Video port base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_ZVPORT (0x090000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* AC97/I2S base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_AC97 (0x0A0000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* 8051 micro controller base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_UCONTROLLER (0x0B0000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* 8051 micro controller SRAM base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_UCONTROLLER_SRAM (0x0C0000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* DMA base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_DMA (0x0D0000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* 2d engine base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_2D_ENGINE (0x100000)
|
|
|
|
#define SM501_2D_SOURCE (0x00)
|
|
|
|
#define SM501_2D_DESTINATION (0x04)
|
|
|
|
#define SM501_2D_DIMENSION (0x08)
|
|
|
|
#define SM501_2D_CONTROL (0x0C)
|
|
|
|
#define SM501_2D_PITCH (0x10)
|
|
|
|
#define SM501_2D_FOREGROUND (0x14)
|
|
|
|
#define SM501_2D_BACKGROUND (0x18)
|
|
|
|
#define SM501_2D_STRETCH (0x1C)
|
|
|
|
#define SM501_2D_COLOR_COMPARE (0x20)
|
|
|
|
#define SM501_2D_COLOR_COMPARE_MASK (0x24)
|
|
|
|
#define SM501_2D_MASK (0x28)
|
|
|
|
#define SM501_2D_CLIP_TL (0x2C)
|
|
|
|
#define SM501_2D_CLIP_BR (0x30)
|
|
|
|
#define SM501_2D_MONO_PATTERN_LOW (0x34)
|
|
|
|
#define SM501_2D_MONO_PATTERN_HIGH (0x38)
|
|
|
|
#define SM501_2D_WINDOW_WIDTH (0x3C)
|
|
|
|
#define SM501_2D_SOURCE_BASE (0x40)
|
|
|
|
#define SM501_2D_DESTINATION_BASE (0x44)
|
|
|
|
#define SM501_2D_ALPHA (0x48)
|
|
|
|
#define SM501_2D_WRAP (0x4C)
|
|
|
|
#define SM501_2D_STATUS (0x50)
|
|
|
|
|
|
|
|
#define SM501_CSC_Y_SOURCE_BASE (0xC8)
|
|
|
|
#define SM501_CSC_CONSTANTS (0xCC)
|
|
|
|
#define SM501_CSC_Y_SOURCE_X (0xD0)
|
|
|
|
#define SM501_CSC_Y_SOURCE_Y (0xD4)
|
|
|
|
#define SM501_CSC_U_SOURCE_BASE (0xD8)
|
|
|
|
#define SM501_CSC_V_SOURCE_BASE (0xDC)
|
|
|
|
#define SM501_CSC_SOURCE_DIMENSION (0xE0)
|
|
|
|
#define SM501_CSC_SOURCE_PITCH (0xE4)
|
|
|
|
#define SM501_CSC_DESTINATION (0xE8)
|
|
|
|
#define SM501_CSC_DESTINATION_DIMENSION (0xEC)
|
|
|
|
#define SM501_CSC_DESTINATION_PITCH (0xF0)
|
|
|
|
#define SM501_CSC_SCALE_FACTOR (0xF4)
|
|
|
|
#define SM501_CSC_DESTINATION_BASE (0xF8)
|
|
|
|
#define SM501_CSC_CONTROL (0xFC)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* 2d engine data port base */
|
2017-04-21 17:18:09 +02:00
|
|
|
#define SM501_2D_ENGINE_DATA (0x110000)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* end of register definitions */
|
|
|
|
|
2010-01-01 07:59:39 +01:00
|
|
|
#define SM501_HWC_WIDTH (64)
|
|
|
|
#define SM501_HWC_HEIGHT (64)
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* SM501 local memory size taken from "linux/drivers/mfd/sm501.c" */
|
|
|
|
static const uint32_t sm501_mem_local_size[] = {
|
2018-06-25 14:41:57 +02:00
|
|
|
[0] = 4 * MiB,
|
|
|
|
[1] = 8 * MiB,
|
|
|
|
[2] = 16 * MiB,
|
|
|
|
[3] = 32 * MiB,
|
|
|
|
[4] = 64 * MiB,
|
|
|
|
[5] = 2 * MiB,
|
2008-11-05 21:24:35 +01:00
|
|
|
};
|
|
|
|
#define get_local_mem_size(s) sm501_mem_local_size[(s)->local_mem_size_index]
|
|
|
|
|
|
|
|
typedef struct SM501State {
|
|
|
|
/* graphic console status */
|
2013-03-05 15:24:14 +01:00
|
|
|
QemuConsole *con;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* status & internal resources */
|
|
|
|
uint32_t local_mem_size_index;
|
2017-04-21 17:18:09 +02:00
|
|
|
uint8_t *local_mem;
|
2011-10-02 17:56:06 +02:00
|
|
|
MemoryRegion local_mem_region;
|
2017-04-21 17:18:09 +02:00
|
|
|
MemoryRegion mmio_region;
|
|
|
|
MemoryRegion system_config_region;
|
2018-07-04 11:40:58 +02:00
|
|
|
MemoryRegion i2c_region;
|
2017-04-21 17:18:09 +02:00
|
|
|
MemoryRegion disp_ctrl_region;
|
|
|
|
MemoryRegion twoD_engine_region;
|
2008-11-05 21:24:35 +01:00
|
|
|
uint32_t last_width;
|
|
|
|
uint32_t last_height;
|
2018-07-04 11:40:58 +02:00
|
|
|
bool do_full_update; /* perform a full update next time */
|
2018-07-04 11:40:58 +02:00
|
|
|
I2CBus *i2c_bus;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* mmio registers */
|
|
|
|
uint32_t system_control;
|
|
|
|
uint32_t misc_control;
|
|
|
|
uint32_t gpio_31_0_control;
|
|
|
|
uint32_t gpio_63_32_control;
|
|
|
|
uint32_t dram_control;
|
2017-04-21 17:18:09 +02:00
|
|
|
uint32_t arbitration_control;
|
2008-11-05 21:24:35 +01:00
|
|
|
uint32_t irq_mask;
|
|
|
|
uint32_t misc_timing;
|
|
|
|
uint32_t power_mode_control;
|
|
|
|
|
2018-07-04 11:40:58 +02:00
|
|
|
uint8_t i2c_byte_count;
|
|
|
|
uint8_t i2c_status;
|
|
|
|
uint8_t i2c_addr;
|
|
|
|
uint8_t i2c_data[16];
|
|
|
|
|
2008-11-05 21:24:35 +01:00
|
|
|
uint32_t uart0_ier;
|
|
|
|
uint32_t uart0_lcr;
|
|
|
|
uint32_t uart0_mcr;
|
|
|
|
uint32_t uart0_scr;
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
uint8_t dc_palette[DC_PALETTE_ENTRIES];
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
uint32_t dc_panel_control;
|
|
|
|
uint32_t dc_panel_panning_control;
|
|
|
|
uint32_t dc_panel_fb_addr;
|
|
|
|
uint32_t dc_panel_fb_offset;
|
|
|
|
uint32_t dc_panel_fb_width;
|
|
|
|
uint32_t dc_panel_fb_height;
|
|
|
|
uint32_t dc_panel_tl_location;
|
|
|
|
uint32_t dc_panel_br_location;
|
|
|
|
uint32_t dc_panel_h_total;
|
|
|
|
uint32_t dc_panel_h_sync;
|
|
|
|
uint32_t dc_panel_v_total;
|
|
|
|
uint32_t dc_panel_v_sync;
|
|
|
|
|
|
|
|
uint32_t dc_panel_hwc_addr;
|
|
|
|
uint32_t dc_panel_hwc_location;
|
|
|
|
uint32_t dc_panel_hwc_color_1_2;
|
|
|
|
uint32_t dc_panel_hwc_color_3;
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
uint32_t dc_video_control;
|
|
|
|
|
2008-11-05 21:24:35 +01:00
|
|
|
uint32_t dc_crt_control;
|
|
|
|
uint32_t dc_crt_fb_addr;
|
|
|
|
uint32_t dc_crt_fb_offset;
|
|
|
|
uint32_t dc_crt_h_total;
|
|
|
|
uint32_t dc_crt_h_sync;
|
|
|
|
uint32_t dc_crt_v_total;
|
|
|
|
uint32_t dc_crt_v_sync;
|
|
|
|
|
|
|
|
uint32_t dc_crt_hwc_addr;
|
|
|
|
uint32_t dc_crt_hwc_location;
|
|
|
|
uint32_t dc_crt_hwc_color_1_2;
|
|
|
|
uint32_t dc_crt_hwc_color_3;
|
|
|
|
|
2011-01-17 19:29:33 +01:00
|
|
|
uint32_t twoD_source;
|
2010-05-15 14:25:39 +02:00
|
|
|
uint32_t twoD_destination;
|
|
|
|
uint32_t twoD_dimension;
|
|
|
|
uint32_t twoD_control;
|
|
|
|
uint32_t twoD_pitch;
|
|
|
|
uint32_t twoD_foreground;
|
2017-04-21 17:18:09 +02:00
|
|
|
uint32_t twoD_background;
|
2010-05-15 14:25:39 +02:00
|
|
|
uint32_t twoD_stretch;
|
2017-04-21 17:18:09 +02:00
|
|
|
uint32_t twoD_color_compare;
|
2010-05-15 14:25:39 +02:00
|
|
|
uint32_t twoD_color_compare_mask;
|
|
|
|
uint32_t twoD_mask;
|
2017-04-21 17:18:09 +02:00
|
|
|
uint32_t twoD_clip_tl;
|
|
|
|
uint32_t twoD_clip_br;
|
|
|
|
uint32_t twoD_mono_pattern_low;
|
|
|
|
uint32_t twoD_mono_pattern_high;
|
2010-05-15 14:25:39 +02:00
|
|
|
uint32_t twoD_window_width;
|
|
|
|
uint32_t twoD_source_base;
|
|
|
|
uint32_t twoD_destination_base;
|
2017-04-21 17:18:09 +02:00
|
|
|
uint32_t twoD_alpha;
|
|
|
|
uint32_t twoD_wrap;
|
2008-11-05 21:24:35 +01:00
|
|
|
} SM501State;
|
|
|
|
|
|
|
|
static uint32_t get_local_mem_size_index(uint32_t size)
|
|
|
|
{
|
|
|
|
uint32_t norm_size = 0;
|
|
|
|
int i, index = 0;
|
|
|
|
|
2008-12-22 21:33:55 +01:00
|
|
|
for (i = 0; i < ARRAY_SIZE(sm501_mem_local_size); i++) {
|
2017-04-21 17:18:09 +02:00
|
|
|
uint32_t new_size = sm501_mem_local_size[i];
|
|
|
|
if (new_size >= size) {
|
|
|
|
if (norm_size == 0 || norm_size > new_size) {
|
|
|
|
norm_size = new_size;
|
|
|
|
index = i;
|
|
|
|
}
|
|
|
|
}
|
2008-11-05 21:24:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
2018-07-04 11:40:58 +02:00
|
|
|
static ram_addr_t get_fb_addr(SM501State *s, int crt)
|
|
|
|
{
|
|
|
|
return (crt ? s->dc_crt_fb_addr : s->dc_panel_fb_addr) & 0x3FFFFF0;
|
|
|
|
}
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static inline int get_width(SM501State *s, int crt)
|
|
|
|
{
|
|
|
|
int width = crt ? s->dc_crt_h_total : s->dc_panel_h_total;
|
|
|
|
return (width & 0x00000FFF) + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int get_height(SM501State *s, int crt)
|
|
|
|
{
|
|
|
|
int height = crt ? s->dc_crt_v_total : s->dc_panel_v_total;
|
|
|
|
return (height & 0x00000FFF) + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int get_bpp(SM501State *s, int crt)
|
|
|
|
{
|
|
|
|
int bpp = crt ? s->dc_crt_control : s->dc_panel_control;
|
|
|
|
return 1 << (bpp & 3);
|
|
|
|
}
|
|
|
|
|
2010-01-01 07:59:39 +01:00
|
|
|
/**
|
|
|
|
* Check the availability of hardware cursor.
|
|
|
|
* @param crt 0 for PANEL, 1 for CRT.
|
|
|
|
*/
|
|
|
|
static inline int is_hwc_enabled(SM501State *state, int crt)
|
|
|
|
{
|
|
|
|
uint32_t addr = crt ? state->dc_crt_hwc_addr : state->dc_panel_hwc_addr;
|
2017-04-21 17:18:09 +02:00
|
|
|
return addr & SM501_HWC_EN;
|
2010-01-01 07:59:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the address which holds cursor pattern data.
|
|
|
|
* @param crt 0 for PANEL, 1 for CRT.
|
|
|
|
*/
|
2017-04-21 17:18:09 +02:00
|
|
|
static inline uint8_t *get_hwc_address(SM501State *state, int crt)
|
2010-01-01 07:59:39 +01:00
|
|
|
{
|
|
|
|
uint32_t addr = crt ? state->dc_crt_hwc_addr : state->dc_panel_hwc_addr;
|
2017-04-21 17:18:09 +02:00
|
|
|
return state->local_mem + (addr & 0x03FFFFF0);
|
2010-01-01 07:59:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the cursor position in y coordinate.
|
|
|
|
* @param crt 0 for PANEL, 1 for CRT.
|
|
|
|
*/
|
|
|
|
static inline uint32_t get_hwc_y(SM501State *state, int crt)
|
|
|
|
{
|
|
|
|
uint32_t location = crt ? state->dc_crt_hwc_location
|
|
|
|
: state->dc_panel_hwc_location;
|
|
|
|
return (location & 0x07FF0000) >> 16;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the cursor position in x coordinate.
|
|
|
|
* @param crt 0 for PANEL, 1 for CRT.
|
|
|
|
*/
|
|
|
|
static inline uint32_t get_hwc_x(SM501State *state, int crt)
|
|
|
|
{
|
|
|
|
uint32_t location = crt ? state->dc_crt_hwc_location
|
|
|
|
: state->dc_panel_hwc_location;
|
|
|
|
return location & 0x000007FF;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-04-21 17:18:09 +02:00
|
|
|
* Get the hardware cursor palette.
|
2010-01-01 07:59:39 +01:00
|
|
|
* @param crt 0 for PANEL, 1 for CRT.
|
2017-04-21 17:18:09 +02:00
|
|
|
* @param palette pointer to a [3 * 3] array to store color values in
|
2010-01-01 07:59:39 +01:00
|
|
|
*/
|
2017-04-21 17:18:09 +02:00
|
|
|
static inline void get_hwc_palette(SM501State *state, int crt, uint8_t *palette)
|
2010-01-01 07:59:39 +01:00
|
|
|
{
|
2017-04-21 17:18:09 +02:00
|
|
|
int i;
|
|
|
|
uint32_t color_reg;
|
|
|
|
uint16_t rgb565;
|
|
|
|
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
|
|
if (i + 1 == 3) {
|
|
|
|
color_reg = crt ? state->dc_crt_hwc_color_3
|
|
|
|
: state->dc_panel_hwc_color_3;
|
|
|
|
} else {
|
|
|
|
color_reg = crt ? state->dc_crt_hwc_color_1_2
|
|
|
|
: state->dc_panel_hwc_color_1_2;
|
|
|
|
}
|
2010-01-01 07:59:39 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
if (i + 1 == 2) {
|
|
|
|
rgb565 = (color_reg >> 16) & 0xFFFF;
|
|
|
|
} else {
|
|
|
|
rgb565 = color_reg & 0xFFFF;
|
|
|
|
}
|
2018-06-18 23:38:16 +02:00
|
|
|
palette[i * 3 + 0] = ((rgb565 >> 11) * 527 + 23) >> 6; /* r */
|
|
|
|
palette[i * 3 + 1] = (((rgb565 >> 5) & 0x3f) * 259 + 33) >> 6; /* g */
|
|
|
|
palette[i * 3 + 2] = ((rgb565 & 0x1f) * 527 + 23) >> 6; /* b */
|
2010-01-01 07:59:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static inline void hwc_invalidate(SM501State *s, int crt)
|
2010-01-01 07:59:39 +01:00
|
|
|
{
|
2017-04-21 17:18:09 +02:00
|
|
|
int w = get_width(s, crt);
|
|
|
|
int h = get_height(s, crt);
|
|
|
|
int bpp = get_bpp(s, crt);
|
|
|
|
int start = get_hwc_y(s, crt);
|
|
|
|
int end = MIN(h, start + SM501_HWC_HEIGHT) + 1;
|
|
|
|
|
|
|
|
start *= w * bpp;
|
|
|
|
end *= w * bpp;
|
|
|
|
|
2018-07-04 11:40:58 +02:00
|
|
|
memory_region_set_dirty(&s->local_mem_region,
|
|
|
|
get_fb_addr(s, crt) + start, end - start);
|
2010-01-01 07:59:39 +01:00
|
|
|
}
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static void sm501_2d_operation(SM501State *s)
|
2010-05-15 14:25:39 +02:00
|
|
|
{
|
2020-05-21 21:39:44 +02:00
|
|
|
int cmd = (s->twoD_control >> 16) & 0x1F;
|
2020-05-21 21:39:44 +02:00
|
|
|
int rtl = s->twoD_control & BIT(27);
|
2020-06-20 22:56:28 +02:00
|
|
|
int format = (s->twoD_stretch >> 20) & 3;
|
|
|
|
int bypp = 1 << format; /* bytes per pixel */
|
|
|
|
int rop_mode = (s->twoD_control >> 15) & 1; /* 1 for rop2, else rop3 */
|
2018-07-04 11:40:58 +02:00
|
|
|
/* 1 if rop2 source is the pattern, otherwise the source is the bitmap */
|
2020-06-20 22:56:28 +02:00
|
|
|
int rop2_source_is_pattern = (s->twoD_control >> 14) & 1;
|
2018-07-04 11:40:58 +02:00
|
|
|
int rop = s->twoD_control & 0xFF;
|
2020-05-21 21:39:44 +02:00
|
|
|
unsigned int dst_x = (s->twoD_destination >> 16) & 0x01FFF;
|
|
|
|
unsigned int dst_y = s->twoD_destination & 0xFFFF;
|
|
|
|
unsigned int width = (s->twoD_dimension >> 16) & 0x1FFF;
|
|
|
|
unsigned int height = s->twoD_dimension & 0xFFFF;
|
2018-07-04 11:40:58 +02:00
|
|
|
uint32_t dst_base = s->twoD_destination_base & 0x03FFFFFF;
|
2020-05-21 21:39:44 +02:00
|
|
|
unsigned int dst_pitch = (s->twoD_pitch >> 16) & 0x1FFF;
|
2018-07-04 11:40:58 +02:00
|
|
|
int crt = (s->dc_crt_control & SM501_DC_CRT_CONTROL_SEL) ? 1 : 0;
|
|
|
|
int fb_len = get_width(s, crt) * get_height(s, crt) * get_bpp(s, crt);
|
2020-06-24 18:42:18 +02:00
|
|
|
bool overlap = false;
|
2010-05-15 14:25:39 +02:00
|
|
|
|
2020-05-21 21:39:44 +02:00
|
|
|
if ((s->twoD_stretch >> 16) & 0xF) {
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_UNIMP, "sm501: only XY addressing is supported.\n");
|
|
|
|
return;
|
2010-05-15 14:25:39 +02:00
|
|
|
}
|
|
|
|
|
2020-05-21 21:39:44 +02:00
|
|
|
if (s->twoD_source_base & BIT(27) || s->twoD_destination_base & BIT(27)) {
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_UNIMP, "sm501: only local memory is supported.\n");
|
|
|
|
return;
|
2010-05-15 14:25:39 +02:00
|
|
|
}
|
|
|
|
|
2020-05-21 21:39:44 +02:00
|
|
|
if (!dst_pitch) {
|
|
|
|
qemu_log_mask(LOG_GUEST_ERROR, "sm501: Zero dest pitch.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!width || !height) {
|
|
|
|
qemu_log_mask(LOG_GUEST_ERROR, "sm501: Zero size 2D op.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rtl) {
|
|
|
|
dst_x -= width - 1;
|
|
|
|
dst_y -= height - 1;
|
|
|
|
}
|
|
|
|
|
2020-06-20 22:56:28 +02:00
|
|
|
if (dst_base >= get_local_mem_size(s) ||
|
2020-06-20 22:56:28 +02:00
|
|
|
dst_base + (dst_x + width + (dst_y + height) * dst_pitch) * bypp >=
|
|
|
|
get_local_mem_size(s)) {
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_GUEST_ERROR, "sm501: 2D op dest is outside vram.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-05-21 21:39:44 +02:00
|
|
|
switch (cmd) {
|
2020-05-21 21:39:44 +02:00
|
|
|
case 0: /* BitBlt */
|
2020-05-21 21:39:44 +02:00
|
|
|
{
|
2020-05-21 21:39:44 +02:00
|
|
|
static uint32_t tmp_buf[16384];
|
2020-05-21 21:39:44 +02:00
|
|
|
unsigned int src_x = (s->twoD_source >> 16) & 0x01FFF;
|
|
|
|
unsigned int src_y = s->twoD_source & 0xFFFF;
|
2020-05-21 21:39:44 +02:00
|
|
|
uint32_t src_base = s->twoD_source_base & 0x03FFFFFF;
|
2020-05-21 21:39:44 +02:00
|
|
|
unsigned int src_pitch = s->twoD_pitch & 0x1FFF;
|
|
|
|
|
|
|
|
if (!src_pitch) {
|
|
|
|
qemu_log_mask(LOG_GUEST_ERROR, "sm501: Zero src pitch.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rtl) {
|
|
|
|
src_x -= width - 1;
|
|
|
|
src_y -= height - 1;
|
|
|
|
}
|
|
|
|
|
2020-06-20 22:56:28 +02:00
|
|
|
if (src_base >= get_local_mem_size(s) ||
|
2020-06-20 22:56:28 +02:00
|
|
|
src_base + (src_x + width + (src_y + height) * src_pitch) * bypp >=
|
|
|
|
get_local_mem_size(s)) {
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_GUEST_ERROR,
|
|
|
|
"sm501: 2D op src is outside vram.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((rop_mode && rop == 0x5) || (!rop_mode && rop == 0x55)) {
|
|
|
|
/* Invert dest, is there a way to do this with pixman? */
|
|
|
|
unsigned int x, y, i;
|
|
|
|
uint8_t *d = s->local_mem + dst_base;
|
|
|
|
|
|
|
|
for (y = 0; y < height; y++) {
|
2020-06-20 22:56:28 +02:00
|
|
|
i = (dst_x + (dst_y + y) * dst_pitch) * bypp;
|
|
|
|
for (x = 0; x < width; x++, i += bypp) {
|
2020-06-20 22:56:28 +02:00
|
|
|
stn_he_p(&d[i], bypp, ~ldn_he_p(&d[i], bypp));
|
2020-05-21 21:39:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Do copy src for unimplemented ops, better than unpainted area */
|
|
|
|
if ((rop_mode && (rop != 0xc || rop2_source_is_pattern)) ||
|
|
|
|
(!rop_mode && rop != 0xcc)) {
|
|
|
|
qemu_log_mask(LOG_UNIMP,
|
|
|
|
"sm501: rop%d op %x%s not implemented\n",
|
|
|
|
(rop_mode ? 2 : 3), rop,
|
|
|
|
(rop2_source_is_pattern ?
|
|
|
|
" with pattern source" : ""));
|
|
|
|
}
|
2020-06-20 22:56:28 +02:00
|
|
|
/* Ignore no-op blits, some guests seem to do this */
|
|
|
|
if (src_base == dst_base && src_pitch == dst_pitch &&
|
|
|
|
src_x == dst_x && src_y == dst_y) {
|
|
|
|
break;
|
|
|
|
}
|
2020-06-20 22:56:28 +02:00
|
|
|
/* Some clients also do 1 pixel blits, avoid overhead for these */
|
|
|
|
if (width == 1 && height == 1) {
|
|
|
|
unsigned int si = (src_x + src_y * src_pitch) * bypp;
|
|
|
|
unsigned int di = (dst_x + dst_y * dst_pitch) * bypp;
|
|
|
|
stn_he_p(&s->local_mem[dst_base + di], bypp,
|
|
|
|
ldn_he_p(&s->local_mem[src_base + si], bypp));
|
|
|
|
break;
|
|
|
|
}
|
2020-06-24 18:42:18 +02:00
|
|
|
/* If reverse blit do simple check for overlaps */
|
|
|
|
if (rtl && src_base == dst_base && src_pitch == dst_pitch) {
|
|
|
|
overlap = (src_x < dst_x + width && src_x + width > dst_x &&
|
|
|
|
src_y < dst_y + height && src_y + height > dst_y);
|
|
|
|
} else if (rtl) {
|
|
|
|
unsigned int sb, se, db, de;
|
|
|
|
sb = src_base + (src_x + src_y * src_pitch) * bypp;
|
|
|
|
se = sb + (width + (height - 1) * src_pitch) * bypp;
|
|
|
|
db = dst_base + (dst_x + dst_y * dst_pitch) * bypp;
|
|
|
|
de = db + (width + (height - 1) * dst_pitch) * bypp;
|
|
|
|
overlap = (db < se && sb < de);
|
|
|
|
}
|
|
|
|
if (overlap) {
|
|
|
|
/* pixman can't do reverse blit: copy via temporary */
|
|
|
|
int tmp_stride = DIV_ROUND_UP(width * bypp, sizeof(uint32_t));
|
2020-05-21 21:39:44 +02:00
|
|
|
uint32_t *tmp = tmp_buf;
|
|
|
|
|
|
|
|
if (tmp_stride * sizeof(uint32_t) * height > sizeof(tmp_buf)) {
|
|
|
|
tmp = g_malloc(tmp_stride * sizeof(uint32_t) * height);
|
|
|
|
}
|
2020-05-21 21:39:44 +02:00
|
|
|
pixman_blt((uint32_t *)&s->local_mem[src_base], tmp,
|
2020-06-20 22:56:28 +02:00
|
|
|
src_pitch * bypp / sizeof(uint32_t),
|
|
|
|
tmp_stride, 8 * bypp, 8 * bypp,
|
2020-05-21 21:39:44 +02:00
|
|
|
src_x, src_y, 0, 0, width, height);
|
|
|
|
pixman_blt(tmp, (uint32_t *)&s->local_mem[dst_base],
|
|
|
|
tmp_stride,
|
2020-06-20 22:56:28 +02:00
|
|
|
dst_pitch * bypp / sizeof(uint32_t),
|
|
|
|
8 * bypp, 8 * bypp,
|
2020-05-21 21:39:44 +02:00
|
|
|
0, 0, dst_x, dst_y, width, height);
|
2020-06-20 22:56:28 +02:00
|
|
|
if (tmp != tmp_buf) {
|
2020-05-21 21:39:44 +02:00
|
|
|
g_free(tmp);
|
|
|
|
}
|
2020-05-21 21:39:44 +02:00
|
|
|
} else {
|
|
|
|
pixman_blt((uint32_t *)&s->local_mem[src_base],
|
|
|
|
(uint32_t *)&s->local_mem[dst_base],
|
2020-06-20 22:56:28 +02:00
|
|
|
src_pitch * bypp / sizeof(uint32_t),
|
|
|
|
dst_pitch * bypp / sizeof(uint32_t),
|
|
|
|
8 * bypp, 8 * bypp,
|
2020-05-21 21:39:44 +02:00
|
|
|
src_x, src_y, dst_x, dst_y, width, height);
|
|
|
|
}
|
2011-01-17 19:29:33 +01:00
|
|
|
}
|
|
|
|
break;
|
2020-05-21 21:39:44 +02:00
|
|
|
}
|
2020-05-21 21:39:44 +02:00
|
|
|
case 1: /* Rectangle Fill */
|
2020-05-21 21:39:44 +02:00
|
|
|
{
|
|
|
|
uint32_t color = s->twoD_foreground;
|
|
|
|
|
2020-05-21 21:39:44 +02:00
|
|
|
if (format == 2) {
|
2018-09-19 14:31:14 +02:00
|
|
|
color = cpu_to_le32(color);
|
2020-05-21 21:39:44 +02:00
|
|
|
} else if (format == 1) {
|
|
|
|
color = cpu_to_le16(color);
|
2010-05-15 14:25:39 +02:00
|
|
|
}
|
2020-05-21 21:39:44 +02:00
|
|
|
|
2020-06-20 22:56:28 +02:00
|
|
|
if (width == 1 && height == 1) {
|
|
|
|
unsigned int i = (dst_x + dst_y * dst_pitch) * bypp;
|
|
|
|
stn_he_p(&s->local_mem[dst_base + i], bypp, color);
|
|
|
|
} else {
|
|
|
|
pixman_fill((uint32_t *)&s->local_mem[dst_base],
|
|
|
|
dst_pitch * bypp / sizeof(uint32_t),
|
|
|
|
8 * bypp, dst_x, dst_y, width, height, color);
|
|
|
|
}
|
2010-05-15 14:25:39 +02:00
|
|
|
break;
|
2020-05-21 21:39:44 +02:00
|
|
|
}
|
2010-05-15 14:25:39 +02:00
|
|
|
default:
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_UNIMP, "sm501: not implemented 2D operation: %d\n",
|
2020-05-21 21:39:44 +02:00
|
|
|
cmd);
|
2020-05-21 21:39:44 +02:00
|
|
|
return;
|
2010-05-15 14:25:39 +02:00
|
|
|
}
|
2018-07-04 11:40:58 +02:00
|
|
|
|
|
|
|
if (dst_base >= get_fb_addr(s, crt) &&
|
|
|
|
dst_base <= get_fb_addr(s, crt) + fb_len) {
|
2020-05-21 21:39:44 +02:00
|
|
|
int dst_len = MIN(fb_len, ((dst_y + height - 1) * dst_pitch +
|
2020-06-20 22:56:28 +02:00
|
|
|
dst_x + width) * bypp);
|
2018-07-04 11:40:58 +02:00
|
|
|
if (dst_len) {
|
|
|
|
memory_region_set_dirty(&s->local_mem_region, dst_base, dst_len);
|
|
|
|
}
|
|
|
|
}
|
2010-05-15 14:25:39 +02:00
|
|
|
}
|
|
|
|
|
2012-10-23 12:30:10 +02:00
|
|
|
static uint64_t sm501_system_config_read(void *opaque, hwaddr addr,
|
2011-10-02 17:56:06 +02:00
|
|
|
unsigned size)
|
2008-11-05 21:24:35 +01:00
|
|
|
{
|
2017-04-21 17:18:09 +02:00
|
|
|
SM501State *s = (SM501State *)opaque;
|
2008-11-05 21:24:35 +01:00
|
|
|
uint32_t ret = 0;
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
switch (addr) {
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_SYSTEM_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->system_control;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_MISC_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->misc_control;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_GPIO31_0_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->gpio_31_0_control;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_GPIO63_32_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->gpio_63_32_control;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DEVICEID:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = 0x050100A0;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DRAM_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = (s->dram_control & 0x07F107C0) | s->local_mem_size_index << 13;
|
|
|
|
break;
|
2017-04-21 17:18:09 +02:00
|
|
|
case SM501_ARBTRTN_CONTROL:
|
|
|
|
ret = s->arbitration_control;
|
|
|
|
break;
|
2017-12-16 23:57:46 +01:00
|
|
|
case SM501_COMMAND_LIST_STATUS:
|
|
|
|
ret = 0x00180002; /* FIFOs are empty, everything idle */
|
2018-01-18 19:01:19 +01:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_IRQ_MASK:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->irq_mask;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_MISC_TIMING:
|
2017-04-21 17:18:09 +02:00
|
|
|
/* TODO : simulate gate control */
|
|
|
|
ret = s->misc_timing;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_CURRENT_GATE:
|
2017-04-21 17:18:09 +02:00
|
|
|
/* TODO : simulate gate control */
|
|
|
|
ret = 0x00021807;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_CURRENT_CLOCK:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = 0x2A1A0A09;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_POWER_MODE_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->power_mode_control;
|
|
|
|
break;
|
2017-12-16 23:57:46 +01:00
|
|
|
case SM501_ENDIAN_CONTROL:
|
|
|
|
ret = 0; /* Only default little endian mode is supported */
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
default:
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_UNIMP, "sm501: not implemented system config"
|
|
|
|
"register read. addr=%" HWADDR_PRIx "\n", addr);
|
2008-11-05 21:24:35 +01:00
|
|
|
}
|
2020-06-20 22:56:28 +02:00
|
|
|
trace_sm501_system_config_read(addr, ret);
|
2008-11-05 21:24:35 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-10-23 12:30:10 +02:00
|
|
|
static void sm501_system_config_write(void *opaque, hwaddr addr,
|
2011-10-02 17:56:06 +02:00
|
|
|
uint64_t value, unsigned size)
|
2008-11-05 21:24:35 +01:00
|
|
|
{
|
2017-04-21 17:18:09 +02:00
|
|
|
SM501State *s = (SM501State *)opaque;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2020-06-20 22:56:28 +02:00
|
|
|
trace_sm501_system_config_write((uint32_t)addr, (uint32_t)value);
|
2017-04-21 17:18:09 +02:00
|
|
|
switch (addr) {
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_SYSTEM_CONTROL:
|
2018-06-14 02:17:00 +02:00
|
|
|
s->system_control &= 0x10DB0000;
|
|
|
|
s->system_control |= value & 0xEF00B8F7;
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_MISC_CONTROL:
|
2018-06-14 02:17:00 +02:00
|
|
|
s->misc_control &= 0xEF;
|
|
|
|
s->misc_control |= value & 0xFF7FFF10;
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_GPIO31_0_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->gpio_31_0_control = value;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_GPIO63_32_CONTROL:
|
2018-06-14 02:17:00 +02:00
|
|
|
s->gpio_63_32_control = value & 0xFF80FFFF;
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DRAM_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->local_mem_size_index = (value >> 13) & 0x7;
|
|
|
|
/* TODO : check validity of size change */
|
2018-06-14 02:17:00 +02:00
|
|
|
s->dram_control &= 0x80000000;
|
|
|
|
s->dram_control |= value & 0x7FFFFFC3;
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2017-04-21 17:18:09 +02:00
|
|
|
case SM501_ARBTRTN_CONTROL:
|
2018-06-14 02:17:00 +02:00
|
|
|
s->arbitration_control = value & 0x37777777;
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_IRQ_MASK:
|
2018-06-14 02:17:00 +02:00
|
|
|
s->irq_mask = value & 0xFFDF3F5F;
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_MISC_TIMING:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->misc_timing = value & 0xF31F1FFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_POWER_MODE_0_GATE:
|
|
|
|
case SM501_POWER_MODE_1_GATE:
|
|
|
|
case SM501_POWER_MODE_0_CLOCK:
|
|
|
|
case SM501_POWER_MODE_1_CLOCK:
|
2017-04-21 17:18:09 +02:00
|
|
|
/* TODO : simulate gate & clock control */
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_POWER_MODE_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->power_mode_control = value & 0x00000003;
|
|
|
|
break;
|
2017-12-16 23:57:46 +01:00
|
|
|
case SM501_ENDIAN_CONTROL:
|
|
|
|
if (value & 0x00000001) {
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_UNIMP, "sm501: system config big endian mode not"
|
|
|
|
" implemented.\n");
|
2017-12-16 23:57:46 +01:00
|
|
|
}
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
default:
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_UNIMP, "sm501: not implemented system config"
|
|
|
|
"register write. addr=%" HWADDR_PRIx
|
|
|
|
", val=%" PRIx64 "\n", addr, value);
|
2008-11-05 21:24:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-02 17:56:06 +02:00
|
|
|
static const MemoryRegionOps sm501_system_config_ops = {
|
|
|
|
.read = sm501_system_config_read,
|
|
|
|
.write = sm501_system_config_write,
|
|
|
|
.valid = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
2017-04-21 17:18:09 +02:00
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
2008-11-05 21:24:35 +01:00
|
|
|
};
|
|
|
|
|
2018-07-04 11:40:58 +02:00
|
|
|
static uint64_t sm501_i2c_read(void *opaque, hwaddr addr, unsigned size)
|
|
|
|
{
|
|
|
|
SM501State *s = (SM501State *)opaque;
|
|
|
|
uint8_t ret = 0;
|
|
|
|
|
|
|
|
switch (addr) {
|
|
|
|
case SM501_I2C_BYTE_COUNT:
|
|
|
|
ret = s->i2c_byte_count;
|
|
|
|
break;
|
|
|
|
case SM501_I2C_STATUS:
|
|
|
|
ret = s->i2c_status;
|
|
|
|
break;
|
|
|
|
case SM501_I2C_SLAVE_ADDRESS:
|
|
|
|
ret = s->i2c_addr;
|
|
|
|
break;
|
|
|
|
case SM501_I2C_DATA ... SM501_I2C_DATA + 15:
|
|
|
|
ret = s->i2c_data[addr - SM501_I2C_DATA];
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
qemu_log_mask(LOG_UNIMP, "sm501 i2c : not implemented register read."
|
|
|
|
" addr=0x%" HWADDR_PRIx "\n", addr);
|
|
|
|
}
|
2020-06-20 22:56:28 +02:00
|
|
|
trace_sm501_i2c_read((uint32_t)addr, ret);
|
2018-07-04 11:40:58 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sm501_i2c_write(void *opaque, hwaddr addr, uint64_t value,
|
|
|
|
unsigned size)
|
|
|
|
{
|
|
|
|
SM501State *s = (SM501State *)opaque;
|
|
|
|
|
2020-06-20 22:56:28 +02:00
|
|
|
trace_sm501_i2c_write((uint32_t)addr, (uint32_t)value);
|
2018-07-04 11:40:58 +02:00
|
|
|
switch (addr) {
|
|
|
|
case SM501_I2C_BYTE_COUNT:
|
|
|
|
s->i2c_byte_count = value & 0xf;
|
|
|
|
break;
|
|
|
|
case SM501_I2C_CONTROL:
|
|
|
|
if (value & SM501_I2C_CONTROL_ENABLE) {
|
|
|
|
if (value & SM501_I2C_CONTROL_START) {
|
2021-06-17 13:53:23 +02:00
|
|
|
bool is_recv = s->i2c_addr & 1;
|
2018-07-04 11:40:58 +02:00
|
|
|
int res = i2c_start_transfer(s->i2c_bus,
|
|
|
|
s->i2c_addr >> 1,
|
2021-06-17 13:53:23 +02:00
|
|
|
is_recv);
|
2021-06-17 13:53:22 +02:00
|
|
|
if (res) {
|
|
|
|
s->i2c_status |= SM501_I2C_STATUS_ERROR;
|
|
|
|
} else {
|
2018-07-04 11:40:58 +02:00
|
|
|
int i;
|
|
|
|
for (i = 0; i <= s->i2c_byte_count; i++) {
|
2021-06-17 13:53:23 +02:00
|
|
|
if (is_recv) {
|
|
|
|
s->i2c_data[i] = i2c_recv(s->i2c_bus);
|
|
|
|
} else if (i2c_send(s->i2c_bus, s->i2c_data[i]) < 0) {
|
2018-07-15 22:59:21 +02:00
|
|
|
s->i2c_status |= SM501_I2C_STATUS_ERROR;
|
2018-07-04 11:40:58 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (i) {
|
|
|
|
s->i2c_status = SM501_I2C_STATUS_COMPLETE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
i2c_end_transfer(s->i2c_bus);
|
|
|
|
s->i2c_status &= ~SM501_I2C_STATUS_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SM501_I2C_RESET:
|
|
|
|
if ((value & SM501_I2C_RESET_ERROR) == 0) {
|
|
|
|
s->i2c_status &= ~SM501_I2C_STATUS_ERROR;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SM501_I2C_SLAVE_ADDRESS:
|
|
|
|
s->i2c_addr = value & 0xff;
|
|
|
|
break;
|
|
|
|
case SM501_I2C_DATA ... SM501_I2C_DATA + 15:
|
|
|
|
s->i2c_data[addr - SM501_I2C_DATA] = value & 0xff;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
qemu_log_mask(LOG_UNIMP, "sm501 i2c : not implemented register write. "
|
|
|
|
"addr=0x%" HWADDR_PRIx " val=%" PRIx64 "\n", addr, value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static const MemoryRegionOps sm501_i2c_ops = {
|
|
|
|
.read = sm501_i2c_read,
|
|
|
|
.write = sm501_i2c_write,
|
|
|
|
.valid = {
|
|
|
|
.min_access_size = 1,
|
|
|
|
.max_access_size = 1,
|
|
|
|
},
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 1,
|
|
|
|
.max_access_size = 1,
|
|
|
|
},
|
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
|
|
|
};
|
|
|
|
|
2012-10-23 12:30:10 +02:00
|
|
|
static uint32_t sm501_palette_read(void *opaque, hwaddr addr)
|
2008-12-07 20:33:15 +01:00
|
|
|
{
|
2017-04-21 17:18:09 +02:00
|
|
|
SM501State *s = (SM501State *)opaque;
|
2020-06-20 22:56:28 +02:00
|
|
|
|
|
|
|
trace_sm501_palette_read((uint32_t)addr);
|
2008-12-07 20:33:15 +01:00
|
|
|
|
|
|
|
/* TODO : consider BYTE/WORD access */
|
|
|
|
/* TODO : consider endian */
|
|
|
|
|
2010-09-18 07:53:14 +02:00
|
|
|
assert(range_covers_byte(0, 0x400 * 3, addr));
|
2017-04-21 17:18:09 +02:00
|
|
|
return *(uint32_t *)&s->dc_palette[addr];
|
2008-12-07 20:33:15 +01:00
|
|
|
}
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static void sm501_palette_write(void *opaque, hwaddr addr,
|
|
|
|
uint32_t value)
|
2008-12-07 20:33:15 +01:00
|
|
|
{
|
2017-04-21 17:18:09 +02:00
|
|
|
SM501State *s = (SM501State *)opaque;
|
2020-06-20 22:56:28 +02:00
|
|
|
|
|
|
|
trace_sm501_palette_write((uint32_t)addr, value);
|
2008-12-07 20:33:15 +01:00
|
|
|
|
|
|
|
/* TODO : consider BYTE/WORD access */
|
|
|
|
/* TODO : consider endian */
|
|
|
|
|
2010-09-18 07:53:14 +02:00
|
|
|
assert(range_covers_byte(0, 0x400 * 3, addr));
|
2017-04-21 17:18:09 +02:00
|
|
|
*(uint32_t *)&s->dc_palette[addr] = value;
|
2018-07-04 11:40:58 +02:00
|
|
|
s->do_full_update = true;
|
2008-12-07 20:33:15 +01:00
|
|
|
}
|
|
|
|
|
2012-10-23 12:30:10 +02:00
|
|
|
static uint64_t sm501_disp_ctrl_read(void *opaque, hwaddr addr,
|
2011-10-02 17:56:06 +02:00
|
|
|
unsigned size)
|
2008-11-05 21:24:35 +01:00
|
|
|
{
|
2017-04-21 17:18:09 +02:00
|
|
|
SM501State *s = (SM501State *)opaque;
|
2008-11-05 21:24:35 +01:00
|
|
|
uint32_t ret = 0;
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
switch (addr) {
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
case SM501_DC_PANEL_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_panel_control;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_PANNING_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_panel_panning_control;
|
|
|
|
break;
|
2017-12-16 23:57:46 +01:00
|
|
|
case SM501_DC_PANEL_COLOR_KEY:
|
|
|
|
/* Not implemented yet */
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_FB_ADDR:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_panel_fb_addr;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_FB_OFFSET:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_panel_fb_offset;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_FB_WIDTH:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_panel_fb_width;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_FB_HEIGHT:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_panel_fb_height;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_TL_LOC:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_panel_tl_location;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_BR_LOC:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_panel_br_location;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
case SM501_DC_PANEL_H_TOT:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_panel_h_total;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_H_SYNC:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_panel_h_sync;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_V_TOT:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_panel_v_total;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_V_SYNC:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_panel_v_sync;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-12-16 23:57:46 +01:00
|
|
|
case SM501_DC_PANEL_HWC_ADDR:
|
|
|
|
ret = s->dc_panel_hwc_addr;
|
|
|
|
break;
|
|
|
|
case SM501_DC_PANEL_HWC_LOC:
|
|
|
|
ret = s->dc_panel_hwc_location;
|
|
|
|
break;
|
|
|
|
case SM501_DC_PANEL_HWC_COLOR_1_2:
|
|
|
|
ret = s->dc_panel_hwc_color_1_2;
|
|
|
|
break;
|
|
|
|
case SM501_DC_PANEL_HWC_COLOR_3:
|
|
|
|
ret = s->dc_panel_hwc_color_3;
|
|
|
|
break;
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
case SM501_DC_VIDEO_CONTROL:
|
|
|
|
ret = s->dc_video_control;
|
|
|
|
break;
|
|
|
|
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_crt_control;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_FB_ADDR:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_crt_fb_addr;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_FB_OFFSET:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_crt_fb_offset;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_H_TOT:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_crt_h_total;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_H_SYNC:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_crt_h_sync;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_V_TOT:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_crt_v_total;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_V_SYNC:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_crt_v_sync;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
case SM501_DC_CRT_HWC_ADDR:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_crt_hwc_addr;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_HWC_LOC:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_crt_hwc_location;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_HWC_COLOR_1_2:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_crt_hwc_color_1_2;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_HWC_COLOR_3:
|
2017-04-21 17:18:09 +02:00
|
|
|
ret = s->dc_crt_hwc_color_3;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
case SM501_DC_PANEL_PALETTE ... SM501_DC_PANEL_PALETTE + 0x400 * 3 - 4:
|
2008-12-07 20:33:15 +01:00
|
|
|
ret = sm501_palette_read(opaque, addr - SM501_DC_PANEL_PALETTE);
|
|
|
|
break;
|
|
|
|
|
2008-11-05 21:24:35 +01:00
|
|
|
default:
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_UNIMP, "sm501: not implemented disp ctrl register "
|
|
|
|
"read. addr=%" HWADDR_PRIx "\n", addr);
|
2008-11-05 21:24:35 +01:00
|
|
|
}
|
2020-06-20 22:56:28 +02:00
|
|
|
trace_sm501_disp_ctrl_read((uint32_t)addr, ret);
|
2008-11-05 21:24:35 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-10-23 12:30:10 +02:00
|
|
|
static void sm501_disp_ctrl_write(void *opaque, hwaddr addr,
|
2011-10-02 17:56:06 +02:00
|
|
|
uint64_t value, unsigned size)
|
2008-11-05 21:24:35 +01:00
|
|
|
{
|
2017-04-21 17:18:09 +02:00
|
|
|
SM501State *s = (SM501State *)opaque;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2020-06-20 22:56:28 +02:00
|
|
|
trace_sm501_disp_ctrl_write((uint32_t)addr, (uint32_t)value);
|
2017-04-21 17:18:09 +02:00
|
|
|
switch (addr) {
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_control = value & 0x0FFF73FF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_PANNING_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_panning_control = value & 0xFF3FFF3F;
|
|
|
|
break;
|
2017-12-16 23:57:46 +01:00
|
|
|
case SM501_DC_PANEL_COLOR_KEY:
|
|
|
|
/* Not implemented yet */
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_FB_ADDR:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_fb_addr = value & 0x8FFFFFF0;
|
2018-07-04 11:40:58 +02:00
|
|
|
if (value & 0x8000000) {
|
|
|
|
qemu_log_mask(LOG_UNIMP, "Panel external memory not supported\n");
|
|
|
|
}
|
2018-07-09 19:02:36 +02:00
|
|
|
s->do_full_update = true;
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_FB_OFFSET:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_fb_offset = value & 0x3FF03FF0;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_FB_WIDTH:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_fb_width = value & 0x0FFF0FFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_FB_HEIGHT:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_fb_height = value & 0x0FFF0FFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_TL_LOC:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_tl_location = value & 0x07FF07FF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_BR_LOC:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_br_location = value & 0x07FF07FF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
case SM501_DC_PANEL_H_TOT:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_h_total = value & 0x0FFF0FFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_H_SYNC:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_h_sync = value & 0x00FF0FFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_V_TOT:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_v_total = value & 0x0FFF0FFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_V_SYNC:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_v_sync = value & 0x003F0FFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
case SM501_DC_PANEL_HWC_ADDR:
|
2017-04-21 17:18:09 +02:00
|
|
|
value &= 0x8FFFFFF0;
|
|
|
|
if (value != s->dc_panel_hwc_addr) {
|
|
|
|
hwc_invalidate(s, 0);
|
|
|
|
s->dc_panel_hwc_addr = value;
|
|
|
|
}
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_HWC_LOC:
|
2017-04-21 17:18:09 +02:00
|
|
|
value &= 0x0FFF0FFF;
|
|
|
|
if (value != s->dc_panel_hwc_location) {
|
|
|
|
hwc_invalidate(s, 0);
|
|
|
|
s->dc_panel_hwc_location = value;
|
|
|
|
}
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_HWC_COLOR_1_2:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_hwc_color_1_2 = value;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_PANEL_HWC_COLOR_3:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_hwc_color_3 = value & 0x0000FFFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
case SM501_DC_VIDEO_CONTROL:
|
|
|
|
s->dc_video_control = value & 0x00037FFF;
|
|
|
|
break;
|
|
|
|
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_CONTROL:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_crt_control = value & 0x0003FFFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_FB_ADDR:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_crt_fb_addr = value & 0x8FFFFFF0;
|
2018-07-04 11:40:58 +02:00
|
|
|
if (value & 0x8000000) {
|
|
|
|
qemu_log_mask(LOG_UNIMP, "CRT external memory not supported\n");
|
|
|
|
}
|
2018-07-09 19:02:36 +02:00
|
|
|
s->do_full_update = true;
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_FB_OFFSET:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_crt_fb_offset = value & 0x3FF03FF0;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_H_TOT:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_crt_h_total = value & 0x0FFF0FFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_H_SYNC:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_crt_h_sync = value & 0x00FF0FFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_V_TOT:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_crt_v_total = value & 0x0FFF0FFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_V_SYNC:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_crt_v_sync = value & 0x003F0FFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
case SM501_DC_CRT_HWC_ADDR:
|
2017-04-21 17:18:09 +02:00
|
|
|
value &= 0x8FFFFFF0;
|
|
|
|
if (value != s->dc_crt_hwc_addr) {
|
|
|
|
hwc_invalidate(s, 1);
|
|
|
|
s->dc_crt_hwc_addr = value;
|
|
|
|
}
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_HWC_LOC:
|
2017-04-21 17:18:09 +02:00
|
|
|
value &= 0x0FFF0FFF;
|
|
|
|
if (value != s->dc_crt_hwc_location) {
|
|
|
|
hwc_invalidate(s, 1);
|
|
|
|
s->dc_crt_hwc_location = value;
|
|
|
|
}
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_HWC_COLOR_1_2:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_crt_hwc_color_1_2 = value;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
case SM501_DC_CRT_HWC_COLOR_3:
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_crt_hwc_color_3 = value & 0x0000FFFF;
|
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
case SM501_DC_PANEL_PALETTE ... SM501_DC_PANEL_PALETTE + 0x400 * 3 - 4:
|
2008-12-07 20:33:15 +01:00
|
|
|
sm501_palette_write(opaque, addr - SM501_DC_PANEL_PALETTE, value);
|
|
|
|
break;
|
|
|
|
|
2008-11-05 21:24:35 +01:00
|
|
|
default:
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_UNIMP, "sm501: not implemented disp ctrl register "
|
|
|
|
"write. addr=%" HWADDR_PRIx
|
|
|
|
", val=%" PRIx64 "\n", addr, value);
|
2008-11-05 21:24:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-02 17:56:06 +02:00
|
|
|
static const MemoryRegionOps sm501_disp_ctrl_ops = {
|
|
|
|
.read = sm501_disp_ctrl_read,
|
|
|
|
.write = sm501_disp_ctrl_write,
|
|
|
|
.valid = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
2017-04-21 17:18:09 +02:00
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
2008-11-05 21:24:35 +01:00
|
|
|
};
|
|
|
|
|
2012-10-23 12:30:10 +02:00
|
|
|
static uint64_t sm501_2d_engine_read(void *opaque, hwaddr addr,
|
2011-10-02 17:56:06 +02:00
|
|
|
unsigned size)
|
2010-05-15 14:25:39 +02:00
|
|
|
{
|
2017-04-21 17:18:09 +02:00
|
|
|
SM501State *s = (SM501State *)opaque;
|
2010-05-15 14:25:39 +02:00
|
|
|
uint32_t ret = 0;
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
switch (addr) {
|
2017-04-21 17:18:09 +02:00
|
|
|
case SM501_2D_SOURCE:
|
|
|
|
ret = s->twoD_source;
|
|
|
|
break;
|
|
|
|
case SM501_2D_DESTINATION:
|
|
|
|
ret = s->twoD_destination;
|
|
|
|
break;
|
|
|
|
case SM501_2D_DIMENSION:
|
|
|
|
ret = s->twoD_dimension;
|
|
|
|
break;
|
|
|
|
case SM501_2D_CONTROL:
|
|
|
|
ret = s->twoD_control;
|
|
|
|
break;
|
|
|
|
case SM501_2D_PITCH:
|
|
|
|
ret = s->twoD_pitch;
|
|
|
|
break;
|
|
|
|
case SM501_2D_FOREGROUND:
|
|
|
|
ret = s->twoD_foreground;
|
|
|
|
break;
|
|
|
|
case SM501_2D_BACKGROUND:
|
|
|
|
ret = s->twoD_background;
|
|
|
|
break;
|
|
|
|
case SM501_2D_STRETCH:
|
|
|
|
ret = s->twoD_stretch;
|
|
|
|
break;
|
|
|
|
case SM501_2D_COLOR_COMPARE:
|
|
|
|
ret = s->twoD_color_compare;
|
|
|
|
break;
|
|
|
|
case SM501_2D_COLOR_COMPARE_MASK:
|
|
|
|
ret = s->twoD_color_compare_mask;
|
|
|
|
break;
|
|
|
|
case SM501_2D_MASK:
|
|
|
|
ret = s->twoD_mask;
|
|
|
|
break;
|
|
|
|
case SM501_2D_CLIP_TL:
|
|
|
|
ret = s->twoD_clip_tl;
|
|
|
|
break;
|
|
|
|
case SM501_2D_CLIP_BR:
|
|
|
|
ret = s->twoD_clip_br;
|
|
|
|
break;
|
|
|
|
case SM501_2D_MONO_PATTERN_LOW:
|
|
|
|
ret = s->twoD_mono_pattern_low;
|
|
|
|
break;
|
|
|
|
case SM501_2D_MONO_PATTERN_HIGH:
|
|
|
|
ret = s->twoD_mono_pattern_high;
|
|
|
|
break;
|
|
|
|
case SM501_2D_WINDOW_WIDTH:
|
|
|
|
ret = s->twoD_window_width;
|
|
|
|
break;
|
2010-05-15 14:25:39 +02:00
|
|
|
case SM501_2D_SOURCE_BASE:
|
|
|
|
ret = s->twoD_source_base;
|
|
|
|
break;
|
2017-04-21 17:18:09 +02:00
|
|
|
case SM501_2D_DESTINATION_BASE:
|
|
|
|
ret = s->twoD_destination_base;
|
|
|
|
break;
|
|
|
|
case SM501_2D_ALPHA:
|
|
|
|
ret = s->twoD_alpha;
|
|
|
|
break;
|
|
|
|
case SM501_2D_WRAP:
|
|
|
|
ret = s->twoD_wrap;
|
|
|
|
break;
|
|
|
|
case SM501_2D_STATUS:
|
|
|
|
ret = 0; /* Should return interrupt status */
|
|
|
|
break;
|
2010-05-15 14:25:39 +02:00
|
|
|
default:
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_UNIMP, "sm501: not implemented disp ctrl register "
|
|
|
|
"read. addr=%" HWADDR_PRIx "\n", addr);
|
2010-05-15 14:25:39 +02:00
|
|
|
}
|
2020-06-20 22:56:28 +02:00
|
|
|
trace_sm501_2d_engine_read((uint32_t)addr, ret);
|
2010-05-15 14:25:39 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-10-23 12:30:10 +02:00
|
|
|
static void sm501_2d_engine_write(void *opaque, hwaddr addr,
|
2011-10-02 17:56:06 +02:00
|
|
|
uint64_t value, unsigned size)
|
2010-05-15 14:25:39 +02:00
|
|
|
{
|
2017-04-21 17:18:09 +02:00
|
|
|
SM501State *s = (SM501State *)opaque;
|
2010-05-15 14:25:39 +02:00
|
|
|
|
2020-06-20 22:56:28 +02:00
|
|
|
trace_sm501_2d_engine_write((uint32_t)addr, (uint32_t)value);
|
2017-04-21 17:18:09 +02:00
|
|
|
switch (addr) {
|
2011-01-17 19:29:33 +01:00
|
|
|
case SM501_2D_SOURCE:
|
|
|
|
s->twoD_source = value;
|
|
|
|
break;
|
2010-05-15 14:25:39 +02:00
|
|
|
case SM501_2D_DESTINATION:
|
|
|
|
s->twoD_destination = value;
|
|
|
|
break;
|
|
|
|
case SM501_2D_DIMENSION:
|
|
|
|
s->twoD_dimension = value;
|
|
|
|
break;
|
|
|
|
case SM501_2D_CONTROL:
|
|
|
|
s->twoD_control = value;
|
|
|
|
|
|
|
|
/* do 2d operation if start flag is set. */
|
|
|
|
if (value & 0x80000000) {
|
|
|
|
sm501_2d_operation(s);
|
|
|
|
s->twoD_control &= ~0x80000000; /* start flag down */
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
case SM501_2D_PITCH:
|
|
|
|
s->twoD_pitch = value;
|
|
|
|
break;
|
|
|
|
case SM501_2D_FOREGROUND:
|
|
|
|
s->twoD_foreground = value;
|
|
|
|
break;
|
2017-04-21 17:18:09 +02:00
|
|
|
case SM501_2D_BACKGROUND:
|
|
|
|
s->twoD_background = value;
|
|
|
|
break;
|
2010-05-15 14:25:39 +02:00
|
|
|
case SM501_2D_STRETCH:
|
2020-06-20 22:56:28 +02:00
|
|
|
if (((value >> 20) & 3) == 3) {
|
|
|
|
value &= ~BIT(20);
|
|
|
|
}
|
2010-05-15 14:25:39 +02:00
|
|
|
s->twoD_stretch = value;
|
|
|
|
break;
|
2017-04-21 17:18:09 +02:00
|
|
|
case SM501_2D_COLOR_COMPARE:
|
|
|
|
s->twoD_color_compare = value;
|
|
|
|
break;
|
2010-05-15 14:25:39 +02:00
|
|
|
case SM501_2D_COLOR_COMPARE_MASK:
|
|
|
|
s->twoD_color_compare_mask = value;
|
|
|
|
break;
|
|
|
|
case SM501_2D_MASK:
|
|
|
|
s->twoD_mask = value;
|
|
|
|
break;
|
2017-04-21 17:18:09 +02:00
|
|
|
case SM501_2D_CLIP_TL:
|
|
|
|
s->twoD_clip_tl = value;
|
|
|
|
break;
|
|
|
|
case SM501_2D_CLIP_BR:
|
|
|
|
s->twoD_clip_br = value;
|
|
|
|
break;
|
|
|
|
case SM501_2D_MONO_PATTERN_LOW:
|
|
|
|
s->twoD_mono_pattern_low = value;
|
|
|
|
break;
|
|
|
|
case SM501_2D_MONO_PATTERN_HIGH:
|
|
|
|
s->twoD_mono_pattern_high = value;
|
|
|
|
break;
|
2010-05-15 14:25:39 +02:00
|
|
|
case SM501_2D_WINDOW_WIDTH:
|
|
|
|
s->twoD_window_width = value;
|
|
|
|
break;
|
|
|
|
case SM501_2D_SOURCE_BASE:
|
|
|
|
s->twoD_source_base = value;
|
|
|
|
break;
|
|
|
|
case SM501_2D_DESTINATION_BASE:
|
|
|
|
s->twoD_destination_base = value;
|
|
|
|
break;
|
2017-04-21 17:18:09 +02:00
|
|
|
case SM501_2D_ALPHA:
|
|
|
|
s->twoD_alpha = value;
|
|
|
|
break;
|
|
|
|
case SM501_2D_WRAP:
|
|
|
|
s->twoD_wrap = value;
|
|
|
|
break;
|
|
|
|
case SM501_2D_STATUS:
|
|
|
|
/* ignored, writing 0 should clear interrupt status */
|
|
|
|
break;
|
2010-05-15 14:25:39 +02:00
|
|
|
default:
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_UNIMP, "sm501: not implemented 2d engine register "
|
|
|
|
"write. addr=%" HWADDR_PRIx
|
|
|
|
", val=%" PRIx64 "\n", addr, value);
|
2010-05-15 14:25:39 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-02 17:56:06 +02:00
|
|
|
static const MemoryRegionOps sm501_2d_engine_ops = {
|
|
|
|
.read = sm501_2d_engine_read,
|
|
|
|
.write = sm501_2d_engine_write,
|
|
|
|
.valid = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
2017-04-21 17:18:09 +02:00
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
2010-05-15 14:25:39 +02:00
|
|
|
};
|
|
|
|
|
2008-11-05 21:24:35 +01:00
|
|
|
/* draw line functions for all console modes */
|
|
|
|
|
|
|
|
typedef void draw_line_func(uint8_t *d, const uint8_t *s,
|
2017-04-21 17:18:09 +02:00
|
|
|
int width, const uint32_t *pal);
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
typedef void draw_hwc_line_func(uint8_t *d, const uint8_t *s,
|
|
|
|
int width, const uint8_t *palette,
|
|
|
|
int c_x, int c_y);
|
2010-01-01 07:59:39 +01:00
|
|
|
|
2021-02-12 19:06:53 +01:00
|
|
|
static void draw_line8_32(uint8_t *d, const uint8_t *s, int width,
|
|
|
|
const uint32_t *pal)
|
|
|
|
{
|
|
|
|
uint8_t v, r, g, b;
|
|
|
|
do {
|
|
|
|
v = ldub_p(s);
|
|
|
|
r = (pal[v] >> 16) & 0xff;
|
|
|
|
g = (pal[v] >> 8) & 0xff;
|
|
|
|
b = (pal[v] >> 0) & 0xff;
|
|
|
|
*(uint32_t *)d = rgb_to_pixel32(r, g, b);
|
|
|
|
s++;
|
|
|
|
d += 4;
|
|
|
|
} while (--width != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void draw_line16_32(uint8_t *d, const uint8_t *s, int width,
|
|
|
|
const uint32_t *pal)
|
|
|
|
{
|
|
|
|
uint16_t rgb565;
|
|
|
|
uint8_t r, g, b;
|
|
|
|
|
|
|
|
do {
|
|
|
|
rgb565 = lduw_le_p(s);
|
|
|
|
r = (rgb565 >> 8) & 0xf8;
|
|
|
|
g = (rgb565 >> 3) & 0xfc;
|
|
|
|
b = (rgb565 << 3) & 0xf8;
|
|
|
|
*(uint32_t *)d = rgb_to_pixel32(r, g, b);
|
|
|
|
s += 2;
|
|
|
|
d += 4;
|
|
|
|
} while (--width != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void draw_line32_32(uint8_t *d, const uint8_t *s, int width,
|
|
|
|
const uint32_t *pal)
|
|
|
|
{
|
|
|
|
uint8_t r, g, b;
|
|
|
|
|
|
|
|
do {
|
|
|
|
r = s[2];
|
|
|
|
g = s[1];
|
|
|
|
b = s[0];
|
|
|
|
*(uint32_t *)d = rgb_to_pixel32(r, g, b);
|
|
|
|
s += 4;
|
|
|
|
d += 4;
|
|
|
|
} while (--width != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Draw hardware cursor image on the given line.
|
|
|
|
*/
|
|
|
|
static void draw_hwc_line_32(uint8_t *d, const uint8_t *s, int width,
|
|
|
|
const uint8_t *palette, int c_x, int c_y)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
uint8_t r, g, b, v, bitset = 0;
|
|
|
|
|
|
|
|
/* get cursor position */
|
|
|
|
assert(0 <= c_y && c_y < SM501_HWC_HEIGHT);
|
|
|
|
s += SM501_HWC_WIDTH * c_y / 4; /* 4 pixels per byte */
|
|
|
|
d += c_x * 4;
|
|
|
|
|
|
|
|
for (i = 0; i < SM501_HWC_WIDTH && c_x + i < width; i++) {
|
|
|
|
/* get pixel value */
|
|
|
|
if (i % 4 == 0) {
|
|
|
|
bitset = ldub_p(s);
|
|
|
|
s++;
|
|
|
|
}
|
|
|
|
v = bitset & 3;
|
|
|
|
bitset >>= 2;
|
|
|
|
|
|
|
|
/* write pixel */
|
|
|
|
if (v) {
|
|
|
|
v--;
|
|
|
|
r = palette[v * 3 + 0];
|
|
|
|
g = palette[v * 3 + 1];
|
|
|
|
b = palette[v * 3 + 2];
|
|
|
|
*(uint32_t *)d = rgb_to_pixel32(r, g, b);
|
|
|
|
}
|
|
|
|
d += 4;
|
|
|
|
}
|
|
|
|
}
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static void sm501_update_display(void *opaque)
|
2008-11-05 21:24:35 +01:00
|
|
|
{
|
2017-04-21 17:18:09 +02:00
|
|
|
SM501State *s = (SM501State *)opaque;
|
2013-03-05 15:24:14 +01:00
|
|
|
DisplaySurface *surface = qemu_console_surface(s->con);
|
2017-05-09 13:19:28 +02:00
|
|
|
DirtyBitmapSnapshot *snap;
|
2017-04-21 17:18:09 +02:00
|
|
|
int y, c_x = 0, c_y = 0;
|
2017-04-21 17:18:09 +02:00
|
|
|
int crt = (s->dc_crt_control & SM501_DC_CRT_CONTROL_SEL) ? 1 : 0;
|
|
|
|
int width = get_width(s, crt);
|
|
|
|
int height = get_height(s, crt);
|
|
|
|
int src_bpp = get_bpp(s, crt);
|
2013-03-05 15:24:14 +01:00
|
|
|
int dst_bpp = surface_bytes_per_pixel(surface);
|
2017-04-21 17:18:09 +02:00
|
|
|
draw_line_func *draw_line = NULL;
|
|
|
|
draw_hwc_line_func *draw_hwc_line = NULL;
|
2008-11-05 21:24:35 +01:00
|
|
|
int full_update = 0;
|
|
|
|
int y_start = -1;
|
2018-07-04 11:40:58 +02:00
|
|
|
ram_addr_t offset;
|
2017-04-21 17:18:09 +02:00
|
|
|
uint32_t *palette;
|
|
|
|
uint8_t hwc_palette[3 * 3];
|
|
|
|
uint8_t *hwc_src = NULL;
|
|
|
|
|
2021-02-12 19:06:51 +01:00
|
|
|
assert(dst_bpp == 4); /* Output is always 32-bit RGB */
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
if (!((crt ? s->dc_crt_control : s->dc_panel_control)
|
|
|
|
& SM501_DC_CRT_CONTROL_ENABLE)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
palette = (uint32_t *)(crt ? &s->dc_palette[SM501_DC_CRT_PALETTE -
|
|
|
|
SM501_DC_PANEL_PALETTE]
|
|
|
|
: &s->dc_palette[0]);
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* choose draw_line function */
|
2017-04-21 17:18:09 +02:00
|
|
|
switch (src_bpp) {
|
|
|
|
case 1:
|
2021-02-12 19:06:51 +01:00
|
|
|
draw_line = draw_line8_32;
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2017-04-21 17:18:09 +02:00
|
|
|
case 2:
|
2021-02-12 19:06:51 +01:00
|
|
|
draw_line = draw_line16_32;
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2017-04-21 17:18:09 +02:00
|
|
|
case 4:
|
2021-02-12 19:06:51 +01:00
|
|
|
draw_line = draw_line32_32;
|
2017-04-21 17:18:09 +02:00
|
|
|
break;
|
2008-11-05 21:24:35 +01:00
|
|
|
default:
|
2020-05-21 21:39:44 +02:00
|
|
|
qemu_log_mask(LOG_GUEST_ERROR, "sm501: update display"
|
|
|
|
"invalid control register value.\n");
|
|
|
|
return;
|
2008-11-05 21:24:35 +01:00
|
|
|
}
|
|
|
|
|
2010-01-01 07:59:39 +01:00
|
|
|
/* set up to draw hardware cursor */
|
2017-04-21 17:18:09 +02:00
|
|
|
if (is_hwc_enabled(s, crt)) {
|
2010-01-01 07:59:39 +01:00
|
|
|
/* choose cursor draw line function */
|
2021-02-12 19:06:51 +01:00
|
|
|
draw_hwc_line = draw_hwc_line_32;
|
2017-04-21 17:18:09 +02:00
|
|
|
hwc_src = get_hwc_address(s, crt);
|
|
|
|
c_x = get_hwc_x(s, crt);
|
|
|
|
c_y = get_hwc_y(s, crt);
|
|
|
|
get_hwc_palette(s, crt, hwc_palette);
|
2010-01-01 07:59:39 +01:00
|
|
|
}
|
|
|
|
|
2008-11-05 21:24:35 +01:00
|
|
|
/* adjust console size */
|
|
|
|
if (s->last_width != width || s->last_height != height) {
|
2013-03-05 15:24:14 +01:00
|
|
|
qemu_console_resize(s->con, width, height);
|
|
|
|
surface = qemu_console_surface(s->con);
|
2017-04-21 17:18:09 +02:00
|
|
|
s->last_width = width;
|
|
|
|
s->last_height = height;
|
|
|
|
full_update = 1;
|
2008-11-05 21:24:35 +01:00
|
|
|
}
|
|
|
|
|
2018-07-04 11:40:58 +02:00
|
|
|
/* someone else requested a full update */
|
|
|
|
if (s->do_full_update) {
|
|
|
|
s->do_full_update = false;
|
|
|
|
full_update = 1;
|
|
|
|
}
|
|
|
|
|
2008-11-05 21:24:35 +01:00
|
|
|
/* draw each line according to conditions */
|
2018-07-04 11:40:58 +02:00
|
|
|
offset = get_fb_addr(s, crt);
|
2017-05-09 13:19:28 +02:00
|
|
|
snap = memory_region_snapshot_and_clear_dirty(&s->local_mem_region,
|
|
|
|
offset, width * height * src_bpp, DIRTY_MEMORY_VGA);
|
2018-07-04 11:40:58 +02:00
|
|
|
for (y = 0; y < height; y++, offset += width * src_bpp) {
|
2017-04-21 17:18:09 +02:00
|
|
|
int update, update_hwc;
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
/* check if hardware cursor is enabled and we're within its range */
|
|
|
|
update_hwc = draw_hwc_line && c_y <= y && y < c_y + SM501_HWC_HEIGHT;
|
|
|
|
update = full_update || update_hwc;
|
2017-04-21 17:18:09 +02:00
|
|
|
/* check dirty flags for each line */
|
2017-05-09 13:19:28 +02:00
|
|
|
update |= memory_region_snapshot_get_dirty(&s->local_mem_region, snap,
|
|
|
|
offset, width * src_bpp);
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
/* draw line and change status */
|
|
|
|
if (update) {
|
2013-03-05 15:24:14 +01:00
|
|
|
uint8_t *d = surface_data(surface);
|
|
|
|
d += y * width * dst_bpp;
|
2010-01-01 07:59:39 +01:00
|
|
|
|
|
|
|
/* draw graphics layer */
|
2017-04-21 17:18:09 +02:00
|
|
|
draw_line(d, s->local_mem + offset, width, palette);
|
2010-01-01 07:59:39 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
/* draw hardware cursor */
|
2010-01-01 07:59:39 +01:00
|
|
|
if (update_hwc) {
|
2017-04-21 17:18:09 +02:00
|
|
|
draw_hwc_line(d, hwc_src, width, hwc_palette, c_x, y - c_y);
|
2010-01-01 07:59:39 +01:00
|
|
|
}
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
if (y_start < 0) {
|
|
|
|
y_start = y;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (y_start >= 0) {
|
|
|
|
/* flush to display */
|
2013-03-05 15:24:14 +01:00
|
|
|
dpy_gfx_update(s->con, 0, y_start, width, y - y_start);
|
2017-04-21 17:18:09 +02:00
|
|
|
y_start = -1;
|
|
|
|
}
|
|
|
|
}
|
2008-11-05 21:24:35 +01:00
|
|
|
}
|
2017-05-09 13:19:28 +02:00
|
|
|
g_free(snap);
|
2008-11-05 21:24:35 +01:00
|
|
|
|
|
|
|
/* complete flush to display */
|
2017-04-21 17:18:09 +02:00
|
|
|
if (y_start >= 0) {
|
2013-03-05 15:24:14 +01:00
|
|
|
dpy_gfx_update(s->con, 0, y_start, width, y - y_start);
|
2017-04-21 17:18:09 +02:00
|
|
|
}
|
2008-11-05 21:24:35 +01:00
|
|
|
}
|
|
|
|
|
2013-03-13 14:04:18 +01:00
|
|
|
static const GraphicHwOps sm501_ops = {
|
|
|
|
.gfx_update = sm501_update_display,
|
|
|
|
};
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static void sm501_reset(SM501State *s)
|
2008-11-05 21:24:35 +01:00
|
|
|
{
|
2017-04-21 17:18:09 +02:00
|
|
|
s->system_control = 0x00100000; /* 2D engine FIFO empty */
|
|
|
|
/* Bits 17 (SH), 7 (CDR), 6:5 (Test), 2:0 (Bus) are all supposed
|
|
|
|
* to be determined at reset by GPIO lines which set config bits.
|
|
|
|
* We hardwire them:
|
|
|
|
* SH = 0 : Hitachi Ready Polarity == Active Low
|
|
|
|
* CDR = 0 : do not reset clock divider
|
|
|
|
* TEST = 0 : Normal mode (not testing the silicon)
|
|
|
|
* BUS = 0 : Hitachi SH3/SH4
|
|
|
|
*/
|
|
|
|
s->misc_control = SM501_MISC_DAC_POWER;
|
2017-04-21 17:18:09 +02:00
|
|
|
s->gpio_31_0_control = 0;
|
|
|
|
s->gpio_63_32_control = 0;
|
|
|
|
s->dram_control = 0;
|
2017-04-21 17:18:09 +02:00
|
|
|
s->arbitration_control = 0x05146732;
|
2017-04-21 17:18:09 +02:00
|
|
|
s->irq_mask = 0;
|
|
|
|
s->misc_timing = 0;
|
|
|
|
s->power_mode_control = 0;
|
2018-07-04 11:40:58 +02:00
|
|
|
s->i2c_byte_count = 0;
|
|
|
|
s->i2c_status = 0;
|
|
|
|
s->i2c_addr = 0;
|
|
|
|
memset(s->i2c_data, 0, 16);
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_panel_control = 0x00010000; /* FIFO level 3 */
|
2017-04-21 17:18:09 +02:00
|
|
|
s->dc_video_control = 0;
|
2008-11-05 21:24:35 +01:00
|
|
|
s->dc_crt_control = 0x00010000;
|
2017-04-21 17:18:09 +02:00
|
|
|
s->twoD_source = 0;
|
|
|
|
s->twoD_destination = 0;
|
|
|
|
s->twoD_dimension = 0;
|
2017-04-21 17:18:09 +02:00
|
|
|
s->twoD_control = 0;
|
2017-04-21 17:18:09 +02:00
|
|
|
s->twoD_pitch = 0;
|
|
|
|
s->twoD_foreground = 0;
|
|
|
|
s->twoD_background = 0;
|
|
|
|
s->twoD_stretch = 0;
|
|
|
|
s->twoD_color_compare = 0;
|
|
|
|
s->twoD_color_compare_mask = 0;
|
|
|
|
s->twoD_mask = 0;
|
|
|
|
s->twoD_clip_tl = 0;
|
|
|
|
s->twoD_clip_br = 0;
|
|
|
|
s->twoD_mono_pattern_low = 0;
|
|
|
|
s->twoD_mono_pattern_high = 0;
|
|
|
|
s->twoD_window_width = 0;
|
|
|
|
s->twoD_source_base = 0;
|
|
|
|
s->twoD_destination_base = 0;
|
|
|
|
s->twoD_alpha = 0;
|
|
|
|
s->twoD_wrap = 0;
|
2017-04-21 17:18:09 +02:00
|
|
|
}
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static void sm501_init(SM501State *s, DeviceState *dev,
|
2017-04-21 17:18:09 +02:00
|
|
|
uint32_t local_mem_bytes)
|
|
|
|
{
|
|
|
|
s->local_mem_size_index = get_local_mem_size_index(local_mem_bytes);
|
|
|
|
|
|
|
|
/* local memory */
|
2017-07-17 18:37:42 +02:00
|
|
|
memory_region_init_ram(&s->local_mem_region, OBJECT(dev), "sm501.local",
|
2017-04-21 17:18:09 +02:00
|
|
|
get_local_mem_size(s), &error_fatal);
|
2015-03-23 10:47:45 +01:00
|
|
|
memory_region_set_log(&s->local_mem_region, true, DIRTY_MEMORY_VGA);
|
2011-10-02 17:56:06 +02:00
|
|
|
s->local_mem = memory_region_get_ram_ptr(&s->local_mem_region);
|
2017-04-21 17:18:09 +02:00
|
|
|
|
2018-07-04 11:40:58 +02:00
|
|
|
/* i2c */
|
|
|
|
s->i2c_bus = i2c_init_bus(dev, "sm501.i2c");
|
|
|
|
/* ddc */
|
2020-06-10 07:31:59 +02:00
|
|
|
I2CDDCState *ddc = I2CDDC(qdev_new(TYPE_I2CDDC));
|
2021-06-17 13:53:31 +02:00
|
|
|
i2c_slave_set_address(I2C_SLAVE(ddc), 0x50);
|
2020-06-10 07:31:59 +02:00
|
|
|
qdev_realize_and_unref(DEVICE(ddc), BUS(s->i2c_bus), &error_abort);
|
2018-07-04 11:40:58 +02:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
/* mmio */
|
|
|
|
memory_region_init(&s->mmio_region, OBJECT(dev), "sm501.mmio", MMIO_SIZE);
|
|
|
|
memory_region_init_io(&s->system_config_region, OBJECT(dev),
|
|
|
|
&sm501_system_config_ops, s,
|
|
|
|
"sm501-system-config", 0x6c);
|
|
|
|
memory_region_add_subregion(&s->mmio_region, SM501_SYS_CONFIG,
|
|
|
|
&s->system_config_region);
|
2018-07-04 11:40:58 +02:00
|
|
|
memory_region_init_io(&s->i2c_region, OBJECT(dev), &sm501_i2c_ops, s,
|
|
|
|
"sm501-i2c", 0x14);
|
|
|
|
memory_region_add_subregion(&s->mmio_region, SM501_I2C, &s->i2c_region);
|
2017-04-21 17:18:09 +02:00
|
|
|
memory_region_init_io(&s->disp_ctrl_region, OBJECT(dev),
|
|
|
|
&sm501_disp_ctrl_ops, s,
|
2011-10-02 17:56:06 +02:00
|
|
|
"sm501-disp-ctrl", 0x1000);
|
2017-04-21 17:18:09 +02:00
|
|
|
memory_region_add_subregion(&s->mmio_region, SM501_DC,
|
|
|
|
&s->disp_ctrl_region);
|
|
|
|
memory_region_init_io(&s->twoD_engine_region, OBJECT(dev),
|
|
|
|
&sm501_2d_engine_ops, s,
|
2011-10-02 17:56:06 +02:00
|
|
|
"sm501-2d-engine", 0x54);
|
2017-04-21 17:18:09 +02:00
|
|
|
memory_region_add_subregion(&s->mmio_region, SM501_2D_ENGINE,
|
|
|
|
&s->twoD_engine_region);
|
|
|
|
|
|
|
|
/* create qemu graphic console */
|
2020-05-12 09:00:20 +02:00
|
|
|
s->con = graphic_console_init(dev, 0, &sm501_ops, s);
|
2017-04-21 17:18:09 +02:00
|
|
|
}
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static const VMStateDescription vmstate_sm501_state = {
|
|
|
|
.name = "sm501-state",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_UINT32(local_mem_size_index, SM501State),
|
|
|
|
VMSTATE_UINT32(system_control, SM501State),
|
|
|
|
VMSTATE_UINT32(misc_control, SM501State),
|
|
|
|
VMSTATE_UINT32(gpio_31_0_control, SM501State),
|
|
|
|
VMSTATE_UINT32(gpio_63_32_control, SM501State),
|
|
|
|
VMSTATE_UINT32(dram_control, SM501State),
|
|
|
|
VMSTATE_UINT32(arbitration_control, SM501State),
|
|
|
|
VMSTATE_UINT32(irq_mask, SM501State),
|
|
|
|
VMSTATE_UINT32(misc_timing, SM501State),
|
|
|
|
VMSTATE_UINT32(power_mode_control, SM501State),
|
|
|
|
VMSTATE_UINT32(uart0_ier, SM501State),
|
|
|
|
VMSTATE_UINT32(uart0_lcr, SM501State),
|
|
|
|
VMSTATE_UINT32(uart0_mcr, SM501State),
|
|
|
|
VMSTATE_UINT32(uart0_scr, SM501State),
|
|
|
|
VMSTATE_UINT8_ARRAY(dc_palette, SM501State, DC_PALETTE_ENTRIES),
|
|
|
|
VMSTATE_UINT32(dc_panel_control, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_panning_control, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_fb_addr, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_fb_offset, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_fb_width, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_fb_height, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_tl_location, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_br_location, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_h_total, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_h_sync, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_v_total, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_v_sync, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_hwc_addr, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_hwc_location, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_hwc_color_1_2, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_panel_hwc_color_3, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_video_control, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_crt_control, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_crt_fb_addr, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_crt_fb_offset, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_crt_h_total, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_crt_h_sync, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_crt_v_total, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_crt_v_sync, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_crt_hwc_addr, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_crt_hwc_location, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_crt_hwc_color_1_2, SM501State),
|
|
|
|
VMSTATE_UINT32(dc_crt_hwc_color_3, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_source, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_destination, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_dimension, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_control, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_pitch, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_foreground, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_background, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_stretch, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_color_compare, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_color_compare_mask, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_mask, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_clip_tl, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_clip_br, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_mono_pattern_low, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_mono_pattern_high, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_window_width, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_source_base, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_destination_base, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_alpha, SM501State),
|
|
|
|
VMSTATE_UINT32(twoD_wrap, SM501State),
|
2018-07-04 11:40:58 +02:00
|
|
|
/* Added in version 2 */
|
|
|
|
VMSTATE_UINT8(i2c_byte_count, SM501State),
|
|
|
|
VMSTATE_UINT8(i2c_status, SM501State),
|
|
|
|
VMSTATE_UINT8(i2c_addr, SM501State),
|
|
|
|
VMSTATE_UINT8_ARRAY(i2c_data, SM501State, 16),
|
2017-04-21 17:18:09 +02:00
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define TYPE_SYSBUS_SM501 "sysbus-sm501"
|
2020-09-16 20:25:19 +02:00
|
|
|
OBJECT_DECLARE_SIMPLE_TYPE(SM501SysBusState, SYSBUS_SM501)
|
2017-04-21 17:18:09 +02:00
|
|
|
|
2020-09-03 22:43:22 +02:00
|
|
|
struct SM501SysBusState {
|
2017-04-21 17:18:09 +02:00
|
|
|
/*< private >*/
|
|
|
|
SysBusDevice parent_obj;
|
|
|
|
/*< public >*/
|
|
|
|
SM501State state;
|
|
|
|
uint32_t vram_size;
|
|
|
|
uint32_t base;
|
2019-10-23 16:06:23 +02:00
|
|
|
SerialMM serial;
|
2020-09-03 22:43:22 +02:00
|
|
|
};
|
2017-04-21 17:18:09 +02:00
|
|
|
|
|
|
|
static void sm501_realize_sysbus(DeviceState *dev, Error **errp)
|
|
|
|
{
|
|
|
|
SM501SysBusState *s = SYSBUS_SM501(dev);
|
|
|
|
SysBusDevice *sbd = SYS_BUS_DEVICE(dev);
|
|
|
|
DeviceState *usb_dev;
|
2019-10-23 16:06:23 +02:00
|
|
|
MemoryRegion *mr;
|
2017-04-21 17:18:09 +02:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
sm501_init(&s->state, dev, s->vram_size);
|
2017-04-21 17:18:09 +02:00
|
|
|
if (get_local_mem_size(&s->state) != s->vram_size) {
|
|
|
|
error_setg(errp, "Invalid VRAM size, nearest valid size is %" PRIu32,
|
|
|
|
get_local_mem_size(&s->state));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
sysbus_init_mmio(sbd, &s->state.local_mem_region);
|
|
|
|
sysbus_init_mmio(sbd, &s->state.mmio_region);
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2009-04-19 11:15:50 +02:00
|
|
|
/* bridge to usb host emulation module */
|
qdev: Convert uses of qdev_create() with Coccinelle
This is the transformation explained in the commit before previous.
Takes care of just one pattern that needs conversion. More to come in
this series.
Coccinelle script:
@ depends on !(file in "hw/arm/highbank.c")@
expression bus, type_name, dev, expr;
@@
- dev = qdev_create(bus, type_name);
+ dev = qdev_new(type_name);
... when != dev = expr
- qdev_init_nofail(dev);
+ qdev_realize_and_unref(dev, bus, &error_fatal);
@@
expression bus, type_name, dev, expr;
identifier DOWN;
@@
- dev = DOWN(qdev_create(bus, type_name));
+ dev = DOWN(qdev_new(type_name));
... when != dev = expr
- qdev_init_nofail(DEVICE(dev));
+ qdev_realize_and_unref(DEVICE(dev), bus, &error_fatal);
@@
expression bus, type_name, expr;
identifier dev;
@@
- DeviceState *dev = qdev_create(bus, type_name);
+ DeviceState *dev = qdev_new(type_name);
... when != dev = expr
- qdev_init_nofail(dev);
+ qdev_realize_and_unref(dev, bus, &error_fatal);
@@
expression bus, type_name, dev, expr, errp;
symbol true;
@@
- dev = qdev_create(bus, type_name);
+ dev = qdev_new(type_name);
... when != dev = expr
- object_property_set_bool(OBJECT(dev), true, "realized", errp);
+ qdev_realize_and_unref(dev, bus, errp);
@@
expression bus, type_name, expr, errp;
identifier dev;
symbol true;
@@
- DeviceState *dev = qdev_create(bus, type_name);
+ DeviceState *dev = qdev_new(type_name);
... when != dev = expr
- object_property_set_bool(OBJECT(dev), true, "realized", errp);
+ qdev_realize_and_unref(dev, bus, errp);
The first rule exempts hw/arm/highbank.c, because it matches along two
control flow paths there, with different @type_name. Covered by the
next commit's manual conversions.
Missing #include "qapi/error.h" added manually.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-10-armbru@redhat.com>
[Conflicts in hw/misc/empty_slot.c and hw/sparc/leon3.c resolved]
2020-06-10 07:31:58 +02:00
|
|
|
usb_dev = qdev_new("sysbus-ohci");
|
2017-04-21 17:18:09 +02:00
|
|
|
qdev_prop_set_uint32(usb_dev, "num-ports", 2);
|
|
|
|
qdev_prop_set_uint64(usb_dev, "dma-offset", s->base);
|
sysbus: Convert to sysbus_realize() etc. with Coccinelle
Convert from qdev_realize(), qdev_realize_and_unref() with null @bus
argument to sysbus_realize(), sysbus_realize_and_unref().
Coccinelle script:
@@
expression dev, errp;
@@
- qdev_realize(DEVICE(dev), NULL, errp);
+ sysbus_realize(SYS_BUS_DEVICE(dev), errp);
@@
expression sysbus_dev, dev, errp;
@@
+ sysbus_dev = SYS_BUS_DEVICE(dev);
- qdev_realize_and_unref(dev, NULL, errp);
+ sysbus_realize_and_unref(sysbus_dev, errp);
- sysbus_dev = SYS_BUS_DEVICE(dev);
@@
expression sysbus_dev, dev, errp;
expression expr;
@@
sysbus_dev = SYS_BUS_DEVICE(dev);
... when != dev = expr;
- qdev_realize_and_unref(dev, NULL, errp);
+ sysbus_realize_and_unref(sysbus_dev, errp);
@@
expression dev, errp;
@@
- qdev_realize_and_unref(DEVICE(dev), NULL, errp);
+ sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), errp);
@@
expression dev, errp;
@@
- qdev_realize_and_unref(dev, NULL, errp);
+ sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), errp);
Whitespace changes minimized manually.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Alistair Francis <alistair.francis@wdc.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-46-armbru@redhat.com>
[Conflicts in hw/misc/empty_slot.c and hw/sparc/leon3.c resolved]
2020-06-10 07:32:34 +02:00
|
|
|
sysbus_realize_and_unref(SYS_BUS_DEVICE(usb_dev), &error_fatal);
|
2017-04-21 17:18:09 +02:00
|
|
|
memory_region_add_subregion(&s->state.mmio_region, SM501_USB_HOST,
|
|
|
|
sysbus_mmio_get_region(SYS_BUS_DEVICE(usb_dev), 0));
|
|
|
|
sysbus_pass_irq(sbd, SYS_BUS_DEVICE(usb_dev));
|
2009-04-19 11:15:50 +02:00
|
|
|
|
2008-11-05 21:24:35 +01:00
|
|
|
/* bridge to serial emulation module */
|
2020-06-10 07:32:38 +02:00
|
|
|
sysbus_realize(SYS_BUS_DEVICE(&s->serial), &error_fatal);
|
2019-10-23 16:06:23 +02:00
|
|
|
mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->serial), 0);
|
|
|
|
memory_region_add_subregion(&s->state.mmio_region, SM501_UART0, mr);
|
|
|
|
/* TODO : chain irq to IRL */
|
2017-04-21 17:18:09 +02:00
|
|
|
}
|
2008-11-05 21:24:35 +01:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static Property sm501_sysbus_properties[] = {
|
|
|
|
DEFINE_PROP_UINT32("vram-size", SM501SysBusState, vram_size, 0),
|
|
|
|
DEFINE_PROP_UINT32("base", SM501SysBusState, base, 0),
|
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
|
|
|
static void sm501_reset_sysbus(DeviceState *dev)
|
|
|
|
{
|
|
|
|
SM501SysBusState *s = SYSBUS_SM501(dev);
|
|
|
|
sm501_reset(&s->state);
|
2008-11-05 21:24:35 +01:00
|
|
|
}
|
2017-04-21 17:18:09 +02:00
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static const VMStateDescription vmstate_sm501_sysbus = {
|
|
|
|
.name = TYPE_SYSBUS_SM501,
|
2018-07-04 11:40:58 +02:00
|
|
|
.version_id = 2,
|
|
|
|
.minimum_version_id = 2,
|
2017-04-21 17:18:09 +02:00
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_STRUCT(state, SM501SysBusState, 1,
|
|
|
|
vmstate_sm501_state, SM501State),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static void sm501_sysbus_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
|
|
|
|
dc->realize = sm501_realize_sysbus;
|
|
|
|
set_bit(DEVICE_CATEGORY_DISPLAY, dc->categories);
|
|
|
|
dc->desc = "SM501 Multimedia Companion";
|
2020-01-10 16:30:32 +01:00
|
|
|
device_class_set_props(dc, sm501_sysbus_properties);
|
2017-04-21 17:18:09 +02:00
|
|
|
dc->reset = sm501_reset_sysbus;
|
2017-04-21 17:18:09 +02:00
|
|
|
dc->vmsd = &vmstate_sm501_sysbus;
|
2019-10-23 16:06:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sm501_sysbus_init(Object *o)
|
|
|
|
{
|
|
|
|
SM501SysBusState *sm501 = SYSBUS_SM501(o);
|
|
|
|
SerialMM *smm = &sm501->serial;
|
|
|
|
|
2020-06-10 07:32:38 +02:00
|
|
|
object_initialize_child(o, "serial", smm, TYPE_SERIAL_MM);
|
2019-10-23 16:06:23 +02:00
|
|
|
qdev_set_legacy_instance_id(DEVICE(smm), SM501_UART0, 2);
|
|
|
|
qdev_prop_set_uint8(DEVICE(smm), "regshift", 2);
|
|
|
|
qdev_prop_set_uint8(DEVICE(smm), "endianness", DEVICE_LITTLE_ENDIAN);
|
|
|
|
|
|
|
|
object_property_add_alias(o, "chardev",
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
OBJECT(smm), "chardev");
|
2017-04-21 17:18:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static const TypeInfo sm501_sysbus_info = {
|
|
|
|
.name = TYPE_SYSBUS_SM501,
|
|
|
|
.parent = TYPE_SYS_BUS_DEVICE,
|
|
|
|
.instance_size = sizeof(SM501SysBusState),
|
|
|
|
.class_init = sm501_sysbus_class_init,
|
2019-10-23 16:06:23 +02:00
|
|
|
.instance_init = sm501_sysbus_init,
|
2017-04-21 17:18:09 +02:00
|
|
|
};
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
#define TYPE_PCI_SM501 "sm501"
|
2020-09-16 20:25:19 +02:00
|
|
|
OBJECT_DECLARE_SIMPLE_TYPE(SM501PCIState, PCI_SM501)
|
2017-04-21 17:18:09 +02:00
|
|
|
|
2020-09-03 22:43:22 +02:00
|
|
|
struct SM501PCIState {
|
2017-04-21 17:18:09 +02:00
|
|
|
/*< private >*/
|
|
|
|
PCIDevice parent_obj;
|
|
|
|
/*< public >*/
|
|
|
|
SM501State state;
|
|
|
|
uint32_t vram_size;
|
2020-09-03 22:43:22 +02:00
|
|
|
};
|
2017-04-21 17:18:09 +02:00
|
|
|
|
|
|
|
static void sm501_realize_pci(PCIDevice *dev, Error **errp)
|
|
|
|
{
|
|
|
|
SM501PCIState *s = PCI_SM501(dev);
|
|
|
|
|
|
|
|
sm501_init(&s->state, DEVICE(dev), s->vram_size);
|
|
|
|
if (get_local_mem_size(&s->state) != s->vram_size) {
|
|
|
|
error_setg(errp, "Invalid VRAM size, nearest valid size is %" PRIu32,
|
|
|
|
get_local_mem_size(&s->state));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pci_register_bar(dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY,
|
|
|
|
&s->state.local_mem_region);
|
|
|
|
pci_register_bar(dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY,
|
|
|
|
&s->state.mmio_region);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Property sm501_pci_properties[] = {
|
2018-06-25 14:41:57 +02:00
|
|
|
DEFINE_PROP_UINT32("vram-size", SM501PCIState, vram_size, 64 * MiB),
|
2017-04-21 17:18:09 +02:00
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
|
|
|
static void sm501_reset_pci(DeviceState *dev)
|
|
|
|
{
|
|
|
|
SM501PCIState *s = PCI_SM501(dev);
|
|
|
|
sm501_reset(&s->state);
|
|
|
|
/* Bits 2:0 of misc_control register is 001 for PCI */
|
|
|
|
s->state.misc_control |= 1;
|
|
|
|
}
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static const VMStateDescription vmstate_sm501_pci = {
|
|
|
|
.name = TYPE_PCI_SM501,
|
2018-07-04 11:40:58 +02:00
|
|
|
.version_id = 2,
|
|
|
|
.minimum_version_id = 2,
|
2017-04-21 17:18:09 +02:00
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_PCI_DEVICE(parent_obj, SM501PCIState),
|
|
|
|
VMSTATE_STRUCT(state, SM501PCIState, 1,
|
|
|
|
vmstate_sm501_state, SM501State),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static void sm501_pci_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
|
|
|
|
|
|
|
|
k->realize = sm501_realize_pci;
|
|
|
|
k->vendor_id = PCI_VENDOR_ID_SILICON_MOTION;
|
|
|
|
k->device_id = PCI_DEVICE_ID_SM501;
|
|
|
|
k->class_id = PCI_CLASS_DISPLAY_OTHER;
|
|
|
|
set_bit(DEVICE_CATEGORY_DISPLAY, dc->categories);
|
|
|
|
dc->desc = "SM501 Display Controller";
|
2020-01-10 16:30:32 +01:00
|
|
|
device_class_set_props(dc, sm501_pci_properties);
|
2017-04-21 17:18:09 +02:00
|
|
|
dc->reset = sm501_reset_pci;
|
|
|
|
dc->hotpluggable = false;
|
2017-04-21 17:18:09 +02:00
|
|
|
dc->vmsd = &vmstate_sm501_pci;
|
2017-04-21 17:18:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static const TypeInfo sm501_pci_info = {
|
|
|
|
.name = TYPE_PCI_SM501,
|
|
|
|
.parent = TYPE_PCI_DEVICE,
|
|
|
|
.instance_size = sizeof(SM501PCIState),
|
|
|
|
.class_init = sm501_pci_class_init,
|
2017-09-27 21:56:34 +02:00
|
|
|
.interfaces = (InterfaceInfo[]) {
|
|
|
|
{ INTERFACE_CONVENTIONAL_PCI_DEVICE },
|
|
|
|
{ },
|
|
|
|
},
|
2017-04-21 17:18:09 +02:00
|
|
|
};
|
|
|
|
|
2017-04-21 17:18:09 +02:00
|
|
|
static void sm501_register_types(void)
|
|
|
|
{
|
|
|
|
type_register_static(&sm501_sysbus_info);
|
2017-04-21 17:18:09 +02:00
|
|
|
type_register_static(&sm501_pci_info);
|
2017-04-21 17:18:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
type_init(sm501_register_types)
|