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
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
|
/* ----> DO NOT REMOVE THE FOLLOWING NOTICE <----
Copyright (c) 2014-2017 Datalight, Inc.
All Rights Reserved Worldwide.
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; use version 2 of the License.
This program is distributed in the hope that it will be useful,
but "AS-IS," WITHOUT ANY WARRANTY; without even the implied warranty
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
/* Businesses and individuals that for commercial or other reasons cannot
comply with the terms of the GPLv2 license may obtain a commercial license
before incorporating Reliance Edge into proprietary software for
distribution in any form. Visit http://www.datalight.com/reliance-edge for
more information.
*/
/** @file
@brief Implements block device I/O.
*/
#include "hal.h"
#if (HAL_USE_SDMMC == TRUE)
#include "sama_sdmmc_lld.h"
#if SDMMC_USE_RELEDGE_LIB == 1
#include "sama_sdmmc_lld.h"
#include "ch_sdmmc_device.h"
#include "ch_sdmmc_cmds.h"
#include "ch_sdmmc_sdio.h"
#include "ch_sdmmc_sd.h"
#include "ch_sdmmc_mmc.h"
#include "ch_sdmmc_reledge.h"
#include <redfs.h>
#include <redvolume.h>
#include <redosdeviations.h>
#if REDCONF_API_POSIX == 0
#error "REDCONF_API_POSIX should be 1"
#endif
#if REDCONF_API_FSE == 1
#error "REDCONF_API_FSE not supported, should be 0"
#endif
/* sd_mmc_mem_2_ram_multi() and sd_mmc_ram_2_mem_multi() use an unsigned
16-bit value to specify the sector count, so no transfer can be larger
than UINT16_MAX sectors.
*/
#define MAX_SECTOR_TRANSFER UINT16_MAX
/** @brief Initialize a disk.
@param bVolNum The volume number of the volume whose block device is being
initialized.
@param mode The open mode, indicating the type of access required.
@return A negated ::REDSTATUS code indicating the operation result.
@retval 0 Operation was successful.
@retval -RED_EIO A disk I/O error occurred.
@retval -RED_EROFS The device is read-only media and write access was
requested.
*/
static REDSTATUS DiskOpen(
uint8_t bVolNum,
BDEVOPENMODE mode)
{
REDSTATUS ret = 0;
uint32_t ulTries;
eSDMMC_RC cs;
SdmmcDriver *sdmmcp = NULL;
if (!sdmmcGetInstance(bVolNum, &sdmmcp))
return RED_EINVAL;
/* Note: Assuming the volume number is the same as the SD card slot. The
ASF SD/MMC driver supports two SD slots. This implementation will need
to be modified if multiple volumes share a single SD card.
*/
/* The first time the disk is opened, the SD card can take a while to get
ready, in which time sd_mmc_test_unit_ready() returns either CTRL_BUSY
or CTRL_NO_PRESENT. Try numerous times, waiting half a second after
each failure. Empirically, this has been observed to succeed on the
second try, so trying 10x more than that provides a margin of error.
*/
for(ulTries = 0U; ulTries < 20U; ulTries++)
{
cs = sd_mmc_test_unit_ready(sdmmcp);
if((cs != SDMMC_OK) && (cs != SDMMC_BUSY))
{
break;
}
// t_msleep(sdmmcp,500);
}
if(cs == SDMMC_OK)
{
#if REDCONF_READ_ONLY == 0
if(mode != BDEV_O_RDONLY)
{
if(sd_mmc_is_write_protected(sdmmcp))
{
ret = -RED_EROFS;
}
}
if(ret == 0)
#endif
{
uint32_t ulSectorLast;
IGNORE_ERRORS(sd_mmc_read_capacity(sdmmcp, &ulSectorLast));
/* The ASF SD/MMC driver only supports 512-byte sectors.
*/
if( (gaRedVolConf[bVolNum].ulSectorSize != 512U)
|| (((uint64_t)ulSectorLast + 1U) < gaRedVolConf[bVolNum].ullSectorCount))
{
ret = -RED_EINVAL;
}
}
}
else
{
ret = -RED_EIO;
}
return ret;
}
/** @brief Uninitialize a disk.
@param bVolNum The volume number of the volume whose block device is being
uninitialized.
@return A negated ::REDSTATUS code indicating the operation result.
@retval 0 Operation was successful.
*/
static REDSTATUS DiskClose(
uint8_t bVolNum)
{
(void)bVolNum;
return 0;
}
/** @brief Read sectors from a disk.
@param bVolNum The volume number of the volume whose block device
is being read from.
@param ullSectorStart The starting sector number.
@param ulSectorCount The number of sectors to read.
@param pBuffer The buffer into which to read the sector data.
@return A negated ::REDSTATUS code indicating the operation result.
@retval 0 Operation was successful.
*/
static REDSTATUS DiskRead(
uint8_t bVolNum,
uint64_t ullSectorStart,
uint32_t ulSectorCount,
void *pBuffer)
{
REDSTATUS ret = 0;
uint8_t *pbBuffer = CAST_VOID_PTR_TO_UINT8_PTR(pBuffer);
SdmmcDriver *sdmmcp = NULL;
eSDMMC_RC cs;
if (!sdmmcGetInstance(bVolNum, &sdmmcp))
return RED_EINVAL;
cs = SD_ReadBlocks(sdmmcp, ullSectorStart, pbBuffer,ulSectorCount);
if(cs != SDMMC_OK)
{
ret = -RED_EIO;
}
return ret;
}
#if REDCONF_READ_ONLY == 0
/** @brief Write sectors to a disk.
@param bVolNum The volume number of the volume whose block device
is being written to.
@param ullSectorStart The starting sector number.
@param ulSectorCount The number of sectors to write.
@param pBuffer The buffer from which to write the sector data.
@return A negated ::REDSTATUS code indicating the operation result.
@retval 0 Operation was successful.
*/
static REDSTATUS DiskWrite(
uint8_t bVolNum,
uint64_t ullSectorStart,
uint32_t ulSectorCount,
const void *pBuffer)
{
REDSTATUS ret = 0;
const uint8_t *pbBuffer = CAST_VOID_PTR_TO_CONST_UINT8_PTR(pBuffer);
SdmmcDriver *sdmmcp = NULL;
eSDMMC_RC cs;
if (!sdmmcGetInstance(bVolNum, &sdmmcp))
return RED_EINVAL;
cs = SD_WriteBlocks(sdmmcp, ullSectorStart, pbBuffer, ulSectorCount);
if(cs != SDMMC_OK)
{
ret = -RED_EIO;
}
return ret;
}
/** @brief Flush any caches beneath the file system.
@param bVolNum The volume number of the volume whose block device is being
flushed.
@return A negated ::REDSTATUS code indicating the operation result.
@retval 0 Operation was successful.
*/
static REDSTATUS DiskFlush(
uint8_t bVolNum)
{
REDSTATUS ret;
eSDMMC_RC cs;
SdmmcDriver *sdmmcp = NULL;
if (!sdmmcGetInstance(bVolNum, &sdmmcp))
return RED_EINVAL;
/* The ASF SD/MMC driver appears to write sectors synchronously, so it
should be fine to do nothing and return success. However, Atmel's
implementation of the FatFs diskio.c file does the equivalent of the
below when the disk is flushed. Just in case this is important for some
non-obvious reason, do the same.
*/
cs = sd_mmc_test_unit_ready(sdmmcp);
if(cs == SDMMC_OK)
{
ret = 0;
}
else
{
ret = -RED_EIO;
}
return ret;
}
#if REDCONF_DISCARDS == 1
/** @brief Discard sectors on a disk.
@param bVolNum The volume number of the volume whose block device
is being accessed.
@param ullSectorStart The starting sector number.
@param ullSectorCount The number of sectors to discard.
*/
static void DiskDiscard(
uint8_t bVolNum,
uint64_t ullSectorStart,
uint64_t ullSectorCount)
{
#error "this SD/MMC driver does not support discards."
}
#endif /* REDCONF_DISCARDS == 1 */
#endif /* REDCONF_READ_ONLY == 0 */
/** @brief Initialize a block device.
This function is called when the file system needs access to a block
device.
Upon successful return, the block device should be fully initialized and
ready to service read/write/flush/close requests.
The behavior of calling this function on a block device which is already
open is undefined.
@param bVolNum The volume number of the volume whose block device is being
initialized.
@param mode The open mode, indicating the type of access required.
@return A negated ::REDSTATUS code indicating the operation result.
@retval 0 Operation was successful.
@retval -RED_EINVAL @p bVolNum is an invalid volume number.
@retval -RED_EIO A disk I/O error occurred.
*/
REDSTATUS RedOsBDevOpen(
uint8_t bVolNum,
BDEVOPENMODE mode)
{
REDSTATUS ret;
if(bVolNum >= REDCONF_VOLUME_COUNT)
{
ret = -RED_EINVAL;
}
else
{
ret = DiskOpen(bVolNum, mode);
}
return ret;
}
/** @brief Uninitialize a block device.
This function is called when the file system no longer needs access to a
block device. If any resource were allocated by RedOsBDevOpen() to service
block device requests, they should be freed at this time.
Upon successful return, the block device must be in such a state that it
can be opened again.
The behavior of calling this function on a block device which is already
closed is undefined.
@param bVolNum The volume number of the volume whose block device is being
uninitialized.
@return A negated ::REDSTATUS code indicating the operation result.
@retval 0 Operation was successful.
@retval -RED_EINVAL @p bVolNum is an invalid volume number.
*/
REDSTATUS RedOsBDevClose(
uint8_t bVolNum)
{
REDSTATUS ret;
if(bVolNum >= REDCONF_VOLUME_COUNT)
{
ret = -RED_EINVAL;
}
else
{
ret = DiskClose(bVolNum);
}
return ret;
}
/** @brief Read sectors from a physical block device.
The behavior of calling this function is undefined if the block device is
closed or if it was opened with ::BDEV_O_WRONLY.
@param bVolNum The volume number of the volume whose block device
is being read from.
@param ullSectorStart The starting sector number.
@param ulSectorCount The number of sectors to read.
@param pBuffer The buffer into which to read the sector data.
@return A negated ::REDSTATUS code indicating the operation result.
@retval 0 Operation was successful.
@retval -RED_EINVAL @p bVolNum is an invalid volume number, @p pBuffer is
`NULL`, or @p ullStartSector and/or @p ulSectorCount
refer to an invalid range of sectors.
@retval -RED_EIO A disk I/O error occurred.
*/
REDSTATUS RedOsBDevRead(
uint8_t bVolNum,
uint64_t ullSectorStart,
uint32_t ulSectorCount,
void *pBuffer)
{
REDSTATUS ret = 0;
if( (bVolNum >= REDCONF_VOLUME_COUNT)
|| (ullSectorStart >= gaRedVolConf[bVolNum].ullSectorCount)
|| ((gaRedVolConf[bVolNum].ullSectorCount - ullSectorStart) < ulSectorCount)
|| (pBuffer == NULL))
{
ret = -RED_EINVAL;
}
else
{
ret = DiskRead(bVolNum, ullSectorStart, ulSectorCount, pBuffer);
}
return ret;
}
#if REDCONF_READ_ONLY == 0
/** @brief Write sectors to a physical block device.
The behavior of calling this function is undefined if the block device is
closed or if it was opened with ::BDEV_O_RDONLY.
@param bVolNum The volume number of the volume whose block device
is being written to.
@param ullSectorStart The starting sector number.
@param ulSectorCount The number of sectors to write.
@param pBuffer The buffer from which to write the sector data.
@return A negated ::REDSTATUS code indicating the operation result.
@retval 0 Operation was successful.
@retval -RED_EINVAL @p bVolNum is an invalid volume number, @p pBuffer is
`NULL`, or @p ullStartSector and/or @p ulSectorCount
refer to an invalid range of sectors.
@retval -RED_EIO A disk I/O error occurred.
*/
REDSTATUS RedOsBDevWrite(
uint8_t bVolNum,
uint64_t ullSectorStart,
uint32_t ulSectorCount,
const void *pBuffer)
{
REDSTATUS ret = 0;
if( (bVolNum >= REDCONF_VOLUME_COUNT)
|| (ullSectorStart >= gaRedVolConf[bVolNum].ullSectorCount)
|| ((gaRedVolConf[bVolNum].ullSectorCount - ullSectorStart) < ulSectorCount)
|| (pBuffer == NULL))
{
ret = -RED_EINVAL;
}
else
{
ret = DiskWrite(bVolNum, ullSectorStart, ulSectorCount, pBuffer);
}
return ret;
}
/** @brief Flush any caches beneath the file system.
This function must synchronously flush all software and hardware caches
beneath the file system, ensuring that all sectors written previously are
committed to permanent storage.
If the environment has no caching beneath the file system, the
implementation of this function can do nothing and return success.
The behavior of calling this function is undefined if the block device is
closed or if it was opened with ::BDEV_O_RDONLY.
@param bVolNum The volume number of the volume whose block device is being
flushed.
@return A negated ::REDSTATUS code indicating the operation result.
@retval 0 Operation was successful.
@retval -RED_EINVAL @p bVolNum is an invalid volume number.
@retval -RED_EIO A disk I/O error occurred.
*/
REDSTATUS RedOsBDevFlush(
uint8_t bVolNum)
{
REDSTATUS ret;
if(bVolNum >= REDCONF_VOLUME_COUNT)
{
ret = -RED_EINVAL;
}
else
{
ret = DiskFlush(bVolNum);
}
return ret;
}
#endif /* REDCONF_READ_ONLY == 0 */
#endif
#endif
|