C++ round_jiffies_relative函数代码示例

static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str,
				struct serio *port)
{
	static bool extended;

	if (str & 0x20)
		return false;

	/* 0x54 wwan, 0x62 bluetooth, 0x76 wlan, 0xE4 touchpad toggle*/
	if (unlikely(data == 0xe0)) {
		extended = true;
		return false;
	} else if (unlikely(extended)) {
		extended = false;
		switch (data) {
		case 0xE4:
			schedule_delayed_work(&msi_touchpad_work,
				round_jiffies_relative(0.5 * HZ));
			break;
		case 0x54:
		case 0x62:
		case 0x76:
			schedule_delayed_work(&msi_rfkill_work,
				round_jiffies_relative(0.5 * HZ));
			break;
		}
	}

	return false;
}

static void  idtp9017_resume(struct device *dev) {
//	struct i2c_client *client = to_i2c_client(dev);
//	struct idtp9017_chip *chip = i2c_get_clientdata(client);
	pr_info("[WLC] wlc_resume\n");

	the_chip->suspend = false;

	schedule_delayed_work(&the_chip->wlc_status_work, round_jiffies_relative(
				msecs_to_jiffies(500)));
#ifdef CONFIG_LGE_PM_CHARGING_USING_CHGSTS_WLC
	schedule_delayed_work(&chip->update_soc_worker, round_jiffies_relative
			(msecs_to_jiffies(500)));
#endif
}

static inline void handle_dc_inout(struct smb349_dual_charger *chip,
								int present)
{
	if (chip->chg_present != present) {
		chip->chg_present = present;
		power_supply_changed(&chip->cradle_psy);

		if (present) {
			dev_dbg(chip->dev, "DC IN\n");
			smb349_hw_init(chip);
			smb349_pm_stay_awake(chip, PM_SMB349_DC_INSERTED);
			schedule_delayed_work(
				&chip->periodic_charge_handler_dwork,
				round_jiffies_relative(
					msecs_to_jiffies(PERIODIC_DELAY_MS)));
			notify_external_charger(chip, 0);
			dev_dbg(chip->dev, "Periodic work started\n");
		} else {
			dev_dbg(chip->dev, "DC OUT\n");
			cancel_delayed_work(
				&chip->periodic_charge_handler_dwork);
			smb349_pm_relax(chip, PM_SMB349_DC_INSERTED);
			notify_external_charger(chip, 1);
			dev_dbg(chip->dev, "Periodic work stopped\n");
		}
	}
}

static int __init init_nonfatal_mce_checker(void)
{
	struct cpuinfo_x86 *c = &boot_cpu_data;

	/* Check for MCE support */
	if (!cpu_has(c, X86_FEATURE_MCE))
		return -ENODEV;

	/* Check for PPro style MCA */
	if (!cpu_has(c, X86_FEATURE_MCA))
		return -ENODEV;

	/* Some Athlons misbehave when we frob bank 0 */
	if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
		boot_cpu_data.x86 == 6)
			firstbank = 1;
	else
			firstbank = 0;

	/*
	 * Check for non-fatal errors every MCE_RATE s
	 */
	schedule_delayed_work(&mce_work, round_jiffies_relative(MCE_RATE));
	printk(KERN_INFO "Machine check exception polling timer started.\n");
	return 0;
}

