/* Threads starts here */ void *process_thread(void *param) { /* Process number */ int i = (int) (long) param, j; /* Allocate request vector */ int *request = malloc(n*sizeof(int)); while (1) { /* Generate request */ generate_request(i, request); while (!resource_request(i, request)) { /* Wait */ Sleep(100); } /* Generate release */ generate_release(i, request); /* Release resources */ resource_release(i, request); /* Wait */ Sleep(1000); } free(request); }
/* Threads starts here */ void *process_thread(void *param) { /* Process number */ int i = (int) (long) param, j; printf("PROC %d\n", i); /* Allocate request vector */ int *request = malloc(n*sizeof(int)); int q; for(q = 0; q < n; q++){ request[q] = 0; } int legal = 0; while (1) { /* Generate request */ generate_request(i, request); while (!resource_request(i, request)) { printf("%s\n", "Waiting"); /* Wait */ Sleep(1000); } /* Generate release */ generate_release(i, request); /* Release resources */ resource_release(i, request); /* Wait */ Sleep(1000); } free(request); }
void omap_pm_set_min_bus_tput(struct device *dev, u8 agent_id, unsigned long r) { #if 1 // Archer-Froyo, KERNEL PANIC in update_resource_level() after EnableSGXClocks() return; #endif // Archer-Froyo if (!dev || (agent_id != OCP_INITIATOR_AGENT && agent_id != OCP_TARGET_AGENT)) { WARN_ON(1); return; }; if (r == 0) { pr_debug("OMAP PM: remove min bus tput constraint: " "dev %s for agent_id %d\n", dev_name(dev), agent_id); resource_release("vdd2_opp", dev); } else { pr_debug("OMAP PM: add min bus tput constraint: " "dev %s for agent_id %d: rate %ld KiB\n", dev_name(dev), agent_id, r); resource_request("vdd2_opp", dev, r); } }
void task_i2c_get_temp_func(const struct task_item *task) { uint8_t temp[2]; int t_out, fract; /* * Wait in OS friendly way for request to run. */ if (!read_temp_enabled) { OS_EVENT_WAIT(event, OS_EVENT_FOREVER); } /* * Require I2C for exclusively reading temperature from FM75 and release it after operation. */ resource_acquire(RES_MASK(RES_ID_I2C1), RES_WAIT_FOREVER); set_target_address(FM75_ADDRESS); /* * Read actual temperature values from FM75. */ fm75_read_reg(FM75_REG_TEMP, temp, sizeof(temp)); resource_release(RES_MASK(RES_ID_I2C1)); /* * Send results to UART. */ t_out = convert_temp(temp, &fract); printf("current temperature: %d.%04d C" NEWLINE, t_out, fract); /* * Wait 1 second to get temperature again. */ OS_DELAY(1000); }
/** * resource_test_1 - Tests the resource framework basic APIs for * "opp/freq" resources * @res_name: Name of the resource requested * @req_lvl: Requested level for the resource * * Requests the "opp/freq" resource for the given level, * verifies if the resource's current level is same as the requested level * and releases the resource * * Returns 0 on success, -1 on failure */ static int resource_test_1(const char *res_name, unsigned long req_lvl) { int ret, cur_lvl, result = TEST_PASS; struct device dev; printk(KERN_INFO "Entry resource_test_1 \n"); if (!strcmp(res_name, "vdd2_opp")) ret = request_vdd2_opp(&dev, req_lvl); else ret = resource_request(res_name, &dev, req_lvl); if (ret) { printk(KERN_ERR "FAILED!!!! dev resource request for " "%s failed with value %d\n", res_name, ret); return TEST_FAIL; } cur_lvl = resource_get_level(res_name); if (cur_lvl != req_lvl) { printk(KERN_ERR "FAILED!!!! resource %s current level:%d" " req lvl:%d\n", res_name, cur_lvl, (int)req_lvl); result = TEST_FAIL; } ret = resource_release(res_name, &dev); if (ret) { printk(KERN_ERR "FAILED!!!! resource release for %s failed" " with value %d\n", res_name, ret); result = TEST_FAIL; } if (!result) printk(KERN_INFO "resource_test_1 PASSED for %s\n", res_name); return result; }
void menu_i2c_read_from_eeprom_func(const struct menu_item *m, bool checked) { size_t rd_status, wr_status; HW_I2C_ABORT_SOURCE abrt_src = HW_I2C_ABORT_NONE; uint8_t addr[2] = {0x00, 0x00}; static uint8_t read_buffer[65]; // 64 bytes of data + '\0' set_target_address(EEPROM_ADDRESS); /* * Acquire I2C resource and read data back from EEPROM and release it after operation. * Before reading data we need to set address from which reading will start. This is done * by writing two bytes indicating address in EEPROM before reading from it. I2C controller * will automatically generate proper write and read commands on I2C bus. */ resource_acquire(RES_MASK(RES_ID_I2C1), RES_WAIT_FOREVER); wr_status = hw_i2c_write_buffer_sync(HW_I2C1, addr, sizeof(addr), &abrt_src, HW_I2C_F_NONE); if ((wr_status < sizeof(addr)) || (abrt_src != HW_I2C_ABORT_NONE)) { printf("EEPROM address write during read failed: %u" NEWLINE, abrt_src); } else { rd_status = hw_i2c_read_buffer_sync(HW_I2C1, read_buffer, sizeof(read_buffer) - 1, &abrt_src, HW_I2C_F_NONE); /* * Print on UART what was read from EEPROM. */ if ((rd_status < sizeof(read_buffer)) || (abrt_src != HW_I2C_ABORT_NONE)) { printf("EEPROM read failure: %u" NEWLINE, abrt_src); } else { printf("read from EEPROM: %s" NEWLINE, read_buffer); } } resource_release(RES_MASK(RES_ID_I2C1)); }
/** * resource_test_7 - Tests the resource_refresh API * @res_name: Name of the resource requested ("vdd1_opp"/"vdd2_opp") * @req_lvl1: Requested lower level for the resource * @req_lvl2: Requested higher level for the resource * * Device 1 requests the resource for the given lower level, * locks the resource. Meanwhile device 2 requests the reource for a * higher level. * Verifies if the resource's current level is same as the requested * higher level after device 1 unlocks the resource * * Returns 0 on success, -1 on failure */ static int resource_test_7(const char *res_name, unsigned long req_lvl1, unsigned long req_lvl2) { int ret, cur_lvl, result = TEST_PASS; int lock_val; struct device dev1, dev2; printk(KERN_INFO "Entry resource_test_7 \n"); if (!strcmp(res_name, "vdd1_opp")) lock_val = VDD1_OPP; else if (!strcmp(res_name, "vdd2_opp")) lock_val = VDD2_OPP; else { printk(KERN_ERR "FAILED!!!! invalid resource name\n"); return TEST_FAIL; } ret = resource_request(res_name, &dev1, req_lvl1); if (ret) { printk(KERN_ERR "FAILED!!!! resource1 request for %s failed" " with value %d\n", res_name, ret); return TEST_FAIL; } cur_lvl = resource_get_level(res_name); if (cur_lvl != req_lvl1) { printk(KERN_ERR "FAILED!!!! resource %s current level:%d" " req lvl:%d\n", res_name, cur_lvl, (int)req_lvl1); result = TEST_FAIL; } if (result == TEST_PASS) { ret = resource_access_opp_lock(lock_val, 1); if (ret < 0) { printk(KERN_ERR "FAILED!!!! resource %s lock failed" " with value %d\n", res_name, ret); result = TEST_FAIL; } } if (result == TEST_PASS) { ret = resource_request(res_name, &dev2, req_lvl2); if (ret) { printk(KERN_ERR "FAILED!!!! resource2 request %s failed" " with value %d\n", res_name, ret); ret = resource_access_opp_lock(lock_val, -1); if (ret < 0) printk(KERN_ERR "FAILED!!!! resource unlock" "for %s failed\n", res_name); result = TEST_FAIL; } } if (result == TEST_PASS) { cur_lvl = resource_get_level(res_name); if (cur_lvl != req_lvl1) { printk(KERN_ERR "FAILED!!!! %s current level:%d" " req lvl:%d\n", res_name, cur_lvl, (int)req_lvl1); result = TEST_FAIL; } ret = resource_access_opp_lock(lock_val, -1); if (ret < 0) { printk(KERN_ERR "FAILED!!!! resource unlock %s failed" " with value %d\n", res_name, ret); result = TEST_FAIL; } ret = resource_refresh(); if (ret) { printk(KERN_ERR "FAILED!!!! resource refresh failed" " with value %d\n", ret); result = TEST_FAIL; } cur_lvl = resource_get_level(res_name); if (cur_lvl != req_lvl2) { printk(KERN_ERR "FAILED!!!! %s current level:%d" " req lvl:%d\n", res_name, cur_lvl, (int)req_lvl2); result = TEST_FAIL; } } ret = resource_release(res_name, &dev1); if (ret) { printk(KERN_ERR "FAILED!!!! resource1 release for %s failed" " with value %d\n", res_name, ret); result = TEST_FAIL; } ret = resource_release(res_name, &dev2); if (ret) { printk(KERN_ERR "FAILED!!!! resource2 release for %s failed" " with value %d\n", res_name, ret); result = TEST_FAIL; } if (!result) printk(KERN_INFO "resource_test_7 PASSED for %s\n", res_name); return result; }
/** * resource_test_6 - Tests resource framework APIs when four devices requests * the same "latency" resource for same or different levels * @res_name: Name of the resource requested * @req_lat1: Device 1 level requested for the resource * @req_lat2: Device 2 level requested for the resource * @req_lat4: Device 3 level requested for the resource * @req_lat4: Device 4 level requested for the resource * @ref_table: Pointer to the reference latency table for the given resource * * Four devices requests the "lat" resource for the specified levels, * verifies if the resource's current level is same as that of the * closest lower reference level to the lowest level requested among the * four devices and releases the resource * * Returns 0 on success, -1 on failure */ static int resource_test_6(const char *res_name, unsigned long req_lat1, unsigned long req_lat2, unsigned long req_lat3, unsigned long req_lat4, unsigned long *ref_table) { int ret, result = TEST_PASS, i; struct device dev1, dev2, dev3, dev4; int cur_lvl, req_lat; printk(KERN_INFO "Entry resource_test_6 \n"); ret = resource_request(res_name, &dev1, req_lat1); if (ret) { printk(KERN_ERR "FAILED!!!! dev1 resource request for %s failed" " with value %d\n", res_name, ret); return TEST_FAIL; } ret = resource_request(res_name, &dev2, req_lat2); if (ret) { printk(KERN_ERR "FAILED!!!! dev2 resource request for %s failed" " with value %d\n", res_name, ret); resource_release(res_name, &dev1); return TEST_FAIL; } ret = resource_request(res_name, &dev3, req_lat3); if (ret) { printk(KERN_ERR "FAILED!!!! dev3 resource request for %s failed" " with value %d\n", res_name, ret); resource_release(res_name, &dev1); resource_release(res_name, &dev2); return TEST_FAIL; } ret = resource_request(res_name, &dev4, req_lat4); if (ret) { printk(KERN_ERR "FAILED!!!! dev4 resource request for %s failed" " with value %d\n", res_name, ret); resource_release(res_name, &dev1); resource_release(res_name, &dev2); resource_release(res_name, &dev3); return TEST_FAIL; } cur_lvl = resource_get_level(res_name); req_lat = (int)min_level_1(req_lat1, req_lat2, req_lat3, req_lat4); /* using the ref table to find the appropriate PD state */ for (i = 0; i < 3; i++) { if (ref_table[i] < req_lat) break; } if (!enable_off_mode && i == PD_LATENCY_OFF) i = PD_LATENCY_RET; /* Inactive state is not being tested */ else if (i == 2) i = PD_LATENCY_ON; if (cur_lvl != i) { printk(KERN_ERR "FAILED!!!! resource %s current level:%d" " req lvl:%d\n", res_name, cur_lvl, i); result = TEST_FAIL; } ret = resource_release(res_name, &dev1); if (ret) { printk(KERN_ERR "FAILED!!!! dev1 resource release for %s failed" " with value %d\n", res_name, ret); result = TEST_FAIL; } ret = resource_release(res_name, &dev2); if (ret) { printk(KERN_ERR "FAILED!!!! dev2 resource release for %s failed" " with value %d\n", res_name, ret); result = TEST_FAIL; } ret = resource_release(res_name, &dev3); if (ret) { printk(KERN_ERR "FAILED!!!! dev3 resource release for %s failed" " with value %d\n", res_name, ret); result = TEST_FAIL; } ret = resource_release(res_name, &dev4); if (ret) { printk(KERN_ERR "FAILED!!!! dev4 resource release for %s failed" " with value %d\n", res_name, ret); result = TEST_FAIL; } if (!result) printk(KERN_INFO "resource_test_6 PASSED for %s\n", res_name); return result; }
/** * resource_test_3 - Tests resource framework APIs when three devices requests * the same "opp/freq" resource for same or different levels * @res_name: Name of the resource requested * @req_lvl1: Device 1 level requested for the resource * @req_lvl2: Device 2 level requested for the resource * @req_lvl3: Device 3 level requested for the resource * * Three devices requests the "opp/freq" resource for the specified levels, * verifies if the resource's current level is same as the maximum of * requested levels and releases the resource * * Returns 0 on success, -1 on failure */ static int resource_test_3(const char *res_name, unsigned long req_lvl1, unsigned long req_lvl2, unsigned long req_lvl3) { int ret, result = TEST_PASS; int cur_lvl, req_lvl; struct device dev1, dev2, dev3; printk(KERN_INFO "Entry resource_test_3 \n"); if (!strcmp(res_name, "vdd2_opp")) ret = request_vdd2_opp(&dev1, req_lvl1); else ret = resource_request(res_name, &dev1, req_lvl1); if (ret) { printk(KERN_ERR "FAILED!!!! dev1 resource request for %s failed" " with value %d\n", res_name, ret); return TEST_FAIL; } if (!strcmp(res_name, "vdd2_opp")) ret = request_vdd2_opp(&dev2, req_lvl2); else ret = resource_request(res_name, &dev2, req_lvl2); if (ret) { printk(KERN_ERR "FAILED!!!! dev2 resource request for %s failed" " with value %d\n", res_name, ret); resource_release(res_name, &dev1); return TEST_FAIL; } if (!strcmp(res_name, "vdd2_opp")) ret = request_vdd2_opp(&dev3, req_lvl3); else ret = resource_request(res_name, &dev3, req_lvl3); if (ret) { printk(KERN_ERR "FAILED!!!! dev3 resource request for %s failed" " with value %d\n", res_name, ret); resource_release(res_name, &dev1); resource_release(res_name, &dev2); return TEST_FAIL; } cur_lvl = resource_get_level(res_name); req_lvl = (int) max_level_1(req_lvl1, req_lvl2, req_lvl3); if (cur_lvl != req_lvl) { printk(KERN_ERR "FAILED!!!! resource %s current level:%d" " req lvl:%d\n", res_name, cur_lvl, req_lvl); result = TEST_FAIL; } ret = resource_release(res_name, &dev1); if (ret) { printk(KERN_ERR "FAILED!!!! dev1 resource release for %s failed" " with value %d\n", res_name, ret); result = TEST_FAIL; } ret = resource_release(res_name, &dev2); if (ret) { printk(KERN_ERR "FAILED!!!! dev2 resource release for %s failed" " with value %d\n", res_name, ret); result = TEST_FAIL; } ret = resource_release(res_name, &dev3); if (ret) { printk(KERN_ERR "FAILED!!!! dev3 resource release for %s failed" " with value %d\n", res_name, ret); result = TEST_FAIL; } if (!result) printk(KERN_INFO "resource_test_3 PASSED for %s\n", res_name); return result; }
JNIEXPORT void JNICALL Java_quickeye_JNI_1QuickEye_free_1jni (JNIEnv *, jclass){ resource_release(); }
static int hsmmc_set_power(struct device *dev, int slot, int power_on, int vdd) { u32 vdd_sel = 0, devconf = 0, reg = 0; int ret = 0; /* REVISIT: Using address directly till the control.h defines * are settled. */ #if defined(CONFIG_ARCH_OMAP2430) #define OMAP2_CONTROL_PBIAS 0x490024A0 #else #define OMAP2_CONTROL_PBIAS 0x48002520 #endif if (power_on) { if (cpu_is_omap24xx()) devconf = omap_readl(OMAP2_CONTROL_DEVCONF1); else devconf = omap_readl(OMAP3_CONTROL_DEVCONF0); switch (1 << vdd) { case MMC_VDD_33_34: case MMC_VDD_32_33: vdd_sel = VSEL_3V; if (cpu_is_omap24xx()) devconf |= OMAP2_CONTROL_DEVCONF1_ACTOV; break; case MMC_VDD_165_195: vdd_sel = VSEL_18V; if (cpu_is_omap24xx()) devconf &= ~OMAP2_CONTROL_DEVCONF1_ACTOV; } if (cpu_is_omap24xx()) omap_writel(devconf, OMAP2_CONTROL_DEVCONF1); else omap_writel(devconf | OMAP2_CONTROL_DEVCONF0_LBCLK, OMAP3_CONTROL_DEVCONF0); reg = omap_readl(OMAP2_CONTROL_PBIAS); reg |= OMAP2_CONTROL_PBIAS_SCTRL; omap_writel(reg, OMAP2_CONTROL_PBIAS); reg = omap_readl(OMAP2_CONTROL_PBIAS); reg &= ~OMAP2_CONTROL_PBIAS_PWRDNZ; omap_writel(reg, OMAP2_CONTROL_PBIAS); reg = omap_readl(OMAP2_CONTROL_PBIAS); reg |= OMAP2_CONTROL_PBIAS_SCTRL1; omap_writel(reg, OMAP2_CONTROL_PBIAS); reg = omap_readl(OMAP2_CONTROL_PBIAS); reg &= ~OMAP2_CONTROL_PBIAS_PWRDNZ1; omap_writel(reg, OMAP2_CONTROL_PBIAS); ret = resource_request(rhandlemmc1, (vdd_sel == VSEL_3V ? T2_VMMC1_3V00 : T2_VMMC1_1V85)); if (ret != 0) goto err; /* Enable VSIM to support MMC 8-bit on ES2 */ if (is_sil_rev_greater_than(OMAP3430_REV_ES1_0)) { ret = resource_request(rhandlevsim, (vdd_sel == VSEL_3V ? T2_VSIM_3V00 : T2_VSIM_1V80)); if (ret != 0) return ret; } msleep(100); reg = omap_readl(OMAP2_CONTROL_PBIAS); reg = (vdd_sel == VSEL_18V) ? (((reg | 0x0606) & ~0x1) & ~(1<<8)) : (reg | 0x0707); omap_writel(reg, OMAP2_CONTROL_PBIAS); return ret; } else { /* Power OFF */ /* For MMC1, Toggle PBIAS before every power up sequence */ reg = omap_readl(OMAP2_CONTROL_PBIAS); reg &= ~OMAP2_CONTROL_PBIAS_PWRDNZ; omap_writel(reg, OMAP2_CONTROL_PBIAS); if (rhandlemmc1 != NULL) { ret = resource_release(rhandlemmc1); if (ret != 0) goto err; } if (is_sil_rev_greater_than(OMAP3430_REV_ES1_0) && (rhandlevsim != NULL)) { ret = resource_release(rhandlevsim); if (ret != 0) goto err; } if (is_sil_rev_equal_to(OMAP3430_REV_ES3_0)) { ret = twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, LDO_CLR, VSIM_DEV_GRP); if (ret) goto err; ret = twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, LDO_CLR, VSIM_DEDICATED); if (ret) goto err; } /* 100ms delay required for PBIAS configuration */ msleep(100); reg = omap_readl(OMAP2_CONTROL_PBIAS); reg |= (OMAP2_CONTROL_PBIAS_VMODE | OMAP2_CONTROL_PBIAS_VMODE1 | OMAP2_CONTROL_PBIAS_PWRDNZ | OMAP2_CONTROL_PBIAS_PWRDNZ1 | OMAP2_CONTROL_PBIAS_SCTRL | OMAP2_CONTROL_PBIAS_SCTRL1); omap_writel(reg, OMAP2_CONTROL_PBIAS); } return 0; err: return 1; }