/* $NetBSD: spi.c,v 1.41 2026/01/17 05:33:51 skrll Exp $ */ /*- * Copyright (c) 2006 Urbana-Champaign Independent Media Center. * Copyright (c) 2006 Garrett D'Amore. * All rights reserved. * * Portions of this code were written by Garrett D'Amore for the * Champaign-Urbana Community Wireless Network Project. * * 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. All advertising materials mentioning features or use of this * software must display the following acknowledgements: * This product includes software developed by the Urbana-Champaign * Independent Media Center. * This product includes software developed by Garrett D'Amore. * 4. Urbana-Champaign Independent Media Center's name and Garrett * D'Amore's name may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE URBANA-CHAMPAIGN INDEPENDENT * MEDIA CENTER AND GARRETT D'AMORE ``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 URBANA-CHAMPAIGN INDEPENDENT * MEDIA CENTER OR GARRETT D'AMORE 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. */ #include "opt_fdt.h" /* XXX */ #include __KERNEL_RCSID(0, "$NetBSD: spi.c,v 1.41 2026/01/17 05:33:51 skrll Exp $"); #include "locators.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef FDT #include /* XXX */ #include /* XXX */ #endif #include "ioconf.h" #include "locators.h" struct spi_softc { device_t sc_dev; const struct spi_controller *sc_controller; int sc_mode; int sc_speed; int sc_slave; int sc_nslaves; spi_handle_t sc_slaves; kmutex_t sc_slave_state_lock; kmutex_t sc_lock; kcondvar_t sc_cv; kmutex_t sc_dev_lock; int sc_flags; #define SPIC_BUSY 1 }; static dev_type_open(spi_open); static dev_type_close(spi_close); static dev_type_ioctl(spi_ioctl); const struct cdevsw spi_cdevsw = { .d_open = spi_open, .d_close = spi_close, .d_read = noread, .d_write = nowrite, .d_ioctl = spi_ioctl, .d_stop = nostop, .d_tty = notty, .d_poll = nopoll, .d_mmap = nommap, .d_kqfilter = nokqfilter, .d_discard = nodiscard, .d_flag = D_OTHER | D_MPSAFE }; /* * SPI slave device. We have one of these per slave. */ struct spi_handle { struct spi_softc *sh_sc; /* static */ const struct spi_controller *sh_controller; /* static */ int sh_slave; /* static */ int sh_mode; /* locked by owning child */ int sh_speed; /* locked by owning child */ int sh_flags; /* vv slave_state_lock vv */ #define SPIH_ATTACHED __BIT(0) #define SPIH_DIRECT __BIT(1) device_t sh_dev; /* ^^ slave_state_lock ^^ */ }; #define SPI_MAXDATA 4096 /* * API for bus drivers. */ int spibus_print(void *aux, const char *pnp) { if (pnp != NULL) aprint_normal("spi at %s", pnp); return (UNCONF); } static int spi_match(device_t parent, cfdata_t cf, void *aux) { return 1; } static int spi_print_direct(void *aux, const char *pnp) { struct spi_attach_args *sa = aux; if (pnp != NULL) { aprint_normal("%s%s%s%s at %s slave %d", sa->sa_name ? sa->sa_name : "(unknown)", sa->sa_clist ? " (" : "", sa->sa_clist ? sa->sa_clist : "", sa->sa_clist ? ")" : "", pnp, sa->sa_handle->sh_slave); } else { aprint_normal(" slave %d", sa->sa_handle->sh_slave); } return UNCONF; } static int spi_print(void *aux, const char *pnp) { struct spi_attach_args *sa = aux; aprint_normal(" slave %d", sa->sa_handle->sh_slave); return UNCONF; } static void spi_attach_child(struct spi_softc *sc, struct spi_attach_args *sa, int chip_select, cfdata_t cf) { spi_handle_t sh; device_t newdev = NULL; bool is_direct = cf == NULL; const int skip_flags = is_direct ? SPIH_ATTACHED : (SPIH_ATTACHED | SPIH_DIRECT); const int claim_flags = skip_flags ^ SPIH_DIRECT; int locs[SPICF_NLOCS] = { 0 }; if (chip_select < 0 || chip_select >= sc->sc_controller->sct_nslaves) { return; } sh = &sc->sc_slaves[chip_select]; mutex_enter(&sc->sc_slave_state_lock); if (ISSET(sh->sh_flags, skip_flags)) { mutex_exit(&sc->sc_slave_state_lock); return; } /* Keep others off of this chip select. */ SET(sh->sh_flags, claim_flags); mutex_exit(&sc->sc_slave_state_lock); locs[SPICF_SLAVE] = chip_select; sa->sa_handle = sh; if (is_direct) { newdev = config_found(sc->sc_dev, sa, spi_print_direct, CFARGS(.submatch = config_stdsubmatch, .locators = locs, .devhandle = sa->sa_devhandle)); } else { if (config_probe(sc->sc_dev, cf, sa)) { newdev = config_attach(sc->sc_dev, cf, sa, spi_print, CFARGS(.locators = locs)); } } mutex_enter(&sc->sc_slave_state_lock); if (newdev == NULL) { /* * Clear our claim on this chip select (yes, just * the ATTACHED flag; we want to keep indirects off * of chip selects for which there is a device tree * node). */ CLR(sh->sh_flags, SPIH_ATTACHED); } else { /* Record the child for posterity. */ sh->sh_dev = newdev; } mutex_exit(&sc->sc_slave_state_lock); } static int spi_search(device_t parent, cfdata_t cf, const int *ldesc, void *aux) { struct spi_softc *sc = device_private(parent); if (cf->cf_loc[SPICF_SLAVE] == SPICF_SLAVE_DEFAULT) { /* No wildcards for indirect on SPI. */ return 0; } struct spi_attach_args sa = { 0 }; spi_attach_child(sc, &sa, cf->cf_loc[SPICF_SLAVE], cf); return 0; } static bool spi_enumerate_devices_callback(device_t self, struct spi_enumerate_devices_args *args) { struct spi_softc *sc = device_private(self); spi_attach_child(sc, args->sa, args->chip_select, NULL); return true; /* keep enumerating */ } int spi_compatible_match(const struct spi_attach_args *sa, const struct device_compatible_entry *compats) { return device_compatible_match_strlist(sa->sa_clist, sa->sa_clist_size, compats); } const struct device_compatible_entry * spi_compatible_lookup(const struct spi_attach_args *sa, const struct device_compatible_entry *compats) { return device_compatible_lookup_strlist(sa->sa_clist, sa->sa_clist_size, compats); } bool spi_use_direct_match(const struct spi_attach_args *sa, const struct device_compatible_entry *compats, int *match_resultp) { KASSERT(match_resultp != NULL); if (sa->sa_clist != NULL && sa->sa_clist_size != 0) { *match_resultp = spi_compatible_match(sa, compats); return true; } return false; } /* * API for device drivers. * * We provide wrapper routines to decouple the ABI for the SPI * device drivers from the ABI for the SPI bus drivers. */ static void spi_attach(device_t parent, device_t self, void *aux) { struct spi_softc *sc = device_private(self); struct spibus_attach_args *sba = aux; int i; aprint_naive(": SPI bus\n"); aprint_normal(": SPI bus\n"); mutex_init(&sc->sc_dev_lock, MUTEX_DEFAULT, IPL_NONE); mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_VM); mutex_init(&sc->sc_slave_state_lock, MUTEX_DEFAULT, IPL_NONE); cv_init(&sc->sc_cv, "spictl"); sc->sc_dev = self; sc->sc_controller = sba->sba_controller; sc->sc_nslaves = sba->sba_controller->sct_nslaves; /* allocate slave structures */ sc->sc_slaves = malloc(sizeof(*sc->sc_slaves) * sc->sc_nslaves, M_DEVBUF, M_WAITOK | M_ZERO); sc->sc_speed = 0; sc->sc_mode = -1; sc->sc_slave = -1; /* * Initialize slave handles */ for (i = 0; i < sc->sc_nslaves; i++) { sc->sc_slaves[i].sh_slave = i; sc->sc_slaves[i].sh_sc = sc; sc->sc_slaves[i].sh_controller = sc->sc_controller; } /* XXX Need a better way for this. */ switch (devhandle_type(device_handle(sc->sc_dev))) { #ifdef FDT case DEVHANDLE_TYPE_OF: #if 0 /* * XXX The addition of a USB SPI controller has triggered * XXX an unfortunate situation, whereby it is attaching * XXX a SPI controller on an otherwise FDT platform (RISC-V) * XXX that does not happen to currently have any platform * XXX SoC SPI controller drivers that carry the fdt_spi * XXX config attribute that would pull in the function * XXX being called here. * XXX * XXX As it happens we can fairly safely elide this call * XXX because, at the moment (1 Dec 2025), there are no * XXX consumers of the registration it performs. However, * XXX this points to a larger problem if needed a way to * XXX resolve these situations at runtime with some sort * XXX of "platform" abstraction rather than at kernel build * XXX time. */ fdtbus_register_spi_controller(self, sc->sc_controller); #endif break; #endif /* FDT */ default: break; } /* * Attempt to enumerate the devices on the bus using the * platform device tree. */ struct spi_attach_args sa = { 0 }; struct spi_enumerate_devices_args enumargs = { .sa = &sa, .callback = spi_enumerate_devices_callback, }; device_call(self, SPI_ENUMERATE_DEVICES(&enumargs)); /* Then do any other devices the user may have manually wired */ config_search(self, NULL, CFARGS(.search = spi_search)); } static int spi_detach(device_t self, int flags) { int error; error = config_detach_children(self, flags); if (error) return error; return 0; } static int spi_open(dev_t dev, int flag, int fmt, lwp_t *l) { struct spi_softc *sc = device_lookup_private(&spi_cd, minor(dev)); if (sc == NULL) return ENXIO; return 0; } static int spi_close(dev_t dev, int flag, int fmt, lwp_t *l) { return 0; } static int spi_ioctl(dev_t dev, u_long cmd, void *data, int flag, lwp_t *l) { struct spi_softc *sc = device_lookup_private(&spi_cd, minor(dev)); spi_handle_t sh; spi_ioctl_configure_t *sic; spi_ioctl_transfer_t *sit; uint8_t *sbuf, *rbuf; int error; if (sc == NULL) return ENXIO; mutex_enter(&sc->sc_dev_lock); switch (cmd) { case SPI_IOCTL_CONFIGURE: sic = (spi_ioctl_configure_t *)data; if (sic->sic_addr < 0 || sic->sic_addr >= sc->sc_nslaves) { error = EINVAL; break; } sh = &sc->sc_slaves[sic->sic_addr]; error = spi_configure(sc->sc_dev, sh, sic->sic_mode, sic->sic_speed); break; case SPI_IOCTL_TRANSFER: sit = (spi_ioctl_transfer_t *)data; if (sit->sit_addr < 0 || sit->sit_addr >= sc->sc_nslaves) { error = EINVAL; break; } if ((sit->sit_send && sit->sit_sendlen == 0) || (sit->sit_recv && sit->sit_recvlen == 0)) { error = EINVAL; break; } sh = &sc->sc_slaves[sit->sit_addr]; sbuf = rbuf = NULL; error = 0; if (sit->sit_send && sit->sit_sendlen <= SPI_MAXDATA) { sbuf = malloc(sit->sit_sendlen, M_DEVBUF, M_WAITOK); error = copyin(sit->sit_send, sbuf, sit->sit_sendlen); } if (sit->sit_recv && sit->sit_recvlen <= SPI_MAXDATA) { rbuf = malloc(sit->sit_recvlen, M_DEVBUF, M_WAITOK); } if (error == 0) { if (sbuf && rbuf) error = spi_send_recv(sh, sit->sit_sendlen, sbuf, sit->sit_recvlen, rbuf); else if (sbuf) error = spi_send(sh, sit->sit_sendlen, sbuf); else if (rbuf) error = spi_recv(sh, sit->sit_recvlen, rbuf); } if (rbuf) { if (error == 0) error = copyout(rbuf, sit->sit_recv, sit->sit_recvlen); free(rbuf, M_DEVBUF); } if (sbuf) { free(sbuf, M_DEVBUF); } break; default: error = ENODEV; break; } mutex_exit(&sc->sc_dev_lock); return error; } CFATTACH_DECL_NEW(spi, sizeof(struct spi_softc), spi_match, spi_attach, spi_detach, NULL); /* * Configure. This should be the first thing that the SPI driver * should do, to configure which mode (e.g. SPI_MODE_0, which is the * same as Philips Microwire mode), and speed. If the bus driver * cannot run fast enough, then it should just configure the fastest * mode that it can support. If the bus driver cannot run slow * enough, then the device is incompatible and an error should be * returned. */ int spi_configure(device_t dev, spi_handle_t sh, int mode, int speed) { struct spi_get_transfer_mode_args args = { 0 }; int error; /* * Get transfer mode information from the platform device tree, if * it exists. */ error = device_call(dev, SPI_GET_TRANSFER_MODE(&args)); if (error) { if (error != ENOTSUP) { /* * This error is fatal. Error message has already * been displayed. */ return error; } } else { /* * If the device tree specifies clock phase shift or * polarity inversion, override whatever the caller * specified. */ if (args.mode != 0) { aprint_debug_dev(dev, "using SPI mode %u from device tree\n", args.mode); mode = args.mode; } /* * If the device tree specifies the max clock frequency, * override whatever the caller specified. */ if (args.max_frequency != 0) { aprint_debug_dev(dev, "using max-frequency %u Hz from device tree\n", args.max_frequency); speed = args.max_frequency; } /* XXX Handle the other transfer properties. */ } sh->sh_mode = mode; sh->sh_speed = speed; return 0; } /* * Acquire controller */ static void spi_acquire(spi_handle_t sh) { struct spi_softc *sc = sh->sh_sc; mutex_enter(&sc->sc_lock); while ((sc->sc_flags & SPIC_BUSY) != 0) cv_wait(&sc->sc_cv, &sc->sc_lock); sc->sc_flags |= SPIC_BUSY; mutex_exit(&sc->sc_lock); } /* * Release controller */ static void spi_release(spi_handle_t sh) { struct spi_softc *sc = sh->sh_sc; mutex_enter(&sc->sc_lock); sc->sc_flags &= ~SPIC_BUSY; cv_broadcast(&sc->sc_cv); mutex_exit(&sc->sc_lock); } void spi_transfer_init(struct spi_transfer *st) { mutex_init(&st->st_lock, MUTEX_DEFAULT, IPL_VM); cv_init(&st->st_cv, "spixfr"); st->st_flags = 0; st->st_errno = 0; st->st_done = NULL; st->st_chunks = NULL; st->st_private = NULL; st->st_slave = -1; } void spi_chunk_init(struct spi_chunk *chunk, int cnt, const uint8_t *wptr, uint8_t *rptr) { chunk->chunk_write = chunk->chunk_wptr = wptr; chunk->chunk_read = chunk->chunk_rptr = rptr; chunk->chunk_rresid = chunk->chunk_wresid = chunk->chunk_count = cnt; chunk->chunk_next = NULL; } void spi_transfer_add(struct spi_transfer *st, struct spi_chunk *chunk) { struct spi_chunk **cpp; /* this is an O(n) insert -- perhaps we should use a simpleq? */ for (cpp = &st->st_chunks; *cpp; cpp = &(*cpp)->chunk_next); *cpp = chunk; } int spi_transfer(spi_handle_t sh, struct spi_transfer *st) { struct spi_softc *sc = sh->sh_sc; const struct spi_controller *tag = sh->sh_controller; struct spi_chunk *chunk; int error; /* * Initialize "resid" counters and pointers, so that callers * and bus drivers don't have to. */ for (chunk = st->st_chunks; chunk; chunk = chunk->chunk_next) { chunk->chunk_wresid = chunk->chunk_rresid = chunk->chunk_count; chunk->chunk_wptr = chunk->chunk_write; chunk->chunk_rptr = chunk->chunk_read; } /* * Match slave and parameters to handle */ st->st_slave = sh->sh_slave; /* * Reserve controller during transaction */ spi_acquire(sh); st->st_spiprivate = (void *)sh; /* * Reconfigure controller * * XXX backends don't configure per-slave parameters * Whenever we switch slaves or change mode or speed, we * need to tell the backend. */ if (sc->sc_slave != sh->sh_slave || sc->sc_mode != sh->sh_mode || sc->sc_speed != sh->sh_speed) { error = (*tag->sct_configure)(tag->sct_cookie, sh->sh_slave, sh->sh_mode, sh->sh_speed); if (error) return error; } sc->sc_mode = sh->sh_mode; sc->sc_speed = sh->sh_speed; sc->sc_slave = sh->sh_slave; error = (*tag->sct_transfer)(tag->sct_cookie, st); return error; } void spi_wait(struct spi_transfer *st) { spi_handle_t sh = st->st_spiprivate; mutex_enter(&st->st_lock); while (!(st->st_flags & SPI_F_DONE)) { cv_wait(&st->st_cv, &st->st_lock); } mutex_exit(&st->st_lock); cv_destroy(&st->st_cv); mutex_destroy(&st->st_lock); /* * End transaction */ spi_release(sh); } void spi_done(struct spi_transfer *st, int err) { mutex_enter(&st->st_lock); if ((st->st_errno = err) != 0) { st->st_flags |= SPI_F_ERROR; } st->st_flags |= SPI_F_DONE; if (st->st_done != NULL) { (*st->st_done)(st); } else { cv_broadcast(&st->st_cv); } mutex_exit(&st->st_lock); } /* * Some convenience routines. These routines block until the work * is done. * * spi_recv - receives data from the bus * * spi_send - sends data to the bus * * spi_send_recv - sends data to the bus, and then receives. Note that this is * done synchronously, i.e. send a command and get the response. This is * not full duplex. If you want full duplex, you can't use these convenience * wrappers. * * spi_sendv - scatter send data to the bus */ int spi_recv(spi_handle_t sh, int cnt, uint8_t *data) { struct spi_transfer trans; struct spi_chunk chunk; spi_transfer_init(&trans); spi_chunk_init(&chunk, cnt, NULL, data); spi_transfer_add(&trans, &chunk); /* enqueue it and wait for it to complete */ spi_transfer(sh, &trans); spi_wait(&trans); if (trans.st_flags & SPI_F_ERROR) return trans.st_errno; return 0; } int spi_send(spi_handle_t sh, int cnt, const uint8_t *data) { struct spi_transfer trans; struct spi_chunk chunk; spi_transfer_init(&trans); spi_chunk_init(&chunk, cnt, data, NULL); spi_transfer_add(&trans, &chunk); /* enqueue it and wait for it to complete */ spi_transfer(sh, &trans); spi_wait(&trans); if (trans.st_flags & SPI_F_ERROR) return trans.st_errno; return 0; } int spi_send_recv(spi_handle_t sh, int scnt, const uint8_t *snd, int rcnt, uint8_t *rcv) { struct spi_transfer trans; struct spi_chunk chunk1, chunk2; spi_transfer_init(&trans); spi_chunk_init(&chunk1, scnt, snd, NULL); spi_chunk_init(&chunk2, rcnt, NULL, rcv); spi_transfer_add(&trans, &chunk1); spi_transfer_add(&trans, &chunk2); /* enqueue it and wait for it to complete */ spi_transfer(sh, &trans); spi_wait(&trans); if (trans.st_flags & SPI_F_ERROR) return trans.st_errno; return 0; } int spi_sendv(spi_handle_t sh, const struct iovec *iov, int iovcnt) { struct spi_transfer trans; SIMPLEQ_HEAD(,spi_chunk_q) ck_q; struct spi_chunk_q *ce; SIMPLEQ_INIT(&ck_q); spi_transfer_init(&trans); for(int c = 0; c < iovcnt;c++) { ce = kmem_alloc(sizeof(struct spi_chunk_q),KM_NOSLEEP); if (ce == NULL) return ENOMEM; spi_chunk_init(&ce->chunk, iov[c].iov_len, iov[c].iov_base, NULL); spi_transfer_add(&trans, &ce->chunk); SIMPLEQ_INSERT_HEAD(&ck_q, ce, chunk_q); } /* enqueue it and wait for it to complete */ spi_transfer(sh, &trans); spi_wait(&trans); while ((ce = SIMPLEQ_FIRST(&ck_q)) != NULL) { SIMPLEQ_REMOVE_HEAD(&ck_q, chunk_q); kmem_free(ce, sizeof(struct spi_chunk_q)); } if (trans.st_flags & SPI_F_ERROR) return trans.st_errno; return 0; }