int main() {
printf("msp430_serial starting...\n");
printf("libusb initing...\n");
// initialize USB context, and get a device handle.
HANDLE h = init_dev(1, 0, 0xf432);
if (h == NULL) {
fprintf(stderr, "Handle is NULL, initialization failed.\n");
return(1);
}
// enable debugging
#ifdef DEBUG
libusb_set_debug(mspContext, 3);
#endif
// get endpoints
MSP_get_endpoints(h, &ep_int_in, &ep_bulk_in, &ep_bulk_out);
// Send magic setup control transfers...
MSP_setup(h);
get_descriptor(h);
// TI driver does this 26 times... not sure why
// read status
do_control_transfer(h,0xa1,0x21);
// write back to device
do_send_std(h,0x21,0x20,true);
while (1) {
do_bulk_transfer(h);
libusb_handle_events(mspContext);
}
printf("Exiting.\n");
MSP_uninitialize(h);
return(0);
}
static int gotemp_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
struct usb_device *udev = interface_to_usbdev(interface);
struct gotemp *gdev;
int retval;
gdev = kzalloc(sizeof(struct gotemp), GFP_KERNEL);
if (gdev == NULL) {
dev_err(&interface->dev, "Out of memory\n");
return -ENOMEM;
}
gdev->udev = usb_get_dev(udev);
usb_set_intfdata(interface, gdev);
init_dev(gdev);
retval = device_create_file(&interface->dev, &dev_attr_temperature);
if (retval)
goto error;
dev_info(&interface->dev, "USB GoTemp device now attached\n");
return 0;
error:
usb_set_intfdata(interface, NULL);
kfree(gdev);
return retval;
}
static int gotemp_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
struct usb_device *udev = interface_to_usbdev(interface);
struct gotemp *gdev;
struct usb_endpoint_descriptor *endpoint;
int retval = -ENOMEM;
size_t buffer_size;
gdev = kzalloc(sizeof(struct gotemp), GFP_KERNEL);
if (gdev == NULL) {
dev_err(&interface->dev, "Out of memory\n");
return -ENOMEM;
}
gdev->udev = usb_get_dev(udev);
/* find the one control endpoint of this device */
endpoint = &interface->cur_altsetting->endpoint[0].desc;
buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
gdev->int_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
if (!gdev->int_in_buffer) {
dev_err(&interface->dev, "Could not allocate buffer");
goto error;
}
gdev->int_in_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!gdev->int_in_urb) {
dev_err(&interface->dev, "No free urbs available\n");
goto error;
}
usb_fill_int_urb(gdev->int_in_urb, udev,
usb_rcvintpipe(udev,
endpoint->bEndpointAddress),
gdev->int_in_buffer, buffer_size,
read_int_callback, gdev,
endpoint->bInterval);
usb_set_intfdata(interface, gdev);
init_dev(gdev);
retval = device_create_file(&interface->dev, &dev_attr_temperature);
if (retval)
goto error;
dev_info(&interface->dev, "USB GoTemp device now attached\n");
return 0;
error:
usb_free_urb(gdev->int_in_urb);
kfree(gdev->int_in_buffer);
kfree(gdev);
return retval;
}
dev_major *new_dev( uint8_t n_minor, const char *name )
{
dev_major *dev = malloc( sizeof (dev_major) );
if( dev == 0 ) return 0;
if( !init_dev( dev, n_minor, name ) )
return dev;
free( dev );
return 0;
}
static EFI_STATUS
probe(dev_info_t* dev)
{
if (init_dev(dev) < 0)
return (EFI_UNSUPPORTED);
add_device(&devices, dev);
return (EFI_SUCCESS);
}
static EFI_STATUS
load(const char *filepath, dev_info_t *dev, void **bufp, size_t *bufsize)
{
ufs_ino_t ino;
EFI_STATUS status;
size_t size;
ssize_t read;
void *buf;
#ifdef EFI_DEBUG
{
CHAR16 *text = efi_devpath_name(dev->devpath);
DPRINTF("Loading '%s' from %S\n", filepath, text);
efi_free_devpath_name(text);
}
#endif
if (init_dev(dev) < 0) {
DPRINTF("Failed to init device\n");
return (EFI_UNSUPPORTED);
}
if ((ino = lookup(filepath)) == 0) {
DPRINTF("Failed to lookup '%s' (file not found?)\n", filepath);
return (EFI_NOT_FOUND);
}
if (fsread_size(ino, NULL, 0, &size) < 0 || size <= 0) {
printf("Failed to read size of '%s' ino: %d\n", filepath, ino);
return (EFI_INVALID_PARAMETER);
}
if ((status = BS->AllocatePool(EfiLoaderData, size, &buf)) !=
EFI_SUCCESS) {
printf("Failed to allocate read buffer %zu for '%s' (%lu)\n",
size, filepath, EFI_ERROR_CODE(status));
return (status);
}
read = fsread(ino, buf, size);
if ((size_t)read != size) {
printf("Failed to read '%s' (%zd != %zu)\n", filepath, read,
size);
(void)BS->FreePool(buf);
return (EFI_INVALID_PARAMETER);
}
DPRINTF("Load complete\n");
*bufp = buf;
*bufsize = size;
return (EFI_SUCCESS);
}
int main(multiboot_t * mbp)
{
cpu_state_t *cpu;
// first is to save critical info from bootloader
// and get symbol tables so we can print back traces
mbootp = mbp;
init_debug(mbp);
// reset text-mode
c80_clear();
printk_color(rc_black, rc_red, "\t\t\t\tRed Magic\n");
// init processors
init_bootstrap_processor();
cpu = get_boot_processor();
ASSERT(cpu != NULL);
// initialize descriptors
init_global_descriptor_table(cpu);
init_interrupt_descriptor_table();
init_io_apic();
// interrupt on
local_irq_enable();
// memory management
show_kernel_pos();
show_ARDS_from_multiboot(mbp);
init_paging();
init_kheap();
// initialize devices and rootfs
init_dev();
//init_root_fs();
// start all APs
if (mpinfo.ismp)
start_smp();
// start system clock
if (!mpinfo.ismp)
init_pit_timer(CLOCK_INT_HZ);
else
init_apic_timer(CLOCK_INT_HZ);
// initialize kernel task and scheduling
setup_init_task();
init_sched();
// All our initialisation calls will go in here.
return 0xDEADBABA;
}
/*
* Query Device command from Director
* Sends Storage Daemon's information on the device to the
* caller (presumably the Director).
* This command always returns "true" so that the line is
* not closed on an error.
*
*/
bool query_cmd(JCR *jcr)
{
POOL_MEM dev_name, VolumeName, MediaType, ChangerName;
BSOCK *dir = jcr->dir_bsock;
DEVRES *device;
AUTOCHANGER *changer;
bool ok;
Dmsg1(100, "Query_cmd: %s", dir->msg);
ok = sscanf(dir->msg, query_device, dev_name.c_str()) == 1;
Dmsg1(100, "<dird: %s", dir->msg);
if (ok) {
unbash_spaces(dev_name);
foreach_res(device, R_DEVICE) {
/* Find resource, and make sure we were able to open it */
if (bstrcmp(dev_name.c_str(), device->name())) {
if (!device->dev) {
device->dev = init_dev(jcr, device);
}
if (!device->dev) {
break;
}
ok = dir_update_device(jcr, device->dev);
if (ok) {
ok = dir->fsend(OK_query);
} else {
dir->fsend(NO_query);
}
return ok;
}
}
foreach_res(changer, R_AUTOCHANGER) {
/*Find resource, and make sure we were able to open it */
if (bstrcmp(dev_name.c_str(), changer->name())) {
if (!changer->device || changer->device->size() == 0) {
continue; /* no devices */
}
ok = dir_update_changer(jcr, changer);
if (ok) {
ok = dir->fsend(OK_query);
} else {
dir->fsend(NO_query);
}
return ok;
}
}
/* If we get here, the device/autochanger was not found */
unbash_spaces(dir->msg);
pm_strcpy(jcr->errmsg, dir->msg);
dir->fsend(NO_device, dev_name.c_str());
Dmsg1(100, ">dird: %s", dir->msg);
} else {
static void init_link(struct bus *link)
{
struct device *dev;
struct bus *c_link;
for (dev = link->children; dev; dev = dev->sibling)
init_dev(dev);
for (dev = link->children; dev; dev = dev->sibling) {
for (c_link = dev->link_list; c_link; c_link = c_link->next)
init_link(c_link);
}
}
struct pipe_screen *
ilo_screen_create(struct intel_winsys *ws)
{
struct ilo_screen *is;
const struct intel_winsys_info *info;
ilo_debug = debug_get_flags_option("ILO_DEBUG", ilo_debug_flags, 0);
is = CALLOC_STRUCT(ilo_screen);
if (!is)
return NULL;
is->winsys = ws;
intel_winsys_enable_reuse(is->winsys);
info = intel_winsys_get_info(is->winsys);
if (!init_dev(&is->dev, info)) {
FREE(is);
return NULL;
}
util_format_s3tc_init();
is->base.destroy = ilo_screen_destroy;
is->base.get_name = ilo_get_name;
is->base.get_vendor = ilo_get_vendor;
is->base.get_param = ilo_get_param;
is->base.get_paramf = ilo_get_paramf;
is->base.get_shader_param = ilo_get_shader_param;
is->base.get_video_param = ilo_get_video_param;
is->base.get_compute_param = ilo_get_compute_param;
is->base.get_timestamp = ilo_get_timestamp;
is->base.flush_frontbuffer = NULL;
is->base.fence_reference = ilo_fence_reference;
is->base.fence_signalled = ilo_fence_signalled;
is->base.fence_finish = ilo_fence_finish;
is->base.get_driver_query_info = NULL;
ilo_init_format_functions(is);
ilo_init_context_functions(is);
ilo_init_resource_functions(is);
return &is->base;
}
int __init cec_init(void)
{
printk("[CEC] init - starting\n");
cec_internal_init();
udelay(10000);
startTask();
/* ********* */
/* irq setup */
printk("[CEC] init - starting intterrupt (%d)\n", CEC_IRQ);
#if defined (CONFIG_KERNELVERSION) || LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
if (!request_irq(CEC_IRQ, (void*)cec_interrupt, IRQF_DISABLED, "cec", NULL))
#else
if (!request_irq(CEC_IRQ, (void*)cec_interrupt, SA_INTERRUPT, "cec", NULL))
#endif
{
}
else
{
printk("[CEC] Can't get irq\n");
}
if(activemode)
{
init_e2_proc();
input_init();
}
else
{
init_dev();
}
// TODO: how can we implement hotplug support?
//while(!cancelStart && getPhysicalAddress() == 0) // HDMI is not plugged in
// msleep(200);
cec_worker_init();
return 0;
}
int main(int argc, char **argv)
{
int handle;
if (argc < 2)
usage();
if (argc > 1 && (streq(argv[1], "-h") || streq(argv[1], "--help")))
usage();
handle = open_dev("/dev/hidraw%d");
if (handle == -1)
trouble_shooting();
init_dev(handle);
configure(handle, argc, argv);
close_dev(handle);
exit(0);
}
static EFI_STATUS
try_load(dev_info_t *dev, const char *loader_path, void **bufp, size_t *bufsize)
{
ufs_ino_t ino;
EFI_STATUS status;
size_t size;
ssize_t read;
void *buf;
if (init_dev(dev) < 0)
return (EFI_UNSUPPORTED);
if ((ino = lookup(loader_path)) == 0)
return (EFI_NOT_FOUND);
if (fsread_size(ino, NULL, 0, &size) < 0 || size <= 0) {
printf("Failed to read size of '%s' ino: %d\n", loader_path,
ino);
return (EFI_INVALID_PARAMETER);
}
if ((status = bs->AllocatePool(EfiLoaderData, size, &buf)) !=
EFI_SUCCESS) {
printf("Failed to allocate read buffer (%lu)\n",
EFI_ERROR_CODE(status));
return (status);
}
read = fsread(ino, buf, size);
if ((size_t)read != size) {
printf("Failed to read '%s' (%zd != %zu)\n", loader_path, read,
size);
(void)bs->FreePool(buf);
return (EFI_INVALID_PARAMETER);
}
*bufp = buf;
*bufsize = size;
return (EFI_SUCCESS);
}
void open_sound(void)
{
int err;
ao_initialize();
driver = ao_default_driver_id();
mpg123_init();
mh = mpg123_new(NULL, &err);
buffer_size = mpg123_outblock(mh);
buffer = malloc(buffer_size * sizeof(char));
GError *error = NULL;
gchar *str;
if ((str = g_key_file_get_string(keyfile, "preferences", "soundfile", &error))) {
if (str[0]) {
sound_file = str;
init_dev();
} else
g_free(str);
}
}
/**
* Initialize all devices in the global device tree.
*
* Starting at the root device, call the device's init() method to do
* device-specific setup, then call each child's init() method.
*/
void dev_initialize(void)
{
struct bus *link;
printk(BIOS_INFO, "Initializing devices...\n");
#if CONFIG_ARCH_X86
/* Ensure EBDA is prepared before Option ROMs. */
setup_default_ebda();
#endif
/* First call the mainboard init. */
init_dev(&dev_root);
/* Now initialize everything. */
for (link = dev_root.link_list; link; link = link->next)
init_link(link);
printk(BIOS_INFO, "Devices initialized\n");
show_all_devs(BIOS_SPEW, "After init.");
}
void handler::run()
{
// 初始化
int rc = init_dev("eth0", "ether proto 0x888e");
if (rc < 0) return;
packet::getInstance()->init_start();
PKT *start = packet::getInstance()->get_start_pkt();
pcap_sendpacket(handle, start->data, start->len);
printf("[i]SEARCH SERVER.\n");
pcap_loop(handle, 0, dispatcher_handler, (u_char *)this);
printf("[i]ENTER KEEPALIVE.\n");
// 保持在线
while (1){
packet::getInstance()->keepalive();
PKT *keepalive = packet::getInstance()->get_keepalive_pkt();
pcap_sendpacket(handle, keepalive->data, keepalive->len);
sleep(20);
}
}
int main(int argc, char **argv)
{
int i, ret, become_daemon = 1;
for(i=1; i<argc; i++) {
if(argv[i][0] == '-' && argv[i][2] == 0) {
switch(argv[i][1]) {
case 'd':
become_daemon = !become_daemon;
break;
case 'v':
verbose = 1;
break;
case 'h':
printf("usage: %s [options]\n", argv[0]);
printf("options:\n");
printf(" -d\tdo not daemonize\n");
printf(" -v\tverbose output\n");
printf(" -h\tprint this usage information\n");
return 0;
default:
fprintf(stderr, "unrecognized argument: %s\n", argv[i]);
return 1;
}
} else {
fprintf(stderr, "unexpected argument: %s\n", argv[i]);
return 1;
}
}
if(become_daemon) {
daemonize();
}
write_pid_file();
puts("Spacenav daemon " VERSION);
read_cfg("/etc/spnavrc", &cfg);
if(init_clients() == -1) {
return 1;
}
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
signal(SIGSEGV, sig_handler);
signal(SIGHUP, sig_handler);
signal(SIGUSR1, sig_handler);
signal(SIGUSR2, sig_handler);
if(init_dev() == -1) {
init_hotplug();
}
init_unix();
#ifdef USE_X11
init_x11();
#endif
atexit(cleanup);
for(;;) {
fd_set rset;
int fd, max_fd = 0;
struct client *c;
FD_ZERO(&rset);
/* set the device fd if it's open, otherwise set the hotplug fd */
if((fd = get_dev_fd()) != -1 || (fd = get_hotplug_fd()) != -1) {
FD_SET(fd, &rset);
if(fd > max_fd) max_fd = fd;
}
/* the UNIX domain socket listening for connections */
if((fd = get_unix_socket()) != -1) {
FD_SET(fd, &rset);
if(fd > max_fd) max_fd = fd;
}
/* all the UNIX socket clients */
c = first_client();
while(c) {
if(get_client_type(c) == CLIENT_UNIX) {
int s = get_client_socket(c);
assert(s >= 0);
FD_SET(s, &rset);
if(s > max_fd) max_fd = s;
}
c = next_client();
}
/* and the X server socket */
#ifdef USE_X11
if((fd = get_x11_socket()) != -1) {
FD_SET(fd, &rset);
if(fd > max_fd) max_fd = fd;
}
#endif
do {
ret = select(max_fd + 1, &rset, 0, 0, 0);
} while(ret == -1 && errno == EINTR);
if(ret > 0) {
handle_events(&rset);
}
}
return 0; /* unreachable */
}
void select_sound(GtkWidget *menu_item, gpointer data)
{
GtkWidget *dialog;
GtkFileFilter *filter, *filter_all;
play = FALSE;
dialog = gtk_file_chooser_dialog_new(_("Choose a file"),
NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
"Stop Sound", 1000,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter, "*.[mM][pP][1-3]");
gtk_file_filter_add_pattern(filter, "*.[wW][aA][vV]");
gtk_file_filter_add_pattern(filter, "*.[oO][gG][gG]");
gtk_file_filter_set_name(filter, _("Sound Files"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
filter_all = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter_all, "*");
gtk_file_filter_set_name(filter_all, _("All Files"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter_all);
gchar *dir = g_build_filename(installation_dir, "etc", NULL);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), dir);
g_free(dir);
gint r = gtk_dialog_run(GTK_DIALOG(dialog));
if (play) { // can start during dialog
gtk_widget_destroy(dialog);
return;
}
if (r == 1000) { // stop sound
G_LOCK(sound);
g_free(sound_file);
sound_file = NULL;
if (dev) ao_close(dev);
dev = NULL;
g_key_file_set_string(keyfile, "preferences", "soundfile", "");
gtk_widget_destroy(dialog);
G_UNLOCK(sound);
return;
}
if (r != GTK_RESPONSE_ACCEPT) {
gtk_widget_destroy(dialog);
return;
}
G_LOCK(sound);
g_free(sound_file);
sound_file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
g_key_file_set_string(keyfile, "preferences", "soundfile", sound_file);
init_dev();
G_UNLOCK(sound);
gtk_widget_destroy(dialog);
}
/*
* Read in the information about files used in making the system.
* Store it in the ftab linked list.
*/
void
read_files(void)
{
FILE *fp;
register struct file_list *tp, *pf;
register struct device *dp;
register struct opt *op;
const char *wd;
char *this, *needs;
const char *devorprof;
int options;
int not_option;
char pname[BUFSIZ];
char fname[1024];
char *rest = (char *) 0;
int nreqs, first = 1, isdup;
ftab = 0;
(void) sprintf(fname, "%s/files", config_directory);
openit:
fp = fopenp(VPATH, fname, pname, "r");
if (fp == 0) {
perror(fname);
exit(1);
}
next:
options = 0;
rest = (char *) 0;
/*
* filename [ standard | optional ]
* [ dev* | profiling-routine ] [ device-driver]
*/
wd = get_word(fp);
if (wd == (char *)EOF) {
(void) fclose(fp);
if (first == 1) {
(void) sprintf(fname, "%s/files.%s", config_directory, machinename);
first++;
goto openit;
}
return;
}
if (wd == 0)
goto next;
/*
* Allow comment lines beginning witha '#' character.
*/
if (*wd == '#')
{
while ((wd=get_word(fp)) && wd != (char *)EOF)
;
goto next;
}
this = ns(wd);
next_word(fp, wd);
if (wd == 0) {
printf("%s: No type for %s.\n",
fname, this);
exit(1);
}
if ((pf = fl_lookup(this)) && (pf->f_type != INVISIBLE || pf->f_flags))
isdup = 1;
else
isdup = 0;
tp = 0;
nreqs = 0;
devorprof = "";
needs = 0;
if (eq(wd, "standard"))
goto checkdev;
if (!eq(wd, "optional")) {
printf("%s: %s must be optional or standard\n", fname, this);
exit(1);
}
if (strncmp(this, "OPTIONS/", 8) == 0)
options++;
not_option = 0;
nextopt:
next_word(fp, wd);
if (wd == 0)
goto doneopt;
if (eq(wd, "not")) {
not_option = !not_option;
goto nextopt;
}
devorprof = wd;
if (eq(wd, "device-driver") || eq(wd, "profiling-routine")) {
next_word(fp, wd);
goto save;
}
nreqs++;
if (needs == 0 && nreqs == 1)
needs = ns(wd);
if (isdup)
goto invis;
if (options)
{
struct opt *lop = 0;
struct device tdev;
/*
* Allocate a pseudo-device entry which we will insert into
* the device list below. The flags field is set non-zero to
* indicate an internal entry rather than one generated from
* the configuration file. The slave field is set to define
* the corresponding symbol as 0 should we fail to find the
* option in the option list.
*/
init_dev(&tdev);
tdev.d_name = ns(wd);
tdev.d_type = PSEUDO_DEVICE;
tdev.d_flags++;
tdev.d_slave = 0;
for (op=opt; op; lop=op, op=op->op_next)
{
char *od = allCaps(ns(wd));
/*
* Found an option which matches the current device
* dependency identifier. Set the slave field to
* define the option in the header file.
*/
if (strcmp(op->op_name, od) == 0)
{
tdev.d_slave = 1;
if (lop == 0)
opt = op->op_next;
else
lop->op_next = op->op_next;
free(op);
op = 0;
}
free(od);
if (op == 0)
break;
}
newdev(&tdev);
}
for (dp = dtab; dp != 0; dp = dp->d_next) {
if (eq(dp->d_name, wd) && (dp->d_type != PSEUDO_DEVICE || dp->d_slave)) {
if (not_option)
goto invis; /* dont want file if option present */
else
goto nextopt;
}
}
if (not_option)
goto nextopt; /* want file if option missing */
for (op = opt; op != 0; op = op->op_next)
if (op->op_value == 0 && opteq(op->op_name, wd)) {
if (nreqs == 1) {
free(needs);
needs = 0;
}
goto nextopt;
}
invis:
while ((wd = get_word(fp)) != 0)
;
if (tp == 0)
tp = new_fent();
tp->f_fn = this;
tp->f_type = INVISIBLE;
tp->f_needs = needs;
tp->f_flags = isdup;
goto next;
doneopt:
if (nreqs == 0) {
printf("%s: what is %s optional on?\n",
fname, this);
exit(1);
}
checkdev:
if (wd) {
if (*wd == '|')
goto getrest;
next_word(fp, wd);
if (wd) {
devorprof = wd;
next_word(fp, wd);
}
}
save:
getrest:
if (wd) {
if (*wd == '|') {
rest = ns(get_rest(fp));
} else {
printf("%s: syntax error describing %s\n",
fname, this);
exit(1);
}
}
if (eq(devorprof, "profiling-routine") && profiling == 0)
goto next;
if (tp == 0)
tp = new_fent();
tp->f_fn = this;
tp->f_extra = rest;
if (options)
tp->f_type = INVISIBLE;
else
if (eq(devorprof, "device-driver"))
tp->f_type = DRIVER;
else if (eq(devorprof, "profiling-routine"))
tp->f_type = PROFILING;
else
tp->f_type = NORMAL;
tp->f_flags = 0;
tp->f_needs = needs;
if (pf && pf->f_type == INVISIBLE)
pf->f_flags = 1; /* mark as duplicate */
goto next;
}
int main(int argc, char **argv)
{
int i, become_daemon = 1;
for(i=1; i<argc; i++) {
if(argv[i][0] == '-' && argv[i][2] == 0) {
switch(argv[i][1]) {
case 'd':
become_daemon = !become_daemon;
break;
case 'v':
verbose = 1;
break;
case 'h':
printf("usage: %s [options]\n", argv[0]);
printf("options:\n");
printf(" -d\tdo not daemonize\n");
printf(" -v\tverbose output\n");
printf(" -h\tprint this usage information\n");
return 0;
default:
fprintf(stderr, "unrecognized argument: %s\n", argv[i]);
return 1;
}
} else {
fprintf(stderr, "unexpected argument: %s\n", argv[i]);
return 1;
}
}
if(become_daemon) {
daemonize();
}
write_pid_file();
read_cfg("/etc/spnavrc", &cfg);
if(!(client_list = malloc(sizeof *client_list))) {
perror("failed to allocate client list");
return 1;
}
client_list->next = 0;
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
signal(SIGSEGV, sig_handler);
signal(SIGHUP, sig_handler);
signal(SIGUSR1, sig_handler);
signal(SIGUSR2, sig_handler);
init_dev();
init_unix();
#ifdef USE_X11
init_x11();
#endif
/* event handling loop */
while(1) {
fd_set rd_set;
if(dev_fd == -1) {
if(init_dev() == -1) {
sleep(30);
continue;
}
}
if(select_all(&rd_set) >= 0) {
handle_events(&rd_set);
}
}
/* just for the sense of symmetry, execution can't reach this :) */
#ifdef USE_X11
close_x11();
#endif
close_dev();
return 0;
}
/*
* Setup device, jcr, and prepare to access device.
* If the caller wants read access, acquire the device, otherwise,
* the caller will do it.
*/
static DCR *setup_to_access_device(JCR *jcr, char *dev_name,
const char *VolumeName, int mode)
{
DEVICE *dev;
char *p;
DEVRES *device;
DCR *dcr;
char VolName[MAX_NAME_LENGTH];
init_reservations_lock();
/*
* If no volume name already given and no bsr, and it is a file,
* try getting name from Filename
*/
if (VolumeName) {
bstrncpy(VolName, VolumeName, sizeof(VolName));
if (strlen(VolumeName) >= MAX_NAME_LENGTH) {
Jmsg0(jcr, M_ERROR, 0, _("Volume name or names is too long. Please use a .bsr file.\n"));
}
} else {
VolName[0] = 0;
}
if (!jcr->bsr && VolName[0] == 0) {
if (!bstrncmp(dev_name, "/dev/", 5)) {
/* Try stripping file part */
p = dev_name + strlen(dev_name);
while (p >= dev_name && !IsPathSeparator(*p))
p--;
if (IsPathSeparator(*p)) {
bstrncpy(VolName, p+1, sizeof(VolName));
*p = 0;
}
}
}
if ((device=find_device_res(dev_name, mode)) == NULL) {
Jmsg2(jcr, M_FATAL, 0, _("Cannot find device \"%s\" in config file %s.\n"),
dev_name, configfile);
return NULL;
}
dev = init_dev(jcr, device);
if (!dev) {
Jmsg1(jcr, M_FATAL, 0, _("Cannot init device %s\n"), dev_name);
return NULL;
}
device->dev = dev;
jcr->dcr = dcr = new_dcr(jcr, NULL, dev);
if (VolName[0]) {
bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
}
bstrncpy(dcr->dev_name, device->device_name, sizeof(dcr->dev_name));
create_restore_volume_list(jcr);
if (mode) { /* read only access? */
Dmsg0(100, "Acquire device for read\n");
if (!acquire_device_for_read(dcr)) {
return NULL;
}
jcr->read_dcr = dcr;
} else {
if (!first_open_device(dcr)) {
Jmsg1(jcr, M_FATAL, 0, _("Cannot open %s\n"), dev->print_name());
return NULL;
}
jcr->dcr = dcr; /* write dcr */
}
return dcr;
}
/*
* tty_open and tty_release keep up the tty count that contains the
* number of opens done on a tty. We cannot use the inode-count, as
* different inodes might point to the same tty.
*
* Open-counting is needed for pty masters, as well as for keeping
* track of serial lines: DTR is dropped when the last close happens.
* (This is not done solely through tty->count, now. - Ted 1/27/92)
*
* The termios state of a pty is reset on first open so that
* settings don't persist across reuse.
*/
static int tty_open(struct inode * inode, struct file * filp)
{
struct tty_struct *tty;
int major, minor;
int noctty, retval;
retry_open:
minor = MINOR(inode->i_rdev);
major = MAJOR(inode->i_rdev);
noctty = filp->f_flags & O_NOCTTY;
if (major == TTYAUX_MAJOR) {
if (!minor) {
major = TTY_MAJOR;
minor = current->tty;
}
/* noctty = 1; */
} else if (major == TTY_MAJOR) {
if (!minor) {
minor = fg_console + 1;
noctty = 1;
}
} else {
printk("Bad major #%d in tty_open\n", MAJOR(inode->i_rdev));
return -ENODEV;
}
if (minor <= 0)
return -ENXIO;
if (IS_A_PTY_MASTER(minor))
noctty = 1;
filp->f_rdev = (major << 8) | minor;
retval = init_dev(minor);
if (retval)
return retval;
tty = tty_table[minor];
#ifdef TTY_DEBUG_HANGUP
printk("opening tty%d...", tty->line);
#endif
if (test_bit(TTY_EXCLUSIVE, &tty->flags) && !suser())
return -EBUSY;
#if 0
/* clean up the packet stuff. */
/*
* Why is this not done in init_dev? Right here, if another
* process opens up a tty in packet mode, all the packet
* variables get cleared. Come to think of it, is anything
* using the packet mode at all??? - Ted, 1/27/93
*
* Not to worry, a pty master can only be opened once.
* And rlogind and telnetd both use packet mode. -- jrs
*
* Not needed. These are cleared in initialize_tty_struct. -- jlc
*/
tty->ctrl_status = 0;
tty->packet = 0;
#endif
if (tty->open) {
retval = tty->open(tty, filp);
} else {
retval = -ENODEV;
}
if (retval) {
#ifdef TTY_DEBUG_HANGUP
printk("error %d in opening tty%d...", retval, tty->line);
#endif
release_dev(minor, filp);
if (retval != -ERESTARTSYS)
return retval;
if (current->signal & ~current->blocked)
return retval;
schedule();
goto retry_open;
}
if (!noctty &&
current->leader &&
current->tty<0 &&
tty->session==0) {
current->tty = minor;
tty->session = current->session;
tty->pgrp = current->pgrp;
}
filp->f_rdev = MKDEV(TTY_MAJOR,minor); /* Set it to something normal */
return 0;
}
/*------------------------------------------------------------------------
* sysinit -- initialize all Xinu data structeres and devices
*------------------------------------------------------------------------
*/
LOCAL
sysinit()
{
static long currsp;
int i,j, avail;
struct pentry *pptr;
struct sentry *sptr;
struct mblock *mptr;
SYSCALL pfintr();
/*********************/
set_evec(14, pfintr);
pptr = &proctab[NULLPROC]; /* initialize null process entry */
/*********************/
numproc = 0; /* initialize system variables */
nextproc = NPROC-1;
nextsem = NSEM-1;
nextqueue = NPROC; /* q[0..NPROC-1] are processes */
/* initialize free memory list */
/* PC version has to pre-allocate 640K-1024K "hole" */
if (maxaddr+1 > HOLESTART) {
memlist.mnext = mptr = (struct mblock *) roundmb(&end);
mptr->mnext = (struct mblock *)HOLEEND;
mptr->mlen = (int) truncew(((unsigned) HOLESTART -
(unsigned)&end));
mptr->mlen -= 4;
mptr = (struct mblock *) HOLEEND;
mptr->mnext = 0;
mptr->mlen = (int) truncew((unsigned)maxaddr - HOLEEND -
NULLSTK);
/*
mptr->mlen = (int) truncew((unsigned)maxaddr - (4096 - 1024 ) * 4096 - HOLEEND - NULLSTK);
*/
} else {
/* initialize free memory list */
memlist.mnext = mptr = (struct mblock *) roundmb(&end);
mptr->mnext = 0;
mptr->mlen = (int) truncew((unsigned)maxaddr - (int)&end -
NULLSTK);
}
for (i=0 ; i<NPROC ; i++) /* initialize process table */
proctab[i].pstate = PRFREE;
#ifdef MEMMARK
_mkinit(); /* initialize memory marking */
#endif
#ifdef RTCLOCK
clkinit(); /* initialize r.t.clock */
#endif
mon_init(); /* init monitor */
#ifdef NDEVS
for (i=0 ; i<NDEVS ; i++ ) {
init_dev(i);
}
#endif
pptr = &proctab[NULLPROC]; /* initialize null process entry */
pptr->pstate = PRCURR;
for (j=0; j<7; j++)
pptr->pname[j] = "prnull"[j];
pptr->plimit = (WORD)(maxaddr + 1) - NULLSTK;
pptr->pbase = (WORD) maxaddr - 3;
/*
pptr->plimit = (WORD)(maxaddr + 1) - NULLSTK - (4096 - 1024 )*4096;
pptr->pbase = (WORD) maxaddr - 3 - (4096-1024)*4096;
*/
pptr->pesp = pptr->pbase-4; /* for stkchk; rewritten before used */
*( (int *)pptr->pbase ) = MAGIC;
pptr->paddr = (WORD) nulluser;
pptr->pargs = 0;
pptr->pprio = 0;
currpid = NULLPROC;
for (i=0 ; i<NSEM ; i++) { /* initialize semaphores */
(sptr = &semaph[i])->sstate = SFREE;
sptr->sqtail = 1 + (sptr->sqhead = newqueue());
}
rdytail = 1 + (rdyhead=newqueue());/* initialize ready list */
init_bsm();
init_frm();
kprintf("initialize page tables for null process\n");
init_glb_pgs(glb_pg_tbl_frm_mapping);
// init pg dir for proc 0
frame_t *pg_dir = get_free_frame();
init_pg_dir(pg_dir, NULLPROC);
pptr->pdbr = pg_dir->frm_num;
pptr->pd = pg_dir;
return(OK);
}
int tc58128_init(struct SH7750State *s, const char *zone1, const char *zone2)
{
init_dev(&tc58128_devs[0], zone1);
init_dev(&tc58128_devs[1], zone2);
return sh7750_register_io_device(s, &tc58128);
}
/*------------------------------------------------------------------------
* sysinit -- initialize all Xinu data structeres and devices
*------------------------------------------------------------------------
*/
LOCAL int sysinit()
{
int i,j;
struct pentry *pptr;
struct sentry *sptr;
struct mblock *mptr;
numproc = 0; /* initialize system variables */
nextproc = NPROC-1;
nextsem = NSEM-1;
nextqueue = NPROC; /* q[0..NPROC-1] are processes */
/* initialize free memory list */
/* PC version has to pre-allocate 640K-1024K "hole" */
if (maxaddr+1 > (char *)HOLESTART) {
memlist.mnext = mptr = (struct mblock *) roundmb(&end);
mptr->mnext = (struct mblock *)HOLEEND;
mptr->mlen = (int) truncew(((unsigned) HOLESTART -
(unsigned)&end));
mptr->mlen -= 4;
mptr = (struct mblock *) HOLEEND;
mptr->mnext = 0;
mptr->mlen = (int) truncew((unsigned)maxaddr - HOLEEND -
NULLSTK);
} else {
/* initialize free memory list */
memlist.mnext = mptr = (struct mblock *) roundmb(&end);
mptr->mnext = 0;
mptr->mlen = (int) truncew((unsigned)maxaddr - (int)&end -
NULLSTK);
}
for (i=0 ; i<NPROC ; i++) /* initialize process table */
proctab[i].pstate = PRFREE;
pptr = &proctab[NULLPROC]; /* initialize null process entry */
pptr->pstate = PRCURR;
for (j=0; j<7; j++)
pptr->pname[j] = "prnull"[j];
pptr->plimit = (WORD)(maxaddr + 1) - NULLSTK;
pptr->pbase = (WORD) maxaddr - 3;
pptr->pesp = pptr->pbase-4; /* for stkchk; rewritten before used */
*( (int *)pptr->pbase ) = MAGIC;
pptr->paddr = (WORD) nulluser;
pptr->pargs = 0;
pptr->pprio = 0;
currpid = NULLPROC;
for (i=0 ; i<NSEM ; i++) { /* initialize semaphores */
(sptr = &semaph[i])->sstate = SFREE;
sptr->sqtail = 1 + (sptr->sqhead = newqueue());
}
rdytail = 1 + (rdyhead=newqueue());/* initialize ready list */
#ifdef MEMMARK
_mkinit(); /* initialize memory marking */
#endif
#ifdef RTCLOCK
clkinit(); /* initialize r.t.clock */
#endif
pci_init(); /* PCI */
mon_init(); /* init monitor */
// ripinit();
#ifdef NDEVS
for (i=0 ; i<NDEVS ; i++ ) {
init_dev(i);
}
#endif
buf_init();
return(OK);
}
int main()
{
struct douban_radio* douban;
douban=(struct douban_radio*) malloc (sizeof(struct douban_radio));
memset(douban, 0, sizeof(struct douban_radio));
douban->channel=2;
douban_radio_playlist_load(douban);
int mp3_out = 0;
char com_temp[1];
init_dev(22050);
uart_fd = Uart_Init(uart_dev);
printf("douban channel %d \n", douban->channel);
while(1) //主消息循环
{
if(uart_read(uart_fd, protocol_buff, 1, 0) > 0)
//if((mp3_out == 1) || (uart_read(uart_fd, protocol_buff, 1, 0) > 0))
{
//mp3_out = 0;
//printf("get data\n");
switch(protocol_buff[0])
{
case COM_START:
com_temp[0] = COM_END;
write(uart_fd, com_temp, 1);
break;
case COM_TITLE:
printf("send title!\n");
send_title(uart_fd, douban);
break;
case COM_ARTIST:
printf("send artist!\n");
send_artist(uart_fd, douban);
break;
case COM_JPG:
printf("send jpg!\n");
send_jpg(uart_fd, douban);
break;
case COM_PLAY:
printf("douban channel %d \n", douban->channel);
play_song(uart_fd, douban);
//printf("play song1\n");
//ice_mp3("http://190.220.157.52:8000");
//mp3("/song1.mp3");
//mp3_out = 1;
break;
case NEW_LIST:
load_list(uart_fd, douban);
case COM_STOP:
stop(uart_fd);
printf("stop!\n");
break;
default:
break;
}
}
}
/*
int index;
struct douban_radio* douban;
douban=(struct douban_radio*) malloc (sizeof(struct douban_radio));
memset(douban, 0, sizeof(struct douban_radio));
douban->channel=2;
douban_radio_playlist_load(douban);
printf("items:\t%d\n",douban->size );
for (index = 0; index < douban->size; index ++)
{
printf("picture: \t%s\n", douban->items[index].picture);
printf("title : \t%s\n", douban->items[index].title);
printf("artist : \t%s\n", douban->items[index].artist);
printf("url : \t%s\n\n", douban->items[index].url);
printf("index %d \n", index);
}
free(douban);
printf("\n\n\n\n\n");
douban=(struct douban_radio*) malloc (sizeof(struct douban_radio));
memset(douban, 0, sizeof(struct douban_radio));
douban->channel=2;
douban_radio_playlist_load(douban);
//load_list(douban);
printf("items:\t%d\n",douban->size );
for (index = 0; index < douban->size; index ++)
{
printf("picture: \t%s\n", douban->items[index].picture);
printf("title : \t%s\n", douban->items[index].title);
printf("artist : \t%s\n", douban->items[index].artist);
printf("url : \t%s\n\n", douban->items[index].url);
printf("index %d \n", index);
}
*/
return 0;
}
/*
* Read in the information about files used in making the system.
* Store it in the ftab linked list.
*/
static void
read_files(void)
{
FILE *fp;
struct file_list *tp, *pf;
struct device *dp;
struct device *save_dp;
struct opt *op;
char *wd, *this, *needs, *special, *depends, *clean, *warning;
char fname[MAXPATHLEN];
int nonoptional;
int nreqs, first = 1, configdep, isdup, std, filetype,
imp_rule, no_obj, before_depend, nowerror, mandatory;
ftab = 0;
save_dp = NULL;
if (ident == NULL) {
printf("no ident line specified\n");
exit(1);
}
snprintf(fname, sizeof(fname), "../conf/files");
openit:
fp = fopen(fname, "r");
if (fp == NULL)
err(1, "%s", fname);
next:
/*
* filename [ standard | mandatory | optional ] [ config-dependent ]
* [ dev* | profiling-routine ] [ no-obj ]
* [ compile-with "compile rule" [no-implicit-rule] ]
* [ dependency "dependency-list"] [ before-depend ]
* [ clean "file-list"] [ warning "text warning" ]
*/
wd = get_word(fp);
if (wd == (char *)EOF) {
fclose(fp);
if (first == 1) {
first++;
snprintf(fname, sizeof(fname),
"../platform/%s/conf/files",
platformname);
fp = fopen(fname, "r");
if (fp != NULL)
goto next;
snprintf(fname, sizeof(fname),
"files.%s", platformname);
goto openit;
}
if (first == 2) {
first++;
snprintf(fname, sizeof(fname),
"files.%s", raisestr(ident));
fp = fopen(fname, "r");
if (fp != NULL)
goto next;
}
return;
}
if (wd == 0)
goto next;
if (wd[0] == '#')
{
while (((wd = get_word(fp)) != (char *)EOF) && wd)
;
goto next;
}
this = strdup(wd);
next_word(fp, wd);
if (wd == 0) {
printf("%s: No type for %s.\n",
fname, this);
exit(1);
}
if ((pf = fl_lookup(this)) && (pf->f_type != INVISIBLE || pf->f_flags))
isdup = 1;
else
isdup = 0;
tp = 0;
if (first == 3 && pf == NULL && (tp = fltail_lookup(this)) != NULL) {
if (tp->f_type != INVISIBLE || tp->f_flags)
printf("%s: Local file %s overrides %s.\n",
fname, this, tp->f_fn);
else
printf("%s: Local file %s could override %s"
" with a different kernel configuration.\n",
fname, this, tp->f_fn);
}
nreqs = 0;
special = NULL;
depends = NULL;
clean = NULL;
warning = NULL;
configdep = 0;
needs = NULL;
std = mandatory = nonoptional = 0;
imp_rule = 0;
no_obj = 0;
before_depend = 0;
nowerror = 0;
filetype = NORMAL;
if (strcmp(wd, "standard") == 0) {
std = 1;
} else if (strcmp(wd, "mandatory") == 0) {
/*
* If an entry is marked "mandatory", config will abort if
* it's not called by a configuration line in the config
* file. Apart from this, the device is handled like one
* marked "optional".
*/
mandatory = 1;
} else if (strcmp(wd, "nonoptional") == 0) {
nonoptional = 1;
} else if (strcmp(wd, "optional") == 0) {
/* don't need to do anything */
} else {
printf("%s: %s must be optional, mandatory or standard\n",
fname, this);
printf("Alternatively, your version of config(8) may be out of sync with your\nkernel source.\n");
exit(1);
}
nextparam:
next_word(fp, wd);
if (wd == NULL)
goto doneparam;
if (strcmp(wd, "config-dependent") == 0) {
configdep++;
goto nextparam;
}
if (strcmp(wd, "no-obj") == 0) {
no_obj++;
goto nextparam;
}
if (strcmp(wd, "no-implicit-rule") == 0) {
if (special == NULL) {
printf("%s: alternate rule required when "
"\"no-implicit-rule\" is specified.\n",
fname);
}
imp_rule++;
goto nextparam;
}
if (strcmp(wd, "before-depend") == 0) {
before_depend++;
goto nextparam;
}
if (strcmp(wd, "dependency") == 0) {
next_quoted_word(fp, wd);
if (wd == NULL) {
printf("%s: %s missing compile command string.\n",
fname, this);
exit(1);
}
depends = strdup(wd);
goto nextparam;
}
if (strcmp(wd, "clean") == 0) {
next_quoted_word(fp, wd);
if (wd == NULL) {
printf("%s: %s missing clean file list.\n",
fname, this);
exit(1);
}
clean = strdup(wd);
goto nextparam;
}
if (strcmp(wd, "compile-with") == 0) {
next_quoted_word(fp, wd);
if (wd == NULL) {
printf("%s: %s missing compile command string.\n",
fname, this);
exit(1);
}
special = strdup(wd);
goto nextparam;
}
if (strcmp(wd, "nowerror") == 0) {
nowerror++;
goto nextparam;
}
if (strcmp(wd, "warning") == 0) {
next_quoted_word(fp, wd);
if (wd == NULL) {
printf("%s: %s missing warning text string.\n",
fname, this);
exit(1);
}
warning = strdup(wd);
goto nextparam;
}
nreqs++;
if (strcmp(wd, "local") == 0) {
filetype = LOCAL;
goto nextparam;
}
if (strcmp(wd, "no-depend") == 0) {
filetype = NODEPEND;
goto nextparam;
}
if (strcmp(wd, "device-driver") == 0) {
printf("%s: `device-driver' flag obsolete.\n", fname);
exit(1);
}
if (strcmp(wd, "profiling-routine") == 0) {
filetype = PROFILING;
goto nextparam;
}
if (needs == 0 && nreqs == 1)
needs = strdup(wd);
if (isdup)
goto invis;
for (dp = dtab; dp != NULL; save_dp = dp, dp = dp->d_next)
if (strcmp(dp->d_name, wd) == 0) {
if (std && dp->d_type == PSEUDO_DEVICE &&
dp->d_count <= 0)
dp->d_count = 1;
goto nextparam;
}
if (mandatory) {
printf("%s: mandatory device \"%s\" not found\n",
fname, wd);
exit(1);
}
if (std) {
dp = malloc(sizeof(*dp));
bzero(dp, sizeof(*dp));
init_dev(dp);
dp->d_name = strdup(wd);
dp->d_type = PSEUDO_DEVICE;
dp->d_count = 1;
save_dp->d_next = dp;
goto nextparam;
}
for (op = opt; op != NULL; op = op->op_next) {
if (op->op_value == 0 && opteq(op->op_name, wd)) {
if (nreqs == 1) {
free(needs);
needs = NULL;
}
goto nextparam;
}
}
if (nonoptional) {
printf("%s: the option \"%s\" MUST be specified\n",
fname, wd);
exit(1);
}
invis:
while ((wd = get_word(fp)) != 0)
;
if (tp == NULL)
tp = new_fent();
tp->f_fn = this;
tp->f_type = INVISIBLE;
tp->f_needs = needs;
tp->f_flags = isdup;
tp->f_special = special;
tp->f_depends = depends;
tp->f_clean = clean;
tp->f_warn = warning;
goto next;
doneparam:
if (std == 0 && nreqs == 0) {
printf("%s: what is %s optional on?\n",
fname, this);
exit(1);
}
if (wd != NULL) {
printf("%s: syntax error describing %s\n",
fname, this);
exit(1);
}
if (filetype == PROFILING && profiling == 0)
goto next;
if (tp == NULL)
tp = new_fent();
tp->f_fn = this;
tp->f_type = filetype;
tp->f_flags = 0;
if (configdep)
tp->f_flags |= CONFIGDEP;
if (imp_rule)
tp->f_flags |= NO_IMPLCT_RULE;
if (no_obj)
tp->f_flags |= NO_OBJ;
if (before_depend)
tp->f_flags |= BEFORE_DEPEND;
if (nowerror)
tp->f_flags |= NOWERROR;
if (imp_rule)
tp->f_flags |= NO_IMPLCT_RULE;
if (no_obj)
tp->f_flags |= NO_OBJ;
tp->f_needs = needs;
tp->f_special = special;
tp->f_depends = depends;
tp->f_clean = clean;
tp->f_warn = warning;
if (pf && pf->f_type == INVISIBLE)
pf->f_flags = 1; /* mark as duplicate */
goto next;
}
static int gotemp_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
struct usb_device *udev = interface_to_usbdev(interface);
struct gotemp *gdev = NULL;
int retval = -ENOMEM;
int i;
struct usb_host_interface *iface_desc;
struct usb_endpoint_descriptor *endpoint = NULL;
size_t buffer_size = 0;
gdev = kzalloc(sizeof(struct gotemp), GFP_KERNEL);
if (gdev == NULL) {
dev_err(&interface->dev, "Out of memory\n");
goto error;
}
gdev->udev = usb_get_dev(udev);
/* find the one control endpoint of this device */
iface_desc = interface->cur_altsetting;
for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
endpoint = &iface_desc->endpoint[i].desc;
if (usb_endpoint_is_int_in(endpoint)) {
buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
gdev->int_in_endpointAddr = endpoint->bEndpointAddress;
gdev->int_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
if (!gdev->int_in_buffer) {
dev_err(&interface->dev,
"Could not allocate buffer");
goto error;
}
break;
}
}
if (!gdev->int_in_endpointAddr) {
dev_err(&interface->dev, "Could not find int-in endpoint");
retval = -ENODEV;
goto error;
}
gdev->int_in_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!gdev->int_in_urb) {
dev_err(&interface->dev, "No free urbs available\n");
goto error;
}
usb_fill_int_urb(gdev->int_in_urb, udev,
usb_rcvintpipe(udev,
endpoint->bEndpointAddress),
gdev->int_in_buffer, buffer_size,
read_int_callback, gdev,
endpoint->bInterval);
usb_set_intfdata(interface, gdev);
init_dev(gdev);
/*
* this must come last - after this call the device is active
* if we delayed any initialization until after this, the user
* would read garbage
*/
retval = device_create_file(&interface->dev, &dev_attr_temperature);
if (retval)
goto error;
dev_info(&interface->dev, "USB GoTemp device now attached\n");
return 0;
error:
usb_set_intfdata(interface, NULL);
if (gdev) {
usb_free_urb(gdev->int_in_urb);
kfree(gdev->int_in_buffer);
}
kfree(gdev);
return retval;
}
void *device_initialization(void *arg)
{
DEVRES *device;
DCR *dcr;
JCR *jcr;
DEVICE *dev;
int errstat;
LockRes();
pthread_detach(pthread_self());
jcr = new_jcr(sizeof(JCR), stored_free_jcr);
new_plugins(jcr); /* instantiate plugins */
jcr->setJobType(JT_SYSTEM);
/*
* Initialize job start condition variable
*/
errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
if (errstat != 0) {
berrno be;
Jmsg1(jcr, M_ABORT, 0, _("Unable to init job start cond variable: ERR=%s\n"), be.bstrerror(errstat));
}
/*
* Initialize job end condition variable
*/
errstat = pthread_cond_init(&jcr->job_end_wait, NULL);
if (errstat != 0) {
berrno be;
Jmsg1(jcr, M_ABORT, 0, _("Unable to init job endstart cond variable: ERR=%s\n"), be.bstrerror(errstat));
}
foreach_res(device, R_DEVICE) {
Dmsg1(90, "calling init_dev %s\n", device->device_name);
dev = init_dev(NULL, device);
Dmsg1(10, "SD init done %s\n", device->device_name);
if (!dev) {
Jmsg1(NULL, M_ERROR, 0, _("Could not initialize %s\n"), device->device_name);
continue;
}
jcr->dcr = dcr = new_dcr(jcr, NULL, dev, NULL);
generate_plugin_event(jcr, bsdEventDeviceInit, dcr);
if (dev->is_autochanger()) {
/* If autochanger set slot in dev structure */
get_autochanger_loaded_slot(dcr);
}
if (device->cap_bits & CAP_ALWAYSOPEN) {
Dmsg1(20, "calling first_open_device %s\n", dev->print_name());
if (!first_open_device(dcr)) {
Jmsg1(NULL, M_ERROR, 0, _("Could not open device %s\n"), dev->print_name());
Dmsg1(20, "Could not open device %s\n", dev->print_name());
free_dcr(dcr);
jcr->dcr = NULL;
continue;
}
}
if (device->cap_bits & CAP_AUTOMOUNT && dev->is_open()) {
switch (read_dev_volume_label(dcr)) {
case VOL_OK:
memcpy(&dev->VolCatInfo, &dcr->VolCatInfo, sizeof(dev->VolCatInfo));
volume_unused(dcr); /* mark volume "released" */
break;
default:
Jmsg1(NULL, M_WARNING, 0, _("Could not mount device %s\n"), dev->print_name());
break;
}
}
free_dcr(dcr);
jcr->dcr = NULL;
}
int
process_cgi (struct ushare_t *ut, char *cgiargs)
{
char *action = NULL;
int refresh = 0;
if (!ut || !cgiargs)
return -1;
if (strncmp (cgiargs, CGI_ACTION, strlen (CGI_ACTION)))
return -1;
action = cgiargs + strlen (CGI_ACTION);
if (!strncmp (action, CGI_ACTION_ADD, strlen (CGI_ACTION_ADD)))
{
char *path = NULL;
path = action + strlen (CGI_ACTION_ADD) + 1;
if (path && !strncmp (path, CGI_PATH"=", strlen (CGI_PATH) + 1))
{
ut->contentlist = content_add (ut->contentlist,
path + strlen (CGI_PATH) + 1);
refresh = 1;
}
}
else if (!strncmp (action, CGI_ACTION_DEL, strlen (CGI_ACTION_DEL)))
{
char *shares,*share;
char *m_buffer = NULL, *buffer;
int num, shift=0;
shares = strdup (action + strlen (CGI_ACTION_DEL) + 1);
m_buffer = (char*) malloc (strlen (shares) * sizeof (char));
if (m_buffer)
{
buffer = m_buffer;
for (share = strtok_r (shares, "&", &buffer) ; share ;
share = strtok_r (NULL, "&", &buffer))
{
if (sscanf (share, CGI_SHARE"[%d]=on", &num) < 0)
continue;
ut->contentlist = content_del (ut->contentlist, num - shift++);
}
free (m_buffer);
}
refresh = 1;
free (shares);
}
else if (!strncmp (action, CGI_ACTION_REFRESH, strlen (CGI_ACTION_REFRESH)))
refresh = 1;
else if (!strncmp (action, CGI_WebCam_Start, strlen (CGI_WebCam_Start)))
{
extern pthread_mutex_t grab_ctrl_mutex;
extern pthread_cond_t grab_ctrl_cond;
if( videoIn.cameraname == NULL )
{
if( init_dev(WebCam_DEV, 0)== 0)
{
pthread_mutex_lock (&grab_ctrl_mutex);
pthread_cond_signal (&grab_ctrl_cond);
pthread_mutex_unlock (&grab_ctrl_mutex);
capFlag = 1;capOK = 0;
}
else
{
close_v4l(&videoIn);
memset (&videoIn, 0, sizeof (struct vdIn));
capFlag = 0;capOK = 1;
}
}
else
{
pthread_mutex_lock (&grab_ctrl_mutex);
pthread_cond_signal (&grab_ctrl_cond);
pthread_mutex_unlock (&grab_ctrl_mutex);
capFlag = 1;capOK = 0;
}
}
else if (!strncmp (action, CGI_WebCam_Stop, strlen (CGI_WebCam_Stop)))
{
extern int webcam_exit_flag,Pic_exit_flag, Mov_exit_flag;
extern pthread_mutex_t Pic_mutex,Mov_mutex;
extern pthread_cond_t Mov_cond,Pic_cond;
capFlag = 0;
if( videoIn.cameraname != NULL )
{
webcam_exit_flag = 1;
if( Pic_exit_flag == 1 )
{
pthread_mutex_lock (&Pic_mutex);
pthread_cond_signal (&Pic_cond);
pthread_mutex_unlock (&Pic_mutex);
}
else
Pic_exit_flag = 1;
if( Mov_exit_flag == 1 )
{
pthread_mutex_lock (&Mov_mutex);
pthread_cond_signal (&Mov_cond);
pthread_mutex_unlock (&Mov_mutex);
}
else
Mov_exit_flag = 1;
}
}
extern int scanDir_flag;
if (refresh && ut->contentlist && !scanDir_flag)
{
scanDir_flag = 1;
free_metadata_list (ut);
build_metadata_list (ut);
scanDir_flag = 0;
}
if (ut->presentation)
buffer_free (ut->presentation);
ut->presentation = buffer_new ();
buffer_append (ut->presentation, "<html>");
buffer_append (ut->presentation, "<head>");
buffer_appendf (ut->presentation, "<title>%s</title>",
_("uShare Information Page"));
buffer_append (ut->presentation,
"<meta http-equiv=\"pragma\" content=\"no-cache\"/>");
buffer_append (ut->presentation,
"<meta http-equiv=\"expires\" content=\"1970-01-01\"/>");
buffer_append (ut->presentation,
"<meta http-equiv=\"refresh\" content=\"0; URL=/web/ushare.html\"/>");
buffer_append (ut->presentation, "</head>");
buffer_append (ut->presentation, "</html>");
return 0;
}
