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=-11.4 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,MIME_BASE64_TEXT,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, UNPARSEABLE_RELAY,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5958FC43466 for ; Thu, 23 Jul 2020 03:07:02 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1AF1D207E8 for ; Thu, 23 Jul 2020 03:07:02 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="Qp96XDf7" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2387903AbgGWDHA (ORCPT ); Wed, 22 Jul 2020 23:07:00 -0400 Received: from mailgw01.mediatek.com ([210.61.82.183]:59519 "EHLO mailgw01.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S2387859AbgGWDGy (ORCPT ); Wed, 22 Jul 2020 23:06:54 -0400 X-UUID: 02ef9156c69a46e689b2861b01b64b41-20200723 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=3vUbUgggiDu/OOAylBirIZ2cYJlSnSLO9WjOqzyMv3o=; b=Qp96XDf7eUW8hvKbrbhbt5fUPAOMRam1RUxIjBpKE6jAqquZCEOApk7FwoMvr3yWc5vyIN9HCho4sxEeiqrxKoCQHUIE7XKDHnXIFk/Qp2SN/kH+K4XkbeQzV79U91jpojrXtkp3HvsJC0Cx0DRwwrzL1+z6DAgsRiw2uLbAdak=; X-UUID: 02ef9156c69a46e689b2861b01b64b41-20200723 Received: from mtkcas07.mediatek.inc [(172.21.101.84)] by mailgw01.mediatek.com (envelope-from ) (Cellopoint E-mail Firewall v4.1.10 Build 0809 with TLS) with ESMTP id 834254624; Thu, 23 Jul 2020 11:06:46 +0800 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs07n2.mediatek.inc (172.21.101.141) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Thu, 23 Jul 2020 11:06:44 +0800 Received: from localhost.localdomain (10.17.3.153) by MTKCAS06.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Thu, 23 Jul 2020 11:06:40 +0800 From: Xia Jiang To: Hans Verkuil , Mauro Carvalho Chehab , Rob Herring , Matthias Brugger , Rick Chang CC: , , , , , Marek Szyprowski , Tomasz Figa , , , , , , Xia Jiang Subject: [PATCH v10 28/28] media: platform: Add jpeg enc feature Date: Thu, 23 Jul 2020 11:04:51 +0800 Message-ID: <20200723030451.5616-29-xia.jiang@mediatek.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20200723030451.5616-1-xia.jiang@mediatek.com> References: <20200723030451.5616-1-xia.jiang@mediatek.com> MIME-Version: 1.0 Content-Type: text/plain X-MTK: N Content-Transfer-Encoding: base64 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org QWRkIG10ayBqcGVnIGVuY29kZSB2NGwyIGRyaXZlciBiYXNlZCBvbiBqcGVnIGRlY29kZSwgYmVj YXVzZSB0aGF0IGpwZWcNCmRlY29kZSBhbmQgZW5jb2RlIGhhdmUgZ3JlYXQgc2ltaWxhcml0aWVz IHdpdGggZnVuY3Rpb24gb3BlcmF0aW9uLg0KDQpTaWduZWQtb2ZmLWJ5OiBYaWEgSmlhbmcgPHhp YS5qaWFuZ0BtZWRpYXRlay5jb20+DQotLS0NCnYxMDogY2FuY2VsIG10a19qcGVnX2VuY19icyBz dHJ1Y3R1cmUuDQogICAgIHJlZmFjdG9yIHRoZSBzZXR0aW5nIGhhcmR3YXJlIHJlZ2lzdGVyIGZ1 bmN0aW9ucyBpbiBtdGtfanBlZ19lbmNfaHcuYy4NCiAgICAgcmVtb3ZlIG10a19qcGVnX2VuY19q b2JfcmVhZHkoKS4NCiAgICAgcmVmYWN0b3IgbXRrX2pwZWdfZW5jX2lycSgpLg0KICAgICBjYW5j ZWwgc2V0dGluZyB1cCBhIGNvbnRyb2wgaGFuZGxlciBmb3IganBlZyBkZWMuDQogICAgIGFkZCB0 aGUgbWVjaGFuaXNtIHRvIGVuc3VyZSB0aGF0IHRoZSBidWZmZXIgaXMgZW5vdWdoIHRvIGhvbGQg dGhlDQogICAgIEVYSUYgZGF0YSBpbiAuYnVmX3ByZXBhcmUgY2FsbGJhY2suDQotLS0NCiBkcml2 ZXJzL21lZGlhL3BsYXRmb3JtL210ay1qcGVnL01ha2VmaWxlICAgICAgfCAgIDUgKy0NCiAuLi4v bWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfY29yZS5jICAgfCAzNDUgKysrKysrKysr KysrKysrKystDQogLi4uL21lZGlhL3BsYXRmb3JtL210ay1qcGVnL210a19qcGVnX2NvcmUuaCAg IHwgIDE3ICsNCiAuLi4vbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfZW5jX2h3LmMg fCAxNTQgKysrKysrKysNCiAuLi4vbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfZW5j X2h3LmggfCAgOTEgKysrKysNCiA1IGZpbGVzIGNoYW5nZWQsIDYwOCBpbnNlcnRpb25zKCspLCA0 IGRlbGV0aW9ucygtKQ0KIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21lZGlhL3BsYXRmb3Jt L210ay1qcGVnL210a19qcGVnX2VuY19ody5jDQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMv bWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfZW5jX2h3LmgNCg0KZGlmZiAtLWdpdCBh L2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvTWFrZWZpbGUgYi9kcml2ZXJzL21lZGlh L3BsYXRmb3JtL210ay1qcGVnL01ha2VmaWxlDQppbmRleCA0ODUxNmRjZjk2ZTYuLjc2YzMzYWFk MGYzZiAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvTWFrZWZp bGUNCisrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvTWFrZWZpbGUNCkBAIC0x LDMgKzEsNiBAQA0KICMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb25seQ0KLW10 a19qcGVnLW9ianMgOj0gbXRrX2pwZWdfY29yZS5vIG10a19qcGVnX2RlY19ody5vIG10a19qcGVn X2RlY19wYXJzZS5vDQorbXRrX2pwZWctb2JqcyA6PSBtdGtfanBlZ19jb3JlLm8gXA0KKwkJIG10 a19qcGVnX2RlY19ody5vIFwNCisJCSBtdGtfanBlZ19kZWNfcGFyc2UubyBcDQorCQkgbXRrX2pw ZWdfZW5jX2h3Lm8NCiBvYmotJChDT05GSUdfVklERU9fTUVESUFURUtfSlBFRykgKz0gbXRrX2pw ZWcubw0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pw ZWdfY29yZS5jIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9tdGstanBlZy9tdGtfanBlZ19jb3Jl LmMNCmluZGV4IDFlZWJiZTcyNmQ0Zi4uNGM4ZDRiNDg3MTNhIDEwMDY0NA0KLS0tIGEvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS9tdGstanBlZy9tdGtfanBlZ19jb3JlLmMNCisrKyBiL2RyaXZlcnMv bWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfY29yZS5jDQpAQCAtMyw2ICszLDcgQEAN CiAgKiBDb3B5cmlnaHQgKGMpIDIwMTYgTWVkaWFUZWsgSW5jLg0KICAqIEF1dGhvcjogTWluZyBI c2l1IFRzYWkgPG1pbmdoc2l1LnRzYWlAbWVkaWF0ZWsuY29tPg0KICAqICAgICAgICAgUmljayBD aGFuZyA8cmljay5jaGFuZ0BtZWRpYXRlay5jb20+DQorICogICAgICAgICBYaWEgSmlhbmcgPHhp YS5qaWFuZ0BtZWRpYXRlay5jb20+DQogICovDQogDQogI2luY2x1ZGUgPGxpbnV4L2Nsay5oPg0K QEAgLTIzLDEwICsyNCw1OSBAQA0KICNpbmNsdWRlIDxtZWRpYS92aWRlb2J1ZjItZG1hLWNvbnRp Zy5oPg0KICNpbmNsdWRlIDxzb2MvbWVkaWF0ZWsvc21pLmg+DQogDQorI2luY2x1ZGUgIm10a19q cGVnX2VuY19ody5oIg0KICNpbmNsdWRlICJtdGtfanBlZ19kZWNfaHcuaCINCiAjaW5jbHVkZSAi bXRrX2pwZWdfY29yZS5oIg0KICNpbmNsdWRlICJtdGtfanBlZ19kZWNfcGFyc2UuaCINCiANCitz dGF0aWMgc3RydWN0IG10a19qcGVnX2ZtdCBtdGtfanBlZ19lbmNfZm9ybWF0c1tdID0gew0KKwl7 DQorCQkuZm91cmNjCQk9IFY0TDJfUElYX0ZNVF9KUEVHLA0KKwkJLmNvbHBsYW5lcwk9IDEsDQor CQkuZmxhZ3MJCT0gTVRLX0pQRUdfRk1UX0ZMQUdfQ0FQVFVSRSwNCisJfSwNCisJew0KKwkJLmZv dXJjYwkJPSBWNEwyX1BJWF9GTVRfTlYxMk0sDQorCQkuaHdfZm9ybWF0CT0gSlBFR19FTkNfWVVW X0ZPUk1BVF9OVjEyLA0KKwkJLmhfc2FtcGxlCT0gezQsIDR9LA0KKwkJLnZfc2FtcGxlCT0gezQs IDJ9LA0KKwkJLmNvbHBsYW5lcwk9IDIsDQorCQkuaF9hbGlnbgk9IDQsDQorCQkudl9hbGlnbgk9 IDQsDQorCQkuZmxhZ3MJCT0gTVRLX0pQRUdfRk1UX0ZMQUdfT1VUUFVULA0KKwl9LA0KKwl7DQor CQkuZm91cmNjCQk9IFY0TDJfUElYX0ZNVF9OVjIxTSwNCisJCS5od19mb3JtYXQJPSBKRVBHX0VO Q19ZVVZfRk9STUFUX05WMjEsDQorCQkuaF9zYW1wbGUJPSB7NCwgNH0sDQorCQkudl9zYW1wbGUJ PSB7NCwgMn0sDQorCQkuY29scGxhbmVzCT0gMiwNCisJCS5oX2FsaWduCT0gNCwNCisJCS52X2Fs aWduCT0gNCwNCisJCS5mbGFncwkJPSBNVEtfSlBFR19GTVRfRkxBR19PVVRQVVQsDQorCX0sDQor CXsNCisJCS5mb3VyY2MJCT0gVjRMMl9QSVhfRk1UX1lVWVYsDQorCQkuaHdfZm9ybWF0CT0gSlBF R19FTkNfWVVWX0ZPUk1BVF9ZVVlWLA0KKwkJLmhfc2FtcGxlCT0gezh9LA0KKwkJLnZfc2FtcGxl CT0gezR9LA0KKwkJLmNvbHBsYW5lcwk9IDEsDQorCQkuaF9hbGlnbgk9IDUsDQorCQkudl9hbGln bgk9IDMsDQorCQkuZmxhZ3MJCT0gTVRLX0pQRUdfRk1UX0ZMQUdfT1VUUFVULA0KKwl9LA0KKwl7 DQorCQkuZm91cmNjCQk9IFY0TDJfUElYX0ZNVF9ZVllVLA0KKwkJLmh3X2Zvcm1hdAk9IEpQRUdf RU5DX1lVVl9GT1JNQVRfWVZZVSwNCisJCS5oX3NhbXBsZQk9IHs4fSwNCisJCS52X3NhbXBsZQk9 IHs0fSwNCisJCS5jb2xwbGFuZXMJPSAxLA0KKwkJLmhfYWxpZ24JPSA1LA0KKwkJLnZfYWxpZ24J PSAzLA0KKwkJLmZsYWdzCQk9IE1US19KUEVHX0ZNVF9GTEFHX09VVFBVVCwNCisJfSwNCit9Ow0K Kw0KIHN0YXRpYyBzdHJ1Y3QgbXRrX2pwZWdfZm10IG10a19qcGVnX2RlY19mb3JtYXRzW10gPSB7 DQogCXsNCiAJCS5mb3VyY2MJCT0gVjRMMl9QSVhfRk1UX0pQRUcsDQpAQCAtNTMsNiArMTAzLDcg QEAgc3RhdGljIHN0cnVjdCBtdGtfanBlZ19mbXQgbXRrX2pwZWdfZGVjX2Zvcm1hdHNbXSA9IHsN CiAJfSwNCiB9Ow0KIA0KKyNkZWZpbmUgTVRLX0pQRUdfRU5DX05VTV9GT1JNQVRTIEFSUkFZX1NJ WkUobXRrX2pwZWdfZW5jX2Zvcm1hdHMpDQogI2RlZmluZSBNVEtfSlBFR19ERUNfTlVNX0ZPUk1B VFMgQVJSQVlfU0laRShtdGtfanBlZ19kZWNfZm9ybWF0cykNCiANCiBzdHJ1Y3QgbXRrX2pwZWdf c3JjX2J1ZiB7DQpAQCAtNjQsNiArMTE1LDExIEBAIHN0cnVjdCBtdGtfanBlZ19zcmNfYnVmIHsN CiBzdGF0aWMgaW50IGRlYnVnOw0KIG1vZHVsZV9wYXJhbShkZWJ1ZywgaW50LCAwNjQ0KTsNCiAN CitzdGF0aWMgaW5saW5lIHN0cnVjdCBtdGtfanBlZ19jdHggKmN0cmxfdG9fY3R4KHN0cnVjdCB2 NGwyX2N0cmwgKmN0cmwpDQorew0KKwlyZXR1cm4gY29udGFpbmVyX29mKGN0cmwtPmhhbmRsZXIs IHN0cnVjdCBtdGtfanBlZ19jdHgsIGN0cmxfaGRsKTsNCit9DQorDQogc3RhdGljIGlubGluZSBz dHJ1Y3QgbXRrX2pwZWdfY3R4ICptdGtfanBlZ19maF90b19jdHgoc3RydWN0IHY0bDJfZmggKmZo KQ0KIHsNCiAJcmV0dXJuIGNvbnRhaW5lcl9vZihmaCwgc3RydWN0IG10a19qcGVnX2N0eCwgZmgp Ow0KQEAgLTg4LDYgKzE0NCw1MyBAQCBzdGF0aWMgaW50IG10a19qcGVnX3F1ZXJ5Y2FwKHN0cnVj dCBmaWxlICpmaWxlLCB2b2lkICpwcml2LA0KIAlyZXR1cm4gMDsNCiB9DQogDQorc3RhdGljIGlu dCB2aWRpb2NfanBlZ19lbmNfc19jdHJsKHN0cnVjdCB2NGwyX2N0cmwgKmN0cmwpDQorew0KKwlz dHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHggPSBjdHJsX3RvX2N0eChjdHJsKTsNCisNCisJc3dpdGNo IChjdHJsLT5pZCkgew0KKwljYXNlIFY0TDJfQ0lEX0pQRUdfUkVTVEFSVF9JTlRFUlZBTDoNCisJ CWN0eC0+cmVzdGFydF9pbnRlcnZhbCA9IGN0cmwtPnZhbDsNCisJCWJyZWFrOw0KKwljYXNlIFY0 TDJfQ0lEX0pQRUdfQ09NUFJFU1NJT05fUVVBTElUWToNCisJCWN0eC0+ZW5jX3F1YWxpdHkgPSBj dHJsLT52YWw7DQorCQlicmVhazsNCisJY2FzZSBWNEwyX0NJRF9KUEVHX0FDVElWRV9NQVJLRVI6 DQorCQljdHgtPmVuYWJsZV9leGlmID0gY3RybC0+dmFsICYgVjRMMl9KUEVHX0FDVElWRV9NQVJL RVJfQVBQMTsNCisJCWJyZWFrOw0KKwl9DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMg Y29uc3Qgc3RydWN0IHY0bDJfY3RybF9vcHMgbXRrX2pwZWdfZW5jX2N0cmxfb3BzID0gew0KKwku c19jdHJsID0gdmlkaW9jX2pwZWdfZW5jX3NfY3RybCwNCit9Ow0KKw0KK3N0YXRpYyBpbnQgbXRr X2pwZWdfZW5jX2N0cmxzX3NldHVwKHN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCkNCit7DQorCWNv bnN0IHN0cnVjdCB2NGwyX2N0cmxfb3BzICpvcHMgPSAmbXRrX2pwZWdfZW5jX2N0cmxfb3BzOw0K KwlzdHJ1Y3QgdjRsMl9jdHJsX2hhbmRsZXIgKmhhbmRsZXIgPSAmY3R4LT5jdHJsX2hkbDsNCisN CisJdjRsMl9jdHJsX2hhbmRsZXJfaW5pdChoYW5kbGVyLCAzKTsNCisNCisJdjRsMl9jdHJsX25l d19zdGQoaGFuZGxlciwgb3BzLCBWNEwyX0NJRF9KUEVHX1JFU1RBUlRfSU5URVJWQUwsIDAsIDEw MCwNCisJCQkgIDEsIDApOw0KKwl2NGwyX2N0cmxfbmV3X3N0ZChoYW5kbGVyLCBvcHMsIFY0TDJf Q0lEX0pQRUdfQ09NUFJFU1NJT05fUVVBTElUWSwgNDgsDQorCQkJICAxMDAsIDEsIDkwKTsNCisJ djRsMl9jdHJsX25ld19zdGQoaGFuZGxlciwgb3BzLCBWNEwyX0NJRF9KUEVHX0FDVElWRV9NQVJL RVIsIDAsDQorCQkJICBWNEwyX0pQRUdfQUNUSVZFX01BUktFUl9BUFAxLCAwLCAwKTsNCisNCisJ aWYgKGhhbmRsZXItPmVycm9yKSB7DQorCQl2NGwyX2N0cmxfaGFuZGxlcl9mcmVlKCZjdHgtPmN0 cmxfaGRsKTsNCisJCXJldHVybiBoYW5kbGVyLT5lcnJvcjsNCisJfQ0KKw0KKwl2NGwyX2N0cmxf aGFuZGxlcl9zZXR1cCgmY3R4LT5jdHJsX2hkbCk7DQorDQorCXJldHVybiAwOw0KK30NCisNCiBz dGF0aWMgaW50IG10a19qcGVnX2VudW1fZm10KHN0cnVjdCBtdGtfanBlZ19mbXQgKm10a19qcGVn X2Zvcm1hdHMsIGludCBuLA0KIAkJCSAgICAgc3RydWN0IHY0bDJfZm10ZGVzYyAqZiwgdTMyIHR5 cGUpDQogew0KQEAgLTMzMSw2ICs0MzQsOCBAQCBzdGF0aWMgaW50IG10a19qcGVnX3NfZm10X21w bGFuZShzdHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHgsDQogCQkJCQkgICBwaXhfbXAtPnBpeGVsZm9y bWF0LCBmbXRfdHlwZSk7DQogCXFfZGF0YS0+cGl4X21wLndpZHRoID0gcGl4X21wLT53aWR0aDsN CiAJcV9kYXRhLT5waXhfbXAuaGVpZ2h0ID0gcGl4X21wLT5oZWlnaHQ7DQorCXFfZGF0YS0+ZW5j X2Nyb3BfcmVjdC53aWR0aCA9IHBpeF9tcC0+d2lkdGg7DQorCXFfZGF0YS0+ZW5jX2Nyb3BfcmVj dC5oZWlnaHQgPSBwaXhfbXAtPmhlaWdodDsNCiAJcV9kYXRhLT5waXhfbXAuY29sb3JzcGFjZSA9 IFY0TDJfQ09MT1JTUEFDRV9TUkdCOw0KIAlxX2RhdGEtPnBpeF9tcC55Y2Jjcl9lbmMgPSBWNEwy X1lDQkNSX0VOQ182MDE7DQogCXFfZGF0YS0+cGl4X21wLnhmZXJfZnVuYyA9IFY0TDJfWEZFUl9G VU5DX1NSR0I7DQpAQCAtNDA3LDYgKzUxMiwzMCBAQCBzdGF0aWMgaW50IG10a19qcGVnX3N1YnNj cmliZV9ldmVudChzdHJ1Y3QgdjRsMl9maCAqZmgsDQogCXJldHVybiB2NGwyX2N0cmxfc3Vic2Ny aWJlX2V2ZW50KGZoLCBzdWIpOw0KIH0NCiANCitzdGF0aWMgaW50IG10a19qcGVnX2VuY19nX3Nl bGVjdGlvbihzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwNCisJCQkJICAgIHN0cnVjdCB2 NGwyX3NlbGVjdGlvbiAqcykNCit7DQorCXN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCA9IG10a19q cGVnX2ZoX3RvX2N0eChwcml2KTsNCisNCisJaWYgKHMtPnR5cGUgIT0gVjRMMl9CVUZfVFlQRV9W SURFT19PVVRQVVQpDQorCQlyZXR1cm4gLUVJTlZBTDsNCisNCisJc3dpdGNoIChzLT50YXJnZXQp IHsNCisJY2FzZSBWNEwyX1NFTF9UR1RfQ1JPUDoNCisJCXMtPnIgPSBjdHgtPm91dF9xLmVuY19j cm9wX3JlY3Q7DQorCWNhc2UgVjRMMl9TRUxfVEdUX0NST1BfQk9VTkRTOg0KKwljYXNlIFY0TDJf U0VMX1RHVF9DUk9QX0RFRkFVTFQ6DQorCQlzLT5yLndpZHRoID0gY3R4LT5vdXRfcS5waXhfbXAu d2lkdGg7DQorCQlzLT5yLmhlaWdodCA9IGN0eC0+b3V0X3EucGl4X21wLmhlaWdodDsNCisJCXMt PnIubGVmdCA9IDA7DQorCQlzLT5yLnRvcCA9IDA7DQorCQlicmVhazsNCisJZGVmYXVsdDoNCisJ CXJldHVybiAtRUlOVkFMOw0KKwl9DQorCXJldHVybiAwOw0KK30NCisNCiBzdGF0aWMgaW50IG10 a19qcGVnX2RlY19nX3NlbGVjdGlvbihzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwNCiAJ CQkJICAgIHN0cnVjdCB2NGwyX3NlbGVjdGlvbiAqcykNCiB7DQpAQCAtNDM2LDYgKzU2NSw1NiBA QCBzdGF0aWMgaW50IG10a19qcGVnX2RlY19nX3NlbGVjdGlvbihzdHJ1Y3QgZmlsZSAqZmlsZSwg dm9pZCAqcHJpdiwNCiAJcmV0dXJuIDA7DQogfQ0KIA0KK3N0YXRpYyBpbnQgbXRrX2pwZWdfZW5j X3Nfc2VsZWN0aW9uKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LA0KKwkJCQkgICAgc3Ry dWN0IHY0bDJfc2VsZWN0aW9uICpzKQ0KK3sNCisJc3RydWN0IG10a19qcGVnX2N0eCAqY3R4ID0g bXRrX2pwZWdfZmhfdG9fY3R4KHByaXYpOw0KKw0KKwlpZiAocy0+dHlwZSAhPSBWNEwyX0JVRl9U WVBFX1ZJREVPX09VVFBVVCkNCisJCXJldHVybiAtRUlOVkFMOw0KKw0KKwlzd2l0Y2ggKHMtPnRh cmdldCkgew0KKwljYXNlIFY0TDJfU0VMX1RHVF9DUk9QOg0KKwkJcy0+ci5sZWZ0ID0gMDsNCisJ CXMtPnIudG9wID0gMDsNCisJCXMtPnIud2lkdGggPSBtaW4ocy0+ci53aWR0aCwgY3R4LT5vdXRf cS5waXhfbXAud2lkdGgpOw0KKwkJcy0+ci5oZWlnaHQgPSBtaW4ocy0+ci5oZWlnaHQsIGN0eC0+ b3V0X3EucGl4X21wLmhlaWdodCk7DQorCQljdHgtPm91dF9xLmVuY19jcm9wX3JlY3QgPSBzLT5y Ow0KKwkJYnJlYWs7DQorCWRlZmF1bHQ6DQorCQlyZXR1cm4gLUVJTlZBTDsNCisJfQ0KKw0KKwly ZXR1cm4gMDsNCit9DQorDQorc3RhdGljIGNvbnN0IHN0cnVjdCB2NGwyX2lvY3RsX29wcyBtdGtf anBlZ19lbmNfaW9jdGxfb3BzID0gew0KKwkudmlkaW9jX3F1ZXJ5Y2FwICAgICAgICAgICAgICAg ID0gbXRrX2pwZWdfcXVlcnljYXAsDQorCS52aWRpb2NfZW51bV9mbXRfdmlkX2NhcAk9IG10a19q cGVnX2VudW1fZm10X3ZpZF9jYXAsDQorCS52aWRpb2NfZW51bV9mbXRfdmlkX291dAk9IG10a19q cGVnX2VudW1fZm10X3ZpZF9vdXQsDQorCS52aWRpb2NfdHJ5X2ZtdF92aWRfY2FwX21wbGFuZQk9 IG10a19qcGVnX3RyeV9mbXRfdmlkX2NhcF9tcGxhbmUsDQorCS52aWRpb2NfdHJ5X2ZtdF92aWRf b3V0X21wbGFuZQk9IG10a19qcGVnX3RyeV9mbXRfdmlkX291dF9tcGxhbmUsDQorCS52aWRpb2Nf Z19mbXRfdmlkX2NhcF9tcGxhbmUgICAgPSBtdGtfanBlZ19nX2ZtdF92aWRfbXBsYW5lLA0KKwku dmlkaW9jX2dfZm10X3ZpZF9vdXRfbXBsYW5lICAgID0gbXRrX2pwZWdfZ19mbXRfdmlkX21wbGFu ZSwNCisJLnZpZGlvY19zX2ZtdF92aWRfY2FwX21wbGFuZSAgICA9IG10a19qcGVnX3NfZm10X3Zp ZF9jYXBfbXBsYW5lLA0KKwkudmlkaW9jX3NfZm10X3ZpZF9vdXRfbXBsYW5lICAgID0gbXRrX2pw ZWdfc19mbXRfdmlkX291dF9tcGxhbmUsDQorCS52aWRpb2NfcWJ1ZiAgICAgICAgICAgICAgICAg ICAgPSB2NGwyX20ybV9pb2N0bF9xYnVmLA0KKwkudmlkaW9jX3N1YnNjcmliZV9ldmVudCAgICAg ICAgID0gbXRrX2pwZWdfc3Vic2NyaWJlX2V2ZW50LA0KKwkudmlkaW9jX2dfc2VsZWN0aW9uCQk9 IG10a19qcGVnX2VuY19nX3NlbGVjdGlvbiwNCisJLnZpZGlvY19zX3NlbGVjdGlvbgkJPSBtdGtf anBlZ19lbmNfc19zZWxlY3Rpb24sDQorDQorCS52aWRpb2NfY3JlYXRlX2J1ZnMJCT0gdjRsMl9t Mm1faW9jdGxfY3JlYXRlX2J1ZnMsDQorCS52aWRpb2NfcHJlcGFyZV9idWYJCT0gdjRsMl9tMm1f aW9jdGxfcHJlcGFyZV9idWYsDQorCS52aWRpb2NfcmVxYnVmcyAgICAgICAgICAgICAgICAgPSB2 NGwyX20ybV9pb2N0bF9yZXFidWZzLA0KKwkudmlkaW9jX3F1ZXJ5YnVmICAgICAgICAgICAgICAg ID0gdjRsMl9tMm1faW9jdGxfcXVlcnlidWYsDQorCS52aWRpb2NfZHFidWYgICAgICAgICAgICAg ICAgICAgPSB2NGwyX20ybV9pb2N0bF9kcWJ1ZiwNCisJLnZpZGlvY19leHBidWYgICAgICAgICAg ICAgICAgICA9IHY0bDJfbTJtX2lvY3RsX2V4cGJ1ZiwNCisJLnZpZGlvY19zdHJlYW1vbiAgICAg ICAgICAgICAgICA9IHY0bDJfbTJtX2lvY3RsX3N0cmVhbW9uLA0KKwkudmlkaW9jX3N0cmVhbW9m ZiAgICAgICAgICAgICAgID0gdjRsMl9tMm1faW9jdGxfc3RyZWFtb2ZmLA0KKw0KKwkudmlkaW9j X3Vuc3Vic2NyaWJlX2V2ZW50CT0gdjRsMl9ldmVudF91bnN1YnNjcmliZSwNCit9Ow0KKw0KIHN0 YXRpYyBjb25zdCBzdHJ1Y3QgdjRsMl9pb2N0bF9vcHMgbXRrX2pwZWdfZGVjX2lvY3RsX29wcyA9 IHsNCiAJLnZpZGlvY19xdWVyeWNhcCAgICAgICAgICAgICAgICA9IG10a19qcGVnX3F1ZXJ5Y2Fw LA0KIAkudmlkaW9jX2VudW1fZm10X3ZpZF9jYXAJPSBtdGtfanBlZ19lbnVtX2ZtdF92aWRfY2Fw LA0KQEAgLTUwMSwxNSArNjgwLDIyIEBAIHN0YXRpYyBpbnQgbXRrX2pwZWdfYnVmX3ByZXBhcmUo c3RydWN0IHZiMl9idWZmZXIgKnZiKQ0KIHsNCiAJc3RydWN0IG10a19qcGVnX2N0eCAqY3R4ID0g dmIyX2dldF9kcnZfcHJpdih2Yi0+dmIyX3F1ZXVlKTsNCiAJc3RydWN0IG10a19qcGVnX3FfZGF0 YSAqcV9kYXRhID0gTlVMTDsNCisJc3RydWN0IHY0bDJfcGxhbmVfcGl4X2Zvcm1hdCBwbGFuZV9m bXQgPSB7fTsNCiAJaW50IGk7DQogDQogCXFfZGF0YSA9IG10a19qcGVnX2dldF9xX2RhdGEoY3R4 LCB2Yi0+dmIyX3F1ZXVlLT50eXBlKTsNCiAJaWYgKCFxX2RhdGEpDQogCQlyZXR1cm4gLUVJTlZB TDsNCiANCi0JZm9yIChpID0gMDsgaSA8IHFfZGF0YS0+Zm10LT5jb2xwbGFuZXM7IGkrKykNCi0J CXZiMl9zZXRfcGxhbmVfcGF5bG9hZCh2YiwgaSwNCi0JCQkJICAgICAgcV9kYXRhLT5waXhfbXAu cGxhbmVfZm10W2ldLnNpemVpbWFnZSk7DQorCWZvciAoaSA9IDA7IGkgPCBxX2RhdGEtPmZtdC0+ Y29scGxhbmVzOyBpKyspIHsNCisJCXBsYW5lX2ZtdCA9IHFfZGF0YS0+cGl4X21wLnBsYW5lX2Zt dFtpXTsNCisJCWlmIChjdHgtPmVuYWJsZV9leGlmICYmDQorCQkgICAgcV9kYXRhLT5mbXQtPmZv dXJjYyA9PSBWNEwyX1BJWF9GTVRfSlBFRykNCisJCQl2YjJfc2V0X3BsYW5lX3BheWxvYWQodmIs IGksIHBsYW5lX2ZtdC5zaXplaW1hZ2UgKw0KKwkJCQkJICAgICAgTVRLX0pQRUdfTUFYX0VYSUZf U0laRSk7DQorCQllbHNlDQorCQkJdmIyX3NldF9wbGFuZV9wYXlsb2FkKHZiLCBpLCAgcGxhbmVf Zm10LnNpemVpbWFnZSk7DQorCX0NCiANCiAJcmV0dXJuIDA7DQogfQ0KQEAgLTU3Miw2ICs3NTgs MTcgQEAgc3RhdGljIHZvaWQgbXRrX2pwZWdfc2V0X3F1ZXVlX2RhdGEoc3RydWN0IG10a19qcGVn X2N0eCAqY3R4LA0KIAkJIHBhcmFtLT5kZWNfdywgcGFyYW0tPmRlY19oKTsNCiB9DQogDQorc3Rh dGljIHZvaWQgbXRrX2pwZWdfZW5jX2J1Zl9xdWV1ZShzdHJ1Y3QgdmIyX2J1ZmZlciAqdmIpDQor ew0KKwlzdHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHggPSB2YjJfZ2V0X2Rydl9wcml2KHZiLT52YjJf cXVldWUpOw0KKwlzdHJ1Y3QgbXRrX2pwZWdfZGV2ICpqcGVnID0gY3R4LT5qcGVnOw0KKw0KKwl2 NGwyX2RiZygyLCBkZWJ1ZywgJmpwZWctPnY0bDJfZGV2LCAiKCVkKSBidWZfcSBpZD0lZCwgdmI9 JXBcbiIsDQorCQkgdmItPnZiMl9xdWV1ZS0+dHlwZSwgdmItPmluZGV4LCB2Yik7DQorDQorCXY0 bDJfbTJtX2J1Zl9xdWV1ZShjdHgtPmZoLm0ybV9jdHgsIHRvX3ZiMl92NGwyX2J1ZmZlcih2Yikp Ow0KK30NCisNCiBzdGF0aWMgdm9pZCBtdGtfanBlZ19kZWNfYnVmX3F1ZXVlKHN0cnVjdCB2YjJf YnVmZmVyICp2YikNCiB7DQogCXN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCA9IHZiMl9nZXRfZHJ2 X3ByaXYodmItPnZiMl9xdWV1ZSk7DQpAQCAtNjIwLDYgKzgxNywxNSBAQCBzdGF0aWMgc3RydWN0 IHZiMl92NGwyX2J1ZmZlciAqbXRrX2pwZWdfYnVmX3JlbW92ZShzdHJ1Y3QgbXRrX2pwZWdfY3R4 ICpjdHgsDQogCQlyZXR1cm4gdjRsMl9tMm1fZHN0X2J1Zl9yZW1vdmUoY3R4LT5maC5tMm1fY3R4 KTsNCiB9DQogDQorc3RhdGljIHZvaWQgbXRrX2pwZWdfZW5jX3N0b3Bfc3RyZWFtaW5nKHN0cnVj dCB2YjJfcXVldWUgKnEpDQorew0KKwlzdHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHggPSB2YjJfZ2V0 X2Rydl9wcml2KHEpOw0KKwlzdHJ1Y3QgdmIyX3Y0bDJfYnVmZmVyICp2YjsNCisNCisJd2hpbGUg KCh2YiA9IG10a19qcGVnX2J1Zl9yZW1vdmUoY3R4LCBxLT50eXBlKSkpDQorCQl2NGwyX20ybV9i dWZfZG9uZSh2YiwgVkIyX0JVRl9TVEFURV9FUlJPUik7DQorfQ0KKw0KIHN0YXRpYyB2b2lkIG10 a19qcGVnX2RlY19zdG9wX3N0cmVhbWluZyhzdHJ1Y3QgdmIyX3F1ZXVlICpxKQ0KIHsNCiAJc3Ry dWN0IG10a19qcGVnX2N0eCAqY3R4ID0gdmIyX2dldF9kcnZfcHJpdihxKTsNCkBAIC02NTUsNiAr ODYxLDE1IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdmIyX29wcyBtdGtfanBlZ19kZWNfcW9wcyA9 IHsNCiAJLnN0b3Bfc3RyZWFtaW5nICAgICA9IG10a19qcGVnX2RlY19zdG9wX3N0cmVhbWluZywN CiB9Ow0KIA0KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdmIyX29wcyBtdGtfanBlZ19lbmNfcW9wcyA9 IHsNCisJLnF1ZXVlX3NldHVwICAgICAgICA9IG10a19qcGVnX3F1ZXVlX3NldHVwLA0KKwkuYnVm X3ByZXBhcmUgICAgICAgID0gbXRrX2pwZWdfYnVmX3ByZXBhcmUsDQorCS5idWZfcXVldWUgICAg ICAgICAgPSBtdGtfanBlZ19lbmNfYnVmX3F1ZXVlLA0KKwkud2FpdF9wcmVwYXJlICAgICAgID0g dmIyX29wc193YWl0X3ByZXBhcmUsDQorCS53YWl0X2ZpbmlzaCAgICAgICAgPSB2YjJfb3BzX3dh aXRfZmluaXNoLA0KKwkuc3RvcF9zdHJlYW1pbmcgICAgID0gbXRrX2pwZWdfZW5jX3N0b3Bfc3Ry ZWFtaW5nLA0KK307DQorDQogc3RhdGljIHZvaWQgbXRrX2pwZWdfc2V0X2RlY19zcmMoc3RydWN0 IG10a19qcGVnX2N0eCAqY3R4LA0KIAkJCQkgc3RydWN0IHZiMl9idWZmZXIgKnNyY19idWYsDQog CQkJCSBzdHJ1Y3QgbXRrX2pwZWdfYnMgKmJzKQ0KQEAgLTY5Miw2ICs5MDcsNTAgQEAgc3RhdGlj IGludCBtdGtfanBlZ19zZXRfZGVjX2RzdChzdHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHgsDQogCXJl dHVybiAwOw0KIH0NCiANCitzdGF0aWMgdm9pZCBtdGtfanBlZ19lbmNfZGV2aWNlX3J1bih2b2lk ICpwcml2KQ0KK3sNCisJc3RydWN0IG10a19qcGVnX2N0eCAqY3R4ID0gcHJpdjsNCisJc3RydWN0 IG10a19qcGVnX2RldiAqanBlZyA9IGN0eC0+anBlZzsNCisJc3RydWN0IHZiMl92NGwyX2J1ZmZl ciAqc3JjX2J1ZiwgKmRzdF9idWY7DQorCWVudW0gdmIyX2J1ZmZlcl9zdGF0ZSBidWZfc3RhdGUg PSBWQjJfQlVGX1NUQVRFX0VSUk9SOw0KKwl1bnNpZ25lZCBsb25nIGZsYWdzOw0KKwlzdHJ1Y3Qg bXRrX2pwZWdfc3JjX2J1ZiAqanBlZ19zcmNfYnVmOw0KKwlpbnQgcmV0Ow0KKw0KKwlzcmNfYnVm ID0gdjRsMl9tMm1fbmV4dF9zcmNfYnVmKGN0eC0+ZmgubTJtX2N0eCk7DQorCWRzdF9idWYgPSB2 NGwyX20ybV9uZXh0X2RzdF9idWYoY3R4LT5maC5tMm1fY3R4KTsNCisJanBlZ19zcmNfYnVmID0g bXRrX2pwZWdfdmIyX3RvX3NyY2J1Zigmc3JjX2J1Zi0+dmIyX2J1Zik7DQorDQorCXJldCA9IHBt X3J1bnRpbWVfZ2V0X3N5bmMoanBlZy0+ZGV2KTsNCisJaWYgKHJldCA8IDApDQorCQlnb3RvIGVu Y19lbmQ7DQorDQorCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmanBlZy0+am9iX3RpbWVvdXRfd29y aywNCisJCQkgICAgICBtc2Vjc190b19qaWZmaWVzKE1US19KUEVHX0hXX1RJTUVPVVRfTVNFQykp Ow0KKw0KKwlzcGluX2xvY2tfaXJxc2F2ZSgmanBlZy0+aHdfbG9jaywgZmxhZ3MpOw0KKw0KKwkv Kg0KKwkgKiBSZXNldHRpbmcgdGhlIGhhcmR3YXJlIGV2ZXJ5IGZyYW1lIGlzIHRvIGVuc3VyZSB0 aGF0IGFsbCB0aGUNCisJICogcmVnaXN0ZXJzIGFyZSBjbGVhcmVkLiBUaGlzIGlzIGEgaGFyZHdh cmUgcmVxdWlyZW1lbnQuDQorCSAqLw0KKwltdGtfanBlZ19lbmNfcmVzZXQoanBlZy0+cmVnX2Jh c2UpOw0KKw0KKwltdGtfanBlZ19zZXRfZW5jX3NyYyhjdHgsIGpwZWctPnJlZ19iYXNlLCAmc3Jj X2J1Zi0+dmIyX2J1Zik7DQorCW10a19qcGVnX3NldF9lbmNfZHN0KGN0eCwganBlZy0+cmVnX2Jh c2UsICZkc3RfYnVmLT52YjJfYnVmKTsNCisJbXRrX2pwZWdfc2V0X2VuY19wYXJhbXMoY3R4LCBq cGVnLT5yZWdfYmFzZSk7DQorCW10a19qcGVnX2VuY19zdGFydChqcGVnLT5yZWdfYmFzZSk7DQor CXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmpwZWctPmh3X2xvY2ssIGZsYWdzKTsNCisJcmV0dXJu Ow0KKw0KK2VuY19lbmQ6DQorCXY0bDJfbTJtX3NyY19idWZfcmVtb3ZlKGN0eC0+ZmgubTJtX2N0 eCk7DQorCXY0bDJfbTJtX2RzdF9idWZfcmVtb3ZlKGN0eC0+ZmgubTJtX2N0eCk7DQorCXY0bDJf bTJtX2J1Zl9kb25lKHNyY19idWYsIGJ1Zl9zdGF0ZSk7DQorCXY0bDJfbTJtX2J1Zl9kb25lKGRz dF9idWYsIGJ1Zl9zdGF0ZSk7DQorCXY0bDJfbTJtX2pvYl9maW5pc2goanBlZy0+bTJtX2Rldiwg Y3R4LT5maC5tMm1fY3R4KTsNCit9DQorDQogc3RhdGljIHZvaWQgbXRrX2pwZWdfZGVjX2Rldmlj ZV9ydW4odm9pZCAqcHJpdikNCiB7DQogCXN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCA9IHByaXY7 DQpAQCAtNzUwLDYgKzEwMDksMTAgQEAgc3RhdGljIGludCBtdGtfanBlZ19kZWNfam9iX3JlYWR5 KHZvaWQgKnByaXYpDQogCXJldHVybiAoY3R4LT5zdGF0ZSA9PSBNVEtfSlBFR19SVU5OSU5HKSA/ IDEgOiAwOw0KIH0NCiANCitzdGF0aWMgY29uc3Qgc3RydWN0IHY0bDJfbTJtX29wcyBtdGtfanBl Z19lbmNfbTJtX29wcyA9IHsNCisJLmRldmljZV9ydW4gPSBtdGtfanBlZ19lbmNfZGV2aWNlX3J1 biwNCit9Ow0KKw0KIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdjRsMl9tMm1fb3BzIG10a19qcGVnX2Rl Y19tMm1fb3BzID0gew0KIAkuZGV2aWNlX3J1biA9IG10a19qcGVnX2RlY19kZXZpY2VfcnVuLA0K IAkuam9iX3JlYWR5ICA9IG10a19qcGVnX2RlY19qb2JfcmVhZHksDQpAQCAtODA4LDYgKzEwNzEs NTQgQEAgc3RhdGljIHZvaWQgbXRrX2pwZWdfY2xrX29mZihzdHJ1Y3QgbXRrX2pwZWdfZGV2ICpq cGVnKQ0KIAltdGtfc21pX2xhcmJfcHV0KGpwZWctPmxhcmIpOw0KIH0NCiANCitzdGF0aWMgaXJx cmV0dXJuX3QgbXRrX2pwZWdfZW5jX2RvbmUoc3RydWN0IG10a19qcGVnX2RldiAqanBlZykNCit7 DQorCXN0cnVjdCBtdGtfanBlZ19jdHggKmN0eDsNCisJc3RydWN0IHZiMl92NGwyX2J1ZmZlciAq c3JjX2J1ZiwgKmRzdF9idWY7DQorCWVudW0gdmIyX2J1ZmZlcl9zdGF0ZSBidWZfc3RhdGUgPSBW QjJfQlVGX1NUQVRFX0VSUk9SOw0KKwl1MzIgcmVzdWx0X3NpemU7DQorDQorCWN0eCA9IHY0bDJf bTJtX2dldF9jdXJyX3ByaXYoanBlZy0+bTJtX2Rldik7DQorCWlmICghY3R4KSB7DQorCQl2NGwy X2VycigmanBlZy0+djRsMl9kZXYsICJDb250ZXh0IGlzIE5VTExcbiIpOw0KKwkJcmV0dXJuIElS UV9IQU5ETEVEOw0KKwl9DQorDQorCXNyY19idWYgPSB2NGwyX20ybV9zcmNfYnVmX3JlbW92ZShj dHgtPmZoLm0ybV9jdHgpOw0KKwlkc3RfYnVmID0gdjRsMl9tMm1fZHN0X2J1Zl9yZW1vdmUoY3R4 LT5maC5tMm1fY3R4KTsNCisNCisJcmVzdWx0X3NpemUgPSBtdGtfanBlZ19lbmNfZ2V0X2ZpbGVf c2l6ZShqcGVnLT5yZWdfYmFzZSk7DQorCXZiMl9zZXRfcGxhbmVfcGF5bG9hZCgmZHN0X2J1Zi0+ dmIyX2J1ZiwgMCwgcmVzdWx0X3NpemUpOw0KKw0KKwlidWZfc3RhdGUgPSBWQjJfQlVGX1NUQVRF X0RPTkU7DQorDQorCXY0bDJfbTJtX2J1Zl9kb25lKHNyY19idWYsIGJ1Zl9zdGF0ZSk7DQorCXY0 bDJfbTJtX2J1Zl9kb25lKGRzdF9idWYsIGJ1Zl9zdGF0ZSk7DQorCXY0bDJfbTJtX2pvYl9maW5p c2goanBlZy0+bTJtX2RldiwgY3R4LT5maC5tMm1fY3R4KTsNCisJcG1fcnVudGltZV9wdXQoY3R4 LT5qcGVnLT5kZXYpOw0KKwlyZXR1cm4gSVJRX0hBTkRMRUQ7DQorfQ0KKw0KK3N0YXRpYyBpcnFy ZXR1cm5fdCBtdGtfanBlZ19lbmNfaXJxKGludCBpcnEsIHZvaWQgKnByaXYpDQorew0KKwlzdHJ1 Y3QgbXRrX2pwZWdfZGV2ICpqcGVnID0gcHJpdjsNCisJdTMyIGlycV9zdGF0dXM7DQorCWlycXJl dHVybl90IHJldCA9IElSUV9OT05FOw0KKw0KKwljYW5jZWxfZGVsYXllZF93b3JrKCZqcGVnLT5q b2JfdGltZW91dF93b3JrKTsNCisNCisJaXJxX3N0YXR1cyA9IHJlYWRsKGpwZWctPnJlZ19iYXNl ICsgSlBFR19FTkNfSU5UX1NUUykgJg0KKwkJICAgICBKUEVHX0VOQ19JTlRfU1RBVFVTX01BU0tf QUxMSVJROw0KKwlpZiAoaXJxX3N0YXR1cykNCisJCXdyaXRlbCgwLCBqcGVnLT5yZWdfYmFzZSAr IEpQRUdfRU5DX0lOVF9TVFMpOw0KKw0KKwlpZiAoIShpcnFfc3RhdHVzICYgSlBFR19FTkNfSU5U X1NUQVRVU19ET05FKSkNCisJCXJldHVybiByZXQ7DQorDQorCXJldCA9IG10a19qcGVnX2VuY19k b25lKGpwZWcpOw0KKwlyZXR1cm4gcmV0Ow0KK30NCisNCiBzdGF0aWMgaXJxcmV0dXJuX3QgbXRr X2pwZWdfZGVjX2lycShpbnQgaXJxLCB2b2lkICpwcml2KQ0KIHsNCiAJc3RydWN0IG10a19qcGVn X2RldiAqanBlZyA9IHByaXY7DQpAQCAtODYwLDYgKzExNzEsNyBAQCBzdGF0aWMgdm9pZCBtdGtf anBlZ19zZXRfZGVmYXVsdF9wYXJhbXMoc3RydWN0IG10a19qcGVnX2N0eCAqY3R4KQ0KIAlzdHJ1 Y3QgbXRrX2pwZWdfcV9kYXRhICpxID0gJmN0eC0+b3V0X3E7DQogCXN0cnVjdCBtdGtfanBlZ19k ZXYgKmpwZWcgPSBjdHgtPmpwZWc7DQogDQorCWN0eC0+ZmguY3RybF9oYW5kbGVyID0gJmN0eC0+ Y3RybF9oZGw7DQogCXEtPnBpeF9tcC5jb2xvcnNwYWNlID0gVjRMMl9DT0xPUlNQQUNFX1NSR0I7 DQogCXEtPnBpeF9tcC55Y2Jjcl9lbmMgPSBWNEwyX1lDQkNSX0VOQ182MDE7DQogCXEtPnBpeF9t cC5xdWFudGl6YXRpb24gPSBWNEwyX1FVQU5USVpBVElPTl9GVUxMX1JBTkdFOw0KQEAgLTkxNiw2 ICsxMjI4LDE1IEBAIHN0YXRpYyBpbnQgbXRrX2pwZWdfb3BlbihzdHJ1Y3QgZmlsZSAqZmlsZSkN CiAJCWdvdG8gZXJyb3I7DQogCX0NCiANCisJaWYgKGpwZWctPnZhcmlhbnQtPmNhcF9xX2RlZmF1 bHRfZm91cmNjID09IFY0TDJfUElYX0ZNVF9KUEVHKSB7DQorCQlyZXQgPSBtdGtfanBlZ19lbmNf Y3RybHNfc2V0dXAoY3R4KTsNCisJCWlmIChyZXQpIHsNCisJCQl2NGwyX2VycigmanBlZy0+djRs Ml9kZXYsICJGYWlsZWQgdG8gc2V0dXAganBlZyBlbmMgY29udHJvbHNcbiIpOw0KKwkJCWdvdG8g ZXJyb3I7DQorCQl9DQorCX0gZWxzZSB7DQorCQl2NGwyX2N0cmxfaGFuZGxlcl9pbml0KCZjdHgt PmN0cmxfaGRsLCAwKTsNCisJfQ0KIAltdGtfanBlZ19zZXRfZGVmYXVsdF9wYXJhbXMoY3R4KTsN CiAJbXV0ZXhfdW5sb2NrKCZqcGVnLT5sb2NrKTsNCiAJcmV0dXJuIDA7DQpAQCAtOTM2LDYgKzEy NTcsNyBAQCBzdGF0aWMgaW50IG10a19qcGVnX3JlbGVhc2Uoc3RydWN0IGZpbGUgKmZpbGUpDQog DQogCW11dGV4X2xvY2soJmpwZWctPmxvY2spOw0KIAl2NGwyX20ybV9jdHhfcmVsZWFzZShjdHgt PmZoLm0ybV9jdHgpOw0KKwl2NGwyX2N0cmxfaGFuZGxlcl9mcmVlKCZjdHgtPmN0cmxfaGRsKTsN CiAJdjRsMl9maF9kZWwoJmN0eC0+ZmgpOw0KIAl2NGwyX2ZoX2V4aXQoJmN0eC0+ZmgpOw0KIAlr ZnJlZShjdHgpOw0KQEAgLTEyMDYsNiArMTUyOCwxOSBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IG10 a19qcGVnX3ZhcmlhbnQgbXQ4MTczX2pwZWdfZHJ2ZGF0YSA9IHsNCiAJLmNhcF9xX2RlZmF1bHRf Zm91cmNjID0gVjRMMl9QSVhfRk1UX1lVVjQyME0sDQogfTsNCiANCitzdGF0aWMgY29uc3Qgc3Ry dWN0IG10a19qcGVnX3ZhcmlhbnQgbXRrX2pwZWdfZHJ2ZGF0YSA9IHsNCisJLmZvcm1hdHMgPSBt dGtfanBlZ19lbmNfZm9ybWF0cywNCisJLm51bV9mb3JtYXRzID0gTVRLX0pQRUdfRU5DX05VTV9G T1JNQVRTLA0KKwkucW9wcyA9ICZtdGtfanBlZ19lbmNfcW9wcywNCisJLmlycV9oYW5kbGVyID0g bXRrX2pwZWdfZW5jX2lycSwNCisJLmh3X3Jlc2V0ID0gbXRrX2pwZWdfZW5jX3Jlc2V0LA0KKwku bTJtX29wcyA9ICZtdGtfanBlZ19lbmNfbTJtX29wcywNCisJLmRldl9uYW1lID0gIm10ay1qcGVn LWVuYyIsDQorCS5pb2N0bF9vcHMgPSAmbXRrX2pwZWdfZW5jX2lvY3RsX29wcywNCisJLm91dF9x X2RlZmF1bHRfZm91cmNjID0gVjRMMl9QSVhfRk1UX1lVWVYsDQorCS5jYXBfcV9kZWZhdWx0X2Zv dXJjYyA9IFY0TDJfUElYX0ZNVF9KUEVHLA0KK307DQorDQogc3RhdGljIGNvbnN0IHN0cnVjdCBv Zl9kZXZpY2VfaWQgbXRrX2pwZWdfbWF0Y2hbXSA9IHsNCiAJew0KIAkJLmNvbXBhdGlibGUgPSAi bWVkaWF0ZWssbXQ4MTczLWpwZ2RlYyIsDQpAQCAtMTIxNSw2ICsxNTUwLDEwIEBAIHN0YXRpYyBj b25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIG10a19qcGVnX21hdGNoW10gPSB7DQogCQkuY29tcGF0 aWJsZSA9ICJtZWRpYXRlayxtdDI3MDEtanBnZGVjIiwNCiAJCS5kYXRhID0gJm10ODE3M19qcGVn X2RydmRhdGEsDQogCX0sDQorCXsNCisJCS5jb21wYXRpYmxlID0gIm1lZGlhdGVrLG10ay1qcGdl bmMiLA0KKwkJLmRhdGEgPSAmbXRrX2pwZWdfZHJ2ZGF0YSwNCisJfSwNCiAJe30sDQogfTsNCiAN CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1qcGVnL210a19qcGVnX2Nv cmUuaCBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfY29yZS5oDQpp bmRleCAzZWQ2Yzc0Y2E1ZmIuLjc1MzU2YTdkZTY5ZSAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvbWVk aWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfY29yZS5oDQorKysgYi9kcml2ZXJzL21lZGlh L3BsYXRmb3JtL210ay1qcGVnL210a19qcGVnX2NvcmUuaA0KQEAgLTMsNiArMyw3IEBADQogICog Q29weXJpZ2h0IChjKSAyMDE2IE1lZGlhVGVrIEluYy4NCiAgKiBBdXRob3I6IE1pbmcgSHNpdSBU c2FpIDxtaW5naHNpdS50c2FpQG1lZGlhdGVrLmNvbT4NCiAgKiAgICAgICAgIFJpY2sgQ2hhbmcg PHJpY2suY2hhbmdAbWVkaWF0ZWsuY29tPg0KKyAqICAgICAgICAgWGlhIEppYW5nIDx4aWEuamlh bmdAbWVkaWF0ZWsuY29tPg0KICAqLw0KIA0KICNpZm5kZWYgX01US19KUEVHX0NPUkVfSA0KQEAg LTEyLDYgKzEzLDggQEANCiAjaW5jbHVkZSA8bWVkaWEvdjRsMi1jdHJscy5oPg0KICNpbmNsdWRl IDxtZWRpYS92NGwyLWRldmljZS5oPg0KICNpbmNsdWRlIDxtZWRpYS92NGwyLWZoLmg+DQorI2lu Y2x1ZGUgPG1lZGlhL3Y0bDItbWVtMm1lbS5oPg0KKyNpbmNsdWRlIDxtZWRpYS92NGwyLWlvY3Rs Lmg+DQogDQogI2RlZmluZSBNVEtfSlBFR19OQU1FCQkibXRrLWpwZWciDQogDQpAQCAtMjksNiAr MzIsOCBAQA0KIA0KICNkZWZpbmUgTVRLX0pQRUdfSFdfVElNRU9VVF9NU0VDIDEwMDANCiANCisj ZGVmaW5lIE1US19KUEVHX01BWF9FWElGX1NJWkUJKDY0ICogMTAyNCkNCisNCiAvKioNCiAgKiBl bnVtIG10a19qcGVnX2N0eF9zdGF0ZSAtIHN0YXRlcyBvZiB0aGUgY29udGV4dCBzdGF0ZSBtYWNo aW5lDQogICogQE1US19KUEVHX0lOSVQ6CQljdXJyZW50IHN0YXRlIGlzIGluaXRpYWxpemVkDQpA QCAtMTA0LDYgKzEwOSw3IEBAIHN0cnVjdCBtdGtfanBlZ19kZXYgew0KIC8qKg0KICAqIHN0cnVj dCBqcGVnX2ZtdCAtIGRyaXZlcidzIGludGVybmFsIGNvbG9yIGZvcm1hdCBkYXRhDQogICogQGZv dXJjYzoJdGhlIGZvdXJjYyBjb2RlLCAwIGlmIG5vdCBhcHBsaWNhYmxlDQorICogQGh3X2Zvcm1h dDoJaGFyZHdhcmUgZm9ybWF0IHZhbHVlDQogICogQGhfc2FtcGxlOglob3Jpem9udGFsIHNhbXBs ZSBjb3VudCBvZiBwbGFuZSBpbiA0ICogNCBwaXhlbCBpbWFnZQ0KICAqIEB2X3NhbXBsZToJdmVy dGljYWwgc2FtcGxlIGNvdW50IG9mIHBsYW5lIGluIDQgKiA0IHBpeGVsIGltYWdlDQogICogQGNv bHBsYW5lczoJbnVtYmVyIG9mIGNvbG9yIHBsYW5lcyAoMSBmb3IgcGFja2VkIGZvcm1hdHMpDQpA QCAtMTEzLDYgKzExOSw3IEBAIHN0cnVjdCBtdGtfanBlZ19kZXYgew0KICAqLw0KIHN0cnVjdCBt dGtfanBlZ19mbXQgew0KIAl1MzIJZm91cmNjOw0KKwl1MzIJaHdfZm9ybWF0Ow0KIAlpbnQJaF9z YW1wbGVbVklERU9fTUFYX1BMQU5FU107DQogCWludAl2X3NhbXBsZVtWSURFT19NQVhfUExBTkVT XTsNCiAJaW50CWNvbHBsYW5lczsNCkBAIC0xMjUsMTAgKzEzMiwxMiBAQCBzdHJ1Y3QgbXRrX2pw ZWdfZm10IHsNCiAgKiBtdGtfanBlZ19xX2RhdGEgLSBwYXJhbWV0ZXJzIG9mIG9uZSBxdWV1ZQ0K ICAqIEBmbXQ6CSAgZHJpdmVyLXNwZWNpZmljIGZvcm1hdCBvZiB0aGlzIHF1ZXVlDQogICogQHBp eF9tcDoJICBtdWx0aXBsYW5hciBmb3JtYXQNCisgKiBAZW5jX2Nyb3BfcmVjdDoJanBlZyBlbmNv ZGVyIGNyb3AgaW5mb3JtYXRpb24NCiAgKi8NCiBzdHJ1Y3QgbXRrX2pwZWdfcV9kYXRhIHsNCiAJ c3RydWN0IG10a19qcGVnX2ZtdAkqZm10Ow0KIAlzdHJ1Y3QgdjRsMl9waXhfZm9ybWF0X21wbGFu ZSBwaXhfbXA7DQorCXN0cnVjdCB2NGwyX3JlY3QgZW5jX2Nyb3BfcmVjdDsNCiB9Ow0KIA0KIC8q Kg0KQEAgLTEzOCw2ICsxNDcsMTAgQEAgc3RydWN0IG10a19qcGVnX3FfZGF0YSB7DQogICogQGNh cF9xOgkJZGVzdGluYXRpb24gKGNhcHR1cmUpIHF1ZXVlIHF1ZXVlIGluZm9ybWF0aW9uDQogICog QGZoOgkJCVY0TDIgZmlsZSBoYW5kbGUNCiAgKiBAc3RhdGU6CQlzdGF0ZSBvZiB0aGUgY29udGV4 dA0KKyAqIEBlbmFibGVfZXhpZjoJZW5hYmxlIGV4aWYgbW9kZSBvZiBqcGVnIGVuY29kZXINCisg KiBAZW5jX3F1YWxpdHk6CWpwZWcgZW5jb2RlciBxdWFsaXR5DQorICogQHJlc3RhcnRfaW50ZXJ2 YWw6CWpwZWcgZW5jb2RlciByZXN0YXJ0IGludGVydmFsDQorICogQGN0cmxfaGRsOgkJY29udHJv bHMgaGFuZGxlcg0KICAqLw0KIHN0cnVjdCBtdGtfanBlZ19jdHggew0KIAlzdHJ1Y3QgbXRrX2pw ZWdfZGV2CQkqanBlZzsNCkBAIC0xNDUsNiArMTU4LDEwIEBAIHN0cnVjdCBtdGtfanBlZ19jdHgg ew0KIAlzdHJ1Y3QgbXRrX2pwZWdfcV9kYXRhCQljYXBfcTsNCiAJc3RydWN0IHY0bDJfZmgJCQlm aDsNCiAJZW51bSBtdGtfanBlZ19jdHhfc3RhdGUJCXN0YXRlOw0KKwlib29sIGVuYWJsZV9leGlm Ow0KKwl1OCBlbmNfcXVhbGl0eTsNCisJdTggcmVzdGFydF9pbnRlcnZhbDsNCisJc3RydWN0IHY0 bDJfY3RybF9oYW5kbGVyIGN0cmxfaGRsOw0KIH07DQogDQogI2VuZGlmIC8qIF9NVEtfSlBFR19D T1JFX0ggKi8NCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1qcGVnL210 a19qcGVnX2VuY19ody5jIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9tdGstanBlZy9tdGtfanBl Z19lbmNfaHcuYw0KbmV3IGZpbGUgbW9kZSAxMDA2NDQNCmluZGV4IDAwMDAwMDAwMDAwMC4uMWNm MDM3YmY3MmRkDQotLS0gL2Rldi9udWxsDQorKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210 ay1qcGVnL210a19qcGVnX2VuY19ody5jDQpAQCAtMCwwICsxLDE1NCBAQA0KKy8vIFNQRFgtTGlj ZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkNCisvKg0KKyAqIENvcHlyaWdodCAoYykgMjAx OSBNZWRpYVRlayBJbmMuDQorICogQXV0aG9yOiBYaWEgSmlhbmcgPHhpYS5qaWFuZ0BtZWRpYXRl ay5jb20+DQorICoNCisgKi8NCisNCisjaW5jbHVkZSA8bGludXgvaW8uaD4NCisjaW5jbHVkZSA8 bGludXgva2VybmVsLmg+DQorI2luY2x1ZGUgPG1lZGlhL3ZpZGVvYnVmMi1jb3JlLmg+DQorI2lu Y2x1ZGUgPG1lZGlhL3ZpZGVvYnVmMi1kbWEtY29udGlnLmg+DQorDQorI2luY2x1ZGUgIm10a19q cGVnX2VuY19ody5oIg0KKw0KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbXRrX2pwZWdfZW5jX3FsdCBt dGtfanBlZ19lbmNfcXVhbGl0eVtdID0gew0KKwl7LnF1YWxpdHlfcGFyYW0gPSAzNCwgLmhhcmR3 YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVBTElUWV9RMzR9LA0KKwl7LnF1YWxpdHlfcGFyYW0gPSAz OSwgLmhhcmR3YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVBTElUWV9RMzl9LA0KKwl7LnF1YWxpdHlf cGFyYW0gPSA0OCwgLmhhcmR3YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVBTElUWV9RNDh9LA0KKwl7 LnF1YWxpdHlfcGFyYW0gPSA2MCwgLmhhcmR3YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVBTElUWV9R NjB9LA0KKwl7LnF1YWxpdHlfcGFyYW0gPSA2NCwgLmhhcmR3YXJlX3ZhbHVlID0gSlBFR19FTkNf UVVBTElUWV9RNjR9LA0KKwl7LnF1YWxpdHlfcGFyYW0gPSA2OCwgLmhhcmR3YXJlX3ZhbHVlID0g SlBFR19FTkNfUVVBTElUWV9RNjh9LA0KKwl7LnF1YWxpdHlfcGFyYW0gPSA3NCwgLmhhcmR3YXJl X3ZhbHVlID0gSlBFR19FTkNfUVVBTElUWV9RNzR9LA0KKwl7LnF1YWxpdHlfcGFyYW0gPSA4MCwg LmhhcmR3YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVBTElUWV9RODB9LA0KKwl7LnF1YWxpdHlfcGFy YW0gPSA4MiwgLmhhcmR3YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVBTElUWV9RODJ9LA0KKwl7LnF1 YWxpdHlfcGFyYW0gPSA4NCwgLmhhcmR3YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVBTElUWV9RODR9 LA0KKwl7LnF1YWxpdHlfcGFyYW0gPSA4NywgLmhhcmR3YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVB TElUWV9RODd9LA0KKwl7LnF1YWxpdHlfcGFyYW0gPSA5MCwgLmhhcmR3YXJlX3ZhbHVlID0gSlBF R19FTkNfUVVBTElUWV9ROTB9LA0KKwl7LnF1YWxpdHlfcGFyYW0gPSA5MiwgLmhhcmR3YXJlX3Zh bHVlID0gSlBFR19FTkNfUVVBTElUWV9ROTJ9LA0KKwl7LnF1YWxpdHlfcGFyYW0gPSA5NSwgLmhh cmR3YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVBTElUWV9ROTV9LA0KKwl7LnF1YWxpdHlfcGFyYW0g PSA5NywgLmhhcmR3YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVBTElUWV9ROTd9LA0KK307DQorDQor dm9pZCBtdGtfanBlZ19lbmNfcmVzZXQodm9pZCBfX2lvbWVtICpiYXNlKQ0KK3sNCisJd3JpdGVs KDAsIGJhc2UgKyBKUEVHX0VOQ19SU1RCKTsNCisJd3JpdGVsKEpQRUdfRU5DX1JFU0VUX0JJVCwg YmFzZSArIEpQRUdfRU5DX1JTVEIpOw0KKwl3cml0ZWwoMCwgYmFzZSArIEpQRUdfRU5DX0NPREVD X1NFTCk7DQorfQ0KKw0KK3UzMiBtdGtfanBlZ19lbmNfZ2V0X2ZpbGVfc2l6ZSh2b2lkIF9faW9t ZW0gKmJhc2UpDQorew0KKwlyZXR1cm4gcmVhZGwoYmFzZSArIEpQRUdfRU5DX0RNQV9BRERSMCkg LQ0KKwkgICAgICAgcmVhZGwoYmFzZSArIEpQRUdfRU5DX0RTVF9BRERSMCk7DQorfQ0KKw0KK3Zv aWQgbXRrX2pwZWdfZW5jX3N0YXJ0KHZvaWQgX19pb21lbSAqYmFzZSkNCit7DQorCXUzMiB2YWx1 ZTsNCisNCisJdmFsdWUgPSByZWFkbChiYXNlICsgSlBFR19FTkNfQ1RSTCk7DQorCXZhbHVlIHw9 IEpQRUdfRU5DX0NUUkxfSU5UX0VOX0JJVCB8IEpQRUdfRU5DX0NUUkxfRU5BQkxFX0JJVDsNCisJ d3JpdGVsKHZhbHVlLCBiYXNlICsgSlBFR19FTkNfQ1RSTCk7DQorfQ0KKw0KK3ZvaWQgbXRrX2pw ZWdfc2V0X2VuY19zcmMoc3RydWN0IG10a19qcGVnX2N0eCAqY3R4LCAgdm9pZCBfX2lvbWVtICpi YXNlLA0KKwkJCSAgc3RydWN0IHZiMl9idWZmZXIgKnNyY19idWYpDQorew0KKwlpbnQgaTsNCisJ ZG1hX2FkZHJfdCBkbWFfYWRkcjsNCisNCisJZm9yIChpID0gMDsgaSA8IHNyY19idWYtPm51bV9w bGFuZXM7IGkrKykgew0KKwkJZG1hX2FkZHIgPSB2YjJfZG1hX2NvbnRpZ19wbGFuZV9kbWFfYWRk cihzcmNfYnVmLCBpKSArDQorCQkJICAgc3JjX2J1Zi0+cGxhbmVzW2ldLmRhdGFfb2Zmc2V0Ow0K KwkJaWYgKCFpKQ0KKwkJCXdyaXRlbChkbWFfYWRkciwgYmFzZSArIEpQRUdfRU5DX1NSQ19MVU1B X0FERFIpOw0KKwkJZWxzZQ0KKwkJCXdyaXRlbChkbWFfYWRkciwgYmFzZSArIEpQRUdfRU5DX1NS Q19DSFJPTUFfQUREUik7DQorCX0NCit9DQorDQordm9pZCBtdGtfanBlZ19zZXRfZW5jX2RzdChz dHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHgsIHZvaWQgX19pb21lbSAqYmFzZSwNCisJCQkgIHN0cnVj dCB2YjJfYnVmZmVyICpkc3RfYnVmKQ0KK3sNCisJZG1hX2FkZHJfdCBkbWFfYWRkcjsNCisJc2l6 ZV90IHNpemU7DQorCXUzMiBkbWFfYWRkcl9vZmZzZXQ7DQorCXUzMiBkbWFfYWRkcl9vZmZzZXRt YXNrOw0KKw0KKwlkbWFfYWRkciA9IHZiMl9kbWFfY29udGlnX3BsYW5lX2RtYV9hZGRyKGRzdF9i dWYsIDApOw0KKwlkbWFfYWRkcl9vZmZzZXQgPSBjdHgtPmVuYWJsZV9leGlmID8gTVRLX0pQRUdf TUFYX0VYSUZfU0laRSA6IDA7DQorCWRtYV9hZGRyX29mZnNldG1hc2sgPSBkbWFfYWRkciAmIEpQ RUdfRU5DX0RTVF9BRERSX09GRlNFVF9NQVNLOw0KKwlzaXplID0gdmIyX3BsYW5lX3NpemUoZHN0 X2J1ZiwgMCk7DQorDQorCXdyaXRlbChkbWFfYWRkcl9vZmZzZXQgJiB+MHhmLCBiYXNlICsgSlBF R19FTkNfT0ZGU0VUX0FERFIpOw0KKwl3cml0ZWwoZG1hX2FkZHJfb2Zmc2V0bWFzayAmIDB4Ziwg YmFzZSArIEpQRUdfRU5DX0JZVEVfT0ZGU0VUX01BU0spOw0KKwl3cml0ZWwoZG1hX2FkZHIgJiB+ MHhmLCBiYXNlICsgSlBFR19FTkNfRFNUX0FERFIwKTsNCisJd3JpdGVsKChkbWFfYWRkciArIHNp emUpICYgfjB4ZiwgYmFzZSArIEpQRUdfRU5DX1NUQUxMX0FERFIwKTsNCit9DQorDQordm9pZCBt dGtfanBlZ19zZXRfZW5jX3BhcmFtcyhzdHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHgsICB2b2lkIF9f aW9tZW0gKmJhc2UpDQorew0KKwl1MzIgdmFsdWU7DQorCXUzMiB3aWR0aCA9IGN0eC0+b3V0X3Eu ZW5jX2Nyb3BfcmVjdC53aWR0aDsNCisJdTMyIGhlaWdodCA9IGN0eC0+b3V0X3EuZW5jX2Nyb3Bf cmVjdC5oZWlnaHQ7DQorCXUzMiBlbmNfZm9ybWF0ID0gY3R4LT5vdXRfcS5mbXQtPmZvdXJjYzsN CisJdTMyIGJ5dGVzcGVybGluZSA9IGN0eC0+b3V0X3EucGl4X21wLnBsYW5lX2ZtdFswXS5ieXRl c3BlcmxpbmU7DQorCXUzMiBibGtfbnVtOw0KKwl1MzIgaW1nX3N0cmlkZTsNCisJdTMyIG1lbV9z dHJpZGU7DQorCXUzMiBpLCBlbmNfcXVhbGl0eTsNCisNCisJdmFsdWUgPSB3aWR0aCA8PCAxNiB8 IGhlaWdodDsNCisJd3JpdGVsKHZhbHVlLCBiYXNlICsgSlBFR19FTkNfSU1HX1NJWkUpOw0KKw0K KwlpZiAoZW5jX2Zvcm1hdCA9PSBWNEwyX1BJWF9GTVRfTlYxMk0gfHwNCisJICAgIGVuY19mb3Jt YXQgPT0gVjRMMl9QSVhfRk1UX05WMjFNKQ0KKwkgICAgLyoNCisJICAgICAqIFRvdGFsIDggeCA4 IGJsb2NrIG51bWJlciBvZiBsdW1hIGFuZCBjaHJvbWEuDQorCSAgICAgKiBUaGUgbnVtYmVyIG9m IGJsb2NrcyBpcyBjb3VudGVkIGZyb20gMC4NCisJICAgICAqLw0KKwkJYmxrX251bSA9IERJVl9S T1VORF9VUCh3aWR0aCwgMTYpICoNCisJCQkgIERJVl9ST1VORF9VUChoZWlnaHQsIDE2KSAqIDYg LSAxOw0KKwllbHNlDQorCQlibGtfbnVtID0gRElWX1JPVU5EX1VQKHdpZHRoLCAxNikgKg0KKwkJ CSAgRElWX1JPVU5EX1VQKGhlaWdodCwgOCkgKiA0IC0gMTsNCisJd3JpdGVsKGJsa19udW0sIGJh c2UgKyBKUEVHX0VOQ19CTEtfTlVNKTsNCisNCisJaWYgKGVuY19mb3JtYXQgPT0gVjRMMl9QSVhf Rk1UX05WMTJNIHx8DQorCSAgICBlbmNfZm9ybWF0ID09IFY0TDJfUElYX0ZNVF9OVjIxTSkgew0K KwkJLyogNDoyOjAgKi8NCisJCWltZ19zdHJpZGUgPSByb3VuZF91cCh3aWR0aCwgMTYpOw0KKwkJ bWVtX3N0cmlkZSA9IGJ5dGVzcGVybGluZTsNCisJfSBlbHNlIHsNCisJCS8qIDQ6MjoyICovDQor CQlpbWdfc3RyaWRlID0gcm91bmRfdXAod2lkdGggKiAyLCAzMik7DQorCQltZW1fc3RyaWRlID0g aW1nX3N0cmlkZTsNCisJfQ0KKwl3cml0ZWwoaW1nX3N0cmlkZSwgYmFzZSArIEpQRUdfRU5DX0lN R19TVFJJREUpOw0KKwl3cml0ZWwobWVtX3N0cmlkZSwgYmFzZSArIEpQRUdfRU5DX1NUUklERSk7 DQorDQorCWVuY19xdWFsaXR5ID0gbXRrX2pwZWdfZW5jX3F1YWxpdHlbMF0uaGFyZHdhcmVfdmFs dWU7DQorCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKG10a19qcGVnX2VuY19xdWFsaXR5KTsg aSsrKSB7DQorCQlpZiAoY3R4LT5lbmNfcXVhbGl0eSA8PSBtdGtfanBlZ19lbmNfcXVhbGl0eVtp XS5xdWFsaXR5X3BhcmFtKSB7DQorCQkJZW5jX3F1YWxpdHkgPSBtdGtfanBlZ19lbmNfcXVhbGl0 eVtpXS5oYXJkd2FyZV92YWx1ZTsNCisJCQlicmVhazsNCisJCX0NCisJfQ0KKwl3cml0ZWwoZW5j X3F1YWxpdHksIGJhc2UgKyBKUEVHX0VOQ19RVUFMSVRZKTsNCisNCisJdmFsdWUgPSByZWFkbChi YXNlICsgSlBFR19FTkNfQ1RSTCk7DQorCXZhbHVlICY9IH5KUEVHX0VOQ19DVFJMX1lVVl9GT1JN QVRfTUFTSzsNCisJdmFsdWUgfD0gKGN0eC0+b3V0X3EuZm10LT5od19mb3JtYXQgJiAzKSA8PCAz Ow0KKwlpZiAoY3R4LT5lbmFibGVfZXhpZikNCisJCXZhbHVlIHw9IEpQRUdfRU5DX0NUUkxfRklM RV9GT1JNQVRfQklUOw0KKwllbHNlDQorCQl2YWx1ZSAmPSB+SlBFR19FTkNfQ1RSTF9GSUxFX0ZP Uk1BVF9CSVQ7DQorCWlmIChjdHgtPnJlc3RhcnRfaW50ZXJ2YWwpDQorCQl2YWx1ZSB8PSBKUEVH X0VOQ19DVFJMX1JFU1RBUlRfRU5fQklUOw0KKwllbHNlDQorCQl2YWx1ZSAmPSB+SlBFR19FTkNf Q1RSTF9SRVNUQVJUX0VOX0JJVDsNCisJd3JpdGVsKHZhbHVlLCBiYXNlICsgSlBFR19FTkNfQ1RS TCk7DQorDQorCXdyaXRlbChjdHgtPnJlc3RhcnRfaW50ZXJ2YWwsIGJhc2UgKyBKUEVHX0VOQ19S U1RfTUNVX05VTSk7DQorfQ0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRr LWpwZWcvbXRrX2pwZWdfZW5jX2h3LmggYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1qcGVn L210a19qcGVnX2VuY19ody5oDQpuZXcgZmlsZSBtb2RlIDEwMDY0NA0KaW5kZXggMDAwMDAwMDAw MDAwLi42MWM2MGU0ZTU4ZWENCi0tLSAvZGV2L251bGwNCisrKyBiL2RyaXZlcnMvbWVkaWEvcGxh dGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfZW5jX2h3LmgNCkBAIC0wLDAgKzEsOTEgQEANCisvKiBT UERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5ICovDQorLyoNCisgKiBDb3B5cmln aHQgKGMpIDIwMTkgTWVkaWFUZWsgSW5jLg0KKyAqIEF1dGhvcjogWGlhIEppYW5nIDx4aWEuamlh bmdAbWVkaWF0ZWsuY29tPg0KKyAqDQorICovDQorDQorI2lmbmRlZiBfTVRLX0pQRUdfRU5DX0hX X0gNCisjZGVmaW5lIF9NVEtfSlBFR19FTkNfSFdfSA0KKw0KKyNpbmNsdWRlIDxtZWRpYS92aWRl b2J1ZjItY29yZS5oPg0KKw0KKyNpbmNsdWRlICJtdGtfanBlZ19jb3JlLmgiDQorDQorI2RlZmlu ZSBKUEVHX0VOQ19JTlRfU1RBVFVTX0RPTkUJQklUKDApDQorI2RlZmluZSBKUEVHX0VOQ19JTlRf U1RBVFVTX01BU0tfQUxMSVJRCTB4MTMNCisNCisjZGVmaW5lIEpQRUdfRU5DX0RTVF9BRERSX09G RlNFVF9NQVNLCUdFTk1BU0soMywgMCkNCisNCisjZGVmaW5lIEpQRUdfRU5DX0NUUkxfWVVWX0ZP Uk1BVF9NQVNLCTB4MTgNCisjZGVmaW5lIEpQRUdfRU5DX0NUUkxfUkVTVEFSVF9FTl9CSVQJQklU KDEwKQ0KKyNkZWZpbmUgSlBFR19FTkNfQ1RSTF9GSUxFX0ZPUk1BVF9CSVQJQklUKDUpDQorI2Rl ZmluZSBKUEVHX0VOQ19DVFJMX0lOVF9FTl9CSVQJQklUKDIpDQorI2RlZmluZSBKUEVHX0VOQ19D VFJMX0VOQUJMRV9CSVQJQklUKDApDQorI2RlZmluZSBKUEVHX0VOQ19SRVNFVF9CSVQJCUJJVCgw KQ0KKw0KKyNkZWZpbmUgSlBFR19FTkNfWVVWX0ZPUk1BVF9ZVVlWCTANCisjZGVmaW5lIEpQRUdf RU5DX1lVVl9GT1JNQVRfWVZZVQkxDQorI2RlZmluZSBKUEVHX0VOQ19ZVVZfRk9STUFUX05WMTIJ Mg0KKyNkZWZpbmUgSkVQR19FTkNfWVVWX0ZPUk1BVF9OVjIxCTMNCisNCisjZGVmaW5lIEpQRUdf RU5DX1FVQUxJVFlfUTYwCQkweDANCisjZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlfUTgwCQkweDEN CisjZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlfUTkwCQkweDINCisjZGVmaW5lIEpQRUdfRU5DX1FV QUxJVFlfUTk1CQkweDMNCisjZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlfUTM5CQkweDQNCisjZGVm aW5lIEpQRUdfRU5DX1FVQUxJVFlfUTY4CQkweDUNCisjZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlf UTg0CQkweDYNCisjZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlfUTkyCQkweDcNCisjZGVmaW5lIEpQ RUdfRU5DX1FVQUxJVFlfUTQ4CQkweDgNCisjZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlfUTc0CQkw eGENCisjZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlfUTg3CQkweGINCisjZGVmaW5lIEpQRUdfRU5D X1FVQUxJVFlfUTM0CQkweGMNCisjZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlfUTY0CQkweGUNCisj ZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlfUTgyCQkweGYNCisjZGVmaW5lIEpQRUdfRU5DX1FVQUxJ VFlfUTk3CQkweDEwDQorDQorI2RlZmluZSBKUEVHX0VOQ19SU1RCCQkJMHgxMDANCisjZGVmaW5l IEpQRUdfRU5DX0NUUkwJCQkweDEwNA0KKyNkZWZpbmUgSlBFR19FTkNfUVVBTElUWQkJMHgxMDgN CisjZGVmaW5lIEpQRUdfRU5DX0JMS19OVU0JCTB4MTBDDQorI2RlZmluZSBKUEVHX0VOQ19CTEtf Q05UCQkweDExMA0KKyNkZWZpbmUgSlBFR19FTkNfSU5UX1NUUwkJMHgxMWMNCisjZGVmaW5lIEpQ RUdfRU5DX0RTVF9BRERSMAkJMHgxMjANCisjZGVmaW5lIEpQRUdfRU5DX0RNQV9BRERSMAkJMHgx MjQNCisjZGVmaW5lIEpQRUdfRU5DX1NUQUxMX0FERFIwCQkweDEyOA0KKyNkZWZpbmUgSlBFR19F TkNfT0ZGU0VUX0FERFIJCTB4MTM4DQorI2RlZmluZSBKUEVHX0VOQ19SU1RfTUNVX05VTQkJMHgx NTANCisjZGVmaW5lIEpQRUdfRU5DX0lNR19TSVpFCQkweDE1NA0KKyNkZWZpbmUgSlBFR19FTkNf REVCVUdfSU5GTzAJCTB4MTYwDQorI2RlZmluZSBKUEVHX0VOQ19ERUJVR19JTkZPMQkJMHgxNjQN CisjZGVmaW5lIEpQRUdfRU5DX1RPVEFMX0NZQ0xFCQkweDE2OA0KKyNkZWZpbmUgSlBFR19FTkNf QllURV9PRkZTRVRfTUFTSwkweDE2Yw0KKyNkZWZpbmUgSlBFR19FTkNfU1JDX0xVTUFfQUREUgkJ MHgxNzANCisjZGVmaW5lIEpQRUdfRU5DX1NSQ19DSFJPTUFfQUREUgkweDE3NA0KKyNkZWZpbmUg SlBFR19FTkNfU1RSSURFCQkJMHgxNzgNCisjZGVmaW5lIEpQRUdfRU5DX0lNR19TVFJJREUJCTB4 MTdjDQorI2RlZmluZSBKUEVHX0VOQ19EQ01fQ1RSTAkJMHgzMDANCisjZGVmaW5lIEpQRUdfRU5D X0NPREVDX1NFTAkJMHgzMTQNCisjZGVmaW5lIEpQRUdfRU5DX1VMVFJBX1RIUkVTCQkweDMxOA0K Kw0KKy8qKg0KKyAqIHN0cnVjdCBtdGtfanBlZ19lbmNfcWx0IC0gSlBFRyBlbmNvZGVyIHF1YWxp dHkgZGF0YQ0KKyAqIEBxdWFsaXR5X3BhcmFtOglxdWFsaXR5IHZhbHVlDQorICogQGhhcmR3YXJl X3ZhbHVlOgloYXJkd2FyZSB2YWx1ZSBvZiBxdWFsaXR5DQorICovDQorc3RydWN0IG10a19qcGVn X2VuY19xbHQgew0KKwl1OAlxdWFsaXR5X3BhcmFtOw0KKwl1OAloYXJkd2FyZV92YWx1ZTsNCit9 Ow0KKw0KK3ZvaWQgbXRrX2pwZWdfZW5jX3Jlc2V0KHZvaWQgX19pb21lbSAqYmFzZSk7DQordTMy IG10a19qcGVnX2VuY19nZXRfZmlsZV9zaXplKHZvaWQgX19pb21lbSAqYmFzZSk7DQordm9pZCBt dGtfanBlZ19lbmNfc3RhcnQodm9pZCBfX2lvbWVtICplbmNfcmVnX2Jhc2UpOw0KK3ZvaWQgbXRr X2pwZWdfc2V0X2VuY19zcmMoc3RydWN0IG10a19qcGVnX2N0eCAqY3R4LCAgdm9pZCBfX2lvbWVt ICpiYXNlLA0KKwkJCSAgc3RydWN0IHZiMl9idWZmZXIgKnNyY19idWYpOw0KK3ZvaWQgbXRrX2pw ZWdfc2V0X2VuY19kc3Qoc3RydWN0IG10a19qcGVnX2N0eCAqY3R4LCB2b2lkIF9faW9tZW0gKmJh c2UsDQorCQkJICBzdHJ1Y3QgdmIyX2J1ZmZlciAqZHN0X2J1Zik7DQordm9pZCBtdGtfanBlZ19z ZXRfZW5jX3BhcmFtcyhzdHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHgsICB2b2lkIF9faW9tZW0gKmJh c2UpOw0KKw0KKyNlbmRpZiAvKiBfTVRLX0pQRUdfRU5DX0hXX0ggKi8NCi0tIA0KMi4xOC4wDQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.0 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B0E6BC433E3 for ; Thu, 23 Jul 2020 03:22:14 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 313BA20771 for ; Thu, 23 Jul 2020 03:22:14 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="VMi6tER0"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="uwucSA4n" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 313BA20771 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mediatek.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-ID:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=MU5lpAsOXVr6d1S66tRIlsUP4uIle6OvK3FeLRIDDyA=; b=VMi6tER0wVzFNAqkthCATl0E4 wVS6uuXV9l1Rsv5j0lfN48Xn3GHTrrLx1hnLrPuwBjqCHZgUeNWqLJYULDTAK7h29GSj9D6c9owMY 3fS+s4r9qNTDD7grJsipH0gEfjCEvwEQmFu6VwI7Pldbv2on9dvJtyHlFqMeETj4OX52VZaZ7GkWd 0SGF8kDbHhQDiLEw1IJA0AnCQSS4BSysz3UMlwP5IhfV3d1EjBt2CMp8oqKA+YEdkR+yqzp4Iaf3T SfSbXPptuAHRxZPvhRJ80DbttgOMflzM+/8mKOxbgIJxYvHN7hhRCN3Lc3I0smzcRkaIXhLXRHj18 bdKOsOM5g==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jyRnu-0007CO-Ke; Thu, 23 Jul 2020 03:21:54 +0000 Received: from mailgw01.mediatek.com ([216.200.240.184]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jyRit-0004yb-PK; Thu, 23 Jul 2020 03:16:48 +0000 X-UUID: fd7ec26f2f134e5bba67a8b56519d47a-20200722 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=3vUbUgggiDu/OOAylBirIZ2cYJlSnSLO9WjOqzyMv3o=; b=uwucSA4nq8ayvplNdFUXjAm9CSNbwjmZrEOCXtseooi2xFt3bPdHHL+NntcSKDWJiyx/hh+QIgFr3f9lPXDdnCu2RICiGMYFZKUXB4Lo0pDT4gUyBGN5dNymtXq5v4VKarh2610YzP6Qrt3eYXgKaIoBCkO02lZl4VBn258mIhk=; X-UUID: fd7ec26f2f134e5bba67a8b56519d47a-20200722 Received: from mtkcas66.mediatek.inc [(172.29.193.44)] by mailgw01.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 1743783570; Wed, 22 Jul 2020 19:16:27 -0800 Received: from MTKMBS07N2.mediatek.inc (172.21.101.141) by MTKMBS62DR.mediatek.inc (172.29.94.18) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 22 Jul 2020 20:06:45 -0700 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs07n2.mediatek.inc (172.21.101.141) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Thu, 23 Jul 2020 11:06:44 +0800 Received: from localhost.localdomain (10.17.3.153) by MTKCAS06.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Thu, 23 Jul 2020 11:06:40 +0800 From: Xia Jiang To: Hans Verkuil , Mauro Carvalho Chehab , Rob Herring , "Matthias Brugger" , Rick Chang Subject: [PATCH v10 28/28] media: platform: Add jpeg enc feature Date: Thu, 23 Jul 2020 11:04:51 +0800 Message-ID: <20200723030451.5616-29-xia.jiang@mediatek.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20200723030451.5616-1-xia.jiang@mediatek.com> References: <20200723030451.5616-1-xia.jiang@mediatek.com> MIME-Version: 1.0 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200722_231645_818363_FB08FA3E X-CRM114-Status: GOOD ( 21.32 ) X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: maoguang.meng@mediatek.com, devicetree@vger.kernel.org, mojahsu@chromium.org, srv_heupstream@mediatek.com, linux-kernel@vger.kernel.org, Tomasz Figa , senozhatsky@chromium.org, drinkcat@chromium.org, linux-mediatek@lists.infradead.org, Xia Jiang , linux-media@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Marek Szyprowski Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org Add mtk jpeg encode v4l2 driver based on jpeg decode, because that jpeg decode and encode have great similarities with function operation. Signed-off-by: Xia Jiang --- v10: cancel mtk_jpeg_enc_bs structure. refactor the setting hardware register functions in mtk_jpeg_enc_hw.c. remove mtk_jpeg_enc_job_ready(). refactor mtk_jpeg_enc_irq(). cancel setting up a control handler for jpeg dec. add the mechanism to ensure that the buffer is enough to hold the EXIF data in .buf_prepare callback. --- drivers/media/platform/mtk-jpeg/Makefile | 5 +- .../media/platform/mtk-jpeg/mtk_jpeg_core.c | 345 +++++++++++++++++- .../media/platform/mtk-jpeg/mtk_jpeg_core.h | 17 + .../media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c | 154 ++++++++ .../media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h | 91 +++++ 5 files changed, 608 insertions(+), 4 deletions(-) create mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c create mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h diff --git a/drivers/media/platform/mtk-jpeg/Makefile b/drivers/media/platform/mtk-jpeg/Makefile index 48516dcf96e6..76c33aad0f3f 100644 --- a/drivers/media/platform/mtk-jpeg/Makefile +++ b/drivers/media/platform/mtk-jpeg/Makefile @@ -1,3 +1,6 @@ # SPDX-License-Identifier: GPL-2.0-only -mtk_jpeg-objs := mtk_jpeg_core.o mtk_jpeg_dec_hw.o mtk_jpeg_dec_parse.o +mtk_jpeg-objs := mtk_jpeg_core.o \ + mtk_jpeg_dec_hw.o \ + mtk_jpeg_dec_parse.o \ + mtk_jpeg_enc_hw.o obj-$(CONFIG_VIDEO_MEDIATEK_JPEG) += mtk_jpeg.o diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c index 1eebbe726d4f..4c8d4b48713a 100644 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c @@ -3,6 +3,7 @@ * Copyright (c) 2016 MediaTek Inc. * Author: Ming Hsiu Tsai * Rick Chang + * Xia Jiang */ #include @@ -23,10 +24,59 @@ #include #include +#include "mtk_jpeg_enc_hw.h" #include "mtk_jpeg_dec_hw.h" #include "mtk_jpeg_core.h" #include "mtk_jpeg_dec_parse.h" +static struct mtk_jpeg_fmt mtk_jpeg_enc_formats[] = { + { + .fourcc = V4L2_PIX_FMT_JPEG, + .colplanes = 1, + .flags = MTK_JPEG_FMT_FLAG_CAPTURE, + }, + { + .fourcc = V4L2_PIX_FMT_NV12M, + .hw_format = JPEG_ENC_YUV_FORMAT_NV12, + .h_sample = {4, 4}, + .v_sample = {4, 2}, + .colplanes = 2, + .h_align = 4, + .v_align = 4, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, + { + .fourcc = V4L2_PIX_FMT_NV21M, + .hw_format = JEPG_ENC_YUV_FORMAT_NV21, + .h_sample = {4, 4}, + .v_sample = {4, 2}, + .colplanes = 2, + .h_align = 4, + .v_align = 4, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, + { + .fourcc = V4L2_PIX_FMT_YUYV, + .hw_format = JPEG_ENC_YUV_FORMAT_YUYV, + .h_sample = {8}, + .v_sample = {4}, + .colplanes = 1, + .h_align = 5, + .v_align = 3, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, + { + .fourcc = V4L2_PIX_FMT_YVYU, + .hw_format = JPEG_ENC_YUV_FORMAT_YVYU, + .h_sample = {8}, + .v_sample = {4}, + .colplanes = 1, + .h_align = 5, + .v_align = 3, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, +}; + static struct mtk_jpeg_fmt mtk_jpeg_dec_formats[] = { { .fourcc = V4L2_PIX_FMT_JPEG, @@ -53,6 +103,7 @@ static struct mtk_jpeg_fmt mtk_jpeg_dec_formats[] = { }, }; +#define MTK_JPEG_ENC_NUM_FORMATS ARRAY_SIZE(mtk_jpeg_enc_formats) #define MTK_JPEG_DEC_NUM_FORMATS ARRAY_SIZE(mtk_jpeg_dec_formats) struct mtk_jpeg_src_buf { @@ -64,6 +115,11 @@ struct mtk_jpeg_src_buf { static int debug; module_param(debug, int, 0644); +static inline struct mtk_jpeg_ctx *ctrl_to_ctx(struct v4l2_ctrl *ctrl) +{ + return container_of(ctrl->handler, struct mtk_jpeg_ctx, ctrl_hdl); +} + static inline struct mtk_jpeg_ctx *mtk_jpeg_fh_to_ctx(struct v4l2_fh *fh) { return container_of(fh, struct mtk_jpeg_ctx, fh); @@ -88,6 +144,53 @@ static int mtk_jpeg_querycap(struct file *file, void *priv, return 0; } +static int vidioc_jpeg_enc_s_ctrl(struct v4l2_ctrl *ctrl) +{ + struct mtk_jpeg_ctx *ctx = ctrl_to_ctx(ctrl); + + switch (ctrl->id) { + case V4L2_CID_JPEG_RESTART_INTERVAL: + ctx->restart_interval = ctrl->val; + break; + case V4L2_CID_JPEG_COMPRESSION_QUALITY: + ctx->enc_quality = ctrl->val; + break; + case V4L2_CID_JPEG_ACTIVE_MARKER: + ctx->enable_exif = ctrl->val & V4L2_JPEG_ACTIVE_MARKER_APP1; + break; + } + + return 0; +} + +static const struct v4l2_ctrl_ops mtk_jpeg_enc_ctrl_ops = { + .s_ctrl = vidioc_jpeg_enc_s_ctrl, +}; + +static int mtk_jpeg_enc_ctrls_setup(struct mtk_jpeg_ctx *ctx) +{ + const struct v4l2_ctrl_ops *ops = &mtk_jpeg_enc_ctrl_ops; + struct v4l2_ctrl_handler *handler = &ctx->ctrl_hdl; + + v4l2_ctrl_handler_init(handler, 3); + + v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_RESTART_INTERVAL, 0, 100, + 1, 0); + v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_COMPRESSION_QUALITY, 48, + 100, 1, 90); + v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_ACTIVE_MARKER, 0, + V4L2_JPEG_ACTIVE_MARKER_APP1, 0, 0); + + if (handler->error) { + v4l2_ctrl_handler_free(&ctx->ctrl_hdl); + return handler->error; + } + + v4l2_ctrl_handler_setup(&ctx->ctrl_hdl); + + return 0; +} + static int mtk_jpeg_enum_fmt(struct mtk_jpeg_fmt *mtk_jpeg_formats, int n, struct v4l2_fmtdesc *f, u32 type) { @@ -331,6 +434,8 @@ static int mtk_jpeg_s_fmt_mplane(struct mtk_jpeg_ctx *ctx, pix_mp->pixelformat, fmt_type); q_data->pix_mp.width = pix_mp->width; q_data->pix_mp.height = pix_mp->height; + q_data->enc_crop_rect.width = pix_mp->width; + q_data->enc_crop_rect.height = pix_mp->height; q_data->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; q_data->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; q_data->pix_mp.xfer_func = V4L2_XFER_FUNC_SRGB; @@ -407,6 +512,30 @@ static int mtk_jpeg_subscribe_event(struct v4l2_fh *fh, return v4l2_ctrl_subscribe_event(fh, sub); } +static int mtk_jpeg_enc_g_selection(struct file *file, void *priv, + struct v4l2_selection *s) +{ + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + + if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) + return -EINVAL; + + switch (s->target) { + case V4L2_SEL_TGT_CROP: + s->r = ctx->out_q.enc_crop_rect; + case V4L2_SEL_TGT_CROP_BOUNDS: + case V4L2_SEL_TGT_CROP_DEFAULT: + s->r.width = ctx->out_q.pix_mp.width; + s->r.height = ctx->out_q.pix_mp.height; + s->r.left = 0; + s->r.top = 0; + break; + default: + return -EINVAL; + } + return 0; +} + static int mtk_jpeg_dec_g_selection(struct file *file, void *priv, struct v4l2_selection *s) { @@ -436,6 +565,56 @@ static int mtk_jpeg_dec_g_selection(struct file *file, void *priv, return 0; } +static int mtk_jpeg_enc_s_selection(struct file *file, void *priv, + struct v4l2_selection *s) +{ + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + + if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) + return -EINVAL; + + switch (s->target) { + case V4L2_SEL_TGT_CROP: + s->r.left = 0; + s->r.top = 0; + s->r.width = min(s->r.width, ctx->out_q.pix_mp.width); + s->r.height = min(s->r.height, ctx->out_q.pix_mp.height); + ctx->out_q.enc_crop_rect = s->r; + break; + default: + return -EINVAL; + } + + return 0; +} + +static const struct v4l2_ioctl_ops mtk_jpeg_enc_ioctl_ops = { + .vidioc_querycap = mtk_jpeg_querycap, + .vidioc_enum_fmt_vid_cap = mtk_jpeg_enum_fmt_vid_cap, + .vidioc_enum_fmt_vid_out = mtk_jpeg_enum_fmt_vid_out, + .vidioc_try_fmt_vid_cap_mplane = mtk_jpeg_try_fmt_vid_cap_mplane, + .vidioc_try_fmt_vid_out_mplane = mtk_jpeg_try_fmt_vid_out_mplane, + .vidioc_g_fmt_vid_cap_mplane = mtk_jpeg_g_fmt_vid_mplane, + .vidioc_g_fmt_vid_out_mplane = mtk_jpeg_g_fmt_vid_mplane, + .vidioc_s_fmt_vid_cap_mplane = mtk_jpeg_s_fmt_vid_cap_mplane, + .vidioc_s_fmt_vid_out_mplane = mtk_jpeg_s_fmt_vid_out_mplane, + .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, + .vidioc_subscribe_event = mtk_jpeg_subscribe_event, + .vidioc_g_selection = mtk_jpeg_enc_g_selection, + .vidioc_s_selection = mtk_jpeg_enc_s_selection, + + .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, + .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, + .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, + .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, + .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, + .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, + .vidioc_streamon = v4l2_m2m_ioctl_streamon, + .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, + + .vidioc_unsubscribe_event = v4l2_event_unsubscribe, +}; + static const struct v4l2_ioctl_ops mtk_jpeg_dec_ioctl_ops = { .vidioc_querycap = mtk_jpeg_querycap, .vidioc_enum_fmt_vid_cap = mtk_jpeg_enum_fmt_vid_cap, @@ -501,15 +680,22 @@ static int mtk_jpeg_buf_prepare(struct vb2_buffer *vb) { struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); struct mtk_jpeg_q_data *q_data = NULL; + struct v4l2_plane_pix_format plane_fmt = {}; int i; q_data = mtk_jpeg_get_q_data(ctx, vb->vb2_queue->type); if (!q_data) return -EINVAL; - for (i = 0; i < q_data->fmt->colplanes; i++) - vb2_set_plane_payload(vb, i, - q_data->pix_mp.plane_fmt[i].sizeimage); + for (i = 0; i < q_data->fmt->colplanes; i++) { + plane_fmt = q_data->pix_mp.plane_fmt[i]; + if (ctx->enable_exif && + q_data->fmt->fourcc == V4L2_PIX_FMT_JPEG) + vb2_set_plane_payload(vb, i, plane_fmt.sizeimage + + MTK_JPEG_MAX_EXIF_SIZE); + else + vb2_set_plane_payload(vb, i, plane_fmt.sizeimage); + } return 0; } @@ -572,6 +758,17 @@ static void mtk_jpeg_set_queue_data(struct mtk_jpeg_ctx *ctx, param->dec_w, param->dec_h); } +static void mtk_jpeg_enc_buf_queue(struct vb2_buffer *vb) +{ + struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + + v4l2_dbg(2, debug, &jpeg->v4l2_dev, "(%d) buf_q id=%d, vb=%p\n", + vb->vb2_queue->type, vb->index, vb); + + v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, to_vb2_v4l2_buffer(vb)); +} + static void mtk_jpeg_dec_buf_queue(struct vb2_buffer *vb) { struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); @@ -620,6 +817,15 @@ static struct vb2_v4l2_buffer *mtk_jpeg_buf_remove(struct mtk_jpeg_ctx *ctx, return v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); } +static void mtk_jpeg_enc_stop_streaming(struct vb2_queue *q) +{ + struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(q); + struct vb2_v4l2_buffer *vb; + + while ((vb = mtk_jpeg_buf_remove(ctx, q->type))) + v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR); +} + static void mtk_jpeg_dec_stop_streaming(struct vb2_queue *q) { struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(q); @@ -655,6 +861,15 @@ static const struct vb2_ops mtk_jpeg_dec_qops = { .stop_streaming = mtk_jpeg_dec_stop_streaming, }; +static const struct vb2_ops mtk_jpeg_enc_qops = { + .queue_setup = mtk_jpeg_queue_setup, + .buf_prepare = mtk_jpeg_buf_prepare, + .buf_queue = mtk_jpeg_enc_buf_queue, + .wait_prepare = vb2_ops_wait_prepare, + .wait_finish = vb2_ops_wait_finish, + .stop_streaming = mtk_jpeg_enc_stop_streaming, +}; + static void mtk_jpeg_set_dec_src(struct mtk_jpeg_ctx *ctx, struct vb2_buffer *src_buf, struct mtk_jpeg_bs *bs) @@ -692,6 +907,50 @@ static int mtk_jpeg_set_dec_dst(struct mtk_jpeg_ctx *ctx, return 0; } +static void mtk_jpeg_enc_device_run(void *priv) +{ + struct mtk_jpeg_ctx *ctx = priv; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + struct vb2_v4l2_buffer *src_buf, *dst_buf; + enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; + unsigned long flags; + struct mtk_jpeg_src_buf *jpeg_src_buf; + int ret; + + src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); + dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); + jpeg_src_buf = mtk_jpeg_vb2_to_srcbuf(&src_buf->vb2_buf); + + ret = pm_runtime_get_sync(jpeg->dev); + if (ret < 0) + goto enc_end; + + schedule_delayed_work(&jpeg->job_timeout_work, + msecs_to_jiffies(MTK_JPEG_HW_TIMEOUT_MSEC)); + + spin_lock_irqsave(&jpeg->hw_lock, flags); + + /* + * Resetting the hardware every frame is to ensure that all the + * registers are cleared. This is a hardware requirement. + */ + mtk_jpeg_enc_reset(jpeg->reg_base); + + mtk_jpeg_set_enc_src(ctx, jpeg->reg_base, &src_buf->vb2_buf); + mtk_jpeg_set_enc_dst(ctx, jpeg->reg_base, &dst_buf->vb2_buf); + mtk_jpeg_set_enc_params(ctx, jpeg->reg_base); + mtk_jpeg_enc_start(jpeg->reg_base); + spin_unlock_irqrestore(&jpeg->hw_lock, flags); + return; + +enc_end: + v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); + v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); + v4l2_m2m_buf_done(src_buf, buf_state); + v4l2_m2m_buf_done(dst_buf, buf_state); + v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); +} + static void mtk_jpeg_dec_device_run(void *priv) { struct mtk_jpeg_ctx *ctx = priv; @@ -750,6 +1009,10 @@ static int mtk_jpeg_dec_job_ready(void *priv) return (ctx->state == MTK_JPEG_RUNNING) ? 1 : 0; } +static const struct v4l2_m2m_ops mtk_jpeg_enc_m2m_ops = { + .device_run = mtk_jpeg_enc_device_run, +}; + static const struct v4l2_m2m_ops mtk_jpeg_dec_m2m_ops = { .device_run = mtk_jpeg_dec_device_run, .job_ready = mtk_jpeg_dec_job_ready, @@ -808,6 +1071,54 @@ static void mtk_jpeg_clk_off(struct mtk_jpeg_dev *jpeg) mtk_smi_larb_put(jpeg->larb); } +static irqreturn_t mtk_jpeg_enc_done(struct mtk_jpeg_dev *jpeg) +{ + struct mtk_jpeg_ctx *ctx; + struct vb2_v4l2_buffer *src_buf, *dst_buf; + enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; + u32 result_size; + + ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); + if (!ctx) { + v4l2_err(&jpeg->v4l2_dev, "Context is NULL\n"); + return IRQ_HANDLED; + } + + src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); + dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); + + result_size = mtk_jpeg_enc_get_file_size(jpeg->reg_base); + vb2_set_plane_payload(&dst_buf->vb2_buf, 0, result_size); + + buf_state = VB2_BUF_STATE_DONE; + + v4l2_m2m_buf_done(src_buf, buf_state); + v4l2_m2m_buf_done(dst_buf, buf_state); + v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); + pm_runtime_put(ctx->jpeg->dev); + return IRQ_HANDLED; +} + +static irqreturn_t mtk_jpeg_enc_irq(int irq, void *priv) +{ + struct mtk_jpeg_dev *jpeg = priv; + u32 irq_status; + irqreturn_t ret = IRQ_NONE; + + cancel_delayed_work(&jpeg->job_timeout_work); + + irq_status = readl(jpeg->reg_base + JPEG_ENC_INT_STS) & + JPEG_ENC_INT_STATUS_MASK_ALLIRQ; + if (irq_status) + writel(0, jpeg->reg_base + JPEG_ENC_INT_STS); + + if (!(irq_status & JPEG_ENC_INT_STATUS_DONE)) + return ret; + + ret = mtk_jpeg_enc_done(jpeg); + return ret; +} + static irqreturn_t mtk_jpeg_dec_irq(int irq, void *priv) { struct mtk_jpeg_dev *jpeg = priv; @@ -860,6 +1171,7 @@ static void mtk_jpeg_set_default_params(struct mtk_jpeg_ctx *ctx) struct mtk_jpeg_q_data *q = &ctx->out_q; struct mtk_jpeg_dev *jpeg = ctx->jpeg; + ctx->fh.ctrl_handler = &ctx->ctrl_hdl; q->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; q->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; q->pix_mp.quantization = V4L2_QUANTIZATION_FULL_RANGE; @@ -916,6 +1228,15 @@ static int mtk_jpeg_open(struct file *file) goto error; } + if (jpeg->variant->cap_q_default_fourcc == V4L2_PIX_FMT_JPEG) { + ret = mtk_jpeg_enc_ctrls_setup(ctx); + if (ret) { + v4l2_err(&jpeg->v4l2_dev, "Failed to setup jpeg enc controls\n"); + goto error; + } + } else { + v4l2_ctrl_handler_init(&ctx->ctrl_hdl, 0); + } mtk_jpeg_set_default_params(ctx); mutex_unlock(&jpeg->lock); return 0; @@ -936,6 +1257,7 @@ static int mtk_jpeg_release(struct file *file) mutex_lock(&jpeg->lock); v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); + v4l2_ctrl_handler_free(&ctx->ctrl_hdl); v4l2_fh_del(&ctx->fh); v4l2_fh_exit(&ctx->fh); kfree(ctx); @@ -1206,6 +1528,19 @@ static const struct mtk_jpeg_variant mt8173_jpeg_drvdata = { .cap_q_default_fourcc = V4L2_PIX_FMT_YUV420M, }; +static const struct mtk_jpeg_variant mtk_jpeg_drvdata = { + .formats = mtk_jpeg_enc_formats, + .num_formats = MTK_JPEG_ENC_NUM_FORMATS, + .qops = &mtk_jpeg_enc_qops, + .irq_handler = mtk_jpeg_enc_irq, + .hw_reset = mtk_jpeg_enc_reset, + .m2m_ops = &mtk_jpeg_enc_m2m_ops, + .dev_name = "mtk-jpeg-enc", + .ioctl_ops = &mtk_jpeg_enc_ioctl_ops, + .out_q_default_fourcc = V4L2_PIX_FMT_YUYV, + .cap_q_default_fourcc = V4L2_PIX_FMT_JPEG, +}; + static const struct of_device_id mtk_jpeg_match[] = { { .compatible = "mediatek,mt8173-jpgdec", @@ -1215,6 +1550,10 @@ static const struct of_device_id mtk_jpeg_match[] = { .compatible = "mediatek,mt2701-jpgdec", .data = &mt8173_jpeg_drvdata, }, + { + .compatible = "mediatek,mtk-jpgenc", + .data = &mtk_jpeg_drvdata, + }, {}, }; diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h index 3ed6c74ca5fb..75356a7de69e 100644 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h @@ -3,6 +3,7 @@ * Copyright (c) 2016 MediaTek Inc. * Author: Ming Hsiu Tsai * Rick Chang + * Xia Jiang */ #ifndef _MTK_JPEG_CORE_H @@ -12,6 +13,8 @@ #include #include #include +#include +#include #define MTK_JPEG_NAME "mtk-jpeg" @@ -29,6 +32,8 @@ #define MTK_JPEG_HW_TIMEOUT_MSEC 1000 +#define MTK_JPEG_MAX_EXIF_SIZE (64 * 1024) + /** * enum mtk_jpeg_ctx_state - states of the context state machine * @MTK_JPEG_INIT: current state is initialized @@ -104,6 +109,7 @@ struct mtk_jpeg_dev { /** * struct jpeg_fmt - driver's internal color format data * @fourcc: the fourcc code, 0 if not applicable + * @hw_format: hardware format value * @h_sample: horizontal sample count of plane in 4 * 4 pixel image * @v_sample: vertical sample count of plane in 4 * 4 pixel image * @colplanes: number of color planes (1 for packed formats) @@ -113,6 +119,7 @@ struct mtk_jpeg_dev { */ struct mtk_jpeg_fmt { u32 fourcc; + u32 hw_format; int h_sample[VIDEO_MAX_PLANES]; int v_sample[VIDEO_MAX_PLANES]; int colplanes; @@ -125,10 +132,12 @@ struct mtk_jpeg_fmt { * mtk_jpeg_q_data - parameters of one queue * @fmt: driver-specific format of this queue * @pix_mp: multiplanar format + * @enc_crop_rect: jpeg encoder crop information */ struct mtk_jpeg_q_data { struct mtk_jpeg_fmt *fmt; struct v4l2_pix_format_mplane pix_mp; + struct v4l2_rect enc_crop_rect; }; /** @@ -138,6 +147,10 @@ struct mtk_jpeg_q_data { * @cap_q: destination (capture) queue queue information * @fh: V4L2 file handle * @state: state of the context + * @enable_exif: enable exif mode of jpeg encoder + * @enc_quality: jpeg encoder quality + * @restart_interval: jpeg encoder restart interval + * @ctrl_hdl: controls handler */ struct mtk_jpeg_ctx { struct mtk_jpeg_dev *jpeg; @@ -145,6 +158,10 @@ struct mtk_jpeg_ctx { struct mtk_jpeg_q_data cap_q; struct v4l2_fh fh; enum mtk_jpeg_ctx_state state; + bool enable_exif; + u8 enc_quality; + u8 restart_interval; + struct v4l2_ctrl_handler ctrl_hdl; }; #endif /* _MTK_JPEG_CORE_H */ diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c new file mode 100644 index 000000000000..1cf037bf72dd --- /dev/null +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c @@ -0,0 +1,154 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2019 MediaTek Inc. + * Author: Xia Jiang + * + */ + +#include +#include +#include +#include + +#include "mtk_jpeg_enc_hw.h" + +static const struct mtk_jpeg_enc_qlt mtk_jpeg_enc_quality[] = { + {.quality_param = 34, .hardware_value = JPEG_ENC_QUALITY_Q34}, + {.quality_param = 39, .hardware_value = JPEG_ENC_QUALITY_Q39}, + {.quality_param = 48, .hardware_value = JPEG_ENC_QUALITY_Q48}, + {.quality_param = 60, .hardware_value = JPEG_ENC_QUALITY_Q60}, + {.quality_param = 64, .hardware_value = JPEG_ENC_QUALITY_Q64}, + {.quality_param = 68, .hardware_value = JPEG_ENC_QUALITY_Q68}, + {.quality_param = 74, .hardware_value = JPEG_ENC_QUALITY_Q74}, + {.quality_param = 80, .hardware_value = JPEG_ENC_QUALITY_Q80}, + {.quality_param = 82, .hardware_value = JPEG_ENC_QUALITY_Q82}, + {.quality_param = 84, .hardware_value = JPEG_ENC_QUALITY_Q84}, + {.quality_param = 87, .hardware_value = JPEG_ENC_QUALITY_Q87}, + {.quality_param = 90, .hardware_value = JPEG_ENC_QUALITY_Q90}, + {.quality_param = 92, .hardware_value = JPEG_ENC_QUALITY_Q92}, + {.quality_param = 95, .hardware_value = JPEG_ENC_QUALITY_Q95}, + {.quality_param = 97, .hardware_value = JPEG_ENC_QUALITY_Q97}, +}; + +void mtk_jpeg_enc_reset(void __iomem *base) +{ + writel(0, base + JPEG_ENC_RSTB); + writel(JPEG_ENC_RESET_BIT, base + JPEG_ENC_RSTB); + writel(0, base + JPEG_ENC_CODEC_SEL); +} + +u32 mtk_jpeg_enc_get_file_size(void __iomem *base) +{ + return readl(base + JPEG_ENC_DMA_ADDR0) - + readl(base + JPEG_ENC_DST_ADDR0); +} + +void mtk_jpeg_enc_start(void __iomem *base) +{ + u32 value; + + value = readl(base + JPEG_ENC_CTRL); + value |= JPEG_ENC_CTRL_INT_EN_BIT | JPEG_ENC_CTRL_ENABLE_BIT; + writel(value, base + JPEG_ENC_CTRL); +} + +void mtk_jpeg_set_enc_src(struct mtk_jpeg_ctx *ctx, void __iomem *base, + struct vb2_buffer *src_buf) +{ + int i; + dma_addr_t dma_addr; + + for (i = 0; i < src_buf->num_planes; i++) { + dma_addr = vb2_dma_contig_plane_dma_addr(src_buf, i) + + src_buf->planes[i].data_offset; + if (!i) + writel(dma_addr, base + JPEG_ENC_SRC_LUMA_ADDR); + else + writel(dma_addr, base + JPEG_ENC_SRC_CHROMA_ADDR); + } +} + +void mtk_jpeg_set_enc_dst(struct mtk_jpeg_ctx *ctx, void __iomem *base, + struct vb2_buffer *dst_buf) +{ + dma_addr_t dma_addr; + size_t size; + u32 dma_addr_offset; + u32 dma_addr_offsetmask; + + dma_addr = vb2_dma_contig_plane_dma_addr(dst_buf, 0); + dma_addr_offset = ctx->enable_exif ? MTK_JPEG_MAX_EXIF_SIZE : 0; + dma_addr_offsetmask = dma_addr & JPEG_ENC_DST_ADDR_OFFSET_MASK; + size = vb2_plane_size(dst_buf, 0); + + writel(dma_addr_offset & ~0xf, base + JPEG_ENC_OFFSET_ADDR); + writel(dma_addr_offsetmask & 0xf, base + JPEG_ENC_BYTE_OFFSET_MASK); + writel(dma_addr & ~0xf, base + JPEG_ENC_DST_ADDR0); + writel((dma_addr + size) & ~0xf, base + JPEG_ENC_STALL_ADDR0); +} + +void mtk_jpeg_set_enc_params(struct mtk_jpeg_ctx *ctx, void __iomem *base) +{ + u32 value; + u32 width = ctx->out_q.enc_crop_rect.width; + u32 height = ctx->out_q.enc_crop_rect.height; + u32 enc_format = ctx->out_q.fmt->fourcc; + u32 bytesperline = ctx->out_q.pix_mp.plane_fmt[0].bytesperline; + u32 blk_num; + u32 img_stride; + u32 mem_stride; + u32 i, enc_quality; + + value = width << 16 | height; + writel(value, base + JPEG_ENC_IMG_SIZE); + + if (enc_format == V4L2_PIX_FMT_NV12M || + enc_format == V4L2_PIX_FMT_NV21M) + /* + * Total 8 x 8 block number of luma and chroma. + * The number of blocks is counted from 0. + */ + blk_num = DIV_ROUND_UP(width, 16) * + DIV_ROUND_UP(height, 16) * 6 - 1; + else + blk_num = DIV_ROUND_UP(width, 16) * + DIV_ROUND_UP(height, 8) * 4 - 1; + writel(blk_num, base + JPEG_ENC_BLK_NUM); + + if (enc_format == V4L2_PIX_FMT_NV12M || + enc_format == V4L2_PIX_FMT_NV21M) { + /* 4:2:0 */ + img_stride = round_up(width, 16); + mem_stride = bytesperline; + } else { + /* 4:2:2 */ + img_stride = round_up(width * 2, 32); + mem_stride = img_stride; + } + writel(img_stride, base + JPEG_ENC_IMG_STRIDE); + writel(mem_stride, base + JPEG_ENC_STRIDE); + + enc_quality = mtk_jpeg_enc_quality[0].hardware_value; + for (i = 0; i < ARRAY_SIZE(mtk_jpeg_enc_quality); i++) { + if (ctx->enc_quality <= mtk_jpeg_enc_quality[i].quality_param) { + enc_quality = mtk_jpeg_enc_quality[i].hardware_value; + break; + } + } + writel(enc_quality, base + JPEG_ENC_QUALITY); + + value = readl(base + JPEG_ENC_CTRL); + value &= ~JPEG_ENC_CTRL_YUV_FORMAT_MASK; + value |= (ctx->out_q.fmt->hw_format & 3) << 3; + if (ctx->enable_exif) + value |= JPEG_ENC_CTRL_FILE_FORMAT_BIT; + else + value &= ~JPEG_ENC_CTRL_FILE_FORMAT_BIT; + if (ctx->restart_interval) + value |= JPEG_ENC_CTRL_RESTART_EN_BIT; + else + value &= ~JPEG_ENC_CTRL_RESTART_EN_BIT; + writel(value, base + JPEG_ENC_CTRL); + + writel(ctx->restart_interval, base + JPEG_ENC_RST_MCU_NUM); +} diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h new file mode 100644 index 000000000000..61c60e4e58ea --- /dev/null +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h @@ -0,0 +1,91 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2019 MediaTek Inc. + * Author: Xia Jiang + * + */ + +#ifndef _MTK_JPEG_ENC_HW_H +#define _MTK_JPEG_ENC_HW_H + +#include + +#include "mtk_jpeg_core.h" + +#define JPEG_ENC_INT_STATUS_DONE BIT(0) +#define JPEG_ENC_INT_STATUS_MASK_ALLIRQ 0x13 + +#define JPEG_ENC_DST_ADDR_OFFSET_MASK GENMASK(3, 0) + +#define JPEG_ENC_CTRL_YUV_FORMAT_MASK 0x18 +#define JPEG_ENC_CTRL_RESTART_EN_BIT BIT(10) +#define JPEG_ENC_CTRL_FILE_FORMAT_BIT BIT(5) +#define JPEG_ENC_CTRL_INT_EN_BIT BIT(2) +#define JPEG_ENC_CTRL_ENABLE_BIT BIT(0) +#define JPEG_ENC_RESET_BIT BIT(0) + +#define JPEG_ENC_YUV_FORMAT_YUYV 0 +#define JPEG_ENC_YUV_FORMAT_YVYU 1 +#define JPEG_ENC_YUV_FORMAT_NV12 2 +#define JEPG_ENC_YUV_FORMAT_NV21 3 + +#define JPEG_ENC_QUALITY_Q60 0x0 +#define JPEG_ENC_QUALITY_Q80 0x1 +#define JPEG_ENC_QUALITY_Q90 0x2 +#define JPEG_ENC_QUALITY_Q95 0x3 +#define JPEG_ENC_QUALITY_Q39 0x4 +#define JPEG_ENC_QUALITY_Q68 0x5 +#define JPEG_ENC_QUALITY_Q84 0x6 +#define JPEG_ENC_QUALITY_Q92 0x7 +#define JPEG_ENC_QUALITY_Q48 0x8 +#define JPEG_ENC_QUALITY_Q74 0xa +#define JPEG_ENC_QUALITY_Q87 0xb +#define JPEG_ENC_QUALITY_Q34 0xc +#define JPEG_ENC_QUALITY_Q64 0xe +#define JPEG_ENC_QUALITY_Q82 0xf +#define JPEG_ENC_QUALITY_Q97 0x10 + +#define JPEG_ENC_RSTB 0x100 +#define JPEG_ENC_CTRL 0x104 +#define JPEG_ENC_QUALITY 0x108 +#define JPEG_ENC_BLK_NUM 0x10C +#define JPEG_ENC_BLK_CNT 0x110 +#define JPEG_ENC_INT_STS 0x11c +#define JPEG_ENC_DST_ADDR0 0x120 +#define JPEG_ENC_DMA_ADDR0 0x124 +#define JPEG_ENC_STALL_ADDR0 0x128 +#define JPEG_ENC_OFFSET_ADDR 0x138 +#define JPEG_ENC_RST_MCU_NUM 0x150 +#define JPEG_ENC_IMG_SIZE 0x154 +#define JPEG_ENC_DEBUG_INFO0 0x160 +#define JPEG_ENC_DEBUG_INFO1 0x164 +#define JPEG_ENC_TOTAL_CYCLE 0x168 +#define JPEG_ENC_BYTE_OFFSET_MASK 0x16c +#define JPEG_ENC_SRC_LUMA_ADDR 0x170 +#define JPEG_ENC_SRC_CHROMA_ADDR 0x174 +#define JPEG_ENC_STRIDE 0x178 +#define JPEG_ENC_IMG_STRIDE 0x17c +#define JPEG_ENC_DCM_CTRL 0x300 +#define JPEG_ENC_CODEC_SEL 0x314 +#define JPEG_ENC_ULTRA_THRES 0x318 + +/** + * struct mtk_jpeg_enc_qlt - JPEG encoder quality data + * @quality_param: quality value + * @hardware_value: hardware value of quality + */ +struct mtk_jpeg_enc_qlt { + u8 quality_param; + u8 hardware_value; +}; + +void mtk_jpeg_enc_reset(void __iomem *base); +u32 mtk_jpeg_enc_get_file_size(void __iomem *base); +void mtk_jpeg_enc_start(void __iomem *enc_reg_base); +void mtk_jpeg_set_enc_src(struct mtk_jpeg_ctx *ctx, void __iomem *base, + struct vb2_buffer *src_buf); +void mtk_jpeg_set_enc_dst(struct mtk_jpeg_ctx *ctx, void __iomem *base, + struct vb2_buffer *dst_buf); +void mtk_jpeg_set_enc_params(struct mtk_jpeg_ctx *ctx, void __iomem *base); + +#endif /* _MTK_JPEG_ENC_HW_H */ -- 2.18.0 _______________________________________________ Linux-mediatek mailing list Linux-mediatek@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-mediatek From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.0 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, URIBL_BLOCKED,USER_AGENT_GIT 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 D65E9C433DF for ; Thu, 23 Jul 2020 04:40:01 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 8C637207F5 for ; Thu, 23 Jul 2020 04:40:01 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="C0Aw3AbK"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="uwucSA4n" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8C637207F5 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mediatek.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-ID:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=iIqiSe2Z18wXqd9OuDgaS9uIiDrTBDnky8qi5PatTYk=; b=C0Aw3AbKxtOUEtAwNtCahGSI/ 7ex7uqcIqlTOTDusfjyWgL4Oytjmpxs8XH/HzT8yZD5KzSyYfMq2VlJghKWSgaHIcg7qMhRO0BkVU Vj/RJ4kqcPqOogwjQw4pKIsQvQOFfQTifLImKHQm6fPIvyGLOvj22r2yz3JJYWCn+PDgpmMh7GpCZ pK3e93/yP5dGQpGk1iK0kpoBE4UzLYYMYCoShHD4e4fGsiD0+4pN13nNV0Qjpvnl/papbGQLOXdfs HV89t2U80iEFAqUduNqZOiu158WvUL9SqEfuGNyC8xf2w9g+mmCC0L0qCt1P/dzt1tGim/9lVv+o1 koStRyz+w==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jyRo7-0007FU-Ef; Thu, 23 Jul 2020 03:22:08 +0000 Received: from mailgw01.mediatek.com ([216.200.240.184]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jyRit-0004yb-PK; Thu, 23 Jul 2020 03:16:48 +0000 X-UUID: fd7ec26f2f134e5bba67a8b56519d47a-20200722 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=3vUbUgggiDu/OOAylBirIZ2cYJlSnSLO9WjOqzyMv3o=; b=uwucSA4nq8ayvplNdFUXjAm9CSNbwjmZrEOCXtseooi2xFt3bPdHHL+NntcSKDWJiyx/hh+QIgFr3f9lPXDdnCu2RICiGMYFZKUXB4Lo0pDT4gUyBGN5dNymtXq5v4VKarh2610YzP6Qrt3eYXgKaIoBCkO02lZl4VBn258mIhk=; X-UUID: fd7ec26f2f134e5bba67a8b56519d47a-20200722 Received: from mtkcas66.mediatek.inc [(172.29.193.44)] by mailgw01.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 1743783570; Wed, 22 Jul 2020 19:16:27 -0800 Received: from MTKMBS07N2.mediatek.inc (172.21.101.141) by MTKMBS62DR.mediatek.inc (172.29.94.18) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 22 Jul 2020 20:06:45 -0700 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs07n2.mediatek.inc (172.21.101.141) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Thu, 23 Jul 2020 11:06:44 +0800 Received: from localhost.localdomain (10.17.3.153) by MTKCAS06.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Thu, 23 Jul 2020 11:06:40 +0800 From: Xia Jiang To: Hans Verkuil , Mauro Carvalho Chehab , Rob Herring , "Matthias Brugger" , Rick Chang Subject: [PATCH v10 28/28] media: platform: Add jpeg enc feature Date: Thu, 23 Jul 2020 11:04:51 +0800 Message-ID: <20200723030451.5616-29-xia.jiang@mediatek.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20200723030451.5616-1-xia.jiang@mediatek.com> References: <20200723030451.5616-1-xia.jiang@mediatek.com> MIME-Version: 1.0 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200722_231645_818363_FB08FA3E X-CRM114-Status: GOOD ( 21.32 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: maoguang.meng@mediatek.com, devicetree@vger.kernel.org, mojahsu@chromium.org, srv_heupstream@mediatek.com, linux-kernel@vger.kernel.org, Tomasz Figa , senozhatsky@chromium.org, drinkcat@chromium.org, linux-mediatek@lists.infradead.org, Xia Jiang , linux-media@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Marek Szyprowski Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Add mtk jpeg encode v4l2 driver based on jpeg decode, because that jpeg decode and encode have great similarities with function operation. Signed-off-by: Xia Jiang --- v10: cancel mtk_jpeg_enc_bs structure. refactor the setting hardware register functions in mtk_jpeg_enc_hw.c. remove mtk_jpeg_enc_job_ready(). refactor mtk_jpeg_enc_irq(). cancel setting up a control handler for jpeg dec. add the mechanism to ensure that the buffer is enough to hold the EXIF data in .buf_prepare callback. --- drivers/media/platform/mtk-jpeg/Makefile | 5 +- .../media/platform/mtk-jpeg/mtk_jpeg_core.c | 345 +++++++++++++++++- .../media/platform/mtk-jpeg/mtk_jpeg_core.h | 17 + .../media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c | 154 ++++++++ .../media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h | 91 +++++ 5 files changed, 608 insertions(+), 4 deletions(-) create mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c create mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h diff --git a/drivers/media/platform/mtk-jpeg/Makefile b/drivers/media/platform/mtk-jpeg/Makefile index 48516dcf96e6..76c33aad0f3f 100644 --- a/drivers/media/platform/mtk-jpeg/Makefile +++ b/drivers/media/platform/mtk-jpeg/Makefile @@ -1,3 +1,6 @@ # SPDX-License-Identifier: GPL-2.0-only -mtk_jpeg-objs := mtk_jpeg_core.o mtk_jpeg_dec_hw.o mtk_jpeg_dec_parse.o +mtk_jpeg-objs := mtk_jpeg_core.o \ + mtk_jpeg_dec_hw.o \ + mtk_jpeg_dec_parse.o \ + mtk_jpeg_enc_hw.o obj-$(CONFIG_VIDEO_MEDIATEK_JPEG) += mtk_jpeg.o diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c index 1eebbe726d4f..4c8d4b48713a 100644 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c @@ -3,6 +3,7 @@ * Copyright (c) 2016 MediaTek Inc. * Author: Ming Hsiu Tsai * Rick Chang + * Xia Jiang */ #include @@ -23,10 +24,59 @@ #include #include +#include "mtk_jpeg_enc_hw.h" #include "mtk_jpeg_dec_hw.h" #include "mtk_jpeg_core.h" #include "mtk_jpeg_dec_parse.h" +static struct mtk_jpeg_fmt mtk_jpeg_enc_formats[] = { + { + .fourcc = V4L2_PIX_FMT_JPEG, + .colplanes = 1, + .flags = MTK_JPEG_FMT_FLAG_CAPTURE, + }, + { + .fourcc = V4L2_PIX_FMT_NV12M, + .hw_format = JPEG_ENC_YUV_FORMAT_NV12, + .h_sample = {4, 4}, + .v_sample = {4, 2}, + .colplanes = 2, + .h_align = 4, + .v_align = 4, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, + { + .fourcc = V4L2_PIX_FMT_NV21M, + .hw_format = JEPG_ENC_YUV_FORMAT_NV21, + .h_sample = {4, 4}, + .v_sample = {4, 2}, + .colplanes = 2, + .h_align = 4, + .v_align = 4, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, + { + .fourcc = V4L2_PIX_FMT_YUYV, + .hw_format = JPEG_ENC_YUV_FORMAT_YUYV, + .h_sample = {8}, + .v_sample = {4}, + .colplanes = 1, + .h_align = 5, + .v_align = 3, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, + { + .fourcc = V4L2_PIX_FMT_YVYU, + .hw_format = JPEG_ENC_YUV_FORMAT_YVYU, + .h_sample = {8}, + .v_sample = {4}, + .colplanes = 1, + .h_align = 5, + .v_align = 3, + .flags = MTK_JPEG_FMT_FLAG_OUTPUT, + }, +}; + static struct mtk_jpeg_fmt mtk_jpeg_dec_formats[] = { { .fourcc = V4L2_PIX_FMT_JPEG, @@ -53,6 +103,7 @@ static struct mtk_jpeg_fmt mtk_jpeg_dec_formats[] = { }, }; +#define MTK_JPEG_ENC_NUM_FORMATS ARRAY_SIZE(mtk_jpeg_enc_formats) #define MTK_JPEG_DEC_NUM_FORMATS ARRAY_SIZE(mtk_jpeg_dec_formats) struct mtk_jpeg_src_buf { @@ -64,6 +115,11 @@ struct mtk_jpeg_src_buf { static int debug; module_param(debug, int, 0644); +static inline struct mtk_jpeg_ctx *ctrl_to_ctx(struct v4l2_ctrl *ctrl) +{ + return container_of(ctrl->handler, struct mtk_jpeg_ctx, ctrl_hdl); +} + static inline struct mtk_jpeg_ctx *mtk_jpeg_fh_to_ctx(struct v4l2_fh *fh) { return container_of(fh, struct mtk_jpeg_ctx, fh); @@ -88,6 +144,53 @@ static int mtk_jpeg_querycap(struct file *file, void *priv, return 0; } +static int vidioc_jpeg_enc_s_ctrl(struct v4l2_ctrl *ctrl) +{ + struct mtk_jpeg_ctx *ctx = ctrl_to_ctx(ctrl); + + switch (ctrl->id) { + case V4L2_CID_JPEG_RESTART_INTERVAL: + ctx->restart_interval = ctrl->val; + break; + case V4L2_CID_JPEG_COMPRESSION_QUALITY: + ctx->enc_quality = ctrl->val; + break; + case V4L2_CID_JPEG_ACTIVE_MARKER: + ctx->enable_exif = ctrl->val & V4L2_JPEG_ACTIVE_MARKER_APP1; + break; + } + + return 0; +} + +static const struct v4l2_ctrl_ops mtk_jpeg_enc_ctrl_ops = { + .s_ctrl = vidioc_jpeg_enc_s_ctrl, +}; + +static int mtk_jpeg_enc_ctrls_setup(struct mtk_jpeg_ctx *ctx) +{ + const struct v4l2_ctrl_ops *ops = &mtk_jpeg_enc_ctrl_ops; + struct v4l2_ctrl_handler *handler = &ctx->ctrl_hdl; + + v4l2_ctrl_handler_init(handler, 3); + + v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_RESTART_INTERVAL, 0, 100, + 1, 0); + v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_COMPRESSION_QUALITY, 48, + 100, 1, 90); + v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_ACTIVE_MARKER, 0, + V4L2_JPEG_ACTIVE_MARKER_APP1, 0, 0); + + if (handler->error) { + v4l2_ctrl_handler_free(&ctx->ctrl_hdl); + return handler->error; + } + + v4l2_ctrl_handler_setup(&ctx->ctrl_hdl); + + return 0; +} + static int mtk_jpeg_enum_fmt(struct mtk_jpeg_fmt *mtk_jpeg_formats, int n, struct v4l2_fmtdesc *f, u32 type) { @@ -331,6 +434,8 @@ static int mtk_jpeg_s_fmt_mplane(struct mtk_jpeg_ctx *ctx, pix_mp->pixelformat, fmt_type); q_data->pix_mp.width = pix_mp->width; q_data->pix_mp.height = pix_mp->height; + q_data->enc_crop_rect.width = pix_mp->width; + q_data->enc_crop_rect.height = pix_mp->height; q_data->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; q_data->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; q_data->pix_mp.xfer_func = V4L2_XFER_FUNC_SRGB; @@ -407,6 +512,30 @@ static int mtk_jpeg_subscribe_event(struct v4l2_fh *fh, return v4l2_ctrl_subscribe_event(fh, sub); } +static int mtk_jpeg_enc_g_selection(struct file *file, void *priv, + struct v4l2_selection *s) +{ + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + + if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) + return -EINVAL; + + switch (s->target) { + case V4L2_SEL_TGT_CROP: + s->r = ctx->out_q.enc_crop_rect; + case V4L2_SEL_TGT_CROP_BOUNDS: + case V4L2_SEL_TGT_CROP_DEFAULT: + s->r.width = ctx->out_q.pix_mp.width; + s->r.height = ctx->out_q.pix_mp.height; + s->r.left = 0; + s->r.top = 0; + break; + default: + return -EINVAL; + } + return 0; +} + static int mtk_jpeg_dec_g_selection(struct file *file, void *priv, struct v4l2_selection *s) { @@ -436,6 +565,56 @@ static int mtk_jpeg_dec_g_selection(struct file *file, void *priv, return 0; } +static int mtk_jpeg_enc_s_selection(struct file *file, void *priv, + struct v4l2_selection *s) +{ + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); + + if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) + return -EINVAL; + + switch (s->target) { + case V4L2_SEL_TGT_CROP: + s->r.left = 0; + s->r.top = 0; + s->r.width = min(s->r.width, ctx->out_q.pix_mp.width); + s->r.height = min(s->r.height, ctx->out_q.pix_mp.height); + ctx->out_q.enc_crop_rect = s->r; + break; + default: + return -EINVAL; + } + + return 0; +} + +static const struct v4l2_ioctl_ops mtk_jpeg_enc_ioctl_ops = { + .vidioc_querycap = mtk_jpeg_querycap, + .vidioc_enum_fmt_vid_cap = mtk_jpeg_enum_fmt_vid_cap, + .vidioc_enum_fmt_vid_out = mtk_jpeg_enum_fmt_vid_out, + .vidioc_try_fmt_vid_cap_mplane = mtk_jpeg_try_fmt_vid_cap_mplane, + .vidioc_try_fmt_vid_out_mplane = mtk_jpeg_try_fmt_vid_out_mplane, + .vidioc_g_fmt_vid_cap_mplane = mtk_jpeg_g_fmt_vid_mplane, + .vidioc_g_fmt_vid_out_mplane = mtk_jpeg_g_fmt_vid_mplane, + .vidioc_s_fmt_vid_cap_mplane = mtk_jpeg_s_fmt_vid_cap_mplane, + .vidioc_s_fmt_vid_out_mplane = mtk_jpeg_s_fmt_vid_out_mplane, + .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, + .vidioc_subscribe_event = mtk_jpeg_subscribe_event, + .vidioc_g_selection = mtk_jpeg_enc_g_selection, + .vidioc_s_selection = mtk_jpeg_enc_s_selection, + + .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, + .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, + .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, + .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, + .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, + .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, + .vidioc_streamon = v4l2_m2m_ioctl_streamon, + .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, + + .vidioc_unsubscribe_event = v4l2_event_unsubscribe, +}; + static const struct v4l2_ioctl_ops mtk_jpeg_dec_ioctl_ops = { .vidioc_querycap = mtk_jpeg_querycap, .vidioc_enum_fmt_vid_cap = mtk_jpeg_enum_fmt_vid_cap, @@ -501,15 +680,22 @@ static int mtk_jpeg_buf_prepare(struct vb2_buffer *vb) { struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); struct mtk_jpeg_q_data *q_data = NULL; + struct v4l2_plane_pix_format plane_fmt = {}; int i; q_data = mtk_jpeg_get_q_data(ctx, vb->vb2_queue->type); if (!q_data) return -EINVAL; - for (i = 0; i < q_data->fmt->colplanes; i++) - vb2_set_plane_payload(vb, i, - q_data->pix_mp.plane_fmt[i].sizeimage); + for (i = 0; i < q_data->fmt->colplanes; i++) { + plane_fmt = q_data->pix_mp.plane_fmt[i]; + if (ctx->enable_exif && + q_data->fmt->fourcc == V4L2_PIX_FMT_JPEG) + vb2_set_plane_payload(vb, i, plane_fmt.sizeimage + + MTK_JPEG_MAX_EXIF_SIZE); + else + vb2_set_plane_payload(vb, i, plane_fmt.sizeimage); + } return 0; } @@ -572,6 +758,17 @@ static void mtk_jpeg_set_queue_data(struct mtk_jpeg_ctx *ctx, param->dec_w, param->dec_h); } +static void mtk_jpeg_enc_buf_queue(struct vb2_buffer *vb) +{ + struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + + v4l2_dbg(2, debug, &jpeg->v4l2_dev, "(%d) buf_q id=%d, vb=%p\n", + vb->vb2_queue->type, vb->index, vb); + + v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, to_vb2_v4l2_buffer(vb)); +} + static void mtk_jpeg_dec_buf_queue(struct vb2_buffer *vb) { struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); @@ -620,6 +817,15 @@ static struct vb2_v4l2_buffer *mtk_jpeg_buf_remove(struct mtk_jpeg_ctx *ctx, return v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); } +static void mtk_jpeg_enc_stop_streaming(struct vb2_queue *q) +{ + struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(q); + struct vb2_v4l2_buffer *vb; + + while ((vb = mtk_jpeg_buf_remove(ctx, q->type))) + v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR); +} + static void mtk_jpeg_dec_stop_streaming(struct vb2_queue *q) { struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(q); @@ -655,6 +861,15 @@ static const struct vb2_ops mtk_jpeg_dec_qops = { .stop_streaming = mtk_jpeg_dec_stop_streaming, }; +static const struct vb2_ops mtk_jpeg_enc_qops = { + .queue_setup = mtk_jpeg_queue_setup, + .buf_prepare = mtk_jpeg_buf_prepare, + .buf_queue = mtk_jpeg_enc_buf_queue, + .wait_prepare = vb2_ops_wait_prepare, + .wait_finish = vb2_ops_wait_finish, + .stop_streaming = mtk_jpeg_enc_stop_streaming, +}; + static void mtk_jpeg_set_dec_src(struct mtk_jpeg_ctx *ctx, struct vb2_buffer *src_buf, struct mtk_jpeg_bs *bs) @@ -692,6 +907,50 @@ static int mtk_jpeg_set_dec_dst(struct mtk_jpeg_ctx *ctx, return 0; } +static void mtk_jpeg_enc_device_run(void *priv) +{ + struct mtk_jpeg_ctx *ctx = priv; + struct mtk_jpeg_dev *jpeg = ctx->jpeg; + struct vb2_v4l2_buffer *src_buf, *dst_buf; + enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; + unsigned long flags; + struct mtk_jpeg_src_buf *jpeg_src_buf; + int ret; + + src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); + dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); + jpeg_src_buf = mtk_jpeg_vb2_to_srcbuf(&src_buf->vb2_buf); + + ret = pm_runtime_get_sync(jpeg->dev); + if (ret < 0) + goto enc_end; + + schedule_delayed_work(&jpeg->job_timeout_work, + msecs_to_jiffies(MTK_JPEG_HW_TIMEOUT_MSEC)); + + spin_lock_irqsave(&jpeg->hw_lock, flags); + + /* + * Resetting the hardware every frame is to ensure that all the + * registers are cleared. This is a hardware requirement. + */ + mtk_jpeg_enc_reset(jpeg->reg_base); + + mtk_jpeg_set_enc_src(ctx, jpeg->reg_base, &src_buf->vb2_buf); + mtk_jpeg_set_enc_dst(ctx, jpeg->reg_base, &dst_buf->vb2_buf); + mtk_jpeg_set_enc_params(ctx, jpeg->reg_base); + mtk_jpeg_enc_start(jpeg->reg_base); + spin_unlock_irqrestore(&jpeg->hw_lock, flags); + return; + +enc_end: + v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); + v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); + v4l2_m2m_buf_done(src_buf, buf_state); + v4l2_m2m_buf_done(dst_buf, buf_state); + v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); +} + static void mtk_jpeg_dec_device_run(void *priv) { struct mtk_jpeg_ctx *ctx = priv; @@ -750,6 +1009,10 @@ static int mtk_jpeg_dec_job_ready(void *priv) return (ctx->state == MTK_JPEG_RUNNING) ? 1 : 0; } +static const struct v4l2_m2m_ops mtk_jpeg_enc_m2m_ops = { + .device_run = mtk_jpeg_enc_device_run, +}; + static const struct v4l2_m2m_ops mtk_jpeg_dec_m2m_ops = { .device_run = mtk_jpeg_dec_device_run, .job_ready = mtk_jpeg_dec_job_ready, @@ -808,6 +1071,54 @@ static void mtk_jpeg_clk_off(struct mtk_jpeg_dev *jpeg) mtk_smi_larb_put(jpeg->larb); } +static irqreturn_t mtk_jpeg_enc_done(struct mtk_jpeg_dev *jpeg) +{ + struct mtk_jpeg_ctx *ctx; + struct vb2_v4l2_buffer *src_buf, *dst_buf; + enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; + u32 result_size; + + ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); + if (!ctx) { + v4l2_err(&jpeg->v4l2_dev, "Context is NULL\n"); + return IRQ_HANDLED; + } + + src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); + dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); + + result_size = mtk_jpeg_enc_get_file_size(jpeg->reg_base); + vb2_set_plane_payload(&dst_buf->vb2_buf, 0, result_size); + + buf_state = VB2_BUF_STATE_DONE; + + v4l2_m2m_buf_done(src_buf, buf_state); + v4l2_m2m_buf_done(dst_buf, buf_state); + v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); + pm_runtime_put(ctx->jpeg->dev); + return IRQ_HANDLED; +} + +static irqreturn_t mtk_jpeg_enc_irq(int irq, void *priv) +{ + struct mtk_jpeg_dev *jpeg = priv; + u32 irq_status; + irqreturn_t ret = IRQ_NONE; + + cancel_delayed_work(&jpeg->job_timeout_work); + + irq_status = readl(jpeg->reg_base + JPEG_ENC_INT_STS) & + JPEG_ENC_INT_STATUS_MASK_ALLIRQ; + if (irq_status) + writel(0, jpeg->reg_base + JPEG_ENC_INT_STS); + + if (!(irq_status & JPEG_ENC_INT_STATUS_DONE)) + return ret; + + ret = mtk_jpeg_enc_done(jpeg); + return ret; +} + static irqreturn_t mtk_jpeg_dec_irq(int irq, void *priv) { struct mtk_jpeg_dev *jpeg = priv; @@ -860,6 +1171,7 @@ static void mtk_jpeg_set_default_params(struct mtk_jpeg_ctx *ctx) struct mtk_jpeg_q_data *q = &ctx->out_q; struct mtk_jpeg_dev *jpeg = ctx->jpeg; + ctx->fh.ctrl_handler = &ctx->ctrl_hdl; q->pix_mp.colorspace = V4L2_COLORSPACE_SRGB; q->pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_601; q->pix_mp.quantization = V4L2_QUANTIZATION_FULL_RANGE; @@ -916,6 +1228,15 @@ static int mtk_jpeg_open(struct file *file) goto error; } + if (jpeg->variant->cap_q_default_fourcc == V4L2_PIX_FMT_JPEG) { + ret = mtk_jpeg_enc_ctrls_setup(ctx); + if (ret) { + v4l2_err(&jpeg->v4l2_dev, "Failed to setup jpeg enc controls\n"); + goto error; + } + } else { + v4l2_ctrl_handler_init(&ctx->ctrl_hdl, 0); + } mtk_jpeg_set_default_params(ctx); mutex_unlock(&jpeg->lock); return 0; @@ -936,6 +1257,7 @@ static int mtk_jpeg_release(struct file *file) mutex_lock(&jpeg->lock); v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); + v4l2_ctrl_handler_free(&ctx->ctrl_hdl); v4l2_fh_del(&ctx->fh); v4l2_fh_exit(&ctx->fh); kfree(ctx); @@ -1206,6 +1528,19 @@ static const struct mtk_jpeg_variant mt8173_jpeg_drvdata = { .cap_q_default_fourcc = V4L2_PIX_FMT_YUV420M, }; +static const struct mtk_jpeg_variant mtk_jpeg_drvdata = { + .formats = mtk_jpeg_enc_formats, + .num_formats = MTK_JPEG_ENC_NUM_FORMATS, + .qops = &mtk_jpeg_enc_qops, + .irq_handler = mtk_jpeg_enc_irq, + .hw_reset = mtk_jpeg_enc_reset, + .m2m_ops = &mtk_jpeg_enc_m2m_ops, + .dev_name = "mtk-jpeg-enc", + .ioctl_ops = &mtk_jpeg_enc_ioctl_ops, + .out_q_default_fourcc = V4L2_PIX_FMT_YUYV, + .cap_q_default_fourcc = V4L2_PIX_FMT_JPEG, +}; + static const struct of_device_id mtk_jpeg_match[] = { { .compatible = "mediatek,mt8173-jpgdec", @@ -1215,6 +1550,10 @@ static const struct of_device_id mtk_jpeg_match[] = { .compatible = "mediatek,mt2701-jpgdec", .data = &mt8173_jpeg_drvdata, }, + { + .compatible = "mediatek,mtk-jpgenc", + .data = &mtk_jpeg_drvdata, + }, {}, }; diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h index 3ed6c74ca5fb..75356a7de69e 100644 --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h @@ -3,6 +3,7 @@ * Copyright (c) 2016 MediaTek Inc. * Author: Ming Hsiu Tsai * Rick Chang + * Xia Jiang */ #ifndef _MTK_JPEG_CORE_H @@ -12,6 +13,8 @@ #include #include #include +#include +#include #define MTK_JPEG_NAME "mtk-jpeg" @@ -29,6 +32,8 @@ #define MTK_JPEG_HW_TIMEOUT_MSEC 1000 +#define MTK_JPEG_MAX_EXIF_SIZE (64 * 1024) + /** * enum mtk_jpeg_ctx_state - states of the context state machine * @MTK_JPEG_INIT: current state is initialized @@ -104,6 +109,7 @@ struct mtk_jpeg_dev { /** * struct jpeg_fmt - driver's internal color format data * @fourcc: the fourcc code, 0 if not applicable + * @hw_format: hardware format value * @h_sample: horizontal sample count of plane in 4 * 4 pixel image * @v_sample: vertical sample count of plane in 4 * 4 pixel image * @colplanes: number of color planes (1 for packed formats) @@ -113,6 +119,7 @@ struct mtk_jpeg_dev { */ struct mtk_jpeg_fmt { u32 fourcc; + u32 hw_format; int h_sample[VIDEO_MAX_PLANES]; int v_sample[VIDEO_MAX_PLANES]; int colplanes; @@ -125,10 +132,12 @@ struct mtk_jpeg_fmt { * mtk_jpeg_q_data - parameters of one queue * @fmt: driver-specific format of this queue * @pix_mp: multiplanar format + * @enc_crop_rect: jpeg encoder crop information */ struct mtk_jpeg_q_data { struct mtk_jpeg_fmt *fmt; struct v4l2_pix_format_mplane pix_mp; + struct v4l2_rect enc_crop_rect; }; /** @@ -138,6 +147,10 @@ struct mtk_jpeg_q_data { * @cap_q: destination (capture) queue queue information * @fh: V4L2 file handle * @state: state of the context + * @enable_exif: enable exif mode of jpeg encoder + * @enc_quality: jpeg encoder quality + * @restart_interval: jpeg encoder restart interval + * @ctrl_hdl: controls handler */ struct mtk_jpeg_ctx { struct mtk_jpeg_dev *jpeg; @@ -145,6 +158,10 @@ struct mtk_jpeg_ctx { struct mtk_jpeg_q_data cap_q; struct v4l2_fh fh; enum mtk_jpeg_ctx_state state; + bool enable_exif; + u8 enc_quality; + u8 restart_interval; + struct v4l2_ctrl_handler ctrl_hdl; }; #endif /* _MTK_JPEG_CORE_H */ diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c new file mode 100644 index 000000000000..1cf037bf72dd --- /dev/null +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c @@ -0,0 +1,154 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2019 MediaTek Inc. + * Author: Xia Jiang + * + */ + +#include +#include +#include +#include + +#include "mtk_jpeg_enc_hw.h" + +static const struct mtk_jpeg_enc_qlt mtk_jpeg_enc_quality[] = { + {.quality_param = 34, .hardware_value = JPEG_ENC_QUALITY_Q34}, + {.quality_param = 39, .hardware_value = JPEG_ENC_QUALITY_Q39}, + {.quality_param = 48, .hardware_value = JPEG_ENC_QUALITY_Q48}, + {.quality_param = 60, .hardware_value = JPEG_ENC_QUALITY_Q60}, + {.quality_param = 64, .hardware_value = JPEG_ENC_QUALITY_Q64}, + {.quality_param = 68, .hardware_value = JPEG_ENC_QUALITY_Q68}, + {.quality_param = 74, .hardware_value = JPEG_ENC_QUALITY_Q74}, + {.quality_param = 80, .hardware_value = JPEG_ENC_QUALITY_Q80}, + {.quality_param = 82, .hardware_value = JPEG_ENC_QUALITY_Q82}, + {.quality_param = 84, .hardware_value = JPEG_ENC_QUALITY_Q84}, + {.quality_param = 87, .hardware_value = JPEG_ENC_QUALITY_Q87}, + {.quality_param = 90, .hardware_value = JPEG_ENC_QUALITY_Q90}, + {.quality_param = 92, .hardware_value = JPEG_ENC_QUALITY_Q92}, + {.quality_param = 95, .hardware_value = JPEG_ENC_QUALITY_Q95}, + {.quality_param = 97, .hardware_value = JPEG_ENC_QUALITY_Q97}, +}; + +void mtk_jpeg_enc_reset(void __iomem *base) +{ + writel(0, base + JPEG_ENC_RSTB); + writel(JPEG_ENC_RESET_BIT, base + JPEG_ENC_RSTB); + writel(0, base + JPEG_ENC_CODEC_SEL); +} + +u32 mtk_jpeg_enc_get_file_size(void __iomem *base) +{ + return readl(base + JPEG_ENC_DMA_ADDR0) - + readl(base + JPEG_ENC_DST_ADDR0); +} + +void mtk_jpeg_enc_start(void __iomem *base) +{ + u32 value; + + value = readl(base + JPEG_ENC_CTRL); + value |= JPEG_ENC_CTRL_INT_EN_BIT | JPEG_ENC_CTRL_ENABLE_BIT; + writel(value, base + JPEG_ENC_CTRL); +} + +void mtk_jpeg_set_enc_src(struct mtk_jpeg_ctx *ctx, void __iomem *base, + struct vb2_buffer *src_buf) +{ + int i; + dma_addr_t dma_addr; + + for (i = 0; i < src_buf->num_planes; i++) { + dma_addr = vb2_dma_contig_plane_dma_addr(src_buf, i) + + src_buf->planes[i].data_offset; + if (!i) + writel(dma_addr, base + JPEG_ENC_SRC_LUMA_ADDR); + else + writel(dma_addr, base + JPEG_ENC_SRC_CHROMA_ADDR); + } +} + +void mtk_jpeg_set_enc_dst(struct mtk_jpeg_ctx *ctx, void __iomem *base, + struct vb2_buffer *dst_buf) +{ + dma_addr_t dma_addr; + size_t size; + u32 dma_addr_offset; + u32 dma_addr_offsetmask; + + dma_addr = vb2_dma_contig_plane_dma_addr(dst_buf, 0); + dma_addr_offset = ctx->enable_exif ? MTK_JPEG_MAX_EXIF_SIZE : 0; + dma_addr_offsetmask = dma_addr & JPEG_ENC_DST_ADDR_OFFSET_MASK; + size = vb2_plane_size(dst_buf, 0); + + writel(dma_addr_offset & ~0xf, base + JPEG_ENC_OFFSET_ADDR); + writel(dma_addr_offsetmask & 0xf, base + JPEG_ENC_BYTE_OFFSET_MASK); + writel(dma_addr & ~0xf, base + JPEG_ENC_DST_ADDR0); + writel((dma_addr + size) & ~0xf, base + JPEG_ENC_STALL_ADDR0); +} + +void mtk_jpeg_set_enc_params(struct mtk_jpeg_ctx *ctx, void __iomem *base) +{ + u32 value; + u32 width = ctx->out_q.enc_crop_rect.width; + u32 height = ctx->out_q.enc_crop_rect.height; + u32 enc_format = ctx->out_q.fmt->fourcc; + u32 bytesperline = ctx->out_q.pix_mp.plane_fmt[0].bytesperline; + u32 blk_num; + u32 img_stride; + u32 mem_stride; + u32 i, enc_quality; + + value = width << 16 | height; + writel(value, base + JPEG_ENC_IMG_SIZE); + + if (enc_format == V4L2_PIX_FMT_NV12M || + enc_format == V4L2_PIX_FMT_NV21M) + /* + * Total 8 x 8 block number of luma and chroma. + * The number of blocks is counted from 0. + */ + blk_num = DIV_ROUND_UP(width, 16) * + DIV_ROUND_UP(height, 16) * 6 - 1; + else + blk_num = DIV_ROUND_UP(width, 16) * + DIV_ROUND_UP(height, 8) * 4 - 1; + writel(blk_num, base + JPEG_ENC_BLK_NUM); + + if (enc_format == V4L2_PIX_FMT_NV12M || + enc_format == V4L2_PIX_FMT_NV21M) { + /* 4:2:0 */ + img_stride = round_up(width, 16); + mem_stride = bytesperline; + } else { + /* 4:2:2 */ + img_stride = round_up(width * 2, 32); + mem_stride = img_stride; + } + writel(img_stride, base + JPEG_ENC_IMG_STRIDE); + writel(mem_stride, base + JPEG_ENC_STRIDE); + + enc_quality = mtk_jpeg_enc_quality[0].hardware_value; + for (i = 0; i < ARRAY_SIZE(mtk_jpeg_enc_quality); i++) { + if (ctx->enc_quality <= mtk_jpeg_enc_quality[i].quality_param) { + enc_quality = mtk_jpeg_enc_quality[i].hardware_value; + break; + } + } + writel(enc_quality, base + JPEG_ENC_QUALITY); + + value = readl(base + JPEG_ENC_CTRL); + value &= ~JPEG_ENC_CTRL_YUV_FORMAT_MASK; + value |= (ctx->out_q.fmt->hw_format & 3) << 3; + if (ctx->enable_exif) + value |= JPEG_ENC_CTRL_FILE_FORMAT_BIT; + else + value &= ~JPEG_ENC_CTRL_FILE_FORMAT_BIT; + if (ctx->restart_interval) + value |= JPEG_ENC_CTRL_RESTART_EN_BIT; + else + value &= ~JPEG_ENC_CTRL_RESTART_EN_BIT; + writel(value, base + JPEG_ENC_CTRL); + + writel(ctx->restart_interval, base + JPEG_ENC_RST_MCU_NUM); +} diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h new file mode 100644 index 000000000000..61c60e4e58ea --- /dev/null +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h @@ -0,0 +1,91 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2019 MediaTek Inc. + * Author: Xia Jiang + * + */ + +#ifndef _MTK_JPEG_ENC_HW_H +#define _MTK_JPEG_ENC_HW_H + +#include + +#include "mtk_jpeg_core.h" + +#define JPEG_ENC_INT_STATUS_DONE BIT(0) +#define JPEG_ENC_INT_STATUS_MASK_ALLIRQ 0x13 + +#define JPEG_ENC_DST_ADDR_OFFSET_MASK GENMASK(3, 0) + +#define JPEG_ENC_CTRL_YUV_FORMAT_MASK 0x18 +#define JPEG_ENC_CTRL_RESTART_EN_BIT BIT(10) +#define JPEG_ENC_CTRL_FILE_FORMAT_BIT BIT(5) +#define JPEG_ENC_CTRL_INT_EN_BIT BIT(2) +#define JPEG_ENC_CTRL_ENABLE_BIT BIT(0) +#define JPEG_ENC_RESET_BIT BIT(0) + +#define JPEG_ENC_YUV_FORMAT_YUYV 0 +#define JPEG_ENC_YUV_FORMAT_YVYU 1 +#define JPEG_ENC_YUV_FORMAT_NV12 2 +#define JEPG_ENC_YUV_FORMAT_NV21 3 + +#define JPEG_ENC_QUALITY_Q60 0x0 +#define JPEG_ENC_QUALITY_Q80 0x1 +#define JPEG_ENC_QUALITY_Q90 0x2 +#define JPEG_ENC_QUALITY_Q95 0x3 +#define JPEG_ENC_QUALITY_Q39 0x4 +#define JPEG_ENC_QUALITY_Q68 0x5 +#define JPEG_ENC_QUALITY_Q84 0x6 +#define JPEG_ENC_QUALITY_Q92 0x7 +#define JPEG_ENC_QUALITY_Q48 0x8 +#define JPEG_ENC_QUALITY_Q74 0xa +#define JPEG_ENC_QUALITY_Q87 0xb +#define JPEG_ENC_QUALITY_Q34 0xc +#define JPEG_ENC_QUALITY_Q64 0xe +#define JPEG_ENC_QUALITY_Q82 0xf +#define JPEG_ENC_QUALITY_Q97 0x10 + +#define JPEG_ENC_RSTB 0x100 +#define JPEG_ENC_CTRL 0x104 +#define JPEG_ENC_QUALITY 0x108 +#define JPEG_ENC_BLK_NUM 0x10C +#define JPEG_ENC_BLK_CNT 0x110 +#define JPEG_ENC_INT_STS 0x11c +#define JPEG_ENC_DST_ADDR0 0x120 +#define JPEG_ENC_DMA_ADDR0 0x124 +#define JPEG_ENC_STALL_ADDR0 0x128 +#define JPEG_ENC_OFFSET_ADDR 0x138 +#define JPEG_ENC_RST_MCU_NUM 0x150 +#define JPEG_ENC_IMG_SIZE 0x154 +#define JPEG_ENC_DEBUG_INFO0 0x160 +#define JPEG_ENC_DEBUG_INFO1 0x164 +#define JPEG_ENC_TOTAL_CYCLE 0x168 +#define JPEG_ENC_BYTE_OFFSET_MASK 0x16c +#define JPEG_ENC_SRC_LUMA_ADDR 0x170 +#define JPEG_ENC_SRC_CHROMA_ADDR 0x174 +#define JPEG_ENC_STRIDE 0x178 +#define JPEG_ENC_IMG_STRIDE 0x17c +#define JPEG_ENC_DCM_CTRL 0x300 +#define JPEG_ENC_CODEC_SEL 0x314 +#define JPEG_ENC_ULTRA_THRES 0x318 + +/** + * struct mtk_jpeg_enc_qlt - JPEG encoder quality data + * @quality_param: quality value + * @hardware_value: hardware value of quality + */ +struct mtk_jpeg_enc_qlt { + u8 quality_param; + u8 hardware_value; +}; + +void mtk_jpeg_enc_reset(void __iomem *base); +u32 mtk_jpeg_enc_get_file_size(void __iomem *base); +void mtk_jpeg_enc_start(void __iomem *enc_reg_base); +void mtk_jpeg_set_enc_src(struct mtk_jpeg_ctx *ctx, void __iomem *base, + struct vb2_buffer *src_buf); +void mtk_jpeg_set_enc_dst(struct mtk_jpeg_ctx *ctx, void __iomem *base, + struct vb2_buffer *dst_buf); +void mtk_jpeg_set_enc_params(struct mtk_jpeg_ctx *ctx, void __iomem *base); + +#endif /* _MTK_JPEG_ENC_HW_H */ -- 2.18.0 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel