static void devalarm_cancel(struct devalarm *alrm)
{
if (is_wakeup(alrm->type))
alarm_cancel(&alrm->u.alrm);
else
hrtimer_cancel(&alrm->u.hrt);
}
static void devalarm_start(struct devalarm *alrm, ktime_t exp)
{
if (is_wakeup(alrm->type))
alarm_start(&alrm->u.alrm, exp);
else
hrtimer_start(&alrm->u.hrt, exp, HRTIMER_MODE_ABS);
}
static int __init alarm_dev_init(void)
{
int err;
int i;
err = misc_register(&alarm_device);
if (err)
return err;
alarm_init(&alarms[ANDROID_ALARM_RTC_WAKEUP].u.alrm,
ALARM_REALTIME, devalarm_alarmhandler);
hrtimer_init(&alarms[ANDROID_ALARM_RTC].u.hrt,
CLOCK_REALTIME, HRTIMER_MODE_ABS);
alarm_init(&alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP].u.alrm,
ALARM_BOOTTIME, devalarm_alarmhandler);
hrtimer_init(&alarms[ANDROID_ALARM_ELAPSED_REALTIME].u.hrt,
CLOCK_BOOTTIME, HRTIMER_MODE_ABS);
hrtimer_init(&alarms[ANDROID_ALARM_SYSTEMTIME].u.hrt,
CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
for (i = 0; i < ANDROID_ALARM_TYPE_COUNT; i++) {
alarms[i].type = i;
if (!is_wakeup(i))
alarms[i].u.hrt.function = devalarm_hrthandler;
}
wakeup_source_init(&alarm_wake_lock, "alarm");
return 0;
}
static void wakeup_event_handler(struct wakeup_ctrl *ctrl)
{
struct fsl_usb2_wakeup_platform_data *pdata = ctrl->pdata;
int i;
wakeup_clk_gate(ctrl->pdata, true);
/* if this is an wakeup event, we should debounce ID pin
* so we can get the correct ID value(ID status) here
* */
if (usb_event_is_otg_wakeup())
usb_debounce_id_pin();
for (i = 0; i < 3; i++) {
struct fsl_usb2_platform_data *usb_pdata = pdata->usb_pdata[i];
if (usb_pdata) {
usb_pdata->irq_delay = 0;
if (is_wakeup(usb_pdata)) {
usb_pdata->wakeup_event = 1;
if (usb_pdata->usb_clock_for_pm)
usb_pdata->usb_clock_for_pm(true);
usb_pdata->lowpower = 0;
}
}
}
wakeup_clk_gate(ctrl->pdata, false);
}
static void smm_install(void)
{
/* The first CPU running this gets to copy the SMM handler. But not all
* of them.
*/
if (smm_handler_copied)
return;
smm_handler_copied = 1;
/* if we're resuming from S3, the SMM code is already in place,
* so don't copy it again to keep the current SMM state */
if (!is_wakeup()) {
/* enable the SMM memory window */
pci_write_config8(dev_find_slot(0, PCI_DEVFN(0, 0)), SMRAM,
D_OPEN | G_SMRAME | C_BASE_SEG);
/* copy the real SMM handler */
memcpy((void *)0xa0000, &_binary_smm_start, (size_t)&_binary_smm_size);
wbinvd();
}
/* close the SMM memory window and enable normal SMM */
pci_write_config8(dev_find_slot(0, PCI_DEVFN(0, 0)), SMRAM,
G_SMRAME | C_BASE_SEG);
}
static int devalarm_try_to_cancel(struct devalarm *alrm)
{
int ret;
if (is_wakeup(alrm->type))
ret = alarm_try_to_cancel(&alrm->u.alrm);
else
ret = hrtimer_try_to_cancel(&alrm->u.hrt);
return ret;
}
static void wakeup_event_handler(struct wakeup_ctrl *ctrl)
{
struct fsl_usb2_wakeup_platform_data *pdata = ctrl->pdata;
int already_waked = 0;
enum usb_wakeup_event wakeup_evt;
int i;
wakeup_clk_gate(ctrl->pdata, true);
/* In order to get the real id/vbus value */
if (usb_event_is_otg_wakeup())
usb_debounce_id_vbus();
for (i = 0; i < 3; i++) {
struct fsl_usb2_platform_data *usb_pdata = pdata->usb_pdata[i];
if (usb_pdata) {
usb_pdata->irq_delay = 0;
wakeup_evt = is_wakeup(usb_pdata);
usb_pdata->wakeup_event = wakeup_evt;
if (wakeup_evt != WAKEUP_EVENT_INVALID) {
if (usb2_is_in_lowpower(ctrl))
if (usb_pdata->usb_clock_for_pm)
usb_pdata->usb_clock_for_pm(true);
usb_pdata->lowpower = 0;
already_waked = 1;
if (usb_pdata->wakeup_handler) {
usb_pdata->wakeup_handler(usb_pdata);
}
}
}
}
/* If nothing to wakeup, clear wakeup event */
if ((already_waked == 0) && pdata->usb_wakeup_exhandle)
pdata->usb_wakeup_exhandle();
wakeup_clk_gate(ctrl->pdata, false);
pdata->usb_wakeup_is_pending = false;
wake_up(&pdata->wq);
}
static int devalarm_try_to_cancel(struct devalarm *alrm)
{
if (is_wakeup(alrm->type))
return alarm_try_to_cancel(&alrm->u.alrm);
return hrtimer_try_to_cancel(&alrm->u.hrt);
}
