nouveau_fbcon.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560
  1. /*
  2. * Copyright © 2007 David Airlie
  3. *
  4. * Permission is hereby granted, free of charge, to any person obtaining a
  5. * copy of this software and associated documentation files (the "Software"),
  6. * to deal in the Software without restriction, including without limitation
  7. * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8. * and/or sell copies of the Software, and to permit persons to whom the
  9. * Software is furnished to do so, subject to the following conditions:
  10. *
  11. * The above copyright notice and this permission notice (including the next
  12. * paragraph) shall be included in all copies or substantial portions of the
  13. * Software.
  14. *
  15. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  18. * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19. * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20. * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21. * DEALINGS IN THE SOFTWARE.
  22. *
  23. * Authors:
  24. * David Airlie
  25. */
  26. #include <linux/module.h>
  27. #include <linux/kernel.h>
  28. #include <linux/errno.h>
  29. #include <linux/string.h>
  30. #include <linux/mm.h>
  31. #include <linux/tty.h>
  32. #include <linux/sysrq.h>
  33. #include <linux/delay.h>
  34. #include <linux/init.h>
  35. #include <linux/screen_info.h>
  36. #include <linux/vga_switcheroo.h>
  37. #include <linux/console.h>
  38. #include <drm/drmP.h>
  39. #include <drm/drm_crtc.h>
  40. #include <drm/drm_crtc_helper.h>
  41. #include <drm/drm_fb_helper.h>
  42. #include <drm/drm_atomic.h>
  43. #include "nouveau_drv.h"
  44. #include "nouveau_gem.h"
  45. #include "nouveau_bo.h"
  46. #include "nouveau_fbcon.h"
  47. #include "nouveau_chan.h"
  48. #include "nouveau_vmm.h"
  49. #include "nouveau_crtc.h"
  50. MODULE_PARM_DESC(nofbaccel, "Disable fbcon acceleration");
  51. int nouveau_nofbaccel = 0;
  52. module_param_named(nofbaccel, nouveau_nofbaccel, int, 0400);
  53. MODULE_PARM_DESC(fbcon_bpp, "fbcon bits-per-pixel (default: auto)");
  54. static int nouveau_fbcon_bpp;
  55. module_param_named(fbcon_bpp, nouveau_fbcon_bpp, int, 0400);
  56. static void
  57. nouveau_fbcon_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
  58. {
  59. struct nouveau_fbdev *fbcon = info->par;
  60. struct nouveau_drm *drm = nouveau_drm(fbcon->helper.dev);
  61. struct nvif_device *device = &drm->client.device;
  62. int ret;
  63. if (info->state != FBINFO_STATE_RUNNING)
  64. return;
  65. ret = -ENODEV;
  66. if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) &&
  67. mutex_trylock(&drm->client.mutex)) {
  68. if (device->info.family < NV_DEVICE_INFO_V0_TESLA)
  69. ret = nv04_fbcon_fillrect(info, rect);
  70. else
  71. if (device->info.family < NV_DEVICE_INFO_V0_FERMI)
  72. ret = nv50_fbcon_fillrect(info, rect);
  73. else
  74. ret = nvc0_fbcon_fillrect(info, rect);
  75. mutex_unlock(&drm->client.mutex);
  76. }
  77. if (ret == 0)
  78. return;
  79. if (ret != -ENODEV)
  80. nouveau_fbcon_gpu_lockup(info);
  81. drm_fb_helper_cfb_fillrect(info, rect);
  82. }
  83. static void
  84. nouveau_fbcon_copyarea(struct fb_info *info, const struct fb_copyarea *image)
  85. {
  86. struct nouveau_fbdev *fbcon = info->par;
  87. struct nouveau_drm *drm = nouveau_drm(fbcon->helper.dev);
  88. struct nvif_device *device = &drm->client.device;
  89. int ret;
  90. if (info->state != FBINFO_STATE_RUNNING)
  91. return;
  92. ret = -ENODEV;
  93. if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) &&
  94. mutex_trylock(&drm->client.mutex)) {
  95. if (device->info.family < NV_DEVICE_INFO_V0_TESLA)
  96. ret = nv04_fbcon_copyarea(info, image);
  97. else
  98. if (device->info.family < NV_DEVICE_INFO_V0_FERMI)
  99. ret = nv50_fbcon_copyarea(info, image);
  100. else
  101. ret = nvc0_fbcon_copyarea(info, image);
  102. mutex_unlock(&drm->client.mutex);
  103. }
  104. if (ret == 0)
  105. return;
  106. if (ret != -ENODEV)
  107. nouveau_fbcon_gpu_lockup(info);
  108. drm_fb_helper_cfb_copyarea(info, image);
  109. }
  110. static void
  111. nouveau_fbcon_imageblit(struct fb_info *info, const struct fb_image *image)
  112. {
  113. struct nouveau_fbdev *fbcon = info->par;
  114. struct nouveau_drm *drm = nouveau_drm(fbcon->helper.dev);
  115. struct nvif_device *device = &drm->client.device;
  116. int ret;
  117. if (info->state != FBINFO_STATE_RUNNING)
  118. return;
  119. ret = -ENODEV;
  120. if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) &&
  121. mutex_trylock(&drm->client.mutex)) {
  122. if (device->info.family < NV_DEVICE_INFO_V0_TESLA)
  123. ret = nv04_fbcon_imageblit(info, image);
  124. else
  125. if (device->info.family < NV_DEVICE_INFO_V0_FERMI)
  126. ret = nv50_fbcon_imageblit(info, image);
  127. else
  128. ret = nvc0_fbcon_imageblit(info, image);
  129. mutex_unlock(&drm->client.mutex);
  130. }
  131. if (ret == 0)
  132. return;
  133. if (ret != -ENODEV)
  134. nouveau_fbcon_gpu_lockup(info);
  135. drm_fb_helper_cfb_imageblit(info, image);
  136. }
  137. static int
  138. nouveau_fbcon_sync(struct fb_info *info)
  139. {
  140. struct nouveau_fbdev *fbcon = info->par;
  141. struct nouveau_drm *drm = nouveau_drm(fbcon->helper.dev);
  142. struct nouveau_channel *chan = drm->channel;
  143. int ret;
  144. if (!chan || !chan->accel_done || in_interrupt() ||
  145. info->state != FBINFO_STATE_RUNNING ||
  146. info->flags & FBINFO_HWACCEL_DISABLED)
  147. return 0;
  148. if (!mutex_trylock(&drm->client.mutex))
  149. return 0;
  150. ret = nouveau_channel_idle(chan);
  151. mutex_unlock(&drm->client.mutex);
  152. if (ret) {
  153. nouveau_fbcon_gpu_lockup(info);
  154. return 0;
  155. }
  156. chan->accel_done = false;
  157. return 0;
  158. }
  159. static int
  160. nouveau_fbcon_open(struct fb_info *info, int user)
  161. {
  162. struct nouveau_fbdev *fbcon = info->par;
  163. struct nouveau_drm *drm = nouveau_drm(fbcon->helper.dev);
  164. int ret = pm_runtime_get_sync(drm->dev->dev);
  165. if (ret < 0 && ret != -EACCES)
  166. return ret;
  167. return 0;
  168. }
  169. static int
  170. nouveau_fbcon_release(struct fb_info *info, int user)
  171. {
  172. struct nouveau_fbdev *fbcon = info->par;
  173. struct nouveau_drm *drm = nouveau_drm(fbcon->helper.dev);
  174. pm_runtime_put(drm->dev->dev);
  175. return 0;
  176. }
  177. static struct fb_ops nouveau_fbcon_ops = {
  178. .owner = THIS_MODULE,
  179. DRM_FB_HELPER_DEFAULT_OPS,
  180. .fb_open = nouveau_fbcon_open,
  181. .fb_release = nouveau_fbcon_release,
  182. .fb_fillrect = nouveau_fbcon_fillrect,
  183. .fb_copyarea = nouveau_fbcon_copyarea,
  184. .fb_imageblit = nouveau_fbcon_imageblit,
  185. .fb_sync = nouveau_fbcon_sync,
  186. };
  187. static struct fb_ops nouveau_fbcon_sw_ops = {
  188. .owner = THIS_MODULE,
  189. DRM_FB_HELPER_DEFAULT_OPS,
  190. .fb_open = nouveau_fbcon_open,
  191. .fb_release = nouveau_fbcon_release,
  192. .fb_fillrect = drm_fb_helper_cfb_fillrect,
  193. .fb_copyarea = drm_fb_helper_cfb_copyarea,
  194. .fb_imageblit = drm_fb_helper_cfb_imageblit,
  195. };
  196. void
  197. nouveau_fbcon_accel_save_disable(struct drm_device *dev)
  198. {
  199. struct nouveau_drm *drm = nouveau_drm(dev);
  200. if (drm->fbcon && drm->fbcon->helper.fbdev) {
  201. drm->fbcon->saved_flags = drm->fbcon->helper.fbdev->flags;
  202. drm->fbcon->helper.fbdev->flags |= FBINFO_HWACCEL_DISABLED;
  203. }
  204. }
  205. void
  206. nouveau_fbcon_accel_restore(struct drm_device *dev)
  207. {
  208. struct nouveau_drm *drm = nouveau_drm(dev);
  209. if (drm->fbcon && drm->fbcon->helper.fbdev) {
  210. drm->fbcon->helper.fbdev->flags = drm->fbcon->saved_flags;
  211. }
  212. }
  213. static void
  214. nouveau_fbcon_accel_fini(struct drm_device *dev)
  215. {
  216. struct nouveau_drm *drm = nouveau_drm(dev);
  217. struct nouveau_fbdev *fbcon = drm->fbcon;
  218. if (fbcon && drm->channel) {
  219. console_lock();
  220. if (fbcon->helper.fbdev)
  221. fbcon->helper.fbdev->flags |= FBINFO_HWACCEL_DISABLED;
  222. console_unlock();
  223. nouveau_channel_idle(drm->channel);
  224. nvif_object_fini(&fbcon->twod);
  225. nvif_object_fini(&fbcon->blit);
  226. nvif_object_fini(&fbcon->gdi);
  227. nvif_object_fini(&fbcon->patt);
  228. nvif_object_fini(&fbcon->rop);
  229. nvif_object_fini(&fbcon->clip);
  230. nvif_object_fini(&fbcon->surf2d);
  231. }
  232. }
  233. static void
  234. nouveau_fbcon_accel_init(struct drm_device *dev)
  235. {
  236. struct nouveau_drm *drm = nouveau_drm(dev);
  237. struct nouveau_fbdev *fbcon = drm->fbcon;
  238. struct fb_info *info = fbcon->helper.fbdev;
  239. int ret;
  240. if (drm->client.device.info.family < NV_DEVICE_INFO_V0_TESLA)
  241. ret = nv04_fbcon_accel_init(info);
  242. else
  243. if (drm->client.device.info.family < NV_DEVICE_INFO_V0_FERMI)
  244. ret = nv50_fbcon_accel_init(info);
  245. else
  246. ret = nvc0_fbcon_accel_init(info);
  247. if (ret == 0)
  248. info->fbops = &nouveau_fbcon_ops;
  249. }
  250. static void
  251. nouveau_fbcon_zfill(struct drm_device *dev, struct nouveau_fbdev *fbcon)
  252. {
  253. struct fb_info *info = fbcon->helper.fbdev;
  254. struct fb_fillrect rect;
  255. /* Clear the entire fbcon. The drm will program every connector
  256. * with it's preferred mode. If the sizes differ, one display will
  257. * quite likely have garbage around the console.
  258. */
  259. rect.dx = rect.dy = 0;
  260. rect.width = info->var.xres_virtual;
  261. rect.height = info->var.yres_virtual;
  262. rect.color = 0;
  263. rect.rop = ROP_COPY;
  264. info->fbops->fb_fillrect(info, &rect);
  265. }
  266. static int
  267. nouveau_fbcon_create(struct drm_fb_helper *helper,
  268. struct drm_fb_helper_surface_size *sizes)
  269. {
  270. struct nouveau_fbdev *fbcon =
  271. container_of(helper, struct nouveau_fbdev, helper);
  272. struct drm_device *dev = fbcon->helper.dev;
  273. struct nouveau_drm *drm = nouveau_drm(dev);
  274. struct nvif_device *device = &drm->client.device;
  275. struct fb_info *info;
  276. struct nouveau_framebuffer *fb;
  277. struct nouveau_channel *chan;
  278. struct nouveau_bo *nvbo;
  279. struct drm_mode_fb_cmd2 mode_cmd;
  280. int ret;
  281. mode_cmd.width = sizes->surface_width;
  282. mode_cmd.height = sizes->surface_height;
  283. mode_cmd.pitches[0] = mode_cmd.width * (sizes->surface_bpp >> 3);
  284. mode_cmd.pitches[0] = roundup(mode_cmd.pitches[0], 256);
  285. mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
  286. sizes->surface_depth);
  287. ret = nouveau_gem_new(&drm->client, mode_cmd.pitches[0] *
  288. mode_cmd.height, 0, NOUVEAU_GEM_DOMAIN_VRAM,
  289. 0, 0x0000, &nvbo);
  290. if (ret) {
  291. NV_ERROR(drm, "failed to allocate framebuffer\n");
  292. goto out;
  293. }
  294. ret = nouveau_framebuffer_new(dev, &mode_cmd, nvbo, &fb);
  295. if (ret)
  296. goto out_unref;
  297. ret = nouveau_bo_pin(nvbo, TTM_PL_FLAG_VRAM, false);
  298. if (ret) {
  299. NV_ERROR(drm, "failed to pin fb: %d\n", ret);
  300. goto out_unref;
  301. }
  302. ret = nouveau_bo_map(nvbo);
  303. if (ret) {
  304. NV_ERROR(drm, "failed to map fb: %d\n", ret);
  305. goto out_unpin;
  306. }
  307. chan = nouveau_nofbaccel ? NULL : drm->channel;
  308. if (chan && device->info.family >= NV_DEVICE_INFO_V0_TESLA) {
  309. ret = nouveau_vma_new(nvbo, &drm->client.vmm, &fb->vma);
  310. if (ret) {
  311. NV_ERROR(drm, "failed to map fb into chan: %d\n", ret);
  312. chan = NULL;
  313. }
  314. }
  315. info = drm_fb_helper_alloc_fbi(helper);
  316. if (IS_ERR(info)) {
  317. ret = PTR_ERR(info);
  318. goto out_unlock;
  319. }
  320. info->skip_vt_switch = 1;
  321. info->par = fbcon;
  322. /* setup helper */
  323. fbcon->helper.fb = &fb->base;
  324. strcpy(info->fix.id, "nouveaufb");
  325. if (!chan)
  326. info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_DISABLED;
  327. else
  328. info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_COPYAREA |
  329. FBINFO_HWACCEL_FILLRECT |
  330. FBINFO_HWACCEL_IMAGEBLIT;
  331. info->flags |= FBINFO_CAN_FORCE_OUTPUT;
  332. info->fbops = &nouveau_fbcon_sw_ops;
  333. info->fix.smem_start = fb->nvbo->bo.mem.bus.base +
  334. fb->nvbo->bo.mem.bus.offset;
  335. info->fix.smem_len = fb->nvbo->bo.mem.num_pages << PAGE_SHIFT;
  336. info->screen_base = nvbo_kmap_obj_iovirtual(fb->nvbo);
  337. info->screen_size = fb->nvbo->bo.mem.num_pages << PAGE_SHIFT;
  338. drm_fb_helper_fill_fix(info, fb->base.pitches[0],
  339. fb->base.format->depth);
  340. drm_fb_helper_fill_var(info, &fbcon->helper, sizes->fb_width, sizes->fb_height);
  341. /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
  342. if (chan)
  343. nouveau_fbcon_accel_init(dev);
  344. nouveau_fbcon_zfill(dev, fbcon);
  345. /* To allow resizeing without swapping buffers */
  346. NV_INFO(drm, "allocated %dx%d fb: 0x%llx, bo %p\n",
  347. fb->base.width, fb->base.height, fb->nvbo->bo.offset, nvbo);
  348. vga_switcheroo_client_fb_set(dev->pdev, info);
  349. return 0;
  350. out_unlock:
  351. if (chan)
  352. nouveau_vma_del(&fb->vma);
  353. nouveau_bo_unmap(fb->nvbo);
  354. out_unpin:
  355. nouveau_bo_unpin(fb->nvbo);
  356. out_unref:
  357. nouveau_bo_ref(NULL, &fb->nvbo);
  358. out:
  359. return ret;
  360. }
  361. static int
  362. nouveau_fbcon_destroy(struct drm_device *dev, struct nouveau_fbdev *fbcon)
  363. {
  364. struct nouveau_framebuffer *nouveau_fb = nouveau_framebuffer(fbcon->helper.fb);
  365. drm_fb_helper_unregister_fbi(&fbcon->helper);
  366. drm_fb_helper_fini(&fbcon->helper);
  367. if (nouveau_fb && nouveau_fb->nvbo) {
  368. nouveau_vma_del(&nouveau_fb->vma);
  369. nouveau_bo_unmap(nouveau_fb->nvbo);
  370. nouveau_bo_unpin(nouveau_fb->nvbo);
  371. drm_framebuffer_unreference(&nouveau_fb->base);
  372. }
  373. return 0;
  374. }
  375. void nouveau_fbcon_gpu_lockup(struct fb_info *info)
  376. {
  377. struct nouveau_fbdev *fbcon = info->par;
  378. struct nouveau_drm *drm = nouveau_drm(fbcon->helper.dev);
  379. NV_ERROR(drm, "GPU lockup - switching to software fbcon\n");
  380. info->flags |= FBINFO_HWACCEL_DISABLED;
  381. }
  382. static const struct drm_fb_helper_funcs nouveau_fbcon_helper_funcs = {
  383. .fb_probe = nouveau_fbcon_create,
  384. };
  385. static void
  386. nouveau_fbcon_set_suspend_work(struct work_struct *work)
  387. {
  388. struct nouveau_drm *drm = container_of(work, typeof(*drm), fbcon_work);
  389. int state = READ_ONCE(drm->fbcon_new_state);
  390. if (state == FBINFO_STATE_RUNNING)
  391. pm_runtime_get_sync(drm->dev->dev);
  392. console_lock();
  393. if (state == FBINFO_STATE_RUNNING)
  394. nouveau_fbcon_accel_restore(drm->dev);
  395. drm_fb_helper_set_suspend(&drm->fbcon->helper, state);
  396. if (state != FBINFO_STATE_RUNNING)
  397. nouveau_fbcon_accel_save_disable(drm->dev);
  398. console_unlock();
  399. if (state == FBINFO_STATE_RUNNING) {
  400. pm_runtime_mark_last_busy(drm->dev->dev);
  401. pm_runtime_put_sync(drm->dev->dev);
  402. }
  403. }
  404. void
  405. nouveau_fbcon_set_suspend(struct drm_device *dev, int state)
  406. {
  407. struct nouveau_drm *drm = nouveau_drm(dev);
  408. if (!drm->fbcon)
  409. return;
  410. drm->fbcon_new_state = state;
  411. /* Since runtime resume can happen as a result of a sysfs operation,
  412. * it's possible we already have the console locked. So handle fbcon
  413. * init/deinit from a seperate work thread
  414. */
  415. schedule_work(&drm->fbcon_work);
  416. }
  417. int
  418. nouveau_fbcon_init(struct drm_device *dev)
  419. {
  420. struct nouveau_drm *drm = nouveau_drm(dev);
  421. struct nouveau_fbdev *fbcon;
  422. int preferred_bpp = nouveau_fbcon_bpp;
  423. int ret;
  424. if (!dev->mode_config.num_crtc ||
  425. (dev->pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
  426. return 0;
  427. fbcon = kzalloc(sizeof(struct nouveau_fbdev), GFP_KERNEL);
  428. if (!fbcon)
  429. return -ENOMEM;
  430. drm->fbcon = fbcon;
  431. INIT_WORK(&drm->fbcon_work, nouveau_fbcon_set_suspend_work);
  432. drm_fb_helper_prepare(dev, &fbcon->helper, &nouveau_fbcon_helper_funcs);
  433. ret = drm_fb_helper_init(dev, &fbcon->helper, 4);
  434. if (ret)
  435. goto free;
  436. ret = drm_fb_helper_single_add_all_connectors(&fbcon->helper);
  437. if (ret)
  438. goto fini;
  439. if (preferred_bpp != 8 && preferred_bpp != 16 && preferred_bpp != 32) {
  440. if (drm->client.device.info.ram_size <= 32 * 1024 * 1024)
  441. preferred_bpp = 8;
  442. else
  443. if (drm->client.device.info.ram_size <= 64 * 1024 * 1024)
  444. preferred_bpp = 16;
  445. else
  446. preferred_bpp = 32;
  447. }
  448. /* disable all the possible outputs/crtcs before entering KMS mode */
  449. if (!drm_drv_uses_atomic_modeset(dev))
  450. drm_helper_disable_unused_functions(dev);
  451. ret = drm_fb_helper_initial_config(&fbcon->helper, preferred_bpp);
  452. if (ret)
  453. goto fini;
  454. if (fbcon->helper.fbdev)
  455. fbcon->helper.fbdev->pixmap.buf_align = 4;
  456. return 0;
  457. fini:
  458. drm_fb_helper_fini(&fbcon->helper);
  459. free:
  460. kfree(fbcon);
  461. return ret;
  462. }
  463. void
  464. nouveau_fbcon_fini(struct drm_device *dev)
  465. {
  466. struct nouveau_drm *drm = nouveau_drm(dev);
  467. if (!drm->fbcon)
  468. return;
  469. nouveau_fbcon_accel_fini(dev);
  470. nouveau_fbcon_destroy(dev, drm->fbcon);
  471. kfree(drm->fbcon);
  472. drm->fbcon = NULL;
  473. }