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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
radeon_cp.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：38k
源码类别：

Linux/Unix编程

开发平台：

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.  */
  31. #include "radeon.h"
  32. #include "drmP.h"
  33. #include "radeon_drv.h"
  35. #include <linux/interrupt.h> /* For task queue support */
  36. #include <linux/delay.h>
  38. #define RADEON_FIFO_DEBUG 0
  40. #if defined(__alpha__)
  41. # define PCIGART_ENABLED
  42. #else
  43. # undef PCIGART_ENABLED
  44. #endif
  47. /* CP microcode (from ATI) */
  48. static u32 radeon_cp_microcode[][2] = {
  49. { 0x21007000, 0000000000 },
  50. { 0x20007000, 0000000000 },
  51. { 0x000000b4, 0x00000004 },
  52. { 0x000000b8, 0x00000004 },
  53. { 0x6f5b4d4c, 0000000000 },
  54. { 0x4c4c427f, 0000000000 },
  55. { 0x5b568a92, 0000000000 },
  56. { 0x4ca09c6d, 0000000000 },
  57. { 0xad4c4c4c, 0000000000 },
  58. { 0x4ce1af3d, 0000000000 },
  59. { 0xd8afafaf, 0000000000 },
  60. { 0xd64c4cdc, 0000000000 },
  61. { 0x4cd10d10, 0000000000 },
  62. { 0x000f0000, 0x00000016 },
  63. { 0x362f242d, 0000000000 },
  64. { 0x00000012, 0x00000004 },
  65. { 0x000f0000, 0x00000016 },
  66. { 0x362f282d, 0000000000 },
  67. { 0x000380e7, 0x00000002 },
  68. { 0x04002c97, 0x00000002 },
  69. { 0x000f0001, 0x00000016 },
  70. { 0x333a3730, 0000000000 },
  71. { 0x000077ef, 0x00000002 },
  72. { 0x00061000, 0x00000002 },
  73. { 0x00000021, 0x0000001a },
  74. { 0x00004000, 0x0000001e },
  75. { 0x00061000, 0x00000002 },
  76. { 0x00000021, 0x0000001a },
  77. { 0x00004000, 0x0000001e },
  78. { 0x00061000, 0x00000002 },
  79. { 0x00000021, 0x0000001a },
  80. { 0x00004000, 0x0000001e },
  81. { 0x00000017, 0x00000004 },
  82. { 0x0003802b, 0x00000002 },
  83. { 0x040067e0, 0x00000002 },
  84. { 0x00000017, 0x00000004 },
  85. { 0x000077e0, 0x00000002 },
  86. { 0x00065000, 0x00000002 },
  87. { 0x000037e1, 0x00000002 },
  88. { 0x040067e1, 0x00000006 },
  89. { 0x000077e0, 0x00000002 },
  90. { 0x000077e1, 0x00000002 },
  91. { 0x000077e1, 0x00000006 },
  92. { 0xffffffff, 0000000000 },
  93. { 0x10000000, 0000000000 },
  94. { 0x0003802b, 0x00000002 },
  95. { 0x040067e0, 0x00000006 },
  96. { 0x00007675, 0x00000002 },
  97. { 0x00007676, 0x00000002 },
  98. { 0x00007677, 0x00000002 },
  99. { 0x00007678, 0x00000006 },
  100. { 0x0003802c, 0x00000002 },
  101. { 0x04002676, 0x00000002 },
  102. { 0x00007677, 0x00000002 },
  103. { 0x00007678, 0x00000006 },
  104. { 0x0000002f, 0x00000018 },
  105. { 0x0000002f, 0x00000018 },
  106. { 0000000000, 0x00000006 },
  107. { 0x00000030, 0x00000018 },
  108. { 0x00000030, 0x00000018 },
  109. { 0000000000, 0x00000006 },
  110. { 0x01605000, 0x00000002 },
  111. { 0x00065000, 0x00000002 },
  112. { 0x00098000, 0x00000002 },
  113. { 0x00061000, 0x00000002 },
  114. { 0x64c0603e, 0x00000004 },
  115. { 0x000380e6, 0x00000002 },
  116. { 0x040025c5, 0x00000002 },
  117. { 0x00080000, 0x00000016 },
  118. { 0000000000, 0000000000 },
  119. { 0x0400251d, 0x00000002 },
  120. { 0x00007580, 0x00000002 },
  121. { 0x00067581, 0x00000002 },
  122. { 0x04002580, 0x00000002 },
  123. { 0x00067581, 0x00000002 },
  124. { 0x00000049, 0x00000004 },
  125. { 0x00005000, 0000000000 },
  126. { 0x000380e6, 0x00000002 },
  127. { 0x040025c5, 0x00000002 },
  128. { 0x00061000, 0x00000002 },
  129. { 0x0000750e, 0x00000002 },
  130. { 0x00019000, 0x00000002 },
  131. { 0x00011055, 0x00000014 },
  132. { 0x00000055, 0x00000012 },
  133. { 0x0400250f, 0x00000002 },
  134. { 0x0000504f, 0x00000004 },
  135. { 0x000380e6, 0x00000002 },
  136. { 0x040025c5, 0x00000002 },
  137. { 0x00007565, 0x00000002 },
  138. { 0x00007566, 0x00000002 },
  139. { 0x00000058, 0x00000004 },
  140. { 0x000380e6, 0x00000002 },
  141. { 0x040025c5, 0x00000002 },
  142. { 0x01e655b4, 0x00000002 },
  143. { 0x4401b0e4, 0x00000002 },
  144. { 0x01c110e4, 0x00000002 },
  145. { 0x26667066, 0x00000018 },
  146. { 0x040c2565, 0x00000002 },
  147. { 0x00000066, 0x00000018 },
  148. { 0x04002564, 0x00000002 },
  149. { 0x00007566, 0x00000002 },
  150. { 0x0000005d, 0x00000004 },
  151. { 0x00401069, 0x00000008 },
  152. { 0x00101000, 0x00000002 },
  153. { 0x000d80ff, 0x00000002 },
  154. { 0x0080006c, 0x00000008 },
  155. { 0x000f9000, 0x00000002 },
  156. { 0x000e00ff, 0x00000002 },
  157. { 0000000000, 0x00000006 },
  158. { 0x0000008f, 0x00000018 },
  159. { 0x0000005b, 0x00000004 },
  160. { 0x000380e6, 0x00000002 },
  161. { 0x040025c5, 0x00000002 },
  162. { 0x00007576, 0x00000002 },
  163. { 0x00065000, 0x00000002 },
  164. { 0x00009000, 0x00000002 },
  165. { 0x00041000, 0x00000002 },
  166. { 0x0c00350e, 0x00000002 },
  167. { 0x00049000, 0x00000002 },
  168. { 0x00051000, 0x00000002 },
  169. { 0x01e785f8, 0x00000002 },
  170. { 0x00200000, 0x00000002 },
  171. { 0x0060007e, 0x0000000c },
  172. { 0x00007563, 0x00000002 },
  173. { 0x006075f0, 0x00000021 },
  174. { 0x20007073, 0x00000004 },
  175. { 0x00005073, 0x00000004 },
  176. { 0x000380e6, 0x00000002 },
  177. { 0x040025c5, 0x00000002 },
  178. { 0x00007576, 0x00000002 },
  179. { 0x00007577, 0x00000002 },
  180. { 0x0000750e, 0x00000002 },
  181. { 0x0000750f, 0x00000002 },
  182. { 0x00a05000, 0x00000002 },
  183. { 0x00600083, 0x0000000c },
  184. { 0x006075f0, 0x00000021 },
  185. { 0x000075f8, 0x00000002 },
  186. { 0x00000083, 0x00000004 },
  187. { 0x000a750e, 0x00000002 },
  188. { 0x000380e6, 0x00000002 },
  189. { 0x040025c5, 0x00000002 },
  190. { 0x0020750f, 0x00000002 },
  191. { 0x00600086, 0x00000004 },
  192. { 0x00007570, 0x00000002 },
  193. { 0x00007571, 0x00000002 },
  194. { 0x00007572, 0x00000006 },
  195. { 0x000380e6, 0x00000002 },
  196. { 0x040025c5, 0x00000002 },
  197. { 0x00005000, 0x00000002 },
  198. { 0x00a05000, 0x00000002 },
  199. { 0x00007568, 0x00000002 },
  200. { 0x00061000, 0x00000002 },
  201. { 0x00000095, 0x0000000c },
  202. { 0x00058000, 0x00000002 },
  203. { 0x0c607562, 0x00000002 },
  204. { 0x00000097, 0x00000004 },
  205. { 0x000380e6, 0x00000002 },
  206. { 0x040025c5, 0x00000002 },
  207. { 0x00600096, 0x00000004 },
  208. { 0x400070e5, 0000000000 },
  209. { 0x000380e6, 0x00000002 },
  210. { 0x040025c5, 0x00000002 },
  211. { 0x000380e5, 0x00000002 },
  212. { 0x000000a8, 0x0000001c },
  213. { 0x000650aa, 0x00000018 },
  214. { 0x040025bb, 0x00000002 },
  215. { 0x000610ab, 0x00000018 },
  216. { 0x040075bc, 0000000000 },
  217. { 0x000075bb, 0x00000002 },
  218. { 0x000075bc, 0000000000 },
  219. { 0x00090000, 0x00000006 },
  220. { 0x00090000, 0x00000002 },
  221. { 0x000d8002, 0x00000006 },
  222. { 0x00007832, 0x00000002 },
  223. { 0x00005000, 0x00000002 },
  224. { 0x000380e7, 0x00000002 },
  225. { 0x04002c97, 0x00000002 },
  226. { 0x00007820, 0x00000002 },
  227. { 0x00007821, 0x00000002 },
  228. { 0x00007800, 0000000000 },
  229. { 0x01200000, 0x00000002 },
  230. { 0x20077000, 0x00000002 },
  231. { 0x01200000, 0x00000002 },
  232. { 0x20007000, 0x00000002 },
  233. { 0x00061000, 0x00000002 },
  234. { 0x0120751b, 0x00000002 },
  235. { 0x8040750a, 0x00000002 },
  236. { 0x8040750b, 0x00000002 },
  237. { 0x00110000, 0x00000002 },
  238. { 0x000380e5, 0x00000002 },
  239. { 0x000000c6, 0x0000001c },
  240. { 0x000610ab, 0x00000018 },
  241. { 0x844075bd, 0x00000002 },
  242. { 0x000610aa, 0x00000018 },
  243. { 0x840075bb, 0x00000002 },
  244. { 0x000610ab, 0x00000018 },
  245. { 0x844075bc, 0x00000002 },
  246. { 0x000000c9, 0x00000004 },
  247. { 0x804075bd, 0x00000002 },
  248. { 0x800075bb, 0x00000002 },
  249. { 0x804075bc, 0x00000002 },
  250. { 0x00108000, 0x00000002 },
  251. { 0x01400000, 0x00000002 },
  252. { 0x006000cd, 0x0000000c },
  253. { 0x20c07000, 0x00000020 },
  254. { 0x000000cf, 0x00000012 },
  255. { 0x00800000, 0x00000006 },
  256. { 0x0080751d, 0x00000006 },
  257. { 0000000000, 0000000000 },
  258. { 0x0000775c, 0x00000002 },
  259. { 0x00a05000, 0x00000002 },
  260. { 0x00661000, 0x00000002 },
  261. { 0x0460275d, 0x00000020 },
  262. { 0x00004000, 0000000000 },
  263. { 0x01e00830, 0x00000002 },
  264. { 0x21007000, 0000000000 },
  265. { 0x6464614d, 0000000000 },
  266. { 0x69687420, 0000000000 },
  267. { 0x00000073, 0000000000 },
  268. { 0000000000, 0000000000 },
  269. { 0x00005000, 0x00000002 },
  270. { 0x000380d0, 0x00000002 },
  271. { 0x040025e0, 0x00000002 },
  272. { 0x000075e1, 0000000000 },
  273. { 0x00000001, 0000000000 },
  274. { 0x000380e0, 0x00000002 },
  275. { 0x04002394, 0x00000002 },
  276. { 0x00005000, 0000000000 },
  277. { 0000000000, 0000000000 },
  278. { 0000000000, 0000000000 },
  279. { 0x00000008, 0000000000 },
  280. { 0x00000004, 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. { 0000000000, 0000000000 },
  301. { 0000000000, 0000000000 },
  302. { 0000000000, 0000000000 },
  303. { 0000000000, 0000000000 },
  304. { 0000000000, 0000000000 },
  305. };
  308. int RADEON_READ_PLL(drm_device_t *dev, int addr)
  309. {
  310. drm_radeon_private_t *dev_priv = dev->dev_private;
  312. RADEON_WRITE8(RADEON_CLOCK_CNTL_INDEX, addr & 0x1f);
  313. return RADEON_READ(RADEON_CLOCK_CNTL_DATA);
  314. }
  316. #if RADEON_FIFO_DEBUG
  317. static void radeon_status( drm_radeon_private_t *dev_priv )
  318. {
  319. printk( "%s:n", __FUNCTION__ );
  320. printk( "RBBM_STATUS = 0x%08xn",
  321. (unsigned int)RADEON_READ( RADEON_RBBM_STATUS ) );
  322. printk( "CP_RB_RTPR = 0x%08xn",
  323. (unsigned int)RADEON_READ( RADEON_CP_RB_RPTR ) );
  324. printk( "CP_RB_WTPR = 0x%08xn",
  325. (unsigned int)RADEON_READ( RADEON_CP_RB_WPTR ) );
  326. printk( "AIC_CNTL = 0x%08xn",
  327. (unsigned int)RADEON_READ( RADEON_AIC_CNTL ) );
  328. printk( "AIC_STAT = 0x%08xn",
  329. (unsigned int)RADEON_READ( RADEON_AIC_STAT ) );
  330. printk( "AIC_PT_BASE = 0x%08xn",
  331. (unsigned int)RADEON_READ( RADEON_AIC_PT_BASE ) );
  332. printk( "TLB_ADDR = 0x%08xn",
  333. (unsigned int)RADEON_READ( RADEON_AIC_TLB_ADDR ) );
  334. printk( "TLB_DATA = 0x%08xn",
  335. (unsigned int)RADEON_READ( RADEON_AIC_TLB_DATA ) );
  336. }
  337. #endif
  340. /* ================================================================
  341.  * Engine, FIFO control
  342.  */
  344. static int radeon_do_pixcache_flush( drm_radeon_private_t *dev_priv )
  345. {
  346. u32 tmp;
  347. int i;
  349. tmp  = RADEON_READ( RADEON_RB2D_DSTCACHE_CTLSTAT );
  350. tmp |= RADEON_RB2D_DC_FLUSH_ALL;
  351. RADEON_WRITE( RADEON_RB2D_DSTCACHE_CTLSTAT, tmp );
  353. for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
  354. if ( !(RADEON_READ( RADEON_RB2D_DSTCACHE_CTLSTAT )
  355.        & RADEON_RB2D_DC_BUSY) ) {
  356. return 0;
  357. }
  358. udelay( 1 );
  359. }
  361. #if RADEON_FIFO_DEBUG
  362. DRM_ERROR( "failed!n" );
  363. radeon_status( dev_priv );
  364. #endif
  365. return -EBUSY;
  366. }
  368. static int radeon_do_wait_for_fifo( drm_radeon_private_t *dev_priv,
  369.     int entries )
  370. {
  371. int i;
  373. for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
  374. int slots = ( RADEON_READ( RADEON_RBBM_STATUS )
  375.       & RADEON_RBBM_FIFOCNT_MASK );
  376. if ( slots >= entries ) return 0;
  377. udelay( 1 );
  378. }
  380. #if RADEON_FIFO_DEBUG
  381. DRM_ERROR( "failed!n" );
  382. radeon_status( dev_priv );
  383. #endif
  384. return -EBUSY;
  385. }
  387. static int radeon_do_wait_for_idle( drm_radeon_private_t *dev_priv )
  388. {
  389. int i, ret;
  391. ret = radeon_do_wait_for_fifo( dev_priv, 64 );
  392. if ( ret < 0 ) return ret;
  394. for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
  395. if ( !(RADEON_READ( RADEON_RBBM_STATUS )
  396.        & RADEON_RBBM_ACTIVE) ) {
  397. radeon_do_pixcache_flush( dev_priv );
  398. return 0;
  399. }
  400. udelay( 1 );
  401. }
  403. #if RADEON_FIFO_DEBUG
  404. DRM_ERROR( "failed!n" );
  405. radeon_status( dev_priv );
  406. #endif
  407. return -EBUSY;
  408. }
  411. /* ================================================================
  412.  * CP control, initialization
  413.  */
  415. /* Load the microcode for the CP */
  416. static void radeon_cp_load_microcode( drm_radeon_private_t *dev_priv )
  417. {
  418. int i;
  419. DRM_DEBUG( "%sn", __FUNCTION__ );
  421. radeon_do_wait_for_idle( dev_priv );
  423. RADEON_WRITE( RADEON_CP_ME_RAM_ADDR, 0 );
  424. for ( i = 0 ; i < 256 ; i++ ) {
  425. RADEON_WRITE( RADEON_CP_ME_RAM_DATAH,
  426.       radeon_cp_microcode[i][1] );
  427. RADEON_WRITE( RADEON_CP_ME_RAM_DATAL,
  428.       radeon_cp_microcode[i][0] );
  429. }
  430. }
  432. /* Flush any pending commands to the CP.  This should only be used just
  433.  * prior to a wait for idle, as it informs the engine that the command
  434.  * stream is ending.
  435.  */
  436. static void radeon_do_cp_flush( drm_radeon_private_t *dev_priv )
  437. {
  438. DRM_DEBUG( "%sn", __FUNCTION__ );
  439. #if 0
  440. u32 tmp;
  442. tmp = RADEON_READ( RADEON_CP_RB_WPTR ) | (1 << 31);
  443. RADEON_WRITE( RADEON_CP_RB_WPTR, tmp );
  444. #endif
  445. }
  447. /* Wait for the CP to go idle.
  448.  */
  449. int radeon_do_cp_idle( drm_radeon_private_t *dev_priv )
  450. {
  451. RING_LOCALS;
  452. DRM_DEBUG( "%sn", __FUNCTION__ );
  454. BEGIN_RING( 6 );
  456. RADEON_PURGE_CACHE();
  457. RADEON_PURGE_ZCACHE();
  458. RADEON_WAIT_UNTIL_IDLE();
  460. ADVANCE_RING();
  462. return radeon_do_wait_for_idle( dev_priv );
  463. }
  465. /* Start the Command Processor.
  466.  */
  467. static void radeon_do_cp_start( drm_radeon_private_t *dev_priv )
  468. {
  469. RING_LOCALS;
  470. DRM_DEBUG( "%sn", __FUNCTION__ );
  472. radeon_do_wait_for_idle( dev_priv );
  474. RADEON_WRITE( RADEON_CP_CSQ_CNTL, dev_priv->cp_mode );
  476. dev_priv->cp_running = 1;
  478. BEGIN_RING( 6 );
  480. RADEON_PURGE_CACHE();
  481. RADEON_PURGE_ZCACHE();
  482. RADEON_WAIT_UNTIL_IDLE();
  484. ADVANCE_RING();
  485. }
  487. /* Reset the Command Processor.  This will not flush any pending
  488.  * commands, so you must wait for the CP command stream to complete
  489.  * before calling this routine.
  490.  */
  491. static void radeon_do_cp_reset( drm_radeon_private_t *dev_priv )
  492. {
  493. u32 cur_read_ptr;
  494. DRM_DEBUG( "%sn", __FUNCTION__ );
  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. DRM_DEBUG( "%sn", __FUNCTION__ );
  510. RADEON_WRITE( RADEON_CP_CSQ_CNTL, RADEON_CSQ_PRIDIS_INDDIS );
  512. dev_priv->cp_running = 0;
  513. }
  515. /* Reset the engine.  This will stop the CP if it is running.
  516.  */
  517. static int radeon_do_engine_reset( drm_device_t *dev )
  518. {
  519. drm_radeon_private_t *dev_priv = dev->dev_private;
  520. u32 clock_cntl_index, mclk_cntl, rbbm_soft_reset;
  521. DRM_DEBUG( "%sn", __FUNCTION__ );
  523. radeon_do_pixcache_flush( dev_priv );
  525. clock_cntl_index = RADEON_READ( RADEON_CLOCK_CNTL_INDEX );
  526. mclk_cntl = RADEON_READ_PLL( dev, RADEON_MCLK_CNTL );
  528. RADEON_WRITE_PLL( RADEON_MCLK_CNTL, ( mclk_cntl |
  529.       RADEON_FORCEON_MCLKA |
  530.       RADEON_FORCEON_MCLKB |
  531.         RADEON_FORCEON_YCLKA |
  532.       RADEON_FORCEON_YCLKB |
  533.       RADEON_FORCEON_MC |
  534.       RADEON_FORCEON_AIC ) );
  536. rbbm_soft_reset = RADEON_READ( RADEON_RBBM_SOFT_RESET );
  538. RADEON_WRITE( RADEON_RBBM_SOFT_RESET, ( rbbm_soft_reset |
  539. RADEON_SOFT_RESET_CP |
  540. RADEON_SOFT_RESET_HI |
  541. RADEON_SOFT_RESET_SE |
  542. RADEON_SOFT_RESET_RE |
  543. RADEON_SOFT_RESET_PP |
  544. RADEON_SOFT_RESET_E2 |
  545. RADEON_SOFT_RESET_RB ) );
  546. RADEON_READ( RADEON_RBBM_SOFT_RESET );
  547. RADEON_WRITE( RADEON_RBBM_SOFT_RESET, ( rbbm_soft_reset &
  548. ~( RADEON_SOFT_RESET_CP |
  549.    RADEON_SOFT_RESET_HI |
  550.    RADEON_SOFT_RESET_SE |
  551.    RADEON_SOFT_RESET_RE |
  552.    RADEON_SOFT_RESET_PP |
  553.    RADEON_SOFT_RESET_E2 |
  554.    RADEON_SOFT_RESET_RB ) ) );
  555. RADEON_READ( RADEON_RBBM_SOFT_RESET );
  558. RADEON_WRITE_PLL( RADEON_MCLK_CNTL, mclk_cntl );
  559. RADEON_WRITE( RADEON_CLOCK_CNTL_INDEX, clock_cntl_index );
  560. RADEON_WRITE( RADEON_RBBM_SOFT_RESET,  rbbm_soft_reset );
  562. /* Reset the CP ring */
  563. radeon_do_cp_reset( dev_priv );
  565. /* The CP is no longer running after an engine reset */
  566. dev_priv->cp_running = 0;
  568. /* Reset any pending vertex, indirect buffers */
  569. radeon_freelist_reset( dev );
  571. return 0;
  572. }
  574. static void radeon_cp_init_ring_buffer( drm_device_t *dev,
  575.         drm_radeon_private_t *dev_priv )
  576. {
  577. u32 ring_start, cur_read_ptr;
  578. u32 tmp;
  580. /* Initialize the memory controller */
  581. RADEON_WRITE( RADEON_MC_FB_LOCATION,
  582.       (dev_priv->agp_vm_start - 1) & 0xffff0000 );
  584. if ( !dev_priv->is_pci ) {
  585. RADEON_WRITE( RADEON_MC_AGP_LOCATION,
  586.       (((dev_priv->agp_vm_start - 1 +
  587.  dev_priv->agp_size) & 0xffff0000) |
  588.        (dev_priv->agp_vm_start >> 16)) );
  589. }
  591. #if __REALLY_HAVE_AGP
  592. if ( !dev_priv->is_pci )
  593. ring_start = (dev_priv->cp_ring->offset
  594.       - dev->agp->base
  595.       + dev_priv->agp_vm_start);
  596.        else
  597. #endif
  598. ring_start = (dev_priv->cp_ring->offset
  599.       - dev->sg->handle
  600.       + dev_priv->agp_vm_start);
  602. RADEON_WRITE( RADEON_CP_RB_BASE, ring_start );
  604. /* Set the write pointer delay */
  605. RADEON_WRITE( RADEON_CP_RB_WPTR_DELAY, 0 );
  607. /* Initialize the ring buffer's read and write pointers */
  608. cur_read_ptr = RADEON_READ( RADEON_CP_RB_RPTR );
  609. RADEON_WRITE( RADEON_CP_RB_WPTR, cur_read_ptr );
  610. *dev_priv->ring.head = cur_read_ptr;
  611. dev_priv->ring.tail = cur_read_ptr;
  613. if ( !dev_priv->is_pci ) {
  614. RADEON_WRITE( RADEON_CP_RB_RPTR_ADDR,
  615.       dev_priv->ring_rptr->offset );
  616. } else {
  617. drm_sg_mem_t *entry = dev->sg;
  618. unsigned long tmp_ofs, page_ofs;
  620. tmp_ofs = dev_priv->ring_rptr->offset - dev->sg->handle;
  621. page_ofs = tmp_ofs >> PAGE_SHIFT;
  623. RADEON_WRITE( RADEON_CP_RB_RPTR_ADDR,
  624.      entry->busaddr[page_ofs]);
  625. DRM_DEBUG( "ring rptr: offset=0x%08llx handle=0x%08lxn",
  626.    (u64)entry->busaddr[page_ofs],
  627.    entry->handle + tmp_ofs );
  628. }
  630. /* Set ring buffer size */
  631. RADEON_WRITE( RADEON_CP_RB_CNTL, dev_priv->ring.size_l2qw );
  633. radeon_do_wait_for_idle( dev_priv );
  635. /* Turn on bus mastering */
  636. tmp = RADEON_READ( RADEON_BUS_CNTL ) & ~RADEON_BUS_MASTER_DIS;
  637. RADEON_WRITE( RADEON_BUS_CNTL, tmp );
  639. /* Sync everything up */
  640. RADEON_WRITE( RADEON_ISYNC_CNTL,
  641.       (RADEON_ISYNC_ANY2D_IDLE3D |
  642.        RADEON_ISYNC_ANY3D_IDLE2D |
  643.        RADEON_ISYNC_WAIT_IDLEGUI |
  644.        RADEON_ISYNC_CPSCRATCH_IDLEGUI) );
  645. }
  647. static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
  648. {
  649. drm_radeon_private_t *dev_priv;
  650. struct list_head *list;
  651. u32 tmp;
  652. DRM_DEBUG( "%sn", __FUNCTION__ );
  654. dev_priv = DRM(alloc)( sizeof(drm_radeon_private_t), DRM_MEM_DRIVER );
  655. if ( dev_priv == NULL )
  656. return -ENOMEM;
  658. memset( dev_priv, 0, sizeof(drm_radeon_private_t) );
  660. dev_priv->is_pci = init->is_pci;
  662. #if !defined(PCIGART_ENABLED)
  663. /* PCI support is not 100% working, so we disable it here.
  664.  */
  665. if ( dev_priv->is_pci ) {
  666. DRM_ERROR( "PCI GART not yet supported for Radeon!n" );
  667. dev->dev_private = (void *)dev_priv;
  668. radeon_do_cleanup_cp(dev);
  669. return -EINVAL;
  670. }
  671. #endif
  673. if ( dev_priv->is_pci && !dev->sg ) {
  674. DRM_ERROR( "PCI GART memory not allocated!n" );
  675. dev->dev_private = (void *)dev_priv;
  676. radeon_do_cleanup_cp(dev);
  677. return -EINVAL;
  678. }
  680. dev_priv->usec_timeout = init->usec_timeout;
  681. if ( dev_priv->usec_timeout < 1 ||
  682.      dev_priv->usec_timeout > RADEON_MAX_USEC_TIMEOUT ) {
  683. DRM_DEBUG( "TIMEOUT problem!n" );
  684. dev->dev_private = (void *)dev_priv;
  685. radeon_do_cleanup_cp(dev);
  686. return -EINVAL;
  687. }
  689. dev_priv->cp_mode = init->cp_mode;
  691. /* Simple idle check.
  692.  */
  693. atomic_set( &dev_priv->idle_count, 0 );
  695. /* We don't support anything other than bus-mastering ring mode,
  696.  * but the ring can be in either AGP or PCI space for the ring
  697.  * read pointer.
  698.  */
  699. if ( ( init->cp_mode != RADEON_CSQ_PRIBM_INDDIS ) &&
  700.      ( init->cp_mode != RADEON_CSQ_PRIBM_INDBM ) ) {
  701. DRM_DEBUG( "BAD cp_mode (%x)!n", init->cp_mode );
  702. dev->dev_private = (void *)dev_priv;
  703. radeon_do_cleanup_cp(dev);
  704. return -EINVAL;
  705. }
  707. switch ( init->fb_bpp ) {
  708. case 16:
  709. dev_priv->color_fmt = RADEON_COLOR_FORMAT_RGB565;
  710. break;
  711. case 32:
  712. default:
  713. dev_priv->color_fmt = RADEON_COLOR_FORMAT_ARGB8888;
  714. break;
  715. }
  716. dev_priv->front_offset = init->front_offset;
  717. dev_priv->front_pitch = init->front_pitch;
  718. dev_priv->back_offset = init->back_offset;
  719. dev_priv->back_pitch = init->back_pitch;
  721. switch ( init->depth_bpp ) {
  722. case 16:
  723. dev_priv->depth_fmt = RADEON_DEPTH_FORMAT_16BIT_INT_Z;
  724. break;
  725. case 32:
  726. default:
  727. dev_priv->depth_fmt = RADEON_DEPTH_FORMAT_24BIT_INT_Z;
  728. break;
  729. }
  730. dev_priv->depth_offset = init->depth_offset;
  731. dev_priv->depth_pitch = init->depth_pitch;
  733. dev_priv->front_pitch_offset = (((dev_priv->front_pitch/64) << 22) |
  734. (dev_priv->front_offset >> 10));
  735. dev_priv->back_pitch_offset = (((dev_priv->back_pitch/64) << 22) |
  736.        (dev_priv->back_offset >> 10));
  737. dev_priv->depth_pitch_offset = (((dev_priv->depth_pitch/64) << 22) |
  738. (dev_priv->depth_offset >> 10));
  740. /* Hardware state for depth clears.  Remove this if/when we no
  741.  * longer clear the depth buffer with a 3D rectangle.  Hard-code
  742.  * all values to prevent unwanted 3D state from slipping through
  743.  * and screwing with the clear operation.
  744.  */
  745. dev_priv->depth_clear.rb3d_cntl = (RADEON_PLANE_MASK_ENABLE |
  746.    RADEON_Z_ENABLE |
  747.    (dev_priv->color_fmt << 10) |
  748.    RADEON_ZBLOCK16);
  750. dev_priv->depth_clear.rb3d_zstencilcntl = (dev_priv->depth_fmt |
  751.    RADEON_Z_TEST_ALWAYS |
  752.    RADEON_STENCIL_TEST_ALWAYS |
  753.    RADEON_STENCIL_S_FAIL_KEEP |
  754.    RADEON_STENCIL_ZPASS_KEEP |
  755.    RADEON_STENCIL_ZFAIL_KEEP |
  756.    RADEON_Z_WRITE_ENABLE);
  758. dev_priv->depth_clear.se_cntl = (RADEON_FFACE_CULL_CW |
  759.  RADEON_BFACE_SOLID |
  760.  RADEON_FFACE_SOLID |
  761.  RADEON_FLAT_SHADE_VTX_LAST |
  762.  RADEON_DIFFUSE_SHADE_FLAT |
  763.  RADEON_ALPHA_SHADE_FLAT |
  764.  RADEON_SPECULAR_SHADE_FLAT |
  765.  RADEON_FOG_SHADE_FLAT |
  766.  RADEON_VTX_PIX_CENTER_OGL |
  767.  RADEON_ROUND_MODE_TRUNC |
  768.  RADEON_ROUND_PREC_8TH_PIX);
  770. list_for_each(list, &dev->maplist->head) {
  771. drm_map_list_t *r_list = (drm_map_list_t *)list;
  772. if( r_list->map &&
  773.     r_list->map->type == _DRM_SHM &&
  774.     r_list->map->flags & _DRM_CONTAINS_LOCK ) {
  775. dev_priv->sarea = r_list->map;
  776.   break;
  777.   }
  778.   }
  779. if(!dev_priv->sarea) {
  780. DRM_ERROR("could not find sarea!n");
  781. dev->dev_private = (void *)dev_priv;
  782. radeon_do_cleanup_cp(dev);
  783. return -EINVAL;
  784. }
  786. DRM_FIND_MAP( dev_priv->fb, init->fb_offset );
  787. if(!dev_priv->fb) {
  788. DRM_ERROR("could not find framebuffer!n");
  789. dev->dev_private = (void *)dev_priv;
  790. radeon_do_cleanup_cp(dev);
  791. return -EINVAL;
  792. }
  793. DRM_FIND_MAP( dev_priv->mmio, init->mmio_offset );
  794. if(!dev_priv->mmio) {
  795. DRM_ERROR("could not find mmio region!n");
  796. dev->dev_private = (void *)dev_priv;
  797. radeon_do_cleanup_cp(dev);
  798. return -EINVAL;
  799. }
  800. DRM_FIND_MAP( dev_priv->cp_ring, init->ring_offset );
  801. if(!dev_priv->cp_ring) {
  802. DRM_ERROR("could not find cp ring region!n");
  803. dev->dev_private = (void *)dev_priv;
  804. radeon_do_cleanup_cp(dev);
  805. return -EINVAL;
  806. }
  807. DRM_FIND_MAP( dev_priv->ring_rptr, init->ring_rptr_offset );
  808. if(!dev_priv->ring_rptr) {
  809. DRM_ERROR("could not find ring read pointer!n");
  810. dev->dev_private = (void *)dev_priv;
  811. radeon_do_cleanup_cp(dev);
  812. return -EINVAL;
  813. }
  814. DRM_FIND_MAP( dev_priv->buffers, init->buffers_offset );
  815. if(!dev_priv->buffers) {
  816. DRM_ERROR("could not find dma buffer region!n");
  817. dev->dev_private = (void *)dev_priv;
  818. radeon_do_cleanup_cp(dev);
  819. return -EINVAL;
  820. }
  822. if ( !dev_priv->is_pci ) {
  823. DRM_FIND_MAP( dev_priv->agp_textures,
  824.       init->agp_textures_offset );
  825. if(!dev_priv->agp_textures) {
  826. DRM_ERROR("could not find agp texture region!n");
  827. dev->dev_private = (void *)dev_priv;
  828. radeon_do_cleanup_cp(dev);
  829. return -EINVAL;
  830. }
  831. }
  833. dev_priv->sarea_priv =
  834. (drm_radeon_sarea_t *)((u8 *)dev_priv->sarea->handle +
  835.        init->sarea_priv_offset);
  837. if ( !dev_priv->is_pci ) {
  838. DRM_IOREMAP( dev_priv->cp_ring );
  839. DRM_IOREMAP( dev_priv->ring_rptr );
  840. DRM_IOREMAP( dev_priv->buffers );
  841. if(!dev_priv->cp_ring->handle ||
  842.    !dev_priv->ring_rptr->handle ||
  843.    !dev_priv->buffers->handle) {
  844. DRM_ERROR("could not find ioremap agp regions!n");
  845. dev->dev_private = (void *)dev_priv;
  846. radeon_do_cleanup_cp(dev);
  847. return -EINVAL;
  848. }
  849. } else {
  850. dev_priv->cp_ring->handle =
  851. (void *)dev_priv->cp_ring->offset;
  852. dev_priv->ring_rptr->handle =
  853. (void *)dev_priv->ring_rptr->offset;
  854. dev_priv->buffers->handle = (void *)dev_priv->buffers->offset;
  856. DRM_DEBUG( "dev_priv->cp_ring->handle %pn",
  857.    dev_priv->cp_ring->handle );
  858. DRM_DEBUG( "dev_priv->ring_rptr->handle %pn",
  859.    dev_priv->ring_rptr->handle );
  860. DRM_DEBUG( "dev_priv->buffers->handle %pn",
  861.    dev_priv->buffers->handle );
  862. }
  865. dev_priv->agp_size = init->agp_size;
  866. dev_priv->agp_vm_start = RADEON_READ( RADEON_CONFIG_APER_SIZE );
  867. #if __REALLY_HAVE_AGP
  868. if ( !dev_priv->is_pci )
  869. dev_priv->agp_buffers_offset = (dev_priv->buffers->offset
  870. - dev->agp->base
  871. + dev_priv->agp_vm_start);
  872. else
  873. #endif
  874. dev_priv->agp_buffers_offset = (dev_priv->buffers->offset
  875. - dev->sg->handle
  876. + dev_priv->agp_vm_start);
  878. DRM_DEBUG( "dev_priv->agp_size %dn",
  879.    dev_priv->agp_size );
  880. DRM_DEBUG( "dev_priv->agp_vm_start 0x%xn",
  881.    dev_priv->agp_vm_start );
  882. DRM_DEBUG( "dev_priv->agp_buffers_offset 0x%lxn",
  883.    dev_priv->agp_buffers_offset );
  885. dev_priv->ring.head = ((__volatile__ u32 *)
  886.        dev_priv->ring_rptr->handle);
  888. dev_priv->ring.start = (u32 *)dev_priv->cp_ring->handle;
  889. dev_priv->ring.end = ((u32 *)dev_priv->cp_ring->handle
  890.       + init->ring_size / sizeof(u32));
  891. dev_priv->ring.size = init->ring_size;
  892. dev_priv->ring.size_l2qw = DRM(order)( init->ring_size / 8 );
  894. dev_priv->ring.tail_mask =
  895. (dev_priv->ring.size / sizeof(u32)) - 1;
  897. dev_priv->ring.high_mark = RADEON_RING_HIGH_MARK;
  899. #if 0
  900. /* Initialize the scratch register pointer.  This will cause
  901.  * the scratch register values to be written out to memory
  902.  * whenever they are updated.
  903.  * FIXME: This doesn't quite work yet, so we're disabling it
  904.  * for the release.
  905.  */
  906. RADEON_WRITE( RADEON_SCRATCH_ADDR, (dev_priv->ring_rptr->offset +
  907.     RADEON_SCRATCH_REG_OFFSET) );
  908. RADEON_WRITE( RADEON_SCRATCH_UMSK, 0x7 );
  909. #endif
  911. dev_priv->scratch = ((__volatile__ u32 *)
  912.      dev_priv->ring_rptr->handle +
  913.      (RADEON_SCRATCH_REG_OFFSET / sizeof(u32)));
  915. dev_priv->sarea_priv->last_frame = 0;
  916. RADEON_WRITE( RADEON_LAST_FRAME_REG,
  917.       dev_priv->sarea_priv->last_frame );
  919. dev_priv->sarea_priv->last_dispatch = 0;
  920. RADEON_WRITE( RADEON_LAST_DISPATCH_REG,
  921.       dev_priv->sarea_priv->last_dispatch );
  923. dev_priv->sarea_priv->last_clear = 0;
  924. RADEON_WRITE( RADEON_LAST_CLEAR_REG,
  925.       dev_priv->sarea_priv->last_clear );
  927. if ( dev_priv->is_pci ) {
  928. if (!DRM(ati_pcigart_init)( dev, &dev_priv->phys_pci_gart,
  929.     &dev_priv->bus_pci_gart)) {
  930. DRM_ERROR( "failed to init PCI GART!n" );
  931. dev->dev_private = (void *)dev_priv;
  932. radeon_do_cleanup_cp(dev);
  933. return -ENOMEM;
  934. }
  935. /* Turn on PCI GART
  936.  */
  937. tmp = RADEON_READ( RADEON_AIC_CNTL )
  938.       | RADEON_PCIGART_TRANSLATE_EN;
  939. RADEON_WRITE( RADEON_AIC_CNTL, tmp );
  941. /* set PCI GART page-table base address
  942.  */
  943. RADEON_WRITE( RADEON_AIC_PT_BASE, dev_priv->bus_pci_gart );
  945. /* set address range for PCI address translate
  946.  */
  947. RADEON_WRITE( RADEON_AIC_LO_ADDR, dev_priv->agp_vm_start );
  948. RADEON_WRITE( RADEON_AIC_HI_ADDR, dev_priv->agp_vm_start
  949.   + dev_priv->agp_size - 1);
  951. /* Turn off AGP aperture -- is this required for PCIGART?
  952.  */
  953. RADEON_WRITE( RADEON_MC_AGP_LOCATION, 0xffffffc0 ); /* ?? */
  954. RADEON_WRITE( RADEON_AGP_COMMAND, 0 ); /* clear AGP_COMMAND */
  955. } else {
  956. /* Turn off PCI GART
  957.  */
  958. tmp = RADEON_READ( RADEON_AIC_CNTL )
  959.       & ~RADEON_PCIGART_TRANSLATE_EN;
  960. RADEON_WRITE( RADEON_AIC_CNTL, tmp );
  961. }
  963. radeon_cp_load_microcode( dev_priv );
  964. radeon_cp_init_ring_buffer( dev, dev_priv );
  966. #if ROTATE_BUFS
  967. dev_priv->last_buf = 0;
  968. #endif
  970. dev->dev_private = (void *)dev_priv;
  972. radeon_do_engine_reset( dev );
  974. return 0;
  975. }
  977. int radeon_do_cleanup_cp( drm_device_t *dev )
  978. {
  979. DRM_DEBUG( "%sn", __FUNCTION__ );
  981. if ( dev->dev_private ) {
  982. drm_radeon_private_t *dev_priv = dev->dev_private;
  984. if ( !dev_priv->is_pci ) {
  985. DRM_IOREMAPFREE( dev_priv->cp_ring );
  986. DRM_IOREMAPFREE( dev_priv->ring_rptr );
  987. DRM_IOREMAPFREE( dev_priv->buffers );
  988. } else {
  989. if (!DRM(ati_pcigart_cleanup)( dev,
  990. dev_priv->phys_pci_gart,
  991. dev_priv->bus_pci_gart ))
  992. DRM_ERROR( "failed to cleanup PCI GART!n" );
  993. }
  995. DRM(free)( dev->dev_private, sizeof(drm_radeon_private_t),
  996.    DRM_MEM_DRIVER );
  997. dev->dev_private = NULL;
  998. }
  1000. return 0;
  1001. }
  1003. int radeon_cp_init( struct inode *inode, struct file *filp,
  1004.     unsigned int cmd, unsigned long arg )
  1005. {
  1006.         drm_file_t *priv = filp->private_data;
  1007.         drm_device_t *dev = priv->dev;
  1008. drm_radeon_init_t init;
  1010. if ( copy_from_user( &init, (drm_radeon_init_t *)arg, sizeof(init) ) )
  1011. return -EFAULT;
  1013. switch ( init.func ) {
  1014. case RADEON_INIT_CP:
  1015. return radeon_do_init_cp( dev, &init );
  1016. case RADEON_CLEANUP_CP:
  1017. return radeon_do_cleanup_cp( dev );
  1018. }
  1020. return -EINVAL;
  1021. }
  1023. int radeon_cp_start( struct inode *inode, struct file *filp,
  1024.      unsigned int cmd, unsigned long arg )
  1025. {
  1026.         drm_file_t *priv = filp->private_data;
  1027.         drm_device_t *dev = priv->dev;
  1028. drm_radeon_private_t *dev_priv = dev->dev_private;
  1029. DRM_DEBUG( "%sn", __FUNCTION__ );
  1031. LOCK_TEST_WITH_RETURN( dev );
  1033. if ( dev_priv->cp_running ) {
  1034. DRM_DEBUG( "%s while CP runningn", __FUNCTION__ );
  1035. return 0;
  1036. }
  1037. if ( dev_priv->cp_mode == RADEON_CSQ_PRIDIS_INDDIS ) {
  1038. DRM_DEBUG( "%s called with bogus CP mode (%d)n",
  1039.    __FUNCTION__, dev_priv->cp_mode );
  1040. return 0;
  1041. }
  1043. radeon_do_cp_start( dev_priv );
  1045. return 0;
  1046. }
  1048. /* Stop the CP.  The engine must have been idled before calling this
  1049.  * routine.
  1050.  */
  1051. int radeon_cp_stop( struct inode *inode, struct file *filp,
  1052.     unsigned int cmd, unsigned long arg )
  1053. {
  1054.         drm_file_t *priv = filp->private_data;
  1055.         drm_device_t *dev = priv->dev;
  1056. drm_radeon_private_t *dev_priv = dev->dev_private;
  1057. drm_radeon_cp_stop_t stop;
  1058. int ret;
  1059. DRM_DEBUG( "%sn", __FUNCTION__ );
  1061. LOCK_TEST_WITH_RETURN( dev );
  1063. if ( copy_from_user( &stop, (drm_radeon_init_t *)arg, sizeof(stop) ) )
  1064. return -EFAULT;
  1066. /* Flush any pending CP commands.  This ensures any outstanding
  1067.  * commands are exectuted by the engine before we turn it off.
  1068.  */
  1069. if ( stop.flush ) {
  1070. radeon_do_cp_flush( dev_priv );
  1071. }
  1073. /* If we fail to make the engine go idle, we return an error
  1074.  * code so that the DRM ioctl wrapper can try again.
  1075.  */
  1076. if ( stop.idle ) {
  1077. ret = radeon_do_cp_idle( dev_priv );
  1078. if ( ret < 0 ) return ret;
  1079. }
  1081. /* Finally, we can turn off the CP.  If the engine isn't idle,
  1082.  * we will get some dropped triangles as they won't be fully
  1083.  * rendered before the CP is shut down.
  1084.  */
  1085. radeon_do_cp_stop( dev_priv );
  1087. /* Reset the engine */
  1088. radeon_do_engine_reset( dev );
  1090. return 0;
  1091. }
  1093. /* Just reset the CP ring.  Called as part of an X Server engine reset.
  1094.  */
  1095. int radeon_cp_reset( struct inode *inode, struct file *filp,
  1096.      unsigned int cmd, unsigned long arg )
  1097. {
  1098.         drm_file_t *priv = filp->private_data;
  1099.         drm_device_t *dev = priv->dev;
  1100. drm_radeon_private_t *dev_priv = dev->dev_private;
  1101. DRM_DEBUG( "%sn", __FUNCTION__ );
  1103. LOCK_TEST_WITH_RETURN( dev );
  1105. if ( !dev_priv ) {
  1106. DRM_DEBUG( "%s called before init donen", __FUNCTION__ );
  1107. return -EINVAL;
  1108. }
  1110. radeon_do_cp_reset( dev_priv );
  1112. /* The CP is no longer running after an engine reset */
  1113. dev_priv->cp_running = 0;
  1115. return 0;
  1116. }
  1118. int radeon_cp_idle( struct inode *inode, struct file *filp,
  1119.     unsigned int cmd, unsigned long arg )
  1120. {
  1121.         drm_file_t *priv = filp->private_data;
  1122.         drm_device_t *dev = priv->dev;
  1123. drm_radeon_private_t *dev_priv = dev->dev_private;
  1124. DRM_DEBUG( "%sn", __FUNCTION__ );
  1126. LOCK_TEST_WITH_RETURN( dev );
  1128. return radeon_do_cp_idle( dev_priv );
  1129. }
  1131. int radeon_engine_reset( struct inode *inode, struct file *filp,
  1132.  unsigned int cmd, unsigned long arg )
  1133. {
  1134.         drm_file_t *priv = filp->private_data;
  1135.         drm_device_t *dev = priv->dev;
  1136. DRM_DEBUG( "%sn", __FUNCTION__ );
  1138. LOCK_TEST_WITH_RETURN( dev );
  1140. return radeon_do_engine_reset( dev );
  1141. }
  1144. /* ================================================================
  1145.  * Fullscreen mode
  1146.  */
  1148. static int radeon_do_init_pageflip( drm_device_t *dev )
  1149. {
  1150. drm_radeon_private_t *dev_priv = dev->dev_private;
  1151. DRM_DEBUG( "%sn", __FUNCTION__ );
  1153. dev_priv->crtc_offset =      RADEON_READ( RADEON_CRTC_OFFSET );
  1154. dev_priv->crtc_offset_cntl = RADEON_READ( RADEON_CRTC_OFFSET_CNTL );
  1156. RADEON_WRITE( RADEON_CRTC_OFFSET, dev_priv->front_offset );
  1157. RADEON_WRITE( RADEON_CRTC_OFFSET_CNTL,
  1158.       dev_priv->crtc_offset_cntl |
  1159.       RADEON_CRTC_OFFSET_FLIP_CNTL );
  1161. dev_priv->page_flipping = 1;
  1162. dev_priv->current_page = 0;
  1164. return 0;
  1165. }
  1167. int radeon_do_cleanup_pageflip( drm_device_t *dev )
  1168. {
  1169. drm_radeon_private_t *dev_priv = dev->dev_private;
  1170. DRM_DEBUG( "%sn", __FUNCTION__ );
  1172. RADEON_WRITE( RADEON_CRTC_OFFSET,      dev_priv->crtc_offset );
  1173. RADEON_WRITE( RADEON_CRTC_OFFSET_CNTL, dev_priv->crtc_offset_cntl );
  1175. dev_priv->page_flipping = 0;
  1176. dev_priv->current_page = 0;
  1178. return 0;
  1179. }
  1181. int radeon_fullscreen( struct inode *inode, struct file *filp,
  1182.        unsigned int cmd, unsigned long arg )
  1183. {
  1184.         drm_file_t *priv = filp->private_data;
  1185.         drm_device_t *dev = priv->dev;
  1186. drm_radeon_fullscreen_t fs;
  1188. LOCK_TEST_WITH_RETURN( dev );
  1190. if ( copy_from_user( &fs, (drm_radeon_fullscreen_t *)arg,
  1191.      sizeof(fs) ) )
  1192. return -EFAULT;
  1194. switch ( fs.func ) {
  1195. case RADEON_INIT_FULLSCREEN:
  1196. return radeon_do_init_pageflip( dev );
  1197. case RADEON_CLEANUP_FULLSCREEN:
  1198. return radeon_do_cleanup_pageflip( dev );
  1199. }
  1201. return -EINVAL;
  1202. }
  1205. /* ================================================================
  1206.  * Freelist management
  1207.  */
  1208. #define RADEON_BUFFER_USED 0xffffffff
  1209. #define RADEON_BUFFER_FREE 0
  1211. #if 0
  1212. static int radeon_freelist_init( drm_device_t *dev )
  1213. {
  1214. drm_device_dma_t *dma = dev->dma;
  1215. drm_radeon_private_t *dev_priv = dev->dev_private;
  1216. drm_buf_t *buf;
  1217. drm_radeon_buf_priv_t *buf_priv;
  1218. drm_radeon_freelist_t *entry;
  1219. int i;
  1221. dev_priv->head = DRM(alloc)( sizeof(drm_radeon_freelist_t),
  1222.      DRM_MEM_DRIVER );
  1223. if ( dev_priv->head == NULL )
  1224. return -ENOMEM;
  1226. memset( dev_priv->head, 0, sizeof(drm_radeon_freelist_t) );
  1227. dev_priv->head->age = RADEON_BUFFER_USED;
  1229. for ( i = 0 ; i < dma->buf_count ; i++ ) {
  1230. buf = dma->buflist[i];
  1231. buf_priv = buf->dev_private;
  1233. entry = DRM(alloc)( sizeof(drm_radeon_freelist_t),
  1234.     DRM_MEM_DRIVER );
  1235. if ( !entry ) return -ENOMEM;
  1237. entry->age = RADEON_BUFFER_FREE;
  1238. entry->buf = buf;
  1239. entry->prev = dev_priv->head;
  1240. entry->next = dev_priv->head->next;
  1241. if ( !entry->next )
  1242. dev_priv->tail = entry;
  1244. buf_priv->discard = 0;
  1245. buf_priv->dispatched = 0;
  1246. buf_priv->list_entry = entry;
  1248. dev_priv->head->next = entry;
  1250. if ( dev_priv->head->next )
  1251. dev_priv->head->next->prev = entry;
  1252. }
  1254. return 0;
  1256. }
  1257. #endif
  1259. drm_buf_t *radeon_freelist_get( drm_device_t *dev )
  1260. {
  1261. drm_device_dma_t *dma = dev->dma;
  1262. drm_radeon_private_t *dev_priv = dev->dev_private;
  1263. drm_radeon_buf_priv_t *buf_priv;
  1264. drm_buf_t *buf;
  1265. int i, t;
  1266. #if ROTATE_BUFS
  1267. int start;
  1268. #endif
  1270. /* FIXME: Optimize -- use freelist code */
  1272. for ( i = 0 ; i < dma->buf_count ; i++ ) {
  1273. buf = dma->buflist[i];
  1274. buf_priv = buf->dev_private;
  1275. if ( buf->pid == 0 ) {
  1276. DRM_DEBUG( "  ret buf=%d last=%d pid=0n",
  1277.    buf->idx, dev_priv->last_buf );
  1278. return buf;
  1279. }
  1280. DRM_DEBUG( "    skipping buf=%d pid=%dn",
  1281.    buf->idx, buf->pid );
  1282. }
  1284. #if ROTATE_BUFS
  1285. if ( ++dev_priv->last_buf >= dma->buf_count )
  1286. dev_priv->last_buf = 0;
  1287. start = dev_priv->last_buf;
  1288. #endif
  1289. for ( t = 0 ; t < dev_priv->usec_timeout ; t++ ) {
  1290. #if 0
  1291. /* FIXME: Disable this for now */
  1292. u32 done_age = dev_priv->scratch[RADEON_LAST_DISPATCH];
  1293. #else
  1294. u32 done_age = RADEON_READ( RADEON_LAST_DISPATCH_REG );
  1295. #endif
  1296. #if ROTATE_BUFS
  1297. for ( i = start ; i < dma->buf_count ; i++ ) {
  1298. #else
  1299. for ( i = 0 ; i < dma->buf_count ; i++ ) {
  1300. #endif
  1301. buf = dma->buflist[i];
  1302. buf_priv = buf->dev_private;
  1303. if ( buf->pending && buf_priv->age <= done_age ) {
  1304. /* The buffer has been processed, so it
  1305.  * can now be used.
  1306.  */
  1307. buf->pending = 0;
  1308. DRM_DEBUG( "  ret buf=%d last=%d age=%d done=%dn", buf->idx, dev_priv->last_buf, buf_priv->age, done_age );
  1309. return buf;
  1310. }
  1311. DRM_DEBUG( "    skipping buf=%d age=%d done=%dn",
  1312.    buf->idx, buf_priv->age,
  1313.    done_age );
  1314. #if ROTATE_BUFS
  1315. start = 0;
  1316. #endif
  1317. }
  1318. udelay( 1 );
  1319. }
  1321. DRM_ERROR( "returning NULL!n" );
  1322. return NULL;
  1323. }
  1325. void radeon_freelist_reset( drm_device_t *dev )
  1326. {
  1327. drm_device_dma_t *dma = dev->dma;
  1328. #if ROTATE_BUFS
  1329. drm_radeon_private_t *dev_priv = dev->dev_private;
  1330. #endif
  1331. int i;
  1333. #if ROTATE_BUFS
  1334. dev_priv->last_buf = 0;
  1335. #endif
  1336. for ( i = 0 ; i < dma->buf_count ; i++ ) {
  1337. drm_buf_t *buf = dma->buflist[i];
  1338. drm_radeon_buf_priv_t *buf_priv = buf->dev_private;
  1339. buf_priv->age = 0;
  1340. }
  1341. }
  1344. /* ================================================================
  1345.  * CP command submission
  1346.  */
  1348. int radeon_wait_ring( drm_radeon_private_t *dev_priv, int n )
  1349. {
  1350. drm_radeon_ring_buffer_t *ring = &dev_priv->ring;
  1351. int i;
  1353. for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
  1354. radeon_update_ring_snapshot( ring );
  1355. if ( ring->space > n )
  1356. return 0;
  1357. udelay( 1 );
  1358. }
  1360. /* FIXME: This return value is ignored in the BEGIN_RING macro! */
  1361. #if RADEON_FIFO_DEBUG
  1362. radeon_status( dev_priv );
  1363. DRM_ERROR( "failed!n" );
  1364. #endif
  1365. return -EBUSY;
  1366. }
  1368. static int radeon_cp_get_buffers( drm_device_t *dev, drm_dma_t *d )
  1369. {
  1370. int i;
  1371. drm_buf_t *buf;
  1373. for ( i = d->granted_count ; i < d->request_count ; i++ ) {
  1374. buf = radeon_freelist_get( dev );
  1375. if ( !buf ) return -EAGAIN;
  1377. buf->pid = current->pid;
  1379. if ( copy_to_user( &d->request_indices[i], &buf->idx,
  1380.    sizeof(buf->idx) ) )
  1381. return -EFAULT;
  1382. if ( copy_to_user( &d->request_sizes[i], &buf->total,
  1383.    sizeof(buf->total) ) )
  1384. return -EFAULT;
  1386. d->granted_count++;
  1387. }
  1388. return 0;
  1389. }
  1391. int radeon_cp_buffers( struct inode *inode, struct file *filp,
  1392.        unsigned int cmd, unsigned long arg )
  1393. {
  1394. drm_file_t *priv = filp->private_data;
  1395. drm_device_t *dev = priv->dev;
  1396. drm_device_dma_t *dma = dev->dma;
  1397. int ret = 0;
  1398. drm_dma_t d;
  1400. LOCK_TEST_WITH_RETURN( dev );
  1402. if ( copy_from_user( &d, (drm_dma_t *)arg, sizeof(d) ) )
  1403. return -EFAULT;
  1405. /* Please don't send us buffers.
  1406.  */
  1407. if ( d.send_count != 0 ) {
  1408. DRM_ERROR( "Process %d trying to send %d buffers via drmDMAn",
  1409.    current->pid, d.send_count );
  1410. return -EINVAL;
  1411. }
  1413. /* We'll send you buffers.
  1414.  */
  1415. if ( d.request_count < 0 || d.request_count > dma->buf_count ) {
  1416. DRM_ERROR( "Process %d trying to get %d buffers (of %d max)n",
  1417.    current->pid, d.request_count, dma->buf_count );
  1418. return -EINVAL;
  1419. }
  1421. d.granted_count = 0;
  1423. if ( d.request_count ) {
  1424. ret = radeon_cp_get_buffers( dev, &d );
  1425. }
  1427. if ( copy_to_user( (drm_dma_t *)arg, &d, sizeof(d) ) )
  1428. return -EFAULT;
  1430. return ret;
  1431. }