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 */
