コード例 #1
0
ファイル: test4.c プロジェクト: jpamorim/feup-lcom
int test_scan(void) {
	int r;
	unsigned long data = 0, irq_set;
	irq_set = kbd_subscribe_int();
	int ipc_status;
	message msg;
	int i = 0;

	while (data != BREAK_ESC){
		if ( r = driver_receive(ANY, &msg, &ipc_status) != 0 ) {
			printf("driver_receive failed with: %d", r);
			continue;}
		if (is_ipc_notify(ipc_status)) { /* received notification */
			switch (_ENDPOINT_P(msg.m_source)) {
			case HARDWARE: /* hardware interrupt notification */
				if (msg.NOTIFY_ARG &irq_set) {
					data = kbd_read_out();
					if(1 << 7 & data)
						printf("Break: 0x%X \n", data);
					else printf("Make: 0x%X \n", data);
				}break;
			default: break;
			}
		}
	}
	kbd_unsubscribe_int();
	return 0;
}
コード例 #2
0
ファイル: kbd.c プロジェクト: joaofidalgo23/feup-lcom
int kbd_test_scan(unsigned short ass) {
	int irq_set = kbd_subscribe_int();
	int ipc_status;
	message msg;
	unsigned char result = 0;
	if (irq_set == ERROR) {
		printf("kbd_test_scan()::kernel call didn't return 0\n");
		return ERROR;
	}
	while (result != KEY_ESC) {
		if (driver_receive(ANY, &msg, &ipc_status) != OK) {
			printf("kbd_test_scan()::driver_receive failed\n");
			continue;
		}
		if (is_ipc_notify(ipc_status)) {
			switch (_ENDPOINT_P(msg.m_source)) {
			case HARDWARE:
				if (msg.NOTIFY_ARG & irq_set) {
					if (ass) {
						result = kbd_int_handler_asm();
					} else {
						result = kbd_int_handler_C();
					}
					if (result == KEY_ESC) {
						printf(
								"kbd_test_scan()::esc was pressed, press any key to continue\n");
					}
				}
				break;
			}
		}
	}
	kbd_unsubscribe_int();
	return 0;
}
コード例 #3
0
ファイル: main.c プロジェクト: AgamAgarwal/minix
/*===========================================================================*
 *				main					     *
 *===========================================================================*/
int main(int argc, char *argv[])
{
	message m_out;
	int r, ipc_status;
	size_t size;

	/* SEF local startup. */
	env_setargs(argc, argv);
	sef_local_startup();

	for (;;) {
		/* Wait for request. */
		if(driver_receive(ANY, &m_in, &ipc_status) != OK) {
			panic("driver_receive failed");
		}

#if DEBUG2
		printf("Filter: got request %d from %d\n",
			m_in.m_type, m_in.m_source);
#endif

		if(m_in.m_source == DS_PROC_NR && is_ipc_notify(ipc_status)) {
			ds_event();
			continue;
		}

		who_e = m_in.m_source;
		req_id = m_in.BDEV_ID;
		grant_id = m_in.BDEV_GRANT;
		size = 0;

		/* Forword the request message to the drivers. */
		switch(m_in.m_type) {
		case BDEV_OPEN:		/* open/close is a noop for filter. */
		case BDEV_CLOSE:	r = OK;				break;
		case BDEV_READ:		r = do_rdwt(FLT_READ);		break;
		case BDEV_WRITE:	r = do_rdwt(FLT_WRITE);		break;
		case BDEV_GATHER:	r = do_vrdwt(FLT_READ);		break;
		case BDEV_SCATTER:	r = do_vrdwt(FLT_WRITE);	break;
		case BDEV_IOCTL:	r = do_ioctl(&m_in);		break;

		default:
			printf("Filter: ignoring unknown request %d from %d\n", 
				m_in.m_type, m_in.m_source);
			continue;
		}

#if DEBUG2
		printf("Filter: replying with code %d\n", r);
#endif

		/* Send back reply message. */
		m_out.m_type = BDEV_REPLY;
		m_out.BDEV_ID = req_id;
		m_out.BDEV_STATUS = r;
		send(who_e, &m_out);
	}

	return 0;
}
コード例 #4
0
ファイル: timer.c プロジェクト: gtugablue/LCOM-Racinix
int timer_test_int(unsigned long time) {
	if (timer_subscribe_int())
	{
		return 1;
	}
	int r, ipc_status;
	message msg;
	time_counter = 0;
	while (time_counter <= time * TIMER_DEFAULT_FREQ)
	{
		/* Get a request message. */
		if ((r = driver_receive(ANY, &msg, &ipc_status)) != 0) {
			printf("driver_receive failed with: %d", r);
			continue;
		}
		if (is_ipc_notify(ipc_status)) { /* received notification */
			switch (_ENDPOINT_P(msg.m_source)) {
			case HARDWARE: /* hardware interrupt notification */
				if (msg.NOTIFY_ARG & BIT(TIMER0_HOOK_BIT)) { /////// /* subscribed interrupt */
					timer_int_handler();
					if(time_counter % TIMER_DEFAULT_FREQ == 0)
					{
						printf("Segundos decorridos: %d\n", time_counter / TIMER_DEFAULT_FREQ);
					}
				}
				break;
			default:
				break; /* no other notifications expected: do nothing */
			}
		} else { /* received a standard message, not a notification */
			/* no standard messages expected: do nothing */
		}
	}
	return timer_unsubscribe_int();
}
コード例 #5
0
ファイル: keyboard.c プロジェクト: joaoacsoares/LCOM
int kbd_test_scan_C(void) {
	int r;
	unsigned long data = 0, irq_set;
	int ipc_status;
	message msg;

	irq_set = kbd_subscribe_int();

	while (data != ESC_CODE){
		if ( r = driver_receive(ANY, &msg, &ipc_status) != 0 ) {
			printf("driver_receive failed with: %d", r);
			continue;}
		if (is_ipc_notify(ipc_status)) { /* received notification */
			switch (_ENDPOINT_P(msg.m_source)) {
			case HARDWARE: /* hardware interrupt notification */
				if (msg.NOTIFY_ARG &BIT(irq_set)) {
					data = kbd_read_buff();
					if(BIT(7) & data)
						printf("Break code: 0x%2X", data);
					else
						printf("Make code: 0x%2X", data);
					printf("\n ----///---- \n");
				}break;
			default: break;
			}
		}
	}
	kbd_unsubscribe_int();
	return 0;
}
コード例 #6
0
ファイル: sb16_dsp.c プロジェクト: Spenser309/CS551
/*===========================================================================*
 *				dsp_write
 *===========================================================================*/
