Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301// SPDX-License-Identifier: GPL-2.0-only/* * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework * for Non-CPU Devices. * * Copyright (C) 2011 Samsung Electronics * MyungJoo Ham <myungjoo.ham@samsung.com> */
#include <linux/kernel.h>#include <linux/kmod.h>#include <linux/sched.h>#include <linux/debugfs.h>#include <linux/devfreq_cooling.h>#include <linux/errno.h>#include <linux/err.h>#include <linux/init.h>#include <linux/export.h>#include <linux/slab.h>#include <linux/stat.h>#include <linux/pm_opp.h>#include <linux/devfreq.h>#include <linux/devfreq-governor.h>#include <linux/workqueue.h>#include <linux/platform_device.h>#include <linux/list.h>#include <linux/printk.h>#include <linux/hrtimer.h>#include <linux/of.h>#include <linux/pm_qos.h>#include <linux/units.h>
#define CREATE_TRACE_POINTS#include <trace/events/devfreq.h>
#define IS_SUPPORTED_FLAG(f, name) ((f & DEVFREQ_GOV_FLAG_##name) ? true : false)#define IS_SUPPORTED_ATTR(f, name) ((f & DEVFREQ_GOV_ATTR_##name) ? true : false)
static struct class *devfreq_class;static struct dentry *devfreq_debugfs;static const struct attribute_group gov_attr_group;
/* * devfreq core provides delayed work based load monitoring helper * functions. Governors can use these or can implement their own * monitoring mechanism. */static struct workqueue_struct *devfreq_wq;
/* The list of all device-devfreq governors */static LIST_HEAD(devfreq_governor_list);/* The list of all device-devfreq */static LIST_HEAD(devfreq_list);static DEFINE_MUTEX(devfreq_list_lock);
static const char timer_name[][DEVFREQ_NAME_LEN] = { [DEVFREQ_TIMER_DEFERRABLE] = { "deferrable" }, [DEVFREQ_TIMER_DELAYED] = { "delayed" },};
/** * find_device_devfreq() - find devfreq struct using device pointer * @dev: device pointer used to lookup device devfreq. * * Search the list of device devfreqs and return the matched device's * devfreq info. devfreq_list_lock should be held by the caller. */static struct devfreq *find_device_devfreq(struct device *dev){ struct devfreq *tmp_devfreq;
lockdep_assert_held(&devfreq_list_lock);
if (IS_ERR_OR_NULL(dev)) { pr_err("DEVFREQ: %s: Invalid parameters\n", __func__); return ERR_PTR(-EINVAL); }
list_for_each_entry(tmp_devfreq, &devfreq_list, node) { if (tmp_devfreq->dev.parent == dev) return tmp_devfreq; }
return ERR_PTR(-ENODEV);}
static unsigned long find_available_min_freq(struct devfreq *devfreq){ struct dev_pm_opp *opp; unsigned long min_freq = 0;
opp = dev_pm_opp_find_freq_ceil_indexed(devfreq->dev.parent, &min_freq, 0); if (IS_ERR(opp)) min_freq = 0; else dev_pm_opp_put(opp);
return min_freq;}
static unsigned long find_available_max_freq(struct devfreq *devfreq){ struct dev_pm_opp *opp; unsigned long max_freq = ULONG_MAX;
opp = dev_pm_opp_find_freq_floor_indexed(devfreq->dev.parent, &max_freq, 0); if (IS_ERR(opp)) max_freq = 0; else dev_pm_opp_put(opp);
return max_freq;}
/** * devfreq_get_freq_range() - Get the current freq range * @devfreq: the devfreq instance * @min_freq: the min frequency * @max_freq: the max frequency * * This takes into consideration all constraints. */void devfreq_get_freq_range(struct devfreq *devfreq, unsigned long *min_freq, unsigned long *max_freq){ unsigned long *freq_table = devfreq->freq_table; s32 qos_min_freq, qos_max_freq;
lockdep_assert_held(&devfreq->lock);
/* * Initialize minimum/maximum frequency from freq table. * The devfreq drivers can initialize this in either ascending or * descending order and devfreq core supports both. */ if (freq_table[0] < freq_table[devfreq->max_state - 1]) { *min_freq = freq_table[0]; *max_freq = freq_table[devfreq->max_state - 1]; } else { *min_freq = freq_table[devfreq->max_state - 1]; *max_freq = freq_table[0]; }
/* Apply constraints from PM QoS */ qos_min_freq = dev_pm_qos_read_value(devfreq->dev.parent, DEV_PM_QOS_MIN_FREQUENCY); qos_max_freq = dev_pm_qos_read_value(devfreq->dev.parent, DEV_PM_QOS_MAX_FREQUENCY); *min_freq = max(*min_freq, HZ_PER_KHZ * qos_min_freq); if (qos_max_freq != PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE) *max_freq = min(*max_freq, HZ_PER_KHZ * qos_max_freq);
/* Apply constraints from OPP interface */ *max_freq = clamp(*max_freq, devfreq->scaling_min_freq, devfreq->scaling_max_freq); *min_freq = clamp(*min_freq, devfreq->scaling_min_freq, *max_freq);}EXPORT_SYMBOL(devfreq_get_freq_range);
/** * devfreq_get_freq_level() - Lookup freq_table for the frequency * @devfreq: the devfreq instance * @freq: the target frequency */static int devfreq_get_freq_level(struct devfreq *devfreq, unsigned long freq){ int lev;
for (lev = 0; lev < devfreq->max_state; lev++) if (freq == devfreq->freq_table[lev]) return lev;
return -EINVAL;}
static int set_freq_table(struct devfreq *devfreq){ struct dev_pm_opp *opp; unsigned long freq; int i, count;
/* Initialize the freq_table from OPP table */ count = dev_pm_opp_get_opp_count(devfreq->dev.parent); if (count <= 0) return -EINVAL;
devfreq->max_state = count; devfreq->freq_table = devm_kcalloc(devfreq->dev.parent, devfreq->max_state, sizeof(*devfreq->freq_table), GFP_KERNEL); if (!devfreq->freq_table) return -ENOMEM;
for (i = 0, freq = 0; i < devfreq->max_state; i++, freq++) { opp = dev_pm_opp_find_freq_ceil_indexed(devfreq->dev.parent, &freq, 0); if (IS_ERR(opp)) { devm_kfree(devfreq->dev.parent, devfreq->freq_table); return PTR_ERR(opp); } dev_pm_opp_put(opp); devfreq->freq_table[i] = freq; }
return 0;}
/** * devfreq_update_status() - Update statistics of devfreq behavior * @devfreq: the devfreq instance * @freq: the update target frequency */int devfreq_update_status(struct devfreq *devfreq, unsigned long freq){ int lev, prev_lev, ret = 0; u64 cur_time;
lockdep_assert_held(&devfreq->lock); cur_time = get_jiffies_64();
/* Immediately exit if previous_freq is not initialized yet. */ if (!devfreq->previous_freq) goto out;
prev_lev = devfreq_get_freq_level(devfreq, devfreq->previous_freq); if (prev_lev < 0) { ret = prev_lev; goto out; }
devfreq->stats.time_in_state[prev_lev] += cur_time - devfreq->stats.last_update;
lev = devfreq_get_freq_level(devfreq, freq); if (lev < 0) { ret = lev; goto out; }
if (lev != prev_lev) { devfreq->stats.trans_table[ (prev_lev * devfreq->max_state) + lev]++; devfreq->stats.total_trans++; }
out: devfreq->stats.last_update = cur_time; return ret;}EXPORT_SYMBOL(devfreq_update_status);
/** * find_devfreq_governor() - find devfreq governor from name * @name: name of the governor * * Search the list of devfreq governors and return the matched * governor's pointer. devfreq_list_lock should be held by the caller. */static struct devfreq_governor *find_devfreq_governor(const char *name){ struct devfreq_governor *tmp_governor;
lockdep_assert_held(&devfreq_list_lock);
if (IS_ERR_OR_NULL(name)) { pr_err("DEVFREQ: %s: Invalid parameters\n", __func__); return ERR_PTR(-EINVAL); }
list_for_each_entry(tmp_governor, &devfreq_governor_list, node) { if (!strncmp(tmp_governor->name, name, DEVFREQ_NAME_LEN)) return tmp_governor; }
return ERR_PTR(-ENODEV);}
/** * try_then_request_governor() - Try to find the governor and request the * module if is not found. * @name: name of the governor * * Search the list of devfreq governors and request the module and try again * if is not found. This can happen when both drivers (the governor driver * and the driver that call devfreq_add_device) are built as modules. * devfreq_list_lock should be held by the caller. Returns the matched * governor's pointer or an error pointer. */static struct devfreq_governor *try_then_request_governor(const char *name){ struct devfreq_governor *governor; int err = 0;
lockdep_assert_held(&devfreq_list_lock);
if (IS_ERR_OR_NULL(name)) { pr_err("DEVFREQ: %s: Invalid parameters\n", __func__); return ERR_PTR(-EINVAL); }
governor = find_devfreq_governor(name); if (IS_ERR(governor)) { mutex_unlock(&devfreq_list_lock);
if (!strncmp(name, DEVFREQ_GOV_SIMPLE_ONDEMAND, DEVFREQ_NAME_LEN)) err = request_module("governor_%s", "simpleondemand"); else err = request_module("governor_%s", name); /* Restore previous state before return */ mutex_lock(&devfreq_list_lock); if (err) return (err < 0) ? ERR_PTR(err) : ERR_PTR(-EINVAL);
governor = find_devfreq_governor(name); }
return governor;}
static int devfreq_notify_transition(struct devfreq *devfreq, struct devfreq_freqs *freqs, unsigned int state){ if (!devfreq) return -EINVAL;
switch (state) { case DEVFREQ_PRECHANGE: srcu_notifier_call_chain(&devfreq->transition_notifier_list, DEVFREQ_PRECHANGE, freqs); break;
case DEVFREQ_POSTCHANGE: srcu_notifier_call_chain(&devfreq->transition_notifier_list, DEVFREQ_POSTCHANGE, freqs); break; default: return -EINVAL; }
return 0;}
static int devfreq_set_target(struct devfreq *devfreq, unsigned long new_freq, u32 flags){ struct devfreq_freqs freqs; unsigned long cur_freq; int err = 0;
if (devfreq->profile->get_cur_freq) devfreq->profile->get_cur_freq(devfreq->dev.parent, &cur_freq); else cur_freq = devfreq->previous_freq;
freqs.old = cur_freq; freqs.new = new_freq; devfreq_notify_transition(devfreq, &freqs, DEVFREQ_PRECHANGE);
err = devfreq->profile->target(devfreq->dev.parent, &new_freq, flags); if (err) { freqs.new = cur_freq; devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE); return err; }
/* * Print devfreq_frequency trace information between DEVFREQ_PRECHANGE * and DEVFREQ_POSTCHANGE because for showing the correct frequency * change order of between devfreq device and passive devfreq device. */ if (trace_devfreq_frequency_enabled() && new_freq != cur_freq) trace_devfreq_frequency(devfreq, new_freq, cur_freq);
freqs.new = new_freq; devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
if (devfreq_update_status(devfreq, new_freq)) dev_warn(&devfreq->dev, "Couldn't update frequency transition information.\n");
devfreq->previous_freq = new_freq;
if (devfreq->suspend_freq) devfreq->resume_freq = new_freq;
return err;}
/** * devfreq_update_target() - Reevaluate the device and configure frequency * on the final stage. * @devfreq: the devfreq instance. * @freq: the new frequency of parent device. This argument * is only used for devfreq device using passive governor. * * Note: Lock devfreq->lock before calling devfreq_update_target. This function * should be only used by both update_devfreq() and devfreq governors. */int devfreq_update_target(struct devfreq *devfreq, unsigned long freq){ unsigned long min_freq, max_freq; int err = 0; u32 flags = 0;
lockdep_assert_held(&devfreq->lock);
if (!devfreq->governor) return -EINVAL;
/* Reevaluate the proper frequency */ err = devfreq->governor->get_target_freq(devfreq, &freq); if (err) return err; devfreq_get_freq_range(devfreq, &min_freq, &max_freq);
if (freq < min_freq) { freq = min_freq; flags &= ~DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use GLB */ } if (freq > max_freq) { freq = max_freq; flags |= DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use LUB */ }
return devfreq_set_target(devfreq, freq, flags);}EXPORT_SYMBOL(devfreq_update_target);
/* Load monitoring helper functions for governors use */
/** * update_devfreq() - Reevaluate the device and configure frequency. * @devfreq: the devfreq instance. * * Note: Lock devfreq->lock before calling update_devfreq * This function is exported for governors. */int update_devfreq(struct devfreq *devfreq){ return devfreq_update_target(devfreq, 0L);}EXPORT_SYMBOL(update_devfreq);
/** * devfreq_monitor() - Periodically poll devfreq objects. * @work: the work struct used to run devfreq_monitor periodically. * */static void devfreq_monitor(struct work_struct *work){ int err; struct devfreq *devfreq = container_of(work, struct devfreq, work.work);
mutex_lock(&devfreq->lock); err = update_devfreq(devfreq); if (err) dev_err(&devfreq->dev, "dvfs failed with (%d) error\n", err);
if (devfreq->stop_polling) goto out;
queue_delayed_work(devfreq_wq, &devfreq->work, msecs_to_jiffies(devfreq->profile->polling_ms));
out: mutex_unlock(&devfreq->lock); trace_devfreq_monitor(devfreq);}
/** * devfreq_monitor_start() - Start load monitoring of devfreq instance * @devfreq: the devfreq instance. * * Helper function for starting devfreq device load monitoring. By default, * deferrable timer is used for load monitoring. But the users can change this * behavior using the "timer" type in devfreq_dev_profile. This function will be * called by devfreq governor in response to the DEVFREQ_GOV_START event * generated while adding a device to the devfreq framework. */void devfreq_monitor_start(struct devfreq *devfreq){ if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN)) return;
mutex_lock(&devfreq->lock); if (delayed_work_pending(&devfreq->work)) goto out;
switch (devfreq->profile->timer) { case DEVFREQ_TIMER_DEFERRABLE: INIT_DEFERRABLE_WORK(&devfreq->work, devfreq_monitor); break; case DEVFREQ_TIMER_DELAYED: INIT_DELAYED_WORK(&devfreq->work, devfreq_monitor); break; default: goto out; }
if (devfreq->profile->polling_ms) queue_delayed_work(devfreq_wq, &devfreq->work, msecs_to_jiffies(devfreq->profile->polling_ms));
out: devfreq->stop_polling = false; mutex_unlock(&devfreq->lock);}EXPORT_SYMBOL(devfreq_monitor_start);
/** * devfreq_monitor_stop() - Stop load monitoring of a devfreq instance * @devfreq: the devfreq instance. * * Helper function to stop devfreq device load monitoring. Function * to be called from governor in response to DEVFREQ_GOV_STOP * event when device is removed from devfreq framework. */void devfreq_monitor_stop(struct devfreq *devfreq){ if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN)) return;
mutex_lock(&devfreq->lock); if (devfreq->stop_polling) { mutex_unlock(&devfreq->lock); return; }
devfreq->stop_polling = true; mutex_unlock(&devfreq->lock); cancel_delayed_work_sync(&devfreq->work);}EXPORT_SYMBOL(devfreq_monitor_stop);
/** * devfreq_monitor_suspend() - Suspend load monitoring of a devfreq instance * @devfreq: the devfreq instance. * * Helper function to suspend devfreq device load monitoring. Function * to be called from governor in response to DEVFREQ_GOV_SUSPEND * event or when polling interval is set to zero. * * Note: Though this function is same as devfreq_monitor_stop(), * intentionally kept separate to provide hooks for collecting * transition statistics. */void devfreq_monitor_suspend(struct devfreq *devfreq){ mutex_lock(&devfreq->lock); if (devfreq->stop_polling) { mutex_unlock(&devfreq->lock); return; }
devfreq_update_status(devfreq, devfreq->previous_freq); devfreq->stop_polling = true; mutex_unlock(&devfreq->lock);
if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN)) return;
cancel_delayed_work_sync(&devfreq->work);}EXPORT_SYMBOL(devfreq_monitor_suspend);
/** * devfreq_monitor_resume() - Resume load monitoring of a devfreq instance * @devfreq: the devfreq instance. * * Helper function to resume devfreq device load monitoring. Function * to be called from governor in response to DEVFREQ_GOV_RESUME * event or when polling interval is set to non-zero. */void devfreq_monitor_resume(struct devfreq *devfreq){ unsigned long freq;
mutex_lock(&devfreq->lock);
if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN)) goto out_update;
if (!devfreq->stop_polling) goto out;
if (!delayed_work_pending(&devfreq->work) && devfreq->profile->polling_ms) queue_delayed_work(devfreq_wq, &devfreq->work, msecs_to_jiffies(devfreq->profile->polling_ms));
out_update: devfreq->stats.last_update = get_jiffies_64(); devfreq->stop_polling = false;
if (devfreq->profile->get_cur_freq && !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq)) devfreq->previous_freq = freq;
out: mutex_unlock(&devfreq->lock);}EXPORT_SYMBOL(devfreq_monitor_resume);
/** * devfreq_update_interval() - Update device devfreq monitoring interval * @devfreq: the devfreq instance. * @delay: new polling interval to be set. * * Helper function to set new load monitoring polling interval. Function * to be called from governor in response to DEVFREQ_GOV_UPDATE_INTERVAL event. */void devfreq_update_interval(struct devfreq *devfreq, unsigned int *delay){ unsigned int cur_delay = devfreq->profile->polling_ms; unsigned int new_delay = *delay;
mutex_lock(&devfreq->lock); devfreq->profile->polling_ms = new_delay;
if (IS_SUPPORTED_FLAG(devfreq->governor->flags, IRQ_DRIVEN)) goto out;
if (devfreq->stop_polling) goto out;
/* if new delay is zero, stop polling */ if (!new_delay) { mutex_unlock(&devfreq->lock); cancel_delayed_work_sync(&devfreq->work); return; }
/* if current delay is zero, start polling with new delay */ if (!cur_delay) { queue_delayed_work(devfreq_wq, &devfreq->work, msecs_to_jiffies(devfreq->profile->polling_ms)); goto out; }
/* if current delay is greater than new delay, restart polling */ if (cur_delay > new_delay) { mutex_unlock(&devfreq->lock); cancel_delayed_work_sync(&devfreq->work); mutex_lock(&devfreq->lock); if (!devfreq->stop_polling) queue_delayed_work(devfreq_wq, &devfreq->work, msecs_to_jiffies(devfreq->profile->polling_ms)); }out: mutex_unlock(&devfreq->lock);}EXPORT_SYMBOL(devfreq_update_interval);
/** * devfreq_notifier_call() - Notify that the device frequency requirements * has been changed out of devfreq framework. * @nb: the notifier_block (supposed to be devfreq->nb) * @type: not used * @devp: not used * * Called by a notifier that uses devfreq->nb. */static int devfreq_notifier_call(struct notifier_block *nb, unsigned long type, void *devp){ struct devfreq *devfreq = container_of(nb, struct devfreq, nb); int err = -EINVAL;
mutex_lock(&devfreq->lock);
devfreq->scaling_min_freq = find_available_min_freq(devfreq); if (!devfreq->scaling_min_freq) goto out;
devfreq->scaling_max_freq = find_available_max_freq(devfreq); if (!devfreq->scaling_max_freq) { devfreq->scaling_max_freq = ULONG_MAX; goto out; }
err = update_devfreq(devfreq);
out: mutex_unlock(&devfreq->lock); if (err) dev_err(devfreq->dev.parent, "failed to update frequency from OPP notifier (%d)\n", err);
return NOTIFY_OK;}
/** * qos_notifier_call() - Common handler for QoS constraints. * @devfreq: the devfreq instance. */static int qos_notifier_call(struct devfreq *devfreq){ int err;
mutex_lock(&devfreq->lock); err = update_devfreq(devfreq); mutex_unlock(&devfreq->lock); if (err) dev_err(devfreq->dev.parent, "failed to update frequency from PM QoS (%d)\n", err);
return NOTIFY_OK;}
/** * qos_min_notifier_call() - Callback for QoS min_freq changes. * @nb: Should be devfreq->nb_min * @val: not used * @ptr: not used */static int qos_min_notifier_call(struct notifier_block *nb, unsigned long val, void *ptr){ return qos_notifier_call(container_of(nb, struct devfreq, nb_min));}
/** * qos_max_notifier_call() - Callback for QoS max_freq changes. * @nb: Should be devfreq->nb_max * @val: not used * @ptr: not used */static int qos_max_notifier_call(struct notifier_block *nb, unsigned long val, void *ptr){ return qos_notifier_call(container_of(nb, struct devfreq, nb_max));}
/** * devfreq_dev_release() - Callback for struct device to release the device. * @dev: the devfreq device * * Remove devfreq from the list and release its resources. */static void devfreq_dev_release(struct device *dev){ struct devfreq *devfreq = to_devfreq(dev); int err;
mutex_lock(&devfreq_list_lock); list_del(&devfreq->node); mutex_unlock(&devfreq_list_lock);
err = dev_pm_qos_remove_notifier(devfreq->dev.parent, &devfreq->nb_max, DEV_PM_QOS_MAX_FREQUENCY); if (err && err != -ENOENT) dev_warn(dev->parent, "Failed to remove max_freq notifier: %d\n", err); err = dev_pm_qos_remove_notifier(devfreq->dev.parent, &devfreq->nb_min, DEV_PM_QOS_MIN_FREQUENCY); if (err && err != -ENOENT) dev_warn(dev->parent, "Failed to remove min_freq notifier: %d\n", err);
if (dev_pm_qos_request_active(&devfreq->user_max_freq_req)) { err = dev_pm_qos_remove_request(&devfreq->user_max_freq_req); if (err < 0) dev_warn(dev->parent, "Failed to remove max_freq request: %d\n", err); } if (dev_pm_qos_request_active(&devfreq->user_min_freq_req)) { err = dev_pm_qos_remove_request(&devfreq->user_min_freq_req); if (err < 0) dev_warn(dev->parent, "Failed to remove min_freq request: %d\n", err); }
if (devfreq->profile->exit) devfreq->profile->exit(devfreq->dev.parent);
if (devfreq->opp_table) dev_pm_opp_put_opp_table(devfreq->opp_table);
mutex_destroy(&devfreq->lock); srcu_cleanup_notifier_head(&devfreq->transition_notifier_list); kfree(devfreq);}
/** * devfreq_add_device() - Add devfreq feature to the device * @dev: the device to add devfreq feature. * @profile: device-specific profile to run devfreq. * @governor_name: name of the policy to choose frequency. * @data: devfreq driver pass to governors, governor should not change it. */struct devfreq *devfreq_add_device(struct device *dev, struct devfreq_dev_profile *profile, const char *governor_name, void *data){ struct devfreq *devfreq; struct devfreq_governor *governor; int err = 0;
if (!dev || !profile || !governor_name) { dev_err(dev, "%s: Invalid parameters.\n", __func__); return ERR_PTR(-EINVAL); }
mutex_lock(&devfreq_list_lock); devfreq = find_device_devfreq(dev); mutex_unlock(&devfreq_list_lock); if (!IS_ERR(devfreq)) { dev_err(dev, "%s: devfreq device already exists!\n", __func__); err = -EINVAL; goto err_out; }
devfreq = kzalloc_obj(struct devfreq); if (!devfreq) { err = -ENOMEM; goto err_out; }
mutex_init(&devfreq->lock); mutex_lock(&devfreq->lock); devfreq->dev.parent = dev; devfreq->dev.class = devfreq_class; devfreq->dev.groups = profile->dev_groups; devfreq->dev.release = devfreq_dev_release; INIT_LIST_HEAD(&devfreq->node); devfreq->profile = profile; devfreq->previous_freq = profile->initial_freq; devfreq->last_status.current_frequency = profile->initial_freq; devfreq->data = data; devfreq->nb.notifier_call = devfreq_notifier_call;
if (devfreq->profile->timer < 0 || devfreq->profile->timer >= DEVFREQ_TIMER_NUM) { mutex_unlock(&devfreq->lock); err = -EINVAL; goto err_dev; }
if (!devfreq->profile->max_state || !devfreq->profile->freq_table) { mutex_unlock(&devfreq->lock); err = set_freq_table(devfreq); if (err < 0) goto err_dev; mutex_lock(&devfreq->lock); } else { devfreq->freq_table = devfreq->profile->freq_table; devfreq->max_state = devfreq->profile->max_state; }
devfreq->scaling_min_freq = find_available_min_freq(devfreq); if (!devfreq->scaling_min_freq) { mutex_unlock(&devfreq->lock); err = -EINVAL; goto err_dev; }
devfreq->scaling_max_freq = find_available_max_freq(devfreq); if (!devfreq->scaling_max_freq) { mutex_unlock(&devfreq->lock); err = -EINVAL; goto err_dev; }
devfreq->suspend_freq = dev_pm_opp_get_suspend_opp_freq(dev); devfreq->opp_table = dev_pm_opp_get_opp_table(dev); if (IS_ERR(devfreq->opp_table)) devfreq->opp_table = NULL;
atomic_set(&devfreq->suspend_count, 0);
dev_set_name(&devfreq->dev, "%s", dev_name(dev)); err = device_register(&devfreq->dev); if (err) { mutex_unlock(&devfreq->lock); put_device(&devfreq->dev); goto err_out; }
devfreq->stats.trans_table = devm_kzalloc(&devfreq->dev, array3_size(sizeof(unsigned int), devfreq->max_state, devfreq->max_state), GFP_KERNEL); if (!devfreq->stats.trans_table) { mutex_unlock(&devfreq->lock); err = -ENOMEM; goto err_devfreq; }
devfreq->stats.time_in_state = devm_kcalloc(&devfreq->dev, devfreq->max_state, sizeof(*devfreq->stats.time_in_state), GFP_KERNEL); if (!devfreq->stats.time_in_state) { mutex_unlock(&devfreq->lock); err = -ENOMEM; goto err_devfreq; }
devfreq->stats.total_trans = 0; devfreq->stats.last_update = get_jiffies_64();
srcu_init_notifier_head(&devfreq->transition_notifier_list);
mutex_unlock(&devfreq->lock);
err = dev_pm_qos_add_request(dev, &devfreq->user_min_freq_req, DEV_PM_QOS_MIN_FREQUENCY, 0); if (err < 0) goto err_devfreq; err = dev_pm_qos_add_request(dev, &devfreq->user_max_freq_req, DEV_PM_QOS_MAX_FREQUENCY, PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE); if (err < 0) goto err_devfreq;
devfreq->nb_min.notifier_call = qos_min_notifier_call; err = dev_pm_qos_add_notifier(dev, &devfreq->nb_min, DEV_PM_QOS_MIN_FREQUENCY); if (err) goto err_devfreq;
devfreq->nb_max.notifier_call = qos_max_notifier_call; err = dev_pm_qos_add_notifier(dev, &devfreq->nb_max, DEV_PM_QOS_MAX_FREQUENCY); if (err) goto err_devfreq;
mutex_lock(&devfreq_list_lock);
governor = try_then_request_governor(governor_name); if (IS_ERR(governor)) { dev_err(dev, "%s: Unable to find governor for the device\n", __func__); err = PTR_ERR(governor); goto err_init; }
devfreq->governor = governor; err = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_START, NULL); if (err) { dev_err_probe(dev, err, "%s: Unable to start governor for the device\n", __func__); goto err_init; }
err = sysfs_update_group(&devfreq->dev.kobj, &gov_attr_group); if (err) goto err_init;
list_add(&devfreq->node, &devfreq_list);
mutex_unlock(&devfreq_list_lock);
if (devfreq->profile->is_cooling_device) { devfreq->cdev = devfreq_cooling_em_register(devfreq, NULL); if (IS_ERR(devfreq->cdev)) devfreq->cdev = NULL; }
return devfreq;
err_init: mutex_unlock(&devfreq_list_lock);err_devfreq: devfreq_remove_device(devfreq); devfreq = NULL;err_dev: kfree(devfreq);err_out: return ERR_PTR(err);}EXPORT_SYMBOL(devfreq_add_device);
/** * devfreq_remove_device() - Remove devfreq feature from a device. * @devfreq: the devfreq instance to be removed * * The opposite of devfreq_add_device(). */int devfreq_remove_device(struct devfreq *devfreq){ if (!devfreq) return -EINVAL;
devfreq_cooling_unregister(devfreq->cdev);
if (devfreq->governor) devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_STOP, NULL); device_unregister(&devfreq->dev);
return 0;}EXPORT_SYMBOL(devfreq_remove_device);
static int devm_devfreq_dev_match(struct device *dev, void *res, void *data){ struct devfreq **r = res;
if (WARN_ON(!r || !*r)) return 0;
return *r == data;}
static void devm_devfreq_dev_release(struct device *dev, void *res){ devfreq_remove_device(*(struct devfreq **)res);}
/** * devm_devfreq_add_device() - Resource-managed devfreq_add_device() * @dev: the device to add devfreq feature. * @profile: device-specific profile to run devfreq. * @governor_name: name of the policy to choose frequency. * @data: devfreq driver pass to governors, governor should not change it. * * This function manages automatically the memory of devfreq device using device * resource management and simplify the free operation for memory of devfreq * device. */struct devfreq *devm_devfreq_add_device(struct device *dev, struct devfreq_dev_profile *profile, const char *governor_name, void *data){ struct devfreq **ptr, *devfreq;
ptr = devres_alloc(devm_devfreq_dev_release, sizeof(*ptr), GFP_KERNEL); if (!ptr) return ERR_PTR(-ENOMEM);
devfreq = devfreq_add_device(dev, profile, governor_name, data); if (IS_ERR(devfreq)) { devres_free(ptr); return devfreq; }
*ptr = devfreq; devres_add(dev, ptr);
return devfreq;}EXPORT_SYMBOL(devm_devfreq_add_device);
#ifdef CONFIG_OF/* * devfreq_get_devfreq_by_node - Get the devfreq device from devicetree * @node - pointer to device_node * * return the instance of devfreq device */struct devfreq *devfreq_get_devfreq_by_node(struct device_node *node){ struct devfreq *devfreq;
if (!node) return ERR_PTR(-EINVAL);
mutex_lock(&devfreq_list_lock); list_for_each_entry(devfreq, &devfreq_list, node) { if (devfreq->dev.parent && device_match_of_node(devfreq->dev.parent, node)) { mutex_unlock(&devfreq_list_lock); return devfreq; } } mutex_unlock(&devfreq_list_lock);
return ERR_PTR(-ENODEV);}
/* * devfreq_get_devfreq_by_phandle - Get the devfreq device from devicetree * @dev - instance to the given device * @phandle_name - name of property holding a phandle value * @index - index into list of devfreq * * return the instance of devfreq device */struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, const char *phandle_name, int index){ struct device_node *node; struct devfreq *devfreq;
if (!dev || !phandle_name) return ERR_PTR(-EINVAL);
if (!dev->of_node) return ERR_PTR(-EINVAL);
node = of_parse_phandle(dev->of_node, phandle_name, index); if (!node) return ERR_PTR(-ENODEV);
devfreq = devfreq_get_devfreq_by_node(node); of_node_put(node);
return devfreq;}
#elsestruct devfreq *devfreq_get_devfreq_by_node(struct device_node *node){ return ERR_PTR(-ENODEV);}
struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, const char *phandle_name, int index){ return ERR_PTR(-ENODEV);}#endif /* CONFIG_OF */EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_node);EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_phandle);
/** * devm_devfreq_remove_device() - Resource-managed devfreq_remove_device() * @dev: the device from which to remove devfreq feature. * @devfreq: the devfreq instance to be removed */void devm_devfreq_remove_device(struct device *dev, struct devfreq *devfreq){ WARN_ON(devres_release(dev, devm_devfreq_dev_release, devm_devfreq_dev_match, devfreq));}EXPORT_SYMBOL(devm_devfreq_remove_device);
/** * devfreq_suspend_device() - Suspend devfreq of a device. * @devfreq: the devfreq instance to be suspended * * This function is intended to be called by the pm callbacks * (e.g., runtime_suspend, suspend) of the device driver that * holds the devfreq. */int devfreq_suspend_device(struct devfreq *devfreq){ int ret;
if (!devfreq) return -EINVAL;
if (atomic_inc_return(&devfreq->suspend_count) > 1) return 0;
if (devfreq->governor) { ret = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_SUSPEND, NULL); if (ret) return ret; }
if (devfreq->suspend_freq) { mutex_lock(&devfreq->lock); ret = devfreq_set_target(devfreq, devfreq->suspend_freq, 0); mutex_unlock(&devfreq->lock); if (ret) return ret; }
return 0;}EXPORT_SYMBOL(devfreq_suspend_device);
/** * devfreq_resume_device() - Resume devfreq of a device. * @devfreq: the devfreq instance to be resumed * * This function is intended to be called by the pm callbacks * (e.g., runtime_resume, resume) of the device driver that * holds the devfreq. */int devfreq_resume_device(struct devfreq *devfreq){ int ret;
if (!devfreq) return -EINVAL;
if (atomic_dec_return(&devfreq->suspend_count) >= 1) return 0;
if (devfreq->resume_freq) { mutex_lock(&devfreq->lock); ret = devfreq_set_target(devfreq, devfreq->resume_freq, 0); mutex_unlock(&devfreq->lock); if (ret) return ret; }
if (devfreq->governor) { ret = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_RESUME, NULL); if (ret) return ret; }
return 0;}EXPORT_SYMBOL(devfreq_resume_device);
/** * devfreq_suspend() - Suspend devfreq governors and devices * * Called during system wide Suspend/Hibernate cycles for suspending governors * and devices preserving the state for resume. On some platforms the devfreq * device must have precise state (frequency) after resume in order to provide * fully operating setup. */void devfreq_suspend(void){ struct devfreq *devfreq; int ret;
mutex_lock(&devfreq_list_lock); list_for_each_entry(devfreq, &devfreq_list, node) { ret = devfreq_suspend_device(devfreq); if (ret) dev_err(&devfreq->dev, "failed to suspend devfreq device\n"); } mutex_unlock(&devfreq_list_lock);}
/** * devfreq_resume() - Resume devfreq governors and devices * * Called during system wide Suspend/Hibernate cycle for resuming governors and * devices that are suspended with devfreq_suspend(). */void devfreq_resume(void){ struct devfreq *devfreq; int ret;
mutex_lock(&devfreq_list_lock); list_for_each_entry(devfreq, &devfreq_list, node) { ret = devfreq_resume_device(devfreq); if (ret) dev_warn(&devfreq->dev, "failed to resume devfreq device\n"); } mutex_unlock(&devfreq_list_lock);}
/** * devfreq_add_governor() - Add devfreq governor * @governor: the devfreq governor to be added */int devfreq_add_governor(struct devfreq_governor *governor){ struct devfreq_governor *g; struct devfreq *devfreq; int err = 0;
if (!governor) { pr_err("%s: Invalid parameters.\n", __func__); return -EINVAL; }
mutex_lock(&devfreq_list_lock); g = find_devfreq_governor(governor->name); if (!IS_ERR(g)) { pr_err("%s: governor %s already registered\n", __func__, g->name); err = -EINVAL; goto err_out; }
list_add(&governor->node, &devfreq_governor_list);
list_for_each_entry(devfreq, &devfreq_list, node) { int ret = 0; struct device *dev = devfreq->dev.parent;
if (!strncmp(devfreq->governor->name, governor->name, DEVFREQ_NAME_LEN)) { /* The following should never occur */ if (devfreq->governor) { dev_warn(dev, "%s: Governor %s already present\n", __func__, devfreq->governor->name); ret = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_STOP, NULL); if (ret) { dev_warn(dev, "%s: Governor %s stop = %d\n", __func__, devfreq->governor->name, ret); } /* Fall through */ } devfreq->governor = governor; ret = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_START, NULL); if (ret) { dev_warn(dev, "%s: Governor %s start=%d\n", __func__, devfreq->governor->name, ret); } } }
err_out: mutex_unlock(&devfreq_list_lock);
return err;}EXPORT_SYMBOL(devfreq_add_governor);
static void devm_devfreq_remove_governor(void *governor){ WARN_ON(devfreq_remove_governor(governor));}
/** * devm_devfreq_add_governor() - Add devfreq governor * @dev: device which adds devfreq governor * @governor: the devfreq governor to be added * * This is a resource-managed variant of devfreq_add_governor(). */int devm_devfreq_add_governor(struct device *dev, struct devfreq_governor *governor){ int err;
err = devfreq_add_governor(governor); if (err) return err;
return devm_add_action_or_reset(dev, devm_devfreq_remove_governor, governor);}EXPORT_SYMBOL(devm_devfreq_add_governor);
/** * devfreq_remove_governor() - Remove devfreq feature from a device. * @governor: the devfreq governor to be removed */int devfreq_remove_governor(struct devfreq_governor *governor){ struct devfreq_governor *g; struct devfreq *devfreq; int err = 0;
if (!governor) { pr_err("%s: Invalid parameters.\n", __func__); return -EINVAL; }
mutex_lock(&devfreq_list_lock); g = find_devfreq_governor(governor->name); if (IS_ERR(g)) { pr_err("%s: governor %s not registered\n", __func__, governor->name); err = PTR_ERR(g); goto err_out; } list_for_each_entry(devfreq, &devfreq_list, node) { int ret; struct device *dev = devfreq->dev.parent;
if (!devfreq->governor) continue;
if (!strncmp(devfreq->governor->name, governor->name, DEVFREQ_NAME_LEN)) { ret = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_STOP, NULL); if (ret) { dev_warn(dev, "%s: Governor %s stop=%d\n", __func__, devfreq->governor->name, ret); } devfreq->governor = NULL; } }
list_del(&governor->node);err_out: mutex_unlock(&devfreq_list_lock);
return err;}EXPORT_SYMBOL(devfreq_remove_governor);
static ssize_t name_show(struct device *dev, struct device_attribute *attr, char *buf){ struct devfreq *df = to_devfreq(dev); return sprintf(buf, "%s\n", dev_name(df->dev.parent));}static DEVICE_ATTR_RO(name);
static ssize_t governor_show(struct device *dev, struct device_attribute *attr, char *buf){ struct devfreq *df = to_devfreq(dev);
if (!df->governor) return -EINVAL;
return sprintf(buf, "%s\n", df->governor->name);}
static ssize_t governor_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ struct devfreq *df = to_devfreq(dev); int ret; char str_governor[DEVFREQ_NAME_LEN + 1]; const struct devfreq_governor *governor, *prev_governor;
if (!df->governor) return -EINVAL;
ret = sscanf(buf, "%" __stringify(DEVFREQ_NAME_LEN) "s", str_governor); if (ret != 1) return -EINVAL;
mutex_lock(&devfreq_list_lock); governor = try_then_request_governor(str_governor); if (IS_ERR(governor)) { ret = PTR_ERR(governor); goto out; } if (df->governor == governor) { ret = 0; goto out; } else if (IS_SUPPORTED_FLAG(df->governor->flags, IMMUTABLE) || IS_SUPPORTED_FLAG(governor->flags, IMMUTABLE)) { ret = -EINVAL; goto out; }
/* * Stop the current governor and remove the specific sysfs files * which depend on current governor. */ ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL); if (ret) { dev_warn(dev, "%s: Governor %s not stopped(%d)\n", __func__, df->governor->name, ret); goto out; }
/* * Start the new governor and create the specific sysfs files * which depend on the new governor. */ prev_governor = df->governor; df->governor = governor; ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL); if (ret) { dev_warn(dev, "%s: Governor %s not started(%d)\n", __func__, df->governor->name, ret);
/* Restore previous governor */ df->governor = prev_governor; ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL); if (ret) { dev_err(dev, "%s: reverting to Governor %s failed (%d)\n", __func__, prev_governor->name, ret); df->governor = NULL; goto out; } }
/* * Create the sysfs files for the new governor. But if failed to start * the new governor, restore the sysfs files of previous governor. */ ret = sysfs_update_group(&df->dev.kobj, &gov_attr_group);
out: mutex_unlock(&devfreq_list_lock);
if (!ret) ret = count; return ret;}static DEVICE_ATTR_RW(governor);
static ssize_t available_governors_show(struct device *d, struct device_attribute *attr, char *buf){ struct devfreq *df = to_devfreq(d); ssize_t count = 0;
if (!df->governor) return -EINVAL;
mutex_lock(&devfreq_list_lock);
/* * The devfreq with immutable governor (e.g., passive) shows * only own governor. */ if (IS_SUPPORTED_FLAG(df->governor->flags, IMMUTABLE)) { count = scnprintf(&buf[count], DEVFREQ_NAME_LEN, "%s ", df->governor->name); /* * The devfreq device shows the registered governor except for * immutable governors such as passive governor . */ } else { struct devfreq_governor *governor;
list_for_each_entry(governor, &devfreq_governor_list, node) { if (IS_SUPPORTED_FLAG(governor->flags, IMMUTABLE)) continue; count += scnprintf(&buf[count], (PAGE_SIZE - count - 2), "%s ", governor->name); } }
mutex_unlock(&devfreq_list_lock);
/* Truncate the trailing space */ if (count) count--;
count += sprintf(&buf[count], "\n");
return count;}static DEVICE_ATTR_RO(available_governors);
static ssize_t cur_freq_show(struct device *dev, struct device_attribute *attr, char *buf){ unsigned long freq; struct devfreq *df = to_devfreq(dev);
if (!df->profile) return -EINVAL;
if (df->profile->get_cur_freq && !df->profile->get_cur_freq(df->dev.parent, &freq)) return sprintf(buf, "%lu\n", freq);
return sprintf(buf, "%lu\n", df->previous_freq);}static DEVICE_ATTR_RO(cur_freq);
static ssize_t target_freq_show(struct device *dev, struct device_attribute *attr, char *buf){ struct devfreq *df = to_devfreq(dev);
return sprintf(buf, "%lu\n", df->previous_freq);}static DEVICE_ATTR_RO(target_freq);
static ssize_t min_freq_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ struct devfreq *df = to_devfreq(dev); unsigned long value; int ret;
/* * Protect against theoretical sysfs writes between * device_add and dev_pm_qos_add_request */ if (!dev_pm_qos_request_active(&df->user_min_freq_req)) return -EAGAIN;
ret = sscanf(buf, "%lu", &value); if (ret != 1) return -EINVAL;
/* Round down to kHz for PM QoS */ ret = dev_pm_qos_update_request(&df->user_min_freq_req, value / HZ_PER_KHZ); if (ret < 0) return ret;
return count;}
static ssize_t min_freq_show(struct device *dev, struct device_attribute *attr, char *buf){ struct devfreq *df = to_devfreq(dev); unsigned long min_freq, max_freq;
mutex_lock(&df->lock); devfreq_get_freq_range(df, &min_freq, &max_freq); mutex_unlock(&df->lock);
return sprintf(buf, "%lu\n", min_freq);}static DEVICE_ATTR_RW(min_freq);
static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ struct devfreq *df = to_devfreq(dev); unsigned long value; int ret;
/* * Protect against theoretical sysfs writes between * device_add and dev_pm_qos_add_request */ if (!dev_pm_qos_request_active(&df->user_max_freq_req)) return -EINVAL;
ret = sscanf(buf, "%lu", &value); if (ret != 1) return -EINVAL;
/* * PM QoS frequencies are in kHz so we need to convert. Convert by * rounding upwards so that the acceptable interval never shrinks. * * For example if the user writes "666666666" to sysfs this value will * be converted to 666667 kHz and back to 666667000 Hz before an OPP * lookup, this ensures that an OPP of 666666666Hz is still accepted. * * A value of zero means "no limit". */ if (value) value = DIV_ROUND_UP(value, HZ_PER_KHZ); else value = PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE;
ret = dev_pm_qos_update_request(&df->user_max_freq_req, value); if (ret < 0) return ret;
return count;}
static ssize_t max_freq_show(struct device *dev, struct device_attribute *attr, char *buf){ struct devfreq *df = to_devfreq(dev); unsigned long min_freq, max_freq;
mutex_lock(&df->lock); devfreq_get_freq_range(df, &min_freq, &max_freq); mutex_unlock(&df->lock);
return sprintf(buf, "%lu\n", max_freq);}static DEVICE_ATTR_RW(max_freq);
static ssize_t available_frequencies_show(struct device *d, struct device_attribute *attr, char *buf){ struct devfreq *df = to_devfreq(d); ssize_t count = 0; int i;
if (!df->profile) return -EINVAL;
mutex_lock(&df->lock);
for (i = 0; i < df->max_state; i++) count += scnprintf(&buf[count], (PAGE_SIZE - count - 2), "%lu ", df->freq_table[i]);
mutex_unlock(&df->lock); /* Truncate the trailing space */ if (count) count--;
count += sprintf(&buf[count], "\n");
return count;}static DEVICE_ATTR_RO(available_frequencies);
static ssize_t trans_stat_show(struct device *dev, struct device_attribute *attr, char *buf){ struct devfreq *df = to_devfreq(dev); ssize_t len = 0; int i, j; unsigned int max_state;
if (!df->profile) return -EINVAL; max_state = df->max_state;
if (max_state == 0) return sysfs_emit(buf, "Not Supported.\n");
mutex_lock(&df->lock); if (!df->stop_polling && devfreq_update_status(df, df->previous_freq)) { mutex_unlock(&df->lock); return 0; } mutex_unlock(&df->lock);
len += sysfs_emit_at(buf, len, " From : To\n"); len += sysfs_emit_at(buf, len, " :"); for (i = 0; i < max_state; i++) { if (len >= PAGE_SIZE - 1) break; len += sysfs_emit_at(buf, len, "%10lu", df->freq_table[i]); }
if (len >= PAGE_SIZE - 1) return PAGE_SIZE - 1; len += sysfs_emit_at(buf, len, " time(ms)\n");
for (i = 0; i < max_state; i++) { if (len >= PAGE_SIZE - 1) break; if (df->freq_table[i] == df->previous_freq) len += sysfs_emit_at(buf, len, "*"); else len += sysfs_emit_at(buf, len, " "); if (len >= PAGE_SIZE - 1) break; len += sysfs_emit_at(buf, len, "%10lu:", df->freq_table[i]); for (j = 0; j < max_state; j++) { if (len >= PAGE_SIZE - 1) break; len += sysfs_emit_at(buf, len, "%10u", df->stats.trans_table[(i * max_state) + j]); } if (len >= PAGE_SIZE - 1) break; len += sysfs_emit_at(buf, len, "%10llu\n", (u64) jiffies64_to_msecs(df->stats.time_in_state[i])); }
if (len < PAGE_SIZE - 1) len += sysfs_emit_at(buf, len, "Total transition : %u\n", df->stats.total_trans); if (len >= PAGE_SIZE - 1) { pr_warn_once("devfreq transition table exceeds PAGE_SIZE. Disabling\n"); return -EFBIG; }
return len;}
static ssize_t trans_stat_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ struct devfreq *df = to_devfreq(dev); int err, value;
if (!df->profile) return -EINVAL;
if (df->max_state == 0) return count;
err = kstrtoint(buf, 10, &value); if (err || value != 0) return -EINVAL;
mutex_lock(&df->lock); memset(df->stats.time_in_state, 0, (df->max_state * sizeof(*df->stats.time_in_state))); memset(df->stats.trans_table, 0, array3_size(sizeof(unsigned int), df->max_state, df->max_state)); df->stats.total_trans = 0; df->stats.last_update = get_jiffies_64(); mutex_unlock(&df->lock);
return count;}static DEVICE_ATTR_RW(trans_stat);
static struct attribute *devfreq_attrs[] = { &dev_attr_name.attr, &dev_attr_governor.attr, &dev_attr_available_governors.attr, &dev_attr_cur_freq.attr, &dev_attr_available_frequencies.attr, &dev_attr_target_freq.attr, &dev_attr_min_freq.attr, &dev_attr_max_freq.attr, &dev_attr_trans_stat.attr, NULL,};
static ssize_t polling_interval_show(struct device *dev, struct device_attribute *attr, char *buf){ struct devfreq *df = to_devfreq(dev);
/* Protect against race between sysfs attrs update and read/write */ guard(mutex)(&devfreq_list_lock);
if (!df->profile || !df->governor || !IS_SUPPORTED_ATTR(df->governor->attrs, POLLING_INTERVAL)) return -EINVAL;
return sprintf(buf, "%d\n", df->profile->polling_ms);}
static ssize_t polling_interval_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ struct devfreq *df = to_devfreq(dev); unsigned int value; int ret;
guard(mutex)(&devfreq_list_lock);
if (!df->governor || !IS_SUPPORTED_ATTR(df->governor->attrs, POLLING_INTERVAL)) return -EINVAL;
ret = sscanf(buf, "%u", &value); if (ret != 1) return -EINVAL;
df->governor->event_handler(df, DEVFREQ_GOV_UPDATE_INTERVAL, &value); ret = count;
return ret;}static DEVICE_ATTR_RW(polling_interval);
static ssize_t timer_show(struct device *dev, struct device_attribute *attr, char *buf){ struct devfreq *df = to_devfreq(dev);
guard(mutex)(&devfreq_list_lock);
if (!df->profile || !df->governor || !IS_SUPPORTED_ATTR(df->governor->attrs, TIMER)) return -EINVAL;
return sprintf(buf, "%s\n", timer_name[df->profile->timer]);}
static ssize_t timer_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ struct devfreq *df = to_devfreq(dev); char str_timer[DEVFREQ_NAME_LEN + 1]; int timer = -1; int ret = 0, i;
guard(mutex)(&devfreq_list_lock);
if (!df->governor || !df->profile || !IS_SUPPORTED_ATTR(df->governor->attrs, TIMER)) return -EINVAL;
ret = sscanf(buf, "%16s", str_timer); if (ret != 1) return -EINVAL;
for (i = 0; i < DEVFREQ_TIMER_NUM; i++) { if (!strncmp(timer_name[i], str_timer, DEVFREQ_NAME_LEN)) { timer = i; break; } }
if (timer < 0) { ret = -EINVAL; goto out; }
if (df->profile->timer == timer) { ret = 0; goto out; }
mutex_lock(&df->lock); df->profile->timer = timer; mutex_unlock(&df->lock);
ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL); if (ret) { dev_warn(dev, "%s: Governor %s not stopped(%d)\n", __func__, df->governor->name, ret); goto out; }
ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL); if (ret) dev_warn(dev, "%s: Governor %s not started(%d)\n", __func__, df->governor->name, ret);out: return ret ? ret : count;}static DEVICE_ATTR_RW(timer);
static struct attribute *governor_attrs[] = { &dev_attr_polling_interval.attr, &dev_attr_timer.attr, NULL};
static umode_t gov_attr_visible(struct kobject *kobj, struct attribute *attr, int n){ struct device *dev = kobj_to_dev(kobj); struct devfreq *df = to_devfreq(dev);
if (!df->governor || !df->governor->attrs) return 0;
if (attr == &dev_attr_polling_interval.attr && IS_SUPPORTED_ATTR(df->governor->attrs, POLLING_INTERVAL)) return attr->mode;
if (attr == &dev_attr_timer.attr && IS_SUPPORTED_ATTR(df->governor->attrs, TIMER)) return attr->mode;
return 0;}
static const struct attribute_group devfreq_group = { .attrs = devfreq_attrs,};
static const struct attribute_group gov_attr_group = { .attrs = governor_attrs, .is_visible = gov_attr_visible,};
static const struct attribute_group *devfreq_groups[] = { &devfreq_group, &gov_attr_group, NULL};
/** * devfreq_summary_show() - Show the summary of the devfreq devices * @s: seq_file instance to show the summary of devfreq devices * @data: not used * * Show the summary of the devfreq devices via 'devfreq_summary' debugfs file. * It helps that user can know the detailed information of the devfreq devices. * * Return 0 always because it shows the information without any data change. */static int devfreq_summary_show(struct seq_file *s, void *data){ struct devfreq *devfreq; struct devfreq *p_devfreq = NULL; unsigned long cur_freq, min_freq, max_freq; unsigned int polling_ms; unsigned int timer;
seq_printf(s, "%-30s %-30s %-15s %-10s %10s %12s %12s %12s\n", "dev", "parent_dev", "governor", "timer", "polling_ms", "cur_freq_Hz", "min_freq_Hz", "max_freq_Hz"); seq_printf(s, "%30s %30s %15s %10s %10s %12s %12s %12s\n", "------------------------------", "------------------------------", "---------------", "----------", "----------", "------------", "------------", "------------");
mutex_lock(&devfreq_list_lock);
list_for_each_entry_reverse(devfreq, &devfreq_list, node) {#if IS_ENABLED(CONFIG_DEVFREQ_GOV_PASSIVE) if (!strncmp(devfreq->governor->name, DEVFREQ_GOV_PASSIVE, DEVFREQ_NAME_LEN)) { struct devfreq_passive_data *data = devfreq->data;
if (data) p_devfreq = data->parent; } else { p_devfreq = NULL; }#endif
mutex_lock(&devfreq->lock); cur_freq = devfreq->previous_freq; devfreq_get_freq_range(devfreq, &min_freq, &max_freq); timer = devfreq->profile->timer;
if (IS_SUPPORTED_ATTR(devfreq->governor->attrs, POLLING_INTERVAL)) polling_ms = devfreq->profile->polling_ms; else polling_ms = 0; mutex_unlock(&devfreq->lock);
seq_printf(s, "%-30s %-30s %-15s %-10s %10d %12ld %12ld %12ld\n", dev_name(&devfreq->dev), p_devfreq ? dev_name(&p_devfreq->dev) : "null", devfreq->governor->name, polling_ms ? timer_name[timer] : "null", polling_ms, cur_freq, min_freq, max_freq); }
mutex_unlock(&devfreq_list_lock);
return 0;}DEFINE_SHOW_ATTRIBUTE(devfreq_summary);
static int __init devfreq_init(void){ devfreq_class = class_create("devfreq"); if (IS_ERR(devfreq_class)) { pr_err("%s: couldn't create class\n", __FILE__); return PTR_ERR(devfreq_class); }
devfreq_wq = create_freezable_workqueue("devfreq_wq"); if (!devfreq_wq) { class_destroy(devfreq_class); pr_err("%s: couldn't create workqueue\n", __FILE__); return -ENOMEM; } devfreq_class->dev_groups = devfreq_groups;
devfreq_debugfs = debugfs_create_dir("devfreq", NULL); debugfs_create_file("devfreq_summary", 0444, devfreq_debugfs, NULL, &devfreq_summary_fops);
return 0;}subsys_initcall(devfreq_init);
/* * The following are helper functions for devfreq user device drivers with * OPP framework. */
/** * devfreq_recommended_opp() - Helper function to get proper OPP for the * freq value given to target callback. * @dev: The devfreq user device. (parent of devfreq) * @freq: The frequency given to target function * @flags: Flags handed from devfreq framework. * * The callers are required to call dev_pm_opp_put() for the returned OPP after * use. */struct dev_pm_opp *devfreq_recommended_opp(struct device *dev, unsigned long *freq, u32 flags){ struct dev_pm_opp *opp;
if (flags & DEVFREQ_FLAG_LEAST_UPPER_BOUND) { /* The freq is an upper bound. opp should be lower */ opp = dev_pm_opp_find_freq_floor_indexed(dev, freq, 0);
/* If not available, use the closest opp */ if (opp == ERR_PTR(-ERANGE)) opp = dev_pm_opp_find_freq_ceil_indexed(dev, freq, 0); } else { /* The freq is an lower bound. opp should be higher */ opp = dev_pm_opp_find_freq_ceil_indexed(dev, freq, 0);
/* If not available, use the closest opp */ if (opp == ERR_PTR(-ERANGE)) opp = dev_pm_opp_find_freq_floor_indexed(dev, freq, 0); }
return opp;}EXPORT_SYMBOL(devfreq_recommended_opp);
/** * devfreq_register_opp_notifier() - Helper function to get devfreq notified * for any changes in the OPP availability * changes * @dev: The devfreq user device. (parent of devfreq) * @devfreq: The devfreq object. */int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq){ return dev_pm_opp_register_notifier(dev, &devfreq->nb);}EXPORT_SYMBOL(devfreq_register_opp_notifier);
/** * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq * notified for any changes in the OPP * availability changes anymore. * @dev: The devfreq user device. (parent of devfreq) * @devfreq: The devfreq object. * * At exit() callback of devfreq_dev_profile, this must be included if * devfreq_recommended_opp is used. */int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq){ return dev_pm_opp_unregister_notifier(dev, &devfreq->nb);}EXPORT_SYMBOL(devfreq_unregister_opp_notifier);
static void devm_devfreq_opp_release(struct device *dev, void *res){ devfreq_unregister_opp_notifier(dev, *(struct devfreq **)res);}
/** * devm_devfreq_register_opp_notifier() - Resource-managed * devfreq_register_opp_notifier() * @dev: The devfreq user device. (parent of devfreq) * @devfreq: The devfreq object. */int devm_devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq){ struct devfreq **ptr; int ret;
ptr = devres_alloc(devm_devfreq_opp_release, sizeof(*ptr), GFP_KERNEL); if (!ptr) return -ENOMEM;
ret = devfreq_register_opp_notifier(dev, devfreq); if (ret) { devres_free(ptr); return ret; }
*ptr = devfreq; devres_add(dev, ptr);
return 0;}EXPORT_SYMBOL(devm_devfreq_register_opp_notifier);
/** * devm_devfreq_unregister_opp_notifier() - Resource-managed * devfreq_unregister_opp_notifier() * @dev: The devfreq user device. (parent of devfreq) * @devfreq: The devfreq object. */void devm_devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq){ WARN_ON(devres_release(dev, devm_devfreq_opp_release, devm_devfreq_dev_match, devfreq));}EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier);
/** * devfreq_register_notifier() - Register a driver with devfreq * @devfreq: The devfreq object. * @nb: The notifier block to register. * @list: DEVFREQ_TRANSITION_NOTIFIER. */int devfreq_register_notifier(struct devfreq *devfreq, struct notifier_block *nb, unsigned int list){ int ret = 0;
if (!devfreq) return -EINVAL;
switch (list) { case DEVFREQ_TRANSITION_NOTIFIER: ret = srcu_notifier_chain_register( &devfreq->transition_notifier_list, nb); break; default: ret = -EINVAL; }
return ret;}EXPORT_SYMBOL(devfreq_register_notifier);
/* * devfreq_unregister_notifier() - Unregister a driver with devfreq * @devfreq: The devfreq object. * @nb: The notifier block to be unregistered. * @list: DEVFREQ_TRANSITION_NOTIFIER. */int devfreq_unregister_notifier(struct devfreq *devfreq, struct notifier_block *nb, unsigned int list){ int ret = 0;
if (!devfreq) return -EINVAL;
switch (list) { case DEVFREQ_TRANSITION_NOTIFIER: ret = srcu_notifier_chain_unregister( &devfreq->transition_notifier_list, nb); break; default: ret = -EINVAL; }
return ret;}EXPORT_SYMBOL(devfreq_unregister_notifier);
struct devfreq_notifier_devres { struct devfreq *devfreq; struct notifier_block *nb; unsigned int list;};
static void devm_devfreq_notifier_release(struct device *dev, void *res){ struct devfreq_notifier_devres *this = res;
devfreq_unregister_notifier(this->devfreq, this->nb, this->list);}
/** * devm_devfreq_register_notifier() * - Resource-managed devfreq_register_notifier() * @dev: The devfreq user device. (parent of devfreq) * @devfreq: The devfreq object. * @nb: The notifier block to be unregistered. * @list: DEVFREQ_TRANSITION_NOTIFIER. */int devm_devfreq_register_notifier(struct device *dev, struct devfreq *devfreq, struct notifier_block *nb, unsigned int list){ struct devfreq_notifier_devres *ptr; int ret;
ptr = devres_alloc(devm_devfreq_notifier_release, sizeof(*ptr), GFP_KERNEL); if (!ptr) return -ENOMEM;
ret = devfreq_register_notifier(devfreq, nb, list); if (ret) { devres_free(ptr); return ret; }
ptr->devfreq = devfreq; ptr->nb = nb; ptr->list = list; devres_add(dev, ptr);
return 0;}EXPORT_SYMBOL(devm_devfreq_register_notifier);
/** * devm_devfreq_unregister_notifier() * - Resource-managed devfreq_unregister_notifier() * @dev: The devfreq user device. (parent of devfreq) * @devfreq: The devfreq object. * @nb: The notifier block to be unregistered. * @list: DEVFREQ_TRANSITION_NOTIFIER. */void devm_devfreq_unregister_notifier(struct device *dev, struct devfreq *devfreq, struct notifier_block *nb, unsigned int list){ WARN_ON(devres_release(dev, devm_devfreq_notifier_release, devm_devfreq_dev_match, devfreq));}EXPORT_SYMBOL(devm_devfreq_unregister_notifier);