From patchwork Fri Aug 7 08:43:45 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Peng Fan X-Patchwork-Id: 505042 X-Patchwork-Delegate: p.marczak@samsung.com Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from theia.denx.de (theia.denx.de [85.214.87.163]) by ozlabs.org (Postfix) with ESMTP id 2D5F514029D for ; Fri, 7 Aug 2015 18:45:16 +1000 (AEST) Received: from localhost (localhost [127.0.0.1]) by theia.denx.de (Postfix) with ESMTP id E6E9D39BF; Fri, 7 Aug 2015 10:44:53 +0200 (CEST) Received: from theia.denx.de ([127.0.0.1]) by localhost (theia.denx.de [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id x4LsyLFsVi9x; Fri, 7 Aug 2015 10:44:53 +0200 (CEST) Received: from theia.denx.de (localhost [127.0.0.1]) by theia.denx.de (Postfix) with ESMTP id 845193A72; Fri, 7 Aug 2015 10:44:46 +0200 (CEST) Received: from localhost (localhost [127.0.0.1]) by theia.denx.de (Postfix) with ESMTP id 561513A63 for ; Fri, 7 Aug 2015 10:44:42 +0200 (CEST) Received: from theia.denx.de ([127.0.0.1]) by localhost (theia.denx.de [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id heOnG1wfLFT7 for ; Fri, 7 Aug 2015 10:44:42 +0200 (CEST) X-policyd-weight: NOT_IN_SBL_XBL_SPAMHAUS=-1.5 NOT_IN_SPAMCOP=-1.5 NOT_IN_BL_NJABL=-1.5 (only DNSBL check requested) Received: from na01-bn1-obe.outbound.protection.outlook.com (mail-bn1on0142.outbound.protection.outlook.com [157.56.110.142]) by theia.denx.de (Postfix) with ESMTPS id 228D03978 for ; Fri, 7 Aug 2015 10:44:29 +0200 (CEST) Received: from CO2PR03CA0026.namprd03.prod.outlook.com (10.141.194.153) by BY2PR0301MB0679.namprd03.prod.outlook.com (10.160.63.146) with Microsoft SMTP Server (TLS) id 15.1.225.19; Fri, 7 Aug 2015 08:44:26 +0000 Received: from BN1BFFO11FD054.protection.gbl (2a01:111:f400:7c10::1:171) by CO2PR03CA0026.outlook.office365.com (2a01:111:e400:1414::25) with Microsoft SMTP Server (TLS) id 15.1.225.19 via Frontend Transport; Fri, 7 Aug 2015 08:44:25 +0000 Authentication-Results: spf=fail (sender IP is 192.88.158.2) smtp.mailfrom=freescale.com; freescale.mail.onmicrosoft.com; dkim=none (message not signed) header.d=none; Received-SPF: Fail (protection.outlook.com: domain of freescale.com does not designate 192.88.158.2 as permitted sender) receiver=protection.outlook.com; client-ip=192.88.158.2; helo=az84smr01.freescale.net; Received: from az84smr01.freescale.net (192.88.158.2) by BN1BFFO11FD054.mail.protection.outlook.com (10.58.145.9) with Microsoft SMTP Server (TLS) id 15.1.243.9 via Frontend Transport; Fri, 7 Aug 2015 08:44:24 +0000 Received: from linux-jyl1.ap.freescale.net ([10.193.99.110]) by az84smr01.freescale.net (8.14.3/8.14.0) with ESMTP id t778hteU026998; Fri, 7 Aug 2015 01:44:21 -0700 From: Peng Fan To: , Date: Fri, 7 Aug 2015 16:43:45 +0800 Message-ID: <1438937026-8731-6-git-send-email-Peng.Fan@freescale.com> X-Mailer: git-send-email 1.8.4 In-Reply-To: <1438937026-8731-1-git-send-email-Peng.Fan@freescale.com> References: <1438937026-8731-1-git-send-email-Peng.Fan@freescale.com> X-EOPAttributedMessage: 0 X-Microsoft-Exchange-Diagnostics: 1; BN1BFFO11FD054; 1:I+YjUpnjoK8OKwXdm2TlP+ZE8CZbeHyUVY2jHteBlVemVO2R327CkqjMhsyUcMaWqaQ92xSRn6B+8iWZKMEG5Fo9cSiKTSlwn9uM2dgAqJtvFuZ+EWbUsHvcWISm2cYtN5e01OndXWbtvsBlRgwh2K7bsMIdwrfn5sB0mueu9u/Gb7QiUWmoidXQzVD6XEIgyUyWFA5yym6Nuu277UhZAjUmAe8ElwyX5mwnVS7yb7YNB3gGB8HWaZ8YqiqJRB6jTAYlnXGV9IR6iwDR+RnfcTM+nWeMlXs1WOog24kIYDEzYFsaBxfgnc8AokktI9fJfs7b8fTsEK4MgKC14Y/8kA== X-Forefront-Antispam-Report: CIP:192.88.158.2; CTRY:US; IPV:NLI; EFV:NLI; SFV:NSPM; SFS:(10019020)(6009001)(2980300002)(339900001)(189002)(199003)(5001860100001)(5001960100002)(4001540100001)(5003940100001)(19580405001)(81156007)(107886002)(6806004)(87936001)(86362001)(19580395003)(5001830100001)(46102003)(50466002)(48376002)(97736004)(189998001)(105606002)(5001770100001)(36756003)(106466001)(2950100001)(50226001)(77096005)(64706001)(76176999)(68736005)(47776003)(85426001)(69596002)(92566002)(77156002)(50986999)(62966003)(104016003)(229853001)(4001430100001)(473944003)(357404004); DIR:OUT; SFP:1102; SCL:1; SRVR:BY2PR0301MB0679; H:az84smr01.freescale.net; FPR:; SPF:Fail; PTR:InfoDomainNonexistent; MX:1; A:1; LANG:en; MIME-Version: 1.0 X-Microsoft-Exchange-Diagnostics: 1; BY2PR0301MB0679; 2:kuTgNmFfB/RTmNGJ8iJRngi7RHBZw9ykDEb4p/vmm5M5Slm2KD2j2zjyZkgvszLwG2D4HlrCR7ro1+ZVH4Urh4Pbz0mfn4Kiq4JcgPiExwicyaQcrCRoUr7gHCuoR4SAWP+IPH9KHKDk+5u/mUBaYitSGlh7wLviwZB0/sbzwko=; 3:SYJuAh2SbDAfdforaW8JyF2UK3oGga9M0Bk+2VT6PyYiC2skKojnbaSdIX2JozCB2a5JhUdm2+3b8Invzm3WQYWlEJCdBwo2TXSyIB4SdAz8tit3GqJ4S4/p5XWofETcniZKjLohyXaTzdk784mZ4Sac0nNZxyoOl4yyccxq7c1FD19EJMLALVnAzb3ge4009JHBK9Y/YETzV5oXOpUeQ9X8CHzNS3gnQoesz1kCjP8=; 25:lU6bAj9Hf9UkeBPKUgrPbgywfWgVY1K3nqqESqZQu/o3/z0uTm2Uwj5552amufbEfXIM6g5zUNlrSM7VNaVD4/ARXFqR7IlgUfxXnG1+lDriAMd1/PlIgSDBg/Kt6O3q9HLgSnvAvvsIEa1a8L31NQHdS3Xlcwi/e3zCSINmtKM5TNU5SMvE1ldP8sTXDn+Ofni3V0P5W1o//4x9VQbRJqx223i2WQsc3dY8LUZjJx7ZXjnvkAQ9gtc1OD1G1BSOjAGKKiQJ2yCANKQjdqw7sw== X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:BY2PR0301MB0679; X-Microsoft-Exchange-Diagnostics: 1; BY2PR0301MB0679; 20:rLBsgUhfh5hzE2wvZeJb+lp2vOb4QnhiDqMhp8eH2EoWlDncvfjKf8Juy/kaSBXAjofDuErvGhm6+ytlEQEnIBY/RD/Xt1NFHpKUfeBr1WSEYlzZ0YipvF2RAmdoFVFUy+kRXn/p4N3h3PgMjSsj4WYu3nuvxujqb43T0gBkpb8pZQNtRYl3nVDG5eRFcbJVGebb+P1TEtOJtx36TNq6FacyJcbpHElRIgIwDzbaxmfzsrkepPUqfyP+Cdxr7Y1bIyvHILeDj39xPAlj8G8cXtNZPca/F6pWklJEbfhn4zn5HYELKgGcCMoiymsXf8RJYrD57rdqxBUmNnsDBqER3IvwD7JRTgoRSAqNkkSpCow=; 4:G34wibi8TPyGOy+JKNO1q3YdW7o3e0ZF3Q/Vgs+WOyVcFKLyGmL/1HtfUzCoXyW7oTk1me6qvCK3Ni0c8lEk/YevLIv8D26ATCc1w0EWM52O7zLEazpHNiBqlrNgUDvj+jN3+kkyiovzFeJg3DF0/pMWlalWZkXyxnlrNRF3NC/MwyBi45lRJ8lqkAY8VND/weDMyZnDst8gf2cQnCqHfuBaOU2HJEt49aZH6Dico926Aif/0hMgj2FripwAqGWtvHrsPEmbNNlBQ6e1vG36vkpjeJ6uHgSrf28BEP8xx6M= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(601004)(5005006)(3002001); SRVR:BY2PR0301MB0679; BCL:0; PCL:0; RULEID:; SRVR:BY2PR0301MB0679; X-Forefront-PRVS: 066153096A X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BY2PR0301MB0679; 23:OBRyjjRtLy8hIK76i9BImrt0ZCJ14d3WpxlujZ6?= =?us-ascii?Q?QInhof/q4EKCZYEARUqWGrLUQFFpD1YEz8vsTXNCescWL5QGPWVE+z0iaKU7?= =?us-ascii?Q?x32RZvm6Mxc3IUwPCraGvgjU1FPojkLE/lKjXJITC2Hsr92YElH7Y4VOzthB?= =?us-ascii?Q?bEdFvW4Ui8XL1RJfgR0wEVwa0X/izi/zWirhN6NnoA46iD9AQb+0sbaRIFId?= =?us-ascii?Q?Yb8aMa7ec6OKOG0wINrT592kW2lGlvGtomfK6Zt2ffLOa9Af8tzvueVP9Bza?= =?us-ascii?Q?CcViDJ+N0f3U2aBj4fJSweNni42uHzmFJOLbplS3sXH2f1skDvcSDWxuGCiC?= =?us-ascii?Q?7RDNn9Mkumw8lt15cRAbZN2T/4jrnytG7ls4YNRGq7jj2JDdYEGHSBRFNc7Z?= =?us-ascii?Q?M0qgs+cg6G4ngOcYxeioM+ajySVmzmmH6Vo+i00BMI5ZPkVBTuIVlfpkHGKG?= =?us-ascii?Q?yGeYbCtV3LITmd/Ja1hheH6Mtjksro080LVDRiRozcDkHxVX2s0yVMqiFm1i?= =?us-ascii?Q?jsxOhlg1Ru75e9f1PBSgrwES/wkjuqLyVySDmVWBTOoJELjmT2b3WewS97sZ?= =?us-ascii?Q?dJETxI64sHJIwbsBwhvLA4JILhfd/TDLXynnqBmugy7FxGWFE8RQ4Ygx/uVu?= =?us-ascii?Q?7OJWPxITv7gCxXapvxsjPfiGIDj4md/Oz451J415KRSkdzpLzrvRBgVN7gZN?= =?us-ascii?Q?vGolPXuk8fryOBRlvddLnYFIXs8vxDiL0h0rQq3f/mkgmHnH0nj3lLzRAnSp?= =?us-ascii?Q?ja3jWvzDRJswQpgx1aGwVnGa6P11jqtwEojK7KO/HdxXoPKE7MWfYKaU70yP?= =?us-ascii?Q?PihrFjaovJuJmopm72MZvP5zvpvXlZmWu79xeXCB2w7e9qcOXM1g22KpZU6B?= =?us-ascii?Q?Y45TMiJOohWDMq7XAVU76JDTEI/pzOqRo0mh0B8JE6iYt/HdNEr7qx/RLerH?= =?us-ascii?Q?/bOAqJQUkiYjLuTvr3uNAuwkOFJOpZfEXc27vXINRBmRjk9iD5z4zhjGNuAS?= =?us-ascii?Q?+9iy+fJTHt5WLo05fvrGlDMfRg8dHDgRJzHmtWAuHESIl7/7A0N//BtJO7Kq?= =?us-ascii?Q?seXlLxCU1cuKGCCh1Cudag65GzoFh2jmZ3LYL6IDH6WLrAJqpwJE2AZnQnLi?= =?us-ascii?Q?nMmeGVKTHZYBc4oAruQxHy1KXuFqvQAADMv2K8cv2f7hJIN7GoYQBZ6yyc83?= =?us-ascii?Q?8D91cWMFqvk8uLiQ=3D?= X-Microsoft-Exchange-Diagnostics: 1; BY2PR0301MB0679; 5:ettIz/tc2yV3nj/o8drod3g0aliHAfC5wAgcwzVfK60SyPEOh1oZPxZuVzOwMhhVC6KHO9kDq9mA7SW+2s6DzioV7ayNiaLHn+akZ0YytgFe97ynHpFD1GoReApAMNpl67v0ulnfwdKn5uFNDbkAqA==; 24:Tniy95zDMoz4uFGgMByFOvnXCe/KmI3GfO9rFuOjaT0PH28doD8MGhlXDI/M6TsRfOFNSVCa8rZL9s+x9sCPe1ASpelIon+3I8hIYfjHIdQ=; 20:SUe3zDWaOSn0k3QJsPrRbyN+ywumwSiD2trfI5+CqM8x6YVZDN85qirwKfyyXh/3NnKbsxhByT7k0NILM46Csg== X-OriginatorOrg: freescale.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 07 Aug 2015 08:44:24.1760 (UTC) X-MS-Exchange-CrossTenant-Id: 710a03f5-10f6-4d38-9ff4-a80b81da590d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=710a03f5-10f6-4d38-9ff4-a80b81da590d; Ip=[192.88.158.2]; Helo=[az84smr01.freescale.net] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BY2PR0301MB0679 Cc: u-boot@lists.denx.de Subject: [U-Boot] [PATCH V3 5/6] power: regulator: add pfuze100 support X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.15 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" 1. Add new regulator driver pfuze100. * Introduce struct pfuze100_regulator_desc for maintaining info for one regulator. 2. Add new Kconfig entry DM_REGULATOR_PFUZE100 for pfuze100. 3. This driver intends to support PF100, PF200 and PF3000. 4. Add related macro definition in pfuze header file. Signed-off-by: Peng Fan Cc: Przemyslaw Marczak Cc: Simon Glass Acked-by: Simon Glass --- Changes v3: Discard the double pointer, using "struct pfuze100_regulator_platdata" following Simon's suggestion. Changes v2: Addressed Simon's comments. 1. Use pmic_reg_read/pmic_reg_write/pmic_clrsetbits 2. blank line between declarations and rest drivers/power/regulator/Kconfig | 8 + drivers/power/regulator/Makefile | 1 + drivers/power/regulator/pfuze100.c | 568 +++++++++++++++++++++++++++++++++++++ include/power/pfuze100_pmic.h | 24 +- 4 files changed, 597 insertions(+), 4 deletions(-) create mode 100644 drivers/power/regulator/pfuze100.c diff --git a/drivers/power/regulator/Kconfig b/drivers/power/regulator/Kconfig index 6289b83..b854773 100644 --- a/drivers/power/regulator/Kconfig +++ b/drivers/power/regulator/Kconfig @@ -16,6 +16,14 @@ config DM_REGULATOR for this purpose if PMIC I/O driver is implemented or dm_scan_fdt_node() otherwise. Detailed information can be found in the header file. +config DM_REGULATOR_PFUZE100 + bool "Enable Driver Model for REGULATOR PFUZE100" + depends on DM_REGULATOR && DM_PMIC_PFUZE100 + ---help--- + This config enables implementation of driver-model regulator uclass + features for REGULATOR PFUZE100. The driver implements get/set api for: + value, enable and mode. + config DM_REGULATOR_MAX77686 bool "Enable Driver Model for REGULATOR MAX77686" depends on DM_REGULATOR && DM_PMIC_MAX77686 diff --git a/drivers/power/regulator/Makefile b/drivers/power/regulator/Makefile index 96aa624..9f8f17b 100644 --- a/drivers/power/regulator/Makefile +++ b/drivers/power/regulator/Makefile @@ -7,5 +7,6 @@ obj-$(CONFIG_DM_REGULATOR) += regulator-uclass.o obj-$(CONFIG_DM_REGULATOR_MAX77686) += max77686.o +obj-$(CONFIG_DM_REGULATOR_PFUZE100) += pfuze100.o obj-$(CONFIG_DM_REGULATOR_FIXED) += fixed.o obj-$(CONFIG_DM_REGULATOR_SANDBOX) += sandbox.o diff --git a/drivers/power/regulator/pfuze100.c b/drivers/power/regulator/pfuze100.c new file mode 100644 index 0000000..4702161 --- /dev/null +++ b/drivers/power/regulator/pfuze100.c @@ -0,0 +1,568 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * struct pfuze100_regulator_desc - regulator descriptor + * + * @name: Identify name for the regulator. + * @type: Indicates the regulator type. + * @uV_step: Voltage increase for each selector. + * @vsel_reg: Register for adjust regulator voltage for normal. + * @vsel_mask: Mask bit for setting regulator voltage for normal. + * @stby_reg: Register for adjust regulator voltage for standby. + * @stby_mask: Mask bit for setting regulator voltage for standby. + * @volt_table: Voltage mapping table (if table based mapping). + * @voltage: Current voltage for REGULATOR_TYPE_FIXED type regulator. + */ +struct pfuze100_regulator_desc { + char *name; + enum regulator_type type; + unsigned int uV_step; + unsigned int vsel_reg; + unsigned int vsel_mask; + unsigned int stby_reg; + unsigned int stby_mask; + unsigned int *volt_table; + unsigned int voltage; +}; + +/** + * struct pfuze100_regulator_platdata - platform data for pfuze100 + * + * @desc: Points the description entry of one regulator of pfuze100 + */ +struct pfuze100_regulator_platdata { + struct pfuze100_regulator_desc *desc; +}; + +#define PFUZE100_FIXED_REG(_name, base, vol) \ + { \ + .name = #_name, \ + .type = REGULATOR_TYPE_FIXED, \ + .voltage = (vol), \ + } + +#define PFUZE100_SW_REG(_name, base, step) \ + { \ + .name = #_name, \ + .type = REGULATOR_TYPE_BUCK, \ + .uV_step = (step), \ + .vsel_reg = (base) + PFUZE100_VOL_OFFSET, \ + .vsel_mask = 0x3F, \ + .stby_reg = (base) + PFUZE100_STBY_OFFSET, \ + .stby_mask = 0x3F, \ + } + +#define PFUZE100_SWB_REG(_name, base, mask, step, voltages) \ + { \ + .name = #_name, \ + .type = REGULATOR_TYPE_BUCK, \ + .uV_step = (step), \ + .vsel_reg = (base), \ + .vsel_mask = (mask), \ + .volt_table = (voltages), \ + } + +#define PFUZE100_SNVS_REG(_name, base, mask, voltages) \ + { \ + .name = #_name, \ + .type = REGULATOR_TYPE_OTHER, \ + .vsel_reg = (base), \ + .vsel_mask = (mask), \ + .volt_table = (voltages), \ + } + +#define PFUZE100_VGEN_REG(_name, base, step) \ + { \ + .name = #_name, \ + .type = REGULATOR_TYPE_LDO, \ + .uV_step = (step), \ + .vsel_reg = (base), \ + .vsel_mask = 0xF, \ + .stby_reg = (base), \ + .stby_mask = 0x20, \ + } + +#define PFUZE3000_VCC_REG(_name, base, step) \ + { \ + .name = #_name, \ + .type = REGULATOR_TYPE_LDO, \ + .uV_step = (step), \ + .vsel_reg = (base), \ + .vsel_mask = 0x3, \ + .stby_reg = (base), \ + .stby_mask = 0x20, \ +} + +#define PFUZE3000_SW1_REG(_name, base, step) \ + { \ + .name = #_name, \ + .type = REGULATOR_TYPE_BUCK, \ + .uV_step = (step), \ + .vsel_reg = (base) + PFUZE100_VOL_OFFSET, \ + .vsel_mask = 0x1F, \ + .stby_reg = (base) + PFUZE100_STBY_OFFSET, \ + .stby_mask = 0x1F, \ + } + +#define PFUZE3000_SW2_REG(_name, base, step) \ + { \ + .name = #_name, \ + .type = REGULATOR_TYPE_BUCK, \ + .uV_step = (step), \ + .vsel_reg = (base) + PFUZE100_VOL_OFFSET, \ + .vsel_mask = 0x7, \ + .stby_reg = (base) + PFUZE100_STBY_OFFSET, \ + .stby_mask = 0x7, \ + } + +#define PFUZE3000_SW3_REG(_name, base, step) \ + { \ + .name = #_name, \ + .type = REGULATOR_TYPE_BUCK, \ + .uV_step = (step), \ + .vsel_reg = (base) + PFUZE100_VOL_OFFSET, \ + .vsel_mask = 0xF, \ + .stby_reg = (base) + PFUZE100_STBY_OFFSET, \ + .stby_mask = 0xF, \ + } + +static unsigned int pfuze100_swbst[] = { + 5000000, 5050000, 5100000, 5150000 +}; + +static unsigned int pfuze100_vsnvs[] = { + 1000000, 1100000, 1200000, 1300000, 1500000, 1800000, 3000000, -1 +}; + +static unsigned int pfuze3000_vsnvs[] = { + -1, -1, -1, -1, -1, -1, 3000000, -1 +}; + +static unsigned int pfuze3000_sw2lo[] = { + 1500000, 1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000 +}; + +/* PFUZE100 */ +static struct pfuze100_regulator_desc pfuze100_regulators[] = { + PFUZE100_SW_REG(sw1ab, PFUZE100_SW1ABVOL, 25000), + PFUZE100_SW_REG(sw1c, PFUZE100_SW1CVOL, 25000), + PFUZE100_SW_REG(sw2, PFUZE100_SW2VOL, 25000), + PFUZE100_SW_REG(sw3a, PFUZE100_SW3AVOL, 25000), + PFUZE100_SW_REG(sw3b, PFUZE100_SW3BVOL, 25000), + PFUZE100_SW_REG(sw4, PFUZE100_SW4VOL, 25000), + PFUZE100_SWB_REG(swbst, PFUZE100_SWBSTCON1, 0x3, 50000, pfuze100_swbst), + PFUZE100_SNVS_REG(vsnvs, PFUZE100_VSNVSVOL, 0x7, pfuze100_vsnvs), + PFUZE100_FIXED_REG(vrefddr, PFUZE100_VREFDDRCON, 750000), + PFUZE100_VGEN_REG(vgen1, PFUZE100_VGEN1VOL, 50000), + PFUZE100_VGEN_REG(vgen2, PFUZE100_VGEN2VOL, 50000), + PFUZE100_VGEN_REG(vgen3, PFUZE100_VGEN3VOL, 100000), + PFUZE100_VGEN_REG(vgen4, PFUZE100_VGEN4VOL, 100000), + PFUZE100_VGEN_REG(vgen5, PFUZE100_VGEN5VOL, 100000), + PFUZE100_VGEN_REG(vgen6, PFUZE100_VGEN6VOL, 100000), +}; + +/* PFUZE200 */ +static struct pfuze100_regulator_desc pfuze200_regulators[] = { + PFUZE100_SW_REG(sw1ab, PFUZE100_SW1ABVOL, 25000), + PFUZE100_SW_REG(sw2, PFUZE100_SW2VOL, 25000), + PFUZE100_SW_REG(sw3a, PFUZE100_SW3AVOL, 25000), + PFUZE100_SW_REG(sw3b, PFUZE100_SW3BVOL, 25000), + PFUZE100_SWB_REG(swbst, PFUZE100_SWBSTCON1, 0x3, 50000, pfuze100_swbst), + PFUZE100_SNVS_REG(vsnvs, PFUZE100_VSNVSVOL, 0x7, pfuze100_vsnvs), + PFUZE100_FIXED_REG(vrefddr, PFUZE100_VREFDDRCON, 750000), + PFUZE100_VGEN_REG(vgen1, PFUZE100_VGEN1VOL, 50000), + PFUZE100_VGEN_REG(vgen2, PFUZE100_VGEN2VOL, 50000), + PFUZE100_VGEN_REG(vgen3, PFUZE100_VGEN3VOL, 100000), + PFUZE100_VGEN_REG(vgen4, PFUZE100_VGEN4VOL, 100000), + PFUZE100_VGEN_REG(vgen5, PFUZE100_VGEN5VOL, 100000), + PFUZE100_VGEN_REG(vgen6, PFUZE100_VGEN6VOL, 100000), +}; + +/* PFUZE3000 */ +static struct pfuze100_regulator_desc pfuze3000_regulators[] = { + PFUZE3000_SW1_REG(sw1a, PFUZE100_SW1ABVOL, 25000), + PFUZE3000_SW1_REG(sw1b, PFUZE100_SW1CVOL, 25000), + PFUZE100_SWB_REG(sw2, PFUZE100_SW2VOL, 0x7, 50000, pfuze3000_sw2lo), + PFUZE3000_SW3_REG(sw3, PFUZE100_SW3AVOL, 50000), + PFUZE100_SWB_REG(swbst, PFUZE100_SWBSTCON1, 0x3, 50000, pfuze100_swbst), + PFUZE100_SNVS_REG(vsnvs, PFUZE100_VSNVSVOL, 0x7, pfuze3000_vsnvs), + PFUZE100_FIXED_REG(vrefddr, PFUZE100_VREFDDRCON, 750000), + PFUZE100_VGEN_REG(vldo1, PFUZE100_VGEN1VOL, 100000), + PFUZE100_VGEN_REG(vldo2, PFUZE100_VGEN2VOL, 50000), + PFUZE3000_VCC_REG(vccsd, PFUZE100_VGEN3VOL, 150000), + PFUZE3000_VCC_REG(v33, PFUZE100_VGEN4VOL, 150000), + PFUZE100_VGEN_REG(vldo3, PFUZE100_VGEN5VOL, 100000), + PFUZE100_VGEN_REG(vldo4, PFUZE100_VGEN6VOL, 100000), +}; + +#define MODE(_id, _val, _name) { \ + .id = _id, \ + .register_value = _val, \ + .name = _name, \ +} + +/* SWx Buck regulator mode */ +static struct dm_regulator_mode pfuze_sw_modes[] = { + MODE(OFF_OFF, OFF_OFF, "OFF_OFF"), + MODE(PWM_OFF, PWM_OFF, "PWM_OFF"), + MODE(PFM_OFF, PFM_OFF, "PFM_OFF"), + MODE(APS_OFF, APS_OFF, "APS_OFF"), + MODE(PWM_PWM, PWM_PWM, "PWM_PWM"), + MODE(PWM_APS, PWM_APS, "PWM_APS"), + MODE(APS_APS, APS_APS, "APS_APS"), + MODE(APS_PFM, APS_PFM, "APS_PFM"), + MODE(PWM_PFM, PWM_PFM, "PWM_PFM"), +}; + +/* Boost Buck regulator mode for normal operation */ +static struct dm_regulator_mode pfuze_swbst_modes[] = { + MODE(SWBST_MODE_OFF, SWBST_MODE_OFF , "SWBST_MODE_OFF"), + MODE(SWBST_MODE_PFM, SWBST_MODE_PFM, "SWBST_MODE_PFM"), + MODE(SWBST_MODE_AUTO, SWBST_MODE_AUTO, "SWBST_MODE_AUTO"), + MODE(SWBST_MODE_APS, SWBST_MODE_APS, "SWBST_MODE_APS"), +}; + +/* VGENx LDO regulator mode for normal operation */ +static struct dm_regulator_mode pfuze_ldo_modes[] = { + MODE(LDO_MODE_OFF, LDO_MODE_OFF, "LDO_MODE_OFF"), + MODE(LDO_MODE_ON, LDO_MODE_ON, "LDO_MODE_ON"), +}; + +static struct pfuze100_regulator_desc *se_desc(struct pfuze100_regulator_desc *desc, + int size, + const char *name) +{ + int i; + + for (i = 0; i < size; desc++) { + if (!strcmp(desc->name, name)) + return desc; + continue; + } + + return NULL; +} + +static int pfuze100_regulator_probe(struct udevice *dev) +{ + struct dm_regulator_uclass_platdata *uc_pdata; + struct pfuze100_regulator_platdata *plat = dev_get_platdata(dev); + struct pfuze100_regulator_desc *desc; + + switch (dev_get_driver_data(dev_get_parent(dev))) { + case PFUZE100: + desc = se_desc(pfuze100_regulators, + ARRAY_SIZE(pfuze100_regulators), + dev->name); + break; + case PFUZE200: + desc = se_desc(pfuze200_regulators, + ARRAY_SIZE(pfuze200_regulators), + dev->name); + break; + case PFUZE3000: + desc = se_desc(pfuze3000_regulators, + ARRAY_SIZE(pfuze3000_regulators), + dev->name); + break; + default: + debug("Unsupported PFUZE\n"); + return -EINVAL; + } + if (!desc) { + debug("Do not support regulator %s\n", dev->name); + return -EINVAL; + } + + plat->desc = desc; + uc_pdata = dev_get_uclass_platdata(dev); + + uc_pdata->type = desc->type; + if (uc_pdata->type == REGULATOR_TYPE_BUCK) { + if (!strcmp(dev->name, "swbst")) { + uc_pdata->mode = pfuze_swbst_modes; + uc_pdata->mode_count = ARRAY_SIZE(pfuze_swbst_modes); + } else { + uc_pdata->mode = pfuze_sw_modes; + uc_pdata->mode_count = ARRAY_SIZE(pfuze_sw_modes); + } + } else if (uc_pdata->type == REGULATOR_TYPE_LDO) { + uc_pdata->mode = pfuze_ldo_modes; + uc_pdata->mode_count = ARRAY_SIZE(pfuze_ldo_modes); + } else { + uc_pdata->mode = NULL; + uc_pdata->mode_count = 0; + } + + return 0; +} + +static int pfuze100_regulator_mode(struct udevice *dev, int op, int *opmode) +{ + unsigned char val; + struct pfuze100_regulator_platdata *plat = dev_get_platdata(dev); + struct pfuze100_regulator_desc *desc = plat->desc; + + if (op == PMIC_OP_GET) { + if (desc->type == REGULATOR_TYPE_BUCK) { + if (!strcmp(dev->name, "swbst")) { + val = pmic_reg_read(dev->parent, + desc->vsel_reg); + if (val < 0) + return val; + + val &= SWBST_MODE_MASK; + val >>= SWBST_MODE_SHIFT; + *opmode = val; + + return 0; + } + val = pmic_reg_read(dev->parent, + desc->vsel_reg + + PFUZE100_MODE_OFFSET); + if (val < 0) + return val; + + val &= SW_MODE_MASK; + val >>= SW_MODE_SHIFT; + *opmode = val; + + return 0; + + } else if (desc->type == REGULATOR_TYPE_LDO) { + val = pmic_reg_read(dev->parent, desc->vsel_reg); + if (val < 0) + return val; + + val &= LDO_MODE_MASK; + val >>= LDO_MODE_SHIFT; + *opmode = val; + + return 0; + } else { + return -EINVAL; + } + } + + if (desc->type == REGULATOR_TYPE_BUCK) { + if (!strcmp(dev->name, "swbst")) + return pmic_clrsetbits(dev->parent, desc->vsel_reg, + SWBST_MODE_MASK, + *opmode << SWBST_MODE_SHIFT); + + val = pmic_clrsetbits(dev->parent, + desc->vsel_reg + PFUZE100_MODE_OFFSET, + SW_MODE_MASK, + *opmode << SW_MODE_SHIFT); + + } else if (desc->type == REGULATOR_TYPE_LDO) { + val = pmic_clrsetbits(dev->parent, desc->vsel_reg, + LDO_MODE_MASK, + *opmode << LDO_MODE_SHIFT); + return val; + } else { + return -EINVAL; + } + + return 0; +} + +static int pfuze100_regulator_enable(struct udevice *dev, int op, bool *enable) +{ + unsigned char val; + int ret, on_off; + struct dm_regulator_uclass_platdata *uc_pdata = + dev_get_uclass_platdata(dev); + + if (op == PMIC_OP_GET) { + if (!strcmp(dev->name, "vrefddr")) { + val = pmic_reg_read(dev->parent, PFUZE100_VREFDDRCON); + if (val < 0) + return val; + + if (val & VREFDDRCON_EN) + *enable = true; + else + *enable = false; + return 0; + } + ret = pfuze100_regulator_mode(dev, op, &on_off); + if (ret) + return ret; + switch (on_off) { + /* OFF_OFF, SWBST_MODE_OFF, LDO_MODE_OFF have same value */ + case OFF_OFF: + *enable = false; + break; + default: + *enable = true; + break; + } + } else if (op == PMIC_OP_SET) { + if (!strcmp(dev->name, "vrefddr")) { + val = pmic_reg_read(dev->parent, PFUZE100_VREFDDRCON); + if (val < 0) + return val; + + if (val & VREFDDRCON_EN) + return 0; + val |= VREFDDRCON_EN; + + return pmic_reg_write(dev->parent, PFUZE100_VREFDDRCON, + val); + } + + if (uc_pdata->type == REGULATOR_TYPE_LDO) { + on_off = *enable ? LDO_MODE_ON : LDO_MODE_OFF; + } else if (uc_pdata->type == REGULATOR_TYPE_BUCK) { + if (!strcmp(dev->name, "swbst")) + on_off = *enable ? SWBST_MODE_AUTO : + SWBST_MODE_OFF; + else + on_off = *enable ? APS_PFM : OFF_OFF; + } else { + return -EINVAL; + } + + return pfuze100_regulator_mode(dev, op, &on_off); + } + + return 0; +} + +static int pfuze100_regulator_val(struct udevice *dev, int op, int *uV) +{ + int i; + unsigned char val; + struct pfuze100_regulator_platdata *plat = dev_get_platdata(dev); + struct pfuze100_regulator_desc *desc = plat->desc; + struct dm_regulator_uclass_platdata *uc_pdata = + dev_get_uclass_platdata(dev); + + if (op == PMIC_OP_GET) { + *uV = 0; + if (uc_pdata->type == REGULATOR_TYPE_FIXED) { + *uV = desc->voltage; + } else if (desc->volt_table) { + val = pmic_reg_read(dev->parent, desc->vsel_reg); + if (val < 0) + return val; + val &= desc->vsel_mask; + *uV = desc->volt_table[val]; + } else { + if (uc_pdata->min_uV < 0) { + debug("Need to provide min_uV in dts.\n"); + return -EINVAL; + } + val = pmic_reg_read(dev->parent, desc->vsel_reg); + if (val < 0) + return val; + val &= desc->vsel_mask; + *uV = uc_pdata->min_uV + (int)val * desc->uV_step; + } + + return 0; + } + + if (uc_pdata->type == REGULATOR_TYPE_FIXED) { + debug("Set voltage for REGULATOR_TYPE_FIXED regulator\n"); + return -EINVAL; + } else if (desc->volt_table) { + for (i = 0; i < desc->vsel_mask; i++) { + if (*uV == desc->volt_table[i]) + break; + } + if (i == desc->vsel_mask) { + debug("Unsupported voltage %u\n", *uV); + return -EINVAL; + } + + return pmic_clrsetbits(dev->parent, desc->vsel_reg, + desc->vsel_mask, i); + } else { + if (uc_pdata->min_uV < 0) { + debug("Need to provide min_uV in dts.\n"); + return -EINVAL; + } + return pmic_clrsetbits(dev->parent, desc->vsel_reg, + desc->vsel_mask, + (*uV - uc_pdata->min_uV) / desc->uV_step); + } + + return 0; +} + +static int pfuze100_regulator_get_value(struct udevice *dev) +{ + int uV; + int ret; + + ret = pfuze100_regulator_val(dev, PMIC_OP_GET, &uV); + if (ret) + return ret; + + return uV; +} + +static int pfuze100_regulator_set_value(struct udevice *dev, int uV) +{ + return pfuze100_regulator_val(dev, PMIC_OP_SET, &uV); +} + +static bool pfuze100_regulator_get_enable(struct udevice *dev) +{ + int ret; + bool enable = false; + + ret = pfuze100_regulator_enable(dev, PMIC_OP_GET, &enable); + if (ret) + return ret; + + return enable; +} + +static int pfuze100_regulator_set_enable(struct udevice *dev, bool enable) +{ + return pfuze100_regulator_enable(dev, PMIC_OP_SET, &enable); +} + +static int pfuze100_regulator_get_mode(struct udevice *dev) +{ + int mode; + int ret; + + ret = pfuze100_regulator_mode(dev, PMIC_OP_GET, &mode); + if (ret) + return ret; + + return mode; +} + +static int pfuze100_regulator_set_mode(struct udevice *dev, int mode) +{ + return pfuze100_regulator_mode(dev, PMIC_OP_SET, &mode); +} + +static const struct dm_regulator_ops pfuze100_regulator_ops = { + .get_value = pfuze100_regulator_get_value, + .set_value = pfuze100_regulator_set_value, + .get_enable = pfuze100_regulator_get_enable, + .set_enable = pfuze100_regulator_set_enable, + .get_mode = pfuze100_regulator_get_mode, + .set_mode = pfuze100_regulator_set_mode, +}; + +U_BOOT_DRIVER(pfuze100_regulator) = { + .name = "pfuze100_regulator", + .id = UCLASS_REGULATOR, + .ops = &pfuze100_regulator_ops, + .probe = pfuze100_regulator_probe, + .platdata_auto_alloc_size = sizeof(struct pfuze100_regulator_platdata), +}; diff --git a/include/power/pfuze100_pmic.h b/include/power/pfuze100_pmic.h index c40a976..41cb710 100644 --- a/include/power/pfuze100_pmic.h +++ b/include/power/pfuze100_pmic.h @@ -62,6 +62,13 @@ enum { PFUZE100_NUM_OF_REGS = 0x7f, }; +/* Registor offset based on VOLT register */ +#define PFUZE100_VOL_OFFSET 0 +#define PFUZE100_STBY_OFFSET 1 +#define PFUZE100_OFF_OFFSET 2 +#define PFUZE100_MODE_OFFSET 3 +#define PFUZE100_CONF_OFFSET 4 + /* * Buck Regulators */ @@ -138,6 +145,9 @@ enum { #define SW1x_STBY_MASK 0x3f #define SW1x_OFF_MASK 0x3f +#define SW_MODE_MASK 0xf +#define SW_MODE_SHIFT 0 + #define SW1xCONF_DVSSPEED_MASK 0xc0 #define SW1xCONF_DVSSPEED_2US 0x00 #define SW1xCONF_DVSSPEED_4US 0x40 @@ -186,7 +196,12 @@ enum { #define LDO_VOL_MASK 0xf #define LDO_EN (1 << 4) +#define LDO_MODE_SHIFT 4 +#define LDO_MODE_MASK (1 << 4) +#define LDO_MODE_OFF 0 +#define LDO_MODE_ON 1 +#define VREFDDRCON_EN (1 << 4) /* * Boost Regulator */ @@ -199,10 +214,11 @@ enum { #define SWBST_VOL_MASK 0x3 #define SWBST_MODE_MASK 0xC -#define SWBST_MODE_OFF (0 << 2) -#define SWBST_MODE_PFM (1 << 2) -#define SWBST_MODE_AUTO (2 << 2) -#define SWBST_MODE_APS (3 << 2) +#define SWBST_MODE_SHIFT 0x2 +#define SWBST_MODE_OFF 0 +#define SWBST_MODE_PFM 1 +#define SWBST_MODE_AUTO 2 +#define SWBST_MODE_APS 3 /* * Regulator Mode Control