util.c

   1 /*-
   2  * Copyright (C) 2011, 2012 glevand <geoffrey.levand@mail.ru>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer,
  10  *    without modification, immediately at the beginning of the file.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <stdint.h>
  32 #include <string.h>
  33 #include <math.h>
  34 #include <errno.h>
  35
  36 #include <sys/ioctl.h>
  37 #include <sys/mman.h>
  38 #include <unistd.h>
  39
  40 #include "ps3gpu_ctl.h"
  41 #include "ps3gpu_mth.h"
  42 #include "util.h"
  43
  44 int
  45 setup_control(int fd, int context_id, unsigned long put, unsigned long get,
  46     unsigned int ref)
  47 {
  48         struct ps3gpu_ctl_setup_control setup_control;
  49
  50         setup_control.context_id = context_id;
  51         setup_control.put = put;
  52         setup_control.get = get;
  53         setup_control.ref = ref;
  54
  55         return (ioctl(fd, PS3GPU_CTL_SETUP_CONTROL, &setup_control));
  56 }
  57
  58 int
  59 memory_allocate(int fd, int context_id, int type, int size, int align,
  60     unsigned long *handle, unsigned int *gpu_addr, void **map)
  61 {
  62         struct ps3gpu_ctl_memory_allocate memory_allocate;
  63         struct ps3gpu_ctl_memory_free memory_free;
  64         int err;
  65
  66         memory_allocate.context_id = context_id;
  67         memory_allocate.type = type;
  68         memory_allocate.size = size;
  69         memory_allocate.align = align;
  70
  71         err = ioctl(fd, PS3GPU_CTL_MEMORY_ALLOCATE, &memory_allocate);
  72         if (err < 0)
  73                 return (err);
  74
  75         if (handle)
  76                 *handle = memory_allocate.handle;
  77
  78         if (gpu_addr)
  79                 *gpu_addr = memory_allocate.gpu_addr;
  80
  81         if (map) {
  82                 *map = mmap(NULL, memory_allocate.size,
  83                     PROT_READ | PROT_WRITE, MAP_SHARED, fd, memory_allocate.handle);
  84                 if (*map == (void *) MAP_FAILED) {
  85                         memory_free.context_id = context_id;
  86                         memory_free.handle = memory_allocate.handle;
  87                         err = errno;
  88                         ioctl(fd, PS3GPU_CTL_MEMORY_FREE, &memory_free);
  89                         errno = err;
  90                         return (-1);
  91                 }
  92         }
  93
  94         return (0);
  95 }
  96
  97 int
  98 display_buffer_set(int fd, int context_id, int buffer_id, int width, int height,
  99     int pitch, unsigned long offset)
 100 {
 101         struct ps3gpu_ctl_display_buffer_set display_buffer_set;
 102
 103         display_buffer_set.context_id = context_id;
 104         display_buffer_set.buffer_id = buffer_id;
 105         display_buffer_set.width = width;
 106         display_buffer_set.height = height;
 107         display_buffer_set.pitch = pitch;
 108         display_buffer_set.offset = offset;
 109
 110         return (ioctl(fd, PS3GPU_CTL_DISPLAY_BUFFER_SET, &display_buffer_set));
 111 }
 112
 113 int
 114 set_flip_mode(int fd, int context_id, int head, int mode)
 115 {
 116         struct ps3gpu_ctl_set_flip_mode set_flip_mode;
 117
 118         set_flip_mode.context_id = context_id;
 119         set_flip_mode.head = head;
 120         set_flip_mode.mode = mode;
 121
 122         return (ioctl(fd, PS3GPU_CTL_SET_FLIP_MODE, &set_flip_mode));
 123 }
 124
 125 int
 126 reset_flip_status(int fd, int context_id, int head)
 127 {
 128         struct ps3gpu_ctl_reset_flip_status reset_flip_status;
 129
 130         reset_flip_status.context_id = context_id;
 131         reset_flip_status.head = head;
 132
 133         return (ioctl(fd, PS3GPU_CTL_RESET_FLIP_STATUS, &reset_flip_status));
 134 }
 135
 136 int
 137 flip(int fd, int context_id, int head, unsigned long offset)
 138 {
 139         struct ps3gpu_ctl_flip flip;
 140
 141         flip.context_id = context_id;
 142         flip.head = head;
 143         flip.offset = offset;
 144
 145         return (ioctl(fd, PS3GPU_CTL_FLIP, &flip));
 146 }
 147
 148 uint32_t
 149 get_tiled_pitch_size(uint32_t pitch)
 150 {
 151         static const uint32_t tile_pitches[] = {
 152                 0x00000000, 0x00000200, 0x00000300, 0x00000400,
 153                 0x00000500, 0x00000600, 0x00000700, 0x00000800,
 154                 0x00000a00, 0x00000c00, 0x00000d00, 0x00000e00,
 155                 0x00001000, 0x00001400, 0x00001800, 0x00001a00,
 156                 0x00001c00, 0x00002000, 0x00002800, 0x00003000,
 157                 0x00003400, 0x00003800, 0x00004000, 0x00005000,
 158                 0x00006000, 0x00006800, 0x00007000, 0x00008000,
 159                 0x0000a000, 0x0000c000, 0x0000d000, 0x0000e000,
 160                 0x00010000,
 161
 162         };
 163         int i;
 164
 165         for (i = 0; i < ARRAY_SIZE(tile_pitches) - 1; i++) {
 166                 if ((tile_pitches[i] < pitch) && (pitch <= tile_pitches[i + 1]))
 167                         return (tile_pitches[i + 1]);
 168         }
 169
 170         return (0);
 171 }
 172
 173 int
 174 save_image(const char *filename, const char *buf, int len)
 175 {
 176         FILE *fp;
 177         int nwritten;
 178         int err = 0;
 179
 180         fp = fopen(filename, "w");
 181         if (!fp)
 182                 return (-1);
 183
 184         nwritten = fwrite(buf, 1, len, fp);
 185         if (nwritten != len)
 186                 err = -1;
 187
 188         fclose(fp);
 189
 190         return (err);
 191 }
 192
 193 void
 194 dump_fifo(FILE *fp, const uint32_t *fifo, unsigned int word_count)
 195 {
 196         int i = 0;
 197
 198         while (word_count--) {
 199                 fprintf(fp, "%08x: %08x\n", i * 4, fifo[i]);
 200                 i++;
 201         }
 202 }
 203
 204 int
 205 set_reference(uint32_t *fifo, uint32_t val)
 206 {
 207         int i = 0;
 208
 209         fifo[i++] = PS3GPU_MTH_HDR(1, 0, PS3GPU_MTH_ADDR_REF);
 210         fifo[i++] = val;
 211
 212         return (i);
 213 }
 214
 215 int
 216 transfer_data(uint32_t *fifo, uint32_t src, uint32_t dst,
 217     uint32_t dst_offset, int32_t dst_pitch, uint32_t src_offset, int32_t src_pitch,
 218     uint32_t row_length, uint32_t row_count)
 219 {
 220         int i = 0;
 221         int h;
 222
 223         fifo[i++] = PS3GPU_MTH_HDR(2, 1, 0x184);
 224         fifo[i++] = src;
 225         fifo[i++] = dst;
 226
 227         while (row_count) {
 228                 h = row_count;
 229                 if (h > 2047)
 230                         h = 2047;
 231
 232                 fifo[i++] = PS3GPU_MTH_HDR(8, 1, 0x30c);
 233                 fifo[i++] = src_offset;
 234                 fifo[i++] = dst_offset;
 235                 fifo[i++] = src_pitch;
 236                 fifo[i++] = dst_pitch;
 237                 fifo[i++] = row_length;
 238                 fifo[i++] = h;
 239                 fifo[i++] = 0x00000101;
 240                 fifo[i++] = 0x00000000;
 241
 242                 src_offset += h * src_pitch;
 243                 dst_offset += h * dst_pitch;
 244                 row_count -= h;
 245         }
 246
 247         fifo[i++] = PS3GPU_MTH_HDR(1, 1, 0x310);
 248         fifo[i++] = 0x00000000;
 249
 250         return (i);
 251 }
 252
 253 int
 254 transfer_inline(uint32_t *fifo, uint32_t dst, uint32_t dst_offset,
 255     const uint32_t *data, uint32_t word_count)
 256 {
 257         int odd = word_count & 1;
 258         int i = 0;
 259
 260         fifo[i++] = PS3GPU_MTH_HDR(1, 3, 0x188);
 261         fifo[i++] = dst;
 262
 263         fifo[i++] = PS3GPU_MTH_HDR(1, 3, 0x30c);
 264         fifo[i++] = dst_offset & ~0x3f;
 265
 266         fifo[i++] = PS3GPU_MTH_HDR(2, 3, 0x300);
 267         fifo[i++] = 0x0000000b;
 268         fifo[i++] = 0x10001000;
 269
 270         fifo[i++] = PS3GPU_MTH_HDR(3, 5, 0x304);
 271         fifo[i++] = (dst_offset >> 2) & 0xf;
 272         fifo[i++] = 0x00010000 | word_count;
 273         fifo[i++] = 0x00010000 | word_count;
 274
 275         fifo[i++] = PS3GPU_MTH_HDR((word_count + 1) & ~1, 5, 0x400);
 276
 277         while (word_count--)
 278                 fifo[i++] = *data++;
 279
 280         if (odd)
 281                 fifo[i++] = 0x00000000;
 282
 283         return (i);
 284 }
 285
 286 int
 287 flip_display_buffer(uint32_t *fifo, uint8_t channel_id, uint8_t buffer_id,
 288     uint8_t head)
 289 {
 290         int i = 0;
 291
 292         /* reset flip label */
 293
 294         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x64);
 295         fifo[i++]= (head << 4);
 296
 297         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x6c);
 298         fifo[i++] = 0x00000001;
 299
 300         /* 0xcafebabe flip method */
 301
 302         fifo[i++] = PS3GPU_MTH_HDR(1, 7, 0x920 + (head << 2));
 303         fifo[i++] = 0x80000000 | (channel_id << 8) | buffer_id;
 304
 305         return (i);
 306 }
 307
 308 int
 309 set_depth_mask(uint32_t *fifo, uint32_t mask)
 310 {
 311         int i = 0;
 312
 313         fifo[i++] = PS3GPU_MTH_HDR(1, 0, PS3GPU_MTH_ADDR_DEPTH_MASK);
 314         fifo[i++] = mask;
 315
 316         return (i);
 317 }
 318
 319 int
 320 set_color_mask(uint32_t *fifo, uint32_t mask)
 321 {
 322         int i = 0;
 323
 324         fifo[i++] = PS3GPU_MTH_HDR(1, 0, PS3GPU_MTH_ADDR_COLOR_MASK);
 325         fifo[i++] = mask;
 326
 327         return (i);
 328 }
 329
 330 int
 331 set_color_mask_mrt(uint32_t *fifo, uint32_t mask)
 332 {
 333         int i = 0;
 334
 335         fifo[i++] = PS3GPU_MTH_HDR(1, 0, PS3GPU_MTH_ADDR_COLOR_MASK_MRT);
 336         fifo[i++] = mask;
 337
 338         return (i);
 339 }
 340
 341 int
 342 set_clear_color(uint32_t *fifo, uint32_t color)
 343 {
 344         int i = 0;
 345
 346         fifo[i++] = PS3GPU_MTH_HDR(1, 0, PS3GPU_MTH_ADDR_CLEAR_COLOR);
 347         fifo[i++] = color;
 348
 349         return (i);
 350 }
 351
 352 int
 353 set_scissor(uint32_t *fifo, uint16_t x, uint16_t y, uint16_t w, uint16_t h)
 354 {
 355         int i = 0;
 356
 357         fifo[i++] = PS3GPU_MTH_HDR(2, 0, PS3GPU_MTH_ADDR_SCISSOR);
 358         fifo[i++] = (w << 16) | x;
 359         fifo[i++] = (h << 16) | y;
 360
 361         return (i);
 362 }
 363
 364 int
 365 set_front_poly_mode(uint32_t *fifo, uint32_t mode)
 366 {
 367         int i = 0;
 368
 369         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1828);
 370         fifo[i++] = mode;
 371
 372         return (i);
 373 }
 374
 375 int
 376 set_shade_mode(uint32_t *fifo, uint32_t mode)
 377 {
 378         int i = 0;
 379
 380         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x368);
 381         fifo[i++] = mode;
 382
 383         return (i);
 384 }
 385
 386 int
 387 blend_enable(uint32_t *fifo, uint32_t enable)
 388 {
 389         int i = 0;
 390
 391         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x310);
 392         fifo[i++] = enable;
 393
 394         return (i);
 395 }
 396
 397 int
 398 clear_surface(uint32_t *fifo, uint32_t mask)
 399 {
 400         int i = 0;
 401
 402         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1d94);
 403         fifo[i++] = mask;
 404
 405         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x100);
 406         fifo[i++] = 0x00000000;
 407
 408         return (i);
 409 }
 410
 411 int
 412 set_surface(uint32_t *fifo, const struct surface_desc *sd)
 413 {
 414         int i = 0;
 415
 416         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x194);
 417         fifo[i++] = sd->sd_color_loc[0];
 418
 419         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x18c);
 420         fifo[i++] = sd->sd_color_loc[1];
 421
 422         fifo[i++] = PS3GPU_MTH_HDR(2, 0, 0x1b4);
 423         fifo[i++] = sd->sd_color_loc[2];
 424         fifo[i++] = sd->sd_color_loc[3];
 425
 426         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x198);
 427         fifo[i++] = sd->sd_depth_loc;
 428
 429         fifo[i++] = PS3GPU_MTH_HDR(6, 0, 0x208);
 430         fifo[i++] = ((uint8_t) log2(sd->sd_h) << 24) | ((uint8_t) log2(sd->sd_w) << 16) |
 431             (0x0 << 12) | (0x1 << 8) |
 432             (sd->sd_depth_fmt << 5) | sd->sd_color_fmt;
 433         fifo[i++] = sd->sd_color_pitch[0];
 434         fifo[i++] = sd->sd_color_off[0];
 435         fifo[i++] = sd->sd_depth_off;
 436         fifo[i++] = sd->sd_color_off[1];
 437         fifo[i++] = sd->sd_color_pitch[1];
 438
 439         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x22c);
 440         fifo[i++] = sd->sd_depth_pitch;
 441
 442         fifo[i++] = PS3GPU_MTH_HDR(4, 0, 0x280);
 443         fifo[i++] = sd->sd_color_pitch[2];
 444         fifo[i++] = sd->sd_color_pitch[3];
 445         fifo[i++] = sd->sd_color_off[2];
 446         fifo[i++] = sd->sd_color_off[3];
 447
 448         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x220);
 449         fifo[i++] = sd->sd_color_target;
 450
 451         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x2b8);
 452         fifo[i++] = (sd->sd_y << 16) | sd->sd_x;
 453
 454         fifo[i++] = PS3GPU_MTH_HDR(2, 0, 0x200);
 455         fifo[i++] = (sd->sd_w << 16) | sd->sd_x;
 456         fifo[i++] = (sd->sd_h << 16) | sd->sd_y;
 457
 458         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1d88);
 459         fifo[i++] = (0x0 << 16) | (0x1 << 12) |
 460             (sd->sd_h - ((sd->sd_h >> 12) & 0x1));
 461
 462         return (i);
 463 }
 464
 465 int
 466 wait_label(uint32_t *fifo, uint32_t index, uint32_t val)
 467 {
 468         int i = 0;
 469
 470         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x64);
 471         fifo[i++] = index << 4;
 472
 473         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x68);
 474         fifo[i++] = val;
 475
 476         return (i);
 477 }
 478
 479 int
 480 write_label(uint32_t *fifo, uint32_t index, uint32_t val)
 481 {
 482         int i = 0;
 483
 484         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x64);
 485         fifo[i++] = index << 4;
 486
 487         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x6c);
 488         fifo[i++] = val;
 489
 490         return (i);
 491 }
 492
 493 int
 494 write_backend_label(uint32_t *fifo, uint32_t index, uint32_t val)
 495 {
 496         int i = 0;
 497
 498         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1d6c);
 499         fifo[i++] = index << 4;
 500
 501         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1d70);
 502         fifo[i++] = (val & 0xff00ff00) | ((val & 0xff) << 16) | ((val >> 16) & 0xff);
 503
 504         return (i);
 505 }
 506
 507 int
 508 write_texture_label(uint32_t *fifo, uint32_t index, uint32_t val)
 509 {
 510         int i = 0;
 511
 512         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1d6c);
 513         fifo[i++] = index << 4;
 514
 515         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1d74);
 516         fifo[i++] = val;
 517
 518         return (i);
 519 }
 520
 521 int
 522 set_viewport(uint32_t *fifo, uint16_t x, uint16_t y, uint16_t w, uint16_t h,
 523     float zmin, float zmax, const float offset[4], const float scale[4])
 524 {
 525         int i = 0;
 526
 527         fifo[i++] = PS3GPU_MTH_HDR(2, 0, 0xa00);
 528         fifo[i++] = (w << 16) | x;
 529         fifo[i++] = (h << 16) | y;
 530
 531         fifo[i++] = PS3GPU_MTH_HDR(2, 0, 0x394);
 532         fifo[i++] = *(uint32_t *) &zmin;
 533         fifo[i++] = *(uint32_t *) &zmax;
 534
 535         fifo[i++] = PS3GPU_MTH_HDR(8, 0, 0xa20);
 536         fifo[i++] = *(uint32_t *) &offset[0];
 537         fifo[i++] = *(uint32_t *) &offset[1];
 538         fifo[i++] = *(uint32_t *) &offset[2];
 539         fifo[i++] = *(uint32_t *) &offset[3];
 540         fifo[i++] = *(uint32_t *) &scale[0];
 541         fifo[i++] = *(uint32_t *) &scale[1];
 542         fifo[i++] = *(uint32_t *) &scale[2];
 543         fifo[i++] = *(uint32_t *) &scale[3];
 544
 545         fifo[i++] = PS3GPU_MTH_HDR(8, 0, 0xa20);
 546         fifo[i++] = *(uint32_t *) &offset[0];
 547         fifo[i++] = *(uint32_t *) &offset[1];
 548         fifo[i++] = *(uint32_t *) &offset[2];
 549         fifo[i++] = *(uint32_t *) &offset[3];
 550         fifo[i++] = *(uint32_t *) &scale[0];
 551         fifo[i++] = *(uint32_t *) &scale[1];
 552         fifo[i++] = *(uint32_t *) &scale[2];
 553         fifo[i++] = *(uint32_t *) &scale[3];
 554
 555         return (i);
 556 }
 557
 558 int
 559 load_vertex_prg(uint32_t *fifo, uint16_t slot, const uint32_t *prg, int instr_count)
 560 {
 561         int i = 0;
 562         int j;
 563
 564         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1e9c);
 565         fifo[i++] = slot;
 566
 567         while (instr_count >= 32) {
 568                 fifo[i++] = PS3GPU_MTH_HDR(32, 0, 0xb80);
 569
 570                 for (j = 0; j < 32; j++) {
 571                         fifo[i++] = *prg++;
 572                         fifo[i++] = *prg++;
 573                         fifo[i++] = *prg++;
 574                         fifo[i++] = *prg++;
 575                 }
 576
 577                 instr_count -= 32;
 578         }
 579
 580         if (instr_count > 0) {
 581                 fifo[i++] = PS3GPU_MTH_HDR(instr_count << 2, 0, 0xb80);
 582
 583                 for (j = 0; j < instr_count; j++) {
 584                         fifo[i++] = *prg++;
 585                         fifo[i++] = *prg++;
 586                         fifo[i++] = *prg++;
 587                         fifo[i++] = *prg++;
 588                 }
 589         }
 590
 591         return (i);
 592 }
 593
 594 int
 595 set_vertex_prg_reg_count(uint32_t *fifo, unsigned int count)
 596 {
 597         int i = 0;
 598         uint32_t val;
 599
 600         val = (count <= 32) ? 0x0020ffff : 0x0030ffff;
 601
 602         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1ef8);
 603         fifo[i++] = val;
 604
 605         return (i);
 606 }
 607
 608 int
 609 set_vertex_prg_start_slot(uint32_t *fifo, uint16_t slot)
 610 {
 611         int i = 0;
 612
 613         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1ea0);
 614         fifo[i++] = slot;
 615
 616         return (i);
 617 }
 618
 619 int
 620 set_vertex_prg_const(uint32_t *fifo, uint32_t start, uint32_t count,
 621     const float *val)
 622 {
 623         int i = 0;
 624         int j;
 625
 626         while (count >= 32) {
 627                 fifo[i++] = PS3GPU_MTH_HDR(33, 0, 0x1efc);
 628                 fifo[i++] = start;
 629
 630                 for (j = 0; j < 32; j++)
 631                         fifo[i++] = *(uint32_t *) val++;
 632
 633                 count -= 32;
 634                 start += 8;
 635         }
 636
 637         if (count > 0) {
 638                 fifo[i++] = PS3GPU_MTH_HDR(count + 1, 0, 0x1efc);
 639                 fifo[i++] = start;
 640
 641                 for (j = 0; j < count; j++)
 642                         fifo[i++] = *(uint32_t *) val++;
 643         }
 644
 645         return (i);
 646 }
 647
 648 int
 649 set_vertex_attr_inmask(uint32_t *fifo, uint32_t mask)
 650 {
 651         int i = 0;
 652
 653         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1ff0);
 654         fifo[i++] = mask;
 655
 656         return (i);
 657 }
 658
 659 int
 660 set_vertex_attr_outmask(uint32_t *fifo, uint32_t mask)
 661 {
 662         int i = 0;
 663
 664         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1ff4);
 665         fifo[i++] = mask;
 666
 667         return (i);
 668 }
 669
 670 int
 671 set_frag_prg(uint32_t *fifo, uint8_t location, uint32_t offset)
 672 {
 673         int i = 0;
 674
 675         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x8e4);
 676         fifo[i++] = offset | location;
 677
 678         return (i);
 679 }
 680
 681 int
 682 frag_prg_ctrl(uint32_t *fifo, uint8_t reg_count, uint8_t replace_txp_with_tex,
 683     uint8_t pixel_kill, uint8_t output_from_h0, uint8_t depth_replace)
 684 {
 685         int i = 0;
 686
 687         if (reg_count <= 1)
 688                 reg_count = 2;
 689
 690         if (depth_replace)
 691                 depth_replace = 0x7;
 692
 693         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1d60);
 694         fifo[i++] = (reg_count << 24) | (replace_txp_with_tex << 15) | 0x00000400 |
 695             (pixel_kill << 7) | (!output_from_h0 << 6) | (depth_replace << 1);
 696
 697         return (i);
 698 }
 699
 700 int
 701 draw_begin(uint32_t *fifo, uint32_t mode)
 702 {
 703         int i = 0;
 704
 705         fifo[i++] = 0x40000000 | PS3GPU_MTH_HDR(3, 0, 0x1714);
 706         fifo[i++] = 0x00000000;
 707         fifo[i++] = 0x00000000;
 708         fifo[i++] = 0x00000000;
 709
 710         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1808);
 711         fifo[i++] = mode;
 712
 713         return (i);
 714 }
 715
 716 int
 717 draw_end(uint32_t *fifo)
 718 {
 719         int i = 0;
 720
 721         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1808);
 722         fifo[i++] = 0x00000000;
 723
 724         return (i);
 725 }
 726
 727 int
 728 set_vertex_data_arrfmt(uint32_t *fifo, uint8_t reg, uint16_t freq,
 729     uint8_t stride, uint8_t size, uint8_t type)
 730 {
 731         int i = 0;
 732
 733         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1740 + (reg << 4));
 734         fifo[i++] = (freq << 16) | (stride << 8) | (size << 4) | type;
 735
 736         return (i);
 737 }
 738
 739 int
 740 set_vertex_data_2f(uint32_t *fifo, uint8_t reg, const float val[2])
 741 {
 742         int i = 0;
 743
 744         fifo[i++] = PS3GPU_MTH_HDR(2, 0, 0x1880 + (reg << 3));
 745         fifo[i++] = *(uint32_t *) &val[0];
 746         fifo[i++] = *(uint32_t *) &val[1];
 747
 748         return (i);
 749 }
 750
 751 int
 752 set_vertex_data_4f(uint32_t *fifo, uint8_t reg, const float val[4])
 753 {
 754         int i = 0;
 755
 756         fifo[i++] = PS3GPU_MTH_HDR(4, 0, 0x1c00 + (reg << 4));
 757         fifo[i++] = *(uint32_t *) &val[0];
 758         fifo[i++] = *(uint32_t *) &val[1];
 759         fifo[i++] = *(uint32_t *) &val[2];
 760         fifo[i++] = *(uint32_t *) &val[3];
 761
 762         return (i);
 763 }
 764
 765 int
 766 set_vertex_data_arr(uint32_t *fifo, uint8_t reg,
 767     uint16_t freq, uint8_t stride, uint8_t size, uint8_t type,
 768     uint8_t location, uint32_t offset)
 769 {
 770         int i = 0;
 771
 772         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1740 + (reg << 2));
 773         fifo[i++] = (freq << 16) | (stride << 8) | (size << 4) | type;
 774
 775         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1680 + (reg << 2));
 776         fifo[i++] = (location << 31) | offset;
 777
 778         return (i);
 779 }
 780
 781 int
 782 draw_arrays(uint32_t *fifo, uint32_t mode, uint32_t first, uint32_t count)
 783 {
 784         int i = 0;
 785         int j;
 786
 787         /* draw begin */
 788
 789         fifo[i++] = 0x40000000 | PS3GPU_MTH_HDR(3, 0, 0x1714);
 790         fifo[i++] = 0x00000000;
 791         fifo[i++] = 0x00000000;
 792         fifo[i++] = 0x00000000;
 793
 794         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1808);
 795         fifo[i++] = mode;
 796
 797         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1814);
 798         fifo[i++] = (((count - 1) & 0xff) << 24) | first;
 799
 800         first += ((count - 1) & 0xff) + 1;
 801         count -= ((count - 1) & 0xff) + 1;
 802
 803         while (count >= (0x7ff * 0x100)) {
 804                 fifo[i++] = 0x40000000 | PS3GPU_MTH_HDR(0x7ff, 0, 0x1814);
 805
 806                 for (j = 0; j < 0x7ff; j++) {
 807                         fifo[i++] = ((0x100 - 1) << 24) | first;
 808                         first += 0x100;
 809                 }
 810
 811                 count -= 0x7ff * 0x100;
 812         }
 813
 814         if (count) {
 815                 fifo[i++] = 0x40000000 | PS3GPU_MTH_HDR(count, 0, 0x1814);
 816
 817                 for (j = 0; j < count; j++) {
 818                         fifo[i++] = ((0x100 - 1) << 24) | first;
 819                         first += 0x100;
 820                 }
 821         }
 822
 823         /* draw end */
 824
 825         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1808);
 826         fifo[i++] = 0x00000000;
 827
 828         return (i);
 829 }
 830
 831 int
 832 invalidate_vertex_cache(uint32_t *fifo)
 833 {
 834         int i = 0;
 835
 836         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1710);
 837         fifo[i++] = 0x00000000;
 838
 839         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1714);
 840         fifo[i++] = 0x00000000;
 841
 842         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1714);
 843         fifo[i++] = 0x00000000;
 844
 845         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1714);
 846         fifo[i++] = 0x00000000;
 847
 848         return (i);
 849 }
 850
 851 int
 852 set_texture(uint32_t *fifo, uint8_t index, const struct texture_desc *td)
 853 {
 854         int i = 0;
 855
 856         fifo[i++] = PS3GPU_MTH_HDR(2, 0, 0x1a00 + (index << 5));
 857         fifo[i++] = td->td_off;
 858         fifo[i++] = (td->td_mipmap << 16) | (td->td_fmt << 8) |
 859             (td->td_dimension << 4) | (td->td_border << 3) |
 860             (td->td_cubemap << 2) | td->td_loc;
 861
 862         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1a18 + (index << 5));
 863         fifo[i++] = (td->td_w << 16) | td->td_h;
 864
 865         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1840 + (index << 2));
 866         fifo[i++] = (td->td_depth << 20) | td->td_pitch;
 867
 868         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1a10 + (index << 5));
 869         fifo[i++] = td->td_remap;
 870
 871         return (i);
 872 }
 873
 874 int
 875 texture_ctrl(uint32_t *fifo, uint8_t index, uint8_t enable,
 876     uint16_t min_lod, uint16_t max_lod, uint8_t max_aniso)
 877 {
 878         int i = 0;
 879
 880         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1a0c + (index << 5));
 881         fifo[i++] = (enable << 31) | ((min_lod & 0xfff) << 19) |
 882             ((max_lod & 0xfff) << 7) | (max_aniso << 4);
 883
 884         return (i);
 885 }
 886
 887 int
 888 set_texture_addr(uint32_t *fifo, uint8_t index,
 889     uint8_t wrap_s, uint8_t wrap_t, uint8_t wrap_r, uint8_t unsigned_remap,
 890     uint8_t zfunc, uint8_t gamma)
 891 {
 892         int i = 0;
 893
 894         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1a08 + (index << 5));
 895         fifo[i++] = (zfunc << 28) | (gamma << 20) | (wrap_r << 16) |
 896             (unsigned_remap << 12) | (wrap_t << 8) | wrap_s;
 897
 898         return (i);
 899 }
 900
 901 int
 902 set_texture_filter(uint32_t *fifo, uint8_t index,
 903     uint16_t bias, uint8_t min, uint8_t mag, uint8_t conv)
 904 {
 905         int i = 0;
 906
 907         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1a14 + (index << 5));
 908         fifo[i++] = (mag << 24) | (min << 16) | (conv << 13) | (bias & 0x1fff);
 909
 910         return (i);
 911 }
 912
 913 int
 914 invalidate_texture_cache(uint32_t *fifo, uint32_t val)
 915 {
 916         int i = 0;
 917
 918         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1fd8);
 919         fifo[i++] = val;
 920
 921         return (i);
 922 }
 923
 924 int
 925 set_timestamp(uint32_t *fifo, uint32_t index)
 926 {
 927         int i = 0;
 928
 929         fifo[i++] = PS3GPU_MTH_HDR(1, 0, 0x1800);
 930         fifo[i++] = 0x01000000 | index << 4;
 931
 932         return (i);
 933 }