working device swapping

source/#buzzer.ccp

@@ -74,32 +74,9 @@ Kernel::Num start ():
 				switch Kernel::recv.protected_data.l:
 					case BUZZER:
 						// Buzzer device control request.
-						switch Kernel::recv.data[0].l:
-							case Device::CREATE_USER:
-								Kernel::Cap reply = Kernel::get_reply ()
-								Keyboard cap = Kernel::my_receiver.create_capability (Kernel::Num (next_user++, BUZZER))
-								reply.invoke (0, 0, cap.copy ())
-								Kernel::free_cap (cap)
-								Kernel::free_cap (reply)
-								break
-							case Device::DESTROY_USER:
-								Kernel::recv.reply.invoke ()
-								break
-							case Device::UNUSE:
-								buzzer.stop ()
-								Kernel::recv.reply.invoke ()
-								break
-							case Device::USE:
-								Kernel::Cap reply = Kernel::get_reply ()
-								user = Kernel::my_receiver.get_protected (Kernel::recv.arg).l
-								reply.invoke ()
-								Kernel::free_cap (reply)
-								break
-							default:
-								kdebug ("invalid buzzer control command: ")
-								kdebug_num (Kernel::recv.data[0].l)
-								kdebug ("\n")
-								break
+						Kernel::Cap reply = Kernel::get_reply ()
+						Kernel::Cap arg = Kernel::get_arg ()
+						Device::host (BUZZER, user, reply, arg)
 						break
 					default:
 						kdebug ("invalid buzzer request\n")

source/#lcd.ccp

@@ -257,6 +257,63 @@ static unsigned spot (unsigned x, unsigned y, unsigned cx, unsigned cy):
 		return 0
 	return ((l * l - d2 - 1) << 8) / (l * l)
 
+static unsigned pages
+static Descriptor descriptor __attribute__ ((aligned (16)))
+static bool is_on
+
+static unsigned create (Kernel::Memory mem, Kernel::Caps caps):
+	unsigned physical = mem.alloc_range (pages)
+	unsigned address = 0x15000
+	if physical & ~PAGE_MASK:
+		Kernel::panic (0, "can't allocate framebuffer")
+	assert (physical & PAGE_MASK && ~physical)
+	for unsigned i = 0; i < pages; ++i:
+		Kernel::Page p = mem.create_page ()
+		p.alloc_physical (physical + (i << PAGE_BITS), false, true)
+		if address != ~0:
+			mem.map (p, address + (i << PAGE_BITS))
+		Kernel::free_cap (p)
+	return physical
+
+static void destroy (unsigned physical, Kernel::Caps caps):
+	unsigned address = 0x15000
+	Kernel::Memory mem = caps.get (1)
+	if physical == ~0:
+		Kernel::panic (0, "unable to destroy framebuffer with wrong cap0")
+	if descriptor.frame == physical && is_on:
+		lcd_clr_ena ()
+		#ifdef NANONOTE
+		write_reg (BACKLIGHT1, 0x5e)
+		#endif
+	if address != ~0:
+		for unsigned i = 0; i < pages; ++i:
+			Kernel::Page p = mem.mapping ((void *)(address + (i << PAGE_BITS)))
+			mem.destroy (p)
+			Kernel::free_cap (p)
+
+static void use (unsigned physical, Kernel::Caps caps):
+	if physical == ~0:
+		Kernel::panic (0, "unable to use framebuffer with wrong cap0")
+	bool was_unused = descriptor.frame == 0
+	descriptor.frame = physical
+	unsigned dptr = (unsigned)&descriptor
+	__asm__ volatile ("lw $a0, %0\ncache 0x15, 0($a0)" :: "m"(dptr) : "memory", "a0")
+	if was_unused && is_on:
+		lcd_set_ena ()
+		#ifdef NANONOTE:
+		write_reg (BACKLIGHT1, 0x5f)
+		#endif
+
+static void unuse (unsigned physical, Kernel::Caps caps):
+	if physical == ~0:
+		Kernel::panic (0, "unable to unuse framebuffer with wrong cap0")
+	if descriptor.frame == physical:
+		lcd_clr_ena ()
+		#ifdef NANONOTE
+		write_reg (BACKLIGHT1, 0x5e)
+		#endif
+		descriptor.frame = 0
+
 Kernel::Num start ():
 	Kernel::schedule ()
 	map_lcd ()
