123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178 |
- /*
- * drm_irq.c IRQ and vblank support
- *
- * \author Rickard E. (Rik) Faith <[email protected]>
- * \author Gareth Hughes <[email protected]>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
- #include <linux/export.h>
- #include <linux/kthread.h>
- #include <linux/moduleparam.h>
- #include <drm/drm_crtc.h>
- #include <drm/drm_drv.h>
- #include <drm/drm_framebuffer.h>
- #include <drm/drm_managed.h>
- #include <drm/drm_modeset_helper_vtables.h>
- #include <drm/drm_print.h>
- #include <drm/drm_vblank.h>
- #include "drm_internal.h"
- #include "drm_trace.h"
- /**
- * DOC: vblank handling
- *
- * From the computer's perspective, every time the monitor displays
- * a new frame the scanout engine has "scanned out" the display image
- * from top to bottom, one row of pixels at a time. The current row
- * of pixels is referred to as the current scanline.
- *
- * In addition to the display's visible area, there's usually a couple of
- * extra scanlines which aren't actually displayed on the screen.
- * These extra scanlines don't contain image data and are occasionally used
- * for features like audio and infoframes. The region made up of these
- * scanlines is referred to as the vertical blanking region, or vblank for
- * short.
- *
- * For historical reference, the vertical blanking period was designed to
- * give the electron gun (on CRTs) enough time to move back to the top of
- * the screen to start scanning out the next frame. Similar for horizontal
- * blanking periods. They were designed to give the electron gun enough
- * time to move back to the other side of the screen to start scanning the
- * next scanline.
- *
- * ::
- *
- *
- * physical → ⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽
- * top of | |
- * display | |
- * | New frame |
- * | |
- * |↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓|
- * |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~| ← Scanline,
- * |↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓| updates the
- * | | frame as it
- * | | travels down
- * | | ("scan out")
- * | Old frame |
- * | |
- * | |
- * | |
- * | | physical
- * | | bottom of
- * vertical |⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽| ← display
- * blanking ┆xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx┆
- * region → ┆xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx┆
- * ┆xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx┆
- * start of → ⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽
- * new frame
- *
- * "Physical top of display" is the reference point for the high-precision/
- * corrected timestamp.
- *
- * On a lot of display hardware, programming needs to take effect during the
- * vertical blanking period so that settings like gamma, the image buffer
- * buffer to be scanned out, etc. can safely be changed without showing
- * any visual artifacts on the screen. In some unforgiving hardware, some of
- * this programming has to both start and end in the same vblank. To help
- * with the timing of the hardware programming, an interrupt is usually
- * available to notify the driver when it can start the updating of registers.
- * The interrupt is in this context named the vblank interrupt.
- *
- * The vblank interrupt may be fired at different points depending on the
- * hardware. Some hardware implementations will fire the interrupt when the
- * new frame start, other implementations will fire the interrupt at different
- * points in time.
- *
- * Vertical blanking plays a major role in graphics rendering. To achieve
- * tear-free display, users must synchronize page flips and/or rendering to
- * vertical blanking. The DRM API offers ioctls to perform page flips
- * synchronized to vertical blanking and wait for vertical blanking.
- *
- * The DRM core handles most of the vertical blanking management logic, which
- * involves filtering out spurious interrupts, keeping race-free blanking
- * counters, coping with counter wrap-around and resets and keeping use counts.
- * It relies on the driver to generate vertical blanking interrupts and
- * optionally provide a hardware vertical blanking counter.
- *
- * Drivers must initialize the vertical blanking handling core with a call to
- * drm_vblank_init(). Minimally, a driver needs to implement
- * &drm_crtc_funcs.enable_vblank and &drm_crtc_funcs.disable_vblank plus call
- * drm_crtc_handle_vblank() in its vblank interrupt handler for working vblank
- * support.
- *
- * Vertical blanking interrupts can be enabled by the DRM core or by drivers
- * themselves (for instance to handle page flipping operations). The DRM core
- * maintains a vertical blanking use count to ensure that the interrupts are not
- * disabled while a user still needs them. To increment the use count, drivers
- * call drm_crtc_vblank_get() and release the vblank reference again with
- * drm_crtc_vblank_put(). In between these two calls vblank interrupts are
- * guaranteed to be enabled.
- *
- * On many hardware disabling the vblank interrupt cannot be done in a race-free
- * manner, see &drm_driver.vblank_disable_immediate and
- * &drm_driver.max_vblank_count. In that case the vblank core only disables the
- * vblanks after a timer has expired, which can be configured through the
- * ``vblankoffdelay`` module parameter.
- *
- * Drivers for hardware without support for vertical-blanking interrupts
- * must not call drm_vblank_init(). For such drivers, atomic helpers will
- * automatically generate fake vblank events as part of the display update.
- * This functionality also can be controlled by the driver by enabling and
- * disabling struct drm_crtc_state.no_vblank.
- */
- /* Retry timestamp calculation up to 3 times to satisfy
- * drm_timestamp_precision before giving up.
- */
- #define DRM_TIMESTAMP_MAXRETRIES 3
- /* Threshold in nanoseconds for detection of redundant
- * vblank irq in drm_handle_vblank(). 1 msec should be ok.
- */
- #define DRM_REDUNDANT_VBLIRQ_THRESH_NS 1000000
- static bool
- drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe,
- ktime_t *tvblank, bool in_vblank_irq);
- static unsigned int drm_timestamp_precision = 20; /* Default to 20 usecs. */
- static int drm_vblank_offdelay = 5000; /* Default to 5000 msecs. */
- module_param_named(vblankoffdelay, drm_vblank_offdelay, int, 0600);
- module_param_named(timestamp_precision_usec, drm_timestamp_precision, int, 0600);
- MODULE_PARM_DESC(vblankoffdelay, "Delay until vblank irq auto-disable [msecs] (0: never disable, <0: disable immediately)");
- MODULE_PARM_DESC(timestamp_precision_usec, "Max. error on timestamps [usecs]");
- static void store_vblank(struct drm_device *dev, unsigned int pipe,
- u32 vblank_count_inc,
- ktime_t t_vblank, u32 last)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- assert_spin_locked(&dev->vblank_time_lock);
- vblank->last = last;
- write_seqlock(&vblank->seqlock);
- vblank->time = t_vblank;
- atomic64_add(vblank_count_inc, &vblank->count);
- write_sequnlock(&vblank->seqlock);
- }
- static u32 drm_max_vblank_count(struct drm_device *dev, unsigned int pipe)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- return vblank->max_vblank_count ?: dev->max_vblank_count;
- }
- /*
- * "No hw counter" fallback implementation of .get_vblank_counter() hook,
- * if there is no usable hardware frame counter available.
- */
- static u32 drm_vblank_no_hw_counter(struct drm_device *dev, unsigned int pipe)
- {
- drm_WARN_ON_ONCE(dev, drm_max_vblank_count(dev, pipe) != 0);
- return 0;
- }
- static u32 __get_vblank_counter(struct drm_device *dev, unsigned int pipe)
- {
- if (drm_core_check_feature(dev, DRIVER_MODESET)) {
- struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
- if (drm_WARN_ON(dev, !crtc))
- return 0;
- if (crtc->funcs->get_vblank_counter)
- return crtc->funcs->get_vblank_counter(crtc);
- }
- #ifdef CONFIG_DRM_LEGACY
- else if (dev->driver->get_vblank_counter) {
- return dev->driver->get_vblank_counter(dev, pipe);
- }
- #endif
- return drm_vblank_no_hw_counter(dev, pipe);
- }
- /*
- * Reset the stored timestamp for the current vblank count to correspond
- * to the last vblank occurred.
- *
- * Only to be called from drm_crtc_vblank_on().
- *
- * Note: caller must hold &drm_device.vbl_lock since this reads & writes
- * device vblank fields.
- */
- static void drm_reset_vblank_timestamp(struct drm_device *dev, unsigned int pipe)
- {
- u32 cur_vblank;
- bool rc;
- ktime_t t_vblank;
- int count = DRM_TIMESTAMP_MAXRETRIES;
- spin_lock(&dev->vblank_time_lock);
- /*
- * sample the current counter to avoid random jumps
- * when drm_vblank_enable() applies the diff
- */
- do {
- cur_vblank = __get_vblank_counter(dev, pipe);
- rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, false);
- } while (cur_vblank != __get_vblank_counter(dev, pipe) && --count > 0);
- /*
- * Only reinitialize corresponding vblank timestamp if high-precision query
- * available and didn't fail. Otherwise reinitialize delayed at next vblank
- * interrupt and assign 0 for now, to mark the vblanktimestamp as invalid.
- */
- if (!rc)
- t_vblank = 0;
- /*
- * +1 to make sure user will never see the same
- * vblank counter value before and after a modeset
- */
- store_vblank(dev, pipe, 1, t_vblank, cur_vblank);
- spin_unlock(&dev->vblank_time_lock);
- }
- /*
- * Call back into the driver to update the appropriate vblank counter
- * (specified by @pipe). Deal with wraparound, if it occurred, and
- * update the last read value so we can deal with wraparound on the next
- * call if necessary.
- *
- * Only necessary when going from off->on, to account for frames we
- * didn't get an interrupt for.
- *
- * Note: caller must hold &drm_device.vbl_lock since this reads & writes
- * device vblank fields.
- */
- static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe,
- bool in_vblank_irq)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- u32 cur_vblank, diff;
- bool rc;
- ktime_t t_vblank;
- int count = DRM_TIMESTAMP_MAXRETRIES;
- int framedur_ns = vblank->framedur_ns;
- u32 max_vblank_count = drm_max_vblank_count(dev, pipe);
- /*
- * Interrupts were disabled prior to this call, so deal with counter
- * wrap if needed.
- * NOTE! It's possible we lost a full dev->max_vblank_count + 1 events
- * here if the register is small or we had vblank interrupts off for
- * a long time.
- *
- * We repeat the hardware vblank counter & timestamp query until
- * we get consistent results. This to prevent races between gpu
- * updating its hardware counter while we are retrieving the
- * corresponding vblank timestamp.
- */
- do {
- cur_vblank = __get_vblank_counter(dev, pipe);
- rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, in_vblank_irq);
- } while (cur_vblank != __get_vblank_counter(dev, pipe) && --count > 0);
- if (max_vblank_count) {
- /* trust the hw counter when it's around */
- diff = (cur_vblank - vblank->last) & max_vblank_count;
- } else if (rc && framedur_ns) {
- u64 diff_ns = ktime_to_ns(ktime_sub(t_vblank, vblank->time));
- /*
- * Figure out how many vblanks we've missed based
- * on the difference in the timestamps and the
- * frame/field duration.
- */
- drm_dbg_vbl(dev, "crtc %u: Calculating number of vblanks."
- " diff_ns = %lld, framedur_ns = %d)\n",
- pipe, (long long)diff_ns, framedur_ns);
- diff = DIV_ROUND_CLOSEST_ULL(diff_ns, framedur_ns);
- if (diff == 0 && in_vblank_irq)
- drm_dbg_vbl(dev, "crtc %u: Redundant vblirq ignored\n",
- pipe);
- } else {
- /* some kind of default for drivers w/o accurate vbl timestamping */
- diff = in_vblank_irq ? 1 : 0;
- }
- /*
- * Within a drm_vblank_pre_modeset - drm_vblank_post_modeset
- * interval? If so then vblank irqs keep running and it will likely
- * happen that the hardware vblank counter is not trustworthy as it
- * might reset at some point in that interval and vblank timestamps
- * are not trustworthy either in that interval. Iow. this can result
- * in a bogus diff >> 1 which must be avoided as it would cause
- * random large forward jumps of the software vblank counter.
- */
- if (diff > 1 && (vblank->inmodeset & 0x2)) {
- drm_dbg_vbl(dev,
- "clamping vblank bump to 1 on crtc %u: diffr=%u"
- " due to pre-modeset.\n", pipe, diff);
- diff = 1;
- }
- drm_dbg_vbl(dev, "updating vblank count on crtc %u:"
- " current=%llu, diff=%u, hw=%u hw_last=%u\n",
- pipe, (unsigned long long)atomic64_read(&vblank->count),
- diff, cur_vblank, vblank->last);
- if (diff == 0) {
- drm_WARN_ON_ONCE(dev, cur_vblank != vblank->last);
- return;
- }
- /*
- * Only reinitialize corresponding vblank timestamp if high-precision query
- * available and didn't fail, or we were called from the vblank interrupt.
- * Otherwise reinitialize delayed at next vblank interrupt and assign 0
- * for now, to mark the vblanktimestamp as invalid.
- */
- if (!rc && !in_vblank_irq)
- t_vblank = 0;
- store_vblank(dev, pipe, diff, t_vblank, cur_vblank);
- }
- u64 drm_vblank_count(struct drm_device *dev, unsigned int pipe)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- u64 count;
- if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
- return 0;
- count = atomic64_read(&vblank->count);
- /*
- * This read barrier corresponds to the implicit write barrier of the
- * write seqlock in store_vblank(). Note that this is the only place
- * where we need an explicit barrier, since all other access goes
- * through drm_vblank_count_and_time(), which already has the required
- * read barrier curtesy of the read seqlock.
- */
- smp_rmb();
- return count;
- }
- /**
- * drm_crtc_accurate_vblank_count - retrieve the master vblank counter
- * @crtc: which counter to retrieve
- *
- * This function is similar to drm_crtc_vblank_count() but this function
- * interpolates to handle a race with vblank interrupts using the high precision
- * timestamping support.
- *
- * This is mostly useful for hardware that can obtain the scanout position, but
- * doesn't have a hardware frame counter.
- */
- u64 drm_crtc_accurate_vblank_count(struct drm_crtc *crtc)
- {
- struct drm_device *dev = crtc->dev;
- unsigned int pipe = drm_crtc_index(crtc);
- u64 vblank;
- unsigned long flags;
- drm_WARN_ONCE(dev, drm_debug_enabled(DRM_UT_VBL) &&
- !crtc->funcs->get_vblank_timestamp,
- "This function requires support for accurate vblank timestamps.");
- spin_lock_irqsave(&dev->vblank_time_lock, flags);
- drm_update_vblank_count(dev, pipe, false);
- vblank = drm_vblank_count(dev, pipe);
- spin_unlock_irqrestore(&dev->vblank_time_lock, flags);
- return vblank;
- }
- EXPORT_SYMBOL(drm_crtc_accurate_vblank_count);
- static void __disable_vblank(struct drm_device *dev, unsigned int pipe)
- {
- if (drm_core_check_feature(dev, DRIVER_MODESET)) {
- struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
- if (drm_WARN_ON(dev, !crtc))
- return;
- if (crtc->funcs->disable_vblank)
- crtc->funcs->disable_vblank(crtc);
- }
- #ifdef CONFIG_DRM_LEGACY
- else {
- dev->driver->disable_vblank(dev, pipe);
- }
- #endif
- }
- /*
- * Disable vblank irq's on crtc, make sure that last vblank count
- * of hardware and corresponding consistent software vblank counter
- * are preserved, even if there are any spurious vblank irq's after
- * disable.
- */
- void drm_vblank_disable_and_save(struct drm_device *dev, unsigned int pipe)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- unsigned long irqflags;
- assert_spin_locked(&dev->vbl_lock);
- /* Prevent vblank irq processing while disabling vblank irqs,
- * so no updates of timestamps or count can happen after we've
- * disabled. Needed to prevent races in case of delayed irq's.
- */
- spin_lock_irqsave(&dev->vblank_time_lock, irqflags);
- /*
- * Update vblank count and disable vblank interrupts only if the
- * interrupts were enabled. This avoids calling the ->disable_vblank()
- * operation in atomic context with the hardware potentially runtime
- * suspended.
- */
- if (!vblank->enabled)
- goto out;
- /*
- * Update the count and timestamp to maintain the
- * appearance that the counter has been ticking all along until
- * this time. This makes the count account for the entire time
- * between drm_crtc_vblank_on() and drm_crtc_vblank_off().
- */
- drm_update_vblank_count(dev, pipe, false);
- __disable_vblank(dev, pipe);
- vblank->enabled = false;
- out:
- spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags);
- }
- static void vblank_disable_fn(struct timer_list *t)
- {
- struct drm_vblank_crtc *vblank = from_timer(vblank, t, disable_timer);
- struct drm_device *dev = vblank->dev;
- unsigned int pipe = vblank->pipe;
- unsigned long irqflags;
- spin_lock_irqsave(&dev->vbl_lock, irqflags);
- if (atomic_read(&vblank->refcount) == 0 && vblank->enabled) {
- drm_dbg_core(dev, "disabling vblank on crtc %u\n", pipe);
- drm_vblank_disable_and_save(dev, pipe);
- }
- spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
- }
- static void drm_vblank_init_release(struct drm_device *dev, void *ptr)
- {
- struct drm_vblank_crtc *vblank = ptr;
- drm_WARN_ON(dev, READ_ONCE(vblank->enabled) &&
- drm_core_check_feature(dev, DRIVER_MODESET));
- drm_vblank_destroy_worker(vblank);
- del_timer_sync(&vblank->disable_timer);
- }
- /**
- * drm_vblank_init - initialize vblank support
- * @dev: DRM device
- * @num_crtcs: number of CRTCs supported by @dev
- *
- * This function initializes vblank support for @num_crtcs display pipelines.
- * Cleanup is handled automatically through a cleanup function added with
- * drmm_add_action_or_reset().
- *
- * Returns:
- * Zero on success or a negative error code on failure.
- */
- int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs)
- {
- int ret;
- unsigned int i;
- spin_lock_init(&dev->vbl_lock);
- spin_lock_init(&dev->vblank_time_lock);
- dev->vblank = drmm_kcalloc(dev, num_crtcs, sizeof(*dev->vblank), GFP_KERNEL);
- if (!dev->vblank)
- return -ENOMEM;
- dev->num_crtcs = num_crtcs;
- for (i = 0; i < num_crtcs; i++) {
- struct drm_vblank_crtc *vblank = &dev->vblank[i];
- vblank->dev = dev;
- vblank->pipe = i;
- init_waitqueue_head(&vblank->queue);
- timer_setup(&vblank->disable_timer, vblank_disable_fn, 0);
- seqlock_init(&vblank->seqlock);
- ret = drmm_add_action_or_reset(dev, drm_vblank_init_release,
- vblank);
- if (ret)
- return ret;
- ret = drm_vblank_worker_init(vblank);
- if (ret)
- return ret;
- }
- return 0;
- }
- EXPORT_SYMBOL(drm_vblank_init);
- /**
- * drm_dev_has_vblank - test if vblanking has been initialized for
- * a device
- * @dev: the device
- *
- * Drivers may call this function to test if vblank support is
- * initialized for a device. For most hardware this means that vblanking
- * can also be enabled.
- *
- * Atomic helpers use this function to initialize
- * &drm_crtc_state.no_vblank. See also drm_atomic_helper_check_modeset().
- *
- * Returns:
- * True if vblanking has been initialized for the given device, false
- * otherwise.
- */
- bool drm_dev_has_vblank(const struct drm_device *dev)
- {
- return dev->num_crtcs != 0;
- }
- EXPORT_SYMBOL(drm_dev_has_vblank);
- /**
- * drm_crtc_vblank_waitqueue - get vblank waitqueue for the CRTC
- * @crtc: which CRTC's vblank waitqueue to retrieve
- *
- * This function returns a pointer to the vblank waitqueue for the CRTC.
- * Drivers can use this to implement vblank waits using wait_event() and related
- * functions.
- */
- wait_queue_head_t *drm_crtc_vblank_waitqueue(struct drm_crtc *crtc)
- {
- return &crtc->dev->vblank[drm_crtc_index(crtc)].queue;
- }
- EXPORT_SYMBOL(drm_crtc_vblank_waitqueue);
- /**
- * drm_calc_timestamping_constants - calculate vblank timestamp constants
- * @crtc: drm_crtc whose timestamp constants should be updated.
- * @mode: display mode containing the scanout timings
- *
- * Calculate and store various constants which are later needed by vblank and
- * swap-completion timestamping, e.g, by
- * drm_crtc_vblank_helper_get_vblank_timestamp(). They are derived from
- * CRTC's true scanout timing, so they take things like panel scaling or
- * other adjustments into account.
- */
- void drm_calc_timestamping_constants(struct drm_crtc *crtc,
- const struct drm_display_mode *mode)
- {
- struct drm_device *dev = crtc->dev;
- unsigned int pipe = drm_crtc_index(crtc);
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- int linedur_ns = 0, framedur_ns = 0;
- int dotclock = mode->crtc_clock;
- if (!drm_dev_has_vblank(dev))
- return;
- if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
- return;
- /* Valid dotclock? */
- if (dotclock > 0) {
- int frame_size = mode->crtc_htotal * mode->crtc_vtotal;
- /*
- * Convert scanline length in pixels and video
- * dot clock to line duration and frame duration
- * in nanoseconds:
- */
- linedur_ns = div_u64((u64) mode->crtc_htotal * 1000000, dotclock);
- framedur_ns = div_u64((u64) frame_size * 1000000, dotclock);
- /*
- * Fields of interlaced scanout modes are only half a frame duration.
- */
- if (mode->flags & DRM_MODE_FLAG_INTERLACE)
- framedur_ns /= 2;
- } else {
- drm_err(dev, "crtc %u: Can't calculate constants, dotclock = 0!\n",
- crtc->base.id);
- }
- vblank->linedur_ns = linedur_ns;
- vblank->framedur_ns = framedur_ns;
- drm_mode_copy(&vblank->hwmode, mode);
- drm_dbg_core(dev,
- "crtc %u: hwmode: htotal %d, vtotal %d, vdisplay %d\n",
- crtc->base.id, mode->crtc_htotal,
- mode->crtc_vtotal, mode->crtc_vdisplay);
- drm_dbg_core(dev, "crtc %u: clock %d kHz framedur %d linedur %d\n",
- crtc->base.id, dotclock, framedur_ns, linedur_ns);
- }
- EXPORT_SYMBOL(drm_calc_timestamping_constants);
- /**
- * drm_crtc_vblank_helper_get_vblank_timestamp_internal - precise vblank
- * timestamp helper
- * @crtc: CRTC whose vblank timestamp to retrieve
- * @max_error: Desired maximum allowable error in timestamps (nanosecs)
- * On return contains true maximum error of timestamp
- * @vblank_time: Pointer to time which should receive the timestamp
- * @in_vblank_irq:
- * True when called from drm_crtc_handle_vblank(). Some drivers
- * need to apply some workarounds for gpu-specific vblank irq quirks
- * if flag is set.
- * @get_scanout_position:
- * Callback function to retrieve the scanout position. See
- * @struct drm_crtc_helper_funcs.get_scanout_position.
- *
- * Implements calculation of exact vblank timestamps from given drm_display_mode
- * timings and current video scanout position of a CRTC.
- *
- * The current implementation only handles standard video modes. For double scan
- * and interlaced modes the driver is supposed to adjust the hardware mode
- * (taken from &drm_crtc_state.adjusted mode for atomic modeset drivers) to
- * match the scanout position reported.
- *
- * Note that atomic drivers must call drm_calc_timestamping_constants() before
- * enabling a CRTC. The atomic helpers already take care of that in
- * drm_atomic_helper_calc_timestamping_constants().
- *
- * Returns:
- *
- * Returns true on success, and false on failure, i.e. when no accurate
- * timestamp could be acquired.
- */
- bool
- drm_crtc_vblank_helper_get_vblank_timestamp_internal(
- struct drm_crtc *crtc, int *max_error, ktime_t *vblank_time,
- bool in_vblank_irq,
- drm_vblank_get_scanout_position_func get_scanout_position)
- {
- struct drm_device *dev = crtc->dev;
- unsigned int pipe = crtc->index;
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- struct timespec64 ts_etime, ts_vblank_time;
- ktime_t stime, etime;
- bool vbl_status;
- const struct drm_display_mode *mode;
- int vpos, hpos, i;
- int delta_ns, duration_ns;
- if (pipe >= dev->num_crtcs) {
- drm_err(dev, "Invalid crtc %u\n", pipe);
- return false;
- }
- /* Scanout position query not supported? Should not happen. */
- if (!get_scanout_position) {
- drm_err(dev, "Called from CRTC w/o get_scanout_position()!?\n");
- return false;
- }
- if (drm_drv_uses_atomic_modeset(dev))
- mode = &vblank->hwmode;
- else
- mode = &crtc->hwmode;
- /* If mode timing undefined, just return as no-op:
- * Happens during initial modesetting of a crtc.
- */
- if (mode->crtc_clock == 0) {
- drm_dbg_core(dev, "crtc %u: Noop due to uninitialized mode.\n",
- pipe);
- drm_WARN_ON_ONCE(dev, drm_drv_uses_atomic_modeset(dev));
- return false;
- }
- /* Get current scanout position with system timestamp.
- * Repeat query up to DRM_TIMESTAMP_MAXRETRIES times
- * if single query takes longer than max_error nanoseconds.
- *
- * This guarantees a tight bound on maximum error if
- * code gets preempted or delayed for some reason.
- */
- for (i = 0; i < DRM_TIMESTAMP_MAXRETRIES; i++) {
- /*
- * Get vertical and horizontal scanout position vpos, hpos,
- * and bounding timestamps stime, etime, pre/post query.
- */
- vbl_status = get_scanout_position(crtc, in_vblank_irq,
- &vpos, &hpos,
- &stime, &etime,
- mode);
- /* Return as no-op if scanout query unsupported or failed. */
- if (!vbl_status) {
- drm_dbg_core(dev,
- "crtc %u : scanoutpos query failed.\n",
- pipe);
- return false;
- }
- /* Compute uncertainty in timestamp of scanout position query. */
- duration_ns = ktime_to_ns(etime) - ktime_to_ns(stime);
- /* Accept result with < max_error nsecs timing uncertainty. */
- if (duration_ns <= *max_error)
- break;
- }
- /* Noisy system timing? */
- if (i == DRM_TIMESTAMP_MAXRETRIES) {
- drm_dbg_core(dev,
- "crtc %u: Noisy timestamp %d us > %d us [%d reps].\n",
- pipe, duration_ns / 1000, *max_error / 1000, i);
- }
- /* Return upper bound of timestamp precision error. */
- *max_error = duration_ns;
- /* Convert scanout position into elapsed time at raw_time query
- * since start of scanout at first display scanline. delta_ns
- * can be negative if start of scanout hasn't happened yet.
- */
- delta_ns = div_s64(1000000LL * (vpos * mode->crtc_htotal + hpos),
- mode->crtc_clock);
- /* Subtract time delta from raw timestamp to get final
- * vblank_time timestamp for end of vblank.
- */
- *vblank_time = ktime_sub_ns(etime, delta_ns);
- if (!drm_debug_enabled(DRM_UT_VBL))
- return true;
- ts_etime = ktime_to_timespec64(etime);
- ts_vblank_time = ktime_to_timespec64(*vblank_time);
- drm_dbg_vbl(dev,
- "crtc %u : v p(%d,%d)@ %lld.%06ld -> %lld.%06ld [e %d us, %d rep]\n",
- pipe, hpos, vpos,
- (u64)ts_etime.tv_sec, ts_etime.tv_nsec / 1000,
- (u64)ts_vblank_time.tv_sec, ts_vblank_time.tv_nsec / 1000,
- duration_ns / 1000, i);
- return true;
- }
- EXPORT_SYMBOL(drm_crtc_vblank_helper_get_vblank_timestamp_internal);
- /**
- * drm_crtc_vblank_helper_get_vblank_timestamp - precise vblank timestamp
- * helper
- * @crtc: CRTC whose vblank timestamp to retrieve
- * @max_error: Desired maximum allowable error in timestamps (nanosecs)
- * On return contains true maximum error of timestamp
- * @vblank_time: Pointer to time which should receive the timestamp
- * @in_vblank_irq:
- * True when called from drm_crtc_handle_vblank(). Some drivers
- * need to apply some workarounds for gpu-specific vblank irq quirks
- * if flag is set.
- *
- * Implements calculation of exact vblank timestamps from given drm_display_mode
- * timings and current video scanout position of a CRTC. This can be directly
- * used as the &drm_crtc_funcs.get_vblank_timestamp implementation of a kms
- * driver if &drm_crtc_helper_funcs.get_scanout_position is implemented.
- *
- * The current implementation only handles standard video modes. For double scan
- * and interlaced modes the driver is supposed to adjust the hardware mode
- * (taken from &drm_crtc_state.adjusted mode for atomic modeset drivers) to
- * match the scanout position reported.
- *
- * Note that atomic drivers must call drm_calc_timestamping_constants() before
- * enabling a CRTC. The atomic helpers already take care of that in
- * drm_atomic_helper_calc_timestamping_constants().
- *
- * Returns:
- *
- * Returns true on success, and false on failure, i.e. when no accurate
- * timestamp could be acquired.
- */
- bool drm_crtc_vblank_helper_get_vblank_timestamp(struct drm_crtc *crtc,
- int *max_error,
- ktime_t *vblank_time,
- bool in_vblank_irq)
- {
- return drm_crtc_vblank_helper_get_vblank_timestamp_internal(
- crtc, max_error, vblank_time, in_vblank_irq,
- crtc->helper_private->get_scanout_position);
- }
- EXPORT_SYMBOL(drm_crtc_vblank_helper_get_vblank_timestamp);
- /**
- * drm_get_last_vbltimestamp - retrieve raw timestamp for the most recent
- * vblank interval
- * @dev: DRM device
- * @pipe: index of CRTC whose vblank timestamp to retrieve
- * @tvblank: Pointer to target time which should receive the timestamp
- * @in_vblank_irq:
- * True when called from drm_crtc_handle_vblank(). Some drivers
- * need to apply some workarounds for gpu-specific vblank irq quirks
- * if flag is set.
- *
- * Fetches the system timestamp corresponding to the time of the most recent
- * vblank interval on specified CRTC. May call into kms-driver to
- * compute the timestamp with a high-precision GPU specific method.
- *
- * Returns zero if timestamp originates from uncorrected do_gettimeofday()
- * call, i.e., it isn't very precisely locked to the true vblank.
- *
- * Returns:
- * True if timestamp is considered to be very precise, false otherwise.
- */
- static bool
- drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe,
- ktime_t *tvblank, bool in_vblank_irq)
- {
- struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
- bool ret = false;
- /* Define requested maximum error on timestamps (nanoseconds). */
- int max_error = (int) drm_timestamp_precision * 1000;
- /* Query driver if possible and precision timestamping enabled. */
- if (crtc && crtc->funcs->get_vblank_timestamp && max_error > 0) {
- struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
- ret = crtc->funcs->get_vblank_timestamp(crtc, &max_error,
- tvblank, in_vblank_irq);
- }
- /* GPU high precision timestamp query unsupported or failed.
- * Return current monotonic/gettimeofday timestamp as best estimate.
- */
- if (!ret)
- *tvblank = ktime_get();
- return ret;
- }
- /**
- * drm_crtc_vblank_count - retrieve "cooked" vblank counter value
- * @crtc: which counter to retrieve
- *
- * Fetches the "cooked" vblank count value that represents the number of
- * vblank events since the system was booted, including lost events due to
- * modesetting activity. Note that this timer isn't correct against a racing
- * vblank interrupt (since it only reports the software vblank counter), see
- * drm_crtc_accurate_vblank_count() for such use-cases.
- *
- * Note that for a given vblank counter value drm_crtc_handle_vblank()
- * and drm_crtc_vblank_count() or drm_crtc_vblank_count_and_time()
- * provide a barrier: Any writes done before calling
- * drm_crtc_handle_vblank() will be visible to callers of the later
- * functions, if the vblank count is the same or a later one.
- *
- * See also &drm_vblank_crtc.count.
- *
- * Returns:
- * The software vblank counter.
- */
- u64 drm_crtc_vblank_count(struct drm_crtc *crtc)
- {
- return drm_vblank_count(crtc->dev, drm_crtc_index(crtc));
- }
- EXPORT_SYMBOL(drm_crtc_vblank_count);
- /**
- * drm_vblank_count_and_time - retrieve "cooked" vblank counter value and the
- * system timestamp corresponding to that vblank counter value.
- * @dev: DRM device
- * @pipe: index of CRTC whose counter to retrieve
- * @vblanktime: Pointer to ktime_t to receive the vblank timestamp.
- *
- * Fetches the "cooked" vblank count value that represents the number of
- * vblank events since the system was booted, including lost events due to
- * modesetting activity. Returns corresponding system timestamp of the time
- * of the vblank interval that corresponds to the current vblank counter value.
- *
- * This is the legacy version of drm_crtc_vblank_count_and_time().
- */
- static u64 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe,
- ktime_t *vblanktime)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- u64 vblank_count;
- unsigned int seq;
- if (drm_WARN_ON(dev, pipe >= dev->num_crtcs)) {
- *vblanktime = 0;
- return 0;
- }
- do {
- seq = read_seqbegin(&vblank->seqlock);
- vblank_count = atomic64_read(&vblank->count);
- *vblanktime = vblank->time;
- } while (read_seqretry(&vblank->seqlock, seq));
- return vblank_count;
- }
- /**
- * drm_crtc_vblank_count_and_time - retrieve "cooked" vblank counter value
- * and the system timestamp corresponding to that vblank counter value
- * @crtc: which counter to retrieve
- * @vblanktime: Pointer to time to receive the vblank timestamp.
- *
- * Fetches the "cooked" vblank count value that represents the number of
- * vblank events since the system was booted, including lost events due to
- * modesetting activity. Returns corresponding system timestamp of the time
- * of the vblank interval that corresponds to the current vblank counter value.
- *
- * Note that for a given vblank counter value drm_crtc_handle_vblank()
- * and drm_crtc_vblank_count() or drm_crtc_vblank_count_and_time()
- * provide a barrier: Any writes done before calling
- * drm_crtc_handle_vblank() will be visible to callers of the later
- * functions, if the vblank count is the same or a later one.
- *
- * See also &drm_vblank_crtc.count.
- */
- u64 drm_crtc_vblank_count_and_time(struct drm_crtc *crtc,
- ktime_t *vblanktime)
- {
- return drm_vblank_count_and_time(crtc->dev, drm_crtc_index(crtc),
- vblanktime);
- }
- EXPORT_SYMBOL(drm_crtc_vblank_count_and_time);
- static void send_vblank_event(struct drm_device *dev,
- struct drm_pending_vblank_event *e,
- u64 seq, ktime_t now)
- {
- struct timespec64 tv;
- switch (e->event.base.type) {
- case DRM_EVENT_VBLANK:
- case DRM_EVENT_FLIP_COMPLETE:
- tv = ktime_to_timespec64(now);
- e->event.vbl.sequence = seq;
- /*
- * e->event is a user space structure, with hardcoded unsigned
- * 32-bit seconds/microseconds. This is safe as we always use
- * monotonic timestamps since linux-4.15
- */
- e->event.vbl.tv_sec = tv.tv_sec;
- e->event.vbl.tv_usec = tv.tv_nsec / 1000;
- break;
- case DRM_EVENT_CRTC_SEQUENCE:
- if (seq)
- e->event.seq.sequence = seq;
- e->event.seq.time_ns = ktime_to_ns(now);
- break;
- }
- trace_drm_vblank_event_delivered(e->base.file_priv, e->pipe, seq);
- /*
- * Use the same timestamp for any associated fence signal to avoid
- * mismatch in timestamps for vsync & fence events triggered by the
- * same HW event. Frameworks like SurfaceFlinger in Android expects the
- * retire-fence timestamp to match exactly with HW vsync as it uses it
- * for its software vsync modeling.
- */
- drm_send_event_timestamp_locked(dev, &e->base, now);
- }
- /**
- * drm_crtc_arm_vblank_event - arm vblank event after pageflip
- * @crtc: the source CRTC of the vblank event
- * @e: the event to send
- *
- * A lot of drivers need to generate vblank events for the very next vblank
- * interrupt. For example when the page flip interrupt happens when the page
- * flip gets armed, but not when it actually executes within the next vblank
- * period. This helper function implements exactly the required vblank arming
- * behaviour.
- *
- * NOTE: Drivers using this to send out the &drm_crtc_state.event as part of an
- * atomic commit must ensure that the next vblank happens at exactly the same
- * time as the atomic commit is committed to the hardware. This function itself
- * does **not** protect against the next vblank interrupt racing with either this
- * function call or the atomic commit operation. A possible sequence could be:
- *
- * 1. Driver commits new hardware state into vblank-synchronized registers.
- * 2. A vblank happens, committing the hardware state. Also the corresponding
- * vblank interrupt is fired off and fully processed by the interrupt
- * handler.
- * 3. The atomic commit operation proceeds to call drm_crtc_arm_vblank_event().
- * 4. The event is only send out for the next vblank, which is wrong.
- *
- * An equivalent race can happen when the driver calls
- * drm_crtc_arm_vblank_event() before writing out the new hardware state.
- *
- * The only way to make this work safely is to prevent the vblank from firing
- * (and the hardware from committing anything else) until the entire atomic
- * commit sequence has run to completion. If the hardware does not have such a
- * feature (e.g. using a "go" bit), then it is unsafe to use this functions.
- * Instead drivers need to manually send out the event from their interrupt
- * handler by calling drm_crtc_send_vblank_event() and make sure that there's no
- * possible race with the hardware committing the atomic update.
- *
- * Caller must hold a vblank reference for the event @e acquired by a
- * drm_crtc_vblank_get(), which will be dropped when the next vblank arrives.
- */
- void drm_crtc_arm_vblank_event(struct drm_crtc *crtc,
- struct drm_pending_vblank_event *e)
- {
- struct drm_device *dev = crtc->dev;
- unsigned int pipe = drm_crtc_index(crtc);
- assert_spin_locked(&dev->event_lock);
- e->pipe = pipe;
- e->sequence = drm_crtc_accurate_vblank_count(crtc) + 1;
- list_add_tail(&e->base.link, &dev->vblank_event_list);
- }
- EXPORT_SYMBOL(drm_crtc_arm_vblank_event);
- /**
- * drm_crtc_send_vblank_event - helper to send vblank event after pageflip
- * @crtc: the source CRTC of the vblank event
- * @e: the event to send
- *
- * Updates sequence # and timestamp on event for the most recently processed
- * vblank, and sends it to userspace. Caller must hold event lock.
- *
- * See drm_crtc_arm_vblank_event() for a helper which can be used in certain
- * situation, especially to send out events for atomic commit operations.
- */
- void drm_crtc_send_vblank_event(struct drm_crtc *crtc,
- struct drm_pending_vblank_event *e)
- {
- struct drm_device *dev = crtc->dev;
- u64 seq;
- unsigned int pipe = drm_crtc_index(crtc);
- ktime_t now;
- if (drm_dev_has_vblank(dev)) {
- seq = drm_vblank_count_and_time(dev, pipe, &now);
- } else {
- seq = 0;
- now = ktime_get();
- }
- e->pipe = pipe;
- send_vblank_event(dev, e, seq, now);
- }
- EXPORT_SYMBOL(drm_crtc_send_vblank_event);
- static int __enable_vblank(struct drm_device *dev, unsigned int pipe)
- {
- if (drm_core_check_feature(dev, DRIVER_MODESET)) {
- struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
- if (drm_WARN_ON(dev, !crtc))
- return 0;
- if (crtc->funcs->enable_vblank)
- return crtc->funcs->enable_vblank(crtc);
- }
- #ifdef CONFIG_DRM_LEGACY
- else if (dev->driver->enable_vblank) {
- return dev->driver->enable_vblank(dev, pipe);
- }
- #endif
- return -EINVAL;
- }
- static int drm_vblank_enable(struct drm_device *dev, unsigned int pipe)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- int ret = 0;
- assert_spin_locked(&dev->vbl_lock);
- spin_lock(&dev->vblank_time_lock);
- if (!vblank->enabled) {
- /*
- * Enable vblank irqs under vblank_time_lock protection.
- * All vblank count & timestamp updates are held off
- * until we are done reinitializing master counter and
- * timestamps. Filtercode in drm_handle_vblank() will
- * prevent double-accounting of same vblank interval.
- */
- ret = __enable_vblank(dev, pipe);
- drm_dbg_core(dev, "enabling vblank on crtc %u, ret: %d\n",
- pipe, ret);
- if (ret) {
- atomic_dec(&vblank->refcount);
- } else {
- drm_update_vblank_count(dev, pipe, 0);
- /* drm_update_vblank_count() includes a wmb so we just
- * need to ensure that the compiler emits the write
- * to mark the vblank as enabled after the call
- * to drm_update_vblank_count().
- */
- WRITE_ONCE(vblank->enabled, true);
- }
- }
- spin_unlock(&dev->vblank_time_lock);
- return ret;
- }
- int drm_vblank_get(struct drm_device *dev, unsigned int pipe)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- unsigned long irqflags;
- int ret = 0;
- if (!drm_dev_has_vblank(dev))
- return -EINVAL;
- if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
- return -EINVAL;
- spin_lock_irqsave(&dev->vbl_lock, irqflags);
- /* Going from 0->1 means we have to enable interrupts again */
- if (atomic_add_return(1, &vblank->refcount) == 1) {
- ret = drm_vblank_enable(dev, pipe);
- } else {
- if (!vblank->enabled) {
- atomic_dec(&vblank->refcount);
- ret = -EINVAL;
- }
- }
- spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
- return ret;
- }
- /**
- * drm_crtc_vblank_get - get a reference count on vblank events
- * @crtc: which CRTC to own
- *
- * Acquire a reference count on vblank events to avoid having them disabled
- * while in use.
- *
- * Returns:
- * Zero on success or a negative error code on failure.
- */
- int drm_crtc_vblank_get(struct drm_crtc *crtc)
- {
- return drm_vblank_get(crtc->dev, drm_crtc_index(crtc));
- }
- EXPORT_SYMBOL(drm_crtc_vblank_get);
- void drm_vblank_put(struct drm_device *dev, unsigned int pipe)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
- return;
- if (drm_WARN_ON(dev, atomic_read(&vblank->refcount) == 0))
- return;
- /* Last user schedules interrupt disable */
- if (atomic_dec_and_test(&vblank->refcount)) {
- if (drm_vblank_offdelay == 0)
- return;
- else if (drm_vblank_offdelay < 0)
- vblank_disable_fn(&vblank->disable_timer);
- else if (!dev->vblank_disable_immediate)
- mod_timer(&vblank->disable_timer,
- jiffies + ((drm_vblank_offdelay * HZ)/1000));
- }
- }
- /**
- * drm_crtc_vblank_put - give up ownership of vblank events
- * @crtc: which counter to give up
- *
- * Release ownership of a given vblank counter, turning off interrupts
- * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
- */
- void drm_crtc_vblank_put(struct drm_crtc *crtc)
- {
- drm_vblank_put(crtc->dev, drm_crtc_index(crtc));
- }
- EXPORT_SYMBOL(drm_crtc_vblank_put);
- /**
- * drm_wait_one_vblank - wait for one vblank
- * @dev: DRM device
- * @pipe: CRTC index
- *
- * This waits for one vblank to pass on @pipe, using the irq driver interfaces.
- * It is a failure to call this when the vblank irq for @pipe is disabled, e.g.
- * due to lack of driver support or because the crtc is off.
- *
- * This is the legacy version of drm_crtc_wait_one_vblank().
- */
- void drm_wait_one_vblank(struct drm_device *dev, unsigned int pipe)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- int ret;
- u64 last;
- if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
- return;
- ret = drm_vblank_get(dev, pipe);
- if (drm_WARN(dev, ret, "vblank not available on crtc %i, ret=%i\n",
- pipe, ret))
- return;
- last = drm_vblank_count(dev, pipe);
- ret = wait_event_timeout(vblank->queue,
- last != drm_vblank_count(dev, pipe),
- msecs_to_jiffies(100));
- drm_WARN(dev, ret == 0, "vblank wait timed out on crtc %i\n", pipe);
- drm_vblank_put(dev, pipe);
- }
- EXPORT_SYMBOL(drm_wait_one_vblank);
- /**
- * drm_crtc_wait_one_vblank - wait for one vblank
- * @crtc: DRM crtc
- *
- * This waits for one vblank to pass on @crtc, using the irq driver interfaces.
- * It is a failure to call this when the vblank irq for @crtc is disabled, e.g.
- * due to lack of driver support or because the crtc is off.
- */
- void drm_crtc_wait_one_vblank(struct drm_crtc *crtc)
- {
- drm_wait_one_vblank(crtc->dev, drm_crtc_index(crtc));
- }
- EXPORT_SYMBOL(drm_crtc_wait_one_vblank);
- /**
- * drm_crtc_vblank_off - disable vblank events on a CRTC
- * @crtc: CRTC in question
- *
- * Drivers can use this function to shut down the vblank interrupt handling when
- * disabling a crtc. This function ensures that the latest vblank frame count is
- * stored so that drm_vblank_on can restore it again.
- *
- * Drivers must use this function when the hardware vblank counter can get
- * reset, e.g. when suspending or disabling the @crtc in general.
- */
- void drm_crtc_vblank_off(struct drm_crtc *crtc)
- {
- struct drm_device *dev = crtc->dev;
- unsigned int pipe = drm_crtc_index(crtc);
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- struct drm_pending_vblank_event *e, *t;
- ktime_t now;
- u64 seq;
- if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
- return;
- /*
- * Grab event_lock early to prevent vblank work from being scheduled
- * while we're in the middle of shutting down vblank interrupts
- */
- spin_lock_irq(&dev->event_lock);
- spin_lock(&dev->vbl_lock);
- drm_dbg_vbl(dev, "crtc %d, vblank enabled %d, inmodeset %d\n",
- pipe, vblank->enabled, vblank->inmodeset);
- /* Avoid redundant vblank disables without previous
- * drm_crtc_vblank_on(). */
- if (drm_core_check_feature(dev, DRIVER_ATOMIC) || !vblank->inmodeset)
- drm_vblank_disable_and_save(dev, pipe);
- wake_up(&vblank->queue);
- /*
- * Prevent subsequent drm_vblank_get() from re-enabling
- * the vblank interrupt by bumping the refcount.
- */
- if (!vblank->inmodeset) {
- atomic_inc(&vblank->refcount);
- vblank->inmodeset = 1;
- }
- spin_unlock(&dev->vbl_lock);
- /* Send any queued vblank events, lest the natives grow disquiet */
- seq = drm_vblank_count_and_time(dev, pipe, &now);
- list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
- if (e->pipe != pipe)
- continue;
- drm_dbg_core(dev, "Sending premature vblank event on disable: "
- "wanted %llu, current %llu\n",
- e->sequence, seq);
- list_del(&e->base.link);
- drm_vblank_put(dev, pipe);
- send_vblank_event(dev, e, seq, now);
- }
- /* Cancel any leftover pending vblank work */
- drm_vblank_cancel_pending_works(vblank);
- spin_unlock_irq(&dev->event_lock);
- /* Will be reset by the modeset helpers when re-enabling the crtc by
- * calling drm_calc_timestamping_constants(). */
- vblank->hwmode.crtc_clock = 0;
- /* Wait for any vblank work that's still executing to finish */
- drm_vblank_flush_worker(vblank);
- }
- EXPORT_SYMBOL(drm_crtc_vblank_off);
- /**
- * drm_crtc_vblank_reset - reset vblank state to off on a CRTC
- * @crtc: CRTC in question
- *
- * Drivers can use this function to reset the vblank state to off at load time.
- * Drivers should use this together with the drm_crtc_vblank_off() and
- * drm_crtc_vblank_on() functions. The difference compared to
- * drm_crtc_vblank_off() is that this function doesn't save the vblank counter
- * and hence doesn't need to call any driver hooks.
- *
- * This is useful for recovering driver state e.g. on driver load, or on resume.
- */
- void drm_crtc_vblank_reset(struct drm_crtc *crtc)
- {
- struct drm_device *dev = crtc->dev;
- unsigned int pipe = drm_crtc_index(crtc);
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- spin_lock_irq(&dev->vbl_lock);
- /*
- * Prevent subsequent drm_vblank_get() from enabling the vblank
- * interrupt by bumping the refcount.
- */
- if (!vblank->inmodeset) {
- atomic_inc(&vblank->refcount);
- vblank->inmodeset = 1;
- }
- spin_unlock_irq(&dev->vbl_lock);
- drm_WARN_ON(dev, !list_empty(&dev->vblank_event_list));
- drm_WARN_ON(dev, !list_empty(&vblank->pending_work));
- }
- EXPORT_SYMBOL(drm_crtc_vblank_reset);
- /**
- * drm_crtc_set_max_vblank_count - configure the hw max vblank counter value
- * @crtc: CRTC in question
- * @max_vblank_count: max hardware vblank counter value
- *
- * Update the maximum hardware vblank counter value for @crtc
- * at runtime. Useful for hardware where the operation of the
- * hardware vblank counter depends on the currently active
- * display configuration.
- *
- * For example, if the hardware vblank counter does not work
- * when a specific connector is active the maximum can be set
- * to zero. And when that specific connector isn't active the
- * maximum can again be set to the appropriate non-zero value.
- *
- * If used, must be called before drm_vblank_on().
- */
- void drm_crtc_set_max_vblank_count(struct drm_crtc *crtc,
- u32 max_vblank_count)
- {
- struct drm_device *dev = crtc->dev;
- unsigned int pipe = drm_crtc_index(crtc);
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- drm_WARN_ON(dev, dev->max_vblank_count);
- drm_WARN_ON(dev, !READ_ONCE(vblank->inmodeset));
- vblank->max_vblank_count = max_vblank_count;
- }
- EXPORT_SYMBOL(drm_crtc_set_max_vblank_count);
- /**
- * drm_crtc_vblank_on - enable vblank events on a CRTC
- * @crtc: CRTC in question
- *
- * This functions restores the vblank interrupt state captured with
- * drm_crtc_vblank_off() again and is generally called when enabling @crtc. Note
- * that calls to drm_crtc_vblank_on() and drm_crtc_vblank_off() can be
- * unbalanced and so can also be unconditionally called in driver load code to
- * reflect the current hardware state of the crtc.
- */
- void drm_crtc_vblank_on(struct drm_crtc *crtc)
- {
- struct drm_device *dev = crtc->dev;
- unsigned int pipe = drm_crtc_index(crtc);
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
- return;
- spin_lock_irq(&dev->vbl_lock);
- drm_dbg_vbl(dev, "crtc %d, vblank enabled %d, inmodeset %d\n",
- pipe, vblank->enabled, vblank->inmodeset);
- /* Drop our private "prevent drm_vblank_get" refcount */
- if (vblank->inmodeset) {
- atomic_dec(&vblank->refcount);
- vblank->inmodeset = 0;
- }
- drm_reset_vblank_timestamp(dev, pipe);
- /*
- * re-enable interrupts if there are users left, or the
- * user wishes vblank interrupts to be enabled all the time.
- */
- if (atomic_read(&vblank->refcount) != 0 || drm_vblank_offdelay == 0)
- drm_WARN_ON(dev, drm_vblank_enable(dev, pipe));
- spin_unlock_irq(&dev->vbl_lock);
- }
- EXPORT_SYMBOL(drm_crtc_vblank_on);
- static void drm_vblank_restore(struct drm_device *dev, unsigned int pipe)
- {
- ktime_t t_vblank;
- struct drm_vblank_crtc *vblank;
- int framedur_ns;
- u64 diff_ns;
- u32 cur_vblank, diff = 1;
- int count = DRM_TIMESTAMP_MAXRETRIES;
- u32 max_vblank_count = drm_max_vblank_count(dev, pipe);
- if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
- return;
- assert_spin_locked(&dev->vbl_lock);
- assert_spin_locked(&dev->vblank_time_lock);
- vblank = &dev->vblank[pipe];
- drm_WARN_ONCE(dev,
- drm_debug_enabled(DRM_UT_VBL) && !vblank->framedur_ns,
- "Cannot compute missed vblanks without frame duration\n");
- framedur_ns = vblank->framedur_ns;
- do {
- cur_vblank = __get_vblank_counter(dev, pipe);
- drm_get_last_vbltimestamp(dev, pipe, &t_vblank, false);
- } while (cur_vblank != __get_vblank_counter(dev, pipe) && --count > 0);
- diff_ns = ktime_to_ns(ktime_sub(t_vblank, vblank->time));
- if (framedur_ns)
- diff = DIV_ROUND_CLOSEST_ULL(diff_ns, framedur_ns);
- drm_dbg_vbl(dev,
- "missed %d vblanks in %lld ns, frame duration=%d ns, hw_diff=%d\n",
- diff, diff_ns, framedur_ns, cur_vblank - vblank->last);
- vblank->last = (cur_vblank - diff) & max_vblank_count;
- }
- /**
- * drm_crtc_vblank_restore - estimate missed vblanks and update vblank count.
- * @crtc: CRTC in question
- *
- * Power manamement features can cause frame counter resets between vblank
- * disable and enable. Drivers can use this function in their
- * &drm_crtc_funcs.enable_vblank implementation to estimate missed vblanks since
- * the last &drm_crtc_funcs.disable_vblank using timestamps and update the
- * vblank counter.
- *
- * Note that drivers must have race-free high-precision timestamping support,
- * i.e. &drm_crtc_funcs.get_vblank_timestamp must be hooked up and
- * &drm_driver.vblank_disable_immediate must be set to indicate the
- * time-stamping functions are race-free against vblank hardware counter
- * increments.
- */
- void drm_crtc_vblank_restore(struct drm_crtc *crtc)
- {
- WARN_ON_ONCE(!crtc->funcs->get_vblank_timestamp);
- WARN_ON_ONCE(!crtc->dev->vblank_disable_immediate);
- drm_vblank_restore(crtc->dev, drm_crtc_index(crtc));
- }
- EXPORT_SYMBOL(drm_crtc_vblank_restore);
- static void drm_legacy_vblank_pre_modeset(struct drm_device *dev,
- unsigned int pipe)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- /* vblank is not initialized (IRQ not installed ?), or has been freed */
- if (!drm_dev_has_vblank(dev))
- return;
- if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
- return;
- /*
- * To avoid all the problems that might happen if interrupts
- * were enabled/disabled around or between these calls, we just
- * have the kernel take a reference on the CRTC (just once though
- * to avoid corrupting the count if multiple, mismatch calls occur),
- * so that interrupts remain enabled in the interim.
- */
- if (!vblank->inmodeset) {
- vblank->inmodeset = 0x1;
- if (drm_vblank_get(dev, pipe) == 0)
- vblank->inmodeset |= 0x2;
- }
- }
- static void drm_legacy_vblank_post_modeset(struct drm_device *dev,
- unsigned int pipe)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- /* vblank is not initialized (IRQ not installed ?), or has been freed */
- if (!drm_dev_has_vblank(dev))
- return;
- if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
- return;
- if (vblank->inmodeset) {
- spin_lock_irq(&dev->vbl_lock);
- drm_reset_vblank_timestamp(dev, pipe);
- spin_unlock_irq(&dev->vbl_lock);
- if (vblank->inmodeset & 0x2)
- drm_vblank_put(dev, pipe);
- vblank->inmodeset = 0;
- }
- }
- int drm_legacy_modeset_ctl_ioctl(struct drm_device *dev, void *data,
- struct drm_file *file_priv)
- {
- struct drm_modeset_ctl *modeset = data;
- unsigned int pipe;
- /* If drm_vblank_init() hasn't been called yet, just no-op */
- if (!drm_dev_has_vblank(dev))
- return 0;
- /* KMS drivers handle this internally */
- if (!drm_core_check_feature(dev, DRIVER_LEGACY))
- return 0;
- pipe = modeset->crtc;
- if (pipe >= dev->num_crtcs)
- return -EINVAL;
- switch (modeset->cmd) {
- case _DRM_PRE_MODESET:
- drm_legacy_vblank_pre_modeset(dev, pipe);
- break;
- case _DRM_POST_MODESET:
- drm_legacy_vblank_post_modeset(dev, pipe);
- break;
- default:
- return -EINVAL;
- }
- return 0;
- }
- static int drm_queue_vblank_event(struct drm_device *dev, unsigned int pipe,
- u64 req_seq,
- union drm_wait_vblank *vblwait,
- struct drm_file *file_priv)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- struct drm_pending_vblank_event *e;
- ktime_t now;
- u64 seq;
- int ret;
- e = kzalloc(sizeof(*e), GFP_KERNEL);
- if (e == NULL) {
- ret = -ENOMEM;
- goto err_put;
- }
- e->pipe = pipe;
- e->event.base.type = DRM_EVENT_VBLANK;
- e->event.base.length = sizeof(e->event.vbl);
- e->event.vbl.user_data = vblwait->request.signal;
- e->event.vbl.crtc_id = 0;
- if (drm_core_check_feature(dev, DRIVER_MODESET)) {
- struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
- if (crtc)
- e->event.vbl.crtc_id = crtc->base.id;
- }
- spin_lock_irq(&dev->event_lock);
- /*
- * drm_crtc_vblank_off() might have been called after we called
- * drm_vblank_get(). drm_crtc_vblank_off() holds event_lock around the
- * vblank disable, so no need for further locking. The reference from
- * drm_vblank_get() protects against vblank disable from another source.
- */
- if (!READ_ONCE(vblank->enabled)) {
- ret = -EINVAL;
- goto err_unlock;
- }
- ret = drm_event_reserve_init_locked(dev, file_priv, &e->base,
- &e->event.base);
- if (ret)
- goto err_unlock;
- seq = drm_vblank_count_and_time(dev, pipe, &now);
- drm_dbg_core(dev, "event on vblank count %llu, current %llu, crtc %u\n",
- req_seq, seq, pipe);
- trace_drm_vblank_event_queued(file_priv, pipe, req_seq);
- e->sequence = req_seq;
- if (drm_vblank_passed(seq, req_seq)) {
- drm_vblank_put(dev, pipe);
- send_vblank_event(dev, e, seq, now);
- vblwait->reply.sequence = seq;
- } else {
- /* drm_handle_vblank_events will call drm_vblank_put */
- list_add_tail(&e->base.link, &dev->vblank_event_list);
- vblwait->reply.sequence = req_seq;
- }
- spin_unlock_irq(&dev->event_lock);
- return 0;
- err_unlock:
- spin_unlock_irq(&dev->event_lock);
- kfree(e);
- err_put:
- drm_vblank_put(dev, pipe);
- return ret;
- }
- static bool drm_wait_vblank_is_query(union drm_wait_vblank *vblwait)
- {
- if (vblwait->request.sequence)
- return false;
- return _DRM_VBLANK_RELATIVE ==
- (vblwait->request.type & (_DRM_VBLANK_TYPES_MASK |
- _DRM_VBLANK_EVENT |
- _DRM_VBLANK_NEXTONMISS));
- }
- /*
- * Widen a 32-bit param to 64-bits.
- *
- * \param narrow 32-bit value (missing upper 32 bits)
- * \param near 64-bit value that should be 'close' to near
- *
- * This function returns a 64-bit value using the lower 32-bits from
- * 'narrow' and constructing the upper 32-bits so that the result is
- * as close as possible to 'near'.
- */
- static u64 widen_32_to_64(u32 narrow, u64 near)
- {
- return near + (s32) (narrow - near);
- }
- static void drm_wait_vblank_reply(struct drm_device *dev, unsigned int pipe,
- struct drm_wait_vblank_reply *reply)
- {
- ktime_t now;
- struct timespec64 ts;
- /*
- * drm_wait_vblank_reply is a UAPI structure that uses 'long'
- * to store the seconds. This is safe as we always use monotonic
- * timestamps since linux-4.15.
- */
- reply->sequence = drm_vblank_count_and_time(dev, pipe, &now);
- ts = ktime_to_timespec64(now);
- reply->tval_sec = (u32)ts.tv_sec;
- reply->tval_usec = ts.tv_nsec / 1000;
- }
- static bool drm_wait_vblank_supported(struct drm_device *dev)
- {
- #if IS_ENABLED(CONFIG_DRM_LEGACY)
- if (unlikely(drm_core_check_feature(dev, DRIVER_LEGACY)))
- return dev->irq_enabled;
- #endif
- return drm_dev_has_vblank(dev);
- }
- int drm_wait_vblank_ioctl(struct drm_device *dev, void *data,
- struct drm_file *file_priv)
- {
- struct drm_crtc *crtc;
- struct drm_vblank_crtc *vblank;
- union drm_wait_vblank *vblwait = data;
- int ret;
- u64 req_seq, seq;
- unsigned int pipe_index;
- unsigned int flags, pipe, high_pipe;
- if (!drm_wait_vblank_supported(dev))
- return -EOPNOTSUPP;
- if (vblwait->request.type & _DRM_VBLANK_SIGNAL)
- return -EINVAL;
- if (vblwait->request.type &
- ~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
- _DRM_VBLANK_HIGH_CRTC_MASK)) {
- drm_dbg_core(dev,
- "Unsupported type value 0x%x, supported mask 0x%x\n",
- vblwait->request.type,
- (_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK |
- _DRM_VBLANK_HIGH_CRTC_MASK));
- return -EINVAL;
- }
- flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
- high_pipe = (vblwait->request.type & _DRM_VBLANK_HIGH_CRTC_MASK);
- if (high_pipe)
- pipe_index = high_pipe >> _DRM_VBLANK_HIGH_CRTC_SHIFT;
- else
- pipe_index = flags & _DRM_VBLANK_SECONDARY ? 1 : 0;
- /* Convert lease-relative crtc index into global crtc index */
- if (drm_core_check_feature(dev, DRIVER_MODESET)) {
- pipe = 0;
- drm_for_each_crtc(crtc, dev) {
- if (drm_lease_held(file_priv, crtc->base.id)) {
- if (pipe_index == 0)
- break;
- pipe_index--;
- }
- pipe++;
- }
- } else {
- pipe = pipe_index;
- }
- if (pipe >= dev->num_crtcs)
- return -EINVAL;
- vblank = &dev->vblank[pipe];
- /* If the counter is currently enabled and accurate, short-circuit
- * queries to return the cached timestamp of the last vblank.
- */
- if (dev->vblank_disable_immediate &&
- drm_wait_vblank_is_query(vblwait) &&
- READ_ONCE(vblank->enabled)) {
- drm_wait_vblank_reply(dev, pipe, &vblwait->reply);
- return 0;
- }
- ret = drm_vblank_get(dev, pipe);
- if (ret) {
- drm_dbg_core(dev,
- "crtc %d failed to acquire vblank counter, %d\n",
- pipe, ret);
- return ret;
- }
- seq = drm_vblank_count(dev, pipe);
- switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
- case _DRM_VBLANK_RELATIVE:
- req_seq = seq + vblwait->request.sequence;
- vblwait->request.sequence = req_seq;
- vblwait->request.type &= ~_DRM_VBLANK_RELATIVE;
- break;
- case _DRM_VBLANK_ABSOLUTE:
- req_seq = widen_32_to_64(vblwait->request.sequence, seq);
- break;
- default:
- ret = -EINVAL;
- goto done;
- }
- if ((flags & _DRM_VBLANK_NEXTONMISS) &&
- drm_vblank_passed(seq, req_seq)) {
- req_seq = seq + 1;
- vblwait->request.type &= ~_DRM_VBLANK_NEXTONMISS;
- vblwait->request.sequence = req_seq;
- }
- if (flags & _DRM_VBLANK_EVENT) {
- /* must hold on to the vblank ref until the event fires
- * drm_vblank_put will be called asynchronously
- */
- return drm_queue_vblank_event(dev, pipe, req_seq, vblwait, file_priv);
- }
- if (req_seq != seq) {
- int wait;
- drm_dbg_core(dev, "waiting on vblank count %llu, crtc %u\n",
- req_seq, pipe);
- wait = wait_event_interruptible_timeout(vblank->queue,
- drm_vblank_passed(drm_vblank_count(dev, pipe), req_seq) ||
- !READ_ONCE(vblank->enabled),
- msecs_to_jiffies(3000));
- switch (wait) {
- case 0:
- /* timeout */
- ret = -EBUSY;
- break;
- case -ERESTARTSYS:
- /* interrupted by signal */
- ret = -EINTR;
- break;
- default:
- ret = 0;
- break;
- }
- }
- if (ret != -EINTR) {
- drm_wait_vblank_reply(dev, pipe, &vblwait->reply);
- drm_dbg_core(dev, "crtc %d returning %u to client\n",
- pipe, vblwait->reply.sequence);
- } else {
- drm_dbg_core(dev, "crtc %d vblank wait interrupted by signal\n",
- pipe);
- }
- done:
- drm_vblank_put(dev, pipe);
- return ret;
- }
- static void drm_handle_vblank_events(struct drm_device *dev, unsigned int pipe)
- {
- struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
- bool high_prec = false;
- struct drm_pending_vblank_event *e, *t;
- ktime_t now;
- u64 seq;
- assert_spin_locked(&dev->event_lock);
- seq = drm_vblank_count_and_time(dev, pipe, &now);
- list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
- if (e->pipe != pipe)
- continue;
- if (!drm_vblank_passed(seq, e->sequence))
- continue;
- drm_dbg_core(dev, "vblank event on %llu, current %llu\n",
- e->sequence, seq);
- list_del(&e->base.link);
- drm_vblank_put(dev, pipe);
- send_vblank_event(dev, e, seq, now);
- }
- if (crtc && crtc->funcs->get_vblank_timestamp)
- high_prec = true;
- trace_drm_vblank_event(pipe, seq, now, high_prec);
- }
- /**
- * drm_handle_vblank - handle a vblank event
- * @dev: DRM device
- * @pipe: index of CRTC where this event occurred
- *
- * Drivers should call this routine in their vblank interrupt handlers to
- * update the vblank counter and send any signals that may be pending.
- *
- * This is the legacy version of drm_crtc_handle_vblank().
- */
- bool drm_handle_vblank(struct drm_device *dev, unsigned int pipe)
- {
- struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
- unsigned long irqflags;
- bool disable_irq;
- if (drm_WARN_ON_ONCE(dev, !drm_dev_has_vblank(dev)))
- return false;
- if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
- return false;
- spin_lock_irqsave(&dev->event_lock, irqflags);
- /* Need timestamp lock to prevent concurrent execution with
- * vblank enable/disable, as this would cause inconsistent
- * or corrupted timestamps and vblank counts.
- */
- spin_lock(&dev->vblank_time_lock);
- /* Vblank irq handling disabled. Nothing to do. */
- if (!vblank->enabled) {
- spin_unlock(&dev->vblank_time_lock);
- spin_unlock_irqrestore(&dev->event_lock, irqflags);
- return false;
- }
- drm_update_vblank_count(dev, pipe, true);
- spin_unlock(&dev->vblank_time_lock);
- wake_up(&vblank->queue);
- /* With instant-off, we defer disabling the interrupt until after
- * we finish processing the following vblank after all events have
- * been signaled. The disable has to be last (after
- * drm_handle_vblank_events) so that the timestamp is always accurate.
- */
- disable_irq = (dev->vblank_disable_immediate &&
- drm_vblank_offdelay > 0 &&
- !atomic_read(&vblank->refcount));
- drm_handle_vblank_events(dev, pipe);
- drm_handle_vblank_works(vblank);
- spin_unlock_irqrestore(&dev->event_lock, irqflags);
- if (disable_irq)
- vblank_disable_fn(&vblank->disable_timer);
- return true;
- }
- EXPORT_SYMBOL(drm_handle_vblank);
- /**
- * drm_crtc_handle_vblank - handle a vblank event
- * @crtc: where this event occurred
- *
- * Drivers should call this routine in their vblank interrupt handlers to
- * update the vblank counter and send any signals that may be pending.
- *
- * This is the native KMS version of drm_handle_vblank().
- *
- * Note that for a given vblank counter value drm_crtc_handle_vblank()
- * and drm_crtc_vblank_count() or drm_crtc_vblank_count_and_time()
- * provide a barrier: Any writes done before calling
- * drm_crtc_handle_vblank() will be visible to callers of the later
- * functions, if the vblank count is the same or a later one.
- *
- * See also &drm_vblank_crtc.count.
- *
- * Returns:
- * True if the event was successfully handled, false on failure.
- */
- bool drm_crtc_handle_vblank(struct drm_crtc *crtc)
- {
- return drm_handle_vblank(crtc->dev, drm_crtc_index(crtc));
- }
- EXPORT_SYMBOL(drm_crtc_handle_vblank);
- /*
- * Get crtc VBLANK count.
- *
- * \param dev DRM device
- * \param data user argument, pointing to a drm_crtc_get_sequence structure.
- * \param file_priv drm file private for the user's open file descriptor
- */
- int drm_crtc_get_sequence_ioctl(struct drm_device *dev, void *data,
- struct drm_file *file_priv)
- {
- struct drm_crtc *crtc;
- struct drm_vblank_crtc *vblank;
- int pipe;
- struct drm_crtc_get_sequence *get_seq = data;
- ktime_t now;
- bool vblank_enabled;
- int ret;
- if (!drm_core_check_feature(dev, DRIVER_MODESET))
- return -EOPNOTSUPP;
- if (!drm_dev_has_vblank(dev))
- return -EOPNOTSUPP;
- crtc = drm_crtc_find(dev, file_priv, get_seq->crtc_id);
- if (!crtc)
- return -ENOENT;
- pipe = drm_crtc_index(crtc);
- vblank = &dev->vblank[pipe];
- vblank_enabled = dev->vblank_disable_immediate && READ_ONCE(vblank->enabled);
- if (!vblank_enabled) {
- ret = drm_crtc_vblank_get(crtc);
- if (ret) {
- drm_dbg_core(dev,
- "crtc %d failed to acquire vblank counter, %d\n",
- pipe, ret);
- return ret;
- }
- }
- drm_modeset_lock(&crtc->mutex, NULL);
- if (crtc->state)
- get_seq->active = crtc->state->enable;
- else
- get_seq->active = crtc->enabled;
- drm_modeset_unlock(&crtc->mutex);
- get_seq->sequence = drm_vblank_count_and_time(dev, pipe, &now);
- get_seq->sequence_ns = ktime_to_ns(now);
- if (!vblank_enabled)
- drm_crtc_vblank_put(crtc);
- return 0;
- }
- /*
- * Queue a event for VBLANK sequence
- *
- * \param dev DRM device
- * \param data user argument, pointing to a drm_crtc_queue_sequence structure.
- * \param file_priv drm file private for the user's open file descriptor
- */
- int drm_crtc_queue_sequence_ioctl(struct drm_device *dev, void *data,
- struct drm_file *file_priv)
- {
- struct drm_crtc *crtc;
- struct drm_vblank_crtc *vblank;
- int pipe;
- struct drm_crtc_queue_sequence *queue_seq = data;
- ktime_t now;
- struct drm_pending_vblank_event *e;
- u32 flags;
- u64 seq;
- u64 req_seq;
- int ret;
- if (!drm_core_check_feature(dev, DRIVER_MODESET))
- return -EOPNOTSUPP;
- if (!drm_dev_has_vblank(dev))
- return -EOPNOTSUPP;
- crtc = drm_crtc_find(dev, file_priv, queue_seq->crtc_id);
- if (!crtc)
- return -ENOENT;
- flags = queue_seq->flags;
- /* Check valid flag bits */
- if (flags & ~(DRM_CRTC_SEQUENCE_RELATIVE|
- DRM_CRTC_SEQUENCE_NEXT_ON_MISS))
- return -EINVAL;
- pipe = drm_crtc_index(crtc);
- vblank = &dev->vblank[pipe];
- e = kzalloc(sizeof(*e), GFP_KERNEL);
- if (e == NULL)
- return -ENOMEM;
- ret = drm_crtc_vblank_get(crtc);
- if (ret) {
- drm_dbg_core(dev,
- "crtc %d failed to acquire vblank counter, %d\n",
- pipe, ret);
- goto err_free;
- }
- seq = drm_vblank_count_and_time(dev, pipe, &now);
- req_seq = queue_seq->sequence;
- if (flags & DRM_CRTC_SEQUENCE_RELATIVE)
- req_seq += seq;
- if ((flags & DRM_CRTC_SEQUENCE_NEXT_ON_MISS) && drm_vblank_passed(seq, req_seq))
- req_seq = seq + 1;
- e->pipe = pipe;
- e->event.base.type = DRM_EVENT_CRTC_SEQUENCE;
- e->event.base.length = sizeof(e->event.seq);
- e->event.seq.user_data = queue_seq->user_data;
- spin_lock_irq(&dev->event_lock);
- /*
- * drm_crtc_vblank_off() might have been called after we called
- * drm_crtc_vblank_get(). drm_crtc_vblank_off() holds event_lock around the
- * vblank disable, so no need for further locking. The reference from
- * drm_crtc_vblank_get() protects against vblank disable from another source.
- */
- if (!READ_ONCE(vblank->enabled)) {
- ret = -EINVAL;
- goto err_unlock;
- }
- ret = drm_event_reserve_init_locked(dev, file_priv, &e->base,
- &e->event.base);
- if (ret)
- goto err_unlock;
- e->sequence = req_seq;
- if (drm_vblank_passed(seq, req_seq)) {
- drm_crtc_vblank_put(crtc);
- send_vblank_event(dev, e, seq, now);
- queue_seq->sequence = seq;
- } else {
- /* drm_handle_vblank_events will call drm_vblank_put */
- list_add_tail(&e->base.link, &dev->vblank_event_list);
- queue_seq->sequence = req_seq;
- }
- spin_unlock_irq(&dev->event_lock);
- return 0;
- err_unlock:
- spin_unlock_irq(&dev->event_lock);
- drm_crtc_vblank_put(crtc);
- err_free:
- kfree(e);
- return ret;
- }
|