/* * Copyright (C) 2017 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * Platform implementation for a nq-nci extension driver. * * The driver presents the following interface on a miscdev: * - ioctl(): * - for setting and getting power. * This handles SVDD_PWR_REQ and NFC_VEN muxing. * (ESE_RST is not connected in this case.) * - read(): * - For reading arbitrary amounts of data. * CS is asserted and deasserted on each call, but the clock * also appears to do the same which keeps the ese data available * as far as I can tell. * - write(): * - For writing arbitrary amounts of data. * CS is asserted as with read() calls, so the less fragmented * the better. * * All GPIO toggling and chip select requirements are handled behind this * interface. * */ #include <errno.h> #include <fcntl.h> #include <limits.h> #include <stdint.h> #include <stdlib.h> #include <string.h> #include <sys/ioctl.h> #include <unistd.h> #include "../include/ese/hw/nxp/pn80t/common.h" #ifndef UNUSED #define UNUSED(x) x __attribute__((unused)) #endif /* From kernel/drivers/nfc/nq-nci.h */ #define ESE_SET_PWR _IOW(0xE9, 0x02, unsigned int) #define ESE_GET_PWR _IOR(0xE9, 0x03, unsigned int) static const char kDevicePath[] = "/dev/pn81a"; struct PlatformHandle { int fd; }; int platform_toggle_reset(void *blob, int val) { const struct PlatformHandle *handle = blob; /* 0=power and 1=no power in the kernel. */ return ioctl(handle->fd, ESE_SET_PWR, !val); } void *platform_init(void *hwopts) { /* TODO(wad): It may make sense to pass in the dev path here. */ if (hwopts != NULL) { return NULL; } struct PlatformHandle *handle = calloc(1, sizeof(*handle)); if (!handle) { ALOGE("%s: unable to allocate memory for handle", __func__); return NULL; } handle->fd = open(kDevicePath, O_RDWR); if (handle->fd < 0) { ALOGE("%s: opening '%s' failed: %s", __func__, kDevicePath, strerror(errno)); free(handle); return NULL; } return handle; } int platform_release(void *blob) { struct PlatformHandle *handle = blob; /* Power off and cooldown should've happened via common code. */ close(handle->fd); free(handle); return 0; } int platform_wait(void *UNUSED(blob), long usec) { return usleep((useconds_t)usec); } uint32_t nq_transmit(struct EseInterface *ese, const uint8_t *buf, uint32_t len, int UNUSED(complete)) { struct NxpState *ns = NXP_PN80T_STATE(ese); const struct Pn80tPlatform *platform = ese->ops->opts; uint32_t bytes = 0; ALOGV("nq_nci:%s: called [%d]", __func__, len); if (len > INT_MAX) { ese_set_error(ese, kNxpPn80tErrorTransmitSize); ALOGE("Unexpectedly large transfer attempted: %u", len); return 0; } if (len == 0) return len; const struct PlatformHandle *handle = ns->handle; while (bytes < len) { ssize_t ret = write(handle->fd, (void *)(buf + bytes), len - bytes); if (ret < 0) { if (errno == EAGAIN || errno == EINTR) { continue; } ese_set_error(ese, kNxpPn80tErrorTransmit); ALOGE("%s: failed to write to hw (ret=%zd, errno=%d)", __func__, ret, errno); return 0; } bytes += ret; } return len; } uint32_t nq_receive(struct EseInterface *ese, uint8_t *buf, uint32_t len, int UNUSED(complete)) { const struct Pn80tPlatform *platform = ese->ops->opts; struct NxpState *ns = NXP_PN80T_STATE(ese); ALOGV("nq_nci:%s: called [%d]", __func__, len); if (!ns) { ALOGE("NxpState was NULL"); return 0; } if (len > INT_MAX) { ese_set_error(ese, kNxpPn80tErrorReceiveSize); ALOGE("Unexpectedly large receive attempted: %u", len); return 0; } const struct PlatformHandle *handle = ns->handle; if (len == 0) { return 0; } uint32_t bytes = 0; while (bytes < len) { ssize_t ret = read(handle->fd, (void *)(buf + bytes), len - bytes); if (ret < 0) { if (errno == EAGAIN || errno == EINTR) { continue; } ALOGE("%s: failed to read from hw (ret=%zd, errno=%d)", __func__, ret, errno); ese_set_error(ese, kNxpPn80tErrorReceive); return 0; } bytes += ret; } ALOGV("%s: read bytes: %u", __func__, bytes); return len; } static const struct Pn80tPlatform kPn80tNqNciPlatform = { .initialize = &platform_init, .release = &platform_release, .toggle_reset = &platform_toggle_reset, .toggle_ven = NULL, .toggle_power_req = NULL, .wait = &platform_wait, }; static const struct EseOperations ops = { .name = "NXP PN80T/PN81A (NQ-NCI:PN553)", .open = &nxp_pn80t_open, .hw_receive = &nq_receive, .hw_transmit = &nq_transmit, .hw_reset = &nxp_pn80t_reset, .transceive = &nxp_pn80t_transceive, .poll = &nxp_pn80t_poll, .close = &nxp_pn80t_close, .opts = &kPn80tNqNciPlatform, .errors = kNxpPn80tErrorMessages, .errors_count = kNxpPn80tErrorMax, }; __attribute__((visibility("default"))) ESE_DEFINE_HW_OPS(ESE_HW_NXP_PN80T_NQ_NCI, ops);