@@ -265,8 +322,7 @@ Kernel::Num start ():
 	map_gpio ()
 	#endif
 
-	Descriptor descriptor __attribute__ ((aligned (16)))
-	unsigned pages = (frame_size + ~PAGE_MASK) >> PAGE_BITS
+	pages = (frame_size + ~PAGE_MASK) >> PAGE_BITS
 	#if 0
 	unsigned physical = Kernel::my_memory.alloc_range (pages)
 	assert (physical & PAGE_MASK && ~physical)
@@ -320,8 +376,8 @@ Kernel::Num start ():
 
 	Kernel::Cap eof_cb
 	bool have_eof = false
-	bool is_on = true
-	unsigned backlight_user = 0
+	is_on = true
+	unsigned lcd_user = 0
 	unsigned current_backlight = 0
 	while true:
 		Kernel::wait ()
@@ -347,87 +403,7 @@ Kernel::Num start ():
 					case LCD:
 						Kernel::Cap reply = Kernel::get_reply ()
 						Kernel::Cap arg = Kernel::get_arg ()
-						switch Kernel::recv.data[0].l:
-							case Device::CREATE_USER:
-								Kernel::Memory mem (arg)
-								unsigned width = Kernel::recv.data[0].h >> 16
-								unsigned height = Kernel::recv.data[0].h & 0xffff
-								unsigned mode = Kernel::recv.data[1].l & ~PAGE_MASK
-								unsigned address = Kernel::recv.data[1].l & PAGE_MASK
-								if (width != 0 && width != h) || (height != 0 && height != v) || mode != 0:
-									reply.invoke (Kernel::ERR_INVALID_ARGUMENT)
-									kdebug ("invalid framebuffer requested\n")
-									Kernel::panic (0)
-									Kernel::free_cap (reply)
-									Kernel::free_cap (arg)
-									break
-								unsigned physical = mem.alloc_range (pages)
-								if physical & ~PAGE_MASK:
-									kdebug ("can't allocate framebuffer\n")
-									Kernel::panic (0)
-								assert (physical & PAGE_MASK && ~physical)
-								Kernel::Cap ret = Kernel::my_receiver.create_capability (Kernel::Num (physical, LCD))
-								for unsigned i = 0; i < pages; ++i:
-									Kernel::Page p = mem.create_page ()
-									p.alloc_physical (physical + (i << PAGE_BITS), false, true)
-									if address != ~0:
-										//Kernel::panic (0xdeaddead)
-										mem.map (p, address + (i << PAGE_BITS))
-									Kernel::free_cap (p)
-								reply.invoke (0, 0, ret.copy ())
-								Kernel::free_cap (ret)
-								break
-							case Device::DESTROY_USER:
-								//Kernel::Memory mem (arg)
-								unsigned address = Kernel::recv.data[1].l & PAGE_MASK
-								unsigned physical = Kernel::my_receiver.get_protected (arg).l
-								if physical == ~0:
-									kdebug ("unable to destroy framebuffer with wrong cap0\n")
-									Kernel::panic (0)
-									break
-								if descriptor.frame == physical && is_on:
-									lcd_clr_ena ()
-									#ifdef NANONOTE
-									write_reg (BACKLIGHT1, 0x5e)
-									#endif
-								//for unsigned i = 0; i < pages; ++i:
-									//if address != ~0:
-										//Kernel::Page p = mem.mapping ((void *)(address + (i << PAGE_BITS)))
-										//mem.destroy (p)
-										//Kernel::free_cap (p)
-								reply.invoke ()
-								break
-							case Device::USE:
-								unsigned physical = Kernel::my_receiver.get_protected (arg).l
-								if physical == ~0:
-									Kernel::panic (0, "unable to use framebuffer with wrong cap0")
-								bool was_unused = descriptor.frame == 0
-								descriptor.frame = physical
-								unsigned dptr = (unsigned)&descriptor
-								__asm__ volatile ("lw $a0, %0\ncache 0x15, 0($a0)" :: "m"(dptr) : "memory", "a0")
-								if was_unused && is_on:
-									lcd_set_ena ()
-									#ifdef NANONOTE:
-									write_reg (BACKLIGHT1, 0x5f)
-									#endif
-								reply.invoke ()
-								break
-							case Device::UNUSE:
-								unsigned physical = Kernel::my_receiver.get_protected (arg).l
-								if physical == ~0:
-									Kernel::panic (0, "unable to unuse framebuffer with wrong cap0")
-								if descriptor.frame == physical:
-									lcd_clr_ena ()
-									#ifdef NANONOTE
-									write_reg (BACKLIGHT1, 0x5e)
-									#endif
-									descriptor.frame = 0
-								reply.invoke ()
-								break
-							default:
-								Kernel::panic (0, "invalid operation for lcd device")
-						Kernel::free_cap (arg)
-						Kernel::free_cap (reply)
+						Device::host (LCD, lcd_user, reply, arg, 3, create, destroy, use, unuse)
 						break
 					default:
 						Kernel::panic (Kernel::recv.protected_data.l, "invalid operation for master lcd")

