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

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

Linux/Unix编程

开发平台：

Unix_Linux

r128_state.c：源码内容
  1. /* r128_state.c -- State support for r128 -*- linux-c -*-
  2.  * Created: Thu Jan 27 02:53:43 2000 by gareth@valinux.com
  3.  *
  4.  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, 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.  *    Gareth Hughes <gareth@valinux.com>
  28.  */
  30. #include "r128.h"
  31. #include "drmP.h"
  32. #include "r128_drv.h"
  33. #include "drm.h"
  34. #include <linux/delay.h>
  37. /* ================================================================
  38.  * CCE hardware state programming functions
  39.  */
  41. static void r128_emit_clip_rects( drm_r128_private_t *dev_priv,
  42.   drm_clip_rect_t *boxes, int count )
  43. {
  44. u32 aux_sc_cntl = 0x00000000;
  45. RING_LOCALS;
  46. DRM_DEBUG( "    %sn", __FUNCTION__ );
  48. BEGIN_RING( 17 );
  50. if ( count >= 1 ) {
  51. OUT_RING( CCE_PACKET0( R128_AUX1_SC_LEFT, 3 ) );
  52. OUT_RING( boxes[0].x1 );
  53. OUT_RING( boxes[0].x2 - 1 );
  54. OUT_RING( boxes[0].y1 );
  55. OUT_RING( boxes[0].y2 - 1 );
  57. aux_sc_cntl |= (R128_AUX1_SC_EN | R128_AUX1_SC_MODE_OR);
  58. }
  59. if ( count >= 2 ) {
  60. OUT_RING( CCE_PACKET0( R128_AUX2_SC_LEFT, 3 ) );
  61. OUT_RING( boxes[1].x1 );
  62. OUT_RING( boxes[1].x2 - 1 );
  63. OUT_RING( boxes[1].y1 );
  64. OUT_RING( boxes[1].y2 - 1 );
  66. aux_sc_cntl |= (R128_AUX2_SC_EN | R128_AUX2_SC_MODE_OR);
  67. }
  68. if ( count >= 3 ) {
  69. OUT_RING( CCE_PACKET0( R128_AUX3_SC_LEFT, 3 ) );
  70. OUT_RING( boxes[2].x1 );
  71. OUT_RING( boxes[2].x2 - 1 );
  72. OUT_RING( boxes[2].y1 );
  73. OUT_RING( boxes[2].y2 - 1 );
  75. aux_sc_cntl |= (R128_AUX3_SC_EN | R128_AUX3_SC_MODE_OR);
  76. }
  78. OUT_RING( CCE_PACKET0( R128_AUX_SC_CNTL, 0 ) );
  79. OUT_RING( aux_sc_cntl );
  81. ADVANCE_RING();
  82. }
  84. static inline void r128_emit_core( drm_r128_private_t *dev_priv )
  85. {
  86. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  87. drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
  88. RING_LOCALS;
  89. DRM_DEBUG( "    %sn", __FUNCTION__ );
  91. BEGIN_RING( 2 );
  93. OUT_RING( CCE_PACKET0( R128_SCALE_3D_CNTL, 0 ) );
  94. OUT_RING( ctx->scale_3d_cntl );
  96. ADVANCE_RING();
  97. }
  99. static inline void r128_emit_context( drm_r128_private_t *dev_priv )
  100. {
  101. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  102. drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
  103. RING_LOCALS;
  104. DRM_DEBUG( "    %sn", __FUNCTION__ );
  106. BEGIN_RING( 13 );
  108. OUT_RING( CCE_PACKET0( R128_DST_PITCH_OFFSET_C, 11 ) );
  109. OUT_RING( ctx->dst_pitch_offset_c );
  110. OUT_RING( ctx->dp_gui_master_cntl_c );
  111. OUT_RING( ctx->sc_top_left_c );
  112. OUT_RING( ctx->sc_bottom_right_c );
  113. OUT_RING( ctx->z_offset_c );
  114. OUT_RING( ctx->z_pitch_c );
  115. OUT_RING( ctx->z_sten_cntl_c );
  116. OUT_RING( ctx->tex_cntl_c );
  117. OUT_RING( ctx->misc_3d_state_cntl_reg );
  118. OUT_RING( ctx->texture_clr_cmp_clr_c );
  119. OUT_RING( ctx->texture_clr_cmp_msk_c );
  120. OUT_RING( ctx->fog_color_c );
  122. ADVANCE_RING();
  123. }
  125. static inline void r128_emit_setup( drm_r128_private_t *dev_priv )
  126. {
  127. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  128. drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
  129. RING_LOCALS;
  130. DRM_DEBUG( "    %sn", __FUNCTION__ );
  132. BEGIN_RING( 3 );
  134. OUT_RING( CCE_PACKET1( R128_SETUP_CNTL, R128_PM4_VC_FPU_SETUP ) );
  135. OUT_RING( ctx->setup_cntl );
  136. OUT_RING( ctx->pm4_vc_fpu_setup );
  138. ADVANCE_RING();
  139. }
  141. static inline void r128_emit_masks( drm_r128_private_t *dev_priv )
  142. {
  143. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  144. drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
  145. RING_LOCALS;
  146. DRM_DEBUG( "    %sn", __FUNCTION__ );
  148. BEGIN_RING( 5 );
  150. OUT_RING( CCE_PACKET0( R128_DP_WRITE_MASK, 0 ) );
  151. OUT_RING( ctx->dp_write_mask );
  153. OUT_RING( CCE_PACKET0( R128_STEN_REF_MASK_C, 1 ) );
  154. OUT_RING( ctx->sten_ref_mask_c );
  155. OUT_RING( ctx->plane_3d_mask_c );
  157. ADVANCE_RING();
  158. }
  160. static inline void r128_emit_window( drm_r128_private_t *dev_priv )
  161. {
  162. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  163. drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
  164. RING_LOCALS;
  165. DRM_DEBUG( "    %sn", __FUNCTION__ );
  167. BEGIN_RING( 2 );
  169. OUT_RING( CCE_PACKET0( R128_WINDOW_XY_OFFSET, 0 ) );
  170. OUT_RING( ctx->window_xy_offset );
  172. ADVANCE_RING();
  173. }
  175. static inline void r128_emit_tex0( drm_r128_private_t *dev_priv )
  176. {
  177. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  178. drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
  179. drm_r128_texture_regs_t *tex = &sarea_priv->tex_state[0];
  180. int i;
  181. RING_LOCALS;
  182. DRM_DEBUG( "    %sn", __FUNCTION__ );
  184. BEGIN_RING( 7 + R128_MAX_TEXTURE_LEVELS );
  186. OUT_RING( CCE_PACKET0( R128_PRIM_TEX_CNTL_C,
  187.        2 + R128_MAX_TEXTURE_LEVELS ) );
  188. OUT_RING( tex->tex_cntl );
  189. OUT_RING( tex->tex_combine_cntl );
  190. OUT_RING( ctx->tex_size_pitch_c );
  191. for ( i = 0 ; i < R128_MAX_TEXTURE_LEVELS ; i++ ) {
  192. OUT_RING( tex->tex_offset[i] );
  193. }
  195. OUT_RING( CCE_PACKET0( R128_CONSTANT_COLOR_C, 1 ) );
  196. OUT_RING( ctx->constant_color_c );
  197. OUT_RING( tex->tex_border_color );
  199. ADVANCE_RING();
  200. }
  202. static inline void r128_emit_tex1( drm_r128_private_t *dev_priv )
  203. {
  204. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  205. drm_r128_texture_regs_t *tex = &sarea_priv->tex_state[1];
  206. int i;
  207. RING_LOCALS;
  208. DRM_DEBUG( "    %sn", __FUNCTION__ );
  210. BEGIN_RING( 5 + R128_MAX_TEXTURE_LEVELS );
  212. OUT_RING( CCE_PACKET0( R128_SEC_TEX_CNTL_C,
  213.        1 + R128_MAX_TEXTURE_LEVELS ) );
  214. OUT_RING( tex->tex_cntl );
  215. OUT_RING( tex->tex_combine_cntl );
  216. for ( i = 0 ; i < R128_MAX_TEXTURE_LEVELS ; i++ ) {
  217. OUT_RING( tex->tex_offset[i] );
  218. }
  220. OUT_RING( CCE_PACKET0( R128_SEC_TEXTURE_BORDER_COLOR_C, 0 ) );
  221. OUT_RING( tex->tex_border_color );
  223. ADVANCE_RING();
  224. }
  226. static inline void r128_emit_state( drm_r128_private_t *dev_priv )
  227. {
  228. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  229. unsigned int dirty = sarea_priv->dirty;
  231. DRM_DEBUG( "%s: dirty=0x%08xn", __FUNCTION__, dirty );
  233. if ( dirty & R128_UPLOAD_CORE ) {
  234. r128_emit_core( dev_priv );
  235. sarea_priv->dirty &= ~R128_UPLOAD_CORE;
  236. }
  238. if ( dirty & R128_UPLOAD_CONTEXT ) {
  239. r128_emit_context( dev_priv );
  240. sarea_priv->dirty &= ~R128_UPLOAD_CONTEXT;
  241. }
  243. if ( dirty & R128_UPLOAD_SETUP ) {
  244. r128_emit_setup( dev_priv );
  245. sarea_priv->dirty &= ~R128_UPLOAD_SETUP;
  246. }
  248. if ( dirty & R128_UPLOAD_MASKS ) {
  249. r128_emit_masks( dev_priv );
  250. sarea_priv->dirty &= ~R128_UPLOAD_MASKS;
  251. }
  253. if ( dirty & R128_UPLOAD_WINDOW ) {
  254. r128_emit_window( dev_priv );
  255. sarea_priv->dirty &= ~R128_UPLOAD_WINDOW;
  256. }
  258. if ( dirty & R128_UPLOAD_TEX0 ) {
  259. r128_emit_tex0( dev_priv );
  260. sarea_priv->dirty &= ~R128_UPLOAD_TEX0;
  261. }
  263. if ( dirty & R128_UPLOAD_TEX1 ) {
  264. r128_emit_tex1( dev_priv );
  265. sarea_priv->dirty &= ~R128_UPLOAD_TEX1;
  266. }
  268. /* Turn off the texture cache flushing */
  269. sarea_priv->context_state.tex_cntl_c &= ~R128_TEX_CACHE_FLUSH;
  271. sarea_priv->dirty &= ~R128_REQUIRE_QUIESCENCE;
  272. }
  275. #if R128_PERFORMANCE_BOXES
  276. /* ================================================================
  277.  * Performance monitoring functions
  278.  */
  280. static void r128_clear_box( drm_r128_private_t *dev_priv,
  281.     int x, int y, int w, int h,
  282.     int r, int g, int b )
  283. {
  284. u32 pitch, offset;
  285. u32 fb_bpp, color;
  286. RING_LOCALS;
  288. switch ( dev_priv->fb_bpp ) {
  289. case 16:
  290. fb_bpp = R128_GMC_DST_16BPP;
  291. color = (((r & 0xf8) << 8) |
  292.  ((g & 0xfc) << 3) |
  293.  ((b & 0xf8) >> 3));
  294. break;
  295. case 24:
  296. fb_bpp = R128_GMC_DST_24BPP;
  297. color = ((r << 16) | (g << 8) | b);
  298. break;
  299. case 32:
  300. fb_bpp = R128_GMC_DST_32BPP;
  301. color = (((0xff) << 24) | (r << 16) | (g <<  8) | b);
  302. break;
  303. default:
  304. return;
  305. }
  307. offset = dev_priv->back_offset;
  308. pitch = dev_priv->back_pitch >> 3;
  310. BEGIN_RING( 6 );
  312. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  313. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
  314.   R128_GMC_BRUSH_SOLID_COLOR |
  315.   fb_bpp |
  316.   R128_GMC_SRC_DATATYPE_COLOR |
  317.   R128_ROP3_P |
  318.   R128_GMC_CLR_CMP_CNTL_DIS |
  319.   R128_GMC_AUX_CLIP_DIS );
  321. OUT_RING( (pitch << 21) | (offset >> 5) );
  322. OUT_RING( color );
  324. OUT_RING( (x << 16) | y );
  325. OUT_RING( (w << 16) | h );
  327. ADVANCE_RING();
  328. }
  330. static void r128_cce_performance_boxes( drm_r128_private_t *dev_priv )
  331. {
  332. if ( atomic_read( &dev_priv->idle_count ) == 0 ) {
  333. r128_clear_box( dev_priv, 64, 4, 8, 8, 0, 255, 0 );
  334. } else {
  335. atomic_set( &dev_priv->idle_count, 0 );
  336. }
  337. }
  339. #endif
  342. /* ================================================================
  343.  * CCE command dispatch functions
  344.  */
  346. static void r128_print_dirty( const char *msg, unsigned int flags )
  347. {
  348. DRM_INFO( "%s: (0x%x) %s%s%s%s%s%s%s%s%sn",
  349.   msg,
  350.   flags,
  351.   (flags & R128_UPLOAD_CORE)        ? "core, " : "",
  352.   (flags & R128_UPLOAD_CONTEXT)     ? "context, " : "",
  353.   (flags & R128_UPLOAD_SETUP)       ? "setup, " : "",
  354.   (flags & R128_UPLOAD_TEX0)        ? "tex0, " : "",
  355.   (flags & R128_UPLOAD_TEX1)        ? "tex1, " : "",
  356.   (flags & R128_UPLOAD_MASKS)       ? "masks, " : "",
  357.   (flags & R128_UPLOAD_WINDOW)      ? "window, " : "",
  358.   (flags & R128_UPLOAD_CLIPRECTS)   ? "cliprects, " : "",
  359.   (flags & R128_REQUIRE_QUIESCENCE) ? "quiescence, " : "" );
  360. }
  362. static void r128_cce_dispatch_clear( drm_device_t *dev,
  363.      drm_r128_clear_t *clear )
  364. {
  365. drm_r128_private_t *dev_priv = dev->dev_private;
  366. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  367. int nbox = sarea_priv->nbox;
  368. drm_clip_rect_t *pbox = sarea_priv->boxes;
  369. unsigned int flags = clear->flags;
  370. int i;
  371. RING_LOCALS;
  372. DRM_DEBUG( "%sn", __FUNCTION__ );
  374. if ( dev_priv->page_flipping && dev_priv->current_page == 1 ) {
  375. unsigned int tmp = flags;
  377. flags &= ~(R128_FRONT | R128_BACK);
  378. if ( tmp & R128_FRONT ) flags |= R128_BACK;
  379. if ( tmp & R128_BACK )  flags |= R128_FRONT;
  380. }
  382. for ( i = 0 ; i < nbox ; i++ ) {
  383. int x = pbox[i].x1;
  384. int y = pbox[i].y1;
  385. int w = pbox[i].x2 - x;
  386. int h = pbox[i].y2 - y;
  388. DRM_DEBUG( "dispatch clear %d,%d-%d,%d flags 0x%xn",
  389.    pbox[i].x1, pbox[i].y1, pbox[i].x2,
  390.    pbox[i].y2, flags );
  392. if ( flags & (R128_FRONT | R128_BACK) ) {
  393. BEGIN_RING( 2 );
  395. OUT_RING( CCE_PACKET0( R128_DP_WRITE_MASK, 0 ) );
  396. OUT_RING( clear->color_mask );
  398. ADVANCE_RING();
  399. }
  401. if ( flags & R128_FRONT ) {
  402. BEGIN_RING( 6 );
  404. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  405. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
  406.   R128_GMC_BRUSH_SOLID_COLOR |
  407.   (dev_priv->color_fmt << 8) |
  408.   R128_GMC_SRC_DATATYPE_COLOR |
  409.   R128_ROP3_P |
  410.   R128_GMC_CLR_CMP_CNTL_DIS |
  411.   R128_GMC_AUX_CLIP_DIS );
  413. OUT_RING( dev_priv->front_pitch_offset_c );
  414. OUT_RING( clear->clear_color );
  416. OUT_RING( (x << 16) | y );
  417. OUT_RING( (w << 16) | h );
  419. ADVANCE_RING();
  420. }
  422. if ( flags & R128_BACK ) {
  423. BEGIN_RING( 6 );
  425. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  426. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
  427.   R128_GMC_BRUSH_SOLID_COLOR |
  428.   (dev_priv->color_fmt << 8) |
  429.   R128_GMC_SRC_DATATYPE_COLOR |
  430.   R128_ROP3_P |
  431.   R128_GMC_CLR_CMP_CNTL_DIS |
  432.   R128_GMC_AUX_CLIP_DIS );
  434. OUT_RING( dev_priv->back_pitch_offset_c );
  435. OUT_RING( clear->clear_color );
  437. OUT_RING( (x << 16) | y );
  438. OUT_RING( (w << 16) | h );
  440. ADVANCE_RING();
  441. }
  443. if ( flags & R128_DEPTH ) {
  444. BEGIN_RING( 6 );
  446. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  447. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
  448.   R128_GMC_BRUSH_SOLID_COLOR |
  449.   (dev_priv->depth_fmt << 8) |
  450.   R128_GMC_SRC_DATATYPE_COLOR |
  451.   R128_ROP3_P |
  452.   R128_GMC_CLR_CMP_CNTL_DIS |
  453.   R128_GMC_AUX_CLIP_DIS |
  454.   R128_GMC_WR_MSK_DIS );
  456. OUT_RING( dev_priv->depth_pitch_offset_c );
  457. OUT_RING( clear->clear_depth );
  459. OUT_RING( (x << 16) | y );
  460. OUT_RING( (w << 16) | h );
  462. ADVANCE_RING();
  463. }
  464. }
  465. }
  467. static void r128_cce_dispatch_swap( drm_device_t *dev )
  468. {
  469. drm_r128_private_t *dev_priv = dev->dev_private;
  470. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  471. int nbox = sarea_priv->nbox;
  472. drm_clip_rect_t *pbox = sarea_priv->boxes;
  473. int i;
  474. RING_LOCALS;
  475. DRM_DEBUG( "%sn", __FUNCTION__ );
  477. #if R128_PERFORMANCE_BOXES
  478. /* Do some trivial performance monitoring...
  479.  */
  480. r128_cce_performance_boxes( dev_priv );
  481. #endif
  483. for ( i = 0 ; i < nbox ; i++ ) {
  484. int x = pbox[i].x1;
  485. int y = pbox[i].y1;
  486. int w = pbox[i].x2 - x;
  487. int h = pbox[i].y2 - y;
  489. BEGIN_RING( 7 );
  491. OUT_RING( CCE_PACKET3( R128_CNTL_BITBLT_MULTI, 5 ) );
  492. OUT_RING( R128_GMC_SRC_PITCH_OFFSET_CNTL |
  493.   R128_GMC_DST_PITCH_OFFSET_CNTL |
  494.   R128_GMC_BRUSH_NONE |
  495.   (dev_priv->color_fmt << 8) |
  496.   R128_GMC_SRC_DATATYPE_COLOR |
  497.   R128_ROP3_S |
  498.   R128_DP_SRC_SOURCE_MEMORY |
  499.   R128_GMC_CLR_CMP_CNTL_DIS |
  500.   R128_GMC_AUX_CLIP_DIS |
  501.   R128_GMC_WR_MSK_DIS );
  503. OUT_RING( dev_priv->back_pitch_offset_c );
  504. OUT_RING( dev_priv->front_pitch_offset_c );
  506. OUT_RING( (x << 16) | y );
  507. OUT_RING( (x << 16) | y );
  508. OUT_RING( (w << 16) | h );
  510. ADVANCE_RING();
  511. }
  513. /* Increment the frame counter.  The client-side 3D driver must
  514.  * throttle the framerate by waiting for this value before
  515.  * performing the swapbuffer ioctl.
  516.  */
  517. dev_priv->sarea_priv->last_frame++;
  519. BEGIN_RING( 2 );
  521. OUT_RING( CCE_PACKET0( R128_LAST_FRAME_REG, 0 ) );
  522. OUT_RING( dev_priv->sarea_priv->last_frame );
  524. ADVANCE_RING();
  525. }
  527. static void r128_cce_dispatch_flip( drm_device_t *dev )
  528. {
  529. drm_r128_private_t *dev_priv = dev->dev_private;
  530. RING_LOCALS;
  531. DRM_DEBUG( "%s: page=%dn", __FUNCTION__, dev_priv->current_page );
  533. #if R128_PERFORMANCE_BOXES
  534. /* Do some trivial performance monitoring...
  535.  */
  536. r128_cce_performance_boxes( dev_priv );
  537. #endif
  539. BEGIN_RING( 4 );
  541. R128_WAIT_UNTIL_PAGE_FLIPPED();
  542. OUT_RING( CCE_PACKET0( R128_CRTC_OFFSET, 0 ) );
  544. if ( dev_priv->current_page == 0 ) {
  545. OUT_RING( dev_priv->back_offset );
  546. dev_priv->current_page = 1;
  547. } else {
  548. OUT_RING( dev_priv->front_offset );
  549. dev_priv->current_page = 0;
  550. }
  552. ADVANCE_RING();
  554. /* Increment the frame counter.  The client-side 3D driver must
  555.  * throttle the framerate by waiting for this value before
  556.  * performing the swapbuffer ioctl.
  557.  */
  558. dev_priv->sarea_priv->last_frame++;
  560. BEGIN_RING( 2 );
  562. OUT_RING( CCE_PACKET0( R128_LAST_FRAME_REG, 0 ) );
  563. OUT_RING( dev_priv->sarea_priv->last_frame );
  565. ADVANCE_RING();
  566. }
  568. static void r128_cce_dispatch_vertex( drm_device_t *dev,
  569.       drm_buf_t *buf )
  570. {
  571. drm_r128_private_t *dev_priv = dev->dev_private;
  572. drm_r128_buf_priv_t *buf_priv = buf->dev_private;
  573. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  574. int format = sarea_priv->vc_format;
  575. int offset = buf->bus_address;
  576. int size = buf->used;
  577. int prim = buf_priv->prim;
  578. int i = 0;
  579. RING_LOCALS;
  580. DRM_DEBUG( "%s: buf=%d nbox=%dn",
  581.    __FUNCTION__, buf->idx, sarea_priv->nbox );
  583. if ( 0 )
  584. r128_print_dirty( "dispatch_vertex", sarea_priv->dirty );
  586. if ( buf->used ) {
  587. buf_priv->dispatched = 1;
  589. if ( sarea_priv->dirty & ~R128_UPLOAD_CLIPRECTS ) {
  590. r128_emit_state( dev_priv );
  591. }
  593. do {
  594. /* Emit the next set of up to three cliprects */
  595. if ( i < sarea_priv->nbox ) {
  596. r128_emit_clip_rects( dev_priv,
  597.       &sarea_priv->boxes[i],
  598.       sarea_priv->nbox - i );
  599. }
  601. /* Emit the vertex buffer rendering commands */
  602. BEGIN_RING( 5 );
  604. OUT_RING( CCE_PACKET3( R128_3D_RNDR_GEN_INDX_PRIM, 3 ) );
  605. OUT_RING( offset );
  606. OUT_RING( size );
  607. OUT_RING( format );
  608. OUT_RING( prim | R128_CCE_VC_CNTL_PRIM_WALK_LIST |
  609.   (size << R128_CCE_VC_CNTL_NUM_SHIFT) );
  611. ADVANCE_RING();
  613. i += 3;
  614. } while ( i < sarea_priv->nbox );
  615. }
  617. if ( buf_priv->discard ) {
  618. buf_priv->age = dev_priv->sarea_priv->last_dispatch;
  620. /* Emit the vertex buffer age */
  621. BEGIN_RING( 2 );
  623. OUT_RING( CCE_PACKET0( R128_LAST_DISPATCH_REG, 0 ) );
  624. OUT_RING( buf_priv->age );
  626. ADVANCE_RING();
  628. buf->pending = 1;
  629. buf->used = 0;
  630. /* FIXME: Check dispatched field */
  631. buf_priv->dispatched = 0;
  632. }
  634. dev_priv->sarea_priv->last_dispatch++;
  636. sarea_priv->dirty &= ~R128_UPLOAD_CLIPRECTS;
  637. sarea_priv->nbox = 0;
  638. }
  640. static void r128_cce_dispatch_indirect( drm_device_t *dev,
  641. drm_buf_t *buf,
  642. int start, int end )
  643. {
  644. drm_r128_private_t *dev_priv = dev->dev_private;
  645. drm_r128_buf_priv_t *buf_priv = buf->dev_private;
  646. RING_LOCALS;
  647. DRM_DEBUG( "indirect: buf=%d s=0x%x e=0x%xn",
  648.    buf->idx, start, end );
  650. if ( start != end ) {
  651. int offset = buf->bus_address + start;
  652. int dwords = (end - start + 3) / sizeof(u32);
  654. /* Indirect buffer data must be an even number of
  655.  * dwords, so if we've been given an odd number we must
  656.  * pad the data with a Type-2 CCE packet.
  657.  */
  658. if ( dwords & 1 ) {
  659. u32 *data = (u32 *)
  660. ((char *)dev_priv->buffers->handle
  661.  + buf->offset + start);
  662. data[dwords++] = cpu_to_le32( R128_CCE_PACKET2 );
  663. }
  665. buf_priv->dispatched = 1;
  667. /* Fire off the indirect buffer */
  668. BEGIN_RING( 3 );
  670. OUT_RING( CCE_PACKET0( R128_PM4_IW_INDOFF, 1 ) );
  671. OUT_RING( offset );
  672. OUT_RING( dwords );
  674. ADVANCE_RING();
  675. }
  677. if ( buf_priv->discard ) {
  678. buf_priv->age = dev_priv->sarea_priv->last_dispatch;
  680. /* Emit the indirect buffer age */
  681. BEGIN_RING( 2 );
  683. OUT_RING( CCE_PACKET0( R128_LAST_DISPATCH_REG, 0 ) );
  684. OUT_RING( buf_priv->age );
  686. ADVANCE_RING();
  688. buf->pending = 1;
  689. buf->used = 0;
  690. /* FIXME: Check dispatched field */
  691. buf_priv->dispatched = 0;
  692. }
  694. dev_priv->sarea_priv->last_dispatch++;
  695. }
  697. static void r128_cce_dispatch_indices( drm_device_t *dev,
  698.        drm_buf_t *buf,
  699.        int start, int end,
  700.        int count )
  701. {
  702. drm_r128_private_t *dev_priv = dev->dev_private;
  703. drm_r128_buf_priv_t *buf_priv = buf->dev_private;
  704. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  705. int format = sarea_priv->vc_format;
  706. int offset = dev_priv->buffers->offset - dev_priv->cce_buffers_offset;
  707. int prim = buf_priv->prim;
  708. u32 *data;
  709. int dwords;
  710. int i = 0;
  711. RING_LOCALS;
  712. DRM_DEBUG( "indices: s=%d e=%d c=%dn", start, end, count );
  714. if ( 0 )
  715. r128_print_dirty( "dispatch_indices", sarea_priv->dirty );
  717. if ( start != end ) {
  718. buf_priv->dispatched = 1;
  720. if ( sarea_priv->dirty & ~R128_UPLOAD_CLIPRECTS ) {
  721. r128_emit_state( dev_priv );
  722. }
  724. dwords = (end - start + 3) / sizeof(u32);
  726. data = (u32 *)((char *)dev_priv->buffers->handle
  727.        + buf->offset + start);
  729. data[0] = cpu_to_le32( CCE_PACKET3( R128_3D_RNDR_GEN_INDX_PRIM,
  730.     dwords-2 ) );
  732. data[1] = cpu_to_le32( offset );
  733. data[2] = cpu_to_le32( R128_MAX_VB_VERTS );
  734. data[3] = cpu_to_le32( format );
  735. data[4] = cpu_to_le32( (prim | R128_CCE_VC_CNTL_PRIM_WALK_IND |
  736. (count << 16)) );
  738. if ( count & 0x1 ) {
  739. #ifdef __LITTLE_ENDIAN
  740. data[dwords-1] &= 0x0000ffff;
  741. #else
  742. data[dwords-1] &= 0xffff0000;
  743. #endif
  744. }
  746. do {
  747. /* Emit the next set of up to three cliprects */
  748. if ( i < sarea_priv->nbox ) {
  749. r128_emit_clip_rects( dev_priv,
  750.       &sarea_priv->boxes[i],
  751.       sarea_priv->nbox - i );
  752. }
  754. r128_cce_dispatch_indirect( dev, buf, start, end );
  756. i += 3;
  757. } while ( i < sarea_priv->nbox );
  758. }
  760. if ( buf_priv->discard ) {
  761. buf_priv->age = dev_priv->sarea_priv->last_dispatch;
  763. /* Emit the vertex buffer age */
  764. BEGIN_RING( 2 );
  766. OUT_RING( CCE_PACKET0( R128_LAST_DISPATCH_REG, 0 ) );
  767. OUT_RING( buf_priv->age );
  769. ADVANCE_RING();
  771. buf->pending = 1;
  772. /* FIXME: Check dispatched field */
  773. buf_priv->dispatched = 0;
  774. }
  776. dev_priv->sarea_priv->last_dispatch++;
  778. sarea_priv->dirty &= ~R128_UPLOAD_CLIPRECTS;
  779. sarea_priv->nbox = 0;
  780. }
  782. static int r128_cce_dispatch_blit( drm_device_t *dev,
  783.    drm_r128_blit_t *blit )
  784. {
  785. drm_r128_private_t *dev_priv = dev->dev_private;
  786. drm_device_dma_t *dma = dev->dma;
  787. drm_buf_t *buf;
  788. drm_r128_buf_priv_t *buf_priv;
  789. u32 *data;
  790. int dword_shift, dwords;
  791. RING_LOCALS;
  792. DRM_DEBUG( "%sn", __FUNCTION__ );
  794. /* The compiler won't optimize away a division by a variable,
  795.  * even if the only legal values are powers of two.  Thus, we'll
  796.  * use a shift instead.
  797.  */
  798. switch ( blit->format ) {
  799. case R128_DATATYPE_ARGB8888:
  800. dword_shift = 0;
  801. break;
  802. case R128_DATATYPE_ARGB1555:
  803. case R128_DATATYPE_RGB565:
  804. case R128_DATATYPE_ARGB4444:
  805. dword_shift = 1;
  806. break;
  807. case R128_DATATYPE_CI8:
  808. case R128_DATATYPE_RGB8:
  809. dword_shift = 2;
  810. break;
  811. default:
  812. DRM_ERROR( "invalid blit format %dn", blit->format );
  813. return -EINVAL;
  814. }
  816. /* Flush the pixel cache, and mark the contents as Read Invalid.
  817.  * This ensures no pixel data gets mixed up with the texture
  818.  * data from the host data blit, otherwise part of the texture
  819.  * image may be corrupted.
  820.  */
  821. BEGIN_RING( 2 );
  823. OUT_RING( CCE_PACKET0( R128_PC_GUI_CTLSTAT, 0 ) );
  824. OUT_RING( R128_PC_RI_GUI | R128_PC_FLUSH_GUI );
  826. ADVANCE_RING();
  828. /* Dispatch the indirect buffer.
  829.  */
  830. buf = dma->buflist[blit->idx];
  831. buf_priv = buf->dev_private;
  833. if ( buf->pid != current->pid ) {
  834. DRM_ERROR( "process %d using buffer owned by %dn",
  835.    current->pid, buf->pid );
  836. return -EINVAL;
  837. }
  838. if ( buf->pending ) {
  839. DRM_ERROR( "sending pending buffer %dn", blit->idx );
  840. return -EINVAL;
  841. }
  843. buf_priv->discard = 1;
  845. dwords = (blit->width * blit->height) >> dword_shift;
  847. data = (u32 *)((char *)dev_priv->buffers->handle + buf->offset);
  849. data[0] = cpu_to_le32( CCE_PACKET3( R128_CNTL_HOSTDATA_BLT, dwords + 6 ) );
  850. data[1] = cpu_to_le32( (R128_GMC_DST_PITCH_OFFSET_CNTL |
  851. R128_GMC_BRUSH_NONE |
  852. (blit->format << 8) |
  853. R128_GMC_SRC_DATATYPE_COLOR |
  854. R128_ROP3_S |
  855. R128_DP_SRC_SOURCE_HOST_DATA |
  856. R128_GMC_CLR_CMP_CNTL_DIS |
  857. R128_GMC_AUX_CLIP_DIS |
  858. R128_GMC_WR_MSK_DIS) );
  860. data[2] = cpu_to_le32( (blit->pitch << 21) | (blit->offset >> 5) );
  861. data[3] = cpu_to_le32( 0xffffffff );
  862. data[4] = cpu_to_le32( 0xffffffff );
  863. data[5] = cpu_to_le32( (blit->y << 16) | blit->x );
  864. data[6] = cpu_to_le32( (blit->height << 16) | blit->width );
  865. data[7] = cpu_to_le32( dwords );
  867. buf->used = (dwords + 8) * sizeof(u32);
  869. r128_cce_dispatch_indirect( dev, buf, 0, buf->used );
  871. /* Flush the pixel cache after the blit completes.  This ensures
  872.  * the texture data is written out to memory before rendering
  873.  * continues.
  874.  */
  875. BEGIN_RING( 2 );
  877. OUT_RING( CCE_PACKET0( R128_PC_GUI_CTLSTAT, 0 ) );
  878. OUT_RING( R128_PC_FLUSH_GUI );
  880. ADVANCE_RING();
  882. return 0;
  883. }
  886. /* ================================================================
  887.  * Tiled depth buffer management
  888.  *
  889.  * FIXME: These should all set the destination write mask for when we
  890.  * have hardware stencil support.
  891.  */
  893. static int r128_cce_dispatch_write_span( drm_device_t *dev,
  894.  drm_r128_depth_t *depth )
  895. {
  896. drm_r128_private_t *dev_priv = dev->dev_private;
  897. int count, x, y;
  898. u32 *buffer;
  899. u8 *mask;
  900. int i;
  901. RING_LOCALS;
  902. DRM_DEBUG( "%sn", __FUNCTION__ );
  904. count = depth->n;
  905. if ( copy_from_user( &x, depth->x, sizeof(x) ) ) {
  906. return -EFAULT;
  907. }
  908. if ( copy_from_user( &y, depth->y, sizeof(y) ) ) {
  909. return -EFAULT;
  910. }
  912. buffer = kmalloc( depth->n * sizeof(u32), GFP_KERNEL );
  913. if ( buffer == NULL )
  914. return -ENOMEM;
  915. if ( copy_from_user( buffer, depth->buffer,
  916.      depth->n * sizeof(u32) ) ) {
  917. kfree( buffer );
  918. return -EFAULT;
  919. }
  921. if ( depth->mask ) {
  922. mask = kmalloc( depth->n * sizeof(u8), GFP_KERNEL );
  923. if ( mask == NULL ) {
  924. kfree( buffer );
  925. return -ENOMEM;
  926. }
  927. if ( copy_from_user( mask, depth->mask,
  928.      depth->n * sizeof(u8) ) ) {
  929. kfree( buffer );
  930. kfree( mask );
  931. return -EFAULT;
  932. }
  934. for ( i = 0 ; i < count ; i++, x++ ) {
  935. if ( mask[i] ) {
  936. BEGIN_RING( 6 );
  938. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  939. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
  940.   R128_GMC_BRUSH_SOLID_COLOR |
  941.   (dev_priv->depth_fmt << 8) |
  942.   R128_GMC_SRC_DATATYPE_COLOR |
  943.   R128_ROP3_P |
  944.   R128_GMC_CLR_CMP_CNTL_DIS |
  945.   R128_GMC_WR_MSK_DIS );
  947. OUT_RING( dev_priv->depth_pitch_offset_c );
  948. OUT_RING( buffer[i] );
  950. OUT_RING( (x << 16) | y );
  951. OUT_RING( (1 << 16) | 1 );
  953. ADVANCE_RING();
  954. }
  955. }
  957. kfree( mask );
  958. } else {
  959. for ( i = 0 ; i < count ; i++, x++ ) {
  960. BEGIN_RING( 6 );
  962. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  963. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
  964.   R128_GMC_BRUSH_SOLID_COLOR |
  965.   (dev_priv->depth_fmt << 8) |
  966.   R128_GMC_SRC_DATATYPE_COLOR |
  967.   R128_ROP3_P |
  968.   R128_GMC_CLR_CMP_CNTL_DIS |
  969.   R128_GMC_WR_MSK_DIS );
  971. OUT_RING( dev_priv->depth_pitch_offset_c );
  972. OUT_RING( buffer[i] );
  974. OUT_RING( (x << 16) | y );
  975. OUT_RING( (1 << 16) | 1 );
  977. ADVANCE_RING();
  978. }
  979. }
  981. kfree( buffer );
  983. return 0;
  984. }
  986. static int r128_cce_dispatch_write_pixels( drm_device_t *dev,
  987.    drm_r128_depth_t *depth )
  988. {
  989. drm_r128_private_t *dev_priv = dev->dev_private;
  990. int count, *x, *y;
  991. u32 *buffer;
  992. u8 *mask;
  993. int i;
  994. RING_LOCALS;
  995. DRM_DEBUG( "%sn", __FUNCTION__ );
  997. count = depth->n;
  999. x = kmalloc( count * sizeof(*x), GFP_KERNEL );
  1000. if ( x == NULL ) {
  1001. return -ENOMEM;
  1002. }
  1003. y = kmalloc( count * sizeof(*y), GFP_KERNEL );
  1004. if ( y == NULL ) {
  1005. kfree( x );
  1006. return -ENOMEM;
  1007. }
  1008. if ( copy_from_user( x, depth->x, count * sizeof(int) ) ) {
  1009. kfree( x );
  1010. kfree( y );
  1011. return -EFAULT;
  1012. }
  1013. if ( copy_from_user( y, depth->y, count * sizeof(int) ) ) {
  1014. kfree( x );
  1015. kfree( y );
  1016. return -EFAULT;
  1017. }
  1019. buffer = kmalloc( depth->n * sizeof(u32), GFP_KERNEL );
  1020. if ( buffer == NULL ) {
  1021. kfree( x );
  1022. kfree( y );
  1023. return -ENOMEM;
  1024. }
  1025. if ( copy_from_user( buffer, depth->buffer,
  1026.      depth->n * sizeof(u32) ) ) {
  1027. kfree( x );
  1028. kfree( y );
  1029. kfree( buffer );
  1030. return -EFAULT;
  1031. }
  1033. if ( depth->mask ) {
  1034. mask = kmalloc( depth->n * sizeof(u8), GFP_KERNEL );
  1035. if ( mask == NULL ) {
  1036. kfree( x );
  1037. kfree( y );
  1038. kfree( buffer );
  1039. return -ENOMEM;
  1040. }
  1041. if ( copy_from_user( mask, depth->mask,
  1042.      depth->n * sizeof(u8) ) ) {
  1043. kfree( x );
  1044. kfree( y );
  1045. kfree( buffer );
  1046. kfree( mask );
  1047. return -EFAULT;
  1048. }
  1050. for ( i = 0 ; i < count ; i++ ) {
  1051. if ( mask[i] ) {
  1052. BEGIN_RING( 6 );
  1054. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  1055. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
  1056.   R128_GMC_BRUSH_SOLID_COLOR |
  1057.   (dev_priv->depth_fmt << 8) |
  1058.   R128_GMC_SRC_DATATYPE_COLOR |
  1059.   R128_ROP3_P |
  1060.   R128_GMC_CLR_CMP_CNTL_DIS |
  1061.   R128_GMC_WR_MSK_DIS );
  1063. OUT_RING( dev_priv->depth_pitch_offset_c );
  1064. OUT_RING( buffer[i] );
  1066. OUT_RING( (x[i] << 16) | y[i] );
  1067. OUT_RING( (1 << 16) | 1 );
  1069. ADVANCE_RING();
  1070. }
  1071. }
  1073. kfree( mask );
  1074. } else {
  1075. for ( i = 0 ; i < count ; i++ ) {
  1076. BEGIN_RING( 6 );
  1078. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  1079. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL |
  1080.   R128_GMC_BRUSH_SOLID_COLOR |
  1081.   (dev_priv->depth_fmt << 8) |
  1082.   R128_GMC_SRC_DATATYPE_COLOR |
  1083.   R128_ROP3_P |
  1084.   R128_GMC_CLR_CMP_CNTL_DIS |
  1085.   R128_GMC_WR_MSK_DIS );
  1087. OUT_RING( dev_priv->depth_pitch_offset_c );
  1088. OUT_RING( buffer[i] );
  1090. OUT_RING( (x[i] << 16) | y[i] );
  1091. OUT_RING( (1 << 16) | 1 );
  1093. ADVANCE_RING();
  1094. }
  1095. }
  1097. kfree( x );
  1098. kfree( y );
  1099. kfree( buffer );
  1101. return 0;
  1102. }
  1104. static int r128_cce_dispatch_read_span( drm_device_t *dev,
  1105. drm_r128_depth_t *depth )
  1106. {
  1107. drm_r128_private_t *dev_priv = dev->dev_private;
  1108. int count, x, y;
  1109. RING_LOCALS;
  1110. DRM_DEBUG( "%sn", __FUNCTION__ );
  1112. count = depth->n;
  1113. if ( copy_from_user( &x, depth->x, sizeof(x) ) ) {
  1114. return -EFAULT;
  1115. }
  1116. if ( copy_from_user( &y, depth->y, sizeof(y) ) ) {
  1117. return -EFAULT;
  1118. }
  1120. BEGIN_RING( 7 );
  1122. OUT_RING( CCE_PACKET3( R128_CNTL_BITBLT_MULTI, 5 ) );
  1123. OUT_RING( R128_GMC_SRC_PITCH_OFFSET_CNTL |
  1124.   R128_GMC_DST_PITCH_OFFSET_CNTL |
  1125.   R128_GMC_BRUSH_NONE |
  1126.   (dev_priv->depth_fmt << 8) |
  1127.   R128_GMC_SRC_DATATYPE_COLOR |
  1128.   R128_ROP3_S |
  1129.   R128_DP_SRC_SOURCE_MEMORY |
  1130.   R128_GMC_CLR_CMP_CNTL_DIS |
  1131.   R128_GMC_WR_MSK_DIS );
  1133. OUT_RING( dev_priv->depth_pitch_offset_c );
  1134. OUT_RING( dev_priv->span_pitch_offset_c );
  1136. OUT_RING( (x << 16) | y );
  1137. OUT_RING( (0 << 16) | 0 );
  1138. OUT_RING( (count << 16) | 1 );
  1140. ADVANCE_RING();
  1142. return 0;
  1143. }
  1145. static int r128_cce_dispatch_read_pixels( drm_device_t *dev,
  1146.   drm_r128_depth_t *depth )
  1147. {
  1148. drm_r128_private_t *dev_priv = dev->dev_private;
  1149. int count, *x, *y;
  1150. int i;
  1151. RING_LOCALS;
  1152. DRM_DEBUG( "%sn", __FUNCTION__ );
  1154. count = depth->n;
  1155. if ( count > dev_priv->depth_pitch ) {
  1156. count = dev_priv->depth_pitch;
  1157. }
  1159. x = kmalloc( count * sizeof(*x), GFP_KERNEL );
  1160. if ( x == NULL ) {
  1161. return -ENOMEM;
  1162. }
  1163. y = kmalloc( count * sizeof(*y), GFP_KERNEL );
  1164. if ( y == NULL ) {
  1165. kfree( x );
  1166. return -ENOMEM;
  1167. }
  1168. if ( copy_from_user( x, depth->x, count * sizeof(int) ) ) {
  1169. kfree( x );
  1170. kfree( y );
  1171. return -EFAULT;
  1172. }
  1173. if ( copy_from_user( y, depth->y, count * sizeof(int) ) ) {
  1174. kfree( x );
  1175. kfree( y );
  1176. return -EFAULT;
  1177. }
  1179. for ( i = 0 ; i < count ; i++ ) {
  1180. BEGIN_RING( 7 );
  1182. OUT_RING( CCE_PACKET3( R128_CNTL_BITBLT_MULTI, 5 ) );
  1183. OUT_RING( R128_GMC_SRC_PITCH_OFFSET_CNTL |
  1184.   R128_GMC_DST_PITCH_OFFSET_CNTL |
  1185.   R128_GMC_BRUSH_NONE |
  1186.   (dev_priv->depth_fmt << 8) |
  1187.   R128_GMC_SRC_DATATYPE_COLOR |
  1188.   R128_ROP3_S |
  1189.   R128_DP_SRC_SOURCE_MEMORY |
  1190.   R128_GMC_CLR_CMP_CNTL_DIS |
  1191.   R128_GMC_WR_MSK_DIS );
  1193. OUT_RING( dev_priv->depth_pitch_offset_c );
  1194. OUT_RING( dev_priv->span_pitch_offset_c );
  1196. OUT_RING( (x[i] << 16) | y[i] );
  1197. OUT_RING( (i << 16) | 0 );
  1198. OUT_RING( (1 << 16) | 1 );
  1200. ADVANCE_RING();
  1201. }
  1203. kfree( x );
  1204. kfree( y );
  1206. return 0;
  1207. }
  1210. /* ================================================================
  1211.  * Polygon stipple
  1212.  */
  1214. static void r128_cce_dispatch_stipple( drm_device_t *dev, u32 *stipple )
  1215. {
  1216. drm_r128_private_t *dev_priv = dev->dev_private;
  1217. int i;
  1218. RING_LOCALS;
  1219. DRM_DEBUG( "%sn", __FUNCTION__ );
  1221. BEGIN_RING( 33 );
  1223. OUT_RING( CCE_PACKET0( R128_BRUSH_DATA0, 31 ) );
  1224. for ( i = 0 ; i < 32 ; i++ ) {
  1225. OUT_RING( stipple[i] );
  1226. }
  1228. ADVANCE_RING();
  1229. }
  1232. /* ================================================================
  1233.  * IOCTL functions
  1234.  */
  1236. int r128_cce_clear( struct inode *inode, struct file *filp,
  1237.     unsigned int cmd, unsigned long arg )
  1238. {
  1239. drm_file_t *priv = filp->private_data;
  1240. drm_device_t *dev = priv->dev;
  1241. drm_r128_private_t *dev_priv = dev->dev_private;
  1242. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  1243. drm_r128_clear_t clear;
  1244. DRM_DEBUG( "%sn", __FUNCTION__ );
  1246. LOCK_TEST_WITH_RETURN( dev );
  1248. if ( copy_from_user( &clear, (drm_r128_clear_t *) arg,
  1249.      sizeof(clear) ) )
  1250. return -EFAULT;
  1252. RING_SPACE_TEST_WITH_RETURN( dev_priv );
  1254. if ( sarea_priv->nbox > R128_NR_SAREA_CLIPRECTS )
  1255. sarea_priv->nbox = R128_NR_SAREA_CLIPRECTS;
  1257. r128_cce_dispatch_clear( dev, &clear );
  1259. /* Make sure we restore the 3D state next time.
  1260.  */
  1261. dev_priv->sarea_priv->dirty |= R128_UPLOAD_CONTEXT | R128_UPLOAD_MASKS;
  1263. return 0;
  1264. }
  1266. int r128_cce_swap( struct inode *inode, struct file *filp,
  1267.    unsigned int cmd, unsigned long arg )
  1268. {
  1269. drm_file_t *priv = filp->private_data;
  1270. drm_device_t *dev = priv->dev;
  1271. drm_r128_private_t *dev_priv = dev->dev_private;
  1272. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  1273. DRM_DEBUG( "%sn", __FUNCTION__ );
  1275. LOCK_TEST_WITH_RETURN( dev );
  1277. RING_SPACE_TEST_WITH_RETURN( dev_priv );
  1279. if ( sarea_priv->nbox > R128_NR_SAREA_CLIPRECTS )
  1280. sarea_priv->nbox = R128_NR_SAREA_CLIPRECTS;
  1282. if ( !dev_priv->page_flipping ) {
  1283. r128_cce_dispatch_swap( dev );
  1284. dev_priv->sarea_priv->dirty |= (R128_UPLOAD_CONTEXT |
  1285. R128_UPLOAD_MASKS);
  1286. } else {
  1287. r128_cce_dispatch_flip( dev );
  1288. }
  1290. return 0;
  1291. }
  1293. int r128_cce_vertex( struct inode *inode, struct file *filp,
  1294.      unsigned int cmd, unsigned long arg )
  1295. {
  1296. drm_file_t *priv = filp->private_data;
  1297. drm_device_t *dev = priv->dev;
  1298. drm_r128_private_t *dev_priv = dev->dev_private;
  1299. drm_device_dma_t *dma = dev->dma;
  1300. drm_buf_t *buf;
  1301. drm_r128_buf_priv_t *buf_priv;
  1302. drm_r128_vertex_t vertex;
  1304. LOCK_TEST_WITH_RETURN( dev );
  1306. if ( !dev_priv ) {
  1307. DRM_ERROR( "%s called with no initializationn", __FUNCTION__ );
  1308. return -EINVAL;
  1309. }
  1311. if ( copy_from_user( &vertex, (drm_r128_vertex_t *)arg,
  1312.      sizeof(vertex) ) )
  1313. return -EFAULT;
  1315. DRM_DEBUG( "%s: pid=%d index=%d count=%d discard=%dn",
  1316.    __FUNCTION__, current->pid,
  1317.    vertex.idx, vertex.count, vertex.discard );
  1319. if ( vertex.idx < 0 || vertex.idx >= dma->buf_count ) {
  1320. DRM_ERROR( "buffer index %d (of %d max)n",
  1321.    vertex.idx, dma->buf_count - 1 );
  1322. return -EINVAL;
  1323. }
  1324. if ( vertex.prim < 0 ||
  1325.      vertex.prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2 ) {
  1326. DRM_ERROR( "buffer prim %dn", vertex.prim );
  1327. return -EINVAL;
  1328. }
  1330. RING_SPACE_TEST_WITH_RETURN( dev_priv );
  1331. VB_AGE_TEST_WITH_RETURN( dev_priv );
  1333. buf = dma->buflist[vertex.idx];
  1334. buf_priv = buf->dev_private;
  1336. if ( buf->pid != current->pid ) {
  1337. DRM_ERROR( "process %d using buffer owned by %dn",
  1338.    current->pid, buf->pid );
  1339. return -EINVAL;
  1340. }
  1341. if ( buf->pending ) {
  1342. DRM_ERROR( "sending pending buffer %dn", vertex.idx );
  1343. return -EINVAL;
  1344. }
  1346. buf->used = vertex.count;
  1347. buf_priv->prim = vertex.prim;
  1348. buf_priv->discard = vertex.discard;
  1350. r128_cce_dispatch_vertex( dev, buf );
  1352. return 0;
  1353. }
  1355. int r128_cce_indices( struct inode *inode, struct file *filp,
  1356.       unsigned int cmd, unsigned long arg )
  1357. {
  1358. drm_file_t *priv = filp->private_data;
  1359. drm_device_t *dev = priv->dev;
  1360. drm_r128_private_t *dev_priv = dev->dev_private;
  1361. drm_device_dma_t *dma = dev->dma;
  1362. drm_buf_t *buf;
  1363. drm_r128_buf_priv_t *buf_priv;
  1364. drm_r128_indices_t elts;
  1365. int count;
  1367. LOCK_TEST_WITH_RETURN( dev );
  1369. if ( !dev_priv ) {
  1370. DRM_ERROR( "%s called with no initializationn", __FUNCTION__ );
  1371. return -EINVAL;
  1372. }
  1374. if ( copy_from_user( &elts, (drm_r128_indices_t *)arg,
  1375.      sizeof(elts) ) )
  1376. return -EFAULT;
  1378. DRM_DEBUG( "%s: pid=%d buf=%d s=%d e=%d d=%dn",
  1379.    __FUNCTION__, current->pid,
  1380.    elts.idx, elts.start, elts.end, elts.discard );
  1382. if ( elts.idx < 0 || elts.idx >= dma->buf_count ) {
  1383. DRM_ERROR( "buffer index %d (of %d max)n",
  1384.    elts.idx, dma->buf_count - 1 );
  1385. return -EINVAL;
  1386. }
  1387. if ( elts.prim < 0 ||
  1388.      elts.prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2 ) {
  1389. DRM_ERROR( "buffer prim %dn", elts.prim );
  1390. return -EINVAL;
  1391. }
  1393. RING_SPACE_TEST_WITH_RETURN( dev_priv );
  1394. VB_AGE_TEST_WITH_RETURN( dev_priv );
  1396. buf = dma->buflist[elts.idx];
  1397. buf_priv = buf->dev_private;
  1399. if ( buf->pid != current->pid ) {
  1400. DRM_ERROR( "process %d using buffer owned by %dn",
  1401.    current->pid, buf->pid );
  1402. return -EINVAL;
  1403. }
  1404. if ( buf->pending ) {
  1405. DRM_ERROR( "sending pending buffer %dn", elts.idx );
  1406. return -EINVAL;
  1407. }
  1409. count = (elts.end - elts.start) / sizeof(u16);
  1410. elts.start -= R128_INDEX_PRIM_OFFSET;
  1412. if ( elts.start & 0x7 ) {
  1413. DRM_ERROR( "misaligned buffer 0x%xn", elts.start );
  1414. return -EINVAL;
  1415. }
  1416. if ( elts.start < buf->used ) {
  1417. DRM_ERROR( "no header 0x%x - 0x%xn", elts.start, buf->used );
  1418. return -EINVAL;
  1419. }
  1421. buf->used = elts.end;
  1422. buf_priv->prim = elts.prim;
  1423. buf_priv->discard = elts.discard;
  1425. r128_cce_dispatch_indices( dev, buf, elts.start, elts.end, count );
  1427. return 0;
  1428. }
  1430. int r128_cce_blit( struct inode *inode, struct file *filp,
  1431.    unsigned int cmd, unsigned long arg )
  1432. {
  1433. drm_file_t *priv = filp->private_data;
  1434. drm_device_t *dev = priv->dev;
  1435. drm_device_dma_t *dma = dev->dma;
  1436. drm_r128_private_t *dev_priv = dev->dev_private;
  1437. drm_r128_blit_t blit;
  1439. LOCK_TEST_WITH_RETURN( dev );
  1441. if ( copy_from_user( &blit, (drm_r128_blit_t *)arg,
  1442.      sizeof(blit) ) )
  1443. return -EFAULT;
  1445. DRM_DEBUG( "%s: pid=%d index=%dn",
  1446.    __FUNCTION__, current->pid, blit.idx );
  1448. if ( blit.idx < 0 || blit.idx >= dma->buf_count ) {
  1449. DRM_ERROR( "buffer index %d (of %d max)n",
  1450.    blit.idx, dma->buf_count - 1 );
  1451. return -EINVAL;
  1452. }
  1454. RING_SPACE_TEST_WITH_RETURN( dev_priv );
  1455. VB_AGE_TEST_WITH_RETURN( dev_priv );
  1457. return r128_cce_dispatch_blit( dev, &blit );
  1458. }
  1460. int r128_cce_depth( struct inode *inode, struct file *filp,
  1461.     unsigned int cmd, unsigned long arg )
  1462. {
  1463. drm_file_t *priv = filp->private_data;
  1464. drm_device_t *dev = priv->dev;
  1465. drm_r128_private_t *dev_priv = dev->dev_private;
  1466. drm_r128_depth_t depth;
  1468. LOCK_TEST_WITH_RETURN( dev );
  1470. if ( copy_from_user( &depth, (drm_r128_depth_t *)arg,
  1471.      sizeof(depth) ) )
  1472. return -EFAULT;
  1474. RING_SPACE_TEST_WITH_RETURN( dev_priv );
  1476. switch ( depth.func ) {
  1477. case R128_WRITE_SPAN:
  1478. return r128_cce_dispatch_write_span( dev, &depth );
  1479. case R128_WRITE_PIXELS:
  1480. return r128_cce_dispatch_write_pixels( dev, &depth );
  1481. case R128_READ_SPAN:
  1482. return r128_cce_dispatch_read_span( dev, &depth );
  1483. case R128_READ_PIXELS:
  1484. return r128_cce_dispatch_read_pixels( dev, &depth );
  1485. }
  1487. return -EINVAL;
  1488. }
  1490. int r128_cce_stipple( struct inode *inode, struct file *filp,
  1491.       unsigned int cmd, unsigned long arg )
  1492. {
  1493. drm_file_t *priv = filp->private_data;
  1494. drm_device_t *dev = priv->dev;
  1495. drm_r128_private_t *dev_priv = dev->dev_private;
  1496. drm_r128_stipple_t stipple;
  1497. u32 mask[32];
  1499. LOCK_TEST_WITH_RETURN( dev );
  1501. if ( copy_from_user( &stipple, (drm_r128_stipple_t *)arg,
  1502.      sizeof(stipple) ) )
  1503. return -EFAULT;
  1505. if ( copy_from_user( &mask, stipple.mask,
  1506.      32 * sizeof(u32) ) )
  1507. return -EFAULT;
  1509. RING_SPACE_TEST_WITH_RETURN( dev_priv );
  1511. r128_cce_dispatch_stipple( dev, mask );
  1513. return 0;
  1514. }
  1516. int r128_cce_indirect( struct inode *inode, struct file *filp,
  1517.        unsigned int cmd, unsigned long arg )
  1518. {
  1519. drm_file_t *priv = filp->private_data;
  1520. drm_device_t *dev = priv->dev;
  1521. drm_r128_private_t *dev_priv = dev->dev_private;
  1522. drm_device_dma_t *dma = dev->dma;
  1523. drm_buf_t *buf;
  1524. drm_r128_buf_priv_t *buf_priv;
  1525. drm_r128_indirect_t indirect;
  1526. #if 0
  1527. RING_LOCALS;
  1528. #endif
  1530. LOCK_TEST_WITH_RETURN( dev );
  1532. if ( !dev_priv ) {
  1533. DRM_ERROR( "%s called with no initializationn", __FUNCTION__ );
  1534. return -EINVAL;
  1535. }
  1537. if ( copy_from_user( &indirect, (drm_r128_indirect_t *)arg,
  1538.      sizeof(indirect) ) )
  1539. return -EFAULT;
  1541. DRM_DEBUG( "indirect: idx=%d s=%d e=%d d=%dn",
  1542.    indirect.idx, indirect.start,
  1543.    indirect.end, indirect.discard );
  1545. if ( indirect.idx < 0 || indirect.idx >= dma->buf_count ) {
  1546. DRM_ERROR( "buffer index %d (of %d max)n",
  1547.    indirect.idx, dma->buf_count - 1 );
  1548. return -EINVAL;
  1549. }
  1551. buf = dma->buflist[indirect.idx];
  1552. buf_priv = buf->dev_private;
  1554. if ( buf->pid != current->pid ) {
  1555. DRM_ERROR( "process %d using buffer owned by %dn",
  1556.    current->pid, buf->pid );
  1557. return -EINVAL;
  1558. }
  1559. if ( buf->pending ) {
  1560. DRM_ERROR( "sending pending buffer %dn", indirect.idx );
  1561. return -EINVAL;
  1562. }
  1564. if ( indirect.start < buf->used ) {
  1565. DRM_ERROR( "reusing indirect: start=0x%x actual=0x%xn",
  1566.    indirect.start, buf->used );
  1567. return -EINVAL;
  1568. }
  1570. RING_SPACE_TEST_WITH_RETURN( dev_priv );
  1571. VB_AGE_TEST_WITH_RETURN( dev_priv );
  1573. buf->used = indirect.end;
  1574. buf_priv->discard = indirect.discard;
  1576. #if 0
  1577. /* Wait for the 3D stream to idle before the indirect buffer
  1578.  * containing 2D acceleration commands is processed.
  1579.  */
  1580. BEGIN_RING( 2 );
  1581. RADEON_WAIT_UNTIL_3D_IDLE();
  1582. ADVANCE_RING();
  1583. #endif
  1585. /* Dispatch the indirect buffer full of commands from the
  1586.  * X server.  This is insecure and is thus only available to
  1587.  * privileged clients.
  1588.  */
  1589. r128_cce_dispatch_indirect( dev, buf, indirect.start, indirect.end );
  1591. return 0;
  1592. }