drm_mode_config.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639
  1. /*
  2. * Copyright (c) 2016 Intel Corporation
  3. *
  4. * Permission to use, copy, modify, distribute, and sell this software and its
  5. * documentation for any purpose is hereby granted without fee, provided that
  6. * the above copyright notice appear in all copies and that both that copyright
  7. * notice and this permission notice appear in supporting documentation, and
  8. * that the name of the copyright holders not be used in advertising or
  9. * publicity pertaining to distribution of the software without specific,
  10. * written prior permission. The copyright holders make no representations
  11. * about the suitability of this software for any purpose. It is provided "as
  12. * is" without express or implied warranty.
  13. *
  14. * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15. * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16. * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17. * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18. * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20. * OF THIS SOFTWARE.
  21. */
  22. #include <linux/uaccess.h>
  23. #include <drm/drm_drv.h>
  24. #include <drm/drm_encoder.h>
  25. #include <drm/drm_file.h>
  26. #include <drm/drm_managed.h>
  27. #include <drm/drm_mode_config.h>
  28. #include <drm/drm_print.h>
  29. #include <linux/dma-resv.h>
  30. #include "drm_crtc_internal.h"
  31. #include "drm_internal.h"
  32. int drm_modeset_register_all(struct drm_device *dev)
  33. {
  34. int ret;
  35. ret = drm_plane_register_all(dev);
  36. if (ret)
  37. goto err_plane;
  38. ret = drm_crtc_register_all(dev);
  39. if (ret)
  40. goto err_crtc;
  41. ret = drm_encoder_register_all(dev);
  42. if (ret)
  43. goto err_encoder;
  44. ret = drm_connector_register_all(dev);
  45. if (ret)
  46. goto err_connector;
  47. return 0;
  48. err_connector:
  49. drm_encoder_unregister_all(dev);
  50. err_encoder:
  51. drm_crtc_unregister_all(dev);
  52. err_crtc:
  53. drm_plane_unregister_all(dev);
  54. err_plane:
  55. return ret;
  56. }
  57. void drm_modeset_unregister_all(struct drm_device *dev)
  58. {
  59. drm_connector_unregister_all(dev);
  60. drm_encoder_unregister_all(dev);
  61. drm_crtc_unregister_all(dev);
  62. drm_plane_unregister_all(dev);
  63. }
  64. /**
  65. * drm_mode_getresources - get graphics configuration
  66. * @dev: drm device for the ioctl
  67. * @data: data pointer for the ioctl
  68. * @file_priv: drm file for the ioctl call
  69. *
  70. * Construct a set of configuration description structures and return
  71. * them to the user, including CRTC, connector and framebuffer configuration.
  72. *
  73. * Called by the user via ioctl.
  74. *
  75. * Returns:
  76. * Zero on success, negative errno on failure.
  77. */
  78. int drm_mode_getresources(struct drm_device *dev, void *data,
  79. struct drm_file *file_priv)
  80. {
  81. struct drm_mode_card_res *card_res = data;
  82. struct drm_framebuffer *fb;
  83. struct drm_connector *connector;
  84. struct drm_crtc *crtc;
  85. struct drm_encoder *encoder;
  86. int count, ret = 0;
  87. uint32_t __user *fb_id;
  88. uint32_t __user *crtc_id;
  89. uint32_t __user *connector_id;
  90. uint32_t __user *encoder_id;
  91. struct drm_connector_list_iter conn_iter;
  92. if (!drm_core_check_feature(dev, DRIVER_MODESET))
  93. return -EOPNOTSUPP;
  94. mutex_lock(&file_priv->fbs_lock);
  95. count = 0;
  96. fb_id = u64_to_user_ptr(card_res->fb_id_ptr);
  97. list_for_each_entry(fb, &file_priv->fbs, filp_head) {
  98. if (count < card_res->count_fbs &&
  99. put_user(fb->base.id, fb_id + count)) {
  100. mutex_unlock(&file_priv->fbs_lock);
  101. return -EFAULT;
  102. }
  103. count++;
  104. }
  105. card_res->count_fbs = count;
  106. mutex_unlock(&file_priv->fbs_lock);
  107. card_res->max_height = dev->mode_config.max_height;
  108. card_res->min_height = dev->mode_config.min_height;
  109. card_res->max_width = dev->mode_config.max_width;
  110. card_res->min_width = dev->mode_config.min_width;
  111. count = 0;
  112. crtc_id = u64_to_user_ptr(card_res->crtc_id_ptr);
  113. drm_for_each_crtc(crtc, dev) {
  114. if (drm_lease_held(file_priv, crtc->base.id)) {
  115. if (count < card_res->count_crtcs &&
  116. put_user(crtc->base.id, crtc_id + count))
  117. return -EFAULT;
  118. count++;
  119. }
  120. }
  121. card_res->count_crtcs = count;
  122. count = 0;
  123. encoder_id = u64_to_user_ptr(card_res->encoder_id_ptr);
  124. drm_for_each_encoder(encoder, dev) {
  125. if (count < card_res->count_encoders &&
  126. put_user(encoder->base.id, encoder_id + count))
  127. return -EFAULT;
  128. count++;
  129. }
  130. card_res->count_encoders = count;
  131. drm_connector_list_iter_begin(dev, &conn_iter);
  132. count = 0;
  133. connector_id = u64_to_user_ptr(card_res->connector_id_ptr);
  134. drm_for_each_connector_iter(connector, &conn_iter) {
  135. /* only expose writeback connectors if userspace understands them */
  136. if (!file_priv->writeback_connectors &&
  137. (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK))
  138. continue;
  139. if (drm_lease_held(file_priv, connector->base.id)) {
  140. if (count < card_res->count_connectors &&
  141. put_user(connector->base.id, connector_id + count)) {
  142. drm_connector_list_iter_end(&conn_iter);
  143. return -EFAULT;
  144. }
  145. count++;
  146. }
  147. }
  148. card_res->count_connectors = count;
  149. drm_connector_list_iter_end(&conn_iter);
  150. return ret;
  151. }
  152. /**
  153. * drm_mode_config_reset - call ->reset callbacks
  154. * @dev: drm device
  155. *
  156. * This functions calls all the crtc's, encoder's and connector's ->reset
  157. * callback. Drivers can use this in e.g. their driver load or resume code to
  158. * reset hardware and software state.
  159. */
  160. void drm_mode_config_reset(struct drm_device *dev)
  161. {
  162. struct drm_crtc *crtc;
  163. struct drm_plane *plane;
  164. struct drm_encoder *encoder;
  165. struct drm_connector *connector;
  166. struct drm_connector_list_iter conn_iter;
  167. drm_for_each_plane(plane, dev)
  168. if (plane->funcs->reset)
  169. plane->funcs->reset(plane);
  170. drm_for_each_crtc(crtc, dev)
  171. if (crtc->funcs->reset)
  172. crtc->funcs->reset(crtc);
  173. drm_for_each_encoder(encoder, dev)
  174. if (encoder->funcs->reset)
  175. encoder->funcs->reset(encoder);
  176. drm_connector_list_iter_begin(dev, &conn_iter);
  177. drm_for_each_connector_iter(connector, &conn_iter)
  178. if (connector->funcs->reset)
  179. connector->funcs->reset(connector);
  180. drm_connector_list_iter_end(&conn_iter);
  181. }
  182. EXPORT_SYMBOL(drm_mode_config_reset);
  183. /*
  184. * Global properties
  185. */
  186. static const struct drm_prop_enum_list drm_plane_type_enum_list[] = {
  187. { DRM_PLANE_TYPE_OVERLAY, "Overlay" },
  188. { DRM_PLANE_TYPE_PRIMARY, "Primary" },
  189. { DRM_PLANE_TYPE_CURSOR, "Cursor" },
  190. };
  191. static int drm_mode_create_standard_properties(struct drm_device *dev)
  192. {
  193. struct drm_property *prop;
  194. int ret;
  195. ret = drm_connector_create_standard_properties(dev);
  196. if (ret)
  197. return ret;
  198. prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
  199. "type", drm_plane_type_enum_list,
  200. ARRAY_SIZE(drm_plane_type_enum_list));
  201. if (!prop)
  202. return -ENOMEM;
  203. dev->mode_config.plane_type_property = prop;
  204. prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
  205. "SRC_X", 0, UINT_MAX);
  206. if (!prop)
  207. return -ENOMEM;
  208. dev->mode_config.prop_src_x = prop;
  209. prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
  210. "SRC_Y", 0, UINT_MAX);
  211. if (!prop)
  212. return -ENOMEM;
  213. dev->mode_config.prop_src_y = prop;
  214. prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
  215. "SRC_W", 0, UINT_MAX);
  216. if (!prop)
  217. return -ENOMEM;
  218. dev->mode_config.prop_src_w = prop;
  219. prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
  220. "SRC_H", 0, UINT_MAX);
  221. if (!prop)
  222. return -ENOMEM;
  223. dev->mode_config.prop_src_h = prop;
  224. prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
  225. "CRTC_X", INT_MIN, INT_MAX);
  226. if (!prop)
  227. return -ENOMEM;
  228. dev->mode_config.prop_crtc_x = prop;
  229. prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
  230. "CRTC_Y", INT_MIN, INT_MAX);
  231. if (!prop)
  232. return -ENOMEM;
  233. dev->mode_config.prop_crtc_y = prop;
  234. prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
  235. "CRTC_W", 0, INT_MAX);
  236. if (!prop)
  237. return -ENOMEM;
  238. dev->mode_config.prop_crtc_w = prop;
  239. prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
  240. "CRTC_H", 0, INT_MAX);
  241. if (!prop)
  242. return -ENOMEM;
  243. dev->mode_config.prop_crtc_h = prop;
  244. prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
  245. "FB_ID", DRM_MODE_OBJECT_FB);
  246. if (!prop)
  247. return -ENOMEM;
  248. dev->mode_config.prop_fb_id = prop;
  249. prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
  250. "IN_FENCE_FD", -1, INT_MAX);
  251. if (!prop)
  252. return -ENOMEM;
  253. dev->mode_config.prop_in_fence_fd = prop;
  254. prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
  255. "OUT_FENCE_PTR", 0, U64_MAX);
  256. if (!prop)
  257. return -ENOMEM;
  258. dev->mode_config.prop_out_fence_ptr = prop;
  259. prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
  260. "CRTC_ID", DRM_MODE_OBJECT_CRTC);
  261. if (!prop)
  262. return -ENOMEM;
  263. dev->mode_config.prop_crtc_id = prop;
  264. prop = drm_property_create(dev,
  265. DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB,
  266. "FB_DAMAGE_CLIPS", 0);
  267. if (!prop)
  268. return -ENOMEM;
  269. dev->mode_config.prop_fb_damage_clips = prop;
  270. prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
  271. "ACTIVE");
  272. if (!prop)
  273. return -ENOMEM;
  274. dev->mode_config.prop_active = prop;
  275. prop = drm_property_create(dev,
  276. DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB,
  277. "MODE_ID", 0);
  278. if (!prop)
  279. return -ENOMEM;
  280. dev->mode_config.prop_mode_id = prop;
  281. prop = drm_property_create_bool(dev, 0,
  282. "VRR_ENABLED");
  283. if (!prop)
  284. return -ENOMEM;
  285. dev->mode_config.prop_vrr_enabled = prop;
  286. prop = drm_property_create(dev,
  287. DRM_MODE_PROP_BLOB,
  288. "DEGAMMA_LUT", 0);
  289. if (!prop)
  290. return -ENOMEM;
  291. dev->mode_config.degamma_lut_property = prop;
  292. prop = drm_property_create_range(dev,
  293. DRM_MODE_PROP_IMMUTABLE,
  294. "DEGAMMA_LUT_SIZE", 0, UINT_MAX);
  295. if (!prop)
  296. return -ENOMEM;
  297. dev->mode_config.degamma_lut_size_property = prop;
  298. prop = drm_property_create(dev,
  299. DRM_MODE_PROP_BLOB,
  300. "CTM", 0);
  301. if (!prop)
  302. return -ENOMEM;
  303. dev->mode_config.ctm_property = prop;
  304. prop = drm_property_create(dev,
  305. DRM_MODE_PROP_BLOB,
  306. "GAMMA_LUT", 0);
  307. if (!prop)
  308. return -ENOMEM;
  309. dev->mode_config.gamma_lut_property = prop;
  310. prop = drm_property_create_range(dev,
  311. DRM_MODE_PROP_IMMUTABLE,
  312. "GAMMA_LUT_SIZE", 0, UINT_MAX);
  313. if (!prop)
  314. return -ENOMEM;
  315. dev->mode_config.gamma_lut_size_property = prop;
  316. prop = drm_property_create(dev,
  317. DRM_MODE_PROP_IMMUTABLE | DRM_MODE_PROP_BLOB,
  318. "IN_FORMATS", 0);
  319. if (!prop)
  320. return -ENOMEM;
  321. dev->mode_config.modifiers_property = prop;
  322. return 0;
  323. }
  324. static void drm_mode_config_init_release(struct drm_device *dev, void *ptr)
  325. {
  326. drm_mode_config_cleanup(dev);
  327. }
  328. /**
  329. * drmm_mode_config_init - managed DRM mode_configuration structure
  330. * initialization
  331. * @dev: DRM device
  332. *
  333. * Initialize @dev's mode_config structure, used for tracking the graphics
  334. * configuration of @dev.
  335. *
  336. * Since this initializes the modeset locks, no locking is possible. Which is no
  337. * problem, since this should happen single threaded at init time. It is the
  338. * driver's problem to ensure this guarantee.
  339. *
  340. * Cleanup is automatically handled through registering drm_mode_config_cleanup
  341. * with drmm_add_action().
  342. *
  343. * Returns: 0 on success, negative error value on failure.
  344. */
  345. int drmm_mode_config_init(struct drm_device *dev)
  346. {
  347. mutex_init(&dev->mode_config.mutex);
  348. drm_modeset_lock_init(&dev->mode_config.connection_mutex);
  349. mutex_init(&dev->mode_config.idr_mutex);
  350. mutex_init(&dev->mode_config.fb_lock);
  351. mutex_init(&dev->mode_config.blob_lock);
  352. INIT_LIST_HEAD(&dev->mode_config.fb_list);
  353. INIT_LIST_HEAD(&dev->mode_config.crtc_list);
  354. INIT_LIST_HEAD(&dev->mode_config.connector_list);
  355. INIT_LIST_HEAD(&dev->mode_config.encoder_list);
  356. INIT_LIST_HEAD(&dev->mode_config.property_list);
  357. INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
  358. INIT_LIST_HEAD(&dev->mode_config.plane_list);
  359. INIT_LIST_HEAD(&dev->mode_config.privobj_list);
  360. idr_init(&dev->mode_config.object_idr);
  361. idr_init(&dev->mode_config.tile_idr);
  362. ida_init(&dev->mode_config.connector_ida);
  363. spin_lock_init(&dev->mode_config.connector_list_lock);
  364. init_llist_head(&dev->mode_config.connector_free_list);
  365. INIT_WORK(&dev->mode_config.connector_free_work, drm_connector_free_work_fn);
  366. drm_mode_create_standard_properties(dev);
  367. /* Just to be sure */
  368. dev->mode_config.num_fb = 0;
  369. dev->mode_config.num_connector = 0;
  370. dev->mode_config.num_crtc = 0;
  371. dev->mode_config.num_encoder = 0;
  372. dev->mode_config.num_total_plane = 0;
  373. if (IS_ENABLED(CONFIG_LOCKDEP)) {
  374. struct drm_modeset_acquire_ctx modeset_ctx;
  375. struct ww_acquire_ctx resv_ctx;
  376. struct dma_resv resv;
  377. int ret;
  378. dma_resv_init(&resv);
  379. drm_modeset_acquire_init(&modeset_ctx, 0);
  380. ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
  381. &modeset_ctx);
  382. if (ret == -EDEADLK)
  383. ret = drm_modeset_backoff(&modeset_ctx);
  384. ww_acquire_init(&resv_ctx, &reservation_ww_class);
  385. ret = dma_resv_lock(&resv, &resv_ctx);
  386. if (ret == -EDEADLK)
  387. dma_resv_lock_slow(&resv, &resv_ctx);
  388. dma_resv_unlock(&resv);
  389. ww_acquire_fini(&resv_ctx);
  390. drm_modeset_drop_locks(&modeset_ctx);
  391. drm_modeset_acquire_fini(&modeset_ctx);
  392. dma_resv_fini(&resv);
  393. }
  394. return drmm_add_action_or_reset(dev, drm_mode_config_init_release,
  395. NULL);
  396. }
  397. EXPORT_SYMBOL(drmm_mode_config_init);
  398. /**
  399. * drm_mode_config_cleanup - free up DRM mode_config info
  400. * @dev: DRM device
  401. *
  402. * Free up all the connectors and CRTCs associated with this DRM device, then
  403. * free up the framebuffers and associated buffer objects.
  404. *
  405. * Note that since this /should/ happen single-threaded at driver/device
  406. * teardown time, no locking is required. It's the driver's job to ensure that
  407. * this guarantee actually holds true.
  408. *
  409. * FIXME: With the managed drmm_mode_config_init() it is no longer necessary for
  410. * drivers to explicitly call this function.
  411. */
  412. void drm_mode_config_cleanup(struct drm_device *dev)
  413. {
  414. struct drm_connector *connector;
  415. struct drm_connector_list_iter conn_iter;
  416. struct drm_crtc *crtc, *ct;
  417. struct drm_encoder *encoder, *enct;
  418. struct drm_framebuffer *fb, *fbt;
  419. struct drm_property *property, *pt;
  420. struct drm_property_blob *blob, *bt;
  421. struct drm_plane *plane, *plt;
  422. list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list,
  423. head) {
  424. encoder->funcs->destroy(encoder);
  425. }
  426. drm_connector_list_iter_begin(dev, &conn_iter);
  427. drm_for_each_connector_iter(connector, &conn_iter) {
  428. /* drm_connector_list_iter holds an full reference to the
  429. * current connector itself, which means it is inherently safe
  430. * against unreferencing the current connector - but not against
  431. * deleting it right away. */
  432. drm_connector_put(connector);
  433. }
  434. drm_connector_list_iter_end(&conn_iter);
  435. /* connector_iter drops references in a work item. */
  436. flush_work(&dev->mode_config.connector_free_work);
  437. if (WARN_ON(!list_empty(&dev->mode_config.connector_list))) {
  438. drm_connector_list_iter_begin(dev, &conn_iter);
  439. drm_for_each_connector_iter(connector, &conn_iter)
  440. DRM_ERROR("connector %s leaked!\n", connector->name);
  441. drm_connector_list_iter_end(&conn_iter);
  442. }
  443. list_for_each_entry_safe(property, pt, &dev->mode_config.property_list,
  444. head) {
  445. drm_property_destroy(dev, property);
  446. }
  447. list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list,
  448. head) {
  449. plane->funcs->destroy(plane);
  450. }
  451. list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
  452. crtc->funcs->destroy(crtc);
  453. }
  454. list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
  455. head_global) {
  456. drm_property_blob_put(blob);
  457. }
  458. /*
  459. * Single-threaded teardown context, so it's not required to grab the
  460. * fb_lock to protect against concurrent fb_list access. Contrary, it
  461. * would actually deadlock with the drm_framebuffer_cleanup function.
  462. *
  463. * Also, if there are any framebuffers left, that's a driver leak now,
  464. * so politely WARN about this.
  465. */
  466. WARN_ON(!list_empty(&dev->mode_config.fb_list));
  467. list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
  468. struct drm_printer p = drm_debug_printer("[leaked fb]");
  469. drm_printf(&p, "framebuffer[%u]:\n", fb->base.id);
  470. drm_framebuffer_print_info(&p, 1, fb);
  471. drm_framebuffer_free(&fb->base.refcount);
  472. }
  473. ida_destroy(&dev->mode_config.connector_ida);
  474. idr_destroy(&dev->mode_config.tile_idr);
  475. idr_destroy(&dev->mode_config.object_idr);
  476. drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
  477. }
  478. EXPORT_SYMBOL(drm_mode_config_cleanup);
  479. static u32 full_encoder_mask(struct drm_device *dev)
  480. {
  481. struct drm_encoder *encoder;
  482. u32 encoder_mask = 0;
  483. drm_for_each_encoder(encoder, dev)
  484. encoder_mask |= drm_encoder_mask(encoder);
  485. return encoder_mask;
  486. }
  487. /*
  488. * For some reason we want the encoder itself included in
  489. * possible_clones. Make life easy for drivers by allowing them
  490. * to leave possible_clones unset if no cloning is possible.
  491. */
  492. static void fixup_encoder_possible_clones(struct drm_encoder *encoder)
  493. {
  494. if (encoder->possible_clones == 0)
  495. encoder->possible_clones = drm_encoder_mask(encoder);
  496. }
  497. static void validate_encoder_possible_clones(struct drm_encoder *encoder)
  498. {
  499. struct drm_device *dev = encoder->dev;
  500. u32 encoder_mask = full_encoder_mask(dev);
  501. struct drm_encoder *other;
  502. drm_for_each_encoder(other, dev) {
  503. WARN(!!(encoder->possible_clones & drm_encoder_mask(other)) !=
  504. !!(other->possible_clones & drm_encoder_mask(encoder)),
  505. "possible_clones mismatch: "
  506. "[ENCODER:%d:%s] mask=0x%x possible_clones=0x%x vs. "
  507. "[ENCODER:%d:%s] mask=0x%x possible_clones=0x%x\n",
  508. encoder->base.id, encoder->name,
  509. drm_encoder_mask(encoder), encoder->possible_clones,
  510. other->base.id, other->name,
  511. drm_encoder_mask(other), other->possible_clones);
  512. }
  513. WARN((encoder->possible_clones & drm_encoder_mask(encoder)) == 0 ||
  514. (encoder->possible_clones & ~encoder_mask) != 0,
  515. "Bogus possible_clones: "
  516. "[ENCODER:%d:%s] possible_clones=0x%x (full encoder mask=0x%x)\n",
  517. encoder->base.id, encoder->name,
  518. encoder->possible_clones, encoder_mask);
  519. }
  520. static u32 full_crtc_mask(struct drm_device *dev)
  521. {
  522. struct drm_crtc *crtc;
  523. u32 crtc_mask = 0;
  524. drm_for_each_crtc(crtc, dev)
  525. crtc_mask |= drm_crtc_mask(crtc);
  526. return crtc_mask;
  527. }
  528. static void validate_encoder_possible_crtcs(struct drm_encoder *encoder)
  529. {
  530. u32 crtc_mask = full_crtc_mask(encoder->dev);
  531. WARN((encoder->possible_crtcs & crtc_mask) == 0 ||
  532. (encoder->possible_crtcs & ~crtc_mask) != 0,
  533. "Bogus possible_crtcs: "
  534. "[ENCODER:%d:%s] possible_crtcs=0x%x (full crtc mask=0x%x)\n",
  535. encoder->base.id, encoder->name,
  536. encoder->possible_crtcs, crtc_mask);
  537. }
  538. void drm_mode_config_validate(struct drm_device *dev)
  539. {
  540. struct drm_encoder *encoder;
  541. if (!drm_core_check_feature(dev, DRIVER_MODESET))
  542. return;
  543. drm_for_each_encoder(encoder, dev)
  544. fixup_encoder_possible_clones(encoder);
  545. drm_for_each_encoder(encoder, dev) {
  546. validate_encoder_possible_clones(encoder);
  547. validate_encoder_possible_crtcs(encoder);
  548. }
  549. }