// Open interface
static int ven_init (const bt_vendor_callbacks_t * p_cb, unsigned char * local_bdaddr) {
logd ("ven_init p_cb: %p local_bdaddr: %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x", p_cb, local_bdaddr [0], local_bdaddr [1], local_bdaddr [2], local_bdaddr [3], local_bdaddr [4], local_bdaddr [5] );
logd ("main start: %s %s", binary_description, manifest_version); // manifest_version automatically set during build
logd (copyright); // Copyright
utils_init ();
if (p_cb == NULL) {
loge ("ven_init no user callbacks");
return (BT_HC_STATUS_FAIL);
}
bt_ven_cbacks = (bt_vendor_callbacks_t *) p_cb; // Store reference to user callbacks
if (shim_start () == NULL) {
loge ("ven_init shim_start error");
return (BT_HC_STATUS_FAIL);
}
int ret = -88;
if (veno_init)
ret = veno_init (p_cb, local_bdaddr);
logd ("ven_init ret: %d", ret);
if (ret == 0)
ret = server_thread_start ();
return (ret);
}
void
inode_pager_init(void)
{
kern_return_t kr;
int nr;
kr = mach_port_allocate(mach_task_self(),
MACH_PORT_RIGHT_PORT_SET,
&inode_pager_port_set);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(0, kr,
("inode_pager_init: mach_port_allocate"));
panic("inode_pager_init: can't allocate port set");
}
/*
* Create a new Linux task for the inode pager, so it can block
* and handle page faults like if it was a user process.
* Skip task[0] (the server task) and task[1] (reserved for init).
*/
for (nr = 2; nr < NR_TASKS; nr++) {
if (!task[nr])
break;
}
if (nr >= NR_TASKS)
panic("inode_pager_init: can't find empty process");
inode_pager_task = *current; /* XXX ? */
strncpy(inode_pager_task.comm,
"inode pager",
sizeof (inode_pager_task.comm));
task[nr] = &inode_pager_task;
SET_LINKS(&inode_pager_task);
nr_tasks++;
(void) server_thread_start(inode_pager_thread, (void *) 0);
}
void
osfmach3_trap_init(
exception_behavior_t behavior,
thread_state_flavor_t flavor)
{
kern_return_t kr;
mach_port_t trap_port_name, trap_port;
exception_mask_t mask;
thread_exception_behavior = behavior;
thread_exception_flavor = flavor;
init_task.osfmach3.task->mach_task_port = mach_task_self();
trap_port_name = ((mach_port_t) &init_task) + 1;
kr = serv_port_allocate_name(&trap_port,
(void *) trap_port_name);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(0, kr,
("osfmach3_trap_init: "
"serv_port_allocate_name(%x)",
trap_port_name));
panic("osfmach3_trap_init: "
"can't allocate exception port");
}
init_task.osfmach3.thread->mach_trap_port = trap_port;
kr = mach_port_insert_right(mach_task_self(),
trap_port,
trap_port,
MACH_MSG_TYPE_MAKE_SEND);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(0, kr,
("osfmach3_trap_init: "
"mach_port_insert_right"));
panic("osfmach3_trap_init: can't insert send right");
}
mask = EXC_MASK_ALL & ~EXC_MASK_RPC_ALERT;
if (parent_server) {
exception_mask_t syscall_exc_mask;
exception_mask_t old_exc_mask;
mach_msg_type_number_t old_exc_count;
mach_port_t old_exc_port;
exception_behavior_t old_exc_behavior;
thread_state_flavor_t old_exc_flavor;
/*
* Don't catch syscall exceptions that are directed to
* the parent server. But save the port, behavior and flavor
* to be able to restore them later.
*/
syscall_exc_mask = parent_server_syscall_exc_mask();
old_exc_count = 1;
kr = task_get_exception_ports(mach_task_self(),
syscall_exc_mask,
&old_exc_mask,
&old_exc_count,
&old_exc_port,
&old_exc_behavior,
&old_exc_flavor);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(0, kr,
("osfmach3_trap_init(FIRST_TASK): "
"task_get_exception_ports(mask=0x%x)",
syscall_exc_mask));
panic("can't get syscall exc port (parent server)");
}
if (old_exc_count == 1) {
parent_server_syscall_port = old_exc_port;
parent_server_syscall_behavior = old_exc_behavior;
parent_server_syscall_flavor = old_exc_flavor;
} else {
printk("osfmach3_trap_init: "
"couldn't get our syscall exc port");
}
mask &= ~syscall_exc_mask;
/* let breakpoints go to the debugger (if any) */
mask &= ~EXC_MASK_BREAKPOINT;
/* let Mach syscalls go to Mach */
mask &= ~EXC_MASK_MACH_SYSCALL;
}
kr = task_set_exception_ports(mach_task_self(),
mask,
trap_port,
behavior,
flavor);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(0, kr,
("osfmach3_trap_init: "
"task_set_exception_ports"));
panic("osfmach3_trap_init: "
"can't set server's task exception ports");
}
#if 0 /* obsolete */
if (parent_server) {
/*
* Hide the EXC_BAD_INSTRUCTION exceptions to avoid
* interferences from the parent_server when we do
* syscalls to ourselves (see start_kernel() and init()).
*/
kr = thread_set_exception_ports(mach_thread_self(),
EXC_MASK_BAD_INSTRUCTION,
MACH_PORT_NULL,
behavior,
flavor);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(1, kr,
("osfmach3_trap_init: "
"thread_set_exception_ports"));
panic("can't unset thread exception port");
}
}
#endif
ASSERT(server_exception_port == MACH_PORT_NULL);
server_exception_port = trap_port;
server_thread_start(server_exception_catcher, (void *) 0);
/*
* Create a global exception port for user tasks to detect
* new user threads.
*/
kr = mach_port_allocate(mach_task_self(),
MACH_PORT_RIGHT_RECEIVE,
&user_trap_port);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(0, kr,
("osfmach3_trap_init: "
"mach_port_allocate()"));
panic("osfmach3_trap_init: "
"can't allocate user trap port");
}
kr = mach_port_insert_right(mach_task_self(),
user_trap_port,
user_trap_port,
MACH_MSG_TYPE_MAKE_SEND);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(0, kr,
("osfmach3_trap_init: "
"mach_port_insert_right"));
panic("osfmach3_trap_init: can't insert send right "
"for user trap port");
}
server_thread_start(task_exception_catcher, (void *) 0);
}
/*
* This routine is called whenever a serial port is opened. It
* enables interrupts for a serial port, linking in its async structure into
* the IRQ chain. It also performs the serial-specific
* initialization for the tty structure.
*/
int rs_open(struct tty_struct *tty, struct file * filp)
{
struct async_struct *info;
int retval, line;
line = MINOR(tty->device) - tty->driver.minor_start;
if ((line < 0) || (line >= NR_PORTS))
return -ENODEV;
info = rs_table + line;
if (serial_paranoia_check(info, tty->device, "rs_open"))
return -ENODEV;
#ifdef SERIAL_DEBUG_OPEN
printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line,
info->count);
#endif
if (!(info->flags & ASYNC_INITIALIZED)) {
char device_name[25];
mach_port_t device_port;
dev_mode_t device_mode;
kern_return_t kr;
int word, count;
sprintf(device_name, "com%d", line);
device_mode = D_READ | D_WRITE;
kr = device_open(device_server_port,
MACH_PORT_NULL,
device_mode,
server_security_token,
device_name,
&device_port);
if (kr != D_SUCCESS) {
if (kr != D_NO_SUCH_DEVICE) {
MACH3_DEBUG(2, kr,
("rs_open(dev 0x%x): "
"device_open(\"%s\")",
tty->device,
device_name));
}
return -ENODEV;
}
info->flags &= ~ASYNC_DCD_PRESENT;
count = TTY_MODEM_COUNT;
kr = device_get_status(device_port,
TTY_MODEM, &word, &count);
if (kr == D_SUCCESS && (word & TM_CAR) != 0)
info->flags |= ASYNC_DCD_PRESENT;
else
info->flags &= ~ASYNC_DCD_PRESENT;
/* Flush any garbage data which might be left over.. */
count = TTY_FLUSH_COUNT;
word = D_READ|D_WRITE;
kr = device_set_status(device_port, TTY_FLUSH, &word, count);
info->device_port = device_port;
tty->flip.char_buf_ptr = tty->flip.char_buf;
tty->flip.flag_buf_ptr = tty->flip.flag_buf;
tty->flip.count = 0;
/* Now register a few asynchronous routines.. */
device_reply_register(&info->reply_port,
(char *) info, serial_read_reply,
serial_write_reply);
}
ASSERT(MACH_PORT_VALID(info->device_port));
info->count++;
tty->driver_data = info;
info->tty = tty;
/*
* Start up serial port
*/
retval = startup(info);
if (retval)
return retval;
if (info->count == 1)
server_thread_start(serial_read_thread, (void *) line);
retval = block_til_ready(tty, filp, info);
if (retval) {
#ifdef SERIAL_DEBUG_OPEN
printk("rs_open returning after block_til_ready with %d\n",
retval);
#endif
return retval;
}
if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
*tty->termios = info->normal_termios;
else
*tty->termios = info->callout_termios;
change_speed(info);
}
info->session = current->session;
info->pgrp = current->pgrp;
#ifdef SERIAL_DEBUG_OPEN
printk("rs_open ttys%d successful...", info->line);
#endif
return 0;
}
