iris

iris Commit Details

Date:	2010-05-05 01:09:32 (13 years 7 months ago)
Author:	Bas Wijnen
Commit:	a4b5d94200105352d02298e552bee04c1a377a47
Message:	removed old device handling
Files:	boot-programs/bootinit.ccp (5 diffs) boot-programs/udc.ccp (7 diffs) devices.hhp (5 diffs) init.config (2 diffs) invoke.ccp (1 diff) mips/nanonote/Makefile.arch (1 diff) source/buzzer.ccp (2 diffs) source/display-emu.ccp (1 diff) source/elfrun.ccp (1 diff) source/lcd.ccp (4 diffs) source/nanonote-gpio.ccp (2 diffs)

Change Details

boot-programs/bootinit.ccp
58	58	void *operator new (unsigned size):
59	59	return new char[size]
60	60
61		static bool have_data_mem, have_fs_mem
62		static Iris::Memory data_mem, fs_mem
63
64	61	// Get the initial block device and filesystem.
65	62	static Iris::Directory receive_devices ():
66		Iris::Caps data, fs
	63	Iris::String data
	64	Iris::Filesystem fs
67	65	bool have_data = false, have_fs = false
68		Iris::Device fs_dev, data_dev
69	66	for unsigned i = 0; i < 2; ++i:
70	67	Iris::wait ()
71	68	if Iris::recv.data[0].l != Iris::Parent::PROVIDE_DEVICE:
...	...
74	71	case Iris::String::ID:
75	72	if have_data:
76	73	Iris::panic (0, "duplicate device.")
77		data_dev = Iris::get_arg ()
	74	data = Iris::get_arg ()
78	75	Iris::recv.reply.invoke ()
79	76	have_data = true
80	77	break
81	78	case Iris::Filesystem::ID:
82	79	if have_fs:
83	80	Iris::panic (0, "duplicate filesystem.")
84		fs_dev = Iris::get_arg ()
	81	fs = Iris::get_arg ()
85	82	Iris::recv.reply.invoke ()
86	83	have_fs = true
87	84	break
88	85	default:
89	86	Iris::panic (Iris::recv.data[1].l, "unexpected device")
90	87	// Initialize the root file system.
91		data = data_dev.create_user (Iris::my_memory)
92		data_dev.use (data)
93		fs = fs_dev.create_user (Iris::my_memory)
94		fs_dev.use (fs)
95		Iris::Filesystem fs_cap = fs.get (0)
96		Iris::Directory root = fs_cap.use_device_ro (data.copy ())
97		have_data_mem = data_dev.call (0).l
98		if have_data_mem:
99		data_mem = Iris::get_arg ()
100		have_fs_mem = fs_dev.call (0).l
101		if have_fs_mem:
102		fs_mem = Iris::get_arg ()
	88	Iris::Directory root = fs.use_device_ro (data.copy ())
103	89	Iris::free_cap (data)
104	90	Iris::free_cap (fs)
105		Iris::free_cap (fs_cap)
106		Iris::free_cap (data_dev)
107		Iris::free_cap (fs_dev)
108	91	return root
109	92
110	93	static bool stringcmp (char const s1, char const s2, unsigned size):
...	...
283	266	if Iris::recv.data[0].l != Iris::Parent::PROVIDE_DEVICE \|\| Iris::recv.data[1].l != Iris::Elfrun::ID:
284	267	Iris::panic (0, "elfrun doesn't provide correct capability")
285	268	Iris::Cap reply = Iris::get_reply ()
286		Iris::Device elfrun_dev = Iris::get_arg ()
	269	Iris::Elfrun elfrun = Iris::get_arg ()
287	270	Iris::my_caps.set (parent_cap.idx (), Iris::Cap (CAP_NONE))
288	271	Iris::free_cap (parent_cap)
289	272	reply.invoke ()
290	273	Iris::free_cap (reply)
291	274
292	275	parent_cap = Iris::my_receiver.create_capability (0)
293		Iris::Caps elfrun = elfrun_dev.create_user (Iris::my_memory)
294		elfrun_dev.use (elfrun)
295		Iris::Elfrun elfrun_cap = elfrun.get (0)
296		Iris::free_cap (elfrun)
297	276	Iris::String init_string = find (root, INIT_NAME)
298		Iris::Caps init_caps = elfrun_cap.run_string (top_memory.copy (), init_string.copy (), parent_cap.copy (), 8, 63)
	277	Iris::Caps init_caps = elfrun.run_string (top_memory.copy (), init_string.copy (), parent_cap.copy (), 8, 63)
