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=-16.4 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING,MIME_BASE64_TEXT,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY,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 9233CC433E7 for ; Wed, 2 Sep 2020 12:04:28 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5CB9C2078B for ; Wed, 2 Sep 2020 12:04:28 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="JZRin0Mg" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726938AbgIBMES (ORCPT ); Wed, 2 Sep 2020 08:04:18 -0400 Received: from mailgw01.mediatek.com ([210.61.82.183]:25674 "EHLO mailgw01.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726586AbgIBMD6 (ORCPT ); Wed, 2 Sep 2020 08:03:58 -0400 X-UUID: b548118ad3ef4056bbc3c4ccb931fecf-20200902 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=WuLF7XUDCvhjAwYLLqbgLri0W+RaEcgUk7UYnX2QiR8=; b=JZRin0MgPDYNFyCZBl4V2/T+JpwN00e+BAYZ8zjENsPhd0gput85WIg4Igg4LfMVpZgDFkK9XEKlPFODZ52ZJZO5y2naDyOhVenZkXwvnY9mH9dwk0opsOAAm4e18OO2mBsoMMqBpZDXXu498PjXgdV2CCxcGVqdJ+jHIca90ms=; X-UUID: b548118ad3ef4056bbc3c4ccb931fecf-20200902 Received: from mtkcas11.mediatek.inc [(172.21.101.40)] by mailgw01.mediatek.com (envelope-from ) (Cellopoint E-mail Firewall v4.1.14 Build 0819 with TLSv1.2 ECDHE-RSA-AES256-SHA384 256/256) with ESMTP id 1641207861; Wed, 02 Sep 2020 20:03:44 +0800 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs07n1.mediatek.inc (172.21.101.16) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 2 Sep 2020 20:03:40 +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; Wed, 2 Sep 2020 20:03:39 +0800 From: Dongchun Zhu To: , , , , , , , , CC: , , , , , , , , Subject: [PATCH v14 2/2] media: i2c: Add OV02A10 image sensor driver Date: Wed, 2 Sep 2020 20:01:22 +0800 Message-ID: <20200902120122.24456-3-dongchun.zhu@mediatek.com> X-Mailer: git-send-email 2.9.2 In-Reply-To: <20200902120122.24456-1-dongchun.zhu@mediatek.com> References: <20200902120122.24456-1-dongchun.zhu@mediatek.com> MIME-Version: 1.0 Content-Type: text/plain X-MTK: N Content-Transfer-Encoding: base64 Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org QWRkIGEgVjRMMiBzdWItZGV2aWNlIGRyaXZlciBmb3IgT21uaVZpc2lvbiBPVjAyQTEwIGltYWdl IHNlbnNvci4NCg0KU2lnbmVkLW9mZi1ieTogRG9uZ2NodW4gWmh1IDxkb25nY2h1bi56aHVAbWVk aWF0ZWsuY29tPg0KLS0tDQogTUFJTlRBSU5FUlMgICAgICAgICAgICAgICAgIHwgICAgMSArDQog ZHJpdmVycy9tZWRpYS9pMmMvS2NvbmZpZyAgIHwgICAxMyArDQogZHJpdmVycy9tZWRpYS9pMmMv TWFrZWZpbGUgIHwgICAgMSArDQogZHJpdmVycy9tZWRpYS9pMmMvb3YwMmExMC5jIHwgMTA4MyAr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrDQogNCBmaWxlcyBjaGFu Z2VkLCAxMDk4IGluc2VydGlvbnMoKykNCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9tZWRp YS9pMmMvb3YwMmExMC5jDQoNCmRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJT DQppbmRleCA0OGFhN2E3Li5jZTdkOGZhIDEwMDY0NA0KLS0tIGEvTUFJTlRBSU5FUlMNCisrKyBi L01BSU5UQUlORVJTDQpAQCAtMTI3MjQsNiArMTI3MjQsNyBAQCBMOglsaW51eC1tZWRpYUB2Z2Vy Lmtlcm5lbC5vcmcNCiBTOglNYWludGFpbmVkDQogVDoJZ2l0IGdpdDovL2xpbnV4dHYub3JnL21l ZGlhX3RyZWUuZ2l0DQogRjoJRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL21lZGlh L2kyYy9vdnRpLG92MDJhMTAueWFtbA0KK0Y6CWRyaXZlcnMvbWVkaWEvaTJjL292MDJhMTAuYw0K IA0KIE9NTklWSVNJT04gT1YxMzg1OCBTRU5TT1IgRFJJVkVSDQogTToJU2FrYXJpIEFpbHVzIDxz YWthcmkuYWlsdXNAbGludXguaW50ZWwuY29tPg0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEv aTJjL0tjb25maWcgYi9kcml2ZXJzL21lZGlhL2kyYy9LY29uZmlnDQppbmRleCA0OGFlNjBhLi5m NDU4ODA0IDEwMDY0NA0KLS0tIGEvZHJpdmVycy9tZWRpYS9pMmMvS2NvbmZpZw0KKysrIGIvZHJp dmVycy9tZWRpYS9pMmMvS2NvbmZpZw0KQEAgLTgyNSw2ICs4MjUsMTkgQEAgY29uZmlnIFZJREVP X0lNWDM1NQ0KIAkgIFRvIGNvbXBpbGUgdGhpcyBkcml2ZXIgYXMgYSBtb2R1bGUsIGNob29zZSBN IGhlcmU6IHRoZQ0KIAkgIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCBpbXgzNTUuDQogDQorY29uZmln IFZJREVPX09WMDJBMTANCisJdHJpc3RhdGUgIk9tbmlWaXNpb24gT1YwMkExMCBzZW5zb3Igc3Vw cG9ydCINCisJZGVwZW5kcyBvbiBJMkMgJiYgVklERU9fVjRMMg0KKwlzZWxlY3QgTUVESUFfQ09O VFJPTExFUg0KKwlzZWxlY3QgVklERU9fVjRMMl9TVUJERVZfQVBJDQorCXNlbGVjdCBWNEwyX0ZX Tk9ERQ0KKwloZWxwDQorCSAgVGhpcyBpcyBhIFZpZGVvNExpbnV4MiBzZW5zb3IgZHJpdmVyIGZv ciB0aGUgT21uaVZpc2lvbg0KKwkgIE9WMDJBMTAgY2FtZXJhIHNlbnNvci4NCisNCisJICBUbyBj b21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9vc2UgTSBoZXJlOiB0aGUNCisJICBt b2R1bGUgd2lsbCBiZSBjYWxsZWQgb3YwMmExMC4NCisNCiBjb25maWcgVklERU9fT1YyNjQwDQog CXRyaXN0YXRlICJPbW5pVmlzaW9uIE9WMjY0MCBzZW5zb3Igc3VwcG9ydCINCiAJZGVwZW5kcyBv biBWSURFT19WNEwyICYmIEkyQw0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvaTJjL01ha2Vm aWxlIGIvZHJpdmVycy9tZWRpYS9pMmMvTWFrZWZpbGUNCmluZGV4IGYwYTc3NDcuLmRjMjdlMTQg MTAwNjQ0DQotLS0gYS9kcml2ZXJzL21lZGlhL2kyYy9NYWtlZmlsZQ0KKysrIGIvZHJpdmVycy9t ZWRpYS9pMmMvTWFrZWZpbGUNCkBAIC02NCw2ICs2NCw3IEBAIG9iai0kKENPTkZJR19WSURFT19W UDI3U01QWCkgKz0gdnAyN3NtcHgubw0KIG9iai0kKENPTkZJR19WSURFT19TT05ZX0JURl9NUFgp ICs9IHNvbnktYnRmLW1weC5vDQogb2JqLSQoQ09ORklHX1ZJREVPX1VQRDY0MDMxQSkgKz0gdXBk NjQwMzFhLm8NCiBvYmotJChDT05GSUdfVklERU9fVVBENjQwODMpICs9IHVwZDY0MDgzLm8NCitv YmotJChDT05GSUdfVklERU9fT1YwMkExMCkgKz0gb3YwMmExMC5vDQogb2JqLSQoQ09ORklHX1ZJ REVPX09WMjY0MCkgKz0gb3YyNjQwLm8NCiBvYmotJChDT05GSUdfVklERU9fT1YyNjgwKSArPSBv djI2ODAubw0KIG9iai0kKENPTkZJR19WSURFT19PVjI2ODUpICs9IG92MjY4NS5vDQpkaWZmIC0t Z2l0IGEvZHJpdmVycy9tZWRpYS9pMmMvb3YwMmExMC5jIGIvZHJpdmVycy9tZWRpYS9pMmMvb3Yw MmExMC5jDQpuZXcgZmlsZSBtb2RlIDEwMDY0NA0KaW5kZXggMDAwMDAwMC4uMWY4YzUyNQ0KLS0t IC9kZXYvbnVsbA0KKysrIGIvZHJpdmVycy9tZWRpYS9pMmMvb3YwMmExMC5jDQpAQCAtMCwwICsx LDEwODMgQEANCisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMA0KKy8vIENvcHly aWdodCAoYykgMjAyMCBNZWRpYVRlayBJbmMuDQorDQorI2luY2x1ZGUgPGxpbnV4L2Nsay5oPg0K KyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPg0KKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4NCisj aW5jbHVkZSA8bGludXgvZ3Bpby9jb25zdW1lci5oPg0KKyNpbmNsdWRlIDxsaW51eC9pMmMuaD4N CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+DQorI2luY2x1ZGUgPGxpbnV4L3BtX3J1bnRpbWUu aD4NCisjaW5jbHVkZSA8bGludXgvcmVndWxhdG9yL2NvbnN1bWVyLmg+DQorI2luY2x1ZGUgPG1l ZGlhL21lZGlhLWVudGl0eS5oPg0KKyNpbmNsdWRlIDxtZWRpYS92NGwyLWFzeW5jLmg+DQorI2lu Y2x1ZGUgPG1lZGlhL3Y0bDItY3RybHMuaD4NCisjaW5jbHVkZSA8bWVkaWEvdjRsMi1zdWJkZXYu aD4NCisjaW5jbHVkZSA8bWVkaWEvdjRsMi1md25vZGUuaD4NCisNCisjZGVmaW5lIENISVBfSUQJ CQkJCQkweDI1MDkNCisjZGVmaW5lIE9WMDJBMTBfUkVHX0NISVBfSURfSAkJCQkweDAyDQorI2Rl ZmluZSBPVjAyQTEwX1JFR19DSElQX0lEX0wJCQkJMHgwMw0KKw0KKy8qIEJpdFsxXSB2ZXJ0aWNh bCB1cHNpZGUgZG93biAqLw0KKy8qIEJpdFswXSBob3Jpem9udGFsIG1pcnJvciAqLw0KKyNkZWZp bmUgUkVHX01JUlJPUl9GTElQX0NPTlRST0wJCQkJMHgzZg0KKw0KKy8qIE9yaWVudGF0aW9uICov DQorI2RlZmluZSBSRUdfTUlSUk9SX0ZMSVBfRU5BQkxFCQkJCTB4MDMNCisNCisvKiBCaXRbMjow XSBNSVBJIHRyYW5zbWlzc2lvbiBzcGVlZCBzZWxlY3QgKi8NCisjZGVmaW5lIFRYX1NQRUVEX0FS RUFfU0VMCQkJCTB4YTENCisjZGVmaW5lIE9WMDJBMTBfTUlQSV9UWF9TUEVFRF9ERUZBVUxUCQkJ MHgwNA0KKw0KKyNkZWZpbmUgUkVHX1BBR0VfU1dJVENICQkJCQkweGZkDQorI2RlZmluZSBSRUdf R0xPQkFMX0VGRkVDVElWRQkJCQkweDAxDQorI2RlZmluZSBSRUdfRU5BQkxFCQkJCQlCSVQoMCkN CisNCisjZGVmaW5lIFJFR19TQ19DVFJMX01PREUJCQkJMHhhYw0KKyNkZWZpbmUgU0NfQ1RSTF9N T0RFX1NUQU5EQlkJCQkJMHgwMA0KKyNkZWZpbmUgU0NfQ1RSTF9NT0RFX1NUUkVBTUlORwkJCQkw eDAxDQorDQorI2RlZmluZSBPVjAyQTEwX0VYUF9TSElGVAkJCQk4DQorI2RlZmluZSBPVjAyQTEw X1JFR19FWFBPU1VSRV9ICQkJCTB4MDMNCisjZGVmaW5lIE9WMDJBMTBfUkVHX0VYUE9TVVJFX0wJ CQkJMHgwNA0KKyNkZWZpbmUJT1YwMkExMF9FWFBPU1VSRV9NSU4JCQkJNA0KKyNkZWZpbmUgT1Yw MkExMF9FWFBPU1VSRV9NQVhfTUFSR0lOCQkJNA0KKyNkZWZpbmUJT1YwMkExMF9FWFBPU1VSRV9T VEVQCQkJCTENCisNCisjZGVmaW5lIE9WMDJBMTBfVlRTX1NISUZUCQkJCTgNCisjZGVmaW5lIE9W MDJBMTBfUkVHX1ZUU19ICQkJCTB4MDUNCisjZGVmaW5lIE9WMDJBMTBfUkVHX1ZUU19MCQkJCTB4 MDYNCisjZGVmaW5lIE9WMDJBMTBfVlRTX01BWAkJCQkJMHgyMDlmDQorI2RlZmluZSBPVjAyQTEw X0JBU0lDX0xJTkUJCQkJMTIyNA0KKw0KKyNkZWZpbmUgT1YwMkExMF9SRUdfR0FJTgkJCQkweDI0 DQorI2RlZmluZSBPVjAyQTEwX0dBSU5fTUlOCQkJCTB4MTANCisjZGVmaW5lIE9WMDJBMTBfR0FJ Tl9NQVgJCQkJMHhmOA0KKyNkZWZpbmUgT1YwMkExMF9HQUlOX1NURVAJCQkJMHgwMQ0KKyNkZWZp bmUgT1YwMkExMF9HQUlOX0RFRkFVTFQJCQkJMHg0MA0KKw0KKy8qIFRlc3QgcGF0dGVybiBjb250 cm9sICovDQorI2RlZmluZSBPVjAyQTEwX1JFR19URVNUX1BBVFRFUk4JCQkweGI2DQorDQorI2Rl ZmluZSBIWl9QRVJfTUhaCQkJCQkxMDAwMDAwTA0KKyNkZWZpbmUgT1YwMkExMF9MSU5LX0ZSRVFf MzkwTUhaCQkJKDM5MCAqIEhaX1BFUl9NSFopDQorI2RlZmluZSBPVjAyQTEwX0VDTEtfRlJFUQkJ CQkoMjQgKiBIWl9QRVJfTUhaKQ0KKyNkZWZpbmUgT1YwMkExMF9EQVRBX0xBTkVTCQkJCTENCisj ZGVmaW5lIE9WMDJBMTBfQklUU19QRVJfU0FNUExFCQkJCTEwDQorDQorc3RhdGljIGNvbnN0IGNo YXIgKiBjb25zdCBvdjAyYTEwX3N1cHBseV9uYW1lc1tdID0gew0KKwkiZG92ZGQiLAkvKiBEaWdp dGFsIEkvTyBwb3dlciAqLw0KKwkiYXZkZCIsCQkvKiBBbmFsb2cgcG93ZXIgKi8NCisJImR2ZGQi LAkJLyogRGlnaXRhbCBjb3JlIHBvd2VyICovDQorfTsNCisNCitzdHJ1Y3Qgb3YwMmExMF9yZWcg ew0KKwl1OCBhZGRyOw0KKwl1OCB2YWw7DQorfTsNCisNCitzdHJ1Y3Qgb3YwMmExMF9yZWdfbGlz dCB7DQorCXUzMiBudW1fb2ZfcmVnczsNCisJY29uc3Qgc3RydWN0IG92MDJhMTBfcmVnICpyZWdz Ow0KK307DQorDQorc3RydWN0IG92MDJhMTBfbW9kZSB7DQorCXUzMiB3aWR0aDsNCisJdTMyIGhl aWdodDsNCisJdTMyIGV4cF9kZWY7DQorCXUzMiBodHNfZGVmOw0KKwl1MzIgdnRzX2RlZjsNCisJ Y29uc3Qgc3RydWN0IG92MDJhMTBfcmVnX2xpc3QgcmVnX2xpc3Q7DQorfTsNCisNCitzdHJ1Y3Qg b3YwMmExMCB7DQorCXUzMiBlY2xrX2ZyZXE7DQorCS8qIEluZGljYXRpb24gb2YgTUlQSSB0cmFu c21pc3Npb24gc3BlZWQgc2VsZWN0ICovDQorCXUzMiBtaXBpX2Nsb2NrX3ZvbHRhZ2U7DQorCS8q IEluZGV4IG9mIGxpbmsgZnJlcXVlbmN5IGNvbmZpZyB0byBiZSB1c2VkICovDQorCXUzMiBmcmVx X2luZGV4Ow0KKw0KKwlzdHJ1Y3QgY2xrICplY2xrOw0KKwlzdHJ1Y3QgZ3Bpb19kZXNjICpwZF9n cGlvOw0KKwlzdHJ1Y3QgZ3Bpb19kZXNjICpyc3RfZ3BpbzsNCisJc3RydWN0IHJlZ3VsYXRvcl9i dWxrX2RhdGEgc3VwcGxpZXNbQVJSQVlfU0laRShvdjAyYTEwX3N1cHBseV9uYW1lcyldOw0KKw0K Kwlib29sIHN0cmVhbWluZzsNCisJYm9vbCB1cHNpZGVfZG93bjsNCisNCisJLyoNCisJICogU2Vy aWFsaXplIGNvbnRyb2wgYWNjZXNzLCBnZXQvc2V0IGZvcm1hdCwgZ2V0IHNlbGVjdGlvbg0KKwkg KiBhbmQgc3RhcnQgc3RyZWFtaW5nLg0KKwkgKi8NCisJc3RydWN0IG11dGV4IG11dGV4Ow0KKwlz dHJ1Y3QgdjRsMl9zdWJkZXYgc3ViZGV2Ow0KKwlzdHJ1Y3QgbWVkaWFfcGFkIHBhZDsNCisJc3Ry dWN0IHY0bDJfbWJ1c19mcmFtZWZtdCBmbXQ7DQorCXN0cnVjdCB2NGwyX2N0cmxfaGFuZGxlciBj dHJsX2hhbmRsZXI7DQorCXN0cnVjdCB2NGwyX2N0cmwgKmV4cG9zdXJlOw0KKw0KKwljb25zdCBz dHJ1Y3Qgb3YwMmExMF9tb2RlICpjdXJfbW9kZTsNCit9Ow0KKw0KK3N0YXRpYyBpbmxpbmUgc3Ry dWN0IG92MDJhMTAgKnRvX292MDJhMTAoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCkNCit7DQorCXJl dHVybiBjb250YWluZXJfb2Yoc2QsIHN0cnVjdCBvdjAyYTEwLCBzdWJkZXYpOw0KK30NCisNCisv Kg0KKyAqIGVjbGsgMjRNaHoNCisgKiBwY2xrIDM5TWh6DQorICogbGluZWxlbmd0aCA5MzQoMHgz YTYpDQorICogZnJhbWVsZW5ndGggMTM5MCgweDU2RSkNCisgKiBncmFid2luZG93X3dpZHRoIDE2 MDANCisgKiBncmFid2luZG93X2hlaWdodCAxMjAwDQorICogbWF4X2ZyYW1lcmF0ZSAzMGZwcw0K KyAqIG1pcGlfZGF0YXJhdGUgcGVyIGxhbmUgNzgwTWJwcw0KKyAqLw0KK3N0YXRpYyBjb25zdCBz dHJ1Y3Qgb3YwMmExMF9yZWcgb3YwMmExMF8xNjAweDEyMDBfcmVnc1tdID0gew0KKwl7MHhmZCwg MHgwMX0sDQorCXsweGFjLCAweDAwfSwNCisJezB4ZmQsIDB4MDB9LA0KKwl7MHgyZiwgMHgyOX0s DQorCXsweDM0LCAweDAwfSwNCisJezB4MzUsIDB4MjF9LA0KKwl7MHgzMCwgMHgxNX0sDQorCXsw eDMzLCAweDAxfSwNCisJezB4ZmQsIDB4MDF9LA0KKwl7MHg0NCwgMHgwMH0sDQorCXsweDJhLCAw eDRjfSwNCisJezB4MmIsIDB4MWV9LA0KKwl7MHgyYywgMHg2MH0sDQorCXsweDI1LCAweDExfSwN CisJezB4MDMsIDB4MDF9LA0KKwl7MHgwNCwgMHhhZX0sDQorCXsweDA5LCAweDAwfSwNCisJezB4 MGEsIDB4MDJ9LA0KKwl7MHgwNiwgMHhhNn0sDQorCXsweDMxLCAweDAwfSwNCisJezB4MjQsIDB4 NDB9LA0KKwl7MHgwMSwgMHgwMX0sDQorCXsweGZiLCAweDczfSwNCisJezB4ZmQsIDB4MDF9LA0K Kwl7MHgxNiwgMHgwNH0sDQorCXsweDFjLCAweDA5fSwNCisJezB4MjEsIDB4NDJ9LA0KKwl7MHgx MiwgMHgwNH0sDQorCXsweDEzLCAweDEwfSwNCisJezB4MTEsIDB4NDB9LA0KKwl7MHgzMywgMHg4 MX0sDQorCXsweGQwLCAweDAwfSwNCisJezB4ZDEsIDB4MDF9LA0KKwl7MHhkMiwgMHgwMH0sDQor CXsweDUwLCAweDEwfSwNCisJezB4NTEsIDB4MjN9LA0KKwl7MHg1MiwgMHgyMH0sDQorCXsweDUz LCAweDEwfSwNCisJezB4NTQsIDB4MDJ9LA0KKwl7MHg1NSwgMHgyMH0sDQorCXsweDU2LCAweDAy fSwNCisJezB4NTgsIDB4NDh9LA0KKwl7MHg1ZCwgMHgxNX0sDQorCXsweDVlLCAweDA1fSwNCisJ ezB4NjYsIDB4NjZ9LA0KKwl7MHg2OCwgMHg2OH0sDQorCXsweDZiLCAweDAwfSwNCisJezB4NmMs IDB4MDB9LA0KKwl7MHg2ZiwgMHg0MH0sDQorCXsweDcwLCAweDQwfSwNCisJezB4NzEsIDB4MGF9 LA0KKwl7MHg3MiwgMHhmMH0sDQorCXsweDczLCAweDEwfSwNCisJezB4NzUsIDB4ODB9LA0KKwl7 MHg3NiwgMHgxMH0sDQorCXsweDg0LCAweDAwfSwNCisJezB4ODUsIDB4MTB9LA0KKwl7MHg4Niwg MHgxMH0sDQorCXsweDg3LCAweDAwfSwNCisJezB4OGEsIDB4MjJ9LA0KKwl7MHg4YiwgMHgyMn0s DQorCXsweDE5LCAweGYxfSwNCisJezB4MjksIDB4MDF9LA0KKwl7MHhmZCwgMHgwMX0sDQorCXsw eDlkLCAweDE2fSwNCisJezB4YTAsIDB4Mjl9LA0KKwl7MHhhMSwgMHgwNH0sDQorCXsweGFkLCAw eDYyfSwNCisJezB4YWUsIDB4MDB9LA0KKwl7MHhhZiwgMHg4NX0sDQorCXsweGIxLCAweDAxfSwN CisJezB4OGUsIDB4MDZ9LA0KKwl7MHg4ZiwgMHg0MH0sDQorCXsweDkwLCAweDA0fSwNCisJezB4 OTEsIDB4YjB9LA0KKwl7MHg0NSwgMHgwMX0sDQorCXsweDQ2LCAweDAwfSwNCisJezB4NDcsIDB4 NmN9LA0KKwl7MHg0OCwgMHgwM30sDQorCXsweDQ5LCAweDhifSwNCisJezB4NGEsIDB4MDB9LA0K Kwl7MHg0YiwgMHgwN30sDQorCXsweDRjLCAweDA0fSwNCisJezB4NGQsIDB4Yjd9LA0KKwl7MHhm MCwgMHg0MH0sDQorCXsweGYxLCAweDQwfSwNCisJezB4ZjIsIDB4NDB9LA0KKwl7MHhmMywgMHg0 MH0sDQorCXsweDNmLCAweDAwfSwNCisJezB4ZmQsIDB4MDF9LA0KKwl7MHgwNSwgMHgwMH0sDQor CXsweDA2LCAweGE2fSwNCisJezB4ZmQsIDB4MDF9LA0KK307DQorDQorc3RhdGljIGNvbnN0IGNo YXIgKiBjb25zdCBvdjAyYTEwX3Rlc3RfcGF0dGVybl9tZW51W10gPSB7DQorCSJEaXNhYmxlZCIs DQorCSJFaWdodCBWZXJ0aWNhbCBDb2xvdXIgQmFycyIsDQorfTsNCisNCitzdGF0aWMgY29uc3Qg czY0IGxpbmtfZnJlcV9tZW51X2l0ZW1zW10gPSB7DQorCU9WMDJBMTBfTElOS19GUkVRXzM5ME1I WiwNCit9Ow0KKw0KK3N0YXRpYyB1NjQgdG9fcGl4ZWxfcmF0ZSh1MzIgZl9pbmRleCkNCit7DQor CXU2NCBwaXhlbF9yYXRlID0gbGlua19mcmVxX21lbnVfaXRlbXNbZl9pbmRleF0gKiAyICogT1Yw MkExMF9EQVRBX0xBTkVTOw0KKw0KKwlkb19kaXYocGl4ZWxfcmF0ZSwgT1YwMkExMF9CSVRTX1BF Ul9TQU1QTEUpOw0KKw0KKwlyZXR1cm4gcGl4ZWxfcmF0ZTsNCit9DQorDQorc3RhdGljIGNvbnN0 IHN0cnVjdCBvdjAyYTEwX21vZGUgc3VwcG9ydGVkX21vZGVzW10gPSB7DQorCXsNCisJCS53aWR0 aCA9IDE2MDAsDQorCQkuaGVpZ2h0ID0gMTIwMCwNCisJCS5leHBfZGVmID0gMHgwMWFlLA0KKwkJ Lmh0c19kZWYgPSAweDAzYTYsDQorCQkudnRzX2RlZiA9IDB4MDU2ZSwNCisJCS5yZWdfbGlzdCA9 IHsNCisJCQkubnVtX29mX3JlZ3MgPSBBUlJBWV9TSVpFKG92MDJhMTBfMTYwMHgxMjAwX3JlZ3Mp LA0KKwkJCS5yZWdzID0gb3YwMmExMF8xNjAweDEyMDBfcmVncywNCisJCX0sDQorCX0sDQorfTsN CisNCitzdGF0aWMgaW50IG92MDJhMTBfd3JpdGVfYXJyYXkoc3RydWN0IG92MDJhMTAgKm92MDJh MTAsDQorCQkJICAgICAgIGNvbnN0IHN0cnVjdCBvdjAyYTEwX3JlZ19saXN0ICpyX2xpc3QpDQor ew0KKwlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gdjRsMl9nZXRfc3ViZGV2ZGF0YSgmb3Yw MmExMC0+c3ViZGV2KTsNCisJdW5zaWduZWQgaW50IGk7DQorCWludCByZXQ7DQorDQorCWZvciAo aSA9IDA7IGkgPCByX2xpc3QtPm51bV9vZl9yZWdzOyBpKyspIHsNCisJCXJldCA9IGkyY19zbWJ1 c193cml0ZV9ieXRlX2RhdGEoY2xpZW50LCByX2xpc3QtPnJlZ3NbaV0uYWRkciwNCisJCQkJCQly X2xpc3QtPnJlZ3NbaV0udmFsKTsNCisJCWlmIChyZXQgPCAwKQ0KKwkJCXJldHVybiByZXQ7DQor CX0NCisNCisJcmV0dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyBpbnQgb3YwMmExMF9yZWFkX3NtYnVz KHN0cnVjdCBvdjAyYTEwICpvdjAyYTEwLCB1bnNpZ25lZCBjaGFyIHJlZywNCisJCQkgICAgICB1 bnNpZ25lZCBjaGFyICp2YWwpDQorew0KKwlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gdjRs Ml9nZXRfc3ViZGV2ZGF0YSgmb3YwMmExMC0+c3ViZGV2KTsNCisJaW50IHJldDsNCisNCisJcmV0 ID0gaTJjX3NtYnVzX3JlYWRfYnl0ZV9kYXRhKGNsaWVudCwgcmVnKTsNCisJaWYgKHJldCA8IDAp DQorCQlyZXR1cm4gcmV0Ow0KKw0KKwkqdmFsID0gKHVuc2lnbmVkIGNoYXIpcmV0Ow0KKw0KKwly ZXR1cm4gMDsNCit9DQorDQorc3RhdGljIHZvaWQgb3YwMmExMF9maWxsX2ZtdChjb25zdCBzdHJ1 Y3Qgb3YwMmExMF9tb2RlICptb2RlLA0KKwkJCSAgICAgc3RydWN0IHY0bDJfbWJ1c19mcmFtZWZt dCAqZm10KQ0KK3sNCisJZm10LT53aWR0aCA9IG1vZGUtPndpZHRoOw0KKwlmbXQtPmhlaWdodCA9 IG1vZGUtPmhlaWdodDsNCisJZm10LT5maWVsZCA9IFY0TDJfRklFTERfTk9ORTsNCit9DQorDQor c3RhdGljIGludCBvdjAyYTEwX3NldF9mbXQoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCwNCisJCQkg ICBzdHJ1Y3QgdjRsMl9zdWJkZXZfcGFkX2NvbmZpZyAqY2ZnLA0KKwkJCSAgIHN0cnVjdCB2NGwy X3N1YmRldl9mb3JtYXQgKmZtdCkNCit7DQorCXN0cnVjdCBvdjAyYTEwICpvdjAyYTEwID0gdG9f b3YwMmExMChzZCk7DQorCXN0cnVjdCB2NGwyX21idXNfZnJhbWVmbXQgKm1idXNfZm10ID0gJmZt dC0+Zm9ybWF0Ow0KKwlzdHJ1Y3QgdjRsMl9tYnVzX2ZyYW1lZm10ICpmcmFtZV9mbXQ7DQorCWlu dCByZXQgPSAwOw0KKw0KKwltdXRleF9sb2NrKCZvdjAyYTEwLT5tdXRleCk7DQorDQorCWlmIChv djAyYTEwLT5zdHJlYW1pbmcgJiYgZm10LT53aGljaCA9PSBWNEwyX1NVQkRFVl9GT1JNQVRfQUNU SVZFKSB7DQorCQlyZXQgPSAtRUJVU1k7DQorCQlnb3RvIGVycm9yOw0KKwl9DQorDQorCS8qIE9u bHkgb25lIHNlbnNvciBtb2RlIHN1cHBvcnRlZCAqLw0KKwltYnVzX2ZtdC0+Y29kZSA9IG92MDJh MTAtPmZtdC5jb2RlOw0KKwlvdjAyYTEwX2ZpbGxfZm10KG92MDJhMTAtPmN1cl9tb2RlLCBtYnVz X2ZtdCk7DQorDQorCWlmIChmbXQtPndoaWNoID09IFY0TDJfU1VCREVWX0ZPUk1BVF9UUlkpDQor CQlmcmFtZV9mbXQgPSB2NGwyX3N1YmRldl9nZXRfdHJ5X2Zvcm1hdChzZCwgY2ZnLCAwKTsNCisJ ZWxzZQ0KKwkJZnJhbWVfZm10ID0gJm92MDJhMTAtPmZtdDsNCisNCisJKmZyYW1lX2ZtdCA9ICpt YnVzX2ZtdDsNCisNCitlcnJvcjoNCisJbXV0ZXhfdW5sb2NrKCZvdjAyYTEwLT5tdXRleCk7DQor CXJldHVybiByZXQ7DQorfQ0KKw0KK3N0YXRpYyBpbnQgb3YwMmExMF9nZXRfZm10KHN0cnVjdCB2 NGwyX3N1YmRldiAqc2QsDQorCQkJICAgc3RydWN0IHY0bDJfc3ViZGV2X3BhZF9jb25maWcgKmNm ZywNCisJCQkgICBzdHJ1Y3QgdjRsMl9zdWJkZXZfZm9ybWF0ICpmbXQpDQorew0KKwlzdHJ1Y3Qg b3YwMmExMCAqb3YwMmExMCA9IHRvX292MDJhMTAoc2QpOw0KKwlzdHJ1Y3QgdjRsMl9tYnVzX2Zy YW1lZm10ICptYnVzX2ZtdCA9ICZmbXQtPmZvcm1hdDsNCisNCisJbXV0ZXhfbG9jaygmb3YwMmEx MC0+bXV0ZXgpOw0KKw0KKwlpZiAoZm10LT53aGljaCA9PSBWNEwyX1NVQkRFVl9GT1JNQVRfVFJZ KSB7DQorCQlmbXQtPmZvcm1hdCA9ICp2NGwyX3N1YmRldl9nZXRfdHJ5X2Zvcm1hdChzZCwgY2Zn LCBmbXQtPnBhZCk7DQorCX0gZWxzZSB7DQorCQlmbXQtPmZvcm1hdCA9IG92MDJhMTAtPmZtdDsN CisJCW1idXNfZm10LT5jb2RlID0gb3YwMmExMC0+Zm10LmNvZGU7DQorCQlvdjAyYTEwX2ZpbGxf Zm10KG92MDJhMTAtPmN1cl9tb2RlLCBtYnVzX2ZtdCk7DQorCX0NCisNCisJbXV0ZXhfdW5sb2Nr KCZvdjAyYTEwLT5tdXRleCk7DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMgaW50IG92 MDJhMTBfZW51bV9tYnVzX2NvZGUoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCwNCisJCQkJICBzdHJ1 Y3QgdjRsMl9zdWJkZXZfcGFkX2NvbmZpZyAqY2ZnLA0KKwkJCQkgIHN0cnVjdCB2NGwyX3N1YmRl dl9tYnVzX2NvZGVfZW51bSAqY29kZSkNCit7DQorCXN0cnVjdCBvdjAyYTEwICpvdjAyYTEwID0g dG9fb3YwMmExMChzZCk7DQorDQorCWlmIChjb2RlLT5pbmRleCAhPSAwKQ0KKwkJcmV0dXJuIC1F SU5WQUw7DQorDQorCWNvZGUtPmNvZGUgPSBvdjAyYTEwLT5mbXQuY29kZTsNCisNCisJcmV0dXJu IDA7DQorfQ0KKw0KK3N0YXRpYyBpbnQgb3YwMmExMF9lbnVtX2ZyYW1lX3NpemVzKHN0cnVjdCB2 NGwyX3N1YmRldiAqc2QsDQorCQkJCSAgICBzdHJ1Y3QgdjRsMl9zdWJkZXZfcGFkX2NvbmZpZyAq Y2ZnLA0KKwkJCQkgICAgc3RydWN0IHY0bDJfc3ViZGV2X2ZyYW1lX3NpemVfZW51bSAqZnNlKQ0K K3sNCisJaWYgKGZzZS0+aW5kZXggPj0gQVJSQVlfU0laRShzdXBwb3J0ZWRfbW9kZXMpKQ0KKwkJ cmV0dXJuIC1FSU5WQUw7DQorDQorCWZzZS0+bWluX3dpZHRoICA9IHN1cHBvcnRlZF9tb2Rlc1tm c2UtPmluZGV4XS53aWR0aDsNCisJZnNlLT5tYXhfd2lkdGggID0gc3VwcG9ydGVkX21vZGVzW2Zz ZS0+aW5kZXhdLndpZHRoOw0KKwlmc2UtPm1heF9oZWlnaHQgPSBzdXBwb3J0ZWRfbW9kZXNbZnNl LT5pbmRleF0uaGVpZ2h0Ow0KKwlmc2UtPm1pbl9oZWlnaHQgPSBzdXBwb3J0ZWRfbW9kZXNbZnNl LT5pbmRleF0uaGVpZ2h0Ow0KKw0KKwlyZXR1cm4gMDsNCit9DQorDQorc3RhdGljIGludCBvdjAy YTEwX2NoZWNrX3NlbnNvcl9pZChzdHJ1Y3Qgb3YwMmExMCAqb3YwMmExMCkNCit7DQorCXN0cnVj dCBpMmNfY2xpZW50ICpjbGllbnQgPSB2NGwyX2dldF9zdWJkZXZkYXRhKCZvdjAyYTEwLT5zdWJk ZXYpOw0KKwl1MTYgaWQ7DQorCXU4IGNoaXBfaWRfaDsNCisJdTggY2hpcF9pZF9sOw0KKwlpbnQg cmV0Ow0KKw0KKwkvKiBDaGVjayBzZW5zb3IgcmV2aXNpb24gKi8NCisJcmV0ID0gb3YwMmExMF9y ZWFkX3NtYnVzKG92MDJhMTAsIE9WMDJBMTBfUkVHX0NISVBfSURfSCwgJmNoaXBfaWRfaCk7DQor CWlmIChyZXQpDQorCQlyZXR1cm4gcmV0Ow0KKw0KKwlyZXQgPSBvdjAyYTEwX3JlYWRfc21idXMo b3YwMmExMCwgT1YwMkExMF9SRUdfQ0hJUF9JRF9MLCAmY2hpcF9pZF9sKTsNCisJaWYgKHJldCkN CisJCXJldHVybiByZXQ7DQorDQorCWlkID0gKGNoaXBfaWRfaCA8PCA4KSB8IGNoaXBfaWRfbDsN CisJaWYgKGlkICE9IENISVBfSUQpIHsNCisJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiVW5leHBl Y3RlZCBzZW5zb3IgaWQoJTA0eClcbiIsIGlkKTsNCisJCXJldHVybiAtRUlOVkFMOw0KKwl9DQor DQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMgaW50IG92MDJhMTBfcG93ZXJfb24oc3RydWN0 IGRldmljZSAqZGV2KQ0KK3sNCisJc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCA9IHRvX2kyY19j bGllbnQoZGV2KTsNCisJc3RydWN0IHY0bDJfc3ViZGV2ICpzZCA9IGkyY19nZXRfY2xpZW50ZGF0 YShjbGllbnQpOw0KKwlzdHJ1Y3Qgb3YwMmExMCAqb3YwMmExMCA9IHRvX292MDJhMTAoc2QpOw0K KwlpbnQgcmV0Ow0KKw0KKwlncGlvZF9zZXRfdmFsdWVfY2Fuc2xlZXAob3YwMmExMC0+cnN0X2dw aW8sIDEpOw0KKwlncGlvZF9zZXRfdmFsdWVfY2Fuc2xlZXAob3YwMmExMC0+cGRfZ3BpbywgMSk7 DQorDQorCXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShvdjAyYTEwLT5lY2xrKTsNCisJaWYgKHJl dCA8IDApIHsNCisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGVuYWJsZSBlY2xrXG4iKTsNCisJ CXJldHVybiByZXQ7DQorCX0NCisNCisJcmV0ID0gcmVndWxhdG9yX2J1bGtfZW5hYmxlKEFSUkFZ X1NJWkUob3YwMmExMF9zdXBwbHlfbmFtZXMpLA0KKwkJCQkgICAgb3YwMmExMC0+c3VwcGxpZXMp Ow0KKwlpZiAocmV0IDwgMCkgew0KKwkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gZW5hYmxlIHJl Z3VsYXRvcnNcbiIpOw0KKwkJZ290byBkaXNhYmxlX2NsazsNCisJfQ0KKwl1c2xlZXBfcmFuZ2Uo NTAwMCwgNjAwMCk7DQorDQorCWdwaW9kX3NldF92YWx1ZV9jYW5zbGVlcChvdjAyYTEwLT5wZF9n cGlvLCAwKTsNCisJdXNsZWVwX3JhbmdlKDUwMDAsIDYwMDApOw0KKw0KKwlncGlvZF9zZXRfdmFs dWVfY2Fuc2xlZXAob3YwMmExMC0+cnN0X2dwaW8sIDApOw0KKwl1c2xlZXBfcmFuZ2UoNTAwMCwg NjAwMCk7DQorDQorCXJldCA9IG92MDJhMTBfY2hlY2tfc2Vuc29yX2lkKG92MDJhMTApOw0KKwlp ZiAocmV0KQ0KKwkJZ290byBkaXNhYmxlX3JlZ3VsYXRvcjsNCisNCisJcmV0dXJuIDA7DQorDQor ZGlzYWJsZV9yZWd1bGF0b3I6DQorCXJlZ3VsYXRvcl9idWxrX2Rpc2FibGUoQVJSQVlfU0laRShv djAyYTEwX3N1cHBseV9uYW1lcyksDQorCQkJICAgICAgIG92MDJhMTAtPnN1cHBsaWVzKTsNCitk aXNhYmxlX2NsazoNCisJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKG92MDJhMTAtPmVjbGspOw0KKw0K KwlyZXR1cm4gcmV0Ow0KK30NCisNCitzdGF0aWMgaW50IG92MDJhMTBfcG93ZXJfb2ZmKHN0cnVj dCBkZXZpY2UgKmRldikNCit7DQorCXN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQgPSB0b19pMmNf Y2xpZW50KGRldik7DQorCXN0cnVjdCB2NGwyX3N1YmRldiAqc2QgPSBpMmNfZ2V0X2NsaWVudGRh dGEoY2xpZW50KTsNCisJc3RydWN0IG92MDJhMTAgKm92MDJhMTAgPSB0b19vdjAyYTEwKHNkKTsN CisNCisJZ3Bpb2Rfc2V0X3ZhbHVlX2NhbnNsZWVwKG92MDJhMTAtPnJzdF9ncGlvLCAxKTsNCisJ Y2xrX2Rpc2FibGVfdW5wcmVwYXJlKG92MDJhMTAtPmVjbGspOw0KKwlncGlvZF9zZXRfdmFsdWVf Y2Fuc2xlZXAob3YwMmExMC0+cGRfZ3BpbywgMSk7DQorCXJlZ3VsYXRvcl9idWxrX2Rpc2FibGUo QVJSQVlfU0laRShvdjAyYTEwX3N1cHBseV9uYW1lcyksDQorCQkJICAgICAgIG92MDJhMTAtPnN1 cHBsaWVzKTsNCisNCisJcmV0dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyBpbnQgX19vdjAyYTEwX3N0 YXJ0X3N0cmVhbShzdHJ1Y3Qgb3YwMmExMCAqb3YwMmExMCkNCit7DQorCXN0cnVjdCBpMmNfY2xp ZW50ICpjbGllbnQgPSB2NGwyX2dldF9zdWJkZXZkYXRhKCZvdjAyYTEwLT5zdWJkZXYpOw0KKwlj b25zdCBzdHJ1Y3Qgb3YwMmExMF9yZWdfbGlzdCAqcmVnX2xpc3Q7DQorCWludCByZXQ7DQorDQor CS8qIEFwcGx5IGRlZmF1bHQgdmFsdWVzIG9mIGN1cnJlbnQgbW9kZSAqLw0KKwlyZWdfbGlzdCA9 ICZvdjAyYTEwLT5jdXJfbW9kZS0+cmVnX2xpc3Q7DQorCXJldCA9IG92MDJhMTBfd3JpdGVfYXJy YXkob3YwMmExMCwgcmVnX2xpc3QpOw0KKwlpZiAocmV0KQ0KKwkJcmV0dXJuIHJldDsNCisNCisJ LyogQXBwbHkgY3VzdG9taXplZCB2YWx1ZXMgZnJvbSB1c2VyICovDQorCXJldCA9IF9fdjRsMl9j dHJsX2hhbmRsZXJfc2V0dXAob3YwMmExMC0+c3ViZGV2LmN0cmxfaGFuZGxlcik7DQorCWlmIChy ZXQpDQorCQlyZXR1cm4gcmV0Ow0KKw0KKwkvKiBTZXQgb3JpZW50YXRpb24gdG8gMTgwIGRlZ3Jl ZSAqLw0KKwlpZiAob3YwMmExMC0+dXBzaWRlX2Rvd24pIHsNCisJCXJldCA9IGkyY19zbWJ1c193 cml0ZV9ieXRlX2RhdGEoY2xpZW50LCBSRUdfTUlSUk9SX0ZMSVBfQ09OVFJPTCwNCisJCQkJCQlS RUdfTUlSUk9SX0ZMSVBfRU5BQkxFKTsNCisJCWlmIChyZXQpIHsNCisJCQlkZXZfZXJyKCZjbGll bnQtPmRldiwgImZhaWxlZCB0byBzZXQgb3JpZW50YXRpb25cbiIpOw0KKwkJCXJldHVybiByZXQ7 DQorCQl9DQorCQlyZXQgPSBpMmNfc21idXNfd3JpdGVfYnl0ZV9kYXRhKGNsaWVudCwgUkVHX0dM T0JBTF9FRkZFQ1RJVkUsDQorCQkJCQkJUkVHX0VOQUJMRSk7DQorCQlpZiAocmV0IDwgMCkNCisJ CQlyZXR1cm4gcmV0Ow0KKwl9DQorDQorCS8qIFNldCBNSVBJIFRYIHNwZWVkIGFjY29yZGluZyB0 byBEVCBwcm9wZXJ0eSAqLw0KKwlpZiAob3YwMmExMC0+bWlwaV9jbG9ja192b2x0YWdlICE9IE9W MDJBMTBfTUlQSV9UWF9TUEVFRF9ERUZBVUxUKSB7DQorCQlyZXQgPSBpMmNfc21idXNfd3JpdGVf Ynl0ZV9kYXRhKGNsaWVudCwgVFhfU1BFRURfQVJFQV9TRUwsDQorCQkJCQkJb3YwMmExMC0+bWlw aV9jbG9ja192b2x0YWdlKTsNCisJCWlmIChyZXQgPCAwKQ0KKwkJCXJldHVybiByZXQ7DQorCX0N CisNCisJLyogU2V0IHN0cmVhbSBvbiByZWdpc3RlciAqLw0KKwlyZXR1cm4gaTJjX3NtYnVzX3dy aXRlX2J5dGVfZGF0YShjbGllbnQsIFJFR19TQ19DVFJMX01PREUsDQorCQkJCQkgU0NfQ1RSTF9N T0RFX1NUUkVBTUlORyk7DQorfQ0KKw0KK3N0YXRpYyBpbnQgX19vdjAyYTEwX3N0b3Bfc3RyZWFt KHN0cnVjdCBvdjAyYTEwICpvdjAyYTEwKQ0KK3sNCisJc3RydWN0IGkyY19jbGllbnQgKmNsaWVu dCA9IHY0bDJfZ2V0X3N1YmRldmRhdGEoJm92MDJhMTAtPnN1YmRldik7DQorDQorCXJldHVybiBp MmNfc21idXNfd3JpdGVfYnl0ZV9kYXRhKGNsaWVudCwgUkVHX1NDX0NUUkxfTU9ERSwNCisJCQkJ CSBTQ19DVFJMX01PREVfU1RBTkRCWSk7DQorfQ0KKw0KK3N0YXRpYyBpbnQgb3YwMmExMF9lbnRp dHlfaW5pdF9jZmcoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCwNCisJCQkJICAgc3RydWN0IHY0bDJf c3ViZGV2X3BhZF9jb25maWcgKmNmZykNCit7DQorCXN0cnVjdCB2NGwyX3N1YmRldl9mb3JtYXQg Zm10ID0gew0KKwkJLndoaWNoID0gVjRMMl9TVUJERVZfRk9STUFUX1RSWSwNCisJCS5mb3JtYXQg PSB7DQorCQkJLndpZHRoID0gMTYwMCwNCisJCQkuaGVpZ2h0ID0gMTIwMCwNCisJCX0NCisJfTsN CisNCisJb3YwMmExMF9zZXRfZm10KHNkLCBjZmcsICZmbXQpOw0KKw0KKwlyZXR1cm4gMDsNCit9 DQorDQorc3RhdGljIGludCBvdjAyYTEwX3Nfc3RyZWFtKHN0cnVjdCB2NGwyX3N1YmRldiAqc2Qs IGludCBvbikNCit7DQorCXN0cnVjdCBvdjAyYTEwICpvdjAyYTEwID0gdG9fb3YwMmExMChzZCk7 DQorCXN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQgPSB2NGwyX2dldF9zdWJkZXZkYXRhKCZvdjAy YTEwLT5zdWJkZXYpOw0KKwlpbnQgcmV0Ow0KKw0KKwltdXRleF9sb2NrKCZvdjAyYTEwLT5tdXRl eCk7DQorDQorCWlmIChvdjAyYTEwLT5zdHJlYW1pbmcgPT0gb24pDQorCQlnb3RvIHVubG9ja19h bmRfcmV0dXJuOw0KKw0KKwlpZiAob24pIHsNCisJCXJldCA9IHBtX3J1bnRpbWVfZ2V0X3N5bmMo JmNsaWVudC0+ZGV2KTsNCisJCWlmIChyZXQgPCAwKSB7DQorCQkJcG1fcnVudGltZV9wdXRfbm9p ZGxlKCZjbGllbnQtPmRldik7DQorCQkJZ290byB1bmxvY2tfYW5kX3JldHVybjsNCisJCX0NCisN CisJCXJldCA9IF9fb3YwMmExMF9zdGFydF9zdHJlYW0ob3YwMmExMCk7DQorCQlpZiAocmV0KSB7 DQorCQkJX19vdjAyYTEwX3N0b3Bfc3RyZWFtKG92MDJhMTApOw0KKwkJCW92MDJhMTAtPnN0cmVh bWluZyA9ICFvbjsNCisJCQlnb3RvIGVycl9ycG1fcHV0Ow0KKwkJfQ0KKwl9IGVsc2Ugew0KKwkJ X19vdjAyYTEwX3N0b3Bfc3RyZWFtKG92MDJhMTApOw0KKwkJcG1fcnVudGltZV9wdXQoJmNsaWVu dC0+ZGV2KTsNCisJfQ0KKw0KKwlvdjAyYTEwLT5zdHJlYW1pbmcgPSBvbjsNCisJbXV0ZXhfdW5s b2NrKCZvdjAyYTEwLT5tdXRleCk7DQorDQorCXJldHVybiAwOw0KKw0KK2Vycl9ycG1fcHV0Og0K KwlwbV9ydW50aW1lX3B1dCgmY2xpZW50LT5kZXYpOw0KK3VubG9ja19hbmRfcmV0dXJuOg0KKwlt dXRleF91bmxvY2soJm92MDJhMTAtPm11dGV4KTsNCisNCisJcmV0dXJuIHJldDsNCit9DQorDQor c3RhdGljIGNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIG92MDJhMTBfcG1fb3BzID0gew0KKwlTRVRf U1lTVEVNX1NMRUVQX1BNX09QUyhwbV9ydW50aW1lX2ZvcmNlX3N1c3BlbmQsDQorCQkJCXBtX3J1 bnRpbWVfZm9yY2VfcmVzdW1lKQ0KKwlTRVRfUlVOVElNRV9QTV9PUFMob3YwMmExMF9wb3dlcl9v ZmYsIG92MDJhMTBfcG93ZXJfb24sIE5VTEwpDQorfTsNCisNCisvKg0KKyAqIG92MDJhMTBfc2V0 X2V4cG9zdXJlIC0gRnVuY3Rpb24gY2FsbGVkIHdoZW4gc2V0dGluZyBleHBvc3VyZSB0aW1lDQor ICogQHByaXY6IFBvaW50ZXIgdG8gZGV2aWNlIHN0cnVjdHVyZQ0KKyAqIEB2YWw6IFZhcmlhYmxl IGZvciBleHBvc3VyZSB0aW1lLCBpbiB0aGUgdW5pdCBvZiBtaWNyby1zZWNvbmQNCisgKg0KKyAq IFNldCBleHBvc3VyZSB0aW1lIGJhc2VkIG9uIGlucHV0IHZhbHVlLg0KKyAqDQorICogUmV0dXJu OiAwIG9uIHN1Y2Nlc3MNCisgKi8NCitzdGF0aWMgaW50IG92MDJhMTBfc2V0X2V4cG9zdXJlKHN0 cnVjdCBvdjAyYTEwICpvdjAyYTEwLCBpbnQgdmFsKQ0KK3sNCisJc3RydWN0IGkyY19jbGllbnQg KmNsaWVudCA9IHY0bDJfZ2V0X3N1YmRldmRhdGEoJm92MDJhMTAtPnN1YmRldik7DQorCWludCBy ZXQ7DQorDQorCXJldCA9IGkyY19zbWJ1c193cml0ZV9ieXRlX2RhdGEoY2xpZW50LCBSRUdfUEFH RV9TV0lUQ0gsIFJFR19FTkFCTEUpOw0KKwlpZiAocmV0IDwgMCkNCisJCXJldHVybiByZXQ7DQor DQorCXJldCA9IGkyY19zbWJ1c193cml0ZV9ieXRlX2RhdGEoY2xpZW50LCBPVjAyQTEwX1JFR19F WFBPU1VSRV9ILA0KKwkJCQkJdmFsID4+IE9WMDJBMTBfRVhQX1NISUZUKTsNCisJaWYgKHJldCA8 IDApDQorCQlyZXR1cm4gcmV0Ow0KKw0KKwlyZXQgPSBpMmNfc21idXNfd3JpdGVfYnl0ZV9kYXRh KGNsaWVudCwgT1YwMkExMF9SRUdfRVhQT1NVUkVfTCwgdmFsKTsNCisJaWYgKHJldCA8IDApDQor CQlyZXR1cm4gcmV0Ow0KKw0KKwlyZXR1cm4gaTJjX3NtYnVzX3dyaXRlX2J5dGVfZGF0YShjbGll bnQsIFJFR19HTE9CQUxfRUZGRUNUSVZFLA0KKwkJCQkJIFJFR19FTkFCTEUpOw0KK30NCisNCitz dGF0aWMgaW50IG92MDJhMTBfc2V0X2dhaW4oc3RydWN0IG92MDJhMTAgKm92MDJhMTAsIGludCB2 YWwpDQorew0KKwlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gdjRsMl9nZXRfc3ViZGV2ZGF0 YSgmb3YwMmExMC0+c3ViZGV2KTsNCisJaW50IHJldDsNCisNCisJcmV0ID0gaTJjX3NtYnVzX3dy aXRlX2J5dGVfZGF0YShjbGllbnQsIFJFR19QQUdFX1NXSVRDSCwgUkVHX0VOQUJMRSk7DQorCWlm IChyZXQgPCAwKQ0KKwkJcmV0dXJuIHJldDsNCisNCisJcmV0ID0gaTJjX3NtYnVzX3dyaXRlX2J5 dGVfZGF0YShjbGllbnQsIE9WMDJBMTBfUkVHX0dBSU4sIHZhbCk7DQorCWlmIChyZXQgPCAwKQ0K KwkJcmV0dXJuIHJldDsNCisNCisJcmV0dXJuIGkyY19zbWJ1c193cml0ZV9ieXRlX2RhdGEoY2xp ZW50LCBSRUdfR0xPQkFMX0VGRkVDVElWRSwNCisJCQkJCSBSRUdfRU5BQkxFKTsNCit9DQorDQor c3RhdGljIGludCBvdjAyYTEwX3NldF92Ymxhbmsoc3RydWN0IG92MDJhMTAgKm92MDJhMTAsIGlu dCB2YWwpDQorew0KKwlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gdjRsMl9nZXRfc3ViZGV2 ZGF0YSgmb3YwMmExMC0+c3ViZGV2KTsNCisJdTMyIHZ0cyA9IHZhbCArIG92MDJhMTAtPmN1cl9t b2RlLT5oZWlnaHQgLSBPVjAyQTEwX0JBU0lDX0xJTkU7DQorCWludCByZXQ7DQorDQorCXJldCA9 IGkyY19zbWJ1c193cml0ZV9ieXRlX2RhdGEoY2xpZW50LCBSRUdfUEFHRV9TV0lUQ0gsIFJFR19F TkFCTEUpOw0KKwlpZiAocmV0IDwgMCkNCisJCXJldHVybiByZXQ7DQorDQorCXJldCA9IGkyY19z bWJ1c193cml0ZV9ieXRlX2RhdGEoY2xpZW50LCBPVjAyQTEwX1JFR19WVFNfSCwNCisJCQkJCXZ0 cyA+PiBPVjAyQTEwX1ZUU19TSElGVCk7DQorCWlmIChyZXQgPCAwKQ0KKwkJcmV0dXJuIHJldDsN CisNCisJcmV0ID0gaTJjX3NtYnVzX3dyaXRlX2J5dGVfZGF0YShjbGllbnQsIE9WMDJBMTBfUkVH X1ZUU19MLCB2dHMpOw0KKwlpZiAocmV0IDwgMCkNCisJCXJldHVybiByZXQ7DQorDQorCXJldHVy biBpMmNfc21idXNfd3JpdGVfYnl0ZV9kYXRhKGNsaWVudCwgUkVHX0dMT0JBTF9FRkZFQ1RJVkUs DQorCQkJCQkgUkVHX0VOQUJMRSk7DQorfQ0KKw0KK3N0YXRpYyBpbnQgb3YwMmExMF9zZXRfdGVz dF9wYXR0ZXJuKHN0cnVjdCBvdjAyYTEwICpvdjAyYTEwLCBpbnQgcGF0dGVybikNCit7DQorCXN0 cnVjdCBpMmNfY2xpZW50ICpjbGllbnQgPSB2NGwyX2dldF9zdWJkZXZkYXRhKCZvdjAyYTEwLT5z dWJkZXYpOw0KKwlpbnQgcmV0Ow0KKw0KKwlyZXQgPSBpMmNfc21idXNfd3JpdGVfYnl0ZV9kYXRh KGNsaWVudCwgUkVHX1BBR0VfU1dJVENILCBSRUdfRU5BQkxFKTsNCisJaWYgKHJldCA8IDApDQor CQlyZXR1cm4gcmV0Ow0KKw0KKwlyZXQgPSBpMmNfc21idXNfd3JpdGVfYnl0ZV9kYXRhKGNsaWVu dCwgT1YwMkExMF9SRUdfVEVTVF9QQVRURVJOLA0KKwkJCQkJcGF0dGVybik7DQorCWlmIChyZXQg PCAwKQ0KKwkJcmV0dXJuIHJldDsNCisNCisJcmV0ID0gaTJjX3NtYnVzX3dyaXRlX2J5dGVfZGF0 YShjbGllbnQsIFJFR19HTE9CQUxfRUZGRUNUSVZFLA0KKwkJCQkJUkVHX0VOQUJMRSk7DQorCWlm IChyZXQgPCAwKQ0KKwkJcmV0dXJuIHJldDsNCisNCisJcmV0dXJuIGkyY19zbWJ1c193cml0ZV9i eXRlX2RhdGEoY2xpZW50LCBSRUdfU0NfQ1RSTF9NT0RFLA0KKwkJCQkJIFNDX0NUUkxfTU9ERV9T VFJFQU1JTkcpOw0KK30NCisNCitzdGF0aWMgaW50IG92MDJhMTBfc2V0X2N0cmwoc3RydWN0IHY0 bDJfY3RybCAqY3RybCkNCit7DQorCXN0cnVjdCBvdjAyYTEwICpvdjAyYTEwID0gY29udGFpbmVy X29mKGN0cmwtPmhhbmRsZXIsDQorCQkJCQkgICAgICAgc3RydWN0IG92MDJhMTAsIGN0cmxfaGFu ZGxlcik7DQorCXN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQgPSB2NGwyX2dldF9zdWJkZXZkYXRh KCZvdjAyYTEwLT5zdWJkZXYpOw0KKwlzNjQgbWF4X2V4cG87DQorCWludCByZXQ7DQorDQorCS8q IFByb3BhZ2F0ZSBjaGFuZ2Ugb2YgY3VycmVudCBjb250cm9sIHRvIGFsbCByZWxhdGVkIGNvbnRy b2xzICovDQorCWlmIChjdHJsLT5pZCA9PSBWNEwyX0NJRF9WQkxBTkspIHsNCisJCS8qIFVwZGF0 ZSBtYXggZXhwb3N1cmUgd2hpbGUgbWVldGluZyBleHBlY3RlZCB2YmxhbmtpbmcgKi8NCisJCW1h eF9leHBvID0gb3YwMmExMC0+Y3VyX21vZGUtPmhlaWdodCArIGN0cmwtPnZhbCAtDQorCQkJICAg T1YwMkExMF9FWFBPU1VSRV9NQVhfTUFSR0lOOw0KKwkJX192NGwyX2N0cmxfbW9kaWZ5X3Jhbmdl KG92MDJhMTAtPmV4cG9zdXJlLA0KKwkJCQkJIG92MDJhMTAtPmV4cG9zdXJlLT5taW5pbXVtLCBt YXhfZXhwbywNCisJCQkJCSBvdjAyYTEwLT5leHBvc3VyZS0+c3RlcCwNCisJCQkJCSBvdjAyYTEw LT5leHBvc3VyZS0+ZGVmYXVsdF92YWx1ZSk7DQorCX0NCisNCisJLyogVjRMMiBjb250cm9scyB2 YWx1ZXMgd2lsbCBiZSBhcHBsaWVkIG9ubHkgd2hlbiBwb3dlciBpcyBhbHJlYWR5IHVwICovDQor CWlmICghcG1fcnVudGltZV9nZXRfaWZfaW5fdXNlKCZjbGllbnQtPmRldikpDQorCQlyZXR1cm4g MDsNCisNCisJc3dpdGNoIChjdHJsLT5pZCkgew0KKwljYXNlIFY0TDJfQ0lEX0VYUE9TVVJFOg0K KwkJcmV0ID0gb3YwMmExMF9zZXRfZXhwb3N1cmUob3YwMmExMCwgY3RybC0+dmFsKTsNCisJCWJy ZWFrOw0KKwljYXNlIFY0TDJfQ0lEX0FOQUxPR1VFX0dBSU46DQorCQlyZXQgPSBvdjAyYTEwX3Nl dF9nYWluKG92MDJhMTAsIGN0cmwtPnZhbCk7DQorCQlicmVhazsNCisJY2FzZSBWNEwyX0NJRF9W QkxBTks6DQorCQlyZXQgPSBvdjAyYTEwX3NldF92Ymxhbmsob3YwMmExMCwgY3RybC0+dmFsKTsN CisJCWJyZWFrOw0KKwljYXNlIFY0TDJfQ0lEX1RFU1RfUEFUVEVSTjoNCisJCXJldCA9IG92MDJh MTBfc2V0X3Rlc3RfcGF0dGVybihvdjAyYTEwLCBjdHJsLT52YWwpOw0KKwkJYnJlYWs7DQorCWRl ZmF1bHQ6DQorCQlyZXQgPSAtRUlOVkFMOw0KKwkJYnJlYWs7DQorCX07DQorDQorCXBtX3J1bnRp bWVfcHV0KCZjbGllbnQtPmRldik7DQorDQorCXJldHVybiByZXQ7DQorfQ0KKw0KK3N0YXRpYyBj b25zdCBzdHJ1Y3QgdjRsMl9zdWJkZXZfdmlkZW9fb3BzIG92MDJhMTBfdmlkZW9fb3BzID0gew0K Kwkuc19zdHJlYW0gPSBvdjAyYTEwX3Nfc3RyZWFtLA0KK307DQorDQorc3RhdGljIGNvbnN0IHN0 cnVjdCB2NGwyX3N1YmRldl9wYWRfb3BzIG92MDJhMTBfcGFkX29wcyA9IHsNCisJLmluaXRfY2Zn ID0gb3YwMmExMF9lbnRpdHlfaW5pdF9jZmcsDQorCS5lbnVtX21idXNfY29kZSA9IG92MDJhMTBf ZW51bV9tYnVzX2NvZGUsDQorCS5lbnVtX2ZyYW1lX3NpemUgPSBvdjAyYTEwX2VudW1fZnJhbWVf c2l6ZXMsDQorCS5nZXRfZm10ID0gb3YwMmExMF9nZXRfZm10LA0KKwkuc2V0X2ZtdCA9IG92MDJh MTBfc2V0X2ZtdCwNCit9Ow0KKw0KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdjRsMl9zdWJkZXZfb3Bz IG92MDJhMTBfc3ViZGV2X29wcyA9IHsNCisJLnZpZGVvCT0gJm92MDJhMTBfdmlkZW9fb3BzLA0K KwkucGFkCT0gJm92MDJhMTBfcGFkX29wcywNCit9Ow0KKw0KK3N0YXRpYyBjb25zdCBzdHJ1Y3Qg bWVkaWFfZW50aXR5X29wZXJhdGlvbnMgb3YwMmExMF9zdWJkZXZfZW50aXR5X29wcyA9IHsNCisJ LmxpbmtfdmFsaWRhdGUgPSB2NGwyX3N1YmRldl9saW5rX3ZhbGlkYXRlLA0KK307DQorDQorc3Rh dGljIGNvbnN0IHN0cnVjdCB2NGwyX2N0cmxfb3BzIG92MDJhMTBfY3RybF9vcHMgPSB7DQorCS5z X2N0cmwgPSBvdjAyYTEwX3NldF9jdHJsLA0KK307DQorDQorc3RhdGljIGludCBvdjAyYTEwX2lu aXRpYWxpemVfY29udHJvbHMoc3RydWN0IG92MDJhMTAgKm92MDJhMTApDQorew0KKwlzdHJ1Y3Qg aTJjX2NsaWVudCAqY2xpZW50ID0gdjRsMl9nZXRfc3ViZGV2ZGF0YSgmb3YwMmExMC0+c3ViZGV2 KTsNCisJY29uc3Qgc3RydWN0IG92MDJhMTBfbW9kZSAqbW9kZTsNCisJc3RydWN0IHY0bDJfY3Ry bF9oYW5kbGVyICpoYW5kbGVyOw0KKwlzdHJ1Y3QgdjRsMl9jdHJsICpjdHJsOw0KKwlzNjQgZXhw b3N1cmVfbWF4Ow0KKwlzNjQgdmJsYW5rX2RlZjsNCisJczY0IHBpeGVsX3JhdGU7DQorCXM2NCBo X2JsYW5rOw0KKwlpbnQgcmV0Ow0KKw0KKwloYW5kbGVyID0gJm92MDJhMTAtPmN0cmxfaGFuZGxl cjsNCisJbW9kZSA9IG92MDJhMTAtPmN1cl9tb2RlOw0KKwlyZXQgPSB2NGwyX2N0cmxfaGFuZGxl cl9pbml0KGhhbmRsZXIsIDcpOw0KKwlpZiAocmV0KQ0KKwkJcmV0dXJuIHJldDsNCisNCisJaGFu ZGxlci0+bG9jayA9ICZvdjAyYTEwLT5tdXRleDsNCisNCisJY3RybCA9IHY0bDJfY3RybF9uZXdf aW50X21lbnUoaGFuZGxlciwgTlVMTCwgVjRMMl9DSURfTElOS19GUkVRLCAwLCAwLA0KKwkJCQkg ICAgICBsaW5rX2ZyZXFfbWVudV9pdGVtcyk7DQorCWlmIChjdHJsKQ0KKwkJY3RybC0+ZmxhZ3Mg fD0gVjRMMl9DVFJMX0ZMQUdfUkVBRF9PTkxZOw0KKw0KKwlwaXhlbF9yYXRlID0gdG9fcGl4ZWxf cmF0ZSgwKTsNCisJdjRsMl9jdHJsX25ld19zdGQoaGFuZGxlciwgTlVMTCwgVjRMMl9DSURfUElY RUxfUkFURSwgMCwgcGl4ZWxfcmF0ZSwgMSwNCisJCQkgIHBpeGVsX3JhdGUpOw0KKw0KKwloX2Js YW5rID0gbW9kZS0+aHRzX2RlZiAtIG1vZGUtPndpZHRoOw0KKwl2NGwyX2N0cmxfbmV3X3N0ZCho YW5kbGVyLCBOVUxMLCBWNEwyX0NJRF9IQkxBTkssIGhfYmxhbmssIGhfYmxhbmssIDEsDQorCQkJ ICBoX2JsYW5rKTsNCisNCisJdmJsYW5rX2RlZiA9IG1vZGUtPnZ0c19kZWYgLSBtb2RlLT5oZWln aHQ7DQorCXY0bDJfY3RybF9uZXdfc3RkKGhhbmRsZXIsICZvdjAyYTEwX2N0cmxfb3BzLCBWNEwy X0NJRF9WQkxBTkssDQorCQkJICB2YmxhbmtfZGVmLCBPVjAyQTEwX1ZUU19NQVggLSBtb2RlLT5o ZWlnaHQsIDEsDQorCQkJICB2YmxhbmtfZGVmKTsNCisNCisJZXhwb3N1cmVfbWF4ID0gbW9kZS0+ dnRzX2RlZiAtIDQ7DQorCW92MDJhMTAtPmV4cG9zdXJlID0gdjRsMl9jdHJsX25ld19zdGQoaGFu ZGxlciwgJm92MDJhMTBfY3RybF9vcHMsDQorCQkJCQkgICAgICBWNEwyX0NJRF9FWFBPU1VSRSwN CisJCQkJCSAgICAgIE9WMDJBMTBfRVhQT1NVUkVfTUlOLA0KKwkJCQkJICAgICAgZXhwb3N1cmVf bWF4LA0KKwkJCQkJICAgICAgT1YwMkExMF9FWFBPU1VSRV9TVEVQLA0KKwkJCQkJICAgICAgbW9k ZS0+ZXhwX2RlZik7DQorDQorCXY0bDJfY3RybF9uZXdfc3RkKGhhbmRsZXIsICZvdjAyYTEwX2N0 cmxfb3BzLA0KKwkJCSAgVjRMMl9DSURfQU5BTE9HVUVfR0FJTiwgT1YwMkExMF9HQUlOX01JTiwN CisJCQkgIE9WMDJBMTBfR0FJTl9NQVgsIE9WMDJBMTBfR0FJTl9TVEVQLA0KKwkJCSAgT1YwMkEx MF9HQUlOX0RFRkFVTFQpOw0KKw0KKwl2NGwyX2N0cmxfbmV3X3N0ZF9tZW51X2l0ZW1zKGhhbmRs ZXIsICZvdjAyYTEwX2N0cmxfb3BzLA0KKwkJCQkgICAgIFY0TDJfQ0lEX1RFU1RfUEFUVEVSTiwN CisJCQkJICAgICBBUlJBWV9TSVpFKG92MDJhMTBfdGVzdF9wYXR0ZXJuX21lbnUpIC0gMSwNCisJ CQkJICAgICAwLCAwLCBvdjAyYTEwX3Rlc3RfcGF0dGVybl9tZW51KTsNCisNCisJaWYgKGhhbmRs ZXItPmVycm9yKSB7DQorCQlyZXQgPSBoYW5kbGVyLT5lcnJvcjsNCisJCWRldl9lcnIoJmNsaWVu dC0+ZGV2LCAiZmFpbGVkIHRvIGluaXQgY29udHJvbHMoJWQpXG4iLCByZXQpOw0KKwkJZ290byBl cnJfZnJlZV9oYW5kbGVyOw0KKwl9DQorDQorCW92MDJhMTAtPnN1YmRldi5jdHJsX2hhbmRsZXIg PSBoYW5kbGVyOw0KKw0KKwlyZXR1cm4gMDsNCisNCitlcnJfZnJlZV9oYW5kbGVyOg0KKwl2NGwy X2N0cmxfaGFuZGxlcl9mcmVlKGhhbmRsZXIpOw0KKw0KKwlyZXR1cm4gcmV0Ow0KK30NCisNCitz dGF0aWMgaW50IG92MDJhMTBfY2hlY2tfaHdjZmcoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qg b3YwMmExMCAqb3YwMmExMCkNCit7DQorCXN0cnVjdCBmd25vZGVfaGFuZGxlICplcDsNCisJc3Ry dWN0IGZ3bm9kZV9oYW5kbGUgKmZ3bm9kZSA9IGRldl9md25vZGUoZGV2KTsNCisJc3RydWN0IHY0 bDJfZndub2RlX2VuZHBvaW50IGJ1c19jZmcgPSB7DQorCQkuYnVzX3R5cGUgPSBWNEwyX01CVVNf Q1NJMl9EUEhZLA0KKwl9Ow0KKwl1bnNpZ25lZCBpbnQgaSwgajsNCisJaW50IHJldDsNCisNCisJ aWYgKCFmd25vZGUpDQorCQlyZXR1cm4gLUVJTlZBTDsNCisNCisJZXAgPSBmd25vZGVfZ3JhcGhf Z2V0X25leHRfZW5kcG9pbnQoZndub2RlLCBOVUxMKTsNCisJaWYgKCFlcCkNCisJCXJldHVybiAt RU5YSU87DQorDQorCXJldCA9IHY0bDJfZndub2RlX2VuZHBvaW50X2FsbG9jX3BhcnNlKGVwLCAm YnVzX2NmZyk7DQorCWZ3bm9kZV9oYW5kbGVfcHV0KGVwKTsNCisJaWYgKHJldCkNCisJCXJldHVy biByZXQ7DQorDQorCWlmICghYnVzX2NmZy5ucl9vZl9saW5rX2ZyZXF1ZW5jaWVzKSB7DQorCQlk ZXZfZXJyKGRldiwgIm5vIGxpbmsgZnJlcXVlbmNpZXMgZGVmaW5lZFxuIik7DQorCQlyZXQgPSAt RUlOVkFMOw0KKwkJZ290byBjaGVja19od2NmZ19lcnJvcjsNCisJfQ0KKw0KKwlmb3IgKGkgPSAw OyBpIDwgQVJSQVlfU0laRShsaW5rX2ZyZXFfbWVudV9pdGVtcyk7IGkrKykgew0KKwkJZm9yIChq ID0gMDsgaiA8IGJ1c19jZmcubnJfb2ZfbGlua19mcmVxdWVuY2llczsgaisrKSB7DQorCQkJaWYg KGxpbmtfZnJlcV9tZW51X2l0ZW1zW2ldID09DQorCQkJCWJ1c19jZmcubGlua19mcmVxdWVuY2ll c1tqXSkgew0KKwkJCQlvdjAyYTEwLT5mcmVxX2luZGV4ID0gaTsNCisJCQkJYnJlYWs7DQorCQkJ fQ0KKwkJfQ0KKw0KKwkJaWYgKGogPT0gYnVzX2NmZy5ucl9vZl9saW5rX2ZyZXF1ZW5jaWVzKSB7 DQorCQkJZGV2X2VycihkZXYsICJubyBsaW5rIGZyZXF1ZW5jeSAlbGxkIHN1cHBvcnRlZFxuIiwN CisJCQkJbGlua19mcmVxX21lbnVfaXRlbXNbaV0pOw0KKwkJCXJldCA9IC1FSU5WQUw7DQorCQkJ Z290byBjaGVja19od2NmZ19lcnJvcjsNCisJCX0NCisJfQ0KKw0KK2NoZWNrX2h3Y2ZnX2Vycm9y Og0KKwl2NGwyX2Z3bm9kZV9lbmRwb2ludF9mcmVlKCZidXNfY2ZnKTsNCisNCisJcmV0dXJuIHJl dDsNCit9DQorDQorc3RhdGljIGludCBvdjAyYTEwX3Byb2JlKHN0cnVjdCBpMmNfY2xpZW50ICpj bGllbnQpDQorew0KKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmY2xpZW50LT5kZXY7DQorCXN0cnVj dCBvdjAyYTEwICpvdjAyYTEwOw0KKwl1bnNpZ25lZCBpbnQgcm90YXRpb247DQorCXVuc2lnbmVk IGludCBjbnQgPSAwOw0KKwl1bnNpZ25lZCBpbnQgaTsNCisJdW5zaWduZWQgaW50IG51bV9mcmVx X2Nsa192b2x0ID0gMiAqIEFSUkFZX1NJWkUobGlua19mcmVxX21lbnVfaXRlbXMpOw0KKwlpbnQg cmV0Ow0KKw0KKwlvdjAyYTEwID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpvdjAyYTEwKSwg R0ZQX0tFUk5FTCk7DQorCWlmICghb3YwMmExMCkNCisJCXJldHVybiAtRU5PTUVNOw0KKw0KKwly ZXQgPSBvdjAyYTEwX2NoZWNrX2h3Y2ZnKGRldiwgb3YwMmExMCk7DQorCWlmIChyZXQpIHsNCisJ CWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGNoZWNrIEhXIGNvbmZpZ3VyYXRpb246ICVkXG4iLCBy ZXQpOw0KKwkJcmV0dXJuIHJldDsNCisJfQ0KKw0KKwl2NGwyX2kyY19zdWJkZXZfaW5pdCgmb3Yw MmExMC0+c3ViZGV2LCBjbGllbnQsICZvdjAyYTEwX3N1YmRldl9vcHMpOw0KKwlvdjAyYTEwLT5t aXBpX2Nsb2NrX3ZvbHRhZ2UgPSBPVjAyQTEwX01JUElfVFhfU1BFRURfREVGQVVMVDsNCisJb3Yw MmExMC0+Zm10LmNvZGUgPSBNRURJQV9CVVNfRk1UX1NCR0dSMTBfMVgxMDsNCisNCisJLyogT3B0 aW9uYWwgaW5kaWNhdGlvbiBvZiBwaHlzaWNhbCByb3RhdGlvbiBvZiBzZW5zb3IgKi8NCisJcmV0 ID0gZndub2RlX3Byb3BlcnR5X3JlYWRfdTMyKGRldl9md25vZGUoZGV2KSwgInJvdGF0aW9uIiwg JnJvdGF0aW9uKTsNCisJaWYgKCFyZXQgJiYgcm90YXRpb24gPT0gMTgwKSB7DQorCQlvdjAyYTEw LT51cHNpZGVfZG93biA9IHRydWU7DQorCQlvdjAyYTEwLT5mbXQuY29kZSA9IE1FRElBX0JVU19G TVRfU1JHR0IxMF8xWDEwOw0KKwl9DQorDQorCS8qIE9wdGlvbmFsIGluZGljYXRpb24gb2YgTUlQ SSBjbG9jayB2b2x0YWdlIHVuaXQgKi8NCisJcmV0ID0gZndub2RlX3Byb3BlcnR5X3JlYWRfdTMy X2FycmF5KGRldl9md25vZGUoZGV2KSwNCisJCQkJCSAgICAgIm92dGksbWlwaS1jbG9jay12b2x0 YWdlIiwgTlVMTCwNCisJCQkJCSAgICAgMCk7DQorCWlmIChyZXQgPiAwICYmIHJldCAlIDIgPT0g MCkgew0KKwkJdTMyIGZyZXFfY2xrX3ZvbHRbcmV0XTsNCisNCisJCWZ3bm9kZV9wcm9wZXJ0eV9y ZWFkX3UzMl9hcnJheShkZXZfZndub2RlKGRldiksDQorCQkJCQkgICAgICAgIm92dGksbWlwaS1j bG9jay12b2x0YWdlIiwNCisJCQkJCSAgICAgICBmcmVxX2Nsa192b2x0LA0KKwkJCQkJICAgICAg IEFSUkFZX1NJWkUoZnJlcV9jbGtfdm9sdCkpOw0KKw0KKwkJd2hpbGUgKG51bV9mcmVxX2Nsa192 b2x0KSB7DQorCQkJdW5zaWduZWQgbG9uZyBmcmVxOw0KKwkJCXVuc2lnbmVkIGxvbmcgdm9sdDsN CisNCisJCQlpZiAoY250ID49IEFSUkFZX1NJWkUoZnJlcV9jbGtfdm9sdCkpIHsNCisJCQkJZGV2 X3dhcm4oZGV2LCAibWlzbWF0Y2hlZCBsaW5rIGZyZXF1ZW5jeVxuIik7DQorCQkJCWJyZWFrOw0K KwkJCX0NCisNCisJCQlmcmVxID0gZnJlcV9jbGtfdm9sdFtjbnQrK10gKiAxMDAwOw0KKwkJCXZv bHQgPSBmcmVxX2Nsa192b2x0W2NudCsrXTsNCisNCisJCQkvKiBHZXQgY2xvY2sgdm9sdGFnZSB1 bml0IHZhbHVlIGZyb20gRFQgKi8NCisJCQlpZiAoZnJlcSA9PSBsaW5rX2ZyZXFfbWVudV9pdGVt c1tvdjAyYTEwLT5mcmVxX2luZGV4XSkgew0KKwkJCQlvdjAyYTEwLT5taXBpX2Nsb2NrX3ZvbHRh Z2UgPSB2b2x0Ow0KKwkJCQlicmVhazsNCisJCQl9DQorDQorCQkJbnVtX2ZyZXFfY2xrX3ZvbHQg LT0gMjsNCisJCX0NCisJfQ0KKw0KKwkvKiBHZXQgZXh0ZXJuYWwgaW5wdXQgY2xvY2sgKGVjbGsp ICovDQorCW92MDJhMTAtPmVjbGsgPSBkZXZtX2Nsa19nZXQoZGV2LCAiZWNsayIpOw0KKwlpZiAo SVNfRVJSKG92MDJhMTAtPmVjbGspKSB7DQorCQlyZXQgPSBQVFJfRVJSKG92MDJhMTAtPmVjbGsp Ow0KKwkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gZ2V0IGVjbGsgJWRcbiIsIHJldCk7DQorCQly ZXR1cm4gcmV0Ow0KKwl9DQorDQorCXJldCA9IGZ3bm9kZV9wcm9wZXJ0eV9yZWFkX3UzMihkZXZf Zndub2RlKGRldiksICJjbG9jay1mcmVxdWVuY3kiLA0KKwkJCQkgICAgICAgJm92MDJhMTAtPmVj bGtfZnJlcSk7DQorCWlmIChyZXQpIHsNCisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGdldCBl Y2xrIGZyZXF1ZW5jeVxuIik7DQorCQlyZXR1cm4gcmV0Ow0KKwl9DQorDQorCXJldCA9IGNsa19z ZXRfcmF0ZShvdjAyYTEwLT5lY2xrLCBvdjAyYTEwLT5lY2xrX2ZyZXEpOw0KKwlpZiAocmV0KSB7 DQorCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBzZXQgZWNsayBmcmVxdWVuY3kgKDI0TUh6KVxu Iik7DQorCQlyZXR1cm4gcmV0Ow0KKwl9DQorDQorCWlmIChjbGtfZ2V0X3JhdGUob3YwMmExMC0+ ZWNsaykgIT0gT1YwMkExMF9FQ0xLX0ZSRVEpIHsNCisJCWRldl93YXJuKGRldiwgImVjbGsgbWlz bWF0Y2hlZCwgbW9kZSBpcyBiYXNlZCBvbiAyNE1IelxuIik7DQorCQlyZXR1cm4gLUVJTlZBTDsN CisJfQ0KKw0KKwlvdjAyYTEwLT5wZF9ncGlvID0gZGV2bV9ncGlvZF9nZXQoZGV2LCAicG93ZXJk b3duIiwgR1BJT0RfT1VUX0hJR0gpOw0KKwlpZiAoSVNfRVJSKG92MDJhMTAtPnBkX2dwaW8pKSB7 DQorCQlyZXQgPSBQVFJfRVJSKG92MDJhMTAtPnBkX2dwaW8pOw0KKwkJZGV2X2VycihkZXYsICJm YWlsZWQgdG8gZ2V0IHBvd2VyZG93bi1ncGlvcyAlZFxuIiwgcmV0KTsNCisJCXJldHVybiByZXQ7 DQorCX0NCisNCisJb3YwMmExMC0+cnN0X2dwaW8gPSBkZXZtX2dwaW9kX2dldChkZXYsICJyZXNl dCIsIEdQSU9EX09VVF9ISUdIKTsNCisJaWYgKElTX0VSUihvdjAyYTEwLT5yc3RfZ3BpbykpIHsN CisJCXJldCA9IFBUUl9FUlIob3YwMmExMC0+cnN0X2dwaW8pOw0KKwkJZGV2X2VycihkZXYsICJm YWlsZWQgdG8gZ2V0IHJlc2V0LWdwaW9zICVkXG4iLCByZXQpOw0KKwkJcmV0dXJuIHJldDsNCisJ fQ0KKw0KKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShvdjAyYTEwX3N1cHBseV9uYW1lcyk7 IGkrKykNCisJCW92MDJhMTAtPnN1cHBsaWVzW2ldLnN1cHBseSA9IG92MDJhMTBfc3VwcGx5X25h bWVzW2ldOw0KKw0KKwlyZXQgPSBkZXZtX3JlZ3VsYXRvcl9idWxrX2dldChkZXYsIEFSUkFZX1NJ WkUob3YwMmExMF9zdXBwbHlfbmFtZXMpLA0KKwkJCQkgICAgICBvdjAyYTEwLT5zdXBwbGllcyk7 DQorCWlmIChyZXQpIHsNCisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGdldCByZWd1bGF0b3Jz XG4iKTsNCisJCXJldHVybiByZXQ7DQorCX0NCisNCisJbXV0ZXhfaW5pdCgmb3YwMmExMC0+bXV0 ZXgpOw0KKwlvdjAyYTEwLT5jdXJfbW9kZSA9ICZzdXBwb3J0ZWRfbW9kZXNbMF07DQorDQorCXJl dCA9IG92MDJhMTBfaW5pdGlhbGl6ZV9jb250cm9scyhvdjAyYTEwKTsNCisJaWYgKHJldCkgew0K KwkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gaW5pdGlhbGl6ZSBjb250cm9sc1xuIik7DQorCQln b3RvIGVycl9kZXN0cm95X211dGV4Ow0KKwl9DQorDQorCW92MDJhMTAtPnN1YmRldi5mbGFncyB8 PSBWNEwyX1NVQkRFVl9GTF9IQVNfREVWTk9ERTsNCisJb3YwMmExMC0+c3ViZGV2LmVudGl0eS5v cHMgPSAmb3YwMmExMF9zdWJkZXZfZW50aXR5X29wczsNCisJb3YwMmExMC0+c3ViZGV2LmVudGl0 eS5mdW5jdGlvbiA9IE1FRElBX0VOVF9GX0NBTV9TRU5TT1I7DQorCW92MDJhMTAtPnBhZC5mbGFn cyA9IE1FRElBX1BBRF9GTF9TT1VSQ0U7DQorDQorCXJldCA9IG1lZGlhX2VudGl0eV9wYWRzX2lu aXQoJm92MDJhMTAtPnN1YmRldi5lbnRpdHksIDEsICZvdjAyYTEwLT5wYWQpOw0KKwlpZiAocmV0 IDwgMCkgew0KKwkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gaW5pdCBlbnRpdHkgcGFkczogJWQi LCByZXQpOw0KKwkJZ290byBlcnJfZnJlZV9oYW5kbGVyOw0KKwl9DQorDQorCXBtX3J1bnRpbWVf ZW5hYmxlKGRldik7DQorCWlmICghcG1fcnVudGltZV9lbmFibGVkKGRldikpIHsNCisJCXJldCA9 IG92MDJhMTBfcG93ZXJfb24oZGV2KTsNCisJCWlmIChyZXQgPCAwKSB7DQorCQkJZGV2X2Vycihk ZXYsICJmYWlsZWQgdG8gcG93ZXIgb246ICVkXG4iLCByZXQpOw0KKwkJCWdvdG8gZXJyX2NsZWFu X2VudGl0eTsNCisJCX0NCisJfQ0KKw0KKwlyZXQgPSB2NGwyX2FzeW5jX3JlZ2lzdGVyX3N1YmRl digmb3YwMmExMC0+c3ViZGV2KTsNCisJaWYgKHJldCkgew0KKwkJZGV2X2VycihkZXYsICJmYWls ZWQgdG8gcmVnaXN0ZXIgVjRMMiBzdWJkZXY6ICVkXG4iLCByZXQpOw0KKwkJZ290byBlcnJfcG93 ZXJfb2ZmOw0KKwl9DQorDQorCXJldHVybiAwOw0KKw0KK2Vycl9wb3dlcl9vZmY6DQorCWlmIChw bV9ydW50aW1lX2VuYWJsZWQoZGV2KSkNCisJCXBtX3J1bnRpbWVfZGlzYWJsZShkZXYpOw0KKwll bHNlDQorCQlvdjAyYTEwX3Bvd2VyX29mZihkZXYpOw0KK2Vycl9jbGVhbl9lbnRpdHk6DQorCW1l ZGlhX2VudGl0eV9jbGVhbnVwKCZvdjAyYTEwLT5zdWJkZXYuZW50aXR5KTsNCitlcnJfZnJlZV9o YW5kbGVyOg0KKwl2NGwyX2N0cmxfaGFuZGxlcl9mcmVlKG92MDJhMTAtPnN1YmRldi5jdHJsX2hh bmRsZXIpOw0KK2Vycl9kZXN0cm95X211dGV4Og0KKwltdXRleF9kZXN0cm95KCZvdjAyYTEwLT5t dXRleCk7DQorDQorCXJldHVybiByZXQ7DQorfQ0KKw0KK3N0YXRpYyBpbnQgb3YwMmExMF9yZW1v dmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCkNCit7DQorCXN0cnVjdCB2NGwyX3N1YmRldiAq c2QgPSBpMmNfZ2V0X2NsaWVudGRhdGEoY2xpZW50KTsNCisJc3RydWN0IG92MDJhMTAgKm92MDJh MTAgPSB0b19vdjAyYTEwKHNkKTsNCisNCisJdjRsMl9hc3luY191bnJlZ2lzdGVyX3N1YmRldihz ZCk7DQorCW1lZGlhX2VudGl0eV9jbGVhbnVwKCZzZC0+ZW50aXR5KTsNCisJdjRsMl9jdHJsX2hh bmRsZXJfZnJlZShzZC0+Y3RybF9oYW5kbGVyKTsNCisJcG1fcnVudGltZV9kaXNhYmxlKCZjbGll bnQtPmRldik7DQorCWlmICghcG1fcnVudGltZV9zdGF0dXNfc3VzcGVuZGVkKCZjbGllbnQtPmRl dikpDQorCQlvdjAyYTEwX3Bvd2VyX29mZigmY2xpZW50LT5kZXYpOw0KKwlwbV9ydW50aW1lX3Nl dF9zdXNwZW5kZWQoJmNsaWVudC0+ZGV2KTsNCisJbXV0ZXhfZGVzdHJveSgmb3YwMmExMC0+bXV0 ZXgpOw0KKw0KKwlyZXR1cm4gMDsNCit9DQorDQorc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZp Y2VfaWQgb3YwMmExMF9vZl9tYXRjaFtdID0gew0KKwl7IC5jb21wYXRpYmxlID0gIm92dGksb3Yw MmExMCIgfSwNCisJe30NCit9Ow0KK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIG92MDJhMTBfb2Zf bWF0Y2gpOw0KKw0KK3N0YXRpYyBzdHJ1Y3QgaTJjX2RyaXZlciBvdjAyYTEwX2kyY19kcml2ZXIg PSB7DQorCS5kcml2ZXIgPSB7DQorCQkubmFtZSA9ICJvdjAyYTEwIiwNCisJCS5wbSA9ICZvdjAy YTEwX3BtX29wcywNCisJCS5vZl9tYXRjaF90YWJsZSA9IG92MDJhMTBfb2ZfbWF0Y2gsDQorCX0s DQorCS5wcm9iZV9uZXcJPSAmb3YwMmExMF9wcm9iZSwNCisJLnJlbW92ZQkJPSAmb3YwMmExMF9y ZW1vdmUsDQorfTsNCisNCittb2R1bGVfaTJjX2RyaXZlcihvdjAyYTEwX2kyY19kcml2ZXIpOw0K Kw0KK01PRFVMRV9BVVRIT1IoIkRvbmdjaHVuIFpodSA8ZG9uZ2NodW4uemh1QG1lZGlhdGVrLmNv bT4iKTsNCitNT0RVTEVfREVTQ1JJUFRJT04oIk9tbmlWaXNpb24gT1YwMkExMCBzZW5zb3IgZHJp dmVyIik7DQorTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOw0KLS0gDQoyLjkuMg0K 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=-18.0 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING,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 D7082C43461 for ; Wed, 2 Sep 2020 12:04:16 +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 96F8B2078B for ; Wed, 2 Sep 2020 12:04:16 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="ELeVvQ8a"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="JZRin0Mg" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 96F8B2078B 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=UoV1VOuFgVVBkfL516XnfN8VKd1meVDe51X7knBSiHM=; b=ELeVvQ8aRbhxNukDtQvOgMCf5 TNAzcOqmda5djBpQ9Cz4HrGgXYVVkwWJEEXXdGs8PMGZ1QAidMlHJYHBGaBGpZcaW0wZDhCJu400E 2fPqIpxbanmf5rDyGsuqcuqZFGQibyOUjLkIW7k0deRr3E7YYe55jwDhB/q7dCbAUBadBYMOPutlG omEEAChK1RZ7l3yR6WibUQ5ZHY1cpPZ0hYG13HXSz7zLsb7F/zMiCZmgaEH5DAbvz20t8WdOOudQO tlONqoIoDqcZNlJWMJ8zBtihQe4SxIF5Pb1dbYQNFSta7cXkeYgjqiXG587Y+2zxVfD7doFrRTwtg UOWjMxLrg==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1kDRUl-0007t9-KV; Wed, 02 Sep 2020 12:04:07 +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 1kDRUd-0007q7-Om; Wed, 02 Sep 2020 12:04:03 +0000 X-UUID: c328dd0e30464d9c8bfece5c7a41af4e-20200902 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=WuLF7XUDCvhjAwYLLqbgLri0W+RaEcgUk7UYnX2QiR8=; b=JZRin0MgPDYNFyCZBl4V2/T+JpwN00e+BAYZ8zjENsPhd0gput85WIg4Igg4LfMVpZgDFkK9XEKlPFODZ52ZJZO5y2naDyOhVenZkXwvnY9mH9dwk0opsOAAm4e18OO2mBsoMMqBpZDXXu498PjXgdV2CCxcGVqdJ+jHIca90ms=; X-UUID: c328dd0e30464d9c8bfece5c7a41af4e-20200902 Received: from mtkcas66.mediatek.inc [(172.29.193.44)] by mailgw01.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLSv1.2 ECDHE-RSA-AES256-SHA384 256/256) with ESMTP id 44328685; Wed, 02 Sep 2020 04:03:45 -0800 Received: from mtkmbs07n1.mediatek.inc (172.21.101.16) by MTKMBS62N2.mediatek.inc (172.29.193.42) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 2 Sep 2020 05:03:43 -0700 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs07n1.mediatek.inc (172.21.101.16) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 2 Sep 2020 20:03:40 +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; Wed, 2 Sep 2020 20:03:39 +0800 From: Dongchun Zhu To: , , , , , , , , Subject: [PATCH v14 2/2] media: i2c: Add OV02A10 image sensor driver Date: Wed, 2 Sep 2020 20:01:22 +0800 Message-ID: <20200902120122.24456-3-dongchun.zhu@mediatek.com> X-Mailer: git-send-email 2.9.2 In-Reply-To: <20200902120122.24456-1-dongchun.zhu@mediatek.com> References: <20200902120122.24456-1-dongchun.zhu@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-20200902_080400_056325_1095E720 X-CRM114-Status: GOOD ( 22.60 ) 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: devicetree@vger.kernel.org, srv_heupstream@mediatek.com, shengnan.wang@mediatek.com, sj.huang@mediatek.com, linux-mediatek@lists.infradead.org, dongchun.zhu@mediatek.com, louis.kuo@mediatek.com, linux-arm-kernel@lists.infradead.org, linux-media@vger.kernel.org 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 a V4L2 sub-device driver for OmniVision OV02A10 image sensor. Signed-off-by: Dongchun Zhu --- MAINTAINERS | 1 + drivers/media/i2c/Kconfig | 13 + drivers/media/i2c/Makefile | 1 + drivers/media/i2c/ov02a10.c | 1083 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 1098 insertions(+) create mode 100644 drivers/media/i2c/ov02a10.c diff --git a/MAINTAINERS b/MAINTAINERS index 48aa7a7..ce7d8fa 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -12724,6 +12724,7 @@ L: linux-media@vger.kernel.org S: Maintained T: git git://linuxtv.org/media_tree.git F: Documentation/devicetree/bindings/media/i2c/ovti,ov02a10.yaml +F: drivers/media/i2c/ov02a10.c OMNIVISION OV13858 SENSOR DRIVER M: Sakari Ailus diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig index 48ae60a..f458804 100644 --- a/drivers/media/i2c/Kconfig +++ b/drivers/media/i2c/Kconfig @@ -825,6 +825,19 @@ config VIDEO_IMX355 To compile this driver as a module, choose M here: the module will be called imx355. +config VIDEO_OV02A10 + tristate "OmniVision OV02A10 sensor support" + depends on I2C && VIDEO_V4L2 + select MEDIA_CONTROLLER + select VIDEO_V4L2_SUBDEV_API + select V4L2_FWNODE + help + This is a Video4Linux2 sensor driver for the OmniVision + OV02A10 camera sensor. + + To compile this driver as a module, choose M here: the + module will be called ov02a10. + config VIDEO_OV2640 tristate "OmniVision OV2640 sensor support" depends on VIDEO_V4L2 && I2C diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile index f0a7747..dc27e14 100644 --- a/drivers/media/i2c/Makefile +++ b/drivers/media/i2c/Makefile @@ -64,6 +64,7 @@ obj-$(CONFIG_VIDEO_VP27SMPX) += vp27smpx.o obj-$(CONFIG_VIDEO_SONY_BTF_MPX) += sony-btf-mpx.o obj-$(CONFIG_VIDEO_UPD64031A) += upd64031a.o obj-$(CONFIG_VIDEO_UPD64083) += upd64083.o +obj-$(CONFIG_VIDEO_OV02A10) += ov02a10.o obj-$(CONFIG_VIDEO_OV2640) += ov2640.o obj-$(CONFIG_VIDEO_OV2680) += ov2680.o obj-$(CONFIG_VIDEO_OV2685) += ov2685.o diff --git a/drivers/media/i2c/ov02a10.c b/drivers/media/i2c/ov02a10.c new file mode 100644 index 0000000..1f8c525 --- /dev/null +++ b/drivers/media/i2c/ov02a10.c @@ -0,0 +1,1083 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 MediaTek Inc. + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define CHIP_ID 0x2509 +#define OV02A10_REG_CHIP_ID_H 0x02 +#define OV02A10_REG_CHIP_ID_L 0x03 + +/* Bit[1] vertical upside down */ +/* Bit[0] horizontal mirror */ +#define REG_MIRROR_FLIP_CONTROL 0x3f + +/* Orientation */ +#define REG_MIRROR_FLIP_ENABLE 0x03 + +/* Bit[2:0] MIPI transmission speed select */ +#define TX_SPEED_AREA_SEL 0xa1 +#define OV02A10_MIPI_TX_SPEED_DEFAULT 0x04 + +#define REG_PAGE_SWITCH 0xfd +#define REG_GLOBAL_EFFECTIVE 0x01 +#define REG_ENABLE BIT(0) + +#define REG_SC_CTRL_MODE 0xac +#define SC_CTRL_MODE_STANDBY 0x00 +#define SC_CTRL_MODE_STREAMING 0x01 + +#define OV02A10_EXP_SHIFT 8 +#define OV02A10_REG_EXPOSURE_H 0x03 +#define OV02A10_REG_EXPOSURE_L 0x04 +#define OV02A10_EXPOSURE_MIN 4 +#define OV02A10_EXPOSURE_MAX_MARGIN 4 +#define OV02A10_EXPOSURE_STEP 1 + +#define OV02A10_VTS_SHIFT 8 +#define OV02A10_REG_VTS_H 0x05 +#define OV02A10_REG_VTS_L 0x06 +#define OV02A10_VTS_MAX 0x209f +#define OV02A10_BASIC_LINE 1224 + +#define OV02A10_REG_GAIN 0x24 +#define OV02A10_GAIN_MIN 0x10 +#define OV02A10_GAIN_MAX 0xf8 +#define OV02A10_GAIN_STEP 0x01 +#define OV02A10_GAIN_DEFAULT 0x40 + +/* Test pattern control */ +#define OV02A10_REG_TEST_PATTERN 0xb6 + +#define HZ_PER_MHZ 1000000L +#define OV02A10_LINK_FREQ_390MHZ (390 * HZ_PER_MHZ) +#define OV02A10_ECLK_FREQ (24 * HZ_PER_MHZ) +#define OV02A10_DATA_LANES 1 +#define OV02A10_BITS_PER_SAMPLE 10 + +static const char * const ov02a10_supply_names[] = { + "dovdd", /* Digital I/O power */ + "avdd", /* Analog power */ + "dvdd", /* Digital core power */ +}; + +struct ov02a10_reg { + u8 addr; + u8 val; +}; + +struct ov02a10_reg_list { + u32 num_of_regs; + const struct ov02a10_reg *regs; +}; + +struct ov02a10_mode { + u32 width; + u32 height; + u32 exp_def; + u32 hts_def; + u32 vts_def; + const struct ov02a10_reg_list reg_list; +}; + +struct ov02a10 { + u32 eclk_freq; + /* Indication of MIPI transmission speed select */ + u32 mipi_clock_voltage; + /* Index of link frequency config to be used */ + u32 freq_index; + + struct clk *eclk; + struct gpio_desc *pd_gpio; + struct gpio_desc *rst_gpio; + struct regulator_bulk_data supplies[ARRAY_SIZE(ov02a10_supply_names)]; + + bool streaming; + bool upside_down; + + /* + * Serialize control access, get/set format, get selection + * and start streaming. + */ + struct mutex mutex; + struct v4l2_subdev subdev; + struct media_pad pad; + struct v4l2_mbus_framefmt fmt; + struct v4l2_ctrl_handler ctrl_handler; + struct v4l2_ctrl *exposure; + + const struct ov02a10_mode *cur_mode; +}; + +static inline struct ov02a10 *to_ov02a10(struct v4l2_subdev *sd) +{ + return container_of(sd, struct ov02a10, subdev); +} + +/* + * eclk 24Mhz + * pclk 39Mhz + * linelength 934(0x3a6) + * framelength 1390(0x56E) + * grabwindow_width 1600 + * grabwindow_height 1200 + * max_framerate 30fps + * mipi_datarate per lane 780Mbps + */ +static const struct ov02a10_reg ov02a10_1600x1200_regs[] = { + {0xfd, 0x01}, + {0xac, 0x00}, + {0xfd, 0x00}, + {0x2f, 0x29}, + {0x34, 0x00}, + {0x35, 0x21}, + {0x30, 0x15}, + {0x33, 0x01}, + {0xfd, 0x01}, + {0x44, 0x00}, + {0x2a, 0x4c}, + {0x2b, 0x1e}, + {0x2c, 0x60}, + {0x25, 0x11}, + {0x03, 0x01}, + {0x04, 0xae}, + {0x09, 0x00}, + {0x0a, 0x02}, + {0x06, 0xa6}, + {0x31, 0x00}, + {0x24, 0x40}, + {0x01, 0x01}, + {0xfb, 0x73}, + {0xfd, 0x01}, + {0x16, 0x04}, + {0x1c, 0x09}, + {0x21, 0x42}, + {0x12, 0x04}, + {0x13, 0x10}, + {0x11, 0x40}, + {0x33, 0x81}, + {0xd0, 0x00}, + {0xd1, 0x01}, + {0xd2, 0x00}, + {0x50, 0x10}, + {0x51, 0x23}, + {0x52, 0x20}, + {0x53, 0x10}, + {0x54, 0x02}, + {0x55, 0x20}, + {0x56, 0x02}, + {0x58, 0x48}, + {0x5d, 0x15}, + {0x5e, 0x05}, + {0x66, 0x66}, + {0x68, 0x68}, + {0x6b, 0x00}, + {0x6c, 0x00}, + {0x6f, 0x40}, + {0x70, 0x40}, + {0x71, 0x0a}, + {0x72, 0xf0}, + {0x73, 0x10}, + {0x75, 0x80}, + {0x76, 0x10}, + {0x84, 0x00}, + {0x85, 0x10}, + {0x86, 0x10}, + {0x87, 0x00}, + {0x8a, 0x22}, + {0x8b, 0x22}, + {0x19, 0xf1}, + {0x29, 0x01}, + {0xfd, 0x01}, + {0x9d, 0x16}, + {0xa0, 0x29}, + {0xa1, 0x04}, + {0xad, 0x62}, + {0xae, 0x00}, + {0xaf, 0x85}, + {0xb1, 0x01}, + {0x8e, 0x06}, + {0x8f, 0x40}, + {0x90, 0x04}, + {0x91, 0xb0}, + {0x45, 0x01}, + {0x46, 0x00}, + {0x47, 0x6c}, + {0x48, 0x03}, + {0x49, 0x8b}, + {0x4a, 0x00}, + {0x4b, 0x07}, + {0x4c, 0x04}, + {0x4d, 0xb7}, + {0xf0, 0x40}, + {0xf1, 0x40}, + {0xf2, 0x40}, + {0xf3, 0x40}, + {0x3f, 0x00}, + {0xfd, 0x01}, + {0x05, 0x00}, + {0x06, 0xa6}, + {0xfd, 0x01}, +}; + +static const char * const ov02a10_test_pattern_menu[] = { + "Disabled", + "Eight Vertical Colour Bars", +}; + +static const s64 link_freq_menu_items[] = { + OV02A10_LINK_FREQ_390MHZ, +}; + +static u64 to_pixel_rate(u32 f_index) +{ + u64 pixel_rate = link_freq_menu_items[f_index] * 2 * OV02A10_DATA_LANES; + + do_div(pixel_rate, OV02A10_BITS_PER_SAMPLE); + + return pixel_rate; +} + +static const struct ov02a10_mode supported_modes[] = { + { + .width = 1600, + .height = 1200, + .exp_def = 0x01ae, + .hts_def = 0x03a6, + .vts_def = 0x056e, + .reg_list = { + .num_of_regs = ARRAY_SIZE(ov02a10_1600x1200_regs), + .regs = ov02a10_1600x1200_regs, + }, + }, +}; + +static int ov02a10_write_array(struct ov02a10 *ov02a10, + const struct ov02a10_reg_list *r_list) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + unsigned int i; + int ret; + + for (i = 0; i < r_list->num_of_regs; i++) { + ret = i2c_smbus_write_byte_data(client, r_list->regs[i].addr, + r_list->regs[i].val); + if (ret < 0) + return ret; + } + + return 0; +} + +static int ov02a10_read_smbus(struct ov02a10 *ov02a10, unsigned char reg, + unsigned char *val) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + int ret; + + ret = i2c_smbus_read_byte_data(client, reg); + if (ret < 0) + return ret; + + *val = (unsigned char)ret; + + return 0; +} + +static void ov02a10_fill_fmt(const struct ov02a10_mode *mode, + struct v4l2_mbus_framefmt *fmt) +{ + fmt->width = mode->width; + fmt->height = mode->height; + fmt->field = V4L2_FIELD_NONE; +} + +static int ov02a10_set_fmt(struct v4l2_subdev *sd, + struct v4l2_subdev_pad_config *cfg, + struct v4l2_subdev_format *fmt) +{ + struct ov02a10 *ov02a10 = to_ov02a10(sd); + struct v4l2_mbus_framefmt *mbus_fmt = &fmt->format; + struct v4l2_mbus_framefmt *frame_fmt; + int ret = 0; + + mutex_lock(&ov02a10->mutex); + + if (ov02a10->streaming && fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) { + ret = -EBUSY; + goto error; + } + + /* Only one sensor mode supported */ + mbus_fmt->code = ov02a10->fmt.code; + ov02a10_fill_fmt(ov02a10->cur_mode, mbus_fmt); + + if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) + frame_fmt = v4l2_subdev_get_try_format(sd, cfg, 0); + else + frame_fmt = &ov02a10->fmt; + + *frame_fmt = *mbus_fmt; + +error: + mutex_unlock(&ov02a10->mutex); + return ret; +} + +static int ov02a10_get_fmt(struct v4l2_subdev *sd, + struct v4l2_subdev_pad_config *cfg, + struct v4l2_subdev_format *fmt) +{ + struct ov02a10 *ov02a10 = to_ov02a10(sd); + struct v4l2_mbus_framefmt *mbus_fmt = &fmt->format; + + mutex_lock(&ov02a10->mutex); + + if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { + fmt->format = *v4l2_subdev_get_try_format(sd, cfg, fmt->pad); + } else { + fmt->format = ov02a10->fmt; + mbus_fmt->code = ov02a10->fmt.code; + ov02a10_fill_fmt(ov02a10->cur_mode, mbus_fmt); + } + + mutex_unlock(&ov02a10->mutex); + + return 0; +} + +static int ov02a10_enum_mbus_code(struct v4l2_subdev *sd, + struct v4l2_subdev_pad_config *cfg, + struct v4l2_subdev_mbus_code_enum *code) +{ + struct ov02a10 *ov02a10 = to_ov02a10(sd); + + if (code->index != 0) + return -EINVAL; + + code->code = ov02a10->fmt.code; + + return 0; +} + +static int ov02a10_enum_frame_sizes(struct v4l2_subdev *sd, + struct v4l2_subdev_pad_config *cfg, + struct v4l2_subdev_frame_size_enum *fse) +{ + if (fse->index >= ARRAY_SIZE(supported_modes)) + return -EINVAL; + + fse->min_width = supported_modes[fse->index].width; + fse->max_width = supported_modes[fse->index].width; + fse->max_height = supported_modes[fse->index].height; + fse->min_height = supported_modes[fse->index].height; + + return 0; +} + +static int ov02a10_check_sensor_id(struct ov02a10 *ov02a10) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + u16 id; + u8 chip_id_h; + u8 chip_id_l; + int ret; + + /* Check sensor revision */ + ret = ov02a10_read_smbus(ov02a10, OV02A10_REG_CHIP_ID_H, &chip_id_h); + if (ret) + return ret; + + ret = ov02a10_read_smbus(ov02a10, OV02A10_REG_CHIP_ID_L, &chip_id_l); + if (ret) + return ret; + + id = (chip_id_h << 8) | chip_id_l; + if (id != CHIP_ID) { + dev_err(&client->dev, "Unexpected sensor id(%04x)\n", id); + return -EINVAL; + } + + return 0; +} + +static int ov02a10_power_on(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct ov02a10 *ov02a10 = to_ov02a10(sd); + int ret; + + gpiod_set_value_cansleep(ov02a10->rst_gpio, 1); + gpiod_set_value_cansleep(ov02a10->pd_gpio, 1); + + ret = clk_prepare_enable(ov02a10->eclk); + if (ret < 0) { + dev_err(dev, "failed to enable eclk\n"); + return ret; + } + + ret = regulator_bulk_enable(ARRAY_SIZE(ov02a10_supply_names), + ov02a10->supplies); + if (ret < 0) { + dev_err(dev, "failed to enable regulators\n"); + goto disable_clk; + } + usleep_range(5000, 6000); + + gpiod_set_value_cansleep(ov02a10->pd_gpio, 0); + usleep_range(5000, 6000); + + gpiod_set_value_cansleep(ov02a10->rst_gpio, 0); + usleep_range(5000, 6000); + + ret = ov02a10_check_sensor_id(ov02a10); + if (ret) + goto disable_regulator; + + return 0; + +disable_regulator: + regulator_bulk_disable(ARRAY_SIZE(ov02a10_supply_names), + ov02a10->supplies); +disable_clk: + clk_disable_unprepare(ov02a10->eclk); + + return ret; +} + +static int ov02a10_power_off(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct ov02a10 *ov02a10 = to_ov02a10(sd); + + gpiod_set_value_cansleep(ov02a10->rst_gpio, 1); + clk_disable_unprepare(ov02a10->eclk); + gpiod_set_value_cansleep(ov02a10->pd_gpio, 1); + regulator_bulk_disable(ARRAY_SIZE(ov02a10_supply_names), + ov02a10->supplies); + + return 0; +} + +static int __ov02a10_start_stream(struct ov02a10 *ov02a10) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + const struct ov02a10_reg_list *reg_list; + int ret; + + /* Apply default values of current mode */ + reg_list = &ov02a10->cur_mode->reg_list; + ret = ov02a10_write_array(ov02a10, reg_list); + if (ret) + return ret; + + /* Apply customized values from user */ + ret = __v4l2_ctrl_handler_setup(ov02a10->subdev.ctrl_handler); + if (ret) + return ret; + + /* Set orientation to 180 degree */ + if (ov02a10->upside_down) { + ret = i2c_smbus_write_byte_data(client, REG_MIRROR_FLIP_CONTROL, + REG_MIRROR_FLIP_ENABLE); + if (ret) { + dev_err(&client->dev, "failed to set orientation\n"); + return ret; + } + ret = i2c_smbus_write_byte_data(client, REG_GLOBAL_EFFECTIVE, + REG_ENABLE); + if (ret < 0) + return ret; + } + + /* Set MIPI TX speed according to DT property */ + if (ov02a10->mipi_clock_voltage != OV02A10_MIPI_TX_SPEED_DEFAULT) { + ret = i2c_smbus_write_byte_data(client, TX_SPEED_AREA_SEL, + ov02a10->mipi_clock_voltage); + if (ret < 0) + return ret; + } + + /* Set stream on register */ + return i2c_smbus_write_byte_data(client, REG_SC_CTRL_MODE, + SC_CTRL_MODE_STREAMING); +} + +static int __ov02a10_stop_stream(struct ov02a10 *ov02a10) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + + return i2c_smbus_write_byte_data(client, REG_SC_CTRL_MODE, + SC_CTRL_MODE_STANDBY); +} + +static int ov02a10_entity_init_cfg(struct v4l2_subdev *sd, + struct v4l2_subdev_pad_config *cfg) +{ + struct v4l2_subdev_format fmt = { + .which = V4L2_SUBDEV_FORMAT_TRY, + .format = { + .width = 1600, + .height = 1200, + } + }; + + ov02a10_set_fmt(sd, cfg, &fmt); + + return 0; +} + +static int ov02a10_s_stream(struct v4l2_subdev *sd, int on) +{ + struct ov02a10 *ov02a10 = to_ov02a10(sd); + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + int ret; + + mutex_lock(&ov02a10->mutex); + + if (ov02a10->streaming == on) + goto unlock_and_return; + + if (on) { + ret = pm_runtime_get_sync(&client->dev); + if (ret < 0) { + pm_runtime_put_noidle(&client->dev); + goto unlock_and_return; + } + + ret = __ov02a10_start_stream(ov02a10); + if (ret) { + __ov02a10_stop_stream(ov02a10); + ov02a10->streaming = !on; + goto err_rpm_put; + } + } else { + __ov02a10_stop_stream(ov02a10); + pm_runtime_put(&client->dev); + } + + ov02a10->streaming = on; + mutex_unlock(&ov02a10->mutex); + + return 0; + +err_rpm_put: + pm_runtime_put(&client->dev); +unlock_and_return: + mutex_unlock(&ov02a10->mutex); + + return ret; +} + +static const struct dev_pm_ops ov02a10_pm_ops = { + SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, + pm_runtime_force_resume) + SET_RUNTIME_PM_OPS(ov02a10_power_off, ov02a10_power_on, NULL) +}; + +/* + * ov02a10_set_exposure - Function called when setting exposure time + * @priv: Pointer to device structure + * @val: Variable for exposure time, in the unit of micro-second + * + * Set exposure time based on input value. + * + * Return: 0 on success + */ +static int ov02a10_set_exposure(struct ov02a10 *ov02a10, int val) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + int ret; + + ret = i2c_smbus_write_byte_data(client, REG_PAGE_SWITCH, REG_ENABLE); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, OV02A10_REG_EXPOSURE_H, + val >> OV02A10_EXP_SHIFT); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, OV02A10_REG_EXPOSURE_L, val); + if (ret < 0) + return ret; + + return i2c_smbus_write_byte_data(client, REG_GLOBAL_EFFECTIVE, + REG_ENABLE); +} + +static int ov02a10_set_gain(struct ov02a10 *ov02a10, int val) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + int ret; + + ret = i2c_smbus_write_byte_data(client, REG_PAGE_SWITCH, REG_ENABLE); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, OV02A10_REG_GAIN, val); + if (ret < 0) + return ret; + + return i2c_smbus_write_byte_data(client, REG_GLOBAL_EFFECTIVE, + REG_ENABLE); +} + +static int ov02a10_set_vblank(struct ov02a10 *ov02a10, int val) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + u32 vts = val + ov02a10->cur_mode->height - OV02A10_BASIC_LINE; + int ret; + + ret = i2c_smbus_write_byte_data(client, REG_PAGE_SWITCH, REG_ENABLE); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, OV02A10_REG_VTS_H, + vts >> OV02A10_VTS_SHIFT); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, OV02A10_REG_VTS_L, vts); + if (ret < 0) + return ret; + + return i2c_smbus_write_byte_data(client, REG_GLOBAL_EFFECTIVE, + REG_ENABLE); +} + +static int ov02a10_set_test_pattern(struct ov02a10 *ov02a10, int pattern) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + int ret; + + ret = i2c_smbus_write_byte_data(client, REG_PAGE_SWITCH, REG_ENABLE); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, OV02A10_REG_TEST_PATTERN, + pattern); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, REG_GLOBAL_EFFECTIVE, + REG_ENABLE); + if (ret < 0) + return ret; + + return i2c_smbus_write_byte_data(client, REG_SC_CTRL_MODE, + SC_CTRL_MODE_STREAMING); +} + +static int ov02a10_set_ctrl(struct v4l2_ctrl *ctrl) +{ + struct ov02a10 *ov02a10 = container_of(ctrl->handler, + struct ov02a10, ctrl_handler); + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + s64 max_expo; + int ret; + + /* Propagate change of current control to all related controls */ + if (ctrl->id == V4L2_CID_VBLANK) { + /* Update max exposure while meeting expected vblanking */ + max_expo = ov02a10->cur_mode->height + ctrl->val - + OV02A10_EXPOSURE_MAX_MARGIN; + __v4l2_ctrl_modify_range(ov02a10->exposure, + ov02a10->exposure->minimum, max_expo, + ov02a10->exposure->step, + ov02a10->exposure->default_value); + } + + /* V4L2 controls values will be applied only when power is already up */ + if (!pm_runtime_get_if_in_use(&client->dev)) + return 0; + + switch (ctrl->id) { + case V4L2_CID_EXPOSURE: + ret = ov02a10_set_exposure(ov02a10, ctrl->val); + break; + case V4L2_CID_ANALOGUE_GAIN: + ret = ov02a10_set_gain(ov02a10, ctrl->val); + break; + case V4L2_CID_VBLANK: + ret = ov02a10_set_vblank(ov02a10, ctrl->val); + break; + case V4L2_CID_TEST_PATTERN: + ret = ov02a10_set_test_pattern(ov02a10, ctrl->val); + break; + default: + ret = -EINVAL; + break; + }; + + pm_runtime_put(&client->dev); + + return ret; +} + +static const struct v4l2_subdev_video_ops ov02a10_video_ops = { + .s_stream = ov02a10_s_stream, +}; + +static const struct v4l2_subdev_pad_ops ov02a10_pad_ops = { + .init_cfg = ov02a10_entity_init_cfg, + .enum_mbus_code = ov02a10_enum_mbus_code, + .enum_frame_size = ov02a10_enum_frame_sizes, + .get_fmt = ov02a10_get_fmt, + .set_fmt = ov02a10_set_fmt, +}; + +static const struct v4l2_subdev_ops ov02a10_subdev_ops = { + .video = &ov02a10_video_ops, + .pad = &ov02a10_pad_ops, +}; + +static const struct media_entity_operations ov02a10_subdev_entity_ops = { + .link_validate = v4l2_subdev_link_validate, +}; + +static const struct v4l2_ctrl_ops ov02a10_ctrl_ops = { + .s_ctrl = ov02a10_set_ctrl, +}; + +static int ov02a10_initialize_controls(struct ov02a10 *ov02a10) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + const struct ov02a10_mode *mode; + struct v4l2_ctrl_handler *handler; + struct v4l2_ctrl *ctrl; + s64 exposure_max; + s64 vblank_def; + s64 pixel_rate; + s64 h_blank; + int ret; + + handler = &ov02a10->ctrl_handler; + mode = ov02a10->cur_mode; + ret = v4l2_ctrl_handler_init(handler, 7); + if (ret) + return ret; + + handler->lock = &ov02a10->mutex; + + ctrl = v4l2_ctrl_new_int_menu(handler, NULL, V4L2_CID_LINK_FREQ, 0, 0, + link_freq_menu_items); + if (ctrl) + ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; + + pixel_rate = to_pixel_rate(0); + v4l2_ctrl_new_std(handler, NULL, V4L2_CID_PIXEL_RATE, 0, pixel_rate, 1, + pixel_rate); + + h_blank = mode->hts_def - mode->width; + v4l2_ctrl_new_std(handler, NULL, V4L2_CID_HBLANK, h_blank, h_blank, 1, + h_blank); + + vblank_def = mode->vts_def - mode->height; + v4l2_ctrl_new_std(handler, &ov02a10_ctrl_ops, V4L2_CID_VBLANK, + vblank_def, OV02A10_VTS_MAX - mode->height, 1, + vblank_def); + + exposure_max = mode->vts_def - 4; + ov02a10->exposure = v4l2_ctrl_new_std(handler, &ov02a10_ctrl_ops, + V4L2_CID_EXPOSURE, + OV02A10_EXPOSURE_MIN, + exposure_max, + OV02A10_EXPOSURE_STEP, + mode->exp_def); + + v4l2_ctrl_new_std(handler, &ov02a10_ctrl_ops, + V4L2_CID_ANALOGUE_GAIN, OV02A10_GAIN_MIN, + OV02A10_GAIN_MAX, OV02A10_GAIN_STEP, + OV02A10_GAIN_DEFAULT); + + v4l2_ctrl_new_std_menu_items(handler, &ov02a10_ctrl_ops, + V4L2_CID_TEST_PATTERN, + ARRAY_SIZE(ov02a10_test_pattern_menu) - 1, + 0, 0, ov02a10_test_pattern_menu); + + if (handler->error) { + ret = handler->error; + dev_err(&client->dev, "failed to init controls(%d)\n", ret); + goto err_free_handler; + } + + ov02a10->subdev.ctrl_handler = handler; + + return 0; + +err_free_handler: + v4l2_ctrl_handler_free(handler); + + return ret; +} + +static int ov02a10_check_hwcfg(struct device *dev, struct ov02a10 *ov02a10) +{ + struct fwnode_handle *ep; + struct fwnode_handle *fwnode = dev_fwnode(dev); + struct v4l2_fwnode_endpoint bus_cfg = { + .bus_type = V4L2_MBUS_CSI2_DPHY, + }; + unsigned int i, j; + int ret; + + if (!fwnode) + return -EINVAL; + + ep = fwnode_graph_get_next_endpoint(fwnode, NULL); + if (!ep) + return -ENXIO; + + ret = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg); + fwnode_handle_put(ep); + if (ret) + return ret; + + if (!bus_cfg.nr_of_link_frequencies) { + dev_err(dev, "no link frequencies defined\n"); + ret = -EINVAL; + goto check_hwcfg_error; + } + + for (i = 0; i < ARRAY_SIZE(link_freq_menu_items); i++) { + for (j = 0; j < bus_cfg.nr_of_link_frequencies; j++) { + if (link_freq_menu_items[i] == + bus_cfg.link_frequencies[j]) { + ov02a10->freq_index = i; + break; + } + } + + if (j == bus_cfg.nr_of_link_frequencies) { + dev_err(dev, "no link frequency %lld supported\n", + link_freq_menu_items[i]); + ret = -EINVAL; + goto check_hwcfg_error; + } + } + +check_hwcfg_error: + v4l2_fwnode_endpoint_free(&bus_cfg); + + return ret; +} + +static int ov02a10_probe(struct i2c_client *client) +{ + struct device *dev = &client->dev; + struct ov02a10 *ov02a10; + unsigned int rotation; + unsigned int cnt = 0; + unsigned int i; + unsigned int num_freq_clk_volt = 2 * ARRAY_SIZE(link_freq_menu_items); + int ret; + + ov02a10 = devm_kzalloc(dev, sizeof(*ov02a10), GFP_KERNEL); + if (!ov02a10) + return -ENOMEM; + + ret = ov02a10_check_hwcfg(dev, ov02a10); + if (ret) { + dev_err(dev, "failed to check HW configuration: %d\n", ret); + return ret; + } + + v4l2_i2c_subdev_init(&ov02a10->subdev, client, &ov02a10_subdev_ops); + ov02a10->mipi_clock_voltage = OV02A10_MIPI_TX_SPEED_DEFAULT; + ov02a10->fmt.code = MEDIA_BUS_FMT_SBGGR10_1X10; + + /* Optional indication of physical rotation of sensor */ + ret = fwnode_property_read_u32(dev_fwnode(dev), "rotation", &rotation); + if (!ret && rotation == 180) { + ov02a10->upside_down = true; + ov02a10->fmt.code = MEDIA_BUS_FMT_SRGGB10_1X10; + } + + /* Optional indication of MIPI clock voltage unit */ + ret = fwnode_property_read_u32_array(dev_fwnode(dev), + "ovti,mipi-clock-voltage", NULL, + 0); + if (ret > 0 && ret % 2 == 0) { + u32 freq_clk_volt[ret]; + + fwnode_property_read_u32_array(dev_fwnode(dev), + "ovti,mipi-clock-voltage", + freq_clk_volt, + ARRAY_SIZE(freq_clk_volt)); + + while (num_freq_clk_volt) { + unsigned long freq; + unsigned long volt; + + if (cnt >= ARRAY_SIZE(freq_clk_volt)) { + dev_warn(dev, "mismatched link frequency\n"); + break; + } + + freq = freq_clk_volt[cnt++] * 1000; + volt = freq_clk_volt[cnt++]; + + /* Get clock voltage unit value from DT */ + if (freq == link_freq_menu_items[ov02a10->freq_index]) { + ov02a10->mipi_clock_voltage = volt; + break; + } + + num_freq_clk_volt -= 2; + } + } + + /* Get external input clock (eclk) */ + ov02a10->eclk = devm_clk_get(dev, "eclk"); + if (IS_ERR(ov02a10->eclk)) { + ret = PTR_ERR(ov02a10->eclk); + dev_err(dev, "failed to get eclk %d\n", ret); + return ret; + } + + ret = fwnode_property_read_u32(dev_fwnode(dev), "clock-frequency", + &ov02a10->eclk_freq); + if (ret) { + dev_err(dev, "failed to get eclk frequency\n"); + return ret; + } + + ret = clk_set_rate(ov02a10->eclk, ov02a10->eclk_freq); + if (ret) { + dev_err(dev, "failed to set eclk frequency (24MHz)\n"); + return ret; + } + + if (clk_get_rate(ov02a10->eclk) != OV02A10_ECLK_FREQ) { + dev_warn(dev, "eclk mismatched, mode is based on 24MHz\n"); + return -EINVAL; + } + + ov02a10->pd_gpio = devm_gpiod_get(dev, "powerdown", GPIOD_OUT_HIGH); + if (IS_ERR(ov02a10->pd_gpio)) { + ret = PTR_ERR(ov02a10->pd_gpio); + dev_err(dev, "failed to get powerdown-gpios %d\n", ret); + return ret; + } + + ov02a10->rst_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); + if (IS_ERR(ov02a10->rst_gpio)) { + ret = PTR_ERR(ov02a10->rst_gpio); + dev_err(dev, "failed to get reset-gpios %d\n", ret); + return ret; + } + + for (i = 0; i < ARRAY_SIZE(ov02a10_supply_names); i++) + ov02a10->supplies[i].supply = ov02a10_supply_names[i]; + + ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(ov02a10_supply_names), + ov02a10->supplies); + if (ret) { + dev_err(dev, "failed to get regulators\n"); + return ret; + } + + mutex_init(&ov02a10->mutex); + ov02a10->cur_mode = &supported_modes[0]; + + ret = ov02a10_initialize_controls(ov02a10); + if (ret) { + dev_err(dev, "failed to initialize controls\n"); + goto err_destroy_mutex; + } + + ov02a10->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; + ov02a10->subdev.entity.ops = &ov02a10_subdev_entity_ops; + ov02a10->subdev.entity.function = MEDIA_ENT_F_CAM_SENSOR; + ov02a10->pad.flags = MEDIA_PAD_FL_SOURCE; + + ret = media_entity_pads_init(&ov02a10->subdev.entity, 1, &ov02a10->pad); + if (ret < 0) { + dev_err(dev, "failed to init entity pads: %d", ret); + goto err_free_handler; + } + + pm_runtime_enable(dev); + if (!pm_runtime_enabled(dev)) { + ret = ov02a10_power_on(dev); + if (ret < 0) { + dev_err(dev, "failed to power on: %d\n", ret); + goto err_clean_entity; + } + } + + ret = v4l2_async_register_subdev(&ov02a10->subdev); + if (ret) { + dev_err(dev, "failed to register V4L2 subdev: %d\n", ret); + goto err_power_off; + } + + return 0; + +err_power_off: + if (pm_runtime_enabled(dev)) + pm_runtime_disable(dev); + else + ov02a10_power_off(dev); +err_clean_entity: + media_entity_cleanup(&ov02a10->subdev.entity); +err_free_handler: + v4l2_ctrl_handler_free(ov02a10->subdev.ctrl_handler); +err_destroy_mutex: + mutex_destroy(&ov02a10->mutex); + + return ret; +} + +static int ov02a10_remove(struct i2c_client *client) +{ + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct ov02a10 *ov02a10 = to_ov02a10(sd); + + v4l2_async_unregister_subdev(sd); + media_entity_cleanup(&sd->entity); + v4l2_ctrl_handler_free(sd->ctrl_handler); + pm_runtime_disable(&client->dev); + if (!pm_runtime_status_suspended(&client->dev)) + ov02a10_power_off(&client->dev); + pm_runtime_set_suspended(&client->dev); + mutex_destroy(&ov02a10->mutex); + + return 0; +} + +static const struct of_device_id ov02a10_of_match[] = { + { .compatible = "ovti,ov02a10" }, + {} +}; +MODULE_DEVICE_TABLE(of, ov02a10_of_match); + +static struct i2c_driver ov02a10_i2c_driver = { + .driver = { + .name = "ov02a10", + .pm = &ov02a10_pm_ops, + .of_match_table = ov02a10_of_match, + }, + .probe_new = &ov02a10_probe, + .remove = &ov02a10_remove, +}; + +module_i2c_driver(ov02a10_i2c_driver); + +MODULE_AUTHOR("Dongchun Zhu "); +MODULE_DESCRIPTION("OmniVision OV02A10 sensor driver"); +MODULE_LICENSE("GPL v2"); -- 2.9.2 _______________________________________________ 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=-18.0 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING,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 A2CB8C433E2 for ; Wed, 2 Sep 2020 12:05:31 +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 627042078B for ; Wed, 2 Sep 2020 12:05:31 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="1C6jJm0+"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="JZRin0Mg" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 627042078B 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=TnSUq7zNCP8a6i49Gq8kc7OtGCRm65KFjuVdLtk9Qm8=; b=1C6jJm0+GS6opQhJ4qSkMtXL1 2q5gEcBSwhDE59KiHjMDEDlWDOyxcyf38S/D8jYtNDiyMUAhEAGk9mCbwZjKaSTpkVRwz4qh7oOPp /DPcvWvcIuIWntqb6bU2Q3L5kxsEOWiEmyMVcj9EjljhWpRzRYxFpu6ZBjkfe78ymhksNi23SrGGF sYx+TD6PPKZSoFuUwhjRAEtLlj5rN5QKYTPTIWmMqEIevZwN6upQziw4T/8roe1hHl03+OxNgqSpj b6IC25ihgVeLQvcdNOz/VRZB+FgAMeWM3XPsk9GAqblKmcgPYoulwi9eQu7TJwGsviufkIetKBClw BKIg3u0Qg==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1kDRUm-0007tZ-MI; Wed, 02 Sep 2020 12:04: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 1kDRUd-0007q7-Om; Wed, 02 Sep 2020 12:04:03 +0000 X-UUID: c328dd0e30464d9c8bfece5c7a41af4e-20200902 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=WuLF7XUDCvhjAwYLLqbgLri0W+RaEcgUk7UYnX2QiR8=; b=JZRin0MgPDYNFyCZBl4V2/T+JpwN00e+BAYZ8zjENsPhd0gput85WIg4Igg4LfMVpZgDFkK9XEKlPFODZ52ZJZO5y2naDyOhVenZkXwvnY9mH9dwk0opsOAAm4e18OO2mBsoMMqBpZDXXu498PjXgdV2CCxcGVqdJ+jHIca90ms=; X-UUID: c328dd0e30464d9c8bfece5c7a41af4e-20200902 Received: from mtkcas66.mediatek.inc [(172.29.193.44)] by mailgw01.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLSv1.2 ECDHE-RSA-AES256-SHA384 256/256) with ESMTP id 44328685; Wed, 02 Sep 2020 04:03:45 -0800 Received: from mtkmbs07n1.mediatek.inc (172.21.101.16) by MTKMBS62N2.mediatek.inc (172.29.193.42) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 2 Sep 2020 05:03:43 -0700 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs07n1.mediatek.inc (172.21.101.16) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 2 Sep 2020 20:03:40 +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; Wed, 2 Sep 2020 20:03:39 +0800 From: Dongchun Zhu To: , , , , , , , , Subject: [PATCH v14 2/2] media: i2c: Add OV02A10 image sensor driver Date: Wed, 2 Sep 2020 20:01:22 +0800 Message-ID: <20200902120122.24456-3-dongchun.zhu@mediatek.com> X-Mailer: git-send-email 2.9.2 In-Reply-To: <20200902120122.24456-1-dongchun.zhu@mediatek.com> References: <20200902120122.24456-1-dongchun.zhu@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-20200902_080400_056325_1095E720 X-CRM114-Status: GOOD ( 22.60 ) 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: devicetree@vger.kernel.org, srv_heupstream@mediatek.com, shengnan.wang@mediatek.com, sj.huang@mediatek.com, linux-mediatek@lists.infradead.org, dongchun.zhu@mediatek.com, louis.kuo@mediatek.com, linux-arm-kernel@lists.infradead.org, linux-media@vger.kernel.org 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 a V4L2 sub-device driver for OmniVision OV02A10 image sensor. Signed-off-by: Dongchun Zhu --- MAINTAINERS | 1 + drivers/media/i2c/Kconfig | 13 + drivers/media/i2c/Makefile | 1 + drivers/media/i2c/ov02a10.c | 1083 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 1098 insertions(+) create mode 100644 drivers/media/i2c/ov02a10.c diff --git a/MAINTAINERS b/MAINTAINERS index 48aa7a7..ce7d8fa 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -12724,6 +12724,7 @@ L: linux-media@vger.kernel.org S: Maintained T: git git://linuxtv.org/media_tree.git F: Documentation/devicetree/bindings/media/i2c/ovti,ov02a10.yaml +F: drivers/media/i2c/ov02a10.c OMNIVISION OV13858 SENSOR DRIVER M: Sakari Ailus diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig index 48ae60a..f458804 100644 --- a/drivers/media/i2c/Kconfig +++ b/drivers/media/i2c/Kconfig @@ -825,6 +825,19 @@ config VIDEO_IMX355 To compile this driver as a module, choose M here: the module will be called imx355. +config VIDEO_OV02A10 + tristate "OmniVision OV02A10 sensor support" + depends on I2C && VIDEO_V4L2 + select MEDIA_CONTROLLER + select VIDEO_V4L2_SUBDEV_API + select V4L2_FWNODE + help + This is a Video4Linux2 sensor driver for the OmniVision + OV02A10 camera sensor. + + To compile this driver as a module, choose M here: the + module will be called ov02a10. + config VIDEO_OV2640 tristate "OmniVision OV2640 sensor support" depends on VIDEO_V4L2 && I2C diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile index f0a7747..dc27e14 100644 --- a/drivers/media/i2c/Makefile +++ b/drivers/media/i2c/Makefile @@ -64,6 +64,7 @@ obj-$(CONFIG_VIDEO_VP27SMPX) += vp27smpx.o obj-$(CONFIG_VIDEO_SONY_BTF_MPX) += sony-btf-mpx.o obj-$(CONFIG_VIDEO_UPD64031A) += upd64031a.o obj-$(CONFIG_VIDEO_UPD64083) += upd64083.o +obj-$(CONFIG_VIDEO_OV02A10) += ov02a10.o obj-$(CONFIG_VIDEO_OV2640) += ov2640.o obj-$(CONFIG_VIDEO_OV2680) += ov2680.o obj-$(CONFIG_VIDEO_OV2685) += ov2685.o diff --git a/drivers/media/i2c/ov02a10.c b/drivers/media/i2c/ov02a10.c new file mode 100644 index 0000000..1f8c525 --- /dev/null +++ b/drivers/media/i2c/ov02a10.c @@ -0,0 +1,1083 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 MediaTek Inc. + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define CHIP_ID 0x2509 +#define OV02A10_REG_CHIP_ID_H 0x02 +#define OV02A10_REG_CHIP_ID_L 0x03 + +/* Bit[1] vertical upside down */ +/* Bit[0] horizontal mirror */ +#define REG_MIRROR_FLIP_CONTROL 0x3f + +/* Orientation */ +#define REG_MIRROR_FLIP_ENABLE 0x03 + +/* Bit[2:0] MIPI transmission speed select */ +#define TX_SPEED_AREA_SEL 0xa1 +#define OV02A10_MIPI_TX_SPEED_DEFAULT 0x04 + +#define REG_PAGE_SWITCH 0xfd +#define REG_GLOBAL_EFFECTIVE 0x01 +#define REG_ENABLE BIT(0) + +#define REG_SC_CTRL_MODE 0xac +#define SC_CTRL_MODE_STANDBY 0x00 +#define SC_CTRL_MODE_STREAMING 0x01 + +#define OV02A10_EXP_SHIFT 8 +#define OV02A10_REG_EXPOSURE_H 0x03 +#define OV02A10_REG_EXPOSURE_L 0x04 +#define OV02A10_EXPOSURE_MIN 4 +#define OV02A10_EXPOSURE_MAX_MARGIN 4 +#define OV02A10_EXPOSURE_STEP 1 + +#define OV02A10_VTS_SHIFT 8 +#define OV02A10_REG_VTS_H 0x05 +#define OV02A10_REG_VTS_L 0x06 +#define OV02A10_VTS_MAX 0x209f +#define OV02A10_BASIC_LINE 1224 + +#define OV02A10_REG_GAIN 0x24 +#define OV02A10_GAIN_MIN 0x10 +#define OV02A10_GAIN_MAX 0xf8 +#define OV02A10_GAIN_STEP 0x01 +#define OV02A10_GAIN_DEFAULT 0x40 + +/* Test pattern control */ +#define OV02A10_REG_TEST_PATTERN 0xb6 + +#define HZ_PER_MHZ 1000000L +#define OV02A10_LINK_FREQ_390MHZ (390 * HZ_PER_MHZ) +#define OV02A10_ECLK_FREQ (24 * HZ_PER_MHZ) +#define OV02A10_DATA_LANES 1 +#define OV02A10_BITS_PER_SAMPLE 10 + +static const char * const ov02a10_supply_names[] = { + "dovdd", /* Digital I/O power */ + "avdd", /* Analog power */ + "dvdd", /* Digital core power */ +}; + +struct ov02a10_reg { + u8 addr; + u8 val; +}; + +struct ov02a10_reg_list { + u32 num_of_regs; + const struct ov02a10_reg *regs; +}; + +struct ov02a10_mode { + u32 width; + u32 height; + u32 exp_def; + u32 hts_def; + u32 vts_def; + const struct ov02a10_reg_list reg_list; +}; + +struct ov02a10 { + u32 eclk_freq; + /* Indication of MIPI transmission speed select */ + u32 mipi_clock_voltage; + /* Index of link frequency config to be used */ + u32 freq_index; + + struct clk *eclk; + struct gpio_desc *pd_gpio; + struct gpio_desc *rst_gpio; + struct regulator_bulk_data supplies[ARRAY_SIZE(ov02a10_supply_names)]; + + bool streaming; + bool upside_down; + + /* + * Serialize control access, get/set format, get selection + * and start streaming. + */ + struct mutex mutex; + struct v4l2_subdev subdev; + struct media_pad pad; + struct v4l2_mbus_framefmt fmt; + struct v4l2_ctrl_handler ctrl_handler; + struct v4l2_ctrl *exposure; + + const struct ov02a10_mode *cur_mode; +}; + +static inline struct ov02a10 *to_ov02a10(struct v4l2_subdev *sd) +{ + return container_of(sd, struct ov02a10, subdev); +} + +/* + * eclk 24Mhz + * pclk 39Mhz + * linelength 934(0x3a6) + * framelength 1390(0x56E) + * grabwindow_width 1600 + * grabwindow_height 1200 + * max_framerate 30fps + * mipi_datarate per lane 780Mbps + */ +static const struct ov02a10_reg ov02a10_1600x1200_regs[] = { + {0xfd, 0x01}, + {0xac, 0x00}, + {0xfd, 0x00}, + {0x2f, 0x29}, + {0x34, 0x00}, + {0x35, 0x21}, + {0x30, 0x15}, + {0x33, 0x01}, + {0xfd, 0x01}, + {0x44, 0x00}, + {0x2a, 0x4c}, + {0x2b, 0x1e}, + {0x2c, 0x60}, + {0x25, 0x11}, + {0x03, 0x01}, + {0x04, 0xae}, + {0x09, 0x00}, + {0x0a, 0x02}, + {0x06, 0xa6}, + {0x31, 0x00}, + {0x24, 0x40}, + {0x01, 0x01}, + {0xfb, 0x73}, + {0xfd, 0x01}, + {0x16, 0x04}, + {0x1c, 0x09}, + {0x21, 0x42}, + {0x12, 0x04}, + {0x13, 0x10}, + {0x11, 0x40}, + {0x33, 0x81}, + {0xd0, 0x00}, + {0xd1, 0x01}, + {0xd2, 0x00}, + {0x50, 0x10}, + {0x51, 0x23}, + {0x52, 0x20}, + {0x53, 0x10}, + {0x54, 0x02}, + {0x55, 0x20}, + {0x56, 0x02}, + {0x58, 0x48}, + {0x5d, 0x15}, + {0x5e, 0x05}, + {0x66, 0x66}, + {0x68, 0x68}, + {0x6b, 0x00}, + {0x6c, 0x00}, + {0x6f, 0x40}, + {0x70, 0x40}, + {0x71, 0x0a}, + {0x72, 0xf0}, + {0x73, 0x10}, + {0x75, 0x80}, + {0x76, 0x10}, + {0x84, 0x00}, + {0x85, 0x10}, + {0x86, 0x10}, + {0x87, 0x00}, + {0x8a, 0x22}, + {0x8b, 0x22}, + {0x19, 0xf1}, + {0x29, 0x01}, + {0xfd, 0x01}, + {0x9d, 0x16}, + {0xa0, 0x29}, + {0xa1, 0x04}, + {0xad, 0x62}, + {0xae, 0x00}, + {0xaf, 0x85}, + {0xb1, 0x01}, + {0x8e, 0x06}, + {0x8f, 0x40}, + {0x90, 0x04}, + {0x91, 0xb0}, + {0x45, 0x01}, + {0x46, 0x00}, + {0x47, 0x6c}, + {0x48, 0x03}, + {0x49, 0x8b}, + {0x4a, 0x00}, + {0x4b, 0x07}, + {0x4c, 0x04}, + {0x4d, 0xb7}, + {0xf0, 0x40}, + {0xf1, 0x40}, + {0xf2, 0x40}, + {0xf3, 0x40}, + {0x3f, 0x00}, + {0xfd, 0x01}, + {0x05, 0x00}, + {0x06, 0xa6}, + {0xfd, 0x01}, +}; + +static const char * const ov02a10_test_pattern_menu[] = { + "Disabled", + "Eight Vertical Colour Bars", +}; + +static const s64 link_freq_menu_items[] = { + OV02A10_LINK_FREQ_390MHZ, +}; + +static u64 to_pixel_rate(u32 f_index) +{ + u64 pixel_rate = link_freq_menu_items[f_index] * 2 * OV02A10_DATA_LANES; + + do_div(pixel_rate, OV02A10_BITS_PER_SAMPLE); + + return pixel_rate; +} + +static const struct ov02a10_mode supported_modes[] = { + { + .width = 1600, + .height = 1200, + .exp_def = 0x01ae, + .hts_def = 0x03a6, + .vts_def = 0x056e, + .reg_list = { + .num_of_regs = ARRAY_SIZE(ov02a10_1600x1200_regs), + .regs = ov02a10_1600x1200_regs, + }, + }, +}; + +static int ov02a10_write_array(struct ov02a10 *ov02a10, + const struct ov02a10_reg_list *r_list) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + unsigned int i; + int ret; + + for (i = 0; i < r_list->num_of_regs; i++) { + ret = i2c_smbus_write_byte_data(client, r_list->regs[i].addr, + r_list->regs[i].val); + if (ret < 0) + return ret; + } + + return 0; +} + +static int ov02a10_read_smbus(struct ov02a10 *ov02a10, unsigned char reg, + unsigned char *val) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + int ret; + + ret = i2c_smbus_read_byte_data(client, reg); + if (ret < 0) + return ret; + + *val = (unsigned char)ret; + + return 0; +} + +static void ov02a10_fill_fmt(const struct ov02a10_mode *mode, + struct v4l2_mbus_framefmt *fmt) +{ + fmt->width = mode->width; + fmt->height = mode->height; + fmt->field = V4L2_FIELD_NONE; +} + +static int ov02a10_set_fmt(struct v4l2_subdev *sd, + struct v4l2_subdev_pad_config *cfg, + struct v4l2_subdev_format *fmt) +{ + struct ov02a10 *ov02a10 = to_ov02a10(sd); + struct v4l2_mbus_framefmt *mbus_fmt = &fmt->format; + struct v4l2_mbus_framefmt *frame_fmt; + int ret = 0; + + mutex_lock(&ov02a10->mutex); + + if (ov02a10->streaming && fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) { + ret = -EBUSY; + goto error; + } + + /* Only one sensor mode supported */ + mbus_fmt->code = ov02a10->fmt.code; + ov02a10_fill_fmt(ov02a10->cur_mode, mbus_fmt); + + if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) + frame_fmt = v4l2_subdev_get_try_format(sd, cfg, 0); + else + frame_fmt = &ov02a10->fmt; + + *frame_fmt = *mbus_fmt; + +error: + mutex_unlock(&ov02a10->mutex); + return ret; +} + +static int ov02a10_get_fmt(struct v4l2_subdev *sd, + struct v4l2_subdev_pad_config *cfg, + struct v4l2_subdev_format *fmt) +{ + struct ov02a10 *ov02a10 = to_ov02a10(sd); + struct v4l2_mbus_framefmt *mbus_fmt = &fmt->format; + + mutex_lock(&ov02a10->mutex); + + if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { + fmt->format = *v4l2_subdev_get_try_format(sd, cfg, fmt->pad); + } else { + fmt->format = ov02a10->fmt; + mbus_fmt->code = ov02a10->fmt.code; + ov02a10_fill_fmt(ov02a10->cur_mode, mbus_fmt); + } + + mutex_unlock(&ov02a10->mutex); + + return 0; +} + +static int ov02a10_enum_mbus_code(struct v4l2_subdev *sd, + struct v4l2_subdev_pad_config *cfg, + struct v4l2_subdev_mbus_code_enum *code) +{ + struct ov02a10 *ov02a10 = to_ov02a10(sd); + + if (code->index != 0) + return -EINVAL; + + code->code = ov02a10->fmt.code; + + return 0; +} + +static int ov02a10_enum_frame_sizes(struct v4l2_subdev *sd, + struct v4l2_subdev_pad_config *cfg, + struct v4l2_subdev_frame_size_enum *fse) +{ + if (fse->index >= ARRAY_SIZE(supported_modes)) + return -EINVAL; + + fse->min_width = supported_modes[fse->index].width; + fse->max_width = supported_modes[fse->index].width; + fse->max_height = supported_modes[fse->index].height; + fse->min_height = supported_modes[fse->index].height; + + return 0; +} + +static int ov02a10_check_sensor_id(struct ov02a10 *ov02a10) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + u16 id; + u8 chip_id_h; + u8 chip_id_l; + int ret; + + /* Check sensor revision */ + ret = ov02a10_read_smbus(ov02a10, OV02A10_REG_CHIP_ID_H, &chip_id_h); + if (ret) + return ret; + + ret = ov02a10_read_smbus(ov02a10, OV02A10_REG_CHIP_ID_L, &chip_id_l); + if (ret) + return ret; + + id = (chip_id_h << 8) | chip_id_l; + if (id != CHIP_ID) { + dev_err(&client->dev, "Unexpected sensor id(%04x)\n", id); + return -EINVAL; + } + + return 0; +} + +static int ov02a10_power_on(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct ov02a10 *ov02a10 = to_ov02a10(sd); + int ret; + + gpiod_set_value_cansleep(ov02a10->rst_gpio, 1); + gpiod_set_value_cansleep(ov02a10->pd_gpio, 1); + + ret = clk_prepare_enable(ov02a10->eclk); + if (ret < 0) { + dev_err(dev, "failed to enable eclk\n"); + return ret; + } + + ret = regulator_bulk_enable(ARRAY_SIZE(ov02a10_supply_names), + ov02a10->supplies); + if (ret < 0) { + dev_err(dev, "failed to enable regulators\n"); + goto disable_clk; + } + usleep_range(5000, 6000); + + gpiod_set_value_cansleep(ov02a10->pd_gpio, 0); + usleep_range(5000, 6000); + + gpiod_set_value_cansleep(ov02a10->rst_gpio, 0); + usleep_range(5000, 6000); + + ret = ov02a10_check_sensor_id(ov02a10); + if (ret) + goto disable_regulator; + + return 0; + +disable_regulator: + regulator_bulk_disable(ARRAY_SIZE(ov02a10_supply_names), + ov02a10->supplies); +disable_clk: + clk_disable_unprepare(ov02a10->eclk); + + return ret; +} + +static int ov02a10_power_off(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct ov02a10 *ov02a10 = to_ov02a10(sd); + + gpiod_set_value_cansleep(ov02a10->rst_gpio, 1); + clk_disable_unprepare(ov02a10->eclk); + gpiod_set_value_cansleep(ov02a10->pd_gpio, 1); + regulator_bulk_disable(ARRAY_SIZE(ov02a10_supply_names), + ov02a10->supplies); + + return 0; +} + +static int __ov02a10_start_stream(struct ov02a10 *ov02a10) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + const struct ov02a10_reg_list *reg_list; + int ret; + + /* Apply default values of current mode */ + reg_list = &ov02a10->cur_mode->reg_list; + ret = ov02a10_write_array(ov02a10, reg_list); + if (ret) + return ret; + + /* Apply customized values from user */ + ret = __v4l2_ctrl_handler_setup(ov02a10->subdev.ctrl_handler); + if (ret) + return ret; + + /* Set orientation to 180 degree */ + if (ov02a10->upside_down) { + ret = i2c_smbus_write_byte_data(client, REG_MIRROR_FLIP_CONTROL, + REG_MIRROR_FLIP_ENABLE); + if (ret) { + dev_err(&client->dev, "failed to set orientation\n"); + return ret; + } + ret = i2c_smbus_write_byte_data(client, REG_GLOBAL_EFFECTIVE, + REG_ENABLE); + if (ret < 0) + return ret; + } + + /* Set MIPI TX speed according to DT property */ + if (ov02a10->mipi_clock_voltage != OV02A10_MIPI_TX_SPEED_DEFAULT) { + ret = i2c_smbus_write_byte_data(client, TX_SPEED_AREA_SEL, + ov02a10->mipi_clock_voltage); + if (ret < 0) + return ret; + } + + /* Set stream on register */ + return i2c_smbus_write_byte_data(client, REG_SC_CTRL_MODE, + SC_CTRL_MODE_STREAMING); +} + +static int __ov02a10_stop_stream(struct ov02a10 *ov02a10) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + + return i2c_smbus_write_byte_data(client, REG_SC_CTRL_MODE, + SC_CTRL_MODE_STANDBY); +} + +static int ov02a10_entity_init_cfg(struct v4l2_subdev *sd, + struct v4l2_subdev_pad_config *cfg) +{ + struct v4l2_subdev_format fmt = { + .which = V4L2_SUBDEV_FORMAT_TRY, + .format = { + .width = 1600, + .height = 1200, + } + }; + + ov02a10_set_fmt(sd, cfg, &fmt); + + return 0; +} + +static int ov02a10_s_stream(struct v4l2_subdev *sd, int on) +{ + struct ov02a10 *ov02a10 = to_ov02a10(sd); + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + int ret; + + mutex_lock(&ov02a10->mutex); + + if (ov02a10->streaming == on) + goto unlock_and_return; + + if (on) { + ret = pm_runtime_get_sync(&client->dev); + if (ret < 0) { + pm_runtime_put_noidle(&client->dev); + goto unlock_and_return; + } + + ret = __ov02a10_start_stream(ov02a10); + if (ret) { + __ov02a10_stop_stream(ov02a10); + ov02a10->streaming = !on; + goto err_rpm_put; + } + } else { + __ov02a10_stop_stream(ov02a10); + pm_runtime_put(&client->dev); + } + + ov02a10->streaming = on; + mutex_unlock(&ov02a10->mutex); + + return 0; + +err_rpm_put: + pm_runtime_put(&client->dev); +unlock_and_return: + mutex_unlock(&ov02a10->mutex); + + return ret; +} + +static const struct dev_pm_ops ov02a10_pm_ops = { + SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, + pm_runtime_force_resume) + SET_RUNTIME_PM_OPS(ov02a10_power_off, ov02a10_power_on, NULL) +}; + +/* + * ov02a10_set_exposure - Function called when setting exposure time + * @priv: Pointer to device structure + * @val: Variable for exposure time, in the unit of micro-second + * + * Set exposure time based on input value. + * + * Return: 0 on success + */ +static int ov02a10_set_exposure(struct ov02a10 *ov02a10, int val) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + int ret; + + ret = i2c_smbus_write_byte_data(client, REG_PAGE_SWITCH, REG_ENABLE); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, OV02A10_REG_EXPOSURE_H, + val >> OV02A10_EXP_SHIFT); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, OV02A10_REG_EXPOSURE_L, val); + if (ret < 0) + return ret; + + return i2c_smbus_write_byte_data(client, REG_GLOBAL_EFFECTIVE, + REG_ENABLE); +} + +static int ov02a10_set_gain(struct ov02a10 *ov02a10, int val) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + int ret; + + ret = i2c_smbus_write_byte_data(client, REG_PAGE_SWITCH, REG_ENABLE); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, OV02A10_REG_GAIN, val); + if (ret < 0) + return ret; + + return i2c_smbus_write_byte_data(client, REG_GLOBAL_EFFECTIVE, + REG_ENABLE); +} + +static int ov02a10_set_vblank(struct ov02a10 *ov02a10, int val) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + u32 vts = val + ov02a10->cur_mode->height - OV02A10_BASIC_LINE; + int ret; + + ret = i2c_smbus_write_byte_data(client, REG_PAGE_SWITCH, REG_ENABLE); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, OV02A10_REG_VTS_H, + vts >> OV02A10_VTS_SHIFT); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, OV02A10_REG_VTS_L, vts); + if (ret < 0) + return ret; + + return i2c_smbus_write_byte_data(client, REG_GLOBAL_EFFECTIVE, + REG_ENABLE); +} + +static int ov02a10_set_test_pattern(struct ov02a10 *ov02a10, int pattern) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + int ret; + + ret = i2c_smbus_write_byte_data(client, REG_PAGE_SWITCH, REG_ENABLE); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, OV02A10_REG_TEST_PATTERN, + pattern); + if (ret < 0) + return ret; + + ret = i2c_smbus_write_byte_data(client, REG_GLOBAL_EFFECTIVE, + REG_ENABLE); + if (ret < 0) + return ret; + + return i2c_smbus_write_byte_data(client, REG_SC_CTRL_MODE, + SC_CTRL_MODE_STREAMING); +} + +static int ov02a10_set_ctrl(struct v4l2_ctrl *ctrl) +{ + struct ov02a10 *ov02a10 = container_of(ctrl->handler, + struct ov02a10, ctrl_handler); + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + s64 max_expo; + int ret; + + /* Propagate change of current control to all related controls */ + if (ctrl->id == V4L2_CID_VBLANK) { + /* Update max exposure while meeting expected vblanking */ + max_expo = ov02a10->cur_mode->height + ctrl->val - + OV02A10_EXPOSURE_MAX_MARGIN; + __v4l2_ctrl_modify_range(ov02a10->exposure, + ov02a10->exposure->minimum, max_expo, + ov02a10->exposure->step, + ov02a10->exposure->default_value); + } + + /* V4L2 controls values will be applied only when power is already up */ + if (!pm_runtime_get_if_in_use(&client->dev)) + return 0; + + switch (ctrl->id) { + case V4L2_CID_EXPOSURE: + ret = ov02a10_set_exposure(ov02a10, ctrl->val); + break; + case V4L2_CID_ANALOGUE_GAIN: + ret = ov02a10_set_gain(ov02a10, ctrl->val); + break; + case V4L2_CID_VBLANK: + ret = ov02a10_set_vblank(ov02a10, ctrl->val); + break; + case V4L2_CID_TEST_PATTERN: + ret = ov02a10_set_test_pattern(ov02a10, ctrl->val); + break; + default: + ret = -EINVAL; + break; + }; + + pm_runtime_put(&client->dev); + + return ret; +} + +static const struct v4l2_subdev_video_ops ov02a10_video_ops = { + .s_stream = ov02a10_s_stream, +}; + +static const struct v4l2_subdev_pad_ops ov02a10_pad_ops = { + .init_cfg = ov02a10_entity_init_cfg, + .enum_mbus_code = ov02a10_enum_mbus_code, + .enum_frame_size = ov02a10_enum_frame_sizes, + .get_fmt = ov02a10_get_fmt, + .set_fmt = ov02a10_set_fmt, +}; + +static const struct v4l2_subdev_ops ov02a10_subdev_ops = { + .video = &ov02a10_video_ops, + .pad = &ov02a10_pad_ops, +}; + +static const struct media_entity_operations ov02a10_subdev_entity_ops = { + .link_validate = v4l2_subdev_link_validate, +}; + +static const struct v4l2_ctrl_ops ov02a10_ctrl_ops = { + .s_ctrl = ov02a10_set_ctrl, +}; + +static int ov02a10_initialize_controls(struct ov02a10 *ov02a10) +{ + struct i2c_client *client = v4l2_get_subdevdata(&ov02a10->subdev); + const struct ov02a10_mode *mode; + struct v4l2_ctrl_handler *handler; + struct v4l2_ctrl *ctrl; + s64 exposure_max; + s64 vblank_def; + s64 pixel_rate; + s64 h_blank; + int ret; + + handler = &ov02a10->ctrl_handler; + mode = ov02a10->cur_mode; + ret = v4l2_ctrl_handler_init(handler, 7); + if (ret) + return ret; + + handler->lock = &ov02a10->mutex; + + ctrl = v4l2_ctrl_new_int_menu(handler, NULL, V4L2_CID_LINK_FREQ, 0, 0, + link_freq_menu_items); + if (ctrl) + ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; + + pixel_rate = to_pixel_rate(0); + v4l2_ctrl_new_std(handler, NULL, V4L2_CID_PIXEL_RATE, 0, pixel_rate, 1, + pixel_rate); + + h_blank = mode->hts_def - mode->width; + v4l2_ctrl_new_std(handler, NULL, V4L2_CID_HBLANK, h_blank, h_blank, 1, + h_blank); + + vblank_def = mode->vts_def - mode->height; + v4l2_ctrl_new_std(handler, &ov02a10_ctrl_ops, V4L2_CID_VBLANK, + vblank_def, OV02A10_VTS_MAX - mode->height, 1, + vblank_def); + + exposure_max = mode->vts_def - 4; + ov02a10->exposure = v4l2_ctrl_new_std(handler, &ov02a10_ctrl_ops, + V4L2_CID_EXPOSURE, + OV02A10_EXPOSURE_MIN, + exposure_max, + OV02A10_EXPOSURE_STEP, + mode->exp_def); + + v4l2_ctrl_new_std(handler, &ov02a10_ctrl_ops, + V4L2_CID_ANALOGUE_GAIN, OV02A10_GAIN_MIN, + OV02A10_GAIN_MAX, OV02A10_GAIN_STEP, + OV02A10_GAIN_DEFAULT); + + v4l2_ctrl_new_std_menu_items(handler, &ov02a10_ctrl_ops, + V4L2_CID_TEST_PATTERN, + ARRAY_SIZE(ov02a10_test_pattern_menu) - 1, + 0, 0, ov02a10_test_pattern_menu); + + if (handler->error) { + ret = handler->error; + dev_err(&client->dev, "failed to init controls(%d)\n", ret); + goto err_free_handler; + } + + ov02a10->subdev.ctrl_handler = handler; + + return 0; + +err_free_handler: + v4l2_ctrl_handler_free(handler); + + return ret; +} + +static int ov02a10_check_hwcfg(struct device *dev, struct ov02a10 *ov02a10) +{ + struct fwnode_handle *ep; + struct fwnode_handle *fwnode = dev_fwnode(dev); + struct v4l2_fwnode_endpoint bus_cfg = { + .bus_type = V4L2_MBUS_CSI2_DPHY, + }; + unsigned int i, j; + int ret; + + if (!fwnode) + return -EINVAL; + + ep = fwnode_graph_get_next_endpoint(fwnode, NULL); + if (!ep) + return -ENXIO; + + ret = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg); + fwnode_handle_put(ep); + if (ret) + return ret; + + if (!bus_cfg.nr_of_link_frequencies) { + dev_err(dev, "no link frequencies defined\n"); + ret = -EINVAL; + goto check_hwcfg_error; + } + + for (i = 0; i < ARRAY_SIZE(link_freq_menu_items); i++) { + for (j = 0; j < bus_cfg.nr_of_link_frequencies; j++) { + if (link_freq_menu_items[i] == + bus_cfg.link_frequencies[j]) { + ov02a10->freq_index = i; + break; + } + } + + if (j == bus_cfg.nr_of_link_frequencies) { + dev_err(dev, "no link frequency %lld supported\n", + link_freq_menu_items[i]); + ret = -EINVAL; + goto check_hwcfg_error; + } + } + +check_hwcfg_error: + v4l2_fwnode_endpoint_free(&bus_cfg); + + return ret; +} + +static int ov02a10_probe(struct i2c_client *client) +{ + struct device *dev = &client->dev; + struct ov02a10 *ov02a10; + unsigned int rotation; + unsigned int cnt = 0; + unsigned int i; + unsigned int num_freq_clk_volt = 2 * ARRAY_SIZE(link_freq_menu_items); + int ret; + + ov02a10 = devm_kzalloc(dev, sizeof(*ov02a10), GFP_KERNEL); + if (!ov02a10) + return -ENOMEM; + + ret = ov02a10_check_hwcfg(dev, ov02a10); + if (ret) { + dev_err(dev, "failed to check HW configuration: %d\n", ret); + return ret; + } + + v4l2_i2c_subdev_init(&ov02a10->subdev, client, &ov02a10_subdev_ops); + ov02a10->mipi_clock_voltage = OV02A10_MIPI_TX_SPEED_DEFAULT; + ov02a10->fmt.code = MEDIA_BUS_FMT_SBGGR10_1X10; + + /* Optional indication of physical rotation of sensor */ + ret = fwnode_property_read_u32(dev_fwnode(dev), "rotation", &rotation); + if (!ret && rotation == 180) { + ov02a10->upside_down = true; + ov02a10->fmt.code = MEDIA_BUS_FMT_SRGGB10_1X10; + } + + /* Optional indication of MIPI clock voltage unit */ + ret = fwnode_property_read_u32_array(dev_fwnode(dev), + "ovti,mipi-clock-voltage", NULL, + 0); + if (ret > 0 && ret % 2 == 0) { + u32 freq_clk_volt[ret]; + + fwnode_property_read_u32_array(dev_fwnode(dev), + "ovti,mipi-clock-voltage", + freq_clk_volt, + ARRAY_SIZE(freq_clk_volt)); + + while (num_freq_clk_volt) { + unsigned long freq; + unsigned long volt; + + if (cnt >= ARRAY_SIZE(freq_clk_volt)) { + dev_warn(dev, "mismatched link frequency\n"); + break; + } + + freq = freq_clk_volt[cnt++] * 1000; + volt = freq_clk_volt[cnt++]; + + /* Get clock voltage unit value from DT */ + if (freq == link_freq_menu_items[ov02a10->freq_index]) { + ov02a10->mipi_clock_voltage = volt; + break; + } + + num_freq_clk_volt -= 2; + } + } + + /* Get external input clock (eclk) */ + ov02a10->eclk = devm_clk_get(dev, "eclk"); + if (IS_ERR(ov02a10->eclk)) { + ret = PTR_ERR(ov02a10->eclk); + dev_err(dev, "failed to get eclk %d\n", ret); + return ret; + } + + ret = fwnode_property_read_u32(dev_fwnode(dev), "clock-frequency", + &ov02a10->eclk_freq); + if (ret) { + dev_err(dev, "failed to get eclk frequency\n"); + return ret; + } + + ret = clk_set_rate(ov02a10->eclk, ov02a10->eclk_freq); + if (ret) { + dev_err(dev, "failed to set eclk frequency (24MHz)\n"); + return ret; + } + + if (clk_get_rate(ov02a10->eclk) != OV02A10_ECLK_FREQ) { + dev_warn(dev, "eclk mismatched, mode is based on 24MHz\n"); + return -EINVAL; + } + + ov02a10->pd_gpio = devm_gpiod_get(dev, "powerdown", GPIOD_OUT_HIGH); + if (IS_ERR(ov02a10->pd_gpio)) { + ret = PTR_ERR(ov02a10->pd_gpio); + dev_err(dev, "failed to get powerdown-gpios %d\n", ret); + return ret; + } + + ov02a10->rst_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); + if (IS_ERR(ov02a10->rst_gpio)) { + ret = PTR_ERR(ov02a10->rst_gpio); + dev_err(dev, "failed to get reset-gpios %d\n", ret); + return ret; + } + + for (i = 0; i < ARRAY_SIZE(ov02a10_supply_names); i++) + ov02a10->supplies[i].supply = ov02a10_supply_names[i]; + + ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(ov02a10_supply_names), + ov02a10->supplies); + if (ret) { + dev_err(dev, "failed to get regulators\n"); + return ret; + } + + mutex_init(&ov02a10->mutex); + ov02a10->cur_mode = &supported_modes[0]; + + ret = ov02a10_initialize_controls(ov02a10); + if (ret) { + dev_err(dev, "failed to initialize controls\n"); + goto err_destroy_mutex; + } + + ov02a10->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; + ov02a10->subdev.entity.ops = &ov02a10_subdev_entity_ops; + ov02a10->subdev.entity.function = MEDIA_ENT_F_CAM_SENSOR; + ov02a10->pad.flags = MEDIA_PAD_FL_SOURCE; + + ret = media_entity_pads_init(&ov02a10->subdev.entity, 1, &ov02a10->pad); + if (ret < 0) { + dev_err(dev, "failed to init entity pads: %d", ret); + goto err_free_handler; + } + + pm_runtime_enable(dev); + if (!pm_runtime_enabled(dev)) { + ret = ov02a10_power_on(dev); + if (ret < 0) { + dev_err(dev, "failed to power on: %d\n", ret); + goto err_clean_entity; + } + } + + ret = v4l2_async_register_subdev(&ov02a10->subdev); + if (ret) { + dev_err(dev, "failed to register V4L2 subdev: %d\n", ret); + goto err_power_off; + } + + return 0; + +err_power_off: + if (pm_runtime_enabled(dev)) + pm_runtime_disable(dev); + else + ov02a10_power_off(dev); +err_clean_entity: + media_entity_cleanup(&ov02a10->subdev.entity); +err_free_handler: + v4l2_ctrl_handler_free(ov02a10->subdev.ctrl_handler); +err_destroy_mutex: + mutex_destroy(&ov02a10->mutex); + + return ret; +} + +static int ov02a10_remove(struct i2c_client *client) +{ + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct ov02a10 *ov02a10 = to_ov02a10(sd); + + v4l2_async_unregister_subdev(sd); + media_entity_cleanup(&sd->entity); + v4l2_ctrl_handler_free(sd->ctrl_handler); + pm_runtime_disable(&client->dev); + if (!pm_runtime_status_suspended(&client->dev)) + ov02a10_power_off(&client->dev); + pm_runtime_set_suspended(&client->dev); + mutex_destroy(&ov02a10->mutex); + + return 0; +} + +static const struct of_device_id ov02a10_of_match[] = { + { .compatible = "ovti,ov02a10" }, + {} +}; +MODULE_DEVICE_TABLE(of, ov02a10_of_match); + +static struct i2c_driver ov02a10_i2c_driver = { + .driver = { + .name = "ov02a10", + .pm = &ov02a10_pm_ops, + .of_match_table = ov02a10_of_match, + }, + .probe_new = &ov02a10_probe, + .remove = &ov02a10_remove, +}; + +module_i2c_driver(ov02a10_i2c_driver); + +MODULE_AUTHOR("Dongchun Zhu "); +MODULE_DESCRIPTION("OmniVision OV02A10 sensor driver"); +MODULE_LICENSE("GPL v2"); -- 2.9.2 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel