int rtems_minimac_driver_attach(struct rtems_bsdnet_ifconfig *config, int attaching) { struct ifnet *ifp; rtems_isr_entry dummy; int i; static int registered; uint8_t *tx_buffer = (uint8_t *)MINIMAC_TX_BASE; if(!attaching) { printk("Minimac driver cannot be detached.\n"); return 0; } ifp = &(arpcom.ac_if); if(registered) { printk("Minimac driver already in use.\n"); return 0; } registered = 1; memcpy(arpcom.ac_enaddr, get_mac_address(), 6); ifp->if_mtu = ETHERMTU; ifp->if_unit = 0; ifp->if_name = "minimac"; ifp->if_init = minimac_init; ifp->if_ioctl = minimac_ioctl; ifp->if_start = minimac_start; ifp->if_output = ether_output; ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX; ifp->if_snd.ifq_maxlen = ifqmaxlen; if_attach(ifp); ether_ifattach(ifp); rx_daemon_id = rtems_bsdnet_newproc("mrxd", 4096, rx_daemon, NULL); tx_daemon_id = rtems_bsdnet_newproc("mtxd", 4096, tx_daemon, NULL); rtems_interrupt_catch(rx_interrupt_handler, MM_IRQ_ETHRX, &dummy); rtems_interrupt_catch(tx_interrupt_handler, MM_IRQ_ETHTX, &dummy); MM_WRITE(MM_MINIMAC_STATE0, MINIMAC_STATE_LOADED); MM_WRITE(MM_MINIMAC_STATE1, MINIMAC_STATE_LOADED); for(i=0;i<7; i++) tx_buffer[i] = 0x55; tx_buffer[7] = 0xd5; MM_WRITE(MM_MINIMAC_SETUP, 0); rtems_bsdnet_event_send(tx_daemon_id, CTS_EVENT); bsp_interrupt_vector_enable(MM_IRQ_ETHRX); bsp_interrupt_vector_enable(MM_IRQ_ETHTX); return 1; }
rtems_device_driver usbinput_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *arg ) { rtems_status_code sc; rtems_isr_entry dummy; MM_WRITE(MM_SOFTUSB_CONTROL, SOFTUSB_CONTROL_RESET); mouse_consume = 0; keyboard_consume = 0; midi_consume = 0; sc = rtems_io_register_name(DEVICE_NAME, major, 0); RTEMS_CHECK_SC(sc, "create USB input device"); sc = rtems_message_queue_create( rtems_build_name('U', 'S', 'B', 'I'), 64, 8, 0, &event_q ); RTEMS_CHECK_SC(sc, "create USB event queue"); rtems_interrupt_catch(interrupt_handler, MM_IRQ_USB, &dummy); bsp_interrupt_vector_enable(MM_IRQ_USB); return RTEMS_SUCCESSFUL; }
rtems_device_driver pfpu_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *arg ) { rtems_status_code sc; rtems_isr_entry dummy; sc = rtems_io_register_name(DEVICE_NAME, major, 0); RTEMS_CHECK_SC(sc, "create PFPU device"); sc = rtems_semaphore_create( rtems_build_name('P', 'F', 'P', 'U'), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE, 0, &done_sem ); RTEMS_CHECK_SC(sc, "create PFPU done semaphore"); rtems_interrupt_catch(done_handler, MM_IRQ_PFPU, &dummy); bsp_interrupt_vector_enable(MM_IRQ_PFPU); return RTEMS_SUCCESSFUL; }
rtems_device_driver ir_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *arg ) { rtems_status_code sc; rtems_isr_entry dummy; sc = rtems_io_register_name(DEVICE_NAME, major, 0); RTEMS_CHECK_SC(sc, "create IR input device"); sc = rtems_message_queue_create( rtems_build_name('R', 'C', '5', 'Q'), 64, 2, 0, &ir_q ); RTEMS_CHECK_SC(sc, "create IR queue"); rtems_interrupt_catch(interrupt_handler, MM_IRQ_IR, &dummy); bsp_interrupt_vector_enable(MM_IRQ_IR); return RTEMS_SUCCESSFUL; }
static void bsp_interrupt_server_task(rtems_task_argument arg) { rtems_status_code sc = RTEMS_SUCCESSFUL; while (true) { rtems_event_set events = 0; bsp_interrupt_server_entry *e = NULL; sc = rtems_event_receive( BSP_INTERRUPT_EVENT, RTEMS_EVENT_ALL | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &events ); if (sc != RTEMS_SUCCESSFUL) { break; } while ((e = bsp_interrupt_server_get_entry()) != NULL) { (*e->handler)(e->arg); bsp_interrupt_vector_enable(e->vector); } } rtems_task_delete(RTEMS_SELF); }
void Clock_driver_support_initialize_hardware(void) { MM_WRITE(MM_TIMER0_COMPARE, (MM_READ(MM_FREQUENCY)/(1000000/rtems_configuration_get_microseconds_per_tick()))); MM_WRITE(MM_TIMER0_COUNTER, 0); MM_WRITE(MM_TIMER0_CONTROL, TIMER_ENABLE | TIMER_AUTORESTART); bsp_interrupt_vector_enable(MM_IRQ_TIMER0); }
static rtems_status_code submit_record(struct snd_buffer *buf) { bsp_interrupt_vector_disable(MM_IRQ_AC97DMAW); if (record_level == RECORD_Q_SIZE) { bsp_interrupt_vector_enable(MM_IRQ_AC97DMAW); return RTEMS_UNSATISFIED; } record_q[record_produce] = buf; record_produce = (record_produce + 1) & RECORD_Q_MASK; record_level++; if (record_level == 1) record_start(buf); bsp_interrupt_vector_enable(MM_IRQ_AC97DMAW); return RTEMS_SUCCESSFUL; }
static rtems_status_code submit_play(struct snd_buffer *buf) { bsp_interrupt_vector_disable(MM_IRQ_AC97DMAR); if (play_level == PLAY_Q_SIZE) { bsp_interrupt_vector_enable(MM_IRQ_AC97DMAR); return RTEMS_UNSATISFIED; } play_q[play_produce] = buf; play_produce = (play_produce + 1) & PLAY_Q_MASK; play_level++; if (play_level == 1) play_start(buf); bsp_interrupt_vector_enable(MM_IRQ_AC97DMAR); return RTEMS_SUCCESSFUL; }
static rtems_status_code i2c_wait_done(stm32f4_i2c_bus_entry *e) { rtems_status_code sc = RTEMS_SUCCESSFUL; bsp_interrupt_vector_enable(e->vector); e->task_id = rtems_task_self(); return rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT); }
rtems_device_driver console_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *arg ) { rtems_status_code status; rtems_isr_entry dummy; rtems_termios_initialize(); status = rtems_io_register_name("/dev/console", major, 0); if (status != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred(status); rtems_interrupt_catch(mmconsole_interrupt, MM_IRQ_UART, &dummy); bsp_interrupt_vector_enable(MM_IRQ_UART); MM_WRITE(MM_UART_CTRL, UART_CTRL_RX_INT|UART_CTRL_TX_INT); return RTEMS_SUCCESSFUL; }
rtems_device_driver video_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *arg ) { rtems_status_code sc; rtems_isr_entry dummy; int i; MM_WRITE(MM_BT656_I2C, BT656_I2C_SDC); sc = rtems_io_register_name(DEVICE_NAME, major, 0); RTEMS_CHECK_SC(sc, "create video input device"); rtems_interrupt_catch(frame_handler, MM_IRQ_VIDEOIN, &dummy); bsp_interrupt_vector_enable(MM_IRQ_VIDEOIN); for(i=0;i<sizeof(vreg_addr);i++) write_reg(vreg_addr[i], vreg_dat[i]); return RTEMS_SUCCESSFUL; }
static int BSP_uart_isOn(const rtems_raw_irq_connect_data* used) { return bsp_interrupt_vector_enable(used->idtIndex - BSP_IRQ_VECTOR_BASE); }
static void BSP_uart_on(const rtems_raw_irq_connect_data* used) { bsp_interrupt_vector_enable(used->idtIndex - BSP_IRQ_VECTOR_BASE); }
rtems_device_driver video_control( rtems_device_major_number major, rtems_device_minor_number minor, void *arg ) { rtems_libio_ioctl_args_t *args = arg; unsigned int *a = (unsigned int *)args->buffer; rtems_status_code sc; switch (args->command) { case VIDEO_BUFFER_LOCK: if (last_buffer == -1) { *a = 0; } else { bsp_interrupt_vector_disable(MM_IRQ_VIDEOIN); if(*a) invalidate_caches(); *a = (unsigned int)buffers[last_buffer]; buffers_locked[last_buffer] = true; bsp_interrupt_vector_enable(MM_IRQ_VIDEOIN); } sc = RTEMS_SUCCESSFUL; break; case VIDEO_BUFFER_UNLOCK: { int i; for(i=0;i<N_BUFFERS;i++) { if ((unsigned int)buffers[i] == (unsigned int)a) { buffers_locked[i] = false; break; } } sc = RTEMS_SUCCESSFUL; break; } case VIDEO_SET_BRIGHTNESS: write_reg(0x0a, (unsigned int)a); sc = RTEMS_SUCCESSFUL; break; case VIDEO_GET_BRIGHTNESS: *a = read_reg(0x0a); sc = RTEMS_SUCCESSFUL; break; case VIDEO_SET_CONTRAST: write_reg(0x08, (unsigned int)a); sc = RTEMS_SUCCESSFUL; break; case VIDEO_GET_CONTRAST: *a = read_reg(0x08); sc = RTEMS_SUCCESSFUL; break; case VIDEO_SET_HUE: write_reg(0x0b, (unsigned int)a); sc = RTEMS_SUCCESSFUL; break; case VIDEO_GET_HUE: *a = read_reg(0x0b); sc = RTEMS_SUCCESSFUL; break; case VIDEO_GET_SIGNAL: *a = read_reg(0x10); sc = RTEMS_SUCCESSFUL; break; case VIDEO_SET_REGISTER: write_reg(((unsigned int)a & 0xffff0000) >> 16, (unsigned int)a & 0x0000ffff); sc = RTEMS_SUCCESSFUL; break; case VIDEO_GET_REGISTER: *a = read_reg(*a); sc = RTEMS_SUCCESSFUL; break; case VIDEO_SET_FORMAT: set_format((int)a); sc = RTEMS_SUCCESSFUL; break; default: sc = RTEMS_UNSATISFIED; break; } if (sc == RTEMS_SUCCESSFUL) args->ioctl_return = 0; else args->ioctl_return = -1; return sc; }
/** * @brief Installs an interrupt handler. * * @ingroup bsp_interrupt * * @return In addition to the standard status codes this function returns: * - If the BSP interrupt support is not initialized RTEMS_INTERNAL_ERROR will * be returned. * - If not enough memory for a new handler is available RTEMS_NO_MEMORY will * be returned * * @see rtems_interrupt_handler_install() */ static rtems_status_code bsp_interrupt_handler_install( rtems_vector_number vector, const char *info, rtems_option options, rtems_interrupt_handler handler, void *arg ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_interrupt_level level; rtems_vector_number index = 0; bsp_interrupt_handler_entry *head = NULL; bsp_interrupt_handler_entry *tail = NULL; bsp_interrupt_handler_entry *current = NULL; bsp_interrupt_handler_entry *match = NULL; bool enable_vector = false; /* Check parameters and system state */ if (!bsp_interrupt_is_initialized()) { return RTEMS_INTERNAL_ERROR; } else if (!bsp_interrupt_is_valid_vector(vector)) { return RTEMS_INVALID_ID; } else if (handler == NULL) { return RTEMS_INVALID_ADDRESS; } else if (rtems_interrupt_is_in_progress()) { return RTEMS_CALLED_FROM_ISR; } /* Lock */ sc = bsp_interrupt_lock(); if (sc != RTEMS_SUCCESSFUL) { return sc; } /* Get handler table index */ index = bsp_interrupt_handler_index(vector); /* Get head entry of the handler list for current vector */ head = &bsp_interrupt_handler_table [index]; if (bsp_interrupt_is_empty_handler_entry(head)) { /* * No real handler installed yet. So allocate a new index in * the handler table and fill the entry with life. */ if (bsp_interrupt_allocate_handler_index(vector, &index)) { rtems_interrupt_disable(level); bsp_interrupt_handler_table [index].handler = handler; bsp_interrupt_handler_table [index].arg = arg; #ifdef BSP_INTERRUPT_USE_INDEX_TABLE bsp_interrupt_handler_index_table [vector] = index; #endif rtems_interrupt_enable(level); bsp_interrupt_handler_table [index].info = info; } else { /* Handler table is full */ bsp_interrupt_unlock(); return RTEMS_NO_MEMORY; } /* This is the first handler so enable the vector later */ enable_vector = true; } else { /* Ensure that a unique handler remains unique */ if ( RTEMS_INTERRUPT_IS_UNIQUE(options) || bsp_interrupt_is_handler_unique(index) ) { /* * Tried to install a unique handler on a not empty * list or there is already a unique handler installed. */ bsp_interrupt_unlock(); return RTEMS_RESOURCE_IN_USE; } /* * Search for the list tail and check if the handler is already * installed. */ current = head; do { if (current->handler == handler && current->arg == arg) { match = current; } tail = current; current = current->next; } while (current != NULL); /* Ensure the handler is not already installed */ if (match != NULL) { /* The handler is already installed */ bsp_interrupt_unlock(); return RTEMS_TOO_MANY; } /* Allocate a new entry */ current = bsp_interrupt_allocate_handler_entry(); if (current == NULL) { /* Not enough memory */ bsp_interrupt_unlock(); return RTEMS_NO_MEMORY; } /* Set entry */ current->handler = handler; current->arg = arg; current->info = info; current->next = NULL; /* Link to list tail */ rtems_interrupt_disable(level); tail->next = current; rtems_interrupt_enable(level); } /* Make the handler unique if necessary */ bsp_interrupt_set_handler_unique(index, RTEMS_INTERRUPT_IS_UNIQUE(options)); /* Enable the vector if necessary */ if (enable_vector) { sc = bsp_interrupt_vector_enable(vector); if (sc != RTEMS_SUCCESSFUL) { bsp_interrupt_unlock(); return sc; } } /* Unlock */ sc = bsp_interrupt_unlock(); if (sc != RTEMS_SUCCESSFUL) { return sc; } return RTEMS_SUCCESSFUL; }
rtems_device_driver ac97_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *arg ) { rtems_status_code sc; rtems_isr_entry dummy; sc = rtems_io_register_name(SND_DEVICE_NAME, major, 0); RTEMS_CHECK_SC(sc, "create snd device"); sc = rtems_io_register_name(MIXER_DEVICE_NAME, major, 1); RTEMS_CHECK_SC(sc, "create mixer device"); sc = rtems_semaphore_create( rtems_build_name('C', 'R', 'W', 'S'), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE, 0, &cr_write_sem ); RTEMS_CHECK_SC(sc, "create AC97 register write semaphore"); sc = rtems_semaphore_create( rtems_build_name('C', 'R', 'R', 'S'), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE, 0, &cr_read_sem ); RTEMS_CHECK_SC(sc, "create AC97 register read semaphore"); sc = rtems_message_queue_create( rtems_build_name('P', 'L', 'Y', 'Q'), PLAY_Q_SIZE*2, sizeof(void *), 0, &play_q_done ); RTEMS_CHECK_SC(sc, "create playback done queue"); sc = rtems_message_queue_create( rtems_build_name('R', 'E', 'C', 'Q'), RECORD_Q_SIZE*2, sizeof(void *), 0, &record_q_done ); RTEMS_CHECK_SC(sc, "create record done queue"); rtems_interrupt_catch(crrequest_handler, MM_IRQ_AC97CRREQUEST, &dummy); rtems_interrupt_catch(crreply_handler, MM_IRQ_AC97CRREPLY, &dummy); rtems_interrupt_catch(pcmplay_handler, MM_IRQ_AC97DMAR, &dummy); rtems_interrupt_catch(pcmrecord_handler, MM_IRQ_AC97DMAW, &dummy); bsp_interrupt_vector_enable(MM_IRQ_AC97CRREQUEST); bsp_interrupt_vector_enable(MM_IRQ_AC97CRREPLY); bsp_interrupt_vector_enable(MM_IRQ_AC97DMAR); bsp_interrupt_vector_enable(MM_IRQ_AC97DMAW); play_produce = 0; play_consume = 0; play_level = 0; record_produce = 0; record_consume = 0; record_level = 0; return RTEMS_SUCCESSFUL; }