From patchwork Mon Feb 17 09:05:37 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Krzysztof Kozlowski X-Patchwork-Id: 3661831 Return-Path: X-Original-To: patchwork-linux-arm@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork2.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.19.201]) by patchwork2.web.kernel.org (Postfix) with ESMTP id 3C31FBF13A for ; Mon, 17 Feb 2014 09:52:20 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id CEF602015E for ; Mon, 17 Feb 2014 09:52:17 +0000 (UTC) Received: from casper.infradead.org (casper.infradead.org [85.118.1.10]) (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 869732013A for ; Mon, 17 Feb 2014 09:52:14 +0000 (UTC) Received: from merlin.infradead.org ([2001:4978:20e::2]) by casper.infradead.org with esmtps (Exim 4.80.1 #2 (Red Hat Linux)) id 1WFKC6-0006aF-Ko; Mon, 17 Feb 2014 09:08:57 +0000 Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.80.1 #2 (Red Hat Linux)) id 1WFKBS-0005Jv-TA; Mon, 17 Feb 2014 09:08:14 +0000 Received: from mailout2.w1.samsung.com ([210.118.77.12]) by merlin.infradead.org with esmtps (Exim 4.80.1 #2 (Red Hat Linux)) id 1WFK9p-00053w-Fg for linux-arm-kernel@lists.infradead.org; Mon, 17 Feb 2014 09:07:16 +0000 Received: from eucpsbgm1.samsung.com (unknown [203.254.199.244]) by mailout2.w1.samsung.com (Oracle Communications Messaging Server 7u4-24.01(7.0.4.24.0) 64bit (built Nov 17 2011)) with ESMTP id <0N1400K8WUM3BN60@mailout2.w1.samsung.com> for linux-arm-kernel@lists.infradead.org; Mon, 17 Feb 2014 09:06:03 +0000 (GMT) X-AuditID: cbfec7f4-b7f796d000005a13-6f-5301d0ffb841 Received: from eusync4.samsung.com ( [203.254.199.214]) by eucpsbgm1.samsung.com (EUCPMTA) with SMTP id 7D.8D.23059.FF0D1035; Mon, 17 Feb 2014 09:06:07 +0000 (GMT) Received: from AMDC1943.digital.local ([106.116.151.171]) by eusync4.samsung.com (Oracle Communications Messaging Server 7u4-24.01(7.0.4.24.0) 64bit (built Nov 17 2011)) with ESMTPA id <0N1400JDQUM1F680@eusync4.samsung.com>; Mon, 17 Feb 2014 09:06:07 +0000 (GMT) From: Krzysztof Kozlowski To: MyungJoo Ham , Chanwoo Choi , Samuel Ortiz , Lee Jones , Mark Brown , linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v3 02/15] mfd: max14577: Rename and add MAX14577 symbols to prepare for max77836 Date: Mon, 17 Feb 2014 10:05:37 +0100 Message-id: <1392627950-26927-3-git-send-email-k.kozlowski@samsung.com> X-Mailer: git-send-email 1.7.9.5 In-reply-to: <1392627950-26927-1-git-send-email-k.kozlowski@samsung.com> References: <1392627950-26927-1-git-send-email-k.kozlowski@samsung.com> X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFlrPLMWRmVeSWpSXmKPExsVy+t/xa7r/LzAGG3w9bmpxcKumxcYZ61kt pj58wmZx/ctzVotJT94zW0xcOZnZ4vULQ4uzTW/YLe5/PcposenxNVaLy7vmsFmsPXKX3eJ2 4wo2i9PdrBbrZ7xmceD3mND/idFj56y77B6bV2h5bFrVyeZx59oeNo95JwM9Ni+p9+jbsorR 4/MmuQDOKC6blNSczLLUIn27BK6M2R83MxfcucxUcWb6DKYGxtYFTF2MnBwSAiYSV+f/Y4ew xSQu3FvP1sXIxSEksJRR4nPDZiYIp49Jom3PQUaQKjYBY4nNy5eAVYkItDBJvF+/nxHEYRZ4 wSTRs7+fFaRKWCBJYvKzicwgNouAqsSnv4/AdvAKuEusWvYCKM4BtE9BYs4kG5Awp4CHxM2l t8BKhIBKnjzawTKBkXcBI8MqRtHU0uSC4qT0XEO94sTc4tK8dL3k/NxNjJBA/rKDcfExq0OM AhyMSjy8BtWMwUKsiWXFlbmHGCU4mJVEeG3XAYV4UxIrq1KL8uOLSnNSiw8xMnFwSjUwymle YJvqOF8we7KEoN2nkoqUu03v04N3HsxZ7dnLvS5beEluiKvAsdiXcXpq6TtSD+7Xk2g+/vOB 67+JAV7/hRdXhXTXy7lZWdzR9n4UdXpZu0WuBc8l9/uvFx9fobjCxeOxf7b88q3xHWf5nQ/d CmXml1s1nev0+aq3xroes3svhAemMLspsRRnJBpqMRcVJwIAsaO8jEICAAA= X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20140217_040633_922785_8176BB7C X-CRM114-Status: GOOD ( 21.02 ) X-Spam-Score: -4.5 (----) Cc: Krzysztof Kozlowski , Bartlomiej Zolnierkiewicz , Dmitry Eremin-Solenikov , Tomasz Figa , Anton Vorontsov , Kyungmin Park , David Woodhouse , Marek Szyprowski X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org X-Spam-Status: No, score=-1.8 required=5.0 tests=BAYES_00,KHOP_BIG_TO_CC, RCVD_IN_DNSWL_MED,RP_MATCHES_RCVD,UNPARSEABLE_RELAY,UPPERCASE_50_75 autolearn=no version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP This patch prepares for adding support for max77836 device to existing max14577 driver: 1. Renames most of symbols and defines prefixed with MAX14577 to MAXIM. 2. Adds prefixes (MAXIM or MAX14577) to defines without any MAX* prefix. This is only a rename-like patch, new code is not added. Signed-off-by: Krzysztof Kozlowski Cc: Kyungmin Park Cc: Marek Szyprowski Cc: Anton Vorontsov Cc: Dmitry Eremin-Solenikov Cc: David Woodhouse Acked-by: Lee Jones Acked-by: Chanwoo Choi --- drivers/extcon/extcon-max14577.c | 105 ++++----- drivers/mfd/max14577.c | 51 ++--- drivers/power/max14577_charger.c | 81 +++---- drivers/regulator/max14577.c | 44 ++-- include/linux/mfd/max14577-private.h | 399 ++++++++++++++++------------------ include/linux/mfd/max14577.h | 2 +- 6 files changed, 333 insertions(+), 349 deletions(-) diff --git a/drivers/extcon/extcon-max14577.c b/drivers/extcon/extcon-max14577.c index 59f084fee4f3..6f7145a929cf 100644 --- a/drivers/extcon/extcon-max14577.c +++ b/drivers/extcon/extcon-max14577.c @@ -86,14 +86,14 @@ struct max14577_muic_irq { }; static struct max14577_muic_irq muic_irqs[] = { - { MAX14577_IRQ_INT1_ADC, "muic-ADC" }, - { MAX14577_IRQ_INT1_ADCLOW, "muic-ADCLOW" }, - { MAX14577_IRQ_INT1_ADCERR, "muic-ADCError" }, - { MAX14577_IRQ_INT2_CHGTYP, "muic-CHGTYP" }, - { MAX14577_IRQ_INT2_CHGDETRUN, "muic-CHGDETRUN" }, - { MAX14577_IRQ_INT2_DCDTMR, "muic-DCDTMR" }, - { MAX14577_IRQ_INT2_DBCHG, "muic-DBCHG" }, - { MAX14577_IRQ_INT2_VBVOLT, "muic-VBVOLT" }, + { MAXIM_IRQ_INT1_ADC, "muic-ADC" }, + { MAXIM_IRQ_INT1_ADCLOW, "muic-ADCLOW" }, + { MAXIM_IRQ_INT1_ADCERR, "muic-ADCError" }, + { MAXIM_IRQ_INT2_CHGTYP, "muic-CHGTYP" }, + { MAXIM_IRQ_INT2_CHGDETRUN, "muic-CHGDETRUN" }, + { MAXIM_IRQ_INT2_DCDTMR, "muic-DCDTMR" }, + { MAXIM_IRQ_INT2_DBCHG, "muic-DBCHG" }, + { MAXIM_IRQ_INT2_VBVOLT, "muic-VBVOLT" }, }; /* Define supported accessory type */ @@ -177,9 +177,9 @@ static int max14577_muic_set_debounce_time(struct max14577_muic_info *info, case ADC_DEBOUNCE_TIME_25MS: case ADC_DEBOUNCE_TIME_38_62MS: ret = max14577_update_reg(info->max14577->regmap, - MAX14577_MUIC_REG_CONTROL3, - CTRL3_ADCDBSET_MASK, - time << CTRL3_ADCDBSET_SHIFT); + MAXIM_MUIC_REG_CONTROL3, + MAXIM_CONTROL3_ADCDBSET_MASK, + time << MAXIM_CONTROL3_ADCDBSET_SHIFT); if (ret) { dev_err(info->dev, "failed to set ADC debounce time\n"); return ret; @@ -211,8 +211,9 @@ static int max14577_muic_set_path(struct max14577_muic_info *info, /* Set open state to path before changing hw path */ ret = max14577_update_reg(info->max14577->regmap, - MAX14577_MUIC_REG_CONTROL1, - CLEAR_IDBEN_MICEN_MASK, CTRL1_SW_OPEN); + MAXIM_MUIC_REG_CONTROL1, + MAXIM_CONTROL1_CLEAR_IDBEN_MICEN_MASK, + MAXIM_CONTROL1_SW_OPEN); if (ret < 0) { dev_err(info->dev, "failed to update MUIC register\n"); return ret; @@ -221,24 +222,25 @@ static int max14577_muic_set_path(struct max14577_muic_info *info, if (attached) ctrl1 = val; else - ctrl1 = CTRL1_SW_OPEN; + ctrl1 = MAXIM_CONTROL1_SW_OPEN; ret = max14577_update_reg(info->max14577->regmap, - MAX14577_MUIC_REG_CONTROL1, - CLEAR_IDBEN_MICEN_MASK, ctrl1); + MAXIM_MUIC_REG_CONTROL1, + MAXIM_CONTROL1_CLEAR_IDBEN_MICEN_MASK, ctrl1); if (ret < 0) { dev_err(info->dev, "failed to update MUIC register\n"); return ret; } if (attached) - ctrl2 |= CTRL2_CPEN_MASK; /* LowPwr=0, CPEn=1 */ + ctrl2 |= MAXIM_CONTROL2_CPEN_MASK; /* LowPwr=0, CPEn=1 */ else - ctrl2 |= CTRL2_LOWPWR_MASK; /* LowPwr=1, CPEn=0 */ + ctrl2 |= MAXIM_CONTROL2_LOWPWR_MASK; /* LowPwr=1, CPEn=0 */ ret = max14577_update_reg(info->max14577->regmap, - MAX14577_REG_CONTROL2, - CTRL2_LOWPWR_MASK | CTRL2_CPEN_MASK, ctrl2); + MAXIM_MUIC_REG_CONTROL2, + MAXIM_CONTROL2_LOWPWR_MASK | MAXIM_CONTROL2_CPEN_MASK, + ctrl2); if (ret < 0) { dev_err(info->dev, "failed to update MUIC register\n"); return ret; @@ -275,8 +277,9 @@ static int max14577_muic_get_cable_type(struct max14577_muic_info *info, * Read ADC value to check cable type and decide cable state * according to cable type */ - adc = info->status[MAX14577_MUIC_STATUS1] & STATUS1_ADC_MASK; - adc >>= STATUS1_ADC_SHIFT; + adc = info->status[MAX14577_MUIC_STATUS1] & + MAXIM_STATUS1_ADC_MASK; + adc >>= MAXIM_STATUS1_ADC_SHIFT; /* * Check current cable state/cable type and store cable type @@ -300,14 +303,14 @@ static int max14577_muic_get_cable_type(struct max14577_muic_info *info, * according to type of charger cable. */ chg_type = info->status[MAX14577_MUIC_STATUS2] & - STATUS2_CHGTYP_MASK; - chg_type >>= STATUS2_CHGTYP_SHIFT; + MAXIM_STATUS2_CHGTYP_MASK; + chg_type >>= MAXIM_STATUS2_CHGTYP_SHIFT; - if (chg_type == MAX14577_CHARGER_TYPE_NONE) { + if (chg_type == MAXIM_CHARGER_TYPE_NONE) { *attached = false; cable_type = info->prev_chg_type; - info->prev_chg_type = MAX14577_CHARGER_TYPE_NONE; + info->prev_chg_type = MAXIM_CHARGER_TYPE_NONE; } else { *attached = true; @@ -334,7 +337,7 @@ static int max14577_muic_jig_handler(struct max14577_muic_info *info, { char cable_name[32]; int ret = 0; - u8 path = CTRL1_SW_OPEN; + u8 path = MAXIM_CONTROL1_SW_OPEN; dev_dbg(info->dev, "external connector is %s (adc:0x%02x)\n", @@ -344,17 +347,17 @@ static int max14577_muic_jig_handler(struct max14577_muic_info *info, case MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF: /* ADC_JIG_USB_OFF */ /* PATH:AP_USB */ strcpy(cable_name, "JIG-USB-OFF"); - path = CTRL1_SW_USB; + path = MAXIM_CONTROL1_SW_USB; break; case MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON: /* ADC_JIG_USB_ON */ /* PATH:AP_USB */ strcpy(cable_name, "JIG-USB-ON"); - path = CTRL1_SW_USB; + path = MAXIM_CONTROL1_SW_USB; break; case MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF: /* ADC_JIG_UART_OFF */ /* PATH:AP_UART */ strcpy(cable_name, "JIG-UART-OFF"); - path = CTRL1_SW_UART; + path = MAXIM_CONTROL1_SW_UART; break; default: dev_err(info->dev, "failed to detect %s jig cable\n", @@ -457,7 +460,7 @@ static int max14577_muic_chg_handler(struct max14577_muic_info *info) chg_type, info->prev_chg_type); switch (chg_type) { - case MAX14577_CHARGER_TYPE_USB: + case MAXIM_CHARGER_TYPE_USB: /* PATH:AP_USB */ ret = max14577_muic_set_path(info, info->path_usb, attached); if (ret < 0) @@ -465,21 +468,21 @@ static int max14577_muic_chg_handler(struct max14577_muic_info *info) extcon_set_cable_state(info->edev, "USB", attached); break; - case MAX14577_CHARGER_TYPE_DEDICATED_CHG: + case MAXIM_CHARGER_TYPE_DEDICATED_CHG: extcon_set_cable_state(info->edev, "TA", attached); break; - case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT: + case MAXIM_CHARGER_TYPE_DOWNSTREAM_PORT: extcon_set_cable_state(info->edev, "Charge-downstream", attached); break; - case MAX14577_CHARGER_TYPE_SPECIAL_500MA: + case MAXIM_CHARGER_TYPE_SPECIAL_500MA: extcon_set_cable_state(info->edev, "Slow-charger", attached); break; - case MAX14577_CHARGER_TYPE_SPECIAL_1A: + case MAXIM_CHARGER_TYPE_SPECIAL_1A: extcon_set_cable_state(info->edev, "Fast-charger", attached); break; - case MAX14577_CHARGER_TYPE_NONE: - case MAX14577_CHARGER_TYPE_DEAD_BATTERY: + case MAXIM_CHARGER_TYPE_NONE: + case MAXIM_CHARGER_TYPE_DEAD_BATTERY: break; default: dev_err(info->dev, @@ -503,7 +506,7 @@ static void max14577_muic_irq_work(struct work_struct *work) mutex_lock(&info->mutex); ret = max14577_bulk_read(info->max14577->regmap, - MAX14577_MUIC_REG_STATUS1, info->status, 2); + MAXIM_MUIC_REG_STATUS1, info->status, 2); if (ret) { dev_err(info->dev, "failed to read MUIC register\n"); mutex_unlock(&info->mutex); @@ -543,18 +546,18 @@ static irqreturn_t max14577_muic_irq_handler(int irq, void *data) irq_type = muic_irqs[i].irq; switch (irq_type) { - case MAX14577_IRQ_INT1_ADC: - case MAX14577_IRQ_INT1_ADCLOW: - case MAX14577_IRQ_INT1_ADCERR: + case MAXIM_IRQ_INT1_ADC: + case MAXIM_IRQ_INT1_ADCLOW: + case MAXIM_IRQ_INT1_ADCERR: /* Handle all of accessory except for type of charger accessory */ info->irq_adc = true; break; - case MAX14577_IRQ_INT2_CHGTYP: - case MAX14577_IRQ_INT2_CHGDETRUN: - case MAX14577_IRQ_INT2_DCDTMR: - case MAX14577_IRQ_INT2_DBCHG: - case MAX14577_IRQ_INT2_VBVOLT: + case MAXIM_IRQ_INT2_CHGTYP: + case MAXIM_IRQ_INT2_CHGDETRUN: + case MAXIM_IRQ_INT2_DCDTMR: + case MAXIM_IRQ_INT2_DBCHG: + case MAXIM_IRQ_INT2_VBVOLT: /* Handle charger accessory */ info->irq_chg = true; break; @@ -579,7 +582,7 @@ static int max14577_muic_detect_accessory(struct max14577_muic_info *info) /* Read STATUSx register to detect accessory */ ret = max14577_bulk_read(info->max14577->regmap, - MAX14577_MUIC_REG_STATUS1, info->status, 2); + MAXIM_MUIC_REG_STATUS1, info->status, 2); if (ret) { dev_err(info->dev, "failed to read MUIC register\n"); mutex_unlock(&info->mutex); @@ -599,7 +602,7 @@ static int max14577_muic_detect_accessory(struct max14577_muic_info *info) chg_type = max14577_muic_get_cable_type(info, MAX14577_CABLE_GROUP_CHG, &attached); - if (attached && chg_type != MAX14577_CHARGER_TYPE_NONE) { + if (attached && chg_type != MAXIM_CHARGER_TYPE_NONE) { ret = max14577_muic_chg_handler(info); if (ret < 0) { dev_err(info->dev, "Cannot detect charger accessory\n"); @@ -682,8 +685,8 @@ static int max14577_muic_probe(struct platform_device *pdev) } /* Default h/w line path */ - info->path_usb = CTRL1_SW_USB; - info->path_uart = CTRL1_SW_UART; + info->path_usb = MAXIM_CONTROL1_SW_USB; + info->path_uart = MAXIM_CONTROL1_SW_UART; delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT); /* Set initial path for UART */ @@ -691,7 +694,7 @@ static int max14577_muic_probe(struct platform_device *pdev) /* Check revision number of MUIC device*/ ret = max14577_read_reg(info->max14577->regmap, - MAX14577_REG_DEVICEID, &id); + MAXIM_MUIC_REG_DEVICEID, &id); if (ret < 0) { dev_err(&pdev->dev, "failed to read revision number\n"); goto err_extcon; diff --git a/drivers/mfd/max14577.c b/drivers/mfd/max14577.c index 2ac2f2d7cea6..d883055ca789 100644 --- a/drivers/mfd/max14577.c +++ b/drivers/mfd/max14577.c @@ -36,10 +36,10 @@ static struct mfd_cell max14577_devs[] = { { .name = "max14577-charger", }, }; -static bool max14577_volatile_reg(struct device *dev, unsigned int reg) +static bool max14577_muic_volatile_reg(struct device *dev, unsigned int reg) { switch (reg) { - case MAX14577_REG_INT1 ... MAX14577_REG_STATUS3: + case MAXIM_MUIC_REG_INT1 ... MAXIM_MUIC_REG_STATUS3: return true; default: break; @@ -47,35 +47,35 @@ static bool max14577_volatile_reg(struct device *dev, unsigned int reg) return false; } -static const struct regmap_config max14577_regmap_config = { +static const struct regmap_config max14577_muic_regmap_config = { .reg_bits = 8, .val_bits = 8, - .volatile_reg = max14577_volatile_reg, - .max_register = MAX14577_REG_END, + .volatile_reg = max14577_muic_volatile_reg, + .max_register = MAXIM_MUIC_REG_END, }; static const struct regmap_irq max14577_irqs[] = { /* INT1 interrupts */ - { .reg_offset = 0, .mask = INT1_ADC_MASK, }, - { .reg_offset = 0, .mask = INT1_ADCLOW_MASK, }, - { .reg_offset = 0, .mask = INT1_ADCERR_MASK, }, + { .reg_offset = 0, .mask = MAXIM_INT1_ADC_MASK, }, + { .reg_offset = 0, .mask = MAXIM_INT1_ADCLOW_MASK, }, + { .reg_offset = 0, .mask = MAXIM_INT1_ADCERR_MASK, }, /* INT2 interrupts */ - { .reg_offset = 1, .mask = INT2_CHGTYP_MASK, }, - { .reg_offset = 1, .mask = INT2_CHGDETRUN_MASK, }, - { .reg_offset = 1, .mask = INT2_DCDTMR_MASK, }, - { .reg_offset = 1, .mask = INT2_DBCHG_MASK, }, - { .reg_offset = 1, .mask = INT2_VBVOLT_MASK, }, + { .reg_offset = 1, .mask = MAXIM_INT2_CHGTYP_MASK, }, + { .reg_offset = 1, .mask = MAXIM_INT2_CHGDETRUN_MASK, }, + { .reg_offset = 1, .mask = MAXIM_INT2_DCDTMR_MASK, }, + { .reg_offset = 1, .mask = MAXIM_INT2_DBCHG_MASK, }, + { .reg_offset = 1, .mask = MAXIM_INT2_VBVOLT_MASK, }, /* INT3 interrupts */ - { .reg_offset = 2, .mask = INT3_EOC_MASK, }, - { .reg_offset = 2, .mask = INT3_CGMBC_MASK, }, - { .reg_offset = 2, .mask = INT3_OVP_MASK, }, - { .reg_offset = 2, .mask = INT3_MBCCHGERR_MASK, }, + { .reg_offset = 2, .mask = MAXIM_INT3_EOC_MASK, }, + { .reg_offset = 2, .mask = MAXIM_INT3_CGMBC_MASK, }, + { .reg_offset = 2, .mask = MAXIM_INT3_OVP_MASK, }, + { .reg_offset = 2, .mask = MAXIM_INT3_MBCCHGERR_MASK, }, }; static const struct regmap_irq_chip max14577_irq_chip = { .name = "max14577", - .status_base = MAX14577_REG_INT1, - .mask_base = MAX14577_REG_INTMASK1, + .status_base = MAXIM_MUIC_REG_INT1, + .mask_base = MAXIM_MUIC_REG_INTMASK1, .mask_invert = 1, .num_regs = 3, .irqs = max14577_irqs, @@ -112,7 +112,8 @@ static int max14577_i2c_probe(struct i2c_client *i2c, max14577->i2c = i2c; max14577->irq = i2c->irq; - max14577->regmap = devm_regmap_init_i2c(i2c, &max14577_regmap_config); + max14577->regmap = devm_regmap_init_i2c(i2c, + &max14577_muic_regmap_config); if (IS_ERR(max14577->regmap)) { ret = PTR_ERR(max14577->regmap); dev_err(max14577->dev, "Failed to allocate register map: %d\n", @@ -120,17 +121,17 @@ static int max14577_i2c_probe(struct i2c_client *i2c, return ret; } - ret = max14577_read_reg(max14577->regmap, MAX14577_REG_DEVICEID, + ret = max14577_read_reg(max14577->regmap, MAXIM_MUIC_REG_DEVICEID, ®_data); if (ret) { dev_err(max14577->dev, "Device not found on this channel: %d\n", ret); return ret; } - max14577->vendor_id = ((reg_data & DEVID_VENDORID_MASK) >> - DEVID_VENDORID_SHIFT); - max14577->device_id = ((reg_data & DEVID_DEVICEID_MASK) >> - DEVID_DEVICEID_SHIFT); + max14577->vendor_id = ((reg_data & MAXIM_DEVID_VENDORID_MASK) >> + MAXIM_DEVID_VENDORID_SHIFT); + max14577->device_id = ((reg_data & MAXIM_DEVID_DEVICEID_MASK) >> + MAXIM_DEVID_DEVICEID_SHIFT); dev_info(max14577->dev, "Device ID: 0x%x, vendor: 0x%x\n", max14577->device_id, max14577->vendor_id); diff --git a/drivers/power/max14577_charger.c b/drivers/power/max14577_charger.c index fad2a75b3604..66a4e4edea42 100644 --- a/drivers/power/max14577_charger.c +++ b/drivers/power/max14577_charger.c @@ -46,14 +46,14 @@ static int max14577_get_charger_state(struct max14577_charger *chg) * - handle properly dead-battery charging (respect timer) * - handle timers (fast-charge and prequal) /MBCCHGERR/ */ - max14577_read_reg(rmap, MAX14577_CHG_REG_CHG_CTRL2, ®_data); - if ((reg_data & CHGCTRL2_MBCHOSTEN_MASK) == 0) + max14577_read_reg(rmap, MAXIM_CHG_REG_CHGCTRL2, ®_data); + if ((reg_data & MAXIM_CHGCTRL2_MBCHOSTEN_MASK) == 0) goto state_set; - max14577_read_reg(rmap, MAX14577_CHG_REG_STATUS3, ®_data); - if (reg_data & STATUS3_CGMBC_MASK) { + max14577_read_reg(rmap, MAXIM_MUIC_REG_STATUS3, ®_data); + if (reg_data & MAXIM_STATUS3_CGMBC_MASK) { /* Charger or USB-cable is connected */ - if (reg_data & STATUS3_EOC_MASK) + if (reg_data & MAXIM_STATUS3_EOC_MASK) state = POWER_SUPPLY_STATUS_FULL; else state = POWER_SUPPLY_STATUS_CHARGING; @@ -90,18 +90,19 @@ static int max14577_get_online(struct max14577_charger *chg) struct regmap *rmap = chg->max14577->regmap; u8 reg_data; - max14577_read_reg(rmap, MAX14577_MUIC_REG_STATUS2, ®_data); - reg_data = ((reg_data & STATUS2_CHGTYP_MASK) >> STATUS2_CHGTYP_SHIFT); + max14577_read_reg(rmap, MAXIM_MUIC_REG_STATUS2, ®_data); + reg_data = reg_data & MAXIM_STATUS2_CHGTYP_MASK; + reg_data >>= MAXIM_STATUS2_CHGTYP_SHIFT; switch (reg_data) { - case MAX14577_CHARGER_TYPE_USB: - case MAX14577_CHARGER_TYPE_DEDICATED_CHG: - case MAX14577_CHARGER_TYPE_SPECIAL_500MA: - case MAX14577_CHARGER_TYPE_SPECIAL_1A: - case MAX14577_CHARGER_TYPE_DEAD_BATTERY: + case MAXIM_CHARGER_TYPE_USB: + case MAXIM_CHARGER_TYPE_DEDICATED_CHG: + case MAXIM_CHARGER_TYPE_SPECIAL_500MA: + case MAXIM_CHARGER_TYPE_SPECIAL_1A: + case MAXIM_CHARGER_TYPE_DEAD_BATTERY: return 1; - case MAX14577_CHARGER_TYPE_NONE: - case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT: - case MAX14577_CHARGER_TYPE_RESERVED: + case MAXIM_CHARGER_TYPE_NONE: + case MAXIM_CHARGER_TYPE_DOWNSTREAM_PORT: + case MAXIM_CHARGER_TYPE_RESERVED: default: return 0; } @@ -119,15 +120,16 @@ static int max14577_get_battery_health(struct max14577_charger *chg) int state = POWER_SUPPLY_HEALTH_GOOD; u8 reg_data; - max14577_read_reg(rmap, MAX14577_MUIC_REG_STATUS2, ®_data); - reg_data = ((reg_data & STATUS2_CHGTYP_MASK) >> STATUS2_CHGTYP_SHIFT); - if (reg_data == MAX14577_CHARGER_TYPE_DEAD_BATTERY) { + max14577_read_reg(rmap, MAXIM_MUIC_REG_STATUS2, ®_data); + reg_data = reg_data & MAXIM_STATUS2_CHGTYP_MASK; + reg_data >>= MAXIM_STATUS2_CHGTYP_SHIFT; + if (reg_data == MAXIM_CHARGER_TYPE_DEAD_BATTERY) { state = POWER_SUPPLY_HEALTH_DEAD; goto state_set; } - max14577_read_reg(rmap, MAX14577_CHG_REG_STATUS3, ®_data); - if (reg_data & STATUS3_OVP_MASK) { + max14577_read_reg(rmap, MAXIM_MUIC_REG_STATUS3, ®_data); + if (reg_data & MAXIM_STATUS3_OVP_MASK) { state = POWER_SUPPLY_HEALTH_OVERVOLTAGE; goto state_set; } @@ -162,46 +164,47 @@ static void max14577_charger_reg_init(struct max14577_charger *chg) * Charger-Detection Enable, default on (set CHGDETEN to 1) * Combined mask of CHGDETEN and CHGTYPMAN will zero the CHGTYPMAN bit */ - reg_data = 0x1 << CDETCTRL1_CHGDETEN_SHIFT; - max14577_update_reg(rmap, MAX14577_REG_CDETCTRL1, - CDETCTRL1_CHGDETEN_MASK | CDETCTRL1_CHGTYPMAN_MASK, + reg_data = 0x1 << MAXIM_CDETCTRL1_CHGDETEN_SHIFT; + max14577_update_reg(rmap, MAXIM_MUIC_REG_CDETCTRL1, + MAXIM_CDETCTRL1_CHGDETEN_MASK | + MAXIM_CDETCTRL1_CHGTYPMAN_MASK, reg_data); /* Battery Fast-Charge Timer, from SM-V700: 6hrs */ - reg_data = 0x3 << CHGCTRL1_TCHW_SHIFT; - max14577_write_reg(rmap, MAX14577_REG_CHGCTRL1, reg_data); + reg_data = 0x3 << MAXIM_CHGCTRL1_TCHW_SHIFT; + max14577_write_reg(rmap, MAXIM_CHG_REG_CHGCTRL1, reg_data); /* * Wall-Adapter Rapid Charge, default on * Battery-Charger, default on */ - reg_data = 0x1 << CHGCTRL2_VCHGR_RC_SHIFT; - reg_data |= 0x1 << CHGCTRL2_MBCHOSTEN_SHIFT; - max14577_write_reg(rmap, MAX14577_REG_CHGCTRL2, reg_data); + reg_data = 0x1 << MAXIM_CHGCTRL2_VCHGR_RC_SHIFT; + reg_data |= 0x1 << MAXIM_CHGCTRL2_MBCHOSTEN_SHIFT; + max14577_write_reg(rmap, MAXIM_CHG_REG_CHGCTRL2, reg_data); /* Battery-Charger Constant Voltage (CV) Mode, from SM-V700: 4.35V */ - reg_data = 0xf << CHGCTRL3_MBCCVWRC_SHIFT; - max14577_write_reg(rmap, MAX14577_REG_CHGCTRL3, reg_data); + reg_data = 0xf << MAXIM_CHGCTRL3_MBCCVWRC_SHIFT; + max14577_write_reg(rmap, MAXIM_CHG_REG_CHGCTRL3, reg_data); /* * Fast Battery-Charge Current Low, default 200-950mA * Fast Battery-Charge Current High, from SM-V700: 450mA */ - reg_data = 0x1 << CHGCTRL4_MBCICHWRCL_SHIFT; - reg_data |= 0x5 << CHGCTRL4_MBCICHWRCH_SHIFT; - max14577_write_reg(rmap, MAX14577_REG_CHGCTRL4, reg_data); + reg_data = 0x1 << MAXIM_CHGCTRL4_MBCICHWRCL_SHIFT; + reg_data |= 0x5 << MAXIM_CHGCTRL4_MBCICHWRCH_SHIFT; + max14577_write_reg(rmap, MAXIM_CHG_REG_CHGCTRL4, reg_data); /* End-of-Charge Current, from SM-V700: 50mA */ - reg_data = 0x0 << CHGCTRL5_EOCS_SHIFT; - max14577_write_reg(rmap, MAX14577_REG_CHGCTRL5, reg_data); + reg_data = 0x0 << MAXIM_CHGCTRL5_EOCS_SHIFT; + max14577_write_reg(rmap, MAXIM_CHG_REG_CHGCTRL5, reg_data); /* Auto Charging Stop, default off */ - reg_data = 0x0 << CHGCTRL6_AUTOSTOP_SHIFT; - max14577_write_reg(rmap, MAX14577_REG_CHGCTRL6, reg_data); + reg_data = 0x0 << MAXIM_CHGCTRL6_AUTOSTOP_SHIFT; + max14577_write_reg(rmap, MAXIM_CHG_REG_CHGCTRL6, reg_data); /* Overvoltage-Protection Threshold, from SM-V700: 6.5V */ - reg_data = 0x2 << CHGCTRL7_OTPCGHCVS_SHIFT; - max14577_write_reg(rmap, MAX14577_REG_CHGCTRL7, reg_data); + reg_data = 0x2 << MAXIM_CHGCTRL7_OTPCGHCVS_SHIFT; + max14577_write_reg(rmap, MAXIM_CHG_REG_CHGCTRL7, reg_data); } /* Support property from charger */ diff --git a/drivers/regulator/max14577.c b/drivers/regulator/max14577.c index dc40c5ca4b75..9e5c0bd54684 100644 --- a/drivers/regulator/max14577.c +++ b/drivers/regulator/max14577.c @@ -30,11 +30,11 @@ static int max14577_reg_is_enabled(struct regulator_dev *rdev) switch (rid) { case MAX14577_CHARGER: - max14577_read_reg(rmap, MAX14577_CHG_REG_CHG_CTRL2, ®_data); - if ((reg_data & CHGCTRL2_MBCHOSTEN_MASK) == 0) + max14577_read_reg(rmap, MAXIM_CHG_REG_CHGCTRL2, ®_data); + if ((reg_data & MAXIM_CHGCTRL2_MBCHOSTEN_MASK) == 0) return 0; - max14577_read_reg(rmap, MAX14577_CHG_REG_STATUS3, ®_data); - if ((reg_data & STATUS3_CGMBC_MASK) == 0) + max14577_read_reg(rmap, MAXIM_MUIC_REG_STATUS3, ®_data); + if ((reg_data & MAXIM_STATUS3_CGMBC_MASK) == 0) return 0; /* MBCHOSTEN and CGMBC are on */ return 1; @@ -51,13 +51,13 @@ static int max14577_reg_get_current_limit(struct regulator_dev *rdev) if (rdev_get_id(rdev) != MAX14577_CHARGER) return -EINVAL; - max14577_read_reg(rmap, MAX14577_CHG_REG_CHG_CTRL4, ®_data); + max14577_read_reg(rmap, MAXIM_CHG_REG_CHGCTRL4, ®_data); - if ((reg_data & CHGCTRL4_MBCICHWRCL_MASK) == 0) + if ((reg_data & MAXIM_CHGCTRL4_MBCICHWRCL_MASK) == 0) return MAX14577_REGULATOR_CURRENT_LIMIT_MIN; - reg_data = ((reg_data & CHGCTRL4_MBCICHWRCH_MASK) >> - CHGCTRL4_MBCICHWRCH_SHIFT); + reg_data = ((reg_data & MAXIM_CHGCTRL4_MBCICHWRCH_MASK) >> + MAXIM_CHGCTRL4_MBCICHWRCH_SHIFT); return MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START + reg_data * MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP; } @@ -77,10 +77,10 @@ static int max14577_reg_set_current_limit(struct regulator_dev *rdev, if (max_uA < MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START) { /* Less than 200 mA, so set 90mA (turn only Low Bit off) */ - u8 reg_data = 0x0 << CHGCTRL4_MBCICHWRCL_SHIFT; + u8 reg_data = 0x0 << MAXIM_CHGCTRL4_MBCICHWRCL_SHIFT; return max14577_update_reg(rdev->regmap, - MAX14577_CHG_REG_CHG_CTRL4, - CHGCTRL4_MBCICHWRCL_MASK, reg_data); + MAXIM_CHG_REG_CHGCTRL4, + MAXIM_CHGCTRL4_MBCICHWRCL_MASK, reg_data); } /* max_uA is in range: , so search for @@ -94,13 +94,13 @@ static int max14577_reg_set_current_limit(struct regulator_dev *rdev, } BUG_ON(current_bits < 0); /* Cannot happen */ /* Turn Low Bit on (use range 200mA-950 mA) */ - reg_data = 0x1 << CHGCTRL4_MBCICHWRCL_SHIFT; + reg_data = 0x1 << MAXIM_CHGCTRL4_MBCICHWRCL_SHIFT; /* and set proper High Bits */ - reg_data |= current_bits << CHGCTRL4_MBCICHWRCH_SHIFT; + reg_data |= current_bits << MAXIM_CHGCTRL4_MBCICHWRCH_SHIFT; - return max14577_update_reg(rdev->regmap, MAX14577_CHG_REG_CHG_CTRL4, - CHGCTRL4_MBCICHWRCL_MASK | CHGCTRL4_MBCICHWRCH_MASK, - reg_data); + return max14577_update_reg(rdev->regmap, MAXIM_CHG_REG_CHGCTRL4, + MAXIM_CHGCTRL4_MBCICHWRCL_MASK | MAXIM_CHGCTRL4_MBCICHWRCH_MASK, + reg_data); } static struct regulator_ops max14577_safeout_ops = { @@ -127,8 +127,8 @@ static const struct regulator_desc supported_regulators[] = { .owner = THIS_MODULE, .n_voltages = 1, .min_uV = MAX14577_REGULATOR_SAFEOUT_VOLTAGE, - .enable_reg = MAX14577_REG_CONTROL2, - .enable_mask = CTRL2_SFOUTORD_MASK, + .enable_reg = MAXIM_MUIC_REG_CONTROL2, + .enable_mask = MAXIM_CONTROL2_SFOUTORD_MASK, }, [MAX14577_CHARGER] = { .name = "CHARGER", @@ -136,8 +136,8 @@ static const struct regulator_desc supported_regulators[] = { .ops = &max14577_charger_ops, .type = REGULATOR_CURRENT, .owner = THIS_MODULE, - .enable_reg = MAX14577_CHG_REG_CHG_CTRL2, - .enable_mask = CHGCTRL2_MBCHOSTEN_MASK, + .enable_reg = MAXIM_CHG_REG_CHGCTRL2, + .enable_mask = MAXIM_CHGCTRL2_MBCHOSTEN_MASK, }, }; @@ -159,7 +159,7 @@ static int max14577_regulator_dt_parse_pdata(struct platform_device *pdev) } ret = of_regulator_match(&pdev->dev, np, max14577_regulator_matches, - MAX14577_REG_MAX); + MAX14577_REG_NUM); if (ret < 0) { dev_err(&pdev->dev, "Error parsing regulator init data: %d\n", ret); } @@ -250,7 +250,7 @@ static int __init max14577_regulator_init(void) BUILD_BUG_ON(MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START + MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP * 0xf != MAX14577_REGULATOR_CURRENT_LIMIT_MAX); - BUILD_BUG_ON(ARRAY_SIZE(supported_regulators) != MAX14577_REG_MAX); + BUILD_BUG_ON(ARRAY_SIZE(supported_regulators) != MAX14577_REG_NUM); return platform_driver_register(&max14577_regulator_driver); } diff --git a/include/linux/mfd/max14577-private.h b/include/linux/mfd/max14577-private.h index c9b332fb0d5d..9f5ce26cb54e 100644 --- a/include/linux/mfd/max14577-private.h +++ b/include/linux/mfd/max14577-private.h @@ -22,224 +22,199 @@ #include #include -#define MAX14577_REG_INVALID (0xff) - -/* Slave addr = 0x4A: Interrupt */ -enum max14577_reg { - MAX14577_REG_DEVICEID = 0x00, - MAX14577_REG_INT1 = 0x01, - MAX14577_REG_INT2 = 0x02, - MAX14577_REG_INT3 = 0x03, - MAX14577_REG_STATUS1 = 0x04, - MAX14577_REG_STATUS2 = 0x05, - MAX14577_REG_STATUS3 = 0x06, - MAX14577_REG_INTMASK1 = 0x07, - MAX14577_REG_INTMASK2 = 0x08, - MAX14577_REG_INTMASK3 = 0x09, - MAX14577_REG_CDETCTRL1 = 0x0A, - MAX14577_REG_RFU = 0x0B, - MAX14577_REG_CONTROL1 = 0x0C, - MAX14577_REG_CONTROL2 = 0x0D, - MAX14577_REG_CONTROL3 = 0x0E, - MAX14577_REG_CHGCTRL1 = 0x0F, - MAX14577_REG_CHGCTRL2 = 0x10, - MAX14577_REG_CHGCTRL3 = 0x11, - MAX14577_REG_CHGCTRL4 = 0x12, - MAX14577_REG_CHGCTRL5 = 0x13, - MAX14577_REG_CHGCTRL6 = 0x14, - MAX14577_REG_CHGCTRL7 = 0x15, - - MAX14577_REG_END, +/* Slave addr = 0x4A: MUIC and Charger */ +enum maxim_muic_reg { + MAXIM_MUIC_REG_DEVICEID = 0x00, + MAXIM_MUIC_REG_INT1 = 0x01, + MAXIM_MUIC_REG_INT2 = 0x02, + MAXIM_MUIC_REG_INT3 = 0x03, + MAXIM_MUIC_REG_STATUS1 = 0x04, + MAXIM_MUIC_REG_STATUS2 = 0x05, + MAXIM_MUIC_REG_STATUS3 = 0x06, + MAXIM_MUIC_REG_INTMASK1 = 0x07, + MAXIM_MUIC_REG_INTMASK2 = 0x08, + MAXIM_MUIC_REG_INTMASK3 = 0x09, + MAXIM_MUIC_REG_CDETCTRL1 = 0x0A, + MAXIM_MUIC_REG_RFU = 0x0B, + MAXIM_MUIC_REG_CONTROL1 = 0x0C, + MAXIM_MUIC_REG_CONTROL2 = 0x0D, + MAXIM_MUIC_REG_CONTROL3 = 0x0E, + MAXIM_CHG_REG_CHGCTRL1 = 0x0F, + MAXIM_CHG_REG_CHGCTRL2 = 0x10, + MAXIM_CHG_REG_CHGCTRL3 = 0x11, + MAXIM_CHG_REG_CHGCTRL4 = 0x12, + MAXIM_CHG_REG_CHGCTRL5 = 0x13, + MAXIM_CHG_REG_CHGCTRL6 = 0x14, + MAXIM_CHG_REG_CHGCTRL7 = 0x15, + + MAXIM_MUIC_REG_END, }; -/* Slave addr = 0x4A: MUIC */ -enum max14577_muic_reg { - MAX14577_MUIC_REG_STATUS1 = 0x04, - MAX14577_MUIC_REG_STATUS2 = 0x05, - MAX14577_MUIC_REG_CONTROL1 = 0x0C, - MAX14577_MUIC_REG_CONTROL3 = 0x0E, - - MAX14577_MUIC_REG_END, -}; - -enum max14577_muic_charger_type { - MAX14577_CHARGER_TYPE_NONE = 0, - MAX14577_CHARGER_TYPE_USB, - MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT, - MAX14577_CHARGER_TYPE_DEDICATED_CHG, - MAX14577_CHARGER_TYPE_SPECIAL_500MA, - MAX14577_CHARGER_TYPE_SPECIAL_1A, - MAX14577_CHARGER_TYPE_RESERVED, - MAX14577_CHARGER_TYPE_DEAD_BATTERY = 7, +enum maxim_muic_charger_type { + MAXIM_CHARGER_TYPE_NONE = 0, + MAXIM_CHARGER_TYPE_USB, + MAXIM_CHARGER_TYPE_DOWNSTREAM_PORT, + MAXIM_CHARGER_TYPE_DEDICATED_CHG, + MAXIM_CHARGER_TYPE_SPECIAL_500MA, + MAXIM_CHARGER_TYPE_SPECIAL_1A, + MAXIM_CHARGER_TYPE_RESERVED, + MAXIM_CHARGER_TYPE_DEAD_BATTERY = 7, }; /* MAX14577 interrupts */ -#define INT1_ADC_MASK (0x1 << 0) -#define INT1_ADCLOW_MASK (0x1 << 1) -#define INT1_ADCERR_MASK (0x1 << 2) +#define MAXIM_INT1_ADC_MASK (0x1 << 0) +#define MAXIM_INT1_ADCLOW_MASK (0x1 << 1) +#define MAXIM_INT1_ADCERR_MASK (0x1 << 2) -#define INT2_CHGTYP_MASK (0x1 << 0) -#define INT2_CHGDETRUN_MASK (0x1 << 1) -#define INT2_DCDTMR_MASK (0x1 << 2) -#define INT2_DBCHG_MASK (0x1 << 3) -#define INT2_VBVOLT_MASK (0x1 << 4) +#define MAXIM_INT2_CHGTYP_MASK (0x1 << 0) +#define MAXIM_INT2_CHGDETRUN_MASK (0x1 << 1) +#define MAXIM_INT2_DCDTMR_MASK (0x1 << 2) +#define MAXIM_INT2_DBCHG_MASK (0x1 << 3) +#define MAXIM_INT2_VBVOLT_MASK (0x1 << 4) -#define INT3_EOC_MASK (0x1 << 0) -#define INT3_CGMBC_MASK (0x1 << 1) -#define INT3_OVP_MASK (0x1 << 2) -#define INT3_MBCCHGERR_MASK (0x1 << 3) +#define MAXIM_INT3_EOC_MASK (0x1 << 0) +#define MAXIM_INT3_CGMBC_MASK (0x1 << 1) +#define MAXIM_INT3_OVP_MASK (0x1 << 2) +#define MAXIM_INT3_MBCCHGERR_MASK (0x1 << 3) /* MAX14577 DEVICE ID register */ -#define DEVID_VENDORID_SHIFT 0 -#define DEVID_DEVICEID_SHIFT 3 -#define DEVID_VENDORID_MASK (0x07 << DEVID_VENDORID_SHIFT) -#define DEVID_DEVICEID_MASK (0x1f << DEVID_DEVICEID_SHIFT) +#define MAXIM_DEVID_VENDORID_SHIFT 0 +#define MAXIM_DEVID_DEVICEID_SHIFT 3 +#define MAXIM_DEVID_VENDORID_MASK (0x07 << MAXIM_DEVID_VENDORID_SHIFT) +#define MAXIM_DEVID_DEVICEID_MASK (0x1f << MAXIM_DEVID_DEVICEID_SHIFT) /* MAX14577 STATUS1 register */ -#define STATUS1_ADC_SHIFT 0 -#define STATUS1_ADCLOW_SHIFT 5 -#define STATUS1_ADCERR_SHIFT 6 -#define STATUS1_ADC_MASK (0x1f << STATUS1_ADC_SHIFT) -#define STATUS1_ADCLOW_MASK (0x1 << STATUS1_ADCLOW_SHIFT) -#define STATUS1_ADCERR_MASK (0x1 << STATUS1_ADCERR_SHIFT) +#define MAXIM_STATUS1_ADC_SHIFT 0 +#define MAXIM_STATUS1_ADCLOW_SHIFT 5 +#define MAXIM_STATUS1_ADCERR_SHIFT 6 +#define MAXIM_STATUS1_ADC_MASK (0x1f << MAXIM_STATUS1_ADC_SHIFT) +#define MAXIM_STATUS1_ADCLOW_MASK (0x1 << MAXIM_STATUS1_ADCLOW_SHIFT) +#define MAXIM_STATUS1_ADCERR_MASK (0x1 << MAXIM_STATUS1_ADCERR_SHIFT) /* MAX14577 STATUS2 register */ -#define STATUS2_CHGTYP_SHIFT 0 -#define STATUS2_CHGDETRUN_SHIFT 3 -#define STATUS2_DCDTMR_SHIFT 4 -#define STATUS2_DBCHG_SHIFT 5 -#define STATUS2_VBVOLT_SHIFT 6 -#define STATUS2_CHGTYP_MASK (0x7 << STATUS2_CHGTYP_SHIFT) -#define STATUS2_CHGDETRUN_MASK (0x1 << STATUS2_CHGDETRUN_SHIFT) -#define STATUS2_DCDTMR_MASK (0x1 << STATUS2_DCDTMR_SHIFT) -#define STATUS2_DBCHG_MASK (0x1 << STATUS2_DBCHG_SHIFT) -#define STATUS2_VBVOLT_MASK (0x1 << STATUS2_VBVOLT_SHIFT) +#define MAXIM_STATUS2_CHGTYP_SHIFT 0 +#define MAXIM_STATUS2_CHGDETRUN_SHIFT 3 +#define MAXIM_STATUS2_DCDTMR_SHIFT 4 +#define MAXIM_STATUS2_DBCHG_SHIFT 5 +#define MAXIM_STATUS2_VBVOLT_SHIFT 6 +#define MAXIM_STATUS2_CHGTYP_MASK (0x7 << MAXIM_STATUS2_CHGTYP_SHIFT) +#define MAXIM_STATUS2_CHGDETRUN_MASK (0x1 << MAXIM_STATUS2_CHGDETRUN_SHIFT) +#define MAXIM_STATUS2_DCDTMR_MASK (0x1 << MAXIM_STATUS2_DCDTMR_SHIFT) +#define MAXIM_STATUS2_DBCHG_MASK (0x1 << MAXIM_STATUS2_DBCHG_SHIFT) +#define MAXIM_STATUS2_VBVOLT_MASK (0x1 << MAXIM_STATUS2_VBVOLT_SHIFT) + +/* MAX14577 STATUS3 register */ +#define MAXIM_STATUS3_EOC_SHIFT 0 +#define MAXIM_STATUS3_CGMBC_SHIFT 1 +#define MAXIM_STATUS3_OVP_SHIFT 2 +#define MAXIM_STATUS3_MBCCHGERR_SHIFT 3 +#define MAXIM_STATUS3_EOC_MASK (0x1 << MAXIM_STATUS3_EOC_SHIFT) +#define MAXIM_STATUS3_CGMBC_MASK (0x1 << MAXIM_STATUS3_CGMBC_SHIFT) +#define MAXIM_STATUS3_OVP_MASK (0x1 << MAXIM_STATUS3_OVP_SHIFT) +#define MAXIM_STATUS3_MBCCHGERR_MASK (0x1 << MAXIM_STATUS3_MBCCHGERR_SHIFT) /* MAX14577 CONTROL1 register */ -#define COMN1SW_SHIFT 0 -#define COMP2SW_SHIFT 3 -#define MICEN_SHIFT 6 -#define IDBEN_SHIFT 7 -#define COMN1SW_MASK (0x7 << COMN1SW_SHIFT) -#define COMP2SW_MASK (0x7 << COMP2SW_SHIFT) -#define MICEN_MASK (0x1 << MICEN_SHIFT) -#define IDBEN_MASK (0x1 << IDBEN_SHIFT) -#define CLEAR_IDBEN_MICEN_MASK (COMN1SW_MASK | COMP2SW_MASK) -#define CTRL1_SW_USB ((1 << COMP2SW_SHIFT) \ - | (1 << COMN1SW_SHIFT)) -#define CTRL1_SW_AUDIO ((2 << COMP2SW_SHIFT) \ - | (2 << COMN1SW_SHIFT)) -#define CTRL1_SW_UART ((3 << COMP2SW_SHIFT) \ - | (3 << COMN1SW_SHIFT)) -#define CTRL1_SW_OPEN ((0 << COMP2SW_SHIFT) \ - | (0 << COMN1SW_SHIFT)) +#define MAXIM_CONTROL1_COMN1SW_SHIFT 0 +#define MAXIM_CONTROL1_COMP2SW_SHIFT 3 +#define MAXIM_CONTROL1_MICEN_SHIFT 6 +#define MAXIM_CONTROL1_IDBEN_SHIFT 7 +#define MAXIM_CONTROL1_COMN1SW_MASK (0x7 << MAXIM_CONTROL1_COMN1SW_SHIFT) +#define MAXIM_CONTROL1_COMP2SW_MASK (0x7 << MAXIM_CONTROL1_COMP2SW_SHIFT) +#define MAXIM_CONTROL1_MICEN_MASK (0x1 << MAXIM_CONTROL1_MICEN_SHIFT) +#define MAXIM_CONTROL1_IDBEN_MASK (0x1 << MAXIM_CONTROL1_IDBEN_SHIFT) + +#define MAXIM_CONTROL1_CLEAR_IDBEN_MICEN_MASK (MAXIM_CONTROL1_COMN1SW_MASK | MAXIM_CONTROL1_COMP2SW_MASK) +#define MAXIM_CONTROL1_SW_USB ((1 << MAXIM_CONTROL1_COMP2SW_SHIFT) \ + | (1 << MAXIM_CONTROL1_COMN1SW_SHIFT)) +#define MAXIM_CONTROL1_SW_AUDIO ((2 << MAXIM_CONTROL1_COMP2SW_SHIFT) \ + | (2 << MAXIM_CONTROL1_COMN1SW_SHIFT)) +#define MAXIM_CONTROL1_SW_UART ((3 << MAXIM_CONTROL1_COMP2SW_SHIFT) \ + | (3 << MAXIM_CONTROL1_COMN1SW_SHIFT)) +#define MAXIM_CONTROL1_SW_OPEN ((0 << MAXIM_CONTROL1_COMP2SW_SHIFT) \ + | (0 << MAXIM_CONTROL1_COMN1SW_SHIFT)) /* MAX14577 CONTROL2 register */ -#define CTRL2_LOWPWR_SHIFT (0) -#define CTRL2_ADCEN_SHIFT (1) -#define CTRL2_CPEN_SHIFT (2) -#define CTRL2_SFOUTASRT_SHIFT (3) -#define CTRL2_SFOUTORD_SHIFT (4) -#define CTRL2_ACCDET_SHIFT (5) -#define CTRL2_USBCPINT_SHIFT (6) -#define CTRL2_RCPS_SHIFT (7) -#define CTRL2_LOWPWR_MASK (0x1 << CTRL2_LOWPWR_SHIFT) -#define CTRL2_ADCEN_MASK (0x1 << CTRL2_ADCEN_SHIFT) -#define CTRL2_CPEN_MASK (0x1 << CTRL2_CPEN_SHIFT) -#define CTRL2_SFOUTASRT_MASK (0x1 << CTRL2_SFOUTASRT_SHIFT) -#define CTRL2_SFOUTORD_MASK (0x1 << CTRL2_SFOUTORD_SHIFT) -#define CTRL2_ACCDET_MASK (0x1 << CTRL2_ACCDET_SHIFT) -#define CTRL2_USBCPINT_MASK (0x1 << CTRL2_USBCPINT_SHIFT) -#define CTRL2_RCPS_MASK (0x1 << CTR2_RCPS_SHIFT) - -#define CTRL2_CPEN1_LOWPWR0 ((1 << CTRL2_CPEN_SHIFT) | \ - (0 << CTRL2_LOWPWR_SHIFT)) -#define CTRL2_CPEN0_LOWPWR1 ((0 << CTRL2_CPEN_SHIFT) | \ - (1 << CTRL2_LOWPWR_SHIFT)) +#define MAXIM_CONTROL2_LOWPWR_SHIFT 0 +#define MAXIM_CONTROL2_ADCEN_SHIFT 1 +#define MAXIM_CONTROL2_CPEN_SHIFT 2 +#define MAXIM_CONTROL2_SFOUTASRT_SHIFT 3 +#define MAXIM_CONTROL2_SFOUTORD_SHIFT 4 +#define MAXIM_CONTROL2_ACCDET_SHIFT 5 +#define MAXIM_CONTROL2_USBCPINT_SHIFT 6 +#define MAXIM_CONTROL2_RCPS_SHIFT 7 +#define MAXIM_CONTROL2_LOWPWR_MASK (0x1 << MAXIM_CONTROL2_LOWPWR_SHIFT) +#define MAXIM_CONTROL2_ADCEN_MASK (0x1 << MAXIM_CONTROL2_ADCEN_SHIFT) +#define MAXIM_CONTROL2_CPEN_MASK (0x1 << MAXIM_CONTROL2_CPEN_SHIFT) +#define MAXIM_CONTROL2_SFOUTASRT_MASK (0x1 << MAXIM_CONTROL2_SFOUTASRT_SHIFT) +#define MAXIM_CONTROL2_SFOUTORD_MASK (0x1 << MAXIM_CONTROL2_SFOUTORD_SHIFT) +#define MAXIM_CONTROL2_ACCDET_MASK (0x1 << MAXIM_CONTROL2_ACCDET_SHIFT) +#define MAXIM_CONTROL2_USBCPINT_MASK (0x1 << MAXIM_CONTROL2_USBCPINT_SHIFT) +#define MAXIM_CONTROL2_RCPS_MASK (0x1 << MAXIM_CONTROL2_RCPS_SHIFT) + +#define MAXIM_CONTROL2_CPEN1_LOWPWR0 ((1 << MAXIM_CONTROL2_CPEN_SHIFT) | \ + (0 << MAXIM_CONTROL2_LOWPWR_SHIFT)) +#define MAXIM_CONTROL2_CPEN0_LOWPWR1 ((0 << MAXIM_CONTROL2_CPEN_SHIFT) | \ + (1 << MAXIM_CONTROL2_LOWPWR_SHIFT)) /* MAX14577 CONTROL3 register */ -#define CTRL3_JIGSET_SHIFT 0 -#define CTRL3_BOOTSET_SHIFT 2 -#define CTRL3_ADCDBSET_SHIFT 4 -#define CTRL3_JIGSET_MASK (0x3 << CTRL3_JIGSET_SHIFT) -#define CTRL3_BOOTSET_MASK (0x3 << CTRL3_BOOTSET_SHIFT) -#define CTRL3_ADCDBSET_MASK (0x3 << CTRL3_ADCDBSET_SHIFT) - -/* Slave addr = 0x4A: Charger */ -enum max14577_charger_reg { - MAX14577_CHG_REG_STATUS3 = 0x06, - MAX14577_CHG_REG_CHG_CTRL1 = 0x0F, - MAX14577_CHG_REG_CHG_CTRL2 = 0x10, - MAX14577_CHG_REG_CHG_CTRL3 = 0x11, - MAX14577_CHG_REG_CHG_CTRL4 = 0x12, - MAX14577_CHG_REG_CHG_CTRL5 = 0x13, - MAX14577_CHG_REG_CHG_CTRL6 = 0x14, - MAX14577_CHG_REG_CHG_CTRL7 = 0x15, - - MAX14577_CHG_REG_END, -}; - -/* MAX14577 STATUS3 register */ -#define STATUS3_EOC_SHIFT 0 -#define STATUS3_CGMBC_SHIFT 1 -#define STATUS3_OVP_SHIFT 2 -#define STATUS3_MBCCHGERR_SHIFT 3 -#define STATUS3_EOC_MASK (0x1 << STATUS3_EOC_SHIFT) -#define STATUS3_CGMBC_MASK (0x1 << STATUS3_CGMBC_SHIFT) -#define STATUS3_OVP_MASK (0x1 << STATUS3_OVP_SHIFT) -#define STATUS3_MBCCHGERR_MASK (0x1 << STATUS3_MBCCHGERR_SHIFT) +#define MAXIM_CONTROL3_JIGSET_SHIFT 0 +#define MAXIM_CONTROL3_BOOTSET_SHIFT 2 +#define MAXIM_CONTROL3_ADCDBSET_SHIFT 4 +#define MAXIM_CONTROL3_JIGSET_MASK (0x3 << MAXIM_CONTROL3_JIGSET_SHIFT) +#define MAXIM_CONTROL3_BOOTSET_MASK (0x3 << MAXIM_CONTROL3_BOOTSET_SHIFT) +#define MAXIM_CONTROL3_ADCDBSET_MASK (0x3 << MAXIM_CONTROL3_ADCDBSET_SHIFT) /* MAX14577 CDETCTRL1 register */ -#define CDETCTRL1_CHGDETEN_SHIFT 0 -#define CDETCTRL1_CHGTYPMAN_SHIFT 1 -#define CDETCTRL1_DCDEN_SHIFT 2 -#define CDETCTRL1_DCD2SCT_SHIFT 3 -#define CDETCTRL1_DCHKTM_SHIFT 4 -#define CDETCTRL1_DBEXIT_SHIFT 5 -#define CDETCTRL1_DBIDLE_SHIFT 6 -#define CDETCTRL1_CDPDET_SHIFT 7 -#define CDETCTRL1_CHGDETEN_MASK (0x1 << CDETCTRL1_CHGDETEN_SHIFT) -#define CDETCTRL1_CHGTYPMAN_MASK (0x1 << CDETCTRL1_CHGTYPMAN_SHIFT) -#define CDETCTRL1_DCDEN_MASK (0x1 << CDETCTRL1_DCDEN_SHIFT) -#define CDETCTRL1_DCD2SCT_MASK (0x1 << CDETCTRL1_DCD2SCT_SHIFT) -#define CDETCTRL1_DCHKTM_MASK (0x1 << CDETCTRL1_DCHKTM_SHIFT) -#define CDETCTRL1_DBEXIT_MASK (0x1 << CDETCTRL1_DBEXIT_SHIFT) -#define CDETCTRL1_DBIDLE_MASK (0x1 << CDETCTRL1_DBIDLE_SHIFT) -#define CDETCTRL1_CDPDET_MASK (0x1 << CDETCTRL1_CDPDET_SHIFT) - -/* MAX14577 CHGCTRL1 register */ -#define CHGCTRL1_TCHW_SHIFT 4 -#define CHGCTRL1_TCHW_MASK (0x7 << CHGCTRL1_TCHW_SHIFT) - -/* MAX14577 CHGCTRL2 register */ -#define CHGCTRL2_MBCHOSTEN_SHIFT 6 -#define CHGCTRL2_MBCHOSTEN_MASK (0x1 << CHGCTRL2_MBCHOSTEN_SHIFT) -#define CHGCTRL2_VCHGR_RC_SHIFT 7 -#define CHGCTRL2_VCHGR_RC_MASK (0x1 << CHGCTRL2_VCHGR_RC_SHIFT) - -/* MAX14577 CHGCTRL3 register */ -#define CHGCTRL3_MBCCVWRC_SHIFT 0 -#define CHGCTRL3_MBCCVWRC_MASK (0xf << CHGCTRL3_MBCCVWRC_SHIFT) - -/* MAX14577 CHGCTRL4 register */ -#define CHGCTRL4_MBCICHWRCH_SHIFT 0 -#define CHGCTRL4_MBCICHWRCH_MASK (0xf << CHGCTRL4_MBCICHWRCH_SHIFT) -#define CHGCTRL4_MBCICHWRCL_SHIFT 4 -#define CHGCTRL4_MBCICHWRCL_MASK (0x1 << CHGCTRL4_MBCICHWRCL_SHIFT) - -/* MAX14577 CHGCTRL5 register */ -#define CHGCTRL5_EOCS_SHIFT 0 -#define CHGCTRL5_EOCS_MASK (0xf << CHGCTRL5_EOCS_SHIFT) - -/* MAX14577 CHGCTRL6 register */ -#define CHGCTRL6_AUTOSTOP_SHIFT 5 -#define CHGCTRL6_AUTOSTOP_MASK (0x1 << CHGCTRL6_AUTOSTOP_SHIFT) - -/* MAX14577 CHGCTRL7 register */ -#define CHGCTRL7_OTPCGHCVS_SHIFT 0 -#define CHGCTRL7_OTPCGHCVS_MASK (0x3 << CHGCTRL7_OTPCGHCVS_SHIFT) - -/* MAX14577 regulator current limits (as in CHGCTRL4 register), uA */ +#define MAXIM_CDETCTRL1_CHGDETEN_SHIFT 0 +#define MAXIM_CDETCTRL1_CHGTYPMAN_SHIFT 1 +#define MAXIM_CDETCTRL1_DCDEN_SHIFT 2 +#define MAXIM_CDETCTRL1_DCD2SCT_SHIFT 3 +#define MAXIM_CDETCTRL1_DCHKTM_SHIFT 4 +#define MAXIM_CDETCTRL1_DBEXIT_SHIFT 5 +#define MAXIM_CDETCTRL1_DBIDLE_SHIFT 6 +#define MAXIM_CDETCTRL1_CDPDET_SHIFT 7 +#define MAXIM_CDETCTRL1_CHGDETEN_MASK (0x1 << MAXIM_CDETCTRL1_CHGDETEN_SHIFT) +#define MAXIM_CDETCTRL1_CHGTYPMAN_MASK (0x1 << MAXIM_CDETCTRL1_CHGTYPMAN_SHIFT) +#define MAXIM_CDETCTRL1_DCDEN_MASK (0x1 << MAXIM_CDETCTRL1_DCDEN_SHIFT) +#define MAXIM_CDETCTRL1_DCD2SCT_MASK (0x1 << MAXIM_CDETCTRL1_DCD2SCT_SHIFT) +#define MAXIM_CDETCTRL1_DCHKTM_MASK (0x1 << MAXIM_CDETCTRL1_DCHKTM_SHIFT) +#define MAXIM_CDETCTRL1_DBEXIT_MASK (0x1 << MAXIM_CDETCTRL1_DBEXIT_SHIFT) +#define MAXIM_CDETCTRL1_DBIDLE_MASK (0x1 << MAXIM_CDETCTRL1_DBIDLE_SHIFT) +#define MAXIM_CDETCTRL1_CDPDET_MASK (0x1 << MAXIM_CDETCTRL1_CDPDET_SHIFT) + +/* MAX14577 MAXIM_CHGCTRL1 register */ +#define MAXIM_CHGCTRL1_TCHW_SHIFT 4 +#define MAXIM_CHGCTRL1_TCHW_MASK (0x7 << MAXIM_CHGCTRL1_TCHW_SHIFT) + +/* MAX14577 MAXIM_CHGCTRL2 register */ +#define MAXIM_CHGCTRL2_MBCHOSTEN_SHIFT 6 +#define MAXIM_CHGCTRL2_MBCHOSTEN_MASK (0x1 << MAXIM_CHGCTRL2_MBCHOSTEN_SHIFT) +#define MAXIM_CHGCTRL2_VCHGR_RC_SHIFT 7 +#define MAXIM_CHGCTRL2_VCHGR_RC_MASK (0x1 << MAXIM_CHGCTRL2_VCHGR_RC_SHIFT) + +/* MAX14577 MAXIM_CHGCTRL3 register */ +#define MAXIM_CHGCTRL3_MBCCVWRC_SHIFT 0 +#define MAXIM_CHGCTRL3_MBCCVWRC_MASK (0xf << MAXIM_CHGCTRL3_MBCCVWRC_SHIFT) + +/* MAX14577 MAXIM_CHGCTRL4 register */ +#define MAXIM_CHGCTRL4_MBCICHWRCH_SHIFT 0 +#define MAXIM_CHGCTRL4_MBCICHWRCH_MASK (0xf << MAXIM_CHGCTRL4_MBCICHWRCH_SHIFT) +#define MAXIM_CHGCTRL4_MBCICHWRCL_SHIFT 4 +#define MAXIM_CHGCTRL4_MBCICHWRCL_MASK (0x1 << MAXIM_CHGCTRL4_MBCICHWRCL_SHIFT) + +/* MAX14577 MAXIM_CHGCTRL5 register */ +#define MAXIM_CHGCTRL5_EOCS_SHIFT 0 +#define MAXIM_CHGCTRL5_EOCS_MASK (0xf << MAXIM_CHGCTRL5_EOCS_SHIFT) + +/* MAX14577 MAXIM_CHGCTRL6 register */ +#define MAXIM_CHGCTRL6_AUTOSTOP_SHIFT 5 +#define MAXIM_CHGCTRL6_AUTOSTOP_MASK (0x1 << MAXIM_CHGCTRL6_AUTOSTOP_SHIFT) + +/* MAX14577 MAXIM_CHGCTRL7 register */ +#define MAXIM_CHGCTRL7_OTPCGHCVS_SHIFT 0 +#define MAXIM_CHGCTRL7_OTPCGHCVS_MASK (0x3 << MAXIM_CHGCTRL7_OTPCGHCVS_SHIFT) + +/* MAX14577 regulator current limits (as in MAXIM_CHGCTRL4 register), uA */ #define MAX14577_REGULATOR_CURRENT_LIMIT_MIN 90000 #define MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START 200000 #define MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP 50000 @@ -248,26 +223,28 @@ enum max14577_charger_reg { /* MAX14577 regulator SFOUT LDO voltage, fixed, uV */ #define MAX14577_REGULATOR_SAFEOUT_VOLTAGE 4900000 -enum max14577_irq { + + +enum maxim_irq { /* INT1 */ - MAX14577_IRQ_INT1_ADC, - MAX14577_IRQ_INT1_ADCLOW, - MAX14577_IRQ_INT1_ADCERR, + MAXIM_IRQ_INT1_ADC, + MAXIM_IRQ_INT1_ADCLOW, + MAXIM_IRQ_INT1_ADCERR, /* INT2 */ - MAX14577_IRQ_INT2_CHGTYP, - MAX14577_IRQ_INT2_CHGDETRUN, - MAX14577_IRQ_INT2_DCDTMR, - MAX14577_IRQ_INT2_DBCHG, - MAX14577_IRQ_INT2_VBVOLT, + MAXIM_IRQ_INT2_CHGTYP, + MAXIM_IRQ_INT2_CHGDETRUN, + MAXIM_IRQ_INT2_DCDTMR, + MAXIM_IRQ_INT2_DBCHG, + MAXIM_IRQ_INT2_VBVOLT, /* INT3 */ - MAX14577_IRQ_INT3_EOC, - MAX14577_IRQ_INT3_CGMBC, - MAX14577_IRQ_INT3_OVP, - MAX14577_IRQ_INT3_MBCCHGERR, + MAXIM_IRQ_INT3_EOC, + MAXIM_IRQ_INT3_CGMBC, + MAXIM_IRQ_INT3_OVP, + MAXIM_IRQ_INT3_MBCCHGERR, - MAX14577_IRQ_NUM, + MAXIM_IRQ_NUM, }; struct max14577 { diff --git a/include/linux/mfd/max14577.h b/include/linux/mfd/max14577.h index 736d39c3ec0d..75301be5c548 100644 --- a/include/linux/mfd/max14577.h +++ b/include/linux/mfd/max14577.h @@ -32,7 +32,7 @@ enum max14577_regulators { MAX14577_SAFEOUT = 0, MAX14577_CHARGER, - MAX14577_REG_MAX, + MAX14577_REG_NUM, }; struct max14577_regulator_platform_data {