299	278
300	279	Iris::Thread init = init_caps.get (__thread_num)
301	280	init.make_priv ()
...	...
319	298	case Iris::Elfrun::ID:
320	299	if have_elfrun:
321	300	Iris::panic (0, "Init requests elfrun twice")
322		Iris::recv.reply.invoke (0, 0, elfrun_cap.copy ())
	301	Iris::recv.reply.invoke (0, 0, elfrun.copy ())
323	302	have_elfrun = true
324	303	break
325	304	default:
...	...
332	311	// Special response: kill boot threads.
333	312	Iris::Cap reply = Iris::get_reply ()
334	313	root.unlock_ro ()
335		if have_data_mem:
336		top_memory.destroy (data_mem)
337		if have_fs_mem:
338		top_memory.destroy (fs_mem)
339	314	reply.invoke ()
340	315	Iris::free_cap (reply)
341	316	top_memory.destroy (Iris::my_memory)

boot-programs/udc.ccp
571	571	__asm__ volatile ("li $a0, 1\nlw $a1, %0\nbreak" :: "m"(logcap.code): "a0", "a1", "memory")
572	572	udc.init ()
573	573	Iris::register_interrupt (IRQ_UDC)
574		Iris::Device fs_dev = Iris::my_receiver.create_capability (FS)
575		Iris::Device data_dev = Iris::my_receiver.create_capability (DATA)
576		Iris::my_parent.provide_device <Iris::Filesystem> (fs_dev.copy ())
577		Iris::my_parent.provide_device <Iris::String> (data_dev.copy ())
578		Iris::free_cap (fs_dev)
579		Iris::free_cap (data_dev)
580		unsigned data_current_user = 0, fs_current_user = 0
581		unsigned next_user
	574	Iris::Filesystem fs = Iris::my_receiver.create_capability (FS)
	575	Iris::String data = Iris::my_receiver.create_capability (DATA)
	576	Iris::my_parent.provide_device <Iris::Filesystem> (fs.copy ())
	577	Iris::my_parent.provide_device <Iris::String> (data.copy ())
	578	Iris::free_cap (fs)
	579	Iris::free_cap (data)
582	580	unsigned state = 0
583	581	while true:
584	582	Iris::wait ()
585	583	Iris::Cap reply = Iris::get_reply ()
586	584	Iris::Cap arg = Iris::get_arg ()
587		switch Iris::recv.protected_data.h:
588		case 0:
589		switch Iris::recv.protected_data.l:
590		case IRQ_UDC:
591		udc.interrupt (state)
592		Iris::register_interrupt (IRQ_UDC)
593		break
594		case LOG:
595		udc.log (Iris::recv.data[0].l)
596		break
597		case FS:
598		Iris::Device::host (FS, fs_current_user, reply, arg)
599		continue
600		case DATA:
601		Iris::Device::host (DATA, data_current_user, reply, arg)
602		continue
603		default:
604		udc.log ('~')
605		char digit[] = "0123456789abcdef"
606		for unsigned i = 0; i < 8; ++i:
607		udc.log (digit[(Iris::recv.protected_data.l >> (4 * (7 - i))) & 0xf])
608		udc.log ('\n')
609		break
	585	switch Iris::recv.protected_data.l:
	586	case IRQ_UDC:
	587	udc.interrupt (state)
	588	Iris::register_interrupt (IRQ_UDC)
	589	break
	590	case LOG:
	591	udc.log (Iris::recv.data[0].l)
610	592	break
611	593	case DATA:
612		if data_current_user != Iris::recv.protected_data.l:
613		break
	594	//kdebug ("data request\n")
614	595	switch Iris::recv.data[0].l:
	596	case Iris::Device::RESET:
615	597	case Iris::String::GET_SIZE:
616	598	case Iris::String::GET_CHARS:
617	599	reply.invoke (0)
...	...
626	608	continue
627	609	break
628	610	case FS:
629		if fs_current_user != Iris::recv.protected_data.l:
630		break
	611	//kdebug ("fs request\n")
631	612	switch Iris::recv.data[0].l:
	613	case Iris::Device::RESET:
	614	reply.invoke (0)
	615	Iris::free_cap (reply)
	616	Iris::free_cap (arg)
	617	continue
632	618	case Iris::Filesystem::USE_DEVICE:
633	619	case Iris::Filesystem::USE_DEVICE_RO:
634		Iris::Directory dir = Iris::my_receiver.create_capability (Iris::Num (0, DIRECTORY))
	620	Iris::Directory dir = Iris::my_receiver.create_capability (DIRECTORY)
635	621	reply.invoke (0, 0, dir.copy ())
636	622	Iris::free_cap (dir)
637	623	Iris::free_cap (reply)
...	...
644	630	continue
645	631	break
646	632	case DIRECTORY:
	633	//kdebug ("dir request\n")
