sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ffcedfd971
nuttx/drivers/usbmisc/fusb301.c
Xiang Xiao 6a3c2aded6 Fix wait loop and void cast (#24) 
* Simplify EINTR/ECANCEL error handling

1. Add semaphore uninterruptible wait function
2 .Replace semaphore wait loop with a single uninterruptible wait
3. Replace all sem_xxx to nxsem_xxx

* Unify the void cast usage

1. Remove void cast for function because many place ignore the returned value witout cast
2. Replace void cast for variable with UNUSED macro
2020-01-02 10:54:43 -06:00

857 lines
22 KiB
C
Raw Blame History

/****************************************************************************
* drivers/usbmisc/fusb301.c
*
* FUSB301 USB-C controller driver
*
* Copyright (C) 2016-2017 Haltian Ltd. All rights reserved.
* Authors: Harri Luhtala <harri.luhtala@haltian.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <assert.h>
#include <errno.h>
#include <poll.h>
#include <debug.h>
#include <nuttx/fs/fs.h>
#include <nuttx/kmalloc.h>
#include <nuttx/i2c/i2c_master.h>
#include <nuttx/usb/fusb301.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#ifdef CONFIG_DEBUG_FUSB301
# define fusb301_err(x, ...) _err(x, ##__VA_ARGS__)
# define fusb301_info(x, ...) _info(x, ##__VA_ARGS__)
#else
# define fusb301_err(x, ...) uerr(x, ##__VA_ARGS__)
# define fusb301_info(x, ...) uinfo(x, ##__VA_ARGS__)
#endif
#ifndef CONFIG_FUSB301_I2C_FREQUENCY
# define CONFIG_FUSB301_I2C_FREQUENCY 400000
#endif
/* Other macros */
#define FUSB301_I2C_RETRIES 10
/****************************************************************************
* Private Data Types
****************************************************************************/
struct fusb301_dev_s
{
FAR struct i2c_master_s *i2c; /* I2C interface */
uint8_t addr; /* I2C address */
volatile bool int_pending; /* Interrupt received but handled */
sem_t devsem; /* Manages exclusive access */
FAR struct fusb301_config_s *config; /* Platform specific configuration */
FAR struct pollfd *fds[CONFIG_FUSB301_NPOLLWAITERS];
};
/****************************************************************************
* Private Function prototypes
****************************************************************************/
static int fusb301_open(FAR struct file *filep);
static int fusb301_close(FAR struct file *filep);
static ssize_t fusb301_read(FAR struct file *, FAR char *, size_t);
static ssize_t fusb301_write(FAR struct file *filep, FAR const char *buffer,
size_t buflen);
static int fusb301_ioctl(FAR struct file *filep, int cmd, unsigned long arg);
static int fusb301_poll(FAR struct file *filep, FAR struct pollfd *fds,
bool setup);
static void fusb301_notify(FAR struct fusb301_dev_s *priv);
/****************************************************************************
* Private Data
****************************************************************************/
static const struct file_operations g_fusb301ops =
{
fusb301_open, /* open */
fusb301_close, /* close */
fusb301_read, /* read */
fusb301_write, /* write */
NULL, /* seek */
fusb301_ioctl, /* ioctl */
fusb301_poll /* poll */
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
, NULL /* unlink */
#endif
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: fusb301_getreg
*
* Description:
* Read from an 8-bit FUSB301 register
*
* Input Parameters:
* priv - pointer to FUSB301 Private Structure
* reg - register to read
*
* Returned Value:
* Returns positive register value in case of success, otherwise ERROR
****************************************************************************/
static int fusb301_getreg(FAR struct fusb301_dev_s *priv, uint8_t reg)
{
int ret = -EIO;
int retries;
uint8_t regval;
struct i2c_msg_s msg[2];
DEBUGASSERT(priv);
msg[0].frequency = CONFIG_FUSB301_I2C_FREQUENCY;
msg[0].addr = priv->addr;
msg[0].flags = 0;
msg[0].buffer = &reg;
msg[0].length = 1;
msg[1].frequency = CONFIG_FUSB301_I2C_FREQUENCY;
msg[1].addr = priv->addr;
msg[1].flags = I2C_M_READ;
msg[1].buffer = &regval;
msg[1].length = 1;
/* Perform the transfer */
for (retries = 0; retries < FUSB301_I2C_RETRIES; retries++)
{
ret = I2C_TRANSFER(priv->i2c, msg, 2);
if (ret >= 0)
{
fusb301_info("reg:%02X, value:%02X\n", reg, regval);
return regval;
}
else
{
/* Some error. Try to reset I2C bus and keep trying. */
#ifdef CONFIG_I2C_RESET
if (retries == FUSB301_I2C_RETRIES - 1)
{
break;
}
ret = I2C_RESET(priv->i2c);
if (ret < 0)
{
fusb301_err("ERROR: I2C_RESET failed: %d\n", ret);
return ret;
}
#endif
}
}
fusb301_info("reg:%02X, error:%d\n", reg, ret);
return ret;
}
/****************************************************************************
* Name: fusb301_putreg
*
* Description:
* Write a value to an 8-bit FUSB301 register
*
* Input Parameters:
* priv - pointer to FUSB301 Private Structure
* regaddr - register to read
* regval - value to be written
*
* Returned Value:
* None
****************************************************************************/
static int fusb301_putreg(FAR struct fusb301_dev_s *priv, uint8_t regaddr,
uint8_t regval)
{
int ret = -EIO;
int retries;
struct i2c_msg_s msg;
uint8_t txbuffer[2];
/* Setup to the data to be transferred (register address and data). */
txbuffer[0] = regaddr;
txbuffer[1] = regval;
/* Setup 8-bit FUSB301 address write message */
msg.frequency = CONFIG_FUSB301_I2C_FREQUENCY;
msg.addr = priv->addr;
msg.flags = 0;
msg.buffer = txbuffer;
msg.length = 2;
/* Perform the transfer */
for (retries = 0; retries < FUSB301_I2C_RETRIES; retries++)
{
ret = I2C_TRANSFER(priv->i2c, &msg, 1);
if (ret == OK)
{
fusb301_info("reg:%02X, value:%02X\n", regaddr, regval);
return OK;
}
else
{
/* Some error. Try to reset I2C bus and keep trying. */
#ifdef CONFIG_I2C_RESET
if (retries == FUSB301_I2C_RETRIES - 1)
{
break;
}
ret = I2C_RESET(priv->i2c);
if (ret < 0)
{
fusb301_err("ERROR: I2C_RESET failed: %d\n", ret);
return ret;
}
#endif
}
}
fusb301_err("ERROR: failed reg:%02X, value:%02X, error:%d\n",
regaddr, regval, ret);
return ret;
}
/****************************************************************************
* Name: fusb301_read_device_id
*
* Description:
* Read device version and revision IDs
*
****************************************************************************/
static int fusb301_read_device_id(FAR struct fusb301_dev_s * priv,
FAR uint8_t * arg)
{
int ret;
ret = fusb301_getreg(priv, FUSB301_DEV_ID_REG);
if (ret < 0)
{
fusb301_err("ERROR: Failed to read device ID\n");
return -EIO;
}
*arg = ret;
return OK;
}
/****************************************************************************
* Name: fusb301_clear_interrupts
*
* Description:
* Clear interrupts from FUSB301 chip
*
****************************************************************************/
static int fusb301_clear_interrupts(FAR struct fusb301_dev_s *priv)
{
int ret = OK;
ret = fusb301_getreg(priv, FUSB301_INTERRUPT_REG);
if (ret < 0)
{
fusb301_err("ERROR: Failed to clear interrupts\n");
return -EIO;
}
return ret;
}
/****************************************************************************
* Name: fusb301_setup
*
* Description:
* Setup FUSB301 chip
*
****************************************************************************/
static int fusb301_setup(FAR struct fusb301_dev_s *priv,
struct fusb301_setup_s *setup)
{
int ret = OK;
fusb301_info("drp_tgl:%02X, host_curr:%02X, global_int:%X, mask:%02X\n",
setup->drp_toggle_timing, setup->host_current, setup->global_int_mask,
setup->int_mask);
ret = fusb301_putreg(priv, FUSB301_CONTROL_REG, setup->drp_toggle_timing |
setup->host_current | setup->global_int_mask);
if (ret < 0)
{
fusb301_err("ERROR: Failed to write control register\n");
goto err_out;
}
ret = fusb301_putreg(priv, FUSB301_MASK_REG, setup->int_mask);
if (ret < 0)
{
fusb301_err("ERROR: Failed to write mask register\n");
}
err_out:
return ret;
}
/****************************************************************************
* Name: fusb301_set_mode
*
* Description:
* Configure supported device modes (sink, source, DRP, accessory)
*
****************************************************************************/
static int fusb301_set_mode(FAR struct fusb301_dev_s *priv,
enum fusb301_mode_e mode)
{
int ret = OK;
if (mode > MODE_DRP_ACC)
{
return -EINVAL;
}
ret = fusb301_putreg(priv, FUSB301_MODE_REG, mode);
if (ret < 0)
{
fusb301_err("ERROR: Failed to write mode register\n");
ret = -EIO;
}
return ret;
}
/****************************************************************************
* Name: fusb301_set_state
*
* Description:
* Force device in specified state
*
****************************************************************************/
static int fusb301_set_state(FAR struct fusb301_dev_s *priv,
enum fusb301_manual_e state)
{
int ret = OK;
if (state > MANUAL_UNATT_SNK)
{
return -EINVAL;
}
ret = fusb301_putreg(priv, FUSB301_MANUAL_REG, state);
if (ret < 0)
{
fusb301_err("ERROR: Failed to write manual register\n");
ret = -EIO;
}
return ret;
}
/****************************************************************************
* Name: fusb301_read_status
*
* Description:
* Read status register
*
****************************************************************************/
static int fusb301_read_status(FAR struct fusb301_dev_s *priv,
FAR uint8_t *arg)
{
int ret;
ret = fusb301_getreg(priv, FUSB301_STATUS_REG);
if (ret < 0)
{
fusb301_err("ERROR: Failed to read status\n");
return -EIO;
}
*arg = ret;
return OK;
}
/****************************************************************************
* Name: fusb301_read_devtype
*
* Description:
* Read type of attached device
*
****************************************************************************/
static int fusb301_read_devtype(FAR struct fusb301_dev_s *priv,
FAR uint8_t *arg)
{
int ret;
ret = fusb301_getreg(priv, FUSB301_TYPE_REG);
if (ret < 0)
{
fusb301_err("ERROR: Failed to read type\n");
return -EIO;
}
*arg = ret;
return OK;
}
/****************************************************************************
* Name: fusb301_reset
*
* Description:
* Reset FUSB301 HW and clear I2C registers
*
****************************************************************************/
static int fusb301_reset(FAR struct fusb301_dev_s *priv)
{
int ret = OK;
ret = fusb301_putreg(priv, FUSB301_RESET_REG, RESET_SW_RES);
if (ret < 0)
{
fusb301_err("ERROR: Failed to write reset register\n");
ret = -EIO;
}
return ret;
}
/****************************************************************************
* Name: fusb301_open
*
* Description:
* This function is called whenever the FUSB301 device is opened.
*
****************************************************************************/
static int fusb301_open(FAR struct file *filep)
{
FAR struct inode *inode = filep->f_inode;
FAR struct fusb301_dev_s *priv = inode->i_private;
int ret = OK;
/* Probe device */
ret = fusb301_getreg(priv, FUSB301_DEV_ID_REG);
if (ret < 0)
{
fusb301_err("ERROR: No response at given address 0x%02X\n", priv->addr);
ret = -EFAULT;
}
else
{
fusb301_info("device id: 0x%02X\n", ret);
fusb301_clear_interrupts(priv);
priv->config->irq_enable(priv->config, true);
}
/* Error exit */
return ret;
}
/****************************************************************************
* Name: fusb301_close
*
* Description:
* This routine is called when the FUSB301 device is closed.
*
****************************************************************************/
static int fusb301_close(FAR struct file *filep)
{
FAR struct inode *inode = filep->f_inode;
FAR struct fusb301_dev_s *priv = inode->i_private;
priv->config->irq_enable(priv->config, false);
return OK;
}
/****************************************************************************
* Name: fusb301_read
* Description:
* This routine is called when the FUSB301 device is read.
****************************************************************************/
static ssize_t fusb301_read(FAR struct file *filep, FAR char *buffer, size_t buflen)
{
FAR struct inode *inode = filep->f_inode;
FAR struct fusb301_dev_s *priv = inode->i_private;
FAR struct fusb301_result_s *ptr;
irqstate_t flags;
int ret;
if (buflen < sizeof(struct fusb301_result_s))
{
return 0;
}
ptr = (struct fusb301_result_s *)buffer;
ret = nxsem_wait(&priv->devsem);
if (ret < 0)
{
return ret;
}
flags = enter_critical_section();
priv->int_pending = false;
leave_critical_section(flags);
fusb301_clear_interrupts(priv);
ptr->status = fusb301_getreg(priv, FUSB301_STATUS_REG);
ptr->dev_type = fusb301_getreg(priv, FUSB301_TYPE_REG);
nxsem_post(&priv->devsem);
return sizeof(struct fusb301_result_s);
}
/****************************************************************************
* Name: fusb301_write
* Description:
* This routine is called when the FUSB301 device is written to.
****************************************************************************/
static ssize_t fusb301_write(FAR struct file *filep, FAR const char *buffer,
size_t buflen)
{
ssize_t length = 0;
return length;
}
/****************************************************************************
* Name: fusb301_ioctl
* Description:
* This routine is called when ioctl function call is performed for
* the FUSB301 device.
****************************************************************************/
static int fusb301_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
{
FAR struct inode *inode = filep->f_inode;
FAR struct fusb301_dev_s *priv = inode->i_private;
int ret;
ret = nxsem_wait(&priv->devsem);
if (ret < 0)
{
return ret;
}
fusb301_info("cmd: 0x%02X, arg:%lu\n", cmd, arg);
switch (cmd)
{
case USBCIOC_READ_DEVID:
{
ret = fusb301_read_device_id(priv, (uint8_t *)arg);
}
break;
case USBCIOC_SETUP:
{
ret = fusb301_setup(priv, (struct fusb301_setup_s *)arg);
}
break;
case USBCIOC_SET_MODE:
{
ret = fusb301_set_mode(priv, (uint8_t)arg);
}
break;
case USBCIOC_SET_STATE:
{
ret = fusb301_set_state(priv, (uint8_t)arg);
}
break;
case USBCIOC_READ_STATUS:
{
ret = fusb301_read_status(priv, (uint8_t *)arg);
}
break;
case USBCIOC_READ_DEVTYPE:
{
ret = fusb301_read_devtype(priv, (uint8_t *)arg);
}
break;
case USBCIOC_RESET:
{
ret = fusb301_reset(priv);
}
break;
default:
{
fusb301_err("ERROR: Unrecognized cmd: %d\n", cmd);
ret = -ENOTTY;
}
break;
}
nxsem_post(&priv->devsem);
return ret;
}
/****************************************************************************
* Name: fusb301_poll
* Description:
* This routine is called during FUSB301 device poll
****************************************************************************/
static int fusb301_poll(FAR struct file *filep, FAR struct pollfd *fds, bool setup)
{
FAR struct inode *inode;
FAR struct fusb301_dev_s *priv;
irqstate_t flags;
int ret = OK;
int i;
DEBUGASSERT(filep && fds);
inode = filep->f_inode;
DEBUGASSERT(inode && inode->i_private);
priv = (FAR struct fusb301_dev_s *)inode->i_private;
ret = nxsem_wait(&priv->devsem);
if (ret < 0)
{
return ret;
}
if (setup)
{
/* Ignore waits that do not include POLLIN */
if ((fds->events & POLLIN) == 0)
{
ret = -EDEADLK;
goto out;
}
/* This is a request to set up the poll. Find an available
* slot for the poll structure reference.
*/
for (i = 0; i < CONFIG_FUSB301_NPOLLWAITERS; i++)
{
/* Find an available slot */
if (!priv->fds[i])
{
/* Bind the poll structure and this slot */
priv->fds[i] = fds;
fds->priv = &priv->fds[i];
break;
}
}
if (i >= CONFIG_FUSB301_NPOLLWAITERS)
{
fds->priv = NULL;
ret = -EBUSY;
goto out;
}
flags = enter_critical_section();
if (priv->int_pending)
{
fusb301_notify(priv);
}
leave_critical_section(flags);
}
else if (fds->priv)
{
/* This is a request to tear down the poll. */
struct pollfd **slot = (struct pollfd **)fds->priv;
DEBUGASSERT(slot != NULL);
/* Remove all memory of the poll setup */
*slot = NULL;
fds->priv = NULL;
}
out:
nxsem_post(&priv->devsem);
return ret;
}
/****************************************************************************
* Name: fusb301_notify
*
* Description:
* Notify thread about data to be available
*
****************************************************************************/
static void fusb301_notify(FAR struct fusb301_dev_s *priv)
{
DEBUGASSERT(priv != NULL);
int i;
/* If there are threads waiting on poll() for FUSB301 data to become available,
* then wake them up now. NOTE: we wake up all waiting threads because we
* do not know that they are going to do. If they all try to read the data,
* then some make end up blocking after all.
*/
for (i = 0; i < CONFIG_FUSB301_NPOLLWAITERS; i++)
{
struct pollfd *fds = priv->fds[i];
if (fds)
{
fds->revents |= POLLIN;
fusb301_info("Report events: %02x\n", fds->revents);
nxsem_post(fds->sem);
}
}
}
/****************************************************************************
* Name: fusb301_callback
*
* Description:
* FUSB301 interrupt handler
*
****************************************************************************/
static int fusb301_int_handler(int irq, FAR void *context, FAR void *arg)
{
FAR struct fusb301_dev_s *priv = (FAR struct fusb301_dev_s *)arg;
irqstate_t flags;
DEBUGASSERT(priv != NULL);
flags = enter_critical_section();
priv->int_pending = true;
fusb301_notify(priv);
leave_critical_section(flags);
return OK;
}
/****************************************************************************
* Public Functions
****************************************************************************/
int fusb301_register(FAR const char *devpath, FAR struct i2c_master_s *i2c,
uint8_t addr, FAR struct fusb301_config_s *config)
{
FAR struct fusb301_dev_s *priv;
int ret;
DEBUGASSERT(devpath != NULL && i2c != NULL && config != NULL);
/* Initialize the FUSB301 device structure */
priv = (FAR struct fusb301_dev_s *)kmm_zalloc(sizeof(struct fusb301_dev_s));
if (!priv)
{
fusb301_err("ERROR: Failed to allocate instance\n");
return -ENOMEM;
}
/* Initialize device structure semaphore */
nxsem_init(&priv->devsem, 0, 1);
priv->int_pending = false;
priv->i2c = i2c;
priv->addr = addr;
priv->config = config;
/* Register the character driver */
ret = register_driver(devpath, &g_fusb301ops, 0666, priv);
if (ret < 0)
{
fusb301_err("ERROR: Failed to register driver: %d\n", ret);
goto errout_with_priv;
}
/* Prepare interrupt line and handler. */
if (priv->config->irq_clear)
{
priv->config->irq_clear(config);
}
priv->config->irq_attach(config, fusb301_int_handler, priv);
priv->config->irq_enable(config, false);
return OK;
errout_with_priv:
nxsem_destroy(&priv->devsem);
kmm_free(priv);
return ret;
}
Reference in New Issue View Git Blame Copy Permalink