make things work with terminals

source/#buzzer.ccp

@@ -60,9 +60,9 @@ Kernel::Num start ():
 	Device dev = Kernel::my_receiver.create_capability (BUZZER)
 	Kernel::my_parent.provide_device <Buzzer> (dev.copy ())
 	Kernel::free_cap (dev)
+	Kernel::my_parent.init_done ()
 	unsigned user (~0)
 	unsigned next_user (0)
-	Kernel::my_parent.init_done ()
 	while true:
 		Kernel::wait ()
 		switch Kernel::recv.protected_data.h:

source/#gpio.ccp

@@ -270,6 +270,7 @@ Kernel::Num start ():
 	c = Kernel::my_receiver.create_capability (TOUCHPAD)
 	Kernel::my_parent.provide_device <Keyboard> (c.copy (), 1)
 	Kernel::free_cap (c)
+	Kernel::my_parent.init_done ()
 
 	if kbd.is_scanning ():
 		Kernel::my_receiver.set_alarm (ALARM_INTERVAL)
@@ -278,7 +279,6 @@ Kernel::Num start ():
 	GPIO_GPIER (GPIO_KBD_ROW_PORT) = (1 << GPIO_TP_LEFT) | (1 << GPIO_TP_RIGHT) | GPIO_KBD_ROW_MASK
 	Kernel::register_interrupt (IRQ_GPIO0)
 
-	Kernel::my_parent.init_done ()
 	while true:
 		Kernel::schedule ()
 		Kernel::wait ()

source/#lcd.ccp

@@ -183,7 +183,7 @@ static void reset ():
 	write_reg (COLOR, 0x01)
 	#endif
 
-	LCD_CTRL = (bpp << LCD_CTRL_BPP_BIT) | LCD_CTRL_BST_16
+	LCD_CTRL = (bpp << LCD_CTRL_BPP_BIT) | LCD_CTRL_BST_16 | LCD_CTRL_EOFM
 	LCD_CFG = cfg
 	LCD_HSYNC = hpe
 	LCD_VSYNC = vpe
@@ -191,8 +191,8 @@ static void reset ():
 	LCD_DAH = (hds << 16) | hde
 	LCD_DAV = (vds << 16) | vde
 	LCD_DA0 = physical_descriptor
-	LCD_CTRL = (bpp << LCD_CTRL_BPP_BIT) | LCD_CTRL_BST_16 | LCD_CTRL_ENA
-	//lcd_enable_eof_intr ()
+	LCD_STATE = 0
+	LCD_CTRL = (bpp << LCD_CTRL_BPP_BIT) | LCD_CTRL_BST_16 | LCD_CTRL_EOFM | LCD_CTRL_ENA
 
 static void putchar (unsigned x, unsigned y, unsigned ch):
 	if ch < 32 || ch > 126:
@@ -245,8 +245,8 @@ static void log_msg ():
 
 enum captype:
 	LOG = 32
-	SET_EOF_CB
 	BACKLIGHT
+	LCD
 
 static unsigned spot (unsigned x, unsigned y, unsigned cx, unsigned cy):
 	unsigned dx2 = (x - cx) * (x - cx)
@@ -267,6 +267,7 @@ Kernel::Num start ():
 
 	Descriptor descriptor __attribute__ ((aligned (16)))
 	unsigned pages = (frame_size + ~PAGE_MASK) >> PAGE_BITS
+	#if 0
 	unsigned physical = Kernel::my_memory.alloc_range (pages)
 	assert (physical & PAGE_MASK && ~physical)
 	for unsigned i = 0; i < pages; ++i:
@@ -286,6 +287,9 @@ Kernel::Num start ():
 			#else
 			#error "Define your framebuffer format."
 			#endif
+	#else
+	unsigned physical = 0
+	#endif
 	Kernel::Page p = Kernel::my_memory.mapping (&descriptor)
 	unsigned paddr = p.physical_address ()
 	physical_descriptor = paddr + ((unsigned)&descriptor & ~PAGE_MASK)
@@ -305,14 +309,20 @@ Kernel::Num start ():
 
 	// Register the backlight device.
 	Kernel::Cap backlight = Kernel::my_receiver.create_capability (BACKLIGHT)
-	Kernel::my_parent.provide_device <Setting> (backlight)
+	Kernel::my_parent.provide_device <Setting> (backlight.copy ())
+	Kernel::free_cap (backlight)
+
+	// Register the display device.
+	Kernel::Cap display = Kernel::my_receiver.create_capability (LCD)
+	Kernel::my_parent.provide_device <Display> (display.copy ())
+	Kernel::free_cap (display)
+	Kernel::my_parent.init_done ()
 
 	Kernel::Cap eof_cb
 	bool have_eof = false
 	bool is_on = true
 	unsigned backlight_user = 0