647	634	switch Iris::recv.data[0].l:
648	635	case Iris::Directory::GET_NAME:
649		Iris::Cap name = Iris::my_receiver.create_capability (Iris::Num (Iris::recv.data[1].l, NAME))
	636	Iris::Cap name = Iris::my_receiver.create_capability (Iris::Num (NAME, Iris::recv.data[1].l))
650	637	reply.invoke (0, 0, name.copy ())
651	638	Iris::free_cap (name)
652	639	Iris::free_cap (reply)
...	...
666	653	kdebug ("index out of supported range\n")
667	654	Iris::panic (0)
668	655	//kdebug ("sending file\n")
669		Iris::Cap file = Iris::my_receiver.create_capability (Iris::Num (Iris::recv.data[1].l, FILE))
	656	Iris::Cap file = Iris::my_receiver.create_capability (Iris::Num (FILE, Iris::recv.data[1].l))
670	657	reply.invoke (0, 0, file.copy ())
671	658	Iris::free_cap (file)
672	659	Iris::free_cap (reply)
...	...
680	667	continue
681	668	break
682	669	case FILE:
	670	//kdebug ("file request\n")
683	671	switch Iris::recv.data[0].l:
684	672	case Iris::String::GET_SIZE:
685	673	case Iris::String::GET_CHARS:
686	674	case Iris::String::GET_PAGE:
687		udc.send (Iris::recv.data[0].l \| ((Iris::recv.data[1].l >> PAGE_BITS) << 16), Iris::recv.protected_data.l, reply, arg)
	675	udc.send (Iris::recv.data[0].l \| ((Iris::recv.data[1].l >> PAGE_BITS) << 16), Iris::recv.protected_data.h, reply, arg)
688	676	continue
689	677	default:
690	678	reply.invoke (Iris::ERR_INVALID_OPERATION)
...	...
693	681	continue
694	682	break
695	683	case NAME:
	684	//kdebug ("name request\n")
696	685	switch Iris::recv.data[0].l:
697	686	case Iris::String::GET_SIZE:
698	687	reply.invoke (16)
...	...
701	690	continue
702	691	case Iris::String::GET_CHARS:
703	692	state = Iris::recv.data[0].l
704		udc.send (Iris::Directory::GET_NAME, Iris::recv.protected_data.l, reply, arg)
	693	udc.send (Iris::Directory::GET_NAME, Iris::recv.protected_data.h, reply, arg)
705	694	continue
706	695	default:
707	696	reply.invoke (Iris::ERR_INVALID_OPERATION)
708	697	Iris::free_cap (reply)
709	698	Iris::free_cap (arg)
710	699	continue
	700	default:
	701	kdebug ("other request:")
	702	kdebug_num (Iris::recv.protected_data.l)
	703	kdebug ("\n")
	704	udc.log ('~')
	705	char digit[] = "0123456789abcdef"
	706	for unsigned i = 0; i < 8; ++i:
	707	udc.log (digit[(Iris::recv.protected_data.l >> (4 * (7 - i))) & 0xf])
	708	udc.log ('\n')
	709	break
711	710	reply.invoke ()
712	711	Iris::free_cap (reply)
713	712	Iris::free_cap (arg)

devices.hhp
85	85	struct Device : public Iris::Cap:
86	86	Device (Iris::Cap c = Iris::Cap ()) : Iris::Cap (c):
87	87	enum request:
88		CREATE_USER = WString::ID
89		DESTROY_USER
90		UNUSE
91		USE
	88	RESET = WString::ID
