Mercurial > sdl-ios-xcode

comparison src/video/ps3/spulibs/fb_writer.c @ 3141:3df74541339b gsoc2009_ps3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added ps3 video driver based on the dummy driver. Added spulib for copying to framebuffer. Added SPU managing functions. Added open/close and taking control of the framebuffer.
author Martin Lowinski <martin@goldtopf.org>
date Fri, 29 May 2009 09:50:21 +0000
parents
children
comparison
equal deleted inserted replaced
3140:9ef99b844c60 3141:3df74541339b
1 /*
2 * SDL - Simple DirectMedia Layer
3 * CELL BE Support for PS3 Framebuffer
4 * Copyright (C) 2008, 2009 International Business Machines Corporation
5 *
6 * This library is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as published
8 * by the Free Software Foundation; either version 2.1 of the License, or
9 * (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
19 * USA
20 *
21 * Martin Lowinski <lowinski [at] de [dot] ibm [ibm] com>
22 * Dirk Herrendoerfer <d.herrendoerfer [at] de [dot] ibm [dot] com>
23 * SPE code based on research by:
24 * Rene Becker
25 * Thimo Emmerich
26 */
27
28 #include "spu_common.h"
29
30 #include <spu_intrinsics.h>
31 #include <spu_mfcio.h>
32 #include <stdio.h>
33 #include <string.h>
34
35 // Debugging
36 //#define DEBUG
37
38 #ifdef DEBUG
39 #define deprintf(fmt, args... ) \
40 fprintf( stdout, fmt, ##args ); \
41 fflush( stdout );
42 #else
43 #define deprintf( fmt, args... )
44 #endif
45
46 void cpy_to_fb(unsigned int);
47
48 /* fb_writer_spu parms */
49 static volatile struct fb_writer_parms_t parms __attribute__ ((aligned(128)));
50
51 /* Code running on SPU */
52 int main(unsigned long long spe_id __attribute__ ((unused)), unsigned long long argp __attribute__ ((unused)))
53 {
54 deprintf("[SPU] fb_writer_spu is up... (on SPE #%llu)\n", spe_id);
55 uint32_t ea_mfc, mbox;
56 // send ready message
57 spu_write_out_mbox(SPU_READY);
58
59 while (1) {
60 /* Check mailbox */
61 mbox = spu_read_in_mbox();
62 deprintf("[SPU] Message is %u\n", mbox);
63 switch (mbox) {
64 case SPU_EXIT:
65 deprintf("[SPU] fb_writer goes down...\n");
66 return 0;
67 case SPU_START:
68 break;
69 default:
70 deprintf("[SPU] Cannot handle message\n");
71 continue;
72 }
73
74 /* Tag Manager setup */
75 unsigned int tags;
76 tags = mfc_multi_tag_reserve(5);
77 if (tags == MFC_TAG_INVALID) {
78 deprintf("[SPU] Failed to reserve mfc tags on fb_writer\n");
79 return 0;
80 }
81
82 /* Framebuffer parms */
83 ea_mfc = spu_read_in_mbox();
84 deprintf("[SPU] Message on fb_writer is %u\n", ea_mfc);
85 spu_mfcdma32(&parms, (unsigned int)ea_mfc,
86 sizeof(struct fb_writer_parms_t), tags,
87 MFC_GET_CMD);
88 deprintf("[SPU] argp = %u\n", (unsigned int)argp);
89 DMA_WAIT_TAG(tags);
90
91 /* Copy parms->data to framebuffer */
92 deprintf("[SPU] Copying to framebuffer started\n");
93 cpy_to_fb(tags);
94 deprintf("[SPU] Copying to framebuffer done!\n");
95
96 mfc_multi_tag_release(tags, 5);
97 deprintf("[SPU] fb_writer_spu... done!\n");
98 /* Send FIN msg */
99 spu_write_out_mbox(SPU_FIN);
100 }
101
102 return 0;
103 }
104
105 void cpy_to_fb(unsigned int tag_id_base)
106 {
107 unsigned int i;
108 unsigned char current_buf;
109 uint8_t *in = parms.data;
110
111 /* Align fb pointer which was centered before */
112 uint8_t *fb =
113 (unsigned char *)((unsigned int)parms.center & 0xFFFFFFF0);
114
115 uint32_t bounded_input_height = parms.bounded_input_height;
116 uint32_t bounded_input_width = parms.bounded_input_width;
117 uint32_t fb_pixel_size = parms.fb_pixel_size;
118
119 uint32_t out_line_stride = parms.out_line_stride;
120 uint32_t in_line_stride = parms.in_line_stride;
121 uint32_t in_line_size = bounded_input_width * fb_pixel_size;
122
123 current_buf = 0;
124
125 /* Local store buffer */
126 static volatile uint8_t buf[4][BUFFER_SIZE]
127 __attribute__ ((aligned(128)));
128 /* do 4-times multibuffering using DMA list, process in two steps */
129 for (i = 0; i < bounded_input_height >> 2; i++) {
130 /* first buffer */
131 DMA_WAIT_TAG(tag_id_base + 1);
132 // retrieve buffer
133 spu_mfcdma32(buf[0], (unsigned int)in, in_line_size,
134 tag_id_base + 1, MFC_GETB_CMD);
135 DMA_WAIT_TAG(tag_id_base + 1);
136 // store buffer
137 spu_mfcdma32(buf[0], (unsigned int)fb, in_line_size,
138 tag_id_base + 1, MFC_PUTB_CMD);
139 in += in_line_stride;
140 fb += out_line_stride;
141 deprintf("[SPU] 1st buffer copied in=0x%x, fb=0x%x\n", in,
142 fb);
143
144 /* second buffer */
145 DMA_WAIT_TAG(tag_id_base + 2);
146 // retrieve buffer
147 spu_mfcdma32(buf[1], (unsigned int)in, in_line_size,
148 tag_id_base + 2, MFC_GETB_CMD);
149 DMA_WAIT_TAG(tag_id_base + 2);
150 // store buffer
151 spu_mfcdma32(buf[1], (unsigned int)fb, in_line_size,
152 tag_id_base + 2, MFC_PUTB_CMD);
153 in += in_line_stride;
154 fb += out_line_stride;
155 deprintf("[SPU] 2nd buffer copied in=0x%x, fb=0x%x\n", in,
156 fb);
157
158 /* third buffer */
159 DMA_WAIT_TAG(tag_id_base + 3);
160 // retrieve buffer
161 spu_mfcdma32(buf[2], (unsigned int)in, in_line_size,
162 tag_id_base + 3, MFC_GETB_CMD);
163 DMA_WAIT_TAG(tag_id_base + 3);
164 // store buffer
165 spu_mfcdma32(buf[2], (unsigned int)fb, in_line_size,
166 tag_id_base + 3, MFC_PUTB_CMD);
167 in += in_line_stride;
168 fb += out_line_stride;
169 deprintf("[SPU] 3rd buffer copied in=0x%x, fb=0x%x\n", in,
170 fb);
171
172 /* fourth buffer */
173 DMA_WAIT_TAG(tag_id_base + 4);
174 // retrieve buffer
175 spu_mfcdma32(buf[3], (unsigned int)in, in_line_size,
176 tag_id_base + 4, MFC_GETB_CMD);
177 DMA_WAIT_TAG(tag_id_base + 4);
178 // store buffer
179 spu_mfcdma32(buf[3], (unsigned int)fb, in_line_size,
180 tag_id_base + 4, MFC_PUTB_CMD);
181 in += in_line_stride;
182 fb += out_line_stride;
183 deprintf("[SPU] 4th buffer copied in=0x%x, fb=0x%x\n", in,
184 fb);
185 deprintf("[SPU] Loop #%i, bounded_input_height=%i\n", i,
186 bounded_input_height >> 2);
187 }
188 DMA_WAIT_TAG(tag_id_base + 2);
189 DMA_WAIT_TAG(tag_id_base + 3);
190 DMA_WAIT_TAG(tag_id_base + 4);
191 }
192
193