void
intel_detect_chipset(ScrnInfoPtr scrn,
EntityInfoPtr ent,
struct pci_device *pci)
{
MessageType from = X_PROBED;
const char *name = NULL;
int i;
if (ent->device->chipID >= 0) {
xf86DrvMsg(scrn->scrnIndex, from = X_CONFIG,
"ChipID override: 0x%04X\n",
ent->device->chipID);
DEVICE_ID(pci) = ent->device->chipID;
}
for (i = 0; intel_chipsets[i].name != NULL; i++) {
if (DEVICE_ID(pci) == intel_chipsets[i].token) {
name = intel_chipsets[i].name;
break;
}
}
if (name == NULL) {
xf86DrvMsg(scrn->scrnIndex, X_WARNING, "unknown chipset\n");
name = "unknown";
} else {
xf86DrvMsg(scrn->scrnIndex, from,
"Integrated Graphics Chipset: Intel(R) %s\n",
name);
}
scrn->chipset = name;
}
/**
* Create IVHDR entry for aliased range
*
*
* @param[in] StartRange Address of start range
* @param[in] EndRange Address of end range
* @param[in] Alias Address of alias requestor ID for range
* @param[in] DataSetting Data setting
* @param[in] Ivhd Pointer to IVHD entry
* @param[in] StdHeader Standard configuration header
*
*/
VOID
GnbIvhdAddDeviceAliasRangeEntry (
IN PCI_ADDR StartRange,
IN PCI_ADDR EndRange,
IN PCI_ADDR Alias,
IN UINT8 DataSetting,
IN IVRS_IVHD_ENTRY *Ivhd,
IN AMD_CONFIG_PARAMS *StdHeader
)
{
IVHD_ALIAS_ENTRY *RangeEntry;
IVHD_GENERIC_ENTRY *Entry;
UINT16 Offset;
Offset = (Ivhd->Length + 0x7) & (~ 0x7);
RangeEntry = (IVHD_ALIAS_ENTRY *) ((UINT8 *) Ivhd + Offset);
RangeEntry->Type = IvhdEntryAliasStartRange;
RangeEntry->DeviceId = DEVICE_ID (StartRange);
RangeEntry->AliasDeviceId = DEVICE_ID (Alias);
RangeEntry->DataSetting = DataSetting;
Ivhd->Length = sizeof (IVHD_ALIAS_ENTRY) + Offset;
Entry = (IVHD_GENERIC_ENTRY *) ((UINT8 *) Ivhd + Ivhd->Length);
Entry->Type = IvhdEntryEndRange;
Entry->DeviceId = DEVICE_ID (EndRange);
Ivhd->Length += sizeof (IVHD_GENERIC_ENTRY);
}
int flash_erase(flash_info_t * info, int s_first, int s_last)
{
int i = s_first;
volatile CFG_FLASH_WORD_SIZE *ROM =
(volatile CFG_FLASH_WORD_SIZE *) (info->start[0]);
int timeout;
printf("First %#x last %#x\n", s_first, s_last);
for (i = s_first; i <= s_last; i++) {
CFG_FLASH_WORD_SIZE state, prev_state, rd_data;
volatile CFG_FLASH_WORD_SIZE *addr_ptr =
(volatile CFG_FLASH_WORD_SIZE *) (info->start[i]);
// Program data [byte] - 6 step sequence
ROM[CFG_FLASH_ADDR0] = FLASH_Setup_Code1;
ROM[CFG_FLASH_ADDR1] = FLASH_Setup_Code2;
ROM[CFG_FLASH_ADDR0] = FLASH_Setup_Erase;
ROM[CFG_FLASH_ADDR0] = FLASH_Setup_Code1;
ROM[CFG_FLASH_ADDR1] = FLASH_Setup_Code2;
*addr_ptr = FLASH_Block_Erase;
if (DEVICE_ID(flash_info->flash_id) == AMD_SPANSION) {
// Wait for erase completion.
timeout = 10000000;
while (timeout) {
state = *addr_ptr;
if (FLASHWORD(0xffff) == state) {
break;
}
timeout--;
}
} else {
// Wait for completion (bit 6 stops toggling)
timeout = 5000000;
prev_state = *addr_ptr & FLASH_Busy;
while (timeout) {
rd_data = *addr_ptr;
state = rd_data & FLASH_Busy;
if ((prev_state == state) && (rd_data == FLASHWORD(0xffff))) {
break;
}
timeout--;
prev_state = state;
}
}
if (!timeout){
printf("Error erasing flash...\n");
return -1;
}
}
return 0;
}
/**
* Create IVHDR entry for device range
*
*
* @param[in] StartRange Address of start range
* @param[in] EndRange Address of end range
* @param[in] DataSetting Data setting
* @param[in] Ivhd Pointer to IVHD entry
* @param[in] StdHeader Standard configuration header
*
*/
VOID
GnbIvhdAddDeviceRangeEntry (
IN PCI_ADDR StartRange,
IN PCI_ADDR EndRange,
IN UINT8 DataSetting,
IN IVRS_IVHD_ENTRY *Ivhd,
IN AMD_CONFIG_PARAMS *StdHeader
)
{
IVHD_GENERIC_ENTRY *Entry;
Entry = (IVHD_GENERIC_ENTRY *) ((UINT8 *) Ivhd + Ivhd->Length);
Entry->Type = IvhdEntryStartRange;
Entry->DeviceId = DEVICE_ID (StartRange);
Entry->DataSetting = DataSetting;
Ivhd->Length += sizeof (IVHD_GENERIC_ENTRY);
Entry = (IVHD_GENERIC_ENTRY *) ((UINT8 *) Ivhd + Ivhd->Length);
Entry->Type = IvhdEntryEndRange;
Entry->DeviceId = DEVICE_ID (EndRange);
Ivhd->Length += sizeof (IVHD_GENERIC_ENTRY);
}
static int write_word(flash_info_t * info, ulong dest, ulong data)
{
volatile CFG_FLASH_WORD_SIZE *ROM =
(CFG_FLASH_WORD_SIZE *) (info->start[0]);
volatile CFG_FLASH_WORD_SIZE *dest2 = (CFG_FLASH_WORD_SIZE *) dest;
CFG_FLASH_WORD_SIZE *data2 = (CFG_FLASH_WORD_SIZE *) & data;
int i;
/* Check if Flash is (sufficiently) erased */
if ((*((vu_long *) dest) & data) != data) {
return (2);
}
for (i = 0; i < 4 / sizeof(CFG_FLASH_WORD_SIZE); i++) {
CFG_FLASH_WORD_SIZE state, prev_state;
int timeout;
ROM[CFG_FLASH_ADDR0] = FLASH_Setup_Code1;
ROM[CFG_FLASH_ADDR1] = FLASH_Setup_Code2;
ROM[CFG_FLASH_ADDR0] = FLASH_Program;
dest2[i] = data2[i];
if (DEVICE_ID(flash_info->flash_id) == AMD_SPANSION) {
timeout = 10000000;
while (timeout) {
if (dest2[i] == data2[i]) {
break;
}
timeout--;
}
} else {
// Wait for completion (bit 6 stops toggling)
timeout = 5000000;
prev_state = dest2[i] & FLASH_Busy;
while (timeout) {
state = dest2[i] & FLASH_Busy;
if (prev_state == state) {
break;
}
timeout--;
prev_state = state;
}
}
if (!timeout)
return -1;
}
return (0);
}
static Bool
VMwarePreinitStub(ScrnInfoPtr pScrn, int flags)
{
#if XSERVER_LIBPCIACCESS
struct pci_device *pciInfo;
#else
pciVideoPtr pciInfo;
#endif /* XSERVER_LIBPCIACCESS */
EntityInfoPtr pEnt;
pScrn->PreInit = pScrn->driverPrivate;
#ifdef BUILD_VMWGFX
pScrn->driverPrivate = NULL;
/*
* Try vmwgfx path.
*/
if ((*pScrn->PreInit)(pScrn, flags))
return TRUE;
/*
* Can't run legacy hosted
*/
if (vmwgfx_hosted_detect())
return FALSE;
#else
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"Driver was compiled without KMS- and 3D support.\n");
#endif /* defined(BUILD_VMWGFX) */
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"Disabling 3D support.\n");
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"Disabling Render Acceleration.\n");
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"Disabling RandR12+ support.\n");
pScrn->driverPrivate = NULL;
vmwlegacy_hookup(pScrn);
pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
pciInfo = xf86GetPciInfoForEntity(pEnt->index);
if (pciInfo == NULL)
return FALSE;
pScrn->chipset = (char*)xf86TokenToString(VMWAREChipsets,
DEVICE_ID(pciInfo));
return (*pScrn->PreInit)(pScrn, flags);
};
void flash_print_info(flash_info_t * info)
{
printf("Name: ");
switch (DEVICE_ID(info->flash_id))
{
case 0x2780: printf ("SST-39VF400"); break;
case 0x2782: printf ("SST-39VF160"); break;
case 0x236b: printf ("SST-39VF6401"); break;
case 0x236a: printf ("SST-39VF6402"); break;
case 0x236d: printf ("SST-39VF6402"); break;
case 0x227e: printf ("AMD-SPANSION"); break;
default: printf ("Unknown Vendor "); break;
}
printf(" Flash id: 0x%X, Size: %lu bytes.\n", info->flash_id, info->size);
}
/*
* intel_pci_probe --
*
* Look through the PCI bus to find cards that are intel boards.
* Setup the dispatch table for the rest of the driver functions.
*
*/
static Bool intel_pci_probe(DriverPtr driver,
int entity_num,
struct pci_device *device,
intptr_t match_data)
{
ScrnInfoPtr scrn;
PciChipsets intel_pci_chipsets[ARRAY_SIZE(intel_chipsets)];
int i;
chipset_info = (void *)match_data;
for (i = 0; i < ARRAY_SIZE(intel_chipsets); i++) {
intel_pci_chipsets[i].numChipset = intel_chipsets[i].token;
intel_pci_chipsets[i].PCIid = intel_chipsets[i].token;
intel_pci_chipsets[i].dummy = NULL;
}
scrn = xf86ConfigPciEntity(NULL, 0, entity_num, intel_pci_chipsets,
NULL, NULL, NULL, NULL, NULL);
if (scrn != NULL) {
scrn->driverVersion = INTEL_VERSION;
scrn->driverName = INTEL_DRIVER_NAME;
scrn->name = INTEL_NAME;
scrn->Probe = NULL;
#if KMS_ONLY
intel_init_scrn(scrn);
#else
switch (DEVICE_ID(device)) {
case PCI_CHIP_I810:
case PCI_CHIP_I810_DC100:
case PCI_CHIP_I810_E:
case PCI_CHIP_I815:
lg_i810_init(scrn);
break;
default:
intel_init_scrn(scrn);
break;
}
#endif
}
return scrn != NULL;
}
/**
* Create IVHDR entry for special device
*
*
* @param[in] SpecialDevice Special device Type
* @param[in] Device Address of requestor ID for special device
* @param[in] Id Apic ID/ Hpet ID
* @param[in] DataSetting Data setting
* @param[in] Ivhd Pointer to IVHD entry
* @param[in] StdHeader Standard configuration header
*
*/
VOID
GnbIvhdAddSpecialDeviceEntry (
IN IVHD_SPECIAL_DEVICE SpecialDevice,
IN PCI_ADDR Device,
IN UINT8 Id,
IN UINT8 DataSetting,
IN IVRS_IVHD_ENTRY *Ivhd,
IN AMD_CONFIG_PARAMS *StdHeader
)
{
IVHD_SPECIAL_ENTRY *SpecialEntry;
UINT16 Offset;
Offset = (Ivhd->Length + 0x7) & (~ 0x7);
SpecialEntry = (IVHD_SPECIAL_ENTRY *) ((UINT8 *) Ivhd + Offset);
SpecialEntry->Type = IvhdEntrySpecialDevice;
SpecialEntry->AliasDeviceId = DEVICE_ID (Device);
SpecialEntry->Variety = (UINT8) SpecialDevice;
SpecialEntry->Handle = Id;
SpecialEntry->DataSetting = DataSetting;
Ivhd->Length = sizeof (IVHD_SPECIAL_ENTRY) + Offset;
}
void intel_detect_chipset(ScrnInfoPtr scrn,
struct pci_device *pci,
struct intel_chipset *chipset)
{
int i;
chipset->info = chipset_info;
for (i = 0; intel_chipsets[i].name != NULL; i++) {
if (DEVICE_ID(pci) == intel_chipsets[i].token) {
chipset->name = intel_chipsets[i].name;
break;
}
}
if (intel_chipsets[i].name == NULL) {
chipset->name = "unknown chipset";
}
xf86DrvMsg(scrn->scrnIndex, X_INFO,
"Integrated Graphics Chipset: Intel(R) %s\n", chipset->name);
}
/*
* intel_pci_probe --
*
* Look through the PCI bus to find cards that are intel boards.
* Setup the dispatch table for the rest of the driver functions.
*
*/
static Bool intel_pci_probe(DriverPtr driver,
int entity_num,
struct pci_device *device,
intptr_t match_data)
{
if (!has_kernel_mode_setting(device)) {
#if KMS_ONLY
return FALSE;
#else
switch (DEVICE_ID(device)) {
case PCI_CHIP_I810:
case PCI_CHIP_I810_DC100:
case PCI_CHIP_I810_E:
case PCI_CHIP_I815:
break;
default:
return FALSE;
}
#endif
}
return intel_scrn_create(driver, entity_num, match_data, 0);
}
unsigned long flash_init(void)
{
ulong sector_size;
ar9100_flash_geom_t *geom;
ushort venid, devid;
int i;
printf("ar9100 flash_init\n");
flash_info->flash_id = read_id();
venid = VENDOR_ID(flash_info->flash_id);
devid = DEVICE_ID(flash_info->flash_id);
for (i = 0; flash_geom_tbl[i].name != NULL; i++) {
if (venid == flash_geom_tbl[i].vendor_id &&
devid == flash_geom_tbl[i].device_id) {
break;
}
}
geom = &flash_geom_tbl[i];
if (geom->name == NULL) {
printf("Unknown flash device\n");
return -1;
}
flash_info->size = geom->size; /* bytes */
flash_info->sector_count = geom->nsectors;
sector_size = (geom->sector_size * 16); /* One Erase block size */
for (i = 0; i < flash_info->sector_count; i++) {
flash_info->start[i] = CFG_FLASH_BASE + (i * sector_size);
flash_info->protect[i] = 0;
}
flash_print_info(flash_info);
return (flash_info->size);
}
static Bool
VMwarePciProbe (DriverPtr drv,
int entity_num,
struct pci_device *device,
intptr_t match_data)
{
ScrnInfoPtr scrn = NULL;
scrn = xf86ConfigPciEntity(scrn, 0, entity_num, VMWAREPciChipsets,
NULL, NULL, NULL, NULL, NULL);
if (scrn != NULL) {
scrn->driverVersion = VMWARE_DRIVER_VERSION;
scrn->driverName = VMWARE_DRIVER_NAME;
scrn->name = VMWARE_NAME;
scrn->Probe = NULL;
}
switch (DEVICE_ID(device)) {
case PCI_DEVICE_ID_VMWARE_SVGA2:
case PCI_DEVICE_ID_VMWARE_SVGA:
xf86MsgVerb(X_INFO, 4, "VMwarePciProbe: Valid device\n");
#ifdef BUILD_VMWGFX
vmwgfx_hookup(scrn);
#else
vmwlegacy_hookup(scrn);
#endif /* defined(BUILD_VMWGFX) */
scrn->driverPrivate = scrn->PreInit;
scrn->PreInit = VMwarePreinitStub;
break;
default:
xf86MsgVerb(X_INFO, 4, "VMwarePciProbe: Unknown device\n");
}
return scrn != NULL;
}
/*
* intel_pci_probe --
*
* Look through the PCI bus to find cards that are intel boards.
* Setup the dispatch table for the rest of the driver functions.
*
*/
static Bool intel_pci_probe(DriverPtr driver,
int entity_num,
struct pci_device *device,
intptr_t match_data)
{
ScrnInfoPtr scrn;
PciChipsets intel_pci_chipsets[NUM_CHIPSETS];
unsigned i;
if (!has_kernel_mode_setting(device)) {
#if KMS_ONLY
return FALSE;
#else
switch (DEVICE_ID(device)) {
case PCI_CHIP_I810:
case PCI_CHIP_I810_DC100:
case PCI_CHIP_I810_E:
case PCI_CHIP_I815:
break;
default:
return FALSE;
}
#endif
}
for (i = 0; i < NUM_CHIPSETS; i++) {
intel_pci_chipsets[i].numChipset = intel_chipsets[i].token;
intel_pci_chipsets[i].PCIid = intel_chipsets[i].token;
#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(1,6,99,0,0)
intel_pci_chipsets[i].resList = RES_SHARED_VGA;
#else
intel_pci_chipsets[i].dummy = NULL;
#endif
}
scrn = xf86ConfigPciEntity(NULL, 0, entity_num, intel_pci_chipsets,
NULL, NULL, NULL, NULL, NULL);
if (scrn == NULL)
return FALSE;
scrn->driverVersion = INTEL_VERSION;
scrn->driverName = INTEL_DRIVER_NAME;
scrn->name = INTEL_NAME;
scrn->driverPrivate = (void *)(match_data | 1);
scrn->Probe = NULL;
#if !KMS_ONLY
switch (DEVICE_ID(device)) {
case PCI_CHIP_I810:
case PCI_CHIP_I810_DC100:
case PCI_CHIP_I810_E:
case PCI_CHIP_I815:
return lg_i810_init(scrn);
}
#endif
#if !UMS_ONLY
switch (get_accel_method()) {
#if USE_SNA
case SNA: return sna_init_scrn(scrn, entity_num);
#endif
#if USE_UXA
case UXA: return intel_init_scrn(scrn);
#endif
default: break;
}
#endif
return FALSE;
}