92	89	ID
93		// Create a new user for this device. It will not be the active user.
94		// The provided storage must allow object creation; no other actions may be used by the terminal.
95		Iris::Cap create_user (Iris::Memory storage, unsigned arg1 = 0, Iris::Num arg2 = 0):
96		iocall (storage, Iris::Num (CAP_MASTER_DIRECT \| CREATE_USER, arg1), arg2)
97		return Iris::get_arg ()
98		// Destroy a user. It is made inactive if it was active.
99		void destroy_user (Iris::Cap user):
100		ocall (user, CAP_MASTER_DIRECT \| DESTROY_USER)
101		// Make user inactive.
102		void unuse (Iris::Cap user):
103		ocall (user, CAP_MASTER_DIRECT \| UNUSE)
104		// Make user active. It makes the previous active user inactive.
105		void use (Iris::Cap user):
106		ocall (user, CAP_MASTER_DIRECT \| USE)
107		// Convenience function for threads implementing a device.
108		static void host (unsigned id, unsigned &current_user, Iris::Cap &reply, Iris::Cap &arg, unsigned capssize = 3, unsigned (create)(Iris::Memory mem, Iris::Caps caps) = NULL, void (destroy)(unsigned id, Iris::Caps caps) = NULL, void (use)(unsigned id, Iris::Caps caps) = NULL, void (unuse)(unsigned id, Iris::Caps caps) = NULL):
109		static unsigned last_user
110		switch Iris::recv.data[0].l:
111		case Device::CREATE_USER:
112		Iris::Memory mem (arg)
113		Iris::Caps caps = mem.create_caps (capssize)
114		unsigned user
115		if create:
116		user = create (mem, caps)
117		else:
118		// Increment last_user; skip 0.
119		// FIXME: if this really wraps, it is possible that two users share their id.
120		if !++last_user:
121		++last_user
122		user = last_user
123		Iris::Cap c = Iris::my_receiver.create_capability (Iris::Num (user, id))
124		caps.set (0, c.copy ())
125		caps.set (1, mem.copy ())
126		reply.invoke (0, 0, caps.copy ())
127		Iris::free_cap (c)
128		Iris::free_cap (caps)
129		Iris::free_cap (reply)
130		Iris::free_cap (arg)
131		break
132		case Device::DESTROY_USER:
133		Iris::Caps caps (arg)
134		Iris::Cap c = caps.get (0)
135		Iris::Num user = Iris::my_receiver.get_protected (c)
136		Iris::free_cap (c)
137		if user.h != id:
138		Iris::panic (user.h, "invalid id for destroy")
139		// TODO: unuse.
140		if destroy:
141		destroy (user.l, caps)
142		reply.invoke ()
143		Iris::free_cap (reply)
144		Iris::free_cap (arg)
145		break
146		case Device::USE:
147		Iris::Caps caps (arg)
148		Iris::Cap c = caps.get (0)
149		Iris::Num user = Iris::my_receiver.get_protected (c)
150		Iris::free_cap (c)
151		if user.h != id:
152		Iris::panic (user.h, "invalid id for use")
153		// TODO: send unuse signal.
154		current_user = user.l
155		if use:
156		use (user.l, caps)
157		c = caps.get (2)
158		c.invoke (1)
159		Iris::free_cap (c)
160		reply.invoke ()
161		Iris::free_cap (reply)
162		Iris::free_cap (arg)
163		break
164		case Device::UNUSE:
165		Iris::Caps caps (arg)
166		Iris::Cap c = caps.get (0)
167		Iris::Num user = Iris::my_receiver.get_protected (c)
168		Iris::free_cap (c)
169		if user.h != id:
170		Iris::panic (user.h, "invalid id for unuse")
171		if unuse:
172		unuse (user.l, caps)
173		if user.l == current_user:
174		c = caps.get (2)
175		c.invoke (0)
176		Iris::free_cap (c)
177		current_user = 0
178		reply.invoke ()
179		Iris::free_cap (reply)
180		Iris::free_cap (arg)
181		break
182		default:
183		kdebug ("invalid request\n")
184		reply.invoke (~0)
185		Iris::free_cap (reply)
186		Iris::free_cap (arg)
187		break
	90	// Reset the device. This is called by the terminal while switching owners.
	91	void reset ():
	92	call (CAP_MASTER_DIRECT \| RESET)
188	93
189	94	struct Elfrun : public Iris::Cap:
190	95	Elfrun (Iris::Cap c = Iris::Cap ()) : Iris::Cap (c):
...	...
255	160	call (CAP_MASTER_DIRECT \| EXIT, code)
256	161
257	162	// Keyboard interface.
258		struct Keyboard : public Iris::Cap:
259		Keyboard (Iris::Cap c = Iris::Cap ()) : Iris::Cap (c):
	163	struct Keyboard : public Device:
	164	Keyboard (Iris::Cap c = Iris::Cap ()) : Iris::Device (c):
260	165	enum request:
261	166	SET_CB = Parent::ID
262	167	GET_NUM_KEYS
...	...
276	181	call (CAP_MASTER_DIRECT \| GET_KEYS, first)
277	182
278	183	// Buzzer interface.
279		struct Buzzer : public Iris::Cap:
280		Buzzer (Iris::Cap c = Iris::Cap ()) : Iris::Cap (c):
	184	struct Buzzer : public Device:
	185	Buzzer (Iris::Cap c = Iris::Cap ()) : Iris::Device (c):
281	186	enum request:
282	187	BEEP = Keyboard::ID
283	188	STOP
...	...
290	195	call (CAP_MASTER_DIRECT \| STOP)
291	196
292	197	// Display interface.
293		struct Display : public Iris::Cap:
294		Display (Iris::Cap c = Iris::Cap ()) : Iris::Cap (c):
	198	struct Display : public Device:
	199	Display (Iris::Cap c = Iris::Cap ()) : Iris::Device (c):
