deac/osd-contiki
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
osd-contiki/platform/galileo/contiki-main.c

92 lines
2.7 KiB
C
Raw Normal View History

galileo: Initial support for Intel Galileo Platform This patch adds the initial support for Intel Galileo Platform. It contains the minimum set of code required to boot a dummy Contiki image. For Galileo initial support, we implemented a linker script, a minimal bootstrap code, a set of stubbed functions required by newlib, and a very simple main() function. Moreover, we also define some header files and macros required by Contiki. To build applications for this platform you should first build newlib (in case it wasn't already built). To build newlib you can run the following command: $ platform/galileo/bsp/libc/build_newlib.sh Once newlib is built, you can build applications. To build applications for Galileo platform you should set TARGET variable to 'galileo'. For instance, building the hello-world application should look like this: $ cd examples/hello-world/ && make TARGET=galileo This will generate the 'hello-world.galileo' file which is a multiboot- compliant [1] ELF image. This image can be booted by any multiboot- complaint bootloader such as Grub. Finally, this patch should be used as a guideline to add the initial support for others platforms based on x86 SoCs. [1] https://www.gnu.org/software/grub/manual/multiboot/multiboot.html
2015-07-01 21:43:42 +02:00
/*
x86, galileo: Refactor I2C and GPIO initialization This patch revises the I2C and GPIO initialization code to always be run during platform boot rather than within each process that requires it. This patch also revises the gpio-output example to use a pin that is set as an output by the default pinmux configuration. Previously, it used a pin that was set as an output by the pinmux configuration that is in effect when the OS does not change the pinmux configuration.
2016-01-06 08:05:09 +01:00
* Copyright (C) 2015-2016, Intel Corporation. All rights reserved.
galileo: Initial support for Intel Galileo Platform This patch adds the initial support for Intel Galileo Platform. It contains the minimum set of code required to boot a dummy Contiki image. For Galileo initial support, we implemented a linker script, a minimal bootstrap code, a set of stubbed functions required by newlib, and a very simple main() function. Moreover, we also define some header files and macros required by Contiki. To build applications for this platform you should first build newlib (in case it wasn't already built). To build newlib you can run the following command: $ platform/galileo/bsp/libc/build_newlib.sh Once newlib is built, you can build applications. To build applications for Galileo platform you should set TARGET variable to 'galileo'. For instance, building the hello-world application should look like this: $ cd examples/hello-world/ && make TARGET=galileo This will generate the 'hello-world.galileo' file which is a multiboot- compliant [1] ELF image. This image can be booted by any multiboot- complaint bootloader such as Grub. Finally, this patch should be used as a guideline to add the initial support for others platforms based on x86 SoCs. [1] https://www.gnu.org/software/grub/manual/multiboot/multiboot.html
2015-07-01 21:43:42 +02:00
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
galileo: Initial stdio support This patch introduces the initial support for stdio library in Galileo platform. For now, only standard output and error are supported. Both streams use the UART1 device. Newlib doesn't call open() for stdin, stdout, and stderr which means that the _write_r call is the first activity the stub will see on those streams. For that reason, we initialize the UART1 device in Galileo's platform main() function instead of in open() system call.
2015-07-17 15:43:55 +02:00
#include <stdio.h>
galileo: Implement main() function This patch implements the main() function for Galileo platform. At this moment, only Processes subsystem is enabled. After this patch we are able to some rudimentary debugging to ensure that process thread from applications are being indeed executed. Once we properly support more Contiki subsystems, such as clock, ctimer, etimer, and rtimer, we will add them to Galileo platform's main() as well.
2015-07-02 00:56:48 +02:00
#include "contiki.h"
galileo: Add Ethernet support This patch adds support for Ethernet to the Intel Galileo port. It uses the Intel Quark X1000 Ethernet driver. It initializes the first Ethernet interface and starts some common network services. By default, it uses the following addresses: - Host: 192.0.2.2 - Netmask: 255.255.255.0 - Default gateway: 192.0.2.1 - DNS server: (same as default gateway) These settings can be changed by editing eth-conf.c.
2015-07-08 01:40:21 +02:00
#include "contiki-net.h"
x86: CPU Initialization This patch defines the cpu_init() function which should encapsulate all code related to x86 CPU initialization. For now, this function initializes GDT and IDT.
2015-07-01 23:30:46 +02:00
#include "cpu.h"
x86: Use shared ISR for I2C and GPIO This patch permits interrupts to be generated by both the I2C and GPIO controllers for simultaneously-executing applications. The controllers share a single interrupt pin, INTC. Prior to this patch, quarkX1000_gpio_init() routed INTA to PIRQC and IRQ 10 (due to an incorrect assumption that INTA is connected to the GPIO controller), and quarkX1000_i2c_init() routed INTC to PIRQC and IRQ 9. The I2C controller initialization is a prerequisite for GPIO initialization, so the final configuration was that INTA and INTC were both routed to PIRQC and IRQ 10. Thus, only the GPIO ISR was being invoked, even if the I2C controller was actually responsible for the interrupt. This patch refactors the I2C and GPIO ISR setup and handler code so that the shared portions are combined in cpu/x86/drivers/legacy_pc/shared-isr.[ch]. The I2C and GPIO drivers communicate their interrupt information to the shared component by placing structures in a specific section of the binary.
2016-01-07 02:00:45 +01:00
#include "eth-conf.h"
x86, galileo: Refactor I2C and GPIO initialization This patch revises the I2C and GPIO initialization code to always be run during platform boot rather than within each process that requires it. This patch also revises the gpio-output example to use a pin that is set as an output by the default pinmux configuration. Previously, it used a pin that was set as an output by the pinmux configuration that is in effect when the OS does not change the pinmux configuration.
2016-01-06 08:05:09 +01:00
#include "galileo-pinmux.h"
#include "gpio.h"
#include "i2c.h"
x86, galileo: Use IMRs to restrict DMA This patch configures Isolated Memory Regions (IMRs) to block DMA to code and data regions that do not contain any data that needs to be DMA-accessible.
2015-09-30 06:29:35 +02:00
#include "imr-conf.h"
x86: Initialize the 8259 PIC The Programmable Interrupt Controller is a chip responsible for translating hardware interrupts to system interrupts. When it receives an Interrupt Request (IRQ), it triggers the appropriate interrupt line reaching the appropriate IDT gate, following a previously setup offset. There are 2 daisy-chained PICs. PIC1 handles IRQs 0-7 and PIC2 handles IRQs 8-15. If no vector offset is set, an IRQ0, for instance, would trigger the interrupt 0, clashing with the "Division by zero exception" handler. Thus the IRQs must be remapped. This patch implements the PICs initialization through their 4 Initialization Command Words (ICWs) in a very "canonical" way: - ICW1: the initializing command; - ICW2: the vector offset for the PIC1 and PIC2 (we add an offset of 32 positions); - ICW3: the inter-PICs wiring setup (we connect PIC2 to PIC1's IRQ2); - ICW4: extra systems information (we set PIC1 as Master and PIC2 as slave). It then masks the Interrupt Mask Register, blocking all IRQs but #2 initially. These must be unmasked on demand. The IMR is 8-bits long, so setting the n^th bit to 1 would DISABLE the IRQ n while setting it to 0 would ENABLE IRQ n. As stated, this is an implementation of the legacy 8259 PIC. More investigation is needed so we decide if it is enough or if we need the (newer) APIC implementation instead. This patch also adds the outb() helper function to helpers.h. The helpers is a wrapper for assembly 'out' instruction. Finally, since we now properly support hardware interrupts, this patch also enables IRQs in platform main(). More information: - Quark X1000 Datasheet, section 21.12, page 898. - http://wiki.osdev.org/8259_PIC - http://stanislavs.org/helppc/8259.html
2015-04-08 22:18:27 +02:00
#include "interrupt.h"
x86: Use shared ISR for I2C and GPIO This patch permits interrupts to be generated by both the I2C and GPIO controllers for simultaneously-executing applications. The controllers share a single interrupt pin, INTC. Prior to this patch, quarkX1000_gpio_init() routed INTA to PIRQC and IRQ 10 (due to an incorrect assumption that INTA is connected to the GPIO controller), and quarkX1000_i2c_init() routed INTC to PIRQC and IRQ 9. The I2C controller initialization is a prerequisite for GPIO initialization, so the final configuration was that INTA and INTC were both routed to PIRQC and IRQ 10. Thus, only the GPIO ISR was being invoked, even if the I2C controller was actually responsible for the interrupt. This patch refactors the I2C and GPIO ISR setup and handler code so that the shared portions are combined in cpu/x86/drivers/legacy_pc/shared-isr.[ch]. The I2C and GPIO drivers communicate their interrupt information to the shared component by placing structures in a specific section of the binary.
2016-01-07 02:00:45 +01:00
#include "shared-isr.h"
galileo: Initial stdio support This patch introduces the initial support for stdio library in Galileo platform. For now, only standard output and error are supported. Both streams use the UART1 device. Newlib doesn't call open() for stdin, stdout, and stderr which means that the _write_r call is the first activity the stub will see on those streams. For that reason, we initialize the UART1 device in Galileo's platform main() function instead of in open() system call.
2015-07-17 15:43:55 +02:00
#include "uart.h"
galileo: Add Ethernet support This patch adds support for Ethernet to the Intel Galileo port. It uses the Intel Quark X1000 Ethernet driver. It initializes the first Ethernet interface and starts some common network services. By default, it uses the following addresses: - Host: 192.0.2.2 - Netmask: 255.255.255.0 - Default gateway: 192.0.2.1 - DNS server: (same as default gateway) These settings can be changed by editing eth-conf.c.
2015-07-08 01:40:21 +02:00
PROCINIT( &etimer_process
, &tcpip_process
#if WITH_DNS
, &resolv_process
#endif
);
galileo: Implement main() function This patch implements the main() function for Galileo platform. At this moment, only Processes subsystem is enabled. After this patch we are able to some rudimentary debugging to ensure that process thread from applications are being indeed executed. Once we properly support more Contiki subsystems, such as clock, ctimer, etimer, and rtimer, we will add them to Galileo platform's main() as well.
2015-07-02 00:56:48 +02:00
galileo: Initial support for Intel Galileo Platform This patch adds the initial support for Intel Galileo Platform. It contains the minimum set of code required to boot a dummy Contiki image. For Galileo initial support, we implemented a linker script, a minimal bootstrap code, a set of stubbed functions required by newlib, and a very simple main() function. Moreover, we also define some header files and macros required by Contiki. To build applications for this platform you should first build newlib (in case it wasn't already built). To build newlib you can run the following command: $ platform/galileo/bsp/libc/build_newlib.sh Once newlib is built, you can build applications. To build applications for Galileo platform you should set TARGET variable to 'galileo'. For instance, building the hello-world application should look like this: $ cd examples/hello-world/ && make TARGET=galileo This will generate the 'hello-world.galileo' file which is a multiboot- compliant [1] ELF image. This image can be booted by any multiboot- complaint bootloader such as Grub. Finally, this patch should be used as a guideline to add the initial support for others platforms based on x86 SoCs. [1] https://www.gnu.org/software/grub/manual/multiboot/multiboot.html
2015-07-01 21:43:42 +02:00
int
main(void)
{
x86: CPU Initialization This patch defines the cpu_init() function which should encapsulate all code related to x86 CPU initialization. For now, this function initializes GDT and IDT.
2015-07-01 23:30:46 +02:00
cpu_init();
x86, galileo: Use IMRs to restrict DMA This patch configures Isolated Memory Regions (IMRs) to block DMA to code and data regions that do not contain any data that needs to be DMA-accessible.
2015-09-30 06:29:35 +02:00
#ifdef X86_CONF_RESTRICT_DMA
quarkX1000_imr_conf();
#endif
galileo: Initial stdio support This patch introduces the initial support for stdio library in Galileo platform. For now, only standard output and error are supported. Both streams use the UART1 device. Newlib doesn't call open() for stdin, stdout, and stderr which means that the _write_r call is the first activity the stub will see on those streams. For that reason, we initialize the UART1 device in Galileo's platform main() function instead of in open() system call.
2015-07-17 15:43:55 +02:00
/* Initialize UART connected to Galileo Gen2 FTDI header */
quarkX1000_uart_init(QUARK_X1000_UART_1);
galileo: Add support for Clock module This patch adds support for Contiki's clock module. All functions from core/sys/clock.h are implemented, except clock_set_seconds() and clock_ delay_usec(). The CLOCK_CONF_SECOND macro is set to 128. This value seems to be good enough since several platforms used it. Finally, we use the RTC driver to track the number of ticks from the system clock.
2015-07-03 23:17:46 +02:00
clock_init();
galileo: Support for rtimer library This patch adds support for rtimer library on Galileo's platform. We use the PIT to implement the rtimer platform dependent functionalities. We chose the PIT for mainly two reason: I) its configuration is very simple II) it has a high frequency which provides us a good clock resolution (requirement from rtimer library). Since we keep track of the number of ticks in software, we define rtimer_clock_t type as uint64_t. This gives us a good amount of time til the variable overflows. For instance, a 32-bit type would overflow in about one hour for high clock resolution (~ 1us). The rtimer clock frequency (RTIMER_ARCH_SECOND) is setup to 1 kHz. There is no technical matter regarding this value. It is just an initial guess. Just for the record, we might want to use HPET in future to implement the rtimer library since it seems to be more appropriate. The reason why we don't use it at this moment is that, in order to configure it, we need support for ACPI 2.0 which we don't. Once we have use-cases for the rtimer library we'll probably replace PIT by HPET or any other timer more suitable for the job.
2015-07-02 22:57:03 +02:00
rtimer_init();
x86: CPU Initialization This patch defines the cpu_init() function which should encapsulate all code related to x86 CPU initialization. For now, this function initializes GDT and IDT.
2015-07-01 23:30:46 +02:00
galileo: Initial stdio support This patch introduces the initial support for stdio library in Galileo platform. For now, only standard output and error are supported. Both streams use the UART1 device. Newlib doesn't call open() for stdin, stdout, and stderr which means that the _write_r call is the first activity the stub will see on those streams. For that reason, we initialize the UART1 device in Galileo's platform main() function instead of in open() system call.
2015-07-17 15:43:55 +02:00
printf("Starting Contiki\n");
x86, galileo: Refactor I2C and GPIO initialization This patch revises the I2C and GPIO initialization code to always be run during platform boot rather than within each process that requires it. This patch also revises the gpio-output example to use a pin that is set as an output by the default pinmux configuration. Previously, it used a pin that was set as an output by the pinmux configuration that is in effect when the OS does not change the pinmux configuration.
2016-01-06 08:05:09 +01:00
quarkX1000_i2c_init();
quarkX1000_i2c_configure(QUARKX1000_I2C_SPEED_STANDARD,
QUARKX1000_I2C_ADDR_MODE_7BIT);
/* use default pinmux configuration */
if(galileo_pinmux_initialize() < 0) {
fprintf(stderr, "Failed to initialize pinmux\n");
}
quarkX1000_gpio_init();
x86: Initialize the 8259 PIC The Programmable Interrupt Controller is a chip responsible for translating hardware interrupts to system interrupts. When it receives an Interrupt Request (IRQ), it triggers the appropriate interrupt line reaching the appropriate IDT gate, following a previously setup offset. There are 2 daisy-chained PICs. PIC1 handles IRQs 0-7 and PIC2 handles IRQs 8-15. If no vector offset is set, an IRQ0, for instance, would trigger the interrupt 0, clashing with the "Division by zero exception" handler. Thus the IRQs must be remapped. This patch implements the PICs initialization through their 4 Initialization Command Words (ICWs) in a very "canonical" way: - ICW1: the initializing command; - ICW2: the vector offset for the PIC1 and PIC2 (we add an offset of 32 positions); - ICW3: the inter-PICs wiring setup (we connect PIC2 to PIC1's IRQ2); - ICW4: extra systems information (we set PIC1 as Master and PIC2 as slave). It then masks the Interrupt Mask Register, blocking all IRQs but #2 initially. These must be unmasked on demand. The IMR is 8-bits long, so setting the n^th bit to 1 would DISABLE the IRQ n while setting it to 0 would ENABLE IRQ n. As stated, this is an implementation of the legacy 8259 PIC. More investigation is needed so we decide if it is enough or if we need the (newer) APIC implementation instead. This patch also adds the outb() helper function to helpers.h. The helpers is a wrapper for assembly 'out' instruction. Finally, since we now properly support hardware interrupts, this patch also enables IRQs in platform main(). More information: - Quark X1000 Datasheet, section 21.12, page 898. - http://wiki.osdev.org/8259_PIC - http://stanislavs.org/helppc/8259.html
2015-04-08 22:18:27 +02:00
ENABLE_IRQ();
galileo: Implement main() function This patch implements the main() function for Galileo platform. At this moment, only Processes subsystem is enabled. After this patch we are able to some rudimentary debugging to ensure that process thread from applications are being indeed executed. Once we properly support more Contiki subsystems, such as clock, ctimer, etimer, and rtimer, we will add them to Galileo platform's main() as well.
2015-07-02 00:56:48 +02:00
process_init();
galileo: Add Ethernet support This patch adds support for Ethernet to the Intel Galileo port. It uses the Intel Quark X1000 Ethernet driver. It initializes the first Ethernet interface and starts some common network services. By default, it uses the following addresses: - Host: 192.0.2.2 - Netmask: 255.255.255.0 - Default gateway: 192.0.2.1 - DNS server: (same as default gateway) These settings can be changed by editing eth-conf.c.
2015-07-08 01:40:21 +02:00
procinit_init();
galileo: Add support for Etimer and Ctimer libraries This patch adds support for the Etimer and Ctimer libraries. To support the Etimer library, we should poll the etimer process every time the system clock is updated. To do this more efficiently, by taking advantage of etimer_next_expiration_time() API, we poll the etimer process only when an 'Event Timer' has expired. We don't need any platform specific support in order to enable the Ctimer library since it relies completely on Etimer. The others timer libraries (Timer and Stime) don't required any specific platform support as well since they rely on the system Clock module only.
2015-07-04 00:21:21 +02:00
ctimer_init();
galileo: Implement main() function This patch implements the main() function for Galileo platform. At this moment, only Processes subsystem is enabled. After this patch we are able to some rudimentary debugging to ensure that process thread from applications are being indeed executed. Once we properly support more Contiki subsystems, such as clock, ctimer, etimer, and rtimer, we will add them to Galileo platform's main() as well.
2015-07-02 00:56:48 +02:00
autostart_start(autostart_processes);
galileo: Add Ethernet support This patch adds support for Ethernet to the Intel Galileo port. It uses the Intel Quark X1000 Ethernet driver. It initializes the first Ethernet interface and starts some common network services. By default, it uses the following addresses: - Host: 192.0.2.2 - Netmask: 255.255.255.0 - Default gateway: 192.0.2.1 - DNS server: (same as default gateway) These settings can be changed by editing eth-conf.c.
2015-07-08 01:40:21 +02:00
eth_init();
x86: Use shared ISR for I2C and GPIO This patch permits interrupts to be generated by both the I2C and GPIO controllers for simultaneously-executing applications. The controllers share a single interrupt pin, INTC. Prior to this patch, quarkX1000_gpio_init() routed INTA to PIRQC and IRQ 10 (due to an incorrect assumption that INTA is connected to the GPIO controller), and quarkX1000_i2c_init() routed INTC to PIRQC and IRQ 9. The I2C controller initialization is a prerequisite for GPIO initialization, so the final configuration was that INTA and INTC were both routed to PIRQC and IRQ 10. Thus, only the GPIO ISR was being invoked, even if the I2C controller was actually responsible for the interrupt. This patch refactors the I2C and GPIO ISR setup and handler code so that the shared portions are combined in cpu/x86/drivers/legacy_pc/shared-isr.[ch]. The I2C and GPIO drivers communicate their interrupt information to the shared component by placing structures in a specific section of the binary.
2016-01-07 02:00:45 +01:00
shared_isr_init();
galileo: Implement main() function This patch implements the main() function for Galileo platform. At this moment, only Processes subsystem is enabled. After this patch we are able to some rudimentary debugging to ensure that process thread from applications are being indeed executed. Once we properly support more Contiki subsystems, such as clock, ctimer, etimer, and rtimer, we will add them to Galileo platform's main() as well.
2015-07-02 00:56:48 +02:00
while(1) {
process_run();
}
galileo: Initial support for Intel Galileo Platform This patch adds the initial support for Intel Galileo Platform. It contains the minimum set of code required to boot a dummy Contiki image. For Galileo initial support, we implemented a linker script, a minimal bootstrap code, a set of stubbed functions required by newlib, and a very simple main() function. Moreover, we also define some header files and macros required by Contiki. To build applications for this platform you should first build newlib (in case it wasn't already built). To build newlib you can run the following command: $ platform/galileo/bsp/libc/build_newlib.sh Once newlib is built, you can build applications. To build applications for Galileo platform you should set TARGET variable to 'galileo'. For instance, building the hello-world application should look like this: $ cd examples/hello-world/ && make TARGET=galileo This will generate the 'hello-world.galileo' file which is a multiboot- compliant [1] ELF image. This image can be booted by any multiboot- complaint bootloader such as Grub. Finally, this patch should be used as a guideline to add the initial support for others platforms based on x86 SoCs. [1] https://www.gnu.org/software/grub/manual/multiboot/multiboot.html
2015-07-01 21:43:42 +02:00
return 0;
}
Reference in a new issue Copy permalink