From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.0 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_SIGNED,DKIM_VALID,FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 34DD6C433E0 for ; Wed, 15 Jul 2020 13:19:42 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id E579A20657 for ; Wed, 15 Jul 2020 13:19:41 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="S/0spRFm"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="V/2gqczV" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E579A20657 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-Id:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=rnQl+dWpuYHwcfrrFeDuOg+iQSuRKg0nS4gK8EJDEHo=; b=S/0spRFm7qitPHaWdMArrE73G PGP5gbI53gFZ/Ufav2b8MQd/M/wdrZ+lLJVTVn0QfVT8bhtZ7JUVMhS26iLeivBbTNNGdL/4wJVgJ WnsyqkCzzBGC+Wz+3UJgc+rs7pvk1B6khIaqRiN3DLokFP7cBlaDBkoIsRcAYXsAhlhoaQsRzq2Jl M8ChzsKqwvv4xrG2V3wOEDyFnSqf3IkYuVJ2b6105gEtRvUiYm7dEHJzvbZnhfuM+XyOvTYFNUt+4 ycWI+DQTRKjI57ATfEH9/uSJwb6TlZRUb8TQCYJ5c8m5sFyqvTBWAIhQmcusVaa9SthnACtGt/L5m oWeswzFlA==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jvhIf-00086V-HN; Wed, 15 Jul 2020 13:18:17 +0000 Received: from mail-wm1-x344.google.com ([2a00:1450:4864:20::344]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jvhIY-000840-1f for linux-arm-kernel@lists.infradead.org; Wed, 15 Jul 2020 13:18:11 +0000 Received: by mail-wm1-x344.google.com with SMTP id o8so5565456wmh.4 for ; Wed, 15 Jul 2020 06:18:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ai1ju57KHlhDmSzcsfVEP+Q7j9oUrLJWPNrHnQlYoTU=; b=V/2gqczVgDIJQOBuQ9y4yrL26IyM+quvqDMn4trfgIu4hFArRAxU/OMe6s4GIhvuB1 9t9oHkJnVYgehrvm18MZ10qLNWgaeyPo5M00yBExtYWTSWXY31HI3FBqkOdPh+z/7pu4 FWoLAYi+3qpQTYG7Ky+DMR7wX2TuHYGgVgaOF5wdfhji21tedZXr53aB2gZKCG7rYfWb cXI+IYwUZ2s322m29gXKuAVqcc2ldfP70UguwGWZ4PnlKIo1ZHlZ4IARtBIdhdWW/Clr c1qcBIXtO73CoiHDE9NoI3wwOo0D5m0kPQBKD69fm32fYv6gDg4u0FcfB5G06yHfbAS5 peEg== 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=ai1ju57KHlhDmSzcsfVEP+Q7j9oUrLJWPNrHnQlYoTU=; b=VOiYt1SpmorxBO2N3woIym5WXISBBmkm/6lIs68prA9AV6EUsbeDKv80dd4sHOdxD+ z+l9BU1YL4TdU2Z1GxARa3esgZTfIUvteOzX8ZS29ziDeg48mp+LLOyRi/IERpaRLlEV fO197N1mPXaJlp341jDXdEx5Cg8TZtuN3fGgf+tIV99WtApjS5TCnQsmGG8IbNxGUQXD 8g80VlyFpJuZ/quI767+k6Pokg+aDi3/SEK4dav45EKyjKu3XiO27TCOERdPbYc3I28j V2BWTECe7WNrZiA/KrAlmLR69C3rfWUjnMqr8XQhzftpCqjTb42P5lPDWvJEO+51zOWz Ggfw== X-Gm-Message-State: AOAM531e/5miQQ4l5ftO+ckKw533JDsDVM5w2oTw4v0VfE/H+okwcHRJ rIxrcvn3bN7LmhBfMB+gvfw= X-Google-Smtp-Source: ABdhPJwd0mRd0NZjdYqG9pETMDLksHl9bYKmjRCkQsD5n4TE4uQdSt6G5KLlhDmQ8taQxgvhP/B0ng== X-Received: by 2002:a05:600c:2050:: with SMTP id p16mr8401066wmg.44.1594819088863; Wed, 15 Jul 2020 06:18:08 -0700 (PDT) Received: from skynet.lan (67.red-88-15-120.dynamicip.rima-tde.net. [88.15.120.67]) by smtp.gmail.com with ESMTPSA id j145sm3623650wmj.7.2020.07.15.06.18.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 15 Jul 2020 06:18:08 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: simon@arlott.org, jonas.gorski@gmail.com, kishon@ti.com, vkoul@kernel.org, robh+dt@kernel.org, f.fainelli@gmail.com, bcm-kernel-feedback-list@broadcom.com, p.zabel@pengutronix.de, krzk@kernel.org, gregkh@linuxfoundation.org, alcooperx@gmail.com, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v6 2/2] phy: bcm63xx-usbh: Add BCM63xx USBH driver Date: Wed, 15 Jul 2020 15:18:03 +0200 Message-Id: <20200715131803.1762064-3-noltari@gmail.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20200715131803.1762064-1-noltari@gmail.com> References: <20200715131803.1762064-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200715_091810_153397_ED070185 X-CRM114-Status: GOOD ( 23.59 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org QWRkIEJDTTYzeHggVVNCSCBQSFkgZHJpdmVyIGZvciBCTUlQUy4KClNpZ25lZC1vZmYtYnk6IMOB bHZhcm8gRmVybsOhbmRleiBSb2phcyA8bm9sdGFyaUBnbWFpbC5jb20+Ci0tLQogdjY6IGludHJv ZHVjZSBjaGFuZ2VzIHN1Z2dlc3RlZCBieSBWaW5vZDoKICAtIFJlbW92ZSBCTUlQU19HRU5FUklD IGRlZmF1bHQgZnJvbSBrY29uZmlnLgogIC0gUHJpbnQgcmVnaXN0ZXJlZCBtZXNzYWdlIGFzIGRl YnVnLgogdjU6IHVzZSBkZXZtX3Jlc2V0X2NvbnRyb2xfZ2V0X2V4Y2x1c2l2ZS4KIHY0OiBzZXZl cmFsIGltcHJvdmVtZW50czoKICAtIFVzZSBkZXZtX3BsYXRmb3JtX2lvcmVtYXBfcmVzb3VyY2Uu CiAgLSBDb2RlIGNsZWFudXBzLgogIC0gSW1wcm92ZSBkZXZpY2UgbW9kZSBjb25maWc6CiAgICAt IE1vdmUgVVNCSF9TV0FQX0NPTlRST0wgZGV2aWNlIG1vZGUgdmFsdWUgdG8gdmFyaWFudCB2YXJp YWJsZS4KICAgIC0gU2V0IFVTQkhfVVRNSV9DT05UUk9MMSByZWdpc3RlciB2YWx1ZSAodmFyaWFu dCB2YXJpYWJsZSkuCiB2MzogaW50cm9kdWNlIGNoYW5nZXMgc3VnZ2VzdGVkIGJ5IEZsb3JpYW46 CiAgLSBBZGQgc3VwcG9ydCBmb3IgZGV2aWNlIG1vZGUuCiB2MjogaW50cm9kdWNlIGNoYW5nZXMg c3VnZ2VzdGVkIGJ5IEZsb3JpYW46CiAgLSBEcm9wIE9GIGRlcGVuZGVuY3kgKHVzZSBkZXZpY2Vf Z2V0X21hdGNoX2RhdGEpLgogIC0gRHJvcCBfX2luaXRjb25zdCBmcm9tIHZhcmlhbnQgdGFibGVz LgogIC0gVXNlIGRldm1fY2xrX2dldF9vcHRpb25hbC4KCiBkcml2ZXJzL3BoeS9icm9hZGNvbS9L Y29uZmlnICAgICAgICAgICAgfCAgIDggKwogZHJpdmVycy9waHkvYnJvYWRjb20vTWFrZWZpbGUg ICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMvcGh5L2Jyb2FkY29tL3BoeS1iY202M3h4LXVzYmgu YyB8IDQ1NyArKysrKysrKysrKysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgNDY2IGlu c2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3BoeS9icm9hZGNvbS9waHkt YmNtNjN4eC11c2JoLmMKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BoeS9icm9hZGNvbS9LY29uZmln IGIvZHJpdmVycy9waHkvYnJvYWRjb20vS2NvbmZpZwppbmRleCBiMjlmMTFjMTkxNTUuLmExZjFh OWM5MGQwZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9waHkvYnJvYWRjb20vS2NvbmZpZworKysgYi9k cml2ZXJzL3BoeS9icm9hZGNvbS9LY29uZmlnCkBAIC0yLDYgKzIsMTQgQEAKICMKICMgUGh5IGRy aXZlcnMgZm9yIEJyb2FkY29tIHBsYXRmb3JtcwogIworY29uZmlnIFBIWV9CQ002M1hYX1VTQkgK Kwl0cmlzdGF0ZSAiQkNNNjN4eCBVU0JIIFBIWSBkcml2ZXIiCisJZGVwZW5kcyBvbiBCTUlQU19H RU5FUklDIHx8IENPTVBJTEVfVEVTVAorCXNlbGVjdCBHRU5FUklDX1BIWQorCWhlbHAKKwkgIEVu YWJsZSB0aGlzIHRvIHN1cHBvcnQgdGhlIEJDTTYzeHggVVNCSCBQSFkgZHJpdmVyLgorCSAgSWYg dW5zdXJlLCBzYXkgTi4KKwogY29uZmlnIFBIWV9DWUdOVVNfUENJRQogCXRyaXN0YXRlICJCcm9h ZGNvbSBDeWdudXMgUENJZSBQSFkgZHJpdmVyIgogCWRlcGVuZHMgb24gT0YgJiYgKEFSQ0hfQkNN X0NZR05VUyB8fCBDT01QSUxFX1RFU1QpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BoeS9icm9hZGNv bS9NYWtlZmlsZSBiL2RyaXZlcnMvcGh5L2Jyb2FkY29tL01ha2VmaWxlCmluZGV4IGM3OGRlNTQ2 MTM1Yy4uNzAyNDEyN2Y4NmFkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BoeS9icm9hZGNvbS9NYWtl ZmlsZQorKysgYi9kcml2ZXJzL3BoeS9icm9hZGNvbS9NYWtlZmlsZQpAQCAtMSw0ICsxLDUgQEAK ICMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKK29iai0kKENPTkZJR19QSFlfQkNN NjNYWF9VU0JIKQkJKz0gcGh5LWJjbTYzeHgtdXNiaC5vCiBvYmotJChDT05GSUdfUEhZX0NZR05V U19QQ0lFKQkJKz0gcGh5LWJjbS1jeWdudXMtcGNpZS5vCiBvYmotJChDT05GSUdfQkNNX0tPTkFf VVNCMl9QSFkpCQkrPSBwaHktYmNtLWtvbmEtdXNiMi5vCiBvYmotJChDT05GSUdfUEhZX0JDTV9O U19VU0IyKQkJKz0gcGh5LWJjbS1ucy11c2IyLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGh5L2Jy b2FkY29tL3BoeS1iY202M3h4LXVzYmguYyBiL2RyaXZlcnMvcGh5L2Jyb2FkY29tL3BoeS1iY202 M3h4LXVzYmguYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjliYjI2 ODFhZGIxNAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvcGh5L2Jyb2FkY29tL3BoeS1iY202 M3h4LXVzYmguYwpAQCAtMCwwICsxLDQ1NyBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IEdQTC0yLjAtb3ItbGF0ZXIKKy8qCisgKiBCQ002MzI4IFVTQkggUEhZIENvbnRyb2xsZXIgRHJp dmVyCisgKgorICogQ29weXJpZ2h0IChDKSAyMDIwIMOBbHZhcm8gRmVybsOhbmRleiBSb2phcyA8 bm9sdGFyaUBnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTUgU2ltb24gQXJsb3R0IDxz aW1vbkBmaXJlLmxwMC5ldT4KKyAqCisgKiBEZXJpdmVkIGZyb20gYmNtOTYzeHhfNC4xMkwuMDZC X2NvbnN1bWVyL2tlcm5lbC9saW51eC9hcmNoL21pcHMvYmNtOTYzeHgvc2V0dXAuYzoKKyAqIENv cHlyaWdodCAoQykgMjAwMiBCcm9hZGNvbSBDb3Jwb3JhdGlvbgorICoKKyAqIERlcml2ZWQgZnJv bSBPcGVuV3J0IHBhdGNoZXM6CisgKiBDb3B5cmlnaHQgKEMpIDIwMTMgSm9uYXMgR29yc2tpIDxq b25hcy5nb3Jza2lAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChDKSAyMDEzIEZsb3JpYW4gRmFp bmVsbGkgPGYuZmFpbmVsbGlAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChDKSAyMDA4IE1heGlt ZSBCaXpvbiA8bWJpem9uQGZyZWVib3guZnI+CisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2Nsay5o PgorI2luY2x1ZGUgPGxpbnV4L2lvLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5j bHVkZSA8bGludXgvcGh5L3BoeS5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5o PgorI2luY2x1ZGUgPGxpbnV4L3Jlc2V0Lmg+CisKKy8qIFVTQkggY29udHJvbCByZWdpc3RlciBv ZmZzZXRzICovCitlbnVtIHVzYmhfcmVncyB7CisJVVNCSF9CUlRfQ09OVFJPTDEgPSAwLAorCVVT QkhfQlJUX0NPTlRST0wyLAorCVVTQkhfQlJUX1NUQVRVUzEsCisJVVNCSF9CUlRfU1RBVFVTMiwK KwlVU0JIX1VUTUlfQ09OVFJPTDEsCisjZGVmaW5lICAgVVNCSF9VQzFfREVWX01PREVfU0VMCQlC SVQoMCkKKwlVU0JIX1RFU1RfUE9SVF9DT05UUk9MLAorCVVTQkhfUExMX0NPTlRST0wxLAorI2Rl ZmluZSAgIFVTQkhfUExMQ19SRUZDTEtTRUxfU0hJRlQJMAorI2RlZmluZSAgIFVTQkhfUExMQ19S RUZDTEtTRUxfTUFTSwkoMHgzIDw8IFVTQkhfUExMQ19SRUZDTEtTRUxfU0hJRlQpCisjZGVmaW5l ICAgVVNCSF9QTExDX0NMS1NFTF9TSElGVAkyCisjZGVmaW5lICAgVVNCSF9QTExDX0NMS1NFTF9N QVNLCQkoMHgzIDw8IFVTQkhfUExMQ19DTEtTRUxfTUFTSykKKyNkZWZpbmUgICBVU0JIX1BMTENf WFRBTF9QV1JEV05CCUJJVCg0KQorI2RlZmluZSAgIFVTQkhfUExMQ19QTExfUFdSRFdOQgkJQklU KDUpCisjZGVmaW5lICAgVVNCSF9QTExDX1BMTF9DQUxFTgkJQklUKDYpCisjZGVmaW5lICAgVVNC SF9QTExDX1BIWVBMTF9CWVAJCUJJVCg3KQorI2RlZmluZSAgIFVTQkhfUExMQ19QTExfUkVTRVQJ CUJJVCg4KQorI2RlZmluZSAgIFVTQkhfUExMQ19QTExfSUREUV9QV1JETglCSVQoOSkKKyNkZWZp bmUgICBVU0JIX1BMTENfUExMX1BXUkROX0RFTEFZCUJJVCgxMCkKKyNkZWZpbmUgICBVU0JIXzYz MThfUExMQ19QTExfU1VTUEVORF9FTglCSVQoMjcpCisjZGVmaW5lICAgVVNCSF82MzE4X1BMTENf UEhZUExMX0JZUAlCSVQoMjkpCisjZGVmaW5lICAgVVNCSF82MzE4X1BMTENfUExMX1JFU0VUCUJJ VCgzMCkKKyNkZWZpbmUgICBVU0JIXzYzMThfUExMQ19QTExfSUREUV9QV1JETglCSVQoMzEpCisJ VVNCSF9TV0FQX0NPTlRST0wsCisjZGVmaW5lICAgVVNCSF9TQ19PSENJX0RBVEFfU1dBUAlCSVQo MCkKKyNkZWZpbmUgICBVU0JIX1NDX09IQ0lfRU5ESUFOX1NXQVAJQklUKDEpCisjZGVmaW5lICAg VVNCSF9TQ19PSENJX0xPR0lDQUxfQUREUl9FTglCSVQoMikKKyNkZWZpbmUgICBVU0JIX1NDX0VI Q0lfREFUQV9TV0FQCUJJVCgzKQorI2RlZmluZSAgIFVTQkhfU0NfRUhDSV9FTkRJQU5fU1dBUAlC SVQoNCkKKyNkZWZpbmUgICBVU0JIX1NDX0VIQ0lfTE9HSUNBTF9BRERSX0VOCUJJVCg1KQorI2Rl ZmluZSAgIFVTQkhfU0NfVVNCX0RFVklDRV9TRUwJQklUKDYpCisJVVNCSF9HRU5FUklDX0NPTlRS T0wsCisjZGVmaW5lICAgVVNCSF9HQ19QTExfU1VTUEVORF9FTglCSVQoMSkKKwlVU0JIX0ZSQU1F X0FESlVTVF9WQUxVRSwKKwlVU0JIX1NFVFVQLAorI2RlZmluZSAgIFVTQkhfU19JT0MJCQlCSVQo NCkKKyNkZWZpbmUgICBVU0JIX1NfSVBQCQkJQklUKDUpCisJVVNCSF9NRElPLAorCVVTQkhfTURJ TzMyLAorCVVTQkhfVVNCX1NJTV9DT05UUk9MLAorI2RlZmluZSAgIFVTQkhfVVNDX0xBRERSX1NF TAkJQklUKDUpCisKKwlfX1VTQkhfRU5VTV9TSVpFCit9OworCitzdHJ1Y3QgYmNtNjN4eF91c2Jo X3BoeV92YXJpYW50IHsKKwkvKiBSZWdpc3RlcnMgKi8KKwlsb25nIHJlZ3NbX19VU0JIX0VOVU1f U0laRV07CisKKwkvKiBQTExDIGJpdHMgdG8gc2V0L2NsZWFyIGZvciBwb3dlciBvbiAqLworCXUz MiBwb3dlcl9wbGxjX2NscjsKKwl1MzIgcG93ZXJfcGxsY19zZXQ7CisKKwkvKiBTZXR1cCBiaXRz IHRvIHNldC9jbGVhciBmb3IgcG93ZXIgb24gKi8KKwl1MzIgc2V0dXBfY2xyOworCXUzMiBzZXR1 cF9zZXQ7CisKKwkvKiBTd2FwIENvbnRyb2wgYml0cyB0byBzZXQgKi8KKwl1MzIgc3dhcGN0bF9k ZXZfc2V0OworCisJLyogVGVzdCBQb3J0IENvbnRyb2wgdmFsdWUgdG8gc2V0IGlmIG5vbi16ZXJv ICovCisJdTMyIHRwY192YWw7CisKKwkvKiBVU0IgU2ltIENvbnRyb2wgYml0cyB0byBzZXQgKi8K Kwl1MzIgdXNjX3NldDsKKworCS8qIFVUTUkgQ29udHJvbCAxIGJpdHMgdG8gc2V0ICovCisJdTMy IHV0bWljdGwxX2Rldl9zZXQ7Cit9OworCitzdHJ1Y3QgYmNtNjN4eF91c2JoX3BoeSB7CisJdm9p ZCBfX2lvbWVtICpiYXNlOworCXN0cnVjdCBjbGsgKnVzYmhfY2xrOworCXN0cnVjdCBjbGsgKnVz Yl9yZWZfY2xrOworCXN0cnVjdCByZXNldF9jb250cm9sICpyZXNldDsKKwljb25zdCBzdHJ1Y3Qg YmNtNjN4eF91c2JoX3BoeV92YXJpYW50ICp2YXJpYW50OworCWJvb2wgZGV2aWNlX21vZGU7Cit9 OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGJjbTYzeHhfdXNiaF9waHlfdmFyaWFudCB1c2JoX2Jj bTYzMTggPSB7CisJLnJlZ3MgPSB7CisJCVtVU0JIX0JSVF9DT05UUk9MMV0gPSAtMSwKKwkJW1VT QkhfQlJUX0NPTlRST0wyXSA9IC0xLAorCQlbVVNCSF9CUlRfU1RBVFVTMV0gPSAtMSwKKwkJW1VT QkhfQlJUX1NUQVRVUzJdID0gLTEsCisJCVtVU0JIX1VUTUlfQ09OVFJPTDFdID0gMHgyYywKKwkJ W1VTQkhfVEVTVF9QT1JUX0NPTlRST0xdID0gMHgxYywKKwkJW1VTQkhfUExMX0NPTlRST0wxXSA9 IDB4MDQsCisJCVtVU0JIX1NXQVBfQ09OVFJPTF0gPSAweDBjLAorCQlbVVNCSF9HRU5FUklDX0NP TlRST0xdID0gLTEsCisJCVtVU0JIX0ZSQU1FX0FESlVTVF9WQUxVRV0gPSAweDA4LAorCQlbVVNC SF9TRVRVUF0gPSAweDAwLAorCQlbVVNCSF9NRElPXSA9IDB4MTQsCisJCVtVU0JIX01ESU8zMl0g PSAweDE4LAorCQlbVVNCSF9VU0JfU0lNX0NPTlRST0xdID0gMHgyMCwKKwl9LAorCS5wb3dlcl9w bGxjX2NsciA9IFVTQkhfNjMxOF9QTExDX1BMTF9JRERRX1BXUkROLAorCS5wb3dlcl9wbGxjX3Nl dCA9IFVTQkhfNjMxOF9QTExDX1BMTF9TVVNQRU5EX0VOLAorCS5zZXR1cF9zZXQgPSBVU0JIX1Nf SU9DLAorCS5zd2FwY3RsX2Rldl9zZXQgPSBVU0JIX1NDX1VTQl9ERVZJQ0VfU0VMLAorCS51c2Nf c2V0ID0gVVNCSF9VU0NfTEFERFJfU0VMLAorCS51dG1pY3RsMV9kZXZfc2V0ID0gVVNCSF9VQzFf REVWX01PREVfU0VMLAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202M3h4X3VzYmhfcGh5 X3ZhcmlhbnQgdXNiaF9iY202MzI4ID0geworCS5yZWdzID0geworCQlbVVNCSF9CUlRfQ09OVFJP TDFdID0gMHgwMCwKKwkJW1VTQkhfQlJUX0NPTlRST0wyXSA9IDB4MDQsCisJCVtVU0JIX0JSVF9T VEFUVVMxXSA9IDB4MDgsCisJCVtVU0JIX0JSVF9TVEFUVVMyXSA9IDB4MGMsCisJCVtVU0JIX1VU TUlfQ09OVFJPTDFdID0gMHgxMCwKKwkJW1VTQkhfVEVTVF9QT1JUX0NPTlRST0xdID0gMHgxNCwK KwkJW1VTQkhfUExMX0NPTlRST0wxXSA9IDB4MTgsCisJCVtVU0JIX1NXQVBfQ09OVFJPTF0gPSAw eDFjLAorCQlbVVNCSF9HRU5FUklDX0NPTlRST0xdID0gMHgyMCwKKwkJW1VTQkhfRlJBTUVfQURK VVNUX1ZBTFVFXSA9IDB4MjQsCisJCVtVU0JIX1NFVFVQXSA9IDB4MjgsCisJCVtVU0JIX01ESU9d ID0gMHgyYywKKwkJW1VTQkhfTURJTzMyXSA9IDB4MzAsCisJCVtVU0JIX1VTQl9TSU1fQ09OVFJP TF0gPSAweDM0LAorCX0sCisJLnNldHVwX3NldCA9IFVTQkhfU19JT0MsCisJLnN3YXBjdGxfZGV2 X3NldCA9IFVTQkhfU0NfVVNCX0RFVklDRV9TRUwsCisJLnV0bWljdGwxX2Rldl9zZXQgPSBVU0JI X1VDMV9ERVZfTU9ERV9TRUwsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGJjbTYzeHhfdXNi aF9waHlfdmFyaWFudCB1c2JoX2JjbTYzNTggPSB7CisJLnJlZ3MgPSB7CisJCVtVU0JIX0JSVF9D T05UUk9MMV0gPSAtMSwKKwkJW1VTQkhfQlJUX0NPTlRST0wyXSA9IC0xLAorCQlbVVNCSF9CUlRf U1RBVFVTMV0gPSAtMSwKKwkJW1VTQkhfQlJUX1NUQVRVUzJdID0gLTEsCisJCVtVU0JIX1VUTUlf Q09OVFJPTDFdID0gLTEsCisJCVtVU0JIX1RFU1RfUE9SVF9DT05UUk9MXSA9IDB4MjQsCisJCVtV U0JIX1BMTF9DT05UUk9MMV0gPSAtMSwKKwkJW1VTQkhfU1dBUF9DT05UUk9MXSA9IDB4MDAsCisJ CVtVU0JIX0dFTkVSSUNfQ09OVFJPTF0gPSAtMSwKKwkJW1VTQkhfRlJBTUVfQURKVVNUX1ZBTFVF XSA9IC0xLAorCQlbVVNCSF9TRVRVUF0gPSAtMSwKKwkJW1VTQkhfTURJT10gPSAtMSwKKwkJW1VT QkhfTURJTzMyXSA9IC0xLAorCQlbVVNCSF9VU0JfU0lNX0NPTlRST0xdID0gLTEsCisJfSwKKwkv KgorCSAqIFRoZSBtYWdpYyB2YWx1ZSBjb21lcyBmb3IgdGhlIG9yaWdpbmFsIHZlbmRvciBCU1AK KwkgKiBhbmQgaXMgbmVlZGVkIGZvciBVU0IgdG8gd29yay4gRGF0YXNoZWV0IGRvZXMgbm90CisJ ICogaGVscCwgc28gdGhlIG1hZ2ljIHZhbHVlIGlzIHVzZWQgYXMtaXMuCisJICovCisJLnRwY192 YWwgPSAweDFjMDAyMCwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYmNtNjN4eF91c2JoX3Bo eV92YXJpYW50IHVzYmhfYmNtNjM2OCA9IHsKKwkucmVncyA9IHsKKwkJW1VTQkhfQlJUX0NPTlRS T0wxXSA9IDB4MDAsCisJCVtVU0JIX0JSVF9DT05UUk9MMl0gPSAweDA0LAorCQlbVVNCSF9CUlRf U1RBVFVTMV0gPSAweDA4LAorCQlbVVNCSF9CUlRfU1RBVFVTMl0gPSAweDBjLAorCQlbVVNCSF9V VE1JX0NPTlRST0wxXSA9IDB4MTAsCisJCVtVU0JIX1RFU1RfUE9SVF9DT05UUk9MXSA9IDB4MTQs CisJCVtVU0JIX1BMTF9DT05UUk9MMV0gPSAweDE4LAorCQlbVVNCSF9TV0FQX0NPTlRST0xdID0g MHgxYywKKwkJW1VTQkhfR0VORVJJQ19DT05UUk9MXSA9IC0xLAorCQlbVVNCSF9GUkFNRV9BREpV U1RfVkFMVUVdID0gMHgyNCwKKwkJW1VTQkhfU0VUVVBdID0gMHgyOCwKKwkJW1VTQkhfTURJT10g PSAweDJjLAorCQlbVVNCSF9NRElPMzJdID0gMHgzMCwKKwkJW1VTQkhfVVNCX1NJTV9DT05UUk9M XSA9IDB4MzQsCisJfSwKKwkucG93ZXJfcGxsY19jbHIgPSBVU0JIX1BMTENfUExMX0lERFFfUFdS RE4gfCBVU0JIX1BMTENfUExMX1BXUkROX0RFTEFZLAorCS5zZXR1cF9zZXQgPSBVU0JIX1NfSU9D LAorCS5zd2FwY3RsX2Rldl9zZXQgPSBVU0JIX1NDX1VTQl9ERVZJQ0VfU0VMLAorCS51dG1pY3Rs MV9kZXZfc2V0ID0gVVNCSF9VQzFfREVWX01PREVfU0VMLAorfTsKKworc3RhdGljIGNvbnN0IHN0 cnVjdCBiY202M3h4X3VzYmhfcGh5X3ZhcmlhbnQgdXNiaF9iY202MzI2OCA9IHsKKwkucmVncyA9 IHsKKwkJW1VTQkhfQlJUX0NPTlRST0wxXSA9IDB4MDAsCisJCVtVU0JIX0JSVF9DT05UUk9MMl0g PSAweDA0LAorCQlbVVNCSF9CUlRfU1RBVFVTMV0gPSAweDA4LAorCQlbVVNCSF9CUlRfU1RBVFVT Ml0gPSAweDBjLAorCQlbVVNCSF9VVE1JX0NPTlRST0wxXSA9IDB4MTAsCisJCVtVU0JIX1RFU1Rf UE9SVF9DT05UUk9MXSA9IDB4MTQsCisJCVtVU0JIX1BMTF9DT05UUk9MMV0gPSAweDE4LAorCQlb VVNCSF9TV0FQX0NPTlRST0xdID0gMHgxYywKKwkJW1VTQkhfR0VORVJJQ19DT05UUk9MXSA9IDB4 MjAsCisJCVtVU0JIX0ZSQU1FX0FESlVTVF9WQUxVRV0gPSAweDI0LAorCQlbVVNCSF9TRVRVUF0g PSAweDI4LAorCQlbVVNCSF9NRElPXSA9IDB4MmMsCisJCVtVU0JIX01ESU8zMl0gPSAweDMwLAor CQlbVVNCSF9VU0JfU0lNX0NPTlRST0xdID0gMHgzNCwKKwl9LAorCS5wb3dlcl9wbGxjX2NsciA9 IFVTQkhfUExMQ19QTExfSUREUV9QV1JETiB8IFVTQkhfUExMQ19QTExfUFdSRE5fREVMQVksCisJ LnNldHVwX2NsciA9IFVTQkhfU19JUFAsCisJLnNldHVwX3NldCA9IFVTQkhfU19JT0MsCisJLnN3 YXBjdGxfZGV2X3NldCA9IFVTQkhfU0NfVVNCX0RFVklDRV9TRUwsCisJLnV0bWljdGwxX2Rldl9z ZXQgPSBVU0JIX1VDMV9ERVZfTU9ERV9TRUwsCit9OworCitzdGF0aWMgaW5saW5lIGJvb2wgdXNi aF9oYXNfcmVnKHN0cnVjdCBiY202M3h4X3VzYmhfcGh5ICp1c2JoLCBpbnQgcmVnKQoreworCXJl dHVybiAodXNiaC0+dmFyaWFudC0+cmVnc1tyZWddID49IDApOworfQorCitzdGF0aWMgaW5saW5l IHUzMiB1c2JoX3JlYWRsKHN0cnVjdCBiY202M3h4X3VzYmhfcGh5ICp1c2JoLCBpbnQgcmVnKQor eworCXJldHVybiBfX3Jhd19yZWFkbCh1c2JoLT5iYXNlICsgdXNiaC0+dmFyaWFudC0+cmVnc1ty ZWddKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHVzYmhfd3JpdGVsKHN0cnVjdCBiY202M3h4 X3VzYmhfcGh5ICp1c2JoLCBpbnQgcmVnLAorCQkJICAgICAgIHUzMiB2YWx1ZSkKK3sKKwlfX3Jh d193cml0ZWwodmFsdWUsIHVzYmgtPmJhc2UgKyB1c2JoLT52YXJpYW50LT5yZWdzW3JlZ10pOwor fQorCitzdGF0aWMgaW50IGJjbTYzeHhfdXNiaF9waHlfaW5pdChzdHJ1Y3QgcGh5ICpwaHkpCit7 CisJc3RydWN0IGJjbTYzeHhfdXNiaF9waHkgKnVzYmggPSBwaHlfZ2V0X2RydmRhdGEocGh5KTsK KwlpbnQgcmV0OworCisJcmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxlKHVzYmgtPnVzYmhfY2xrKTsK KwlpZiAocmV0KSB7CisJCWRldl9lcnIoJnBoeS0+ZGV2LCAidW5hYmxlIHRvIGVuYWJsZSB1c2Jo IGNsb2NrOiAlZFxuIiwgcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXQgPSBjbGtfcHJl cGFyZV9lbmFibGUodXNiaC0+dXNiX3JlZl9jbGspOworCWlmIChyZXQpIHsKKwkJZGV2X2Vycigm cGh5LT5kZXYsICJ1bmFibGUgdG8gZW5hYmxlIHVzYl9yZWYgY2xvY2s6ICVkXG4iLCByZXQpOwor CQljbGtfZGlzYWJsZV91bnByZXBhcmUodXNiaC0+dXNiaF9jbGspOworCQlyZXR1cm4gcmV0Owor CX0KKworCXJldCA9IHJlc2V0X2NvbnRyb2xfcmVzZXQodXNiaC0+cmVzZXQpOworCWlmIChyZXQp IHsKKwkJZGV2X2VycigmcGh5LT5kZXYsICJ1bmFibGUgdG8gcmVzZXQgZGV2aWNlOiAlZFxuIiwg cmV0KTsKKwkJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHVzYmgtPnVzYl9yZWZfY2xrKTsKKwkJY2xr X2Rpc2FibGVfdW5wcmVwYXJlKHVzYmgtPnVzYmhfY2xrKTsKKwkJcmV0dXJuIHJldDsKKwl9CisK KwkvKiBDb25maWd1cmUgdG8gd29yayBpbiBuYXRpdmUgQ1BVIGVuZGlhbiAqLworCWlmICh1c2Jo X2hhc19yZWcodXNiaCwgVVNCSF9TV0FQX0NPTlRST0wpKSB7CisJCXUzMiB2YWwgPSB1c2JoX3Jl YWRsKHVzYmgsIFVTQkhfU1dBUF9DT05UUk9MKTsKKworCQl2YWwgfD0gVVNCSF9TQ19FSENJX0RB VEFfU1dBUDsKKwkJdmFsICY9IH5VU0JIX1NDX0VIQ0lfRU5ESUFOX1NXQVA7CisKKwkJdmFsIHw9 IFVTQkhfU0NfT0hDSV9EQVRBX1NXQVA7CisJCXZhbCAmPSB+VVNCSF9TQ19PSENJX0VORElBTl9T V0FQOworCisJCWlmICh1c2JoLT5kZXZpY2VfbW9kZSAmJiB1c2JoLT52YXJpYW50LT5zd2FwY3Rs X2Rldl9zZXQpCisJCQl2YWwgfD0gdXNiaC0+dmFyaWFudC0+c3dhcGN0bF9kZXZfc2V0OworCisJ CXVzYmhfd3JpdGVsKHVzYmgsIFVTQkhfU1dBUF9DT05UUk9MLCB2YWwpOworCX0KKworCWlmICh1 c2JoX2hhc19yZWcodXNiaCwgVVNCSF9TRVRVUCkpIHsKKwkJdTMyIHZhbCA9IHVzYmhfcmVhZGwo dXNiaCwgVVNCSF9TRVRVUCk7CisKKwkJdmFsIHw9IHVzYmgtPnZhcmlhbnQtPnNldHVwX3NldDsK KwkJdmFsICY9IH51c2JoLT52YXJpYW50LT5zZXR1cF9jbHI7CisKKwkJdXNiaF93cml0ZWwodXNi aCwgVVNCSF9TRVRVUCwgdmFsKTsKKwl9CisKKwlpZiAodXNiaF9oYXNfcmVnKHVzYmgsIFVTQkhf VVNCX1NJTV9DT05UUk9MKSkgeworCQl1MzIgdmFsID0gdXNiaF9yZWFkbCh1c2JoLCBVU0JIX1VT Ql9TSU1fQ09OVFJPTCk7CisKKwkJdmFsIHw9IHVzYmgtPnZhcmlhbnQtPnVzY19zZXQ7CisKKwkJ dXNiaF93cml0ZWwodXNiaCwgVVNCSF9VU0JfU0lNX0NPTlRST0wsIHZhbCk7CisJfQorCisJaWYg KHVzYmgtPnZhcmlhbnQtPnRwY192YWwgJiYKKwkgICAgdXNiaF9oYXNfcmVnKHVzYmgsIFVTQkhf VEVTVF9QT1JUX0NPTlRST0wpKQorCQl1c2JoX3dyaXRlbCh1c2JoLCBVU0JIX1RFU1RfUE9SVF9D T05UUk9MLAorCQkJICAgIHVzYmgtPnZhcmlhbnQtPnRwY192YWwpOworCisJaWYgKHVzYmgtPmRl dmljZV9tb2RlICYmCisJICAgIHVzYmhfaGFzX3JlZyh1c2JoLCBVU0JIX1VUTUlfQ09OVFJPTDEp ICYmCisJICAgIHVzYmgtPnZhcmlhbnQtPnV0bWljdGwxX2Rldl9zZXQpIHsKKwkJdTMyIHZhbCA9 IHVzYmhfcmVhZGwodXNiaCwgVVNCSF9VVE1JX0NPTlRST0wxKTsKKworCQl2YWwgfD0gdXNiaC0+ dmFyaWFudC0+dXRtaWN0bDFfZGV2X3NldDsKKworCQl1c2JoX3dyaXRlbCh1c2JoLCBVU0JIX1VU TUlfQ09OVFJPTDEsIHZhbCk7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmNt NjN4eF91c2JoX3BoeV9wb3dlcl9vbihzdHJ1Y3QgcGh5ICpwaHkpCit7CisJc3RydWN0IGJjbTYz eHhfdXNiaF9waHkgKnVzYmggPSBwaHlfZ2V0X2RydmRhdGEocGh5KTsKKworCWlmICh1c2JoX2hh c19yZWcodXNiaCwgVVNCSF9QTExfQ09OVFJPTDEpKSB7CisJCXUzMiB2YWwgPSB1c2JoX3JlYWRs KHVzYmgsIFVTQkhfUExMX0NPTlRST0wxKTsKKworCQl2YWwgfD0gdXNiaC0+dmFyaWFudC0+cG93 ZXJfcGxsY19zZXQ7CisJCXZhbCAmPSB+dXNiaC0+dmFyaWFudC0+cG93ZXJfcGxsY19jbHI7CisK KwkJdXNiaF93cml0ZWwodXNiaCwgVVNCSF9QTExfQ09OVFJPTDEsIHZhbCk7CisJfQorCisJcmV0 dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjN4eF91c2JoX3BoeV9wb3dlcl9vZmYoc3RydWN0 IHBoeSAqcGh5KQoreworCXN0cnVjdCBiY202M3h4X3VzYmhfcGh5ICp1c2JoID0gcGh5X2dldF9k cnZkYXRhKHBoeSk7CisKKwlpZiAodXNiaF9oYXNfcmVnKHVzYmgsIFVTQkhfUExMX0NPTlRST0wx KSkgeworCQl1MzIgdmFsID0gdXNiaF9yZWFkbCh1c2JoLCBVU0JIX1BMTF9DT05UUk9MMSk7CisK KwkJdmFsICY9IH51c2JoLT52YXJpYW50LT5wb3dlcl9wbGxjX3NldDsKKwkJdmFsIHw9IHVzYmgt PnZhcmlhbnQtPnBvd2VyX3BsbGNfY2xyOworCisJCXVzYmhfd3JpdGVsKHVzYmgsIFVTQkhfUExM X0NPTlRST0wxLCB2YWwpOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJjbTYz eHhfdXNiaF9waHlfZXhpdChzdHJ1Y3QgcGh5ICpwaHkpCit7CisJc3RydWN0IGJjbTYzeHhfdXNi aF9waHkgKnVzYmggPSBwaHlfZ2V0X2RydmRhdGEocGh5KTsKKworCWNsa19kaXNhYmxlX3VucHJl cGFyZSh1c2JoLT51c2JoX2Nsayk7CisJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHVzYmgtPnVzYl9y ZWZfY2xrKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IHBoeV9vcHMg YmNtNjN4eF91c2JoX3BoeV9vcHMgPSB7CisJLmV4aXQgPSBiY202M3h4X3VzYmhfcGh5X2V4aXQs CisJLmluaXQgPSBiY202M3h4X3VzYmhfcGh5X2luaXQsCisJLnBvd2VyX29mZiA9IGJjbTYzeHhf dXNiaF9waHlfcG93ZXJfb2ZmLAorCS5wb3dlcl9vbiA9IGJjbTYzeHhfdXNiaF9waHlfcG93ZXJf b24sCisJLm93bmVyID0gVEhJU19NT0RVTEUsCit9OworCitzdGF0aWMgc3RydWN0IHBoeSAqYmNt NjN4eF91c2JoX3BoeV94bGF0ZShzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJCSAgc3RydWN0IG9m X3BoYW5kbGVfYXJncyAqYXJncykKK3sKKwlzdHJ1Y3QgYmNtNjN4eF91c2JoX3BoeSAqdXNiaCA9 IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCisJdXNiaC0+ZGV2aWNlX21vZGUgPSAhIWFyZ3MtPmFy Z3NbMF07CisKKwlyZXR1cm4gb2ZfcGh5X3NpbXBsZV94bGF0ZShkZXYsIGFyZ3MpOworfQorCitz dGF0aWMgaW50IF9faW5pdCBiY202M3h4X3VzYmhfcGh5X3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9k ZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKKwlzdHJ1 Y3QgYmNtNjN4eF91c2JoX3BoeQkqdXNiaDsKKwljb25zdCBzdHJ1Y3QgYmNtNjN4eF91c2JoX3Bo eV92YXJpYW50ICp2YXJpYW50OworCXN0cnVjdCBwaHkgKnBoeTsKKwlzdHJ1Y3QgcGh5X3Byb3Zp ZGVyICpwaHlfcHJvdmlkZXI7CisKKwl1c2JoID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCp1 c2JoKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCF1c2JoKQorCQlyZXR1cm4gLUVOT01FTTsKKworCXZh cmlhbnQgPSBkZXZpY2VfZ2V0X21hdGNoX2RhdGEoZGV2KTsKKwlpZiAoIXZhcmlhbnQpCisJCXJl dHVybiAtRUlOVkFMOworCXVzYmgtPnZhcmlhbnQgPSB2YXJpYW50OworCisJdXNiaC0+YmFzZSA9 IGRldm1fcGxhdGZvcm1faW9yZW1hcF9yZXNvdXJjZShwZGV2LCAwKTsKKwlpZiAoSVNfRVJSKHVz YmgtPmJhc2UpKQorCQlyZXR1cm4gUFRSX0VSUih1c2JoLT5iYXNlKTsKKworCXVzYmgtPnJlc2V0 ID0gZGV2bV9yZXNldF9jb250cm9sX2dldF9leGNsdXNpdmUoZGV2LCBOVUxMKTsKKwlpZiAoSVNf RVJSKHVzYmgtPnJlc2V0KSkgeworCQlpZiAoUFRSX0VSUih1c2JoLT5yZXNldCkgIT0gLUVQUk9C RV9ERUZFUikKKwkJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGdldCByZXNldFxuIik7CisJCXJl dHVybiBQVFJfRVJSKHVzYmgtPnJlc2V0KTsKKwl9CisKKwl1c2JoLT51c2JoX2NsayA9IGRldm1f Y2xrX2dldF9vcHRpb25hbChkZXYsICJ1c2JoIik7CisJaWYgKElTX0VSUih1c2JoLT51c2JoX2Ns aykpCisJCXJldHVybiBQVFJfRVJSKHVzYmgtPnVzYmhfY2xrKTsKKworCXVzYmgtPnVzYl9yZWZf Y2xrID0gZGV2bV9jbGtfZ2V0X29wdGlvbmFsKGRldiwgInVzYl9yZWYiKTsKKwlpZiAoSVNfRVJS KHVzYmgtPnVzYl9yZWZfY2xrKSkKKwkJcmV0dXJuIFBUUl9FUlIodXNiaC0+dXNiX3JlZl9jbGsp OworCisJcGh5ID0gZGV2bV9waHlfY3JlYXRlKGRldiwgTlVMTCwgJmJjbTYzeHhfdXNiaF9waHlf b3BzKTsKKwlpZiAoSVNfRVJSKHBoeSkpIHsKKwkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gY3Jl YXRlIFBIWVxuIik7CisJCXJldHVybiBQVFJfRVJSKHBoeSk7CisJfQorCisJcGxhdGZvcm1fc2V0 X2RydmRhdGEocGRldiwgdXNiaCk7CisJcGh5X3NldF9kcnZkYXRhKHBoeSwgdXNiaCk7CisKKwlw aHlfcHJvdmlkZXIgPSBkZXZtX29mX3BoeV9wcm92aWRlcl9yZWdpc3RlcihkZXYsCisJCQkJCQkg ICAgIGJjbTYzeHhfdXNiaF9waHlfeGxhdGUpOworCWlmIChJU19FUlIocGh5X3Byb3ZpZGVyKSkg eworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byByZWdpc3RlciBQSFkgcHJvdmlkZXJcbiIpOwor CQlyZXR1cm4gUFRSX0VSUihwaHlfcHJvdmlkZXIpOworCX0KKworCWRldl9kYmcoZGV2LCAiUmVn aXN0ZXJlZCBCQ002M3h4IFVTQiBQSFkgZHJpdmVyXG4iKTsKKworCXJldHVybiAwOworfQorCitz dGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBiY202M3h4X3VzYmhfcGh5X2lkc1tdIF9f aW5pdGNvbnN0ID0geworCXsgLmNvbXBhdGlibGUgPSAiYnJjbSxiY202MzE4LXVzYmgtcGh5Iiwg LmRhdGEgPSAmdXNiaF9iY202MzE4IH0sCisJeyAuY29tcGF0aWJsZSA9ICJicmNtLGJjbTYzMjgt dXNiaC1waHkiLCAuZGF0YSA9ICZ1c2JoX2JjbTYzMjggfSwKKwl7IC5jb21wYXRpYmxlID0gImJy Y20sYmNtNjM1OC11c2JoLXBoeSIsIC5kYXRhID0gJnVzYmhfYmNtNjM1OCB9LAorCXsgLmNvbXBh dGlibGUgPSAiYnJjbSxiY202MzYyLXVzYmgtcGh5IiwgLmRhdGEgPSAmdXNiaF9iY202MzY4IH0s CisJeyAuY29tcGF0aWJsZSA9ICJicmNtLGJjbTYzNjgtdXNiaC1waHkiLCAuZGF0YSA9ICZ1c2Jo X2JjbTYzNjggfSwKKwl7IC5jb21wYXRpYmxlID0gImJyY20sYmNtNjMyNjgtdXNiaC1waHkiLCAu ZGF0YSA9ICZ1c2JoX2JjbTYzMjY4IH0sCisJeyAvKiBzZW50aW5lbCAqLyB9Cit9OworTU9EVUxF X0RFVklDRV9UQUJMRShvZiwgYmNtNjN4eF91c2JoX3BoeV9pZHMpOworCitzdGF0aWMgc3RydWN0 IHBsYXRmb3JtX2RyaXZlciBiY202M3h4X3VzYmhfcGh5X2RyaXZlciBfX3JlZmRhdGEgPSB7CisJ LmRyaXZlcgk9IHsKKwkJLm5hbWUgPSAiYmNtNjN4eC11c2JoLXBoeSIsCisJCS5vZl9tYXRjaF90 YWJsZSA9IGJjbTYzeHhfdXNiaF9waHlfaWRzLAorCX0sCisJLnByb2JlCT0gYmNtNjN4eF91c2Jo X3BoeV9wcm9iZSwKK307Cittb2R1bGVfcGxhdGZvcm1fZHJpdmVyKGJjbTYzeHhfdXNiaF9waHlf ZHJpdmVyKTsKKworTU9EVUxFX0RFU0NSSVBUSU9OKCJCQ002M3h4IFVTQkggUEhZIGRyaXZlciIp OworTU9EVUxFX0FVVEhPUigiw4FsdmFybyBGZXJuw6FuZGV6IFJvamFzIDxub2x0YXJpQGdtYWls LmNvbT4iKTsKK01PRFVMRV9BVVRIT1IoIlNpbW9uIEFybG90dCA8c2ltb25AZmlyZS5scDAuZXU+ Iik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7Ci0tIAoyLjI3LjAKCgpfX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcg bGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmlu ZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.1 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9DC03C433E6 for ; Wed, 15 Jul 2020 13:18:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 71A8E20657 for ; Wed, 15 Jul 2020 13:18:20 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="V/2gqczV" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731606AbgGONSP (ORCPT ); Wed, 15 Jul 2020 09:18:15 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40324 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731627AbgGONSK (ORCPT ); Wed, 15 Jul 2020 09:18:10 -0400 Received: from mail-wm1-x343.google.com (mail-wm1-x343.google.com [IPv6:2a00:1450:4864:20::343]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 54EF8C061755; Wed, 15 Jul 2020 06:18:10 -0700 (PDT) Received: by mail-wm1-x343.google.com with SMTP id o2so5810587wmh.2; Wed, 15 Jul 2020 06:18:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ai1ju57KHlhDmSzcsfVEP+Q7j9oUrLJWPNrHnQlYoTU=; b=V/2gqczVgDIJQOBuQ9y4yrL26IyM+quvqDMn4trfgIu4hFArRAxU/OMe6s4GIhvuB1 9t9oHkJnVYgehrvm18MZ10qLNWgaeyPo5M00yBExtYWTSWXY31HI3FBqkOdPh+z/7pu4 FWoLAYi+3qpQTYG7Ky+DMR7wX2TuHYGgVgaOF5wdfhji21tedZXr53aB2gZKCG7rYfWb cXI+IYwUZ2s322m29gXKuAVqcc2ldfP70UguwGWZ4PnlKIo1ZHlZ4IARtBIdhdWW/Clr c1qcBIXtO73CoiHDE9NoI3wwOo0D5m0kPQBKD69fm32fYv6gDg4u0FcfB5G06yHfbAS5 peEg== 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=ai1ju57KHlhDmSzcsfVEP+Q7j9oUrLJWPNrHnQlYoTU=; b=eK34FxBCPBAMKc+lIlvSDMZ8sp9pHd+yDNO6X9HbuaJpG6+YOe9Z8mXc4j3ydbGqqI b2iTODEU3nkzotGe/+cNRXARecQU5xRYTp1CFHqS9UdU/mrINQlr7shAlR6Aml+DABqC VzOM2LRoZlAss+zdbJc5JZoF9ZDhxowaVJMakLqRgXPUA9NFlNjqmgxpvHb5tF5EcP3k 6d0y9xcnauzeVP6YeBy+V2BjLYW1nDItNwQOCnd9lxyQqAQwfS/j2qZuCwh5F1tBXv/V 99Q4AEYJA65OFzI9xt/kgWcuq9WFSmZqimwSChDjAiyqzPqnZ4p3OK0RS7z/zHF5Jqru 2VNQ== X-Gm-Message-State: AOAM532EMGUnXMZ2OyqrvuwOm+55pLL8dfIVxn+Ctze17gej+u467bHt jYAkayePqyxf+KQml2j6u3Q= X-Google-Smtp-Source: ABdhPJwd0mRd0NZjdYqG9pETMDLksHl9bYKmjRCkQsD5n4TE4uQdSt6G5KLlhDmQ8taQxgvhP/B0ng== X-Received: by 2002:a05:600c:2050:: with SMTP id p16mr8401066wmg.44.1594819088863; Wed, 15 Jul 2020 06:18:08 -0700 (PDT) Received: from skynet.lan (67.red-88-15-120.dynamicip.rima-tde.net. [88.15.120.67]) by smtp.gmail.com with ESMTPSA id j145sm3623650wmj.7.2020.07.15.06.18.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 15 Jul 2020 06:18:08 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: simon@arlott.org, jonas.gorski@gmail.com, kishon@ti.com, vkoul@kernel.org, robh+dt@kernel.org, f.fainelli@gmail.com, bcm-kernel-feedback-list@broadcom.com, p.zabel@pengutronix.de, krzk@kernel.org, gregkh@linuxfoundation.org, alcooperx@gmail.com, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= Subject: [PATCH v6 2/2] phy: bcm63xx-usbh: Add BCM63xx USBH driver Date: Wed, 15 Jul 2020 15:18:03 +0200 Message-Id: <20200715131803.1762064-3-noltari@gmail.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20200715131803.1762064-1-noltari@gmail.com> References: <20200715131803.1762064-1-noltari@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org Add BCM63xx USBH PHY driver for BMIPS. Signed-off-by: Álvaro Fernández Rojas --- v6: introduce changes suggested by Vinod: - Remove BMIPS_GENERIC default from kconfig. - Print registered message as debug. v5: use devm_reset_control_get_exclusive. v4: several improvements: - Use devm_platform_ioremap_resource. - Code cleanups. - Improve device mode config: - Move USBH_SWAP_CONTROL device mode value to variant variable. - Set USBH_UTMI_CONTROL1 register value (variant variable). v3: introduce changes suggested by Florian: - Add support for device mode. v2: introduce changes suggested by Florian: - Drop OF dependency (use device_get_match_data). - Drop __initconst from variant tables. - Use devm_clk_get_optional. drivers/phy/broadcom/Kconfig | 8 + drivers/phy/broadcom/Makefile | 1 + drivers/phy/broadcom/phy-bcm63xx-usbh.c | 457 ++++++++++++++++++++++++ 3 files changed, 466 insertions(+) create mode 100644 drivers/phy/broadcom/phy-bcm63xx-usbh.c diff --git a/drivers/phy/broadcom/Kconfig b/drivers/phy/broadcom/Kconfig index b29f11c19155..a1f1a9c90d0d 100644 --- a/drivers/phy/broadcom/Kconfig +++ b/drivers/phy/broadcom/Kconfig @@ -2,6 +2,14 @@ # # Phy drivers for Broadcom platforms # +config PHY_BCM63XX_USBH + tristate "BCM63xx USBH PHY driver" + depends on BMIPS_GENERIC || COMPILE_TEST + select GENERIC_PHY + help + Enable this to support the BCM63xx USBH PHY driver. + If unsure, say N. + config PHY_CYGNUS_PCIE tristate "Broadcom Cygnus PCIe PHY driver" depends on OF && (ARCH_BCM_CYGNUS || COMPILE_TEST) diff --git a/drivers/phy/broadcom/Makefile b/drivers/phy/broadcom/Makefile index c78de546135c..7024127f86ad 100644 --- a/drivers/phy/broadcom/Makefile +++ b/drivers/phy/broadcom/Makefile @@ -1,4 +1,5 @@ # SPDX-License-Identifier: GPL-2.0 +obj-$(CONFIG_PHY_BCM63XX_USBH) += phy-bcm63xx-usbh.o obj-$(CONFIG_PHY_CYGNUS_PCIE) += phy-bcm-cygnus-pcie.o obj-$(CONFIG_BCM_KONA_USB2_PHY) += phy-bcm-kona-usb2.o obj-$(CONFIG_PHY_BCM_NS_USB2) += phy-bcm-ns-usb2.o diff --git a/drivers/phy/broadcom/phy-bcm63xx-usbh.c b/drivers/phy/broadcom/phy-bcm63xx-usbh.c new file mode 100644 index 000000000000..9bb2681adb14 --- /dev/null +++ b/drivers/phy/broadcom/phy-bcm63xx-usbh.c @@ -0,0 +1,457 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * BCM6328 USBH PHY Controller Driver + * + * Copyright (C) 2020 Álvaro Fernández Rojas + * Copyright (C) 2015 Simon Arlott + * + * Derived from bcm963xx_4.12L.06B_consumer/kernel/linux/arch/mips/bcm963xx/setup.c: + * Copyright (C) 2002 Broadcom Corporation + * + * Derived from OpenWrt patches: + * Copyright (C) 2013 Jonas Gorski + * Copyright (C) 2013 Florian Fainelli + * Copyright (C) 2008 Maxime Bizon + */ + +#include +#include +#include +#include +#include +#include + +/* USBH control register offsets */ +enum usbh_regs { + USBH_BRT_CONTROL1 = 0, + USBH_BRT_CONTROL2, + USBH_BRT_STATUS1, + USBH_BRT_STATUS2, + USBH_UTMI_CONTROL1, +#define USBH_UC1_DEV_MODE_SEL BIT(0) + USBH_TEST_PORT_CONTROL, + USBH_PLL_CONTROL1, +#define USBH_PLLC_REFCLKSEL_SHIFT 0 +#define USBH_PLLC_REFCLKSEL_MASK (0x3 << USBH_PLLC_REFCLKSEL_SHIFT) +#define USBH_PLLC_CLKSEL_SHIFT 2 +#define USBH_PLLC_CLKSEL_MASK (0x3 << USBH_PLLC_CLKSEL_MASK) +#define USBH_PLLC_XTAL_PWRDWNB BIT(4) +#define USBH_PLLC_PLL_PWRDWNB BIT(5) +#define USBH_PLLC_PLL_CALEN BIT(6) +#define USBH_PLLC_PHYPLL_BYP BIT(7) +#define USBH_PLLC_PLL_RESET BIT(8) +#define USBH_PLLC_PLL_IDDQ_PWRDN BIT(9) +#define USBH_PLLC_PLL_PWRDN_DELAY BIT(10) +#define USBH_6318_PLLC_PLL_SUSPEND_EN BIT(27) +#define USBH_6318_PLLC_PHYPLL_BYP BIT(29) +#define USBH_6318_PLLC_PLL_RESET BIT(30) +#define USBH_6318_PLLC_PLL_IDDQ_PWRDN BIT(31) + USBH_SWAP_CONTROL, +#define USBH_SC_OHCI_DATA_SWAP BIT(0) +#define USBH_SC_OHCI_ENDIAN_SWAP BIT(1) +#define USBH_SC_OHCI_LOGICAL_ADDR_EN BIT(2) +#define USBH_SC_EHCI_DATA_SWAP BIT(3) +#define USBH_SC_EHCI_ENDIAN_SWAP BIT(4) +#define USBH_SC_EHCI_LOGICAL_ADDR_EN BIT(5) +#define USBH_SC_USB_DEVICE_SEL BIT(6) + USBH_GENERIC_CONTROL, +#define USBH_GC_PLL_SUSPEND_EN BIT(1) + USBH_FRAME_ADJUST_VALUE, + USBH_SETUP, +#define USBH_S_IOC BIT(4) +#define USBH_S_IPP BIT(5) + USBH_MDIO, + USBH_MDIO32, + USBH_USB_SIM_CONTROL, +#define USBH_USC_LADDR_SEL BIT(5) + + __USBH_ENUM_SIZE +}; + +struct bcm63xx_usbh_phy_variant { + /* Registers */ + long regs[__USBH_ENUM_SIZE]; + + /* PLLC bits to set/clear for power on */ + u32 power_pllc_clr; + u32 power_pllc_set; + + /* Setup bits to set/clear for power on */ + u32 setup_clr; + u32 setup_set; + + /* Swap Control bits to set */ + u32 swapctl_dev_set; + + /* Test Port Control value to set if non-zero */ + u32 tpc_val; + + /* USB Sim Control bits to set */ + u32 usc_set; + + /* UTMI Control 1 bits to set */ + u32 utmictl1_dev_set; +}; + +struct bcm63xx_usbh_phy { + void __iomem *base; + struct clk *usbh_clk; + struct clk *usb_ref_clk; + struct reset_control *reset; + const struct bcm63xx_usbh_phy_variant *variant; + bool device_mode; +}; + +static const struct bcm63xx_usbh_phy_variant usbh_bcm6318 = { + .regs = { + [USBH_BRT_CONTROL1] = -1, + [USBH_BRT_CONTROL2] = -1, + [USBH_BRT_STATUS1] = -1, + [USBH_BRT_STATUS2] = -1, + [USBH_UTMI_CONTROL1] = 0x2c, + [USBH_TEST_PORT_CONTROL] = 0x1c, + [USBH_PLL_CONTROL1] = 0x04, + [USBH_SWAP_CONTROL] = 0x0c, + [USBH_GENERIC_CONTROL] = -1, + [USBH_FRAME_ADJUST_VALUE] = 0x08, + [USBH_SETUP] = 0x00, + [USBH_MDIO] = 0x14, + [USBH_MDIO32] = 0x18, + [USBH_USB_SIM_CONTROL] = 0x20, + }, + .power_pllc_clr = USBH_6318_PLLC_PLL_IDDQ_PWRDN, + .power_pllc_set = USBH_6318_PLLC_PLL_SUSPEND_EN, + .setup_set = USBH_S_IOC, + .swapctl_dev_set = USBH_SC_USB_DEVICE_SEL, + .usc_set = USBH_USC_LADDR_SEL, + .utmictl1_dev_set = USBH_UC1_DEV_MODE_SEL, +}; + +static const struct bcm63xx_usbh_phy_variant usbh_bcm6328 = { + .regs = { + [USBH_BRT_CONTROL1] = 0x00, + [USBH_BRT_CONTROL2] = 0x04, + [USBH_BRT_STATUS1] = 0x08, + [USBH_BRT_STATUS2] = 0x0c, + [USBH_UTMI_CONTROL1] = 0x10, + [USBH_TEST_PORT_CONTROL] = 0x14, + [USBH_PLL_CONTROL1] = 0x18, + [USBH_SWAP_CONTROL] = 0x1c, + [USBH_GENERIC_CONTROL] = 0x20, + [USBH_FRAME_ADJUST_VALUE] = 0x24, + [USBH_SETUP] = 0x28, + [USBH_MDIO] = 0x2c, + [USBH_MDIO32] = 0x30, + [USBH_USB_SIM_CONTROL] = 0x34, + }, + .setup_set = USBH_S_IOC, + .swapctl_dev_set = USBH_SC_USB_DEVICE_SEL, + .utmictl1_dev_set = USBH_UC1_DEV_MODE_SEL, +}; + +static const struct bcm63xx_usbh_phy_variant usbh_bcm6358 = { + .regs = { + [USBH_BRT_CONTROL1] = -1, + [USBH_BRT_CONTROL2] = -1, + [USBH_BRT_STATUS1] = -1, + [USBH_BRT_STATUS2] = -1, + [USBH_UTMI_CONTROL1] = -1, + [USBH_TEST_PORT_CONTROL] = 0x24, + [USBH_PLL_CONTROL1] = -1, + [USBH_SWAP_CONTROL] = 0x00, + [USBH_GENERIC_CONTROL] = -1, + [USBH_FRAME_ADJUST_VALUE] = -1, + [USBH_SETUP] = -1, + [USBH_MDIO] = -1, + [USBH_MDIO32] = -1, + [USBH_USB_SIM_CONTROL] = -1, + }, + /* + * The magic value comes for the original vendor BSP + * and is needed for USB to work. Datasheet does not + * help, so the magic value is used as-is. + */ + .tpc_val = 0x1c0020, +}; + +static const struct bcm63xx_usbh_phy_variant usbh_bcm6368 = { + .regs = { + [USBH_BRT_CONTROL1] = 0x00, + [USBH_BRT_CONTROL2] = 0x04, + [USBH_BRT_STATUS1] = 0x08, + [USBH_BRT_STATUS2] = 0x0c, + [USBH_UTMI_CONTROL1] = 0x10, + [USBH_TEST_PORT_CONTROL] = 0x14, + [USBH_PLL_CONTROL1] = 0x18, + [USBH_SWAP_CONTROL] = 0x1c, + [USBH_GENERIC_CONTROL] = -1, + [USBH_FRAME_ADJUST_VALUE] = 0x24, + [USBH_SETUP] = 0x28, + [USBH_MDIO] = 0x2c, + [USBH_MDIO32] = 0x30, + [USBH_USB_SIM_CONTROL] = 0x34, + }, + .power_pllc_clr = USBH_PLLC_PLL_IDDQ_PWRDN | USBH_PLLC_PLL_PWRDN_DELAY, + .setup_set = USBH_S_IOC, + .swapctl_dev_set = USBH_SC_USB_DEVICE_SEL, + .utmictl1_dev_set = USBH_UC1_DEV_MODE_SEL, +}; + +static const struct bcm63xx_usbh_phy_variant usbh_bcm63268 = { + .regs = { + [USBH_BRT_CONTROL1] = 0x00, + [USBH_BRT_CONTROL2] = 0x04, + [USBH_BRT_STATUS1] = 0x08, + [USBH_BRT_STATUS2] = 0x0c, + [USBH_UTMI_CONTROL1] = 0x10, + [USBH_TEST_PORT_CONTROL] = 0x14, + [USBH_PLL_CONTROL1] = 0x18, + [USBH_SWAP_CONTROL] = 0x1c, + [USBH_GENERIC_CONTROL] = 0x20, + [USBH_FRAME_ADJUST_VALUE] = 0x24, + [USBH_SETUP] = 0x28, + [USBH_MDIO] = 0x2c, + [USBH_MDIO32] = 0x30, + [USBH_USB_SIM_CONTROL] = 0x34, + }, + .power_pllc_clr = USBH_PLLC_PLL_IDDQ_PWRDN | USBH_PLLC_PLL_PWRDN_DELAY, + .setup_clr = USBH_S_IPP, + .setup_set = USBH_S_IOC, + .swapctl_dev_set = USBH_SC_USB_DEVICE_SEL, + .utmictl1_dev_set = USBH_UC1_DEV_MODE_SEL, +}; + +static inline bool usbh_has_reg(struct bcm63xx_usbh_phy *usbh, int reg) +{ + return (usbh->variant->regs[reg] >= 0); +} + +static inline u32 usbh_readl(struct bcm63xx_usbh_phy *usbh, int reg) +{ + return __raw_readl(usbh->base + usbh->variant->regs[reg]); +} + +static inline void usbh_writel(struct bcm63xx_usbh_phy *usbh, int reg, + u32 value) +{ + __raw_writel(value, usbh->base + usbh->variant->regs[reg]); +} + +static int bcm63xx_usbh_phy_init(struct phy *phy) +{ + struct bcm63xx_usbh_phy *usbh = phy_get_drvdata(phy); + int ret; + + ret = clk_prepare_enable(usbh->usbh_clk); + if (ret) { + dev_err(&phy->dev, "unable to enable usbh clock: %d\n", ret); + return ret; + } + + ret = clk_prepare_enable(usbh->usb_ref_clk); + if (ret) { + dev_err(&phy->dev, "unable to enable usb_ref clock: %d\n", ret); + clk_disable_unprepare(usbh->usbh_clk); + return ret; + } + + ret = reset_control_reset(usbh->reset); + if (ret) { + dev_err(&phy->dev, "unable to reset device: %d\n", ret); + clk_disable_unprepare(usbh->usb_ref_clk); + clk_disable_unprepare(usbh->usbh_clk); + return ret; + } + + /* Configure to work in native CPU endian */ + if (usbh_has_reg(usbh, USBH_SWAP_CONTROL)) { + u32 val = usbh_readl(usbh, USBH_SWAP_CONTROL); + + val |= USBH_SC_EHCI_DATA_SWAP; + val &= ~USBH_SC_EHCI_ENDIAN_SWAP; + + val |= USBH_SC_OHCI_DATA_SWAP; + val &= ~USBH_SC_OHCI_ENDIAN_SWAP; + + if (usbh->device_mode && usbh->variant->swapctl_dev_set) + val |= usbh->variant->swapctl_dev_set; + + usbh_writel(usbh, USBH_SWAP_CONTROL, val); + } + + if (usbh_has_reg(usbh, USBH_SETUP)) { + u32 val = usbh_readl(usbh, USBH_SETUP); + + val |= usbh->variant->setup_set; + val &= ~usbh->variant->setup_clr; + + usbh_writel(usbh, USBH_SETUP, val); + } + + if (usbh_has_reg(usbh, USBH_USB_SIM_CONTROL)) { + u32 val = usbh_readl(usbh, USBH_USB_SIM_CONTROL); + + val |= usbh->variant->usc_set; + + usbh_writel(usbh, USBH_USB_SIM_CONTROL, val); + } + + if (usbh->variant->tpc_val && + usbh_has_reg(usbh, USBH_TEST_PORT_CONTROL)) + usbh_writel(usbh, USBH_TEST_PORT_CONTROL, + usbh->variant->tpc_val); + + if (usbh->device_mode && + usbh_has_reg(usbh, USBH_UTMI_CONTROL1) && + usbh->variant->utmictl1_dev_set) { + u32 val = usbh_readl(usbh, USBH_UTMI_CONTROL1); + + val |= usbh->variant->utmictl1_dev_set; + + usbh_writel(usbh, USBH_UTMI_CONTROL1, val); + } + + return 0; +} + +static int bcm63xx_usbh_phy_power_on(struct phy *phy) +{ + struct bcm63xx_usbh_phy *usbh = phy_get_drvdata(phy); + + if (usbh_has_reg(usbh, USBH_PLL_CONTROL1)) { + u32 val = usbh_readl(usbh, USBH_PLL_CONTROL1); + + val |= usbh->variant->power_pllc_set; + val &= ~usbh->variant->power_pllc_clr; + + usbh_writel(usbh, USBH_PLL_CONTROL1, val); + } + + return 0; +} + +static int bcm63xx_usbh_phy_power_off(struct phy *phy) +{ + struct bcm63xx_usbh_phy *usbh = phy_get_drvdata(phy); + + if (usbh_has_reg(usbh, USBH_PLL_CONTROL1)) { + u32 val = usbh_readl(usbh, USBH_PLL_CONTROL1); + + val &= ~usbh->variant->power_pllc_set; + val |= usbh->variant->power_pllc_clr; + + usbh_writel(usbh, USBH_PLL_CONTROL1, val); + } + + return 0; +} + +static int bcm63xx_usbh_phy_exit(struct phy *phy) +{ + struct bcm63xx_usbh_phy *usbh = phy_get_drvdata(phy); + + clk_disable_unprepare(usbh->usbh_clk); + clk_disable_unprepare(usbh->usb_ref_clk); + + return 0; +} + +static const struct phy_ops bcm63xx_usbh_phy_ops = { + .exit = bcm63xx_usbh_phy_exit, + .init = bcm63xx_usbh_phy_init, + .power_off = bcm63xx_usbh_phy_power_off, + .power_on = bcm63xx_usbh_phy_power_on, + .owner = THIS_MODULE, +}; + +static struct phy *bcm63xx_usbh_phy_xlate(struct device *dev, + struct of_phandle_args *args) +{ + struct bcm63xx_usbh_phy *usbh = dev_get_drvdata(dev); + + usbh->device_mode = !!args->args[0]; + + return of_phy_simple_xlate(dev, args); +} + +static int __init bcm63xx_usbh_phy_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct bcm63xx_usbh_phy *usbh; + const struct bcm63xx_usbh_phy_variant *variant; + struct phy *phy; + struct phy_provider *phy_provider; + + usbh = devm_kzalloc(dev, sizeof(*usbh), GFP_KERNEL); + if (!usbh) + return -ENOMEM; + + variant = device_get_match_data(dev); + if (!variant) + return -EINVAL; + usbh->variant = variant; + + usbh->base = devm_platform_ioremap_resource(pdev, 0); + if (IS_ERR(usbh->base)) + return PTR_ERR(usbh->base); + + usbh->reset = devm_reset_control_get_exclusive(dev, NULL); + if (IS_ERR(usbh->reset)) { + if (PTR_ERR(usbh->reset) != -EPROBE_DEFER) + dev_err(dev, "failed to get reset\n"); + return PTR_ERR(usbh->reset); + } + + usbh->usbh_clk = devm_clk_get_optional(dev, "usbh"); + if (IS_ERR(usbh->usbh_clk)) + return PTR_ERR(usbh->usbh_clk); + + usbh->usb_ref_clk = devm_clk_get_optional(dev, "usb_ref"); + if (IS_ERR(usbh->usb_ref_clk)) + return PTR_ERR(usbh->usb_ref_clk); + + phy = devm_phy_create(dev, NULL, &bcm63xx_usbh_phy_ops); + if (IS_ERR(phy)) { + dev_err(dev, "failed to create PHY\n"); + return PTR_ERR(phy); + } + + platform_set_drvdata(pdev, usbh); + phy_set_drvdata(phy, usbh); + + phy_provider = devm_of_phy_provider_register(dev, + bcm63xx_usbh_phy_xlate); + if (IS_ERR(phy_provider)) { + dev_err(dev, "failed to register PHY provider\n"); + return PTR_ERR(phy_provider); + } + + dev_dbg(dev, "Registered BCM63xx USB PHY driver\n"); + + return 0; +} + +static const struct of_device_id bcm63xx_usbh_phy_ids[] __initconst = { + { .compatible = "brcm,bcm6318-usbh-phy", .data = &usbh_bcm6318 }, + { .compatible = "brcm,bcm6328-usbh-phy", .data = &usbh_bcm6328 }, + { .compatible = "brcm,bcm6358-usbh-phy", .data = &usbh_bcm6358 }, + { .compatible = "brcm,bcm6362-usbh-phy", .data = &usbh_bcm6368 }, + { .compatible = "brcm,bcm6368-usbh-phy", .data = &usbh_bcm6368 }, + { .compatible = "brcm,bcm63268-usbh-phy", .data = &usbh_bcm63268 }, + { /* sentinel */ } +}; +MODULE_DEVICE_TABLE(of, bcm63xx_usbh_phy_ids); + +static struct platform_driver bcm63xx_usbh_phy_driver __refdata = { + .driver = { + .name = "bcm63xx-usbh-phy", + .of_match_table = bcm63xx_usbh_phy_ids, + }, + .probe = bcm63xx_usbh_phy_probe, +}; +module_platform_driver(bcm63xx_usbh_phy_driver); + +MODULE_DESCRIPTION("BCM63xx USBH PHY driver"); +MODULE_AUTHOR("Álvaro Fernández Rojas "); +MODULE_AUTHOR("Simon Arlott "); +MODULE_LICENSE("GPL"); -- 2.27.0