Statistics
| Branch: | Tag: | Revision:

amiro-os / components / eeprom / at24.cpp @ 58fe0e0b

History | View | Annotate | Download (5.81 KB)

1
#include <ch.hpp>
2
#include <hal.h>
3

    
4
#include <type_traits>
5

    
6
#include <amiro/bus/i2c/I2CDriver.hpp>
7
#include <amiro/bus/i2c/I2CParams.hpp>
8

    
9
#include <amiro/eeprom/at24.hpp>
10

    
11
#define AT24_GET_PAGE_OFFSET(_ADDRESS_, _PAGE_SIZE_) (_ADDRESS_ & (_PAGE_SIZE_ - 1u))
12

    
13
namespace amiro {
14

    
15
const struct BaseFileStreamVMT eeprom_at24_base_file_stream_methods = {
16

    
17
    /* .write       */ AT24::write,
18
    /* .read        */ AT24::read,
19
    /* .put         */ 0,
20
    /* .get         */ 0,
21
    /* .close       */ AT24::close,
22
    /* .geterror    */ EEPROM::geterror,
23
    /* .getsize     */ EEPROM::getsize,
24
    /* .getposition */ EEPROM::getposition,
25
    /* .lseek       */ EEPROM::lseek,
26

    
27
};
28

    
29
AT24::
30
AT24(size_t size, uint8_t page_size, uint16_t max_t_wr, I2CDriver* i2c_driver) :
31
  EEPROM(&eeprom_at24_base_file_stream_methods, size, page_size, max_t_wr, AT24_SLA, i2c_driver) {
32

    
33
}
34

    
35
AT24::
36
~AT24() {
37

    
38
}
39

    
40
msg_t
41
AT24::
42
poll_ack(void* instance) {
43

    
44
  EEPROM* bfs = (EEPROM*) instance;
45

    
46
  register I2CDriver* bfs_i2c_driver = bfs->i2c_driver;
47
  register msg_t ret_val = RDY_OK;
48
  register i2cflags_t i2c_err_flags;
49

    
50
  uint8_t dummy_buf[2];
51

    
52
  I2CRxParams i2c_rxparams;
53
  i2c_rxparams.addr = bfs->i2c_txparams.addr;
54
  i2c_rxparams.rxbuf = dummy_buf;
55
  i2c_rxparams.rxbytes = sizeof(dummy_buf);
56

    
57
  for (register uint16_t wr_time = 0x0000u; wr_time < bfs->max_t_wr; wr_time++) {
58

    
59
    bfs_i2c_driver->acquireBus();
60

    
61
    ret_val = bfs_i2c_driver->masterReceive(&i2c_rxparams);
62

    
63
    i2c_err_flags = bfs->i2c_driver->getErrors();
64

    
65
    bfs_i2c_driver->releaseBus();
66

    
67
    // Wait cycle over
68
    if (ret_val == RDY_OK)
69
      break;
70

    
71
    // Check for errors, ignoring only I2CD_ACK_FAILURE
72
    if (i2c_err_flags & ~I2CD_ACK_FAILURE) {
73
      break;
74
    }
75

    
76
    chThdSleepMicroseconds(10);
77

    
78
  }
79

    
80
  // This can only be the case when
81
  // * timeout reached
82
  // * i2cError other than I2CD_ACK_FAILURE within time limit
83
  if (ret_val != RDY_OK)
84
    bfs->error = i2c_err_flags;
85

    
86
  return ret_val;
87

    
88
}
89

    
90

    
91
size_t
92
AT24::
93
write(void* instance, const uint8_t* bp, size_t n) {
94

    
95
  EEPROM* bfs = (EEPROM*) instance;
96

    
97
  i2cflags_t i2c_err_flags;
98
  uint8_t i;
99
  uint8_t j;
100
  uint8_t scratchpad[2 + AT24_MAX_PAGE_SIZE];
101
  msg_t ret_val = RDY_OK;
102
  fileoffset_t cur_pos = bfs->position;
103

    
104
  register size_t tx_bytes;
105
  register const uint8_t* ptr = bp;
106
  register size_t num_bytes;
107
  register uint8_t page_size = bfs->page_size;
108
  register I2CTxParams* bfs_i2c_txparams = &bfs->i2c_txparams;
109

    
110
  // If no bytes are to be written, shortcut stop
111
  if (!n)
112
    return 0;
113

    
114
  // Clear error
115
  bfs->error = EEPROM_ERROR_NONE;
116

    
117
#if HAL_USE_I2C
118

    
119
  // number of bytes remaining in page starting at cur_pos
120
  // b/c of address rollover withing current page
121
  tx_bytes = AT24_GET_PAGE_OFFSET(cur_pos, page_size);
122
  // adjust for AT24_MAX_PAGE_SIZE < page_size
123
  tx_bytes = AT24_MAX_PAGE_SIZE - AT24_GET_PAGE_OFFSET(tx_bytes, AT24_MAX_PAGE_SIZE);
124

    
125
  for (num_bytes = n; num_bytes > 0;) {
126

    
127
    // write address
128
    i = 0;
129
    // Support for 16bit-addressable devices
130
    if (bfs->size > 0x0080u)
131
      scratchpad[i++] = (cur_pos >> 8) & 0xFFu;
132

    
133
    scratchpad[i++] = cur_pos & 0xFFu;
134

    
135
    // adjust number of bytes to transfer if end of buffer
136
    if (num_bytes < tx_bytes)
137
      tx_bytes = num_bytes;
138

    
139
    // copy data
140
    for (j = 0; j < tx_bytes; j++) {
141
      scratchpad[i++] = *ptr++;
142
    }
143

    
144
    // acknowledge polling
145

    
146
    // acknowledge polling and
147
    // address device
148
    for (register uint16_t wr_time = 0x0000u; wr_time < bfs->max_t_wr; wr_time++) {
149

    
150
      bfs->i2c_driver->acquireBus();
151

    
152
      bfs_i2c_txparams->txbuf = scratchpad;
153
      bfs_i2c_txparams->txbytes = i;
154
      bfs_i2c_txparams->rxbytes = 0;
155

    
156
      ret_val = bfs->i2c_driver->masterTransmit(bfs_i2c_txparams);
157

    
158
      i2c_err_flags = bfs->i2c_driver->getErrors();
159

    
160
      bfs->i2c_driver->releaseBus();
161

    
162
      // Write cycle over
163
      if (ret_val == RDY_OK)
164
        break;
165

    
166
      // Check for errors, ignoring only I2CD_ACK_FAILURE
167
      if (i2c_err_flags & ~I2CD_ACK_FAILURE) {
168
        break;
169
      }
170

    
171
      chThdSleepMicroseconds(10);
172

    
173
    }
174

    
175
    // This can only be the case when
176
    // * timeout reached
177
    // * i2cError other than I2CD_ACK_FAILURE within time limit
178
    if (ret_val != RDY_OK)
179
      break;
180

    
181
    cur_pos += tx_bytes;
182
    num_bytes -= tx_bytes;
183
    tx_bytes = AT24_MAX_PAGE_SIZE;
184

    
185
  }
186

    
187
  if (ret_val != RDY_OK)
188
    bfs->error = i2c_err_flags;
189

    
190
#endif
191

    
192
  bfs->position = cur_pos;
193

    
194
  // number of bytes to transfer - number of bytes not transferred
195
  return n - num_bytes;
196

    
197
}
198

    
199
size_t
200
AT24::
201
read(void* instance, uint8_t* bp, size_t n) {
202

    
203
  EEPROM* bfs = (EEPROM*) instance;
204

    
205
  uint8_t i;
206
  uint8_t scratchpad[2];
207
  msg_t ret_val;
208
  register I2CTxParams* bfs_i2c_txparams = &bfs->i2c_txparams;
209

    
210
  // If no bytes are to be read, shortcut stop
211
  if (!n)
212
    return 0;
213

    
214
  // Clear error
215
  bfs->error = EEPROM_ERROR_NONE;
216

    
217
#if HAL_USE_I2C
218

    
219
  // Fill address buffer
220
  i = 0;
221
  // Support for 16bit-addressable devices
222
  if (bfs->size > 0x0080u)
223
    scratchpad[i++] = (bfs->position >> 8) & 0xFFu;
224

    
225
  scratchpad[i++] = bfs->position & 0xFFu;
226

    
227
  // if device does not answer within timeout, don't read anything
228
  if (poll_ack(bfs) != RDY_OK)
229
    return 0;
230

    
231
  bfs->i2c_driver->acquireBus();
232

    
233
  bfs_i2c_txparams->txbuf = scratchpad;
234
  bfs_i2c_txparams->txbytes = i;
235
  bfs_i2c_txparams->rxbuf = bp;
236
  bfs_i2c_txparams->rxbytes = n;
237

    
238
  // address device
239
  // and read data
240
  ret_val = bfs->i2c_driver->masterTransmit(bfs_i2c_txparams);
241

    
242
  if (ret_val != RDY_OK)
243
    bfs->error = bfs->i2c_driver->getErrors();
244

    
245
  bfs->i2c_driver->releaseBus();
246

    
247
  // We cannot tell where I²C transfer went wrong
248
  // therefore report 0 bytes read
249
  if (ret_val != RDY_OK)
250
    return 0;
251

    
252
#endif
253

    
254
  return n;
255

    
256
}
257

    
258
/**
259
 * Close EEPROM device.
260
 * \note EEPROMs do not support close semantics.
261
 * \return FILE_OK Closing an EEPROM device will never fail.
262
 */
263
uint32_t
264
AT24::
265
close(void* instance) {
266

    
267
  (void) instance;
268
  return FILE_OK;
269

    
270
}
271

    
272
} /* amiro */