static int rfkill_init(struct platform_device *sdev)
{
	/* add rfkill */
	int retval;

	/* keep the hardware wireless state */
	get_wireless_state_ec_standard();

	rfk_bluetooth = rfkill_alloc("msi-bluetooth", &sdev->dev,
				RFKILL_TYPE_BLUETOOTH,
				&rfkill_bluetooth_ops, NULL);
	if (!rfk_bluetooth) {
		retval = -ENOMEM;
		goto err_bluetooth;
	}
	retval = rfkill_register(rfk_bluetooth);
	if (retval)
		goto err_bluetooth;

	rfk_wlan = rfkill_alloc("msi-wlan", &sdev->dev, RFKILL_TYPE_WLAN,
				&rfkill_wlan_ops, NULL);
	if (!rfk_wlan) {
		retval = -ENOMEM;
		goto err_wlan;
	}
	retval = rfkill_register(rfk_wlan);
	if (retval)
		goto err_wlan;

	if (threeg_exists) {
		rfk_threeg = rfkill_alloc("msi-threeg", &sdev->dev,
				RFKILL_TYPE_WWAN, &rfkill_threeg_ops, NULL);
		if (!rfk_threeg) {
			retval = -ENOMEM;
			goto err_threeg;
		}
		retval = rfkill_register(rfk_threeg);
		if (retval)
			goto err_threeg;
	}

	/* schedule to run rfkill state initial */
	schedule_delayed_work(&msi_rfkill_init,
				round_jiffies_relative(1 * HZ));

	return 0;

err_threeg:
	rfkill_destroy(rfk_threeg);
	if (rfk_wlan)
		rfkill_unregister(rfk_wlan);
err_wlan:
	rfkill_destroy(rfk_wlan);
	if (rfk_bluetooth)
		rfkill_unregister(rfk_bluetooth);
err_bluetooth:
	rfkill_destroy(rfk_bluetooth);

	return retval;
}

static void sta32x_watchdog_start(struct sta32x_priv *sta32x)
{
	if (sta32x->pdata->needs_esd_watchdog) {
		sta32x->shutdown = 0;
		schedule_delayed_work(&sta32x->watchdog_work,
				      round_jiffies_relative(HZ));
	}
}

static void iwl_mvm_enter_ctkill(struct iwl_mvm *mvm)
{
	u32 duration = mvm->thermal_throttle.params->ct_kill_duration;

	IWL_ERR(mvm, "Enter CT Kill\n");
	iwl_mvm_set_hw_ctkill_state(mvm, true);
	schedule_delayed_work(&mvm->thermal_throttle.ct_kill_exit,
			      round_jiffies_relative(duration * HZ));
}

static void sta32x_watchdog_start(struct sta32x_priv *sta32x)
{
	if (sta32x->pdata->needs_esd_watchdog) {
		sta32x->shutdown = 0;
		queue_delayed_work(system_power_efficient_wq,
				   &sta32x->watchdog_work,
				   round_jiffies_relative(HZ));
	}
}

static void adkey_input_queue_work(struct adgpio_key_data *adkey)
{
    unsigned long delay;

    delay = msecs_to_jiffies(adkey->poll_interval);
    if (delay >= HZ)
        delay = round_jiffies_relative(delay);

    queue_delayed_work(system_freezable_wq, &adkey->work, delay);
}

static void input_polldev_queue_work(struct input_polled_dev *dev)
{
	unsigned long delay;

	delay = msecs_to_jiffies(dev->poll_interval);
	if (delay >= HZ)
		delay = round_jiffies_relative(delay);

	queue_delayed_work(system_freezable_wq, &dev->work, delay);
}

