From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?Q?Christian_K=c3=b6nig?= Subject: Re: [PATCH 5/5] dma-fence: Polish kernel-doc for dma-fence.c Date: Wed, 4 Jul 2018 11:36:26 +0200 Message-ID: <14cbffca-b274-a190-a7e8-243d1225927e@gmail.com> References: <20180704092909.6599-1-daniel.vetter@ffwll.ch> <20180704092909.6599-6-daniel.vetter@ffwll.ch> Reply-To: christian.koenig@amd.com Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180704092909.6599-6-daniel.vetter@ffwll.ch> Content-Language: en-US List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Daniel Vetter , DRI Development Cc: linaro-mm-sig@lists.linaro.org, Intel Graphics Development , linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org QW0gMDQuMDcuMjAxOCB1bSAxMToyOSBzY2hyaWViIERhbmllbCBWZXR0ZXI6Cj4gLSBJbnRybyBz ZWN0aW9uIHRoYXQgbGlua3MgdG8gaG93IHRoaXMgaXMgZXhwb3NlZCB0byB1c2Vyc3BhY2UuCj4g LSBMb3RzIG1vcmUgaHlwZXJsaW5rcy4KPiAtIE1pbm9yIGNsYXJpZmljYXRpb25zIGFuZCBzdHls ZSBwb2xpc2gKPgo+IHYyOiBBZGQgbWlzcGxhY2VkIGh1bmsgb2Yga2VybmVsZG9jIGZyb20gYSBk aWZmZXJlbnQgcGF0Y2guCj4KPiBTaWduZWQtb2ZmLWJ5OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwu dmV0dGVyQGZmd2xsLmNoPgo+IENjOiBTdW1pdCBTZW13YWwgPHN1bWl0LnNlbXdhbEBsaW5hcm8u b3JnPgo+IENjOiBHdXN0YXZvIFBhZG92YW4gPGd1c3Rhdm9AcGFkb3Zhbi5vcmc+Cj4gQ2M6IGxp bnV4LW1lZGlhQHZnZXIua2VybmVsLm9yZwo+IENjOiBsaW5hcm8tbW0tc2lnQGxpc3RzLmxpbmFy by5vcmcKClJldmlld2VkLWJ5OiBDaHJpc3RpYW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFt ZC5jb20+Cgo+IC0tLQo+ICAgRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0IHwg ICA2ICsrCj4gICBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMgICAgICAgICAgfCAxNDcgKysr KysrKysrKysrKysrKysrKy0tLS0tLS0tCj4gICAyIGZpbGVzIGNoYW5nZWQsIDEwOSBpbnNlcnRp b25zKCspLCA0NCBkZWxldGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2Ry aXZlci1hcGkvZG1hLWJ1Zi5yc3QgYi9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZG1hLWJ1Zi5y c3QKPiBpbmRleCBkYzM4NGYyZjdmMzQuLmI1NDFlOTdjN2FiMSAxMDA2NDQKPiAtLS0gYS9Eb2N1 bWVudGF0aW9uL2RyaXZlci1hcGkvZG1hLWJ1Zi5yc3QKPiArKysgYi9Eb2N1bWVudGF0aW9uL2Ry aXZlci1hcGkvZG1hLWJ1Zi5yc3QKPiBAQCAtMTMwLDYgKzEzMCwxMiBAQCBSZXNlcnZhdGlvbiBP YmplY3RzCj4gICBETUEgRmVuY2VzCj4gICAtLS0tLS0tLS0tCj4gICAKPiArLi4ga2VybmVsLWRv Yzo6IGRyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVuY2UuYwo+ICsgICA6ZG9jOiBETUEgZmVuY2VzIG92 ZXJ2aWV3Cj4gKwo+ICtETUEgRmVuY2VzIEZ1bmN0aW9ucyBSZWZlcmVuY2UKPiArfn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+Cj4gKwo+ICAgLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvZG1h LWJ1Zi9kbWEtZmVuY2UuYwo+ICAgICAgOmV4cG9ydDoKPiAgIAo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKPiBp bmRleCA3YTkyZjg1YTRjZWMuLjE1NTFjYTdkZjM5NCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2Rt YS1idWYvZG1hLWZlbmNlLmMKPiArKysgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKPiBA QCAtMzgsMTIgKzM4LDQzIEBAIEVYUE9SVF9UUkFDRVBPSU5UX1NZTUJPTChkbWFfZmVuY2VfZW5h YmxlX3NpZ25hbCk7Cj4gICAgKi8KPiAgIHN0YXRpYyBhdG9taWM2NF90IGRtYV9mZW5jZV9jb250 ZXh0X2NvdW50ZXIgPSBBVE9NSUM2NF9JTklUKDApOwo+ICAgCj4gKy8qKgo+ICsgKiBET0M6IERN QSBmZW5jZXMgb3ZlcnZpZXcKPiArICoKPiArICogRE1BIGZlbmNlcywgcmVwcmVzZW50ZWQgYnkg JnN0cnVjdCBkbWFfZmVuY2UsIGFyZSB0aGUga2VybmVsIGludGVybmFsCj4gKyAqIHN5bmNocm9u aXphdGlvbiBwcmltaXRpdmUgZm9yIERNQSBvcGVyYXRpb25zIGxpa2UgR1BVIHJlbmRlcmluZywg dmlkZW8KPiArICogZW5jb2RpbmcvZGVjb2RpbmcsIG9yIGRpc3BsYXlpbmcgYnVmZmVycyBvbiBh IHNjcmVlbi4KPiArICoKPiArICogQSBmZW5jZSBpcyBpbml0aWFsaXplZCB1c2luZyBkbWFfZmVu Y2VfaW5pdCgpIGFuZCBjb21wbGV0ZWQgdXNpbmcKPiArICogZG1hX2ZlbmNlX3NpZ25hbCgpLiBG ZW5jZXMgYXJlIGFzc29jaWF0ZWQgd2l0aCBhIGNvbnRleHQsIGFsbG9jYXRlZCB0aHJvdWdoCj4g KyAqIGRtYV9mZW5jZV9jb250ZXh0X2FsbG9jKCksIGFuZCBhbGwgZmVuY2VzIG9uIHRoZSBzYW1l IGNvbnRleHQgYXJlCj4gKyAqIGZ1bGx5IG9yZGVyZWQuCj4gKyAqCj4gKyAqIFNpbmNlIHRoZSBw dXJwb3NlcyBvZiBmZW5jZXMgaXMgdG8gZmFjaWxpdGF0ZSBjcm9zcy1kZXZpY2UgYW5kCj4gKyAq IGNyb3NzLWFwcGxpY2F0aW9uIHN5bmNocm9uaXphdGlvbiwgdGhlcmUncyBtdWx0aXBsZSB3YXlz IHRvIHVzZSBvbmU6Cj4gKyAqCj4gKyAqIC0gSW5kaXZpZHVhbCBmZW5jZXMgY2FuIGJlIGV4cG9z ZWQgYXMgYSAmc3luY19maWxlLCBhY2Nlc3NlZCBhcyBhIGZpbGUKPiArICogICBkZXNjcmlwdG9y IGZyb20gdXNlcnNwYWNlLCBjcmVhdGVkIGJ5IGNhbGxpbmcgc3luY19maWxlX2NyZWF0ZSgpLiBU aGlzIGlzCj4gKyAqICAgY2FsbGVkIGV4cGxpY2l0IGZlbmNpbmcsIHNpbmNlIHVzZXJzcGFjZSBw YXNzZXMgYXJvdW5kIGV4cGxpY2l0Cj4gKyAqICAgc3luY2hyb25pemF0aW9uIHBvaW50cy4KPiAr ICoKPiArICogLSBTb21lIHN1YnN5c3RlbXMgYWxzbyBoYXZlIHRoZWlyIG93biBleHBsaWNpdCBm ZW5jaW5nIHByaW1pdGl2ZXMsIGxpa2UKPiArICogICAmZHJtX3N5bmNvYmouIENvbXBhcmVkIHRv ICZzeW5jX2ZpbGUsIGEgJmRybV9zeW5jb2JqIGFsbG93cyB0aGUgdW5kZXJseWluZwo+ICsgKiAg IGZlbmNlIHRvIGJlIHVwZGF0ZWQuCj4gKyAqCj4gKyAqIC0gVGhlbiB0aGVyZSdzIGFsc28gaW1w bGljaXQgZmVuY2luZywgd2hlcmUgdGhlIHN5bmNocm9uaXphdGlvbiBwb2ludHMgYXJlCj4gKyAq ICAgaW1wbGljaXRseSBwYXNzZWQgYXJvdW5kIGFzIHBhcnQgb2Ygc2hhcmVkICZkbWFfYnVmIGlu c3RhbmNlcy4gU3VjaAo+ICsgKiAgIGltcGxpY2l0IGZlbmNlcyBhcmUgc3RvcmVkIGluICZzdHJ1 Y3QgcmVzZXJ2YXRpb25fb2JqZWN0IHRocm91Z2ggdGhlCj4gKyAqICAgJmRtYV9idWYucmVzdiBw b2ludGVyLgo+ICsgKi8KPiArCj4gICAvKioKPiAgICAqIGRtYV9mZW5jZV9jb250ZXh0X2FsbG9j IC0gYWxsb2NhdGUgYW4gYXJyYXkgb2YgZmVuY2UgY29udGV4dHMKPiAtICogQG51bToJW2luXQlh bW91bnQgb2YgY29udGV4dHMgdG8gYWxsb2NhdGUKPiArICogQG51bTogYW1vdW50IG9mIGNvbnRl eHRzIHRvIGFsbG9jYXRlCj4gICAgKgo+IC0gKiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmV0dXJuIHRo ZSBmaXJzdCBpbmRleCBvZiB0aGUgbnVtYmVyIG9mIGZlbmNlcyBhbGxvY2F0ZWQuCj4gLSAqIFRo ZSBmZW5jZSBjb250ZXh0IGlzIHVzZWQgZm9yIHNldHRpbmcgZmVuY2UtPmNvbnRleHQgdG8gYSB1 bmlxdWUgbnVtYmVyLgo+ICsgKiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmV0dXJuIHRoZSBmaXJzdCBp bmRleCBvZiB0aGUgbnVtYmVyIG9mIGZlbmNlIGNvbnRleHRzCj4gKyAqIGFsbG9jYXRlZC4gIFRo ZSBmZW5jZSBjb250ZXh0IGlzIHVzZWQgZm9yIHNldHRpbmcgJmRtYV9mZW5jZS5jb250ZXh0IHRv IGEKPiArICogdW5pcXVlIG51bWJlciBieSBwYXNzaW5nIHRoZSBjb250ZXh0IHRvIGRtYV9mZW5j ZV9pbml0KCkuCj4gICAgKi8KPiAgIHU2NCBkbWFfZmVuY2VfY29udGV4dF9hbGxvYyh1bnNpZ25l ZCBudW0pCj4gICB7Cj4gQEAgLTU5LDEwICs5MCwxNCBAQCBFWFBPUlRfU1lNQk9MKGRtYV9mZW5j ZV9jb250ZXh0X2FsbG9jKTsKPiAgICAqIFNpZ25hbCBjb21wbGV0aW9uIGZvciBzb2Z0d2FyZSBj YWxsYmFja3Mgb24gYSBmZW5jZSwgdGhpcyB3aWxsIHVuYmxvY2sKPiAgICAqIGRtYV9mZW5jZV93 YWl0KCkgY2FsbHMgYW5kIHJ1biBhbGwgdGhlIGNhbGxiYWNrcyBhZGRlZCB3aXRoCj4gICAgKiBk bWFfZmVuY2VfYWRkX2NhbGxiYWNrKCkuIENhbiBiZSBjYWxsZWQgbXVsdGlwbGUgdGltZXMsIGJ1 dCBzaW5jZSBhIGZlbmNlCj4gLSAqIGNhbiBvbmx5IGdvIGZyb20gdW5zaWduYWxlZCB0byBzaWdu YWxlZCBzdGF0ZSwgaXQgd2lsbCBvbmx5IGJlIGVmZmVjdGl2ZQo+IC0gKiB0aGUgZmlyc3QgdGlt ZS4KPiArICogY2FuIG9ubHkgZ28gZnJvbSB0aGUgdW5zaWduYWxlZCB0byB0aGUgc2lnbmFsZWQg c3RhdGUgYW5kIG5vdCBiYWNrLCBpdCB3aWxsCj4gKyAqIG9ubHkgYmUgZWZmZWN0aXZlIHRoZSBm aXJzdCB0aW1lLgo+ICsgKgo+ICsgKiBVbmxpa2UgZG1hX2ZlbmNlX3NpZ25hbCgpLCB0aGlzIGZ1 bmN0aW9uIG11c3QgYmUgY2FsbGVkIHdpdGggJmRtYV9mZW5jZS5sb2NrCj4gKyAqIGhlbGQuCj4g ICAgKgo+IC0gKiBVbmxpa2UgZG1hX2ZlbmNlX3NpZ25hbCwgdGhpcyBmdW5jdGlvbiBtdXN0IGJl IGNhbGxlZCB3aXRoIGZlbmNlLT5sb2NrIGhlbGQuCj4gKyAqIFJldHVybnMgMCBvbiBzdWNjZXNz IGFuZCBhIG5lZ2F0aXZlIGVycm9yIHZhbHVlIHdoZW4gQGZlbmNlIGhhcyBiZWVuCj4gKyAqIHNp Z25hbGxlZCBhbHJlYWR5Lgo+ICAgICovCj4gICBpbnQgZG1hX2ZlbmNlX3NpZ25hbF9sb2NrZWQo c3RydWN0IGRtYV9mZW5jZSAqZmVuY2UpCj4gICB7Cj4gQEAgLTEwMiw4ICsxMzcsMTEgQEAgRVhQ T1JUX1NZTUJPTChkbWFfZmVuY2Vfc2lnbmFsX2xvY2tlZCk7Cj4gICAgKiBTaWduYWwgY29tcGxl dGlvbiBmb3Igc29mdHdhcmUgY2FsbGJhY2tzIG9uIGEgZmVuY2UsIHRoaXMgd2lsbCB1bmJsb2Nr Cj4gICAgKiBkbWFfZmVuY2Vfd2FpdCgpIGNhbGxzIGFuZCBydW4gYWxsIHRoZSBjYWxsYmFja3Mg YWRkZWQgd2l0aAo+ICAgICogZG1hX2ZlbmNlX2FkZF9jYWxsYmFjaygpLiBDYW4gYmUgY2FsbGVk IG11bHRpcGxlIHRpbWVzLCBidXQgc2luY2UgYSBmZW5jZQo+IC0gKiBjYW4gb25seSBnbyBmcm9t IHVuc2lnbmFsZWQgdG8gc2lnbmFsZWQgc3RhdGUsIGl0IHdpbGwgb25seSBiZSBlZmZlY3RpdmUK PiAtICogdGhlIGZpcnN0IHRpbWUuCj4gKyAqIGNhbiBvbmx5IGdvIGZyb20gdGhlIHVuc2lnbmFs ZWQgdG8gdGhlIHNpZ25hbGVkIHN0YXRlIGFuZCBub3QgYmFjaywgaXQgd2lsbAo+ICsgKiBvbmx5 IGJlIGVmZmVjdGl2ZSB0aGUgZmlyc3QgdGltZS4KPiArICoKPiArICogUmV0dXJucyAwIG9uIHN1 Y2Nlc3MgYW5kIGEgbmVnYXRpdmUgZXJyb3IgdmFsdWUgd2hlbiBAZmVuY2UgaGFzIGJlZW4KPiAr ICogc2lnbmFsbGVkIGFscmVhZHkuCj4gICAgKi8KPiAgIGludCBkbWFfZmVuY2Vfc2lnbmFsKHN0 cnVjdCBkbWFfZmVuY2UgKmZlbmNlKQo+ICAgewo+IEBAIC0xMzYsOSArMTc0LDkgQEAgRVhQT1JU X1NZTUJPTChkbWFfZmVuY2Vfc2lnbmFsKTsKPiAgIC8qKgo+ICAgICogZG1hX2ZlbmNlX3dhaXRf dGltZW91dCAtIHNsZWVwIHVudGlsIHRoZSBmZW5jZSBnZXRzIHNpZ25hbGVkCj4gICAgKiBvciB1 bnRpbCB0aW1lb3V0IGVsYXBzZXMKPiAtICogQGZlbmNlOglbaW5dCXRoZSBmZW5jZSB0byB3YWl0 IG9uCj4gLSAqIEBpbnRyOglbaW5dCWlmIHRydWUsIGRvIGFuIGludGVycnVwdGlibGUgd2FpdAo+ IC0gKiBAdGltZW91dDoJW2luXQl0aW1lb3V0IHZhbHVlIGluIGppZmZpZXMsIG9yIE1BWF9TQ0hF RFVMRV9USU1FT1VUCj4gKyAqIEBmZW5jZTogdGhlIGZlbmNlIHRvIHdhaXQgb24KPiArICogQGlu dHI6IGlmIHRydWUsIGRvIGFuIGludGVycnVwdGlibGUgd2FpdAo+ICsgKiBAdGltZW91dDogdGlt ZW91dCB2YWx1ZSBpbiBqaWZmaWVzLCBvciBNQVhfU0NIRURVTEVfVElNRU9VVAo+ICAgICoKPiAg ICAqIFJldHVybnMgLUVSRVNUQVJUU1lTIGlmIGludGVycnVwdGVkLCAwIGlmIHRoZSB3YWl0IHRp bWVkIG91dCwgb3IgdGhlCj4gICAgKiByZW1haW5pbmcgdGltZW91dCBpbiBqaWZmaWVzIG9uIHN1 Y2Nlc3MuIE90aGVyIGVycm9yIHZhbHVlcyBtYXkgYmUKPiBAQCAtMTQ4LDYgKzE4Niw4IEBAIEVY UE9SVF9TWU1CT0woZG1hX2ZlbmNlX3NpZ25hbCk7Cj4gICAgKiBkaXJlY3RseSBvciBpbmRpcmVj dGx5IChidWYtbWdyIGJldHdlZW4gcmVzZXJ2YXRpb24gYW5kIGNvbW1pdHRpbmcpCj4gICAgKiBo b2xkcyBhIHJlZmVyZW5jZSB0byB0aGUgZmVuY2UsIG90aGVyd2lzZSB0aGUgZmVuY2UgbWlnaHQg YmUKPiAgICAqIGZyZWVkIGJlZm9yZSByZXR1cm4sIHJlc3VsdGluZyBpbiB1bmRlZmluZWQgYmVo YXZpb3IuCj4gKyAqCj4gKyAqIFNlZSBhbHNvIGRtYV9mZW5jZV93YWl0KCkgYW5kIGRtYV9mZW5j ZV93YWl0X2FueV90aW1lb3V0KCkuCj4gICAgKi8KPiAgIHNpZ25lZCBsb25nCj4gICBkbWFfZmVu Y2Vfd2FpdF90aW1lb3V0KHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlLCBib29sIGludHIsIHNpZ25l ZCBsb25nIHRpbWVvdXQpCj4gQEAgLTE2Nyw2ICsyMDcsMTMgQEAgZG1hX2ZlbmNlX3dhaXRfdGlt ZW91dChzdHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSwgYm9vbCBpbnRyLCBzaWduZWQgbG9uZyB0aW1l b3V0KQo+ICAgfQo+ICAgRVhQT1JUX1NZTUJPTChkbWFfZmVuY2Vfd2FpdF90aW1lb3V0KTsKPiAg IAo+ICsvKioKPiArICogZG1hX2ZlbmNlX3JlbGVhc2UgLSBkZWZhdWx0IHJlbGVzZSBmdW5jdGlv biBmb3IgZmVuY2VzCj4gKyAqIEBrcmVmOiAmZG1hX2ZlbmNlLnJlY2ZvdW50Cj4gKyAqCj4gKyAq IFRoaXMgaXMgdGhlIGRlZmF1bHQgcmVsZWFzZSBmdW5jdGlvbnMgZm9yICZkbWFfZmVuY2UuIERy aXZlcnMgc2hvdWxkbid0IGNhbGwKPiArICogdGhpcyBkaXJlY3RseSwgYnV0IGluc3RlYWQgY2Fs bCBkbWFfZmVuY2VfcHV0KCkuCj4gKyAqLwo+ICAgdm9pZCBkbWFfZmVuY2VfcmVsZWFzZShzdHJ1 Y3Qga3JlZiAqa3JlZikKPiAgIHsKPiAgIAlzdHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSA9Cj4gQEAg LTE4NCw2ICsyMzEsMTMgQEAgdm9pZCBkbWFfZmVuY2VfcmVsZWFzZShzdHJ1Y3Qga3JlZiAqa3Jl ZikKPiAgIH0KPiAgIEVYUE9SVF9TWU1CT0woZG1hX2ZlbmNlX3JlbGVhc2UpOwo+ICAgCj4gKy8q Kgo+ICsgKiBkbWFfZmVuY2VfZnJlZSAtIGRlZmF1bHQgcmVsZWFzZSBmdW5jdGlvbiBmb3IgJmRt YV9mZW5jZS4KPiArICogQGZlbmNlOiBmZW5jZSB0byByZWxlYXNlCj4gKyAqCj4gKyAqIFRoaXMg aXMgdGhlIGRlZmF1bHQgaW1wbGVtZW50YXRpb24gZm9yICZkbWFfZmVuY2Vfb3BzLnJlbGVhc2Uu IEl0IGNhbGxzCj4gKyAqIGtmcmVlX3JjdSgpIG9uIEBmZW5jZS4KPiArICovCj4gICB2b2lkIGRt YV9mZW5jZV9mcmVlKHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlKQo+ICAgewo+ICAgCWtmcmVlX3Jj dShmZW5jZSwgcmN1KTsKPiBAQCAtMTkyLDEwICsyNDYsMTEgQEAgRVhQT1JUX1NZTUJPTChkbWFf ZmVuY2VfZnJlZSk7Cj4gICAKPiAgIC8qKgo+ICAgICogZG1hX2ZlbmNlX2VuYWJsZV9zd19zaWdu YWxpbmcgLSBlbmFibGUgc2lnbmFsaW5nIG9uIGZlbmNlCj4gLSAqIEBmZW5jZToJW2luXQl0aGUg ZmVuY2UgdG8gZW5hYmxlCj4gKyAqIEBmZW5jZTogdGhlIGZlbmNlIHRvIGVuYWJsZQo+ICAgICoK PiAtICogdGhpcyB3aWxsIHJlcXVlc3QgZm9yIHN3IHNpZ25hbGluZyB0byBiZSBlbmFibGVkLCB0 byBtYWtlIHRoZSBmZW5jZQo+IC0gKiBjb21wbGV0ZSBhcyBzb29uIGFzIHBvc3NpYmxlCj4gKyAq IFRoaXMgd2lsbCByZXF1ZXN0IGZvciBzdyBzaWduYWxpbmcgdG8gYmUgZW5hYmxlZCwgdG8gbWFr ZSB0aGUgZmVuY2UKPiArICogY29tcGxldGUgYXMgc29vbiBhcyBwb3NzaWJsZS4gVGhpcyBjYWxs cyAmZG1hX2ZlbmNlX29wcy5lbmFibGVfc2lnbmFsaW5nCj4gKyAqIGludGVybmFsbHkuCj4gICAg Ki8KPiAgIHZvaWQgZG1hX2ZlbmNlX2VuYWJsZV9zd19zaWduYWxpbmcoc3RydWN0IGRtYV9mZW5j ZSAqZmVuY2UpCj4gICB7Cj4gQEAgLTIyMCwyNCArMjc1LDI0IEBAIEVYUE9SVF9TWU1CT0woZG1h X2ZlbmNlX2VuYWJsZV9zd19zaWduYWxpbmcpOwo+ICAgLyoqCj4gICAgKiBkbWFfZmVuY2VfYWRk X2NhbGxiYWNrIC0gYWRkIGEgY2FsbGJhY2sgdG8gYmUgY2FsbGVkIHdoZW4gdGhlIGZlbmNlCj4g ICAgKiBpcyBzaWduYWxlZAo+IC0gKiBAZmVuY2U6CVtpbl0JdGhlIGZlbmNlIHRvIHdhaXQgb24K PiAtICogQGNiOgkJW2luXQl0aGUgY2FsbGJhY2sgdG8gcmVnaXN0ZXIKPiAtICogQGZ1bmM6CVtp bl0JdGhlIGZ1bmN0aW9uIHRvIGNhbGwKPiArICogQGZlbmNlOiB0aGUgZmVuY2UgdG8gd2FpdCBv bgo+ICsgKiBAY2I6IHRoZSBjYWxsYmFjayB0byByZWdpc3Rlcgo+ICsgKiBAZnVuYzogdGhlIGZ1 bmN0aW9uIHRvIGNhbGwKPiAgICAqCj4gLSAqIGNiIHdpbGwgYmUgaW5pdGlhbGl6ZWQgYnkgZG1h X2ZlbmNlX2FkZF9jYWxsYmFjaywgbm8gaW5pdGlhbGl6YXRpb24KPiArICogQGNiIHdpbGwgYmUg aW5pdGlhbGl6ZWQgYnkgZG1hX2ZlbmNlX2FkZF9jYWxsYmFjaygpLCBubyBpbml0aWFsaXphdGlv bgo+ICAgICogYnkgdGhlIGNhbGxlciBpcyByZXF1aXJlZC4gQW55IG51bWJlciBvZiBjYWxsYmFj a3MgY2FuIGJlIHJlZ2lzdGVyZWQKPiAgICAqIHRvIGEgZmVuY2UsIGJ1dCBhIGNhbGxiYWNrIGNh biBvbmx5IGJlIHJlZ2lzdGVyZWQgdG8gb25lIGZlbmNlIGF0IGEgdGltZS4KPiAgICAqCj4gICAg KiBOb3RlIHRoYXQgdGhlIGNhbGxiYWNrIGNhbiBiZSBjYWxsZWQgZnJvbSBhbiBhdG9taWMgY29u dGV4dC4gIElmCj4gICAgKiBmZW5jZSBpcyBhbHJlYWR5IHNpZ25hbGVkLCB0aGlzIGZ1bmN0aW9u IHdpbGwgcmV0dXJuIC1FTk9FTlQgKGFuZAo+IC0gKiAqbm90KiBjYWxsIHRoZSBjYWxsYmFjaykK PiArICogKm5vdCogY2FsbCB0aGUgY2FsbGJhY2spLgo+ICAgICoKPiAgICAqIEFkZCBhIHNvZnR3 YXJlIGNhbGxiYWNrIHRvIHRoZSBmZW5jZS4gU2FtZSByZXN0cmljdGlvbnMgYXBwbHkgdG8KPiAt ICogcmVmY291bnQgYXMgaXQgZG9lcyB0byBkbWFfZmVuY2Vfd2FpdCwgaG93ZXZlciB0aGUgY2Fs bGVyIGRvZXNuJ3QgbmVlZCB0bwo+IC0gKiBrZWVwIGEgcmVmY291bnQgdG8gZmVuY2UgYWZ0ZXJ3 YXJkczogd2hlbiBzb2Z0d2FyZSBhY2Nlc3MgaXMgZW5hYmxlZCwKPiAtICogdGhlIGNyZWF0b3Ig b2YgdGhlIGZlbmNlIGlzIHJlcXVpcmVkIHRvIGtlZXAgdGhlIGZlbmNlIGFsaXZlIHVudGlsCj4g LSAqIGFmdGVyIGl0IHNpZ25hbHMgd2l0aCBkbWFfZmVuY2Vfc2lnbmFsLiBUaGUgY2FsbGJhY2sg aXRzZWxmIGNhbiBiZSBjYWxsZWQKPiAtICogZnJvbSBpcnEgY29udGV4dC4KPiArICogcmVmY291 bnQgYXMgaXQgZG9lcyB0byBkbWFfZmVuY2Vfd2FpdCgpLCBob3dldmVyIHRoZSBjYWxsZXIgZG9l c24ndCBuZWVkIHRvCj4gKyAqIGtlZXAgYSByZWZjb3VudCB0byBmZW5jZSBhZnRlcndhcmQgZG1h X2ZlbmNlX2FkZF9jYWxsYmFjaygpIGhhcyByZXR1cm5lZDoKPiArICogd2hlbiBzb2Z0d2FyZSBh Y2Nlc3MgaXMgZW5hYmxlZCwgdGhlIGNyZWF0b3Igb2YgdGhlIGZlbmNlIGlzIHJlcXVpcmVkIHRv IGtlZXAKPiArICogdGhlIGZlbmNlIGFsaXZlIHVudGlsIGFmdGVyIGl0IHNpZ25hbHMgd2l0aCBk bWFfZmVuY2Vfc2lnbmFsKCkuIFRoZSBjYWxsYmFjawo+ICsgKiBpdHNlbGYgY2FuIGJlIGNhbGxl ZCBmcm9tIGlycSBjb250ZXh0Lgo+ICAgICoKPiAgICAqIFJldHVybnMgMCBpbiBjYXNlIG9mIHN1 Y2Nlc3MsIC1FTk9FTlQgaWYgdGhlIGZlbmNlIGlzIGFscmVhZHkgc2lnbmFsZWQKPiAgICAqIGFu ZCAtRUlOVkFMIGluIGNhc2Ugb2YgZXJyb3IuCj4gQEAgLTI4Niw3ICszNDEsNyBAQCBFWFBPUlRf U1lNQk9MKGRtYV9mZW5jZV9hZGRfY2FsbGJhY2spOwo+ICAgCj4gICAvKioKPiAgICAqIGRtYV9m ZW5jZV9nZXRfc3RhdHVzIC0gcmV0dXJucyB0aGUgc3RhdHVzIHVwb24gY29tcGxldGlvbgo+IC0g KiBAZmVuY2U6IFtpbl0JdGhlIGRtYV9mZW5jZSB0byBxdWVyeQo+ICsgKiBAZmVuY2U6IHRoZSBk bWFfZmVuY2UgdG8gcXVlcnkKPiAgICAqCj4gICAgKiBUaGlzIHdyYXBzIGRtYV9mZW5jZV9nZXRf c3RhdHVzX2xvY2tlZCgpIHRvIHJldHVybiB0aGUgZXJyb3Igc3RhdHVzCj4gICAgKiBjb25kaXRp b24gb24gYSBzaWduYWxlZCBmZW5jZS4gU2VlIGRtYV9mZW5jZV9nZXRfc3RhdHVzX2xvY2tlZCgp IGZvciBtb3JlCj4gQEAgLTMxMSw4ICszNjYsOCBAQCBFWFBPUlRfU1lNQk9MKGRtYV9mZW5jZV9n ZXRfc3RhdHVzKTsKPiAgIAo+ICAgLyoqCj4gICAgKiBkbWFfZmVuY2VfcmVtb3ZlX2NhbGxiYWNr IC0gcmVtb3ZlIGEgY2FsbGJhY2sgZnJvbSB0aGUgc2lnbmFsaW5nIGxpc3QKPiAtICogQGZlbmNl OglbaW5dCXRoZSBmZW5jZSB0byB3YWl0IG9uCj4gLSAqIEBjYjoJCVtpbl0JdGhlIGNhbGxiYWNr IHRvIHJlbW92ZQo+ICsgKiBAZmVuY2U6IHRoZSBmZW5jZSB0byB3YWl0IG9uCj4gKyAqIEBjYjog dGhlIGNhbGxiYWNrIHRvIHJlbW92ZQo+ICAgICoKPiAgICAqIFJlbW92ZSBhIHByZXZpb3VzbHkg cXVldWVkIGNhbGxiYWNrIGZyb20gdGhlIGZlbmNlLiBUaGlzIGZ1bmN0aW9uIHJldHVybnMKPiAg ICAqIHRydWUgaWYgdGhlIGNhbGxiYWNrIGlzIHN1Y2Nlc3NmdWxseSByZW1vdmVkLCBvciBmYWxz ZSBpZiB0aGUgZmVuY2UgaGFzCj4gQEAgLTMyMyw2ICszNzgsOSBAQCBFWFBPUlRfU1lNQk9MKGRt YV9mZW5jZV9nZXRfc3RhdHVzKTsKPiAgICAqIGRvaW5nLCBzaW5jZSBkZWFkbG9ja3MgYW5kIHJh Y2UgY29uZGl0aW9ucyBjb3VsZCBvY2N1ciBhbGwgdG9vIGVhc2lseS4gRm9yCj4gICAgKiB0aGlz IHJlYXNvbiwgaXQgc2hvdWxkIG9ubHkgZXZlciBiZSBkb25lIG9uIGhhcmR3YXJlIGxvY2t1cCBy ZWNvdmVyeSwKPiAgICAqIHdpdGggYSByZWZlcmVuY2UgaGVsZCB0byB0aGUgZmVuY2UuCj4gKyAq Cj4gKyAqIEJlaGF2aW91ciBpcyB1bmRlZmluZWQgaWYgQGNiIGhhcyBub3QgYmVlbiBhZGRlZCB0 byBAZmVuY2UgdXNpbmcKPiArICogZG1hX2ZlbmNlX2FkZF9jYWxsYmFjaygpIGJlZm9yZWhhbmQu Cj4gICAgKi8KPiAgIGJvb2wKPiAgIGRtYV9mZW5jZV9yZW1vdmVfY2FsbGJhY2soc3RydWN0IGRt YV9mZW5jZSAqZmVuY2UsIHN0cnVjdCBkbWFfZmVuY2VfY2IgKmNiKQo+IEBAIC0zNTksOSArNDE3 LDkgQEAgZG1hX2ZlbmNlX2RlZmF1bHRfd2FpdF9jYihzdHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSwg c3RydWN0IGRtYV9mZW5jZV9jYiAqY2IpCj4gICAvKioKPiAgICAqIGRtYV9mZW5jZV9kZWZhdWx0 X3dhaXQgLSBkZWZhdWx0IHNsZWVwIHVudGlsIHRoZSBmZW5jZSBnZXRzIHNpZ25hbGVkCj4gICAg KiBvciB1bnRpbCB0aW1lb3V0IGVsYXBzZXMKPiAtICogQGZlbmNlOglbaW5dCXRoZSBmZW5jZSB0 byB3YWl0IG9uCj4gLSAqIEBpbnRyOglbaW5dCWlmIHRydWUsIGRvIGFuIGludGVycnVwdGlibGUg d2FpdAo+IC0gKiBAdGltZW91dDoJW2luXQl0aW1lb3V0IHZhbHVlIGluIGppZmZpZXMsIG9yIE1B WF9TQ0hFRFVMRV9USU1FT1VUCj4gKyAqIEBmZW5jZTogdGhlIGZlbmNlIHRvIHdhaXQgb24KPiAr ICogQGludHI6IGlmIHRydWUsIGRvIGFuIGludGVycnVwdGlibGUgd2FpdAo+ICsgKiBAdGltZW91 dDogdGltZW91dCB2YWx1ZSBpbiBqaWZmaWVzLCBvciBNQVhfU0NIRURVTEVfVElNRU9VVAo+ICAg ICoKPiAgICAqIFJldHVybnMgLUVSRVNUQVJUU1lTIGlmIGludGVycnVwdGVkLCAwIGlmIHRoZSB3 YWl0IHRpbWVkIG91dCwgb3IgdGhlCj4gICAgKiByZW1haW5pbmcgdGltZW91dCBpbiBqaWZmaWVz IG9uIHN1Y2Nlc3MuIElmIHRpbWVvdXQgaXMgemVybyB0aGUgdmFsdWUgb25lIGlzCj4gQEAgLTQ1 NCwxMiArNTEyLDEyIEBAIGRtYV9mZW5jZV90ZXN0X3NpZ25hbGVkX2FueShzdHJ1Y3QgZG1hX2Zl bmNlICoqZmVuY2VzLCB1aW50MzJfdCBjb3VudCwKPiAgIC8qKgo+ICAgICogZG1hX2ZlbmNlX3dh aXRfYW55X3RpbWVvdXQgLSBzbGVlcCB1bnRpbCBhbnkgZmVuY2UgZ2V0cyBzaWduYWxlZAo+ICAg ICogb3IgdW50aWwgdGltZW91dCBlbGFwc2VzCj4gLSAqIEBmZW5jZXM6CVtpbl0JYXJyYXkgb2Yg ZmVuY2VzIHRvIHdhaXQgb24KPiAtICogQGNvdW50OglbaW5dCW51bWJlciBvZiBmZW5jZXMgdG8g d2FpdCBvbgo+IC0gKiBAaW50cjoJW2luXQlpZiB0cnVlLCBkbyBhbiBpbnRlcnJ1cHRpYmxlIHdh aXQKPiAtICogQHRpbWVvdXQ6CVtpbl0JdGltZW91dCB2YWx1ZSBpbiBqaWZmaWVzLCBvciBNQVhf U0NIRURVTEVfVElNRU9VVAo+IC0gKiBAaWR4OiAgICAgICBbb3V0XQl0aGUgZmlyc3Qgc2lnbmFs ZWQgZmVuY2UgaW5kZXgsIG1lYW5pbmdmdWwgb25seSBvbgo+IC0gKgkJCXBvc2l0aXZlIHJldHVy bgo+ICsgKiBAZmVuY2VzOiBhcnJheSBvZiBmZW5jZXMgdG8gd2FpdCBvbgo+ICsgKiBAY291bnQ6 IG51bWJlciBvZiBmZW5jZXMgdG8gd2FpdCBvbgo+ICsgKiBAaW50cjogaWYgdHJ1ZSwgZG8gYW4g aW50ZXJydXB0aWJsZSB3YWl0Cj4gKyAqIEB0aW1lb3V0OiB0aW1lb3V0IHZhbHVlIGluIGppZmZp ZXMsIG9yIE1BWF9TQ0hFRFVMRV9USU1FT1VUCj4gKyAqIEBpZHg6IHVzZWQgdG8gc3RvcmUgdGhl IGZpcnN0IHNpZ25hbGVkIGZlbmNlIGluZGV4LCBtZWFuaW5nZnVsIG9ubHkgb24KPiArICoJcG9z aXRpdmUgcmV0dXJuCj4gICAgKgo+ICAgICogUmV0dXJucyAtRUlOVkFMIG9uIGN1c3RvbSBmZW5j ZSB3YWl0IGltcGxlbWVudGF0aW9uLCAtRVJFU1RBUlRTWVMgaWYKPiAgICAqIGludGVycnVwdGVk LCAwIGlmIHRoZSB3YWl0IHRpbWVkIG91dCwgb3IgdGhlIHJlbWFpbmluZyB0aW1lb3V0IGluIGpp ZmZpZXMKPiBAQCAtNDY4LDYgKzUyNiw4IEBAIGRtYV9mZW5jZV90ZXN0X3NpZ25hbGVkX2FueShz dHJ1Y3QgZG1hX2ZlbmNlICoqZmVuY2VzLCB1aW50MzJfdCBjb3VudCwKPiAgICAqIFN5bmNocm9u b3VzIHdhaXRzIGZvciB0aGUgZmlyc3QgZmVuY2UgaW4gdGhlIGFycmF5IHRvIGJlIHNpZ25hbGVk LiBUaGUKPiAgICAqIGNhbGxlciBuZWVkcyB0byBob2xkIGEgcmVmZXJlbmNlIHRvIGFsbCBmZW5j ZXMgaW4gdGhlIGFycmF5LCBvdGhlcndpc2UgYQo+ICAgICogZmVuY2UgbWlnaHQgYmUgZnJlZWQg YmVmb3JlIHJldHVybiwgcmVzdWx0aW5nIGluIHVuZGVmaW5lZCBiZWhhdmlvci4KPiArICoKPiAr ICogU2VlIGFsc28gZG1hX2ZlbmNlX3dhaXQoKSBhbmQgZG1hX2ZlbmNlX3dhaXRfdGltZW91dCgp Lgo+ICAgICovCj4gICBzaWduZWQgbG9uZwo+ICAgZG1hX2ZlbmNlX3dhaXRfYW55X3RpbWVvdXQo c3RydWN0IGRtYV9mZW5jZSAqKmZlbmNlcywgdWludDMyX3QgY291bnQsCj4gQEAgLTU0MCwxOSAr NjAwLDE4IEBAIEVYUE9SVF9TWU1CT0woZG1hX2ZlbmNlX3dhaXRfYW55X3RpbWVvdXQpOwo+ICAg Cj4gICAvKioKPiAgICAqIGRtYV9mZW5jZV9pbml0IC0gSW5pdGlhbGl6ZSBhIGN1c3RvbSBmZW5j ZS4KPiAtICogQGZlbmNlOglbaW5dCXRoZSBmZW5jZSB0byBpbml0aWFsaXplCj4gLSAqIEBvcHM6 CVtpbl0JdGhlIGRtYV9mZW5jZV9vcHMgZm9yIG9wZXJhdGlvbnMgb24gdGhpcyBmZW5jZQo+IC0g KiBAbG9jazoJW2luXQl0aGUgaXJxc2FmZSBzcGlubG9jayB0byB1c2UgZm9yIGxvY2tpbmcgdGhp cyBmZW5jZQo+IC0gKiBAY29udGV4dDoJW2luXQl0aGUgZXhlY3V0aW9uIGNvbnRleHQgdGhpcyBm ZW5jZSBpcyBydW4gb24KPiAtICogQHNlcW5vOglbaW5dCWEgbGluZWFyIGluY3JlYXNpbmcgc2Vx dWVuY2UgbnVtYmVyIGZvciB0aGlzIGNvbnRleHQKPiArICogQGZlbmNlOiB0aGUgZmVuY2UgdG8g aW5pdGlhbGl6ZQo+ICsgKiBAb3BzOiB0aGUgZG1hX2ZlbmNlX29wcyBmb3Igb3BlcmF0aW9ucyBv biB0aGlzIGZlbmNlCj4gKyAqIEBsb2NrOiB0aGUgaXJxc2FmZSBzcGlubG9jayB0byB1c2UgZm9y IGxvY2tpbmcgdGhpcyBmZW5jZQo+ICsgKiBAY29udGV4dDogdGhlIGV4ZWN1dGlvbiBjb250ZXh0 IHRoaXMgZmVuY2UgaXMgcnVuIG9uCj4gKyAqIEBzZXFubzogYSBsaW5lYXIgaW5jcmVhc2luZyBz ZXF1ZW5jZSBudW1iZXIgZm9yIHRoaXMgY29udGV4dAo+ICAgICoKPiAgICAqIEluaXRpYWxpemVz IGFuIGFsbG9jYXRlZCBmZW5jZSwgdGhlIGNhbGxlciBkb2Vzbid0IGhhdmUgdG8ga2VlcCBpdHMK PiAgICAqIHJlZmNvdW50IGFmdGVyIGNvbW1pdHRpbmcgd2l0aCB0aGlzIGZlbmNlLCBidXQgaXQg d2lsbCBuZWVkIHRvIGhvbGQgYQo+IC0gKiByZWZjb3VudCBhZ2FpbiBpZiBkbWFfZmVuY2Vfb3Bz LmVuYWJsZV9zaWduYWxpbmcgZ2V0cyBjYWxsZWQuIFRoaXMgY2FuCj4gLSAqIGJlIHVzZWQgZm9y IG90aGVyIGltcGxlbWVudGluZyBvdGhlciB0eXBlcyBvZiBmZW5jZS4KPiArICogcmVmY291bnQg YWdhaW4gaWYgJmRtYV9mZW5jZV9vcHMuZW5hYmxlX3NpZ25hbGluZyBnZXRzIGNhbGxlZC4KPiAg ICAqCj4gICAgKiBjb250ZXh0IGFuZCBzZXFubyBhcmUgdXNlZCBmb3IgZWFzeSBjb21wYXJpc29u IGJldHdlZW4gZmVuY2VzLCBhbGxvd2luZwo+IC0gKiB0byBjaGVjayB3aGljaCBmZW5jZSBpcyBs YXRlciBieSBzaW1wbHkgdXNpbmcgZG1hX2ZlbmNlX2xhdGVyLgo+ICsgKiB0byBjaGVjayB3aGlj aCBmZW5jZSBpcyBsYXRlciBieSBzaW1wbHkgdXNpbmcgZG1hX2ZlbmNlX2xhdGVyKCkuCj4gICAg Ki8KPiAgIHZvaWQKPiAgIGRtYV9mZW5jZV9pbml0KHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlLCBj b25zdCBzdHJ1Y3QgZG1hX2ZlbmNlX29wcyAqb3BzLAoKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxA bGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxt YW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-wm0-f66.google.com ([74.125.82.66]:36507 "EHLO mail-wm0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752878AbeGDJg3 (ORCPT ); Wed, 4 Jul 2018 05:36:29 -0400 Received: by mail-wm0-f66.google.com with SMTP id s14-v6so5021391wmc.1 for ; Wed, 04 Jul 2018 02:36:29 -0700 (PDT) Reply-To: christian.koenig@amd.com Subject: Re: [PATCH 5/5] dma-fence: Polish kernel-doc for dma-fence.c To: Daniel Vetter , DRI Development Cc: Intel Graphics Development , linaro-mm-sig@lists.linaro.org, linux-media@vger.kernel.org References: <20180704092909.6599-1-daniel.vetter@ffwll.ch> <20180704092909.6599-6-daniel.vetter@ffwll.ch> From: =?UTF-8?Q?Christian_K=c3=b6nig?= Message-ID: <14cbffca-b274-a190-a7e8-243d1225927e@gmail.com> Date: Wed, 4 Jul 2018 11:36:26 +0200 MIME-Version: 1.0 In-Reply-To: <20180704092909.6599-6-daniel.vetter@ffwll.ch> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US Sender: linux-media-owner@vger.kernel.org List-ID: Am 04.07.2018 um 11:29 schrieb Daniel Vetter: > - Intro section that links to how this is exposed to userspace. > - Lots more hyperlinks. > - Minor clarifications and style polish > > v2: Add misplaced hunk of kerneldoc from a different patch. > > Signed-off-by: Daniel Vetter > Cc: Sumit Semwal > Cc: Gustavo Padovan > Cc: linux-media@vger.kernel.org > Cc: linaro-mm-sig@lists.linaro.org Reviewed-by: Christian König > --- > Documentation/driver-api/dma-buf.rst | 6 ++ > drivers/dma-buf/dma-fence.c | 147 +++++++++++++++++++-------- > 2 files changed, 109 insertions(+), 44 deletions(-) > > diff --git a/Documentation/driver-api/dma-buf.rst b/Documentation/driver-api/dma-buf.rst > index dc384f2f7f34..b541e97c7ab1 100644 > --- a/Documentation/driver-api/dma-buf.rst > +++ b/Documentation/driver-api/dma-buf.rst > @@ -130,6 +130,12 @@ Reservation Objects > DMA Fences > ---------- > > +.. kernel-doc:: drivers/dma-buf/dma-fence.c > + :doc: DMA fences overview > + > +DMA Fences Functions Reference > +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ > + > .. kernel-doc:: drivers/dma-buf/dma-fence.c > :export: > > diff --git a/drivers/dma-buf/dma-fence.c b/drivers/dma-buf/dma-fence.c > index 7a92f85a4cec..1551ca7df394 100644 > --- a/drivers/dma-buf/dma-fence.c > +++ b/drivers/dma-buf/dma-fence.c > @@ -38,12 +38,43 @@ EXPORT_TRACEPOINT_SYMBOL(dma_fence_enable_signal); > */ > static atomic64_t dma_fence_context_counter = ATOMIC64_INIT(0); > > +/** > + * DOC: DMA fences overview > + * > + * DMA fences, represented by &struct dma_fence, are the kernel internal > + * synchronization primitive for DMA operations like GPU rendering, video > + * encoding/decoding, or displaying buffers on a screen. > + * > + * A fence is initialized using dma_fence_init() and completed using > + * dma_fence_signal(). Fences are associated with a context, allocated through > + * dma_fence_context_alloc(), and all fences on the same context are > + * fully ordered. > + * > + * Since the purposes of fences is to facilitate cross-device and > + * cross-application synchronization, there's multiple ways to use one: > + * > + * - Individual fences can be exposed as a &sync_file, accessed as a file > + * descriptor from userspace, created by calling sync_file_create(). This is > + * called explicit fencing, since userspace passes around explicit > + * synchronization points. > + * > + * - Some subsystems also have their own explicit fencing primitives, like > + * &drm_syncobj. Compared to &sync_file, a &drm_syncobj allows the underlying > + * fence to be updated. > + * > + * - Then there's also implicit fencing, where the synchronization points are > + * implicitly passed around as part of shared &dma_buf instances. Such > + * implicit fences are stored in &struct reservation_object through the > + * &dma_buf.resv pointer. > + */ > + > /** > * dma_fence_context_alloc - allocate an array of fence contexts > - * @num: [in] amount of contexts to allocate > + * @num: amount of contexts to allocate > * > - * This function will return the first index of the number of fences allocated. > - * The fence context is used for setting fence->context to a unique number. > + * This function will return the first index of the number of fence contexts > + * allocated. The fence context is used for setting &dma_fence.context to a > + * unique number by passing the context to dma_fence_init(). > */ > u64 dma_fence_context_alloc(unsigned num) > { > @@ -59,10 +90,14 @@ EXPORT_SYMBOL(dma_fence_context_alloc); > * Signal completion for software callbacks on a fence, this will unblock > * dma_fence_wait() calls and run all the callbacks added with > * dma_fence_add_callback(). Can be called multiple times, but since a fence > - * can only go from unsignaled to signaled state, it will only be effective > - * the first time. > + * can only go from the unsignaled to the signaled state and not back, it will > + * only be effective the first time. > + * > + * Unlike dma_fence_signal(), this function must be called with &dma_fence.lock > + * held. > * > - * Unlike dma_fence_signal, this function must be called with fence->lock held. > + * Returns 0 on success and a negative error value when @fence has been > + * signalled already. > */ > int dma_fence_signal_locked(struct dma_fence *fence) > { > @@ -102,8 +137,11 @@ EXPORT_SYMBOL(dma_fence_signal_locked); > * Signal completion for software callbacks on a fence, this will unblock > * dma_fence_wait() calls and run all the callbacks added with > * dma_fence_add_callback(). Can be called multiple times, but since a fence > - * can only go from unsignaled to signaled state, it will only be effective > - * the first time. > + * can only go from the unsignaled to the signaled state and not back, it will > + * only be effective the first time. > + * > + * Returns 0 on success and a negative error value when @fence has been > + * signalled already. > */ > int dma_fence_signal(struct dma_fence *fence) > { > @@ -136,9 +174,9 @@ EXPORT_SYMBOL(dma_fence_signal); > /** > * dma_fence_wait_timeout - sleep until the fence gets signaled > * or until timeout elapses > - * @fence: [in] the fence to wait on > - * @intr: [in] if true, do an interruptible wait > - * @timeout: [in] timeout value in jiffies, or MAX_SCHEDULE_TIMEOUT > + * @fence: the fence to wait on > + * @intr: if true, do an interruptible wait > + * @timeout: timeout value in jiffies, or MAX_SCHEDULE_TIMEOUT > * > * Returns -ERESTARTSYS if interrupted, 0 if the wait timed out, or the > * remaining timeout in jiffies on success. Other error values may be > @@ -148,6 +186,8 @@ EXPORT_SYMBOL(dma_fence_signal); > * directly or indirectly (buf-mgr between reservation and committing) > * holds a reference to the fence, otherwise the fence might be > * freed before return, resulting in undefined behavior. > + * > + * See also dma_fence_wait() and dma_fence_wait_any_timeout(). > */ > signed long > dma_fence_wait_timeout(struct dma_fence *fence, bool intr, signed long timeout) > @@ -167,6 +207,13 @@ dma_fence_wait_timeout(struct dma_fence *fence, bool intr, signed long timeout) > } > EXPORT_SYMBOL(dma_fence_wait_timeout); > > +/** > + * dma_fence_release - default relese function for fences > + * @kref: &dma_fence.recfount > + * > + * This is the default release functions for &dma_fence. Drivers shouldn't call > + * this directly, but instead call dma_fence_put(). > + */ > void dma_fence_release(struct kref *kref) > { > struct dma_fence *fence = > @@ -184,6 +231,13 @@ void dma_fence_release(struct kref *kref) > } > EXPORT_SYMBOL(dma_fence_release); > > +/** > + * dma_fence_free - default release function for &dma_fence. > + * @fence: fence to release > + * > + * This is the default implementation for &dma_fence_ops.release. It calls > + * kfree_rcu() on @fence. > + */ > void dma_fence_free(struct dma_fence *fence) > { > kfree_rcu(fence, rcu); > @@ -192,10 +246,11 @@ EXPORT_SYMBOL(dma_fence_free); > > /** > * dma_fence_enable_sw_signaling - enable signaling on fence > - * @fence: [in] the fence to enable > + * @fence: the fence to enable > * > - * this will request for sw signaling to be enabled, to make the fence > - * complete as soon as possible > + * This will request for sw signaling to be enabled, to make the fence > + * complete as soon as possible. This calls &dma_fence_ops.enable_signaling > + * internally. > */ > void dma_fence_enable_sw_signaling(struct dma_fence *fence) > { > @@ -220,24 +275,24 @@ EXPORT_SYMBOL(dma_fence_enable_sw_signaling); > /** > * dma_fence_add_callback - add a callback to be called when the fence > * is signaled > - * @fence: [in] the fence to wait on > - * @cb: [in] the callback to register > - * @func: [in] the function to call > + * @fence: the fence to wait on > + * @cb: the callback to register > + * @func: the function to call > * > - * cb will be initialized by dma_fence_add_callback, no initialization > + * @cb will be initialized by dma_fence_add_callback(), no initialization > * by the caller is required. Any number of callbacks can be registered > * to a fence, but a callback can only be registered to one fence at a time. > * > * Note that the callback can be called from an atomic context. If > * fence is already signaled, this function will return -ENOENT (and > - * *not* call the callback) > + * *not* call the callback). > * > * Add a software callback to the fence. Same restrictions apply to > - * refcount as it does to dma_fence_wait, however the caller doesn't need to > - * keep a refcount to fence afterwards: when software access is enabled, > - * the creator of the fence is required to keep the fence alive until > - * after it signals with dma_fence_signal. The callback itself can be called > - * from irq context. > + * refcount as it does to dma_fence_wait(), however the caller doesn't need to > + * keep a refcount to fence afterward dma_fence_add_callback() has returned: > + * when software access is enabled, the creator of the fence is required to keep > + * the fence alive until after it signals with dma_fence_signal(). The callback > + * itself can be called from irq context. > * > * Returns 0 in case of success, -ENOENT if the fence is already signaled > * and -EINVAL in case of error. > @@ -286,7 +341,7 @@ EXPORT_SYMBOL(dma_fence_add_callback); > > /** > * dma_fence_get_status - returns the status upon completion > - * @fence: [in] the dma_fence to query > + * @fence: the dma_fence to query > * > * This wraps dma_fence_get_status_locked() to return the error status > * condition on a signaled fence. See dma_fence_get_status_locked() for more > @@ -311,8 +366,8 @@ EXPORT_SYMBOL(dma_fence_get_status); > > /** > * dma_fence_remove_callback - remove a callback from the signaling list > - * @fence: [in] the fence to wait on > - * @cb: [in] the callback to remove > + * @fence: the fence to wait on > + * @cb: the callback to remove > * > * Remove a previously queued callback from the fence. This function returns > * true if the callback is successfully removed, or false if the fence has > @@ -323,6 +378,9 @@ EXPORT_SYMBOL(dma_fence_get_status); > * doing, since deadlocks and race conditions could occur all too easily. For > * this reason, it should only ever be done on hardware lockup recovery, > * with a reference held to the fence. > + * > + * Behaviour is undefined if @cb has not been added to @fence using > + * dma_fence_add_callback() beforehand. > */ > bool > dma_fence_remove_callback(struct dma_fence *fence, struct dma_fence_cb *cb) > @@ -359,9 +417,9 @@ dma_fence_default_wait_cb(struct dma_fence *fence, struct dma_fence_cb *cb) > /** > * dma_fence_default_wait - default sleep until the fence gets signaled > * or until timeout elapses > - * @fence: [in] the fence to wait on > - * @intr: [in] if true, do an interruptible wait > - * @timeout: [in] timeout value in jiffies, or MAX_SCHEDULE_TIMEOUT > + * @fence: the fence to wait on > + * @intr: if true, do an interruptible wait > + * @timeout: timeout value in jiffies, or MAX_SCHEDULE_TIMEOUT > * > * Returns -ERESTARTSYS if interrupted, 0 if the wait timed out, or the > * remaining timeout in jiffies on success. If timeout is zero the value one is > @@ -454,12 +512,12 @@ dma_fence_test_signaled_any(struct dma_fence **fences, uint32_t count, > /** > * dma_fence_wait_any_timeout - sleep until any fence gets signaled > * or until timeout elapses > - * @fences: [in] array of fences to wait on > - * @count: [in] number of fences to wait on > - * @intr: [in] if true, do an interruptible wait > - * @timeout: [in] timeout value in jiffies, or MAX_SCHEDULE_TIMEOUT > - * @idx: [out] the first signaled fence index, meaningful only on > - * positive return > + * @fences: array of fences to wait on > + * @count: number of fences to wait on > + * @intr: if true, do an interruptible wait > + * @timeout: timeout value in jiffies, or MAX_SCHEDULE_TIMEOUT > + * @idx: used to store the first signaled fence index, meaningful only on > + * positive return > * > * Returns -EINVAL on custom fence wait implementation, -ERESTARTSYS if > * interrupted, 0 if the wait timed out, or the remaining timeout in jiffies > @@ -468,6 +526,8 @@ dma_fence_test_signaled_any(struct dma_fence **fences, uint32_t count, > * Synchronous waits for the first fence in the array to be signaled. The > * caller needs to hold a reference to all fences in the array, otherwise a > * fence might be freed before return, resulting in undefined behavior. > + * > + * See also dma_fence_wait() and dma_fence_wait_timeout(). > */ > signed long > dma_fence_wait_any_timeout(struct dma_fence **fences, uint32_t count, > @@ -540,19 +600,18 @@ EXPORT_SYMBOL(dma_fence_wait_any_timeout); > > /** > * dma_fence_init - Initialize a custom fence. > - * @fence: [in] the fence to initialize > - * @ops: [in] the dma_fence_ops for operations on this fence > - * @lock: [in] the irqsafe spinlock to use for locking this fence > - * @context: [in] the execution context this fence is run on > - * @seqno: [in] a linear increasing sequence number for this context > + * @fence: the fence to initialize > + * @ops: the dma_fence_ops for operations on this fence > + * @lock: the irqsafe spinlock to use for locking this fence > + * @context: the execution context this fence is run on > + * @seqno: a linear increasing sequence number for this context > * > * Initializes an allocated fence, the caller doesn't have to keep its > * refcount after committing with this fence, but it will need to hold a > - * refcount again if dma_fence_ops.enable_signaling gets called. This can > - * be used for other implementing other types of fence. > + * refcount again if &dma_fence_ops.enable_signaling gets called. > * > * context and seqno are used for easy comparison between fences, allowing > - * to check which fence is later by simply using dma_fence_later. > + * to check which fence is later by simply using dma_fence_later(). > */ > void > dma_fence_init(struct dma_fence *fence, const struct dma_fence_ops *ops,