Trond Enger / d7a_1x

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of d7a_1x by WizziLab

src/d7a_fs.cpp@33:f9a542d3efaa, 2016-06-24 (annotated)

Committer:
Jeej
Date:
Fri Jun 24 10:11:19 2016 +0000
Revision:
33:f9a542d3efaa
Parent:
31:ab9bfdbc6b44
Child:
34:1311cc53201a
Rewritten parser.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Jeej 25:aac250164497 1 #include "mbed.h"
Jeej 25:aac250164497 2 #include "rtos.h"
Jeej 25:aac250164497 3 #include "dbg.h"
Jeej 25:aac250164497 4 #include "d7a_com.h"
Jeej 25:aac250164497 5 #include "d7a_common.h"
Jeej 25:aac250164497 6 #include "d7a_fs.h"
Jeej 25:aac250164497 7
Jeej 25:aac250164497 8
Jeej 25:aac250164497 9 #define FS_MAX_FILE_QTY 256
Jeej 25:aac250164497 10 #define FS_MAX_MIRROR_QTY 32
Jeej 25:aac250164497 11 #define FS_MAX_WATCHERS_QTY 32
Jeej 25:aac250164497 12
Jeej 25:aac250164497 13 #define FS_NULL_MAP 0xFF // XXX: this actually removes usage of file 255
Jeej 25:aac250164497 14
Jeej 25:aac250164497 15 TYPEDEF_STRUCT_PACKED {
Jeej 30:d775c1409849 16 uint8_t id;
Jeej 25:aac250164497 17 uint8_t cmd;
Jeej 25:aac250164497 18 uint8_t fid;
Jeej 25:aac250164497 19 uint32_t offset;
Jeej 25:aac250164497 20 uint32_t length;
Jeej 25:aac250164497 21 } d7a_fs_com_req_t;
Jeej 25:aac250164497 22
Jeej 25:aac250164497 23 TYPEDEF_STRUCT_PACKED {
Jeej 30:d775c1409849 24 uint8_t id;
Jeej 25:aac250164497 25 uint8_t cmd;
Jeej 30:d775c1409849 26 int8_t status;
Jeej 25:aac250164497 27 uint32_t length;
Jeej 25:aac250164497 28 uint8_t data[1];
Jeej 25:aac250164497 29 } d7a_fs_com_resp_t;
Jeej 25:aac250164497 30
Jeej 25:aac250164497 31 typedef struct {
Jeej 25:aac250164497 32 d7a_fs_com_req_t req;
Jeej 25:aac250164497 33 void* data;
Jeej 25:aac250164497 34 } d7a_fs_com_t;
Jeej 25:aac250164497 35
Jeej 25:aac250164497 36 typedef struct {
Jeej 25:aac250164497 37 Thread* thread;
Jeej 26:9f0b9833cac6 38 Queue<void, 8> fs_done;
Jeej 30:d775c1409849 39 const d7a_fs_callbacks_t* callback;
Jeej 25:aac250164497 40 Queue<d7a_com_rx_msg_t, 16> pkt_queue;
Jeej 25:aac250164497 41 uint8_t hdr_map[FS_MAX_FILE_QTY];
Jeej 25:aac250164497 42 uint8_t nb_files;
Jeej 30:d775c1409849 43 d7a_fs_com_t com[FS_MAX_CONCURRENCY];
Jeej 25:aac250164497 44 } d7a_fs_ctx_t;
Jeej 25:aac250164497 45
Jeej 25:aac250164497 46 d7a_fs_ctx_t g_fs_ctx;
Jeej 25:aac250164497 47
Jeej 25:aac250164497 48 void d7a_fs_thread(const void *p);
Jeej 25:aac250164497 49
Jeej 30:d775c1409849 50 void d7a_fs_open(const d7a_fs_callbacks_t* config)
Jeej 25:aac250164497 51 {
Jeej 25:aac250164497 52 FPRINT("\r\n");
Jeej 25:aac250164497 53
Jeej 25:aac250164497 54 memset(&g_fs_ctx.com, 0, sizeof(g_fs_ctx.com));
Jeej 30:d775c1409849 55 g_fs_ctx.callback = config;
Jeej 31:ab9bfdbc6b44 56 g_fs_ctx.thread = new Thread(d7a_fs_thread, NULL, osPriorityHigh, DEFAULT_STACK_SIZE);
Jeej 25:aac250164497 57 }
Jeej 25:aac250164497 58
Jeej 30:d775c1409849 59 static uint8_t d7a_fs_get_req_id(void)
Jeej 30:d775c1409849 60 {
Jeej 30:d775c1409849 61 int i;
Jeej 30:d775c1409849 62 for (i=0;i<FS_MAX_CONCURRENCY;i++)
Jeej 30:d775c1409849 63 {
Jeej 30:d775c1409849 64 if (g_fs_ctx.com[i].req.cmd == FS_OP_NULL)
Jeej 30:d775c1409849 65 {
Jeej 30:d775c1409849 66 DPRINT("New req %d\r\n", i);
Jeej 30:d775c1409849 67 return i;
Jeej 30:d775c1409849 68 }
Jeej 30:d775c1409849 69 }
Jeej 30:d775c1409849 70 ASSERT(false, "FS: MAX_CONCURRENCY exceeded\r\n");
Jeej 30:d775c1409849 71 return 0xff;
Jeej 30:d775c1409849 72 }
Jeej 30:d775c1409849 73
Jeej 30:d775c1409849 74
Jeej 25:aac250164497 75 static void d7a_fs_msg(uint8_t* buf, uint8_t len, uint8_t id)
Jeej 25:aac250164497 76 {
Jeej 25:aac250164497 77 FPRINT("\r\n");
Jeej 25:aac250164497 78 d7a_com_tx_msg_t msg;
Jeej 25:aac250164497 79 msg.id = id;
Jeej 25:aac250164497 80 msg.pbuf = buf;
Jeej 25:aac250164497 81 msg.plen = len;
Jeej 25:aac250164497 82 msg.alen = 0;
Jeej 25:aac250164497 83 d7a_com_send_msg(&msg);
Jeej 25:aac250164497 84 }
Jeej 25:aac250164497 85
Jeej 26:9f0b9833cac6 86 void* d7a_fs_wait_done( uint32_t millisec )
Jeej 25:aac250164497 87 {
Jeej 25:aac250164497 88 FPRINT("\r\n");
Jeej 26:9f0b9833cac6 89 osEvent evt = g_fs_ctx.fs_done.get(millisec);
Jeej 33:f9a542d3efaa 90 ASSERT(evt.status == osEventMessage, "FS Wait Timeout!\r\n");
Jeej 33:f9a542d3efaa 91
Jeej 33:f9a542d3efaa 92 return (void*)evt.value.p;
Jeej 25:aac250164497 93 }
Jeej 25:aac250164497 94
Jeej 25:aac250164497 95 void d7a_fs_new_pkt(d7a_com_rx_msg_t* pkt)
Jeej 25:aac250164497 96 {
Jeej 25:aac250164497 97 FPRINT("\r\n");
Jeej 25:aac250164497 98 ASSERT(g_fs_ctx.pkt_queue.put(pkt) == osOK, "FS queue full!\r\n");
Jeej 25:aac250164497 99 }
Jeej 25:aac250164497 100
Jeej 25:aac250164497 101 d7a_com_rx_msg_t* d7a_fs_wait_pkt( uint32_t millisec )
Jeej 25:aac250164497 102 {
Jeej 30:d775c1409849 103 FPRINT("(millisec:%d)\r\n", millisec);
Jeej 25:aac250164497 104 osEvent evt = g_fs_ctx.pkt_queue.get(millisec);
Jeej 25:aac250164497 105 return (evt.status == osEventMessage)? (d7a_com_rx_msg_t*)evt.value.p : NULL;
Jeej 25:aac250164497 106 }
Jeej 25:aac250164497 107
Jeej 30:d775c1409849 108 static uint32_t d7a_fs_hdr(uint8_t fid, const d7a_fs_header_t* hdr)
Jeej 25:aac250164497 109 {
Jeej 25:aac250164497 110 FPRINT("\r\n");
Jeej 30:d775c1409849 111 d7a_fs_header_t* temp_hdr = g_fs_ctx.callback->get_stat(fid);
Jeej 30:d775c1409849 112 if (!temp_hdr)
Jeej 30:d775c1409849 113 {
Jeej 30:d775c1409849 114 return 0;
Jeej 30:d775c1409849 115 }
Jeej 30:d775c1409849 116 memcpy((void*)hdr, (void*)temp_hdr, sizeof(d7a_fs_header_t));
Jeej 30:d775c1409849 117 return sizeof(d7a_fs_header_t);
Jeej 25:aac250164497 118 }
Jeej 25:aac250164497 119
Jeej 25:aac250164497 120 uint32_t d7a_fs_get_properties(uint8_t fid, d7a_fs_property_t prop, d7a_fs_properties_t* props)
Jeej 25:aac250164497 121 {
Jeej 28:0376b97b4b55 122 FPRINT("(fid:%d, prop:0x%02X)\r\n", fid, prop);
Jeej 25:aac250164497 123 d7a_fs_header_t hdr;
Jeej 25:aac250164497 124 d7a_fs_hdr(fid, &hdr);
Jeej 25:aac250164497 125
Jeej 25:aac250164497 126 uint32_t ret = 0;
Jeej 25:aac250164497 127 if (prop == KAL_FS_PROP_ALL)
Jeej 25:aac250164497 128 {
Jeej 25:aac250164497 129 // Fill in the API structure
Jeej 25:aac250164497 130 //props->addr = (uint32_t)d7a_fs_get_memory_addr(hdr);
Jeej 25:aac250164497 131 props->type = hdr.byte.type;
Jeej 25:aac250164497 132
Jeej 25:aac250164497 133 props->afid = hdr.byte.afid;
Jeej 25:aac250164497 134 props->ifid = hdr.byte.ifid;
Jeej 25:aac250164497 135 props->prop = hdr.byte.prop;
Jeej 25:aac250164497 136 props->perm = hdr.byte.perm;
Jeej 25:aac250164497 137
Jeej 25:aac250164497 138 props->length = hdr.bf.length;
Jeej 25:aac250164497 139 props->alloc = hdr.bf.alloc;
Jeej 25:aac250164497 140 }
Jeej 25:aac250164497 141 else
Jeej 25:aac250164497 142 {
Jeej 25:aac250164497 143 switch(prop)
Jeej 25:aac250164497 144 {
Jeej 25:aac250164497 145 case KAL_FS_PROP_SIZE: ret = hdr.bf.length; break;
Jeej 25:aac250164497 146 case KAL_FS_PROP_ALLOC: ret = hdr.bf.alloc; break;
Jeej 25:aac250164497 147 case KAL_FS_PROP_TYPE: ret = hdr.byte.type; break;
Jeej 25:aac250164497 148 //case KAL_FS_PROP_ADDR: ret = (uint32_t)d7a_fs_get_memory_addr(hdr); break;
Jeej 25:aac250164497 149 case KAL_FS_PROP_AFID: ret = hdr.byte.afid; break;
Jeej 25:aac250164497 150 case KAL_FS_PROP_IFID: ret = hdr.byte.ifid; break;
Jeej 25:aac250164497 151 case KAL_FS_PROP_PROP: ret = hdr.byte.prop; break;
Jeej 25:aac250164497 152 case KAL_FS_PROP_PERM: ret = hdr.byte.perm; break;
Jeej 25:aac250164497 153 default:
Jeej 25:aac250164497 154 ASSERT(false, "FS:Invalid get prop request %d\n",prop);
Jeej 25:aac250164497 155 }
Jeej 25:aac250164497 156 }
Jeej 30:d775c1409849 157 //DPRINT("GetProp[%d](%d): %d\n",fid,prop,ret);
Jeej 25:aac250164497 158 return ret;
Jeej 25:aac250164497 159 }
Jeej 25:aac250164497 160
Jeej 26:9f0b9833cac6 161 void d7a_fs_distant_stat(uint8_t fid, int* length)
Jeej 26:9f0b9833cac6 162 {
Jeej 26:9f0b9833cac6 163 FPRINT("\r\n");
Jeej 26:9f0b9833cac6 164 // "Distant" Files
Jeej 30:d775c1409849 165 uint8_t id = d7a_fs_get_req_id();
Jeej 30:d775c1409849 166 g_fs_ctx.com[id].req = (d7a_fs_com_req_t){id,FS_OP_STAT,fid,0,0};
Jeej 30:d775c1409849 167 g_fs_ctx.com[id].data = length;
Jeej 31:ab9bfdbc6b44 168 d7a_fs_msg((uint8_t*)&g_fs_ctx.com[id].req, sizeof(d7a_fs_com_req_t), KAL_COM_FLOW_FS_CMD);
Jeej 26:9f0b9833cac6 169 // We do a "normal" STAT but we don't want to update our local(true) file-size
Jeej 26:9f0b9833cac6 170 // with the response of the STAT as:
Jeej 26:9f0b9833cac6 171 // - the distant is likely a "Host-file" with hazardous size/alloc
Jeej 26:9f0b9833cac6 172 // - we may not even have the corresponding local file (-> assert when getting props)
Jeej 26:9f0b9833cac6 173 // So flag the cmd to differentiate response treatment
Jeej 30:d775c1409849 174 g_fs_ctx.com[id].req.cmd = FS_OP_DSTAT; // XXX
Jeej 26:9f0b9833cac6 175 }
Jeej 26:9f0b9833cac6 176
Jeej 25:aac250164497 177 int d7a_fs_distant_create(uint8_t fid, d7a_fs_properties_t* props)
Jeej 25:aac250164497 178 {
Jeej 30:d775c1409849 179 uint8_t id;
Jeej 25:aac250164497 180 FPRINT("\r\n");
Jeej 30:d775c1409849 181 //DPRINT("CrD[%d] type 0x%x\n",fid,props->type);
Jeej 25:aac250164497 182
Jeej 25:aac250164497 183 switch (props->type)
Jeej 25:aac250164497 184 {
Jeej 25:aac250164497 185 case EEPROM:
Jeej 25:aac250164497 186 case RAM:
Jeej 25:aac250164497 187 case PFLASH:
Jeej 25:aac250164497 188 case HOST:
Jeej 30:d775c1409849 189 id = d7a_fs_get_req_id();
Jeej 25:aac250164497 190 // Build WR command
Jeej 25:aac250164497 191 uint8_t* buf = (uint8_t*)MALLOC(sizeof(d7a_fs_com_req_t) + sizeof(d7a_fs_properties_t));
Jeej 25:aac250164497 192 d7a_fs_com_req_t* buf_req = (d7a_fs_com_req_t*)buf;
Jeej 30:d775c1409849 193 *buf_req = (d7a_fs_com_req_t){id,FS_OP_CREATE,fid,0,sizeof(d7a_fs_properties_t)};
Jeej 25:aac250164497 194 memcpy(&buf[sizeof(d7a_fs_com_req_t)],(uint8_t*)props,sizeof(d7a_fs_properties_t));
Jeej 25:aac250164497 195
Jeej 25:aac250164497 196 // Keep command request for response treatment
Jeej 30:d775c1409849 197 g_fs_ctx.com[id].req.cmd = FS_OP_CREATE;
Jeej 25:aac250164497 198 d7a_fs_msg(buf,sizeof(d7a_fs_com_req_t) + sizeof(d7a_fs_properties_t), KAL_COM_FLOW_FS_CMD);
Jeej 25:aac250164497 199 FREE(buf);
Jeej 25:aac250164497 200 break;
Jeej 25:aac250164497 201 // Wrong type
Jeej 25:aac250164497 202 default:
Jeej 25:aac250164497 203 ASSERT(false, "FS:post_distant_create wrong file type %x\n",props->type);
Jeej 25:aac250164497 204 break;
Jeej 25:aac250164497 205 }
Jeej 25:aac250164497 206 return 0;
Jeej 25:aac250164497 207 }
Jeej 25:aac250164497 208
Jeej 27:934ab7455115 209 int d7a_fs_read(uint8_t fid, void *data, uint32_t offset, uint32_t length)
Jeej 27:934ab7455115 210 {
Jeej 30:d775c1409849 211 //DPRINT("RdP[%d] @:%d %d bytes\n", fid, offset, length);
Jeej 27:934ab7455115 212 d7a_fs_header_t hdr;
Jeej 27:934ab7455115 213 uint8_t local = 0;
Jeej 30:d775c1409849 214 uint8_t id;
Jeej 27:934ab7455115 215
Jeej 27:934ab7455115 216 if (!d7a_fs_hdr(fid, &hdr))
Jeej 27:934ab7455115 217 {
Jeej 30:d775c1409849 218 // If file is not found locally, it is a distant file
Jeej 27:934ab7455115 219 hdr.bf.type = HOST;
Jeej 27:934ab7455115 220 }
Jeej 27:934ab7455115 221
Jeej 27:934ab7455115 222 switch (hdr.bf.type)
Jeej 27:934ab7455115 223 {
Jeej 27:934ab7455115 224 // "Local" files are also supported through "posted" API
Jeej 27:934ab7455115 225 case EEPROM:
Jeej 27:934ab7455115 226 case RAM:
Jeej 27:934ab7455115 227 case PFLASH:
Jeej 27:934ab7455115 228 // "Local" file, respond right away
Jeej 27:934ab7455115 229 d7a_fs_read(fid,data,offset,length);
Jeej 30:d775c1409849 230 g_fs_ctx.callback->read_file(fid, offset, length, (uint8_t*)data);
Jeej 27:934ab7455115 231 // Inform requester
Jeej 27:934ab7455115 232 g_fs_ctx.fs_done.put((void*)fid);
Jeej 27:934ab7455115 233 local = 1;
Jeej 27:934ab7455115 234 break;
Jeej 27:934ab7455115 235 // "Distant" Files
Jeej 27:934ab7455115 236 case HOST:
Jeej 30:d775c1409849 237 id = d7a_fs_get_req_id();
Jeej 30:d775c1409849 238 g_fs_ctx.com[id].req = (d7a_fs_com_req_t){id,FS_OP_RD,fid,offset,length};
Jeej 30:d775c1409849 239 g_fs_ctx.com[id].data = data;
Jeej 30:d775c1409849 240 d7a_fs_msg((uint8_t*)&g_fs_ctx.com[id].req, sizeof(d7a_fs_com_req_t), KAL_COM_FLOW_FS_CMD);
Jeej 27:934ab7455115 241 break;
Jeej 27:934ab7455115 242 // Wrong type
Jeej 27:934ab7455115 243 default:
Jeej 27:934ab7455115 244 ASSERT(false, "FS:post_read wrong file type %x\n", hdr.bf.type);
Jeej 27:934ab7455115 245 }
Jeej 27:934ab7455115 246 return local;
Jeej 27:934ab7455115 247 }
Jeej 27:934ab7455115 248
Jeej 27:934ab7455115 249
Jeej 25:aac250164497 250
Jeej 30:d775c1409849 251 #define OP_SIZE_RD 11
Jeej 30:d775c1409849 252 #define OP_SIZE_WR 11
Jeej 30:d775c1409849 253 #define OP_SIZE_TOUCH 11
Jeej 30:d775c1409849 254 #define OP_SIZE_STAT 3
Jeej 30:d775c1409849 255 #define OP_SIZE_FLUSH 3
Jeej 30:d775c1409849 256 #define OP_SIZE_CREATE 11
Jeej 30:d775c1409849 257 #define OP_SIZE_RETSTAT (3+4)
Jeej 30:d775c1409849 258 #define OP_SIZE_RETDATA (3+4)
Jeej 30:d775c1409849 259 uint8_t k_valid_cmd[] = {FS_OP_RD, FS_OP_WR, FS_OP_TOUCH ,FS_OP_STAT, FS_OP_FLUSH, FS_OP_CREATE};
Jeej 30:d775c1409849 260 uint8_t k_valid_size[]= {OP_SIZE_RD,OP_SIZE_WR,OP_SIZE_TOUCH,OP_SIZE_STAT,OP_SIZE_FLUSH,OP_SIZE_CREATE};
Jeej 30:d775c1409849 261
Jeej 25:aac250164497 262
Jeej 25:aac250164497 263
Jeej 30:d775c1409849 264 /// ------------------------------------------------------------------
Jeej 30:d775c1409849 265 /// |TOKEN|CMD/RESP| PAYLOAD |
Jeej 30:d775c1409849 266 /// --------------------------------------------------------------
Jeej 30:d775c1409849 267 /// | 1B | 1B | PKT.blen - 1 bytes |
Jeej 30:d775c1409849 268 /// --------------------------------------------------------------
Jeej 30:d775c1409849 269 /// | | | 1B | 4B | 4B | PKT.blen - 11 bytes|
Jeej 30:d775c1409849 270 /// --------------------------------------------------------------
Jeej 30:d775c1409849 271 // | | write | FID | offset | length | datas... |
Jeej 30:d775c1409849 272 // | | read | FID | offset | length |
Jeej 30:d775c1409849 273 // | | touch | FID | offset | length |
Jeej 30:d775c1409849 274 // | | exist | FID |
Jeej 30:d775c1409849 275 // | | flush | FID |
Jeej 30:d775c1409849 276 // | | retstat|status| length | <kal_fs_properties_t>
Jeej 30:d775c1409849 277 // | | retdat |status| length | datas... |
Jeej 25:aac250164497 278 void d7a_fs_thread(const void *p)
Jeej 25:aac250164497 279 {
Jeej 25:aac250164497 280 FPRINT("\r\n");
Jeej 25:aac250164497 281 d7a_com_rx_msg_t* pkt;
Jeej 26:9f0b9833cac6 282 int8_t status = FS_STAT_OK;
Jeej 25:aac250164497 283
Jeej 25:aac250164497 284 while (true)
Jeej 25:aac250164497 285 {
Jeej 25:aac250164497 286 status = FS_STAT_OK;
Jeej 25:aac250164497 287 // TODO: For now only one outgoing-request can be pending
Jeej 25:aac250164497 288 // An incoming-request response can be served simultaneously
Jeej 25:aac250164497 289 // TODO: handle segmentation. For now MTU = 255-10 = 245
Jeej 25:aac250164497 290 pkt = d7a_fs_wait_pkt();
Jeej 25:aac250164497 291 ASSERT(pkt != NULL, "FS NULL pkt\r\n");
Jeej 25:aac250164497 292 // ---------------------------------------------------------------------------
Jeej 25:aac250164497 293 // Peer request
Jeej 25:aac250164497 294 // ---------------------------------------------------------------------------
Jeej 25:aac250164497 295 switch (pkt->id)
Jeej 25:aac250164497 296 {
Jeej 25:aac250164497 297 case KAL_COM_FLOW_FS_CMD:
Jeej 25:aac250164497 298 d7a_fs_com_req_t* req = (d7a_fs_com_req_t*)pkt->buffer;
Jeej 33:f9a542d3efaa 299 DPRINT("Rfs(%d)[%d] cmd:%d\n", req->id, req->fid, req->cmd);
Jeej 30:d775c1409849 300 //dbg_print_data("%02X ", (uint8_t*)req, sizeof(d7a_fs_com_req_t));
Jeej 30:d775c1409849 301 //DPRINT("\r\n");
Jeej 30:d775c1409849 302 d7a_fs_com_resp_t buf = (d7a_fs_com_resp_t) {.id = req->id, .cmd = FS_OP_RETSTAT};
Jeej 25:aac250164497 303
Jeej 25:aac250164497 304 // Error management makes sense here as we face peer-requests,
Jeej 25:aac250164497 305 // and we don't want to assert because of the peer.
Jeej 25:aac250164497 306 //status = d7a_fs_check_req(req, pkt->blen);
Jeej 25:aac250164497 307 //buf.status = status;
Jeej 25:aac250164497 308 buf.status = FS_STAT_OK;
Jeej 25:aac250164497 309
Jeej 25:aac250164497 310 // From here we assume that the request is valid
Jeej 25:aac250164497 311 // TODO: for now we consider that COM-FS request are targetting
Jeej 25:aac250164497 312 // FIDs that are "local" to the Host, but we can extend this
Jeej 25:aac250164497 313 // to "distant" files as well.(i.e. access SPI-Flash of an Host)
Jeej 25:aac250164497 314 if (status != FS_STAT_OK)
Jeej 25:aac250164497 315 {
Jeej 25:aac250164497 316 buf.length = 0;
Jeej 25:aac250164497 317 // Here we respond to request errors and OP_STAT
Jeej 25:aac250164497 318 d7a_fs_msg((uint8_t*)&buf,OP_SIZE_RETSTAT, KAL_COM_FLOW_FS_RESP);
Jeej 25:aac250164497 319 }
Jeej 25:aac250164497 320 else if (req->cmd == FS_OP_RD)
Jeej 25:aac250164497 321 {
Jeej 25:aac250164497 322 d7a_fs_com_resp_t* b = (d7a_fs_com_resp_t*)MALLOC(OP_SIZE_RETDATA + req->length);
Jeej 30:d775c1409849 323 uint32_t len = g_fs_ctx.callback->read_file(req->fid, req->offset, req->length, &b->data[0]);
Jeej 30:d775c1409849 324 b->id = req->id;
Jeej 25:aac250164497 325 b->length = len;
Jeej 25:aac250164497 326 b->cmd = FS_OP_RETDATA;
Jeej 25:aac250164497 327 b->status = FS_STAT_OK; // TODO
Jeej 25:aac250164497 328 d7a_fs_msg((uint8_t*)b, OP_SIZE_RETDATA + req->length, KAL_COM_FLOW_FS_RESP);
Jeej 25:aac250164497 329 FREE(b);
Jeej 25:aac250164497 330 }
Jeej 25:aac250164497 331 else if (req->cmd == FS_OP_WR)
Jeej 25:aac250164497 332 {
Jeej 30:d775c1409849 333 buf.length = g_fs_ctx.callback->write_file(req->fid, req->offset, req->length, &pkt->buffer[OP_SIZE_WR]);
Jeej 25:aac250164497 334 d7a_fs_msg((uint8_t*)&buf, OP_SIZE_RETSTAT, KAL_COM_FLOW_FS_RESP);
Jeej 25:aac250164497 335 }
Jeej 25:aac250164497 336 else if (req->cmd == FS_OP_STAT)
Jeej 25:aac250164497 337 {
Jeej 25:aac250164497 338 // If file doesn't exist, FS_OP_STAT response is already handled
Jeej 25:aac250164497 339 // by the common d7a_fs_check_req error response.
Jeej 25:aac250164497 340 d7a_fs_com_resp_t* b = (d7a_fs_com_resp_t*)MALLOC(OP_SIZE_RETSTAT + sizeof(d7a_fs_properties_t));
Jeej 25:aac250164497 341 d7a_fs_get_properties(req->fid, KAL_FS_PROP_ALL, (d7a_fs_properties_t*) &b->data[0]);
Jeej 25:aac250164497 342 d7a_fs_properties_t* props = (d7a_fs_properties_t*)&b->data[0];
Jeej 30:d775c1409849 343 b->id = req->id;
Jeej 25:aac250164497 344 b->length = props->length;
Jeej 25:aac250164497 345 b->cmd = FS_OP_RETSTAT;
Jeej 25:aac250164497 346 b->status = FS_STAT_OK;
Jeej 26:9f0b9833cac6 347 d7a_fs_msg((uint8_t*)b, OP_SIZE_RETSTAT + sizeof(d7a_fs_properties_t), KAL_COM_FLOW_FS_RESP);
Jeej 25:aac250164497 348 FREE(b);
Jeej 25:aac250164497 349 }
Jeej 25:aac250164497 350 else if (req->cmd == FS_OP_FLUSH)
Jeej 25:aac250164497 351 {
Jeej 25:aac250164497 352 //d7a_fs_flush(req->fid);
Jeej 25:aac250164497 353 //d7a_fs_msg((uint8_t*)&buf, OP_SIZE_RETSTAT, KAL_COM_FLOW_FS_RESP);
Jeej 25:aac250164497 354 }
Jeej 25:aac250164497 355 else if (req->cmd == FS_OP_CREATE)
Jeej 25:aac250164497 356 {
Jeej 25:aac250164497 357 //d7a_fs_create(req->fid,(d7a_fs_properties_t*)&pkt->buffer[OP_SIZE_CREATE]);
Jeej 25:aac250164497 358 //d7a_fs_msg((uint8_t*)&buf, OP_SIZE_RETSTAT, KAL_COM_FLOW_FS_RESP);
Jeej 25:aac250164497 359 }
Jeej 29:8e7c5c1e9aab 360 else if (req->cmd == FS_OP_TOUCH)
Jeej 29:8e7c5c1e9aab 361 {
Jeej 30:d775c1409849 362 buf.length = g_fs_ctx.callback->touch_file(req->fid, req->offset, req->length);
Jeej 29:8e7c5c1e9aab 363 d7a_fs_msg((uint8_t*)&buf, OP_SIZE_RETSTAT, KAL_COM_FLOW_FS_RESP);
Jeej 29:8e7c5c1e9aab 364 }
Jeej 26:9f0b9833cac6 365 else
Jeej 26:9f0b9833cac6 366 {
Jeej 26:9f0b9833cac6 367 ASSERT(false, "FS: Unknown cmd %d\r\n", req->cmd);
Jeej 26:9f0b9833cac6 368 }
Jeej 25:aac250164497 369 break;
Jeej 25:aac250164497 370 // ---------------------------------------------------------------------------
Jeej 25:aac250164497 371 // Response to our commands
Jeej 25:aac250164497 372 // ---------------------------------------------------------------------------
Jeej 25:aac250164497 373 case KAL_COM_FLOW_FS_RESP:
Jeej 25:aac250164497 374 d7a_fs_com_resp_t* resp = (d7a_fs_com_resp_t*)pkt->buffer;
Jeej 30:d775c1409849 375 uint8_t id = resp->id;
Jeej 30:d775c1409849 376 DPRINT("Rfs(%d) resp - cmd:%d status:%d bytes:%d\n", id, resp->cmd, resp->status, resp->length);
Jeej 30:d775c1409849 377 //dbg_print_data("%02X ", (uint8_t*)resp, sizeof(d7a_fs_com_resp_t));
Jeej 30:d775c1409849 378 //DPRINT("\r\n");
Jeej 30:d775c1409849 379 ASSERT(g_fs_ctx.com[id].req.cmd != FS_OP_NULL, "FS: Unexpected FS_RESP ID:%d CMD:%d status:%d LEN:%d\n", id, resp->cmd, resp->status, resp->length);
Jeej 30:d775c1409849 380 if (g_fs_ctx.com[id].req.cmd != FS_OP_STAT &&
Jeej 30:d775c1409849 381 g_fs_ctx.com[id].req.cmd != FS_OP_DSTAT )
Jeej 25:aac250164497 382 {
Jeej 25:aac250164497 383 // No pity for errors here, handled-ones should be avoided at
Jeej 25:aac250164497 384 // upper level, the others diserve to assert anyway.
Jeej 26:9f0b9833cac6 385 ASSERT(resp->status == FS_STAT_OK, "FS: Peer error:%d\n", resp->status);
Jeej 25:aac250164497 386
Jeej 25:aac250164497 387 // Fill read buffer
Jeej 25:aac250164497 388 if (resp->cmd == FS_OP_RETDATA)
Jeej 25:aac250164497 389 {
Jeej 30:d775c1409849 390 memcpy(g_fs_ctx.com[id].data, &resp->data[0], resp->length);
Jeej 25:aac250164497 391 }
Jeej 25:aac250164497 392 else if (resp->cmd == FS_OP_RETSTAT)
Jeej 25:aac250164497 393 {
Jeej 30:d775c1409849 394 if (g_fs_ctx.com[id].req.cmd == FS_OP_WR)
Jeej 25:aac250164497 395 {
Jeej 25:aac250164497 396 // We did a successful WR, update size if needed
Jeej 25:aac250164497 397 // TODO:This is not really enforcing header coherency. It will do the
Jeej 25:aac250164497 398 // job for Hosted NVM storage, provided the Host doesn't use the file for
Jeej 25:aac250164497 399 // writing.
Jeej 25:aac250164497 400 d7a_fs_header_t hdr;
Jeej 30:d775c1409849 401 d7a_fs_hdr(g_fs_ctx.com[id].req.fid, &hdr);
Jeej 25:aac250164497 402 if (resp->length != hdr.bf.length)
Jeej 25:aac250164497 403 {
Jeej 30:d775c1409849 404 hdr.bf.length = resp->length;
Jeej 30:d775c1409849 405 g_fs_ctx.callback->set_stat(g_fs_ctx.com[id].req.fid, &hdr);
Jeej 25:aac250164497 406 }
Jeej 25:aac250164497 407 }
Jeej 25:aac250164497 408 }
Jeej 25:aac250164497 409 }
Jeej 25:aac250164497 410 else // FS_OP_STAT/DSTAT
Jeej 25:aac250164497 411 {
Jeej 30:d775c1409849 412 if (g_fs_ctx.com[id].req.cmd == FS_OP_STAT)
Jeej 25:aac250164497 413 {
Jeej 25:aac250164497 414 d7a_fs_header_t hdr;
Jeej 30:d775c1409849 415 d7a_fs_hdr(g_fs_ctx.com[id].req.fid, &hdr);
Jeej 25:aac250164497 416 // Try to keep HOST-files coherency as much as we can:
Jeej 25:aac250164497 417 // STAT returns the full header so we can update all fields.
Jeej 25:aac250164497 418 if (hdr.byte.type == HOST)
Jeej 25:aac250164497 419 {
Jeej 25:aac250164497 420 d7a_fs_properties_t* props = (d7a_fs_properties_t*)&resp->data[0];
Jeej 25:aac250164497 421 // XXX d7a_fs_set_properties_p is for now keeping our file remote,
Jeej 25:aac250164497 422 // as it doesn't change addr,type,mirror etc.
Jeej 25:aac250164497 423 //d7a_fs_set_properties(hdr, (uint32_t)props);
Jeej 25:aac250164497 424 }
Jeej 25:aac250164497 425 }
Jeej 25:aac250164497 426 // TODO: for now only keep length info for upper layer. (normal for a STAT)
Jeej 30:d775c1409849 427 if (g_fs_ctx.com[id].data != NULL)
Jeej 26:9f0b9833cac6 428 {
Jeej 30:d775c1409849 429 *(uint32_t*)g_fs_ctx.com[id].data = resp->length;
Jeej 26:9f0b9833cac6 430 }
Jeej 25:aac250164497 431 status = resp->status;
Jeej 25:aac250164497 432 }
Jeej 25:aac250164497 433 // Free to serve a new request
Jeej 30:d775c1409849 434 g_fs_ctx.com[id].req.cmd = FS_OP_NULL;
Jeej 25:aac250164497 435 // Inform requester
Jeej 26:9f0b9833cac6 436 g_fs_ctx.fs_done.put((void*)status);
Jeej 25:aac250164497 437 break;
Jeej 25:aac250164497 438 default:
Jeej 25:aac250164497 439 EPRINT("FS Unknown Flow ID 0x%02X\r\n", pkt->id);
Jeej 25:aac250164497 440 break;
Jeej 25:aac250164497 441 }
Jeej 25:aac250164497 442 FREE(pkt);
Jeej 25:aac250164497 443 }
Jeej 25:aac250164497 444 }