From mboxrd@z Thu Jan 1 00:00:00 1970 From: Sam Ravnborg Subject: Re: [PATCH v1 2/7] drm: move DRM_SWITCH_POWER defines to drm_device.h Date: Thu, 27 Dec 2018 23:17:11 +0100 Message-ID: <20181227221711.GA29366@ravnborg.org> References: <20181226210215.GA27610@ravnborg.org> <20181226210353.13993-2-sam@ravnborg.org> <20181227121234.GE9058@dvetter-linux.ger.corp.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from asavdk3.altibox.net (asavdk3.altibox.net [109.247.116.14]) by gabe.freedesktop.org (Postfix) with ESMTPS id 8D2596E420 for ; Thu, 27 Dec 2018 22:17:15 +0000 (UTC) Content-Disposition: inline In-Reply-To: <20181227121234.GE9058@dvetter-linux.ger.corp.intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: David Airlie , Maarten Lankhorst , Maxime Ripard , Sean Paul , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org SGkgRGFuaWVsLgoKPiA+ICsvKiBVc2VkIGJ5IGRybV9kZXZpY2Uuc3dpdGNoX3Bvd2VyX3N0YXRl ICovCj4gPiArI2RlZmluZSBEUk1fU1dJVENIX1BPV0VSX09OIDAKPiA+ICsjZGVmaW5lIERSTV9T V0lUQ0hfUE9XRVJfT0ZGIDEKPiA+ICsjZGVmaW5lIERSTV9TV0lUQ0hfUE9XRVJfQ0hBTkdJTkcg Mgo+ID4gKyNkZWZpbmUgRFJNX1NXSVRDSF9QT1dFUl9EWU5BTUlDX09GRiAzCj4gCj4gU2luY2Ug dGhpcyBpc24ndCB1YXBpIGl0J2QgYmUgbmljZSB0byBjaGFuZ2UgaXQgdG8gYW4gZW51bSwgd2hp Y2ggd2UgY2FuCj4gdGhlbiBwcm9wZXJseSBrZXJuZWwtZG9jIGFuZCBtYWtlIHlvdXIgcmVmZXJl bmNlcyBsaW5rcyBpbiB0aGUgcmVzdWx0aW5nCj4gaHRtbC4gT3RoZXJ3aXNlIGxndG0uCj4gCj4g V291bGQgbmVlZCBhbiBpbmNsdWRlIHN0YW56YSBmb3IgZHJtX2RldmljZS5oIGluIGRybS1pbnRl cm5hbHMucnN0LCBwbHVzIGEKPiBiaXQgb2Yga2VybmVsLWRvYyBjbGVhbnVwIGluIGhlcmUgSSB0 aGluayAod2hpY2ggaWlyYyBpcyB3aHkgSSBkaWRuJ3QgeWV0Cj4gZG8gdGhpcykuCgpDb252ZXJ0 aW5nIHRvIGVudW0gd2FzIGVhc3ksIHRoZSBkb2N1bWVudGF0aW9uIHBhcnQgbm90IHNvLgpJIGhh dmUgdHJpZWQgdG8gYWRkIHNvbWUgZG9jdW1lbnRhdGlvbiBiYXNlZCBvbiB3aGF0IEkgY291bGQg ZmlndXJlIG91dC4KVGhlcmUgYXJlIHJvb20gZm9yIGltcHJvdmVtZW50cy4KClRoZSBvdGhlciB0 YXNrIHdhcyB0byBpbmNsdWRlIGRybV9kZXZpY2UgaW4gdGhlIGRvY3VtZW50YXRpb24uCgpUaGlz IHdvcmsgcmVzdWx0ZWQgaW4gdGhlIGZvbGxvd2luZyB0d28gcGF0Y2hlcyB0aGF0IEkgd2lsbCBw b3N0CmFzIHBhcnQgb2YgYW4gdXBkYXRlZCBzZXJpZXMgbGF0ZXIuClBvc3RlZCBoZXJlIHRvIG1h eWJlIGdldCBzb21lIGluaXRpYWwgZmVlZGJhY2suCgoJU2FtCgpGcm9tIDNiYzVkNmExMWExZTA0 ZjIwYTQ2NWUyNjkwNTgzYzg3Y2VlNzRhYzAgTW9uIFNlcCAxNyAwMDowMDowMCAyMDAxCkZyb206 IFNhbSBSYXZuYm9yZyA8c2FtQHJhdm5ib3JnLm9yZz4KRGF0ZTogVGh1LCAyNyBEZWMgMjAxOCAy MzowMzoxMiArMDEwMApTdWJqZWN0OiBbUEFUQ0ggMS83XSBkcm06IGFkZCBkcm1fZGV2aWNlLmgg dG8ga2VybmVsLWRvYwoKVXBkYXRlZCBjb21tZW50IHN0eWxlIHRvIGtlcm5lbC1kb2MgZm9ybWF0 CgpTaWduZWQtb2ZmLWJ5OiBTYW0gUmF2bmJvcmcgPHNhbUByYXZuYm9yZy5vcmc+Ci0tLQogRG9j dW1lbnRhdGlvbi9ncHUvZHJtLWludGVybmFscy5yc3QgfCAgIDQgKwogaW5jbHVkZS9kcm0vZHJt X2RldmljZS5oICAgICAgICAgICAgfCAxNTcgKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0t LS0tLS0tCiAyIGZpbGVzIGNoYW5nZWQsIDEwMSBpbnNlcnRpb25zKCspLCA2MCBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dwdS9kcm0taW50ZXJuYWxzLnJzdCBiL0Rv Y3VtZW50YXRpb24vZ3B1L2RybS1pbnRlcm5hbHMucnN0CmluZGV4IDVlZTk2NzRmYjllOS4uN2E2 NzdiMmIwZWJjIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dwdS9kcm0taW50ZXJuYWxzLnJz dAorKysgYi9Eb2N1bWVudGF0aW9uL2dwdS9kcm0taW50ZXJuYWxzLnJzdApAQCAtMTQ5LDYgKzE0 OSwxMCBAQCBEZXZpY2UgSW5zdGFuY2UgYW5kIERyaXZlciBIYW5kbGluZwogLi4ga2VybmVsLWRv Yzo6IGRyaXZlcnMvZ3B1L2RybS9kcm1fZHJ2LmMKICAgIDpleHBvcnQ6CiAKK0RSTSBEZXZpY2UK Ky0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2RybS9kcm1fZGV2aWNlLmgKKwog RHJpdmVyIExvYWQKIC0tLS0tLS0tLS0tCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9k ZXZpY2UuaCBiL2luY2x1ZGUvZHJtL2RybV9kZXZpY2UuaAppbmRleCA0MjQxMWIzZWEwYzguLmNk Mzg1ZDNmYzk3OSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJtX2RldmljZS5oCisrKyBiL2lu Y2x1ZGUvZHJtL2RybV9kZXZpY2UuaApAQCAtMjUsMjQgKzI1LDM5IEBAIHN0cnVjdCBwY2lfZGV2 Owogc3RydWN0IHBjaV9jb250cm9sbGVyOwogCiAvKioKLSAqIERSTSBkZXZpY2Ugc3RydWN0dXJl LiBUaGlzIHN0cnVjdHVyZSByZXByZXNlbnQgYSBjb21wbGV0ZSBjYXJkIHRoYXQKKyAqIHN0cnVj dCBkcm1fZGV2aWNlIC0gRFJNIGRldmljZSBzdHJ1Y3R1cmUKKyAqCisgKiBUaGlzIHN0cnVjdHVy ZSByZXByZXNlbnQgYSBjb21wbGV0ZSBjYXJkIHRoYXQKICAqIG1heSBjb250YWluIG11bHRpcGxl IGhlYWRzLgogICovCiBzdHJ1Y3QgZHJtX2RldmljZSB7Ci0Jc3RydWN0IGxpc3RfaGVhZCBsZWdh Y3lfZGV2X2xpc3Q7LyoqPCBsaXN0IG9mIGRldmljZXMgcGVyIGRyaXZlciBmb3Igc3RlYWx0aCBh dHRhY2ggY2xlYW51cCAqLwotCWludCBpZl92ZXJzaW9uOwkJCS8qKjwgSGlnaGVzdCBpbnRlcmZh Y2UgdmVyc2lvbiBzZXQgKi8KLQotCS8qKiBcbmFtZSBMaWZldGltZSBNYW5hZ2VtZW50ICovCi0J LypAeyAqLwotCXN0cnVjdCBrcmVmIHJlZjsJCS8qKjwgT2JqZWN0IHJlZi1jb3VudCAqLwotCXN0 cnVjdCBkZXZpY2UgKmRldjsJCS8qKjwgRGV2aWNlIHN0cnVjdHVyZSBvZiBidXMtZGV2aWNlICov Ci0Jc3RydWN0IGRybV9kcml2ZXIgKmRyaXZlcjsJLyoqPCBEUk0gZHJpdmVyIG1hbmFnaW5nIHRo ZSBkZXZpY2UgKi8KLQl2b2lkICpkZXZfcHJpdmF0ZTsJCS8qKjwgRFJNIGRyaXZlciBwcml2YXRl IGRhdGEgKi8KLQlzdHJ1Y3QgZHJtX21pbm9yICpwcmltYXJ5OwkJLyoqPCBQcmltYXJ5IG5vZGUg Ki8KLQlzdHJ1Y3QgZHJtX21pbm9yICpyZW5kZXI7CQkvKio8IFJlbmRlciBub2RlICovCisJLyoq IEBsZWdhY3lfZGV2X2xpc3Q6IExpc3Qgb2YgZGV2aWNlcyBwZXIgZHJpdmVyIGZvciBzdGVhbHRo IGF0dGFjaCBjbGVhbnVwICovCisJc3RydWN0IGxpc3RfaGVhZCBsZWdhY3lfZGV2X2xpc3Q7CisK KwkvKiogQGlmX3ZlcnNpb246IEhpZ2hlc3QgaW50ZXJmYWNlIHZlcnNpb24gc2V0ICovCisJaW50 IGlmX3ZlcnNpb247CisKKwkvKiogQHJlZjogT2JqZWN0IHJlZi1jb3VudCAqLworCXN0cnVjdCBr cmVmIHJlZjsKKworCS8qKiBAZGV2OiBEZXZpY2Ugc3RydWN0dXJlIG9mIGJ1cy1kZXZpY2UgKi8K KwlzdHJ1Y3QgZGV2aWNlICpkZXY7CisKKwkvKiogQGRyaXZlcjogRFJNIGRyaXZlciBtYW5hZ2lu ZyB0aGUgZGV2aWNlICovCisJc3RydWN0IGRybV9kcml2ZXIgKmRyaXZlcjsKKworCS8qKiBAZGV2 X3ByaXZhdGU6IERSTSBkcml2ZXIgcHJpdmF0ZSBkYXRhICovCisJdm9pZCAqZGV2X3ByaXZhdGU7 CisKKwkvKiogQHByaW1hcnk6IFByaW1hcnkgbm9kZSAqLworCXN0cnVjdCBkcm1fbWlub3IgKnBy aW1hcnk7CisKKwkvKiogQHJlbmRlcjogUmVuZGVyIG5vZGUgKi8KKwlzdHJ1Y3QgZHJtX21pbm9y ICpyZW5kZXI7CisKIAlib29sIHJlZ2lzdGVyZWQ7CiAKLQkvKiBjdXJyZW50bHkgYWN0aXZlIG1h c3RlciBmb3IgdGhpcyBkZXZpY2UuIFByb3RlY3RlZCBieSBtYXN0ZXJfbXV0ZXggKi8KKwkvKiog QG1hc3RlcjogQ3VycmVudGx5IGFjdGl2ZSBtYXN0ZXIgZm9yIHRoaXMgZGV2aWNlLiBQcm90ZWN0 ZWQgYnkgbWFzdGVyX211dGV4ICovCiAJc3RydWN0IGRybV9tYXN0ZXIgKm1hc3RlcjsKIAogCS8q KgpAQCAtNjMsMjMgKzc4LDI5IEBAIHN0cnVjdCBkcm1fZGV2aWNlIHsKIAkgKi8KIAlib29sIHVu cGx1Z2dlZDsKIAotCXN0cnVjdCBpbm9kZSAqYW5vbl9pbm9kZTsJCS8qKjwgaW5vZGUgZm9yIHBy aXZhdGUgYWRkcmVzcy1zcGFjZSAqLwotCWNoYXIgKnVuaXF1ZTsJCQkJLyoqPCB1bmlxdWUgbmFt ZSBvZiB0aGUgZGV2aWNlICovCi0JLypAfSAqLworCS8qKiBAYW5vbl9pbm9kZTogaW5vZGUgZm9y IHByaXZhdGUgYWRkcmVzcy1zcGFjZSAqLworCXN0cnVjdCBpbm9kZSAqYW5vbl9pbm9kZTsKKwor CS8qKiBAdW5pcXVlOiBVbmlxdWUgbmFtZSBvZiB0aGUgZGV2aWNlICovCisJY2hhciAqdW5pcXVl OworCisJLyoqIEBzdHJ1Y3RfbXV0ZXg6IExvY2sgZm9yIG90aGVycyAobm90IGRybV9taW5vcjo6 bWFzdGVyIGFuZCBkcm1fZmlsZTo6aXNfbWFzdGVyKSAqLworCXN0cnVjdCBtdXRleCBzdHJ1Y3Rf bXV0ZXg7CisKKwkvKiogQG1hc3Rlcl9tdXRleDogTG9jayBmb3IgZHJtX21pbm9yOjptYXN0ZXIg YW5kIGRybV9maWxlOjppc19tYXN0ZXIgKi8KKwlzdHJ1Y3QgbXV0ZXggbWFzdGVyX211dGV4Owor CisJLyoqIEBvcGVuX2NvdW50OiBVc2FnZSBjb3VudGVyIGZvciBvdXRzdGFuZGluZyBmaWxlcyBv cGVuLCBwcm90ZWN0ZWQgYnkgZHJtX2dsb2JhbF9tdXRleC4gKi8KKwlpbnQgb3Blbl9jb3VudDsK IAotCS8qKiBcbmFtZSBMb2NrcyAqLwotCS8qQHsgKi8KLQlzdHJ1Y3QgbXV0ZXggc3RydWN0X211 dGV4OwkvKio8IEZvciBvdGhlcnMgKi8KLQlzdHJ1Y3QgbXV0ZXggbWFzdGVyX211dGV4OyAgICAg IC8qKjwgRm9yIGRybV9taW5vcjo6bWFzdGVyIGFuZCBkcm1fZmlsZTo6aXNfbWFzdGVyICovCi0J LypAfSAqLworCS8qKiBAYnVmX2xvY2s6IExvY2sgZm9yIGRybV9kZXZpY2U6OmJ1Zl91c2UgYW5k IGEgZmV3IG90aGVyIHRoaW5ncy4gKi8KKwlzcGlubG9ja190IGJ1Zl9sb2NrOwogCi0JLyoqIFxu YW1lIFVzYWdlIENvdW50ZXJzICovCi0JLypAeyAqLwotCWludCBvcGVuX2NvdW50OwkJCS8qKjwg T3V0c3RhbmRpbmcgZmlsZXMgb3BlbiwgcHJvdGVjdGVkIGJ5IGRybV9nbG9iYWxfbXV0ZXguICov Ci0Jc3BpbmxvY2tfdCBidWZfbG9jazsJCS8qKjwgRm9yIGRybV9kZXZpY2U6OmJ1Zl91c2UgYW5k IGEgZmV3IG90aGVyIHRoaW5ncy4gKi8KLQlpbnQgYnVmX3VzZTsJCQkvKio8IEJ1ZmZlcnMgaW4g dXNlIC0tIGNhbm5vdCBhbGxvYyAqLwotCWF0b21pY190IGJ1Zl9hbGxvYzsJCS8qKjwgQnVmZmVy IGFsbG9jYXRpb24gaW4gcHJvZ3Jlc3MgKi8KLQkvKkB9ICovCisJLyoqIEBidWZfdXNlOiBVc2Fn ZSBjb3VudGVyIGZvciBidWZmZXJzIGluIHVzZSAtLSBjYW5ub3QgYWxsb2MgKi8KKwlpbnQgYnVm X3VzZTsKKworCS8qKiBAYnVmX2FsbG9jOiBCdWZmZXIgYWxsb2NhdGlvbiBpbiBwcm9ncmVzcyAq LworCWF0b21pY190IGJ1Zl9hbGxvYzsKIAogCXN0cnVjdCBtdXRleCBmaWxlbGlzdF9tdXRleDsK IAlzdHJ1Y3QgbGlzdF9oZWFkIGZpbGVsaXN0OwpAQCAtMTA1LDMzICsxMjYsMzIgQEAgc3RydWN0 IGRybV9kZXZpY2UgewogCSAqLwogCXN0cnVjdCBsaXN0X2hlYWQgY2xpZW50bGlzdDsKIAotCS8q KiBcbmFtZSBNZW1vcnkgbWFuYWdlbWVudCAqLwotCS8qQHsgKi8KLQlzdHJ1Y3QgbGlzdF9oZWFk IG1hcGxpc3Q7CS8qKjwgTGlua2VkIGxpc3Qgb2YgcmVnaW9ucyAqLwotCXN0cnVjdCBkcm1fb3Bl bl9oYXNoIG1hcF9oYXNoOwkvKio8IFVzZXIgdG9rZW4gaGFzaCB0YWJsZSBmb3IgbWFwcyAqLwor CS8qKiBAbWFwbGlzdDogTWVtb3J5IG1hbmFnZW1lbnQgLSBsaW5rZWQgbGlzdCBvZiByZWdpb25z ICovCisJc3RydWN0IGxpc3RfaGVhZCBtYXBsaXN0OwogCi0JLyoqIFxuYW1lIENvbnRleHQgaGFu ZGxlIG1hbmFnZW1lbnQgKi8KLQkvKkB7ICovCi0Jc3RydWN0IGxpc3RfaGVhZCBjdHhsaXN0Owkv Kio8IExpbmtlZCBsaXN0IG9mIGNvbnRleHQgaGFuZGxlcyAqLwotCXN0cnVjdCBtdXRleCBjdHhs aXN0X211dGV4OwkvKio8IEZvciBjdHhsaXN0ICovCisJLyoqIEBtYXBfaGFzaDogTWVtb3J5IG1h bmFnZW1lbnQgLSB1c2VyIHRva2VuIGhhc2ggdGFibGUgZm9yIG1hcHMgKi8KKwlzdHJ1Y3QgZHJt X29wZW5faGFzaCBtYXBfaGFzaDsKIAotCXN0cnVjdCBpZHIgY3R4X2lkcjsKKwkvKiogQGN0eGxp c3Q6IENvbnRleHQgaGFuZGxlIG1hbmFnZW1lbnQgLSBsaW5rZWQgbGlzdCBvZiBjb250ZXh0IGhh bmRsZXMgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIGN0eGxpc3Q7CisKKwkvKiogQGN0eGxpc3RfbXV0 ZXg6IENvbnRleHQgaGFuZGxlIG1hbmFnZW1lbnQgLSBtdXRleCBmb3IgY3R4bGlzdCAqLworCXN0 cnVjdCBtdXRleCBjdHhsaXN0X211dGV4OwogCi0Jc3RydWN0IGxpc3RfaGVhZCB2bWFsaXN0Owkv Kio8IExpc3Qgb2Ygdm1hcyAoZm9yIGRlYnVnZ2luZykgKi8KKwkvKiogQGN0eF9pZHI6IENvbnRl eHQgaGFuZGxlIG1hbmFnZW1lbnQgKi8KKwlzdHJ1Y3QgaWRyIGN0eF9pZHI7CiAKLQkvKkB9ICov CisJLyoqIEB2bWFsaXN0OiBDb250ZXh0IGhhbmRsZSBtYW5hZ2VtZW50IC0gbGlzdCBvZiB2bWFz IChmb3IgZGVidWdnaW5nKSAqLworCXN0cnVjdCBsaXN0X2hlYWQgdm1hbGlzdDsKIAotCS8qKiBc bmFtZSBETUEgc3VwcG9ydCAqLwotCS8qQHsgKi8KLQlzdHJ1Y3QgZHJtX2RldmljZV9kbWEgKmRt YTsJCS8qKjwgT3B0aW9uYWwgcG9pbnRlciBmb3IgRE1BIHN1cHBvcnQgKi8KLQkvKkB9ICovCisJ LyoqIEBkbWE6IE9wdGlvbmFsIHBvaW50ZXIgZm9yIERNQSBzdXBwb3J0ICovCisJc3RydWN0IGRy bV9kZXZpY2VfZG1hICpkbWE7CiAKLQkvKiogXG5hbWUgQ29udGV4dCBzdXBwb3J0ICovCi0JLypA eyAqLworCS8qKiBAY29udGV4dF9mbGFnOiBDb250ZXh0IHN3YXBwaW5nIGZsYWcgKi8KKwlfX3Zv bGF0aWxlX18gbG9uZyBjb250ZXh0X2ZsYWc7CiAKLQlfX3ZvbGF0aWxlX18gbG9uZyBjb250ZXh0 X2ZsYWc7CS8qKjwgQ29udGV4dCBzd2FwcGluZyBmbGFnICovCi0JaW50IGxhc3RfY29udGV4dDsJ CS8qKjwgTGFzdCBjdXJyZW50IGNvbnRleHQgKi8KLQkvKkB9ICovCisJLyoqIEBsYXN0X2NvbnRl eHQ6IExhc3QgY3VycmVudCBjb250ZXh0ICovCisJaW50IGxhc3RfY29udGV4dDsKIAogCS8qKgog CSAqIEBpcnFfZW5hYmxlZDoKQEAgLTE2OCw3ICsxODgsMTIgQEAgc3RydWN0IGRybV9kZXZpY2Ug ewogCSAqLwogCXN0cnVjdCBkcm1fdmJsYW5rX2NydGMgKnZibGFuazsKIAotCXNwaW5sb2NrX3Qg dmJsYW5rX3RpbWVfbG9jazsgICAgLyoqPCBQcm90ZWN0cyB2YmxhbmsgY291bnQgYW5kIHRpbWUg dXBkYXRlcyBkdXJpbmcgdmJsYW5rIGVuYWJsZS9kaXNhYmxlICovCisJLyoqCisJICogQHZibGFu a190aW1lX2xvY2s6CisJICogCisJICogIFByb3RlY3RzIHZibGFuayBjb3VudCBhbmQgdGltZSB1 cGRhdGVzIGR1cmluZyB2YmxhbmsgZW5hYmxlL2Rpc2FibGUKKwkgKi8KKwlzcGlubG9ja190IHZi bGFua190aW1lX2xvY2s7CiAJc3BpbmxvY2tfdCB2YmxfbG9jazsKIAogCS8qKgpAQCAtMTg2LDI1 ICsyMTEsMzMgQEAgc3RydWN0IGRybV9kZXZpY2UgewogCSAqCiAJICogSWYgbm9uLXplb3IsICZk cm1fY3J0Y19mdW5jcy5nZXRfdmJsYW5rX2NvdW50ZXIgbXVzdCBiZSBzZXQuCiAJICovCi0JdTMy IG1heF92YmxhbmtfY291bnQ7ICAgICAgICAgICAvKio8IHNpemUgb2YgdmJsYW5rIGNvdW50ZXIg cmVnaXN0ZXIgKi8KKworCS8qKiBAbWF4X3ZibGFua19jb3VudDogU2l6ZSBvZiB2YmxhbmsgY291 bnRlciByZWdpc3RlciAqLworCXUzMiBtYXhfdmJsYW5rX2NvdW50OwogCiAJLyoqCi0JICogTGlz dCBvZiBldmVudHMKKwkgKiBAdmJsYW5rX2V2ZW50X2xpc3Q6CisJICoKKwkgKiBMaXN0IG9mIHZi bGFuayBldmVudHMKIAkgKi8KIAlzdHJ1Y3QgbGlzdF9oZWFkIHZibGFua19ldmVudF9saXN0Owog CXNwaW5sb2NrX3QgZXZlbnRfbG9jazsKIAotCS8qQH0gKi8KKwkvKiogQGFncDogQUdQIGRhdGEg Ki8KKwlzdHJ1Y3QgZHJtX2FncF9oZWFkICphZ3A7CiAKLQlzdHJ1Y3QgZHJtX2FncF9oZWFkICph Z3A7CS8qKjwgQUdQIGRhdGEgKi8KKwkvKiogQHBkZXY6IFBDSSBkZXZpY2Ugc3RydWN0dXJlICov CisJc3RydWN0IHBjaV9kZXYgKnBkZXY7CiAKLQlzdHJ1Y3QgcGNpX2RldiAqcGRldjsJCS8qKjwg UENJIGRldmljZSBzdHJ1Y3R1cmUgKi8KICNpZmRlZiBfX2FscGhhX18KIAlzdHJ1Y3QgcGNpX2Nv bnRyb2xsZXIgKmhvc2U7CiAjZW5kaWYKIAotCXN0cnVjdCBkcm1fc2dfbWVtICpzZzsJLyoqPCBT Y2F0dGVyIGdhdGhlciBtZW1vcnkgKi8KLQl1bnNpZ25lZCBpbnQgbnVtX2NydGNzOyAgICAgICAg ICAgICAgICAgIC8qKjwgTnVtYmVyIG9mIENSVENzIG9uIHRoaXMgZGV2aWNlICovCisJLyoqIEBz ZzogU2NhdHRlciBnYXRoZXIgbWVtb3J5ICovCisJc3RydWN0IGRybV9zZ19tZW0gKnNnOworCisJ LyoqIEBudW1fY3J0Y3M6IE51bWJlciBvZiBDUlRDcyBvbiB0aGlzIGRldmljZSAqLworCXVuc2ln bmVkIGludCBudW1fY3J0Y3M7CiAKIAlzdHJ1Y3QgewogCQlpbnQgY29udGV4dDsKQEAgLTIxNCwx NCArMjQ3LDE4IEBAIHN0cnVjdCBkcm1fZGV2aWNlIHsKIAlzdHJ1Y3QgZHJtX2xvY2FsX21hcCAq YWdwX2J1ZmZlcl9tYXA7CiAJdW5zaWduZWQgaW50IGFncF9idWZmZXJfdG9rZW47CiAKLQlzdHJ1 Y3QgZHJtX21vZGVfY29uZmlnIG1vZGVfY29uZmlnOwkvKio8IEN1cnJlbnQgbW9kZSBjb25maWcg Ki8KKwkvKiogQG1vZGVfY29uZmlnOiBDdXJyZW50IG1vZGUgY29uZmlnICovCisJc3RydWN0IGRy bV9tb2RlX2NvbmZpZyBtb2RlX2NvbmZpZzsKIAotCS8qKiBcbmFtZSBHRU0gaW5mb3JtYXRpb24g Ki8KLQkvKkB7ICovCisJLyoqIEBvYmplY3RfbmFtZV9sb2NrOiBHRU0gaW5mb3JtYXRpb24gKi8K IAlzdHJ1Y3QgbXV0ZXggb2JqZWN0X25hbWVfbG9jazsKKworCS8qKiBAb2JqZWN0X25hbWVfaWRy OiBHRU0gaW5mb3JtYXRpb24gKi8KIAlzdHJ1Y3QgaWRyIG9iamVjdF9uYW1lX2lkcjsKKworCS8q KiBAdm1hX29mZnNldF9tYW5hZ2VyOiBHRU0gaW5mb3JtYXRpb24gKi8KIAlzdHJ1Y3QgZHJtX3Zt YV9vZmZzZXRfbWFuYWdlciAqdm1hX29mZnNldF9tYW5hZ2VyOwotCS8qQH0gKi8KKwogCWludCBz d2l0Y2hfcG93ZXJfc3RhdGU7CiAKIAkvKioKLS0gCjIuMTIuMAoKRnJvbSBhM2M5NDYwNGY4YzMy YTJhNDhlZmM3OWQxNWZiYzY2ZTBlNjJmZDMzIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9t OiBTYW0gUmF2bmJvcmcgPHNhbUByYXZuYm9yZy5vcmc+CkRhdGU6IFdlZCwgMjYgRGVjIDIwMTgg MTQ6MjE6MDEgKzAxMDAKU3ViamVjdDogW1BBVENIIDIvN10gZHJtOiBtb3ZlIERSTV9TV0lUQ0hf UE9XRVIgZGVmaW5lcyB0byBkcm1fZGV2aWNlLmgKCk1vdmUgRFJNX1NXSVRDSF9QT1dFUiBvdXQg b2YgZHJtUC5oIHRvIGFsbG93IHVzZXJzCnRvIGdldCByaWQgb2YgdGhlIGRybVAgaW5jbHVkZS4K CkRSTV9TV0lUQ0hfUE9XRVIgZGVmaW5lcyBhcmUgdXNlZCBpbiBjb21iaW5hdGlvbgp3aXRoIGRy bV9kZXZpY2Uuc3dpdGNoX3Bvd2VyX3N0YXRlLgoKTW92ZSB0aGUgRFJNX1NXSVRDSF9QT1dFUiBk ZWZpbmVzIHRvIHRoZSBmaWxlIHdoZXJlCmRybV9kZXZpY2Uuc3dpdGNoX3Bvd2VyX3N0YXRlIGlz IGRlZmluZWQuCgpTaWduZWQtb2ZmLWJ5OiBTYW0gUmF2bmJvcmcgPHNhbUByYXZuYm9yZy5vcmc+ CkNjOiBNYWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5sYW5raG9yc3RAbGludXguaW50ZWwuY29t PgpDYzogTWF4aW1lIFJpcGFyZCA8bWF4aW1lLnJpcGFyZEBib290bGluLmNvbT4KQ2M6IFNlYW4g UGF1bCA8c2VhbkBwb29ybHkucnVuPgpDYzogRGF2aWQgQWlybGllIDxhaXJsaWVkQGxpbnV4Lmll PgpDYzogRGFuaWVsIFZldHRlciA8ZGFuaWVsQGZmd2xsLmNoPgotLS0KIGluY2x1ZGUvZHJtL2Ry bVAuaCAgICAgICB8ICA1IC0tLS0tCiBpbmNsdWRlL2RybS9kcm1fZGV2aWNlLmggfCAzNyArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCiAyIGZpbGVzIGNoYW5nZWQsIDM2IGlu c2VydGlvbnMoKyksIDYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJt UC5oIGIvaW5jbHVkZS9kcm0vZHJtUC5oCmluZGV4IGI2Yjg0MzZiNTEyMy4uMmJhNzg2ODIwMDUy IDEwMDY0NAotLS0gYS9pbmNsdWRlL2RybS9kcm1QLmgKKysrIGIvaW5jbHVkZS9kcm0vZHJtUC5o CkBAIC05NSwxMSArOTUsNiBAQCBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50Owogc3RydWN0IHBj aV9kZXY7CiBzdHJ1Y3QgcGNpX2NvbnRyb2xsZXI7CiAKLSNkZWZpbmUgRFJNX1NXSVRDSF9QT1dF Ul9PTiAwCi0jZGVmaW5lIERSTV9TV0lUQ0hfUE9XRVJfT0ZGIDEKLSNkZWZpbmUgRFJNX1NXSVRD SF9QT1dFUl9DSEFOR0lORyAyCi0jZGVmaW5lIERSTV9TV0lUQ0hfUE9XRVJfRFlOQU1JQ19PRkYg MwotCiAvKiByZXR1cm5zIHRydWUgaWYgY3VycmVudGx5IG9rYXkgdG8gc2xlZXAgKi8KIHN0YXRp YyBpbmxpbmUgYm9vbCBkcm1fY2FuX3NsZWVwKHZvaWQpCiB7CmRpZmYgLS1naXQgYS9pbmNsdWRl L2RybS9kcm1fZGV2aWNlLmggYi9pbmNsdWRlL2RybS9kcm1fZGV2aWNlLmgKaW5kZXggY2QzODVk M2ZjOTc5Li4wOThiYmMyYjE2OWUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2RybV9kZXZpY2Uu aAorKysgYi9pbmNsdWRlL2RybS9kcm1fZGV2aWNlLmgKQEAgLTI0LDYgKzI0LDMzIEBAIHN0cnVj dCBpbm9kZTsKIHN0cnVjdCBwY2lfZGV2Owogc3RydWN0IHBjaV9jb250cm9sbGVyOwogCisKKy8q KgorICogZW51bSBkcm1fc3dpdGNoX3Bvd2VyIC0gcG93ZXIgc3RhdGUgb2YgZHJtIGRldmljZQor ICovCisKK2VudW0gc3dpdGNoX3Bvd2VyX3N0YXRlIHsKKwkvKioKKwkgKiBARFJNX1NXSVRDSF9Q T1dFUl9PTjogUG93ZXIgc3RhdGUgaXMgT04KKwkgKi8KKwlEUk1fU1dJVENIX1BPV0VSX09OID0g MCwKKworCS8qKgorCSAqIEBEUk1fU1dJVENIX1BPV0VSX09GRjogUG93ZXIgc3RhdGUgaXMgT0ZG CisJICovCisJRFJNX1NXSVRDSF9QT1dFUl9PRkYgPSAxLAorCisJLyoqCisJICogQERSTV9TV0lU Q0hfUE9XRVJfQ0hBTkdJTkc6IFBvd2VyIHN0YXRlIGlzIGNoYW5naW5nCisJICovCisJRFJNX1NX SVRDSF9QT1dFUl9DSEFOR0lORyA9IDIsCisKKwkvKioKKwkgKiBARFJNX1NXSVRDSF9QT1dFUl9E WU5BTUlDX09GRjogU3VzcGVuZGVkCisJICovCisJRFJNX1NXSVRDSF9QT1dFUl9EWU5BTUlDX09G RiA9IDMsCit9OworCiAvKioKICAqIHN0cnVjdCBkcm1fZGV2aWNlIC0gRFJNIGRldmljZSBzdHJ1 Y3R1cmUKICAqCkBAIC0yNTksNyArMjg2LDE1IEBAIHN0cnVjdCBkcm1fZGV2aWNlIHsKIAkvKiog QHZtYV9vZmZzZXRfbWFuYWdlcjogR0VNIGluZm9ybWF0aW9uICovCiAJc3RydWN0IGRybV92bWFf b2Zmc2V0X21hbmFnZXIgKnZtYV9vZmZzZXRfbWFuYWdlcjsKIAotCWludCBzd2l0Y2hfcG93ZXJf c3RhdGU7CisJLyoqCisJICogQHN3aXRjaF9wb3dlcl9zdGF0ZToKKwkgKgorCSAqIFBvd2VyIHN0 YXRlIG9mIHRoZSBjbGllbnQuCisJICogVXNlZCBieSBkcml2ZXJzIHN1cHBvcnRpbmcgdGhlIHN3 aXRjaGVyb28gZHJpdmVyLgorCSAqIFRoZSBzdGF0ZSBpcyBtYWludGFpbmVkIGluIHRoZQorCSAq ICZ2Z2Ffc3dpdGNoZXJvb19jbGllbnRfb3BzLnNldF9ncHVfc3RhdGUgY2FsbGJhY2sKKwkgKi8K KwllbnVtIHN3aXRjaF9wb3dlcl9zdGF0ZSBzd2l0Y2hfcG93ZXJfc3RhdGU7CiAKIAkvKioKIAkg KiBAZmJfaGVscGVyOgotLSAKMi4xMi4wCgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2RyaS1kZXZlbAo= 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=-8.5 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED, USER_AGENT_MUTT autolearn=ham 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 15195C43387 for ; Thu, 27 Dec 2018 22:17:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C7F1E20866 for ; Thu, 27 Dec 2018 22:17:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1733151AbeL0WRT (ORCPT ); Thu, 27 Dec 2018 17:17:19 -0500 Received: from asavdk3.altibox.net ([109.247.116.14]:51909 "EHLO asavdk3.altibox.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1733136AbeL0WRS (ORCPT ); Thu, 27 Dec 2018 17:17:18 -0500 Received: from ravnborg.org (unknown [158.248.194.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by asavdk3.altibox.net (Postfix) with ESMTPS id DC62D20058; Thu, 27 Dec 2018 23:17:12 +0100 (CET) Date: Thu, 27 Dec 2018 23:17:11 +0100 From: Sam Ravnborg To: David Airlie , Maarten Lankhorst , Maxime Ripard , Sean Paul , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: Re: [PATCH v1 2/7] drm: move DRM_SWITCH_POWER defines to drm_device.h Message-ID: <20181227221711.GA29366@ravnborg.org> References: <20181226210215.GA27610@ravnborg.org> <20181226210353.13993-2-sam@ravnborg.org> <20181227121234.GE9058@dvetter-linux.ger.corp.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20181227121234.GE9058@dvetter-linux.ger.corp.intel.com> User-Agent: Mutt/1.5.21 (2010-09-15) X-CMAE-Score: 0 X-CMAE-Analysis: v=2.3 cv=dqr19Wo4 c=1 sm=1 tr=0 a=UWs3HLbX/2nnQ3s7vZ42gw==:117 a=UWs3HLbX/2nnQ3s7vZ42gw==:17 a=kj9zAlcOel0A:10 a=7gkXJVJtAAAA:8 a=QyXUC8HyAAAA:8 a=P-IC7800AAAA:8 a=-UzwvaD4mrT_bkKbTtgA:9 a=gTs02ahKwakilbJL:21 a=Ox9J3REOmXjxrJcp:21 a=CjuIK1q_8ugA:10 a=E9Po1WZjFZOl8hwRPBS3:22 a=d3PnA9EDa4IxuAV0gXij:22 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi Daniel. > > +/* Used by drm_device.switch_power_state */ > > +#define DRM_SWITCH_POWER_ON 0 > > +#define DRM_SWITCH_POWER_OFF 1 > > +#define DRM_SWITCH_POWER_CHANGING 2 > > +#define DRM_SWITCH_POWER_DYNAMIC_OFF 3 > > Since this isn't uapi it'd be nice to change it to an enum, which we can > then properly kernel-doc and make your references links in the resulting > html. Otherwise lgtm. > > Would need an include stanza for drm_device.h in drm-internals.rst, plus a > bit of kernel-doc cleanup in here I think (which iirc is why I didn't yet > do this). Converting to enum was easy, the documentation part not so. I have tried to add some documentation based on what I could figure out. There are room for improvements. The other task was to include drm_device in the documentation. This work resulted in the following two patches that I will post as part of an updated series later. Posted here to maybe get some initial feedback. Sam >From 3bc5d6a11a1e04f20a465e2690583c87cee74ac0 Mon Sep 17 00:00:00 2001 From: Sam Ravnborg Date: Thu, 27 Dec 2018 23:03:12 +0100 Subject: [PATCH 1/7] drm: add drm_device.h to kernel-doc Updated comment style to kernel-doc format Signed-off-by: Sam Ravnborg --- Documentation/gpu/drm-internals.rst | 4 + include/drm/drm_device.h | 157 ++++++++++++++++++++++-------------- 2 files changed, 101 insertions(+), 60 deletions(-) diff --git a/Documentation/gpu/drm-internals.rst b/Documentation/gpu/drm-internals.rst index 5ee9674fb9e9..7a677b2b0ebc 100644 --- a/Documentation/gpu/drm-internals.rst +++ b/Documentation/gpu/drm-internals.rst @@ -149,6 +149,10 @@ Device Instance and Driver Handling .. kernel-doc:: drivers/gpu/drm/drm_drv.c :export: +DRM Device +---------- +.. kernel-doc:: include/drm/drm_device.h + Driver Load ----------- diff --git a/include/drm/drm_device.h b/include/drm/drm_device.h index 42411b3ea0c8..cd385d3fc979 100644 --- a/include/drm/drm_device.h +++ b/include/drm/drm_device.h @@ -25,24 +25,39 @@ struct pci_dev; struct pci_controller; /** - * DRM device structure. This structure represent a complete card that + * struct drm_device - DRM device structure + * + * This structure represent a complete card that * may contain multiple heads. */ struct drm_device { - struct list_head legacy_dev_list;/**< list of devices per driver for stealth attach cleanup */ - int if_version; /**< Highest interface version set */ - - /** \name Lifetime Management */ - /*@{ */ - struct kref ref; /**< Object ref-count */ - struct device *dev; /**< Device structure of bus-device */ - struct drm_driver *driver; /**< DRM driver managing the device */ - void *dev_private; /**< DRM driver private data */ - struct drm_minor *primary; /**< Primary node */ - struct drm_minor *render; /**< Render node */ + /** @legacy_dev_list: List of devices per driver for stealth attach cleanup */ + struct list_head legacy_dev_list; + + /** @if_version: Highest interface version set */ + int if_version; + + /** @ref: Object ref-count */ + struct kref ref; + + /** @dev: Device structure of bus-device */ + struct device *dev; + + /** @driver: DRM driver managing the device */ + struct drm_driver *driver; + + /** @dev_private: DRM driver private data */ + void *dev_private; + + /** @primary: Primary node */ + struct drm_minor *primary; + + /** @render: Render node */ + struct drm_minor *render; + bool registered; - /* currently active master for this device. Protected by master_mutex */ + /** @master: Currently active master for this device. Protected by master_mutex */ struct drm_master *master; /** @@ -63,23 +78,29 @@ struct drm_device { */ bool unplugged; - struct inode *anon_inode; /**< inode for private address-space */ - char *unique; /**< unique name of the device */ - /*@} */ + /** @anon_inode: inode for private address-space */ + struct inode *anon_inode; + + /** @unique: Unique name of the device */ + char *unique; + + /** @struct_mutex: Lock for others (not drm_minor::master and drm_file::is_master) */ + struct mutex struct_mutex; + + /** @master_mutex: Lock for drm_minor::master and drm_file::is_master */ + struct mutex master_mutex; + + /** @open_count: Usage counter for outstanding files open, protected by drm_global_mutex. */ + int open_count; - /** \name Locks */ - /*@{ */ - struct mutex struct_mutex; /**< For others */ - struct mutex master_mutex; /**< For drm_minor::master and drm_file::is_master */ - /*@} */ + /** @buf_lock: Lock for drm_device::buf_use and a few other things. */ + spinlock_t buf_lock; - /** \name Usage Counters */ - /*@{ */ - int open_count; /**< Outstanding files open, protected by drm_global_mutex. */ - spinlock_t buf_lock; /**< For drm_device::buf_use and a few other things. */ - int buf_use; /**< Buffers in use -- cannot alloc */ - atomic_t buf_alloc; /**< Buffer allocation in progress */ - /*@} */ + /** @buf_use: Usage counter for buffers in use -- cannot alloc */ + int buf_use; + + /** @buf_alloc: Buffer allocation in progress */ + atomic_t buf_alloc; struct mutex filelist_mutex; struct list_head filelist; @@ -105,33 +126,32 @@ struct drm_device { */ struct list_head clientlist; - /** \name Memory management */ - /*@{ */ - struct list_head maplist; /**< Linked list of regions */ - struct drm_open_hash map_hash; /**< User token hash table for maps */ + /** @maplist: Memory management - linked list of regions */ + struct list_head maplist; - /** \name Context handle management */ - /*@{ */ - struct list_head ctxlist; /**< Linked list of context handles */ - struct mutex ctxlist_mutex; /**< For ctxlist */ + /** @map_hash: Memory management - user token hash table for maps */ + struct drm_open_hash map_hash; - struct idr ctx_idr; + /** @ctxlist: Context handle management - linked list of context handles */ + struct list_head ctxlist; + + /** @ctxlist_mutex: Context handle management - mutex for ctxlist */ + struct mutex ctxlist_mutex; - struct list_head vmalist; /**< List of vmas (for debugging) */ + /** @ctx_idr: Context handle management */ + struct idr ctx_idr; - /*@} */ + /** @vmalist: Context handle management - list of vmas (for debugging) */ + struct list_head vmalist; - /** \name DMA support */ - /*@{ */ - struct drm_device_dma *dma; /**< Optional pointer for DMA support */ - /*@} */ + /** @dma: Optional pointer for DMA support */ + struct drm_device_dma *dma; - /** \name Context support */ - /*@{ */ + /** @context_flag: Context swapping flag */ + __volatile__ long context_flag; - __volatile__ long context_flag; /**< Context swapping flag */ - int last_context; /**< Last current context */ - /*@} */ + /** @last_context: Last current context */ + int last_context; /** * @irq_enabled: @@ -168,7 +188,12 @@ struct drm_device { */ struct drm_vblank_crtc *vblank; - spinlock_t vblank_time_lock; /**< Protects vblank count and time updates during vblank enable/disable */ + /** + * @vblank_time_lock: + * + * Protects vblank count and time updates during vblank enable/disable + */ + spinlock_t vblank_time_lock; spinlock_t vbl_lock; /** @@ -186,25 +211,33 @@ struct drm_device { * * If non-zeor, &drm_crtc_funcs.get_vblank_counter must be set. */ - u32 max_vblank_count; /**< size of vblank counter register */ + + /** @max_vblank_count: Size of vblank counter register */ + u32 max_vblank_count; /** - * List of events + * @vblank_event_list: + * + * List of vblank events */ struct list_head vblank_event_list; spinlock_t event_lock; - /*@} */ + /** @agp: AGP data */ + struct drm_agp_head *agp; - struct drm_agp_head *agp; /**< AGP data */ + /** @pdev: PCI device structure */ + struct pci_dev *pdev; - struct pci_dev *pdev; /**< PCI device structure */ #ifdef __alpha__ struct pci_controller *hose; #endif - struct drm_sg_mem *sg; /**< Scatter gather memory */ - unsigned int num_crtcs; /**< Number of CRTCs on this device */ + /** @sg: Scatter gather memory */ + struct drm_sg_mem *sg; + + /** @num_crtcs: Number of CRTCs on this device */ + unsigned int num_crtcs; struct { int context; @@ -214,14 +247,18 @@ struct drm_device { struct drm_local_map *agp_buffer_map; unsigned int agp_buffer_token; - struct drm_mode_config mode_config; /**< Current mode config */ + /** @mode_config: Current mode config */ + struct drm_mode_config mode_config; - /** \name GEM information */ - /*@{ */ + /** @object_name_lock: GEM information */ struct mutex object_name_lock; + + /** @object_name_idr: GEM information */ struct idr object_name_idr; + + /** @vma_offset_manager: GEM information */ struct drm_vma_offset_manager *vma_offset_manager; - /*@} */ + int switch_power_state; /** -- 2.12.0 >From a3c94604f8c32a2a48efc79d15fbc66e0e62fd33 Mon Sep 17 00:00:00 2001 From: Sam Ravnborg Date: Wed, 26 Dec 2018 14:21:01 +0100 Subject: [PATCH 2/7] drm: move DRM_SWITCH_POWER defines to drm_device.h Move DRM_SWITCH_POWER out of drmP.h to allow users to get rid of the drmP include. DRM_SWITCH_POWER defines are used in combination with drm_device.switch_power_state. Move the DRM_SWITCH_POWER defines to the file where drm_device.switch_power_state is defined. Signed-off-by: Sam Ravnborg Cc: Maarten Lankhorst Cc: Maxime Ripard Cc: Sean Paul Cc: David Airlie Cc: Daniel Vetter --- include/drm/drmP.h | 5 ----- include/drm/drm_device.h | 37 ++++++++++++++++++++++++++++++++++++- 2 files changed, 36 insertions(+), 6 deletions(-) diff --git a/include/drm/drmP.h b/include/drm/drmP.h index b6b8436b5123..2ba786820052 100644 --- a/include/drm/drmP.h +++ b/include/drm/drmP.h @@ -95,11 +95,6 @@ struct dma_buf_attachment; struct pci_dev; struct pci_controller; -#define DRM_SWITCH_POWER_ON 0 -#define DRM_SWITCH_POWER_OFF 1 -#define DRM_SWITCH_POWER_CHANGING 2 -#define DRM_SWITCH_POWER_DYNAMIC_OFF 3 - /* returns true if currently okay to sleep */ static inline bool drm_can_sleep(void) { diff --git a/include/drm/drm_device.h b/include/drm/drm_device.h index cd385d3fc979..098bbc2b169e 100644 --- a/include/drm/drm_device.h +++ b/include/drm/drm_device.h @@ -24,6 +24,33 @@ struct inode; struct pci_dev; struct pci_controller; + +/** + * enum drm_switch_power - power state of drm device + */ + +enum switch_power_state { + /** + * @DRM_SWITCH_POWER_ON: Power state is ON + */ + DRM_SWITCH_POWER_ON = 0, + + /** + * @DRM_SWITCH_POWER_OFF: Power state is OFF + */ + DRM_SWITCH_POWER_OFF = 1, + + /** + * @DRM_SWITCH_POWER_CHANGING: Power state is changing + */ + DRM_SWITCH_POWER_CHANGING = 2, + + /** + * @DRM_SWITCH_POWER_DYNAMIC_OFF: Suspended + */ + DRM_SWITCH_POWER_DYNAMIC_OFF = 3, +}; + /** * struct drm_device - DRM device structure * @@ -259,7 +286,15 @@ struct drm_device { /** @vma_offset_manager: GEM information */ struct drm_vma_offset_manager *vma_offset_manager; - int switch_power_state; + /** + * @switch_power_state: + * + * Power state of the client. + * Used by drivers supporting the switcheroo driver. + * The state is maintained in the + * &vga_switcheroo_client_ops.set_gpu_state callback + */ + enum switch_power_state switch_power_state; /** * @fb_helper: -- 2.12.0