Lines Matching full:rp
360 struct mgmt_rp_read_version *rp = ver;
362 rp->version = MGMT_VERSION;
363 rp->revision = cpu_to_le16(MGMT_REVISION);
369 struct mgmt_rp_read_version rp;
373 mgmt_fill_version_info(&rp);
376 &rp, sizeof(rp));
382 struct mgmt_rp_read_commands *rp;
397 rp_size = sizeof(*rp) + ((num_commands + num_events) * sizeof(u16));
399 rp = kmalloc(rp_size, GFP_KERNEL);
400 if (!rp)
403 rp->num_commands = cpu_to_le16(num_commands);
404 rp->num_events = cpu_to_le16(num_events);
407 __le16 *opcode = rp->opcodes;
415 __le16 *opcode = rp->opcodes;
425 rp, rp_size);
426 kfree(rp);
434 struct mgmt_rp_read_index_list *rp;
450 rp_len = sizeof(*rp) + (2 * count);
451 rp = kmalloc(rp_len, GFP_ATOMIC);
452 if (!rp) {
471 rp->index[count++] = cpu_to_le16(d->id);
476 rp->num_controllers = cpu_to_le16(count);
477 rp_len = sizeof(*rp) + (2 * count);
482 0, rp, rp_len);
484 kfree(rp);
492 struct mgmt_rp_read_unconf_index_list *rp;
508 rp_len = sizeof(*rp) + (2 * count);
509 rp = kmalloc(rp_len, GFP_ATOMIC);
510 if (!rp) {
529 rp->index[count++] = cpu_to_le16(d->id);
534 rp->num_controllers = cpu_to_le16(count);
535 rp_len = sizeof(*rp) + (2 * count);
540 MGMT_OP_READ_UNCONF_INDEX_LIST, 0, rp, rp_len);
542 kfree(rp);
550 struct mgmt_rp_read_ext_index_list *rp;
563 rp = kmalloc(struct_size(rp, entry, count), GFP_ATOMIC);
564 if (!rp) {
583 rp->entry[count].type = 0x01;
585 rp->entry[count].type = 0x00;
587 rp->entry[count].bus = d->bus;
588 rp->entry[count++].index = cpu_to_le16(d->id);
592 rp->num_controllers = cpu_to_le16(count);
605 MGMT_OP_READ_EXT_INDEX_LIST, 0, rp,
606 struct_size(rp, entry, count));
608 kfree(rp);
662 struct mgmt_rp_read_config_info rp;
669 memset(&rp, 0, sizeof(rp));
670 rp.manufacturer = cpu_to_le16(hdev->manufacturer);
678 rp.supported_options = cpu_to_le32(options);
679 rp.missing_options = get_missing_options(hdev);
684 &rp, sizeof(rp));
1140 struct mgmt_rp_read_info rp;
1146 memset(&rp, 0, sizeof(rp));
1148 bacpy(&rp.bdaddr, &hdev->bdaddr);
1150 rp.version = hdev->hci_ver;
1151 rp.manufacturer = cpu_to_le16(hdev->manufacturer);
1153 rp.supported_settings = cpu_to_le32(get_supported_settings(hdev));
1154 rp.current_settings = cpu_to_le32(get_current_settings(hdev));
1156 memcpy(rp.dev_class, hdev->dev_class, 3);
1158 memcpy(rp.name, hdev->dev_name, sizeof(hdev->dev_name));
1159 memcpy(rp.short_name, hdev->short_name, sizeof(hdev->short_name));
1163 return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_READ_INFO, 0, &rp,
1164 sizeof(rp));
1195 struct mgmt_rp_read_ext_info *rp = (void *)buf;
1204 bacpy(&rp->bdaddr, &hdev->bdaddr);
1206 rp->version = hdev->hci_ver;
1207 rp->manufacturer = cpu_to_le16(hdev->manufacturer);
1209 rp->supported_settings = cpu_to_le32(get_supported_settings(hdev));
1210 rp->current_settings = cpu_to_le32(get_current_settings(hdev));
1213 eir_len = append_eir_data_to_buf(hdev, rp->eir);
1214 rp->eir_len = cpu_to_le16(eir_len);
1227 return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_READ_EXT_INFO, 0, rp,
1228 sizeof(*rp) + eir_len);
2275 struct mgmt_rp_mesh_read_features *rp = data;
2277 if (rp->used_handles >= rp->max_handles)
2280 rp->handles[rp->used_handles++] = mesh_tx->handle;
2286 struct mgmt_rp_mesh_read_features rp;
2293 memset(&rp, 0, sizeof(rp));
2294 rp.index = cpu_to_le16(hdev->id);
2296 rp.max_handles = MESH_HANDLES_MAX;
2300 if (rp.max_handles)
2301 mgmt_mesh_foreach(hdev, send_count, &rp, sk);
2303 mgmt_cmd_complete(sk, hdev->id, MGMT_OP_MESH_READ_FEATURES, 0, &rp,
2304 rp.used_handles + sizeof(rp) - MESH_HANDLES_MAX);
2375 struct mgmt_rp_mesh_read_features rp;
2391 memset(&rp, 0, sizeof(rp));
2392 rp.max_handles = MESH_HANDLES_MAX;
2394 mgmt_mesh_foreach(hdev, send_count, &rp, sk);
2396 if (rp.max_handles <= rp.used_handles) {
2947 struct mgmt_rp_unpair_device rp;
2954 memset(&rp, 0, sizeof(rp));
2955 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
2956 rp.addr.type = cp->addr.type;
2961 &rp, sizeof(rp));
2966 &rp, sizeof(rp));
2972 MGMT_STATUS_NOT_POWERED, &rp,
2973 sizeof(rp));
2995 MGMT_STATUS_NOT_PAIRED, &rp,
2996 sizeof(rp));
3010 MGMT_STATUS_NOT_PAIRED, &rp,
3011 sizeof(rp));
3048 &rp, sizeof(rp));
3108 struct mgmt_rp_disconnect rp;
3114 memset(&rp, 0, sizeof(rp));
3115 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
3116 rp.addr.type = cp->addr.type;
3121 &rp, sizeof(rp));
3127 MGMT_STATUS_NOT_POWERED, &rp,
3128 sizeof(rp));
3173 struct mgmt_rp_get_connections *rp;
3194 rp = kmalloc(struct_size(rp, addr, i), GFP_KERNEL);
3195 if (!rp) {
3204 bacpy(&rp->addr[i].bdaddr, &c->dst);
3205 rp->addr[i].type = link_to_bdaddr(c->type, c->dst_type);
3211 rp->conn_count = cpu_to_le16(i);
3214 err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_CONNECTIONS, 0, rp,
3215 struct_size(rp, addr, i));
3217 kfree(rp);
3350 struct mgmt_rp_pair_device rp;
3354 bacpy(&rp.addr.bdaddr, &conn->dst);
3355 rp.addr.type = link_to_bdaddr(conn->type, conn->dst_type);
3358 status, &rp, sizeof(rp));
3428 struct mgmt_rp_pair_device rp;
3436 memset(&rp, 0, sizeof(rp));
3437 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
3438 rp.addr.type = cp->addr.type;
3443 &rp, sizeof(rp));
3448 &rp, sizeof(rp));
3454 MGMT_STATUS_NOT_POWERED, &rp,
3455 sizeof(rp));
3461 MGMT_STATUS_ALREADY_PAIRED, &rp,
3462 sizeof(rp));
3512 status, &rp, sizeof(rp));
3519 MGMT_STATUS_BUSY, &rp, sizeof(rp));
3927 struct mgmt_rp_get_phy_configuration rp;
3933 memset(&rp, 0, sizeof(rp));
3935 rp.supported_phys = cpu_to_le32(get_supported_phys(hdev));
3936 rp.selected_phys = cpu_to_le32(get_selected_phys(hdev));
3937 rp.configurable_phys = cpu_to_le32(get_configurable_phys(hdev));
3942 &rp, sizeof(rp));
4265 struct mgmt_rp_read_controller_cap *rp = (void *)buf;
4295 cap_len = eir_append_data(rp->cap, cap_len, MGMT_CAP_SEC_FLAGS,
4302 cap_len = eir_append_le16(rp->cap, cap_len,
4306 cap_len = eir_append_le16(rp->cap, cap_len,
4316 cap_len = eir_append_data(rp->cap, cap_len, MGMT_CAP_LE_TX_PWR,
4320 rp->cap_len = cpu_to_le16(cap_len);
4325 rp, sizeof(*rp) + cap_len);
4375 struct mgmt_rp_read_exp_features_info *rp;
4384 len = sizeof(*rp) + (sizeof(rp->features[0]) * 7);
4385 rp = kzalloc(len, GFP_KERNEL);
4386 if (!rp)
4393 memcpy(rp->features[idx].uuid, debug_uuid, 16);
4394 rp->features[idx].flags = cpu_to_le32(flags);
4405 memcpy(rp->features[idx].uuid, le_simultaneous_roles_uuid, 16);
4406 rp->features[idx].flags = cpu_to_le32(flags);
4416 memcpy(rp->features[idx].uuid, rpa_resolution_uuid, 16);
4417 rp->features[idx].flags = cpu_to_le32(flags);
4428 memcpy(rp->features[idx].uuid, quality_report_uuid, 16);
4429 rp->features[idx].flags = cpu_to_le32(flags);
4439 memcpy(rp->features[idx].uuid, offload_codecs_uuid, 16);
4440 rp->features[idx].flags = cpu_to_le32(flags);
4446 memcpy(rp->features[idx].uuid, iso_socket_uuid, 16);
4447 rp->features[idx].flags = cpu_to_le32(flags);
4457 memcpy(rp->features[idx].uuid, mgmt_mesh_uuid, 16);
4458 rp->features[idx].flags = cpu_to_le32(flags);
4462 rp->feature_count = cpu_to_le16(idx);
4471 0, rp, sizeof(*rp) + (20 * idx));
4473 kfree(rp);
4522 struct mgmt_rp_set_exp_feature rp;
4524 memset(rp.uuid, 0, 16);
4525 rp.flags = cpu_to_le32(0);
4552 &rp, sizeof(rp));
4559 struct mgmt_rp_set_exp_feature rp;
4586 memcpy(rp.uuid, debug_uuid, 16);
4587 rp.flags = cpu_to_le32(val ? BIT(0) : 0);
4593 &rp, sizeof(rp));
4605 struct mgmt_rp_set_exp_feature rp;
4638 memcpy(rp.uuid, mgmt_mesh_uuid, 16);
4639 rp.flags = cpu_to_le32(val ? BIT(0) : 0);
4645 &rp, sizeof(rp));
4657 struct mgmt_rp_set_exp_feature rp;
4703 memcpy(rp.uuid, rpa_resolution_uuid, 16);
4704 rp.flags = cpu_to_le32(flags);
4710 &rp, sizeof(rp));
4722 struct mgmt_rp_set_exp_feature rp;
4777 memcpy(rp.uuid, quality_report_uuid, 16);
4778 rp.flags = cpu_to_le32(val ? BIT(0) : 0);
4782 &rp, sizeof(rp));
4798 struct mgmt_rp_set_exp_feature rp;
4837 memcpy(rp.uuid, offload_codecs_uuid, 16);
4838 rp.flags = cpu_to_le32(val ? BIT(0) : 0);
4842 &rp, sizeof(rp));
4856 struct mgmt_rp_set_exp_feature rp;
4895 memcpy(rp.uuid, le_simultaneous_roles_uuid, 16);
4896 rp.flags = cpu_to_le32(val ? BIT(0) : 0);
4900 &rp, sizeof(rp));
4912 struct mgmt_rp_set_exp_feature rp;
4943 memcpy(rp.uuid, iso_socket_uuid, 16);
4944 rp.flags = cpu_to_le32(val ? BIT(0) : 0);
4950 &rp, sizeof(rp));
5019 struct mgmt_rp_get_device_flags rp;
5033 memset(&rp, 0, sizeof(rp));
5053 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
5054 rp.addr.type = cp->addr.type;
5055 rp.supported_flags = cpu_to_le32(supported_flags);
5056 rp.current_flags = cpu_to_le32(current_flags);
5064 &rp, sizeof(rp));
5192 struct mgmt_rp_read_adv_monitor_features *rp = NULL;
5212 rp_size = sizeof(*rp) + (num_handles * sizeof(u16));
5213 rp = kmalloc(rp_size, GFP_KERNEL);
5214 if (!rp)
5220 rp->supported_features = cpu_to_le32(supported);
5221 rp->enabled_features = cpu_to_le32(enabled);
5222 rp->max_num_handles = cpu_to_le16(HCI_MAX_ADV_MONITOR_NUM_HANDLES);
5223 rp->max_num_patterns = HCI_MAX_ADV_MONITOR_NUM_PATTERNS;
5224 rp->num_handles = cpu_to_le16(num_handles);
5226 memcpy(&rp->handles, &handles, (num_handles * sizeof(u16)));
5230 MGMT_STATUS_SUCCESS, rp, rp_size);
5232 kfree(rp);
5240 struct mgmt_rp_add_adv_patterns_monitor rp;
5246 rp.monitor_handle = cpu_to_le16(monitor->handle);
5257 mgmt_status(status), &rp, sizeof(rp));
5262 rp.monitor_handle, status);
5454 struct mgmt_rp_remove_adv_monitor rp;
5466 rp.monitor_handle = cp->monitor_handle;
5472 mgmt_status(status), &rp, sizeof(rp));
5477 rp.monitor_handle, status);
5569 struct hci_rp_read_local_oob_data *rp = (void *) skb->data;
5571 if (skb->len < sizeof(*rp)) {
5578 memcpy(mgmt_rp.hash192, rp->hash, sizeof(rp->hash));
5579 memcpy(mgmt_rp.rand192, rp->rand, sizeof(rp->rand));
5583 struct hci_rp_read_local_oob_ext_data *rp = (void *) skb->data;
5585 if (skb->len < sizeof(*rp)) {
5592 memcpy(mgmt_rp.hash192, rp->hash192, sizeof(rp->hash192));
5593 memcpy(mgmt_rp.rand192, rp->rand192, sizeof(rp->rand192));
5595 memcpy(mgmt_rp.hash256, rp->hash256, sizeof(rp->hash256));
5596 memcpy(mgmt_rp.rand256, rp->rand256, sizeof(rp->rand256));
7258 struct mgmt_rp_get_conn_info rp;
7263 memcpy(&rp.addr, &cp->addr, sizeof(rp.addr));
7267 rp.rssi = conn->rssi;
7268 rp.tx_power = conn->tx_power;
7269 rp.max_tx_power = conn->max_tx_power;
7271 rp.rssi = HCI_RSSI_INVALID;
7272 rp.tx_power = HCI_TX_POWER_INVALID;
7273 rp.max_tx_power = HCI_TX_POWER_INVALID;
7277 &rp, sizeof(rp));
7324 struct mgmt_rp_get_conn_info rp;
7331 memset(&rp, 0, sizeof(rp));
7332 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
7333 rp.addr.type = cp->addr.type;
7338 &rp, sizeof(rp));
7344 MGMT_STATUS_NOT_POWERED, &rp,
7345 sizeof(rp));
7357 MGMT_STATUS_NOT_CONNECTED, &rp,
7358 sizeof(rp));
7387 MGMT_STATUS_FAILED, &rp, sizeof(rp));
7398 rp.rssi = conn->rssi;
7399 rp.tx_power = conn->tx_power;
7400 rp.max_tx_power = conn->max_tx_power;
7403 MGMT_STATUS_SUCCESS, &rp, sizeof(rp));
7415 struct mgmt_rp_get_clock_info rp;
7421 memset(&rp, 0, sizeof(rp));
7422 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
7423 rp.addr.type = cp->addr.type;
7428 rp.local_clock = cpu_to_le32(hdev->clock);
7431 rp.piconet_clock = cpu_to_le32(conn->clock);
7432 rp.accuracy = cpu_to_le16(conn->clock_accuracy);
7436 mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode, status, &rp,
7437 sizeof(rp));
7468 struct mgmt_rp_get_clock_info rp;
7475 memset(&rp, 0, sizeof(rp));
7476 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
7477 rp.addr.type = cp->addr.type;
7482 &rp, sizeof(rp));
7488 MGMT_STATUS_NOT_POWERED, &rp,
7489 sizeof(rp));
7500 &rp, sizeof(rp));
7516 MGMT_STATUS_FAILED, &rp, sizeof(rp));
8113 struct hci_rp_read_local_oob_data *rp;
8115 if (skb->len != sizeof(*rp)) {
8120 rp = (void *)skb->data;
8123 h192 = rp->hash;
8124 r192 = rp->rand;
8129 struct hci_rp_read_local_oob_ext_data *rp;
8131 if (skb->len != sizeof(*rp)) {
8136 rp = (void *)skb->data;
8144 h192 = rp->hash192;
8145 r192 = rp->rand192;
8148 h256 = rp->hash256;
8149 r256 = rp->rand256;
8226 struct mgmt_rp_read_local_oob_ext_data *rp;
8260 rp_len = sizeof(*rp) + eir_len;
8261 rp = kmalloc(rp_len, GFP_ATOMIC);
8262 if (!rp)
8287 eir_len = eir_append_data(rp->eir, eir_len,
8327 eir_len = eir_append_data(rp->eir, eir_len, EIR_LE_BDADDR,
8335 eir_len = eir_append_data(rp->eir, eir_len, EIR_LE_ROLE,
8339 eir_len = eir_append_data(rp->eir, eir_len,
8343 eir_len = eir_append_data(rp->eir, eir_len,
8353 eir_len = eir_append_data(rp->eir, eir_len, EIR_FLAGS,
8365 rp->type = cp->type;
8366 rp->eir_len = cpu_to_le16(eir_len);
8369 status, rp, sizeof(*rp) + eir_len);
8374 rp, sizeof(*rp) + eir_len,
8378 kfree(rp);
8423 struct mgmt_rp_read_adv_features *rp;
8438 rp_len = sizeof(*rp) + hdev->adv_instance_cnt;
8439 rp = kmalloc(rp_len, GFP_ATOMIC);
8440 if (!rp) {
8447 rp->supported_flags = cpu_to_le32(supported_flags);
8448 rp->max_adv_data_len = max_adv_len(hdev);
8449 rp->max_scan_rsp_len = max_adv_len(hdev);
8450 rp->max_instances = hdev->le_num_of_adv_sets;
8451 rp->num_instances = hdev->adv_instance_cnt;
8453 instance = rp->instance;
8460 rp->num_instances--;
8468 MGMT_STATUS_SUCCESS, rp, rp_len);
8470 kfree(rp);
8630 struct mgmt_rp_add_advertising rp;
8632 memset(&rp, 0, sizeof(rp));
8634 rp.instance = cp->instance;
8641 mgmt_status(err), &rp, sizeof(rp));
8660 struct mgmt_rp_add_advertising rp;
8762 rp.instance = cp->instance;
8764 MGMT_STATUS_SUCCESS, &rp, sizeof(rp));
8796 struct mgmt_rp_add_ext_adv_params rp;
8808 rp.instance = cp->instance;
8809 rp.tx_power = adv->tx_power;
8815 rp.max_adv_data_len = tlv_data_max_len(hdev, flags, true);
8816 rp.max_scan_rsp_len = tlv_data_max_len(hdev, flags, false);
8832 mgmt_status(err), &rp, sizeof(rp));
8854 struct mgmt_rp_add_ext_adv_params rp;
8951 rp.instance = cp->instance;
8952 rp.tx_power = HCI_ADV_TX_POWER_NO_PREFERENCE;
8953 rp.max_adv_data_len = tlv_data_max_len(hdev, flags, true);
8954 rp.max_scan_rsp_len = tlv_data_max_len(hdev, flags, false);
8957 MGMT_STATUS_SUCCESS, &rp, sizeof(rp));
8970 struct mgmt_rp_add_advertising rp;
8974 memset(&rp, 0, sizeof(rp));
8976 rp.instance = cp->instance;
8983 mgmt_status(err), &rp, sizeof(rp));
9013 struct mgmt_rp_add_ext_adv_data rp;
9089 rp.instance = cp->instance;
9091 MGMT_STATUS_SUCCESS, &rp, sizeof(rp));
9133 struct mgmt_rp_remove_advertising rp;
9137 memset(&rp, 0, sizeof(rp));
9138 rp.instance = cp->instance;
9145 MGMT_STATUS_SUCCESS, &rp, sizeof(rp));
9218 struct mgmt_rp_get_adv_size_info rp;
9241 rp.instance = cp->instance;
9242 rp.flags = cp->flags;
9243 rp.max_adv_data_len = tlv_data_max_len(hdev, flags, true);
9244 rp.max_scan_rsp_len = tlv_data_max_len(hdev, flags, false);
9247 MGMT_STATUS_SUCCESS, &rp, sizeof(rp));