cursor.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
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <sys/uio.h>
  37 #include <sys/ioctl.h>
  38 #include <sys/mman.h>
  39 #include <sys/fbio.h>
  40 #include <sys/consio.h>
  41 #include <fcntl.h>
  42 #include <unistd.h>
  43
  44 #include "ps3gpu_ctl.h"
  45 #include "ps3gpu_mth.h"
  46 #include "util.h"
  47
  48 static const uint64_t cursor_bitmap[64] = {
  49         0x000000ffff000000,
  50         0x0000ff0000ff0000,
  51         0x00ff00000000ff00,
  52         0xff000000000000ff,
  53         0xff000000000000ff,
  54         0xff000000000000ff,
  55         0xff000000000000ff,
  56         0xff000000000000ff,
  57         0xff000000000000ff,
  58         0xff000000000000ff,
  59         0xff000000000000ff,
  60         0xff000000000000ff,
  61         0xff000000000000ff,
  62         0xff000000000000ff,
  63         0xff000000000000ff,
  64         0xff000000000000ff,
  65         0xff000000000000ff,
  66         0xff000000000000ff,
  67         0xff000000000000ff,
  68         0xff000000000000ff,
  69         0xff000000000000ff,
  70         0xff000000000000ff,
  71         0xff000000000000ff,
  72         0xff000000000000ff,
  73         0xff000000000000ff,
  74         0xff000000000000ff,
  75         0xff000000000000ff,
  76         0xff000000000000ff,
  77         0xff000000000000ff,
  78         0xff000000000000ff,
  79         0xff000000000000ff,
  80         0xff000000000000ff,
  81         0xff000000000000ff,
  82         0xff000000000000ff,
  83         0xff000000000000ff,
  84         0xff000000000000ff,
  85         0xff000000000000ff,
  86         0xff000000000000ff,
  87         0xff000000000000ff,
  88         0xff000000000000ff,
  89         0xff000000000000ff,
  90         0xff000000000000ff,
  91         0xff000000000000ff,
  92         0xff000000000000ff,
  93         0xff000000000000ff,
  94         0xff000000000000ff,
  95         0xff000000000000ff,
  96         0xff000000000000ff,
  97         0xff000000000000ff,
  98         0xff000000000000ff,
  99         0xff000000000000ff,
 100         0xff000000000000ff,
 101         0xff000000000000ff,
 102         0xff000000000000ff,
 103         0xff000000000000ff,
 104         0xff000000000000ff,
 105         0xff000000000000ff,
 106         0xff000000000000ff,
 107         0xff000000000000ff,
 108         0xff000000000000ff,
 109         0xff000000000000ff,
 110         0x00ff00000000ff00,
 111         0x0000ff0000ff0000,
 112         0x000000ffff000000,
 113 };
 114
 115
 116 static int
 117 update_cursor(int fd, int context_id, int head, unsigned long offset,
 118     int x, int y, int enable)
 119 {
 120         struct ps3gpu_ctl_cursor_enable cursor_enable;
 121         struct ps3gpu_ctl_cursor_set_image cursor_set_image;
 122         struct ps3gpu_ctl_cursor_set_position cursor_set_position;
 123         int err;
 124
 125         /* Disable cursor */
 126
 127         cursor_enable.context_id = context_id;
 128         cursor_enable.head = head;
 129         cursor_enable.enable = 0;
 130
 131         err = ioctl(fd, PS3GPU_CTL_CURSOR_ENABLE, &cursor_enable);
 132         if (err < 0) {
 133                 perror("ioctl");
 134                 return (err);
 135         }
 136
 137         /* Set cursor image */
 138
 139         cursor_set_image.context_id = context_id;
 140         cursor_set_image.head = head;
 141         cursor_set_image.offset = offset;
 142
 143         err = ioctl(fd, PS3GPU_CTL_CURSOR_SET_IMAGE, &cursor_set_image);
 144         if (err < 0) {
 145                 perror("ioctl");
 146                 return (err);
 147         }
 148
 149         /* Set cursor position */
 150
 151         cursor_set_position.context_id = context_id;
 152         cursor_set_position.head = head;
 153         cursor_set_position.x = x;
 154         cursor_set_position.y = y;
 155
 156         err = ioctl(fd, PS3GPU_CTL_CURSOR_SET_POSITION, &cursor_set_position);
 157         if (err < 0) {
 158                 perror("ioctl");
 159                 return (err);
 160         }
 161
 162         /* Enable cursor */
 163
 164         cursor_enable.context_id = context_id;
 165         cursor_enable.head = head;
 166         cursor_enable.enable = enable;
 167
 168         err = ioctl(fd, PS3GPU_CTL_CURSOR_ENABLE, &cursor_enable);
 169         if (err < 0) {
 170                 perror("ioctl");
 171                 return (err);
 172         }
 173
 174         return (0);
 175 }
 176
 177 int
 178 main(int argc, char **argv)
 179 {
 180         struct ps3gpu_ctl_context_allocate context_allocate;
 181         struct ps3gpu_ctl_context_free context_free;
 182         int context_id;
 183         volatile uint32_t *control;
 184         uint32_t *vram, *cursor;
 185         unsigned long vram_handle, cursor_handle;
 186         unsigned int vram_gaddr, cursor_gaddr;
 187         int fd = -1;
 188         int x, y;
 189         int err;
 190
 191         /* Open GPU device */
 192
 193         fd = open(PS3GPU_DEV_PATH, O_RDWR);
 194         if (fd < 0) {
 195                 perror("open");
 196                 goto done;
 197         }
 198
 199         /* Create GPU context */
 200
 201         context_allocate.vram_size = 64; /* MB */
 202
 203         err = ioctl(fd, PS3GPU_CTL_CONTEXT_ALLOCATE, &context_allocate);
 204         if (err < 0) {
 205                 perror("ioctl");
 206                 goto done;
 207         }
 208
 209         context_id = context_allocate.context_id;
 210
 211         printf("context id %d\n", context_id);
 212         printf("control handle 0x%lx size %d\n",
 213             context_allocate.control_handle, context_allocate.control_size);
 214
 215         /* Map control registers */
 216
 217         control = mmap(NULL, context_allocate.control_size,
 218             PROT_READ | PROT_WRITE, MAP_SHARED, fd, context_allocate.control_handle);
 219         if (control == (void *) MAP_FAILED) {
 220                 perror("mmap");
 221                 goto done;
 222         }
 223
 224         /* Allocate VRAM */
 225
 226         err = memory_allocate(fd, context_id, PS3GPU_CTL_MEMORY_TYPE_VIDEO,
 227             ROUNDUP(DISPLAY_HEIGHT * DISPLAY_PITCH, 4 * 1024), 12,
 228             &vram_handle, &vram_gaddr, (void **) &vram);
 229         if (err < 0) {
 230                 perror("memory_allocate");
 231                 goto done;
 232         }
 233
 234         printf("VRAM handle 0x%lx gpu addr 0x%08x\n",
 235             vram_handle, vram_gaddr);
 236
 237         memset32(vram, 0xff404040, DISPLAY_HEIGHT * DISPLAY_WIDTH);
 238
 239         /* Allocate cursor */
 240
 241         err = memory_allocate(fd, context_id, PS3GPU_CTL_MEMORY_TYPE_VIDEO,
 242             16 * 1024, 20, &cursor_handle, &cursor_gaddr, (void **) &cursor);
 243         if (err < 0) {
 244                 perror("memory_allocate");
 245                 goto done;
 246         }
 247
 248         printf("cursor handle 0x%lx gpu addr 0x%08x\n",
 249             cursor_handle, cursor_gaddr);
 250
 251         /* Create cursor image */
 252
 253         for (y = 0; y < 64; y++) {
 254                 for (x = 0; x < 64; x++)
 255                         if (cursor_bitmap[(y * 64 + x) >> 6] &
 256                                 (1ul << ((63 - (y * 64 + x)) & 0x3f)))
 257                                 cursor[y * 64 + x] = 0xffffff00;
 258                         else
 259                                 cursor[y * 64 + x] = 0x00000000;
 260         }
 261
 262         /* Update cursor */
 263
 264         err = update_cursor(fd, context_id, PS3GPU_CTL_HEAD_A,
 265             cursor_handle, 100, 100, 1);
 266         if (err)
 267                 goto done;
 268
 269         err = update_cursor(fd, context_id, PS3GPU_CTL_HEAD_B,
 270             cursor_handle, 100, 100, 1);
 271         if (err)
 272                 goto done;
 273
 274         /* Flip */
 275
 276         err = flip(fd, context_id, PS3GPU_CTL_HEAD_A, vram_handle);
 277         if (err < 0) {
 278                 perror("flip");
 279                 goto done;
 280         }
 281
 282         err = flip(fd, context_id, PS3GPU_CTL_HEAD_B, vram_handle);
 283         if (err < 0) {
 284                 perror("flip");
 285                 goto done;
 286         }
 287
 288         usleep(2000000);
 289
 290         /* Update cursor */
 291
 292         err = update_cursor(fd, context_id, PS3GPU_CTL_HEAD_A,
 293             cursor_handle, 300, 300, 1);
 294         if (err) {
 295                 fprintf(stderr, "could not update cursor\n");
 296                 goto done;
 297         }
 298
 299         err = update_cursor(fd, context_id, PS3GPU_CTL_HEAD_B,
 300             cursor_handle, 300, 300, 1);
 301         if (err) {
 302                 fprintf(stderr, "could not update cursor\n");
 303                 goto done;
 304         }
 305
 306         usleep(2000000);
 307
 308         /* Destroy GPU context */
 309
 310         context_free.context_id = context_id;
 311
 312         err = ioctl(fd, PS3GPU_CTL_CONTEXT_FREE, &context_free);
 313         if (err < 0) {
 314                 perror("ioctl");
 315                 goto done;
 316         }
 317
 318 done:
 319
 320         if (fd >= 0)
 321                 close(fd);
 322
 323         /* Restore console */
 324
 325         ioctl(0, SW_TEXT_80x25, NULL);
 326
 327         exit(0);
 328 }