1b445bfcbSMarco Felsch // SPDX-License-Identifier: GPL-2.0-or-later 2787f4889SMark Brown // SPI init/core code 3787f4889SMark Brown // 4787f4889SMark Brown // Copyright (C) 2005 David Brownell 5787f4889SMark Brown // Copyright (C) 2008 Secret Lab Technologies Ltd. 68ae12a0dSDavid Brownell 7edf6a864SAndy Shevchenko #include <linux/acpi.h> 88ae12a0dSDavid Brownell #include <linux/cache.h> 9edf6a864SAndy Shevchenko #include <linux/clk/clk-conf.h> 10edf6a864SAndy Shevchenko #include <linux/delay.h> 11edf6a864SAndy Shevchenko #include <linux/device.h> 1299adef31SMark Brown #include <linux/dmaengine.h> 13edf6a864SAndy Shevchenko #include <linux/dma-mapping.h> 14edf6a864SAndy Shevchenko #include <linux/export.h> 15edf6a864SAndy Shevchenko #include <linux/gpio/consumer.h> 16edf6a864SAndy Shevchenko #include <linux/highmem.h> 17edf6a864SAndy Shevchenko #include <linux/idr.h> 18edf6a864SAndy Shevchenko #include <linux/init.h> 19edf6a864SAndy Shevchenko #include <linux/ioport.h> 20edf6a864SAndy Shevchenko #include <linux/kernel.h> 21edf6a864SAndy Shevchenko #include <linux/kthread.h> 22edf6a864SAndy Shevchenko #include <linux/mod_devicetable.h> 2394040828SMatthias Kaehlcke #include <linux/mutex.h> 242b7a32f7SSinan Akman #include <linux/of_device.h> 25d57a4282SGrant Likely #include <linux/of_irq.h> 26edf6a864SAndy Shevchenko #include <linux/percpu.h> 27edf6a864SAndy Shevchenko #include <linux/platform_data/x86/apple.h> 28edf6a864SAndy Shevchenko #include <linux/pm_domain.h> 29edf6a864SAndy Shevchenko #include <linux/pm_runtime.h> 30edf6a864SAndy Shevchenko #include <linux/property.h> 31edf6a864SAndy Shevchenko #include <linux/ptp_clock_kernel.h> 32edf6a864SAndy Shevchenko #include <linux/sched/rt.h> 335a0e3ad6STejun Heo #include <linux/slab.h> 348ae12a0dSDavid Brownell #include <linux/spi/spi.h> 35b5932f5cSBoris Brezillon #include <linux/spi/spi-mem.h> 36ae7e81c0SIngo Molnar #include <uapi/linux/sched/types.h> 378ae12a0dSDavid Brownell 3856ec1978SMark Brown #define CREATE_TRACE_POINTS 3956ec1978SMark Brown #include <trace/events/spi.h> 40ca1438dcSArnd Bergmann EXPORT_TRACEPOINT_SYMBOL(spi_transfer_start); 41ca1438dcSArnd Bergmann EXPORT_TRACEPOINT_SYMBOL(spi_transfer_stop); 429b61e302SSuniel Mahesh 4346336966SBoris Brezillon #include "internals.h" 4446336966SBoris Brezillon 459b61e302SSuniel Mahesh static DEFINE_IDR(spi_master_idr); 4656ec1978SMark Brown 478ae12a0dSDavid Brownell static void spidev_release(struct device *dev) 488ae12a0dSDavid Brownell { 490ffa0285SHans-Peter Nilsson struct spi_device *spi = to_spi_device(dev); 508ae12a0dSDavid Brownell 518caab75fSGeert Uytterhoeven spi_controller_put(spi->controller); 525039563eSTrent Piepho kfree(spi->driver_override); 536598b91bSDavid Jander free_percpu(spi->pcpu_statistics); 5407a389feSRoman Tereshonkov kfree(spi); 558ae12a0dSDavid Brownell } 568ae12a0dSDavid Brownell 578ae12a0dSDavid Brownell static ssize_t 588ae12a0dSDavid Brownell modalias_show(struct device *dev, struct device_attribute *a, char *buf) 598ae12a0dSDavid Brownell { 608ae12a0dSDavid Brownell const struct spi_device *spi = to_spi_device(dev); 618c4ff6d0SZhang Rui int len; 628c4ff6d0SZhang Rui 638c4ff6d0SZhang Rui len = acpi_device_modalias(dev, buf, PAGE_SIZE - 1); 648c4ff6d0SZhang Rui if (len != -ENODEV) 658c4ff6d0SZhang Rui return len; 668ae12a0dSDavid Brownell 67f2daa466SAndy Shevchenko return sysfs_emit(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias); 688ae12a0dSDavid Brownell } 69aa7da564SGreg Kroah-Hartman static DEVICE_ATTR_RO(modalias); 708ae12a0dSDavid Brownell 715039563eSTrent Piepho static ssize_t driver_override_store(struct device *dev, 725039563eSTrent Piepho struct device_attribute *a, 735039563eSTrent Piepho const char *buf, size_t count) 745039563eSTrent Piepho { 755039563eSTrent Piepho struct spi_device *spi = to_spi_device(dev); 7619368f0fSKrzysztof Kozlowski int ret; 775039563eSTrent Piepho 7819368f0fSKrzysztof Kozlowski ret = driver_set_override(dev, &spi->driver_override, buf, count); 7919368f0fSKrzysztof Kozlowski if (ret) 8019368f0fSKrzysztof Kozlowski return ret; 815039563eSTrent Piepho 825039563eSTrent Piepho return count; 835039563eSTrent Piepho } 845039563eSTrent Piepho 855039563eSTrent Piepho static ssize_t driver_override_show(struct device *dev, 865039563eSTrent Piepho struct device_attribute *a, char *buf) 875039563eSTrent Piepho { 885039563eSTrent Piepho const struct spi_device *spi = to_spi_device(dev); 895039563eSTrent Piepho ssize_t len; 905039563eSTrent Piepho 915039563eSTrent Piepho device_lock(dev); 92f2daa466SAndy Shevchenko len = sysfs_emit(buf, "%s\n", spi->driver_override ? : ""); 935039563eSTrent Piepho device_unlock(dev); 945039563eSTrent Piepho return len; 955039563eSTrent Piepho } 965039563eSTrent Piepho static DEVICE_ATTR_RW(driver_override); 975039563eSTrent Piepho 98d501cc4cSDavid Jander static struct spi_statistics __percpu *spi_alloc_pcpu_stats(struct device *dev) 996598b91bSDavid Jander { 1006598b91bSDavid Jander struct spi_statistics __percpu *pcpu_stats; 1016598b91bSDavid Jander 1026598b91bSDavid Jander if (dev) 1036598b91bSDavid Jander pcpu_stats = devm_alloc_percpu(dev, struct spi_statistics); 1046598b91bSDavid Jander else 1056598b91bSDavid Jander pcpu_stats = alloc_percpu_gfp(struct spi_statistics, GFP_KERNEL); 1066598b91bSDavid Jander 1076598b91bSDavid Jander if (pcpu_stats) { 1086598b91bSDavid Jander int cpu; 1096598b91bSDavid Jander 1106598b91bSDavid Jander for_each_possible_cpu(cpu) { 1116598b91bSDavid Jander struct spi_statistics *stat; 1126598b91bSDavid Jander 1136598b91bSDavid Jander stat = per_cpu_ptr(pcpu_stats, cpu); 1146598b91bSDavid Jander u64_stats_init(&stat->syncp); 1156598b91bSDavid Jander } 1166598b91bSDavid Jander } 1176598b91bSDavid Jander return pcpu_stats; 1186598b91bSDavid Jander } 1196598b91bSDavid Jander 120fc12d4bbSGeert Uytterhoeven static ssize_t spi_emit_pcpu_stats(struct spi_statistics __percpu *stat, 121fc12d4bbSGeert Uytterhoeven char *buf, size_t offset) 122fc12d4bbSGeert Uytterhoeven { 123fc12d4bbSGeert Uytterhoeven u64 val = 0; 124fc12d4bbSGeert Uytterhoeven int i; 125fc12d4bbSGeert Uytterhoeven 126fc12d4bbSGeert Uytterhoeven for_each_possible_cpu(i) { 127fc12d4bbSGeert Uytterhoeven const struct spi_statistics *pcpu_stats; 128fc12d4bbSGeert Uytterhoeven u64_stats_t *field; 129fc12d4bbSGeert Uytterhoeven unsigned int start; 130fc12d4bbSGeert Uytterhoeven u64 inc; 131fc12d4bbSGeert Uytterhoeven 132fc12d4bbSGeert Uytterhoeven pcpu_stats = per_cpu_ptr(stat, i); 133fc12d4bbSGeert Uytterhoeven field = (void *)pcpu_stats + offset; 134fc12d4bbSGeert Uytterhoeven do { 135fc12d4bbSGeert Uytterhoeven start = u64_stats_fetch_begin(&pcpu_stats->syncp); 136fc12d4bbSGeert Uytterhoeven inc = u64_stats_read(field); 137fc12d4bbSGeert Uytterhoeven } while (u64_stats_fetch_retry(&pcpu_stats->syncp, start)); 138fc12d4bbSGeert Uytterhoeven val += inc; 139fc12d4bbSGeert Uytterhoeven } 140fc12d4bbSGeert Uytterhoeven return sysfs_emit(buf, "%llu\n", val); 141fc12d4bbSGeert Uytterhoeven } 1426598b91bSDavid Jander 143eca2ebc7SMartin Sperl #define SPI_STATISTICS_ATTRS(field, file) \ 1448caab75fSGeert Uytterhoeven static ssize_t spi_controller_##field##_show(struct device *dev, \ 145eca2ebc7SMartin Sperl struct device_attribute *attr, \ 146eca2ebc7SMartin Sperl char *buf) \ 147eca2ebc7SMartin Sperl { \ 1488caab75fSGeert Uytterhoeven struct spi_controller *ctlr = container_of(dev, \ 1498caab75fSGeert Uytterhoeven struct spi_controller, dev); \ 1506598b91bSDavid Jander return spi_statistics_##field##_show(ctlr->pcpu_statistics, buf); \ 151eca2ebc7SMartin Sperl } \ 1528caab75fSGeert Uytterhoeven static struct device_attribute dev_attr_spi_controller_##field = { \ 153ad25c92eSGeert Uytterhoeven .attr = { .name = file, .mode = 0444 }, \ 1548caab75fSGeert Uytterhoeven .show = spi_controller_##field##_show, \ 155eca2ebc7SMartin Sperl }; \ 156eca2ebc7SMartin Sperl static ssize_t spi_device_##field##_show(struct device *dev, \ 157eca2ebc7SMartin Sperl struct device_attribute *attr, \ 158eca2ebc7SMartin Sperl char *buf) \ 159eca2ebc7SMartin Sperl { \ 160d1eba93bSGeliang Tang struct spi_device *spi = to_spi_device(dev); \ 1616598b91bSDavid Jander return spi_statistics_##field##_show(spi->pcpu_statistics, buf); \ 162eca2ebc7SMartin Sperl } \ 163eca2ebc7SMartin Sperl static struct device_attribute dev_attr_spi_device_##field = { \ 164ad25c92eSGeert Uytterhoeven .attr = { .name = file, .mode = 0444 }, \ 165eca2ebc7SMartin Sperl .show = spi_device_##field##_show, \ 166eca2ebc7SMartin Sperl } 167eca2ebc7SMartin Sperl 1686598b91bSDavid Jander #define SPI_STATISTICS_SHOW_NAME(name, file, field) \ 169d501cc4cSDavid Jander static ssize_t spi_statistics_##name##_show(struct spi_statistics __percpu *stat, \ 170eca2ebc7SMartin Sperl char *buf) \ 171eca2ebc7SMartin Sperl { \ 172fc12d4bbSGeert Uytterhoeven return spi_emit_pcpu_stats(stat, buf, \ 173fc12d4bbSGeert Uytterhoeven offsetof(struct spi_statistics, field)); \ 174eca2ebc7SMartin Sperl } \ 175eca2ebc7SMartin Sperl SPI_STATISTICS_ATTRS(name, file) 176eca2ebc7SMartin Sperl 1776598b91bSDavid Jander #define SPI_STATISTICS_SHOW(field) \ 178eca2ebc7SMartin Sperl SPI_STATISTICS_SHOW_NAME(field, __stringify(field), \ 1796598b91bSDavid Jander field) 180eca2ebc7SMartin Sperl 1816598b91bSDavid Jander SPI_STATISTICS_SHOW(messages); 1826598b91bSDavid Jander SPI_STATISTICS_SHOW(transfers); 1836598b91bSDavid Jander SPI_STATISTICS_SHOW(errors); 1846598b91bSDavid Jander SPI_STATISTICS_SHOW(timedout); 185eca2ebc7SMartin Sperl 1866598b91bSDavid Jander SPI_STATISTICS_SHOW(spi_sync); 1876598b91bSDavid Jander SPI_STATISTICS_SHOW(spi_sync_immediate); 1886598b91bSDavid Jander SPI_STATISTICS_SHOW(spi_async); 189eca2ebc7SMartin Sperl 1906598b91bSDavid Jander SPI_STATISTICS_SHOW(bytes); 1916598b91bSDavid Jander SPI_STATISTICS_SHOW(bytes_rx); 1926598b91bSDavid Jander SPI_STATISTICS_SHOW(bytes_tx); 193eca2ebc7SMartin Sperl 1946b7bc061SMartin Sperl #define SPI_STATISTICS_TRANSFER_BYTES_HISTO(index, number) \ 1956b7bc061SMartin Sperl SPI_STATISTICS_SHOW_NAME(transfer_bytes_histo##index, \ 1966b7bc061SMartin Sperl "transfer_bytes_histo_" number, \ 1976598b91bSDavid Jander transfer_bytes_histo[index]) 1986b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(0, "0-1"); 1996b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(1, "2-3"); 2006b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(2, "4-7"); 2016b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(3, "8-15"); 2026b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(4, "16-31"); 2036b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(5, "32-63"); 2046b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(6, "64-127"); 2056b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(7, "128-255"); 2066b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(8, "256-511"); 2076b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(9, "512-1023"); 2086b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(10, "1024-2047"); 2096b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(11, "2048-4095"); 2106b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(12, "4096-8191"); 2116b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(13, "8192-16383"); 2126b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(14, "16384-32767"); 2136b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(15, "32768-65535"); 2146b7bc061SMartin Sperl SPI_STATISTICS_TRANSFER_BYTES_HISTO(16, "65536+"); 2156b7bc061SMartin Sperl 2166598b91bSDavid Jander SPI_STATISTICS_SHOW(transfers_split_maxsize); 217d9f12122SMartin Sperl 218aa7da564SGreg Kroah-Hartman static struct attribute *spi_dev_attrs[] = { 219aa7da564SGreg Kroah-Hartman &dev_attr_modalias.attr, 2205039563eSTrent Piepho &dev_attr_driver_override.attr, 221aa7da564SGreg Kroah-Hartman NULL, 2228ae12a0dSDavid Brownell }; 223eca2ebc7SMartin Sperl 224eca2ebc7SMartin Sperl static const struct attribute_group spi_dev_group = { 225eca2ebc7SMartin Sperl .attrs = spi_dev_attrs, 226eca2ebc7SMartin Sperl }; 227eca2ebc7SMartin Sperl 228eca2ebc7SMartin Sperl static struct attribute *spi_device_statistics_attrs[] = { 229eca2ebc7SMartin Sperl &dev_attr_spi_device_messages.attr, 230eca2ebc7SMartin Sperl &dev_attr_spi_device_transfers.attr, 231eca2ebc7SMartin Sperl &dev_attr_spi_device_errors.attr, 232eca2ebc7SMartin Sperl &dev_attr_spi_device_timedout.attr, 233eca2ebc7SMartin Sperl &dev_attr_spi_device_spi_sync.attr, 234eca2ebc7SMartin Sperl &dev_attr_spi_device_spi_sync_immediate.attr, 235eca2ebc7SMartin Sperl &dev_attr_spi_device_spi_async.attr, 236eca2ebc7SMartin Sperl &dev_attr_spi_device_bytes.attr, 237eca2ebc7SMartin Sperl &dev_attr_spi_device_bytes_rx.attr, 238eca2ebc7SMartin Sperl &dev_attr_spi_device_bytes_tx.attr, 2396b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo0.attr, 2406b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo1.attr, 2416b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo2.attr, 2426b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo3.attr, 2436b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo4.attr, 2446b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo5.attr, 2456b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo6.attr, 2466b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo7.attr, 2476b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo8.attr, 2486b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo9.attr, 2496b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo10.attr, 2506b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo11.attr, 2516b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo12.attr, 2526b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo13.attr, 2536b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo14.attr, 2546b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo15.attr, 2556b7bc061SMartin Sperl &dev_attr_spi_device_transfer_bytes_histo16.attr, 256d9f12122SMartin Sperl &dev_attr_spi_device_transfers_split_maxsize.attr, 257eca2ebc7SMartin Sperl NULL, 258eca2ebc7SMartin Sperl }; 259eca2ebc7SMartin Sperl 260eca2ebc7SMartin Sperl static const struct attribute_group spi_device_statistics_group = { 261eca2ebc7SMartin Sperl .name = "statistics", 262eca2ebc7SMartin Sperl .attrs = spi_device_statistics_attrs, 263eca2ebc7SMartin Sperl }; 264eca2ebc7SMartin Sperl 265eca2ebc7SMartin Sperl static const struct attribute_group *spi_dev_groups[] = { 266eca2ebc7SMartin Sperl &spi_dev_group, 267eca2ebc7SMartin Sperl &spi_device_statistics_group, 268eca2ebc7SMartin Sperl NULL, 269eca2ebc7SMartin Sperl }; 270eca2ebc7SMartin Sperl 2718caab75fSGeert Uytterhoeven static struct attribute *spi_controller_statistics_attrs[] = { 2728caab75fSGeert Uytterhoeven &dev_attr_spi_controller_messages.attr, 2738caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfers.attr, 2748caab75fSGeert Uytterhoeven &dev_attr_spi_controller_errors.attr, 2758caab75fSGeert Uytterhoeven &dev_attr_spi_controller_timedout.attr, 2768caab75fSGeert Uytterhoeven &dev_attr_spi_controller_spi_sync.attr, 2778caab75fSGeert Uytterhoeven &dev_attr_spi_controller_spi_sync_immediate.attr, 2788caab75fSGeert Uytterhoeven &dev_attr_spi_controller_spi_async.attr, 2798caab75fSGeert Uytterhoeven &dev_attr_spi_controller_bytes.attr, 2808caab75fSGeert Uytterhoeven &dev_attr_spi_controller_bytes_rx.attr, 2818caab75fSGeert Uytterhoeven &dev_attr_spi_controller_bytes_tx.attr, 2828caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo0.attr, 2838caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo1.attr, 2848caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo2.attr, 2858caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo3.attr, 2868caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo4.attr, 2878caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo5.attr, 2888caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo6.attr, 2898caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo7.attr, 2908caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo8.attr, 2918caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo9.attr, 2928caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo10.attr, 2938caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo11.attr, 2948caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo12.attr, 2958caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo13.attr, 2968caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo14.attr, 2978caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo15.attr, 2988caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfer_bytes_histo16.attr, 2998caab75fSGeert Uytterhoeven &dev_attr_spi_controller_transfers_split_maxsize.attr, 300eca2ebc7SMartin Sperl NULL, 301eca2ebc7SMartin Sperl }; 302eca2ebc7SMartin Sperl 3038caab75fSGeert Uytterhoeven static const struct attribute_group spi_controller_statistics_group = { 304eca2ebc7SMartin Sperl .name = "statistics", 3058caab75fSGeert Uytterhoeven .attrs = spi_controller_statistics_attrs, 306eca2ebc7SMartin Sperl }; 307eca2ebc7SMartin Sperl 308eca2ebc7SMartin Sperl static const struct attribute_group *spi_master_groups[] = { 3098caab75fSGeert Uytterhoeven &spi_controller_statistics_group, 310eca2ebc7SMartin Sperl NULL, 311eca2ebc7SMartin Sperl }; 312eca2ebc7SMartin Sperl 313d501cc4cSDavid Jander static void spi_statistics_add_transfer_stats(struct spi_statistics __percpu *pcpu_stats, 314eca2ebc7SMartin Sperl struct spi_transfer *xfer, 3158caab75fSGeert Uytterhoeven struct spi_controller *ctlr) 316eca2ebc7SMartin Sperl { 3176b7bc061SMartin Sperl int l2len = min(fls(xfer->len), SPI_STATISTICS_HISTO_SIZE) - 1; 31867b9d641SDavid Jander struct spi_statistics *stats; 3196b7bc061SMartin Sperl 3206b7bc061SMartin Sperl if (l2len < 0) 3216b7bc061SMartin Sperl l2len = 0; 322eca2ebc7SMartin Sperl 32367b9d641SDavid Jander get_cpu(); 32467b9d641SDavid Jander stats = this_cpu_ptr(pcpu_stats); 3256598b91bSDavid Jander u64_stats_update_begin(&stats->syncp); 326eca2ebc7SMartin Sperl 3276598b91bSDavid Jander u64_stats_inc(&stats->transfers); 3286598b91bSDavid Jander u64_stats_inc(&stats->transfer_bytes_histo[l2len]); 329eca2ebc7SMartin Sperl 3306598b91bSDavid Jander u64_stats_add(&stats->bytes, xfer->len); 331eca2ebc7SMartin Sperl if ((xfer->tx_buf) && 3328caab75fSGeert Uytterhoeven (xfer->tx_buf != ctlr->dummy_tx)) 3336598b91bSDavid Jander u64_stats_add(&stats->bytes_tx, xfer->len); 334eca2ebc7SMartin Sperl if ((xfer->rx_buf) && 3358caab75fSGeert Uytterhoeven (xfer->rx_buf != ctlr->dummy_rx)) 3366598b91bSDavid Jander u64_stats_add(&stats->bytes_rx, xfer->len); 337eca2ebc7SMartin Sperl 3386598b91bSDavid Jander u64_stats_update_end(&stats->syncp); 33967b9d641SDavid Jander put_cpu(); 340eca2ebc7SMartin Sperl } 3418ae12a0dSDavid Brownell 342350de7ceSAndy Shevchenko /* 343350de7ceSAndy Shevchenko * modalias support makes "modprobe $MODALIAS" new-style hotplug work, 3448ae12a0dSDavid Brownell * and the sysfs version makes coldplug work too. 3458ae12a0dSDavid Brownell */ 3463f076575SAndy Shevchenko static const struct spi_device_id *spi_match_id(const struct spi_device_id *id, const char *name) 34775368bf6SAnton Vorontsov { 34875368bf6SAnton Vorontsov while (id->name[0]) { 3493f076575SAndy Shevchenko if (!strcmp(name, id->name)) 35075368bf6SAnton Vorontsov return id; 35175368bf6SAnton Vorontsov id++; 35275368bf6SAnton Vorontsov } 35375368bf6SAnton Vorontsov return NULL; 35475368bf6SAnton Vorontsov } 35575368bf6SAnton Vorontsov 35675368bf6SAnton Vorontsov const struct spi_device_id *spi_get_device_id(const struct spi_device *sdev) 35775368bf6SAnton Vorontsov { 35875368bf6SAnton Vorontsov const struct spi_driver *sdrv = to_spi_driver(sdev->dev.driver); 35975368bf6SAnton Vorontsov 3603f076575SAndy Shevchenko return spi_match_id(sdrv->id_table, sdev->modalias); 36175368bf6SAnton Vorontsov } 36275368bf6SAnton Vorontsov EXPORT_SYMBOL_GPL(spi_get_device_id); 36375368bf6SAnton Vorontsov 364aea672d0SAndy Shevchenko const void *spi_get_device_match_data(const struct spi_device *sdev) 365aea672d0SAndy Shevchenko { 366aea672d0SAndy Shevchenko const void *match; 367aea672d0SAndy Shevchenko 368aea672d0SAndy Shevchenko match = device_get_match_data(&sdev->dev); 369aea672d0SAndy Shevchenko if (match) 370aea672d0SAndy Shevchenko return match; 371aea672d0SAndy Shevchenko 372aea672d0SAndy Shevchenko return (const void *)spi_get_device_id(sdev)->driver_data; 373aea672d0SAndy Shevchenko } 374aea672d0SAndy Shevchenko EXPORT_SYMBOL_GPL(spi_get_device_match_data); 375aea672d0SAndy Shevchenko 3768ae12a0dSDavid Brownell static int spi_match_device(struct device *dev, struct device_driver *drv) 3778ae12a0dSDavid Brownell { 3788ae12a0dSDavid Brownell const struct spi_device *spi = to_spi_device(dev); 37975368bf6SAnton Vorontsov const struct spi_driver *sdrv = to_spi_driver(drv); 38075368bf6SAnton Vorontsov 3815039563eSTrent Piepho /* Check override first, and if set, only use the named driver */ 3825039563eSTrent Piepho if (spi->driver_override) 3835039563eSTrent Piepho return strcmp(spi->driver_override, drv->name) == 0; 3845039563eSTrent Piepho 3852b7a32f7SSinan Akman /* Attempt an OF style match */ 3862b7a32f7SSinan Akman if (of_driver_match_device(dev, drv)) 3872b7a32f7SSinan Akman return 1; 3882b7a32f7SSinan Akman 38964bee4d2SMika Westerberg /* Then try ACPI */ 39064bee4d2SMika Westerberg if (acpi_driver_match_device(dev, drv)) 39164bee4d2SMika Westerberg return 1; 39264bee4d2SMika Westerberg 39375368bf6SAnton Vorontsov if (sdrv->id_table) 3943f076575SAndy Shevchenko return !!spi_match_id(sdrv->id_table, spi->modalias); 3958ae12a0dSDavid Brownell 39635f74fcaSKay Sievers return strcmp(spi->modalias, drv->name) == 0; 3978ae12a0dSDavid Brownell } 3988ae12a0dSDavid Brownell 3992a81ada3SGreg Kroah-Hartman static int spi_uevent(const struct device *dev, struct kobj_uevent_env *env) 4008ae12a0dSDavid Brownell { 4018ae12a0dSDavid Brownell const struct spi_device *spi = to_spi_device(dev); 4028c4ff6d0SZhang Rui int rc; 4038c4ff6d0SZhang Rui 4048c4ff6d0SZhang Rui rc = acpi_device_uevent_modalias(dev, env); 4058c4ff6d0SZhang Rui if (rc != -ENODEV) 4068c4ff6d0SZhang Rui return rc; 4078ae12a0dSDavid Brownell 4082856670fSAndy Shevchenko return add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias); 4098ae12a0dSDavid Brownell } 4108ae12a0dSDavid Brownell 4119db34ee6SUwe Kleine-König static int spi_probe(struct device *dev) 412b885244eSDavid Brownell { 413b885244eSDavid Brownell const struct spi_driver *sdrv = to_spi_driver(dev->driver); 41444af7927SJon Hunter struct spi_device *spi = to_spi_device(dev); 41533cf00e5SMika Westerberg int ret; 416b885244eSDavid Brownell 41786be408bSSylwester Nawrocki ret = of_clk_set_defaults(dev->of_node, false); 41886be408bSSylwester Nawrocki if (ret) 41986be408bSSylwester Nawrocki return ret; 42086be408bSSylwester Nawrocki 42144af7927SJon Hunter if (dev->of_node) { 42244af7927SJon Hunter spi->irq = of_irq_get(dev->of_node, 0); 42344af7927SJon Hunter if (spi->irq == -EPROBE_DEFER) 42444af7927SJon Hunter return -EPROBE_DEFER; 42544af7927SJon Hunter if (spi->irq < 0) 42644af7927SJon Hunter spi->irq = 0; 42744af7927SJon Hunter } 42844af7927SJon Hunter 429676e7c25SUlf Hansson ret = dev_pm_domain_attach(dev, true); 43071f277a7SUlf Hansson if (ret) 43171f277a7SUlf Hansson return ret; 43271f277a7SUlf Hansson 433440408dbSUwe Kleine-König if (sdrv->probe) { 43444af7927SJon Hunter ret = sdrv->probe(spi); 43533cf00e5SMika Westerberg if (ret) 436676e7c25SUlf Hansson dev_pm_domain_detach(dev, true); 437440408dbSUwe Kleine-König } 43833cf00e5SMika Westerberg 43933cf00e5SMika Westerberg return ret; 440b885244eSDavid Brownell } 441b885244eSDavid Brownell 442fc7a6209SUwe Kleine-König static void spi_remove(struct device *dev) 443b885244eSDavid Brownell { 444b885244eSDavid Brownell const struct spi_driver *sdrv = to_spi_driver(dev->driver); 445b885244eSDavid Brownell 446a0386bbaSUwe Kleine-König if (sdrv->remove) 447a0386bbaSUwe Kleine-König sdrv->remove(to_spi_device(dev)); 4487795d475SUwe Kleine-König 449676e7c25SUlf Hansson dev_pm_domain_detach(dev, true); 450b885244eSDavid Brownell } 451b885244eSDavid Brownell 4529db34ee6SUwe Kleine-König static void spi_shutdown(struct device *dev) 453b885244eSDavid Brownell { 454a6f483b2SMarek Szyprowski if (dev->driver) { 455b885244eSDavid Brownell const struct spi_driver *sdrv = to_spi_driver(dev->driver); 456b885244eSDavid Brownell 4579db34ee6SUwe Kleine-König if (sdrv->shutdown) 458b885244eSDavid Brownell sdrv->shutdown(to_spi_device(dev)); 459b885244eSDavid Brownell } 460a6f483b2SMarek Szyprowski } 461b885244eSDavid Brownell 4629db34ee6SUwe Kleine-König struct bus_type spi_bus_type = { 4639db34ee6SUwe Kleine-König .name = "spi", 4649db34ee6SUwe Kleine-König .dev_groups = spi_dev_groups, 4659db34ee6SUwe Kleine-König .match = spi_match_device, 4669db34ee6SUwe Kleine-König .uevent = spi_uevent, 4679db34ee6SUwe Kleine-König .probe = spi_probe, 4689db34ee6SUwe Kleine-König .remove = spi_remove, 4699db34ee6SUwe Kleine-König .shutdown = spi_shutdown, 4709db34ee6SUwe Kleine-König }; 4719db34ee6SUwe Kleine-König EXPORT_SYMBOL_GPL(spi_bus_type); 4729db34ee6SUwe Kleine-König 47333e34dc6SDavid Brownell /** 474ca5d2485SAndrew F. Davis * __spi_register_driver - register a SPI driver 47588c9321dSThierry Reding * @owner: owner module of the driver to register 47633e34dc6SDavid Brownell * @sdrv: the driver to register 47733e34dc6SDavid Brownell * Context: can sleep 47897d56dc6SJavier Martinez Canillas * 47997d56dc6SJavier Martinez Canillas * Return: zero on success, else a negative error code. 48033e34dc6SDavid Brownell */ 481ca5d2485SAndrew F. Davis int __spi_register_driver(struct module *owner, struct spi_driver *sdrv) 482b885244eSDavid Brownell { 483ca5d2485SAndrew F. Davis sdrv->driver.owner = owner; 484b885244eSDavid Brownell sdrv->driver.bus = &spi_bus_type; 4855fa6863bSMark Brown 4865fa6863bSMark Brown /* 4875fa6863bSMark Brown * For Really Good Reasons we use spi: modaliases not of: 4885fa6863bSMark Brown * modaliases for DT so module autoloading won't work if we 4895fa6863bSMark Brown * don't have a spi_device_id as well as a compatible string. 4905fa6863bSMark Brown */ 4915fa6863bSMark Brown if (sdrv->driver.of_match_table) { 4925fa6863bSMark Brown const struct of_device_id *of_id; 4935fa6863bSMark Brown 4945fa6863bSMark Brown for (of_id = sdrv->driver.of_match_table; of_id->compatible[0]; 4955fa6863bSMark Brown of_id++) { 4965fa6863bSMark Brown const char *of_name; 4975fa6863bSMark Brown 4985fa6863bSMark Brown /* Strip off any vendor prefix */ 4995fa6863bSMark Brown of_name = strnchr(of_id->compatible, 5005fa6863bSMark Brown sizeof(of_id->compatible), ','); 5015fa6863bSMark Brown if (of_name) 5025fa6863bSMark Brown of_name++; 5035fa6863bSMark Brown else 5045fa6863bSMark Brown of_name = of_id->compatible; 5055fa6863bSMark Brown 5065fa6863bSMark Brown if (sdrv->id_table) { 5075fa6863bSMark Brown const struct spi_device_id *spi_id; 5085fa6863bSMark Brown 5093f076575SAndy Shevchenko spi_id = spi_match_id(sdrv->id_table, of_name); 510b79332efSAndy Shevchenko if (spi_id) 5115fa6863bSMark Brown continue; 5125fa6863bSMark Brown } else { 5135fa6863bSMark Brown if (strcmp(sdrv->driver.name, of_name) == 0) 5145fa6863bSMark Brown continue; 5155fa6863bSMark Brown } 5165fa6863bSMark Brown 5175fa6863bSMark Brown pr_warn("SPI driver %s has no spi_device_id for %s\n", 5185fa6863bSMark Brown sdrv->driver.name, of_id->compatible); 5195fa6863bSMark Brown } 5205fa6863bSMark Brown } 5215fa6863bSMark Brown 522b885244eSDavid Brownell return driver_register(&sdrv->driver); 523b885244eSDavid Brownell } 524ca5d2485SAndrew F. Davis EXPORT_SYMBOL_GPL(__spi_register_driver); 525b885244eSDavid Brownell 5268ae12a0dSDavid Brownell /*-------------------------------------------------------------------------*/ 5278ae12a0dSDavid Brownell 528350de7ceSAndy Shevchenko /* 529350de7ceSAndy Shevchenko * SPI devices should normally not be created by SPI device drivers; that 5308caab75fSGeert Uytterhoeven * would make them board-specific. Similarly with SPI controller drivers. 5318ae12a0dSDavid Brownell * Device registration normally goes into like arch/.../mach.../board-YYY.c 5328ae12a0dSDavid Brownell * with other readonly (flashable) information about mainboard devices. 5338ae12a0dSDavid Brownell */ 5348ae12a0dSDavid Brownell 5358ae12a0dSDavid Brownell struct boardinfo { 5368ae12a0dSDavid Brownell struct list_head list; 5372b9603a0SFeng Tang struct spi_board_info board_info; 5388ae12a0dSDavid Brownell }; 5398ae12a0dSDavid Brownell 5408ae12a0dSDavid Brownell static LIST_HEAD(board_list); 5418caab75fSGeert Uytterhoeven static LIST_HEAD(spi_controller_list); 5422b9603a0SFeng Tang 5432b9603a0SFeng Tang /* 544be73e323SAndy Shevchenko * Used to protect add/del operation for board_info list and 545350de7ceSAndy Shevchenko * spi_controller list, and their matching process also used 546350de7ceSAndy Shevchenko * to protect object of type struct idr. 5472b9603a0SFeng Tang */ 54894040828SMatthias Kaehlcke static DEFINE_MUTEX(board_lock); 5498ae12a0dSDavid Brownell 550dc87c98eSGrant Likely /** 551dc87c98eSGrant Likely * spi_alloc_device - Allocate a new SPI device 5528caab75fSGeert Uytterhoeven * @ctlr: Controller to which device is connected 553dc87c98eSGrant Likely * Context: can sleep 554dc87c98eSGrant Likely * 555dc87c98eSGrant Likely * Allows a driver to allocate and initialize a spi_device without 556dc87c98eSGrant Likely * registering it immediately. This allows a driver to directly 557dc87c98eSGrant Likely * fill the spi_device with device parameters before calling 558dc87c98eSGrant Likely * spi_add_device() on it. 559dc87c98eSGrant Likely * 560dc87c98eSGrant Likely * Caller is responsible to call spi_add_device() on the returned 5618caab75fSGeert Uytterhoeven * spi_device structure to add it to the SPI controller. If the caller 562dc87c98eSGrant Likely * needs to discard the spi_device without adding it, then it should 563dc87c98eSGrant Likely * call spi_dev_put() on it. 564dc87c98eSGrant Likely * 56597d56dc6SJavier Martinez Canillas * Return: a pointer to the new device, or NULL. 566dc87c98eSGrant Likely */ 567e3dc1399SStefan Binding struct spi_device *spi_alloc_device(struct spi_controller *ctlr) 568dc87c98eSGrant Likely { 569dc87c98eSGrant Likely struct spi_device *spi; 570dc87c98eSGrant Likely 5718caab75fSGeert Uytterhoeven if (!spi_controller_get(ctlr)) 572dc87c98eSGrant Likely return NULL; 573dc87c98eSGrant Likely 5745fe5f05eSJingoo Han spi = kzalloc(sizeof(*spi), GFP_KERNEL); 575dc87c98eSGrant Likely if (!spi) { 5768caab75fSGeert Uytterhoeven spi_controller_put(ctlr); 577dc87c98eSGrant Likely return NULL; 578dc87c98eSGrant Likely } 579dc87c98eSGrant Likely 5806598b91bSDavid Jander spi->pcpu_statistics = spi_alloc_pcpu_stats(NULL); 5816598b91bSDavid Jander if (!spi->pcpu_statistics) { 5826598b91bSDavid Jander kfree(spi); 5836598b91bSDavid Jander spi_controller_put(ctlr); 5846598b91bSDavid Jander return NULL; 5856598b91bSDavid Jander } 5866598b91bSDavid Jander 5878caab75fSGeert Uytterhoeven spi->master = spi->controller = ctlr; 5888caab75fSGeert Uytterhoeven spi->dev.parent = &ctlr->dev; 589dc87c98eSGrant Likely spi->dev.bus = &spi_bus_type; 590dc87c98eSGrant Likely spi->dev.release = spidev_release; 591ea235786SJohn Garry spi->mode = ctlr->buswidth_override_bits; 592eca2ebc7SMartin Sperl 593dc87c98eSGrant Likely device_initialize(&spi->dev); 594dc87c98eSGrant Likely return spi; 595dc87c98eSGrant Likely } 596e3dc1399SStefan Binding EXPORT_SYMBOL_GPL(spi_alloc_device); 597dc87c98eSGrant Likely 598e13ac47bSJarkko Nikula static void spi_dev_set_name(struct spi_device *spi) 599e13ac47bSJarkko Nikula { 600e13ac47bSJarkko Nikula struct acpi_device *adev = ACPI_COMPANION(&spi->dev); 601e13ac47bSJarkko Nikula 602e13ac47bSJarkko Nikula if (adev) { 603e13ac47bSJarkko Nikula dev_set_name(&spi->dev, "spi-%s", acpi_dev_name(adev)); 604e13ac47bSJarkko Nikula return; 605e13ac47bSJarkko Nikula } 606e13ac47bSJarkko Nikula 6078caab75fSGeert Uytterhoeven dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->controller->dev), 608303feb3cSAmit Kumar Mahapatra spi_get_chipselect(spi, 0)); 609e13ac47bSJarkko Nikula } 610e13ac47bSJarkko Nikula 611b6fb8d3aSMika Westerberg static int spi_dev_check(struct device *dev, void *data) 612b6fb8d3aSMika Westerberg { 613b6fb8d3aSMika Westerberg struct spi_device *spi = to_spi_device(dev); 614b6fb8d3aSMika Westerberg struct spi_device *new_spi = data; 615b6fb8d3aSMika Westerberg 6168caab75fSGeert Uytterhoeven if (spi->controller == new_spi->controller && 617303feb3cSAmit Kumar Mahapatra spi_get_chipselect(spi, 0) == spi_get_chipselect(new_spi, 0)) 618b6fb8d3aSMika Westerberg return -EBUSY; 619b6fb8d3aSMika Westerberg return 0; 620b6fb8d3aSMika Westerberg } 621b6fb8d3aSMika Westerberg 622c7299feaSSaravana Kannan static void spi_cleanup(struct spi_device *spi) 623c7299feaSSaravana Kannan { 624c7299feaSSaravana Kannan if (spi->controller->cleanup) 625c7299feaSSaravana Kannan spi->controller->cleanup(spi); 626c7299feaSSaravana Kannan } 627c7299feaSSaravana Kannan 6280c79378cSSebastian Reichel static int __spi_add_device(struct spi_device *spi) 6290c79378cSSebastian Reichel { 6300c79378cSSebastian Reichel struct spi_controller *ctlr = spi->controller; 6310c79378cSSebastian Reichel struct device *dev = ctlr->dev.parent; 6320c79378cSSebastian Reichel int status; 6330c79378cSSebastian Reichel 63436124deaSAndy Shevchenko /* Chipselects are numbered 0..max; validate. */ 63536124deaSAndy Shevchenko if (spi_get_chipselect(spi, 0) >= ctlr->num_chipselect) { 63636124deaSAndy Shevchenko dev_err(dev, "cs%d >= max %d\n", spi_get_chipselect(spi, 0), 63736124deaSAndy Shevchenko ctlr->num_chipselect); 63836124deaSAndy Shevchenko return -EINVAL; 63936124deaSAndy Shevchenko } 64036124deaSAndy Shevchenko 64136124deaSAndy Shevchenko /* Set the bus ID string */ 64236124deaSAndy Shevchenko spi_dev_set_name(spi); 64336124deaSAndy Shevchenko 6446bfb15f3SUwe Kleine-König /* 6456bfb15f3SUwe Kleine-König * We need to make sure there's no other device with this 6466bfb15f3SUwe Kleine-König * chipselect **BEFORE** we call setup(), else we'll trash 6476bfb15f3SUwe Kleine-König * its configuration. 6486bfb15f3SUwe Kleine-König */ 6490c79378cSSebastian Reichel status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check); 6500c79378cSSebastian Reichel if (status) { 6510c79378cSSebastian Reichel dev_err(dev, "chipselect %d already in use\n", 652303feb3cSAmit Kumar Mahapatra spi_get_chipselect(spi, 0)); 6530c79378cSSebastian Reichel return status; 6540c79378cSSebastian Reichel } 6550c79378cSSebastian Reichel 6560c79378cSSebastian Reichel /* Controller may unregister concurrently */ 6570c79378cSSebastian Reichel if (IS_ENABLED(CONFIG_SPI_DYNAMIC) && 6580c79378cSSebastian Reichel !device_is_registered(&ctlr->dev)) { 6590c79378cSSebastian Reichel return -ENODEV; 6600c79378cSSebastian Reichel } 6610c79378cSSebastian Reichel 6620c79378cSSebastian Reichel if (ctlr->cs_gpiods) 663303feb3cSAmit Kumar Mahapatra spi_set_csgpiod(spi, 0, ctlr->cs_gpiods[spi_get_chipselect(spi, 0)]); 6640c79378cSSebastian Reichel 665350de7ceSAndy Shevchenko /* 666350de7ceSAndy Shevchenko * Drivers may modify this initial i/o setup, but will 6670c79378cSSebastian Reichel * normally rely on the device being setup. Devices 6680c79378cSSebastian Reichel * using SPI_CS_HIGH can't coexist well otherwise... 6690c79378cSSebastian Reichel */ 6700c79378cSSebastian Reichel status = spi_setup(spi); 6710c79378cSSebastian Reichel if (status < 0) { 6720c79378cSSebastian Reichel dev_err(dev, "can't setup %s, status %d\n", 6730c79378cSSebastian Reichel dev_name(&spi->dev), status); 6740c79378cSSebastian Reichel return status; 6750c79378cSSebastian Reichel } 6760c79378cSSebastian Reichel 6770c79378cSSebastian Reichel /* Device may be bound to an active driver when this returns */ 6780c79378cSSebastian Reichel status = device_add(&spi->dev); 6790c79378cSSebastian Reichel if (status < 0) { 6800c79378cSSebastian Reichel dev_err(dev, "can't add %s, status %d\n", 6810c79378cSSebastian Reichel dev_name(&spi->dev), status); 6820c79378cSSebastian Reichel spi_cleanup(spi); 6830c79378cSSebastian Reichel } else { 6840c79378cSSebastian Reichel dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev)); 6850c79378cSSebastian Reichel } 6860c79378cSSebastian Reichel 6870c79378cSSebastian Reichel return status; 6880c79378cSSebastian Reichel } 6890c79378cSSebastian Reichel 690dc87c98eSGrant Likely /** 691dc87c98eSGrant Likely * spi_add_device - Add spi_device allocated with spi_alloc_device 692dc87c98eSGrant Likely * @spi: spi_device to register 693dc87c98eSGrant Likely * 694dc87c98eSGrant Likely * Companion function to spi_alloc_device. Devices allocated with 695702ca026SAndy Shevchenko * spi_alloc_device can be added onto the SPI bus with this function. 696dc87c98eSGrant Likely * 69797d56dc6SJavier Martinez Canillas * Return: 0 on success; negative errno on failure 698dc87c98eSGrant Likely */ 699e3dc1399SStefan Binding int spi_add_device(struct spi_device *spi) 700dc87c98eSGrant Likely { 7018caab75fSGeert Uytterhoeven struct spi_controller *ctlr = spi->controller; 702dc87c98eSGrant Likely int status; 703dc87c98eSGrant Likely 7046098475dSMark Brown mutex_lock(&ctlr->add_lock); 7050c79378cSSebastian Reichel status = __spi_add_device(spi); 7066098475dSMark Brown mutex_unlock(&ctlr->add_lock); 707e48880e0SDavid Brownell return status; 708dc87c98eSGrant Likely } 709e3dc1399SStefan Binding EXPORT_SYMBOL_GPL(spi_add_device); 7108ae12a0dSDavid Brownell 71133e34dc6SDavid Brownell /** 71233e34dc6SDavid Brownell * spi_new_device - instantiate one new SPI device 7138caab75fSGeert Uytterhoeven * @ctlr: Controller to which device is connected 71433e34dc6SDavid Brownell * @chip: Describes the SPI device 71533e34dc6SDavid Brownell * Context: can sleep 71633e34dc6SDavid Brownell * 71733e34dc6SDavid Brownell * On typical mainboards, this is purely internal; and it's not needed 7188ae12a0dSDavid Brownell * after board init creates the hard-wired devices. Some development 7198ae12a0dSDavid Brownell * platforms may not be able to use spi_register_board_info though, and 7208ae12a0dSDavid Brownell * this is exported so that for example a USB or parport based adapter 7218ae12a0dSDavid Brownell * driver could add devices (which it would learn about out-of-band). 722082c8cb4SDavid Brownell * 72397d56dc6SJavier Martinez Canillas * Return: the new device, or NULL. 7248ae12a0dSDavid Brownell */ 7258caab75fSGeert Uytterhoeven struct spi_device *spi_new_device(struct spi_controller *ctlr, 726e9d5a461SAdrian Bunk struct spi_board_info *chip) 7278ae12a0dSDavid Brownell { 7288ae12a0dSDavid Brownell struct spi_device *proxy; 7298ae12a0dSDavid Brownell int status; 7308ae12a0dSDavid Brownell 731350de7ceSAndy Shevchenko /* 732350de7ceSAndy Shevchenko * NOTE: caller did any chip->bus_num checks necessary. 733082c8cb4SDavid Brownell * 734082c8cb4SDavid Brownell * Also, unless we change the return value convention to use 735082c8cb4SDavid Brownell * error-or-pointer (not NULL-or-pointer), troubleshootability 736082c8cb4SDavid Brownell * suggests syslogged diagnostics are best here (ugh). 737082c8cb4SDavid Brownell */ 738082c8cb4SDavid Brownell 7398caab75fSGeert Uytterhoeven proxy = spi_alloc_device(ctlr); 740dc87c98eSGrant Likely if (!proxy) 7418ae12a0dSDavid Brownell return NULL; 7428ae12a0dSDavid Brownell 743102eb975SGrant Likely WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias)); 744102eb975SGrant Likely 745303feb3cSAmit Kumar Mahapatra spi_set_chipselect(proxy, 0, chip->chip_select); 7468ae12a0dSDavid Brownell proxy->max_speed_hz = chip->max_speed_hz; 747980a01c9SDavid Brownell proxy->mode = chip->mode; 7488ae12a0dSDavid Brownell proxy->irq = chip->irq; 74951e99de5SWolfram Sang strscpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias)); 7508ae12a0dSDavid Brownell proxy->dev.platform_data = (void *) chip->platform_data; 7518ae12a0dSDavid Brownell proxy->controller_data = chip->controller_data; 7528ae12a0dSDavid Brownell proxy->controller_state = NULL; 7538ae12a0dSDavid Brownell 75447afc77bSHeikki Krogerus if (chip->swnode) { 75547afc77bSHeikki Krogerus status = device_add_software_node(&proxy->dev, chip->swnode); 756826cf175SDmitry Torokhov if (status) { 7579d902c2aSColin Ian King dev_err(&ctlr->dev, "failed to add software node to '%s': %d\n", 758826cf175SDmitry Torokhov chip->modalias, status); 759826cf175SDmitry Torokhov goto err_dev_put; 760826cf175SDmitry Torokhov } 7618ae12a0dSDavid Brownell } 762dc87c98eSGrant Likely 763826cf175SDmitry Torokhov status = spi_add_device(proxy); 764826cf175SDmitry Torokhov if (status < 0) 765df41a5daSHeikki Krogerus goto err_dev_put; 766826cf175SDmitry Torokhov 767dc87c98eSGrant Likely return proxy; 768826cf175SDmitry Torokhov 769826cf175SDmitry Torokhov err_dev_put: 770df41a5daSHeikki Krogerus device_remove_software_node(&proxy->dev); 771826cf175SDmitry Torokhov spi_dev_put(proxy); 772826cf175SDmitry Torokhov return NULL; 773dc87c98eSGrant Likely } 7748ae12a0dSDavid Brownell EXPORT_SYMBOL_GPL(spi_new_device); 7758ae12a0dSDavid Brownell 7763b1884c2SGeert Uytterhoeven /** 7773b1884c2SGeert Uytterhoeven * spi_unregister_device - unregister a single SPI device 7783b1884c2SGeert Uytterhoeven * @spi: spi_device to unregister 7793b1884c2SGeert Uytterhoeven * 7803b1884c2SGeert Uytterhoeven * Start making the passed SPI device vanish. Normally this would be handled 7818caab75fSGeert Uytterhoeven * by spi_unregister_controller(). 7823b1884c2SGeert Uytterhoeven */ 7833b1884c2SGeert Uytterhoeven void spi_unregister_device(struct spi_device *spi) 7843b1884c2SGeert Uytterhoeven { 785bd6c1644SGeert Uytterhoeven if (!spi) 786bd6c1644SGeert Uytterhoeven return; 787bd6c1644SGeert Uytterhoeven 7888324147fSJohan Hovold if (spi->dev.of_node) { 789bd6c1644SGeert Uytterhoeven of_node_clear_flag(spi->dev.of_node, OF_POPULATED); 7908324147fSJohan Hovold of_node_put(spi->dev.of_node); 7918324147fSJohan Hovold } 7927f24467fSOctavian Purdila if (ACPI_COMPANION(&spi->dev)) 7937f24467fSOctavian Purdila acpi_device_clear_enumerated(ACPI_COMPANION(&spi->dev)); 79447afc77bSHeikki Krogerus device_remove_software_node(&spi->dev); 79527e7db56SSaravana Kannan device_del(&spi->dev); 79627e7db56SSaravana Kannan spi_cleanup(spi); 79727e7db56SSaravana Kannan put_device(&spi->dev); 7983b1884c2SGeert Uytterhoeven } 7993b1884c2SGeert Uytterhoeven EXPORT_SYMBOL_GPL(spi_unregister_device); 8003b1884c2SGeert Uytterhoeven 8018caab75fSGeert Uytterhoeven static void spi_match_controller_to_boardinfo(struct spi_controller *ctlr, 8022b9603a0SFeng Tang struct spi_board_info *bi) 8032b9603a0SFeng Tang { 8042b9603a0SFeng Tang struct spi_device *dev; 8052b9603a0SFeng Tang 8068caab75fSGeert Uytterhoeven if (ctlr->bus_num != bi->bus_num) 8072b9603a0SFeng Tang return; 8082b9603a0SFeng Tang 8098caab75fSGeert Uytterhoeven dev = spi_new_device(ctlr, bi); 8102b9603a0SFeng Tang if (!dev) 8118caab75fSGeert Uytterhoeven dev_err(ctlr->dev.parent, "can't create new device for %s\n", 8122b9603a0SFeng Tang bi->modalias); 8132b9603a0SFeng Tang } 8142b9603a0SFeng Tang 81533e34dc6SDavid Brownell /** 81633e34dc6SDavid Brownell * spi_register_board_info - register SPI devices for a given board 81733e34dc6SDavid Brownell * @info: array of chip descriptors 81833e34dc6SDavid Brownell * @n: how many descriptors are provided 81933e34dc6SDavid Brownell * Context: can sleep 82033e34dc6SDavid Brownell * 8218ae12a0dSDavid Brownell * Board-specific early init code calls this (probably during arch_initcall) 8228ae12a0dSDavid Brownell * with segments of the SPI device table. Any device nodes are created later, 8238ae12a0dSDavid Brownell * after the relevant parent SPI controller (bus_num) is defined. We keep 8248ae12a0dSDavid Brownell * this table of devices forever, so that reloading a controller driver will 8258ae12a0dSDavid Brownell * not make Linux forget about these hard-wired devices. 8268ae12a0dSDavid Brownell * 8278ae12a0dSDavid Brownell * Other code can also call this, e.g. a particular add-on board might provide 8288ae12a0dSDavid Brownell * SPI devices through its expansion connector, so code initializing that board 8298ae12a0dSDavid Brownell * would naturally declare its SPI devices. 8308ae12a0dSDavid Brownell * 8318ae12a0dSDavid Brownell * The board info passed can safely be __initdata ... but be careful of 8328ae12a0dSDavid Brownell * any embedded pointers (platform_data, etc), they're copied as-is. 83397d56dc6SJavier Martinez Canillas * 83497d56dc6SJavier Martinez Canillas * Return: zero on success, else a negative error code. 8358ae12a0dSDavid Brownell */ 836fd4a319bSGrant Likely int spi_register_board_info(struct spi_board_info const *info, unsigned n) 8378ae12a0dSDavid Brownell { 8388ae12a0dSDavid Brownell struct boardinfo *bi; 8392b9603a0SFeng Tang int i; 8408ae12a0dSDavid Brownell 841c7908a37SXiubo Li if (!n) 842f974cf57SDmitry Torokhov return 0; 843c7908a37SXiubo Li 844f9bdb7fdSMarkus Elfring bi = kcalloc(n, sizeof(*bi), GFP_KERNEL); 8458ae12a0dSDavid Brownell if (!bi) 8468ae12a0dSDavid Brownell return -ENOMEM; 8478ae12a0dSDavid Brownell 8482b9603a0SFeng Tang for (i = 0; i < n; i++, bi++, info++) { 8498caab75fSGeert Uytterhoeven struct spi_controller *ctlr; 8502b9603a0SFeng Tang 8512b9603a0SFeng Tang memcpy(&bi->board_info, info, sizeof(*info)); 852826cf175SDmitry Torokhov 85394040828SMatthias Kaehlcke mutex_lock(&board_lock); 8548ae12a0dSDavid Brownell list_add_tail(&bi->list, &board_list); 8558caab75fSGeert Uytterhoeven list_for_each_entry(ctlr, &spi_controller_list, list) 8568caab75fSGeert Uytterhoeven spi_match_controller_to_boardinfo(ctlr, 8578caab75fSGeert Uytterhoeven &bi->board_info); 85894040828SMatthias Kaehlcke mutex_unlock(&board_lock); 8592b9603a0SFeng Tang } 8602b9603a0SFeng Tang 8618ae12a0dSDavid Brownell return 0; 8628ae12a0dSDavid Brownell } 8638ae12a0dSDavid Brownell 8648ae12a0dSDavid Brownell /*-------------------------------------------------------------------------*/ 8658ae12a0dSDavid Brownell 866fb51601bSUwe Kleine-König /* Core methods for SPI resource management */ 867fb51601bSUwe Kleine-König 868fb51601bSUwe Kleine-König /** 869fb51601bSUwe Kleine-König * spi_res_alloc - allocate a spi resource that is life-cycle managed 870fb51601bSUwe Kleine-König * during the processing of a spi_message while using 871fb51601bSUwe Kleine-König * spi_transfer_one 872702ca026SAndy Shevchenko * @spi: the SPI device for which we allocate memory 873fb51601bSUwe Kleine-König * @release: the release code to execute for this resource 874fb51601bSUwe Kleine-König * @size: size to alloc and return 875fb51601bSUwe Kleine-König * @gfp: GFP allocation flags 876fb51601bSUwe Kleine-König * 877fb51601bSUwe Kleine-König * Return: the pointer to the allocated data 878fb51601bSUwe Kleine-König * 879fb51601bSUwe Kleine-König * This may get enhanced in the future to allocate from a memory pool 880fb51601bSUwe Kleine-König * of the @spi_device or @spi_controller to avoid repeated allocations. 881fb51601bSUwe Kleine-König */ 882da21fde0SUwe Kleine-König static void *spi_res_alloc(struct spi_device *spi, spi_res_release_t release, 883fb51601bSUwe Kleine-König size_t size, gfp_t gfp) 884fb51601bSUwe Kleine-König { 885fb51601bSUwe Kleine-König struct spi_res *sres; 886fb51601bSUwe Kleine-König 887fb51601bSUwe Kleine-König sres = kzalloc(sizeof(*sres) + size, gfp); 888fb51601bSUwe Kleine-König if (!sres) 889fb51601bSUwe Kleine-König return NULL; 890fb51601bSUwe Kleine-König 891fb51601bSUwe Kleine-König INIT_LIST_HEAD(&sres->entry); 892fb51601bSUwe Kleine-König sres->release = release; 893fb51601bSUwe Kleine-König 894fb51601bSUwe Kleine-König return sres->data; 895fb51601bSUwe Kleine-König } 896fb51601bSUwe Kleine-König 897fb51601bSUwe Kleine-König /** 898702ca026SAndy Shevchenko * spi_res_free - free an SPI resource 899fb51601bSUwe Kleine-König * @res: pointer to the custom data of a resource 900fb51601bSUwe Kleine-König */ 901da21fde0SUwe Kleine-König static void spi_res_free(void *res) 902fb51601bSUwe Kleine-König { 903fb51601bSUwe Kleine-König struct spi_res *sres = container_of(res, struct spi_res, data); 904fb51601bSUwe Kleine-König 905fb51601bSUwe Kleine-König if (!res) 906fb51601bSUwe Kleine-König return; 907fb51601bSUwe Kleine-König 908fb51601bSUwe Kleine-König WARN_ON(!list_empty(&sres->entry)); 909fb51601bSUwe Kleine-König kfree(sres); 910fb51601bSUwe Kleine-König } 911fb51601bSUwe Kleine-König 912fb51601bSUwe Kleine-König /** 913fb51601bSUwe Kleine-König * spi_res_add - add a spi_res to the spi_message 914702ca026SAndy Shevchenko * @message: the SPI message 915fb51601bSUwe Kleine-König * @res: the spi_resource 916fb51601bSUwe Kleine-König */ 917da21fde0SUwe Kleine-König static void spi_res_add(struct spi_message *message, void *res) 918fb51601bSUwe Kleine-König { 919fb51601bSUwe Kleine-König struct spi_res *sres = container_of(res, struct spi_res, data); 920fb51601bSUwe Kleine-König 921fb51601bSUwe Kleine-König WARN_ON(!list_empty(&sres->entry)); 922fb51601bSUwe Kleine-König list_add_tail(&sres->entry, &message->resources); 923fb51601bSUwe Kleine-König } 924fb51601bSUwe Kleine-König 925fb51601bSUwe Kleine-König /** 926702ca026SAndy Shevchenko * spi_res_release - release all SPI resources for this message 927fb51601bSUwe Kleine-König * @ctlr: the @spi_controller 928fb51601bSUwe Kleine-König * @message: the @spi_message 929fb51601bSUwe Kleine-König */ 930da21fde0SUwe Kleine-König static void spi_res_release(struct spi_controller *ctlr, struct spi_message *message) 931fb51601bSUwe Kleine-König { 932fb51601bSUwe Kleine-König struct spi_res *res, *tmp; 933fb51601bSUwe Kleine-König 934fb51601bSUwe Kleine-König list_for_each_entry_safe_reverse(res, tmp, &message->resources, entry) { 935fb51601bSUwe Kleine-König if (res->release) 936fb51601bSUwe Kleine-König res->release(ctlr, message, res->data); 937fb51601bSUwe Kleine-König 938fb51601bSUwe Kleine-König list_del(&res->entry); 939fb51601bSUwe Kleine-König 940fb51601bSUwe Kleine-König kfree(res); 941fb51601bSUwe Kleine-König } 942fb51601bSUwe Kleine-König } 943fb51601bSUwe Kleine-König 944fb51601bSUwe Kleine-König /*-------------------------------------------------------------------------*/ 945fb51601bSUwe Kleine-König 946d347b4aaSDavid Bauer static void spi_set_cs(struct spi_device *spi, bool enable, bool force) 947b158935fSMark Brown { 94886527bcbSAndy Shevchenko bool activate = enable; 94925093bdeSAlexandru Ardelean 950d40f0b6fSDouglas Anderson /* 951d40f0b6fSDouglas Anderson * Avoid calling into the driver (or doing delays) if the chip select 952d40f0b6fSDouglas Anderson * isn't actually changing from the last time this was called. 953d40f0b6fSDouglas Anderson */ 954303feb3cSAmit Kumar Mahapatra if (!force && ((enable && spi->controller->last_cs == spi_get_chipselect(spi, 0)) || 955303feb3cSAmit Kumar Mahapatra (!enable && spi->controller->last_cs != spi_get_chipselect(spi, 0))) && 956d40f0b6fSDouglas Anderson (spi->controller->last_cs_mode_high == (spi->mode & SPI_CS_HIGH))) 957d40f0b6fSDouglas Anderson return; 958d40f0b6fSDouglas Anderson 9595cb4e1f3SAndy Shevchenko trace_spi_set_cs(spi, activate); 9605cb4e1f3SAndy Shevchenko 961303feb3cSAmit Kumar Mahapatra spi->controller->last_cs = enable ? spi_get_chipselect(spi, 0) : -1; 962d40f0b6fSDouglas Anderson spi->controller->last_cs_mode_high = spi->mode & SPI_CS_HIGH; 963d40f0b6fSDouglas Anderson 964303feb3cSAmit Kumar Mahapatra if ((spi_get_csgpiod(spi, 0) || !spi->controller->set_cs_timing) && !activate) 9658c33ebfeSMason Zhang spi_delay_exec(&spi->cs_hold, NULL); 96625093bdeSAlexandru Ardelean 967b158935fSMark Brown if (spi->mode & SPI_CS_HIGH) 968b158935fSMark Brown enable = !enable; 969b158935fSMark Brown 970303feb3cSAmit Kumar Mahapatra if (spi_get_csgpiod(spi, 0)) { 971f48dc6b9SLinus Walleij if (!(spi->mode & SPI_NO_CS)) { 9726b695469SAndy Shevchenko /* 9736b695469SAndy Shevchenko * Historically ACPI has no means of the GPIO polarity and 9746b695469SAndy Shevchenko * thus the SPISerialBus() resource defines it on the per-chip 9756b695469SAndy Shevchenko * basis. In order to avoid a chain of negations, the GPIO 9766b695469SAndy Shevchenko * polarity is considered being Active High. Even for the cases 9776b695469SAndy Shevchenko * when _DSD() is involved (in the updated versions of ACPI) 9786b695469SAndy Shevchenko * the GPIO CS polarity must be defined Active High to avoid 9796b695469SAndy Shevchenko * ambiguity. That's why we use enable, that takes SPI_CS_HIGH 9806b695469SAndy Shevchenko * into account. 9816b695469SAndy Shevchenko */ 9826b695469SAndy Shevchenko if (has_acpi_companion(&spi->dev)) 983303feb3cSAmit Kumar Mahapatra gpiod_set_value_cansleep(spi_get_csgpiod(spi, 0), !enable); 984f3186dd8SLinus Walleij else 9856b695469SAndy Shevchenko /* Polarity handled by GPIO library */ 986303feb3cSAmit Kumar Mahapatra gpiod_set_value_cansleep(spi_get_csgpiod(spi, 0), activate); 9876b695469SAndy Shevchenko } 9888eee6b9dSThor Thayer /* Some SPI masters need both GPIO CS & slave_select */ 98982238d2cSAndy Shevchenko if ((spi->controller->flags & SPI_CONTROLLER_GPIO_SS) && 9908caab75fSGeert Uytterhoeven spi->controller->set_cs) 9918caab75fSGeert Uytterhoeven spi->controller->set_cs(spi, !enable); 9928caab75fSGeert Uytterhoeven } else if (spi->controller->set_cs) { 9938caab75fSGeert Uytterhoeven spi->controller->set_cs(spi, !enable); 9948eee6b9dSThor Thayer } 99525093bdeSAlexandru Ardelean 996303feb3cSAmit Kumar Mahapatra if (spi_get_csgpiod(spi, 0) || !spi->controller->set_cs_timing) { 99795c07247SHector Martin if (activate) 99895c07247SHector Martin spi_delay_exec(&spi->cs_setup, NULL); 99995c07247SHector Martin else 10008c33ebfeSMason Zhang spi_delay_exec(&spi->cs_inactive, NULL); 100125093bdeSAlexandru Ardelean } 1002b158935fSMark Brown } 1003b158935fSMark Brown 10042de440f5SGeert Uytterhoeven #ifdef CONFIG_HAS_DMA 10050c17ba73SVincent Whitchurch static int spi_map_buf_attrs(struct spi_controller *ctlr, struct device *dev, 10066ad45a27SMark Brown struct sg_table *sgt, void *buf, size_t len, 10070c17ba73SVincent Whitchurch enum dma_data_direction dir, unsigned long attrs) 10086ad45a27SMark Brown { 10096ad45a27SMark Brown const bool vmalloced_buf = is_vmalloc_addr(buf); 1010df88e91bSAndy Shevchenko unsigned int max_seg_size = dma_get_max_seg_size(dev); 1011b1b8153cSVignesh R #ifdef CONFIG_HIGHMEM 1012b1b8153cSVignesh R const bool kmap_buf = ((unsigned long)buf >= PKMAP_BASE && 1013b1b8153cSVignesh R (unsigned long)buf < (PKMAP_BASE + 1014b1b8153cSVignesh R (LAST_PKMAP * PAGE_SIZE))); 1015b1b8153cSVignesh R #else 1016b1b8153cSVignesh R const bool kmap_buf = false; 1017b1b8153cSVignesh R #endif 101865598c13SAndrew Gabbasov int desc_len; 101965598c13SAndrew Gabbasov int sgs; 10206ad45a27SMark Brown struct page *vm_page; 10218dd4a016SJuan Gutierrez struct scatterlist *sg; 10226ad45a27SMark Brown void *sg_buf; 10236ad45a27SMark Brown size_t min; 10246ad45a27SMark Brown int i, ret; 10256ad45a27SMark Brown 1026b1b8153cSVignesh R if (vmalloced_buf || kmap_buf) { 1027ebc4cb43SBiju Das desc_len = min_t(unsigned long, max_seg_size, PAGE_SIZE); 102865598c13SAndrew Gabbasov sgs = DIV_ROUND_UP(len + offset_in_page(buf), desc_len); 10290569a88fSVignesh R } else if (virt_addr_valid(buf)) { 1030ebc4cb43SBiju Das desc_len = min_t(size_t, max_seg_size, ctlr->max_dma_len); 103165598c13SAndrew Gabbasov sgs = DIV_ROUND_UP(len, desc_len); 10320569a88fSVignesh R } else { 10330569a88fSVignesh R return -EINVAL; 103465598c13SAndrew Gabbasov } 103565598c13SAndrew Gabbasov 10366ad45a27SMark Brown ret = sg_alloc_table(sgt, sgs, GFP_KERNEL); 10376ad45a27SMark Brown if (ret != 0) 10386ad45a27SMark Brown return ret; 10396ad45a27SMark Brown 10408dd4a016SJuan Gutierrez sg = &sgt->sgl[0]; 10416ad45a27SMark Brown for (i = 0; i < sgs; i++) { 10426ad45a27SMark Brown 1043b1b8153cSVignesh R if (vmalloced_buf || kmap_buf) { 1044ce99319aSMaxime Chevallier /* 1045ce99319aSMaxime Chevallier * Next scatterlist entry size is the minimum between 1046ce99319aSMaxime Chevallier * the desc_len and the remaining buffer length that 1047ce99319aSMaxime Chevallier * fits in a page. 1048ce99319aSMaxime Chevallier */ 1049ce99319aSMaxime Chevallier min = min_t(size_t, desc_len, 1050ce99319aSMaxime Chevallier min_t(size_t, len, 1051ce99319aSMaxime Chevallier PAGE_SIZE - offset_in_page(buf))); 1052b1b8153cSVignesh R if (vmalloced_buf) 10536ad45a27SMark Brown vm_page = vmalloc_to_page(buf); 1054b1b8153cSVignesh R else 1055b1b8153cSVignesh R vm_page = kmap_to_page(buf); 10566ad45a27SMark Brown if (!vm_page) { 10576ad45a27SMark Brown sg_free_table(sgt); 10586ad45a27SMark Brown return -ENOMEM; 10596ad45a27SMark Brown } 10608dd4a016SJuan Gutierrez sg_set_page(sg, vm_page, 1061c1aefbddSCharles Keepax min, offset_in_page(buf)); 10626ad45a27SMark Brown } else { 106365598c13SAndrew Gabbasov min = min_t(size_t, len, desc_len); 10646ad45a27SMark Brown sg_buf = buf; 10658dd4a016SJuan Gutierrez sg_set_buf(sg, sg_buf, min); 10666ad45a27SMark Brown } 10676ad45a27SMark Brown 10686ad45a27SMark Brown buf += min; 10696ad45a27SMark Brown len -= min; 10708dd4a016SJuan Gutierrez sg = sg_next(sg); 10716ad45a27SMark Brown } 10726ad45a27SMark Brown 10730c17ba73SVincent Whitchurch ret = dma_map_sgtable(dev, sgt, dir, attrs); 10746ad45a27SMark Brown if (ret < 0) { 10756ad45a27SMark Brown sg_free_table(sgt); 10766ad45a27SMark Brown return ret; 10776ad45a27SMark Brown } 10786ad45a27SMark Brown 10796ad45a27SMark Brown return 0; 10806ad45a27SMark Brown } 10816ad45a27SMark Brown 10820c17ba73SVincent Whitchurch int spi_map_buf(struct spi_controller *ctlr, struct device *dev, 10830c17ba73SVincent Whitchurch struct sg_table *sgt, void *buf, size_t len, 10840c17ba73SVincent Whitchurch enum dma_data_direction dir) 10850c17ba73SVincent Whitchurch { 10860c17ba73SVincent Whitchurch return spi_map_buf_attrs(ctlr, dev, sgt, buf, len, dir, 0); 10870c17ba73SVincent Whitchurch } 10880c17ba73SVincent Whitchurch 10890c17ba73SVincent Whitchurch static void spi_unmap_buf_attrs(struct spi_controller *ctlr, 10900c17ba73SVincent Whitchurch struct device *dev, struct sg_table *sgt, 10910c17ba73SVincent Whitchurch enum dma_data_direction dir, 10920c17ba73SVincent Whitchurch unsigned long attrs) 10930c17ba73SVincent Whitchurch { 10940c17ba73SVincent Whitchurch if (sgt->orig_nents) { 10950c17ba73SVincent Whitchurch dma_unmap_sgtable(dev, sgt, dir, attrs); 10960c17ba73SVincent Whitchurch sg_free_table(sgt); 10978e9204cdSMarek Szyprowski sgt->orig_nents = 0; 10988e9204cdSMarek Szyprowski sgt->nents = 0; 10990c17ba73SVincent Whitchurch } 11000c17ba73SVincent Whitchurch } 11010c17ba73SVincent Whitchurch 110246336966SBoris Brezillon void spi_unmap_buf(struct spi_controller *ctlr, struct device *dev, 11036ad45a27SMark Brown struct sg_table *sgt, enum dma_data_direction dir) 11046ad45a27SMark Brown { 11050c17ba73SVincent Whitchurch spi_unmap_buf_attrs(ctlr, dev, sgt, dir, 0); 11066ad45a27SMark Brown } 11076ad45a27SMark Brown 11088caab75fSGeert Uytterhoeven static int __spi_map_msg(struct spi_controller *ctlr, struct spi_message *msg) 110999adef31SMark Brown { 111099adef31SMark Brown struct device *tx_dev, *rx_dev; 111199adef31SMark Brown struct spi_transfer *xfer; 11126ad45a27SMark Brown int ret; 11133a2eba9bSMark Brown 11148caab75fSGeert Uytterhoeven if (!ctlr->can_dma) 111599adef31SMark Brown return 0; 111699adef31SMark Brown 11178caab75fSGeert Uytterhoeven if (ctlr->dma_tx) 11188caab75fSGeert Uytterhoeven tx_dev = ctlr->dma_tx->device->dev; 1119b470e10eSVinod Koul else if (ctlr->dma_map_dev) 1120b470e10eSVinod Koul tx_dev = ctlr->dma_map_dev; 1121c37f45b5SLeilk Liu else 11228caab75fSGeert Uytterhoeven tx_dev = ctlr->dev.parent; 1123c37f45b5SLeilk Liu 11248caab75fSGeert Uytterhoeven if (ctlr->dma_rx) 11258caab75fSGeert Uytterhoeven rx_dev = ctlr->dma_rx->device->dev; 1126b470e10eSVinod Koul else if (ctlr->dma_map_dev) 1127b470e10eSVinod Koul rx_dev = ctlr->dma_map_dev; 1128c37f45b5SLeilk Liu else 11298caab75fSGeert Uytterhoeven rx_dev = ctlr->dev.parent; 113099adef31SMark Brown 113199adef31SMark Brown list_for_each_entry(xfer, &msg->transfers, transfer_list) { 11320c17ba73SVincent Whitchurch /* The sync is done before each transfer. */ 11330c17ba73SVincent Whitchurch unsigned long attrs = DMA_ATTR_SKIP_CPU_SYNC; 11340c17ba73SVincent Whitchurch 11358caab75fSGeert Uytterhoeven if (!ctlr->can_dma(ctlr, msg->spi, xfer)) 113699adef31SMark Brown continue; 113799adef31SMark Brown 113899adef31SMark Brown if (xfer->tx_buf != NULL) { 11390c17ba73SVincent Whitchurch ret = spi_map_buf_attrs(ctlr, tx_dev, &xfer->tx_sg, 11400c17ba73SVincent Whitchurch (void *)xfer->tx_buf, 11410c17ba73SVincent Whitchurch xfer->len, DMA_TO_DEVICE, 11420c17ba73SVincent Whitchurch attrs); 11436ad45a27SMark Brown if (ret != 0) 11446ad45a27SMark Brown return ret; 114599adef31SMark Brown } 114699adef31SMark Brown 114799adef31SMark Brown if (xfer->rx_buf != NULL) { 11480c17ba73SVincent Whitchurch ret = spi_map_buf_attrs(ctlr, rx_dev, &xfer->rx_sg, 114999adef31SMark Brown xfer->rx_buf, xfer->len, 11500c17ba73SVincent Whitchurch DMA_FROM_DEVICE, attrs); 11516ad45a27SMark Brown if (ret != 0) { 11520c17ba73SVincent Whitchurch spi_unmap_buf_attrs(ctlr, tx_dev, 11530c17ba73SVincent Whitchurch &xfer->tx_sg, DMA_TO_DEVICE, 11540c17ba73SVincent Whitchurch attrs); 11550c17ba73SVincent Whitchurch 11566ad45a27SMark Brown return ret; 115799adef31SMark Brown } 115899adef31SMark Brown } 115999adef31SMark Brown } 116099adef31SMark Brown 1161f25723dcSVincent Whitchurch ctlr->cur_rx_dma_dev = rx_dev; 1162f25723dcSVincent Whitchurch ctlr->cur_tx_dma_dev = tx_dev; 11638caab75fSGeert Uytterhoeven ctlr->cur_msg_mapped = true; 116499adef31SMark Brown 116599adef31SMark Brown return 0; 116699adef31SMark Brown } 116799adef31SMark Brown 11688caab75fSGeert Uytterhoeven static int __spi_unmap_msg(struct spi_controller *ctlr, struct spi_message *msg) 116999adef31SMark Brown { 1170f25723dcSVincent Whitchurch struct device *rx_dev = ctlr->cur_rx_dma_dev; 1171f25723dcSVincent Whitchurch struct device *tx_dev = ctlr->cur_tx_dma_dev; 117299adef31SMark Brown struct spi_transfer *xfer; 117399adef31SMark Brown 11748caab75fSGeert Uytterhoeven if (!ctlr->cur_msg_mapped || !ctlr->can_dma) 117599adef31SMark Brown return 0; 117699adef31SMark Brown 117799adef31SMark Brown list_for_each_entry(xfer, &msg->transfers, transfer_list) { 11780c17ba73SVincent Whitchurch /* The sync has already been done after each transfer. */ 11790c17ba73SVincent Whitchurch unsigned long attrs = DMA_ATTR_SKIP_CPU_SYNC; 11800c17ba73SVincent Whitchurch 11818caab75fSGeert Uytterhoeven if (!ctlr->can_dma(ctlr, msg->spi, xfer)) 118299adef31SMark Brown continue; 118399adef31SMark Brown 11840c17ba73SVincent Whitchurch spi_unmap_buf_attrs(ctlr, rx_dev, &xfer->rx_sg, 11850c17ba73SVincent Whitchurch DMA_FROM_DEVICE, attrs); 11860c17ba73SVincent Whitchurch spi_unmap_buf_attrs(ctlr, tx_dev, &xfer->tx_sg, 11870c17ba73SVincent Whitchurch DMA_TO_DEVICE, attrs); 118899adef31SMark Brown } 118999adef31SMark Brown 1190809b1b04SRobin Gong ctlr->cur_msg_mapped = false; 1191809b1b04SRobin Gong 119299adef31SMark Brown return 0; 119399adef31SMark Brown } 11940c17ba73SVincent Whitchurch 11950c17ba73SVincent Whitchurch static void spi_dma_sync_for_device(struct spi_controller *ctlr, 11960c17ba73SVincent Whitchurch struct spi_transfer *xfer) 11970c17ba73SVincent Whitchurch { 11980c17ba73SVincent Whitchurch struct device *rx_dev = ctlr->cur_rx_dma_dev; 11990c17ba73SVincent Whitchurch struct device *tx_dev = ctlr->cur_tx_dma_dev; 12000c17ba73SVincent Whitchurch 12010c17ba73SVincent Whitchurch if (!ctlr->cur_msg_mapped) 12020c17ba73SVincent Whitchurch return; 12030c17ba73SVincent Whitchurch 12040c17ba73SVincent Whitchurch if (xfer->tx_sg.orig_nents) 12050c17ba73SVincent Whitchurch dma_sync_sgtable_for_device(tx_dev, &xfer->tx_sg, DMA_TO_DEVICE); 12060c17ba73SVincent Whitchurch if (xfer->rx_sg.orig_nents) 12070c17ba73SVincent Whitchurch dma_sync_sgtable_for_device(rx_dev, &xfer->rx_sg, DMA_FROM_DEVICE); 12080c17ba73SVincent Whitchurch } 12090c17ba73SVincent Whitchurch 12100c17ba73SVincent Whitchurch static void spi_dma_sync_for_cpu(struct spi_controller *ctlr, 12110c17ba73SVincent Whitchurch struct spi_transfer *xfer) 12120c17ba73SVincent Whitchurch { 12130c17ba73SVincent Whitchurch struct device *rx_dev = ctlr->cur_rx_dma_dev; 12140c17ba73SVincent Whitchurch struct device *tx_dev = ctlr->cur_tx_dma_dev; 12150c17ba73SVincent Whitchurch 12160c17ba73SVincent Whitchurch if (!ctlr->cur_msg_mapped) 12170c17ba73SVincent Whitchurch return; 12180c17ba73SVincent Whitchurch 12190c17ba73SVincent Whitchurch if (xfer->rx_sg.orig_nents) 12200c17ba73SVincent Whitchurch dma_sync_sgtable_for_cpu(rx_dev, &xfer->rx_sg, DMA_FROM_DEVICE); 12210c17ba73SVincent Whitchurch if (xfer->tx_sg.orig_nents) 12220c17ba73SVincent Whitchurch dma_sync_sgtable_for_cpu(tx_dev, &xfer->tx_sg, DMA_TO_DEVICE); 12230c17ba73SVincent Whitchurch } 12242de440f5SGeert Uytterhoeven #else /* !CONFIG_HAS_DMA */ 12258caab75fSGeert Uytterhoeven static inline int __spi_map_msg(struct spi_controller *ctlr, 12262de440f5SGeert Uytterhoeven struct spi_message *msg) 12272de440f5SGeert Uytterhoeven { 12282de440f5SGeert Uytterhoeven return 0; 12292de440f5SGeert Uytterhoeven } 12302de440f5SGeert Uytterhoeven 12318caab75fSGeert Uytterhoeven static inline int __spi_unmap_msg(struct spi_controller *ctlr, 12322de440f5SGeert Uytterhoeven struct spi_message *msg) 12332de440f5SGeert Uytterhoeven { 12342de440f5SGeert Uytterhoeven return 0; 12352de440f5SGeert Uytterhoeven } 12360c17ba73SVincent Whitchurch 12370c17ba73SVincent Whitchurch static void spi_dma_sync_for_device(struct spi_controller *ctrl, 12380c17ba73SVincent Whitchurch struct spi_transfer *xfer) 12390c17ba73SVincent Whitchurch { 12400c17ba73SVincent Whitchurch } 12410c17ba73SVincent Whitchurch 12420c17ba73SVincent Whitchurch static void spi_dma_sync_for_cpu(struct spi_controller *ctrl, 12430c17ba73SVincent Whitchurch struct spi_transfer *xfer) 12440c17ba73SVincent Whitchurch { 12450c17ba73SVincent Whitchurch } 12462de440f5SGeert Uytterhoeven #endif /* !CONFIG_HAS_DMA */ 12472de440f5SGeert Uytterhoeven 12488caab75fSGeert Uytterhoeven static inline int spi_unmap_msg(struct spi_controller *ctlr, 12494b786458SMartin Sperl struct spi_message *msg) 12504b786458SMartin Sperl { 12514b786458SMartin Sperl struct spi_transfer *xfer; 12524b786458SMartin Sperl 12534b786458SMartin Sperl list_for_each_entry(xfer, &msg->transfers, transfer_list) { 12544b786458SMartin Sperl /* 12554b786458SMartin Sperl * Restore the original value of tx_buf or rx_buf if they are 12564b786458SMartin Sperl * NULL. 12574b786458SMartin Sperl */ 12588caab75fSGeert Uytterhoeven if (xfer->tx_buf == ctlr->dummy_tx) 12594b786458SMartin Sperl xfer->tx_buf = NULL; 12608caab75fSGeert Uytterhoeven if (xfer->rx_buf == ctlr->dummy_rx) 12614b786458SMartin Sperl xfer->rx_buf = NULL; 12624b786458SMartin Sperl } 12634b786458SMartin Sperl 12648caab75fSGeert Uytterhoeven return __spi_unmap_msg(ctlr, msg); 12654b786458SMartin Sperl } 12664b786458SMartin Sperl 12678caab75fSGeert Uytterhoeven static int spi_map_msg(struct spi_controller *ctlr, struct spi_message *msg) 12682de440f5SGeert Uytterhoeven { 12692de440f5SGeert Uytterhoeven struct spi_transfer *xfer; 12702de440f5SGeert Uytterhoeven void *tmp; 12712de440f5SGeert Uytterhoeven unsigned int max_tx, max_rx; 12722de440f5SGeert Uytterhoeven 1273aee67fe8Sdillon min if ((ctlr->flags & (SPI_CONTROLLER_MUST_RX | SPI_CONTROLLER_MUST_TX)) 1274aee67fe8Sdillon min && !(msg->spi->mode & SPI_3WIRE)) { 12752de440f5SGeert Uytterhoeven max_tx = 0; 12762de440f5SGeert Uytterhoeven max_rx = 0; 12772de440f5SGeert Uytterhoeven 12782de440f5SGeert Uytterhoeven list_for_each_entry(xfer, &msg->transfers, transfer_list) { 12798caab75fSGeert Uytterhoeven if ((ctlr->flags & SPI_CONTROLLER_MUST_TX) && 12802de440f5SGeert Uytterhoeven !xfer->tx_buf) 12812de440f5SGeert Uytterhoeven max_tx = max(xfer->len, max_tx); 12828caab75fSGeert Uytterhoeven if ((ctlr->flags & SPI_CONTROLLER_MUST_RX) && 12832de440f5SGeert Uytterhoeven !xfer->rx_buf) 12842de440f5SGeert Uytterhoeven max_rx = max(xfer->len, max_rx); 12852de440f5SGeert Uytterhoeven } 12862de440f5SGeert Uytterhoeven 12872de440f5SGeert Uytterhoeven if (max_tx) { 12888caab75fSGeert Uytterhoeven tmp = krealloc(ctlr->dummy_tx, max_tx, 1289b00bab9dSAndy Shevchenko GFP_KERNEL | GFP_DMA | __GFP_ZERO); 12902de440f5SGeert Uytterhoeven if (!tmp) 12912de440f5SGeert Uytterhoeven return -ENOMEM; 12928caab75fSGeert Uytterhoeven ctlr->dummy_tx = tmp; 12932de440f5SGeert Uytterhoeven } 12942de440f5SGeert Uytterhoeven 12952de440f5SGeert Uytterhoeven if (max_rx) { 12968caab75fSGeert Uytterhoeven tmp = krealloc(ctlr->dummy_rx, max_rx, 12972de440f5SGeert Uytterhoeven GFP_KERNEL | GFP_DMA); 12982de440f5SGeert Uytterhoeven if (!tmp) 12992de440f5SGeert Uytterhoeven return -ENOMEM; 13008caab75fSGeert Uytterhoeven ctlr->dummy_rx = tmp; 13012de440f5SGeert Uytterhoeven } 13022de440f5SGeert Uytterhoeven 13032de440f5SGeert Uytterhoeven if (max_tx || max_rx) { 13042de440f5SGeert Uytterhoeven list_for_each_entry(xfer, &msg->transfers, 13052de440f5SGeert Uytterhoeven transfer_list) { 13065442dcaaSChris Lesiak if (!xfer->len) 13075442dcaaSChris Lesiak continue; 13082de440f5SGeert Uytterhoeven if (!xfer->tx_buf) 13098caab75fSGeert Uytterhoeven xfer->tx_buf = ctlr->dummy_tx; 13102de440f5SGeert Uytterhoeven if (!xfer->rx_buf) 13118caab75fSGeert Uytterhoeven xfer->rx_buf = ctlr->dummy_rx; 13122de440f5SGeert Uytterhoeven } 13132de440f5SGeert Uytterhoeven } 13142de440f5SGeert Uytterhoeven } 13152de440f5SGeert Uytterhoeven 13168caab75fSGeert Uytterhoeven return __spi_map_msg(ctlr, msg); 13172de440f5SGeert Uytterhoeven } 131899adef31SMark Brown 1319810923f3SLubomir Rintel static int spi_transfer_wait(struct spi_controller *ctlr, 1320810923f3SLubomir Rintel struct spi_message *msg, 1321810923f3SLubomir Rintel struct spi_transfer *xfer) 1322810923f3SLubomir Rintel { 1323d501cc4cSDavid Jander struct spi_statistics __percpu *statm = ctlr->pcpu_statistics; 1324d501cc4cSDavid Jander struct spi_statistics __percpu *stats = msg->spi->pcpu_statistics; 13256170d077SXu Yilun u32 speed_hz = xfer->speed_hz; 132649686df5SColin Ian King unsigned long long ms; 1327810923f3SLubomir Rintel 1328810923f3SLubomir Rintel if (spi_controller_is_slave(ctlr)) { 1329810923f3SLubomir Rintel if (wait_for_completion_interruptible(&ctlr->xfer_completion)) { 1330810923f3SLubomir Rintel dev_dbg(&msg->spi->dev, "SPI transfer interrupted\n"); 1331810923f3SLubomir Rintel return -EINTR; 1332810923f3SLubomir Rintel } 1333810923f3SLubomir Rintel } else { 13346170d077SXu Yilun if (!speed_hz) 13356170d077SXu Yilun speed_hz = 100000; 13366170d077SXu Yilun 133786b8bff7SAndy Shevchenko /* 133886b8bff7SAndy Shevchenko * For each byte we wait for 8 cycles of the SPI clock. 133986b8bff7SAndy Shevchenko * Since speed is defined in Hz and we want milliseconds, 134086b8bff7SAndy Shevchenko * use respective multiplier, but before the division, 134186b8bff7SAndy Shevchenko * otherwise we may get 0 for short transfers. 134286b8bff7SAndy Shevchenko */ 134386b8bff7SAndy Shevchenko ms = 8LL * MSEC_PER_SEC * xfer->len; 13446170d077SXu Yilun do_div(ms, speed_hz); 1345810923f3SLubomir Rintel 134686b8bff7SAndy Shevchenko /* 134786b8bff7SAndy Shevchenko * Increase it twice and add 200 ms tolerance, use 134886b8bff7SAndy Shevchenko * predefined maximum in case of overflow. 134986b8bff7SAndy Shevchenko */ 135086b8bff7SAndy Shevchenko ms += ms + 200; 1351810923f3SLubomir Rintel if (ms > UINT_MAX) 1352810923f3SLubomir Rintel ms = UINT_MAX; 1353810923f3SLubomir Rintel 1354810923f3SLubomir Rintel ms = wait_for_completion_timeout(&ctlr->xfer_completion, 1355810923f3SLubomir Rintel msecs_to_jiffies(ms)); 1356810923f3SLubomir Rintel 1357810923f3SLubomir Rintel if (ms == 0) { 1358810923f3SLubomir Rintel SPI_STATISTICS_INCREMENT_FIELD(statm, timedout); 1359810923f3SLubomir Rintel SPI_STATISTICS_INCREMENT_FIELD(stats, timedout); 1360810923f3SLubomir Rintel dev_err(&msg->spi->dev, 1361810923f3SLubomir Rintel "SPI transfer timed out\n"); 1362810923f3SLubomir Rintel return -ETIMEDOUT; 1363810923f3SLubomir Rintel } 1364810923f3SLubomir Rintel } 1365810923f3SLubomir Rintel 1366810923f3SLubomir Rintel return 0; 1367810923f3SLubomir Rintel } 1368810923f3SLubomir Rintel 13690ff2de8bSMartin Sperl static void _spi_transfer_delay_ns(u32 ns) 13700ff2de8bSMartin Sperl { 13710ff2de8bSMartin Sperl if (!ns) 13720ff2de8bSMartin Sperl return; 137386b8bff7SAndy Shevchenko if (ns <= NSEC_PER_USEC) { 13740ff2de8bSMartin Sperl ndelay(ns); 13750ff2de8bSMartin Sperl } else { 137686b8bff7SAndy Shevchenko u32 us = DIV_ROUND_UP(ns, NSEC_PER_USEC); 13770ff2de8bSMartin Sperl 13780ff2de8bSMartin Sperl if (us <= 10) 13790ff2de8bSMartin Sperl udelay(us); 13800ff2de8bSMartin Sperl else 13810ff2de8bSMartin Sperl usleep_range(us, us + DIV_ROUND_UP(us, 10)); 13820ff2de8bSMartin Sperl } 13830ff2de8bSMartin Sperl } 13840ff2de8bSMartin Sperl 13853984d39bSAlexandru Ardelean int spi_delay_to_ns(struct spi_delay *_delay, struct spi_transfer *xfer) 13860ff2de8bSMartin Sperl { 1387b2c98153SAlexandru Ardelean u32 delay = _delay->value; 1388b2c98153SAlexandru Ardelean u32 unit = _delay->unit; 1389d5864e5bSMartin Sperl u32 hz; 13900ff2de8bSMartin Sperl 1391b2c98153SAlexandru Ardelean if (!delay) 1392b2c98153SAlexandru Ardelean return 0; 13930ff2de8bSMartin Sperl 13940ff2de8bSMartin Sperl switch (unit) { 13950ff2de8bSMartin Sperl case SPI_DELAY_UNIT_USECS: 139686b8bff7SAndy Shevchenko delay *= NSEC_PER_USEC; 13970ff2de8bSMartin Sperl break; 139886b8bff7SAndy Shevchenko case SPI_DELAY_UNIT_NSECS: 139986b8bff7SAndy Shevchenko /* Nothing to do here */ 14000ff2de8bSMartin Sperl break; 1401d5864e5bSMartin Sperl case SPI_DELAY_UNIT_SCK: 140295c8222fSDavid Jander /* Clock cycles need to be obtained from spi_transfer */ 1403b2c98153SAlexandru Ardelean if (!xfer) 1404b2c98153SAlexandru Ardelean return -EINVAL; 140586b8bff7SAndy Shevchenko /* 140686b8bff7SAndy Shevchenko * If there is unknown effective speed, approximate it 1407702ca026SAndy Shevchenko * by underestimating with half of the requested Hz. 1408d5864e5bSMartin Sperl */ 1409d5864e5bSMartin Sperl hz = xfer->effective_speed_hz ?: xfer->speed_hz / 2; 1410b2c98153SAlexandru Ardelean if (!hz) 1411b2c98153SAlexandru Ardelean return -EINVAL; 141286b8bff7SAndy Shevchenko 141386b8bff7SAndy Shevchenko /* Convert delay to nanoseconds */ 141486b8bff7SAndy Shevchenko delay *= DIV_ROUND_UP(NSEC_PER_SEC, hz); 1415d5864e5bSMartin Sperl break; 14160ff2de8bSMartin Sperl default: 1417b2c98153SAlexandru Ardelean return -EINVAL; 1418b2c98153SAlexandru Ardelean } 1419b2c98153SAlexandru Ardelean 1420b2c98153SAlexandru Ardelean return delay; 1421b2c98153SAlexandru Ardelean } 14223984d39bSAlexandru Ardelean EXPORT_SYMBOL_GPL(spi_delay_to_ns); 1423b2c98153SAlexandru Ardelean 1424b2c98153SAlexandru Ardelean int spi_delay_exec(struct spi_delay *_delay, struct spi_transfer *xfer) 1425b2c98153SAlexandru Ardelean { 1426b2c98153SAlexandru Ardelean int delay; 1427b2c98153SAlexandru Ardelean 14288fede89fSMark Brown might_sleep(); 14298fede89fSMark Brown 1430b2c98153SAlexandru Ardelean if (!_delay) 1431b2c98153SAlexandru Ardelean return -EINVAL; 1432b2c98153SAlexandru Ardelean 14333984d39bSAlexandru Ardelean delay = spi_delay_to_ns(_delay, xfer); 1434b2c98153SAlexandru Ardelean if (delay < 0) 1435b2c98153SAlexandru Ardelean return delay; 1436b2c98153SAlexandru Ardelean 1437b2c98153SAlexandru Ardelean _spi_transfer_delay_ns(delay); 1438b2c98153SAlexandru Ardelean 1439b2c98153SAlexandru Ardelean return 0; 1440b2c98153SAlexandru Ardelean } 1441b2c98153SAlexandru Ardelean EXPORT_SYMBOL_GPL(spi_delay_exec); 1442b2c98153SAlexandru Ardelean 14430ff2de8bSMartin Sperl static void _spi_transfer_cs_change_delay(struct spi_message *msg, 14440ff2de8bSMartin Sperl struct spi_transfer *xfer) 14450ff2de8bSMartin Sperl { 144686b8bff7SAndy Shevchenko u32 default_delay_ns = 10 * NSEC_PER_USEC; 1447329f0dacSAlexandru Ardelean u32 delay = xfer->cs_change_delay.value; 1448329f0dacSAlexandru Ardelean u32 unit = xfer->cs_change_delay.unit; 1449329f0dacSAlexandru Ardelean int ret; 14500ff2de8bSMartin Sperl 145195c8222fSDavid Jander /* Return early on "fast" mode - for everything but USECS */ 14526b3f236aSAlexandru Ardelean if (!delay) { 14536b3f236aSAlexandru Ardelean if (unit == SPI_DELAY_UNIT_USECS) 145486b8bff7SAndy Shevchenko _spi_transfer_delay_ns(default_delay_ns); 14550ff2de8bSMartin Sperl return; 14566b3f236aSAlexandru Ardelean } 14570ff2de8bSMartin Sperl 1458329f0dacSAlexandru Ardelean ret = spi_delay_exec(&xfer->cs_change_delay, xfer); 1459329f0dacSAlexandru Ardelean if (ret) { 14600ff2de8bSMartin Sperl dev_err_once(&msg->spi->dev, 146186b8bff7SAndy Shevchenko "Use of unsupported delay unit %i, using default of %luus\n", 146286b8bff7SAndy Shevchenko unit, default_delay_ns / NSEC_PER_USEC); 146386b8bff7SAndy Shevchenko _spi_transfer_delay_ns(default_delay_ns); 14640ff2de8bSMartin Sperl } 14650ff2de8bSMartin Sperl } 14660ff2de8bSMartin Sperl 14676e80133aSWilliam Zhang void spi_transfer_cs_change_delay_exec(struct spi_message *msg, 14686e80133aSWilliam Zhang struct spi_transfer *xfer) 14696e80133aSWilliam Zhang { 14706e80133aSWilliam Zhang _spi_transfer_cs_change_delay(msg, xfer); 14716e80133aSWilliam Zhang } 14726e80133aSWilliam Zhang EXPORT_SYMBOL_GPL(spi_transfer_cs_change_delay_exec); 14736e80133aSWilliam Zhang 1474b158935fSMark Brown /* 1475b158935fSMark Brown * spi_transfer_one_message - Default implementation of transfer_one_message() 1476b158935fSMark Brown * 1477b158935fSMark Brown * This is a standard implementation of transfer_one_message() for 14788ba811a7SMoritz Fischer * drivers which implement a transfer_one() operation. It provides 1479b158935fSMark Brown * standard handling of delays and chip select management. 1480b158935fSMark Brown */ 14818caab75fSGeert Uytterhoeven static int spi_transfer_one_message(struct spi_controller *ctlr, 1482b158935fSMark Brown struct spi_message *msg) 1483b158935fSMark Brown { 1484b158935fSMark Brown struct spi_transfer *xfer; 1485b158935fSMark Brown bool keep_cs = false; 1486b158935fSMark Brown int ret = 0; 1487d501cc4cSDavid Jander struct spi_statistics __percpu *statm = ctlr->pcpu_statistics; 1488d501cc4cSDavid Jander struct spi_statistics __percpu *stats = msg->spi->pcpu_statistics; 1489b158935fSMark Brown 14905e0531f6SChristophe Leroy xfer = list_first_entry(&msg->transfers, struct spi_transfer, transfer_list); 14915e0531f6SChristophe Leroy spi_set_cs(msg->spi, !xfer->cs_off, false); 1492b158935fSMark Brown 1493eca2ebc7SMartin Sperl SPI_STATISTICS_INCREMENT_FIELD(statm, messages); 1494eca2ebc7SMartin Sperl SPI_STATISTICS_INCREMENT_FIELD(stats, messages); 1495eca2ebc7SMartin Sperl 1496b158935fSMark Brown list_for_each_entry(xfer, &msg->transfers, transfer_list) { 1497b158935fSMark Brown trace_spi_transfer_start(msg, xfer); 1498b158935fSMark Brown 14998caab75fSGeert Uytterhoeven spi_statistics_add_transfer_stats(statm, xfer, ctlr); 15008caab75fSGeert Uytterhoeven spi_statistics_add_transfer_stats(stats, xfer, ctlr); 1501eca2ebc7SMartin Sperl 1502b42faeeeSVladimir Oltean if (!ctlr->ptp_sts_supported) { 1503b42faeeeSVladimir Oltean xfer->ptp_sts_word_pre = 0; 1504b42faeeeSVladimir Oltean ptp_read_system_prets(xfer->ptp_sts); 1505b42faeeeSVladimir Oltean } 1506b42faeeeSVladimir Oltean 1507b3063203SNicolas Saenz Julienne if ((xfer->tx_buf || xfer->rx_buf) && xfer->len) { 15088caab75fSGeert Uytterhoeven reinit_completion(&ctlr->xfer_completion); 1509b158935fSMark Brown 1510809b1b04SRobin Gong fallback_pio: 15110c17ba73SVincent Whitchurch spi_dma_sync_for_device(ctlr, xfer); 15128caab75fSGeert Uytterhoeven ret = ctlr->transfer_one(ctlr, msg->spi, xfer); 1513b158935fSMark Brown if (ret < 0) { 15140c17ba73SVincent Whitchurch spi_dma_sync_for_cpu(ctlr, xfer); 15150c17ba73SVincent Whitchurch 1516809b1b04SRobin Gong if (ctlr->cur_msg_mapped && 1517809b1b04SRobin Gong (xfer->error & SPI_TRANS_FAIL_NO_START)) { 1518809b1b04SRobin Gong __spi_unmap_msg(ctlr, msg); 1519809b1b04SRobin Gong ctlr->fallback = true; 1520809b1b04SRobin Gong xfer->error &= ~SPI_TRANS_FAIL_NO_START; 1521809b1b04SRobin Gong goto fallback_pio; 1522809b1b04SRobin Gong } 1523809b1b04SRobin Gong 1524eca2ebc7SMartin Sperl SPI_STATISTICS_INCREMENT_FIELD(statm, 1525eca2ebc7SMartin Sperl errors); 1526eca2ebc7SMartin Sperl SPI_STATISTICS_INCREMENT_FIELD(stats, 1527eca2ebc7SMartin Sperl errors); 1528b158935fSMark Brown dev_err(&msg->spi->dev, 1529b158935fSMark Brown "SPI transfer failed: %d\n", ret); 1530b158935fSMark Brown goto out; 1531b158935fSMark Brown } 1532b158935fSMark Brown 1533d57e7960SMark Brown if (ret > 0) { 1534810923f3SLubomir Rintel ret = spi_transfer_wait(ctlr, msg, xfer); 1535810923f3SLubomir Rintel if (ret < 0) 1536810923f3SLubomir Rintel msg->status = ret; 1537d57e7960SMark Brown } 15380c17ba73SVincent Whitchurch 15390c17ba73SVincent Whitchurch spi_dma_sync_for_cpu(ctlr, xfer); 154038ec10f6SMark Brown } else { 154138ec10f6SMark Brown if (xfer->len) 154238ec10f6SMark Brown dev_err(&msg->spi->dev, 154338ec10f6SMark Brown "Bufferless transfer has length %u\n", 154438ec10f6SMark Brown xfer->len); 154538ec10f6SMark Brown } 1546b158935fSMark Brown 1547b42faeeeSVladimir Oltean if (!ctlr->ptp_sts_supported) { 1548b42faeeeSVladimir Oltean ptp_read_system_postts(xfer->ptp_sts); 1549b42faeeeSVladimir Oltean xfer->ptp_sts_word_post = xfer->len; 1550b42faeeeSVladimir Oltean } 1551b42faeeeSVladimir Oltean 1552b158935fSMark Brown trace_spi_transfer_stop(msg, xfer); 1553b158935fSMark Brown 1554b158935fSMark Brown if (msg->status != -EINPROGRESS) 1555b158935fSMark Brown goto out; 1556b158935fSMark Brown 1557bebcfd27SAlexandru Ardelean spi_transfer_delay_exec(xfer); 1558b158935fSMark Brown 1559b158935fSMark Brown if (xfer->cs_change) { 1560b158935fSMark Brown if (list_is_last(&xfer->transfer_list, 1561b158935fSMark Brown &msg->transfers)) { 1562b158935fSMark Brown keep_cs = true; 1563b158935fSMark Brown } else { 15645e0531f6SChristophe Leroy if (!xfer->cs_off) 1565d347b4aaSDavid Bauer spi_set_cs(msg->spi, false, false); 15660ff2de8bSMartin Sperl _spi_transfer_cs_change_delay(msg, xfer); 15675e0531f6SChristophe Leroy if (!list_next_entry(xfer, transfer_list)->cs_off) 1568d347b4aaSDavid Bauer spi_set_cs(msg->spi, true, false); 1569b158935fSMark Brown } 15705e0531f6SChristophe Leroy } else if (!list_is_last(&xfer->transfer_list, &msg->transfers) && 15715e0531f6SChristophe Leroy xfer->cs_off != list_next_entry(xfer, transfer_list)->cs_off) { 15725e0531f6SChristophe Leroy spi_set_cs(msg->spi, xfer->cs_off, false); 1573b158935fSMark Brown } 1574b158935fSMark Brown 1575b158935fSMark Brown msg->actual_length += xfer->len; 1576b158935fSMark Brown } 1577b158935fSMark Brown 1578b158935fSMark Brown out: 1579b158935fSMark Brown if (ret != 0 || !keep_cs) 1580d347b4aaSDavid Bauer spi_set_cs(msg->spi, false, false); 1581b158935fSMark Brown 1582b158935fSMark Brown if (msg->status == -EINPROGRESS) 1583b158935fSMark Brown msg->status = ret; 1584b158935fSMark Brown 15858caab75fSGeert Uytterhoeven if (msg->status && ctlr->handle_err) 15868caab75fSGeert Uytterhoeven ctlr->handle_err(ctlr, msg); 1587b716c4ffSAndy Shevchenko 15880ed56252SMark Brown spi_finalize_current_message(ctlr); 15890ed56252SMark Brown 1590b158935fSMark Brown return ret; 1591b158935fSMark Brown } 1592b158935fSMark Brown 1593b158935fSMark Brown /** 1594b158935fSMark Brown * spi_finalize_current_transfer - report completion of a transfer 15958caab75fSGeert Uytterhoeven * @ctlr: the controller reporting completion 1596b158935fSMark Brown * 1597b158935fSMark Brown * Called by SPI drivers using the core transfer_one_message() 1598b158935fSMark Brown * implementation to notify it that the current interrupt driven 15999e8f4882SGeert Uytterhoeven * transfer has finished and the next one may be scheduled. 1600b158935fSMark Brown */ 16018caab75fSGeert Uytterhoeven void spi_finalize_current_transfer(struct spi_controller *ctlr) 1602b158935fSMark Brown { 16038caab75fSGeert Uytterhoeven complete(&ctlr->xfer_completion); 1604b158935fSMark Brown } 1605b158935fSMark Brown EXPORT_SYMBOL_GPL(spi_finalize_current_transfer); 1606b158935fSMark Brown 1607e1268597SMark Brown static void spi_idle_runtime_pm(struct spi_controller *ctlr) 1608e1268597SMark Brown { 1609e1268597SMark Brown if (ctlr->auto_runtime_pm) { 1610e1268597SMark Brown pm_runtime_mark_last_busy(ctlr->dev.parent); 1611e1268597SMark Brown pm_runtime_put_autosuspend(ctlr->dev.parent); 1612e1268597SMark Brown } 1613e1268597SMark Brown } 1614e1268597SMark Brown 1615ae7d2346SDavid Jander static int __spi_pump_transfer_message(struct spi_controller *ctlr, 1616ae7d2346SDavid Jander struct spi_message *msg, bool was_busy) 1617ae7d2346SDavid Jander { 1618ae7d2346SDavid Jander struct spi_transfer *xfer; 1619ae7d2346SDavid Jander int ret; 1620ae7d2346SDavid Jander 1621ae7d2346SDavid Jander if (!was_busy && ctlr->auto_runtime_pm) { 1622ae7d2346SDavid Jander ret = pm_runtime_get_sync(ctlr->dev.parent); 1623ae7d2346SDavid Jander if (ret < 0) { 1624ae7d2346SDavid Jander pm_runtime_put_noidle(ctlr->dev.parent); 1625ae7d2346SDavid Jander dev_err(&ctlr->dev, "Failed to power device: %d\n", 1626ae7d2346SDavid Jander ret); 1627ae7d2346SDavid Jander return ret; 1628ae7d2346SDavid Jander } 1629ae7d2346SDavid Jander } 1630ae7d2346SDavid Jander 1631ae7d2346SDavid Jander if (!was_busy) 1632ae7d2346SDavid Jander trace_spi_controller_busy(ctlr); 1633ae7d2346SDavid Jander 1634ae7d2346SDavid Jander if (!was_busy && ctlr->prepare_transfer_hardware) { 1635ae7d2346SDavid Jander ret = ctlr->prepare_transfer_hardware(ctlr); 1636ae7d2346SDavid Jander if (ret) { 1637ae7d2346SDavid Jander dev_err(&ctlr->dev, 1638ae7d2346SDavid Jander "failed to prepare transfer hardware: %d\n", 1639ae7d2346SDavid Jander ret); 1640ae7d2346SDavid Jander 1641ae7d2346SDavid Jander if (ctlr->auto_runtime_pm) 1642ae7d2346SDavid Jander pm_runtime_put(ctlr->dev.parent); 1643ae7d2346SDavid Jander 1644ae7d2346SDavid Jander msg->status = ret; 1645ae7d2346SDavid Jander spi_finalize_current_message(ctlr); 1646ae7d2346SDavid Jander 1647ae7d2346SDavid Jander return ret; 1648ae7d2346SDavid Jander } 1649ae7d2346SDavid Jander } 1650ae7d2346SDavid Jander 1651ae7d2346SDavid Jander trace_spi_message_start(msg); 1652ae7d2346SDavid Jander 16538d699ff9SVincent Whitchurch ret = spi_split_transfers_maxsize(ctlr, msg, 16548d699ff9SVincent Whitchurch spi_max_transfer_size(msg->spi), 16558d699ff9SVincent Whitchurch GFP_KERNEL | GFP_DMA); 16568d699ff9SVincent Whitchurch if (ret) { 16578d699ff9SVincent Whitchurch msg->status = ret; 16588d699ff9SVincent Whitchurch spi_finalize_current_message(ctlr); 16598d699ff9SVincent Whitchurch return ret; 16608d699ff9SVincent Whitchurch } 16618d699ff9SVincent Whitchurch 1662ae7d2346SDavid Jander if (ctlr->prepare_message) { 1663ae7d2346SDavid Jander ret = ctlr->prepare_message(ctlr, msg); 1664ae7d2346SDavid Jander if (ret) { 1665ae7d2346SDavid Jander dev_err(&ctlr->dev, "failed to prepare message: %d\n", 1666ae7d2346SDavid Jander ret); 1667ae7d2346SDavid Jander msg->status = ret; 1668ae7d2346SDavid Jander spi_finalize_current_message(ctlr); 1669ae7d2346SDavid Jander return ret; 1670ae7d2346SDavid Jander } 1671ae7d2346SDavid Jander msg->prepared = true; 1672ae7d2346SDavid Jander } 1673ae7d2346SDavid Jander 1674ae7d2346SDavid Jander ret = spi_map_msg(ctlr, msg); 1675ae7d2346SDavid Jander if (ret) { 1676ae7d2346SDavid Jander msg->status = ret; 1677ae7d2346SDavid Jander spi_finalize_current_message(ctlr); 1678ae7d2346SDavid Jander return ret; 1679ae7d2346SDavid Jander } 1680ae7d2346SDavid Jander 1681ae7d2346SDavid Jander if (!ctlr->ptp_sts_supported && !ctlr->transfer_one) { 1682ae7d2346SDavid Jander list_for_each_entry(xfer, &msg->transfers, transfer_list) { 1683ae7d2346SDavid Jander xfer->ptp_sts_word_pre = 0; 1684ae7d2346SDavid Jander ptp_read_system_prets(xfer->ptp_sts); 1685ae7d2346SDavid Jander } 1686ae7d2346SDavid Jander } 1687ae7d2346SDavid Jander 1688dc302905SDavid Jander /* 1689dc302905SDavid Jander * Drivers implementation of transfer_one_message() must arrange for 1690dc302905SDavid Jander * spi_finalize_current_message() to get called. Most drivers will do 1691dc302905SDavid Jander * this in the calling context, but some don't. For those cases, a 1692dc302905SDavid Jander * completion is used to guarantee that this function does not return 1693dc302905SDavid Jander * until spi_finalize_current_message() is done accessing 1694dc302905SDavid Jander * ctlr->cur_msg. 1695dc302905SDavid Jander * Use of the following two flags enable to opportunistically skip the 1696dc302905SDavid Jander * use of the completion since its use involves expensive spin locks. 1697dc302905SDavid Jander * In case of a race with the context that calls 1698dc302905SDavid Jander * spi_finalize_current_message() the completion will always be used, 1699dc302905SDavid Jander * due to strict ordering of these flags using barriers. 1700dc302905SDavid Jander */ 1701dc302905SDavid Jander WRITE_ONCE(ctlr->cur_msg_incomplete, true); 1702dc302905SDavid Jander WRITE_ONCE(ctlr->cur_msg_need_completion, false); 170369fa9590SDavid Jander reinit_completion(&ctlr->cur_msg_completion); 170495c8222fSDavid Jander smp_wmb(); /* Make these available to spi_finalize_current_message() */ 1705dc302905SDavid Jander 1706ae7d2346SDavid Jander ret = ctlr->transfer_one_message(ctlr, msg); 1707ae7d2346SDavid Jander if (ret) { 1708ae7d2346SDavid Jander dev_err(&ctlr->dev, 1709ae7d2346SDavid Jander "failed to transfer one message from queue\n"); 1710ae7d2346SDavid Jander return ret; 171131d4c1bdSDavid Jander } 171231d4c1bdSDavid Jander 1713dc302905SDavid Jander WRITE_ONCE(ctlr->cur_msg_need_completion, true); 171431d4c1bdSDavid Jander smp_mb(); /* See spi_finalize_current_message()... */ 1715dc302905SDavid Jander if (READ_ONCE(ctlr->cur_msg_incomplete)) 171669fa9590SDavid Jander wait_for_completion(&ctlr->cur_msg_completion); 1717ae7d2346SDavid Jander 1718ae7d2346SDavid Jander return 0; 1719ae7d2346SDavid Jander } 1720ae7d2346SDavid Jander 1721ffbbdd21SLinus Walleij /** 1722702ca026SAndy Shevchenko * __spi_pump_messages - function which processes SPI message queue 17238caab75fSGeert Uytterhoeven * @ctlr: controller to process queue for 1724fc9e0f71SMark Brown * @in_kthread: true if we are in the context of the message pump thread 1725ffbbdd21SLinus Walleij * 1726702ca026SAndy Shevchenko * This function checks if there is any SPI message in the queue that 1727ffbbdd21SLinus Walleij * needs processing and if so call out to the driver to initialize hardware 1728ffbbdd21SLinus Walleij * and transfer each message. 1729ffbbdd21SLinus Walleij * 17300461a414SMark Brown * Note that it is called both from the kthread itself and also from 17310461a414SMark Brown * inside spi_sync(); the queue extraction handling at the top of the 17320461a414SMark Brown * function should deal with this safely. 1733ffbbdd21SLinus Walleij */ 17348caab75fSGeert Uytterhoeven static void __spi_pump_messages(struct spi_controller *ctlr, bool in_kthread) 1735ffbbdd21SLinus Walleij { 1736d1c44c93SVladimir Oltean struct spi_message *msg; 1737ffbbdd21SLinus Walleij bool was_busy = false; 1738d1c44c93SVladimir Oltean unsigned long flags; 1739ffbbdd21SLinus Walleij int ret; 1740ffbbdd21SLinus Walleij 1741702ca026SAndy Shevchenko /* Take the I/O mutex */ 1742c1038165SDavid Jander mutex_lock(&ctlr->io_mutex); 1743c1038165SDavid Jander 1744983aee5dSMark Brown /* Lock queue */ 17458caab75fSGeert Uytterhoeven spin_lock_irqsave(&ctlr->queue_lock, flags); 1746983aee5dSMark Brown 1747983aee5dSMark Brown /* Make sure we are not already running a message */ 17488711a2abSDavid Jander if (ctlr->cur_msg) 1749c1038165SDavid Jander goto out_unlock; 1750983aee5dSMark Brown 1751983aee5dSMark Brown /* Check if the queue is idle */ 17528caab75fSGeert Uytterhoeven if (list_empty(&ctlr->queue) || !ctlr->running) { 17538711a2abSDavid Jander if (!ctlr->busy) 1754c1038165SDavid Jander goto out_unlock; 1755fc9e0f71SMark Brown 1756e1268597SMark Brown /* Defer any non-atomic teardown to the thread */ 1757f0125f1aSMark Brown if (!in_kthread) { 1758e1268597SMark Brown if (!ctlr->dummy_rx && !ctlr->dummy_tx && 1759e1268597SMark Brown !ctlr->unprepare_transfer_hardware) { 1760e1268597SMark Brown spi_idle_runtime_pm(ctlr); 1761e1268597SMark Brown ctlr->busy = false; 1762ae7d2346SDavid Jander ctlr->queue_empty = true; 1763e1268597SMark Brown trace_spi_controller_idle(ctlr); 1764e1268597SMark Brown } else { 176560a883d1SMarek Szyprowski kthread_queue_work(ctlr->kworker, 1766f0125f1aSMark Brown &ctlr->pump_messages); 1767e1268597SMark Brown } 1768c1038165SDavid Jander goto out_unlock; 1769f0125f1aSMark Brown } 1770f0125f1aSMark Brown 1771f0125f1aSMark Brown ctlr->busy = false; 1772f0125f1aSMark Brown spin_unlock_irqrestore(&ctlr->queue_lock, flags); 1773f0125f1aSMark Brown 1774f0125f1aSMark Brown kfree(ctlr->dummy_rx); 1775f0125f1aSMark Brown ctlr->dummy_rx = NULL; 1776f0125f1aSMark Brown kfree(ctlr->dummy_tx); 1777f0125f1aSMark Brown ctlr->dummy_tx = NULL; 1778f0125f1aSMark Brown if (ctlr->unprepare_transfer_hardware && 1779f0125f1aSMark Brown ctlr->unprepare_transfer_hardware(ctlr)) 1780f0125f1aSMark Brown dev_err(&ctlr->dev, 1781f0125f1aSMark Brown "failed to unprepare transfer hardware\n"); 1782e1268597SMark Brown spi_idle_runtime_pm(ctlr); 1783f0125f1aSMark Brown trace_spi_controller_idle(ctlr); 1784f0125f1aSMark Brown 1785f0125f1aSMark Brown spin_lock_irqsave(&ctlr->queue_lock, flags); 1786ae7d2346SDavid Jander ctlr->queue_empty = true; 1787c1038165SDavid Jander goto out_unlock; 1788ffbbdd21SLinus Walleij } 1789ffbbdd21SLinus Walleij 1790ffbbdd21SLinus Walleij /* Extract head of queue */ 1791d1c44c93SVladimir Oltean msg = list_first_entry(&ctlr->queue, struct spi_message, queue); 1792d1c44c93SVladimir Oltean ctlr->cur_msg = msg; 1793ffbbdd21SLinus Walleij 1794d1c44c93SVladimir Oltean list_del_init(&msg->queue); 17958caab75fSGeert Uytterhoeven if (ctlr->busy) 1796ffbbdd21SLinus Walleij was_busy = true; 1797ffbbdd21SLinus Walleij else 17988caab75fSGeert Uytterhoeven ctlr->busy = true; 17998caab75fSGeert Uytterhoeven spin_unlock_irqrestore(&ctlr->queue_lock, flags); 1800ffbbdd21SLinus Walleij 1801ae7d2346SDavid Jander ret = __spi_pump_transfer_message(ctlr, msg, was_busy); 180269fa9590SDavid Jander kthread_queue_work(ctlr->kworker, &ctlr->pump_messages); 1803c191543eSDavid Jander 180469fa9590SDavid Jander ctlr->cur_msg = NULL; 180569fa9590SDavid Jander ctlr->fallback = false; 180669fa9590SDavid Jander 18078caab75fSGeert Uytterhoeven mutex_unlock(&ctlr->io_mutex); 180862826970SMark Brown 180962826970SMark Brown /* Prod the scheduler in case transfer_one() was busy waiting */ 181049023d2eSJon Hunter if (!ret) 181162826970SMark Brown cond_resched(); 1812c1038165SDavid Jander return; 1813c1038165SDavid Jander 1814c1038165SDavid Jander out_unlock: 18158711a2abSDavid Jander spin_unlock_irqrestore(&ctlr->queue_lock, flags); 1816c1038165SDavid Jander mutex_unlock(&ctlr->io_mutex); 1817ffbbdd21SLinus Walleij } 1818ffbbdd21SLinus Walleij 1819fc9e0f71SMark Brown /** 1820fc9e0f71SMark Brown * spi_pump_messages - kthread work function which processes spi message queue 18218caab75fSGeert Uytterhoeven * @work: pointer to kthread work struct contained in the controller struct 1822fc9e0f71SMark Brown */ 1823fc9e0f71SMark Brown static void spi_pump_messages(struct kthread_work *work) 1824fc9e0f71SMark Brown { 18258caab75fSGeert Uytterhoeven struct spi_controller *ctlr = 18268caab75fSGeert Uytterhoeven container_of(work, struct spi_controller, pump_messages); 1827fc9e0f71SMark Brown 18288caab75fSGeert Uytterhoeven __spi_pump_messages(ctlr, true); 1829fc9e0f71SMark Brown } 1830fc9e0f71SMark Brown 1831924b5867SDouglas Anderson /** 1832350de7ceSAndy Shevchenko * spi_take_timestamp_pre - helper to collect the beginning of the TX timestamp 1833b42faeeeSVladimir Oltean * @ctlr: Pointer to the spi_controller structure of the driver 1834b42faeeeSVladimir Oltean * @xfer: Pointer to the transfer being timestamped 1835862dd2a9SVladimir Oltean * @progress: How many words (not bytes) have been transferred so far 1836b42faeeeSVladimir Oltean * @irqs_off: If true, will disable IRQs and preemption for the duration of the 1837b42faeeeSVladimir Oltean * transfer, for less jitter in time measurement. Only compatible 1838b42faeeeSVladimir Oltean * with PIO drivers. If true, must follow up with 1839b42faeeeSVladimir Oltean * spi_take_timestamp_post or otherwise system will crash. 1840b42faeeeSVladimir Oltean * WARNING: for fully predictable results, the CPU frequency must 1841b42faeeeSVladimir Oltean * also be under control (governor). 1842350de7ceSAndy Shevchenko * 1843350de7ceSAndy Shevchenko * This is a helper for drivers to collect the beginning of the TX timestamp 1844350de7ceSAndy Shevchenko * for the requested byte from the SPI transfer. The frequency with which this 1845350de7ceSAndy Shevchenko * function must be called (once per word, once for the whole transfer, once 1846350de7ceSAndy Shevchenko * per batch of words etc) is arbitrary as long as the @tx buffer offset is 1847350de7ceSAndy Shevchenko * greater than or equal to the requested byte at the time of the call. The 1848350de7ceSAndy Shevchenko * timestamp is only taken once, at the first such call. It is assumed that 1849350de7ceSAndy Shevchenko * the driver advances its @tx buffer pointer monotonically. 1850b42faeeeSVladimir Oltean */ 1851b42faeeeSVladimir Oltean void spi_take_timestamp_pre(struct spi_controller *ctlr, 1852b42faeeeSVladimir Oltean struct spi_transfer *xfer, 1853862dd2a9SVladimir Oltean size_t progress, bool irqs_off) 1854b42faeeeSVladimir Oltean { 1855b42faeeeSVladimir Oltean if (!xfer->ptp_sts) 1856b42faeeeSVladimir Oltean return; 1857b42faeeeSVladimir Oltean 18586a726824SVladimir Oltean if (xfer->timestamped) 1859b42faeeeSVladimir Oltean return; 1860b42faeeeSVladimir Oltean 18616a726824SVladimir Oltean if (progress > xfer->ptp_sts_word_pre) 1862b42faeeeSVladimir Oltean return; 1863b42faeeeSVladimir Oltean 1864b42faeeeSVladimir Oltean /* Capture the resolution of the timestamp */ 1865862dd2a9SVladimir Oltean xfer->ptp_sts_word_pre = progress; 1866b42faeeeSVladimir Oltean 1867b42faeeeSVladimir Oltean if (irqs_off) { 1868b42faeeeSVladimir Oltean local_irq_save(ctlr->irq_flags); 1869b42faeeeSVladimir Oltean preempt_disable(); 1870b42faeeeSVladimir Oltean } 1871b42faeeeSVladimir Oltean 1872b42faeeeSVladimir Oltean ptp_read_system_prets(xfer->ptp_sts); 1873b42faeeeSVladimir Oltean } 1874b42faeeeSVladimir Oltean EXPORT_SYMBOL_GPL(spi_take_timestamp_pre); 1875b42faeeeSVladimir Oltean 1876b42faeeeSVladimir Oltean /** 1877350de7ceSAndy Shevchenko * spi_take_timestamp_post - helper to collect the end of the TX timestamp 1878b42faeeeSVladimir Oltean * @ctlr: Pointer to the spi_controller structure of the driver 1879b42faeeeSVladimir Oltean * @xfer: Pointer to the transfer being timestamped 1880862dd2a9SVladimir Oltean * @progress: How many words (not bytes) have been transferred so far 1881b42faeeeSVladimir Oltean * @irqs_off: If true, will re-enable IRQs and preemption for the local CPU. 1882350de7ceSAndy Shevchenko * 1883350de7ceSAndy Shevchenko * This is a helper for drivers to collect the end of the TX timestamp for 1884350de7ceSAndy Shevchenko * the requested byte from the SPI transfer. Can be called with an arbitrary 1885350de7ceSAndy Shevchenko * frequency: only the first call where @tx exceeds or is equal to the 1886350de7ceSAndy Shevchenko * requested word will be timestamped. 1887b42faeeeSVladimir Oltean */ 1888b42faeeeSVladimir Oltean void spi_take_timestamp_post(struct spi_controller *ctlr, 1889b42faeeeSVladimir Oltean struct spi_transfer *xfer, 1890862dd2a9SVladimir Oltean size_t progress, bool irqs_off) 1891b42faeeeSVladimir Oltean { 1892b42faeeeSVladimir Oltean if (!xfer->ptp_sts) 1893b42faeeeSVladimir Oltean return; 1894b42faeeeSVladimir Oltean 18956a726824SVladimir Oltean if (xfer->timestamped) 1896b42faeeeSVladimir Oltean return; 1897b42faeeeSVladimir Oltean 1898862dd2a9SVladimir Oltean if (progress < xfer->ptp_sts_word_post) 1899b42faeeeSVladimir Oltean return; 1900b42faeeeSVladimir Oltean 1901b42faeeeSVladimir Oltean ptp_read_system_postts(xfer->ptp_sts); 1902b42faeeeSVladimir Oltean 1903b42faeeeSVladimir Oltean if (irqs_off) { 1904b42faeeeSVladimir Oltean local_irq_restore(ctlr->irq_flags); 1905b42faeeeSVladimir Oltean preempt_enable(); 1906b42faeeeSVladimir Oltean } 1907b42faeeeSVladimir Oltean 1908b42faeeeSVladimir Oltean /* Capture the resolution of the timestamp */ 1909862dd2a9SVladimir Oltean xfer->ptp_sts_word_post = progress; 1910b42faeeeSVladimir Oltean 19119d77522bSChristophe JAILLET xfer->timestamped = 1; 1912b42faeeeSVladimir Oltean } 1913b42faeeeSVladimir Oltean EXPORT_SYMBOL_GPL(spi_take_timestamp_post); 1914b42faeeeSVladimir Oltean 1915b42faeeeSVladimir Oltean /** 1916924b5867SDouglas Anderson * spi_set_thread_rt - set the controller to pump at realtime priority 1917924b5867SDouglas Anderson * @ctlr: controller to boost priority of 1918924b5867SDouglas Anderson * 1919924b5867SDouglas Anderson * This can be called because the controller requested realtime priority 1920924b5867SDouglas Anderson * (by setting the ->rt value before calling spi_register_controller()) or 1921924b5867SDouglas Anderson * because a device on the bus said that its transfers needed realtime 1922924b5867SDouglas Anderson * priority. 1923924b5867SDouglas Anderson * 1924924b5867SDouglas Anderson * NOTE: at the moment if any device on a bus says it needs realtime then 1925924b5867SDouglas Anderson * the thread will be at realtime priority for all transfers on that 1926924b5867SDouglas Anderson * controller. If this eventually becomes a problem we may see if we can 1927924b5867SDouglas Anderson * find a way to boost the priority only temporarily during relevant 1928924b5867SDouglas Anderson * transfers. 1929924b5867SDouglas Anderson */ 1930924b5867SDouglas Anderson static void spi_set_thread_rt(struct spi_controller *ctlr) 1931ffbbdd21SLinus Walleij { 1932924b5867SDouglas Anderson dev_info(&ctlr->dev, 1933924b5867SDouglas Anderson "will run message pump with realtime priority\n"); 19346d2b84a4SLinus Torvalds sched_set_fifo(ctlr->kworker->task); 1935924b5867SDouglas Anderson } 1936924b5867SDouglas Anderson 1937924b5867SDouglas Anderson static int spi_init_queue(struct spi_controller *ctlr) 1938924b5867SDouglas Anderson { 19398caab75fSGeert Uytterhoeven ctlr->running = false; 19408caab75fSGeert Uytterhoeven ctlr->busy = false; 1941ae7d2346SDavid Jander ctlr->queue_empty = true; 1942ffbbdd21SLinus Walleij 194360a883d1SMarek Szyprowski ctlr->kworker = kthread_create_worker(0, dev_name(&ctlr->dev)); 194460a883d1SMarek Szyprowski if (IS_ERR(ctlr->kworker)) { 194560a883d1SMarek Szyprowski dev_err(&ctlr->dev, "failed to create message pump kworker\n"); 194660a883d1SMarek Szyprowski return PTR_ERR(ctlr->kworker); 1947ffbbdd21SLinus Walleij } 194860a883d1SMarek Szyprowski 19498caab75fSGeert Uytterhoeven kthread_init_work(&ctlr->pump_messages, spi_pump_messages); 1950f0125f1aSMark Brown 1951ffbbdd21SLinus Walleij /* 19528caab75fSGeert Uytterhoeven * Controller config will indicate if this controller should run the 1953ffbbdd21SLinus Walleij * message pump with high (realtime) priority to reduce the transfer 1954ffbbdd21SLinus Walleij * latency on the bus by minimising the delay between a transfer 1955ffbbdd21SLinus Walleij * request and the scheduling of the message pump thread. Without this 1956ffbbdd21SLinus Walleij * setting the message pump thread will remain at default priority. 1957ffbbdd21SLinus Walleij */ 1958924b5867SDouglas Anderson if (ctlr->rt) 1959924b5867SDouglas Anderson spi_set_thread_rt(ctlr); 1960ffbbdd21SLinus Walleij 1961ffbbdd21SLinus Walleij return 0; 1962ffbbdd21SLinus Walleij } 1963ffbbdd21SLinus Walleij 1964ffbbdd21SLinus Walleij /** 1965ffbbdd21SLinus Walleij * spi_get_next_queued_message() - called by driver to check for queued 1966ffbbdd21SLinus Walleij * messages 19678caab75fSGeert Uytterhoeven * @ctlr: the controller to check for queued messages 1968ffbbdd21SLinus Walleij * 1969ffbbdd21SLinus Walleij * If there are more messages in the queue, the next message is returned from 1970ffbbdd21SLinus Walleij * this call. 197197d56dc6SJavier Martinez Canillas * 197297d56dc6SJavier Martinez Canillas * Return: the next message in the queue, else NULL if the queue is empty. 1973ffbbdd21SLinus Walleij */ 19748caab75fSGeert Uytterhoeven struct spi_message *spi_get_next_queued_message(struct spi_controller *ctlr) 1975ffbbdd21SLinus Walleij { 1976ffbbdd21SLinus Walleij struct spi_message *next; 1977ffbbdd21SLinus Walleij unsigned long flags; 1978ffbbdd21SLinus Walleij 197995c8222fSDavid Jander /* Get a pointer to the next message, if any */ 19808caab75fSGeert Uytterhoeven spin_lock_irqsave(&ctlr->queue_lock, flags); 19818caab75fSGeert Uytterhoeven next = list_first_entry_or_null(&ctlr->queue, struct spi_message, 19821cfd97f9SAxel Lin queue); 19838caab75fSGeert Uytterhoeven spin_unlock_irqrestore(&ctlr->queue_lock, flags); 1984ffbbdd21SLinus Walleij 1985ffbbdd21SLinus Walleij return next; 1986ffbbdd21SLinus Walleij } 1987ffbbdd21SLinus Walleij EXPORT_SYMBOL_GPL(spi_get_next_queued_message); 1988ffbbdd21SLinus Walleij 1989ffbbdd21SLinus Walleij /** 1990ffbbdd21SLinus Walleij * spi_finalize_current_message() - the current message is complete 19918caab75fSGeert Uytterhoeven * @ctlr: the controller to return the message to 1992ffbbdd21SLinus Walleij * 1993ffbbdd21SLinus Walleij * Called by the driver to notify the core that the message in the front of the 1994ffbbdd21SLinus Walleij * queue is complete and can be removed from the queue. 1995ffbbdd21SLinus Walleij */ 19968caab75fSGeert Uytterhoeven void spi_finalize_current_message(struct spi_controller *ctlr) 1997ffbbdd21SLinus Walleij { 1998b42faeeeSVladimir Oltean struct spi_transfer *xfer; 1999ffbbdd21SLinus Walleij struct spi_message *mesg; 20002841a5fcSMark Brown int ret; 2001ffbbdd21SLinus Walleij 20028caab75fSGeert Uytterhoeven mesg = ctlr->cur_msg; 2003ffbbdd21SLinus Walleij 2004b42faeeeSVladimir Oltean if (!ctlr->ptp_sts_supported && !ctlr->transfer_one) { 2005b42faeeeSVladimir Oltean list_for_each_entry(xfer, &mesg->transfers, transfer_list) { 2006b42faeeeSVladimir Oltean ptp_read_system_postts(xfer->ptp_sts); 2007b42faeeeSVladimir Oltean xfer->ptp_sts_word_post = xfer->len; 2008b42faeeeSVladimir Oltean } 2009b42faeeeSVladimir Oltean } 2010b42faeeeSVladimir Oltean 20116a726824SVladimir Oltean if (unlikely(ctlr->ptp_sts_supported)) 20126a726824SVladimir Oltean list_for_each_entry(xfer, &mesg->transfers, transfer_list) 20136a726824SVladimir Oltean WARN_ON_ONCE(xfer->ptp_sts && !xfer->timestamped); 2014f971a207SVladimir Oltean 20158caab75fSGeert Uytterhoeven spi_unmap_msg(ctlr, mesg); 201699adef31SMark Brown 2017350de7ceSAndy Shevchenko /* 2018350de7ceSAndy Shevchenko * In the prepare_messages callback the SPI bus has the opportunity 2019350de7ceSAndy Shevchenko * to split a transfer to smaller chunks. 2020350de7ceSAndy Shevchenko * 2021350de7ceSAndy Shevchenko * Release the split transfers here since spi_map_msg() is done on 2022350de7ceSAndy Shevchenko * the split transfers. 2023b59a7ca1SGustav Wiklander */ 2024b59a7ca1SGustav Wiklander spi_res_release(ctlr, mesg); 2025b59a7ca1SGustav Wiklander 20261714582aSDavid Jander if (mesg->prepared && ctlr->unprepare_message) { 20278caab75fSGeert Uytterhoeven ret = ctlr->unprepare_message(ctlr, mesg); 20282841a5fcSMark Brown if (ret) { 20298caab75fSGeert Uytterhoeven dev_err(&ctlr->dev, "failed to unprepare message: %d\n", 20308caab75fSGeert Uytterhoeven ret); 20312841a5fcSMark Brown } 20322841a5fcSMark Brown } 2033391949b6SUwe Kleine-König 20341714582aSDavid Jander mesg->prepared = false; 20351714582aSDavid Jander 2036dc302905SDavid Jander WRITE_ONCE(ctlr->cur_msg_incomplete, false); 2037dc302905SDavid Jander smp_mb(); /* See __spi_pump_transfer_message()... */ 2038dc302905SDavid Jander if (READ_ONCE(ctlr->cur_msg_need_completion)) 203969fa9590SDavid Jander complete(&ctlr->cur_msg_completion); 20408e76ef88SMartin Sperl 20418e76ef88SMartin Sperl trace_spi_message_done(mesg); 20422841a5fcSMark Brown 2043ffbbdd21SLinus Walleij mesg->state = NULL; 2044ffbbdd21SLinus Walleij if (mesg->complete) 2045ffbbdd21SLinus Walleij mesg->complete(mesg->context); 2046ffbbdd21SLinus Walleij } 2047ffbbdd21SLinus Walleij EXPORT_SYMBOL_GPL(spi_finalize_current_message); 2048ffbbdd21SLinus Walleij 20498caab75fSGeert Uytterhoeven static int spi_start_queue(struct spi_controller *ctlr) 2050ffbbdd21SLinus Walleij { 2051ffbbdd21SLinus Walleij unsigned long flags; 2052ffbbdd21SLinus Walleij 20538caab75fSGeert Uytterhoeven spin_lock_irqsave(&ctlr->queue_lock, flags); 2054ffbbdd21SLinus Walleij 20558caab75fSGeert Uytterhoeven if (ctlr->running || ctlr->busy) { 20568caab75fSGeert Uytterhoeven spin_unlock_irqrestore(&ctlr->queue_lock, flags); 2057ffbbdd21SLinus Walleij return -EBUSY; 2058ffbbdd21SLinus Walleij } 2059ffbbdd21SLinus Walleij 20608caab75fSGeert Uytterhoeven ctlr->running = true; 20618caab75fSGeert Uytterhoeven ctlr->cur_msg = NULL; 20628caab75fSGeert Uytterhoeven spin_unlock_irqrestore(&ctlr->queue_lock, flags); 2063ffbbdd21SLinus Walleij 206460a883d1SMarek Szyprowski kthread_queue_work(ctlr->kworker, &ctlr->pump_messages); 2065ffbbdd21SLinus Walleij 2066ffbbdd21SLinus Walleij return 0; 2067ffbbdd21SLinus Walleij } 2068ffbbdd21SLinus Walleij 20698caab75fSGeert Uytterhoeven static int spi_stop_queue(struct spi_controller *ctlr) 2070ffbbdd21SLinus Walleij { 2071ffbbdd21SLinus Walleij unsigned long flags; 2072ffbbdd21SLinus Walleij unsigned limit = 500; 2073ffbbdd21SLinus Walleij int ret = 0; 2074ffbbdd21SLinus Walleij 20758caab75fSGeert Uytterhoeven spin_lock_irqsave(&ctlr->queue_lock, flags); 2076ffbbdd21SLinus Walleij 2077ffbbdd21SLinus Walleij /* 2078ffbbdd21SLinus Walleij * This is a bit lame, but is optimized for the common execution path. 20798caab75fSGeert Uytterhoeven * A wait_queue on the ctlr->busy could be used, but then the common 2080ffbbdd21SLinus Walleij * execution path (pump_messages) would be required to call wake_up or 2081ffbbdd21SLinus Walleij * friends on every SPI message. Do this instead. 2082ffbbdd21SLinus Walleij */ 20838caab75fSGeert Uytterhoeven while ((!list_empty(&ctlr->queue) || ctlr->busy) && limit--) { 20848caab75fSGeert Uytterhoeven spin_unlock_irqrestore(&ctlr->queue_lock, flags); 2085f97b26b0SAxel Lin usleep_range(10000, 11000); 20868caab75fSGeert Uytterhoeven spin_lock_irqsave(&ctlr->queue_lock, flags); 2087ffbbdd21SLinus Walleij } 2088ffbbdd21SLinus Walleij 20898caab75fSGeert Uytterhoeven if (!list_empty(&ctlr->queue) || ctlr->busy) 2090ffbbdd21SLinus Walleij ret = -EBUSY; 2091ffbbdd21SLinus Walleij else 20928caab75fSGeert Uytterhoeven ctlr->running = false; 2093ffbbdd21SLinus Walleij 20948caab75fSGeert Uytterhoeven spin_unlock_irqrestore(&ctlr->queue_lock, flags); 2095ffbbdd21SLinus Walleij 2096ffbbdd21SLinus Walleij if (ret) { 20978caab75fSGeert Uytterhoeven dev_warn(&ctlr->dev, "could not stop message queue\n"); 2098ffbbdd21SLinus Walleij return ret; 2099ffbbdd21SLinus Walleij } 2100ffbbdd21SLinus Walleij return ret; 2101ffbbdd21SLinus Walleij } 2102ffbbdd21SLinus Walleij 21038caab75fSGeert Uytterhoeven static int spi_destroy_queue(struct spi_controller *ctlr) 2104ffbbdd21SLinus Walleij { 2105ffbbdd21SLinus Walleij int ret; 2106ffbbdd21SLinus Walleij 21078caab75fSGeert Uytterhoeven ret = spi_stop_queue(ctlr); 2108ffbbdd21SLinus Walleij 2109ffbbdd21SLinus Walleij /* 21103989144fSPetr Mladek * kthread_flush_worker will block until all work is done. 2111ffbbdd21SLinus Walleij * If the reason that stop_queue timed out is that the work will never 2112ffbbdd21SLinus Walleij * finish, then it does no good to call flush/stop thread, so 2113ffbbdd21SLinus Walleij * return anyway. 2114ffbbdd21SLinus Walleij */ 2115ffbbdd21SLinus Walleij if (ret) { 21168caab75fSGeert Uytterhoeven dev_err(&ctlr->dev, "problem destroying queue\n"); 2117ffbbdd21SLinus Walleij return ret; 2118ffbbdd21SLinus Walleij } 2119ffbbdd21SLinus Walleij 212060a883d1SMarek Szyprowski kthread_destroy_worker(ctlr->kworker); 2121ffbbdd21SLinus Walleij 2122ffbbdd21SLinus Walleij return 0; 2123ffbbdd21SLinus Walleij } 2124ffbbdd21SLinus Walleij 21250461a414SMark Brown static int __spi_queued_transfer(struct spi_device *spi, 21260461a414SMark Brown struct spi_message *msg, 21270461a414SMark Brown bool need_pump) 2128ffbbdd21SLinus Walleij { 21298caab75fSGeert Uytterhoeven struct spi_controller *ctlr = spi->controller; 2130ffbbdd21SLinus Walleij unsigned long flags; 2131ffbbdd21SLinus Walleij 21328caab75fSGeert Uytterhoeven spin_lock_irqsave(&ctlr->queue_lock, flags); 2133ffbbdd21SLinus Walleij 21348caab75fSGeert Uytterhoeven if (!ctlr->running) { 21358caab75fSGeert Uytterhoeven spin_unlock_irqrestore(&ctlr->queue_lock, flags); 2136ffbbdd21SLinus Walleij return -ESHUTDOWN; 2137ffbbdd21SLinus Walleij } 2138ffbbdd21SLinus Walleij msg->actual_length = 0; 2139ffbbdd21SLinus Walleij msg->status = -EINPROGRESS; 2140ffbbdd21SLinus Walleij 21418caab75fSGeert Uytterhoeven list_add_tail(&msg->queue, &ctlr->queue); 2142ae7d2346SDavid Jander ctlr->queue_empty = false; 2143f0125f1aSMark Brown if (!ctlr->busy && need_pump) 214460a883d1SMarek Szyprowski kthread_queue_work(ctlr->kworker, &ctlr->pump_messages); 2145ffbbdd21SLinus Walleij 21468caab75fSGeert Uytterhoeven spin_unlock_irqrestore(&ctlr->queue_lock, flags); 2147ffbbdd21SLinus Walleij return 0; 2148ffbbdd21SLinus Walleij } 2149ffbbdd21SLinus Walleij 21500461a414SMark Brown /** 21510461a414SMark Brown * spi_queued_transfer - transfer function for queued transfers 2152702ca026SAndy Shevchenko * @spi: SPI device which is requesting transfer 2153702ca026SAndy Shevchenko * @msg: SPI message which is to handled is queued to driver queue 215497d56dc6SJavier Martinez Canillas * 215597d56dc6SJavier Martinez Canillas * Return: zero on success, else a negative error code. 21560461a414SMark Brown */ 21570461a414SMark Brown static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg) 21580461a414SMark Brown { 21590461a414SMark Brown return __spi_queued_transfer(spi, msg, true); 21600461a414SMark Brown } 21610461a414SMark Brown 21628caab75fSGeert Uytterhoeven static int spi_controller_initialize_queue(struct spi_controller *ctlr) 2163ffbbdd21SLinus Walleij { 2164ffbbdd21SLinus Walleij int ret; 2165ffbbdd21SLinus Walleij 21668caab75fSGeert Uytterhoeven ctlr->transfer = spi_queued_transfer; 21678caab75fSGeert Uytterhoeven if (!ctlr->transfer_one_message) 21688caab75fSGeert Uytterhoeven ctlr->transfer_one_message = spi_transfer_one_message; 2169ffbbdd21SLinus Walleij 2170ffbbdd21SLinus Walleij /* Initialize and start queue */ 21718caab75fSGeert Uytterhoeven ret = spi_init_queue(ctlr); 2172ffbbdd21SLinus Walleij if (ret) { 21738caab75fSGeert Uytterhoeven dev_err(&ctlr->dev, "problem initializing queue\n"); 2174ffbbdd21SLinus Walleij goto err_init_queue; 2175ffbbdd21SLinus Walleij } 21768caab75fSGeert Uytterhoeven ctlr->queued = true; 21778caab75fSGeert Uytterhoeven ret = spi_start_queue(ctlr); 2178ffbbdd21SLinus Walleij if (ret) { 21798caab75fSGeert Uytterhoeven dev_err(&ctlr->dev, "problem starting queue\n"); 2180ffbbdd21SLinus Walleij goto err_start_queue; 2181ffbbdd21SLinus Walleij } 2182ffbbdd21SLinus Walleij 2183ffbbdd21SLinus Walleij return 0; 2184ffbbdd21SLinus Walleij 2185ffbbdd21SLinus Walleij err_start_queue: 21868caab75fSGeert Uytterhoeven spi_destroy_queue(ctlr); 2187c3676d5cSMark Brown err_init_queue: 2188ffbbdd21SLinus Walleij return ret; 2189ffbbdd21SLinus Walleij } 2190ffbbdd21SLinus Walleij 2191988f259bSBoris Brezillon /** 2192988f259bSBoris Brezillon * spi_flush_queue - Send all pending messages in the queue from the callers' 2193988f259bSBoris Brezillon * context 2194988f259bSBoris Brezillon * @ctlr: controller to process queue for 2195988f259bSBoris Brezillon * 2196988f259bSBoris Brezillon * This should be used when one wants to ensure all pending messages have been 2197988f259bSBoris Brezillon * sent before doing something. Is used by the spi-mem code to make sure SPI 2198988f259bSBoris Brezillon * memory operations do not preempt regular SPI transfers that have been queued 2199988f259bSBoris Brezillon * before the spi-mem operation. 2200988f259bSBoris Brezillon */ 2201988f259bSBoris Brezillon void spi_flush_queue(struct spi_controller *ctlr) 2202988f259bSBoris Brezillon { 2203988f259bSBoris Brezillon if (ctlr->transfer == spi_queued_transfer) 2204988f259bSBoris Brezillon __spi_pump_messages(ctlr, false); 2205988f259bSBoris Brezillon } 2206988f259bSBoris Brezillon 2207ffbbdd21SLinus Walleij /*-------------------------------------------------------------------------*/ 2208ffbbdd21SLinus Walleij 22097cb94361SAndreas Larsson #if defined(CONFIG_OF) 2210f276aacfSJanne Grunau static void of_spi_parse_dt_cs_delay(struct device_node *nc, 2211f276aacfSJanne Grunau struct spi_delay *delay, const char *prop) 2212f276aacfSJanne Grunau { 2213f276aacfSJanne Grunau u32 value; 2214f276aacfSJanne Grunau 2215f276aacfSJanne Grunau if (!of_property_read_u32(nc, prop, &value)) { 2216f276aacfSJanne Grunau if (value > U16_MAX) { 2217f276aacfSJanne Grunau delay->value = DIV_ROUND_UP(value, 1000); 2218f276aacfSJanne Grunau delay->unit = SPI_DELAY_UNIT_USECS; 2219f276aacfSJanne Grunau } else { 2220f276aacfSJanne Grunau delay->value = value; 2221f276aacfSJanne Grunau delay->unit = SPI_DELAY_UNIT_NSECS; 2222f276aacfSJanne Grunau } 2223f276aacfSJanne Grunau } 2224f276aacfSJanne Grunau } 2225f276aacfSJanne Grunau 22268caab75fSGeert Uytterhoeven static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi, 2227c2e51ac3SGeert Uytterhoeven struct device_node *nc) 2228d57a4282SGrant Likely { 222989da4293STrent Piepho u32 value; 2230c2e51ac3SGeert Uytterhoeven int rc; 2231d57a4282SGrant Likely 2232d57a4282SGrant Likely /* Mode (clock phase/polarity/etc.) */ 2233e0bcb680SSergei Shtylyov if (of_property_read_bool(nc, "spi-cpha")) 2234d57a4282SGrant Likely spi->mode |= SPI_CPHA; 2235e0bcb680SSergei Shtylyov if (of_property_read_bool(nc, "spi-cpol")) 2236d57a4282SGrant Likely spi->mode |= SPI_CPOL; 2237e0bcb680SSergei Shtylyov if (of_property_read_bool(nc, "spi-3wire")) 2238c20151dfSLars-Peter Clausen spi->mode |= SPI_3WIRE; 2239e0bcb680SSergei Shtylyov if (of_property_read_bool(nc, "spi-lsb-first")) 2240cd6339e6SZhao Qiang spi->mode |= SPI_LSB_FIRST; 22413e5ec1dbSGregory CLEMENT if (of_property_read_bool(nc, "spi-cs-high")) 2242f3186dd8SLinus Walleij spi->mode |= SPI_CS_HIGH; 2243f3186dd8SLinus Walleij 2244f477b7fbSwangyuhang /* Device DUAL/QUAD mode */ 224589da4293STrent Piepho if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) { 224689da4293STrent Piepho switch (value) { 2247d962608cSDragos Bogdan case 0: 2248d962608cSDragos Bogdan spi->mode |= SPI_NO_TX; 2249d962608cSDragos Bogdan break; 225089da4293STrent Piepho case 1: 2251f477b7fbSwangyuhang break; 225289da4293STrent Piepho case 2: 2253f477b7fbSwangyuhang spi->mode |= SPI_TX_DUAL; 2254f477b7fbSwangyuhang break; 225589da4293STrent Piepho case 4: 2256f477b7fbSwangyuhang spi->mode |= SPI_TX_QUAD; 2257f477b7fbSwangyuhang break; 22586b03061fSYogesh Narayan Gaur case 8: 22596b03061fSYogesh Narayan Gaur spi->mode |= SPI_TX_OCTAL; 22606b03061fSYogesh Narayan Gaur break; 2261f477b7fbSwangyuhang default: 22628caab75fSGeert Uytterhoeven dev_warn(&ctlr->dev, 2263a110f93dSwangyuhang "spi-tx-bus-width %d not supported\n", 226489da4293STrent Piepho value); 226580874d8cSGeert Uytterhoeven break; 2266f477b7fbSwangyuhang } 2267a822e99cSMark Brown } 2268f477b7fbSwangyuhang 226989da4293STrent Piepho if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) { 227089da4293STrent Piepho switch (value) { 2271d962608cSDragos Bogdan case 0: 2272d962608cSDragos Bogdan spi->mode |= SPI_NO_RX; 2273d962608cSDragos Bogdan break; 227489da4293STrent Piepho case 1: 2275f477b7fbSwangyuhang break; 227689da4293STrent Piepho case 2: 2277f477b7fbSwangyuhang spi->mode |= SPI_RX_DUAL; 2278f477b7fbSwangyuhang break; 227989da4293STrent Piepho case 4: 2280f477b7fbSwangyuhang spi->mode |= SPI_RX_QUAD; 2281f477b7fbSwangyuhang break; 22826b03061fSYogesh Narayan Gaur case 8: 22836b03061fSYogesh Narayan Gaur spi->mode |= SPI_RX_OCTAL; 22846b03061fSYogesh Narayan Gaur break; 2285f477b7fbSwangyuhang default: 22868caab75fSGeert Uytterhoeven dev_warn(&ctlr->dev, 2287a110f93dSwangyuhang "spi-rx-bus-width %d not supported\n", 228889da4293STrent Piepho value); 228980874d8cSGeert Uytterhoeven break; 2290f477b7fbSwangyuhang } 2291a822e99cSMark Brown } 2292f477b7fbSwangyuhang 22938caab75fSGeert Uytterhoeven if (spi_controller_is_slave(ctlr)) { 2294194276b0SRob Herring if (!of_node_name_eq(nc, "slave")) { 229525c56c88SRob Herring dev_err(&ctlr->dev, "%pOF is not called 'slave'\n", 229625c56c88SRob Herring nc); 22976c364062SGeert Uytterhoeven return -EINVAL; 22986c364062SGeert Uytterhoeven } 22996c364062SGeert Uytterhoeven return 0; 23006c364062SGeert Uytterhoeven } 23016c364062SGeert Uytterhoeven 23026c364062SGeert Uytterhoeven /* Device address */ 23036c364062SGeert Uytterhoeven rc = of_property_read_u32(nc, "reg", &value); 23046c364062SGeert Uytterhoeven if (rc) { 230525c56c88SRob Herring dev_err(&ctlr->dev, "%pOF has no valid 'reg' property (%d)\n", 230625c56c88SRob Herring nc, rc); 23076c364062SGeert Uytterhoeven return rc; 23086c364062SGeert Uytterhoeven } 2309303feb3cSAmit Kumar Mahapatra spi_set_chipselect(spi, 0, value); 23106c364062SGeert Uytterhoeven 2311d57a4282SGrant Likely /* Device speed */ 2312671c3bf5SChuanhong Guo if (!of_property_read_u32(nc, "spi-max-frequency", &value)) 231389da4293STrent Piepho spi->max_speed_hz = value; 2314d57a4282SGrant Likely 2315f276aacfSJanne Grunau /* Device CS delays */ 2316f276aacfSJanne Grunau of_spi_parse_dt_cs_delay(nc, &spi->cs_setup, "spi-cs-setup-delay-ns"); 23175827b31dSJanne Grunau of_spi_parse_dt_cs_delay(nc, &spi->cs_hold, "spi-cs-hold-delay-ns"); 23185827b31dSJanne Grunau of_spi_parse_dt_cs_delay(nc, &spi->cs_inactive, "spi-cs-inactive-delay-ns"); 231933a2fde5STudor Ambarus 2320c2e51ac3SGeert Uytterhoeven return 0; 2321c2e51ac3SGeert Uytterhoeven } 2322c2e51ac3SGeert Uytterhoeven 2323c2e51ac3SGeert Uytterhoeven static struct spi_device * 23248caab75fSGeert Uytterhoeven of_register_spi_device(struct spi_controller *ctlr, struct device_node *nc) 2325c2e51ac3SGeert Uytterhoeven { 2326c2e51ac3SGeert Uytterhoeven struct spi_device *spi; 2327c2e51ac3SGeert Uytterhoeven int rc; 2328c2e51ac3SGeert Uytterhoeven 2329c2e51ac3SGeert Uytterhoeven /* Alloc an spi_device */ 23308caab75fSGeert Uytterhoeven spi = spi_alloc_device(ctlr); 2331c2e51ac3SGeert Uytterhoeven if (!spi) { 233225c56c88SRob Herring dev_err(&ctlr->dev, "spi_device alloc error for %pOF\n", nc); 2333c2e51ac3SGeert Uytterhoeven rc = -ENOMEM; 2334c2e51ac3SGeert Uytterhoeven goto err_out; 2335c2e51ac3SGeert Uytterhoeven } 2336c2e51ac3SGeert Uytterhoeven 2337c2e51ac3SGeert Uytterhoeven /* Select device driver */ 2338673aa1edSMiquel Raynal rc = of_alias_from_compatible(nc, spi->modalias, 2339c2e51ac3SGeert Uytterhoeven sizeof(spi->modalias)); 2340c2e51ac3SGeert Uytterhoeven if (rc < 0) { 234125c56c88SRob Herring dev_err(&ctlr->dev, "cannot find modalias for %pOF\n", nc); 2342c2e51ac3SGeert Uytterhoeven goto err_out; 2343c2e51ac3SGeert Uytterhoeven } 2344c2e51ac3SGeert Uytterhoeven 23458caab75fSGeert Uytterhoeven rc = of_spi_parse_dt(ctlr, spi, nc); 2346c2e51ac3SGeert Uytterhoeven if (rc) 2347c2e51ac3SGeert Uytterhoeven goto err_out; 2348c2e51ac3SGeert Uytterhoeven 2349d57a4282SGrant Likely /* Store a pointer to the node in the device structure */ 2350d57a4282SGrant Likely of_node_get(nc); 2351c7cc588bSAndy Shevchenko 2352c7cc588bSAndy Shevchenko device_set_node(&spi->dev, of_fwnode_handle(nc)); 2353d57a4282SGrant Likely 2354d57a4282SGrant Likely /* Register the new device */ 2355d57a4282SGrant Likely rc = spi_add_device(spi); 2356d57a4282SGrant Likely if (rc) { 235725c56c88SRob Herring dev_err(&ctlr->dev, "spi_device register error %pOF\n", nc); 23588324147fSJohan Hovold goto err_of_node_put; 2359d57a4282SGrant Likely } 2360d57a4282SGrant Likely 2361aff5e3f8SPantelis Antoniou return spi; 2362aff5e3f8SPantelis Antoniou 23638324147fSJohan Hovold err_of_node_put: 23648324147fSJohan Hovold of_node_put(nc); 2365aff5e3f8SPantelis Antoniou err_out: 2366aff5e3f8SPantelis Antoniou spi_dev_put(spi); 2367aff5e3f8SPantelis Antoniou return ERR_PTR(rc); 2368aff5e3f8SPantelis Antoniou } 2369aff5e3f8SPantelis Antoniou 2370aff5e3f8SPantelis Antoniou /** 2371aff5e3f8SPantelis Antoniou * of_register_spi_devices() - Register child devices onto the SPI bus 23728caab75fSGeert Uytterhoeven * @ctlr: Pointer to spi_controller device 2373aff5e3f8SPantelis Antoniou * 23746c364062SGeert Uytterhoeven * Registers an spi_device for each child node of controller node which 23756c364062SGeert Uytterhoeven * represents a valid SPI slave. 2376aff5e3f8SPantelis Antoniou */ 23778caab75fSGeert Uytterhoeven static void of_register_spi_devices(struct spi_controller *ctlr) 2378aff5e3f8SPantelis Antoniou { 2379aff5e3f8SPantelis Antoniou struct spi_device *spi; 2380aff5e3f8SPantelis Antoniou struct device_node *nc; 2381aff5e3f8SPantelis Antoniou 23828caab75fSGeert Uytterhoeven for_each_available_child_of_node(ctlr->dev.of_node, nc) { 2383bd6c1644SGeert Uytterhoeven if (of_node_test_and_set_flag(nc, OF_POPULATED)) 2384bd6c1644SGeert Uytterhoeven continue; 23858caab75fSGeert Uytterhoeven spi = of_register_spi_device(ctlr, nc); 2386e0af98a7SRalf Ramsauer if (IS_ERR(spi)) { 23878caab75fSGeert Uytterhoeven dev_warn(&ctlr->dev, 238825c56c88SRob Herring "Failed to create SPI device for %pOF\n", nc); 2389e0af98a7SRalf Ramsauer of_node_clear_flag(nc, OF_POPULATED); 2390e0af98a7SRalf Ramsauer } 2391d57a4282SGrant Likely } 2392d57a4282SGrant Likely } 2393d57a4282SGrant Likely #else 23948caab75fSGeert Uytterhoeven static void of_register_spi_devices(struct spi_controller *ctlr) { } 2395d57a4282SGrant Likely #endif 2396d57a4282SGrant Likely 23970c79378cSSebastian Reichel /** 23980c79378cSSebastian Reichel * spi_new_ancillary_device() - Register ancillary SPI device 23990c79378cSSebastian Reichel * @spi: Pointer to the main SPI device registering the ancillary device 24000c79378cSSebastian Reichel * @chip_select: Chip Select of the ancillary device 24010c79378cSSebastian Reichel * 24020c79378cSSebastian Reichel * Register an ancillary SPI device; for example some chips have a chip-select 24030c79378cSSebastian Reichel * for normal device usage and another one for setup/firmware upload. 24040c79378cSSebastian Reichel * 24050c79378cSSebastian Reichel * This may only be called from main SPI device's probe routine. 24060c79378cSSebastian Reichel * 24070c79378cSSebastian Reichel * Return: 0 on success; negative errno on failure 24080c79378cSSebastian Reichel */ 24090c79378cSSebastian Reichel struct spi_device *spi_new_ancillary_device(struct spi_device *spi, 24100c79378cSSebastian Reichel u8 chip_select) 24110c79378cSSebastian Reichel { 24127b5c6a54SAndy Shevchenko struct spi_controller *ctlr = spi->controller; 24130c79378cSSebastian Reichel struct spi_device *ancillary; 24140c79378cSSebastian Reichel int rc = 0; 24150c79378cSSebastian Reichel 24160c79378cSSebastian Reichel /* Alloc an spi_device */ 24177b5c6a54SAndy Shevchenko ancillary = spi_alloc_device(ctlr); 24180c79378cSSebastian Reichel if (!ancillary) { 24190c79378cSSebastian Reichel rc = -ENOMEM; 24200c79378cSSebastian Reichel goto err_out; 24210c79378cSSebastian Reichel } 24220c79378cSSebastian Reichel 242351e99de5SWolfram Sang strscpy(ancillary->modalias, "dummy", sizeof(ancillary->modalias)); 24240c79378cSSebastian Reichel 24250c79378cSSebastian Reichel /* Use provided chip-select for ancillary device */ 2426303feb3cSAmit Kumar Mahapatra spi_set_chipselect(ancillary, 0, chip_select); 24270c79378cSSebastian Reichel 24280c79378cSSebastian Reichel /* Take over SPI mode/speed from SPI main device */ 24290c79378cSSebastian Reichel ancillary->max_speed_hz = spi->max_speed_hz; 2430b01d5506SColin Ian King ancillary->mode = spi->mode; 24310c79378cSSebastian Reichel 24327b5c6a54SAndy Shevchenko WARN_ON(!mutex_is_locked(&ctlr->add_lock)); 24337b5c6a54SAndy Shevchenko 24340c79378cSSebastian Reichel /* Register the new device */ 24357b5c6a54SAndy Shevchenko rc = __spi_add_device(ancillary); 24360c79378cSSebastian Reichel if (rc) { 24370c79378cSSebastian Reichel dev_err(&spi->dev, "failed to register ancillary device\n"); 24380c79378cSSebastian Reichel goto err_out; 24390c79378cSSebastian Reichel } 24400c79378cSSebastian Reichel 24410c79378cSSebastian Reichel return ancillary; 24420c79378cSSebastian Reichel 24430c79378cSSebastian Reichel err_out: 24440c79378cSSebastian Reichel spi_dev_put(ancillary); 24450c79378cSSebastian Reichel return ERR_PTR(rc); 24460c79378cSSebastian Reichel } 24470c79378cSSebastian Reichel EXPORT_SYMBOL_GPL(spi_new_ancillary_device); 24480c79378cSSebastian Reichel 244964bee4d2SMika Westerberg #ifdef CONFIG_ACPI 24504c3c5954SArd Biesheuvel struct acpi_spi_lookup { 24514c3c5954SArd Biesheuvel struct spi_controller *ctlr; 24524c3c5954SArd Biesheuvel u32 max_speed_hz; 24534c3c5954SArd Biesheuvel u32 mode; 24544c3c5954SArd Biesheuvel int irq; 24554c3c5954SArd Biesheuvel u8 bits_per_word; 24564c3c5954SArd Biesheuvel u8 chip_select; 245787e59b36SStefan Binding int n; 245887e59b36SStefan Binding int index; 24594c3c5954SArd Biesheuvel }; 24604c3c5954SArd Biesheuvel 2461e612af7aSStefan Binding static int acpi_spi_count(struct acpi_resource *ares, void *data) 2462e612af7aSStefan Binding { 2463e612af7aSStefan Binding struct acpi_resource_spi_serialbus *sb; 2464e612af7aSStefan Binding int *count = data; 2465e612af7aSStefan Binding 2466e612af7aSStefan Binding if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) 2467e612af7aSStefan Binding return 1; 2468e612af7aSStefan Binding 2469e612af7aSStefan Binding sb = &ares->data.spi_serial_bus; 2470e612af7aSStefan Binding if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_SPI) 2471e612af7aSStefan Binding return 1; 2472e612af7aSStefan Binding 2473e612af7aSStefan Binding *count = *count + 1; 2474e612af7aSStefan Binding 2475e612af7aSStefan Binding return 1; 2476e612af7aSStefan Binding } 2477e612af7aSStefan Binding 2478e612af7aSStefan Binding /** 2479e612af7aSStefan Binding * acpi_spi_count_resources - Count the number of SpiSerialBus resources 2480e612af7aSStefan Binding * @adev: ACPI device 2481e612af7aSStefan Binding * 2482702ca026SAndy Shevchenko * Return: the number of SpiSerialBus resources in the ACPI-device's 2483e612af7aSStefan Binding * resource-list; or a negative error code. 2484e612af7aSStefan Binding */ 2485e612af7aSStefan Binding int acpi_spi_count_resources(struct acpi_device *adev) 2486e612af7aSStefan Binding { 2487e612af7aSStefan Binding LIST_HEAD(r); 2488e612af7aSStefan Binding int count = 0; 2489e612af7aSStefan Binding int ret; 2490e612af7aSStefan Binding 2491e612af7aSStefan Binding ret = acpi_dev_get_resources(adev, &r, acpi_spi_count, &count); 2492e612af7aSStefan Binding if (ret < 0) 2493e612af7aSStefan Binding return ret; 2494e612af7aSStefan Binding 2495e612af7aSStefan Binding acpi_dev_free_resource_list(&r); 2496e612af7aSStefan Binding 2497e612af7aSStefan Binding return count; 2498e612af7aSStefan Binding } 2499e612af7aSStefan Binding EXPORT_SYMBOL_GPL(acpi_spi_count_resources); 2500e612af7aSStefan Binding 25014c3c5954SArd Biesheuvel static void acpi_spi_parse_apple_properties(struct acpi_device *dev, 25024c3c5954SArd Biesheuvel struct acpi_spi_lookup *lookup) 25038a2e487eSLukas Wunner { 25048a2e487eSLukas Wunner const union acpi_object *obj; 25058a2e487eSLukas Wunner 25068a2e487eSLukas Wunner if (!x86_apple_machine) 25078a2e487eSLukas Wunner return; 25088a2e487eSLukas Wunner 25098a2e487eSLukas Wunner if (!acpi_dev_get_property(dev, "spiSclkPeriod", ACPI_TYPE_BUFFER, &obj) 25108a2e487eSLukas Wunner && obj->buffer.length >= 4) 25114c3c5954SArd Biesheuvel lookup->max_speed_hz = NSEC_PER_SEC / *(u32 *)obj->buffer.pointer; 25128a2e487eSLukas Wunner 25138a2e487eSLukas Wunner if (!acpi_dev_get_property(dev, "spiWordSize", ACPI_TYPE_BUFFER, &obj) 25148a2e487eSLukas Wunner && obj->buffer.length == 8) 25154c3c5954SArd Biesheuvel lookup->bits_per_word = *(u64 *)obj->buffer.pointer; 25168a2e487eSLukas Wunner 25178a2e487eSLukas Wunner if (!acpi_dev_get_property(dev, "spiBitOrder", ACPI_TYPE_BUFFER, &obj) 25188a2e487eSLukas Wunner && obj->buffer.length == 8 && !*(u64 *)obj->buffer.pointer) 25194c3c5954SArd Biesheuvel lookup->mode |= SPI_LSB_FIRST; 25208a2e487eSLukas Wunner 25218a2e487eSLukas Wunner if (!acpi_dev_get_property(dev, "spiSPO", ACPI_TYPE_BUFFER, &obj) 25228a2e487eSLukas Wunner && obj->buffer.length == 8 && *(u64 *)obj->buffer.pointer) 25234c3c5954SArd Biesheuvel lookup->mode |= SPI_CPOL; 25248a2e487eSLukas Wunner 25258a2e487eSLukas Wunner if (!acpi_dev_get_property(dev, "spiSPH", ACPI_TYPE_BUFFER, &obj) 25268a2e487eSLukas Wunner && obj->buffer.length == 8 && *(u64 *)obj->buffer.pointer) 25274c3c5954SArd Biesheuvel lookup->mode |= SPI_CPHA; 25288a2e487eSLukas Wunner } 25298a2e487eSLukas Wunner 253087e59b36SStefan Binding static struct spi_controller *acpi_spi_find_controller_by_adev(struct acpi_device *adev); 253187e59b36SStefan Binding 253264bee4d2SMika Westerberg static int acpi_spi_add_resource(struct acpi_resource *ares, void *data) 253364bee4d2SMika Westerberg { 25344c3c5954SArd Biesheuvel struct acpi_spi_lookup *lookup = data; 25354c3c5954SArd Biesheuvel struct spi_controller *ctlr = lookup->ctlr; 253664bee4d2SMika Westerberg 253764bee4d2SMika Westerberg if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) { 253864bee4d2SMika Westerberg struct acpi_resource_spi_serialbus *sb; 25394c3c5954SArd Biesheuvel acpi_handle parent_handle; 25404c3c5954SArd Biesheuvel acpi_status status; 254164bee4d2SMika Westerberg 254264bee4d2SMika Westerberg sb = &ares->data.spi_serial_bus; 254364bee4d2SMika Westerberg if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_SPI) { 25444c3c5954SArd Biesheuvel 254587e59b36SStefan Binding if (lookup->index != -1 && lookup->n++ != lookup->index) 254687e59b36SStefan Binding return 1; 254787e59b36SStefan Binding 25484c3c5954SArd Biesheuvel status = acpi_get_handle(NULL, 25494c3c5954SArd Biesheuvel sb->resource_source.string_ptr, 25504c3c5954SArd Biesheuvel &parent_handle); 25514c3c5954SArd Biesheuvel 255287e59b36SStefan Binding if (ACPI_FAILURE(status)) 25534c3c5954SArd Biesheuvel return -ENODEV; 25544c3c5954SArd Biesheuvel 255587e59b36SStefan Binding if (ctlr) { 255687e59b36SStefan Binding if (ACPI_HANDLE(ctlr->dev.parent) != parent_handle) 255787e59b36SStefan Binding return -ENODEV; 255887e59b36SStefan Binding } else { 255987e59b36SStefan Binding struct acpi_device *adev; 256087e59b36SStefan Binding 2561ac2a3feeSRafael J. Wysocki adev = acpi_fetch_acpi_dev(parent_handle); 2562ac2a3feeSRafael J. Wysocki if (!adev) 256387e59b36SStefan Binding return -ENODEV; 256487e59b36SStefan Binding 256587e59b36SStefan Binding ctlr = acpi_spi_find_controller_by_adev(adev); 256687e59b36SStefan Binding if (!ctlr) 25679c22ec4aSAndy Shevchenko return -EPROBE_DEFER; 256887e59b36SStefan Binding 256987e59b36SStefan Binding lookup->ctlr = ctlr; 257087e59b36SStefan Binding } 257187e59b36SStefan Binding 2572a0a90718SMika Westerberg /* 2573a0a90718SMika Westerberg * ACPI DeviceSelection numbering is handled by the 2574a0a90718SMika Westerberg * host controller driver in Windows and can vary 2575a0a90718SMika Westerberg * from driver to driver. In Linux we always expect 2576a0a90718SMika Westerberg * 0 .. max - 1 so we need to ask the driver to 2577a0a90718SMika Westerberg * translate between the two schemes. 2578a0a90718SMika Westerberg */ 25798caab75fSGeert Uytterhoeven if (ctlr->fw_translate_cs) { 25808caab75fSGeert Uytterhoeven int cs = ctlr->fw_translate_cs(ctlr, 2581a0a90718SMika Westerberg sb->device_selection); 2582a0a90718SMika Westerberg if (cs < 0) 2583a0a90718SMika Westerberg return cs; 25844c3c5954SArd Biesheuvel lookup->chip_select = cs; 2585a0a90718SMika Westerberg } else { 25864c3c5954SArd Biesheuvel lookup->chip_select = sb->device_selection; 2587a0a90718SMika Westerberg } 2588a0a90718SMika Westerberg 25894c3c5954SArd Biesheuvel lookup->max_speed_hz = sb->connection_speed; 25900dadde34SAndy Shevchenko lookup->bits_per_word = sb->data_bit_length; 259164bee4d2SMika Westerberg 259264bee4d2SMika Westerberg if (sb->clock_phase == ACPI_SPI_SECOND_PHASE) 25934c3c5954SArd Biesheuvel lookup->mode |= SPI_CPHA; 259464bee4d2SMika Westerberg if (sb->clock_polarity == ACPI_SPI_START_HIGH) 25954c3c5954SArd Biesheuvel lookup->mode |= SPI_CPOL; 259664bee4d2SMika Westerberg if (sb->device_polarity == ACPI_SPI_ACTIVE_HIGH) 25974c3c5954SArd Biesheuvel lookup->mode |= SPI_CS_HIGH; 259864bee4d2SMika Westerberg } 25994c3c5954SArd Biesheuvel } else if (lookup->irq < 0) { 260064bee4d2SMika Westerberg struct resource r; 260164bee4d2SMika Westerberg 260264bee4d2SMika Westerberg if (acpi_dev_resource_interrupt(ares, 0, &r)) 26034c3c5954SArd Biesheuvel lookup->irq = r.start; 260464bee4d2SMika Westerberg } 260564bee4d2SMika Westerberg 260664bee4d2SMika Westerberg /* Always tell the ACPI core to skip this resource */ 260764bee4d2SMika Westerberg return 1; 260864bee4d2SMika Westerberg } 260964bee4d2SMika Westerberg 2610000bee0eSStefan Binding /** 2611000bee0eSStefan Binding * acpi_spi_device_alloc - Allocate a spi device, and fill it in with ACPI information 2612000bee0eSStefan Binding * @ctlr: controller to which the spi device belongs 2613000bee0eSStefan Binding * @adev: ACPI Device for the spi device 261487e59b36SStefan Binding * @index: Index of the spi resource inside the ACPI Node 2615000bee0eSStefan Binding * 2616702ca026SAndy Shevchenko * This should be used to allocate a new SPI device from and ACPI Device node. 2617702ca026SAndy Shevchenko * The caller is responsible for calling spi_add_device to register the SPI device. 2618000bee0eSStefan Binding * 2619702ca026SAndy Shevchenko * If ctlr is set to NULL, the Controller for the SPI device will be looked up 262087e59b36SStefan Binding * using the resource. 262187e59b36SStefan Binding * If index is set to -1, index is not used. 262287e59b36SStefan Binding * Note: If index is -1, ctlr must be set. 262387e59b36SStefan Binding * 2624000bee0eSStefan Binding * Return: a pointer to the new device, or ERR_PTR on error. 2625000bee0eSStefan Binding */ 2626000bee0eSStefan Binding struct spi_device *acpi_spi_device_alloc(struct spi_controller *ctlr, 262787e59b36SStefan Binding struct acpi_device *adev, 262887e59b36SStefan Binding int index) 262964bee4d2SMika Westerberg { 26304c3c5954SArd Biesheuvel acpi_handle parent_handle = NULL; 263164bee4d2SMika Westerberg struct list_head resource_list; 2632b28944c6SArd Biesheuvel struct acpi_spi_lookup lookup = {}; 263364bee4d2SMika Westerberg struct spi_device *spi; 263464bee4d2SMika Westerberg int ret; 263564bee4d2SMika Westerberg 263687e59b36SStefan Binding if (!ctlr && index == -1) 263787e59b36SStefan Binding return ERR_PTR(-EINVAL); 263887e59b36SStefan Binding 26394c3c5954SArd Biesheuvel lookup.ctlr = ctlr; 26404c3c5954SArd Biesheuvel lookup.irq = -1; 264187e59b36SStefan Binding lookup.index = index; 264287e59b36SStefan Binding lookup.n = 0; 26434c3c5954SArd Biesheuvel 26444c3c5954SArd Biesheuvel INIT_LIST_HEAD(&resource_list); 26454c3c5954SArd Biesheuvel ret = acpi_dev_get_resources(adev, &resource_list, 26464c3c5954SArd Biesheuvel acpi_spi_add_resource, &lookup); 26474c3c5954SArd Biesheuvel acpi_dev_free_resource_list(&resource_list); 26484c3c5954SArd Biesheuvel 26494c3c5954SArd Biesheuvel if (ret < 0) 265095c8222fSDavid Jander /* Found SPI in _CRS but it points to another controller */ 2651b6747f4fSAndy Shevchenko return ERR_PTR(ret); 26524c3c5954SArd Biesheuvel 26534c3c5954SArd Biesheuvel if (!lookup.max_speed_hz && 265410e92724SBjorn Helgaas ACPI_SUCCESS(acpi_get_parent(adev->handle, &parent_handle)) && 265587e59b36SStefan Binding ACPI_HANDLE(lookup.ctlr->dev.parent) == parent_handle) { 26564c3c5954SArd Biesheuvel /* Apple does not use _CRS but nested devices for SPI slaves */ 26574c3c5954SArd Biesheuvel acpi_spi_parse_apple_properties(adev, &lookup); 26584c3c5954SArd Biesheuvel } 26594c3c5954SArd Biesheuvel 26604c3c5954SArd Biesheuvel if (!lookup.max_speed_hz) 2661000bee0eSStefan Binding return ERR_PTR(-ENODEV); 26624c3c5954SArd Biesheuvel 266387e59b36SStefan Binding spi = spi_alloc_device(lookup.ctlr); 266464bee4d2SMika Westerberg if (!spi) { 266587e59b36SStefan Binding dev_err(&lookup.ctlr->dev, "failed to allocate SPI device for %s\n", 266664bee4d2SMika Westerberg dev_name(&adev->dev)); 2667000bee0eSStefan Binding return ERR_PTR(-ENOMEM); 266864bee4d2SMika Westerberg } 266964bee4d2SMika Westerberg 26707b199811SRafael J. Wysocki ACPI_COMPANION_SET(&spi->dev, adev); 26714c3c5954SArd Biesheuvel spi->max_speed_hz = lookup.max_speed_hz; 2672ea235786SJohn Garry spi->mode |= lookup.mode; 26734c3c5954SArd Biesheuvel spi->irq = lookup.irq; 26744c3c5954SArd Biesheuvel spi->bits_per_word = lookup.bits_per_word; 2675303feb3cSAmit Kumar Mahapatra spi_set_chipselect(spi, 0, lookup.chip_select); 267664bee4d2SMika Westerberg 2677000bee0eSStefan Binding return spi; 2678000bee0eSStefan Binding } 2679000bee0eSStefan Binding EXPORT_SYMBOL_GPL(acpi_spi_device_alloc); 2680000bee0eSStefan Binding 2681000bee0eSStefan Binding static acpi_status acpi_register_spi_device(struct spi_controller *ctlr, 2682000bee0eSStefan Binding struct acpi_device *adev) 2683000bee0eSStefan Binding { 2684000bee0eSStefan Binding struct spi_device *spi; 2685000bee0eSStefan Binding 2686000bee0eSStefan Binding if (acpi_bus_get_status(adev) || !adev->status.present || 2687000bee0eSStefan Binding acpi_device_enumerated(adev)) 2688000bee0eSStefan Binding return AE_OK; 2689000bee0eSStefan Binding 269087e59b36SStefan Binding spi = acpi_spi_device_alloc(ctlr, adev, -1); 2691000bee0eSStefan Binding if (IS_ERR(spi)) { 2692000bee0eSStefan Binding if (PTR_ERR(spi) == -ENOMEM) 2693000bee0eSStefan Binding return AE_NO_MEMORY; 2694000bee0eSStefan Binding else 2695000bee0eSStefan Binding return AE_OK; 2696000bee0eSStefan Binding } 2697000bee0eSStefan Binding 26980c6543f6SDan O'Donovan acpi_set_modalias(adev, acpi_device_hid(adev), spi->modalias, 26990c6543f6SDan O'Donovan sizeof(spi->modalias)); 27000c6543f6SDan O'Donovan 270133ada67dSChristophe RICARD if (spi->irq < 0) 270233ada67dSChristophe RICARD spi->irq = acpi_dev_gpio_irq_get(adev, 0); 270333ada67dSChristophe RICARD 27047f24467fSOctavian Purdila acpi_device_set_enumerated(adev); 27057f24467fSOctavian Purdila 270633cf00e5SMika Westerberg adev->power.flags.ignore_parent = true; 270764bee4d2SMika Westerberg if (spi_add_device(spi)) { 270833cf00e5SMika Westerberg adev->power.flags.ignore_parent = false; 27098caab75fSGeert Uytterhoeven dev_err(&ctlr->dev, "failed to add SPI device %s from ACPI\n", 271064bee4d2SMika Westerberg dev_name(&adev->dev)); 271164bee4d2SMika Westerberg spi_dev_put(spi); 271264bee4d2SMika Westerberg } 271364bee4d2SMika Westerberg 271464bee4d2SMika Westerberg return AE_OK; 271564bee4d2SMika Westerberg } 271664bee4d2SMika Westerberg 27177f24467fSOctavian Purdila static acpi_status acpi_spi_add_device(acpi_handle handle, u32 level, 27187f24467fSOctavian Purdila void *data, void **return_value) 27197f24467fSOctavian Purdila { 27207030c428SRafael J. Wysocki struct acpi_device *adev = acpi_fetch_acpi_dev(handle); 27218caab75fSGeert Uytterhoeven struct spi_controller *ctlr = data; 27227f24467fSOctavian Purdila 27237030c428SRafael J. Wysocki if (!adev) 27247f24467fSOctavian Purdila return AE_OK; 27257f24467fSOctavian Purdila 27268caab75fSGeert Uytterhoeven return acpi_register_spi_device(ctlr, adev); 27277f24467fSOctavian Purdila } 27287f24467fSOctavian Purdila 27294c3c5954SArd Biesheuvel #define SPI_ACPI_ENUMERATE_MAX_DEPTH 32 27304c3c5954SArd Biesheuvel 27318caab75fSGeert Uytterhoeven static void acpi_register_spi_devices(struct spi_controller *ctlr) 273264bee4d2SMika Westerberg { 273364bee4d2SMika Westerberg acpi_status status; 273464bee4d2SMika Westerberg acpi_handle handle; 273564bee4d2SMika Westerberg 27368caab75fSGeert Uytterhoeven handle = ACPI_HANDLE(ctlr->dev.parent); 273764bee4d2SMika Westerberg if (!handle) 273864bee4d2SMika Westerberg return; 273964bee4d2SMika Westerberg 27404c3c5954SArd Biesheuvel status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 27414c3c5954SArd Biesheuvel SPI_ACPI_ENUMERATE_MAX_DEPTH, 27428caab75fSGeert Uytterhoeven acpi_spi_add_device, NULL, ctlr, NULL); 274364bee4d2SMika Westerberg if (ACPI_FAILURE(status)) 27448caab75fSGeert Uytterhoeven dev_warn(&ctlr->dev, "failed to enumerate SPI slaves\n"); 274564bee4d2SMika Westerberg } 274664bee4d2SMika Westerberg #else 27478caab75fSGeert Uytterhoeven static inline void acpi_register_spi_devices(struct spi_controller *ctlr) {} 274864bee4d2SMika Westerberg #endif /* CONFIG_ACPI */ 274964bee4d2SMika Westerberg 27508caab75fSGeert Uytterhoeven static void spi_controller_release(struct device *dev) 27518ae12a0dSDavid Brownell { 27528caab75fSGeert Uytterhoeven struct spi_controller *ctlr; 27538ae12a0dSDavid Brownell 27548caab75fSGeert Uytterhoeven ctlr = container_of(dev, struct spi_controller, dev); 27558caab75fSGeert Uytterhoeven kfree(ctlr); 27568ae12a0dSDavid Brownell } 27578ae12a0dSDavid Brownell 27588ae12a0dSDavid Brownell static struct class spi_master_class = { 27598ae12a0dSDavid Brownell .name = "spi_master", 27608caab75fSGeert Uytterhoeven .dev_release = spi_controller_release, 2761eca2ebc7SMartin Sperl .dev_groups = spi_master_groups, 27628ae12a0dSDavid Brownell }; 27638ae12a0dSDavid Brownell 27646c364062SGeert Uytterhoeven #ifdef CONFIG_SPI_SLAVE 27656c364062SGeert Uytterhoeven /** 27666c364062SGeert Uytterhoeven * spi_slave_abort - abort the ongoing transfer request on an SPI slave 27676c364062SGeert Uytterhoeven * controller 27686c364062SGeert Uytterhoeven * @spi: device used for the current transfer 27696c364062SGeert Uytterhoeven */ 27706c364062SGeert Uytterhoeven int spi_slave_abort(struct spi_device *spi) 27716c364062SGeert Uytterhoeven { 27728caab75fSGeert Uytterhoeven struct spi_controller *ctlr = spi->controller; 27736c364062SGeert Uytterhoeven 27748caab75fSGeert Uytterhoeven if (spi_controller_is_slave(ctlr) && ctlr->slave_abort) 27758caab75fSGeert Uytterhoeven return ctlr->slave_abort(ctlr); 27766c364062SGeert Uytterhoeven 27776c364062SGeert Uytterhoeven return -ENOTSUPP; 27786c364062SGeert Uytterhoeven } 27796c364062SGeert Uytterhoeven EXPORT_SYMBOL_GPL(spi_slave_abort); 27806c364062SGeert Uytterhoeven 2781b8d3b056SYang Yingliang int spi_target_abort(struct spi_device *spi) 2782b8d3b056SYang Yingliang { 2783b8d3b056SYang Yingliang struct spi_controller *ctlr = spi->controller; 2784b8d3b056SYang Yingliang 2785b8d3b056SYang Yingliang if (spi_controller_is_target(ctlr) && ctlr->target_abort) 2786b8d3b056SYang Yingliang return ctlr->target_abort(ctlr); 2787b8d3b056SYang Yingliang 2788b8d3b056SYang Yingliang return -ENOTSUPP; 2789b8d3b056SYang Yingliang } 2790b8d3b056SYang Yingliang EXPORT_SYMBOL_GPL(spi_target_abort); 2791b8d3b056SYang Yingliang 2792cc8b4659SGeert Uytterhoeven static ssize_t slave_show(struct device *dev, struct device_attribute *attr, 2793cc8b4659SGeert Uytterhoeven char *buf) 27946c364062SGeert Uytterhoeven { 27958caab75fSGeert Uytterhoeven struct spi_controller *ctlr = container_of(dev, struct spi_controller, 27968caab75fSGeert Uytterhoeven dev); 27976c364062SGeert Uytterhoeven struct device *child; 27986c364062SGeert Uytterhoeven 2799c21b0837SAndy Shevchenko child = device_find_any_child(&ctlr->dev); 2800f2daa466SAndy Shevchenko return sysfs_emit(buf, "%s\n", child ? to_spi_device(child)->modalias : NULL); 28016c364062SGeert Uytterhoeven } 28026c364062SGeert Uytterhoeven 2803cc8b4659SGeert Uytterhoeven static ssize_t slave_store(struct device *dev, struct device_attribute *attr, 2804cc8b4659SGeert Uytterhoeven const char *buf, size_t count) 28056c364062SGeert Uytterhoeven { 28068caab75fSGeert Uytterhoeven struct spi_controller *ctlr = container_of(dev, struct spi_controller, 28078caab75fSGeert Uytterhoeven dev); 28086c364062SGeert Uytterhoeven struct spi_device *spi; 28096c364062SGeert Uytterhoeven struct device *child; 28106c364062SGeert Uytterhoeven char name[32]; 28116c364062SGeert Uytterhoeven int rc; 28126c364062SGeert Uytterhoeven 28136c364062SGeert Uytterhoeven rc = sscanf(buf, "%31s", name); 28146c364062SGeert Uytterhoeven if (rc != 1 || !name[0]) 28156c364062SGeert Uytterhoeven return -EINVAL; 28166c364062SGeert Uytterhoeven 2817c21b0837SAndy Shevchenko child = device_find_any_child(&ctlr->dev); 28186c364062SGeert Uytterhoeven if (child) { 28196c364062SGeert Uytterhoeven /* Remove registered slave */ 28206c364062SGeert Uytterhoeven device_unregister(child); 28216c364062SGeert Uytterhoeven put_device(child); 28226c364062SGeert Uytterhoeven } 28236c364062SGeert Uytterhoeven 28246c364062SGeert Uytterhoeven if (strcmp(name, "(null)")) { 28256c364062SGeert Uytterhoeven /* Register new slave */ 28266c364062SGeert Uytterhoeven spi = spi_alloc_device(ctlr); 28276c364062SGeert Uytterhoeven if (!spi) 28286c364062SGeert Uytterhoeven return -ENOMEM; 28296c364062SGeert Uytterhoeven 283051e99de5SWolfram Sang strscpy(spi->modalias, name, sizeof(spi->modalias)); 28316c364062SGeert Uytterhoeven 28326c364062SGeert Uytterhoeven rc = spi_add_device(spi); 28336c364062SGeert Uytterhoeven if (rc) { 28346c364062SGeert Uytterhoeven spi_dev_put(spi); 28356c364062SGeert Uytterhoeven return rc; 28366c364062SGeert Uytterhoeven } 28376c364062SGeert Uytterhoeven } 28386c364062SGeert Uytterhoeven 28396c364062SGeert Uytterhoeven return count; 28406c364062SGeert Uytterhoeven } 28416c364062SGeert Uytterhoeven 2842cc8b4659SGeert Uytterhoeven static DEVICE_ATTR_RW(slave); 28436c364062SGeert Uytterhoeven 28446c364062SGeert Uytterhoeven static struct attribute *spi_slave_attrs[] = { 28456c364062SGeert Uytterhoeven &dev_attr_slave.attr, 28466c364062SGeert Uytterhoeven NULL, 28476c364062SGeert Uytterhoeven }; 28486c364062SGeert Uytterhoeven 28496c364062SGeert Uytterhoeven static const struct attribute_group spi_slave_group = { 28506c364062SGeert Uytterhoeven .attrs = spi_slave_attrs, 28516c364062SGeert Uytterhoeven }; 28526c364062SGeert Uytterhoeven 28536c364062SGeert Uytterhoeven static const struct attribute_group *spi_slave_groups[] = { 28548caab75fSGeert Uytterhoeven &spi_controller_statistics_group, 28556c364062SGeert Uytterhoeven &spi_slave_group, 28566c364062SGeert Uytterhoeven NULL, 28576c364062SGeert Uytterhoeven }; 28586c364062SGeert Uytterhoeven 28596c364062SGeert Uytterhoeven static struct class spi_slave_class = { 28606c364062SGeert Uytterhoeven .name = "spi_slave", 28618caab75fSGeert Uytterhoeven .dev_release = spi_controller_release, 28626c364062SGeert Uytterhoeven .dev_groups = spi_slave_groups, 28636c364062SGeert Uytterhoeven }; 28646c364062SGeert Uytterhoeven #else 28656c364062SGeert Uytterhoeven extern struct class spi_slave_class; /* dummy */ 28666c364062SGeert Uytterhoeven #endif 28678ae12a0dSDavid Brownell 28688ae12a0dSDavid Brownell /** 28696c364062SGeert Uytterhoeven * __spi_alloc_controller - allocate an SPI master or slave controller 28708ae12a0dSDavid Brownell * @dev: the controller, possibly using the platform_bus 287133e34dc6SDavid Brownell * @size: how much zeroed driver-private data to allocate; the pointer to this 2872229e6af1SLukas Wunner * memory is in the driver_data field of the returned device, accessible 2873229e6af1SLukas Wunner * with spi_controller_get_devdata(); the memory is cacheline aligned; 2874229e6af1SLukas Wunner * drivers granting DMA access to portions of their private data need to 2875229e6af1SLukas Wunner * round up @size using ALIGN(size, dma_get_cache_alignment()). 28766c364062SGeert Uytterhoeven * @slave: flag indicating whether to allocate an SPI master (false) or SPI 28776c364062SGeert Uytterhoeven * slave (true) controller 287833e34dc6SDavid Brownell * Context: can sleep 28798ae12a0dSDavid Brownell * 28806c364062SGeert Uytterhoeven * This call is used only by SPI controller drivers, which are the 28818ae12a0dSDavid Brownell * only ones directly touching chip registers. It's how they allocate 28828caab75fSGeert Uytterhoeven * an spi_controller structure, prior to calling spi_register_controller(). 28838ae12a0dSDavid Brownell * 288497d56dc6SJavier Martinez Canillas * This must be called from context that can sleep. 28858ae12a0dSDavid Brownell * 28866c364062SGeert Uytterhoeven * The caller is responsible for assigning the bus number and initializing the 28878caab75fSGeert Uytterhoeven * controller's methods before calling spi_register_controller(); and (after 28888caab75fSGeert Uytterhoeven * errors adding the device) calling spi_controller_put() to prevent a memory 28898caab75fSGeert Uytterhoeven * leak. 289097d56dc6SJavier Martinez Canillas * 28916c364062SGeert Uytterhoeven * Return: the SPI controller structure on success, else NULL. 28928ae12a0dSDavid Brownell */ 28938caab75fSGeert Uytterhoeven struct spi_controller *__spi_alloc_controller(struct device *dev, 28946c364062SGeert Uytterhoeven unsigned int size, bool slave) 28958ae12a0dSDavid Brownell { 28968caab75fSGeert Uytterhoeven struct spi_controller *ctlr; 2897229e6af1SLukas Wunner size_t ctlr_size = ALIGN(sizeof(*ctlr), dma_get_cache_alignment()); 28988ae12a0dSDavid Brownell 28990c868461SDavid Brownell if (!dev) 29000c868461SDavid Brownell return NULL; 29010c868461SDavid Brownell 2902229e6af1SLukas Wunner ctlr = kzalloc(size + ctlr_size, GFP_KERNEL); 29038caab75fSGeert Uytterhoeven if (!ctlr) 29048ae12a0dSDavid Brownell return NULL; 29058ae12a0dSDavid Brownell 29068caab75fSGeert Uytterhoeven device_initialize(&ctlr->dev); 290716a8e2fbSUwe Kleine-König INIT_LIST_HEAD(&ctlr->queue); 290816a8e2fbSUwe Kleine-König spin_lock_init(&ctlr->queue_lock); 290916a8e2fbSUwe Kleine-König spin_lock_init(&ctlr->bus_lock_spinlock); 291016a8e2fbSUwe Kleine-König mutex_init(&ctlr->bus_lock_mutex); 291116a8e2fbSUwe Kleine-König mutex_init(&ctlr->io_mutex); 291216a8e2fbSUwe Kleine-König mutex_init(&ctlr->add_lock); 29138caab75fSGeert Uytterhoeven ctlr->bus_num = -1; 29148caab75fSGeert Uytterhoeven ctlr->num_chipselect = 1; 29158caab75fSGeert Uytterhoeven ctlr->slave = slave; 29166c364062SGeert Uytterhoeven if (IS_ENABLED(CONFIG_SPI_SLAVE) && slave) 29178caab75fSGeert Uytterhoeven ctlr->dev.class = &spi_slave_class; 29186c364062SGeert Uytterhoeven else 29198caab75fSGeert Uytterhoeven ctlr->dev.class = &spi_master_class; 29208caab75fSGeert Uytterhoeven ctlr->dev.parent = dev; 29218caab75fSGeert Uytterhoeven pm_suspend_ignore_children(&ctlr->dev, true); 2922229e6af1SLukas Wunner spi_controller_set_devdata(ctlr, (void *)ctlr + ctlr_size); 29238ae12a0dSDavid Brownell 29248caab75fSGeert Uytterhoeven return ctlr; 29258ae12a0dSDavid Brownell } 29266c364062SGeert Uytterhoeven EXPORT_SYMBOL_GPL(__spi_alloc_controller); 29278ae12a0dSDavid Brownell 29285e844cc3SLukas Wunner static void devm_spi_release_controller(struct device *dev, void *ctlr) 29295e844cc3SLukas Wunner { 29305e844cc3SLukas Wunner spi_controller_put(*(struct spi_controller **)ctlr); 29315e844cc3SLukas Wunner } 29325e844cc3SLukas Wunner 29335e844cc3SLukas Wunner /** 29345e844cc3SLukas Wunner * __devm_spi_alloc_controller - resource-managed __spi_alloc_controller() 29355e844cc3SLukas Wunner * @dev: physical device of SPI controller 29365e844cc3SLukas Wunner * @size: how much zeroed driver-private data to allocate 29375e844cc3SLukas Wunner * @slave: whether to allocate an SPI master (false) or SPI slave (true) 29385e844cc3SLukas Wunner * Context: can sleep 29395e844cc3SLukas Wunner * 29405e844cc3SLukas Wunner * Allocate an SPI controller and automatically release a reference on it 29415e844cc3SLukas Wunner * when @dev is unbound from its driver. Drivers are thus relieved from 29425e844cc3SLukas Wunner * having to call spi_controller_put(). 29435e844cc3SLukas Wunner * 29445e844cc3SLukas Wunner * The arguments to this function are identical to __spi_alloc_controller(). 29455e844cc3SLukas Wunner * 29465e844cc3SLukas Wunner * Return: the SPI controller structure on success, else NULL. 29475e844cc3SLukas Wunner */ 29485e844cc3SLukas Wunner struct spi_controller *__devm_spi_alloc_controller(struct device *dev, 29495e844cc3SLukas Wunner unsigned int size, 29505e844cc3SLukas Wunner bool slave) 29515e844cc3SLukas Wunner { 29525e844cc3SLukas Wunner struct spi_controller **ptr, *ctlr; 29535e844cc3SLukas Wunner 29545e844cc3SLukas Wunner ptr = devres_alloc(devm_spi_release_controller, sizeof(*ptr), 29555e844cc3SLukas Wunner GFP_KERNEL); 29565e844cc3SLukas Wunner if (!ptr) 29575e844cc3SLukas Wunner return NULL; 29585e844cc3SLukas Wunner 29595e844cc3SLukas Wunner ctlr = __spi_alloc_controller(dev, size, slave); 29605e844cc3SLukas Wunner if (ctlr) { 2961794aaf01SWilliam A. Kennington III ctlr->devm_allocated = true; 29625e844cc3SLukas Wunner *ptr = ctlr; 29635e844cc3SLukas Wunner devres_add(dev, ptr); 29645e844cc3SLukas Wunner } else { 29655e844cc3SLukas Wunner devres_free(ptr); 29665e844cc3SLukas Wunner } 29675e844cc3SLukas Wunner 29685e844cc3SLukas Wunner return ctlr; 29695e844cc3SLukas Wunner } 29705e844cc3SLukas Wunner EXPORT_SYMBOL_GPL(__devm_spi_alloc_controller); 29715e844cc3SLukas Wunner 2972f3186dd8SLinus Walleij /** 2973f3186dd8SLinus Walleij * spi_get_gpio_descs() - grab chip select GPIOs for the master 2974f3186dd8SLinus Walleij * @ctlr: The SPI master to grab GPIO descriptors for 2975f3186dd8SLinus Walleij */ 2976f3186dd8SLinus Walleij static int spi_get_gpio_descs(struct spi_controller *ctlr) 2977f3186dd8SLinus Walleij { 2978f3186dd8SLinus Walleij int nb, i; 2979f3186dd8SLinus Walleij struct gpio_desc **cs; 2980f3186dd8SLinus Walleij struct device *dev = &ctlr->dev; 29817d93aecdSGeert Uytterhoeven unsigned long native_cs_mask = 0; 29827d93aecdSGeert Uytterhoeven unsigned int num_cs_gpios = 0; 2983f3186dd8SLinus Walleij 2984f3186dd8SLinus Walleij nb = gpiod_count(dev, "cs"); 298531ed8ebcSAndy Shevchenko if (nb < 0) { 2986f3186dd8SLinus Walleij /* No GPIOs at all is fine, else return the error */ 298731ed8ebcSAndy Shevchenko if (nb == -ENOENT) 2988f3186dd8SLinus Walleij return 0; 2989f3186dd8SLinus Walleij return nb; 299031ed8ebcSAndy Shevchenko } 299131ed8ebcSAndy Shevchenko 299231ed8ebcSAndy Shevchenko ctlr->num_chipselect = max_t(int, nb, ctlr->num_chipselect); 2993f3186dd8SLinus Walleij 2994f3186dd8SLinus Walleij cs = devm_kcalloc(dev, ctlr->num_chipselect, sizeof(*cs), 2995f3186dd8SLinus Walleij GFP_KERNEL); 2996f3186dd8SLinus Walleij if (!cs) 2997f3186dd8SLinus Walleij return -ENOMEM; 2998f3186dd8SLinus Walleij ctlr->cs_gpiods = cs; 2999f3186dd8SLinus Walleij 3000f3186dd8SLinus Walleij for (i = 0; i < nb; i++) { 3001f3186dd8SLinus Walleij /* 3002f3186dd8SLinus Walleij * Most chipselects are active low, the inverted 3003f3186dd8SLinus Walleij * semantics are handled by special quirks in gpiolib, 3004f3186dd8SLinus Walleij * so initializing them GPIOD_OUT_LOW here means 3005f3186dd8SLinus Walleij * "unasserted", in most cases this will drive the physical 3006f3186dd8SLinus Walleij * line high. 3007f3186dd8SLinus Walleij */ 3008f3186dd8SLinus Walleij cs[i] = devm_gpiod_get_index_optional(dev, "cs", i, 3009f3186dd8SLinus Walleij GPIOD_OUT_LOW); 30101723fdecSGeert Uytterhoeven if (IS_ERR(cs[i])) 30111723fdecSGeert Uytterhoeven return PTR_ERR(cs[i]); 3012f3186dd8SLinus Walleij 3013f3186dd8SLinus Walleij if (cs[i]) { 3014f3186dd8SLinus Walleij /* 3015f3186dd8SLinus Walleij * If we find a CS GPIO, name it after the device and 3016f3186dd8SLinus Walleij * chip select line. 3017f3186dd8SLinus Walleij */ 3018f3186dd8SLinus Walleij char *gpioname; 3019f3186dd8SLinus Walleij 3020f3186dd8SLinus Walleij gpioname = devm_kasprintf(dev, GFP_KERNEL, "%s CS%d", 3021f3186dd8SLinus Walleij dev_name(dev), i); 3022f3186dd8SLinus Walleij if (!gpioname) 3023f3186dd8SLinus Walleij return -ENOMEM; 3024f3186dd8SLinus Walleij gpiod_set_consumer_name(cs[i], gpioname); 30257d93aecdSGeert Uytterhoeven num_cs_gpios++; 30267d93aecdSGeert Uytterhoeven continue; 3027f3186dd8SLinus Walleij } 30287d93aecdSGeert Uytterhoeven 30297d93aecdSGeert Uytterhoeven if (ctlr->max_native_cs && i >= ctlr->max_native_cs) { 30307d93aecdSGeert Uytterhoeven dev_err(dev, "Invalid native chip select %d\n", i); 30317d93aecdSGeert Uytterhoeven return -EINVAL; 30327d93aecdSGeert Uytterhoeven } 30337d93aecdSGeert Uytterhoeven native_cs_mask |= BIT(i); 30347d93aecdSGeert Uytterhoeven } 30357d93aecdSGeert Uytterhoeven 3036f60d7270SAndy Shevchenko ctlr->unused_native_cs = ffs(~native_cs_mask) - 1; 3037dbaca8e5SAndy Shevchenko 303882238d2cSAndy Shevchenko if ((ctlr->flags & SPI_CONTROLLER_GPIO_SS) && num_cs_gpios && 3039dbaca8e5SAndy Shevchenko ctlr->max_native_cs && ctlr->unused_native_cs >= ctlr->max_native_cs) { 30407d93aecdSGeert Uytterhoeven dev_err(dev, "No unused native chip select available\n"); 30417d93aecdSGeert Uytterhoeven return -EINVAL; 3042f3186dd8SLinus Walleij } 3043f3186dd8SLinus Walleij 3044f3186dd8SLinus Walleij return 0; 3045f3186dd8SLinus Walleij } 3046f3186dd8SLinus Walleij 3047bdf3a3b5SBoris Brezillon static int spi_controller_check_ops(struct spi_controller *ctlr) 3048bdf3a3b5SBoris Brezillon { 3049bdf3a3b5SBoris Brezillon /* 3050b5932f5cSBoris Brezillon * The controller may implement only the high-level SPI-memory like 3051b5932f5cSBoris Brezillon * operations if it does not support regular SPI transfers, and this is 3052b5932f5cSBoris Brezillon * valid use case. 305376a85704SWilliam Zhang * If ->mem_ops or ->mem_ops->exec_op is NULL, we request that at least 305476a85704SWilliam Zhang * one of the ->transfer_xxx() method be implemented. 3055bdf3a3b5SBoris Brezillon */ 305620064c47SWilliam Zhang if (!ctlr->mem_ops || !ctlr->mem_ops->exec_op) { 305776a85704SWilliam Zhang if (!ctlr->transfer && !ctlr->transfer_one && 3058b5932f5cSBoris Brezillon !ctlr->transfer_one_message) { 3059b5932f5cSBoris Brezillon return -EINVAL; 3060b5932f5cSBoris Brezillon } 306176a85704SWilliam Zhang } 3062bdf3a3b5SBoris Brezillon 3063bdf3a3b5SBoris Brezillon return 0; 3064bdf3a3b5SBoris Brezillon } 3065bdf3a3b5SBoris Brezillon 3066440c4733SAndy Shevchenko /* Allocate dynamic bus number using Linux idr */ 3067440c4733SAndy Shevchenko static int spi_controller_id_alloc(struct spi_controller *ctlr, int start, int end) 3068440c4733SAndy Shevchenko { 3069440c4733SAndy Shevchenko int id; 3070440c4733SAndy Shevchenko 3071440c4733SAndy Shevchenko mutex_lock(&board_lock); 3072440c4733SAndy Shevchenko id = idr_alloc(&spi_master_idr, ctlr, start, end, GFP_KERNEL); 3073440c4733SAndy Shevchenko mutex_unlock(&board_lock); 3074440c4733SAndy Shevchenko if (WARN(id < 0, "couldn't get idr")) 3075440c4733SAndy Shevchenko return id == -ENOSPC ? -EBUSY : id; 3076440c4733SAndy Shevchenko ctlr->bus_num = id; 3077440c4733SAndy Shevchenko return 0; 3078440c4733SAndy Shevchenko } 3079440c4733SAndy Shevchenko 30808ae12a0dSDavid Brownell /** 30818caab75fSGeert Uytterhoeven * spi_register_controller - register SPI master or slave controller 30828caab75fSGeert Uytterhoeven * @ctlr: initialized master, originally from spi_alloc_master() or 30838caab75fSGeert Uytterhoeven * spi_alloc_slave() 308433e34dc6SDavid Brownell * Context: can sleep 30858ae12a0dSDavid Brownell * 30868caab75fSGeert Uytterhoeven * SPI controllers connect to their drivers using some non-SPI bus, 30878ae12a0dSDavid Brownell * such as the platform bus. The final stage of probe() in that code 30888caab75fSGeert Uytterhoeven * includes calling spi_register_controller() to hook up to this SPI bus glue. 30898ae12a0dSDavid Brownell * 30908ae12a0dSDavid Brownell * SPI controllers use board specific (often SOC specific) bus numbers, 30918ae12a0dSDavid Brownell * and board-specific addressing for SPI devices combines those numbers 30928ae12a0dSDavid Brownell * with chip select numbers. Since SPI does not directly support dynamic 30938ae12a0dSDavid Brownell * device identification, boards need configuration tables telling which 30948ae12a0dSDavid Brownell * chip is at which address. 30958ae12a0dSDavid Brownell * 30968ae12a0dSDavid Brownell * This must be called from context that can sleep. It returns zero on 30978caab75fSGeert Uytterhoeven * success, else a negative error code (dropping the controller's refcount). 30980c868461SDavid Brownell * After a successful return, the caller is responsible for calling 30998caab75fSGeert Uytterhoeven * spi_unregister_controller(). 310097d56dc6SJavier Martinez Canillas * 310197d56dc6SJavier Martinez Canillas * Return: zero on success, else a negative error code. 31028ae12a0dSDavid Brownell */ 31038caab75fSGeert Uytterhoeven int spi_register_controller(struct spi_controller *ctlr) 31048ae12a0dSDavid Brownell { 31058caab75fSGeert Uytterhoeven struct device *dev = ctlr->dev.parent; 31062b9603a0SFeng Tang struct boardinfo *bi; 3107440c4733SAndy Shevchenko int first_dynamic; 3108b93318a2SSergei Shtylyov int status; 31098ae12a0dSDavid Brownell 31100c868461SDavid Brownell if (!dev) 31110c868461SDavid Brownell return -ENODEV; 31120c868461SDavid Brownell 3113bdf3a3b5SBoris Brezillon /* 3114bdf3a3b5SBoris Brezillon * Make sure all necessary hooks are implemented before registering 3115bdf3a3b5SBoris Brezillon * the SPI controller. 3116bdf3a3b5SBoris Brezillon */ 3117bdf3a3b5SBoris Brezillon status = spi_controller_check_ops(ctlr); 3118bdf3a3b5SBoris Brezillon if (status) 3119bdf3a3b5SBoris Brezillon return status; 3120bdf3a3b5SBoris Brezillon 3121440c4733SAndy Shevchenko if (ctlr->bus_num < 0) 3122440c4733SAndy Shevchenko ctlr->bus_num = of_alias_get_id(ctlr->dev.of_node, "spi"); 312304b2d03aSGeert Uytterhoeven if (ctlr->bus_num >= 0) { 312495c8222fSDavid Jander /* Devices with a fixed bus num must check-in with the num */ 3125440c4733SAndy Shevchenko status = spi_controller_id_alloc(ctlr, ctlr->bus_num, ctlr->bus_num + 1); 3126440c4733SAndy Shevchenko if (status) 3127440c4733SAndy Shevchenko return status; 31289b61e302SSuniel Mahesh } 31298caab75fSGeert Uytterhoeven if (ctlr->bus_num < 0) { 313042bdd706SLucas Stach first_dynamic = of_alias_get_highest_id("spi"); 313142bdd706SLucas Stach if (first_dynamic < 0) 313242bdd706SLucas Stach first_dynamic = 0; 313342bdd706SLucas Stach else 313442bdd706SLucas Stach first_dynamic++; 313542bdd706SLucas Stach 3136440c4733SAndy Shevchenko status = spi_controller_id_alloc(ctlr, first_dynamic, 0); 3137440c4733SAndy Shevchenko if (status) 3138440c4733SAndy Shevchenko return status; 31398ae12a0dSDavid Brownell } 31408caab75fSGeert Uytterhoeven ctlr->bus_lock_flag = 0; 31418caab75fSGeert Uytterhoeven init_completion(&ctlr->xfer_completion); 314269fa9590SDavid Jander init_completion(&ctlr->cur_msg_completion); 31438caab75fSGeert Uytterhoeven if (!ctlr->max_dma_len) 31448caab75fSGeert Uytterhoeven ctlr->max_dma_len = INT_MAX; 3145cf32b71eSErnst Schwab 3146350de7ceSAndy Shevchenko /* 3147350de7ceSAndy Shevchenko * Register the device, then userspace will see it. 3148350de7ceSAndy Shevchenko * Registration fails if the bus ID is in use. 31498ae12a0dSDavid Brownell */ 31508caab75fSGeert Uytterhoeven dev_set_name(&ctlr->dev, "spi%u", ctlr->bus_num); 31510a919ae4SAndrey Smirnov 3152f48dc6b9SLinus Walleij if (!spi_controller_is_slave(ctlr) && ctlr->use_gpio_descriptors) { 31530a919ae4SAndrey Smirnov status = spi_get_gpio_descs(ctlr); 31540a919ae4SAndrey Smirnov if (status) 3155f9981d4fSAaro Koskinen goto free_bus_id; 31560a919ae4SAndrey Smirnov /* 31570a919ae4SAndrey Smirnov * A controller using GPIO descriptors always 31580a919ae4SAndrey Smirnov * supports SPI_CS_HIGH if need be. 31590a919ae4SAndrey Smirnov */ 31600a919ae4SAndrey Smirnov ctlr->mode_bits |= SPI_CS_HIGH; 31610a919ae4SAndrey Smirnov } 31620a919ae4SAndrey Smirnov 3163f9481b08STudor Ambarus /* 3164f9481b08STudor Ambarus * Even if it's just one always-selected device, there must 3165f9481b08STudor Ambarus * be at least one chipselect. 3166f9481b08STudor Ambarus */ 3167f9981d4fSAaro Koskinen if (!ctlr->num_chipselect) { 3168f9981d4fSAaro Koskinen status = -EINVAL; 3169f9981d4fSAaro Koskinen goto free_bus_id; 3170f9981d4fSAaro Koskinen } 3171f9481b08STudor Ambarus 317295c8222fSDavid Jander /* Setting last_cs to -1 means no chip selected */ 31736bb477dfSYun Zhou ctlr->last_cs = -1; 31746bb477dfSYun Zhou 31758caab75fSGeert Uytterhoeven status = device_add(&ctlr->dev); 3176f9981d4fSAaro Koskinen if (status < 0) 3177f9981d4fSAaro Koskinen goto free_bus_id; 31789b61e302SSuniel Mahesh dev_dbg(dev, "registered %s %s\n", 31798caab75fSGeert Uytterhoeven spi_controller_is_slave(ctlr) ? "slave" : "master", 31809b61e302SSuniel Mahesh dev_name(&ctlr->dev)); 31818ae12a0dSDavid Brownell 3182b5932f5cSBoris Brezillon /* 3183b5932f5cSBoris Brezillon * If we're using a queued driver, start the queue. Note that we don't 3184b5932f5cSBoris Brezillon * need the queueing logic if the driver is only supporting high-level 3185b5932f5cSBoris Brezillon * memory operations. 3186b5932f5cSBoris Brezillon */ 3187b5932f5cSBoris Brezillon if (ctlr->transfer) { 31888caab75fSGeert Uytterhoeven dev_info(dev, "controller is unqueued, this is deprecated\n"); 3189b5932f5cSBoris Brezillon } else if (ctlr->transfer_one || ctlr->transfer_one_message) { 31908caab75fSGeert Uytterhoeven status = spi_controller_initialize_queue(ctlr); 3191ffbbdd21SLinus Walleij if (status) { 31928caab75fSGeert Uytterhoeven device_del(&ctlr->dev); 3193f9981d4fSAaro Koskinen goto free_bus_id; 3194ffbbdd21SLinus Walleij } 3195ffbbdd21SLinus Walleij } 319695c8222fSDavid Jander /* Add statistics */ 31976598b91bSDavid Jander ctlr->pcpu_statistics = spi_alloc_pcpu_stats(dev); 31986598b91bSDavid Jander if (!ctlr->pcpu_statistics) { 31996598b91bSDavid Jander dev_err(dev, "Error allocating per-cpu statistics\n"); 3200d52b095bSDan Carpenter status = -ENOMEM; 32016598b91bSDavid Jander goto destroy_queue; 32026598b91bSDavid Jander } 3203ffbbdd21SLinus Walleij 32042b9603a0SFeng Tang mutex_lock(&board_lock); 32058caab75fSGeert Uytterhoeven list_add_tail(&ctlr->list, &spi_controller_list); 32062b9603a0SFeng Tang list_for_each_entry(bi, &board_list, list) 32078caab75fSGeert Uytterhoeven spi_match_controller_to_boardinfo(ctlr, &bi->board_info); 32082b9603a0SFeng Tang mutex_unlock(&board_lock); 32092b9603a0SFeng Tang 321064bee4d2SMika Westerberg /* Register devices from the device tree and ACPI */ 32118caab75fSGeert Uytterhoeven of_register_spi_devices(ctlr); 32128caab75fSGeert Uytterhoeven acpi_register_spi_devices(ctlr); 3213f9981d4fSAaro Koskinen return status; 3214f9981d4fSAaro Koskinen 32156598b91bSDavid Jander destroy_queue: 32166598b91bSDavid Jander spi_destroy_queue(ctlr); 3217f9981d4fSAaro Koskinen free_bus_id: 3218f9981d4fSAaro Koskinen mutex_lock(&board_lock); 3219f9981d4fSAaro Koskinen idr_remove(&spi_master_idr, ctlr->bus_num); 3220f9981d4fSAaro Koskinen mutex_unlock(&board_lock); 32218ae12a0dSDavid Brownell return status; 32228ae12a0dSDavid Brownell } 32238caab75fSGeert Uytterhoeven EXPORT_SYMBOL_GPL(spi_register_controller); 32248ae12a0dSDavid Brownell 322543cc5a0aSYang Yingliang static void devm_spi_unregister(struct device *dev, void *res) 3226666d5b4cSMark Brown { 322743cc5a0aSYang Yingliang spi_unregister_controller(*(struct spi_controller **)res); 3228666d5b4cSMark Brown } 3229666d5b4cSMark Brown 3230666d5b4cSMark Brown /** 32318caab75fSGeert Uytterhoeven * devm_spi_register_controller - register managed SPI master or slave 32328caab75fSGeert Uytterhoeven * controller 32338caab75fSGeert Uytterhoeven * @dev: device managing SPI controller 32348caab75fSGeert Uytterhoeven * @ctlr: initialized controller, originally from spi_alloc_master() or 32358caab75fSGeert Uytterhoeven * spi_alloc_slave() 3236666d5b4cSMark Brown * Context: can sleep 3237666d5b4cSMark Brown * 32388caab75fSGeert Uytterhoeven * Register a SPI device as with spi_register_controller() which will 323968b892f1SJohan Hovold * automatically be unregistered and freed. 324097d56dc6SJavier Martinez Canillas * 324197d56dc6SJavier Martinez Canillas * Return: zero on success, else a negative error code. 3242666d5b4cSMark Brown */ 32438caab75fSGeert Uytterhoeven int devm_spi_register_controller(struct device *dev, 32448caab75fSGeert Uytterhoeven struct spi_controller *ctlr) 3245666d5b4cSMark Brown { 324643cc5a0aSYang Yingliang struct spi_controller **ptr; 3247666d5b4cSMark Brown int ret; 3248666d5b4cSMark Brown 324943cc5a0aSYang Yingliang ptr = devres_alloc(devm_spi_unregister, sizeof(*ptr), GFP_KERNEL); 325043cc5a0aSYang Yingliang if (!ptr) 325143cc5a0aSYang Yingliang return -ENOMEM; 325259ebbe40STian Tao 325343cc5a0aSYang Yingliang ret = spi_register_controller(ctlr); 325443cc5a0aSYang Yingliang if (!ret) { 325543cc5a0aSYang Yingliang *ptr = ctlr; 325643cc5a0aSYang Yingliang devres_add(dev, ptr); 325743cc5a0aSYang Yingliang } else { 325843cc5a0aSYang Yingliang devres_free(ptr); 325943cc5a0aSYang Yingliang } 326043cc5a0aSYang Yingliang 326143cc5a0aSYang Yingliang return ret; 3262666d5b4cSMark Brown } 32638caab75fSGeert Uytterhoeven EXPORT_SYMBOL_GPL(devm_spi_register_controller); 3264666d5b4cSMark Brown 326534860089SDavid Lamparter static int __unregister(struct device *dev, void *null) 32668ae12a0dSDavid Brownell { 32670c868461SDavid Brownell spi_unregister_device(to_spi_device(dev)); 32688ae12a0dSDavid Brownell return 0; 32698ae12a0dSDavid Brownell } 32708ae12a0dSDavid Brownell 32718ae12a0dSDavid Brownell /** 32728caab75fSGeert Uytterhoeven * spi_unregister_controller - unregister SPI master or slave controller 32738caab75fSGeert Uytterhoeven * @ctlr: the controller being unregistered 327433e34dc6SDavid Brownell * Context: can sleep 32758ae12a0dSDavid Brownell * 32768caab75fSGeert Uytterhoeven * This call is used only by SPI controller drivers, which are the 32778ae12a0dSDavid Brownell * only ones directly touching chip registers. 32788ae12a0dSDavid Brownell * 32798ae12a0dSDavid Brownell * This must be called from context that can sleep. 328068b892f1SJohan Hovold * 328168b892f1SJohan Hovold * Note that this function also drops a reference to the controller. 32828ae12a0dSDavid Brownell */ 32838caab75fSGeert Uytterhoeven void spi_unregister_controller(struct spi_controller *ctlr) 32848ae12a0dSDavid Brownell { 32859b61e302SSuniel Mahesh struct spi_controller *found; 328667f7b278SJohan Hovold int id = ctlr->bus_num; 328789fc9a1aSJeff Garzik 3288ddf75be4SLukas Wunner /* Prevent addition of new devices, unregister existing ones */ 3289ddf75be4SLukas Wunner if (IS_ENABLED(CONFIG_SPI_DYNAMIC)) 32906098475dSMark Brown mutex_lock(&ctlr->add_lock); 3291ddf75be4SLukas Wunner 329284855678SLukas Wunner device_for_each_child(&ctlr->dev, NULL, __unregister); 329384855678SLukas Wunner 32949b61e302SSuniel Mahesh /* First make sure that this controller was ever added */ 32959b61e302SSuniel Mahesh mutex_lock(&board_lock); 329667f7b278SJohan Hovold found = idr_find(&spi_master_idr, id); 32979b61e302SSuniel Mahesh mutex_unlock(&board_lock); 32988caab75fSGeert Uytterhoeven if (ctlr->queued) { 32998caab75fSGeert Uytterhoeven if (spi_destroy_queue(ctlr)) 33008caab75fSGeert Uytterhoeven dev_err(&ctlr->dev, "queue remove failed\n"); 3301ffbbdd21SLinus Walleij } 33022b9603a0SFeng Tang mutex_lock(&board_lock); 33038caab75fSGeert Uytterhoeven list_del(&ctlr->list); 33042b9603a0SFeng Tang mutex_unlock(&board_lock); 33052b9603a0SFeng Tang 33065e844cc3SLukas Wunner device_del(&ctlr->dev); 33075e844cc3SLukas Wunner 330895c8222fSDavid Jander /* Free bus id */ 33099b61e302SSuniel Mahesh mutex_lock(&board_lock); 3310613bd1eaSJarkko Nikula if (found == ctlr) 331167f7b278SJohan Hovold idr_remove(&spi_master_idr, id); 33129b61e302SSuniel Mahesh mutex_unlock(&board_lock); 3313ddf75be4SLukas Wunner 3314ddf75be4SLukas Wunner if (IS_ENABLED(CONFIG_SPI_DYNAMIC)) 33156098475dSMark Brown mutex_unlock(&ctlr->add_lock); 33166c53b45cSMichael Walle 3317702ca026SAndy Shevchenko /* 3318702ca026SAndy Shevchenko * Release the last reference on the controller if its driver 33196c53b45cSMichael Walle * has not yet been converted to devm_spi_alloc_master/slave(). 33206c53b45cSMichael Walle */ 33216c53b45cSMichael Walle if (!ctlr->devm_allocated) 33226c53b45cSMichael Walle put_device(&ctlr->dev); 33238ae12a0dSDavid Brownell } 33248caab75fSGeert Uytterhoeven EXPORT_SYMBOL_GPL(spi_unregister_controller); 33258ae12a0dSDavid Brownell 33268caab75fSGeert Uytterhoeven int spi_controller_suspend(struct spi_controller *ctlr) 3327ffbbdd21SLinus Walleij { 3328ffbbdd21SLinus Walleij int ret; 3329ffbbdd21SLinus Walleij 33308caab75fSGeert Uytterhoeven /* Basically no-ops for non-queued controllers */ 33318caab75fSGeert Uytterhoeven if (!ctlr->queued) 3332ffbbdd21SLinus Walleij return 0; 3333ffbbdd21SLinus Walleij 33348caab75fSGeert Uytterhoeven ret = spi_stop_queue(ctlr); 3335ffbbdd21SLinus Walleij if (ret) 33368caab75fSGeert Uytterhoeven dev_err(&ctlr->dev, "queue stop failed\n"); 3337ffbbdd21SLinus Walleij 3338ffbbdd21SLinus Walleij return ret; 3339ffbbdd21SLinus Walleij } 33408caab75fSGeert Uytterhoeven EXPORT_SYMBOL_GPL(spi_controller_suspend); 3341ffbbdd21SLinus Walleij 33428caab75fSGeert Uytterhoeven int spi_controller_resume(struct spi_controller *ctlr) 3343ffbbdd21SLinus Walleij { 3344ffbbdd21SLinus Walleij int ret; 3345ffbbdd21SLinus Walleij 33468caab75fSGeert Uytterhoeven if (!ctlr->queued) 3347ffbbdd21SLinus Walleij return 0; 3348ffbbdd21SLinus Walleij 33498caab75fSGeert Uytterhoeven ret = spi_start_queue(ctlr); 3350ffbbdd21SLinus Walleij if (ret) 33518caab75fSGeert Uytterhoeven dev_err(&ctlr->dev, "queue restart failed\n"); 3352ffbbdd21SLinus Walleij 3353ffbbdd21SLinus Walleij return ret; 3354ffbbdd21SLinus Walleij } 33558caab75fSGeert Uytterhoeven EXPORT_SYMBOL_GPL(spi_controller_resume); 3356ffbbdd21SLinus Walleij 33578ae12a0dSDavid Brownell /*-------------------------------------------------------------------------*/ 33588ae12a0dSDavid Brownell 3359523baf5aSMartin Sperl /* Core methods for spi_message alterations */ 3360523baf5aSMartin Sperl 33618caab75fSGeert Uytterhoeven static void __spi_replace_transfers_release(struct spi_controller *ctlr, 3362523baf5aSMartin Sperl struct spi_message *msg, 3363523baf5aSMartin Sperl void *res) 3364523baf5aSMartin Sperl { 3365523baf5aSMartin Sperl struct spi_replaced_transfers *rxfer = res; 3366523baf5aSMartin Sperl size_t i; 3367523baf5aSMartin Sperl 336895c8222fSDavid Jander /* Call extra callback if requested */ 3369523baf5aSMartin Sperl if (rxfer->release) 33708caab75fSGeert Uytterhoeven rxfer->release(ctlr, msg, res); 3371523baf5aSMartin Sperl 337295c8222fSDavid Jander /* Insert replaced transfers back into the message */ 3373523baf5aSMartin Sperl list_splice(&rxfer->replaced_transfers, rxfer->replaced_after); 3374523baf5aSMartin Sperl 337595c8222fSDavid Jander /* Remove the formerly inserted entries */ 3376523baf5aSMartin Sperl for (i = 0; i < rxfer->inserted; i++) 3377523baf5aSMartin Sperl list_del(&rxfer->inserted_transfers[i].transfer_list); 3378523baf5aSMartin Sperl } 3379523baf5aSMartin Sperl 3380523baf5aSMartin Sperl /** 3381523baf5aSMartin Sperl * spi_replace_transfers - replace transfers with several transfers 3382523baf5aSMartin Sperl * and register change with spi_message.resources 3383523baf5aSMartin Sperl * @msg: the spi_message we work upon 3384523baf5aSMartin Sperl * @xfer_first: the first spi_transfer we want to replace 3385523baf5aSMartin Sperl * @remove: number of transfers to remove 3386523baf5aSMartin Sperl * @insert: the number of transfers we want to insert instead 3387523baf5aSMartin Sperl * @release: extra release code necessary in some circumstances 3388523baf5aSMartin Sperl * @extradatasize: extra data to allocate (with alignment guarantees 3389523baf5aSMartin Sperl * of struct @spi_transfer) 339005885397SMartin Sperl * @gfp: gfp flags 3391523baf5aSMartin Sperl * 3392523baf5aSMartin Sperl * Returns: pointer to @spi_replaced_transfers, 3393523baf5aSMartin Sperl * PTR_ERR(...) in case of errors. 3394523baf5aSMartin Sperl */ 3395da21fde0SUwe Kleine-König static struct spi_replaced_transfers *spi_replace_transfers( 3396523baf5aSMartin Sperl struct spi_message *msg, 3397523baf5aSMartin Sperl struct spi_transfer *xfer_first, 3398523baf5aSMartin Sperl size_t remove, 3399523baf5aSMartin Sperl size_t insert, 3400523baf5aSMartin Sperl spi_replaced_release_t release, 3401523baf5aSMartin Sperl size_t extradatasize, 3402523baf5aSMartin Sperl gfp_t gfp) 3403523baf5aSMartin Sperl { 3404523baf5aSMartin Sperl struct spi_replaced_transfers *rxfer; 3405523baf5aSMartin Sperl struct spi_transfer *xfer; 3406523baf5aSMartin Sperl size_t i; 3407523baf5aSMartin Sperl 340895c8222fSDavid Jander /* Allocate the structure using spi_res */ 3409523baf5aSMartin Sperl rxfer = spi_res_alloc(msg->spi, __spi_replace_transfers_release, 3410aef97522SGustavo A. R. Silva struct_size(rxfer, inserted_transfers, insert) 3411523baf5aSMartin Sperl + extradatasize, 3412523baf5aSMartin Sperl gfp); 3413523baf5aSMartin Sperl if (!rxfer) 3414523baf5aSMartin Sperl return ERR_PTR(-ENOMEM); 3415523baf5aSMartin Sperl 341695c8222fSDavid Jander /* The release code to invoke before running the generic release */ 3417523baf5aSMartin Sperl rxfer->release = release; 3418523baf5aSMartin Sperl 341995c8222fSDavid Jander /* Assign extradata */ 3420523baf5aSMartin Sperl if (extradatasize) 3421523baf5aSMartin Sperl rxfer->extradata = 3422523baf5aSMartin Sperl &rxfer->inserted_transfers[insert]; 3423523baf5aSMartin Sperl 342495c8222fSDavid Jander /* Init the replaced_transfers list */ 3425523baf5aSMartin Sperl INIT_LIST_HEAD(&rxfer->replaced_transfers); 3426523baf5aSMartin Sperl 3427350de7ceSAndy Shevchenko /* 3428350de7ceSAndy Shevchenko * Assign the list_entry after which we should reinsert 3429523baf5aSMartin Sperl * the @replaced_transfers - it may be spi_message.messages! 3430523baf5aSMartin Sperl */ 3431523baf5aSMartin Sperl rxfer->replaced_after = xfer_first->transfer_list.prev; 3432523baf5aSMartin Sperl 343395c8222fSDavid Jander /* Remove the requested number of transfers */ 3434523baf5aSMartin Sperl for (i = 0; i < remove; i++) { 3435350de7ceSAndy Shevchenko /* 3436350de7ceSAndy Shevchenko * If the entry after replaced_after it is msg->transfers 3437523baf5aSMartin Sperl * then we have been requested to remove more transfers 3438350de7ceSAndy Shevchenko * than are in the list. 3439523baf5aSMartin Sperl */ 3440523baf5aSMartin Sperl if (rxfer->replaced_after->next == &msg->transfers) { 3441523baf5aSMartin Sperl dev_err(&msg->spi->dev, 3442523baf5aSMartin Sperl "requested to remove more spi_transfers than are available\n"); 344395c8222fSDavid Jander /* Insert replaced transfers back into the message */ 3444523baf5aSMartin Sperl list_splice(&rxfer->replaced_transfers, 3445523baf5aSMartin Sperl rxfer->replaced_after); 3446523baf5aSMartin Sperl 344795c8222fSDavid Jander /* Free the spi_replace_transfer structure... */ 3448523baf5aSMartin Sperl spi_res_free(rxfer); 3449523baf5aSMartin Sperl 345095c8222fSDavid Jander /* ...and return with an error */ 3451523baf5aSMartin Sperl return ERR_PTR(-EINVAL); 3452523baf5aSMartin Sperl } 3453523baf5aSMartin Sperl 3454350de7ceSAndy Shevchenko /* 3455350de7ceSAndy Shevchenko * Remove the entry after replaced_after from list of 3456350de7ceSAndy Shevchenko * transfers and add it to list of replaced_transfers. 3457523baf5aSMartin Sperl */ 3458523baf5aSMartin Sperl list_move_tail(rxfer->replaced_after->next, 3459523baf5aSMartin Sperl &rxfer->replaced_transfers); 3460523baf5aSMartin Sperl } 3461523baf5aSMartin Sperl 3462350de7ceSAndy Shevchenko /* 3463350de7ceSAndy Shevchenko * Create copy of the given xfer with identical settings 3464350de7ceSAndy Shevchenko * based on the first transfer to get removed. 3465523baf5aSMartin Sperl */ 3466523baf5aSMartin Sperl for (i = 0; i < insert; i++) { 346795c8222fSDavid Jander /* We need to run in reverse order */ 3468523baf5aSMartin Sperl xfer = &rxfer->inserted_transfers[insert - 1 - i]; 3469523baf5aSMartin Sperl 347095c8222fSDavid Jander /* Copy all spi_transfer data */ 3471523baf5aSMartin Sperl memcpy(xfer, xfer_first, sizeof(*xfer)); 3472523baf5aSMartin Sperl 347395c8222fSDavid Jander /* Add to list */ 3474523baf5aSMartin Sperl list_add(&xfer->transfer_list, rxfer->replaced_after); 3475523baf5aSMartin Sperl 347695c8222fSDavid Jander /* Clear cs_change and delay for all but the last */ 3477523baf5aSMartin Sperl if (i) { 3478523baf5aSMartin Sperl xfer->cs_change = false; 3479bebcfd27SAlexandru Ardelean xfer->delay.value = 0; 3480523baf5aSMartin Sperl } 3481523baf5aSMartin Sperl } 3482523baf5aSMartin Sperl 348395c8222fSDavid Jander /* Set up inserted... */ 3484523baf5aSMartin Sperl rxfer->inserted = insert; 3485523baf5aSMartin Sperl 348695c8222fSDavid Jander /* ...and register it with spi_res/spi_message */ 3487523baf5aSMartin Sperl spi_res_add(msg, rxfer); 3488523baf5aSMartin Sperl 3489523baf5aSMartin Sperl return rxfer; 3490523baf5aSMartin Sperl } 3491523baf5aSMartin Sperl 34928caab75fSGeert Uytterhoeven static int __spi_split_transfer_maxsize(struct spi_controller *ctlr, 3493d9f12122SMartin Sperl struct spi_message *msg, 3494d9f12122SMartin Sperl struct spi_transfer **xferp, 3495d9f12122SMartin Sperl size_t maxsize, 3496d9f12122SMartin Sperl gfp_t gfp) 3497d9f12122SMartin Sperl { 3498d9f12122SMartin Sperl struct spi_transfer *xfer = *xferp, *xfers; 3499d9f12122SMartin Sperl struct spi_replaced_transfers *srt; 3500d9f12122SMartin Sperl size_t offset; 3501d9f12122SMartin Sperl size_t count, i; 3502d9f12122SMartin Sperl 350395c8222fSDavid Jander /* Calculate how many we have to replace */ 3504d9f12122SMartin Sperl count = DIV_ROUND_UP(xfer->len, maxsize); 3505d9f12122SMartin Sperl 350695c8222fSDavid Jander /* Create replacement */ 3507d9f12122SMartin Sperl srt = spi_replace_transfers(msg, xfer, 1, count, NULL, 0, gfp); 3508657d32efSDan Carpenter if (IS_ERR(srt)) 3509657d32efSDan Carpenter return PTR_ERR(srt); 3510d9f12122SMartin Sperl xfers = srt->inserted_transfers; 3511d9f12122SMartin Sperl 3512350de7ceSAndy Shevchenko /* 3513350de7ceSAndy Shevchenko * Now handle each of those newly inserted spi_transfers. 3514350de7ceSAndy Shevchenko * Note that the replacements spi_transfers all are preset 3515d9f12122SMartin Sperl * to the same values as *xferp, so tx_buf, rx_buf and len 3516d9f12122SMartin Sperl * are all identical (as well as most others) 3517d9f12122SMartin Sperl * so we just have to fix up len and the pointers. 3518d9f12122SMartin Sperl * 3519350de7ceSAndy Shevchenko * This also includes support for the depreciated 3520350de7ceSAndy Shevchenko * spi_message.is_dma_mapped interface. 3521d9f12122SMartin Sperl */ 3522d9f12122SMartin Sperl 3523350de7ceSAndy Shevchenko /* 3524350de7ceSAndy Shevchenko * The first transfer just needs the length modified, so we 3525350de7ceSAndy Shevchenko * run it outside the loop. 3526d9f12122SMartin Sperl */ 3527c8dab77aSFabio Estevam xfers[0].len = min_t(size_t, maxsize, xfer[0].len); 3528d9f12122SMartin Sperl 352995c8222fSDavid Jander /* All the others need rx_buf/tx_buf also set */ 3530d9f12122SMartin Sperl for (i = 1, offset = maxsize; i < count; offset += maxsize, i++) { 3531702ca026SAndy Shevchenko /* Update rx_buf, tx_buf and DMA */ 3532d9f12122SMartin Sperl if (xfers[i].rx_buf) 3533d9f12122SMartin Sperl xfers[i].rx_buf += offset; 3534d9f12122SMartin Sperl if (xfers[i].rx_dma) 3535d9f12122SMartin Sperl xfers[i].rx_dma += offset; 3536d9f12122SMartin Sperl if (xfers[i].tx_buf) 3537d9f12122SMartin Sperl xfers[i].tx_buf += offset; 3538d9f12122SMartin Sperl if (xfers[i].tx_dma) 3539d9f12122SMartin Sperl xfers[i].tx_dma += offset; 3540d9f12122SMartin Sperl 354195c8222fSDavid Jander /* Update length */ 3542d9f12122SMartin Sperl xfers[i].len = min(maxsize, xfers[i].len - offset); 3543d9f12122SMartin Sperl } 3544d9f12122SMartin Sperl 3545350de7ceSAndy Shevchenko /* 3546350de7ceSAndy Shevchenko * We set up xferp to the last entry we have inserted, 3547350de7ceSAndy Shevchenko * so that we skip those already split transfers. 3548d9f12122SMartin Sperl */ 3549d9f12122SMartin Sperl *xferp = &xfers[count - 1]; 3550d9f12122SMartin Sperl 355195c8222fSDavid Jander /* Increment statistics counters */ 35526598b91bSDavid Jander SPI_STATISTICS_INCREMENT_FIELD(ctlr->pcpu_statistics, 3553d9f12122SMartin Sperl transfers_split_maxsize); 35546598b91bSDavid Jander SPI_STATISTICS_INCREMENT_FIELD(msg->spi->pcpu_statistics, 3555d9f12122SMartin Sperl transfers_split_maxsize); 3556d9f12122SMartin Sperl 3557d9f12122SMartin Sperl return 0; 3558d9f12122SMartin Sperl } 3559d9f12122SMartin Sperl 3560d9f12122SMartin Sperl /** 3561ce2424d7SMauro Carvalho Chehab * spi_split_transfers_maxsize - split spi transfers into multiple transfers 3562d9f12122SMartin Sperl * when an individual transfer exceeds a 3563d9f12122SMartin Sperl * certain size 35648caab75fSGeert Uytterhoeven * @ctlr: the @spi_controller for this transfer 35653700ce95SMasanari Iida * @msg: the @spi_message to transform 35663700ce95SMasanari Iida * @maxsize: the maximum when to apply this 356710f11a22SJavier Martinez Canillas * @gfp: GFP allocation flags 3568d9f12122SMartin Sperl * 3569d9f12122SMartin Sperl * Return: status of transformation 3570d9f12122SMartin Sperl */ 35718caab75fSGeert Uytterhoeven int spi_split_transfers_maxsize(struct spi_controller *ctlr, 3572d9f12122SMartin Sperl struct spi_message *msg, 3573d9f12122SMartin Sperl size_t maxsize, 3574d9f12122SMartin Sperl gfp_t gfp) 3575d9f12122SMartin Sperl { 3576d9f12122SMartin Sperl struct spi_transfer *xfer; 3577d9f12122SMartin Sperl int ret; 3578d9f12122SMartin Sperl 3579350de7ceSAndy Shevchenko /* 3580350de7ceSAndy Shevchenko * Iterate over the transfer_list, 3581d9f12122SMartin Sperl * but note that xfer is advanced to the last transfer inserted 3582d9f12122SMartin Sperl * to avoid checking sizes again unnecessarily (also xfer does 3583350de7ceSAndy Shevchenko * potentially belong to a different list by the time the 3584350de7ceSAndy Shevchenko * replacement has happened). 3585d9f12122SMartin Sperl */ 3586d9f12122SMartin Sperl list_for_each_entry(xfer, &msg->transfers, transfer_list) { 3587d9f12122SMartin Sperl if (xfer->len > maxsize) { 35888caab75fSGeert Uytterhoeven ret = __spi_split_transfer_maxsize(ctlr, msg, &xfer, 35898caab75fSGeert Uytterhoeven maxsize, gfp); 3590d9f12122SMartin Sperl if (ret) 3591d9f12122SMartin Sperl return ret; 3592d9f12122SMartin Sperl } 3593d9f12122SMartin Sperl } 3594d9f12122SMartin Sperl 3595d9f12122SMartin Sperl return 0; 3596d9f12122SMartin Sperl } 3597d9f12122SMartin Sperl EXPORT_SYMBOL_GPL(spi_split_transfers_maxsize); 35988ae12a0dSDavid Brownell 3599027781f3SLeonard Göhrs 3600027781f3SLeonard Göhrs /** 3601702ca026SAndy Shevchenko * spi_split_transfers_maxwords - split SPI transfers into multiple transfers 3602027781f3SLeonard Göhrs * when an individual transfer exceeds a 3603027781f3SLeonard Göhrs * certain number of SPI words 3604027781f3SLeonard Göhrs * @ctlr: the @spi_controller for this transfer 3605027781f3SLeonard Göhrs * @msg: the @spi_message to transform 3606027781f3SLeonard Göhrs * @maxwords: the number of words to limit each transfer to 3607027781f3SLeonard Göhrs * @gfp: GFP allocation flags 3608027781f3SLeonard Göhrs * 3609027781f3SLeonard Göhrs * Return: status of transformation 3610027781f3SLeonard Göhrs */ 3611027781f3SLeonard Göhrs int spi_split_transfers_maxwords(struct spi_controller *ctlr, 3612027781f3SLeonard Göhrs struct spi_message *msg, 3613027781f3SLeonard Göhrs size_t maxwords, 3614027781f3SLeonard Göhrs gfp_t gfp) 3615027781f3SLeonard Göhrs { 3616027781f3SLeonard Göhrs struct spi_transfer *xfer; 3617027781f3SLeonard Göhrs 3618027781f3SLeonard Göhrs /* 3619027781f3SLeonard Göhrs * Iterate over the transfer_list, 3620027781f3SLeonard Göhrs * but note that xfer is advanced to the last transfer inserted 3621027781f3SLeonard Göhrs * to avoid checking sizes again unnecessarily (also xfer does 3622027781f3SLeonard Göhrs * potentially belong to a different list by the time the 3623027781f3SLeonard Göhrs * replacement has happened). 3624027781f3SLeonard Göhrs */ 3625027781f3SLeonard Göhrs list_for_each_entry(xfer, &msg->transfers, transfer_list) { 3626027781f3SLeonard Göhrs size_t maxsize; 3627027781f3SLeonard Göhrs int ret; 3628027781f3SLeonard Göhrs 36292b308e71SAndy Shevchenko maxsize = maxwords * roundup_pow_of_two(BITS_TO_BYTES(xfer->bits_per_word)); 3630027781f3SLeonard Göhrs if (xfer->len > maxsize) { 3631027781f3SLeonard Göhrs ret = __spi_split_transfer_maxsize(ctlr, msg, &xfer, 3632027781f3SLeonard Göhrs maxsize, gfp); 3633027781f3SLeonard Göhrs if (ret) 3634027781f3SLeonard Göhrs return ret; 3635027781f3SLeonard Göhrs } 3636027781f3SLeonard Göhrs } 3637027781f3SLeonard Göhrs 3638027781f3SLeonard Göhrs return 0; 3639027781f3SLeonard Göhrs } 3640027781f3SLeonard Göhrs EXPORT_SYMBOL_GPL(spi_split_transfers_maxwords); 3641027781f3SLeonard Göhrs 36428ae12a0dSDavid Brownell /*-------------------------------------------------------------------------*/ 36438ae12a0dSDavid Brownell 3644702ca026SAndy Shevchenko /* 3645702ca026SAndy Shevchenko * Core methods for SPI controller protocol drivers. Some of the 36467d077197SDavid Brownell * other core methods are currently defined as inline functions. 36477d077197SDavid Brownell */ 36487d077197SDavid Brownell 36498caab75fSGeert Uytterhoeven static int __spi_validate_bits_per_word(struct spi_controller *ctlr, 36508caab75fSGeert Uytterhoeven u8 bits_per_word) 365163ab645fSStefan Brüns { 36528caab75fSGeert Uytterhoeven if (ctlr->bits_per_word_mask) { 365363ab645fSStefan Brüns /* Only 32 bits fit in the mask */ 365463ab645fSStefan Brüns if (bits_per_word > 32) 365563ab645fSStefan Brüns return -EINVAL; 36568caab75fSGeert Uytterhoeven if (!(ctlr->bits_per_word_mask & SPI_BPW_MASK(bits_per_word))) 365763ab645fSStefan Brüns return -EINVAL; 365863ab645fSStefan Brüns } 365963ab645fSStefan Brüns 366063ab645fSStefan Brüns return 0; 366163ab645fSStefan Brüns } 366263ab645fSStefan Brüns 36637d077197SDavid Brownell /** 3664684a4784STudor Ambarus * spi_set_cs_timing - configure CS setup, hold, and inactive delays 3665684a4784STudor Ambarus * @spi: the device that requires specific CS timing configuration 3666684a4784STudor Ambarus * 3667684a4784STudor Ambarus * Return: zero on success, else a negative error code. 3668684a4784STudor Ambarus */ 3669684a4784STudor Ambarus static int spi_set_cs_timing(struct spi_device *spi) 3670684a4784STudor Ambarus { 3671684a4784STudor Ambarus struct device *parent = spi->controller->dev.parent; 3672684a4784STudor Ambarus int status = 0; 3673684a4784STudor Ambarus 3674303feb3cSAmit Kumar Mahapatra if (spi->controller->set_cs_timing && !spi_get_csgpiod(spi, 0)) { 3675684a4784STudor Ambarus if (spi->controller->auto_runtime_pm) { 3676684a4784STudor Ambarus status = pm_runtime_get_sync(parent); 3677684a4784STudor Ambarus if (status < 0) { 3678684a4784STudor Ambarus pm_runtime_put_noidle(parent); 3679684a4784STudor Ambarus dev_err(&spi->controller->dev, "Failed to power device: %d\n", 3680684a4784STudor Ambarus status); 3681684a4784STudor Ambarus return status; 3682684a4784STudor Ambarus } 3683684a4784STudor Ambarus 3684684a4784STudor Ambarus status = spi->controller->set_cs_timing(spi); 3685684a4784STudor Ambarus pm_runtime_mark_last_busy(parent); 3686684a4784STudor Ambarus pm_runtime_put_autosuspend(parent); 3687684a4784STudor Ambarus } else { 3688684a4784STudor Ambarus status = spi->controller->set_cs_timing(spi); 3689684a4784STudor Ambarus } 3690684a4784STudor Ambarus } 3691684a4784STudor Ambarus return status; 3692684a4784STudor Ambarus } 3693684a4784STudor Ambarus 3694684a4784STudor Ambarus /** 36957d077197SDavid Brownell * spi_setup - setup SPI mode and clock rate 36967d077197SDavid Brownell * @spi: the device whose settings are being modified 36977d077197SDavid Brownell * Context: can sleep, and no requests are queued to the device 36987d077197SDavid Brownell * 36997d077197SDavid Brownell * SPI protocol drivers may need to update the transfer mode if the 37007d077197SDavid Brownell * device doesn't work with its default. They may likewise need 37017d077197SDavid Brownell * to update clock rates or word sizes from initial values. This function 37027d077197SDavid Brownell * changes those settings, and must be called from a context that can sleep. 37037d077197SDavid Brownell * Except for SPI_CS_HIGH, which takes effect immediately, the changes take 37047d077197SDavid Brownell * effect the next time the device is selected and data is transferred to 3705702ca026SAndy Shevchenko * or from it. When this function returns, the SPI device is deselected. 37067d077197SDavid Brownell * 37077d077197SDavid Brownell * Note that this call will fail if the protocol driver specifies an option 37087d077197SDavid Brownell * that the underlying controller or its driver does not support. For 37097d077197SDavid Brownell * example, not all hardware supports wire transfers using nine bit words, 37107d077197SDavid Brownell * LSB-first wire encoding, or active-high chipselects. 371197d56dc6SJavier Martinez Canillas * 371297d56dc6SJavier Martinez Canillas * Return: zero on success, else a negative error code. 37137d077197SDavid Brownell */ 37147d077197SDavid Brownell int spi_setup(struct spi_device *spi) 37157d077197SDavid Brownell { 371683596fbeSGeert Uytterhoeven unsigned bad_bits, ugly_bits; 371773f93db5SPaul Kocialkowski int status = 0; 37187d077197SDavid Brownell 3719d962608cSDragos Bogdan /* 3720350de7ceSAndy Shevchenko * Check mode to prevent that any two of DUAL, QUAD and NO_MOSI/MISO 3721350de7ceSAndy Shevchenko * are set at the same time. 3722f477b7fbSwangyuhang */ 3723d962608cSDragos Bogdan if ((hweight_long(spi->mode & 3724d962608cSDragos Bogdan (SPI_TX_DUAL | SPI_TX_QUAD | SPI_NO_TX)) > 1) || 3725d962608cSDragos Bogdan (hweight_long(spi->mode & 3726d962608cSDragos Bogdan (SPI_RX_DUAL | SPI_RX_QUAD | SPI_NO_RX)) > 1)) { 3727f477b7fbSwangyuhang dev_err(&spi->dev, 3728d962608cSDragos Bogdan "setup: can not select any two of dual, quad and no-rx/tx at the same time\n"); 3729f477b7fbSwangyuhang return -EINVAL; 3730f477b7fbSwangyuhang } 3731350de7ceSAndy Shevchenko /* If it is SPI_3WIRE mode, DUAL and QUAD should be forbidden */ 3732f477b7fbSwangyuhang if ((spi->mode & SPI_3WIRE) && (spi->mode & 37336b03061fSYogesh Narayan Gaur (SPI_TX_DUAL | SPI_TX_QUAD | SPI_TX_OCTAL | 37346b03061fSYogesh Narayan Gaur SPI_RX_DUAL | SPI_RX_QUAD | SPI_RX_OCTAL))) 3735f477b7fbSwangyuhang return -EINVAL; 3736350de7ceSAndy Shevchenko /* 3737350de7ceSAndy Shevchenko * Help drivers fail *cleanly* when they need options 3738350de7ceSAndy Shevchenko * that aren't supported with their current controller. 3739cbaa62e0SDavid Lechner * SPI_CS_WORD has a fallback software implementation, 3740cbaa62e0SDavid Lechner * so it is ignored here. 3741e7db06b5SDavid Brownell */ 3742d962608cSDragos Bogdan bad_bits = spi->mode & ~(spi->controller->mode_bits | SPI_CS_WORD | 3743d962608cSDragos Bogdan SPI_NO_TX | SPI_NO_RX); 374483596fbeSGeert Uytterhoeven ugly_bits = bad_bits & 37456b03061fSYogesh Narayan Gaur (SPI_TX_DUAL | SPI_TX_QUAD | SPI_TX_OCTAL | 37466b03061fSYogesh Narayan Gaur SPI_RX_DUAL | SPI_RX_QUAD | SPI_RX_OCTAL); 374783596fbeSGeert Uytterhoeven if (ugly_bits) { 374883596fbeSGeert Uytterhoeven dev_warn(&spi->dev, 374983596fbeSGeert Uytterhoeven "setup: ignoring unsupported mode bits %x\n", 375083596fbeSGeert Uytterhoeven ugly_bits); 375183596fbeSGeert Uytterhoeven spi->mode &= ~ugly_bits; 375283596fbeSGeert Uytterhoeven bad_bits &= ~ugly_bits; 375383596fbeSGeert Uytterhoeven } 3754e7db06b5SDavid Brownell if (bad_bits) { 3755eb288a1fSLinus Walleij dev_err(&spi->dev, "setup: unsupported mode bits %x\n", 3756e7db06b5SDavid Brownell bad_bits); 3757e7db06b5SDavid Brownell return -EINVAL; 3758e7db06b5SDavid Brownell } 3759e7db06b5SDavid Brownell 3760b3fe2e51SPaul Kocialkowski if (!spi->bits_per_word) { 37617d077197SDavid Brownell spi->bits_per_word = 8; 3762b3fe2e51SPaul Kocialkowski } else { 3763b3fe2e51SPaul Kocialkowski /* 3764b3fe2e51SPaul Kocialkowski * Some controllers may not support the default 8 bits-per-word 3765b3fe2e51SPaul Kocialkowski * so only perform the check when this is explicitly provided. 3766b3fe2e51SPaul Kocialkowski */ 37678caab75fSGeert Uytterhoeven status = __spi_validate_bits_per_word(spi->controller, 37688caab75fSGeert Uytterhoeven spi->bits_per_word); 37695ab8d262SAndy Shevchenko if (status) 37705ab8d262SAndy Shevchenko return status; 3771b3fe2e51SPaul Kocialkowski } 377263ab645fSStefan Brüns 37736820e812STudor Ambarus if (spi->controller->max_speed_hz && 37746820e812STudor Ambarus (!spi->max_speed_hz || 37756820e812STudor Ambarus spi->max_speed_hz > spi->controller->max_speed_hz)) 37768caab75fSGeert Uytterhoeven spi->max_speed_hz = spi->controller->max_speed_hz; 3777052eb2d4SAxel Lin 37784fae3a58SSerge Semin mutex_lock(&spi->controller->io_mutex); 37794fae3a58SSerge Semin 3780c914dbf8SJoe Burmeister if (spi->controller->setup) { 37818caab75fSGeert Uytterhoeven status = spi->controller->setup(spi); 3782c914dbf8SJoe Burmeister if (status) { 3783c914dbf8SJoe Burmeister mutex_unlock(&spi->controller->io_mutex); 3784c914dbf8SJoe Burmeister dev_err(&spi->controller->dev, "Failed to setup device: %d\n", 3785c914dbf8SJoe Burmeister status); 3786c914dbf8SJoe Burmeister return status; 3787c914dbf8SJoe Burmeister } 3788c914dbf8SJoe Burmeister } 37897d077197SDavid Brownell 3790684a4784STudor Ambarus status = spi_set_cs_timing(spi); 3791684a4784STudor Ambarus if (status) { 3792684a4784STudor Ambarus mutex_unlock(&spi->controller->io_mutex); 3793684a4784STudor Ambarus return status; 3794684a4784STudor Ambarus } 3795684a4784STudor Ambarus 3796d948e6caSLuhua Xu if (spi->controller->auto_runtime_pm && spi->controller->set_cs) { 3797dd769f15SMinghao Chi status = pm_runtime_resume_and_get(spi->controller->dev.parent); 3798d948e6caSLuhua Xu if (status < 0) { 37994fae3a58SSerge Semin mutex_unlock(&spi->controller->io_mutex); 3800d948e6caSLuhua Xu dev_err(&spi->controller->dev, "Failed to power device: %d\n", 3801d948e6caSLuhua Xu status); 3802d948e6caSLuhua Xu return status; 3803d948e6caSLuhua Xu } 380457a94607STony Lindgren 380557a94607STony Lindgren /* 380657a94607STony Lindgren * We do not want to return positive value from pm_runtime_get, 380757a94607STony Lindgren * there are many instances of devices calling spi_setup() and 380857a94607STony Lindgren * checking for a non-zero return value instead of a negative 380957a94607STony Lindgren * return value. 381057a94607STony Lindgren */ 381157a94607STony Lindgren status = 0; 381257a94607STony Lindgren 3813d347b4aaSDavid Bauer spi_set_cs(spi, false, true); 3814d948e6caSLuhua Xu pm_runtime_mark_last_busy(spi->controller->dev.parent); 3815d948e6caSLuhua Xu pm_runtime_put_autosuspend(spi->controller->dev.parent); 3816d948e6caSLuhua Xu } else { 3817d347b4aaSDavid Bauer spi_set_cs(spi, false, true); 3818d948e6caSLuhua Xu } 3819abeedb01SFranklin S Cooper Jr 38204fae3a58SSerge Semin mutex_unlock(&spi->controller->io_mutex); 38214fae3a58SSerge Semin 3822924b5867SDouglas Anderson if (spi->rt && !spi->controller->rt) { 3823924b5867SDouglas Anderson spi->controller->rt = true; 3824924b5867SDouglas Anderson spi_set_thread_rt(spi->controller); 3825924b5867SDouglas Anderson } 3826924b5867SDouglas Anderson 38275cb4e1f3SAndy Shevchenko trace_spi_setup(spi, status); 38285cb4e1f3SAndy Shevchenko 382940b82c2dSAndy Shevchenko dev_dbg(&spi->dev, "setup mode %lu, %s%s%s%s%u bits/w, %u Hz max --> %d\n", 383040b82c2dSAndy Shevchenko spi->mode & SPI_MODE_X_MASK, 38317d077197SDavid Brownell (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "", 38327d077197SDavid Brownell (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "", 38337d077197SDavid Brownell (spi->mode & SPI_3WIRE) ? "3wire, " : "", 38347d077197SDavid Brownell (spi->mode & SPI_LOOP) ? "loopback, " : "", 38357d077197SDavid Brownell spi->bits_per_word, spi->max_speed_hz, 38367d077197SDavid Brownell status); 38377d077197SDavid Brownell 38387d077197SDavid Brownell return status; 38397d077197SDavid Brownell } 38407d077197SDavid Brownell EXPORT_SYMBOL_GPL(spi_setup); 38417d077197SDavid Brownell 38426c613f68SAlexandru Ardelean static int _spi_xfer_word_delay_update(struct spi_transfer *xfer, 38436c613f68SAlexandru Ardelean struct spi_device *spi) 38446c613f68SAlexandru Ardelean { 38456c613f68SAlexandru Ardelean int delay1, delay2; 38466c613f68SAlexandru Ardelean 38473984d39bSAlexandru Ardelean delay1 = spi_delay_to_ns(&xfer->word_delay, xfer); 38486c613f68SAlexandru Ardelean if (delay1 < 0) 38496c613f68SAlexandru Ardelean return delay1; 38506c613f68SAlexandru Ardelean 38513984d39bSAlexandru Ardelean delay2 = spi_delay_to_ns(&spi->word_delay, xfer); 38526c613f68SAlexandru Ardelean if (delay2 < 0) 38536c613f68SAlexandru Ardelean return delay2; 38546c613f68SAlexandru Ardelean 38556c613f68SAlexandru Ardelean if (delay1 < delay2) 38566c613f68SAlexandru Ardelean memcpy(&xfer->word_delay, &spi->word_delay, 38576c613f68SAlexandru Ardelean sizeof(xfer->word_delay)); 38586c613f68SAlexandru Ardelean 38596c613f68SAlexandru Ardelean return 0; 38606c613f68SAlexandru Ardelean } 38616c613f68SAlexandru Ardelean 386290808738SMark Brown static int __spi_validate(struct spi_device *spi, struct spi_message *message) 3863cf32b71eSErnst Schwab { 38648caab75fSGeert Uytterhoeven struct spi_controller *ctlr = spi->controller; 3865e6811d1dSLaxman Dewangan struct spi_transfer *xfer; 38666ea31293SAtsushi Nemoto int w_size; 3867cf32b71eSErnst Schwab 386824a0013aSMark Brown if (list_empty(&message->transfers)) 386924a0013aSMark Brown return -EINVAL; 387024a0013aSMark Brown 3871350de7ceSAndy Shevchenko /* 3872350de7ceSAndy Shevchenko * If an SPI controller does not support toggling the CS line on each 387371388b21SDavid Lechner * transfer (indicated by the SPI_CS_WORD flag) or we are using a GPIO 387471388b21SDavid Lechner * for the CS line, we can emulate the CS-per-word hardware function by 3875cbaa62e0SDavid Lechner * splitting transfers into one-word transfers and ensuring that 3876cbaa62e0SDavid Lechner * cs_change is set for each transfer. 3877cbaa62e0SDavid Lechner */ 387871388b21SDavid Lechner if ((spi->mode & SPI_CS_WORD) && (!(ctlr->mode_bits & SPI_CS_WORD) || 3879303feb3cSAmit Kumar Mahapatra spi_get_csgpiod(spi, 0))) { 3880*169f5312SAndy Shevchenko size_t maxsize = BITS_TO_BYTES(spi->bits_per_word); 3881cbaa62e0SDavid Lechner int ret; 3882cbaa62e0SDavid Lechner 3883cbaa62e0SDavid Lechner /* spi_split_transfers_maxsize() requires message->spi */ 3884cbaa62e0SDavid Lechner message->spi = spi; 3885cbaa62e0SDavid Lechner 3886cbaa62e0SDavid Lechner ret = spi_split_transfers_maxsize(ctlr, message, maxsize, 3887cbaa62e0SDavid Lechner GFP_KERNEL); 3888cbaa62e0SDavid Lechner if (ret) 3889cbaa62e0SDavid Lechner return ret; 3890cbaa62e0SDavid Lechner 3891cbaa62e0SDavid Lechner list_for_each_entry(xfer, &message->transfers, transfer_list) { 389295c8222fSDavid Jander /* Don't change cs_change on the last entry in the list */ 3893cbaa62e0SDavid Lechner if (list_is_last(&xfer->transfer_list, &message->transfers)) 3894cbaa62e0SDavid Lechner break; 3895cbaa62e0SDavid Lechner xfer->cs_change = 1; 3896cbaa62e0SDavid Lechner } 3897cbaa62e0SDavid Lechner } 3898cbaa62e0SDavid Lechner 3899350de7ceSAndy Shevchenko /* 3900350de7ceSAndy Shevchenko * Half-duplex links include original MicroWire, and ones with 3901cf32b71eSErnst Schwab * only one data pin like SPI_3WIRE (switches direction) or where 3902cf32b71eSErnst Schwab * either MOSI or MISO is missing. They can also be caused by 3903cf32b71eSErnst Schwab * software limitations. 3904cf32b71eSErnst Schwab */ 39058caab75fSGeert Uytterhoeven if ((ctlr->flags & SPI_CONTROLLER_HALF_DUPLEX) || 39068caab75fSGeert Uytterhoeven (spi->mode & SPI_3WIRE)) { 39078caab75fSGeert Uytterhoeven unsigned flags = ctlr->flags; 3908cf32b71eSErnst Schwab 3909cf32b71eSErnst Schwab list_for_each_entry(xfer, &message->transfers, transfer_list) { 3910cf32b71eSErnst Schwab if (xfer->rx_buf && xfer->tx_buf) 3911cf32b71eSErnst Schwab return -EINVAL; 39128caab75fSGeert Uytterhoeven if ((flags & SPI_CONTROLLER_NO_TX) && xfer->tx_buf) 3913cf32b71eSErnst Schwab return -EINVAL; 39148caab75fSGeert Uytterhoeven if ((flags & SPI_CONTROLLER_NO_RX) && xfer->rx_buf) 3915cf32b71eSErnst Schwab return -EINVAL; 3916cf32b71eSErnst Schwab } 3917cf32b71eSErnst Schwab } 3918cf32b71eSErnst Schwab 3919350de7ceSAndy Shevchenko /* 3920059b8ffeSLaxman Dewangan * Set transfer bits_per_word and max speed as spi device default if 3921059b8ffeSLaxman Dewangan * it is not set for this transfer. 3922f477b7fbSwangyuhang * Set transfer tx_nbits and rx_nbits as single transfer default 3923f477b7fbSwangyuhang * (SPI_NBITS_SINGLE) if it is not set for this transfer. 3924b7bb367aSJonas Bonn * Ensure transfer word_delay is at least as long as that required by 3925b7bb367aSJonas Bonn * device itself. 3926e6811d1dSLaxman Dewangan */ 392777e80588SMartin Sperl message->frame_length = 0; 3928e6811d1dSLaxman Dewangan list_for_each_entry(xfer, &message->transfers, transfer_list) { 39295d7e2b5eSMartin Sperl xfer->effective_speed_hz = 0; 3930078726ceSSourav Poddar message->frame_length += xfer->len; 3931e6811d1dSLaxman Dewangan if (!xfer->bits_per_word) 3932e6811d1dSLaxman Dewangan xfer->bits_per_word = spi->bits_per_word; 3933a6f87fadSAxel Lin 3934a6f87fadSAxel Lin if (!xfer->speed_hz) 3935059b8ffeSLaxman Dewangan xfer->speed_hz = spi->max_speed_hz; 3936a6f87fadSAxel Lin 39378caab75fSGeert Uytterhoeven if (ctlr->max_speed_hz && xfer->speed_hz > ctlr->max_speed_hz) 39388caab75fSGeert Uytterhoeven xfer->speed_hz = ctlr->max_speed_hz; 393956ede94aSGabor Juhos 39408caab75fSGeert Uytterhoeven if (__spi_validate_bits_per_word(ctlr, xfer->bits_per_word)) 3941543bb255SStephen Warren return -EINVAL; 3942a2fd4f9fSMark Brown 39434d94bd21SIvan T. Ivanov /* 39444d94bd21SIvan T. Ivanov * SPI transfer length should be multiple of SPI word size 3945350de7ceSAndy Shevchenko * where SPI word size should be power-of-two multiple. 39464d94bd21SIvan T. Ivanov */ 39474d94bd21SIvan T. Ivanov if (xfer->bits_per_word <= 8) 39484d94bd21SIvan T. Ivanov w_size = 1; 39494d94bd21SIvan T. Ivanov else if (xfer->bits_per_word <= 16) 39504d94bd21SIvan T. Ivanov w_size = 2; 39514d94bd21SIvan T. Ivanov else 39524d94bd21SIvan T. Ivanov w_size = 4; 39534d94bd21SIvan T. Ivanov 39544d94bd21SIvan T. Ivanov /* No partial transfers accepted */ 39556ea31293SAtsushi Nemoto if (xfer->len % w_size) 39564d94bd21SIvan T. Ivanov return -EINVAL; 39574d94bd21SIvan T. Ivanov 39588caab75fSGeert Uytterhoeven if (xfer->speed_hz && ctlr->min_speed_hz && 39598caab75fSGeert Uytterhoeven xfer->speed_hz < ctlr->min_speed_hz) 3960a2fd4f9fSMark Brown return -EINVAL; 3961f477b7fbSwangyuhang 3962f477b7fbSwangyuhang if (xfer->tx_buf && !xfer->tx_nbits) 3963f477b7fbSwangyuhang xfer->tx_nbits = SPI_NBITS_SINGLE; 3964f477b7fbSwangyuhang if (xfer->rx_buf && !xfer->rx_nbits) 3965f477b7fbSwangyuhang xfer->rx_nbits = SPI_NBITS_SINGLE; 3966350de7ceSAndy Shevchenko /* 3967350de7ceSAndy Shevchenko * Check transfer tx/rx_nbits: 39681afd9989SGeert Uytterhoeven * 1. check the value matches one of single, dual and quad 39691afd9989SGeert Uytterhoeven * 2. check tx/rx_nbits match the mode in spi_device 3970f477b7fbSwangyuhang */ 3971db90a441SSourav Poddar if (xfer->tx_buf) { 3972d962608cSDragos Bogdan if (spi->mode & SPI_NO_TX) 3973d962608cSDragos Bogdan return -EINVAL; 3974f477b7fbSwangyuhang if (xfer->tx_nbits != SPI_NBITS_SINGLE && 3975f477b7fbSwangyuhang xfer->tx_nbits != SPI_NBITS_DUAL && 3976f477b7fbSwangyuhang xfer->tx_nbits != SPI_NBITS_QUAD) 3977a2fd4f9fSMark Brown return -EINVAL; 3978f477b7fbSwangyuhang if ((xfer->tx_nbits == SPI_NBITS_DUAL) && 3979f477b7fbSwangyuhang !(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD))) 3980f477b7fbSwangyuhang return -EINVAL; 3981f477b7fbSwangyuhang if ((xfer->tx_nbits == SPI_NBITS_QUAD) && 3982f477b7fbSwangyuhang !(spi->mode & SPI_TX_QUAD)) 3983f477b7fbSwangyuhang return -EINVAL; 3984db90a441SSourav Poddar } 398595c8222fSDavid Jander /* Check transfer rx_nbits */ 3986db90a441SSourav Poddar if (xfer->rx_buf) { 3987d962608cSDragos Bogdan if (spi->mode & SPI_NO_RX) 3988d962608cSDragos Bogdan return -EINVAL; 3989f477b7fbSwangyuhang if (xfer->rx_nbits != SPI_NBITS_SINGLE && 3990f477b7fbSwangyuhang xfer->rx_nbits != SPI_NBITS_DUAL && 3991f477b7fbSwangyuhang xfer->rx_nbits != SPI_NBITS_QUAD) 3992f477b7fbSwangyuhang return -EINVAL; 3993f477b7fbSwangyuhang if ((xfer->rx_nbits == SPI_NBITS_DUAL) && 3994f477b7fbSwangyuhang !(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD))) 3995f477b7fbSwangyuhang return -EINVAL; 3996f477b7fbSwangyuhang if ((xfer->rx_nbits == SPI_NBITS_QUAD) && 3997f477b7fbSwangyuhang !(spi->mode & SPI_RX_QUAD)) 3998f477b7fbSwangyuhang return -EINVAL; 3999e6811d1dSLaxman Dewangan } 4000b7bb367aSJonas Bonn 40016c613f68SAlexandru Ardelean if (_spi_xfer_word_delay_update(xfer, spi)) 40026c613f68SAlexandru Ardelean return -EINVAL; 4003e6811d1dSLaxman Dewangan } 4004e6811d1dSLaxman Dewangan 4005cf32b71eSErnst Schwab message->status = -EINPROGRESS; 400690808738SMark Brown 400790808738SMark Brown return 0; 400890808738SMark Brown } 400990808738SMark Brown 401090808738SMark Brown static int __spi_async(struct spi_device *spi, struct spi_message *message) 401190808738SMark Brown { 40128caab75fSGeert Uytterhoeven struct spi_controller *ctlr = spi->controller; 4013b42faeeeSVladimir Oltean struct spi_transfer *xfer; 401490808738SMark Brown 4015b5932f5cSBoris Brezillon /* 4016b5932f5cSBoris Brezillon * Some controllers do not support doing regular SPI transfers. Return 4017b5932f5cSBoris Brezillon * ENOTSUPP when this is the case. 4018b5932f5cSBoris Brezillon */ 4019b5932f5cSBoris Brezillon if (!ctlr->transfer) 4020b5932f5cSBoris Brezillon return -ENOTSUPP; 4021b5932f5cSBoris Brezillon 402290808738SMark Brown message->spi = spi; 402390808738SMark Brown 40246598b91bSDavid Jander SPI_STATISTICS_INCREMENT_FIELD(ctlr->pcpu_statistics, spi_async); 40256598b91bSDavid Jander SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_async); 4026eca2ebc7SMartin Sperl 402790808738SMark Brown trace_spi_message_submit(message); 402890808738SMark Brown 4029b42faeeeSVladimir Oltean if (!ctlr->ptp_sts_supported) { 4030b42faeeeSVladimir Oltean list_for_each_entry(xfer, &message->transfers, transfer_list) { 4031b42faeeeSVladimir Oltean xfer->ptp_sts_word_pre = 0; 4032b42faeeeSVladimir Oltean ptp_read_system_prets(xfer->ptp_sts); 4033b42faeeeSVladimir Oltean } 4034b42faeeeSVladimir Oltean } 4035b42faeeeSVladimir Oltean 40368caab75fSGeert Uytterhoeven return ctlr->transfer(spi, message); 4037cf32b71eSErnst Schwab } 4038cf32b71eSErnst Schwab 4039568d0697SDavid Brownell /** 4040568d0697SDavid Brownell * spi_async - asynchronous SPI transfer 4041568d0697SDavid Brownell * @spi: device with which data will be exchanged 4042568d0697SDavid Brownell * @message: describes the data transfers, including completion callback 4043702ca026SAndy Shevchenko * Context: any (IRQs may be blocked, etc) 4044568d0697SDavid Brownell * 4045568d0697SDavid Brownell * This call may be used in_irq and other contexts which can't sleep, 4046568d0697SDavid Brownell * as well as from task contexts which can sleep. 4047568d0697SDavid Brownell * 4048568d0697SDavid Brownell * The completion callback is invoked in a context which can't sleep. 4049568d0697SDavid Brownell * Before that invocation, the value of message->status is undefined. 4050568d0697SDavid Brownell * When the callback is issued, message->status holds either zero (to 4051568d0697SDavid Brownell * indicate complete success) or a negative error code. After that 4052568d0697SDavid Brownell * callback returns, the driver which issued the transfer request may 4053568d0697SDavid Brownell * deallocate the associated memory; it's no longer in use by any SPI 4054568d0697SDavid Brownell * core or controller driver code. 4055568d0697SDavid Brownell * 4056568d0697SDavid Brownell * Note that although all messages to a spi_device are handled in 4057568d0697SDavid Brownell * FIFO order, messages may go to different devices in other orders. 4058568d0697SDavid Brownell * Some device might be higher priority, or have various "hard" access 4059568d0697SDavid Brownell * time requirements, for example. 4060568d0697SDavid Brownell * 4061568d0697SDavid Brownell * On detection of any fault during the transfer, processing of 4062568d0697SDavid Brownell * the entire message is aborted, and the device is deselected. 4063568d0697SDavid Brownell * Until returning from the associated message completion callback, 4064568d0697SDavid Brownell * no other spi_message queued to that device will be processed. 4065568d0697SDavid Brownell * (This rule applies equally to all the synchronous transfer calls, 4066568d0697SDavid Brownell * which are wrappers around this core asynchronous primitive.) 406797d56dc6SJavier Martinez Canillas * 406897d56dc6SJavier Martinez Canillas * Return: zero on success, else a negative error code. 4069568d0697SDavid Brownell */ 4070568d0697SDavid Brownell int spi_async(struct spi_device *spi, struct spi_message *message) 4071568d0697SDavid Brownell { 40728caab75fSGeert Uytterhoeven struct spi_controller *ctlr = spi->controller; 4073cf32b71eSErnst Schwab int ret; 4074cf32b71eSErnst Schwab unsigned long flags; 4075568d0697SDavid Brownell 407690808738SMark Brown ret = __spi_validate(spi, message); 407790808738SMark Brown if (ret != 0) 407890808738SMark Brown return ret; 407990808738SMark Brown 40808caab75fSGeert Uytterhoeven spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags); 4081568d0697SDavid Brownell 40828caab75fSGeert Uytterhoeven if (ctlr->bus_lock_flag) 4083cf32b71eSErnst Schwab ret = -EBUSY; 4084cf32b71eSErnst Schwab else 4085cf32b71eSErnst Schwab ret = __spi_async(spi, message); 4086568d0697SDavid Brownell 40878caab75fSGeert Uytterhoeven spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags); 4088cf32b71eSErnst Schwab 4089cf32b71eSErnst Schwab return ret; 4090568d0697SDavid Brownell } 4091568d0697SDavid Brownell EXPORT_SYMBOL_GPL(spi_async); 4092568d0697SDavid Brownell 4093cf32b71eSErnst Schwab /** 4094cf32b71eSErnst Schwab * spi_async_locked - version of spi_async with exclusive bus usage 4095cf32b71eSErnst Schwab * @spi: device with which data will be exchanged 4096cf32b71eSErnst Schwab * @message: describes the data transfers, including completion callback 4097702ca026SAndy Shevchenko * Context: any (IRQs may be blocked, etc) 4098cf32b71eSErnst Schwab * 4099cf32b71eSErnst Schwab * This call may be used in_irq and other contexts which can't sleep, 4100cf32b71eSErnst Schwab * as well as from task contexts which can sleep. 4101cf32b71eSErnst Schwab * 4102cf32b71eSErnst Schwab * The completion callback is invoked in a context which can't sleep. 4103cf32b71eSErnst Schwab * Before that invocation, the value of message->status is undefined. 4104cf32b71eSErnst Schwab * When the callback is issued, message->status holds either zero (to 4105cf32b71eSErnst Schwab * indicate complete success) or a negative error code. After that 4106cf32b71eSErnst Schwab * callback returns, the driver which issued the transfer request may 4107cf32b71eSErnst Schwab * deallocate the associated memory; it's no longer in use by any SPI 4108cf32b71eSErnst Schwab * core or controller driver code. 4109cf32b71eSErnst Schwab * 4110cf32b71eSErnst Schwab * Note that although all messages to a spi_device are handled in 4111cf32b71eSErnst Schwab * FIFO order, messages may go to different devices in other orders. 4112cf32b71eSErnst Schwab * Some device might be higher priority, or have various "hard" access 4113cf32b71eSErnst Schwab * time requirements, for example. 4114cf32b71eSErnst Schwab * 4115cf32b71eSErnst Schwab * On detection of any fault during the transfer, processing of 4116cf32b71eSErnst Schwab * the entire message is aborted, and the device is deselected. 4117cf32b71eSErnst Schwab * Until returning from the associated message completion callback, 4118cf32b71eSErnst Schwab * no other spi_message queued to that device will be processed. 4119cf32b71eSErnst Schwab * (This rule applies equally to all the synchronous transfer calls, 4120cf32b71eSErnst Schwab * which are wrappers around this core asynchronous primitive.) 412197d56dc6SJavier Martinez Canillas * 412297d56dc6SJavier Martinez Canillas * Return: zero on success, else a negative error code. 4123cf32b71eSErnst Schwab */ 4124da21fde0SUwe Kleine-König static int spi_async_locked(struct spi_device *spi, struct spi_message *message) 4125cf32b71eSErnst Schwab { 41268caab75fSGeert Uytterhoeven struct spi_controller *ctlr = spi->controller; 4127cf32b71eSErnst Schwab int ret; 4128cf32b71eSErnst Schwab unsigned long flags; 4129cf32b71eSErnst Schwab 413090808738SMark Brown ret = __spi_validate(spi, message); 413190808738SMark Brown if (ret != 0) 413290808738SMark Brown return ret; 413390808738SMark Brown 41348caab75fSGeert Uytterhoeven spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags); 4135cf32b71eSErnst Schwab 4136cf32b71eSErnst Schwab ret = __spi_async(spi, message); 4137cf32b71eSErnst Schwab 41388caab75fSGeert Uytterhoeven spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags); 4139cf32b71eSErnst Schwab 4140cf32b71eSErnst Schwab return ret; 4141cf32b71eSErnst Schwab 4142cf32b71eSErnst Schwab } 4143cf32b71eSErnst Schwab 4144ae7d2346SDavid Jander static void __spi_transfer_message_noqueue(struct spi_controller *ctlr, struct spi_message *msg) 4145ae7d2346SDavid Jander { 4146ae7d2346SDavid Jander bool was_busy; 4147ae7d2346SDavid Jander int ret; 4148ae7d2346SDavid Jander 4149ae7d2346SDavid Jander mutex_lock(&ctlr->io_mutex); 4150ae7d2346SDavid Jander 41511a9cafcbSDavid Jander was_busy = ctlr->busy; 4152ae7d2346SDavid Jander 415372c5c59bSDavid Jander ctlr->cur_msg = msg; 4154ae7d2346SDavid Jander ret = __spi_pump_transfer_message(ctlr, msg, was_busy); 4155ae7d2346SDavid Jander if (ret) 4156ae7d2346SDavid Jander goto out; 4157ae7d2346SDavid Jander 415869fa9590SDavid Jander ctlr->cur_msg = NULL; 415969fa9590SDavid Jander ctlr->fallback = false; 416069fa9590SDavid Jander 4161ae7d2346SDavid Jander if (!was_busy) { 4162ae7d2346SDavid Jander kfree(ctlr->dummy_rx); 4163ae7d2346SDavid Jander ctlr->dummy_rx = NULL; 4164ae7d2346SDavid Jander kfree(ctlr->dummy_tx); 4165ae7d2346SDavid Jander ctlr->dummy_tx = NULL; 4166ae7d2346SDavid Jander if (ctlr->unprepare_transfer_hardware && 4167ae7d2346SDavid Jander ctlr->unprepare_transfer_hardware(ctlr)) 4168ae7d2346SDavid Jander dev_err(&ctlr->dev, 4169ae7d2346SDavid Jander "failed to unprepare transfer hardware\n"); 4170ae7d2346SDavid Jander spi_idle_runtime_pm(ctlr); 4171ae7d2346SDavid Jander } 4172ae7d2346SDavid Jander 4173ae7d2346SDavid Jander out: 4174ae7d2346SDavid Jander mutex_unlock(&ctlr->io_mutex); 4175ae7d2346SDavid Jander } 4176ae7d2346SDavid Jander 41777d077197SDavid Brownell /*-------------------------------------------------------------------------*/ 41787d077197SDavid Brownell 4179350de7ceSAndy Shevchenko /* 4180350de7ceSAndy Shevchenko * Utility methods for SPI protocol drivers, layered on 41817d077197SDavid Brownell * top of the core. Some other utility methods are defined as 41827d077197SDavid Brownell * inline functions. 41837d077197SDavid Brownell */ 41847d077197SDavid Brownell 41855d870c8eSAndrew Morton static void spi_complete(void *arg) 41865d870c8eSAndrew Morton { 41875d870c8eSAndrew Morton complete(arg); 41885d870c8eSAndrew Morton } 41895d870c8eSAndrew Morton 4190ef4d96ecSMark Brown static int __spi_sync(struct spi_device *spi, struct spi_message *message) 4191cf32b71eSErnst Schwab { 4192cf32b71eSErnst Schwab DECLARE_COMPLETION_ONSTACK(done); 4193cf32b71eSErnst Schwab int status; 41948caab75fSGeert Uytterhoeven struct spi_controller *ctlr = spi->controller; 41950461a414SMark Brown 41960461a414SMark Brown status = __spi_validate(spi, message); 41970461a414SMark Brown if (status != 0) 41980461a414SMark Brown return status; 4199cf32b71eSErnst Schwab 42000461a414SMark Brown message->spi = spi; 4201cf32b71eSErnst Schwab 42026598b91bSDavid Jander SPI_STATISTICS_INCREMENT_FIELD(ctlr->pcpu_statistics, spi_sync); 42036598b91bSDavid Jander SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_sync); 4204eca2ebc7SMartin Sperl 4205350de7ceSAndy Shevchenko /* 4206ae7d2346SDavid Jander * Checking queue_empty here only guarantees async/sync message 4207ae7d2346SDavid Jander * ordering when coming from the same context. It does not need to 4208ae7d2346SDavid Jander * guard against reentrancy from a different context. The io_mutex 4209ae7d2346SDavid Jander * will catch those cases. 42100461a414SMark Brown */ 4211b30f7c8eSMark Brown if (READ_ONCE(ctlr->queue_empty) && !ctlr->must_async) { 4212ae7d2346SDavid Jander message->actual_length = 0; 4213ae7d2346SDavid Jander message->status = -EINPROGRESS; 42140461a414SMark Brown 42150461a414SMark Brown trace_spi_message_submit(message); 42160461a414SMark Brown 4217ae7d2346SDavid Jander SPI_STATISTICS_INCREMENT_FIELD(ctlr->pcpu_statistics, spi_sync_immediate); 4218ae7d2346SDavid Jander SPI_STATISTICS_INCREMENT_FIELD(spi->pcpu_statistics, spi_sync_immediate); 42190461a414SMark Brown 4220ae7d2346SDavid Jander __spi_transfer_message_noqueue(ctlr, message); 4221ae7d2346SDavid Jander 4222ae7d2346SDavid Jander return message->status; 4223ae7d2346SDavid Jander } 4224ae7d2346SDavid Jander 4225ae7d2346SDavid Jander /* 4226ae7d2346SDavid Jander * There are messages in the async queue that could have originated 4227ae7d2346SDavid Jander * from the same context, so we need to preserve ordering. 4228ae7d2346SDavid Jander * Therefor we send the message to the async queue and wait until they 4229ae7d2346SDavid Jander * are completed. 4230ae7d2346SDavid Jander */ 4231ae7d2346SDavid Jander message->complete = spi_complete; 4232ae7d2346SDavid Jander message->context = &done; 4233cf32b71eSErnst Schwab status = spi_async_locked(spi, message); 4234cf32b71eSErnst Schwab if (status == 0) { 4235cf32b71eSErnst Schwab wait_for_completion(&done); 4236cf32b71eSErnst Schwab status = message->status; 4237cf32b71eSErnst Schwab } 4238cf32b71eSErnst Schwab message->context = NULL; 4239ae7d2346SDavid Jander 4240cf32b71eSErnst Schwab return status; 4241cf32b71eSErnst Schwab } 4242cf32b71eSErnst Schwab 42438ae12a0dSDavid Brownell /** 42448ae12a0dSDavid Brownell * spi_sync - blocking/synchronous SPI data transfers 42458ae12a0dSDavid Brownell * @spi: device with which data will be exchanged 42468ae12a0dSDavid Brownell * @message: describes the data transfers 424733e34dc6SDavid Brownell * Context: can sleep 42488ae12a0dSDavid Brownell * 42498ae12a0dSDavid Brownell * This call may only be used from a context that may sleep. The sleep 42508ae12a0dSDavid Brownell * is non-interruptible, and has no timeout. Low-overhead controller 42518ae12a0dSDavid Brownell * drivers may DMA directly into and out of the message buffers. 42528ae12a0dSDavid Brownell * 42538ae12a0dSDavid Brownell * Note that the SPI device's chip select is active during the message, 42548ae12a0dSDavid Brownell * and then is normally disabled between messages. Drivers for some 42558ae12a0dSDavid Brownell * frequently-used devices may want to minimize costs of selecting a chip, 42568ae12a0dSDavid Brownell * by leaving it selected in anticipation that the next message will go 42578ae12a0dSDavid Brownell * to the same chip. (That may increase power usage.) 42588ae12a0dSDavid Brownell * 42590c868461SDavid Brownell * Also, the caller is guaranteeing that the memory associated with the 42600c868461SDavid Brownell * message will not be freed before this call returns. 42610c868461SDavid Brownell * 426297d56dc6SJavier Martinez Canillas * Return: zero on success, else a negative error code. 42638ae12a0dSDavid Brownell */ 42648ae12a0dSDavid Brownell int spi_sync(struct spi_device *spi, struct spi_message *message) 42658ae12a0dSDavid Brownell { 4266ef4d96ecSMark Brown int ret; 4267ef4d96ecSMark Brown 42688caab75fSGeert Uytterhoeven mutex_lock(&spi->controller->bus_lock_mutex); 4269ef4d96ecSMark Brown ret = __spi_sync(spi, message); 42708caab75fSGeert Uytterhoeven mutex_unlock(&spi->controller->bus_lock_mutex); 4271ef4d96ecSMark Brown 4272ef4d96ecSMark Brown return ret; 42738ae12a0dSDavid Brownell } 42748ae12a0dSDavid Brownell EXPORT_SYMBOL_GPL(spi_sync); 42758ae12a0dSDavid Brownell 4276cf32b71eSErnst Schwab /** 4277cf32b71eSErnst Schwab * spi_sync_locked - version of spi_sync with exclusive bus usage 4278cf32b71eSErnst Schwab * @spi: device with which data will be exchanged 4279cf32b71eSErnst Schwab * @message: describes the data transfers 4280cf32b71eSErnst Schwab * Context: can sleep 4281cf32b71eSErnst Schwab * 4282cf32b71eSErnst Schwab * This call may only be used from a context that may sleep. The sleep 4283cf32b71eSErnst Schwab * is non-interruptible, and has no timeout. Low-overhead controller 4284cf32b71eSErnst Schwab * drivers may DMA directly into and out of the message buffers. 4285cf32b71eSErnst Schwab * 4286cf32b71eSErnst Schwab * This call should be used by drivers that require exclusive access to the 428725985edcSLucas De Marchi * SPI bus. It has to be preceded by a spi_bus_lock call. The SPI bus must 4288cf32b71eSErnst Schwab * be released by a spi_bus_unlock call when the exclusive access is over. 4289cf32b71eSErnst Schwab * 429097d56dc6SJavier Martinez Canillas * Return: zero on success, else a negative error code. 4291cf32b71eSErnst Schwab */ 4292cf32b71eSErnst Schwab int spi_sync_locked(struct spi_device *spi, struct spi_message *message) 4293cf32b71eSErnst Schwab { 4294ef4d96ecSMark Brown return __spi_sync(spi, message); 4295cf32b71eSErnst Schwab } 4296cf32b71eSErnst Schwab EXPORT_SYMBOL_GPL(spi_sync_locked); 4297cf32b71eSErnst Schwab 4298cf32b71eSErnst Schwab /** 4299cf32b71eSErnst Schwab * spi_bus_lock - obtain a lock for exclusive SPI bus usage 43008caab75fSGeert Uytterhoeven * @ctlr: SPI bus master that should be locked for exclusive bus access 4301cf32b71eSErnst Schwab * Context: can sleep 4302cf32b71eSErnst Schwab * 4303cf32b71eSErnst Schwab * This call may only be used from a context that may sleep. The sleep 4304cf32b71eSErnst Schwab * is non-interruptible, and has no timeout. 4305cf32b71eSErnst Schwab * 4306cf32b71eSErnst Schwab * This call should be used by drivers that require exclusive access to the 4307cf32b71eSErnst Schwab * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the 4308cf32b71eSErnst Schwab * exclusive access is over. Data transfer must be done by spi_sync_locked 4309cf32b71eSErnst Schwab * and spi_async_locked calls when the SPI bus lock is held. 4310cf32b71eSErnst Schwab * 431197d56dc6SJavier Martinez Canillas * Return: always zero. 4312cf32b71eSErnst Schwab */ 43138caab75fSGeert Uytterhoeven int spi_bus_lock(struct spi_controller *ctlr) 4314cf32b71eSErnst Schwab { 4315cf32b71eSErnst Schwab unsigned long flags; 4316cf32b71eSErnst Schwab 43178caab75fSGeert Uytterhoeven mutex_lock(&ctlr->bus_lock_mutex); 4318cf32b71eSErnst Schwab 43198caab75fSGeert Uytterhoeven spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags); 43208caab75fSGeert Uytterhoeven ctlr->bus_lock_flag = 1; 43218caab75fSGeert Uytterhoeven spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags); 4322cf32b71eSErnst Schwab 432395c8222fSDavid Jander /* Mutex remains locked until spi_bus_unlock() is called */ 4324cf32b71eSErnst Schwab 4325cf32b71eSErnst Schwab return 0; 4326cf32b71eSErnst Schwab } 4327cf32b71eSErnst Schwab EXPORT_SYMBOL_GPL(spi_bus_lock); 4328cf32b71eSErnst Schwab 4329cf32b71eSErnst Schwab /** 4330cf32b71eSErnst Schwab * spi_bus_unlock - release the lock for exclusive SPI bus usage 43318caab75fSGeert Uytterhoeven * @ctlr: SPI bus master that was locked for exclusive bus access 4332cf32b71eSErnst Schwab * Context: can sleep 4333cf32b71eSErnst Schwab * 4334cf32b71eSErnst Schwab * This call may only be used from a context that may sleep. The sleep 4335cf32b71eSErnst Schwab * is non-interruptible, and has no timeout. 4336cf32b71eSErnst Schwab * 4337cf32b71eSErnst Schwab * This call releases an SPI bus lock previously obtained by an spi_bus_lock 4338cf32b71eSErnst Schwab * call. 4339cf32b71eSErnst Schwab * 434097d56dc6SJavier Martinez Canillas * Return: always zero. 4341cf32b71eSErnst Schwab */ 43428caab75fSGeert Uytterhoeven int spi_bus_unlock(struct spi_controller *ctlr) 4343cf32b71eSErnst Schwab { 43448caab75fSGeert Uytterhoeven ctlr->bus_lock_flag = 0; 4345cf32b71eSErnst Schwab 43468caab75fSGeert Uytterhoeven mutex_unlock(&ctlr->bus_lock_mutex); 4347cf32b71eSErnst Schwab 4348cf32b71eSErnst Schwab return 0; 4349cf32b71eSErnst Schwab } 4350cf32b71eSErnst Schwab EXPORT_SYMBOL_GPL(spi_bus_unlock); 4351cf32b71eSErnst Schwab 435295c8222fSDavid Jander /* Portable code must never pass more than 32 bytes */ 4353a9948b61SDavid Brownell #define SPI_BUFSIZ max(32, SMP_CACHE_BYTES) 43548ae12a0dSDavid Brownell 43558ae12a0dSDavid Brownell static u8 *buf; 43568ae12a0dSDavid Brownell 43578ae12a0dSDavid Brownell /** 43588ae12a0dSDavid Brownell * spi_write_then_read - SPI synchronous write followed by read 43598ae12a0dSDavid Brownell * @spi: device with which data will be exchanged 4360702ca026SAndy Shevchenko * @txbuf: data to be written (need not be DMA-safe) 43618ae12a0dSDavid Brownell * @n_tx: size of txbuf, in bytes 4362702ca026SAndy Shevchenko * @rxbuf: buffer into which data will be read (need not be DMA-safe) 436327570497SJiri Pirko * @n_rx: size of rxbuf, in bytes 436433e34dc6SDavid Brownell * Context: can sleep 43658ae12a0dSDavid Brownell * 43668ae12a0dSDavid Brownell * This performs a half duplex MicroWire style transaction with the 43678ae12a0dSDavid Brownell * device, sending txbuf and then reading rxbuf. The return value 43688ae12a0dSDavid Brownell * is zero for success, else a negative errno status code. 4369b885244eSDavid Brownell * This call may only be used from a context that may sleep. 43708ae12a0dSDavid Brownell * 4371c373643bSMark Brown * Parameters to this routine are always copied using a small buffer. 437233e34dc6SDavid Brownell * Performance-sensitive or bulk transfer code should instead use 4373702ca026SAndy Shevchenko * spi_{async,sync}() calls with DMA-safe buffers. 437497d56dc6SJavier Martinez Canillas * 437597d56dc6SJavier Martinez Canillas * Return: zero on success, else a negative error code. 43768ae12a0dSDavid Brownell */ 43778ae12a0dSDavid Brownell int spi_write_then_read(struct spi_device *spi, 43780c4a1590SMark Brown const void *txbuf, unsigned n_tx, 43790c4a1590SMark Brown void *rxbuf, unsigned n_rx) 43808ae12a0dSDavid Brownell { 4381068f4070SDavid Brownell static DEFINE_MUTEX(lock); 43828ae12a0dSDavid Brownell 43838ae12a0dSDavid Brownell int status; 43848ae12a0dSDavid Brownell struct spi_message message; 4385bdff549eSDavid Brownell struct spi_transfer x[2]; 43868ae12a0dSDavid Brownell u8 *local_buf; 43878ae12a0dSDavid Brownell 4388350de7ceSAndy Shevchenko /* 4389350de7ceSAndy Shevchenko * Use preallocated DMA-safe buffer if we can. We can't avoid 4390b3a223eeSMark Brown * copying here, (as a pure convenience thing), but we can 4391b3a223eeSMark Brown * keep heap costs out of the hot path unless someone else is 4392b3a223eeSMark Brown * using the pre-allocated buffer or the transfer is too large. 43938ae12a0dSDavid Brownell */ 4394b3a223eeSMark Brown if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) { 43952cd94c8aSMark Brown local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx), 43962cd94c8aSMark Brown GFP_KERNEL | GFP_DMA); 4397b3a223eeSMark Brown if (!local_buf) 4398b3a223eeSMark Brown return -ENOMEM; 4399b3a223eeSMark Brown } else { 4400b3a223eeSMark Brown local_buf = buf; 4401b3a223eeSMark Brown } 44028ae12a0dSDavid Brownell 44038275c642SVitaly Wool spi_message_init(&message); 44045fe5f05eSJingoo Han memset(x, 0, sizeof(x)); 4405bdff549eSDavid Brownell if (n_tx) { 4406bdff549eSDavid Brownell x[0].len = n_tx; 4407bdff549eSDavid Brownell spi_message_add_tail(&x[0], &message); 4408bdff549eSDavid Brownell } 4409bdff549eSDavid Brownell if (n_rx) { 4410bdff549eSDavid Brownell x[1].len = n_rx; 4411bdff549eSDavid Brownell spi_message_add_tail(&x[1], &message); 4412bdff549eSDavid Brownell } 44138275c642SVitaly Wool 44148ae12a0dSDavid Brownell memcpy(local_buf, txbuf, n_tx); 4415bdff549eSDavid Brownell x[0].tx_buf = local_buf; 4416bdff549eSDavid Brownell x[1].rx_buf = local_buf + n_tx; 44178ae12a0dSDavid Brownell 4418702ca026SAndy Shevchenko /* Do the I/O */ 44198ae12a0dSDavid Brownell status = spi_sync(spi, &message); 44209b938b74SMarc Pignat if (status == 0) 4421bdff549eSDavid Brownell memcpy(rxbuf, x[1].rx_buf, n_rx); 44228ae12a0dSDavid Brownell 4423bdff549eSDavid Brownell if (x[0].tx_buf == buf) 4424068f4070SDavid Brownell mutex_unlock(&lock); 44258ae12a0dSDavid Brownell else 44268ae12a0dSDavid Brownell kfree(local_buf); 44278ae12a0dSDavid Brownell 44288ae12a0dSDavid Brownell return status; 44298ae12a0dSDavid Brownell } 44308ae12a0dSDavid Brownell EXPORT_SYMBOL_GPL(spi_write_then_read); 44318ae12a0dSDavid Brownell 44328ae12a0dSDavid Brownell /*-------------------------------------------------------------------------*/ 44338ae12a0dSDavid Brownell 4434da21fde0SUwe Kleine-König #if IS_ENABLED(CONFIG_OF_DYNAMIC) 443595c8222fSDavid Jander /* Must call put_device() when done with returned spi_device device */ 4436da21fde0SUwe Kleine-König static struct spi_device *of_find_spi_device_by_node(struct device_node *node) 4437ce79d54aSPantelis Antoniou { 4438cfba5de9SSuzuki K Poulose struct device *dev = bus_find_device_by_of_node(&spi_bus_type, node); 4439cfba5de9SSuzuki K Poulose 4440ce79d54aSPantelis Antoniou return dev ? to_spi_device(dev) : NULL; 4441ce79d54aSPantelis Antoniou } 4442ce79d54aSPantelis Antoniou 444395c8222fSDavid Jander /* The spi controllers are not using spi_bus, so we find it with another way */ 44448caab75fSGeert Uytterhoeven static struct spi_controller *of_find_spi_controller_by_node(struct device_node *node) 4445ce79d54aSPantelis Antoniou { 4446ce79d54aSPantelis Antoniou struct device *dev; 4447ce79d54aSPantelis Antoniou 4448cfba5de9SSuzuki K Poulose dev = class_find_device_by_of_node(&spi_master_class, node); 44496c364062SGeert Uytterhoeven if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE)) 4450cfba5de9SSuzuki K Poulose dev = class_find_device_by_of_node(&spi_slave_class, node); 4451ce79d54aSPantelis Antoniou if (!dev) 4452ce79d54aSPantelis Antoniou return NULL; 4453ce79d54aSPantelis Antoniou 445495c8222fSDavid Jander /* Reference got in class_find_device */ 44558caab75fSGeert Uytterhoeven return container_of(dev, struct spi_controller, dev); 4456ce79d54aSPantelis Antoniou } 4457ce79d54aSPantelis Antoniou 4458ce79d54aSPantelis Antoniou static int of_spi_notify(struct notifier_block *nb, unsigned long action, 4459ce79d54aSPantelis Antoniou void *arg) 4460ce79d54aSPantelis Antoniou { 4461ce79d54aSPantelis Antoniou struct of_reconfig_data *rd = arg; 44628caab75fSGeert Uytterhoeven struct spi_controller *ctlr; 4463ce79d54aSPantelis Antoniou struct spi_device *spi; 4464ce79d54aSPantelis Antoniou 4465ce79d54aSPantelis Antoniou switch (of_reconfig_get_state_change(action, arg)) { 4466ce79d54aSPantelis Antoniou case OF_RECONFIG_CHANGE_ADD: 44678caab75fSGeert Uytterhoeven ctlr = of_find_spi_controller_by_node(rd->dn->parent); 44688caab75fSGeert Uytterhoeven if (ctlr == NULL) 446995c8222fSDavid Jander return NOTIFY_OK; /* Not for us */ 4470ce79d54aSPantelis Antoniou 4471bd6c1644SGeert Uytterhoeven if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) { 44728caab75fSGeert Uytterhoeven put_device(&ctlr->dev); 4473bd6c1644SGeert Uytterhoeven return NOTIFY_OK; 4474bd6c1644SGeert Uytterhoeven } 4475bd6c1644SGeert Uytterhoeven 44761a50d940SGeert Uytterhoeven /* 44771a50d940SGeert Uytterhoeven * Clear the flag before adding the device so that fw_devlink 44781a50d940SGeert Uytterhoeven * doesn't skip adding consumers to this device. 44791a50d940SGeert Uytterhoeven */ 44801a50d940SGeert Uytterhoeven rd->dn->fwnode.flags &= ~FWNODE_FLAG_NOT_DEVICE; 44818caab75fSGeert Uytterhoeven spi = of_register_spi_device(ctlr, rd->dn); 44828caab75fSGeert Uytterhoeven put_device(&ctlr->dev); 4483ce79d54aSPantelis Antoniou 4484ce79d54aSPantelis Antoniou if (IS_ERR(spi)) { 448525c56c88SRob Herring pr_err("%s: failed to create for '%pOF'\n", 448625c56c88SRob Herring __func__, rd->dn); 4487e0af98a7SRalf Ramsauer of_node_clear_flag(rd->dn, OF_POPULATED); 4488ce79d54aSPantelis Antoniou return notifier_from_errno(PTR_ERR(spi)); 4489ce79d54aSPantelis Antoniou } 4490ce79d54aSPantelis Antoniou break; 4491ce79d54aSPantelis Antoniou 4492ce79d54aSPantelis Antoniou case OF_RECONFIG_CHANGE_REMOVE: 449395c8222fSDavid Jander /* Already depopulated? */ 4494bd6c1644SGeert Uytterhoeven if (!of_node_check_flag(rd->dn, OF_POPULATED)) 4495bd6c1644SGeert Uytterhoeven return NOTIFY_OK; 4496bd6c1644SGeert Uytterhoeven 449795c8222fSDavid Jander /* Find our device by node */ 4498ce79d54aSPantelis Antoniou spi = of_find_spi_device_by_node(rd->dn); 4499ce79d54aSPantelis Antoniou if (spi == NULL) 450095c8222fSDavid Jander return NOTIFY_OK; /* No? not meant for us */ 4501ce79d54aSPantelis Antoniou 450295c8222fSDavid Jander /* Unregister takes one ref away */ 4503ce79d54aSPantelis Antoniou spi_unregister_device(spi); 4504ce79d54aSPantelis Antoniou 450595c8222fSDavid Jander /* And put the reference of the find */ 4506ce79d54aSPantelis Antoniou put_device(&spi->dev); 4507ce79d54aSPantelis Antoniou break; 4508ce79d54aSPantelis Antoniou } 4509ce79d54aSPantelis Antoniou 4510ce79d54aSPantelis Antoniou return NOTIFY_OK; 4511ce79d54aSPantelis Antoniou } 4512ce79d54aSPantelis Antoniou 4513ce79d54aSPantelis Antoniou static struct notifier_block spi_of_notifier = { 4514ce79d54aSPantelis Antoniou .notifier_call = of_spi_notify, 4515ce79d54aSPantelis Antoniou }; 4516ce79d54aSPantelis Antoniou #else /* IS_ENABLED(CONFIG_OF_DYNAMIC) */ 4517ce79d54aSPantelis Antoniou extern struct notifier_block spi_of_notifier; 4518ce79d54aSPantelis Antoniou #endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */ 4519ce79d54aSPantelis Antoniou 45207f24467fSOctavian Purdila #if IS_ENABLED(CONFIG_ACPI) 45218caab75fSGeert Uytterhoeven static int spi_acpi_controller_match(struct device *dev, const void *data) 45227f24467fSOctavian Purdila { 45237f24467fSOctavian Purdila return ACPI_COMPANION(dev->parent) == data; 45247f24467fSOctavian Purdila } 45257f24467fSOctavian Purdila 45268caab75fSGeert Uytterhoeven static struct spi_controller *acpi_spi_find_controller_by_adev(struct acpi_device *adev) 45277f24467fSOctavian Purdila { 45287f24467fSOctavian Purdila struct device *dev; 45297f24467fSOctavian Purdila 45307f24467fSOctavian Purdila dev = class_find_device(&spi_master_class, NULL, adev, 45318caab75fSGeert Uytterhoeven spi_acpi_controller_match); 45326c364062SGeert Uytterhoeven if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE)) 45336c364062SGeert Uytterhoeven dev = class_find_device(&spi_slave_class, NULL, adev, 45348caab75fSGeert Uytterhoeven spi_acpi_controller_match); 45357f24467fSOctavian Purdila if (!dev) 45367f24467fSOctavian Purdila return NULL; 45377f24467fSOctavian Purdila 45388caab75fSGeert Uytterhoeven return container_of(dev, struct spi_controller, dev); 45397f24467fSOctavian Purdila } 45407f24467fSOctavian Purdila 45417f24467fSOctavian Purdila static struct spi_device *acpi_spi_find_device_by_adev(struct acpi_device *adev) 45427f24467fSOctavian Purdila { 45437f24467fSOctavian Purdila struct device *dev; 45447f24467fSOctavian Purdila 454500500147SSuzuki K Poulose dev = bus_find_device_by_acpi_dev(&spi_bus_type, adev); 45465b16668eSWolfram Sang return to_spi_device(dev); 45477f24467fSOctavian Purdila } 45487f24467fSOctavian Purdila 45497f24467fSOctavian Purdila static int acpi_spi_notify(struct notifier_block *nb, unsigned long value, 45507f24467fSOctavian Purdila void *arg) 45517f24467fSOctavian Purdila { 45527f24467fSOctavian Purdila struct acpi_device *adev = arg; 45538caab75fSGeert Uytterhoeven struct spi_controller *ctlr; 45547f24467fSOctavian Purdila struct spi_device *spi; 45557f24467fSOctavian Purdila 45567f24467fSOctavian Purdila switch (value) { 45577f24467fSOctavian Purdila case ACPI_RECONFIG_DEVICE_ADD: 455862fcb99bSRafael J. Wysocki ctlr = acpi_spi_find_controller_by_adev(acpi_dev_parent(adev)); 45598caab75fSGeert Uytterhoeven if (!ctlr) 45607f24467fSOctavian Purdila break; 45617f24467fSOctavian Purdila 45628caab75fSGeert Uytterhoeven acpi_register_spi_device(ctlr, adev); 45638caab75fSGeert Uytterhoeven put_device(&ctlr->dev); 45647f24467fSOctavian Purdila break; 45657f24467fSOctavian Purdila case ACPI_RECONFIG_DEVICE_REMOVE: 45667f24467fSOctavian Purdila if (!acpi_device_enumerated(adev)) 45677f24467fSOctavian Purdila break; 45687f24467fSOctavian Purdila 45697f24467fSOctavian Purdila spi = acpi_spi_find_device_by_adev(adev); 45707f24467fSOctavian Purdila if (!spi) 45717f24467fSOctavian Purdila break; 45727f24467fSOctavian Purdila 45737f24467fSOctavian Purdila spi_unregister_device(spi); 45747f24467fSOctavian Purdila put_device(&spi->dev); 45757f24467fSOctavian Purdila break; 45767f24467fSOctavian Purdila } 45777f24467fSOctavian Purdila 45787f24467fSOctavian Purdila return NOTIFY_OK; 45797f24467fSOctavian Purdila } 45807f24467fSOctavian Purdila 45817f24467fSOctavian Purdila static struct notifier_block spi_acpi_notifier = { 45827f24467fSOctavian Purdila .notifier_call = acpi_spi_notify, 45837f24467fSOctavian Purdila }; 45847f24467fSOctavian Purdila #else 45857f24467fSOctavian Purdila extern struct notifier_block spi_acpi_notifier; 45867f24467fSOctavian Purdila #endif 45877f24467fSOctavian Purdila 45888ae12a0dSDavid Brownell static int __init spi_init(void) 45898ae12a0dSDavid Brownell { 4590b885244eSDavid Brownell int status; 45918ae12a0dSDavid Brownell 4592e94b1766SChristoph Lameter buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL); 4593b885244eSDavid Brownell if (!buf) { 4594b885244eSDavid Brownell status = -ENOMEM; 4595b885244eSDavid Brownell goto err0; 45968ae12a0dSDavid Brownell } 4597b885244eSDavid Brownell 4598b885244eSDavid Brownell status = bus_register(&spi_bus_type); 4599b885244eSDavid Brownell if (status < 0) 4600b885244eSDavid Brownell goto err1; 4601b885244eSDavid Brownell 4602b885244eSDavid Brownell status = class_register(&spi_master_class); 4603b885244eSDavid Brownell if (status < 0) 4604b885244eSDavid Brownell goto err2; 4605ce79d54aSPantelis Antoniou 46066c364062SGeert Uytterhoeven if (IS_ENABLED(CONFIG_SPI_SLAVE)) { 46076c364062SGeert Uytterhoeven status = class_register(&spi_slave_class); 46086c364062SGeert Uytterhoeven if (status < 0) 46096c364062SGeert Uytterhoeven goto err3; 46106c364062SGeert Uytterhoeven } 46116c364062SGeert Uytterhoeven 46125267720eSFabio Estevam if (IS_ENABLED(CONFIG_OF_DYNAMIC)) 4613ce79d54aSPantelis Antoniou WARN_ON(of_reconfig_notifier_register(&spi_of_notifier)); 46147f24467fSOctavian Purdila if (IS_ENABLED(CONFIG_ACPI)) 46157f24467fSOctavian Purdila WARN_ON(acpi_reconfig_notifier_register(&spi_acpi_notifier)); 4616ce79d54aSPantelis Antoniou 4617b885244eSDavid Brownell return 0; 4618b885244eSDavid Brownell 46196c364062SGeert Uytterhoeven err3: 46206c364062SGeert Uytterhoeven class_unregister(&spi_master_class); 4621b885244eSDavid Brownell err2: 4622b885244eSDavid Brownell bus_unregister(&spi_bus_type); 4623b885244eSDavid Brownell err1: 4624b885244eSDavid Brownell kfree(buf); 4625b885244eSDavid Brownell buf = NULL; 4626b885244eSDavid Brownell err0: 4627b885244eSDavid Brownell return status; 4628b885244eSDavid Brownell } 4629b885244eSDavid Brownell 4630350de7ceSAndy Shevchenko /* 4631350de7ceSAndy Shevchenko * A board_info is normally registered in arch_initcall(), 4632350de7ceSAndy Shevchenko * but even essential drivers wait till later. 4633b885244eSDavid Brownell * 4634350de7ceSAndy Shevchenko * REVISIT only boardinfo really needs static linking. The rest (device and 4635350de7ceSAndy Shevchenko * driver registration) _could_ be dynamically linked (modular) ... Costs 4636b885244eSDavid Brownell * include needing to have boardinfo data structures be much more public. 46378ae12a0dSDavid Brownell */ 4638673c0c00SDavid Brownell postcore_initcall(spi_init); 4639