kv_dpm.c 91 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348
  1. /*
  2. * Copyright 2013 Advanced Micro Devices, Inc.
  3. *
  4. * Permission is hereby granted, free of charge, to any person obtaining a
  5. * copy of this software and associated documentation files (the "Software"),
  6. * to deal in the Software without restriction, including without limitation
  7. * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8. * and/or sell copies of the Software, and to permit persons to whom the
  9. * Software is furnished to do so, subject to the following conditions:
  10. *
  11. * The above copyright notice and this permission notice shall be included in
  12. * all copies or substantial portions of the Software.
  13. *
  14. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  17. * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18. * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19. * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20. * OTHER DEALINGS IN THE SOFTWARE.
  21. *
  22. */
  23. #include <drm/drmP.h>
  24. #include "amdgpu.h"
  25. #include "amdgpu_pm.h"
  26. #include "cikd.h"
  27. #include "atom.h"
  28. #include "amdgpu_atombios.h"
  29. #include "amdgpu_dpm.h"
  30. #include "kv_dpm.h"
  31. #include "gfx_v7_0.h"
  32. #include <linux/seq_file.h>
  33. #include "smu/smu_7_0_0_d.h"
  34. #include "smu/smu_7_0_0_sh_mask.h"
  35. #include "gca/gfx_7_2_d.h"
  36. #include "gca/gfx_7_2_sh_mask.h"
  37. #define KV_MAX_DEEPSLEEP_DIVIDER_ID 5
  38. #define KV_MINIMUM_ENGINE_CLOCK 800
  39. #define SMC_RAM_END 0x40000
  40. static void kv_dpm_set_dpm_funcs(struct amdgpu_device *adev);
  41. static void kv_dpm_set_irq_funcs(struct amdgpu_device *adev);
  42. static int kv_enable_nb_dpm(struct amdgpu_device *adev,
  43. bool enable);
  44. static void kv_init_graphics_levels(struct amdgpu_device *adev);
  45. static int kv_calculate_ds_divider(struct amdgpu_device *adev);
  46. static int kv_calculate_nbps_level_settings(struct amdgpu_device *adev);
  47. static int kv_calculate_dpm_settings(struct amdgpu_device *adev);
  48. static void kv_enable_new_levels(struct amdgpu_device *adev);
  49. static void kv_program_nbps_index_settings(struct amdgpu_device *adev,
  50. struct amdgpu_ps *new_rps);
  51. static int kv_set_enabled_level(struct amdgpu_device *adev, u32 level);
  52. static int kv_set_enabled_levels(struct amdgpu_device *adev);
  53. static int kv_force_dpm_highest(struct amdgpu_device *adev);
  54. static int kv_force_dpm_lowest(struct amdgpu_device *adev);
  55. static void kv_apply_state_adjust_rules(struct amdgpu_device *adev,
  56. struct amdgpu_ps *new_rps,
  57. struct amdgpu_ps *old_rps);
  58. static int kv_set_thermal_temperature_range(struct amdgpu_device *adev,
  59. int min_temp, int max_temp);
  60. static int kv_init_fps_limits(struct amdgpu_device *adev);
  61. static void kv_dpm_powergate_uvd(struct amdgpu_device *adev, bool gate);
  62. static void kv_dpm_powergate_vce(struct amdgpu_device *adev, bool gate);
  63. static void kv_dpm_powergate_samu(struct amdgpu_device *adev, bool gate);
  64. static void kv_dpm_powergate_acp(struct amdgpu_device *adev, bool gate);
  65. static u32 kv_convert_vid2_to_vid7(struct amdgpu_device *adev,
  66. struct sumo_vid_mapping_table *vid_mapping_table,
  67. u32 vid_2bit)
  68. {
  69. struct amdgpu_clock_voltage_dependency_table *vddc_sclk_table =
  70. &adev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
  71. u32 i;
  72. if (vddc_sclk_table && vddc_sclk_table->count) {
  73. if (vid_2bit < vddc_sclk_table->count)
  74. return vddc_sclk_table->entries[vid_2bit].v;
  75. else
  76. return vddc_sclk_table->entries[vddc_sclk_table->count - 1].v;
  77. } else {
  78. for (i = 0; i < vid_mapping_table->num_entries; i++) {
  79. if (vid_mapping_table->entries[i].vid_2bit == vid_2bit)
  80. return vid_mapping_table->entries[i].vid_7bit;
  81. }
  82. return vid_mapping_table->entries[vid_mapping_table->num_entries - 1].vid_7bit;
  83. }
  84. }
  85. static u32 kv_convert_vid7_to_vid2(struct amdgpu_device *adev,
  86. struct sumo_vid_mapping_table *vid_mapping_table,
  87. u32 vid_7bit)
  88. {
  89. struct amdgpu_clock_voltage_dependency_table *vddc_sclk_table =
  90. &adev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
  91. u32 i;
  92. if (vddc_sclk_table && vddc_sclk_table->count) {
  93. for (i = 0; i < vddc_sclk_table->count; i++) {
  94. if (vddc_sclk_table->entries[i].v == vid_7bit)
  95. return i;
  96. }
  97. return vddc_sclk_table->count - 1;
  98. } else {
  99. for (i = 0; i < vid_mapping_table->num_entries; i++) {
  100. if (vid_mapping_table->entries[i].vid_7bit == vid_7bit)
  101. return vid_mapping_table->entries[i].vid_2bit;
  102. }
  103. return vid_mapping_table->entries[vid_mapping_table->num_entries - 1].vid_2bit;
  104. }
  105. }
  106. static void sumo_take_smu_control(struct amdgpu_device *adev, bool enable)
  107. {
  108. /* This bit selects who handles display phy powergating.
  109. * Clear the bit to let atom handle it.
  110. * Set it to let the driver handle it.
  111. * For now we just let atom handle it.
  112. */
  113. #if 0
  114. u32 v = RREG32(mmDOUT_SCRATCH3);
  115. if (enable)
  116. v |= 0x4;
  117. else
  118. v &= 0xFFFFFFFB;
  119. WREG32(mmDOUT_SCRATCH3, v);
  120. #endif
  121. }
  122. static void sumo_construct_sclk_voltage_mapping_table(struct amdgpu_device *adev,
  123. struct sumo_sclk_voltage_mapping_table *sclk_voltage_mapping_table,
  124. ATOM_AVAILABLE_SCLK_LIST *table)
  125. {
  126. u32 i;
  127. u32 n = 0;
  128. u32 prev_sclk = 0;
  129. for (i = 0; i < SUMO_MAX_HARDWARE_POWERLEVELS; i++) {
  130. if (table[i].ulSupportedSCLK > prev_sclk) {
  131. sclk_voltage_mapping_table->entries[n].sclk_frequency =
  132. table[i].ulSupportedSCLK;
  133. sclk_voltage_mapping_table->entries[n].vid_2bit =
  134. table[i].usVoltageIndex;
  135. prev_sclk = table[i].ulSupportedSCLK;
  136. n++;
  137. }
  138. }
  139. sclk_voltage_mapping_table->num_max_dpm_entries = n;
  140. }
  141. static void sumo_construct_vid_mapping_table(struct amdgpu_device *adev,
  142. struct sumo_vid_mapping_table *vid_mapping_table,
  143. ATOM_AVAILABLE_SCLK_LIST *table)
  144. {
  145. u32 i, j;
  146. for (i = 0; i < SUMO_MAX_HARDWARE_POWERLEVELS; i++) {
  147. if (table[i].ulSupportedSCLK != 0) {
  148. vid_mapping_table->entries[table[i].usVoltageIndex].vid_7bit =
  149. table[i].usVoltageID;
  150. vid_mapping_table->entries[table[i].usVoltageIndex].vid_2bit =
  151. table[i].usVoltageIndex;
  152. }
  153. }
  154. for (i = 0; i < SUMO_MAX_NUMBER_VOLTAGES; i++) {
  155. if (vid_mapping_table->entries[i].vid_7bit == 0) {
  156. for (j = i + 1; j < SUMO_MAX_NUMBER_VOLTAGES; j++) {
  157. if (vid_mapping_table->entries[j].vid_7bit != 0) {
  158. vid_mapping_table->entries[i] =
  159. vid_mapping_table->entries[j];
  160. vid_mapping_table->entries[j].vid_7bit = 0;
  161. break;
  162. }
  163. }
  164. if (j == SUMO_MAX_NUMBER_VOLTAGES)
  165. break;
  166. }
  167. }
  168. vid_mapping_table->num_entries = i;
  169. }
  170. #if 0
  171. static const struct kv_lcac_config_values sx_local_cac_cfg_kv[] =
  172. {
  173. { 0, 4, 1 },
  174. { 1, 4, 1 },
  175. { 2, 5, 1 },
  176. { 3, 4, 2 },
  177. { 4, 1, 1 },
  178. { 5, 5, 2 },
  179. { 6, 6, 1 },
  180. { 7, 9, 2 },
  181. { 0xffffffff }
  182. };
  183. static const struct kv_lcac_config_values mc0_local_cac_cfg_kv[] =
  184. {
  185. { 0, 4, 1 },
  186. { 0xffffffff }
  187. };
  188. static const struct kv_lcac_config_values mc1_local_cac_cfg_kv[] =
  189. {
  190. { 0, 4, 1 },
  191. { 0xffffffff }
  192. };
  193. static const struct kv_lcac_config_values mc2_local_cac_cfg_kv[] =
  194. {
  195. { 0, 4, 1 },
  196. { 0xffffffff }
  197. };
  198. static const struct kv_lcac_config_values mc3_local_cac_cfg_kv[] =
  199. {
  200. { 0, 4, 1 },
  201. { 0xffffffff }
  202. };
  203. static const struct kv_lcac_config_values cpl_local_cac_cfg_kv[] =
  204. {
  205. { 0, 4, 1 },
  206. { 1, 4, 1 },
  207. { 2, 5, 1 },
  208. { 3, 4, 1 },
  209. { 4, 1, 1 },
  210. { 5, 5, 1 },
  211. { 6, 6, 1 },
  212. { 7, 9, 1 },
  213. { 8, 4, 1 },
  214. { 9, 2, 1 },
  215. { 10, 3, 1 },
  216. { 11, 6, 1 },
  217. { 12, 8, 2 },
  218. { 13, 1, 1 },
  219. { 14, 2, 1 },
  220. { 15, 3, 1 },
  221. { 16, 1, 1 },
  222. { 17, 4, 1 },
  223. { 18, 3, 1 },
  224. { 19, 1, 1 },
  225. { 20, 8, 1 },
  226. { 21, 5, 1 },
  227. { 22, 1, 1 },
  228. { 23, 1, 1 },
  229. { 24, 4, 1 },
  230. { 27, 6, 1 },
  231. { 28, 1, 1 },
  232. { 0xffffffff }
  233. };
  234. static const struct kv_lcac_config_reg sx0_cac_config_reg[] =
  235. {
  236. { 0xc0400d00, 0x003e0000, 17, 0x3fc00000, 22, 0x0001fffe, 1, 0x00000001, 0 }
  237. };
  238. static const struct kv_lcac_config_reg mc0_cac_config_reg[] =
  239. {
  240. { 0xc0400d30, 0x003e0000, 17, 0x3fc00000, 22, 0x0001fffe, 1, 0x00000001, 0 }
  241. };
  242. static const struct kv_lcac_config_reg mc1_cac_config_reg[] =
  243. {
  244. { 0xc0400d3c, 0x003e0000, 17, 0x3fc00000, 22, 0x0001fffe, 1, 0x00000001, 0 }
  245. };
  246. static const struct kv_lcac_config_reg mc2_cac_config_reg[] =
  247. {
  248. { 0xc0400d48, 0x003e0000, 17, 0x3fc00000, 22, 0x0001fffe, 1, 0x00000001, 0 }
  249. };
  250. static const struct kv_lcac_config_reg mc3_cac_config_reg[] =
  251. {
  252. { 0xc0400d54, 0x003e0000, 17, 0x3fc00000, 22, 0x0001fffe, 1, 0x00000001, 0 }
  253. };
  254. static const struct kv_lcac_config_reg cpl_cac_config_reg[] =
  255. {
  256. { 0xc0400d80, 0x003e0000, 17, 0x3fc00000, 22, 0x0001fffe, 1, 0x00000001, 0 }
  257. };
  258. #endif
  259. static const struct kv_pt_config_reg didt_config_kv[] =
  260. {
  261. { 0x10, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  262. { 0x10, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
  263. { 0x10, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
  264. { 0x10, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
  265. { 0x11, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  266. { 0x11, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
  267. { 0x11, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
  268. { 0x11, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
  269. { 0x12, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  270. { 0x12, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
  271. { 0x12, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
  272. { 0x12, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
  273. { 0x2, 0x00003fff, 0, 0x4, KV_CONFIGREG_DIDT_IND },
  274. { 0x2, 0x03ff0000, 16, 0x80, KV_CONFIGREG_DIDT_IND },
  275. { 0x2, 0x78000000, 27, 0x3, KV_CONFIGREG_DIDT_IND },
  276. { 0x1, 0x0000ffff, 0, 0x3FFF, KV_CONFIGREG_DIDT_IND },
  277. { 0x1, 0xffff0000, 16, 0x3FFF, KV_CONFIGREG_DIDT_IND },
  278. { 0x0, 0x00000001, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  279. { 0x30, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  280. { 0x30, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
  281. { 0x30, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
  282. { 0x30, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
  283. { 0x31, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  284. { 0x31, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
  285. { 0x31, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
  286. { 0x31, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
  287. { 0x32, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  288. { 0x32, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
  289. { 0x32, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
  290. { 0x32, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
  291. { 0x22, 0x00003fff, 0, 0x4, KV_CONFIGREG_DIDT_IND },
  292. { 0x22, 0x03ff0000, 16, 0x80, KV_CONFIGREG_DIDT_IND },
  293. { 0x22, 0x78000000, 27, 0x3, KV_CONFIGREG_DIDT_IND },
  294. { 0x21, 0x0000ffff, 0, 0x3FFF, KV_CONFIGREG_DIDT_IND },
  295. { 0x21, 0xffff0000, 16, 0x3FFF, KV_CONFIGREG_DIDT_IND },
  296. { 0x20, 0x00000001, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  297. { 0x50, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  298. { 0x50, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
  299. { 0x50, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
  300. { 0x50, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
  301. { 0x51, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  302. { 0x51, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
  303. { 0x51, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
  304. { 0x51, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
  305. { 0x52, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  306. { 0x52, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
  307. { 0x52, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
  308. { 0x52, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
  309. { 0x42, 0x00003fff, 0, 0x4, KV_CONFIGREG_DIDT_IND },
  310. { 0x42, 0x03ff0000, 16, 0x80, KV_CONFIGREG_DIDT_IND },
  311. { 0x42, 0x78000000, 27, 0x3, KV_CONFIGREG_DIDT_IND },
  312. { 0x41, 0x0000ffff, 0, 0x3FFF, KV_CONFIGREG_DIDT_IND },
  313. { 0x41, 0xffff0000, 16, 0x3FFF, KV_CONFIGREG_DIDT_IND },
  314. { 0x40, 0x00000001, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  315. { 0x70, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  316. { 0x70, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
  317. { 0x70, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
  318. { 0x70, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
  319. { 0x71, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  320. { 0x71, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
  321. { 0x71, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
  322. { 0x71, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
  323. { 0x72, 0x000000ff, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  324. { 0x72, 0x0000ff00, 8, 0x0, KV_CONFIGREG_DIDT_IND },
  325. { 0x72, 0x00ff0000, 16, 0x0, KV_CONFIGREG_DIDT_IND },
  326. { 0x72, 0xff000000, 24, 0x0, KV_CONFIGREG_DIDT_IND },
  327. { 0x62, 0x00003fff, 0, 0x4, KV_CONFIGREG_DIDT_IND },
  328. { 0x62, 0x03ff0000, 16, 0x80, KV_CONFIGREG_DIDT_IND },
  329. { 0x62, 0x78000000, 27, 0x3, KV_CONFIGREG_DIDT_IND },
  330. { 0x61, 0x0000ffff, 0, 0x3FFF, KV_CONFIGREG_DIDT_IND },
  331. { 0x61, 0xffff0000, 16, 0x3FFF, KV_CONFIGREG_DIDT_IND },
  332. { 0x60, 0x00000001, 0, 0x0, KV_CONFIGREG_DIDT_IND },
  333. { 0xFFFFFFFF }
  334. };
  335. static struct kv_ps *kv_get_ps(struct amdgpu_ps *rps)
  336. {
  337. struct kv_ps *ps = rps->ps_priv;
  338. return ps;
  339. }
  340. static struct kv_power_info *kv_get_pi(struct amdgpu_device *adev)
  341. {
  342. struct kv_power_info *pi = adev->pm.dpm.priv;
  343. return pi;
  344. }
  345. #if 0
  346. static void kv_program_local_cac_table(struct amdgpu_device *adev,
  347. const struct kv_lcac_config_values *local_cac_table,
  348. const struct kv_lcac_config_reg *local_cac_reg)
  349. {
  350. u32 i, count, data;
  351. const struct kv_lcac_config_values *values = local_cac_table;
  352. while (values->block_id != 0xffffffff) {
  353. count = values->signal_id;
  354. for (i = 0; i < count; i++) {
  355. data = ((values->block_id << local_cac_reg->block_shift) &
  356. local_cac_reg->block_mask);
  357. data |= ((i << local_cac_reg->signal_shift) &
  358. local_cac_reg->signal_mask);
  359. data |= ((values->t << local_cac_reg->t_shift) &
  360. local_cac_reg->t_mask);
  361. data |= ((1 << local_cac_reg->enable_shift) &
  362. local_cac_reg->enable_mask);
  363. WREG32_SMC(local_cac_reg->cntl, data);
  364. }
  365. values++;
  366. }
  367. }
  368. #endif
  369. static int kv_program_pt_config_registers(struct amdgpu_device *adev,
  370. const struct kv_pt_config_reg *cac_config_regs)
  371. {
  372. const struct kv_pt_config_reg *config_regs = cac_config_regs;
  373. u32 data;
  374. u32 cache = 0;
  375. if (config_regs == NULL)
  376. return -EINVAL;
  377. while (config_regs->offset != 0xFFFFFFFF) {
  378. if (config_regs->type == KV_CONFIGREG_CACHE) {
  379. cache |= ((config_regs->value << config_regs->shift) & config_regs->mask);
  380. } else {
  381. switch (config_regs->type) {
  382. case KV_CONFIGREG_SMC_IND:
  383. data = RREG32_SMC(config_regs->offset);
  384. break;
  385. case KV_CONFIGREG_DIDT_IND:
  386. data = RREG32_DIDT(config_regs->offset);
  387. break;
  388. default:
  389. data = RREG32(config_regs->offset);
  390. break;
  391. }
  392. data &= ~config_regs->mask;
  393. data |= ((config_regs->value << config_regs->shift) & config_regs->mask);
  394. data |= cache;
  395. cache = 0;
  396. switch (config_regs->type) {
  397. case KV_CONFIGREG_SMC_IND:
  398. WREG32_SMC(config_regs->offset, data);
  399. break;
  400. case KV_CONFIGREG_DIDT_IND:
  401. WREG32_DIDT(config_regs->offset, data);
  402. break;
  403. default:
  404. WREG32(config_regs->offset, data);
  405. break;
  406. }
  407. }
  408. config_regs++;
  409. }
  410. return 0;
  411. }
  412. static void kv_do_enable_didt(struct amdgpu_device *adev, bool enable)
  413. {
  414. struct kv_power_info *pi = kv_get_pi(adev);
  415. u32 data;
  416. if (pi->caps_sq_ramping) {
  417. data = RREG32_DIDT(ixDIDT_SQ_CTRL0);
  418. if (enable)
  419. data |= DIDT_SQ_CTRL0__DIDT_CTRL_EN_MASK;
  420. else
  421. data &= ~DIDT_SQ_CTRL0__DIDT_CTRL_EN_MASK;
  422. WREG32_DIDT(ixDIDT_SQ_CTRL0, data);
  423. }
  424. if (pi->caps_db_ramping) {
  425. data = RREG32_DIDT(ixDIDT_DB_CTRL0);
  426. if (enable)
  427. data |= DIDT_DB_CTRL0__DIDT_CTRL_EN_MASK;
  428. else
  429. data &= ~DIDT_DB_CTRL0__DIDT_CTRL_EN_MASK;
  430. WREG32_DIDT(ixDIDT_DB_CTRL0, data);
  431. }
  432. if (pi->caps_td_ramping) {
  433. data = RREG32_DIDT(ixDIDT_TD_CTRL0);
  434. if (enable)
  435. data |= DIDT_TD_CTRL0__DIDT_CTRL_EN_MASK;
  436. else
  437. data &= ~DIDT_TD_CTRL0__DIDT_CTRL_EN_MASK;
  438. WREG32_DIDT(ixDIDT_TD_CTRL0, data);
  439. }
  440. if (pi->caps_tcp_ramping) {
  441. data = RREG32_DIDT(ixDIDT_TCP_CTRL0);
  442. if (enable)
  443. data |= DIDT_TCP_CTRL0__DIDT_CTRL_EN_MASK;
  444. else
  445. data &= ~DIDT_TCP_CTRL0__DIDT_CTRL_EN_MASK;
  446. WREG32_DIDT(ixDIDT_TCP_CTRL0, data);
  447. }
  448. }
  449. static int kv_enable_didt(struct amdgpu_device *adev, bool enable)
  450. {
  451. struct kv_power_info *pi = kv_get_pi(adev);
  452. int ret;
  453. if (pi->caps_sq_ramping ||
  454. pi->caps_db_ramping ||
  455. pi->caps_td_ramping ||
  456. pi->caps_tcp_ramping) {
  457. adev->gfx.rlc.funcs->enter_safe_mode(adev);
  458. if (enable) {
  459. ret = kv_program_pt_config_registers(adev, didt_config_kv);
  460. if (ret) {
  461. adev->gfx.rlc.funcs->exit_safe_mode(adev);
  462. return ret;
  463. }
  464. }
  465. kv_do_enable_didt(adev, enable);
  466. adev->gfx.rlc.funcs->exit_safe_mode(adev);
  467. }
  468. return 0;
  469. }
  470. #if 0
  471. static void kv_initialize_hardware_cac_manager(struct amdgpu_device *adev)
  472. {
  473. struct kv_power_info *pi = kv_get_pi(adev);
  474. if (pi->caps_cac) {
  475. WREG32_SMC(ixLCAC_SX0_OVR_SEL, 0);
  476. WREG32_SMC(ixLCAC_SX0_OVR_VAL, 0);
  477. kv_program_local_cac_table(adev, sx_local_cac_cfg_kv, sx0_cac_config_reg);
  478. WREG32_SMC(ixLCAC_MC0_OVR_SEL, 0);
  479. WREG32_SMC(ixLCAC_MC0_OVR_VAL, 0);
  480. kv_program_local_cac_table(adev, mc0_local_cac_cfg_kv, mc0_cac_config_reg);
  481. WREG32_SMC(ixLCAC_MC1_OVR_SEL, 0);
  482. WREG32_SMC(ixLCAC_MC1_OVR_VAL, 0);
  483. kv_program_local_cac_table(adev, mc1_local_cac_cfg_kv, mc1_cac_config_reg);
  484. WREG32_SMC(ixLCAC_MC2_OVR_SEL, 0);
  485. WREG32_SMC(ixLCAC_MC2_OVR_VAL, 0);
  486. kv_program_local_cac_table(adev, mc2_local_cac_cfg_kv, mc2_cac_config_reg);
  487. WREG32_SMC(ixLCAC_MC3_OVR_SEL, 0);
  488. WREG32_SMC(ixLCAC_MC3_OVR_VAL, 0);
  489. kv_program_local_cac_table(adev, mc3_local_cac_cfg_kv, mc3_cac_config_reg);
  490. WREG32_SMC(ixLCAC_CPL_OVR_SEL, 0);
  491. WREG32_SMC(ixLCAC_CPL_OVR_VAL, 0);
  492. kv_program_local_cac_table(adev, cpl_local_cac_cfg_kv, cpl_cac_config_reg);
  493. }
  494. }
  495. #endif
  496. static int kv_enable_smc_cac(struct amdgpu_device *adev, bool enable)
  497. {
  498. struct kv_power_info *pi = kv_get_pi(adev);
  499. int ret = 0;
  500. if (pi->caps_cac) {
  501. if (enable) {
  502. ret = amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_EnableCac);
  503. if (ret)
  504. pi->cac_enabled = false;
  505. else
  506. pi->cac_enabled = true;
  507. } else if (pi->cac_enabled) {
  508. amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_DisableCac);
  509. pi->cac_enabled = false;
  510. }
  511. }
  512. return ret;
  513. }
  514. static int kv_process_firmware_header(struct amdgpu_device *adev)
  515. {
  516. struct kv_power_info *pi = kv_get_pi(adev);
  517. u32 tmp;
  518. int ret;
  519. ret = amdgpu_kv_read_smc_sram_dword(adev, SMU7_FIRMWARE_HEADER_LOCATION +
  520. offsetof(SMU7_Firmware_Header, DpmTable),
  521. &tmp, pi->sram_end);
  522. if (ret == 0)
  523. pi->dpm_table_start = tmp;
  524. ret = amdgpu_kv_read_smc_sram_dword(adev, SMU7_FIRMWARE_HEADER_LOCATION +
  525. offsetof(SMU7_Firmware_Header, SoftRegisters),
  526. &tmp, pi->sram_end);
  527. if (ret == 0)
  528. pi->soft_regs_start = tmp;
  529. return ret;
  530. }
  531. static int kv_enable_dpm_voltage_scaling(struct amdgpu_device *adev)
  532. {
  533. struct kv_power_info *pi = kv_get_pi(adev);
  534. int ret;
  535. pi->graphics_voltage_change_enable = 1;
  536. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  537. pi->dpm_table_start +
  538. offsetof(SMU7_Fusion_DpmTable, GraphicsVoltageChangeEnable),
  539. &pi->graphics_voltage_change_enable,
  540. sizeof(u8), pi->sram_end);
  541. return ret;
  542. }
  543. static int kv_set_dpm_interval(struct amdgpu_device *adev)
  544. {
  545. struct kv_power_info *pi = kv_get_pi(adev);
  546. int ret;
  547. pi->graphics_interval = 1;
  548. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  549. pi->dpm_table_start +
  550. offsetof(SMU7_Fusion_DpmTable, GraphicsInterval),
  551. &pi->graphics_interval,
  552. sizeof(u8), pi->sram_end);
  553. return ret;
  554. }
  555. static int kv_set_dpm_boot_state(struct amdgpu_device *adev)
  556. {
  557. struct kv_power_info *pi = kv_get_pi(adev);
  558. int ret;
  559. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  560. pi->dpm_table_start +
  561. offsetof(SMU7_Fusion_DpmTable, GraphicsBootLevel),
  562. &pi->graphics_boot_level,
  563. sizeof(u8), pi->sram_end);
  564. return ret;
  565. }
  566. static void kv_program_vc(struct amdgpu_device *adev)
  567. {
  568. WREG32_SMC(ixCG_FREQ_TRAN_VOTING_0, 0x3FFFC100);
  569. }
  570. static void kv_clear_vc(struct amdgpu_device *adev)
  571. {
  572. WREG32_SMC(ixCG_FREQ_TRAN_VOTING_0, 0);
  573. }
  574. static int kv_set_divider_value(struct amdgpu_device *adev,
  575. u32 index, u32 sclk)
  576. {
  577. struct kv_power_info *pi = kv_get_pi(adev);
  578. struct atom_clock_dividers dividers;
  579. int ret;
  580. ret = amdgpu_atombios_get_clock_dividers(adev, COMPUTE_ENGINE_PLL_PARAM,
  581. sclk, false, &dividers);
  582. if (ret)
  583. return ret;
  584. pi->graphics_level[index].SclkDid = (u8)dividers.post_div;
  585. pi->graphics_level[index].SclkFrequency = cpu_to_be32(sclk);
  586. return 0;
  587. }
  588. static u16 kv_convert_8bit_index_to_voltage(struct amdgpu_device *adev,
  589. u16 voltage)
  590. {
  591. return 6200 - (voltage * 25);
  592. }
  593. static u16 kv_convert_2bit_index_to_voltage(struct amdgpu_device *adev,
  594. u32 vid_2bit)
  595. {
  596. struct kv_power_info *pi = kv_get_pi(adev);
  597. u32 vid_8bit = kv_convert_vid2_to_vid7(adev,
  598. &pi->sys_info.vid_mapping_table,
  599. vid_2bit);
  600. return kv_convert_8bit_index_to_voltage(adev, (u16)vid_8bit);
  601. }
  602. static int kv_set_vid(struct amdgpu_device *adev, u32 index, u32 vid)
  603. {
  604. struct kv_power_info *pi = kv_get_pi(adev);
  605. pi->graphics_level[index].VoltageDownH = (u8)pi->voltage_drop_t;
  606. pi->graphics_level[index].MinVddNb =
  607. cpu_to_be32(kv_convert_2bit_index_to_voltage(adev, vid));
  608. return 0;
  609. }
  610. static int kv_set_at(struct amdgpu_device *adev, u32 index, u32 at)
  611. {
  612. struct kv_power_info *pi = kv_get_pi(adev);
  613. pi->graphics_level[index].AT = cpu_to_be16((u16)at);
  614. return 0;
  615. }
  616. static void kv_dpm_power_level_enable(struct amdgpu_device *adev,
  617. u32 index, bool enable)
  618. {
  619. struct kv_power_info *pi = kv_get_pi(adev);
  620. pi->graphics_level[index].EnabledForActivity = enable ? 1 : 0;
  621. }
  622. static void kv_start_dpm(struct amdgpu_device *adev)
  623. {
  624. u32 tmp = RREG32_SMC(ixGENERAL_PWRMGT);
  625. tmp |= GENERAL_PWRMGT__GLOBAL_PWRMGT_EN_MASK;
  626. WREG32_SMC(ixGENERAL_PWRMGT, tmp);
  627. amdgpu_kv_smc_dpm_enable(adev, true);
  628. }
  629. static void kv_stop_dpm(struct amdgpu_device *adev)
  630. {
  631. amdgpu_kv_smc_dpm_enable(adev, false);
  632. }
  633. static void kv_start_am(struct amdgpu_device *adev)
  634. {
  635. u32 sclk_pwrmgt_cntl = RREG32_SMC(ixSCLK_PWRMGT_CNTL);
  636. sclk_pwrmgt_cntl &= ~(SCLK_PWRMGT_CNTL__RESET_SCLK_CNT_MASK |
  637. SCLK_PWRMGT_CNTL__RESET_BUSY_CNT_MASK);
  638. sclk_pwrmgt_cntl |= SCLK_PWRMGT_CNTL__DYNAMIC_PM_EN_MASK;
  639. WREG32_SMC(ixSCLK_PWRMGT_CNTL, sclk_pwrmgt_cntl);
  640. }
  641. static void kv_reset_am(struct amdgpu_device *adev)
  642. {
  643. u32 sclk_pwrmgt_cntl = RREG32_SMC(ixSCLK_PWRMGT_CNTL);
  644. sclk_pwrmgt_cntl |= (SCLK_PWRMGT_CNTL__RESET_SCLK_CNT_MASK |
  645. SCLK_PWRMGT_CNTL__RESET_BUSY_CNT_MASK);
  646. WREG32_SMC(ixSCLK_PWRMGT_CNTL, sclk_pwrmgt_cntl);
  647. }
  648. static int kv_freeze_sclk_dpm(struct amdgpu_device *adev, bool freeze)
  649. {
  650. return amdgpu_kv_notify_message_to_smu(adev, freeze ?
  651. PPSMC_MSG_SCLKDPM_FreezeLevel : PPSMC_MSG_SCLKDPM_UnfreezeLevel);
  652. }
  653. static int kv_force_lowest_valid(struct amdgpu_device *adev)
  654. {
  655. return kv_force_dpm_lowest(adev);
  656. }
  657. static int kv_unforce_levels(struct amdgpu_device *adev)
  658. {
  659. if (adev->asic_type == CHIP_KABINI || adev->asic_type == CHIP_MULLINS)
  660. return amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_NoForcedLevel);
  661. else
  662. return kv_set_enabled_levels(adev);
  663. }
  664. static int kv_update_sclk_t(struct amdgpu_device *adev)
  665. {
  666. struct kv_power_info *pi = kv_get_pi(adev);
  667. u32 low_sclk_interrupt_t = 0;
  668. int ret = 0;
  669. if (pi->caps_sclk_throttle_low_notification) {
  670. low_sclk_interrupt_t = cpu_to_be32(pi->low_sclk_interrupt_t);
  671. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  672. pi->dpm_table_start +
  673. offsetof(SMU7_Fusion_DpmTable, LowSclkInterruptT),
  674. (u8 *)&low_sclk_interrupt_t,
  675. sizeof(u32), pi->sram_end);
  676. }
  677. return ret;
  678. }
  679. static int kv_program_bootup_state(struct amdgpu_device *adev)
  680. {
  681. struct kv_power_info *pi = kv_get_pi(adev);
  682. u32 i;
  683. struct amdgpu_clock_voltage_dependency_table *table =
  684. &adev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
  685. if (table && table->count) {
  686. for (i = pi->graphics_dpm_level_count - 1; i > 0; i--) {
  687. if (table->entries[i].clk == pi->boot_pl.sclk)
  688. break;
  689. }
  690. pi->graphics_boot_level = (u8)i;
  691. kv_dpm_power_level_enable(adev, i, true);
  692. } else {
  693. struct sumo_sclk_voltage_mapping_table *table =
  694. &pi->sys_info.sclk_voltage_mapping_table;
  695. if (table->num_max_dpm_entries == 0)
  696. return -EINVAL;
  697. for (i = pi->graphics_dpm_level_count - 1; i > 0; i--) {
  698. if (table->entries[i].sclk_frequency == pi->boot_pl.sclk)
  699. break;
  700. }
  701. pi->graphics_boot_level = (u8)i;
  702. kv_dpm_power_level_enable(adev, i, true);
  703. }
  704. return 0;
  705. }
  706. static int kv_enable_auto_thermal_throttling(struct amdgpu_device *adev)
  707. {
  708. struct kv_power_info *pi = kv_get_pi(adev);
  709. int ret;
  710. pi->graphics_therm_throttle_enable = 1;
  711. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  712. pi->dpm_table_start +
  713. offsetof(SMU7_Fusion_DpmTable, GraphicsThermThrottleEnable),
  714. &pi->graphics_therm_throttle_enable,
  715. sizeof(u8), pi->sram_end);
  716. return ret;
  717. }
  718. static int kv_upload_dpm_settings(struct amdgpu_device *adev)
  719. {
  720. struct kv_power_info *pi = kv_get_pi(adev);
  721. int ret;
  722. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  723. pi->dpm_table_start +
  724. offsetof(SMU7_Fusion_DpmTable, GraphicsLevel),
  725. (u8 *)&pi->graphics_level,
  726. sizeof(SMU7_Fusion_GraphicsLevel) * SMU7_MAX_LEVELS_GRAPHICS,
  727. pi->sram_end);
  728. if (ret)
  729. return ret;
  730. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  731. pi->dpm_table_start +
  732. offsetof(SMU7_Fusion_DpmTable, GraphicsDpmLevelCount),
  733. &pi->graphics_dpm_level_count,
  734. sizeof(u8), pi->sram_end);
  735. return ret;
  736. }
  737. static u32 kv_get_clock_difference(u32 a, u32 b)
  738. {
  739. return (a >= b) ? a - b : b - a;
  740. }
  741. static u32 kv_get_clk_bypass(struct amdgpu_device *adev, u32 clk)
  742. {
  743. struct kv_power_info *pi = kv_get_pi(adev);
  744. u32 value;
  745. if (pi->caps_enable_dfs_bypass) {
  746. if (kv_get_clock_difference(clk, 40000) < 200)
  747. value = 3;
  748. else if (kv_get_clock_difference(clk, 30000) < 200)
  749. value = 2;
  750. else if (kv_get_clock_difference(clk, 20000) < 200)
  751. value = 7;
  752. else if (kv_get_clock_difference(clk, 15000) < 200)
  753. value = 6;
  754. else if (kv_get_clock_difference(clk, 10000) < 200)
  755. value = 8;
  756. else
  757. value = 0;
  758. } else {
  759. value = 0;
  760. }
  761. return value;
  762. }
  763. static int kv_populate_uvd_table(struct amdgpu_device *adev)
  764. {
  765. struct kv_power_info *pi = kv_get_pi(adev);
  766. struct amdgpu_uvd_clock_voltage_dependency_table *table =
  767. &adev->pm.dpm.dyn_state.uvd_clock_voltage_dependency_table;
  768. struct atom_clock_dividers dividers;
  769. int ret;
  770. u32 i;
  771. if (table == NULL || table->count == 0)
  772. return 0;
  773. pi->uvd_level_count = 0;
  774. for (i = 0; i < table->count; i++) {
  775. if (pi->high_voltage_t &&
  776. (pi->high_voltage_t < table->entries[i].v))
  777. break;
  778. pi->uvd_level[i].VclkFrequency = cpu_to_be32(table->entries[i].vclk);
  779. pi->uvd_level[i].DclkFrequency = cpu_to_be32(table->entries[i].dclk);
  780. pi->uvd_level[i].MinVddNb = cpu_to_be16(table->entries[i].v);
  781. pi->uvd_level[i].VClkBypassCntl =
  782. (u8)kv_get_clk_bypass(adev, table->entries[i].vclk);
  783. pi->uvd_level[i].DClkBypassCntl =
  784. (u8)kv_get_clk_bypass(adev, table->entries[i].dclk);
  785. ret = amdgpu_atombios_get_clock_dividers(adev, COMPUTE_ENGINE_PLL_PARAM,
  786. table->entries[i].vclk, false, &dividers);
  787. if (ret)
  788. return ret;
  789. pi->uvd_level[i].VclkDivider = (u8)dividers.post_div;
  790. ret = amdgpu_atombios_get_clock_dividers(adev, COMPUTE_ENGINE_PLL_PARAM,
  791. table->entries[i].dclk, false, &dividers);
  792. if (ret)
  793. return ret;
  794. pi->uvd_level[i].DclkDivider = (u8)dividers.post_div;
  795. pi->uvd_level_count++;
  796. }
  797. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  798. pi->dpm_table_start +
  799. offsetof(SMU7_Fusion_DpmTable, UvdLevelCount),
  800. (u8 *)&pi->uvd_level_count,
  801. sizeof(u8), pi->sram_end);
  802. if (ret)
  803. return ret;
  804. pi->uvd_interval = 1;
  805. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  806. pi->dpm_table_start +
  807. offsetof(SMU7_Fusion_DpmTable, UVDInterval),
  808. &pi->uvd_interval,
  809. sizeof(u8), pi->sram_end);
  810. if (ret)
  811. return ret;
  812. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  813. pi->dpm_table_start +
  814. offsetof(SMU7_Fusion_DpmTable, UvdLevel),
  815. (u8 *)&pi->uvd_level,
  816. sizeof(SMU7_Fusion_UvdLevel) * SMU7_MAX_LEVELS_UVD,
  817. pi->sram_end);
  818. return ret;
  819. }
  820. static int kv_populate_vce_table(struct amdgpu_device *adev)
  821. {
  822. struct kv_power_info *pi = kv_get_pi(adev);
  823. int ret;
  824. u32 i;
  825. struct amdgpu_vce_clock_voltage_dependency_table *table =
  826. &adev->pm.dpm.dyn_state.vce_clock_voltage_dependency_table;
  827. struct atom_clock_dividers dividers;
  828. if (table == NULL || table->count == 0)
  829. return 0;
  830. pi->vce_level_count = 0;
  831. for (i = 0; i < table->count; i++) {
  832. if (pi->high_voltage_t &&
  833. pi->high_voltage_t < table->entries[i].v)
  834. break;
  835. pi->vce_level[i].Frequency = cpu_to_be32(table->entries[i].evclk);
  836. pi->vce_level[i].MinVoltage = cpu_to_be16(table->entries[i].v);
  837. pi->vce_level[i].ClkBypassCntl =
  838. (u8)kv_get_clk_bypass(adev, table->entries[i].evclk);
  839. ret = amdgpu_atombios_get_clock_dividers(adev, COMPUTE_ENGINE_PLL_PARAM,
  840. table->entries[i].evclk, false, &dividers);
  841. if (ret)
  842. return ret;
  843. pi->vce_level[i].Divider = (u8)dividers.post_div;
  844. pi->vce_level_count++;
  845. }
  846. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  847. pi->dpm_table_start +
  848. offsetof(SMU7_Fusion_DpmTable, VceLevelCount),
  849. (u8 *)&pi->vce_level_count,
  850. sizeof(u8),
  851. pi->sram_end);
  852. if (ret)
  853. return ret;
  854. pi->vce_interval = 1;
  855. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  856. pi->dpm_table_start +
  857. offsetof(SMU7_Fusion_DpmTable, VCEInterval),
  858. (u8 *)&pi->vce_interval,
  859. sizeof(u8),
  860. pi->sram_end);
  861. if (ret)
  862. return ret;
  863. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  864. pi->dpm_table_start +
  865. offsetof(SMU7_Fusion_DpmTable, VceLevel),
  866. (u8 *)&pi->vce_level,
  867. sizeof(SMU7_Fusion_ExtClkLevel) * SMU7_MAX_LEVELS_VCE,
  868. pi->sram_end);
  869. return ret;
  870. }
  871. static int kv_populate_samu_table(struct amdgpu_device *adev)
  872. {
  873. struct kv_power_info *pi = kv_get_pi(adev);
  874. struct amdgpu_clock_voltage_dependency_table *table =
  875. &adev->pm.dpm.dyn_state.samu_clock_voltage_dependency_table;
  876. struct atom_clock_dividers dividers;
  877. int ret;
  878. u32 i;
  879. if (table == NULL || table->count == 0)
  880. return 0;
  881. pi->samu_level_count = 0;
  882. for (i = 0; i < table->count; i++) {
  883. if (pi->high_voltage_t &&
  884. pi->high_voltage_t < table->entries[i].v)
  885. break;
  886. pi->samu_level[i].Frequency = cpu_to_be32(table->entries[i].clk);
  887. pi->samu_level[i].MinVoltage = cpu_to_be16(table->entries[i].v);
  888. pi->samu_level[i].ClkBypassCntl =
  889. (u8)kv_get_clk_bypass(adev, table->entries[i].clk);
  890. ret = amdgpu_atombios_get_clock_dividers(adev, COMPUTE_ENGINE_PLL_PARAM,
  891. table->entries[i].clk, false, &dividers);
  892. if (ret)
  893. return ret;
  894. pi->samu_level[i].Divider = (u8)dividers.post_div;
  895. pi->samu_level_count++;
  896. }
  897. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  898. pi->dpm_table_start +
  899. offsetof(SMU7_Fusion_DpmTable, SamuLevelCount),
  900. (u8 *)&pi->samu_level_count,
  901. sizeof(u8),
  902. pi->sram_end);
  903. if (ret)
  904. return ret;
  905. pi->samu_interval = 1;
  906. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  907. pi->dpm_table_start +
  908. offsetof(SMU7_Fusion_DpmTable, SAMUInterval),
  909. (u8 *)&pi->samu_interval,
  910. sizeof(u8),
  911. pi->sram_end);
  912. if (ret)
  913. return ret;
  914. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  915. pi->dpm_table_start +
  916. offsetof(SMU7_Fusion_DpmTable, SamuLevel),
  917. (u8 *)&pi->samu_level,
  918. sizeof(SMU7_Fusion_ExtClkLevel) * SMU7_MAX_LEVELS_SAMU,
  919. pi->sram_end);
  920. if (ret)
  921. return ret;
  922. return ret;
  923. }
  924. static int kv_populate_acp_table(struct amdgpu_device *adev)
  925. {
  926. struct kv_power_info *pi = kv_get_pi(adev);
  927. struct amdgpu_clock_voltage_dependency_table *table =
  928. &adev->pm.dpm.dyn_state.acp_clock_voltage_dependency_table;
  929. struct atom_clock_dividers dividers;
  930. int ret;
  931. u32 i;
  932. if (table == NULL || table->count == 0)
  933. return 0;
  934. pi->acp_level_count = 0;
  935. for (i = 0; i < table->count; i++) {
  936. pi->acp_level[i].Frequency = cpu_to_be32(table->entries[i].clk);
  937. pi->acp_level[i].MinVoltage = cpu_to_be16(table->entries[i].v);
  938. ret = amdgpu_atombios_get_clock_dividers(adev, COMPUTE_ENGINE_PLL_PARAM,
  939. table->entries[i].clk, false, &dividers);
  940. if (ret)
  941. return ret;
  942. pi->acp_level[i].Divider = (u8)dividers.post_div;
  943. pi->acp_level_count++;
  944. }
  945. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  946. pi->dpm_table_start +
  947. offsetof(SMU7_Fusion_DpmTable, AcpLevelCount),
  948. (u8 *)&pi->acp_level_count,
  949. sizeof(u8),
  950. pi->sram_end);
  951. if (ret)
  952. return ret;
  953. pi->acp_interval = 1;
  954. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  955. pi->dpm_table_start +
  956. offsetof(SMU7_Fusion_DpmTable, ACPInterval),
  957. (u8 *)&pi->acp_interval,
  958. sizeof(u8),
  959. pi->sram_end);
  960. if (ret)
  961. return ret;
  962. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  963. pi->dpm_table_start +
  964. offsetof(SMU7_Fusion_DpmTable, AcpLevel),
  965. (u8 *)&pi->acp_level,
  966. sizeof(SMU7_Fusion_ExtClkLevel) * SMU7_MAX_LEVELS_ACP,
  967. pi->sram_end);
  968. if (ret)
  969. return ret;
  970. return ret;
  971. }
  972. static void kv_calculate_dfs_bypass_settings(struct amdgpu_device *adev)
  973. {
  974. struct kv_power_info *pi = kv_get_pi(adev);
  975. u32 i;
  976. struct amdgpu_clock_voltage_dependency_table *table =
  977. &adev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
  978. if (table && table->count) {
  979. for (i = 0; i < pi->graphics_dpm_level_count; i++) {
  980. if (pi->caps_enable_dfs_bypass) {
  981. if (kv_get_clock_difference(table->entries[i].clk, 40000) < 200)
  982. pi->graphics_level[i].ClkBypassCntl = 3;
  983. else if (kv_get_clock_difference(table->entries[i].clk, 30000) < 200)
  984. pi->graphics_level[i].ClkBypassCntl = 2;
  985. else if (kv_get_clock_difference(table->entries[i].clk, 26600) < 200)
  986. pi->graphics_level[i].ClkBypassCntl = 7;
  987. else if (kv_get_clock_difference(table->entries[i].clk , 20000) < 200)
  988. pi->graphics_level[i].ClkBypassCntl = 6;
  989. else if (kv_get_clock_difference(table->entries[i].clk , 10000) < 200)
  990. pi->graphics_level[i].ClkBypassCntl = 8;
  991. else
  992. pi->graphics_level[i].ClkBypassCntl = 0;
  993. } else {
  994. pi->graphics_level[i].ClkBypassCntl = 0;
  995. }
  996. }
  997. } else {
  998. struct sumo_sclk_voltage_mapping_table *table =
  999. &pi->sys_info.sclk_voltage_mapping_table;
  1000. for (i = 0; i < pi->graphics_dpm_level_count; i++) {
  1001. if (pi->caps_enable_dfs_bypass) {
  1002. if (kv_get_clock_difference(table->entries[i].sclk_frequency, 40000) < 200)
  1003. pi->graphics_level[i].ClkBypassCntl = 3;
  1004. else if (kv_get_clock_difference(table->entries[i].sclk_frequency, 30000) < 200)
  1005. pi->graphics_level[i].ClkBypassCntl = 2;
  1006. else if (kv_get_clock_difference(table->entries[i].sclk_frequency, 26600) < 200)
  1007. pi->graphics_level[i].ClkBypassCntl = 7;
  1008. else if (kv_get_clock_difference(table->entries[i].sclk_frequency, 20000) < 200)
  1009. pi->graphics_level[i].ClkBypassCntl = 6;
  1010. else if (kv_get_clock_difference(table->entries[i].sclk_frequency, 10000) < 200)
  1011. pi->graphics_level[i].ClkBypassCntl = 8;
  1012. else
  1013. pi->graphics_level[i].ClkBypassCntl = 0;
  1014. } else {
  1015. pi->graphics_level[i].ClkBypassCntl = 0;
  1016. }
  1017. }
  1018. }
  1019. }
  1020. static int kv_enable_ulv(struct amdgpu_device *adev, bool enable)
  1021. {
  1022. return amdgpu_kv_notify_message_to_smu(adev, enable ?
  1023. PPSMC_MSG_EnableULV : PPSMC_MSG_DisableULV);
  1024. }
  1025. static void kv_reset_acp_boot_level(struct amdgpu_device *adev)
  1026. {
  1027. struct kv_power_info *pi = kv_get_pi(adev);
  1028. pi->acp_boot_level = 0xff;
  1029. }
  1030. static void kv_update_current_ps(struct amdgpu_device *adev,
  1031. struct amdgpu_ps *rps)
  1032. {
  1033. struct kv_ps *new_ps = kv_get_ps(rps);
  1034. struct kv_power_info *pi = kv_get_pi(adev);
  1035. pi->current_rps = *rps;
  1036. pi->current_ps = *new_ps;
  1037. pi->current_rps.ps_priv = &pi->current_ps;
  1038. adev->pm.dpm.current_ps = &pi->current_rps;
  1039. }
  1040. static void kv_update_requested_ps(struct amdgpu_device *adev,
  1041. struct amdgpu_ps *rps)
  1042. {
  1043. struct kv_ps *new_ps = kv_get_ps(rps);
  1044. struct kv_power_info *pi = kv_get_pi(adev);
  1045. pi->requested_rps = *rps;
  1046. pi->requested_ps = *new_ps;
  1047. pi->requested_rps.ps_priv = &pi->requested_ps;
  1048. adev->pm.dpm.requested_ps = &pi->requested_rps;
  1049. }
  1050. static void kv_dpm_enable_bapm(struct amdgpu_device *adev, bool enable)
  1051. {
  1052. struct kv_power_info *pi = kv_get_pi(adev);
  1053. int ret;
  1054. if (pi->bapm_enable) {
  1055. ret = amdgpu_kv_smc_bapm_enable(adev, enable);
  1056. if (ret)
  1057. DRM_ERROR("amdgpu_kv_smc_bapm_enable failed\n");
  1058. }
  1059. }
  1060. static int kv_dpm_enable(struct amdgpu_device *adev)
  1061. {
  1062. struct kv_power_info *pi = kv_get_pi(adev);
  1063. int ret;
  1064. ret = kv_process_firmware_header(adev);
  1065. if (ret) {
  1066. DRM_ERROR("kv_process_firmware_header failed\n");
  1067. return ret;
  1068. }
  1069. kv_init_fps_limits(adev);
  1070. kv_init_graphics_levels(adev);
  1071. ret = kv_program_bootup_state(adev);
  1072. if (ret) {
  1073. DRM_ERROR("kv_program_bootup_state failed\n");
  1074. return ret;
  1075. }
  1076. kv_calculate_dfs_bypass_settings(adev);
  1077. ret = kv_upload_dpm_settings(adev);
  1078. if (ret) {
  1079. DRM_ERROR("kv_upload_dpm_settings failed\n");
  1080. return ret;
  1081. }
  1082. ret = kv_populate_uvd_table(adev);
  1083. if (ret) {
  1084. DRM_ERROR("kv_populate_uvd_table failed\n");
  1085. return ret;
  1086. }
  1087. ret = kv_populate_vce_table(adev);
  1088. if (ret) {
  1089. DRM_ERROR("kv_populate_vce_table failed\n");
  1090. return ret;
  1091. }
  1092. ret = kv_populate_samu_table(adev);
  1093. if (ret) {
  1094. DRM_ERROR("kv_populate_samu_table failed\n");
  1095. return ret;
  1096. }
  1097. ret = kv_populate_acp_table(adev);
  1098. if (ret) {
  1099. DRM_ERROR("kv_populate_acp_table failed\n");
  1100. return ret;
  1101. }
  1102. kv_program_vc(adev);
  1103. #if 0
  1104. kv_initialize_hardware_cac_manager(adev);
  1105. #endif
  1106. kv_start_am(adev);
  1107. if (pi->enable_auto_thermal_throttling) {
  1108. ret = kv_enable_auto_thermal_throttling(adev);
  1109. if (ret) {
  1110. DRM_ERROR("kv_enable_auto_thermal_throttling failed\n");
  1111. return ret;
  1112. }
  1113. }
  1114. ret = kv_enable_dpm_voltage_scaling(adev);
  1115. if (ret) {
  1116. DRM_ERROR("kv_enable_dpm_voltage_scaling failed\n");
  1117. return ret;
  1118. }
  1119. ret = kv_set_dpm_interval(adev);
  1120. if (ret) {
  1121. DRM_ERROR("kv_set_dpm_interval failed\n");
  1122. return ret;
  1123. }
  1124. ret = kv_set_dpm_boot_state(adev);
  1125. if (ret) {
  1126. DRM_ERROR("kv_set_dpm_boot_state failed\n");
  1127. return ret;
  1128. }
  1129. ret = kv_enable_ulv(adev, true);
  1130. if (ret) {
  1131. DRM_ERROR("kv_enable_ulv failed\n");
  1132. return ret;
  1133. }
  1134. kv_start_dpm(adev);
  1135. ret = kv_enable_didt(adev, true);
  1136. if (ret) {
  1137. DRM_ERROR("kv_enable_didt failed\n");
  1138. return ret;
  1139. }
  1140. ret = kv_enable_smc_cac(adev, true);
  1141. if (ret) {
  1142. DRM_ERROR("kv_enable_smc_cac failed\n");
  1143. return ret;
  1144. }
  1145. kv_reset_acp_boot_level(adev);
  1146. ret = amdgpu_kv_smc_bapm_enable(adev, false);
  1147. if (ret) {
  1148. DRM_ERROR("amdgpu_kv_smc_bapm_enable failed\n");
  1149. return ret;
  1150. }
  1151. kv_update_current_ps(adev, adev->pm.dpm.boot_ps);
  1152. if (adev->irq.installed &&
  1153. amdgpu_is_internal_thermal_sensor(adev->pm.int_thermal_type)) {
  1154. ret = kv_set_thermal_temperature_range(adev, KV_TEMP_RANGE_MIN, KV_TEMP_RANGE_MAX);
  1155. if (ret) {
  1156. DRM_ERROR("kv_set_thermal_temperature_range failed\n");
  1157. return ret;
  1158. }
  1159. amdgpu_irq_get(adev, &adev->pm.dpm.thermal.irq,
  1160. AMDGPU_THERMAL_IRQ_LOW_TO_HIGH);
  1161. amdgpu_irq_get(adev, &adev->pm.dpm.thermal.irq,
  1162. AMDGPU_THERMAL_IRQ_HIGH_TO_LOW);
  1163. }
  1164. return ret;
  1165. }
  1166. static void kv_dpm_disable(struct amdgpu_device *adev)
  1167. {
  1168. amdgpu_irq_put(adev, &adev->pm.dpm.thermal.irq,
  1169. AMDGPU_THERMAL_IRQ_LOW_TO_HIGH);
  1170. amdgpu_irq_put(adev, &adev->pm.dpm.thermal.irq,
  1171. AMDGPU_THERMAL_IRQ_HIGH_TO_LOW);
  1172. amdgpu_kv_smc_bapm_enable(adev, false);
  1173. if (adev->asic_type == CHIP_MULLINS)
  1174. kv_enable_nb_dpm(adev, false);
  1175. /* powerup blocks */
  1176. kv_dpm_powergate_acp(adev, false);
  1177. kv_dpm_powergate_samu(adev, false);
  1178. kv_dpm_powergate_vce(adev, false);
  1179. kv_dpm_powergate_uvd(adev, false);
  1180. kv_enable_smc_cac(adev, false);
  1181. kv_enable_didt(adev, false);
  1182. kv_clear_vc(adev);
  1183. kv_stop_dpm(adev);
  1184. kv_enable_ulv(adev, false);
  1185. kv_reset_am(adev);
  1186. kv_update_current_ps(adev, adev->pm.dpm.boot_ps);
  1187. }
  1188. #if 0
  1189. static int kv_write_smc_soft_register(struct amdgpu_device *adev,
  1190. u16 reg_offset, u32 value)
  1191. {
  1192. struct kv_power_info *pi = kv_get_pi(adev);
  1193. return amdgpu_kv_copy_bytes_to_smc(adev, pi->soft_regs_start + reg_offset,
  1194. (u8 *)&value, sizeof(u16), pi->sram_end);
  1195. }
  1196. static int kv_read_smc_soft_register(struct amdgpu_device *adev,
  1197. u16 reg_offset, u32 *value)
  1198. {
  1199. struct kv_power_info *pi = kv_get_pi(adev);
  1200. return amdgpu_kv_read_smc_sram_dword(adev, pi->soft_regs_start + reg_offset,
  1201. value, pi->sram_end);
  1202. }
  1203. #endif
  1204. static void kv_init_sclk_t(struct amdgpu_device *adev)
  1205. {
  1206. struct kv_power_info *pi = kv_get_pi(adev);
  1207. pi->low_sclk_interrupt_t = 0;
  1208. }
  1209. static int kv_init_fps_limits(struct amdgpu_device *adev)
  1210. {
  1211. struct kv_power_info *pi = kv_get_pi(adev);
  1212. int ret = 0;
  1213. if (pi->caps_fps) {
  1214. u16 tmp;
  1215. tmp = 45;
  1216. pi->fps_high_t = cpu_to_be16(tmp);
  1217. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  1218. pi->dpm_table_start +
  1219. offsetof(SMU7_Fusion_DpmTable, FpsHighT),
  1220. (u8 *)&pi->fps_high_t,
  1221. sizeof(u16), pi->sram_end);
  1222. tmp = 30;
  1223. pi->fps_low_t = cpu_to_be16(tmp);
  1224. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  1225. pi->dpm_table_start +
  1226. offsetof(SMU7_Fusion_DpmTable, FpsLowT),
  1227. (u8 *)&pi->fps_low_t,
  1228. sizeof(u16), pi->sram_end);
  1229. }
  1230. return ret;
  1231. }
  1232. static void kv_init_powergate_state(struct amdgpu_device *adev)
  1233. {
  1234. struct kv_power_info *pi = kv_get_pi(adev);
  1235. pi->uvd_power_gated = false;
  1236. pi->vce_power_gated = false;
  1237. pi->samu_power_gated = false;
  1238. pi->acp_power_gated = false;
  1239. }
  1240. static int kv_enable_uvd_dpm(struct amdgpu_device *adev, bool enable)
  1241. {
  1242. return amdgpu_kv_notify_message_to_smu(adev, enable ?
  1243. PPSMC_MSG_UVDDPM_Enable : PPSMC_MSG_UVDDPM_Disable);
  1244. }
  1245. static int kv_enable_vce_dpm(struct amdgpu_device *adev, bool enable)
  1246. {
  1247. return amdgpu_kv_notify_message_to_smu(adev, enable ?
  1248. PPSMC_MSG_VCEDPM_Enable : PPSMC_MSG_VCEDPM_Disable);
  1249. }
  1250. static int kv_enable_samu_dpm(struct amdgpu_device *adev, bool enable)
  1251. {
  1252. return amdgpu_kv_notify_message_to_smu(adev, enable ?
  1253. PPSMC_MSG_SAMUDPM_Enable : PPSMC_MSG_SAMUDPM_Disable);
  1254. }
  1255. static int kv_enable_acp_dpm(struct amdgpu_device *adev, bool enable)
  1256. {
  1257. return amdgpu_kv_notify_message_to_smu(adev, enable ?
  1258. PPSMC_MSG_ACPDPM_Enable : PPSMC_MSG_ACPDPM_Disable);
  1259. }
  1260. static int kv_update_uvd_dpm(struct amdgpu_device *adev, bool gate)
  1261. {
  1262. struct kv_power_info *pi = kv_get_pi(adev);
  1263. struct amdgpu_uvd_clock_voltage_dependency_table *table =
  1264. &adev->pm.dpm.dyn_state.uvd_clock_voltage_dependency_table;
  1265. int ret;
  1266. u32 mask;
  1267. if (!gate) {
  1268. if (table->count)
  1269. pi->uvd_boot_level = table->count - 1;
  1270. else
  1271. pi->uvd_boot_level = 0;
  1272. if (!pi->caps_uvd_dpm || pi->caps_stable_p_state) {
  1273. mask = 1 << pi->uvd_boot_level;
  1274. } else {
  1275. mask = 0x1f;
  1276. }
  1277. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  1278. pi->dpm_table_start +
  1279. offsetof(SMU7_Fusion_DpmTable, UvdBootLevel),
  1280. (uint8_t *)&pi->uvd_boot_level,
  1281. sizeof(u8), pi->sram_end);
  1282. if (ret)
  1283. return ret;
  1284. amdgpu_kv_send_msg_to_smc_with_parameter(adev,
  1285. PPSMC_MSG_UVDDPM_SetEnabledMask,
  1286. mask);
  1287. }
  1288. return kv_enable_uvd_dpm(adev, !gate);
  1289. }
  1290. static u8 kv_get_vce_boot_level(struct amdgpu_device *adev, u32 evclk)
  1291. {
  1292. u8 i;
  1293. struct amdgpu_vce_clock_voltage_dependency_table *table =
  1294. &adev->pm.dpm.dyn_state.vce_clock_voltage_dependency_table;
  1295. for (i = 0; i < table->count; i++) {
  1296. if (table->entries[i].evclk >= evclk)
  1297. break;
  1298. }
  1299. return i;
  1300. }
  1301. static int kv_update_vce_dpm(struct amdgpu_device *adev,
  1302. struct amdgpu_ps *amdgpu_new_state,
  1303. struct amdgpu_ps *amdgpu_current_state)
  1304. {
  1305. struct kv_power_info *pi = kv_get_pi(adev);
  1306. struct amdgpu_vce_clock_voltage_dependency_table *table =
  1307. &adev->pm.dpm.dyn_state.vce_clock_voltage_dependency_table;
  1308. int ret;
  1309. if (amdgpu_new_state->evclk > 0 && amdgpu_current_state->evclk == 0) {
  1310. kv_dpm_powergate_vce(adev, false);
  1311. if (pi->caps_stable_p_state)
  1312. pi->vce_boot_level = table->count - 1;
  1313. else
  1314. pi->vce_boot_level = kv_get_vce_boot_level(adev, amdgpu_new_state->evclk);
  1315. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  1316. pi->dpm_table_start +
  1317. offsetof(SMU7_Fusion_DpmTable, VceBootLevel),
  1318. (u8 *)&pi->vce_boot_level,
  1319. sizeof(u8),
  1320. pi->sram_end);
  1321. if (ret)
  1322. return ret;
  1323. if (pi->caps_stable_p_state)
  1324. amdgpu_kv_send_msg_to_smc_with_parameter(adev,
  1325. PPSMC_MSG_VCEDPM_SetEnabledMask,
  1326. (1 << pi->vce_boot_level));
  1327. kv_enable_vce_dpm(adev, true);
  1328. } else if (amdgpu_new_state->evclk == 0 && amdgpu_current_state->evclk > 0) {
  1329. kv_enable_vce_dpm(adev, false);
  1330. kv_dpm_powergate_vce(adev, true);
  1331. }
  1332. return 0;
  1333. }
  1334. static int kv_update_samu_dpm(struct amdgpu_device *adev, bool gate)
  1335. {
  1336. struct kv_power_info *pi = kv_get_pi(adev);
  1337. struct amdgpu_clock_voltage_dependency_table *table =
  1338. &adev->pm.dpm.dyn_state.samu_clock_voltage_dependency_table;
  1339. int ret;
  1340. if (!gate) {
  1341. if (pi->caps_stable_p_state)
  1342. pi->samu_boot_level = table->count - 1;
  1343. else
  1344. pi->samu_boot_level = 0;
  1345. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  1346. pi->dpm_table_start +
  1347. offsetof(SMU7_Fusion_DpmTable, SamuBootLevel),
  1348. (u8 *)&pi->samu_boot_level,
  1349. sizeof(u8),
  1350. pi->sram_end);
  1351. if (ret)
  1352. return ret;
  1353. if (pi->caps_stable_p_state)
  1354. amdgpu_kv_send_msg_to_smc_with_parameter(adev,
  1355. PPSMC_MSG_SAMUDPM_SetEnabledMask,
  1356. (1 << pi->samu_boot_level));
  1357. }
  1358. return kv_enable_samu_dpm(adev, !gate);
  1359. }
  1360. static u8 kv_get_acp_boot_level(struct amdgpu_device *adev)
  1361. {
  1362. u8 i;
  1363. struct amdgpu_clock_voltage_dependency_table *table =
  1364. &adev->pm.dpm.dyn_state.acp_clock_voltage_dependency_table;
  1365. for (i = 0; i < table->count; i++) {
  1366. if (table->entries[i].clk >= 0) /* XXX */
  1367. break;
  1368. }
  1369. if (i >= table->count)
  1370. i = table->count - 1;
  1371. return i;
  1372. }
  1373. static void kv_update_acp_boot_level(struct amdgpu_device *adev)
  1374. {
  1375. struct kv_power_info *pi = kv_get_pi(adev);
  1376. u8 acp_boot_level;
  1377. if (!pi->caps_stable_p_state) {
  1378. acp_boot_level = kv_get_acp_boot_level(adev);
  1379. if (acp_boot_level != pi->acp_boot_level) {
  1380. pi->acp_boot_level = acp_boot_level;
  1381. amdgpu_kv_send_msg_to_smc_with_parameter(adev,
  1382. PPSMC_MSG_ACPDPM_SetEnabledMask,
  1383. (1 << pi->acp_boot_level));
  1384. }
  1385. }
  1386. }
  1387. static int kv_update_acp_dpm(struct amdgpu_device *adev, bool gate)
  1388. {
  1389. struct kv_power_info *pi = kv_get_pi(adev);
  1390. struct amdgpu_clock_voltage_dependency_table *table =
  1391. &adev->pm.dpm.dyn_state.acp_clock_voltage_dependency_table;
  1392. int ret;
  1393. if (!gate) {
  1394. if (pi->caps_stable_p_state)
  1395. pi->acp_boot_level = table->count - 1;
  1396. else
  1397. pi->acp_boot_level = kv_get_acp_boot_level(adev);
  1398. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  1399. pi->dpm_table_start +
  1400. offsetof(SMU7_Fusion_DpmTable, AcpBootLevel),
  1401. (u8 *)&pi->acp_boot_level,
  1402. sizeof(u8),
  1403. pi->sram_end);
  1404. if (ret)
  1405. return ret;
  1406. if (pi->caps_stable_p_state)
  1407. amdgpu_kv_send_msg_to_smc_with_parameter(adev,
  1408. PPSMC_MSG_ACPDPM_SetEnabledMask,
  1409. (1 << pi->acp_boot_level));
  1410. }
  1411. return kv_enable_acp_dpm(adev, !gate);
  1412. }
  1413. static void kv_dpm_powergate_uvd(struct amdgpu_device *adev, bool gate)
  1414. {
  1415. struct kv_power_info *pi = kv_get_pi(adev);
  1416. int ret;
  1417. pi->uvd_power_gated = gate;
  1418. if (gate) {
  1419. /* stop the UVD block */
  1420. ret = amdgpu_set_powergating_state(adev, AMD_IP_BLOCK_TYPE_UVD,
  1421. AMD_PG_STATE_GATE);
  1422. kv_update_uvd_dpm(adev, gate);
  1423. if (pi->caps_uvd_pg)
  1424. /* power off the UVD block */
  1425. amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_UVDPowerOFF);
  1426. } else {
  1427. if (pi->caps_uvd_pg)
  1428. /* power on the UVD block */
  1429. amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_UVDPowerON);
  1430. /* re-init the UVD block */
  1431. kv_update_uvd_dpm(adev, gate);
  1432. ret = amdgpu_set_powergating_state(adev, AMD_IP_BLOCK_TYPE_UVD,
  1433. AMD_PG_STATE_UNGATE);
  1434. }
  1435. }
  1436. static void kv_dpm_powergate_vce(struct amdgpu_device *adev, bool gate)
  1437. {
  1438. struct kv_power_info *pi = kv_get_pi(adev);
  1439. if (pi->vce_power_gated == gate)
  1440. return;
  1441. pi->vce_power_gated = gate;
  1442. if (!pi->caps_vce_pg)
  1443. return;
  1444. if (gate)
  1445. amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_VCEPowerOFF);
  1446. else
  1447. amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_VCEPowerON);
  1448. }
  1449. static void kv_dpm_powergate_samu(struct amdgpu_device *adev, bool gate)
  1450. {
  1451. struct kv_power_info *pi = kv_get_pi(adev);
  1452. if (pi->samu_power_gated == gate)
  1453. return;
  1454. pi->samu_power_gated = gate;
  1455. if (gate) {
  1456. kv_update_samu_dpm(adev, true);
  1457. if (pi->caps_samu_pg)
  1458. amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_SAMPowerOFF);
  1459. } else {
  1460. if (pi->caps_samu_pg)
  1461. amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_SAMPowerON);
  1462. kv_update_samu_dpm(adev, false);
  1463. }
  1464. }
  1465. static void kv_dpm_powergate_acp(struct amdgpu_device *adev, bool gate)
  1466. {
  1467. struct kv_power_info *pi = kv_get_pi(adev);
  1468. if (pi->acp_power_gated == gate)
  1469. return;
  1470. if (adev->asic_type == CHIP_KABINI || adev->asic_type == CHIP_MULLINS)
  1471. return;
  1472. pi->acp_power_gated = gate;
  1473. if (gate) {
  1474. kv_update_acp_dpm(adev, true);
  1475. if (pi->caps_acp_pg)
  1476. amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_ACPPowerOFF);
  1477. } else {
  1478. if (pi->caps_acp_pg)
  1479. amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_ACPPowerON);
  1480. kv_update_acp_dpm(adev, false);
  1481. }
  1482. }
  1483. static void kv_set_valid_clock_range(struct amdgpu_device *adev,
  1484. struct amdgpu_ps *new_rps)
  1485. {
  1486. struct kv_ps *new_ps = kv_get_ps(new_rps);
  1487. struct kv_power_info *pi = kv_get_pi(adev);
  1488. u32 i;
  1489. struct amdgpu_clock_voltage_dependency_table *table =
  1490. &adev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
  1491. if (table && table->count) {
  1492. for (i = 0; i < pi->graphics_dpm_level_count; i++) {
  1493. if ((table->entries[i].clk >= new_ps->levels[0].sclk) ||
  1494. (i == (pi->graphics_dpm_level_count - 1))) {
  1495. pi->lowest_valid = i;
  1496. break;
  1497. }
  1498. }
  1499. for (i = pi->graphics_dpm_level_count - 1; i > 0; i--) {
  1500. if (table->entries[i].clk <= new_ps->levels[new_ps->num_levels - 1].sclk)
  1501. break;
  1502. }
  1503. pi->highest_valid = i;
  1504. if (pi->lowest_valid > pi->highest_valid) {
  1505. if ((new_ps->levels[0].sclk - table->entries[pi->highest_valid].clk) >
  1506. (table->entries[pi->lowest_valid].clk - new_ps->levels[new_ps->num_levels - 1].sclk))
  1507. pi->highest_valid = pi->lowest_valid;
  1508. else
  1509. pi->lowest_valid = pi->highest_valid;
  1510. }
  1511. } else {
  1512. struct sumo_sclk_voltage_mapping_table *table =
  1513. &pi->sys_info.sclk_voltage_mapping_table;
  1514. for (i = 0; i < (int)pi->graphics_dpm_level_count; i++) {
  1515. if (table->entries[i].sclk_frequency >= new_ps->levels[0].sclk ||
  1516. i == (int)(pi->graphics_dpm_level_count - 1)) {
  1517. pi->lowest_valid = i;
  1518. break;
  1519. }
  1520. }
  1521. for (i = pi->graphics_dpm_level_count - 1; i > 0; i--) {
  1522. if (table->entries[i].sclk_frequency <=
  1523. new_ps->levels[new_ps->num_levels - 1].sclk)
  1524. break;
  1525. }
  1526. pi->highest_valid = i;
  1527. if (pi->lowest_valid > pi->highest_valid) {
  1528. if ((new_ps->levels[0].sclk -
  1529. table->entries[pi->highest_valid].sclk_frequency) >
  1530. (table->entries[pi->lowest_valid].sclk_frequency -
  1531. new_ps->levels[new_ps->num_levels -1].sclk))
  1532. pi->highest_valid = pi->lowest_valid;
  1533. else
  1534. pi->lowest_valid = pi->highest_valid;
  1535. }
  1536. }
  1537. }
  1538. static int kv_update_dfs_bypass_settings(struct amdgpu_device *adev,
  1539. struct amdgpu_ps *new_rps)
  1540. {
  1541. struct kv_ps *new_ps = kv_get_ps(new_rps);
  1542. struct kv_power_info *pi = kv_get_pi(adev);
  1543. int ret = 0;
  1544. u8 clk_bypass_cntl;
  1545. if (pi->caps_enable_dfs_bypass) {
  1546. clk_bypass_cntl = new_ps->need_dfs_bypass ?
  1547. pi->graphics_level[pi->graphics_boot_level].ClkBypassCntl : 0;
  1548. ret = amdgpu_kv_copy_bytes_to_smc(adev,
  1549. (pi->dpm_table_start +
  1550. offsetof(SMU7_Fusion_DpmTable, GraphicsLevel) +
  1551. (pi->graphics_boot_level * sizeof(SMU7_Fusion_GraphicsLevel)) +
  1552. offsetof(SMU7_Fusion_GraphicsLevel, ClkBypassCntl)),
  1553. &clk_bypass_cntl,
  1554. sizeof(u8), pi->sram_end);
  1555. }
  1556. return ret;
  1557. }
  1558. static int kv_enable_nb_dpm(struct amdgpu_device *adev,
  1559. bool enable)
  1560. {
  1561. struct kv_power_info *pi = kv_get_pi(adev);
  1562. int ret = 0;
  1563. if (enable) {
  1564. if (pi->enable_nb_dpm && !pi->nb_dpm_enabled) {
  1565. ret = amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_NBDPM_Enable);
  1566. if (ret == 0)
  1567. pi->nb_dpm_enabled = true;
  1568. }
  1569. } else {
  1570. if (pi->enable_nb_dpm && pi->nb_dpm_enabled) {
  1571. ret = amdgpu_kv_notify_message_to_smu(adev, PPSMC_MSG_NBDPM_Disable);
  1572. if (ret == 0)
  1573. pi->nb_dpm_enabled = false;
  1574. }
  1575. }
  1576. return ret;
  1577. }
  1578. static int kv_dpm_force_performance_level(struct amdgpu_device *adev,
  1579. enum amd_dpm_forced_level level)
  1580. {
  1581. int ret;
  1582. if (level == AMD_DPM_FORCED_LEVEL_HIGH) {
  1583. ret = kv_force_dpm_highest(adev);
  1584. if (ret)
  1585. return ret;
  1586. } else if (level == AMD_DPM_FORCED_LEVEL_LOW) {
  1587. ret = kv_force_dpm_lowest(adev);
  1588. if (ret)
  1589. return ret;
  1590. } else if (level == AMD_DPM_FORCED_LEVEL_AUTO) {
  1591. ret = kv_unforce_levels(adev);
  1592. if (ret)
  1593. return ret;
  1594. }
  1595. adev->pm.dpm.forced_level = level;
  1596. return 0;
  1597. }
  1598. static int kv_dpm_pre_set_power_state(struct amdgpu_device *adev)
  1599. {
  1600. struct kv_power_info *pi = kv_get_pi(adev);
  1601. struct amdgpu_ps requested_ps = *adev->pm.dpm.requested_ps;
  1602. struct amdgpu_ps *new_ps = &requested_ps;
  1603. kv_update_requested_ps(adev, new_ps);
  1604. kv_apply_state_adjust_rules(adev,
  1605. &pi->requested_rps,
  1606. &pi->current_rps);
  1607. return 0;
  1608. }
  1609. static int kv_dpm_set_power_state(struct amdgpu_device *adev)
  1610. {
  1611. struct kv_power_info *pi = kv_get_pi(adev);
  1612. struct amdgpu_ps *new_ps = &pi->requested_rps;
  1613. struct amdgpu_ps *old_ps = &pi->current_rps;
  1614. int ret;
  1615. if (pi->bapm_enable) {
  1616. ret = amdgpu_kv_smc_bapm_enable(adev, adev->pm.dpm.ac_power);
  1617. if (ret) {
  1618. DRM_ERROR("amdgpu_kv_smc_bapm_enable failed\n");
  1619. return ret;
  1620. }
  1621. }
  1622. if (adev->asic_type == CHIP_KABINI || adev->asic_type == CHIP_MULLINS) {
  1623. if (pi->enable_dpm) {
  1624. kv_set_valid_clock_range(adev, new_ps);
  1625. kv_update_dfs_bypass_settings(adev, new_ps);
  1626. ret = kv_calculate_ds_divider(adev);
  1627. if (ret) {
  1628. DRM_ERROR("kv_calculate_ds_divider failed\n");
  1629. return ret;
  1630. }
  1631. kv_calculate_nbps_level_settings(adev);
  1632. kv_calculate_dpm_settings(adev);
  1633. kv_force_lowest_valid(adev);
  1634. kv_enable_new_levels(adev);
  1635. kv_upload_dpm_settings(adev);
  1636. kv_program_nbps_index_settings(adev, new_ps);
  1637. kv_unforce_levels(adev);
  1638. kv_set_enabled_levels(adev);
  1639. kv_force_lowest_valid(adev);
  1640. kv_unforce_levels(adev);
  1641. ret = kv_update_vce_dpm(adev, new_ps, old_ps);
  1642. if (ret) {
  1643. DRM_ERROR("kv_update_vce_dpm failed\n");
  1644. return ret;
  1645. }
  1646. kv_update_sclk_t(adev);
  1647. if (adev->asic_type == CHIP_MULLINS)
  1648. kv_enable_nb_dpm(adev, true);
  1649. }
  1650. } else {
  1651. if (pi->enable_dpm) {
  1652. kv_set_valid_clock_range(adev, new_ps);
  1653. kv_update_dfs_bypass_settings(adev, new_ps);
  1654. ret = kv_calculate_ds_divider(adev);
  1655. if (ret) {
  1656. DRM_ERROR("kv_calculate_ds_divider failed\n");
  1657. return ret;
  1658. }
  1659. kv_calculate_nbps_level_settings(adev);
  1660. kv_calculate_dpm_settings(adev);
  1661. kv_freeze_sclk_dpm(adev, true);
  1662. kv_upload_dpm_settings(adev);
  1663. kv_program_nbps_index_settings(adev, new_ps);
  1664. kv_freeze_sclk_dpm(adev, false);
  1665. kv_set_enabled_levels(adev);
  1666. ret = kv_update_vce_dpm(adev, new_ps, old_ps);
  1667. if (ret) {
  1668. DRM_ERROR("kv_update_vce_dpm failed\n");
  1669. return ret;
  1670. }
  1671. kv_update_acp_boot_level(adev);
  1672. kv_update_sclk_t(adev);
  1673. kv_enable_nb_dpm(adev, true);
  1674. }
  1675. }
  1676. return 0;
  1677. }
  1678. static void kv_dpm_post_set_power_state(struct amdgpu_device *adev)
  1679. {
  1680. struct kv_power_info *pi = kv_get_pi(adev);
  1681. struct amdgpu_ps *new_ps = &pi->requested_rps;
  1682. kv_update_current_ps(adev, new_ps);
  1683. }
  1684. static void kv_dpm_setup_asic(struct amdgpu_device *adev)
  1685. {
  1686. sumo_take_smu_control(adev, true);
  1687. kv_init_powergate_state(adev);
  1688. kv_init_sclk_t(adev);
  1689. }
  1690. #if 0
  1691. static void kv_dpm_reset_asic(struct amdgpu_device *adev)
  1692. {
  1693. struct kv_power_info *pi = kv_get_pi(adev);
  1694. if (adev->asic_type == CHIP_KABINI || adev->asic_type == CHIP_MULLINS) {
  1695. kv_force_lowest_valid(adev);
  1696. kv_init_graphics_levels(adev);
  1697. kv_program_bootup_state(adev);
  1698. kv_upload_dpm_settings(adev);
  1699. kv_force_lowest_valid(adev);
  1700. kv_unforce_levels(adev);
  1701. } else {
  1702. kv_init_graphics_levels(adev);
  1703. kv_program_bootup_state(adev);
  1704. kv_freeze_sclk_dpm(adev, true);
  1705. kv_upload_dpm_settings(adev);
  1706. kv_freeze_sclk_dpm(adev, false);
  1707. kv_set_enabled_level(adev, pi->graphics_boot_level);
  1708. }
  1709. }
  1710. #endif
  1711. static void kv_construct_max_power_limits_table(struct amdgpu_device *adev,
  1712. struct amdgpu_clock_and_voltage_limits *table)
  1713. {
  1714. struct kv_power_info *pi = kv_get_pi(adev);
  1715. if (pi->sys_info.sclk_voltage_mapping_table.num_max_dpm_entries > 0) {
  1716. int idx = pi->sys_info.sclk_voltage_mapping_table.num_max_dpm_entries - 1;
  1717. table->sclk =
  1718. pi->sys_info.sclk_voltage_mapping_table.entries[idx].sclk_frequency;
  1719. table->vddc =
  1720. kv_convert_2bit_index_to_voltage(adev,
  1721. pi->sys_info.sclk_voltage_mapping_table.entries[idx].vid_2bit);
  1722. }
  1723. table->mclk = pi->sys_info.nbp_memory_clock[0];
  1724. }
  1725. static void kv_patch_voltage_values(struct amdgpu_device *adev)
  1726. {
  1727. int i;
  1728. struct amdgpu_uvd_clock_voltage_dependency_table *uvd_table =
  1729. &adev->pm.dpm.dyn_state.uvd_clock_voltage_dependency_table;
  1730. struct amdgpu_vce_clock_voltage_dependency_table *vce_table =
  1731. &adev->pm.dpm.dyn_state.vce_clock_voltage_dependency_table;
  1732. struct amdgpu_clock_voltage_dependency_table *samu_table =
  1733. &adev->pm.dpm.dyn_state.samu_clock_voltage_dependency_table;
  1734. struct amdgpu_clock_voltage_dependency_table *acp_table =
  1735. &adev->pm.dpm.dyn_state.acp_clock_voltage_dependency_table;
  1736. if (uvd_table->count) {
  1737. for (i = 0; i < uvd_table->count; i++)
  1738. uvd_table->entries[i].v =
  1739. kv_convert_8bit_index_to_voltage(adev,
  1740. uvd_table->entries[i].v);
  1741. }
  1742. if (vce_table->count) {
  1743. for (i = 0; i < vce_table->count; i++)
  1744. vce_table->entries[i].v =
  1745. kv_convert_8bit_index_to_voltage(adev,
  1746. vce_table->entries[i].v);
  1747. }
  1748. if (samu_table->count) {
  1749. for (i = 0; i < samu_table->count; i++)
  1750. samu_table->entries[i].v =
  1751. kv_convert_8bit_index_to_voltage(adev,
  1752. samu_table->entries[i].v);
  1753. }
  1754. if (acp_table->count) {
  1755. for (i = 0; i < acp_table->count; i++)
  1756. acp_table->entries[i].v =
  1757. kv_convert_8bit_index_to_voltage(adev,
  1758. acp_table->entries[i].v);
  1759. }
  1760. }
  1761. static void kv_construct_boot_state(struct amdgpu_device *adev)
  1762. {
  1763. struct kv_power_info *pi = kv_get_pi(adev);
  1764. pi->boot_pl.sclk = pi->sys_info.bootup_sclk;
  1765. pi->boot_pl.vddc_index = pi->sys_info.bootup_nb_voltage_index;
  1766. pi->boot_pl.ds_divider_index = 0;
  1767. pi->boot_pl.ss_divider_index = 0;
  1768. pi->boot_pl.allow_gnb_slow = 1;
  1769. pi->boot_pl.force_nbp_state = 0;
  1770. pi->boot_pl.display_wm = 0;
  1771. pi->boot_pl.vce_wm = 0;
  1772. }
  1773. static int kv_force_dpm_highest(struct amdgpu_device *adev)
  1774. {
  1775. int ret;
  1776. u32 enable_mask, i;
  1777. ret = amdgpu_kv_dpm_get_enable_mask(adev, &enable_mask);
  1778. if (ret)
  1779. return ret;
  1780. for (i = SMU7_MAX_LEVELS_GRAPHICS - 1; i > 0; i--) {
  1781. if (enable_mask & (1 << i))
  1782. break;
  1783. }
  1784. if (adev->asic_type == CHIP_KABINI || adev->asic_type == CHIP_MULLINS)
  1785. return amdgpu_kv_send_msg_to_smc_with_parameter(adev, PPSMC_MSG_DPM_ForceState, i);
  1786. else
  1787. return kv_set_enabled_level(adev, i);
  1788. }
  1789. static int kv_force_dpm_lowest(struct amdgpu_device *adev)
  1790. {
  1791. int ret;
  1792. u32 enable_mask, i;
  1793. ret = amdgpu_kv_dpm_get_enable_mask(adev, &enable_mask);
  1794. if (ret)
  1795. return ret;
  1796. for (i = 0; i < SMU7_MAX_LEVELS_GRAPHICS; i++) {
  1797. if (enable_mask & (1 << i))
  1798. break;
  1799. }
  1800. if (adev->asic_type == CHIP_KABINI || adev->asic_type == CHIP_MULLINS)
  1801. return amdgpu_kv_send_msg_to_smc_with_parameter(adev, PPSMC_MSG_DPM_ForceState, i);
  1802. else
  1803. return kv_set_enabled_level(adev, i);
  1804. }
  1805. static u8 kv_get_sleep_divider_id_from_clock(struct amdgpu_device *adev,
  1806. u32 sclk, u32 min_sclk_in_sr)
  1807. {
  1808. struct kv_power_info *pi = kv_get_pi(adev);
  1809. u32 i;
  1810. u32 temp;
  1811. u32 min = max(min_sclk_in_sr, (u32)KV_MINIMUM_ENGINE_CLOCK);
  1812. if (sclk < min)
  1813. return 0;
  1814. if (!pi->caps_sclk_ds)
  1815. return 0;
  1816. for (i = KV_MAX_DEEPSLEEP_DIVIDER_ID; i > 0; i--) {
  1817. temp = sclk >> i;
  1818. if (temp >= min)
  1819. break;
  1820. }
  1821. return (u8)i;
  1822. }
  1823. static int kv_get_high_voltage_limit(struct amdgpu_device *adev, int *limit)
  1824. {
  1825. struct kv_power_info *pi = kv_get_pi(adev);
  1826. struct amdgpu_clock_voltage_dependency_table *table =
  1827. &adev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
  1828. int i;
  1829. if (table && table->count) {
  1830. for (i = table->count - 1; i >= 0; i--) {
  1831. if (pi->high_voltage_t &&
  1832. (kv_convert_8bit_index_to_voltage(adev, table->entries[i].v) <=
  1833. pi->high_voltage_t)) {
  1834. *limit = i;
  1835. return 0;
  1836. }
  1837. }
  1838. } else {
  1839. struct sumo_sclk_voltage_mapping_table *table =
  1840. &pi->sys_info.sclk_voltage_mapping_table;
  1841. for (i = table->num_max_dpm_entries - 1; i >= 0; i--) {
  1842. if (pi->high_voltage_t &&
  1843. (kv_convert_2bit_index_to_voltage(adev, table->entries[i].vid_2bit) <=
  1844. pi->high_voltage_t)) {
  1845. *limit = i;
  1846. return 0;
  1847. }
  1848. }
  1849. }
  1850. *limit = 0;
  1851. return 0;
  1852. }
  1853. static void kv_apply_state_adjust_rules(struct amdgpu_device *adev,
  1854. struct amdgpu_ps *new_rps,
  1855. struct amdgpu_ps *old_rps)
  1856. {
  1857. struct kv_ps *ps = kv_get_ps(new_rps);
  1858. struct kv_power_info *pi = kv_get_pi(adev);
  1859. u32 min_sclk = 10000; /* ??? */
  1860. u32 sclk, mclk = 0;
  1861. int i, limit;
  1862. bool force_high;
  1863. struct amdgpu_clock_voltage_dependency_table *table =
  1864. &adev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
  1865. u32 stable_p_state_sclk = 0;
  1866. struct amdgpu_clock_and_voltage_limits *max_limits =
  1867. &adev->pm.dpm.dyn_state.max_clock_voltage_on_ac;
  1868. if (new_rps->vce_active) {
  1869. new_rps->evclk = adev->pm.dpm.vce_states[adev->pm.dpm.vce_level].evclk;
  1870. new_rps->ecclk = adev->pm.dpm.vce_states[adev->pm.dpm.vce_level].ecclk;
  1871. } else {
  1872. new_rps->evclk = 0;
  1873. new_rps->ecclk = 0;
  1874. }
  1875. mclk = max_limits->mclk;
  1876. sclk = min_sclk;
  1877. if (pi->caps_stable_p_state) {
  1878. stable_p_state_sclk = (max_limits->sclk * 75) / 100;
  1879. for (i = table->count - 1; i >= 0; i--) {
  1880. if (stable_p_state_sclk >= table->entries[i].clk) {
  1881. stable_p_state_sclk = table->entries[i].clk;
  1882. break;
  1883. }
  1884. }
  1885. if (i > 0)
  1886. stable_p_state_sclk = table->entries[0].clk;
  1887. sclk = stable_p_state_sclk;
  1888. }
  1889. if (new_rps->vce_active) {
  1890. if (sclk < adev->pm.dpm.vce_states[adev->pm.dpm.vce_level].sclk)
  1891. sclk = adev->pm.dpm.vce_states[adev->pm.dpm.vce_level].sclk;
  1892. }
  1893. ps->need_dfs_bypass = true;
  1894. for (i = 0; i < ps->num_levels; i++) {
  1895. if (ps->levels[i].sclk < sclk)
  1896. ps->levels[i].sclk = sclk;
  1897. }
  1898. if (table && table->count) {
  1899. for (i = 0; i < ps->num_levels; i++) {
  1900. if (pi->high_voltage_t &&
  1901. (pi->high_voltage_t <
  1902. kv_convert_8bit_index_to_voltage(adev, ps->levels[i].vddc_index))) {
  1903. kv_get_high_voltage_limit(adev, &limit);
  1904. ps->levels[i].sclk = table->entries[limit].clk;
  1905. }
  1906. }
  1907. } else {
  1908. struct sumo_sclk_voltage_mapping_table *table =
  1909. &pi->sys_info.sclk_voltage_mapping_table;
  1910. for (i = 0; i < ps->num_levels; i++) {
  1911. if (pi->high_voltage_t &&
  1912. (pi->high_voltage_t <
  1913. kv_convert_8bit_index_to_voltage(adev, ps->levels[i].vddc_index))) {
  1914. kv_get_high_voltage_limit(adev, &limit);
  1915. ps->levels[i].sclk = table->entries[limit].sclk_frequency;
  1916. }
  1917. }
  1918. }
  1919. if (pi->caps_stable_p_state) {
  1920. for (i = 0; i < ps->num_levels; i++) {
  1921. ps->levels[i].sclk = stable_p_state_sclk;
  1922. }
  1923. }
  1924. pi->video_start = new_rps->dclk || new_rps->vclk ||
  1925. new_rps->evclk || new_rps->ecclk;
  1926. if ((new_rps->class & ATOM_PPLIB_CLASSIFICATION_UI_MASK) ==
  1927. ATOM_PPLIB_CLASSIFICATION_UI_BATTERY)
  1928. pi->battery_state = true;
  1929. else
  1930. pi->battery_state = false;
  1931. if (adev->asic_type == CHIP_KABINI || adev->asic_type == CHIP_MULLINS) {
  1932. ps->dpm0_pg_nb_ps_lo = 0x1;
  1933. ps->dpm0_pg_nb_ps_hi = 0x0;
  1934. ps->dpmx_nb_ps_lo = 0x1;
  1935. ps->dpmx_nb_ps_hi = 0x0;
  1936. } else {
  1937. ps->dpm0_pg_nb_ps_lo = 0x3;
  1938. ps->dpm0_pg_nb_ps_hi = 0x0;
  1939. ps->dpmx_nb_ps_lo = 0x3;
  1940. ps->dpmx_nb_ps_hi = 0x0;
  1941. if (pi->sys_info.nb_dpm_enable) {
  1942. force_high = (mclk >= pi->sys_info.nbp_memory_clock[3]) ||
  1943. pi->video_start || (adev->pm.dpm.new_active_crtc_count >= 3) ||
  1944. pi->disable_nb_ps3_in_battery;
  1945. ps->dpm0_pg_nb_ps_lo = force_high ? 0x2 : 0x3;
  1946. ps->dpm0_pg_nb_ps_hi = 0x2;
  1947. ps->dpmx_nb_ps_lo = force_high ? 0x2 : 0x3;
  1948. ps->dpmx_nb_ps_hi = 0x2;
  1949. }
  1950. }
  1951. }
  1952. static void kv_dpm_power_level_enabled_for_throttle(struct amdgpu_device *adev,
  1953. u32 index, bool enable)
  1954. {
  1955. struct kv_power_info *pi = kv_get_pi(adev);
  1956. pi->graphics_level[index].EnabledForThrottle = enable ? 1 : 0;
  1957. }
  1958. static int kv_calculate_ds_divider(struct amdgpu_device *adev)
  1959. {
  1960. struct kv_power_info *pi = kv_get_pi(adev);
  1961. u32 sclk_in_sr = 10000; /* ??? */
  1962. u32 i;
  1963. if (pi->lowest_valid > pi->highest_valid)
  1964. return -EINVAL;
  1965. for (i = pi->lowest_valid; i <= pi->highest_valid; i++) {
  1966. pi->graphics_level[i].DeepSleepDivId =
  1967. kv_get_sleep_divider_id_from_clock(adev,
  1968. be32_to_cpu(pi->graphics_level[i].SclkFrequency),
  1969. sclk_in_sr);
  1970. }
  1971. return 0;
  1972. }
  1973. static int kv_calculate_nbps_level_settings(struct amdgpu_device *adev)
  1974. {
  1975. struct kv_power_info *pi = kv_get_pi(adev);
  1976. u32 i;
  1977. bool force_high;
  1978. struct amdgpu_clock_and_voltage_limits *max_limits =
  1979. &adev->pm.dpm.dyn_state.max_clock_voltage_on_ac;
  1980. u32 mclk = max_limits->mclk;
  1981. if (pi->lowest_valid > pi->highest_valid)
  1982. return -EINVAL;
  1983. if (adev->asic_type == CHIP_KABINI || adev->asic_type == CHIP_MULLINS) {
  1984. for (i = pi->lowest_valid; i <= pi->highest_valid; i++) {
  1985. pi->graphics_level[i].GnbSlow = 1;
  1986. pi->graphics_level[i].ForceNbPs1 = 0;
  1987. pi->graphics_level[i].UpH = 0;
  1988. }
  1989. if (!pi->sys_info.nb_dpm_enable)
  1990. return 0;
  1991. force_high = ((mclk >= pi->sys_info.nbp_memory_clock[3]) ||
  1992. (adev->pm.dpm.new_active_crtc_count >= 3) || pi->video_start);
  1993. if (force_high) {
  1994. for (i = pi->lowest_valid; i <= pi->highest_valid; i++)
  1995. pi->graphics_level[i].GnbSlow = 0;
  1996. } else {
  1997. if (pi->battery_state)
  1998. pi->graphics_level[0].ForceNbPs1 = 1;
  1999. pi->graphics_level[1].GnbSlow = 0;
  2000. pi->graphics_level[2].GnbSlow = 0;
  2001. pi->graphics_level[3].GnbSlow = 0;
  2002. pi->graphics_level[4].GnbSlow = 0;
  2003. }
  2004. } else {
  2005. for (i = pi->lowest_valid; i <= pi->highest_valid; i++) {
  2006. pi->graphics_level[i].GnbSlow = 1;
  2007. pi->graphics_level[i].ForceNbPs1 = 0;
  2008. pi->graphics_level[i].UpH = 0;
  2009. }
  2010. if (pi->sys_info.nb_dpm_enable && pi->battery_state) {
  2011. pi->graphics_level[pi->lowest_valid].UpH = 0x28;
  2012. pi->graphics_level[pi->lowest_valid].GnbSlow = 0;
  2013. if (pi->lowest_valid != pi->highest_valid)
  2014. pi->graphics_level[pi->lowest_valid].ForceNbPs1 = 1;
  2015. }
  2016. }
  2017. return 0;
  2018. }
  2019. static int kv_calculate_dpm_settings(struct amdgpu_device *adev)
  2020. {
  2021. struct kv_power_info *pi = kv_get_pi(adev);
  2022. u32 i;
  2023. if (pi->lowest_valid > pi->highest_valid)
  2024. return -EINVAL;
  2025. for (i = pi->lowest_valid; i <= pi->highest_valid; i++)
  2026. pi->graphics_level[i].DisplayWatermark = (i == pi->highest_valid) ? 1 : 0;
  2027. return 0;
  2028. }
  2029. static void kv_init_graphics_levels(struct amdgpu_device *adev)
  2030. {
  2031. struct kv_power_info *pi = kv_get_pi(adev);
  2032. u32 i;
  2033. struct amdgpu_clock_voltage_dependency_table *table =
  2034. &adev->pm.dpm.dyn_state.vddc_dependency_on_sclk;
  2035. if (table && table->count) {
  2036. u32 vid_2bit;
  2037. pi->graphics_dpm_level_count = 0;
  2038. for (i = 0; i < table->count; i++) {
  2039. if (pi->high_voltage_t &&
  2040. (pi->high_voltage_t <
  2041. kv_convert_8bit_index_to_voltage(adev, table->entries[i].v)))
  2042. break;
  2043. kv_set_divider_value(adev, i, table->entries[i].clk);
  2044. vid_2bit = kv_convert_vid7_to_vid2(adev,
  2045. &pi->sys_info.vid_mapping_table,
  2046. table->entries[i].v);
  2047. kv_set_vid(adev, i, vid_2bit);
  2048. kv_set_at(adev, i, pi->at[i]);
  2049. kv_dpm_power_level_enabled_for_throttle(adev, i, true);
  2050. pi->graphics_dpm_level_count++;
  2051. }
  2052. } else {
  2053. struct sumo_sclk_voltage_mapping_table *table =
  2054. &pi->sys_info.sclk_voltage_mapping_table;
  2055. pi->graphics_dpm_level_count = 0;
  2056. for (i = 0; i < table->num_max_dpm_entries; i++) {
  2057. if (pi->high_voltage_t &&
  2058. pi->high_voltage_t <
  2059. kv_convert_2bit_index_to_voltage(adev, table->entries[i].vid_2bit))
  2060. break;
  2061. kv_set_divider_value(adev, i, table->entries[i].sclk_frequency);
  2062. kv_set_vid(adev, i, table->entries[i].vid_2bit);
  2063. kv_set_at(adev, i, pi->at[i]);
  2064. kv_dpm_power_level_enabled_for_throttle(adev, i, true);
  2065. pi->graphics_dpm_level_count++;
  2066. }
  2067. }
  2068. for (i = 0; i < SMU7_MAX_LEVELS_GRAPHICS; i++)
  2069. kv_dpm_power_level_enable(adev, i, false);
  2070. }
  2071. static void kv_enable_new_levels(struct amdgpu_device *adev)
  2072. {
  2073. struct kv_power_info *pi = kv_get_pi(adev);
  2074. u32 i;
  2075. for (i = 0; i < SMU7_MAX_LEVELS_GRAPHICS; i++) {
  2076. if (i >= pi->lowest_valid && i <= pi->highest_valid)
  2077. kv_dpm_power_level_enable(adev, i, true);
  2078. }
  2079. }
  2080. static int kv_set_enabled_level(struct amdgpu_device *adev, u32 level)
  2081. {
  2082. u32 new_mask = (1 << level);
  2083. return amdgpu_kv_send_msg_to_smc_with_parameter(adev,
  2084. PPSMC_MSG_SCLKDPM_SetEnabledMask,
  2085. new_mask);
  2086. }
  2087. static int kv_set_enabled_levels(struct amdgpu_device *adev)
  2088. {
  2089. struct kv_power_info *pi = kv_get_pi(adev);
  2090. u32 i, new_mask = 0;
  2091. for (i = pi->lowest_valid; i <= pi->highest_valid; i++)
  2092. new_mask |= (1 << i);
  2093. return amdgpu_kv_send_msg_to_smc_with_parameter(adev,
  2094. PPSMC_MSG_SCLKDPM_SetEnabledMask,
  2095. new_mask);
  2096. }
  2097. static void kv_program_nbps_index_settings(struct amdgpu_device *adev,
  2098. struct amdgpu_ps *new_rps)
  2099. {
  2100. struct kv_ps *new_ps = kv_get_ps(new_rps);
  2101. struct kv_power_info *pi = kv_get_pi(adev);
  2102. u32 nbdpmconfig1;
  2103. if (adev->asic_type == CHIP_KABINI || adev->asic_type == CHIP_MULLINS)
  2104. return;
  2105. if (pi->sys_info.nb_dpm_enable) {
  2106. nbdpmconfig1 = RREG32_SMC(ixNB_DPM_CONFIG_1);
  2107. nbdpmconfig1 &= ~(NB_DPM_CONFIG_1__Dpm0PgNbPsLo_MASK |
  2108. NB_DPM_CONFIG_1__Dpm0PgNbPsHi_MASK |
  2109. NB_DPM_CONFIG_1__DpmXNbPsLo_MASK |
  2110. NB_DPM_CONFIG_1__DpmXNbPsHi_MASK);
  2111. nbdpmconfig1 |= (new_ps->dpm0_pg_nb_ps_lo << NB_DPM_CONFIG_1__Dpm0PgNbPsLo__SHIFT) |
  2112. (new_ps->dpm0_pg_nb_ps_hi << NB_DPM_CONFIG_1__Dpm0PgNbPsHi__SHIFT) |
  2113. (new_ps->dpmx_nb_ps_lo << NB_DPM_CONFIG_1__DpmXNbPsLo__SHIFT) |
  2114. (new_ps->dpmx_nb_ps_hi << NB_DPM_CONFIG_1__DpmXNbPsHi__SHIFT);
  2115. WREG32_SMC(ixNB_DPM_CONFIG_1, nbdpmconfig1);
  2116. }
  2117. }
  2118. static int kv_set_thermal_temperature_range(struct amdgpu_device *adev,
  2119. int min_temp, int max_temp)
  2120. {
  2121. int low_temp = 0 * 1000;
  2122. int high_temp = 255 * 1000;
  2123. u32 tmp;
  2124. if (low_temp < min_temp)
  2125. low_temp = min_temp;
  2126. if (high_temp > max_temp)
  2127. high_temp = max_temp;
  2128. if (high_temp < low_temp) {
  2129. DRM_ERROR("invalid thermal range: %d - %d\n", low_temp, high_temp);
  2130. return -EINVAL;
  2131. }
  2132. tmp = RREG32_SMC(ixCG_THERMAL_INT_CTRL);
  2133. tmp &= ~(CG_THERMAL_INT_CTRL__DIG_THERM_INTH_MASK |
  2134. CG_THERMAL_INT_CTRL__DIG_THERM_INTL_MASK);
  2135. tmp |= ((49 + (high_temp / 1000)) << CG_THERMAL_INT_CTRL__DIG_THERM_INTH__SHIFT) |
  2136. ((49 + (low_temp / 1000)) << CG_THERMAL_INT_CTRL__DIG_THERM_INTL__SHIFT);
  2137. WREG32_SMC(ixCG_THERMAL_INT_CTRL, tmp);
  2138. adev->pm.dpm.thermal.min_temp = low_temp;
  2139. adev->pm.dpm.thermal.max_temp = high_temp;
  2140. return 0;
  2141. }
  2142. union igp_info {
  2143. struct _ATOM_INTEGRATED_SYSTEM_INFO info;
  2144. struct _ATOM_INTEGRATED_SYSTEM_INFO_V2 info_2;
  2145. struct _ATOM_INTEGRATED_SYSTEM_INFO_V5 info_5;
  2146. struct _ATOM_INTEGRATED_SYSTEM_INFO_V6 info_6;
  2147. struct _ATOM_INTEGRATED_SYSTEM_INFO_V1_7 info_7;
  2148. struct _ATOM_INTEGRATED_SYSTEM_INFO_V1_8 info_8;
  2149. };
  2150. static int kv_parse_sys_info_table(struct amdgpu_device *adev)
  2151. {
  2152. struct kv_power_info *pi = kv_get_pi(adev);
  2153. struct amdgpu_mode_info *mode_info = &adev->mode_info;
  2154. int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo);
  2155. union igp_info *igp_info;
  2156. u8 frev, crev;
  2157. u16 data_offset;
  2158. int i;
  2159. if (amdgpu_atom_parse_data_header(mode_info->atom_context, index, NULL,
  2160. &frev, &crev, &data_offset)) {
  2161. igp_info = (union igp_info *)(mode_info->atom_context->bios +
  2162. data_offset);
  2163. if (crev != 8) {
  2164. DRM_ERROR("Unsupported IGP table: %d %d\n", frev, crev);
  2165. return -EINVAL;
  2166. }
  2167. pi->sys_info.bootup_sclk = le32_to_cpu(igp_info->info_8.ulBootUpEngineClock);
  2168. pi->sys_info.bootup_uma_clk = le32_to_cpu(igp_info->info_8.ulBootUpUMAClock);
  2169. pi->sys_info.bootup_nb_voltage_index =
  2170. le16_to_cpu(igp_info->info_8.usBootUpNBVoltage);
  2171. if (igp_info->info_8.ucHtcTmpLmt == 0)
  2172. pi->sys_info.htc_tmp_lmt = 203;
  2173. else
  2174. pi->sys_info.htc_tmp_lmt = igp_info->info_8.ucHtcTmpLmt;
  2175. if (igp_info->info_8.ucHtcHystLmt == 0)
  2176. pi->sys_info.htc_hyst_lmt = 5;
  2177. else
  2178. pi->sys_info.htc_hyst_lmt = igp_info->info_8.ucHtcHystLmt;
  2179. if (pi->sys_info.htc_tmp_lmt <= pi->sys_info.htc_hyst_lmt) {
  2180. DRM_ERROR("The htcTmpLmt should be larger than htcHystLmt.\n");
  2181. }
  2182. if (le32_to_cpu(igp_info->info_8.ulSystemConfig) & (1 << 3))
  2183. pi->sys_info.nb_dpm_enable = true;
  2184. else
  2185. pi->sys_info.nb_dpm_enable = false;
  2186. for (i = 0; i < KV_NUM_NBPSTATES; i++) {
  2187. pi->sys_info.nbp_memory_clock[i] =
  2188. le32_to_cpu(igp_info->info_8.ulNbpStateMemclkFreq[i]);
  2189. pi->sys_info.nbp_n_clock[i] =
  2190. le32_to_cpu(igp_info->info_8.ulNbpStateNClkFreq[i]);
  2191. }
  2192. if (le32_to_cpu(igp_info->info_8.ulGPUCapInfo) &
  2193. SYS_INFO_GPUCAPS__ENABEL_DFS_BYPASS)
  2194. pi->caps_enable_dfs_bypass = true;
  2195. sumo_construct_sclk_voltage_mapping_table(adev,
  2196. &pi->sys_info.sclk_voltage_mapping_table,
  2197. igp_info->info_8.sAvail_SCLK);
  2198. sumo_construct_vid_mapping_table(adev,
  2199. &pi->sys_info.vid_mapping_table,
  2200. igp_info->info_8.sAvail_SCLK);
  2201. kv_construct_max_power_limits_table(adev,
  2202. &adev->pm.dpm.dyn_state.max_clock_voltage_on_ac);
  2203. }
  2204. return 0;
  2205. }
  2206. union power_info {
  2207. struct _ATOM_POWERPLAY_INFO info;
  2208. struct _ATOM_POWERPLAY_INFO_V2 info_2;
  2209. struct _ATOM_POWERPLAY_INFO_V3 info_3;
  2210. struct _ATOM_PPLIB_POWERPLAYTABLE pplib;
  2211. struct _ATOM_PPLIB_POWERPLAYTABLE2 pplib2;
  2212. struct _ATOM_PPLIB_POWERPLAYTABLE3 pplib3;
  2213. };
  2214. union pplib_clock_info {
  2215. struct _ATOM_PPLIB_R600_CLOCK_INFO r600;
  2216. struct _ATOM_PPLIB_RS780_CLOCK_INFO rs780;
  2217. struct _ATOM_PPLIB_EVERGREEN_CLOCK_INFO evergreen;
  2218. struct _ATOM_PPLIB_SUMO_CLOCK_INFO sumo;
  2219. };
  2220. union pplib_power_state {
  2221. struct _ATOM_PPLIB_STATE v1;
  2222. struct _ATOM_PPLIB_STATE_V2 v2;
  2223. };
  2224. static void kv_patch_boot_state(struct amdgpu_device *adev,
  2225. struct kv_ps *ps)
  2226. {
  2227. struct kv_power_info *pi = kv_get_pi(adev);
  2228. ps->num_levels = 1;
  2229. ps->levels[0] = pi->boot_pl;
  2230. }
  2231. static void kv_parse_pplib_non_clock_info(struct amdgpu_device *adev,
  2232. struct amdgpu_ps *rps,
  2233. struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info,
  2234. u8 table_rev)
  2235. {
  2236. struct kv_ps *ps = kv_get_ps(rps);
  2237. rps->caps = le32_to_cpu(non_clock_info->ulCapsAndSettings);
  2238. rps->class = le16_to_cpu(non_clock_info->usClassification);
  2239. rps->class2 = le16_to_cpu(non_clock_info->usClassification2);
  2240. if (ATOM_PPLIB_NONCLOCKINFO_VER1 < table_rev) {
  2241. rps->vclk = le32_to_cpu(non_clock_info->ulVCLK);
  2242. rps->dclk = le32_to_cpu(non_clock_info->ulDCLK);
  2243. } else {
  2244. rps->vclk = 0;
  2245. rps->dclk = 0;
  2246. }
  2247. if (rps->class & ATOM_PPLIB_CLASSIFICATION_BOOT) {
  2248. adev->pm.dpm.boot_ps = rps;
  2249. kv_patch_boot_state(adev, ps);
  2250. }
  2251. if (rps->class & ATOM_PPLIB_CLASSIFICATION_UVDSTATE)
  2252. adev->pm.dpm.uvd_ps = rps;
  2253. }
  2254. static void kv_parse_pplib_clock_info(struct amdgpu_device *adev,
  2255. struct amdgpu_ps *rps, int index,
  2256. union pplib_clock_info *clock_info)
  2257. {
  2258. struct kv_power_info *pi = kv_get_pi(adev);
  2259. struct kv_ps *ps = kv_get_ps(rps);
  2260. struct kv_pl *pl = &ps->levels[index];
  2261. u32 sclk;
  2262. sclk = le16_to_cpu(clock_info->sumo.usEngineClockLow);
  2263. sclk |= clock_info->sumo.ucEngineClockHigh << 16;
  2264. pl->sclk = sclk;
  2265. pl->vddc_index = clock_info->sumo.vddcIndex;
  2266. ps->num_levels = index + 1;
  2267. if (pi->caps_sclk_ds) {
  2268. pl->ds_divider_index = 5;
  2269. pl->ss_divider_index = 5;
  2270. }
  2271. }
  2272. static int kv_parse_power_table(struct amdgpu_device *adev)
  2273. {
  2274. struct amdgpu_mode_info *mode_info = &adev->mode_info;
  2275. struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info;
  2276. union pplib_power_state *power_state;
  2277. int i, j, k, non_clock_array_index, clock_array_index;
  2278. union pplib_clock_info *clock_info;
  2279. struct _StateArray *state_array;
  2280. struct _ClockInfoArray *clock_info_array;
  2281. struct _NonClockInfoArray *non_clock_info_array;
  2282. union power_info *power_info;
  2283. int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
  2284. u16 data_offset;
  2285. u8 frev, crev;
  2286. u8 *power_state_offset;
  2287. struct kv_ps *ps;
  2288. if (!amdgpu_atom_parse_data_header(mode_info->atom_context, index, NULL,
  2289. &frev, &crev, &data_offset))
  2290. return -EINVAL;
  2291. power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
  2292. amdgpu_add_thermal_controller(adev);
  2293. state_array = (struct _StateArray *)
  2294. (mode_info->atom_context->bios + data_offset +
  2295. le16_to_cpu(power_info->pplib.usStateArrayOffset));
  2296. clock_info_array = (struct _ClockInfoArray *)
  2297. (mode_info->atom_context->bios + data_offset +
  2298. le16_to_cpu(power_info->pplib.usClockInfoArrayOffset));
  2299. non_clock_info_array = (struct _NonClockInfoArray *)
  2300. (mode_info->atom_context->bios + data_offset +
  2301. le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset));
  2302. adev->pm.dpm.ps = kzalloc(sizeof(struct amdgpu_ps) *
  2303. state_array->ucNumEntries, GFP_KERNEL);
  2304. if (!adev->pm.dpm.ps)
  2305. return -ENOMEM;
  2306. power_state_offset = (u8 *)state_array->states;
  2307. for (i = 0; i < state_array->ucNumEntries; i++) {
  2308. u8 *idx;
  2309. power_state = (union pplib_power_state *)power_state_offset;
  2310. non_clock_array_index = power_state->v2.nonClockInfoIndex;
  2311. non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *)
  2312. &non_clock_info_array->nonClockInfo[non_clock_array_index];
  2313. ps = kzalloc(sizeof(struct kv_ps), GFP_KERNEL);
  2314. if (ps == NULL) {
  2315. kfree(adev->pm.dpm.ps);
  2316. return -ENOMEM;
  2317. }
  2318. adev->pm.dpm.ps[i].ps_priv = ps;
  2319. k = 0;
  2320. idx = (u8 *)&power_state->v2.clockInfoIndex[0];
  2321. for (j = 0; j < power_state->v2.ucNumDPMLevels; j++) {
  2322. clock_array_index = idx[j];
  2323. if (clock_array_index >= clock_info_array->ucNumEntries)
  2324. continue;
  2325. if (k >= SUMO_MAX_HARDWARE_POWERLEVELS)
  2326. break;
  2327. clock_info = (union pplib_clock_info *)
  2328. ((u8 *)&clock_info_array->clockInfo[0] +
  2329. (clock_array_index * clock_info_array->ucEntrySize));
  2330. kv_parse_pplib_clock_info(adev,
  2331. &adev->pm.dpm.ps[i], k,
  2332. clock_info);
  2333. k++;
  2334. }
  2335. kv_parse_pplib_non_clock_info(adev, &adev->pm.dpm.ps[i],
  2336. non_clock_info,
  2337. non_clock_info_array->ucEntrySize);
  2338. power_state_offset += 2 + power_state->v2.ucNumDPMLevels;
  2339. }
  2340. adev->pm.dpm.num_ps = state_array->ucNumEntries;
  2341. /* fill in the vce power states */
  2342. for (i = 0; i < adev->pm.dpm.num_of_vce_states; i++) {
  2343. u32 sclk;
  2344. clock_array_index = adev->pm.dpm.vce_states[i].clk_idx;
  2345. clock_info = (union pplib_clock_info *)
  2346. &clock_info_array->clockInfo[clock_array_index * clock_info_array->ucEntrySize];
  2347. sclk = le16_to_cpu(clock_info->sumo.usEngineClockLow);
  2348. sclk |= clock_info->sumo.ucEngineClockHigh << 16;
  2349. adev->pm.dpm.vce_states[i].sclk = sclk;
  2350. adev->pm.dpm.vce_states[i].mclk = 0;
  2351. }
  2352. return 0;
  2353. }
  2354. static int kv_dpm_init(struct amdgpu_device *adev)
  2355. {
  2356. struct kv_power_info *pi;
  2357. int ret, i;
  2358. pi = kzalloc(sizeof(struct kv_power_info), GFP_KERNEL);
  2359. if (pi == NULL)
  2360. return -ENOMEM;
  2361. adev->pm.dpm.priv = pi;
  2362. ret = amdgpu_get_platform_caps(adev);
  2363. if (ret)
  2364. return ret;
  2365. ret = amdgpu_parse_extended_power_table(adev);
  2366. if (ret)
  2367. return ret;
  2368. for (i = 0; i < SUMO_MAX_HARDWARE_POWERLEVELS; i++)
  2369. pi->at[i] = TRINITY_AT_DFLT;
  2370. pi->sram_end = SMC_RAM_END;
  2371. pi->enable_nb_dpm = true;
  2372. pi->caps_power_containment = true;
  2373. pi->caps_cac = true;
  2374. pi->enable_didt = false;
  2375. if (pi->enable_didt) {
  2376. pi->caps_sq_ramping = true;
  2377. pi->caps_db_ramping = true;
  2378. pi->caps_td_ramping = true;
  2379. pi->caps_tcp_ramping = true;
  2380. }
  2381. if (amdgpu_pp_feature_mask & SCLK_DEEP_SLEEP_MASK)
  2382. pi->caps_sclk_ds = true;
  2383. else
  2384. pi->caps_sclk_ds = false;
  2385. pi->enable_auto_thermal_throttling = true;
  2386. pi->disable_nb_ps3_in_battery = false;
  2387. if (amdgpu_bapm == 0)
  2388. pi->bapm_enable = false;
  2389. else
  2390. pi->bapm_enable = true;
  2391. pi->voltage_drop_t = 0;
  2392. pi->caps_sclk_throttle_low_notification = false;
  2393. pi->caps_fps = false; /* true? */
  2394. pi->caps_uvd_pg = (adev->pg_flags & AMD_PG_SUPPORT_UVD) ? true : false;
  2395. pi->caps_uvd_dpm = true;
  2396. pi->caps_vce_pg = (adev->pg_flags & AMD_PG_SUPPORT_VCE) ? true : false;
  2397. pi->caps_samu_pg = (adev->pg_flags & AMD_PG_SUPPORT_SAMU) ? true : false;
  2398. pi->caps_acp_pg = (adev->pg_flags & AMD_PG_SUPPORT_ACP) ? true : false;
  2399. pi->caps_stable_p_state = false;
  2400. ret = kv_parse_sys_info_table(adev);
  2401. if (ret)
  2402. return ret;
  2403. kv_patch_voltage_values(adev);
  2404. kv_construct_boot_state(adev);
  2405. ret = kv_parse_power_table(adev);
  2406. if (ret)
  2407. return ret;
  2408. pi->enable_dpm = true;
  2409. return 0;
  2410. }
  2411. static void
  2412. kv_dpm_debugfs_print_current_performance_level(struct amdgpu_device *adev,
  2413. struct seq_file *m)
  2414. {
  2415. struct kv_power_info *pi = kv_get_pi(adev);
  2416. u32 current_index =
  2417. (RREG32_SMC(ixTARGET_AND_CURRENT_PROFILE_INDEX) &
  2418. TARGET_AND_CURRENT_PROFILE_INDEX__CURR_SCLK_INDEX_MASK) >>
  2419. TARGET_AND_CURRENT_PROFILE_INDEX__CURR_SCLK_INDEX__SHIFT;
  2420. u32 sclk, tmp;
  2421. u16 vddc;
  2422. if (current_index >= SMU__NUM_SCLK_DPM_STATE) {
  2423. seq_printf(m, "invalid dpm profile %d\n", current_index);
  2424. } else {
  2425. sclk = be32_to_cpu(pi->graphics_level[current_index].SclkFrequency);
  2426. tmp = (RREG32_SMC(ixSMU_VOLTAGE_STATUS) &
  2427. SMU_VOLTAGE_STATUS__SMU_VOLTAGE_CURRENT_LEVEL_MASK) >>
  2428. SMU_VOLTAGE_STATUS__SMU_VOLTAGE_CURRENT_LEVEL__SHIFT;
  2429. vddc = kv_convert_8bit_index_to_voltage(adev, (u16)tmp);
  2430. seq_printf(m, "uvd %sabled\n", pi->uvd_power_gated ? "dis" : "en");
  2431. seq_printf(m, "vce %sabled\n", pi->vce_power_gated ? "dis" : "en");
  2432. seq_printf(m, "power level %d sclk: %u vddc: %u\n",
  2433. current_index, sclk, vddc);
  2434. }
  2435. }
  2436. static void
  2437. kv_dpm_print_power_state(struct amdgpu_device *adev,
  2438. struct amdgpu_ps *rps)
  2439. {
  2440. int i;
  2441. struct kv_ps *ps = kv_get_ps(rps);
  2442. amdgpu_dpm_print_class_info(rps->class, rps->class2);
  2443. amdgpu_dpm_print_cap_info(rps->caps);
  2444. printk("\tuvd vclk: %d dclk: %d\n", rps->vclk, rps->dclk);
  2445. for (i = 0; i < ps->num_levels; i++) {
  2446. struct kv_pl *pl = &ps->levels[i];
  2447. printk("\t\tpower level %d sclk: %u vddc: %u\n",
  2448. i, pl->sclk,
  2449. kv_convert_8bit_index_to_voltage(adev, pl->vddc_index));
  2450. }
  2451. amdgpu_dpm_print_ps_status(adev, rps);
  2452. }
  2453. static void kv_dpm_fini(struct amdgpu_device *adev)
  2454. {
  2455. int i;
  2456. for (i = 0; i < adev->pm.dpm.num_ps; i++) {
  2457. kfree(adev->pm.dpm.ps[i].ps_priv);
  2458. }
  2459. kfree(adev->pm.dpm.ps);
  2460. kfree(adev->pm.dpm.priv);
  2461. amdgpu_free_extended_power_table(adev);
  2462. }
  2463. static void kv_dpm_display_configuration_changed(struct amdgpu_device *adev)
  2464. {
  2465. }
  2466. static u32 kv_dpm_get_sclk(struct amdgpu_device *adev, bool low)
  2467. {
  2468. struct kv_power_info *pi = kv_get_pi(adev);
  2469. struct kv_ps *requested_state = kv_get_ps(&pi->requested_rps);
  2470. if (low)
  2471. return requested_state->levels[0].sclk;
  2472. else
  2473. return requested_state->levels[requested_state->num_levels - 1].sclk;
  2474. }
  2475. static u32 kv_dpm_get_mclk(struct amdgpu_device *adev, bool low)
  2476. {
  2477. struct kv_power_info *pi = kv_get_pi(adev);
  2478. return pi->sys_info.bootup_uma_clk;
  2479. }
  2480. /* get temperature in millidegrees */
  2481. static int kv_dpm_get_temp(struct amdgpu_device *adev)
  2482. {
  2483. u32 temp;
  2484. int actual_temp = 0;
  2485. temp = RREG32_SMC(0xC0300E0C);
  2486. if (temp)
  2487. actual_temp = (temp / 8) - 49;
  2488. else
  2489. actual_temp = 0;
  2490. actual_temp = actual_temp * 1000;
  2491. return actual_temp;
  2492. }
  2493. static int kv_dpm_early_init(void *handle)
  2494. {
  2495. struct amdgpu_device *adev = (struct amdgpu_device *)handle;
  2496. kv_dpm_set_dpm_funcs(adev);
  2497. kv_dpm_set_irq_funcs(adev);
  2498. return 0;
  2499. }
  2500. static int kv_dpm_late_init(void *handle)
  2501. {
  2502. /* powerdown unused blocks for now */
  2503. struct amdgpu_device *adev = (struct amdgpu_device *)handle;
  2504. int ret;
  2505. if (!amdgpu_dpm)
  2506. return 0;
  2507. /* init the sysfs and debugfs files late */
  2508. ret = amdgpu_pm_sysfs_init(adev);
  2509. if (ret)
  2510. return ret;
  2511. kv_dpm_powergate_acp(adev, true);
  2512. kv_dpm_powergate_samu(adev, true);
  2513. return 0;
  2514. }
  2515. static int kv_dpm_sw_init(void *handle)
  2516. {
  2517. int ret;
  2518. struct amdgpu_device *adev = (struct amdgpu_device *)handle;
  2519. ret = amdgpu_irq_add_id(adev, AMDGPU_IH_CLIENTID_LEGACY, 230,
  2520. &adev->pm.dpm.thermal.irq);
  2521. if (ret)
  2522. return ret;
  2523. ret = amdgpu_irq_add_id(adev, AMDGPU_IH_CLIENTID_LEGACY, 231,
  2524. &adev->pm.dpm.thermal.irq);
  2525. if (ret)
  2526. return ret;
  2527. /* default to balanced state */
  2528. adev->pm.dpm.state = POWER_STATE_TYPE_BALANCED;
  2529. adev->pm.dpm.user_state = POWER_STATE_TYPE_BALANCED;
  2530. adev->pm.dpm.forced_level = AMD_DPM_FORCED_LEVEL_AUTO;
  2531. adev->pm.default_sclk = adev->clock.default_sclk;
  2532. adev->pm.default_mclk = adev->clock.default_mclk;
  2533. adev->pm.current_sclk = adev->clock.default_sclk;
  2534. adev->pm.current_mclk = adev->clock.default_mclk;
  2535. adev->pm.int_thermal_type = THERMAL_TYPE_NONE;
  2536. if (amdgpu_dpm == 0)
  2537. return 0;
  2538. INIT_WORK(&adev->pm.dpm.thermal.work, amdgpu_dpm_thermal_work_handler);
  2539. mutex_lock(&adev->pm.mutex);
  2540. ret = kv_dpm_init(adev);
  2541. if (ret)
  2542. goto dpm_failed;
  2543. adev->pm.dpm.current_ps = adev->pm.dpm.requested_ps = adev->pm.dpm.boot_ps;
  2544. if (amdgpu_dpm == 1)
  2545. amdgpu_pm_print_power_states(adev);
  2546. mutex_unlock(&adev->pm.mutex);
  2547. DRM_INFO("amdgpu: dpm initialized\n");
  2548. return 0;
  2549. dpm_failed:
  2550. kv_dpm_fini(adev);
  2551. mutex_unlock(&adev->pm.mutex);
  2552. DRM_ERROR("amdgpu: dpm initialization failed\n");
  2553. return ret;
  2554. }
  2555. static int kv_dpm_sw_fini(void *handle)
  2556. {
  2557. struct amdgpu_device *adev = (struct amdgpu_device *)handle;
  2558. flush_work(&adev->pm.dpm.thermal.work);
  2559. mutex_lock(&adev->pm.mutex);
  2560. amdgpu_pm_sysfs_fini(adev);
  2561. kv_dpm_fini(adev);
  2562. mutex_unlock(&adev->pm.mutex);
  2563. return 0;
  2564. }
  2565. static int kv_dpm_hw_init(void *handle)
  2566. {
  2567. int ret;
  2568. struct amdgpu_device *adev = (struct amdgpu_device *)handle;
  2569. if (!amdgpu_dpm)
  2570. return 0;
  2571. mutex_lock(&adev->pm.mutex);
  2572. kv_dpm_setup_asic(adev);
  2573. ret = kv_dpm_enable(adev);
  2574. if (ret)
  2575. adev->pm.dpm_enabled = false;
  2576. else
  2577. adev->pm.dpm_enabled = true;
  2578. mutex_unlock(&adev->pm.mutex);
  2579. return ret;
  2580. }
  2581. static int kv_dpm_hw_fini(void *handle)
  2582. {
  2583. struct amdgpu_device *adev = (struct amdgpu_device *)handle;
  2584. if (adev->pm.dpm_enabled) {
  2585. mutex_lock(&adev->pm.mutex);
  2586. kv_dpm_disable(adev);
  2587. mutex_unlock(&adev->pm.mutex);
  2588. }
  2589. return 0;
  2590. }
  2591. static int kv_dpm_suspend(void *handle)
  2592. {
  2593. struct amdgpu_device *adev = (struct amdgpu_device *)handle;
  2594. if (adev->pm.dpm_enabled) {
  2595. mutex_lock(&adev->pm.mutex);
  2596. /* disable dpm */
  2597. kv_dpm_disable(adev);
  2598. /* reset the power state */
  2599. adev->pm.dpm.current_ps = adev->pm.dpm.requested_ps = adev->pm.dpm.boot_ps;
  2600. mutex_unlock(&adev->pm.mutex);
  2601. }
  2602. return 0;
  2603. }
  2604. static int kv_dpm_resume(void *handle)
  2605. {
  2606. int ret;
  2607. struct amdgpu_device *adev = (struct amdgpu_device *)handle;
  2608. if (adev->pm.dpm_enabled) {
  2609. /* asic init will reset to the boot state */
  2610. mutex_lock(&adev->pm.mutex);
  2611. kv_dpm_setup_asic(adev);
  2612. ret = kv_dpm_enable(adev);
  2613. if (ret)
  2614. adev->pm.dpm_enabled = false;
  2615. else
  2616. adev->pm.dpm_enabled = true;
  2617. mutex_unlock(&adev->pm.mutex);
  2618. if (adev->pm.dpm_enabled)
  2619. amdgpu_pm_compute_clocks(adev);
  2620. }
  2621. return 0;
  2622. }
  2623. static bool kv_dpm_is_idle(void *handle)
  2624. {
  2625. return true;
  2626. }
  2627. static int kv_dpm_wait_for_idle(void *handle)
  2628. {
  2629. return 0;
  2630. }
  2631. static int kv_dpm_soft_reset(void *handle)
  2632. {
  2633. return 0;
  2634. }
  2635. static int kv_dpm_set_interrupt_state(struct amdgpu_device *adev,
  2636. struct amdgpu_irq_src *src,
  2637. unsigned type,
  2638. enum amdgpu_interrupt_state state)
  2639. {
  2640. u32 cg_thermal_int;
  2641. switch (type) {
  2642. case AMDGPU_THERMAL_IRQ_LOW_TO_HIGH:
  2643. switch (state) {
  2644. case AMDGPU_IRQ_STATE_DISABLE:
  2645. cg_thermal_int = RREG32_SMC(ixCG_THERMAL_INT_CTRL);
  2646. cg_thermal_int &= ~CG_THERMAL_INT_CTRL__THERM_INTH_MASK_MASK;
  2647. WREG32_SMC(ixCG_THERMAL_INT_CTRL, cg_thermal_int);
  2648. break;
  2649. case AMDGPU_IRQ_STATE_ENABLE:
  2650. cg_thermal_int = RREG32_SMC(ixCG_THERMAL_INT_CTRL);
  2651. cg_thermal_int |= CG_THERMAL_INT_CTRL__THERM_INTH_MASK_MASK;
  2652. WREG32_SMC(ixCG_THERMAL_INT_CTRL, cg_thermal_int);
  2653. break;
  2654. default:
  2655. break;
  2656. }
  2657. break;
  2658. case AMDGPU_THERMAL_IRQ_HIGH_TO_LOW:
  2659. switch (state) {
  2660. case AMDGPU_IRQ_STATE_DISABLE:
  2661. cg_thermal_int = RREG32_SMC(ixCG_THERMAL_INT_CTRL);
  2662. cg_thermal_int &= ~CG_THERMAL_INT_CTRL__THERM_INTL_MASK_MASK;
  2663. WREG32_SMC(ixCG_THERMAL_INT_CTRL, cg_thermal_int);
  2664. break;
  2665. case AMDGPU_IRQ_STATE_ENABLE:
  2666. cg_thermal_int = RREG32_SMC(ixCG_THERMAL_INT_CTRL);
  2667. cg_thermal_int |= CG_THERMAL_INT_CTRL__THERM_INTL_MASK_MASK;
  2668. WREG32_SMC(ixCG_THERMAL_INT_CTRL, cg_thermal_int);
  2669. break;
  2670. default:
  2671. break;
  2672. }
  2673. break;
  2674. default:
  2675. break;
  2676. }
  2677. return 0;
  2678. }
  2679. static int kv_dpm_process_interrupt(struct amdgpu_device *adev,
  2680. struct amdgpu_irq_src *source,
  2681. struct amdgpu_iv_entry *entry)
  2682. {
  2683. bool queue_thermal = false;
  2684. if (entry == NULL)
  2685. return -EINVAL;
  2686. switch (entry->src_id) {
  2687. case 230: /* thermal low to high */
  2688. DRM_DEBUG("IH: thermal low to high\n");
  2689. adev->pm.dpm.thermal.high_to_low = false;
  2690. queue_thermal = true;
  2691. break;
  2692. case 231: /* thermal high to low */
  2693. DRM_DEBUG("IH: thermal high to low\n");
  2694. adev->pm.dpm.thermal.high_to_low = true;
  2695. queue_thermal = true;
  2696. break;
  2697. default:
  2698. break;
  2699. }
  2700. if (queue_thermal)
  2701. schedule_work(&adev->pm.dpm.thermal.work);
  2702. return 0;
  2703. }
  2704. static int kv_dpm_set_clockgating_state(void *handle,
  2705. enum amd_clockgating_state state)
  2706. {
  2707. return 0;
  2708. }
  2709. static int kv_dpm_set_powergating_state(void *handle,
  2710. enum amd_powergating_state state)
  2711. {
  2712. return 0;
  2713. }
  2714. static inline bool kv_are_power_levels_equal(const struct kv_pl *kv_cpl1,
  2715. const struct kv_pl *kv_cpl2)
  2716. {
  2717. return ((kv_cpl1->sclk == kv_cpl2->sclk) &&
  2718. (kv_cpl1->vddc_index == kv_cpl2->vddc_index) &&
  2719. (kv_cpl1->ds_divider_index == kv_cpl2->ds_divider_index) &&
  2720. (kv_cpl1->force_nbp_state == kv_cpl2->force_nbp_state));
  2721. }
  2722. static int kv_check_state_equal(struct amdgpu_device *adev,
  2723. struct amdgpu_ps *cps,
  2724. struct amdgpu_ps *rps,
  2725. bool *equal)
  2726. {
  2727. struct kv_ps *kv_cps;
  2728. struct kv_ps *kv_rps;
  2729. int i;
  2730. if (adev == NULL || cps == NULL || rps == NULL || equal == NULL)
  2731. return -EINVAL;
  2732. kv_cps = kv_get_ps(cps);
  2733. kv_rps = kv_get_ps(rps);
  2734. if (kv_cps == NULL) {
  2735. *equal = false;
  2736. return 0;
  2737. }
  2738. if (kv_cps->num_levels != kv_rps->num_levels) {
  2739. *equal = false;
  2740. return 0;
  2741. }
  2742. for (i = 0; i < kv_cps->num_levels; i++) {
  2743. if (!kv_are_power_levels_equal(&(kv_cps->levels[i]),
  2744. &(kv_rps->levels[i]))) {
  2745. *equal = false;
  2746. return 0;
  2747. }
  2748. }
  2749. /* If all performance levels are the same try to use the UVD clocks to break the tie.*/
  2750. *equal = ((cps->vclk == rps->vclk) && (cps->dclk == rps->dclk));
  2751. *equal &= ((cps->evclk == rps->evclk) && (cps->ecclk == rps->ecclk));
  2752. return 0;
  2753. }
  2754. static int kv_dpm_read_sensor(struct amdgpu_device *adev, int idx,
  2755. void *value, int *size)
  2756. {
  2757. struct kv_power_info *pi = kv_get_pi(adev);
  2758. uint32_t sclk;
  2759. u32 pl_index =
  2760. (RREG32_SMC(ixTARGET_AND_CURRENT_PROFILE_INDEX) &
  2761. TARGET_AND_CURRENT_PROFILE_INDEX__CURR_SCLK_INDEX_MASK) >>
  2762. TARGET_AND_CURRENT_PROFILE_INDEX__CURR_SCLK_INDEX__SHIFT;
  2763. /* size must be at least 4 bytes for all sensors */
  2764. if (*size < 4)
  2765. return -EINVAL;
  2766. switch (idx) {
  2767. case AMDGPU_PP_SENSOR_GFX_SCLK:
  2768. if (pl_index < SMU__NUM_SCLK_DPM_STATE) {
  2769. sclk = be32_to_cpu(
  2770. pi->graphics_level[pl_index].SclkFrequency);
  2771. *((uint32_t *)value) = sclk;
  2772. *size = 4;
  2773. return 0;
  2774. }
  2775. return -EINVAL;
  2776. case AMDGPU_PP_SENSOR_GPU_TEMP:
  2777. *((uint32_t *)value) = kv_dpm_get_temp(adev);
  2778. *size = 4;
  2779. return 0;
  2780. default:
  2781. return -EINVAL;
  2782. }
  2783. }
  2784. const struct amd_ip_funcs kv_dpm_ip_funcs = {
  2785. .name = "kv_dpm",
  2786. .early_init = kv_dpm_early_init,
  2787. .late_init = kv_dpm_late_init,
  2788. .sw_init = kv_dpm_sw_init,
  2789. .sw_fini = kv_dpm_sw_fini,
  2790. .hw_init = kv_dpm_hw_init,
  2791. .hw_fini = kv_dpm_hw_fini,
  2792. .suspend = kv_dpm_suspend,
  2793. .resume = kv_dpm_resume,
  2794. .is_idle = kv_dpm_is_idle,
  2795. .wait_for_idle = kv_dpm_wait_for_idle,
  2796. .soft_reset = kv_dpm_soft_reset,
  2797. .set_clockgating_state = kv_dpm_set_clockgating_state,
  2798. .set_powergating_state = kv_dpm_set_powergating_state,
  2799. };
  2800. static const struct amdgpu_dpm_funcs kv_dpm_funcs = {
  2801. .get_temperature = &kv_dpm_get_temp,
  2802. .pre_set_power_state = &kv_dpm_pre_set_power_state,
  2803. .set_power_state = &kv_dpm_set_power_state,
  2804. .post_set_power_state = &kv_dpm_post_set_power_state,
  2805. .display_configuration_changed = &kv_dpm_display_configuration_changed,
  2806. .get_sclk = &kv_dpm_get_sclk,
  2807. .get_mclk = &kv_dpm_get_mclk,
  2808. .print_power_state = &kv_dpm_print_power_state,
  2809. .debugfs_print_current_performance_level = &kv_dpm_debugfs_print_current_performance_level,
  2810. .force_performance_level = &kv_dpm_force_performance_level,
  2811. .powergate_uvd = &kv_dpm_powergate_uvd,
  2812. .enable_bapm = &kv_dpm_enable_bapm,
  2813. .get_vce_clock_state = amdgpu_get_vce_clock_state,
  2814. .check_state_equal = kv_check_state_equal,
  2815. .read_sensor = &kv_dpm_read_sensor,
  2816. };
  2817. static void kv_dpm_set_dpm_funcs(struct amdgpu_device *adev)
  2818. {
  2819. if (adev->pm.funcs == NULL)
  2820. adev->pm.funcs = &kv_dpm_funcs;
  2821. }
  2822. static const struct amdgpu_irq_src_funcs kv_dpm_irq_funcs = {
  2823. .set = kv_dpm_set_interrupt_state,
  2824. .process = kv_dpm_process_interrupt,
  2825. };
  2826. static void kv_dpm_set_irq_funcs(struct amdgpu_device *adev)
  2827. {
  2828. adev->pm.dpm.thermal.irq.num_types = AMDGPU_THERMAL_IRQ_LAST;
  2829. adev->pm.dpm.thermal.irq.funcs = &kv_dpm_irq_funcs;
  2830. }