PRIVATE void dsp_write(const message *m_ptr)
{
	message mess;
	int ipc_status;
	
	dprint("sb16_dsp.c: dsp_write()\n");

	if(m_ptr->COUNT != DspFragmentSize) {
		reply(TASK_REPLY, m_ptr->m_source, m_ptr->IO_ENDPT, EINVAL);
		return;
	}
	if(m_ptr->m_type != DmaMode && DmaBusy >= 0) {
		reply(TASK_REPLY, m_ptr->m_source, m_ptr->IO_ENDPT, EBUSY);
		return;
	}
	
	reply(TASK_REPLY, m_ptr->m_source, m_ptr->IO_ENDPT, SUSPEND);
	is_processing = TRUE;

	if(DmaBusy < 0) { /* Dma tranfer not yet started */

		DmaMode = DEV_WRITE_S;           /* Dma mode is writing */
		sys_datacopy(m_ptr->IO_ENDPT, (vir_bytes)m_ptr->ADDRESS, SELF, (vir_bytes)DmaPtr, (phys_bytes)DspFragmentSize);
		dsp_dma_setup(DmaPhys, DspFragmentSize * DMA_NR_OF_BUFFERS);
		dsp_setup();
		DmaBusy = 0;         /* Dma is busy */
		dprint(" filled dma[0]\n");
		DmaFillNext = 1;

	} else if(DmaBusy != DmaFillNext) { /* Dma transfer started, but Dma buffer not yet full */

		sys_datacopy(m_ptr->IO_ENDPT, (vir_bytes)m_ptr->ADDRESS, SELF, (vir_bytes)DmaPtr + DmaFillNext * DspFragmentSize, (phys_bytes)DspFragmentSize);
		dprint(" filled dma[%d]\n", DmaFillNext);
		DmaFillNext = (DmaFillNext + 1) % DMA_NR_OF_BUFFERS;

	} else if(BufReadNext < 0) { /* Dma buffer full, fill first element of second buffer */ 

		sys_datacopy(m_ptr->IO_ENDPT, (vir_bytes)m_ptr->ADDRESS, SELF, (vir_bytes)Buffer, (phys_bytes)DspFragmentSize);
		dprint(" filled buf[0]\n");
		BufReadNext = 0;
		BufFillNext = 1;

	} else { /* Dma buffer is full, filling second buffer */ 

		while(BufReadNext == BufFillNext) { /* Second buffer also full, wait for space to become available */ 
			driver_receive(HARDWARE, &mess, &ipc_status);
			dsp_hardware_msg();
		}
		sys_datacopy(m_ptr->IO_ENDPT, (vir_bytes)m_ptr->ADDRESS, SELF, (vir_bytes)Buffer + BufFillNext * DspFragmentSize, (phys_bytes)DspFragmentSize);
		dprint(" filled buf[%d]\n", BufFillNext);
		BufFillNext = (BufFillNext + 1) % DSP_NR_OF_BUFFERS;

	} 
	
	is_status_msg_expected = TRUE;
	revivePending = 1;
	reviveStatus = DspFragmentSize;
	reviveProcNr = m_ptr->IO_ENDPT;
	notify(m_ptr->m_source);
}
コード例 #7
0
ファイル: acpi.c プロジェクト: DragonQuan/minix3
int main(void)
{
	int err;
	message m;
	int ipc_status;

	sef_local_startup();

	for(;;) {
		err = driver_receive(ANY, &m, &ipc_status);
		if (err != OK) {
			printf("ACPI: driver_receive failed: %d\n", err);
			continue;
		}

		switch (((struct acpi_request_hdr *)&m)->request) {
		case ACPI_REQ_GET_IRQ:
			do_get_irq(&m);
			break;
		case ACPI_REQ_MAP_BRIDGE:
			do_map_bridge(&m);
			break;
		default:
			printf("ACPI: ignoring unsupported request %d "
				"from %d\n",
				((struct acpi_request_hdr *)&m)->request,
				((struct acpi_request_hdr *)&m)->m_source);
		}

		err = send(m.m_source, &m);
		if (err != OK) {
			printf("ACPI: send failed: %d\n", err);
		}
	}
}
コード例 #8
0
ファイル: test4.c プロジェクト: joaofidalgo23/LCOM
int test_gesture(short length, unsigned short tolerance) {
	int ipc_status;
	message msg;
	int receive;
	int validation = 1;
	sumOfX = 0;
	int irq_set = mouse_subscribe();
	unsigned long clean;
	counter = 0;
	interrupts = 0;
	while (validation) {
		receive = driver_receive(ANY, &msg, &ipc_status);
		if (receive != 0) {
			printf("driver_receive failed with: %d", receive);
			continue;
		}

		if (is_ipc_notify(ipc_status)) {
			switch (_ENDPOINT_P(msg.m_source)) {
			case HARDWARE:
				if (msg.NOTIFY_ARG & irq_set) {
					validation = gesture_handler(length, tolerance);
				}
				break;
			default:
				break;
			}
		} else {
		}
	}
	mouse_unsubscribe();
	printf("\n\tpress ANY KEY to continue\n");
	mouse_read(&clean); //Clean the buffer
	return 0;
}
コード例 #9
0
ファイル: test4.c プロジェクト: joaofidalgo23/LCOM
int test_packet(unsigned short cnt) {
	int i = 0;
	int ipc_status;
	message msg;
	int receive;
	int irq_set = mouse_subscribe();
	unsigned long clean;
	counter = 0;
	interrupts = 0;
	while (i < cnt * 3) {
		receive = driver_receive(ANY, &msg, &ipc_status);
		if (receive != 0) {
			printf("driver_receive failed with: %d", receive);
			continue;
		}

		if (is_ipc_notify(ipc_status)) {
			switch (_ENDPOINT_P(msg.m_source)) {
			case HARDWARE:
				if (msg.NOTIFY_ARG & irq_set) {
					mouse_handler();
					i++;
				}
				break;
			default:
				break;
			}
		} else {
		}
	}
	mouse_unsubscribe();
	printf("\n\tpress ANY KEY to continue\n");
	mouse_read(&clean); //Clean the buffer
	return 0;
}
コード例 #10
0
ファイル: test5.c プロジェクト: Digas29/LCOM-FROGGER
int test_square(unsigned short x, unsigned short y, unsigned short size, unsigned long color) {
	vg_init(GRAPHIC_MODE);

	int ipc_status;
	message msg;
	int request;
	int irq_set;

	irq_set = subscribe_kbd();

	while (scanCode != EXIT_MAKE_CODE) {
		request = driver_receive(ANY, &msg, &ipc_status);
		if (request != 0) {
			printf("driver_receive failed with: %d", request);
			continue;
		}
		if (is_ipc_notify(ipc_status)) {
			switch (_ENDPOINT_P(msg.m_source)) {
			case HARDWARE:
				if (msg.NOTIFY_ARG & irq_set) {
					kbd_handler();
				}
				vg_draw_rectangle(x,y,size,size,color);
				break;
			default:
				break;
			}
		}
		else {
		}
	}
	unsubscribe_kbd();
	vg_exit();
	return 0;
}
コード例 #11
0
ファイル: test6.c プロジェクト: gtugablue/LCOM-Racinix
int test_date()
{
	int ipc_status;
	message msg;
	unsigned int i=0;
	unsigned rtc_hook_id;
	rtc_subscribe_int(&rtc_hook_id);

	while(1)
	{
		if (driver_receive(ANY, &msg, &ipc_status) != 0)
		{
			if (is_ipc_notify(ipc_status))
			{ /* received notification */
				switch (_ENDPOINT_P(msg.m_source))
				{
				case HARDWARE: /* hardware interrupt notification */
					if (msg.NOTIFY_ARG & (1 << RTC_HOOK))
					{ /* subscribed interrupt */
						i++;
					}
					break;
				default:
					break;
				}
			}
		}
	}

	rtc_unsubscribe_int(rtc_hook_id);
	sys_outb(RTC_ADDR_REG, RTC_CTRL_REG_B); ///
}
コード例 #12
0
ファイル: proj.c プロジェクト: bernardobelchior1/feup-lcom
int start() {
	unsigned short character = 0x00;
	int ipc_status;
	message msg;
	int irq_set_kb = kb_subscribe_int();
	int irq_set_timer = timer_subscribe_int();
	int irq_set_mouse = mouse_subscribe_int();
	int r;
	unsigned char packet[3];
	unsigned short counter = 0;

	space_invaders_font = font_init("spaceinvader_font_transparent.bmp");
	srand(1);
	options_load();
	mouse_init();
	init_state();
	highscore_load();
	vg_init(VBE_VIDEO_MODE);

	while (1) { //TODO change condition
		/* Get a request message. */
		if ((r = driver_receive(ANY, &msg, &ipc_status)) != 0) {
			printf("driver_receive failed with: %d", r);
			continue;
		}
		if (is_ipc_notify(ipc_status)) { /* received notification */
			switch (_ENDPOINT_P(msg.m_source)) {
			case HARDWARE: /* hardware interrupt notification */
				if (msg.NOTIFY_ARG & irq_set_kb) { /* keyboard interrupt */
					character = kb_int_handler();
					if (character != KB_2BYTE_SCODE)
						kb_event_handler(character);
				}
				if (msg.NOTIFY_ARG & irq_set_mouse){ /* mouse interrupt */
					mouse_int_handler(counter, packet);
					if(packet[0] != MOUSE_ACK && (packet[0] & BIT(3)))
						counter++;
					if(counter == 3){
						counter = 0;
						mouse_event_handler(packet);
					}

				}
				if (msg.NOTIFY_ARG & irq_set_timer){ /* timer interrupt */
					timer_int_handler();
				}
				break;
			default:
				break; /* no other notifications expected: do nothing */
			}
		}
		else { /* received a standard message, not a notification */
			/* no standard messages expected: do nothing */
		}
	}

	return 0;
}
コード例 #13
0
ファイル: test3.c プロジェクト: mgpsp/LCOM-FEUP
int kbd_test_timed_scan(unsigned short n)
{
	int ipc_status, r, exit = 0, max, counter = 0, flag = 0;
	unsigned long irq1, irq2, data;
	message msg;

	irq2 = subscribe_int(TIMER0_IRQ, IRQ_REENABLE, &timer0_id);
	irq1 = subscribe_int(KB_IRQ, IRQ_REENABLE | IRQ_EXCLUSIVE, &kb_id);
	if (irq1 == -1 || irq2 == -1) return -1;  // check if subscribe_int failed

	max = n*60;

	do
	{
		r = driver_receive(ANY, &msg, &ipc_status);
		if (r != 0)
		{
			printf("driver_receive failed with: %d", r);
			continue;
		}

		if (is_ipc_notify(ipc_status))
		{
			switch (_ENDPOINT_P(msg.m_source))
			{
			case HARDWARE:
				if (msg.NOTIFY_ARG & irq1)
				{
					counter = 0;
					data = keyboard_handler(0);
					flag = print_scancodes(data, flag);
					if (data == ESC)
					{
						printf("Done\n");
						exit = 1;
					}
				}
				if (msg.NOTIFY_ARG & irq2)
				{
					counter++;
					if (counter >= max)
					{
						printf("Done\n");
						exit = 1;
					}
				}
				break;
			default:
				break;
			}
		}
	} while (exit == 0);

	unsubscribe_int(&kb_id);
	unsubscribe_int(&timer0_id);

	return 0;
}
コード例 #14
0
ファイル: menu.c プロジェクト: ricardocerq/FEUP-LCOM
int main_menu()
{
	continue_condition = true;
	fade_condition = false;
	function_to_call = NULL;
	darken = 127;
	int failure = 0;
	initialize_main_menu_buttons();
	int ipc_status;
	message msg;
	int r;
	char * display_name = (char*)malloc(sizeof(char) * strlen("Player name: ")+MAX_PLAYER_NAME_LENGTH);
	strcpy(display_name, "Player name: ");
	display_name = strcat(display_name, get_program_playername());
	if(!failure){
		do{
			/* Get a request message. */
			if ( (r = driver_receive(ANY, &msg, &ipc_status)) != 0 ) {
				printf("driver_receive failed with: %d", r);
				continue;
			}
			if (is_ipc_notify(ipc_status)) { /* received notification */
				switch (_ENDPOINT_P(msg.m_source)) {
				case HARDWARE: /* hardware interrupt notification */
					if (msg.NOTIFY_ARG & get_kbd_irq_set()){  /* subscribed kbd interrupt */
						kbd_int_handler();
					}
					if (msg.NOTIFY_ARG & get_rtc_irq_set()) { /* subscribed timer interrupt */
						if(rtc_ih())
							failure = 1;
						getDateString(get_date_str_ptr());
					}
					if(msg.NOTIFY_ARG & get_timer_irq_set()){
						timer_int_handler();
						main_menu_render();
					}
					if (msg.NOTIFY_ARG & get_mouse_irq_set()) { /* subscribed timer interrupt */
						mouse_int_handler();
				}
					break;
				default:
					break; /* no other notifications expected: do nothing */
				}
			} else {/* received a standard message, not a notification */
				/* no standard messages expected: do nothing */
			}
			if(mouse_is_updated())
			{
				assign_mouse(get_previous_mouse(), get_mouse());
				assign_mouse(get_mouse(), get_mouse_state());
				main_menu_mouse_event(get_previous_mouse(), get_mouse());
				move_cursor(get_cursor(), get_mouse()->coords);
			}
		} while(continue_condition);
	}
	return failure;
}
コード例 #15
0
ファイル: test5.c プロジェクト: ricardocerq/FEUP-LCOM
int test_line(unsigned short xi, unsigned short yi, 
		           unsigned short xf, unsigned short yf, unsigned long color) {
	
	char* video_mem = NULL;
	int failure =0;
	if((video_mem=(char *)vg_init(VBE_MODE_RES_1024x768)) == NULL)
	{
		printf("test_line(): vg_init() failed");
		return 1;
	}
	draw_line(video_mem,xi,yi, xf,yf,color);
	int kbd_irq_set = 0;
	if((kbd_irq_set = kbd_subscribe_int(0)) < 0){//subscribe kbd interrupts
		printf("test_line(): kbd_subscribe_int() failed \n");
		failure = 1;
	}
	int ipc_status;
	message msg;
	int r;
	if(!failure){
		do{
			/* Get a request message. */
			if ( (r = driver_receive(ANY, &msg, &ipc_status)) != 0 ) {
				printf("driver_receive failed with: %d", r);
				continue;
			}
			if (is_ipc_notify(ipc_status)) { /* received notification */
				switch (_ENDPOINT_P(msg.m_source)) {
				case HARDWARE: /* hardware interrupt notification */
					if (msg.NOTIFY_ARG & kbd_irq_set) { /* subscribed kbd interrupt */
						if(kbd_int_handler())
							failure = 1;
					}
					break;
				default:
					break; /* no other notifications expected: do nothing */
				}
			} else {/* received a standard message, not a notification */
				/* no standard messages expected: do nothing */
			}
		} while(get_scancode() != ESC_BREAK && !failure);
	}
	if(kbd_unsubscribe_int()){//unsubscribe interrupts
		printf("test_square(): kbd_unsubscribe_int() failed\n");
		failure = 1;
	}
	printf("Done\n");

	if(vg_exit()){
		printf("test_line(): vg_exit() failed");
		return 1;
	}
	return failure;
	
}
コード例 #16
0
ファイル: main.c プロジェクト: Spenser309/CS551
int main(void)
{
	int r;
	message m;
	int ipc_status;

	/* SEF local startup. */
	sef_local_startup();

	for(;;)
	{
		r= driver_receive(ANY, &m, &ipc_status);
		if (r < 0)
		{
			printf("PCI: driver_receive failed: %d\n", r);
			break;
		}

		if (is_ipc_notify(ipc_status)) {
			printf("PCI: got notify from %d\n", m.m_source);

			/* done, get a new message */
			continue;
		}

		switch(m.m_type)
		{
		case BUSC_PCI_INIT: do_init(&m); break;
		case BUSC_PCI_FIRST_DEV: do_first_dev(&m); break;
		case BUSC_PCI_NEXT_DEV: do_next_dev(&m); break;
		case BUSC_PCI_FIND_DEV: do_find_dev(&m); break;
		case BUSC_PCI_IDS: do_ids(&m); break;
		case BUSC_PCI_DEV_NAME: do_dev_name(&m); break;
		case BUSC_PCI_RESERVE: do_reserve(&m); break;
		case BUSC_PCI_ATTR_R8: do_attr_r8(&m); break;
		case BUSC_PCI_ATTR_R16: do_attr_r16(&m); break;
		case BUSC_PCI_ATTR_R32: do_attr_r32(&m); break;
		case BUSC_PCI_ATTR_W8: do_attr_w8(&m); break;
		case BUSC_PCI_ATTR_W16: do_attr_w16(&m); break;
		case BUSC_PCI_ATTR_W32: do_attr_w32(&m); break;
		case BUSC_PCI_RESCAN: do_rescan_bus(&m); break;
		case BUSC_PCI_DEV_NAME_S: do_dev_name_s(&m); break;
		case BUSC_PCI_SLOT_NAME_S: do_slot_name_s(&m); break;
		case BUSC_PCI_SET_ACL: do_set_acl(&m); break;
		case BUSC_PCI_DEL_ACL: do_del_acl(&m); break;
		case BUSC_PCI_GET_BAR: do_get_bar(&m); break;
		default:
			printf("PCI: got message from %d, type %d\n",
				m.m_source, m.m_type);
			break;
		}
	}

	return 0;
}
コード例 #17
0
ファイル: sb16_dsp.c プロジェクト: Spenser309/CS551
/*===========================================================================*
 *				main
 *===========================================================================*/
