From nobody Sat May 18 06:04:26 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1684311196; cv=none; d=zohomail.com; s=zohoarc; b=Hsv+66NrYa+xOfigqe1AK0h7DO5Qk0048ZDBuAmg708uVE5evJuHj4AmSJbMil9thY8WWtASzSLg7+C4kRc3IN0xDA9uHLyQ+9yI1pAi6ea+WBDeS1mGcBnTYEGC2SYWLiF5O2L8Ou4a1Q1BN45cQYQyAhE4Q2dUzmIzofpwiVs= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1684311196; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=+4H4TLD9Tgw1VSAkuUmuXqvaTIifJo+7xd82yABLyRs=; b=fapjl7uIwHNruDaBGZnOT1iaTEhPu9fDYhb9k4i+JVCSqYaoJZ4mIXsMYwhmZ33fTkyfQW2VnVKv8btj9Bx2EBqJiHoa45dyhUJgtlpBj+9p6eDIayod+ShH72y9VbC7ax170iPeaN/6Br9ebrrFhAEhqZ5XN7bw1syZJxRIATg= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1684311196813734.4588926747301; Wed, 17 May 2023 01:13:16 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1pzCGi-0005iV-Kj; Wed, 17 May 2023 04:12:20 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pzCGe-0005eN-T5; Wed, 17 May 2023 04:12:17 -0400 Received: from mail-wm1-x333.google.com ([2a00:1450:4864:20::333]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1pzCGb-0003II-Sm; Wed, 17 May 2023 04:12:16 -0400 Received: by mail-wm1-x333.google.com with SMTP id 5b1f17b1804b1-3f42bcf5df1so4349095e9.3; Wed, 17 May 2023 01:12:13 -0700 (PDT) Received: from i.. ([41.236.82.205]) by smtp.gmail.com with ESMTPSA id o24-20020a1c7518000000b003f42158288dsm1414942wmc.20.2023.05.17.01.12.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 May 2023 01:12:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1684311132; x=1686903132; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=+4H4TLD9Tgw1VSAkuUmuXqvaTIifJo+7xd82yABLyRs=; b=Q6CgS3RdJX4L3572tZ7hyDZT20H59gptV8LYkmDrFakNfF5OULVIRmIOSRlcrjH3B/ Ytk0BLqDyKaQ0pIFqkkmuxmd87aPDvM4dGXINjlTm9RLyDdDSi0q1700Xm0O9v/z1SFr QOQC39ZSHq3CHfGA4XAtAZa2P9+9J3kStGRAMF/HAg2fS6FTXChV3rokLspND1L+xCcI AA6oCiuY6tb10YhK11n2DY/DxIj4t6HKCZpDFNSIBdRuY0TntCMsEd2OhoP1XcLxo74K drhYiMh2UTJUwdZsS0PfUqIZQm4hPVcob7x5wyXxg7rL6TbwgjrlLpNagvI2DCpRsQLH WQdg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1684311132; x=1686903132; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=+4H4TLD9Tgw1VSAkuUmuXqvaTIifJo+7xd82yABLyRs=; b=ktRr+Vl+jKzkncLrHKxCs5Yc2nTsE98E+l3KkM+nm7Rvmg+c8oCuGSscisfV6xOoVF +Uyo4eXFFNAMsXXZJxzavwmoyciZ6Ca3YeknKAZQwIYg02caYlSXocM9g+zCFNmZr0Oo ikK6O5ylpeYqI6sxI0nhcTdORLtf1H7UTw4HzTqSwmoCs0KLGhd7xgzjZHCAIoOG+p1p Kn75rMmYyZRa/TTHb2oc3e5DFPTvI1SUL+yTvymm2k7uzTt54fzzABzEYG6kwTj0U6MY frEE8XF+Gvp0I5dEq9zWg/Pw7nygoib51bLwI9gFG9GxkFaMBsMl6vKULbb9rhQeoZeo CF+w== X-Gm-Message-State: AC+VfDzXKIRYvUFcM20HqE5h2W2nINryqA2DgBlCxz17s66vq0IXvEg4 G5WGsOtsJNOsE/kxgNfa/dUBdVPJpahnHA== X-Google-Smtp-Source: ACHHUZ6MvVvXolK68xNPIRc/MMQN7673B8iHiyyMbSTZLphXrvefN/+CqR3zyhTYREAMxBUDgjS3RQ== X-Received: by 2002:a05:600c:3787:b0:3f4:2775:3f89 with SMTP id o7-20020a05600c378700b003f427753f89mr21813453wmr.35.1684311131419; Wed, 17 May 2023 01:12:11 -0700 (PDT) From: Mohamed ElSayed To: qemu-devel@nongnu.org Cc: qemu-arm@nongnu.org, Mohamed ElSayed Subject: [PATCH 1/8] The tivac board initial machine definition Date: Wed, 17 May 2023 11:11:57 +0300 Message-Id: <20230517081204.30333-2-m.elsayed4420@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230517081204.30333-1-m.elsayed4420@gmail.com> References: <20230517081204.30333-1-m.elsayed4420@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::333; envelope-from=m.elsayed4420@gmail.com; helo=mail-wm1-x333.google.com X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @gmail.com) X-ZM-MESSAGEID: 1684311198496100005 Content-Type: text/plain; charset="utf-8" Signed-off-by: Mohamed ElSayed --- hw/arm/tivac.c | 56 ++++++ hw/arm/tm4c123gh6pm_soc.c | 275 ++++++++++++++++++++++++++++++ include/hw/arm/tm4c123gh6pm_soc.h | 71 ++++++++ 3 files changed, 402 insertions(+) create mode 100644 hw/arm/tivac.c create mode 100644 hw/arm/tm4c123gh6pm_soc.c create mode 100644 include/hw/arm/tm4c123gh6pm_soc.h diff --git a/hw/arm/tivac.c b/hw/arm/tivac.c new file mode 100644 index 0000000000..5d917a8f9e --- /dev/null +++ b/hw/arm/tivac.c @@ -0,0 +1,56 @@ +/* + * TivaC Board Implementation + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#include "qemu/osdep.h" +#include "qapi/error.h" +#include "hw/boards.h" +#include "hw/qdev-properties.h" +#include "hw/qdev-clock.h" +#include "qemu/error-report.h" +#include "hw/arm/tm4c123gh6pm_soc.h" +#include "hw/arm/boot.h" + + +/* Main SYSCLK frequency in Hz (24MHz) */ +#define SYSCLK_FRQ 24000000ULL + +static void tivac_init(MachineState *machine) +{ + DeviceState *dev; + dev =3D qdev_new(TYPE_TM4C123GH6PM_SOC); + + qdev_prop_set_string(dev, "cpu-type", ARM_CPU_TYPE_NAME("cortex-m4")); + sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal); + + armv7m_load_kernel(ARM_CPU(first_cpu), + machine->kernel_filename, + 0, FLASH_SIZE); +} + +static void tivac_machine_init(MachineClass *mc) +{ + mc->desc =3D "Tiva C (Cortex-M4)"; + mc->init =3D tivac_init; +} +DEFINE_MACHINE("tivac", tivac_machine_init) diff --git a/hw/arm/tm4c123gh6pm_soc.c b/hw/arm/tm4c123gh6pm_soc.c new file mode 100644 index 0000000000..3e61911bba --- /dev/null +++ b/hw/arm/tm4c123gh6pm_soc.c @@ -0,0 +1,275 @@ +/* + * TM4C123GH6PM SoC + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#include "qemu/osdep.h" +#include "qapi/error.h" +#include "qemu/module.h" +#include "hw/arm/boot.h" +#include "exec/address-spaces.h" +#include "hw/arm/tm4c123gh6pm_soc.h" +#include "hw/qdev-properties.h" +#include "hw/qdev-clock.h" +#include "hw/misc/unimp.h" +#include "sysemu/sysemu.h" + +static const uint32_t gpio_addrs[GPIO_COUNT] =3D { + 0x40004000, + 0x40005000, + 0x40006000, + 0x40007000, + 0x40024000, + 0x40025000 +}; + +static const uint32_t usart_addrs[USART_COUNT] =3D { + 0x4000C000, + 0x4000D000, + 0x4000E000, + 0x4000F000, + 0x40010000, + 0x40011000, + 0x40012000, + 0x40013000 +}; + +static const uint32_t wdt_addrs[WDT_COUNT] =3D { + 0x40000000, + 0x40001000 +}; + +static const uint32_t gptm_addrs[GPTM_COUNT] =3D { + 0x40030000, + 0x40031000, + 0x40032000, + 0x40033000, + 0x40034000, + 0x40035000, + 0x40036000, + 0x40037000, + 0x4003C800, + 0x4003D000, + 0x4003E000, + 0x4003F000, +}; + +static const uint16_t usart_irqs[USART_COUNT] =3D {5, 6, 33, 59, 60, 61, 6= 2, 63}; +static const uint16_t gpio_irqs[GPIO_COUNT] =3D {0, 1, 2, 3, 4, 30}; +static const uint16_t wdt_irqs[WDT_COUNT] =3D {18, 18}; +static const uint16_t gptm_irqs[GPTM_COUNT * 2] =3D { + 19, 20, 21, 22, 23, 24, 35, 36, 70, 71, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105}; + +static void tm4c123gh6pm_soc_initfn(Object *obj) +{ + int i; + TM4C123GH6PMState *s =3D TM4C123GH6PM_SOC(obj); + + object_initialize_child(obj, "armv7m", &s->armv7m, TYPE_ARMV7M); + object_initialize_child(obj, "sysctl", &s->sysctl, TYPE_TM4C123_SYSCTL= ); + + for (i =3D 0; i < USART_COUNT; i++) { + object_initialize_child(obj, "usart[*]", + &s->usart[i], TYPE_TM4C123_USART); + } + + for (i =3D 0; i < GPIO_COUNT; i++) { + object_initialize_child(obj, "gpio[*]", &s->gpio[i], TYPE_TM4C123_= GPIO); + } + + for (i =3D 0; i < WDT_COUNT; i++) { + object_initialize_child(obj, "watchdog-timer[*]", + &s->wdt[i], TYPE_TM4C123_WATCHDOG); + } + + for (i =3D 0; i < GPTM_COUNT; i++) { + object_initialize_child(obj, "gptm[*]", &s->gptm[i], TYPE_TM4C123_= GPTM); + } +} + +static void tm4c123gh6pm_soc_realize(DeviceState *dev_soc, Error **errp) +{ + TM4C123GH6PMState *s =3D TM4C123GH6PM_SOC(dev_soc); + DeviceState *armv7m; + DeviceState *dev; + SysBusDevice *busdev; + int i; + + MemoryRegion *system_memory =3D get_system_memory(); + + /* init flash memory */ + memory_region_init_rom( + &s->flash, OBJECT(dev_soc), + "TM4C123GH6PM.flash", FLASH_SIZE, &error_fatal + ); + memory_region_add_subregion(system_memory, FLASH_BASE_ADDRESS, &s->fla= sh); + + /* init sram and the sram alias region */ + memory_region_init_ram( + &s->sram, OBJECT(dev_soc), + "TM4C123GH6PM.sram", SRAM_SIZE, &error_fatal); + memory_region_add_subregion(system_memory, SRAM_BASE_ADDRESS, &s->sram= ); + + /* Init ARMv7m */ + armv7m =3D DEVICE(&s->armv7m); + qdev_prop_set_uint32(armv7m, "num-irq", 138); + qdev_prop_set_string(armv7m, "cpu-type", s->cpu_type); + qdev_prop_set_bit(armv7m, "enable-bitband", true); + qdev_connect_clock_in(armv7m, "cpuclk", s->sysctl.mainclk); + qdev_connect_clock_in(armv7m, "refclk", s->sysctl.mainclk); + object_property_set_link(OBJECT(&s->armv7m), "memory", + OBJECT(get_system_memory()), &error_abort); + + if (!sysbus_realize(SYS_BUS_DEVICE(&s->armv7m), errp)) { + return; + } + + /* USART */ + for (i =3D 0; i < USART_COUNT; i++) { + dev =3D DEVICE(&(s->usart[i])); + s->usart[i].sysctl =3D &s->sysctl; + qdev_prop_set_chr(dev, "chardev", serial_hd(i)); + if (!sysbus_realize(SYS_BUS_DEVICE(&s->usart[i]), errp)) { + return; + } + busdev =3D SYS_BUS_DEVICE(dev); + sysbus_mmio_map(busdev, 0, usart_addrs[i]); + sysbus_connect_irq(busdev, 0, qdev_get_gpio_in(armv7m, usart_irqs[= i])); + } + + /* GPIO */ + for (i =3D 0; i < GPIO_COUNT; i++) { + dev =3D DEVICE(&(s->gpio[i])); + s->gpio[i].sysctl =3D &s->sysctl; + if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio[i]), errp)) { + return; + } + busdev =3D SYS_BUS_DEVICE(dev); + sysbus_mmio_map(busdev, 0, gpio_addrs[i]); + sysbus_connect_irq(busdev, 0, qdev_get_gpio_in(armv7m, gpio_irqs[i= ])); + } + + /* Watchdog Timers */ + for (i =3D 0; i < WDT_COUNT; i++) { + dev =3D DEVICE(&(s->wdt[i])); + s->wdt[i].sysctl =3D &s->sysctl; + if (!sysbus_realize(SYS_BUS_DEVICE(&s->wdt[i]), errp)) { + return; + } + busdev =3D SYS_BUS_DEVICE(dev); + sysbus_mmio_map(busdev, 0, wdt_addrs[i]); + sysbus_connect_irq(busdev, 0, qdev_get_gpio_in(armv7m, wdt_irqs[i]= )); + } + + /* General purpose timers */ + int j =3D 0; + for (i =3D 0, j =3D 0; i < GPTM_COUNT; i++, j +=3D 2) { + dev =3D DEVICE(&(s->gptm[i])); + s->gptm[i].sysctl =3D &s->sysctl; + if (!sysbus_realize(SYS_BUS_DEVICE(&s->gptm[i]), errp)) { + return; + } + busdev =3D SYS_BUS_DEVICE(dev); + sysbus_mmio_map(busdev, 0, gptm_addrs[i]); + sysbus_connect_irq(busdev, 0, qdev_get_gpio_in(armv7m, gptm_irqs[j= ])); + sysbus_connect_irq(busdev, 1, qdev_get_gpio_in(armv7m, gptm_irqs[j= + 1])); + } + + /* SYSCTL */ + dev =3D DEVICE(&(s->sysctl)); + if (!sysbus_realize(SYS_BUS_DEVICE(&s->sysctl), errp)) { + return; + } + busdev =3D SYS_BUS_DEVICE(dev); + sysbus_mmio_map(busdev, 0, SYSCTL_ADDR); + + + create_unimplemented_device("SSI_0", 0x40008000, 0xFFF); + create_unimplemented_device("SSI_1", 0x40009000, 0xFFF); + create_unimplemented_device("SSI_2", 0x4000A000, 0xFFF); + create_unimplemented_device("SSI_3", 0x4000B000, 0xFFF); + + create_unimplemented_device("I2C_0", 0x40020000, 0xFFF); + create_unimplemented_device("I2C_1", 0x40021000, 0xFFF); + create_unimplemented_device("I2C_2", 0x40022000, 0xFFF); + create_unimplemented_device("I2C_3", 0x40023000, 0xFFF); + + create_unimplemented_device("PWM_0", 0x40028000, 0xFFF); + create_unimplemented_device("PWM_1", 0x40029000, 0xFFF); + + create_unimplemented_device("QEI_0", 0x4002C000, 0xFFF); + create_unimplemented_device("QEI_1", 0x4002D000, 0xFFF); + + create_unimplemented_device("ADC_0", 0x40038000, 0xFFF); + create_unimplemented_device("ADC_1", 0x40039000, 0xFFF); + + create_unimplemented_device("ANALOG_CMP", 0x4003C000, 0xFFF); + + create_unimplemented_device("CAN_0", 0x40040000, 0xFFF); + create_unimplemented_device("CAN_1", 0x40041000, 0xFFF); + + create_unimplemented_device("USB", 0x40050000, 0xFFF); + + create_unimplemented_device("GPIO_A_AHB", 0x40058000, 0xFFF); + create_unimplemented_device("GPIO_B_AHB", 0x40059000, 0xFFF); + create_unimplemented_device("GPIO_C_AHB", 0x4005A000, 0xFFF); + create_unimplemented_device("GPIO_D_AHB", 0x4005B000, 0xFFF); + create_unimplemented_device("GPIO_E_AHB", 0x4005C000, 0xFFF); + create_unimplemented_device("GPIO_F_AHB", 0x4005D000, 0xFFF); + + create_unimplemented_device("EEPROM", 0x400AF000, 0xFFF); + create_unimplemented_device("SYS_EXC", 0x400F9000, 0xFFF); + create_unimplemented_device("HIBERNATION_MOD", 0x400FC000, 0xFFF); + create_unimplemented_device("FLASH_CONT", 0x400FD000, 0xFFF); + create_unimplemented_device("SYS_CONT", 0x400FE000, 0xFFF); + + create_unimplemented_device("uDMA", 0x400FF000, 0xFFF); +} + +static Property tm4c123gh6pm_soc_properties[] =3D { + DEFINE_PROP_STRING("cpu-type", TM4C123GH6PMState, cpu_type), + DEFINE_PROP_END_OF_LIST(), +}; + +static void tm4c123gh6pm_soc_class_init(ObjectClass *klass, void *data) +{ + DeviceClass *dc =3D DEVICE_CLASS(klass); + + dc->realize =3D tm4c123gh6pm_soc_realize; + device_class_set_props(dc, tm4c123gh6pm_soc_properties); +} + +static const TypeInfo tm4c123gh6pm_soc_info =3D { + .name =3D TYPE_TM4C123GH6PM_SOC, + .parent =3D TYPE_SYS_BUS_DEVICE, + .instance_size =3D sizeof(TM4C123GH6PMState), + .instance_init =3D tm4c123gh6pm_soc_initfn, + .class_init =3D tm4c123gh6pm_soc_class_init, +}; + +static void tm4c123gh6pm_soc_types(void) +{ + type_register_static(&tm4c123gh6pm_soc_info); +} + +type_init(tm4c123gh6pm_soc_types) diff --git a/include/hw/arm/tm4c123gh6pm_soc.h b/include/hw/arm/tm4c123gh6p= m_soc.h new file mode 100644 index 0000000000..1841483a78 --- /dev/null +++ b/include/hw/arm/tm4c123gh6pm_soc.h @@ -0,0 +1,71 @@ +/* + * TM4C123GH6PM SoC + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#ifndef HW_ARM_TM4C123GH6PM_SOC_H +#define HW_ARM_TM4C123GH6PM_SOC_H + +#include "hw/arm/armv7m.h" +#include "qom/object.h" +#include "hw/clock.h" +#include "hw/char/tm4c123_usart.h" +#include "hw/misc/tm4c123_sysctl.h" +#include "hw/gpio/tm4c123_gpio.h" +#include "hw/watchdog/tm4c123_watchdog.h" +#include "hw/timer/tm4c123_gptm.h" + +#define TYPE_TM4C123GH6PM_SOC "tm4c123gh6pm-soc" + +OBJECT_DECLARE_SIMPLE_TYPE(TM4C123GH6PMState, TM4C123GH6PM_SOC) + +#define FLASH_BASE_ADDRESS 0x00000000 +#define FLASH_SIZE (256 * 1024) +#define SRAM_BASE_ADDRESS 0x20000000 +#define SRAM_SIZE (32 * 1024) + +#define SYSCTL_ADDR 0x400FE000 + +#define USART_COUNT 8 +#define GPIO_COUNT 6 +#define WDT_COUNT 2 +#define GPTM_COUNT 12 + +struct TM4C123GH6PMState { + SysBusDevice parent_obj; + + char *cpu_type; + + ARMv7MState armv7m; + + TM4C123USARTState usart[USART_COUNT]; + TM4C123SysCtlState sysctl; + TM4C123GPIOState gpio[GPIO_COUNT]; + TM4C123WatchdogState wdt[WDT_COUNT]; + TM4C123GPTMState gptm[GPTM_COUNT]; + + MemoryRegion sram; + MemoryRegion alias_region; + MemoryRegion flash; +}; + +#endif --=20 2.34.1 From nobody Sat May 18 06:04:26 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1684311197; cv=none; d=zohomail.com; s=zohoarc; b=S4SQ2YVqHa/LWF8Foucrw7mAnAuqI95ZInQpyQMrjv4tLSq6A2XGbJ/dFaxV0RRw+OND2yw5i8IfpFp06gA85SVRfUF24v3Ftu7KK2mEB1XlbxjTk6KRU7UWuQjSgeDzVlZ2HAMOUJ1pqKJMRYdz54AL6k1sYPDVVQTPOudpFsI= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1684311197; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=FME8dFCXHhrLjbPwofbxFf6dtGoZ1sG2sL76yiqsucE=; b=L6ncL7D1Q57bq/CLrP1WB1kiNnBRLMk5Fm38n0rNO4+InyJ1M1JQg1trpSq+Ps1P/dSJuHVtJL7zT3tYb0JlycJiFkMaPAb3160Bw7LREAR6fkD1r3NcxFyfoJbFOGXwzwgmmWl8CTwzlpm1rThapg2/7vvBv6ESCKkyWhMCzQQ= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1684311197450256.03256434217224; Wed, 17 May 2023 01:13:17 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1pzCGp-0005qQ-4I; Wed, 17 May 2023 04:12:27 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pzCGm-0005nJ-Fu; Wed, 17 May 2023 04:12:24 -0400 Received: from mail-wm1-x333.google.com ([2a00:1450:4864:20::333]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1pzCGf-0003JO-2e; Wed, 17 May 2023 04:12:23 -0400 Received: by mail-wm1-x333.google.com with SMTP id 5b1f17b1804b1-3f50020e0f8so53369115e9.0; Wed, 17 May 2023 01:12:14 -0700 (PDT) Received: from i.. ([41.236.82.205]) by smtp.gmail.com with ESMTPSA id o24-20020a1c7518000000b003f42158288dsm1414942wmc.20.2023.05.17.01.12.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 May 2023 01:12:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1684311133; x=1686903133; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=FME8dFCXHhrLjbPwofbxFf6dtGoZ1sG2sL76yiqsucE=; b=Y4/nwImEoziYQiSRkwrwumNpSRBWNGb4WP+2oJYT0YBxfkEneU3CLTx8sNgCNbID/q ZAmdpkVXmrj21AEgpJz3qc2cMf85um6Ogrmb6y8jNSfVUB/NW2paxlrW7gKdAP7DCO6G fKorcWu6jF2AukagEedLTuj14R6kPNva7BJ5aA515KvLIu70gpV0BUb1N++4zd6/jdDQ Yh060r5HLaQZT8VMTzP8Rto44IIHKolpr9Bap0ADwEf81Lz4Y7XZmdktegXRO9PAOtus Z5P9JgdsfZ7JSRPIHQZtWE5wdMKvawFKT6VigObq7pCQrIExePmvFXDqzW4hGJ5+ctkH B2Vg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1684311133; x=1686903133; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=FME8dFCXHhrLjbPwofbxFf6dtGoZ1sG2sL76yiqsucE=; b=Y4Oip3l74h07tiUdkjly41PfwiOQAamKSEm+Yk+5mrlpruKUnBqa1Aknom5BChSNJA UyBxU1ZTAVoGa72tavX2ql5qFzHgPAPxToLpfU15uWLxz646lmtHm3x0dnFYKq0vsCd3 7mfPbb4PVafjatTqwgrZxq7+w6VpqZfQ6ms31EpomyaDBYLuom0JepYKQNFlaCD5tgGM zMrmNz+G188DtrkmlbDeBHAs3VUOeYYLCt4GLEoX+UYwFlGyHWFfGuzqsSmj7zvGJqJR 0WtRzpdqW6Yx2GQWMpbWFY8rfzOqqEfFsxRuiiJjuWSpaw7gwAIi+JdQM+eLTb8LhmjQ Y63g== X-Gm-Message-State: AC+VfDxmP9TuCI3XthDoGSugI0mwPDmRWGjajwNGzUHBJ8H+eXI0ncSP vbGZnerSL4xN8TVU/FPpd/q/l8hgvg+RrA== X-Google-Smtp-Source: ACHHUZ7utJl2Zh8kcPhX4eFcD31oxshaRNNnKRvdqilLBPD3VA/Mz7kYrMweYrlO8UZytviyYz60Mg== X-Received: by 2002:a1c:7210:0:b0:3f1:8129:2c53 with SMTP id n16-20020a1c7210000000b003f181292c53mr1060531wmc.16.1684311132872; Wed, 17 May 2023 01:12:12 -0700 (PDT) From: Mohamed ElSayed To: qemu-devel@nongnu.org Cc: qemu-arm@nongnu.org, Mohamed ElSayed Subject: [PATCH 2/8] tiva c usart module implementation Date: Wed, 17 May 2023 11:11:58 +0300 Message-Id: <20230517081204.30333-3-m.elsayed4420@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230517081204.30333-1-m.elsayed4420@gmail.com> References: <20230517081204.30333-1-m.elsayed4420@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::333; envelope-from=m.elsayed4420@gmail.com; helo=mail-wm1-x333.google.com X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @gmail.com) X-ZM-MESSAGEID: 1684311198629100009 Content-Type: text/plain; charset="utf-8" Signed-off-by: Mohamed ElSayed --- hw/char/tm4c123_usart.c | 381 ++++++++++++++++++++++++++++++++ hw/char/trace-events | 4 + include/hw/char/tm4c123_usart.h | 124 +++++++++++ 3 files changed, 509 insertions(+) create mode 100644 hw/char/tm4c123_usart.c create mode 100644 include/hw/char/tm4c123_usart.h diff --git a/hw/char/tm4c123_usart.c b/hw/char/tm4c123_usart.c new file mode 100644 index 0000000000..21bfe781b0 --- /dev/null +++ b/hw/char/tm4c123_usart.c @@ -0,0 +1,381 @@ +/* + * TM4C123 USART + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#include "qemu/osdep.h" +#include "hw/char/tm4c123_usart.h" +#include "hw/irq.h" +#include "hw/qdev-properties.h" +#include "hw/qdev-properties-system.h" +#include "qemu/log.h" +#include "qemu/module.h" +#include "trace.h" + +#define LOG(mask, fmt, args...) qemu_log_mask(mask, "%s: " fmt, __func__, = ## args) +#define READONLY LOG(LOG_GUEST_ERROR, "0x%"HWADDR_PRIx" is a readonly fiel= d\n.", addr) + +static bool usart_clock_enabled(TM4C123SysCtlState *s, hwaddr addr) +{ + switch (addr) { + case USART_0: + return s->sysctl_rcgcuart & (1 << 0); + break; + case USART_1: + return s->sysctl_rcgcuart & (1 << 1); + break; + case USART_2: + return s->sysctl_rcgcuart & (1 << 2); + break; + case USART_3: + return s->sysctl_rcgcuart & (1 << 3); + break; + case USART_4: + return s->sysctl_rcgcuart & (1 << 4); + break; + case USART_5: + return s->sysctl_rcgcuart & (1 << 5); + break; + case USART_6: + return s->sysctl_rcgcuart & (1 << 6); + break; + case USART_7: + return s->sysctl_rcgcuart & (1 << 7); + break; + } + return false; +} + + +static int tm4c123_usart_can_receive(void *opaque) +{ + TM4C123USARTState *s =3D opaque; + + if (!(s->usart_fr & USART_FR_RXFF)) { + return 1; + } + return 0; +} + +static void tm4c123_usart_receive(void *opaque, const uint8_t *buf, int si= ze) +{ + TM4C123USARTState *s =3D opaque; + + if (!(s->usart_ctl & USART_CR_EN && s->usart_ctl & USART_CR_RXE)) { + LOG(LOG_GUEST_ERROR, "The module is not enbled\n"); + return; + } + + s->usart_dr =3D *buf; + s->usart_ctl &=3D ~USART_FR_RXFE; + + if (s->usart_im & USART_IM_RXIM) { + qemu_set_irq(s->irq, 1); + } +} + +static void tm4c123_usart_reset(DeviceState *dev) +{ + TM4C123USARTState *s =3D TM4C123_USART(dev); + + s->usart_dr =3D 0x00000000; + s->usart_rsr =3D 0x00000000; + s->usart_fr =3D 0x00000090; + s->usart_ilpr =3D 0x00000000; + s->usart_ibrd =3D 0x00000000; + s->usart_fbrd =3D 0x00000000; + s->usart_lcrh =3D 0x00000000; + s->usart_ctl =3D 0x00000300; + s->usart_ifls =3D 0x00000012; + s->usart_im =3D 0x00000000; + s->usart_ris =3D 0x00000000; + s->usart_mis =3D 0x00000000; + s->usart_icr =3D 0x00000000; + s->usart_dma_ctl =3D 0x00000000; + s->usart_9bit_addr =3D 0x00000000; + s->usart_9bit_mask =3D 0x000000FF; + s->usart_pp =3D 0x00000003; + s->usart_cc =3D 0x00000000; + s->usart_per_id4 =3D 0x00000000; + s->usart_per_id5 =3D 0x00000000; + s->usart_per_id6 =3D 0x00000000; + s->usart_per_id7 =3D 0x00000000; + s->usart_per_id0 =3D 0x00000060; + s->usart_per_id1 =3D 0x00000000; + s->usart_per_id2 =3D 0x00000018; + s->usart_per_id3 =3D 0x00000001; + s->usart_pcell_id0 =3D 0x0000000D; + s->usart_pcell_id1 =3D 0x000000F0; + s->usart_pcell_id2 =3D 0x00000005; + s->usart_pcell_id3 =3D 0x000000B1; + + qemu_set_irq(s->irq, 0); +} + +static uint64_t tm4c123_usart_read(void *opaque, hwaddr addr, unsigned int= size) +{ + TM4C123USARTState *s =3D opaque; + + if (!usart_clock_enabled(s->sysctl, s->mmio.addr)) { + hw_error("USART module clock is not enabled"); + } + + trace_tm4c123_usart_read(addr); + + switch (addr) { + case USART_DR: + return s->usart_dr; + case USART_RSR: + return s->usart_rsr; + case USART_FR: + return s->usart_fr; + case USART_ILPR: + return s->usart_ilpr; + case USART_IBRD: + return s->usart_ibrd; + case USART_FBRD: + return s->usart_fbrd; + case USART_LCRH: + return s->usart_lcrh; + case USART_CTL: + return s->usart_ctl; + case USART_IFLS: + return s->usart_ifls; + case USART_IM: + return s->usart_im; + case USART_RIS: + return s->usart_ris; + case USART_MIS: + return s->usart_mis; + case USART_ICR: + return s->usart_icr; + case USART_DMA_CTL: + return s->usart_dma_ctl; + case USART_9BIT_ADDR: + return s->usart_9bit_addr; + case USART_9BIT_MASK: + return s->usart_9bit_mask; + case USART_PP: + return s->usart_pp; + case USART_CC: + return s->usart_cc; + case USART_PER_ID4: + return s->usart_per_id4; + case USART_PER_ID5: + return s->usart_per_id5; + case USART_PER_ID6: + return s->usart_per_id6; + case USART_PER_ID7: + return s->usart_per_id7; + case USART_PER_ID0: + return s->usart_per_id0; + case USART_PER_ID1: + return s->usart_per_id1; + case USART_PER_ID2: + return s->usart_per_id2; + case USART_PER_ID3: + return s->usart_per_id3; + case USART_PCELL_ID0: + return s->usart_pcell_id0; + case USART_PCELL_ID1: + return s->usart_pcell_id1; + case USART_PCELL_ID2: + return s->usart_pcell_id2; + case USART_PCELL_ID3: + return s->usart_pcell_id3; + default: + LOG(LOG_GUEST_ERROR, "Bad address 0x%"HWADDR_PRIx"\n", addr); + return 0; + } + + return 0; +} + +static void tm4c123_usart_write(void *opaque, hwaddr addr, uint64_t val64,= unsigned int size) +{ + TM4C123USARTState *s =3D opaque; + uint32_t val32 =3D val64; + unsigned char ch; + + if (!usart_clock_enabled(s->sysctl, s->mmio.addr)) { + hw_error("USART module clock is not enabled"); + } + + trace_tm4c123_usart_write(addr, val32); + + switch (addr) { + case USART_DR: + s->usart_dr =3D val32; + if (val32 < 0xF000) { + ch =3D val32; + qemu_chr_fe_write_all(&s->chr, &ch, 1); + } + break; + case USART_RSR: + s->usart_rsr =3D val32; + break; + case USART_FR: + READONLY; + break; + case USART_ILPR: + s->usart_ilpr =3D val32; + break; + case USART_IBRD: + s->usart_ibrd =3D val32; + break; + case USART_FBRD: + s->usart_fbrd =3D val32; + break; + case USART_LCRH: + s->usart_lcrh =3D val32; + break; + case USART_CTL: + s->usart_ctl =3D val32; + break; + case USART_IFLS: + s->usart_ifls =3D val32; + break; + case USART_IM: + s->usart_im =3D val32; + break; + case USART_RIS: + READONLY; + break; + case USART_MIS: + READONLY; + break; + case USART_ICR: + s->usart_icr =3D val32; + break; + case USART_DMA_CTL: + s->usart_dma_ctl =3D val32; + break; + case USART_9BIT_ADDR: + s->usart_9bit_addr =3D val32; + break; + case USART_9BIT_MASK: + s->usart_9bit_mask =3D val32; + break; + case USART_PP: + READONLY; + break; + case USART_CC: + s->usart_cc =3D val32; + break; + case USART_PER_ID4: + READONLY; + break; + case USART_PER_ID5: + READONLY; + break; + case USART_PER_ID6: + READONLY; + break; + case USART_PER_ID7: + READONLY; + break; + case USART_PER_ID0: + READONLY; + break; + case USART_PER_ID1: + READONLY; + break; + case USART_PER_ID2: + READONLY; + break; + case USART_PER_ID3: + READONLY; + break; + case USART_PCELL_ID0: + READONLY; + break; + case USART_PCELL_ID1: + READONLY; + break; + case USART_PCELL_ID2: + READONLY; + break; + case USART_PCELL_ID3: + READONLY; + break; + default: + LOG(LOG_GUEST_ERROR, "Bad address 0x%"HWADDR_PRIx"\n", addr); + return; + } + + return; +} + +static const MemoryRegionOps tm4c123_usart_ops =3D { + .read =3D tm4c123_usart_read, + .write =3D tm4c123_usart_write, + .endianness =3D DEVICE_NATIVE_ENDIAN, +}; + +static Property tm4c123_usart_properties[] =3D { + DEFINE_PROP_CHR("chardev", TM4C123USARTState, chr), + DEFINE_PROP_END_OF_LIST(), +}; + +static void tm4c123_usart_init(Object *obj) +{ + TM4C123USARTState *s =3D TM4C123_USART(obj); + + sysbus_init_irq(SYS_BUS_DEVICE(obj), &s->irq); + + memory_region_init_io(&s->mmio, obj, &tm4c123_usart_ops, s, + TYPE_TM4C123_USART, 0xFFF); + sysbus_init_mmio(SYS_BUS_DEVICE(obj), &s->mmio); +} + +static void tm4c123_usart_realize(DeviceState *dev, Error **errp) +{ + TM4C123USARTState *s =3D TM4C123_USART(dev); + + qemu_chr_fe_set_handlers(&s->chr, tm4c123_usart_can_receive, + tm4c123_usart_receive, NULL, NULL, + s, NULL, true); +} + +static void tm4c123_usart_class_init(ObjectClass *klass, void *data) +{ + DeviceClass *dc =3D DEVICE_CLASS(klass); + + dc->reset =3D tm4c123_usart_reset; + device_class_set_props(dc, tm4c123_usart_properties); + dc->realize =3D tm4c123_usart_realize; +} + +static const TypeInfo tm4c123_usart_info =3D { + .name =3D TYPE_TM4C123_USART, + .parent =3D TYPE_SYS_BUS_DEVICE, + .instance_size =3D sizeof(TM4C123USARTState), + .instance_init =3D tm4c123_usart_init, + .class_init =3D tm4c123_usart_class_init, +}; + +static void tm4c123_usart_register_types(void) +{ + type_register_static(&tm4c123_usart_info); +} + +type_init(tm4c123_usart_register_types) diff --git a/hw/char/trace-events b/hw/char/trace-events index 2ecb36232e..47b7e3b772 100644 --- a/hw/char/trace-events +++ b/hw/char/trace-events @@ -1,5 +1,9 @@ # See docs/devel/tracing.rst for syntax documentation. =20 +# tm4c123_usart.c +tm4c123_usart_read(uint64_t offset) " offset: 0x%" PRIu64 +tm4c123_usart_write(uint64_t offset, uint64_t value) " offset: 0x%" PRIu64= " - value: 0x%" PRIu64 + # parallel.c parallel_ioport_read(const char *desc, uint16_t addr, uint8_t value) "read= [%s] addr 0x%02x val 0x%02x" parallel_ioport_write(const char *desc, uint16_t addr, uint8_t value) "wri= te [%s] addr 0x%02x val 0x%02x" diff --git a/include/hw/char/tm4c123_usart.h b/include/hw/char/tm4c123_usar= t.h new file mode 100644 index 0000000000..be98eb3948 --- /dev/null +++ b/include/hw/char/tm4c123_usart.h @@ -0,0 +1,124 @@ +/* + * TM4C123 USART + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#ifndef HW_ARM_TM4C123_USART_H +#define HW_ARM_TM4C123_USART_H + +#include "hw/sysbus.h" +#include "qom/object.h" +#include "chardev/char-fe.h" +#include "hw/misc/tm4c123_sysctl.h" + +#define USART_DR 0x000 +#define USART_RSR 0x004 +#define USART_FR 0x018 +#define USART_ILPR 0x020 +#define USART_IBRD 0x024 +#define USART_FBRD 0x028 +#define USART_LCRH 0x02C +#define USART_CTL 0x030 +#define USART_IFLS 0x034 +#define USART_IM 0x038 +#define USART_RIS 0x03C +#define USART_MIS 0x040 +#define USART_ICR 0x044 +#define USART_DMA_CTL 0x048 +#define USART_9BIT_ADDR 0x0A4 +#define USART_9BIT_MASK 0x0A8 +#define USART_PP 0xFC0 +#define USART_CC 0xFC8 +#define USART_PER_ID4 0x0FD0 +#define USART_PER_ID5 0xFD4 +#define USART_PER_ID6 0xFD8 +#define USART_PER_ID7 0xFDC +#define USART_PER_ID0 0xFE0 +#define USART_PER_ID1 0xFE4 +#define USART_PER_ID2 0xFE8 +#define USART_PER_ID3 0xFEC +#define USART_PCELL_ID0 0xFF0 +#define USART_PCELL_ID1 0xFF4 +#define USART_PCELL_ID2 0xFF8 +#define USART_PCELL_ID3 0xFFC + +#define USART_FR_RXFF (1 << 6) +#define USART_FR_TXFF (1 << 5) +#define USART_FR_RXFE (1 << 4) +#define USART_FR_BUSY (1 << 3) +#define USART_CR_RXE (1 << 9) +#define USART_CR_EN (1 << 0) +#define USART_IM_RXIM (1 << 4) + +#define USART_0 0x4000C000 +#define USART_1 0x4000D000 +#define USART_2 0x4000E000 +#define USART_3 0x4000F000 +#define USART_4 0x40010000 +#define USART_5 0x40011000 +#define USART_6 0x40012000 +#define USART_7 0x40013000 +#define TYPE_TM4C123_USART "tm4c123-usart" + +OBJECT_DECLARE_SIMPLE_TYPE(TM4C123USARTState, TM4C123_USART) + +struct TM4C123USARTState { + SysBusDevice parent_obj; + MemoryRegion mmio; + + uint32_t usart_dr; + uint32_t usart_rsr; + uint32_t usart_fr; + uint32_t usart_ilpr; + uint32_t usart_ibrd; + uint32_t usart_fbrd; + uint32_t usart_lcrh; + uint32_t usart_ctl; + uint32_t usart_ifls; + uint32_t usart_im; + uint32_t usart_ris; + uint32_t usart_mis; + uint32_t usart_icr; + uint32_t usart_dma_ctl; + uint32_t usart_9bit_addr; + uint32_t usart_9bit_mask; + uint32_t usart_pp; + uint32_t usart_cc; + uint32_t usart_per_id4; + uint32_t usart_per_id5; + uint32_t usart_per_id6; + uint32_t usart_per_id7; + uint32_t usart_per_id0; + uint32_t usart_per_id1; + uint32_t usart_per_id2; + uint32_t usart_per_id3; + uint32_t usart_pcell_id0; + uint32_t usart_pcell_id1; + uint32_t usart_pcell_id2; + uint32_t usart_pcell_id3; + + CharBackend chr; + qemu_irq irq; + TM4C123SysCtlState *sysctl; +}; + +#endif --=20 2.34.1 From nobody Sat May 18 06:04:26 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1684311299; cv=none; d=zohomail.com; s=zohoarc; b=bz8w871K8VYT7qV3tOLE6A9fSSKD4btGUdb4QdaaDfzFyEXniPTOs1zr/0mKnvWSXsCViWqnv42fEWmXuv5mg40RZZNEkjsg1m9gxqL382l2AX6JorQr4AxSIw+4DnRZ03ofMrm1eKeoJ3cpv5/dUnr0I8mbuZVe1oJFffyKcQo= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1684311299; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=hKfFNcI7UZM1bQvwClQo6ytWJhhG6hGO4kDTfpv6SCQ=; b=nfjPsm2r5+2/YC1w3B4/U3z5VopzTmKdXOqVS8/J5gKMZY3u1wj1LqV7YeeczRXV/9Re2RC4tt/QNiv5QLCrbqezyrWXt3XHDdQxAl2aeTrs4P0luRay/m6ST1WKjujQRMgtH9Nc7pi8A0av+Grs74vd1wt8pp5KF7wOo0AQIw4= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1684311299327993.1922820893634; Wed, 17 May 2023 01:14:59 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1pzCGv-00062A-8d; Wed, 17 May 2023 04:12:33 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pzCGo-0005pJ-9M; Wed, 17 May 2023 04:12:26 -0400 Received: from mail-wm1-x32e.google.com ([2a00:1450:4864:20::32e]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1pzCGg-0003Kn-PN; Wed, 17 May 2023 04:12:25 -0400 Received: by mail-wm1-x32e.google.com with SMTP id 5b1f17b1804b1-3f41dceb9d4so4434235e9.1; Wed, 17 May 2023 01:12:17 -0700 (PDT) Received: from i.. ([41.236.82.205]) by smtp.gmail.com with ESMTPSA id o24-20020a1c7518000000b003f42158288dsm1414942wmc.20.2023.05.17.01.12.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 May 2023 01:12:13 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1684311137; x=1686903137; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=hKfFNcI7UZM1bQvwClQo6ytWJhhG6hGO4kDTfpv6SCQ=; b=N2gYqAzkheGEc2BAvwadiUwj6CnKiVcLWNnlGHF+0JQatTWnfRvG/x3PG82nziiDg8 SWogU5xkcKUiG/29DIqPxtV3+OG9R8HbHGjZQBvyT99WCnJBW/Tzx3EGb2JR2MTU90Ee /uc1EvzSMggzbHxQaayuaNO4ScKJ0HIG56QRv9XRsvnk2TTRUOuE9xu7YqKzJjILpLkg hj9xjg5W5sqf2Aavfvrw1kEIBD0QvVVl1IbZ4gJrAvnT23jfaf5PlYb4V/3r+sFF7wCt Egaka0/XAD7j5RcpvrkWhBG4fJs3m18yh+/Mhu+pFLVkV+4AcOut0zCS90D4gooYmU0a 9odw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1684311137; x=1686903137; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=hKfFNcI7UZM1bQvwClQo6ytWJhhG6hGO4kDTfpv6SCQ=; b=LP5MfAQiGGq1BVlcreX3Wel5CufxDmAAWCJVkq0x9O+C8RrL90Q24cLmLPDb8WA9Uq PNmfuP/lRuzhlM2K/LJQPM6f/kXusk/vyRw0ZAaJdkZb9rUix/y2aQjgJCzANNCUPomZ WVOlbM/NFSjw4LH3xCskAOi5uzpAnBWw3SCxUjETyFNpTqQROcqEr904055Hwepl6wH8 bp8EkZdgF6JWR94tl1SfCpjnOQPxf+5Y162zODUnSPi+CVMs0WkzHUFyd0k4DE0wXiAs zHZHVVaafUOyTT9xDvCx1xFzR4IWOb5tl5uK5z2mpD9HmhgGkTfxsbQdUWdZNM3lyNf4 S8QQ== X-Gm-Message-State: AC+VfDxT41mpKCq/8i1kqPf+bEWH4RJR2RpBPlI8ZeFoBcJu7KbZ1e43 b2L8jlIX+/d5QrnoZeOLCZ2moljYEVzr+g== X-Google-Smtp-Source: ACHHUZ7zXlfnSAURRzEHuXFUDX2oPxtcpFzJ9QN4B1w0eYzqQaf5Cvzx7ZeWGyeujgrTUxdj/4xH3w== X-Received: by 2002:a7b:c012:0:b0:3f0:9d1a:223b with SMTP id c18-20020a7bc012000000b003f09d1a223bmr30559950wmb.16.1684311136582; Wed, 17 May 2023 01:12:16 -0700 (PDT) From: Mohamed ElSayed To: qemu-devel@nongnu.org Cc: qemu-arm@nongnu.org, Mohamed ElSayed Subject: [PATCH 3/8] tiva c gpio implementation Date: Wed, 17 May 2023 11:11:59 +0300 Message-Id: <20230517081204.30333-4-m.elsayed4420@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230517081204.30333-1-m.elsayed4420@gmail.com> References: <20230517081204.30333-1-m.elsayed4420@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::32e; envelope-from=m.elsayed4420@gmail.com; helo=mail-wm1-x32e.google.com X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @gmail.com) X-ZM-MESSAGEID: 1684311299679100001 Content-Type: text/plain; charset="utf-8" Signed-off-by: Mohamed ElSayed --- hw/gpio/tm4c123_gpio.c | 372 +++++++++++++++++++++++++++++++++ hw/gpio/trace-events | 4 + include/hw/gpio/tm4c123_gpio.h | 127 +++++++++++ 3 files changed, 503 insertions(+) create mode 100644 hw/gpio/tm4c123_gpio.c create mode 100644 include/hw/gpio/tm4c123_gpio.h diff --git a/hw/gpio/tm4c123_gpio.c b/hw/gpio/tm4c123_gpio.c new file mode 100644 index 0000000000..9a27e0664e --- /dev/null +++ b/hw/gpio/tm4c123_gpio.c @@ -0,0 +1,372 @@ +/* + * TM4C123 GPIO + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#include "qemu/osdep.h" +#include "hw/gpio/tm4c123_gpio.h" +#include "qemu/log.h" +#include "qemu/module.h" +#include "hw/misc/tm4c123_sysctl.h" +#include "qemu/bitops.h" +#include "trace.h" + +#define LOG(mask, fmt, args...) qemu_log_mask(mask, "%s: " fmt, __func__, = ## args) +#define READONLY LOG(LOG_GUEST_ERROR, "0x%"HWADDR_PRIx" is a readonly fiel= d\n.", addr) + +static bool gpio_clock_enabled(TM4C123SysCtlState *s, hwaddr addr) +{ + switch(addr) { + case GPIO_A: + return test_bit(0, (const unsigned long*)&s->sysctl_rcgcgpio); + break; + case GPIO_B: + return test_bit(1, (const unsigned long*)&s->sysctl_rcgcgpio); + break; + case GPIO_C: + return test_bit(2, (const unsigned long*)&s->sysctl_rcgcgpio); + break; + case GPIO_D: + return test_bit(3, (const unsigned long*)&s->sysctl_rcgcgpio); + break; + case GPIO_E: + return test_bit(4, (const unsigned long*)&s->sysctl_rcgcgpio); + break; + case GPIO_F: + return test_bit(5, (const unsigned long*)&s->sysctl_rcgcgpio); + break; + } + return false; +} + +static void tm4c123_gpio_reset(DeviceState *dev) +{ + TM4C123GPIOState *s =3D TM4C123_GPIO(dev); + + s->gpio_data =3D 0x00000000; + s->gpio_dir =3D 0x00000000; + s->gpio_is =3D 0x00000000; + s->gpio_ibe =3D 0x00000000; + s->gpio_iev =3D 0x00000000; + s->gpio_im =3D 0x00000000; + s->gpio_ris =3D 0x00000000; + s->gpio_mis =3D 0x00000000; + s->gpio_icr =3D 0x00000000; + s->gpio_afsel =3D 0x00000000; + s->gpio_dr2r =3D 0x000000FF; + s->gpio_dr4r =3D 0x00000000; + s->gpio_dr8r =3D 0x00000000; + s->gpio_odr =3D 0x00000000; + s->gpio_pur =3D 0x00000000; + s->gpio_pdr =3D 0x00000000; + s->gpio_slr =3D 0x00000000; + s->gpio_den =3D 0x00000000; + s->gpio_lock =3D 0x00000001; + s->gpio_ocr =3D 0x00000000; + s->gpio_amsel =3D 0x00000000; + s->gpio_pctl =3D 0x00000000; + s->gpio_adcctl =3D 0x00000000; + s->gpio_dmactl =3D 0x00000000; + s->gpio_per_id4 =3D 0x00000000; + s->gpio_per_id5 =3D 0x00000000; + s->gpio_per_id6 =3D 0x00000000; + s->gpio_per_id7 =3D 0x00000000; + s->gpio_per_id0 =3D 0x00000061; + s->gpio_per_id1 =3D 0x00000000; + s->gpio_per_id2 =3D 0x00000018; + s->gpio_per_id3 =3D 0x00000001; + s->gpio_pcell_id0 =3D 0x0000000D; + s->gpio_pcell_id1 =3D 0x000000F0; + s->gpio_pcell_id2 =3D 0x00000005; + s->gpio_pcell_id3 =3D 0x000000B1; +} + +static void tm4c123_gpio_write(void *opaque, hwaddr addr, uint64_t val64, = unsigned int size) +{ + TM4C123GPIOState *s =3D opaque; + uint32_t val32 =3D val64; + + if (!gpio_clock_enabled(s->sysctl, s->mmio.addr)) { + hw_error("GPIO module clock is not enabled"); + } + trace_tm4c123_gpio_write(addr, val32); + + switch(addr) { + case GPIO_DATA: + { + uint32_t rising_edge =3D (val32 ^ s->gpio_data) & val32; + //level detection + s->gpio_mis =3D s->gpio_is & s->gpio_iev & val32; + s->gpio_mis |=3D s->gpio_is & ~(s->gpio_iev | val32); + s->gpio_mis &=3D s->gpio_im; + + //edge detection + //both edges + s->gpio_mis |=3D (s->gpio_is | s->gpio_ibe) & (~s->gpio_is= ); + //rising edge + s->gpio_mis |=3D (~(s->gpio_is | s->gpio_ibe | s->gpio_iev= )) & rising_edge; + //falling edge + s->gpio_mis |=3D ~(s->gpio_is | s->gpio_ibe | s->gpio_iev = | rising_edge); + s->gpio_mis &=3D s->gpio_im; + s->gpio_ris |=3D s->gpio_mis & val32; + + s->gpio_data =3D val32; + if (s->gpio_im !=3D 0) + qemu_irq_pulse(s->irq); + } + break; + case GPIO_DIR: + s->gpio_dir =3D val32; + break; + case GPIO_IS: + s->gpio_is =3D val32; + break; + case GPIO_IBE: + s->gpio_ibe =3D val32; + break; + case GPIO_IEV: + s->gpio_iev =3D val32; + break; + case GPIO_IM: + s->gpio_im =3D val32; + break; + case GPIO_RIS: + s->gpio_ris =3D val32; + break; + case GPIO_MIS: + READONLY; + break; + case GPIO_ICR: + s->gpio_mis ^=3D val32; + s->gpio_ris ^=3D val32; + s->gpio_icr =3D val32; + break; + case GPIO_AFSEL: + s->gpio_afsel =3D val32; + break; + case GPIO_DR2R: + s->gpio_dr2r =3D val32; + break; + case GPIO_DR4R: + s->gpio_dr4r =3D val32; + break; + case GPIO_DR8R: + s->gpio_dr8r =3D val32; + break; + case GPIO_ODR: + s->gpio_odr =3D val32; + break; + case GPIO_PUR: + s->gpio_pur =3D val32; + break; + case GPIO_PDR: + s->gpio_pdr =3D val32; + break; + case GPIO_SLR: + s->gpio_slr =3D val32; + break; + case GPIO_DEN: + s->gpio_den =3D val32; + break; + case GPIO_LOCK: + s->gpio_lock =3D val32; + break; + case GPIO_OCR: + s->gpio_ocr =3D val32; + break; + case GPIO_AMSEL: + s->gpio_amsel =3D val32; + break; + case GPIO_PCTL: + s->gpio_pctl =3D val32; + break; + case GPIO_ADCCTL: + s->gpio_adcctl =3D val32; + break; + case GPIO_DMACTL: + s->gpio_dmactl =3D val32; + break; + case GPIO_PER_ID4: + READONLY; + break; + case GPIO_PER_ID5: + READONLY; + break; + case GPIO_PER_ID6: + READONLY; + break; + case GPIO_PER_ID7: + READONLY; + break; + case GPIO_PER_ID0: + READONLY; + break; + case GPIO_PER_ID1: + READONLY; + break; + case GPIO_PER_ID2: + READONLY; + break; + case GPIO_PER_ID3: + READONLY; + break; + case GPIO_PCELL_ID0: + READONLY; + break; + case GPIO_PCELL_ID1: + READONLY; + break; + case GPIO_PCELL_ID2: + READONLY; + break; + case GPIO_PCELL_ID3: + READONLY; + break; + default: + LOG(LOG_GUEST_ERROR, "Bad address 0x%"HWADDR_PRIx"\n", addr); + } +} + +static uint64_t tm4c123_gpio_read(void *opaque, hwaddr addr, unsigned int = size) +{ + TM4C123GPIOState *s =3D opaque; + + trace_tm4c123_gpio_read(addr); + + if (!gpio_clock_enabled(s->sysctl, s->mmio.addr)) { + hw_error("GPIO module clock is not enabled"); + } + + switch(addr) { + case GPIO_DATA: + return s->gpio_data; + case GPIO_DIR: + return s->gpio_dir; + case GPIO_IS: + return s->gpio_is; + case GPIO_IBE: + return s->gpio_ibe; + case GPIO_IEV: + return s->gpio_iev; + case GPIO_IM: + return s->gpio_im; + case GPIO_RIS: + return s->gpio_ris; + case GPIO_MIS: + return s->gpio_mis; + case GPIO_ICR: + return s->gpio_icr; + case GPIO_AFSEL: + return s->gpio_afsel; + case GPIO_DR2R: + return s->gpio_dr2r; + case GPIO_DR4R: + return s->gpio_dr4r; + case GPIO_DR8R: + return s->gpio_dr8r; + case GPIO_ODR: + return s->gpio_odr; + case GPIO_PUR: + return s->gpio_pur; + case GPIO_PDR: + return s->gpio_pdr; + case GPIO_SLR: + return s->gpio_slr; + case GPIO_DEN: + return s->gpio_den; + case GPIO_LOCK: + return s->gpio_lock; + case GPIO_OCR: + return s->gpio_ocr; + case GPIO_AMSEL: + return s->gpio_amsel; + case GPIO_PCTL: + return s->gpio_pctl; + case GPIO_ADCCTL: + return s->gpio_adcctl; + case GPIO_DMACTL: + return s->gpio_dmactl; + case GPIO_PER_ID4: + return s->gpio_per_id4; + case GPIO_PER_ID5: + return s->gpio_per_id5; + case GPIO_PER_ID6: + return s->gpio_per_id6; + case GPIO_PER_ID7: + return s->gpio_per_id7; + case GPIO_PER_ID0: + return s->gpio_per_id0; + case GPIO_PER_ID1: + return s->gpio_per_id1; + case GPIO_PER_ID2: + return s->gpio_per_id2; + case GPIO_PER_ID3: + return s->gpio_per_id3; + case GPIO_PCELL_ID0: + return s->gpio_pcell_id0; + case GPIO_PCELL_ID1: + return s->gpio_pcell_id1; + case GPIO_PCELL_ID2: + return s->gpio_pcell_id2; + case GPIO_PCELL_ID3: + return s->gpio_pcell_id3; + default: + LOG(LOG_GUEST_ERROR, "Bad address 0x%"HWADDR_PRIx"\n", addr); + } + return 0; +} + +static const MemoryRegionOps tm4c123_gpio_ops =3D { + .read =3D tm4c123_gpio_read, + .write =3D tm4c123_gpio_write, + .endianness =3D DEVICE_NATIVE_ENDIAN, +}; + +static void tm4c123_gpio_init(Object *obj) +{ + TM4C123GPIOState *s =3D TM4C123_GPIO(obj); + + sysbus_init_irq(SYS_BUS_DEVICE(obj), &s->irq); + memory_region_init_io(&s->mmio, obj, &tm4c123_gpio_ops, s, TYPE_TM4C12= 3_GPIO, 0xFFF); + sysbus_init_mmio(SYS_BUS_DEVICE(obj), &s->mmio); +} + +static void tm4c123_gpio_class_init(ObjectClass *kclass, void *data) +{ + DeviceClass *dc =3D DEVICE_CLASS(kclass); + dc->reset =3D tm4c123_gpio_reset; +} + +static const TypeInfo tm4c123_gpio_info =3D { + .name =3D TYPE_TM4C123_GPIO, + .parent =3D TYPE_SYS_BUS_DEVICE, + .instance_size =3D sizeof(TM4C123GPIOState), + .instance_init =3D tm4c123_gpio_init, + .class_init =3D tm4c123_gpio_class_init, +}; + +static void tm4c123_gpio_register_types(void) +{ + type_register_static(&tm4c123_gpio_info); +} + +type_init(tm4c123_gpio_register_types) diff --git a/hw/gpio/trace-events b/hw/gpio/trace-events index 9736b362ac..22d282495d 100644 --- a/hw/gpio/trace-events +++ b/hw/gpio/trace-events @@ -1,5 +1,9 @@ # See docs/devel/tracing.rst for syntax documentation. =20 +# tm4c123_gpio.c +tm4c123_gpio_read(uint64_t offset) " offset: 0x%" PRIx64 +tm4c123_gpio_write(uint64_t offset, uint64_t value) " offset: 0x%" PRIx64 = " - value: 0x%" PRIx64 + # npcm7xx_gpio.c npcm7xx_gpio_read(const char *id, uint64_t offset, uint64_t value) " %s of= fset: 0x%04" PRIx64 " value 0x%08" PRIx64 npcm7xx_gpio_write(const char *id, uint64_t offset, uint64_t value) "%s of= fset: 0x%04" PRIx64 " value 0x%08" PRIx64 diff --git a/include/hw/gpio/tm4c123_gpio.h b/include/hw/gpio/tm4c123_gpio.h new file mode 100644 index 0000000000..5162e7bd53 --- /dev/null +++ b/include/hw/gpio/tm4c123_gpio.h @@ -0,0 +1,127 @@ +/* + * TM4C123 GPIO + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#ifndef HW_ARM_TM4C123_GPIO_H +#define HW_ARM_TM4C123_GPIO_H + +#include "hw/sysbus.h" +#include "hw/irq.h" +#include "qom/object.h" +#include "hw/misc/tm4c123_sysctl.h" + +/* #define GPIO_DATA 0x00 */ +#define GPIO_DATA 0x3FC +#define GPIO_DIR 0x400 +#define GPIO_IS 0x404 +#define GPIO_IBE 0x408 +#define GPIO_IEV 0x40C +#define GPIO_IM 0x410 +#define GPIO_RIS 0x414 +#define GPIO_MIS 0x418 +#define GPIO_ICR 0x41C +#define GPIO_AFSEL 0x420 +#define GPIO_DR2R 0x500 +#define GPIO_DR4R 0x504 +#define GPIO_DR8R 0x508 +#define GPIO_ODR 0x50C +#define GPIO_PUR 0x510 +#define GPIO_PDR 0x514 +#define GPIO_SLR 0x518 +#define GPIO_DEN 0x51C +#define GPIO_LOCK 0x520 +#define GPIO_OCR 0x524 +#define GPIO_AMSEL 0x528 +#define GPIO_PCTL 0x52C +#define GPIO_ADCCTL 0x530 +#define GPIO_DMACTL 0x534 +#define GPIO_PER_ID4 0xFD0 +#define GPIO_PER_ID5 0xFD4 +#define GPIO_PER_ID6 0xFD8 +#define GPIO_PER_ID7 0xFDC +#define GPIO_PER_ID0 0XFE0 +#define GPIO_PER_ID1 0xFE4 +#define GPIO_PER_ID2 0xFE8 +#define GPIO_PER_ID3 0xFEC +#define GPIO_PCELL_ID0 0xFF0 +#define GPIO_PCELL_ID1 0xFF4 +#define GPIO_PCELL_ID2 0xFF8 +#define GPIO_PCELL_ID3 0xFFC + +#define GPIO_A 0x40004000 +#define GPIO_B 0x40005000 +#define GPIO_C 0x40006000 +#define GPIO_D 0x40007000 +#define GPIO_E 0x40024000 +#define GPIO_F 0x40025000 + +#define TYPE_TM4C123_GPIO "tm4c123-gpio" + +OBJECT_DECLARE_SIMPLE_TYPE(TM4C123GPIOState, TM4C123_GPIO) + +struct TM4C123GPIOState { + SysBusDevice parent_obj; + MemoryRegion mmio; + + uint32_t gpio_data; + uint32_t gpio_dir; + uint32_t gpio_is; + uint32_t gpio_ibe; + uint32_t gpio_iev; + uint32_t gpio_im; + uint32_t gpio_ris; + uint32_t gpio_mis; + uint32_t gpio_icr; + uint32_t gpio_afsel; + uint32_t gpio_dr2r; + uint32_t gpio_dr4r; + uint32_t gpio_dr8r; + uint32_t gpio_odr; + uint32_t gpio_pur; + uint32_t gpio_pdr; + uint32_t gpio_slr; + uint32_t gpio_den; + uint32_t gpio_lock; + uint32_t gpio_ocr; + uint32_t gpio_amsel; + uint32_t gpio_pctl; + uint32_t gpio_adcctl; + uint32_t gpio_dmactl; + uint32_t gpio_per_id4; + uint32_t gpio_per_id5; + uint32_t gpio_per_id6; + uint32_t gpio_per_id7; + uint32_t gpio_per_id0; + uint32_t gpio_per_id1; + uint32_t gpio_per_id2; + uint32_t gpio_per_id3; + uint32_t gpio_pcell_id0; + uint32_t gpio_pcell_id1; + uint32_t gpio_pcell_id2; + uint32_t gpio_pcell_id3; + + qemu_irq irq; + TM4C123SysCtlState *sysctl; +}; + +#endif --=20 2.34.1 From nobody Sat May 18 06:04:26 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1684311272; cv=none; d=zohomail.com; s=zohoarc; b=meWAs/UsW6FhICQ4VHFB2LvsPvz7nrN9qHr/01uP2MLGskqNchjY/v7l52C0hDQnDYxJ138efYpBO3pC4OgPwxpIyiqcFSd+dtT0qx/tWSeNjb59li4SjGd0tcA5zZDMU2pVnNSCFzkhApJv4nrRhye6zFPRUahR30dOPbsOrLE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1684311272; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=0f4tT8d3urTRD4jqJYeSH/NEbZLE78HUw12SMr7FgyM=; b=XPkPsE3j/xfyHjutL+UsoqqqMzWcRfOnnm970GwOEuOvU955ko54bvH5lAuPr0JcskyFKZRT0oIySczkAAiu4DFpkFLtWqz40YOf47+hJMhv4/Vnqj/7QomLvEl2sOiztuiUlNPOv71/nagkATRSNKO6nvDmYxAv4SgGC5tU2gY= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1684311272472758.0313311875539; Wed, 17 May 2023 01:14:32 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1pzCGw-00063j-7H; Wed, 17 May 2023 04:12:34 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pzCGp-0005sV-Hx; Wed, 17 May 2023 04:12:27 -0400 Received: from mail-wm1-x32b.google.com ([2a00:1450:4864:20::32b]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1pzCGj-0003M5-G0; Wed, 17 May 2023 04:12:27 -0400 Received: by mail-wm1-x32b.google.com with SMTP id 5b1f17b1804b1-3f423ac6e2dso2794745e9.2; Wed, 17 May 2023 01:12:20 -0700 (PDT) Received: from i.. ([41.236.82.205]) by smtp.gmail.com with ESMTPSA id o24-20020a1c7518000000b003f42158288dsm1414942wmc.20.2023.05.17.01.12.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 May 2023 01:12:18 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1684311139; x=1686903139; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=0f4tT8d3urTRD4jqJYeSH/NEbZLE78HUw12SMr7FgyM=; b=GXhiQDiFQNXM+ZxkarCmg6Cl3B3aTAcIh7aCCTEvlgYDjNHMwfNZrEkY/sqVDiqzm1 0GdVGYVy7cXHOhRt960XDQ11rfqqwU2j5LWkOH0fAirVFL6nrTG92S69u55YuHYph4Ko X/ERt9U6Y+SL672b32N6mG1yEf0dg74HmTDG9MSUIZMJJRD3/1RMasEp5AVOr7PkvsPW n2U4kmvg551zdGWgI9e1jcdC+gxYWYxGw0i2cP0GkcWtlddqaK164iI95tX0ZuQqZHpx HI5HN+wCqeMnVV+pC4Y4d94Tr1ZqCI6Qpm6Ei0G1ffANx6nBSriffnGSkgGyuuomgza9 YyTA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1684311139; x=1686903139; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=0f4tT8d3urTRD4jqJYeSH/NEbZLE78HUw12SMr7FgyM=; b=fhkBSD+nPhShuL+GjQ0t/xYuC4RpaksbB1y4HsIFKma6pInHh3BMNfdPO28HRuakFi 2M7yF2OgjxKzK/vRx+Yt3fgMdjWIbqeIMKdh9aglqiPdJQAoYSABGd3StXS2PZrexY2d jI4SybWfDPCfgHh0O+UvV5pDhF25heb1JsC/3Y/n6hcU9i0P3gvedc9SqwoCn/0b6Q64 clAUktGg14n6X3ZLQdleMk8L4JXK18W38mp0ma5IhDHYY498nZxu64aE3DhejeoA6ZYm 7F+ezxfxCWNKynlMMkkN2/7qnbXZaOouUK1hVor34EPJX/aX52qcXin5o4N7SAPzJt0/ D+Ng== X-Gm-Message-State: AC+VfDyPjvVNht05gChLP64NUsx+3lJeZSzz9QOOLtgGSXFY+Xcvs4ad /1ozgscpE/ZVLXaNX1TrSAuMfVZvsu5G3Q== X-Google-Smtp-Source: ACHHUZ7SzZxkxX5htCFn9pvgKRyihNw32Sa4oUEMRh+T3UUPbmnef38BA+vn+/f06Dwd3qpejxPZPw== X-Received: by 2002:a05:600c:2119:b0:3f4:2c71:b9b1 with SMTP id u25-20020a05600c211900b003f42c71b9b1mr19439568wml.24.1684311139153; Wed, 17 May 2023 01:12:19 -0700 (PDT) From: Mohamed ElSayed To: qemu-devel@nongnu.org Cc: qemu-arm@nongnu.org, Mohamed ElSayed Subject: [PATCH 4/8] tiva c sysctl implementation Date: Wed, 17 May 2023 11:12:00 +0300 Message-Id: <20230517081204.30333-5-m.elsayed4420@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230517081204.30333-1-m.elsayed4420@gmail.com> References: <20230517081204.30333-1-m.elsayed4420@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::32b; envelope-from=m.elsayed4420@gmail.com; helo=mail-wm1-x32b.google.com X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @gmail.com) X-ZM-MESSAGEID: 1684311273788100001 Content-Type: text/plain; charset="utf-8" Signed-off-by: Mohamed ElSayed --- hw/misc/tm4c123_sysctl.c | 989 +++++++++++++++++++++++++++++++ hw/misc/trace-events | 5 + include/hw/misc/tm4c123_sysctl.h | 307 ++++++++++ 3 files changed, 1301 insertions(+) create mode 100644 hw/misc/tm4c123_sysctl.c create mode 100644 include/hw/misc/tm4c123_sysctl.h diff --git a/hw/misc/tm4c123_sysctl.c b/hw/misc/tm4c123_sysctl.c new file mode 100644 index 0000000000..c996609fc7 --- /dev/null +++ b/hw/misc/tm4c123_sysctl.c @@ -0,0 +1,989 @@ +/* + * TM4C123 SYSCTL + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#include "qemu/osdep.h" +#include "hw/misc/tm4c123_sysctl.h" +#include "qemu/log.h" +#include "qemu/module.h" +#include "trace.h" + +#define LOG(mask, fmt, args...) qemu_log_mask(mask, "%s: " fmt, __func__, = ## args) +#define READONLY LOG(LOG_GUEST_ERROR, "0x%"HWADDR_PRIx" is a readonly fiel= d\n.", addr) + +static void tm4c123_sysctl_update_system_clock(void *opaque) +{ + TM4C123SysCtlState *s =3D opaque; + + uint32_t RCC_Val =3D s->sysctl_rcc; + uint32_t RCC2_Val =3D s->sysctl_rcc2; + + uint32_t __CORE_CLK_PRE; + uint32_t __CORE_CLK; + + if (RCC2_Val & (1UL << 31)) { /* is rcc2 used? */ + if (RCC2_Val & (1UL << 11)) { /* check BYPASS */ + if (((RCC2_Val >> 4) & 0x07) =3D=3D 0x0) { + if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x0) { + __CORE_CLK_PRE =3D 1000000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x1) { + __CORE_CLK_PRE =3D 1843200UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x2) { + __CORE_CLK_PRE =3D 2000000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x3) { + __CORE_CLK_PRE =3D 2457600UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x4) { + __CORE_CLK_PRE =3D 3579545UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x5) { + __CORE_CLK_PRE =3D 3686400UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x6) { + __CORE_CLK_PRE =3D 4000000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x7) { + __CORE_CLK_PRE =3D 4096000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x8) { + __CORE_CLK_PRE =3D 4915200UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x9) { + __CORE_CLK_PRE =3D 5000000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0xA) { + __CORE_CLK_PRE =3D 5120000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0xB) { + __CORE_CLK_PRE =3D 6000000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0xC) { + __CORE_CLK_PRE =3D 6144000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0xD) { + __CORE_CLK_PRE =3D 7372800UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0xE) { + __CORE_CLK_PRE =3D 8000000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0xF) { + __CORE_CLK_PRE =3D 8192000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x10) { + __CORE_CLK_PRE =3D 10000000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x11) { + __CORE_CLK_PRE =3D 12000000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x12) { + __CORE_CLK_PRE =3D 12288000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x13) { + __CORE_CLK_PRE =3D 13560000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x14) { + __CORE_CLK_PRE =3D 14318180UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x15) { + __CORE_CLK_PRE =3D 16000000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x16) { + __CORE_CLK_PRE =3D 16384000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x17) { + __CORE_CLK_PRE =3D 18000000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x18) { + __CORE_CLK_PRE =3D 20000000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x19) { + __CORE_CLK_PRE =3D 24000000UL; + } else if (((RCC_Val >> 6) & 0x1F) =3D=3D 0x1A) { + __CORE_CLK_PRE =3D 25000000UL; + } else { + __CORE_CLK_PRE =3D 0UL; + } + __CORE_CLK =3D __CORE_CLK_PRE / 2UL; /* divide by 2 since= BYPASS is set */ + } else { /* PLL is used */ + uint32_t __PLL_MULT =3D ((RCC2_Val >> 4) & 0x1F) + 2; + uint32_t __PLL_DIV =3D ((RCC2_Val >> 0) & 0x3F) + 1; + uint32_t __PLL_SOURCE =3D ((RCC2_Val >> 13) & 0x01); + if (__PLL_SOURCE =3D=3D 0) { /* source is XTAL */ + __CORE_CLK_PRE =3D (XTALI * __PLL_MULT) / __PLL_DIV; + } else { /* source is internal oscillator */ + __CORE_CLK_PRE =3D (16000000UL * __PLL_MULT) / __PLL_D= IV; /* internal oscillator frequency is 16MHz */ + } + __CORE_CLK =3D __CORE_CLK_PRE / 2UL; /* divide by 2 since= BYPASS is set */ + } + } else { /* BYPASS is not set */ + uint32_t __SYS_DIV =3D ((RCC2_Val >> 22) & 0x7F) + 1; + uint32_t __PLL_MULT =3D ((RCC2_Val >> 4) & 0x1F) + 2; + uint32_t __PLL_DIV =3D ((RCC2_Val >> 0) & 0x3F) + 1; + uint32_t __PLL_SOURCE =3D ((RCC2_Val >> 13) & 0x01); + if (__PLL_SOURCE =3D=3D 0) { /* source is XTAL */ + __CORE_CLK_PRE =3D (XTALI * __PLL_MULT) / __PLL_DIV; + } else { /* source is internal oscillator */ + __CORE_CLK_PRE =3D (16000000UL * __PLL_MULT) / __PLL_DIV; = /* internal oscillator frequency is 16MHz */ + } + __CORE_CLK =3D __CORE_CLK_PRE / __SYS_DIV; + } + } else { /* rcc2 is not used */ + if (((RCC_Val >> 16) & 0x01) =3D=3D 0x01) { /* check USESYSCLK */ + if (((RCC_Val >> 23) & 0x01) =3D=3D 0x01) { /* check BYPASS */ + __CORE_CLK_PRE =3D XTALI; + } else { /* PLL is used */ + uint32_t __PLL_MULT =3D ((RCC_Val >> 18) & 0x1F) + 2; + uint32_t __PLL_DIV =3D ((RCC_Val >> 12) & 0x3F) + 1; + uint32_t __PLL_SOURCE =3D ((RCC_Val >> 16) & 0x01); + if (__PLL_SOURCE =3D=3D 0) { /* source is XTAL */ + __CORE_CLK_PRE =3D (XTALI * __PLL_MULT) / __PLL_DIV; + } else { /* source is internal oscillator */ + __CORE_CLK_PRE =3D (16000000UL * __PLL_MULT) / __PLL_D= IV; /* internal oscillator frequency is 16MHz */ + } + } + } else { /* USESYSCLK bit is not set */ + __CORE_CLK_PRE =3D 16000000UL; /* default to internal oscilla= tor frequency */ + } + __CORE_CLK =3D __CORE_CLK_PRE / 1UL; /* no division needed since = BYPASS is not set */ + } + trace_tm4c123_sysctl_update_system_clock(__CORE_CLK); + clock_update_hz(s->mainclk, __CORE_CLK); +} + +static void tm4c123_sysctl_reset(DeviceState *dev) +{ + TM4C123SysCtlState *s =3D TM4C123_SYSCTL(dev); + + s->sysctl_did0 =3D 0x00000000; + s->sysctl_did1 =3D 0x10A1606E; + s->sysctl_pborctl =3D 0x00000000; + s->sysctl_ris =3D 0x00000000; + s->sysctl_imc =3D 0x00000000; + s->sysctl_misc =3D 0x00000000; + s->sysctl_resc =3D 0x00000000; + s->sysctl_rcc =3D 0x078E3AD1; + s->sysctl_gpiohbctl =3D 0x00007E00; + s->sysctl_rcc2 =3D 0x07C06810; + s->sysctl_moscctl =3D 0x00000000; + s->sysctl_dslpclkcfg =3D 0x07800000; + s->sysctl_sysprop =3D 0x00001D31; + s->sysctl_piosccal =3D 0x00000000; + s->sysctl_pioscstat =3D 0x00000040; + s->sysctl_pllfreq0 =3D 0x00000032; + s->sysctl_pllfreq1 =3D 0x00000001; + s->sysctl_pllstat =3D 0x00000000; + s->sysctl_slppwrcfg =3D 0x00000000; + s->sysctl_dslppwrcfg =3D 0x00000000; + s->sysctl_ldospctl =3D 0x00000018; + s->sysctl_ldospcal =3D 0x00001818; + s->sysctl_ldodpctl =3D 0x00000012; + s->sysctl_ldodpcal =3D 0x00001212; + s->sysctl_sdpmst =3D 0x00000000; + s->sysctl_ppwd =3D 0x00000003; + s->sysctl_pptimer =3D 0x0000003F; + s->sysctl_ppgpio =3D 0x0000003F; + s->sysctl_ppdma =3D 0x00000001; + s->sysctl_pphib =3D 0x00000001; + s->sysctl_ppuart =3D 0x000000FF; + s->sysctl_ppsi =3D 0x0000000F; + s->sysctl_ppi2c =3D 0x0000000F; + s->sysctl_ppusb =3D 0x00000001; + s->sysctl_ppcan =3D 0x00000003; + s->sysctl_ppadc =3D 0x00000003; + s->sysctl_ppacmp =3D 0x00000001; + s->sysctl_pppwm =3D 0x00000003; + s->sysctl_ppqei =3D 0x00000003; + s->sysctl_ppeeprom =3D 0x00000001; + s->sysctl_ppwtimer =3D 0x0000003F; + s->sysctl_srwd =3D 0x00000000; + s->sysctl_srtimer =3D 0x00000000; + s->sysctl_srgpio =3D 0x00000000; + s->sysctl_srdma =3D 0x00000000; + s->sysctl_srhib =3D 0x00000000; + s->sysctl_sruart =3D 0x00000000; + s->sysctl_srssi =3D 0x00000000; + s->sysctl_sri2c =3D 0x00000000; + s->sysctl_srusb =3D 0x00000000; + s->sysctl_srcan =3D 0x00000000; + s->sysctl_sradc =3D 0x00000000; + s->sysctl_sracmp =3D 0x00000000; + s->sysctl_srpwm =3D 0x00000000; + s->sysctl_srqei =3D 0x00000000; + s->sysctl_sreeprom =3D 0x00000000; + s->sysctl_srwtimer =3D 0x00000000; + s->sysctl_rcgcwd =3D 0x00000000; + s->sysctl_rcgctimer =3D 0x00000000; + s->sysctl_rcgcgpio =3D 0x00000000; + s->sysctl_rcgcdma =3D 0x00000000; + s->sysctl_rcgchib =3D 0x00000001; + s->sysctl_rcgcuart =3D 0x00000000; + s->sysctl_rcgcssi =3D 0x00000000; + s->sysctl_rcgci2c =3D 0x00000000; + s->sysctl_rcgcusb =3D 0x00000000; + s->sysctl_rcgccan =3D 0x00000000; + s->sysctl_rcgcadc =3D 0x00000000; + s->sysctl_rcgcacmp =3D 0x00000000; + s->sysctl_rcgcpwm =3D 0x00000000; + s->sysctl_rcgcqei =3D 0x00000000; + s->sysctl_rcgceeprom =3D 0x00000000; + s->sysctl_rcgcwtimer =3D 0x00000000; + s->sysctl_scgcwd =3D 0x00000000; + s->sysctl_scgctimer =3D 0x00000000; + s->sysctl_scgcgpio =3D 0x00000000; + s->sysctl_scgcdma =3D 0x00000000; + s->sysctl_scgchib =3D 0x00000001; + s->sysctl_scgcuart =3D 0x00000000; + s->sysctl_scgcssi =3D 0x00000000; + s->sysctl_scgci2c =3D 0x00000000; + s->sysctl_scgcusb =3D 0x00000000; + s->sysctl_scgccan =3D 0x00000000; + s->sysctl_scgcadc =3D 0x00000000; + s->sysctl_scgcacmp =3D 0x00000000; + s->sysctl_scgcpwm =3D 0x00000000; + s->sysctl_scgcqei =3D 0x00000000; + s->sysctl_scgceeprom =3D 0x00000000; + s->sysctl_scgcwtimer =3D 0x00000000; + s->sysctl_dcgcwd =3D 0x00000000; + s->sysctl_dcgctimer =3D 0x00000000; + s->sysctl_dcgcgpio =3D 0x00000000; + s->sysctl_dcgcdma =3D 0x00000000; + s->sysctl_dcgchib =3D 0x00000001; + s->sysctl_dcgcuart =3D 0x00000000; + s->sysctl_dcgcssi =3D 0x00000000; + s->sysctl_dcgci2c =3D 0x00000000; + s->sysctl_dcgcusb =3D 0x00000000; + s->sysctl_dcgccan =3D 0x00000000; + s->sysctl_dcgcadc =3D 0x00000000; + s->sysctl_dcgcacmp =3D 0x00000000; + s->sysctl_dcgcpwm =3D 0x00000000; + s->sysctl_dcgcqei =3D 0x00000000; + s->sysctl_dcgceeprom =3D 0x00000000; + s->sysctl_dcgcwtime =3D 0x00000000; + s->sysctl_prwd =3D 0x00000000; + s->sysctl_prtimer =3D 0x00000000; + s->sysctl_prgpio =3D 0x00000000; + s->sysctl_prdma =3D 0x00000000; + s->sysctl_prhib =3D 0x00000001; + s->sysctl_pruart =3D 0x00000000; + s->sysctl_prssi =3D 0x00000000; + s->sysctl_pri2c =3D 0x00000000; + s->sysctl_prusb =3D 0x00000000; + s->sysctl_prcan =3D 0x00000000; + s->sysctl_pradc =3D 0x00000000; + s->sysctl_pracmp =3D 0x00000000; + s->sysctl_prpwm =3D 0x00000000; + s->sysctl_prqei =3D 0x00000000; + s->sysctl_preeprom =3D 0x00000000; + s->sysctl_prwtimer =3D 0x00000000; +} + +static void tm4c123_sysctl_write(void *opaque, hwaddr addr, uint64_t val64= , unsigned int size) +{ + TM4C123SysCtlState *s =3D opaque; + uint32_t val32 =3D val64; + + trace_tm4c123_sysctl_write(addr, val32); + + switch (addr) { + case SYSCTL_DID0: + READONLY; + break; + case SYSCTL_DID1: + READONLY; + break; + case SYSCTL_PBORCTL: + s->sysctl_pborctl =3D val32; + break; + case SYSCTL_RIS: + READONLY; + break; + case SYSCTL_IMC: + s->sysctl_imc =3D val32; + /* + * setting the MISC + */ + s->sysctl_misc =3D val32; + break; + case SYSCTL_MISC: + s->sysctl_misc =3D val32; + break; + case SYSCTL_RESC: + s->sysctl_resc =3D val32; + break; + case SYSCTL_RCC: + s->sysctl_rcc =3D val32; + /* + * Setting the SYSCTL_RIS manually for now. + */ + if (s->sysctl_rcc & SYSCTL_RCC_PWRDN && !(s->sysctl_rcc2 & SYS= CTL_RCC2_USERCC2)) { + s->sysctl_ris |=3D SYSCTL_RIS_PLLRIS; + } + tm4c123_sysctl_update_system_clock(s); + break; + case SYSCTL_GPIOHBCTL: + s->sysctl_gpiohbctl =3D val32; + break; + case SYSCTL_RCC2: + s->sysctl_rcc2 =3D val32; + /* + * Setting the SYSCTL_RIS manually for now. + */ + if (s->sysctl_rcc2 & SYSCTL_RCC2_USERCC2 && !(s->sysctl_rcc2 &= SYSCTL_RCC2_PWRDN2)) { + s->sysctl_ris |=3D SYSCTL_RIS_PLLRIS; + } + tm4c123_sysctl_update_system_clock(s); + break; + case SYSCTL_MOSCCTL: + s->sysctl_moscctl =3D val32; + break; + case SYSCTL_DSLPCLKCFG: + s->sysctl_dslpclkcfg =3D val32; + break; + case SYSCTL_SYSPROP: + READONLY; + break; + case SYSCTL_PIOSCCAL: + s->sysctl_piosccal =3D val32; + break; + case SYSCTL_PIOSCSTAT: + READONLY; + break; + case SYSCTL_PLLFREQ0: + READONLY; + break; + case SYSCTL_PLLFREQ1: + READONLY; + break; + case SYSCTL_PLLSTAT: + READONLY; + break; + case SYSCTL_SLPPWRCFG: + s->sysctl_slppwrcfg =3D val32; + break; + case SYSCTL_DSLPPWRCFG: + s->sysctl_dslppwrcfg =3D val32; + break; + case SYSCTL_LDOSPCTL: + s->sysctl_ldospctl =3D val32; + break; + case SYSCTL_LDOSPCAL: + READONLY; + break; + case SYSCTL_LDODPCTL: + s->sysctl_ldodpctl =3D val32; + break; + case SYSCTL_LDODPCAL: + READONLY; + break; + case SYSCTL_SDPMST: + s->sysctl_sdpmst =3D val32; + break; + case SYSCTL_PPWD: + READONLY; + break; + case SYSCTL_PPTIMER: + READONLY; + break; + case SYSCTL_PPGPIO: + READONLY; + break; + case SYSCTL_PPDMA: + READONLY; + break; + case SYSCTL_PPHIB: + READONLY; + break; + case SYSCTL_PPUART: + READONLY; + break; + case SYSCTL_PPSI: + READONLY; + break; + case SYSCTL_PPI2C: + READONLY; + break; + case SYSCTL_PPUSB: + READONLY; + break; + case SYSCTL_PPCAN: + READONLY; + break; + case SYSCTL_PPADC: + READONLY; + break; + case SYSCTL_PPACMP: + READONLY; + break; + case SYSCTL_PPPWM: + READONLY; + break; + case SYSCTL_PPQEI: + READONLY; + break; + case SYSCTL_PPEEPROM: + READONLY; + break; + case SYSCTL_PPWTIMER: + READONLY; + break; + case SYSCTL_SRWD: + s->sysctl_srwd =3D val32; + break; + case SYSCTL_SRTIMER: + s->sysctl_srtimer =3D val32; + break; + case SYSCTL_SRGPIO: + s->sysctl_srgpio =3D val32; + break; + case SYSCTL_SRDMA: + s->sysctl_srdma =3D val32; + break; + case SYSCTL_SRHIB: + s->sysctl_srhib =3D val32; + break; + case SYSCTL_SRUART: + s->sysctl_sruart =3D val32; + break; + case SYSCTL_SRSSI: + s->sysctl_srssi =3D val32; + break; + case SYSCTL_SRI2C: + s->sysctl_sri2c =3D val32; + break; + case SYSCTL_SRUSB: + s->sysctl_srusb =3D val32; + break; + case SYSCTL_SRCAN: + s->sysctl_srcan =3D val32; + break; + case SYSCTL_SRADC: + s->sysctl_sradc =3D val32; + break; + case SYSCTL_SRACMP: + s->sysctl_sracmp =3D val32; + break; + case SYSCTL_SRPWM: + s->sysctl_srpwm =3D val32; + break; + case SYSCTL_SRQEI: + s->sysctl_srqei =3D val32; + break; + case SYSCTL_SREEPROM: + s->sysctl_sreeprom =3D val32; + break; + case SYSCTL_SRWTIMER: + s->sysctl_srwtimer =3D val32; + break; + case SYSCTL_RCGCWD: + s->sysctl_rcgcwd =3D val32; + break; + case SYSCTL_RCGCTIMER: + s->sysctl_rcgctimer =3D val32; + break; + case SYSCTL_RCGCGPIO: + s->sysctl_rcgcgpio =3D val32; + s->sysctl_prgpio =3D val32; + break; + case SYSCTL_RCGCDMA: + s->sysctl_rcgcdma =3D val32; + s->sysctl_prdma =3D val32; + break; + case SYSCTL_RCGCHIB: + s->sysctl_rcgchib =3D val32; + s->sysctl_prhib =3D val32; + break; + case SYSCTL_RCGCUART: + s->sysctl_rcgcuart =3D val32; + s->sysctl_pruart =3D val32; + break; + case SYSCTL_RCGCSSI: + s->sysctl_rcgcssi =3D val32; + s->sysctl_prssi =3D val32; + break; + case SYSCTL_RCGCI2C: + s->sysctl_rcgci2c =3D val32; + s->sysctl_pri2c =3D val32; + break; + case SYSCTL_RCGCUSB: + s->sysctl_rcgcusb =3D val32; + s->sysctl_prusb =3D val32; + break; + case SYSCTL_RCGCCAN: + s->sysctl_rcgccan =3D val32; + s->sysctl_prcan =3D val32; + break; + case SYSCTL_RCGCADC: + s->sysctl_rcgcadc =3D val32; + s->sysctl_pradc =3D val32; + break; + case SYSCTL_RCGCACMP: + s->sysctl_rcgcacmp =3D val32; + s->sysctl_pracmp =3D val32; + break; + case SYSCTL_RCGCPWM: + s->sysctl_rcgcpwm =3D val32; + s->sysctl_prpwm =3D val32; + break; + case SYSCTL_RCGCQEI: + s->sysctl_rcgcqei =3D val32; + s->sysctl_prqei =3D val32; + break; + case SYSCTL_RCGCEEPROM: + s->sysctl_rcgceeprom =3D val32; + s->sysctl_preeprom =3D val32; + break; + case SYSCTL_RCGCWTIMER: + s->sysctl_rcgcwtimer =3D val32; + s->sysctl_prwtimer =3D val32; + break; + case SYSCTL_SCGCWD: + s->sysctl_scgcwd =3D val32; + break; + case SYSCTL_SCGCTIMER: + s->sysctl_scgctimer =3D val32; + break; + case SYSCTL_SCGCGPIO: + s->sysctl_scgcgpio =3D val32; + break; + case SYSCTL_SCGCDMA: + s->sysctl_scgcdma =3D val32; + break; + case SYSCTL_SCGCHIB: + s->sysctl_scgchib =3D val32; + break; + case SYSCTL_SCGCUART: + s->sysctl_scgcuart =3D val32; + break; + case SYSCTL_SCGCSSI: + s->sysctl_scgcssi =3D val32; + break; + case SYSCTL_SCGCI2C: + s->sysctl_scgci2c =3D val32; + break; + case SYSCTL_SCGCUSB: + s->sysctl_scgcusb =3D val32; + break; + case SYSCTL_SCGCCAN: + s->sysctl_scgccan =3D val32; + break; + case SYSCTL_SCGCADC: + s->sysctl_scgcadc =3D val32; + break; + case SYSCTL_SCGCACMP: + s->sysctl_scgcacmp =3D val32; + break; + case SYSCTL_SCGCPWM: + s->sysctl_scgcpwm =3D val32; + break; + case SYSCTL_SCGCQEI: + s->sysctl_scgcqei =3D val32; + break; + case SYSCTL_SCGCEEPROM: + s->sysctl_scgceeprom =3D val32; + break; + case SYSCTL_SCGCWTIMER: + s->sysctl_scgcwtimer =3D val32; + break; + case SYSCTL_DCGCWD: + s->sysctl_dcgcwd =3D val32; + break; + case SYSCTL_DCGCTIMER: + s->sysctl_dcgctimer =3D val32; + break; + case SYSCTL_DCGCGPIO: + s->sysctl_dcgcgpio =3D val32; + break; + case SYSCTL_DCGCDMA: + s->sysctl_dcgcdma =3D val32; + break; + case SYSCTL_DCGCHIB: + s->sysctl_dcgchib =3D val32; + break; + case SYSCTL_DCGCUART: + s->sysctl_dcgcuart =3D val32; + break; + case SYSCTL_DCGCSSI: + s->sysctl_dcgcssi =3D val32; + break; + case SYSCTL_DCGCI2C: + s->sysctl_dcgci2c =3D val32; + break; + case SYSCTL_DCGCUSB: + s->sysctl_dcgcusb =3D val32; + break; + case SYSCTL_DCGCCAN: + s->sysctl_dcgccan =3D val32; + break; + case SYSCTL_DCGCADC: + s->sysctl_dcgcadc =3D val32; + break; + case SYSCTL_DCGCACMP: + s->sysctl_dcgcacmp =3D val32; + break; + case SYSCTL_DCGCPWM: + s->sysctl_dcgcpwm =3D val32; + break; + case SYSCTL_DCGCQEI: + s->sysctl_dcgcqei =3D val32; + break; + case SYSCTL_DCGCEEPROM: + s->sysctl_dcgceeprom =3D val32; + break; + case SYSCTL_DCGCWTIME: + s->sysctl_dcgcwtime =3D val32; + break; + case SYSCTL_PRWD: + READONLY; + break; + case SYSCTL_PRTIMER: + READONLY; + break; + case SYSCTL_PRGPIO: + READONLY; + break; + case SYSCTL_PRDMA: + READONLY; + break; + case SYSCTL_PRHIB: + READONLY; + break; + case SYSCTL_PRUART: + READONLY; + break; + case SYSCTL_PRSSI: + READONLY; + break; + case SYSCTL_PRI2C: + READONLY; + break; + case SYSCTL_PRUSB: + READONLY; + break; + case SYSCTL_PRCAN: + READONLY; + break; + case SYSCTL_PRADC: + READONLY; + break; + case SYSCTL_PRACMP: + READONLY; + break; + case SYSCTL_PRPWM: + READONLY; + break; + case SYSCTL_PRQEI: + READONLY; + break; + case SYSCTL_PREEPROM: + READONLY; + break; + case SYSCTL_PRWTIMER: + READONLY; + break; + default: + LOG(LOG_GUEST_ERROR, "Bad address 0x%"HWADDR_PRIx"\n", addr); + break; + } +} + +static uint64_t tm4c123_sysctl_read(void *opaque, hwaddr addr, unsigned in= t size) +{ + TM4C123SysCtlState *s =3D opaque; + + trace_tm4c123_sysctl_read(addr); + + switch (addr) { + case SYSCTL_DID0: + return s->sysctl_did0; + case SYSCTL_DID1: + return s->sysctl_did1; + case SYSCTL_PBORCTL: + return s->sysctl_pborctl; + case SYSCTL_RIS: + return s->sysctl_ris; + case SYSCTL_IMC: + return s->sysctl_imc; + case SYSCTL_MISC: + return s->sysctl_misc; + case SYSCTL_RESC: + return s->sysctl_resc; + case SYSCTL_RCC: + return s->sysctl_rcc; + case SYSCTL_GPIOHBCTL: + return s->sysctl_gpiohbctl; + case SYSCTL_RCC2: + return s->sysctl_rcc2; + case SYSCTL_MOSCCTL: + return s->sysctl_moscctl; + case SYSCTL_DSLPCLKCFG: + return s->sysctl_dslpclkcfg; + case SYSCTL_SYSPROP: + return s->sysctl_sysprop; + case SYSCTL_PIOSCCAL: + return s->sysctl_piosccal; + case SYSCTL_PIOSCSTAT: + return s->sysctl_pioscstat; + case SYSCTL_PLLFREQ0: + return s->sysctl_pllfreq0; + case SYSCTL_PLLFREQ1: + return s->sysctl_pllfreq1; + case SYSCTL_PLLSTAT: + return s->sysctl_pllstat; + case SYSCTL_SLPPWRCFG: + return s->sysctl_slppwrcfg; + case SYSCTL_DSLPPWRCFG: + return s->sysctl_dslppwrcfg; + case SYSCTL_LDOSPCTL: + return s->sysctl_ldospctl; + case SYSCTL_LDOSPCAL: + return s->sysctl_ldospcal; + case SYSCTL_LDODPCTL: + return s->sysctl_ldodpctl; + case SYSCTL_LDODPCAL: + return s->sysctl_ldodpcal; + case SYSCTL_SDPMST: + return s->sysctl_sdpmst; + case SYSCTL_PPWD: + return s->sysctl_ppwd; + case SYSCTL_PPTIMER: + return s->sysctl_pptimer; + case SYSCTL_PPGPIO: + return s->sysctl_ppgpio; + case SYSCTL_PPDMA: + return s->sysctl_ppdma; + case SYSCTL_PPHIB: + return s->sysctl_pphib; + case SYSCTL_PPUART: + return s->sysctl_ppuart; + case SYSCTL_PPSI: + return s->sysctl_ppsi; + case SYSCTL_PPI2C: + return s->sysctl_ppi2c; + case SYSCTL_PPUSB: + return s->sysctl_ppusb; + case SYSCTL_PPCAN: + return s->sysctl_ppcan; + case SYSCTL_PPADC: + return s->sysctl_ppadc; + case SYSCTL_PPACMP: + return s->sysctl_ppacmp; + case SYSCTL_PPPWM: + return s->sysctl_pppwm; + case SYSCTL_PPQEI: + return s->sysctl_ppqei; + case SYSCTL_PPEEPROM: + return s->sysctl_ppeeprom; + case SYSCTL_PPWTIMER: + return s->sysctl_ppwtimer; + case SYSCTL_SRWD: + return s->sysctl_srwd; + case SYSCTL_SRTIMER: + return s->sysctl_srtimer; + case SYSCTL_SRGPIO: + return s->sysctl_srgpio; + case SYSCTL_SRDMA: + return s->sysctl_srdma; + case SYSCTL_SRHIB: + return s->sysctl_srhib; + case SYSCTL_SRUART: + return s->sysctl_sruart; + case SYSCTL_SRSSI: + return s->sysctl_srssi; + case SYSCTL_SRI2C: + return s->sysctl_sri2c; + case SYSCTL_SRUSB: + return s->sysctl_srusb; + case SYSCTL_SRCAN: + return s->sysctl_srcan; + case SYSCTL_SRADC: + return s->sysctl_sradc; + case SYSCTL_SRACMP: + return s->sysctl_sracmp; + case SYSCTL_SRPWM: + return s->sysctl_srpwm; + case SYSCTL_SRQEI: + return s->sysctl_srqei; + case SYSCTL_SREEPROM: + return s->sysctl_sreeprom; + case SYSCTL_SRWTIMER: + return s->sysctl_srwtimer; + case SYSCTL_RCGCWD: + return s->sysctl_rcgcwd; + case SYSCTL_RCGCTIMER: + return s->sysctl_rcgctimer; + case SYSCTL_RCGCGPIO: + return s->sysctl_rcgcgpio; + case SYSCTL_RCGCDMA: + return s->sysctl_rcgcdma; + case SYSCTL_RCGCHIB: + return s->sysctl_rcgchib; + case SYSCTL_RCGCUART: + return s->sysctl_rcgcuart; + case SYSCTL_RCGCSSI: + return s->sysctl_rcgcssi; + case SYSCTL_RCGCI2C: + return s->sysctl_rcgci2c; + case SYSCTL_RCGCUSB: + return s->sysctl_rcgcusb; + case SYSCTL_RCGCCAN: + return s->sysctl_rcgccan; + case SYSCTL_RCGCADC: + return s->sysctl_rcgcadc; + case SYSCTL_RCGCACMP: + return s->sysctl_rcgcacmp; + case SYSCTL_RCGCPWM: + return s->sysctl_rcgcpwm; + case SYSCTL_RCGCQEI: + return s->sysctl_rcgcqei; + case SYSCTL_RCGCEEPROM: + return s->sysctl_rcgceeprom; + case SYSCTL_RCGCWTIMER: + return s->sysctl_rcgcwtimer; + case SYSCTL_SCGCWD: + return s->sysctl_scgcwd; + case SYSCTL_SCGCTIMER: + return s->sysctl_scgctimer; + case SYSCTL_SCGCGPIO: + return s->sysctl_scgcgpio; + case SYSCTL_SCGCDMA: + return s->sysctl_scgcdma; + case SYSCTL_SCGCHIB: + return s->sysctl_scgchib; + case SYSCTL_SCGCUART: + return s->sysctl_scgcuart; + case SYSCTL_SCGCSSI: + return s->sysctl_scgcssi; + case SYSCTL_SCGCI2C: + return s->sysctl_scgci2c; + case SYSCTL_SCGCUSB: + return s->sysctl_scgcusb; + case SYSCTL_SCGCCAN: + return s->sysctl_scgccan; + case SYSCTL_SCGCADC: + return s->sysctl_scgcadc; + case SYSCTL_SCGCACMP: + return s->sysctl_scgcacmp; + case SYSCTL_SCGCPWM: + return s->sysctl_scgcpwm; + case SYSCTL_SCGCQEI: + return s->sysctl_scgcqei; + case SYSCTL_SCGCEEPROM: + return s->sysctl_scgceeprom; + case SYSCTL_SCGCWTIMER: + return s->sysctl_scgcwtimer; + case SYSCTL_DCGCWD: + return s->sysctl_dcgcwd; + case SYSCTL_DCGCTIMER: + return s->sysctl_dcgctimer; + case SYSCTL_DCGCGPIO: + return s->sysctl_dcgcgpio; + case SYSCTL_DCGCDMA: + return s->sysctl_dcgcdma; + case SYSCTL_DCGCHIB: + return s->sysctl_dcgchib; + case SYSCTL_DCGCUART: + return s->sysctl_dcgcuart; + case SYSCTL_DCGCSSI: + return s->sysctl_dcgcssi; + case SYSCTL_DCGCI2C: + return s->sysctl_dcgci2c; + case SYSCTL_DCGCUSB: + return s->sysctl_dcgcusb; + case SYSCTL_DCGCCAN: + return s->sysctl_dcgccan; + case SYSCTL_DCGCADC: + return s->sysctl_dcgcadc; + case SYSCTL_DCGCACMP: + return s->sysctl_dcgcacmp; + case SYSCTL_DCGCPWM: + return s->sysctl_dcgcpwm; + case SYSCTL_DCGCQEI: + return s->sysctl_dcgcqei; + case SYSCTL_DCGCEEPROM: + return s->sysctl_dcgceeprom; + case SYSCTL_DCGCWTIME: + return s->sysctl_dcgcwtime; + case SYSCTL_PRWD: + return s->sysctl_prwd; + case SYSCTL_PRTIMER: + return s->sysctl_prtimer; + case SYSCTL_PRGPIO: + return s->sysctl_prgpio; + case SYSCTL_PRDMA: + return s->sysctl_prdma; + case SYSCTL_PRHIB: + return s->sysctl_prhib; + case SYSCTL_PRUART: + return s->sysctl_pruart; + case SYSCTL_PRSSI: + return s->sysctl_prssi; + case SYSCTL_PRI2C: + return s->sysctl_pri2c; + case SYSCTL_PRUSB: + return s->sysctl_prusb; + case SYSCTL_PRCAN: + return s->sysctl_prcan; + case SYSCTL_PRADC: + return s->sysctl_pradc; + case SYSCTL_PRACMP: + return s->sysctl_pracmp; + case SYSCTL_PRPWM: + return s->sysctl_prpwm; + case SYSCTL_PRQEI: + return s->sysctl_prqei; + case SYSCTL_PREEPROM: + return s->sysctl_preeprom; + case SYSCTL_PRWTIMER: + return s->sysctl_prwtimer; + default: + LOG(LOG_GUEST_ERROR, "Bad address 0x%"HWADDR_PRIx"\n", addr); + break; + } + return 0; +} + +static const MemoryRegionOps tm4c123_sysctl_ops =3D { + .read =3D tm4c123_sysctl_read, + .write =3D tm4c123_sysctl_write, + .endianness =3D DEVICE_NATIVE_ENDIAN, +}; + +static void tm4c123_sysctl_init(Object *obj) +{ + TM4C123SysCtlState *s =3D TM4C123_SYSCTL(obj); + + s->mainclk =3D clock_new(OBJECT(s), "main-clk"); + clock_set_hz(s->mainclk, 1000 * 1000); + s->outclk =3D qdev_init_clock_out(DEVICE(s), "outclk"); + clock_set_source(s->outclk, s->mainclk); + + memory_region_init_io(&s->mmio, obj, &tm4c123_sysctl_ops, s, TYPE_TM4C= 123_SYSCTL, 0xFFF); + sysbus_init_mmio(SYS_BUS_DEVICE(obj), &s->mmio); +} + +static void tm4c123_sysctl_realize(DeviceState *dev, Error **errp) +{ + TM4C123SysCtlState *s =3D TM4C123_SYSCTL(dev); + tm4c123_sysctl_update_system_clock(s); + +} + +static void tm4c123_sysctl_class_init(ObjectClass *kclass, void *data) +{ + DeviceClass *dc =3D DEVICE_CLASS(kclass); + dc->reset =3D tm4c123_sysctl_reset; + dc->realize =3D tm4c123_sysctl_realize; +} + +static const TypeInfo tm4c123_sysctl_info =3D { + .name =3D TYPE_TM4C123_SYSCTL, + .parent =3D TYPE_SYS_BUS_DEVICE, + .instance_size =3D sizeof(TM4C123SysCtlState), + .instance_init =3D tm4c123_sysctl_init, + .class_init =3D tm4c123_sysctl_class_init, +}; + +static void tm4c123_sysctl_register_types(void) +{ + type_register_static(&tm4c123_sysctl_info); +} + +type_init(tm4c123_sysctl_register_types) diff --git a/hw/misc/trace-events b/hw/misc/trace-events index c47876a902..0c40b49457 100644 --- a/hw/misc/trace-events +++ b/hw/misc/trace-events @@ -1,5 +1,10 @@ # See docs/devel/tracing.rst for syntax documentation. =20 +# tm4c123_sysctl.c +tm4c123_sysctl_read(uint64_t offset) " offset: 0x%" PRIu64 +tm4c123_sysctl_write(uint64_t offset, uint64_t value) " offset: 0x%" PRIu6= 4 " - value: 0x%"PRIu64 +tm4c123_sysctl_update_system_clock(uint32_t value) "New clock value =3D %"= PRIu32" Hz" + # allwinner-cpucfg.c allwinner_cpucfg_cpu_reset(uint8_t cpu_id, uint32_t reset_addr) "id %u, re= set_addr 0x%" PRIx32 allwinner_cpucfg_read(uint64_t offset, uint64_t data, unsigned size) "offs= et 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32 diff --git a/include/hw/misc/tm4c123_sysctl.h b/include/hw/misc/tm4c123_sys= ctl.h new file mode 100644 index 0000000000..a8219a8693 --- /dev/null +++ b/include/hw/misc/tm4c123_sysctl.h @@ -0,0 +1,307 @@ +/* + * TM4C123 SYSCTL + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#ifndef HW_ARM_TM4C123_SYSCTL_H +#define HW_ARM_TM4C123_SYSCTL_H + +#include "qom/object.h" +#include "hw/sysbus.h" +#include "hw/hw.h" +#include "hw/clock.h" +#include "hw/qdev-clock.h" +#include "qapi/error.h" + +#define XTALM (16000000UL) /* Main oscillator fre= q */ +#define XTALI (16000000UL) /* Internal oscillator fre= q */ +#define XTAL30K ( 30000UL) /* Internal 30K oscillator fre= q */ +#define XTAL32K ( 32768UL) /* external 32K oscillator fre= q */ + +#define PLL_CLK (400000000UL) +#define ADC_CLK (PLL_CLK/25) +#define CAN_CLK (PLL_CLK/50) + +#define SYSCTL_DID0 0x000 +#define SYSCTL_DID1 0x004 +#define SYSCTL_PBORCTL 0x030 +#define SYSCTL_RIS 0x050 +#define SYSCTL_IMC 0x054 +#define SYSCTL_MISC 0x058 +#define SYSCTL_RESC 0x05C +#define SYSCTL_RCC 0x060 +#define SYSCTL_GPIOHBCTL 0x06C +#define SYSCTL_RCC2 0x070 +#define SYSCTL_MOSCCTL 0x07C +#define SYSCTL_DSLPCLKCFG 0x144 +#define SYSCTL_SYSPROP 0x14C +#define SYSCTL_PIOSCCAL 0x150 +#define SYSCTL_PIOSCSTAT 0x154 +#define SYSCTL_PLLFREQ0 0x160 +#define SYSCTL_PLLFREQ1 0x164 +#define SYSCTL_PLLSTAT 0x168 +#define SYSCTL_SLPPWRCFG 0x188 +#define SYSCTL_DSLPPWRCFG 0x18C +#define SYSCTL_LDOSPCTL 0x1B4 +#define SYSCTL_LDOSPCAL 0x1B8 +#define SYSCTL_LDODPCTL 0x1Bc +#define SYSCTL_LDODPCAL 0x1C0 +#define SYSCTL_SDPMST 0x1CC +#define SYSCTL_PPWD 0x300 +#define SYSCTL_PPTIMER 0x304 +#define SYSCTL_PPGPIO 0x308 +#define SYSCTL_PPDMA 0x30C +#define SYSCTL_PPHIB 0x314 +#define SYSCTL_PPUART 0x318 +#define SYSCTL_PPSI 0x31C +#define SYSCTL_PPI2C 0x320 +#define SYSCTL_PPUSB 0x328 +#define SYSCTL_PPCAN 0x334 +#define SYSCTL_PPADC 0x338 +#define SYSCTL_PPACMP 0x33C +#define SYSCTL_PPPWM 0x340 +#define SYSCTL_PPQEI 0x344 +#define SYSCTL_PPEEPROM 0x358 +#define SYSCTL_PPWTIMER 0x35C +#define SYSCTL_SRWD 0x500 +#define SYSCTL_SRTIMER 0x504 +#define SYSCTL_SRGPIO 0x508 +#define SYSCTL_SRDMA 0x50C +#define SYSCTL_SRHIB 0x514 +#define SYSCTL_SRUART 0x518 +#define SYSCTL_SRSSI 0x51C +#define SYSCTL_SRI2C 0x520 +#define SYSCTL_SRUSB 0x528 +#define SYSCTL_SRCAN 0x534 +#define SYSCTL_SRADC 0x538 +#define SYSCTL_SRACMP 0x53C +#define SYSCTL_SRPWM 0x540 +#define SYSCTL_SRQEI 0x544 +#define SYSCTL_SREEPROM 0x558 +#define SYSCTL_SRWTIMER 0x55C +#define SYSCTL_RCGCWD 0x600 +#define SYSCTL_RCGCTIMER 0x604 +#define SYSCTL_RCGCGPIO 0x608 +#define SYSCTL_RCGCDMA 0x60C +#define SYSCTL_RCGCHIB 0x614 +#define SYSCTL_RCGCUART 0x618 +#define SYSCTL_RCGCSSI 0x61C +#define SYSCTL_RCGCI2C 0x620 +#define SYSCTL_RCGCUSB 0x628 +#define SYSCTL_RCGCCAN 0x634 +#define SYSCTL_RCGCADC 0x638 +#define SYSCTL_RCGCACMP 0x63C +#define SYSCTL_RCGCPWM 0x640 +#define SYSCTL_RCGCQEI 0x644 +#define SYSCTL_RCGCEEPROM 0x658 +#define SYSCTL_RCGCWTIMER 0x65C +#define SYSCTL_SCGCWD 0x700 +#define SYSCTL_SCGCTIMER 0x704 +#define SYSCTL_SCGCGPIO 0x708 +#define SYSCTL_SCGCDMA 0x70C +#define SYSCTL_SCGCHIB 0x714 +#define SYSCTL_SCGCUART 0x718 +#define SYSCTL_SCGCSSI 0x71C +#define SYSCTL_SCGCI2C 0x720 +#define SYSCTL_SCGCUSB 0x728 +#define SYSCTL_SCGCCAN 0x734 +#define SYSCTL_SCGCADC 0x738 +#define SYSCTL_SCGCACMP 0x73C +#define SYSCTL_SCGCPWM 0x740 +#define SYSCTL_SCGCQEI 0x744 +#define SYSCTL_SCGCEEPROM 0x758 +#define SYSCTL_SCGCWTIMER 0x75C +#define SYSCTL_DCGCWD 0x800 +#define SYSCTL_DCGCTIMER 0x804 +#define SYSCTL_DCGCGPIO 0x808 +#define SYSCTL_DCGCDMA 0x80C +#define SYSCTL_DCGCHIB 0x814 +#define SYSCTL_DCGCUART 0x818 +#define SYSCTL_DCGCSSI 0x81C +#define SYSCTL_DCGCI2C 0x820 +#define SYSCTL_DCGCUSB 0x828 +#define SYSCTL_DCGCCAN 0x834 +#define SYSCTL_DCGCADC 0x838 +#define SYSCTL_DCGCACMP 0x83C +#define SYSCTL_DCGCPWM 0x840 +#define SYSCTL_DCGCQEI 0x844 +#define SYSCTL_DCGCEEPROM 0x858 +#define SYSCTL_DCGCWTIME 0x85C +#define SYSCTL_PRWD 0xA00 +#define SYSCTL_PRTIMER 0xA04 +#define SYSCTL_PRGPIO 0xA08 +#define SYSCTL_PRDMA 0xA0C +#define SYSCTL_PRHIB 0xA14 +#define SYSCTL_PRUART 0xA18 +#define SYSCTL_PRSSI 0xA1C +#define SYSCTL_PRI2C 0xA20 +#define SYSCTL_PRUSB 0xA28 +#define SYSCTL_PRCAN 0xA34 +#define SYSCTL_PRADC 0xA38 +#define SYSCTL_PRACMP 0xA3C +#define SYSCTL_PRPWM 0xA40 +#define SYSCTL_PRQEI 0xA44 +#define SYSCTL_PREEPROM 0xA58 +#define SYSCTL_PRWTIMER 0xA5C + + +#define SYSCTL_RCC_PWRDN (1 << 13) +#define SYSCTL_RCC2_PWRDN2 (1 << 13) +#define SYSCTL_RCC2_USERCC2 (1 << 31) +#define SYSCTL_RIS_PLLRIS (1 << 6) + +#define TYPE_TM4C123_SYSCTL "tm4c123-sysctl" +OBJECT_DECLARE_SIMPLE_TYPE(TM4C123SysCtlState, TM4C123_SYSCTL) + +struct TM4C123SysCtlState { + + SysBusDevice parent_obj; + MemoryRegion mmio; + + uint32_t sysctl_did0; + uint32_t sysctl_did1; + uint32_t sysctl_pborctl; + uint32_t sysctl_ris; + uint32_t sysctl_imc; + uint32_t sysctl_misc; + uint32_t sysctl_resc; + uint32_t sysctl_rcc; + uint32_t sysctl_gpiohbctl; + uint32_t sysctl_rcc2; + uint32_t sysctl_moscctl; + uint32_t sysctl_dslpclkcfg; + uint32_t sysctl_sysprop; + uint32_t sysctl_piosccal; + uint32_t sysctl_pioscstat; + uint32_t sysctl_pllfreq0; + uint32_t sysctl_pllfreq1; + uint32_t sysctl_pllstat; + uint32_t sysctl_slppwrcfg; + uint32_t sysctl_dslppwrcfg; + uint32_t sysctl_ldospctl; + uint32_t sysctl_ldospcal; + uint32_t sysctl_ldodpctl; + uint32_t sysctl_ldodpcal; + uint32_t sysctl_sdpmst; + uint32_t sysctl_ppwd; + uint32_t sysctl_pptimer; + uint32_t sysctl_ppgpio; + uint32_t sysctl_ppdma; + uint32_t sysctl_pphib; + uint32_t sysctl_ppuart; + uint32_t sysctl_ppsi; + uint32_t sysctl_ppi2c; + uint32_t sysctl_ppusb; + uint32_t sysctl_ppcan; + uint32_t sysctl_ppadc; + uint32_t sysctl_ppacmp; + uint32_t sysctl_pppwm; + uint32_t sysctl_ppqei; + uint32_t sysctl_ppeeprom; + uint32_t sysctl_ppwtimer; + uint32_t sysctl_srwd; + uint32_t sysctl_srtimer; + uint32_t sysctl_srgpio; + uint32_t sysctl_srdma; + uint32_t sysctl_srhib; + uint32_t sysctl_sruart; + uint32_t sysctl_srssi; + uint32_t sysctl_sri2c; + uint32_t sysctl_srusb; + uint32_t sysctl_srcan; + uint32_t sysctl_sradc; + uint32_t sysctl_sracmp; + uint32_t sysctl_srpwm; + uint32_t sysctl_srqei; + uint32_t sysctl_sreeprom; + uint32_t sysctl_srwtimer; + uint32_t sysctl_rcgcwd; + uint32_t sysctl_rcgctimer; + uint32_t sysctl_rcgcgpio; + uint32_t sysctl_rcgcdma; + uint32_t sysctl_rcgchib; + uint32_t sysctl_rcgcuart; + uint32_t sysctl_rcgcssi; + uint32_t sysctl_rcgci2c; + uint32_t sysctl_rcgcusb; + uint32_t sysctl_rcgccan; + uint32_t sysctl_rcgcadc; + uint32_t sysctl_rcgcacmp; + uint32_t sysctl_rcgcpwm; + uint32_t sysctl_rcgcqei; + uint32_t sysctl_rcgceeprom; + uint32_t sysctl_rcgcwtimer; + uint32_t sysctl_scgcwd; + uint32_t sysctl_scgctimer; + uint32_t sysctl_scgcgpio; + uint32_t sysctl_scgcdma; + uint32_t sysctl_scgchib; + uint32_t sysctl_scgcuart; + uint32_t sysctl_scgcssi; + uint32_t sysctl_scgci2c; + uint32_t sysctl_scgcusb; + uint32_t sysctl_scgccan; + uint32_t sysctl_scgcadc; + uint32_t sysctl_scgcacmp; + uint32_t sysctl_scgcpwm; + uint32_t sysctl_scgcqei; + uint32_t sysctl_scgceeprom; + uint32_t sysctl_scgcwtimer; + uint32_t sysctl_dcgcwd; + uint32_t sysctl_dcgctimer; + uint32_t sysctl_dcgcgpio; + uint32_t sysctl_dcgcdma; + uint32_t sysctl_dcgchib; + uint32_t sysctl_dcgcuart; + uint32_t sysctl_dcgcssi; + uint32_t sysctl_dcgci2c; + uint32_t sysctl_dcgcusb; + uint32_t sysctl_dcgccan; + uint32_t sysctl_dcgcadc; + uint32_t sysctl_dcgcacmp; + uint32_t sysctl_dcgcpwm; + uint32_t sysctl_dcgcqei; + uint32_t sysctl_dcgceeprom; + uint32_t sysctl_dcgcwtime; + uint32_t sysctl_prwd; + uint32_t sysctl_prtimer; + uint32_t sysctl_prgpio; + uint32_t sysctl_prdma; + uint32_t sysctl_prhib; + uint32_t sysctl_pruart; + uint32_t sysctl_prssi; + uint32_t sysctl_pri2c; + uint32_t sysctl_prusb; + uint32_t sysctl_prcan; + uint32_t sysctl_pradc; + uint32_t sysctl_pracmp; + uint32_t sysctl_prpwm; + uint32_t sysctl_prqei; + uint32_t sysctl_preeprom; + uint32_t sysctl_prwtimer; + + Clock* mainclk; + Clock* outclk; + +}; + +#endif --=20 2.34.1 From nobody Sat May 18 06:04:26 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1684311259; cv=none; d=zohomail.com; s=zohoarc; b=EbN1sYBERraw1q0ozh1rLBktbM+/S8IaDXDKiCMATlWOfGUyU4Au1d/ER+xkSbjva0IdKoZ90xB+A/ZJzRQ1E2p5RbE1jOBWD5NKKdygy9Z3E0t5//s00VqjW0Y0xD6JOe9yiuF5lqcxl8VmSPancOAJ/16PGOQtqW0PGGpxJ+w= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1684311259; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=Pc+h22qrBgYh6YvkhQsj0ayYok4y4K6400dOTySuxLA=; b=nFRsNBoMapitSbjaZbPAOaTyVKsZOczh11YBQrNop4nh9HO6wBK+YJ62pLGyrBsIqB/kgfRTY3OiKoFIozZHfldg1GyjMmZWJRN2pBZ7cTifTn3Ol/9qYiyfiDrw6Er8rqq5/GyFGe47Qcg5vTwP86GuZ6Yz7znMLCG/r355PYw= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1684311259379785.140354292049; Wed, 17 May 2023 01:14:19 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1pzCGy-00068s-Cm; Wed, 17 May 2023 04:12:36 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pzCGq-0005uT-NF; Wed, 17 May 2023 04:12:28 -0400 Received: from mail-wr1-x42a.google.com ([2a00:1450:4864:20::42a]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1pzCGk-0003Mj-Hk; Wed, 17 May 2023 04:12:28 -0400 Received: by mail-wr1-x42a.google.com with SMTP id ffacd0b85a97d-30796c0cbcaso421649f8f.1; Wed, 17 May 2023 01:12:21 -0700 (PDT) Received: from i.. ([41.236.82.205]) by smtp.gmail.com with ESMTPSA id o24-20020a1c7518000000b003f42158288dsm1414942wmc.20.2023.05.17.01.12.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 May 2023 01:12:20 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1684311140; x=1686903140; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Pc+h22qrBgYh6YvkhQsj0ayYok4y4K6400dOTySuxLA=; b=siotNUOmOWflEPo740kwQAQir/z8pc/CuLL7nhbqHb2f/6+bcCWsqo4rItaa8TuOld 7g4HjeSnHgzVQBe1lu4PPpkJaGvlKc7Cgs+laGou+v9gzSCJ6VlLpsOhli+7dk02hJXg 5AF+HF6FzGQWeyqS1l7EA4B3v68Ln0tjD4Ls7m9/WjzE689ekoWYpKpPZh1kwOy0t/B1 sMpcyd3//xOHHDUOvShytvtWbuFpIJ4tBADALKtDazPl22HpGxFudfOPOrOw9UWKjPaF tBY+66q1+aBOBTQffPPtqPZ3wu4ocwxFHTy0TENCBZ+hut8V/xg/jPfm7swjrFVw5EXl R25Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1684311140; x=1686903140; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=Pc+h22qrBgYh6YvkhQsj0ayYok4y4K6400dOTySuxLA=; b=U4JuJUUTSamqSM3oz3LAUVk6+vHzTEci+r/Npk4ZBtfQacU21Cf1QsVB19RkLfBZsL qO/Z11fAWN41BDaHtWmBGqEIU3fY6xDN28Ioj8vv7QxiKz94n9nMF+xtKtAfGS+UUtMk 3FS44aZxOtuLcD4I6OtaS0pUx79kvvZv6PCM7c+idmUGPKq0nCQnSsaahmTUb7zwAMD5 eBK86L9F/S3hp4MOon2GCvJhiegi0W+BUjiMQaWm2YxYz6KDt6XgrH4jD8efNMNUO6TA BHhmyU0eR1Nn0Nyv+Hj0qtxkKQ7l63R8IdXGvYcEHqbveUI9bukJ2Csz4bRo2oNvWYqE A3/A== X-Gm-Message-State: AC+VfDwKe/euzCFxHUxVD0+Fx6ENC9Mj30Vtfo8gYSgwfXfXbvJq39Cn Tgobv1qH48eEFUrP3EhX/+x3VjjMIBg= X-Google-Smtp-Source: ACHHUZ4wLYIT4COkjvV9E9twYE8XhDlk/jMO2wNfIjWr19wXdNFg8dPH2qZSGQBWcdDc5w9d7WjWHQ== X-Received: by 2002:a5d:4c8c:0:b0:2f5:3dfd:f4d2 with SMTP id z12-20020a5d4c8c000000b002f53dfdf4d2mr29187143wrs.64.1684311140380; Wed, 17 May 2023 01:12:20 -0700 (PDT) From: Mohamed ElSayed To: qemu-devel@nongnu.org Cc: qemu-arm@nongnu.org, Mohamed ElSayed Subject: [PATCH 5/8] tiva c watchdog timers implementation Date: Wed, 17 May 2023 11:12:01 +0300 Message-Id: <20230517081204.30333-6-m.elsayed4420@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230517081204.30333-1-m.elsayed4420@gmail.com> References: <20230517081204.30333-1-m.elsayed4420@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::42a; envelope-from=m.elsayed4420@gmail.com; helo=mail-wr1-x42a.google.com X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @gmail.com) X-ZM-MESSAGEID: 1684311261605100003 Content-Type: text/plain; charset="utf-8" Signed-off-by: Mohamed ElSayed --- hw/watchdog/tm4c123_watchdog.c | 297 +++++++++++++++++++++++++ hw/watchdog/trace-events | 3 + include/hw/watchdog/tm4c123_watchdog.h | 97 ++++++++ 3 files changed, 397 insertions(+) create mode 100644 hw/watchdog/tm4c123_watchdog.c create mode 100644 include/hw/watchdog/tm4c123_watchdog.h diff --git a/hw/watchdog/tm4c123_watchdog.c b/hw/watchdog/tm4c123_watchdog.c new file mode 100644 index 0000000000..ea0a41f3c0 --- /dev/null +++ b/hw/watchdog/tm4c123_watchdog.c @@ -0,0 +1,297 @@ +/* + * TM4C123 Watchdog Timers + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#include "qemu/osdep.h" +#include "hw/watchdog/tm4c123_watchdog.h" +#include "hw/irq.h" +#include "hw/qdev-properties.h" +#include "hw/qdev-clock.h" +#include "sysemu/runstate.h" +#include "qemu/log.h" +#include "qemu/module.h" +#include "hw/nmi.h" +#include "trace.h" + +#define LOG(mask, fmt, args...) qemu_log_mask(mask, "%s: " fmt, __func__, = ## args) +#define READONLY LOG(LOG_GUEST_ERROR, "0x%"HWADDR_PRIx" is a readonly fiel= d\n.", addr) + +static bool locked; + +static void tm4c123_wdt_expired(void *opaque) +{ + TM4C123WatchdogState *s =3D opaque; + /*if this is the first timeout/the ris is not cleared */ + if (!test_bit(0, (const unsigned long *)&s->wdt_mis)) { + set_bit(0, (unsigned long *)&s->wdt_mis); + nmi_monitor_handle(0, NULL); + qemu_irq_pulse(s->irq); + } else { + if (test_bit(1, (const unsigned long *)&s->wdt_ctl)) + qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET); + else { + nmi_monitor_handle(0, NULL); + qemu_irq_pulse(s->irq); + } + } +} + +static bool wdt_clock_enabled(TM4C123SysCtlState *s, hwaddr addr) +{ + switch (addr) { + case WDT_0: + return s->sysctl_rcgcwd & (1 << 0); + break; + case WDT_1: + return s->sysctl_rcgcwd & (1 << 1); + break; + } + return false; +} + +static void tm4c123_wdt_reset(DeviceState *dev) +{ + TM4C123WatchdogState *s =3D TM4C123_WATCHDOG(dev); + + s->wdt_load =3D 0xFFFFFFFF; + s->wdt_value =3D 0xFFFFFFFF; + s->wdt_ctl =3D (s->mmio.addr =3D=3D WDT_0 ? 0x00000000 : 0x80000000); + s->wdt_icr =3D 0x00000000; + s->wdt_ris =3D 0x00000000; + s->wdt_mis =3D 0x00000000; + s->wdt_test =3D 0x00000000; + s->wdt_lock =3D 0x00000000; + s->wdt_per_id4 =3D 0x00000000; + s->wdt_per_id5 =3D 0x00000000; + s->wdt_per_id6 =3D 0x00000000; + s->wdt_per_id7 =3D 0x00000000; + s->wdt_per_id0 =3D 0x00000005; + s->wdt_per_id1 =3D 0x00000018; + s->wdt_per_id2 =3D 0x00000018; + s->wdt_per_id3 =3D 0x00000001; + s->wdt_pcell_id0 =3D 0x0000000D; + s->wdt_pcell_id1 =3D 0x000000F0; + s->wdt_pcell_id2 =3D 0x00000006; + s->wdt_pcell_id3 =3D 0x000000B1; +} + +static uint64_t tm4c123_wdt_read(void *opaque, hwaddr addr, unsigned int s= ize) +{ + TM4C123WatchdogState *s =3D opaque; + + if (!wdt_clock_enabled(s->sysctl, s->mmio.addr)) { + hw_error("Watchdog timer module clock is not enabled"); + } + + switch (addr) { + case WDT_LOAD: + return s->wdt_load; + case WDT_VALUE: + return ptimer_get_count(s->timer); + case WDT_CTL: + return s->wdt_ctl; + case WDT_ICR: + return s->wdt_icr; + case WDT_RIS: + return s->wdt_ris; + case WDT_MIS: + return s->wdt_mis; + case WDT_TEST: + return s->wdt_test; + case WDT_LOCK: + return s->wdt_lock; + case WDT_PER_ID4: + return s->wdt_per_id4; + case WDT_PER_ID5: + return s->wdt_per_id5; + case WDT_PER_ID6: + return s->wdt_per_id6; + case WDT_PER_ID7: + return s->wdt_per_id7; + case WDT_PER_ID0: + return s->wdt_per_id0; + case WDT_PER_ID1: + return s->wdt_per_id1; + case WDT_PER_ID2: + return s->wdt_per_id2; + case WDT_PER_ID3: + return s->wdt_per_id3; + case WDT_PCELL_ID0: + return s->wdt_pcell_id0; + case WDT_PCELL_ID1: + return s->wdt_pcell_id1; + case WDT_PCELL_ID2: + return s->wdt_pcell_id2; + case WDT_PCELL_ID3: + return s->wdt_pcell_id3; + default: + LOG(LOG_GUEST_ERROR, "Bad address 0x%"HWADDR_PRIx"\n", addr); + } + return 0; +} + +static void tm4c123_wdt_write(void *opaque, hwaddr addr, uint64_t val64, u= nsigned int size) +{ + TM4C123WatchdogState *s =3D opaque; + uint32_t val32 =3D val64; + + trace_tm4c123_wdt_write(addr, val64); + if (!wdt_clock_enabled(s->sysctl, s->mmio.addr)) { + hw_error("Watchdog module clock is not enabled"); + } + + switch (addr) { + case WDT_LOAD: + s->wdt_load =3D val32; + locked =3D true; + s->wdt_ctl |=3D WDT_CTL_INTEN; + ptimer_transaction_begin(s->timer); + ptimer_set_count(s->timer, s->wdt_load); + ptimer_set_limit(s->timer, s->wdt_load, 1); + ptimer_run(s->timer, 0); + ptimer_transaction_commit(s->timer); + break; + case WDT_VALUE: + READONLY; + break; + case WDT_CTL: + s->wdt_ctl =3D val32; + break; + case WDT_ICR: + ptimer_transaction_begin(s->timer); + ptimer_set_limit(s->timer, s->wdt_load, 1); + ptimer_transaction_commit(s->timer); + clear_bit(0, (unsigned long *)&s->wdt_ris); + clear_bit(0, (unsigned long *)&s->wdt_mis); + s->wdt_icr =3D val32; + break; + case WDT_RIS: + READONLY; + break; + case WDT_MIS: + READONLY; + break; + case WDT_TEST: + s->wdt_test =3D val32; + break; + case WDT_LOCK: + /* The actual hardware never locks the module */ + if (val32 =3D=3D UNLOCK_VALUE) { + locked =3D false; + s->wdt_lock =3D 0; + } + break; + case WDT_PER_ID4: + READONLY; + break; + case WDT_PER_ID5: + READONLY; + break; + case WDT_PER_ID6: + READONLY; + break; + case WDT_PER_ID7: + READONLY; + break; + case WDT_PER_ID0: + READONLY; + break; + case WDT_PER_ID1: + READONLY; + break; + case WDT_PER_ID2: + READONLY; + break; + case WDT_PER_ID3: + READONLY; + break; + case WDT_PCELL_ID0: + READONLY; + break; + case WDT_PCELL_ID1: + READONLY; + break; + case WDT_PCELL_ID2: + READONLY; + break; + case WDT_PCELL_ID3: + READONLY; + break; + default: + LOG(LOG_GUEST_ERROR, "Bad address 0x%"HWADDR_PRIx"\n", addr); + } +} + +const struct MemoryRegionOps tm4c123_wdt_ops =3D { + .read =3D tm4c123_wdt_read, + .write =3D tm4c123_wdt_write, + .endianness =3D DEVICE_NATIVE_ENDIAN, +}; + +static void tm4c123_wdt_init(Object *obj) +{ + TM4C123WatchdogState *s =3D TM4C123_WATCHDOG(obj); + + s->wdt_clock =3D qdev_init_clock_in(DEVICE(s), "wdt_clock", NULL, NULL= , 0); + + sysbus_init_irq(SYS_BUS_DEVICE(obj), &s->irq); + memory_region_init_io(&s->mmio, obj, &tm4c123_wdt_ops, s, TYPE_TM4C123= _WATCHDOG, 0xFFF); + sysbus_init_mmio(SYS_BUS_DEVICE(obj), &s->mmio); +} + +static void tm4c123_wdt_realize(DeviceState *dev, Error **errp) +{ + TM4C123WatchdogState *s =3D TM4C123_WATCHDOG(dev); + qdev_connect_clock_in(dev, "wdt_clock", qdev_get_clock_out(DEVICE(s->s= ysctl), "outclk")); + + s->timer =3D ptimer_init(tm4c123_wdt_expired, s, + PTIMER_POLICY_NO_IMMEDIATE_RELOAD | + PTIMER_POLICY_NO_COUNTER_ROUND_DOWN); + + ptimer_transaction_begin(s->timer); + ptimer_set_period_from_clock(s->timer, s->wdt_clock, 1); + ptimer_set_limit(s->timer, 0xFFFFFFFF, 0); + ptimer_transaction_commit(s->timer); +} + +static void tm4c123_wdt_class_init(ObjectClass *kclass, void *data) +{ + DeviceClass *dc =3D DEVICE_CLASS(kclass); + dc->realize =3D tm4c123_wdt_realize; + dc->reset =3D tm4c123_wdt_reset; +} + +static const TypeInfo tm4c123_wdt_info =3D { + .name =3D TYPE_TM4C123_WATCHDOG, + .parent =3D TYPE_SYS_BUS_DEVICE, + .instance_size =3D sizeof(TM4C123WatchdogState), + .instance_init =3D tm4c123_wdt_init, + .class_init =3D tm4c123_wdt_class_init, +}; + +static void tm4c123_wdt_register_types(void) +{ + type_register_static(&tm4c123_wdt_info); +} + +type_init(tm4c123_wdt_register_types) diff --git a/hw/watchdog/trace-events b/hw/watchdog/trace-events index 2739570652..802aed4a6f 100644 --- a/hw/watchdog/trace-events +++ b/hw/watchdog/trace-events @@ -1,5 +1,8 @@ # See docs/devel/tracing.rst for syntax documentation. =20 +# tm4c123_wdt.c +tm4c123_wdt_write(uint64_t offset, uint64_t data) "TM4C123-WDT Write: [ Of= fset 0x%" PRIx64 " - Data 0x%" PRIx64 "]" + # allwinner-wdt.c allwinner_wdt_read(uint64_t offset, uint64_t data, unsigned size) "Allwinn= er watchdog read: offset 0x%" PRIx64 " data 0x%" PRIx64 " size %u" allwinner_wdt_write(uint64_t offset, uint64_t data, unsigned size) "Allwin= ner watchdog write: offset 0x%" PRIx64 " data 0x%" PRIx64 " size %u" diff --git a/include/hw/watchdog/tm4c123_watchdog.h b/include/hw/watchdog/t= m4c123_watchdog.h new file mode 100644 index 0000000000..2621b5d805 --- /dev/null +++ b/include/hw/watchdog/tm4c123_watchdog.h @@ -0,0 +1,97 @@ +/* + * TM4C123 Watchdog Timers + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#ifndef HW_ARM_TM4C123_WATCHDOG_H +#define HW_ARM_TM4C123_WATCHDOG_H + +#include "hw/sysbus.h" +#include "qom/object.h" +#include "hw/misc/tm4c123_sysctl.h" +#include "hw/ptimer.h" + +#define WDT_0 0x40000000 +#define WDT_1 0x40001000 + +#define WDT_LOAD 0x000 +#define WDT_VALUE 0x004 +#define WDT_CTL 0x008 +#define WDT_ICR 0x00C +#define WDT_RIS 0x010 +#define WDT_MIS 0x014 +#define WDT_TEST 0x418 +#define WDT_LOCK 0xC00 +#define WDT_PER_ID4 0xFD0 +#define WDT_PER_ID5 0xFD4 +#define WDT_PER_ID6 0xFD8 +#define WDT_PER_ID7 0xFDC +#define WDT_PER_ID0 0xFE0 +#define WDT_PER_ID1 0xFE4 +#define WDT_PER_ID2 0xFE8 +#define WDT_PER_ID3 0xFEC +#define WDT_PCELL_ID0 0xFF0 +#define WDT_PCELL_ID1 0xFF4 +#define WDT_PCELL_ID2 0xFF8 +#define WDT_PCELL_ID3 0xFFC + +#define UNLOCK_VALUE 0x1ACCE551 + +#define WDT_CTL_INTEN (1 << 0) +#define WDT_CTL_INTTYPE (1 << 2) + +#define TYPE_TM4C123_WATCHDOG "tm4c123-watchdog" + +OBJECT_DECLARE_SIMPLE_TYPE(TM4C123WatchdogState, TM4C123_WATCHDOG) + +struct TM4C123WatchdogState { + SysBusDevice parent_obj; + MemoryRegion mmio; + qemu_irq irq; + struct ptimer_state *timer; + TM4C123SysCtlState* sysctl; + + uint32_t wdt_load; + uint32_t wdt_value; + uint32_t wdt_ctl; + uint32_t wdt_icr; + uint32_t wdt_ris; + uint32_t wdt_mis; + uint32_t wdt_test; + uint32_t wdt_lock; + uint32_t wdt_per_id4; + uint32_t wdt_per_id5; + uint32_t wdt_per_id6; + uint32_t wdt_per_id7; + uint32_t wdt_per_id0; + uint32_t wdt_per_id1; + uint32_t wdt_per_id2; + uint32_t wdt_per_id3; + uint32_t wdt_pcell_id0; + uint32_t wdt_pcell_id1; + uint32_t wdt_pcell_id2; + uint32_t wdt_pcell_id3; + + Clock* wdt_clock; +}; + +#endif --=20 2.34.1 From nobody Sat May 18 06:04:26 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1684311288; cv=none; d=zohomail.com; s=zohoarc; b=KfmmKnINjXXgQghlpmmpqcu5CuRhq3PP3PBDmsanLwM1/BMj/+CIIFrn9q3VZOq/+qKPbue1Lwmz/Vfe5SlGABKcB6LoYTv2CtkDsLR+nvEXb2ZRE4OCvu+cLsL5tGY9yCtAWk/8HTWe2+pg5erfY0qGLY0A+mIZHqbatvZSHgU= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1684311288; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=qnZry/mZ+YqdIcfBo8MVTR0ygK8zmQY+tnNtARvrW+M=; b=Z3v8FINERCx74XnIvy98Nc6DKlz8lYreTATOWI/xdXRbVSMRBz+//7VHB0xXRkW0Y0fiImFJbnRcMNkm16m3I+DwqIoHnBrfGG0N6SWO2rAQMUEkbHy1FPckBUPh+m+cQYGtz8pxH5AqI3pzv1Gr4EGnh+ENc7a/NDzMsK6p7xE= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1684311288536581.9315674496016; Wed, 17 May 2023 01:14:48 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1pzCGs-0005yB-OF; Wed, 17 May 2023 04:12:30 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pzCGp-0005sG-HM; Wed, 17 May 2023 04:12:27 -0400 Received: from mail-wm1-x330.google.com ([2a00:1450:4864:20::330]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1pzCGm-0003NM-15; Wed, 17 May 2023 04:12:27 -0400 Received: by mail-wm1-x330.google.com with SMTP id 5b1f17b1804b1-3f41d087b24so3116205e9.1; Wed, 17 May 2023 01:12:23 -0700 (PDT) Received: from i.. ([41.236.82.205]) by smtp.gmail.com with ESMTPSA id o24-20020a1c7518000000b003f42158288dsm1414942wmc.20.2023.05.17.01.12.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 May 2023 01:12:21 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1684311142; x=1686903142; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=qnZry/mZ+YqdIcfBo8MVTR0ygK8zmQY+tnNtARvrW+M=; b=TJgADLgrRx8HJNo5pLNjhGDYAxCTcR6GKOEPBVaFnScJ5vE0WFDtBGR6KxEQr4br2p jKukb2YLub/NDAtzSED/DbtUERBsFiRvfebNABd7RAEhpVrtAc9nAY/RYyTWZJc7f01v oLP+/RmNtYSGXB9Z1ftFeNKwcnBDz9hAYaUk7H6OBagy0i3Q83iBvZAdX5pK5lUxQy8O yBiCtNpgX3mcxmrHT1DaPW930NSbXL8lYuKvIzXD2TSo59sPcJ6ZDimi7pwt6iLGBz7Q Y0bD6nPmiEVnnaXh4QrDngv78Z9utTgPO0/gN1uZatKz1STMDyxfDWm+Gv2WykKZZFxc ZjEQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1684311142; x=1686903142; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=qnZry/mZ+YqdIcfBo8MVTR0ygK8zmQY+tnNtARvrW+M=; b=KpHbZb7odgjRzzHsxPmoCdNcpeWamNkT/chIXbqaZ9Br5LcM73xd3QPekh6EN1u5ME 0AaCeuWyCIM2ewLGEpmLmUBqOSv248hFt6WsabHXDdvKxvTKRWdNqn/qUm4zHQxg7arH dDQmUSII3oL2KyDJqq9mNTrr4i67p2URRV4Ec0Hniku15d8ayajgdFkx2fQhdDnJpaUu 93orusaV6KeIbFaeFx8rEI2OIZgK9vrNTSh6eKNVAb4VSa/YZk1oi3DtLUUvla/zHxyT 2Fj36nSMtPGcOwcL5KiFyMLiOx8r1+EytMTSPVVQhiInXycP/6iZ0Z1E+DEYxZ91nJrA qmNA== X-Gm-Message-State: AC+VfDyWQvrhiDCMGkDyI4bnRM7vHbQFWG0ID8+MhvFutJZCSztuRkPM 0xucEsk1X48FMZPpfX52KbEpgfEypQA= X-Google-Smtp-Source: ACHHUZ4kkgyWi8+Mpg0VNiwZNeVTv9nuHtkZsoD0x0XlSSjYvuOZwAbNYfA64iW1G7nX2e59wsFAow== X-Received: by 2002:a05:600c:2116:b0:3f4:294d:8524 with SMTP id u22-20020a05600c211600b003f4294d8524mr20909254wml.22.1684311141744; Wed, 17 May 2023 01:12:21 -0700 (PDT) From: Mohamed ElSayed To: qemu-devel@nongnu.org Cc: qemu-arm@nongnu.org, Mohamed ElSayed Subject: [PATCH 6/8] tiva c general purpose timers implementation Date: Wed, 17 May 2023 11:12:02 +0300 Message-Id: <20230517081204.30333-7-m.elsayed4420@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230517081204.30333-1-m.elsayed4420@gmail.com> References: <20230517081204.30333-1-m.elsayed4420@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::330; envelope-from=m.elsayed4420@gmail.com; helo=mail-wm1-x330.google.com X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @gmail.com) X-ZM-MESSAGEID: 1684311289846100001 Content-Type: text/plain; charset="utf-8" Signed-off-by: Mohamed ElSayed --- hw/timer/tm4c123_gptm.c | 495 ++++++++++++++++++++++++++++++++ hw/timer/trace-events | 5 + include/hw/timer/tm4c123_gptm.h | 131 +++++++++ 3 files changed, 631 insertions(+) create mode 100644 hw/timer/tm4c123_gptm.c create mode 100644 include/hw/timer/tm4c123_gptm.h diff --git a/hw/timer/tm4c123_gptm.c b/hw/timer/tm4c123_gptm.c new file mode 100644 index 0000000000..bdbaff776c --- /dev/null +++ b/hw/timer/tm4c123_gptm.c @@ -0,0 +1,495 @@ +/* + * TM4C123 General purpose timers + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#include "hw/timer/tm4c123_gptm.h" +#include "hw/irq.h" +#include "trace.h" +#include "qemu/timer.h" +#include + +#define LOG(mask, fmt, args...) qemu_log_mask(mask, "%s: " fmt, __func__, = ## args) +#define READONLY LOG(LOG_GUEST_ERROR, "0x%"HWADDR_PRIx" is a readonly fiel= d\n.", addr) + +static uint64_t ns_to_ticks(void *opaque, uint64_t ns, uint32_t prescaler) +{ + TM4C123GPTMState *s =3D opaque; + + uint32_t freq =3D clock_get_hz(s->clk) / prescaler; + float sec =3D (float)ns / (float)NANOSECONDS_PER_SECOND; + return sec * freq; +} + +static unsigned long ticks_to_time_ns(void *opaque, uint64_t ticks, uint32= _t prescaler) +{ + TM4C123GPTMState *s =3D opaque; + uint32_t freq =3D clock_get_hz(s->clk) / prescaler; + return ((float)ticks / (float)freq) * NANOSECONDS_PER_SECOND; +} + +static uint16_t get_timer_width(void *opaque) +{ + TM4C123GPTMState *s =3D opaque; + switch (s->mmio.addr) { + case TIMER0_32...TIMER5_32: + return TIMER_WIDTH_32; + case TIMER0_64...TIMER5_64: + return TIMER_WIDTH_64; + } + return 0; +} + +static uint64_t build_interval_value(void *opaque) +{ + TM4C123GPTMState *s =3D opaque; + uint16_t timer_width =3D get_timer_width(s); + uint64_t interval_value =3D 0; + if (timer_width =3D=3D TIMER_WIDTH_32) { + /* timer is in 32 bit mode or 32bit rtc*/ + uint16_t upper16 =3D extract32(s->gptm_talir, 16, 16); + uint16_t lower16 =3D extract32(s->gptm_tblir, 0, 16); + interval_value =3D ((uint32_t)lower16 << 16) + upper16; + } else if (timer_width =3D=3D TIMER_WIDTH_64) { + interval_value =3D ((uint64_t)s->gptm_talir << 32) + s->gptm_tblir; + } + + trace_tm4c123_gptm_build_interval_value(s->gptm_talir, s->gptm_tblir, = interval_value); + return interval_value; +} + +static void set_timers(void *opaque) +{ + TM4C123GPTMState *s =3D opaque; + uint64_t interval_value; + uint16_t timer_width; + if (s->gptm_ctl & GPTM_TACTL_EN) { + timer_width =3D get_timer_width(s); + if (timer_width =3D=3D TIMER_WIDTH_32) { + /* What is the mode of the timer? 16/32 */ + if (s->gptm_cfg =3D=3D 0x4) { + /* 16 bit mode */ + interval_value =3D extract32(s->gptm_talir, 0, 16); + /* Start the timer? */ + timer_mod(s->a, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + ti= cks_to_time_ns(s, interval_value, s->gptm_tapr)); + } else if (s->gptm_cfg =3D=3D 0x1) { + /* 32 bit mode rtc */ + interval_value =3D build_interval_value(s); + timer_mod(s->a, qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + t= icks_to_time_ns(s, interval_value, s->gptm_tapr)); + } else if (s->gptm_cfg =3D=3D 0x0) { + /* 32 bit mode rtc */ + interval_value =3D build_interval_value(s); + timer_mod(s->a, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + ti= cks_to_time_ns(s, interval_value, s->gptm_tapr)); + } + } else if (timer_width =3D=3D TIMER_WIDTH_64) { + /* What is the mode of the timer? 32/64 */ + if (s->gptm_cfg =3D=3D 0) { + /* 64 bit mode */ + interval_value =3D build_interval_value(s); + timer_mod(s->a, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + ti= cks_to_time_ns(s, interval_value, s->gptm_tapr)); + } else if (s->gptm_cfg =3D=3D 0x1) { + /* 64 bit mode */ + interval_value =3D build_interval_value(s); + timer_mod(s->a, qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + t= icks_to_time_ns(s, interval_value, s->gptm_tapr)); + } else if (s->gptm_cfg =3D=3D 0x4) { + interval_value =3D s->gptm_talir; + timer_mod(s->a, qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + t= icks_to_time_ns(s, interval_value, s->gptm_tapr)); + } + } + } else if (s->gptm_ctl & GPTM_TBCTL_EN) { + timer_width =3D get_timer_width(s); + if (timer_width =3D=3D TIMER_WIDTH_32) { + /* What is the mode of the timer? 16/32 */ + if (s->gptm_cfg =3D=3D 0x4) { + /* 16 bit mode */ + interval_value =3D extract32(s->gptm_tblir, 0, 16); + /* Start the timer? */ + timer_mod(s->b, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + ti= cks_to_time_ns(s, interval_value, s->gptm_tbpr)); + } else if (s->gptm_cfg =3D=3D 0x01) { + /* 32 bit mode rtc */ + interval_value =3D build_interval_value(s); + timer_mod(s->b, + qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + ticks_to_= time_ns(s, interval_value, s->gptm_tbpr)); + } else if (s->gptm_cfg =3D=3D 0x00) { + /* 32 bit mode rtc */ + interval_value =3D build_interval_value(s); + timer_mod(s->b, + qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + ticks_to_t= ime_ns(s, interval_value, s->gptm_tbpr)); + } + } else if (timer_width =3D=3D TIMER_WIDTH_64) { + /* What is the mode of the timer? 32/64 */ + if (s->gptm_cfg =3D=3D 0) { + /* 64 bit mode */ + interval_value =3D build_interval_value(s); + timer_mod(s->b, + qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + ticks_to_t= ime_ns(s, interval_value, s->gptm_tbpr)); + } else if (s->gptm_cfg =3D=3D 0x1) { + /* 64 bit mode */ + interval_value =3D build_interval_value(s); + timer_mod(s->b, + qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + ticks_to_= time_ns(s, interval_value, s->gptm_tbpr)); + } else if (s->gptm_cfg =3D=3D 0x4) { + interval_value =3D s->gptm_tblir; + timer_mod(s->b, + qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + ticks_to_= time_ns(s, interval_value, s->gptm_tbpr)); + } + } + } +} + +static bool gptm_clock_enabled(TM4C123SysCtlState *s, hwaddr addr) +{ + switch (addr) { + case TIMER0_32: + return test_bit(0, (const unsigned long *)&s->sysctl_rcgctimer= ); + break; + case TIMER1_32: + return test_bit(1, (const unsigned long *)&s->sysctl_rcgctimer= ); + break; + case TIMER2_32: + return test_bit(2, (const unsigned long *)&s->sysctl_rcgctimer= ); + break; + case TIMER3_32: + return test_bit(3, (const unsigned long *)&s->sysctl_rcgctimer= ); + break; + case TIMER4_32: + return test_bit(4, (const unsigned long *)&s->sysctl_rcgctimer= ); + break; + case TIMER5_32: + return test_bit(5, (const unsigned long *)&s->sysctl_rcgctimer= ); + break; + case TIMER0_64: + return test_bit(0, (const unsigned long *)&s->sysctl_rcgcwtime= r); + break; + case TIMER1_64: + return test_bit(1, (const unsigned long *)&s->sysctl_rcgcwtime= r); + break; + case TIMER2_64: + return test_bit(2, (const unsigned long *)&s->sysctl_rcgcwtime= r); + break; + case TIMER3_64: + return test_bit(3, (const unsigned long *)&s->sysctl_rcgcwtime= r); + break; + case TIMER4_64: + return test_bit(4, (const unsigned long *)&s->sysctl_rcgcwtime= r); + break; + case TIMER5_64: + return test_bit(5, (const unsigned long *)&s->sysctl_rcgcwtime= r); + break; + } + return false; +} + +static void tm4c123_gptm_reset(DeviceState *dev) +{ + TM4C123GPTMState *s =3D TM4C123_GPTM(dev); + + s->gptm_cfg =3D 0x00000000; + s->gptm_amr =3D 0x00000000; + s->gptm_bmr =3D 0x00000000; + s->gptm_ctl =3D 0x00000000; + s->gptm_sync =3D 0x00000000; + s->gptm_imr =3D 0x00000000; + s->gptm_ris =3D 0x00000000; + s->gptm_mis =3D 0x00000000; + s->gptm_icr =3D 0x00000000; + s->gptm_talir =3D 0xFFFFFFFF; + s->gptm_tblir =3D 0x00000000; + s->gptm_tamatchr =3D 0xFFFFFFFF; + s->gptm_tbmatchr =3D 0x00000000; + s->gptm_tapr =3D 0x00000000; + s->gptm_tbpr =3D 0x00000000; + s->gptm_tapmr =3D 0x00000000; + s->gptm_tbpmr =3D 0x00000000; + s->gptm_tar =3D 0xFFFFFFFF; + s->gptm_tbr =3D 0x00000000; + s->gptm_tav =3D 0xFFFFFFFF; + s->gptm_tbv =3D 0x00000000; + s->gptm_rtcpd =3D 0x00007FFF; + s->gptm_taps =3D 0x00000000; + s->gptm_tbps =3D 0x00000000; + s->gptm_tapv =3D 0x00000000; + s->gptm_tbpv =3D 0x00000000; + s->gptm_pp =3D 0x00000000; +} + +static uint64_t tm4c123_gptm_read(void *opaque, hwaddr addr, unsigned int = size) +{ + TM4C123GPTMState *s =3D opaque; + + if (!gptm_clock_enabled(s->sysctl, s->mmio.addr)) { + hw_error("GPTM module clock is not enabled"); + } + + trace_tm4c123_gptm_read(addr); + + switch (addr) { + case GPTM_CFG: + return s->gptm_cfg; + case GPTM_AMR: + return s->gptm_amr; + case GPTM_BMR: + return s->gptm_bmr; + case GPTM_CTL: + return s->gptm_ctl; + case GPTM_SYNC: + return s->gptm_sync; + case GPTM_IMR: + return s->gptm_imr; + case GPTM_RIS: + return s->gptm_ris; + case GPTM_MIS: + return s->gptm_mis; + case GPTM_ICR: + return s->gptm_icr; + case GPTM_TALIR: + return s->gptm_talir; + case GPTM_TBLIR: + return s->gptm_tblir; + case GPTM_TAMATCHR: + return s->gptm_tamatchr; + case GPTM_TBMATCHR: + return s->gptm_tbmatchr; + case GPTM_TAPR: + return s->gptm_tapr; + case GPTM_TBPR: + return s->gptm_tbpr; + case GPTM_TAPMR: + return s->gptm_tapmr; + case GPTM_TBPMR: + return s->gptm_tbpmr; + case GPTM_TAR: + return s->gptm_tar; + case GPTM_TBR: + return s->gptm_tbr; + case GPTM_TAV: + if (get_timer_width(s) =3D=3D TIMER_WIDTH_64 && s->gptm_cfg = =3D=3D 0) { + return extract64( + ns_to_ticks(s, s->a->expire_time - qemu_clock_get_= ns(QEMU_CLOCK_VIRTUAL), s->gptm_tapr), + 0, 31); + } else { + return ns_to_ticks(s, s->a->expire_time - qemu_clock_get_n= s(QEMU_CLOCK_VIRTUAL), s->gptm_tapr); + } + case GPTM_TBV: + if (get_timer_width(s) =3D=3D TIMER_WIDTH_64 && s->gptm_cfg = =3D=3D 0) { + return extract64( + ns_to_ticks(s, s->a->expire_time - qemu_clock_get_= ns(QEMU_CLOCK_VIRTUAL), s->gptm_tapr), + 32, 64); + } else { + return ns_to_ticks(s, s->b->expire_time - qemu_clock_get_n= s(QEMU_CLOCK_VIRTUAL), s->gptm_tapr); + } + case GPTM_RTCPD: + return s->gptm_rtcpd; + case GPTM_TAPS: + return s->gptm_taps; + case GPTM_TBPS: + return s->gptm_tbps; + case GPTM_TAPV: + return s->gptm_tapv; + case GPTM_TBPV: + return s->gptm_tbpv; + case GPTM_PP: + return s->gptm_pp; + default: + LOG(LOG_GUEST_ERROR, "Bad address 0x%"HWADDR_PRIx"\n", addr); + } + + return 0; +} + +static void tm4c123_gptm_write(void *opaque, hwaddr addr, uint64_t val64, = unsigned int size) +{ + TM4C123GPTMState *s =3D opaque; + uint32_t val32 =3D val64; + + if (!gptm_clock_enabled(s->sysctl, s->mmio.addr)) { + hw_error("GPTM module clock is not enabled"); + } + + trace_tm4c123_gptm_write(addr, val32); + + switch (addr) { + case GPTM_CFG: + s->gptm_cfg =3D val32; + break; + case GPTM_AMR: + s->gptm_amr =3D val32; + break; + case GPTM_BMR: + s->gptm_bmr =3D val32; + break; + case GPTM_CTL: + s->gptm_ctl =3D val32; + set_timers(s); + break; + case GPTM_SYNC: + s->gptm_sync =3D val32; + break; + case GPTM_IMR: + s->gptm_imr =3D val32; + break; + case GPTM_RIS: + READONLY; + break; + case GPTM_MIS: + s->gptm_mis =3D val32; + break; + case GPTM_ICR: + s->gptm_ris &=3D ~val32; + s->gptm_mis &=3D ~val32; + break; + case GPTM_TALIR: + s->gptm_talir =3D val32; + break; + case GPTM_TBLIR: + s->gptm_tblir =3D val32; + break; + case GPTM_TAMATCHR: + s->gptm_tamatchr =3D val32; + break; + case GPTM_TBMATCHR: + s->gptm_tbmatchr =3D val32; + break; + case GPTM_TAPR: + s->gptm_tapr =3D val32; + break; + case GPTM_TBPR: + s->gptm_tbpr =3D val32; + break; + case GPTM_TAPMR: + s->gptm_tapmr =3D val32; + break; + case GPTM_TBPMR: + s->gptm_tbpmr =3D val32; + break; + case GPTM_TAR: + READONLY; + break; + case GPTM_TBR: + READONLY; + break; + case GPTM_TAV: + s->gptm_tav =3D val32; + break; + case GPTM_TBV: + s->gptm_tbv =3D val32; + break; + case GPTM_RTCPD: + READONLY; + break; + case GPTM_TAPS: + READONLY; + break; + case GPTM_TBPS: + READONLY; + break; + case GPTM_TAPV: + READONLY; + break; + case GPTM_TBPV: + READONLY; + break; + case GPTM_PP: + READONLY; + break; + default: + LOG(LOG_GUEST_ERROR, "Bad address 0x%"HWADDR_PRIx"\n", addr); + } +} + +static const MemoryRegionOps tm4c123_gptm_ops =3D { + .read =3D tm4c123_gptm_read, + .write =3D tm4c123_gptm_write, + .endianness =3D DEVICE_NATIVE_ENDIAN, +}; + +static void timer_a_callback(void *opaque) +{ + TM4C123GPTMState *s =3D opaque; + + if (test_bit(0, (unsigned long *)&s->gptm_imr)) { + qemu_irq_pulse(s->irq_a); + set_bit(0, (unsigned long *)&s->gptm_mis); + } + set_bit(0, (unsigned long *)&s->gptm_ris); + if ((s->gptm_amr & 0x0000000F) =3D=3D 0x2) { + set_timers(s); + } +} + +static void timer_b_callback(void *opaque) +{ + TM4C123GPTMState *s =3D opaque; + + if (test_bit(8, (unsigned long *)&s->gptm_imr)) { + qemu_irq_pulse(s->irq_b); + set_bit(8, (unsigned long *)&s->gptm_mis); + } + set_bit(8, (unsigned long *)&s->gptm_ris); + if ((s->gptm_bmr & 0x0000000F) =3D=3D 0x2) { + set_timers(s); + } +} + +static void tm4c123_gptm_init(Object *obj) +{ + TM4C123GPTMState *s =3D TM4C123_GPTM(obj); + s->clk =3D qdev_init_clock_in(DEVICE(s), "gptm_clock", NULL, NULL, 0); + s->a =3D timer_new_ns(QEMU_CLOCK_VIRTUAL, timer_a_callback, s); + s->b =3D timer_new_ns(QEMU_CLOCK_VIRTUAL, timer_b_callback, s); + timer_init_ns(s->a, QEMU_CLOCK_VIRTUAL, timer_a_callback, s); + timer_init_ns(s->b, QEMU_CLOCK_VIRTUAL, timer_b_callback, s); + + sysbus_init_irq(SYS_BUS_DEVICE(obj), &s->irq_a); + sysbus_init_irq(SYS_BUS_DEVICE(obj), &s->irq_b); + memory_region_init_io(&s->mmio, obj, &tm4c123_gptm_ops, s, TYPE_TM4C12= 3_GPTM, 0xFFF); + sysbus_init_mmio(SYS_BUS_DEVICE(obj), &s->mmio); +} + +static void tm4c123_gptm_realize(DeviceState *dev, Error **errp) +{ + TM4C123GPTMState *s =3D TM4C123_GPTM(dev); + qdev_connect_clock_in(dev, "gptm_clock", qdev_get_clock_out(DEVICE(s->= sysctl), "outclk")); + +} + +static void tm4c123_gptm_class_init(ObjectClass *kclass, void *data) +{ + DeviceClass *dc =3D DEVICE_CLASS(kclass); + dc->reset =3D tm4c123_gptm_reset; + dc->realize =3D tm4c123_gptm_realize; +} + +static const TypeInfo tm4c123_gptm_info =3D { + .name =3D TYPE_TM4C123_GPTM, + .parent =3D TYPE_SYS_BUS_DEVICE, + .instance_size =3D sizeof(TM4C123GPTMState), + .instance_init =3D tm4c123_gptm_init, + .class_init =3D tm4c123_gptm_class_init, +}; + +static void tm4c123_gptm_register_types(void) +{ + type_register_static(&tm4c123_gptm_info); +} + +type_init(tm4c123_gptm_register_types) diff --git a/hw/timer/trace-events b/hw/timer/trace-events index 3eccef8385..e40b445630 100644 --- a/hw/timer/trace-events +++ b/hw/timer/trace-events @@ -1,5 +1,10 @@ # See docs/devel/tracing.rst for syntax documentation. =20 +# tm4c123_gptm.c +tm4c123_gptm_read(uint32_t offset) "offset: 0x%"PRIx32 +tm4c123_gptm_write(uint32_t offset, uint32_t value) "offset: 0x%"PRIx32" -= value: 0x%"PRIx32 +tm4c123_gptm_build_interval_value(uint32_t talir, uint32_t tblir, uint64_t= result) "TALIR: 0x%"PRIx32" - TBLIR: 0x%"PRIx32" - value: 0x%"PRIx64 + # slavio_timer.c slavio_timer_get_out(uint64_t limit, uint32_t counthigh, uint32_t count) "= limit 0x%"PRIx64" count 0x%x0x%08x" slavio_timer_irq(uint32_t counthigh, uint32_t count) "callback: count 0x%x= 0x%08x" diff --git a/include/hw/timer/tm4c123_gptm.h b/include/hw/timer/tm4c123_gpt= m.h new file mode 100644 index 0000000000..e86049f5c1 --- /dev/null +++ b/include/hw/timer/tm4c123_gptm.h @@ -0,0 +1,131 @@ +/* + * TM4C123 General purpose timers + * + * Copyright (c) 2023 Mohamed ElSayed + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * 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 OT= HER + * 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. + */ + +#ifndef HW_ARM_TM4C123_GPTM_H +#define HW_ARM_TM4C123_GPTM_H + +#include "qemu/osdep.h" +#include "qemu/log.h" +#include "qemu/module.h" +#include "hw/misc/tm4c123_sysctl.h" +#include "qemu/bitops.h" +#include "hw/sysbus.h" +#include "hw/irq.h" +#include "qom/object.h" + +#define TIMER_WIDTH_32 0x32B +#define TIMER_WIDTH_64 0x64B + +#define TIMER0_32 0x40030000 +#define TIMER1_32 0x40031000 +#define TIMER2_32 0x40032000 +#define TIMER3_32 0x40033000 +#define TIMER4_32 0x40034000 +#define TIMER5_32 0x40035000 + +#define TIMER0_64 0x40036000 +#define TIMER1_64 0x40037000 +#define TIMER2_64 0x4003C000 +#define TIMER3_64 0x4003D000 +#define TIMER4_64 0x4003E000 +#define TIMER5_64 0x4003F000 + +#define GPTM_CFG 0x000 +#define GPTM_AMR 0x004 +#define GPTM_BMR 0x008 +#define GPTM_CTL 0x00C +#define GPTM_SYNC 0x010 +#define GPTM_IMR 0x018 +#define GPTM_RIS 0x01C +#define GPTM_MIS 0x020 +#define GPTM_ICR 0x024 +#define GPTM_TALIR 0x028 +#define GPTM_TBLIR 0x02C +#define GPTM_TAMATCHR 0x030 +#define GPTM_TBMATCHR 0x034 +#define GPTM_TAPR 0x038 +#define GPTM_TBPR 0x03C +#define GPTM_TAPMR 0x040 +#define GPTM_TBPMR 0x044 +#define GPTM_TAR 0x048 +#define GPTM_TBR 0x04C +#define GPTM_TAV 0x050 +#define GPTM_TBV 0x054 +#define GPTM_RTCPD 0x058 +#define GPTM_TAPS 0x05C +#define GPTM_TBPS 0x060 +#define GPTM_TAPV 0x064 +#define GPTM_TBPV 0x068 +#define GPTM_PP 0xFC0 + +#define GPTM_TACTL_EN (1 << 0) +#define GPTM_TBCTL_EN (1 << 8) +#define GPTM_TAM_CD (1 << 4) +#define GPTM_TAM_MODE_ONESHOT (1 << 1) +#define GPTM_TAM_PERIODIC (1 << 2) + +#define TYPE_TM4C123_GPTM "tm4c123-gptm" + +OBJECT_DECLARE_SIMPLE_TYPE(TM4C123GPTMState, TM4C123_GPTM) + +struct TM4C123GPTMState { + SysBusDevice parent_obj; + MemoryRegion mmio; + qemu_irq irq_a; + qemu_irq irq_b; + TM4C123SysCtlState *sysctl; + + uint32_t gptm_cfg; + uint32_t gptm_amr; + uint32_t gptm_bmr; + uint32_t gptm_ctl; + uint32_t gptm_sync; + uint32_t gptm_imr; + uint32_t gptm_ris; + uint32_t gptm_mis; + uint32_t gptm_icr; + uint32_t gptm_talir; + uint32_t gptm_tblir; + uint32_t gptm_tamatchr; + uint32_t gptm_tbmatchr; + uint32_t gptm_tapr; + uint32_t gptm_tbpr; + uint32_t gptm_tapmr; + uint32_t gptm_tbpmr; + uint32_t gptm_tar; + uint32_t gptm_tbr; + uint32_t gptm_tav; + uint32_t gptm_tbv; + uint32_t gptm_rtcpd; + uint32_t gptm_taps; + uint32_t gptm_tbps; + uint32_t gptm_tapv; + uint32_t gptm_tbpv; + uint32_t gptm_pp; + QEMUTimer *a; + QEMUTimer *b; + Clock* clk; +}; + +#endif --=20 2.34.1 From nobody Sat May 18 06:04:26 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1684311238; cv=none; d=zohomail.com; s=zohoarc; b=MWUQwslQ04iAcBq89hW3deFhs9jTkmfthN8vkZOOWTA1vuQPwx/dVlQxO/UCoYuTa1AgqVhTpLqpkW8kS6OUAnst3kTaHqoCWXMNTq1cW3DjD9TS9Ic23sXHeWonXz34LN3WRkVV7l+mVvfXnQV9ew5JuEvZe/noaBUzmefkxOM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1684311238; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=erP4CMZ3vKzTZs3RtOtcV+NBfbOirUzqRMc5Dx/ruy8=; b=Qd5b52RgAhg/Y3B7qAoP+8RiAJZWGlWSWdnfgJzhfo7wJpqAlGM/dRYERRLa3RNxkrvjloYW7BeD2kQOmTqkMKBznNUQhOD6ylIh22K1j5cvqDGb6+37Fj5eheWOwjmyledJd0hQ9/vrf9gr+NfTO4HdUfc1HChqHmhNpdRXpxk= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1684311238641222.71372926539493; Wed, 17 May 2023 01:13:58 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1pzCGy-000698-Mw; Wed, 17 May 2023 04:12:36 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pzCGt-00060Z-NA; Wed, 17 May 2023 04:12:31 -0400 Received: from mail-wm1-x332.google.com ([2a00:1450:4864:20::332]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1pzCGn-0003O1-6E; Wed, 17 May 2023 04:12:31 -0400 Received: by mail-wm1-x332.google.com with SMTP id 5b1f17b1804b1-3f475366514so3067885e9.2; Wed, 17 May 2023 01:12:24 -0700 (PDT) Received: from i.. ([41.236.82.205]) by smtp.gmail.com with ESMTPSA id o24-20020a1c7518000000b003f42158288dsm1414942wmc.20.2023.05.17.01.12.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 May 2023 01:12:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1684311143; x=1686903143; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=erP4CMZ3vKzTZs3RtOtcV+NBfbOirUzqRMc5Dx/ruy8=; b=YyD2deSJCrPOpWB+mePixeJypSKZRSTLJ7YhfZjEbnYTd3VVeUAgzMWyH9YudP0qCL LhG6r1jBOpGv2XPF13xt7bHUbbO5UKON9tsWquqsvTa1cs0loIOoRJngDy2mxXrh3tPI caJxnNl2fpUKnHKHWkDE/3PYN3ATL288AGPDpT6albTc1cojcpJ/Owzh3WpzfKrELNEm w0DF2Wo4sjnnk1s8wLE3Q10cIyPmskNm7mgP8j1kjN52bzDl3bbyzGoiE0b/jz6xX60e UMWTtG+uPVCd9PM4v4SbWUZasDga3lB3FYFOZgd768ytT9JC/MDCChhQftNmmvlNvINY aA1w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1684311143; x=1686903143; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=erP4CMZ3vKzTZs3RtOtcV+NBfbOirUzqRMc5Dx/ruy8=; b=OMcvLOqRr/2H2J50sUtl7rDkC6nhR+tdDJwReyYLAh+P0noNFTnLYPP+BZvKYARH4C CNS95L/k5fFxaIVJs3XmeqhXiQ9x1NqUxAyyxqYE+aGdCjaNvQUbJdmgtT/hE+yNoQk+ xhzUym6cEG18TB11225mL4S5hiOOOjvKiSyESwMT6KjfSPNX+TfZURXpLfVfbrlErgHX 3yewXwZ8yWJ8PnftLt25je2MdXMxNwd4P5wfkFWJdVRBp8xygvOGrC23eV6PlTWzLSAC UL9UhmhD2FlruV8qwRUFUoXkEbP71s4u4TaqFz5uJuRueG8mQhSsfO+UuMkI25VZs/iy vmIQ== X-Gm-Message-State: AC+VfDxQfyt9Xgfgt0rAmqGd8wG75e5+mjo9k9ql+MNeW3Q6RGX1f5+Q 0yahZddXDIF54V3xfZ/nj2aQFlbQMDE= X-Google-Smtp-Source: ACHHUZ4aRwGJReYAzXa5s72lUagP7El8Z8CkxgAIRHPnZN/X65to23HsNlmeHYSOAW48QwSAJRX7cQ== X-Received: by 2002:a1c:7517:0:b0:3f4:2610:5cbb with SMTP id o23-20020a1c7517000000b003f426105cbbmr21910773wmc.2.1684311142852; Wed, 17 May 2023 01:12:22 -0700 (PDT) From: Mohamed ElSayed To: qemu-devel@nongnu.org Cc: qemu-arm@nongnu.org, Mohamed ElSayed Subject: [PATCH 7/8] tiva c board documentation Date: Wed, 17 May 2023 11:12:03 +0300 Message-Id: <20230517081204.30333-8-m.elsayed4420@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230517081204.30333-1-m.elsayed4420@gmail.com> References: <20230517081204.30333-1-m.elsayed4420@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::332; envelope-from=m.elsayed4420@gmail.com; helo=mail-wm1-x332.google.com X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @gmail.com) X-ZM-MESSAGEID: 1684311238964100001 Content-Type: text/plain; charset="utf-8" Signed-off-by: Mohamed ElSayed --- docs/system/arm/tivac.rst | 47 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 docs/system/arm/tivac.rst diff --git a/docs/system/arm/tivac.rst b/docs/system/arm/tivac.rst new file mode 100644 index 0000000000..8e78726c01 --- /dev/null +++ b/docs/system/arm/tivac.rst @@ -0,0 +1,47 @@ +Texas Instruments EK-TM4C123GXL Evaluation Board, ``Tiva C`` +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +The `Tiva C`_ board is an evaluation platform for ARM Cortex-M4-based micr= ocontrollers. +Its based on the `TM4C123GH6PM`_ microcontroller by Texas Instruments. + +.. _Tiva C: https://www.ti.com/tool/EK-TM4C123GXL +.. _TM4C123GH6PM: https://www.ti.com/product/TM4C123GH6PM + +Supported modules +----------------- + + * ARM Cortex-M4 + * General Purpose Input/Output (GPIO) + * General Purpose Timers (GPTM) + * Serial Ports (USART) + * System Control (SYSCTL) + * Watchdog Timers (WDT) + +Missing modules +--------------- + + * Dynamic Memory Access (uDMA) + * Analog to Digital Converter (ADC) + * Synchronous Serial Interface (SSI) + * Inter-Integrated Circuit Interface (I2C) + * Controller Area Network (CAN) + * USB Controller + * Analog Comparators + * Pulse Width Modulator (PWM) + * Quadrature Encoder Interface (QEI) + +Boot options +------------ + +The Tiva C machines could be started using the ``-kernel`` option to load = a binary file. + +.. code-block:: bash + + $ qemu-system-arm -M tivac -kernel binary.elf -s -S + +The ``-s -S`` switches are for debugging, in another terminal window you c= an do: + +.. code-block:: bash + + $ arm-none-eabi-gdb binary.elf + (gdb) target remote :1234 --=20 2.34.1 From nobody Sat May 18 06:04:26 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1684311274; cv=none; d=zohomail.com; s=zohoarc; b=aTTf5K/Z3M/KeBtGZzJ1Rw0pB/JyDvXFoK+ZIw4ZPHdUWWu+5yXzzWJVRHaj9pZ+6y0vVQfmc+N30002sUk7zi4yGSW1WJkqYBCNgMV85eoxj6PbZDtA1FBlqexIHgpB/yssRxlp3PSjRZyr7rjOSO7QsmAS0do7syQJhD7wQ/g= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1684311274; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=8jTtg6c8tXk3r3zlSLsfWvCTfAcAZwl11odHV82izYQ=; b=UqJ9LDneY6iumi5CrY1fWoYaCv6DHO2fo53H1OPRnxyvr7Ry8dEdPsZNOvPYJShn6dW8uI8e69nbRmRQ+pIJGe0Q3k5v9yBGUadMAi6MC18pvi8DYyEBmcm1PUcOOYtLNSPDkbLliyvf8igCgvh31OaKsa8jrob8/cQhT/g/1Ao= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1684311274202516.9400591792378; Wed, 17 May 2023 01:14:34 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1pzCH1-0006E2-HB; Wed, 17 May 2023 04:12:39 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pzCGv-00063N-QX; Wed, 17 May 2023 04:12:33 -0400 Received: from mail-wr1-x430.google.com ([2a00:1450:4864:20::430]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1pzCGo-0003Oc-9j; Wed, 17 May 2023 04:12:33 -0400 Received: by mail-wr1-x430.google.com with SMTP id ffacd0b85a97d-305f0491e62so411806f8f.3; Wed, 17 May 2023 01:12:25 -0700 (PDT) Received: from i.. ([41.236.82.205]) by smtp.gmail.com with ESMTPSA id o24-20020a1c7518000000b003f42158288dsm1414942wmc.20.2023.05.17.01.12.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 May 2023 01:12:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1684311144; x=1686903144; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=8jTtg6c8tXk3r3zlSLsfWvCTfAcAZwl11odHV82izYQ=; b=eRuQVvi8CwECCCMW1pJmIyNFr7xkWiG4y6PGWoH4CoAZ0lRhqRLFQ0QG5t6lXRe3EK A7inncCKnbpzgh8/oCdZDhlx2WR0Kv7kGazYPbxGol0ZkQFTG9uckRuk0MmCStgF87D9 IpLKwDiDD3CX5tWdPyTz0MwEPXGcTl91fSHdQUAHI04OYAsIn+OtcBEtwWIXORH5qP+i loCeZpVwy/onUDqfgMOirtxlaG9M1JURfsTYpWfETpBz+YtXxj1z3OlT2dsupilM25/n RYj+HYw3G554fIVKw+A3Tzm+OdW82Ks4btuE3h/f+RYrGzL7ga6DgmLWON0/nhtipEh3 qjfw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1684311144; x=1686903144; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=8jTtg6c8tXk3r3zlSLsfWvCTfAcAZwl11odHV82izYQ=; b=ciOkaE1FjbjVKERLmtljFLpgMf5oE+LrqtJ0IGo50Gelm5yx6SOVa7HzCRI+GUo4+V 7eo8JP1bjFj9Ak24j9wzqF9CJ7TlHyBW5VfPT3v1q+IKowE0Nz7NxwYd1djRfrw3WR8s lCSTeNin1/oe0vJD8y6kixHwxXhCKrMqibK3wFW6TRRHHb5OjlNnUsCfJoEt09vt67HN dwl59IRHRQQBQzUNCwEkNHQNdzZfpVwW4DmrBQSa5hEeJtSjE1vgbq8VAKRoDKOd0DMY isi9BJ4ySQpyoP40BQGT2VX2VLJnBIzT1ATUz3HC2mPZs0fx2vU7P089mKCIJv2PBB2R utcA== X-Gm-Message-State: AC+VfDzHxUSUEjX/sNLZL+lHM9nh8A9eYBrOj4q/kSd2x8uFkaiFeJuF Ui2z8TxmvABOn0OAM15/iNJNHaghjuw= X-Google-Smtp-Source: ACHHUZ6x2l5J1oqGOFLCwZEiVY682R0m2hozgfpB23UJK3JuAGoTzM+SkRaIJ0UIR4lIlJj3PLueRw== X-Received: by 2002:adf:df01:0:b0:306:cfba:3c32 with SMTP id y1-20020adfdf01000000b00306cfba3c32mr27994911wrl.48.1684311144084; Wed, 17 May 2023 01:12:24 -0700 (PDT) From: Mohamed ElSayed To: qemu-devel@nongnu.org Cc: qemu-arm@nongnu.org, Mohamed ElSayed Subject: [PATCH 8/8] adding tiva c to the qemu build system and adding my info to the maintainers list Date: Wed, 17 May 2023 11:12:04 +0300 Message-Id: <20230517081204.30333-9-m.elsayed4420@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230517081204.30333-1-m.elsayed4420@gmail.com> References: <20230517081204.30333-1-m.elsayed4420@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::430; envelope-from=m.elsayed4420@gmail.com; helo=mail-wr1-x430.google.com X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_ENVFROM_END_DIGIT=0.25, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @gmail.com) X-ZM-MESSAGEID: 1684311275433100007 Content-Type: text/plain; charset="utf-8" Signed-off-by: Mohamed ElSayed --- MAINTAINERS | 9 +++++++++ configs/devices/arm-softmmu/default.mak | 1 + hw/arm/Kconfig | 13 +++++++++++++ hw/arm/meson.build | 3 +++ hw/char/Kconfig | 3 +++ hw/char/meson.build | 1 + hw/gpio/Kconfig | 3 +++ hw/gpio/meson.build | 1 + hw/misc/Kconfig | 3 +++ hw/misc/meson.build | 1 + hw/timer/Kconfig | 3 +++ hw/timer/meson.build | 1 + hw/watchdog/Kconfig | 3 +++ hw/watchdog/meson.build | 1 + 14 files changed, 46 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index b22b85bc3a..dcd902fadf 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1008,6 +1008,15 @@ F: include/hw/misc/zynq_slcr.h F: include/hw/adc/zynq-xadc.h X: hw/ssi/xilinx_* =20 +Tiva C +M: Mohamed ElSayed +L: qemu-arm@nongnu.org +S: Maintained +F: hw/*/tm4c123* +F: include/hw/*/tm4c123* +F: hw/arm/tivac.c +F: docs/system/arm/tivac.rst + Xilinx ZynqMP and Versal M: Alistair Francis M: Edgar E. Iglesias diff --git a/configs/devices/arm-softmmu/default.mak b/configs/devices/arm-= softmmu/default.mak index 1b49a7830c..d3490f6d11 100644 --- a/configs/devices/arm-softmmu/default.mak +++ b/configs/devices/arm-softmmu/default.mak @@ -43,3 +43,4 @@ CONFIG_FSL_IMX6UL=3Dy CONFIG_SEMIHOSTING=3Dy CONFIG_ARM_COMPATIBLE_SEMIHOSTING=3Dy CONFIG_ALLWINNER_H3=3Dy +CONFIG_TIVAC=3Dy diff --git a/hw/arm/Kconfig b/hw/arm/Kconfig index b53bd7f0b2..ef8046ab1b 100644 --- a/hw/arm/Kconfig +++ b/hw/arm/Kconfig @@ -581,3 +581,16 @@ config ARMSSE select UNIMP select SSE_COUNTER select SSE_TIMER + +config TM4C123GH6PM_SOC + bool + select ARM_V7M + select TM4C123_USART + select TM4C123_SYSCTL + select TM4C123_GPIO + select TM4C123_WDT + select TM4C123_GPTM + +config TIVAC + bool + select TM4C123GH6PM_SOC diff --git a/hw/arm/meson.build b/hw/arm/meson.build index b545ba0e4f..29503388a5 100644 --- a/hw/arm/meson.build +++ b/hw/arm/meson.build @@ -62,10 +62,13 @@ arm_ss.add(when: 'CONFIG_FSL_IMX7', if_true: files('fsl= -imx7.c', 'mcimx7d-sabre. arm_ss.add(when: 'CONFIG_ARM_SMMUV3', if_true: files('smmuv3.c')) arm_ss.add(when: 'CONFIG_FSL_IMX6UL', if_true: files('fsl-imx6ul.c', 'mcim= x6ul-evk.c')) arm_ss.add(when: 'CONFIG_NRF51_SOC', if_true: files('nrf51_soc.c')) +arm_ss.add(when: 'CONFIG_TM4C123GH6PM_SOC', if_true: files('tm4c123gh6pm_s= oc.c')) +arm_ss.add(when: 'CONFIG_TIVAC', if_true: files('tivac.c')) =20 softmmu_ss.add(when: 'CONFIG_ARM_SMMUV3', if_true: files('smmu-common.c')) softmmu_ss.add(when: 'CONFIG_EXYNOS4', if_true: files('exynos4_boards.c')) softmmu_ss.add(when: 'CONFIG_RASPI', if_true: files('bcm2835_peripherals.c= ')) softmmu_ss.add(when: 'CONFIG_TOSA', if_true: files('tosa.c')) =20 + hw_arch +=3D {'arm': arm_ss} diff --git a/hw/char/Kconfig b/hw/char/Kconfig index 6b6cf2fc1d..88da979b75 100644 --- a/hw/char/Kconfig +++ b/hw/char/Kconfig @@ -71,3 +71,6 @@ config GOLDFISH_TTY =20 config SHAKTI_UART bool + +config TM4C123_USART + bool diff --git a/hw/char/meson.build b/hw/char/meson.build index 0807e00ae4..8461748c8d 100644 --- a/hw/char/meson.build +++ b/hw/char/meson.build @@ -33,6 +33,7 @@ softmmu_ss.add(when: 'CONFIG_SH_SCI', if_true: files('sh_= serial.c')) softmmu_ss.add(when: 'CONFIG_STM32F2XX_USART', if_true: files('stm32f2xx_u= sart.c')) softmmu_ss.add(when: 'CONFIG_MCHP_PFSOC_MMUART', if_true: files('mchp_pfso= c_mmuart.c')) softmmu_ss.add(when: 'CONFIG_HTIF', if_true: files('riscv_htif.c')) +softmmu_ss.add(when: 'CONFIG_TM4C123_USART', if_true: files('tm4c123_usart= .c')) softmmu_ss.add(when: 'CONFIG_GOLDFISH_TTY', if_true: files('goldfish_tty.c= ')) =20 specific_ss.add(when: 'CONFIG_TERMINAL3270', if_true: files('terminal3270.= c')) diff --git a/hw/gpio/Kconfig b/hw/gpio/Kconfig index d2cf3accc8..1b843d669a 100644 --- a/hw/gpio/Kconfig +++ b/hw/gpio/Kconfig @@ -16,3 +16,6 @@ config GPIO_PWR =20 config SIFIVE_GPIO bool + +config TM4C123_GPIO + bool diff --git a/hw/gpio/meson.build b/hw/gpio/meson.build index b726e6d27a..b253e8ce67 100644 --- a/hw/gpio/meson.build +++ b/hw/gpio/meson.build @@ -12,3 +12,4 @@ softmmu_ss.add(when: 'CONFIG_OMAP', if_true: files('omap_= gpio.c')) softmmu_ss.add(when: 'CONFIG_RASPI', if_true: files('bcm2835_gpio.c')) softmmu_ss.add(when: 'CONFIG_ASPEED_SOC', if_true: files('aspeed_gpio.c')) softmmu_ss.add(when: 'CONFIG_SIFIVE_GPIO', if_true: files('sifive_gpio.c')) +softmmu_ss.add(when: 'CONFIG_TM4C123_GPIO', if_true: files('tm4c123_gpio.c= ')) diff --git a/hw/misc/Kconfig b/hw/misc/Kconfig index 2ef5781ef8..c8be9ae285 100644 --- a/hw/misc/Kconfig +++ b/hw/misc/Kconfig @@ -180,4 +180,7 @@ config AXP209_PMU bool depends on I2C =20 +config TM4C123_SYSCTL + bool + source macio/Kconfig diff --git a/hw/misc/meson.build b/hw/misc/meson.build index a40245ad44..95ddb4b1b4 100644 --- a/hw/misc/meson.build +++ b/hw/misc/meson.build @@ -141,3 +141,4 @@ softmmu_ss.add(when: 'CONFIG_SBSA_REF', if_true: files(= 'sbsa_ec.c')) =20 # HPPA devices softmmu_ss.add(when: 'CONFIG_LASI', if_true: files('lasi.c')) +softmmu_ss.add(when: 'CONFIG_TM4C123_SYSCTL', if_true: files('tm4c123_sysc= tl.c')) diff --git a/hw/timer/Kconfig b/hw/timer/Kconfig index 010be7ed1f..aaf42e3f3f 100644 --- a/hw/timer/Kconfig +++ b/hw/timer/Kconfig @@ -60,3 +60,6 @@ config STELLARIS_GPTM =20 config AVR_TIMER16 bool + +config TM4C123_GPTM + bool diff --git a/hw/timer/meson.build b/hw/timer/meson.build index 03092e2ceb..118593e959 100644 --- a/hw/timer/meson.build +++ b/hw/timer/meson.build @@ -36,5 +36,6 @@ softmmu_ss.add(when: 'CONFIG_STM32F2XX_TIMER', if_true: f= iles('stm32f2xx_timer.c softmmu_ss.add(when: 'CONFIG_XILINX', if_true: files('xilinx_timer.c')) specific_ss.add(when: 'CONFIG_IBEX', if_true: files('ibex_timer.c')) softmmu_ss.add(when: 'CONFIG_SIFIVE_PWM', if_true: files('sifive_pwm.c')) +softmmu_ss.add(when: 'CONFIG_TM4C123_GPTM', if_true: files('tm4c123_gptm.c= ')) =20 specific_ss.add(when: 'CONFIG_AVR_TIMER16', if_true: files('avr_timer16.c'= )) diff --git a/hw/watchdog/Kconfig b/hw/watchdog/Kconfig index 861fd00334..ada7163055 100644 --- a/hw/watchdog/Kconfig +++ b/hw/watchdog/Kconfig @@ -24,3 +24,6 @@ config WDT_SBSA config ALLWINNER_WDT bool select PTIMER + +config TM4C123_WDT + bool diff --git a/hw/watchdog/meson.build b/hw/watchdog/meson.build index 5dcd4fbe2f..cc48d2dec9 100644 --- a/hw/watchdog/meson.build +++ b/hw/watchdog/meson.build @@ -7,4 +7,5 @@ softmmu_ss.add(when: 'CONFIG_WDT_DIAG288', if_true: files('= wdt_diag288.c')) softmmu_ss.add(when: 'CONFIG_ASPEED_SOC', if_true: files('wdt_aspeed.c')) softmmu_ss.add(when: 'CONFIG_WDT_IMX2', if_true: files('wdt_imx2.c')) softmmu_ss.add(when: 'CONFIG_WDT_SBSA', if_true: files('sbsa_gwdt.c')) +softmmu_ss.add(when: 'CONFIG_TM4C123_WDT', if_true: files('tm4c123_watchdo= g.c')) specific_ss.add(when: 'CONFIG_PSERIES', if_true: files('spapr_watchdog.c')) --=20 2.34.1