/system/core/init/ |
H A D | devices.cpp | 51 /* Given a path that may start with a PCI device, populate the supplied buffer 53 * If it doesn't start with a PCI device, or there is some error, return -1 */ 81 /* Given a path that may start with a virtual block device, populate 82 * the supplied buffer with the virtual block device ID and return 0. 83 * If it doesn't start with a virtual block device, or there is some 94 virtual block device ID. Example: 768 */ 161 // Given a path that may start with a platform device, find the parent platform device by finding a 163 // If it doesn't start with a platform device, return false 239 * device nod 295 std::string device; local 320 LOG(VERBOSE) << "found " << type << " device " << device; local [all...] |
/system/core/libdiskconfig/include/diskconfig/ |
H A D | diskconfig.h | 90 char *device; member in struct:disk_info
|
/system/core/trusty/keymaster/ |
H A D | trusty_keymaster_device_test.cpp | 67 static int fake_call(keymaster::AndroidKeymaster* device, argument 74 (device->*method)(req, &rsp); 113 TrustyKeymasterTest() : device(NULL) {} 142 TrustyKeymasterDevice device; member in class:keymaster::test::TrustyKeymasterTest 159 ASSERT_EQ(0, device.generate_keypair(TYPE_RSA, ¶ms, &ptr, &size)); 168 ASSERT_EQ(0, device.generate_keypair(TYPE_EC, &ec_params, &ptr, &size)); 178 ASSERT_EQ(0, device.generate_keypair(TYPE_RSA, ¶ms, &ptr, &size)); 187 EXPECT_EQ(KM_ERROR_OK, device.sign_data(&sig_params, ptr, size, message.get(), message_len, 197 ASSERT_EQ(0, device.generate_keypair(TYPE_RSA, ¶ms, &ptr, &size)); 206 EXPECT_EQ(KM_ERROR_UNKNOWN_ERROR, device [all...] |
/system/core/trusty/storage/lib/ |
H A D | storage.c | 127 int storage_open_session(const char *device, storage_session_t *session_p, argument 130 int rc = tipc_connect(device, port);
|
/system/keymaster/contexts/ |
H A D | keymaster1_passthrough_context.cpp | 110 static keymaster_error_t parseKeymaster1HwBlob(const keymaster1_device_t* device, argument 127 keymaster_error_t error = device->get_key_characteristics(device, &blob, client_id_ptr, 159 error = parseKeymaster1HwBlob(km1_engine_->device(), blob, additional_params, 177 // HACK. Due to a bug with Qualcomm's Keymaster implementation, which causes the device to
|
/system/keymaster/legacy_support/ |
H A D | keymaster_passthrough_engine.cpp | 44 * The engine takes ownership of the device, and will close it during destruction. 78 // QUIRK: we only take ownership if this is a KM2 device. 178 const KeymasterDeviceType* device() const { return km_device_; } function in class:keymaster::TKeymasterPassthroughEngine
|
/system/nvram/client/ |
H A D | nvram_client.c | 101 static int HandleGetTotalSize(nvram_device_t* device, char* args[]) { argument 104 nvram_result_t result = device->get_total_size_in_bytes(device, &total_size); 113 static int HandleGetAvailableSize(nvram_device_t* device, char* args[]) { argument 117 device->get_available_size_in_bytes(device, &available_size); 126 static int HandleGetMaxSpaceSize(nvram_device_t* device, char* args[]) { argument 130 device->get_max_space_size_in_bytes(device, &max_space_size); 139 static int HandleGetMaxSpaces(nvram_device_t* device, cha argument 151 HandleGetSpaceList(nvram_device_t* device, char* args[]) argument 183 HandleGetSpaceSize(nvram_device_t* device, char* args[]) argument 195 HandleGetSpaceControls(nvram_device_t* device, char* args[]) argument 233 HandleIsSpaceReadLocked(nvram_device_t* device, char* args[]) argument 247 HandleIsSpaceWriteLocked(nvram_device_t* device, char* args[]) argument 261 HandleCreateSpace(nvram_device_t* device, char* args[]) argument 288 HandleDeleteSpace(nvram_device_t* device, char* args[]) argument 294 HandleDisableCreate(nvram_device_t* device, char* args[]) argument 299 HandleWriteSpace(nvram_device_t* device, char* args[]) argument 305 HandleReadSpace(nvram_device_t* device, char* args[]) argument 331 HandleEnableWriteLock(nvram_device_t* device, char* args[]) argument 337 HandleEnableReadLock(nvram_device_t* device, char* args[]) argument [all...] |
/system/keymaster/tests/ |
H A D | android_keymaster_test_utils.h | 184 keymaster2_device_t* device(); 352 explicit Keymaster0CountingWrapper(keymaster0_device_t* device) : device_(device), counter_(0) { argument 385 static keymaster0_device_t* device(const keymaster0_device_t* dev) { function in struct:keymaster::test::Keymaster0CountingWrapper 412 int result = device(dev)->generate_keypair(device(dev), key_type, key_params, key_blob, 424 device(dev)->import_keypair(device(dev), key, key_length, key_blob, key_blob_length); 435 return device(dev)->get_keypair_public(device(de [all...] |
H A D | android_keymaster_test_utils.cpp | 190 keymaster2_device_t* Keymaster2Test::device() { function in class:keymaster::test::Keymaster2Test 201 return device()->generate_key(device(), ¶ms, &blob_, &characteristics_); 205 return device()->delete_key(device(), &blob_); 219 return device()->import_key(device(), ¶ms, format, &key, &blob_, &characteristics_); 240 device()->begin(device(), purpose, &blob_, &in_params, &out_params, &op_handle_); 251 device() 922 make_device_sha256_only(keymaster1_device_t* device) argument [all...] |
H A D | android_keymaster_test.cpp | 116 std::cerr << "Creating software-only device" << std::endl; 118 SoftKeymasterDevice* device = new SoftKeymasterDevice(context_); variable 122 device->keymaster2_device()->configure(device->keymaster2_device(), &version_info); 123 return device->keymaster2_device(); 142 std::cerr << "Creating keymaster1-backed device that supports only SHA256"; 144 // fake_device doesn't leak because device (below) takes ownership of it. 148 // device doesn't leak; it's cleaned up by device->keymaster_device()->common.close(). 150 SoftKeymasterDevice* device variable 185 SoftKeymasterDevice* device = new SoftKeymasterDevice(context_); variable [all...] |
/system/media/alsa_utils/ |
H A D | alsa_device_profile.c | 51 quality and driver instability (depends on device). 52 The order here determines the default sample rate for the device. 57 requires opening the device which may cause pops. */ 63 profile->card = profile->device = -1; 84 return profile->card >= 0 && profile->device >= 0; 91 bool profile_is_cached_for(const alsa_device_profile* profile, int card, int device) { argument 92 return card == profile->card && device == profile->device; 225 struct pcm * pcm = pcm_open(profile->card, profile->device, 310 ALOGW("usb device doe [all...] |
/system/nvram/hal/ |
H A D | nvram_device_adapter.cpp | 28 // Executes an operation on the |NvramDeviceAdapter| corresponding to |device|. 35 nvram_result_t Execute(const nvram_device_t* device, argument 39 const_cast<nvram_device_t*>(device)); 61 nvram_result_t device_get_total_size_in_bytes(const nvram_device_t* device, argument 66 device, std::move(get_info_request), &get_info_response); 71 nvram_result_t device_get_available_size_in_bytes(const nvram_device_t* device, argument 76 device, std::move(get_info_request), &get_info_response); 81 nvram_result_t device_get_max_space_size_in_bytes(const nvram_device_t* device, argument 86 device, std::move(get_info_request), &get_info_response); 91 nvram_result_t device_get_max_spaces(const nvram_device_t* device, argument 101 device_get_space_list(const nvram_device_t* device, uint32_t max_list_size, uint32_t* space_index_list, uint32_t* list_size) argument 123 device_get_space_size(const nvram_device_t* device, uint32_t index, uint64_t* size) argument 135 device_get_space_controls(const nvram_device_t* device, uint32_t index, uint32_t max_list_size, nvram_control_t* control_list, uint32_t* list_size) argument 159 device_is_space_locked(const nvram_device_t* device, uint32_t index, int* write_lock_enabled, int* read_lock_enabled) argument 173 device_create_space(const nvram_device_t* device, uint32_t index, uint64_t size_in_bytes, const nvram_control_t* control_list, uint32_t list_size, const uint8_t* authorization_value, uint32_t authorization_value_size) argument 198 device_delete_space(const nvram_device_t* device, uint32_t index, const uint8_t* authorization_value, uint32_t authorization_value_size) argument 213 device_disable_create(const nvram_device_t* device) argument 220 device_write_space(const nvram_device_t* device, uint32_t index, const uint8_t* buffer, uint64_t buffer_size, const uint8_t* authorization_value, uint32_t authorization_value_size) argument 238 device_read_space(const nvram_device_t* device, uint32_t index, uint64_t num_bytes_to_read, const uint8_t* authorization_value, uint32_t authorization_value_size, uint8_t* buffer, uint64_t* bytes_read) argument 260 device_enable_write_lock(const nvram_device_t* device, uint32_t index, const uint8_t* authorization_value, uint32_t authorization_value_size) argument 275 device_enable_read_lock(const nvram_device_t* device, uint32_t index, const uint8_t* authorization_value, uint32_t authorization_value_size) argument 290 device_nvram_device_close(struct hw_device_t* device) argument [all...] |
/system/core/adb/client/ |
H A D | usb_libusb.cpp | 156 static std::string get_device_address(libusb_device* device) { argument 157 return StringPrintf("usb:%d:%d", libusb_get_bus_number(device), 158 libusb_get_device_address(device)); 162 static std::string get_device_serial_path(libusb_device* device) { argument 164 int port_count = libusb_get_port_numbers(device, ports, 7); 168 StringPrintf("/sys/bus/usb/devices/%d-%d", libusb_get_bus_number(device), ports[0]); 176 static std::string get_device_dev_path(libusb_device* device) { argument 178 int port_count = libusb_get_port_numbers(device, ports, 7); 180 return StringPrintf("/dev/bus/usb/%03u/%03u", libusb_get_bus_number(device), ports[0]); 193 static void process_device(libusb_device* device) { argument 391 device_connected(libusb_device* device) argument 412 device_disconnected(libusb_device* device) argument 450 hotplug_callback(libusb_context*, libusb_device* device, libusb_hotplug_event event, void*) argument [all...] |
H A D | usb_linux.cpp | 96 // set mark flag to indicate this device is still alive 106 // kick any devices in the device list that were not found in the device scan 143 struct usb_device_descriptor* device; local 166 // should have device and configuration descriptors, and atleast two endpoints 173 device = (struct usb_device_descriptor*)bufptr; 176 if((device->bLength != USB_DT_DEVICE_SIZE) || (device->bDescriptorType != USB_DT_DEVICE)) { 181 vid = device->idVendor; 182 pid = device [all...] |
/system/core/toolbox/ |
H A D | getevent.c | 312 static int open_device(const char *device, int print_flags) argument 324 fd = open(device, O_RDWR); 327 fprintf(stderr, "could not open %s, %s\n", device, strerror(errno)); 333 fprintf(stderr, "could not get driver version for %s, %s\n", device, strerror(errno)); 338 fprintf(stderr, "could not get driver id for %s, %s\n", device, strerror(errno)); 345 //fprintf(stderr, "could not get device name for %s, %s\n", device, strerror(errno)); 349 //fprintf(stderr, "could not get location for %s, %s\n", device, strerror(errno)); 353 //fprintf(stderr, "could not get idstring for %s, %s\n", device, strerror(errno)); 376 printf("add device 411 close_device(const char *device, int print_flags) argument 530 const char *device = NULL; local [all...] |
/system/vold/ |
H A D | VolumeManager.cpp | 127 dev_t device = mVirtualDisk->getDevice(); local 128 handleDiskRemoved(device); 192 dev_t device = makedev(major, minor); local 211 auto disk = new android::vold::Disk(eventPath, device, 221 handleDiskChanged(device); 225 handleDiskRemoved(device); 237 // until the user unlocks the device to actually touch it 248 void VolumeManager::handleDiskChanged(dev_t device) { argument 250 if (disk->getDevice() == device) { 257 // we'll scan them once the device i 260 handleDiskRemoved(dev_t device) argument [all...] |
/system/vold/model/ |
H A D | Disk.cpp | 93 * MMC-based SD card device; instead, it emulates SD cards with virtio-blk, 95 * Unfortunately, the virtio-blk block device driver does not use a fixed 105 * b) If the major number is an experimental block device major number (for 110 * "ranchu", the device's sysfs path should end with "/block/vd[d-z]", etc. 117 Disk::Disk(const std::string& eventPath, dev_t device, argument 119 mDevice(device), mSize(-1), mNickname(nickname), mFlags(flags), mCreated( 121 mId = StringPrintf("disk:%u,%u", major(device), minor(device)); 178 void Disk::createPublicVolume(dev_t device) { argument 179 auto vol = std::shared_ptr<VolumeBase>(new PublicVolume(device)); 194 createPrivateVolume(dev_t device, const std::string& partGuid) argument [all...] |
/system/sepolicy/ |
H A D | Android.mk | 48 # build process for device: 274 # sepolicy_policy.conf - All of the policy for the device. This is only used to 385 # which will ship with the device. The platform will always reflect the most 769 # CTS checks neverallow rules of this policy against the policy of the device under test. 806 # 2. Collect all device specific file_contexts files and process them with m4 807 # into a tmp file called file_contexts.device.tmp. 808 # 3. Run checkfc -e (allow no device fc entries ie empty) and fc_sort on 809 # file_contexts.device.tmp and output to file_contexts.device.sorted.tmp. 810 # 4. Concatenate file_contexts.local.tmp and file_contexts.device [all...] |
/system/bt/bta/hearing_aid/ |
H A D | hearing_aid.cc | 24 #include "device/include/controller.h" 114 * device */ 117 /* we are making active attempt to connect to this device, 'direct connect'. 123 * are far from each other. This flag means that this device is waiting for 178 /* return true if this device represents left Hearing Aid. Returned value is 185 void Add(HearingDevice device) { argument 186 if (FindByAddress(device.address) != nullptr) return; 188 devices.push_back(device); 205 [&address](const HearingDevice& device) { 206 return device 731 SendStart(const HearingDevice& device) argument [all...] |
/system/core/libusbhost/ |
H A D | usbhost.c | 203 D("Created device discovery thread\n"); 290 D("new device %s\n", path); 293 D("gone device %s\n", path); 330 /* Hack around waiting for permissions to be set on the USB device node. 364 void usb_device_close(struct usb_device *device) argument 366 close(device->fd); 367 free(device); 372 struct usb_device *device = calloc(1, sizeof(struct usb_device)); local 379 length = read(fd, device->desc, sizeof(device 399 usb_device_reopen_writeable(struct usb_device *device) argument 415 usb_device_get_fd(struct usb_device *device) argument 422 usb_device_get_name(struct usb_device *device) argument 427 usb_device_get_unique_id(struct usb_device *device) argument 450 usb_device_get_vendor_id(struct usb_device *device) argument 456 usb_device_get_product_id(struct usb_device *device) argument 462 usb_device_get_device_descriptor(struct usb_device* device) argument 466 usb_device_get_descriptors_length(const struct usb_device* device) argument 470 usb_device_get_raw_descriptors(const struct usb_device* device) argument 488 usb_device_get_string_ucs2(struct usb_device* device, int id, int timeout, void** ucs2_out, size_t* response_size) argument 537 usb_device_get_string(struct usb_device* device, int id, int timeout) argument 558 usb_device_get_manufacturer_name(struct usb_device *device, int timeout) argument 564 usb_device_get_product_name(struct usb_device *device, int timeout) argument 570 usb_device_get_version(struct usb_device *device) argument 576 usb_device_get_serial(struct usb_device *device, int timeout) argument 582 usb_device_is_writeable(struct usb_device *device) argument 587 usb_descriptor_iter_init(struct usb_device *device, struct usb_descriptor_iter *iter) argument 604 usb_device_claim_interface(struct usb_device *device, unsigned int interface) argument 609 usb_device_release_interface(struct usb_device *device, unsigned int interface) argument 614 usb_device_connect_kernel_driver(struct usb_device *device, unsigned int interface, int connect) argument 625 usb_device_set_configuration(struct usb_device *device, int configuration) argument 630 usb_device_set_interface(struct usb_device *device, unsigned int interface, unsigned int alt_setting) argument 640 usb_device_control_transfer(struct usb_device *device, int requestType, int request, int value, int index, void* buffer, int length, unsigned int timeout) argument 666 usb_device_bulk_transfer(struct usb_device *device, int endpoint, void* buffer, unsigned int length, unsigned int timeout) argument 682 usb_device_reset(struct usb_device *device) argument [all...] |
/system/update_engine/payload_generator/ |
H A D | delta_diff_utils.cc | 790 // the puffing on the client device. 918 bool IsExtFilesystem(const string& device) { argument 924 device, 0, SUPERBLOCK_OFFSET + SUPERBLOCK_SIZE, &header) ||
|
/system/bt/audio_a2dp_hw/src/ |
H A D | audio_a2dp_hw.cc | 23 * Description: Implements hal for bluedroid a2dp audio device 104 // Important: device must be first as an audio_hw_device* may be cast to 106 struct audio_hw_device device; member in struct:a2dp_audio_device 1870 static int adev_dump(UNUSED_ATTR const audio_hw_device_t* device, argument 1877 static int adev_close(hw_device_t* device) { argument 1878 struct a2dp_audio_device* a2dp_dev = (struct a2dp_audio_device*)device; 1883 free(device); 1888 hw_device_t** device) { 1905 adev->device.common.tag = HARDWARE_DEVICE_TAG; 1906 adev->device 1887 adev_open(const hw_module_t* module, const char* name, hw_device_t** device) argument [all...] |
/system/bt/audio_hearing_aid_hw/src/ |
H A D | audio_hearing_aid_hw.cc | 19 /* Implements hal for bluedroid ha audio device */ 91 // Important: device must be first as an audio_hw_device* may be cast to 93 struct audio_hw_device device; member in struct:ha_audio_device 1811 static int adev_dump(UNUSED_ATTR const audio_hw_device_t* device, argument 1818 static int adev_close(hw_device_t* device) { argument 1819 struct ha_audio_device* ha_dev = (struct ha_audio_device*)device; 1824 free(device); 1829 hw_device_t** device) { 1846 adev->device.common.tag = HARDWARE_DEVICE_TAG; 1847 adev->device 1828 adev_open(const hw_module_t* module, const char* name, hw_device_t** device) argument [all...] |
/system/bt/btif/src/ |
H A D | btif_rc.cc | 48 #include "device/include/interop.h" 217 rc_device_t device; variable 411 BTIF_TRACE_ERROR("%s: device not found, returning NULL!", __func__); 653 /* report connection state if remote device is AVRCP target */ 677 BTIF_TRACE_ERROR("Got disconnect of unknown device"); 680 /* report connection state if device is AVRCP target */ 697 /* check if there is another device connected */ 1155 ** which causes the audio to be on th device's speaker. Delay between 1903 BTIF_TRACE_ERROR("%s: Avrcp device is not connected, handle: 0x%x", 2662 // Just discard the message, if the device send [all...] |
/system/core/logcat/ |
H A D | logcat.cpp | 61 const char* device; member in struct:log_device_t 70 device = d; 365 dev->printed ? "switch to" : "beginning of", dev->device); 1121 if (!strcmp(name, dev->device)) { 1205 // in an emulated device only. It basically looks for 1445 android_name_to_log_id(dev->device)); 1447 reportErrorName(&openDeviceFail, dev->device, allSelected); 1472 reportErrorName(&clearFail, dev->device, allSelected); 1480 reportErrorName(&clearFail, dev->device, allSelected); 1484 reportErrorName(&clearFail, dev->device, allSelecte [all...] |