src/add-ons/accelerants/nvidia/GetAccelerantHook.c

   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-8/2009
   8 */
   9
  10 #define MODULE_BIT 0x08000000
  11
  12 #include "acc_std.h"
  13
  14 /*
  15 The standard entry point.  Given a uint32 feature identifier, this routine
  16 returns a pointer to the function that implements the feature.  Some features
  17 require more information than just the identifier to select the proper
  18 function.  The extra information (which is specific to the feature) is
  19 pointed at by the void *data parameter.  By default, no extra information
  20 is available.  Any extra information available to choose the function will be
  21 noted on a case by case below.
  22 */
  23
  24 /*
  25 These definitions are out of pure lazyness.
  26 */
  27 #define CHKO(x) case B_##x: \
  28         if (check_overlay_capability(B_##x) == B_OK) return (void *)x; else return (void *)0
  29 #define CHKA(x) case B_##x: \
  30         if (check_acc_capability(B_##x) == B_OK) \
  31         {if(!si->settings.dma_acc) return (void *)x##_PIO; else return (void *)x##_DMA;} \
  32         else return (void *)0
  33 #define CHKS(x) case B_##x: \
  34         if(!si->settings.dma_acc) return (void *)x##_PIO; else return (void *)x##_DMA
  35 #define HOOK(x) case B_##x: return (void *)x
  36 #define ZERO(x) case B_##x: return (void *)0
  37 #define HRDC(x) case B_##x: return si->settings.hardcursor? (void *)x: (void *)0; // apsed
  38
  39 void *  get_accelerant_hook(uint32 feature, void *data)
  40 {
  41         switch (feature)
  42         {
  43                 /*
  44                 One of either B_INIT_ACCELERANT or B_CLONE_ACCELERANT will be requested and
  45                 subsequently called before any other hook is requested.  All other feature
  46                 hook selections can be predicated on variables assigned during the accelerant
  47                 initialization process.
  48                 */
  49
  50                 /* initialization */
  51                 HOOK(INIT_ACCELERANT);
  52                 HOOK(CLONE_ACCELERANT);
  53
  54                 HOOK(ACCELERANT_CLONE_INFO_SIZE);
  55                 HOOK(GET_ACCELERANT_CLONE_INFO);
  56                 HOOK(UNINIT_ACCELERANT);
  57                 HOOK(GET_ACCELERANT_DEVICE_INFO);
  58                 HOOK(ACCELERANT_RETRACE_SEMAPHORE);
  59
  60                 /* mode configuration */
  61                 HOOK(ACCELERANT_MODE_COUNT);
  62                 HOOK(GET_MODE_LIST);
  63                 HOOK(PROPOSE_DISPLAY_MODE);
  64                 HOOK(SET_DISPLAY_MODE);
  65                 HOOK(GET_DISPLAY_MODE);
  66 #ifdef __HAIKU__
  67                 HOOK(GET_EDID_INFO);
  68                 HOOK(GET_PREFERRED_DISPLAY_MODE);
  69 #endif
  70                 HOOK(GET_FRAME_BUFFER_CONFIG);
  71                 HOOK(GET_PIXEL_CLOCK_LIMITS);
  72                 HOOK(MOVE_DISPLAY);
  73                 HOOK(SET_INDEXED_COLORS);
  74                 HOOK(GET_TIMING_CONSTRAINTS);
  75
  76                 HOOK(DPMS_CAPABILITIES);
  77                 HOOK(DPMS_MODE);
  78                 HOOK(SET_DPMS_MODE);
  79
  80                 /* cursor managment */
  81                 HRDC(SET_CURSOR_SHAPE);
  82                 HRDC(MOVE_CURSOR);
  83                 HRDC(SHOW_CURSOR);
  84
  85                 /* synchronization */
  86                 HOOK(ACCELERANT_ENGINE_COUNT);
  87                 CHKS(ACQUIRE_ENGINE);
  88                 HOOK(RELEASE_ENGINE);
  89                 HOOK(WAIT_ENGINE_IDLE);
  90                 HOOK(GET_SYNC_TOKEN);
  91                 HOOK(SYNC_TO_TOKEN);
  92
  93                 /*
  94                 Depending on the engine architecture, you may choose to provide a different
  95                 function to be used with each bit-depth for example.
  96
  97                 Note: These hooks are re-acquired by the app_server after each mode switch.
  98                 */
  99
 100                 /* only export video overlay functions if card is capable of it */
 101                 CHKO(OVERLAY_COUNT);
 102                 CHKO(OVERLAY_SUPPORTED_SPACES);
 103                 CHKO(OVERLAY_SUPPORTED_FEATURES);
 104                 CHKO(ALLOCATE_OVERLAY_BUFFER);
 105                 CHKO(RELEASE_OVERLAY_BUFFER);
 106                 CHKO(GET_OVERLAY_CONSTRAINTS);
 107                 CHKO(ALLOCATE_OVERLAY);
 108                 CHKO(RELEASE_OVERLAY);
 109                 CHKO(CONFIGURE_OVERLAY);
 110
 111                 /*
 112                 When requesting an acceleration hook, the calling application provides a
 113                 pointer to the display_mode for which the acceleration function will be used.
 114                 Depending on the engine architecture, you may choose to provide a different
 115                 function to be used with each bit-depth.  In the sample driver we return
 116                 the same function all the time.
 117
 118                 Note: These hooks are re-acquired by the app_server after each mode switch.
 119                 */
 120
 121                 /* only export 2D acceleration functions in modes that are capable of it */
 122                 /* used by the app_server and applications (BWindowScreen) */
 123                 CHKA(SCREEN_TO_SCREEN_BLIT);
 124                 CHKA(FILL_RECTANGLE);
 125                 CHKA(INVERT_RECTANGLE);
 126                 CHKA(FILL_SPAN);
 127                 /* not (yet) used by the app_server:
 128                  * so just for application use (BWindowScreen) */
 129 //              CHKA(SCREEN_TO_SCREEN_TRANSPARENT_BLIT);
 130                 CHKA(SCREEN_TO_SCREEN_SCALED_FILTERED_BLIT);
 131         }
 132
 133         /* Return a null pointer for any feature we don't understand. */
 134         return 0;
 135 }
 136 #undef CHKO
 137 #undef CHKA
 138 #undef CHKD
 139 #undef HOOK
 140 #undef ZERO
 141 #undef HRDC
 142
 143 status_t check_overlay_capability(uint32 feature)
 144 {
 145         char *msg = "";
 146
 147         /* setup logmessage text */
 148         switch (feature)
 149         {
 150         case B_OVERLAY_COUNT:
 151                 msg = "B_OVERLAY_COUNT";
 152                 break;
 153         case B_OVERLAY_SUPPORTED_SPACES:
 154                 msg = "B_OVERLAY_SUPPORTED_SPACES";
 155                 break;
 156         case B_OVERLAY_SUPPORTED_FEATURES:
 157                 msg = "B_OVERLAY_SUPPORTED_FEATURES";
 158                 break;
 159         case B_ALLOCATE_OVERLAY_BUFFER:
 160                 msg = "B_ALLOCATE_OVERLAY_BUFFER";
 161                 break;
 162         case B_RELEASE_OVERLAY_BUFFER:
 163                 msg = "B_RELEASE_OVERLAY_BUFFER";
 164                 break;
 165         case B_GET_OVERLAY_CONSTRAINTS:
 166                 msg = "B_GET_OVERLAY_CONSTRAINTS";
 167                 break;
 168         case B_ALLOCATE_OVERLAY:
 169                 msg = "B_ALLOCATE_OVERLAY";
 170                 break;
 171         case B_RELEASE_OVERLAY:
 172                 msg = "B_RELEASE_OVERLAY";
 173                 break;
 174         case B_CONFIGURE_OVERLAY:
 175                 msg = "B_CONFIGURE_OVERLAY";
 176                 break;
 177         default:
 178                 msg = "UNKNOWN";
 179                 break;
 180         }
 181
 182         /* all older cards have a supported bes */
 183         if ((si->ps.card_type <= NV40) || (si->ps.card_type == NV45))
 184         {
 185                 LOG(4, ("Overlay: Exporting hook %s.\n", msg));
 186                 return B_OK;
 187         }
 188
 189         /* all newer NV40 architecture cards have a new HDTV capable bes except for
 190          * GeForce 6800's. Unfortunately we have no info about the new bes yet. */
 191         LOG(4, ("Overlay: Not exporting hook %s.\n", msg));
 192         return B_ERROR;
 193 }
 194
 195 status_t check_acc_capability(uint32 feature)
 196 {
 197         char *msg = "";
 198
 199         /* setup logmessage text */
 200         switch (feature)
 201         {
 202         case B_SCREEN_TO_SCREEN_BLIT:
 203                 msg = "B_SCREEN_TO_SCREEN_BLIT";
 204                 break;
 205         case B_FILL_RECTANGLE:
 206                 msg = "B_FILL_RECTANGLE";
 207                 break;
 208         case B_INVERT_RECTANGLE:
 209                 msg = "B_INVERT_RECTANGLE";
 210                 break;
 211         case B_FILL_SPAN:
 212                 msg = "B_FILL_SPAN";
 213                 break;
 214         case B_SCREEN_TO_SCREEN_TRANSPARENT_BLIT:
 215                 msg = "B_SCREEN_TO_SCREEN_TRANSPARENT_BLIT";
 216                 break;
 217         case B_SCREEN_TO_SCREEN_SCALED_FILTERED_BLIT:
 218                 msg = "B_SCREEN_TO_SCREEN_SCALED_FILTERED_BLIT";
 219                 /* this function is only defined for DMA acceleration,
 220                  * but doesn't support the B_CMAP8 colorspace */
 221                 //fixme: checkout B_CMAP8 support sometime, as some cards seem to support it?
 222                 if (!si->settings.dma_acc || (si->dm.space == B_CMAP8))
 223                 {
 224                         LOG(4, ("Acc: Not exporting hook %s.\n", msg));
 225                         return B_ERROR;
 226                 }
 227                 break;
 228         default:
 229                 msg = "UNKNOWN";
 230                 break;
 231         }
 232
 233         /* hardware acceleration is only supported in modes with upto a certain
 234          * memory pitch.. and acceleration must not be blocked */
 235         if (si->acc_mode && !si->settings.block_acc)
 236         {
 237                 LOG(4, ("Acc: Exporting hook %s.\n", msg));
 238                 return B_OK;
 239         }
 240         else
 241         {
 242                 LOG(4, ("Acc: Not exporting hook %s.\n", msg));
 243                 return B_ERROR;
 244         }
 245 }