1 #include <stdio.h>
2 #include <string.h>
3 #include <stdlib.h>
4 
5 #include "py/mperrno.h"
6 #include "py/obj.h"
7 #include "py/runtime.h"
8 #include "py/builtin.h"
9 
10 #include "ulog/ulog.h"
11 
12 
13 #define LOG_TAG "SYSTEM_FS"
14 
15 extern const mp_obj_type_t system_fs_type;
16 extern int amp_get_user_dir(char *dir);
17 // this is the actual C-structure for our new object
18 
check_fs_is_support()19 static int check_fs_is_support()
20 {
21     int ret;
22 	void *fp;
23     const char *string = "test if fs mount ok";
24     char testfile[64]  = {0};
25     char root_dir[128] = {0};
26 #if 0
27     amp_get_user_dir(root_dir);
28     snprintf(testfile, sizeof(testfile), "%s/%s", root_dir,
29              "testfile.txt");
30     fp = amp_fopen(testfile, "w+");
31     if (fp == NULL) {
32         LOGE(LOG_TAG, "check_fs_is_support open fail\n");
33         return 0;
34     }
35 
36     ret = amp_fwrite((char *)string, 1, strlen(string), fp);
37     if (ret <= 0) {
38         LOGE(LOG_TAG, "check_fs_is_support write fail\n");
39         amp_fclose(fp);
40         return 0;
41     }
42 
43     amp_fclose(fp);
44 
45     ret = amp_remove(testfile);
46     if (ret) {
47         LOGE(LOG_TAG, "check_fs_is_support sync fail\n");
48         return 0;
49     }
50 #endif
51     return 1;
52 }
53 
54 typedef struct
55 {
56     // base represents some basic information, like type
57     mp_obj_base_t Base;
58     // a member created by us
59     char *ModuleName;
60 } mp_fs_obj_t;
61 
fs_obj_print(const mp_print_t * print,mp_obj_t self_in,mp_print_kind_t kind)62 void fs_obj_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind)
63 {
64     LOGD(LOG_TAG, "entern %s;\n", __func__);
65     mp_fs_obj_t *self = MP_OBJ_TO_PTR(self_in);
66     mp_printf(print, "ModuleName(%s)", self->ModuleName);
67 }
68 
fs_obj_make_new(const mp_obj_type_t * type,size_t n_args,size_t n_kw,const mp_obj_t * args)69 STATIC mp_obj_t fs_obj_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args)
70 {
71     LOGD(LOG_TAG, "entern  %s;\n", __func__);
72     mp_fs_obj_t* driver_obj = m_new_obj(mp_fs_obj_t);
73     if (!driver_obj) {
74         mp_raise_OSError(ENOMEM);
75     }
76 
77     driver_obj->Base.type = &system_fs_type;
78     driver_obj->ModuleName = "fs";
79 
80     return MP_OBJ_FROM_PTR(driver_obj);
81 }
82 
obj_open(size_t n_args,const mp_obj_t * args)83 STATIC mp_obj_t obj_open(size_t n_args, const mp_obj_t *args)
84 {
85     LOGD(LOG_TAG, "entern  %s; n_args = %d;\n", __func__, n_args);
86     int ret = -1;
87     if (n_args < 1)
88     {
89         LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
90         return mp_const_none;
91     }
92     mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
93     mp_fs_obj_t* driver_obj = (mp_fs_obj_t *)self;
94     if (driver_obj == NULL)
95     {
96         LOGE(LOG_TAG, "driver_obj is NULL\n");
97         return mp_const_none;
98     }
99     LOGD(LOG_TAG, "%s:out\n", __func__);
100 
101     return mp_const_none;
102 }
103 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(fs_obj_open, 1, obj_open);
104 
obj_close(size_t n_args,const mp_obj_t * args)105 STATIC mp_obj_t obj_close(size_t n_args, const mp_obj_t *args)
106 {
107     LOGD(LOG_TAG, "entern  %s; n_args = %d;\n", __func__, n_args);
108     int ret = -1;
109     if (n_args < 1)
110     {
111         LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
112         return mp_const_none;
113     }
114     mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
115     mp_fs_obj_t* driver_obj = (mp_fs_obj_t *)self;
116     if (driver_obj == NULL)
117     {
118         LOGE(LOG_TAG, "driver_obj is NULL\n");
119         return mp_const_none;
120     }
121     LOGD(LOG_TAG, "%s:out\n", __func__);
122 
123     return mp_const_none;
124 }
125 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(fs_obj_close, 1, obj_close);
126 
obj_issupport(size_t n_args,const mp_obj_t * args)127 STATIC mp_obj_t obj_issupport(size_t n_args, const mp_obj_t *args)
128 {
129     LOGD(LOG_TAG, "entern  %s; n_args = %d;\n", __func__, n_args);
130     int ret = -1;
131     if (n_args < 1)
132     {
133         LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
134         return mp_const_none;
135     }
136     mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
137     mp_fs_obj_t* driver_obj = (mp_fs_obj_t *)self;
138     if (driver_obj == NULL)
139     {
140         LOGE(LOG_TAG, "driver_obj is NULL\n");
141         return mp_const_none;
142     }
143 
144     ret = check_fs_is_support();
145     LOGD(LOG_TAG, "%s:out\n", __func__);
146 
147     return MP_ROM_INT(ret);
148 }
149 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(fs_obj_issupport, 1, obj_issupport);
150 
obj_read(size_t n_args,const mp_obj_t * args)151 STATIC mp_obj_t obj_read(size_t n_args, const mp_obj_t *args)
152 {
153     LOGD(LOG_TAG, "entern  %s; n_args = %d;\n", __func__, n_args);
154     int ret = -1;
155     void *fp   = NULL;
156     int len  = 0;
157     int size = 0;
158     int32_t curpos = -1;
159     char *path;
160     char *buf = NULL;
161     if (n_args < 2)
162     {
163         LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
164         return mp_const_none;
165     }
166     mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
167     mp_fs_obj_t* driver_obj = (mp_fs_obj_t *)self;
168     if (driver_obj == NULL)
169     {
170         LOGE(LOG_TAG, "driver_obj is NULL\n");
171         return mp_const_none;
172     }
173 
174     path = (char *)mp_obj_str_get_str(args[1]);
175     LOGD(LOG_TAG, "%s: path = %s;\n", __func__, path);
176 #if 0
177     fp   = amp_fopen(path, "r");
178     if (fp == NULL) {
179         LOGE(LOG_TAG, "jse_open failed\n");
180         goto out;
181     }
182 
183     amp_fseek(fp, 0, HAL_SEEK_END, &curpos);
184     if (curpos < 0) {
185         size = amp_ftell(fp);
186     } else {
187         size = curpos;
188     }
189 
190     amp_fseek(fp, 0, HAL_SEEK_SET, &curpos);
191 
192     buf = (char *)amp_malloc(size + 1);
193     if (!buf) {
194         LOGE(LOG_TAG, "malloc failed\n");
195         amp_fclose(fp);
196         goto out;
197     }
198 
199     len = amp_fread(buf, 1, size, fp);
200     if (len > 0) {
201         buf[len] = 0;
202         LOGE(LOG_TAG, "read data: %s\n", buf);
203     }
204     amp_fclose(fp);
205 
206     mp_obj_base_t *content = MP_ROM_QSTR(buf);
207 out:
208     amp_free(buf);
209     LOGD(LOG_TAG, "%s:out\n", __func__);
210 
211     return content;
212 #else
213     return mp_const_none;
214 #endif
215 }
216 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(fs_obj_read, 2, obj_read);
217 
obj_write(size_t n_args,const mp_obj_t * args)218 STATIC mp_obj_t obj_write(size_t n_args, const mp_obj_t *args)
219 {
220     LOGD(LOG_TAG, "entern  %s; n_args = %d;\n", __func__, n_args);
221     int ret = -1;
222     void *fp = NULL;
223     size_t str_len = 0;
224     size_t nwrite  = 0;
225     char *path;
226     char *content;
227     char *flag;
228 
229     if (n_args < 4)
230     {
231         LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
232         return mp_const_none;
233     }
234     mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
235     mp_fs_obj_t* driver_obj = (mp_fs_obj_t *)self;
236     if (driver_obj == NULL)
237     {
238         LOGE(LOG_TAG, "driver_obj is NULL\n");
239         return mp_const_none;
240     }
241 
242     path = (char *)mp_obj_str_get_str(args[1]);
243     flag = (char *)mp_obj_str_get_str(args[2]);
244     LOGD(LOG_TAG, "%s:path = %s;flag = %s;\n", __func__, path, flag);
245 #if 0
246 	mp_buffer_info_t src;
247     mp_get_buffer_raise(args[3], &src, MP_BUFFER_READ);
248     LOGD(LOG_TAG, "%s:src.buf = %p;src.len = %d;\n", __func__, src.buf, src.len);
249     content = (char*)src.buf;
250     str_len = src.len;
251 
252     fp   = amp_fopen(path, flag);
253     if (fp == NULL) {
254         LOGE(LOG_TAG, "be_osal_open fail\n");
255         return mp_const_none;
256     }
257 
258     nwrite = amp_fwrite((char *)content, 1, str_len, fp);
259     if (nwrite <= 0) {
260         LOGE(LOG_TAG, "be_osal_write fail\n");
261         amp_fclose(fp);
262         return mp_const_none;
263     }
264 
265     LOGD(LOG_TAG, "FS.write(%s,%s,%s);\n", path, content, flag);
266 
267     amp_fsync(fp);
268     amp_fclose(fp);
269 #endif
270     LOGD(LOG_TAG, "%s:out\n", __func__);
271 
272     return mp_const_none;
273 }
274 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(fs_obj_write, 4, obj_write);
275 
obj_delete(size_t n_args,const mp_obj_t * args)276 STATIC mp_obj_t obj_delete(size_t n_args, const mp_obj_t *args)
277 {
278     LOGD(LOG_TAG, "entern  %s; n_args = %d;\n", __func__, n_args);
279     int ret = -1;
280     char *path;
281     if (n_args < 2)
282     {
283         LOGE(LOG_TAG, "%s: args num is illegal :n_args = %d;\n", __func__, n_args);
284         return mp_const_none;
285     }
286     mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
287     mp_fs_obj_t* driver_obj = (mp_fs_obj_t *)self;
288     if (driver_obj == NULL)
289     {
290         LOGE(LOG_TAG, "driver_obj is NULL\n");
291         return mp_const_none;
292     }
293     path = (char *)mp_obj_str_get_str(args[1]);
294     LOGD(LOG_TAG, "%s:path = %s;\n", __func__, path);
295     //ret  = amp_remove(path);
296     LOGD(LOG_TAG, "%s:out\n", __func__);
297 
298     return MP_ROM_INT(ret);
299 }
300 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR(fs_obj_delete, 2, obj_delete);
301 
302 STATIC const mp_rom_map_elem_t fs_locals_dict_table[] = {
303     {MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_FS)},
304     {MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&fs_obj_open)},
305     {MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&fs_obj_close)},
306     {MP_ROM_QSTR(MP_QSTR_issupport), MP_ROM_PTR(&fs_obj_issupport)},
307     {MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&fs_obj_read)},
308     {MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&fs_obj_write)},
309     {MP_ROM_QSTR(MP_QSTR_delete), MP_ROM_PTR(&fs_obj_delete)},
310 };
311 
312 STATIC MP_DEFINE_CONST_DICT(fs_locals_dict, fs_locals_dict_table);
313 
314 const mp_obj_type_t system_fs_type = {
315     .base = {&mp_type_type},
316     .name = MP_QSTR_FS,
317     .print = fs_obj_print,
318     .make_new = fs_obj_make_new,
319     .locals_dict = (mp_obj_dict_t *)&fs_locals_dict,
320 };
321 
322