From patchwork Tue Nov 10 07:22:27 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roderick Colenbrander X-Patchwork-Id: 11893425 X-Patchwork-Delegate: jikos@jikos.cz 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 1F907697 for ; Tue, 10 Nov 2020 07:22:39 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id EEA13207BC for ; Tue, 10 Nov 2020 07:22:36 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gaikai-com.20150623.gappssmtp.com header.i=@gaikai-com.20150623.gappssmtp.com header.b="mYS9cE91" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728827AbgKJHWg (ORCPT ); Tue, 10 Nov 2020 02:22:36 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50690 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726307AbgKJHWf (ORCPT ); Tue, 10 Nov 2020 02:22:35 -0500 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 726E9C0613D3 for ; Mon, 9 Nov 2020 23:22:34 -0800 (PST) Received: by mail-pl1-x643.google.com with SMTP id z1so6025785plo.12 for ; Mon, 09 Nov 2020 23:22:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gaikai-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=U2wmd8E30VXBNniV0j7JBzF/Qznio3upP+g2QyP8x4g=; b=mYS9cE91fb2g+uJAhpmy1E1y973b/n5/pO58kNhvZn2AMvwQMDbLeDwaPP+p+Hjuys Im6pd7I3Rqa5l80GERseqP/qLA0VXhnc0P/RIqiFVWoZ45r8JqNVLI1+Lkjt714coIRf Ux/jD5JFKA03F3ZO75J3stg+VglxdH7PZ5EWal2AZkkE+xKAqgcVA/HCAmvfZ9FVix1t ObRVa0FgeV7ZG/MPJZbwt5OTqMz6tgH+5P/H90d+EnEyv4poC03aZe4ztamfrRcYdyaz cuHtiegldW0mOkeUXaJ/syWmr8tkEMAncW6Exe9l1Rgz2P/n/OKY6aFjict1Gmvg93UA 9sbw== 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=U2wmd8E30VXBNniV0j7JBzF/Qznio3upP+g2QyP8x4g=; b=fcUiIv3rt48MqT3kJZZz+xtUu96+qm0+euO461w0KRST1s2K5+yeKbnDXJ9qWE10m2 xJTnZjhOR4WUzgAXK05wd2gHV7HtUwJZZw5y9UQrCQskdTeB6uo/J1hyFOCkcptTkprH GGYchPYZKObiVydDdOYKpWu8qFhLYh1jpxhWTgVWAsvKCQpof2B1gcnyraPQResUr2Ed VHJQKzYn91eeC6CQSYiDwVTmcxuLN2F7DnOTy08R/Bh68jKk+LGtQ7kUh30nfQPYVrMZ bQ74jwXpgGnVRyoU/9O+bdJgB2HNvxmINXr/dLKLOet0+Uc6wjS7rO9VBJsnoHn3mP62 xm8A== X-Gm-Message-State: AOAM531IHbjwmmTAJOlbpk/LHY6tRSiXZ9SOqk3MDOM/PEZEkSeLtUGc JlP+XBxybKfZtjKD+z7bWgmrfA== X-Google-Smtp-Source: ABdhPJxoQlHEaNsVClwIuEAaMOobLE8qOxADKA0A2OoO5YnotFUW0lY5q8BBDlzmStlkqX9GVUJdUQ== X-Received: by 2002:a17:902:8e8b:b029:d2:4276:1df0 with SMTP id bg11-20020a1709028e8bb02900d242761df0mr15609741plb.62.1604992954026; Mon, 09 Nov 2020 23:22:34 -0800 (PST) Received: from us8c16456344dc.lan (cpe-76-87-77-78.socal.res.rr.com. [76.87.77.78]) by smtp.gmail.com with ESMTPSA id j11sm12908189pfh.143.2020.11.09.23.22.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Nov 2020 23:22:33 -0800 (PST) From: Roderick Colenbrander To: Jiri Kosina , Benjamin Tissoires Cc: linux-input@vger.kernel.org, Roderick Colenbrander Subject: [PATCH 1/3] HID: sony: Report more accurate DS4 power status. Date: Mon, 9 Nov 2020 23:22:27 -0800 Message-Id: <20201110072229.9112-2-roderick@gaikai.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20201110072229.9112-1-roderick@gaikai.com> References: <20201110072229.9112-1-roderick@gaikai.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-input@vger.kernel.org From: Roderick Colenbrander This patch moves the power supply status logic to DS3/DS4 parse_report, to allow for more accurate DS4 status reporting. The DS4 power status code was actually incorrect, but reported okay'ish data in most cases. There was a different interpretation of the battery_info values 0-10 or 0-9 depending on cable state. It added +1 to extend the range to 0-10. This is actually incorrect, there is no different range. Values higher than 11 actually indicates 'full' and 14/15 'error' for which we reported 100% and a valid power state. Moving the status logic to parse_report avoids having to pass more state to the generic sony_battery_get_property and simplifies the code. Signed-off-by: Roderick Colenbrander --- drivers/hid/hid-sony.c | 85 +++++++++++++++++++++++++----------------- 1 file changed, 50 insertions(+), 35 deletions(-) diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c index 2f073f536070..81d526a5d003 100644 --- a/drivers/hid/hid-sony.c +++ b/drivers/hid/hid-sony.c @@ -562,9 +562,8 @@ struct sony_sc { u8 hotplug_worker_initialized; u8 state_worker_initialized; u8 defer_initialization; - u8 cable_state; - u8 battery_charging; u8 battery_capacity; + int battery_status; u8 led_state[MAX_LEDS]; u8 led_delay_on[MAX_LEDS]; u8 led_delay_off[MAX_LEDS]; @@ -892,7 +891,8 @@ static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size) static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 }; unsigned long flags; int offset; - u8 cable_state, battery_capacity, battery_charging; + u8 battery_capacity; + int battery_status; /* * The sixaxis is charging if the battery value is 0xee @@ -904,19 +904,16 @@ static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size) if (rd[offset] >= 0xee) { battery_capacity = 100; - battery_charging = !(rd[offset] & 0x01); - cable_state = 1; + battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING; } else { u8 index = rd[offset] <= 5 ? rd[offset] : 5; battery_capacity = sixaxis_battery_capacity[index]; - battery_charging = 0; - cable_state = 0; + battery_status = POWER_SUPPLY_STATUS_DISCHARGING; } spin_lock_irqsave(&sc->lock, flags); - sc->cable_state = cable_state; sc->battery_capacity = battery_capacity; - sc->battery_charging = battery_charging; + sc->battery_status = battery_status; spin_unlock_irqrestore(&sc->lock, flags); if (sc->quirks & SIXAXIS_CONTROLLER) { @@ -944,7 +941,8 @@ static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size) struct input_dev *input_dev = hidinput->input; unsigned long flags; int n, m, offset, num_touch_data, max_touch_data; - u8 cable_state, battery_capacity, battery_charging; + u8 cable_state, battery_capacity; + int battery_status; u16 timestamp; /* When using Bluetooth the header is 2 bytes longer, so skip these. */ @@ -1049,29 +1047,52 @@ static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size) */ offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET; cable_state = (rd[offset] >> 4) & 0x01; - battery_capacity = rd[offset] & 0x0F; /* - * When a USB power source is connected the battery level ranges from - * 0 to 10, and when running on battery power it ranges from 0 to 9. - * A battery level above 10 when plugged in means charge completed. + * Interpretation of the battery_capacity data depends on the cable state. + * When no cable is connected (bit4 is 0): + * - 0:10: percentage in units of 10%. + * When a cable is plugged in: + * - 0-10: percentage in units of 10%. + * - 11: battery is full + * - 14: not charging due to Voltage or temperature error + * - 15: charge error */ - if (!cable_state || battery_capacity > 10) - battery_charging = 0; - else - battery_charging = 1; + if (cable_state) { + u8 battery_data = rd[offset] & 0xf; + + if (battery_data < 10) { + /* Take the mid-point for each battery capacity value, + * because on the hardware side 0 = 0-9%, 1=10-19%, etc. + * This matches official platform behavior, which does + * the same. + */ + battery_capacity = battery_data * 10 + 5; + battery_status = POWER_SUPPLY_STATUS_CHARGING; + } else if (battery_data == 10) { + battery_capacity = 100; + battery_status = POWER_SUPPLY_STATUS_CHARGING; + } else if (battery_data == 11) { + battery_capacity = 100; + battery_status = POWER_SUPPLY_STATUS_FULL; + } else { /* 14, 15 and undefined values */ + battery_capacity = 0; + battery_status = POWER_SUPPLY_STATUS_UNKNOWN; + } + } else { + u8 battery_data = rd[offset] & 0xf; - if (!cable_state) - battery_capacity++; - if (battery_capacity > 10) - battery_capacity = 10; + if (battery_data < 10) + battery_capacity = battery_data * 10 + 5; + else /* 10 */ + battery_capacity = 100; - battery_capacity *= 10; + battery_status = POWER_SUPPLY_STATUS_DISCHARGING; + } spin_lock_irqsave(&sc->lock, flags); - sc->cable_state = cable_state; sc->battery_capacity = battery_capacity; - sc->battery_charging = battery_charging; + sc->battery_status = battery_status; spin_unlock_irqrestore(&sc->lock, flags); /* @@ -2300,12 +2321,12 @@ static int sony_battery_get_property(struct power_supply *psy, struct sony_sc *sc = power_supply_get_drvdata(psy); unsigned long flags; int ret = 0; - u8 battery_charging, battery_capacity, cable_state; + u8 battery_capacity; + int battery_status; spin_lock_irqsave(&sc->lock, flags); - battery_charging = sc->battery_charging; battery_capacity = sc->battery_capacity; - cable_state = sc->cable_state; + battery_status = sc->battery_status; spin_unlock_irqrestore(&sc->lock, flags); switch (psp) { @@ -2319,13 +2340,7 @@ static int sony_battery_get_property(struct power_supply *psy, val->intval = battery_capacity; break; case POWER_SUPPLY_PROP_STATUS: - if (battery_charging) - val->intval = POWER_SUPPLY_STATUS_CHARGING; - else - if (battery_capacity == 100 && cable_state) - val->intval = POWER_SUPPLY_STATUS_FULL; - else - val->intval = POWER_SUPPLY_STATUS_DISCHARGING; + val->intval = battery_status; break; default: ret = -EINVAL; From patchwork Tue Nov 10 07:22:28 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roderick Colenbrander X-Patchwork-Id: 11893427 X-Patchwork-Delegate: jikos@jikos.cz 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 594421746 for ; Tue, 10 Nov 2020 07:22:39 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 37869206B6 for ; Tue, 10 Nov 2020 07:22:39 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gaikai-com.20150623.gappssmtp.com header.i=@gaikai-com.20150623.gappssmtp.com header.b="do5YO04l" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730756AbgKJHWh (ORCPT ); Tue, 10 Nov 2020 02:22:37 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50694 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726307AbgKJHWg (ORCPT ); Tue, 10 Nov 2020 02:22:36 -0500 Received: from mail-pf1-x443.google.com (mail-pf1-x443.google.com [IPv6:2607:f8b0:4864:20::443]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 79147C0613CF for ; Mon, 9 Nov 2020 23:22:35 -0800 (PST) Received: by mail-pf1-x443.google.com with SMTP id z3so10571923pfb.10 for ; Mon, 09 Nov 2020 23:22:35 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gaikai-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=HG6fQ6KNywoEbOA0cD3Y/aR1fh1NyyLoymuYZZrgbZw=; b=do5YO04lrX0/rF2F3YI4gmcmlfMn1MAaoEDMPj52HvMD+ux6sX9hue0lVly/0HLXzJ W179YVkPnk4/Gl63NMhADwR12WuJLVvbYg2o5HQVTqr7h9NZg3Els7HMLX92GiLGj5bE YQo6/Bn1DzQp/KnnIdVSV8LI9nkgRgEfUKQXYl5mN4n8FMhlMejkrCIDDfZyDKIcf7Nw 9LIcqTR9WRA+reu187G+Nmaq3lMZxLur2PzT5Tr0Ugns9Aq3D2EehlpNhH/wddTFKy7t ryyfJ12D050PjR3FW+F7KzbmIQsQ72YCkON2uSYOyxyzC3T1iisFSNmfvtyT85o5Tc00 qDYw== 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=HG6fQ6KNywoEbOA0cD3Y/aR1fh1NyyLoymuYZZrgbZw=; b=SPV+WW4lF11v7RIuLnLUyPjdRGsE++yHUS+THILQAumQlKxhbAnkVLO0zkKz9UkE/H 7/WY4fwPfoee0UMu7B1/iUMOstBtEj1Okegy+gwVSuzbTr4Ph2BlKMgZHbaNmvVDs34w Ip9YrVuMBjVHDpah0SP6NiY0JXdOy68W4p5lx+pH+nrq+YeuSAiNDQt1C00f/XWmmQYH CWIWK9p+w9feewoFCU5Lso/QQMqdOmUp+y81dn6Ks5UnDJJYxdFR8bB+kiyswVj+OxOb jSeZyNjicLTOCdgM9VpUbSkxfNUTIuWxiZJa7aeXXiRoqKksByva8B+FL9RdB/naGrQq PXTg== X-Gm-Message-State: AOAM532YEMoBUm0NtXNs89W8V3Ze9qrvsdrIQTza0BNurzGxx6K2EUWc sUFalmVumdRFLxYMFg3W8B7OSw== X-Google-Smtp-Source: ABdhPJxxPKjhqGVz6IOcopmEDWvy/qq4GcKC+i5/HaXw67N1hA+y9/JQUuK//ht9rcb7YHYdHzS/zw== X-Received: by 2002:a63:221d:: with SMTP id i29mr16073353pgi.69.1604992955070; Mon, 09 Nov 2020 23:22:35 -0800 (PST) Received: from us8c16456344dc.lan (cpe-76-87-77-78.socal.res.rr.com. [76.87.77.78]) by smtp.gmail.com with ESMTPSA id j11sm12908189pfh.143.2020.11.09.23.22.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Nov 2020 23:22:34 -0800 (PST) From: Roderick Colenbrander To: Jiri Kosina , Benjamin Tissoires Cc: linux-input@vger.kernel.org, Roderick Colenbrander Subject: [PATCH 2/3] HID: sony: Workaround for DS4 dongle hotplug kernel crash. Date: Mon, 9 Nov 2020 23:22:28 -0800 Message-Id: <20201110072229.9112-3-roderick@gaikai.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20201110072229.9112-1-roderick@gaikai.com> References: <20201110072229.9112-1-roderick@gaikai.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-input@vger.kernel.org From: Roderick Colenbrander The hid-sony driver has custom DS4 connect/disconnect logic for the DS4 dongle, which is a USB dongle acting as a proxy to Bluetooth connected DS4. The connect/disconnect logic works fine generally, however not in conjunction with Steam. Steam implements its own DS4 driver using hidraw. Both hid-sony and Steam are issuing their own HID requests and are racing each other during DS4 dongle connect/disconnect resulting in a kernel crash in hid-sony. The problem is that upon a DS4 connect to the dongle, hid-sony kicks of 'ds4_get_calibration_data' from within its dongle hotplug code. The calibration code issues raw HID feature report for reportID 0x02. When Steam is running, it issues a feature report for reportID 0x12 typically just prior to hid-sony requesting feature reportID 0x02. The result is that 'ds4_get_calibration_data' receives the data Steam requested as that's the HID report returing first. Currently this results in it processing invalid data, which ultimately results in a divide by zero upon a future 'dualshock4_parse_report'. The solution for now is to check within 'ds4_get_calibration_data' to check if we received data for the feature report we issued and if not retry. This fixes bug 206785. Signed-off-by: Roderick Colenbrander --- drivers/hid/hid-sony.c | 34 ++++++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c index 81d526a5d003..83a94ddbfa4e 100644 --- a/drivers/hid/hid-sony.c +++ b/drivers/hid/hid-sony.c @@ -1618,16 +1618,38 @@ static int dualshock4_get_calibration_data(struct sony_sc *sc) * of the controller, so that it sends input reports of type 0x11. */ if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) { + int retries; + buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL); if (!buf) return -ENOMEM; - ret = hid_hw_raw_request(sc->hdev, 0x02, buf, - DS4_FEATURE_REPORT_0x02_SIZE, - HID_FEATURE_REPORT, - HID_REQ_GET_REPORT); - if (ret < 0) - goto err_stop; + /* We should normally receive the feature report data we asked + * for, but hidraw applications such as Steam can issue feature + * reports as well. In particular for Dongle reconnects, Steam + * and this function are competing resulting in often receiving + * data for a different HID report, so retry a few times. + */ + for (retries = 0; retries < 3; retries++) { + ret = hid_hw_raw_request(sc->hdev, 0x02, buf, + DS4_FEATURE_REPORT_0x02_SIZE, + HID_FEATURE_REPORT, + HID_REQ_GET_REPORT); + if (ret < 0) + goto err_stop; + + if (buf[0] != 0x02) { + if (retries < 2) { + hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report (0x02) request\n"); + continue; + } else { + ret = -EILSEQ; + goto err_stop; + } + } else { + break; + } + } } else { u8 bthdr = 0xA3; u32 crc; From patchwork Tue Nov 10 07:22:29 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roderick Colenbrander X-Patchwork-Id: 11893429 X-Patchwork-Delegate: jikos@jikos.cz 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 95B6316C1 for ; Tue, 10 Nov 2020 07:22:39 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 68691206B6 for ; Tue, 10 Nov 2020 07:22:39 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gaikai-com.20150623.gappssmtp.com header.i=@gaikai-com.20150623.gappssmtp.com header.b="lrEVIlQS" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730883AbgKJHWi (ORCPT ); Tue, 10 Nov 2020 02:22:38 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50700 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726307AbgKJHWh (ORCPT ); Tue, 10 Nov 2020 02:22:37 -0500 Received: from mail-pl1-x641.google.com (mail-pl1-x641.google.com [IPv6:2607:f8b0:4864:20::641]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 78F78C0613D3 for ; Mon, 9 Nov 2020 23:22:36 -0800 (PST) Received: by mail-pl1-x641.google.com with SMTP id k7so6044381plk.3 for ; Mon, 09 Nov 2020 23:22:36 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gaikai-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=YnHa/F/HaGv4VR0sa6+1zv7CJdR4JYv3dYH/evzFgeA=; b=lrEVIlQSybTMZqqqf0stJtBOhnMev9nPe6OWeGJUOLEVUkRigL/qJn4/82Jn2XZowR x7wevF4OyK3jv7Wby1r684nZ+UExXhve848e0Jy8ruXA51n32j1L8cXkAc/BSNG+VErH h2vWLurpSzWxU+NAo7Db91NETch+PM9lV5kqzPe1n1ZUoysGP6LKEMld6fW6YDvl3uFE NnuS7hJ/MOPefVlSzLWcrxEGUMXtmV/jAHLsMA4sj0JZ+4LYQvl36wS8dVEu1GRKxBJc knPzmwmQu0R8NJ+r8jQCd5iCAtXdGTm/jSGOmZGkU9iiNkCr7sfT2hYf32ofdOBzDXn4 BEjw== 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=YnHa/F/HaGv4VR0sa6+1zv7CJdR4JYv3dYH/evzFgeA=; b=PzZKThEZHSthhdoIaNaJzLyBPiW0dmZxvkfTnUWh+yVWS7ZhEgeK39wg2dDbCgbNPC /EEFqdUQMO0AE1NaD+7Qg2vEldhLKzLyDHXVL3EVzY0la8/sBOjS/M+ZCzaz+0SEErAg fhZn0kK4DN4LvwaaPd38zu5NuY+/KRzFse2p95ryuSzN2Lq1GpLTSGvKPAKDeWfYsWmQ 2kAdqLObDea2CtEyzYWFbzaBAB9EfK6wAPhpBJEF6YyioLOl7wlyG4XhgN3gD0NLUixw L4rCjQDFw2wi1tdS9B+Pb1j6bKUfDedL6pZPfB7GxkCX6HwoEKAIkrNgAZGWjt3a07tF lnqQ== X-Gm-Message-State: AOAM530qX8iCgzyPhpR0z64QUpJSxuFQviIxjtk+RKLkHF8vg1Qg9NVV 8QZDQIxxI7LzyamBQWVLS2rIjg== X-Google-Smtp-Source: ABdhPJzKqYFx+M3yTNw8rMgDtwc++h/c3rGnTHP9JyEk82PTX9ABBjlq8Dzfz/rVjCx9wuWXTMcrmQ== X-Received: by 2002:a17:902:bccb:b029:d6:fa5c:b481 with SMTP id o11-20020a170902bccbb02900d6fa5cb481mr15697400pls.17.1604992956087; Mon, 09 Nov 2020 23:22:36 -0800 (PST) Received: from us8c16456344dc.lan (cpe-76-87-77-78.socal.res.rr.com. [76.87.77.78]) by smtp.gmail.com with ESMTPSA id j11sm12908189pfh.143.2020.11.09.23.22.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Nov 2020 23:22:35 -0800 (PST) From: Roderick Colenbrander To: Jiri Kosina , Benjamin Tissoires Cc: linux-input@vger.kernel.org, Roderick Colenbrander Subject: [PATCH 3/3] HID: sony: Don't use fw_version/hw_version for sysfs cleanup. Date: Mon, 9 Nov 2020 23:22:29 -0800 Message-Id: <20201110072229.9112-4-roderick@gaikai.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20201110072229.9112-1-roderick@gaikai.com> References: <20201110072229.9112-1-roderick@gaikai.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-input@vger.kernel.org From: Roderick Colenbrander The DS4 dongle reports fw_version and hw_version as 0 when no actual DS4 is connected to it. This prevents cleaning up sysfs nodes upon device remove. This patch decouples sysfs cleanup from the fw_version and hw_version values by introducing boolean values. Signed-off-by: Roderick Colenbrander --- drivers/hid/hid-sony.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c index 83a94ddbfa4e..124ed4806c78 100644 --- a/drivers/hid/hid-sony.c +++ b/drivers/hid/hid-sony.c @@ -550,7 +550,9 @@ struct sony_sc { struct power_supply_desc battery_desc; int device_id; unsigned fw_version; + bool fw_version_created; unsigned hw_version; + bool hw_version_created; u8 *output_report_dmabuf; #ifdef CONFIG_SONY_FF @@ -2760,19 +2762,17 @@ static int sony_input_configured(struct hid_device *hdev, ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version); if (ret) { - /* Make zero for cleanup reasons of sysfs entries. */ - sc->fw_version = 0; - sc->hw_version = 0; hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret); goto err_stop; } + sc->fw_version_created = true; ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version); if (ret) { - sc->hw_version = 0; hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret); goto err_stop; } + sc->hw_version_created = true; /* * The Dualshock 4 touchpad supports 2 touches and has a @@ -2864,9 +2864,9 @@ static int sony_input_configured(struct hid_device *hdev, */ if (sc->ds4_bt_poll_interval) device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval); - if (sc->fw_version) + if (sc->fw_version_created) device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version); - if (sc->hw_version) + if (sc->hw_version_created) device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version); sony_cancel_work_sync(sc); sony_remove_dev_list(sc); @@ -2951,10 +2951,10 @@ static void sony_remove(struct hid_device *hdev) if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval); - if (sc->fw_version) + if (sc->fw_version_created) device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version); - if (sc->hw_version) + if (sc->hw_version_created) device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version); sony_cancel_work_sync(sc);