PUBLIC int main(int argc, char *argv[]) 
{	
	int r;
	endpoint_t caller;
	int proc_nr;
	message mess;
	int ipc_status;

	/* SEF local startup. */
	sef_local_startup();

	while(TRUE) {
		/* Wait for an incoming message */
		driver_receive(ANY, &mess, &ipc_status);

		caller = mess.m_source;
		proc_nr = mess.IO_ENDPT;

		if (is_ipc_notify(ipc_status)) {
			switch (_ENDPOINT_P(mess.m_source)) {
				case HARDWARE:
					dsp_hardware_msg();
					continue; /* don't reply */
				default:
					r = EINVAL;
			}

			/* dont with this message */
			goto send_reply;
		}

		/* Now carry out the work. */
		switch(mess.m_type) {
			case DEV_OPEN:		r = dsp_open();	break;
			case DEV_CLOSE:		r = dsp_close(); break;
#ifdef DEV_IOCTL
			case DEV_IOCTL:		r = dsp_ioctl(&mess); break;
#endif
#ifdef DEV_READ

			case DEV_READ:		r = EINVAL; break; /* Not yet implemented */
			case DEV_WRITE:		dsp_write(&mess); continue; /* don't reply */
#endif
			
			case DEV_STATUS:	dsp_status(&mess); continue; /* don't reply */
			default:			r = EINVAL;
		}

send_reply:
		/* Finally, prepare and send the reply message. */
		reply(TASK_REPLY, caller, proc_nr, r);
	}

}
コード例 #18
0
ファイル: driver_st.c プロジェクト: DragonQuan/minix3
/*===========================================================================*
 *			       blockdriver_receive_mq			     *
 *===========================================================================*/
