static int
pcf2123_rtc_attach(device_t dev)
{
struct pcf2123_rtc_softc *sc;
struct spi_command cmd;
unsigned char rxBuf[3];
unsigned char txBuf[3];
int err;
sc = device_get_softc(dev);
sc->dev = dev;
clock_register(dev, 1000000);
memset(&cmd, 0, sizeof(cmd));
memset(rxBuf, 0, sizeof(rxBuf));
memset(txBuf, 0, sizeof(txBuf));
/* Make sure Ctrl1 and Ctrl2 are zeroes */
txBuf[0] = PCF2123_WRITE(PCF2123_REG_CTRL1);
cmd.rx_cmd = rxBuf;
cmd.tx_cmd = txBuf;
cmd.rx_cmd_sz = sizeof(rxBuf);
cmd.tx_cmd_sz = sizeof(txBuf);
err = SPIBUS_TRANSFER(device_get_parent(dev), dev, &cmd);
DELAY(PCF2123_DELAY);
return (0);
}
static int
spigen_transfer(struct cdev *cdev, struct spigen_transfer *st)
{
struct spi_command transfer = SPI_COMMAND_INITIALIZER;
device_t dev = cdev->si_drv1;
struct spigen_softc *sc = device_get_softc(dev);
int error = 0;
mtx_lock(&sc->sc_mtx);
if (st->st_command.iov_len == 0)
error = EINVAL;
else if (st->st_command.iov_len > sc->sc_command_length_max ||
st->st_data.iov_len > sc->sc_data_length_max)
error = ENOMEM;
mtx_unlock(&sc->sc_mtx);
if (error)
return (error);
#if 0
device_printf(dev, "cmd %p %u data %p %u\n", st->st_command.iov_base,
st->st_command.iov_len, st->st_data.iov_base, st->st_data.iov_len);
#endif
transfer.tx_cmd = transfer.rx_cmd = malloc(st->st_command.iov_len,
M_DEVBUF, M_WAITOK);
if (transfer.tx_cmd == NULL)
return (ENOMEM);
if (st->st_data.iov_len > 0) {
transfer.tx_data = transfer.rx_data = malloc(st->st_data.iov_len,
M_DEVBUF, M_WAITOK);
if (transfer.tx_data == NULL) {
free(transfer.tx_cmd, M_DEVBUF);
return (ENOMEM);
}
}
else
transfer.tx_data = transfer.rx_data = NULL;
error = copyin(st->st_command.iov_base, transfer.tx_cmd,
transfer.tx_cmd_sz = transfer.rx_cmd_sz = st->st_command.iov_len);
if ((error == 0) && (st->st_data.iov_len > 0))
error = copyin(st->st_data.iov_base, transfer.tx_data,
transfer.tx_data_sz = transfer.rx_data_sz =
st->st_data.iov_len);
if (error == 0)
error = SPIBUS_TRANSFER(device_get_parent(dev), dev, &transfer);
if (error == 0) {
error = copyout(transfer.rx_cmd, st->st_command.iov_base,
transfer.rx_cmd_sz);
if ((error == 0) && (st->st_data.iov_len > 0))
error = copyout(transfer.rx_data, st->st_data.iov_base,
transfer.rx_data_sz);
}
free(transfer.tx_cmd, M_DEVBUF);
free(transfer.tx_data, M_DEVBUF);
return (error);
}
static int
pcf2123_rtc_settime(device_t dev, struct timespec *ts)
{
struct clocktime ct;
struct pcf2123_rtc_softc *sc;
struct spi_command cmd;
unsigned char rxTimedate[8];
unsigned char txTimedate[8];
int err;
sc = device_get_softc(dev);
/* Resolution: 1 sec */
if (ts->tv_nsec >= 500000000)
ts->tv_sec++;
ts->tv_nsec = 0;
clock_ts_to_ct(ts, &ct);
memset(&cmd, 0, sizeof(cmd));
memset(rxTimedate, 0, sizeof(rxTimedate));
memset(txTimedate, 0, sizeof(txTimedate));
/* Start reading from seconds */
cmd.rx_cmd = rxTimedate;
cmd.tx_cmd = txTimedate;
cmd.rx_cmd_sz = sizeof(rxTimedate);
cmd.tx_cmd_sz = sizeof(txTimedate);
/*
* Counter is stopped when access to time registers is in progress
* So there is no need to stop/start counter
*/
txTimedate[0] = PCF2123_WRITE(PCF2123_REG_SECONDS);
txTimedate[1] = TOBCD(ct.sec);
txTimedate[2] = TOBCD(ct.min);
txTimedate[3] = TOBCD(ct.hour);
txTimedate[4] = TOBCD(ct.day);
txTimedate[5] = TOBCD(ct.dow);
txTimedate[6] = TOBCD(ct.mon);
txTimedate[7] = TOBCD(ct.year - YEAR_BASE);
err = SPIBUS_TRANSFER(device_get_parent(dev), dev, &cmd);
DELAY(PCF2123_DELAY);
return (err);
}
static int
pcf2123_rtc_gettime(device_t dev, struct timespec *ts)
{
struct clocktime ct;
struct spi_command cmd;
unsigned char rxTimedate[8];
unsigned char txTimedate[8];
int err;
memset(&cmd, 0, sizeof(cmd));
memset(rxTimedate, 0, sizeof(rxTimedate));
memset(txTimedate, 0, sizeof(txTimedate));
/*
* Counter is stopped when access to time registers is in progress
* So there is no need to stop/start counter
*/
/* Start reading from seconds */
txTimedate[0] = PCF2123_READ(PCF2123_REG_SECONDS);
cmd.rx_cmd = rxTimedate;
cmd.tx_cmd = txTimedate;
cmd.rx_cmd_sz = sizeof(rxTimedate);
cmd.tx_cmd_sz = sizeof(txTimedate);
err = SPIBUS_TRANSFER(device_get_parent(dev), dev, &cmd);
DELAY(PCF2123_DELAY);
ct.nsec = 0;
ct.sec = FROMBCD(rxTimedate[1] & 0x7f);
ct.min = FROMBCD(rxTimedate[2] & 0x7f);
ct.hour = FROMBCD(rxTimedate[3] & 0x3f);
ct.dow = FROMBCD(rxTimedate[5] & 0x3f);
ct.day = FROMBCD(rxTimedate[4] & 0x3f);
ct.mon = FROMBCD(rxTimedate[6] & 0x1f);
ct.year = YEAR_BASE + FROMBCD(rxTimedate[7]);
return (clock_ct_to_ts(&ct, ts));
}
static int
spigen_transfer_mmapped(struct cdev *cdev, struct spigen_transfer_mmapped *stm)
{
struct spi_command transfer = SPI_COMMAND_INITIALIZER;
device_t dev = cdev->si_drv1;
struct spigen_softc *sc = device_get_softc(dev);
int error = 0;
mtx_lock(&sc->sc_mtx);
if (sc->sc_mmap_busy)
error = EBUSY;
else if (stm->stm_command_length > sc->sc_command_length_max ||
stm->stm_data_length > sc->sc_data_length_max)
error = E2BIG;
else if (sc->sc_mmap_buffer == NULL)
error = EINVAL;
else if (sc->sc_mmap_buffer_size <
stm->stm_command_length + stm->stm_data_length)
error = ENOMEM;
if (error == 0)
sc->sc_mmap_busy = 1;
mtx_unlock(&sc->sc_mtx);
if (error)
return (error);
transfer.tx_cmd = transfer.rx_cmd = (void *)sc->sc_mmap_kvaddr;
transfer.tx_cmd_sz = transfer.rx_cmd_sz = stm->stm_command_length;
transfer.tx_data = transfer.rx_data =
(void *)(sc->sc_mmap_kvaddr + stm->stm_command_length);
transfer.tx_data_sz = transfer.rx_data_sz = stm->stm_data_length;
error = SPIBUS_TRANSFER(device_get_parent(dev), dev, &transfer);
mtx_lock(&sc->sc_mtx);
KASSERT(sc->sc_mmap_busy, ("mmap no longer marked busy"));
sc->sc_mmap_busy = 0;
mtx_unlock(&sc->sc_mtx);
return (error);
}
static int
spibus_transfer_impl(device_t dev, device_t child, struct spi_command *cmd)
{
return (SPIBUS_TRANSFER(device_get_parent(dev), child, cmd));
}