source/bsquare.ccp

@@ -0,0 +1,43 @@
+#pypp 0
+#include <iris.hh>
+#include <devices.hh>
+
+static unsigned *framebuffer
+static int const r = 10
+static int colour
+
+void square (int x, int y, bool print):
+	for int ty = y - r; ty < y + r; ++ty:
+		if ty < 0 || ty >= 240:
+			continue
+		for int tx = x - r; tx < x + r; ++tx:
+			if tx < 0 || tx >= 320:
+				continue
+			framebuffer[ty * 320 + tx] = (print ? colour : 0)
+
+Kernel::Num start ():
+	Kernel::my_parent.init_done ()
+	colour = 0xffffff
+	framebuffer = (unsigned *)0x15000
+	Display display = Kernel::my_parent.get_device <Display> (0x10001)
+	int x = r, y = r, dx = 3, dy = 3
+	Kernel::Cap eof = Kernel::my_receiver.create_capability (0)
+	while true:
+		display.set_eof_cb (eof)
+		Kernel::wait ()
+		square (x, y, false)
+		x += dx
+		y += dy
+		if y + r >= 240:
+			dy = -dy
+			y = 240 - r
+		if x - r < 0:
+			x = r
+			dx = -dx
+		if x + r >= 320:
+			x = 320 - r
+			dx = -dx
+		if y - r < 0:
+			y = r
+			dy = -dy
+		square (x, y, true)

source/display-emu.ccp

@@ -17,7 +17,11 @@ Kernel::Num start ():
 				switch Kernel::recv.data[0].l:
 					case Device::CREATE_USER:
 						Kernel::Memory mem (arg)
+						Kernel::Caps ret = mem.create_caps (3)
 						Kernel::Cap target = Kernel::my_receiver.create_capability (Kernel::Num (0, 1))
+						ret.set (0, target.copy ())
+						ret.set (1, mem)
+						Kernel::free_cap (target)
 						for unsigned i = 0; i < 320 * 240 * 4; i += PAGE_SIZE:
 							Kernel::Page p = Kernel::my_memory.mapping ((void *)(0x15000 + i))
 							Kernel::Page t = mem.create_page ()
@@ -27,8 +31,8 @@ Kernel::Num start ():
 							Kernel::my_memory.destroy (t)
 							Kernel::free_cap (t)
 							Kernel::free_cap (p)
-						reply.invoke (0, 0, target)
-						Kernel::free_cap (target)
+						reply.invoke (0, 0, ret.copy ())
+						Kernel::free_cap (ret)
 						break
 					case Device::DESTROY_USER:
 						Kernel::panic (0, "destroying emulation user")

source/display-emu2.ccp

@@ -0,0 +1 @@
+display-emu.ccp