00001
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059 #include "compiler.h"
00060 #include "preprocessor.h"
00061 #ifdef FREERTOS_USED
00062 #include "FreeRTOS.h"
00063 #include "semphr.h"
00064 #endif
00065 #include "ctrl_access.h"
00066
00067
00068
00069
00070 #ifdef FREERTOS_USED
00071
00074
00075
00080 #define Ctrl_access_lock() ctrl_access_lock()
00081
00084 #define Ctrl_access_unlock() xSemaphoreGive(ctrl_access_semphr)
00085
00087
00089 static xSemaphoreHandle ctrl_access_semphr = NULL;
00090
00091 #else
00092
00095
00096
00101 #define Ctrl_access_lock() TRUE
00102
00105 #define Ctrl_access_unlock()
00106
00108
00109 #endif // FREERTOS_USED
00110
00111
00112 #if MAX_LUN
00113
00120 #if ACCESS_USB == ENABLED && ACCESS_MEM_TO_RAM == ENABLED
00121 #define Lun_desc_entry(lun) \
00122 {\
00123 TPASTE3(Lun_, lun, _test_unit_ready),\
00124 TPASTE3(Lun_, lun, _read_capacity),\
00125 TPASTE3(Lun_, lun, _wr_protect),\
00126 TPASTE3(Lun_, lun, _removal),\
00127 TPASTE3(Lun_, lun, _usb_read_10),\
00128 TPASTE3(Lun_, lun, _usb_write_10),\
00129 TPASTE3(Lun_, lun, _mem_2_ram),\
00130 TPASTE3(Lun_, lun, _ram_2_mem),\
00131 TPASTE3(LUN_, lun, _NAME)\
00132 }
00133 #elif ACCESS_USB == ENABLED
00134 #define Lun_desc_entry(lun) \
00135 {\
00136 TPASTE3(Lun_, lun, _test_unit_ready),\
00137 TPASTE3(Lun_, lun, _read_capacity),\
00138 TPASTE3(Lun_, lun, _wr_protect),\
00139 TPASTE3(Lun_, lun, _removal),\
00140 TPASTE3(Lun_, lun, _usb_read_10),\
00141 TPASTE3(Lun_, lun, _usb_write_10),\
00142 TPASTE3(LUN_, lun, _NAME)\
00143 }
00144 #elif ACCESS_MEM_TO_RAM == ENABLED
00145 #define Lun_desc_entry(lun) \
00146 {\
00147 TPASTE3(Lun_, lun, _test_unit_ready),\
00148 TPASTE3(Lun_, lun, _read_capacity),\
00149 TPASTE3(Lun_, lun, _wr_protect),\
00150 TPASTE3(Lun_, lun, _removal),\
00151 TPASTE3(Lun_, lun, _mem_2_ram),\
00152 TPASTE3(Lun_, lun, _ram_2_mem),\
00153 TPASTE3(LUN_, lun, _NAME)\
00154 }
00155 #else
00156 #define Lun_desc_entry(lun) \
00157 {\
00158 TPASTE3(Lun_, lun, _test_unit_ready),\
00159 TPASTE3(Lun_, lun, _read_capacity),\
00160 TPASTE3(Lun_, lun, _wr_protect),\
00161 TPASTE3(Lun_, lun, _removal),\
00162 TPASTE3(LUN_, lun, _NAME)\
00163 }
00164 #endif
00165
00167 static const struct
00168 {
00169 Ctrl_status (*test_unit_ready)(void);
00170 Ctrl_status (*read_capacity)(U32 *);
00171 Bool (*wr_protect)(void);
00172 Bool (*removal)(void);
00173 #if ACCESS_USB == ENABLED
00174 Ctrl_status (*usb_read_10)(U32, U16);
00175 Ctrl_status (*usb_write_10)(U32, U16);
00176 #endif
00177 #if ACCESS_MEM_TO_RAM == ENABLED
00178 Ctrl_status (*mem_2_ram)(U32, void *);
00179 Ctrl_status (*ram_2_mem)(U32, const void *);
00180 #endif
00181 const char *name;
00182 } lun_desc[MAX_LUN] =
00183 {
00184 #if LUN_0 == ENABLE
00185 Lun_desc_entry(0),
00186 #endif
00187 #if LUN_1 == ENABLE
00188 Lun_desc_entry(1),
00189 #endif
00190 #if LUN_2 == ENABLE
00191 Lun_desc_entry(2),
00192 #endif
00193 #if LUN_3 == ENABLE
00194 Lun_desc_entry(3),
00195 #endif
00196 #if LUN_4 == ENABLE
00197 Lun_desc_entry(4),
00198 #endif
00199 #if LUN_5 == ENABLE
00200 Lun_desc_entry(5),
00201 #endif
00202 #if LUN_6 == ENABLE
00203 Lun_desc_entry(6),
00204 #endif
00205 #if LUN_7 == ENABLE
00206 Lun_desc_entry(7)
00207 #endif
00208 };
00209
00210 #endif
00211
00212
00213 #if GLOBAL_WR_PROTECT == ENABLED
00214 Bool g_wr_protect;
00215 #endif
00216
00217
00220
00221
00222
00223 #ifdef FREERTOS_USED
00224
00225 Bool ctrl_access_init(void)
00226 {
00227
00228 if (!ctrl_access_semphr)
00229 {
00230
00231 vSemaphoreCreateBinary(ctrl_access_semphr);
00232
00233
00234 if (!ctrl_access_semphr) return FALSE;
00235 }
00236
00237 return TRUE;
00238 }
00239
00240
00245 static Bool ctrl_access_lock(void)
00246 {
00247
00248 if (!ctrl_access_semphr) return FALSE;
00249
00250
00251 while (!xSemaphoreTake(ctrl_access_semphr, portMAX_DELAY));
00252
00253 return TRUE;
00254 }
00255
00256 #endif // FREERTOS_USED
00257
00258
00259 U8 get_nb_lun(void)
00260 {
00261 #if MEM_USB == ENABLE
00262 U8 nb_lun;
00263
00264 if (!Ctrl_access_lock()) return MAX_LUN;
00265
00266 nb_lun = MAX_LUN + host_get_lun();
00267
00268 Ctrl_access_unlock();
00269
00270 return nb_lun;
00271 #else
00272 return MAX_LUN;
00273 #endif
00274 }
00275
00276
00277 U8 get_cur_lun(void)
00278 {
00279 return LUN_ID_0;
00280 }
00281
00282
00283 Ctrl_status mem_test_unit_ready(U8 lun)
00284 {
00285 Ctrl_status status;
00286
00287 if (!Ctrl_access_lock()) return CTRL_FAIL;
00288
00289 status =
00290 #if MAX_LUN
00291 (lun < MAX_LUN) ? lun_desc[lun].test_unit_ready() :
00292 #endif
00293 #if LUN_USB == ENABLE
00294 Lun_usb_test_unit_ready(lun - LUN_ID_USB);
00295 #else
00296 CTRL_FAIL;
00297 #endif
00298
00299 Ctrl_access_unlock();
00300
00301 return status;
00302 }
00303
00304
00305 Ctrl_status mem_read_capacity(U8 lun, U32 *u32_nb_sector)
00306 {
00307 Ctrl_status status;
00308
00309 if (!Ctrl_access_lock()) return CTRL_FAIL;
00310
00311 status =
00312 #if MAX_LUN
00313 (lun < MAX_LUN) ? lun_desc[lun].read_capacity(u32_nb_sector) :
00314 #endif
00315 #if LUN_USB == ENABLE
00316 Lun_usb_read_capacity(lun - LUN_ID_USB, u32_nb_sector);
00317 #else
00318 CTRL_FAIL;
00319 #endif
00320
00321 Ctrl_access_unlock();
00322
00323 return status;
00324 }
00325
00326
00327 U8 mem_sector_size(U8 lun)
00328 {
00329 U8 sector_size;
00330
00331 if (!Ctrl_access_lock()) return 0;
00332
00333 sector_size =
00334 #if MAX_LUN
00335 (lun < MAX_LUN) ? 1 :
00336 #endif
00337 #if LUN_USB == ENABLE
00338 Lun_usb_read_sector_size(lun - LUN_ID_USB);
00339 #else
00340 0;
00341 #endif
00342
00343 Ctrl_access_unlock();
00344
00345 return sector_size;
00346 }
00347
00348
00349 Bool mem_wr_protect(U8 lun)
00350 {
00351 Bool wr_protect;
00352
00353 if (!Ctrl_access_lock()) return TRUE;
00354
00355 wr_protect =
00356 #if MAX_LUN
00357 (lun < MAX_LUN) ? lun_desc[lun].wr_protect() :
00358 #endif
00359 #if LUN_USB == ENABLE
00360 Lun_usb_wr_protect(lun - LUN_ID_USB);
00361 #else
00362 TRUE;
00363 #endif
00364
00365 Ctrl_access_unlock();
00366
00367 return wr_protect;
00368 }
00369
00370
00371 Bool mem_removal(U8 lun)
00372 {
00373 Bool removal;
00374
00375 if (!Ctrl_access_lock()) return TRUE;
00376
00377 removal =
00378 #if MAX_LUN
00379 (lun < MAX_LUN) ? lun_desc[lun].removal() :
00380 #endif
00381 #if LUN_USB == ENABLE
00382 Lun_usb_removal();
00383 #else
00384 TRUE;
00385 #endif
00386
00387 Ctrl_access_unlock();
00388
00389 return removal;
00390 }
00391
00392
00393 const char *mem_name(U8 lun)
00394 {
00395 return
00396 #if MAX_LUN
00397 (lun < MAX_LUN) ? lun_desc[lun].name :
00398 #endif
00399 #if LUN_USB == ENABLE
00400 LUN_USB_NAME;
00401 #else
00402 NULL;
00403 #endif
00404 }
00405
00406
00408
00409
00410 #if ACCESS_USB == ENABLED
00411
00414
00415
00416
00417 Ctrl_status memory_2_usb(U8 lun, U32 addr, U16 nb_sector)
00418 {
00419 Ctrl_status status;
00420
00421 if (!Ctrl_access_lock()) return CTRL_FAIL;
00422
00423 memory_start_read_action(nb_sector);
00424 status =
00425 #if MAX_LUN
00426 (lun < MAX_LUN) ? lun_desc[lun].usb_read_10(addr, nb_sector) :
00427 #endif
00428 CTRL_FAIL;
00429 memory_stop_read_action();
00430
00431 Ctrl_access_unlock();
00432
00433 return status;
00434 }
00435
00436
00437 Ctrl_status usb_2_memory(U8 lun, U32 addr, U16 nb_sector)
00438 {
00439 Ctrl_status status;
00440
00441 if (!Ctrl_access_lock()) return CTRL_FAIL;
00442
00443 memory_start_write_action(nb_sector);
00444 status =
00445 #if MAX_LUN
00446 (lun < MAX_LUN) ? lun_desc[lun].usb_write_10(addr, nb_sector) :
00447 #endif
00448 CTRL_FAIL;
00449 memory_stop_write_action();
00450
00451 Ctrl_access_unlock();
00452
00453 return status;
00454 }
00455
00456
00458
00459 #endif // ACCESS_USB == ENABLED
00460
00461
00462 #if ACCESS_MEM_TO_RAM == ENABLED
00463
00466
00467
00468
00469 Ctrl_status memory_2_ram(U8 lun, U32 addr, void *ram)
00470 {
00471 Ctrl_status status;
00472
00473 if (!Ctrl_access_lock()) return CTRL_FAIL;
00474
00475 memory_start_read_action(1);
00476 status =
00477 #if MAX_LUN
00478 (lun < MAX_LUN) ? lun_desc[lun].mem_2_ram(addr, ram) :
00479 #endif
00480 #if LUN_USB == ENABLE
00481 Lun_usb_mem_2_ram(addr, ram);
00482 #else
00483 CTRL_FAIL;
00484 #endif
00485 memory_stop_read_action();
00486
00487 Ctrl_access_unlock();
00488
00489 return status;
00490 }
00491
00492
00493 Ctrl_status ram_2_memory(U8 lun, U32 addr, const void *ram)
00494 {
00495 Ctrl_status status;
00496
00497 if (!Ctrl_access_lock()) return CTRL_FAIL;
00498
00499 memory_start_write_action(1);
00500 status =
00501 #if MAX_LUN
00502 (lun < MAX_LUN) ? lun_desc[lun].ram_2_mem(addr, ram) :
00503 #endif
00504 #if LUN_USB == ENABLE
00505 Lun_usb_ram_2_mem(addr, ram);
00506 #else
00507 CTRL_FAIL;
00508 #endif
00509 memory_stop_write_action();
00510
00511 Ctrl_access_unlock();
00512
00513 return status;
00514 }
00515
00516
00518
00519 #endif // ACCESS_MEM_TO_RAM == ENABLED
00520
00521
00522 #if ACCESS_STREAM == ENABLED
00523
00526
00527
00528
00529 #if ACCESS_MEM_TO_MEM == ENABLED
00530
00531 #include "fat.h"
00532
00533 Ctrl_status stream_mem_to_mem(U8 src_lun, U32 src_addr, U8 dest_lun, U32 dest_addr, U16 nb_sector)
00534 {
00535 #if (defined __GNUC__) && (defined __AVR32__)
00536 __attribute__((__aligned__(4)))
00537 #elif (defined __ICCAVR32__)
00538 #pragma data_alignment = 4
00539 #endif
00540 static U8 sector_buf[FS_512B];
00541 Ctrl_status status = CTRL_GOOD;
00542
00543 while (nb_sector--)
00544 {
00545 if ((status = memory_2_ram(src_lun, src_addr++, sector_buf)) != CTRL_GOOD) break;
00546 if ((status = ram_2_memory(dest_lun, dest_addr++, sector_buf)) != CTRL_GOOD) break;
00547 }
00548
00549 return status;
00550 }
00551
00552 #endif // ACCESS_MEM_TO_MEM == ENABLED
00553
00554
00555 Ctrl_status stream_state(U8 id)
00556 {
00557 return CTRL_GOOD;
00558 }
00559
00560
00561 U16 stream_stop(U8 id)
00562 {
00563 return 0;
00564 }
00565
00566
00568
00569 #endif // ACCESS_STREAM == ENABLED