1 /* $NetBSD: spi.c,v 1.9 2018/09/03 16:29:33 riastradh Exp $ */ 2 3 /*- 4 * Copyright (c) 2006 Urbana-Champaign Independent Media Center. 5 * Copyright (c) 2006 Garrett D'Amore. 6 * All rights reserved. 7 * 8 * Portions of this code were written by Garrett D'Amore for the 9 * Champaign-Urbana Community Wireless Network Project. 10 * 11 * Redistribution and use in source and binary forms, with or 12 * without modification, are permitted provided that the following 13 * conditions are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above 17 * copyright notice, this list of conditions and the following 18 * disclaimer in the documentation and/or other materials provided 19 * with the distribution. 20 * 3. All advertising materials mentioning features or use of this 21 * software must display the following acknowledgements: 22 * This product includes software developed by the Urbana-Champaign 23 * Independent Media Center. 24 * This product includes software developed by Garrett D'Amore. 25 * 4. Urbana-Champaign Independent Media Center's name and Garrett 26 * D'Amore's name may not be used to endorse or promote products 27 * derived from this software without specific prior written permission. 28 * 29 * THIS SOFTWARE IS PROVIDED BY THE URBANA-CHAMPAIGN INDEPENDENT 30 * MEDIA CENTER AND GARRETT D'AMORE ``AS IS'' AND ANY EXPRESS OR 31 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 32 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 33 * ARE DISCLAIMED. IN NO EVENT SHALL THE URBANA-CHAMPAIGN INDEPENDENT 34 * MEDIA CENTER OR GARRETT D'AMORE BE LIABLE FOR ANY DIRECT, INDIRECT, 35 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 36 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 37 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 38 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 40 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 41 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 42 */ 43 44 #include <sys/cdefs.h> 45 __KERNEL_RCSID(0, "$NetBSD: spi.c,v 1.9 2018/09/03 16:29:33 riastradh Exp $"); 46 47 #include "locators.h" 48 49 #include <sys/param.h> 50 #include <sys/systm.h> 51 #include <sys/device.h> 52 #include <sys/malloc.h> 53 #include <sys/mutex.h> 54 #include <sys/condvar.h> 55 #include <sys/errno.h> 56 57 #include <dev/spi/spivar.h> 58 59 struct spi_softc { 60 struct spi_controller sc_controller; 61 int sc_mode; 62 int sc_speed; 63 int sc_nslaves; 64 struct spi_handle *sc_slaves; 65 }; 66 67 /* 68 * SPI slave device. We have one of these per slave. 69 */ 70 struct spi_handle { 71 struct spi_softc *sh_sc; 72 struct spi_controller *sh_controller; 73 int sh_slave; 74 }; 75 76 /* 77 * API for bus drivers. 78 */ 79 80 int 81 spibus_print(void *aux, const char *pnp) 82 { 83 84 if (pnp != NULL) 85 aprint_normal("spi at %s", pnp); 86 87 return (UNCONF); 88 } 89 90 91 static int 92 spi_match(device_t parent, cfdata_t cf, void *aux) 93 { 94 95 return 1; 96 } 97 98 static int 99 spi_print(void *aux, const char *pnp) 100 { 101 struct spi_attach_args *sa = aux; 102 103 if (sa->sa_handle->sh_slave != -1) 104 aprint_normal(" slave %d", sa->sa_handle->sh_slave); 105 106 return (UNCONF); 107 } 108 109 static int 110 spi_search(device_t parent, cfdata_t cf, const int *ldesc, void *aux) 111 { 112 struct spi_softc *sc = device_private(parent); 113 struct spi_attach_args sa; 114 int addr; 115 116 addr = cf->cf_loc[SPICF_SLAVE]; 117 if ((addr < 0) || (addr >= sc->sc_controller.sct_nslaves)) { 118 return -1; 119 } 120 121 sa.sa_handle = &sc->sc_slaves[addr]; 122 123 if (config_match(parent, cf, &sa) > 0) 124 config_attach(parent, cf, &sa, spi_print); 125 126 return 0; 127 } 128 129 /* 130 * API for device drivers. 131 * 132 * We provide wrapper routines to decouple the ABI for the SPI 133 * device drivers from the ABI for the SPI bus drivers. 134 */ 135 static void 136 spi_attach(device_t parent, device_t self, void *aux) 137 { 138 struct spi_softc *sc = device_private(self); 139 struct spibus_attach_args *sba = aux; 140 int i; 141 142 aprint_naive(": SPI bus\n"); 143 aprint_normal(": SPI bus\n"); 144 145 sc->sc_controller = *sba->sba_controller; 146 sc->sc_nslaves = sba->sba_controller->sct_nslaves; 147 /* allocate slave structures */ 148 sc->sc_slaves = malloc(sizeof (struct spi_handle) * sc->sc_nslaves, 149 M_DEVBUF, M_WAITOK | M_ZERO); 150 151 sc->sc_speed = 0; 152 sc->sc_mode = -1; 153 154 /* 155 * Initialize slave handles 156 */ 157 for (i = 0; i < sc->sc_nslaves; i++) { 158 sc->sc_slaves[i].sh_slave = i; 159 sc->sc_slaves[i].sh_sc = sc; 160 sc->sc_slaves[i].sh_controller = &sc->sc_controller; 161 } 162 163 /* 164 * Locate and attach child devices 165 */ 166 config_search_ia(spi_search, self, "spi", NULL); 167 } 168 169 CFATTACH_DECL_NEW(spi, sizeof(struct spi_softc), 170 spi_match, spi_attach, NULL, NULL); 171 172 /* 173 * Configure. This should be the first thing that the SPI driver 174 * should do, to configure which mode (e.g. SPI_MODE_0, which is the 175 * same as Philips Microwire mode), and speed. If the bus driver 176 * cannot run fast enough, then it should just configure the fastest 177 * mode that it can support. If the bus driver cannot run slow 178 * enough, then the device is incompatible and an error should be 179 * returned. 180 */ 181 int 182 spi_configure(struct spi_handle *sh, int mode, int speed) 183 { 184 int s, rv; 185 struct spi_softc *sc = sh->sh_sc; 186 struct spi_controller *tag = sh->sh_controller; 187 188 /* ensure that request is compatible with other devices on the bus */ 189 if ((sc->sc_mode >= 0) && (sc->sc_mode != mode)) 190 return EINVAL; 191 192 s = splbio(); 193 /* pick lowest configured speed */ 194 if (speed == 0) 195 speed = sc->sc_speed; 196 if (sc->sc_speed) 197 speed = uimin(sc->sc_speed, speed); 198 199 rv = (*tag->sct_configure)(tag->sct_cookie, sh->sh_slave, 200 mode, speed); 201 202 if (rv == 0) { 203 sc->sc_mode = mode; 204 sc->sc_speed = speed; 205 } 206 splx(s); 207 return rv; 208 } 209 210 void 211 spi_transfer_init(struct spi_transfer *st) 212 { 213 214 mutex_init(&st->st_lock, MUTEX_DEFAULT, IPL_BIO); 215 cv_init(&st->st_cv, "spicv"); 216 217 st->st_flags = 0; 218 st->st_errno = 0; 219 st->st_done = NULL; 220 st->st_chunks = NULL; 221 st->st_private = NULL; 222 st->st_slave = -1; 223 } 224 225 void 226 spi_chunk_init(struct spi_chunk *chunk, int cnt, const uint8_t *wptr, 227 uint8_t *rptr) 228 { 229 230 chunk->chunk_write = chunk->chunk_wptr = wptr; 231 chunk->chunk_read = chunk->chunk_rptr = rptr; 232 chunk->chunk_rresid = chunk->chunk_wresid = chunk->chunk_count = cnt; 233 chunk->chunk_next = NULL; 234 } 235 236 void 237 spi_transfer_add(struct spi_transfer *st, struct spi_chunk *chunk) 238 { 239 struct spi_chunk **cpp; 240 241 /* this is an O(n) insert -- perhaps we should use a simpleq? */ 242 for (cpp = &st->st_chunks; *cpp; cpp = &(*cpp)->chunk_next); 243 *cpp = chunk; 244 } 245 246 int 247 spi_transfer(struct spi_handle *sh, struct spi_transfer *st) 248 { 249 struct spi_controller *tag = sh->sh_controller; 250 struct spi_chunk *chunk; 251 252 /* 253 * Initialize "resid" counters and pointers, so that callers 254 * and bus drivers don't have to. 255 */ 256 for (chunk = st->st_chunks; chunk; chunk = chunk->chunk_next) { 257 chunk->chunk_wresid = chunk->chunk_rresid = chunk->chunk_count; 258 chunk->chunk_wptr = chunk->chunk_write; 259 chunk->chunk_rptr = chunk->chunk_read; 260 } 261 262 /* 263 * Match slave to handle's slave. 264 */ 265 st->st_slave = sh->sh_slave; 266 267 return (*tag->sct_transfer)(tag->sct_cookie, st); 268 } 269 270 void 271 spi_wait(struct spi_transfer *st) 272 { 273 274 mutex_enter(&st->st_lock); 275 while (!(st->st_flags & SPI_F_DONE)) { 276 cv_wait(&st->st_cv, &st->st_lock); 277 } 278 mutex_exit(&st->st_lock); 279 cv_destroy(&st->st_cv); 280 mutex_destroy(&st->st_lock); 281 } 282 283 void 284 spi_done(struct spi_transfer *st, int err) 285 { 286 287 mutex_enter(&st->st_lock); 288 if ((st->st_errno = err) != 0) { 289 st->st_flags |= SPI_F_ERROR; 290 } 291 st->st_flags |= SPI_F_DONE; 292 if (st->st_done != NULL) { 293 (*st->st_done)(st); 294 } else { 295 cv_broadcast(&st->st_cv); 296 } 297 mutex_exit(&st->st_lock); 298 } 299 300 /* 301 * Some convenience routines. These routines block until the work 302 * is done. 303 * 304 * spi_recv - receives data from the bus 305 * 306 * spi_send - sends data to the bus 307 * 308 * spi_send_recv - sends data to the bus, and then receives. Note that this is 309 * done synchronously, i.e. send a command and get the response. This is 310 * not full duplex. If you wnat full duplex, you can't use these convenience 311 * wrappers. 312 */ 313 int 314 spi_recv(struct spi_handle *sh, int cnt, uint8_t *data) 315 { 316 struct spi_transfer trans; 317 struct spi_chunk chunk; 318 319 spi_transfer_init(&trans); 320 spi_chunk_init(&chunk, cnt, NULL, data); 321 spi_transfer_add(&trans, &chunk); 322 323 /* enqueue it and wait for it to complete */ 324 spi_transfer(sh, &trans); 325 spi_wait(&trans); 326 327 if (trans.st_flags & SPI_F_ERROR) 328 return trans.st_errno; 329 330 return 0; 331 } 332 333 int 334 spi_send(struct spi_handle *sh, int cnt, const uint8_t *data) 335 { 336 struct spi_transfer trans; 337 struct spi_chunk chunk; 338 339 spi_transfer_init(&trans); 340 spi_chunk_init(&chunk, cnt, data, NULL); 341 spi_transfer_add(&trans, &chunk); 342 343 /* enqueue it and wait for it to complete */ 344 spi_transfer(sh, &trans); 345 spi_wait(&trans); 346 347 if (trans.st_flags & SPI_F_ERROR) 348 return trans.st_errno; 349 350 return 0; 351 } 352 353 int 354 spi_send_recv(struct spi_handle *sh, int scnt, const uint8_t *snd, 355 int rcnt, uint8_t *rcv) 356 { 357 struct spi_transfer trans; 358 struct spi_chunk chunk1, chunk2; 359 360 spi_transfer_init(&trans); 361 spi_chunk_init(&chunk1, scnt, snd, NULL); 362 spi_chunk_init(&chunk2, rcnt, NULL, rcv); 363 spi_transfer_add(&trans, &chunk1); 364 spi_transfer_add(&trans, &chunk2); 365 366 /* enqueue it and wait for it to complete */ 367 spi_transfer(sh, &trans); 368 spi_wait(&trans); 369 370 if (trans.st_flags & SPI_F_ERROR) 371 return trans.st_errno; 372 373 return 0; 374 } 375