ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2025-04-07 19:34:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

gpio: remove env deprecated warnings

Browse Source 
And while there, remove usage of Server library.

Issue #2280.
This commit is contained in:
Josef Söntgen 2017-02-23 14:32:20 +01:00 committed by Christian Helmuth
parent 4f8804c334
commit 0c7200a0fe
18 changed files with 156 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
repos/os/include/gpio/config.h
View File

@ -27,23 +27,24 @@
#ifndef _INCLUDE__GPIO__CONFIG_H_
#define _INCLUDE__GPIO__CONFIG_H_
/* Genode includes */
#include <base/exception.h>
#include <os/config.h>
#include <gpio/driver.h>
#include <util/xml_node.h>
namespace Gpio {
class Invalid_gpio_number : Genode::Exception {};
class Invalid_mode : Genode::Exception {};
static void process_config(Gpio::Driver &driver);
static void process_config(Genode::Xml_node const &config, Gpio::Driver &driver);
}
void Gpio::process_config(Gpio::Driver &driver)
void Gpio::process_config(Genode::Xml_node const &config, Gpio::Driver &driver)
{
try {
Genode::Xml_node gpio_node = Genode::config()->xml_node().sub_node("gpio");
Genode::Xml_node gpio_node = config.sub_node("gpio");
for (;; gpio_node = gpio_node.next("gpio")) {
unsigned num = 0;

31
repos/os/src/drivers/gpio/spec/exynos4/driver.h
View File

@ -32,18 +32,18 @@ namespace Gpio { class Odroid_x2_driver; }
class Gpio::Odroid_x2_driver : public Driver
{
private:
Server::Entrypoint &_ep;
Reg _reg1;
Reg _reg2;
Reg _reg3;
Reg _reg4;
Genode::Irq_connection _irq;
Genode::Signal_rpc_member<Odroid_x2_driver> _dispatcher;
Genode::Signal_handler<Odroid_x2_driver> _dispatcher;
Genode::Signal_context_capability _sig_cap[MAX_PINS];
bool _irq_enabled[MAX_PINS];
bool _async;
void _handle(unsigned)
void _handle()
{
handle_irq();
}
@ -70,14 +70,14 @@ class Gpio::Odroid_x2_driver : public Driver
int _gpio_index(int gpio) { return gpio & 0x1f; }
Odroid_x2_driver(Server::Entrypoint &ep)
: _ep(ep),
_reg1(0x11400000, 1000),
_reg2(0x11000000, 1000),
_reg3(0x03860000, 1000),
_reg4(0x106E0000, 1000),
_irq(104),
_dispatcher(ep, *this, &Odroid_x2_driver::_handle),
Odroid_x2_driver(Genode::Env &env)
:
_reg1(env, 0x11400000, 1000),
_reg2(env, 0x11000000, 1000),
_reg3(env, 0x03860000, 1000),
_reg4(env, 0x106E0000, 1000),
_irq(env, 104),
_dispatcher(env.ep(), *this, &Odroid_x2_driver::_handle),
_async(false)
{
_irq.sigh(_dispatcher);
@ -87,7 +87,7 @@ class Gpio::Odroid_x2_driver : public Driver
public:
static Odroid_x2_driver& factory(Server::Entrypoint &ep);
static Odroid_x2_driver& factory(Genode::Env &env);
/******************************
@ -218,11 +218,4 @@ class Gpio::Odroid_x2_driver : public Driver
bool gpio_valid(unsigned gpio) { return gpio < (MAX_PINS); }
};
Gpio::Odroid_x2_driver& Gpio::Odroid_x2_driver::factory(Server::Entrypoint &ep)
{
static Odroid_x2_driver driver(ep);
return driver;
}
#endif /* _DRIVER_H_ */

4
repos/os/src/drivers/gpio/spec/exynos4/gpio.h
View File

@ -77,8 +77,8 @@ struct Gpio::Reg : Attached_io_mem_dataspace, Mmio
}
};
Reg(addr_t base, size_t size)
: Attached_io_mem_dataspace(base, size),
Reg(Genode::Env &env, addr_t base, size_t size)
: Attached_io_mem_dataspace(env, base, size),
Mmio((addr_t)local_addr<Reg>()) { }
void set_direction(int gpio, bool input, Genode::off_t offset)

39
repos/os/src/drivers/gpio/spec/exynos4/main.cc
View File

@ -14,50 +14,51 @@
*/
/* Genode includes */
#include <base/attached_rom_dataspace.h>
#include <base/component.h>
#include <base/heap.h>
#include <base/log.h>
#include <base/sleep.h>
#include <cap_session/connection.h>
#include <gpio/component.h>
#include <gpio/config.h>
#include <os/server.h>
/* local includes */
#include <driver.h>
Gpio::Odroid_x2_driver& Gpio::Odroid_x2_driver::factory(Genode::Env &env)
{
static Odroid_x2_driver driver(env);
return driver;
}
struct Main
{
Server::Entrypoint &ep;
Genode::Env &env;
Genode::Sliced_heap sliced_heap;
Gpio::Odroid_x2_driver &driver;
Gpio::Root root;
Main(Server::Entrypoint &ep)
: ep(ep),
sliced_heap(Genode::env()->ram_session(), Genode::env()->rm_session()),
driver(Gpio::Odroid_x2_driver::factory(ep)),
root(&ep.rpc_ep(), &sliced_heap, driver)
Genode::Attached_rom_dataspace config_rom { env, "config" };
Main(Genode::Env &env)
: env(env),
sliced_heap(env.ram(), env.rm()),
driver(Gpio::Odroid_x2_driver::factory(env)),
root(&env.ep().rpc_ep(), &sliced_heap, driver)
{
using namespace Genode;
log("--- Odroid_x2 gpio driver ---");
Gpio::process_config(driver);
Gpio::process_config(config_rom.xml(), driver);
/*
* Announce service
*/
env()->parent()->announce(ep.manage(root));
env.parent().announce(env.ep().manage(root));
}
};
/************
** Server **
************/
namespace Server {
char const *name() { return "gpio_drv_ep"; }
size_t stack_size() { return 16*1024*sizeof(long); }
void construct(Entrypoint &ep) { static Main server(ep); }
}
void Component::construct(Genode::Env &env) { static Main main(env); }

2
repos/os/src/drivers/gpio/spec/exynos4/target.mk
View File

@ -1,7 +1,7 @@
TARGET = gpio_drv
REQUIRES = exynos4
SRC_CC = main.cc
LIBS = base config server
LIBS = base
INC_DIR += $(PRG_DIR)
vpath main.cc $(PRG_DIR)

53
repos/os/src/drivers/gpio/spec/imx53/driver.h
View File

@ -39,15 +39,6 @@ class Imx53_driver : public Gpio::Driver
};
struct Timer_delayer : Timer::Connection, Genode::Mmio::Delayer
{
/**
* Implementation of 'Delayer' interface
*/
void usleep(unsigned us) { Timer::Connection::usleep(us); }
} _delayer;
class Gpio_bank
{
public:
@ -70,10 +61,10 @@ class Imx53_driver : public Gpio::Driver
private:
Genode::Irq_connection _irq;
Genode::Signal_rpc_member<Irq_handler> _dispatcher;
Genode::Signal_handler<Irq_handler> _dispatcher;
Gpio_bank *_bank;
void _handle(unsigned)
void _handle()
{
_bank->handle_irq();
_irq.ack_irq();
@ -82,9 +73,9 @@ class Imx53_driver : public Gpio::Driver
public:
Irq_handler(Server::Entrypoint &ep,
Irq_handler(Genode::Env &env,
unsigned irq, Gpio_bank *bank)
: _irq(irq), _dispatcher(ep, *this, &Irq_handler::_handle),
: _irq(env, irq), _dispatcher(env.ep(), *this, &Irq_handler::_handle),
_bank(bank)
{
_irq.sigh(_dispatcher);
@ -100,11 +91,11 @@ class Imx53_driver : public Gpio::Driver
public:
Gpio_bank(Server::Entrypoint &ep, Genode::addr_t base,
Gpio_bank(Genode::Env &env, Genode::addr_t base,
Genode::size_t size, unsigned irq_low, unsigned irq_high)
: _reg(base, size),
_irqh_low(ep, irq_low, this),
_irqh_high(ep, irq_high, this) { }
: _reg(env, base, size),
_irqh_low(env, irq_low, this),
_irqh_high(env, irq_high, this) { }
Gpio_reg* regs() { return &_reg; }
@ -123,8 +114,6 @@ class Imx53_driver : public Gpio::Driver
_sig_cap[pin] = cap; }
};
Server::Entrypoint &_ep;
Gpio_bank _gpio_bank_0;
Gpio_bank _gpio_bank_1;
Gpio_bank _gpio_bank_2;
@ -158,22 +147,21 @@ class Imx53_driver : public Gpio::Driver
int _gpio_index(int gpio) { return gpio & 0x1f; }
Imx53_driver(Server::Entrypoint &ep)
Imx53_driver(Genode::Env &env)
:
_ep(ep),
_gpio_bank_0(_ep, Genode::Board_base::GPIO1_MMIO_BASE, Genode::Board_base::GPIO1_MMIO_SIZE,
_gpio_bank_0(env, Genode::Board_base::GPIO1_MMIO_BASE, Genode::Board_base::GPIO1_MMIO_SIZE,
Genode::Board_base::GPIO1_IRQL, Genode::Board_base::GPIO1_IRQH),
_gpio_bank_1(_ep, Genode::Board_base::GPIO2_MMIO_BASE, Genode::Board_base::GPIO2_MMIO_SIZE,
_gpio_bank_1(env, Genode::Board_base::GPIO2_MMIO_BASE, Genode::Board_base::GPIO2_MMIO_SIZE,
Genode::Board_base::GPIO2_IRQL, Genode::Board_base::GPIO2_IRQH),
_gpio_bank_2(_ep, Genode::Board_base::GPIO3_MMIO_BASE, Genode::Board_base::GPIO3_MMIO_SIZE,
_gpio_bank_2(env, Genode::Board_base::GPIO3_MMIO_BASE, Genode::Board_base::GPIO3_MMIO_SIZE,
Genode::Board_base::GPIO3_IRQL, Genode::Board_base::GPIO3_IRQH),
_gpio_bank_3(_ep, Genode::Board_base::GPIO4_MMIO_BASE, Genode::Board_base::GPIO4_MMIO_SIZE,
_gpio_bank_3(env, Genode::Board_base::GPIO4_MMIO_BASE, Genode::Board_base::GPIO4_MMIO_SIZE,
Genode::Board_base::GPIO4_IRQL, Genode::Board_base::GPIO4_IRQH),
_gpio_bank_4(_ep, Genode::Board_base::GPIO5_MMIO_BASE, Genode::Board_base::GPIO5_MMIO_SIZE,
_gpio_bank_4(env, Genode::Board_base::GPIO5_MMIO_BASE, Genode::Board_base::GPIO5_MMIO_SIZE,
Genode::Board_base::GPIO5_IRQL, Genode::Board_base::GPIO5_IRQH),
_gpio_bank_5(_ep, Genode::Board_base::GPIO6_MMIO_BASE, Genode::Board_base::GPIO6_MMIO_SIZE,
_gpio_bank_5(env, Genode::Board_base::GPIO6_MMIO_BASE, Genode::Board_base::GPIO6_MMIO_SIZE,
Genode::Board_base::GPIO6_IRQL, Genode::Board_base::GPIO6_IRQH),
_gpio_bank_6(_ep, Genode::Board_base::GPIO7_MMIO_BASE, Genode::Board_base::GPIO7_MMIO_SIZE,
_gpio_bank_6(env, Genode::Board_base::GPIO7_MMIO_BASE, Genode::Board_base::GPIO7_MMIO_SIZE,
Genode::Board_base::GPIO7_IRQL, Genode::Board_base::GPIO7_IRQH)
{
for (unsigned i = 0; i < MAX_BANKS; ++i) {
@ -189,7 +177,7 @@ class Imx53_driver : public Gpio::Driver
public:
static Imx53_driver &factory(Server::Entrypoint &ep);
static Imx53_driver &factory(Genode::Env &env);
/******************************
** Gpio::Driver interface **
@ -278,11 +266,4 @@ class Imx53_driver : public Gpio::Driver
bool gpio_valid(unsigned gpio) { return gpio < (MAX_PINS*MAX_BANKS); }
};
Imx53_driver &Imx53_driver::factory(Server::Entrypoint &ep)
{
static Imx53_driver driver(ep);
return driver;
}
#endif /* _DRIVERS__GPIO__SPEC__IMX53__DRIVER_H_ */

5
repos/os/src/drivers/gpio/spec/imx53/gpio.h
View File

@ -22,9 +22,10 @@
struct Gpio_reg : Genode::Attached_io_mem_dataspace, Genode::Mmio
{
Gpio_reg(Genode::addr_t const mmio_base,
Gpio_reg(Genode::Env &env,
Genode::addr_t const mmio_base,
Genode::size_t const mmio_size)
: Genode::Attached_io_mem_dataspace(mmio_base, mmio_size),
: Genode::Attached_io_mem_dataspace(env, mmio_base, mmio_size),
Genode::Mmio((Genode::addr_t)local_addr<void>()) { }
struct Data : Register_array<0x0, 32, 32, 1> {};

39
repos/os/src/drivers/gpio/spec/imx53/main.cc
View File

@ -15,51 +15,52 @@
*/
/* Genode includes */
#include <base/attached_rom_dataspace.h>
#include <base/component.h>
#include <base/log.h>
#include <base/heap.h>
#include <base/sleep.h>
#include <gpio/component.h>
#include <gpio/config.h>
#include <os/server.h>
/* local includes */
#include <driver.h>
Imx53_driver &Imx53_driver::factory(Genode::Env &env)
{
static Imx53_driver driver(env);
return driver;
}
struct Main
{
Server::Entrypoint &ep;
Genode::Env &env;
Genode::Sliced_heap sliced_heap;
Imx53_driver &driver;
Gpio::Root root;
Main(Server::Entrypoint &ep)
Genode::Attached_rom_dataspace config_rom { env, "config" };
Main(Genode::Env &env)
:
ep(ep),
sliced_heap(Genode::env()->ram_session(), Genode::env()->rm_session()),
driver(Imx53_driver::factory(ep)),
root(&ep.rpc_ep(), &sliced_heap, driver)
env(env),
sliced_heap(env.ram(), env.rm()),
driver(Imx53_driver::factory(env)),
root(&env.ep().rpc_ep(), &sliced_heap, driver)
{
using namespace Genode;
log("--- i.MX53 gpio driver ---");
Gpio::process_config(driver);
Gpio::process_config(config_rom.xml(), driver);
/*
* Announce service
*/
env()->parent()->announce(ep.manage(root));
env.parent().announce(env.ep().manage(root));
}
};
/************
** Server **
************/
namespace Server {
char const *name() { return "gpio_drv_ep"; }
size_t stack_size() { return 16*1024*sizeof(long); }
void construct(Entrypoint &ep) { static Main server(ep); }
}
void Component::construct(Genode::Env &env) { static Main main(env); }

2
repos/os/src/drivers/gpio/spec/imx53/target.mk
View File

@ -1,7 +1,7 @@
TARGET = gpio_drv
REQUIRES = imx53
SRC_CC = main.cc
LIBS = base config server
LIBS = base
INC_DIR += $(PRG_DIR)
vpath main.cc $(PRG_DIR)

45
repos/os/src/drivers/gpio/spec/omap4/driver.h
View File

@ -37,26 +37,17 @@ class Omap4_driver : public Gpio::Driver
};
struct Timer_delayer : Timer::Connection, Genode::Mmio::Delayer
{
/**
* Implementation of 'Delayer' interface
*/
void usleep(unsigned us) { Timer::Connection::usleep(us); }
} _delayer;
class Gpio_bank
{
private:
Gpio_reg _reg;
Genode::Irq_connection _irq;
Genode::Signal_rpc_member<Gpio_bank> _dispatcher;
Genode::Signal_handler<Gpio_bank> _dispatcher;
Genode::Signal_context_capability _sig_cap[MAX_PINS];
bool _irq_enabled[MAX_PINS];
void _handle(unsigned)
void _handle()
{
_reg.write<Gpio_reg::Irqstatus_0>(0xffffffff);
@ -74,11 +65,11 @@ class Omap4_driver : public Gpio::Driver
public:
Gpio_bank(Server::Entrypoint &ep,
Gpio_bank(Genode::Env &env,
Genode::addr_t base, Genode::size_t size,
unsigned irq)
: _reg(base, size), _irq(irq),
_dispatcher(ep, *this, &Gpio_bank::_handle)
: _reg(env, base, size), _irq(env, irq),
_dispatcher(env.ep(), *this, &Gpio_bank::_handle)
{
for (unsigned i = 0; i < MAX_PINS; i++)
_irq_enabled[i] = false;
@ -106,8 +97,6 @@ class Omap4_driver : public Gpio::Driver
_sig_cap[pin] = cap; }
};
Server::Entrypoint &_ep;
Gpio_bank _gpio_bank_0;
Gpio_bank _gpio_bank_1;
Gpio_bank _gpio_bank_2;
@ -138,26 +127,25 @@ class Omap4_driver : public Gpio::Driver
int _gpio_index(int gpio) { return gpio & 0x1f; }
Omap4_driver(Server::Entrypoint &ep)
Omap4_driver(Genode::Env &env)
:
_ep(ep),
_gpio_bank_0(_ep, Genode::Board_base::GPIO1_MMIO_BASE, Genode::Board_base::GPIO1_MMIO_SIZE,
_gpio_bank_0(env, Genode::Board_base::GPIO1_MMIO_BASE, Genode::Board_base::GPIO1_MMIO_SIZE,
Genode::Board_base::GPIO1_IRQ),
_gpio_bank_1(_ep, Genode::Board_base::GPIO2_MMIO_BASE, Genode::Board_base::GPIO2_MMIO_SIZE,
_gpio_bank_1(env, Genode::Board_base::GPIO2_MMIO_BASE, Genode::Board_base::GPIO2_MMIO_SIZE,
Genode::Board_base::GPIO2_IRQ),
_gpio_bank_2(_ep, Genode::Board_base::GPIO3_MMIO_BASE, Genode::Board_base::GPIO3_MMIO_SIZE,
_gpio_bank_2(env, Genode::Board_base::GPIO3_MMIO_BASE, Genode::Board_base::GPIO3_MMIO_SIZE,
Genode::Board_base::GPIO3_IRQ),
_gpio_bank_3(_ep, Genode::Board_base::GPIO4_MMIO_BASE, Genode::Board_base::GPIO4_MMIO_SIZE,
_gpio_bank_3(env, Genode::Board_base::GPIO4_MMIO_BASE, Genode::Board_base::GPIO4_MMIO_SIZE,
Genode::Board_base::GPIO4_IRQ),
_gpio_bank_4(_ep, Genode::Board_base::GPIO5_MMIO_BASE, Genode::Board_base::GPIO5_MMIO_SIZE,
_gpio_bank_4(env, Genode::Board_base::GPIO5_MMIO_BASE, Genode::Board_base::GPIO5_MMIO_SIZE,
Genode::Board_base::GPIO5_IRQ),
_gpio_bank_5(_ep, Genode::Board_base::GPIO6_MMIO_BASE, Genode::Board_base::GPIO6_MMIO_SIZE,
_gpio_bank_5(env, Genode::Board_base::GPIO6_MMIO_BASE, Genode::Board_base::GPIO6_MMIO_SIZE,
Genode::Board_base::GPIO6_IRQ)
{ }
public:
static Omap4_driver& factory(Server::Entrypoint &ep);
static Omap4_driver& factory(Genode::Env &env);
/******************************
@ -268,11 +256,4 @@ class Omap4_driver : public Gpio::Driver
bool gpio_valid(unsigned gpio) { return gpio < (MAX_PINS*MAX_BANKS); }
};
Omap4_driver& Omap4_driver::factory(Server::Entrypoint &ep)
{
static Omap4_driver driver(ep);
return driver;
}
#endif /* _DRIVERS__GPIO__SPEC__OMAP4__DRIVER_H_ */

5
repos/os/src/drivers/gpio/spec/omap4/gpio.h
View File

@ -22,9 +22,10 @@
struct Gpio_reg : Genode::Attached_io_mem_dataspace, Genode::Mmio
{
Gpio_reg(Genode::addr_t const mmio_base,
Gpio_reg(Genode::Env &env,
Genode::addr_t const mmio_base,
Genode::size_t const mmio_size)
: Genode::Attached_io_mem_dataspace(mmio_base, mmio_size),
: Genode::Attached_io_mem_dataspace(env, mmio_base, mmio_size),
Genode::Mmio((Genode::addr_t)local_addr<void>()) { }
struct Oe : Register_array<0x134, 32, 32, 1> {};

37
repos/os/src/drivers/gpio/spec/omap4/main.cc
View File

@ -14,10 +14,10 @@
*/
/* Genode includes */
#include <base/attached_rom_dataspace.h>
#include <base/component.h>
#include <base/log.h>
#include <base/heap.h>
#include <base/sleep.h>
#include <cap_session/connection.h>
#include <gpio/component.h>
#include <gpio/config.h>
#include <os/server.h>
@ -25,40 +25,41 @@
/* local includes */
#include <driver.h>
Omap4_driver& Omap4_driver::factory(Genode::Env &env)
{
static Omap4_driver driver(env);
return driver;
}
struct Main
{
Server::Entrypoint &ep;
Genode::Env &env;
Genode::Sliced_heap sliced_heap;
Omap4_driver &driver;
Gpio::Root root;
Main(Server::Entrypoint &ep)
Genode::Attached_rom_dataspace config_rom { env, "config" };
Main(Genode::Env &env)
:
ep(ep),
sliced_heap(Genode::env()->ram_session(), Genode::env()->rm_session()),
driver(Omap4_driver::factory(ep)),
root(&ep.rpc_ep(), &sliced_heap, driver)
env(env),
sliced_heap(env.ram(), env.rm()),
driver(Omap4_driver::factory(env)),
root(&env.ep().rpc_ep(), &sliced_heap, driver)
{
using namespace Genode;
log("--- omap4 gpio driver ---");
Gpio::process_config(driver);
Gpio::process_config(config_rom.xml(), driver);
/*
* Announce service
*/
env()->parent()->announce(ep.manage(root));
env.parent().announce(env.ep().manage(root));
}
};
/************
** Server **
************/
namespace Server {
char const *name() { return "gpio_drv_ep"; }
size_t stack_size() { return 16*1024*sizeof(long); }
void construct(Entrypoint &ep) { static Main server(ep); }
}
void Component::construct(Genode::Env &env) { static Main main(env); }

2
repos/os/src/drivers/gpio/spec/omap4/target.mk
View File

@ -1,7 +1,7 @@
TARGET = gpio_drv
REQUIRES = omap4
SRC_CC = main.cc
LIBS = base config server
LIBS = base
INC_DIR += $(PRG_DIR)
vpath main.cc $(PRG_DIR)

23
repos/os/src/drivers/gpio/spec/rpi/driver.h
View File

@ -37,15 +37,14 @@ class Gpio::Rpi_driver : public Driver
enum { MAX_PINS = 54 };
Server::Entrypoint &_ep;
Reg _reg;
Genode::Irq_connection _irq;
Genode::Signal_rpc_member<Rpi_driver> _dispatcher;
Genode::Signal_handler<Rpi_driver> _dispatcher;
Genode::Signal_context_capability _sig_cap[MAX_PINS];
bool _irq_enabled[MAX_PINS];
bool _async;
void _handle(unsigned)
void _handle()
{
_reg.for_each_gpio_status([&] (unsigned i, bool s) {
if (!s || !_irq_enabled[i] || !_sig_cap[i].valid()) { return; }
@ -53,13 +52,12 @@ class Gpio::Rpi_driver : public Driver
});
}
Rpi_driver(Server::Entrypoint &ep)
Rpi_driver(Genode::Env &env)
:
_ep(ep),
_reg(Genode::Board_base::GPIO_CONTROLLER_BASE,
_reg(env, Genode::Board_base::GPIO_CONTROLLER_BASE,
0, Genode::Board_base::GPIO_CONTROLLER_SIZE),
_irq(IRQ),
_dispatcher(ep,*this,&Rpi_driver::_handle),
_irq(env, IRQ),
_dispatcher(env.ep(), *this, &Rpi_driver::_handle),
_async(false)
{
_irq.sigh(_dispatcher);
@ -81,7 +79,7 @@ class Gpio::Rpi_driver : public Driver
_reg.set_gpio_function(gpio, function);
}
static Rpi_driver& factory(Server::Entrypoint &ep);
static Rpi_driver& factory(Genode::Env &env);
/******************************
@ -208,11 +206,4 @@ class Gpio::Rpi_driver : public Driver
}
};
Gpio::Rpi_driver& Gpio::Rpi_driver::factory(Server::Entrypoint &ep)
{
static Rpi_driver driver(ep);
return driver;
}
#endif /* _DRIVERS__GPIO__SPEC__RPI__DRIVER_H_ */

2
repos/os/src/drivers/gpio/spec/rpi/foc/target.mk
View File

@ -1,5 +1,5 @@
TARGET = foc_gpio_drv
REQUIRES = rpi
SRC_CC += ../main.cc
LIBS += base config server
LIBS += base
INC_DIR += $(PRG_DIR) $(PRG_DIR)/..

10
repos/os/src/drivers/gpio/spec/rpi/gpio.h
View File

@ -113,6 +113,8 @@ class Gpio::Reg : Attached_io_mem_dataspace, Mmio
struct Timer_delayer : Timer::Connection, Mmio::Delayer
{
Timer_delayer(Genode::Env &env) : Timer::Connection(env) { }
/**
* Implementation of 'Delayer' interface
*/
@ -134,10 +136,12 @@ class Gpio::Reg : Attached_io_mem_dataspace, Mmio
public:
Reg(addr_t base, off_t offset, size_t size)
Reg(Genode::Env &env,
addr_t base, off_t offset, size_t size)
:
Attached_io_mem_dataspace(base, size),
Mmio((addr_t)local_addr<Reg>() + offset)
Attached_io_mem_dataspace(env, base, size),
Mmio((addr_t)local_addr<Reg>() + offset),
_delayer(env)
{ }
enum Function {

2
repos/os/src/drivers/gpio/spec/rpi/hw/target.mk
View File

@ -1,5 +1,5 @@
TARGET = hw_gpio_drv
REQUIRES = rpi
SRC_CC += ../main.cc
LIBS += base config server
LIBS = base
INC_DIR += $(PRG_DIR) $(PRG_DIR)/..

43
repos/os/src/drivers/gpio/spec/rpi/main.cc
View File

@ -14,10 +14,10 @@
*/
/* Genode includes */
#include <base/attached_rom_dataspace.h>
#include <base/component.h>
#include <base/log.h>
#include <base/heap.h>
#include <base/sleep.h>
#include <cap_session/connection.h>
#include <gpio/component.h>
#include <gpio/config.h>
#include <os/server.h>
@ -25,19 +25,29 @@
/* local includes */
#include "driver.h"
Gpio::Rpi_driver& Gpio::Rpi_driver::factory(Genode::Env &env)
{
static Rpi_driver driver(env);
return driver;
}
struct Main
{
Server::Entrypoint &ep;
Genode::Env &env;
Genode::Sliced_heap sliced_heap;
Gpio::Rpi_driver &driver;
Gpio::Root root;
Main(Server::Entrypoint &ep)
Genode::Attached_rom_dataspace config_rom { env, "config" };
Main(Genode::Env &env)
:
ep(ep),
sliced_heap(Genode::env()->ram_session(), Genode::env()->rm_session()),
driver(Gpio::Rpi_driver::factory(ep)),
root(&ep.rpc_ep(), &sliced_heap, driver)
env(env),
sliced_heap(env.ram(), env.rm()),
driver(Gpio::Rpi_driver::factory(env)),
root(&env.ep().rpc_ep(), &sliced_heap, driver)
{
using namespace Genode;
log("--- Raspberry Pi GPIO driver ---");
@ -47,20 +57,20 @@ struct Main
*/
unsigned int async = 0;
try {
config()->xml_node().attribute("async_events").value(&async);
config_rom.xml().attribute("async_events").value(&async);
} catch (...) { }
driver.set_async_events(async>0);
/*
* Check for common GPIO configuration
*/
Gpio::process_config(driver);
Gpio::process_config(config_rom.xml(), driver);
/*
* Check configuration for specific function
*/
try {
Xml_node gpio_node = config()->xml_node().sub_node("gpio");
Xml_node gpio_node = config_rom.xml().sub_node("gpio");
for (;; gpio_node = gpio_node.next("gpio")) {
unsigned num = 0;
@ -89,16 +99,9 @@ struct Main
/*
* Announce service
*/
env()->parent()->announce(ep.manage(root));
env.parent().announce(env.ep().manage(root));
}
};
/************
** Server **
************/
namespace Server {
char const *name() { return "gpio_drv_ep"; }
size_t stack_size() { return 16*1024*sizeof(long); }
void construct(Entrypoint &ep) { static Main server(ep); }
}
void Component::construct(Genode::Env &env) { static Main main(env); }