295	200	enum request:
296	201	SET_EOF_CB = Buzzer::ID
297	202	MAP_FB
...	...
310	215	Iris::panic (0, "using undefined interface Display::get_info ()")
311	216
312	217	// Numerical setting, such as a display backlight.
313		struct Setting : public Iris::Cap:
314		Setting (Iris::Cap c = Iris::Cap ()) : Iris::Cap (c):
	218	struct Setting : public Iris::Device:
	219	Setting (Iris::Cap c = Iris::Cap ()) : Iris::Device (c):
315	220	enum request:
316	221	SET = Display::ID
317	222	GET_RANGE

init.config
2	2	load driver_lcd = "lcd.elf"
3	3	#load driver_buzzer = "buzzer.elf"
4	4	#load driver_gpio = "gpio.elf"
5		#load ball = "ball.elf"
	5	load ball = "ball.elf"
6	6
7	7	# killbootthreads destroy bootinit, bootfs and bootstore.
8	8	killbootthreads
...	...
26	26	sysreq sysreq
27	27
28	28	# give <name> / <type> [, <index>] = <cap> give this capability to this program when it requests it.
29		#give ball / Display = display
	29	give ball / Display = display
30	30
31	31	# run <name> run a previously loaded program (normally).
32		#run ball
	32	run ball
33	33
34	34	# include <name> include a loaded file as another config file.

invoke.ccp
296	296	reply_cap (CAPTYPE_THREAD \| CAP_MASTER, (unsigned)ret, &ret->refs)
297	297	kdebug ("(created thread ")
298	298	kdebug_num ((unsigned)ret)
299		kdebug (")")
	299	kdebug (")\n")
300	300	else:
301	301	dpanic (0x23311992, "out of memory creating thread")
302	302	reply_num (Iris::ERR_OUT_OF_MEMORY)

mips/nanonote/Makefile.arch
29	29	boot_sources = mips/init.cc mips/nanonote/board.cc
30	30	arch_headers = mips/arch.hh mips/nanonote/jz4740.hh mips/nanonote/board.hh devices.hh
31	31	boot_threads = bootinit udc
32		programs = init gpio lcd display-emu bsquare ball buzzer metronome elfrun
	32	programs = init gpio lcd bsquare ball buzzer metronome elfrun
33	33
34	34	all: test
35	35

source/buzzer.ccp
57	57
58	58	DevBuzzer buzzer
59	59
60		Iris::Device dev = Iris::my_receiver.create_capability (BUZZER)
	60	Iris::Buzzer dev = Iris::my_receiver.create_capability (BUZZER)
61	61	Iris::my_parent.provide_device <Iris::Buzzer> (dev.copy ())
62	62	Iris::free_cap (dev)
63	63	Iris::my_parent.init_done ()
64		unsigned user (~0)
65		unsigned next_user (0)
66	64	while true:
67	65	Iris::wait ()
68		switch Iris::recv.protected_data.h:
69		case ~0:
70		// Alarm.
71		buzzer.stop ()
72		break
73		case 0:
74		switch Iris::recv.protected_data.l:
75		case BUZZER:
76		// Buzzer device control request.
77		Iris::Cap reply = Iris::get_reply ()
78		Iris::Cap arg = Iris::get_arg ()
79		Iris::Device::host (BUZZER, user, reply, arg)
80		break
81		default:
82		kdebug ("invalid buzzer request\n")
83		break
84		break
	66	if Iris::recv.protected_data.h == ~0:
	67	// Alarm.
	68	buzzer.stop ()
	69	break
	70	switch Iris::recv.protected_data.l:
85	71	case BUZZER:
86	72	// Buzzer device user request.
87		if Iris::recv.protected_data.l != user:
88		kdebug ("invalid user requesting buzzer\n")
89		Iris::recv.reply.invoke ()
90		break
91	73	switch Iris::recv.data[0].l:
	74	case Iris::Device::RESET:
	75	buzzer.stop ()
	76	Iris::recv.reply.invoke ()
	77	break
92	78	case Iris::Buzzer::BEEP:
93	79	// Volume is not used by this buzzer.
94	80	Iris::Cap arg = Iris::get_arg ()
...	...
107	93	break
108	94	default:
109	95	kdebug ("Buzzer: unknown num: ")
110		kdebug_num (Iris::recv.protected_data.h)
	96	kdebug_num (Iris::recv.protected_data.l)
111	97	kdebug ("\n")

