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

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

嵌入式Linux

开发平台：

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.  *
  29.  */
  31. #define __NO_VERSION__
  32. #include "drmP.h"
  33. #include "r128_drv.h"
  34. #include "drm.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_TEX_MAXLEVELS );
  186. OUT_RING( CCE_PACKET0( R128_PRIM_TEX_CNTL_C,
  187.        2 + R128_TEX_MAXLEVELS ) );
  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_TEX_MAXLEVELS ; 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_TEX_MAXLEVELS );
  212. OUT_RING( CCE_PACKET0( R128_SEC_TEX_CNTL_C,
  213.        1 + R128_TEX_MAXLEVELS ) );
  214. OUT_RING( tex->tex_cntl );
  215. OUT_RING( tex->tex_combine_cntl );
  216. for ( i = 0 ; i < R128_TEX_MAXLEVELS ; 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.      unsigned int flags,
  364.      int cx, int cy, int cw, int ch,
  365.      unsigned int clear_color,
  366.      unsigned int clear_depth )
  367. {
  368. drm_r128_private_t *dev_priv = dev->dev_private;
  369. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  370. int nbox = sarea_priv->nbox;
  371. drm_clip_rect_t *pbox = sarea_priv->boxes;
  372. u32 fb_bpp, depth_bpp;
  373. int i;
  374. RING_LOCALS;
  375. DRM_DEBUG( "%sn", __FUNCTION__ );
  377. r128_update_ring_snapshot( dev_priv );
  379. switch ( dev_priv->fb_bpp ) {
  380. case 16:
  381. fb_bpp = R128_GMC_DST_16BPP;
  382. break;
  383. case 32:
  384. fb_bpp = R128_GMC_DST_32BPP;
  385. break;
  386. default:
  387. return;
  388. }
  389. switch ( dev_priv->depth_bpp ) {
  390. case 16:
  391. depth_bpp = R128_GMC_DST_16BPP;
  392. break;
  393. case 24:
  394. case 32:
  395. depth_bpp = R128_GMC_DST_32BPP;
  396. break;
  397. default:
  398. return;
  399. }
  401. for ( i = 0 ; i < nbox ; i++ ) {
  402. int x = pbox[i].x1;
  403. int y = pbox[i].y1;
  404. int w = pbox[i].x2 - x;
  405. int h = pbox[i].y2 - y;
  407. DRM_DEBUG( "dispatch clear %d,%d-%d,%d flags 0x%xn",
  408.    pbox[i].x1, pbox[i].y1, pbox[i].x2,
  409.    pbox[i].y2, flags );
  411. if ( flags & (R128_FRONT | R128_BACK) ) {
  412. BEGIN_RING( 2 );
  414. OUT_RING( CCE_PACKET0( R128_DP_WRITE_MASK, 0 ) );
  415. OUT_RING( sarea_priv->context_state.plane_3d_mask_c );
  417. ADVANCE_RING();
  418. }
  420. if ( flags & R128_FRONT ) {
  421. BEGIN_RING( 6 );
  423. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  424. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL
  425.   | R128_GMC_BRUSH_SOLID_COLOR
  426.   | fb_bpp
  427.   | R128_GMC_SRC_DATATYPE_COLOR
  428.   | R128_ROP3_P
  429.   | R128_GMC_CLR_CMP_CNTL_DIS
  430.   | R128_GMC_AUX_CLIP_DIS );
  432. OUT_RING( dev_priv->front_pitch_offset_c );
  433. OUT_RING( clear_color );
  435. OUT_RING( (x << 16) | y );
  436. OUT_RING( (w << 16) | h );
  438. ADVANCE_RING();
  439. }
  441. if ( flags & R128_BACK ) {
  442. BEGIN_RING( 6 );
  444. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  445. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL
  446.   | R128_GMC_BRUSH_SOLID_COLOR
  447.   | fb_bpp
  448.   | R128_GMC_SRC_DATATYPE_COLOR
  449.   | R128_ROP3_P
  450.   | R128_GMC_CLR_CMP_CNTL_DIS
  451.   | R128_GMC_AUX_CLIP_DIS );
  453. OUT_RING( dev_priv->back_pitch_offset_c );
  454. OUT_RING( clear_color );
  456. OUT_RING( (x << 16) | y );
  457. OUT_RING( (w << 16) | h );
  459. ADVANCE_RING();
  460. }
  462. if ( flags & R128_DEPTH ) {
  463. BEGIN_RING( 6 );
  465. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  466. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL
  467.   | R128_GMC_BRUSH_SOLID_COLOR
  468.   | depth_bpp
  469.   | R128_GMC_SRC_DATATYPE_COLOR
  470.   | R128_ROP3_P
  471.   | R128_GMC_CLR_CMP_CNTL_DIS
  472.   | R128_GMC_AUX_CLIP_DIS
  473.   | R128_GMC_WR_MSK_DIS );
  475. OUT_RING( dev_priv->depth_pitch_offset_c );
  476. OUT_RING( clear_depth );
  478. OUT_RING( (x << 16) | y );
  479. OUT_RING( (w << 16) | h );
  481. ADVANCE_RING();
  482. }
  483. }
  484. }
  486. static void r128_cce_dispatch_swap( drm_device_t *dev )
  487. {
  488. drm_r128_private_t *dev_priv = dev->dev_private;
  489. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  490. int nbox = sarea_priv->nbox;
  491. drm_clip_rect_t *pbox = sarea_priv->boxes;
  492. u32 fb_bpp;
  493. int i;
  494. RING_LOCALS;
  495. DRM_DEBUG( "%sn", __FUNCTION__ );
  497. r128_update_ring_snapshot( dev_priv );
  499. #if R128_PERFORMANCE_BOXES
  500. /* Do some trivial performance monitoring...
  501.  */
  502. r128_cce_performance_boxes( dev_priv );
  503. #endif
  505. switch ( dev_priv->fb_bpp ) {
  506. case 16:
  507. fb_bpp = R128_GMC_DST_16BPP;
  508. break;
  509. case 32:
  510. default:
  511. fb_bpp = R128_GMC_DST_32BPP;
  512. break;
  513. }
  515. for ( i = 0 ; i < nbox ; i++ ) {
  516. int x = pbox[i].x1;
  517. int y = pbox[i].y1;
  518. int w = pbox[i].x2 - x;
  519. int h = pbox[i].y2 - y;
  521. BEGIN_RING( 7 );
  523. OUT_RING( CCE_PACKET3( R128_CNTL_BITBLT_MULTI, 5 ) );
  524. OUT_RING( R128_GMC_SRC_PITCH_OFFSET_CNTL
  525.   | R128_GMC_DST_PITCH_OFFSET_CNTL
  526.   | R128_GMC_BRUSH_NONE
  527.   | fb_bpp
  528.   | R128_GMC_SRC_DATATYPE_COLOR
  529.   | R128_ROP3_S
  530.   | R128_DP_SRC_SOURCE_MEMORY
  531.   | R128_GMC_CLR_CMP_CNTL_DIS
  532.   | R128_GMC_AUX_CLIP_DIS
  533.   | R128_GMC_WR_MSK_DIS );
  535. OUT_RING( dev_priv->back_pitch_offset_c );
  536. OUT_RING( dev_priv->front_pitch_offset_c );
  538. OUT_RING( (x << 16) | y );
  539. OUT_RING( (x << 16) | y );
  540. OUT_RING( (w << 16) | h );
  542. ADVANCE_RING();
  543. }
  545. /* Increment the frame counter.  The client-side 3D driver must
  546.  * throttle the framerate by waiting for this value before
  547.  * performing the swapbuffer ioctl.
  548.  */
  549. dev_priv->sarea_priv->last_frame++;
  551. BEGIN_RING( 2 );
  553. OUT_RING( CCE_PACKET0( R128_LAST_FRAME_REG, 0 ) );
  554. OUT_RING( dev_priv->sarea_priv->last_frame );
  556. ADVANCE_RING();
  557. }
  559. static void r128_cce_dispatch_vertex( drm_device_t *dev,
  560.       drm_buf_t *buf )
  561. {
  562. drm_r128_private_t *dev_priv = dev->dev_private;
  563. drm_r128_buf_priv_t *buf_priv = buf->dev_private;
  564. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  565. int format = sarea_priv->vc_format;
  566. int offset = dev_priv->buffers->offset + buf->offset - dev->agp->base;
  567. int size = buf->used;
  568. int prim = buf_priv->prim;
  569. int i = 0;
  570. RING_LOCALS;
  571. DRM_DEBUG( "%s: buf=%d nbox=%dn",
  572.    __FUNCTION__, buf->idx, sarea_priv->nbox );
  574. r128_update_ring_snapshot( dev_priv );
  576. if ( 0 )
  577. r128_print_dirty( "dispatch_vertex", sarea_priv->dirty );
  579. if ( buf->used ) {
  580. buf_priv->dispatched = 1;
  582. if ( sarea_priv->dirty & ~R128_UPLOAD_CLIPRECTS ) {
  583. r128_emit_state( dev_priv );
  584. }
  586. do {
  587. /* Emit the next set of up to three cliprects */
  588. if ( i < sarea_priv->nbox ) {
  589. r128_emit_clip_rects( dev_priv,
  590.       &sarea_priv->boxes[i],
  591.       sarea_priv->nbox - i );
  592. }
  594. /* Emit the vertex buffer rendering commands */
  595. BEGIN_RING( 5 );
  597. OUT_RING( CCE_PACKET3( R128_3D_RNDR_GEN_INDX_PRIM, 3 ) );
  598. OUT_RING( offset );
  599. OUT_RING( size );
  600. OUT_RING( format );
  601. OUT_RING( prim | R128_CCE_VC_CNTL_PRIM_WALK_LIST |
  602.   (size << R128_CCE_VC_CNTL_NUM_SHIFT) );
  604. ADVANCE_RING();
  606. i += 3;
  607. } while ( i < sarea_priv->nbox );
  608. }
  610. if ( buf_priv->discard ) {
  611. buf_priv->age = dev_priv->sarea_priv->last_dispatch;
  613. /* Emit the vertex buffer age */
  614. BEGIN_RING( 2 );
  616. OUT_RING( CCE_PACKET0( R128_LAST_DISPATCH_REG, 0 ) );
  617. OUT_RING( buf_priv->age );
  619. ADVANCE_RING();
  621. buf->pending = 1;
  622. buf->used = 0;
  623. /* FIXME: Check dispatched field */
  624. buf_priv->dispatched = 0;
  625. }
  627. dev_priv->sarea_priv->last_dispatch++;
  629. #if 0
  630. if ( dev_priv->submit_age == R128_MAX_VB_AGE ) {
  631. ret = r128_do_cce_idle( dev_priv );
  632. if ( ret < 0 ) return ret;
  633. dev_priv->submit_age = 0;
  634. r128_freelist_reset( dev );
  635. }
  636. #endif
  638. sarea_priv->dirty &= ~R128_UPLOAD_CLIPRECTS;
  639. sarea_priv->nbox = 0;
  640. }
  645. static void r128_cce_dispatch_indirect( drm_device_t *dev,
  646. drm_buf_t *buf,
  647. int start, int end )
  648. {
  649. drm_r128_private_t *dev_priv = dev->dev_private;
  650. drm_r128_buf_priv_t *buf_priv = buf->dev_private;
  651. RING_LOCALS;
  652. DRM_DEBUG( "indirect: buf=%d s=0x%x e=0x%xn",
  653.    buf->idx, start, end );
  655. r128_update_ring_snapshot( dev_priv );
  657. if ( start != end ) {
  658. int offset = (dev_priv->buffers->offset - dev->agp->base
  659.       + buf->offset + start);
  660. int dwords = (end - start + 3) / sizeof(u32);
  662. /* Indirect buffer data must be an even number of
  663.  * dwords, so if we've been given an odd number we must
  664.  * pad the data with a Type-2 CCE packet.
  665.  */
  666. if ( dwords & 1 ) {
  667. u32 *data = (u32 *)
  668. ((char *)dev_priv->buffers->handle
  669.  + buf->offset + start);
  670. data[dwords++] = R128_CCE_PACKET2;
  671. }
  673. buf_priv->dispatched = 1;
  675. /* Fire off the indirect buffer */
  676. BEGIN_RING( 3 );
  678. OUT_RING( CCE_PACKET0( R128_PM4_IW_INDOFF, 1 ) );
  679. OUT_RING( offset );
  680. OUT_RING( dwords );
  682. ADVANCE_RING();
  683. }
  685. if ( buf_priv->discard ) {
  686. buf_priv->age = dev_priv->sarea_priv->last_dispatch;
  688. /* Emit the indirect buffer age */
  689. BEGIN_RING( 2 );
  691. OUT_RING( CCE_PACKET0( R128_LAST_DISPATCH_REG, 0 ) );
  692. OUT_RING( buf_priv->age );
  694. ADVANCE_RING();
  696. buf->pending = 1;
  697. buf->used = 0;
  698. /* FIXME: Check dispatched field */
  699. buf_priv->dispatched = 0;
  700. }
  702. dev_priv->sarea_priv->last_dispatch++;
  704. #if 0
  705. if ( dev_priv->submit_age == R128_MAX_VB_AGE ) {
  706. ret = r128_do_cce_idle( dev_priv );
  707. if ( ret < 0 ) return ret;
  708. dev_priv->submit_age = 0;
  709. r128_freelist_reset( dev );
  710. }
  711. #endif
  712. }
  714. static void r128_cce_dispatch_indices( drm_device_t *dev,
  715.        drm_buf_t *buf,
  716.        int start, int end,
  717.        int count )
  718. {
  719. drm_r128_private_t *dev_priv = dev->dev_private;
  720. drm_r128_buf_priv_t *buf_priv = buf->dev_private;
  721. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  722. int format = sarea_priv->vc_format;
  723. int offset = dev_priv->buffers->offset - dev->agp->base;
  724. int prim = buf_priv->prim;
  725. u32 *data;
  726. int dwords;
  727. int i = 0;
  728. RING_LOCALS;
  729. DRM_DEBUG( "indices: s=%d e=%d c=%dn", start, end, count );
  731. r128_update_ring_snapshot( dev_priv );
  733. if ( 0 )
  734. r128_print_dirty( "dispatch_indices", sarea_priv->dirty );
  736. if ( start != end ) {
  737. buf_priv->dispatched = 1;
  739. if ( sarea_priv->dirty & ~R128_UPLOAD_CLIPRECTS ) {
  740. r128_emit_state( dev_priv );
  741. }
  743. dwords = (end - start + 3) / sizeof(u32);
  745. data = (u32 *)((char *)dev_priv->buffers->handle
  746.        + buf->offset + start);
  748. data[0] = CCE_PACKET3( R128_3D_RNDR_GEN_INDX_PRIM, dwords-2 );
  750. data[1] = offset;
  751. data[2] = R128_MAX_VB_VERTS;
  752. data[3] = format;
  753. data[4] = (prim | R128_CCE_VC_CNTL_PRIM_WALK_IND |
  754.    (count << 16));
  756. if ( count & 0x1 ) {
  757. data[dwords-1] &= 0x0000ffff;
  758. }
  760. do {
  761. /* Emit the next set of up to three cliprects */
  762. if ( i < sarea_priv->nbox ) {
  763. r128_emit_clip_rects( dev_priv,
  764.       &sarea_priv->boxes[i],
  765.       sarea_priv->nbox - i );
  766. }
  768. r128_cce_dispatch_indirect( dev, buf, start, end );
  770. i += 3;
  771. } while ( i < sarea_priv->nbox );
  772. }
  774. if ( buf_priv->discard ) {
  775. buf_priv->age = dev_priv->sarea_priv->last_dispatch;
  777. /* Emit the vertex buffer age */
  778. BEGIN_RING( 2 );
  780. OUT_RING( CCE_PACKET0( R128_LAST_DISPATCH_REG, 0 ) );
  781. OUT_RING( buf_priv->age );
  783. ADVANCE_RING();
  785. buf->pending = 1;
  786. /* FIXME: Check dispatched field */
  787. buf_priv->dispatched = 0;
  788. }
  790. dev_priv->sarea_priv->last_dispatch++;
  792. #if 0
  793. if ( dev_priv->submit_age == R128_MAX_VB_AGE ) {
  794. ret = r128_do_cce_idle( dev_priv );
  795. if ( ret < 0 ) return ret;
  796. dev_priv->submit_age = 0;
  797. r128_freelist_reset( dev );
  798. }
  799. #endif
  801. sarea_priv->dirty &= ~R128_UPLOAD_CLIPRECTS;
  802. sarea_priv->nbox = 0;
  803. }
  805. static int r128_cce_dispatch_blit( drm_device_t *dev,
  806.    drm_r128_blit_t *blit )
  807. {
  808. drm_r128_private_t *dev_priv = dev->dev_private;
  809. drm_device_dma_t *dma = dev->dma;
  810. drm_buf_t *buf;
  811. drm_r128_buf_priv_t *buf_priv;
  812. u32 *data;
  813. int dword_shift, dwords;
  814. RING_LOCALS;
  815. DRM_DEBUG( "%sn", __FUNCTION__ );
  817. r128_update_ring_snapshot( dev_priv );
  819. /* The compiler won't optimize away a division by a variable,
  820.  * even if the only legal values are powers of two.  Thus, we'll
  821.  * use a shift instead.
  822.  */
  823. switch ( blit->format ) {
  824. case R128_DATATYPE_ARGB1555:
  825. case R128_DATATYPE_RGB565:
  826. case R128_DATATYPE_ARGB4444:
  827. dword_shift = 1;
  828. break;
  829. case R128_DATATYPE_ARGB8888:
  830. dword_shift = 0;
  831. break;
  832. default:
  833. DRM_ERROR( "invalid blit format %dn", blit->format );
  834. return -EINVAL;
  835. }
  837. /* Flush the pixel cache, and mark the contents as Read Invalid.
  838.  * This ensures no pixel data gets mixed up with the texture
  839.  * data from the host data blit, otherwise part of the texture
  840.  * image may be corrupted.
  841.  */
  842. BEGIN_RING( 2 );
  844. OUT_RING( CCE_PACKET0( R128_PC_GUI_CTLSTAT, 0 ) );
  845. OUT_RING( R128_PC_RI_GUI | R128_PC_FLUSH_GUI );
  847. ADVANCE_RING();
  849. /* Dispatch the indirect buffer.
  850.  */
  851. buf = dma->buflist[blit->idx];
  852. buf_priv = buf->dev_private;
  854. if ( buf->pid != current->pid ) {
  855. DRM_ERROR( "process %d using buffer owned by %dn",
  856.    current->pid, buf->pid );
  857. return -EINVAL;
  858. }
  859. if ( buf->pending ) {
  860. DRM_ERROR( "sending pending buffer %dn", blit->idx );
  861. return -EINVAL;
  862. }
  864. buf_priv->discard = 1;
  866. dwords = (blit->width * blit->height) >> dword_shift;
  868. data = (u32 *)((char *)dev_priv->buffers->handle + buf->offset);
  870. data[0] = CCE_PACKET3( R128_CNTL_HOSTDATA_BLT, dwords + 6 );
  871. data[1] = ( R128_GMC_DST_PITCH_OFFSET_CNTL
  872.     | R128_GMC_BRUSH_NONE
  873.     | (blit->format << 8)
  874.     | R128_GMC_SRC_DATATYPE_COLOR
  875.     | R128_ROP3_S
  876.     | R128_DP_SRC_SOURCE_HOST_DATA
  877.     | R128_GMC_CLR_CMP_CNTL_DIS
  878.     | R128_GMC_AUX_CLIP_DIS
  879.     | R128_GMC_WR_MSK_DIS );
  881. data[2] = (blit->pitch << 21) | (blit->offset >> 5);
  882. data[3] = 0xffffffff;
  883. data[4] = 0xffffffff;
  884. data[5] = (blit->y << 16) | blit->x;
  885. data[6] = (blit->height << 16) | blit->width;
  886. data[7] = dwords;
  888. buf->used = (dwords + 8) * sizeof(u32);
  890. r128_cce_dispatch_indirect( dev, buf, 0, buf->used );
  892. /* Flush the pixel cache after the blit completes.  This ensures
  893.  * the texture data is written out to memory before rendering
  894.  * continues.
  895.  */
  896. BEGIN_RING( 2 );
  898. OUT_RING( CCE_PACKET0( R128_PC_GUI_CTLSTAT, 0 ) );
  899. OUT_RING( R128_PC_FLUSH_GUI );
  901. ADVANCE_RING();
  903. return 0;
  904. }
  907. /* ================================================================
  908.  * Tiled depth buffer management
  909.  *
  910.  * FIXME: These should all set the destination write mask for when we
  911.  * have hardware stencil support.
  912.  */
  914. static int r128_cce_dispatch_write_span( drm_device_t *dev,
  915.  drm_r128_depth_t *depth )
  916. {
  917. drm_r128_private_t *dev_priv = dev->dev_private;
  918. int count, x, y;
  919. u32 *buffer;
  920. u8 *mask;
  921. u32 depth_bpp;
  922. int i;
  923. RING_LOCALS;
  924. DRM_DEBUG( "%sn", __FUNCTION__ );
  926. r128_update_ring_snapshot( dev_priv );
  928. switch ( dev_priv->depth_bpp ) {
  929. case 16:
  930. depth_bpp = R128_GMC_DST_16BPP;
  931. break;
  932. case 24:
  933. case 32:
  934. depth_bpp = R128_GMC_DST_32BPP;
  935. break;
  936. default:
  937. return -EINVAL;
  938. }
  940. count = depth->n;
  941. if ( copy_from_user( &x, depth->x, sizeof(x) ) ) {
  942. return -EFAULT;
  943. }
  944. if ( copy_from_user( &y, depth->y, sizeof(y) ) ) {
  945. return -EFAULT;
  946. }
  948. buffer = kmalloc( depth->n * sizeof(u32), 0 );
  949. if ( buffer == NULL )
  950. return -ENOMEM;
  951. if ( copy_from_user( buffer, depth->buffer,
  952.      depth->n * sizeof(u32) ) ) {
  953. kfree( buffer );
  954. return -EFAULT;
  955. }
  957. if ( depth->mask ) {
  958. mask = kmalloc( depth->n * sizeof(u8), 0 );
  959. if ( mask == NULL ) {
  960. kfree( buffer );
  961. return -ENOMEM;
  962. }
  963. if ( copy_from_user( mask, depth->mask,
  964.      depth->n * sizeof(u8) ) ) {
  965. kfree( buffer );
  966. kfree( mask );
  967. return -EFAULT;
  968. }
  970. for ( i = 0 ; i < count ; i++, x++ ) {
  971. if ( mask[i] ) {
  972. BEGIN_RING( 6 );
  974. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI,
  975.        4 ) );
  976. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL
  977.   | R128_GMC_BRUSH_SOLID_COLOR
  978.   | depth_bpp
  979.   | R128_GMC_SRC_DATATYPE_COLOR
  980.   | R128_ROP3_P
  981.   | R128_GMC_CLR_CMP_CNTL_DIS
  982.   | R128_GMC_WR_MSK_DIS );
  984. OUT_RING( dev_priv->depth_pitch_offset_c );
  985. OUT_RING( buffer[i] );
  987. OUT_RING( (x << 16) | y );
  988. OUT_RING( (1 << 16) | 1 );
  990. ADVANCE_RING();
  991. }
  992. }
  994. kfree( mask );
  995. } else {
  996. for ( i = 0 ; i < count ; i++, x++ ) {
  997. BEGIN_RING( 6 );
  999. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  1000. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL
  1001.   | R128_GMC_BRUSH_SOLID_COLOR
  1002.   | depth_bpp
  1003.   | R128_GMC_SRC_DATATYPE_COLOR
  1004.   | R128_ROP3_P
  1005.   | R128_GMC_CLR_CMP_CNTL_DIS
  1006.   | R128_GMC_WR_MSK_DIS );
  1008. OUT_RING( dev_priv->depth_pitch_offset_c );
  1009. OUT_RING( buffer[i] );
  1011. OUT_RING( (x << 16) | y );
  1012. OUT_RING( (1 << 16) | 1 );
  1014. ADVANCE_RING();
  1015. }
  1016. }
  1018. kfree( buffer );
  1020. return 0;
  1021. }
  1023. static int r128_cce_dispatch_write_pixels( drm_device_t *dev,
  1024.    drm_r128_depth_t *depth )
  1025. {
  1026. drm_r128_private_t *dev_priv = dev->dev_private;
  1027. int count, *x, *y;
  1028. u32 *buffer;
  1029. u8 *mask;
  1030. u32 depth_bpp;
  1031. int i;
  1032. RING_LOCALS;
  1033. DRM_DEBUG( "%sn", __FUNCTION__ );
  1035. r128_update_ring_snapshot( dev_priv );
  1037. switch ( dev_priv->depth_bpp ) {
  1038. case 16:
  1039. depth_bpp = R128_GMC_DST_16BPP;
  1040. break;
  1041. case 24:
  1042. case 32:
  1043. depth_bpp = R128_GMC_DST_32BPP;
  1044. break;
  1045. default:
  1046. return -EINVAL;
  1047. }
  1049. count = depth->n;
  1051. x = kmalloc( count * sizeof(*x), 0 );
  1052. if ( x == NULL ) {
  1053. return -ENOMEM;
  1054. }
  1055. y = kmalloc( count * sizeof(*y), 0 );
  1056. if ( y == NULL ) {
  1057. kfree( x );
  1058. return -ENOMEM;
  1059. }
  1060. if ( copy_from_user( x, depth->x, count * sizeof(int) ) ) {
  1061. kfree( x );
  1062. kfree( y );
  1063. return -EFAULT;
  1064. }
  1065. if ( copy_from_user( y, depth->y, count * sizeof(int) ) ) {
  1066. kfree( x );
  1067. kfree( y );
  1068. return -EFAULT;
  1069. }
  1071. buffer = kmalloc( depth->n * sizeof(u32), 0 );
  1072. if ( buffer == NULL ) {
  1073. kfree( x );
  1074. kfree( y );
  1075. return -ENOMEM;
  1076. }
  1077. if ( copy_from_user( buffer, depth->buffer,
  1078.      depth->n * sizeof(u32) ) ) {
  1079. kfree( x );
  1080. kfree( y );
  1081. kfree( buffer );
  1082. return -EFAULT;
  1083. }
  1085. if ( depth->mask ) {
  1086. mask = kmalloc( depth->n * sizeof(u8), 0 );
  1087. if ( mask == NULL ) {
  1088. kfree( x );
  1089. kfree( y );
  1090. kfree( buffer );
  1091. return -ENOMEM;
  1092. }
  1093. if ( copy_from_user( mask, depth->mask,
  1094.      depth->n * sizeof(u8) ) ) {
  1095. kfree( x );
  1096. kfree( y );
  1097. kfree( buffer );
  1098. kfree( mask );
  1099. return -EFAULT;
  1100. }
  1102. for ( i = 0 ; i < count ; i++ ) {
  1103. if ( mask[i] ) {
  1104. BEGIN_RING( 6 );
  1106. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI,
  1107.        4 ) );
  1108. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL
  1109.   | R128_GMC_BRUSH_SOLID_COLOR
  1110.   | depth_bpp
  1111.   | R128_GMC_SRC_DATATYPE_COLOR
  1112.   | R128_ROP3_P
  1113.   | R128_GMC_CLR_CMP_CNTL_DIS
  1114.   | R128_GMC_WR_MSK_DIS );
  1116. OUT_RING( dev_priv->depth_pitch_offset_c );
  1117. OUT_RING( buffer[i] );
  1119. OUT_RING( (x[i] << 16) | y[i] );
  1120. OUT_RING( (1 << 16) | 1 );
  1122. ADVANCE_RING();
  1123. }
  1124. }
  1126. kfree( mask );
  1127. } else {
  1128. for ( i = 0 ; i < count ; i++ ) {
  1129. BEGIN_RING( 6 );
  1131. OUT_RING( CCE_PACKET3( R128_CNTL_PAINT_MULTI, 4 ) );
  1132. OUT_RING( R128_GMC_DST_PITCH_OFFSET_CNTL
  1133.   | R128_GMC_BRUSH_SOLID_COLOR
  1134.   | depth_bpp
  1135.   | R128_GMC_SRC_DATATYPE_COLOR
  1136.   | R128_ROP3_P
  1137.   | R128_GMC_CLR_CMP_CNTL_DIS
  1138.   | R128_GMC_WR_MSK_DIS );
  1140. OUT_RING( dev_priv->depth_pitch_offset_c );
  1141. OUT_RING( buffer[i] );
  1143. OUT_RING( (x[i] << 16) | y[i] );
  1144. OUT_RING( (1 << 16) | 1 );
  1146. ADVANCE_RING();
  1147. }
  1148. }
  1150. kfree( x );
  1151. kfree( y );
  1152. kfree( buffer );
  1154. return 0;
  1155. }
  1157. static int r128_cce_dispatch_read_span( drm_device_t *dev,
  1158. drm_r128_depth_t *depth )
  1159. {
  1160. drm_r128_private_t *dev_priv = dev->dev_private;
  1161. int count, x, y;
  1162. u32 depth_bpp;
  1163. RING_LOCALS;
  1164. DRM_DEBUG( "%sn", __FUNCTION__ );
  1166. r128_update_ring_snapshot( dev_priv );
  1168. switch ( dev_priv->depth_bpp ) {
  1169. case 16:
  1170. depth_bpp = R128_GMC_DST_16BPP;
  1171. break;
  1172. case 24:
  1173. case 32:
  1174. depth_bpp = R128_GMC_DST_32BPP;
  1175. break;
  1176. default:
  1177. return -EINVAL;
  1178. }
  1180. count = depth->n;
  1181. if ( copy_from_user( &x, depth->x, sizeof(x) ) ) {
  1182. return -EFAULT;
  1183. }
  1184. if ( copy_from_user( &y, depth->y, sizeof(y) ) ) {
  1185. return -EFAULT;
  1186. }
  1188. BEGIN_RING( 7 );
  1190. OUT_RING( CCE_PACKET3( R128_CNTL_BITBLT_MULTI, 5 ) );
  1191. OUT_RING( R128_GMC_SRC_PITCH_OFFSET_CNTL
  1192.   | R128_GMC_DST_PITCH_OFFSET_CNTL
  1193.   | R128_GMC_BRUSH_NONE
  1194.   | depth_bpp
  1195.   | R128_GMC_SRC_DATATYPE_COLOR
  1196.   | R128_ROP3_S
  1197.   | R128_DP_SRC_SOURCE_MEMORY
  1198.   | R128_GMC_CLR_CMP_CNTL_DIS
  1199.   | R128_GMC_WR_MSK_DIS );
  1201. OUT_RING( dev_priv->depth_pitch_offset_c );
  1202. OUT_RING( dev_priv->span_pitch_offset_c );
  1204. OUT_RING( (x << 16) | y );
  1205. OUT_RING( (0 << 16) | 0 );
  1206. OUT_RING( (count << 16) | 1 );
  1208. ADVANCE_RING();
  1210. return 0;
  1211. }
  1213. static int r128_cce_dispatch_read_pixels( drm_device_t *dev,
  1214.   drm_r128_depth_t *depth )
  1215. {
  1216. drm_r128_private_t *dev_priv = dev->dev_private;
  1217. int count, *x, *y;
  1218. u32 depth_bpp;
  1219. int i;
  1220. RING_LOCALS;
  1221. DRM_DEBUG( "%sn", __FUNCTION__ );
  1223. r128_update_ring_snapshot( dev_priv );
  1225. switch ( dev_priv->depth_bpp ) {
  1226. case 16:
  1227. depth_bpp = R128_GMC_DST_16BPP;
  1228. break;
  1229. case 24:
  1230. case 32:
  1231. depth_bpp = R128_GMC_DST_32BPP;
  1232. break;
  1233. default:
  1234. return -EINVAL;
  1235. }
  1237. count = depth->n;
  1238. if ( count > dev_priv->depth_pitch ) {
  1239. count = dev_priv->depth_pitch;
  1240. }
  1242. x = kmalloc( count * sizeof(*x), 0 );
  1243. if ( x == NULL ) {
  1244. return -ENOMEM;
  1245. }
  1246. y = kmalloc( count * sizeof(*y), 0 );
  1247. if ( y == NULL ) {
  1248. kfree( x );
  1249. return -ENOMEM;
  1250. }
  1251. if ( copy_from_user( x, depth->x, count * sizeof(int) ) ) {
  1252. kfree( x );
  1253. kfree( y );
  1254. return -EFAULT;
  1255. }
  1256. if ( copy_from_user( y, depth->y, count * sizeof(int) ) ) {
  1257. kfree( x );
  1258. kfree( y );
  1259. return -EFAULT;
  1260. }
  1262. for ( i = 0 ; i < count ; i++ ) {
  1263. BEGIN_RING( 7 );
  1265. OUT_RING( CCE_PACKET3( R128_CNTL_BITBLT_MULTI, 5 ) );
  1266. OUT_RING( R128_GMC_SRC_PITCH_OFFSET_CNTL
  1267.   | R128_GMC_DST_PITCH_OFFSET_CNTL
  1268.   | R128_GMC_BRUSH_NONE
  1269.   | depth_bpp
  1270.   | R128_GMC_SRC_DATATYPE_COLOR
  1271.   | R128_ROP3_S
  1272.   | R128_DP_SRC_SOURCE_MEMORY
  1273.   | R128_GMC_CLR_CMP_CNTL_DIS
  1274.   | R128_GMC_WR_MSK_DIS );
  1276. OUT_RING( dev_priv->depth_pitch_offset_c );
  1277. OUT_RING( dev_priv->span_pitch_offset_c );
  1279. OUT_RING( (x[i] << 16) | y[i] );
  1280. OUT_RING( (i << 16) | 0 );
  1281. OUT_RING( (1 << 16) | 1 );
  1283. ADVANCE_RING();
  1284. }
  1286. kfree( x );
  1287. kfree( y );
  1289. return 0;
  1290. }
  1293. /* ================================================================
  1294.  * Polygon stipple
  1295.  */
  1297. static void r128_cce_dispatch_stipple( drm_device_t *dev, u32 *stipple )
  1298. {
  1299. drm_r128_private_t *dev_priv = dev->dev_private;
  1300. int i;
  1301. RING_LOCALS;
  1302. DRM_DEBUG( "%sn", __FUNCTION__ );
  1304. r128_update_ring_snapshot( dev_priv );
  1306. BEGIN_RING( 33 );
  1308. OUT_RING(  CCE_PACKET0( R128_BRUSH_DATA0, 31 ) );
  1309. for ( i = 0 ; i < 32 ; i++ ) {
  1310. OUT_RING( stipple[i] );
  1311. }
  1313. ADVANCE_RING();
  1314. }
  1317. /* ================================================================
  1318.  * IOCTL functions
  1319.  */
  1321. int r128_cce_clear( struct inode *inode, struct file *filp,
  1322.     unsigned int cmd, unsigned long arg )
  1323. {
  1324. drm_file_t *priv = filp->private_data;
  1325. drm_device_t *dev = priv->dev;
  1326. drm_r128_private_t *dev_priv = dev->dev_private;
  1327. drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  1328. drm_r128_clear_t clear;
  1329. DRM_DEBUG( "%sn", __FUNCTION__ );
  1331. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  1332.      dev->lock.pid != current->pid ) {
  1333. DRM_ERROR( "r128_cce_clear called without lock heldn" );
  1334. return -EINVAL;
  1335. }
  1337. if ( copy_from_user( &clear, (drm_r128_clear_t *) arg,
  1338.      sizeof(clear) ) )
  1339. return -EFAULT;
  1341. if ( sarea_priv->nbox > R128_NR_SAREA_CLIPRECTS )
  1342. sarea_priv->nbox = R128_NR_SAREA_CLIPRECTS;
  1344. r128_cce_dispatch_clear( dev, clear.flags,
  1345.  clear.x, clear.y, clear.w, clear.h,
  1346.  clear.clear_color, clear.clear_depth );
  1348. /* Make sure we restore the 3D state next time.
  1349.  */
  1350. dev_priv->sarea_priv->dirty |= R128_UPLOAD_CONTEXT | R128_UPLOAD_MASKS;
  1352. return 0;
  1353. }
  1355. int r128_cce_swap( 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_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
  1362. DRM_DEBUG( "%sn", __FUNCTION__ );
  1364. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  1365.      dev->lock.pid != current->pid ) {
  1366. DRM_ERROR( "r128_cce_swap called without lock heldn" );
  1367. return -EINVAL;
  1368. }
  1370. if ( sarea_priv->nbox > R128_NR_SAREA_CLIPRECTS )
  1371. sarea_priv->nbox = R128_NR_SAREA_CLIPRECTS;
  1373. r128_cce_dispatch_swap( dev );
  1375. /* Make sure we restore the 3D state next time.
  1376.  */
  1377. dev_priv->sarea_priv->dirty |= R128_UPLOAD_CONTEXT | R128_UPLOAD_MASKS;
  1379. return 0;
  1380. }
  1382. int r128_cce_vertex( struct inode *inode, struct file *filp,
  1383.      unsigned int cmd, unsigned long arg )
  1384. {
  1385. drm_file_t *priv = filp->private_data;
  1386. drm_device_t *dev = priv->dev;
  1387. drm_r128_private_t *dev_priv = dev->dev_private;
  1388. drm_device_dma_t *dma = dev->dma;
  1389. drm_buf_t *buf;
  1390. drm_r128_buf_priv_t *buf_priv;
  1391. drm_r128_vertex_t vertex;
  1393. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  1394.      dev->lock.pid != current->pid ) {
  1395. DRM_ERROR( "%s called without lock heldn", __FUNCTION__ );
  1396. return -EINVAL;
  1397. }
  1398. if ( !dev_priv || dev_priv->is_pci ) {
  1399. DRM_ERROR( "%s called with a PCI cardn", __FUNCTION__ );
  1400. return -EINVAL;
  1401. }
  1403. if ( copy_from_user( &vertex, (drm_r128_vertex_t *)arg,
  1404.      sizeof(vertex) ) )
  1405. return -EFAULT;
  1407. DRM_DEBUG( "%s: pid=%d index=%d count=%d discard=%dn",
  1408.    __FUNCTION__, current->pid,
  1409.    vertex.idx, vertex.count, vertex.discard );
  1411. if ( vertex.idx < 0 || vertex.idx >= dma->buf_count ) {
  1412. DRM_ERROR( "buffer index %d (of %d max)n",
  1413.    vertex.idx, dma->buf_count - 1 );
  1414. return -EINVAL;
  1415. }
  1416. if ( vertex.prim < 0 ||
  1417.      vertex.prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2 ) {
  1418. DRM_ERROR( "buffer prim %dn", vertex.prim );
  1419. return -EINVAL;
  1420. }
  1422. buf = dma->buflist[vertex.idx];
  1423. buf_priv = buf->dev_private;
  1425. if ( buf->pid != current->pid ) {
  1426. DRM_ERROR( "process %d using buffer owned by %dn",
  1427.    current->pid, buf->pid );
  1428. return -EINVAL;
  1429. }
  1430. if ( buf->pending ) {
  1431. DRM_ERROR( "sending pending buffer %dn", vertex.idx );
  1432. return -EINVAL;
  1433. }
  1435. buf->used = vertex.count;
  1436. buf_priv->prim = vertex.prim;
  1437. buf_priv->discard = vertex.discard;
  1439. r128_cce_dispatch_vertex( dev, buf );
  1441. return 0;
  1442. }
  1444. int r128_cce_indices( struct inode *inode, struct file *filp,
  1445.       unsigned int cmd, unsigned long arg )
  1446. {
  1447. drm_file_t *priv = filp->private_data;
  1448. drm_device_t *dev = priv->dev;
  1449. drm_r128_private_t *dev_priv = dev->dev_private;
  1450. drm_device_dma_t *dma = dev->dma;
  1451. drm_buf_t *buf;
  1452. drm_r128_buf_priv_t *buf_priv;
  1453. drm_r128_indices_t elts;
  1454. int count;
  1456. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  1457.      dev->lock.pid != current->pid ) {
  1458. DRM_ERROR( "%s called without lock heldn", __FUNCTION__ );
  1459. return -EINVAL;
  1460. }
  1461. if ( !dev_priv || dev_priv->is_pci ) {
  1462. DRM_ERROR( "%s called with a PCI cardn", __FUNCTION__ );
  1463. return -EINVAL;
  1464. }
  1466. if ( copy_from_user( &elts, (drm_r128_indices_t *)arg,
  1467.      sizeof(elts) ) )
  1468. return -EFAULT;
  1470. DRM_DEBUG( "%s: pid=%d buf=%d s=%d e=%d d=%dn",
  1471.    __FUNCTION__, current->pid,
  1472.    elts.idx, elts.start, elts.end, elts.discard );
  1474. if ( elts.idx < 0 || elts.idx >= dma->buf_count ) {
  1475. DRM_ERROR( "buffer index %d (of %d max)n",
  1476.    elts.idx, dma->buf_count - 1 );
  1477. return -EINVAL;
  1478. }
  1479. if ( elts.prim < 0 ||
  1480.      elts.prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2 ) {
  1481. DRM_ERROR( "buffer prim %dn", elts.prim );
  1482. return -EINVAL;
  1483. }
  1485. buf = dma->buflist[elts.idx];
  1486. buf_priv = buf->dev_private;
  1488. if ( buf->pid != current->pid ) {
  1489. DRM_ERROR( "process %d using buffer owned by %dn",
  1490.    current->pid, buf->pid );
  1491. return -EINVAL;
  1492. }
  1493. if ( buf->pending ) {
  1494. DRM_ERROR( "sending pending buffer %dn", elts.idx );
  1495. return -EINVAL;
  1496. }
  1498. count = (elts.end - elts.start) / sizeof(u16);
  1499. elts.start -= R128_INDEX_PRIM_OFFSET;
  1501. if ( elts.start & 0x7 ) {
  1502. DRM_ERROR( "misaligned buffer 0x%xn", elts.start );
  1503. return -EINVAL;
  1504. }
  1505. if ( elts.start < buf->used ) {
  1506. DRM_ERROR( "no header 0x%x - 0x%xn", elts.start, buf->used );
  1507. return -EINVAL;
  1508. }
  1510. buf->used = elts.end;
  1511. buf_priv->prim = elts.prim;
  1512. buf_priv->discard = elts.discard;
  1514. r128_cce_dispatch_indices( dev, buf, elts.start, elts.end, count );
  1516. return 0;
  1517. }
  1519. int r128_cce_blit( struct inode *inode, struct file *filp,
  1520.    unsigned int cmd, unsigned long arg )
  1521. {
  1522. drm_file_t *priv = filp->private_data;
  1523. drm_device_t *dev = priv->dev;
  1524. drm_device_dma_t *dma = dev->dma;
  1525. drm_r128_blit_t blit;
  1527. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  1528.      dev->lock.pid != current->pid ) {
  1529. DRM_ERROR( "%s called without lock heldn", __FUNCTION__ );
  1530. return -EINVAL;
  1531. }
  1533. if ( copy_from_user( &blit, (drm_r128_blit_t *)arg,
  1534.      sizeof(blit) ) )
  1535. return -EFAULT;
  1537. DRM_DEBUG( "%s: pid=%d index=%dn",
  1538.    __FUNCTION__, current->pid, blit.idx );
  1540. if ( blit.idx < 0 || blit.idx >= dma->buf_count ) {
  1541. DRM_ERROR( "buffer index %d (of %d max)n",
  1542.    blit.idx, dma->buf_count - 1 );
  1543. return -EINVAL;
  1544. }
  1546. return r128_cce_dispatch_blit( dev, &blit );
  1547. }
  1549. int r128_cce_depth( struct inode *inode, struct file *filp,
  1550.     unsigned int cmd, unsigned long arg )
  1551. {
  1552. drm_file_t *priv = filp->private_data;
  1553. drm_device_t *dev = priv->dev;
  1554. drm_r128_depth_t depth;
  1556. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  1557.      dev->lock.pid != current->pid ) {
  1558. DRM_ERROR( "%s called without lock heldn", __FUNCTION__ );
  1559. return -EINVAL;
  1560. }
  1562. if ( copy_from_user( &depth, (drm_r128_depth_t *)arg,
  1563.      sizeof(depth) ) )
  1564. return -EFAULT;
  1566. switch ( depth.func ) {
  1567. case R128_WRITE_SPAN:
  1568. return r128_cce_dispatch_write_span( dev, &depth );
  1569. case R128_WRITE_PIXELS:
  1570. return r128_cce_dispatch_write_pixels( dev, &depth );
  1571. case R128_READ_SPAN:
  1572. return r128_cce_dispatch_read_span( dev, &depth );
  1573. case R128_READ_PIXELS:
  1574. return r128_cce_dispatch_read_pixels( dev, &depth );
  1575. }
  1577. return -EINVAL;
  1578. }
  1580. int r128_cce_stipple( struct inode *inode, struct file *filp,
  1581.       unsigned int cmd, unsigned long arg )
  1582. {
  1583. drm_file_t *priv = filp->private_data;
  1584. drm_device_t *dev = priv->dev;
  1585. drm_r128_stipple_t stipple;
  1586. u32 mask[32];
  1588. if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) ||
  1589.      dev->lock.pid != current->pid ) {
  1590. DRM_ERROR( "%s called without lock heldn", __FUNCTION__ );
  1591. return -EINVAL;
  1592. }
  1594. if ( copy_from_user( &stipple, (drm_r128_stipple_t *)arg,
  1595.      sizeof(stipple) ) )
  1596. return -EFAULT;
  1598. if ( copy_from_user( &mask, stipple.mask,
  1599.      32 * sizeof(u32) ) )
  1600. return -EFAULT;
  1602. r128_cce_dispatch_stipple( dev, mask );
  1604. return 0;
  1605. }