RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2024-12-29 04:50:03 +01:00
Code Releases Activity

* refactored uart / chardev handling

Browse Source
This commit is contained in:
Kaspar Schleiser 2010-09-30 15:10:39 +02:00
parent 4941f01946
commit d3f3962190
3 changed files with 25 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
msba2/drivers/Jamfile
View File

@ -3,4 +3,5 @@ SubDir TOP board msba2 drivers ;
Module board_cc1100 : msba2-cc1100.c ;
Module board_hal : msba2-hal.c ;
Module board_ltc4150 : msba2-ltc4150.c : gpioint ;
Module board_common : msba2-uart0.c msba2-uart0_thread.c : ringbuffer ;
Module board_common : msba2-uart0.c : ringbuffer ;
Module board_uart : msba2-uart0_thread.c : chardev_thread ;

23
msba2/drivers/msba2-uart0.c
View File

@ -110,11 +110,9 @@ int uart_active(void){
}
static void notify_handler() {
if (uart0_handler_pid) {
msg m;
m.type = 0;
msg_send_int(&m, uart0_handler_pid);
}
msg m;
m.type = 0;
msg_send_int(&m, uart0_handler_pid);
}
void stdio_flush(void)
@ -142,14 +140,15 @@ void UART0_IRQHandler(void)
case UIIR_CTI_INT: // Character Timeout Indicator
case UIIR_RDA_INT: // Receive Data Available
do {
int c = U0RBR;
rb_add_element(&uart0_ringbuffer, c);
} while (U0LSR & ULSR_RDR);
notify_handler();
break;
if (uart0_handler_pid) {
do {
int c = U0RBR;
rb_add_element(&uart0_ringbuffer, c);
} while (U0LSR & ULSR_RDR);
notify_handler();
break;
}
default:
U0LSR;
U0RBR;

100
msba2/drivers/msba2-uart0_thread.c
View File

@ -1,101 +1,25 @@
#include <thread.h>
#include <kernel.h>
#include <msg.h>
#include <board.h>
#include <chardev_thread.h>
#include <ringbuffer.h>
#include <stdio.h>
#include <errno.h>
#include <irq.h>
#include <posix_io.h>
#include "uart0.h"
#include <thread.h>
//#define ENABLE_DEBUG
#include <debug.h>
#include <board_uart0.h>
#define UART0_BUFSIZE 32
extern ringbuffer uart0_ringbuffer;
extern int uart0_handler_pid;
static char buffer[UART0_BUFSIZE];
ringbuffer uart0_ringbuffer;
static void uart0_loop();
static void uart0_loop() {
chardev_loop(&uart0_ringbuffer);
}
void uart0_init() {
void board_uart0_init() {
ringbuffer_init(&uart0_ringbuffer, buffer, UART0_BUFSIZE);
int pid = thread_create(KERNEL_CONF_STACKSIZE_MAIN, PRIORITY_MAIN-1, CREATE_STACKTEST, uart0_loop, "uart0");
uart0_handler_pid = pid;
puts("uart0_init() [OK]");
}
static int min(int a, int b) {
if (b>a) return a;
else return b;
}
static void uart0_loop() {
msg m;
int pid = thread_getpid();
int reader_pid = -1;
struct posix_iop *r = NULL;
puts("UART0 thread started.");
while (1) {
msg_receive(&m);
if (m.sender_pid == pid) {
} else {
switch (m.type) {
case OPEN:
if (reader_pid == -1) {
reader_pid = m.sender_pid;
m.content.value = 0; // no error
} else {
m.content.value = -EBUSY;
}
msg_reply(&m,&m);
break;
case READ:
if (m.sender_pid != reader_pid) {
m.content.value = -EINVAL;
msg_reply(&m, &m);
} else {
r = (struct posix_iop *)m.content.ptr;
}
break;
case CLOSE:
if (m.sender_pid == reader_pid) {
DEBUG("uart0_thread: closing file from %i\n", reader_pid);
reader_pid = -1;
r = NULL;
m.content.value = 0;
} else {
m.content.value = -EINVAL;
}
msg_reply(&m,&m);
break;
default:
m.content.value = -EINVAL;
msg_reply(&m, &m);
}
}
if (uart0_ringbuffer.avail && (r != NULL)) {
int state = disableIRQ();
int nbytes = min(r->nbytes, uart0_ringbuffer.avail);
DEBUG("uart0_thread: sending %i bytes to pid %i\n", nbytes, reader_pid);
rb_get_elements(&uart0_ringbuffer, r->buffer, nbytes);
r->nbytes = nbytes;
m.sender_pid = reader_pid;
m.type = OPEN;
m.content.ptr = (char*)r;
msg_reply(&m, &m);
// DEBUG("uart0_thread: sending res=%i\n", res);
r = NULL;
restoreIRQ(state);
}
}
}