source/display-emu.ccp
1		#pypp 0
2		// Iris: micro-kernel for a capability-based operating system.
3		// source/display-emu.ccp: Display interface emulation layer.
4		// Copyright 2009 Bas Wijnen <wijnen@debian.org>
5		//
6		// This program is free software: you can redistribute it and/or modify
7		// it under the terms of the GNU General Public License as published by
8		// the Free Software Foundation, either version 3 of the License, or
9		// (at your option) any later version.
10		//
11		// This program is distributed in the hope that it will be useful,
12		// but WITHOUT ANY WARRANTY; without even the implied warranty of
13		// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14		// GNU General Public License for more details.
15		//
16		// You should have received a copy of the GNU General Public License
17		// along with this program. If not, see <http://www.gnu.org/licenses/>.
18
19		#include <devices.hh>
20		#include <iris.hh>
21
22		Iris::Num start ():
23		Iris::Device d = Iris::my_receiver.create_capability (0)
24		Iris::my_parent.provide_device <Iris::Display> (d.copy (), 0x10000)
25		Iris::free_cap (d)
26		Iris::my_parent.init_done ()
27		Iris::Display real = Iris::my_parent.get_device <Iris::Display> (0)
28		while true:
29		Iris::wait ()
30		Iris::Cap arg = Iris::get_arg ()
31		Iris::Cap reply = Iris::get_reply ()
32		switch Iris::recv.protected_data.h:
33		case 0:
34		switch Iris::recv.data[0].l:
35		case Iris::Device::CREATE_USER:
36		Iris::Memory mem (arg)
37		Iris::Caps ret = mem.create_caps (3)
38		Iris::Cap target = Iris::my_receiver.create_capability (Iris::Num (0, 1))
39		ret.set (0, target.copy ())
40		ret.set (1, mem)
41		Iris::free_cap (target)
42		for unsigned i = 0; i < 320 * 240 * 4; i += PAGE_SIZE:
43		Iris::Page p = Iris::my_memory.mapping ((void *)(0x15000 + i))
44		Iris::Page t = mem.create_page ()
45		t.set_flags (Iris::Page::PAYING, Iris::Page::PAYING)
46		p.share (t, Iris::Page::FORGET)
47		mem.map (t, 0x15000 + i)
48		Iris::my_memory.destroy (t)
49		Iris::free_cap (t)
50		Iris::free_cap (p)
51		reply.invoke (0, 0, ret.copy ())
52		Iris::free_cap (ret)
53		break
54		case Iris::Device::DESTROY_USER:
55		Iris::panic (0, "destroying emulation user")
56		case Iris::Device::USE:
57		case Iris::Device::UNUSE:
58		reply.invoke ()
59		break
60		default:
61		kdebug_num (Iris::recv.data[0].l)
62		kdebug ("\n")
63		Iris::panic (0, "invalid emulation command")
64		break
65		case 1:
66		switch Iris::recv.data[0].l:
67		case Iris::Display::SET_EOF_CB:
68		real.set_eof_cb (arg.copy ())
69		while Iris::recv.data[0].l != 0:
70		Iris::my_parent.wait <Iris::Display> (0)
71		real.set_eof_cb (arg.copy ())
72		reply.invoke ()
73		break
74		default:
75		kdebug_num (Iris::recv.data[0].l)
76		kdebug_char ('\n')
77		Iris::panic (Iris::recv.data[0].l, "invalid operation on display emulation")
78		break
79		default:
80		Iris::panic (0, "bug in display emulation")
81		Iris::free_cap (arg)
82		Iris::free_cap (reply)

source/elfrun.ccp
234	234	Iris::Num start ():
235	235	kdebug ("elfrun started.\n")
236	236	init_alloc ()
237		Iris::Device dev = Iris::my_receiver.create_capability (0)
	237	Iris::Elfrun dev = Iris::my_receiver.create_capability (0)
238	238	Iris::my_parent.provide_device <Iris::Elfrun> (dev.copy ())
	239	Iris::free_cap (dev)
239	240
240		unsigned user = ~0
241	241	while true:
242	242	Iris::wait ()
243	243	Iris::Cap reply = Iris::get_reply ()
244	244	Iris::Cap arg = Iris::get_arg ()
245		Iris::print_caps ()
246		switch Iris::recv.protected_data.h:
247		case 0:
248		Iris::Device::host (1, user, reply, arg)
	245	switch Iris::recv.data[0].l:
	246	case Iris::Elfrun::RUN_STRING:
	247	unsigned num_slots = Iris::recv.data[1].l
	248	unsigned num_caps = Iris::recv.data[1].h
	249	parent_memory = Iris::Caps (arg).get (Iris::Elfrun::PARENT_MEMORY)
	250	parent = Iris::Caps (arg).get (Iris::Elfrun::PARENT)
	251	Iris::String data = Iris::Caps (arg).get (Iris::Elfrun::DATA)
	252	map_string (data)
	253	Iris::Caps ret = run (data, parent_memory, parent, num_slots, num_caps)
	254	reply.invoke (0, 0, ret.copy ())
	255	free_cap (ret)
	256	free_cap (parent_memory)
	257	free_cap (parent)
	258	free_cap (data)