-	Kernel::Num current_backlight = 0
-	Kernel::my_parent.init_done ()
+	unsigned current_backlight = 0
 	while true:
 		Kernel::wait ()
 		//log_msg ()
@@ -320,9 +330,8 @@ Kernel::Num start ():
 			case 0:
 				switch Kernel::recv.protected_data.l:
 					case IRQ_LCD:
-						lcd_clr_eof ()
-						eof_cb.invoke ()
 						have_eof = false
+						eof_cb.invoke ()
 						Kernel::free_cap (eof_cb)
 						break
 					#if defined (TRENDTAC)
@@ -331,46 +340,112 @@ Kernel::Num start ():
 						break
 					#endif
 					case BACKLIGHT:
+						Kernel::Cap reply = Kernel::get_reply ()
+						Kernel::Cap arg = Kernel::get_arg ()
+						Device::host (BACKLIGHT, current_backlight, reply, arg)
+						break
+					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::Cap reply = Kernel::get_reply ()
-								Kernel::Cap c = Kernel::my_receiver.create_capability (Kernel::Num (backlight_user++, BACKLIGHT))
-								reply.invoke (0, 0, c.copy ())
-								Kernel::free_cap (c)
-								Kernel::free_cap (reply)
+								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
+								Kernel::Caps caps = mem.create_caps (4)
+								caps.set (1, mem.copy ())
+								unsigned slot = caps.use ()
+								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::set_recv_arg (Kernel::Cap (slot, 0))
+								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)
+								Kernel::free_slot (slot)
+								reply.invoke (0, 0, caps.copy ())
+								Kernel::free_cap (caps)
 								break
 							case Device::DESTROY_USER:
-								Kernel::recv.reply.invoke ()
+								unsigned slot = Kernel::Caps (arg).use ()
+								unsigned physical = Kernel::my_receiver.get_protected (Kernel::Cap (slot, 0)).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
+								Kernel::Memory mem = Kernel::Cap (slot, 1)
+								for unsigned i = 0; i < pages; ++i:
+									mem.destroy (Kernel::Cap (slot, 2 + i))
+								mem.destroy (arg)
+								Kernel::free_slot (slot)
+								reply.invoke ()
 								break
 							case Device::USE:
-								Kernel::Cap reply = Kernel::get_reply ()
-								Kernel::Cap arg = Kernel::get_arg ()
-								current_backlight = Kernel::my_receiver.get_protected (arg)
+								Kernel::Cap first = Kernel::Caps (arg).get (0)
+								unsigned physical = Kernel::my_receiver.get_protected (first).l
+								if physical == ~0:
+									kdebug ("unable to use framebuffer with wrong cap0\n")
+									Kernel::panic (0)
+									break
+								Kernel::free_cap (first)
+								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 ()
-								Kernel::free_cap (arg)
-								Kernel::free_cap (reply)
 								break
 							case Device::UNUSE:
-								Kernel::Cap reply = Kernel::get_reply ()
-								Kernel::Cap arg = Kernel::get_arg ()
-								if current_backlight.value () == Kernel::my_receiver.get_protected (arg).value ():
-									current_backlight = 0
+								Kernel::Cap first = Kernel::Caps (arg).get (0)
+								unsigned physical = Kernel::my_receiver.get_protected (first).l
+								if physical == ~0:
+									kdebug ("unable to unuse framebuffer with wrong cap0\n")
+									Kernel::panic (0)
+									break
+								Kernel::free_cap (first)
+								if descriptor.frame == physical:
+									lcd_clr_ena ()
+									#ifdef NANONOTE
+									write_reg (BACKLIGHT1, 0x5e)
+									#endif
 								reply.invoke ()
-								Kernel::free_cap (arg)
-								Kernel::free_cap (reply)
 								break
 							default:
-								log_char ('@')
-								break
+								Kernel::panic (0, "invalid operation for lcd device")
+						Kernel::free_cap (arg)
+						Kernel::free_cap (reply)
 						break
 					default:
-						log_char ('#')
-						log_num (Kernel::recv.protected_data)
-						log_char ('\n')
+						Kernel::panic (Kernel::recv.protected_data.l, "invalid operation for master lcd")
 						break
 				break
 			case BACKLIGHT:
-				if current_backlight.value () != Kernel::recv.protected_data.value ():
+				if current_backlight != Kernel::recv.protected_data.l:
 					log_char ('&')
 					log_num (current_backlight)
 					log_num (Kernel::recv.protected_data)
@@ -400,22 +475,36 @@ Kernel::Num start ():
 						Kernel::recv.reply.invoke (~0)
 						break
 					default:
-						log_char ('$')
+						Kernel::panic (0, "invalid operation for backlight")
 						break
 				break
-			case SET_EOF_CB:
-				Kernel::Cap reply = Kernel::get_reply ()
-				if have_eof:
-					Kernel::free_cap (eof_cb)
-				else:
-					Kernel::register_interrupt (IRQ_LCD)
-					have_eof = true
-				eof_cb = Kernel::get_arg ()
-				reply.invoke ()
-				Kernel::free_cap (reply)
+			case LCD:
+				if descriptor.frame != Kernel::recv.protected_data.l:
+					kdebug ("invalid user requesting lcd\n")
+					Kernel::panic (0)
+					break
+				switch Kernel::recv.data[0].l:
+					case Display::SET_EOF_CB:
+						Kernel::Cap reply = Kernel::get_reply ()
+						Kernel::Cap arg = Kernel::get_arg ()
+						if have_eof:
+							Kernel::free_cap (eof_cb)
+							kdebug ("replacing eof_cb\n")
+							Kernel::panic (0)
+						else:
+							lcd_clr_eof ()
+							Kernel::register_interrupt (IRQ_LCD)
+							have_eof = true
+						eof_cb = arg
+						reply.invoke ()
+						Kernel::free_cap (reply)
+						break
+					case Display::GET_INFO:
+						kdebug ("get_info isn't defined yet.\n")
+						Kernel::panic (0)
+					default:
+						Kernel::panic (0, "invalid operation for lcd")
 				break
 			default:
-				log_char ('~')
-				log_num (Kernel::recv.protected_data)
-				log_char ('\n')
+				Kernel::panic (0, "invalid master operation type for lcd")
 				break

source/#nanonote-gpio.ccp

@@ -170,6 +170,8 @@ class PowerButton:
 	Kernel::Cap cb
 	public:
 	void scan ():
+		if !started:
+			return
 		gpio_mask_irq (3, 1 << 29)
 		bool s = gpio_get_port (3) & (1 << 29)
 		if s != state:
@@ -206,12 +208,12 @@ Kernel::Num start ():
 	Kernel::my_parent.provide_device <Keyboard> (pw.copy (), 1)
 	Kernel::free_cap (dev)
 	Kernel::free_cap (pw)
+	Kernel::my_parent.init_done ()
 	if kbd.scanning ():
 		Kernel::my_receiver.set_alarm (SCAN_INTERVAL)
-	unsigned user (~0)
+	unsigned user (0), power_user (0)
 	unsigned next_user (0)
 	Kernel::register_interrupt (IRQ_GPIO3)
-	Kernel::my_parent.init_done ()
 	while true:
 		Kernel::wait ()
 		switch Kernel::recv.protected_data.h:
@@ -233,43 +235,15 @@ Kernel::Num start ():
 						break
 					case PWR:
 						// Power button request.
-						switch Kernel::recv.data[0].l:
-							case Keyboard::SET_CB:
-								pwr.set_cb (Kernel::get_arg ())
-								Kernel::recv.reply.invoke ()
-								break
-							default:
-								kdebug ("power button invalid request\n")
-								break
+						Kernel::Cap reply = Kernel::get_reply ()
+						Kernel::Cap arg = Kernel::get_arg ()
+						Device::host (PWR, power_user, reply, arg)
 						break
 					case KBD_DEV:
 						// Keyboard 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++, KBD_DEV))
-								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:
-								kbd.inactive ()
-								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 ("gpio other dev:")
-								kdebug_num (Kernel::recv.data[0].l)
-								kdebug ("\n")
-								break
+						Kernel::Cap reply = Kernel::get_reply ()
+						Kernel::Cap arg = Kernel::get_arg ()
+						Device::host (KBD_DEV, user, reply, arg)
 						break
 					default:
 						break
@@ -277,7 +251,7 @@ Kernel::Num start ():
 			case KBD_DEV:
 				// Keyboard device user request.
 				if Kernel::recv.protected_data.l != user:
-					kdebug ("invalid user requesting\n")
+					kdebug ("invalid user requesting keyboard\n")
 					Kernel::recv.reply.invoke ()
 					break
 				switch Kernel::recv.data[0].l:
@@ -297,6 +271,24 @@ Kernel::Num start ():
 						kdebug ("keyboard other\n")
 						break
 				break
+			case PWR:
+				if Kernel::recv.protected_data.l != power_user:
+					kdebug ("invalid user requesting power\n")
+					Kernel::recv.reply.invoke ()
+					break
+				switch Kernel::recv.data[0].l:
+					case Keyboard::SET_CB:
+						Kernel::Cap reply = Kernel::get_reply ()
+						pwr.set_cb (Kernel::get_arg ())
+						reply.invoke ()
+						Kernel::free_cap (reply)
+						break
+					default:
+						kdebug ("Power button invalid request\n")
+						kdebug_num (Kernel::recv.data[0].l)
+						kdebug ("\n")
+						break
+				break
 			default:
 				kdebug ("keyboard unknown num: ")
 				kdebug_num (Kernel::recv.protected_data.h)

