int do_test_sem(const char *test_parm)
{
(void) test_parm;
printf("Testing semaphores\n");
hal_sem_init(&test_sem_0, "semTest");
softirq = hal_alloc_softirq();
if( softirq < 0 )
test_fail_msg( 1, "Unable to get softirq" );
hal_set_softirq_handler( softirq, sem_softirq, 0 );
//int tid =
hal_start_kernel_thread_arg( sem_rel, 0 );
printf("sema wait 1\n");
// Direct
sem_released = 0;
hal_sem_acquire( &test_sem_0 );
test_check_eq(sem_released,1);
hal_sleep_msec( 100 );
printf("sema wait 2\n");
#if TEST_SOFTIRQ
// Softirq
sem_released = 0;
hal_sem_acquire( &test_sem_0 );
test_check_eq(sem_released,1);
#endif
hal_sleep_msec( 100 );
printf("sema timeout\n");
sem_released = 0;
hal_start_kernel_thread_arg( sem_etc, 0 );
hal_sleep_msec( 100 );
test_check_eq(sem_released,0);
hal_sleep_msec( 120 );
test_check_eq(sem_released,1);
test_check_eq( rc, ETIMEDOUT);
stop_sem_test = 1;
printf("Done testing semaphores\n");
return 0;
}
static void paint_thread(void *arg)
{
(void) arg;
hal_set_current_thread_name("paint");
// +1 so that it is a bit higher than regular sys threads
t_current_set_priority(PHANTOM_SYS_THREAD_PRIO+1);
while(1)
{
//hal_sleep_msec(10);
hal_sem_acquire( &paint_sem );
if( !paint_request )
continue;
if( prev_paint_request < paint_request )
{
#if 0
if( no_paint_msec < MAX_NO_PAINT )
{
prev_paint_request = paint_request;
no_paint_msec += 10;
continue;
}
#endif
}
prev_paint_request = paint_request = 0;
no_paint_msec = 0;
do_paint_area();
}
}
static void mouse_push_event_thread(void *arg)
{
(void) arg;
t_current_set_name("MouEvents");
t_current_set_priority(PHANTOM_SYS_THREAD_PRIO);
while(1)
{
hal_sem_acquire( &mouse_sem );
if(video_drv->mouse_redraw_cursor != NULL)
video_drv->mouse_redraw_cursor();
//hal_mutex_lock( &mouse_mutex );
struct ui_event e, e1;
while( get_buf(&e) )
{
if( peek_buf( &e1 ) )
{
// We already have one more event and buttons state is the same?
// Throw away current event, use next one.
if( e1.m.buttons == e.m.buttons )
continue;
}
ev_q_put_any( &e );
}
//hal_mutex_unlock( &mouse_mutex );
}
}
static void com_wr_thread( void *_dev )
{
phantom_device_t * dev = _dev;
int unit = dev->seq_number;
int addr = dev->iobase;
com_port_t *cp = dev->drv_private;
while(1)
{
hal_sem_acquire( &(cp->wsem) );
//hal_sem_zero( &(cp->wsem) ); // we will process all the requsets at once
(void) unit;
SHOW_FLOW( 9, "com port %d wr", unit );
/* if have data and transmitter is empty */
while( (!wtty_is_empty(cp->wrq)) && (inb(LINE_STAT(addr)) & iTHRE) )
{
/* send the char */
outb(addr, wtty_getc(cp->wrq) );
}
}
}
static void com_rd_thread( void *_dev )
{
phantom_device_t * dev = _dev;
int unit = dev->seq_number;
int addr = dev->iobase;
com_port_t *cp = dev->drv_private;
while(1)
{
hal_sem_acquire( &(cp->rsem) );
hal_sem_zero( &(cp->rsem) ); // we will process all the requsets at once
(void) unit;
SHOW_FLOW( 9, "com port %d io", unit );
// try input
u_int8_t line;
while ((line = inb(LINE_STAT(addr))) & iDR)
{
int c = inb(TXRX(addr));
wtty_putc_nowait( cp->rdq, c );
}
}
}
void rtl8169_xmit(rtl8169 *r, const char *ptr, ssize_t len)
{
//int i;
#if debug_level_flow >= 3
dprintf("rtl8169_xmit dumping packet:");
hexdump(ptr, len, 0, 0);
#endif
restart:
hal_sem_acquire(&r->tx_sem);
hal_mutex_lock(&r->lock);
int_disable_interrupts();
acquire_spinlock(&r->reg_spinlock);
/* look at the descriptor pointed to by tx_idx_free */
if (r->txdesc[r->tx_idx_free].flags & RTL_DESC_OWN) {
/* card owns this one, wait and try again later */
release_spinlock(&r->reg_spinlock);
int_restore_interrupts();
mutex_unlock(&r->lock);
// sem_release(r->tx_sem, 1);
goto restart;
}
/* queue it up */
memcpy(TXBUF(r, r->tx_idx_free), ptr, len);
if (len < 64)
len = 64;
r->txdesc[r->tx_idx_free].frame_len = len;
r->txdesc[r->tx_idx_free].flags = (r->txdesc[r->tx_idx_free].flags & RTL_DESC_EOR) | RTL_DESC_FS | RTL_DESC_LS | RTL_DESC_OWN;
inc_tx_idx_free(r);
RTL_WRITE_8(r, REG_TPPOLL, (1<<6)); // something is on the normal queue
release_spinlock(&r->reg_spinlock);
int_restore_interrupts();
mutex_unlock(&r->lock);
}
static int mipsnet_write(phantom_device_t * dev, const void *buf, int in_buflen )
{
struct mipsnet *pvt = dev->drv_private;
SHOW_FLOW( 3, "write %d bytes", in_buflen );
//hexdump( buf, in_buflen, "pkt", 0 );
int buflen = in_buflen;
//assert( buflen < 1514 );
if( buflen > 1514 )
buflen = 1514;
if(buflen < 0)
return ERR_INVALID_ARGS;
hal_sem_acquire( &(pvt->send_interrupt_sem) );
mipsnet_pio_write( dev, buf, buflen);
return buflen;
}
static void thread1(void *a)
{
char *name = a;
while(!thread_stop_request)
{
thread_activity_counter++;
if(TEST_CHATTY) printf("--- thread %s runs ---\n", name);
pressEnter("");
if(TEST_CHATTY) printf("Will lock mutex\n");
hal_mutex_lock(&m);
if(TEST_CHATTY) printf("locked mutex\n");
checkEnterMutex();
YIELD();
if(TEST_CHATTY) printf("Will unlock mutex\n");
checkLeaveMutex();
hal_mutex_unlock(&m);
if(TEST_CHATTY) printf("unlocked mutex\n");
if( random() & 1 )
hal_sem_acquire( &s );
counter++;
if(counter >7)
{
counter = 0;
if(TEST_CHATTY) printf("Will signal cond\n");
hal_cond_signal(&c);
if(TEST_CHATTY) printf("Signalled cond\n");
}
YIELD();
}
FINISH();
}
void w_event_deliver_thread(void)
{
hal_sem_init( &we_sem, "wevent" );
we_inited = 1;
hal_set_thread_name("WEvent");
hal_set_current_thread_priority(PHANTOM_SYS_THREAD_PRIO+1);
while(1)
{
hal_sem_acquire( &we_sem ); // TODO need some 'acquire_all' method to eat all releases
restart:
w_lock();
window_handle_t w;
queue_iterate_back(&allwindows, w, drv_video_window_t *, chain)
{
if( w->events_count )
{
if(w->eventDeliverSema)
hal_sem_release(w->eventDeliverSema);
if(w->inKernelEventProcess)
{
w_unlock();
w_do_deliver_event(w);
goto restart;
}
}
}
w_unlock();
}
}
static int mipsnet_read( struct phantom_device *dev, void *buf, int len)
{
SHOW_FLOW( 4, "read %d bytes", len );
if(len < ETHERNET_MAX_SIZE)
return ERR_VFS_INSUFFICIENT_BUF;
struct mipsnet *pvt = dev->drv_private;
int ret = 0;
do {
SHOW_FLOW( 7, "poll %d bytes", len );
hal_sem_acquire( &(pvt->recv_interrupt_sem) );
ret = mipsnet_pio_read( dev, buf, len );
} while( ret <= 0 );
//hexdump( buf, ret, "recv pkt", 0 );
SHOW_FLOW( 7, "read %d bytes", ret );
return ret;
}
ssize_t rtl8169_rx(rtl8169 *r, char *buf, ssize_t buf_len)
{
//uint32 tail;
ssize_t len;
int rc;
bool release_sem = false;
SHOW_FLOW0(3, "rtl8169_rx: entry\n");
if(buf_len < 1500)
return -1;
restart:
hal_sem_acquire(&r->rx_sem);
mutex_lock(&r->lock);
int_disable_interrupts();
acquire_spinlock(&r->reg_spinlock);
/* look at the descriptor pointed to by rx_idx_free */
if (r->rxdesc[r->rx_idx_free].flags & RTL_DESC_OWN) {
/* for some reason it's owned by the card, wait for more packets */
release_spinlock(&r->reg_spinlock);
int_restore_interrupts();
mutex_unlock(&r->lock);
goto restart;
}
/* process this packet */
len = r->rxdesc[r->rx_idx_free].frame_len & 0x3fff;
SHOW_FLOW(3, "rtl8169_rx: desc idx %d: len %d\n", r->rx_idx_free, len);
if (len > buf_len) {
rc = ERR_TOO_BIG;
release_sem = true;
goto out;
}
memcpy(buf, RXBUF(r, r->rx_idx_free), len);
rc = len;
#if debug_level_flow >= 3
hexdump(RXBUF(r, r->rx_idx_free), len, 0, 0);
#endif
/* stick it back in the free list */
r->rxdesc[r->rx_idx_free].buffer_size = BUFSIZE_PER_FRAME;
r->rxdesc[r->rx_idx_free].flags = (r->rxdesc[r->rx_idx_free].flags & RTL_DESC_EOR) | RTL_DESC_OWN;
inc_rx_idx_free(r);
/* see if there are more packets pending */
if ((r->rxdesc[r->rx_idx_free].flags & RTL_DESC_OWN) == 0)
release_sem = true; // if so, release the rx sem so the next reader gets a shot
out:
release_spinlock(&r->reg_spinlock);
int_restore_interrupts();
if(release_sem)
hal_sem_release(&r->rx_sem);
mutex_unlock(&r->lock);
return rc;
}
