From patchwork Mon Jul 6 20:25:13 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Abhishek Pandit-Subedi X-Patchwork-Id: 11646833 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 4CEED1398 for ; Mon, 6 Jul 2020 20:25:36 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 343EC20BED for ; Mon, 6 Jul 2020 20:25:36 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="jl6M085M" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727031AbgGFUZe (ORCPT ); Mon, 6 Jul 2020 16:25:34 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54606 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725860AbgGFUZc (ORCPT ); Mon, 6 Jul 2020 16:25:32 -0400 Received: from mail-pl1-x635.google.com (mail-pl1-x635.google.com [IPv6:2607:f8b0:4864:20::635]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 678BCC061755 for ; Mon, 6 Jul 2020 13:25:32 -0700 (PDT) Received: by mail-pl1-x635.google.com with SMTP id j7so2425530plk.13 for ; Mon, 06 Jul 2020 13:25:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=PYYU0UwoMy/TrOAen5MS1rO2nahTd7K1yKosFEDdKU4=; b=jl6M085MpXP1jNgwTQeo0D4rx7tqf7+So3lf9DO2o6/fQBK65YQRh/3hRUJPDCo2O7 W1Z8eEJ7wvst4shvHxUXR5VJTON3x3k0cF9NZuXX4K8BxmQhSwyH7zBGmv7HnvQDH/ro HJZR32kRCu3TZkkt8/tvp7o3f0tBKZpvgWp4U= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=PYYU0UwoMy/TrOAen5MS1rO2nahTd7K1yKosFEDdKU4=; b=CfPwOGxSZCZHsNhJBP/GyHLZWfidZRmXIUyh/pWpCiTUcuyin5YXOq3NDMqsgjp7y2 w6ORPyD8+HIehpQSAEse+heIMlrMuQyHb+jIzgdOdrce5tAuCO/gYxDsXbc+NY2QDd0/ BbLXQwZFWfiOiiNuGMwtEgWWb7db1HM14CWh6WJzVevbHW1Zj9p6ln4vAfKBofilcZUd cY4e6JAW9zpzuWKRooPycawuQC1DOOxi7rQkT4tCV2jE3edTcnwONXSsybgGzc4UF1x2 3P66UonE0pYjQFBkWXShujp9FXC9ppkLgwWunOcafXQ3w/SctQfBPpQxazI27p0jXrj5 V4aw== X-Gm-Message-State: AOAM531Mp1o/Pu08egPQV+A0IKL/AFDNQzEKt6AVzP5wAEohgaClGKeA Gn+xYqNPml67gjlZDMICkWuJSJBEjM0= X-Google-Smtp-Source: ABdhPJyuoptO/FAMSNzibYd5ThR3oaPC+Yge5n1u9otcN+O2F+n8WgqyWAAzG+Fz7f2ExGO65NSicA== X-Received: by 2002:a17:902:9a47:: with SMTP id x7mr25498158plv.90.1594067131894; Mon, 06 Jul 2020 13:25:31 -0700 (PDT) Received: from apsdesk.mtv.corp.google.com ([2620:15c:202:1:7220:84ff:fe09:2b94]) by smtp.gmail.com with ESMTPSA id n25sm3320226pff.51.2020.07.06.13.25.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 06 Jul 2020 13:25:31 -0700 (PDT) From: Abhishek Pandit-Subedi To: luiz.dentz@gmail.com, linux-bluetooth@vger.kernel.org Cc: alainm@chromium.org, marcel@holtmann.org, chromeos-bluetooth-upstreaming@chromium.org, Abhishek Pandit-Subedi Subject: [BlueZ PATCH v7 1/6] mgmt: Add mgmt op and events for device flags Date: Mon, 6 Jul 2020 13:25:13 -0700 Message-Id: <20200706132503.BlueZ.v7.1.I3a6c238b09e1a0fad69e69cc2e6f4063af989b37@changeid> X-Mailer: git-send-email 2.27.0.212.ge8ba1cc988-goog In-Reply-To: <20200706202518.1153647-1-abhishekpandit@chromium.org> References: <20200706202518.1153647-1-abhishekpandit@chromium.org> MIME-Version: 1.0 Sender: linux-bluetooth-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-bluetooth@vger.kernel.org Add Get Device Flags, Set Device Flags and Device Flags Changed. --- Changes in v7: None Changes in v6: None Changes in v5: - Use device_flags mgmt op Changes in v4: None Changes in v3: None Changes in v2: None lib/mgmt.h | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/lib/mgmt.h b/lib/mgmt.h index fad1f3dfe..525c4dd62 100644 --- a/lib/mgmt.h +++ b/lib/mgmt.h @@ -654,6 +654,27 @@ struct mgmt_cp_set_default_runtime_config { uint8_t parameters[0]; /* mgmt_tlv */ } __packed; +#define MGMT_OP_GET_DEVICE_FLAGS 0x004F +#define MGMT_GET_DEVICE_FLAGS_SIZE 7 +struct mgmt_cp_get_device_flags { + struct mgmt_addr_info addr; +} __packed; +struct mgmt_rp_get_device_flags { + struct mgmt_addr_info addr; + uint32_t supported_flags; + uint32_t current_flags; +} __packed; + +#define MGMT_OP_SET_DEVICE_FLAGS 0x0050 +#define MGMT_SET_DEVICE_FLAGS_SIZE 11 +struct mgmt_cp_set_device_flags { + struct mgmt_addr_info addr; + uint32_t current_flags; +} __packed; +struct mgmt_rp_set_device_flags { + struct mgmt_addr_info addr; +} __packed; + #define MGMT_ADV_MONITOR_FEATURE_MASK_OR_PATTERNS (1 << 0) #define MGMT_OP_READ_ADV_MONITOR_FEATURES 0x0051 @@ -919,6 +940,13 @@ struct mgmt_ev_exp_feature_changed { uint32_t flags; } __packed; +#define MGMT_EV_DEVICE_FLAGS_CHANGED 0x002a +struct mgmt_ev_device_flags_changed { + struct mgmt_addr_info addr; + uint32_t supported_flags; + uint32_t current_flags; +} __packed; + #define MGMT_EV_ADV_MONITOR_ADDED 0x002b struct mgmt_ev_adv_monitor_added { uint16_t monitor_handle; @@ -1007,6 +1035,8 @@ static const char *mgmt_op[] = { "Set Experimental Feature", "Read Default System Configuration", "Set Default System Configuration", + "Get Device Flags", + "Set Device Flags", /* 0x0050 */ "Read Advertisement Monitor Features", "Add Advertisement Patterns Monitor", "Remove Advertisement Monitor", @@ -1053,6 +1083,7 @@ static const char *mgmt_ev[] = { "Extended Controller Information Changed", "PHY Configuration Changed", "Experimental Feature Changed", + "Device Flags Changed", "Advertisement Monitor Added", /* 0x002b */ "Advertisement Monitor Removed", }; From patchwork Mon Jul 6 20:25:14 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Abhishek Pandit-Subedi X-Patchwork-Id: 11646835 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id CB31113B4 for ; Mon, 6 Jul 2020 20:25:36 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id B28ED20674 for ; Mon, 6 Jul 2020 20:25:36 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="k/lQQyPr" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727053AbgGFUZg (ORCPT ); Mon, 6 Jul 2020 16:25:36 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54610 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726869AbgGFUZd (ORCPT ); Mon, 6 Jul 2020 16:25:33 -0400 Received: from mail-pj1-x102f.google.com (mail-pj1-x102f.google.com [IPv6:2607:f8b0:4864:20::102f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5842BC061755 for ; Mon, 6 Jul 2020 13:25:33 -0700 (PDT) Received: by mail-pj1-x102f.google.com with SMTP id k5so7928572pjg.3 for ; Mon, 06 Jul 2020 13:25:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=sp2PpsNYtdlkB2zGQ5iXNthHuroaVA/dnOY7kVTTSGk=; b=k/lQQyPrWkjj2dmUt1M+PIwzylCjgPoQRd4G/xVLpSE6xboGetNnjQvQ9BMeWqvBnl 3PVlVH4F2CwFWXrWJbZsIhtIqRX4p+AtecLkVG4U69bE01FgNInPaEQb6H2cgmWlAKIC z4zQaF7LslGiUjzrwR9yJxJGIYe7/dl8z5paE= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=sp2PpsNYtdlkB2zGQ5iXNthHuroaVA/dnOY7kVTTSGk=; b=gRA51lLR5zkSuuFhd8pmzLzdjueEvvRux0Yq9zHhM/HLYjtDueRhyfPXi6ILz765hq DhafR84QNL1/gl4gadCloBC/bsC5eH6yMOAiRFgCW0SHcnuhwPS5dsjhEiWd4dLK+Hxd 1boZOOjAcPAL2Ua7bn6nVrzha017h+iQBQEDmg6ZAYiiwSR0Vw6tUGEYz9g7Wc+AiRw+ qthWlyfCouthuI9vM/kEPOZp5CuenAMJvGsb6f1fJhxhyQQ26fgnXLm823YrtVJQlT/j yNvkQ4CJHKaaKBo+jScH+DN+1h0BQGCbfj2LBPTVdwgUQ/iOuc2SyiwFtDTxLt5bvod5 DRGg== X-Gm-Message-State: AOAM530ohh5uvu78Gdi9qL4OMKyCmOxAsw3/aUul77rru8Aa6JczjaX4 hV+NA2EHfTweiWDadUtPy23P+w== X-Google-Smtp-Source: ABdhPJzF5hes9AigF0tS3z3rNIxt9q118eFHumvlFRr6BUw/qnEd/wtHVzeuGJKdvvaAwHtt1MXWUQ== X-Received: by 2002:a17:902:8bc7:: with SMTP id r7mr42583233plo.174.1594067132876; Mon, 06 Jul 2020 13:25:32 -0700 (PDT) Received: from apsdesk.mtv.corp.google.com ([2620:15c:202:1:7220:84ff:fe09:2b94]) by smtp.gmail.com with ESMTPSA id n25sm3320226pff.51.2020.07.06.13.25.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 06 Jul 2020 13:25:32 -0700 (PDT) From: Abhishek Pandit-Subedi To: luiz.dentz@gmail.com, linux-bluetooth@vger.kernel.org Cc: alainm@chromium.org, marcel@holtmann.org, chromeos-bluetooth-upstreaming@chromium.org, Abhishek Pandit-Subedi Subject: [BlueZ PATCH v7 2/6] monitor: Decode device flags mgmt ops and event Date: Mon, 6 Jul 2020 13:25:14 -0700 Message-Id: <20200706132503.BlueZ.v7.2.Ieac700ddea68a19e8c3dc53528f686482076a77a@changeid> X-Mailer: git-send-email 2.27.0.212.ge8ba1cc988-goog In-Reply-To: <20200706202518.1153647-1-abhishekpandit@chromium.org> References: <20200706202518.1153647-1-abhishekpandit@chromium.org> MIME-Version: 1.0 Sender: linux-bluetooth-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-bluetooth@vger.kernel.org Add support for Get Device Flags and Set Device Flags mgmt operations and Device Flags Changed mgmt event. Sample trace: @ MGMT Command: Set Device Flags (0x0050) plen 11 {0x0002} [hci0] LE Address: CD:F3:CD:13:C5:91 (Static) Current Flags: 0x00000000 @ MGMT Event: Device Flags Changed (0x002a) plen 15 {0x0001} [hci0] LE Address: CD:F3:CD:13:C5:91 (Static) Supported Flags: 0x00000001 Remote Wakeup Current Flags: 0x00000000 @ MGMT Event: Device Flags Changed (0x002a) plen 15 {0x0004} [hci0] LE Address: CD:F3:CD:13:C5:91 (Static) Supported Flags: 0x00000001 Remote Wakeup Current Flags: 0x00000000 @ MGMT Event: Device Flags Changed (0x002a) plen 15 {0x0003} [hci0] LE Address: CD:F3:CD:13:C5:91 (Static) Supported Flags: 0x00000001 Remote Wakeup Current Flags: 0x00000000 @ MGMT Event: Command Complete (0x0001) plen 10 {0x0002} [hci0] Set Device Flags (0x0050) plen 7 Status: Success (0x00) LE Address: CD:F3:CD:13:C5:91 (Static) --- Changes in v7: None Changes in v6: * Fix up some build issues reported by bluez.test.bot Changes in v5: * Decode device flags Changes in v4: None Changes in v3: None Changes in v2: None monitor/packet.c | 70 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) diff --git a/monitor/packet.c b/monitor/packet.c index 3b9c06512..431a39b66 100644 --- a/monitor/packet.c +++ b/monitor/packet.c @@ -100,6 +100,7 @@ #define COLOR_UNKNOWN_EXP_FEATURE_FLAG COLOR_WHITE_BG #define COLOR_UNKNOWN_ADV_FLAG COLOR_WHITE_BG #define COLOR_UNKNOWN_PHY COLOR_WHITE_BG +#define COLOR_UNKNOWN_ADDED_DEVICE_FLAG COLOR_WHITE_BG #define COLOR_PHY_PACKET COLOR_BLUE @@ -13099,6 +13100,56 @@ static void mgmt_set_exp_feature_rsp(const void *data, uint16_t size) mgmt_print_exp_feature(data); } +static const struct bitfield_data mgmt_added_device_flags_table[] = { + { 0, "Remote Wakeup" }, + { } +}; + +static void mgmt_print_added_device_flags(char *label, uint32_t flags) +{ + uint32_t mask; + + print_field("%s: 0x%8.8x", label, flags); + mask = print_bitfield(2, flags, mgmt_added_device_flags_table); + if (mask) + print_text(COLOR_UNKNOWN_ADDED_DEVICE_FLAG, + " Unknown Flags (0x%8.8x)", mask); +} + +static void mgmt_get_device_flags_cmd(const void *data, uint16_t size) +{ + uint8_t type = get_u8(data + 6); + + mgmt_print_address(data, type); +} + +static void mgmt_get_device_flags_rsp(const void *data, uint16_t size) +{ + uint8_t type = get_u8(data + 6); + uint32_t supported_flags = get_le32(data + 7); + uint32_t current_flags = get_le32(data + 11); + + mgmt_print_address(data, type); + mgmt_print_added_device_flags("Supported Flags", supported_flags); + mgmt_print_added_device_flags("Current Flags", current_flags); +} + +static void mgmt_set_device_flags_cmd(const void *data, uint16_t size) +{ + uint8_t type = get_u8(data + 6); + uint32_t current_flags = get_le32(data + 7); + + mgmt_print_address(data, type); + mgmt_print_added_device_flags("Current Flags", current_flags); +} + +static void mgmt_set_device_flags_rsp(const void *data, uint16_t size) +{ + uint8_t type = get_u8(data + 6); + + mgmt_print_address(data, type); +} + struct mgmt_data { uint16_t opcode; const char *str; @@ -13324,6 +13375,12 @@ static const struct mgmt_data mgmt_command_table[] = { { 0x004a, "Set Experimental Feature", mgmt_set_exp_feature_cmd, 17, true, mgmt_set_exp_feature_rsp, 20, true }, + { 0x004f, "Get Device Flags", + mgmt_get_device_flags_cmd, 7, true, + mgmt_get_device_flags_rsp, 15, true}, + { 0x0050, "Set Device Flags", + mgmt_set_device_flags_cmd, 11, true, + mgmt_set_device_flags_rsp, 7, true}, { } }; @@ -13714,6 +13771,17 @@ static void mgmt_exp_feature_changed_evt(const void *data, uint16_t size) mgmt_print_exp_feature(data); } +static void mgmt_device_flags_changed_evt(const void *data, uint16_t size) +{ + uint8_t type = get_u8(data + 6); + uint32_t supported_flags = get_le32(data + 7); + uint32_t current_flags = get_le32(data + 11); + + mgmt_print_address(data, type); + mgmt_print_added_device_flags("Supported Flags", supported_flags); + mgmt_print_added_device_flags("Current Flags", current_flags); +} + static const struct mgmt_data mgmt_event_table[] = { { 0x0001, "Command Complete", mgmt_command_complete_evt, 3, false }, @@ -13793,6 +13861,8 @@ static const struct mgmt_data mgmt_event_table[] = { mgmt_phy_changed_evt, 4, true }, { 0x0027, "Experimental Feature Changed", mgmt_exp_feature_changed_evt, 20, true }, + { 0x002a, "Device Flags Changed", + mgmt_device_flags_changed_evt, 15, true }, { } }; From patchwork Mon Jul 6 20:25:15 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Abhishek Pandit-Subedi X-Patchwork-Id: 11646837 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 622ED13B6 for ; Mon, 6 Jul 2020 20:25:37 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 3E80C215A4 for ; Mon, 6 Jul 2020 20:25:37 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="Qh9Xe9qS" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727120AbgGFUZg (ORCPT ); Mon, 6 Jul 2020 16:25:36 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54616 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727088AbgGFUZe (ORCPT ); Mon, 6 Jul 2020 16:25:34 -0400 Received: from mail-pl1-x643.google.com (mail-pl1-x643.google.com [IPv6:2607:f8b0:4864:20::643]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 65D97C061794 for ; Mon, 6 Jul 2020 13:25:34 -0700 (PDT) Received: by mail-pl1-x643.google.com with SMTP id k4so1612036pld.12 for ; Mon, 06 Jul 2020 13:25:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=0SKTS/P3VVnxtXiKmmcc9yL2vznCzJDGVC6hgr5NWd8=; b=Qh9Xe9qSMSTqvB68j2i5QzuSgSb0C1QiQw3xUSEQJLK/0Js84pY95EBAEuvAruEcK9 IIl6mtvQlPxqpyhkfWrnIpYq3cVA6hSDTD+0RfEVRL5nmBOe6fQZiLRNWuLXOtV3BpiW EhKy+nHYn76BC4b+lO/N5PTqDw0ljCRj6Ra5s= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=0SKTS/P3VVnxtXiKmmcc9yL2vznCzJDGVC6hgr5NWd8=; b=ccQFwn/Mm02kzztjsPym27Dpya7r95cKuv/9DFzA5562pM1favTs3BOj0tpiwdFaJn Hjjh5yWNctF0zl+YWcl2t0mUJvKqnYBWxQrRnaaN7639t6OmgpRTPptVqSsFE0G0oJt8 AWiE42Gx3UuRITfGG6Wf4Qaq55hbJa7Zq7kegHnVs1LqnlPv2u7LNK3/rv8XL05gU9VW XcYbrSSBWnfNtf82gJFOSnBKqMQUkA2cbNHOHv78nJTWdUEWWpJta7f/cKRo2i6pcPlA we0pyxOjOf4e/0nwAxf0ItotqoypNdwT8AY24Uy58VHKU8NIxa/llu6gFShnbhATfQJp pB6g== X-Gm-Message-State: AOAM533H6JBG2hqs/p8pB2qXlrdrCZeK0/am8Uyliyknv0rN1Kv/cgwF 0KQ6TogCFwoNhObkxovFzhIGaQ== X-Google-Smtp-Source: ABdhPJwf35MTPoQgz5QG1C8aP5J+BSvlAouurmNUsmq/Vt8qmhzp422dmgquBd+8im+0XFJhhc716g== X-Received: by 2002:a17:902:d392:: with SMTP id e18mr30091623pld.139.1594067133799; Mon, 06 Jul 2020 13:25:33 -0700 (PDT) Received: from apsdesk.mtv.corp.google.com ([2620:15c:202:1:7220:84ff:fe09:2b94]) by smtp.gmail.com with ESMTPSA id n25sm3320226pff.51.2020.07.06.13.25.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 06 Jul 2020 13:25:33 -0700 (PDT) From: Abhishek Pandit-Subedi To: luiz.dentz@gmail.com, linux-bluetooth@vger.kernel.org Cc: alainm@chromium.org, marcel@holtmann.org, chromeos-bluetooth-upstreaming@chromium.org, Abhishek Pandit-Subedi Subject: [BlueZ PATCH v7 3/6] device: Support marking a device with wake allowed Date: Mon, 6 Jul 2020 13:25:15 -0700 Message-Id: <20200706132503.BlueZ.v7.3.I1b0ff04f458fdaec2a193d27c2b94ce8f2cc4138@changeid> X-Mailer: git-send-email 2.27.0.212.ge8ba1cc988-goog In-Reply-To: <20200706202518.1153647-1-abhishekpandit@chromium.org> References: <20200706202518.1153647-1-abhishekpandit@chromium.org> MIME-Version: 1.0 Sender: linux-bluetooth-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-bluetooth@vger.kernel.org If a device is allowed to wake the host system from suspend, it should be marked as wake allowed. We add support for a new property that is sent to the kernel via set device flags mgmt op. We also add the dbus endpoint to allow the wake allowed setting to be controlled. In order for wake allowed to be set, the profile must also support wake. This setting isn't exposed to the user but must be set by profiles that intend to support wake from suspend. If a device is connecting for the first time, it will be marked WakeAllowed if the profile supports it. On subsequent reloads of bluez, the stored setting "WakeAllowed" will be used to override any other setting. --- Changes in v7: * Fix more build issues reported by bluez.test.bot Changes in v6: * Save pending property id and emit success only after set flags returns * Ignore multiple calls to set_wake_allowed to the same value * Emit property error busy if same value is already sent to mgmt * Fix up build issues reported by bluez.test.bot Changes in v5: * Refactor to use set_wake_flags and respond to device flags changed * Add wake_override so we can keep track of user/profile configuration vs what is currently active Changes in v4: * Renamed wake_capable to wake_allowed * Removed set_wake_capable mgmt op and updated add_device to accept flags to set whether a device is wakeable * Refactored adapter_whitelist_add and adapter_auto_connect_add to call adapter_add_device Changes in v3: * Added profile_wake_support and made wake_capable dependent on it Changes in v2: * Added dbus api "WakeCapable" to set value * Update device_set_wake_capable to be called by adapter_set_wake_capable_complete so we can emit property changed lib/mgmt.h | 2 + src/adapter.c | 93 ++++++++++++++++++++++ src/adapter.h | 3 +- src/device.c | 210 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/device.h | 10 +++ 5 files changed, 317 insertions(+), 1 deletion(-) diff --git a/lib/mgmt.h b/lib/mgmt.h index 525c4dd62..a800bcab4 100644 --- a/lib/mgmt.h +++ b/lib/mgmt.h @@ -665,6 +665,8 @@ struct mgmt_rp_get_device_flags { uint32_t current_flags; } __packed; +#define DEVICE_FLAG_REMOTE_WAKEUP (1 << 0) + #define MGMT_OP_SET_DEVICE_FLAGS 0x0050 #define MGMT_SET_DEVICE_FLAGS_SIZE 11 struct mgmt_cp_set_device_flags { diff --git a/src/adapter.c b/src/adapter.c index 9ce351893..bccdbe8bf 100644 --- a/src/adapter.c +++ b/src/adapter.c @@ -5102,6 +5102,94 @@ void adapter_auto_connect_add(struct btd_adapter *adapter, adapter->connect_list = g_slist_append(adapter->connect_list, device); } +static void set_device_wakeable_complete(uint8_t status, uint16_t length, + const void *param, void *user_data) +{ + const struct mgmt_rp_set_device_flags *rp = param; + struct btd_adapter *adapter = user_data; + struct btd_device *dev; + char addr[18]; + + if (status != MGMT_STATUS_SUCCESS) { + btd_error(adapter->dev_id, "Set device flags return status: %s", + mgmt_errstr(status)); + return; + } + + if (length < sizeof(*rp)) { + btd_error(adapter->dev_id, + "Too small Set Device Flags complete event: %d", + length); + return; + } + + ba2str(&rp->addr.bdaddr, addr); + + dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr, rp->addr.type); + if (!dev) { + btd_error(adapter->dev_id, + "Set Device Flags complete for unknown device %s", + addr); + return; + } + + device_set_wake_allowed_complete(dev); +} + +void adapter_set_device_wakeable(struct btd_adapter *adapter, + struct btd_device *device, bool wakeable) +{ + struct mgmt_cp_set_device_flags cp; + const bdaddr_t *bdaddr; + uint8_t bdaddr_type; + + if (!kernel_conn_control) + return; + + bdaddr = device_get_address(device); + bdaddr_type = btd_device_get_bdaddr_type(device); + + memset(&cp, 0, sizeof(cp)); + bacpy(&cp.addr.bdaddr, bdaddr); + cp.addr.type = bdaddr_type; + cp.current_flags = btd_device_get_current_flags(device); + if (wakeable) + cp.current_flags |= DEVICE_FLAG_REMOTE_WAKEUP; + else + cp.current_flags &= ~DEVICE_FLAG_REMOTE_WAKEUP; + + mgmt_send(adapter->mgmt, MGMT_OP_SET_DEVICE_FLAGS, adapter->dev_id, + sizeof(cp), &cp, set_device_wakeable_complete, adapter, NULL); +} + +static void device_flags_changed_callback(uint16_t index, uint16_t length, + const void *param, void *user_data) +{ + const struct mgmt_ev_device_flags_changed *ev = param; + struct btd_adapter *adapter = user_data; + struct btd_device *dev; + char addr[18]; + + if (length < sizeof(*ev)) { + btd_error(adapter->dev_id, + "Too small Device Flags Changed event: %d", + length); + return; + } + + ba2str(&ev->addr.bdaddr, addr); + + dev = btd_adapter_find_device(adapter, &ev->addr.bdaddr, ev->addr.type); + if (!dev) { + btd_error(adapter->dev_id, + "Device Flags Changed for unknown device %s", addr); + return; + } + + btd_device_flags_changed(dev, ev->supported_flags, ev->current_flags); +} + + static void remove_device_complete(uint8_t status, uint16_t length, const void *param, void *user_data) { @@ -8544,6 +8632,11 @@ static int adapter_register(struct btd_adapter *adapter) adapter, NULL); load: + mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_FLAGS_CHANGED, + adapter->dev_id, + device_flags_changed_callback, + adapter, NULL); + load_config(adapter); fix_storage(adapter); load_drivers(adapter); diff --git a/src/adapter.h b/src/adapter.h index d0a5253bd..f8ac20261 100644 --- a/src/adapter.h +++ b/src/adapter.h @@ -213,6 +213,8 @@ int adapter_connect_list_add(struct btd_adapter *adapter, struct btd_device *device); void adapter_connect_list_remove(struct btd_adapter *adapter, struct btd_device *device); +void adapter_set_device_wakeable(struct btd_adapter *adapter, + struct btd_device *dev, bool wakeable); void adapter_auto_connect_add(struct btd_adapter *adapter, struct btd_device *device); void adapter_auto_connect_remove(struct btd_adapter *adapter, @@ -231,4 +233,3 @@ void btd_adapter_for_each_device(struct btd_adapter *adapter, void *data); bool btd_le_connect_before_pairing(void); - diff --git a/src/device.c b/src/device.c index 7b0eb256e..0deee2707 100644 --- a/src/device.c +++ b/src/device.c @@ -177,6 +177,12 @@ struct csrk_info { uint32_t counter; }; +enum { + WAKE_FLAG_DEFAULT = 0, + WAKE_FLAG_ENABLED, + WAKE_FLAG_DISABLED, +}; + struct btd_device { int ref_count; @@ -189,6 +195,21 @@ struct btd_device { bool le; bool pending_paired; /* "Paired" waiting for SDP */ bool svc_refreshed; + + /* Manage whether this device can wake the system from suspend. + * - wake_support: Requires a profile that supports wake (i.e. HID) + * - wake_allowed: Is wake currently allowed? + * - pending_wake_allowed - Wake flag sent via set_device_flags + * - wake_override - User configured wake setting + */ + bool wake_support; + bool wake_allowed; + bool pending_wake_allowed; + uint8_t wake_override; + GDBusPendingPropertySet wake_id; + + uint32_t supported_flags; + uint32_t current_flags; GSList *svc_callbacks; GSList *eir_uuids; struct bt_ad *ad; @@ -415,6 +436,12 @@ static gboolean store_device_info_cb(gpointer user_data) g_key_file_set_boolean(key_file, "General", "Blocked", device->blocked); + if (device->wake_override != WAKE_FLAG_DEFAULT) { + g_key_file_set_boolean(key_file, "General", "WakeAllowed", + device->wake_override == + WAKE_FLAG_ENABLED); + } + if (device->uuids) { GSList *l; int i; @@ -1318,6 +1345,130 @@ dev_property_advertising_data_exist(const GDBusPropertyTable *property, return bt_ad_has_data(device->ad, NULL); } +static bool device_get_wake_support(struct btd_device *device) +{ + return device->wake_support; +} + +void device_set_wake_support(struct btd_device *device, bool wake_support) +{ + device->wake_support = wake_support; + + /* If wake configuration has not been made yet, set the initial + * configuration. + */ + if (device->wake_override == WAKE_FLAG_DEFAULT) { + device_set_wake_override(device, wake_support); + device_set_wake_allowed(device, wake_support, -1U); + } +} + +static bool device_get_wake_allowed(struct btd_device *device) +{ + return device->wake_allowed; +} + +void device_set_wake_override(struct btd_device *device, bool wake_override) +{ + if (wake_override) { + device->wake_override = WAKE_FLAG_ENABLED; + device->current_flags |= DEVICE_FLAG_REMOTE_WAKEUP; + } else { + device->wake_override = WAKE_FLAG_DISABLED; + device->current_flags &= ~DEVICE_FLAG_REMOTE_WAKEUP; + } +} + +void device_set_wake_allowed(struct btd_device *device, bool wake_allowed, + GDBusPendingPropertySet id) +{ + /* Pending and current value are the same unless there is a change in + * progress. Only update wake allowed if pending value doesn't match the + * new value. + */ + if (wake_allowed == device->pending_wake_allowed) + return; + + device->wake_id = id; + device->pending_wake_allowed = wake_allowed; + adapter_set_device_wakeable(device_get_adapter(device), device, + wake_allowed); +} + +void device_set_wake_allowed_complete(struct btd_device *device) +{ + if (device->wake_id != -1U) { + g_dbus_pending_property_success(device->wake_id); + device->wake_id = -1U; + } + + device->wake_allowed = device->pending_wake_allowed; + g_dbus_emit_property_changed(dbus_conn, device->path, + DEVICE_INTERFACE, "WakeAllowed"); + + store_device_info(device); +} + + +static gboolean +dev_property_get_wake_allowed(const GDBusPropertyTable *property, + DBusMessageIter *iter, void *data) +{ + struct btd_device *device = data; + dbus_bool_t wake_allowed = device_get_wake_allowed(device); + + dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &wake_allowed); + + return TRUE; +} + +static void dev_property_set_wake_allowed(const GDBusPropertyTable *property, + DBusMessageIter *value, + GDBusPendingPropertySet id, void *data) +{ + struct btd_device *device = data; + dbus_bool_t b; + + if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN) { + g_dbus_pending_property_error(id, + ERROR_INTERFACE ".InvalidArguments", + "Invalid arguments in method call"); + return; + } + + if (device->temporary) { + g_dbus_pending_property_error(id, + ERROR_INTERFACE ".Unsupported", + "Cannot set property while temporary"); + return; + } + + /* Emit busy or success depending on current value. */ + if (b == device->pending_wake_allowed) { + if (device->wake_allowed == device->pending_wake_allowed) + g_dbus_pending_property_success(id); + else + g_dbus_pending_property_error( + id, ERROR_INTERFACE ".Busy", + "Property change in progress"); + + return; + } + + dbus_message_iter_get_basic(value, &b); + device_set_wake_override(device, b); + device_set_wake_allowed(device, b, id); +} + +static gboolean dev_property_wake_allowed_exist( + const GDBusPropertyTable *property, void *data) +{ + struct btd_device *device = data; + + return device_get_wake_support(device); +} + + static gboolean disconnect_all(gpointer user_data) { struct btd_device *device = user_data; @@ -2790,6 +2941,9 @@ static const GDBusPropertyTable device_properties[] = { { "AdvertisingData", "a{yv}", dev_property_get_advertising_data, NULL, dev_property_advertising_data_exist, G_DBUS_PROPERTY_FLAG_EXPERIMENTAL }, + { "WakeAllowed", "b", dev_property_get_wake_allowed, + dev_property_set_wake_allowed, + dev_property_wake_allowed_exist }, { } }; @@ -3038,9 +3192,11 @@ static void convert_info(struct btd_device *device, GKeyFile *key_file) static void load_info(struct btd_device *device, const char *local, const char *peer, GKeyFile *key_file) { + GError *gerr = NULL; char *str; gboolean store_needed = FALSE; gboolean blocked; + gboolean wake_allowed; char **uuids; int source, vendor, product, version; char **techno, **t; @@ -3152,6 +3308,18 @@ next: btd_device_set_pnpid(device, source, vendor, product, version); } + /* Wake allowed is only configured and stored if user changed it. + * Otherwise, we enable if profile supports it. + */ + wake_allowed = g_key_file_get_boolean(key_file, "General", + "WakeAllowed", &gerr); + if (!gerr) { + device_set_wake_override(device, wake_allowed); + } else { + g_error_free(gerr); + gerr = NULL; + } + if (store_needed) store_device_info(device); } @@ -6558,6 +6726,48 @@ void btd_device_set_pnpid(struct btd_device *device, uint16_t source, store_device_info(device); } +uint32_t btd_device_get_current_flags(struct btd_device *dev) +{ + return dev->current_flags; +} + +/* This event is sent immediately after add device on all mgmt sockets. + * Afterwards, it is only sent to mgmt sockets other than the one which called + * set_device_flags. + */ +void btd_device_flags_changed(struct btd_device *dev, uint32_t supported_flags, + uint32_t current_flags) +{ + const uint32_t changed_flags = dev->current_flags ^ current_flags; + bool flag_value; + + dev->supported_flags = supported_flags; + dev->current_flags = current_flags; + + if (!changed_flags) + return; + + if (changed_flags & DEVICE_FLAG_REMOTE_WAKEUP) { + flag_value = !!(current_flags & DEVICE_FLAG_REMOTE_WAKEUP); + dev->pending_wake_allowed = flag_value; + + /* If an override exists and doesn't match the current state, + * apply it. This logic will run after Add Device only and will + * enable wake for previously paired devices. + */ + if (dev->wake_override != WAKE_FLAG_DEFAULT) { + bool wake_allowed = + dev->wake_override == WAKE_FLAG_ENABLED; + if (flag_value != wake_allowed) + device_set_wake_allowed(dev, wake_allowed, -1U); + else + device_set_wake_allowed_complete(dev); + } else { + device_set_wake_allowed_complete(dev); + } + } +} + static void service_state_changed(struct btd_service *service, btd_service_state_t old_state, btd_service_state_t new_state, diff --git a/src/device.h b/src/device.h index 06b100499..cb8d884e8 100644 --- a/src/device.h +++ b/src/device.h @@ -33,6 +33,7 @@ struct btd_device *device_create_from_storage(struct btd_adapter *adapter, char *btd_device_get_storage_path(struct btd_device *device, const char *filename); + void btd_device_device_set_name(struct btd_device *device, const char *name); void device_store_cached_name(struct btd_device *dev, const char *name); void device_get_name(struct btd_device *device, char *name, size_t len); @@ -139,6 +140,11 @@ void device_store_svc_chng_ccc(struct btd_device *device, uint8_t bdaddr_type, uint16_t value); void device_load_svc_chng_ccc(struct btd_device *device, uint16_t *ccc_le, uint16_t *ccc_bredr); +void device_set_wake_support(struct btd_device *device, bool wake_support); +void device_set_wake_override(struct btd_device *device, bool wake_override); +void device_set_wake_allowed(struct btd_device *device, bool wake_allowed, + guint32 id); +void device_set_wake_allowed_complete(struct btd_device *device); typedef void (*disconnect_watch) (struct btd_device *device, gboolean removal, void *user_data); @@ -176,5 +182,9 @@ struct btd_service *btd_device_get_service(struct btd_device *dev, int device_discover_services(struct btd_device *device); int btd_device_connect_services(struct btd_device *dev, GSList *services); +uint32_t btd_device_get_current_flags(struct btd_device *dev); +void btd_device_flags_changed(struct btd_device *dev, uint32_t supported_flags, + uint32_t current_flags); + void btd_device_init(void); void btd_device_cleanup(void); From patchwork Mon Jul 6 20:25:16 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Abhishek Pandit-Subedi X-Patchwork-Id: 11646839 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id E604213B4 for ; Mon, 6 Jul 2020 20:25:37 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id CC4FB215A4 for ; Mon, 6 Jul 2020 20:25:37 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="h0rswxM9" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727088AbgGFUZg (ORCPT ); Mon, 6 Jul 2020 16:25:36 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54618 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727108AbgGFUZf (ORCPT ); Mon, 6 Jul 2020 16:25:35 -0400 Received: from mail-pj1-x1042.google.com (mail-pj1-x1042.google.com [IPv6:2607:f8b0:4864:20::1042]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 31AB9C08C5DF for ; Mon, 6 Jul 2020 13:25:35 -0700 (PDT) Received: by mail-pj1-x1042.google.com with SMTP id o22so12442875pjw.2 for ; Mon, 06 Jul 2020 13:25:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=0LatEk0g8LQ9EDPYxpI3OOipaRxOzP67SKgN1Taywi8=; b=h0rswxM9fGGKb7fWb1RA8CqYAQSY0g4KTkQVjgTXdhC8ClNpny5VVVEZnrCIcgyul9 trqe99WQMNUjPfqZMGWOZ0Qz23qMYB7p3B5KZKn944uU5f8de/0W2oDGDYyAisDT8/Iw vwJASBPafny/VcNzrG4dZ8+6l+9uG+Uh12NyM= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=0LatEk0g8LQ9EDPYxpI3OOipaRxOzP67SKgN1Taywi8=; b=P2wm+m0LZ7H3tTnoSI1diDwSZRgz0ZS+ITfpSiB0lwztJpIraBr8LjMzPymn3yGx/u BY64oTUIaR4lqcOChcc7z4026OkQjnGh3hO+9sEnLjiNdU4jjb3UUq7APs4wfUk5+apc 9i7coGPiavAmXF8dBJVAR8VBnfI13+RBo1t1smtFO5r+S8OMspO6YqoZ77wQLsmDl0u2 nshS68qNe0YmPMf5jWdrEvHEt3610Fks1OvTCzglkkuOHbartMcF6sN2c6XiSA8mtczj x6DG1jEubUNDwsgqvkAzB+GY9wOXIMC0F9l+vVyp0U+tH0532RB3/w0Q423kaIAut1eQ /IvA== X-Gm-Message-State: AOAM533FhVQmrwGDOxZ8sIctATF2wr3tLmpuT9cAQV3+cqOTtou1ajH0 BKB1GFzahNX1vKZDG19ht36ieA== X-Google-Smtp-Source: ABdhPJz/irbGi3WKkdJArD0wq5wK9eVTNJfqtwqTIJCQgjX/dnau3rOffPRsfN3GXLJKGN1dThAqNg== X-Received: by 2002:a17:902:bcc1:: with SMTP id o1mr41810694pls.246.1594067134774; Mon, 06 Jul 2020 13:25:34 -0700 (PDT) Received: from apsdesk.mtv.corp.google.com ([2620:15c:202:1:7220:84ff:fe09:2b94]) by smtp.gmail.com with ESMTPSA id n25sm3320226pff.51.2020.07.06.13.25.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 06 Jul 2020 13:25:34 -0700 (PDT) From: Abhishek Pandit-Subedi To: luiz.dentz@gmail.com, linux-bluetooth@vger.kernel.org Cc: alainm@chromium.org, marcel@holtmann.org, chromeos-bluetooth-upstreaming@chromium.org, Abhishek Pandit-Subedi Subject: [BlueZ PATCH v7 4/6] client: Display wake allowed property with info Date: Mon, 6 Jul 2020 13:25:16 -0700 Message-Id: <20200706132503.BlueZ.v7.4.I45dbf8ee15dff6c9346dc9754574a0be9bee1fa1@changeid> X-Mailer: git-send-email 2.27.0.212.ge8ba1cc988-goog In-Reply-To: <20200706202518.1153647-1-abhishekpandit@chromium.org> References: <20200706202518.1153647-1-abhishekpandit@chromium.org> MIME-Version: 1.0 Sender: linux-bluetooth-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-bluetooth@vger.kernel.org Display whether the device is configured as wake allowed when queried with cmd_info. --- Changes in v7: None Changes in v6: None Changes in v5: None Changes in v4: * Renamed WakeCapable to WakeAllowed Changes in v3: None Changes in v2: * Newly added to show whether device is wake capable * Removed automatically setting wake capable for HID devices client/main.c | 1 + 1 file changed, 1 insertion(+) diff --git a/client/main.c b/client/main.c index 422da5593..4953f50f0 100644 --- a/client/main.c +++ b/client/main.c @@ -1637,6 +1637,7 @@ static void cmd_info(int argc, char *argv[]) print_property(proxy, "Trusted"); print_property(proxy, "Blocked"); print_property(proxy, "Connected"); + print_property(proxy, "WakeAllowed"); print_property(proxy, "LegacyPairing"); print_uuids(proxy); print_property(proxy, "Modalias"); From patchwork Mon Jul 6 20:25:17 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Abhishek Pandit-Subedi X-Patchwork-Id: 11646843 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 7A8EC1398 for ; Mon, 6 Jul 2020 20:25:39 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 61B6E212CC for ; Mon, 6 Jul 2020 20:25:39 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="HwaG98fe" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727124AbgGFUZi (ORCPT ); Mon, 6 Jul 2020 16:25:38 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54624 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727116AbgGFUZg (ORCPT ); Mon, 6 Jul 2020 16:25:36 -0400 Received: from mail-pl1-x643.google.com (mail-pl1-x643.google.com [IPv6:2607:f8b0:4864:20::643]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2A47FC061755 for ; Mon, 6 Jul 2020 13:25:36 -0700 (PDT) Received: by mail-pl1-x643.google.com with SMTP id d10so3743910pll.3 for ; Mon, 06 Jul 2020 13:25:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=QJK/v7CS6qpK7d2NGsWDNwIq2Zg5Zj/Jc/lazqa5Mqo=; b=HwaG98fe6K1/6kIWNzabVqHxk6u50+S0dVD5BXK6ptaw+INBnM0gGzLaAEKadOYfnK JaGhylFLHaJIVyqzZRaIngjbUjdMCgOXTVxNUoM0Z1jIEstmHZTmByVn8PwIZ1CXUsZL jxBY3YoiUW3xScK9B/SxKXMNQmbMxMZoL6vn0= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=QJK/v7CS6qpK7d2NGsWDNwIq2Zg5Zj/Jc/lazqa5Mqo=; b=uQiIzfNtooWcGdudDijiVus9bL9BlwbckPceY3FP5TZDrDN/xCBm/bRNZTjVVaQnEq OvWu1cdRz9izHNbGLbBDzrDRifcTImFE4mkfqd3Yx8yHy7QEHb+vqvxoe0eYhHFWICDR BDrZq7XIE+/AYcSfD1WfhO0nxF//rbkQ6TTFKi/L2ey3xPKSO2cfDUCCIvBTNHPj5eXq zqrd9s61bbb9vVYSvsNtp304zKo0AxHvTD6k+4U8HDlTYYPhJjy5wtaKRNgD5uTx5c2j GbLh9uuIQXqGDSdqc9G7NEiJMn925oJmJgCdD8V2ozX+5lQRL23Xsdc2lf9cbdrGq59K A/Fw== X-Gm-Message-State: AOAM532NpkEBjGxvrT+VFxoT0ecQdD0zM0OMsPP+EgL2hJ2UryGhBXm0 t69wX/MckSA7jJLLhcq3NIcscA== X-Google-Smtp-Source: ABdhPJxFVkbpydRsaYoZNDNe7dTasihd5IQ0YgRzpeJb/dmbK9n8z7KJwU0NI7iyY8PqKpzU7C30nw== X-Received: by 2002:a17:902:7d8f:: with SMTP id a15mr2742106plm.37.1594067135735; Mon, 06 Jul 2020 13:25:35 -0700 (PDT) Received: from apsdesk.mtv.corp.google.com ([2620:15c:202:1:7220:84ff:fe09:2b94]) by smtp.gmail.com with ESMTPSA id n25sm3320226pff.51.2020.07.06.13.25.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 06 Jul 2020 13:25:35 -0700 (PDT) From: Abhishek Pandit-Subedi To: luiz.dentz@gmail.com, linux-bluetooth@vger.kernel.org Cc: alainm@chromium.org, marcel@holtmann.org, chromeos-bluetooth-upstreaming@chromium.org, Abhishek Pandit-Subedi Subject: [BlueZ PATCH v7 5/6] doc/device-api: Add WakeAllowed Date: Mon, 6 Jul 2020 13:25:17 -0700 Message-Id: <20200706132503.BlueZ.v7.5.If391d18ed934a1d9c24d3f54e4fee3fded0b17ab@changeid> X-Mailer: git-send-email 2.27.0.212.ge8ba1cc988-goog In-Reply-To: <20200706202518.1153647-1-abhishekpandit@chromium.org> References: <20200706202518.1153647-1-abhishekpandit@chromium.org> MIME-Version: 1.0 Sender: linux-bluetooth-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-bluetooth@vger.kernel.org Add documentation for WakeAllowed, which allows a device to wake the system from suspend. --- Changes in v7: None Changes in v6: None Changes in v5: None Changes in v4: * Renamed WakeCapable to WakeAllowed Changes in v3: * Added documentation for WakeCapable Changes in v2: None doc/device-api.txt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/doc/device-api.txt b/doc/device-api.txt index 65d8fee37..4e824d2de 100644 --- a/doc/device-api.txt +++ b/doc/device-api.txt @@ -189,6 +189,11 @@ Properties string Address [readonly] drivers will also be removed and no new ones will be probed as long as the device is blocked. + boolean WakeAllowed [readwrite] + + If set to true this device will be allowed to wake the + host from system suspend. + string Alias [readwrite] The name alias for the remote device. The alias can From patchwork Mon Jul 6 20:25:18 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Abhishek Pandit-Subedi X-Patchwork-Id: 11646841 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id C9C0A1398 for ; Mon, 6 Jul 2020 20:25:38 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id ADA9E2158C for ; Mon, 6 Jul 2020 20:25:38 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="WMsRRXFA" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727123AbgGFUZi (ORCPT ); Mon, 6 Jul 2020 16:25:38 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54628 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727108AbgGFUZh (ORCPT ); Mon, 6 Jul 2020 16:25:37 -0400 Received: from mail-pg1-x543.google.com (mail-pg1-x543.google.com [IPv6:2607:f8b0:4864:20::543]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6B951C061755 for ; Mon, 6 Jul 2020 13:25:37 -0700 (PDT) Received: by mail-pg1-x543.google.com with SMTP id k27so2824359pgm.2 for ; Mon, 06 Jul 2020 13:25:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=kufSIwBkTCOC8NS3izomh7PEGJvrLLTDuQTWRmVaS3c=; b=WMsRRXFAsVnGc3JgqeyrWeQNQ0kqBbB8/AHUpF5Kawxj6P7sEJaiFBjkNqjWlRY1RJ eImakgV8lXHteuTc1tsC68NI0T7Ls9JdsEqzOwSHLVfszBYo6g2VXlrYnxdM6W+zyk2T elkNKxlXkoF5C8uTuGksqGWzAbpr/I79+MpEI= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=kufSIwBkTCOC8NS3izomh7PEGJvrLLTDuQTWRmVaS3c=; b=gNsJIdaETgxwMSaS9kZATTq1EmF34X6xZHvRmnaJhybIE3oofXTZvUu2gGqoiGD73G MQuyVUWIppxxQSSy2TjJ45Q9t/sK09bpYZ39nhgnf1HeUDv10QoXAIxBFKbWOXFaBbcQ 7c8VNP1tP4bIhsx6c8LbljrBUppSpohM/PiF2Rs04pu5A/fwcvFhIXGKiXaiz1LbNF0a 7FefgNK5jpLz3iV1uUwyDq9UnTPWTKFmDLMymS0J0xNtGJBppsnHelEteQG8Nik5+wGq ILrVv1W2SKPnOuCf5dKoTex3Dg8+H6C+JSHMmtXIWxkOysATpIlAIDq83l3jf/b1QxZM 08sg== X-Gm-Message-State: AOAM530OPjKmWLJTauTiQNyI44d1C4rK/G0z31rOkzXbXCUbkejtgpsJ KT0P6YceI3zWRDT9Fls9Rqq6LA== X-Google-Smtp-Source: ABdhPJzRQSblEfSUXwfIhsKThWX/YcGcUNbhgVD+xNOMqB7FCxZPtpIPVACoVPl+OklOwZrArP6FeQ== X-Received: by 2002:a65:60d4:: with SMTP id r20mr37992478pgv.436.1594067136842; Mon, 06 Jul 2020 13:25:36 -0700 (PDT) Received: from apsdesk.mtv.corp.google.com ([2620:15c:202:1:7220:84ff:fe09:2b94]) by smtp.gmail.com with ESMTPSA id n25sm3320226pff.51.2020.07.06.13.25.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 06 Jul 2020 13:25:36 -0700 (PDT) From: Abhishek Pandit-Subedi To: luiz.dentz@gmail.com, linux-bluetooth@vger.kernel.org Cc: alainm@chromium.org, marcel@holtmann.org, chromeos-bluetooth-upstreaming@chromium.org, Abhishek Pandit-Subedi Subject: [BlueZ PATCH v7 6/6] input: Make HID devices support wake Date: Mon, 6 Jul 2020 13:25:18 -0700 Message-Id: <20200706132503.BlueZ.v7.6.I3290604153369ff32013f3dcadda4df3f2eb0f36@changeid> X-Mailer: git-send-email 2.27.0.212.ge8ba1cc988-goog In-Reply-To: <20200706202518.1153647-1-abhishekpandit@chromium.org> References: <20200706202518.1153647-1-abhishekpandit@chromium.org> MIME-Version: 1.0 Sender: linux-bluetooth-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-bluetooth@vger.kernel.org HID devices can wake the host from a suspended state. Mark the profiles to support wake when they are accepted. If the device hasn't already been configured with a Wake Allowed configuration, it will default to yes when the profile is accepted. --- Changes in v7: None Changes in v6: None Changes in v5: * Only call device_set_wake_support Changes in v4: * Renamed device_set_profile_wake_support to just device_set_wake_support Changes in v3: * Mark HID device to support wake from suspend Changes in v2: None profiles/input/device.c | 1 + profiles/input/hog.c | 1 + 2 files changed, 2 insertions(+) diff --git a/profiles/input/device.c b/profiles/input/device.c index d3724ed54..2dc2ecab2 100644 --- a/profiles/input/device.c +++ b/profiles/input/device.c @@ -1409,6 +1409,7 @@ int input_device_register(struct btd_service *service) } btd_service_set_user_data(service, idev); + device_set_wake_support(device, true); return 0; } diff --git a/profiles/input/hog.c b/profiles/input/hog.c index 9335b7e8b..130f696a9 100644 --- a/profiles/input/hog.c +++ b/profiles/input/hog.c @@ -166,6 +166,7 @@ static int hog_probe(struct btd_service *service) return -EINVAL; btd_service_set_user_data(service, dev); + device_set_wake_support(device, true); return 0; }