void cache_access(struct cache *cache, int access_type, void *addr) { if (!cache) return; cache->access_count[access_type]++; struct decoded_address d_addr; decode_address(&d_addr, addr, cache); struct set *set = &cache->sets[d_addr.index]; bool hit = set_access(set, d_addr.tag, access_type); if (!hit) cache_miss(cache, access_type, set, &d_addr); }
void test_set_access(CuTest *tc) { struct decoded_address addr; struct cache cache; int c = 16; int b = 4; int s = 4; cache_init(&cache, NULL, 0, c, b, s); CuAssertIntEquals(tc, 16, cache.sets[0].entry_count); addr.tag = 0xDEADB; addr.index = 0xEE; addr.offset = 0xF; /* fill in with some dummy data */ struct set *set = cache.sets; struct cache_entry *e; for (int i = 0; i < set->entry_count; ++i) { e = &set->entries[i]; e->age = i; e->tag = i; e->flags = VALID; } int mid = set->entry_count / 2; set->entries[mid].age = 250; set->entries[mid].tag = 42; int hit = set_access(set, addr.tag, READ_ACCESS); CuAssertIntEquals(tc, 0, hit); CuAssertIntEquals(tc, 251, set->entries[mid].age); CuAssertTrue(tc, set->entries[mid].flags & VALID); CuAssertTrue(tc, !(set->entries[mid].flags & DIRTY)); set->entries[mid].tag = 42; addr.tag = 43; hit = set_access(set, addr.tag, WRITE_ACCESS); CuAssertIntEquals(tc, 0, hit); CuAssertIntEquals(tc, 252, set->entries[mid].age); CuAssertTrue(tc, set->entries[mid].flags & VALID); CuAssertTrue(tc, !(set->entries[mid].flags & DIRTY)); set->entries[mid].tag = 42; addr.tag = 42; hit = set_access(set, addr.tag, WRITE_ACCESS); CuAssertIntEquals(tc, 1, hit); CuAssertIntEquals(tc, 0, set->entries[mid].age); CuAssertTrue(tc, set->entries[mid].flags & VALID); CuAssertTrue(tc, (set->entries[mid].flags & DIRTY)); }
static void set_property_info(Array &ret, ClassInfo::PropertyInfo *info, const ClassInfo *cls) { ret.set("name", info->name); set_access(ret, info->attribute); ret.set("modifiers", get_modifiers(info->attribute, false)); ret.set("static", (bool)(info->attribute & ClassInfo::IsStatic)); ret.set("class", cls->getName()); set_doc_comment(ret, info->docComment); }
int agentppTestSparseCol3::set(const Vbx& vb) { //--AgentGen BEGIN=agentppTestSparseCol3::set OctetStr v; vb.get_value(v); if (v == get_state()) set_access(NOACCESS); //--AgentGen END return MibLeaf::set(vb); }
DexField* make_field_def(DexType* cls, const char* name, DexType* type, DexAccessFlags access = ACC_PUBLIC, bool external = false) { auto field = DexField::make_field(cls, DexString::make_string(name), type); if (external) { field->set_access(access); field->set_external(); } else { field->make_concrete(access); } return field; }
static void set_method_info(Array &ret, ClassInfo::MethodInfo *info, const ClassInfo *cls) { ret.set("name", info->name); set_access(ret, info->attribute); ret.set("modifiers", get_modifiers(info->attribute, false)); ret.set("static", (bool)(info->attribute & ClassInfo::IsStatic)); ret.set("final", (bool)(info->attribute & ClassInfo::IsFinal)); ret.set("abstract", (bool)(info->attribute & ClassInfo::IsAbstract)); ret.set("internal", (bool)(cls->getAttribute() & ClassInfo::IsSystem)); ret.set("class", cls->getName()); set_function_info(ret, info, cls->getName()); }
auto add_getProperty(ossia::net::node_base& n, Object& obj, QObject* context) { constexpr const auto t = ossia::qt_property_converter<typename Property::param_type>::val; auto node = n.create_child(Property::name); SCORE_ASSERT(node); auto addr = node->create_parameter(t); SCORE_ASSERT(addr); addr->set_access(ossia::access_mode::GET); return std::make_unique<GetPropertyWrapper<Property>>(*addr, obj, context); }
int mem_reset_ipc_link(struct mem_link_device *mld) { struct link_device *ld = &mld->link_dev; unsigned int magic; unsigned int access; set_access(mld, 0); set_magic(mld, 0); reset_ipc_map(mld); reset_ipc_devices(mld); atomic_set(&ld->netif_stopped, 0); set_magic(mld, MEM_IPC_MAGIC); set_access(mld, 1); magic = get_magic(mld); access = get_access(mld); if (magic != MEM_IPC_MAGIC || access != 1) return -EACCES; return 0; }
int mem_reset_ipc_link(struct mem_link_device *mld) { struct link_device *ld = &mld->link_dev; unsigned int magic; unsigned int access; int i; set_access(mld, 0); set_magic(mld, 0); reset_ipc_map(mld); for (i = 0; i < MAX_SIPC5_DEVICES; i++) { struct mem_ipc_device *dev = mld->dev[i]; skb_queue_purge(dev->skb_txq); atomic_set(&dev->txq.busy, 0); dev->req_ack_cnt[TX] = 0; skb_queue_purge(dev->skb_rxq); atomic_set(&dev->rxq.busy, 0); dev->req_ack_cnt[RX] = 0; } atomic_set(&ld->netif_stopped, 0); set_magic(mld, MEM_IPC_MAGIC); set_access(mld, 1); magic = get_magic(mld); access = get_access(mld); if (magic != MEM_IPC_MAGIC || access != 1) return -EACCES; return 0; }
static int dpram_init_ipc(struct dpram_link_device *dpld) { struct link_device *ld = &dpld->ld; int i; if (ld->mode == LINK_MODE_IPC && get_magic(dpld) == DPRAM_MAGIC_CODE && get_access(dpld) == 1) mif_info("%s: IPC already initialized\n", ld->name); /* Clear pointers in every circular queue */ for (i = 0; i < dpld->max_ipc_dev; i++) { set_tx_head(dpld, i, 0); set_tx_tail(dpld, i, 0); set_rx_head(dpld, i, 0); set_rx_tail(dpld, i, 0); } /* Initialize variables for efficient TX/RX processing */ for (i = 0; i < dpld->max_ipc_dev; i++) dpld->iod[i] = link_get_iod_with_format(ld, i); dpld->iod[IPC_RAW] = link_get_iod_with_format(ld, IPC_MULTI_RAW); if (dpld->iod[IPC_RAW]->recv_skb) dpld->use_skb = true; for (i = 0; i < dpld->max_ipc_dev; i++) { spin_lock_init(&dpld->tx_lock[i]); atomic_set(&dpld->res_required[i], 0); skb_queue_purge(&dpld->skb_rxq[i]); } /* Enable IPC */ atomic_set(&dpld->accessing, 0); set_magic(dpld, DPRAM_MAGIC_CODE); set_access(dpld, 1); if (get_magic(dpld) != DPRAM_MAGIC_CODE || get_access(dpld) != 1) return -EACCES; ld->mode = LINK_MODE_IPC; if (wake_lock_active(&dpld->wlock)) wake_unlock(&dpld->wlock); return 0; }
void mem_handle_cp_crash(struct mem_link_device *mld, enum modem_state state) { struct link_device *ld = &mld->link_dev; struct modem_ctl *mc = ld->mc; #ifdef CONFIG_LINK_POWER_MANAGEMENT if (mld->stop_pm) mld->stop_pm(mld); #endif /* Disable normal IPC */ set_magic(mld, MEM_CRASH_MAGIC); set_access(mld, 0); stop_tx(mld); purge_txq(mld); if (cp_online(mc)) set_modem_state(mld, state); atomic_set(&mc->forced_cp_crash, 0); }
static int dpram_init_ipc(struct dpram_link_device *dpld) { struct link_device *ld = &dpld->ld; int i; if (ld->mode == LINK_MODE_IPC && get_magic(dpld) == DPRAM_MAGIC_CODE && get_access(dpld) == 1) mif_info("%s: IPC already initialized\n", ld->name); /* Clear pointers in every circular queue */ for (i = 0; i < dpld->max_ipc_dev; i++) { set_tx_head(dpld, i, 0); set_tx_tail(dpld, i, 0); set_rx_head(dpld, i, 0); set_rx_tail(dpld, i, 0); } for (i = 0; i < dpld->max_ipc_dev; i++) { spin_lock_init(&dpld->tx_lock[i]); atomic_set(&dpld->res_required[i], 0); } atomic_set(&dpld->accessing, 0); /* Enable IPC */ set_magic(dpld, DPRAM_MAGIC_CODE); set_access(dpld, 1); if (get_magic(dpld) != DPRAM_MAGIC_CODE || get_access(dpld) != 1) return -EACCES; ld->mode = LINK_MODE_IPC; if (wake_lock_active(&dpld->wlock)) wake_unlock(&dpld->wlock); return 0; }
void mem_handle_cp_crash(struct mem_link_device *mld, enum modem_state state) { struct link_device *ld = &mld->link_dev; struct modem_ctl *mc = ld->mc; int i; /* Disable normal IPC */ set_magic(mld, MEM_CRASH_MAGIC); set_access(mld, 0); if (!wake_lock_active(&mld->dump_wlock)) wake_lock(&mld->dump_wlock); stop_net_ifaces(ld); /* Purge the skb_txq in every IPC device (IPC_FMT, IPC_RAW, etc.) */ for (i = 0; i < MAX_SIPC5_DEV; i++) skb_queue_purge(mld->dev[i]->skb_txq); if (cp_online(mc)) set_modem_state(mld, state); mld->forced_cp_crash = false; }
/** @brief trigger an enforced CP crash @param mld the pointer to a mem_link_device instance */ void mem_forced_cp_crash(struct mem_link_device *mld) { struct link_device *ld = &mld->link_dev; struct modem_ctl *mc = ld->mc; unsigned long flags; bool duplicated = false; #ifdef DEBUG_MODEM_IF struct utc_time t; #endif #ifdef DEBUG_MODEM_IF get_utc_time(&t); #endif /* Disable normal IPC */ set_magic(mld, MEM_CRASH_MAGIC); set_access(mld, 0); spin_lock_irqsave(&mld->lock, flags); if (mld->forced_cp_crash) duplicated = true; else mld->forced_cp_crash = true; spin_unlock_irqrestore(&mld->lock, flags); if (duplicated) { #ifdef DEBUG_MODEM_IF evt_log(HMSU_FMT " %s: %s: ALREADY in progress <%pf>\n", t.hour, t.min, t.sec, t.us, CALLEE, ld->name, CALLER); #endif return; } if (!cp_online(mc)) { #ifdef DEBUG_MODEM_IF evt_log(HMSU_FMT " %s: %s: %s.state %s != ONLINE <%pf>\n", t.hour, t.min, t.sec, t.us, CALLEE, ld->name, mc->name, mc_state(mc), CALLER); #endif return; } if (!wake_lock_active(&mld->dump_wlock)) wake_lock(&mld->dump_wlock); stop_net_ifaces(ld); /** * If there is no CRASH_ACK from a CP in FORCE_CRASH_ACK_TIMEOUT, * handle_no_cp_crash_ack() will be executed. */ mif_add_timer(&mld->crash_ack_timer, FORCE_CRASH_ACK_TIMEOUT, handle_no_cp_crash_ack, (unsigned long)mld); /* Send CRASH_EXIT command to a CP */ send_ipc_irq(mld, cmd2int(CMD_CRASH_EXIT)); #ifdef DEBUG_MODEM_IF evt_log(HMSU_FMT " CRASH_EXIT: %s->%s: CP_CRASH_REQ <by %pf>\n", t.hour, t.min, t.sec, t.us, ld->name, mc->name, CALLER); if (in_interrupt()) queue_work(system_nrt_wq, &mld->dump_work); else save_mem_dump(mld); #endif }
struct link_device *dpram_create_link_device(struct platform_device *pdev) { struct modem_data *mdm_data = NULL; struct dpram_link_device *dpld = NULL; struct link_device *ld = NULL; struct resource *res = NULL; resource_size_t res_size; struct modemlink_dpram_control *dpctl = NULL; unsigned long task_data; int ret = 0; int i = 0; int bsize; int qsize; /* Get the platform data */ mdm_data = (struct modem_data *)pdev->dev.platform_data; if (!mdm_data) { mif_info("ERR! mdm_data == NULL\n"); goto err; } mif_info("modem = %s\n", mdm_data->name); mif_info("link device = %s\n", mdm_data->link_name); if (!mdm_data->dpram_ctl) { mif_info("ERR! mdm_data->dpram_ctl == NULL\n"); goto err; } dpctl = mdm_data->dpram_ctl; /* Alloc DPRAM link device structure */ dpld = kzalloc(sizeof(struct dpram_link_device), GFP_KERNEL); if (!dpld) { mif_info("ERR! kzalloc dpld fail\n"); goto err; } ld = &dpld->ld; task_data = (unsigned long)dpld; /* Retrieve modem data and DPRAM control data from the modem data */ ld->mdm_data = mdm_data; ld->name = mdm_data->link_name; ld->ipc_version = mdm_data->ipc_version; /* Retrieve the most basic data for IPC from the modem data */ dpld->dpctl = dpctl; dpld->dp_type = dpctl->dp_type; if (mdm_data->ipc_version < SIPC_VER_50) { if (!dpctl->max_ipc_dev) { mif_info("ERR! no max_ipc_dev\n"); goto err; } ld->aligned = dpctl->aligned; dpld->max_ipc_dev = dpctl->max_ipc_dev; } else { ld->aligned = 1; dpld->max_ipc_dev = MAX_SIPC5_DEV; } /* Set attributes as a link device */ ld->init_comm = dpram_link_init; ld->terminate_comm = dpram_link_terminate; ld->send = dpram_send; ld->force_dump = dpram_force_dump; ld->dump_start = dpram_dump_start; ld->dump_update = dpram_dump_update; ld->ioctl = dpram_ioctl; INIT_LIST_HEAD(&ld->list); skb_queue_head_init(&ld->sk_fmt_tx_q); skb_queue_head_init(&ld->sk_raw_tx_q); skb_queue_head_init(&ld->sk_rfs_tx_q); ld->skb_txq[IPC_FMT] = &ld->sk_fmt_tx_q; ld->skb_txq[IPC_RAW] = &ld->sk_raw_tx_q; ld->skb_txq[IPC_RFS] = &ld->sk_rfs_tx_q; /* Set up function pointers */ dpram_setup_common_op(dpld); dpld->dpram_dump = dpram_dump_memory; dpld->ext_op = dpram_get_ext_op(mdm_data->modem_type); /* Retrieve DPRAM resource */ if (!dpctl->dp_base) { res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { mif_info("%s: ERR! platform_get_resource fail\n", ld->name); goto err; } res_size = resource_size(res); dpctl->dp_base = ioremap_nocache(res->start, res_size); dpctl->dp_size = res_size; } dpld->dp_base = dpctl->dp_base; dpld->dp_size = dpctl->dp_size; mif_info("%s: dp_type %d, aligned %d, dp_base 0x%08X, dp_size %d\n", ld->name, dpld->dp_type, ld->aligned, (int)dpld->dp_base, dpld->dp_size); /* Initialize DPRAM map (physical map -> logical map) */ ret = dpram_table_init(dpld); if (ret < 0) { mif_info("%s: ERR! dpram_table_init fail (err %d)\n", ld->name, ret); goto err; } /* Disable IPC */ set_magic(dpld, 0); set_access(dpld, 0); dpld->dpram_init_status = DPRAM_INIT_STATE_NONE; /* Initialize locks, completions, and bottom halves */ snprintf(dpld->wlock_name, DP_MAX_NAME_LEN, "%s_wlock", ld->name); wake_lock_init(&dpld->wlock, WAKE_LOCK_SUSPEND, dpld->wlock_name); init_completion(&dpld->dpram_init_cmd); init_completion(&dpld->modem_pif_init_done); init_completion(&dpld->udl_start_complete); init_completion(&dpld->udl_cmd_complete); init_completion(&dpld->crash_start_complete); init_completion(&dpld->dump_start_complete); init_completion(&dpld->dump_recv_done); tasklet_init(&dpld->rx_tsk, dpram_ipc_rx_task, task_data); if (dpld->ext_op && dpld->ext_op->dl_task) tasklet_init(&dpld->dl_tsk, dpld->ext_op->dl_task, task_data); /* Prepare RXB queue */ qsize = DPRAM_MAX_RXBQ_SIZE; for (i = 0; i < dpld->max_ipc_dev; i++) { bsize = rxbq_get_page_size(get_rx_buff_size(dpld, i)); dpld->rxbq[i].size = qsize; dpld->rxbq[i].in = 0; dpld->rxbq[i].out = 0; dpld->rxbq[i].rxb = rxbq_create_pool(bsize, qsize); if (!dpld->rxbq[i].rxb) { mif_info("%s: ERR! %s rxbq_create_pool fail\n", ld->name, get_dev_name(i)); goto err; } mif_info("%s: %s rxbq_pool created (bsize:%d, qsize:%d)\n", ld->name, get_dev_name(i), bsize, qsize); } /* Prepare a multi-purpose miscellaneous buffer */ dpld->buff = kzalloc(dpld->dp_size, GFP_KERNEL); if (!dpld->buff) { mif_info("%s: ERR! kzalloc dpld->buff fail\n", ld->name); goto err; } /* Retrieve DPRAM IRQ GPIO# */ dpld->gpio_dpram_int = mdm_data->gpio_dpram_int; /* Retrieve DPRAM IRQ# */ if (!dpctl->dpram_irq) { dpctl->dpram_irq = platform_get_irq_byname(pdev, "dpram_irq"); if (dpctl->dpram_irq < 0) { mif_info("%s: ERR! platform_get_irq_byname fail\n", ld->name); goto err; } } dpld->irq = dpctl->dpram_irq; /* Retrieve DPRAM IRQ flags */ if (!dpctl->dpram_irq_flags) dpctl->dpram_irq_flags = (IRQF_NO_SUSPEND | IRQF_TRIGGER_LOW); dpld->irq_flags = dpctl->dpram_irq_flags; /* Register DPRAM interrupt handler */ snprintf(dpld->irq_name, DP_MAX_NAME_LEN, "%s_irq", ld->name); ret = dpram_register_isr(dpld->irq, dpram_irq_handler, dpld->irq_flags, dpld->irq_name, dpld); if (ret) goto err; return ld; err: if (dpld) { if (dpld->buff) kfree(dpld->buff); kfree(dpld); } return NULL; }
void mem_forced_cp_crash(struct mem_link_device *mld) { struct link_device *ld = &mld->link_dev; struct modem_ctl *mc = ld->mc; bool duplicated = false; unsigned long flags; /* Disable normal IPC */ set_magic(mld, MEM_CRASH_MAGIC); set_access(mld, 0); spin_lock_irqsave(&mld->lock, flags); if (atomic_read(&mc->forced_cp_crash)) duplicated = true; else atomic_set(&mc->forced_cp_crash, 1); spin_unlock_irqrestore(&mld->lock, flags); if (duplicated) { evt_log(0, "%s: %s: ALREADY in progress <%pf>\n", FUNC, ld->name, CALLER); return; } if (!cp_online(mc)) { evt_log(0, "%s: %s: %s.state %s != ONLINE <%pf>\n", FUNC, ld->name, mc->name, mc_state(mc), CALLER); return; } if (mc->wake_lock) { if (!wake_lock_active(mc->wake_lock)) { wake_lock(mc->wake_lock); mif_err("%s->wake_lock locked\n", mc->name); } } if (mld->attrs & LINK_ATTR(LINK_ATTR_MEM_DUMP)) { stop_net_ifaces(ld); if (mld->debug_info) mld->debug_info(); /** * If there is no CRASH_ACK from CP in a timeout, * handle_no_cp_crash_ack() will be executed. */ mif_add_timer(&mc->crash_ack_timer, FORCE_CRASH_ACK_TIMEOUT, handle_no_cp_crash_ack, (unsigned long)mld); /* Send CRASH_EXIT command to a CP */ send_ipc_irq(mld, cmd2int(CMD_CRASH_EXIT)); } else { modemctl_notify_event(MDM_EVENT_CP_FORCE_CRASH); } evt_log(0, "%s->%s: CP_CRASH_REQ <%pf>\n", ld->name, mc->name, CALLER); #ifdef DEBUG_MODEM_IF if (in_interrupt()) queue_work(system_nrt_wq, &mld->dump_work); else save_mem_dump(mld); #endif }