PUBLIC int blockdriver_receive_mq(message *m_ptr, int *status_ptr)
{
/* receive() interface for drivers with message queueing. */

  /* Any queued messages? */
  if (mq_dequeue(SINGLE_THREAD, m_ptr, status_ptr))
	return OK;

  /* Fall back to standard receive() interface otherwise. */
  return driver_receive(ANY, m_ptr, status_ptr);
}
コード例 #19
0
ファイル: interupts.c プロジェクト: pedro93/LCOM
//Interrupt receptor
void interupt_handler(int time)
{
	int ipc_status;
	message msg;
	//int irq_set=timer_subscribe_int();
	int error;
	//ligar RTC
	unsigned long regB;
	counter = 0;
	regB = read_rtc(RTC_REG_B);
	regB = regB ^ RTC_UIE;
	write_rtc(RTC_REG_B,regB);

	while(counter<(time*60) && check_number_of_tries()==0) {
		/* Get a request message. */
		error = driver_receive(ANY, &msg, &ipc_status);
		if (error != 0 ) {
			printf("driver_receive failed with: %d",error);
			continue;
		}
		if (is_ipc_notify(ipc_status))
		{
			/* received notification */
			switch (_ENDPOINT_P(msg.m_source))
			{
			case HARDWARE: /* hardware interrupt notification */
				/*if ((msg.NOTIFY_ARG & BIT(0)) && (counter%60==0)) //subscribed interruptTimer
				{
					//timer_int_handler(counter); //same function as in lab3
					RTC_handler_date();
					counter++;
				}
				else*/
				if(msg.NOTIFY_ARG & BIT(1))
				{
					keyboard_handler(); //different function from the original
				}

				break;
			default:
				break; /* no other notifications expected: do nothing */
			}

		} else
		{ /* received a standard message, not a notification */
			/* no standard messages expected: do nothing */
		}
		counter++;
	}

	return;

}
コード例 #20
0
ファイル: test3.c プロジェクト: joaofidalgo23/LCOM
int kbd_test_timed_scan(unsigned short n) {
    int ipc_status;
    message msg;
    int validation = 0;
    int counter = 0;

    // usado para evitar chamar a função driver_receive várias vezes
    int receive;

    //subscribe() já verifica se não há problemas.
    int irq_set1 = kbd_subscribe();
    int irq_set2 = timer_subscribe_int();

    //Para quando a tecla ESC é libertada, ou quando passam n segundos sem input
    while (!validation) {
        /* Get a request message. */
        receive = driver_receive(ANY, &msg, &ipc_status);
        if (receive != 0) {
            printf("driver_receive failed with: %d", receive);
            continue;
        }

        if (is_ipc_notify(ipc_status)) { /* received notification */
            switch (_ENDPOINT_P(msg.m_source)) {
            case HARDWARE: /* hardware interrupt notification */
                if (msg.NOTIFY_ARG & irq_set1) { /* subscribed interrupt */
                    validation = kbd_handler_c(); /* process it */
                    counter = 0;
                }
                if (msg.NOTIFY_ARG & irq_set2) { /* subscribed interrupt */
                    counter++; /* process it */
                    if (counter == n*60)
                    {
                        printf("\n\tkbd_test_scan() stopped, press ENTER to continue!\n");
                        validation = 1;
                    }
                }
                break;
            default:
                break; /* no other notifications expected: do nothing */
            }
        } else { /* received a standard message, not a notification */
            /* no standard messages expected: do nothing */
        }
    }
    // unsubscribe_int() já verifica se não há problemas.
    kbd_unsubscribe();
    timer_unsubscribe_int();
    return 0;
}
コード例 #21
0
ファイル: test5.c プロジェクト: ricardocerq/FEUP-LCOM
void *test_init(unsigned short mode, unsigned short delay) {
	void* video_mem = NULL;
	if((video_mem=vg_init(mode)) == NULL)
	{
		printf("test_init(): vg_init() failed");
		return NULL;
	}
	int failure=0;
	int timer_irq_set=0;
	if((timer_irq_set = timer_subscribe_int()) < 0){//subscribe timer 0 interrupts
		printf("test_move(): timer_subscribe_int() failed \n");
		failure = 1;
	}
	int ipc_status;
	message msg;
	int r;
	//unsigned long ticks=0;
	if(!failure){
		do{
			/* Get a request message. */
			if ( (r = driver_receive(ANY, &msg, &ipc_status)) != 0 ) {
				printf("driver_receive failed with: %d", r);
				continue;
			}
			if (is_ipc_notify(ipc_status)) { /* received notification */
				switch (_ENDPOINT_P(msg.m_source)) {
				case HARDWARE: /* hardware interrupt notification */
					if(msg.NOTIFY_ARG & timer_irq_set){
						timer_int_handler();
					}
					break;
				default:
					break; /* no other notifications expected: do nothing */
				}
			} else {/* received a standard message, not a notification */
				/* no standard messages expected: do nothing */
			}
		} while(get_ticks() < delay * 60);
	}
	if(timer_unsubscribe_int()){//unsubscribe interrupts
		printf("test_move(): timer_unsubscribe_int() failed\n");
		failure = 1;
	}
	if(vg_exit()){
		printf("test_init(): vg_exit() failed");
		return NULL;
	}
	printf("Physical Address of VRAM: 0x%X\n", get_vram_phys_addr());
	return (void*)get_video_mem();
}
コード例 #22
0
ファイル: keyboard.c プロジェクト: joaoacsoares/LCOM
int timer0_sleep(int n){

	int r;
	int irq_set_timer;
	int ipc_status;
	message msg;

	int time = 60 * n;

	irq_set_timer = timer_subscribe_int();
	while( /*get_counter() < time*/1 ) {
		r = driver_receive(ANY, &msg, &ipc_status);
		if ( driver_receive(ANY, &msg, &ipc_status) != 0 ) {
			printf("driver_receive failed with: %d", r);
			continue;
		}
		if (is_ipc_notify(ipc_status)) { /* received notification */
			switch (_ENDPOINT_P(msg.m_source)) {
			case HARDWARE: /* hardware interrupt notification */
				if (msg.NOTIFY_ARG & BIT(irq_set_timer)) { /* subscribed interrupt */
					//timer_int_handler();
				}
				break;
			default:
				break; /* no other notifications expected: do nothing */
			}
		} else { /* received a standard message, not a notification */
			/* no standard messages expected: do nothing */
		}
	}

	timer_unsubscribe_int();
	//reset_counter();

	return 0;
}
コード例 #23
0
ファイル: test4.c プロジェクト: F0lha/LCOM-MINEHUNTER
int test_packet(unsigned short cnt) {

	unsigned long mouse_byte;
	int ipc_status, loops = 0,contador = 0;
	message msg;
	unsigned char packets[3];
	short irq_set = BIT(mouse_subscribe_int());
	enable_packets();
	while (loops != cnt) {
		/* Get a request message. */
		if (driver_receive(ANY, &msg, &ipc_status) != 0) {
			printf("driver_receive failed with: %d");
			continue;
		}
		if (is_ipc_notify(ipc_status)) {

			/* received notification */
			switch (_ENDPOINT_P(msg.m_source)) {
			case HARDWARE: /* hardware interrupt notification */
				if (msg.NOTIFY_ARG & irq_set) {
					mouse_byte = mouse_int_handler();
					if (contador == 0) {
						if (!first_byte(mouse_byte)) {
							contador = 0;
							continue;
						}
					}
					packets[contador] = mouse_byte;
					if (contador == 2) {
						contador = 0;
						print_packet(packets);
						loops++;
						continue;
					}
					contador++;
				}
				break;
			default:
				break; /* no other notifications expected: do nothing */
			}
		}
		else { /* received a standard message, not a notification */
			/* no standard messages expected: do nothing */
		}
	}

	return mouse_unsubscribe_int();
}
コード例 #24
0
ファイル: test4.c プロジェクト: pedro-c/LCOM-FEUP
int test_packet(unsigned short cnt) {
	int conta = 0, ind = 0, r, ipc_status;
	unsigned long irq_set, data;
	char cmd;
	message msg;
	if ((irq_set = mouse_subscribe()) == -1) {
		printf("Unable to subscribe mouse!\n");
		return 1;
	}
	if (sys_outb(STAT_REG, ENABLE_MOUSE) != OK) //rato enable
		printf("Error\n");
	if (sys_outb(STAT_REG, W_TO_MOUSE) != OK) //MOUSE
		printf("Error-MC\n");
	if (sys_outb(OUT_BUF, ENABLE_SEND) != OK) //Ativar o envio
		printf("Error-SEND\n");
	while (cnt > conta) {
		if ((r = driver_receive(ANY, &msg, &ipc_status)) != 0) {
			printf("driver_receive failed with: %d", r);
			continue;
		}
		if (is_ipc_notify(ipc_status)) {
			switch (_ENDPOINT_P(msg.m_source)) {
			case HARDWARE:
				if (msg.NOTIFY_ARG & irq_set) {
					get_packet();
					mouse_print();

				}
				break;
			default:
				break;
			}
		} else {
		}
	}
	printf("Terminou!\n");
	if (sys_outb(STAT_REG, W_TO_MOUSE) != OK)
		printf("ERROR-MC");
	if (sys_outb(OUT_BUF, DISABLE_STREAM) != OK)
		printf("ERROR-DISABLE_STREAM");
	if (sys_inb(OUT_BUF, &data) != OK)
		printf("OUT_BUF not full!\n");
	if (data != ACK)
		printf("Not ACK!\n");
	if (mouse_unsubscribe() == -1)
		printf("falhou unsubscribe mouse!\n");
	return 0;
}
コード例 #25
0
ファイル: sb16_mixer.c プロジェクト: Spenser309/CS551
/*===========================================================================*
 *				main
 *===========================================================================*/
