static DBusHandlerResult message_handler(DBusConnection *connection, DBusMessage *message, void *data) { DBusError error; DBusMessage *reply; struct connection_info *info = data; /* ret is the overall D-Bus handler result, whereas err is the internal * X error from our individual functions. */ int ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; int err; DebugF("[config/dbus] received a message for %s\n", dbus_message_get_interface(message)); dbus_error_init(&error); reply = dbus_message_new_method_return(message); if (!reply) { ErrorF("[config/dbus] failed to create reply\n"); ret = DBUS_HANDLER_RESULT_NEED_MEMORY; goto err_start; } if (strcmp(dbus_message_get_member(message), "add") == 0) err = add_device(message, reply, &error); else if (strcmp(dbus_message_get_member(message), "remove") == 0) err = remove_device(message, reply, &error); else if (strcmp(dbus_message_get_member(message), "listDevices") == 0) err = list_devices(message, reply, &error); else if (strcmp(dbus_message_get_member(message), "version") == 0) err = get_version(message, reply, &error); else goto err_reply; /* Failure to allocate is a special case. */ if (err == BadAlloc) { ret = DBUS_HANDLER_RESULT_NEED_MEMORY; goto err_reply; } /* While failure here is always an OOM, we don't return that, * since that would result in devices being double-added/removed. */ if (dbus_connection_send(info->connection, reply, NULL)) dbus_connection_flush(info->connection); else ErrorF("[config/dbus] failed to send reply\n"); ret = DBUS_HANDLER_RESULT_HANDLED; err_reply: dbus_message_unref(reply); err_start: dbus_error_free(&error); return ret; }
static void unmapVidMem(int ScreenNum, pointer Base, unsigned long Size) { memType alignOff = (memType)Base - ((memType)Base & ~(getpagesize() - 1)); DebugF("alignment offset: %lx\n",alignOff); munmap((caddr_t)((memType)Base - alignOff), (Size + alignOff)); }
static int update_pixel_doubling(struct omap_screen_info *omaps, int enable) { DebugF("omapUpdatePixelDoubling: pixel doubling is %d\n", enable); omaps->pixel_doubled = enable; omap_screen_update_all(omaps, TRUE); return Success; }
static void unmapVidMem(int ScreenNum, void *Base, unsigned long Size) { uintptr_t alignOff = (uintptr_t) Base - ((uintptr_t) Base & ~(getpagesize() - 1)); DebugF("alignment offset: %lx\n", (unsigned long) alignOff); munmap((void *) ((uintptr_t) Base - alignOff), (Size + alignOff)); }
static int remove_device(DBusMessage *message, DBusMessage *reply, DBusError *error) { int deviceid, ret, err; DeviceIntPtr dev; DBusMessageIter iter, reply_iter; dbus_message_iter_init_append(reply, &reply_iter); if (!dbus_message_iter_init(message, &iter)) { ErrorF("[config/dbus] failed to init iterator\n"); MALFORMED_MESSAGE(); } if (!dbus_message_get_args(message, error, DBUS_TYPE_UINT32, &deviceid, DBUS_TYPE_INVALID)) { MALFORMED_MESSAGE_ERROR(); } dev = LookupDeviceIntRec(deviceid); if (!dev) { DebugF("[config/dbus] bogus device id %d given\n", deviceid); ret = BadMatch; goto unwind; } DebugF("[config/dbus] removing device %s (id %d)\n", dev->name, deviceid); /* Call PIE here so we don't try to dereference a device that's * already been removed. */ OsBlockSignals(); ProcessInputEvents(); DeleteInputDeviceRequest(dev); OsReleaseSignals(); ret = Success; unwind: err = (ret == Success) ? ret : -ret; dbus_message_iter_append_basic(&reply_iter, DBUS_TYPE_INT32, &err); return ret; }
static void lnxCloseAPM(void) { int fd; DebugF("APM: Closing device\n"); if (APMihPtr) { fd = xf86RemoveGeneralHandler(APMihPtr); close(fd); APMihPtr = NULL; } }
static void remove_device(DeviceIntPtr dev) { DebugF("[config/hal] removing device %s\n", dev->name); /* Call PIE here so we don't try to dereference a device that's * already been removed. */ OsBlockSignals(); ProcessInputEvents(); DeleteInputDeviceRequest(dev); OsReleaseSignals(); }
unsigned XkbDDXLoadKeymapByNames(DeviceIntPtr keybd, XkbComponentNamesPtr names, unsigned want, unsigned need, XkbDescPtr *xkbRtrn, char *nameRtrn, int nameRtrnLen) { XkbDescPtr xkb; FILE *file; char fileName[PATH_MAX]; unsigned missing; *xkbRtrn = NULL; if ((keybd == NULL) || (keybd->key == NULL) || (keybd->key->xkbInfo == NULL)) xkb = NULL; else xkb = keybd->key->xkbInfo->desc; if ((names->keycodes == NULL) && (names->types == NULL) && (names->compat == NULL) && (names->symbols == NULL) && (names->geometry == NULL)) { LogMessage(X_ERROR, "XKB: No components provided for device %s\n", keybd->name ? keybd->name : "(unnamed keyboard)"); return 0; } else if (!XkbDDXCompileKeymapByNames(xkb, names, want, need, nameRtrn, nameRtrnLen)) { LogMessage(X_ERROR, "XKB: Couldn't compile keymap\n"); return 0; } file = XkbDDXOpenConfigFile(nameRtrn, fileName, PATH_MAX); if (file == NULL) { LogMessage(X_ERROR, "Couldn't open compiled keymap file %s\n", fileName); return 0; } missing = XkmReadFile(file, need, want, xkbRtrn); if (*xkbRtrn == NULL) { LogMessage(X_ERROR, "Error loading keymap %s\n", fileName); fclose(file); (void) unlink(fileName); return 0; } else { DebugF("Loaded XKB keymap %s, defined=0x%x\n", fileName, (*xkbRtrn)->defined); } fclose(file); (void) unlink(fileName); return (need | want) & (~missing); }
void _DtTermPrimLogFileCleanup ( void ) { logInfo *logInfoTmp; DebugF('s', 10, fprintf(stderr, ">>_DtTermPrimLogFileCleanup() starting\n")); /* flush all the log files... */ _DtTermProcessLock(); for (logInfoTmp = logInfoHead->next; logInfoTmp; logInfoTmp = logInfoTmp->next) { DebugF('s', 10, fprintf(stderr, ">>flushing logfile 0x%lx\n", logInfoTmp->logFile)); (void) fflush(logInfoTmp->logFile); } _DtTermProcessUnlock(); DebugF('s', 10, fprintf(stderr, ">>_DtTermPrimLogFileCleanup() finished\n")); }
static void connect_hook(DBusConnection *connection, void *data) { DBusError error; DBusObjectPathVTable vtable = { .message_function = message_handler, }; struct connection_info *info = data; info->connection = connection; dbus_error_init(&error); dbus_bus_request_name(info->connection, info->busname, 0, &error); if (dbus_error_is_set(&error)) { ErrorF("[config/dbus] couldn't take over org.x.config: %s (%s)\n", error.name, error.message); goto err_start; } /* blocks until we get a reply. */ dbus_bus_add_match(info->connection, MATCH_RULE, &error); if (dbus_error_is_set(&error)) { ErrorF("[config/dbus] couldn't add match: %s (%s)\n", error.name, error.message); goto err_name; } if (!dbus_connection_register_object_path(info->connection, info->busobject, &vtable, info)) { ErrorF("[config/dbus] couldn't register object path\n"); goto err_match; } DebugF("[dbus] registered %s, %s\n", info->busname, info->busobject); dbus_error_free(&error); return; err_match: dbus_bus_remove_match(info->connection, MATCH_RULE, &error); err_name: dbus_bus_release_name(info->connection, info->busname, &error); err_start: dbus_error_free(&error); reset_info(info); }
void omap_plane_disable(struct omap_plane_info *plane_info) { struct omapfb_plane_info kplane_info; struct omapfb_mem_info mem_info; if (plane_info->type == OMAP_PLANE_BASE) FatalError("attempting to disable base plane\n"); omap_card_sync(plane_info->omaps->omapc); if (plane_info->fb) munmap(plane_info->fb, plane_info->fb_size); plane_info->fb = NULL; plane_info->fb_size = 0; plane_info->pitch = 0; if (ioctl(plane_info->fd, OMAPFB_QUERY_PLANE, &kplane_info) != 0) { ErrorF("omapPlaneDisable: couldn't get plane info\n"); goto bail; } kplane_info.enabled = 0; if (ioctl(plane_info->fd, OMAPFB_SETUP_PLANE, &kplane_info) != 0) { ErrorF("omapPlaneDisable: couldn't disable plane\n"); goto bail; } if (plane_info->type == OMAP_PLANE_OVERLAY) { /* Deallocate our plane. */ if (ioctl(plane_info->fd, OMAPFB_QUERY_MEM, &mem_info) != 0) { ErrorF("omapPlaneDisable: couldn't get mem info\n"); goto bail; } mem_info.size = 0; if (ioctl(plane_info->fd, OMAPFB_SETUP_MEM, &mem_info) != 0) { ErrorF("omapPlaneDisable: couldn't set mem info\n"); goto bail; } } DebugF("omapPlaneDisable: disabled plane %d\n", plane_info->id); bail: /* Give it a chance to take. */ omap_card_sync(plane_info->omaps->omapc); }
static char * get_prop_string(LibHalContext *hal_ctx, const char *udi, const char *name) { char *prop, *ret; prop = libhal_device_get_property_string(hal_ctx, udi, name, NULL); DebugF(" [config/hal] getting %s on %s returned %s\n", name, udi, prop); if (prop) { ret = xstrdup(prop); libhal_free_string(prop); } else { return NULL; } return ret; }
static void disconnect_hook(void *data) { DBusError error; struct config_hal_info *info = data; if (info->hal_ctx) { dbus_error_init(&error); if (!libhal_ctx_shutdown(info->hal_ctx, &error)) DebugF("[config/hal] couldn't shut down context: %s (%s)\n", error.name, error.message); libhal_ctx_free(info->hal_ctx); dbus_error_free(&error); } info->hal_ctx = NULL; info->system_bus = NULL; }
int xf86FlushInput(int fd) { struct pollfd poll_fd; /* this needs to be big enough to flush an evdev event. */ char c[256]; DebugF("FlushingSerial\n"); if (tcflush(fd, TCIFLUSH) == 0) return 0; poll_fd.fd = fd; poll_fd.events = POLLIN; while (xserver_poll(&poll_fd, 1, 0) > 0) { if (read(fd, &c, sizeof(c)) < 1) return 0; } return 0; }
/** * This is a filter, which only handles the disconnected signal, which * doesn't go to the normal message handling function. This takes * precedence over the message handling function, so have have to be * careful to ignore anything we don't want to deal with here. */ static DBusHandlerResult message_filter(DBusConnection * connection, DBusMessage * message, void *data) { /* If we get disconnected, then take everything down, and attempt to * reconnect immediately (assuming it's just a restart). The * connection isn't valid at this point, so throw it out immediately. */ if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) { DebugF("[dbus-core] disconnected from bus\n"); bus_info.connection = NULL; teardown(); if (bus_info.timer) TimerFree(bus_info.timer); bus_info.timer = TimerSet(NULL, 0, 1, reconnect_timer, NULL); return DBUS_HANDLER_RESULT_HANDLED; } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
static XkbRF_RulePtr XkbRF_AddRule(XkbRF_RulesPtr rules) { if (rules->sz_rules<1) { rules->sz_rules= 16; rules->num_rules= 0; rules->rules= xcalloc(rules->sz_rules, sizeof(XkbRF_RuleRec)); } else if (rules->num_rules>=rules->sz_rules) { rules->sz_rules*= 2; rules->rules= xrealloc(rules->rules, rules->sz_rules * sizeof(XkbRF_RuleRec)); } if (!rules->rules) { rules->sz_rules= rules->num_rules= 0; DebugF("Allocation failure in XkbRF_AddRule\n"); return NULL; } bzero((char *)&rules->rules[rules->num_rules],sizeof(XkbRF_RuleRec)); return &rules->rules[rules->num_rules++]; }
/** * Handle NewOwnerChanged signals to deal with HAL startup at X server runtime. * * NewOwnerChanged is send once when HAL shuts down, and once again when it * comes back up. Message has three arguments, first is the name * (org.freedesktop.Hal), the second one is the old owner, third one is new * owner. */ static DBusHandlerResult ownerchanged_handler(DBusConnection *connection, DBusMessage *message, void *data) { int ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (dbus_message_is_signal(message, "org.freedesktop.DBus", "NameOwnerChanged")) { DBusError error; char *name, *old_owner, *new_owner; dbus_error_init(&error); dbus_message_get_args(message, &error, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &old_owner, DBUS_TYPE_STRING, &new_owner, DBUS_TYPE_INVALID); if (dbus_error_is_set(&error)) { ErrorF("[config/hal] failed to get NameOwnerChanged args: %s (%s)\n", error.name, error.message); } else if (name && strcmp(name, "org.freedesktop.Hal") == 0) { if (!old_owner || !strlen(old_owner)) { DebugF("[config/hal] HAL startup detected.\n"); if (connect_and_register(connection, (struct config_hal_info*)data)) dbus_connection_unregister_object_path(connection, "/org/freedesktop/DBus"); else ErrorF("[config/hal] Failed to connect to HAL bus.\n"); } ret = DBUS_HANDLER_RESULT_HANDLED; } dbus_error_free(&error); } return ret; }
int xf86FlushInput(int fd) { fd_set fds; struct timeval timeout; char c[4]; DebugF("FlushingSerial\n"); if (tcflush(fd, TCIFLUSH) == 0) return 0; timeout.tv_sec = 0; timeout.tv_usec = 0; FD_ZERO(&fds); FD_SET(fd, &fds); while (select(FD_SETSIZE, &fds, NULL, NULL, &timeout) > 0) { if (read(fd, &c, sizeof(c)) < 1) return 0; FD_ZERO(&fds); FD_SET(fd, &fds); } return 0; }
int xf86FlushInput(int fd) { fd_set fds; struct timeval timeout; /* this needs to be big enough to flush an evdev event. */ char c[256]; DebugF("FlushingSerial\n"); if (tcflush(fd, TCIFLUSH) == 0) return 0; timeout.tv_sec = 0; timeout.tv_usec = 0; FD_ZERO(&fds); FD_SET(fd, &fds); while (select(FD_SETSIZE, &fds, NULL, NULL, &timeout) > 0) { if (read(fd, &c, sizeof(c)) < 1) return 0; FD_ZERO(&fds); FD_SET(fd, &fds); } return 0; }
static struct mtrr_wc_region * mtrr_add_wc_region(int screenNum, unsigned long base, unsigned long size, MessageType from) { struct mtrr_wc_region **wcr, *wcreturn, *curwcr; /* * There can be only one.... */ wcreturn = mtrr_remove_offending(screenNum, base, size, from); wcr = &wcreturn; while (*wcr) { wcr = &((*wcr)->next); } /* Linux 2.0 should not warn, unless the user explicitly asks for WC. */ if (!mtrr_open(from == X_CONFIG ? 0 : 2)) return wcreturn; *wcr = curwcr = xalloc(sizeof(**wcr)); if (!curwcr) return wcreturn; curwcr->sentry.base = base; curwcr->sentry.size = size; curwcr->sentry.type = MTRR_TYPE_WRCOMB; curwcr->added = TRUE; curwcr->next = NULL; #if SPLIT_WC_REGIONS /* * Splits up the write-combining region if it is not aligned on a * size boundary. */ { unsigned long lbase, d_size = 1; unsigned long n_size = size; unsigned long n_base = base; for (lbase = n_base, d_size = 1; !(lbase & 1); lbase = lbase >> 1, d_size <<= 1); while (d_size > n_size) d_size = d_size >> 1; DebugF("WC_BASE: 0x%lx WC_END: 0x%lx\n",base,base+d_size-1); n_base += d_size; n_size -= d_size; if (n_size) { xf86DrvMsgVerb(screenNum,X_INFO,3,"Splitting WC range: " "base: 0x%lx, size: 0x%lx\n",base,size); curwcr->next = mtrr_add_wc_region(screenNum, n_base, n_size,from); } curwcr->sentry.size = d_size; } /*****************************************************************/ #endif /* SPLIT_WC_REGIONS */ if (ioctl(mtrr_fd, MTRRIOC_ADD_ENTRY, &curwcr->sentry) >= 0) { /* Avoid printing on every VT switch */ if (xf86ServerIsInitialising()) { xf86DrvMsg(screenNum, from, "Write-combining range (0x%lx,0x%lx)\n", base, size); } return wcreturn; } else { *wcr = curwcr->next; xfree(curwcr); /* Don't complain about the VGA region: MTRR fixed regions aren't currently supported, but might be in the future. */ if ((unsigned long)base >= 0x100000) { xf86DrvMsgVerb(screenNum, X_WARNING, 0, "Failed to set up write-combining range " "(0x%lx,0x%lx)\n", base, size); } return wcreturn; } }
/* * xf86VTSwitch -- * Handle requests for switching the vt. */ static void xf86VTSwitch(void) { int i; static int prevSIGIO; InputInfoPtr pInfo; IHPtr ih; DebugF("xf86VTSwitch()\n"); #ifdef XFreeXDGA if(!DGAVTSwitch()) return; #endif /* * Since all screens are currently all in the same state it is sufficient * check the first. This might change in future. */ if (xf86Screens[0]->vtSema) { DebugF("xf86VTSwitch: Leaving, xf86Exiting is %s\n", BOOLTOSTRING((dispatchException & DE_TERMINATE) ? TRUE : FALSE)); #ifdef DPMSExtension if (DPMSPowerLevel != DPMSModeOn) DPMSSet(serverClient, DPMSModeOn); #endif for (i = 0; i < xf86NumScreens; i++) { if (!(dispatchException & DE_TERMINATE)) if (xf86Screens[i]->EnableDisableFBAccess) (*xf86Screens[i]->EnableDisableFBAccess) (i, FALSE); } /* * Keep the order: Disable Device > LeaveVT * EnterVT > EnableDevice */ for (ih = InputHandlers; ih; ih = ih->next) xf86DisableInputHandler(ih); for (pInfo = xf86InputDevs; pInfo; pInfo = pInfo->next) { if (pInfo->dev) { xf86ReleaseKeys(pInfo->dev); ProcessInputEvents(); DisableDevice(pInfo->dev, TRUE); } } prevSIGIO = xf86BlockSIGIO(); for (i = 0; i < xf86NumScreens; i++) xf86Screens[i]->LeaveVT(i, 0); xf86AccessLeave(); /* We need this here, otherwise */ if (!xf86VTSwitchAway()) { /* * switch failed */ DebugF("xf86VTSwitch: Leave failed\n"); xf86AccessEnter(); for (i = 0; i < xf86NumScreens; i++) { if (!xf86Screens[i]->EnterVT(i, 0)) FatalError("EnterVT failed for screen %d\n", i); } if (!(dispatchException & DE_TERMINATE)) { for (i = 0; i < xf86NumScreens; i++) { if (xf86Screens[i]->EnableDisableFBAccess) (*xf86Screens[i]->EnableDisableFBAccess) (i, TRUE); } } dixSaveScreens(serverClient, SCREEN_SAVER_FORCER, ScreenSaverReset); pInfo = xf86InputDevs; while (pInfo) { if (pInfo->dev) EnableDevice(pInfo->dev, TRUE); pInfo = pInfo->next; } for (ih = InputHandlers; ih; ih = ih->next) xf86EnableInputHandler(ih); xf86UnblockSIGIO(prevSIGIO); } else { #ifdef XF86PM if (xf86OSPMClose) xf86OSPMClose(); xf86OSPMClose = NULL; #endif for (i = 0; i < xf86NumScreens; i++) { /* * zero all access functions to * trap calls when switched away. */ xf86Screens[i]->vtSema = FALSE; } if (xorgHWAccess) xf86DisableIO(); } } else { DebugF("xf86VTSwitch: Entering\n"); if (!xf86VTSwitchTo()) return; #ifdef XF86PM xf86OSPMClose = xf86OSPMOpen(); #endif if (xorgHWAccess) xf86EnableIO(); xf86AccessEnter(); for (i = 0; i < xf86NumScreens; i++) { xf86Screens[i]->vtSema = TRUE; if (!xf86Screens[i]->EnterVT(i, 0)) FatalError("EnterVT failed for screen %d\n", i); } for (i = 0; i < xf86NumScreens; i++) { if (xf86Screens[i]->EnableDisableFBAccess) (*xf86Screens[i]->EnableDisableFBAccess)(i, TRUE); } /* Turn screen saver off when switching back */ dixSaveScreens(serverClient, SCREEN_SAVER_FORCER, ScreenSaverReset); pInfo = xf86InputDevs; while (pInfo) { if (pInfo->dev) EnableDevice(pInfo->dev, TRUE); pInfo = pInfo->next; } for (ih = InputHandlers; ih; ih = ih->next) xf86EnableInputHandler(ih); xf86UnblockSIGIO(prevSIGIO); } }
static Bool XkbDDXCompileKeymapByNames( XkbDescPtr xkb, XkbComponentNamesPtr names, unsigned want, unsigned need, char * nameRtrn, int nameRtrnLen) { FILE * out; char *buf = NULL, keymap[PATH_MAX], xkm_output_dir[PATH_MAX]; const char *emptystring = ""; char *xkbbasedirflag = NULL; const char *xkbbindir = emptystring; const char *xkbbindirsep = emptystring; #ifdef WIN32 /* WIN32 has no popen. The input must be stored in a file which is used as input for xkbcomp. xkbcomp does not read from stdin. */ char tmpname[PATH_MAX]; const char *xkmfile = tmpname; #else const char *xkmfile = "-"; #endif snprintf(keymap, sizeof(keymap), "server-%s", display); OutputDirectory(xkm_output_dir, sizeof(xkm_output_dir)); #ifdef WIN32 strcpy(tmpname, Win32TempDir()); strcat(tmpname, "\\xkb_XXXXXX"); (void) mktemp(tmpname); #endif if (XkbBaseDirectory != NULL) { xkbbasedirflag = Xprintf("\"-R%s\"", XkbBaseDirectory); } if (XkbBinDirectory != NULL) { int ld = strlen(XkbBinDirectory); int lps = strlen(PATHSEPARATOR); xkbbindir = XkbBinDirectory; if ((ld >= lps) && (strcmp(xkbbindir + ld - lps, PATHSEPARATOR) != 0)) { xkbbindirsep = PATHSEPARATOR; } } buf = Xprintf("\"%s%sxkbcomp\" -w %d %s -xkm \"%s\" " "-em1 %s -emp %s -eml %s \"%s%s.xkm\"", xkbbindir, xkbbindirsep, ( (xkbDebugFlags < 2) ? 1 : ((xkbDebugFlags > 10) ? 10 : (int)xkbDebugFlags) ), xkbbasedirflag ? xkbbasedirflag : "", xkmfile, PRE_ERROR_MSG, ERROR_PREFIX, POST_ERROR_MSG1, xkm_output_dir, keymap); free(xkbbasedirflag); if (!buf) { LogMessage(X_ERROR, "XKB: Could not invoke xkbcomp: not enough memory\n"); return FALSE; } #ifndef WIN32 out= Popen(buf,"w"); #else out= fopen(tmpname, "w"); #endif if (out!=NULL) { #ifdef DEBUG if (xkbDebugFlags) { ErrorF("[xkb] XkbDDXCompileKeymapByNames compiling keymap:\n"); XkbWriteXKBKeymapForNames(stderr,names,xkb,want,need); } #endif XkbWriteXKBKeymapForNames(out,names,xkb,want,need); #ifndef WIN32 if (Pclose(out)==0) #else if (fclose(out)==0 && System(buf) >= 0) #endif { if (xkbDebugFlags) DebugF("[xkb] xkb executes: %s\n",buf); if (nameRtrn) { strncpy(nameRtrn,keymap,nameRtrnLen); nameRtrn[nameRtrnLen-1]= '\0'; } if (buf != NULL) free(buf); return TRUE; } else LogMessage(X_ERROR, "Error compiling keymap (%s)\n", keymap); #ifdef WIN32 /* remove the temporary file */ unlink(tmpname); #endif } else { #ifndef WIN32 LogMessage(X_ERROR, "XKB: Could not invoke xkbcomp\n"); #else LogMessage(X_ERROR, "Could not open file %s\n", tmpname); #endif } if (nameRtrn) nameRtrn[0]= '\0'; if (buf != NULL) free(buf); return FALSE; }
/***====================================================================***/ static Status XkbDDXListComponent( DeviceIntPtr dev, int what, XkbSrvListInfoPtr list, ClientPtr client) { char *file,*map,*tmp,*buf=NULL; FILE *in; Status status; int rval; Bool haveDir; #ifdef WIN32 char tmpname[PATH_MAX]; #endif if ((list->pattern[what]==NULL)||(list->pattern[what][0]=='\0')) return Success; file= list->pattern[what]; map= strrchr(file,'('); if (map!=NULL) { char *tmp; map++; tmp= strrchr(map,')'); if ((tmp==NULL)||(tmp[1]!='\0')) { /* illegal pattern. No error, but no match */ return Success; } } in= NULL; haveDir= TRUE; #ifdef WIN32 strcpy(tmpname, Win32TempDir()); strcat(tmpname, "\\xkb_XXXXXX"); (void) mktemp(tmpname); #endif if (XkbBaseDirectory!=NULL) { if ((list->pattern[what][0]=='*')&&(list->pattern[what][1]=='\0')) { if (asprintf(&buf, "%s/%s.dir", XkbBaseDirectory, componentDirs[what]) == -1) buf = NULL; else in = fopen(buf,"r"); } if (!in) { haveDir= FALSE; free(buf); if (asprintf (&buf, "'%s/xkbcomp' '-R%s/%s' -w %ld -l -vlfhpR '%s'" W32_tmparg, XkbBinDirectory, XkbBaseDirectory, componentDirs[what], (long) ((xkbDebugFlags < 2) ? 1 : ((xkbDebugFlags > 10) ? 10 : xkbDebugFlags)), file W32_tmpfile ) == -1) buf = NULL; } } else { if ((list->pattern[what][0]=='*')&&(list->pattern[what][1]=='\0')) { if (asprintf(&buf, "%s.dir", componentDirs[what]) == -1) buf = NULL; else in = fopen(buf,"r"); } if (!in) { haveDir= FALSE; free(buf); if (asprintf (&buf, "xkbcomp -R%s -w %ld -l -vlfhpR '%s'" W32_tmparg, componentDirs[what], (long) ((xkbDebugFlags < 2) ? 1 : ((xkbDebugFlags > 10) ? 10 : xkbDebugFlags)), file W32_tmpfile ) == -1) buf = NULL; } } status= Success; if (!haveDir) { #ifndef WIN32 in= Popen(buf,"r"); #else if (xkbDebugFlags) DebugF("[xkb] xkbList executes: %s\n",buf); if (System(buf) < 0) ErrorF("[xkb] Could not invoke keymap compiler\n"); else in= fopen(tmpname, "r"); #endif } if (!in) { free(buf); #ifdef WIN32 unlink(tmpname); #endif return BadImplementation; } list->nFound[what]= 0; free(buf); buf = malloc(PATH_MAX * sizeof(char)); if (!buf) return BadAlloc; while ((status==Success)&&((tmp=fgets(buf,PATH_MAX,in))!=NULL)) { unsigned flags; register unsigned int i; if (*tmp=='#') /* comment, skip it */ continue; if (!strncmp(tmp, "Warning:", 8) || !strncmp(tmp, " ", 8)) /* skip warnings too */ continue; flags= 0; /* each line in the listing is supposed to start with two */ /* groups of eight characters, which specify the general */ /* flags and the flags that are specific to the component */ /* if they're missing, fail with BadImplementation */ for (i=0;(i<8)&&(status==Success);i++) { /* read the general flags */ if (isalpha(*tmp)) flags|= (1L<<i); else if (*tmp!='-') status= BadImplementation; tmp++; } if (status != Success) break; if (!isspace(*tmp)) { status= BadImplementation; break; } else tmp++; for (i=0;(i<8)&&(status==Success);i++) { /* read the component flags */ if (isalpha(*tmp)) flags|= (1L<<(i+8)); else if (*tmp!='-') status= BadImplementation; tmp++; } if (status != Success) break; if (isspace(*tmp)) { while (isspace(*tmp)) { tmp++; } } else { status= BadImplementation; break; } status= _AddListComponent(list,what,flags,tmp,client); } #ifndef WIN32 if (haveDir) fclose(in); else if ((rval=Pclose(in))!=0) { if (xkbDebugFlags) ErrorF("[xkb] xkbcomp returned exit code %d\n",rval); } #else fclose(in); unlink(tmpname); #endif free(buf); return status; }
_X_EXPORT Bool InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet *rmlvo, BellProcPtr bell_func, KbdCtrlProcPtr ctrl_func) { int i; unsigned int check; XkbSrvInfoPtr xkbi; XkbDescPtr xkb; XkbSrvLedInfoPtr sli; XkbChangesRec changes; XkbEventCauseRec cause; XkbRMLVOSet rmlvo_dflts = { NULL }; if (dev->key || dev->kbdfeed) return FALSE; if (!rmlvo) { rmlvo = &rmlvo_dflts; XkbGetRulesDflts(rmlvo); } memset(&changes, 0, sizeof(changes)); XkbSetCauseUnknown(&cause); dev->key = calloc(1, sizeof(*dev->key)); if (!dev->key) { ErrorF("XKB: Failed to allocate key class\n"); return FALSE; } dev->key->sourceid = dev->id; dev->kbdfeed = calloc(1, sizeof(*dev->kbdfeed)); if (!dev->kbdfeed) { ErrorF("XKB: Failed to allocate key feedback class\n"); goto unwind_key; } xkbi = calloc(1, sizeof(*xkbi)); if (!xkbi) { ErrorF("XKB: Failed to allocate XKB info\n"); goto unwind_kbdfeed; } dev->key->xkbInfo = xkbi; if (xkb_cached_map && !XkbCompareUsedRMLVO(rmlvo)) { XkbFreeKeyboard(xkb_cached_map, XkbAllComponentsMask, TRUE); xkb_cached_map = NULL; } if (xkb_cached_map) LogMessageVerb(X_INFO, 4, "XKB: Reusing cached keymap\n"); else { xkb_cached_map = XkbCompileKeymap(dev, rmlvo); if (!xkb_cached_map) { ErrorF("XKB: Failed to compile keymap\n"); goto unwind_info; } } xkb = XkbAllocKeyboard(); if (!xkb) { ErrorF("XKB: Failed to allocate keyboard description\n"); goto unwind_info; } if (!XkbCopyKeymap(xkb, xkb_cached_map)) { ErrorF("XKB: Failed to copy keymap\n"); goto unwind_desc; } xkb->defined = xkb_cached_map->defined; xkb->flags = xkb_cached_map->flags; xkb->device_spec = xkb_cached_map->device_spec; xkbi->desc = xkb; if (xkb->min_key_code == 0) xkb->min_key_code = 8; if (xkb->max_key_code == 0) xkb->max_key_code = 255; i = XkbNumKeys(xkb) / 3 + 1; if (XkbAllocClientMap(xkb, XkbAllClientInfoMask, 0) != Success) goto unwind_desc; if (XkbAllocServerMap(xkb, XkbAllServerInfoMask, i) != Success) goto unwind_desc; xkbi->dfltPtrDelta = 1; xkbi->device = dev; XkbInitSemantics(xkb); XkbInitNames(xkbi); XkbInitRadioGroups(xkbi); XkbInitControls(dev, xkbi); XkbInitIndicatorMap(xkbi); XkbUpdateActions(dev, xkb->min_key_code, XkbNumKeys(xkb), &changes, &check, &cause); InitFocusClassDeviceStruct(dev); xkbi->kbdProc = ctrl_func; dev->kbdfeed->BellProc = bell_func; dev->kbdfeed->CtrlProc = XkbDDXKeybdCtrlProc; dev->kbdfeed->ctrl = defaultKeyboardControl; if (dev->kbdfeed->ctrl.autoRepeat) xkb->ctrls->enabled_ctrls |= XkbRepeatKeysMask; memcpy(dev->kbdfeed->ctrl.autoRepeats, xkb->ctrls->per_key_repeat, XkbPerKeyBitArraySize); sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0); if (sli) XkbCheckIndicatorMaps(dev, sli, XkbAllIndicatorsMask); else DebugF("XKB: No indicator feedback in XkbFinishInit!\n"); dev->kbdfeed->CtrlProc(dev,&dev->kbdfeed->ctrl); XkbSetRulesDflts(rmlvo); XkbSetRulesUsed(rmlvo); XkbFreeRMLVOSet(&rmlvo_dflts, FALSE); return TRUE; unwind_desc: XkbFreeKeyboard(xkb, 0, TRUE); unwind_info: free(xkbi); dev->key->xkbInfo = NULL; unwind_kbdfeed: free(dev->kbdfeed); dev->kbdfeed = NULL; unwind_key: free(dev->key); dev->key = NULL; return FALSE; }
int xf86MatchSbusInstances(const char *driverName, int sbusDevId, GDevPtr *devList, int numDevs, DriverPtr drvp, int **foundEntities) { int i,j; sbusDevicePtr psdp, *psdpp; int numClaimedInstances = 0; int allocatedInstances = 0; int numFound = 0; GDevPtr devBus = NULL; GDevPtr dev = NULL; int *retEntities = NULL; int useProm = 0; struct Inst { sbusDevicePtr sbus; GDevPtr dev; Bool claimed; /* BusID matches with a device section */ } *instances = NULL; *foundEntities = NULL; for (psdpp = xf86SbusInfo, psdp = *psdpp; psdp; psdp = *++psdpp) { if (psdp->devId != sbusDevId) continue; if (psdp->fd == -2) continue; ++allocatedInstances; instances = xnfrealloc(instances, allocatedInstances * sizeof(struct Inst)); instances[allocatedInstances - 1].sbus = psdp; instances[allocatedInstances - 1].dev = NULL; instances[allocatedInstances - 1].claimed = FALSE; numFound++; } /* * This may be debatable, but if no SBUS devices with a matching vendor * type is found, return zero now. It is probably not desirable to * allow the config file to override this. */ if (allocatedInstances <= 0) { free(instances); return 0; } if (sparcPromInit() >= 0) useProm = 1; if (xf86DoConfigure && xf86DoConfigurePass1) { GDevPtr pGDev; int actualcards = 0; for (i = 0; i < allocatedInstances; i++) { actualcards++; pGDev = xf86AddBusDeviceToConfigure(drvp->driverName, BUS_SBUS, instances[i].sbus, -1); if (pGDev) { /* * XF86Match???Instances() treat chipID and chipRev as * overrides, so clobber them here. */ pGDev->chipID = pGDev->chipRev = -1; } } free(instances); if (useProm) sparcPromClose(); return actualcards; } DebugF("%s instances found: %d\n", driverName, allocatedInstances); for (i = 0; i < allocatedInstances; i++) { char *promPath = NULL; psdp = instances[i].sbus; devBus = NULL; dev = NULL; if (useProm && psdp->node.node) promPath = sparcPromNode2Pathname(&psdp->node); for (j = 0; j < numDevs; j++) { if (devList[j]->busID && *devList[j]->busID) { if (xf86CompareSbusBusString(devList[j]->busID, psdp->fbNum)) { if (devBus) xf86MsgVerb(X_WARNING,0, "%s: More than one matching Device section for " "instance (BusID: %s) found: %s\n", driverName,devList[j]->identifier, devList[j]->busID); else devBus = devList[j]; } } else { if (!dev && !devBus) { if (promPath) xf86Msg(X_PROBED, "Assigning device section with no busID to SBUS:%s\n", promPath); else xf86Msg(X_PROBED, "Assigning device section with no busID to SBUS:fb%d\n", psdp->fbNum); dev = devList[j]; } else xf86MsgVerb(X_WARNING, 0, "%s: More than one matching Device section " "found: %s\n", driverName, devList[j]->identifier); } } if (devBus) dev = devBus; /* busID preferred */ if (!dev && psdp->fd != -2) { if (promPath) { xf86MsgVerb(X_WARNING, 0, "%s: No matching Device section " "for instance (BusID SBUS:%s) found\n", driverName, promPath); } else xf86MsgVerb(X_WARNING, 0, "%s: No matching Device section " "for instance (BusID SBUS:fb%d) found\n", driverName, psdp->fbNum); } else if (dev) { numClaimedInstances++; instances[i].claimed = TRUE; instances[i].dev = dev; } free(promPath); } DebugF("%s instances found: %d\n", driverName, numClaimedInstances); /* * Of the claimed instances, check that another driver hasn't already * claimed its slot. */ numFound = 0; for (i = 0; i < allocatedInstances && numClaimedInstances > 0; i++) { if (!instances[i].claimed) continue; psdp = instances[i].sbus; if (!xf86CheckSbusSlot(psdp->fbNum)) continue; DebugF("%s: card at fb%d %08x is claimed by a Device section\n", driverName, psdp->fbNum, psdp->node.node); /* Allocate an entry in the lists to be returned */ numFound++; retEntities = xnfrealloc(retEntities, numFound * sizeof(int)); retEntities[numFound - 1] = xf86ClaimSbusSlot(psdp, drvp, instances[i].dev,instances[i].dev->active ? TRUE : FALSE); } free(instances); if (numFound > 0) { *foundEntities = retEntities; } if (useProm) sparcPromClose(); return numFound; }
static Bool CheckLine( InputLine * line, RemapSpec * remap, XkbRF_RulePtr rule, XkbRF_GroupPtr group) { char * str,*tok; register int nread, i; FileSpec tmp; _Xstrtokparams strtok_buf; Bool append = FALSE; if (line->line[0]=='!') { if (line->line[1] == '$' || (line->line[1] == ' ' && line->line[2] == '$')) { char *gname = strchr(line->line, '$'); char *words = strchr(gname, ' '); if(!words) return FALSE; *words++ = '\0'; for (; *words; words++) { if (*words != '=' && *words != ' ') break; } if (*words == '\0') return FALSE; group->name = _XkbDupString(gname); group->words = _XkbDupString(words); for (i = 1, words = group->words; *words; words++) { if ( *words == ' ') { *words++ = '\0'; i++; } } group->number = i; return TRUE; } else { SetUpRemap(line,remap); return FALSE; } } if (remap->num_remap==0) { DebugF("Must have a mapping before first line of data\n"); DebugF("Illegal line of data ignored\n"); return FALSE; } bzero((char *)&tmp,sizeof(FileSpec)); str= line->line; for (nread= 0;(tok=_XStrtok(str," ",strtok_buf))!=NULL;nread++) { str= NULL; if (strcmp(tok,"=")==0) { nread--; continue; } if (nread>remap->num_remap) { DebugF("Too many words on a line\n"); DebugF("Extra word \"%s\" ignored\n",tok); continue; } tmp.name[remap->remap[nread].word]= tok; if (*tok == '+' || *tok == '|') append = TRUE; } if (nread<remap->num_remap) { DebugF("Too few words on a line: %s\n", line->line); DebugF("line ignored\n"); return FALSE; } rule->flags= 0; rule->number = remap->number; if (tmp.name[OPTION]) rule->flags|= XkbRF_Option; else if (append) rule->flags|= XkbRF_Append; else rule->flags|= XkbRF_Normal; rule->model= _XkbDupString(tmp.name[MODEL]); rule->layout= _XkbDupString(tmp.name[LAYOUT]); rule->variant= _XkbDupString(tmp.name[VARIANT]); rule->option= _XkbDupString(tmp.name[OPTION]); rule->keycodes= _XkbDupString(tmp.name[KEYCODES]); rule->symbols= _XkbDupString(tmp.name[SYMBOLS]); rule->types= _XkbDupString(tmp.name[TYPES]); rule->compat= _XkbDupString(tmp.name[COMPAT]); rule->geometry= _XkbDupString(tmp.name[GEOMETRY]); rule->layout_num = rule->variant_num = 0; for (i = 0; i < nread; i++) { if (remap->remap[i].index) { if (remap->remap[i].word == LAYOUT) rule->layout_num = remap->remap[i].index; if (remap->remap[i].word == VARIANT) rule->variant_num = remap->remap[i].index; } } return TRUE; }
static void SetUpRemap(InputLine *line,RemapSpec *remap) { char * tok,*str; unsigned present, l_ndx_present, v_ndx_present; register int i; int len, ndx; _Xstrtokparams strtok_buf; Bool found; l_ndx_present = v_ndx_present = present= 0; str= &line->line[1]; len = remap->number; bzero((char *)remap,sizeof(RemapSpec)); remap->number = len; while ((tok=_XStrtok(str," ",strtok_buf))!=NULL) { found= FALSE; str= NULL; if (strcmp(tok,"=")==0) continue; for (i=0;i<MAX_WORDS;i++) { len = strlen(cname[i]); if (strncmp(cname[i],tok,len)==0) { if(strlen(tok) > len) { char *end = get_index(tok+len, &ndx); if ((i != LAYOUT && i != VARIANT) || *end != '\0' || ndx == -1) break; if (ndx < 1 || ndx > XkbNumKbdGroups) { DebugF("Illegal %s index: %d\n", cname[i], ndx); DebugF("Index must be in range 1..%d\n", XkbNumKbdGroups); break; } } else { ndx = 0; } found= TRUE; if (present&(1<<i)) { if ((i == LAYOUT && l_ndx_present&(1<<ndx)) || (i == VARIANT && v_ndx_present&(1<<ndx)) ) { DebugF("Component \"%s\" listed twice\n",tok); DebugF("Second definition ignored\n"); break; } } present |= (1<<i); if (i == LAYOUT) l_ndx_present |= 1 << ndx; if (i == VARIANT) v_ndx_present |= 1 << ndx; remap->remap[remap->num_remap].word= i; remap->remap[remap->num_remap++].index= ndx; break; } } if (!found) { fprintf(stderr,"Unknown component \"%s\" ignored\n",tok); } } if ((present&PART_MASK)==0) { unsigned mask= PART_MASK; ErrorF("Mapping needs at least one of "); for (i=0; (i<MAX_WORDS); i++) { if ((1L<<i)&mask) { mask&= ~(1L<<i); if (mask) DebugF("\"%s,\" ",cname[i]); else DebugF("or \"%s\"\n",cname[i]); } } DebugF("Illegal mapping ignored\n"); remap->num_remap= 0; return; } if ((present&COMPONENT_MASK)==0) { DebugF("Mapping needs at least one component\n"); DebugF("Illegal mapping ignored\n"); remap->num_remap= 0; return; } remap->number++; return; }
static Bool GetInputLine(FILE *file,InputLine *line,Bool checkbang) { int ch; Bool endOfFile,spacePending,slashPending,inComment; endOfFile= FALSE; while ((!endOfFile)&&(line->num_line==0)) { spacePending= slashPending= inComment= FALSE; while (((ch=getc(file))!='\n')&&(ch!=EOF)) { if (ch=='\\') { if ((ch=getc(file))==EOF) break; if (ch=='\n') { inComment= FALSE; ch= ' '; line->line_num++; } } if (inComment) continue; if (ch=='/') { if (slashPending) { inComment= TRUE; slashPending= FALSE; } else { slashPending= TRUE; } continue; } else if (slashPending) { if (spacePending) { ADD_CHAR(line,' '); spacePending= FALSE; } ADD_CHAR(line,'/'); slashPending= FALSE; } if (isspace(ch)) { while (isspace(ch)&&(ch!='\n')&&(ch!=EOF)) { ch= getc(file); } if (ch==EOF) break; if ((ch!='\n')&&(line->num_line>0)) spacePending= TRUE; ungetc(ch,file); } else { if (spacePending) { ADD_CHAR(line,' '); spacePending= FALSE; } if (checkbang && ch=='!') { if (line->num_line!=0) { DebugF("The '!' legal only at start of line\n"); DebugF("Line containing '!' ignored\n"); line->num_line= 0; inComment= 0; break; } } ADD_CHAR(line,ch); } } if (ch==EOF) endOfFile= TRUE; /* else line->num_line++;*/ } if ((line->num_line==0)&&(endOfFile)) return FALSE; ADD_CHAR(line,'\0'); return TRUE; }
static FBLinearPtr localAllocateOffscreenLinear(ScreenPtr pScreen, int length, int gran, MoveLinearCallbackProcPtr moveCB, RemoveLinearCallbackProcPtr removeCB, void *privData) { FBManagerPtr offman; FBLinearLinkPtr link; FBAreaPtr area; FBLinearPtr linear = NULL; BoxPtr extents; int w, h, pitch; offman = (FBManagerPtr) dixLookupPrivate(&pScreen->devPrivates, xf86FBScreenKey); /* Try to allocate from linear memory first...... */ DebugF("ALLOCATING LINEAR\n"); if ((linear = AllocateLinear(offman, length, gran, privData))) return linear; DebugF("NOPE, ALLOCATING AREA\n"); if (!(link = malloc(sizeof(FBLinearLink)))) return NULL; /* No linear available, so try and pinch some from the XY areas */ extents = RegionExtents(offman->InitialBoxes); pitch = extents->x2 - extents->x1; if (gran > 1) { if (gran > pitch) { /* we can't match the specified alignment with XY allocations */ free(link); return NULL; } if (pitch % gran) { /* pitch and granularity aren't a perfect match, let's allocate * a bit more so we can align later on */ length += gran - 1; } } if (length < pitch) { /* special case */ w = length; h = 1; } else { w = pitch; h = (length + pitch - 1) / pitch; } if ((area = localAllocateOffscreenArea(pScreen, w, h, gran, moveCB ? LinearMoveCBWrapper : NULL, removeCB ? LinearRemoveCBWrapper : NULL, privData))) { link->area = area; link->free = 0; link->next = offman->LinearAreas; offman->LinearAreas = link; linear = &(link->linear); linear->pScreen = pScreen; linear->size = h * w; linear->offset = (pitch * area->box.y1) + area->box.x1; if (gran > 1) linear->offset = ((linear->offset + gran - 1) / gran) * gran; linear->granularity = gran; linear->MoveLinearCallback = moveCB; linear->RemoveLinearCallback = removeCB; linear->devPrivate.ptr = privData; } else free(link); DumpDebug(offman->LinearAreas); return linear; }
Bool xf86PciProbeDev(DriverPtr drvp) { int i, j; struct pci_device *pPci; Bool foundScreen = FALSE; const struct pci_id_match *const devices = drvp->supported_devices; GDevPtr *devList; const unsigned numDevs = xf86MatchDevice(drvp->driverName, &devList); for (i = 0; i < numDevs; i++) { struct pci_device_iterator *iter; unsigned device_id; /* Find the pciVideoRec associated with this device section. */ iter = pci_id_match_iterator_create(NULL); while ((pPci = pci_device_next(iter)) != NULL) { if (devList[i]->busID && *devList[i]->busID) { if (xf86ComparePciBusString(devList[i]->busID, ((pPci->domain << 8) | pPci->bus), pPci->dev, pPci->func)) { break; } } else if (xf86IsPrimaryPci(pPci)) { break; } } pci_iterator_destroy(iter); if (pPci == NULL) { continue; } device_id = (devList[i]->chipID > 0) ? devList[i]->chipID : pPci->device_id; /* Once the pciVideoRec is found, determine if the device is supported * by the driver. If it is, probe it! */ for (j = 0; !END_OF_MATCHES(devices[j]); j++) { if (PCI_ID_COMPARE(devices[j].vendor_id, pPci->vendor_id) && PCI_ID_COMPARE(devices[j].device_id, device_id) && ((devices[j].device_class_mask & pPci->device_class) == devices[j].device_class)) { int entry; /* Allow the same entity to be used more than once for * devices with multiple screens per entity. This assumes * implicitly that there will be a screen == 0 instance. * * FIXME Need to make sure that two different drivers don't * FIXME claim the same screen > 0 instance. */ if ((devList[i]->screen == 0) && !xf86CheckPciSlot(pPci)) continue; DebugF("%s: card at %d:%d:%d is claimed by a Device section\n", drvp->driverName, pPci->bus, pPci->dev, pPci->func); /* Allocate an entry in the lists to be returned */ entry = xf86ClaimPciSlot(pPci, drvp, device_id, devList[i], devList[i]->active); if ((entry == -1) && (devList[i]->screen > 0)) { unsigned k; for (k = 0; k < xf86NumEntities; k++) { EntityPtr pEnt = xf86Entities[k]; if (pEnt->bus.type != BUS_PCI) continue; if (pEnt->bus.id.pci == pPci) { entry = k; xf86AddDevToEntity(k, devList[i]); break; } } } if (entry != -1) { if ((*drvp->PciProbe) (drvp, entry, pPci, devices[j].match_data)) { foundScreen = TRUE; } else xf86UnclaimPciSlot(pPci, devList[i]); } break; } } } free(devList); return foundScreen; }