source/ball.ccp

@@ -0,0 +1,49 @@
+#pypp 0
+#include <iris.hh>
+#include <devices.hh>
+
+static unsigned *framebuffer
+static int const r = 10
+
+void ball (int x, int y, bool print):
+	static unsigned bg
+	static unsigned count
+	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
+			if (x - tx) * (x - tx) + (y - ty) * (y - ty) > r * r:
+				continue
+			framebuffer[ty * 320 + tx] = (print ? 0xffffff : bg)
+	if ++count >= 30:
+		bg += 0x010307
+		count = 0
+
+Kernel::Num start ():
+	Kernel::my_parent.init_done ()
+	framebuffer = (unsigned *)0x15000
+	Kernel::Caps caps = Kernel::my_parent.get_device <Display> ()
+	Display display = caps.get (0)
+	int x = r, y = r, dx = 3, dy = 0
+	Kernel::Cap eof = Kernel::my_receiver.create_capability (0)
+	while true:
+		display.set_eof_cb (eof)
+		Kernel::wait ()
+		ball (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 == 240 - r && dy == 0:
+			dy = -21
+		++dy
+		ball (x, y, true)

source/crt0.ccp

@@ -46,7 +46,7 @@ namespace Kernel:
 		for list *i = __first_free_cap; i; i = i->next:
 			used[i - __cap_admin] = false
 			++num
-		kdebug_num (num, 1)
+		kdebug_num (num, 2)
 		kdebug (":")
 		for unsigned i = 0; i < 32; ++i:
 			kdebug_char (used[i] ? '#' : '.')
@@ -61,9 +61,12 @@ namespace Kernel:
 		__first_free_slot = &__slot_admin[slot]
 
 	void free_cap (Cap cap):
-		//kdebug ("free cap\n")
+		//kdebug ("free cap ")
+		//kdebug_num (cap.idx (), 2)
+		//kdebug ("\n")
 		if cap.slot () != 0:
 			kdebug ("trying to free capability from non-0 slot\n")
+			Kernel::panic (0)
 			return
 		list *l = &__cap_admin[cap.idx ()]
 		l->prev = NULL
@@ -77,6 +80,7 @@ namespace Kernel:
 		if !__first_free_slot:
 			// Out of slots...  Probably best to raise an exception.  For now, just return NO_SLOT.
 			kdebug ("out of slots!\n")
+			Kernel::panic (0)
 			return ~0
 		list *ret = __first_free_slot
 		__first_free_slot = ret->next
@@ -85,15 +89,18 @@ namespace Kernel:
 		return ret - __slot_admin
 
 	Cap alloc_cap ():
-		//kdebug ("alloc cap\n")
+		//kdebug ("alloc cap ")
 		if !__first_free_cap:
 			// Out of caps...  Probably best to raise an exception.  For now, just return CAP_NONE
 			kdebug ("out of capabilities!\n")
+			Kernel::panic (0)
 			return Cap (0, CAP_NONE)
 		list *ret = __first_free_cap
 		__first_free_cap = ret->next
 		if ret->next:
 			ret->next->prev = NULL
+		//kdebug_num (ret - __cap_admin, 2)
+		//kdebug ("\n")
 		return Cap (0, ret - __cap_admin)
 
 extern "C":
@@ -103,7 +110,7 @@ extern "C":
 		__slot_admin = slot_admin
 		__cap_admin = cap_admin
 		__first_free_slot = NULL
-		for unsigned i = 2; i < __slots; ++i:
+		for unsigned i = 1; i < __slots; ++i:
 			Kernel::free_slot (i)
 		__first_free_cap = NULL
 		for unsigned i = 7; i < __caps; ++i:

source/metronome.ccp

@@ -20,6 +20,7 @@
 #include "keys.hh"
 
 Kernel::Num start ():
+	Kernel::my_parent.init_done ()
 	Buzzer buzzer = Kernel::my_parent.get_device <Buzzer> ()
 	Keyboard kbd = Kernel::my_parent.get_device <Keyboard> ()
 	Kernel::Cap key = Kernel::my_receiver.create_capability (0)
@@ -29,7 +30,6 @@ Kernel::Num start ():
 	// Frequency of single pulses in hertz.
 	unsigned freq = 1000
 	bool running (false)
-	Kernel::my_parent.init_done ()
 	while true:
 		Kernel::wait ()
 		switch Kernel::recv.protected_data.l: