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 194
