1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2011 by Amaury Pouly
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "system.h"
#include "system-target.h"
#include "lradc-imx233.h"
#include "kernel-imx233.h"
/* channels */
static struct channel_arbiter_t channel_arbiter;
/* delay channels */
static struct channel_arbiter_t delay_arbiter;
/* battery is very special, dedicate a channel and a delay to it */
static int battery_chan;
static int battery_delay_chan;
void imx233_lradc_setup_channel(int channel, bool div2, bool acc, int nr_samples, int src)
{
__REG_CLR(HW_LRADC_CHx(channel)) = HW_LRADC_CHx__NUM_SAMPLES_BM | HW_LRADC_CHx__ACCUMULATE;
__REG_SET(HW_LRADC_CHx(channel)) = nr_samples << HW_LRADC_CHx__NUM_SAMPLES_BP |
acc << HW_LRADC_CHx__ACCUMULATE;
if(div2)
__REG_SET(HW_LRADC_CTRL2) = HW_LRADC_CTRL2__DIVIDE_BY_TWO(channel);
else
__REG_CLR(HW_LRADC_CTRL2) = HW_LRADC_CTRL2__DIVIDE_BY_TWO(channel);
__REG_CLR(HW_LRADC_CTRL4) = HW_LRADC_CTRL4__LRADCxSELECT_BM(channel);
__REG_SET(HW_LRADC_CTRL4) = src << HW_LRADC_CTRL4__LRADCxSELECT_BP(channel);
}
void imx233_lradc_setup_delay(int dchan, int trigger_lradc, int trigger_delays,
int loop_count, int delay)
{
HW_LRADC_DELAYx(dchan) =
trigger_lradc << HW_LRADC_DELAYx__TRIGGER_LRADCS_BP |
trigger_delays << HW_LRADC_DELAYx__TRIGGER_DELAYS_BP |
loop_count << HW_LRADC_DELAYx__LOOP_COUNT_BP |
delay << HW_LRADC_DELAYx__DELAY_BP;
}
void imx233_lradc_kick_channel(int channel)
{
__REG_CLR(HW_LRADC_CTRL1) = HW_LRADC_CTRL1__LRADCx_IRQ(channel);
__REG_SET(HW_LRADC_CTRL0) = HW_LRADC_CTRL0__SCHEDULE(channel);
}
void imx233_lradc_kick_delay(int dchan)
{
__REG_SET(HW_LRADC_DELAYx(dchan)) = HW_LRADC_DELAYx__KICK;
}
void imx233_lradc_wait_channel(int channel)
{
/* wait for completion */
while(!(HW_LRADC_CTRL1 & HW_LRADC_CTRL1__LRADCx_IRQ(channel)))
yield();
}
int imx233_lradc_read_channel(int channel)
{
return __XTRACT_EX(HW_LRADC_CHx(channel), HW_LRADC_CHx__VALUE);
}
void imx233_lradc_clear_channel(int channel)
{
__REG_CLR(HW_LRADC_CHx(channel)) = HW_LRADC_CHx__VALUE_BM;
}
int imx233_lradc_acquire_channel(int timeout)
{
return arbiter_acquire(&channel_arbiter, timeout);
}
void imx233_lradc_release_channel(int chan)
{
return arbiter_release(&channel_arbiter, chan);
}
void imx233_lradc_reserve_channel(int channel)
{
return arbiter_reserve(&channel_arbiter, channel);
}
int imx233_lradc_acquire_delay(int timeout)
{
return arbiter_acquire(&delay_arbiter, timeout);
}
void imx233_lradc_release_delay(int chan)
{
return arbiter_release(&delay_arbiter, chan);
}
void imx233_lradc_reserve_delay(int channel)
{
return arbiter_reserve(&delay_arbiter, channel);
}
int imx233_lradc_sense_die_temperature(int nmos_chan, int pmos_chan)
{
imx233_lradc_setup_channel(nmos_chan, false, false, 0, HW_LRADC_CHANNEL_NMOS_THIN);
imx233_lradc_setup_channel(pmos_chan, false, false, 0, HW_LRADC_CHANNEL_PMOS_THIN);
// mux sensors
__REG_CLR(HW_LRADC_CTRL2) = HW_LRADC_CTRL2__TEMPSENSE_PWD;
imx233_lradc_clear_channel(nmos_chan);
imx233_lradc_clear_channel(pmos_chan);
// schedule both channels
imx233_lradc_kick_channel(nmos_chan);
imx233_lradc_kick_channel(pmos_chan);
// wait completion
imx233_lradc_wait_channel(nmos_chan);
imx233_lradc_wait_channel(pmos_chan);
// mux sensors
__REG_SET(HW_LRADC_CTRL2) = HW_LRADC_CTRL2__TEMPSENSE_PWD;
// do the computation
int diff = imx233_lradc_read_channel(nmos_chan) - imx233_lradc_read_channel(pmos_chan);
// return diff * 1.012 / 4
return (diff * 1012) / 4000;
}
/* set to 0 to disable current source */
static void imx233_lradc_set_temp_isrc(int sensor, int value)
{
if(sensor < 0 || sensor > 1)
panicf("imx233_lradc_set_temp_isrc: invalid sensor");
unsigned mask = HW_LRADC_CTRL2__TEMP_ISRCx_BM(sensor);
unsigned bp = HW_LRADC_CTRL2__TEMP_ISRCx_BP(sensor);
unsigned en = HW_LRADC_CTRL2__TEMP_SENSOR_IENABLEx(sensor);
__REG_CLR(HW_LRADC_CTRL2) = mask;
__REG_SET(HW_LRADC_CTRL2) = value << bp;
if(value != 0)
{
__REG_SET(HW_LRADC_CTRL2) = en;
udelay(100);
}
else
__REG_CLR(HW_LRADC_CTRL2) = en;
}
int imx233_lradc_sense_ext_temperature(int chan, int sensor)
{
#define EXT_TEMP_ACC_COUNT 5
/* setup channel */
imx233_lradc_setup_channel(chan, false, false, 0, sensor);
/* set current source to 300µA */
imx233_lradc_set_temp_isrc(sensor, HW_LRADC_CTRL2__TEMP_ISRC__300uA);
/* read value and accumulate */
int a = 0;
for(int i = 0; i < EXT_TEMP_ACC_COUNT; i++)
{
imx233_lradc_clear_channel(chan);
imx233_lradc_kick_channel(chan);
imx233_lradc_wait_channel(chan);
a += imx233_lradc_read_channel(chan);
}
/* setup channel for small accumulation */
/* set current source to 20µA */
imx233_lradc_set_temp_isrc(sensor, HW_LRADC_CTRL2__TEMP_ISRC__20uA);
/* read value */
int b = 0;
for(int i = 0; i < EXT_TEMP_ACC_COUNT; i++)
{
imx233_lradc_clear_channel(chan);
imx233_lradc_kick_channel(chan);
imx233_lradc_wait_channel(chan);
b += imx233_lradc_read_channel(chan);
}
/* disable sensor current */
imx233_lradc_set_temp_isrc(sensor, HW_LRADC_CTRL2__TEMP_ISRC__0uA);
return (b - a) / EXT_TEMP_ACC_COUNT;
}
void imx233_lradc_setup_battery_conversion(bool automatic, unsigned long scale_factor)
{
__REG_CLR(HW_LRADC_CONVERSION) = HW_LRADC_CONVERSION__SCALE_FACTOR_BM;
__REG_SET(HW_LRADC_CONVERSION) = scale_factor;
if(automatic)
__REG_SET(HW_LRADC_CONVERSION) = HW_LRADC_CONVERSION__AUTOMATIC;
else
__REG_CLR(HW_LRADC_CONVERSION) = HW_LRADC_CONVERSION__AUTOMATIC;
}
int imx233_lradc_read_battery_voltage(void)
{
return __XTRACT(HW_LRADC_CONVERSION, SCALED_BATT_VOLTAGE);
}
void imx233_lradc_init(void)
{
arbiter_init(&channel_arbiter, HW_LRADC_NUM_CHANNELS);
arbiter_init(&delay_arbiter, HW_LRADC_NUM_DELAYS);
// enable block
imx233_reset_block(&HW_LRADC_CTRL0);
// disable ground ref
__REG_CLR(HW_LRADC_CTRL0) = HW_LRADC_CTRL0__ONCHIP_GROUNDREF;
// disable temperature sensors
__REG_CLR(HW_LRADC_CTRL2) = HW_LRADC_CTRL2__TEMP_SENSOR_IENABLE0 |
HW_LRADC_CTRL2__TEMP_SENSOR_IENABLE1;
__REG_SET(HW_LRADC_CTRL2) = HW_LRADC_CTRL2__TEMPSENSE_PWD;
// set frequency
__REG_CLR(HW_LRADC_CTRL3) = HW_LRADC_CTRL3__CYCLE_TIME_BM;
__REG_SET(HW_LRADC_CTRL3) = HW_LRADC_CTRL3__CYCLE_TIME__6MHz;
// setup battery
battery_chan = 7;
imx233_lradc_reserve_channel(battery_chan);
/* setup them for the simplest use: no accumulation, no division*/
imx233_lradc_setup_channel(battery_chan, false, false, 0, HW_LRADC_CHANNEL_BATTERY);
/* setup delay channel for battery for automatic reading and scaling */
battery_delay_chan = 0;
imx233_lradc_reserve_delay(battery_delay_chan);
/* setup delay to trigger battery channel and retrigger itself.
* The counter runs at 2KHz so a delay of 200 will trigger 10
* conversions per seconds */
imx233_lradc_setup_delay(battery_delay_chan, 1 << battery_chan,
1 << battery_delay_chan, 0, 200);
imx233_lradc_kick_delay(battery_delay_chan);
/* enable automatic conversion, use Li-Ion type battery */
imx233_lradc_setup_battery_conversion(true, HW_LRADC_CONVERSION__SCALE_FACTOR__LI_ION);
}
|