static void wlc_eoc_work(struct work_struct *work)
{
	struct rt9536_chip *rt9536_chg = container_of(work, struct rt9536_chip,
				 wireless_eoc_work);

	pr_err("[RT9536] %s \n", __func__);
	rt9536_chg->chg_done = 1;
	if (rt9536_set_charger_enable(rt9536_chg, 0)) {
		pr_err("%s : charger enable fail!!!\n", __func__);
	}
	power_supply_changed(&rt9536_chg->charger);
	if (wake_lock_active(&rt9536_chg->wl))
		wake_unlock(&rt9536_chg->wl);

#if 0
	int chg_state = 0;
	int wlc_connect_state = 0;
	struct rt9536_chip *rt9536_chg = container_of(work, struct rt9536_chip,
			 wireless_eoc_work.work);
	pr_err("[RT9536] %s \n", __func__);

	chg_state = wlc_check_irq_pin(rt9536_chg);
	wlc_connect_state = wlc_is_connected();
	if (chg_state) {
		if (wlc_connect_state == 1) {
			power_supply_changed(&rt9536_chg->charger);
			rt9536_chg->chg_done = 1;
		} else {
			schedule_delayed_work(&rt9536_chg->wireless_set_offline_work,
				round_jiffies_relative(msecs_to_jiffies(500)));
		}
	} else {
		schedule_delayed_work(&rt9536_chg->wireless_set_online_work,
			round_jiffies_relative(msecs_to_jiffies(500)));
	}

	/* msleep(3500);
	gpio_set_value(rt9536_chg->pdata->wlc_chg_full_pin,0);
	rt9536_chg->chg_done=1;
	rt9536_set_charger_enable(0);  // temp */
#endif
	return;
}

static irqreturn_t smb349_chg_stat_handler(int irq, void *dev_id)
{
	struct smb349_dual_charger *chip = dev_id;

	smb349_pm_stay_awake(chip, PM_SMB349_IRQ_HANDLING);
	schedule_delayed_work(&chip->irq_handler_dwork,
		round_jiffies_relative(msecs_to_jiffies(DELAY_IRQ_LEVEL_MS)));

	return IRQ_HANDLED;
}

/* must be called with ts->mutex held */
static void __tsc200x_enable(struct tsc200x *ts)
{
    tsc200x_start_scan(ts);

    if (ts->esd_timeout && (ts->set_reset || ts->reset_gpio)) {
        ts->last_valid_interrupt = jiffies;
        schedule_delayed_work(&ts->esd_work,
                              round_jiffies_relative(
                                  msecs_to_jiffies(ts->esd_timeout)));
    }
}

static ssize_t pwronoff_trigger_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count)
{
	sscanf(buf, "%d\n", &pwr_on_trigger);

	if (!s_pwrkey)
		return 0;

	schedule_delayed_work(&s_pwrkey->power_key_emulation_work, round_jiffies_relative(msecs_to_jiffies(pwrkey_delay_ms)));

	return count;
}

static void tsc200x_esd_work(struct work_struct *work)
{
    struct tsc200x *ts = container_of(work, struct tsc200x, esd_work.work);
    int error;
    unsigned int r;

    if (!mutex_trylock(&ts->mutex)) {
        /*
         * If the mutex is taken, it means that disable or enable is in
         * progress. In that case just reschedule the work. If the work
         * is not needed, it will be canceled by disable.
         */
        goto reschedule;
    }

    if (time_is_after_jiffies(ts->last_valid_interrupt +
                              msecs_to_jiffies(ts->esd_timeout)))
        goto out;

    /* We should be able to read register without disabling interrupts. */
    error = regmap_read(ts->regmap, TSC200X_REG_CFR0, &r);
    if (!error &&
            !((r ^ TSC200X_CFR0_INITVALUE) & TSC200X_CFR0_RW_MASK)) {
        goto out;
    }

    /*
     * If we could not read our known value from configuration register 0
     * then we should reset the controller as if from power-up and start
     * scanning again.
     */
    dev_info(ts->dev, "TSC200X not responding - resetting\n");

    disable_irq(ts->irq);
    del_timer_sync(&ts->penup_timer);

    tsc200x_update_pen_state(ts, 0, 0, 0);

    tsc200x_set_reset(ts, false);
    usleep_range(100, 500); /* only 10us required */
    tsc200x_set_reset(ts, true);

    enable_irq(ts->irq);
    tsc200x_start_scan(ts);

out:
    mutex_unlock(&ts->mutex);
reschedule:
    /* re-arm the watchdog */
    schedule_delayed_work(&ts->esd_work,
                          round_jiffies_relative(
                              msecs_to_jiffies(ts->esd_timeout)));
}