radeon_mergedfb.c

x.org上有关ati系列显卡最新驱动

	case X_XineramaQueryScreens:
	     return RADEONSProcXineramaQueryScreens(client);
    }
    return BadRequest;
}

static void
RADEONXineramaResetProc(ExtensionEntry* extEntry)
{
    if(RADEONXineramadataPtr) {
       Xfree(RADEONXineramadataPtr);
       RADEONXineramadataPtr = NULL;
    }
}

void
RADEONXineramaExtensionInit(ScrnInfoPtr pScrn)
{
    RADEONInfoPtr info = RADEONPTR(pScrn);
    Bool	success = FALSE;

    if(!(RADEONXineramadataPtr)) {

       if(!info->MergedFB) {
          RADEONnoPanoramiXExtension = TRUE;
	  info->MouseRestrictions = FALSE;
          return;
       }

#ifdef PANORAMIX
       if(!noPanoramiXExtension) {
          xf86DrvMsg(pScrn->scrnIndex, X_INFO,
       	     "Xinerama active, not initializing Radeon Pseudo-Xinerama\n");
          RADEONnoPanoramiXExtension = TRUE;
	  info->MouseRestrictions = FALSE;
          return;
       }
#endif

       if(RADEONnoPanoramiXExtension) {
          xf86DrvMsg(pScrn->scrnIndex, X_INFO,
       	      "Radeon Pseudo-Xinerama disabled\n");
	  info->MouseRestrictions = FALSE;
          return;
       }

       if(info->CRT2Position == radeonClone) {
          xf86DrvMsg(pScrn->scrnIndex, X_INFO,
       	     "Running MergedFB in Clone mode, Radeon Pseudo-Xinerama disabled\n");
          RADEONnoPanoramiXExtension = TRUE;
	  info->MouseRestrictions = FALSE;
          return;
       }

       if(!(info->AtLeastOneNonClone)) {
          xf86DrvMsg(pScrn->scrnIndex, X_INFO,
       	     "Only Clone modes defined, Radeon Pseudo-Xinerama disabled\n");
          RADEONnoPanoramiXExtension = TRUE;
	  info->MouseRestrictions = FALSE;
          return;
       }

       RADEONXineramaNumScreens = 2;

       while(RADEONXineramaGeneration != serverGeneration) {

	  info->XineramaExtEntry = AddExtension(PANORAMIX_PROTOCOL_NAME, 0,0,
					RADEONProcXineramaDispatch,
					RADEONSProcXineramaDispatch,
					RADEONXineramaResetProc,
					StandardMinorOpcode);

	  if(!info->XineramaExtEntry) break;

	  RADEONXineramaReqCode = (unsigned char)info->XineramaExtEntry->base;

	  if(!(RADEONXineramadataPtr = (RADEONXineramaData *)
	        xcalloc(RADEONXineramaNumScreens, sizeof(RADEONXineramaData)))) break;

	  RADEONXineramaGeneration = serverGeneration;
	  success = TRUE;
       }

       if(!success) {
          xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
	    	"Failed to initialize Radeon Pseudo-Xinerama extension\n");
          RADEONnoPanoramiXExtension = TRUE;
	  info->MouseRestrictions = FALSE;
          return;
       }

       xf86DrvMsg(pScrn->scrnIndex, X_INFO,
    	  "Initialized Radeon Pseudo-Xinerama extension\n");

       info->RADEONXineramaVX = 0;
       info->RADEONXineramaVY = 0;

    }

    RADEONUpdateXineramaScreenInfo(pScrn);

}
/* End of PseudoXinerama */

static Bool
InRegion(int x, int y, region r)
{
    return (r.x0 <= x) && (x <= r.x1) && (r.y0 <= y) && (y <= r.y1);
}

