static void qoriq_clock_handler_install(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; #if defined(RTEMS_MULTIPROCESSING) && !defined(RTEMS_SMP) { Processor_mask affinity; _Processor_mask_From_index(&affinity, ppc_processor_id()); bsp_interrupt_set_affinity(CLOCK_INTERRUPT, &affinity); } #endif sc = qoriq_pic_set_priority( CLOCK_INTERRUPT, QORIQ_PIC_PRIORITY_LOWEST, NULL ); if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred(0xdeadbeef); } sc = rtems_interrupt_handler_install( CLOCK_INTERRUPT, "Clock", RTEMS_INTERRUPT_UNIQUE, Clock_isr, NULL ); if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred(0xdeadbeef); } }
void rtems_filesystem_initialize( void ) { int rv = 0; const rtems_filesystem_mount_configuration *root_config = &rtems_filesystem_root_configuration; rv = mount( root_config->source, root_config->target, root_config->filesystemtype, root_config->options, root_config->data ); if ( rv != 0 ) rtems_fatal_error_occurred( 0xABCD0002 ); /* * Traditionally RTEMS devices are under "/dev" so install this directory. * * If the mkdir() fails, we can't print anything so just fatal error. */ rv = mkdir( "/dev", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH ); if ( rv != 0 ) rtems_fatal_error_occurred( 0xABCD0003 ); /* * You can't mount another filesystem properly until the mount point * it will be mounted onto is created. Moreover, if it is going to * use a device, then it is REALLY unfair to attempt this * before device drivers are initialized. So we return via a base * filesystem image and nothing auto-mounted at this point. */ }
void ReInstall_clock(void (*new_clock_isr)(void *)) { uint32_t isrlevel = 0; rtems_irq_connect_data clockIrqConnData; rtems_interrupt_disable(isrlevel); clockIrqConnData.name = BSP_PIT; if ( ! BSP_get_current_rtems_irq_handler(&clockIrqConnData)) { printk("Unable to stop system clock\n"); rtems_fatal_error_occurred(1); } BSP_remove_rtems_irq_handler (&clockIrqConnData); clockIrqConnData.on = ClockOn; clockIrqConnData.off = ClockOff; clockIrqConnData.isOn = ClockIsOn; clockIrqConnData.name = BSP_PIT; clockIrqConnData.hdl = new_clock_isr; if (!BSP_install_rtems_irq_handler (&clockIrqConnData)) { printk("Unable to connect Clock Irq handler\n"); rtems_fatal_error_occurred(1); } rtems_interrupt_enable(isrlevel); }
void exceptionHandler(int vector, void (*handler)(void)) { rtems_raw_irq_connect_data excep_raw_irq_data; excep_raw_irq_data.idtIndex = vector; if(!i386_get_current_idt_entry(&excep_raw_irq_data)) { printk("GDB: cannot get idt entry\n"); rtems_fatal_error_occurred(1); } if(!i386_delete_idt_entry(&excep_raw_irq_data)) { printk("GDB: cannot delete idt entry\n"); rtems_fatal_error_occurred(1); } excep_raw_irq_data.on = nop; excep_raw_irq_data.off = nop; excep_raw_irq_data.isOn = isOn; excep_raw_irq_data.hdl = handler; if (!i386_set_idt_entry (&excep_raw_irq_data)) { printk("GDB: raw exception handler connection failed\n"); rtems_fatal_error_occurred(1); } return; }
/* * Interface to file system close. * * *pipep points to pipe control structure. When the last user releases pipe, * it will be set to NULL. */ int pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) { pipe_control_t *pipe = *pipep; uint32_t mode; rtems_status_code sc; sc = rtems_semaphore_obtain(pipe->Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); /* WARN pipe not released! */ if(sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred(sc); mode = LIBIO_ACCMODE(iop); if (mode & LIBIO_FLAGS_READ) pipe->Readers --; if (mode & LIBIO_FLAGS_WRITE) pipe->Writers --; sc = rtems_semaphore_obtain(rtems_pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); /* WARN pipe not freed and pipep not set to NULL! */ if(sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred(sc); PIPE_UNLOCK(pipe); if (pipe->Readers == 0 && pipe->Writers == 0) { #if 0 /* To delete an anonymous pipe file when all users closed it */ if (pipe->Anonymous) delfile = TRUE; #endif pipe_free(pipe); *pipep = NULL; } else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE) /* Notify waiting Writers that all their partners left */ PIPE_WAKEUPWRITERS(pipe); else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ) PIPE_WAKEUPREADERS(pipe); rtems_semaphore_release(rtems_pipe_semaphore); #if 0 if (! delfile) return 0; if (iop->pathinfo.ops->unlink_h == NULL) return 0; /* This is safe for IMFS, but how about other FSes? */ iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return -errno; #endif return 0; }
/* * This is a replaceable stub which opens the console, if present. */ void open_dev_console(void) { int stdin_fd; int stdout_fd; int stderr_fd; /* * Attempt to open /dev/console. */ if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) { /* * There may not be a console driver so this is OK. */ return; } /* * But if we find /dev/console once, we better find it twice more * or something is REALLY wrong. */ if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1) rtems_fatal_error_occurred( 0x55544431 ); /* error STD1 */ if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1) rtems_fatal_error_occurred( 0x55544432 ); /* error STD2 */ }
/* * ide_controller_initialize -- * Initializes all configured IDE controllers. Controllers configuration * table is provided by BSP * * PARAMETERS: * major - device major number * minor_arg - device minor number * args - arguments * * RETURNS: * RTEMS_SUCCESSFUL on success, or error code if * error occured */ rtems_device_driver ide_controller_initialize(rtems_device_major_number major, rtems_device_minor_number minor_arg, void *args) { unsigned long minor; /* FIXME: may be it should be done on compilation phase */ if (IDE_Controller_Count > IDE_CTRL_MAX_MINOR_NUMBER) rtems_fatal_error_occurred(RTEMS_TOO_MANY); for (minor=0; minor < IDE_Controller_Count; minor++) { IDE_Controller_Table[minor].status = IDE_CTRL_NON_INITIALIZED; if ((IDE_Controller_Table[minor].probe == NULL || IDE_Controller_Table[minor].probe(minor)) && (IDE_Controller_Table[minor].fns->ctrl_probe == NULL || IDE_Controller_Table[minor].fns->ctrl_probe(minor))) { dev_t dev; dev = rtems_filesystem_make_dev_t( major, minor ); if (mknod(IDE_Controller_Table[minor].name, 0777 | S_IFBLK, dev ) < 0) rtems_fatal_error_occurred(errno); IDE_Controller_Table[minor].fns->ctrl_initialize(minor); IDE_Controller_Table[minor].status = IDE_CTRL_INITIALIZED; } } return RTEMS_SUCCESSFUL; }
/*-------------------------------------------------------------------------+ | Console device driver INITIALIZE entry point. +--------------------------------------------------------------------------+ | Initilizes the I/O console (keyboard + VGA display) driver. +--------------------------------------------------------------------------*/ rtems_device_driver console_initialize(rtems_device_major_number major, rtems_device_minor_number minor, void *arg) { rtems_status_code status; /* * Set up TERMIOS */ rtems_termios_initialize (); /* * Do device-specific initialization */ /* 115200-8-N-1, without hardware flow control */ BSP_uart_init(BSPConsolePort, 115200, CHR_8_BITS, 0, 0, 0); /* Set interrupt handler */ if(BSPConsolePort == BSP_UART_COM1) { console_isr_data.name = BSP_UART_COM1_IRQ; console_isr_data.hdl = BSP_uart_termios_isr_com1; } else { assert(BSPConsolePort == BSP_UART_COM2); console_isr_data.name = BSP_UART_COM2_IRQ; console_isr_data.hdl = BSP_uart_termios_isr_com2; } status = BSP_install_rtems_irq_handler(&console_isr_data); if (!status){ printk("Error installing serial console interrupt handler!\n"); rtems_fatal_error_occurred(status); } /* * Register the device */ status = rtems_io_register_name ("/dev/console", major, 0); if (status != RTEMS_SUCCESSFUL) { printk("Error registering console device!\n"); rtems_fatal_error_occurred (status); } if(BSPConsolePort == BSP_UART_COM1) { printk("Initialized console on port COM1 115200-8-N-1\n\n"); } else { printk("Initialized console on port COM2 115200-8-N-1\n\n"); } return RTEMS_SUCCESSFUL; } /* console_initialize */
static void qoriq_clock_handler_install(rtems_isr_entry *old_isr) { rtems_status_code sc = RTEMS_SUCCESSFUL; *old_isr = NULL; sc = qoriq_pic_set_affinity( CLOCK_INTERRUPT, ppc_processor_id() ); if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred(0xdeadbeef); } sc = qoriq_pic_set_priority( CLOCK_INTERRUPT, QORIQ_PIC_PRIORITY_LOWEST, NULL ); if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred(0xdeadbeef); } sc = rtems_interrupt_handler_install( CLOCK_INTERRUPT, "Clock", RTEMS_INTERRUPT_UNIQUE, Clock_isr, NULL ); if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred(0xdeadbeef); } }
/* * Test Device Driver Entry Points */ rtems_device_driver termios_test_driver_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *arg ) { rtems_status_code status; rtems_termios_initialize(); /* * Register Device Names */ (void) rtems_io_register_name( TERMIOS_TEST_DRIVER_DEVICE_NAME, major, 0 ); status = rtems_timer_create(rtems_build_name('T', 'M', 'R', 'X'), &Rx_Timer); if ( status ) rtems_fatal_error_occurred(1);; status = rtems_timer_create(rtems_build_name('T', 'M', 'T', 'X'), &Tx_Timer); if ( status ) rtems_fatal_error_occurred(1);; return RTEMS_SUCCESSFUL; }
/* console_initialize -- * This routine initializes the console IO drivers and register devices * in RTEMS I/O system. * * PARAMETERS: * major - major console device number * minor - minor console device number (not used) * arg - device initialize argument * * RETURNS: * RTEMS error code (RTEMS_SUCCESSFUL if device initialized successfuly) */ rtems_device_driver console_initialize(rtems_device_major_number major, rtems_device_minor_number minor, void *arg) { rtems_status_code status; #ifdef SH4_WITH_IPL /* booting from flash we cannot have IPL console */ if (boot_mode != SH4_BOOT_MODE_IPL && console_mode == CONSOLE_MODE_IPL) console_mode = CONSOLE_MODE_INT; /* break out from gdb if neccessary */ if (boot_mode == SH4_BOOT_MODE_IPL && console_mode != CONSOLE_MODE_IPL) ipl_finish(); #endif /* * Set up TERMIOS */ if ((console_mode != CONSOLE_MODE_RAW) && (console_mode != CONSOLE_MODE_IPL)) rtems_termios_initialize (); /* * Register the devices */ status = rtems_io_register_name ("/dev/console", major, 0); if (status != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (status); status = rtems_io_register_name ("/dev/aux", major, 1); if (status != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (status); if (console_mode == CONSOLE_MODE_RAW) { rtems_status_code sc; sc = sh4uart_init(&sh4_uarts[0], /* uart */ NULL, /* tty */ 1, /* UART channel number */ 0); /* Poll-mode */ if (sc == RTEMS_SUCCESSFUL) sc = sh4uart_reset(&sh4_uarts[0]); sc = sh4uart_init(&sh4_uarts[1], /* uart */ NULL, /* tty */ 2, /* UART channel number */ 0); /* Poll-mode */ if (sc == RTEMS_SUCCESSFUL) sc = sh4uart_reset(&sh4_uarts[1]); return sc; } return RTEMS_SUCCESSFUL; }
/* * Read/write handling */ static int sparse_disk_read_write( rtems_sparse_disk *sparse_disk, rtems_blkdev_request *req, const bool read ) { int rv = 0; uint32_t req_buffer; rtems_blkdev_sg_buffer *scatter_gather; rtems_blkdev_bnum block; uint8_t *buff; size_t buff_size; unsigned int bytes_handled; rtems_status_code sc; sc = rtems_semaphore_obtain(sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred( 0xdeadbeef ); } for ( req_buffer = 0; ( 0 <= rv ) && ( req_buffer < req->bufnum ); ++req_buffer ) { scatter_gather = &req->bufs[req_buffer]; bytes_handled = 0; buff = (uint8_t *) scatter_gather->buffer; block = scatter_gather->block; buff_size = scatter_gather->length; while ( ( 0 <= rv ) && ( 0 < buff_size ) ) { if ( read ) rv = sparse_disk_read_block( sparse_disk, block, &buff[bytes_handled], buff_size ); else rv = sparse_disk_write_block( sparse_disk, block, &buff[bytes_handled], buff_size ); ++block; bytes_handled += rv; buff_size -= rv; } } sc = rtems_semaphore_release( sparse_disk->mutex ); if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred( 0xdeadbeef ); } if ( 0 > rv ) rtems_blkdev_request_done( req, RTEMS_IO_ERROR ); else rtems_blkdev_request_done( req, RTEMS_SUCCESSFUL ); return 0; }
/* * ns16550_initialize_interrupts * * This routine initializes the port to operate in interrupt driver mode. */ NS16550_STATIC void ns16550_initialize_interrupts( int minor) { #if defined(BSP_FEATURE_IRQ_EXTENSION) || defined(BSP_FEATURE_IRQ_LEGACY) console_tbl *c = Console_Port_Tbl [minor]; #endif console_data *d = &Console_Port_Data [minor]; d->bActive = false; #ifdef BSP_FEATURE_IRQ_EXTENSION { rtems_status_code sc = RTEMS_SUCCESSFUL; sc = rtems_interrupt_handler_install( c->ulIntVector, "NS16550", RTEMS_INTERRUPT_SHARED, ns16550_isr, (void *) minor ); if (sc != RTEMS_SUCCESSFUL) { /* FIXME */ printk( "%s: Error: Install interrupt handler\n", __func__); rtems_fatal_error_occurred( 0xdeadbeef); } } #elif defined(BSP_FEATURE_IRQ_LEGACY) { int rv = 0; #ifdef BSP_FEATURE_IRQ_LEGACY_SHARED_HANDLER_SUPPORT rtems_irq_connect_data cd = { c->ulIntVector, ns16550_isr, (void *) minor, NULL, NULL, NULL, NULL }; rv = BSP_install_rtems_shared_irq_handler( &cd); #else rtems_irq_connect_data cd = { c->ulIntVector, ns16550_isr, (void *) minor, NULL, NULL, NULL }; rv = BSP_install_rtems_irq_handler( &cd); #endif if (rv == 0) { /* FIXME */ printk( "%s: Error: Install interrupt handler\n", __func__); rtems_fatal_error_occurred( 0xdeadbeef); } } #endif }
/* * Interface to file system close. * * *pipep points to pipe control structure. When the last user releases pipe, * it will be set to NULL. */ void pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) { pipe_control_t *pipe = *pipep; uint32_t mode; #if defined(RTEMS_DEBUG) /* WARN pipe not freed and pipep not set to NULL! */ if (pipe_lock()) rtems_fatal_error_occurred(0xdeadbeef); /* WARN pipe not released! */ if (!PIPE_LOCK(pipe)) rtems_fatal_error_occurred(0xdeadbeef); #endif mode = LIBIO_ACCMODE(iop); if (mode & LIBIO_FLAGS_READ) pipe->Readers --; if (mode & LIBIO_FLAGS_WRITE) pipe->Writers --; PIPE_UNLOCK(pipe); if (pipe->Readers == 0 && pipe->Writers == 0) { #if 0 /* To delete an anonymous pipe file when all users closed it */ if (pipe->Anonymous) delfile = TRUE; #endif pipe_free(pipe); *pipep = NULL; } else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE) /* Notify waiting Writers that all their partners left */ PIPE_WAKEUPWRITERS(pipe); else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ) PIPE_WAKEUPREADERS(pipe); pipe_unlock(); #if 0 if (! delfile) return; if (iop->pathinfo.ops->unlink_h == NULL) return; /* This is safe for IMFS, but how about other FSes? */ iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif }
int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { IMFS_jnode_t *jnode = node->node_access; int result = 0; int i; /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) rtems_fatal_error_occurred (0xABCD0000); if ( !jnode->Parent ) rtems_fatal_error_occurred( 0xBAD00000 ); /* * Move the node_access to either the symbolic links parent or * root depending on the symbolic links path. */ node->node_access = jnode->Parent; rtems_filesystem_get_sym_start_loc( jnode->info.sym_link.name, &i, node ); /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( &jnode->info.sym_link.name[i], strlen( &jnode->info.sym_link.name[i] ), flags, node ); IMFS_Set_handlers( node ); /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; }
/* * In order to have a possibility to break into * running program, one has to call this function */ void i386_stub_glue_init_breakin(void) { rtems_raw_irq_connect_data uart_raw_irq_data; assert(uart_current == BSP_UART_COM1 || uart_current == BSP_UART_COM2); if(uart_current == BSP_UART_COM1) { uart_raw_irq_data.idtIndex = BSP_UART_COM1_IRQ + BSP_IRQ_VECTOR_BASE; } else { uart_raw_irq_data.idtIndex = BSP_UART_COM2_IRQ + BSP_IRQ_VECTOR_BASE; } if(!i386_get_current_idt_entry(&uart_raw_irq_data)) { printk("cannot get idt entry\n"); rtems_fatal_error_occurred(1); } if(!i386_delete_idt_entry(&uart_raw_irq_data)) { printk("cannot delete idt entry\n"); rtems_fatal_error_occurred(1); } uart_raw_irq_data.on = BSP_uart_on; uart_raw_irq_data.off = BSP_uart_off; uart_raw_irq_data.isOn= BSP_uart_isOn; /* Install ISR */ if(uart_current == BSP_UART_COM1) { uart_raw_irq_data.idtIndex = BSP_UART_COM1_IRQ + BSP_IRQ_VECTOR_BASE; uart_raw_irq_data.hdl = BSP_uart_dbgisr_com1; } else { uart_raw_irq_data.idtIndex = BSP_UART_COM2_IRQ + BSP_IRQ_VECTOR_BASE; uart_raw_irq_data.hdl = BSP_uart_dbgisr_com2; } if (!i386_set_idt_entry (&uart_raw_irq_data)) { printk("raw exception handler connection failed\n"); rtems_fatal_error_occurred(1); } /* Enable interrupts */ BSP_uart_intr_ctrl(uart_current, BSP_UART_INTR_CTRL_GDB); return; }
static void rtems_termios_destroy_tty (rtems_termios_tty *tty, void *arg, bool last_close) { rtems_status_code sc; if (rtems_termios_linesw[tty->t_line].l_close != NULL) { /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); } else if (last_close) { /* * default: just flush output buffer */ sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred (sc); } drainOutput (tty); rtems_semaphore_release (tty->osem); } if (tty->handler.mode == TERMIOS_TASK_DRIVEN) { /* * send "terminate" to I/O tasks */ sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT ); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT ); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if (last_close && tty->handler.last_close) (*tty->handler.last_close)(tty, arg); if (tty->device_node != NULL) tty->device_node->tty = NULL; rtems_semaphore_delete (tty->isem); rtems_semaphore_delete (tty->osem); rtems_semaphore_delete (tty->rawOutBuf.Semaphore); if ((tty->handler.poll_read == NULL) || (tty->handler.mode == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); rtems_interrupt_lock_destroy (&tty->interrupt_lock); free (tty->rawInBuf.theBuf); free (tty->rawOutBuf.theBuf); free (tty->cbuf); free (tty); }
static int console_first_open(int major, int minor, void *arg) { rtems_status_code status; /* must not open a minor device we have no ISR for */ assert( minor>=0 && minor < sizeof(ttyS)/sizeof(ttyS[0]) && ttyS[minor].isr ); /* 9600-8-N-1 */ BSP_uart_init(minor, 9600, 0); status = BSP_uart_install_isr(minor, ttyS[minor].isr); if (!status) { printk("Error installing serial console interrupt handler for '%s'!\n", ttyS[minor].name); rtems_fatal_error_occurred(status); } /* * Pass data area info down to driver */ BSP_uart_termios_set(minor, ((rtems_libio_open_close_args_t *)arg)->iop->data1); /* Enable interrupts on channel */ BSP_uart_intr_ctrl(minor, BSP_UART_INTR_CTRL_TERMIOS); return 0; }
/* * Characters have been transmitted * NOTE: This routine runs in the context of the * device transmit interrupt handler. * The second argument is the number of characters transmitted so far. * This value will always be 1 for devices which generate an interrupt * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { struct rtems_termios_tty *tty = ttyp; rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); return 0; /* nothing to output in IRQ... */ } else if (tty->t_line == PPPDISC ) { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } else { return rtems_termios_refill_transmitter(tty); } }
/* * Set time into chip */ int mc146818a_set_time( int minor, const rtems_time_of_day *time ) { uint32_t mc146818a; getRegister_f getReg; setRegister_f setReg; mc146818a = RTC_Table[ minor ].ulCtrlPort1; getReg = RTC_Table[ minor ].getRegister; setReg = RTC_Table[ minor ].setRegister; /* * Stop the RTC */ (*setReg)( mc146818a, MC146818A_STATUSB, MC146818ASB_HALT|MC146818ASB_24HR ); if ( time->year >= 2088 ) rtems_fatal_error_occurred( RTEMS_INVALID_NUMBER ); (*setReg)( mc146818a, MC146818A_YEAR, To_BCD(time->year % 100) ); (*setReg)( mc146818a, MC146818A_MONTH, To_BCD(time->month) ); (*setReg)( mc146818a, MC146818A_DAY, To_BCD(time->day) ); (*setReg)( mc146818a, MC146818A_HRS, To_BCD(time->hour) ); (*setReg)( mc146818a, MC146818A_MIN, To_BCD(time->minute) ); (*setReg)( mc146818a, MC146818A_SEC, To_BCD(time->second) ); /* * Restart the RTC */ (*setReg)( mc146818a, MC146818A_STATUSB, MC146818ASB_24HR ); return 0; }
/****************************************************** Name: console_initialize Input parameters: MAJOR # of console_driver, minor is always 0, args are always NULL Output parameters: - Description: Reserve resources consumed by this driver TODO: We should pass m340_uart_config table in arg *****************************************************/ rtems_device_driver console_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *arg ) { rtems_status_code status; int i; /* * Set up TERMIOS */ rtems_termios_initialize (); /* * Do device-specific initialization */ Init_UART_Table(); dbugInitialise (); Fifo_Full_benchmark_timer_initialize(); /* * Register the devices */ for (i=0; i<UART_NUMBER_OF_CHANNELS; i++) { if (m340_uart_config[i].enable) { status = rtems_io_register_name (m340_uart_config[i].name, major, i); if (status != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (status); } } return RTEMS_SUCCESSFUL; }
int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { IMFS_jnode_t *jnode = node->node_access; int result = 0; /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) rtems_fatal_error_occurred (0xABCD0000); /* * Set the hard link value and the handlers. */ node->node_access = jnode->info.hard_link.link_node; IMFS_Set_handlers( node ); /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; }
void l4rtems_timerInit( void ) { printk( "Timer init called\n"); if( !init ) { init = true; rtems_raw_irq_connect_data raw_irq_data = { BSP_PERIODIC_TIMER + BSP_IRQ_VECTOR_BASE, rtems_irq_prologue_0, NULL, NULL, NULL }; i386_delete_idt_entry (&raw_irq_data); atexit(l4rtems_timer_exit); /* Try not to hose the system at exit. */ if (!i386_set_idt_entry (&timer_raw_irq_data)) { printk("raw handler connection failed\n"); rtems_fatal_error_occurred(1); } } /* wait for ISR to be called at least once */ Ttimer_val = 0; while(Ttimer_val == 0) continue; printk( "Timer initialized!" ); Ttimer_val = 0; }
rtems_device_driver console_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *arg ) { rtems_status_code status; rtems_termios_initialize(); /* * Make sure the hardware is initialized. */ console_initialize_hardware(); /* * Register Device Names */ status = rtems_io_register_name( "/dev/console", major, 0 ); if (status != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred(status); return RTEMS_SUCCESSFUL; }
/* * paux device driver INITIALIZE entry point. */ rtems_device_driver paux_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *arg) { rtems_status_code status; /* * Set up TERMIOS */ rtems_termios_initialize(); printk( "PS/2 mouse probe.\n" ); if( psaux_init() < 0 ) { printk("Error detecting PS/2 mouse --\n"); /* we might want to finish the application here !!! */ } open_aux(); /* * Register the device */ status = rtems_io_register_name ("/dev/mouse", major, 0); if (status != RTEMS_SUCCESSFUL) { printk("Error registering paux device!\n"); rtems_fatal_error_occurred (status); } return RTEMS_SUCCESSFUL; } /* tty_initialize */
/** * * This routine initializes the console IO driver. * * Parameters * @param major major number * @param minor minor number * * Output parameters: NONE * * @return void */ rtems_device_driver console_initialize(rtems_device_major_number major, rtems_device_minor_number minor, void *arg) { rtems_status_code status = RTEMS_NOT_DEFINED; #if CONSOLE_USE_INTERRUPTS int i = 0; #endif status = bfin_uart_initialize(major, &config); if (status != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred(status); } #if CONSOLE_USE_INTERRUPTS for (i = 0; i < sizeof(bfinUARTISRs) / sizeof(bfinUARTISRs[0]); i++) { bfin_interrupt_register(&bfinUARTISRs[i]); #if INTERRUPT_USE_TABLE #else bfin_interrupt_enable(&bfinUARTISRs[i], 1); #endif } #endif return RTEMS_SUCCESSFUL; }
int console_inbyte_nonblocking( int port ) { int UStat; UStat = ERC32_MEC.UART_Status; switch (port) { case 0: if (UStat & ERC32_MEC_UART_STATUS_ERRA) { ERC32_MEC.UART_Status = ERC32_MEC_UART_STATUS_CLRA; ERC32_MEC.Control = ERC32_MEC.Control; } if ((UStat & ERC32_MEC_UART_STATUS_DRA) == 0) return -1; return (int) ERC32_MEC.UART_Channel_A; case 1: if (UStat & ERC32_MEC_UART_STATUS_ERRB) { ERC32_MEC.UART_Status = ERC32_MEC_UART_STATUS_CLRB; ERC32_MEC.Control = ERC32_MEC.Control; } if ((UStat & ERC32_MEC_UART_STATUS_DRB) == 0) return -1; return (int) ERC32_MEC.UART_Channel_B; default: rtems_fatal_error_occurred( 'D' << 8 | (port & 0xffffff) ); } return -1; }
void m5xx_uart_initialize (int minor) { /* * Check that minor number is valid. */ if ( (minor < SCI1_MINOR) || (minor > SCI2_MINOR) ) return; /* * Configure and enable receiver and transmitter. */ m5xx_uart_setAttributes(minor, &default_termios); /* * Connect interrupt if not yet done. */ if ( init_calls++ == 0 ) { rtems_irq_connect_data irq_data; irq_data.name = CPU_IRQ_SCI; irq_data.hdl = m5xx_sci_interrupt_handler; irq_data.on = m5xx_sci_nop; /* can't enable both channels here */ irq_data.off = m5xx_sci_nop; /* can't disable both channels here */ irq_data.isOn = m5xx_sci_isOn; if (!CPU_install_rtems_irq_handler (&irq_data)) { printk("Unable to connect SCI Irq handler\n"); rtems_fatal_error_occurred(1); } imb.qsmcm.qdsci_il = /* set interrupt level in port */ QSMCM_ILDSCI(CPU_irq_level_from_symbolic_name(CPU_IRQ_SCI)); } }
rtems_mpci_entry Shm_Send_packet( uint32_t node, rtems_packet_prefix *packet ) { Shm_Envelope_control *ecb, *tmp_ecb; uint32_t nnum; ecb = Shm_Packet_prefix_to_envelope_control_pointer( packet ); if ( node ) { Shm_Build_preamble( ecb, node ); Shm_Build_postamble( ecb ); Shm_Append_to_receive_queue( node, ecb ); (*Shm_Configuration->cause_intr)( node ); } else { for( nnum = SHM_FIRST_NODE ; nnum <= Shm_Maximum_nodes ; nnum++ ) if ( Shm_Local_node != nnum ) { tmp_ecb = Shm_Allocate_envelope(); if ( !tmp_ecb ) rtems_fatal_error_occurred( SHM_NO_FREE_PKTS ); Shm_Build_preamble( tmp_ecb, nnum ); *((struct pkt_cpy *)tmp_ecb->packet) = *((struct pkt_cpy *)packet); Shm_Build_postamble( tmp_ecb ); Shm_Append_to_receive_queue( nnum, tmp_ecb ); (*Shm_Configuration->cause_intr)( nnum ); } Shm_Free_envelope( ecb ); } }
void ICM7170_SetTOD( volatile unsigned char *imc1770_regs, uint8_t icm1770_freq, rtems_time_of_day *rtc_tod ) { int year; year = rtc_tod->year; if ( year >= 2088 ) /* plan ahead :) */ rtems_fatal_error_occurred( 0xBAD0BAD0 ); if ( year >= 2000 ) year -= 2000; else year -= 1900; ICM7170_SetField( imc1770_regs, 0x11, (0x04 |icm1770_freq ) ); ICM7170_SetField( imc1770_regs, 0x06, year ); ICM7170_SetField( imc1770_regs, 0x04, rtc_tod->month ); ICM7170_SetField( imc1770_regs, 0x05, rtc_tod->day ); ICM7170_SetField( imc1770_regs, 0x01, rtc_tod->hour ); ICM7170_SetField( imc1770_regs, 0x02, rtc_tod->minute ); ICM7170_SetField( imc1770_regs, 0x03, rtc_tod->second ); /* * I don't know which day of week is * */ ICM7170_SetField( imc1770_regs, 0x07, 1 ); ICM7170_SetField( imc1770_regs, 0x11, (0x0c | icm1770_freq) ); }