249	259	break
250		case 1:
251		switch Iris::recv.data[0].l:
252		case Iris::Elfrun::RUN_STRING:
253		unsigned num_slots = Iris::recv.data[1].l
254		unsigned num_caps = Iris::recv.data[1].h
255		parent_memory = Iris::Caps (arg).get (Iris::Elfrun::PARENT_MEMORY)
256		parent = Iris::Caps (arg).get (Iris::Elfrun::PARENT)
257		Iris::String data = Iris::Caps (arg).get (Iris::Elfrun::DATA)
258		map_string (data)
259		Iris::Caps ret = run (data, parent_memory, parent, num_slots, num_caps)
260		reply.invoke (0, 0, ret.copy ())
261		free_cap (ret)
262		free_cap (parent_memory)
263		free_cap (parent)
264		free_cap (data)
265		break
266		case Iris::Elfrun::RUN_CAPS:
267		unsigned num_slots = Iris::recv.data[1].l
268		unsigned num_caps = Iris::recv.data[1].h
269		unsigned p = Iris::recv.data[0].h
270		parent_memory = Iris::Caps (arg).get (Iris::Elfrun::PARENT_MEMORY)
271		parent = Iris::Caps (arg).get (Iris::Elfrun::PARENT)
272		Iris::Caps data = Iris::Caps (arg).get (Iris::Elfrun::DATA)
273		map_caps (data, p)
274		Iris::Caps ret = run (data, parent_memory, parent, num_slots, num_caps)
275		reply.invoke (0, 0, ret.copy ())
276		free_cap (ret)
277		free_cap (parent_memory)
278		free_cap (parent)
279		free_cap (data)
280		break
281		default:
282		Iris::panic (0, "invalid operation for elfrun")
283		reply.invoke (~0)
284		break
285		Iris::free_cap (arg)
286		Iris::free_cap (reply)
	260	case Iris::Elfrun::RUN_CAPS:
	261	unsigned num_slots = Iris::recv.data[1].l
	262	unsigned num_caps = Iris::recv.data[1].h
	263	unsigned p = Iris::recv.data[0].h
	264	parent_memory = Iris::Caps (arg).get (Iris::Elfrun::PARENT_MEMORY)
	265	parent = Iris::Caps (arg).get (Iris::Elfrun::PARENT)
	266	Iris::Caps data = Iris::Caps (arg).get (Iris::Elfrun::DATA)
	267	map_caps (data, p)
	268	Iris::Caps ret = run (data, parent_memory, parent, num_slots, num_caps)
	269	reply.invoke (0, 0, ret.copy ())
	270	free_cap (ret)
	271	free_cap (parent_memory)
	272	free_cap (parent)
	273	free_cap (data)
	274	break
	275	default:
	276	Iris::panic (0, "invalid operation for elfrun")
	277	reply.invoke (~0)
	278	break
	279	Iris::free_cap (arg)
	280	Iris::free_cap (reply)

source/lcd.ccp
369	369	Iris::free_cap (backlight)
370	370
371	371	// Register the display device.
372		Iris::Cap display = Iris::my_receiver.create_capability (LCD)
	372	Iris::Display display = Iris::my_receiver.create_capability (LCD)
373	373	Iris::my_parent.provide_device <Iris::Display> (display.copy ())
374	374	Iris::free_cap (display)
375	375	Iris::my_parent.init_done ()
...	...
377	377	Iris::Cap eof_cb
378	378	bool have_eof = false
379	379	is_on = true
380		unsigned lcd_user = 0
381		unsigned current_backlight = 0
382	380	while true:
383	381	Iris::wait ()
384	382	//log_msg ()
385		switch Iris::recv.protected_data.h:
386		case 0:
387		switch Iris::recv.protected_data.l:
388		case IRQ_LCD:
389		have_eof = false
390		eof_cb.invoke ()
391		Iris::free_cap (eof_cb)
392		break
393		#if defined (TRENDTAC)
394		case LOG:
395		log_char (Iris::recv.data[0].l)
396		break
397		#endif
398		case BACKLIGHT:
399		Iris::Cap reply = Iris::get_reply ()
400		Iris::Cap arg = Iris::get_arg ()
401		Iris::Device::host (BACKLIGHT, current_backlight, reply, arg)
402		break
403		case LCD:
404		Iris::Cap reply = Iris::get_reply ()
405		Iris::Cap arg = Iris::get_arg ()
406		Iris::Device::host (LCD, lcd_user, reply, arg, 3, create, destroy, use, unuse)
407		break
408		default:
409		Iris::panic (Iris::recv.protected_data.l, "invalid operation for master lcd")
410		break
	383	switch Iris::recv.protected_data.l:
	384	case IRQ_LCD:
	385	have_eof = false
	386	eof_cb.invoke ()
	387	Iris::free_cap (eof_cb)
	388	break
	389	#if defined (TRENDTAC)
	390	case LOG:
	391	log_char (Iris::recv.data[0].l)