void
RADEONMergePointerMoved(int scrnIndex, int x, int y)
{
  ScrnInfoPtr   pScrn1 = xf86Screens[scrnIndex];
  RADEONInfoPtr info = RADEONPTR(pScrn1);
  ScrnInfoPtr   pScrn2 = info->CRT2pScrn;
  region 	out, in1, in2, f2, f1;
  int 		deltax, deltay;
  int           temp1, temp2;
  int           old1x0, old1y0, old2x0, old2y0;
  int		CRT1XOffs = 0, CRT1YOffs = 0, CRT2XOffs = 0, CRT2YOffs = 0;
  int		HVirt = pScrn1->virtualX;
  int		VVirt = pScrn1->virtualY;
  int		sigstate;
  Bool		doit = FALSE, HaveNonRect = FALSE, HaveOffsRegions = FALSE;
  RADEONScrn2Rel   srel = ((RADEONMergedDisplayModePtr)info->CurrentLayout.mode->Private)->CRT2Position;

  if(info->DGAactive) {
     return;
     /* DGA: There is no cursor and no panning while DGA is active. */
     /* If it were, we would need to do: */
     /* HVirt = info->CurrentLayout.displayWidth;
        VVirt = info->CurrentLayout.displayHeight;
        BOUND(x, info->CurrentLayout.DGAViewportX, HVirt);
        BOUND(y, info->CurrentLayout.DGAViewportY, VVirt); */
  } else {
     CRT1XOffs = info->CRT1XOffs;
     CRT1YOffs = info->CRT1YOffs;
     CRT2XOffs = info->CRT2XOffs;
     CRT2YOffs = info->CRT2YOffs;
     HaveNonRect = info->HaveNonRect;
     HaveOffsRegions = info->HaveOffsRegions;
  }

  /* Check if the pointer is inside our dead areas */
  if((info->MouseRestrictions) && (srel != radeonClone) && !RADEONnoPanoramiXExtension) {
     if(HaveNonRect) {
	if(InRegion(x, y, info->NonRectDead)) {
	   switch(srel) {
	   case radeonLeftOf:
	   case radeonRightOf: y = info->NonRectDead.y0 - 1;
			    doit = TRUE;
			    break;
	   case radeonAbove:
	   case radeonBelow:   x = info->NonRectDead.x0 - 1;
			    doit = TRUE;
	   default:	    break;
	   }
	}
     }
     if(HaveOffsRegions) {
	if(InRegion(x, y, info->OffDead1)) {
	   switch(srel) {
	   case radeonLeftOf:
	   case radeonRightOf: y = info->OffDead1.y1;
			    doit = TRUE;
			    break;
	   case radeonAbove:
	   case radeonBelow:   x = info->OffDead1.x1;
			    doit = TRUE;
	   default:	    break;
	   }
	} else if(InRegion(x, y, info->OffDead2)) {
	   switch(srel) {
	   case radeonLeftOf:
	   case radeonRightOf: y = info->OffDead2.y0 - 1;
			    doit = TRUE;
			    break;
	   case radeonAbove:
	   case radeonBelow:   x = info->OffDead2.x0 - 1;
			    doit = TRUE;
	   default:	    break;
	   }
	}
     }
     if(doit) {
	UpdateCurrentTime();
	sigstate = xf86BlockSIGIO();
	miPointerAbsoluteCursor(x, y, currentTime.milliseconds);
	xf86UnblockSIGIO(sigstate);
	return;
     }
  }

  f1.x0 = old1x0 = info->CRT1frameX0;
  f1.x1 = info->CRT1frameX1;
  f1.y0 = old1y0 = info->CRT1frameY0;
  f1.y1 = info->CRT1frameY1;
  f2.x0 = old2x0 = pScrn2->frameX0;
  f2.x1 = pScrn2->frameX1;
  f2.y0 = old2y0 = pScrn2->frameY0;
  f2.y1 = pScrn2->frameY1;

  /* Define the outer region. Crossing this causes all frames to move */
  out.x0 = pScrn1->frameX0;
  out.x1 = pScrn1->frameX1;
  out.y0 = pScrn1->frameY0;
  out.y1 = pScrn1->frameY1;

  /*
   * Define the inner sliding window. Being outsize both frames but
   * inside the outer clipping window will slide corresponding frame
   */
  in1 = out;
  in2 = out;
  switch(srel) {
     case radeonLeftOf:
        in1.x0 = f1.x0;
        in2.x1 = f2.x1;
        break;
     case radeonRightOf:
        in1.x1 = f1.x1;
        in2.x0 = f2.x0;
        break;
     case radeonBelow:
        in1.y1 = f1.y1;
        in2.y0 = f2.y0;
        break;
     case radeonAbove:
        in1.y0 = f1.y0;
        in2.y1 = f2.y1;
        break;
     case radeonClone:
        break;
  }

  deltay = 0;
  deltax = 0;

  if(InRegion(x, y, out)) {	/* inside outer region */

     /* xf86DrvMsg(0, X_INFO, "1: %d %d | %d %d %d %d | %d %d %d %d\n",
     	x, y, in1.x0, in1.x1, in1.y0, in1.y1, f1.x0, f1.x1, f1.y0, f1.y1); */

     if(InRegion(x, y, in1) && !InRegion(x, y, f1)) {
        REBOUND(f1.x0, f1.x1, x);
        REBOUND(f1.y0, f1.y1, y);
        deltax = 1;
	/* xf86DrvMsg(0, X_INFO, "2: %d %d | %d %d %d %d | %d %d %d %d\n",
     		x, y, in1.x0, in1.x1, in1.y0, in1.y1, f1.x0, f1.x1, f1.y0, f1.y1); */
     }
     if(InRegion(x, y, in2) && !InRegion(x, y, f2)) {
        REBOUND(f2.x0, f2.x1, x);
        REBOUND(f2.y0, f2.y1, y);
        deltax = 1;
     }

  } else {			/* outside outer region */

     /* xf86DrvMsg(0, X_INFO, "3: %d %d | %d %d %d %d | %d %d %d %d\n",
     	x, y, in1.x0, in1.x1, in1.y0, in1.y1, f1.x0, f1.x1, f1.y0, f1.y1);
     xf86DrvMsg(0, X_INFO, "3-out: %d %d %d %d\n",
     	out.x0, out.x1, out.y0, out.y1); */

     if(out.x0 > x) {
        deltax = x - out.x0;
     }
     if(out.x1 < x) {
        deltax = x - out.x1;
     }
     if(deltax) {
        pScrn1->frameX0 += deltax;
        pScrn1->frameX1 += deltax;
	f1.x0 += deltax;
        f1.x1 += deltax;
        f2.x0 += deltax;
        f2.x1 += deltax;
     }

     if(out.y0 > y) {
        deltay = y - out.y0;
     }
     if(out.y1 < y) {
        deltay = y - out.y1;
     }
     if(deltay) {
        pScrn1->frameY0 += deltay;
        pScrn1->frameY1 += deltay;
	f1.y0 += deltay;
        f1.y1 += deltay;
        f2.y0 += deltay;
        f2.y1 += deltay;
     }

     switch(srel) {
        case radeonLeftOf:
	   if(x >= f1.x0) { REBOUND(f1.y0, f1.y1, y); }
	   if(x <= f2.x1) { REBOUND(f2.y0, f2.y1, y); }
           break;
        case radeonRightOf:
	   if(x <= f1.x1) { REBOUND(f1.y0, f1.y1, y); }
	   if(x >= f2.x0) { REBOUND(f2.y0, f2.y1, y); }
           break;
        case radeonBelow:
	   if(y <= f1.y1) { REBOUND(f1.x0, f1.x1, x); }
	   if(y >= f2.y0) { REBOUND(f2.x0, f2.x1, x); }
           break;
        case radeonAbove:
	   if(y >= f1.y0) { REBOUND(f1.x0, f1.x1, x); }
	   if(y <= f2.y1) { REBOUND(f2.x0, f2.x1, x); }
           break;
        case radeonClone:
           break;
     }

  }

  if(deltax || deltay) {
     info->CRT1frameX0 = f1.x0;
     info->CRT1frameY0 = f1.y0;
     pScrn2->frameX0 = f2.x0;
     pScrn2->frameY0 = f2.y0;

     switch(((RADEONMergedDisplayModePtr)info->CurrentLayout.mode->Private)->CRT2Position) {
	case radeonLeftOf:
	case radeonRightOf:
	    if(info->CRT1YOffs || info->CRT2YOffs || HaveNonRect) {
		if(info->CRT1frameY0 != old1y0) {
		    if(info->CRT1frameY0 < info->CRT1YOffs)
  	                info->CRT1frameY0 = info->CRT1YOffs;
  	            temp1 = info->CRT1frameY0 + CDMPTR->CRT1->VDisplay;
  	            /*temp2 = pScrn1->virtualY - info->CRT2YOffs;*/
		    temp2 = min((VVirt - CRT2YOffs), (CRT1YOffs + info->MBXNR1YMAX));
  	            if(temp1 > temp2)
  	                info->CRT1frameY0 -= (temp1 - temp2);
  	        }
  	        if(pScrn2->frameY0 != old2y0) {
  	            if(pScrn2->frameY0 < info->CRT2YOffs)
  	                pScrn2->frameY0 = info->CRT2YOffs;
  	            temp1 = pScrn2->frameY0   + CDMPTR->CRT2->VDisplay;
  	            /*temp2 = pScrn1->virtualY - info->CRT1YOffs;*/
		    temp2 = min((VVirt - CRT1YOffs), (CRT2YOffs + info->MBXNR2YMAX));
  	            if(temp1 > temp2)
  	                pScrn2->frameY0 -= (temp1 - temp2);
  	        }
  	    }
	    break;
	case radeonBelow:
	case radeonAbove:
	    if(info->CRT1XOffs || info->CRT2XOffs || HaveNonRect) {
		if(info->CRT1frameX0 != old1x0) {
		    if(info->CRT1frameX0 < info->CRT1XOffs)
			info->CRT1frameX0 = info->CRT1XOffs;
		    temp1 = info->CRT1frameX0 + CDMPTR->CRT1->HDisplay;
  	            /*temp2 = pScrn1->virtualX - info->CRT2XOffs;*/
                    temp2 = min((HVirt - CRT2XOffs), (CRT1XOffs + info->MBXNR1XMAX));
  	            if(temp1 > temp2)
  	            	info->CRT1frameX0 -= (temp1 - temp2);
  	        }
  	        if(pScrn2->frameX0 != old2x0) {
  	            if(pScrn2->frameX0 < info->CRT2XOffs)
  	       		pScrn2->frameX0 = info->CRT2XOffs;
  	            temp1 = pScrn2->frameX0   + CDMPTR->CRT2->HDisplay;
  	            /*temp2 = pScrn1->virtualX - info->CRT1XOffs;*/
		    temp2 = min((HVirt - CRT1XOffs), (CRT2XOffs + info->MBXNR2XMAX));
  	            if(temp1 > temp2)
  	            	pScrn2->frameX0 -= (temp1 - temp2);
  	        }
  	    }
  	    break;
  	    case radeonClone:
  	    	break;
     }

     info->CRT1frameX1 = info->CRT1frameX0 + CDMPTR->CRT1->HDisplay - 1;
     info->CRT1frameY1 = info->CRT1frameY0 + CDMPTR->CRT1->VDisplay - 1;
     pScrn2->frameX1   = pScrn2->frameX0   + CDMPTR->CRT2->HDisplay - 1;
     pScrn2->frameY1   = pScrn2->frameY0   + CDMPTR->CRT2->VDisplay - 1;
#if 0
     pScrn1->frameX1   = pScrn1->frameX0   + info->CurrentLayout.mode->HDisplay  - 1;
     pScrn1->frameY1   = pScrn1->frameY0   + info->CurrentLayout.mode->VDisplay  - 1;
#endif

     RADEONDoAdjustFrame(pScrn1, info->CRT1frameX0, info->CRT1frameY0, FALSE);
     RADEONDoAdjustFrame(pScrn1, pScrn2->frameX0, pScrn2->frameY0, TRUE);
  }
}