PUBLIC int main(int argc, char *argv[])
{
	message mess;
	int ipc_status;
	int err, caller, proc_nr;

	/* SEF local startup. */
	sef_local_startup();

	/* Here is the main loop of the mixer task. It waits for a message, carries
	* it out, and sends a reply.
	*/
	while (TRUE) {
		driver_receive(ANY, &mess, &ipc_status);

		caller = mess.m_source;
		proc_nr = mess.IO_ENDPT;

		switch (caller) {
			case HARDWARE: /* Leftover interrupt. */
				continue;
			case VFS_PROC_NR: /* The only legitimate caller. */
				break;
			default:
				dprint("sb16: got message from %d\n", caller);
				continue;
		}

		/* Now carry out the work. */
		switch(mess.m_type) {
			case DEV_OPEN:      err = mixer_open(&mess); break;	
			case DEV_CLOSE:     err = mixer_close(&mess); break; 
#ifdef DEV_IOCTL
			case DEV_IOCTL:     err = mixer_ioctl(&mess); break;
#endif
			default:		err = EINVAL; break;
		}

		/* Finally, prepare and send the reply message. */
		mess.m_type = TASK_REPLY;
		mess.REP_ENDPT = proc_nr;
	
		dprint("%d %d", err, OK);
		
		mess.REP_STATUS = err;	/* error code */
		send(caller, &mess);	/* send reply to caller */
	}
}
コード例 #26
0
ファイル: keyboard.c プロジェクト: mgpsp/LCOM-FEUP
int exit_on_ESC()
{
	int ipc_status, r, exit = 0;
	unsigned long irq_set, data;
	message msg;

	irq_set = keyboard_subscribe_int();
	if (irq_set == -1) return 1;  // check if subscribe_int failed

	do
	{
		r = driver_receive(ANY, &msg, &ipc_status);
		if (r != 0)
		{
			printf("driver_receive failed with: %d", r);
			continue;
		}

		if (is_ipc_notify(ipc_status))
		{
			switch (_ENDPOINT_P(msg.m_source))
			{
			case HARDWARE:
				if (msg.NOTIFY_ARG & irq_set)
				{
					data = readFromKBC();
					if (data == ESC)
					{
						exit = 1;
						if (vg_exit() != 0)
						{
							printf("\texit_on_ESC(): vg_exit() failed\n");
							return 1;
						}
					}
				}
				break;
			default:
				break;
			}
		}
	} while (exit == 0);

	keyboard_unsubscribe_int();

	return 0;
}
コード例 #27
0
ファイル: driver.c プロジェクト: vivekp/minix-1
/*===========================================================================*
 *				restart_driver				     *
 *===========================================================================*/
