| Message ID | 1418162614-19182-2-git-send-email-khilman@kernel.org |
|---|---|
| State | New |
| Headers | show |
Hi Thomas, On 23 January 2015 at 17:27, Thomas Gleixner <tglx@linutronix.de> wrote: > static int __clockevents_set_mode(dev, mode) > { > /* Transition mode */ > if (dev->set_mode) { > if (mode > CLOCK_EVT_MODE_RESUME) > return -ENOSYS; > dev->set_mode(mode, dev); > return 0; > } > > if (dev->features & CLOCK_EVT_FEAT_DUMMY) > return 0; > > switch (mode) { > /* > * This is an internal state, which is guaranteed to > * go from SHUTDOWN to UNUSED. No driver interaction > * required. > */ > case CLOCK_EVT_MODE_UNUSED: > return 0; > > case CLOCK_EVT_MODE_SHUTDOWN: > return dev->shutdown(dev); > > case CLOCK_EVT_MODE_PERIODIC: > /* Core internal bug */ > if (!(dev->features & CLOCK_EVT_FEAT_PERIODIC)) > return -ENOSYS; > return dev->setup_periodic(dev); > > case CLOCK_EVT_MODE_ONESHOT: > /* Core internal bug */ > if (!(dev->features & CLOCK_EVT_FEAT_ONESHOT)) > return -ENOSYS; > return dev->setup_oneshot(dev); > > case CLOCK_EVT_MODE_RESUME: > return dev->setup_resume(dev); Because setting to all these existing modes isn't allowed to fail currently, shouldn't we make return type of all the new callbacks as 'void' and return 0 from this routine ? That way, these callbacks would stay consistent with the set_mode() callback.. > > default: > return -ENOSYS; > } > > And do sanity checking on registration time: > > static int ce_check(dev) > { > if (dev->set_mode) > return 0; > > if (dev->features & CLOCK_EVT_FEAT_DUMMY) > return 0; > > if (!dev->shutdown) > return -EMORON; > > if ((dev->features & CLOCK_EVT_FEAT_PERIODIC) && > !dev->setup_periodic) > return -EMORON; > > if ((dev->features & CLOCK_EVT_FEAT_ONESHOT) && > !dev->setup_oneshot) > return -EMORON; > > /* Optional callbacks */ > if (!dev->setup_resume) > dev->setup_resume = setup_noop(); > > return 0; > } > > That gives us a clear distinction of required and optional callbacks, > which will make error handling and recovery simpler as well. Now that we are looking forward to providing individual callbacks per feature, I wanted to propose few more solutions to it, though I am quite sure you would have already considered and rejected them. I remember from your earlier mail that you didn't wanted to add ONESHOT_STOPPED as a feature (as it isn't a feature really) and that restricts us from doing this: static int __clockevents_set_mode(dev, mode) { if ((mode == CLOCK_EVT_MODE_ONESHOT_STOPPED) && !(dev->features & CLOCK_EVT_FEAT_ONESHOT_STOPPED)) return -ENOSYS; dev->set_mode(mode, dev); return 0; } But what about providing a separate callback only for ONESHOT_STOPPED mode and use set_mode() for everything else ? static int __clockevents_set_mode(dev, mode) { if (mode == CLOCK_EVT_MODE_ONESHOT_STOPPED) { if (dev->stop_onshot) return dev->stop_onshot(dev); else return -ENOSYS; } dev->set_mode(mode, dev); return 0; } Thanks for looking into this thread again.. -- viresh -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
diff --git a/include/linux/clockchips.h b/include/linux/clockchips.h index 2e4cb67f6e56..d969659cf688 100644 --- a/include/linux/clockchips.h +++ b/include/linux/clockchips.h @@ -81,7 +81,8 @@ enum clock_event_mode { * @mode: operating mode assigned by the management code * @features: features * @retries: number of forced programming retries - * @set_mode: set mode function + * @set_dev_mode: set dev mode function + * @set_mode: set mode function (deprecated, use set_dev_mode instead) * @broadcast: function to broadcast events * @min_delta_ticks: minimum delta value in ticks stored for reconfiguration * @max_delta_ticks: maximum delta value in ticks stored for reconfiguration @@ -109,6 +110,8 @@ struct clock_event_device { unsigned long retries; void (*broadcast)(const struct cpumask *mask); + int (*set_dev_mode)(enum clock_event_mode mode, + struct clock_event_device *); void (*set_mode)(enum clock_event_mode mode, struct clock_event_device *); void (*suspend)(struct clock_event_device *); diff --git a/kernel/time/clockevents.c b/kernel/time/clockevents.c index 55449909f114..f7614041240e 100644 --- a/kernel/time/clockevents.c +++ b/kernel/time/clockevents.c @@ -105,7 +105,16 @@ void clockevents_set_mode(struct clock_event_device *dev, enum clock_event_mode mode) { if (dev->mode != mode) { - dev->set_mode(mode, dev); + if (dev->set_dev_mode) { + int ret = dev->set_dev_mode(mode, dev); + + /* Currently available modes shouldn't fail */ + WARN_ONCE(ret, "Requested mode: %d, error: %d\n", + mode, ret); + } else { + dev->set_mode(mode, dev); + } + dev->mode = mode; /* @@ -448,8 +457,14 @@ int __clockevents_update_freq(struct clock_event_device *dev, u32 freq) if (dev->mode == CLOCK_EVT_MODE_ONESHOT) return clockevents_program_event(dev, dev->next_event, false); - if (dev->mode == CLOCK_EVT_MODE_PERIODIC) - dev->set_mode(CLOCK_EVT_MODE_PERIODIC, dev); + if (dev->mode == CLOCK_EVT_MODE_PERIODIC) { + /* Shouldn't fail while switching to PERIODIC MODE */ + if (dev->set_dev_mode) + WARN_ON_ONCE(dev->set_dev_mode(CLOCK_EVT_MODE_PERIODIC, + dev)); + else + dev->set_mode(CLOCK_EVT_MODE_PERIODIC, dev); + } return 0; } diff --git a/kernel/time/timer_list.c b/kernel/time/timer_list.c index 61ed862cdd37..957a04951ef0 100644 --- a/kernel/time/timer_list.c +++ b/kernel/time/timer_list.c @@ -229,7 +229,10 @@ print_tickdevice(struct seq_file *m, struct tick_device *td, int cpu) SEQ_printf(m, "\n"); SEQ_printf(m, " set_mode: "); - print_name_offset(m, dev->set_mode); + if (dev->set_dev_mode) + print_name_offset(m, dev->set_dev_mode); + else + print_name_offset(m, dev->set_mode); SEQ_printf(m, "\n"); SEQ_printf(m, " event_handler: ");