本文整理汇总了C++中pr_warn函数的典型用法代码示例。如果您正苦于以下问题:C++ pr_warn函数的具体用法?C++ pr_warn怎么用?C++ pr_warn使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了pr_warn函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: rxe_qp_from_attr
//.........这里部分代码省略.........
qp->attr.path_mtu = attr->path_mtu;
qp->mtu = ib_mtu_enum_to_int(attr->path_mtu);
}
if (mask & IB_QP_TIMEOUT) {
qp->attr.timeout = attr->timeout;
if (attr->timeout == 0) {
qp->qp_timeout_jiffies = 0;
} else {
/* According to the spec, timeout = 4.096 * 2 ^ attr->timeout [us] */
int j = nsecs_to_jiffies(4096ULL << attr->timeout);
qp->qp_timeout_jiffies = j ? j : 1;
}
}
if (mask & IB_QP_RETRY_CNT) {
qp->attr.retry_cnt = attr->retry_cnt;
qp->comp.retry_cnt = attr->retry_cnt;
pr_debug("qp#%d set retry count = %d\n", qp_num(qp),
attr->retry_cnt);
}
if (mask & IB_QP_RNR_RETRY) {
qp->attr.rnr_retry = attr->rnr_retry;
qp->comp.rnr_retry = attr->rnr_retry;
pr_debug("qp#%d set rnr retry count = %d\n", qp_num(qp),
attr->rnr_retry);
}
if (mask & IB_QP_RQ_PSN) {
qp->attr.rq_psn = (attr->rq_psn & BTH_PSN_MASK);
qp->resp.psn = qp->attr.rq_psn;
pr_debug("qp#%d set resp psn = 0x%x\n", qp_num(qp),
qp->resp.psn);
}
if (mask & IB_QP_MIN_RNR_TIMER) {
qp->attr.min_rnr_timer = attr->min_rnr_timer;
pr_debug("qp#%d set min rnr timer = 0x%x\n", qp_num(qp),
attr->min_rnr_timer);
}
if (mask & IB_QP_SQ_PSN) {
qp->attr.sq_psn = (attr->sq_psn & BTH_PSN_MASK);
qp->req.psn = qp->attr.sq_psn;
qp->comp.psn = qp->attr.sq_psn;
pr_debug("qp#%d set req psn = 0x%x\n", qp_num(qp), qp->req.psn);
}
if (mask & IB_QP_PATH_MIG_STATE)
qp->attr.path_mig_state = attr->path_mig_state;
if (mask & IB_QP_DEST_QPN)
qp->attr.dest_qp_num = attr->dest_qp_num;
if (mask & IB_QP_STATE) {
qp->attr.qp_state = attr->qp_state;
switch (attr->qp_state) {
case IB_QPS_RESET:
pr_debug("qp#%d state -> RESET\n", qp_num(qp));
rxe_qp_reset(qp);
break;
case IB_QPS_INIT:
pr_debug("qp#%d state -> INIT\n", qp_num(qp));
qp->req.state = QP_STATE_INIT;
qp->resp.state = QP_STATE_INIT;
break;
case IB_QPS_RTR:
pr_debug("qp#%d state -> RTR\n", qp_num(qp));
qp->resp.state = QP_STATE_READY;
break;
case IB_QPS_RTS:
pr_debug("qp#%d state -> RTS\n", qp_num(qp));
qp->req.state = QP_STATE_READY;
break;
case IB_QPS_SQD:
pr_debug("qp#%d state -> SQD\n", qp_num(qp));
rxe_qp_drain(qp);
break;
case IB_QPS_SQE:
pr_warn("qp#%d state -> SQE !!?\n", qp_num(qp));
/* Not possible from modify_qp. */
break;
case IB_QPS_ERR:
pr_debug("qp#%d state -> ERR\n", qp_num(qp));
rxe_qp_error(qp);
break;
}
}
return 0;
}
示例2: dbbt_check
/**
* dbbt_check - Check if DBBT is readable and consistent to the mtd BBT
* @mtd: The mtd Nand device
* @dbbt: The page where the DBBT is found
*
* This function checks if the DBBT is readable and consistent to the mtd
* layers idea of bad blocks.
*
* return: 0 if the DBBT is readable and consistent to the mtd BBT, a
* negative error code otherwise.
*/
static int dbbt_check(struct mtd_info *mtd, int page)
{
int ret, needs_cleanup = 0;
size_t r;
void *dbbt_header;
void *dbbt_entries = NULL;
struct dbbt_block *dbbt;
int num_blocks = mtd_div_by_eb(mtd->size, mtd);
int n;
dbbt_header = xmalloc(mtd->writesize);
ret = mtd_read(mtd, page * mtd->writesize, mtd->writesize, &r, dbbt_header);
if (ret == -EUCLEAN) {
pr_warn("page %d needs cleaning\n", page);
needs_cleanup = 1;
} else if (ret < 0) {
pr_err("Cannot read page %d: %s\n", page, strerror(-ret));
goto out;
}
dbbt = dbbt_header;
if (dbbt->FingerPrint != 0x54424244) {
pr_err("dbbt at page %d is readable but does not contain a valid DBBT\n",
page);
ret = -EINVAL;
goto out;
}
if (dbbt->DBBTNumOfPages) {
dbbt_entries = xmalloc(mtd->writesize);
ret = mtd_read(mtd, (page + 4) * mtd->writesize, mtd->writesize, &r, dbbt_entries);
if (ret == -EUCLEAN) {
pr_warn("page %d needs cleaning\n", page);
needs_cleanup = 1;
} else if (ret < 0) {
pr_err("Cannot read page %d: %s\n", page, strerror(-ret));
goto out;
}
} else {
dbbt_entries = NULL;
}
for (n = 0; n < num_blocks; n++) {
if (mtd_peb_is_bad(mtd, n) != dbbt_block_is_bad(dbbt_entries, n)) {
ret = -EINVAL;
goto out;
}
}
ret = 0;
out:
free(dbbt_header);
free(dbbt_entries);
if (ret < 0)
return ret;
if (needs_cleanup)
return -EUCLEAN;
return 0;
}
示例3: read_firmware_all
static void read_firmware_all(struct mtd_info *mtd, struct fcb_block *fcb, void **data, int *len,
int *used_refresh, int *unused_refresh, int *used)
{
void *primary = NULL, *secondary = NULL;
int pages_per_block = mtd->erasesize / mtd->writesize;
int fw0 = imx_bbu_firmware_start_block(mtd, 0) * pages_per_block;
int fw1 = imx_bbu_firmware_start_block(mtd, 1) * pages_per_block;
int first, ret, primary_refresh = 0, secondary_refresh = 0;
*used_refresh = 0;
*unused_refresh = 0;
if (fcb->Firmware1_startingPage == fw0 &&
fcb->Firmware2_startingPage == fw1) {
first = 0;
} else if (fcb->Firmware1_startingPage == fw1 &&
fcb->Firmware2_startingPage == fw0) {
first = 1;
} else {
pr_warn("FCB is not what we expect. Update will not be robust\n");
*used = 0;
return;
}
if (fcb->PagesInFirmware1 != fcb->PagesInFirmware2) {
pr_warn("FCB is not what we expect. Update will not be robust\n");
return;
}
*len = fcb->PagesInFirmware1 * mtd->writesize;
ret = read_firmware(mtd, fcb->Firmware1_startingPage, fcb->PagesInFirmware1, &primary);
if (ret > 0)
primary_refresh = 1;
ret = read_firmware(mtd, fcb->Firmware2_startingPage, fcb->PagesInFirmware2, &secondary);
if (ret > 0)
secondary_refresh = 1;
if (!primary && !secondary) {
*unused_refresh = 1;
*used_refresh = 1;
*used = 0;
*data = NULL;
} else if (primary && !secondary) {
*used_refresh = primary_refresh;
*unused_refresh = 1;
*used = first;
*data = primary;
return;
} else if (secondary && !primary) {
*used_refresh = secondary_refresh;
*unused_refresh = 1;
*used = !first;
*data = secondary;
} else {
if (memcmp(primary, secondary, fcb->PagesInFirmware1 * mtd->writesize))
*unused_refresh = 1;
*used_refresh = primary_refresh;
*used = first;
*data = primary;
free(secondary);
}
pr_info("Primary firmware is on pages %d-%d, %svalid, %s\n", fcb->Firmware1_startingPage,
fcb->Firmware1_startingPage + fcb->PagesInFirmware1, primary ? "" : "in",
primary_refresh ? "needs cleanup" : "clean");
pr_info("secondary firmware is on pages %d-%d, %svalid, %s\n", fcb->Firmware2_startingPage,
fcb->Firmware2_startingPage + fcb->PagesInFirmware2, secondary ? "" : "in",
secondary_refresh ? "needs cleanup" : "clean");
pr_info("ROM uses slot %d\n", *used);
}
示例4: cps_pm_init
static int __init cps_pm_init(void)
{
unsigned cpu;
int err;
/* Detect appropriate sync types for the system */
switch (current_cpu_data.cputype) {
case CPU_INTERAPTIV:
case CPU_PROAPTIV:
case CPU_M5150:
case CPU_P5600:
stype_intervention = 0x2;
stype_memory = 0x3;
stype_ordering = 0x10;
break;
default:
pr_warn("Power management is using heavyweight sync 0\n");
}
/* A CM is required for all non-coherent states */
if (!mips_cm_present()) {
pr_warn("pm-cps: no CM, non-coherent states unavailable\n");
goto out;
}
/*
* If interrupts were enabled whilst running a wait instruction on a
* non-coherent core then the VPE may end up processing interrupts
* whilst non-coherent. That would be bad.
*/
if (cpu_wait == r4k_wait_irqoff)
set_bit(CPS_PM_NC_WAIT, state_support);
else
pr_warn("pm-cps: non-coherent wait unavailable\n");
/* Detect whether a CPC is present */
if (mips_cpc_present()) {
/* Detect whether clock gating is implemented */
if (read_cpc_cl_stat_conf() & CPC_Cx_STAT_CONF_CLKGAT_IMPL_MSK)
set_bit(CPS_PM_CLOCK_GATED, state_support);
else
pr_warn("pm-cps: CPC does not support clock gating\n");
/* Power gating is available with CPS SMP & any CPC */
if (mips_cps_smp_in_use())
set_bit(CPS_PM_POWER_GATED, state_support);
else
pr_warn("pm-cps: CPS SMP not in use, power gating unavailable\n");
} else {
pr_warn("pm-cps: no CPC, clock & power gating unavailable\n");
}
for_each_present_cpu(cpu) {
err = cps_gen_core_entries(cpu);
if (err)
return err;
}
out:
return 0;
}
示例5: ak8963c_selftest
static int ak8963c_selftest(struct ak8963c_p *data, int *sf)
{
u8 temp[6], reg;
s16 x, y, z;
int retry_count = 0;
int ready_count = 0;
int ret;
retry:
mutex_lock(&data->lock);
/* power down */
reg = AK8963C_CNTL1_POWER_DOWN;
ak8963c_smbus_write_byte(data->client, AK8963C_REG_CNTL1, ®);
/* read device info */
ak8963c_smbus_read_byte_block(data->client, AK8963C_REG_WIA, temp, 2);
pr_info("[SENSOR]: %s - device id = 0x%x, info = 0x%x\n",
__func__, temp[0], temp[1]);
/* set ATSC self test bit to 1 */
reg = 0x40;
ak8963c_smbus_write_byte(data->client, AK8963C_REG_ASTC, ®);
/* start self test */
reg = AK8963C_CNTL1_SELF_TEST;
ak8963c_smbus_write_byte(data->client, AK8963C_REG_CNTL1, ®);
/* wait for data ready */
while (ready_count < 10) {
msleep(20);
ret = ak8963c_smbus_read_byte(data->client,
AK8963C_REG_ST1, ®);
if ((reg == 1) && (ret == 0))
break;
ready_count++;
}
ak8963c_smbus_read_byte_block(data->client, AK8963C_REG_HXL,
temp, sizeof(temp));
/* set ATSC self test bit to 0 */
reg = 0x00;
ak8963c_smbus_write_byte(data->client, AK8963C_REG_ASTC, ®);
mutex_unlock(&data->lock);
x = temp[0] | (temp[1] << 8);
y = temp[2] | (temp[3] << 8);
z = temp[4] | (temp[5] << 8);
/* Hadj = (H*(Asa+128))/256 */
x = (x * (data->asa[0] + 128)) >> 8;
y = (y * (data->asa[1] + 128)) >> 8;
z = (z * (data->asa[2] + 128)) >> 8;
pr_info("[SENSOR]: %s - self test x = %d, y = %d, z = %d\n",
__func__, x, y, z);
if ((x >= -200) && (x <= 200))
pr_info("[SENSOR]: %s - x passed self test, -200<=x<=200\n",
__func__);
else
pr_info("[SENSOR]: %s - x failed self test, -200<=x<=200\n",
__func__);
if ((y >= -200) && (y <= 200))
pr_info("[SENSOR]: %s - y passed self test, -200<=y<=200\n",
__func__);
else
pr_info("[SENSOR]: %s - y failed self test, -200<=y<=200\n",
__func__);
if ((z >= -3200) && (z <= -800))
pr_info("[SENSOR]: %s - z passed self test, -3200<=z<=-800\n",
__func__);
else
pr_info("[SENSOR]: %s - z failed self test, -3200<=z<=-800\n",
__func__);
sf[0] = x;
sf[1] = y;
sf[2] = z;
if (((x >= -200) && (x <= 200)) &&
((y >= -200) && (y <= 200)) &&
((z >= -3200) && (z <= -800))) {
pr_info("%s, Selftest is successful.\n", __func__);
return 1;
} else {
if (retry_count < 5) {
retry_count++;
pr_warn("############################################");
pr_warn("%s, retry_count=%d\n", __func__, retry_count);
pr_warn("############################################");
goto retry;
} else {
pr_err("[SENSOR]: %s - Selftest is failed.\n",
__func__);
return 0;
}
}
}
示例6: max14577_muic_detect_dev
static void max14577_muic_detect_dev(struct max14577_muic_data *muic_data, int irq)
{
struct i2c_client *i2c = muic_data->i2c;
const struct max14577_muic_vps_data *tmp_vps;
enum muic_attached_dev new_dev = ATTACHED_DEV_UNKNOWN_MUIC;
int intr = MUIC_INTR_DETACH;
u8 status[2], ctrl2, ctrl3;
u8 adcerr, adclow, adc, vbvolt, chgdetrun, chgtyp, adcen;
int ret;
int i;
ret = max14577_bulk_read(i2c, MAX14577_MUIC_REG_STATUS1, 2, status);
if (ret) {
pr_err("%s:%s fail to read STAT (%d)\n", MUIC_DEV_NAME, __func__, ret);
return;
}
ret = max14577_read_reg(muic_data->i2c, MAX14577_REG_CONTROL2, &ctrl2);
if (ret) {
pr_err("%s:%s fail to read CTRL2 (%d)\n", MUIC_DEV_NAME, __func__, ret);
return;
}
ret = max14577_read_reg(muic_data->i2c, MAX14577_MUIC_REG_CONTROL3, &ctrl3);
if (ret) {
pr_err("%s:%s fail to read CTRL3 (%d)\n", MUIC_DEV_NAME, __func__, ret);
return;
}
pr_info("%s:%s STATUS1:0x%02x, 2:0x%02x, ctrl2:0x%02x\n", MUIC_DEV_NAME,
__func__, status[0], status[1], ctrl2);
adcerr = status[0] & STATUS1_ADCERR_MASK;
adclow = status[0] & STATUS1_ADCLOW_MASK;
adc = status[0] & STATUS1_ADC_MASK;
vbvolt = status[1] & STATUS2_VBVOLT_MASK;
chgdetrun = status[1] & STATUS2_CHGDETRUN_MASK;
chgtyp = status[1] & STATUS2_CHGTYP_MASK;
adcen = ctrl2 & CTRL2_ADCEN_MASK;
pr_info("%s:%s adcerr:0x%x adclow:0x%x adc:0x%x vb:0x%x chgdetrun:0x%x"
" chgtyp:0x%x adcen:0x%x\n", MUIC_DEV_NAME, __func__, adcerr,
adclow, adc, vbvolt, chgdetrun, chgtyp, adcen);
/* Workaround for Factory mode.
* Abandon adc interrupt of approximately +-100K range
* if previous cable status was JIG UART BOOT OFF.
*/
if (muic_data->attached_dev == ATTACHED_DEV_JIG_UART_OFF_MUIC) {
if ((adc == (ADC_JIG_UART_OFF + 1)) ||
(adc == (ADC_JIG_UART_OFF - 1))) {
pr_warn("%s:%s abandon ADC\n", MUIC_DEV_NAME, __func__);
return;
}
}
for (i = 0; i < ARRAY_SIZE(muic_vps_table); i++) {
tmp_vps = &(muic_vps_table[i]);
if (tmp_vps->adcerr != adcerr)
continue;
if (tmp_vps->adclow != adclow)
continue;
if (tmp_vps->adc != adc)
continue;
if (tmp_vps->vbvolt != vbvolt)
continue;
if (tmp_vps->chgdetrun != chgdetrun)
continue;
if (tmp_vps->chgtyp != chgtyp)
continue;
pr_info("%s:%s vps table match found at i(%d), %s\n",
MUIC_DEV_NAME, __func__, i, tmp_vps->vps_name);
new_dev = tmp_vps->attached_dev;
intr = MUIC_INTR_ATTACH;
break;
}
if (intr == MUIC_INTR_ATTACH) {
pr_info("%s:%s ATTACHED\n", MUIC_DEV_NAME, __func__);
max14577_muic_handle_attach(muic_data, new_dev);
} else {
pr_info("%s:%s DETACHED\n", MUIC_DEV_NAME, __func__);
max14577_muic_handle_detach(muic_data);
}
return;
}
示例7: rfkill_gpio_probe
static int rfkill_gpio_probe(struct platform_device *pdev)
{
struct rfkill_gpio_data *rfkill;
struct rfkill_gpio_platform_data *pdata = pdev->dev.platform_data;
int ret = 0;
int len = 0;
if (!pdata) {
pr_warn("%s: No platform data specified\n", __func__);
return -EINVAL;
}
/*
*/
if (!pdata->name || (!gpio_is_valid(pdata->reset_gpio) &&
!gpio_is_valid(pdata->shutdown_gpio))) {
pr_warn("%s: invalid platform data\n", __func__);
return -EINVAL;
}
rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL);
if (!rfkill)
return -ENOMEM;
if (pdata->gpio_runtime_setup) {
ret = pdata->gpio_runtime_setup(pdev);
if (ret) {
pr_warn("%s: can't set up gpio\n", __func__);
goto fail_alloc;
}
}
rfkill->pdata = pdata;
len = strlen(pdata->name);
rfkill->reset_name = kzalloc(len + 7, GFP_KERNEL);
if (!rfkill->reset_name) {
ret = -ENOMEM;
goto fail_alloc;
}
rfkill->shutdown_name = kzalloc(len + 10, GFP_KERNEL);
if (!rfkill->shutdown_name) {
ret = -ENOMEM;
goto fail_reset_name;
}
snprintf(rfkill->reset_name, len + 6 , "%s_reset", pdata->name);
snprintf(rfkill->shutdown_name, len + 9, "%s_shutdown", pdata->name);
if (pdata->power_clk_name) {
rfkill->pwr_clk = clk_get(&pdev->dev, pdata->power_clk_name);
if (IS_ERR(rfkill->pwr_clk)) {
pr_warn("%s: can't find pwr_clk.\n", __func__);
goto fail_shutdown_name;
}
}
if (gpio_is_valid(pdata->reset_gpio)) {
ret = gpio_request(pdata->reset_gpio, rfkill->reset_name);
if (ret) {
pr_warn("%s: failed to get reset gpio.\n", __func__);
goto fail_clock;
}
}
if (gpio_is_valid(pdata->shutdown_gpio)) {
ret = gpio_request(pdata->shutdown_gpio, rfkill->shutdown_name);
if (ret) {
pr_warn("%s: failed to get shutdown gpio.\n", __func__);
goto fail_reset;
}
}
rfkill->rfkill_dev = rfkill_alloc(pdata->name, &pdev->dev, pdata->type,
&rfkill_gpio_ops, rfkill);
if (!rfkill->rfkill_dev)
goto fail_shutdown;
ret = rfkill_register(rfkill->rfkill_dev);
if (ret < 0)
goto fail_rfkill;
platform_set_drvdata(pdev, rfkill);
dev_info(&pdev->dev, "%s device registered.\n", pdata->name);
return 0;
fail_rfkill:
rfkill_destroy(rfkill->rfkill_dev);
fail_shutdown:
if (gpio_is_valid(pdata->shutdown_gpio))
gpio_free(pdata->shutdown_gpio);
fail_reset:
if (gpio_is_valid(pdata->reset_gpio))
gpio_free(pdata->reset_gpio);
fail_clock:
if (rfkill->pwr_clk)
clk_put(rfkill->pwr_clk);
//.........这里部分代码省略.........
示例8: jffs2_scan_eraseblock
//.........这里部分代码省略.........
return BLK_STATE_CLEANMARKER; /* don't bother with re-erase */
else
return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */
}
if (ofs) {
jffs2_dbg(1, "Free space at %08x ends at %08x\n", jeb->offset,
jeb->offset + ofs);
if ((err = jffs2_prealloc_raw_node_refs(c, jeb, 1)))
return err;
if ((err = jffs2_scan_dirty_space(c, jeb, ofs)))
return err;
}
/* Now ofs is a complete physical flash offset as it always was... */
ofs += jeb->offset;
noise = 10;
dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb->offset);
scan_more:
while(ofs < jeb->offset + c->sector_size) {
jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
/* Make sure there are node refs available for use */
err = jffs2_prealloc_raw_node_refs(c, jeb, 2);
if (err)
return err;
cond_resched();
if (ofs & 3) {
pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs);
ofs = PAD(ofs);
continue;
}
if (ofs == prevofs) {
pr_warn("ofs 0x%08x has already been seen. Skipping\n",
ofs);
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
return err;
ofs += 4;
continue;
}
prevofs = ofs;
if (jeb->offset + c->sector_size < ofs + sizeof(*node)) {
jffs2_dbg(1, "Fewer than %zd bytes left to end of block. (%x+%x<%x+%zx) Not reading\n",
sizeof(struct jffs2_unknown_node),
jeb->offset, c->sector_size, ofs,
sizeof(*node));
if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs)))
return err;
break;
}
if (buf_ofs + buf_len < ofs + sizeof(*node)) {
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
jffs2_dbg(1, "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n",
sizeof(struct jffs2_unknown_node),
buf_len, ofs);
err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
if (err)
return err;
buf_ofs = ofs;
示例9: jffs2_scan_medium
//.........这里部分代码省略.........
}
break;
case BLK_STATE_CLEAN:
/* Full (or almost full) of clean data. Clean list */
list_add(&jeb->list, &c->clean_list);
break;
case BLK_STATE_PARTDIRTY:
/* Some data, but not full. Dirty list. */
/* We want to remember the block with most free space
and stick it in the 'nextblock' position to start writing to it. */
if (jeb->free_size > min_free(c) &&
(!c->nextblock || c->nextblock->free_size < jeb->free_size)) {
/* Better candidate for the next writes to go to */
if (c->nextblock) {
ret = file_dirty(c, c->nextblock);
if (ret)
goto out;
/* deleting summary information of the old nextblock */
jffs2_sum_reset_collected(c->summary);
}
/* update collected summary information for the current nextblock */
jffs2_sum_move_collected(c, s);
jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n",
__func__, jeb->offset);
c->nextblock = jeb;
} else {
ret = file_dirty(c, jeb);
if (ret)
goto out;
}
break;
case BLK_STATE_ALLDIRTY:
/* Nothing valid - not even a clean marker. Needs erasing. */
/* For now we just put it on the erasing list. We'll start the erases later */
jffs2_dbg(1, "Erase block at 0x%08x is not formatted. It will be erased\n",
jeb->offset);
list_add(&jeb->list, &c->erase_pending_list);
c->nr_erasing_blocks++;
break;
case BLK_STATE_BADBLOCK:
jffs2_dbg(1, "Block at 0x%08x is bad\n", jeb->offset);
list_add(&jeb->list, &c->bad_list);
c->bad_size += c->sector_size;
c->free_size -= c->sector_size;
bad_blocks++;
break;
default:
pr_warn("%s(): unknown block state\n", __func__);
BUG();
}
}
/* Nextblock dirty is always seen as wasted, because we cannot recycle it now */
if (c->nextblock && (c->nextblock->dirty_size)) {
c->nextblock->wasted_size += c->nextblock->dirty_size;
c->wasted_size += c->nextblock->dirty_size;
c->dirty_size -= c->nextblock->dirty_size;
c->nextblock->dirty_size = 0;
}
#ifdef CONFIG_JFFS2_FS_WRITEBUFFER
if (!jffs2_can_mark_obsolete(c) && c->wbuf_pagesize && c->nextblock && (c->nextblock->free_size % c->wbuf_pagesize)) {
/* If we're going to start writing into a block which already
contains data, and the end of the data isn't page-aligned,
skip a little and align it. */
uint32_t skip = c->nextblock->free_size % c->wbuf_pagesize;
jffs2_dbg(1, "%s(): Skipping %d bytes in nextblock to ensure page alignment\n",
__func__, skip);
jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
jffs2_scan_dirty_space(c, c->nextblock, skip);
}
#endif
if (c->nr_erasing_blocks) {
if ( !c->used_size && ((c->nr_free_blocks+empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) {
pr_notice("Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n");
pr_notice("empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",
empty_blocks, bad_blocks, c->nr_blocks);
ret = -EIO;
goto out;
}
spin_lock(&c->erase_completion_lock);
jffs2_garbage_collect_trigger(c);
spin_unlock(&c->erase_completion_lock);
}
ret = 0;
out:
if (buf_size)
kfree(flashbuf);
#ifndef __ECOS
else
mtd_unpoint(c->mtd, 0, c->mtd->size);
#endif
kfree(s);
return ret;
}
示例10: check_s32c1i
/* This condition should not occur with a commercially deployed processor.
Display reminder for early engr test or demo chips / FPGA bitstreams */
static int __init check_s32c1i(void)
{
pr_warn("Processor configuration lacks atomic compare-and-swap support!\n");
return 0;
}
示例11: sunxi_timer_init
void __init sunxi_timer_init(void)
{
#ifdef CONFIG_OF
struct device_node *node;
struct clk *clk;
#endif
unsigned long rate = 0;
int ret, irq;
u32 val;
#ifdef CONFIG_OF
node = of_find_matching_node(NULL, sunxi_timer_dt_ids);
if (!node)
panic("No sunxi timer node");
timer_base = of_iomap(node, 0);
if (!timer_base)
panic("Can't map registers");
irq = irq_of_parse_and_map(node, 0);
if (irq <= 0)
panic("Can't parse IRQ");
clk = of_clk_get(node, 0);
if (IS_ERR(clk))
panic("Can't get timer clock");
rate = clk_get_rate(clk);
#else
timer_base = (void __iomem *)SUNXI_TIMER_VBASE;
irq = SUNXI_IRQ_TIMER0;
#if defined(CONFIG_ARCH_SUN8IW3P1) && defined(CONFIG_FPGA_V4_PLATFORM)
rate = 32000; /* it is proved by test that clk-src=32000, prescale=1 on fpga */
#else
rate = 24000000;
#endif
#endif
writel(rate / (TIMER_SCAL * HZ),
timer_base + TIMER0_INTVAL_REG);
/* set clock source to HOSC, 16 pre-division */
val = readl(timer_base + TIMER0_CTL_REG);
val &= ~(0x07 << 4);
val &= ~(0x03 << 2);
val |= (4 << 4) | (1 << 2);
writel(val, timer_base + TIMER0_CTL_REG);
/* set mode to auto reload */
val = readl(timer_base + TIMER0_CTL_REG);
writel(val | TIMER0_CTL_AUTORELOAD, timer_base + TIMER0_CTL_REG);
ret = setup_irq(irq, &sunxi_timer_irq);
if (ret)
pr_warn("failed to setup irq %d\n", irq);
/* Enable timer0 interrupt */
val = readl(timer_base + TIMER_CTL_REG);
writel(val | TIMER_CTL_ENABLE, timer_base + TIMER_CTL_REG);
sunxi_clockevent.mult = div_sc(rate / TIMER_SCAL,
NSEC_PER_SEC,
sunxi_clockevent.shift);
sunxi_clockevent.max_delta_ns = clockevent_delta2ns(0x7fffffff,
&sunxi_clockevent);
sunxi_clockevent.min_delta_ns = clockevent_delta2ns(0x10,
&sunxi_clockevent);
sunxi_clockevent.cpumask = cpumask_of(0);
clockevents_register_device(&sunxi_clockevent);
}
示例12: dib7090_fe_cfg_get
static int dib7090_fe_cfg_get(struct aml_dvb *advb, struct platform_device *pdev, int id, struct nim7090_adapter_state **pcfg)
{
struct resource *res;
char buf[32];
int ret=0;
struct nim7090_adapter_state *cfg;
cfg = kzalloc(sizeof(struct nim7090_adapter_state), GFP_KERNEL);
if (!cfg)
return -ENOMEM;
cfg->i2c_id = fe_i2c;
if(cfg->i2c_id == -1) {
snprintf(buf, sizeof(buf), "frontend%d_i2c", id);
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, buf);
if (!res) {
pr_error("cannot get resource \"%s\"\n", buf);
ret = -EINVAL;
goto err_resource;
}
cfg->i2c_id = res->start;
fe_i2c = cfg->i2c_id;
}
cfg->demod_addr = fe_demod_addr;
if(cfg->demod_addr==-1) {
snprintf(buf, sizeof(buf), "frontend%d_demod_addr", id);
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, buf);
if (!res) {
pr_error("cannot get resource \"%s\"\n", buf);
ret = -EINVAL;
goto err_resource;
}
cfg->demod_addr = res->start;
fe_demod_addr = cfg->demod_addr;
}
cfg->reset_pin = fe_demod_rst_pin;
if(cfg->reset_pin==-1) {
snprintf(buf, sizeof(buf), "frontend%d_reset_pin", id);
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, buf);
if (!res) {
pr_warn("cannot get resource \"%s\"\n", buf);
cfg->reset_pin = 0;
} else {
cfg->reset_pin = res->start;
}
fe_demod_rst_pin = cfg->demod_addr;
}
cfg->reset_val_en= fe_demod_rst_val_en;
if(cfg->reset_val_en==-1) {
snprintf(buf, sizeof(buf), "frontend%d_reset_value_enable", id);
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, buf);
if (!res) {
pr_warn("cannot get resource \"%s\"\n", buf);
} else {
cfg->reset_val_en = res->start;
}
fe_demod_rst_val_en = cfg->reset_val_en;
}
cfg->power_pin = fe_demod_pwr_pin;
if(cfg->power_pin==-1) {
snprintf(buf, sizeof(buf), "frontend%d_power_pin", id);
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, buf);
if (!res) {
pr_warn("cannot get resource \"%s\"\n", buf);
cfg->power_pin = 0;
} else {
cfg->power_pin = res->start;
}
fe_demod_pwr_pin = cfg->power_pin;
}
cfg->power_val_en= fe_demod_pwr_val_en;
if(cfg->power_val_en==-1) {
snprintf(buf, sizeof(buf), "frontend%d_power_value_enable", id);
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, buf);
if (!res) {
pr_warn("cannot get resource \"%s\"\n", buf);
} else {
cfg->power_val_en = res->start;
}
fe_demod_pwr_val_en = cfg->power_val_en;
}
*pcfg = cfg;
return 0;
err_resource:
kfree(cfg);
return ret;
}
示例13: max77849_irq_thread
static irqreturn_t max77849_irq_thread(int irq, void *data)
{
struct max77849_dev *max77849 = data;
u8 irq_reg[MAX77849_IRQ_GROUP_NR] = {0};
u8 tmp_irq_reg[MAX77849_IRQ_GROUP_NR] = {};
u8 irq_src;
int ret;
int i;
/* INTMASK1 3:ADC1K 0:ADC */
/* INTMASK2 4:VBVolt 0:Chgtype */
max77849_write_reg(max77849->muic, MAX77849_MUIC_REG_INTMASK1, 0x09);
max77849_write_reg(max77849->muic, MAX77849_MUIC_REG_INTMASK2, 0x11);
clear_retry:
ret = max77849_read_reg(max77849->i2c,
MAX77849_PMIC_REG_INTSRC, &irq_src);
if (ret < 0) {
dev_err(max77849->dev,
"Failed to read interrupt source: %d\n", ret);
return IRQ_NONE;
}
pr_info("%s: interrupt source(0x%02x)\n", __func__, irq_src);
if (irq_src & MAX77849_IRQSRC_CHG) {
/* CHG_INT */
ret = max77849_read_reg(max77849->i2c, MAX77849_CHG_REG_CHG_INT,
&irq_reg[CHG_INT]);
pr_info("%s: charger interrupt(0x%02x)\n",
__func__, irq_reg[CHG_INT]);
/* mask chgin to prevent chgin infinite interrupt
* chgin is unmasked chgin isr
*/
if (irq_reg[CHG_INT] &
max77849_irqs[MAX77849_CHG_IRQ_CHGIN_I].mask) {
u8 reg_data;
max77849_read_reg(max77849->i2c,
MAX77849_CHG_REG_CHG_INT_MASK, ®_data);
reg_data |= (1 << 6);
max77849_write_reg(max77849->i2c,
MAX77849_CHG_REG_CHG_INT_MASK, reg_data);
}
}
if (irq_src & MAX77849_IRQSRC_TOP) {
/* TOPSYS_INT */
ret = max77849_read_reg(max77849->i2c,
MAX77849_PMIC_REG_TOPSYS_INT,
&irq_reg[TOPSYS_INT]);
pr_info("%s: topsys interrupt(0x%02x)\n",
__func__, irq_reg[TOPSYS_INT]);
}
if (irq_src & MAX77849_IRQSRC_MUIC) {
/* MUIC INT1 ~ INT3 */
ret = max77849_bulk_read(max77849->muic, MAX77849_MUIC_REG_INT1,
MAX77849_NUM_IRQ_MUIC_REGS,
&tmp_irq_reg[MUIC_INT1]);
/* Or temp irq register to irq register for if it retries */
for (i = MUIC_INT1; i < MAX77849_IRQ_GROUP_NR; i++)
irq_reg[i] |= tmp_irq_reg[i];
pr_warn("%s: muic interrupt(0x%02x, 0x%02x, 0x%02x)\n",
__func__, irq_reg[MUIC_INT1],
irq_reg[MUIC_INT2], irq_reg[MUIC_INT3]);
}
pr_debug("%s: irq gpio post-state(0x%02x)\n", __func__,
gpio_get_value(max77849->irq_gpio));
if (gpio_get_value(max77849->irq_gpio) == 0) {
pr_warn("%s: irq_gpio is not High!\n", __func__);
goto clear_retry;
}
#if 0
/* Apply masking */
for (i = 0; i < MAX77849_IRQ_GROUP_NR; i++) {
if (i >= MUIC_INT1 && i <= MUIC_INT3)
irq_reg[i] &= max77849->irq_masks_cur[i];
else
irq_reg[i] &= ~max77849->irq_masks_cur[i];
}
#endif
/* Report */
for (i = 0; i < MAX77849_IRQ_NR; i++) {
if (irq_reg[max77849_irqs[i].group] & max77849_irqs[i].mask)
handle_nested_irq(max77849->irq_base + i);
}
return IRQ_HANDLED;
}
示例14: jffs2_erase_block
static void jffs2_erase_block(struct jffs2_sb_info *c,
struct jffs2_eraseblock *jeb)
{
int ret;
uint32_t bad_offset;
#ifdef __ECOS
ret = jffs2_flash_erase(c, jeb);
if (!ret) {
jffs2_erase_succeeded(c, jeb);
return;
}
bad_offset = jeb->offset;
#else /* Linux */
struct erase_info *instr;
jffs2_dbg(1, "%s(): erase block %#08x (range %#08x-%#08x)\n",
__func__,
jeb->offset, jeb->offset, jeb->offset + c->sector_size);
instr = kmalloc(sizeof(struct erase_info) + sizeof(struct erase_priv_struct), GFP_KERNEL);
if (!instr) {
pr_warn("kmalloc for struct erase_info in jffs2_erase_block failed. Refiling block for later\n");
mutex_lock(&c->erase_free_sem);
spin_lock(&c->erase_completion_lock);
list_move(&jeb->list, &c->erase_pending_list);
c->erasing_size -= c->sector_size;
c->dirty_size += c->sector_size;
jeb->dirty_size = c->sector_size;
spin_unlock(&c->erase_completion_lock);
mutex_unlock(&c->erase_free_sem);
return;
}
memset(instr, 0, sizeof(*instr));
instr->mtd = c->mtd;
instr->addr = jeb->offset;
instr->len = c->sector_size;
instr->callback = jffs2_erase_callback;
instr->priv = (unsigned long)(&instr[1]);
((struct erase_priv_struct *)instr->priv)->jeb = jeb;
((struct erase_priv_struct *)instr->priv)->c = c;
ret = mtd_erase(c->mtd, instr);
if (!ret)
return;
bad_offset = instr->fail_addr;
kfree(instr);
#endif /* __ECOS */
if (ret == -ENOMEM || ret == -EAGAIN) {
/* Erase failed immediately. Refile it on the list */
jffs2_dbg(1, "Erase at 0x%08x failed: %d. Refiling on erase_pending_list\n",
jeb->offset, ret);
mutex_lock(&c->erase_free_sem);
spin_lock(&c->erase_completion_lock);
list_move(&jeb->list, &c->erase_pending_list);
c->erasing_size -= c->sector_size;
c->dirty_size += c->sector_size;
jeb->dirty_size = c->sector_size;
spin_unlock(&c->erase_completion_lock);
mutex_unlock(&c->erase_free_sem);
return;
}
if (ret == -EROFS)
pr_warn("Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n",
jeb->offset);
else
pr_warn("Erase at 0x%08x failed immediately: errno %d\n",
jeb->offset, ret);
jffs2_erase_failed(c, jeb, bad_offset);
}
示例15: au_cmoo
static int au_cmoo(struct dentry *dentry)
{
int err, cmoo;
unsigned int udba;
struct path h_path;
struct au_pin pin;
struct au_cp_generic cpg = {
.dentry = dentry,
.bdst = -1,
.bsrc = -1,
.len = -1,
.pin = &pin,
.flags = AuCpup_DTIME | AuCpup_HOPEN
};
struct inode *inode, *delegated;
struct super_block *sb;
struct au_sbinfo *sbinfo;
struct au_fhsm *fhsm;
pid_t pid;
struct au_branch *br;
struct dentry *parent;
struct au_hinode *hdir;
DiMustWriteLock(dentry);
inode = dentry->d_inode;
IiMustWriteLock(inode);
err = 0;
if (IS_ROOT(dentry))
goto out;
cpg.bsrc = au_dbstart(dentry);
if (!cpg.bsrc)
goto out;
sb = dentry->d_sb;
sbinfo = au_sbi(sb);
fhsm = &sbinfo->si_fhsm;
pid = au_fhsm_pid(fhsm);
if (pid
&& (current->pid == pid
|| current->real_parent->pid == pid))
goto out;
br = au_sbr(sb, cpg.bsrc);
cmoo = au_br_cmoo(br->br_perm);
if (!cmoo)
goto out;
if (!S_ISREG(inode->i_mode))
cmoo &= AuBrAttr_COO_ALL;
if (!cmoo)
goto out;
parent = dget_parent(dentry);
di_write_lock_parent(parent);
err = au_wbr_do_copyup_bu(dentry, cpg.bsrc - 1);
cpg.bdst = err;
if (unlikely(err < 0)) {
err = 0; /* there is no upper writable branch */
goto out_dgrade;
}
AuDbg("bsrc %d, bdst %d\n", cpg.bsrc, cpg.bdst);
/* do not respect the coo attrib for the target branch */
err = au_cpup_dirs(dentry, cpg.bdst);
if (unlikely(err))
goto out_dgrade;
di_downgrade_lock(parent, AuLock_IR);
udba = au_opt_udba(sb);
err = au_pin(&pin, dentry, cpg.bdst, udba,
AuPin_DI_LOCKED | AuPin_MNT_WRITE);
if (unlikely(err))
goto out_parent;
err = au_sio_cpup_simple(&cpg);
au_unpin(&pin);
if (unlikely(err))
goto out_parent;
if (!(cmoo & AuBrWAttr_MOO))
goto out_parent; /* success */
err = au_pin(&pin, dentry, cpg.bsrc, udba,
AuPin_DI_LOCKED | AuPin_MNT_WRITE);
if (unlikely(err))
goto out_parent;
h_path.mnt = au_br_mnt(br);
h_path.dentry = au_h_dptr(dentry, cpg.bsrc);
hdir = au_hi(parent->d_inode, cpg.bsrc);
delegated = NULL;
err = vfsub_unlink(hdir->hi_inode, &h_path, &delegated, /*force*/1);
au_unpin(&pin);
/* todo: keep h_dentry or not? */
if (unlikely(err == -EWOULDBLOCK)) {
pr_warn("cannot retry for NFSv4 delegation"
" for an internal unlink\n");
iput(delegated);
}
if (unlikely(err)) {
pr_err("unlink %pd after coo failed (%d), ignored\n",
//.........这里部分代码省略.........