From mboxrd@z Thu Jan 1 00:00:00 1970 From: Archit Taneja Subject: Re: [PATCH] drm/msm/mdp5: release SMB(shared memory blocks) in various cases Date: Mon, 22 Jun 2015 16:04:31 +0530 Message-ID: <5587E4B7.9080004@codeaurora.org> References: <1434737022-23591-1-git-send-email-wentaox@codeaurora.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1434737022-23591-1-git-send-email-wentaox@codeaurora.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Wentao Xu , dri-devel@lists.freedesktop.org Cc: linux-arm-msm@vger.kernel.org, linux-kernel@vger.kernel.org List-Id: linux-arm-msm@vger.kernel.org Ck9uIDA2LzE5LzIwMTUgMTE6MzMgUE0sIFdlbnRhbyBYdSB3cm90ZToKPiBSZWxlYXNlIGFsbCBi bG9ja3MgYWZ0ZXIgdGhlIHBpcGUgaXMgZGlzYWJsZWQsIGV2ZW4gd2hlbiB2c3luYwo+IGRpZG4n dCBoYXBwZW4gaW4gc29tZSBlcnJvciBjYXNlcy4gQWxsb3cgcmVxdWVzdGluZyBTTUIgbXVsdGlw bGUKPiB0aW1lcyBiZWZvcmUgY29uZmlndXJpbmcgdG8gaGFyZHdhcmUsIGJ5IHJlbGVhc2luZyBi bG9ja3Mgbm90Cj4gcHJvZ3JhbW1lZCB0byBoYXJkd2FyZSB5ZXQgZm9yIHNocmlua2luZyBjYXNl LgoKVGVzdGVkLWJ5OiBBcmNoaXQgVGFuZWphIDxhcmNoaXR0QGNvZGVhdXJvcmEub3JnPgoKPgo+ IFNpZ25lZC1vZmYtYnk6IFdlbnRhbyBYdSA8d2VudGFveEBjb2RlYXVyb3JhLm9yZz4KPiAtLS0K PiAgIGRyaXZlcnMvZ3B1L2RybS9tc20vbWRwL21kcDUvbWRwNV9rbXMuYyAgIHwgMTMgKysrKysK PiAgIGRyaXZlcnMvZ3B1L2RybS9tc20vbWRwL21kcDUvbWRwNV9rbXMuaCAgIHwgIDIgKwo+ICAg ZHJpdmVycy9ncHUvZHJtL21zbS9tZHAvbWRwNS9tZHA1X3BsYW5lLmMgfCAzMyArKysrKy0tLS0t LS0KPiAgIGRyaXZlcnMvZ3B1L2RybS9tc20vbWRwL21kcDUvbWRwNV9zbXAuYyAgIHwgODcgKysr KysrKysrKysrKysrKysrKysrKysrKystLS0tLQo+ICAgZHJpdmVycy9ncHUvZHJtL21zbS9tZHAv bWRwNS9tZHA1X3NtcC5oICAgfCAgMSArCj4gICA1IGZpbGVzIGNoYW5nZWQsIDEwNCBpbnNlcnRp b25zKCspLCAzMiBkZWxldGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v bXNtL21kcC9tZHA1L21kcDVfa21zLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21kcC9tZHA1L21k cDVfa21zLmMKPiBpbmRleCA5NzIyNmExLi5kYjQ5ZWU4IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMv Z3B1L2RybS9tc20vbWRwL21kcDUvbWRwNV9rbXMuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9t c20vbWRwL21kcDUvbWRwNV9rbXMuYwo+IEBAIC03OCw3ICs3OCwyMCBAQCBzdGF0aWMgdm9pZCBt ZHA1X3ByZXBhcmVfY29tbWl0KHN0cnVjdCBtc21fa21zICprbXMsIHN0cnVjdCBkcm1fYXRvbWlj X3N0YXRlICpzdAo+Cj4gICBzdGF0aWMgdm9pZCBtZHA1X2NvbXBsZXRlX2NvbW1pdChzdHJ1Y3Qg bXNtX2ttcyAqa21zLCBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpCj4gICB7Cj4gKwlp bnQgaTsKPiAgIAlzdHJ1Y3QgbWRwNV9rbXMgKm1kcDVfa21zID0gdG9fbWRwNV9rbXModG9fbWRw X2ttcyhrbXMpKTsKPiArCWludCBucGxhbmVzID0gbWRwNV9rbXMtPmRldi0+bW9kZV9jb25maWcu bnVtX3RvdGFsX3BsYW5lOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBucGxhbmVzOyBpKyspIHsK PiArCQlzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSA9IHN0YXRlLT5wbGFuZXNbaV07Cj4gKwkJc3Ry dWN0IGRybV9wbGFuZV9zdGF0ZSAqcGxhbmVfc3RhdGUgPSBzdGF0ZS0+cGxhbmVfc3RhdGVzW2ld Owo+ICsKPiArCQlpZiAoIXBsYW5lKQo+ICsJCQljb250aW51ZTsKPiArCj4gKwkJbWRwNV9wbGFu ZV9jb21wbGV0ZV9jb21taXQocGxhbmUsIHBsYW5lX3N0YXRlKTsKPiArCX0KPiArCj4gICAJbWRw NV9kaXNhYmxlKG1kcDVfa21zKTsKPiAgIH0KPgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vbXNtL21kcC9tZHA1L21kcDVfa21zLmggYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21kcC9tZHA1 L21kcDVfa21zLmgKPiBpbmRleCAyYzBkZTE3Li40MmYyNzBiIDEwMDY0NAo+IC0tLSBhL2RyaXZl cnMvZ3B1L2RybS9tc20vbWRwL21kcDUvbWRwNV9rbXMuaAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9tc20vbWRwL21kcDUvbWRwNV9rbXMuaAo+IEBAIC0yMjcsNiArMjI3LDggQEAgdm9pZCBtZHA1 X3BsYW5lX2luc3RhbGxfcHJvcGVydGllcyhzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwKPiAgIAkJ c3RydWN0IGRybV9tb2RlX29iamVjdCAqb2JqKTsKPiAgIHVpbnQzMl90IG1kcDVfcGxhbmVfZ2V0 X2ZsdXNoKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lKTsKPiAgIHZvaWQgbWRwNV9wbGFuZV9jb21w bGV0ZV9mbGlwKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lKTsKPiArdm9pZCBtZHA1X3BsYW5lX2Nv bXBsZXRlX2NvbW1pdChzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwKPiArCXN0cnVjdCBkcm1fcGxh bmVfc3RhdGUgKnN0YXRlKTsKPiAgIGVudW0gbWRwNV9waXBlIG1kcDVfcGxhbmVfcGlwZShzdHJ1 Y3QgZHJtX3BsYW5lICpwbGFuZSk7Cj4gICBzdHJ1Y3QgZHJtX3BsYW5lICptZHA1X3BsYW5lX2lu aXQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKPiAgIAkJZW51bSBtZHA1X3BpcGUgcGlwZSwgYm9v bCBwcml2YXRlX3BsYW5lLCB1aW50MzJfdCByZWdfb2Zmc2V0KTsKPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL21zbS9tZHAvbWRwNS9tZHA1X3BsYW5lLmMgYi9kcml2ZXJzL2dwdS9kcm0v bXNtL21kcC9tZHA1L21kcDVfcGxhbmUuYwo+IGluZGV4IDE4YTNkMjAuLjA1YjI2MzQgMTAwNjQ0 Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9tZHAvbWRwNS9tZHA1X3BsYW5lLmMKPiArKysg Yi9kcml2ZXJzL2dwdS9kcm0vbXNtL21kcC9tZHA1L21kcDVfcGxhbmUuYwo+IEBAIC0zMSw4ICsz MSw2IEBAIHN0cnVjdCBtZHA1X3BsYW5lIHsKPgo+ICAgCXVpbnQzMl90IG5mb3JtYXRzOwo+ICAg CXVpbnQzMl90IGZvcm1hdHNbMzJdOwo+IC0KPiAtCWJvb2wgZW5hYmxlZDsKPiAgIH07Cj4gICAj ZGVmaW5lIHRvX21kcDVfcGxhbmUoeCkgY29udGFpbmVyX29mKHgsIHN0cnVjdCBtZHA1X3BsYW5l LCBiYXNlKQo+Cj4gQEAgLTU2LDIyICs1NCw2IEBAIHN0YXRpYyBib29sIHBsYW5lX2VuYWJsZWQo c3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqc3RhdGUpCj4gICAJcmV0dXJuIHN0YXRlLT5mYiAmJiBz dGF0ZS0+Y3J0YzsKPiAgIH0KPgo+IC1zdGF0aWMgaW50IG1kcDVfcGxhbmVfZGlzYWJsZShzdHJ1 Y3QgZHJtX3BsYW5lICpwbGFuZSkKPiAtewo+IC0Jc3RydWN0IG1kcDVfcGxhbmUgKm1kcDVfcGxh bmUgPSB0b19tZHA1X3BsYW5lKHBsYW5lKTsKPiAtCXN0cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXMg PSBnZXRfa21zKHBsYW5lKTsKPiAtCWVudW0gbWRwNV9waXBlIHBpcGUgPSBtZHA1X3BsYW5lLT5w aXBlOwo+IC0KPiAtCURCRygiJXM6IGRpc2FibGUiLCBtZHA1X3BsYW5lLT5uYW1lKTsKPiAtCj4g LQlpZiAobWRwNV9rbXMpIHsKPiAtCQkvKiBSZWxlYXNlIHRoZSBtZW1vcnkgd2UgcmVxdWVzdGVk IGVhcmxpZXIgZnJvbSB0aGUgU01QOiAqLwo+IC0JCW1kcDVfc21wX3JlbGVhc2UobWRwNV9rbXMt PnNtcCwgcGlwZSk7Cj4gLQl9Cj4gLQo+IC0JcmV0dXJuIDA7Cj4gLX0KPiAtCj4gICBzdGF0aWMg dm9pZCBtZHA1X3BsYW5lX2Rlc3Ryb3koc3RydWN0IGRybV9wbGFuZSAqcGxhbmUpCj4gICB7Cj4g ICAJc3RydWN0IG1kcDVfcGxhbmUgKm1kcDVfcGxhbmUgPSB0b19tZHA1X3BsYW5lKHBsYW5lKTsK PiBAQCAtMjI0LDcgKzIwNiw2IEBAIHN0YXRpYyB2b2lkIG1kcDVfcGxhbmVfYXRvbWljX3VwZGF0 ZShzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwKPgo+ICAgCWlmICghcGxhbmVfZW5hYmxlZChzdGF0 ZSkpIHsKPiAgIAkJdG9fbWRwNV9wbGFuZV9zdGF0ZShzdGF0ZSktPnBlbmRpbmcgPSB0cnVlOwo+ IC0JCW1kcDVfcGxhbmVfZGlzYWJsZShwbGFuZSk7Cj4gICAJfSBlbHNlIGlmICh0b19tZHA1X3Bs YW5lX3N0YXRlKHN0YXRlKS0+bW9kZV9jaGFuZ2VkKSB7Cj4gICAJCWludCByZXQ7Cj4gICAJCXRv X21kcDVfcGxhbmVfc3RhdGUoc3RhdGUpLT5wZW5kaW5nID0gdHJ1ZTsKPiBAQCAtNjAyLDYgKzU4 MywyMCBAQCB1aW50MzJfdCBtZHA1X3BsYW5lX2dldF9mbHVzaChzdHJ1Y3QgZHJtX3BsYW5lICpw bGFuZSkKPiAgIAlyZXR1cm4gbWRwNV9wbGFuZS0+Zmx1c2hfbWFzazsKPiAgIH0KPgo+ICsvKiBj YWxsZWQgYWZ0ZXIgdnN5bmMgaW4gdGhyZWFkIGNvbnRleHQgKi8KPiArdm9pZCBtZHA1X3BsYW5l X2NvbXBsZXRlX2NvbW1pdChzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwKPiArCXN0cnVjdCBkcm1f cGxhbmVfc3RhdGUgKnN0YXRlKQo+ICt7Cj4gKwlzdHJ1Y3QgbWRwNV9rbXMgKm1kcDVfa21zID0g Z2V0X2ttcyhwbGFuZSk7Cj4gKwlzdHJ1Y3QgbWRwNV9wbGFuZSAqbWRwNV9wbGFuZSA9IHRvX21k cDVfcGxhbmUocGxhbmUpOwo+ICsJZW51bSBtZHA1X3BpcGUgcGlwZSA9IG1kcDVfcGxhbmUtPnBp cGU7Cj4gKwo+ICsJaWYgKCFwbGFuZV9lbmFibGVkKHBsYW5lLT5zdGF0ZSkpIHsKPiArCQlEQkco IiVzOiBmcmVlIFNNUCIsIG1kcDVfcGxhbmUtPm5hbWUpOwo+ICsJCW1kcDVfc21wX3JlbGVhc2Uo bWRwNV9rbXMtPnNtcCwgcGlwZSk7Cj4gKwl9Cj4gK30KPiArCj4gICAvKiBpbml0aWFsaXplIHBs YW5lICovCj4gICBzdHJ1Y3QgZHJtX3BsYW5lICptZHA1X3BsYW5lX2luaXQoc3RydWN0IGRybV9k ZXZpY2UgKmRldiwKPiAgIAkJZW51bSBtZHA1X3BpcGUgcGlwZSwgYm9vbCBwcml2YXRlX3BsYW5l LCB1aW50MzJfdCByZWdfb2Zmc2V0KQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNt L21kcC9tZHA1L21kcDVfc21wLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21kcC9tZHA1L21kcDVf c21wLmMKPiBpbmRleCAxNjcwMmFlLi42NGEyN2Q4IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9tc20vbWRwL21kcDUvbWRwNV9zbXAuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20v bWRwL21kcDUvbWRwNV9zbXAuYwo+IEBAIC0zNCwyMiArMzQsNDQgQEAKPiAgICAqIGFuZCBDQU5O T1QgYmUgcmUtYWxsb2NhdGVkIChlZzogTU1CMCBhbmQgTU1CMSBib3RoIHRpZWQgdG8gUkdCMCku Cj4gICAgKgo+ICAgICogRm9yIGVhY2ggYmxvY2sgdGhhdCBjYW4gYmUgZHluYW1pY2FsbHkgYWxs b2NhdGVkLCBpdCBjYW4gYmUgZWl0aGVyCj4gLSAqIGZyZWUsIG9yIHBlbmRpbmcvaW4tdXNlIGJ5 IGEgY2xpZW50LiBUaGUgdXBkYXRlcyBoYXBwZW4gaW4gdGhyZWUgc3RlcHM6Cj4gKyAqICAgICBm cmVlOgo+ICsgKiAgICAgVGhlIGJsb2NrIGlzIGZyZWUuCj4gKyAqCj4gKyAqICAgICBwZW5kaW5n Ogo+ICsgKiAgICAgVGhlIGJsb2NrIGlzIGFsbG9jYXRlZCB0byBzb21lIGNsaWVudCBhbmQgbm90 IGZyZWUuCj4gKyAqCj4gKyAqICAgICBjb25maWd1cmVkOgo+ICsgKiAgICAgVGhlIGJsb2NrIGlz IGFsbG9jYXRlZCB0byBzb21lIGNsaWVudCwgYW5kIGFzc2lnbmVkIHRvIHRoYXQKPiArICogICAg IGNsaWVudCBpbiBNRFA1X01EUF9TTVBfQUxMT0MgcmVnaXN0ZXJzLgo+ICsgKgo+ICsgKiAgICAg aW51c2U6Cj4gKyAqICAgICBUaGUgYmxvY2sgaXMgYmVpbmcgYWN0aXZlbHkgdXNlZCBieSBhIGNs aWVudC4KPiArICoKPiArICogVGhlIHVwZGF0ZXMgaGFwcGVuIGluIHRoZSBmb2xsb3dpbmcgc3Rl cHM6Cj4gICAgKgo+ICAgICogIDEpIG1kcDVfc21wX3JlcXVlc3QoKToKPiAgICAqICAgICBXaGVu IHBsYW5lIHNjYW5vdXQgaXMgc2V0dXAsIGNhbGN1bGF0ZSByZXF1aXJlZCBudW1iZXIgb2YKPiAt ICogICAgIGJsb2NrcyBuZWVkZWQgcGVyIGNsaWVudCwgYW5kIHJlcXVlc3QuICBCbG9ja3Mgbm90 IGludXNlIG9yCj4gLSAqICAgICBwZW5kaW5nIGJ5IGFueSBvdGhlciBjbGllbnQgYXJlIGFkZGVk IHRvIGNsaWVudCdzIHBlbmRpbmcKPiAtICogICAgIHNldC4KPiArICogICAgIGJsb2NrcyBuZWVk ZWQgcGVyIGNsaWVudCwgYW5kIHJlcXVlc3QuIEJsb2NrcyBuZWl0aGVyIGludXNlIG5vcgo+ICsg KiAgICAgY29uZmlndXJlZCBub3IgcGVuZGluZyBieSBhbnkgb3RoZXIgY2xpZW50IGFyZSBhZGRl ZCB0byBjbGllbnQncwo+ICsgKiAgICAgcGVuZGluZyBzZXQuCj4gKyAqICAgICBGb3Igc2hyaW5r aW5nLCBibG9ja3MgaW4gcGVuZGluZyBidXQgbm90IGluIGNvbmZpZ3VyZWQgY2FuIGJlIGZyZWVk Cj4gKyAqICAgICBkaXJlY3RseSwgYnV0IHRob3NlIGFscmVhZHkgaW4gY29uZmlndXJlZCB3aWxs IGJlIGZyZWVkIGxhdGVyIGJ5Cj4gKyAqICAgICBtZHA1X3NtcF9jb21taXQuCj4gICAgKgo+ICAg ICogIDIpIG1kcDVfc21wX2NvbmZpZ3VyZSgpOgo+ICAgICogICAgIEFzIGh3IGlzIHByb2dyYW1t ZWQsIGJlZm9yZSBGTFVTSCwgTURQNV9NRFBfU01QX0FMTE9DIHJlZ2lzdGVycwo+ICAgICogICAg IGFyZSBjb25maWd1cmVkIGZvciB0aGUgdW5pb24ocGVuZGluZywgaW51c2UpCj4gKyAqICAgICBD dXJyZW50IHBlbmRpbmcgaXMgY29waWVkIHRvIGNvbmZpZ3VyZWQuCj4gKyAqICAgICBJdCBpcyBh c3N1bWVkIHRoYXQgbWRwNV9zbXBfcmVxdWVzdCBhbmQgbWRwNV9zbXBfY29uZmlndXJlIG5vdCBy dW4KPiArICogICAgIGNvbmN1cnJlbnRseSBmb3IgdGhlIHNhbWUgcGlwZS4KPiAgICAqCj4gICAg KiAgMykgbWRwNV9zbXBfY29tbWl0KCk6Cj4gLSAqICAgICBBZnRlciBuZXh0IHZibGFuaywgY29w eSBwZW5kaW5nIC0+IGludXNlLiAgT3B0aW9uYWxseSB1cGRhdGUKPiArICogICAgIEFmdGVyIG5l eHQgdmJsYW5rLCBjb3B5IGNvbmZpZ3VyZWQgLT4gaW51c2UuICBPcHRpb25hbGx5IHVwZGF0ZQo+ ICAgICogICAgIE1EUDVfU01QX0FMTE9DIHJlZ2lzdGVycyBpZiB0aGVyZSBhcmUgbmV3bHkgdW51 c2VkIGJsb2Nrcwo+ICAgICoKPiArICogIDQpIG1kcDVfc21wX3JlbGVhc2UoKToKPiArICogICAg IE11c3QgYmUgY2FsbGVkIGFmdGVyIHRoZSBwaXBlIGlzIGRpc2FibGVkIGFuZCBubyBsb25nZXIg dXNlcyBhbnkgU01CCj4gKyAqCj4gICAgKiBPbiB0aGUgbmV4dCB2YmxhbmsgYWZ0ZXIgY2hhbmdl cyBoYXZlIGJlZW4gY29tbWl0dGVkIHRvIGh3LCB0aGUKPiAgICAqIGNsaWVudCdzIHBlbmRpbmcg YmxvY2tzIGJlY29tZSBpdCdzIGluLXVzZSBibG9ja3MgKGFuZCBuby1sb25nZXIKPiAgICAqIGlu LXVzZSBibG9ja3MgYmVjb21lIGF2YWlsYWJsZSB0byBvdGhlciBjbGllbnRzKS4KPiBAQCAtNzcs NiArOTksOSBAQCBzdHJ1Y3QgbWRwNV9zbXAgewo+ICAgCXN0cnVjdCBtZHA1X2NsaWVudF9zbXBf c3RhdGUgY2xpZW50X3N0YXRlW01BWF9DTElFTlRTXTsKPiAgIH07Cj4KPiArc3RhdGljIHZvaWQg dXBkYXRlX3NtcF9zdGF0ZShzdHJ1Y3QgbWRwNV9zbXAgKnNtcCwKPiArCQl1MzIgY2lkLCBtZHA1 X3NtcF9zdGF0ZV90ICphc3NpZ25lZCk7Cj4gKwo+ICAgc3RhdGljIGlubGluZQo+ICAgc3RydWN0 IG1kcDVfa21zICpnZXRfa21zKHN0cnVjdCBtZHA1X3NtcCAqc21wKQo+ICAgewo+IEBAIC0xNDks NyArMTc0LDEyIEBAIHN0YXRpYyBpbnQgc21wX3JlcXVlc3RfYmxvY2soc3RydWN0IG1kcDVfc21w ICpzbXAsCj4gICAJCWZvciAoaSA9IGN1cl9uYmxrczsgaSA+IG5ibGtzOyBpLS0pIHsKPiAgIAkJ CWludCBibGsgPSBmaW5kX2ZpcnN0X2JpdChwcy0+cGVuZGluZywgY250KTsKPiAgIAkJCWNsZWFy X2JpdChibGssIHBzLT5wZW5kaW5nKTsKPiAtCQkJLyogZG9uJ3QgY2xlYXIgaW4gZ2xvYmFsIHNt cF9zdGF0ZSB1bnRpbCBfY29tbWl0KCkgKi8KPiArCj4gKwkJCS8qIGNsZWFyIGluIGdsb2JhbCBz bXBfc3RhdGUgaWYgbm90IGluIGNvbmZpZ3VyZWQKPiArCQkJICogb3RoZXJ3aXNlIHVudGlsIF9j b21taXQoKQo+ICsJCQkgKi8KPiArCQkJaWYgKCF0ZXN0X2JpdChibGssIHBzLT5jb25maWd1cmVk KSkKPiArCQkJCWNsZWFyX2JpdChibGssIHNtcC0+c3RhdGUpOwo+ICAgCQl9Cj4gICAJfQo+Cj4g QEAgLTIyMywxMCArMjUzLDMzIEBAIGludCBtZHA1X3NtcF9yZXF1ZXN0KHN0cnVjdCBtZHA1X3Nt cCAqc21wLCBlbnVtIG1kcDVfcGlwZSBwaXBlLCB1MzIgZm10LCB1MzIgd2lkCj4gICAvKiBSZWxl YXNlIFNNUCBibG9ja3MgZm9yIGFsbCBjbGllbnRzIG9mIHRoZSBwaXBlICovCj4gICB2b2lkIG1k cDVfc21wX3JlbGVhc2Uoc3RydWN0IG1kcDVfc21wICpzbXAsIGVudW0gbWRwNV9waXBlIHBpcGUp Cj4gICB7Cj4gLQlpbnQgaSwgbmJsa3M7Cj4gKwlpbnQgaTsKPiArCXVuc2lnbmVkIGxvbmcgZmxh Z3M7Cj4gKwlpbnQgY250ID0gc21wLT5ibGtfY250Owo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBw aXBlMm5jbGllbnRzKHBpcGUpOyBpKyspIHsKPiArCQltZHA1X3NtcF9zdGF0ZV90IGFzc2lnbmVk Owo+ICsJCXUzMiBjaWQgPSBwaXBlMmNsaWVudChwaXBlLCBpKTsKPiArCQlzdHJ1Y3QgbWRwNV9j bGllbnRfc21wX3N0YXRlICpwcyA9ICZzbXAtPmNsaWVudF9zdGF0ZVtjaWRdOwo+ICsKPiArCQlz cGluX2xvY2tfaXJxc2F2ZSgmc21wLT5zdGF0ZV9sb2NrLCBmbGFncyk7Cj4gKwo+ICsJCS8qIGNs ZWFyIGh3IGFzc2lnbm1lbnQgKi8KPiArCQliaXRtYXBfb3IoYXNzaWduZWQsIHBzLT5pbnVzZSwg cHMtPmNvbmZpZ3VyZWQsIGNudCk7Cj4gKwkJdXBkYXRlX3NtcF9zdGF0ZShzbXAsIENJRF9VTlVT RUQsICZhc3NpZ25lZCk7Cj4gKwo+ICsJCS8qIGZyZWUgdG8gZ2xvYmFsIHBvb2wgKi8KPiArCQli aXRtYXBfYW5kbm90KHNtcC0+c3RhdGUsIHNtcC0+c3RhdGUsIHBzLT5wZW5kaW5nLCBjbnQpOwo+ ICsJCWJpdG1hcF9hbmRub3Qoc21wLT5zdGF0ZSwgc21wLT5zdGF0ZSwgYXNzaWduZWQsIGNudCk7 Cj4gKwo+ICsJCS8qIGNsZWFyIGNsaWVudCdzIGluZm9yICovCj4gKwkJYml0bWFwX3plcm8ocHMt PnBlbmRpbmcsIGNudCk7Cj4gKwkJYml0bWFwX3plcm8ocHMtPmNvbmZpZ3VyZWQsIGNudCk7Cj4g KwkJYml0bWFwX3plcm8ocHMtPmludXNlLCBjbnQpOwo+ICsKPiArCQlzcGluX3VubG9ja19pcnFy ZXN0b3JlKCZzbXAtPnN0YXRlX2xvY2ssIGZsYWdzKTsKPiArCX0KPgo+IC0JZm9yIChpID0gMCwg bmJsa3MgPSAwOyBpIDwgcGlwZTJuY2xpZW50cyhwaXBlKTsgaSsrKQo+IC0JCXNtcF9yZXF1ZXN0 X2Jsb2NrKHNtcCwgcGlwZTJjbGllbnQocGlwZSwgaSksIDApOwo+ICAgCXNldF9maWZvX3RocmVz aG9sZHMoc21wLCBwaXBlLCAwKTsKPiAgIH0KPgo+IEBAIC0yNzQsMTIgKzMyNywyMCBAQCB2b2lk IG1kcDVfc21wX2NvbmZpZ3VyZShzdHJ1Y3QgbWRwNV9zbXAgKnNtcCwgZW51bSBtZHA1X3BpcGUg cGlwZSkKPiAgIAkJdTMyIGNpZCA9IHBpcGUyY2xpZW50KHBpcGUsIGkpOwo+ICAgCQlzdHJ1Y3Qg bWRwNV9jbGllbnRfc21wX3N0YXRlICpwcyA9ICZzbXAtPmNsaWVudF9zdGF0ZVtjaWRdOwo+Cj4g LQkJYml0bWFwX29yKGFzc2lnbmVkLCBwcy0+aW51c2UsIHBzLT5wZW5kaW5nLCBjbnQpOwo+ICsJ CS8qCj4gKwkJICogaWYgdmJsYW5rIGhhcyBub3QgaGFwcGVuZWQgc2luY2UgbGFzdCBzbXBfY29u ZmlndXJlCj4gKwkJICogc2tpcCB0aGUgY29uZmlndXJlIGZvciBub3cKPiArCQkgKi8KPiArCQlp ZiAoIWJpdG1hcF9lcXVhbChwcy0+aW51c2UsIHBzLT5jb25maWd1cmVkLCBjbnQpKQo+ICsJCQlj b250aW51ZTsKPiArCj4gKwkJYml0bWFwX2NvcHkocHMtPmNvbmZpZ3VyZWQsIHBzLT5wZW5kaW5n LCBjbnQpOwo+ICsJCWJpdG1hcF9vcihhc3NpZ25lZCwgcHMtPmludXNlLCBwcy0+Y29uZmlndXJl ZCwgY250KTsKPiAgIAkJdXBkYXRlX3NtcF9zdGF0ZShzbXAsIGNpZCwgJmFzc2lnbmVkKTsKPiAg IAl9Cj4gICB9Cj4KPiAtLyogc3RlcCAjMzogYWZ0ZXIgdmJsYW5rLCBjb3B5IHBlbmRpbmcgLT4g aW51c2U6ICovCj4gKy8qIHN0ZXAgIzM6IGFmdGVyIHZibGFuaywgY29weSBjb25maWd1cmVkIC0+ IGludXNlOiAqLwo+ICAgdm9pZCBtZHA1X3NtcF9jb21taXQoc3RydWN0IG1kcDVfc21wICpzbXAs IGVudW0gbWRwNV9waXBlIHBpcGUpCj4gICB7Cj4gICAJaW50IGNudCA9IHNtcC0+YmxrX2NudDsK PiBAQCAtMjk1LDcgKzM1Niw3IEBAIHZvaWQgbWRwNV9zbXBfY29tbWl0KHN0cnVjdCBtZHA1X3Nt cCAqc21wLCBlbnVtIG1kcDVfcGlwZSBwaXBlKQo+ICAgCQkgKiB1c2luZywgd2hpY2ggY2FuIGJl IHJlbGVhc2VkIGFuZCBtYWRlIGF2YWlsYWJsZSB0byBvdGhlcgo+ICAgCQkgKiBjbGllbnRzOgo+ ICAgCQkgKi8KPiAtCQlpZiAoYml0bWFwX2FuZG5vdChyZWxlYXNlZCwgcHMtPmludXNlLCBwcy0+ cGVuZGluZywgY250KSkgewo+ICsJCWlmIChiaXRtYXBfYW5kbm90KHJlbGVhc2VkLCBwcy0+aW51 c2UsIHBzLT5jb25maWd1cmVkLCBjbnQpKSB7Cj4gICAJCQl1bnNpZ25lZCBsb25nIGZsYWdzOwo+ Cj4gICAJCQlzcGluX2xvY2tfaXJxc2F2ZSgmc21wLT5zdGF0ZV9sb2NrLCBmbGFncyk7Cj4gQEAg LTMwNiw3ICszNjcsNyBAQCB2b2lkIG1kcDVfc21wX2NvbW1pdChzdHJ1Y3QgbWRwNV9zbXAgKnNt cCwgZW51bSBtZHA1X3BpcGUgcGlwZSkKPiAgIAkJCXVwZGF0ZV9zbXBfc3RhdGUoc21wLCBDSURf VU5VU0VELCAmcmVsZWFzZWQpOwo+ICAgCQl9Cj4KPiAtCQliaXRtYXBfY29weShwcy0+aW51c2Us IHBzLT5wZW5kaW5nLCBjbnQpOwo+ICsJCWJpdG1hcF9jb3B5KHBzLT5pbnVzZSwgcHMtPmNvbmZp Z3VyZWQsIGNudCk7Cj4gICAJfQo+ICAgfQo+Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9tc20vbWRwL21kcDUvbWRwNV9zbXAuaCBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbWRwL21kcDUv bWRwNV9zbXAuaAo+IGluZGV4IGU0NzE3OWYuLjViNmMyMzYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL21zbS9tZHAvbWRwNS9tZHA1X3NtcC5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJt L21zbS9tZHAvbWRwNS9tZHA1X3NtcC5oCj4gQEAgLTIzLDYgKzIzLDcgQEAKPgo+ICAgc3RydWN0 IG1kcDVfY2xpZW50X3NtcF9zdGF0ZSB7Cj4gICAJbWRwNV9zbXBfc3RhdGVfdCBpbnVzZTsKPiAr CW1kcDVfc21wX3N0YXRlX3QgY29uZmlndXJlZDsKPiAgIAltZHA1X3NtcF9zdGF0ZV90IHBlbmRp bmc7Cj4gICB9Owo+Cj4KCi0tIApRdWFsY29tbSBJbm5vdmF0aW9uIENlbnRlciwgSW5jLiBpcyBh IG1lbWJlciBvZiBDb2RlIEF1cm9yYSBGb3J1bSwKYSBMaW51eCBGb3VuZGF0aW9uIENvbGxhYm9y YXRpdmUgUHJvamVjdApfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5v cmcKaHR0cDovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZl bAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933236AbbFVKep (ORCPT ); Mon, 22 Jun 2015 06:34:45 -0400 Received: from smtp.codeaurora.org ([198.145.29.96]:51897 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756008AbbFVKei (ORCPT ); Mon, 22 Jun 2015 06:34:38 -0400 Message-ID: <5587E4B7.9080004@codeaurora.org> Date: Mon, 22 Jun 2015 16:04:31 +0530 From: Archit Taneja User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:31.0) Gecko/20100101 Thunderbird/31.6.0 MIME-Version: 1.0 To: Wentao Xu , dri-devel@lists.freedesktop.org CC: linux-arm-msm@vger.kernel.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH] drm/msm/mdp5: release SMB(shared memory blocks) in various cases References: <1434737022-23591-1-git-send-email-wentaox@codeaurora.org> In-Reply-To: <1434737022-23591-1-git-send-email-wentaox@codeaurora.org> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 06/19/2015 11:33 PM, Wentao Xu wrote: > Release all blocks after the pipe is disabled, even when vsync > didn't happen in some error cases. Allow requesting SMB multiple > times before configuring to hardware, by releasing blocks not > programmed to hardware yet for shrinking case. Tested-by: Archit Taneja > > Signed-off-by: Wentao Xu > --- > drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c | 13 +++++ > drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h | 2 + > drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c | 33 +++++------- > drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.c | 87 ++++++++++++++++++++++++++----- > drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.h | 1 + > 5 files changed, 104 insertions(+), 32 deletions(-) > > diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c > index 97226a1..db49ee8 100644 > --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c > +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c > @@ -78,7 +78,20 @@ static void mdp5_prepare_commit(struct msm_kms *kms, struct drm_atomic_state *st > > static void mdp5_complete_commit(struct msm_kms *kms, struct drm_atomic_state *state) > { > + int i; > struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms)); > + int nplanes = mdp5_kms->dev->mode_config.num_total_plane; > + > + for (i = 0; i < nplanes; i++) { > + struct drm_plane *plane = state->planes[i]; > + struct drm_plane_state *plane_state = state->plane_states[i]; > + > + if (!plane) > + continue; > + > + mdp5_plane_complete_commit(plane, plane_state); > + } > + > mdp5_disable(mdp5_kms); > } > > diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h > index 2c0de17..42f270b 100644 > --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h > +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h > @@ -227,6 +227,8 @@ void mdp5_plane_install_properties(struct drm_plane *plane, > struct drm_mode_object *obj); > uint32_t mdp5_plane_get_flush(struct drm_plane *plane); > void mdp5_plane_complete_flip(struct drm_plane *plane); > +void mdp5_plane_complete_commit(struct drm_plane *plane, > + struct drm_plane_state *state); > enum mdp5_pipe mdp5_plane_pipe(struct drm_plane *plane); > struct drm_plane *mdp5_plane_init(struct drm_device *dev, > enum mdp5_pipe pipe, bool private_plane, uint32_t reg_offset); > diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c > index 18a3d20..05b2634 100644 > --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c > +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c > @@ -31,8 +31,6 @@ struct mdp5_plane { > > uint32_t nformats; > uint32_t formats[32]; > - > - bool enabled; > }; > #define to_mdp5_plane(x) container_of(x, struct mdp5_plane, base) > > @@ -56,22 +54,6 @@ static bool plane_enabled(struct drm_plane_state *state) > return state->fb && state->crtc; > } > > -static int mdp5_plane_disable(struct drm_plane *plane) > -{ > - struct mdp5_plane *mdp5_plane = to_mdp5_plane(plane); > - struct mdp5_kms *mdp5_kms = get_kms(plane); > - enum mdp5_pipe pipe = mdp5_plane->pipe; > - > - DBG("%s: disable", mdp5_plane->name); > - > - if (mdp5_kms) { > - /* Release the memory we requested earlier from the SMP: */ > - mdp5_smp_release(mdp5_kms->smp, pipe); > - } > - > - return 0; > -} > - > static void mdp5_plane_destroy(struct drm_plane *plane) > { > struct mdp5_plane *mdp5_plane = to_mdp5_plane(plane); > @@ -224,7 +206,6 @@ static void mdp5_plane_atomic_update(struct drm_plane *plane, > > if (!plane_enabled(state)) { > to_mdp5_plane_state(state)->pending = true; > - mdp5_plane_disable(plane); > } else if (to_mdp5_plane_state(state)->mode_changed) { > int ret; > to_mdp5_plane_state(state)->pending = true; > @@ -602,6 +583,20 @@ uint32_t mdp5_plane_get_flush(struct drm_plane *plane) > return mdp5_plane->flush_mask; > } > > +/* called after vsync in thread context */ > +void mdp5_plane_complete_commit(struct drm_plane *plane, > + struct drm_plane_state *state) > +{ > + struct mdp5_kms *mdp5_kms = get_kms(plane); > + struct mdp5_plane *mdp5_plane = to_mdp5_plane(plane); > + enum mdp5_pipe pipe = mdp5_plane->pipe; > + > + if (!plane_enabled(plane->state)) { > + DBG("%s: free SMP", mdp5_plane->name); > + mdp5_smp_release(mdp5_kms->smp, pipe); > + } > +} > + > /* initialize plane */ > struct drm_plane *mdp5_plane_init(struct drm_device *dev, > enum mdp5_pipe pipe, bool private_plane, uint32_t reg_offset) > diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.c > index 16702ae..64a27d8 100644 > --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.c > +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.c > @@ -34,22 +34,44 @@ > * and CANNOT be re-allocated (eg: MMB0 and MMB1 both tied to RGB0). > * > * For each block that can be dynamically allocated, it can be either > - * free, or pending/in-use by a client. The updates happen in three steps: > + * free: > + * The block is free. > + * > + * pending: > + * The block is allocated to some client and not free. > + * > + * configured: > + * The block is allocated to some client, and assigned to that > + * client in MDP5_MDP_SMP_ALLOC registers. > + * > + * inuse: > + * The block is being actively used by a client. > + * > + * The updates happen in the following steps: > * > * 1) mdp5_smp_request(): > * When plane scanout is setup, calculate required number of > - * blocks needed per client, and request. Blocks not inuse or > - * pending by any other client are added to client's pending > - * set. > + * blocks needed per client, and request. Blocks neither inuse nor > + * configured nor pending by any other client are added to client's > + * pending set. > + * For shrinking, blocks in pending but not in configured can be freed > + * directly, but those already in configured will be freed later by > + * mdp5_smp_commit. > * > * 2) mdp5_smp_configure(): > * As hw is programmed, before FLUSH, MDP5_MDP_SMP_ALLOC registers > * are configured for the union(pending, inuse) > + * Current pending is copied to configured. > + * It is assumed that mdp5_smp_request and mdp5_smp_configure not run > + * concurrently for the same pipe. > * > * 3) mdp5_smp_commit(): > - * After next vblank, copy pending -> inuse. Optionally update > + * After next vblank, copy configured -> inuse. Optionally update > * MDP5_SMP_ALLOC registers if there are newly unused blocks > * > + * 4) mdp5_smp_release(): > + * Must be called after the pipe is disabled and no longer uses any SMB > + * > * On the next vblank after changes have been committed to hw, the > * client's pending blocks become it's in-use blocks (and no-longer > * in-use blocks become available to other clients). > @@ -77,6 +99,9 @@ struct mdp5_smp { > struct mdp5_client_smp_state client_state[MAX_CLIENTS]; > }; > > +static void update_smp_state(struct mdp5_smp *smp, > + u32 cid, mdp5_smp_state_t *assigned); > + > static inline > struct mdp5_kms *get_kms(struct mdp5_smp *smp) > { > @@ -149,7 +174,12 @@ static int smp_request_block(struct mdp5_smp *smp, > for (i = cur_nblks; i > nblks; i--) { > int blk = find_first_bit(ps->pending, cnt); > clear_bit(blk, ps->pending); > - /* don't clear in global smp_state until _commit() */ > + > + /* clear in global smp_state if not in configured > + * otherwise until _commit() > + */ > + if (!test_bit(blk, ps->configured)) > + clear_bit(blk, smp->state); > } > } > > @@ -223,10 +253,33 @@ int mdp5_smp_request(struct mdp5_smp *smp, enum mdp5_pipe pipe, u32 fmt, u32 wid > /* Release SMP blocks for all clients of the pipe */ > void mdp5_smp_release(struct mdp5_smp *smp, enum mdp5_pipe pipe) > { > - int i, nblks; > + int i; > + unsigned long flags; > + int cnt = smp->blk_cnt; > + > + for (i = 0; i < pipe2nclients(pipe); i++) { > + mdp5_smp_state_t assigned; > + u32 cid = pipe2client(pipe, i); > + struct mdp5_client_smp_state *ps = &smp->client_state[cid]; > + > + spin_lock_irqsave(&smp->state_lock, flags); > + > + /* clear hw assignment */ > + bitmap_or(assigned, ps->inuse, ps->configured, cnt); > + update_smp_state(smp, CID_UNUSED, &assigned); > + > + /* free to global pool */ > + bitmap_andnot(smp->state, smp->state, ps->pending, cnt); > + bitmap_andnot(smp->state, smp->state, assigned, cnt); > + > + /* clear client's infor */ > + bitmap_zero(ps->pending, cnt); > + bitmap_zero(ps->configured, cnt); > + bitmap_zero(ps->inuse, cnt); > + > + spin_unlock_irqrestore(&smp->state_lock, flags); > + } > > - for (i = 0, nblks = 0; i < pipe2nclients(pipe); i++) > - smp_request_block(smp, pipe2client(pipe, i), 0); > set_fifo_thresholds(smp, pipe, 0); > } > > @@ -274,12 +327,20 @@ void mdp5_smp_configure(struct mdp5_smp *smp, enum mdp5_pipe pipe) > u32 cid = pipe2client(pipe, i); > struct mdp5_client_smp_state *ps = &smp->client_state[cid]; > > - bitmap_or(assigned, ps->inuse, ps->pending, cnt); > + /* > + * if vblank has not happened since last smp_configure > + * skip the configure for now > + */ > + if (!bitmap_equal(ps->inuse, ps->configured, cnt)) > + continue; > + > + bitmap_copy(ps->configured, ps->pending, cnt); > + bitmap_or(assigned, ps->inuse, ps->configured, cnt); > update_smp_state(smp, cid, &assigned); > } > } > > -/* step #3: after vblank, copy pending -> inuse: */ > +/* step #3: after vblank, copy configured -> inuse: */ > void mdp5_smp_commit(struct mdp5_smp *smp, enum mdp5_pipe pipe) > { > int cnt = smp->blk_cnt; > @@ -295,7 +356,7 @@ void mdp5_smp_commit(struct mdp5_smp *smp, enum mdp5_pipe pipe) > * using, which can be released and made available to other > * clients: > */ > - if (bitmap_andnot(released, ps->inuse, ps->pending, cnt)) { > + if (bitmap_andnot(released, ps->inuse, ps->configured, cnt)) { > unsigned long flags; > > spin_lock_irqsave(&smp->state_lock, flags); > @@ -306,7 +367,7 @@ void mdp5_smp_commit(struct mdp5_smp *smp, enum mdp5_pipe pipe) > update_smp_state(smp, CID_UNUSED, &released); > } > > - bitmap_copy(ps->inuse, ps->pending, cnt); > + bitmap_copy(ps->inuse, ps->configured, cnt); > } > } > > diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.h b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.h > index e47179f..5b6c236 100644 > --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.h > +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.h > @@ -23,6 +23,7 @@ > > struct mdp5_client_smp_state { > mdp5_smp_state_t inuse; > + mdp5_smp_state_t configured; > mdp5_smp_state_t pending; > }; > > -- Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in Please read the FAQ at http://www.tux.org/lkml/