1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <plat/inc/taggedPtr.h> 18 #include <plat/inc/rtc.h> 19 #include <syscall.h> 20 #include <sensors.h> 21 #include <errno.h> 22 #include <osApi.h> 23 #include <timer.h> 24 #include <gpio.h> 25 #include <util.h> 26 #include <seos.h> 27 #include <slab.h> 28 #include <heap.h> 29 #include <i2c.h> 30 #include <nanohubCommand.h> 31 32 static struct SlabAllocator *mSlabAllocator; 33 34 35 static void osExpApiEvtqSubscribe(uintptr_t *retValP, va_list args) 36 { 37 (void)va_arg(args, uint32_t); // tid 38 uint32_t evtType = va_arg(args, uint32_t); 39 40 *retValP = osEventSubscribe(0, evtType); 41 } 42 43 static void osExpApiEvtqUnsubscribe(uintptr_t *retValP, va_list args) 44 { 45 (void)va_arg(args, uint32_t); // tid 46 uint32_t evtType = va_arg(args, uint32_t); 47 48 *retValP = osEventUnsubscribe(0, evtType); 49 } 50 51 static void osExpApiEvtqEnqueue(uintptr_t *retValP, va_list args) 52 { 53 uint32_t evtType = va_arg(args, uint32_t); 54 void *evtData = va_arg(args, void*); 55 (void)va_arg(args, uint32_t); // tid 56 57 *retValP = osEnqueueEvtAsApp(evtType, evtData, 0); 58 } 59 60 static void osExpApiEvtqEnqueuePrivate(uintptr_t *retValP, va_list args) 61 { 62 uint32_t evtType = va_arg(args, uint32_t); 63 void *evtData = va_arg(args, void*); 64 (void)va_arg(args, uint32_t); // tid 65 uint32_t toTid = va_arg(args, uint32_t); 66 67 *retValP = osEnqueuePrivateEvtAsApp(evtType, evtData, 0, toTid); 68 } 69 70 static void osExpApiEvtqRetainEvt(uintptr_t *retValP, va_list args) 71 { 72 TaggedPtr *evtFreeingInfoP = va_arg(args, TaggedPtr*); 73 74 *retValP = osRetainCurrentEvent(evtFreeingInfoP); 75 } 76 77 static void osExpApiEvtqFreeRetained(uintptr_t *retValP, va_list args) 78 { 79 uint32_t evtType = va_arg(args, uint32_t); 80 void *evtData = va_arg(args, void*); 81 TaggedPtr *evtFreeingInfoP = va_arg(args, TaggedPtr*); 82 83 osFreeRetainedEvent(evtType, evtData, evtFreeingInfoP); 84 } 85 86 static void osExpApiLogLogv(uintptr_t *retValP, va_list args) 87 { 88 enum LogLevel level = va_arg(args, int /* enums promoted to ints in va_args in C */); 89 const char *str = va_arg(args, const char*); 90 va_list innerArgs; 91 va_copy(innerArgs, INTEGER_TO_VA_LIST(va_arg(args, uintptr_t))); 92 osLogv(level, str, innerArgs); 93 va_end(innerArgs); 94 } 95 96 static void osExpApiSensorSignal(uintptr_t *retValP, va_list args) 97 { 98 uint32_t handle = va_arg(args, uint32_t); 99 uint32_t intEvtNum = va_arg(args, uint32_t); 100 uint32_t value1 = va_arg(args, uint32_t); 101 uint32_t value2_lo = va_arg(args, uint32_t); 102 uint32_t value2_hi = va_arg(args, uint32_t); 103 uint64_t value2 = (((uint64_t)value2_hi) << 32) + value2_lo; 104 105 *retValP = (uintptr_t)sensorSignalInternalEvt(handle, intEvtNum, value1, value2); 106 } 107 108 static void osExpApiSensorReg(uintptr_t *retValP, va_list args) 109 { 110 const struct SensorInfo *si = va_arg(args, const struct SensorInfo*); 111 (void)va_arg(args, uint32_t); // tid 112 void *cookie = va_arg(args, void *); 113 bool initComplete = va_arg(args, int); 114 115 *retValP = (uintptr_t)sensorRegisterAsApp(si, 0, cookie, initComplete); 116 } 117 118 static void osExpApiSensorUnreg(uintptr_t *retValP, va_list args) 119 { 120 uint32_t handle = va_arg(args, uint32_t); 121 122 *retValP = (uintptr_t)sensorUnregister(handle); 123 } 124 125 static void osExpApiSensorRegInitComp(uintptr_t *retValP, va_list args) 126 { 127 uint32_t handle = va_arg(args, uint32_t); 128 129 *retValP = (uintptr_t)sensorRegisterInitComplete(handle); 130 } 131 132 static void osExpApiSensorFind(uintptr_t *retValP, va_list args) 133 { 134 uint32_t sensorType = va_arg(args, uint32_t); 135 uint32_t idx = va_arg(args, uint32_t); 136 uint32_t *handleP = va_arg(args, uint32_t*); 137 138 *retValP = (uintptr_t)sensorFind(sensorType, idx, handleP); 139 } 140 141 static void osExpApiSensorReq(uintptr_t *retValP, va_list args) 142 { 143 (void)va_arg(args, uint32_t); // clientId == tid 144 uint32_t sensorHandle = va_arg(args, uint32_t); 145 uint32_t rate = va_arg(args, uint32_t); 146 uint32_t latency_lo = va_arg(args, uint32_t); 147 uint32_t latency_hi = va_arg(args, uint32_t); 148 uint64_t latency = (((uint64_t)latency_hi) << 32) + latency_lo; 149 150 *retValP = sensorRequest(0, sensorHandle, rate, latency); 151 } 152 153 static void osExpApiSensorRateChg(uintptr_t *retValP, va_list args) 154 { 155 (void)va_arg(args, uint32_t); // clientId == tid 156 uint32_t sensorHandle = va_arg(args, uint32_t); 157 uint32_t newRate = va_arg(args, uint32_t); 158 uint32_t newLatency_lo = va_arg(args, uint32_t); 159 uint32_t newLatency_hi = va_arg(args, uint32_t); 160 uint64_t newLatency = (((uint64_t)newLatency_hi) << 32) + newLatency_lo; 161 162 *retValP = sensorRequestRateChange(0, sensorHandle, newRate, newLatency); 163 } 164 165 static void osExpApiSensorRel(uintptr_t *retValP, va_list args) 166 { 167 (void)va_arg(args, uint32_t); // clientId == tid 168 uint32_t sensorHandle = va_arg(args, uint32_t); 169 170 *retValP = sensorRelease(0, sensorHandle); 171 } 172 173 static void osExpApiSensorTrigger(uintptr_t *retValP, va_list args) 174 { 175 (void)va_arg(args, uint32_t); // clientId == tid 176 uint32_t sensorHandle = va_arg(args, uint32_t); 177 178 *retValP = sensorTriggerOndemand(0, sensorHandle); 179 } 180 181 static void osExpApiSensorGetRate(uintptr_t *retValP, va_list args) 182 { 183 uint32_t sensorHandle = va_arg(args, uint32_t); 184 185 *retValP = sensorGetCurRate(sensorHandle); 186 } 187 188 static void osExpApiSensorGetTime(uintptr_t *retValP, va_list args) 189 { 190 uint64_t *timeNanos = va_arg(args, uint64_t *); 191 *timeNanos = sensorGetTime(); 192 } 193 194 static void osExpApiTimGetTime(uintptr_t *retValP, va_list args) 195 { 196 uint64_t *timeNanos = va_arg(args, uint64_t *); 197 *timeNanos = timGetTime(); 198 } 199 200 static void osExpApiTimSetTimer(uintptr_t *retValP, va_list args) 201 { 202 uint32_t length_lo = va_arg(args, uint32_t); 203 uint32_t length_hi = va_arg(args, uint32_t); 204 uint32_t jitterPpm = va_arg(args, uint32_t); 205 uint32_t driftPpm = va_arg(args, uint32_t); 206 (void)va_arg(args, uint32_t); // tid 207 void *cookie = va_arg(args, void *); 208 bool oneshot = va_arg(args, int); 209 uint64_t length = (((uint64_t)length_hi) << 32) + length_lo; 210 211 *retValP = timTimerSetAsApp(length, jitterPpm, driftPpm, 0, cookie, oneshot); 212 } 213 214 static void osExpApiTimCancelTimer(uintptr_t *retValP, va_list args) 215 { 216 uint32_t timerId = va_arg(args, uint32_t); 217 218 *retValP = timTimerCancel(timerId); 219 } 220 221 static void osExpApiHeapAlloc(uintptr_t *retValP, va_list args) 222 { 223 uint32_t sz = va_arg(args, uint32_t); 224 225 *retValP = (uintptr_t)heapAlloc(sz); 226 } 227 228 static void osExpApiHeapFree(uintptr_t *retValP, va_list args) 229 { 230 void *mem = va_arg(args, void *); 231 232 heapFree(mem); 233 } 234 235 static void osExpApiSlabNew(uintptr_t *retValP, va_list args) 236 { 237 uint32_t itemSz = va_arg(args, uint32_t); 238 uint32_t itemAlign = va_arg(args, uint32_t); 239 uint32_t numItems = va_arg(args, uint32_t); 240 241 *retValP = (uintptr_t)slabAllocatorNew(itemSz, itemAlign, numItems); 242 } 243 244 static void osExpApiSlabDestroy(uintptr_t *retValP, va_list args) 245 { 246 struct SlabAllocator *allocator = va_arg(args, struct SlabAllocator *); 247 248 slabAllocatorDestroy(allocator); 249 } 250 251 static void osExpApiSlabAlloc(uintptr_t *retValP, va_list args) 252 { 253 struct SlabAllocator *allocator = va_arg(args, struct SlabAllocator *); 254 255 *retValP = (uintptr_t)slabAllocatorAlloc(allocator); 256 } 257 258 static void osExpApiSlabFree(uintptr_t *retValP, va_list args) 259 { 260 struct SlabAllocator *allocator = va_arg(args, struct SlabAllocator *); 261 void *mem = va_arg(args, void *); 262 263 slabAllocatorFree(allocator, mem); 264 } 265 266 static void osExpApiHostGetTime(uintptr_t *retValP, va_list args) 267 { 268 uint64_t *timeNanos = va_arg(args, uint64_t *); 269 *timeNanos = hostGetTime(); 270 } 271 272 static void osExpApiRtcGetTime(uintptr_t *retValP, va_list args) 273 { 274 uint64_t *timeNanos = va_arg(args, uint64_t *); 275 *timeNanos = rtcGetTime(); 276 } 277 278 static union OsApiSlabItem* osExpApiI2cCbkInfoAlloc(void *cookie) 279 { 280 union OsApiSlabItem *thing = slabAllocatorAlloc(mSlabAllocator); 281 282 if (thing) { 283 thing->i2cAppCbkInfo.toTid = osGetCurrentTid(); 284 thing->i2cAppCbkInfo.cookie = cookie; 285 } 286 287 return thing; 288 } 289 290 static void osExpApiI2cInternalEvtFreeF(void *evt) 291 { 292 slabAllocatorFree(mSlabAllocator, evt); 293 } 294 295 static void osExpApiI2cInternalCbk(void *cookie, size_t tx, size_t rx, int err) 296 { 297 union OsApiSlabItem *thing = (union OsApiSlabItem*)cookie; 298 uint32_t tid; 299 300 tid = thing->i2cAppCbkInfo.toTid; 301 cookie = thing->i2cAppCbkInfo.cookie; 302 303 //we reuse the same slab element to send the event now 304 thing->i2cAppCbkEvt.cookie = cookie; 305 thing->i2cAppCbkEvt.tx = tx; 306 thing->i2cAppCbkEvt.rx = rx; 307 thing->i2cAppCbkEvt.err = err; 308 309 if (!osEnqueuePrivateEvt(EVT_APP_I2C_CBK, &thing->i2cAppCbkEvt, osExpApiI2cInternalEvtFreeF, tid)) { 310 osLog(LOG_WARN, "Failed to send I2C evt to app. This might end badly for the app..."); 311 osExpApiI2cInternalEvtFreeF(thing); 312 // TODO: terminate app here: memory pressure is severe 313 } 314 } 315 316 static void osExpApiGpioReq(uintptr_t *retValP, va_list args) 317 { 318 uint32_t gpioNum = va_arg(args, uint32_t); 319 320 *retValP = (uintptr_t)gpioRequest(gpioNum); 321 } 322 323 static void osExpApiGpioRel(uintptr_t *retValP, va_list args) 324 { 325 struct Gpio* gpio = va_arg(args, struct Gpio*); 326 327 gpioRelease(gpio); 328 } 329 330 static void osExpApiGpioCfgIn(uintptr_t *retValP, va_list args) 331 { 332 struct Gpio* gpio = va_arg(args, struct Gpio*); 333 int32_t speed = va_arg(args, int32_t); 334 enum GpioPullMode pullMode = va_arg(args, int); 335 336 gpioConfigInput(gpio, speed, pullMode); 337 } 338 339 static void osExpApiGpioCfgOut(uintptr_t *retValP, va_list args) 340 { 341 struct Gpio* gpio = va_arg(args, struct Gpio*); 342 int32_t speed = va_arg(args, int32_t); 343 enum GpioPullMode pullMode = va_arg(args, int); 344 enum GpioOpenDrainMode odrMode = va_arg(args, int); 345 bool value = !!va_arg(args, int); 346 347 gpioConfigOutput(gpio, speed, pullMode, odrMode, value); 348 } 349 350 static void osExpApiGpioCfgAlt(uintptr_t *retValP, va_list args) 351 { 352 struct Gpio* gpio = va_arg(args, struct Gpio*); 353 int32_t speed = va_arg(args, int32_t); 354 enum GpioPullMode pullMode = va_arg(args, int); 355 enum GpioOpenDrainMode odrMode = va_arg(args, int); 356 uint32_t altFunc = va_arg(args, uint32_t); 357 358 gpioConfigAlt(gpio, speed, pullMode, odrMode, altFunc); 359 } 360 361 static void osExpApiGpioGet(uintptr_t *retValP, va_list args) 362 { 363 struct Gpio* gpio = va_arg(args, struct Gpio*); 364 365 *retValP = gpioGet(gpio); 366 } 367 368 static void osExpApiGpioSet(uintptr_t *retValP, va_list args) 369 { 370 struct Gpio* gpio = va_arg(args, struct Gpio*); 371 bool value = !!va_arg(args, int); 372 373 gpioSet(gpio, value); 374 } 375 376 static void osExpApiI2cMstReq(uintptr_t *retValP, va_list args) 377 { 378 uint32_t busId = va_arg(args, uint32_t); 379 uint32_t speed = va_arg(args, uint32_t); 380 381 *retValP = i2cMasterRequest(busId, speed); 382 } 383 384 static void osExpApiI2cMstRel(uintptr_t *retValP, va_list args) 385 { 386 uint32_t busId = va_arg(args, uint32_t); 387 388 *retValP = i2cMasterRelease(busId); 389 } 390 391 static void osExpApiI2cMstTxRx(uintptr_t *retValP, va_list args) 392 { 393 uint32_t busId = va_arg(args, uint32_t); 394 uint32_t addr = va_arg(args, uint32_t); 395 const void *txBuf = va_arg(args, const void*); 396 size_t txSize = va_arg(args, size_t); 397 void *rxBuf = va_arg(args, void*); 398 size_t rxSize = va_arg(args, size_t); 399 (void)va_arg(args, uint32_t); // tid 400 void *cookie = va_arg(args, void *); 401 union OsApiSlabItem *cbkInfo = osExpApiI2cCbkInfoAlloc(cookie); 402 403 if (!cbkInfo) 404 *retValP = -ENOMEM; 405 406 *retValP = i2cMasterTxRx(busId, addr, txBuf, txSize, rxBuf, rxSize, osExpApiI2cInternalCbk, cbkInfo); 407 408 if (*retValP) 409 slabAllocatorFree(mSlabAllocator, cbkInfo); 410 } 411 412 static void osExpApiI2cSlvReq(uintptr_t *retValP, va_list args) 413 { 414 uint32_t busId = va_arg(args, uint32_t); 415 uint32_t addr = va_arg(args, uint32_t); 416 417 *retValP = i2cSlaveRequest(busId, addr); 418 } 419 420 static void osExpApiI2cSlvRel(uintptr_t *retValP, va_list args) 421 { 422 uint32_t busId = va_arg(args, uint32_t); 423 424 *retValP = i2cSlaveRelease(busId); 425 } 426 427 static void osExpApiI2cSlvRxEn(uintptr_t *retValP, va_list args) 428 { 429 uint32_t busId = va_arg(args, uint32_t); 430 void *rxBuf = va_arg(args, void*); 431 size_t rxSize = va_arg(args, size_t); 432 (void)va_arg(args, uint32_t); // tid 433 void *cookie = va_arg(args, void *); 434 union OsApiSlabItem *cbkInfo = osExpApiI2cCbkInfoAlloc(cookie); 435 436 if (!cbkInfo) 437 *retValP = -ENOMEM; 438 439 i2cSlaveEnableRx(busId, rxBuf, rxSize, osExpApiI2cInternalCbk, cbkInfo); 440 441 if (*retValP) 442 slabAllocatorFree(mSlabAllocator, cbkInfo); 443 } 444 445 static void osExpApiI2cSlvTxPre(uintptr_t *retValP, va_list args) 446 { 447 uint32_t busId = va_arg(args, uint32_t); 448 uint8_t byte = va_arg(args, int); 449 (void)va_arg(args, uint32_t); // tid 450 void *cookie = va_arg(args, void *); 451 union OsApiSlabItem *cbkInfo = osExpApiI2cCbkInfoAlloc(cookie); 452 453 if (!cbkInfo) 454 *retValP = -ENOMEM; 455 456 *retValP = i2cSlaveTxPreamble(busId, byte, osExpApiI2cInternalCbk, cbkInfo); 457 458 if (*retValP) 459 slabAllocatorFree(mSlabAllocator, cbkInfo); 460 } 461 462 static void osExpApiI2cSlvTxPkt(uintptr_t *retValP, va_list args) 463 { 464 uint32_t busId = va_arg(args, uint32_t); 465 const void *txBuf = va_arg(args, const void*); 466 size_t txSize = va_arg(args, size_t); 467 (void)va_arg(args, uint32_t); // tid 468 void *cookie = va_arg(args, void *); 469 union OsApiSlabItem *cbkInfo = osExpApiI2cCbkInfoAlloc(cookie); 470 471 if (!cbkInfo) 472 *retValP = -ENOMEM; 473 474 *retValP = i2cSlaveTxPacket(busId, txBuf, txSize, osExpApiI2cInternalCbk, cbkInfo); 475 476 if (*retValP) 477 slabAllocatorFree(mSlabAllocator, cbkInfo); 478 } 479 480 void osApiExport(struct SlabAllocator *mainSlubAllocator) 481 { 482 static const struct SyscallTable osMainEvtqTable = { 483 .numEntries = SYSCALL_OS_MAIN_EVTQ_LAST, 484 .entry = { 485 [SYSCALL_OS_MAIN_EVTQ_SUBCRIBE] = { .func = osExpApiEvtqSubscribe, }, 486 [SYSCALL_OS_MAIN_EVTQ_UNSUBCRIBE] = { .func = osExpApiEvtqUnsubscribe, }, 487 [SYSCALL_OS_MAIN_EVTQ_ENQUEUE] = { .func = osExpApiEvtqEnqueue, }, 488 [SYSCALL_OS_MAIN_EVTQ_ENQUEUE_PRIVATE] = { .func = osExpApiEvtqEnqueuePrivate, }, 489 [SYSCALL_OS_MAIN_EVTQ_RETAIN_EVT] = { .func = osExpApiEvtqRetainEvt, }, 490 [SYSCALL_OS_MAIN_EVTQ_FREE_RETAINED] = { .func = osExpApiEvtqFreeRetained, }, 491 }, 492 }; 493 494 static const struct SyscallTable osMainLogTable = { 495 .numEntries = SYSCALL_OS_MAIN_LOG_LAST, 496 .entry = { 497 [SYSCALL_OS_MAIN_LOG_LOGV] = { .func = osExpApiLogLogv, }, 498 }, 499 }; 500 501 static const struct SyscallTable osMainSensorsTable = { 502 .numEntries = SYSCALL_OS_MAIN_SENSOR_LAST, 503 .entry = { 504 [SYSCALL_OS_MAIN_SENSOR_SIGNAL] = { .func = osExpApiSensorSignal, }, 505 [SYSCALL_OS_MAIN_SENSOR_REG] = { .func = osExpApiSensorReg, }, 506 [SYSCALL_OS_MAIN_SENSOR_UNREG] = { .func = osExpApiSensorUnreg, }, 507 [SYSCALL_OS_MAIN_SENSOR_REG_INIT_COMP] = { .func = osExpApiSensorRegInitComp }, 508 [SYSCALL_OS_MAIN_SENSOR_FIND] = { .func = osExpApiSensorFind, }, 509 [SYSCALL_OS_MAIN_SENSOR_REQUEST] = { .func = osExpApiSensorReq, }, 510 [SYSCALL_OS_MAIN_SENSOR_RATE_CHG] = { .func = osExpApiSensorRateChg, }, 511 [SYSCALL_OS_MAIN_SENSOR_RELEASE] = { .func = osExpApiSensorRel, }, 512 [SYSCALL_OS_MAIN_SENSOR_TRIGGER] = { .func = osExpApiSensorTrigger, }, 513 [SYSCALL_OS_MAIN_SENSOR_GET_RATE] = { .func = osExpApiSensorGetRate, }, 514 [SYSCALL_OS_MAIN_SENSOR_GET_TIME] = { .func = osExpApiSensorGetTime, }, 515 516 }, 517 }; 518 519 static const struct SyscallTable osMainTimerTable = { 520 .numEntries = SYSCALL_OS_MAIN_TIME_LAST, 521 .entry = { 522 [SYSCALL_OS_MAIN_TIME_GET_TIME] = { .func = osExpApiTimGetTime, }, 523 [SYSCALL_OS_MAIN_TIME_SET_TIMER] = { .func = osExpApiTimSetTimer, }, 524 [SYSCALL_OS_MAIN_TIME_CANCEL_TIMER] = { .func = osExpApiTimCancelTimer, }, 525 }, 526 }; 527 528 static const struct SyscallTable osMainHeapTable = { 529 .numEntries = SYSCALL_OS_MAIN_HEAP_LAST, 530 .entry = { 531 [SYSCALL_OS_MAIN_HEAP_ALLOC] = { .func = osExpApiHeapAlloc }, 532 [SYSCALL_OS_MAIN_HEAP_FREE] = { .func = osExpApiHeapFree }, 533 }, 534 }; 535 536 static const struct SyscallTable osMainSlabTable = { 537 .numEntries = SYSCALL_OS_MAIN_SLAB_LAST, 538 .entry = { 539 [SYSCALL_OS_MAIN_SLAB_NEW] = { .func = osExpApiSlabNew }, 540 [SYSCALL_OS_MAIN_SLAB_DESTROY] = { .func = osExpApiSlabDestroy }, 541 [SYSCALL_OS_MAIN_SLAB_ALLOC] = { .func = osExpApiSlabAlloc }, 542 [SYSCALL_OS_MAIN_SLAB_FREE] = { .func = osExpApiSlabFree }, 543 }, 544 }; 545 546 static const struct SyscallTable osMainHostTable = { 547 .numEntries = SYSCALL_OS_MAIN_HOST_LAST, 548 .entry = { 549 [SYSCALL_OS_MAIN_HOST_GET_TIME] = { .func = osExpApiHostGetTime }, 550 }, 551 }; 552 553 static const struct SyscallTable osMainRtcTable = { 554 .numEntries = SYSCALL_OS_MAIN_RTC_LAST, 555 .entry = { 556 [SYSCALL_OS_MAIN_RTC_GET_TIME] = { .func = osExpApiRtcGetTime }, 557 }, 558 }; 559 560 static const struct SyscallTable osMainTable = { 561 .numEntries = SYSCALL_OS_MAIN_LAST, 562 .entry = { 563 [SYSCALL_OS_MAIN_EVENTQ] = { .subtable = (struct SyscallTable*)&osMainEvtqTable, }, 564 [SYSCALL_OS_MAIN_LOGGING] = { .subtable = (struct SyscallTable*)&osMainLogTable, }, 565 [SYSCALL_OS_MAIN_SENSOR] = { .subtable = (struct SyscallTable*)&osMainSensorsTable, }, 566 [SYSCALL_OS_MAIN_TIME] = { .subtable = (struct SyscallTable*)&osMainTimerTable, }, 567 [SYSCALL_OS_MAIN_HEAP] = { .subtable = (struct SyscallTable*)&osMainHeapTable, }, 568 [SYSCALL_OS_MAIN_SLAB] = { .subtable = (struct SyscallTable*)&osMainSlabTable, }, 569 [SYSCALL_OS_MAIN_HOST] = { .subtable = (struct SyscallTable*)&osMainHostTable, }, 570 [SYSCALL_OS_MAIN_RTC] = { .subtable = (struct SyscallTable*)&osMainRtcTable, }, 571 }, 572 }; 573 574 static const struct SyscallTable osDrvGpioTable = { 575 .numEntries = SYSCALL_OS_DRV_GPIO_LAST, 576 .entry = { 577 [SYSCALL_OS_DRV_GPIO_REQ] = { .func = osExpApiGpioReq, }, 578 [SYSCALL_OS_DRV_GPIO_REL] = { .func = osExpApiGpioRel, }, 579 [SYSCALL_OS_DRV_GPIO_CFG_IN] = { .func = osExpApiGpioCfgIn, }, 580 [SYSCALL_OS_DRV_GPIO_CFG_OUT] = { .func = osExpApiGpioCfgOut, }, 581 [SYSCALL_OS_DRV_GPIO_CFG_ALT] = { .func = osExpApiGpioCfgAlt, }, 582 [SYSCALL_OS_DRV_GPIO_GET] = { .func = osExpApiGpioGet, }, 583 [SYSCALL_OS_DRV_GPIO_SET] = { .func = osExpApiGpioSet, }, 584 }, 585 }; 586 587 static const struct SyscallTable osGrvI2cMstTable = { 588 .numEntries = SYSCALL_OS_DRV_I2CM_LAST, 589 .entry = { 590 [SYSCALL_OS_DRV_I2CM_REQ] = { .func = osExpApiI2cMstReq, }, 591 [SYSCALL_OS_DRV_I2CM_REL] = { .func = osExpApiI2cMstRel, }, 592 [SYSCALL_OS_DRV_I2CM_TXRX] = { .func = osExpApiI2cMstTxRx, }, 593 }, 594 }; 595 596 static const struct SyscallTable osGrvI2cSlvTable = { 597 .numEntries = SYSCALL_OS_DRV_I2CS_LAST, 598 .entry = { 599 [ SYSCALL_OS_DRV_I2CS_REQ] = { .func = osExpApiI2cSlvReq, }, 600 [ SYSCALL_OS_DRV_I2CS_REL] = { .func = osExpApiI2cSlvRel, }, 601 [ SYSCALL_OS_DRV_I2CS_RX_EN] = { .func = osExpApiI2cSlvRxEn, }, 602 [ SYSCALL_OS_DRV_I2CS_TX_PRE] = { .func = osExpApiI2cSlvTxPre, }, 603 [ SYSCALL_OS_DRV_I2CS_TX_PKT] = { .func = osExpApiI2cSlvTxPkt, }, 604 }, 605 }; 606 607 static const struct SyscallTable osDriversTable = { 608 .numEntries = SYSCALL_OS_DRV_LAST, 609 .entry = { 610 [SYSCALL_OS_DRV_GPIO] = { .subtable = (struct SyscallTable*)&osDrvGpioTable, }, 611 [SYSCALL_OS_DRV_I2C_MASTER] = { .subtable = (struct SyscallTable*)&osGrvI2cMstTable, }, 612 [SYSCALL_OS_DRV_I2C_SLAVE] = { .subtable = (struct SyscallTable*)&osGrvI2cSlvTable, }, 613 }, 614 }; 615 616 static const struct SyscallTable osTable = { 617 .numEntries = SYSCALL_OS_LAST, 618 .entry = { 619 [SYSCALL_OS_MAIN] = { .subtable = (struct SyscallTable*)&osMainTable, }, 620 [SYSCALL_OS_DRIVERS] = { .subtable = (struct SyscallTable*)&osDriversTable, }, 621 }, 622 }; 623 624 if (!syscallAddTable(SYSCALL_DOMAIN_OS, 1, (struct SyscallTable*)&osTable)) 625 osLog(LOG_ERROR, "Failed to export OS base API"); 626 } 627 628
