QList<QByteArray> QAudioDeviceInfoInternal::availableDevices(QAudio::Mode mode) { QList<QByteArray> devices; UInt32 propSize = 0; if (AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &propSize, 0) == noErr) { const int dc = propSize / sizeof(AudioDeviceID); if (dc > 0) { AudioDeviceID* audioDevices = new AudioDeviceID[dc]; if (AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &propSize, audioDevices) == noErr) { for (int i = 0; i < dc; ++i) { QByteArray info = get_device_info(audioDevices[i], mode); if (!info.isNull()) devices << info; } } delete audioDevices; } } return devices; }
void DevicePCI::InitFromAttributes() { // Process the attributes fClassBaseId = atoi(fAttributeMap[B_DEVICE_TYPE].String()); fClassSubId = atoi(fAttributeMap[B_DEVICE_SUB_TYPE].String()); fClassApiId = atoi(fAttributeMap[B_DEVICE_INTERFACE].String()); fVendorId = atoi(fAttributeMap[B_DEVICE_VENDOR_ID].String()); fDeviceId = atoi(fAttributeMap[B_DEVICE_ID].String()); // Looks better in Hex, so rewrite fAttributeMap[B_DEVICE_TYPE] = ToHex(fClassBaseId); fAttributeMap[B_DEVICE_SUB_TYPE] = ToHex(fClassSubId); fAttributeMap[B_DEVICE_INTERFACE] = ToHex(fClassApiId); fAttributeMap[B_DEVICE_VENDOR_ID] = ToHex(fVendorId); fAttributeMap[B_DEVICE_ID] = ToHex(fDeviceId); // Fetch ClassInfo char classInfo[64]; get_class_info(fClassBaseId, fClassSubId, fClassApiId, classInfo, sizeof(classInfo)); // Fetch ManufacturerName BString ManufacturerName; const char *venShort; const char *venFull; get_vendor_info(fVendorId, &venShort, &venFull); if (!venShort && !venFull) { ManufacturerName << B_TRANSLATE("Unknown"); } else if (venShort && venFull) { ManufacturerName << venFull << "(" << venShort << ")"; } else { ManufacturerName << (venShort ? venShort : venFull); } // Fetch DeviceName BString DeviceName; const char *devShort; const char *devFull; get_device_info(fVendorId, fDeviceId, fSubsystemVendorId, fSubSystemId, &devShort, &devFull); if (!devShort && !devFull) { DeviceName << B_TRANSLATE("Unknown"); } else if (devShort && devFull) { DeviceName << devFull << "(" << devShort << ")"; } else { DeviceName << (devShort ? devShort : devFull); } SetAttribute(B_TRANSLATE("Device name"), DeviceName); SetAttribute(B_TRANSLATE("Manufacturer"), ManufacturerName); SetAttribute(B_TRANSLATE("Driver used"), B_TRANSLATE("Not implemented")); SetAttribute(B_TRANSLATE("Device paths"), B_TRANSLATE("Not implemented")); SetAttribute(B_TRANSLATE("Class info"), classInfo); fCategory = (Category)fClassBaseId; BString outlineName; outlineName << ManufacturerName << " " << DeviceName; SetText(outlineName.String()); }
/*! * \brief Handles the SOAP requests to querry the state variables. * This functionality has been deprecated in the UPnP V1.0 architecture. */ static UPNP_INLINE void handle_query_variable( IN SOCKINFO *info, IN http_message_t *request, IN IXML_Document *xml_doc) { UpnpStateVarRequest *variable = UpnpStateVarRequest_new(); Upnp_FunPtr soap_event_callback; void *cookie; char var_name[LINE_SIZE]; const char *err_str; int err_code; if (get_var_name(xml_doc, var_name) != 0) { send_error_response(info, SOAP_INVALID_VAR, Soap_Invalid_Var, request); return; } /* get info for event */ err_code = get_device_info(request, 1, xml_doc, info->foreign_sockaddr.ss_family, (UpnpString *)UpnpStateVarRequest_get_DevUDN(variable), (UpnpString *)UpnpStateVarRequest_get_ServiceID(variable), &soap_event_callback, &cookie); if (err_code != 0) { send_error_response(info, SOAP_INVALID_VAR, Soap_Invalid_Var, request); return; } UpnpStateVarRequest_set_ErrCode(variable, UPNP_E_SUCCESS); UpnpStateVarRequest_strcpy_StateVarName(variable, var_name); UpnpStateVarRequest_set_CtrlPtIPAddr(variable, &info->foreign_sockaddr); /* send event */ soap_event_callback(UPNP_CONTROL_GET_VAR_REQUEST, variable, cookie); UpnpPrintf(UPNP_INFO, SOAP, __FILE__, __LINE__, "Return from callback for var request\n"); /* validate, and handle result */ if (UpnpStateVarRequest_get_CurrentVal(variable) == NULL) { err_code = SOAP_ACTION_FAILED; err_str = Soap_Action_Failed; send_error_response(info, SOAP_INVALID_VAR, Soap_Invalid_Var, request); return; } if (UpnpStateVarRequest_get_ErrCode(variable) != UPNP_E_SUCCESS) { if (UpnpString_get_Length(UpnpStateVarRequest_get_ErrStr(variable)) > 0) { err_code = SOAP_INVALID_VAR; err_str = Soap_Invalid_Var; } else { err_code = UpnpStateVarRequest_get_ErrCode(variable); err_str = UpnpStateVarRequest_get_ErrStr_cstr(variable); } send_error_response(info, err_code, err_str, request); return; } /* send response */ send_var_query_response(info, UpnpStateVarRequest_get_CurrentVal(variable), request); UpnpStateVarRequest_delete(variable); }
/* For external library use */ int kmc_is_kmc() { int isakmc; get_device_info(); isakmc = is_a_kmc(); return isakmc; }
int test_get_device_info() { // Blog: http://blog.csdn.net/fengbingchun/article/details/76902556 int ret = get_device_info(); if (ret != 0) PRINT_ERROR_INFO(get_device_info); return 0; }
void mt_audio_out_util::change_device( int n ){ if( check_availability(n) ){ stream.close(); stream.setDeviceID( n ); current_device_num = n; bool ok = stream.setup(app, out_ch, in_ch, sample_rate, buffer_size, 4); if( ok ){ cout << "Success : sound device connection ;" << n << endl; cout << get_device_info( n ) << endl; }else{ cout << "Error : sound device connection : " << n << endl; cout << get_device_info( n ) << endl; } } }
static GObject * impl_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_properties) { RBGenericPlayerSource *source; RBGenericPlayerSourcePrivate *priv; GMount *mount; char *mount_name; RBShell *shell; GFile *root; GFileInfo *info; GError *error = NULL; source = RB_GENERIC_PLAYER_SOURCE (G_OBJECT_CLASS (rb_generic_player_source_parent_class)-> constructor (type, n_construct_properties, construct_properties)); priv = GENERIC_PLAYER_SOURCE_GET_PRIVATE (source); g_object_get (source, "shell", &shell, NULL); g_object_get (shell, "db", &priv->db, NULL); priv->import_errors = rb_import_errors_source_new (shell, priv->error_type); g_object_unref (shell); g_object_get (source, "mount", &mount, NULL); root = g_mount_get_root (mount); mount_name = g_mount_get_name (mount); info = g_file_query_filesystem_info (root, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY, NULL, &error); if (error != NULL) { rb_debug ("error querying filesystem info for %s: %s", mount_name, error->message); g_error_free (error); priv->read_only = FALSE; } else { priv->read_only = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY); g_object_unref (info); } g_free (mount_name); g_object_unref (root); g_object_unref (mount); priv->folder_depth = -1; /* 0 is a possible value, I guess */ priv->playlist_format_unknown = TRUE; get_device_info (source); load_songs (source); return G_OBJECT (source); }
/* Outputs full scsi device information. * If <filename> is empty, prints long query to STDOUT. * If <filename> is not empty, writes long query to file <filename>. */ int kmc_long_query(char *filename) { int filenamelength; FILE *fp; int status = 0; /* Read device and set global variables for device properties */ get_device_info(); /* Determine destination, open file if necessary, and set file pointer fp */ filenamelength = strlen(filename); if (filenamelength != 0) { fp = fopen(filename,"w"); if (fp < 0) { perror("kmc_long_query(fopen)"); exit(1); } } else fp = stdout; /* Print long query to file or stdout */ fprintf(fp,"Vendor: %.8s\n",vendor); fprintf(fp,"Product: %.16s\n",product); fprintf(fp,"Version: %.4s\n",version); fprintf(fp,"Vendor Inherent: %.20s\n",vendorinherent); fprintf(fp,"Reserved: %.40s\n",reserved); fprintf(fp,"ID Code: %d\n",idcode); fprintf(fp,"Data Version: %d\n",dataversion); fprintf(fp,"Frame X Size: %d\n",hsize); fprintf(fp,"Frame Y Size: %d\n",vsize); fprintf(fp,"Total Number of Frames: %d\n",nframes); fprintf(fp,"Frame Rate(fps): %d\n",fps); fprintf(fp,"Shutter Speed: %d\n",speed); fprintf(fp,"Trigger Flag: %d\n",trigger); fprintf(fp,"Color Flag: %d\n",color); fprintf(fp,"Year: %d\n",year); fprintf(fp,"Month: %d\n",month); fprintf(fp,"Date: %d\n",date); fprintf(fp,"Hour: %d\n",time_hour); fprintf(fp,"Minute: %d\n",time_minute); fprintf(fp,"Second: %d\n",time_second); fprintf(fp,"Session ID: %d\n",sessionid); fprintf(fp,"White Balance: %d\n",balance); /* Close file <filename> if <filename> was specified */ if (filenamelength != 0) { status = fclose(fp); if ( status < 0 ) { perror("kmc:write_gray_image(fclose)"); exit(1); } } return 0; }
const char *get_dc_nickname(const char *model, uint32_t deviceid) { struct device_info *known = get_device_info(model, deviceid); if (known) { if (known->nickname && *known->nickname) return known->nickname; else return known->model; } return NULL; }
static void list_pci_entry( char* dir ) { int error; int vendor_id; int device_id; char vendor[ 16 ]; char device[ 16 ]; /* TODO: Determine revision, subsystem vendor and subsystem device Print them when in debug mode (-v etc.) char revision[ 16 ]; char subsystem_vendor[ 16 ]; char subsystem_device[ 16 ]; */ const char* vendor_name; const char* device_name; vendor_info_t* vendor_info; device_info_t* device_info; error = read_pci_entry_node( dir, "vendor", vendor, sizeof( vendor ) ); if ( error < 0 ) { return; } error = read_pci_entry_node( dir, "device", device, sizeof( device ) ); if ( error < 0 ) { return; } vendor_id = strtol( vendor, NULL, 16 ); device_id = strtol( device, NULL, 16 ); vendor_info = get_vendor_info( vendor_id ); if ( vendor_info == NULL ) { vendor_name = "Unknown vendor"; device_name = "Unknown device"; } else { vendor_name = vendor_info->name; device_info = get_device_info( device_id, vendor_info->device_start, vendor_info->device_count ); if ( device_info == NULL ) { device_name = "Unknown device"; } else { device_name = device_info->name; } } printf( "%s %04x:%04x %s %s\n", dir, vendor_id, device_id, vendor_name, device_name ); }
PADeviceInfo PA::output_device_info() const { PADeviceInfo info; if (is_open() == false) return PADeviceInfo(); bool rv = get_device_info(output_device_idx_, info); if (rv == false) return PADeviceInfo(); return info; }
/* sfs_write_device - デバイスにデータを送る(そしてストレージに書き込む) * */ W sfs_write_device (ID device, B *buf, W start, W length, W *rlength) { DDEV_REQ req; /* 要求パケット */ DDEV_RES res; /* 返答パケット */ ID res_port; W errno; ID send_port; UW dd; errno = get_device_info (device, &send_port, &dd); if (errno) { return (errno); } res_port = get_port (sizeof (res), sizeof (res)); if (res_port <= 0) { return (EP_NOMEM); } if (length > MAX_BODY_SIZE) /* Kludge!! */ { return (EP_INVAL); } req.header.mbfid = res_port; req.header.msgtyp = DEV_WRI; req.body.wri_req.dd = dd; req.body.wri_req.start = start; req.body.wri_req.size = length; bcopy (buf, req.body.wri_req.dt, length); errno = snd_mbf (send_port, sizeof (req), &req); if (errno != E_OK) { dbg_printf ("cannot send packet. %d\n", errno); /* */ del_mbf (res_port); return (EP_NODEV); } *rlength = sizeof (res); errno = rcv_mbf ((UB *)&res, (INT *)rlength, res_port); if (errno != E_OK) { dbg_printf ("cannot send packet. %d\n", errno); /* */ del_mbf (res_port); return (EP_NODEV); } *rlength = res.body.wri_res.a_size; del_mbf (res_port); return (res.body.wri_res.errinfo); }
/* Returns the trigger value. * 0 ==> Start Trigger * 1 ==> Center Trigger * 2 ==> Stop Trigger */ int kmc_get_triggerval() { get_device_info(); /* The following is for TESTING and should be REMOVED. */ // printf("trigger: %d\n",trigger); // trigger = 1; // printf("changed trigger to: %d\n",trigger); /* End region to be REMOVED. */ return trigger; }
/* Returns the number of frames stored in camera */ int kmc_get_nframes() { get_device_info(); /* The following is for TESTING and should be REMOVED. */ // printf("nframes: %d\n",trigger); // nframes = 100; // printf("changed nframes to : %d\n",nframes); /* End region to be REMOVED. */ return nframes; }
int main(int argc, char **argv) { vbfs_init_paramters(); parse_options(argc, argv); if (get_device_info() < 0) return -1; if (vbfs_format_device() < 0) return -1; return 0; }
QByteArray QAudioDeviceInfoInternal::defaultOutputDevice() { AudioDeviceID audioDevice; UInt32 size = sizeof(audioDevice); if (AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &size, &audioDevice) != noErr) { qWarning() << "QAudioDeviceInfo: Unable to find default output device"; return QByteArray(); } return get_device_info(audioDevice, QAudio::AudioOutput); }
const shared_ptr<devices::HardwareDevice> DeviceManager::find_device_from_info( const map<string, string> search_info) { shared_ptr<devices::HardwareDevice> last_resort_dev; map<string, string> dev_info; for (shared_ptr<devices::HardwareDevice> dev : devices_) { assert(dev); dev_info = get_device_info(dev); // If present, vendor and model always have to match. if (dev_info.count("vendor") > 0 && search_info.count("vendor") > 0) if (dev_info.at("vendor") != search_info.at("vendor")) continue; if (dev_info.count("model") > 0 && search_info.count("model") > 0) if (dev_info.at("model") != search_info.at("model")) continue; // Most unique match: vendor/model/serial_num (but don't match a S/N of 0) if ((dev_info.count("serial_num") > 0) && (dev_info.at("serial_num") != "0") && search_info.count("serial_num") > 0) if (dev_info.at("serial_num") == search_info.at("serial_num") && dev_info.at("serial_num") != "0") return dev; // Second best match: vendor/model/connection_id if (dev_info.count("connection_id") > 0 && search_info.count("connection_id") > 0) if (dev_info.at("connection_id") == search_info.at("connection_id")) return dev; // Last resort: vendor/model/version if (dev_info.count("version") > 0 && search_info.count("version") > 0) if (dev_info.at("version") == search_info.at("version") && dev_info.at("version") != "0") return dev; // For this device, we merely have a vendor/model match. last_resort_dev = dev; } // If there wasn't even a vendor/model/version match, we end up here. // This is usually the case for devices with only vendor/model data. // The selected device may be wrong with multiple such devices attached // but it is the best we can do at this point. After all, there may be // only one such device and we do want to select it in this case. return last_resort_dev; }
std::vector<PADeviceInfo> PA::get_device_infos() { int num = get_device_count(); std::vector<PADeviceInfo> infos; for (int i = 0; i < num; ++i) { PADeviceInfo info; if (get_device_info(i, info)) { infos.push_back(info); } } return infos; }
/* * Get info about a v4l device given its device file */ JNIEXPORT void JNICALL Java_au_edu_jcu_v4l4j_DeviceInfo_getInfo(JNIEnv *e, jobject t, jlong v4l4j_device){ dprint(LOG_CALLS, "[CALL] Entering %s\n",__PRETTY_FUNCTION__); struct v4l4j_device *d = (struct v4l4j_device *) (uintptr_t) v4l4j_device; jfieldID name_field; jclass this_class; struct video_device *vd = d->vdev; //get handles on needed java objects this_class = (*e)->GetObjectClass(e,t); if(this_class == NULL){ info("[V4L4J] Error looking up the DeviceInfo class\n"); THROW_EXCEPTION(e, JNI_EXCP, "Error looking up the DeviceInfo class"); return; } name_field = (*e)->GetFieldID(e, this_class, "deviceFile", "Ljava/lang/String;"); if(name_field == NULL){ info("[V4L4J] Error looking up the deviceFile attribute\n"); THROW_EXCEPTION(e, JNI_EXCP, "Error looking up the deviceFile attribute"); return; } dprint(LOG_LIBVIDEO, "[LIBVIDEO] call to get_device_info\n"); //get data from libvideo if(get_device_info(vd)!=NULL){ //fill in values in DeviceInfo object if (getPlatform() == kLinuxPlatform) { dprint(LOG_LIBVIDEO, "[V4L4J] setting device file name to '%s'\n" , vd->id.device_handle); /* set the name field */ (*e)->SetObjectField(e, t, name_field, (*e)->NewStringUTF(e, vd->id.device_handle)); } /* set the inputs field */ dprint(LOG_V4L4J, "[V4L4J] Creating inputInfo objects\n"); create_inputs_object(e, t, this_class, vd); /* set the formats field */ dprint(LOG_V4L4J, "[V4L4J] Creating Format objects\n"); create_formats_object(e, t, this_class, d); } else THROW_EXCEPTION(e, GENERIC_EXCP, "Error getting information from video device"); }
/* Get an existing device info model or create a new one if valid */ struct device_info *create_device_info(const char *model, uint32_t deviceid) { struct device_info *entry; if (!deviceid || !model || !*model) return NULL; entry = get_device_info(model, deviceid); if (entry) return entry; entry = calloc(1, sizeof(*entry)); if (entry) { entry->model = strdup(model); entry->deviceid = deviceid; add_entry_sorted(entry); } return entry; }
status_t devs_ioctl( void* pNode, void* pCookie, uint32 nCommand, void* pArgs, bool bFromKernel ) { switch( nCommand ) { case 0: if( get_device_info( ( DeviceInfo_s* )pArgs, g_nCurrentDev ) != 0 ) { g_nCurrentDev = 0; return( -1 ); } else { g_nCurrentDev++; return( 0 ); } break; default: return( -1 ); } return( -1 ); }
void print_device_names(cl_device_id *devices, cl_uint num) { char *name; int len; cl_uint i; printf("Device names:\n", num); name = NULL; len = 0; for (i = 0; i < num; i++) { get_device_info(devices[i], CL_DEVICE_NAME, &name, &len); printf(" [%d] %s\n", i, name); } if (name != NULL) free(name); }
static int major_from_name(const char *name, mode_t mode) { int i; struct kinfo_drivers *kd; if (kern_drivers == NULL) get_device_info(); kd = kern_drivers; for (i = 0; i < num_drivers; kd++, i++) { if (strcmp(name, kd->d_name)) continue; if (S_ISCHR(mode)) return kd->d_cmajor; return kd->d_bmajor; } return -1; }
static void prvCreatePacket1(internals_t * internP) { // this is the beginning of the session SmlAlertPtr_t alertP; alertP = smlAllocAlert(); if (alertP) { SmlReplacePtr_t replaceP; switch(internP->state) { case STATE_CLIENT_INIT: alertP->data = smlString2Pcdata("1201"); break; case STATE_SERVER_INIT: alertP->data = smlString2Pcdata("1200"); break; default: smlFreeProtoElement((basicElement_t *)alertP); return; } smlFreeItemList(alertP->itemList); alertP->itemList = NULL; replaceP = get_device_info(internP); if (replaceP) { add_element(internP, (basicElement_t *)alertP); add_element(internP, (basicElement_t *)replaceP); internP->state = STATE_IN_SESSION; } else { smlFreeProtoElement((basicElement_t *)alertP); } } }
static void print_device_info(char **names) { int i; struct kinfo_drivers *kd; if (kern_drivers == NULL) get_device_info(); do { kd = kern_drivers; for (i = 0; i < num_drivers; kd++, i++) { if (*names && strcmp(*names, kd->d_name)) continue; printf("%s", kd->d_name); if (kd->d_cmajor != -1) printf(" character major %d", kd->d_cmajor); if (kd->d_bmajor != -1) printf(" block major %d", kd->d_bmajor); printf("\n"); } } while (*names && *++names); }
/* * Open the device, fill out information about it, * allocate and fill private data, start input thread. * Called during initialization, resuming or taking over mastership. */ static DFBResult driver_open_device( InputDevice *device, unsigned int number, InputDeviceInfo *info, void **driver_data ) { int fd; char buf[32]; LinuxInputData *data; snprintf( buf, 32, "/dev/input/event%d", device_nums[number] ); /* open device */ fd = open( buf, O_RDONLY ); if (fd < 0) { PERRORMSG( "DirectFB/linux_input: could not open device" ); return DFB_INIT; } /* fill device info structure */ get_device_info( fd, info ); /* allocate and fill private data */ data = DFBCALLOC( 1, sizeof(LinuxInputData) ); data->fd = fd; data->device = device; /* start input thread */ data->thread = dfb_thread_create( CTT_INPUT, linux_input_EventThread, data ); /* set private data pointer */ *driver_data = data; return DFB_OK; }
int get_frame(int frame) { int nblocks; int blocksize = READ_REPLY_LEN; int blocknumber = 0; unsigned char Readbuffer[ SCSI_OFF + READ_REPLY_LEN ]; unsigned char cmdblk [ READ_CMDLEN ] = { READ_CMD, /* command */ 0, /* lun/reserved */ 0, /* Frame No. (1st byte) */ 0, /* Frame No. (2nd byte) */ 0, /* Frame No. (3rd byte) */ 0, /* Transfer Block No. */ 0, /* reserved */ 0, /* Transfer Data Length (1st byte) */ 0, /* Transfer Data Length (2nd byte) */ 0 }; /* reserved/flag/link */ /* Set the Frame No. */ cmdblk[2] = (frame & 0x00ff0000) >> 16; cmdblk[3] = (frame & 0x0000ff00) >> 8; cmdblk[4] = (frame & 0x000000ff); /* printf("cmdblk[2]: (hex)%x (decimal)%d\n",cmdblk[2],cmdblk[2]); printf("cmdblk[3]: (hex)%x (decimal)%d\n",cmdblk[3],cmdblk[3]); printf("cmdblk[4]: (hex)%x (decimal)%d\n",cmdblk[4],cmdblk[4]); printf("value: %d\n",(long)cmdblk[2]*256*256 + (long)cmdblk[3]*256 + cmdblk[4]); */ /* Set the Transfer Data Length */ cmdblk[7] = (blocksize & 0xff00) >> 8; cmdblk[8] = (blocksize & 0x00ff); /* printf("cmdblk[7]: (hex)%x (decimal)%d\n",cmdblk[7],cmdblk[7]); printf("cmdblk[8]: (hex)%x (decimal)%d\n",cmdblk[8],cmdblk[8]); printf("value: %d\n",(long)cmdblk[7]*256 + cmdblk[8]); */ /* Get the image height and width */ get_device_info(); /* printf("frames sizes is %d by %d\n",hsize,vsize); printf("reading frame %d\n",frame); */ nblocks = 1+hsize*vsize/blocksize; for (blocknumber = 0; blocknumber<nblocks; blocknumber++) { if (blocknumber != nblocks-1) { /* Tranfer Full Sized Block */ /* printf("\nWill get block number: %d\n",blocknumber); printf("Will get full sized block: %d\n",blocksize); printf("Will write to position: %d\n",blocksize*(blocknumber)); */ cmdblk[5] = blocknumber; memcpy( cmd + SCSI_OFF, cmdblk, sizeof(cmdblk) ); if (handle_SCSI_cmd(sizeof(cmdblk), 0, cmd, sizeof(Readbuffer) - SCSI_OFF, Readbuffer )) { fprintf( stderr, "Read failed\n" ); exit(2); } memcpy( imagedata+(blocknumber*blocksize), Readbuffer+SCSI_OFF, blocksize); } else { /* Transfer Partial Sized Block */ blocksize = hsize*vsize-blocksize*(nblocks-1); if (blocksize != 0) { /* printf("get partial sized block: %d\n",blocksize); printf("will write to position: %d\n",blocksize*(blocknumber)); */ cmdblk[7] = (blocksize & 0xff00) >> 8; cmdblk[8] = (blocksize & 0x00ff); cmdblk[5] = blocknumber; memcpy( cmd + SCSI_OFF, cmdblk, sizeof(cmdblk) ); if (handle_SCSI_cmd(sizeof(cmdblk), 0, cmd, sizeof(Readbuffer) - SCSI_OFF, Readbuffer )) { fprintf( stderr, "Read failed\n" ); exit(2); } memcpy( imagedata+((blocknumber)*READ_REPLY_LEN), Readbuffer+SCSI_OFF, blocksize); } } }
/* * This function loads the device_info structure and put them in an array */ static int load_device_info(int fd, struct device_info **device_info_ptr, int *device_info_count) { int ret, i, ndevs, e; struct btrfs_ioctl_fs_info_args fi_args; struct btrfs_ioctl_dev_info_args dev_info; struct device_info *info; *device_info_count = 0; *device_info_ptr = 0; ret = ioctl(fd, BTRFS_IOC_FS_INFO, &fi_args); e = errno; if (e == EPERM) return -e; if (ret < 0) { fprintf(stderr, "ERROR: cannot get filesystem info - %s\n", strerror(e)); return 1; } info = calloc(fi_args.num_devices, sizeof(struct device_info)); if (!info) { fprintf(stderr, "ERROR: not enough memory\n"); return 1; } for (i = 0, ndevs = 0 ; i <= fi_args.max_id ; i++) { BUG_ON(ndevs >= fi_args.num_devices); memset(&dev_info, 0, sizeof(dev_info)); ret = get_device_info(fd, i, &dev_info); if (ret == -ENODEV) continue; if (ret) { fprintf(stderr, "ERROR: cannot get info about device devid=%d\n", i); free(info); return ret; } info[ndevs].devid = dev_info.devid; if (!dev_info.path[0]) { strcpy(info[ndevs].path, "missing"); } else { strcpy(info[ndevs].path, (char *)dev_info.path); info[ndevs].device_size = get_partition_size((char *)dev_info.path); } info[ndevs].size = dev_info.total_bytes; ++ndevs; } BUG_ON(ndevs != fi_args.num_devices); qsort(info, fi_args.num_devices, sizeof(struct device_info), cmp_device_info); *device_info_count = fi_args.num_devices; *device_info_ptr = info; return 0; }
/* For external library use */ int kmc_is_color() { get_device_info(); return color; }
static int ds_ioctl(struct inode * inode, struct file * file, u_int cmd, u_long arg) { socket_t i = MINOR(inode->i_rdev); socket_info_t *s; u_int size; int ret, err; ds_ioctl_arg_t buf; DEBUG(2, "ds_ioctl(socket %d, %#x, %#lx)\n", i, cmd, arg); if ((i >= sockets) || (sockets == 0)) return -ENODEV; s = &socket_table[i]; size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT; if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL; /* Permission check */ if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN)) return -EPERM; if (cmd & IOC_IN) { err = verify_area(VERIFY_READ, (char *)arg, size); if (err) { DEBUG(3, "ds_ioctl(): verify_read = %d\n", err); return err; } } if (cmd & IOC_OUT) { err = verify_area(VERIFY_WRITE, (char *)arg, size); if (err) { DEBUG(3, "ds_ioctl(): verify_write = %d\n", err); return err; } } err = ret = 0; if (cmd & IOC_IN) copy_from_user((char *)&buf, (char *)arg, size); switch (cmd) { case DS_ADJUST_RESOURCE_INFO: ret = CardServices(AdjustResourceInfo, s->handle, &buf.adjust); break; case DS_GET_CARD_SERVICES_INFO: ret = CardServices(GetCardServicesInfo, &buf.servinfo); break; case DS_GET_CONFIGURATION_INFO: ret = CardServices(GetConfigurationInfo, s->handle, &buf.config); break; case DS_GET_FIRST_TUPLE: ret = CardServices(GetFirstTuple, s->handle, &buf.tuple); break; case DS_GET_NEXT_TUPLE: ret = CardServices(GetNextTuple, s->handle, &buf.tuple); break; case DS_GET_TUPLE_DATA: buf.tuple.TupleData = buf.tuple_parse.data; buf.tuple.TupleDataMax = sizeof(buf.tuple_parse.data); ret = CardServices(GetTupleData, s->handle, &buf.tuple); break; case DS_PARSE_TUPLE: buf.tuple.TupleData = buf.tuple_parse.data; ret = CardServices(ParseTuple, s->handle, &buf.tuple, &buf.tuple_parse.parse); break; case DS_RESET_CARD: ret = CardServices(ResetCard, s->handle, NULL); break; case DS_GET_STATUS: ret = CardServices(GetStatus, s->handle, &buf.status); break; case DS_VALIDATE_CIS: ret = CardServices(ValidateCIS, s->handle, &buf.cisinfo); break; case DS_SUSPEND_CARD: ret = CardServices(SuspendCard, s->handle, NULL); break; case DS_RESUME_CARD: ret = CardServices(ResumeCard, s->handle, NULL); break; case DS_EJECT_CARD: ret = CardServices(EjectCard, s->handle, NULL); break; case DS_INSERT_CARD: ret = CardServices(InsertCard, s->handle, NULL); break; case DS_ACCESS_CONFIGURATION_REGISTER: if ((buf.conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) return -EPERM; ret = CardServices(AccessConfigurationRegister, s->handle, &buf.conf_reg); break; case DS_GET_FIRST_REGION: ret = CardServices(GetFirstRegion, s->handle, &buf.region); break; case DS_GET_NEXT_REGION: ret = CardServices(GetNextRegion, s->handle, &buf.region); break; case DS_GET_FIRST_WINDOW: buf.win_info.handle = (window_handle_t)s->handle; ret = CardServices(GetFirstWindow, &buf.win_info.handle, &buf.win_info.window); break; case DS_GET_NEXT_WINDOW: ret = CardServices(GetNextWindow, &buf.win_info.handle, &buf.win_info.window); break; case DS_GET_MEM_PAGE: ret = CardServices(GetMemPage, buf.win_info.handle, &buf.win_info.map); break; case DS_REPLACE_CIS: ret = CardServices(ReplaceCIS, s->handle, &buf.cisdump); break; case DS_BIND_REQUEST: if (!capable(CAP_SYS_ADMIN)) return -EPERM; err = bind_request(i, &buf.bind_info); break; case DS_GET_DEVICE_INFO: err = get_device_info(i, &buf.bind_info, 1); break; case DS_GET_NEXT_DEVICE: err = get_device_info(i, &buf.bind_info, 0); break; case DS_UNBIND_REQUEST: err = unbind_request(i, &buf.bind_info); break; case DS_BIND_MTD: if (!capable(CAP_SYS_ADMIN)) return -EPERM; err = bind_mtd(i, &buf.mtd_info); break; default: err = -EINVAL; } if ((err == 0) && (ret != CS_SUCCESS)) { DEBUG(2, "ds_ioctl: ret = %d\n", ret); switch (ret) { case CS_BAD_SOCKET: case CS_NO_CARD: err = -ENODEV; break; case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ: case CS_BAD_TUPLE: err = -EINVAL; break; case CS_IN_USE: err = -EBUSY; break; case CS_OUT_OF_RESOURCE: err = -ENOSPC; break; case CS_NO_MORE_ITEMS: err = -ENODATA; break; case CS_UNSUPPORTED_FUNCTION: err = -ENOSYS; break; default: err = -EIO; break; } } if (cmd & IOC_OUT) copy_to_user((char *)arg, (char *)&buf, size); return err; } /* ds_ioctl */