1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2021, Adrian Chadd <adrian@FreeBSD.org>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice unmodified, this list of conditions, and the following
11 * disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/param.h>
30 #include <sys/systm.h>
31
32 #include <sys/bus.h>
33 #include <sys/interrupt.h>
34 #include <sys/malloc.h>
35 #include <sys/lock.h>
36 #include <sys/mutex.h>
37 #include <sys/kernel.h>
38 #include <sys/module.h>
39 #include <sys/rman.h>
40 #include <sys/gpio.h>
41
42 #include <vm/vm.h>
43 #include <vm/pmap.h>
44 #include <vm/vm_extern.h>
45
46 #include <machine/bus.h>
47 #include <machine/cpu.h>
48
49 #include <dev/fdt/fdt_common.h>
50 #include <dev/fdt/fdt_pinctrl.h>
51
52 #include <dev/gpio/gpiobusvar.h>
53 #include <dev/ofw/ofw_bus.h>
54 #include <dev/ofw/ofw_bus_subr.h>
55
56 #include <dev/clk/clk.h>
57 #include <dev/hwreset/hwreset.h>
58
59 #include <dev/spibus/spi.h>
60 #include <dev/spibus/spibusvar.h>
61 #include "spibus_if.h"
62
63 #include <dev/qcom_qup/qcom_spi_var.h>
64 #include <dev/qcom_qup/qcom_qup_reg.h>
65 #include <dev/qcom_qup/qcom_spi_reg.h>
66 #include <dev/qcom_qup/qcom_spi_debug.h>
67
68 static struct ofw_compat_data compat_data[] = {
69 { "qcom,spi-qup-v1.1.1", QCOM_SPI_HW_QPI_V1_1 },
70 { "qcom,spi-qup-v2.1.1", QCOM_SPI_HW_QPI_V2_1 },
71 { "qcom,spi-qup-v2.2.1", QCOM_SPI_HW_QPI_V2_2 },
72 { NULL, 0 }
73 };
74
75 /*
76 * Flip the CS GPIO line either active or inactive.
77 *
78 * Actually listen to the CS polarity.
79 */
80 static void
qcom_spi_set_chipsel(struct qcom_spi_softc * sc,int cs,bool active)81 qcom_spi_set_chipsel(struct qcom_spi_softc *sc, int cs, bool active)
82 {
83 bool pinactive;
84 bool invert = !! (cs & SPIBUS_CS_HIGH);
85
86 cs = cs & ~SPIBUS_CS_HIGH;
87
88 if (sc->cs_pins[cs] == NULL) {
89 device_printf(sc->sc_dev,
90 "%s: cs=%u, active=%u, invert=%u, no gpio?\n",
91 __func__, cs, active, invert);
92 return;
93 }
94
95 QCOM_SPI_DPRINTF(sc, QCOM_SPI_DEBUG_CHIPSELECT,
96 "%s: cs=%u active=%u\n", __func__, cs, active);
97
98 /*
99 * Default rule here is CS is active low.
100 */
101 if (active)
102 pinactive = false;
103 else
104 pinactive = true;
105
106 /*
107 * Invert the CS line if required.
108 */
109 if (invert)
110 pinactive = !! pinactive;
111
112 gpio_pin_set_active(sc->cs_pins[cs], pinactive);
113 gpio_pin_is_active(sc->cs_pins[cs], &pinactive);
114 }
115
116 static void
qcom_spi_intr(void * arg)117 qcom_spi_intr(void *arg)
118 {
119 struct qcom_spi_softc *sc = arg;
120 int ret;
121
122 QCOM_SPI_DPRINTF(sc, QCOM_SPI_DEBUG_INTR, "%s: called\n", __func__);
123
124
125 QCOM_SPI_LOCK(sc);
126 ret = qcom_spi_hw_interrupt_handle(sc);
127 if (ret != 0) {
128 device_printf(sc->sc_dev,
129 "ERROR: failed to read intr status\n");
130 goto done;
131 }
132
133 /*
134 * Handle spurious interrupts outside of an actual
135 * transfer.
136 */
137 if (sc->transfer.active == false) {
138 device_printf(sc->sc_dev,
139 "ERROR: spurious interrupt\n");
140 qcom_spi_hw_ack_opmode(sc);
141 goto done;
142 }
143
144 /* Now, handle interrupts */
145 if (sc->intr.error) {
146 sc->intr.error = false;
147 device_printf(sc->sc_dev, "ERROR: intr\n");
148 }
149
150 if (sc->intr.do_rx) {
151 sc->intr.do_rx = false;
152 QCOM_SPI_DPRINTF(sc, QCOM_SPI_DEBUG_INTR,
153 "%s: PIO_READ\n", __func__);
154 if (sc->state.transfer_mode == QUP_IO_M_MODE_FIFO)
155 ret = qcom_spi_hw_read_pio_fifo(sc);
156 else
157 ret = qcom_spi_hw_read_pio_block(sc);
158 if (ret != 0) {
159 device_printf(sc->sc_dev,
160 "ERROR: qcom_spi_hw_read failed (%u)\n", ret);
161 goto done;
162 }
163 }
164 if (sc->intr.do_tx) {
165 sc->intr.do_tx = false;
166 QCOM_SPI_DPRINTF(sc, QCOM_SPI_DEBUG_INTR,
167 "%s: PIO_WRITE\n", __func__);
168 /*
169 * For FIFO operations we do not do a write here, we did
170 * it at the beginning of the transfer.
171 *
172 * For BLOCK operations yes, we call the routine.
173 */
174
175 if (sc->state.transfer_mode == QUP_IO_M_MODE_FIFO)
176 ret = qcom_spi_hw_ack_write_pio_fifo(sc);
177 else
178 ret = qcom_spi_hw_write_pio_block(sc);
179 if (ret != 0) {
180 device_printf(sc->sc_dev,
181 "ERROR: qcom_spi_hw_write failed (%u)\n", ret);
182 goto done;
183 }
184 }
185
186 /*
187 * Do this last. We may actually have completed the
188 * transfer in the PIO receive path above and it will
189 * set the done flag here.
190 */
191 if (sc->intr.done) {
192 sc->intr.done = false;
193 sc->transfer.done = true;
194 QCOM_SPI_DPRINTF(sc, QCOM_SPI_DEBUG_INTR,
195 "%s: transfer done\n", __func__);
196 wakeup(sc);
197 }
198
199 done:
200 QCOM_SPI_DPRINTF(sc, QCOM_SPI_DEBUG_INTR,
201 "%s: done\n", __func__);
202 QCOM_SPI_UNLOCK(sc);
203 }
204
205 static int
qcom_spi_probe(device_t dev)206 qcom_spi_probe(device_t dev)
207 {
208
209 if (!ofw_bus_status_okay(dev))
210 return (ENXIO);
211
212 if (!ofw_bus_search_compatible(dev, compat_data)->ocd_data)
213 return (ENXIO);
214
215 device_set_desc(dev, "Qualcomm SPI Interface");
216 return (BUS_PROBE_DEFAULT);
217 }
218
219 /*
220 * Allocate GPIOs if provided in the SPI controller block.
221 *
222 * Some devices will use GPIO lines for chip select.
223 * It's also quite annoying because some devices will want to use
224 * the hardware provided CS gating for say, the first chipselect block,
225 * and then use GPIOs for the later ones.
226 *
227 * So here we just assume for now that SPI index 0 uses the hardware
228 * lines, and >0 use GPIO lines. Revisit this if better hardware
229 * shows up.
230 *
231 * And finally, iterating over the cs-gpios list to allocate GPIOs
232 * doesn't actually tell us what the polarity is. For that we need
233 * to actually iterate over the list of child nodes and check what
234 * their properties are (and look for "spi-cs-high".)
235 */
236 static void
qcom_spi_attach_gpios(struct qcom_spi_softc * sc)237 qcom_spi_attach_gpios(struct qcom_spi_softc *sc)
238 {
239 phandle_t node;
240 int idx, err;
241
242 /* Allocate gpio pins for configured chip selects. */
243 node = ofw_bus_get_node(sc->sc_dev);
244 for (idx = 0; idx < nitems(sc->cs_pins); idx++) {
245 err = gpio_pin_get_by_ofw_propidx(sc->sc_dev, node,
246 "cs-gpios", idx, &sc->cs_pins[idx]);
247 if (err == 0) {
248 err = gpio_pin_setflags(sc->cs_pins[idx],
249 GPIO_PIN_OUTPUT);
250 if (err != 0) {
251 device_printf(sc->sc_dev,
252 "error configuring gpio for"
253 " cs %u (%d)\n", idx, err);
254 }
255 /*
256 * We can't set this HIGH right now because
257 * we don't know if it needs to be set to
258 * high for inactive or low for inactive
259 * based on the child SPI device flags.
260 */
261 #if 0
262 gpio_pin_set_active(sc->cs_pins[idx], 1);
263 gpio_pin_is_active(sc->cs_pins[idx], &tmp);
264 #endif
265 } else {
266 device_printf(sc->sc_dev,
267 "cannot configure gpio for chip select %u\n", idx);
268 sc->cs_pins[idx] = NULL;
269 }
270 }
271 }
272
273 static void
qcom_spi_sysctl_attach(struct qcom_spi_softc * sc)274 qcom_spi_sysctl_attach(struct qcom_spi_softc *sc)
275 {
276 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
277 struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
278
279 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
280 "debug", CTLFLAG_RW, &sc->sc_debug, 0,
281 "control debugging printfs");
282 }
283
284 static int
qcom_spi_attach(device_t dev)285 qcom_spi_attach(device_t dev)
286 {
287 struct qcom_spi_softc *sc = device_get_softc(dev);
288 int rid, ret, i, val;
289
290 sc->sc_dev = dev;
291
292 /*
293 * Hardware version is stored in the ofw_compat_data table.
294 */
295 sc->hw_version =
296 ofw_bus_search_compatible(dev, compat_data)->ocd_data;
297
298 mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
299
300 rid = 0;
301 sc->sc_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
302 RF_ACTIVE);
303 if (!sc->sc_mem_res) {
304 device_printf(dev, "ERROR: Could not map memory\n");
305 ret = ENXIO;
306 goto error;
307 }
308
309 rid = 0;
310 sc->sc_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
311 RF_ACTIVE | RF_SHAREABLE);
312 if (!sc->sc_irq_res) {
313 device_printf(dev, "ERROR: Could not map interrupt\n");
314 ret = ENXIO;
315 goto error;
316 }
317
318 ret = bus_setup_intr(dev, sc->sc_irq_res,
319 INTR_TYPE_MISC | INTR_MPSAFE,
320 NULL, qcom_spi_intr, sc, &sc->sc_irq_h);
321 if (ret != 0) {
322 device_printf(dev, "ERROR: could not configure interrupt "
323 "(%d)\n",
324 ret);
325 goto error;
326 }
327
328 qcom_spi_attach_gpios(sc);
329
330 ret = clk_get_by_ofw_name(dev, 0, "core", &sc->clk_core);
331 if (ret != 0) {
332 device_printf(dev, "ERROR: could not get %s clock (%d)\n",
333 "core", ret);
334 goto error;
335 }
336 ret = clk_get_by_ofw_name(dev, 0, "iface", &sc->clk_iface);
337 if (ret != 0) {
338 device_printf(dev, "ERROR: could not get %s clock (%d)\n",
339 "iface", ret);
340 goto error;
341 }
342
343 /* Bring up initial clocks if they're off */
344 ret = clk_enable(sc->clk_core);
345 if (ret != 0) {
346 device_printf(dev, "ERROR: couldn't enable core clock (%u)\n",
347 ret);
348 goto error;
349 }
350 ret = clk_enable(sc->clk_iface);
351 if (ret != 0) {
352 device_printf(dev, "ERROR: couldn't enable iface clock (%u)\n",
353 ret);
354 goto error;
355 }
356
357 /*
358 * Read optional spi-max-frequency
359 */
360 if (OF_getencprop(ofw_bus_get_node(dev), "spi-max-frequency",
361 &val, sizeof(val)) > 0)
362 sc->config.max_frequency = val;
363 else
364 sc->config.max_frequency = SPI_MAX_RATE;
365
366 /*
367 * Read optional cs-select
368 */
369 if (OF_getencprop(ofw_bus_get_node(dev), "cs-select",
370 &val, sizeof(val)) > 0)
371 sc->config.cs_select = val;
372 else
373 sc->config.cs_select = 0;
374
375 /*
376 * Read optional num-cs
377 */
378 if (OF_getencprop(ofw_bus_get_node(dev), "num-cs",
379 &val, sizeof(val)) > 0)
380 sc->config.num_cs = val;
381 else
382 sc->config.num_cs = SPI_NUM_CHIPSELECTS;
383
384 ret = fdt_pinctrl_configure_by_name(dev, "default");
385 if (ret != 0) {
386 device_printf(dev,
387 "ERROR: could not configure default pinmux\n");
388 goto error;
389 }
390
391 ret = qcom_spi_hw_read_controller_transfer_sizes(sc);
392 if (ret != 0) {
393 device_printf(dev, "ERROR: Could not read transfer config\n");
394 goto error;
395 }
396
397
398 device_printf(dev, "BLOCK: input=%u bytes, output=%u bytes\n",
399 sc->config.input_block_size,
400 sc->config.output_block_size);
401 device_printf(dev, "FIFO: input=%u bytes, output=%u bytes\n",
402 sc->config.input_fifo_size,
403 sc->config.output_fifo_size);
404
405 /* QUP config */
406 QCOM_SPI_LOCK(sc);
407 ret = qcom_spi_hw_qup_init_locked(sc);
408 if (ret != 0) {
409 device_printf(dev, "ERROR: QUP init failed (%d)\n", ret);
410 QCOM_SPI_UNLOCK(sc);
411 goto error;
412 }
413
414 /* Initial SPI config */
415 ret = qcom_spi_hw_spi_init_locked(sc);
416 if (ret != 0) {
417 device_printf(dev, "ERROR: SPI init failed (%d)\n", ret);
418 QCOM_SPI_UNLOCK(sc);
419 goto error;
420 }
421 QCOM_SPI_UNLOCK(sc);
422
423 sc->spibus = device_add_child(dev, "spibus", -1);
424
425 /* We're done, so shut down the interface clock for now */
426 device_printf(dev, "DONE: shutting down interface clock for now\n");
427 clk_disable(sc->clk_iface);
428
429 /* Register for debug sysctl */
430 qcom_spi_sysctl_attach(sc);
431
432 return (bus_generic_attach(dev));
433 error:
434 if (sc->sc_irq_h)
435 bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_irq_h);
436 if (sc->sc_mem_res)
437 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res);
438 if (sc->sc_irq_res)
439 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq_res);
440 if (sc->clk_core) {
441 clk_disable(sc->clk_core);
442 clk_release(sc->clk_core);
443 }
444 if (sc->clk_iface) {
445 clk_disable(sc->clk_iface);
446 clk_release(sc->clk_iface);
447 }
448 for (i = 0; i < CS_MAX; i++) {
449 if (sc->cs_pins[i] != NULL)
450 gpio_pin_release(sc->cs_pins[i]);
451 }
452 mtx_destroy(&sc->sc_mtx);
453 return (ret);
454 }
455
456 /*
457 * Do a PIO transfer.
458 *
459 * Note that right now the TX/RX lens need to match, I'm not doing
460 * dummy reads / dummy writes as required if they're not the same
461 * size. The QUP hardware supports doing multi-phase transactions
462 * where the FIFO isn't engaged for transmit or receive, but it's
463 * not yet being done here.
464 */
465 static int
qcom_spi_transfer_pio_block(struct qcom_spi_softc * sc,int mode,char * tx_buf,int tx_len,char * rx_buf,int rx_len)466 qcom_spi_transfer_pio_block(struct qcom_spi_softc *sc, int mode,
467 char *tx_buf, int tx_len, char *rx_buf, int rx_len)
468 {
469 int ret = 0;
470
471 QCOM_SPI_DPRINTF(sc, QCOM_SPI_DEBUG_TRANSFER, "%s: start\n",
472 __func__);
473
474 if (rx_len != tx_len) {
475 device_printf(sc->sc_dev,
476 "ERROR: tx/rx len doesn't match (%d/%d)\n",
477 tx_len, rx_len);
478 return (ENXIO);
479 }
480
481 QCOM_SPI_ASSERT_LOCKED(sc);
482
483 /*
484 * Make initial choices for transfer configuration.
485 */
486 ret = qcom_spi_hw_setup_transfer_selection(sc, tx_len);
487 if (ret != 0) {
488 device_printf(sc->sc_dev,
489 "ERROR: failed to setup transfer selection (%d)\n",
490 ret);
491 return (ret);
492 }
493
494 /* Now set suitable buffer/lengths */
495 sc->transfer.tx_buf = tx_buf;
496 sc->transfer.tx_len = tx_len;
497 sc->transfer.rx_buf = rx_buf;
498 sc->transfer.rx_len = rx_len;
499 sc->transfer.done = false;
500 sc->transfer.active = false;
501
502 /*
503 * Loop until the full transfer set is done.
504 *
505 * qcom_spi_hw_setup_current_transfer() will take care of
506 * setting a maximum transfer size for the hardware and choose
507 * a suitable operating mode.
508 */
509 while (sc->transfer.tx_offset < sc->transfer.tx_len) {
510 /*
511 * Set transfer to false early; this covers
512 * it also finishing a sub-transfer and we're
513 * about the put the block into RESET state before
514 * starting a new transfer.
515 */
516 sc->transfer.active = false;
517
518 QCOM_SPI_DPRINTF(sc, QCOM_SPI_DEBUG_TRANSFER,
519 "%s: tx=%d of %d bytes, rx=%d of %d bytes\n",
520 __func__,
521 sc->transfer.tx_offset, sc->transfer.tx_len,
522 sc->transfer.rx_offset, sc->transfer.rx_len);
523
524 /*
525 * Set state to RESET before doing anything.
526 *
527 * Otherwise the second sub-transfer that we queue up
528 * will generate interrupts immediately when we start
529 * configuring it here and it'll start underflowing.
530 */
531 ret = qcom_spi_hw_qup_set_state_locked(sc, QUP_STATE_RESET);
532 if (ret != 0) {
533 device_printf(sc->sc_dev,
534 "ERROR: can't transition to RESET (%u)\n", ret);
535 goto done;
536 }
537 /* blank interrupt state; we'll do a RESET below */
538 bzero(&sc->intr, sizeof(sc->intr));
539 sc->transfer.done = false;
540
541 /*
542 * Configure what the transfer configuration for this
543 * sub-transfer will be.
544 */
545 ret = qcom_spi_hw_setup_current_transfer(sc);
546 if (ret != 0) {
547 device_printf(sc->sc_dev,
548 "ERROR: failed to setup sub transfer (%d)\n",
549 ret);
550 goto done;
551 }
552
553 /*
554 * For now since we're configuring up PIO, we only setup
555 * the PIO transfer size.
556 */
557 ret = qcom_spi_hw_setup_pio_transfer_cnt(sc);
558 if (ret != 0) {
559 device_printf(sc->sc_dev,
560 "ERROR: qcom_spi_hw_setup_pio_transfer_cnt failed"
561 " (%u)\n", ret);
562 goto done;
563 }
564
565 #if 0
566 /*
567 * This is what we'd do to setup the block transfer sizes.
568 */
569 ret = qcom_spi_hw_setup_block_transfer_cnt(sc);
570 if (ret != 0) {
571 device_printf(sc->sc_dev,
572 "ERROR: qcom_spi_hw_setup_block_transfer_cnt failed"
573 " (%u)\n", ret);
574 goto done;
575 }
576 #endif
577
578 ret = qcom_spi_hw_setup_io_modes(sc);
579 if (ret != 0) {
580 device_printf(sc->sc_dev,
581 "ERROR: qcom_spi_hw_setup_io_modes failed"
582 " (%u)\n", ret);
583 goto done;
584 }
585
586 ret = qcom_spi_hw_setup_spi_io_clock_polarity(sc,
587 !! (mode & SPIBUS_MODE_CPOL));
588 if (ret != 0) {
589 device_printf(sc->sc_dev,
590 "ERROR: qcom_spi_hw_setup_spi_io_clock_polarity"
591 " failed (%u)\n", ret);
592 goto done;
593 }
594
595 ret = qcom_spi_hw_setup_spi_config(sc, sc->state.frequency,
596 !! (mode & SPIBUS_MODE_CPHA));
597 if (ret != 0) {
598 device_printf(sc->sc_dev,
599 "ERROR: qcom_spi_hw_setup_spi_config failed"
600 " (%u)\n", ret);
601 goto done;
602 }
603
604 ret = qcom_spi_hw_setup_qup_config(sc, !! (tx_len > 0),
605 !! (rx_len > 0));
606 if (ret != 0) {
607 device_printf(sc->sc_dev,
608 "ERROR: qcom_spi_hw_setup_qup_config failed"
609 " (%u)\n", ret);
610 goto done;
611 }
612
613 ret = qcom_spi_hw_setup_operational_mask(sc);
614 if (ret != 0) {
615 device_printf(sc->sc_dev,
616 "ERROR: qcom_spi_hw_setup_operational_mask failed"
617 " (%u)\n", ret);
618 goto done;
619 }
620
621 /*
622 * Setup is done; reset the controller and start the PIO
623 * write.
624 */
625
626 /*
627 * Set state to RUN; we may start getting interrupts that
628 * are valid and we need to handle.
629 */
630 sc->transfer.active = true;
631 ret = qcom_spi_hw_qup_set_state_locked(sc, QUP_STATE_RUN);
632 if (ret != 0) {
633 device_printf(sc->sc_dev,
634 "ERROR: can't transition to RUN (%u)\n", ret);
635 goto done;
636 }
637
638 /*
639 * Set state to PAUSE
640 */
641 ret = qcom_spi_hw_qup_set_state_locked(sc, QUP_STATE_PAUSE);
642 if (ret != 0) {
643 device_printf(sc->sc_dev,
644 "ERROR: can't transition to PAUSE (%u)\n", ret);
645 goto done;
646 }
647
648 /*
649 * If FIFO mode, write data now. Else, we'll get an
650 * interrupt when it's time to populate more data
651 * in BLOCK mode.
652 */
653 if (sc->state.transfer_mode == QUP_IO_M_MODE_FIFO)
654 ret = qcom_spi_hw_write_pio_fifo(sc);
655 else
656 ret = qcom_spi_hw_write_pio_block(sc);
657 if (ret != 0) {
658 device_printf(sc->sc_dev,
659 "ERROR: qcom_spi_hw_write failed (%u)\n", ret);
660 goto done;
661 }
662
663 /*
664 * Set state to RUN
665 */
666 ret = qcom_spi_hw_qup_set_state_locked(sc, QUP_STATE_RUN);
667 if (ret != 0) {
668 device_printf(sc->sc_dev,
669 "ERROR: can't transition to RUN (%u)\n", ret);
670 goto done;
671 }
672
673 /*
674 * Wait for an interrupt notification (which will
675 * continue to drive the state machine for this
676 * sub-transfer) or timeout.
677 */
678 ret = 0;
679 while (ret == 0 && sc->transfer.done == false) {
680 QCOM_SPI_DPRINTF(sc, QCOM_SPI_DEBUG_TRANSFER,
681 "%s: waiting\n", __func__);
682 ret = msleep(sc, &sc->sc_mtx, 0, "qcom_spi", 0);
683 }
684 }
685 done:
686 /*
687 * Complete; put controller into reset.
688 *
689 * Don't worry about return value here; if we errored out above then
690 * we want to communicate that value to the caller.
691 */
692 (void) qcom_spi_hw_qup_set_state_locked(sc, QUP_STATE_RESET);
693 QCOM_SPI_DPRINTF(sc, QCOM_SPI_DEBUG_TRANSFER,
694 "%s: completed\n", __func__);
695
696 /*
697 * Blank the transfer state so we don't use an old transfer
698 * state in a subsequent interrupt.
699 */
700 (void) qcom_spi_hw_complete_transfer(sc);
701 sc->transfer.active = false;
702
703 return (ret);
704 }
705
706 static int
qcom_spi_transfer(device_t dev,device_t child,struct spi_command * cmd)707 qcom_spi_transfer(device_t dev, device_t child, struct spi_command *cmd)
708 {
709 struct qcom_spi_softc *sc = device_get_softc(dev);
710 uint32_t cs_val, mode_val, clock_val;
711 uint32_t ret = 0;
712
713 spibus_get_cs(child, &cs_val);
714 spibus_get_clock(child, &clock_val);
715 spibus_get_mode(child, &mode_val);
716
717 QCOM_SPI_DPRINTF(sc, QCOM_SPI_DEBUG_TRANSFER,
718 "%s: called; child cs=0x%08x, clock=%u, mode=0x%08x, "
719 "cmd=%u/%u bytes; data=%u/%u bytes\n",
720 __func__,
721 cs_val,
722 clock_val,
723 mode_val,
724 cmd->tx_cmd_sz, cmd->rx_cmd_sz,
725 cmd->tx_data_sz, cmd->rx_data_sz);
726
727 QCOM_SPI_LOCK(sc);
728
729 /*
730 * wait until the controller isn't busy
731 */
732 while (sc->sc_busy == true)
733 mtx_sleep(sc, &sc->sc_mtx, 0, "qcom_spi_wait", 0);
734
735 /*
736 * it's ours now!
737 */
738 sc->sc_busy = true;
739
740 sc->state.cs_high = !! (cs_val & SPIBUS_CS_HIGH);
741 sc->state.frequency = clock_val;
742
743 /*
744 * We can't set the clock frequency and enable it
745 * with the driver lock held, as the SPI lock is non-sleepable
746 * and the clock framework is sleepable.
747 *
748 * No other transaction is going on right now, so we can
749 * unlock here and do the clock related work.
750 */
751 QCOM_SPI_UNLOCK(sc);
752
753 /*
754 * Set the clock frequency
755 */
756 ret = clk_set_freq(sc->clk_iface, sc->state.frequency, 0);
757 if (ret != 0) {
758 device_printf(sc->sc_dev,
759 "ERROR: failed to set frequency to %u\n",
760 sc->state.frequency);
761 goto done2;
762 }
763 clk_enable(sc->clk_iface);
764
765 QCOM_SPI_LOCK(sc);
766
767 /*
768 * Set state to RESET
769 */
770 ret = qcom_spi_hw_qup_set_state_locked(sc, QUP_STATE_RESET);
771 if (ret != 0) {
772 device_printf(sc->sc_dev,
773 "ERROR: can't transition to RESET (%u)\n", ret);
774 goto done;
775 }
776
777 /* Assert hardware CS if set, else GPIO */
778 if (sc->cs_pins[cs_val & ~SPIBUS_CS_HIGH] == NULL)
779 qcom_spi_hw_spi_cs_force(sc, cs_val & SPIBUS_CS_HIGH, true);
780 else
781 qcom_spi_set_chipsel(sc, cs_val & ~SPIBUS_CS_HIGH, true);
782
783 /*
784 * cmd buffer transfer
785 */
786 ret = qcom_spi_transfer_pio_block(sc, mode_val, cmd->tx_cmd,
787 cmd->tx_cmd_sz, cmd->rx_cmd, cmd->rx_cmd_sz);
788 if (ret != 0) {
789 device_printf(sc->sc_dev,
790 "ERROR: failed to transfer cmd payload (%u)\n", ret);
791 goto done;
792 }
793
794 /*
795 * data buffer transfer
796 */
797 if (cmd->tx_data_sz > 0) {
798 ret = qcom_spi_transfer_pio_block(sc, mode_val, cmd->tx_data,
799 cmd->tx_data_sz, cmd->rx_data, cmd->rx_data_sz);
800 if (ret != 0) {
801 device_printf(sc->sc_dev,
802 "ERROR: failed to transfer data payload (%u)\n",
803 ret);
804 goto done;
805 }
806 }
807
808 done:
809 /* De-assert GPIO/CS */
810 if (sc->cs_pins[cs_val & ~SPIBUS_CS_HIGH] == NULL)
811 qcom_spi_hw_spi_cs_force(sc, cs_val & ~SPIBUS_CS_HIGH, false);
812 else
813 qcom_spi_set_chipsel(sc, cs_val & ~SPIBUS_CS_HIGH, false);
814
815 /*
816 * Similarly to when we enabled the clock, we can't hold it here
817 * across a clk API as that's a sleep lock and we're non-sleepable.
818 * So instead we unlock/relock here, but we still hold the busy flag.
819 */
820
821 QCOM_SPI_UNLOCK(sc);
822 clk_disable(sc->clk_iface);
823 QCOM_SPI_LOCK(sc);
824 done2:
825 /*
826 * We're done; so mark the bus as not busy and wakeup
827 * the next caller.
828 */
829 sc->sc_busy = false;
830 wakeup_one(sc);
831 QCOM_SPI_UNLOCK(sc);
832 return (ret);
833 }
834
835 static int
qcom_spi_detach(device_t dev)836 qcom_spi_detach(device_t dev)
837 {
838 struct qcom_spi_softc *sc = device_get_softc(dev);
839 int i;
840
841 bus_generic_detach(sc->sc_dev);
842 if (sc->spibus != NULL)
843 device_delete_child(dev, sc->spibus);
844
845 if (sc->sc_irq_h)
846 bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_irq_h);
847
848 if (sc->clk_iface) {
849 clk_disable(sc->clk_iface);
850 clk_release(sc->clk_iface);
851 }
852 if (sc->clk_core) {
853 clk_disable(sc->clk_core);
854 clk_release(sc->clk_core);
855 }
856
857 for (i = 0; i < CS_MAX; i++) {
858 if (sc->cs_pins[i] != NULL)
859 gpio_pin_release(sc->cs_pins[i]);
860 }
861
862 if (sc->sc_mem_res)
863 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res);
864 if (sc->sc_irq_res)
865 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq_res);
866
867 mtx_destroy(&sc->sc_mtx);
868
869 return (0);
870 }
871
872 static phandle_t
qcom_spi_get_node(device_t bus,device_t dev)873 qcom_spi_get_node(device_t bus, device_t dev)
874 {
875
876 return ofw_bus_get_node(bus);
877 }
878
879
880 static device_method_t qcom_spi_methods[] = {
881 /* Device interface */
882 DEVMETHOD(device_probe, qcom_spi_probe),
883 DEVMETHOD(device_attach, qcom_spi_attach),
884 DEVMETHOD(device_detach, qcom_spi_detach),
885 /* TODO: suspend */
886 /* TODO: resume */
887
888 DEVMETHOD(spibus_transfer, qcom_spi_transfer),
889
890 /* ofw_bus_if */
891 DEVMETHOD(ofw_bus_get_node, qcom_spi_get_node),
892
893 DEVMETHOD_END
894 };
895
896 static driver_t qcom_spi_driver = {
897 "qcom_spi",
898 qcom_spi_methods,
899 sizeof(struct qcom_spi_softc),
900 };
901
902 DRIVER_MODULE(qcom_spi, simplebus, qcom_spi_driver, 0, 0);
903 DRIVER_MODULE(ofw_spibus, qcom_spi, ofw_spibus_driver, 0, 0);
904 MODULE_DEPEND(qcom_spi, ofw_spibus, 1, 1, 1);
905 SIMPLEBUS_PNP_INFO(compat_data);
906