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/2016. 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 nv_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 = NV_PRIVATE_DATA_MAGIC; 29 /* contact driver and get a pointer to the registers and shared data */ 30 result = ioctl(fd, NV_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, switchhead %d, force_pci %d\n", 42 si->settings.logmask, si->settings.memory, si->settings.hardcursor, si->settings.usebios, si->settings.switchhead, si->settings.force_pci)); 43 LOG(4,("init_common: dumprom %d, unhide_fw %d, pgm_panel %d, dma_acc %d, tv_output %d, vga_on_tv %d\n", 44 si->settings.dumprom, si->settings.unhide_fw, si->settings.pgm_panel, si->settings.dma_acc, si->settings.tv_output, si->settings.vga_on_tv)); 45 LOG(4,("init_common: force_sync %d, gpu_clk %dMhz, ram_clk %dMhz, force_ws %d, block_acc %d, check_edid %d\n", 46 si->settings.force_sync, si->settings.gpu_clk, si->settings.ram_clk, si->settings.force_ws, si->settings.block_acc, si->settings.check_edid)); 47 48 /*Check for R4.5.0 and if it is running, use work around*/ 49 { 50 if (si->use_clone_bugfix) 51 { 52 /*check for R4.5.0 bug and attempt to work around*/ 53 LOG(2,("InitACC: Found R4.5.0 bug - attempting to work around\n")); 54 regs = si->clone_bugfix_regs; 55 } 56 else 57 { 58 /* clone the memory mapped registers for our use - does not work on <4.5.2 (but is better this way)*/ 59 regs_area = clone_area(DRIVER_PREFIX " regs", (void **)®s, B_ANY_ADDRESS, 60 B_READ_AREA | B_WRITE_AREA, si->regs_area); 61 if (regs_area < 0) { 62 result = regs_area; 63 goto error1; 64 } 65 } 66 } 67 68 /* all done */ 69 goto error0; 70 71 error1: 72 delete_area(shared_info_area); 73 error0: 74 return result; 75 } 76 77 /* Clean up code shared between primary and cloned accelrants */ 78 static void uninit_common(void) { 79 /* release the memory mapped registers */ 80 delete_area(regs_area); 81 /* a little cheap paranoia */ 82 regs = 0; 83 /* release our copy of the shared info from the kernel driver */ 84 delete_area(shared_info_area); 85 /* more cheap paranoia */ 86 si = 0; 87 } 88 89 /* 90 Initialize the accelerant. the_fd is the file handle of the device (in 91 /dev/graphics) that has been opened by the app_server (or some test harness). 92 We need to determine if the kernel driver and the accelerant are compatible. 93 If they are, get the accelerant ready to handle other hook functions and 94 report success or failure. 95 */ 96 status_t INIT_ACCELERANT(int the_fd) 97 { 98 status_t result; 99 int pointer_reservation; //mem reserved for pointer 100 int cnt; //used for iteration through the overlay buffers 101 102 if (0) { 103 time_t now = time (NULL); 104 // LOG not available from here to next LOG: NULL si 105 MSG(("INIT_ACCELERANT: %s", ctime (&now))); 106 } 107 108 /* note that we're the primary accelerant (accelerantIsClone is global) */ 109 accelerantIsClone = 0; 110 111 /* do the initialization common to both the primary and the clones */ 112 result = init_common(the_fd); 113 114 /* bail out if the common initialization failed */ 115 if (result != B_OK) goto error0; 116 // LOG now available: !NULL si 117 118 /* ensure that INIT_ACCELERANT is executed just once (copies should be clones) */ 119 if (si->accelerant_in_use) 120 { 121 result = B_NOT_ALLOWED; 122 goto error1; 123 } 124 125 /* call the device specific init code */ 126 result = nv_general_powerup(); 127 128 /* bail out if it failed */ 129 if (result != B_OK) goto error1; 130 131 /* 132 Now would be a good time to figure out what video modes your card supports. 133 We'll place the list of modes in another shared area so all of the copies 134 of the driver can see them. The primary copy of the accelerant (ie the one 135 initialized with this routine) will own the "one true copy" of the list. 136 Everybody else get's a read-only clone. 137 */ 138 result = create_mode_list(); 139 if (result != B_OK) 140 { 141 goto error1; 142 } 143 144 /* 145 Put the cursor at the start of the frame buffer. 146 Nvidia cursor is 32x32 16 color? takes up 4096 bytes of RAM. 147 */ 148 /* Initialize the rest of the cursor information while we're here */ 149 si->cursor.width = 16; 150 si->cursor.height = 16; 151 si->cursor.hot_x = 0; 152 si->cursor.hot_y = 0; 153 si->cursor.x = 0; 154 si->cursor.y = 0; 155 si->cursor.dh_right = false; 156 157 /* 158 Put the frame buffer immediately following the cursor data. We store this 159 info in a frame_buffer_config structure to make it convienient to return 160 to the app_server later. 161 */ 162 pointer_reservation = 0; 163 /* Nvidia hardcursor needs 2kB space */ 164 if (si->settings.hardcursor) pointer_reservation = 2048; 165 166 si->fbc.frame_buffer = (void *)((char *)si->framebuffer+pointer_reservation); 167 si->fbc.frame_buffer_dma = (void *)((char *)si->framebuffer_pci+pointer_reservation); 168 169 /* count of issued parameters or commands */ 170 si->engine.last_idle = si->engine.count = 0; 171 /* no 3D clones are currently loaded */ 172 si->engine.threeD.clones = 0; 173 /* tell 3D add-ons that they should reload their rendering states and surfaces */ 174 si->engine.threeD.reload = 0xffffffff; 175 INIT_BEN(si->engine.lock); 176 177 INIT_BEN(si->overlay.lock); 178 for (cnt = 0; cnt < MAXBUFFERS; cnt++) 179 { 180 /* make sure overlay buffers are 'marked' as being free */ 181 si->overlay.myBuffer[cnt].buffer = NULL; 182 si->overlay.myBuffer[cnt].buffer_dma = NULL; 183 } 184 185 /* make sure overlay unit is 'marked' as being free */ 186 si->overlay.myToken = NULL; 187 188 /* note that overlay is not in use (for nv_bes_move_overlay()) */ 189 si->overlay.active = false; 190 191 /* bail out if something failed */ 192 if (result != B_OK) goto error1; 193 194 /* initialise various cursor stuff */ 195 head1_cursor_init(); 196 if (si->ps.secondary_head) head2_cursor_init(); 197 198 /* ensure cursor state */ 199 head1_cursor_hide(); 200 if (si->ps.secondary_head) head2_cursor_hide(); 201 202 /* ensure DPMS state */ 203 si->dpms_flags = B_DPMS_ON; 204 205 /* ensure TVout state: 206 * TVencoder is on head to be assigned primary, no dualhead switch mode active. */ 207 //fixme: actually check on what CRTC TVout was active during boot (if any)... 208 si->dm.flags = TV_PRIMARY; 209 210 /* make sure a possible 3D add-on will block rendering and re-initialize itself. 211 * note: update in _this_ order only */ 212 /* SET_DISPLAY_MODE will reset this flag when it's done. */ 213 si->engine.threeD.mode_changing = true; 214 /* every 3D add-on will reset this bit-flag when it's done. */ 215 si->engine.threeD.newmode = 0xffffffff; 216 217 /* we did not detect the Haiku ScreenPrefs app yet */ 218 si->haiku_prefs_used = false; 219 si->Haiku_switch_head = false; 220 221 /* a winner! */ 222 result = B_OK; 223 /* ensure that INIT_ACCELERANT won't be executed again (copies should be clones) */ 224 si->accelerant_in_use = true; 225 goto error0; 226 227 error1: 228 /* 229 Initialization failed after init_common() succeeded, so we need to clean 230 up before quiting. 231 */ 232 uninit_common(); 233 234 error0: 235 return result; 236 } 237 238 /* 239 Return the number of bytes required to hold the information required 240 to clone the device. 241 */ 242 ssize_t ACCELERANT_CLONE_INFO_SIZE(void) { 243 /* 244 Since we're passing the name of the device as the only required 245 info, return the size of the name buffer 246 */ 247 return B_OS_NAME_LENGTH; // apsed, was MAX_NV_DEVICE_NAME_LENGTH; 248 } 249 250 251 /* 252 Return the info required to clone the device. void *data points to 253 a buffer at least ACCELERANT_CLONE_INFO_SIZE() bytes in length. 254 */ 255 void GET_ACCELERANT_CLONE_INFO(void *data) { 256 nv_device_name dn; 257 status_t result; 258 259 /* call the kernel driver to get the device name */ 260 dn.magic = NV_PRIVATE_DATA_MAGIC; 261 /* store the returned info directly into the passed buffer */ 262 dn.name = (char *)data; 263 result = ioctl(fd, NV_DEVICE_NAME, &dn, sizeof(dn)); 264 } 265 266 /* 267 Initialize a copy of the accelerant as a clone. void *data points to 268 a copy of the data returned by GET_ACCELERANT_CLONE_INFO(). 269 */ 270 status_t CLONE_ACCELERANT(void *data) 271 { 272 status_t result; 273 char path[MAXPATHLEN]; 274 275 /* the data is the device name */ 276 /* Note: the R4 graphics driver kit is in error here (missing trailing '/') */ 277 strcpy(path, "/dev/"); 278 strcat(path, (const char *)data); 279 /* open the device, the permissions aren't important */ 280 fd = open(path, B_READ_WRITE); 281 if (fd < 0) 282 { 283 /* we can't use LOG because we didn't get the shared_info struct.. */ 284 char fname[64]; 285 FILE *myhand = NULL; 286 287 sprintf (fname, "/boot/home/" DRIVER_PREFIX ".accelerant.0.log"); 288 myhand=fopen(fname,"a+"); 289 fprintf(myhand, "CLONE_ACCELERANT: couldn't open kerneldriver %s! Aborting.\n", path); 290 fclose(myhand); 291 292 /* abort with resultcode from open attempt on kerneldriver */ 293 result = fd; 294 goto error0; 295 } 296 297 /* note that we're a clone accelerant */ 298 accelerantIsClone = 1; 299 300 /* call the shared initialization code */ 301 result = init_common(fd); 302 303 /* bail out if the common initialization failed */ 304 if (result != B_OK) goto error1; 305 306 /* ensure that INIT_ACCELERANT is executed first (i.e. primary accelerant exists) */ 307 if (!(si->accelerant_in_use)) 308 { 309 result = B_NOT_ALLOWED; 310 goto error2; 311 } 312 313 /* setup CRTC and DAC functions access */ 314 //fixme: setup_virtualized_heads is a problem for clones: needs to be run 315 //for each clone if the mode is changed! 316 if (si->ps.secondary_head) 317 setup_virtualized_heads(si->crtc_switch_mode); 318 else 319 setup_virtualized_heads(si->ps.crtc2_prim); 320 321 /* get shared area for display modes */ 322 result = my_mode_list_area = clone_area( 323 DRIVER_PREFIX " cloned display_modes", 324 (void **)&my_mode_list, 325 B_ANY_ADDRESS, 326 B_READ_AREA, 327 si->mode_area 328 ); 329 if (result < B_OK) goto error2; 330 331 /* all done */ 332 LOG(4,("CLONE_ACCELERANT: cloning was succesfull.\n")); 333 334 result = B_OK; 335 goto error0; 336 337 error2: 338 /* free up the areas we cloned */ 339 uninit_common(); 340 error1: 341 /* close the device we opened */ 342 close(fd); 343 error0: 344 return result; 345 } 346 347 void UNINIT_ACCELERANT(void) 348 { 349 if (accelerantIsClone) 350 { 351 LOG(4,("UNINIT_ACCELERANT: shutting down clone accelerant.\n")); 352 } 353 else 354 { 355 LOG(4,("UNINIT_ACCELERANT: shutting down primary accelerant.\n")); 356 357 /* delete benaphores ONLY if we are the primary accelerant */ 358 DELETE_BEN(si->engine.lock); 359 DELETE_BEN(si->overlay.lock); 360 361 /* ensure that INIT_ACCELERANT can be executed again */ 362 si->accelerant_in_use = false; 363 } 364 365 /* free our mode list area */ 366 delete_area(my_mode_list_area); 367 /* paranoia */ 368 my_mode_list = 0; 369 /* release our cloned data */ 370 uninit_common(); 371 /* close the file handle ONLY if we're the clone */ 372 if (accelerantIsClone) close(fd); 373 } 374