static void _bootstrap (ArvUvDevice *uv_device) { ArvDevice *device = ARV_DEVICE (uv_device); guint64 offset; guint32 response_time; guint64 manifest_table_address; guint64 device_capability; guint32 max_cmd_transfer; guint32 max_ack_transfer; guint32 u3vcp_capability; guint64 sirm_offset; guint32 si_info; guint32 si_control; guint64 si_req_payload_size; guint32 si_req_leader_size; guint32 si_req_trailer_size; guint32 si_max_leader_size; guint32 si_payload_size; guint32 si_payload_count; guint32 si_transfer1_size; guint32 si_transfer2_size; guint32 si_max_trailer_size; guint64 manifest_n_entries; ArvUvcpManifestEntry entry; ArvUvcpManifestSchemaType schema_type; GString *string; void *data; char manufacturer[64]; arv_debug_device ("Get genicam"); arv_device_read_memory(device, ARV_ABRM_MANUFACTURER_NAME, 64, &manufacturer, NULL); manufacturer[63] = 0; arv_debug_device ("MANUFACTURER_NAME = '%s'", manufacturer); arv_device_read_memory (device, ARV_ABRM_SBRM_ADDRESS, sizeof (guint64), &offset, NULL); arv_device_read_memory (device, ARV_ABRM_MAX_DEVICE_RESPONSE_TIME, sizeof (guint32), &response_time, NULL); arv_device_read_memory (device, ARV_ABRM_DEVICE_CAPABILITY, sizeof (guint64), &device_capability, NULL); arv_device_read_memory (device, ARV_ABRM_MANIFEST_TABLE_ADDRESS, sizeof (guint64), &manifest_table_address, NULL); arv_debug_device ("MAX_DEVICE_RESPONSE_TIME = 0x%08x", response_time); arv_debug_device ("DEVICE_CAPABILITY = 0x%016lx", device_capability); arv_debug_device ("SRBM_ADDRESS = 0x%016lx", offset); arv_debug_device ("MANIFEST_TABLE_ADDRESS = 0x%016lx", manifest_table_address); uv_device->priv->timeout_ms = MAX (ARV_UVCP_DEFAULT_RESPONSE_TIME_MS, response_time); arv_device_read_memory (device, offset + ARV_SBRM_U3VCP_CAPABILITY, sizeof (guint32), &u3vcp_capability, NULL); arv_device_read_memory (device, offset + ARV_SBRM_MAX_CMD_TRANSFER, sizeof (guint32), &max_cmd_transfer, NULL); arv_device_read_memory (device, offset + ARV_SBRM_MAX_ACK_TRANSFER, sizeof (guint32), &max_ack_transfer, NULL); arv_device_read_memory (device, offset + ARV_SBRM_SIRM_ADDRESS, sizeof (guint64), &sirm_offset, NULL); arv_debug_device ("U3VCP_CAPABILITY = 0x%08x", u3vcp_capability); arv_debug_device ("MAX_CMD_TRANSFER = 0x%08x", max_cmd_transfer); arv_debug_device ("MAX_ACK_TRANSFER = 0x%08x", max_ack_transfer); arv_debug_device ("SIRM_OFFSET = 0x%016lx", sirm_offset); uv_device->priv->cmd_packet_size_max = MIN (uv_device->priv->cmd_packet_size_max, max_cmd_transfer); uv_device->priv->ack_packet_size_max = MIN (uv_device->priv->ack_packet_size_max, max_ack_transfer); arv_device_read_memory (device, sirm_offset + ARV_SI_INFO, sizeof (si_info), &si_info, NULL); arv_device_read_memory (device, sirm_offset + ARV_SI_CONTROL, sizeof (si_control), &si_control, NULL); arv_device_read_memory (device, sirm_offset + ARV_SI_REQ_PAYLOAD_SIZE, sizeof (si_req_payload_size), &si_req_payload_size, NULL); arv_device_read_memory (device, sirm_offset + ARV_SI_REQ_LEADER_SIZE, sizeof (si_req_leader_size), &si_req_leader_size, NULL); arv_device_read_memory (device, sirm_offset + ARV_SI_REQ_TRAILER_SIZE, sizeof (si_req_trailer_size), &si_req_trailer_size, NULL); arv_device_read_memory (device, sirm_offset + ARV_SI_MAX_LEADER_SIZE, sizeof (si_max_leader_size), &si_max_leader_size, NULL); arv_device_read_memory (device, sirm_offset + ARV_SI_PAYLOAD_SIZE, sizeof (si_payload_size), &si_payload_size, NULL); arv_device_read_memory (device, sirm_offset + ARV_SI_PAYLOAD_COUNT, sizeof (si_payload_count), &si_payload_count, NULL); arv_device_read_memory (device, sirm_offset + ARV_SI_TRANSFER1_SIZE, sizeof (si_transfer1_size), &si_transfer1_size, NULL); arv_device_read_memory (device, sirm_offset + ARV_SI_TRANSFER2_SIZE, sizeof (si_transfer2_size), &si_transfer2_size, NULL); arv_device_read_memory (device, sirm_offset + ARV_SI_MAX_TRAILER_SIZE, sizeof (si_max_trailer_size), &si_max_trailer_size, NULL); arv_debug_device ("SI_INFO = 0x%08x", si_info); arv_debug_device ("SI_CONTROL = 0x%08x", si_control); arv_debug_device ("SI_REQ_PAYLOAD_SIZE = 0x%016lx", si_req_payload_size); arv_debug_device ("SI_REQ_LEADER_SIZE = 0x%08x", si_req_leader_size); arv_debug_device ("SI_REQ_TRAILER_SIZE = 0x%08x", si_req_trailer_size); arv_debug_device ("SI_MAX_LEADER_SIZE = 0x%08x", si_max_leader_size); arv_debug_device ("SI_PAYLOAD_SIZE = 0x%08x", si_payload_size); arv_debug_device ("SI_PAYLOAD_COUNT = 0x%08x", si_payload_count); arv_debug_device ("SI_TRANSFER1_SIZE = 0x%08x", si_transfer1_size); arv_debug_device ("SI_TRANSFER2_SIZE = 0x%08x", si_transfer2_size); arv_debug_device ("SI_MAX_TRAILER_SIZE = 0x%08x", si_max_trailer_size); arv_device_read_memory (device, manifest_table_address, sizeof (guint64), &manifest_n_entries, NULL); arv_device_read_memory (device, manifest_table_address + 0x08, sizeof (entry), &entry, NULL); arv_debug_device ("MANIFEST_N_ENTRIES = 0x%016lx", manifest_n_entries); string = g_string_new (""); arv_g_string_append_hex_dump (string, &entry, sizeof (entry)); arv_debug_device ("MANIFEST ENTRY\n%s", string->str); g_string_free (string, TRUE); arv_debug_device ("genicam address = 0x%016lx", entry.address); arv_debug_device ("genicam size = 0x%016lx", entry.size); data = g_malloc0 (entry.size); arv_device_read_memory (device, entry.address, entry.size, data, NULL); #if 0 string = g_string_new (""); arv_g_string_append_hex_dump (string, data, entry.size); arv_debug_device ("GENICAM\n%s", string->str); g_string_free (string, TRUE); #endif schema_type = arv_uvcp_manifest_entry_get_schema_type (&entry); switch (schema_type) { case ARV_UVCP_SCHEMA_ZIP: { ArvZip *zip; const GSList *zip_files; zip = arv_zip_new (data, entry.size); zip_files = arv_zip_get_file_list (zip); if (zip_files != NULL) { const char *zip_filename; zip_filename = arv_zip_file_get_name (zip_files->data); uv_device->priv->genicam_xml = arv_zip_get_file (zip, zip_filename, &uv_device->priv->genicam_xml_size); arv_debug_device ("zip file = %s", zip_filename); #if 0 string = g_string_new (""); arv_g_string_append_hex_dump (string, uv_device->priv->genicam_xml, uv_device->priv->genicam_xml_size); arv_debug_device ("GENICAM\n%s", string->str); g_string_free (string, TRUE); #endif uv_device->priv->genicam = arv_gc_new (ARV_DEVICE (uv_device), uv_device->priv->genicam_xml, uv_device->priv->genicam_xml_size); } arv_zip_free (zip); g_free (data); } break; case ARV_UVCP_SCHEMA_RAW: { uv_device->priv->genicam_xml = data; uv_device->priv->genicam_xml_size = entry.size; uv_device->priv->genicam = arv_gc_new (ARV_DEVICE (uv_device), uv_device->priv->genicam_xml, uv_device->priv->genicam_xml_size); } break; default: arv_warning_device ("Unknown USB3Vision manifest schema type (%d)", schema_type); } #if 0 arv_debug_device("GENICAM\n:%s", uv_device->priv->genicam_xml); #endif }
char * arv_gvcp_packet_to_string (const ArvGvcpPacket *packet) { GString *string; char *c_string; char *data; int packet_size; guint32 value; g_return_val_if_fail (packet != NULL, NULL); string = g_string_new (""); g_string_append_printf (string, "packet_type = %s\n", arv_gvcp_packet_type_to_string (g_ntohs (packet->header.packet_type))); g_string_append_printf (string, "command = %s\n", arv_gvcp_command_to_string (g_ntohs (packet->header.command))); g_string_append_printf (string, "size = %d\n", g_ntohs (packet->header.size)); g_string_append_printf (string, "id = %d\n", g_ntohs (packet->header.id)); data = (char *) &packet->data; switch (g_ntohs (packet->header.command)) { case ARV_GVCP_COMMAND_DISCOVERY_CMD: break; case ARV_GVCP_COMMAND_DISCOVERY_ACK: g_string_append_printf (string, "manufacturer = %s\n", &data[ARV_GVBS_MANUFACTURER_NAME_OFFSET]); g_string_append_printf (string, "name = %s\n", &data[ARV_GVBS_USER_DEFINED_NAME_OFFSET]); g_string_append_printf (string, "model = %s\n", &data[ARV_GVBS_MODEL_NAME_OFFSET]); g_string_append_printf (string, "address = %d.%d.%d.%d\n", data[ARV_GVBS_CURRENT_IP_ADDRESS_OFFSET] & 0xff, data[ARV_GVBS_CURRENT_IP_ADDRESS_OFFSET + 1] & 0xff, data[ARV_GVBS_CURRENT_IP_ADDRESS_OFFSET + 2] & 0xff, data[ARV_GVBS_CURRENT_IP_ADDRESS_OFFSET + 3] & 0xff); break; case ARV_GVCP_COMMAND_WRITE_REGISTER_CMD: value = g_ntohl (*((guint32 *) &data[0])); g_string_append_printf (string, "address = %10u (0x%08x)\n", value, value); value = g_ntohl (*((guint32 *) &data[4])); g_string_append_printf (string, "value = %10u (0x%08x)\n", value, value); break; case ARV_GVCP_COMMAND_READ_REGISTER_CMD: value = g_ntohl (*((guint32 *) &data[0])); g_string_append_printf (string, "address = %10u (0x%08x)\n", value, value); break; case ARV_GVCP_COMMAND_READ_REGISTER_ACK: value = g_ntohl (*((guint32 *) &data[0])); g_string_append_printf (string, "success = %10u (0x%08x)\n", value, value); break; case ARV_GVCP_COMMAND_READ_MEMORY_CMD: value = g_ntohl (*((guint32 *) &data[0])); g_string_append_printf (string, "address = %10u (0x%08x)\n", value, value); value = g_ntohl (*((guint32 *) &data[4])); g_string_append_printf (string, "size = %10u (0x%08x)\n", value, value); break; case ARV_GVCP_COMMAND_READ_MEMORY_ACK: value = g_ntohl (*((guint32 *) &data[0])); g_string_append_printf (string, "address = %10u (0x%08x)\n", value, value); break; } packet_size = sizeof (ArvGvcpHeader) + g_ntohs (packet->header.size); arv_g_string_append_hex_dump (string, packet, packet_size); c_string = string->str; g_string_free (string, FALSE); return c_string; }
char * arv_uvcp_packet_to_string (const ArvUvcpPacket *packet) { GString *string; char *c_string; int packet_size; guint32 value; g_return_val_if_fail (packet != NULL, NULL); string = g_string_new (""); g_string_append_printf (string, "packet_type = %s\n", arv_uvcp_packet_type_to_string (GUINT16_FROM_LE (packet->header.packet_type))); g_string_append_printf (string, "command = %s\n", arv_uvcp_command_to_string (GUINT16_FROM_LE (packet->header.command))); g_string_append_printf (string, "size = %d\n", GUINT16_FROM_LE (packet->header.size)); g_string_append_printf (string, "id = %d\n", GUINT16_FROM_LE (packet->header.id)); switch (GUINT16_FROM_LE (packet->header.command)) { case ARV_UVCP_COMMAND_READ_MEMORY_CMD: { ArvUvcpReadMemoryCmd *cmd_packet = (void *) packet; value = GUINT64_FROM_LE (cmd_packet->infos.address); g_string_append_printf (string, "address = %10u (0x%08x)\n", value, value); value = GUINT16_FROM_LE (cmd_packet->infos.size); g_string_append_printf (string, "size = %10u (0x%08x)\n", value, value); break; } case ARV_UVCP_COMMAND_READ_MEMORY_ACK: { break; } case ARV_UVCP_COMMAND_WRITE_MEMORY_CMD: { ArvUvcpWriteMemoryCmd *cmd_packet = (void *) packet; value = GUINT64_FROM_LE (cmd_packet->infos.address); g_string_append_printf (string, "address = %10u (0x%08x)\n", value, value); } case ARV_UVCP_COMMAND_WRITE_MEMORY_ACK: { ArvUvcpWriteMemoryAck *cmd_packet = (void *) packet; value = GUINT64_FROM_LE (cmd_packet->infos.bytes_written); g_string_append_printf (string, "written = %10u (0x%08x)\n", value, value); } } packet_size = sizeof (ArvUvcpHeader) + GUINT16_FROM_LE (packet->header.size); arv_g_string_append_hex_dump (string, packet, packet_size); c_string = string->str; g_string_free (string, FALSE); return c_string; }
static char * _load_genicam (ArvGvDevice *gv_device, guint32 address, size_t *size) { char filename[ARV_GVBS_XML_URL_SIZE]; char **tokens; char *genicam = NULL; g_return_val_if_fail (size != NULL, NULL); *size = 0; if (!arv_device_read_memory (ARV_DEVICE (gv_device), address, ARV_GVBS_XML_URL_SIZE, filename, NULL)) return NULL; filename[ARV_GVBS_XML_URL_SIZE - 1] = '\0'; arv_debug_device ("[GvDevice::load_genicam] xml url = '%s' at 0x%x", filename, address); tokens = g_regex_split (arv_gv_device_get_url_regex (), filename, 0); if (tokens[0] != NULL) { if (g_strcmp0 (tokens[1], "File:") == 0) g_file_get_contents (filename, &genicam, NULL, NULL); else if (g_strcmp0 (tokens[1], "Local:") == 0 && tokens[2] != NULL && tokens[3] != NULL && tokens[4] != NULL) { guint32 file_address; guint32 file_size; file_address = strtoul (tokens[3], NULL, 16); file_size = strtoul (tokens[4], NULL, 16); arv_debug_device ("[GvDevice::load_genicam] Xml address = 0x%x - size = 0x%x - %s", file_address, file_size, tokens[2]); if (file_size > 0) { genicam = g_malloc (file_size); if (arv_device_read_memory (ARV_DEVICE (gv_device), file_address, file_size, genicam, NULL)) { if (arv_debug_check (&arv_debug_category_misc, ARV_DEBUG_LEVEL_LOG)) { GString *string = g_string_new (""); g_string_append_printf (string, "[GvDevice::load_genicam] Raw data size = 0x%x\n", file_size); arv_g_string_append_hex_dump (string, genicam, file_size); arv_log_misc ("%s", string->str); g_string_free (string, TRUE); } if (g_str_has_suffix (tokens[2], ".zip")) { ArvZip *zip; const GSList *zip_files; arv_debug_device ("[GvDevice::load_genicam] Zipped xml data"); zip = arv_zip_new (genicam, file_size); zip_files = arv_zip_get_file_list (zip); if (zip_files != NULL) { const char *zip_filename; void *tmp_buffer; size_t tmp_buffer_size; zip_filename = arv_zip_file_get_name (zip_files->data); tmp_buffer = arv_zip_get_file (zip, zip_filename, &tmp_buffer_size); g_free (genicam); file_size = tmp_buffer_size; genicam = tmp_buffer; } else arv_warning_device ("[GvDevice::load_genicam] Invalid format"); arv_zip_free (zip); } *size = file_size; } else { g_free (genicam); genicam = NULL; *size = 0; } } } } g_strfreev (tokens); return genicam; }