411	392	break
	393	#endif
412	394	case BACKLIGHT:
413		if current_backlight != Iris::recv.protected_data.l:
414		log_char ('&')
415		log_num (current_backlight)
416		log_num (Iris::recv.protected_data)
417		log_char ('\n')
418		break
419	395	switch Iris::recv.data[0].l:
	396	case Iris::Device::RESET:
	397	Iris::recv.reply.invoke ()
	398	break
420	399	case Iris::Setting::SET:
421	400	// TODO
422	401	unsigned state = Iris::recv.data[1].l
...	...
444	423	break
445	424	break
446	425	case LCD:
447		if descriptor.frame != Iris::recv.protected_data.l:
448		//Iris::panic (0, "invalid user requesting lcd")
449		Iris::recv.reply.invoke (~0)
450		break
451	426	switch Iris::recv.data[0].l:
	427	case Iris::Device::RESET:
	428	Iris::recv.reply.invoke ()
	429	break
452	430	case Iris::Display::SET_EOF_CB:
453	431	Iris::Cap reply = Iris::get_reply ()
454	432	Iris::Cap arg = Iris::get_arg ()
...	...
469	447	Iris::panic (Iris::recv.data[0].l, "invalid operation for lcd")
470	448	break
471	449	default:
472		Iris::panic (0, "invalid master operation type for lcd")
	450	Iris::panic (0, "invalid operation type for lcd")
473	451	break

source/nanonote-gpio.ccp
211	211	Iris::my_parent.init_done ()
212	212	if kbd.scanning ():
213	213	Iris::my_receiver.set_alarm (SCAN_INTERVAL)
214		unsigned user (0), power_user (0)
215		unsigned next_user (0)
216	214	Iris::register_interrupt (IRQ_GPIO3)
217	215	while true:
218	216	Iris::wait ()
219		switch Iris::recv.protected_data.h:
220		case ~0:
221		// Alarm.
	217	if Iris::recv.protected_data.h == ~0:
	218	// Alarm.
	219	kbd.scan ()
	220	if kbd.scanning ():
	221	Iris::my_receiver.set_alarm (SCAN_INTERVAL)
	222	continue
	223	switch Iris::recv.protected_data.l:
	224	case IRQ_GPIO3:
	225	// Interrupt.
	226	pwr.scan ()
222	227	kbd.scan ()
223	228	if kbd.scanning ():
224	229	Iris::my_receiver.set_alarm (SCAN_INTERVAL)
225		break
226		case 0:
227		switch Iris::recv.protected_data.l:
228		case IRQ_GPIO3:
229		// Interrupt.
230		pwr.scan ()
231		kbd.scan ()
232		if kbd.scanning ():
233		Iris::my_receiver.set_alarm (SCAN_INTERVAL)
234		Iris::register_interrupt (IRQ_GPIO3)
235		break
236		case PWR:
237		// Power button request.
238		Iris::Cap reply = Iris::get_reply ()
239		Iris::Cap arg = Iris::get_arg ()
240		Iris::Device::host (PWR, power_user, reply, arg)
241		break
242		case KBD_DEV:
243		// Keyboard device control request.
244		Iris::Cap reply = Iris::get_reply ()
245		Iris::Cap arg = Iris::get_arg ()
246		Iris::Device::host (KBD_DEV, user, reply, arg)
247		break
248		default:
249		break
	230	Iris::register_interrupt (IRQ_GPIO3)
250	231	break
251	232	case KBD_DEV:
252	233	// Keyboard device user request.
253		if Iris::recv.protected_data.l != user:
254		kdebug ("invalid user requesting keyboard\n")
255		Iris::recv.reply.invoke ()
256		break
257	234	switch Iris::recv.data[0].l:
	235	case Iris::Device::RESET:
	236	Iris::recv.reply.invoke ()
	237	break
258	238	case Iris::Keyboard::SET_CB:
259	239	Iris::Cap reply = Iris::get_reply ()
260	240	kbd.active (Iris::get_arg ())
...	...
272	252	break
273	253	break
274	254	case PWR:
275		if Iris::recv.protected_data.l != power_user:
276		kdebug ("invalid user requesting power\n")
277		Iris::recv.reply.invoke ()
278		break
279	255	switch Iris::recv.data[0].l:
	256	case Iris::Device::RESET:
	257	Iris::recv.reply.invoke ()
	258	break
280	259	case Iris::Keyboard::SET_CB:
281	260	Iris::Cap reply = Iris::get_reply ()
282	261	pwr.set_cb (Iris::get_arg ())

Download the corresponding diff file

Branches:
master

iris

iris Commit Details

Change Details

interactive