static ssize_t pccard_show_card_pm_state(struct device *dev, struct device_attribute *attr, char *buf) { struct pcmcia_socket *s = to_socket(dev); return sprintf(buf, "%s\n", s->state & SOCKET_SUSPEND ? "off" : "on"); }
static ssize_t pccard_store_resource(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned long flags; struct pcmcia_socket *s = to_socket(dev); if (!count) return -EINVAL; spin_lock_irqsave(&s->lock, flags); if (!s->resource_setup_done) s->resource_setup_done = 1; spin_unlock_irqrestore(&s->lock, flags); mutex_lock(&s->skt_mutex); if ((s->callback) && (s->state & SOCKET_PRESENT) && !(s->state & SOCKET_CARDBUS)) { if (try_module_get(s->callback->owner)) { s->callback->requery(s, 0); module_put(s->callback->owner); } } mutex_unlock(&s->skt_mutex); return count; }
static void ngx_lcb_timer_thunk(ngx_event_t *ev) { ngx_lcb_context_t *ctx = ev->data; ctx->handler(to_socket(-1), 0, ctx->handler_data); }
static ssize_t pccard_show_irq_mask(struct device *dev, struct device_attribute *attr, char *buf) { struct pcmcia_socket *s = to_socket(dev); return sprintf(buf, "0x%04x\n", s->irq_mask); }
static ssize_t pccard_show_vcc(struct device *dev, struct device_attribute *attr, char *buf) { struct pcmcia_socket *s = to_socket(dev); if (!(s->state & SOCKET_PRESENT)) return -ENODEV; return sprintf(buf, "%d.%dV\n", s->socket.Vcc / 10, s->socket.Vcc % 10); }
static ssize_t pccard_show_type(struct device *dev, struct device_attribute *attr, char *buf) { struct pcmcia_socket *s = to_socket(dev); if (!(s->state & SOCKET_PRESENT)) return -ENODEV; if (s->state & SOCKET_CARDBUS) return sprintf(buf, "32-bit\n"); return sprintf(buf, "16-bit\n"); }
static ssize_t pccard_store_insert(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct pcmcia_socket *s = to_socket(dev); if (!count) return -EINVAL; pcmcia_parse_uevents(s, PCMCIA_UEVENT_INSERT); return count; }
/* allocate ngx_peer_connection_t struct */ static lcb_socket_t ngx_lcb_socket(lcb_io_opt_t io, const char *hostname, const char *servname) { ngx_lcb_context_t *ctx; ngx_lcb_cookie_t cookie = io->v.v0.cookie; ctx = ngx_pcalloc(cookie->pool, sizeof(ngx_lcb_context_t)); if (ctx == NULL) { return to_socket(-1); } ctx->io_len = io->v.v0.iov_max; ctx->io_chains = ngx_pcalloc(cookie->pool, sizeof(ngx_chain_t) * ctx->io_len); ctx->io_bufs = ngx_pcalloc(cookie->pool, sizeof(ngx_buf_t) * ctx->io_len); ctx->peer = ngx_pcalloc(cookie->pool, sizeof(ngx_peer_connection_t)); if (ctx->io_chains == NULL || ctx->io_bufs == NULL || ctx->peer == NULL) { ngx_lcb_close(io, to_socket(ctx)); return to_socket(-1); } ctx->peer->log = cookie->log; ctx->peer->log_error = NGX_ERROR_ERR; ctx->peer->get = ngx_event_get_peer; if (common_getaddrinfo(hostname, servname, &ctx->root_ai) != 0) { ngx_lcb_close(io, to_socket(ctx)); return to_socket(-1); } ctx->curr_ai = ctx->root_ai; return to_socket(ctx); }
static ssize_t pccard_store_insert(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { ssize_t ret; struct pcmcia_socket *s = to_socket(dev); if (!count) return -EINVAL; ret = pcmcia_insert_card(s); return ret ? ret : count; }
static void ngx_lcb_handler_thunk(ngx_event_t *ev) { ngx_connection_t *conn = ev->data; ngx_lcb_context_t *ctx = conn->data; int which = 0; if (ev->write) { which |= LCB_WRITE_EVENT; } else { which |= LCB_READ_EVENT; } if (ctx->handler_mask & which) { ctx->handler(to_socket(ctx), which, ctx->handler_data); } }
static ssize_t pccard_store_card_pm_state(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { ssize_t ret = -EINVAL; struct pcmcia_socket *s = to_socket(dev); if (!count) return -EINVAL; if (!(s->state & SOCKET_SUSPEND) && !strncmp(buf, "off", 3)) ret = pcmcia_suspend_card(s); else if ((s->state & SOCKET_SUSPEND) && !strncmp(buf, "on", 2)) ret = pcmcia_resume_card(s); return ret ? -ENODEV : count; }
static ssize_t pccard_store_resource(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct pcmcia_socket *s = to_socket(dev); if (!count) return -EINVAL; mutex_lock(&s->ops_mutex); if (!s->resource_setup_done) s->resource_setup_done = 1; mutex_unlock(&s->ops_mutex); pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY); return count; }
static ssize_t pccard_store_irq_mask(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { ssize_t ret; struct pcmcia_socket *s = to_socket(dev); u32 mask; if (!count) return -EINVAL; ret = sscanf (buf, "0x%x\n", &mask); if (ret == 1) { s->irq_mask &= mask; ret = 0; } return ret ? ret : count; }
static ssize_t pccard_store_card_pm_state(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct pcmcia_socket *s = to_socket(dev); ssize_t ret = count; if (!count) return -EINVAL; if (!strncmp(buf, "off", 3)) pcmcia_parse_uevents(s, PCMCIA_UEVENT_SUSPEND); else { if (!strncmp(buf, "on", 2)) pcmcia_parse_uevents(s, PCMCIA_UEVENT_RESUME); else ret = -EINVAL; } return ret; }
static ssize_t pccard_show_resource(struct device *dev, struct device_attribute *attr, char *buf) { struct pcmcia_socket *s = to_socket(dev); return sprintf(buf, "%s\n", s->resource_setup_done ? "yes" : "no"); }
static void add_nodes(Scene *scene, BL::RenderEngine& b_engine, BL::BlendData& b_data, BL::Scene& b_scene, const bool background, ShaderGraph *graph, BL::ShaderNodeTree& b_ntree, const ProxyMap &proxy_input_map, const ProxyMap &proxy_output_map) { /* add nodes */ BL::ShaderNodeTree::nodes_iterator b_node; PtrInputMap input_map; PtrOutputMap output_map; BL::Node::inputs_iterator b_input; BL::Node::outputs_iterator b_output; /* find the node to use for output if there are multiple */ bool found_active_output = false; BL::ShaderNode output_node(PointerRNA_NULL); for(b_ntree.nodes.begin(b_node); b_node != b_ntree.nodes.end(); ++b_node) { if(is_output_node(*b_node)) { BL::ShaderNodeOutputMaterial b_output_node(*b_node); if(b_output_node.is_active_output()) { output_node = b_output_node; found_active_output = true; break; } else if(!output_node.ptr.data && !found_active_output) { output_node = b_output_node; } } } /* add nodes */ for(b_ntree.nodes.begin(b_node); b_node != b_ntree.nodes.end(); ++b_node) { if(b_node->mute() || b_node->is_a(&RNA_NodeReroute)) { /* replace muted node with internal links */ BL::Node::internal_links_iterator b_link; for(b_node->internal_links.begin(b_link); b_link != b_node->internal_links.end(); ++b_link) { BL::NodeSocket to_socket(b_link->to_socket()); ProxyNode *proxy = new ProxyNode(convert_socket_type(to_socket)); input_map[b_link->from_socket().ptr.data] = proxy->inputs[0]; output_map[b_link->to_socket().ptr.data] = proxy->outputs[0]; graph->add(proxy); } } else if(b_node->is_a(&RNA_ShaderNodeGroup) || b_node->is_a(&RNA_NodeCustomGroup)) { BL::ShaderNodeTree b_group_ntree(PointerRNA_NULL); if(b_node->is_a(&RNA_ShaderNodeGroup)) b_group_ntree = BL::ShaderNodeTree(((BL::NodeGroup)(*b_node)).node_tree()); else b_group_ntree = BL::ShaderNodeTree(((BL::NodeCustomGroup)(*b_node)).node_tree()); ProxyMap group_proxy_input_map, group_proxy_output_map; /* Add a proxy node for each socket * Do this even if the node group has no internal tree, * so that links have something to connect to and assert won't fail. */ for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) { ProxyNode *proxy = new ProxyNode(convert_socket_type(*b_input)); graph->add(proxy); /* register the proxy node for internal binding */ group_proxy_input_map[b_input->identifier()] = proxy; input_map[b_input->ptr.data] = proxy->inputs[0]; set_default_value(proxy->inputs[0], *b_input, b_data, b_ntree); } for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) { ProxyNode *proxy = new ProxyNode(convert_socket_type(*b_output)); graph->add(proxy); /* register the proxy node for internal binding */ group_proxy_output_map[b_output->identifier()] = proxy; output_map[b_output->ptr.data] = proxy->outputs[0]; } if(b_group_ntree) { add_nodes(scene, b_engine, b_data, b_scene, background, graph, b_group_ntree, group_proxy_input_map, group_proxy_output_map); } } else if(b_node->is_a(&RNA_NodeGroupInput)) { /* map each socket to a proxy node */ for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) { ProxyMap::const_iterator proxy_it = proxy_input_map.find(b_output->identifier()); if(proxy_it != proxy_input_map.end()) { ProxyNode *proxy = proxy_it->second; output_map[b_output->ptr.data] = proxy->outputs[0]; } } } else if(b_node->is_a(&RNA_NodeGroupOutput)) { BL::NodeGroupOutput b_output_node(*b_node); /* only the active group output is used */ if(b_output_node.is_active_output()) { /* map each socket to a proxy node */ for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) { ProxyMap::const_iterator proxy_it = proxy_output_map.find(b_input->identifier()); if(proxy_it != proxy_output_map.end()) { ProxyNode *proxy = proxy_it->second; input_map[b_input->ptr.data] = proxy->inputs[0]; set_default_value(proxy->inputs[0], *b_input, b_data, b_ntree); } } } } else { ShaderNode *node = NULL; if(is_output_node(*b_node)) { if(b_node->ptr.data == output_node.ptr.data) { node = graph->output(); } } else { BL::ShaderNode b_shader_node(*b_node); node = add_node(scene, b_engine, b_data, b_scene, background, graph, b_ntree, b_shader_node); } if(node) { /* map node sockets for linking */ for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) { ShaderInput *input = node_find_input_by_name(node, *b_node, *b_input); if(!input) { /* XXX should not happen, report error? */ continue; } input_map[b_input->ptr.data] = input; set_default_value(input, *b_input, b_data, b_ntree); } for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) { ShaderOutput *output = node_find_output_by_name(node, *b_node, *b_output); if(!output) { /* XXX should not happen, report error? */ continue; } output_map[b_output->ptr.data] = output; } } } } /* connect nodes */ BL::NodeTree::links_iterator b_link; for(b_ntree.links.begin(b_link); b_link != b_ntree.links.end(); ++b_link) { /* Ignore invalid links to avoid unwanted cycles created in graph. */ if(!b_link->is_valid()) { continue; } /* get blender link data */ BL::NodeSocket b_from_sock = b_link->from_socket(); BL::NodeSocket b_to_sock = b_link->to_socket(); ShaderOutput *output = 0; ShaderInput *input = 0; PtrOutputMap::iterator output_it = output_map.find(b_from_sock.ptr.data); if(output_it != output_map.end()) output = output_it->second; PtrInputMap::iterator input_it = input_map.find(b_to_sock.ptr.data); if(input_it != input_map.end()) input = input_it->second; /* either node may be NULL when the node was not exported, typically * because the node type is not supported */ if(output && input) graph->connect(output, input); } }