static Bool
ms_pci_probe(DriverPtr driver,
int entity_num, struct pci_device *dev, intptr_t match_data)
{
ScrnInfoPtr scrn = NULL;
scrn = xf86ConfigPciEntity(scrn, 0, entity_num, NULL,
NULL, NULL, NULL, NULL, NULL);
if (scrn) {
const char *devpath;
GDevPtr devSection = xf86GetDevFromEntity(scrn->entityList[0],
scrn->entityInstanceList[0]);
devpath = xf86FindOptionValue(devSection->options, "kmsdev");
if (probe_hw_pci(devpath, dev)) {
ms_setup_scrn_hooks(scrn);
xf86DrvMsg(scrn->scrnIndex, X_CONFIG,
"claimed PCI slot %d@%d:%d:%d\n",
dev->bus, dev->domain, dev->dev, dev->func);
xf86DrvMsg(scrn->scrnIndex, X_INFO,
"using %s\n", devpath ? devpath : "default device");
}
else
scrn = NULL;
}
return scrn != NULL;
}
static Bool
ms_pci_probe(DriverPtr driver,
int entity_num, struct pci_device *dev, intptr_t match_data)
{
ScrnInfoPtr scrn = NULL;
scrn = xf86ConfigPciEntity(scrn, 0, entity_num, NULL,
NULL, NULL, NULL, NULL, NULL);
if (scrn) {
const char *devpath;
GDevPtr devSection = xf86GetDevFromEntity(scrn->entityList[0],
scrn->entityInstanceList[0]);
devpath = xf86FindOptionValue(devSection->options, "kmsdev");
if (probe_hw_pci(devpath, dev)) {
scrn->driverVersion = 1;
scrn->driverName = "modesetting";
scrn->name = "modeset";
scrn->Probe = NULL;
scrn->PreInit = PreInit;
scrn->ScreenInit = ScreenInit;
scrn->SwitchMode = SwitchMode;
scrn->AdjustFrame = AdjustFrame;
scrn->EnterVT = EnterVT;
scrn->LeaveVT = LeaveVT;
scrn->FreeScreen = FreeScreen;
scrn->ValidMode = ValidMode;
xf86DrvMsg(scrn->scrnIndex, X_CONFIG,
"claimed PCI slot %d@%d:%d:%d\n",
dev->bus, dev->domain, dev->dev, dev->func);
xf86DrvMsg(scrn->scrnIndex, X_INFO,
"using %s\n", devpath ? devpath : "default device");
} else
scrn = NULL;
}
return scrn != NULL;
}
/**
* @return TRUE if all buses are configured and set up correctly and FALSE
* otherwise.
*/
Bool
xf86BusConfig(void)
{
screenLayoutPtr layout;
int i, j;
/*
* Now call each of the Probe functions. Each successful probe will
* result in an extra entry added to the xf86Screens[] list for each
* instance of the hardware found.
*/
for (i = 0; i < xf86NumDrivers; i++) {
xf86CallDriverProbe(xf86DriverList[i], FALSE);
}
/* If nothing was detected, return now */
if (xf86NumScreens == 0) {
xf86Msg(X_ERROR, "No devices detected.\n");
return FALSE;
}
xf86VGAarbiterInit();
/*
* Match up the screens found by the probes against those specified
* in the config file. Remove the ones that won't be used. Sort
* them in the order specified.
*
* What is the best way to do this?
*
* For now, go through the screens allocated by the probes, and
* look for screen config entry which refers to the same device
* section as picked out by the probe.
*
*/
for (i = 0; i < xf86NumScreens; i++) {
for (layout = xf86ConfigLayout.screens; layout->screen != NULL;
layout++) {
Bool found = FALSE;
for (j = 0; j < xf86Screens[i]->numEntities; j++) {
GDevPtr dev =
xf86GetDevFromEntity(xf86Screens[i]->entityList[j],
xf86Screens[i]->entityInstanceList[j]);
if (dev == layout->screen->device) {
/* A match has been found */
xf86Screens[i]->confScreen = layout->screen;
found = TRUE;
break;
}
}
if (found)
break;
}
if (layout->screen == NULL) {
/* No match found */
xf86Msg(X_ERROR,
"Screen %d deleted because of no matching config section.\n",
i);
xf86DeleteScreen(xf86Screens[i--]);
}
}
/* bind GPU conf screen to protocol screen 0 */
for (i = 0; i < xf86NumGPUScreens; i++)
xf86GPUScreens[i]->confScreen = xf86Screens[0]->confScreen;
/* If no screens left, return now. */
if (xf86NumScreens == 0) {
xf86Msg(X_ERROR,
"Device(s) detected, but none match those in the config file.\n");
return FALSE;
}
return TRUE;
}
Bool
xf86SetDepthBpp(ScrnInfoPtr scrp, int depth, int dummy, int fbbpp,
int depth24flags)
{
int i;
DispPtr disp;
Pix24Flags pix24 = xf86Info.pixmap24;
Bool nomatch = FALSE;
scrp->bitsPerPixel = -1;
scrp->depth = -1;
scrp->pixmap24 = Pix24DontCare;
scrp->bitsPerPixelFrom = X_DEFAULT;
scrp->depthFrom = X_DEFAULT;
if (xf86FbBpp > 0) {
scrp->bitsPerPixel = xf86FbBpp;
scrp->bitsPerPixelFrom = X_CMDLINE;
}
if (xf86Depth > 0) {
scrp->depth = xf86Depth;
scrp->depthFrom = X_CMDLINE;
}
if (xf86FbBpp < 0 && xf86Depth < 0) {
if (scrp->confScreen->defaultfbbpp > 0) {
scrp->bitsPerPixel = scrp->confScreen->defaultfbbpp;
scrp->bitsPerPixelFrom = X_CONFIG;
}
if (scrp->confScreen->defaultdepth > 0) {
scrp->depth = scrp->confScreen->defaultdepth;
scrp->depthFrom = X_CONFIG;
}
if (scrp->confScreen->defaultfbbpp <= 0 &&
scrp->confScreen->defaultdepth <= 0) {
/*
* Check for DefaultDepth and DefaultFbBpp options in the
* Device sections.
*/
int i;
GDevPtr device;
Bool found = FALSE;
for (i = 0; i < scrp->numEntities; i++) {
device = xf86GetDevFromEntity(scrp->entityList[i],
scrp->entityInstanceList[i]);
if (device && device->options) {
if (xf86FindOption(device->options, "DefaultDepth")) {
scrp->depth = xf86SetIntOption(device->options,
"DefaultDepth", -1);
scrp->depthFrom = X_CONFIG;
found = TRUE;
}
if (xf86FindOption(device->options, "DefaultFbBpp")) {
scrp->bitsPerPixel = xf86SetIntOption(device->options,
"DefaultFbBpp",
-1);
scrp->bitsPerPixelFrom = X_CONFIG;
found = TRUE;
}
}
if (found)
break;
}
}
}
/* If none of these is set, pick a default */
if (scrp->bitsPerPixel < 0 && scrp->depth < 0) {
if (fbbpp > 0 || depth > 0) {
if (fbbpp > 0)
scrp->bitsPerPixel = fbbpp;
if (depth > 0)
scrp->depth = depth;
} else {
scrp->depth = GLOBAL_DEFAULT_DEPTH;
}
}
/* If any are not given, determine a default for the others */
if (scrp->bitsPerPixel < 0) {
/* The depth must be set */
if (scrp->depth > -1) {
if (scrp->depth == 1)
scrp->bitsPerPixel = 1;
else if (scrp->depth <= 4)
scrp->bitsPerPixel = 4;
else if (scrp->depth <= 8)
scrp->bitsPerPixel = 8;
else if (scrp->depth <= 16)
scrp->bitsPerPixel = 16;
else if (scrp->depth <= 24) {
/*
* Figure out if a choice is possible based on the depth24
* and pix24 flags.
*/
/* Check pix24 first */
if (pix24 != Pix24DontCare) {
if (pix24 == Pix24Use32) {
if (DO_PIX32(depth24flags)) {
if (CHOOSE24FOR32(depth24flags))
scrp->bitsPerPixel = 24;
else
scrp->bitsPerPixel = 32;
} else {
nomatch = TRUE;
}
} else if (pix24 == Pix24Use24) {
if (DO_PIX24(depth24flags)) {
if (CHOOSE32FOR24(depth24flags))
scrp->bitsPerPixel = 32;
else
scrp->bitsPerPixel = 24;
} else {
nomatch = TRUE;
}
}
} else {
if (DO_PIX32(depth24flags)) {
if (CHOOSE24FOR32(depth24flags))
scrp->bitsPerPixel = 24;
else
scrp->bitsPerPixel = 32;
} else if (DO_PIX24(depth24flags)) {
if (CHOOSE32FOR24(depth24flags))
scrp->bitsPerPixel = 32;
else
scrp->bitsPerPixel = 24;
}
}
} else if (scrp->depth <= 32)
scrp->bitsPerPixel = 32;
else {
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
"Specified depth (%d) is greater than 32\n",
scrp->depth);
return FALSE;
}
} else {
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
"xf86SetDepthBpp: internal error: depth and fbbpp"
" are both not set\n");
return FALSE;
}
if (scrp->bitsPerPixel < 0) {
if (nomatch)
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
"Driver can't support depth 24 pixmap format (%d)\n",
PIX24TOBPP(pix24));
else if ((depth24flags & (Support24bppFb | Support32bppFb)) ==
NoDepth24Support)
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
"Driver can't support depth 24\n");
else
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
"Can't find fbbpp for depth 24\n");
return FALSE;
}
scrp->bitsPerPixelFrom = X_PROBED;
}
if (scrp->depth <= 0) {
/* bitsPerPixel is already set */
switch (scrp->bitsPerPixel) {
case 32:
scrp->depth = 24;
break;
default:
/* 1, 4, 8, 16 and 24 */
scrp->depth = scrp->bitsPerPixel;
break;
}
scrp->depthFrom = X_PROBED;
}
/* Sanity checks */
if (scrp->depth < 1 || scrp->depth > 32) {
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
"Specified depth (%d) is not in the range 1-32\n",
scrp->depth);
return FALSE;
}
switch (scrp->bitsPerPixel) {
case 1:
case 4:
case 8:
case 16:
case 24:
case 32:
break;
default:
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
"Specified fbbpp (%d) is not a permitted value\n",
scrp->bitsPerPixel);
return FALSE;
}
if (scrp->depth > scrp->bitsPerPixel) {
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
"Specified depth (%d) is greater than the fbbpp (%d)\n",
scrp->depth, scrp->bitsPerPixel);
return FALSE;
}
/* set scrp->pixmap24 if the driver isn't flexible */
if (scrp->bitsPerPixel == 24 && !DO_PIX32FOR24(depth24flags)) {
scrp->pixmap24 = Pix24Use24;
}
if (scrp->bitsPerPixel == 32 && !DO_PIX24FOR32(depth24flags)) {
scrp->pixmap24 = Pix24Use32;
}
/*
* Find the Display subsection matching the depth/fbbpp and initialise
* scrp->display with it.
*/
for (i = 0, disp = scrp->confScreen->displays;
i < scrp->confScreen->numdisplays; i++, disp++) {
if ((disp->depth == scrp->depth && disp->fbbpp == scrp->bitsPerPixel)
|| (disp->depth == scrp->depth && disp->fbbpp <= 0)
|| (disp->fbbpp == scrp->bitsPerPixel && disp->depth <= 0)) {
scrp->display = disp;
break;
}
}
/*
* If an exact match can't be found, see if there is one with no
* depth or fbbpp specified.
*/
if (i == scrp->confScreen->numdisplays) {
for (i = 0, disp = scrp->confScreen->displays;
i < scrp->confScreen->numdisplays; i++, disp++) {
if (disp->depth <= 0 && disp->fbbpp <= 0) {
scrp->display = disp;
break;
}
}
}
/*
* If all else fails, create a default one.
*/
if (i == scrp->confScreen->numdisplays) {
scrp->confScreen->numdisplays++;
scrp->confScreen->displays =
xnfrealloc(scrp->confScreen->displays,
scrp->confScreen->numdisplays * sizeof(DispRec));
xf86DrvMsg(scrp->scrnIndex, X_INFO,
"Creating default Display subsection in Screen section\n"
"\t\"%s\" for depth/fbbpp %d/%d\n",
scrp->confScreen->id, scrp->depth, scrp->bitsPerPixel);
memset(&scrp->confScreen->displays[i], 0, sizeof(DispRec));
scrp->confScreen->displays[i].blackColour.red = -1;
scrp->confScreen->displays[i].blackColour.green = -1;
scrp->confScreen->displays[i].blackColour.blue = -1;
scrp->confScreen->displays[i].whiteColour.red = -1;
scrp->confScreen->displays[i].whiteColour.green = -1;
scrp->confScreen->displays[i].whiteColour.blue = -1;
scrp->confScreen->displays[i].defaultVisual = -1;
scrp->confScreen->displays[i].modes = xnfalloc(sizeof(char *));
scrp->confScreen->displays[i].modes[0] = NULL;
scrp->confScreen->displays[i].depth = depth;
scrp->confScreen->displays[i].fbbpp = fbbpp;
scrp->display = &scrp->confScreen->displays[i];
}
/*
* Setup defaults for the display-wide attributes the framebuffer will
* need. These defaults should eventually be set globally, and not
* dependent on the screens.
*/
scrp->imageByteOrder = IMAGE_BYTE_ORDER;
scrp->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
if (scrp->depth < 8) {
/* Planar modes need these settings */
scrp->bitmapScanlineUnit = 8;
scrp->bitmapBitOrder = MSBFirst;
} else {
scrp->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
scrp->bitmapBitOrder = BITMAP_BIT_ORDER;
}
/*
* If an unusual depth is required, add it to scrp->formats. The formats
* for the common depths are handled globally in InitOutput
*/
switch (scrp->depth) {
case 1:
case 4:
case 8:
case 15:
case 16:
case 24:
/* Common depths. Nothing to do for them */
break;
default:
if (!xf86AddPixFormat(scrp, scrp->depth, 0, 0)) {
xf86DrvMsg(scrp->scrnIndex, X_ERROR,
"Can't add pixmap format for depth %d\n", scrp->depth);
return FALSE;
}
}
/* Initialise the framebuffer format for this screen */
scrp->fbFormat.depth = scrp->depth;
scrp->fbFormat.bitsPerPixel = scrp->bitsPerPixel;
scrp->fbFormat.scanlinePad = BITMAP_SCANLINE_PAD;
return TRUE;
}