root/drivers/mfd/ucb1400_core.c

DEFINITIONS

1. ucb1400_adc_read
2. ucb1400_core_probe
3. ucb1400_core_remove
4. ucb1400_core_init
5. ucb1400_core_exit

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Core functions for:
   4  *  Philips UCB1400 multifunction chip
   5  *
   6  * Based on ucb1400_ts.c:
   7  *  Author:     Nicolas Pitre
   8  *  Created:    September 25, 2006
   9  *  Copyright:  MontaVista Software, Inc.
  10  *
  11  * Spliting done by: Marek Vasut <marek.vasut@gmail.com>
  12  * If something doesn't work and it worked before spliting, e-mail me,
  13  * dont bother Nicolas please ;-)
  14  *
  15  * This code is heavily based on ucb1x00-*.c copyrighted by Russell King
  16  * covering the UCB1100, UCB1200 and UCB1300..  Support for the UCB1400 has
  17  * been made separate from ucb1x00-core/ucb1x00-ts on Russell's request.
  18  */
  19 
  20 #include <linux/module.h>
  21 #include <linux/sched.h>
  22 #include <linux/slab.h>
  23 #include <linux/ucb1400.h>
  24 
  25 unsigned int ucb1400_adc_read(struct snd_ac97 *ac97, u16 adc_channel,
  26                 int adcsync)
  27 {
  28         unsigned int val;
  29 
  30         if (adcsync)
  31                 adc_channel |= UCB_ADC_SYNC_ENA;
  32 
  33         ucb1400_reg_write(ac97, UCB_ADC_CR, UCB_ADC_ENA | adc_channel);
  34         ucb1400_reg_write(ac97, UCB_ADC_CR, UCB_ADC_ENA | adc_channel |
  35                         UCB_ADC_START);
  36 
  37         while (!((val = ucb1400_reg_read(ac97, UCB_ADC_DATA))
  38                                 & UCB_ADC_DAT_VALID))
  39                 schedule_timeout_uninterruptible(1);
  40 
  41         return val & UCB_ADC_DAT_MASK;
  42 }
  43 EXPORT_SYMBOL_GPL(ucb1400_adc_read);
  44 
  45 static int ucb1400_core_probe(struct device *dev)
  46 {
  47         int err;
  48         struct ucb1400 *ucb;
  49         struct ucb1400_ts ucb_ts;
  50         struct ucb1400_gpio ucb_gpio;
  51         struct snd_ac97 *ac97;
  52         struct ucb1400_pdata *pdata = dev_get_platdata(dev);
  53 
  54         memset(&ucb_ts, 0, sizeof(ucb_ts));
  55         memset(&ucb_gpio, 0, sizeof(ucb_gpio));
  56 
  57         ucb = kzalloc(sizeof(struct ucb1400), GFP_KERNEL);
  58         if (!ucb) {
  59                 err = -ENOMEM;
  60                 goto err;
  61         }
  62 
  63         dev_set_drvdata(dev, ucb);
  64 
  65         ac97 = to_ac97_t(dev);
  66 
  67         ucb_ts.id = ucb1400_reg_read(ac97, UCB_ID);
  68         if (ucb_ts.id != UCB_ID_1400) {
  69                 err = -ENODEV;
  70                 goto err0;
  71         }
  72 
  73         /* GPIO */
  74         ucb_gpio.ac97 = ac97;
  75         if (pdata) {
  76                 ucb_gpio.gpio_setup = pdata->gpio_setup;
  77                 ucb_gpio.gpio_teardown = pdata->gpio_teardown;
  78                 ucb_gpio.gpio_offset = pdata->gpio_offset;
  79         }
  80         ucb->ucb1400_gpio = platform_device_alloc("ucb1400_gpio", -1);
  81         if (!ucb->ucb1400_gpio) {
  82                 err = -ENOMEM;
  83                 goto err0;
  84         }
  85         err = platform_device_add_data(ucb->ucb1400_gpio, &ucb_gpio,
  86                                         sizeof(ucb_gpio));
  87         if (err)
  88                 goto err1;
  89         err = platform_device_add(ucb->ucb1400_gpio);
  90         if (err)
  91                 goto err1;
  92 
  93         /* TOUCHSCREEN */
  94         ucb_ts.ac97 = ac97;
  95 
  96         if (pdata != NULL && pdata->irq >= 0)
  97                 ucb_ts.irq = pdata->irq;
  98         else
  99                 ucb_ts.irq = -1;
 100 
 101         ucb->ucb1400_ts = platform_device_alloc("ucb1400_ts", -1);
 102         if (!ucb->ucb1400_ts) {
 103                 err = -ENOMEM;
 104                 goto err2;
 105         }
 106         err = platform_device_add_data(ucb->ucb1400_ts, &ucb_ts,
 107                                         sizeof(ucb_ts));
 108         if (err)
 109                 goto err3;
 110         err = platform_device_add(ucb->ucb1400_ts);
 111         if (err)
 112                 goto err3;
 113 
 114         return 0;
 115 
 116 err3:
 117         platform_device_put(ucb->ucb1400_ts);
 118 err2:
 119         platform_device_del(ucb->ucb1400_gpio);
 120 err1:
 121         platform_device_put(ucb->ucb1400_gpio);
 122 err0:
 123         kfree(ucb);
 124 err:
 125         return err;
 126 }
 127 
 128 static int ucb1400_core_remove(struct device *dev)
 129 {
 130         struct ucb1400 *ucb = dev_get_drvdata(dev);
 131 
 132         platform_device_unregister(ucb->ucb1400_ts);
 133         platform_device_unregister(ucb->ucb1400_gpio);
 134 
 135         kfree(ucb);
 136         return 0;
 137 }
 138 
 139 static struct device_driver ucb1400_core_driver = {
 140         .name   = "ucb1400_core",
 141         .bus    = &ac97_bus_type,
 142         .probe  = ucb1400_core_probe,
 143         .remove = ucb1400_core_remove,
 144 };
 145 
 146 static int __init ucb1400_core_init(void)
 147 {
 148         return driver_register(&ucb1400_core_driver);
 149 }
 150 
 151 static void __exit ucb1400_core_exit(void)
 152 {
 153         driver_unregister(&ucb1400_core_driver);
 154 }
 155 
 156 module_init(ucb1400_core_init);
 157 module_exit(ucb1400_core_exit);
 158 
 159 MODULE_DESCRIPTION("Philips UCB1400 driver");
 160 MODULE_LICENSE("GPL");