intel.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396
  1. /*
  2. * Intel Ironlake (Gen5) hardware cursor.
  3. *
  4. * The Ironlake display engine fetches the cursor through the global GTT, so
  5. * enabling it needs more than a register write: the 64x64 ARGB image must be
  6. * mapped at a free GTT slot. BAR0 contains the MMIO registers followed by
  7. * the GTT at +2 MB; the BIOS has already mapped the VBE framebuffer at GTT
  8. * offset 0, and the table has free entries above it.
  9. *
  10. * Register semantics follow the Linux i915 Ironlake path:
  11. * - CURACNTR/CURABASE/CURAPOS are per-pipe (A at 0x70080, B at 0x700c0).
  12. * - 64x64 ARGB8888 cursor, MSB A:R:G:B, hotspot at (0,0).
  13. * - CURCNTR bit 31 enables, mode 0x27 is 64x64 ARGB, bits 29:28 hold the
  14. * pipe select. CURBASE is written after CURPOS to arm the update.
  15. * - The GTT PTE is the physical page, its bits 35:32 in PTE bits 7:4, the
  16. * uncached mapping type (0) and the valid bit (1).
  17. */
  18. #include "intel.h"
  19. #include "cursor_shape.h"
  20. #include "mm.h"
  21. #include "paging.h"
  22. #include "pci.h"
  23. #include "serial.h"
  24. #include "vga.h"
  25. #define INTEL_IRONLAKE_D 0x0042
  26. #define INTEL_IRONLAKE_M 0x0046
  27. #define INTEL_BAR0 0x10
  28. #define INTEL_BAR2 0x18
  29. #define INTEL_GTT_OFFSET 0x200000
  30. #define INTEL_PGETBL_CTL 0x2020
  31. /* Display pipe registers. */
  32. #define DSPACNTR 0x70180
  33. #define DSPASURF 0x7019c
  34. #define DSPBCNTR 0x71180
  35. #define DSPBSURF 0x7119c
  36. /* Cursor registers (A; B is +0x40). */
  37. #define CURACNTR 0x70080
  38. #define CURABASE 0x70084
  39. #define CURAPOS 0x70088
  40. #define CURASURFLIVE 0x700ac
  41. #define CUR_PIPE_B 0x40
  42. #define DSP_PLANE_ENABLE (1u << 31)
  43. #define CURSOR_ENABLE (1u << 31)
  44. #define CURSOR_GAMMA_ENABLE (1u << 26)
  45. #define CURSOR_MODE_64_ARGB 0x27u
  46. #define CURSOR_PIPE_SEL_SHIFT 28
  47. #define CUR_SIZE 64
  48. #define CUR_BYTES (CUR_SIZE * CUR_SIZE * 4)
  49. #define CUR_PAGES (CUR_BYTES / 4096)
  50. #define GTT_PTE_VALID 0x1u
  51. #define GTT_PTE_UNCACHED 0x0u
  52. static unsigned int intel_mmio;
  53. static volatile unsigned int *intel_gtt;
  54. static unsigned int intel_gtt_entries;
  55. static unsigned int intel_gtt_limit;
  56. static unsigned int intel_cursor_gtt;
  57. static unsigned int intel_cursor_phys;
  58. static unsigned int intel_pipe_mask;
  59. static int intel_probe_ok;
  60. static int intel_cursor_ok;
  61. static inline unsigned int mmio_read(unsigned int ofs)
  62. {
  63. return *(volatile unsigned int *)(intel_mmio + ofs);
  64. }
  65. static inline void mmio_write(unsigned int ofs, unsigned int val)
  66. {
  67. *(volatile unsigned int *)(intel_mmio + ofs) = val;
  68. }
  69. static unsigned int intel_bar_base(unsigned int value)
  70. {
  71. if (value & 1)
  72. return 0;
  73. return value & 0xFFFFFFF0u;
  74. }
  75. static unsigned int intel_bar_size(unsigned int bus, unsigned int dev,
  76. unsigned int reg)
  77. {
  78. unsigned int save, raw;
  79. save = pci_cfg_read32(bus, dev, 0, reg);
  80. pci_cfg_write32(bus, dev, 0, reg, 0xFFFFFFFFu);
  81. raw = pci_cfg_read32(bus, dev, 0, reg);
  82. pci_cfg_write32(bus, dev, 0, reg, save);
  83. if ((save & 1) || !(raw & 0xFFFFFFF0u))
  84. return 0;
  85. return (~(raw & 0xFFFFFFF0u)) + 1;
  86. }
  87. static unsigned int gtt_size_from_pgetbl(unsigned int pgetbl)
  88. {
  89. switch (pgetbl & 0xE) {
  90. case 0: return 512 * 1024;
  91. case 1: return 256 * 1024;
  92. case 2: return 128 * 1024;
  93. case 3: return 1024 * 1024;
  94. case 4: return 2048 * 1024;
  95. case 5: return 1536 * 1024;
  96. default: return 512 * 1024;
  97. }
  98. }
  99. /* The BIOS leaves unused PTEs as all-ones rather than clearing the valid
  100. * bit, so test both forms. */
  101. static int gtt_pte_free(unsigned int pte)
  102. {
  103. return pte == 0xFFFFFFFFu || !(pte & GTT_PTE_VALID);
  104. }
  105. /* Find four consecutive invalid PTEs, preferably just above the visible
  106. * framebuffer and 64 KB aligned (the VT-d workaround alignment). */
  107. static unsigned int gtt_find_slot(void)
  108. {
  109. unsigned int i, j;
  110. unsigned int limit = intel_gtt_limit ? intel_gtt_limit
  111. : intel_gtt_entries;
  112. unsigned int fb_pages;
  113. if (limit < 32)
  114. return 0;
  115. fb_pages = (vga_fb_pitch() * vga_fb_height() + 4095) / 4096;
  116. i = (fb_pages + 15) & ~15u;
  117. if (i < 16)
  118. i = 16;
  119. for (; i + CUR_PAGES <= limit; i += 16) {
  120. for (j = 0; j < CUR_PAGES; j++)
  121. if (!gtt_pte_free(intel_gtt[i + j]))
  122. break;
  123. if (j == CUR_PAGES)
  124. return i;
  125. }
  126. /* Fallback: high entries inside the aperture. */
  127. i = (limit - 64) & ~15u;
  128. while (i >= 16) {
  129. for (j = 0; j < CUR_PAGES; j++)
  130. if (!gtt_pte_free(intel_gtt[i + j]))
  131. break;
  132. if (j == CUR_PAGES)
  133. return i;
  134. i -= 16;
  135. }
  136. return 0;
  137. }
  138. /* The cursor fetch is happy with 4 KB on Ironlake unless VT-d is active;
  139. * still give it a 64 KB-aligned physical block so the VT-d workaround
  140. * alignment is covered as well. */
  141. static int intel_alloc_cursor(void)
  142. {
  143. unsigned int raw, aligned, pad, i;
  144. raw = mm_alloc_pages(32);
  145. if (!raw)
  146. return -1;
  147. aligned = (raw + 0xFFFFu) & ~0xFFFFu;
  148. pad = (aligned - raw) >> 12;
  149. for (i = 0; i < pad; i++)
  150. mm_free_page(raw + i * 4096);
  151. for (i = pad + CUR_PAGES; i < 32; i++)
  152. mm_free_page(raw + i * 4096);
  153. intel_cursor_phys = aligned;
  154. return 0;
  155. }
  156. static void intel_fill_cursor(unsigned int phys)
  157. {
  158. unsigned int *img = (unsigned int *)phys;
  159. unsigned int i, r, c;
  160. for (i = 0; i < CUR_SIZE * CUR_SIZE; i++)
  161. img[i] = 0;
  162. for (r = 0; r < CURSOR_SHAPE_HEIGHT; r++) {
  163. unsigned short fill = cursor_shape_fill[r];
  164. unsigned short outline = cursor_shape_outline[r];
  165. for (c = 0; c < CURSOR_SHAPE_WIDTH; c++) {
  166. unsigned short bit = (unsigned short)(0x8000u >> c);
  167. unsigned int *px = &img[r * CUR_SIZE + c];
  168. if (fill & bit)
  169. *px = 0xFFFFFFFFu; /* opaque white */
  170. else if (outline & bit)
  171. *px = 0xFF000000u; /* opaque black */
  172. }
  173. }
  174. /* The GTT mapping is uncached, so push the WB image out to DRAM. */
  175. __asm__ volatile ("wbinvd" ::: "memory");
  176. }
  177. static int intel_map_cursor(unsigned int slot)
  178. {
  179. unsigned int i;
  180. for (i = 0; i < CUR_PAGES; i++) {
  181. unsigned int pa = intel_cursor_phys + i * 4096;
  182. unsigned int pte = (pa & 0xFFFFF000u) |
  183. ((pa >> 28) & 0xF0u) |
  184. GTT_PTE_UNCACHED | GTT_PTE_VALID;
  185. intel_gtt[slot + i] = pte;
  186. }
  187. /* Posting read: also makes the display engine invalidate its TLB. */
  188. (void)intel_gtt[slot + CUR_PAGES - 1];
  189. /* Do not point the cursor plane at a slot the GTT did not accept. */
  190. for (i = 0; i < CUR_PAGES; i++) {
  191. unsigned int pa = intel_cursor_phys + i * 4096;
  192. if ((intel_gtt[slot + i] & 0xFFFFF000u) !=
  193. (pa & 0xFFFFF000u))
  194. return -1;
  195. }
  196. return 0;
  197. }
  198. static unsigned int cursor_ctrl(unsigned int pipe)
  199. {
  200. return CURSOR_ENABLE | CURSOR_GAMMA_ENABLE |
  201. CURSOR_MODE_64_ARGB | (pipe << CURSOR_PIPE_SEL_SHIFT);
  202. }
  203. void intel_init(unsigned int bus, unsigned int dev, unsigned int device_id)
  204. {
  205. unsigned int bar0, bar0_size, bar2_base, bar2_size;
  206. unsigned int lfb, lfb_gtt = 0xFFFFFFFFu;
  207. unsigned int pgetbl, gtt_size;
  208. unsigned int dspa, dspb, surfa, surfb;
  209. unsigned int slot;
  210. intel_probe_ok = 0;
  211. intel_cursor_ok = 0;
  212. intel_mmio = 0;
  213. intel_gtt = 0;
  214. intel_pipe_mask = 0;
  215. if (device_id != INTEL_IRONLAKE_D && device_id != INTEL_IRONLAKE_M)
  216. return;
  217. bar0 = pci_cfg_read32(bus, dev, 0, INTEL_BAR0);
  218. if ((bar0 & 1) || !(bar0 & 0xFFFFFFF0u))
  219. return;
  220. if ((bar0 & 0x6) == 0x4) {
  221. /* 64-bit BAR; the kernel cannot address anything above 4 GB. */
  222. if (pci_cfg_read32(bus, dev, 0, INTEL_BAR0 + 4))
  223. return;
  224. }
  225. bar0_size = intel_bar_size(bus, dev, INTEL_BAR0);
  226. if (bar0_size < 0x400000)
  227. bar0_size = 0x400000;
  228. if (bar0_size > 0x1000000)
  229. bar0_size = 0x1000000;
  230. intel_mmio = intel_bar_base(bar0);
  231. paging_map_mmio(intel_mmio, bar0_size);
  232. pgetbl = mmio_read(INTEL_PGETBL_CTL);
  233. if (pgetbl == 0xFFFFFFFFu) {
  234. serial_puts(SERIAL_COM1, "intel: no display MMIO\n");
  235. return;
  236. }
  237. /* A kexec leaves the previous kernel's cursor enabled, pointing at a
  238. * GTT slot this kernel may no longer own. Clear both cursor planes;
  239. * the new cursor is enabled later from mouse_cursor_setup(). */
  240. mmio_write(CURACNTR, 0);
  241. mmio_write(CURACNTR + CUR_PIPE_B, 0);
  242. gtt_size = gtt_size_from_pgetbl(pgetbl);
  243. intel_gtt_entries = gtt_size / 4;
  244. intel_gtt = (volatile unsigned int *)(intel_mmio + INTEL_GTT_OFFSET);
  245. bar2_base = intel_bar_base(pci_cfg_read32(bus, dev, 0, INTEL_BAR2));
  246. bar2_size = intel_bar_size(bus, dev, INTEL_BAR2);
  247. intel_gtt_limit = intel_gtt_entries;
  248. if (bar2_size >= 0x1000000 && bar2_size / 4096 < intel_gtt_limit)
  249. intel_gtt_limit = bar2_size / 4096;
  250. lfb = vga_fb_lfb_addr();
  251. if (bar2_base && lfb >= bar2_base)
  252. lfb_gtt = (lfb - bar2_base) & 0xFFFFF000u;
  253. dspa = mmio_read(DSPACNTR);
  254. dspb = mmio_read(DSPBCNTR);
  255. surfa = mmio_read(DSPASURF) & 0xFFFFF000u;
  256. surfb = mmio_read(DSPBSURF) & 0xFFFFF000u;
  257. if ((dspa & DSP_PLANE_ENABLE) && surfa == lfb_gtt)
  258. intel_pipe_mask |= 1;
  259. if ((dspb & DSP_PLANE_ENABLE) && surfb == lfb_gtt)
  260. intel_pipe_mask |= 2;
  261. if (!intel_pipe_mask) {
  262. /* No surface match (or an unexpected BIOS layout): use every
  263. * pipe the VBIOS left enabled. */
  264. if (dspa & DSP_PLANE_ENABLE)
  265. intel_pipe_mask |= 1;
  266. if (dspb & DSP_PLANE_ENABLE)
  267. intel_pipe_mask |= 2;
  268. }
  269. if (!intel_pipe_mask) {
  270. serial_puts(SERIAL_COM1, "intel: no enabled display pipe\n");
  271. return;
  272. }
  273. slot = gtt_find_slot();
  274. if (!slot) {
  275. serial_puts(SERIAL_COM1, "intel: no free GTT slot\n");
  276. return;
  277. }
  278. if (intel_alloc_cursor() != 0) {
  279. serial_puts(SERIAL_COM1, "intel: no cursor memory\n");
  280. return;
  281. }
  282. intel_cursor_gtt = slot * 4096;
  283. intel_fill_cursor(intel_cursor_phys);
  284. if (intel_map_cursor(slot) != 0) {
  285. serial_puts(SERIAL_COM1, "intel: GTT write did not stick\n");
  286. return;
  287. }
  288. serial_puts(SERIAL_COM1, "intel: Ironlake GTT ");
  289. serial_puthex(SERIAL_COM1, intel_gtt_entries * 4096);
  290. serial_puts(SERIAL_COM1, ", lfb gtt ");
  291. serial_puthex(SERIAL_COM1, lfb_gtt);
  292. serial_puts(SERIAL_COM1, ", pipe ");
  293. serial_puthex(SERIAL_COM1, intel_pipe_mask);
  294. serial_puts(SERIAL_COM1, ", cursor ");
  295. serial_puthex(SERIAL_COM1, intel_cursor_gtt);
  296. serial_puts(SERIAL_COM1, "\n");
  297. intel_probe_ok = 1;
  298. }
  299. int intel_available(void)
  300. {
  301. return intel_probe_ok;
  302. }
  303. static void intel_cursor_program(unsigned int pipe, unsigned int x,
  304. unsigned int y)
  305. {
  306. unsigned int base = CURACNTR + (pipe ? CUR_PIPE_B : 0);
  307. unsigned int pos = (x & 0x7FFFu) | ((y & 0x7FFFu) << 16);
  308. mmio_write(base, cursor_ctrl(pipe));
  309. mmio_write(base + 8, pos); /* CURAPOS */
  310. mmio_write(base + 4, intel_cursor_gtt); /* CURABASE */
  311. (void)mmio_read(base + 4);
  312. }
  313. int intel_cursor_setup(unsigned int x, unsigned int y)
  314. {
  315. if (!intel_probe_ok || !intel_cursor_gtt)
  316. return -1;
  317. if (intel_pipe_mask & 1)
  318. intel_cursor_program(0, x, y);
  319. if (intel_pipe_mask & 2)
  320. intel_cursor_program(1, x, y);
  321. serial_puts(SERIAL_COM1, "intel: cursor enabled, live ");
  322. serial_puthex(SERIAL_COM1, mmio_read(CURASURFLIVE));
  323. serial_puts(SERIAL_COM1, "\n");
  324. intel_cursor_ok = 1;
  325. return 0;
  326. }
  327. void intel_cursor_move(unsigned int x, unsigned int y)
  328. {
  329. unsigned int pos;
  330. if (!intel_cursor_ok)
  331. return;
  332. pos = (x & 0x7FFFu) | ((y & 0x7FFFu) << 16);
  333. if (intel_pipe_mask & 1) {
  334. mmio_write(CURAPOS, pos);
  335. mmio_write(CURABASE, intel_cursor_gtt);
  336. }
  337. if (intel_pipe_mask & 2) {
  338. mmio_write(CURAPOS + CUR_PIPE_B, pos);
  339. mmio_write(CURABASE + CUR_PIPE_B, intel_cursor_gtt);
  340. }
  341. }