static void
RADEONAdjustFrameMergedHelper(int scrnIndex, int x, int y, int flags)
{
    ScrnInfoPtr pScrn1 = xf86Screens[scrnIndex];
    RADEONInfoPtr info = RADEONPTR(pScrn1);
    ScrnInfoPtr pScrn2 = info->CRT2pScrn;
    int VTotal = info->CurrentLayout.mode->VDisplay;
    int HTotal = info->CurrentLayout.mode->HDisplay;
    int VMax = VTotal;
    int HMax = HTotal;
    int HVirt = pScrn1->virtualX;
    int VVirt = pScrn1->virtualY;
    int x1 = x, x2 = x;
    int y1 = y, y2 = y;
    int CRT1XOffs = 0, CRT1YOffs = 0, CRT2XOffs = 0, CRT2YOffs = 0;
    int MBXNR1XMAX = 65536, MBXNR1YMAX = 65536, MBXNR2XMAX = 65536, MBXNR2YMAX = 65536;

    if(info->DGAactive) {
       HVirt = info->CurrentLayout.displayWidth;
       VVirt = info->CurrentLayout.displayHeight;
    } else {
       CRT1XOffs = info->CRT1XOffs;
       CRT1YOffs = info->CRT1YOffs;
       CRT2XOffs = info->CRT2XOffs;
       CRT2YOffs = info->CRT2YOffs;
       MBXNR1XMAX = info->MBXNR1XMAX;
       MBXNR1YMAX = info->MBXNR1YMAX;