cam_sync.c 82 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
  4. * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
  5. */
  6. #include <linux/init.h>
  7. #include <linux/module.h>
  8. #include <linux/irqflags.h>
  9. #include <linux/module.h>
  10. #include <linux/platform_device.h>
  11. #include <linux/debugfs.h>
  12. #if IS_REACHABLE(CONFIG_MSM_GLOBAL_SYNX) || IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  13. #include <synx_api.h>
  14. #endif
  15. #include "cam_sync_util.h"
  16. #include "cam_debug_util.h"
  17. #include "cam_common_util.h"
  18. #include "cam_compat.h"
  19. #include "camera_main.h"
  20. #include "cam_req_mgr_workq.h"
  21. struct sync_device *sync_dev;
  22. /*
  23. * Flag to determine whether to enqueue cb of a
  24. * signaled fence onto the workq or invoke it
  25. * directly in the same context
  26. */
  27. static bool trigger_cb_without_switch;
  28. unsigned long cam_sync_monitor_mask;
  29. static void cam_sync_print_fence_table(void)
  30. {
  31. int idx;
  32. for (idx = 0; idx < CAM_SYNC_MAX_OBJS; idx++) {
  33. spin_lock_bh(&sync_dev->row_spinlocks[idx]);
  34. CAM_INFO(CAM_SYNC,
  35. "index[%u]: sync_id=%d, name=%s, type=%d, state=%d, ref_cnt=%d",
  36. idx,
  37. sync_dev->sync_table[idx].sync_id,
  38. sync_dev->sync_table[idx].name,
  39. sync_dev->sync_table[idx].type,
  40. sync_dev->sync_table[idx].state,
  41. atomic_read(&sync_dev->sync_table[idx].ref_cnt));
  42. spin_unlock_bh(&sync_dev->row_spinlocks[idx]);
  43. }
  44. }
  45. static int cam_sync_create_util(
  46. int32_t *sync_obj, const char *name,
  47. struct cam_dma_fence_create_sync_obj_payload *dma_sync_create_info,
  48. struct sync_synx_obj_info *synx_obj_sync_create_info)
  49. {
  50. int rc;
  51. long idx;
  52. bool bit;
  53. struct sync_table_row *row = NULL;
  54. do {
  55. idx = find_first_zero_bit(sync_dev->bitmap, CAM_SYNC_MAX_OBJS);
  56. if (idx >= CAM_SYNC_MAX_OBJS) {
  57. CAM_ERR(CAM_SYNC,
  58. "Error: Unable to create sync idx = %d sync name = %s reached max!",
  59. idx, name);
  60. cam_sync_print_fence_table();
  61. return -ENOMEM;
  62. }
  63. CAM_DBG(CAM_SYNC, "Index location available at idx: %ld", idx);
  64. bit = test_and_set_bit(idx, sync_dev->bitmap);
  65. } while (bit);
  66. spin_lock_bh(&sync_dev->row_spinlocks[idx]);
  67. rc = cam_sync_init_row(sync_dev->sync_table, idx, name,
  68. CAM_SYNC_TYPE_INDV);
  69. if (rc) {
  70. CAM_ERR(CAM_SYNC, "Error: Unable to init row at idx = %ld",
  71. idx);
  72. clear_bit(idx, sync_dev->bitmap);
  73. spin_unlock_bh(&sync_dev->row_spinlocks[idx]);
  74. return -EINVAL;
  75. }
  76. *sync_obj = idx;
  77. /* Associate sync obj with synx if any holding sync lock */
  78. if (synx_obj_sync_create_info) {
  79. row = sync_dev->sync_table + idx;
  80. row->synx_obj_info.synx_obj_row_idx =
  81. synx_obj_sync_create_info->synx_obj_row_idx;
  82. row->synx_obj_info.sync_created_with_synx =
  83. synx_obj_sync_create_info->sync_created_with_synx;
  84. row->synx_obj_info.synx_obj = synx_obj_sync_create_info->synx_obj;
  85. set_bit(CAM_GENERIC_FENCE_TYPE_SYNX_OBJ, &row->ext_fence_mask);
  86. CAM_DBG(CAM_SYNC, "sync_obj: %s[%d] associated with synx_obj: %d",
  87. name, *sync_obj, row->synx_obj_info.synx_obj);
  88. }
  89. /* Associate sync obj with dma fence if any holding sync lock */
  90. if (dma_sync_create_info) {
  91. row = sync_dev->sync_table + idx;
  92. row->dma_fence_info.dma_fence_fd = dma_sync_create_info->fd;
  93. row->dma_fence_info.dma_fence_row_idx = dma_sync_create_info->dma_fence_row_idx;
  94. row->dma_fence_info.sync_created_with_dma =
  95. dma_sync_create_info->sync_created_with_dma;
  96. set_bit(CAM_GENERIC_FENCE_TYPE_DMA_FENCE, &row->ext_fence_mask);
  97. /* Association refcnt for non-import cases */
  98. if (dma_sync_create_info->sync_created_with_dma) {
  99. rc = cam_dma_fence_get_put_ref(true, row->dma_fence_info.dma_fence_row_idx);
  100. if (rc)
  101. CAM_ERR(CAM_SYNC,
  102. "Failed to getref on dma fence idx: %u fd: %d sync_obj: %d rc: %d",
  103. row->dma_fence_info.dma_fence_row_idx,
  104. row->dma_fence_info.dma_fence_fd,
  105. *sync_obj, rc);
  106. goto end;
  107. }
  108. CAM_DBG(CAM_SYNC, "sync_obj: %s[%d] associated with dma fence fd: %d",
  109. name, *sync_obj, dma_sync_create_info->fd);
  110. goto end;
  111. }
  112. CAM_DBG(CAM_SYNC, "sync_obj: %s[%i]", name, *sync_obj);
  113. end:
  114. spin_unlock_bh(&sync_dev->row_spinlocks[idx]);
  115. return rc;
  116. }
  117. int cam_sync_create(int32_t *sync_obj, const char *name)
  118. {
  119. return cam_sync_create_util(sync_obj, name, NULL, NULL);
  120. }
  121. int cam_sync_register_callback(sync_callback cb_func,
  122. void *userdata, int32_t sync_obj)
  123. {
  124. struct sync_callback_info *sync_cb;
  125. struct sync_table_row *row = NULL;
  126. int status = 0;
  127. int rc = 0;
  128. if ((sync_obj >= CAM_SYNC_MAX_OBJS) || (sync_obj <= 0) || (!cb_func))
  129. return -EINVAL;
  130. spin_lock_bh(&sync_dev->row_spinlocks[sync_obj]);
  131. row = sync_dev->sync_table + sync_obj;
  132. if (row->state == CAM_SYNC_STATE_INVALID) {
  133. CAM_ERR(CAM_SYNC,
  134. "Error: accessing an uninitialized sync obj %s[%d]",
  135. row->name,
  136. sync_obj);
  137. rc = -EINVAL;
  138. goto monitor_dump;
  139. }
  140. sync_cb = kzalloc(sizeof(*sync_cb), GFP_ATOMIC);
  141. if (!sync_cb) {
  142. rc = -ENOMEM;
  143. goto monitor_dump;
  144. }
  145. /* Trigger callback if sync object is already in SIGNALED state */
  146. if (((row->state == CAM_SYNC_STATE_SIGNALED_SUCCESS) ||
  147. (row->state == CAM_SYNC_STATE_SIGNALED_ERROR) ||
  148. (row->state == CAM_SYNC_STATE_SIGNALED_CANCEL)) &&
  149. (!row->remaining)) {
  150. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNC_OBJ,
  151. &cam_sync_monitor_mask))
  152. cam_generic_fence_update_monitor_array(sync_obj,
  153. &sync_dev->table_lock, sync_dev->mon_data,
  154. CAM_FENCE_OP_SKIP_REGISTER_CB);
  155. if (trigger_cb_without_switch) {
  156. CAM_DBG(CAM_SYNC, "Invoke callback for sync object:%s[%d]",
  157. row->name,
  158. sync_obj);
  159. status = row->state;
  160. kfree(sync_cb);
  161. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  162. cb_func(sync_obj, status, userdata);
  163. } else {
  164. sync_cb->callback_func = cb_func;
  165. sync_cb->cb_data = userdata;
  166. sync_cb->sync_obj = sync_obj;
  167. INIT_WORK(&sync_cb->cb_dispatch_work,
  168. cam_sync_util_cb_dispatch);
  169. sync_cb->status = row->state;
  170. CAM_DBG(CAM_SYNC, "Enqueue callback for sync object:%s[%d]",
  171. row->name,
  172. sync_cb->sync_obj);
  173. sync_cb->workq_scheduled_ts = ktime_get();
  174. queue_work(sync_dev->work_queue,
  175. &sync_cb->cb_dispatch_work);
  176. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  177. }
  178. return 0;
  179. }
  180. sync_cb->callback_func = cb_func;
  181. sync_cb->cb_data = userdata;
  182. sync_cb->sync_obj = sync_obj;
  183. INIT_WORK(&sync_cb->cb_dispatch_work, cam_sync_util_cb_dispatch);
  184. list_add_tail(&sync_cb->list, &row->callback_list);
  185. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNC_OBJ, &cam_sync_monitor_mask))
  186. cam_generic_fence_update_monitor_array(sync_obj,
  187. &sync_dev->table_lock, sync_dev->mon_data,
  188. CAM_FENCE_OP_REGISTER_CB);
  189. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  190. return 0;
  191. monitor_dump:
  192. cam_sync_dump_monitor_array(row);
  193. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  194. return rc;
  195. }
  196. int cam_sync_deregister_callback(sync_callback cb_func,
  197. void *userdata, int32_t sync_obj)
  198. {
  199. struct sync_table_row *row = NULL;
  200. struct sync_callback_info *sync_cb, *temp;
  201. bool found = false;
  202. int rc = 0;
  203. if ((sync_obj >= CAM_SYNC_MAX_OBJS) || (sync_obj <= 0))
  204. return -EINVAL;
  205. spin_lock_bh(&sync_dev->row_spinlocks[sync_obj]);
  206. row = sync_dev->sync_table + sync_obj;
  207. if (row->state == CAM_SYNC_STATE_INVALID) {
  208. CAM_ERR(CAM_SYNC,
  209. "Error: accessing an uninitialized sync obj = %s[%d]",
  210. row->name,
  211. sync_obj);
  212. rc = -EINVAL;
  213. goto monitor_dump;
  214. }
  215. CAM_DBG(CAM_SYNC, "deregistered callback for sync object:%s[%d]",
  216. row->name,
  217. sync_obj);
  218. list_for_each_entry_safe(sync_cb, temp, &row->callback_list, list) {
  219. if ((sync_cb->callback_func == cb_func) &&
  220. (sync_cb->cb_data == userdata)) {
  221. list_del_init(&sync_cb->list);
  222. kfree(sync_cb);
  223. found = true;
  224. }
  225. }
  226. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNC_OBJ, &cam_sync_monitor_mask)) {
  227. if (found) {
  228. cam_generic_fence_update_monitor_array(sync_obj,
  229. &sync_dev->table_lock, sync_dev->mon_data,
  230. CAM_FENCE_OP_UNREGISTER_CB);
  231. } else {
  232. CAM_ERR(CAM_SYNC,
  233. "Error: Callback not found sync obj = %s[%d] : sync_id %d, state %d",
  234. row->name, sync_obj, row->sync_id, row->state);
  235. cam_sync_dump_monitor_array(row);
  236. }
  237. }
  238. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  239. return found ? 0 : -ENOENT;
  240. monitor_dump:
  241. cam_sync_dump_monitor_array(row);
  242. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  243. return rc;
  244. }
  245. static inline int cam_sync_signal_dma_fence_util(
  246. struct sync_table_row *row, uint32_t status)
  247. {
  248. struct cam_dma_fence_signal signal_dma_fence;
  249. signal_dma_fence.dma_fence_fd = row->dma_fence_info.dma_fence_fd;
  250. switch (status) {
  251. case CAM_SYNC_STATE_SIGNALED_SUCCESS:
  252. signal_dma_fence.status = 0;
  253. break;
  254. case CAM_SYNC_STATE_SIGNALED_ERROR:
  255. /* Advertise error */
  256. signal_dma_fence.status = -EADV;
  257. break;
  258. case CAM_SYNC_STATE_SIGNALED_CANCEL:
  259. signal_dma_fence.status = -ECANCELED;
  260. break;
  261. default:
  262. CAM_ERR(CAM_SYNC,
  263. "Signaling undefined status: %d for sync obj: %d",
  264. status, row->sync_id);
  265. return -EINVAL;
  266. }
  267. return cam_dma_fence_internal_signal(row->dma_fence_info.dma_fence_row_idx,
  268. &signal_dma_fence);
  269. }
  270. static void cam_sync_signal_parent_util(int32_t status,
  271. uint32_t event_cause, struct list_head *parents_list)
  272. {
  273. int rc;
  274. struct sync_table_row *parent_row = NULL;
  275. struct sync_parent_info *parent_info, *temp_parent_info;
  276. /*
  277. * Now iterate over all parents of this object and if they too need to
  278. * be signaled dispatch cb's
  279. */
  280. list_for_each_entry_safe(parent_info, temp_parent_info,
  281. parents_list, list) {
  282. parent_row = sync_dev->sync_table + parent_info->sync_id;
  283. spin_lock_bh(&sync_dev->row_spinlocks[parent_info->sync_id]);
  284. parent_row->remaining--;
  285. rc = cam_sync_util_update_parent_state(
  286. parent_row,
  287. status);
  288. if (rc) {
  289. CAM_ERR(CAM_SYNC, "Invalid parent state %d",
  290. parent_row->state);
  291. spin_unlock_bh(
  292. &sync_dev->row_spinlocks[parent_info->sync_id]);
  293. kfree(parent_info);
  294. continue;
  295. }
  296. if (!parent_row->remaining)
  297. cam_sync_util_dispatch_signaled_cb(
  298. parent_info->sync_id, parent_row->state,
  299. event_cause);
  300. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNC_OBJ,
  301. &cam_sync_monitor_mask))
  302. cam_generic_fence_update_monitor_array(parent_info->sync_id,
  303. &sync_dev->table_lock, sync_dev->mon_data,
  304. CAM_FENCE_OP_SIGNAL);
  305. spin_unlock_bh(&sync_dev->row_spinlocks[parent_info->sync_id]);
  306. list_del_init(&parent_info->list);
  307. kfree(parent_info);
  308. }
  309. }
  310. static int cam_sync_signal_validate_util(
  311. int32_t sync_obj, int32_t status)
  312. {
  313. struct sync_table_row *row = sync_dev->sync_table + sync_obj;
  314. if (row->state == CAM_SYNC_STATE_INVALID) {
  315. CAM_ERR(CAM_SYNC,
  316. "Error: accessing an uninitialized sync obj = %s[%d]",
  317. row->name, sync_obj);
  318. return -EINVAL;
  319. }
  320. if (row->type == CAM_SYNC_TYPE_GROUP) {
  321. CAM_ERR(CAM_SYNC,
  322. "Error: Signaling a GROUP sync object = %s[%d]",
  323. row->name, sync_obj);
  324. return -EINVAL;
  325. }
  326. if (row->state != CAM_SYNC_STATE_ACTIVE) {
  327. CAM_ERR(CAM_SYNC,
  328. "Error: Sync object already signaled sync_obj = %s[%d]",
  329. row->name, sync_obj);
  330. return -EALREADY;
  331. }
  332. if ((status != CAM_SYNC_STATE_SIGNALED_SUCCESS) &&
  333. (status != CAM_SYNC_STATE_SIGNALED_ERROR) &&
  334. (status != CAM_SYNC_STATE_SIGNALED_CANCEL)) {
  335. CAM_ERR(CAM_SYNC,
  336. "Error: signaling with undefined status = %d", status);
  337. return -EINVAL;
  338. }
  339. return 0;
  340. }
  341. int cam_sync_signal(int32_t sync_obj, uint32_t status, uint32_t event_cause)
  342. {
  343. struct sync_table_row *row = NULL;
  344. struct list_head parents_list;
  345. int rc = 0;
  346. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  347. uint32_t synx_row_idx;
  348. struct cam_synx_obj_signal signal_synx_obj;
  349. #endif
  350. if ((sync_obj >= CAM_SYNC_MAX_OBJS) || (sync_obj <= 0)) {
  351. CAM_ERR(CAM_SYNC, "Error: Out of range sync obj (0 <= %d < %d)",
  352. sync_obj, CAM_SYNC_MAX_OBJS);
  353. return -EINVAL;
  354. }
  355. spin_lock_bh(&sync_dev->row_spinlocks[sync_obj]);
  356. row = sync_dev->sync_table + sync_obj;
  357. rc = cam_sync_signal_validate_util(sync_obj, status);
  358. if (rc) {
  359. CAM_ERR(CAM_SYNC,
  360. "Error: Failed to validate signal info for sync_obj = %s[%d] with status = %d rc = %d",
  361. row->name, sync_obj, status, rc);
  362. goto monitor_dump;
  363. }
  364. if (!atomic_dec_and_test(&row->ref_cnt)) {
  365. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  366. return 0;
  367. }
  368. row->state = status;
  369. /*
  370. * Signal associated dma fence first - external entities
  371. * waiting on this fence can start processing
  372. */
  373. if (test_bit(CAM_GENERIC_FENCE_TYPE_DMA_FENCE, &row->ext_fence_mask)) {
  374. rc = cam_sync_signal_dma_fence_util(row, status);
  375. if (rc)
  376. CAM_ERR(CAM_SYNC,
  377. "Error: Failed to signal associated dma fencefd = %d for sync_obj = %s[%d]",
  378. row->dma_fence_info.dma_fence_fd, row->name, sync_obj);
  379. }
  380. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  381. /*
  382. * Signal associated synx obj prior to sync
  383. */
  384. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNX_OBJ, &row->ext_fence_mask)) {
  385. signal_synx_obj.status = status;
  386. signal_synx_obj.synx_obj = row->synx_obj_info.synx_obj;
  387. synx_row_idx = row->synx_obj_info.synx_obj_row_idx;
  388. /* Release & obtain the row lock after synx signal */
  389. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  390. rc = cam_synx_obj_internal_signal(synx_row_idx, &signal_synx_obj);
  391. spin_lock_bh(&sync_dev->row_spinlocks[sync_obj]);
  392. if (rc)
  393. CAM_ERR(CAM_SYNC,
  394. "Error: Failed to signal associated synx obj = %d for sync_obj = %d",
  395. signal_synx_obj.synx_obj, sync_obj);
  396. }
  397. #endif
  398. cam_sync_util_dispatch_signaled_cb(sync_obj, status, event_cause);
  399. /* copy parent list to local and release child lock */
  400. INIT_LIST_HEAD(&parents_list);
  401. list_splice_init(&row->parents_list, &parents_list);
  402. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNC_OBJ, &cam_sync_monitor_mask))
  403. cam_generic_fence_update_monitor_array(sync_obj,
  404. &sync_dev->table_lock, sync_dev->mon_data,
  405. CAM_FENCE_OP_SIGNAL);
  406. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  407. if (list_empty(&parents_list))
  408. return 0;
  409. cam_sync_signal_parent_util(status, event_cause, &parents_list);
  410. return 0;
  411. monitor_dump:
  412. cam_sync_dump_monitor_array(row);
  413. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  414. return rc;
  415. }
  416. int cam_sync_merge(int32_t *sync_obj, uint32_t num_objs, int32_t *merged_obj)
  417. {
  418. int rc;
  419. long idx = 0;
  420. bool bit;
  421. int i = 0;
  422. if ((!sync_obj) || (!merged_obj)) {
  423. CAM_ERR(CAM_SYNC, "Invalid pointer(s)");
  424. return -EINVAL;
  425. }
  426. if (num_objs <= 1) {
  427. CAM_ERR(CAM_SYNC, "Single object merge is not allowed");
  428. return -EINVAL;
  429. }
  430. if (cam_common_util_remove_duplicate_arr(sync_obj, num_objs)
  431. != num_objs) {
  432. CAM_ERR(CAM_SYNC, "The obj list has duplicate fence");
  433. return -EINVAL;
  434. }
  435. for (i = 0; i < num_objs; i++) {
  436. rc = cam_sync_check_valid(sync_obj[i]);
  437. if (rc) {
  438. CAM_ERR(CAM_SYNC, "Sync_obj[%d] %d valid check fail",
  439. i, sync_obj[i]);
  440. return rc;
  441. }
  442. }
  443. do {
  444. idx = find_first_zero_bit(sync_dev->bitmap, CAM_SYNC_MAX_OBJS);
  445. if (idx >= CAM_SYNC_MAX_OBJS)
  446. return -ENOMEM;
  447. bit = test_and_set_bit(idx, sync_dev->bitmap);
  448. } while (bit);
  449. spin_lock_bh(&sync_dev->row_spinlocks[idx]);
  450. rc = cam_sync_init_group_object(sync_dev->sync_table,
  451. idx, sync_obj,
  452. num_objs);
  453. if (rc < 0) {
  454. CAM_ERR(CAM_SYNC, "Error: Unable to init row at idx = %ld",
  455. idx);
  456. clear_bit(idx, sync_dev->bitmap);
  457. return -EINVAL;
  458. }
  459. CAM_DBG(CAM_SYNC, "Init row at idx:%ld to merge objects", idx);
  460. *merged_obj = idx;
  461. spin_unlock_bh(&sync_dev->row_spinlocks[idx]);
  462. return 0;
  463. }
  464. int cam_sync_get_obj_ref(int32_t sync_obj)
  465. {
  466. struct sync_table_row *row = NULL;
  467. int rc;
  468. if ((sync_obj >= CAM_SYNC_MAX_OBJS) || (sync_obj <= 0))
  469. return -EINVAL;
  470. spin_lock(&sync_dev->row_spinlocks[sync_obj]);
  471. row = sync_dev->sync_table + sync_obj;
  472. if (row->state != CAM_SYNC_STATE_ACTIVE) {
  473. CAM_ERR(CAM_SYNC,
  474. "Error: accessing an uninitialized sync obj = %s[%d]",
  475. row->name,
  476. sync_obj);
  477. rc = -EINVAL;
  478. goto monitor_dump;
  479. }
  480. atomic_inc(&row->ref_cnt);
  481. spin_unlock(&sync_dev->row_spinlocks[sync_obj]);
  482. CAM_DBG(CAM_SYNC, "get ref for obj %d", sync_obj);
  483. return 0;
  484. monitor_dump:
  485. cam_sync_dump_monitor_array(row);
  486. spin_unlock(&sync_dev->row_spinlocks[sync_obj]);
  487. return rc;
  488. }
  489. int cam_sync_put_obj_ref(int32_t sync_obj)
  490. {
  491. struct sync_table_row *row = NULL;
  492. if ((sync_obj >= CAM_SYNC_MAX_OBJS) || (sync_obj <= 0))
  493. return -EINVAL;
  494. row = sync_dev->sync_table + sync_obj;
  495. atomic_dec(&row->ref_cnt);
  496. CAM_DBG(CAM_SYNC, "put ref for obj %d", sync_obj);
  497. return 0;
  498. }
  499. int cam_sync_destroy(int32_t sync_obj)
  500. {
  501. return cam_sync_deinit_object(sync_dev->sync_table, sync_obj, NULL, NULL);
  502. }
  503. int cam_sync_check_valid(int32_t sync_obj)
  504. {
  505. struct sync_table_row *row = NULL;
  506. int rc;
  507. if ((sync_obj >= CAM_SYNC_MAX_OBJS) || (sync_obj <= 0))
  508. return -EINVAL;
  509. spin_lock_bh(&sync_dev->row_spinlocks[sync_obj]);
  510. row = sync_dev->sync_table + sync_obj;
  511. if (!test_bit(sync_obj, sync_dev->bitmap)) {
  512. CAM_ERR(CAM_SYNC, "Error: Released sync obj received %s[%d]",
  513. row->name,
  514. sync_obj);
  515. rc = -EINVAL;
  516. goto monitor_dump;
  517. }
  518. if (row->state == CAM_SYNC_STATE_INVALID) {
  519. CAM_ERR(CAM_SYNC,
  520. "Error: accessing an uninitialized sync obj = %s[%d]",
  521. row->name,
  522. sync_obj);
  523. rc = -EINVAL;
  524. goto monitor_dump;
  525. }
  526. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  527. return 0;
  528. monitor_dump:
  529. cam_sync_dump_monitor_array(row);
  530. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  531. return rc;
  532. }
  533. int cam_sync_wait(int32_t sync_obj, uint64_t timeout_ms)
  534. {
  535. unsigned long timeleft;
  536. int rc;
  537. struct sync_table_row *row = NULL;
  538. if ((sync_obj >= CAM_SYNC_MAX_OBJS) || (sync_obj <= 0))
  539. return -EINVAL;
  540. row = sync_dev->sync_table + sync_obj;
  541. if (row->state == CAM_SYNC_STATE_INVALID) {
  542. CAM_ERR(CAM_SYNC,
  543. "Error: accessing an uninitialized sync obj = %s[%d]",
  544. row->name,
  545. sync_obj);
  546. rc = -EINVAL;
  547. goto monitor_dump;
  548. }
  549. timeleft = cam_common_wait_for_completion_timeout(&row->signaled,
  550. msecs_to_jiffies(timeout_ms));
  551. if (!timeleft) {
  552. CAM_ERR(CAM_SYNC,
  553. "Error: timed out for sync obj = %s[%d]", row->name, sync_obj);
  554. rc = -ETIMEDOUT;
  555. goto monitor_dump;
  556. } else {
  557. switch (row->state) {
  558. case CAM_SYNC_STATE_INVALID:
  559. case CAM_SYNC_STATE_ACTIVE:
  560. case CAM_SYNC_STATE_SIGNALED_ERROR:
  561. case CAM_SYNC_STATE_SIGNALED_CANCEL:
  562. CAM_ERR(CAM_SYNC,
  563. "Error: Wait on invalid state = %d, obj = %d, name = %s",
  564. row->state, sync_obj, row->name);
  565. rc = -EINVAL;
  566. goto monitor_dump;
  567. case CAM_SYNC_STATE_SIGNALED_SUCCESS:
  568. rc = 0;
  569. break;
  570. default:
  571. rc = -EINVAL;
  572. goto monitor_dump;
  573. }
  574. }
  575. return rc;
  576. monitor_dump:
  577. cam_sync_dump_monitor_array(row);
  578. return rc;
  579. }
  580. static int cam_sync_handle_create(struct cam_private_ioctl_arg *k_ioctl)
  581. {
  582. struct cam_sync_info sync_create;
  583. int result;
  584. if (k_ioctl->size != sizeof(struct cam_sync_info))
  585. return -EINVAL;
  586. if (!k_ioctl->ioctl_ptr)
  587. return -EINVAL;
  588. if (copy_from_user(&sync_create,
  589. u64_to_user_ptr(k_ioctl->ioctl_ptr),
  590. k_ioctl->size))
  591. return -EFAULT;
  592. sync_create.name[SYNC_DEBUG_NAME_LEN] = '\0';
  593. result = cam_sync_create(&sync_create.sync_obj,
  594. sync_create.name);
  595. if (!result)
  596. if (copy_to_user(
  597. u64_to_user_ptr(k_ioctl->ioctl_ptr),
  598. &sync_create,
  599. k_ioctl->size))
  600. return -EFAULT;
  601. return result;
  602. }
  603. static int cam_sync_handle_signal(struct cam_private_ioctl_arg *k_ioctl)
  604. {
  605. int rc;
  606. struct cam_sync_signal sync_signal;
  607. if (k_ioctl->size != sizeof(struct cam_sync_signal))
  608. return -EINVAL;
  609. if (!k_ioctl->ioctl_ptr)
  610. return -EINVAL;
  611. if (copy_from_user(&sync_signal,
  612. u64_to_user_ptr(k_ioctl->ioctl_ptr),
  613. k_ioctl->size))
  614. return -EFAULT;
  615. /* need to get ref for UMD signaled fences */
  616. rc = cam_sync_get_obj_ref(sync_signal.sync_obj);
  617. if (rc) {
  618. CAM_DBG(CAM_SYNC,
  619. "Error: cannot signal an uninitialized sync obj = %d",
  620. sync_signal.sync_obj);
  621. return rc;
  622. }
  623. return cam_sync_signal(sync_signal.sync_obj,
  624. sync_signal.sync_state,
  625. CAM_SYNC_COMMON_SYNC_SIGNAL_EVENT);
  626. }
  627. static int cam_sync_handle_merge(struct cam_private_ioctl_arg *k_ioctl)
  628. {
  629. struct cam_sync_merge sync_merge;
  630. uint32_t *sync_objs;
  631. uint32_t num_objs;
  632. uint32_t size;
  633. int result;
  634. if (k_ioctl->size != sizeof(struct cam_sync_merge))
  635. return -EINVAL;
  636. if (!k_ioctl->ioctl_ptr)
  637. return -EINVAL;
  638. if (copy_from_user(&sync_merge,
  639. u64_to_user_ptr(k_ioctl->ioctl_ptr),
  640. k_ioctl->size))
  641. return -EFAULT;
  642. if (sync_merge.num_objs >= CAM_SYNC_MAX_OBJS)
  643. return -EINVAL;
  644. size = sizeof(uint32_t) * sync_merge.num_objs;
  645. sync_objs = kzalloc(size, GFP_ATOMIC);
  646. if (!sync_objs)
  647. return -ENOMEM;
  648. if (copy_from_user(sync_objs,
  649. u64_to_user_ptr(sync_merge.sync_objs),
  650. sizeof(uint32_t) * sync_merge.num_objs)) {
  651. kfree(sync_objs);
  652. return -EFAULT;
  653. }
  654. num_objs = sync_merge.num_objs;
  655. result = cam_sync_merge(sync_objs,
  656. num_objs,
  657. &sync_merge.merged);
  658. if (!result)
  659. if (copy_to_user(
  660. u64_to_user_ptr(k_ioctl->ioctl_ptr),
  661. &sync_merge,
  662. k_ioctl->size)) {
  663. kfree(sync_objs);
  664. return -EFAULT;
  665. }
  666. kfree(sync_objs);
  667. return result;
  668. }
  669. static int cam_sync_handle_wait(struct cam_private_ioctl_arg *k_ioctl)
  670. {
  671. struct cam_sync_wait sync_wait;
  672. if (k_ioctl->size != sizeof(struct cam_sync_wait))
  673. return -EINVAL;
  674. if (!k_ioctl->ioctl_ptr)
  675. return -EINVAL;
  676. if (copy_from_user(&sync_wait,
  677. u64_to_user_ptr(k_ioctl->ioctl_ptr),
  678. k_ioctl->size))
  679. return -EFAULT;
  680. k_ioctl->result = cam_sync_wait(sync_wait.sync_obj,
  681. sync_wait.timeout_ms);
  682. return 0;
  683. }
  684. static int cam_sync_handle_destroy(struct cam_private_ioctl_arg *k_ioctl)
  685. {
  686. struct cam_sync_info sync_create;
  687. if (k_ioctl->size != sizeof(struct cam_sync_info))
  688. return -EINVAL;
  689. if (!k_ioctl->ioctl_ptr)
  690. return -EINVAL;
  691. if (copy_from_user(&sync_create,
  692. u64_to_user_ptr(k_ioctl->ioctl_ptr),
  693. k_ioctl->size))
  694. return -EFAULT;
  695. return cam_sync_destroy(sync_create.sync_obj);
  696. }
  697. static int cam_sync_handle_register_user_payload(
  698. struct cam_private_ioctl_arg *k_ioctl)
  699. {
  700. struct cam_sync_userpayload_info userpayload_info;
  701. struct sync_user_payload *user_payload_kernel;
  702. struct sync_user_payload *user_payload_iter;
  703. struct sync_user_payload *temp_upayload_kernel;
  704. uint32_t sync_obj;
  705. struct sync_table_row *row = NULL;
  706. if (k_ioctl->size != sizeof(struct cam_sync_userpayload_info))
  707. return -EINVAL;
  708. if (!k_ioctl->ioctl_ptr)
  709. return -EINVAL;
  710. if (copy_from_user(&userpayload_info,
  711. u64_to_user_ptr(k_ioctl->ioctl_ptr),
  712. k_ioctl->size))
  713. return -EFAULT;
  714. sync_obj = userpayload_info.sync_obj;
  715. if ((sync_obj >= CAM_SYNC_MAX_OBJS) || (sync_obj <= 0))
  716. return -EINVAL;
  717. user_payload_kernel = kzalloc(sizeof(*user_payload_kernel), GFP_KERNEL);
  718. if (!user_payload_kernel)
  719. return -ENOMEM;
  720. memcpy(user_payload_kernel->payload_data,
  721. userpayload_info.payload,
  722. CAM_SYNC_PAYLOAD_WORDS * sizeof(__u64));
  723. spin_lock_bh(&sync_dev->row_spinlocks[sync_obj]);
  724. row = sync_dev->sync_table + sync_obj;
  725. if (row->state == CAM_SYNC_STATE_INVALID) {
  726. CAM_ERR(CAM_SYNC,
  727. "Error: accessing an uninitialized sync obj = %s[%d]",
  728. row->name,
  729. sync_obj);
  730. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  731. kfree(user_payload_kernel);
  732. return -EINVAL;
  733. }
  734. if ((row->state == CAM_SYNC_STATE_SIGNALED_SUCCESS) ||
  735. (row->state == CAM_SYNC_STATE_SIGNALED_ERROR) ||
  736. (row->state == CAM_SYNC_STATE_SIGNALED_CANCEL)) {
  737. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNC_OBJ,
  738. &cam_sync_monitor_mask))
  739. cam_generic_fence_update_monitor_array(sync_obj,
  740. &sync_dev->table_lock, sync_dev->mon_data,
  741. CAM_FENCE_OP_SKIP_REGISTER_CB);
  742. cam_sync_util_send_v4l2_event(CAM_SYNC_V4L_EVENT_ID_CB_TRIG,
  743. sync_obj,
  744. row->state,
  745. user_payload_kernel->payload_data,
  746. CAM_SYNC_USER_PAYLOAD_SIZE * sizeof(__u64),
  747. CAM_SYNC_COMMON_REG_PAYLOAD_EVENT);
  748. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  749. kfree(user_payload_kernel);
  750. return 0;
  751. }
  752. list_for_each_entry_safe(user_payload_iter,
  753. temp_upayload_kernel,
  754. &row->user_payload_list,
  755. list) {
  756. if (user_payload_iter->payload_data[0] ==
  757. user_payload_kernel->payload_data[0] &&
  758. user_payload_iter->payload_data[1] ==
  759. user_payload_kernel->payload_data[1]) {
  760. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNC_OBJ,
  761. &cam_sync_monitor_mask))
  762. cam_generic_fence_update_monitor_array(sync_obj,
  763. &sync_dev->table_lock, sync_dev->mon_data,
  764. CAM_FENCE_OP_ALREADY_REGISTERED_CB);
  765. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  766. kfree(user_payload_kernel);
  767. return -EALREADY;
  768. }
  769. }
  770. list_add_tail(&user_payload_kernel->list, &row->user_payload_list);
  771. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNC_OBJ, &cam_sync_monitor_mask))
  772. cam_generic_fence_update_monitor_array(sync_obj,
  773. &sync_dev->table_lock, sync_dev->mon_data,
  774. CAM_FENCE_OP_REGISTER_CB);
  775. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  776. return 0;
  777. }
  778. static int cam_sync_handle_deregister_user_payload(
  779. struct cam_private_ioctl_arg *k_ioctl)
  780. {
  781. struct cam_sync_userpayload_info userpayload_info;
  782. struct sync_user_payload *user_payload_kernel, *temp;
  783. uint32_t sync_obj;
  784. struct sync_table_row *row = NULL;
  785. if (k_ioctl->size != sizeof(struct cam_sync_userpayload_info)) {
  786. CAM_ERR(CAM_SYNC, "Incorrect ioctl size");
  787. return -EINVAL;
  788. }
  789. if (!k_ioctl->ioctl_ptr) {
  790. CAM_ERR(CAM_SYNC, "Invalid embedded ioctl ptr");
  791. return -EINVAL;
  792. }
  793. if (copy_from_user(&userpayload_info,
  794. u64_to_user_ptr(k_ioctl->ioctl_ptr),
  795. k_ioctl->size))
  796. return -EFAULT;
  797. sync_obj = userpayload_info.sync_obj;
  798. if ((sync_obj >= CAM_SYNC_MAX_OBJS) || (sync_obj <= 0))
  799. return -EINVAL;
  800. spin_lock_bh(&sync_dev->row_spinlocks[sync_obj]);
  801. row = sync_dev->sync_table + sync_obj;
  802. if (row->state == CAM_SYNC_STATE_INVALID) {
  803. CAM_ERR(CAM_SYNC,
  804. "Error: accessing an uninitialized sync obj = %s[%d]",
  805. row->name,
  806. sync_obj);
  807. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  808. return -EINVAL;
  809. }
  810. list_for_each_entry_safe(user_payload_kernel, temp,
  811. &row->user_payload_list, list) {
  812. if (user_payload_kernel->payload_data[0] ==
  813. userpayload_info.payload[0] &&
  814. user_payload_kernel->payload_data[1] ==
  815. userpayload_info.payload[1]) {
  816. list_del_init(&user_payload_kernel->list);
  817. kfree(user_payload_kernel);
  818. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNC_OBJ,
  819. &cam_sync_monitor_mask))
  820. cam_generic_fence_update_monitor_array(sync_obj,
  821. &sync_dev->table_lock, sync_dev->mon_data,
  822. CAM_FENCE_OP_UNREGISTER_CB);
  823. }
  824. }
  825. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  826. return 0;
  827. }
  828. static int cam_sync_dma_fence_cb(
  829. int32_t sync_obj,
  830. struct cam_dma_fence_signal_sync_obj *signal_sync_obj)
  831. {
  832. int32_t rc;
  833. int32_t status = CAM_SYNC_STATE_SIGNALED_SUCCESS;
  834. struct sync_table_row *row = NULL;
  835. struct list_head parents_list;
  836. if (!signal_sync_obj) {
  837. CAM_ERR(CAM_SYNC, "Invalid signal info args");
  838. return -EINVAL;
  839. }
  840. /* Validate sync object range */
  841. if (!((sync_obj > 0) && (sync_obj < CAM_SYNC_MAX_OBJS))) {
  842. CAM_ERR(CAM_SYNC, "Invalid sync obj: %d", sync_obj);
  843. return -EINVAL;
  844. }
  845. spin_lock_bh(&sync_dev->row_spinlocks[sync_obj]);
  846. row = sync_dev->sync_table + sync_obj;
  847. /* Validate if sync obj has a dma fence association */
  848. if (!test_bit(CAM_GENERIC_FENCE_TYPE_DMA_FENCE, &row->ext_fence_mask)) {
  849. CAM_ERR(CAM_SYNC,
  850. "sync obj = %d[%s] has no associated dma fence ext_fence_mask = 0x%x",
  851. sync_obj, row->name, row->ext_fence_mask);
  852. rc = -EINVAL;
  853. goto end;
  854. }
  855. /* Validate if we are signaling the right sync obj based on dma fence fd */
  856. if (row->dma_fence_info.dma_fence_fd != signal_sync_obj->fd) {
  857. CAM_ERR(CAM_SYNC,
  858. "sync obj: %d[%s] is associated with a different fd: %d, signaling for fd: %d",
  859. sync_obj, row->name, row->dma_fence_info.dma_fence_fd, signal_sync_obj->fd);
  860. rc = -EINVAL;
  861. goto end;
  862. }
  863. /* Check for error status */
  864. if (signal_sync_obj->status < 0) {
  865. if (signal_sync_obj->status == -ECANCELED)
  866. status = CAM_SYNC_STATE_SIGNALED_CANCEL;
  867. else
  868. status = CAM_SYNC_STATE_SIGNALED_ERROR;
  869. }
  870. rc = cam_sync_signal_validate_util(sync_obj, status);
  871. if (rc) {
  872. CAM_ERR(CAM_SYNC,
  873. "Error: Failed to validate signal info for sync_obj = %d[%s] with status = %d rc = %d",
  874. sync_obj, row->name, status, rc);
  875. goto end;
  876. }
  877. /* Adding dma fence reference on sync */
  878. atomic_inc(&row->ref_cnt);
  879. if (!atomic_dec_and_test(&row->ref_cnt))
  880. goto end;
  881. row->state = status;
  882. cam_sync_util_dispatch_signaled_cb(sync_obj, status, 0);
  883. INIT_LIST_HEAD(&parents_list);
  884. list_splice_init(&row->parents_list, &parents_list);
  885. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  886. if (list_empty(&parents_list))
  887. return 0;
  888. cam_sync_signal_parent_util(status, 0x0, &parents_list);
  889. return 0;
  890. end:
  891. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  892. return rc;
  893. }
  894. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  895. static int cam_sync_synx_obj_cb(int32_t sync_obj,
  896. struct cam_synx_obj_signal_sync_obj *signal_sync_obj)
  897. {
  898. int32_t rc;
  899. struct sync_table_row *row = NULL;
  900. struct list_head parents_list;
  901. if (!signal_sync_obj) {
  902. CAM_ERR(CAM_SYNC, "Invalid signal info args");
  903. return -EINVAL;
  904. }
  905. /* Validate sync object range */
  906. if (!((sync_obj > 0) && (sync_obj < CAM_SYNC_MAX_OBJS))) {
  907. CAM_ERR(CAM_SYNC, "Invalid sync obj: %d", sync_obj);
  908. return -EINVAL;
  909. }
  910. spin_lock_bh(&sync_dev->row_spinlocks[sync_obj]);
  911. row = sync_dev->sync_table + sync_obj;
  912. /* Validate if sync obj has a synx obj association */
  913. if (!test_bit(CAM_GENERIC_FENCE_TYPE_SYNX_OBJ, &row->ext_fence_mask)) {
  914. CAM_ERR(CAM_SYNC,
  915. "sync obj = %d[%s] has no associated synx obj ext_fence_mask = 0x%x",
  916. sync_obj, row->name, row->ext_fence_mask);
  917. rc = -EINVAL;
  918. goto end;
  919. }
  920. /* Validate if we are signaling the right sync obj based on synx handle */
  921. if (row->synx_obj_info.synx_obj != signal_sync_obj->synx_obj) {
  922. CAM_ERR(CAM_SYNC,
  923. "sync obj: %d[%s] is associated with a different synx obj: %d, signaling for synx obj: %d",
  924. sync_obj, row->name, row->synx_obj_info.synx_obj,
  925. signal_sync_obj->synx_obj);
  926. rc = -EINVAL;
  927. goto end;
  928. }
  929. rc = cam_sync_signal_validate_util(sync_obj, signal_sync_obj->status);
  930. if (rc) {
  931. CAM_ERR(CAM_SYNC,
  932. "Error: Failed to validate signal info for sync_obj = %d[%s] with status = %d rc = %d",
  933. sync_obj, row->name, signal_sync_obj->status, rc);
  934. goto end;
  935. }
  936. /* Adding synx reference on sync */
  937. atomic_inc(&row->ref_cnt);
  938. if (!atomic_dec_and_test(&row->ref_cnt)) {
  939. CAM_DBG(CAM_SYNC, "Sync = %d[%s] fence still has references, synx_hdl = %d",
  940. sync_obj, row->name, signal_sync_obj->synx_obj);
  941. goto end;
  942. }
  943. row->state = signal_sync_obj->status;
  944. cam_sync_util_dispatch_signaled_cb(sync_obj, signal_sync_obj->status, 0);
  945. INIT_LIST_HEAD(&parents_list);
  946. list_splice_init(&row->parents_list, &parents_list);
  947. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  948. if (list_empty(&parents_list))
  949. return 0;
  950. cam_sync_signal_parent_util(signal_sync_obj->status, 0x0, &parents_list);
  951. CAM_DBG(CAM_SYNC,
  952. "Successfully signaled sync obj = %d with status = %d via synx obj = %d signal callback",
  953. sync_obj, signal_sync_obj->status, signal_sync_obj->synx_obj);
  954. return 0;
  955. end:
  956. spin_unlock_bh(&sync_dev->row_spinlocks[sync_obj]);
  957. return rc;
  958. }
  959. #endif
  960. static int cam_generic_fence_alloc_validate_input_info_util(
  961. struct cam_generic_fence_cmd_args *fence_cmd_args,
  962. struct cam_generic_fence_input_info **fence_input_info)
  963. {
  964. int rc = 0;
  965. struct cam_generic_fence_input_info *fence_input = NULL;
  966. uint32_t num_fences;
  967. size_t expected_size;
  968. *fence_input_info = NULL;
  969. if (fence_cmd_args->input_data_size !=
  970. sizeof(struct cam_generic_fence_input_info)) {
  971. CAM_ERR(CAM_SYNC, "Size is invalid expected: 0x%llx actual: 0x%llx",
  972. sizeof(struct cam_generic_fence_input_info),
  973. fence_cmd_args->input_data_size);
  974. return -EINVAL;
  975. }
  976. fence_input = memdup_user(u64_to_user_ptr(fence_cmd_args->input_handle),
  977. fence_cmd_args->input_data_size);
  978. if (IS_ERR_OR_NULL(fence_input)) {
  979. CAM_ERR(CAM_SYNC, "memdup failed for hdl: %d size: 0x%x",
  980. fence_cmd_args->input_handle, fence_cmd_args->input_data_size);
  981. return -ENOMEM;
  982. }
  983. /* Validate num fences */
  984. num_fences = fence_input->num_fences_requested;
  985. if ((num_fences == 0) || (num_fences > CAM_GENERIC_FENCE_BATCH_MAX)) {
  986. CAM_ERR(CAM_SYNC, "Invalid number of fences: %u for batching",
  987. num_fences);
  988. rc = -EINVAL;
  989. goto free_mem;
  990. }
  991. /* Validate sizes */
  992. expected_size = sizeof(struct cam_generic_fence_input_info) +
  993. ((num_fences - 1) * sizeof(struct cam_generic_fence_config));
  994. if ((uint32_t)expected_size != fence_cmd_args->input_data_size) {
  995. CAM_ERR(CAM_SYNC, "Invalid input size expected: 0x%x actual: 0x%x for fences: %u",
  996. expected_size, fence_cmd_args->input_data_size, num_fences);
  997. rc = -EINVAL;
  998. goto free_mem;
  999. }
  1000. *fence_input_info = fence_input;
  1001. return rc;
  1002. free_mem:
  1003. kfree(fence_input);
  1004. return rc;
  1005. }
  1006. static void cam_generic_fence_free_input_info_util(
  1007. struct cam_generic_fence_input_info **fence_input_info)
  1008. {
  1009. struct cam_generic_fence_input_info *fence_input = *fence_input_info;
  1010. kfree(fence_input);
  1011. *fence_input_info = NULL;
  1012. }
  1013. static int cam_generic_fence_handle_dma_create(
  1014. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1015. {
  1016. int rc, i, dma_fence_row_idx;
  1017. struct cam_generic_fence_input_info *fence_input_info = NULL;
  1018. struct cam_generic_fence_config *fence_cfg = NULL;
  1019. rc = cam_generic_fence_alloc_validate_input_info_util(fence_cmd_args, &fence_input_info);
  1020. if (rc || !fence_input_info) {
  1021. CAM_ERR(CAM_DMA_FENCE,
  1022. "Fence input info validation failed rc: %d fence_input_info: %pK",
  1023. rc, fence_input_info);
  1024. return -EINVAL;
  1025. }
  1026. for (i = 0; i < fence_input_info->num_fences_requested; i++) {
  1027. fence_cfg = &fence_input_info->fence_cfg[i];
  1028. fence_input_info->num_fences_processed++;
  1029. fence_cfg->reason_code = 0;
  1030. rc = cam_dma_fence_create_fd(&fence_cfg->dma_fence_fd,
  1031. &dma_fence_row_idx, fence_cfg->name);
  1032. if (rc) {
  1033. CAM_ERR(CAM_DMA_FENCE,
  1034. "Failed to create dma fence at index: %d rc: %d num fences [requested: %u processed: %u]",
  1035. i, rc, fence_input_info->num_fences_requested,
  1036. fence_input_info->num_fences_processed);
  1037. fence_cfg->reason_code = rc;
  1038. goto out_copy;
  1039. }
  1040. CAM_DBG(CAM_DMA_FENCE,
  1041. "Created dma_fence @ i: %d fence fd: %d[%s] num fences [requested: %u processed: %u] ",
  1042. i, fence_cfg->dma_fence_fd, fence_cfg->name,
  1043. fence_input_info->num_fences_requested,
  1044. fence_input_info->num_fences_processed);
  1045. }
  1046. out_copy:
  1047. if (copy_to_user(u64_to_user_ptr(fence_cmd_args->input_handle),
  1048. fence_input_info, fence_cmd_args->input_data_size)) {
  1049. CAM_ERR(CAM_DMA_FENCE, "copy to user failed hdl: %d size: 0x%x",
  1050. fence_cmd_args->input_handle, fence_cmd_args->input_data_size);
  1051. rc = -EFAULT;
  1052. }
  1053. cam_generic_fence_free_input_info_util(&fence_input_info);
  1054. return rc;
  1055. }
  1056. static int cam_generic_fence_handle_dma_release(
  1057. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1058. {
  1059. int rc, i;
  1060. bool failed = false;
  1061. struct cam_dma_fence_release_params release_params;
  1062. struct cam_generic_fence_input_info *fence_input_info = NULL;
  1063. struct cam_generic_fence_config *fence_cfg = NULL;
  1064. rc = cam_generic_fence_alloc_validate_input_info_util(fence_cmd_args, &fence_input_info);
  1065. if (rc || !fence_input_info) {
  1066. CAM_ERR(CAM_DMA_FENCE,
  1067. "Fence input info validation failed rc: %d fence_input_info: %pK",
  1068. rc, fence_input_info);
  1069. return -EINVAL;
  1070. }
  1071. for (i = 0; i < fence_input_info->num_fences_requested; i++) {
  1072. fence_cfg = &fence_input_info->fence_cfg[i];
  1073. fence_input_info->num_fences_processed++;
  1074. fence_cfg->reason_code = 0;
  1075. release_params.use_row_idx = false;
  1076. release_params.u.dma_fence_fd = fence_cfg->dma_fence_fd;
  1077. rc = cam_dma_fence_release(&release_params);
  1078. if (rc) {
  1079. CAM_ERR(CAM_DMA_FENCE,
  1080. "Failed to destroy dma fence at index: %d fd: %d rc: %d num fences [requested: %u processed: %u]",
  1081. i, fence_cfg->dma_fence_fd, rc,
  1082. fence_input_info->num_fences_requested,
  1083. fence_input_info->num_fences_processed);
  1084. fence_cfg->reason_code = rc;
  1085. /* Continue to release other fences, but mark the call as failed */
  1086. failed = true;
  1087. continue;
  1088. }
  1089. CAM_DBG(CAM_DMA_FENCE,
  1090. "Released dma_fence @ i: %d fd: %d num fences [requested: %u processed: %u]",
  1091. i, fence_cfg->dma_fence_fd,
  1092. fence_input_info->num_fences_requested,
  1093. fence_input_info->num_fences_processed);
  1094. }
  1095. if (failed)
  1096. rc = -ENOMSG;
  1097. if (copy_to_user(u64_to_user_ptr(fence_cmd_args->input_handle),
  1098. fence_input_info, fence_cmd_args->input_data_size)) {
  1099. CAM_ERR(CAM_DMA_FENCE, "copy to user failed hdl: %d size: 0x%x",
  1100. fence_cmd_args->input_handle, fence_cmd_args->input_data_size);
  1101. rc = -EFAULT;
  1102. }
  1103. cam_generic_fence_free_input_info_util(&fence_input_info);
  1104. return rc;
  1105. }
  1106. static int cam_generic_fence_handle_dma_import(
  1107. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1108. {
  1109. int32_t rc, i, dma_fence_row_idx;
  1110. struct dma_fence *fence = NULL;
  1111. struct cam_dma_fence_create_sync_obj_payload dma_sync_create;
  1112. struct cam_generic_fence_input_info *fence_input_info = NULL;
  1113. struct cam_generic_fence_config *fence_cfg = NULL;
  1114. rc = cam_generic_fence_alloc_validate_input_info_util(fence_cmd_args, &fence_input_info);
  1115. if (rc || !fence_input_info) {
  1116. CAM_ERR(CAM_DMA_FENCE,
  1117. "Fence input info validation failed rc: %d fence_input_info: %pK",
  1118. rc, fence_input_info);
  1119. return -EINVAL;
  1120. }
  1121. for (i = 0; i < fence_input_info->num_fences_requested; i++) {
  1122. fence_cfg = &fence_input_info->fence_cfg[i];
  1123. fence_input_info->num_fences_processed++;
  1124. fence_cfg->reason_code = 0;
  1125. /* Check if fd is for a valid dma fence */
  1126. fence = cam_dma_fence_get_fence_from_fd(fence_cfg->dma_fence_fd,
  1127. &dma_fence_row_idx);
  1128. if (IS_ERR_OR_NULL(fence)) {
  1129. CAM_ERR(CAM_DMA_FENCE,
  1130. "Invalid dma fence for fd: %d", fence_cfg->dma_fence_fd);
  1131. fence_cfg->reason_code = -EINVAL;
  1132. goto out_copy;
  1133. }
  1134. dma_sync_create.dma_fence_row_idx = dma_fence_row_idx;
  1135. dma_sync_create.fd = fence_cfg->dma_fence_fd;
  1136. dma_sync_create.sync_created_with_dma = false;
  1137. /* Create new sync object and associate dma fence */
  1138. rc = cam_sync_create_util(&fence_cfg->sync_obj, fence_cfg->name,
  1139. &dma_sync_create, NULL);
  1140. if (rc) {
  1141. fence_cfg->reason_code = rc;
  1142. /* put on the import refcnt */
  1143. cam_dma_fence_get_put_ref(false, dma_fence_row_idx);
  1144. goto out_copy;
  1145. }
  1146. /* Register a cb for dma fence */
  1147. rc = cam_dma_fence_register_cb(&fence_cfg->sync_obj,
  1148. &dma_fence_row_idx, cam_sync_dma_fence_cb);
  1149. if (rc) {
  1150. CAM_ERR(CAM_DMA_FENCE,
  1151. "Failed to register cb for dma fence fd: %d sync_obj: %d rc: %d",
  1152. fence_cfg->dma_fence_fd, fence_cfg->sync_obj, rc);
  1153. cam_sync_deinit_object(sync_dev->sync_table, fence_cfg->sync_obj,
  1154. NULL, NULL);
  1155. fence_cfg->reason_code = rc;
  1156. goto out_copy;
  1157. }
  1158. CAM_DBG(CAM_DMA_FENCE,
  1159. "dma fence fd = %d imported for sync_obj = %d[%s] num fences [requested: %u processed: %u]",
  1160. fence_cfg->dma_fence_fd, fence_cfg->sync_obj, fence_cfg->name,
  1161. fence_input_info->num_fences_requested,
  1162. fence_input_info->num_fences_processed);
  1163. }
  1164. out_copy:
  1165. if (copy_to_user(u64_to_user_ptr(fence_cmd_args->input_handle),
  1166. fence_input_info, fence_cmd_args->input_data_size)) {
  1167. rc = -EFAULT;
  1168. CAM_ERR(CAM_DMA_FENCE, "copy to user failed hdl: %d size: 0x%x",
  1169. fence_cmd_args->input_handle, fence_cmd_args->input_data_size);
  1170. }
  1171. cam_generic_fence_free_input_info_util(&fence_input_info);
  1172. return rc;
  1173. }
  1174. static int cam_generic_fence_handle_dma_signal(
  1175. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1176. {
  1177. struct cam_dma_fence_signal signal_dma_fence;
  1178. if (fence_cmd_args->input_data_size != sizeof(struct cam_dma_fence_signal)) {
  1179. CAM_ERR(CAM_DMA_FENCE, "Size is invalid expected: 0x%llx actual: 0x%llx",
  1180. sizeof(struct cam_dma_fence_signal),
  1181. fence_cmd_args->input_data_size);
  1182. return -EINVAL;
  1183. }
  1184. if (copy_from_user(&signal_dma_fence, (void __user *)fence_cmd_args->input_handle,
  1185. fence_cmd_args->input_data_size))
  1186. return -EFAULT;
  1187. return cam_dma_fence_signal_fd(&signal_dma_fence);
  1188. }
  1189. static int cam_generic_fence_process_dma_fence_cmd(
  1190. uint32_t id,
  1191. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1192. {
  1193. int rc = -EINVAL;
  1194. switch (id) {
  1195. case CAM_GENERIC_FENCE_CREATE:
  1196. rc = cam_generic_fence_handle_dma_create(fence_cmd_args);
  1197. break;
  1198. case CAM_GENERIC_FENCE_RELEASE:
  1199. rc = cam_generic_fence_handle_dma_release(fence_cmd_args);
  1200. break;
  1201. case CAM_GENERIC_FENCE_IMPORT:
  1202. rc = cam_generic_fence_handle_dma_import(fence_cmd_args);
  1203. break;
  1204. case CAM_GENERIC_FENCE_SIGNAL:
  1205. rc = cam_generic_fence_handle_dma_signal(fence_cmd_args);
  1206. break;
  1207. default:
  1208. CAM_ERR(CAM_DMA_FENCE, "IOCTL cmd: %u not supported for dma fence", id);
  1209. break;
  1210. }
  1211. return rc;
  1212. }
  1213. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  1214. static int cam_generic_fence_validate_signal_input_info_util(
  1215. int32_t fence_type,
  1216. struct cam_generic_fence_cmd_args *fence_cmd_args,
  1217. struct cam_generic_fence_signal_info **fence_signal_info,
  1218. void **fence_signal_data)
  1219. {
  1220. int rc = 0;
  1221. struct cam_generic_fence_signal_info *signal_info = NULL;
  1222. void *signal_data;
  1223. uint32_t num_fences;
  1224. size_t expected_size;
  1225. *fence_signal_info = NULL;
  1226. *fence_signal_data = NULL;
  1227. if (fence_cmd_args->input_data_size !=
  1228. sizeof(struct cam_generic_fence_signal_info)) {
  1229. CAM_ERR(CAM_SYNC, "Size is invalid expected: 0x%llx actual: 0x%llx",
  1230. sizeof(struct cam_generic_fence_signal_info),
  1231. fence_cmd_args->input_data_size);
  1232. return -EINVAL;
  1233. }
  1234. signal_info = memdup_user(u64_to_user_ptr(fence_cmd_args->input_handle),
  1235. fence_cmd_args->input_data_size);
  1236. if (IS_ERR_OR_NULL(signal_info)) {
  1237. CAM_ERR(CAM_SYNC, "memdup failed for hdl: %d size: 0x%x",
  1238. fence_cmd_args->input_handle, fence_cmd_args->input_data_size);
  1239. return -ENOMEM;
  1240. }
  1241. /* Validate num fences */
  1242. num_fences = signal_info->num_fences_requested;
  1243. if ((num_fences == 0) || (num_fences > CAM_GENERIC_FENCE_BATCH_MAX)) {
  1244. CAM_ERR(CAM_SYNC, "Invalid number of fences: %u for batching",
  1245. num_fences);
  1246. rc = -EINVAL;
  1247. goto free_mem;
  1248. }
  1249. if (signal_info->fence_handle_type != CAM_HANDLE_USER_POINTER) {
  1250. CAM_ERR(CAM_SYNC, "Invalid signal handle type: %d",
  1251. signal_info->fence_handle_type);
  1252. rc = -EINVAL;
  1253. goto free_mem;
  1254. }
  1255. /* Validate sizes */
  1256. switch (fence_type) {
  1257. case CAM_GENERIC_FENCE_TYPE_SYNC_OBJ:
  1258. expected_size = sizeof(struct cam_sync_signal);
  1259. break;
  1260. case CAM_GENERIC_FENCE_TYPE_SYNX_OBJ:
  1261. expected_size = sizeof(struct cam_synx_obj_signal);
  1262. break;
  1263. case CAM_GENERIC_FENCE_TYPE_DMA_FENCE:
  1264. expected_size = sizeof(struct cam_dma_fence_signal);
  1265. break;
  1266. default:
  1267. CAM_ERR(CAM_SYNC, "Unsupported fence type: %u", fence_type);
  1268. rc = -EINVAL;
  1269. goto free_mem;
  1270. }
  1271. if ((signal_info->fence_data_size) != (expected_size * num_fences)) {
  1272. CAM_ERR(CAM_SYNC, "Invalid input size expected: 0x%x actual: 0x%x for fences: %u",
  1273. (expected_size * num_fences), signal_info->fence_data_size, num_fences);
  1274. rc = -EINVAL;
  1275. goto free_mem;
  1276. }
  1277. signal_data = memdup_user(u64_to_user_ptr(signal_info->fence_info_hdl),
  1278. signal_info->fence_data_size);
  1279. if (IS_ERR_OR_NULL(signal_data)) {
  1280. CAM_ERR(CAM_SYNC, "memdup failed for hdl: %d size: 0x%x",
  1281. signal_info->fence_info_hdl, signal_info->fence_data_size);
  1282. rc = -ENOMEM;
  1283. goto free_mem;
  1284. }
  1285. *fence_signal_info = signal_info;
  1286. *fence_signal_data = signal_data;
  1287. return rc;
  1288. free_mem:
  1289. kfree(signal_info);
  1290. return rc;
  1291. }
  1292. static void cam_generic_fence_free_signal_input_info_util(
  1293. struct cam_generic_fence_signal_info **fence_signal_info,
  1294. void **fence_signal_data)
  1295. {
  1296. void *signal_data = *fence_signal_data;
  1297. struct cam_generic_fence_signal_info *fence_input = *fence_signal_info;
  1298. kfree(signal_data);
  1299. kfree(fence_input);
  1300. *fence_signal_info = NULL;
  1301. *fence_signal_data = NULL;
  1302. }
  1303. static int cam_generic_fence_config_parse_params(
  1304. struct cam_generic_fence_config *fence_cfg,
  1305. int32_t requested_param_mask, int32_t *result)
  1306. {
  1307. uint32_t index = 0, num_entries;
  1308. if (!result) {
  1309. CAM_ERR(CAM_SYNC, "Invalid result hdl : %p", result);
  1310. return -EINVAL;
  1311. }
  1312. /* Assign to 0 by default */
  1313. *result = 0;
  1314. if (!fence_cfg->num_valid_params || !requested_param_mask) {
  1315. CAM_DBG(CAM_SYNC,
  1316. "No params configured num_valid = %d requested_mask = 0x%x",
  1317. fence_cfg->num_valid_params, requested_param_mask);
  1318. return 0;
  1319. }
  1320. if (!(fence_cfg->valid_param_mask & requested_param_mask)) {
  1321. CAM_DBG(CAM_SYNC,
  1322. "Requested parameter not set in additional param mask expecting: 0x%x actual: 0x%x",
  1323. requested_param_mask, fence_cfg->valid_param_mask);
  1324. return 0;
  1325. }
  1326. index = ffs(requested_param_mask) - 1;
  1327. num_entries = ARRAY_SIZE(fence_cfg->params);
  1328. if (index >= num_entries) {
  1329. CAM_DBG(CAM_SYNC,
  1330. "Obtained index %u from mask: 0x%x num_param_entries: %u, index exceeding max",
  1331. index, requested_param_mask, num_entries);
  1332. return 0;
  1333. }
  1334. *result = fence_cfg->params[index];
  1335. return 0;
  1336. }
  1337. static int cam_generic_fence_handle_synx_create(
  1338. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1339. {
  1340. int rc, i;
  1341. int32_t row_idx, fence_flag;
  1342. struct cam_generic_fence_input_info *fence_input_info = NULL;
  1343. struct cam_generic_fence_config *fence_cfg = NULL;
  1344. rc = cam_generic_fence_alloc_validate_input_info_util(fence_cmd_args, &fence_input_info);
  1345. if (rc || !fence_input_info) {
  1346. CAM_ERR(CAM_SYNX,
  1347. "Fence input info validation failed rc: %d fence_input_info: %pK",
  1348. rc, fence_input_info);
  1349. return -EINVAL;
  1350. }
  1351. for (i = 0; i < fence_input_info->num_fences_requested; i++) {
  1352. fence_cfg = &fence_input_info->fence_cfg[i];
  1353. fence_input_info->num_fences_processed++;
  1354. fence_cfg->reason_code = 0;
  1355. fence_flag = 0;
  1356. cam_generic_fence_config_parse_params(fence_cfg,
  1357. CAM_GENERIC_FENCE_CONFIG_FLAG_PARAM_INDEX, &fence_flag);
  1358. rc = cam_synx_obj_create(fence_cfg->name,
  1359. fence_flag, &fence_cfg->synx_obj, &row_idx);
  1360. if (rc) {
  1361. CAM_ERR(CAM_SYNX,
  1362. "Failed to create synx fence at index: %d rc: %d num fences [requested: %u processed: %u]",
  1363. i, rc, fence_input_info->num_fences_requested,
  1364. fence_input_info->num_fences_processed);
  1365. fence_cfg->reason_code = rc;
  1366. goto out_copy;
  1367. }
  1368. CAM_DBG(CAM_SYNX,
  1369. "Created synx fence @ i: %d synx_obj: %d[%s] num fences [requested: %u processed: %u] ",
  1370. i, fence_cfg->synx_obj, fence_cfg->name,
  1371. fence_input_info->num_fences_requested,
  1372. fence_input_info->num_fences_processed);
  1373. }
  1374. out_copy:
  1375. if (copy_to_user(u64_to_user_ptr(fence_cmd_args->input_handle),
  1376. fence_input_info, fence_cmd_args->input_data_size)) {
  1377. CAM_ERR(CAM_SYNX, "copy to user failed hdl: %d size: 0x%x",
  1378. fence_cmd_args->input_handle, fence_cmd_args->input_data_size);
  1379. rc = -EFAULT;
  1380. }
  1381. cam_generic_fence_free_input_info_util(&fence_input_info);
  1382. return rc;
  1383. }
  1384. static int cam_generic_fence_handle_synx_release(
  1385. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1386. {
  1387. int rc, i;
  1388. bool failed = false;
  1389. struct cam_generic_fence_input_info *fence_input_info = NULL;
  1390. struct cam_generic_fence_config *fence_cfg = NULL;
  1391. struct cam_synx_obj_release_params synx_release_params;
  1392. rc = cam_generic_fence_alloc_validate_input_info_util(fence_cmd_args, &fence_input_info);
  1393. if (rc || !fence_input_info) {
  1394. CAM_ERR(CAM_SYNX,
  1395. "Fence input info validation failed rc: %d fence_input_info: %pK",
  1396. rc, fence_input_info);
  1397. return -EINVAL;
  1398. }
  1399. for (i = 0; i < fence_input_info->num_fences_requested; i++) {
  1400. fence_cfg = &fence_input_info->fence_cfg[i];
  1401. fence_input_info->num_fences_processed++;
  1402. fence_cfg->reason_code = 0;
  1403. synx_release_params.use_row_idx = false;
  1404. synx_release_params.u.synx_obj = fence_cfg->synx_obj;
  1405. rc = cam_synx_obj_release(&synx_release_params);
  1406. if (rc) {
  1407. CAM_ERR(CAM_SYNX,
  1408. "Failed to release synx object at index: %d rc: %d num fences [requested: %u processed: %u]",
  1409. i, rc, fence_input_info->num_fences_requested,
  1410. fence_input_info->num_fences_processed);
  1411. fence_cfg->reason_code = rc;
  1412. /* Continue to release other fences, but mark the call as failed */
  1413. failed = true;
  1414. continue;
  1415. }
  1416. CAM_DBG(CAM_SYNX,
  1417. "Released synx object @ i: %d handle: %d num fences [requested: %u processed: %u]",
  1418. i, fence_cfg->synx_obj,
  1419. fence_input_info->num_fences_requested,
  1420. fence_input_info->num_fences_processed);
  1421. }
  1422. if (failed)
  1423. rc = -ENOMSG;
  1424. if (copy_to_user(u64_to_user_ptr(fence_cmd_args->input_handle),
  1425. fence_input_info, fence_cmd_args->input_data_size)) {
  1426. CAM_ERR(CAM_SYNX, "copy to user failed hdl: %d size: 0x%x",
  1427. fence_cmd_args->input_handle, fence_cmd_args->input_data_size);
  1428. rc = -EFAULT;
  1429. }
  1430. cam_generic_fence_free_input_info_util(&fence_input_info);
  1431. return rc;
  1432. }
  1433. static int cam_sync_synx_associate_obj(int32_t sync_obj, uint32_t synx_obj,
  1434. int32_t synx_obj_row_idx, bool *is_sync_obj_signaled)
  1435. {
  1436. int rc;
  1437. struct sync_table_row *row = NULL;
  1438. struct cam_synx_obj_signal signal_synx_obj;
  1439. rc = cam_sync_check_valid(sync_obj);
  1440. if (rc)
  1441. return rc;
  1442. row = sync_dev->sync_table + sync_obj;
  1443. spin_lock(&sync_dev->row_spinlocks[sync_obj]);
  1444. if (row->state != CAM_SYNC_STATE_ACTIVE) {
  1445. signal_synx_obj.status = row->state;
  1446. signal_synx_obj.synx_obj = synx_obj;
  1447. *is_sync_obj_signaled = true;
  1448. goto signal_synx;
  1449. } else {
  1450. row->synx_obj_info.synx_obj_row_idx = synx_obj_row_idx;
  1451. row->synx_obj_info.sync_created_with_synx = false;
  1452. row->synx_obj_info.synx_obj = synx_obj;
  1453. set_bit(CAM_GENERIC_FENCE_TYPE_SYNX_OBJ, &row->ext_fence_mask);
  1454. CAM_DBG(CAM_SYNX, "sync_obj: %s[%d] associated with synx_obj: %d",
  1455. row->name, sync_obj, row->synx_obj_info.synx_obj);
  1456. }
  1457. spin_unlock(&sync_dev->row_spinlocks[sync_obj]);
  1458. return rc;
  1459. signal_synx:
  1460. spin_unlock(&sync_dev->row_spinlocks[sync_obj]);
  1461. return cam_synx_obj_signal_obj(&signal_synx_obj);
  1462. }
  1463. static int cam_generic_fence_handle_synx_import(
  1464. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1465. {
  1466. int32_t rc, i, synx_obj_row_idx;
  1467. struct sync_synx_obj_info synx_sync_create;
  1468. struct cam_generic_fence_input_info *fence_input_info = NULL;
  1469. struct cam_generic_fence_config *fence_cfg = NULL;
  1470. bool is_sync_obj_signaled = false;
  1471. bool is_sync_obj_created = false;
  1472. rc = cam_generic_fence_alloc_validate_input_info_util(fence_cmd_args, &fence_input_info);
  1473. if (rc || !fence_input_info) {
  1474. CAM_ERR(CAM_SYNX,
  1475. "Fence input info validation failed rc: %d fence_input_info: %pK",
  1476. rc, fence_input_info);
  1477. return -EINVAL;
  1478. }
  1479. for (i = 0; i < fence_input_info->num_fences_requested; i++) {
  1480. fence_cfg = &fence_input_info->fence_cfg[i];
  1481. fence_input_info->num_fences_processed++;
  1482. fence_cfg->reason_code = 0;
  1483. is_sync_obj_signaled = false;
  1484. is_sync_obj_created = false;
  1485. /* Check if synx handle is for a valid synx obj */
  1486. rc = cam_synx_obj_find_obj_in_table(fence_cfg->synx_obj,
  1487. &synx_obj_row_idx);
  1488. if (rc) {
  1489. CAM_ERR(CAM_SYNX,
  1490. "Invalid synx obj for handle: %d", fence_cfg->synx_obj);
  1491. fence_cfg->reason_code = -EINVAL;
  1492. goto out_copy;
  1493. }
  1494. if ((fence_cfg->sync_obj > 0) && (fence_cfg->sync_obj < CAM_SYNC_MAX_OBJS)) {
  1495. /* Associate synx object with existing sync object */
  1496. rc = cam_sync_synx_associate_obj(fence_cfg->sync_obj,
  1497. fence_cfg->synx_obj, synx_obj_row_idx,
  1498. &is_sync_obj_signaled);
  1499. } else {
  1500. /* Create new sync object and associate synx object */
  1501. synx_sync_create.sync_created_with_synx = false;
  1502. synx_sync_create.synx_obj = fence_cfg->synx_obj;
  1503. synx_sync_create.synx_obj_row_idx = synx_obj_row_idx;
  1504. rc = cam_sync_create_util(&fence_cfg->sync_obj, fence_cfg->name,
  1505. NULL, &synx_sync_create);
  1506. is_sync_obj_created = true;
  1507. }
  1508. if (rc) {
  1509. fence_cfg->reason_code = rc;
  1510. goto out_copy;
  1511. }
  1512. if (!is_sync_obj_signaled) {
  1513. /* Register a cb for synx_obj */
  1514. rc = cam_synx_obj_register_cb(&fence_cfg->sync_obj,
  1515. synx_obj_row_idx, cam_sync_synx_obj_cb);
  1516. if (rc) {
  1517. CAM_ERR(CAM_SYNX,
  1518. "Failed to register cb for synx_obj: %d sync_obj: %d rc: %d",
  1519. fence_cfg->synx_obj, fence_cfg->sync_obj, rc);
  1520. if (is_sync_obj_created)
  1521. cam_sync_deinit_object(sync_dev->sync_table,
  1522. fence_cfg->sync_obj, NULL, NULL);
  1523. fence_cfg->reason_code = rc;
  1524. goto out_copy;
  1525. }
  1526. }
  1527. CAM_DBG(CAM_SYNX,
  1528. "synx_obj handle = %d imported for dma fence fd: %d sync_obj = %d[%s] num fences [requested: %u processed: %u]",
  1529. fence_cfg->synx_obj, fence_cfg->dma_fence_fd,
  1530. fence_cfg->sync_obj, fence_cfg->name,
  1531. fence_input_info->num_fences_requested,
  1532. fence_input_info->num_fences_processed);
  1533. }
  1534. out_copy:
  1535. if (copy_to_user(u64_to_user_ptr(fence_cmd_args->input_handle),
  1536. fence_input_info, fence_cmd_args->input_data_size)) {
  1537. rc = -EFAULT;
  1538. CAM_ERR(CAM_SYNX, "copy to user failed hdl: %d size: 0x%x",
  1539. fence_cmd_args->input_handle, fence_cmd_args->input_data_size);
  1540. }
  1541. cam_generic_fence_free_input_info_util(&fence_input_info);
  1542. return rc;
  1543. }
  1544. static int cam_generic_fence_handle_synx_signal(
  1545. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1546. {
  1547. int32_t rc, i;
  1548. struct cam_generic_fence_signal_info *fence_signal_info;
  1549. struct cam_synx_obj_signal *synx_signal_info;
  1550. rc = cam_generic_fence_validate_signal_input_info_util(
  1551. CAM_GENERIC_FENCE_TYPE_SYNX_OBJ, fence_cmd_args,
  1552. &fence_signal_info, (void **)&synx_signal_info);
  1553. if (rc || !fence_signal_info || !synx_signal_info) {
  1554. CAM_ERR(CAM_SYNX,
  1555. "Fence input signal info validation failed rc: %d fence_input_info: %pK synx_signal_info: %pK",
  1556. rc, fence_signal_info, synx_signal_info);
  1557. return -EINVAL;
  1558. }
  1559. for (i = 0; i < fence_signal_info->num_fences_requested; i++) {
  1560. fence_signal_info->num_fences_processed++;
  1561. rc = cam_synx_obj_signal_obj(&synx_signal_info[i]);
  1562. if (rc) {
  1563. CAM_ERR(CAM_SYNX,
  1564. "Failed to signal for synx_obj: %d, rc: %d, status : %d",
  1565. synx_signal_info[i].synx_obj, rc,
  1566. synx_signal_info[i].status);
  1567. }
  1568. synx_signal_info[i].reason_code = rc;
  1569. }
  1570. if (copy_to_user(u64_to_user_ptr(fence_signal_info->fence_info_hdl), synx_signal_info,
  1571. fence_signal_info->fence_data_size)) {
  1572. rc = -EFAULT;
  1573. CAM_ERR(CAM_SYNX, "copy to user for signal data failed hdl: %d size: 0x%x",
  1574. fence_cmd_args->input_handle,
  1575. (sizeof(struct cam_synx_obj_signal) *
  1576. fence_signal_info->num_fences_requested));
  1577. goto end;
  1578. }
  1579. if (copy_to_user(u64_to_user_ptr(fence_cmd_args->input_handle),
  1580. fence_signal_info, sizeof(struct cam_generic_fence_signal_info))) {
  1581. rc = -EFAULT;
  1582. CAM_ERR(CAM_SYNX, "copy to user failed hdl: %d size: 0x%x",
  1583. fence_cmd_args->input_handle,
  1584. sizeof(struct cam_generic_fence_signal_info));
  1585. }
  1586. end:
  1587. cam_generic_fence_free_signal_input_info_util(&fence_signal_info,
  1588. (void **)&synx_signal_info);
  1589. return rc;
  1590. }
  1591. static int cam_generic_fence_process_synx_obj_cmd(
  1592. uint32_t id,
  1593. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1594. {
  1595. int rc = -EINVAL;
  1596. switch (id) {
  1597. case CAM_GENERIC_FENCE_CREATE:
  1598. rc = cam_generic_fence_handle_synx_create(fence_cmd_args);
  1599. break;
  1600. case CAM_GENERIC_FENCE_RELEASE:
  1601. rc = cam_generic_fence_handle_synx_release(fence_cmd_args);
  1602. break;
  1603. case CAM_GENERIC_FENCE_IMPORT:
  1604. rc = cam_generic_fence_handle_synx_import(fence_cmd_args);
  1605. break;
  1606. case CAM_GENERIC_FENCE_SIGNAL:
  1607. rc = cam_generic_fence_handle_synx_signal(fence_cmd_args);
  1608. break;
  1609. default:
  1610. CAM_ERR(CAM_SYNX, "IOCTL cmd: %u not supported for synx object", id);
  1611. break;
  1612. }
  1613. return rc;
  1614. }
  1615. #endif
  1616. static int cam_generic_fence_handle_sync_create(
  1617. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1618. {
  1619. int rc, i, dma_fence_row_idx;
  1620. bool dma_fence_created;
  1621. unsigned long fence_sel_mask;
  1622. struct cam_dma_fence_release_params release_params;
  1623. struct cam_dma_fence_create_sync_obj_payload dma_sync_create;
  1624. struct cam_generic_fence_input_info *fence_input_info = NULL;
  1625. struct cam_generic_fence_config *fence_cfg = NULL;
  1626. bool synx_obj_created = false;
  1627. struct sync_synx_obj_info synx_obj_create;
  1628. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  1629. int32_t fence_flag;
  1630. int32_t synx_obj_row_idx = 0;
  1631. struct cam_synx_obj_release_params synx_release_params;
  1632. struct dma_fence *dma_fence_ptr;
  1633. #endif
  1634. rc = cam_generic_fence_alloc_validate_input_info_util(fence_cmd_args, &fence_input_info);
  1635. if (rc || !fence_input_info) {
  1636. CAM_ERR(CAM_SYNC,
  1637. "Fence input info validation failed rc: %d fence_input_info: %pK",
  1638. rc, fence_input_info);
  1639. return -EINVAL;
  1640. }
  1641. for (i = 0; i < fence_input_info->num_fences_requested; i++) {
  1642. fence_cfg = &fence_input_info->fence_cfg[i];
  1643. fence_input_info->num_fences_processed++;
  1644. fence_cfg->reason_code = 0;
  1645. /* Reset flag */
  1646. dma_fence_created = false;
  1647. synx_obj_created = false;
  1648. fence_sel_mask = fence_cfg->fence_sel_mask;
  1649. if (test_bit(CAM_GENERIC_FENCE_TYPE_DMA_FENCE, &fence_sel_mask)) {
  1650. rc = cam_dma_fence_create_fd(&fence_cfg->dma_fence_fd,
  1651. &dma_fence_row_idx, fence_cfg->name);
  1652. if (rc) {
  1653. CAM_ERR(CAM_SYNC,
  1654. "Failed to create dma fence at index: %d rc: %d num_fences: %u",
  1655. i, rc, fence_input_info->num_fences_requested);
  1656. fence_cfg->reason_code = rc;
  1657. goto out_copy;
  1658. }
  1659. dma_sync_create.dma_fence_row_idx = dma_fence_row_idx;
  1660. dma_sync_create.fd = fence_cfg->dma_fence_fd;
  1661. dma_sync_create.sync_created_with_dma = true;
  1662. dma_fence_created = true;
  1663. }
  1664. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  1665. /* Create a synx object */
  1666. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNX_OBJ, &fence_sel_mask)) {
  1667. if (dma_fence_created) {
  1668. dma_fence_ptr = cam_dma_fence_get_fence_from_fd(
  1669. dma_sync_create.fd, &dma_fence_row_idx);
  1670. rc = cam_synx_obj_import_dma_fence(fence_cfg->name,
  1671. fence_cfg->params[0], dma_fence_ptr,
  1672. &fence_cfg->synx_obj, &synx_obj_row_idx);
  1673. } else {
  1674. cam_generic_fence_config_parse_params(fence_cfg,
  1675. CAM_GENERIC_FENCE_CONFIG_FLAG_PARAM_INDEX, &fence_flag);
  1676. rc = cam_synx_obj_create(fence_cfg->name,
  1677. fence_flag, &fence_cfg->synx_obj,
  1678. &synx_obj_row_idx);
  1679. }
  1680. if (rc) {
  1681. CAM_ERR(CAM_SYNC,
  1682. "Failed to create/import synx obj at index: %d rc: %d num_fences: %u",
  1683. i, rc, fence_input_info->num_fences_requested);
  1684. /* Release dma fence */
  1685. if (dma_fence_created) {
  1686. release_params.use_row_idx = true;
  1687. release_params.u.dma_row_idx = dma_fence_row_idx;
  1688. cam_dma_fence_release(&release_params);
  1689. }
  1690. /* Release synx obj */
  1691. if (synx_obj_created) {
  1692. synx_release_params.use_row_idx = true;
  1693. synx_release_params.u.synx_row_idx = synx_obj_row_idx;
  1694. cam_synx_obj_release(&synx_release_params);
  1695. }
  1696. goto out_copy;
  1697. }
  1698. synx_obj_create.sync_created_with_synx = true;
  1699. synx_obj_create.synx_obj = fence_cfg->synx_obj;
  1700. synx_obj_create.synx_obj_row_idx = synx_obj_row_idx;
  1701. synx_obj_created = true;
  1702. }
  1703. #endif
  1704. rc = cam_sync_create_util(&fence_cfg->sync_obj, fence_cfg->name,
  1705. (dma_fence_created ? &dma_sync_create : NULL),
  1706. (synx_obj_created ? &synx_obj_create : NULL));
  1707. if (rc) {
  1708. fence_cfg->reason_code = rc;
  1709. CAM_ERR(CAM_SYNC,
  1710. "Failed to create sync obj at index: %d rc: %d num_fences: %u",
  1711. i, rc, fence_input_info->num_fences_requested);
  1712. /* Release dma fence */
  1713. if (dma_fence_created) {
  1714. release_params.use_row_idx = true;
  1715. release_params.u.dma_row_idx = dma_fence_row_idx;
  1716. cam_dma_fence_release(&release_params);
  1717. }
  1718. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  1719. /* Release synx obj */
  1720. if (synx_obj_created) {
  1721. synx_release_params.use_row_idx = true;
  1722. synx_release_params.u.synx_row_idx = synx_obj_row_idx;
  1723. cam_synx_obj_release(&synx_release_params);
  1724. }
  1725. #endif
  1726. goto out_copy;
  1727. }
  1728. /* Register dma fence cb */
  1729. if (test_bit(CAM_GENERIC_FENCE_TYPE_DMA_FENCE, &fence_sel_mask)) {
  1730. rc = cam_dma_fence_register_cb(&fence_cfg->sync_obj,
  1731. &dma_fence_row_idx, cam_sync_dma_fence_cb);
  1732. if (rc) {
  1733. CAM_ERR(CAM_SYNC,
  1734. "Failed to register cb for dma fence fd: %d sync_obj: %d rc: %d",
  1735. fence_cfg->dma_fence_fd, fence_cfg->sync_obj, rc);
  1736. fence_cfg->reason_code = rc;
  1737. /* Destroy sync obj */
  1738. cam_sync_deinit_object(sync_dev->sync_table, fence_cfg->sync_obj,
  1739. NULL, NULL);
  1740. /* Release dma fence */
  1741. if (dma_fence_created) {
  1742. release_params.use_row_idx = true;
  1743. release_params.u.dma_row_idx = dma_fence_row_idx;
  1744. cam_dma_fence_release(&release_params);
  1745. }
  1746. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  1747. /* Release synx obj */
  1748. if (synx_obj_created) {
  1749. synx_release_params.use_row_idx = true;
  1750. synx_release_params.u.synx_row_idx = synx_obj_row_idx;
  1751. cam_synx_obj_release(&synx_release_params);
  1752. }
  1753. #endif
  1754. goto out_copy;
  1755. }
  1756. }
  1757. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  1758. /* Register synx object callback */
  1759. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNX_OBJ, &fence_sel_mask)) {
  1760. rc = cam_synx_obj_register_cb(&fence_cfg->sync_obj,
  1761. synx_obj_row_idx, cam_sync_synx_obj_cb);
  1762. if (rc) {
  1763. CAM_ERR(CAM_SYNC,
  1764. "Failed to register cb for synx_obj: %d sync_obj: %d rc: %d",
  1765. fence_cfg->synx_obj, fence_cfg->sync_obj, rc);
  1766. fence_cfg->reason_code = rc;
  1767. /* Destroy sync obj */
  1768. cam_sync_deinit_object(sync_dev->sync_table, fence_cfg->sync_obj,
  1769. NULL, NULL);
  1770. /* Release dma fence */
  1771. if (dma_fence_created) {
  1772. release_params.use_row_idx = true;
  1773. release_params.u.dma_row_idx = dma_fence_row_idx;
  1774. cam_dma_fence_release(&release_params);
  1775. }
  1776. /* Release synx obj */
  1777. if (synx_obj_created) {
  1778. synx_release_params.use_row_idx = true;
  1779. synx_release_params.u.synx_row_idx = synx_obj_row_idx;
  1780. cam_synx_obj_release(&synx_release_params);
  1781. }
  1782. goto out_copy;
  1783. }
  1784. }
  1785. #endif
  1786. CAM_DBG(CAM_SYNC,
  1787. "Created sync_obj = %d[%s] with fence_sel_mask: 0x%x dma_fence_fd: %d num fences [requested: %u processed: %u]",
  1788. fence_cfg->sync_obj, fence_cfg->name,
  1789. fence_cfg->fence_sel_mask, fence_cfg->dma_fence_fd,
  1790. fence_input_info->num_fences_requested,
  1791. fence_input_info->num_fences_processed);
  1792. }
  1793. out_copy:
  1794. if (copy_to_user(u64_to_user_ptr(fence_cmd_args->input_handle),
  1795. fence_input_info, fence_cmd_args->input_data_size)) {
  1796. rc = -EFAULT;
  1797. CAM_ERR(CAM_SYNC, "copy to user failed hdl: %d size: 0x%x",
  1798. fence_cmd_args->input_handle, fence_cmd_args->input_data_size);
  1799. }
  1800. cam_generic_fence_free_input_info_util(&fence_input_info);
  1801. return rc;
  1802. }
  1803. static int cam_generic_fence_handle_sync_release(
  1804. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1805. {
  1806. bool failed = false;
  1807. int rc, i;
  1808. unsigned long fence_sel_mask;
  1809. struct cam_sync_check_for_dma_release check_for_dma_release;
  1810. struct cam_dma_fence_release_params release_params;
  1811. struct cam_generic_fence_input_info *fence_input_info = NULL;
  1812. struct cam_generic_fence_config *fence_cfg = NULL;
  1813. struct cam_sync_check_for_synx_release check_for_synx_release;
  1814. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  1815. struct cam_synx_obj_release_params synx_release_params;
  1816. #endif
  1817. rc = cam_generic_fence_alloc_validate_input_info_util(fence_cmd_args, &fence_input_info);
  1818. if (rc || !fence_input_info) {
  1819. CAM_ERR(CAM_SYNC,
  1820. "Fence input info validation failed rc: %d fence_input_info: %pK",
  1821. rc, fence_input_info);
  1822. return -EINVAL;
  1823. }
  1824. for (i = 0; i < fence_input_info->num_fences_requested; i++) {
  1825. fence_cfg = &fence_input_info->fence_cfg[i];
  1826. fence_input_info->num_fences_processed++;
  1827. /* Reset fields */
  1828. fence_cfg->reason_code = 0;
  1829. check_for_dma_release.sync_created_with_dma = false;
  1830. check_for_dma_release.dma_fence_fd = fence_cfg->dma_fence_fd;
  1831. check_for_synx_release.sync_created_with_synx = false;
  1832. check_for_synx_release.synx_obj = fence_cfg->synx_obj;
  1833. rc = cam_sync_deinit_object(sync_dev->sync_table, fence_cfg->sync_obj,
  1834. &check_for_dma_release, &check_for_synx_release);
  1835. if (rc) {
  1836. fence_cfg->reason_code = rc;
  1837. failed = true;
  1838. CAM_ERR(CAM_SYNC,
  1839. "Failed to release sync obj at index: %d rc: %d num_fences [requested: %u processed: %u]",
  1840. i, rc, fence_input_info->num_fences_requested,
  1841. fence_input_info->num_fences_processed);
  1842. }
  1843. fence_sel_mask = fence_cfg->fence_sel_mask;
  1844. if (test_bit(CAM_GENERIC_FENCE_TYPE_DMA_FENCE, &fence_sel_mask)) {
  1845. if (!check_for_dma_release.sync_created_with_dma) {
  1846. CAM_ERR(CAM_SYNC,
  1847. "Failed to release dma fence fd: %d with sync_obj: %d, not created together",
  1848. fence_cfg->dma_fence_fd, fence_cfg->sync_obj);
  1849. failed = true;
  1850. fence_cfg->reason_code = -EPERM;
  1851. continue;
  1852. }
  1853. release_params.use_row_idx = true;
  1854. release_params.u.dma_row_idx = check_for_dma_release.dma_fence_row_idx;
  1855. rc = cam_dma_fence_release(&release_params);
  1856. if (rc) {
  1857. CAM_ERR(CAM_SYNC,
  1858. "Failed to destroy dma fence at index: %d rc: %d num fences [requested: %u processed: %u]",
  1859. i, rc, fence_input_info->num_fences_requested,
  1860. fence_input_info->num_fences_processed);
  1861. fence_cfg->reason_code = rc;
  1862. failed = true;
  1863. continue;
  1864. }
  1865. }
  1866. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  1867. /* Release associated synx obj */
  1868. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNX_OBJ, &fence_sel_mask)) {
  1869. if (!check_for_synx_release.sync_created_with_synx) {
  1870. CAM_ERR(CAM_SYNC,
  1871. "Failed to release synx_obj: %d with sync_obj: %d, not created together",
  1872. fence_cfg->synx_obj, fence_cfg->sync_obj);
  1873. failed = true;
  1874. fence_cfg->reason_code = -EPERM;
  1875. continue;
  1876. }
  1877. synx_release_params.use_row_idx = true;
  1878. synx_release_params.u.synx_row_idx =
  1879. check_for_synx_release.synx_obj_row_idx;
  1880. rc = cam_synx_obj_release(&synx_release_params);
  1881. if (rc) {
  1882. CAM_ERR(CAM_SYNC,
  1883. "Failed to destroy synx_obj at index: %d rc: %d num fences [requested: %u processed: %u]",
  1884. i, rc, fence_input_info->num_fences_requested,
  1885. fence_input_info->num_fences_processed);
  1886. fence_cfg->reason_code = rc;
  1887. failed = true;
  1888. continue;
  1889. }
  1890. }
  1891. #endif
  1892. CAM_DBG(CAM_SYNC,
  1893. "Released sync_obj = %d[%s] with fence_sel_mask: 0x%x dma_fence_fd: %d synx_obj: %d num fences [requested: %u processed: %u]",
  1894. fence_cfg->sync_obj, fence_cfg->name,
  1895. fence_cfg->fence_sel_mask, fence_cfg->dma_fence_fd, fence_cfg->synx_obj,
  1896. fence_input_info->num_fences_requested,
  1897. fence_input_info->num_fences_processed);
  1898. }
  1899. if (failed)
  1900. rc = -ENOMSG;
  1901. if (copy_to_user(u64_to_user_ptr(fence_cmd_args->input_handle),
  1902. fence_input_info, fence_cmd_args->input_data_size)) {
  1903. rc = -EFAULT;
  1904. CAM_ERR(CAM_SYNC, "copy to user failed hdl: %d size: 0x%x",
  1905. fence_cmd_args->input_handle, fence_cmd_args->input_data_size);
  1906. }
  1907. cam_generic_fence_free_input_info_util(&fence_input_info);
  1908. return rc;
  1909. }
  1910. static int cam_generic_fence_process_sync_obj_cmd(
  1911. uint32_t id,
  1912. struct cam_generic_fence_cmd_args *fence_cmd_args)
  1913. {
  1914. int rc = -EINVAL;
  1915. switch (id) {
  1916. case CAM_GENERIC_FENCE_CREATE:
  1917. rc = cam_generic_fence_handle_sync_create(fence_cmd_args);
  1918. break;
  1919. case CAM_GENERIC_FENCE_RELEASE:
  1920. rc = cam_generic_fence_handle_sync_release(fence_cmd_args);
  1921. break;
  1922. default:
  1923. CAM_ERR(CAM_SYNC, "IOCTL cmd: %u not supported for sync object", id);
  1924. break;
  1925. }
  1926. return rc;
  1927. }
  1928. static int cam_generic_fence_parser(
  1929. struct cam_private_ioctl_arg *k_ioctl)
  1930. {
  1931. int rc;
  1932. struct cam_generic_fence_cmd_args fence_cmd_args;
  1933. if (!k_ioctl->ioctl_ptr) {
  1934. CAM_ERR(CAM_SYNC, "Invalid args input ptr: %p",
  1935. k_ioctl->ioctl_ptr);
  1936. return -EINVAL;
  1937. }
  1938. if (k_ioctl->size != sizeof(struct cam_generic_fence_cmd_args)) {
  1939. CAM_ERR(CAM_SYNC, "Size mismatch expected: 0x%llx actual: 0x%llx",
  1940. sizeof(struct cam_generic_fence_cmd_args), k_ioctl->size);
  1941. return -EINVAL;
  1942. }
  1943. if (copy_from_user(&fence_cmd_args, u64_to_user_ptr(k_ioctl->ioctl_ptr),
  1944. sizeof(fence_cmd_args))) {
  1945. CAM_ERR(CAM_SYNC, "copy from user failed for input ptr: %pK",
  1946. k_ioctl->ioctl_ptr);
  1947. return -EFAULT;
  1948. }
  1949. if (fence_cmd_args.input_handle_type != CAM_HANDLE_USER_POINTER) {
  1950. CAM_ERR(CAM_SYNC, "Invalid handle type: %u",
  1951. fence_cmd_args.input_handle_type);
  1952. return -EINVAL;
  1953. }
  1954. switch (fence_cmd_args.fence_type) {
  1955. case CAM_GENERIC_FENCE_TYPE_SYNC_OBJ:
  1956. rc = cam_generic_fence_process_sync_obj_cmd(k_ioctl->id, &fence_cmd_args);
  1957. break;
  1958. case CAM_GENERIC_FENCE_TYPE_DMA_FENCE:
  1959. rc = cam_generic_fence_process_dma_fence_cmd(k_ioctl->id, &fence_cmd_args);
  1960. break;
  1961. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  1962. case CAM_GENERIC_FENCE_TYPE_SYNX_OBJ:
  1963. rc = cam_generic_fence_process_synx_obj_cmd(k_ioctl->id, &fence_cmd_args);
  1964. break;
  1965. #endif
  1966. default:
  1967. rc = -EINVAL;
  1968. CAM_ERR(CAM_SYNC, "fence type: 0x%x handling not supported",
  1969. fence_cmd_args.fence_type);
  1970. break;
  1971. }
  1972. return rc;
  1973. }
  1974. static long cam_sync_dev_ioctl(struct file *filep, void *fh,
  1975. bool valid_prio, unsigned int cmd, void *arg)
  1976. {
  1977. int32_t rc;
  1978. struct sync_device *sync_dev = video_drvdata(filep);
  1979. struct cam_private_ioctl_arg k_ioctl;
  1980. if (!sync_dev) {
  1981. CAM_ERR(CAM_SYNC, "sync_dev NULL");
  1982. return -EINVAL;
  1983. }
  1984. if (!arg)
  1985. return -EINVAL;
  1986. if (cmd != CAM_PRIVATE_IOCTL_CMD)
  1987. return -ENOIOCTLCMD;
  1988. k_ioctl = *(struct cam_private_ioctl_arg *)arg;
  1989. switch (k_ioctl.id) {
  1990. case CAM_SYNC_CREATE:
  1991. rc = cam_sync_handle_create(&k_ioctl);
  1992. break;
  1993. case CAM_SYNC_DESTROY:
  1994. rc = cam_sync_handle_destroy(&k_ioctl);
  1995. break;
  1996. case CAM_SYNC_REGISTER_PAYLOAD:
  1997. rc = cam_sync_handle_register_user_payload(
  1998. &k_ioctl);
  1999. break;
  2000. case CAM_SYNC_DEREGISTER_PAYLOAD:
  2001. rc = cam_sync_handle_deregister_user_payload(
  2002. &k_ioctl);
  2003. break;
  2004. case CAM_SYNC_SIGNAL:
  2005. rc = cam_sync_handle_signal(&k_ioctl);
  2006. break;
  2007. case CAM_SYNC_MERGE:
  2008. rc = cam_sync_handle_merge(&k_ioctl);
  2009. break;
  2010. case CAM_SYNC_WAIT:
  2011. rc = cam_sync_handle_wait(&k_ioctl);
  2012. ((struct cam_private_ioctl_arg *)arg)->result =
  2013. k_ioctl.result;
  2014. break;
  2015. case CAM_GENERIC_FENCE_CREATE:
  2016. case CAM_GENERIC_FENCE_RELEASE:
  2017. case CAM_GENERIC_FENCE_IMPORT:
  2018. case CAM_GENERIC_FENCE_SIGNAL:
  2019. rc = cam_generic_fence_parser(&k_ioctl);
  2020. break;
  2021. default:
  2022. rc = -ENOIOCTLCMD;
  2023. }
  2024. return rc;
  2025. }
  2026. static unsigned int cam_sync_poll(struct file *f,
  2027. struct poll_table_struct *pll_table)
  2028. {
  2029. int rc = 0;
  2030. struct v4l2_fh *eventq = f->private_data;
  2031. if (!eventq)
  2032. return -EINVAL;
  2033. poll_wait(f, &eventq->wait, pll_table);
  2034. if (v4l2_event_pending(eventq))
  2035. rc = POLLPRI;
  2036. return rc;
  2037. }
  2038. static int cam_sync_open(struct file *filep)
  2039. {
  2040. int rc;
  2041. struct sync_device *sync_dev = video_drvdata(filep);
  2042. if (!sync_dev) {
  2043. CAM_ERR(CAM_SYNC, "Sync device NULL");
  2044. return -ENODEV;
  2045. }
  2046. mutex_lock(&sync_dev->table_lock);
  2047. if (sync_dev->open_cnt >= 1) {
  2048. mutex_unlock(&sync_dev->table_lock);
  2049. return -EALREADY;
  2050. }
  2051. rc = v4l2_fh_open(filep);
  2052. if (!rc) {
  2053. sync_dev->open_cnt++;
  2054. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  2055. cam_synx_obj_open();
  2056. #endif
  2057. cam_dma_fence_open();
  2058. spin_lock_bh(&sync_dev->cam_sync_eventq_lock);
  2059. sync_dev->cam_sync_eventq = filep->private_data;
  2060. spin_unlock_bh(&sync_dev->cam_sync_eventq_lock);
  2061. } else {
  2062. CAM_ERR(CAM_SYNC, "v4l2_fh_open failed : %d", rc);
  2063. }
  2064. if (test_bit(CAM_GENERIC_FENCE_TYPE_SYNC_OBJ, &cam_sync_monitor_mask)) {
  2065. sync_dev->mon_data = kzalloc(
  2066. sizeof(struct cam_generic_fence_monitor_data *) *
  2067. CAM_SYNC_MONITOR_TABLE_SIZE, GFP_KERNEL);
  2068. if (!sync_dev->mon_data) {
  2069. CAM_WARN(CAM_SYNC, "Failed to allocate memory %d",
  2070. sizeof(struct cam_generic_fence_monitor_data *) *
  2071. CAM_SYNC_MONITOR_TABLE_SIZE);
  2072. }
  2073. }
  2074. mutex_unlock(&sync_dev->table_lock);
  2075. return rc;
  2076. }
  2077. static int cam_sync_close(struct file *filep)
  2078. {
  2079. int rc = 0;
  2080. int i;
  2081. struct sync_device *sync_dev = video_drvdata(filep);
  2082. if (!sync_dev) {
  2083. CAM_ERR(CAM_SYNC, "Sync device NULL");
  2084. rc = -ENODEV;
  2085. return rc;
  2086. }
  2087. mutex_lock(&sync_dev->table_lock);
  2088. sync_dev->open_cnt--;
  2089. if (!sync_dev->open_cnt) {
  2090. for (i = 1; i < CAM_SYNC_MAX_OBJS; i++) {
  2091. struct sync_table_row *row =
  2092. sync_dev->sync_table + i;
  2093. /*
  2094. * Signal all ACTIVE objects as ERR, but we don't
  2095. * care about the return status here apart from logging
  2096. * it.
  2097. */
  2098. if (row->state == CAM_SYNC_STATE_ACTIVE) {
  2099. rc = cam_sync_signal(i,
  2100. CAM_SYNC_STATE_SIGNALED_ERROR,
  2101. CAM_SYNC_COMMON_RELEASE_EVENT);
  2102. if (rc < 0)
  2103. CAM_ERR(CAM_SYNC,
  2104. "Cleanup signal fail idx:%d", i);
  2105. }
  2106. }
  2107. /*
  2108. * Flush the work queue to wait for pending signal callbacks to
  2109. * finish
  2110. */
  2111. flush_workqueue(sync_dev->work_queue);
  2112. /*
  2113. * Now that all callbacks worker threads have finished,
  2114. * destroy the sync objects
  2115. */
  2116. for (i = 1; i < CAM_SYNC_MAX_OBJS; i++) {
  2117. struct sync_table_row *row =
  2118. sync_dev->sync_table + i;
  2119. if (row->state != CAM_SYNC_STATE_INVALID) {
  2120. rc = cam_sync_destroy(i);
  2121. if (rc < 0)
  2122. CAM_ERR(CAM_SYNC,
  2123. "Cleanup destroy fail:idx:%d\n", i);
  2124. }
  2125. }
  2126. if (sync_dev->mon_data) {
  2127. for (i = 0; i < CAM_SYNC_MONITOR_TABLE_SIZE; i++)
  2128. kfree(sync_dev->mon_data[i]);
  2129. }
  2130. kfree(sync_dev->mon_data);
  2131. }
  2132. /* Clean dma fence table */
  2133. cam_dma_fence_close();
  2134. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  2135. /* Clean synx obj table */
  2136. cam_synx_obj_close();
  2137. #endif
  2138. mutex_unlock(&sync_dev->table_lock);
  2139. spin_lock_bh(&sync_dev->cam_sync_eventq_lock);
  2140. sync_dev->cam_sync_eventq = NULL;
  2141. spin_unlock_bh(&sync_dev->cam_sync_eventq_lock);
  2142. v4l2_fh_release(filep);
  2143. return rc;
  2144. }
  2145. static void cam_sync_event_queue_notify_error(const struct v4l2_event *old,
  2146. struct v4l2_event *new)
  2147. {
  2148. if (sync_dev->version == CAM_SYNC_V4L_EVENT_V2) {
  2149. struct cam_sync_ev_header_v2 *ev_header;
  2150. ev_header = CAM_SYNC_GET_HEADER_PTR_V2((*old));
  2151. CAM_ERR(CAM_CRM,
  2152. "Failed to notify event id %d fence %d statue %d reason %u %u %u %u",
  2153. old->id, ev_header->sync_obj, ev_header->status,
  2154. ev_header->evt_param[0], ev_header->evt_param[1],
  2155. ev_header->evt_param[2], ev_header->evt_param[3]);
  2156. } else {
  2157. struct cam_sync_ev_header *ev_header;
  2158. ev_header = CAM_SYNC_GET_HEADER_PTR((*old));
  2159. CAM_ERR(CAM_CRM,
  2160. "Failed to notify event id %d fence %d statue %d",
  2161. old->id, ev_header->sync_obj, ev_header->status);
  2162. }
  2163. }
  2164. static struct v4l2_subscribed_event_ops cam_sync_v4l2_ops = {
  2165. .merge = cam_sync_event_queue_notify_error,
  2166. };
  2167. int cam_sync_subscribe_event(struct v4l2_fh *fh,
  2168. const struct v4l2_event_subscription *sub)
  2169. {
  2170. if (!((sub->type == CAM_SYNC_V4L_EVENT) ||
  2171. (sub->type == CAM_SYNC_V4L_EVENT_V2))) {
  2172. CAM_ERR(CAM_SYNC, "Non supported event type 0x%x", sub->type);
  2173. return -EINVAL;
  2174. }
  2175. sync_dev->version = sub->type;
  2176. CAM_DBG(CAM_SYNC, "Sync event verion type 0x%x", sync_dev->version);
  2177. return v4l2_event_subscribe(fh, sub, CAM_SYNC_MAX_V4L2_EVENTS,
  2178. &cam_sync_v4l2_ops);
  2179. }
  2180. int cam_sync_unsubscribe_event(struct v4l2_fh *fh,
  2181. const struct v4l2_event_subscription *sub)
  2182. {
  2183. if (!((sub->type == CAM_SYNC_V4L_EVENT) ||
  2184. (sub->type == CAM_SYNC_V4L_EVENT_V2))) {
  2185. CAM_ERR(CAM_SYNC, "Non supported event type 0x%x", sub->type);
  2186. return -EINVAL;
  2187. }
  2188. return v4l2_event_unsubscribe(fh, sub);
  2189. }
  2190. static const struct v4l2_ioctl_ops g_cam_sync_ioctl_ops = {
  2191. .vidioc_subscribe_event = cam_sync_subscribe_event,
  2192. .vidioc_unsubscribe_event = cam_sync_unsubscribe_event,
  2193. .vidioc_default = cam_sync_dev_ioctl,
  2194. };
  2195. static struct v4l2_file_operations cam_sync_v4l2_fops = {
  2196. .owner = THIS_MODULE,
  2197. .open = cam_sync_open,
  2198. .release = cam_sync_close,
  2199. .poll = cam_sync_poll,
  2200. .unlocked_ioctl = video_ioctl2,
  2201. #ifdef CONFIG_COMPAT
  2202. .compat_ioctl32 = video_ioctl2,
  2203. #endif
  2204. };
  2205. #if IS_REACHABLE(CONFIG_MEDIA_CONTROLLER)
  2206. static int cam_sync_media_controller_init(struct sync_device *sync_dev,
  2207. struct platform_device *pdev)
  2208. {
  2209. int rc;
  2210. sync_dev->v4l2_dev.mdev = kzalloc(sizeof(struct media_device),
  2211. GFP_KERNEL);
  2212. if (!sync_dev->v4l2_dev.mdev)
  2213. return -ENOMEM;
  2214. media_device_init(sync_dev->v4l2_dev.mdev);
  2215. strlcpy(sync_dev->v4l2_dev.mdev->model, CAM_SYNC_DEVICE_NAME,
  2216. sizeof(sync_dev->v4l2_dev.mdev->model));
  2217. sync_dev->v4l2_dev.mdev->dev = &(pdev->dev);
  2218. rc = media_device_register(sync_dev->v4l2_dev.mdev);
  2219. if (rc < 0)
  2220. goto register_fail;
  2221. rc = media_entity_pads_init(&sync_dev->vdev->entity, 0, NULL);
  2222. if (rc < 0)
  2223. goto entity_fail;
  2224. return 0;
  2225. entity_fail:
  2226. media_device_unregister(sync_dev->v4l2_dev.mdev);
  2227. register_fail:
  2228. media_device_cleanup(sync_dev->v4l2_dev.mdev);
  2229. return rc;
  2230. }
  2231. static void cam_sync_media_controller_cleanup(struct sync_device *sync_dev)
  2232. {
  2233. media_entity_cleanup(&sync_dev->vdev->entity);
  2234. media_device_unregister(sync_dev->v4l2_dev.mdev);
  2235. media_device_cleanup(sync_dev->v4l2_dev.mdev);
  2236. kfree(sync_dev->v4l2_dev.mdev);
  2237. }
  2238. static void cam_sync_init_entity(struct sync_device *sync_dev)
  2239. {
  2240. sync_dev->vdev->entity.function = CAM_SYNC_DEVICE_TYPE;
  2241. sync_dev->vdev->entity.name =
  2242. video_device_node_name(sync_dev->vdev);
  2243. }
  2244. #else
  2245. static int cam_sync_media_controller_init(struct sync_device *sync_dev,
  2246. struct platform_device *pdev)
  2247. {
  2248. return 0;
  2249. }
  2250. static void cam_sync_media_controller_cleanup(struct sync_device *sync_dev)
  2251. {
  2252. }
  2253. static void cam_sync_init_entity(struct sync_device *sync_dev)
  2254. {
  2255. }
  2256. #endif
  2257. static int cam_sync_create_debugfs(void)
  2258. {
  2259. int rc;
  2260. struct dentry *dbgfileptr = NULL;
  2261. if (!cam_debugfs_available())
  2262. return 0;
  2263. rc = cam_debugfs_create_subdir("sync", &dbgfileptr);
  2264. if (rc) {
  2265. CAM_ERR(CAM_SYNC,"DebugFS could not create directory!");
  2266. rc = -ENOENT;
  2267. goto end;
  2268. }
  2269. /* Store parent inode for cleanup in caller */
  2270. sync_dev->dentry = dbgfileptr;
  2271. debugfs_create_bool("trigger_cb_without_switch", 0644,
  2272. sync_dev->dentry, &trigger_cb_without_switch);
  2273. debugfs_create_ulong("cam_sync_monitor_mask", 0644,
  2274. sync_dev->dentry, &cam_sync_monitor_mask);
  2275. end:
  2276. return rc;
  2277. }
  2278. #if IS_REACHABLE(CONFIG_MSM_GLOBAL_SYNX)
  2279. int cam_synx_sync_signal(int32_t sync_obj, uint32_t synx_status)
  2280. {
  2281. int rc;
  2282. uint32_t sync_status = synx_status;
  2283. switch (synx_status) {
  2284. case SYNX_STATE_ACTIVE:
  2285. sync_status = CAM_SYNC_STATE_ACTIVE;
  2286. break;
  2287. case SYNX_STATE_SIGNALED_SUCCESS:
  2288. sync_status = CAM_SYNC_STATE_SIGNALED_SUCCESS;
  2289. break;
  2290. case SYNX_STATE_SIGNALED_ERROR:
  2291. sync_status = CAM_SYNC_STATE_SIGNALED_ERROR;
  2292. break;
  2293. case 4: /* SYNX_STATE_SIGNALED_CANCEL: */
  2294. sync_status = CAM_SYNC_STATE_SIGNALED_CANCEL;
  2295. break;
  2296. default:
  2297. CAM_ERR(CAM_SYNC, "Invalid synx status %d for obj %d",
  2298. synx_status, sync_obj);
  2299. sync_status = CAM_SYNC_STATE_SIGNALED_ERROR;
  2300. break;
  2301. }
  2302. rc = cam_sync_signal(sync_obj, sync_status, CAM_SYNC_COMMON_EVENT_SYNX);
  2303. if (rc) {
  2304. CAM_ERR(CAM_SYNC,
  2305. "synx signal failed with %d, sync_obj=%d, synx_status=%d, sync_status=%d",
  2306. sync_obj, synx_status, sync_status, rc);
  2307. }
  2308. return rc;
  2309. }
  2310. int cam_synx_sync_register_callback(sync_callback cb_func,
  2311. void *userdata, int32_t sync_obj)
  2312. {
  2313. return cam_sync_register_callback(cb_func, userdata, sync_obj);
  2314. }
  2315. int cam_synx_sync_deregister_callback(sync_callback cb_func,
  2316. void *userdata, int32_t sync_obj)
  2317. {
  2318. return cam_sync_deregister_callback(cb_func, userdata, sync_obj);
  2319. }
  2320. static int cam_sync_register_synx_bind_ops(
  2321. struct synx_register_params *object)
  2322. {
  2323. int rc;
  2324. rc = synx_register_ops(object);
  2325. if (rc)
  2326. CAM_ERR(CAM_SYNC, "synx registration fail with rc=%d", rc);
  2327. return rc;
  2328. }
  2329. static void cam_sync_unregister_synx_bind_ops(
  2330. struct synx_register_params *object)
  2331. {
  2332. int rc;
  2333. rc = synx_deregister_ops(object);
  2334. if (rc)
  2335. CAM_ERR(CAM_SYNC, "sync unregistration fail with %d", rc);
  2336. }
  2337. static void cam_sync_configure_synx_obj(struct synx_register_params *object)
  2338. {
  2339. struct synx_register_params *params = object;
  2340. params->name = CAM_SYNC_NAME;
  2341. params->type = SYNX_TYPE_CSL;
  2342. params->ops.register_callback = cam_synx_sync_register_callback;
  2343. params->ops.deregister_callback = cam_synx_sync_deregister_callback;
  2344. params->ops.enable_signaling = cam_sync_get_obj_ref;
  2345. params->ops.signal = cam_synx_sync_signal;
  2346. }
  2347. #endif
  2348. static int cam_sync_component_bind(struct device *dev,
  2349. struct device *master_dev, void *data)
  2350. {
  2351. int rc;
  2352. int idx;
  2353. struct platform_device *pdev = to_platform_device(dev);
  2354. sync_dev = kzalloc(sizeof(*sync_dev), GFP_KERNEL);
  2355. if (!sync_dev)
  2356. return -ENOMEM;
  2357. mutex_init(&sync_dev->table_lock);
  2358. spin_lock_init(&sync_dev->cam_sync_eventq_lock);
  2359. for (idx = 0; idx < CAM_SYNC_MAX_OBJS; idx++)
  2360. spin_lock_init(&sync_dev->row_spinlocks[idx]);
  2361. sync_dev->vdev = video_device_alloc();
  2362. if (!sync_dev->vdev) {
  2363. rc = -ENOMEM;
  2364. goto vdev_fail;
  2365. }
  2366. rc = cam_sync_media_controller_init(sync_dev, pdev);
  2367. if (rc < 0)
  2368. goto mcinit_fail;
  2369. sync_dev->vdev->v4l2_dev = &sync_dev->v4l2_dev;
  2370. rc = v4l2_device_register(&(pdev->dev), sync_dev->vdev->v4l2_dev);
  2371. if (rc < 0)
  2372. goto register_fail;
  2373. strlcpy(sync_dev->vdev->name, CAM_SYNC_NAME,
  2374. sizeof(sync_dev->vdev->name));
  2375. sync_dev->vdev->release = video_device_release_empty;
  2376. sync_dev->vdev->fops = &cam_sync_v4l2_fops;
  2377. sync_dev->vdev->ioctl_ops = &g_cam_sync_ioctl_ops;
  2378. sync_dev->vdev->minor = -1;
  2379. sync_dev->vdev->device_caps |= V4L2_CAP_VIDEO_CAPTURE;
  2380. sync_dev->vdev->vfl_type = VFL_TYPE_VIDEO;
  2381. rc = video_register_device(sync_dev->vdev, VFL_TYPE_VIDEO, -1);
  2382. if (rc < 0) {
  2383. CAM_ERR(CAM_SYNC,
  2384. "video device registration failure rc = %d, name = %s, device_caps = %d",
  2385. rc, sync_dev->vdev->name, sync_dev->vdev->device_caps);
  2386. goto v4l2_fail;
  2387. }
  2388. cam_sync_init_entity(sync_dev);
  2389. video_set_drvdata(sync_dev->vdev, sync_dev);
  2390. bitmap_zero(sync_dev->bitmap, CAM_SYNC_MAX_OBJS);
  2391. /*
  2392. * We treat zero as invalid handle, so we will keep the 0th bit set
  2393. * always
  2394. */
  2395. set_bit(0, sync_dev->bitmap);
  2396. sync_dev->work_queue = alloc_workqueue(CAM_SYNC_WORKQUEUE_NAME,
  2397. WQ_HIGHPRI | WQ_UNBOUND, 1);
  2398. if (!sync_dev->work_queue) {
  2399. CAM_ERR(CAM_SYNC,
  2400. "Error: high priority work queue creation failed");
  2401. rc = -ENOMEM;
  2402. goto v4l2_fail;
  2403. }
  2404. /* Initialize dma fence driver */
  2405. rc = cam_dma_fence_driver_init();
  2406. if (rc) {
  2407. CAM_ERR(CAM_SYNC,
  2408. "DMA fence driver initialization failed rc: %d", rc);
  2409. goto workq_destroy;
  2410. }
  2411. trigger_cb_without_switch = false;
  2412. cam_sync_monitor_mask = 0;
  2413. cam_sync_create_debugfs();
  2414. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  2415. /* Initialize synx obj driver */
  2416. rc = cam_synx_obj_driver_init();
  2417. if (rc) {
  2418. CAM_ERR(CAM_SYNC,
  2419. "Synx obj driver initialization failed rc: %d", rc);
  2420. goto dma_driver_deinit;
  2421. }
  2422. #elif IS_REACHABLE(CONFIG_MSM_GLOBAL_SYNX)
  2423. CAM_DBG(CAM_SYNC, "Registering with synx driver");
  2424. cam_sync_configure_synx_obj(&sync_dev->params);
  2425. rc = cam_sync_register_synx_bind_ops(&sync_dev->params);
  2426. if (rc)
  2427. goto dma_driver_deinit;
  2428. #endif
  2429. CAM_DBG(CAM_SYNC, "Component bound successfully");
  2430. return rc;
  2431. #if IS_REACHABLE(CONFIG_MSM_GLOBAL_SYNX) || IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  2432. dma_driver_deinit:
  2433. cam_dma_fence_driver_deinit();
  2434. #endif
  2435. workq_destroy:
  2436. destroy_workqueue(sync_dev->work_queue);
  2437. v4l2_fail:
  2438. v4l2_device_unregister(sync_dev->vdev->v4l2_dev);
  2439. register_fail:
  2440. cam_sync_media_controller_cleanup(sync_dev);
  2441. mcinit_fail:
  2442. video_unregister_device(sync_dev->vdev);
  2443. video_device_release(sync_dev->vdev);
  2444. vdev_fail:
  2445. mutex_destroy(&sync_dev->table_lock);
  2446. kfree(sync_dev);
  2447. return rc;
  2448. }
  2449. static void cam_sync_component_unbind(struct device *dev,
  2450. struct device *master_dev, void *data)
  2451. {
  2452. int i;
  2453. v4l2_device_unregister(sync_dev->vdev->v4l2_dev);
  2454. cam_sync_media_controller_cleanup(sync_dev);
  2455. #if IS_ENABLED(CONFIG_TARGET_SYNX_ENABLE)
  2456. cam_synx_obj_driver_deinit();
  2457. #elif IS_REACHABLE(CONFIG_MSM_GLOBAL_SYNX)
  2458. cam_sync_unregister_synx_bind_ops(&sync_dev->params);
  2459. #endif
  2460. video_unregister_device(sync_dev->vdev);
  2461. video_device_release(sync_dev->vdev);
  2462. sync_dev->dentry = NULL;
  2463. cam_dma_fence_driver_deinit();
  2464. for (i = 0; i < CAM_SYNC_MAX_OBJS; i++)
  2465. spin_lock_init(&sync_dev->row_spinlocks[i]);
  2466. kfree(sync_dev);
  2467. sync_dev = NULL;
  2468. }
  2469. const static struct component_ops cam_sync_component_ops = {
  2470. .bind = cam_sync_component_bind,
  2471. .unbind = cam_sync_component_unbind,
  2472. };
  2473. static int cam_sync_probe(struct platform_device *pdev)
  2474. {
  2475. int rc;
  2476. CAM_DBG(CAM_SYNC, "Adding Sync component");
  2477. rc = component_add(&pdev->dev, &cam_sync_component_ops);
  2478. if (rc)
  2479. CAM_ERR(CAM_SYNC, "failed to add component rc: %d", rc);
  2480. return rc;
  2481. }
  2482. static int cam_sync_remove(struct platform_device *pdev)
  2483. {
  2484. component_del(&pdev->dev, &cam_sync_component_ops);
  2485. return 0;
  2486. }
  2487. static const struct of_device_id cam_sync_dt_match[] = {
  2488. {.compatible = "qcom,cam-sync"},
  2489. {}
  2490. };
  2491. MODULE_DEVICE_TABLE(of, cam_sync_dt_match);
  2492. struct platform_driver cam_sync_driver = {
  2493. .probe = cam_sync_probe,
  2494. .remove = cam_sync_remove,
  2495. .driver = {
  2496. .name = "cam_sync",
  2497. .owner = THIS_MODULE,
  2498. .of_match_table = cam_sync_dt_match,
  2499. .suppress_bind_attrs = true,
  2500. },
  2501. };
  2502. int cam_sync_init(void)
  2503. {
  2504. return platform_driver_register(&cam_sync_driver);
  2505. }
  2506. void cam_sync_exit(void)
  2507. {
  2508. platform_driver_unregister(&cam_sync_driver);
  2509. }
  2510. MODULE_DESCRIPTION("Camera sync driver");
  2511. MODULE_LICENSE("GPL v2");