static void restart_driver(int which, int tell_rs)
{
    /* Restart the given driver. Block until the new instance is up.
     */
    message msg;
    int ipc_status;
    int r;

    if (tell_rs) {
        /* Tell RS to refresh or restart the driver */
        msg.m_type = RS_REFRESH;
        msg.RS_CMD_ADDR = driver[which].label;
        msg.RS_CMD_LEN = strlen(driver[which].label);

#if DEBUG
        printf("Filter: asking RS to refresh %s..\n",
               driver[which].label);
#endif

        r = sendrec(RS_PROC_NR, &msg);

        if (r != OK || msg.m_type != OK)
            panic("RS request failed: %d", r);

#if DEBUG
        printf("Filter: RS call succeeded\n");
#endif
    }

    /* Wait until the new driver instance is up, and get its endpoint. */
#if DEBUG
    printf("Filter: endpoint update driver %d; old endpoint %d\n",
           which, driver[which].endpt);
#endif

    if(driver[which].up_event == UP_EXPECTED) {
        driver[which].up_event = UP_NONE;
    }
    while(driver[which].up_event != UP_PENDING) {
        r = driver_receive(DS_PROC_NR, &msg, &ipc_status);
        if(r != OK)
            panic("driver_receive returned error: %d", r);

        ds_event();
    }
}
コード例 #28
0
ファイル: timer.c プロジェクト: Pigmoth69/LCOM-DODGEM
int timer_test_int(unsigned long time)
{
	int irq_set = timer_subscribe_int(); //subscreve e inicia as interrupções do timer0
	timer_set_square(0,60); //coloca a frequencia a 60

	int ipc_status;
	int r;
	message msg;
	unsigned i = 0;
	while( i < time) { // enquando a contagem é menor que o valor passado no parametro
		/* Get a request message. */
		if ((r = driver_receive(ANY, &msg, &ipc_status)) != 0)
		{
			printf("driver_receive failed with: %d", r);
			continue;
		}



		if (is_ipc_notify(ipc_status)) { /* received notification */
			switch (_ENDPOINT_P(msg.m_source)) {
			 case HARDWARE: /* hardware interrupt notification */
				 if (msg.NOTIFY_ARG & irq_set)
				 { /* subscribed interrupt */
					 timer_int_handler();
					 if (counter % 60 == 0) //a cada segundo (60 contagens a 60 de frequencia)
					 {
						 i++;
						 printf("%d", i); // imprime o valor do segundo.
						 printf("\n");
					 }
				 }
				 break;
				default:
					break; /* no other notifications expected: do nothing */
			}
		} else { /* received a standard message, not a notification */
			/* no standard messages expected: do nothing */

			}
	}
	if (timer_unsubscribe_int() != OK)  //termina a subscrição, caso dê erro retorna 1
		return 1;
	
	return 0;
}
コード例 #29
0
ファイル: test3.c プロジェクト: mgpsp/LCOM-FEUP
int kbd_test_scan(unsigned short ass)
{
	int ipc_status, r, exit = 0, flag = 0;
	unsigned long irq_set, data;
	message msg;

	irq_set = subscribe_int(KB_IRQ, IRQ_REENABLE | IRQ_EXCLUSIVE, &kb_id);
	if (irq_set == -1) return -1;  // check if subscribe_int failed

	do
	{
		r = driver_receive(ANY, &msg, &ipc_status);
		if (r != 0)
		{
			printf("driver_receive failed with: %d", r);
			continue;
		}

		if (is_ipc_notify(ipc_status))
		{
			switch (_ENDPOINT_P(msg.m_source))
			{
			case HARDWARE:
				if (msg.NOTIFY_ARG & irq_set)
				{
					data = keyboard_handler(ass);
					flag = print_scancodes(data, flag);
					if (data == ESC)
					{
						printf("Done\n");
						exit = 1;
					}
				}
				break;
			default:
				break;
			}
		}
	} while (exit == 0);

	unsubscribe_int(&kb_id);

	return 0;
}
コード例 #30
0
ファイル: test4.c プロジェクト: Digas29/LCOM-FROGGER
int test_gesture(short length, unsigned short tolerance) {
	int ipc_status;
	message msg;
	int request;
	unsigned long  irq_set;
	int stop=0;

	counter = 0;
	X = 0;
	Y = 0;
	LENGTH = length;
	TOLERANCE = tolerance;

	irq_set = subscribe_mouse();

	while(!stop) {
		request = driver_receive(ANY, &msg, &ipc_status);
		if (request != 0 ) {
			printf("driver_receive failed with: %d", request);
			continue;
		}
		if (is_ipc_notify(ipc_status)) {
			switch (_ENDPOINT_P(msg.m_source)) {
			case HARDWARE:
				if (msg.NOTIFY_ARG & irq_set) {
					stop=gesture_handler();
					if(abs(Y) > tolerance){
						X=0;
						Y=0;
 					}
				}
				break;
			default:
				break;
			}
		}
	}
	mouse_write_byte(DISABLE_DATA_PACKETS);
	unsubscribe_mouse();
	printf("\nExit gesture!\n");
	return 0;

}