arm: mach-k3: Enable dcache in SPL
[oweals/u-boot.git] / drivers / adc / sandbox.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2015 Samsung Electronics
4  * Przemyslaw Marczak <p.marczak@samsung.com>
5  */
6 #include <common.h>
7 #include <errno.h>
8 #include <dm.h>
9 #include <adc.h>
10 #include <sandbox-adc.h>
11
12 /**
13  * struct sandbox_adc_priv - sandbox ADC device's operation status and data
14  *
15  * @conversion_status - conversion status: ACTIVE (started) / INACTIVE (stopped)
16  * @conversion_mode   - conversion mode: single or multi-channel
17  * @active_channel    - active channel number, valid for single channel mode
18  * data[]             - channels data
19  */
20 struct sandbox_adc_priv {
21         int conversion_status;
22         int conversion_mode;
23         int active_channel_mask;
24         unsigned int data[4];
25 };
26
27 int sandbox_adc_start_channel(struct udevice *dev, int channel)
28 {
29         struct sandbox_adc_priv *priv = dev_get_priv(dev);
30
31         /* Set single-channel mode */
32         priv->conversion_mode = SANDBOX_ADC_MODE_SINGLE_CHANNEL;
33         /* Select channel */
34         priv->active_channel_mask = 1 << channel;
35         /* Start conversion */
36         priv->conversion_status = SANDBOX_ADC_ACTIVE;
37
38         return 0;
39 }
40
41 int sandbox_adc_start_channels(struct udevice *dev, unsigned int channel_mask)
42 {
43         struct sandbox_adc_priv *priv = dev_get_priv(dev);
44
45         /* Set single-channel mode */
46         priv->conversion_mode = SANDBOX_ADC_MODE_MULTI_CHANNEL;
47         /* Select channel */
48         priv->active_channel_mask = channel_mask;
49         /* Start conversion */
50         priv->conversion_status = SANDBOX_ADC_ACTIVE;
51
52         return 0;
53 }
54
55 int sandbox_adc_channel_data(struct udevice *dev, int channel,
56                              unsigned int *data)
57 {
58         struct sandbox_adc_priv *priv = dev_get_priv(dev);
59
60         /* For single-channel conversion mode, check if channel was selected */
61         if ((priv->conversion_mode == SANDBOX_ADC_MODE_SINGLE_CHANNEL) &&
62             !(priv->active_channel_mask & (1 << channel))) {
63                 pr_err("Request for an inactive channel!");
64                 return -EINVAL;
65         }
66
67         /* The conversion must be started before reading the data */
68         if (priv->conversion_status == SANDBOX_ADC_INACTIVE)
69                 return -EIO;
70
71         *data = priv->data[channel];
72
73         return 0;
74 }
75
76 int sandbox_adc_channels_data(struct udevice *dev, unsigned int channel_mask,
77                               struct adc_channel *channels)
78 {
79         struct sandbox_adc_priv *priv = dev_get_priv(dev);
80         int i;
81
82         /* Return error for single-channel conversion mode */
83         if (priv->conversion_mode == SANDBOX_ADC_MODE_SINGLE_CHANNEL) {
84                 pr_err("ADC in single-channel mode!");
85                 return -EPERM;
86         }
87         /* Check channel selection */
88         if (!(priv->active_channel_mask & channel_mask)) {
89                 pr_err("Request for an inactive channel!");
90                 return -EINVAL;
91         }
92         /* The conversion must be started before reading the data */
93         if (priv->conversion_status == SANDBOX_ADC_INACTIVE)
94                 return -EIO;
95
96         for (i = 0; i < SANDBOX_ADC_CHANNELS; i++) {
97                 if (!((channel_mask >> i) & 0x1))
98                         continue;
99
100                 channels->data = priv->data[i];
101                 channels->id = i;
102                 channels++;
103         }
104
105         return 0;
106 }
107
108 int sandbox_adc_stop(struct udevice *dev)
109 {
110         struct sandbox_adc_priv *priv = dev_get_priv(dev);
111
112         /* Start conversion */
113         priv->conversion_status = SANDBOX_ADC_INACTIVE;
114
115         return 0;
116 }
117
118 int sandbox_adc_probe(struct udevice *dev)
119 {
120         struct sandbox_adc_priv *priv = dev_get_priv(dev);
121
122         /* Stop conversion */
123         priv->conversion_status = SANDBOX_ADC_INACTIVE;
124         /* Set single-channel mode */
125         priv->conversion_mode = SANDBOX_ADC_MODE_SINGLE_CHANNEL;
126         /* Deselect all channels */
127         priv->active_channel_mask = 0;
128
129         /* Set sandbox test data */
130         priv->data[0] = SANDBOX_ADC_CHANNEL0_DATA;
131         priv->data[1] = SANDBOX_ADC_CHANNEL1_DATA;
132         priv->data[2] = SANDBOX_ADC_CHANNEL2_DATA;
133         priv->data[3] = SANDBOX_ADC_CHANNEL3_DATA;
134
135         return 0;
136 }
137
138 int sandbox_adc_ofdata_to_platdata(struct udevice *dev)
139 {
140         struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
141
142         uc_pdata->data_mask = SANDBOX_ADC_DATA_MASK;
143         uc_pdata->data_format = ADC_DATA_FORMAT_BIN;
144         uc_pdata->data_timeout_us = 0;
145
146         /* Mask available channel bits: [0:3] */
147         uc_pdata->channel_mask = (1 << SANDBOX_ADC_CHANNELS) - 1;
148
149         return 0;
150 }
151
152 static const struct adc_ops sandbox_adc_ops = {
153         .start_channel = sandbox_adc_start_channel,
154         .start_channels = sandbox_adc_start_channels,
155         .channel_data = sandbox_adc_channel_data,
156         .channels_data = sandbox_adc_channels_data,
157         .stop = sandbox_adc_stop,
158 };
159
160 static const struct udevice_id sandbox_adc_ids[] = {
161         { .compatible = "sandbox,adc" },
162         { }
163 };
164
165 U_BOOT_DRIVER(sandbox_adc) = {
166         .name           = "sandbox-adc",
167         .id             = UCLASS_ADC,
168         .of_match       = sandbox_adc_ids,
169         .ops            = &sandbox_adc_ops,
170         .probe          = sandbox_adc_probe,
171         .ofdata_to_platdata = sandbox_adc_ofdata_to_platdata,
172         .priv_auto_alloc_size = sizeof(struct sandbox_adc_priv),
173 };