From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754602AbdFWXEg (ORCPT ); Fri, 23 Jun 2017 19:04:36 -0400 Received: from mail-by2nam01on0115.outbound.protection.outlook.com ([104.47.34.115]:64102 "EHLO NAM01-BY2-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1753900AbdFWXEc (ORCPT ); Fri, 23 Jun 2017 19:04:32 -0400 Authentication-Results: kernel.org; dkim=none (message not signed) header.d=none;kernel.org; dmarc=none action=none header.from=maximintegrated.com; From: Ismail Kose To: jic23@kernel.org, knaack.h@gmx.de, lars@metafoo.de, pmeerw@pmeerw.net, robh+dt@kernel.org, mark.rutland@arm.com, vilhelm.gray@gmail.com, linus.walleij@linaro.org, jeff.dagenais@gmail.com, fabrice.gasnier@st.com Cc: gwenhael.goavec-merou@trabucayre.com, peda@axentia.se, maxime.roussinbelanger@gmail.com, ihkose@gmail.com, Ismail.Kose@maximintegrated.com, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH] iio: dac: DS4424: add Maxim DS4422/DS4424 DAC driver support Date: Fri, 23 Jun 2017 16:04:04 -0700 Message-Id: <20170623230404.2283-1-Ismail.Kose@maximintegrated.com> X-Mailer: git-send-email 2.11.0 MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [204.17.143.20] X-ClientProxiedBy: MWHPR14CA0054.namprd14.prod.outlook.com (10.173.97.144) To CY4PR11MB1864.namprd11.prod.outlook.com (10.175.61.138) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 345aa69b-50e7-4f93-d8c2-08d4ba8c32d7 X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:(22001)(48565401081)(201703131423075)(201703031133081);SRVR:CY4PR11MB1864; X-Microsoft-Exchange-Diagnostics: 1;CY4PR11MB1864;3:KUTmiHDvVZkkH61Ko45BsW4YInsbFc8EZa0SiPnUruwLZelZsOpIgM4sZrP0HPnsYsJ1hDLPBkiw+HB1qMhowp8HYe/actYPn4jycDLa/N8362azSfl3R8Jrsvni24yNPOYZu276vg+eO89F42EgTe4VZaWVJWx6dUqeth9hBNq01Y8d2z5Gqs6lyibGN5WuARClye72LEAn92KVnckY3Km6KfpmMd+56qxlmOI+EX5kNcCFe7UXhtd50xQyzCKGVJESDs6afneJJ49tCmLhwaZEyuOAyEIauyCqwXOVXqFyVTdQm4EhktrBjnOTBQUsNuwZ0rmlikljKHiycwrN+CJkBepMK4E4ii3WUunhYrk= X-MS-TrafficTypeDiagnostic: CY4PR11MB1864: X-Microsoft-Exchange-Diagnostics: 1;CY4PR11MB1864;25:62AXuYN6v2Tb7jGXkHEj1IgSQ5WwsGPMNNOIKl/OUf35OjEzFJCvDvmIY6Mh0EwgkVwRso0A9YxABfbqmkexcKTBLeEkcVYTZfuLh862BLkRg0NXa0sprUEr3xnaX4F+zai3TljiFS+JDP/ovXoy3cbWkj3rvq5PoqynQs+N9f1zXK5HGCCB05qi6zAb8y+gYB4nb1rsy3ZsxtsPVyGRF3cpkwUszfYw5uccVYZdwSD7607OvvlXG1ue0IsIgTP0HZjnecJ7/CV2/pE9pDzwXzE6VclhK0ddBJIV4I/PIoI3Wad/6CMb4KvIYV3EO8Vv9BRkelWe9H6pUMt/f1losT2lEbcWhNA3pbSpjASS1g1bdjekvZVCbGt1AS+urh1/r6LVAY9b37/vkeJGoqTCUEwh+FJCEpGCqGLD3Xi0ahP5qSeweg7VCtVs0SqNZZw3lw1IqaUt4WVPswCgNu4U64Tee9dpek7T7GzUPaI1a6W+UlX0naxJmP07WTMztzYRnEEx0LtfcRfY/zHnxUkbRndpFN4BlJ+TOOeFMR0bwoszznSDH/u2oL7LT4tiGiu0zzqUAv0iWiB2U0qyrjW1NLeoI7IBIHzEGCaCKbraMUMY51Z94O480cRco2O/LRxZc9w64vAEq5E9zkseWGXFCm9Hf5on1nnBM/h9NcdThn5o8pPw16sl7IVIvdvaesEbZSHxnOAOu0xsZzx18gljH1yBMCR8iudDRVdswqGFoBa6J0Z+GoYHXazxrpjPsfd9cgdnWvth8I2z6bLeS3uJINI5Vg5o0Ye0HbOFMZZGhxW+09lJWe6iq0o+MUm0WMu9V4HsDHz/nrEb3jPJq0vosUfdPGdDPHgTj2eSYCmI0RSxQzhhjf6AJJK60anrq9INAE1HDb+IrAtklFMnDUeynBOG/j6UOd97b4oooaSJPbI= X-Microsoft-Exchange-Diagnostics: 1;CY4PR11MB1864;31:prFu2Bz3vzebPZnwrS77Kr/B8+1xY1ER7UXu6lHU/48HpV6jo8kbBenC3UKBrF9NRdSTmgE6b3G7mtcbtxsi/+7bZwrfC8Rn6zHveoLaxJwIAnw7BcAqfmXg6klQFlnOr2wkfXMp/m/MTWLc99NauruHSDC0ujfGZ1HtEd3Ynj5CwCgmY4MJUnInwHvXVJ2g5LnRv/oSdXnpN9doTBTpqWHK0Fp8wkaph8dqNHhCqtMvQCxe3iK74HWDa/dydeGXm+yCHFfwLhgXh7EjHE7M2kMAYcDkz6YyUULqU8JJQ4060syylmWkx2InEASvALVSQZyYtQ07MTBhWqYj63m1J73qStXZj8tQ/5bjBarUjl8l8mkwX97LerLl7h5D7MZOYSRoBPLl++YsoDngMS5RDNBCoYANKExrG75TDgADqfpG3Ueos3JYO7wHK7z0DjutARBxfn6YFM8KVx2B8ZHqXpAWPAw07NFseT0WG3z7qACK00k7xIydvpg42I9xbW6THwyz7PJj1v3/NsOAqtAm0EILQ8uZvPsGO1KiQgJvu3LjDl9YPE3dffo5aEmkFlkTomvryux2x0PcmrydnsEdkwH9HKYzuN8E8M3M0ACizzwylgdnsEWLzyruf600UZrLxWbbLYdcxkO7uVi6qN1SDC5AR5ha5VE3XXl/S1iJXQeIGw44QzTrjQQgeYRw7nmy X-Microsoft-Exchange-Diagnostics: 1;CY4PR11MB1864;20:FeKJwnEAKWY3ft1q73GQU8MaXcDgjIrop0OhLMTFV73Jkwlj6gFlptdgKWsBxhus7my4v3ibpxukStIaYAdQLFmEoy63Q6H7wWteOLT2B6JWgepUGDVhFLSi7Fgzqr/O7k0hU7ZVKF5Do/MfJjojHp6i2UdMqvWEBhpJXFk+e6poV4KtGM1hJkedl/kUsDn8vBOrbwrl1a1XPIQZLP7hLBimUEF7FxAwMcgL5miUYIBvJDhuIXpY3jORGe2rSYsMogCnf7ozte07QlWAGYsBVqFOB5wB/zoOIVae6o48IdtdtCFnj1qf4VSy1vonZS/+aWsmHXd4t/BWMHJfwYg6aN39A14QlU5JfG05A5Esbdsf/H25iiqcP+Ybmd9tKbC3l94YmLbSHDYndYnzccDrlZxf9YKXT5UwOPk99Lz5OoAYYf+CYHo4gBKwQEKDev7Ks1XuRMzXl6/40fDzXMvy440rGqW8v6dnP5fBDP/VYcj1qynL4nimMGURaPW6yZn3 X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(108721460000369)(133145235818549)(236129657087228)(148574349560750); X-Exchange-Antispam-Report-CFA-Test: BCL:0;PCL:0;RULEID:(100000700101)(100105000095)(100000701101)(100105300095)(100000702101)(100105100095)(6040450)(601004)(2401047)(5005006)(8121501046)(3002001)(100000703101)(100105400095)(93006095)(93001095)(10201501046)(6055026)(6041248)(201703131423075)(201702281528075)(201703061421075)(201703061406153)(20161123564025)(20161123562025)(20161123555025)(20161123558100)(20161123560025)(6072148)(100000704101)(100105200095)(100000705101)(100105500095);SRVR:CY4PR11MB1864;BCL:0;PCL:0;RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(100000804101)(100110200095)(100000805101)(100110500095);SRVR:CY4PR11MB1864; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1;CY4PR11MB1864;4:A3+XwnDZpgnqeduvRn4g7Sqkq1vJ7JyHkvjm4+rbWB?= =?us-ascii?Q?cKD90AEoBm4Rp2WAIOvxCPCWITpoe8aIx9IKSf+ZRYED+1woLpEaigwWCPT0?= =?us-ascii?Q?hBhkPj0XU6Q3njK/oC/To6nv6LNqUX4Q4gI24zdvF2bCSWaxwAnq7zKAYJOM?= =?us-ascii?Q?4NDVzMV3Rw5tK1/b7HOXQHymgdj8lYwa4HbVCz78UEOZ2W6sLFDK24D1TFs4?= =?us-ascii?Q?dWscGNad6Y7AiHkJpod+eAQE67fmNdDb37RiSuHLG+3hBCdCrJvRokDagYx+?= =?us-ascii?Q?jLFNa257/X2i1VwMOw+/+/XYxEL+Jr01/+LOy/O1mvw6uiUTozxMUc6ujJN5?= =?us-ascii?Q?Z0E4SUnuLVgVroFHUhqpbPFJZRXZqHz+5HC80MpI2CksMA4tXoRKvWxdBS/P?= =?us-ascii?Q?wKxFxcitpc7qt5+nXE6ZKnI2lfNepkjt8qLZylDYfV9pZNaAqrruNQ1/Cwbv?= =?us-ascii?Q?ER80QR+VSNsTbioMh92DgnTKaX5qtwPtLShmI/AkR1es39+QyXrcguhslyQt?= =?us-ascii?Q?JfKzmCW2YgA5lQ1Q98y/fN0pD3NGzUwqp+ym89qvq3RrgaxB34a66LPfOkvx?= =?us-ascii?Q?Ixd08DxG/BgG+3pdqCT6n2o92hucRaX/BY4W8/QeVB0NtOvfW8m1xCrIz+Ln?= =?us-ascii?Q?/b46vwBJOrUPwG87cLaBGyYX2DpGMzagZGF7NK3u9ooqQYLH/jIzFBLmXhby?= =?us-ascii?Q?2rKoNmz/DkjKPJijG+taV4/pR5YQ0XSL7qgp/GV2N6sdyhWohdVfN9Zu1AlU?= =?us-ascii?Q?T4oMRXEuqe44lapfLlqfjFRgvZLKIKQdlUcRVdVG5o737SliEu2PIrkb+iAE?= =?us-ascii?Q?1/iUpa9hbbGVe4h3ASEepFnMLVs2eR28csLYo7CKPdmSobgm8E1qEIsCSsGq?= =?us-ascii?Q?2w8aUp63ds2yVNA3Ob9/8c9Vd+IueJ15kuUPBbJ9Ilinx/Ut5vVdo5DcAOUE?= =?us-ascii?Q?dhhyoFXWkaERba/BlwZOYp4VL+N9u6EPAbjHdLZeF1i+cNUwOYr8FvcoRm3R?= =?us-ascii?Q?6+lzLaN1DtluGgCc0ZA/iKp1719HJfv0MrXmZ/egyDheMlnftcpDfZzZhFjt?= =?us-ascii?Q?Ghm1gmEEqN3YqBNAwCsqu0lJOeDzy2XXe6rKXFsdRl/7gi9cDa5OsL7JhG4Q?= =?us-ascii?Q?0CqS5eKjh5h8DiToqBwKnKHLNZwPv7uknPm7sp7pO/VODw8CwEUq5mdzllGN?= =?us-ascii?Q?uFFdyKb+tA//4IXYvKV6/5JVodu3GTg4hUU/t3O9UuecyuVr+U4hgNRx4umm?= =?us-ascii?Q?brq+NoIsHblxBORP+ugl8lHANfi9WZRfg2PCqJzi1gKg29ywLxtJGd0m5cUu?= =?us-ascii?Q?1ib9MYO1epZWOn8mCDWyw=3D?= X-Forefront-PRVS: 0347410860 X-Forefront-Antispam-Report: SFV:NSPM;SFS:(10019020)(4630300001)(6009001)(39450400003)(39850400002)(39400400002)(39410400002)(39860400002)(39840400002)(478600001)(6666003)(575784001)(189998001)(86362001)(38730400002)(2906002)(110136004)(8676002)(6116002)(1076002)(53936002)(81166006)(561924002)(42186005)(53416004)(3846002)(5003940100001)(50226002)(48376002)(50466002)(47776003)(5660300001)(305945005)(7416002)(66066001)(36756003)(6486002)(72206003)(8666007)(966005)(6512007)(25786009)(6306002)(6506006)(4326008)(50986999)(921003)(1121003);DIR:OUT;SFP:1102;SCL:1;SRVR:CY4PR11MB1864;H:kose.maxim-ic.com;FPR:;SPF:None;MLV:sfv;LANG:en; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1;CY4PR11MB1864;23:hp68WyRnIBE8mKxAVFQiTnR8qLvYSOAeCOFfFXxL0?= =?us-ascii?Q?HkzIsZ7ica7OJ3ATZFN8wf72UwXeNETN9RSNaga0ScOuL9CHLuUdZcxrc+zs?= =?us-ascii?Q?NJuHUJA18Lgu9OD1k4CJKkrv7PFj+f+Ci3TlagAyHQtu1m72oD3aCu7ae6On?= =?us-ascii?Q?TZrCnQ2h2CixETQbP3H44hlXckj03jkcOUiqMxoGZ+HjMVYPessc0F5cp0z6?= =?us-ascii?Q?r55Q06vU3K0POamJv6RBFk0ViF8Zed6uVwxKDqhtRd8juX5Htr0//bmZkU1X?= =?us-ascii?Q?+Z2rONUSEYaOYLLntFbvZklQDUafzGvRuAqDyz6B2E2zxvFISiWNsy2OAyp5?= =?us-ascii?Q?LH1TAkdQRgKTSbJobO9ChK9XLOayTxfxwuanC+t75h3vJJ59xeAwcjxFOW5+?= =?us-ascii?Q?wOPqrElImnNVF29KIVGNYLESMC9QpQ0f3CfGSva+LEAoSBuhy/BXQbBNP1Wr?= =?us-ascii?Q?kAq2T1Z/NTkHTNKnWlYCQtlfjRwRbpNF6f51xm1IHIH5JsMKAyj6UxNExAWv?= =?us-ascii?Q?CD1jZbqLEG1YprzevBYJwaEpyo1SZDDlXhRG1Xyg/Jgs2hRHX+wZ4HJuBcVQ?= =?us-ascii?Q?as8xOnk7SQdq/nLBUqKgMlcLMIUTn4kwqca763avY073hvR8PCw8OLwwhaWV?= =?us-ascii?Q?TAzzNsV7LaImUAD4pDTy/yB2T3p5NHsSDfvbVMv05Cy6upulOHj4xwdPcW7m?= =?us-ascii?Q?cWZpVSuda4XVdOiZkqSpSNYxWh2npATpfzBDf4YCYeAUG8mBQbHhoNpPVXyu?= =?us-ascii?Q?Av2/+jh2tnRRjdgb6x34zbfG77QCl6Cvmq+3j3B1Wed+iSLFfKQVP2r5s5ju?= =?us-ascii?Q?wQy+4U2Sey6w0XxYwRxcY/zFyJ03fXj5sQ6sMyGxwTNlZr3mcGaW0QLlBhND?= =?us-ascii?Q?BL9dwRfycPWE3mYe6n2cU2x6Zf4nGsaksOCm8fYoMbrRymDgxVnk49r6ikke?= =?us-ascii?Q?6FvfFtTtbvGdsWRcrwGDCtuDVMWnqtoJtSqLeirkj1QvhGu5mOtfD6MqU5G6?= =?us-ascii?Q?PtwDnjzz2Uw1II5TAlzY/a4cK2XlOXg4VN+ljfBahqYfRsIBTyvXwslHLY3I?= =?us-ascii?Q?KYbJMsVAEse5Cw4C+hRI8Erl5HonbNuvgwM/nQX7652Af7JJjXViK5e/41V+?= =?us-ascii?Q?mgTeOp0ZNpWfV8C3dU0dzD7NgeQsjUkJkeFuKiAwS+iQkhxW/lbWQ=3D=3D?= X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1;CY4PR11MB1864;6:5ZN2cEDv228Lz3Vc9A4dCQnHNpdthtdk25gChZHxlu?= =?us-ascii?Q?h6RuBs107s5DULXz++e2CWF8ITgGv7PySg5iw0W3RHzXJs1SECKXoeTHWzIQ?= =?us-ascii?Q?bU0H99xuNWA8hrMIgo1pxl6zRbrN4lU4JCUvyjes9Jnds8xF3tzXKJlbdGhc?= =?us-ascii?Q?BKWu4y0OCDwPUALmxV97ZXZT7kBEq2qFJYbAp1fxE38T9rkFxdB3CwD/ZAQI?= =?us-ascii?Q?9sjCux+HAzHlr45xtUR/O6FUGD45W5ax2shKsWHI8ExNejpLuLWajcG0UOeV?= =?us-ascii?Q?Da3oFl2JGlp45uUAmBSpb0sc6TwfkX2ZKTFxoKm1qYXVahlwYAqIXY9doM9i?= =?us-ascii?Q?eNvrPJq1/5McycdNpIA8HTM59HRUGypwgposU/6LoEb7b/94og9Djo9OMhJp?= =?us-ascii?Q?SvmjONJBe223rpf45uvz9lwEPY8uspLztejvZORUiKXia0DFqtWLPJvdABQE?= =?us-ascii?Q?SfKNEvPQPKSNLKGAJF3m82OKAloxSlI9KsAC59y5lVXEu1OeF+D+WHQBGSwz?= =?us-ascii?Q?yNeEVYipmH+G8WD1y6FIYfOy9VVuRmy/I6iXIjXpQjylguqags1295dZaD6i?= =?us-ascii?Q?QeBXdGZRaczHQ5bGEDtLx1GwXSQZa+ai/I6xe8aEA7up0UlnFRNRQ8G/cKTQ?= =?us-ascii?Q?SCsMWyv7dsLrQRkYYXLBcathrK2gelRi6a0N9RgqvEbj4U/u2IYWYGiXMjN+?= =?us-ascii?Q?GYawj73osUdDsTmFezGpMlZ+hmm7abgr7ubWoe1L63xWCdcfmZtRCLpZ7hGW?= =?us-ascii?Q?MsSHmMs7TRr2lqB9AJwP5izIsWt/eGSjFwyQV0LiQzJrN2DTaksG4Rmcb2/T?= =?us-ascii?Q?17JRBR5uRfm74QFLW/jpi1CZEoRjJt+fmNemSHIgvj6CNKKUS6yE4iB/HH9c?= =?us-ascii?Q?oI1psUc2KKibzG8iqfZRkCIbBODyJh0py0Kb/Vi/DLmZmFyB6TlKLoJWJsXV?= =?us-ascii?Q?OkWe868KVikOr/gj+F3ralfke49ddUPiVt6vjp+lUHZNXlwMbxFNBDw9Rf3L?= =?us-ascii?Q?/ya+FpDVPQ60XV8J8FvWC4?= X-Microsoft-Exchange-Diagnostics: 1;CY4PR11MB1864;5:E713vOH/z2NY9x/+khcnydfsRcTt0MmdsuSE8r4jYWG71JbWs3ukye7zye0nfZK6u27JJ/mimj4Ym48W2eZrEb01MZcIc/PEdihMrgJHKFwSxmD362FHdXe90x+bEwZ6MJXOmxK/Er/mUXXWzyRQKQsSZRZs1zVAMCs/KQX1AB+cQPRSP1BCE9RI8A7Ea/Nvn4TNs6QAu6zGBlYJ8PEiJbcv59PI79YhGXUXGxfQj+WsDoTckuM8fAS44B+e0ZLsKDPVkSZS580T+CGZVgk3JEd10tJVPajhFTRVSqSLEzxvYwULBjiUYX4Bx3xMcaib6Jmor/btu9kZiEhMoLUAV5FBFmUEnp7D7sE2ysoEp43PcgwxfpaG3dZ1BgwOrZQjFcXFozlSRRzKMW4Ktbpo8wBfRGvo46S/6o50YN85LIREAwaq/WRflUKxUC8nxz/SoJu5XdNZIliKd8Ihr++wiYwm80JG3NSMezFOe/vQKalu3ptvtIK9kyIITuOOyQ2O;24:tmMJE75/xCeMNsIM8jg/AXWlSuSSJCiQXQS+UA/H9nF/9+GVs3RPgTZEPy/58Oe9c3kOFgQ8dlPeVpdoA13uQOKinCepD6j7A3vBCW9RP4E= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1;CY4PR11MB1864;7:5fuQEzsOplx7pm8jnbVQg8PenOVikLSLwbMsJZ/p0SuQw0iOxKgbVRQEcvTDcNouzO701qDGIKihkXf3VWdzGMbnKQsZvzcRrhAtedBerIEqaCxZRvN9NmDKAFsnjS+3qO+HGaOUQ1Sj+9hLtai4/6q24mT3qRf6czECDgLwjs2CpnCFsI2SqkaQ40JnNUiZELQ4tgS9Ricb2nuYaivwLVWJAvC6JnJ+TzZ7ovYXKZ1fP3++DlHt7L4inY8iHX5I3O0v8kcLC1iGiv6w80B3PCkyClgD2SsOQvdne+uhuaOQfdGCOsyWMdk9tcAgCm4IBXE/48Bk5500L4weFQIcI2aodHcz5lIdK21Yi1m6RF/H8AOWPBIu+fH/N7FILwOC8QPdi2AdNSZramJlitKutbNtobdkGlFm8XmhisE/zkMLqBANrEh0qdhf3dxpMxWrCsOWbZ+Qgs0rtzZ4LkJ2+63M+AlqkrM1vq/9NzhTQct2XDBYQ7ks/JRspqglZ71fWvop53qJBiWYnUNmg6cIbGz1Q0EO577Tej4Uturj9L1A/ROkGSAqv+0OPkeT0JWv0xOlMHOnvnQYgf0lzTLnsTDo3Jv9Q6f0Aga8sNwDhHB8BmPlH/DKX88B+GjMIvoTjC1Cv7Sdk6yW/IUI44lXGQ/23BqjBerWiUY98PjaBze2ljjK0j9qrYCV7RqrFjR5EnqGgTK/YLphn1oCzkxOudJPfm92mME33gEKxGPqlZUxvsJdQwIYUPAo1d9p9plvGrQY1RzmbjbIHFv4hSUlOd4Rbt/l7dC7kw5G4HbF72c= X-OriginatorOrg: maximintegrated.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 23 Jun 2017 23:04:26.8058 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-Transport-CrossTenantHeadersStamped: CY4PR11MB1864 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: "Ismail H. Kose" Add iio driver for DS4422/DS4424 chips that support two/four channel 7-bit Sink/Source Current DAC. The driver supports device tree and platfrom files for the configurations. Datasheet publicly available at: https://datasheets.maximintegrated.com/en/ds/DS4422-DS4424.pdf Signed-off-by: Ismail Kose --- .../devicetree/bindings/iio/dac/ds4424.txt | 41 ++ drivers/iio/dac/Kconfig | 9 + drivers/iio/dac/Makefile | 1 + drivers/iio/dac/ds4424.c | 733 +++++++++++++++++++++ include/linux/iio/dac/ds4424.h | 29 + 5 files changed, 813 insertions(+) create mode 100644 Documentation/devicetree/bindings/iio/dac/ds4424.txt create mode 100644 drivers/iio/dac/ds4424.c create mode 100644 include/linux/iio/dac/ds4424.h diff --git a/Documentation/devicetree/bindings/iio/dac/ds4424.txt b/Documentation/devicetree/bindings/iio/dac/ds4424.txt new file mode 100644 index 000000000000..03c1b575a6db --- /dev/null +++ b/Documentation/devicetree/bindings/iio/dac/ds4424.txt @@ -0,0 +1,41 @@ +Maxim Integrated DS4422/DS4424 DAC device driver + +Required properties: + - compatible: Must be "maxim,ds4422" or "maxim,ds4424" + - reg: Should contain the DAC I2C address + - min_rfs, max_rfs: In order to get the correct processed data values, + these resistor values should be changed to the correct values + that match the user's system resistor values for RFS0 to RFS1. + Resistance values for rfs_resistor are listed in 100 Ohm units; + ie, 800 is 80K. Acceptable RFS values are 40K to 160K. + - ifs_scale: 61000*100 = 6100000 = 100,000,000 * .976/16 + - max_picoamp: Should contain DAC maximum pico amper value. + - rfs_resistor: Should contain reference resistor + - iio map: Should contain IIO Map info + +Optional properties: + - vcc-supply: Power supply us optional. If not defined, driver will ignore it. + +Example: + ds4224@10 { + compatible = "maxim,ds4424"; + reg = <0x10>; /* When A0, A1 pins are ground */ + vcc-supply = "dac_vcc_3v3"; + max-picoamp = <200000000>; /* 200uA */ + ifs-scale = <61000>; + /* In order to get the correct processed data values, + these resistor values should be changed to the correct values that match the + user's system resistor values for RFS0 to RFS1. + Resistance values for rfs_resistor are listed in 100 Ohm units; + ie, 800 is 80K. Acceptable RFS values are 40K to 160K. + */ + min-rfs = <400>; + max-rfs = <1600>; + rfs-resistors = <400 800 1000 1600>; + dac-iio-map = + /* consumer_dev_name, consumer_channel, adc_channel_label */ + "ds4424_dac-consumer-dev_name-1", "ds4424_dac1", "OUT1", + "ds4424_dac-consumer-dev_name-2", "ds4424_dac2", "OUT2", + "ds4424_dac-consumer-dev_name-3", "ds4424_dac3", "OUT3", + "ds4424_dac-consumer-dev_name-4", "ds4424_dac4", "OUT4"; + }; diff --git a/drivers/iio/dac/Kconfig b/drivers/iio/dac/Kconfig index df5abc46cd3f..6f569c0ac88a 100644 --- a/drivers/iio/dac/Kconfig +++ b/drivers/iio/dac/Kconfig @@ -309,4 +309,13 @@ config VF610_DAC This driver can also be built as a module. If so, the module will be called vf610_dac. +config DAC_DS4424 + tristate "Maxim Integrated DS4422/DS4424 DAC driver" + depends on I2C + help + If you say yes here you get support for Maxim chip DS4422, DS4424. + + This driver can also be built as a module. If so, the module + will be called DAC_DS4424. + endmenu diff --git a/drivers/iio/dac/Makefile b/drivers/iio/dac/Makefile index 603587cc2f07..fa77510a5538 100644 --- a/drivers/iio/dac/Makefile +++ b/drivers/iio/dac/Makefile @@ -33,3 +33,4 @@ obj-$(CONFIG_MCP4922) += mcp4922.o obj-$(CONFIG_STM32_DAC_CORE) += stm32-dac-core.o obj-$(CONFIG_STM32_DAC) += stm32-dac.o obj-$(CONFIG_VF610_DAC) += vf610_dac.o +obj-$(CONFIG_DAC_DS4424) += ds4424.o diff --git a/drivers/iio/dac/ds4424.c b/drivers/iio/dac/ds4424.c new file mode 100644 index 000000000000..d13590a00c79 --- /dev/null +++ b/drivers/iio/dac/ds4424.c @@ -0,0 +1,733 @@ +/* + * Maxim Integrated + * 7-bit, Multi-Channel Sink/Source Current DAC Driver + * Copyright (C) 2017 Maxim Integrated + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DS4424_DAC_ADDR(chan) ((chan) + 0xf8) +#define SOURCE_I 1 +#define SINK_I 0 + +#define PWR_ON true +#define PWR_OFF false + +#define DS4424_CHANNEL(chan) { \ + .type = IIO_CURRENT, \ + .indexed = 1, \ + .output = 1, \ + .channel = chan, \ + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ + BIT(IIO_CHAN_INFO_PROCESSED) | \ + BIT(IIO_CHAN_INFO_SCALE),\ + .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET), \ + .address = DS4424_DAC_ADDR(chan), \ + .scan_type = { \ + .sign = 'u', \ + .realbits = 8, \ + .storagebits = 8, \ + .shift = 0, \ + }, \ +} + +union raw_data { + struct { + u8 dx:7; + u8 source_bit:1; /* 1 is source, 0 is sink */ + }; + u8 bits; +}; + +enum ds4424_device_ids { + ID_DS4422, + ID_DS4424, +}; + +struct ds4424_data { + struct i2c_client *client; + struct mutex lock; + uint16_t raw[DS442X_MAX_DAC_CHANNELS]; +#ifdef CONFIG_PM_SLEEP + uint16_t save[DS442X_MAX_DAC_CHANNELS]; +#endif + uint32_t max_rfs; + uint32_t min_rfs; + uint32_t ifs_scale; + uint32_t max_picoamp; + uint32_t rfs_res[DS442X_MAX_DAC_CHANNELS]; + struct iio_map dac_iio_map[DS442X_MAX_DAC_CHANNELS + 1]; + struct regulator *vcc_reg; + const char *vcc_reg_name; + bool regulator_state; +}; + +static const struct ds4424_pdata ds4424_pdata_default = { + /* .vcc_supply_name = "dac_vdd_3v3", */ + .min_rfs = 400, + .max_rfs = 1600, + .ifs_scale = 61000, /* 61000*100 = 6100000 = 100,000,000 * .976/16 */ + .max_picoamp = 200000000, + .rfs_res = {400, 800, 1000, 1600}, + .dac_iio_map = { + { .consumer_dev_name = "ds4424_dac-consumer-dev_name-1", + .consumer_channel = "ds4424_dac1", + .adc_channel_label = "OUT1" + }, + { + .consumer_dev_name = "ds4424_dac-consumer-dev_name-2", + .consumer_channel = "ds4424_dac2", + .adc_channel_label = "OUT2" + }, + { + .consumer_dev_name = "ds4424_dac-consumer-dev_name-3", + .consumer_channel = "ds4424_dac3", + .adc_channel_label = "OUT3" + }, + { + .consumer_dev_name = "ds4424_dac-consumer-dev_name-4", + .consumer_channel = "ds4424_dac4", + .adc_channel_label = "OUT4" + }, + {}, + }, +}; + +static const struct iio_chan_spec ds4424_channels[] = { + DS4424_CHANNEL(0), + DS4424_CHANNEL(1), + DS4424_CHANNEL(2), + DS4424_CHANNEL(3) +}; + +int ds4424_regulator_onoff(struct iio_dev *indio_dev, bool enable) +{ + struct ds4424_data *data = iio_priv(indio_dev); + int ret = 0; + + if (data->vcc_reg == NULL) + return ret; + + if (data->regulator_state == PWR_OFF && enable == PWR_ON) { + ret = regulator_enable(data->vcc_reg); + if (ret) { + pr_err("%s - enable vcc_reg failed, ret=%d\n", + __func__, ret); + goto done; + } + } else if (data->regulator_state == PWR_ON && enable == PWR_OFF) { + ret = regulator_disable(data->vcc_reg); + if (ret) { + pr_err("%s - disable vcc_reg failed, ret=%d\n", + __func__, ret); + goto done; + } + } + + data->regulator_state = enable; +done: + return ret; +} + +static int ds4424_get_value(struct iio_dev *indio_dev, + int *val, int channel) +{ + struct ds4424_data *data = iio_priv(indio_dev); + struct i2c_client *client = data->client; + u8 outbuf[1]; + u8 inbuf[1]; + int ret; + + if ((channel < 0) && (channel >= indio_dev->num_channels)) + return -EINVAL; + + outbuf[0] = DS4424_DAC_ADDR(channel); + mutex_lock(&data->lock); + ret = i2c_master_send(client, outbuf, 1); + if (ret < 0) { + mutex_unlock(&data->lock); + return ret; + } else if (ret != 1) { + mutex_unlock(&data->lock); + return -EIO; + } + + ret = i2c_master_recv(client, inbuf, 1); + if (ret < 0) { + mutex_unlock(&data->lock); + return ret; + } else if (ret != 1) { + mutex_unlock(&data->lock); + return -EIO; + } + + mutex_unlock(&data->lock); + + *val = inbuf[0]; + return 0; +} + +/* + * DS4432 DAC control register 8 bits + * [7] 0: to sink; 1: to source + * [6:0] steps to sink/source + * bit[7] looks like a sign bit, but the value of the register is + * not a complemental code considering the bit[6:0] is a absolute + * distance from the zero point. + */ + +/* + * val is positive if sourcing + * val is negative if sinking + * val can be -127 to 127 + */ +static int ds4424_set_value(struct iio_dev *indio_dev, + int val, struct iio_chan_spec const *chan) +{ + struct ds4424_data *data = iio_priv(indio_dev); + struct i2c_client *client = data->client; + u8 outbuf[2]; + int ret; + int max_val = ((1 << chan->scan_type.realbits) - 1); + + if (val < 0 || val > max_val) + return -EINVAL; + + if ((chan->channel < 0) + && (chan->channel >= indio_dev->num_channels)) + return -EINVAL; + + outbuf[0] = DS4424_DAC_ADDR(chan->channel); + outbuf[1] = (val & 0xff); + + mutex_lock(&data->lock); + ret = i2c_master_send(client, outbuf, ARRAY_SIZE(outbuf)); + mutex_unlock(&data->lock); + + if (ret < 0) + return ret; + else if (ret >= 0 && ret != ARRAY_SIZE(outbuf)) + return -EIO; + + data->raw[chan->channel] = outbuf[1]; + return 0; +} + +static int ds4424_read_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int *val, int *val2, long mask) +{ + union raw_data raw; + int round_up, ret; + struct ds4424_data *data = iio_priv(indio_dev); + + switch (mask) { + case IIO_CHAN_INFO_RAW: + /* Raw is processed a little bit + * outputs positive values for sourcing + * and negative values for sinking + */ + ret = ds4424_get_value(indio_dev, val, chan->channel); + if (ret < 0) { + pr_err("%s : ds4424_get_value returned %d\n", + __func__, ret); + return ret; + } + raw.bits = *val; + *val = raw.dx; + if (raw.source_bit == SINK_I) + *val = -*val; + return IIO_VAL_INT; + + case IIO_CHAN_INFO_PROCESSED: + /** + * To get the processed current using the 8-bit raw data: + * bit 7 is a 1 if sourcing current and it's a 0 if sinking + * current. + * The current full scale (Ifs) depends on the Rfs resistor + * value in ohms: + * Ifs = (0.976/Rfs)*(127/16) + * Then the current sourced or sinked can be determined as + * follows: + * I = Ifs * (Dx/127) + * where Dx is the value of the seven bits 6 to 0. + */ + if (data->rfs_res[chan->channel] < data->min_rfs || + data->rfs_res[chan->channel] > data->max_rfs) { + pr_err("%s : rfs_res out of range. rfs_res[%d]: %d\n", + __func__, + chan->channel, + data->rfs_res[chan->channel]); + return -EINVAL; + } + + ret = ds4424_get_value(indio_dev, val, chan->channel); + if (ret < 0) { + pr_err("%s : ds4424_get_value returned %d\n", + __func__, ret); + return ret; + } + raw.bits = *val; + *val = data->ifs_scale * raw.dx * 100; + round_up = data->rfs_res[chan->channel] / 2; + *val = (*val + round_up) / data->rfs_res[chan->channel]; + + if (raw.source_bit == SINK_I) + *val = -*val; + *val = *val * 100; /* picoAmps */ + return IIO_VAL_INT; + + case IIO_CHAN_INFO_SCALE: + round_up = data->rfs_res[chan->channel] / 2; + /* picoAmps */ + *val = (data->ifs_scale * 10000 + round_up) / + data->rfs_res[chan->channel]; + return IIO_VAL_INT; + + case IIO_CHAN_INFO_OFFSET: + *val = 0; + return IIO_VAL_INT; + default: + return -EINVAL; + } +} + +/** + * val is positive if sourcing + * val is negative if sinking + */ +static int ds4424_write_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int val, int val2, long mask) +{ + union raw_data raw; + struct ds4424_data *data = iio_priv(indio_dev); + int val0, max_val, min_val, tmp_scale; + + if (val2 != 0) + return -EINVAL; + + switch (mask) { + case IIO_CHAN_INFO_RAW: + + max_val = ((1 << chan->scan_type.realbits)/2) - 1; + min_val = -max_val; + if ((val > max_val) || (val < min_val)) + return -EINVAL; + + if (val > 0) { + raw.source_bit = SOURCE_I; + raw.dx = val; + } else { + raw.source_bit = SINK_I; + raw.dx = -val; + } + + return ds4424_set_value(indio_dev, raw.bits, chan); + + case IIO_CHAN_INFO_PROCESSED: /* val input is picoAmps */ + /* val can be 0 to 200,000,000 (200 picoAmps) */ + val0 = val; + raw.source_bit = SOURCE_I; + if (val < 0) { + raw.source_bit = SINK_I; + val = -val; + } + if (val > data->max_picoamp) { + pr_err("%s : Requested current %d ", __func__, val); + pr_err("exceeds %d picoAmps\n", data->max_picoamp); + return -EINVAL; + } + if (data->rfs_res[chan->channel] < data->min_rfs || + data->rfs_res[chan->channel] > data->max_rfs) { + pr_info("%s : Resistor values out of range\n", + __func__); + return -EINVAL; + } + val = val / 1000; + tmp_scale = data->ifs_scale / 10; /* preserve resolution */ + val = (val * data->rfs_res[chan->channel]) / + tmp_scale; + val = (val + 50) / 100; + val2 = ((1 << chan->scan_type.realbits) / 2) - 1; + if (val > val2) { + pr_info("%s : Requested current %d %d", + __func__, val0, val); + pr_info("exceeds maximum. DAC set to maximum %d\n", + val2); + val = val2; + } + raw.dx = val; + return ds4424_set_value(indio_dev, raw.bits, chan); + + default: + return -EINVAL; + } +} + +static int ds4424_verify_chip(struct iio_dev *indio_dev) +{ + int ret = 0, val; + int i; + + usleep_range(1000, 1200); + for (i = 0; i < indio_dev->num_channels; i++) { + ret = ds4424_get_value(indio_dev, &val, i); + if (ret < 0) { + pr_err("%s : read %d, should be 0\n", __func__, ret); + break; + } + } + return ret; +} + +#ifdef CONFIG_PM_SLEEP +static int ds4424_suspend(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct iio_dev *indio_dev = i2c_get_clientdata(client); + struct ds4424_data *data = iio_priv(indio_dev); + int ret = 0; + u32 i; + + for (i = 0; i < indio_dev->num_channels; i++) { + data->save[i] = data->raw[i]; + ret = ds4424_set_value(indio_dev, 0, + &(indio_dev->channels[i])); + if (ret < 0) + return ret; + } + return ret; +} + +static int ds4424_resume(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct iio_dev *indio_dev = i2c_get_clientdata(client); + struct ds4424_data *data = iio_priv(indio_dev); + int ret = 0; + u32 i; + + for (i = 0; i < indio_dev->num_channels; i++) { + ret = ds4424_set_value(indio_dev, data->save[i], + &(indio_dev->channels[i])); + if (ret < 0) + return ret; + } + return ret; +} + +static SIMPLE_DEV_PM_OPS(ds4424_pm_ops, ds4424_suspend, ds4424_resume); +#define DS4424_PM_OPS (&ds4424_pm_ops) +#else +#define DS4424_PM_OPS NULL +#endif /* CONFIG_PM_SLEEP */ + +static const struct iio_info ds4424_info = { + .read_raw = ds4424_read_raw, + .write_raw = ds4424_write_raw, + .driver_module = THIS_MODULE, +}; + +#ifdef CONFIG_OF +static int ds4424_parse_dt(struct iio_dev *indio_dev) +{ + int ret; + int len; + int num_ch; + int i; + int count; + struct property *prop; + struct ds4424_data *data = iio_priv(indio_dev); + struct device_node *node = indio_dev->dev.parent->of_node; + + if (!node) { + pr_info("%s:%d ds4424 dts not found\n", __func__, __LINE__); + return -ENODEV; + } + + prop = of_find_property(node, "rfs-resistors", &len); + if (!prop) { + pr_err("Invalid rfs-resistor in dt. len: %d\n", len); + return -EINVAL; + } + + if (len != (DS442X_MAX_DAC_CHANNELS * sizeof(uint32_t))) { + pr_err("Invalid rfs-resistor length in dt. len: %d\n", len); + return -EINVAL; + } + + ret = of_property_read_u32_array(node, "rfs-resistors", + data->rfs_res, DS442X_MAX_DAC_CHANNELS); + if (ret < 0) { + pr_err("Reading rfs-resistors from dt failed. ret: %d\n", ret); + return ret; + } + + pr_info("ds4424 rfs-resistors: %d, %d, %d, %d\n", + data->rfs_res[0], data->rfs_res[1], + data->rfs_res[2], data->rfs_res[3]); + + ret = of_property_read_u32(node, "max-rfs", + &data->max_rfs); + if (ret < 0) { + pr_err("Reading max-rfs from dt failed. ret: %d\n", ret); + return ret; + } + + ret = of_property_read_u32(node, "min-rfs", + (u32 *)&data->min_rfs); + if (ret < 0) { + pr_err("Reading min-rfs from dt failed. ret: %d\n", ret); + return ret; + } + + pr_info("ds4424 max-rfs: %d, min-rfs: %d\n", + data->max_rfs, data->min_rfs); + + ret = of_property_read_u32(node, "max-picoamp", + (u32 *)&data->max_picoamp); + if (ret < 0) { + pr_err("Reading max-picoamp from dt failed. ret: %d\n", ret); + return ret; + } + + ret = of_property_read_u32(node, "ifs-scale", + (u32 *)&data->ifs_scale); + if (ret < 0) { + pr_err("Reading ifs-scale from dt failed. ret: %d\n", ret); + return ret; + } + + pr_info("ds4424 max-picoamp: %d, ifs-scale: %d\n", + data->max_picoamp, data->ifs_scale); + + count = of_property_count_strings(node, "dac-iio-map"); + if (count < 0) { + pr_info("dac-iio-map not found in dts\n"); + return count; + } + + ret = of_property_read_string(node, "vcc-supply", &data->vcc_reg_name); + if (ret < 0) { + pr_info("DAC vcc-supply is not available in dts\n"); + data->vcc_reg_name = NULL; + } + + if (count != DS4424_MAX_DAC_CHANNELS * 3 && + count != DS4424_MAX_DAC_CHANNELS * 3) { + pr_info("Incorrect dac-iio-map in dts. count: %d\n", count); + return -EINVAL; + } + + num_ch = count / 3; + for (i = 0; i < num_ch; i++) { + ret = of_property_read_string_index(node, + "dac-iio-map", i * 3, + &data->dac_iio_map[i].consumer_dev_name); + if (ret < 0) { + pr_info("%s:%d\n", __func__, __LINE__); + return ret; + } + + ret = of_property_read_string_index(node, "dac-iio-map", + i * 3 + 1, + &data->dac_iio_map[i].consumer_channel); + if (ret < 0) { + pr_info("%s:%d\n", __func__, __LINE__); + return ret; + } + + ret = of_property_read_string_index(node, "dac-iio-map", + i * 3 + 2, + &data->dac_iio_map[i].adc_channel_label); + if (ret < 0) { + pr_info("%s:%d\n", __func__, __LINE__); + return ret; + } + + pr_info("ds4424 iio-map[%d]: %s, %s, %s\n", i, + data->dac_iio_map[i].consumer_dev_name, + data->dac_iio_map[i].consumer_channel, + data->dac_iio_map[i].adc_channel_label); + } + + return 0; +} +#else +static int ds4424_parse_dt(struct iio_dev *indio_dev) +{ + return -ENODEV; +} +#endif + +static int ds4424_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + const struct ds4424_pdata *pdata; + struct ds4424_data *data; + struct iio_dev *indio_dev; + int ret; + + if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { + dev_err(&client->dev, "I2C is not supported\n"); + return -ENODEV; + } + + indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); + if (!indio_dev) { + pr_err("%s:%d\n", __func__, __LINE__); + return -ENOMEM; + } + + data = iio_priv(indio_dev); + memset(data, 0, sizeof(*data)); + i2c_set_clientdata(client, indio_dev); + data->client = client; + indio_dev->name = id->name; + indio_dev->dev.parent = &client->dev; + + ret = ds4424_verify_chip(indio_dev); + if (ret < 0) { + dev_err(&client->dev, "%s failed. ret:%d\n", __func__, ret); + return -ENXIO; + } + + if (client->dev.of_node) { + ret = ds4424_parse_dt(indio_dev); + if (ret < 0) { + dev_err(&client->dev, + "%s - of_node error\n", __func__); + ret = -EINVAL; + } + } else { + pdata = client->dev.platform_data; + if (!pdata) { + dev_err(&client->dev, + "dts/platform data not found.\n"); + /* Use default driver settings */ + pdata = &ds4424_pdata_default; + } + + pdata = client->dev.platform_data; + data->min_rfs = pdata->min_rfs; + data->max_rfs = pdata->max_rfs; + data->ifs_scale = pdata->ifs_scale; + data->max_picoamp = pdata->max_picoamp; + data->vcc_reg_name = pdata->vcc_supply_name; + memcpy(data->rfs_res, pdata->rfs_res, + sizeof(uint32_t) * DS442X_MAX_DAC_CHANNELS); + memcpy(data->dac_iio_map, pdata->dac_iio_map, + sizeof(struct iio_map) * DS442X_MAX_DAC_CHANNELS); + } + + if (data->vcc_reg_name) { + data->vcc_reg = devm_regulator_get(&client->dev, + data->vcc_reg_name); + if (IS_ERR(data->vcc_reg)) { + ret = PTR_ERR(data->vcc_reg); + dev_err(&client->dev, + "Failed to get vcc_reg regulator: %d\n", ret); + return ret; + } + } + + mutex_init(&data->lock); + ret = ds4424_regulator_onoff(indio_dev, PWR_ON); + if (ret < 0) { + pr_err("Unable to turn on the regulator. %s:%d, ret: %d\n", + __func__, __LINE__, ret); + return ret; + } + + switch (id->driver_data) { + case ID_DS4422: + indio_dev->num_channels = DS4422_MAX_DAC_CHANNELS; + break; + case ID_DS4424: + indio_dev->num_channels = DS4424_MAX_DAC_CHANNELS; + break; + default: + indio_dev->num_channels = DS4424_MAX_DAC_CHANNELS; + break; + } + + indio_dev->channels = ds4424_channels; + indio_dev->modes = INDIO_DIRECT_MODE; + indio_dev->info = &ds4424_info; + + ret = iio_map_array_register(indio_dev, data->dac_iio_map); + if (ret < 0) + goto err_iio_device_0; + + ret = iio_device_register(indio_dev); + if (ret < 0) { + pr_err("iio_device_register failed . %s:%d, ret: %d\n", + __func__, __LINE__, ret); + goto err_iio_device_1; + } + + return ret; + +err_iio_device_0: + ds4424_regulator_onoff(indio_dev, PWR_OFF); +err_iio_device_1: + iio_map_array_unregister(indio_dev); + return ret; +} + +static int ds4424_remove(struct i2c_client *client) +{ + struct iio_dev *indio_dev = i2c_get_clientdata(client); + + iio_device_unregister(indio_dev); + iio_map_array_unregister(indio_dev); + ds4424_regulator_onoff(indio_dev, PWR_OFF); + return 0; +} + +static const struct i2c_device_id ds4424_id[] = { + { "ds4422", ID_DS4422 }, + { "ds4424", ID_DS4424 }, + { } +}; +MODULE_DEVICE_TABLE(i2c, ds4424_id); + +static const struct of_device_id ds4424_of_match[] = { + { .compatible = "maxim,ds4422" }, + { .compatible = "maxim,ds4424" }, + { } +}; + +MODULE_DEVICE_TABLE(of, ds4424_of_match); + +static struct i2c_driver ds4424_driver = { + .driver = { + .name = "ds4424", + .pm = DS4424_PM_OPS, + }, + .probe = ds4424_probe, + .remove = ds4424_remove, + .id_table = ds4424_id, +}; +module_i2c_driver(ds4424_driver); + +MODULE_DESCRIPTION("Maxim DS4424 DAC Driver"); +MODULE_AUTHOR("Ismail H. Kose "); +MODULE_AUTHOR("Vishal Sood "); +MODULE_AUTHOR("David Jung "); +MODULE_LICENSE("GPL v2"); diff --git a/include/linux/iio/dac/ds4424.h b/include/linux/iio/dac/ds4424.h new file mode 100644 index 000000000000..09ff3d61797d --- /dev/null +++ b/include/linux/iio/dac/ds4424.h @@ -0,0 +1,29 @@ +/* + * Maxim Integrated + * 7-bit, Multi-Channel Sink/Source Current DAC Driver + * Copyright (C) 2017 Maxim Integrated + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#ifndef IIO_DAC_DS4424_H_ +#define IIO_DAC_DS4424_H_ +#include +#include + +#define DS4422_MAX_DAC_CHANNELS 2 +#define DS4424_MAX_DAC_CHANNELS 4 +#define DS442X_MAX_DAC_CHANNELS DS4424_MAX_DAC_CHANNELS + +struct ds4424_pdata { + const char *vcc_supply_name; + uint32_t max_rfs; + uint32_t min_rfs; + uint32_t ifs_scale; + uint32_t max_picoamp; + uint32_t rfs_res[DS442X_MAX_DAC_CHANNELS]; + struct iio_map dac_iio_map[DS442X_MAX_DAC_CHANNELS + 1]; +}; +#endif /* IIO_DAC_DS4424_H_ */ -- 2.11.0