// Initializes the ABDAC
void initAudio(void) {
// Set interrupt routine
register_interrupt(abdac_isr, AVR32_ABDAC_IRQ/32, AVR32_ABDAC_IRQ % 32, ABDAC_INT_LEVEL);
// Release pins from PIO
piob->PUER.p20 = 1;
piob->PUER.p21 = 1;
// Release pins from PIO
piob->PDR.p20 = 1;
piob->PDR.p21 = 1;
// Set pins to peripheral A (ABDAC)
piob->ASR.p20 = 1;
piob->ASR.p21 = 1;
// Connect and activate oscillator 1
pm->GCCTRL[6].pllsel = 0;
pm->GCCTRL[6].oscsel = 1;
pm->GCCTRL[6].cen = 1;
// Activate clock division [ CLK = 12MHz >> (DIV+1); SMPL_RATE = CLK >> 8; ]
// This should be done when the clock is disabled according to the docs, but then it does not work
pm->GCCTRL[6].div = 0;
pm->GCCTRL[6].diven = 1;
// Activate ABDAC
dac->CR.en = 1;
// Activate interrupts
dac->IER.tx_ready = 1;
}
void init_timer(unsigned int freq)
{
printk("Initializing programmable interval timer... ");
// initialize timers
for(int i = 0; i < TIMER_MAX_CALLBACKS; ++i){
callbacks[i].when = TIMER_CANCEL;
}
timer_freq = freq;
register_interrupt(IRQ0, &timer_interrupt);
u32 divisor = ((u32)(1193180 / freq));
u32 eflags = disablei();
// PIT command byte
outb(0x43, 0x36); // 0b00110110
// Get the high and low bytes of the divisor
u8 low = (u8)( divisor & 0xFF );
u8 high = (u8)( (divisor >> 8) & 0xFF );
outb(0x40, low);
outb(0x40, high);
restore(eflags);
timer_sync_time();
printk(" done.\n");
}
void audio_init(volatile avr32_pio_t* pio, volatile avr32_pm_t* pm, volatile avr32_abdac_t* dac, void* handler, int IRQ) {
/* take control of pins 20 and 21 away from PIOB */
pio->PDR.p20 = 1;
pio->PDR.p21 = 1;
/* and give control of the pins to peripheral A (which is the ABDAC) instead */
pio->ASR.p20 = 1;
pio->ASR.p21 = 1;
/* setting up options for the generic clock that will drive the ABDAC */
pm->GCCTRL[6].oscsel = 1; /* select oscillator 1 which runs at 12Mhz */
//pm->GCCTRL[6].pllsel = 0;
pm->GCCTRL[6].cen = 1; /* enable the clock */
pm->GCCTRL[6].div = 0;
pm->GCCTRL[6].diven = 1;
/* actually activate the ABDAC */
dac->CR.en = 1;
/* activate the interrupt for the ABDAC */
dac->IER.tx_ready = 1;
/* connect the interrupt handler to the interrupt signal */
register_interrupt((__int_handler)handler, IRQ / 32, IRQ % 32, ABDAC_INT_LEVEL);
}
// Initializes the buttons
void initButtons(void) {
// Set interrupt routine
register_interrupt(button_isr, AVR32_PIOB_IRQ/32, AVR32_PIOB_IRQ % 32, BUTTONS_INT_LEVEL);
piob->per = 0xFF;
piob->puer = 0xFF;
piob->ier = 0xFF;
}
static void init_serial_port(char *devname, int iobase, int irq, struct unit *unit) {
struct serial_port *sp;
dev_t devno;
sp = (struct serial_port *) kmalloc(sizeof(struct serial_port));
memset(sp, 0, sizeof(struct serial_port));
sp->iobase = iobase;
sp->irq = irq;
sp->cfg.speed = 115200;
sp->cfg.databits = 8;
sp->cfg.parity = PARITY_NONE;
sp->cfg.stopbits = 1;
sp->cfg.rx_timeout = INFINITE;
sp->cfg.tx_timeout = INFINITE;
init_dpc(&sp->dpc);
sp->dpc.flags |= DPC_NORAND;
init_event(&sp->event, 0, 0);
init_sem(&sp->tx_sem, QUEUE_SIZE);
init_mutex(&sp->tx_lock, 0);
init_sem(&sp->rx_sem, 0);
init_mutex(&sp->rx_lock, 0);
// Disable interrupts
outp(sp->iobase + UART_IER, 0);
// Determine UART type
check_uart_type(sp);
// Set baudrate, parity, databits and stopbits
serial_config(sp);
// Enable FIFO
if (sp->type == UART_16550A) {
outp(sp->iobase + UART_FCR, FCR_ENABLE | FCR_RCV_RST | FCR_XMT_RST | FCR_TRIGGER_14);
}
// Turn on DTR, RTS and OUT2
sp->mcr = MCR_DTR | MCR_RTS | MCR_IENABLE;
outp(sp->iobase + UART_MCR, sp->mcr);
// Create device
devno = dev_make(devname, &serial_driver, unit, sp);
// Enable interrupts
register_interrupt(&sp->intr, IRQ2INTR(sp->irq), serial_handler, sp);
enable_irq(sp->irq);
outp((unsigned short) (sp->iobase + UART_IER), IER_ERXRDY | IER_ETXRDY | IER_ERLS | IER_EMSC);
kprintf(KERN_INFO "%s: %s iobase 0x%x irq %d\n", device(devno)->name, uart_name[sp->type], sp->iobase, sp->irq);
}
//test touch screen
void test_ts(void)
{
int ret;
//register interrupt
ret = register_interrupt(ISR_ADC_OFT,adc_ts_inthandle);
//设置触摸屏转换时间
adc_reg->ADCDLY = 50000;
//设置触摸屏为等待中断模式，等待按下
adc_reg->ADCTSC = WAIT_INTERRUPT;
}
void init_sched (void)
{
unsigned long eflags;
eflags = read_flags ();
if ((idle_task = kmalloc (sizeof (Task), 0)) == NULL) {
printk ("init_sched: not enough memory\n");
write_flags (eflags);
return;
}
idle_task->pid = next_pid++;
idle_task->next = idle_task;
#if 0
idle_task->kernel_stack = kstack;
#endif
idle_task->tss.link = 0;
idle_task->tss.esp0 = (unsigned long) &kstack[PAGE_SIZE >> 2];
idle_task->tss.ss0 = KERNEL_DS;
idle_task->tss.cr3 = (unsigned long) &pg_dir[0];
idle_task->tss.es = KERNEL_DS;
idle_task->tss.cs = KERNEL_CS;
idle_task->tss.ss = KERNEL_DS;
idle_task->tss.ds = KERNEL_DS;
idle_task->tss.fs = KERNEL_DS;
idle_task->tss.gs = KERNEL_DS;
current = idle_task;
set_tss (idle_task);
write_tr (idle_task->tss.tr);
cli ();
register_interrupt (0x08, do_timer);
register_interrupt (0x80, do_fork);
outb(0x36,0x43);
outb(0xa9,0x40);
outb(0x04,0x40);
write_flags (eflags);
}
void hwtimer_arch_enable_interrupt(void)
{
DEBUG("hwtimer_arch_enable_interrupt()\n");
if (register_interrupt(SIGALRM, hwtimer_isr_timer) != 0) {
DEBUG("darn!\n\n");
}
return;
}
void timer_irq_enable(tim_t dev)
{
(void)dev;
DEBUG("%s\n", __func__);
if (register_interrupt(SIGALRM, native_isr_timer) != 0) {
DEBUG("darn!\n\n");
}
return;
}
/*!
* \brief MACB interrupt control.
*
* \param cmd Control command.
* - NUT_IRQCTL_INIT Initialize and disable interrupt.
* - NUT_IRQCTL_STATUS Query interrupt status.
* - NUT_IRQCTL_ENABLE Enable interrupt.
* - NUT_IRQCTL_DISABLE Disable interrupt.
* - NUT_IRQCTL_GETMODE Query interrupt mode.
* - NUT_IRQCTL_SETMODE Set interrupt mode (NUT_IRQMODE_LEVEL or NUT_IRQMODE_EDGE).
* - NUT_IRQCTL_GETPRIO Query interrupt priority.
* - NUT_IRQCTL_SETPRIO Set interrupt priority.
* - NUT_IRQCTL_GETCOUNT Query and clear interrupt counter.
* \param param Pointer to optional parameter.
*
* \return 0 on success, -1 otherwise.
*/
int MacbIrqCtl(int cmd, void *param)
{
int rc = 0;
unsigned int *ival = (unsigned int *) param;
ureg_t imr = AVR32_MACB.imr;
static ureg_t enabledIMR = 0;
int_fast8_t enabled = imr;
/* Disable interrupt. */
if (enabled) {
AVR32_MACB.idr = 0xFFFFFFFF;
AVR32_MACB.imr;
enabledIMR = imr;
}
switch (cmd) {
case NUT_IRQCTL_INIT:
/* Set the vector. */
register_interrupt(MacbIrqEntry, AVR32_MACB_IRQ, NUT_IRQPRI_MACB);
break;
case NUT_IRQCTL_STATUS:
if (enabled) {
*ival |= 1;
} else {
*ival &= ~1;
}
break;
case NUT_IRQCTL_ENABLE:
enabled = 1;
break;
case NUT_IRQCTL_DISABLE:
enabled = 0;
break;
case NUT_IRQCTL_GETPRIO:
*ival = NUT_IRQPRI_MACB;
break;
#ifdef NUT_PERFMON
case NUT_IRQCTL_GETCOUNT:
*ival = (unsigned int) sig_MACB.ir_count;
sig_MACB.ir_count = 0;
break;
#endif
default:
rc = -1;
break;
}
/* Enable interrupt. */
if (enabled) {
AVR32_MACB.ier = enabledIMR;
}
return rc;
}
/*
* start polling for network packets. this is separate so that clock interrupts
* can be turned on without network interrupts. however, this function requires
* that clock_init has been called!
*/
void start_network_poll(interrupt_handler_t network_handler, SOCKET* s) {
HANDLE network_thread = NULL; /* NT thread to check for incoming packets */
DWORD id;
kprintf("Starting network interrupts.\n");
register_interrupt(NETWORK_INTERRUPT_TYPE, network_handler, INTERRUPT_DEFER);
/* create clock and return threads, but discard ids */
network_thread = CreateThread(NULL, 0, network_poll, s, 0, &id);
assert(network_thread != NULL);
}
void buttons_init(volatile avr32_pio_t *_pio, int bitmask, void *handler, int IRQ) {
/* Store a reference to the PIO which has the leds */
pio = _pio;
/* Enable I/O pins for them buttans */
pio->per = bitmask;
/* Enable pull-up resistors */
pio->puer = bitmask;
/* enable interrupts */
pio->ier = bitmask;
/* connect the interrupt handler to the interrupt signal */
register_interrupt(handler, IRQ / 32, IRQ % 32, BUTTONS_INT_LEVEL);
}
int miniterm_initialize() {
HANDLE read_thread = NULL;
DWORD id;
kprintf("Starting read interrupts.\n");
register_interrupt(READ_INTERRUPT_TYPE, read_handler, INTERRUPT_DEFER);
kb_head = NULL;
kb_tail = NULL;
new_data = semaphore_create();
semaphore_initialize(new_data, 0);
read_thread = CreateThread(NULL, 0, read_poll, NULL, 0, &id);
assert(read_thread != NULL);
return 0;
}
/*main*/
int main(int argc,char** argv)
{
int ret = 0;
//swi_test();
clean_bss();
uart0_init();
init_led();
init_irq();
#ifdef _DEBUG
/*register extern4*/
key_init(4,EXTINT);
register_extern_int(EXTERNIRQ4,KeyINT2_Handle);
//invoking timer0 initialize and enable timer0 handle
register_interrupt(ISR_TIMER0_OFT,Timer0_Handle);
timer0_init();
#endif
ret = smdk2440_machine_init();
if(ret != 0)
{
goto tail;
}
ret = dm9000_initialize();
if(ret != 0)
{
printf("dm9000_initialize error.\n\t");
goto tail;
}
ret = eth_init();
if(ret != 0)
{
printf("eth_init error.\n\t");
goto tail;
}
wait(50000);
test_dm9000();
wait(500000);
test_dm9000();
//arp_test();
uip_exe();
tail:
while(1);
return 0;
}
int
Device::init()
{
int ret = OK;
// If assigned an interrupt, connect it
if (_irq) {
/* ensure it's disabled */
up_disable_irq(_irq);
/* register */
ret = register_interrupt(_irq, this);
if (ret != OK)
goto out;
_irq_attached = true;
}
out:
return ret;
}
int timer_init(tim_t dev, unsigned long freq, timer_cb_t cb, void *arg)
{
(void)freq;
DEBUG("%s\n", __func__);
if (dev >= TIMER_NUMOF) {
return -1;
}
if (freq != NATIVE_TIMER_SPEED) {
return -1;
}
/* initialize time delta */
time_null = 0;
time_null = timer_read(0);
_callback = cb;
_cb_arg = arg;
if (register_interrupt(SIGALRM, native_isr_timer) != 0) {
DEBUG("darn!\n\n");
}
return 0;
}
/*
* Setup the interval timer and install user interrupt handler. After this
* routine is called, and after you call set_interrupt_level(ENABLED), clock
* interrupts will begin to be sent. They will call the handler
* function h specified by the caller.
*/
void minithread_clock_init(interrupt_handler_t clock_handler)
{
#ifndef WINCE
HANDLE process;
#endif
DWORD id;
char name[32];
if (clock_handler == NULL) {
kprintf("INT ERR: Must provide an interrupt handler, interrupts not started.\n");
return;
}
dbgprintf("Starting clock interrupts...\n");
clock_enabled = 1;
clock_poll_done = 0;
ticks = 0;
/* set values for *start_address and *stop_address */
start_address = start();
end_address = end();
loopforever_start_address = loopforever_start();
loopforever_end_address = loopforever_end();
// if (DEBUG){
//kprintf("start_address=%x\tend_address=%x\n",
// start_address, end_address);
//kprintf("loop_start_address=%x\tloop_end_address=%x\n",
// loopforever_start_address, loopforever_end_address);
// }
pid = GetCurrentProcessId();
/* set up the signal queue and semaphores */
sprintf(name, "interrupt mutex %d", pid);
mutex = CreateMutex(NULL, FALSE, name);
/* use this semaphore as a condition variable */
sprintf(name, "interrupt return semaphore %d", pid);
cleanup = CreateSemaphore(NULL, 0, 10, name);
/* set up clock poll mutex */
sprintf(name, "clock poll mutex %d", pid);
clock_poll_done = CreateMutex(NULL, FALSE, name);
interrupt_level = DISABLED;
register_interrupt(CLOCK_INTERRUPT_TYPE, clock_handler, INTERRUPT_DROP);
#ifndef WINCE
/* overcome an NT "feature" -- GetCurrentThread() returns a "pseudohandle" to
the executing thread, not the real handle, so we need to use
DuplicateHandle() to get the real handle.
*/
process = GetCurrentProcess();
AbortOnError(DuplicateHandle(process, GetCurrentThread(), process,
&system_thread, THREAD_ALL_ACCESS, FALSE, 0));
#else
/* system_thread already set properly in WinMain */
#endif
/* create clock and return threads, but discard ids */
clock_thread = CreateThread(NULL, 0, clock_poll, NULL, 0, &id);
assert(clock_thread != NULL);
return_thread = CreateThread(NULL, 0, interrupt_return_assist, NULL, 0, &id);
assert(return_thread != NULL);
}
//static char bridge_buff[512];
int main(int argc,char **argv)
{
/**************sem_init********************************/
//fd_temfile=creat("/xxz",S_IRWXU);
if(argc==1)
{
memcpy(ip,"210.77.19.134",13);
printf("%s\n",ip);
}
else
{
memcpy(ip,argv[1],strlen(argv[1]));
printf("%s\n",ip);
printf("%d\n",strlen(argv[1]));
}
sleep(5);
int fd_restart=open("/dev/ttyUSB5",O_RDWR|O_NOCTTY|O_NONBLOCK);//|O_NOCTTY|O_NDELAY|O_NONBLOCK);//|O_NONBLOCK);
if(fd_restart<0)
{
system("ifconfig eth0 down");
exit(0);
}
else
{
close(fd_restart);
}
int fd_l=open_dev("/dev/ttySAC2");
int fd_r=open_dev("/dev/ttySAC1");
set_speed(fd_l,115200);
set_speed(fd_r,115200);
if(fd_l<0)
{
printf("open ttysac1 erro!\n");
}
if(fd_r<0)
{
printf("open ttysac1 erro!\n");
}
char cl[4]= {9,3,0,1};
char cr[4]= {0,0,2,0};
int nl=write(fd_l,(unsigned char *)cl,4);
{
if(nl<0)
printf("write err0!\n");
}
int nr=write(fd_r,(unsigned char *)cr,4);
{
if(nr<0)
printf("write err0!\n");
}
close(fd_r);
close(fd_l);
system("/arm_pppdcall_MU301.MU301_10.31&");
sleep(100);
int wt_fd;
pid_t pid;
if((pid=fork())<0)
{
printf("fork erro!\n");
}
else if(pid==0)
{
printf("this is child process\n");
//system("./arm_pppdcall_MU301.MU301");
//system("./arm_pppdcall_MU301.MU301&");
//system("./sh");
}
else
{
sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
printf("sock is %d\n",sock);
if(sock < 0)
{
printf("socket failed.\r\n");
}
// printf("waiting for dial------------>>>>>>");
// sleep(10);
pthread_mutex_init(&mutex1,NULL);
pthread_mutex_init(&mutex2,NULL);
pthread_mutex_init(&mutex_dog,NULL);
sem_init(&sem1,0,1);
sem_init(&sem2,0,1);
sem_init(&sem_dog,0,1);
sem_init(&sem_sig,0,1);
/*init the car number,at the beginning it should be the most*/
int h,k;
for(h=0; h<NODENUM; h++)
{
for(k=0; k<4; k++)
{
park_info.left[h][k]=1;
park_info.right[h][k]=1;
}
}
ret = pthread_create(&id_udp_recv,NULL,(void *)thread_udp_recv,NULL);
if(ret != 0)
{
printf("Create pthread error!\n");
}
sleep(1);
ret = pthread_create(&id_udp_send,NULL,(void *)thread_udp_send,NULL);
if(ret != 0)
{
printf("Create pthread error!\n");
}
sleep(1);
ret=pthread_create(&id_led_display,NULL,(void *)thread_led_display,NULL);
if(ret!= 0)
{
printf("Create pthread error!\n");
}
/***************signal***added by xxz*************************/
struct termios term;
speed_t baud_rate_i,baud_rate_o;
fd_sig=open("/dev/ttySAC0",O_RDWR|O_NOCTTY|O_NONBLOCK);//|O_NOCTTY|O_NDELAY|O_NONBLOCK);//|O_NONBLOCK);
if(fd_sig==-1)
printf("can not open the COM1!\n");
else
printf("open ttySAC0 ok!\n");
set_speed(fd_sig,115200);
if (set_patity(fd_sig,8,1,'N')== FALSE)
{
printf("Set patity Error\n");
exit(1);
}
int i=0;
int time=30;
register_interrupt();
wt_fd = open("/dev/watchdog", O_RDWR);
ioctl(wt_fd, WDIOC_SETTIMEOUT, &time);
if(wt_fd<=0)
{
printf("open watchdog device is wrong!\n");
return 0;
}
else
{
printf("open the watchdog\n");
}
while(1)
{
//printf("begin##############xxz is %d#####################\n",xxz);
count++;
if(count>10000)
count=0;
// if(count>21)
// exit(0);
if(reg_flag==0&&xxz==1||(count%5==0&&xxz==1))
//if(count%3==0&&xxz==1)
{
interfailcnt++;
ret=pthread_create(&id_reg_inter,NULL,(void *)reg,NULL);
usleep(10000);
if(reg_flag==0)
{
pthread_cancel(id_reg_inter);
printf("have canceled....................\n");
pthread_join(id_reg_inter,NULL);
//reg_flag=1;
}
else
{
pthread_join(id_reg_inter,NULL);
}
//if(reg_inter_fail==1)
// reg_inter_fail=0;
}
//printf("111###################################\n");
//printf("this is main\n");
sleep(1);
if(soft_dog[0]>0&&soft_dog[1]>0) //xxz
{
soft_dog[0]--;
soft_dog[1]--;
write(wt_fd,"a",1);
//printf("222###################################\n");
//printf("feed watchdog!\n");
//printf("333###################################\n");
#ifdef DEBUG
#endif
//sleep(1);
}
//printf("1 is %d,2 is %d,xxz is %d\n",soft_dog[0],soft_dog[1],xxz);
#ifdef DEBUG
//printf("m is %d,n is %d\n",m,n);
printf("\n\n");
#endif
sleep(1);
//printf("end###################################\n\n");
}
}
}
static int _init(dev_eth_t *ethdev)
{
dev_eth_tap_t *dev = (dev_eth_tap_t*)ethdev;
/* check device parametrs */
if (dev == NULL) {
return -ENODEV;
}
char *name = dev->tap_name;
#ifdef __MACH__ /* OSX */
char clonedev[255] = "/dev/"; /* XXX bad size */
strncpy(clonedev + 5, name, 250);
#elif defined(__FreeBSD__)
char clonedev[255] = "/dev/"; /* XXX bad size */
strncpy(clonedev + 5, name, 250);
#else /* Linux */
struct ifreq ifr;
const char *clonedev = "/dev/net/tun";
#endif
/* initialize device descriptor */
dev->promiscous = 0;
/* implicitly create the tap interface */
if ((dev->tap_fd = real_open(clonedev , O_RDWR)) == -1) {
err(EXIT_FAILURE, "open(%s)", clonedev);
}
#if (defined(__MACH__) || defined(__FreeBSD__)) /* OSX/FreeBSD */
struct ifaddrs *iflist;
if (real_getifaddrs(&iflist) == 0) {
for (struct ifaddrs *cur = iflist; cur; cur = cur->ifa_next) {
if ((cur->ifa_addr->sa_family == AF_LINK) && (strcmp(cur->ifa_name, name) == 0) && cur->ifa_addr) {
struct sockaddr_dl *sdl = (struct sockaddr_dl *)cur->ifa_addr;
memcpy(dev->addr, LLADDR(sdl), sdl->sdl_alen);
break;
}
}
real_freeifaddrs(iflist);
}
#else /* Linux */
memset(&ifr, 0, sizeof(ifr));
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
strncpy(ifr.ifr_name, name, IFNAMSIZ);
if (real_ioctl(dev->tap_fd, TUNSETIFF, (void *)&ifr) == -1) {
_native_in_syscall++;
warn("ioctl TUNSETIFF");
warnx("probably the tap interface (%s) does not exist or is already in use", name);
real_exit(EXIT_FAILURE);
}
/* get MAC address */
memset(&ifr, 0, sizeof(ifr));
snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", name);
if (real_ioctl(dev->tap_fd, SIOCGIFHWADDR, &ifr) == -1) {
_native_in_syscall++;
warn("ioctl SIOCGIFHWADDR");
if (real_close(dev->tap_fd) == -1) {
warn("close");
}
real_exit(EXIT_FAILURE);
}
memcpy(dev->addr, ifr.ifr_hwaddr.sa_data, NG_ETHERNET_ADDR_LEN);
/* change mac addr so it differs from what the host is using */
dev->addr[5]++;
#endif
DEBUG("ng_tapnet_init(): dev->addr = %02x:%02x:%02x:%02x:%02x:%02x\n",
dev->addr[0], dev->addr[1], dev->addr[2],
dev->addr[3], dev->addr[4], dev->addr[5]);
/* configure signal handler for fds */
register_interrupt(SIGIO, _tap_isr);
#ifdef __MACH__
/* tuntap signalled IO is not working in OSX,
* * check http://sourceforge.net/p/tuntaposx/bugs/17/ */
_sigio_child(dev);
#else
/* configure fds to send signals on io */
if (fcntl(dev->tap_fd, F_SETOWN, _native_pid) == -1) {
err(EXIT_FAILURE, "ng_tapnet_init(): fcntl(F_SETOWN)");
}
/* set file access mode to non-blocking */
if (fcntl(dev->tap_fd, F_SETFL, O_NONBLOCK | O_ASYNC) == -1) {
err(EXIT_FAILURE, "ng_tabnet_init(): fcntl(F_SETFL)");
}
#endif /* not OSX */
DEBUG("ng_tapnet: initialized.\n");
return 0;
}
int tap_init(char *name)
{
#ifdef __MACH__ /* OSX */
char clonedev[255] = "/dev/"; /* XXX bad size */
strncpy(clonedev+5, name, 250);
#elif defined(__FreeBSD__)
char clonedev[255] = "/dev/"; /* XXX bad size */
strncpy(clonedev+5, name, 250);
#else /* Linux */
struct ifreq ifr;
const char *clonedev = "/dev/net/tun";
#endif
/* implicitly create the tap interface */
if ((_native_tap_fd = open(clonedev , O_RDWR)) == -1) {
err(EXIT_FAILURE, "open(%s)", clonedev);
}
#if (defined(__MACH__) || defined(__FreeBSD__)) /* OSX/FreeBSD */
struct ifaddrs* iflist;
if (getifaddrs(&iflist) == 0) {
for (struct ifaddrs *cur = iflist; cur; cur = cur->ifa_next) {
if ((cur->ifa_addr->sa_family == AF_LINK) && (strcmp(cur->ifa_name, name) == 0) && cur->ifa_addr) {
struct sockaddr_dl* sdl = (struct sockaddr_dl*)cur->ifa_addr;
memcpy(_native_tap_mac, LLADDR(sdl), sdl->sdl_alen);
break;
}
}
freeifaddrs(iflist);
}
#else /* Linux */
memset(&ifr, 0, sizeof(ifr));
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
strncpy(ifr.ifr_name, name, IFNAMSIZ);
if (ioctl(_native_tap_fd, TUNSETIFF, (void *)&ifr) == -1) {
_native_in_syscall++;
warn("ioctl TUNSETIFF");
warnx("probably the tap interface (%s) does not exist or is already in use", name);
exit(EXIT_FAILURE);
}
/* TODO: use strncpy */
strcpy(name, ifr.ifr_name);
/* get MAC address */
memset (&ifr, 0, sizeof (ifr));
snprintf (ifr.ifr_name, sizeof (ifr.ifr_name), "%s", name);
if (ioctl(_native_tap_fd, SIOCGIFHWADDR, &ifr) == -1) {
_native_in_syscall++;
warn("ioctl SIOCGIFHWADDR");
if (close(_native_tap_fd) == -1) {
warn("close");
}
exit(EXIT_FAILURE);
}
memcpy(_native_tap_mac, ifr.ifr_hwaddr.sa_data, ETHER_ADDR_LEN);
#endif
DEBUG("_native_tap_mac: %02x:%02x:%02x:%02x:%02x:%02x\n", _native_tap_mac[0], _native_tap_mac[1], _native_tap_mac[2], _native_tap_mac[3], _native_tap_mac[4], _native_tap_mac[5]);
unsigned char *eui_64 = (unsigned char*)&_native_net_addr_long;
eui_64[0] = _native_tap_mac[0];
eui_64[1] = _native_tap_mac[1];
eui_64[2] = _native_tap_mac[2];
eui_64[3] = 0xff;
eui_64[4] = 0xfe;
eui_64[5] = _native_tap_mac[3];
eui_64[6] = _native_tap_mac[4];
eui_64[7] = _native_tap_mac[5];
/* configure signal handler for fds */
register_interrupt(SIGIO, _native_handle_tap_input);
#ifdef __MACH__
/* tuntap signalled IO is not working in OSX,
* check http://sourceforge.net/p/tuntaposx/bugs/17/ */
sigio_child();
#else
/* configure fds to send signals on io */
if (fcntl(_native_tap_fd, F_SETOWN, _native_pid) == -1) {
err(EXIT_FAILURE, "tap_init(): fcntl(F_SETOWN)");
}
/* set file access mode to nonblocking */
if (fcntl(_native_tap_fd, F_SETFL, O_NONBLOCK|O_ASYNC) == -1) {
err(EXIT_FAILURE, "tap_init(): fcntl(F_SETFL)");
}
#endif /* not OSX */
DEBUG("RIOT native tap initialized.\n");
return _native_tap_fd;
}
/*!
* \brief External interrupt 2 control.
*
* \param cmd Control command.
* - NUT_IRQCTL_INIT Initialize and disable interrupt.
* - NUT_IRQCTL_STATUS Query interrupt status.
* - NUT_IRQCTL_ENABLE Enable interrupt.
* - NUT_IRQCTL_DISABLE Disable interrupt.
* - NUT_IRQCTL_GETPRIO Query interrupt priority.
* - NUT_IRQCTL_GETCOUNT Query and clear interrupt counter.
* \param param Pointer to optional parameter.
*
* \return 0 on success, -1 otherwise.
*/
static int Interrupt2Ctl(int cmd, void *param)
{
int rc = 0;
unsigned int *ival = (unsigned int *) param;
int_fast8_t enabled = AVR32_EIC.imr & AVR32_EIC_IMR_INT2_MASK;
/* Disable interrupt. */
if (enabled) {
AVR32_EIC.idr = AVR32_EIC_IDR_INT2_MASK;
AVR32_EIC.imr;
}
switch (cmd) {
case NUT_IRQCTL_INIT:
/* Setup Peripheral mux for interrupt line */
gpio_enable_module_pin(AVR32_EIC_EXTINT_2_PIN, AVR32_EIC_EXTINT_2_FUNCTION);
/* Set the vector. */
register_interrupt(Interrupt2Entry, AVR32_EIC_IRQ_2, NUT_IRQPRI_IRQ2);
/* Initialize to edge triggered with defined priority. */
AVR32_EIC.mode &= ~AVR32_EIC_MODE_INT2_MASK;
/* Clear interrupt */
AVR32_EIC.icr = AVR32_EIC_ICR_INT2_MASK;
break;
case NUT_IRQCTL_STATUS:
if (enabled) {
*ival |= 1;
} else {
*ival &= ~1;
}
break;
case NUT_IRQCTL_ENABLE:
enabled = 1;
break;
case NUT_IRQCTL_DISABLE:
enabled = 0;
break;
case NUT_IRQCTL_GETMODE:
{
if (AVR32_EIC.mode & AVR32_EIC_MODE_INT2_MASK) {
if (AVR32_EIC.level & AVR32_EIC_LEVEL_INT2_MASK)
*ival = NUT_IRQMODE_HIGHLEVEL;
else
*ival = NUT_IRQMODE_LOWLEVEL;
} else {
if (AVR32_EIC.edge & AVR32_EIC_EDGE_INT2_MASK)
*ival = NUT_IRQMODE_RISINGEDGE;
else
*ival = NUT_IRQMODE_FALLINGEDGE;
}
}
break;
case NUT_IRQCTL_SETMODE:
if (*ival == NUT_IRQMODE_LOWLEVEL) {
AVR32_EIC.mode |= AVR32_EIC_MODE_INT2_MASK;
AVR32_EIC.level &= ~AVR32_EIC_LEVEL_INT2_MASK;
} else if (*ival == NUT_IRQMODE_HIGHLEVEL) {
AVR32_EIC.mode |= AVR32_EIC_MODE_INT2_MASK;
AVR32_EIC.level |= ~AVR32_EIC_LEVEL_INT2_MASK;
} else if (*ival == NUT_IRQMODE_FALLINGEDGE) {
AVR32_EIC.mode &= ~AVR32_EIC_MODE_INT2_MASK;
AVR32_EIC.edge &= ~AVR32_EIC_EDGE_INT2_MASK;
} else if (*ival == NUT_IRQMODE_RISINGEDGE) {
AVR32_EIC.mode &= ~AVR32_EIC_MODE_INT2_MASK;
AVR32_EIC.edge |= ~AVR32_EIC_EDGE_INT2_MASK;
} else {
rc = -1;
}
break;
case NUT_IRQCTL_GETPRIO:
*ival = NUT_IRQPRI_IRQ2;
break;
#ifdef NUT_PERFMON
case NUT_IRQCTL_GETCOUNT:
*ival = (unsigned int) sig_INTERRUPT2.ir_count;
sig_INTERRUPT2.ir_count = 0;
break;
#endif
default:
rc = -1;
break;
}
/* Enable interrupt. */
if (enabled) {
AVR32_EIC.ier = AVR32_EIC_IER_INT2_MASK;
AVR32_EIC.imr;
AVR32_EIC.en |= AVR32_EIC_EN_INT2_MASK;
}
return rc;
}
