1 /* 2 Copyright 1999, Be Incorporated. All Rights Reserved. 3 This file may be used under the terms of the Be Sample Code License. 4 5 Other authors: 6 Mark Watson, 7 Rudolf Cornelissen 10/2002-1/2004. 8 */ 9 10 #define MODULE_BIT 0x00800000 11 12 #include <string.h> 13 #include <unistd.h> 14 #include "acc_std.h" 15 16 static status_t init_common(int the_fd); 17 18 /* Initialization code shared between primary and cloned accelerants */ 19 static status_t init_common(int the_fd) { 20 status_t result; 21 gx00_get_private_data gpd; 22 23 // LOG not available from here to next LOG: NULL si 24 25 /* memorize the file descriptor */ 26 fd = the_fd; 27 /* set the magic number so the driver knows we're for real */ 28 gpd.magic = GX00_PRIVATE_DATA_MAGIC; 29 /* contact driver and get a pointer to the registers and shared data */ 30 result = ioctl(fd, GX00_GET_PRIVATE_DATA, &gpd, sizeof(gpd)); 31 if (result != B_OK) goto error0; 32 33 /* clone the shared area for our use */ 34 shared_info_area = clone_area(DRIVER_PREFIX " shared", (void **)&si, B_ANY_ADDRESS, 35 B_READ_AREA | B_WRITE_AREA, gpd.shared_info_area); 36 if (shared_info_area < 0) { 37 result = shared_info_area; 38 goto error0; 39 } 40 // LOG is now available, si !NULL 41 LOG(4,("init_common: logmask 0x%08x, memory %dMB, hardcursor %d, usebios %d, greensync %d\n", 42 si->settings.logmask, si->settings.memory, si->settings.hardcursor, si->settings.usebios, si->settings.greensync)); 43 44 /*Check for R4.5.0 and if it is running, use work around*/ 45 { 46 if (si->use_clone_bugfix) 47 { 48 /*check for R4.5.0 bug and attempt to work around*/ 49 LOG(2,("InitACC: Found R4.5.0 bug - attempting to work around\n")); 50 regs = si->clone_bugfix_regs; 51 } 52 else 53 { 54 /* clone the memory mapped registers for our use - does not work on <4.5.2 (but is better this way)*/ 55 regs_area = clone_area(DRIVER_PREFIX " regs", (void **)®s, B_ANY_ADDRESS, 56 B_READ_AREA | B_WRITE_AREA, si->regs_area); 57 if (regs_area < 0) { 58 result = regs_area; 59 goto error1; 60 } 61 } 62 } 63 64 /*FIXME - print dma addresses*/ 65 //LOG(4,("DMA_virtual:%x\tDMA_physical:%x\tDMA_area:%x\n",si->dma_buffer,si->dma_buffer_pci,si->dma_buffer_area)); 66 67 /* all done */ 68 goto error0; 69 70 error1: 71 delete_area(shared_info_area); 72 error0: 73 return result; 74 } 75 76 /* Clean up code shared between primary and cloned accelerants */ 77 static void uninit_common(void) { 78 /* release the memory mapped registers */ 79 delete_area(regs_area); 80 /* a little cheap paranoia */ 81 regs = 0; 82 /* release our copy of the shared info from the kernel driver */ 83 delete_area(shared_info_area); 84 /* more cheap paranoia */ 85 si = 0; 86 } 87 88 /* 89 Initialize the accelerant. the_fd is the file handle of the device (in 90 /dev/graphics) that has been opened by the app_server (or some test harness). 91 We need to determine if the kernel driver and the accelerant are compatible. 92 If they are, get the accelerant ready to handle other hook functions and 93 report success or failure. 94 */ 95 status_t INIT_ACCELERANT(int the_fd) { 96 status_t result; 97 int pointer_reservation; //mem reserved for pointer 98 int cnt; //used for iteration through the overlay buffers 99 100 if (1) { 101 time_t now = time (NULL); 102 // LOG not available from here to next LOG: NULL si 103 // MSG(("INIT_ACCELERANT: booted since %f ms %s\n", system_time()/1000.0, real_time_clock())); 104 MSG(("INIT_ACCELERANT: %s", ctime (&now))); 105 } 106 107 /* note that we're the primary accelerant (accelerantIsClone is global) */ 108 accelerantIsClone = 0; 109 110 /* do the initialization common to both the primary and the clones */ 111 result = init_common(the_fd); 112 113 /* bail out if the common initialization failed */ 114 if (result != B_OK) goto error0; 115 // LOG now available: !NULL si 116 117 /* signal CRTC2 DPMS on G450/G550 which connector to program (before powerup) */ 118 si->crossed_conns = false; 119 120 /* call the device specific init code */ 121 result = gx00_general_powerup(); 122 123 /* bail out if it failed */ 124 if (result != B_OK) goto error1; 125 126 /* 127 Now would be a good time to figure out what video modes your card supports. 128 We'll place the list of modes in another shared area so all of the copies 129 of the driver can see them. The primary copy of the accelerant (ie the one 130 initialized with this routine) will own the "one true copy" of the list. 131 Everybody else get's a read-only clone. 132 */ 133 result = create_mode_list(); 134 if (result != B_OK) 135 { 136 goto error1; 137 } 138 139 /* 140 Put the cursor at the start of the frame buffer. The typical 64x64 4 color 141 (black, white, transparent, inverse) takes up 1024 bytes of RAM. 142 */ 143 /* Initialize the rest of the cursor information while we're here */ 144 si->cursor.width = 16; 145 si->cursor.height = 16; 146 si->cursor.hot_x = 0; 147 si->cursor.hot_y = 0; 148 si->cursor.x = 0; 149 si->cursor.y = 0; 150 151 /* 152 Put the frame buffer immediately following the cursor data. We store this 153 info in a frame_buffer_config structure to make it convienient to return 154 to the app_server later. 155 */ 156 pointer_reservation = 0; 157 /* MIL 1/2 cards have a seperate buffer for the cursorbitmap inside the DAC */ 158 if ((si->ps.card_type >= G100) && si->settings.hardcursor) 159 pointer_reservation = 1024; 160 161 si->fbc.frame_buffer = (void *)((char *)si->framebuffer+pointer_reservation); 162 si->fbc.frame_buffer_dma = (void *)((char *)si->framebuffer_pci+pointer_reservation); 163 164 /* count of issued parameters or commands */ 165 si->engine.last_idle = si->engine.count = 0; 166 INIT_BEN(si->engine.lock); 167 168 INIT_BEN(si->overlay.lock); 169 for (cnt = 0; cnt < MAXBUFFERS; cnt++) 170 { 171 /* make sure overlay buffers are 'marked' as being free */ 172 si->overlay.myBuffer[cnt].buffer = NULL; 173 si->overlay.myBuffer[cnt].buffer_dma = NULL; 174 } 175 /* make sure overlay unit is 'marked' as being free */ 176 si->overlay.myToken = NULL; 177 178 /* bail out if something failed */ 179 if (result != B_OK) goto error1; 180 181 /* initialise various cursor stuff*/ 182 gx00_crtc_cursor_init(); 183 184 /* ensure cursor state */ 185 SHOW_CURSOR(false); 186 187 /* a winner! */ 188 result = B_OK; 189 goto error0; 190 191 error1: 192 /* 193 Initialization failed after init_common() succeeded, so we need to clean 194 up before quiting. 195 */ 196 uninit_common(); 197 198 error0: 199 return result; 200 } 201 202 /* 203 Return the number of bytes required to hold the information required 204 to clone the device. 205 */ 206 ssize_t ACCELERANT_CLONE_INFO_SIZE(void) { 207 /* 208 Since we're passing the name of the device as the only required 209 info, return the size of the name buffer 210 */ 211 return B_OS_NAME_LENGTH; // apsed, was MAX_GX00_DEVICE_NAME_LENGTH; 212 } 213 214 215 /* 216 Return the info required to clone the device. void *data points to 217 a buffer at least ACCELERANT_CLONE_INFO_SIZE() bytes in length. 218 */ 219 void GET_ACCELERANT_CLONE_INFO(void *data) { 220 gx00_device_name dn; 221 status_t result; 222 223 /* call the kernel driver to get the device name */ 224 dn.magic = GX00_PRIVATE_DATA_MAGIC; 225 /* store the returned info directly into the passed buffer */ 226 dn.name = (char *)data; 227 result = ioctl(fd, GX00_DEVICE_NAME, &dn, sizeof(dn)); 228 } 229 230 /* 231 Initialize a copy of the accelerant as a clone. void *data points to 232 a copy of the data returned by GET_ACCELERANT_CLONE_INFO(). 233 */ 234 status_t CLONE_ACCELERANT(void *data) { 235 status_t result; 236 char path[MAXPATHLEN]; 237 238 /* the data is the device name */ 239 /* Note: the R4 graphics driver kit is in error here (missing trailing '/') */ 240 strcpy(path, "/dev/"); 241 strcat(path, (const char *)data); 242 /* open the device, the permissions aren't important */ 243 fd = open(path, B_READ_WRITE); 244 if (fd < 0) 245 { 246 /* we can't use LOG because we didn't get the shared_info struct.. */ 247 char fname[64]; 248 FILE *myhand = NULL; 249 250 sprintf (fname, "/boot/home/" DRIVER_PREFIX ".accelerant.0.log"); 251 myhand=fopen(fname,"a+"); 252 fprintf(myhand, "CLONE_ACCELERANT: couldn't open kerneldriver %s! Aborting.\n", path); 253 fclose(myhand); 254 255 /* abort with resultcode from open attempt on kerneldriver */ 256 result = fd; 257 goto error0; 258 } 259 260 /* note that we're a clone accelerant */ 261 accelerantIsClone = 1; 262 263 /* call the shared initialization code */ 264 result = init_common(fd); 265 266 /* bail out if the common initialization failed */ 267 if (result != B_OK) goto error1; 268 269 /* get shared area for display modes */ 270 result = my_mode_list_area = clone_area( 271 DRIVER_PREFIX " cloned display_modes", 272 (void **)&my_mode_list, 273 B_ANY_ADDRESS, 274 B_READ_AREA, 275 si->mode_area 276 ); 277 if (result < B_OK) goto error2; 278 279 /* all done */ 280 LOG(4,("CLONE_ACCELERANT: cloning was succesfull.\n")); 281 282 result = B_OK; 283 goto error0; 284 285 error2: 286 /* free up the areas we cloned */ 287 uninit_common(); 288 error1: 289 /* close the device we opened */ 290 close(fd); 291 error0: 292 return result; 293 } 294 295 void UNINIT_ACCELERANT(void) 296 { 297 if (accelerantIsClone) 298 { 299 LOG(4,("UNINIT_ACCELERANT: shutting down clone accelerant.\n")); 300 } 301 else 302 { 303 LOG(4,("UNINIT_ACCELERANT: shutting down primary accelerant.\n")); 304 305 /* delete benaphores ONLY if we are the primary accelerant */ 306 DELETE_BEN(si->engine.lock); 307 DELETE_BEN(si->overlay.lock); 308 } 309 310 /* free our mode list area */ 311 delete_area(my_mode_list_area); 312 /* paranoia */ 313 my_mode_list = 0; 314 /* release our cloned data */ 315 uninit_common(); 316 /* close the file handle ONLY if we're the clone */ 317 if (accelerantIsClone) close(fd); 318 } 319