开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
radeon_cp.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：35k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

radeon_cp.c：源码内容
  1. /* radeon_cp.c -- CP support for Radeon -*- linux-c -*-
  2.  *
  3.  * Copyright 2000 Precision Insight, Inc., Cedar Park, Texas.
  4.  * Copyright 2000 VA Linux Systems, Inc., Fremont, California.
  5.  * All Rights Reserved.
  6.  *
  7.  * Permission is hereby granted, free of charge, to any person obtaining a
  8.  * copy of this software and associated documentation files (the "Software"),
  9.  * to deal in the Software without restriction, including without limitation
  10.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11.  * and/or sell copies of the Software, and to permit persons to whom the
  12.  * Software is furnished to do so, subject to the following conditions:
  13.  *
  14.  * The above copyright notice and this permission notice (including the next
  15.  * paragraph) shall be included in all copies or substantial portions of the
  16.  * Software.
  17.  *
  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21.  * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  22.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  23.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24.  * DEALINGS IN THE SOFTWARE.
  25.  *
  26.  * Authors:
  27.  *   Kevin E. Martin <martin@valinux.com>
  28.  *   Gareth Hughes <gareth@valinux.com>
  29.  *
  30.  */
  32. #define __NO_VERSION__
  33. #include "drmP.h"
  34. #include "radeon_drv.h"
  36. #include <linux/interrupt.h> /* For task queue support */
  37. #include <linux/delay.h>
  39. #define RADEON_FIFO_DEBUG 0
  42. /* CP microcode (from ATI) */
  43. static u32 radeon_cp_microcode[][2] = {
  44. { 0x21007000, 0000000000 },
  45. { 0x20007000, 0000000000 },
  46. { 0x000000b4, 0x00000004 },
  47. { 0x000000b8, 0x00000004 },
  48. { 0x6f5b4d4c, 0000000000 },
  49. { 0x4c4c427f, 0000000000 },
  50. { 0x5b568a92, 0000000000 },
  51. { 0x4ca09c6d, 0000000000 },
  52. { 0xad4c4c4c, 0000000000 },
  53. { 0x4ce1af3d, 0000000000 },
  54. { 0xd8afafaf, 0000000000 },
  55. { 0xd64c4cdc, 0000000000 },
  56. { 0x4cd10d10, 0000000000 },
  57. { 0x000f0000, 0x00000016 },
  58. { 0x362f242d, 0000000000 },
  59. { 0x00000012, 0x00000004 },
  60. { 0x000f0000, 0x00000016 },
  61. { 0x362f282d, 0000000000 },
  62. { 0x000380e7, 0x00000002 },
  63. { 0x04002c97, 0x00000002 },
  64. { 0x000f0001, 0x00000016 },
  65. { 0x333a3730, 0000000000 },
  66. { 0x000077ef, 0x00000002 },
  67. { 0x00061000, 0x00000002 },
  68. { 0x00000021, 0x0000001a },
  69. { 0x00004000, 0x0000001e },
  70. { 0x00061000, 0x00000002 },
  71. { 0x00000021, 0x0000001a },
  72. { 0x00004000, 0x0000001e },
  73. { 0x00061000, 0x00000002 },
  74. { 0x00000021, 0x0000001a },
  75. { 0x00004000, 0x0000001e },
  76. { 0x00000017, 0x00000004 },
  77. { 0x0003802b, 0x00000002 },
  78. { 0x040067e0, 0x00000002 },
  79. { 0x00000017, 0x00000004 },
  80. { 0x000077e0, 0x00000002 },
  81. { 0x00065000, 0x00000002 },
  82. { 0x000037e1, 0x00000002 },
  83. { 0x040067e1, 0x00000006 },
  84. { 0x000077e0, 0x00000002 },
  85. { 0x000077e1, 0x00000002 },
  86. { 0x000077e1, 0x00000006 },
  87. { 0xffffffff, 0000000000 },
  88. { 0x10000000, 0000000000 },
  89. { 0x0003802b, 0x00000002 },
  90. { 0x040067e0, 0x00000006 },
  91. { 0x00007675, 0x00000002 },
  92. { 0x00007676, 0x00000002 },
  93. { 0x00007677, 0x00000002 },
  94. { 0x00007678, 0x00000006 },
  95. { 0x0003802c, 0x00000002 },
  96. { 0x04002676, 0x00000002 },
  97. { 0x00007677, 0x00000002 },
  98. { 0x00007678, 0x00000006 },
  99. { 0x0000002f, 0x00000018 },
  100. { 0x0000002f, 0x00000018 },
  101. { 0000000000, 0x00000006 },
  102. { 0x00000030, 0x00000018 },
  103. { 0x00000030, 0x00000018 },
  104. { 0000000000, 0x00000006 },
  105. { 0x01605000, 0x00000002 },
  106. { 0x00065000, 0x00000002 },
  107. { 0x00098000, 0x00000002 },
  108. { 0x00061000, 0x00000002 },
  109. { 0x64c0603e, 0x00000004 },
  110. { 0x000380e6, 0x00000002 },
  111. { 0x040025c5, 0x00000002 },
  112. { 0x00080000, 0x00000016 },
  113. { 0000000000, 0000000000 },
  114. { 0x0400251d, 0x00000002 },
  115. { 0x00007580, 0x00000002 },
  116. { 0x00067581, 0x00000002 },
  117. { 0x04002580, 0x00000002 },
  118. { 0x00067581, 0x00000002 },
  119. { 0x00000049, 0x00000004 },
  120. { 0x00005000, 0000000000 },
  121. { 0x000380e6, 0x00000002 },
  122. { 0x040025c5, 0x00000002 },
  123. { 0x00061000, 0x00000002 },
  124. { 0x0000750e, 0x00000002 },
  125. { 0x00019000, 0x00000002 },
  126. { 0x00011055, 0x00000014 },
  127. { 0x00000055, 0x00000012 },
  128. { 0x0400250f, 0x00000002 },
  129. { 0x0000504f, 0x00000004 },
  130. { 0x000380e6, 0x00000002 },
  131. { 0x040025c5, 0x00000002 },
  132. { 0x00007565, 0x00000002 },
  133. { 0x00007566, 0x00000002 },
  134. { 0x00000058, 0x00000004 },
  135. { 0x000380e6, 0x00000002 },
  136. { 0x040025c5, 0x00000002 },
  137. { 0x01e655b4, 0x00000002 },
  138. { 0x4401b0e4, 0x00000002 },
  139. { 0x01c110e4, 0x00000002 },
  140. { 0x26667066, 0x00000018 },
  141. { 0x040c2565, 0x00000002 },
  142. { 0x00000066, 0x00000018 },
  143. { 0x04002564, 0x00000002 },
  144. { 0x00007566, 0x00000002 },
  145. { 0x0000005d, 0x00000004 },
  146. { 0x00401069, 0x00000008 },
  147. { 0x00101000, 0x00000002 },
  148. { 0x000d80ff, 0x00000002 },
  149. { 0x0080006c, 0x00000008 },
  150. { 0x000f9000, 0x00000002 },
  151. { 0x000e00ff, 0x00000002 },
  152. { 0000000000, 0x00000006 },
  153. { 0x0000008f, 0x00000018 },
  154. { 0x0000005b, 0x00000004 },
  155. { 0x000380e6, 0x00000002 },
  156. { 0x040025c5, 0x00000002 },
  157. { 0x00007576, 0x00000002 },
  158. { 0x00065000, 0x00000002 },
  159. { 0x00009000, 0x00000002 },
  160. { 0x00041000, 0x00000002 },
  161. { 0x0c00350e, 0x00000002 },
  162. { 0x00049000, 0x00000002 },
  163. { 0x00051000, 0x00000002 },
  164. { 0x01e785f8, 0x00000002 },
  165. { 0x00200000, 0x00000002 },
  166. { 0x0060007e, 0x0000000c },
  167. { 0x00007563, 0x00000002 },
  168. { 0x006075f0, 0x00000021 },
  169. { 0x20007073, 0x00000004 },
  170. { 0x00005073, 0x00000004 },
  171. { 0x000380e6, 0x00000002 },
  172. { 0x040025c5, 0x00000002 },
  173. { 0x00007576, 0x00000002 },
  174. { 0x00007577, 0x00000002 },
  175. { 0x0000750e, 0x00000002 },
  176. { 0x0000750f, 0x00000002 },
  177. { 0x00a05000, 0x00000002 },
  178. { 0x00600083, 0x0000000c },
  179. { 0x006075f0, 0x00000021 },
  180. { 0x000075f8, 0x00000002 },
  181. { 0x00000083, 0x00000004 },
  182. { 0x000a750e, 0x00000002 },
  183. { 0x000380e6, 0x00000002 },
  184. { 0x040025c5, 0x00000002 },
  185. { 0x0020750f, 0x00000002 },
  186. { 0x00600086, 0x00000004 },
  187. { 0x00007570, 0x00000002 },
  188. { 0x00007571, 0x00000002 },
  189. { 0x00007572, 0x00000006 },
  190. { 0x000380e6, 0x00000002 },
  191. { 0x040025c5, 0x00000002 },
  192. { 0x00005000, 0x00000002 },
  193. { 0x00a05000, 0x00000002 },
  194. { 0x00007568, 0x00000002 },
  195. { 0x00061000, 0x00000002 },
  196. { 0x00000095, 0x0000000c },
  197. { 0x00058000, 0x00000002 },
  198. { 0x0c607562, 0x00000002 },
  199. { 0x00000097, 0x00000004 },
  200. { 0x000380e6, 0x00000002 },
  201. { 0x040025c5, 0x00000002 },
  202. { 0x00600096, 0x00000004 },
  203. { 0x400070e5, 0000000000 },
  204. { 0x000380e6, 0x00000002 },
  205. { 0x040025c5, 0x00000002 },
  206. { 0x000380e5, 0x00000002 },
  207. { 0x000000a8, 0x0000001c },
  208. { 0x000650aa, 0x00000018 },
  209. { 0x040025bb, 0x00000002 },
  210. { 0x000610ab, 0x00000018 },
  211. { 0x040075bc, 0000000000 },
  212. { 0x000075bb, 0x00000002 },
  213. { 0x000075bc, 0000000000 },
  214. { 0x00090000, 0x00000006 },
  215. { 0x00090000, 0x00000002 },
  216. { 0x000d8002, 0x00000006 },
  217. { 0x00007832, 0x00000002 },
  218. { 0x00005000, 0x00000002 },
  219. { 0x000380e7, 0x00000002 },
  220. { 0x04002c97, 0x00000002 },
  221. { 0x00007820, 0x00000002 },
  222. { 0x00007821, 0x00000002 },
  223. { 0x00007800, 0000000000 },
  224. { 0x01200000, 0x00000002 },
  225. { 0x20077000, 0x00000002 },
  226. { 0x01200000, 0x00000002 },
  227. { 0x20007000, 0x00000002 },
  228. { 0x00061000, 0x00000002 },
  229. { 0x0120751b, 0x00000002 },
  230. { 0x8040750a, 0x00000002 },
  231. { 0x8040750b, 0x00000002 },
  232. { 0x00110000, 0x00000002 },
  233. { 0x000380e5, 0x00000002 },
  234. { 0x000000c6, 0x0000001c },
  235. { 0x000610ab, 0x00000018 },
  236. { 0x844075bd, 0x00000002 },
  237. { 0x000610aa, 0x00000018 },
  238. { 0x840075bb, 0x00000002 },
  239. { 0x000610ab, 0x00000018 },
  240. { 0x844075bc, 0x00000002 },
  241. { 0x000000c9, 0x00000004 },
  242. { 0x804075bd, 0x00000002 },
  243. { 0x800075bb, 0x00000002 },
  244. { 0x804075bc, 0x00000002 },
  245. { 0x00108000, 0x00000002 },
  246. { 0x01400000, 0x00000002 },
  247. { 0x006000cd, 0x0000000c },
  248. { 0x20c07000, 0x00000020 },
  249. { 0x000000cf, 0x00000012 },
  250. { 0x00800000, 0x00000006 },
  251. { 0x0080751d, 0x00000006 },
  252. { 0000000000, 0000000000 },
  253. { 0x0000775c, 0x00000002 },
  254. { 0x00a05000, 0x00000002 },
  255. { 0x00661000, 0x00000002 },
  256. { 0x0460275d, 0x00000020 },
  257. { 0x00004000, 0000000000 },
  258. { 0x01e00830, 0x00000002 },
  259. { 0x21007000, 0000000000 },
  260. { 0x6464614d, 0000000000 },
  261. { 0x69687420, 0000000000 },
  262. { 0x00000073, 0000000000 },
  263. { 0000000000, 0000000000 },
  264. { 0x00005000, 0x00000002 },
  265. { 0x000380d0, 0x00000002 },
  266. { 0x040025e0, 0x00000002 },
  267. { 0x000075e1, 0000000000 },
  268. { 0x00000001, 0000000000 },
  269. { 0x000380e0, 0x00000002 },
  270. { 0x04002394, 0x00000002 },
  271. { 0x00005000, 0000000000 },
  272. { 0000000000, 0000000000 },
  273. { 0000000000, 0000000000 },
  274. { 0x00000008, 0000000000 },
  275. { 0x00000004, 0000000000 },
  276. { 0000000000, 0000000000 },
  277. { 0000000000, 0000000000 },
  278. { 0000000000, 0000000000 },
  279. { 0000000000, 0000000000 },
  280. { 0000000000, 0000000000 },
  281. { 0000000000, 0000000000 },
  282. { 0000000000, 0000000000 },
  283. { 0000000000, 0000000000 },
  284. { 0000000000, 0000000000 },
  285. { 0000000000, 0000000000 },
  286. { 0000000000, 0000000000 },
  287. { 0000000000, 0000000000 },
  288. { 0000000000, 0000000000 },
  289. { 0000000000, 0000000000 },
  290. { 0000000000, 0000000000 },
  291. { 0000000000, 0000000000 },
  292. { 0000000000, 0000000000 },
  293. { 0000000000, 0000000000 },
  294. { 0000000000, 0000000000 },
  295. { 0000000000, 0000000000 },
  296. { 0000000000, 0000000000 },
  297. { 0000000000, 0000000000 },
  298. { 0000000000, 0000000000 },
  299. { 0000000000, 0000000000 },
  300. };
  303. #define DO_IOREMAP(_m) (_m)->handle = drm_ioremap((_m)->offset, (_m)->size)
  305. #define DO_IOREMAPFREE(_m)
  306. do {
  307. if ((_m)->handle && (_m)->size)
  308. drm_ioremapfree((_m)->handle, (_m)->size);
  309. } while (0)
  311. #define DO_FIND_MAP(_m, _o)
  312. do {
  313. int _i;
  314. for (_i = 0; _i < dev->map_count; _i++) {
  315. if (dev->maplist[_i]->offset == _o) {
  316. _m = dev->maplist[_i];
  317. break;
  318. }
  319. }
  320. } while (0)
  323. int RADEON_READ_PLL(drm_device_t *dev, int addr)
  324. {
  325. drm_radeon_private_t *dev_priv = dev->dev_private;
  327. RADEON_WRITE8(RADEON_CLOCK_CNTL_INDEX, addr & 0x1f);
  328. return RADEON_READ(RADEON_CLOCK_CNTL_DATA);
  329. }
  331. #if RADEON_FIFO_DEBUG
  332. static void radeon_status( drm_radeon_private_t *dev_priv )
  333. {
  334. printk( "%s:n", __FUNCTION__ );
  335. printk( "RBBM_STATUS = 0x%08xn",
  336. (unsigned int)RADEON_READ( RADEON_RBBM_STATUS ) );
  337. printk( "CP_RB_RTPR = 0x%08xn",
  338. (unsigned int)RADEON_READ( RADEON_CP_RB_RPTR ) );
  339. printk( "CP_RB_WTPR = 0x%08xn",
  340. (unsigned int)RADEON_READ( RADEON_CP_RB_WPTR ) );
  341. }
  342. #endif
  345. /* ================================================================
  346.  * Engine, FIFO control
  347.  */
  349. static int radeon_do_pixcache_flush( drm_radeon_private_t *dev_priv )
  350. {
  351. u32 tmp;
  352. int i;
  354. tmp  = RADEON_READ( RADEON_RB2D_DSTCACHE_CTLSTAT );
  355. tmp |= RADEON_RB2D_DC_FLUSH_ALL;
  356. RADEON_WRITE( RADEON_RB2D_DSTCACHE_CTLSTAT, tmp );
  358. for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
  359. if ( !(RADEON_READ( RADEON_RB2D_DSTCACHE_CTLSTAT )
  360.        & RADEON_RB2D_DC_BUSY) ) {
  361. return 0;
  362. }
  363. udelay( 1 );
  364. }
  366. #if RADEON_FIFO_DEBUG
  367. DRM_ERROR( "failed!n" );
  368. radeon_status( dev_priv );
  369. #endif
  370. return -EBUSY;
  371. }
  373. static int radeon_do_wait_for_fifo( drm_radeon_private_t *dev_priv,
  374.     int entries )
  375. {
  376. int i;
  378. for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
  379. int slots = ( RADEON_READ( RADEON_RBBM_STATUS )
  380.       & RADEON_RBBM_FIFOCNT_MASK );
  381. if ( slots >= entries ) return 0;
  382. udelay( 1 );
  383. }
  385. #if RADEON_FIFO_DEBUG
  386. DRM_ERROR( "failed!n" );
  387. radeon_status( dev_priv );
  388. #endif
  389. return -EBUSY;
  390. }
  392. static int radeon_do_wait_for_idle( drm_radeon_private_t *dev_priv )
  393. {
  394. int i, ret;
  396. ret = radeon_do_wait_for_fifo( dev_priv, 64 );
  397. if ( ret < 0 ) return ret;
  399. for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
  400. if ( !(RADEON_READ( RADEON_RBBM_STATUS )
  401.        & RADEON_RBBM_ACTIVE) ) {
  402. radeon_do_pixcache_flush( dev_priv );
  403. return 0;
  404. }
  405. udelay( 1 );
  406. }
  408. #if RADEON_FIFO_DEBUG
  409. DRM_ERROR( "failed!n" );
  410. radeon_status( dev_priv );
  411. #endif
  412. return -EBUSY;
  413. }
  416. /* ================================================================
  417.  * CP control, initialization
  418.  */
  420. /* Load the microcode for the CP */
  421. static void radeon_cp_load_microcode( drm_radeon_private_t *dev_priv )
  422. {
  423. int i;
  425. radeon_do_wait_for_idle( dev_priv );
  427. RADEON_WRITE( RADEON_CP_ME_RAM_ADDR, 0 );
  428. for ( i = 0 ; i < 256 ; i++ ) {
  429. RADEON_WRITE( RADEON_CP_ME_RAM_DATAH,
  430.       radeon_cp_microcode[i][1] );
  431. RADEON_WRITE( RADEON_CP_ME_RAM_DATAL,
  432.       radeon_cp_microcode[i][0] );
  433. }
  434. }
  436. /* Flush any pending commands to the CP.  This should only be used just
  437.  * prior to a wait for idle, as it informs the engine that the command
  438.  * stream is ending.
  439.  */
  440. static void radeon_do_cp_flush( drm_radeon_private_t *dev_priv )
  441. {
  442. #if 0
  443. u32 tmp;
  445. tmp = RADEON_READ( RADEON_CP_RB_WPTR ) | (1 << 31);
  446. RADEON_WRITE( RADEON_CP_RB_WPTR, tmp );
  447. #endif
  448. }
  450. /* Wait for the CP to go idle.
  451.  */
  452. int radeon_do_cp_idle( drm_radeon_private_t *dev_priv )
  453. {
  454. RING_LOCALS;
  456. BEGIN_RING( 6 );
  458. RADEON_PURGE_CACHE();
  459. RADEON_PURGE_ZCACHE();
  460. RADEON_WAIT_UNTIL_IDLE();
  462. ADVANCE_RING();
  464. return radeon_do_wait_for_idle( dev_priv );
  465. }
  467. /* Start the Command Processor.
  468.  */
  469. static void radeon_do_cp_start( drm_radeon_private_t *dev_priv )
  470. {
  471. RING_LOCALS;
  473. radeon_do_wait_for_idle( dev_priv );
  475. RADEON_WRITE( RADEON_CP_CSQ_CNTL, dev_priv->cp_mode );
  477. dev_priv->cp_running = 1;
  479. BEGIN_RING( 6 );
  481. RADEON_PURGE_CACHE();
  482. RADEON_PURGE_ZCACHE();
  483. RADEON_WAIT_UNTIL_IDLE();
  485. ADVANCE_RING();
  486. }
  488. /* Reset the Command Processor.  This will not flush any pending
  489.  * commands, so you must wait for the CP command stream to complete
  490.  * before calling this routine.
  491.  */
  492. static void radeon_do_cp_reset( drm_radeon_private_t *dev_priv )
  493. {
  494. u32 cur_read_ptr;
  496. cur_read_ptr = RADEON_READ( RADEON_CP_RB_RPTR );
  497. RADEON_WRITE( RADEON_CP_RB_WPTR, cur_read_ptr );
  498. *dev_priv->ring.head = cur_read_ptr;
  499. dev_priv->ring.tail = cur_read_ptr;
  500. }
  502. /* Stop the Command Processor.  This will not flush any pending
  503.  * commands, so you must flush the command stream and wait for the CP
  504.  * to go idle before calling this routine.
  505.  */
  506. static void radeon_do_cp_stop( drm_radeon_private_t *dev_priv )
  507. {
  508. RADEON_WRITE( RADEON_CP_CSQ_CNTL, RADEON_CSQ_PRIDIS_INDDIS );
  510. dev_priv->cp_running = 0;
  511. }
  513. /* Reset the engine.  This will stop the CP if it is running.
  514.  */
  515. static int radeon_do_engine_reset( drm_device_t *dev )
  516. {
  517. drm_radeon_private_t *dev_priv = dev->dev_private;
  518. u32 clock_cntl_index, mclk_cntl, rbbm_soft_reset;
  519. DRM_DEBUG( "%sn", __FUNCTION__ );
  521. radeon_do_pixcache_flush( dev_priv );
  523. clock_cntl_index = RADEON_READ( RADEON_CLOCK_CNTL_INDEX );
  524. mclk_cntl = RADEON_READ_PLL( dev, RADEON_MCLK_CNTL );
  526. /* FIXME: remove magic number here and in radeon ddx driver!!! */
  527. RADEON_WRITE_PLL( RADEON_MCLK_CNTL, mclk_cntl | 0x003f00000 );
  529. rbbm_soft_reset = RADEON_READ( RADEON_RBBM_SOFT_RESET );
  531. RADEON_WRITE( RADEON_RBBM_SOFT_RESET, ( rbbm_soft_reset |
  532. RADEON_SOFT_RESET_CP |
  533. RADEON_SOFT_RESET_HI |
  534. RADEON_SOFT_RESET_SE |
  535. RADEON_SOFT_RESET_RE |
  536. RADEON_SOFT_RESET_PP |
  537. RADEON_SOFT_RESET_E2 |
  538. RADEON_SOFT_RESET_RB |
  539. RADEON_SOFT_RESET_HDP ) );
  540. RADEON_READ( RADEON_RBBM_SOFT_RESET );
  541. RADEON_WRITE( RADEON_RBBM_SOFT_RESET, ( rbbm_soft_reset &
  542. ~( RADEON_SOFT_RESET_CP |
  543.    RADEON_SOFT_RESET_HI |
  544.    RADEON_SOFT_RESET_SE |
  545.    RADEON_SOFT_RESET_RE |
  546.    RADEON_SOFT_RESET_PP |
  547.    RADEON_SOFT_RESET_E2 |
  548.    RADEON_SOFT_RESET_RB |
  549.    RADEON_SOFT_RESET_HDP ) ) );
  550. RADEON_READ( RADEON_RBBM_SOFT_RESET );
  553. RADEON_WRITE_PLL( RADEON_MCLK_CNTL, mclk_cntl );
  554. RADEON_WRITE( RADEON_CLOCK_CNTL_INDEX, clock_cntl_index );
  555. RADEON_WRITE( RADEON_RBBM_SOFT_RESET,  rbbm_soft_reset );
  557. /* Reset the CP ring */
  558. radeon_do_cp_reset( dev_priv );
  560. /* The CP is no longer running after an engine reset */
  561. dev_priv->cp_running = 0;
  563. /* Reset any pending vertex, indirect buffers */
  564. radeon_freelist_reset( dev );
  566. return 0;
  567. }
  569. static void radeon_cp_init_ring_buffer( drm_device_t *dev )
  570. {
  571. drm_radeon_private_t *dev_priv = dev->dev_private;
  572. u32 ring_start, cur_read_ptr;
  573. u32 tmp;
  575. /* Initialize the memory controller */
  576. RADEON_WRITE( RADEON_MC_FB_LOCATION,
  577.       (dev_priv->agp_vm_start - 1) & 0xffff0000 );
  578. RADEON_WRITE( RADEON_MC_AGP_LOCATION,
  579.       (((dev_priv->agp_vm_start - 1 +
  580.  dev_priv->agp_size) & 0xffff0000) |
  581.        (dev_priv->agp_vm_start >> 16)) );
  583. ring_start = (dev_priv->cp_ring->offset
  584.       - dev->agp->base
  585.       + dev_priv->agp_vm_start);
  587. RADEON_WRITE( RADEON_CP_RB_BASE, ring_start );
  589. /* Set the write pointer delay */
  590. RADEON_WRITE( RADEON_CP_RB_WPTR_DELAY, 0 );
  592. /* Initialize the ring buffer's read and write pointers */
  593. cur_read_ptr = RADEON_READ( RADEON_CP_RB_RPTR );
  594. RADEON_WRITE( RADEON_CP_RB_WPTR, cur_read_ptr );
  595. *dev_priv->ring.head = cur_read_ptr;
  596. dev_priv->ring.tail = cur_read_ptr;
  598. RADEON_WRITE( RADEON_CP_RB_RPTR_ADDR, dev_priv->ring_rptr->offset );
  600. /* Set ring buffer size */
  601. RADEON_WRITE( RADEON_CP_RB_CNTL, dev_priv->ring.size_l2qw );
  603. radeon_do_wait_for_idle( dev_priv );
  605. /* Turn off PCI GART */
  606. tmp = RADEON_READ( RADEON_AIC_CNTL ) & ~RADEON_PCIGART_TRANSLATE_EN;
  607. RADEON_WRITE( RADEON_AIC_CNTL, tmp );
  609. /* Turn on bus mastering */
  610. tmp = RADEON_READ( RADEON_BUS_CNTL ) & ~RADEON_BUS_MASTER_DIS;
  611. RADEON_WRITE( RADEON_BUS_CNTL, tmp );
  613. /* Sync everything up */
  614. RADEON_WRITE( RADEON_ISYNC_CNTL,
  615.       (RADEON_ISYNC_ANY2D_IDLE3D |
  616.        RADEON_ISYNC_ANY3D_IDLE2D |
  617.        RADEON_ISYNC_WAIT_IDLEGUI |
  618.        RADEON_ISYNC_CPSCRATCH_IDLEGUI) );
  619. }
  621. static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
  622. {
  623. drm_radeon_private_t *dev_priv;
  624.         int i;
  626. dev_priv = drm_alloc( sizeof(drm_radeon_private_t), DRM_MEM_DRIVER );
  627. if ( dev_priv == NULL )
  628. return -ENOMEM;
  629. dev->dev_private = (void *)dev_priv;
  631. memset( dev_priv, 0, sizeof(drm_radeon_private_t) );
  633. dev_priv->is_pci = init->is_pci;
  635. /* We don't support PCI cards until PCI GART is implemented.
  636.  * Fail here so we can remove all checks for PCI cards around
  637.  * the CP ring code.
  638.  */
  639. if ( dev_priv->is_pci ) {
  640. drm_free( dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER );
  641. dev->dev_private = NULL;
  642. return -EINVAL;
  643. }
  645. dev_priv->usec_timeout = init->usec_timeout;
  646. if ( dev_priv->usec_timeout < 1 ||
  647.      dev_priv->usec_timeout > RADEON_MAX_USEC_TIMEOUT ) {
  648. drm_free( dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER );
  649. dev->dev_private = NULL;
  650. return -EINVAL;
  651. }
  653. dev_priv->cp_mode = init->cp_mode;
  655. /* Simple idle check.
  656.  */
  657. atomic_set( &dev_priv->idle_count, 0 );
  659. /* We don't support anything other than bus-mastering ring mode,
  660.  * but the ring can be in either AGP or PCI space for the ring
  661.  * read pointer.
  662.  */
  663. if ( ( init->cp_mode != RADEON_CSQ_PRIBM_INDDIS ) &&
  664.      ( init->cp_mode != RADEON_CSQ_PRIBM_INDBM ) ) {
  665. drm_free( dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER );
  666. dev->dev_private = NULL;
  667. return -EINVAL;
  668. }
  670. switch ( init->fb_bpp ) {
  671. case 16:
  672. dev_priv->color_fmt = RADEON_COLOR_FORMAT_RGB565;
  673. break;
  674. case 32:
  675. default:
  676. dev_priv->color_fmt = RADEON_COLOR_FORMAT_ARGB8888;
  677. break;
  678. }
  679. dev_priv->front_offset = init->front_offset;
  680. dev_priv->front_pitch = init->front_pitch;
  681. dev_priv->back_offset = init->back_offset;
  682. dev_priv->back_pitch = init->back_pitch;
  684. switch ( init->depth_bpp ) {
  685. case 16:
  686. dev_priv->depth_fmt = RADEON_DEPTH_FORMAT_16BIT_INT_Z;
  687. break;
  688. case 32:
  689. default:
  690. dev_priv->depth_fmt = RADEON_DEPTH_FORMAT_24BIT_INT_Z;
  691. break;
  692. }
  693. dev_priv->depth_offset = init->depth_offset;
  694. dev_priv->depth_pitch = init->depth_pitch;
  696. dev_priv->front_pitch_offset = (((dev_priv->front_pitch/64) << 22) |
  697. (dev_priv->front_offset >> 10));
  698. dev_priv->back_pitch_offset = (((dev_priv->back_pitch/64) << 22) |
  699.        (dev_priv->back_offset >> 10));
  700. dev_priv->depth_pitch_offset = (((dev_priv->depth_pitch/64) << 22) |
  701. (dev_priv->depth_offset >> 10));
  703. /* Hardware state for depth clears.  Remove this if/when we no
  704.  * longer clear the depth buffer with a 3D rectangle.  Hard-code
  705.  * all values to prevent unwanted 3D state from slipping through
  706.  * and screwing with the clear operation.
  707.  */
  708. dev_priv->depth_clear.rb3d_cntl = (RADEON_PLANE_MASK_ENABLE |
  709.    RADEON_Z_ENABLE |
  710.    (dev_priv->color_fmt << 10) |
  711.    RADEON_ZBLOCK16);
  713. dev_priv->depth_clear.rb3d_zstencilcntl = (dev_priv->depth_fmt |
  714.    RADEON_Z_TEST_ALWAYS |
  715.    RADEON_STENCIL_TEST_ALWAYS |
  716.    RADEON_STENCIL_S_FAIL_KEEP |
  717.    RADEON_STENCIL_ZPASS_KEEP |
  718.    RADEON_STENCIL_ZFAIL_KEEP |
  719.    RADEON_Z_WRITE_ENABLE);
  721. dev_priv->depth_clear.se_cntl = (RADEON_FFACE_CULL_CW |
  722.  RADEON_BFACE_SOLID |
  723.  RADEON_FFACE_SOLID |
  724.  RADEON_FLAT_SHADE_VTX_LAST |
  726.  RADEON_DIFFUSE_SHADE_FLAT |
  727.  RADEON_ALPHA_SHADE_FLAT |
  728.  RADEON_SPECULAR_SHADE_FLAT |
  729.  RADEON_FOG_SHADE_FLAT |
  731.  RADEON_VTX_PIX_CENTER_OGL |
  732.  RADEON_ROUND_MODE_TRUNC |
  733.  RADEON_ROUND_PREC_8TH_PIX);
  735. /* FIXME: We want multiple shared areas, including one shared
  736.  * only by the X Server and kernel module.
  737.  */
  738. for ( i = 0 ; i < dev->map_count ; i++ ) {
  739. if ( dev->maplist[i]->type == _DRM_SHM ) {
  740. dev_priv->sarea = dev->maplist[i];
  741. break;
  742. }
  743. }
  745. DO_FIND_MAP( dev_priv->fb, init->fb_offset );
  746. DO_FIND_MAP( dev_priv->mmio, init->mmio_offset );
  747. DO_FIND_MAP( dev_priv->cp_ring, init->ring_offset );
  748. DO_FIND_MAP( dev_priv->ring_rptr, init->ring_rptr_offset );
  749. DO_FIND_MAP( dev_priv->buffers, init->buffers_offset );
  751. if ( !dev_priv->is_pci ) {
  752. DO_FIND_MAP( dev_priv->agp_textures,
  753.      init->agp_textures_offset );
  754. }
  756. dev_priv->sarea_priv =
  757. (drm_radeon_sarea_t *)((u8 *)dev_priv->sarea->handle +
  758.        init->sarea_priv_offset);
  760. DO_IOREMAP( dev_priv->cp_ring );
  761. DO_IOREMAP( dev_priv->ring_rptr );
  762. DO_IOREMAP( dev_priv->buffers );
  763. #if 0
  764. if ( !dev_priv->is_pci ) {
  765. DO_IOREMAP( dev_priv->agp_textures );
  766. }
  767. #endif
  769. dev_priv->agp_size = init->agp_size;
  770. dev_priv->agp_vm_start = RADEON_READ( RADEON_CONFIG_APER_SIZE );
  771. dev_priv->agp_buffers_offset = (dev_priv->buffers->offset
  772. - dev->agp->base
  773. + dev_priv->agp_vm_start);
  775. dev_priv->ring.head = ((__volatile__ u32 *)
  776.        dev_priv->ring_rptr->handle);
  778. dev_priv->ring.start = (u32 *)dev_priv->cp_ring->handle;
  779. dev_priv->ring.end = ((u32 *)dev_priv->cp_ring->handle
  780.       + init->ring_size / sizeof(u32));
  781. dev_priv->ring.size = init->ring_size;
  782. dev_priv->ring.size_l2qw = drm_order( init->ring_size / 8 );
  784. dev_priv->ring.tail_mask =
  785. (dev_priv->ring.size / sizeof(u32)) - 1;
  787. #if 0
  788. /* Initialize the scratch register pointer.  This will cause
  789.  * the scratch register values to be written out to memory
  790.  * whenever they are updated.
  791.  * FIXME: This doesn't quite work yet, so we're disabling it
  792.  * for the release.
  793.  */
  794. RADEON_WRITE( RADEON_SCRATCH_ADDR, (dev_priv->ring_rptr->offset +
  795.     RADEON_SCRATCH_REG_OFFSET) );
  796. RADEON_WRITE( RADEON_SCRATCH_UMSK, 0x7 );
  797. #endif
  799. dev_priv->scratch = ((__volatile__ u32 *)
  800.      dev_priv->ring_rptr->handle +
  801.      (RADEON_SCRATCH_REG_OFFSET / sizeof(u32)));
  803. dev_priv->sarea_priv->last_frame = 0;
  804. RADEON_WRITE( RADEON_LAST_FRAME_REG,
  805.       dev_priv->sarea_priv->last_frame );
  807. dev_priv->sarea_priv->last_dispatch = 0;
  808. RADEON_WRITE( RADEON_LAST_DISPATCH_REG,
  809.       dev_priv->sarea_priv->last_dispatch );
  811. dev_priv->sarea_priv->last_clear = 0;
  812. RADEON_WRITE( RADEON_LAST_CLEAR_REG,
  813.       dev_priv->sarea_priv->last_clear );
  815. radeon_cp_load_microcode( dev_priv );
  816. radeon_cp_init_ring_buffer( dev );
  817. radeon_do_engine_reset( dev );
  819. #if ROTATE_BUFS
  820. dev_priv->last_buf = 0;
  821. #endif
  823. return 0;
  824. }
  826. static int radeon_do_cleanup_cp( drm_device_t *dev )
  827. {
  828. if ( dev->dev_private ) {
  829. drm_radeon_private_t *dev_priv = dev->dev_private;
  831. DO_IOREMAPFREE( dev_priv->cp_ring );
  832. DO_IOREMAPFREE( dev_priv->ring_rptr );
  833. DO_IOREMAPFREE( dev_priv->buffers );
  834. #if 0
  835. if ( !dev_priv->is_pci ) {
  836. DO_IOREMAPFREE( dev_priv->agp_textures );
  837. }
  838. #endif
  840. drm_free( dev->dev_private, sizeof(drm_radeon_private_t),
  841.   DRM_MEM_DRIVER );
  842. dev->dev_private = NULL;
  843. }
  845. return 0;
  846. }
  848. int radeon_cp_init( struct inode *inode, struct file *filp,
  849.     unsigned int cmd, unsigned long arg )
  850. {
  851.         drm_file_t *priv = filp->private_data;
  852.         drm_device_t *dev = priv->dev;
  853. drm_radeon_init_t init;
  855. if ( copy_from_user( &init, (drm_radeon_init_t *)arg, sizeof(init) ) )
  856. return -EFAULT;
  858. switch ( init.func ) {
  859. case RADEON_INIT_CP:
  860. return radeon_do_init_cp( dev, &init );
  861. case RADEON_CLEANUP_CP:
  862. return radeon_do_cleanup_cp( dev );
  863. }
  865. return -EINVAL;
  866. }
  868. int radeon_cp_start( struct inode *inode, struct file *filp,
  869.      unsigned int cmd, unsigned long arg )
  870. {
  871.         drm_file_t *priv = filp->private_data;
  872.         drm_device_t *dev = priv->dev;
  873. drm_radeon_private_t *dev_priv = dev->dev_private;
  874. DRM_DEBUG( "%sn", __FUNCTION__ );
  876. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  877.      dev->lock.pid != current->pid ) {
  878. DRM_ERROR( "%s called without lock heldn", __FUNCTION__ );
  879. return -EINVAL;
  880. }
  881. if ( dev_priv->cp_running ) {
  882. DRM_DEBUG( "%s while CP runningn", __FUNCTION__ );
  883. return 0;
  884. }
  885. if ( dev_priv->cp_mode == RADEON_CSQ_PRIDIS_INDDIS ) {
  886. DRM_DEBUG( "%s called with bogus CP mode (%d)n",
  887.    __FUNCTION__, dev_priv->cp_mode );
  888. return 0;
  889. }
  891. radeon_do_cp_start( dev_priv );
  893. return 0;
  894. }
  896. /* Stop the CP.  The engine must have been idled before calling this
  897.  * routine.
  898.  */
  899. int radeon_cp_stop( struct inode *inode, struct file *filp,
  900.     unsigned int cmd, unsigned long arg )
  901. {
  902.         drm_file_t *priv = filp->private_data;
  903.         drm_device_t *dev = priv->dev;
  904. drm_radeon_private_t *dev_priv = dev->dev_private;
  905. drm_radeon_cp_stop_t stop;
  906. int ret;
  907. DRM_DEBUG( "%sn", __FUNCTION__ );
  909. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  910.      dev->lock.pid != current->pid ) {
  911. DRM_ERROR( "%s called without lock heldn", __FUNCTION__ );
  912. return -EINVAL;
  913. }
  915. if ( copy_from_user( &stop, (drm_radeon_init_t *)arg, sizeof(stop) ) )
  916. return -EFAULT;
  918. /* Flush any pending CP commands.  This ensures any outstanding
  919.  * commands are exectuted by the engine before we turn it off.
  920.  */
  921. if ( stop.flush ) {
  922. radeon_do_cp_flush( dev_priv );
  923. }
  925. /* If we fail to make the engine go idle, we return an error
  926.  * code so that the DRM ioctl wrapper can try again.
  927.  */
  928. if ( stop.idle ) {
  929. ret = radeon_do_cp_idle( dev_priv );
  930. if ( ret < 0 ) return ret;
  931. }
  933. /* Finally, we can turn off the CP.  If the engine isn't idle,
  934.  * we will get some dropped triangles as they won't be fully
  935.  * rendered before the CP is shut down.
  936.  */
  937. radeon_do_cp_stop( dev_priv );
  939. /* Reset the engine */
  940. radeon_do_engine_reset( dev );
  942. return 0;
  943. }
  945. /* Just reset the CP ring.  Called as part of an X Server engine reset.
  946.  */
  947. int radeon_cp_reset( struct inode *inode, struct file *filp,
  948.      unsigned int cmd, unsigned long arg )
  949. {
  950.         drm_file_t *priv = filp->private_data;
  951.         drm_device_t *dev = priv->dev;
  952. drm_radeon_private_t *dev_priv = dev->dev_private;
  953. DRM_DEBUG( "%sn", __FUNCTION__ );
  955. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  956.      dev->lock.pid != current->pid ) {
  957. DRM_ERROR( "%s called without lock heldn", __FUNCTION__ );
  958. return -EINVAL;
  959. }
  960. if ( !dev_priv ) {
  961. DRM_DEBUG( "%s called before init donen", __FUNCTION__ );
  962. return -EINVAL;
  963. }
  965. radeon_do_cp_reset( dev_priv );
  967. /* The CP is no longer running after an engine reset */
  968. dev_priv->cp_running = 0;
  970. return 0;
  971. }
  973. int radeon_cp_idle( struct inode *inode, struct file *filp,
  974.     unsigned int cmd, unsigned long arg )
  975. {
  976.         drm_file_t *priv = filp->private_data;
  977.         drm_device_t *dev = priv->dev;
  978. drm_radeon_private_t *dev_priv = dev->dev_private;
  979. DRM_DEBUG( "%sn", __FUNCTION__ );
  981. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  982.      dev->lock.pid != current->pid ) {
  983. DRM_ERROR( "%s called without lock heldn", __FUNCTION__ );
  984. return -EINVAL;
  985. }
  987. return radeon_do_cp_idle( dev_priv );
  988. }
  990. int radeon_engine_reset( struct inode *inode, struct file *filp,
  991.  unsigned int cmd, unsigned long arg )
  992. {
  993.         drm_file_t *priv = filp->private_data;
  994.         drm_device_t *dev = priv->dev;
  995. DRM_DEBUG( "%sn", __FUNCTION__ );
  997. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  998.      dev->lock.pid != current->pid ) {
  999. DRM_ERROR( "%s called without lock heldn", __FUNCTION__ );
  1000. return -EINVAL;
  1001. }
  1003. return radeon_do_engine_reset( dev );
  1004. }
  1007. /* ================================================================
  1008.  * Fullscreen mode
  1009.  */
  1011. static int radeon_do_init_pageflip( drm_device_t *dev )
  1012. {
  1013. drm_radeon_private_t *dev_priv = dev->dev_private;
  1014. DRM_DEBUG( "%sn", __FUNCTION__ );
  1016. dev_priv->crtc_offset =      RADEON_READ( RADEON_CRTC_OFFSET );
  1017. dev_priv->crtc_offset_cntl = RADEON_READ( RADEON_CRTC_OFFSET_CNTL );
  1019. RADEON_WRITE( RADEON_CRTC_OFFSET, dev_priv->front_offset );
  1020. RADEON_WRITE( RADEON_CRTC_OFFSET_CNTL,
  1021.       dev_priv->crtc_offset_cntl |
  1022.       RADEON_CRTC_OFFSET_FLIP_CNTL );
  1024. dev_priv->page_flipping = 1;
  1025. dev_priv->current_page = 0;
  1027. return 0;
  1028. }
  1030. int radeon_do_cleanup_pageflip( drm_device_t *dev )
  1031. {
  1032. drm_radeon_private_t *dev_priv = dev->dev_private;
  1033. DRM_DEBUG( "%sn", __FUNCTION__ );
  1035. RADEON_WRITE( RADEON_CRTC_OFFSET,      dev_priv->crtc_offset );
  1036. RADEON_WRITE( RADEON_CRTC_OFFSET_CNTL, dev_priv->crtc_offset_cntl );
  1038. dev_priv->page_flipping = 0;
  1039. dev_priv->current_page = 0;
  1041. return 0;
  1042. }
  1044. int radeon_fullscreen( struct inode *inode, struct file *filp,
  1045.        unsigned int cmd, unsigned long arg )
  1046. {
  1047.         drm_file_t *priv = filp->private_data;
  1048.         drm_device_t *dev = priv->dev;
  1049. drm_radeon_fullscreen_t fs;
  1051. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  1052.      dev->lock.pid != current->pid ) {
  1053. DRM_ERROR( "%s called without lock heldn", __FUNCTION__ );
  1054. return -EINVAL;
  1055. }
  1057. if ( copy_from_user( &fs, (drm_radeon_fullscreen_t *)arg,
  1058.      sizeof(fs) ) )
  1059. return -EFAULT;
  1061. switch ( fs.func ) {
  1062. case RADEON_INIT_FULLSCREEN:
  1063. return radeon_do_init_pageflip( dev );
  1064. case RADEON_CLEANUP_FULLSCREEN:
  1065. return radeon_do_cleanup_pageflip( dev );
  1066. }
  1068. return -EINVAL;
  1069. }
  1072. /* ================================================================
  1073.  * Freelist management
  1074.  */
  1075. #define RADEON_BUFFER_USED 0xffffffff
  1076. #define RADEON_BUFFER_FREE 0
  1078. #if 0
  1079. static int radeon_freelist_init( drm_device_t *dev )
  1080. {
  1081. drm_device_dma_t *dma = dev->dma;
  1082. drm_radeon_private_t *dev_priv = dev->dev_private;
  1083. drm_buf_t *buf;
  1084. drm_radeon_buf_priv_t *buf_priv;
  1085. drm_radeon_freelist_t *entry;
  1086. int i;
  1088. dev_priv->head = drm_alloc( sizeof(drm_radeon_freelist_t),
  1089.     DRM_MEM_DRIVER );
  1090. if ( dev_priv->head == NULL )
  1091. return -ENOMEM;
  1093. memset( dev_priv->head, 0, sizeof(drm_radeon_freelist_t) );
  1094. dev_priv->head->age = RADEON_BUFFER_USED;
  1096. for ( i = 0 ; i < dma->buf_count ; i++ ) {
  1097. buf = dma->buflist[i];
  1098. buf_priv = buf->dev_private;
  1100. entry = drm_alloc( sizeof(drm_radeon_freelist_t),
  1101.    DRM_MEM_DRIVER );
  1102. if ( !entry ) return -ENOMEM;
  1104. entry->age = RADEON_BUFFER_FREE;
  1105. entry->buf = buf;
  1106. entry->prev = dev_priv->head;
  1107. entry->next = dev_priv->head->next;
  1108. if ( !entry->next )
  1109. dev_priv->tail = entry;
  1111. buf_priv->discard = 0;
  1112. buf_priv->dispatched = 0;
  1113. buf_priv->list_entry = entry;
  1115. dev_priv->head->next = entry;
  1117. if ( dev_priv->head->next )
  1118. dev_priv->head->next->prev = entry;
  1119. }
  1121. return 0;
  1123. }
  1124. #endif
  1126. drm_buf_t *radeon_freelist_get( drm_device_t *dev )
  1127. {
  1128. drm_device_dma_t *dma = dev->dma;
  1129. drm_radeon_private_t *dev_priv = dev->dev_private;
  1130. drm_radeon_buf_priv_t *buf_priv;
  1131. drm_buf_t *buf;
  1132. int i, t;
  1133. #if ROTATE_BUFS
  1134. int start;
  1135. #endif
  1137. /* FIXME: Optimize -- use freelist code */
  1139. for ( i = 0 ; i < dma->buf_count ; i++ ) {
  1140. buf = dma->buflist[i];
  1141. buf_priv = buf->dev_private;
  1142. if ( buf->pid == 0 ) {
  1143. DRM_DEBUG( "  ret buf=%d last=%d pid=0n",
  1144.    buf->idx, dev_priv->last_buf );
  1145. return buf;
  1146. }
  1147. DRM_DEBUG( "    skipping buf=%d pid=%dn",
  1148.    buf->idx, buf->pid );
  1149. }
  1151. #if ROTATE_BUFS
  1152. if ( ++dev_priv->last_buf >= dma->buf_count )
  1153. dev_priv->last_buf = 0;
  1154. start = dev_priv->last_buf;
  1155. #endif
  1156. for ( t = 0 ; t < dev_priv->usec_timeout ; t++ ) {
  1157. #if 0
  1158. /* FIXME: Disable this for now */
  1159. u32 done_age = dev_priv->scratch[RADEON_LAST_DISPATCH];
  1160. #else
  1161. u32 done_age = RADEON_READ( RADEON_LAST_DISPATCH_REG );
  1162. #endif
  1163. #if ROTATE_BUFS
  1164. for ( i = start ; i < dma->buf_count ; i++ ) {
  1165. #else
  1166. for ( i = 0 ; i < dma->buf_count ; i++ ) {
  1167. #endif
  1168. buf = dma->buflist[i];
  1169. buf_priv = buf->dev_private;
  1170. if ( buf->pending && buf_priv->age <= done_age ) {
  1171. /* The buffer has been processed, so it
  1172.  * can now be used.
  1173.  */
  1174. buf->pending = 0;
  1175. DRM_DEBUG( "  ret buf=%d last=%d age=%d done=%dn", buf->idx, dev_priv->last_buf, buf_priv->age, done_age );
  1176. return buf;
  1177. }
  1178. DRM_DEBUG( "    skipping buf=%d age=%d done=%dn",
  1179.    buf->idx, buf_priv->age,
  1180.    done_age );
  1181. #if ROTATE_BUFS
  1182. start = 0;
  1183. #endif
  1184. }
  1185. udelay( 1 );
  1186. }
  1188. DRM_ERROR( "returning NULL!n" );
  1189. return NULL;
  1190. }
  1192. void radeon_freelist_reset( drm_device_t *dev )
  1193. {
  1194. drm_device_dma_t *dma = dev->dma;
  1195. #if ROTATE_BUFS
  1196. drm_radeon_private_t *dev_priv = dev->dev_private;
  1197. #endif
  1198. int i;
  1200. #if ROTATE_BUFS
  1201. dev_priv->last_buf = 0;
  1202. #endif
  1203. for ( i = 0 ; i < dma->buf_count ; i++ ) {
  1204. drm_buf_t *buf = dma->buflist[i];
  1205. drm_radeon_buf_priv_t *buf_priv = buf->dev_private;
  1206. buf_priv->age = 0;
  1207. }
  1208. }
  1211. /* ================================================================
  1212.  * CP command submission
  1213.  */
  1215. int radeon_wait_ring( drm_radeon_private_t *dev_priv, int n )
  1216. {
  1217. drm_radeon_ring_buffer_t *ring = &dev_priv->ring;
  1218. int i;
  1220. for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
  1221. ring->space = *ring->head - ring->tail;
  1222. if ( ring->space <= 0 )
  1223. ring->space += ring->size;
  1225. if ( ring->space >= n )
  1226. return 0;
  1228. udelay( 1 );
  1229. }
  1231. /* FIXME: This return value is ignored in the BEGIN_RING macro! */
  1232. DRM_ERROR( "failed!n" );
  1233. return -EBUSY;
  1234. }
  1236. void radeon_update_ring_snapshot( drm_radeon_private_t *dev_priv )
  1237. {
  1238. drm_radeon_ring_buffer_t *ring = &dev_priv->ring;
  1240. ring->space = *ring->head - ring->tail;
  1241. if ( ring->space == 0 )
  1242. atomic_inc( &dev_priv->idle_count );
  1243. if ( ring->space <= 0 )
  1244. ring->space += ring->size;
  1245. }
  1247. static int radeon_cp_get_buffers( drm_device_t *dev, drm_dma_t *d )
  1248. {
  1249. int i;
  1250. drm_buf_t *buf;
  1252. for ( i = d->granted_count ; i < d->request_count ; i++ ) {
  1253. buf = radeon_freelist_get( dev );
  1254. if ( !buf ) return -EAGAIN;
  1256. buf->pid = current->pid;
  1258. if ( copy_to_user( &d->request_indices[i], &buf->idx,
  1259.    sizeof(buf->idx) ) )
  1260. return -EFAULT;
  1261. if ( copy_to_user( &d->request_sizes[i], &buf->total,
  1262.    sizeof(buf->total) ) )
  1263. return -EFAULT;
  1265. d->granted_count++;
  1266. }
  1267. return 0;
  1268. }
  1270. int radeon_cp_buffers( struct inode *inode, struct file *filp,
  1271.        unsigned int cmd, unsigned long arg )
  1272. {
  1273. drm_file_t *priv = filp->private_data;
  1274. drm_device_t *dev = priv->dev;
  1275. drm_device_dma_t *dma = dev->dma;
  1276. int ret = 0;
  1277. drm_dma_t d;
  1279. if ( copy_from_user( &d, (drm_dma_t *) arg, sizeof(d) ) )
  1280. return -EFAULT;
  1282. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  1283.      dev->lock.pid != current->pid ) {
  1284. DRM_ERROR( "%s called without lock heldn", __FUNCTION__ );
  1285. return -EINVAL;
  1286. }
  1288. /* Please don't send us buffers.
  1289.  */
  1290. if ( d.send_count != 0 ) {
  1291. DRM_ERROR( "Process %d trying to send %d buffers via drmDMAn",
  1292.    current->pid, d.send_count );
  1293. return -EINVAL;
  1294. }
  1296. /* We'll send you buffers.
  1297.  */
  1298. if ( d.request_count < 0 || d.request_count > dma->buf_count ) {
  1299. DRM_ERROR( "Process %d trying to get %d buffers (of %d max)n",
  1300.    current->pid, d.request_count, dma->buf_count );
  1301. return -EINVAL;
  1302. }
  1304. d.granted_count = 0;
  1306. if ( d.request_count ) {
  1307. ret = radeon_cp_get_buffers( dev, &d );
  1308. }
  1310. if ( copy_to_user( (drm_dma_t *) arg, &d, sizeof(d) ) )
  1311. return -EFAULT;
  1313. return ret;
  1314. }