Kayori/segatools
1
0
Fork 0
forked from Dniel97/segatools
Code Pull Requests Activity

board: Naming convention change for "sg" bus

Browse Source
This commit is contained in:
Tau 2019-10-26 18:25:04 -04:00
parent ff14fd7fac
commit 2b5bde7742
8 changed files with 128 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
board/sg-cmd.c
View File

@ -12,15 +12,15 @@ union sg_req_any {
uint8_t bytes[256]; uint8_t bytes[256];
}; };
union sg_resp_any { union sg_res_any {
struct sg_resp_header resp; struct sg_res_header res;
uint8_t bytes[256]; uint8_t bytes[256];
}; };
static HRESULT sg_req_validate(const void *ptr, size_t nbytes); static HRESULT sg_req_validate(const void *ptr, size_t nbytes);
static void sg_resp_error( static void sg_res_error(
struct sg_resp_header *resp, struct sg_res_header *res,
const struct sg_req_header *req); const struct sg_req_header *req);
static HRESULT sg_req_validate(const void *ptr, size_t nbytes) static HRESULT sg_req_validate(const void *ptr, size_t nbytes)
@ -60,7 +60,7 @@ static HRESULT sg_req_validate(const void *ptr, size_t nbytes)
} }
void sg_req_transact( void sg_req_transact(
struct iobuf *resp_frame, struct iobuf *res_frame,
const uint8_t *req_bytes, const uint8_t *req_bytes,
size_t req_nbytes, size_t req_nbytes,
sg_dispatch_fn_t dispatch, sg_dispatch_fn_t dispatch,
@ -68,10 +68,10 @@ void sg_req_transact(
{ {
struct iobuf req_span; struct iobuf req_span;
union sg_req_any req; union sg_req_any req;
union sg_resp_any resp; union sg_res_any res;
HRESULT hr; HRESULT hr;
assert(resp_frame != NULL); assert(res_frame != NULL);
assert(req_bytes != NULL); assert(req_bytes != NULL);
assert(dispatch != NULL); assert(dispatch != NULL);
@ -91,44 +91,44 @@ void sg_req_transact(
return; return;
} }
hr = dispatch(ctx, &req, &resp); hr = dispatch(ctx, &req, &res);
if (hr != S_FALSE) { if (hr != S_FALSE) {
if (FAILED(hr)) { if (FAILED(hr)) {
sg_resp_error(&resp.resp, &req.req); sg_res_error(&res.res, &req.req);
} }
sg_frame_encode(resp_frame, resp.bytes, resp.resp.hdr.frame_len); sg_frame_encode(res_frame, res.bytes, res.res.hdr.frame_len);
} }
} }
void sg_resp_init( void sg_res_init(
struct sg_resp_header *resp, struct sg_res_header *res,
const struct sg_req_header *req, const struct sg_req_header *req,
size_t payload_len) size_t payload_len)
{ {
assert(resp != NULL); assert(res != NULL);
assert(req != NULL); assert(req != NULL);
resp->hdr.frame_len = sizeof(*resp) + payload_len; res->hdr.frame_len = sizeof(*res) + payload_len;
resp->hdr.addr = req->hdr.addr; res->hdr.addr = req->hdr.addr;
resp->hdr.seq_no = req->hdr.seq_no; res->hdr.seq_no = req->hdr.seq_no;
resp->hdr.cmd = req->hdr.cmd; res->hdr.cmd = req->hdr.cmd;
resp->status = 0; res->status = 0;
resp->payload_len = payload_len; res->payload_len = payload_len;
} }
static void sg_resp_error( static void sg_res_error(
struct sg_resp_header *resp, struct sg_res_header *res,
const struct sg_req_header *req) const struct sg_req_header *req)
{ {
assert(resp != NULL); assert(res != NULL);
assert(req != NULL); assert(req != NULL);
resp->hdr.frame_len = sizeof(*resp); res->hdr.frame_len = sizeof(*res);
resp->hdr.addr = req->hdr.addr; res->hdr.addr = req->hdr.addr;
resp->hdr.seq_no = req->hdr.seq_no; res->hdr.seq_no = req->hdr.seq_no;
resp->hdr.cmd = req->hdr.cmd; res->hdr.cmd = req->hdr.cmd;
resp->status = 1; res->status = 1;
resp->payload_len = 0; res->payload_len = 0;
} }

10
board/sg-cmd.h
View File

@ -19,7 +19,7 @@ struct sg_req_header {
uint8_t payload_len; uint8_t payload_len;
}; };
struct sg_resp_header { struct sg_res_header {
struct sg_header hdr; struct sg_header hdr;
uint8_t status; uint8_t status;
uint8_t payload_len; uint8_t payload_len;
@ -28,16 +28,16 @@ struct sg_resp_header {
typedef HRESULT (*sg_dispatch_fn_t)( typedef HRESULT (*sg_dispatch_fn_t)(
void *ctx, void *ctx,
const void *req, const void *req,
void *resp); void *res);
void sg_req_transact( void sg_req_transact(
struct iobuf *resp_frame, struct iobuf *res_frame,
const uint8_t *req_bytes, const uint8_t *req_bytes,
size_t req_nbytes, size_t req_nbytes,
sg_dispatch_fn_t dispatch, sg_dispatch_fn_t dispatch,
void *ctx); void *ctx);
void sg_resp_init( void sg_res_init(
struct sg_resp_header *resp, struct sg_res_header *res,
const struct sg_req_header *req, const struct sg_req_header *req,
size_t payload_len); size_t payload_len);

16
board/sg-led-cmd.h
View File

@ -10,13 +10,13 @@ enum {
SG_RGB_CMD_GET_INFO = 0xF0, SG_RGB_CMD_GET_INFO = 0xF0,
}; };
struct sg_led_resp_reset { struct sg_led_res_reset {
struct sg_resp_header resp; struct sg_res_header res;
uint8_t payload; uint8_t payload;
}; };
struct sg_led_resp_get_info { struct sg_led_res_get_info {
struct sg_resp_header resp; struct sg_res_header res;
uint8_t payload[9]; uint8_t payload[9];
}; };
@ -31,9 +31,9 @@ union sg_led_req_any {
struct sg_led_req_set_color set_color; struct sg_led_req_set_color set_color;
}; };
union sg_led_resp_any { union sg_led_res_any {
uint8_t bytes[256]; uint8_t bytes[256];
struct sg_resp_header simple; struct sg_res_header simple;
struct sg_led_resp_reset reset; struct sg_led_res_reset reset;
struct sg_led_resp_get_info get_info; struct sg_led_res_get_info get_info;
}; };

34
board/sg-led.c
View File

@ -11,17 +11,17 @@
static HRESULT sg_led_dispatch( static HRESULT sg_led_dispatch(
void *ctx, void *ctx,
const void *v_req, const void *v_req,
void *v_resp); void *v_res);
static HRESULT sg_led_cmd_reset( static HRESULT sg_led_cmd_reset(
const struct sg_led *led, const struct sg_led *led,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_led_resp_reset *resp); struct sg_led_res_reset *res);
static HRESULT sg_led_cmd_get_info( static HRESULT sg_led_cmd_get_info(
const struct sg_led *led, const struct sg_led *led,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_led_resp_get_info *resp); struct sg_led_res_get_info *res);
static HRESULT sg_led_cmd_set_color( static HRESULT sg_led_cmd_set_color(
const struct sg_led *led, const struct sg_led *led,
@ -47,15 +47,15 @@ void sg_led_init(
void sg_led_transact( void sg_led_transact(
struct sg_led *led, struct sg_led *led,
struct iobuf *resp_frame, struct iobuf *res_frame,
const void *req_bytes, const void *req_bytes,
size_t req_nbytes) size_t req_nbytes)
{ {
assert(led != NULL); assert(led != NULL);
assert(resp_frame != NULL); assert(res_frame != NULL);
assert(req_bytes != NULL); assert(req_bytes != NULL);
sg_req_transact(resp_frame, req_bytes, req_nbytes, sg_led_dispatch, led); sg_req_transact(res_frame, req_bytes, req_nbytes, sg_led_dispatch, led);
} }
#ifdef NDEBUG #ifdef NDEBUG
@ -87,15 +87,15 @@ static void sg_led_dprintf(
static HRESULT sg_led_dispatch( static HRESULT sg_led_dispatch(
void *ctx, void *ctx,
const void *v_req, const void *v_req,
void *v_resp) void *v_res)
{ {
const struct sg_led *led; const struct sg_led *led;
const union sg_led_req_any *req; const union sg_led_req_any *req;
union sg_led_resp_any *resp; union sg_led_res_any *res;
led = ctx; led = ctx;
req = v_req; req = v_req;
resp = v_resp; res = v_res;
if (req->simple.hdr.addr != led->addr) { if (req->simple.hdr.addr != led->addr) {
/* Not addressed to us, don't send a response */ /* Not addressed to us, don't send a response */
@ -104,10 +104,10 @@ static HRESULT sg_led_dispatch(
switch (req->simple.hdr.cmd) { switch (req->simple.hdr.cmd) {
case SG_RGB_CMD_RESET: case SG_RGB_CMD_RESET:
return sg_led_cmd_reset(led, &req->simple, &resp->reset); return sg_led_cmd_reset(led, &req->simple, &res->reset);
case SG_RGB_CMD_GET_INFO: case SG_RGB_CMD_GET_INFO:
return sg_led_cmd_get_info(led, &req->simple, &resp->get_info); return sg_led_cmd_get_info(led, &req->simple, &res->get_info);
case SG_RGB_CMD_SET_COLOR: case SG_RGB_CMD_SET_COLOR:
return sg_led_cmd_set_color(led, &req->set_color); return sg_led_cmd_set_color(led, &req->set_color);
@ -122,13 +122,13 @@ static HRESULT sg_led_dispatch(
static HRESULT sg_led_cmd_reset( static HRESULT sg_led_cmd_reset(
const struct sg_led *led, const struct sg_led *led,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_led_resp_reset *resp) struct sg_led_res_reset *res)
{ {
HRESULT hr; HRESULT hr;
sg_led_dprintf(led, "Reset\n"); sg_led_dprintf(led, "Reset\n");
sg_resp_init(&resp->resp, req, sizeof(resp->payload)); sg_res_init(&res->res, req, sizeof(res->payload));
resp->payload = 0; res->payload = 0;
if (led->ops->reset != NULL) { if (led->ops->reset != NULL) {
hr = led->ops->reset(led->ops_ctx); hr = led->ops->reset(led->ops_ctx);
@ -147,11 +147,11 @@ static HRESULT sg_led_cmd_reset(
static HRESULT sg_led_cmd_get_info( static HRESULT sg_led_cmd_get_info(
const struct sg_led *led, const struct sg_led *led,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_led_resp_get_info *resp) struct sg_led_res_get_info *res)
{ {
sg_led_dprintf(led, "Get info\n"); sg_led_dprintf(led, "Get info\n");
sg_resp_init(&resp->resp, req, sizeof(resp->payload)); sg_res_init(&res->res, req, sizeof(res->payload));
memcpy(resp->payload, sg_led_info, sizeof(sg_led_info)); memcpy(res->payload, sg_led_info, sizeof(sg_led_info));
return S_OK; return S_OK;
} }

2
board/sg-led.h
View File

@ -25,6 +25,6 @@ void sg_led_init(
void sg_led_transact( void sg_led_transact(
struct sg_led *led, struct sg_led *led,
struct iobuf *resp_frame, struct iobuf *res_frame,
const void *req_bytes, const void *req_bytes,
size_t req_nbytes); size_t req_nbytes);

36
board/sg-nfc-cmd.h
View File

@ -19,13 +19,13 @@ enum {
SG_NFC_CMD_FELICA_ENCAP = 0x71, SG_NFC_CMD_FELICA_ENCAP = 0x71,
}; };
struct sg_nfc_resp_get_fw_version { struct sg_nfc_res_get_fw_version {
struct sg_resp_header resp; struct sg_res_header res;
char version[23]; char version[23];
}; };
struct sg_nfc_resp_get_hw_version { struct sg_nfc_res_get_hw_version {
struct sg_resp_header resp; struct sg_res_header res;
char version[23]; char version[23];
}; };
@ -57,14 +57,14 @@ struct sg_nfc_poll_felica {
uint64_t PMm; uint64_t PMm;
}; };
struct sg_nfc_resp_poll { struct sg_nfc_res_poll {
struct sg_resp_header resp; struct sg_res_header res;
uint8_t count; uint8_t count;
uint8_t payload[250]; uint8_t payload[250];
}; };
struct sg_nfc_req_mifare_select_tag { struct sg_nfc_req_mifare_select_tag {
struct sg_resp_header resp; struct sg_res_header res;
uint32_t uid; uint32_t uid;
}; };
@ -76,8 +76,8 @@ struct sg_nfc_req_mifare_read_block {
} payload; } payload;
}; };
struct sg_nfc_resp_mifare_read_block { struct sg_nfc_res_mifare_read_block {
struct sg_resp_header resp; struct sg_res_header res;
uint8_t block[16]; uint8_t block[16];
}; };
@ -87,8 +87,8 @@ struct sg_nfc_req_felica_encap {
uint8_t payload[243]; uint8_t payload[243];
}; };
struct sg_nfc_resp_felica_encap { struct sg_nfc_res_felica_encap {
struct sg_resp_header resp; struct sg_res_header res;
uint8_t payload[250]; uint8_t payload[250];
}; };
@ -102,14 +102,14 @@ union sg_nfc_req_any {
struct sg_nfc_req_felica_encap felica_encap; struct sg_nfc_req_felica_encap felica_encap;
}; };
union sg_nfc_resp_any { union sg_nfc_res_any {
uint8_t bytes[256]; uint8_t bytes[256];
struct sg_resp_header simple; struct sg_res_header simple;
struct sg_nfc_resp_get_fw_version get_fw_version; struct sg_nfc_res_get_fw_version get_fw_version;
struct sg_nfc_resp_get_hw_version get_hw_version; struct sg_nfc_res_get_hw_version get_hw_version;
struct sg_nfc_resp_poll poll; struct sg_nfc_res_poll poll;
struct sg_nfc_resp_mifare_read_block mifare_read_block; struct sg_nfc_res_mifare_read_block mifare_read_block;
struct sg_nfc_resp_felica_encap felica_encap; struct sg_nfc_res_felica_encap felica_encap;
}; };
#pragma pack(pop) #pragma pack(pop)

100
board/sg-nfc.c
View File

@ -20,27 +20,27 @@
static HRESULT sg_nfc_dispatch( static HRESULT sg_nfc_dispatch(
void *ctx, void *ctx,
const void *v_req, const void *v_req,
void *v_resp); void *v_res);
static HRESULT sg_nfc_cmd_reset( static HRESULT sg_nfc_cmd_reset(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_resp_header *resp); struct sg_res_header *res);
static HRESULT sg_nfc_cmd_get_fw_version( static HRESULT sg_nfc_cmd_get_fw_version(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_nfc_resp_get_fw_version *resp); struct sg_nfc_res_get_fw_version *res);
static HRESULT sg_nfc_cmd_get_hw_version( static HRESULT sg_nfc_cmd_get_hw_version(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_nfc_resp_get_hw_version *resp); struct sg_nfc_res_get_hw_version *res);
static HRESULT sg_nfc_cmd_poll( static HRESULT sg_nfc_cmd_poll(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_nfc_resp_poll *resp); struct sg_nfc_res_poll *res);
static HRESULT sg_nfc_poll_aime( static HRESULT sg_nfc_poll_aime(
struct sg_nfc *nfc, struct sg_nfc *nfc,
@ -53,17 +53,17 @@ static HRESULT sg_nfc_poll_felica(
static HRESULT sg_nfc_cmd_mifare_read_block( static HRESULT sg_nfc_cmd_mifare_read_block(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_nfc_req_mifare_read_block *req, const struct sg_nfc_req_mifare_read_block *req,
struct sg_nfc_resp_mifare_read_block *resp); struct sg_nfc_res_mifare_read_block *res);
static HRESULT sg_nfc_cmd_felica_encap( static HRESULT sg_nfc_cmd_felica_encap(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_nfc_req_felica_encap *req, const struct sg_nfc_req_felica_encap *req,
struct sg_nfc_resp_felica_encap *resp); struct sg_nfc_res_felica_encap *res);
static HRESULT sg_nfc_cmd_dummy( static HRESULT sg_nfc_cmd_dummy(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_resp_header *resp); struct sg_res_header *res);
void sg_nfc_init( void sg_nfc_init(
struct sg_nfc *nfc, struct sg_nfc *nfc,
@ -107,29 +107,29 @@ static void sg_nfc_dprintf(
void sg_nfc_transact( void sg_nfc_transact(
struct sg_nfc *nfc, struct sg_nfc *nfc,
struct iobuf *resp_frame, struct iobuf *res_frame,
const void *req_bytes, const void *req_bytes,
size_t req_nbytes) size_t req_nbytes)
{ {
assert(nfc != NULL); assert(nfc != NULL);
assert(resp_frame != NULL); assert(res_frame != NULL);
assert(req_bytes != NULL); assert(req_bytes != NULL);
sg_req_transact(resp_frame, req_bytes, req_nbytes, sg_nfc_dispatch, nfc); sg_req_transact(res_frame, req_bytes, req_nbytes, sg_nfc_dispatch, nfc);
} }
static HRESULT sg_nfc_dispatch( static HRESULT sg_nfc_dispatch(
void *ctx, void *ctx,
const void *v_req, const void *v_req,
void *v_resp) void *v_res)
{ {
struct sg_nfc *nfc; struct sg_nfc *nfc;
const union sg_nfc_req_any *req; const union sg_nfc_req_any *req;
union sg_nfc_resp_any *resp; union sg_nfc_res_any *res;
nfc = ctx; nfc = ctx;
req = v_req; req = v_req;
resp = v_resp; res = v_res;
if (req->simple.hdr.addr != nfc->addr) { if (req->simple.hdr.addr != nfc->addr) {
/* Not addressed to us, don't send a response */ /* Not addressed to us, don't send a response */
@ -138,37 +138,37 @@ static HRESULT sg_nfc_dispatch(
switch (req->simple.hdr.cmd) { switch (req->simple.hdr.cmd) {
case SG_NFC_CMD_RESET: case SG_NFC_CMD_RESET:
return sg_nfc_cmd_reset(nfc, &req->simple, &resp->simple); return sg_nfc_cmd_reset(nfc, &req->simple, &res->simple);
case SG_NFC_CMD_GET_FW_VERSION: case SG_NFC_CMD_GET_FW_VERSION:
return sg_nfc_cmd_get_fw_version( return sg_nfc_cmd_get_fw_version(
nfc, nfc,
&req->simple, &req->simple,
&resp->get_fw_version); &res->get_fw_version);
case SG_NFC_CMD_GET_HW_VERSION: case SG_NFC_CMD_GET_HW_VERSION:
return sg_nfc_cmd_get_hw_version( return sg_nfc_cmd_get_hw_version(
nfc, nfc,
&req->simple, &req->simple,
&resp->get_hw_version); &res->get_hw_version);
case SG_NFC_CMD_POLL: case SG_NFC_CMD_POLL:
return sg_nfc_cmd_poll( return sg_nfc_cmd_poll(
nfc, nfc,
&req->simple, &req->simple,
&resp->poll); &res->poll);
case SG_NFC_CMD_MIFARE_READ_BLOCK: case SG_NFC_CMD_MIFARE_READ_BLOCK:
return sg_nfc_cmd_mifare_read_block( return sg_nfc_cmd_mifare_read_block(
nfc, nfc,
&req->mifare_read_block, &req->mifare_read_block,
&resp->mifare_read_block); &res->mifare_read_block);
case SG_NFC_CMD_FELICA_ENCAP: case SG_NFC_CMD_FELICA_ENCAP:
return sg_nfc_cmd_felica_encap( return sg_nfc_cmd_felica_encap(
nfc, nfc,
&req->felica_encap, &req->felica_encap,
&resp->felica_encap); &res->felica_encap);
case SG_NFC_CMD_MIFARE_AUTHENTICATE: case SG_NFC_CMD_MIFARE_AUTHENTICATE:
case SG_NFC_CMD_MIFARE_SELECT_TAG: case SG_NFC_CMD_MIFARE_SELECT_TAG:
@ -176,7 +176,7 @@ static HRESULT sg_nfc_dispatch(
case SG_NFC_CMD_MIFARE_SET_KEY_BANA: case SG_NFC_CMD_MIFARE_SET_KEY_BANA:
case SG_NFC_CMD_RADIO_ON: case SG_NFC_CMD_RADIO_ON:
case SG_NFC_CMD_RADIO_OFF: case SG_NFC_CMD_RADIO_OFF:
return sg_nfc_cmd_dummy(nfc, &req->simple, &resp->simple); return sg_nfc_cmd_dummy(nfc, &req->simple, &res->simple);
default: default:
sg_nfc_dprintf(nfc, "Unimpl command %02x\n", req->simple.hdr.cmd); sg_nfc_dprintf(nfc, "Unimpl command %02x\n", req->simple.hdr.cmd);
@ -188,11 +188,11 @@ static HRESULT sg_nfc_dispatch(
static HRESULT sg_nfc_cmd_reset( static HRESULT sg_nfc_cmd_reset(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_resp_header *resp) struct sg_res_header *res)
{ {
sg_nfc_dprintf(nfc, "Reset\n"); sg_nfc_dprintf(nfc, "Reset\n");
sg_resp_init(resp, req, 0); sg_res_init(res, req, 0);
resp->status = 3; res->status = 3;
return S_OK; return S_OK;
} }
@ -200,11 +200,11 @@ static HRESULT sg_nfc_cmd_reset(
static HRESULT sg_nfc_cmd_get_fw_version( static HRESULT sg_nfc_cmd_get_fw_version(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_nfc_resp_get_fw_version *resp) struct sg_nfc_res_get_fw_version *res)
{ {
/* Dest version is not NUL terminated, this is intentional */ /* Dest version is not NUL terminated, this is intentional */
sg_resp_init(&resp->resp, req, sizeof(resp->version)); sg_res_init(&res->res, req, sizeof(res->version));
memcpy(resp->version, "TN32MSEC003S F/W Ver1.2E", sizeof(resp->version)); memcpy(res->version, "TN32MSEC003S F/W Ver1.2E", sizeof(res->version));
return S_OK; return S_OK;
} }
@ -212,11 +212,11 @@ static HRESULT sg_nfc_cmd_get_fw_version(
static HRESULT sg_nfc_cmd_get_hw_version( static HRESULT sg_nfc_cmd_get_hw_version(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_nfc_resp_get_hw_version *resp) struct sg_nfc_res_get_hw_version *res)
{ {
/* Dest version is not NUL terminated, this is intentional */ /* Dest version is not NUL terminated, this is intentional */
sg_resp_init(&resp->resp, req, sizeof(resp->version)); sg_res_init(&res->res, req, sizeof(res->version));
memcpy(resp->version, "TN32MSEC003S H/W Ver3.0J", sizeof(resp->version)); memcpy(res->version, "TN32MSEC003S H/W Ver3.0J", sizeof(res->version));
return S_OK; return S_OK;
} }
@ -224,7 +224,7 @@ static HRESULT sg_nfc_cmd_get_hw_version(
static HRESULT sg_nfc_cmd_poll( static HRESULT sg_nfc_cmd_poll(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_nfc_resp_poll *resp) struct sg_nfc_res_poll *res)
{ {
struct sg_nfc_poll_mifare mifare; struct sg_nfc_poll_mifare mifare;
struct sg_nfc_poll_felica felica; struct sg_nfc_poll_felica felica;
@ -239,9 +239,9 @@ static HRESULT sg_nfc_cmd_poll(
hr = sg_nfc_poll_felica(nfc, &felica); hr = sg_nfc_poll_felica(nfc, &felica);
if (SUCCEEDED(hr) && hr != S_FALSE) { if (SUCCEEDED(hr) && hr != S_FALSE) {
sg_resp_init(&resp->resp, req, 1 + sizeof(felica)); sg_res_init(&res->res, req, 1 + sizeof(felica));
memcpy(resp->payload, &felica, sizeof(felica)); memcpy(res->payload, &felica, sizeof(felica));
resp->count = 1; res->count = 1;
return S_OK; return S_OK;
} }
@ -249,15 +249,15 @@ static HRESULT sg_nfc_cmd_poll(
hr = sg_nfc_poll_aime(nfc, &mifare); hr = sg_nfc_poll_aime(nfc, &mifare);
if (SUCCEEDED(hr) && hr != S_FALSE) { if (SUCCEEDED(hr) && hr != S_FALSE) {
sg_resp_init(&resp->resp, req, 1 + sizeof(mifare)); sg_res_init(&res->res, req, 1 + sizeof(mifare));
memcpy(resp->payload, &mifare, sizeof(mifare)); memcpy(res->payload, &mifare, sizeof(mifare));
resp->count = 1; res->count = 1;
return S_OK; return S_OK;
} }
sg_resp_init(&resp->resp, req, 1); sg_res_init(&res->res, req, 1);
resp->count = 0; res->count = 0;
return S_OK; return S_OK;
} }
@ -340,7 +340,7 @@ static HRESULT sg_nfc_poll_felica(
static HRESULT sg_nfc_cmd_mifare_read_block( static HRESULT sg_nfc_cmd_mifare_read_block(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_nfc_req_mifare_read_block *req, const struct sg_nfc_req_mifare_read_block *req,
struct sg_nfc_resp_mifare_read_block *resp) struct sg_nfc_res_mifare_read_block *res)
{ {
uint32_t uid; uint32_t uid;
@ -360,11 +360,11 @@ static HRESULT sg_nfc_cmd_mifare_read_block(
return E_FAIL; return E_FAIL;
} }
sg_resp_init(&resp->resp, &req->req, sizeof(resp->block)); sg_res_init(&res->res, &req->req, sizeof(res->block));
memcpy( resp->block, memcpy( res->block,
nfc->mifare.sectors[0].blocks[req->payload.block_no].bytes, nfc->mifare.sectors[0].blocks[req->payload.block_no].bytes,
sizeof(resp->block)); sizeof(res->block));
return S_OK; return S_OK;
} }
@ -372,7 +372,7 @@ static HRESULT sg_nfc_cmd_mifare_read_block(
static HRESULT sg_nfc_cmd_felica_encap( static HRESULT sg_nfc_cmd_felica_encap(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_nfc_req_felica_encap *req, const struct sg_nfc_req_felica_encap *req,
struct sg_nfc_resp_felica_encap *resp) struct sg_nfc_res_felica_encap *res)
{ {
struct const_iobuf f_req; struct const_iobuf f_req;
struct iobuf f_res; struct iobuf f_res;
@ -397,8 +397,8 @@ static HRESULT sg_nfc_cmd_felica_encap(
f_req.nbytes = req->payload[0]; f_req.nbytes = req->payload[0];
f_req.pos = 1; f_req.pos = 1;
f_res.bytes = resp->payload; f_res.bytes = res->payload;
f_res.nbytes = sizeof(resp->payload); f_res.nbytes = sizeof(res->payload);
f_res.pos = 1; f_res.pos = 1;
#if 0 #if 0
@ -412,8 +412,8 @@ static HRESULT sg_nfc_cmd_felica_encap(
return hr; return hr;
} }
sg_resp_init(&resp->resp, &req->req, f_res.pos); sg_res_init(&res->res, &req->req, f_res.pos);
resp->payload[0] = f_res.pos; res->payload[0] = f_res.pos;
#if 0 #if 0
dprintf("FELICA INBOUND:\n"); dprintf("FELICA INBOUND:\n");
@ -426,9 +426,9 @@ static HRESULT sg_nfc_cmd_felica_encap(
static HRESULT sg_nfc_cmd_dummy( static HRESULT sg_nfc_cmd_dummy(
struct sg_nfc *nfc, struct sg_nfc *nfc,
const struct sg_req_header *req, const struct sg_req_header *req,
struct sg_resp_header *resp) struct sg_res_header *res)
{ {
sg_resp_init(resp, req, 0); sg_res_init(res, req, 0);
return S_OK; return S_OK;
} }

2
board/sg-nfc.h
View File

@ -34,6 +34,6 @@ void sg_nfc_init(
void sg_nfc_transact( void sg_nfc_transact(
struct sg_nfc *nfc, struct sg_nfc *nfc,
struct iobuf *resp_frame, struct iobuf *res_frame,
const void *req_bytes, const void *req_bytes,
size_t req_nbytes); size_t req_nbytes);