Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * wm8350-core.c  --  Device access for Wolfson WM8350
0004  *
0005  * Copyright 2007, 2008 Wolfson Microelectronics PLC.
0006  *
0007  * Author: Liam Girdwood, Mark Brown
0008  */
0009 
0010 #include <linux/kernel.h>
0011 #include <linux/init.h>
0012 #include <linux/export.h>
0013 #include <linux/slab.h>
0014 #include <linux/bug.h>
0015 #include <linux/device.h>
0016 #include <linux/delay.h>
0017 #include <linux/interrupt.h>
0018 #include <linux/regmap.h>
0019 #include <linux/workqueue.h>
0020 
0021 #include <linux/mfd/wm8350/core.h>
0022 #include <linux/mfd/wm8350/audio.h>
0023 #include <linux/mfd/wm8350/comparator.h>
0024 #include <linux/mfd/wm8350/gpio.h>
0025 #include <linux/mfd/wm8350/pmic.h>
0026 #include <linux/mfd/wm8350/rtc.h>
0027 #include <linux/mfd/wm8350/supply.h>
0028 #include <linux/mfd/wm8350/wdt.h>
0029 
0030 #define WM8350_CLOCK_CONTROL_1      0x28
0031 #define WM8350_AIF_TEST         0x74
0032 
0033 /* debug */
0034 #define WM8350_BUS_DEBUG 0
0035 #if WM8350_BUS_DEBUG
0036 #define dump(regs, src) do { \
0037     int i_; \
0038     u16 *src_ = src; \
0039     printk(KERN_DEBUG); \
0040     for (i_ = 0; i_ < regs; i_++) \
0041         printk(" 0x%4.4x", *src_++); \
0042     printk("\n"); \
0043 } while (0);
0044 #else
0045 #define dump(bytes, src)
0046 #endif
0047 
0048 #define WM8350_LOCK_DEBUG 0
0049 #if WM8350_LOCK_DEBUG
0050 #define ldbg(format, arg...) printk(format, ## arg)
0051 #else
0052 #define ldbg(format, arg...)
0053 #endif
0054 
0055 /*
0056  * WM8350 Device IO
0057  */
0058 static DEFINE_MUTEX(reg_lock_mutex);
0059 
0060 /*
0061  * Safe read, modify, write methods
0062  */
0063 int wm8350_clear_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
0064 {
0065     return regmap_update_bits(wm8350->regmap, reg, mask, 0);
0066 }
0067 EXPORT_SYMBOL_GPL(wm8350_clear_bits);
0068 
0069 int wm8350_set_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
0070 {
0071     return regmap_update_bits(wm8350->regmap, reg, mask, mask);
0072 }
0073 EXPORT_SYMBOL_GPL(wm8350_set_bits);
0074 
0075 u16 wm8350_reg_read(struct wm8350 *wm8350, int reg)
0076 {
0077     unsigned int data;
0078     int err;
0079 
0080     err = regmap_read(wm8350->regmap, reg, &data);
0081     if (err)
0082         dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
0083 
0084     return data;
0085 }
0086 EXPORT_SYMBOL_GPL(wm8350_reg_read);
0087 
0088 int wm8350_reg_write(struct wm8350 *wm8350, int reg, u16 val)
0089 {
0090     int ret;
0091 
0092     ret = regmap_write(wm8350->regmap, reg, val);
0093 
0094     if (ret)
0095         dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
0096     return ret;
0097 }
0098 EXPORT_SYMBOL_GPL(wm8350_reg_write);
0099 
0100 int wm8350_block_read(struct wm8350 *wm8350, int start_reg, int regs,
0101               u16 *dest)
0102 {
0103     int err = 0;
0104 
0105     err = regmap_bulk_read(wm8350->regmap, start_reg, dest, regs);
0106     if (err)
0107         dev_err(wm8350->dev, "block read starting from R%d failed\n",
0108             start_reg);
0109 
0110     return err;
0111 }
0112 EXPORT_SYMBOL_GPL(wm8350_block_read);
0113 
0114 int wm8350_block_write(struct wm8350 *wm8350, int start_reg, int regs,
0115                u16 *src)
0116 {
0117     int ret = 0;
0118 
0119     ret = regmap_bulk_write(wm8350->regmap, start_reg, src, regs);
0120     if (ret)
0121         dev_err(wm8350->dev, "block write starting at R%d failed\n",
0122             start_reg);
0123 
0124     return ret;
0125 }
0126 EXPORT_SYMBOL_GPL(wm8350_block_write);
0127 
0128 /**
0129  * wm8350_reg_lock()
0130  *
0131  * The WM8350 has a hardware lock which can be used to prevent writes to
0132  * some registers (generally those which can cause particularly serious
0133  * problems if misused).  This function enables that lock.
0134  *
0135  * @wm8350: pointer to local driver data structure
0136  */
0137 int wm8350_reg_lock(struct wm8350 *wm8350)
0138 {
0139     int ret;
0140 
0141     mutex_lock(&reg_lock_mutex);
0142 
0143     ldbg(__func__);
0144 
0145     ret = wm8350_reg_write(wm8350, WM8350_SECURITY, WM8350_LOCK_KEY);
0146     if (ret)
0147         dev_err(wm8350->dev, "lock failed\n");
0148 
0149     wm8350->unlocked = false;
0150 
0151     mutex_unlock(&reg_lock_mutex);
0152 
0153     return ret;
0154 }
0155 EXPORT_SYMBOL_GPL(wm8350_reg_lock);
0156 
0157 /**
0158  * wm8350_reg_unlock()
0159  *
0160  * The WM8350 has a hardware lock which can be used to prevent writes to
0161  * some registers (generally those which can cause particularly serious
0162  * problems if misused).  This function disables that lock so updates
0163  * can be performed.  For maximum safety this should be done only when
0164  * required.
0165  *
0166  * @wm8350: pointer to local driver data structure
0167  */
0168 int wm8350_reg_unlock(struct wm8350 *wm8350)
0169 {
0170     int ret;
0171 
0172     mutex_lock(&reg_lock_mutex);
0173 
0174     ldbg(__func__);
0175 
0176     ret = wm8350_reg_write(wm8350, WM8350_SECURITY, WM8350_UNLOCK_KEY);
0177     if (ret)
0178         dev_err(wm8350->dev, "unlock failed\n");
0179 
0180     wm8350->unlocked = true;
0181 
0182     mutex_unlock(&reg_lock_mutex);
0183 
0184     return ret;
0185 }
0186 EXPORT_SYMBOL_GPL(wm8350_reg_unlock);
0187 
0188 int wm8350_read_auxadc(struct wm8350 *wm8350, int channel, int scale, int vref)
0189 {
0190     u16 reg, result = 0;
0191 
0192     if (channel < WM8350_AUXADC_AUX1 || channel > WM8350_AUXADC_TEMP)
0193         return -EINVAL;
0194     if (channel >= WM8350_AUXADC_USB && channel <= WM8350_AUXADC_TEMP
0195         && (scale != 0 || vref != 0))
0196         return -EINVAL;
0197 
0198     mutex_lock(&wm8350->auxadc_mutex);
0199 
0200     /* Turn on the ADC */
0201     reg = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5);
0202     wm8350_reg_write(wm8350, WM8350_POWER_MGMT_5, reg | WM8350_AUXADC_ENA);
0203 
0204     if (scale || vref) {
0205         reg = scale << 13;
0206         reg |= vref << 12;
0207         wm8350_reg_write(wm8350, WM8350_AUX1_READBACK + channel, reg);
0208     }
0209 
0210     reg = wm8350_reg_read(wm8350, WM8350_DIGITISER_CONTROL_1);
0211     reg |= 1 << channel | WM8350_AUXADC_POLL;
0212     wm8350_reg_write(wm8350, WM8350_DIGITISER_CONTROL_1, reg);
0213 
0214     /* If a late IRQ left the completion signalled then consume
0215      * the completion. */
0216     try_wait_for_completion(&wm8350->auxadc_done);
0217 
0218     /* We ignore the result of the completion and just check for a
0219      * conversion result, allowing us to soldier on if the IRQ
0220      * infrastructure is not set up for the chip. */
0221     wait_for_completion_timeout(&wm8350->auxadc_done, msecs_to_jiffies(5));
0222 
0223     reg = wm8350_reg_read(wm8350, WM8350_DIGITISER_CONTROL_1);
0224     if (reg & WM8350_AUXADC_POLL)
0225         dev_err(wm8350->dev, "adc chn %d read timeout\n", channel);
0226     else
0227         result = wm8350_reg_read(wm8350,
0228                      WM8350_AUX1_READBACK + channel);
0229 
0230     /* Turn off the ADC */
0231     reg = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5);
0232     wm8350_reg_write(wm8350, WM8350_POWER_MGMT_5,
0233              reg & ~WM8350_AUXADC_ENA);
0234 
0235     mutex_unlock(&wm8350->auxadc_mutex);
0236 
0237     return result & WM8350_AUXADC_DATA1_MASK;
0238 }
0239 EXPORT_SYMBOL_GPL(wm8350_read_auxadc);
0240 
0241 static irqreturn_t wm8350_auxadc_irq(int irq, void *irq_data)
0242 {
0243     struct wm8350 *wm8350 = irq_data;
0244 
0245     complete(&wm8350->auxadc_done);
0246 
0247     return IRQ_HANDLED;
0248 }
0249 
0250 /*
0251  * Register a client device.  This is non-fatal since there is no need to
0252  * fail the entire device init due to a single platform device failing.
0253  */
0254 static void wm8350_client_dev_register(struct wm8350 *wm8350,
0255                        const char *name,
0256                        struct platform_device **pdev)
0257 {
0258     int ret;
0259 
0260     *pdev = platform_device_alloc(name, -1);
0261     if (*pdev == NULL) {
0262         dev_err(wm8350->dev, "Failed to allocate %s\n", name);
0263         return;
0264     }
0265 
0266     (*pdev)->dev.parent = wm8350->dev;
0267     platform_set_drvdata(*pdev, wm8350);
0268     ret = platform_device_add(*pdev);
0269     if (ret != 0) {
0270         dev_err(wm8350->dev, "Failed to register %s: %d\n", name, ret);
0271         platform_device_put(*pdev);
0272         *pdev = NULL;
0273     }
0274 }
0275 
0276 int wm8350_device_init(struct wm8350 *wm8350, int irq,
0277                struct wm8350_platform_data *pdata)
0278 {
0279     int ret;
0280     unsigned int id1, id2, mask_rev;
0281     unsigned int cust_id, mode, chip_rev;
0282 
0283     dev_set_drvdata(wm8350->dev, wm8350);
0284 
0285     /* get WM8350 revision and config mode */
0286     ret = regmap_read(wm8350->regmap, WM8350_RESET_ID, &id1);
0287     if (ret != 0) {
0288         dev_err(wm8350->dev, "Failed to read ID: %d\n", ret);
0289         goto err;
0290     }
0291 
0292     ret = regmap_read(wm8350->regmap, WM8350_ID, &id2);
0293     if (ret != 0) {
0294         dev_err(wm8350->dev, "Failed to read ID: %d\n", ret);
0295         goto err;
0296     }
0297 
0298     ret = regmap_read(wm8350->regmap, WM8350_REVISION, &mask_rev);
0299     if (ret != 0) {
0300         dev_err(wm8350->dev, "Failed to read revision: %d\n", ret);
0301         goto err;
0302     }
0303 
0304     if (id1 != 0x6143) {
0305         dev_err(wm8350->dev,
0306             "Device with ID %x is not a WM8350\n", id1);
0307         ret = -ENODEV;
0308         goto err;
0309     }
0310 
0311     mode = (id2 & WM8350_CONF_STS_MASK) >> 10;
0312     cust_id = id2 & WM8350_CUST_ID_MASK;
0313     chip_rev = (id2 & WM8350_CHIP_REV_MASK) >> 12;
0314     dev_info(wm8350->dev,
0315          "CONF_STS %d, CUST_ID %d, MASK_REV %d, CHIP_REV %d\n",
0316          mode, cust_id, mask_rev, chip_rev);
0317 
0318     if (cust_id != 0) {
0319         dev_err(wm8350->dev, "Unsupported CUST_ID\n");
0320         ret = -ENODEV;
0321         goto err;
0322     }
0323 
0324     switch (mask_rev) {
0325     case 0:
0326         wm8350->pmic.max_dcdc = WM8350_DCDC_6;
0327         wm8350->pmic.max_isink = WM8350_ISINK_B;
0328 
0329         switch (chip_rev) {
0330         case WM8350_REV_E:
0331             dev_info(wm8350->dev, "WM8350 Rev E\n");
0332             break;
0333         case WM8350_REV_F:
0334             dev_info(wm8350->dev, "WM8350 Rev F\n");
0335             break;
0336         case WM8350_REV_G:
0337             dev_info(wm8350->dev, "WM8350 Rev G\n");
0338             wm8350->power.rev_g_coeff = 1;
0339             break;
0340         case WM8350_REV_H:
0341             dev_info(wm8350->dev, "WM8350 Rev H\n");
0342             wm8350->power.rev_g_coeff = 1;
0343             break;
0344         default:
0345             /* For safety we refuse to run on unknown hardware */
0346             dev_err(wm8350->dev, "Unknown WM8350 CHIP_REV\n");
0347             ret = -ENODEV;
0348             goto err;
0349         }
0350         break;
0351 
0352     case 1:
0353         wm8350->pmic.max_dcdc = WM8350_DCDC_4;
0354         wm8350->pmic.max_isink = WM8350_ISINK_A;
0355 
0356         switch (chip_rev) {
0357         case 0:
0358             dev_info(wm8350->dev, "WM8351 Rev A\n");
0359             wm8350->power.rev_g_coeff = 1;
0360             break;
0361 
0362         case 1:
0363             dev_info(wm8350->dev, "WM8351 Rev B\n");
0364             wm8350->power.rev_g_coeff = 1;
0365             break;
0366 
0367         default:
0368             dev_err(wm8350->dev, "Unknown WM8351 CHIP_REV\n");
0369             ret = -ENODEV;
0370             goto err;
0371         }
0372         break;
0373 
0374     case 2:
0375         wm8350->pmic.max_dcdc = WM8350_DCDC_6;
0376         wm8350->pmic.max_isink = WM8350_ISINK_B;
0377 
0378         switch (chip_rev) {
0379         case 0:
0380             dev_info(wm8350->dev, "WM8352 Rev A\n");
0381             wm8350->power.rev_g_coeff = 1;
0382             break;
0383 
0384         default:
0385             dev_err(wm8350->dev, "Unknown WM8352 CHIP_REV\n");
0386             ret = -ENODEV;
0387             goto err;
0388         }
0389         break;
0390 
0391     default:
0392         dev_err(wm8350->dev, "Unknown MASK_REV\n");
0393         ret = -ENODEV;
0394         goto err;
0395     }
0396 
0397     mutex_init(&wm8350->auxadc_mutex);
0398     init_completion(&wm8350->auxadc_done);
0399 
0400     ret = wm8350_irq_init(wm8350, irq, pdata);
0401     if (ret < 0)
0402         goto err;
0403 
0404     if (wm8350->irq_base) {
0405         ret = request_threaded_irq(wm8350->irq_base +
0406                        WM8350_IRQ_AUXADC_DATARDY,
0407                        NULL, wm8350_auxadc_irq,
0408                        IRQF_ONESHOT,
0409                        "auxadc", wm8350);
0410         if (ret < 0)
0411             dev_warn(wm8350->dev,
0412                  "Failed to request AUXADC IRQ: %d\n", ret);
0413     }
0414 
0415     if (pdata && pdata->init) {
0416         ret = pdata->init(wm8350);
0417         if (ret != 0) {
0418             dev_err(wm8350->dev, "Platform init() failed: %d\n",
0419                 ret);
0420             goto err_irq;
0421         }
0422     }
0423 
0424     wm8350_reg_write(wm8350, WM8350_SYSTEM_INTERRUPTS_MASK, 0x0);
0425 
0426     wm8350_client_dev_register(wm8350, "wm8350-codec",
0427                    &(wm8350->codec.pdev));
0428     wm8350_client_dev_register(wm8350, "wm8350-gpio",
0429                    &(wm8350->gpio.pdev));
0430     wm8350_client_dev_register(wm8350, "wm8350-hwmon",
0431                    &(wm8350->hwmon.pdev));
0432     wm8350_client_dev_register(wm8350, "wm8350-power",
0433                    &(wm8350->power.pdev));
0434     wm8350_client_dev_register(wm8350, "wm8350-rtc", &(wm8350->rtc.pdev));
0435     wm8350_client_dev_register(wm8350, "wm8350-wdt", &(wm8350->wdt.pdev));
0436 
0437     return 0;
0438 
0439 err_irq:
0440     wm8350_irq_exit(wm8350);
0441 err:
0442     return ret;
0443 }
0444 EXPORT_SYMBOL_GPL(wm8350_device_init);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!