mirror of
https://github.com/genodelabs/genode.git
synced 2024-12-20 06:07:59 +00:00
usb: transition to the new base API
* remove all 'Genode::env()' calls * use attached roms to read configuration * use compoenent framework * remove all PDBG, PINF, PWRN macros Issue #1987 Fixes #2019
This commit is contained in:
Sebastian Sumpf
Christian Helmuth
parent
58ef6e3695
commit
d48219138c
@ -38,7 +38,7 @@ MOD_SUFFIX =
|
||||
CC_OPT += -DMOD_SUFFIX=$(MOD_SUFFIX)
|
||||
|
||||
# lx_kit
|
||||
SRC_CC += printf.cc work.cc timer.cc scheduler.cc irq.cc malloc.cc
|
||||
SRC_CC += printf.cc work.cc timer.cc scheduler.cc irq.cc malloc.cc env.cc
|
||||
|
||||
# common lib
|
||||
SRC_C += lib/int_sqrt.c
|
||||
|
||||
@ -659,11 +659,6 @@ unsigned int jiffies_to_usecs(const unsigned long j)
|
||||
return -1;
|
||||
}
|
||||
|
||||
void kmem_cache_destroy(struct kmem_cache *cache)
|
||||
{
|
||||
TRACE_AND_STOP;
|
||||
}
|
||||
|
||||
int kobject_uevent_env(struct kobject *kobj, enum kobject_action action, char *envp[])
|
||||
{
|
||||
TRACE_AND_STOP;
|
||||
|
||||
@ -11,12 +11,13 @@
|
||||
* under the terms of the GNU General Public License version 2.
|
||||
*/
|
||||
|
||||
#include <os/server.h>
|
||||
#include <base/component.h>
|
||||
|
||||
extern void start_usb_driver(Server::Entrypoint &e);
|
||||
extern void start_usb_driver(Genode::Env &env);
|
||||
|
||||
namespace Server {
|
||||
char const *name() { return "usb_drv_ep"; }
|
||||
size_t stack_size() { return 4*1024*sizeof(long); }
|
||||
void construct(Entrypoint &e) { start_usb_driver(e); }
|
||||
}
|
||||
|
||||
Genode::size_t Component::stack_size() {
|
||||
return 4*1024*sizeof(long); }
|
||||
|
||||
|
||||
void Component::construct(Genode::Env &env) { start_usb_driver(env); }
|
||||
|
||||
@ -1,3 +1,3 @@
|
||||
TARGET = usb_drv
|
||||
SRC_CC = main.cc
|
||||
LIBS = base usb server
|
||||
LIBS = base usb
|
||||
|
||||
@ -307,7 +307,6 @@ DUMMY(-1, ipv4_is_local_multicast)
|
||||
DUMMY(-1, irqs_disabled)
|
||||
DUMMY(-1, is_vlan_dev)
|
||||
DUMMY(-1, kernel_sendmsg)
|
||||
DUMMY(-1, kmem_cache_destroy)
|
||||
DUMMY(-1, kobject_put)
|
||||
DUMMY(-1, kobject_uevent)
|
||||
DUMMY(-1, krealloc)
|
||||
|
||||
@ -16,14 +16,18 @@
|
||||
#ifndef _PLATFORM_H_
|
||||
#define _PLATFORM_H_
|
||||
|
||||
#include <base/printf.h>
|
||||
#include <os/config.h>
|
||||
#include <base/log.h>
|
||||
#include <util/xml_node.h>
|
||||
#include <os/signal_rpc_dispatcher.h>
|
||||
#include <irq_session/capability.h>
|
||||
|
||||
#include <lx_kit/env.h>
|
||||
|
||||
struct Services
|
||||
{
|
||||
|
||||
Genode::Env &env;
|
||||
|
||||
/* USB profiles */
|
||||
bool hid = false;
|
||||
bool stor = false;
|
||||
@ -46,12 +50,13 @@ struct Services
|
||||
/* report generation */
|
||||
bool raw_report_device_list = false;
|
||||
|
||||
Services()
|
||||
Services(Genode::Env &env) : env(env)
|
||||
{
|
||||
using namespace Genode;
|
||||
|
||||
Genode::Xml_node config_node = Lx_kit::env().config_rom().xml();
|
||||
try {
|
||||
Genode::Xml_node node_hid = config()->xml_node().sub_node("hid");
|
||||
Genode::Xml_node node_hid = config_node.sub_node("hid");
|
||||
hid = true;
|
||||
|
||||
try {
|
||||
@ -61,28 +66,28 @@ struct Services
|
||||
multitouch = node_screen.attribute_value("multitouch", false);
|
||||
} catch (...) {
|
||||
screen_width = screen_height = 0;
|
||||
PDBG("Could not read screen resolution in config node");
|
||||
log("Could not read screen resolution in config node");
|
||||
}
|
||||
} catch (Xml_node::Nonexistent_sub_node) {
|
||||
PDBG("No <hid> config node found - not starting the USB HID (Input) service");
|
||||
log("No <hid> config node found - not starting the USB HID (Input) service");
|
||||
}
|
||||
|
||||
try {
|
||||
config()->xml_node().sub_node("storage");
|
||||
config_node.sub_node("storage");
|
||||
stor = true;
|
||||
} catch (Xml_node::Nonexistent_sub_node) {
|
||||
PDBG("No <storage> config node found - not starting the USB Storage (Block) service");
|
||||
log("No <storage> config node found - not starting the USB Storage (Block) service");
|
||||
}
|
||||
|
||||
try {
|
||||
config()->xml_node().sub_node("nic");
|
||||
config_node.sub_node("nic");
|
||||
nic = true;
|
||||
} catch (Xml_node::Nonexistent_sub_node) {
|
||||
PDBG("No <nic> config node found - not starting the USB Nic (Network) service");
|
||||
log("No <nic> config node found - not starting the USB Nic (Network) service");
|
||||
}
|
||||
|
||||
try {
|
||||
Genode::Xml_node node_raw = config()->xml_node().sub_node("raw");
|
||||
Genode::Xml_node node_raw = config_node.sub_node("raw");
|
||||
raw = true;
|
||||
|
||||
try {
|
||||
@ -90,26 +95,26 @@ struct Services
|
||||
raw_report_device_list = node_report.attribute_value("devices", false);
|
||||
} catch (...) { }
|
||||
} catch (Xml_node::Nonexistent_sub_node) {
|
||||
PDBG("No <raw> config node found - not starting external USB service");
|
||||
log("No <raw> config node found - not starting external USB service");
|
||||
}
|
||||
|
||||
if (config()->xml_node().attribute_value("uhci", false)) {
|
||||
if (config_node.attribute_value("uhci", false)) {
|
||||
uhci = true;
|
||||
PINF("Enabled UHCI (USB 1.0/1.1) support");
|
||||
log("Enabled UHCI (USB 1.0/1.1) support");
|
||||
}
|
||||
|
||||
if (config()->xml_node().attribute_value("ehci", false)) {
|
||||
if (config_node.attribute_value("ehci", false)) {
|
||||
ehci = true;
|
||||
PINF("Enabled EHCI (USB 2.0) support");
|
||||
log("Enabled EHCI (USB 2.0) support");
|
||||
}
|
||||
|
||||
if (config()->xml_node().attribute_value("xhci", false)) {
|
||||
if (config_node.attribute_value("xhci", false)) {
|
||||
xhci = true;
|
||||
PINF("Enabled XHCI (USB 3.0) support");
|
||||
log("Enabled XHCI (USB 3.0) support");
|
||||
}
|
||||
|
||||
if (!(uhci | ehci | xhci))
|
||||
PWRN("Warning: No USB controllers enabled.\n"
|
||||
warning("Warning: No USB controllers enabled.\n"
|
||||
"Use <config (u/e/x)hci=\"yes\"> in your 'usb_drv' configuration");
|
||||
}
|
||||
};
|
||||
|
||||
@ -14,10 +14,9 @@
|
||||
#ifndef _SIGNAL_H_
|
||||
#define _SIGNAL_H_
|
||||
|
||||
#include <base/env.h>
|
||||
#include <base/printf.h>
|
||||
#include <platform.h>
|
||||
|
||||
#include <base/signal.h>
|
||||
#include <os/server.h>
|
||||
|
||||
static bool const verbose = false;
|
||||
|
||||
@ -28,32 +27,34 @@ class Signal_helper
|
||||
{
|
||||
private:
|
||||
|
||||
Server::Entrypoint &_ep;
|
||||
Genode::Env &_env;
|
||||
Genode::Signal_transmitter _sender;
|
||||
|
||||
public:
|
||||
|
||||
Signal_helper(Server::Entrypoint &ep) : _ep(ep) { }
|
||||
Signal_helper(Genode::Env &env) : _env(env) { }
|
||||
|
||||
Server::Entrypoint &ep() { return _ep; }
|
||||
Genode::Entrypoint &ep() { return _env.ep(); }
|
||||
Genode::Signal_transmitter &sender() { return _sender; }
|
||||
Genode::Parent &parent() { return _env.parent(); }
|
||||
Genode::Env &env() { return _env; }
|
||||
};
|
||||
|
||||
|
||||
|
||||
namespace Storage
|
||||
{
|
||||
void init(Server::Entrypoint &ep);
|
||||
void init(Genode::Env &env);
|
||||
}
|
||||
|
||||
namespace Nic
|
||||
{
|
||||
void init(Server::Entrypoint &ep);
|
||||
void init(Genode::Env &env);
|
||||
}
|
||||
|
||||
namespace Raw
|
||||
{
|
||||
void init(Server::Entrypoint &ep, bool report_device_list);
|
||||
void init(Genode::Env &env, bool report_device_list);
|
||||
}
|
||||
|
||||
|
||||
#endif /* _SIGNAL_H_ */
|
||||
|
||||
@ -17,6 +17,12 @@
|
||||
#ifndef _ARM__PLATFORM_DEVICE__PLATFORM_DEVICE_H_
|
||||
#define _ARM__PLATFORM_DEVICE__PLATFORM_DEVICE_H_
|
||||
|
||||
|
||||
#include <lx_emul/extern_c_begin.h>
|
||||
#include <lx_emul/printf.h>
|
||||
#include <lx_emul/extern_c_end.h>
|
||||
|
||||
#include <lx_kit/malloc.h>
|
||||
#include <platform_device/device.h>
|
||||
|
||||
#include <irq_session/connection.h>
|
||||
@ -46,7 +52,7 @@ struct Platform::Device : Platform::Abstract_device, Genode::List<Device>::Eleme
|
||||
Genode::Cache_attribute,
|
||||
Genode::addr_t, Genode::size_t) override
|
||||
{
|
||||
PERR("%s: not implemented", __PRETTY_FUNCTION__);
|
||||
lx_printf("%s: not implemented\n", __PRETTY_FUNCTION__);
|
||||
return Genode::Io_mem_session_capability();
|
||||
}
|
||||
|
||||
@ -63,7 +69,7 @@ struct Platform::Device : Platform::Abstract_device, Genode::List<Device>::Eleme
|
||||
if (d->irq_num == irq_num)
|
||||
return *d;
|
||||
|
||||
d = new (Genode::env()->heap()) Device(irq_num);
|
||||
d = new (Lx::Malloc::mem()) Device(irq_num);
|
||||
list().insert(d);
|
||||
|
||||
return *d;
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#ifndef _USB_NIC_COMPONENT_H_
|
||||
#define _USB_NIC_COMPONENT_H_
|
||||
|
||||
#include <base/log.h>
|
||||
#include <nic/component.h>
|
||||
#include <root/component.h>
|
||||
|
||||
@ -148,7 +149,7 @@ class Usb_nic::Session_component : public Nic::Session_component
|
||||
|
||||
Genode::Packet_descriptor packet = _tx.sink()->get_packet();
|
||||
if (!packet.size()) {
|
||||
PWRN("Invalid tx packet");
|
||||
Genode::warning("Invalid tx packet");
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -178,7 +179,7 @@ class Usb_nic::Session_component : public Nic::Session_component
|
||||
Genode::size_t const rx_buf_size,
|
||||
Genode::Allocator &rx_block_md_alloc,
|
||||
Genode::Ram_session &ram_session,
|
||||
Server::Entrypoint &ep,
|
||||
Genode::Entrypoint &ep,
|
||||
Device *device)
|
||||
: Nic::Session_component(tx_buf_size, rx_buf_size, rx_block_md_alloc, ram_session, ep),
|
||||
_device(device)
|
||||
@ -222,7 +223,7 @@ class Root : public Root_component
|
||||
{
|
||||
private:
|
||||
|
||||
Server::Entrypoint &_ep;
|
||||
Genode::Env &_env;
|
||||
Usb_nic::Device *_device;
|
||||
|
||||
protected:
|
||||
@ -246,24 +247,24 @@ class Root : public Root_component
|
||||
*/
|
||||
if (tx_buf_size + rx_buf_size < tx_buf_size ||
|
||||
tx_buf_size + rx_buf_size > ram_quota - session_size) {
|
||||
PERR("insufficient 'ram_quota', got %zd, need %zd",
|
||||
ram_quota, tx_buf_size + rx_buf_size + session_size);
|
||||
Genode::error("insufficient 'ram_quota', got ", ram_quota, " need %zd",
|
||||
tx_buf_size + rx_buf_size + session_size);
|
||||
throw Genode::Root::Quota_exceeded();
|
||||
}
|
||||
|
||||
return new (Root::md_alloc())
|
||||
Usb_nic::Session_component(tx_buf_size, rx_buf_size,
|
||||
*env()->heap(),
|
||||
*env()->ram_session(),
|
||||
_ep, _device);
|
||||
Lx::Malloc::mem(),
|
||||
_env.ram(),
|
||||
_env.ep(), _device);
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
Root(Server::Entrypoint &ep, Genode::Allocator &md_alloc,
|
||||
Root(Genode::Env &env, Genode::Allocator &md_alloc,
|
||||
Usb_nic::Device *device)
|
||||
: Root_component(&ep.rpc_ep(), &md_alloc),
|
||||
_ep(ep), _device(device)
|
||||
: Root_component(&env.ep().rpc_ep(), &md_alloc),
|
||||
_env(env), _device(device)
|
||||
{ }
|
||||
};
|
||||
|
||||
|
||||
@ -13,7 +13,6 @@
|
||||
* under the terms of the GNU General Public License version 2.
|
||||
*/
|
||||
|
||||
#include <base/printf.h>
|
||||
#include <base/rpc_server.h>
|
||||
#include <input/root.h>
|
||||
#include <os/ring_buffer.h>
|
||||
@ -77,8 +76,9 @@ void start_input_service(void *ep_ptr, void * service_ptr)
|
||||
{
|
||||
Rpc_entrypoint *ep = static_cast<Rpc_entrypoint *>(ep_ptr);
|
||||
Services *service = static_cast<Services *>(service_ptr);
|
||||
Env &env = service->env;
|
||||
|
||||
env()->parent()->announce(ep->manage(&input_root(ep)));
|
||||
env.parent().announce(ep->manage(&input_root(ep)));
|
||||
|
||||
genode_input_register(input_callback, service->screen_width,
|
||||
service->screen_height, service->multitouch);
|
||||
|
||||
@ -82,24 +82,20 @@ void dma_free(void *ptr)
|
||||
|
||||
void *vzalloc(unsigned long size)
|
||||
{
|
||||
size_t real_size = size + sizeof(size_t);
|
||||
size_t *addr;
|
||||
try { addr = (size_t *)Genode::env()->heap()->alloc(real_size); }
|
||||
try { addr = (size_t *)Lx::Malloc::mem().alloc_large(size); }
|
||||
catch (...) { return 0; }
|
||||
|
||||
*addr = real_size;
|
||||
memset(addr + 1, 0, size);
|
||||
memset(addr, 0, size);
|
||||
|
||||
return addr + 1;
|
||||
return addr;
|
||||
}
|
||||
|
||||
|
||||
void vfree(void *addr)
|
||||
{
|
||||
if (!addr) return;
|
||||
|
||||
size_t size = *(((size_t *)addr) - 1);
|
||||
Genode::env()->heap()->free(const_cast<void *>(addr), size);
|
||||
Lx::Malloc::mem().free_large(addr);
|
||||
}
|
||||
|
||||
|
||||
@ -266,17 +262,13 @@ int ilog2(u32 n) { return Genode::log2(n); }
|
||||
** linux/slab.h **
|
||||
********************/
|
||||
|
||||
void kmem_cache_destroy(struct kmem_cache *cache)
|
||||
{
|
||||
destroy(Genode::env()->heap(), cache);
|
||||
}
|
||||
|
||||
|
||||
void *kmem_cache_zalloc(struct kmem_cache *cache, gfp_t flags)
|
||||
{
|
||||
void *ret;
|
||||
ret = kmem_cache_alloc(cache, flags);
|
||||
memset(ret, 0, cache->size());
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -361,7 +353,7 @@ class Driver : public Genode::List<Driver>::Element
|
||||
int driver_register(struct device_driver *drv)
|
||||
{
|
||||
lx_log(DEBUG_DRIVER, "%s at %p", drv->name, drv);
|
||||
new (Genode::env()->heap()) Driver(drv);
|
||||
new (Lx::Malloc::mem()) Driver(drv);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -438,7 +430,7 @@ long find_next_zero_bit_le(const void *addr,
|
||||
static unsigned cnt = 0;
|
||||
unsigned long max_size = sizeof(long) * 8;
|
||||
if (offset >= max_size) {
|
||||
PWRN("Offset greater max size");
|
||||
Genode::warning("Offset greater max size");
|
||||
return offset + size;
|
||||
}
|
||||
|
||||
@ -446,7 +438,7 @@ long find_next_zero_bit_le(const void *addr,
|
||||
if (!(*(unsigned long*)addr & (1L << offset)))
|
||||
return offset;
|
||||
|
||||
lx_log(DEBUG_TRACE, "No zero bit findable %u", cnt++);
|
||||
Genode::warning("No zero bit findable");
|
||||
|
||||
return offset + size;
|
||||
}
|
||||
@ -551,7 +543,7 @@ struct dma_pool *dma_pool_create(const char *name, struct device *d, size_t size
|
||||
if (align & (align - 1))
|
||||
return 0;
|
||||
|
||||
dma_pool *pool = new(Genode::env()->heap()) dma_pool;
|
||||
dma_pool *pool = new(Lx::Malloc::mem()) dma_pool;
|
||||
pool->align = Genode::log2((int)align);
|
||||
pool->size = size;
|
||||
return pool;
|
||||
@ -561,7 +553,7 @@ struct dma_pool *dma_pool_create(const char *name, struct device *d, size_t size
|
||||
void dma_pool_destroy(struct dma_pool *d)
|
||||
{
|
||||
lx_log(DEBUG_DMA, "close");
|
||||
destroy(Genode::env()->heap(), d);
|
||||
destroy(Lx::Malloc::mem(), d);
|
||||
}
|
||||
|
||||
|
||||
@ -615,7 +607,7 @@ dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
|
||||
dma_addr_t phys = (dma_addr_t)Lx::Malloc::dma().phys_addr(ptr);
|
||||
|
||||
if (phys == ~0UL)
|
||||
PERR("translation virt->phys %p->%lx failed, return ip %p", ptr, phys,
|
||||
Genode::error("translation virt->phys ", ptr, "->", Genode::Hex(phys), "failed, return ip ",
|
||||
__builtin_return_address(0));
|
||||
|
||||
lx_log(DEBUG_DMA, "virt: %p phys: %lx", ptr, phys);
|
||||
@ -649,7 +641,7 @@ struct task_struct *kthread_run(int (*fn)(void *), void *arg, const char *n, ...
|
||||
*/
|
||||
lx_log(DEBUG_THREAD, "Run %s", n);
|
||||
|
||||
new (Genode::env()->heap()) Lx::Task((void (*)(void *))fn, arg, n,
|
||||
new (Lx::Malloc::mem()) Lx::Task((void (*)(void *))fn, arg, n,
|
||||
Lx::Task::PRIORITY_2,
|
||||
Lx::scheduler());
|
||||
return 0;
|
||||
@ -728,7 +720,7 @@ int smp_call_function_single(int cpu, smp_call_func_t func, void *info,
|
||||
|
||||
struct net_device *alloc_etherdev(int sizeof_priv)
|
||||
{
|
||||
net_device *dev = new (Genode::env()->heap()) net_device();
|
||||
net_device *dev = new (Lx::Malloc::mem()) net_device();
|
||||
|
||||
dev->mtu = 1500;
|
||||
dev->hard_header_len = 0;
|
||||
@ -1009,7 +1001,7 @@ void tasklet_hi_schedule(struct tasklet_struct *tasklet)
|
||||
struct workqueue_struct *create_singlethread_workqueue(char const *name)
|
||||
{
|
||||
workqueue_struct *wq = (workqueue_struct *)kzalloc(sizeof(workqueue_struct), 0);
|
||||
Lx::Work *work = Lx::Work::alloc_work_queue(Genode::env()->heap(), name);
|
||||
Lx::Work *work = Lx::Work::alloc_work_queue(&Lx::Malloc::mem(), name);
|
||||
wq->task = (void *)work;
|
||||
|
||||
return wq;
|
||||
|
||||
@ -16,17 +16,17 @@
|
||||
|
||||
|
||||
/* Genode */
|
||||
#include <base/printf.h>
|
||||
#include <base/sleep.h>
|
||||
#include <os/server.h>
|
||||
#include <nic_session/nic_session.h>
|
||||
|
||||
/* Local */
|
||||
#include <platform.h>
|
||||
#include <signal.h>
|
||||
#include <lx_emul.h>
|
||||
|
||||
#include <lx_kit/env.h>
|
||||
#include <lx_kit/irq.h>
|
||||
#include <lx_kit/malloc.h>
|
||||
#include <lx_kit/scheduler.h>
|
||||
#include <lx_kit/timer.h>
|
||||
#include <lx_kit/work.h>
|
||||
@ -53,7 +53,7 @@ struct workqueue_struct *system_power_efficient_wq;
|
||||
struct workqueue_struct *system_wq;
|
||||
struct workqueue_struct *tasklet_wq;
|
||||
|
||||
void breakpoint() { PDBG("BREAK"); }
|
||||
void breakpoint() { Genode::log("BREAK"); }
|
||||
|
||||
extern "C" int stdout_write(const char *);
|
||||
|
||||
@ -103,25 +103,26 @@ static void run_linux(void *s)
|
||||
}
|
||||
|
||||
|
||||
void start_usb_driver(Server::Entrypoint &ep)
|
||||
void start_usb_driver(Genode::Env &env)
|
||||
{
|
||||
static Services services;
|
||||
/* initialize USB env */
|
||||
Lx_kit::construct_env(env);
|
||||
static Services services(env);
|
||||
|
||||
if (services.hid)
|
||||
start_input_service(&ep.rpc_ep(), &services);
|
||||
start_input_service(&env.ep().rpc_ep(), &services);
|
||||
|
||||
Storage::init(ep);
|
||||
Nic::init(ep);
|
||||
Storage::init(env);
|
||||
Nic::init(env);
|
||||
|
||||
if (services.raw)
|
||||
Raw::init(ep, services.raw_report_device_list);
|
||||
Raw::init(env, services.raw_report_device_list);
|
||||
|
||||
Lx::Scheduler &sched = Lx::scheduler();
|
||||
Lx::Timer &timer = Lx::timer(&ep, &jiffies);
|
||||
|
||||
Lx::Irq::irq(&ep, Genode::env()->heap());
|
||||
Lx::Work::work_queue(Genode::env()->heap());
|
||||
Lx::Timer &timer = Lx::timer(&env.ep(), &jiffies);
|
||||
|
||||
Lx::Irq::irq(&env.ep(), &Lx_kit::env().heap());
|
||||
Lx::Work::work_queue(&Lx_kit::env().heap());
|
||||
|
||||
static Lx::Task linux(run_linux, &services, "linux", Lx::Task::PRIORITY_0,
|
||||
Lx::scheduler());
|
||||
|
||||
@ -17,7 +17,6 @@
|
||||
#include <cap_session/connection.h>
|
||||
#include <nic/xml_node.h>
|
||||
#include <util/xml_node.h>
|
||||
#include <os/config.h>
|
||||
|
||||
#include <lx_emul.h>
|
||||
#include <lx_emul/extern_c_begin.h>
|
||||
@ -25,6 +24,9 @@
|
||||
#include <linux/usb/usbnet.h>
|
||||
#include <lx_emul/extern_c_end.h>
|
||||
|
||||
#include <lx_kit/env.h>
|
||||
#include <lx_kit/malloc.h>
|
||||
|
||||
#include <usb_nic_component.h>
|
||||
#include "signal.h"
|
||||
|
||||
@ -176,7 +178,7 @@ class Nic_device : public Usb_nic::Device
|
||||
* Add device
|
||||
*/
|
||||
static Nic_device *add(struct net_device *ndev) {
|
||||
return new (Genode::env()->heap()) Nic_device(ndev); }
|
||||
return new (Lx::Malloc::mem()) Nic_device(ndev); }
|
||||
|
||||
/**
|
||||
* Report link state
|
||||
@ -244,7 +246,7 @@ class Nic_device : public Usb_nic::Device
|
||||
_ndev->netdev_ops->ndo_start_xmit(skb, _ndev);
|
||||
|
||||
if (dropped < dev->net->stats.tx_dropped)
|
||||
PWRN("Dropped SKB");
|
||||
Genode::warning("Dropped SKB");
|
||||
}
|
||||
|
||||
/**
|
||||
@ -254,7 +256,7 @@ class Nic_device : public Usb_nic::Device
|
||||
{
|
||||
struct usbnet *dev = (usbnet *)netdev_priv(_ndev);
|
||||
if(!_tx_fixup || !_tx_fixup(dev, skb, 0))
|
||||
PERR("Tx fixup error");
|
||||
Genode::error("Tx fixup error");
|
||||
}
|
||||
|
||||
|
||||
@ -302,8 +304,8 @@ class Nic_device : public Usb_nic::Device
|
||||
static Nic_device *_nic = 0;
|
||||
|
||||
|
||||
void Nic::init(Server::Entrypoint &ep) {
|
||||
_signal = new (Genode::env()->heap()) Signal_helper(ep); }
|
||||
void Nic::init(Genode::Env &env) {
|
||||
_signal = new (Lx::Malloc::mem()) Signal_helper(env); }
|
||||
|
||||
|
||||
/***********************
|
||||
@ -320,7 +322,7 @@ int register_netdev(struct net_device *ndev)
|
||||
|
||||
/* XXX: move to 'main' */
|
||||
if (!announce) {
|
||||
static ::Root root(_signal->ep(), *env()->heap(), nic);
|
||||
static ::Root root(_signal->env(), Lx::Malloc::mem(), nic);
|
||||
|
||||
announce = true;
|
||||
|
||||
@ -334,7 +336,7 @@ int register_netdev(struct net_device *ndev)
|
||||
ndev->netdev_ops->ndo_set_rx_mode(ndev);
|
||||
|
||||
_nic = nic;
|
||||
env()->parent()->announce(_signal->ep().rpc_ep().manage(&root));
|
||||
_signal->parent().announce(_signal->ep().rpc_ep().manage(&root));
|
||||
}
|
||||
|
||||
return err;
|
||||
@ -387,7 +389,7 @@ int netif_rx(struct sk_buff *skb)
|
||||
try {
|
||||
_stat.data(new (skb->data) Net::Ethernet_frame(skb->len), skb->len);
|
||||
} catch(Net::Ethernet_frame::No_ethernet_frame) {
|
||||
PWRN("No ether frame");
|
||||
Genode::warning("No ether frame");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@ -466,8 +468,8 @@ void kfree_skb(struct sk_buff *skb) { dev_kfree_skb(skb); }
|
||||
void skb_reserve(struct sk_buff *skb, int len)
|
||||
{
|
||||
if ((skb->data + len) > skb->end) {
|
||||
PERR("Error resevring SKB data: skb: %p data: %p end: %p len: %d",
|
||||
skb, skb->data, skb->end, skb->len);
|
||||
Genode::error("Error resevring SKB data: skb: ", skb, " data: ", skb->data,
|
||||
" end: ", skb->end, "len: ", skb->len);
|
||||
return;
|
||||
}
|
||||
skb->data += len;
|
||||
@ -481,8 +483,8 @@ void skb_reserve(struct sk_buff *skb, int len)
|
||||
unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
|
||||
{
|
||||
if((skb->data - len) < skb->start) {
|
||||
PERR("Error SKB head room too small: %p data: %p start: %p len: %u",
|
||||
skb, skb->data, skb->start, len);
|
||||
Genode::error("Error SKB head room too small: ", skb, " data: ", skb->data,
|
||||
" start: ", skb->start, " len: ", len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -500,8 +502,8 @@ unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
|
||||
unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
|
||||
{
|
||||
if ((skb->data + len > skb->end)) {
|
||||
PERR("Error increasing SKB length: skb: %p data: %p end: %p len: %u",
|
||||
skb, skb->data, skb->end, len);
|
||||
Genode::error("Error increasing SKB length: skb: ", skb, " data: ", skb->data,
|
||||
" end: ", skb->end, " len: ", len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -535,8 +537,8 @@ int skb_tailroom(const struct sk_buff *skb)
|
||||
unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
|
||||
{
|
||||
if (len > skb->len) {
|
||||
PERR("Error try to pull too much: skb: %p len: %u pull len: %u",
|
||||
skb, skb->len, len);
|
||||
Genode::error("Error try to pull too much: skb: ", skb, " len: ", skb->len,
|
||||
" pull len: ", len);
|
||||
return 0;
|
||||
}
|
||||
skb->len -= len;
|
||||
@ -551,8 +553,8 @@ unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
|
||||
void skb_trim(struct sk_buff *skb, unsigned int len)
|
||||
{
|
||||
if (skb->len <= len) {
|
||||
PERR("Error trimming to %u bytes skb: %p data: %p start: %p len %u ret: %p",
|
||||
len, skb, skb->data, skb->start, skb->len, __builtin_return_address((0)));
|
||||
Genode::error("Error trimming to ", len, " bytes skb: ", skb, " data: ",
|
||||
skb->data, " start: ", skb->start, " len ", skb->len);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -708,16 +710,17 @@ void random_ether_addr(u8 *addr)
|
||||
u8 fallback[] = { 0x2e, 0x60, 0x90, 0x0c, 0x4e, 0x01 };
|
||||
Nic::Mac_address mac;
|
||||
|
||||
Xml_node config_node = Lx_kit::env().config_rom().xml();
|
||||
|
||||
/* try using configured mac */
|
||||
try {
|
||||
Xml_node nic_config = config()->xml_node().sub_node("nic");
|
||||
Xml_node nic_config = config_node.sub_node("nic");
|
||||
Xml_node::Attribute mac_node = nic_config.attribute("mac");
|
||||
mac_node.value(&mac);
|
||||
} catch (...) {
|
||||
/* use fallback mac */
|
||||
snprint_mac(str, fallback);
|
||||
PWRN("No mac address or wrong format attribute in <nic> - using fallback (%s)",
|
||||
str);
|
||||
Genode::warning("No mac address or wrong format attribute in <nic> - using fallback (", str, ")");
|
||||
|
||||
Genode::memcpy(addr, fallback, ETH_ALEN);
|
||||
return;
|
||||
@ -726,7 +729,7 @@ void random_ether_addr(u8 *addr)
|
||||
/* use configured mac*/
|
||||
Genode::memcpy(addr, mac.addr, ETH_ALEN);
|
||||
snprint_mac(str, (u8 *)mac.addr);
|
||||
PINF("Using configured mac: %s", str);
|
||||
Genode::log("Using configured mac: ", str);
|
||||
|
||||
#ifdef GENODE_NET_STAT
|
||||
_stat.set_mac(mac.addr);
|
||||
|
||||
@ -11,8 +11,7 @@
|
||||
* under the terms of the GNU General Public License version 2.
|
||||
*/
|
||||
|
||||
#include <base/env.h>
|
||||
#include <base/printf.h>
|
||||
#include <base/log.h>
|
||||
#include <os/reporter.h>
|
||||
#include <os/session_policy.h>
|
||||
#include <root/component.h>
|
||||
@ -26,6 +25,7 @@
|
||||
#include <lx_emul/extern_c_end.h>
|
||||
#include <signal.h>
|
||||
|
||||
#include <lx_kit/malloc.h>
|
||||
#include <lx_kit/scheduler.h>
|
||||
|
||||
using namespace Genode;
|
||||
@ -183,7 +183,7 @@ class Usb::Worker
|
||||
int length;
|
||||
|
||||
if ((length = usb_string(_device->udev, p.string.index, buffer, p.size())) < 0) {
|
||||
PWRN("Could not read string descriptor index: %u", p.string.index);
|
||||
warning("Could not read string descriptor index: ", (unsigned)p.string.index);
|
||||
p.string.length = 0;
|
||||
} else {
|
||||
/* returned length is in bytes (char) */
|
||||
@ -296,7 +296,7 @@ class Usb::Worker
|
||||
|
||||
urb *bulk_urb = usb_alloc_urb(0, GFP_KERNEL);
|
||||
if (!bulk_urb) {
|
||||
PERR("Failed to allocate bulk URB");
|
||||
error("Failed to allocate bulk URB");
|
||||
kfree(buf);
|
||||
return false;
|
||||
}
|
||||
@ -309,7 +309,7 @@ class Usb::Worker
|
||||
_async_complete, data);
|
||||
|
||||
if (usb_submit_urb(bulk_urb, GFP_KERNEL))
|
||||
PERR("Failed to submit URB");
|
||||
error("Failed to submit URB");
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -331,7 +331,7 @@ class Usb::Worker
|
||||
|
||||
urb *irq_urb = usb_alloc_urb(0, GFP_KERNEL);
|
||||
if (!irq_urb) {
|
||||
PERR("Failed to allocate interrupt URB");
|
||||
error("Failed to allocate interrupt URB");
|
||||
kfree(buf);
|
||||
return false;
|
||||
}
|
||||
@ -344,7 +344,7 @@ class Usb::Worker
|
||||
_async_complete, data, p.transfer.timeout);
|
||||
|
||||
if (usb_submit_urb(irq_urb, GFP_KERNEL))
|
||||
PERR("Failed to submit URB");
|
||||
error("Failed to submit URB");
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -372,7 +372,7 @@ class Usb::Worker
|
||||
|
||||
for (unsigned i = 0; i < config->desc.bNumInterfaces; i++) {
|
||||
if (usb_interface_claimed(config->interface[i])) {
|
||||
PERR("There are interfaces claimed, won't set configuration");
|
||||
error("There are interfaces claimed, won't set configuration");
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -411,7 +411,7 @@ class Usb::Worker
|
||||
Packet_descriptor p = _sink->get_packet();
|
||||
|
||||
if (verbose_raw)
|
||||
PDBG("PACKET: %u first value: %x", p.type, p.number);
|
||||
log("PACKET: ", (unsigned)p.type, " first value: ", Hex(p.number));
|
||||
|
||||
_p_in_flight++;
|
||||
|
||||
@ -500,7 +500,7 @@ class Usb::Worker
|
||||
void start()
|
||||
{
|
||||
if (!_task) {
|
||||
_task = new (Genode::env()->heap()) Lx::Task(run, this, "raw_worker",
|
||||
_task = new (Lx::Malloc::mem()) Lx::Task(run, this, "raw_worker",
|
||||
Lx::Task::PRIORITY_2,
|
||||
Lx::scheduler());
|
||||
if (!Lx::scheduler().active()) {
|
||||
@ -513,7 +513,7 @@ class Usb::Worker
|
||||
{
|
||||
if (_task) {
|
||||
Lx::scheduler().remove(_task);
|
||||
destroy(Genode::env()->heap(), _task);
|
||||
destroy(Lx::Malloc::mem(), _task);
|
||||
_task = nullptr;
|
||||
}
|
||||
}
|
||||
@ -539,7 +539,7 @@ class Usb::Session_component : public Session_rpc_object,
|
||||
{
|
||||
private:
|
||||
|
||||
Server::Entrypoint &_ep;
|
||||
Genode::Entrypoint &_ep;
|
||||
unsigned long _vendor;
|
||||
unsigned long _product;
|
||||
long _bus = 0;
|
||||
@ -571,7 +571,7 @@ class Usb::Session_component : public Session_rpc_object,
|
||||
DEVICE_REMOVE,
|
||||
};
|
||||
|
||||
Session_component(Genode::Ram_dataspace_capability tx_ds, Server::Entrypoint &ep,
|
||||
Session_component(Genode::Ram_dataspace_capability tx_ds, Genode::Entrypoint &ep,
|
||||
unsigned long vendor, unsigned long product,
|
||||
long bus, long dev)
|
||||
: Session_rpc_object(tx_ds, ep.rpc_ep()),
|
||||
@ -700,9 +700,10 @@ class Usb::Session_component : public Session_rpc_object,
|
||||
return false;
|
||||
|
||||
if (_device)
|
||||
PWRN("Device type already present (vendor: %x product: %x). Overwrite!",
|
||||
device->udev->descriptor.idVendor,
|
||||
device->udev->descriptor.idProduct);
|
||||
warning("Device type already present (vendor: ",
|
||||
Hex(device->udev->descriptor.idVendor),
|
||||
" product: ", Hex(device->udev->descriptor.idProduct),
|
||||
") Overwrite!");
|
||||
|
||||
_device = device;
|
||||
_worker.device(_device, _sigh_state_change);
|
||||
@ -754,18 +755,18 @@ class Usb::Root : public Genode::Root_component<Session_component>
|
||||
{
|
||||
private:
|
||||
|
||||
Server::Entrypoint &_ep;
|
||||
Genode::Env &_env;
|
||||
|
||||
Genode::Signal_rpc_member<Usb::Root> _config_dispatcher = {
|
||||
_ep, *this, &Usb::Root::_handle_config };
|
||||
_env.ep(), *this, &Usb::Root::_handle_config };
|
||||
|
||||
Genode::Reporter _config_reporter { "config" };
|
||||
|
||||
void _handle_config(unsigned)
|
||||
{
|
||||
Genode::config()->reload();
|
||||
Lx_kit::env().config_rom().update();
|
||||
|
||||
Genode::Xml_node config = Genode::config()->xml_node();
|
||||
Genode::Xml_node config = Lx_kit::env().config_rom().xml();
|
||||
|
||||
if (!_config_reporter.enabled())
|
||||
_config_reporter.enabled(true);
|
||||
@ -790,7 +791,8 @@ class Usb::Root : public Genode::Root_component<Session_component>
|
||||
using namespace Genode;
|
||||
|
||||
try {
|
||||
Xml_node raw = Genode::config()->xml_node().sub_node("raw");
|
||||
Xml_node config_node = Lx_kit::env().config_rom().xml();
|
||||
Xml_node raw = config_node.sub_node("raw");
|
||||
Genode::Session_label label(args);
|
||||
Genode::Session_policy policy(label, raw);
|
||||
|
||||
@ -808,19 +810,19 @@ class Usb::Root : public Genode::Root_component<Session_component>
|
||||
throw Root::Quota_exceeded();
|
||||
|
||||
if (tx_buf_size > ram_quota - session_size) {
|
||||
PERR("Insufficient 'ram_quota',got %zu, need %zu",
|
||||
ram_quota, tx_buf_size + session_size);
|
||||
error("Insufficient 'ram_quota',got ", ram_quota, " need ",
|
||||
tx_buf_size + session_size);
|
||||
throw Root::Quota_exceeded();
|
||||
}
|
||||
|
||||
Ram_dataspace_capability tx_ds = env()->ram_session()->alloc(tx_buf_size);
|
||||
Ram_dataspace_capability tx_ds = _env.ram().alloc(tx_buf_size);
|
||||
Session_component *session = new (md_alloc())
|
||||
Session_component(tx_ds, _ep, vendor, product, bus, dev);
|
||||
Session_component(tx_ds, _env.ep(), vendor, product, bus, dev);
|
||||
::Session::list()->insert(session);
|
||||
return session;
|
||||
} catch (Genode::Session_policy::No_policy_defined) {
|
||||
PERR("Invalid session request, no matching policy for '%s'",
|
||||
Genode::Session_label(args).string());
|
||||
error("Invalid session request, no matching policy for '",
|
||||
Genode::Session_label(args).string(), "'");
|
||||
throw Genode::Root::Unavailable();
|
||||
}
|
||||
}
|
||||
@ -832,26 +834,26 @@ class Usb::Root : public Genode::Root_component<Session_component>
|
||||
::Session::list()->remove(session);
|
||||
Genode::Root_component<Session_component>::_destroy_session(session);
|
||||
|
||||
Genode::env()->ram_session()->free(tx_ds);
|
||||
_env.ram().free(tx_ds);
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
Root(Server::Entrypoint &session_ep,
|
||||
Root(Genode::Env &env,
|
||||
Genode::Allocator *md_alloc)
|
||||
: Genode::Root_component<Session_component>(&session_ep.rpc_ep(), md_alloc),
|
||||
_ep(session_ep)
|
||||
: Genode::Root_component<Session_component>(&env.ep().rpc_ep(), md_alloc),
|
||||
_env(env)
|
||||
{
|
||||
Genode::config()->sigh(_config_dispatcher);
|
||||
Lx_kit::env().config_rom().sigh(_config_dispatcher);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
void Raw::init(Server::Entrypoint &ep, bool report_device_list)
|
||||
void Raw::init(Genode::Env &env, bool report_device_list)
|
||||
{
|
||||
Device::device_list_reporter().enabled(report_device_list);
|
||||
static Usb::Root root(ep, env()->heap());
|
||||
Genode::env()->parent()->announce(ep.rpc_ep().manage(&root));
|
||||
static Usb::Root root(env, &Lx::Malloc::mem());
|
||||
env.parent().announce(env.ep().rpc_ep().manage(&root));
|
||||
}
|
||||
|
||||
|
||||
@ -864,9 +866,9 @@ int raw_notify(struct notifier_block *nb, unsigned long action, void *data)
|
||||
struct usb_device *udev = (struct usb_device*)data;
|
||||
|
||||
if (verbose_raw)
|
||||
PDBG("RAW: %s vendor: %04x product: %04x\n",
|
||||
action == USB_DEVICE_ADD ? "Add" : "Remove",
|
||||
udev->descriptor.idVendor, udev->descriptor.idProduct);
|
||||
log("RAW: ",action == USB_DEVICE_ADD ? "Add" : "Remove",
|
||||
" vendor: ", Hex(udev->descriptor.idVendor),
|
||||
" product: ", Hex(udev->descriptor.idProduct));
|
||||
|
||||
|
||||
switch (action) {
|
||||
@ -874,7 +876,7 @@ int raw_notify(struct notifier_block *nb, unsigned long action, void *data)
|
||||
case USB_DEVICE_ADD:
|
||||
{
|
||||
::Session::list()->state_change(Usb::Session_component::DEVICE_ADD,
|
||||
new (env()->heap()) Device(udev));
|
||||
new (Lx::Malloc::mem()) Device(udev));
|
||||
break;
|
||||
}
|
||||
|
||||
@ -884,7 +886,7 @@ int raw_notify(struct notifier_block *nb, unsigned long action, void *data)
|
||||
udev->devnum);
|
||||
if (dev) {
|
||||
::Session::list()->state_change(Usb::Session_component::DEVICE_REMOVE, dev);
|
||||
destroy(env()->heap(), dev);
|
||||
destroy(Lx::Malloc::mem(), dev);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#include <os/attached_io_mem_dataspace.h>
|
||||
#include <lx_emul.h>
|
||||
|
||||
#include <lx_kit/malloc.h>
|
||||
|
||||
#define to_platform_driver(drv) (container_of((drv), struct platform_driver, \
|
||||
driver))
|
||||
@ -197,7 +198,7 @@ void platform_set_drvdata(struct platform_device *pdev, void *data)
|
||||
void *_ioremap(phys_addr_t phys_addr, unsigned long size, int wc)
|
||||
{
|
||||
try {
|
||||
Genode::Attached_io_mem_dataspace *ds = new(Genode::env()->heap())
|
||||
Genode::Attached_io_mem_dataspace *ds = new(Lx::Malloc::mem())
|
||||
Genode::Attached_io_mem_dataspace(phys_addr, size, !!wc);
|
||||
return ds->local_addr<void>();
|
||||
} catch (...) {
|
||||
|
||||
@ -11,11 +11,10 @@
|
||||
* under the terms of the GNU General Public License version 2.
|
||||
*/
|
||||
|
||||
#include <base/env.h>
|
||||
|
||||
#include <lx_emul/irq.h>
|
||||
|
||||
#include <base/env.h>
|
||||
#include <lx_kit/backend_alloc.h>
|
||||
#include <lx_kit/env.h>
|
||||
#include <lx_kit/irq.h>
|
||||
|
||||
|
||||
@ -25,11 +24,11 @@
|
||||
|
||||
Genode::Ram_dataspace_capability
|
||||
Lx::backend_alloc(Genode::addr_t size, Genode::Cache_attribute cached) {
|
||||
return Genode::env()->ram_session()->alloc(size, cached); }
|
||||
return Lx_kit::env().env().ram().alloc(size, cached); }
|
||||
|
||||
|
||||
void Lx::backend_free(Genode::Ram_dataspace_capability cap) {
|
||||
return Genode::env()->ram_session()->free(cap); }
|
||||
return Lx_kit::env().env().ram().free(cap); }
|
||||
|
||||
|
||||
/***********************
|
||||
|
||||
@ -116,7 +116,7 @@ static void gpio_direction_output(Gpio_bank *bank, int gpio, int en)
|
||||
}
|
||||
|
||||
|
||||
static void arndale_ehci_init()
|
||||
static void arndale_ehci_init(Genode::Env &env)
|
||||
{
|
||||
enum Gpio_offset { D1 = 0x180, X3 = 0xc60 };
|
||||
|
||||
@ -128,8 +128,8 @@ static void arndale_ehci_init()
|
||||
reg_pwr.state(true);
|
||||
|
||||
/* reset hub via GPIO */
|
||||
Io_mem_connection io_gpio(GPIO_BASE, 0x1000);
|
||||
addr_t gpio_base = (addr_t)env()->rm_session()->attach(io_gpio.dataspace());
|
||||
Io_mem_connection io_gpio(env, GPIO_BASE, 0x1000);
|
||||
addr_t gpio_base = (addr_t)env.rm().attach(io_gpio.dataspace());
|
||||
|
||||
Gpio_bank *d1 = reinterpret_cast<Gpio_bank *>(gpio_base + D1);
|
||||
Gpio_bank *x3 = reinterpret_cast<Gpio_bank *>(gpio_base + X3);
|
||||
@ -142,14 +142,14 @@ static void arndale_ehci_init()
|
||||
gpio_direction_output(x3, 5, 1);
|
||||
gpio_direction_output(d1, 7, 1);
|
||||
|
||||
env()->rm_session()->detach(gpio_base);
|
||||
env.rm().detach(gpio_base);
|
||||
|
||||
/* reset ehci controller */
|
||||
Io_mem_connection io_ehci(EHCI_BASE, 0x1000);
|
||||
addr_t ehci_base = (addr_t)env()->rm_session()->attach(io_ehci.dataspace());
|
||||
Io_mem_connection io_ehci(env, EHCI_BASE, 0x1000);
|
||||
addr_t ehci_base = (addr_t)env.rm().attach(io_ehci.dataspace());
|
||||
|
||||
Ehci ehci(ehci_base);
|
||||
env()->rm_session()->detach(ehci_base);
|
||||
env.rm().detach(ehci_base);
|
||||
}
|
||||
|
||||
|
||||
@ -267,7 +267,7 @@ struct Phy_usb3 : Genode::Mmio
|
||||
};
|
||||
|
||||
|
||||
static void arndale_xhci_init()
|
||||
static void arndale_xhci_init(Genode::Env &env)
|
||||
{
|
||||
/* enable USB3 clock and power up */
|
||||
static Regulator::Connection reg_clk(Regulator::CLK_USB30);
|
||||
@ -277,7 +277,7 @@ static void arndale_xhci_init()
|
||||
reg_pwr.state(true);
|
||||
|
||||
/* setup PHY */
|
||||
Attached_io_mem_dataspace io_phy(DWC3_PHY_BASE, 0x1000);
|
||||
Attached_io_mem_dataspace io_phy(env, DWC3_PHY_BASE, 0x1000);
|
||||
Phy_usb3 phy((addr_t)io_phy.local_addr<addr_t>());
|
||||
}
|
||||
|
||||
@ -300,7 +300,7 @@ void ehci_setup(Services *services)
|
||||
module_ehci_exynos_init();
|
||||
|
||||
/* setup controller */
|
||||
arndale_ehci_init();
|
||||
arndale_ehci_init(services->env);
|
||||
|
||||
/* setup EHCI-controller platform device */
|
||||
platform_device *pdev = (platform_device *)kzalloc(sizeof(platform_device), 0);
|
||||
@ -326,7 +326,7 @@ void xhci_setup(Services *services)
|
||||
module_dwc3_driver_init();
|
||||
module_xhci_plat_init();
|
||||
|
||||
arndale_xhci_init();
|
||||
arndale_xhci_init(services->env);
|
||||
|
||||
/* setup DWC3-controller platform device */
|
||||
platform_device *pdev = (platform_device *)kzalloc(sizeof(platform_device), 0);
|
||||
|
||||
@ -130,18 +130,18 @@ static void clock_pwr_init()
|
||||
reg_pwr.state(true);
|
||||
}
|
||||
|
||||
static void usb_phy_init()
|
||||
static void usb_phy_init(Genode::Env &env)
|
||||
{
|
||||
Io_mem_connection io_usbotg(USBOTG, 0x1000);
|
||||
addr_t usbotg_base = (addr_t)env()->rm_session()->attach(io_usbotg.dataspace());
|
||||
Io_mem_connection io_usbotg(env, USBOTG, 0x1000);
|
||||
addr_t usbotg_base = (addr_t)env.rm().attach(io_usbotg.dataspace());
|
||||
Usb_Otg usbotg(usbotg_base);
|
||||
env()->rm_session()->detach(usbotg_base);
|
||||
env.rm().detach(usbotg_base);
|
||||
}
|
||||
|
||||
static void odroidx2_ehci_init()
|
||||
static void odroidx2_ehci_init(Genode::Env &env)
|
||||
{
|
||||
clock_pwr_init();
|
||||
usb_phy_init();
|
||||
usb_phy_init(env);
|
||||
|
||||
/* reset hub via GPIO */
|
||||
enum { X30 = 294, X34 = 298, X35 = 299 };
|
||||
@ -161,12 +161,12 @@ static void odroidx2_ehci_init()
|
||||
gpio_x34.write(true);
|
||||
|
||||
/* reset ehci controller */
|
||||
Io_mem_connection io_ehci(EHCI_BASE, 0x1000);
|
||||
addr_t ehci_base = (addr_t)env()->rm_session()->attach(io_ehci.dataspace());
|
||||
Io_mem_connection io_ehci(env, EHCI_BASE, 0x1000);
|
||||
addr_t ehci_base = (addr_t)env.rm().attach(io_ehci.dataspace());
|
||||
|
||||
Ehci ehci(ehci_base);
|
||||
|
||||
env()->rm_session()->detach(ehci_base);
|
||||
env.rm().detach(ehci_base);
|
||||
}
|
||||
|
||||
extern "C" void module_ehci_exynos_init();
|
||||
@ -187,7 +187,7 @@ void ehci_setup(Services *services)
|
||||
module_ehci_exynos_init();
|
||||
|
||||
/* setup controller */
|
||||
odroidx2_ehci_init();
|
||||
odroidx2_ehci_init(services->env);
|
||||
|
||||
/* setup EHCI-controller platform device */
|
||||
platform_device *pdev = (platform_device *)kzalloc(sizeof(platform_device), 0);
|
||||
|
||||
@ -224,14 +224,14 @@ struct Ehci : Genode::Mmio
|
||||
* Initialize the USB controller from scratch, since the boot loader might not
|
||||
* do it or even disable USB.
|
||||
*/
|
||||
static void omap_ehci_init()
|
||||
static void omap_ehci_init(Genode::Env &env)
|
||||
{
|
||||
/* taken from the Panda board manual */
|
||||
enum { HUB_POWER = 1, HUB_NRESET = 62, ULPI_PHY_TYPE = 182 };
|
||||
|
||||
/* SCRM */
|
||||
Io_mem_connection io_scrm(SCRM_BASE, 0x1000);
|
||||
addr_t scrm_base = (addr_t)env()->rm_session()->attach(io_scrm.dataspace());
|
||||
Io_mem_connection io_scrm(env, SCRM_BASE, 0x1000);
|
||||
addr_t scrm_base = (addr_t)env.rm().attach(io_scrm.dataspace());
|
||||
|
||||
/* enable reference clock */
|
||||
Aux3 aux3(scrm_base);
|
||||
@ -247,18 +247,18 @@ static void omap_ehci_init()
|
||||
gpio_reset.write(true);
|
||||
|
||||
/* enable clocks */
|
||||
Io_mem_connection io_clock(CAM_BASE, 0x1000);
|
||||
addr_t clock_base = (addr_t)env()->rm_session()->attach(io_clock.dataspace());
|
||||
Io_mem_connection io_clock(env, CAM_BASE, 0x1000);
|
||||
addr_t clock_base = (addr_t)env.rm().attach(io_clock.dataspace());
|
||||
Clocks c(clock_base);
|
||||
|
||||
/* reset TLL */
|
||||
Io_mem_connection io_tll(TLL_BASE, 0x1000);
|
||||
addr_t tll_base = (addr_t)env()->rm_session()->attach(io_tll.dataspace());
|
||||
Io_mem_connection io_tll(env, TLL_BASE, 0x1000);
|
||||
addr_t tll_base = (addr_t)env.rm().attach(io_tll.dataspace());
|
||||
Tll t(tll_base);
|
||||
|
||||
/* reset host */
|
||||
Io_mem_connection io_uhh(UHH_BASE, 0x1000);
|
||||
addr_t uhh_base = (addr_t)env()->rm_session()->attach(io_uhh.dataspace());
|
||||
Io_mem_connection io_uhh(env, UHH_BASE, 0x1000);
|
||||
addr_t uhh_base = (addr_t)env.rm().attach(io_uhh.dataspace());
|
||||
Uhh uhh(uhh_base);
|
||||
|
||||
/* enable hub power */
|
||||
@ -270,7 +270,7 @@ static void omap_ehci_init()
|
||||
|
||||
addr_t base[] = { scrm_base, clock_base, tll_base, uhh_base, 0 };
|
||||
for (int i = 0; base[i]; i++)
|
||||
env()->rm_session()->detach(base[i]);
|
||||
env.rm().detach(base[i]);
|
||||
}
|
||||
|
||||
|
||||
@ -293,7 +293,7 @@ void platform_hcd_init(Services *services)
|
||||
module_ehci_omap_init();
|
||||
|
||||
/* initialize EHCI */
|
||||
omap_ehci_init();
|
||||
omap_ehci_init(services->env);
|
||||
|
||||
/* setup EHCI-controller platform device */
|
||||
platform_device *pdev = (platform_device *)kzalloc(sizeof(platform_device), 0);
|
||||
@ -314,7 +314,7 @@ void platform_hcd_init(Services *services)
|
||||
static u64 dma_mask = ~(u64)0;
|
||||
pdev->dev.dma_mask = &dma_mask;
|
||||
pdev->dev.coherent_dma_mask = ~0;
|
||||
PDBG("register platform device");
|
||||
|
||||
platform_device_register(pdev);
|
||||
}
|
||||
|
||||
|
||||
@ -204,7 +204,7 @@ extern "C" long name() { return retval; }
|
||||
|
||||
int in_irq()
|
||||
{
|
||||
TRACE; PDBG("called by %p", __builtin_return_address(0));
|
||||
TRACE;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -16,13 +16,14 @@
|
||||
#include <base/entrypoint.h>
|
||||
#include <base/lock.h>
|
||||
#include <base/signal.h>
|
||||
#include <os/config.h>
|
||||
#include <util/misc_math.h>
|
||||
|
||||
#include <lx_emul.h>
|
||||
|
||||
#include <lx_kit/env.h>
|
||||
#include <lx_kit/irq.h>
|
||||
#include <lx_kit/pci_dev_registry.h>
|
||||
#include <lx_kit/malloc.h>
|
||||
#include <lx_kit/mapped_io_mem_range.h>
|
||||
|
||||
#include <lx_emul/impl/io.h>
|
||||
@ -60,7 +61,7 @@ class Pci_dev_list
|
||||
* 'Out_of_metadata' exception.
|
||||
*/
|
||||
auto handler = [&] () {
|
||||
Genode::env()->parent()->upgrade(Lx::pci()->cap(),
|
||||
Lx_kit::env().env().parent().upgrade(Lx::pci()->cap(),
|
||||
"ram_quota=4096"); };
|
||||
|
||||
/*
|
||||
@ -76,7 +77,7 @@ class Pci_dev_list
|
||||
*/
|
||||
while (cap.valid()) {
|
||||
|
||||
_pci_caps.insert(new (Genode::env()->heap()) Element(cap));
|
||||
_pci_caps.insert(new (Lx::Malloc::mem()) Element(cap));
|
||||
|
||||
/* try next one. Upgrade session * quota on demand.*/
|
||||
auto attempt = [&] () {
|
||||
@ -144,7 +145,7 @@ extern "C" int pci_register_driver(struct pci_driver *driver)
|
||||
return false;
|
||||
|
||||
/* create 'pci_dev' struct for matching device */
|
||||
Lx::Pci_dev *pci_dev = new (env()->heap()) Lx::Pci_dev(cap);
|
||||
Lx::Pci_dev *pci_dev = new (Lx::Malloc::mem()) Lx::Pci_dev(cap);
|
||||
|
||||
/* enable ioremap to work */
|
||||
Lx::pci_dev_registry()->insert(pci_dev);
|
||||
@ -157,7 +158,7 @@ extern "C" int pci_register_driver(struct pci_driver *driver)
|
||||
* access the USB controller after bootup. For this the ext cap register of
|
||||
* the PCI config space is checked
|
||||
*/
|
||||
if (config()->xml_node().attribute_value("bios_handoff", true))
|
||||
if (Lx_kit::env().config_rom().xml().attribute_value("bios_handoff", true))
|
||||
__pci_fixup_quirk_usb_early_handoff(pci_dev);
|
||||
|
||||
/* call probe function of the Linux driver */
|
||||
|
||||
@ -11,6 +11,7 @@
|
||||
* under the terms of the GNU General Public License version 2.
|
||||
*/
|
||||
|
||||
#include <base/log.h>
|
||||
#include <base/rpc_server.h>
|
||||
#include <block/component.h>
|
||||
#include <cap_session/connection.h>
|
||||
@ -19,6 +20,7 @@
|
||||
|
||||
#include <lx_emul.h>
|
||||
|
||||
#include <lx_kit/malloc.h>
|
||||
#include <lx_kit/backend_alloc.h>
|
||||
#include <lx_kit/scheduler.h>
|
||||
|
||||
@ -75,7 +77,7 @@ class Storage_device : public Genode::List<Storage_device>::Element,
|
||||
_block_count++;
|
||||
|
||||
if (verbose)
|
||||
PDBG("block size: %zu block count: %llu", _block_size, _block_count);
|
||||
Genode::log("block size: ", _block_size, " block count", _block_count);
|
||||
|
||||
scsi_free_buffer(cmnd);
|
||||
_scsi_free_command(cmnd);
|
||||
@ -89,8 +91,8 @@ class Storage_device : public Genode::List<Storage_device>::Element,
|
||||
throw Io_error();
|
||||
|
||||
if (verbose)
|
||||
PDBG("PACKET: phys: %lx block: %llu count: %zu %s",
|
||||
phys, block_nr, block_count, read ? "read" : "write");
|
||||
log("PACKET: phys: ", Genode::Hex(phys), " block: ", block_nr, "count: ", block_count,
|
||||
read ? " read" : " write");
|
||||
|
||||
/* check if we can call queuecommand */
|
||||
struct us_data *us = (struct us_data *) _sdev->host->hostdata;
|
||||
@ -105,7 +107,7 @@ class Storage_device : public Genode::List<Storage_device>::Element,
|
||||
cmnd->sc_data_direction = read ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
|
||||
cmnd->scsi_done = _async_done;
|
||||
|
||||
Block::Packet_descriptor *p = new (Genode::env()->heap()) Block::Packet_descriptor();
|
||||
Block::Packet_descriptor *p = new (Lx::Malloc::mem()) Block::Packet_descriptor();
|
||||
*p = packet;
|
||||
cmnd->packet = (void *)p;
|
||||
|
||||
@ -176,8 +178,8 @@ class Storage_device : public Genode::List<Storage_device>::Element,
|
||||
};
|
||||
|
||||
|
||||
void Storage::init(Server::Entrypoint &ep) {
|
||||
_signal = new (Genode::env()->heap()) Signal_helper(ep); }
|
||||
void Storage::init(Genode::Env &env) {
|
||||
_signal = new (Lx::Malloc::mem()) Signal_helper(env); }
|
||||
|
||||
|
||||
struct Factory : Block::Driver_factory
|
||||
@ -201,10 +203,10 @@ extern "C" void ack_packet(work_struct *work)
|
||||
(Block::Packet_descriptor *)(work->data);
|
||||
|
||||
if (verbose)
|
||||
PDBG("ACK packet for block: %llu", packet->block_number());
|
||||
Genode::log("ACK packet for block: ", packet->block_number());
|
||||
|
||||
device->ack_packet(*packet);
|
||||
Genode::destroy(Genode::env()->heap(), packet);
|
||||
Genode::destroy(Lx::Malloc::mem(), packet);
|
||||
}
|
||||
|
||||
|
||||
@ -221,8 +223,8 @@ void scsi_add_device(struct scsi_device *sdev)
|
||||
*/
|
||||
if (!announce) {
|
||||
PREPARE_WORK(&delayed, ack_packet);
|
||||
static Block::Root root(_signal->ep(), env()->heap(), factory);
|
||||
env()->parent()->announce(_signal->ep().rpc_ep().manage(&root));
|
||||
static Block::Root root(_signal->ep(), &Lx::Malloc::mem(), factory);
|
||||
_signal->parent().announce(_signal->ep().rpc_ep().manage(&root));
|
||||
announce = true;
|
||||
}
|
||||
}
|
||||
|
||||
@ -209,7 +209,6 @@ DUMMY(0, ipv6_hdr)
|
||||
DUMMY(0, irqs_disabled)
|
||||
DUMMY(0, isalpha)
|
||||
DUMMY(0, jhash_2words)
|
||||
DUMMY(0, kmem_cache_destroy)
|
||||
DUMMY(0, kobject_uevent)
|
||||
DUMMY(0, kobject_uevent_env)
|
||||
DUMMY(0, kstrtoul)
|
||||
|
||||
@ -24,8 +24,13 @@ class Usb::Packet_handler
|
||||
private:
|
||||
|
||||
Usb::Connection &_connection;
|
||||
Signal_rpc_member<Packet_handler> _rpc_ack_avail;
|
||||
Signal_rpc_member<Packet_handler> _rpc_ready_submit;
|
||||
Genode::Entrypoint &_ep;
|
||||
|
||||
Signal_rpc_member<Packet_handler> _rpc_ack_avail =
|
||||
{_ep, *this, &Packet_handler::_packet_handler };
|
||||
|
||||
Signal_rpc_member<Packet_handler> _rpc_ready_submit =
|
||||
{ _ep, *this, &Packet_handler::_ready_handler };
|
||||
|
||||
bool _ready_submit = true;
|
||||
|
||||
@ -51,10 +56,8 @@ class Usb::Packet_handler
|
||||
|
||||
public:
|
||||
|
||||
Packet_handler(Connection &connection, Server::Entrypoint &ep)
|
||||
: _connection(connection),
|
||||
_rpc_ack_avail(ep, *this, &Packet_handler::_packet_handler),
|
||||
_rpc_ready_submit(ep, *this, &Packet_handler::_ready_handler)
|
||||
Packet_handler(Connection &connection, Genode::Entrypoint &ep)
|
||||
: _connection(connection), _ep(ep)
|
||||
{
|
||||
/* connect 'ack_avail' to our rpc member */
|
||||
_connection.tx_channel()->sigh_ack_avail(_rpc_ack_avail);
|
||||
@ -73,7 +76,7 @@ class Usb::Packet_handler
|
||||
|
||||
void wait_for_packet()
|
||||
{
|
||||
packet_avail() ? _packet_handler(0) : Server::wait_and_dispatch_one_signal();
|
||||
packet_avail() ? _packet_handler(0) : _ep.wait_and_dispatch_one_signal();
|
||||
}
|
||||
|
||||
Packet_descriptor alloc(size_t size)
|
||||
@ -104,7 +107,7 @@ class Usb::Packet_handler
|
||||
|
||||
/* wait for ready_to_submit signal */
|
||||
while (!_ready_submit)
|
||||
Server::wait_and_dispatch_one_signal();
|
||||
_ep.wait_and_dispatch_one_signal();
|
||||
}
|
||||
|
||||
_connection.source()->submit_packet(p);
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#define _INCLUDE__USB__USB_H_
|
||||
|
||||
#include <base/allocator.h>
|
||||
#include <base/entrypoint.h>
|
||||
#include <usb/types.h>
|
||||
#include <usb/packet_handler.h>
|
||||
#include <usb_session/connection.h>
|
||||
@ -451,7 +452,7 @@ class Usb::Device : public Meta_data
|
||||
String serial_number_string;
|
||||
|
||||
Device(Genode::Allocator * const md_alloc, Connection &connection,
|
||||
Server::Entrypoint &ep)
|
||||
Genode::Entrypoint &ep)
|
||||
: Meta_data(md_alloc, connection, _handler), _handler(connection, ep)
|
||||
{ }
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user