LCOV - code coverage report
Current view: top level - drivers/spi - spi.c (source / functions) Hit Total Coverage
Test: Real Lines: 19 1153 1.6 %
Date: 2020-10-17 15:46:43 Functions: 0 175 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : // SPI init/core code
       3                 :            : //
       4                 :            : // Copyright (C) 2005 David Brownell
       5                 :            : // Copyright (C) 2008 Secret Lab Technologies Ltd.
       6                 :            : 
       7                 :            : #include <linux/kernel.h>
       8                 :            : #include <linux/device.h>
       9                 :            : #include <linux/init.h>
      10                 :            : #include <linux/cache.h>
      11                 :            : #include <linux/dma-mapping.h>
      12                 :            : #include <linux/dmaengine.h>
      13                 :            : #include <linux/mutex.h>
      14                 :            : #include <linux/of_device.h>
      15                 :            : #include <linux/of_irq.h>
      16                 :            : #include <linux/clk/clk-conf.h>
      17                 :            : #include <linux/slab.h>
      18                 :            : #include <linux/mod_devicetable.h>
      19                 :            : #include <linux/spi/spi.h>
      20                 :            : #include <linux/spi/spi-mem.h>
      21                 :            : #include <linux/of_gpio.h>
      22                 :            : #include <linux/gpio/consumer.h>
      23                 :            : #include <linux/pm_runtime.h>
      24                 :            : #include <linux/pm_domain.h>
      25                 :            : #include <linux/property.h>
      26                 :            : #include <linux/export.h>
      27                 :            : #include <linux/sched/rt.h>
      28                 :            : #include <uapi/linux/sched/types.h>
      29                 :            : #include <linux/delay.h>
      30                 :            : #include <linux/kthread.h>
      31                 :            : #include <linux/ioport.h>
      32                 :            : #include <linux/acpi.h>
      33                 :            : #include <linux/highmem.h>
      34                 :            : #include <linux/idr.h>
      35                 :            : #include <linux/platform_data/x86/apple.h>
      36                 :            : 
      37                 :            : #define CREATE_TRACE_POINTS
      38                 :            : #include <trace/events/spi.h>
      39                 :            : EXPORT_TRACEPOINT_SYMBOL(spi_transfer_start);
      40                 :            : EXPORT_TRACEPOINT_SYMBOL(spi_transfer_stop);
      41                 :            : 
      42                 :            : #include "internals.h"
      43                 :            : 
      44                 :            : static DEFINE_IDR(spi_master_idr);
      45                 :            : 
      46                 :          0 : static void spidev_release(struct device *dev)
      47                 :            : {
      48                 :            :         struct spi_device       *spi = to_spi_device(dev);
      49                 :            : 
      50                 :            :         /* spi controllers may cleanup for released devices */
      51                 :          0 :         if (spi->controller->cleanup)
      52                 :          0 :                 spi->controller->cleanup(spi);
      53                 :            : 
      54                 :          0 :         spi_controller_put(spi->controller);
      55                 :          0 :         kfree(spi->driver_override);
      56                 :          0 :         kfree(spi);
      57                 :          0 : }
      58                 :            : 
      59                 :            : static ssize_t
      60                 :          0 : modalias_show(struct device *dev, struct device_attribute *a, char *buf)
      61                 :            : {
      62                 :            :         const struct spi_device *spi = to_spi_device(dev);
      63                 :            :         int len;
      64                 :            : 
      65                 :            :         len = acpi_device_modalias(dev, buf, PAGE_SIZE - 1);
      66                 :            :         if (len != -ENODEV)
      67                 :            :                 return len;
      68                 :            : 
      69                 :          0 :         return sprintf(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias);
      70                 :            : }
      71                 :            : static DEVICE_ATTR_RO(modalias);
      72                 :            : 
      73                 :          0 : static ssize_t driver_override_store(struct device *dev,
      74                 :            :                                      struct device_attribute *a,
      75                 :            :                                      const char *buf, size_t count)
      76                 :            : {
      77                 :            :         struct spi_device *spi = to_spi_device(dev);
      78                 :          0 :         const char *end = memchr(buf, '\n', count);
      79                 :          0 :         const size_t len = end ? end - buf : count;
      80                 :            :         const char *driver_override, *old;
      81                 :            : 
      82                 :            :         /* We need to keep extra room for a newline when displaying value */
      83                 :          0 :         if (len >= (PAGE_SIZE - 1))
      84                 :            :                 return -EINVAL;
      85                 :            : 
      86                 :          0 :         driver_override = kstrndup(buf, len, GFP_KERNEL);
      87                 :          0 :         if (!driver_override)
      88                 :            :                 return -ENOMEM;
      89                 :            : 
      90                 :            :         device_lock(dev);
      91                 :          0 :         old = spi->driver_override;
      92                 :          0 :         if (len) {
      93                 :          0 :                 spi->driver_override = driver_override;
      94                 :            :         } else {
      95                 :            :                 /* Emptry string, disable driver override */
      96                 :          0 :                 spi->driver_override = NULL;
      97                 :          0 :                 kfree(driver_override);
      98                 :            :         }
      99                 :            :         device_unlock(dev);
     100                 :          0 :         kfree(old);
     101                 :            : 
     102                 :          0 :         return count;
     103                 :            : }
     104                 :            : 
     105                 :          0 : static ssize_t driver_override_show(struct device *dev,
     106                 :            :                                     struct device_attribute *a, char *buf)
     107                 :            : {
     108                 :            :         const struct spi_device *spi = to_spi_device(dev);
     109                 :            :         ssize_t len;
     110                 :            : 
     111                 :            :         device_lock(dev);
     112                 :          0 :         len = snprintf(buf, PAGE_SIZE, "%s\n", spi->driver_override ? : "");
     113                 :            :         device_unlock(dev);
     114                 :          0 :         return len;
     115                 :            : }
     116                 :            : static DEVICE_ATTR_RW(driver_override);
     117                 :            : 
     118                 :            : #define SPI_STATISTICS_ATTRS(field, file)                               \
     119                 :            : static ssize_t spi_controller_##field##_show(struct device *dev,        \
     120                 :            :                                              struct device_attribute *attr, \
     121                 :            :                                              char *buf)                 \
     122                 :            : {                                                                       \
     123                 :            :         struct spi_controller *ctlr = container_of(dev,                 \
     124                 :            :                                          struct spi_controller, dev);   \
     125                 :            :         return spi_statistics_##field##_show(&ctlr->statistics, buf);    \
     126                 :            : }                                                                       \
     127                 :            : static struct device_attribute dev_attr_spi_controller_##field = {      \
     128                 :            :         .attr = { .name = file, .mode = 0444 },                         \
     129                 :            :         .show = spi_controller_##field##_show,                          \
     130                 :            : };                                                                      \
     131                 :            : static ssize_t spi_device_##field##_show(struct device *dev,            \
     132                 :            :                                          struct device_attribute *attr, \
     133                 :            :                                         char *buf)                      \
     134                 :            : {                                                                       \
     135                 :            :         struct spi_device *spi = to_spi_device(dev);                    \
     136                 :            :         return spi_statistics_##field##_show(&spi->statistics, buf);     \
     137                 :            : }                                                                       \
     138                 :            : static struct device_attribute dev_attr_spi_device_##field = {          \
     139                 :            :         .attr = { .name = file, .mode = 0444 },                         \
     140                 :            :         .show = spi_device_##field##_show,                              \
     141                 :            : }
     142                 :            : 
     143                 :            : #define SPI_STATISTICS_SHOW_NAME(name, file, field, format_string)      \
     144                 :            : static ssize_t spi_statistics_##name##_show(struct spi_statistics *stat, \
     145                 :            :                                             char *buf)                  \
     146                 :            : {                                                                       \
     147                 :            :         unsigned long flags;                                            \
     148                 :            :         ssize_t len;                                                    \
     149                 :            :         spin_lock_irqsave(&stat->lock, flags);                           \
     150                 :            :         len = sprintf(buf, format_string, stat->field);                      \
     151                 :            :         spin_unlock_irqrestore(&stat->lock, flags);                      \
     152                 :            :         return len;                                                     \
     153                 :            : }                                                                       \
     154                 :            : SPI_STATISTICS_ATTRS(name, file)
     155                 :            : 
     156                 :            : #define SPI_STATISTICS_SHOW(field, format_string)                       \
     157                 :            :         SPI_STATISTICS_SHOW_NAME(field, __stringify(field),             \
     158                 :            :                                  field, format_string)
     159                 :            : 
     160                 :          0 : SPI_STATISTICS_SHOW(messages, "%lu");
     161                 :          0 : SPI_STATISTICS_SHOW(transfers, "%lu");
     162                 :          0 : SPI_STATISTICS_SHOW(errors, "%lu");
     163                 :          0 : SPI_STATISTICS_SHOW(timedout, "%lu");
     164                 :            : 
     165                 :          0 : SPI_STATISTICS_SHOW(spi_sync, "%lu");
     166                 :          0 : SPI_STATISTICS_SHOW(spi_sync_immediate, "%lu");
     167                 :          0 : SPI_STATISTICS_SHOW(spi_async, "%lu");
     168                 :            : 
     169                 :          0 : SPI_STATISTICS_SHOW(bytes, "%llu");
     170                 :          0 : SPI_STATISTICS_SHOW(bytes_rx, "%llu");
     171                 :          0 : SPI_STATISTICS_SHOW(bytes_tx, "%llu");
     172                 :            : 
     173                 :            : #define SPI_STATISTICS_TRANSFER_BYTES_HISTO(index, number)              \
     174                 :            :         SPI_STATISTICS_SHOW_NAME(transfer_bytes_histo##index,           \
     175                 :            :                                  "transfer_bytes_histo_" number,      \
     176                 :            :                                  transfer_bytes_histo[index],  "%lu")
     177                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(0,  "0-1");
     178                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(1,  "2-3");
     179                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(2,  "4-7");
     180                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(3,  "8-15");
     181                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(4,  "16-31");
     182                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(5,  "32-63");
     183                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(6,  "64-127");
     184                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(7,  "128-255");
     185                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(8,  "256-511");
     186                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(9,  "512-1023");
     187                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(10, "1024-2047");
     188                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(11, "2048-4095");
     189                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(12, "4096-8191");
     190                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(13, "8192-16383");
     191                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(14, "16384-32767");
     192                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(15, "32768-65535");
     193                 :          0 : SPI_STATISTICS_TRANSFER_BYTES_HISTO(16, "65536+");
     194                 :            : 
     195                 :          0 : SPI_STATISTICS_SHOW(transfers_split_maxsize, "%lu");
     196                 :            : 
     197                 :            : static struct attribute *spi_dev_attrs[] = {
     198                 :            :         &dev_attr_modalias.attr,
     199                 :            :         &dev_attr_driver_override.attr,
     200                 :            :         NULL,
     201                 :            : };
     202                 :            : 
     203                 :            : static const struct attribute_group spi_dev_group = {
     204                 :            :         .attrs  = spi_dev_attrs,
     205                 :            : };
     206                 :            : 
     207                 :            : static struct attribute *spi_device_statistics_attrs[] = {
     208                 :            :         &dev_attr_spi_device_messages.attr,
     209                 :            :         &dev_attr_spi_device_transfers.attr,
     210                 :            :         &dev_attr_spi_device_errors.attr,
     211                 :            :         &dev_attr_spi_device_timedout.attr,
     212                 :            :         &dev_attr_spi_device_spi_sync.attr,
     213                 :            :         &dev_attr_spi_device_spi_sync_immediate.attr,
     214                 :            :         &dev_attr_spi_device_spi_async.attr,
     215                 :            :         &dev_attr_spi_device_bytes.attr,
     216                 :            :         &dev_attr_spi_device_bytes_rx.attr,
     217                 :            :         &dev_attr_spi_device_bytes_tx.attr,
     218                 :            :         &dev_attr_spi_device_transfer_bytes_histo0.attr,
     219                 :            :         &dev_attr_spi_device_transfer_bytes_histo1.attr,
     220                 :            :         &dev_attr_spi_device_transfer_bytes_histo2.attr,
     221                 :            :         &dev_attr_spi_device_transfer_bytes_histo3.attr,
     222                 :            :         &dev_attr_spi_device_transfer_bytes_histo4.attr,
     223                 :            :         &dev_attr_spi_device_transfer_bytes_histo5.attr,
     224                 :            :         &dev_attr_spi_device_transfer_bytes_histo6.attr,
     225                 :            :         &dev_attr_spi_device_transfer_bytes_histo7.attr,
     226                 :            :         &dev_attr_spi_device_transfer_bytes_histo8.attr,
     227                 :            :         &dev_attr_spi_device_transfer_bytes_histo9.attr,
     228                 :            :         &dev_attr_spi_device_transfer_bytes_histo10.attr,
     229                 :            :         &dev_attr_spi_device_transfer_bytes_histo11.attr,
     230                 :            :         &dev_attr_spi_device_transfer_bytes_histo12.attr,
     231                 :            :         &dev_attr_spi_device_transfer_bytes_histo13.attr,
     232                 :            :         &dev_attr_spi_device_transfer_bytes_histo14.attr,
     233                 :            :         &dev_attr_spi_device_transfer_bytes_histo15.attr,
     234                 :            :         &dev_attr_spi_device_transfer_bytes_histo16.attr,
     235                 :            :         &dev_attr_spi_device_transfers_split_maxsize.attr,
     236                 :            :         NULL,
     237                 :            : };
     238                 :            : 
     239                 :            : static const struct attribute_group spi_device_statistics_group = {
     240                 :            :         .name  = "statistics",
     241                 :            :         .attrs  = spi_device_statistics_attrs,
     242                 :            : };
     243                 :            : 
     244                 :            : static const struct attribute_group *spi_dev_groups[] = {
     245                 :            :         &spi_dev_group,
     246                 :            :         &spi_device_statistics_group,
     247                 :            :         NULL,
     248                 :            : };
     249                 :            : 
     250                 :            : static struct attribute *spi_controller_statistics_attrs[] = {
     251                 :            :         &dev_attr_spi_controller_messages.attr,
     252                 :            :         &dev_attr_spi_controller_transfers.attr,
     253                 :            :         &dev_attr_spi_controller_errors.attr,
     254                 :            :         &dev_attr_spi_controller_timedout.attr,
     255                 :            :         &dev_attr_spi_controller_spi_sync.attr,
     256                 :            :         &dev_attr_spi_controller_spi_sync_immediate.attr,
     257                 :            :         &dev_attr_spi_controller_spi_async.attr,
     258                 :            :         &dev_attr_spi_controller_bytes.attr,
     259                 :            :         &dev_attr_spi_controller_bytes_rx.attr,
     260                 :            :         &dev_attr_spi_controller_bytes_tx.attr,
     261                 :            :         &dev_attr_spi_controller_transfer_bytes_histo0.attr,
     262                 :            :         &dev_attr_spi_controller_transfer_bytes_histo1.attr,
     263                 :            :         &dev_attr_spi_controller_transfer_bytes_histo2.attr,
     264                 :            :         &dev_attr_spi_controller_transfer_bytes_histo3.attr,
     265                 :            :         &dev_attr_spi_controller_transfer_bytes_histo4.attr,
     266                 :            :         &dev_attr_spi_controller_transfer_bytes_histo5.attr,
     267                 :            :         &dev_attr_spi_controller_transfer_bytes_histo6.attr,
     268                 :            :         &dev_attr_spi_controller_transfer_bytes_histo7.attr,
     269                 :            :         &dev_attr_spi_controller_transfer_bytes_histo8.attr,
     270                 :            :         &dev_attr_spi_controller_transfer_bytes_histo9.attr,
     271                 :            :         &dev_attr_spi_controller_transfer_bytes_histo10.attr,
     272                 :            :         &dev_attr_spi_controller_transfer_bytes_histo11.attr,
     273                 :            :         &dev_attr_spi_controller_transfer_bytes_histo12.attr,
     274                 :            :         &dev_attr_spi_controller_transfer_bytes_histo13.attr,
     275                 :            :         &dev_attr_spi_controller_transfer_bytes_histo14.attr,
     276                 :            :         &dev_attr_spi_controller_transfer_bytes_histo15.attr,
     277                 :            :         &dev_attr_spi_controller_transfer_bytes_histo16.attr,
     278                 :            :         &dev_attr_spi_controller_transfers_split_maxsize.attr,
     279                 :            :         NULL,
     280                 :            : };
     281                 :            : 
     282                 :            : static const struct attribute_group spi_controller_statistics_group = {
     283                 :            :         .name  = "statistics",
     284                 :            :         .attrs  = spi_controller_statistics_attrs,
     285                 :            : };
     286                 :            : 
     287                 :            : static const struct attribute_group *spi_master_groups[] = {
     288                 :            :         &spi_controller_statistics_group,
     289                 :            :         NULL,
     290                 :            : };
     291                 :            : 
     292                 :          0 : void spi_statistics_add_transfer_stats(struct spi_statistics *stats,
     293                 :            :                                        struct spi_transfer *xfer,
     294                 :            :                                        struct spi_controller *ctlr)
     295                 :            : {
     296                 :            :         unsigned long flags;
     297                 :          0 :         int l2len = min(fls(xfer->len), SPI_STATISTICS_HISTO_SIZE) - 1;
     298                 :            : 
     299                 :          0 :         if (l2len < 0)
     300                 :            :                 l2len = 0;
     301                 :            : 
     302                 :          0 :         spin_lock_irqsave(&stats->lock, flags);
     303                 :            : 
     304                 :          0 :         stats->transfers++;
     305                 :          0 :         stats->transfer_bytes_histo[l2len]++;
     306                 :            : 
     307                 :          0 :         stats->bytes += xfer->len;
     308                 :          0 :         if ((xfer->tx_buf) &&
     309                 :          0 :             (xfer->tx_buf != ctlr->dummy_tx))
     310                 :          0 :                 stats->bytes_tx += xfer->len;
     311                 :          0 :         if ((xfer->rx_buf) &&
     312                 :          0 :             (xfer->rx_buf != ctlr->dummy_rx))
     313                 :          0 :                 stats->bytes_rx += xfer->len;
     314                 :            : 
     315                 :            :         spin_unlock_irqrestore(&stats->lock, flags);
     316                 :          0 : }
     317                 :            : EXPORT_SYMBOL_GPL(spi_statistics_add_transfer_stats);
     318                 :            : 
     319                 :            : /* modalias support makes "modprobe $MODALIAS" new-style hotplug work,
     320                 :            :  * and the sysfs version makes coldplug work too.
     321                 :            :  */
     322                 :            : 
     323                 :          0 : static const struct spi_device_id *spi_match_id(const struct spi_device_id *id,
     324                 :            :                                                 const struct spi_device *sdev)
     325                 :            : {
     326                 :          0 :         while (id->name[0]) {
     327                 :          0 :                 if (!strcmp(sdev->modalias, id->name))
     328                 :          0 :                         return id;
     329                 :          0 :                 id++;
     330                 :            :         }
     331                 :            :         return NULL;
     332                 :            : }
     333                 :            : 
     334                 :          0 : const struct spi_device_id *spi_get_device_id(const struct spi_device *sdev)
     335                 :            : {
     336                 :          0 :         const struct spi_driver *sdrv = to_spi_driver(sdev->dev.driver);
     337                 :            : 
     338                 :          0 :         return spi_match_id(sdrv->id_table, sdev);
     339                 :            : }
     340                 :            : EXPORT_SYMBOL_GPL(spi_get_device_id);
     341                 :            : 
     342                 :          0 : static int spi_match_device(struct device *dev, struct device_driver *drv)
     343                 :            : {
     344                 :            :         const struct spi_device *spi = to_spi_device(dev);
     345                 :            :         const struct spi_driver *sdrv = to_spi_driver(drv);
     346                 :            : 
     347                 :            :         /* Check override first, and if set, only use the named driver */
     348                 :          0 :         if (spi->driver_override)
     349                 :          0 :                 return strcmp(spi->driver_override, drv->name) == 0;
     350                 :            : 
     351                 :            :         /* Attempt an OF style match */
     352                 :          0 :         if (of_driver_match_device(dev, drv))
     353                 :            :                 return 1;
     354                 :            : 
     355                 :            :         /* Then try ACPI */
     356                 :            :         if (acpi_driver_match_device(dev, drv))
     357                 :            :                 return 1;
     358                 :            : 
     359                 :          0 :         if (sdrv->id_table)
     360                 :          0 :                 return !!spi_match_id(sdrv->id_table, spi);
     361                 :            : 
     362                 :          0 :         return strcmp(spi->modalias, drv->name) == 0;
     363                 :            : }
     364                 :            : 
     365                 :          0 : static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
     366                 :            : {
     367                 :            :         const struct spi_device         *spi = to_spi_device(dev);
     368                 :            :         int rc;
     369                 :            : 
     370                 :            :         rc = acpi_device_uevent_modalias(dev, env);
     371                 :            :         if (rc != -ENODEV)
     372                 :            :                 return rc;
     373                 :            : 
     374                 :          0 :         return add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias);
     375                 :            : }
     376                 :            : 
     377                 :            : struct bus_type spi_bus_type = {
     378                 :            :         .name           = "spi",
     379                 :            :         .dev_groups     = spi_dev_groups,
     380                 :            :         .match          = spi_match_device,
     381                 :            :         .uevent         = spi_uevent,
     382                 :            : };
     383                 :            : EXPORT_SYMBOL_GPL(spi_bus_type);
     384                 :            : 
     385                 :            : 
     386                 :          0 : static int spi_drv_probe(struct device *dev)
     387                 :            : {
     388                 :          0 :         const struct spi_driver         *sdrv = to_spi_driver(dev->driver);
     389                 :            :         struct spi_device               *spi = to_spi_device(dev);
     390                 :            :         int ret;
     391                 :            : 
     392                 :          0 :         ret = of_clk_set_defaults(dev->of_node, false);
     393                 :          0 :         if (ret)
     394                 :            :                 return ret;
     395                 :            : 
     396                 :          0 :         if (dev->of_node) {
     397                 :          0 :                 spi->irq = of_irq_get(dev->of_node, 0);
     398                 :          0 :                 if (spi->irq == -EPROBE_DEFER)
     399                 :            :                         return -EPROBE_DEFER;
     400                 :          0 :                 if (spi->irq < 0)
     401                 :          0 :                         spi->irq = 0;
     402                 :            :         }
     403                 :            : 
     404                 :          0 :         ret = dev_pm_domain_attach(dev, true);
     405                 :          0 :         if (ret)
     406                 :            :                 return ret;
     407                 :            : 
     408                 :          0 :         ret = sdrv->probe(spi);
     409                 :          0 :         if (ret)
     410                 :          0 :                 dev_pm_domain_detach(dev, true);
     411                 :            : 
     412                 :          0 :         return ret;
     413                 :            : }
     414                 :            : 
     415                 :          0 : static int spi_drv_remove(struct device *dev)
     416                 :            : {
     417                 :          0 :         const struct spi_driver         *sdrv = to_spi_driver(dev->driver);
     418                 :            :         int ret;
     419                 :            : 
     420                 :          0 :         ret = sdrv->remove(to_spi_device(dev));
     421                 :          0 :         dev_pm_domain_detach(dev, true);
     422                 :            : 
     423                 :          0 :         return ret;
     424                 :            : }
     425                 :            : 
     426                 :          0 : static void spi_drv_shutdown(struct device *dev)
     427                 :            : {
     428                 :          0 :         const struct spi_driver         *sdrv = to_spi_driver(dev->driver);
     429                 :            : 
     430                 :          0 :         sdrv->shutdown(to_spi_device(dev));
     431                 :          0 : }
     432                 :            : 
     433                 :            : /**
     434                 :            :  * __spi_register_driver - register a SPI driver
     435                 :            :  * @owner: owner module of the driver to register
     436                 :            :  * @sdrv: the driver to register
     437                 :            :  * Context: can sleep
     438                 :            :  *
     439                 :            :  * Return: zero on success, else a negative error code.
     440                 :            :  */
     441                 :          3 : int __spi_register_driver(struct module *owner, struct spi_driver *sdrv)
     442                 :            : {
     443                 :          3 :         sdrv->driver.owner = owner;
     444                 :          3 :         sdrv->driver.bus = &spi_bus_type;
     445                 :          3 :         if (sdrv->probe)
     446                 :          3 :                 sdrv->driver.probe = spi_drv_probe;
     447                 :          3 :         if (sdrv->remove)
     448                 :          3 :                 sdrv->driver.remove = spi_drv_remove;
     449                 :          3 :         if (sdrv->shutdown)
     450                 :          0 :                 sdrv->driver.shutdown = spi_drv_shutdown;
     451                 :          3 :         return driver_register(&sdrv->driver);
     452                 :            : }
     453                 :            : EXPORT_SYMBOL_GPL(__spi_register_driver);
     454                 :            : 
     455                 :            : /*-------------------------------------------------------------------------*/
     456                 :            : 
     457                 :            : /* SPI devices should normally not be created by SPI device drivers; that
     458                 :            :  * would make them board-specific.  Similarly with SPI controller drivers.
     459                 :            :  * Device registration normally goes into like arch/.../mach.../board-YYY.c
     460                 :            :  * with other readonly (flashable) information about mainboard devices.
     461                 :            :  */
     462                 :            : 
     463                 :            : struct boardinfo {
     464                 :            :         struct list_head        list;
     465                 :            :         struct spi_board_info   board_info;
     466                 :            : };
     467                 :            : 
     468                 :            : static LIST_HEAD(board_list);
     469                 :            : static LIST_HEAD(spi_controller_list);
     470                 :            : 
     471                 :            : /*
     472                 :            :  * Used to protect add/del opertion for board_info list and
     473                 :            :  * spi_controller list, and their matching process
     474                 :            :  * also used to protect object of type struct idr
     475                 :            :  */
     476                 :            : static DEFINE_MUTEX(board_lock);
     477                 :            : 
     478                 :            : /*
     479                 :            :  * Prevents addition of devices with same chip select and
     480                 :            :  * addition of devices below an unregistering controller.
     481                 :            :  */
     482                 :            : static DEFINE_MUTEX(spi_add_lock);
     483                 :            : 
     484                 :            : /**
     485                 :            :  * spi_alloc_device - Allocate a new SPI device
     486                 :            :  * @ctlr: Controller to which device is connected
     487                 :            :  * Context: can sleep
     488                 :            :  *
     489                 :            :  * Allows a driver to allocate and initialize a spi_device without
     490                 :            :  * registering it immediately.  This allows a driver to directly
     491                 :            :  * fill the spi_device with device parameters before calling
     492                 :            :  * spi_add_device() on it.
     493                 :            :  *
     494                 :            :  * Caller is responsible to call spi_add_device() on the returned
     495                 :            :  * spi_device structure to add it to the SPI controller.  If the caller
     496                 :            :  * needs to discard the spi_device without adding it, then it should
     497                 :            :  * call spi_dev_put() on it.
     498                 :            :  *
     499                 :            :  * Return: a pointer to the new device, or NULL.
     500                 :            :  */
     501                 :          0 : struct spi_device *spi_alloc_device(struct spi_controller *ctlr)
     502                 :            : {
     503                 :            :         struct spi_device       *spi;
     504                 :            : 
     505                 :          0 :         if (!spi_controller_get(ctlr))
     506                 :            :                 return NULL;
     507                 :            : 
     508                 :          0 :         spi = kzalloc(sizeof(*spi), GFP_KERNEL);
     509                 :          0 :         if (!spi) {
     510                 :            :                 spi_controller_put(ctlr);
     511                 :            :                 return NULL;
     512                 :            :         }
     513                 :            : 
     514                 :          0 :         spi->master = spi->controller = ctlr;
     515                 :          0 :         spi->dev.parent = &ctlr->dev;
     516                 :          0 :         spi->dev.bus = &spi_bus_type;
     517                 :          0 :         spi->dev.release = spidev_release;
     518                 :          0 :         spi->cs_gpio = -ENOENT;
     519                 :            : 
     520                 :          0 :         spin_lock_init(&spi->statistics.lock);
     521                 :            : 
     522                 :          0 :         device_initialize(&spi->dev);
     523                 :          0 :         return spi;
     524                 :            : }
     525                 :            : EXPORT_SYMBOL_GPL(spi_alloc_device);
     526                 :            : 
     527                 :          0 : static void spi_dev_set_name(struct spi_device *spi)
     528                 :            : {
     529                 :            :         struct acpi_device *adev = ACPI_COMPANION(&spi->dev);
     530                 :            : 
     531                 :            :         if (adev) {
     532                 :            :                 dev_set_name(&spi->dev, "spi-%s", acpi_dev_name(adev));
     533                 :          0 :                 return;
     534                 :            :         }
     535                 :            : 
     536                 :          0 :         dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->controller->dev),
     537                 :          0 :                      spi->chip_select);
     538                 :            : }
     539                 :            : 
     540                 :          0 : static int spi_dev_check(struct device *dev, void *data)
     541                 :            : {
     542                 :            :         struct spi_device *spi = to_spi_device(dev);
     543                 :            :         struct spi_device *new_spi = data;
     544                 :            : 
     545                 :          0 :         if (spi->controller == new_spi->controller &&
     546                 :          0 :             spi->chip_select == new_spi->chip_select)
     547                 :            :                 return -EBUSY;
     548                 :          0 :         return 0;
     549                 :            : }
     550                 :            : 
     551                 :            : /**
     552                 :            :  * spi_add_device - Add spi_device allocated with spi_alloc_device
     553                 :            :  * @spi: spi_device to register
     554                 :            :  *
     555                 :            :  * Companion function to spi_alloc_device.  Devices allocated with
     556                 :            :  * spi_alloc_device can be added onto the spi bus with this function.
     557                 :            :  *
     558                 :            :  * Return: 0 on success; negative errno on failure
     559                 :            :  */
     560                 :          0 : int spi_add_device(struct spi_device *spi)
     561                 :            : {
     562                 :          0 :         struct spi_controller *ctlr = spi->controller;
     563                 :          0 :         struct device *dev = ctlr->dev.parent;
     564                 :            :         int status;
     565                 :            : 
     566                 :            :         /* Chipselects are numbered 0..max; validate. */
     567                 :          0 :         if (spi->chip_select >= ctlr->num_chipselect) {
     568                 :          0 :                 dev_err(dev, "cs%d >= max %d\n", spi->chip_select,
     569                 :            :                         ctlr->num_chipselect);
     570                 :          0 :                 return -EINVAL;
     571                 :            :         }
     572                 :            : 
     573                 :            :         /* Set the bus ID string */
     574                 :          0 :         spi_dev_set_name(spi);
     575                 :            : 
     576                 :            :         /* We need to make sure there's no other device with this
     577                 :            :          * chipselect **BEFORE** we call setup(), else we'll trash
     578                 :            :          * its configuration.  Lock against concurrent add() calls.
     579                 :            :          */
     580                 :          0 :         mutex_lock(&spi_add_lock);
     581                 :            : 
     582                 :          0 :         status = bus_for_each_dev(&spi_bus_type, NULL, spi, spi_dev_check);
     583                 :          0 :         if (status) {
     584                 :          0 :                 dev_err(dev, "chipselect %d already in use\n",
     585                 :            :                                 spi->chip_select);
     586                 :          0 :                 goto done;
     587                 :            :         }
     588                 :            : 
     589                 :            :         /* Controller may unregister concurrently */
     590                 :          0 :         if (IS_ENABLED(CONFIG_SPI_DYNAMIC) &&
     591                 :            :             !device_is_registered(&ctlr->dev)) {
     592                 :            :                 status = -ENODEV;
     593                 :            :                 goto done;
     594                 :            :         }
     595                 :            : 
     596                 :            :         /* Descriptors take precedence */
     597                 :          0 :         if (ctlr->cs_gpiods)
     598                 :          0 :                 spi->cs_gpiod = ctlr->cs_gpiods[spi->chip_select];
     599                 :          0 :         else if (ctlr->cs_gpios)
     600                 :          0 :                 spi->cs_gpio = ctlr->cs_gpios[spi->chip_select];
     601                 :            : 
     602                 :            :         /* Drivers may modify this initial i/o setup, but will
     603                 :            :          * normally rely on the device being setup.  Devices
     604                 :            :          * using SPI_CS_HIGH can't coexist well otherwise...
     605                 :            :          */
     606                 :          0 :         status = spi_setup(spi);
     607                 :          0 :         if (status < 0) {
     608                 :          0 :                 dev_err(dev, "can't setup %s, status %d\n",
     609                 :            :                                 dev_name(&spi->dev), status);
     610                 :          0 :                 goto done;
     611                 :            :         }
     612                 :            : 
     613                 :            :         /* Device may be bound to an active driver when this returns */
     614                 :          0 :         status = device_add(&spi->dev);
     615                 :          0 :         if (status < 0)
     616                 :          0 :                 dev_err(dev, "can't add %s, status %d\n",
     617                 :            :                                 dev_name(&spi->dev), status);
     618                 :            :         else
     619                 :            :                 dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
     620                 :            : 
     621                 :            : done:
     622                 :          0 :         mutex_unlock(&spi_add_lock);
     623                 :          0 :         return status;
     624                 :            : }
     625                 :            : EXPORT_SYMBOL_GPL(spi_add_device);
     626                 :            : 
     627                 :            : /**
     628                 :            :  * spi_new_device - instantiate one new SPI device
     629                 :            :  * @ctlr: Controller to which device is connected
     630                 :            :  * @chip: Describes the SPI device
     631                 :            :  * Context: can sleep
     632                 :            :  *
     633                 :            :  * On typical mainboards, this is purely internal; and it's not needed
     634                 :            :  * after board init creates the hard-wired devices.  Some development
     635                 :            :  * platforms may not be able to use spi_register_board_info though, and
     636                 :            :  * this is exported so that for example a USB or parport based adapter
     637                 :            :  * driver could add devices (which it would learn about out-of-band).
     638                 :            :  *
     639                 :            :  * Return: the new device, or NULL.
     640                 :            :  */
     641                 :          0 : struct spi_device *spi_new_device(struct spi_controller *ctlr,
     642                 :            :                                   struct spi_board_info *chip)
     643                 :            : {
     644                 :            :         struct spi_device       *proxy;
     645                 :            :         int                     status;
     646                 :            : 
     647                 :            :         /* NOTE:  caller did any chip->bus_num checks necessary.
     648                 :            :          *
     649                 :            :          * Also, unless we change the return value convention to use
     650                 :            :          * error-or-pointer (not NULL-or-pointer), troubleshootability
     651                 :            :          * suggests syslogged diagnostics are best here (ugh).
     652                 :            :          */
     653                 :            : 
     654                 :          0 :         proxy = spi_alloc_device(ctlr);
     655                 :          0 :         if (!proxy)
     656                 :            :                 return NULL;
     657                 :            : 
     658                 :          0 :         WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
     659                 :            : 
     660                 :          0 :         proxy->chip_select = chip->chip_select;
     661                 :          0 :         proxy->max_speed_hz = chip->max_speed_hz;
     662                 :          0 :         proxy->mode = chip->mode;
     663                 :          0 :         proxy->irq = chip->irq;
     664                 :          0 :         strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
     665                 :          0 :         proxy->dev.platform_data = (void *) chip->platform_data;
     666                 :          0 :         proxy->controller_data = chip->controller_data;
     667                 :          0 :         proxy->controller_state = NULL;
     668                 :            : 
     669                 :          0 :         if (chip->properties) {
     670                 :          0 :                 status = device_add_properties(&proxy->dev, chip->properties);
     671                 :          0 :                 if (status) {
     672                 :          0 :                         dev_err(&ctlr->dev,
     673                 :            :                                 "failed to add properties to '%s': %d\n",
     674                 :            :                                 chip->modalias, status);
     675                 :          0 :                         goto err_dev_put;
     676                 :            :                 }
     677                 :            :         }
     678                 :            : 
     679                 :          0 :         status = spi_add_device(proxy);
     680                 :          0 :         if (status < 0)
     681                 :            :                 goto err_remove_props;
     682                 :            : 
     683                 :            :         return proxy;
     684                 :            : 
     685                 :            : err_remove_props:
     686                 :          0 :         if (chip->properties)
     687                 :          0 :                 device_remove_properties(&proxy->dev);
     688                 :            : err_dev_put:
     689                 :            :         spi_dev_put(proxy);
     690                 :            :         return NULL;
     691                 :            : }
     692                 :            : EXPORT_SYMBOL_GPL(spi_new_device);
     693                 :            : 
     694                 :            : /**
     695                 :            :  * spi_unregister_device - unregister a single SPI device
     696                 :            :  * @spi: spi_device to unregister
     697                 :            :  *
     698                 :            :  * Start making the passed SPI device vanish. Normally this would be handled
     699                 :            :  * by spi_unregister_controller().
     700                 :            :  */
     701                 :          0 : void spi_unregister_device(struct spi_device *spi)
     702                 :            : {
     703                 :          0 :         if (!spi)
     704                 :          0 :                 return;
     705                 :            : 
     706                 :          0 :         if (spi->dev.of_node) {
     707                 :            :                 of_node_clear_flag(spi->dev.of_node, OF_POPULATED);
     708                 :          0 :                 of_node_put(spi->dev.of_node);
     709                 :            :         }
     710                 :            :         if (ACPI_COMPANION(&spi->dev))
     711                 :            :                 acpi_device_clear_enumerated(ACPI_COMPANION(&spi->dev));
     712                 :          0 :         device_unregister(&spi->dev);
     713                 :            : }
     714                 :            : EXPORT_SYMBOL_GPL(spi_unregister_device);
     715                 :            : 
     716                 :          0 : static void spi_match_controller_to_boardinfo(struct spi_controller *ctlr,
     717                 :            :                                               struct spi_board_info *bi)
     718                 :            : {
     719                 :            :         struct spi_device *dev;
     720                 :            : 
     721                 :          0 :         if (ctlr->bus_num != bi->bus_num)
     722                 :          0 :                 return;
     723                 :            : 
     724                 :          0 :         dev = spi_new_device(ctlr, bi);
     725                 :          0 :         if (!dev)
     726                 :          0 :                 dev_err(ctlr->dev.parent, "can't create new device for %s\n",
     727                 :            :                         bi->modalias);
     728                 :            : }
     729                 :            : 
     730                 :            : /**
     731                 :            :  * spi_register_board_info - register SPI devices for a given board
     732                 :            :  * @info: array of chip descriptors
     733                 :            :  * @n: how many descriptors are provided
     734                 :            :  * Context: can sleep
     735                 :            :  *
     736                 :            :  * Board-specific early init code calls this (probably during arch_initcall)
     737                 :            :  * with segments of the SPI device table.  Any device nodes are created later,
     738                 :            :  * after the relevant parent SPI controller (bus_num) is defined.  We keep
     739                 :            :  * this table of devices forever, so that reloading a controller driver will
     740                 :            :  * not make Linux forget about these hard-wired devices.
     741                 :            :  *
     742                 :            :  * Other code can also call this, e.g. a particular add-on board might provide
     743                 :            :  * SPI devices through its expansion connector, so code initializing that board
     744                 :            :  * would naturally declare its SPI devices.
     745                 :            :  *
     746                 :            :  * The board info passed can safely be __initdata ... but be careful of
     747                 :            :  * any embedded pointers (platform_data, etc), they're copied as-is.
     748                 :            :  * Device properties are deep-copied though.
     749                 :            :  *
     750                 :            :  * Return: zero on success, else a negative error code.
     751                 :            :  */
     752                 :          0 : int spi_register_board_info(struct spi_board_info const *info, unsigned n)
     753                 :            : {
     754                 :            :         struct boardinfo *bi;
     755                 :            :         int i;
     756                 :            : 
     757                 :          0 :         if (!n)
     758                 :            :                 return 0;
     759                 :            : 
     760                 :            :         bi = kcalloc(n, sizeof(*bi), GFP_KERNEL);
     761                 :          0 :         if (!bi)
     762                 :            :                 return -ENOMEM;
     763                 :            : 
     764                 :          0 :         for (i = 0; i < n; i++, bi++, info++) {
     765                 :            :                 struct spi_controller *ctlr;
     766                 :            : 
     767                 :          0 :                 memcpy(&bi->board_info, info, sizeof(*info));
     768                 :          0 :                 if (info->properties) {
     769                 :          0 :                         bi->board_info.properties =
     770                 :          0 :                                         property_entries_dup(info->properties);
     771                 :          0 :                         if (IS_ERR(bi->board_info.properties))
     772                 :          0 :                                 return PTR_ERR(bi->board_info.properties);
     773                 :            :                 }
     774                 :            : 
     775                 :          0 :                 mutex_lock(&board_lock);
     776                 :          0 :                 list_add_tail(&bi->list, &board_list);
     777                 :          0 :                 list_for_each_entry(ctlr, &spi_controller_list, list)
     778                 :          0 :                         spi_match_controller_to_boardinfo(ctlr,
     779                 :            :                                                           &bi->board_info);
     780                 :          0 :                 mutex_unlock(&board_lock);
     781                 :            :         }
     782                 :            : 
     783                 :            :         return 0;
     784                 :            : }
     785                 :            : 
     786                 :            : /*-------------------------------------------------------------------------*/
     787                 :            : 
     788                 :          0 : static void spi_set_cs(struct spi_device *spi, bool enable)
     789                 :            : {
     790                 :          0 :         if (spi->mode & SPI_CS_HIGH)
     791                 :          0 :                 enable = !enable;
     792                 :            : 
     793                 :          0 :         if (spi->cs_gpiod || gpio_is_valid(spi->cs_gpio)) {
     794                 :            :                 /*
     795                 :            :                  * Honour the SPI_NO_CS flag and invert the enable line, as
     796                 :            :                  * active low is default for SPI. Execution paths that handle
     797                 :            :                  * polarity inversion in gpiolib (such as device tree) will
     798                 :            :                  * enforce active high using the SPI_CS_HIGH resulting in a
     799                 :            :                  * double inversion through the code above.
     800                 :            :                  */
     801                 :          0 :                 if (!(spi->mode & SPI_NO_CS)) {
     802                 :          0 :                         if (spi->cs_gpiod)
     803                 :          0 :                                 gpiod_set_value_cansleep(spi->cs_gpiod,
     804                 :          0 :                                                          !enable);
     805                 :            :                         else
     806                 :          0 :                                 gpio_set_value_cansleep(spi->cs_gpio, !enable);
     807                 :            :                 }
     808                 :            :                 /* Some SPI masters need both GPIO CS & slave_select */
     809                 :          0 :                 if ((spi->controller->flags & SPI_MASTER_GPIO_SS) &&
     810                 :          0 :                     spi->controller->set_cs)
     811                 :          0 :                         spi->controller->set_cs(spi, !enable);
     812                 :          0 :         } else if (spi->controller->set_cs) {
     813                 :          0 :                 spi->controller->set_cs(spi, !enable);
     814                 :            :         }
     815                 :          0 : }
     816                 :            : 
     817                 :            : #ifdef CONFIG_HAS_DMA
     818                 :          0 : int spi_map_buf(struct spi_controller *ctlr, struct device *dev,
     819                 :            :                 struct sg_table *sgt, void *buf, size_t len,
     820                 :            :                 enum dma_data_direction dir)
     821                 :            : {
     822                 :            :         const bool vmalloced_buf = is_vmalloc_addr(buf);
     823                 :            :         unsigned int max_seg_size = dma_get_max_seg_size(dev);
     824                 :            : #ifdef CONFIG_HIGHMEM
     825                 :            :         const bool kmap_buf = ((unsigned long)buf >= PKMAP_BASE &&
     826                 :            :                                 (unsigned long)buf < (PKMAP_BASE +
     827                 :            :                                         (LAST_PKMAP * PAGE_SIZE)));
     828                 :            : #else
     829                 :            :         const bool kmap_buf = false;
     830                 :            : #endif
     831                 :            :         int desc_len;
     832                 :            :         int sgs;
     833                 :            :         struct page *vm_page;
     834                 :            :         struct scatterlist *sg;
     835                 :            :         void *sg_buf;
     836                 :            :         size_t min;
     837                 :            :         int i, ret;
     838                 :            : 
     839                 :          0 :         if (vmalloced_buf || kmap_buf) {
     840                 :          0 :                 desc_len = min_t(int, max_seg_size, PAGE_SIZE);
     841                 :          0 :                 sgs = DIV_ROUND_UP(len + offset_in_page(buf), desc_len);
     842                 :          0 :         } else if (virt_addr_valid(buf)) {
     843                 :          0 :                 desc_len = min_t(int, max_seg_size, ctlr->max_dma_len);
     844                 :          0 :                 sgs = DIV_ROUND_UP(len, desc_len);
     845                 :            :         } else {
     846                 :            :                 return -EINVAL;
     847                 :            :         }
     848                 :            : 
     849                 :          0 :         ret = sg_alloc_table(sgt, sgs, GFP_KERNEL);
     850                 :          0 :         if (ret != 0)
     851                 :            :                 return ret;
     852                 :            : 
     853                 :          0 :         sg = &sgt->sgl[0];
     854                 :          0 :         for (i = 0; i < sgs; i++) {
     855                 :            : 
     856                 :          0 :                 if (vmalloced_buf || kmap_buf) {
     857                 :            :                         /*
     858                 :            :                          * Next scatterlist entry size is the minimum between
     859                 :            :                          * the desc_len and the remaining buffer length that
     860                 :            :                          * fits in a page.
     861                 :            :                          */
     862                 :          0 :                         min = min_t(size_t, desc_len,
     863                 :            :                                     min_t(size_t, len,
     864                 :            :                                           PAGE_SIZE - offset_in_page(buf)));
     865                 :          0 :                         if (vmalloced_buf)
     866                 :          0 :                                 vm_page = vmalloc_to_page(buf);
     867                 :            :                         else
     868                 :            :                                 vm_page = kmap_to_page(buf);
     869                 :          0 :                         if (!vm_page) {
     870                 :          0 :                                 sg_free_table(sgt);
     871                 :          0 :                                 return -ENOMEM;
     872                 :            :                         }
     873                 :            :                         sg_set_page(sg, vm_page,
     874                 :            :                                     min, offset_in_page(buf));
     875                 :            :                 } else {
     876                 :          0 :                         min = min_t(size_t, len, desc_len);
     877                 :            :                         sg_buf = buf;
     878                 :          0 :                         sg_set_buf(sg, sg_buf, min);
     879                 :            :                 }
     880                 :            : 
     881                 :          0 :                 buf += min;
     882                 :          0 :                 len -= min;
     883                 :          0 :                 sg = sg_next(sg);
     884                 :            :         }
     885                 :            : 
     886                 :          0 :         ret = dma_map_sg(dev, sgt->sgl, sgt->nents, dir);
     887                 :          0 :         if (!ret)
     888                 :            :                 ret = -ENOMEM;
     889                 :          0 :         if (ret < 0) {
     890                 :          0 :                 sg_free_table(sgt);
     891                 :          0 :                 return ret;
     892                 :            :         }
     893                 :            : 
     894                 :          0 :         sgt->nents = ret;
     895                 :            : 
     896                 :          0 :         return 0;
     897                 :            : }
     898                 :            : 
     899                 :          0 : void spi_unmap_buf(struct spi_controller *ctlr, struct device *dev,
     900                 :            :                    struct sg_table *sgt, enum dma_data_direction dir)
     901                 :            : {
     902                 :          0 :         if (sgt->orig_nents) {
     903                 :          0 :                 dma_unmap_sg(dev, sgt->sgl, sgt->orig_nents, dir);
     904                 :          0 :                 sg_free_table(sgt);
     905                 :            :         }
     906                 :          0 : }
     907                 :            : 
     908                 :          0 : static int __spi_map_msg(struct spi_controller *ctlr, struct spi_message *msg)
     909                 :            : {
     910                 :            :         struct device *tx_dev, *rx_dev;
     911                 :            :         struct spi_transfer *xfer;
     912                 :            :         int ret;
     913                 :            : 
     914                 :          0 :         if (!ctlr->can_dma)
     915                 :            :                 return 0;
     916                 :            : 
     917                 :          0 :         if (ctlr->dma_tx)
     918                 :          0 :                 tx_dev = ctlr->dma_tx->device->dev;
     919                 :            :         else
     920                 :          0 :                 tx_dev = ctlr->dev.parent;
     921                 :            : 
     922                 :          0 :         if (ctlr->dma_rx)
     923                 :          0 :                 rx_dev = ctlr->dma_rx->device->dev;
     924                 :            :         else
     925                 :          0 :                 rx_dev = ctlr->dev.parent;
     926                 :            : 
     927                 :          0 :         list_for_each_entry(xfer, &msg->transfers, transfer_list) {
     928                 :          0 :                 if (!ctlr->can_dma(ctlr, msg->spi, xfer))
     929                 :          0 :                         continue;
     930                 :            : 
     931                 :          0 :                 if (xfer->tx_buf != NULL) {
     932                 :          0 :                         ret = spi_map_buf(ctlr, tx_dev, &xfer->tx_sg,
     933                 :            :                                           (void *)xfer->tx_buf, xfer->len,
     934                 :            :                                           DMA_TO_DEVICE);
     935                 :          0 :                         if (ret != 0)
     936                 :          0 :                                 return ret;
     937                 :            :                 }
     938                 :            : 
     939                 :          0 :                 if (xfer->rx_buf != NULL) {
     940                 :          0 :                         ret = spi_map_buf(ctlr, rx_dev, &xfer->rx_sg,
     941                 :            :                                           xfer->rx_buf, xfer->len,
     942                 :            :                                           DMA_FROM_DEVICE);
     943                 :          0 :                         if (ret != 0) {
     944                 :          0 :                                 spi_unmap_buf(ctlr, tx_dev, &xfer->tx_sg,
     945                 :            :                                               DMA_TO_DEVICE);
     946                 :          0 :                                 return ret;
     947                 :            :                         }
     948                 :            :                 }
     949                 :            :         }
     950                 :            : 
     951                 :          0 :         ctlr->cur_msg_mapped = true;
     952                 :            : 
     953                 :          0 :         return 0;
     954                 :            : }
     955                 :            : 
     956                 :          0 : static int __spi_unmap_msg(struct spi_controller *ctlr, struct spi_message *msg)
     957                 :            : {
     958                 :            :         struct spi_transfer *xfer;
     959                 :            :         struct device *tx_dev, *rx_dev;
     960                 :            : 
     961                 :          0 :         if (!ctlr->cur_msg_mapped || !ctlr->can_dma)
     962                 :            :                 return 0;
     963                 :            : 
     964                 :          0 :         if (ctlr->dma_tx)
     965                 :          0 :                 tx_dev = ctlr->dma_tx->device->dev;
     966                 :            :         else
     967                 :          0 :                 tx_dev = ctlr->dev.parent;
     968                 :            : 
     969                 :          0 :         if (ctlr->dma_rx)
     970                 :          0 :                 rx_dev = ctlr->dma_rx->device->dev;
     971                 :            :         else
     972                 :          0 :                 rx_dev = ctlr->dev.parent;
     973                 :            : 
     974                 :          0 :         list_for_each_entry(xfer, &msg->transfers, transfer_list) {
     975                 :          0 :                 if (!ctlr->can_dma(ctlr, msg->spi, xfer))
     976                 :          0 :                         continue;
     977                 :            : 
     978                 :          0 :                 spi_unmap_buf(ctlr, rx_dev, &xfer->rx_sg, DMA_FROM_DEVICE);
     979                 :          0 :                 spi_unmap_buf(ctlr, tx_dev, &xfer->tx_sg, DMA_TO_DEVICE);
     980                 :            :         }
     981                 :            : 
     982                 :            :         return 0;
     983                 :            : }
     984                 :            : #else /* !CONFIG_HAS_DMA */
     985                 :            : static inline int __spi_map_msg(struct spi_controller *ctlr,
     986                 :            :                                 struct spi_message *msg)
     987                 :            : {
     988                 :            :         return 0;
     989                 :            : }
     990                 :            : 
     991                 :            : static inline int __spi_unmap_msg(struct spi_controller *ctlr,
     992                 :            :                                   struct spi_message *msg)
     993                 :            : {
     994                 :            :         return 0;
     995                 :            : }
     996                 :            : #endif /* !CONFIG_HAS_DMA */
     997                 :            : 
     998                 :          0 : static inline int spi_unmap_msg(struct spi_controller *ctlr,
     999                 :            :                                 struct spi_message *msg)
    1000                 :            : {
    1001                 :            :         struct spi_transfer *xfer;
    1002                 :            : 
    1003                 :          0 :         list_for_each_entry(xfer, &msg->transfers, transfer_list) {
    1004                 :            :                 /*
    1005                 :            :                  * Restore the original value of tx_buf or rx_buf if they are
    1006                 :            :                  * NULL.
    1007                 :            :                  */
    1008                 :          0 :                 if (xfer->tx_buf == ctlr->dummy_tx)
    1009                 :          0 :                         xfer->tx_buf = NULL;
    1010                 :          0 :                 if (xfer->rx_buf == ctlr->dummy_rx)
    1011                 :          0 :                         xfer->rx_buf = NULL;
    1012                 :            :         }
    1013                 :            : 
    1014                 :          0 :         return __spi_unmap_msg(ctlr, msg);
    1015                 :            : }
    1016                 :            : 
    1017                 :          0 : static int spi_map_msg(struct spi_controller *ctlr, struct spi_message *msg)
    1018                 :            : {
    1019                 :            :         struct spi_transfer *xfer;
    1020                 :            :         void *tmp;
    1021                 :            :         unsigned int max_tx, max_rx;
    1022                 :            : 
    1023                 :          0 :         if (ctlr->flags & (SPI_CONTROLLER_MUST_RX | SPI_CONTROLLER_MUST_TX)) {
    1024                 :            :                 max_tx = 0;
    1025                 :            :                 max_rx = 0;
    1026                 :            : 
    1027                 :          0 :                 list_for_each_entry(xfer, &msg->transfers, transfer_list) {
    1028                 :          0 :                         if ((ctlr->flags & SPI_CONTROLLER_MUST_TX) &&
    1029                 :          0 :                             !xfer->tx_buf)
    1030                 :          0 :                                 max_tx = max(xfer->len, max_tx);
    1031                 :          0 :                         if ((ctlr->flags & SPI_CONTROLLER_MUST_RX) &&
    1032                 :          0 :                             !xfer->rx_buf)
    1033                 :          0 :                                 max_rx = max(xfer->len, max_rx);
    1034                 :            :                 }
    1035                 :            : 
    1036                 :          0 :                 if (max_tx) {
    1037                 :          0 :                         tmp = krealloc(ctlr->dummy_tx, max_tx,
    1038                 :            :                                        GFP_KERNEL | GFP_DMA);
    1039                 :          0 :                         if (!tmp)
    1040                 :            :                                 return -ENOMEM;
    1041                 :          0 :                         ctlr->dummy_tx = tmp;
    1042                 :          0 :                         memset(tmp, 0, max_tx);
    1043                 :            :                 }
    1044                 :            : 
    1045                 :          0 :                 if (max_rx) {
    1046                 :          0 :                         tmp = krealloc(ctlr->dummy_rx, max_rx,
    1047                 :            :                                        GFP_KERNEL | GFP_DMA);
    1048                 :          0 :                         if (!tmp)
    1049                 :            :                                 return -ENOMEM;
    1050                 :          0 :                         ctlr->dummy_rx = tmp;
    1051                 :            :                 }
    1052                 :            : 
    1053                 :          0 :                 if (max_tx || max_rx) {
    1054                 :          0 :                         list_for_each_entry(xfer, &msg->transfers,
    1055                 :            :                                             transfer_list) {
    1056                 :          0 :                                 if (!xfer->len)
    1057                 :          0 :                                         continue;
    1058                 :          0 :                                 if (!xfer->tx_buf)
    1059                 :          0 :                                         xfer->tx_buf = ctlr->dummy_tx;
    1060                 :          0 :                                 if (!xfer->rx_buf)
    1061                 :          0 :                                         xfer->rx_buf = ctlr->dummy_rx;
    1062                 :            :                         }
    1063                 :            :                 }
    1064                 :            :         }
    1065                 :            : 
    1066                 :          0 :         return __spi_map_msg(ctlr, msg);
    1067                 :            : }
    1068                 :            : 
    1069                 :          0 : static int spi_transfer_wait(struct spi_controller *ctlr,
    1070                 :            :                              struct spi_message *msg,
    1071                 :            :                              struct spi_transfer *xfer)
    1072                 :            : {
    1073                 :            :         struct spi_statistics *statm = &ctlr->statistics;
    1074                 :          0 :         struct spi_statistics *stats = &msg->spi->statistics;
    1075                 :          0 :         unsigned long long ms = 1;
    1076                 :            : 
    1077                 :          0 :         if (spi_controller_is_slave(ctlr)) {
    1078                 :          0 :                 if (wait_for_completion_interruptible(&ctlr->xfer_completion)) {
    1079                 :            :                         dev_dbg(&msg->spi->dev, "SPI transfer interrupted\n");
    1080                 :            :                         return -EINTR;
    1081                 :            :                 }
    1082                 :            :         } else {
    1083                 :          0 :                 ms = 8LL * 1000LL * xfer->len;
    1084                 :          0 :                 do_div(ms, xfer->speed_hz);
    1085                 :          0 :                 ms += ms + 200; /* some tolerance */
    1086                 :            : 
    1087                 :          0 :                 if (ms > UINT_MAX)
    1088                 :          0 :                         ms = UINT_MAX;
    1089                 :            : 
    1090                 :          0 :                 ms = wait_for_completion_timeout(&ctlr->xfer_completion,
    1091                 :            :                                                  msecs_to_jiffies(ms));
    1092                 :            : 
    1093                 :          0 :                 if (ms == 0) {
    1094                 :          0 :                         SPI_STATISTICS_INCREMENT_FIELD(statm, timedout);
    1095                 :          0 :                         SPI_STATISTICS_INCREMENT_FIELD(stats, timedout);
    1096                 :          0 :                         dev_err(&msg->spi->dev,
    1097                 :            :                                 "SPI transfer timed out\n");
    1098                 :          0 :                         return -ETIMEDOUT;
    1099                 :            :                 }
    1100                 :            :         }
    1101                 :            : 
    1102                 :            :         return 0;
    1103                 :            : }
    1104                 :            : 
    1105                 :          0 : static void _spi_transfer_delay_ns(u32 ns)
    1106                 :            : {
    1107                 :          0 :         if (!ns)
    1108                 :          0 :                 return;
    1109                 :          0 :         if (ns <= 1000) {
    1110                 :          0 :                 ndelay(ns);
    1111                 :            :         } else {
    1112                 :          0 :                 u32 us = DIV_ROUND_UP(ns, 1000);
    1113                 :            : 
    1114                 :          0 :                 if (us <= 10)
    1115                 :          0 :                         udelay(us);
    1116                 :            :                 else
    1117                 :          0 :                         usleep_range(us, us + DIV_ROUND_UP(us, 10));
    1118                 :            :         }
    1119                 :            : }
    1120                 :            : 
    1121                 :          0 : static void _spi_transfer_cs_change_delay(struct spi_message *msg,
    1122                 :            :                                           struct spi_transfer *xfer)
    1123                 :            : {
    1124                 :          0 :         u32 delay = xfer->cs_change_delay;
    1125                 :          0 :         u32 unit = xfer->cs_change_delay_unit;
    1126                 :            :         u32 hz;
    1127                 :            : 
    1128                 :            :         /* return early on "fast" mode - for everything but USECS */
    1129                 :          0 :         if (!delay && unit != SPI_DELAY_UNIT_USECS)
    1130                 :          0 :                 return;
    1131                 :            : 
    1132                 :          0 :         switch (unit) {
    1133                 :            :         case SPI_DELAY_UNIT_USECS:
    1134                 :            :                 /* for compatibility use default of 10us */
    1135                 :          0 :                 if (!delay)
    1136                 :            :                         delay = 10000;
    1137                 :            :                 else
    1138                 :          0 :                         delay *= 1000;
    1139                 :            :                 break;
    1140                 :            :         case SPI_DELAY_UNIT_NSECS: /* nothing to do here */
    1141                 :            :                 break;
    1142                 :            :         case SPI_DELAY_UNIT_SCK:
    1143                 :            :                 /* if there is no effective speed know, then approximate
    1144                 :            :                  * by underestimating with half the requested hz
    1145                 :            :                  */
    1146                 :          0 :                 hz = xfer->effective_speed_hz ?: xfer->speed_hz / 2;
    1147                 :          0 :                 delay *= DIV_ROUND_UP(1000000000, hz);
    1148                 :          0 :                 break;
    1149                 :            :         default:
    1150                 :          0 :                 dev_err_once(&msg->spi->dev,
    1151                 :            :                              "Use of unsupported delay unit %i, using default of 10us\n",
    1152                 :            :                              xfer->cs_change_delay_unit);
    1153                 :            :                 delay = 10000;
    1154                 :            :         }
    1155                 :            :         /* now sleep for the requested amount of time */
    1156                 :          0 :         _spi_transfer_delay_ns(delay);
    1157                 :            : }
    1158                 :            : 
    1159                 :            : /*
    1160                 :            :  * spi_transfer_one_message - Default implementation of transfer_one_message()
    1161                 :            :  *
    1162                 :            :  * This is a standard implementation of transfer_one_message() for
    1163                 :            :  * drivers which implement a transfer_one() operation.  It provides
    1164                 :            :  * standard handling of delays and chip select management.
    1165                 :            :  */
    1166                 :          0 : static int spi_transfer_one_message(struct spi_controller *ctlr,
    1167                 :            :                                     struct spi_message *msg)
    1168                 :            : {
    1169                 :            :         struct spi_transfer *xfer;
    1170                 :            :         bool keep_cs = false;
    1171                 :            :         int ret = 0;
    1172                 :          0 :         struct spi_statistics *statm = &ctlr->statistics;
    1173                 :          0 :         struct spi_statistics *stats = &msg->spi->statistics;
    1174                 :            : 
    1175                 :          0 :         spi_set_cs(msg->spi, true);
    1176                 :            : 
    1177                 :          0 :         SPI_STATISTICS_INCREMENT_FIELD(statm, messages);
    1178                 :          0 :         SPI_STATISTICS_INCREMENT_FIELD(stats, messages);
    1179                 :            : 
    1180                 :          0 :         list_for_each_entry(xfer, &msg->transfers, transfer_list) {
    1181                 :          0 :                 trace_spi_transfer_start(msg, xfer);
    1182                 :            : 
    1183                 :          0 :                 spi_statistics_add_transfer_stats(statm, xfer, ctlr);
    1184                 :          0 :                 spi_statistics_add_transfer_stats(stats, xfer, ctlr);
    1185                 :            : 
    1186                 :          0 :                 if (xfer->tx_buf || xfer->rx_buf) {
    1187                 :            :                         reinit_completion(&ctlr->xfer_completion);
    1188                 :            : 
    1189                 :          0 :                         ret = ctlr->transfer_one(ctlr, msg->spi, xfer);
    1190                 :          0 :                         if (ret < 0) {
    1191                 :          0 :                                 SPI_STATISTICS_INCREMENT_FIELD(statm,
    1192                 :            :                                                                errors);
    1193                 :          0 :                                 SPI_STATISTICS_INCREMENT_FIELD(stats,
    1194                 :            :                                                                errors);
    1195                 :          0 :                                 dev_err(&msg->spi->dev,
    1196                 :            :                                         "SPI transfer failed: %d\n", ret);
    1197                 :          0 :                                 goto out;
    1198                 :            :                         }
    1199                 :            : 
    1200                 :          0 :                         if (ret > 0) {
    1201                 :          0 :                                 ret = spi_transfer_wait(ctlr, msg, xfer);
    1202                 :          0 :                                 if (ret < 0)
    1203                 :          0 :                                         msg->status = ret;
    1204                 :            :                         }
    1205                 :            :                 } else {
    1206                 :          0 :                         if (xfer->len)
    1207                 :          0 :                                 dev_err(&msg->spi->dev,
    1208                 :            :                                         "Bufferless transfer has length %u\n",
    1209                 :            :                                         xfer->len);
    1210                 :            :                 }
    1211                 :            : 
    1212                 :          0 :                 trace_spi_transfer_stop(msg, xfer);
    1213                 :            : 
    1214                 :          0 :                 if (msg->status != -EINPROGRESS)
    1215                 :            :                         goto out;
    1216                 :            : 
    1217                 :          0 :                 if (xfer->delay_usecs)
    1218                 :          0 :                         _spi_transfer_delay_ns(xfer->delay_usecs * 1000);
    1219                 :            : 
    1220                 :          0 :                 if (xfer->cs_change) {
    1221                 :          0 :                         if (list_is_last(&xfer->transfer_list,
    1222                 :            :                                          &msg->transfers)) {
    1223                 :            :                                 keep_cs = true;
    1224                 :            :                         } else {
    1225                 :          0 :                                 spi_set_cs(msg->spi, false);
    1226                 :          0 :                                 _spi_transfer_cs_change_delay(msg, xfer);
    1227                 :          0 :                                 spi_set_cs(msg->spi, true);
    1228                 :            :                         }
    1229                 :            :                 }
    1230                 :            : 
    1231                 :          0 :                 msg->actual_length += xfer->len;
    1232                 :            :         }
    1233                 :            : 
    1234                 :            : out:
    1235                 :          0 :         if (ret != 0 || !keep_cs)
    1236                 :          0 :                 spi_set_cs(msg->spi, false);
    1237                 :            : 
    1238                 :          0 :         if (msg->status == -EINPROGRESS)
    1239                 :          0 :                 msg->status = ret;
    1240                 :            : 
    1241                 :          0 :         if (msg->status && ctlr->handle_err)
    1242                 :          0 :                 ctlr->handle_err(ctlr, msg);
    1243                 :            : 
    1244                 :          0 :         spi_res_release(ctlr, msg);
    1245                 :            : 
    1246                 :          0 :         spi_finalize_current_message(ctlr);
    1247                 :            : 
    1248                 :          0 :         return ret;
    1249                 :            : }
    1250                 :            : 
    1251                 :            : /**
    1252                 :            :  * spi_finalize_current_transfer - report completion of a transfer
    1253                 :            :  * @ctlr: the controller reporting completion
    1254                 :            :  *
    1255                 :            :  * Called by SPI drivers using the core transfer_one_message()
    1256                 :            :  * implementation to notify it that the current interrupt driven
    1257                 :            :  * transfer has finished and the next one may be scheduled.
    1258                 :            :  */
    1259                 :          0 : void spi_finalize_current_transfer(struct spi_controller *ctlr)
    1260                 :            : {
    1261                 :          0 :         complete(&ctlr->xfer_completion);
    1262                 :          0 : }
    1263                 :            : EXPORT_SYMBOL_GPL(spi_finalize_current_transfer);
    1264                 :            : 
    1265                 :            : /**
    1266                 :            :  * __spi_pump_messages - function which processes spi message queue
    1267                 :            :  * @ctlr: controller to process queue for
    1268                 :            :  * @in_kthread: true if we are in the context of the message pump thread
    1269                 :            :  *
    1270                 :            :  * This function checks if there is any spi message in the queue that
    1271                 :            :  * needs processing and if so call out to the driver to initialize hardware
    1272                 :            :  * and transfer each message.
    1273                 :            :  *
    1274                 :            :  * Note that it is called both from the kthread itself and also from
    1275                 :            :  * inside spi_sync(); the queue extraction handling at the top of the
    1276                 :            :  * function should deal with this safely.
    1277                 :            :  */
    1278                 :          0 : static void __spi_pump_messages(struct spi_controller *ctlr, bool in_kthread)
    1279                 :            : {
    1280                 :            :         struct spi_message *msg;
    1281                 :            :         bool was_busy = false;
    1282                 :            :         unsigned long flags;
    1283                 :            :         int ret;
    1284                 :            : 
    1285                 :            :         /* Lock queue */
    1286                 :          0 :         spin_lock_irqsave(&ctlr->queue_lock, flags);
    1287                 :            : 
    1288                 :            :         /* Make sure we are not already running a message */
    1289                 :          0 :         if (ctlr->cur_msg) {
    1290                 :            :                 spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1291                 :            :                 return;
    1292                 :            :         }
    1293                 :            : 
    1294                 :            :         /* If another context is idling the device then defer */
    1295                 :          0 :         if (ctlr->idling) {
    1296                 :          0 :                 kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
    1297                 :            :                 spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1298                 :            :                 return;
    1299                 :            :         }
    1300                 :            : 
    1301                 :            :         /* Check if the queue is idle */
    1302                 :          0 :         if (list_empty(&ctlr->queue) || !ctlr->running) {
    1303                 :          0 :                 if (!ctlr->busy) {
    1304                 :            :                         spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1305                 :            :                         return;
    1306                 :            :                 }
    1307                 :            : 
    1308                 :            :                 /* Only do teardown in the thread */
    1309                 :          0 :                 if (!in_kthread) {
    1310                 :          0 :                         kthread_queue_work(&ctlr->kworker,
    1311                 :            :                                            &ctlr->pump_messages);
    1312                 :            :                         spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1313                 :            :                         return;
    1314                 :            :                 }
    1315                 :            : 
    1316                 :          0 :                 ctlr->busy = false;
    1317                 :          0 :                 ctlr->idling = true;
    1318                 :            :                 spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1319                 :            : 
    1320                 :          0 :                 kfree(ctlr->dummy_rx);
    1321                 :          0 :                 ctlr->dummy_rx = NULL;
    1322                 :          0 :                 kfree(ctlr->dummy_tx);
    1323                 :          0 :                 ctlr->dummy_tx = NULL;
    1324                 :          0 :                 if (ctlr->unprepare_transfer_hardware &&
    1325                 :          0 :                     ctlr->unprepare_transfer_hardware(ctlr))
    1326                 :          0 :                         dev_err(&ctlr->dev,
    1327                 :            :                                 "failed to unprepare transfer hardware\n");
    1328                 :          0 :                 if (ctlr->auto_runtime_pm) {
    1329                 :          0 :                         pm_runtime_mark_last_busy(ctlr->dev.parent);
    1330                 :          0 :                         pm_runtime_put_autosuspend(ctlr->dev.parent);
    1331                 :            :                 }
    1332                 :          0 :                 trace_spi_controller_idle(ctlr);
    1333                 :            : 
    1334                 :          0 :                 spin_lock_irqsave(&ctlr->queue_lock, flags);
    1335                 :          0 :                 ctlr->idling = false;
    1336                 :            :                 spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1337                 :            :                 return;
    1338                 :            :         }
    1339                 :            : 
    1340                 :            :         /* Extract head of queue */
    1341                 :          0 :         msg = list_first_entry(&ctlr->queue, struct spi_message, queue);
    1342                 :          0 :         ctlr->cur_msg = msg;
    1343                 :            : 
    1344                 :          0 :         list_del_init(&msg->queue);
    1345                 :          0 :         if (ctlr->busy)
    1346                 :            :                 was_busy = true;
    1347                 :            :         else
    1348                 :          0 :                 ctlr->busy = true;
    1349                 :            :         spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1350                 :            : 
    1351                 :          0 :         mutex_lock(&ctlr->io_mutex);
    1352                 :            : 
    1353                 :          0 :         if (!was_busy && ctlr->auto_runtime_pm) {
    1354                 :          0 :                 ret = pm_runtime_get_sync(ctlr->dev.parent);
    1355                 :          0 :                 if (ret < 0) {
    1356                 :          0 :                         pm_runtime_put_noidle(ctlr->dev.parent);
    1357                 :          0 :                         dev_err(&ctlr->dev, "Failed to power device: %d\n",
    1358                 :            :                                 ret);
    1359                 :          0 :                         mutex_unlock(&ctlr->io_mutex);
    1360                 :          0 :                         return;
    1361                 :            :                 }
    1362                 :            :         }
    1363                 :            : 
    1364                 :          0 :         if (!was_busy)
    1365                 :          0 :                 trace_spi_controller_busy(ctlr);
    1366                 :            : 
    1367                 :          0 :         if (!was_busy && ctlr->prepare_transfer_hardware) {
    1368                 :          0 :                 ret = ctlr->prepare_transfer_hardware(ctlr);
    1369                 :          0 :                 if (ret) {
    1370                 :          0 :                         dev_err(&ctlr->dev,
    1371                 :            :                                 "failed to prepare transfer hardware: %d\n",
    1372                 :            :                                 ret);
    1373                 :            : 
    1374                 :          0 :                         if (ctlr->auto_runtime_pm)
    1375                 :          0 :                                 pm_runtime_put(ctlr->dev.parent);
    1376                 :            : 
    1377                 :          0 :                         msg->status = ret;
    1378                 :          0 :                         spi_finalize_current_message(ctlr);
    1379                 :            : 
    1380                 :          0 :                         mutex_unlock(&ctlr->io_mutex);
    1381                 :          0 :                         return;
    1382                 :            :                 }
    1383                 :            :         }
    1384                 :            : 
    1385                 :          0 :         trace_spi_message_start(msg);
    1386                 :            : 
    1387                 :          0 :         if (ctlr->prepare_message) {
    1388                 :          0 :                 ret = ctlr->prepare_message(ctlr, msg);
    1389                 :          0 :                 if (ret) {
    1390                 :          0 :                         dev_err(&ctlr->dev, "failed to prepare message: %d\n",
    1391                 :            :                                 ret);
    1392                 :          0 :                         msg->status = ret;
    1393                 :          0 :                         spi_finalize_current_message(ctlr);
    1394                 :          0 :                         goto out;
    1395                 :            :                 }
    1396                 :          0 :                 ctlr->cur_msg_prepared = true;
    1397                 :            :         }
    1398                 :            : 
    1399                 :          0 :         ret = spi_map_msg(ctlr, msg);
    1400                 :          0 :         if (ret) {
    1401                 :          0 :                 msg->status = ret;
    1402                 :          0 :                 spi_finalize_current_message(ctlr);
    1403                 :          0 :                 goto out;
    1404                 :            :         }
    1405                 :            : 
    1406                 :          0 :         ret = ctlr->transfer_one_message(ctlr, msg);
    1407                 :          0 :         if (ret) {
    1408                 :          0 :                 dev_err(&ctlr->dev,
    1409                 :            :                         "failed to transfer one message from queue\n");
    1410                 :          0 :                 goto out;
    1411                 :            :         }
    1412                 :            : 
    1413                 :            : out:
    1414                 :          0 :         mutex_unlock(&ctlr->io_mutex);
    1415                 :            : 
    1416                 :            :         /* Prod the scheduler in case transfer_one() was busy waiting */
    1417                 :          0 :         if (!ret)
    1418                 :          0 :                 cond_resched();
    1419                 :            : }
    1420                 :            : 
    1421                 :            : /**
    1422                 :            :  * spi_pump_messages - kthread work function which processes spi message queue
    1423                 :            :  * @work: pointer to kthread work struct contained in the controller struct
    1424                 :            :  */
    1425                 :          0 : static void spi_pump_messages(struct kthread_work *work)
    1426                 :            : {
    1427                 :            :         struct spi_controller *ctlr =
    1428                 :          0 :                 container_of(work, struct spi_controller, pump_messages);
    1429                 :            : 
    1430                 :          0 :         __spi_pump_messages(ctlr, true);
    1431                 :          0 : }
    1432                 :            : 
    1433                 :            : /**
    1434                 :            :  * spi_set_thread_rt - set the controller to pump at realtime priority
    1435                 :            :  * @ctlr: controller to boost priority of
    1436                 :            :  *
    1437                 :            :  * This can be called because the controller requested realtime priority
    1438                 :            :  * (by setting the ->rt value before calling spi_register_controller()) or
    1439                 :            :  * because a device on the bus said that its transfers needed realtime
    1440                 :            :  * priority.
    1441                 :            :  *
    1442                 :            :  * NOTE: at the moment if any device on a bus says it needs realtime then
    1443                 :            :  * the thread will be at realtime priority for all transfers on that
    1444                 :            :  * controller.  If this eventually becomes a problem we may see if we can
    1445                 :            :  * find a way to boost the priority only temporarily during relevant
    1446                 :            :  * transfers.
    1447                 :            :  */
    1448                 :          0 : static void spi_set_thread_rt(struct spi_controller *ctlr)
    1449                 :            : {
    1450                 :          0 :         struct sched_param param = { .sched_priority = MAX_RT_PRIO / 2 };
    1451                 :            : 
    1452                 :          0 :         dev_info(&ctlr->dev,
    1453                 :            :                 "will run message pump with realtime priority\n");
    1454                 :          0 :         sched_setscheduler(ctlr->kworker_task, SCHED_FIFO, &param);
    1455                 :          0 : }
    1456                 :            : 
    1457                 :          0 : static int spi_init_queue(struct spi_controller *ctlr)
    1458                 :            : {
    1459                 :          0 :         ctlr->running = false;
    1460                 :          0 :         ctlr->busy = false;
    1461                 :            : 
    1462                 :          0 :         kthread_init_worker(&ctlr->kworker);
    1463                 :          0 :         ctlr->kworker_task = kthread_run(kthread_worker_fn, &ctlr->kworker,
    1464                 :            :                                          "%s", dev_name(&ctlr->dev));
    1465                 :          0 :         if (IS_ERR(ctlr->kworker_task)) {
    1466                 :          0 :                 dev_err(&ctlr->dev, "failed to create message pump task\n");
    1467                 :          0 :                 return PTR_ERR(ctlr->kworker_task);
    1468                 :            :         }
    1469                 :          0 :         kthread_init_work(&ctlr->pump_messages, spi_pump_messages);
    1470                 :            : 
    1471                 :            :         /*
    1472                 :            :          * Controller config will indicate if this controller should run the
    1473                 :            :          * message pump with high (realtime) priority to reduce the transfer
    1474                 :            :          * latency on the bus by minimising the delay between a transfer
    1475                 :            :          * request and the scheduling of the message pump thread. Without this
    1476                 :            :          * setting the message pump thread will remain at default priority.
    1477                 :            :          */
    1478                 :          0 :         if (ctlr->rt)
    1479                 :          0 :                 spi_set_thread_rt(ctlr);
    1480                 :            : 
    1481                 :            :         return 0;
    1482                 :            : }
    1483                 :            : 
    1484                 :            : /**
    1485                 :            :  * spi_get_next_queued_message() - called by driver to check for queued
    1486                 :            :  * messages
    1487                 :            :  * @ctlr: the controller to check for queued messages
    1488                 :            :  *
    1489                 :            :  * If there are more messages in the queue, the next message is returned from
    1490                 :            :  * this call.
    1491                 :            :  *
    1492                 :            :  * Return: the next message in the queue, else NULL if the queue is empty.
    1493                 :            :  */
    1494                 :          0 : struct spi_message *spi_get_next_queued_message(struct spi_controller *ctlr)
    1495                 :            : {
    1496                 :            :         struct spi_message *next;
    1497                 :            :         unsigned long flags;
    1498                 :            : 
    1499                 :            :         /* get a pointer to the next message, if any */
    1500                 :          0 :         spin_lock_irqsave(&ctlr->queue_lock, flags);
    1501                 :          0 :         next = list_first_entry_or_null(&ctlr->queue, struct spi_message,
    1502                 :            :                                         queue);
    1503                 :            :         spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1504                 :            : 
    1505                 :          0 :         return next;
    1506                 :            : }
    1507                 :            : EXPORT_SYMBOL_GPL(spi_get_next_queued_message);
    1508                 :            : 
    1509                 :            : /**
    1510                 :            :  * spi_finalize_current_message() - the current message is complete
    1511                 :            :  * @ctlr: the controller to return the message to
    1512                 :            :  *
    1513                 :            :  * Called by the driver to notify the core that the message in the front of the
    1514                 :            :  * queue is complete and can be removed from the queue.
    1515                 :            :  */
    1516                 :          0 : void spi_finalize_current_message(struct spi_controller *ctlr)
    1517                 :            : {
    1518                 :            :         struct spi_message *mesg;
    1519                 :            :         unsigned long flags;
    1520                 :            :         int ret;
    1521                 :            : 
    1522                 :          0 :         spin_lock_irqsave(&ctlr->queue_lock, flags);
    1523                 :          0 :         mesg = ctlr->cur_msg;
    1524                 :            :         spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1525                 :            : 
    1526                 :          0 :         spi_unmap_msg(ctlr, mesg);
    1527                 :            : 
    1528                 :          0 :         if (ctlr->cur_msg_prepared && ctlr->unprepare_message) {
    1529                 :          0 :                 ret = ctlr->unprepare_message(ctlr, mesg);
    1530                 :          0 :                 if (ret) {
    1531                 :          0 :                         dev_err(&ctlr->dev, "failed to unprepare message: %d\n",
    1532                 :            :                                 ret);
    1533                 :            :                 }
    1534                 :            :         }
    1535                 :            : 
    1536                 :          0 :         spin_lock_irqsave(&ctlr->queue_lock, flags);
    1537                 :          0 :         ctlr->cur_msg = NULL;
    1538                 :          0 :         ctlr->cur_msg_prepared = false;
    1539                 :          0 :         kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
    1540                 :            :         spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1541                 :            : 
    1542                 :          0 :         trace_spi_message_done(mesg);
    1543                 :            : 
    1544                 :          0 :         mesg->state = NULL;
    1545                 :          0 :         if (mesg->complete)
    1546                 :          0 :                 mesg->complete(mesg->context);
    1547                 :          0 : }
    1548                 :            : EXPORT_SYMBOL_GPL(spi_finalize_current_message);
    1549                 :            : 
    1550                 :          0 : static int spi_start_queue(struct spi_controller *ctlr)
    1551                 :            : {
    1552                 :            :         unsigned long flags;
    1553                 :            : 
    1554                 :          0 :         spin_lock_irqsave(&ctlr->queue_lock, flags);
    1555                 :            : 
    1556                 :          0 :         if (ctlr->running || ctlr->busy) {
    1557                 :            :                 spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1558                 :          0 :                 return -EBUSY;
    1559                 :            :         }
    1560                 :            : 
    1561                 :          0 :         ctlr->running = true;
    1562                 :          0 :         ctlr->cur_msg = NULL;
    1563                 :            :         spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1564                 :            : 
    1565                 :          0 :         kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
    1566                 :            : 
    1567                 :          0 :         return 0;
    1568                 :            : }
    1569                 :            : 
    1570                 :          0 : static int spi_stop_queue(struct spi_controller *ctlr)
    1571                 :            : {
    1572                 :            :         unsigned long flags;
    1573                 :            :         unsigned limit = 500;
    1574                 :            :         int ret = 0;
    1575                 :            : 
    1576                 :          0 :         spin_lock_irqsave(&ctlr->queue_lock, flags);
    1577                 :            : 
    1578                 :            :         /*
    1579                 :            :          * This is a bit lame, but is optimized for the common execution path.
    1580                 :            :          * A wait_queue on the ctlr->busy could be used, but then the common
    1581                 :            :          * execution path (pump_messages) would be required to call wake_up or
    1582                 :            :          * friends on every SPI message. Do this instead.
    1583                 :            :          */
    1584                 :          0 :         while ((!list_empty(&ctlr->queue) || ctlr->busy) && limit--) {
    1585                 :            :                 spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1586                 :          0 :                 usleep_range(10000, 11000);
    1587                 :          0 :                 spin_lock_irqsave(&ctlr->queue_lock, flags);
    1588                 :            :         }
    1589                 :            : 
    1590                 :          0 :         if (!list_empty(&ctlr->queue) || ctlr->busy)
    1591                 :            :                 ret = -EBUSY;
    1592                 :            :         else
    1593                 :          0 :                 ctlr->running = false;
    1594                 :            : 
    1595                 :            :         spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1596                 :            : 
    1597                 :          0 :         if (ret) {
    1598                 :          0 :                 dev_warn(&ctlr->dev, "could not stop message queue\n");
    1599                 :          0 :                 return ret;
    1600                 :            :         }
    1601                 :            :         return ret;
    1602                 :            : }
    1603                 :            : 
    1604                 :          0 : static int spi_destroy_queue(struct spi_controller *ctlr)
    1605                 :            : {
    1606                 :            :         int ret;
    1607                 :            : 
    1608                 :          0 :         ret = spi_stop_queue(ctlr);
    1609                 :            : 
    1610                 :            :         /*
    1611                 :            :          * kthread_flush_worker will block until all work is done.
    1612                 :            :          * If the reason that stop_queue timed out is that the work will never
    1613                 :            :          * finish, then it does no good to call flush/stop thread, so
    1614                 :            :          * return anyway.
    1615                 :            :          */
    1616                 :          0 :         if (ret) {
    1617                 :          0 :                 dev_err(&ctlr->dev, "problem destroying queue\n");
    1618                 :          0 :                 return ret;
    1619                 :            :         }
    1620                 :            : 
    1621                 :          0 :         kthread_flush_worker(&ctlr->kworker);
    1622                 :          0 :         kthread_stop(ctlr->kworker_task);
    1623                 :            : 
    1624                 :          0 :         return 0;
    1625                 :            : }
    1626                 :            : 
    1627                 :          0 : static int __spi_queued_transfer(struct spi_device *spi,
    1628                 :            :                                  struct spi_message *msg,
    1629                 :            :                                  bool need_pump)
    1630                 :            : {
    1631                 :          0 :         struct spi_controller *ctlr = spi->controller;
    1632                 :            :         unsigned long flags;
    1633                 :            : 
    1634                 :          0 :         spin_lock_irqsave(&ctlr->queue_lock, flags);
    1635                 :            : 
    1636                 :          0 :         if (!ctlr->running) {
    1637                 :            :                 spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1638                 :          0 :                 return -ESHUTDOWN;
    1639                 :            :         }
    1640                 :          0 :         msg->actual_length = 0;
    1641                 :          0 :         msg->status = -EINPROGRESS;
    1642                 :            : 
    1643                 :          0 :         list_add_tail(&msg->queue, &ctlr->queue);
    1644                 :          0 :         if (!ctlr->busy && need_pump)
    1645                 :          0 :                 kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
    1646                 :            : 
    1647                 :            :         spin_unlock_irqrestore(&ctlr->queue_lock, flags);
    1648                 :          0 :         return 0;
    1649                 :            : }
    1650                 :            : 
    1651                 :            : /**
    1652                 :            :  * spi_queued_transfer - transfer function for queued transfers
    1653                 :            :  * @spi: spi device which is requesting transfer
    1654                 :            :  * @msg: spi message which is to handled is queued to driver queue
    1655                 :            :  *
    1656                 :            :  * Return: zero on success, else a negative error code.
    1657                 :            :  */
    1658                 :          0 : static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
    1659                 :            : {
    1660                 :          0 :         return __spi_queued_transfer(spi, msg, true);
    1661                 :            : }
    1662                 :            : 
    1663                 :          0 : static int spi_controller_initialize_queue(struct spi_controller *ctlr)
    1664                 :            : {
    1665                 :            :         int ret;
    1666                 :            : 
    1667                 :          0 :         ctlr->transfer = spi_queued_transfer;
    1668                 :          0 :         if (!ctlr->transfer_one_message)
    1669                 :          0 :                 ctlr->transfer_one_message = spi_transfer_one_message;
    1670                 :            : 
    1671                 :            :         /* Initialize and start queue */
    1672                 :          0 :         ret = spi_init_queue(ctlr);
    1673                 :          0 :         if (ret) {
    1674                 :          0 :                 dev_err(&ctlr->dev, "problem initializing queue\n");
    1675                 :          0 :                 goto err_init_queue;
    1676                 :            :         }
    1677                 :          0 :         ctlr->queued = true;
    1678                 :          0 :         ret = spi_start_queue(ctlr);
    1679                 :          0 :         if (ret) {
    1680                 :          0 :                 dev_err(&ctlr->dev, "problem starting queue\n");
    1681                 :            :                 goto err_start_queue;
    1682                 :            :         }
    1683                 :            : 
    1684                 :            :         return 0;
    1685                 :            : 
    1686                 :            : err_start_queue:
    1687                 :          0 :         spi_destroy_queue(ctlr);
    1688                 :            : err_init_queue:
    1689                 :          0 :         return ret;
    1690                 :            : }
    1691                 :            : 
    1692                 :            : /**
    1693                 :            :  * spi_flush_queue - Send all pending messages in the queue from the callers'
    1694                 :            :  *                   context
    1695                 :            :  * @ctlr: controller to process queue for
    1696                 :            :  *
    1697                 :            :  * This should be used when one wants to ensure all pending messages have been
    1698                 :            :  * sent before doing something. Is used by the spi-mem code to make sure SPI
    1699                 :            :  * memory operations do not preempt regular SPI transfers that have been queued
    1700                 :            :  * before the spi-mem operation.
    1701                 :            :  */
    1702                 :          0 : void spi_flush_queue(struct spi_controller *ctlr)
    1703                 :            : {
    1704                 :          0 :         if (ctlr->transfer == spi_queued_transfer)
    1705                 :          0 :                 __spi_pump_messages(ctlr, false);
    1706                 :          0 : }
    1707                 :            : 
    1708                 :            : /*-------------------------------------------------------------------------*/
    1709                 :            : 
    1710                 :            : #if defined(CONFIG_OF)
    1711                 :          0 : static int of_spi_parse_dt(struct spi_controller *ctlr, struct spi_device *spi,
    1712                 :            :                            struct device_node *nc)
    1713                 :            : {
    1714                 :            :         u32 value;
    1715                 :            :         int rc;
    1716                 :            : 
    1717                 :            :         /* Mode (clock phase/polarity/etc.) */
    1718                 :          0 :         if (of_property_read_bool(nc, "spi-cpha"))
    1719                 :          0 :                 spi->mode |= SPI_CPHA;
    1720                 :          0 :         if (of_property_read_bool(nc, "spi-cpol"))
    1721                 :          0 :                 spi->mode |= SPI_CPOL;
    1722                 :          0 :         if (of_property_read_bool(nc, "spi-3wire"))
    1723                 :          0 :                 spi->mode |= SPI_3WIRE;
    1724                 :          0 :         if (of_property_read_bool(nc, "spi-lsb-first"))
    1725                 :          0 :                 spi->mode |= SPI_LSB_FIRST;
    1726                 :          0 :         if (of_property_read_bool(nc, "spi-cs-high"))
    1727                 :          0 :                 spi->mode |= SPI_CS_HIGH;
    1728                 :            : 
    1729                 :            :         /* Device DUAL/QUAD mode */
    1730                 :          0 :         if (!of_property_read_u32(nc, "spi-tx-bus-width", &value)) {
    1731                 :          0 :                 switch (value) {
    1732                 :            :                 case 1:
    1733                 :            :                         break;
    1734                 :            :                 case 2:
    1735                 :          0 :                         spi->mode |= SPI_TX_DUAL;
    1736                 :          0 :                         break;
    1737                 :            :                 case 4:
    1738                 :          0 :                         spi->mode |= SPI_TX_QUAD;
    1739                 :          0 :                         break;
    1740                 :            :                 case 8:
    1741                 :          0 :                         spi->mode |= SPI_TX_OCTAL;
    1742                 :          0 :                         break;
    1743                 :            :                 default:
    1744                 :          0 :                         dev_warn(&ctlr->dev,
    1745                 :            :                                 "spi-tx-bus-width %d not supported\n",
    1746                 :            :                                 value);
    1747                 :          0 :                         break;
    1748                 :            :                 }
    1749                 :            :         }
    1750                 :            : 
    1751                 :          0 :         if (!of_property_read_u32(nc, "spi-rx-bus-width", &value)) {
    1752                 :          0 :                 switch (value) {
    1753                 :            :                 case 1:
    1754                 :            :                         break;
    1755                 :            :                 case 2:
    1756                 :          0 :                         spi->mode |= SPI_RX_DUAL;
    1757                 :          0 :                         break;
    1758                 :            :                 case 4:
    1759                 :          0 :                         spi->mode |= SPI_RX_QUAD;
    1760                 :          0 :                         break;
    1761                 :            :                 case 8:
    1762                 :          0 :                         spi->mode |= SPI_RX_OCTAL;
    1763                 :          0 :                         break;
    1764                 :            :                 default:
    1765                 :          0 :                         dev_warn(&ctlr->dev,
    1766                 :            :                                 "spi-rx-bus-width %d not supported\n",
    1767                 :            :                                 value);
    1768                 :          0 :                         break;
    1769                 :            :                 }
    1770                 :            :         }
    1771                 :            : 
    1772                 :          0 :         if (spi_controller_is_slave(ctlr)) {
    1773                 :          0 :                 if (!of_node_name_eq(nc, "slave")) {
    1774                 :          0 :                         dev_err(&ctlr->dev, "%pOF is not called 'slave'\n",
    1775                 :            :                                 nc);
    1776                 :          0 :                         return -EINVAL;
    1777                 :            :                 }
    1778                 :            :                 return 0;
    1779                 :            :         }
    1780                 :            : 
    1781                 :            :         /* Device address */
    1782                 :            :         rc = of_property_read_u32(nc, "reg", &value);
    1783                 :          0 :         if (rc) {
    1784                 :          0 :                 dev_err(&ctlr->dev, "%pOF has no valid 'reg' property (%d)\n",
    1785                 :            :                         nc, rc);
    1786                 :          0 :                 return rc;
    1787                 :            :         }
    1788                 :          0 :         spi->chip_select = value;
    1789                 :            : 
    1790                 :            :         /* Device speed */
    1791                 :            :         rc = of_property_read_u32(nc, "spi-max-frequency", &value);
    1792                 :          0 :         if (rc) {
    1793                 :          0 :                 dev_err(&ctlr->dev,
    1794                 :            :                         "%pOF has no valid 'spi-max-frequency' property (%d)\n", nc, rc);
    1795                 :          0 :                 return rc;
    1796                 :            :         }
    1797                 :          0 :         spi->max_speed_hz = value;
    1798                 :            : 
    1799                 :          0 :         return 0;
    1800                 :            : }
    1801                 :            : 
    1802                 :            : static struct spi_device *
    1803                 :          0 : of_register_spi_device(struct spi_controller *ctlr, struct device_node *nc)
    1804                 :            : {
    1805                 :            :         struct spi_device *spi;
    1806                 :            :         int rc;
    1807                 :            : 
    1808                 :            :         /* Alloc an spi_device */
    1809                 :          0 :         spi = spi_alloc_device(ctlr);
    1810                 :          0 :         if (!spi) {
    1811                 :          0 :                 dev_err(&ctlr->dev, "spi_device alloc error for %pOF\n", nc);
    1812                 :            :                 rc = -ENOMEM;
    1813                 :          0 :                 goto err_out;
    1814                 :            :         }
    1815                 :            : 
    1816                 :            :         /* Select device driver */
    1817                 :          0 :         rc = of_modalias_node(nc, spi->modalias,
    1818                 :            :                                 sizeof(spi->modalias));
    1819                 :          0 :         if (rc < 0) {
    1820                 :          0 :                 dev_err(&ctlr->dev, "cannot find modalias for %pOF\n", nc);
    1821                 :          0 :                 goto err_out;
    1822                 :            :         }
    1823                 :            : 
    1824                 :          0 :         rc = of_spi_parse_dt(ctlr, spi, nc);
    1825                 :          0 :         if (rc)
    1826                 :            :                 goto err_out;
    1827                 :            : 
    1828                 :            :         /* Store a pointer to the node in the device structure */
    1829                 :          0 :         of_node_get(nc);
    1830                 :          0 :         spi->dev.of_node = nc;
    1831                 :            : 
    1832                 :            :         /* Register the new device */
    1833                 :          0 :         rc = spi_add_device(spi);
    1834                 :          0 :         if (rc) {
    1835                 :          0 :                 dev_err(&ctlr->dev, "spi_device register error %pOF\n", nc);
    1836                 :            :                 goto err_of_node_put;
    1837                 :            :         }
    1838                 :            : 
    1839                 :            :         return spi;
    1840                 :            : 
    1841                 :            : err_of_node_put:
    1842                 :          0 :         of_node_put(nc);
    1843                 :            : err_out:
    1844                 :            :         spi_dev_put(spi);
    1845                 :          0 :         return ERR_PTR(rc);
    1846                 :            : }
    1847                 :            : 
    1848                 :            : /**
    1849                 :            :  * of_register_spi_devices() - Register child devices onto the SPI bus
    1850                 :            :  * @ctlr:       Pointer to spi_controller device
    1851                 :            :  *
    1852                 :            :  * Registers an spi_device for each child node of controller node which
    1853                 :            :  * represents a valid SPI slave.
    1854                 :            :  */
    1855                 :          0 : static void of_register_spi_devices(struct spi_controller *ctlr)
    1856                 :            : {
    1857                 :            :         struct spi_device *spi;
    1858                 :            :         struct device_node *nc;
    1859                 :            : 
    1860                 :          0 :         if (!ctlr->dev.of_node)
    1861                 :          0 :                 return;
    1862                 :            : 
    1863                 :          0 :         for_each_available_child_of_node(ctlr->dev.of_node, nc) {
    1864                 :          0 :                 if (of_node_test_and_set_flag(nc, OF_POPULATED))
    1865                 :          0 :                         continue;
    1866                 :          0 :                 spi = of_register_spi_device(ctlr, nc);
    1867                 :          0 :                 if (IS_ERR(spi)) {
    1868                 :          0 :                         dev_warn(&ctlr->dev,
    1869                 :            :                                  "Failed to create SPI device for %pOF\n", nc);
    1870                 :            :                         of_node_clear_flag(nc, OF_POPULATED);
    1871                 :            :                 }
    1872                 :            :         }
    1873                 :            : }
    1874                 :            : #else
    1875                 :            : static void of_register_spi_devices(struct spi_controller *ctlr) { }
    1876                 :            : #endif
    1877                 :            : 
    1878                 :            : #ifdef CONFIG_ACPI
    1879                 :            : struct acpi_spi_lookup {
    1880                 :            :         struct spi_controller   *ctlr;
    1881                 :            :         u32                     max_speed_hz;
    1882                 :            :         u32                     mode;
    1883                 :            :         int                     irq;
    1884                 :            :         u8                      bits_per_word;
    1885                 :            :         u8                      chip_select;
    1886                 :            : };
    1887                 :            : 
    1888                 :            : static void acpi_spi_parse_apple_properties(struct acpi_device *dev,
    1889                 :            :                                             struct acpi_spi_lookup *lookup)
    1890                 :            : {
    1891                 :            :         const union acpi_object *obj;
    1892                 :            : 
    1893                 :            :         if (!x86_apple_machine)
    1894                 :            :                 return;
    1895                 :            : 
    1896                 :            :         if (!acpi_dev_get_property(dev, "spiSclkPeriod", ACPI_TYPE_BUFFER, &obj)
    1897                 :            :             && obj->buffer.length >= 4)
    1898                 :            :                 lookup->max_speed_hz  = NSEC_PER_SEC / *(u32 *)obj->buffer.pointer;
    1899                 :            : 
    1900                 :            :         if (!acpi_dev_get_property(dev, "spiWordSize", ACPI_TYPE_BUFFER, &obj)
    1901                 :            :             && obj->buffer.length == 8)
    1902                 :            :                 lookup->bits_per_word = *(u64 *)obj->buffer.pointer;
    1903                 :            : 
    1904                 :            :         if (!acpi_dev_get_property(dev, "spiBitOrder", ACPI_TYPE_BUFFER, &obj)
    1905                 :            :             && obj->buffer.length == 8 && !*(u64 *)obj->buffer.pointer)
    1906                 :            :                 lookup->mode |= SPI_LSB_FIRST;
    1907                 :            : 
    1908                 :            :         if (!acpi_dev_get_property(dev, "spiSPO", ACPI_TYPE_BUFFER, &obj)
    1909                 :            :             && obj->buffer.length == 8 &&  *(u64 *)obj->buffer.pointer)
    1910                 :            :                 lookup->mode |= SPI_CPOL;
    1911                 :            : 
    1912                 :            :         if (!acpi_dev_get_property(dev, "spiSPH", ACPI_TYPE_BUFFER, &obj)
    1913                 :            :             && obj->buffer.length == 8 &&  *(u64 *)obj->buffer.pointer)
    1914                 :            :                 lookup->mode |= SPI_CPHA;
    1915                 :            : }
    1916                 :            : 
    1917                 :            : static int acpi_spi_add_resource(struct acpi_resource *ares, void *data)
    1918                 :            : {
    1919                 :            :         struct acpi_spi_lookup *lookup = data;
    1920                 :            :         struct spi_controller *ctlr = lookup->ctlr;
    1921                 :            : 
    1922                 :            :         if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
    1923                 :            :                 struct acpi_resource_spi_serialbus *sb;
    1924                 :            :                 acpi_handle parent_handle;
    1925                 :            :                 acpi_status status;
    1926                 :            : 
    1927                 :            :                 sb = &ares->data.spi_serial_bus;
    1928                 :            :                 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_SPI) {
    1929                 :            : 
    1930                 :            :                         status = acpi_get_handle(NULL,
    1931                 :            :                                                  sb->resource_source.string_ptr,
    1932                 :            :                                                  &parent_handle);
    1933                 :            : 
    1934                 :            :                         if (ACPI_FAILURE(status) ||
    1935                 :            :                             ACPI_HANDLE(ctlr->dev.parent) != parent_handle)
    1936                 :            :                                 return -ENODEV;
    1937                 :            : 
    1938                 :            :                         /*
    1939                 :            :                          * ACPI DeviceSelection numbering is handled by the
    1940                 :            :                          * host controller driver in Windows and can vary
    1941                 :            :                          * from driver to driver. In Linux we always expect
    1942                 :            :                          * 0 .. max - 1 so we need to ask the driver to
    1943                 :            :                          * translate between the two schemes.
    1944                 :            :                          */
    1945                 :            :                         if (ctlr->fw_translate_cs) {
    1946                 :            :                                 int cs = ctlr->fw_translate_cs(ctlr,
    1947                 :            :                                                 sb->device_selection);
    1948                 :            :                                 if (cs < 0)
    1949                 :            :                                         return cs;
    1950                 :            :                                 lookup->chip_select = cs;
    1951                 :            :                         } else {
    1952                 :            :                                 lookup->chip_select = sb->device_selection;
    1953                 :            :                         }
    1954                 :            : 
    1955                 :            :                         lookup->max_speed_hz = sb->connection_speed;
    1956                 :            :                         lookup->bits_per_word = sb->data_bit_length;
    1957                 :            : 
    1958                 :            :                         if (sb->clock_phase == ACPI_SPI_SECOND_PHASE)
    1959                 :            :                                 lookup->mode |= SPI_CPHA;
    1960                 :            :                         if (sb->clock_polarity == ACPI_SPI_START_HIGH)
    1961                 :            :                                 lookup->mode |= SPI_CPOL;
    1962                 :            :                         if (sb->device_polarity == ACPI_SPI_ACTIVE_HIGH)
    1963                 :            :                                 lookup->mode |= SPI_CS_HIGH;
    1964                 :            :                 }
    1965                 :            :         } else if (lookup->irq < 0) {
    1966                 :            :                 struct resource r;
    1967                 :            : 
    1968                 :            :                 if (acpi_dev_resource_interrupt(ares, 0, &r))
    1969                 :            :                         lookup->irq = r.start;
    1970                 :            :         }
    1971                 :            : 
    1972                 :            :         /* Always tell the ACPI core to skip this resource */
    1973                 :            :         return 1;
    1974                 :            : }
    1975                 :            : 
    1976                 :            : static acpi_status acpi_register_spi_device(struct spi_controller *ctlr,
    1977                 :            :                                             struct acpi_device *adev)
    1978                 :            : {
    1979                 :            :         acpi_handle parent_handle = NULL;
    1980                 :            :         struct list_head resource_list;
    1981                 :            :         struct acpi_spi_lookup lookup = {};
    1982                 :            :         struct spi_device *spi;
    1983                 :            :         int ret;
    1984                 :            : 
    1985                 :            :         if (acpi_bus_get_status(adev) || !adev->status.present ||
    1986                 :            :             acpi_device_enumerated(adev))
    1987                 :            :                 return AE_OK;
    1988                 :            : 
    1989                 :            :         lookup.ctlr             = ctlr;
    1990                 :            :         lookup.irq              = -1;
    1991                 :            : 
    1992                 :            :         INIT_LIST_HEAD(&resource_list);
    1993                 :            :         ret = acpi_dev_get_resources(adev, &resource_list,
    1994                 :            :                                      acpi_spi_add_resource, &lookup);
    1995                 :            :         acpi_dev_free_resource_list(&resource_list);
    1996                 :            : 
    1997                 :            :         if (ret < 0)
    1998                 :            :                 /* found SPI in _CRS but it points to another controller */
    1999                 :            :                 return AE_OK;
    2000                 :            : 
    2001                 :            :         if (!lookup.max_speed_hz &&
    2002                 :            :             !ACPI_FAILURE(acpi_get_parent(adev->handle, &parent_handle)) &&
    2003                 :            :             ACPI_HANDLE(ctlr->dev.parent) == parent_handle) {
    2004                 :            :                 /* Apple does not use _CRS but nested devices for SPI slaves */
    2005                 :            :                 acpi_spi_parse_apple_properties(adev, &lookup);
    2006                 :            :         }
    2007                 :            : 
    2008                 :            :         if (!lookup.max_speed_hz)
    2009                 :            :                 return AE_OK;
    2010                 :            : 
    2011                 :            :         spi = spi_alloc_device(ctlr);
    2012                 :            :         if (!spi) {
    2013                 :            :                 dev_err(&ctlr->dev, "failed to allocate SPI device for %s\n",
    2014                 :            :                         dev_name(&adev->dev));
    2015                 :            :                 return AE_NO_MEMORY;
    2016                 :            :         }
    2017                 :            : 
    2018                 :            :         ACPI_COMPANION_SET(&spi->dev, adev);
    2019                 :            :         spi->max_speed_hz    = lookup.max_speed_hz;
    2020                 :            :         spi->mode            = lookup.mode;
    2021                 :            :         spi->irq             = lookup.irq;
    2022                 :            :         spi->bits_per_word   = lookup.bits_per_word;
    2023                 :            :         spi->chip_select     = lookup.chip_select;
    2024                 :            : 
    2025                 :            :         acpi_set_modalias(adev, acpi_device_hid(adev), spi->modalias,
    2026                 :            :                           sizeof(spi->modalias));
    2027                 :            : 
    2028                 :            :         if (spi->irq < 0)
    2029                 :            :                 spi->irq = acpi_dev_gpio_irq_get(adev, 0);
    2030                 :            : 
    2031                 :            :         acpi_device_set_enumerated(adev);
    2032                 :            : 
    2033                 :            :         adev->power.flags.ignore_parent = true;
    2034                 :            :         if (spi_add_device(spi)) {
    2035                 :            :                 adev->power.flags.ignore_parent = false;
    2036                 :            :                 dev_err(&ctlr->dev, "failed to add SPI device %s from ACPI\n",
    2037                 :            :                         dev_name(&adev->dev));
    2038                 :            :                 spi_dev_put(spi);
    2039                 :            :         }
    2040                 :            : 
    2041                 :            :         return AE_OK;
    2042                 :            : }
    2043                 :            : 
    2044                 :            : static acpi_status acpi_spi_add_device(acpi_handle handle, u32 level,
    2045                 :            :                                        void *data, void **return_value)
    2046                 :            : {
    2047                 :            :         struct spi_controller *ctlr = data;
    2048                 :            :         struct acpi_device *adev;
    2049                 :            : 
    2050                 :            :         if (acpi_bus_get_device(handle, &adev))
    2051                 :            :                 return AE_OK;
    2052                 :            : 
    2053                 :            :         return acpi_register_spi_device(ctlr, adev);
    2054                 :            : }
    2055                 :            : 
    2056                 :            : #define SPI_ACPI_ENUMERATE_MAX_DEPTH            32
    2057                 :            : 
    2058                 :            : static void acpi_register_spi_devices(struct spi_controller *ctlr)
    2059                 :            : {
    2060                 :            :         acpi_status status;
    2061                 :            :         acpi_handle handle;
    2062                 :            : 
    2063                 :            :         handle = ACPI_HANDLE(ctlr->dev.parent);
    2064                 :            :         if (!handle)
    2065                 :            :                 return;
    2066                 :            : 
    2067                 :            :         status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
    2068                 :            :                                      SPI_ACPI_ENUMERATE_MAX_DEPTH,
    2069                 :            :                                      acpi_spi_add_device, NULL, ctlr, NULL);
    2070                 :            :         if (ACPI_FAILURE(status))
    2071                 :            :                 dev_warn(&ctlr->dev, "failed to enumerate SPI slaves\n");
    2072                 :            : }
    2073                 :            : #else
    2074                 :            : static inline void acpi_register_spi_devices(struct spi_controller *ctlr) {}
    2075                 :            : #endif /* CONFIG_ACPI */
    2076                 :            : 
    2077                 :          0 : static void spi_controller_release(struct device *dev)
    2078                 :            : {
    2079                 :            :         struct spi_controller *ctlr;
    2080                 :            : 
    2081                 :            :         ctlr = container_of(dev, struct spi_controller, dev);
    2082                 :          0 :         kfree(ctlr);
    2083                 :          0 : }
    2084                 :            : 
    2085                 :            : static struct class spi_master_class = {
    2086                 :            :         .name           = "spi_master",
    2087                 :            :         .owner          = THIS_MODULE,
    2088                 :            :         .dev_release    = spi_controller_release,
    2089                 :            :         .dev_groups     = spi_master_groups,
    2090                 :            : };
    2091                 :            : 
    2092                 :            : #ifdef CONFIG_SPI_SLAVE
    2093                 :            : /**
    2094                 :            :  * spi_slave_abort - abort the ongoing transfer request on an SPI slave
    2095                 :            :  *                   controller
    2096                 :            :  * @spi: device used for the current transfer
    2097                 :            :  */
    2098                 :          0 : int spi_slave_abort(struct spi_device *spi)
    2099                 :            : {
    2100                 :          0 :         struct spi_controller *ctlr = spi->controller;
    2101                 :            : 
    2102                 :          0 :         if (spi_controller_is_slave(ctlr) && ctlr->slave_abort)
    2103                 :          0 :                 return ctlr->slave_abort(ctlr);
    2104                 :            : 
    2105                 :            :         return -ENOTSUPP;
    2106                 :            : }
    2107                 :            : EXPORT_SYMBOL_GPL(spi_slave_abort);
    2108                 :            : 
    2109                 :          0 : static int match_true(struct device *dev, void *data)
    2110                 :            : {
    2111                 :          0 :         return 1;
    2112                 :            : }
    2113                 :            : 
    2114                 :          0 : static ssize_t slave_show(struct device *dev, struct device_attribute *attr,
    2115                 :            :                           char *buf)
    2116                 :            : {
    2117                 :            :         struct spi_controller *ctlr = container_of(dev, struct spi_controller,
    2118                 :            :                                                    dev);
    2119                 :            :         struct device *child;
    2120                 :            : 
    2121                 :          0 :         child = device_find_child(&ctlr->dev, NULL, match_true);
    2122                 :          0 :         return sprintf(buf, "%s\n",
    2123                 :            :                        child ? to_spi_device(child)->modalias : NULL);
    2124                 :            : }
    2125                 :            : 
    2126                 :          0 : static ssize_t slave_store(struct device *dev, struct device_attribute *attr,
    2127                 :            :                            const char *buf, size_t count)
    2128                 :            : {
    2129                 :            :         struct spi_controller *ctlr = container_of(dev, struct spi_controller,
    2130                 :            :                                                    dev);
    2131                 :            :         struct spi_device *spi;
    2132                 :            :         struct device *child;
    2133                 :            :         char name[32];
    2134                 :            :         int rc;
    2135                 :            : 
    2136                 :          0 :         rc = sscanf(buf, "%31s", name);
    2137                 :          0 :         if (rc != 1 || !name[0])
    2138                 :            :                 return -EINVAL;
    2139                 :            : 
    2140                 :          0 :         child = device_find_child(&ctlr->dev, NULL, match_true);
    2141                 :          0 :         if (child) {
    2142                 :            :                 /* Remove registered slave */
    2143                 :          0 :                 device_unregister(child);
    2144                 :          0 :                 put_device(child);
    2145                 :            :         }
    2146                 :            : 
    2147                 :          0 :         if (strcmp(name, "(null)")) {
    2148                 :            :                 /* Register new slave */
    2149                 :          0 :                 spi = spi_alloc_device(ctlr);
    2150                 :          0 :                 if (!spi)
    2151                 :            :                         return -ENOMEM;
    2152                 :            : 
    2153                 :          0 :                 strlcpy(spi->modalias, name, sizeof(spi->modalias));
    2154                 :            : 
    2155                 :          0 :                 rc = spi_add_device(spi);
    2156                 :          0 :                 if (rc) {
    2157                 :            :                         spi_dev_put(spi);
    2158                 :          0 :                         return rc;
    2159                 :            :                 }
    2160                 :            :         }
    2161                 :            : 
    2162                 :          0 :         return count;
    2163                 :            : }
    2164                 :            : 
    2165                 :            : static DEVICE_ATTR_RW(slave);
    2166                 :            : 
    2167                 :            : static struct attribute *spi_slave_attrs[] = {
    2168                 :            :         &dev_attr_slave.attr,
    2169                 :            :         NULL,
    2170                 :            : };
    2171                 :            : 
    2172                 :            : static const struct attribute_group spi_slave_group = {
    2173                 :            :         .attrs = spi_slave_attrs,
    2174                 :            : };
    2175                 :            : 
    2176                 :            : static const struct attribute_group *spi_slave_groups[] = {
    2177                 :            :         &spi_controller_statistics_group,
    2178                 :            :         &spi_slave_group,
    2179                 :            :         NULL,
    2180                 :            : };
    2181                 :            : 
    2182                 :            : static struct class spi_slave_class = {
    2183                 :            :         .name           = "spi_slave",
    2184                 :            :         .owner          = THIS_MODULE,
    2185                 :            :         .dev_release    = spi_controller_release,
    2186                 :            :         .dev_groups     = spi_slave_groups,
    2187                 :            : };
    2188                 :            : #else
    2189                 :            : extern struct class spi_slave_class;    /* dummy */
    2190                 :            : #endif
    2191                 :            : 
    2192                 :            : /**
    2193                 :            :  * __spi_alloc_controller - allocate an SPI master or slave controller
    2194                 :            :  * @dev: the controller, possibly using the platform_bus
    2195                 :            :  * @size: how much zeroed driver-private data to allocate; the pointer to this
    2196                 :            :  *      memory is in the driver_data field of the returned device, accessible
    2197                 :            :  *      with spi_controller_get_devdata(); the memory is cacheline aligned;
    2198                 :            :  *      drivers granting DMA access to portions of their private data need to
    2199                 :            :  *      round up @size using ALIGN(size, dma_get_cache_alignment()).
    2200                 :            :  * @slave: flag indicating whether to allocate an SPI master (false) or SPI
    2201                 :            :  *      slave (true) controller
    2202                 :            :  * Context: can sleep
    2203                 :            :  *
    2204                 :            :  * This call is used only by SPI controller drivers, which are the
    2205                 :            :  * only ones directly touching chip registers.  It's how they allocate
    2206                 :            :  * an spi_controller structure, prior to calling spi_register_controller().
    2207                 :            :  *
    2208                 :            :  * This must be called from context that can sleep.
    2209                 :            :  *
    2210                 :            :  * The caller is responsible for assigning the bus number and initializing the
    2211                 :            :  * controller's methods before calling spi_register_controller(); and (after
    2212                 :            :  * errors adding the device) calling spi_controller_put() to prevent a memory
    2213                 :            :  * leak.
    2214                 :            :  *
    2215                 :            :  * Return: the SPI controller structure on success, else NULL.
    2216                 :            :  */
    2217                 :          0 : struct spi_controller *__spi_alloc_controller(struct device *dev,
    2218                 :            :                                               unsigned int size, bool slave)
    2219                 :            : {
    2220                 :            :         struct spi_controller   *ctlr;
    2221                 :            :         size_t ctlr_size = ALIGN(sizeof(*ctlr), dma_get_cache_alignment());
    2222                 :            : 
    2223                 :          0 :         if (!dev)
    2224                 :            :                 return NULL;
    2225                 :            : 
    2226                 :          0 :         ctlr = kzalloc(size + ctlr_size, GFP_KERNEL);
    2227                 :          0 :         if (!ctlr)
    2228                 :            :                 return NULL;
    2229                 :            : 
    2230                 :          0 :         device_initialize(&ctlr->dev);
    2231                 :          0 :         ctlr->bus_num = -1;
    2232                 :          0 :         ctlr->num_chipselect = 1;
    2233                 :          0 :         ctlr->slave = slave;
    2234                 :          0 :         if (IS_ENABLED(CONFIG_SPI_SLAVE) && slave)
    2235                 :          0 :                 ctlr->dev.class = &spi_slave_class;
    2236                 :            :         else
    2237                 :          0 :                 ctlr->dev.class = &spi_master_class;
    2238                 :          0 :         ctlr->dev.parent = dev;
    2239                 :            :         pm_suspend_ignore_children(&ctlr->dev, true);
    2240                 :          0 :         spi_controller_set_devdata(ctlr, (void *)ctlr + ctlr_size);
    2241                 :            : 
    2242                 :          0 :         return ctlr;
    2243                 :            : }
    2244                 :            : EXPORT_SYMBOL_GPL(__spi_alloc_controller);
    2245                 :            : 
    2246                 :            : #ifdef CONFIG_OF
    2247                 :          0 : static int of_spi_get_gpio_numbers(struct spi_controller *ctlr)
    2248                 :            : {
    2249                 :            :         int nb, i, *cs;
    2250                 :          0 :         struct device_node *np = ctlr->dev.of_node;
    2251                 :            : 
    2252                 :          0 :         if (!np)
    2253                 :            :                 return 0;
    2254                 :            : 
    2255                 :            :         nb = of_gpio_named_count(np, "cs-gpios");
    2256                 :          0 :         ctlr->num_chipselect = max_t(int, nb, ctlr->num_chipselect);
    2257                 :            : 
    2258                 :            :         /* Return error only for an incorrectly formed cs-gpios property */
    2259                 :          0 :         if (nb == 0 || nb == -ENOENT)
    2260                 :            :                 return 0;
    2261                 :          0 :         else if (nb < 0)
    2262                 :            :                 return nb;
    2263                 :            : 
    2264                 :          0 :         cs = devm_kcalloc(&ctlr->dev, ctlr->num_chipselect, sizeof(int),
    2265                 :            :                           GFP_KERNEL);
    2266                 :          0 :         ctlr->cs_gpios = cs;
    2267                 :            : 
    2268                 :          0 :         if (!ctlr->cs_gpios)
    2269                 :            :                 return -ENOMEM;
    2270                 :            : 
    2271                 :          0 :         for (i = 0; i < ctlr->num_chipselect; i++)
    2272                 :          0 :                 cs[i] = -ENOENT;
    2273                 :            : 
    2274                 :          0 :         for (i = 0; i < nb; i++)
    2275                 :          0 :                 cs[i] = of_get_named_gpio(np, "cs-gpios", i);
    2276                 :            : 
    2277                 :            :         return 0;
    2278                 :            : }
    2279                 :            : #else
    2280                 :            : static int of_spi_get_gpio_numbers(struct spi_controller *ctlr)
    2281                 :            : {
    2282                 :            :         return 0;
    2283                 :            : }
    2284                 :            : #endif
    2285                 :            : 
    2286                 :            : /**
    2287                 :            :  * spi_get_gpio_descs() - grab chip select GPIOs for the master
    2288                 :            :  * @ctlr: The SPI master to grab GPIO descriptors for
    2289                 :            :  */
    2290                 :          0 : static int spi_get_gpio_descs(struct spi_controller *ctlr)
    2291                 :            : {
    2292                 :            :         int nb, i;
    2293                 :            :         struct gpio_desc **cs;
    2294                 :          0 :         struct device *dev = &ctlr->dev;
    2295                 :            : 
    2296                 :          0 :         nb = gpiod_count(dev, "cs");
    2297                 :          0 :         ctlr->num_chipselect = max_t(int, nb, ctlr->num_chipselect);
    2298                 :            : 
    2299                 :            :         /* No GPIOs at all is fine, else return the error */
    2300                 :          0 :         if (nb == 0 || nb == -ENOENT)
    2301                 :            :                 return 0;
    2302                 :          0 :         else if (nb < 0)
    2303                 :            :                 return nb;
    2304                 :            : 
    2305                 :          0 :         cs = devm_kcalloc(dev, ctlr->num_chipselect, sizeof(*cs),
    2306                 :            :                           GFP_KERNEL);
    2307                 :          0 :         if (!cs)
    2308                 :            :                 return -ENOMEM;
    2309                 :          0 :         ctlr->cs_gpiods = cs;
    2310                 :            : 
    2311                 :          0 :         for (i = 0; i < nb; i++) {
    2312                 :            :                 /*
    2313                 :            :                  * Most chipselects are active low, the inverted
    2314                 :            :                  * semantics are handled by special quirks in gpiolib,
    2315                 :            :                  * so initializing them GPIOD_OUT_LOW here means
    2316                 :            :                  * "unasserted", in most cases this will drive the physical
    2317                 :            :                  * line high.
    2318                 :            :                  */
    2319                 :          0 :                 cs[i] = devm_gpiod_get_index_optional(dev, "cs", i,
    2320                 :            :                                                       GPIOD_OUT_LOW);
    2321                 :          0 :                 if (IS_ERR(cs[i]))
    2322                 :          0 :                         return PTR_ERR(cs[i]);
    2323                 :            : 
    2324                 :          0 :                 if (cs[i]) {
    2325                 :            :                         /*
    2326                 :            :                          * If we find a CS GPIO, name it after the device and
    2327                 :            :                          * chip select line.
    2328                 :            :                          */
    2329                 :            :                         char *gpioname;
    2330                 :            : 
    2331                 :          0 :                         gpioname = devm_kasprintf(dev, GFP_KERNEL, "%s CS%d",
    2332                 :            :                                                   dev_name(dev), i);
    2333                 :          0 :                         if (!gpioname)
    2334                 :            :                                 return -ENOMEM;
    2335                 :          0 :                         gpiod_set_consumer_name(cs[i], gpioname);
    2336                 :            :                 }
    2337                 :            :         }
    2338                 :            : 
    2339                 :            :         return 0;
    2340                 :            : }
    2341                 :            : 
    2342                 :            : static int spi_controller_check_ops(struct spi_controller *ctlr)
    2343                 :            : {
    2344                 :            :         /*
    2345                 :            :          * The controller may implement only the high-level SPI-memory like
    2346                 :            :          * operations if it does not support regular SPI transfers, and this is
    2347                 :            :          * valid use case.
    2348                 :            :          * If ->mem_ops is NULL, we request that at least one of the
    2349                 :            :          * ->transfer_xxx() method be implemented.
    2350                 :            :          */
    2351                 :          0 :         if (ctlr->mem_ops) {
    2352                 :          0 :                 if (!ctlr->mem_ops->exec_op)
    2353                 :            :                         return -EINVAL;
    2354                 :          0 :         } else if (!ctlr->transfer && !ctlr->transfer_one &&
    2355                 :          0 :                    !ctlr->transfer_one_message) {
    2356                 :            :                 return -EINVAL;
    2357                 :            :         }
    2358                 :            : 
    2359                 :            :         return 0;
    2360                 :            : }
    2361                 :            : 
    2362                 :            : /**
    2363                 :            :  * spi_register_controller - register SPI master or slave controller
    2364                 :            :  * @ctlr: initialized master, originally from spi_alloc_master() or
    2365                 :            :  *      spi_alloc_slave()
    2366                 :            :  * Context: can sleep
    2367                 :            :  *
    2368                 :            :  * SPI controllers connect to their drivers using some non-SPI bus,
    2369                 :            :  * such as the platform bus.  The final stage of probe() in that code
    2370                 :            :  * includes calling spi_register_controller() to hook up to this SPI bus glue.
    2371                 :            :  *
    2372                 :            :  * SPI controllers use board specific (often SOC specific) bus numbers,
    2373                 :            :  * and board-specific addressing for SPI devices combines those numbers
    2374                 :            :  * with chip select numbers.  Since SPI does not directly support dynamic
    2375                 :            :  * device identification, boards need configuration tables telling which
    2376                 :            :  * chip is at which address.
    2377                 :            :  *
    2378                 :            :  * This must be called from context that can sleep.  It returns zero on
    2379                 :            :  * success, else a negative error code (dropping the controller's refcount).
    2380                 :            :  * After a successful return, the caller is responsible for calling
    2381                 :            :  * spi_unregister_controller().
    2382                 :            :  *
    2383                 :            :  * Return: zero on success, else a negative error code.
    2384                 :            :  */
    2385                 :          0 : int spi_register_controller(struct spi_controller *ctlr)
    2386                 :            : {
    2387                 :          0 :         struct device           *dev = ctlr->dev.parent;
    2388                 :            :         struct boardinfo        *bi;
    2389                 :            :         int                     status;
    2390                 :            :         int                     id, first_dynamic;
    2391                 :            : 
    2392                 :          0 :         if (!dev)
    2393                 :            :                 return -ENODEV;
    2394                 :            : 
    2395                 :            :         /*
    2396                 :            :          * Make sure all necessary hooks are implemented before registering
    2397                 :            :          * the SPI controller.
    2398                 :            :          */
    2399                 :            :         status = spi_controller_check_ops(ctlr);
    2400                 :          0 :         if (status)
    2401                 :            :                 return status;
    2402                 :            : 
    2403                 :          0 :         if (ctlr->bus_num >= 0) {
    2404                 :            :                 /* devices with a fixed bus num must check-in with the num */
    2405                 :          0 :                 mutex_lock(&board_lock);
    2406                 :          0 :                 id = idr_alloc(&spi_master_idr, ctlr, ctlr->bus_num,
    2407                 :          0 :                         ctlr->bus_num + 1, GFP_KERNEL);
    2408                 :          0 :                 mutex_unlock(&board_lock);
    2409                 :          0 :                 if (WARN(id < 0, "couldn't get idr"))
    2410                 :          0 :                         return id == -ENOSPC ? -EBUSY : id;
    2411                 :          0 :                 ctlr->bus_num = id;
    2412                 :          0 :         } else if (ctlr->dev.of_node) {
    2413                 :            :                 /* allocate dynamic bus number using Linux idr */
    2414                 :          0 :                 id = of_alias_get_id(ctlr->dev.of_node, "spi");
    2415                 :          0 :                 if (id >= 0) {
    2416                 :          0 :                         ctlr->bus_num = id;
    2417                 :          0 :                         mutex_lock(&board_lock);
    2418                 :          0 :                         id = idr_alloc(&spi_master_idr, ctlr, ctlr->bus_num,
    2419                 :          0 :                                        ctlr->bus_num + 1, GFP_KERNEL);
    2420                 :          0 :                         mutex_unlock(&board_lock);
    2421                 :          0 :                         if (WARN(id < 0, "couldn't get idr"))
    2422                 :          0 :                                 return id == -ENOSPC ? -EBUSY : id;
    2423                 :            :                 }
    2424                 :            :         }
    2425                 :          0 :         if (ctlr->bus_num < 0) {
    2426                 :          0 :                 first_dynamic = of_alias_get_highest_id("spi");
    2427                 :          0 :                 if (first_dynamic < 0)
    2428                 :            :                         first_dynamic = 0;
    2429                 :            :                 else
    2430                 :          0 :                         first_dynamic++;
    2431                 :            : 
    2432                 :          0 :                 mutex_lock(&board_lock);
    2433                 :          0 :                 id = idr_alloc(&spi_master_idr, ctlr, first_dynamic,
    2434                 :            :                                0, GFP_KERNEL);
    2435                 :          0 :                 mutex_unlock(&board_lock);
    2436                 :          0 :                 if (WARN(id < 0, "couldn't get idr"))
    2437                 :            :                         return id;
    2438                 :          0 :                 ctlr->bus_num = id;
    2439                 :            :         }
    2440                 :          0 :         INIT_LIST_HEAD(&ctlr->queue);
    2441                 :          0 :         spin_lock_init(&ctlr->queue_lock);
    2442                 :          0 :         spin_lock_init(&ctlr->bus_lock_spinlock);
    2443                 :          0 :         mutex_init(&ctlr->bus_lock_mutex);
    2444                 :          0 :         mutex_init(&ctlr->io_mutex);
    2445                 :          0 :         ctlr->bus_lock_flag = 0;
    2446                 :            :         init_completion(&ctlr->xfer_completion);
    2447                 :          0 :         if (!ctlr->max_dma_len)
    2448                 :          0 :                 ctlr->max_dma_len = INT_MAX;
    2449                 :            : 
    2450                 :            :         /* register the device, then userspace will see it.
    2451                 :            :          * registration fails if the bus ID is in use.
    2452                 :            :          */
    2453                 :          0 :         dev_set_name(&ctlr->dev, "spi%u", ctlr->bus_num);
    2454                 :            : 
    2455                 :          0 :         if (!spi_controller_is_slave(ctlr)) {
    2456                 :          0 :                 if (ctlr->use_gpio_descriptors) {
    2457                 :          0 :                         status = spi_get_gpio_descs(ctlr);
    2458                 :          0 :                         if (status)
    2459                 :            :                                 goto free_bus_id;
    2460                 :            :                         /*
    2461                 :            :                          * A controller using GPIO descriptors always
    2462                 :            :                          * supports SPI_CS_HIGH if need be.
    2463                 :            :                          */
    2464                 :          0 :                         ctlr->mode_bits |= SPI_CS_HIGH;
    2465                 :            :                 } else {
    2466                 :            :                         /* Legacy code path for GPIOs from DT */
    2467                 :          0 :                         status = of_spi_get_gpio_numbers(ctlr);
    2468                 :          0 :                         if (status)
    2469                 :            :                                 goto free_bus_id;
    2470                 :            :                 }
    2471                 :            :         }
    2472                 :            : 
    2473                 :            :         /*
    2474                 :            :          * Even if it's just one always-selected device, there must
    2475                 :            :          * be at least one chipselect.
    2476                 :            :          */
    2477                 :          0 :         if (!ctlr->num_chipselect) {
    2478                 :            :                 status = -EINVAL;
    2479                 :            :                 goto free_bus_id;
    2480                 :            :         }
    2481                 :            : 
    2482                 :          0 :         status = device_add(&ctlr->dev);
    2483                 :          0 :         if (status < 0)
    2484                 :            :                 goto free_bus_id;
    2485                 :            :         dev_dbg(dev, "registered %s %s\n",
    2486                 :            :                         spi_controller_is_slave(ctlr) ? "slave" : "master",
    2487                 :            :                         dev_name(&ctlr->dev));
    2488                 :            : 
    2489                 :            :         /*
    2490                 :            :          * If we're using a queued driver, start the queue. Note that we don't
    2491                 :            :          * need the queueing logic if the driver is only supporting high-level
    2492                 :            :          * memory operations.
    2493                 :            :          */
    2494                 :          0 :         if (ctlr->transfer) {
    2495                 :          0 :                 dev_info(dev, "controller is unqueued, this is deprecated\n");
    2496                 :          0 :         } else if (ctlr->transfer_one || ctlr->transfer_one_message) {
    2497                 :          0 :                 status = spi_controller_initialize_queue(ctlr);
    2498                 :          0 :                 if (status) {
    2499                 :          0 :                         device_del(&ctlr->dev);
    2500                 :          0 :                         goto free_bus_id;
    2501                 :            :                 }
    2502                 :            :         }
    2503                 :            :         /* add statistics */
    2504                 :          0 :         spin_lock_init(&ctlr->statistics.lock);
    2505                 :            : 
    2506                 :          0 :         mutex_lock(&board_lock);
    2507                 :          0 :         list_add_tail(&ctlr->list, &spi_controller_list);
    2508                 :          0 :         list_for_each_entry(bi, &board_list, list)
    2509                 :          0 :                 spi_match_controller_to_boardinfo(ctlr, &bi->board_info);
    2510                 :          0 :         mutex_unlock(&board_lock);
    2511                 :            : 
    2512                 :            :         /* Register devices from the device tree and ACPI */
    2513                 :          0 :         of_register_spi_devices(ctlr);
    2514                 :            :         acpi_register_spi_devices(ctlr);
    2515                 :          0 :         return status;
    2516                 :            : 
    2517                 :            : free_bus_id:
    2518                 :          0 :         mutex_lock(&board_lock);
    2519                 :          0 :         idr_remove(&spi_master_idr, ctlr->bus_num);
    2520                 :          0 :         mutex_unlock(&board_lock);
    2521                 :          0 :         return status;
    2522                 :            : }
    2523                 :            : EXPORT_SYMBOL_GPL(spi_register_controller);
    2524                 :            : 
    2525                 :          0 : static void devm_spi_unregister(struct device *dev, void *res)
    2526                 :            : {
    2527                 :          0 :         spi_unregister_controller(*(struct spi_controller **)res);
    2528                 :          0 : }
    2529                 :            : 
    2530                 :            : /**
    2531                 :            :  * devm_spi_register_controller - register managed SPI master or slave
    2532                 :            :  *      controller
    2533                 :            :  * @dev:    device managing SPI controller
    2534                 :            :  * @ctlr: initialized controller, originally from spi_alloc_master() or
    2535                 :            :  *      spi_alloc_slave()
    2536                 :            :  * Context: can sleep
    2537                 :            :  *
    2538                 :            :  * Register a SPI device as with spi_register_controller() which will
    2539                 :            :  * automatically be unregistered and freed.
    2540                 :            :  *
    2541                 :            :  * Return: zero on success, else a negative error code.
    2542                 :            :  */
    2543                 :          0 : int devm_spi_register_controller(struct device *dev,
    2544                 :            :                                  struct spi_controller *ctlr)
    2545                 :            : {
    2546                 :            :         struct spi_controller **ptr;
    2547                 :            :         int ret;
    2548                 :            : 
    2549                 :            :         ptr = devres_alloc(devm_spi_unregister, sizeof(*ptr), GFP_KERNEL);
    2550                 :          0 :         if (!ptr)
    2551                 :            :                 return -ENOMEM;
    2552                 :            : 
    2553                 :          0 :         ret = spi_register_controller(ctlr);
    2554                 :          0 :         if (!ret) {
    2555                 :          0 :                 *ptr = ctlr;
    2556                 :          0 :                 devres_add(dev, ptr);
    2557                 :            :         } else {
    2558                 :          0 :                 devres_free(ptr);
    2559                 :            :         }
    2560                 :            : 
    2561                 :          0 :         return ret;
    2562                 :            : }
    2563                 :            : EXPORT_SYMBOL_GPL(devm_spi_register_controller);
    2564                 :            : 
    2565                 :          0 : static int __unregister(struct device *dev, void *null)
    2566                 :            : {
    2567                 :          0 :         spi_unregister_device(to_spi_device(dev));
    2568                 :          0 :         return 0;
    2569                 :            : }
    2570                 :            : 
    2571                 :            : /**
    2572                 :            :  * spi_unregister_controller - unregister SPI master or slave controller
    2573                 :            :  * @ctlr: the controller being unregistered
    2574                 :            :  * Context: can sleep
    2575                 :            :  *
    2576                 :            :  * This call is used only by SPI controller drivers, which are the
    2577                 :            :  * only ones directly touching chip registers.
    2578                 :            :  *
    2579                 :            :  * This must be called from context that can sleep.
    2580                 :            :  *
    2581                 :            :  * Note that this function also drops a reference to the controller.
    2582                 :            :  */
    2583                 :          0 : void spi_unregister_controller(struct spi_controller *ctlr)
    2584                 :            : {
    2585                 :            :         struct spi_controller *found;
    2586                 :          0 :         int id = ctlr->bus_num;
    2587                 :            : 
    2588                 :            :         /* Prevent addition of new devices, unregister existing ones */
    2589                 :            :         if (IS_ENABLED(CONFIG_SPI_DYNAMIC))
    2590                 :          0 :                 mutex_lock(&spi_add_lock);
    2591                 :            : 
    2592                 :          0 :         device_for_each_child(&ctlr->dev, NULL, __unregister);
    2593                 :            : 
    2594                 :            :         /* First make sure that this controller was ever added */
    2595                 :          0 :         mutex_lock(&board_lock);
    2596                 :          0 :         found = idr_find(&spi_master_idr, id);
    2597                 :          0 :         mutex_unlock(&board_lock);
    2598                 :          0 :         if (ctlr->queued) {
    2599                 :          0 :                 if (spi_destroy_queue(ctlr))
    2600                 :          0 :                         dev_err(&ctlr->dev, "queue remove failed\n");
    2601                 :            :         }
    2602                 :          0 :         mutex_lock(&board_lock);
    2603                 :            :         list_del(&ctlr->list);
    2604                 :          0 :         mutex_unlock(&board_lock);
    2605                 :            : 
    2606                 :          0 :         device_unregister(&ctlr->dev);
    2607                 :            :         /* free bus id */
    2608                 :          0 :         mutex_lock(&board_lock);
    2609                 :          0 :         if (found == ctlr)
    2610                 :          0 :                 idr_remove(&spi_master_idr, id);
    2611                 :          0 :         mutex_unlock(&board_lock);
    2612                 :            : 
    2613                 :            :         if (IS_ENABLED(CONFIG_SPI_DYNAMIC))
    2614                 :          0 :                 mutex_unlock(&spi_add_lock);
    2615                 :          0 : }
    2616                 :            : EXPORT_SYMBOL_GPL(spi_unregister_controller);
    2617                 :            : 
    2618                 :          0 : int spi_controller_suspend(struct spi_controller *ctlr)
    2619                 :            : {
    2620                 :            :         int ret;
    2621                 :            : 
    2622                 :            :         /* Basically no-ops for non-queued controllers */
    2623                 :          0 :         if (!ctlr->queued)
    2624                 :            :                 return 0;
    2625                 :            : 
    2626                 :          0 :         ret = spi_stop_queue(ctlr);
    2627                 :          0 :         if (ret)
    2628                 :          0 :                 dev_err(&ctlr->dev, "queue stop failed\n");
    2629                 :            : 
    2630                 :          0 :         return ret;
    2631                 :            : }
    2632                 :            : EXPORT_SYMBOL_GPL(spi_controller_suspend);
    2633                 :            : 
    2634                 :          0 : int spi_controller_resume(struct spi_controller *ctlr)
    2635                 :            : {
    2636                 :            :         int ret;
    2637                 :            : 
    2638                 :          0 :         if (!ctlr->queued)
    2639                 :            :                 return 0;
    2640                 :            : 
    2641                 :          0 :         ret = spi_start_queue(ctlr);
    2642                 :          0 :         if (ret)
    2643                 :          0 :                 dev_err(&ctlr->dev, "queue restart failed\n");
    2644                 :            : 
    2645                 :          0 :         return ret;
    2646                 :            : }
    2647                 :            : EXPORT_SYMBOL_GPL(spi_controller_resume);
    2648                 :            : 
    2649                 :          0 : static int __spi_controller_match(struct device *dev, const void *data)
    2650                 :            : {
    2651                 :            :         struct spi_controller *ctlr;
    2652                 :            :         const u16 *bus_num = data;
    2653                 :            : 
    2654                 :            :         ctlr = container_of(dev, struct spi_controller, dev);
    2655                 :          0 :         return ctlr->bus_num == *bus_num;
    2656                 :            : }
    2657                 :            : 
    2658                 :            : /**
    2659                 :            :  * spi_busnum_to_master - look up master associated with bus_num
    2660                 :            :  * @bus_num: the master's bus number
    2661                 :            :  * Context: can sleep
    2662                 :            :  *
    2663                 :            :  * This call may be used with devices that are registered after
    2664                 :            :  * arch init time.  It returns a refcounted pointer to the relevant
    2665                 :            :  * spi_controller (which the caller must release), or NULL if there is
    2666                 :            :  * no such master registered.
    2667                 :            :  *
    2668                 :            :  * Return: the SPI master structure on success, else NULL.
    2669                 :            :  */
    2670                 :          0 : struct spi_controller *spi_busnum_to_master(u16 bus_num)
    2671                 :            : {
    2672                 :            :         struct device           *dev;
    2673                 :            :         struct spi_controller   *ctlr = NULL;
    2674                 :            : 
    2675                 :          0 :         dev = class_find_device(&spi_master_class, NULL, &bus_num,
    2676                 :            :                                 __spi_controller_match);
    2677                 :          0 :         if (dev)
    2678                 :            :                 ctlr = container_of(dev, struct spi_controller, dev);
    2679                 :            :         /* reference got in class_find_device */
    2680                 :          0 :         return ctlr;
    2681                 :            : }
    2682                 :            : EXPORT_SYMBOL_GPL(spi_busnum_to_master);
    2683                 :            : 
    2684                 :            : /*-------------------------------------------------------------------------*/
    2685                 :            : 
    2686                 :            : /* Core methods for SPI resource management */
    2687                 :            : 
    2688                 :            : /**
    2689                 :            :  * spi_res_alloc - allocate a spi resource that is life-cycle managed
    2690                 :            :  *                 during the processing of a spi_message while using
    2691                 :            :  *                 spi_transfer_one
    2692                 :            :  * @spi:     the spi device for which we allocate memory
    2693                 :            :  * @release: the release code to execute for this resource
    2694                 :            :  * @size:    size to alloc and return
    2695                 :            :  * @gfp:     GFP allocation flags
    2696                 :            :  *
    2697                 :            :  * Return: the pointer to the allocated data
    2698                 :            :  *
    2699                 :            :  * This may get enhanced in the future to allocate from a memory pool
    2700                 :            :  * of the @spi_device or @spi_controller to avoid repeated allocations.
    2701                 :            :  */
    2702                 :          0 : void *spi_res_alloc(struct spi_device *spi,
    2703                 :            :                     spi_res_release_t release,
    2704                 :            :                     size_t size, gfp_t gfp)
    2705                 :            : {
    2706                 :            :         struct spi_res *sres;
    2707                 :            : 
    2708                 :          0 :         sres = kzalloc(sizeof(*sres) + size, gfp);
    2709                 :          0 :         if (!sres)
    2710                 :            :                 return NULL;
    2711                 :            : 
    2712                 :          0 :         INIT_LIST_HEAD(&sres->entry);
    2713                 :          0 :         sres->release = release;
    2714                 :            : 
    2715                 :          0 :         return sres->data;
    2716                 :            : }
    2717                 :            : EXPORT_SYMBOL_GPL(spi_res_alloc);
    2718                 :            : 
    2719                 :            : /**
    2720                 :            :  * spi_res_free - free an spi resource
    2721                 :            :  * @res: pointer to the custom data of a resource
    2722                 :            :  *
    2723                 :            :  */
    2724                 :          0 : void spi_res_free(void *res)
    2725                 :            : {
    2726                 :          0 :         struct spi_res *sres = container_of(res, struct spi_res, data);
    2727                 :            : 
    2728                 :          0 :         if (!res)
    2729                 :          0 :                 return;
    2730                 :            : 
    2731                 :          0 :         WARN_ON(!list_empty(&sres->entry));
    2732                 :          0 :         kfree(sres);
    2733                 :            : }
    2734                 :            : EXPORT_SYMBOL_GPL(spi_res_free);
    2735                 :            : 
    2736                 :            : /**
    2737                 :            :  * spi_res_add - add a spi_res to the spi_message
    2738                 :            :  * @message: the spi message
    2739                 :            :  * @res:     the spi_resource
    2740                 :            :  */
    2741                 :          0 : void spi_res_add(struct spi_message *message, void *res)
    2742                 :            : {
    2743                 :            :         struct spi_res *sres = container_of(res, struct spi_res, data);
    2744                 :            : 
    2745                 :          0 :         WARN_ON(!list_empty(&sres->entry));
    2746                 :          0 :         list_add_tail(&sres->entry, &message->resources);
    2747                 :          0 : }
    2748                 :            : EXPORT_SYMBOL_GPL(spi_res_add);
    2749                 :            : 
    2750                 :            : /**
    2751                 :            :  * spi_res_release - release all spi resources for this message
    2752                 :            :  * @ctlr:  the @spi_controller
    2753                 :            :  * @message: the @spi_message
    2754                 :            :  */
    2755                 :          0 : void spi_res_release(struct spi_controller *ctlr, struct spi_message *message)
    2756                 :            : {
    2757                 :            :         struct spi_res *res, *tmp;
    2758                 :            : 
    2759                 :          0 :         list_for_each_entry_safe_reverse(res, tmp, &message->resources, entry) {
    2760                 :          0 :                 if (res->release)
    2761                 :          0 :                         res->release(ctlr, message, res->data);
    2762                 :            : 
    2763                 :            :                 list_del(&res->entry);
    2764                 :            : 
    2765                 :          0 :                 kfree(res);
    2766                 :            :         }
    2767                 :          0 : }
    2768                 :            : EXPORT_SYMBOL_GPL(spi_res_release);
    2769                 :            : 
    2770                 :            : /*-------------------------------------------------------------------------*/
    2771                 :            : 
    2772                 :            : /* Core methods for spi_message alterations */
    2773                 :            : 
    2774                 :          0 : static void __spi_replace_transfers_release(struct spi_controller *ctlr,
    2775                 :            :                                             struct spi_message *msg,
    2776                 :            :                                             void *res)
    2777                 :            : {
    2778                 :            :         struct spi_replaced_transfers *rxfer = res;
    2779                 :            :         size_t i;
    2780                 :            : 
    2781                 :            :         /* call extra callback if requested */
    2782                 :          0 :         if (rxfer->release)
    2783                 :          0 :                 rxfer->release(ctlr, msg, res);
    2784                 :            : 
    2785                 :            :         /* insert replaced transfers back into the message */
    2786                 :          0 :         list_splice(&rxfer->replaced_transfers, rxfer->replaced_after);
    2787                 :            : 
    2788                 :            :         /* remove the formerly inserted entries */
    2789                 :          0 :         for (i = 0; i < rxfer->inserted; i++)
    2790                 :            :                 list_del(&rxfer->inserted_transfers[i].transfer_list);
    2791                 :          0 : }
    2792                 :            : 
    2793                 :            : /**
    2794                 :            :  * spi_replace_transfers - replace transfers with several transfers
    2795                 :            :  *                         and register change with spi_message.resources
    2796                 :            :  * @msg:           the spi_message we work upon
    2797                 :            :  * @xfer_first:    the first spi_transfer we want to replace
    2798                 :            :  * @remove:        number of transfers to remove
    2799                 :            :  * @insert:        the number of transfers we want to insert instead
    2800                 :            :  * @release:       extra release code necessary in some circumstances
    2801                 :            :  * @extradatasize: extra data to allocate (with alignment guarantees
    2802                 :            :  *                 of struct @spi_transfer)
    2803                 :            :  * @gfp:           gfp flags
    2804                 :            :  *
    2805                 :            :  * Returns: pointer to @spi_replaced_transfers,
    2806                 :            :  *          PTR_ERR(...) in case of errors.
    2807                 :            :  */
    2808                 :          0 : struct spi_replaced_transfers *spi_replace_transfers(
    2809                 :            :         struct spi_message *msg,
    2810                 :            :         struct spi_transfer *xfer_first,
    2811                 :            :         size_t remove,
    2812                 :            :         size_t insert,
    2813                 :            :         spi_replaced_release_t release,
    2814                 :            :         size_t extradatasize,
    2815                 :            :         gfp_t gfp)
    2816                 :            : {
    2817                 :            :         struct spi_replaced_transfers *rxfer;
    2818                 :            :         struct spi_transfer *xfer;
    2819                 :            :         size_t i;
    2820                 :            : 
    2821                 :            :         /* allocate the structure using spi_res */
    2822                 :          0 :         rxfer = spi_res_alloc(msg->spi, __spi_replace_transfers_release,
    2823                 :          0 :                               struct_size(rxfer, inserted_transfers, insert)
    2824                 :            :                               + extradatasize,
    2825                 :            :                               gfp);
    2826                 :          0 :         if (!rxfer)
    2827                 :            :                 return ERR_PTR(-ENOMEM);
    2828                 :            : 
    2829                 :            :         /* the release code to invoke before running the generic release */
    2830                 :          0 :         rxfer->release = release;
    2831                 :            : 
    2832                 :            :         /* assign extradata */
    2833                 :          0 :         if (extradatasize)
    2834                 :          0 :                 rxfer->extradata =
    2835                 :          0 :                         &rxfer->inserted_transfers[insert];
    2836                 :            : 
    2837                 :            :         /* init the replaced_transfers list */
    2838                 :          0 :         INIT_LIST_HEAD(&rxfer->replaced_transfers);
    2839                 :            : 
    2840                 :            :         /* assign the list_entry after which we should reinsert
    2841                 :            :          * the @replaced_transfers - it may be spi_message.messages!
    2842                 :            :          */
    2843                 :          0 :         rxfer->replaced_after = xfer_first->transfer_list.prev;
    2844                 :            : 
    2845                 :            :         /* remove the requested number of transfers */
    2846                 :          0 :         for (i = 0; i < remove; i++) {
    2847                 :            :                 /* if the entry after replaced_after it is msg->transfers
    2848                 :            :                  * then we have been requested to remove more transfers
    2849                 :            :                  * than are in the list
    2850                 :            :                  */
    2851                 :          0 :                 if (rxfer->replaced_after->next == &msg->transfers) {
    2852                 :          0 :                         dev_err(&msg->spi->dev,
    2853                 :            :                                 "requested to remove more spi_transfers than are available\n");
    2854                 :            :                         /* insert replaced transfers back into the message */
    2855                 :          0 :                         list_splice(&rxfer->replaced_transfers,
    2856                 :            :                                     rxfer->replaced_after);
    2857                 :            : 
    2858                 :            :                         /* free the spi_replace_transfer structure */
    2859                 :          0 :                         spi_res_free(rxfer);
    2860                 :            : 
    2861                 :            :                         /* and return with an error */
    2862                 :          0 :                         return ERR_PTR(-EINVAL);
    2863                 :            :                 }
    2864                 :            : 
    2865                 :            :                 /* remove the entry after replaced_after from list of
    2866                 :            :                  * transfers and add it to list of replaced_transfers
    2867                 :            :                  */
    2868                 :            :                 list_move_tail(rxfer->replaced_after->next,
    2869                 :            :                                &rxfer->replaced_transfers);
    2870                 :            :         }
    2871                 :            : 
    2872                 :            :         /* create copy of the given xfer with identical settings
    2873                 :            :          * based on the first transfer to get removed
    2874                 :            :          */
    2875                 :          0 :         for (i = 0; i < insert; i++) {
    2876                 :            :                 /* we need to run in reverse order */
    2877                 :          0 :                 xfer = &rxfer->inserted_transfers[insert - 1 - i];
    2878                 :            : 
    2879                 :            :                 /* copy all spi_transfer data */
    2880                 :          0 :                 memcpy(xfer, xfer_first, sizeof(*xfer));
    2881                 :            : 
    2882                 :            :                 /* add to list */
    2883                 :          0 :                 list_add(&xfer->transfer_list, rxfer->replaced_after);
    2884                 :            : 
    2885                 :            :                 /* clear cs_change and delay_usecs for all but the last */
    2886                 :          0 :                 if (i) {
    2887                 :          0 :                         xfer->cs_change = false;
    2888                 :          0 :                         xfer->delay_usecs = 0;
    2889                 :            :                 }
    2890                 :            :         }
    2891                 :            : 
    2892                 :            :         /* set up inserted */
    2893                 :          0 :         rxfer->inserted = insert;
    2894                 :            : 
    2895                 :            :         /* and register it with spi_res/spi_message */
    2896                 :          0 :         spi_res_add(msg, rxfer);
    2897                 :            : 
    2898                 :          0 :         return rxfer;
    2899                 :            : }
    2900                 :            : EXPORT_SYMBOL_GPL(spi_replace_transfers);
    2901                 :            : 
    2902                 :          0 : static int __spi_split_transfer_maxsize(struct spi_controller *ctlr,
    2903                 :            :                                         struct spi_message *msg,
    2904                 :            :                                         struct spi_transfer **xferp,
    2905                 :            :                                         size_t maxsize,
    2906                 :            :                                         gfp_t gfp)
    2907                 :            : {
    2908                 :          0 :         struct spi_transfer *xfer = *xferp, *xfers;
    2909                 :            :         struct spi_replaced_transfers *srt;
    2910                 :            :         size_t offset;
    2911                 :            :         size_t count, i;
    2912                 :            : 
    2913                 :            :         /* calculate how many we have to replace */
    2914                 :          0 :         count = DIV_ROUND_UP(xfer->len, maxsize);
    2915                 :            : 
    2916                 :            :         /* create replacement */
    2917                 :          0 :         srt = spi_replace_transfers(msg, xfer, 1, count, NULL, 0, gfp);
    2918                 :          0 :         if (IS_ERR(srt))
    2919                 :          0 :                 return PTR_ERR(srt);
    2920                 :          0 :         xfers = srt->inserted_transfers;
    2921                 :            : 
    2922                 :            :         /* now handle each of those newly inserted spi_transfers
    2923                 :            :          * note that the replacements spi_transfers all are preset
    2924                 :            :          * to the same values as *xferp, so tx_buf, rx_buf and len
    2925                 :            :          * are all identical (as well as most others)
    2926                 :            :          * so we just have to fix up len and the pointers.
    2927                 :            :          *
    2928                 :            :          * this also includes support for the depreciated
    2929                 :            :          * spi_message.is_dma_mapped interface
    2930                 :            :          */
    2931                 :            : 
    2932                 :            :         /* the first transfer just needs the length modified, so we
    2933                 :            :          * run it outside the loop
    2934                 :            :          */
    2935                 :          0 :         xfers[0].len = min_t(size_t, maxsize, xfer[0].len);
    2936                 :            : 
    2937                 :            :         /* all the others need rx_buf/tx_buf also set */
    2938                 :          0 :         for (i = 1, offset = maxsize; i < count; offset += maxsize, i++) {
    2939                 :            :                 /* update rx_buf, tx_buf and dma */
    2940                 :          0 :                 if (xfers[i].rx_buf)
    2941                 :          0 :                         xfers[i].rx_buf += offset;
    2942                 :          0 :                 if (xfers[i].rx_dma)
    2943                 :          0 :                         xfers[i].rx_dma += offset;
    2944                 :          0 :                 if (xfers[i].tx_buf)
    2945                 :          0 :                         xfers[i].tx_buf += offset;
    2946                 :          0 :                 if (xfers[i].tx_dma)
    2947                 :          0 :                         xfers[i].tx_dma += offset;
    2948                 :            : 
    2949                 :            :                 /* update length */
    2950                 :          0 :                 xfers[i].len = min(maxsize, xfers[i].len - offset);
    2951                 :            :         }
    2952                 :            : 
    2953                 :            :         /* we set up xferp to the last entry we have inserted,
    2954                 :            :          * so that we skip those already split transfers
    2955                 :            :          */
    2956                 :          0 :         *xferp = &xfers[count - 1];
    2957                 :            : 
    2958                 :            :         /* increment statistics counters */
    2959                 :          0 :         SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics,
    2960                 :            :                                        transfers_split_maxsize);
    2961                 :          0 :         SPI_STATISTICS_INCREMENT_FIELD(&msg->spi->statistics,
    2962                 :            :                                        transfers_split_maxsize);
    2963                 :            : 
    2964                 :          0 :         return 0;
    2965                 :            : }
    2966                 :            : 
    2967                 :            : /**
    2968                 :            :  * spi_split_tranfers_maxsize - split spi transfers into multiple transfers
    2969                 :            :  *                              when an individual transfer exceeds a
    2970                 :            :  *                              certain size
    2971                 :            :  * @ctlr:    the @spi_controller for this transfer
    2972                 :            :  * @msg:   the @spi_message to transform
    2973                 :            :  * @maxsize:  the maximum when to apply this
    2974                 :            :  * @gfp: GFP allocation flags
    2975                 :            :  *
    2976                 :            :  * Return: status of transformation
    2977                 :            :  */
    2978                 :          0 : int spi_split_transfers_maxsize(struct spi_controller *ctlr,
    2979                 :            :                                 struct spi_message *msg,
    2980                 :            :                                 size_t maxsize,
    2981                 :            :                                 gfp_t gfp)
    2982                 :            : {
    2983                 :            :         struct spi_transfer *xfer;
    2984                 :            :         int ret;
    2985                 :            : 
    2986                 :            :         /* iterate over the transfer_list,
    2987                 :            :          * but note that xfer is advanced to the last transfer inserted
    2988                 :            :          * to avoid checking sizes again unnecessarily (also xfer does
    2989                 :            :          * potentiall belong to a different list by the time the
    2990                 :            :          * replacement has happened
    2991                 :            :          */
    2992                 :          0 :         list_for_each_entry(xfer, &msg->transfers, transfer_list) {
    2993                 :          0 :                 if (xfer->len > maxsize) {
    2994                 :          0 :                         ret = __spi_split_transfer_maxsize(ctlr, msg, &xfer,
    2995                 :            :                                                            maxsize, gfp);
    2996                 :          0 :                         if (ret)
    2997                 :          0 :                                 return ret;
    2998                 :            :                 }
    2999                 :            :         }
    3000                 :            : 
    3001                 :            :         return 0;
    3002                 :            : }
    3003                 :            : EXPORT_SYMBOL_GPL(spi_split_transfers_maxsize);
    3004                 :            : 
    3005                 :            : /*-------------------------------------------------------------------------*/
    3006                 :            : 
    3007                 :            : /* Core methods for SPI controller protocol drivers.  Some of the
    3008                 :            :  * other core methods are currently defined as inline functions.
    3009                 :            :  */
    3010                 :            : 
    3011                 :            : static int __spi_validate_bits_per_word(struct spi_controller *ctlr,
    3012                 :            :                                         u8 bits_per_word)
    3013                 :            : {
    3014                 :          0 :         if (ctlr->bits_per_word_mask) {
    3015                 :            :                 /* Only 32 bits fit in the mask */
    3016                 :          0 :                 if (bits_per_word > 32)
    3017                 :            :                         return -EINVAL;
    3018                 :          0 :                 if (!(ctlr->bits_per_word_mask & SPI_BPW_MASK(bits_per_word)))
    3019                 :            :                         return -EINVAL;
    3020                 :            :         }
    3021                 :            : 
    3022                 :            :         return 0;
    3023                 :            : }
    3024                 :            : 
    3025                 :            : /**
    3026                 :            :  * spi_setup - setup SPI mode and clock rate
    3027                 :            :  * @spi: the device whose settings are being modified
    3028                 :            :  * Context: can sleep, and no requests are queued to the device
    3029                 :            :  *
    3030                 :            :  * SPI protocol drivers may need to update the transfer mode if the
    3031                 :            :  * device doesn't work with its default.  They may likewise need
    3032                 :            :  * to update clock rates or word sizes from initial values.  This function
    3033                 :            :  * changes those settings, and must be called from a context that can sleep.
    3034                 :            :  * Except for SPI_CS_HIGH, which takes effect immediately, the changes take
    3035                 :            :  * effect the next time the device is selected and data is transferred to
    3036                 :            :  * or from it.  When this function returns, the spi device is deselected.
    3037                 :            :  *
    3038                 :            :  * Note that this call will fail if the protocol driver specifies an option
    3039                 :            :  * that the underlying controller or its driver does not support.  For
    3040                 :            :  * example, not all hardware supports wire transfers using nine bit words,
    3041                 :            :  * LSB-first wire encoding, or active-high chipselects.
    3042                 :            :  *
    3043                 :            :  * Return: zero on success, else a negative error code.
    3044                 :            :  */
    3045                 :          0 : int spi_setup(struct spi_device *spi)
    3046                 :            : {
    3047                 :          0 :         struct spi_controller *ctlr = spi->controller;
    3048                 :            :         unsigned        bad_bits, ugly_bits;
    3049                 :            :         int             status;
    3050                 :            : 
    3051                 :            :         /* check mode to prevent that DUAL and QUAD set at the same time
    3052                 :            :          */
    3053                 :          0 :         if (((spi->mode & SPI_TX_DUAL) && (spi->mode & SPI_TX_QUAD)) ||
    3054                 :          0 :                 ((spi->mode & SPI_RX_DUAL) && (spi->mode & SPI_RX_QUAD))) {
    3055                 :          0 :                 dev_err(&spi->dev,
    3056                 :            :                 "setup: can not select dual and quad at the same time\n");
    3057                 :          0 :                 return -EINVAL;
    3058                 :            :         }
    3059                 :            :         /* if it is SPI_3WIRE mode, DUAL and QUAD should be forbidden
    3060                 :            :          */
    3061                 :          0 :         if ((spi->mode & SPI_3WIRE) && (spi->mode &
    3062                 :            :                 (SPI_TX_DUAL | SPI_TX_QUAD | SPI_TX_OCTAL |
    3063                 :            :                  SPI_RX_DUAL | SPI_RX_QUAD | SPI_RX_OCTAL)))
    3064                 :            :                 return -EINVAL;
    3065                 :            : 
    3066                 :          0 :         if (ctlr->use_gpio_descriptors && ctlr->cs_gpiods &&
    3067                 :          0 :             ctlr->cs_gpiods[spi->chip_select] && !(spi->mode & SPI_CS_HIGH)) {
    3068                 :            :                 dev_dbg(&spi->dev,
    3069                 :            :                         "setup: forcing CS_HIGH (use_gpio_descriptors)\n");
    3070                 :          0 :                 spi->mode |= SPI_CS_HIGH;
    3071                 :            :         }
    3072                 :            : 
    3073                 :            :         /* help drivers fail *cleanly* when they need options
    3074                 :            :          * that aren't supported with their current controller
    3075                 :            :          * SPI_CS_WORD has a fallback software implementation,
    3076                 :            :          * so it is ignored here.
    3077                 :            :          */
    3078                 :          0 :         bad_bits = spi->mode & ~(spi->controller->mode_bits | SPI_CS_WORD);
    3079                 :            :         /* nothing prevents from working with active-high CS in case if it
    3080                 :            :          * is driven by GPIO.
    3081                 :            :          */
    3082                 :          0 :         if (gpio_is_valid(spi->cs_gpio))
    3083                 :          0 :                 bad_bits &= ~SPI_CS_HIGH;
    3084                 :          0 :         ugly_bits = bad_bits &
    3085                 :            :                     (SPI_TX_DUAL | SPI_TX_QUAD | SPI_TX_OCTAL |
    3086                 :            :                      SPI_RX_DUAL | SPI_RX_QUAD | SPI_RX_OCTAL);
    3087                 :          0 :         if (ugly_bits) {
    3088                 :          0 :                 dev_warn(&spi->dev,
    3089                 :            :                          "setup: ignoring unsupported mode bits %x\n",
    3090                 :            :                          ugly_bits);
    3091                 :          0 :                 spi->mode &= ~ugly_bits;
    3092                 :          0 :                 bad_bits &= ~ugly_bits;
    3093                 :            :         }
    3094                 :          0 :         if (bad_bits) {
    3095                 :          0 :                 dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
    3096                 :            :                         bad_bits);
    3097                 :          0 :                 return -EINVAL;
    3098                 :            :         }
    3099                 :            : 
    3100                 :          0 :         if (!spi->bits_per_word)
    3101                 :          0 :                 spi->bits_per_word = 8;
    3102                 :            : 
    3103                 :          0 :         status = __spi_validate_bits_per_word(spi->controller,
    3104                 :            :                                               spi->bits_per_word);
    3105                 :          0 :         if (status)
    3106                 :            :                 return status;
    3107                 :            : 
    3108                 :          0 :         if (!spi->max_speed_hz)
    3109                 :          0 :                 spi->max_speed_hz = spi->controller->max_speed_hz;
    3110                 :            : 
    3111                 :          0 :         if (spi->controller->setup)
    3112                 :          0 :                 status = spi->controller->setup(spi);
    3113                 :            : 
    3114                 :          0 :         spi_set_cs(spi, false);
    3115                 :            : 
    3116                 :          0 :         if (spi->rt && !spi->controller->rt) {
    3117                 :          0 :                 spi->controller->rt = true;
    3118                 :          0 :                 spi_set_thread_rt(spi->controller);
    3119                 :            :         }
    3120                 :            : 
    3121                 :            :         dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s%u bits/w, %u Hz max --> %d\n",
    3122                 :            :                         (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
    3123                 :            :                         (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
    3124                 :            :                         (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
    3125                 :            :                         (spi->mode & SPI_3WIRE) ? "3wire, " : "",
    3126                 :            :                         (spi->mode & SPI_LOOP) ? "loopback, " : "",
    3127                 :            :                         spi->bits_per_word, spi->max_speed_hz,
    3128                 :            :                         status);
    3129                 :            : 
    3130                 :          0 :         return status;
    3131                 :            : }
    3132                 :            : EXPORT_SYMBOL_GPL(spi_setup);
    3133                 :            : 
    3134                 :            : /**
    3135                 :            :  * spi_set_cs_timing - configure CS setup, hold, and inactive delays
    3136                 :            :  * @spi: the device that requires specific CS timing configuration
    3137                 :            :  * @setup: CS setup time in terms of clock count
    3138                 :            :  * @hold: CS hold time in terms of clock count
    3139                 :            :  * @inactive_dly: CS inactive delay between transfers in terms of clock count
    3140                 :            :  */
    3141                 :          0 : void spi_set_cs_timing(struct spi_device *spi, u8 setup, u8 hold,
    3142                 :            :                        u8 inactive_dly)
    3143                 :            : {
    3144                 :          0 :         if (spi->controller->set_cs_timing)
    3145                 :          0 :                 spi->controller->set_cs_timing(spi, setup, hold, inactive_dly);
    3146                 :          0 : }
    3147                 :            : EXPORT_SYMBOL_GPL(spi_set_cs_timing);
    3148                 :            : 
    3149                 :          0 : static int __spi_validate(struct spi_device *spi, struct spi_message *message)
    3150                 :            : {
    3151                 :          0 :         struct spi_controller *ctlr = spi->controller;
    3152                 :            :         struct spi_transfer *xfer;
    3153                 :            :         int w_size;
    3154                 :            : 
    3155                 :          0 :         if (list_empty(&message->transfers))
    3156                 :            :                 return -EINVAL;
    3157                 :            : 
    3158                 :            :         /* If an SPI controller does not support toggling the CS line on each
    3159                 :            :          * transfer (indicated by the SPI_CS_WORD flag) or we are using a GPIO
    3160                 :            :          * for the CS line, we can emulate the CS-per-word hardware function by
    3161                 :            :          * splitting transfers into one-word transfers and ensuring that
    3162                 :            :          * cs_change is set for each transfer.
    3163                 :            :          */
    3164                 :          0 :         if ((spi->mode & SPI_CS_WORD) && (!(ctlr->mode_bits & SPI_CS_WORD) ||
    3165                 :          0 :                                           spi->cs_gpiod ||
    3166                 :          0 :                                           gpio_is_valid(spi->cs_gpio))) {
    3167                 :            :                 size_t maxsize;
    3168                 :            :                 int ret;
    3169                 :            : 
    3170                 :          0 :                 maxsize = (spi->bits_per_word + 7) / 8;
    3171                 :            : 
    3172                 :            :                 /* spi_split_transfers_maxsize() requires message->spi */
    3173                 :          0 :                 message->spi = spi;
    3174                 :            : 
    3175                 :          0 :                 ret = spi_split_transfers_maxsize(ctlr, message, maxsize,
    3176                 :            :                                                   GFP_KERNEL);
    3177                 :          0 :                 if (ret)
    3178                 :            :                         return ret;
    3179                 :            : 
    3180                 :          0 :                 list_for_each_entry(xfer, &message->transfers, transfer_list) {
    3181                 :            :                         /* don't change cs_change on the last entry in the list */
    3182                 :          0 :                         if (list_is_last(&xfer->transfer_list, &message->transfers))
    3183                 :            :                                 break;
    3184                 :          0 :                         xfer->cs_change = 1;
    3185                 :            :                 }
    3186                 :            :         }
    3187                 :            : 
    3188                 :            :         /* Half-duplex links include original MicroWire, and ones with
    3189                 :            :          * only one data pin like SPI_3WIRE (switches direction) or where
    3190                 :            :          * either MOSI or MISO is missing.  They can also be caused by
    3191                 :            :          * software limitations.
    3192                 :            :          */
    3193                 :          0 :         if ((ctlr->flags & SPI_CONTROLLER_HALF_DUPLEX) ||
    3194                 :          0 :             (spi->mode & SPI_3WIRE)) {
    3195                 :            :                 unsigned flags = ctlr->flags;
    3196                 :            : 
    3197                 :          0 :                 list_for_each_entry(xfer, &message->transfers, transfer_list) {
    3198                 :          0 :                         if (xfer->rx_buf && xfer->tx_buf)
    3199                 :            :                                 return -EINVAL;
    3200                 :          0 :                         if ((flags & SPI_CONTROLLER_NO_TX) && xfer->tx_buf)
    3201                 :            :                                 return -EINVAL;
    3202                 :          0 :                         if ((flags & SPI_CONTROLLER_NO_RX) && xfer->rx_buf)
    3203                 :            :                                 return -EINVAL;
    3204                 :            :                 }
    3205                 :            :         }
    3206                 :            : 
    3207                 :            :         /**
    3208                 :            :          * Set transfer bits_per_word and max speed as spi device default if
    3209                 :            :          * it is not set for this transfer.
    3210                 :            :          * Set transfer tx_nbits and rx_nbits as single transfer default
    3211                 :            :          * (SPI_NBITS_SINGLE) if it is not set for this transfer.
    3212                 :            :          * Ensure transfer word_delay is at least as long as that required by
    3213                 :            :          * device itself.
    3214                 :            :          */
    3215                 :          0 :         message->frame_length = 0;
    3216                 :          0 :         list_for_each_entry(xfer, &message->transfers, transfer_list) {
    3217                 :          0 :                 xfer->effective_speed_hz = 0;
    3218                 :          0 :                 message->frame_length += xfer->len;
    3219                 :          0 :                 if (!xfer->bits_per_word)
    3220                 :          0 :                         xfer->bits_per_word = spi->bits_per_word;
    3221                 :            : 
    3222                 :          0 :                 if (!xfer->speed_hz)
    3223                 :          0 :                         xfer->speed_hz = spi->max_speed_hz;
    3224                 :            : 
    3225                 :          0 :                 if (ctlr->max_speed_hz && xfer->speed_hz > ctlr->max_speed_hz)
    3226                 :          0 :                         xfer->speed_hz = ctlr->max_speed_hz;
    3227                 :            : 
    3228                 :          0 :                 if (__spi_validate_bits_per_word(ctlr, xfer->bits_per_word))
    3229                 :            :                         return -EINVAL;
    3230                 :            : 
    3231                 :            :                 /*
    3232                 :            :                  * SPI transfer length should be multiple of SPI word size
    3233                 :            :                  * where SPI word size should be power-of-two multiple
    3234                 :            :                  */
    3235                 :          0 :                 if (xfer->bits_per_word <= 8)
    3236                 :            :                         w_size = 1;
    3237                 :          0 :                 else if (xfer->bits_per_word <= 16)
    3238                 :            :                         w_size = 2;
    3239                 :            :                 else
    3240                 :            :                         w_size = 4;
    3241                 :            : 
    3242                 :            :                 /* No partial transfers accepted */
    3243                 :          0 :                 if (xfer->len % w_size)
    3244                 :            :                         return -EINVAL;
    3245                 :            : 
    3246                 :          0 :                 if (xfer->speed_hz && ctlr->min_speed_hz &&
    3247                 :            :                     xfer->speed_hz < ctlr->min_speed_hz)
    3248                 :            :                         return -EINVAL;
    3249                 :            : 
    3250                 :          0 :                 if (xfer->tx_buf && !xfer->tx_nbits)
    3251                 :          0 :                         xfer->tx_nbits = SPI_NBITS_SINGLE;
    3252                 :          0 :                 if (xfer->rx_buf && !xfer->rx_nbits)
    3253                 :          0 :                         xfer->rx_nbits = SPI_NBITS_SINGLE;
    3254                 :            :                 /* check transfer tx/rx_nbits:
    3255                 :            :                  * 1. check the value matches one of single, dual and quad
    3256                 :            :                  * 2. check tx/rx_nbits match the mode in spi_device
    3257                 :            :                  */
    3258                 :          0 :                 if (xfer->tx_buf) {
    3259                 :          0 :                         if (xfer->tx_nbits != SPI_NBITS_SINGLE &&
    3260                 :          0 :                                 xfer->tx_nbits != SPI_NBITS_DUAL &&
    3261                 :            :                                 xfer->tx_nbits != SPI_NBITS_QUAD)
    3262                 :            :                                 return -EINVAL;
    3263                 :          0 :                         if ((xfer->tx_nbits == SPI_NBITS_DUAL) &&
    3264                 :          0 :                                 !(spi->mode & (SPI_TX_DUAL | SPI_TX_QUAD)))
    3265                 :            :                                 return -EINVAL;
    3266                 :          0 :                         if ((xfer->tx_nbits == SPI_NBITS_QUAD) &&
    3267                 :          0 :                                 !(spi->mode & SPI_TX_QUAD))
    3268                 :            :                                 return -EINVAL;
    3269                 :            :                 }
    3270                 :            :                 /* check transfer rx_nbits */
    3271                 :          0 :                 if (xfer->rx_buf) {
    3272                 :          0 :                         if (xfer->rx_nbits != SPI_NBITS_SINGLE &&
    3273                 :          0 :                                 xfer->rx_nbits != SPI_NBITS_DUAL &&
    3274                 :            :                                 xfer->rx_nbits != SPI_NBITS_QUAD)
    3275                 :            :                                 return -EINVAL;
    3276                 :          0 :                         if ((xfer->rx_nbits == SPI_NBITS_DUAL) &&
    3277                 :          0 :                                 !(spi->mode & (SPI_RX_DUAL | SPI_RX_QUAD)))
    3278                 :            :                                 return -EINVAL;
    3279                 :          0 :                         if ((xfer->rx_nbits == SPI_NBITS_QUAD) &&
    3280                 :          0 :                                 !(spi->mode & SPI_RX_QUAD))
    3281                 :            :                                 return -EINVAL;
    3282                 :            :                 }
    3283                 :            : 
    3284                 :          0 :                 if (xfer->word_delay_usecs < spi->word_delay_usecs)
    3285                 :          0 :                         xfer->word_delay_usecs = spi->word_delay_usecs;
    3286                 :            :         }
    3287                 :            : 
    3288                 :          0 :         message->status = -EINPROGRESS;
    3289                 :            : 
    3290                 :          0 :         return 0;
    3291                 :            : }
    3292                 :            : 
    3293                 :          0 : static int __spi_async(struct spi_device *spi, struct spi_message *message)
    3294                 :            : {
    3295                 :          0 :         struct spi_controller *ctlr = spi->controller;
    3296                 :            : 
    3297                 :            :         /*
    3298                 :            :          * Some controllers do not support doing regular SPI transfers. Return
    3299                 :            :          * ENOTSUPP when this is the case.
    3300                 :            :          */
    3301                 :          0 :         if (!ctlr->transfer)
    3302                 :            :                 return -ENOTSUPP;
    3303                 :            : 
    3304                 :          0 :         message->spi = spi;
    3305                 :            : 
    3306                 :          0 :         SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics, spi_async);
    3307                 :          0 :         SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_async);
    3308                 :            : 
    3309                 :          0 :         trace_spi_message_submit(message);
    3310                 :            : 
    3311                 :          0 :         return ctlr->transfer(spi, message);
    3312                 :            : }
    3313                 :            : 
    3314                 :            : /**
    3315                 :            :  * spi_async - asynchronous SPI transfer
    3316                 :            :  * @spi: device with which data will be exchanged
    3317                 :            :  * @message: describes the data transfers, including completion callback
    3318                 :            :  * Context: any (irqs may be blocked, etc)
    3319                 :            :  *
    3320                 :            :  * This call may be used in_irq and other contexts which can't sleep,
    3321                 :            :  * as well as from task contexts which can sleep.
    3322                 :            :  *
    3323                 :            :  * The completion callback is invoked in a context which can't sleep.
    3324                 :            :  * Before that invocation, the value of message->status is undefined.
    3325                 :            :  * When the callback is issued, message->status holds either zero (to
    3326                 :            :  * indicate complete success) or a negative error code.  After that
    3327                 :            :  * callback returns, the driver which issued the transfer request may
    3328                 :            :  * deallocate the associated memory; it's no longer in use by any SPI
    3329                 :            :  * core or controller driver code.
    3330                 :            :  *
    3331                 :            :  * Note that although all messages to a spi_device are handled in
    3332                 :            :  * FIFO order, messages may go to different devices in other orders.
    3333                 :            :  * Some device might be higher priority, or have various "hard" access
    3334                 :            :  * time requirements, for example.
    3335                 :            :  *
    3336                 :            :  * On detection of any fault during the transfer, processing of
    3337                 :            :  * the entire message is aborted, and the device is deselected.
    3338                 :            :  * Until returning from the associated message completion callback,
    3339                 :            :  * no other spi_message queued to that device will be processed.
    3340                 :            :  * (This rule applies equally to all the synchronous transfer calls,
    3341                 :            :  * which are wrappers around this core asynchronous primitive.)
    3342                 :            :  *
    3343                 :            :  * Return: zero on success, else a negative error code.
    3344                 :            :  */
    3345                 :          0 : int spi_async(struct spi_device *spi, struct spi_message *message)
    3346                 :            : {
    3347                 :          0 :         struct spi_controller *ctlr = spi->controller;
    3348                 :            :         int ret;
    3349                 :            :         unsigned long flags;
    3350                 :            : 
    3351                 :          0 :         ret = __spi_validate(spi, message);
    3352                 :          0 :         if (ret != 0)
    3353                 :            :                 return ret;
    3354                 :            : 
    3355                 :          0 :         spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);
    3356                 :            : 
    3357                 :          0 :         if (ctlr->bus_lock_flag)
    3358                 :            :                 ret = -EBUSY;
    3359                 :            :         else
    3360                 :          0 :                 ret = __spi_async(spi, message);
    3361                 :            : 
    3362                 :            :         spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
    3363                 :            : 
    3364                 :          0 :         return ret;
    3365                 :            : }
    3366                 :            : EXPORT_SYMBOL_GPL(spi_async);
    3367                 :            : 
    3368                 :            : /**
    3369                 :            :  * spi_async_locked - version of spi_async with exclusive bus usage
    3370                 :            :  * @spi: device with which data will be exchanged
    3371                 :            :  * @message: describes the data transfers, including completion callback
    3372                 :            :  * Context: any (irqs may be blocked, etc)
    3373                 :            :  *
    3374                 :            :  * This call may be used in_irq and other contexts which can't sleep,
    3375                 :            :  * as well as from task contexts which can sleep.
    3376                 :            :  *
    3377                 :            :  * The completion callback is invoked in a context which can't sleep.
    3378                 :            :  * Before that invocation, the value of message->status is undefined.
    3379                 :            :  * When the callback is issued, message->status holds either zero (to
    3380                 :            :  * indicate complete success) or a negative error code.  After that
    3381                 :            :  * callback returns, the driver which issued the transfer request may
    3382                 :            :  * deallocate the associated memory; it's no longer in use by any SPI
    3383                 :            :  * core or controller driver code.
    3384                 :            :  *
    3385                 :            :  * Note that although all messages to a spi_device are handled in
    3386                 :            :  * FIFO order, messages may go to different devices in other orders.
    3387                 :            :  * Some device might be higher priority, or have various "hard" access
    3388                 :            :  * time requirements, for example.
    3389                 :            :  *
    3390                 :            :  * On detection of any fault during the transfer, processing of
    3391                 :            :  * the entire message is aborted, and the device is deselected.
    3392                 :            :  * Until returning from the associated message completion callback,
    3393                 :            :  * no other spi_message queued to that device will be processed.
    3394                 :            :  * (This rule applies equally to all the synchronous transfer calls,
    3395                 :            :  * which are wrappers around this core asynchronous primitive.)
    3396                 :            :  *
    3397                 :            :  * Return: zero on success, else a negative error code.
    3398                 :            :  */
    3399                 :          0 : int spi_async_locked(struct spi_device *spi, struct spi_message *message)
    3400                 :            : {
    3401                 :          0 :         struct spi_controller *ctlr = spi->controller;
    3402                 :            :         int ret;
    3403                 :            :         unsigned long flags;
    3404                 :            : 
    3405                 :          0 :         ret = __spi_validate(spi, message);
    3406                 :          0 :         if (ret != 0)
    3407                 :            :                 return ret;
    3408                 :            : 
    3409                 :          0 :         spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);
    3410                 :            : 
    3411                 :          0 :         ret = __spi_async(spi, message);
    3412                 :            : 
    3413                 :            :         spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
    3414                 :            : 
    3415                 :          0 :         return ret;
    3416                 :            : 
    3417                 :            : }
    3418                 :            : EXPORT_SYMBOL_GPL(spi_async_locked);
    3419                 :            : 
    3420                 :            : /*-------------------------------------------------------------------------*/
    3421                 :            : 
    3422                 :            : /* Utility methods for SPI protocol drivers, layered on
    3423                 :            :  * top of the core.  Some other utility methods are defined as
    3424                 :            :  * inline functions.
    3425                 :            :  */
    3426                 :            : 
    3427                 :          0 : static void spi_complete(void *arg)
    3428                 :            : {
    3429                 :          0 :         complete(arg);
    3430                 :          0 : }
    3431                 :            : 
    3432                 :          0 : static int __spi_sync(struct spi_device *spi, struct spi_message *message)
    3433                 :            : {
    3434                 :          0 :         DECLARE_COMPLETION_ONSTACK(done);
    3435                 :            :         int status;
    3436                 :          0 :         struct spi_controller *ctlr = spi->controller;
    3437                 :            :         unsigned long flags;
    3438                 :            : 
    3439                 :          0 :         status = __spi_validate(spi, message);
    3440                 :          0 :         if (status != 0)
    3441                 :            :                 return status;
    3442                 :            : 
    3443                 :          0 :         message->complete = spi_complete;
    3444                 :          0 :         message->context = &done;
    3445                 :          0 :         message->spi = spi;
    3446                 :            : 
    3447                 :          0 :         SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics, spi_sync);
    3448                 :          0 :         SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_sync);
    3449                 :            : 
    3450                 :            :         /* If we're not using the legacy transfer method then we will
    3451                 :            :          * try to transfer in the calling context so special case.
    3452                 :            :          * This code would be less tricky if we could remove the
    3453                 :            :          * support for driver implemented message queues.
    3454                 :            :          */
    3455                 :          0 :         if (ctlr->transfer == spi_queued_transfer) {
    3456                 :          0 :                 spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);
    3457                 :            : 
    3458                 :          0 :                 trace_spi_message_submit(message);
    3459                 :            : 
    3460                 :          0 :                 status = __spi_queued_transfer(spi, message, false);
    3461                 :            : 
    3462                 :            :                 spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
    3463                 :            :         } else {
    3464                 :          0 :                 status = spi_async_locked(spi, message);
    3465                 :            :         }
    3466                 :            : 
    3467                 :          0 :         if (status == 0) {
    3468                 :            :                 /* Push out the messages in the calling context if we
    3469                 :            :                  * can.
    3470                 :            :                  */
    3471                 :          0 :                 if (ctlr->transfer == spi_queued_transfer) {
    3472                 :          0 :                         SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics,
    3473                 :            :                                                        spi_sync_immediate);
    3474                 :          0 :                         SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics,
    3475                 :            :                                                        spi_sync_immediate);
    3476                 :          0 :                         __spi_pump_messages(ctlr, false);
    3477                 :            :                 }
    3478                 :            : 
    3479                 :          0 :                 wait_for_completion(&done);
    3480                 :          0 :                 status = message->status;
    3481                 :            :         }
    3482                 :          0 :         message->context = NULL;
    3483                 :          0 :         return status;
    3484                 :            : }
    3485                 :            : 
    3486                 :            : /**
    3487                 :            :  * spi_sync - blocking/synchronous SPI data transfers
    3488                 :            :  * @spi: device with which data will be exchanged
    3489                 :            :  * @message: describes the data transfers
    3490                 :            :  * Context: can sleep
    3491                 :            :  *
    3492                 :            :  * This call may only be used from a context that may sleep.  The sleep
    3493                 :            :  * is non-interruptible, and has no timeout.  Low-overhead controller
    3494                 :            :  * drivers may DMA directly into and out of the message buffers.
    3495                 :            :  *
    3496                 :            :  * Note that the SPI device's chip select is active during the message,
    3497                 :            :  * and then is normally disabled between messages.  Drivers for some
    3498                 :            :  * frequently-used devices may want to minimize costs of selecting a chip,
    3499                 :            :  * by leaving it selected in anticipation that the next message will go
    3500                 :            :  * to the same chip.  (That may increase power usage.)
    3501                 :            :  *
    3502                 :            :  * Also, the caller is guaranteeing that the memory associated with the
    3503                 :            :  * message will not be freed before this call returns.
    3504                 :            :  *
    3505                 :            :  * Return: zero on success, else a negative error code.
    3506                 :            :  */
    3507                 :          0 : int spi_sync(struct spi_device *spi, struct spi_message *message)
    3508                 :            : {
    3509                 :            :         int ret;
    3510                 :            : 
    3511                 :          0 :         mutex_lock(&spi->controller->bus_lock_mutex);
    3512                 :          0 :         ret = __spi_sync(spi, message);
    3513                 :          0 :         mutex_unlock(&spi->controller->bus_lock_mutex);
    3514                 :            : 
    3515                 :          0 :         return ret;
    3516                 :            : }
    3517                 :            : EXPORT_SYMBOL_GPL(spi_sync);
    3518                 :            : 
    3519                 :            : /**
    3520                 :            :  * spi_sync_locked - version of spi_sync with exclusive bus usage
    3521                 :            :  * @spi: device with which data will be exchanged
    3522                 :            :  * @message: describes the data transfers
    3523                 :            :  * Context: can sleep
    3524                 :            :  *
    3525                 :            :  * This call may only be used from a context that may sleep.  The sleep
    3526                 :            :  * is non-interruptible, and has no timeout.  Low-overhead controller
    3527                 :            :  * drivers may DMA directly into and out of the message buffers.
    3528                 :            :  *
    3529                 :            :  * This call should be used by drivers that require exclusive access to the
    3530                 :            :  * SPI bus. It has to be preceded by a spi_bus_lock call. The SPI bus must
    3531                 :            :  * be released by a spi_bus_unlock call when the exclusive access is over.
    3532                 :            :  *
    3533                 :            :  * Return: zero on success, else a negative error code.
    3534                 :            :  */
    3535                 :          0 : int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
    3536                 :            : {
    3537                 :          0 :         return __spi_sync(spi, message);
    3538                 :            : }
    3539                 :            : EXPORT_SYMBOL_GPL(spi_sync_locked);
    3540                 :            : 
    3541                 :            : /**
    3542                 :            :  * spi_bus_lock - obtain a lock for exclusive SPI bus usage
    3543                 :            :  * @ctlr: SPI bus master that should be locked for exclusive bus access
    3544                 :            :  * Context: can sleep
    3545                 :            :  *
    3546                 :            :  * This call may only be used from a context that may sleep.  The sleep
    3547                 :            :  * is non-interruptible, and has no timeout.
    3548                 :            :  *
    3549                 :            :  * This call should be used by drivers that require exclusive access to the
    3550                 :            :  * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the
    3551                 :            :  * exclusive access is over. Data transfer must be done by spi_sync_locked
    3552                 :            :  * and spi_async_locked calls when the SPI bus lock is held.
    3553                 :            :  *
    3554                 :            :  * Return: always zero.
    3555                 :            :  */
    3556                 :          0 : int spi_bus_lock(struct spi_controller *ctlr)
    3557                 :            : {
    3558                 :            :         unsigned long flags;
    3559                 :            : 
    3560                 :          0 :         mutex_lock(&ctlr->bus_lock_mutex);
    3561                 :            : 
    3562                 :          0 :         spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);
    3563                 :          0 :         ctlr->bus_lock_flag = 1;
    3564                 :            :         spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
    3565                 :            : 
    3566                 :            :         /* mutex remains locked until spi_bus_unlock is called */
    3567                 :            : 
    3568                 :          0 :         return 0;
    3569                 :            : }
    3570                 :            : EXPORT_SYMBOL_GPL(spi_bus_lock);
    3571                 :            : 
    3572                 :            : /**
    3573                 :            :  * spi_bus_unlock - release the lock for exclusive SPI bus usage
    3574                 :            :  * @ctlr: SPI bus master that was locked for exclusive bus access
    3575                 :            :  * Context: can sleep
    3576                 :            :  *
    3577                 :            :  * This call may only be used from a context that may sleep.  The sleep
    3578                 :            :  * is non-interruptible, and has no timeout.
    3579                 :            :  *
    3580                 :            :  * This call releases an SPI bus lock previously obtained by an spi_bus_lock
    3581                 :            :  * call.
    3582                 :            :  *
    3583                 :            :  * Return: always zero.
    3584                 :            :  */
    3585                 :          0 : int spi_bus_unlock(struct spi_controller *ctlr)
    3586                 :            : {
    3587                 :          0 :         ctlr->bus_lock_flag = 0;
    3588                 :            : 
    3589                 :          0 :         mutex_unlock(&ctlr->bus_lock_mutex);
    3590                 :            : 
    3591                 :          0 :         return 0;
    3592                 :            : }
    3593                 :            : EXPORT_SYMBOL_GPL(spi_bus_unlock);
    3594                 :            : 
    3595                 :            : /* portable code must never pass more than 32 bytes */
    3596                 :            : #define SPI_BUFSIZ      max(32, SMP_CACHE_BYTES)
    3597                 :            : 
    3598                 :            : static u8       *buf;
    3599                 :            : 
    3600                 :            : /**
    3601                 :            :  * spi_write_then_read - SPI synchronous write followed by read
    3602                 :            :  * @spi: device with which data will be exchanged
    3603                 :            :  * @txbuf: data to be written (need not be dma-safe)
    3604                 :            :  * @n_tx: size of txbuf, in bytes
    3605                 :            :  * @rxbuf: buffer into which data will be read (need not be dma-safe)
    3606                 :            :  * @n_rx: size of rxbuf, in bytes
    3607                 :            :  * Context: can sleep
    3608                 :            :  *
    3609                 :            :  * This performs a half duplex MicroWire style transaction with the
    3610                 :            :  * device, sending txbuf and then reading rxbuf.  The return value
    3611                 :            :  * is zero for success, else a negative errno status code.
    3612                 :            :  * This call may only be used from a context that may sleep.
    3613                 :            :  *
    3614                 :            :  * Parameters to this routine are always copied using a small buffer;
    3615                 :            :  * portable code should never use this for more than 32 bytes.
    3616                 :            :  * Performance-sensitive or bulk transfer code should instead use
    3617                 :            :  * spi_{async,sync}() calls with dma-safe buffers.
    3618                 :            :  *
    3619                 :            :  * Return: zero on success, else a negative error code.
    3620                 :            :  */
    3621                 :          0 : int spi_write_then_read(struct spi_device *spi,
    3622                 :            :                 const void *txbuf, unsigned n_tx,
    3623                 :            :                 void *rxbuf, unsigned n_rx)
    3624                 :            : {
    3625                 :            :         static DEFINE_MUTEX(lock);
    3626                 :            : 
    3627                 :            :         int                     status;
    3628                 :            :         struct spi_message      message;
    3629                 :            :         struct spi_transfer     x[2];
    3630                 :            :         u8                      *local_buf;
    3631                 :            : 
    3632                 :            :         /* Use preallocated DMA-safe buffer if we can.  We can't avoid
    3633                 :            :          * copying here, (as a pure convenience thing), but we can
    3634                 :            :          * keep heap costs out of the hot path unless someone else is
    3635                 :            :          * using the pre-allocated buffer or the transfer is too large.
    3636                 :            :          */
    3637                 :          0 :         if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) {
    3638                 :          0 :                 local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx),
    3639                 :            :                                     GFP_KERNEL | GFP_DMA);
    3640                 :          0 :                 if (!local_buf)
    3641                 :            :                         return -ENOMEM;
    3642                 :            :         } else {
    3643                 :          0 :                 local_buf = buf;
    3644                 :            :         }
    3645                 :            : 
    3646                 :            :         spi_message_init(&message);
    3647                 :          0 :         memset(x, 0, sizeof(x));
    3648                 :          0 :         if (n_tx) {
    3649                 :          0 :                 x[0].len = n_tx;
    3650                 :            :                 spi_message_add_tail(&x[0], &message);
    3651                 :            :         }
    3652                 :          0 :         if (n_rx) {
    3653                 :          0 :                 x[1].len = n_rx;
    3654                 :            :                 spi_message_add_tail(&x[1], &message);
    3655                 :            :         }
    3656                 :            : 
    3657                 :          0 :         memcpy(local_buf, txbuf, n_tx);
    3658                 :          0 :         x[0].tx_buf = local_buf;
    3659                 :          0 :         x[1].rx_buf = local_buf + n_tx;
    3660                 :            : 
    3661                 :            :         /* do the i/o */
    3662                 :          0 :         status = spi_sync(spi, &message);
    3663                 :          0 :         if (status == 0)
    3664                 :          0 :                 memcpy(rxbuf, x[1].rx_buf, n_rx);
    3665                 :            : 
    3666                 :          0 :         if (x[0].tx_buf == buf)
    3667                 :          0 :                 mutex_unlock(&lock);
    3668                 :            :         else
    3669                 :          0 :                 kfree(local_buf);
    3670                 :            : 
    3671                 :          0 :         return status;
    3672                 :            : }
    3673                 :            : EXPORT_SYMBOL_GPL(spi_write_then_read);
    3674                 :            : 
    3675                 :            : /*-------------------------------------------------------------------------*/
    3676                 :            : 
    3677                 :            : #if IS_ENABLED(CONFIG_OF)
    3678                 :            : /* must call put_device() when done with returned spi_device device */
    3679                 :          0 : struct spi_device *of_find_spi_device_by_node(struct device_node *node)
    3680                 :            : {
    3681                 :            :         struct device *dev = bus_find_device_by_of_node(&spi_bus_type, node);
    3682                 :            : 
    3683                 :          0 :         return dev ? to_spi_device(dev) : NULL;
    3684                 :            : }
    3685                 :            : EXPORT_SYMBOL_GPL(of_find_spi_device_by_node);
    3686                 :            : #endif /* IS_ENABLED(CONFIG_OF) */
    3687                 :            : 
    3688                 :            : #if IS_ENABLED(CONFIG_OF_DYNAMIC)
    3689                 :            : /* the spi controllers are not using spi_bus, so we find it with another way */
    3690                 :          0 : static struct spi_controller *of_find_spi_controller_by_node(struct device_node *node)
    3691                 :            : {
    3692                 :            :         struct device *dev;
    3693                 :            : 
    3694                 :            :         dev = class_find_device_by_of_node(&spi_master_class, node);
    3695                 :          0 :         if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE))
    3696                 :            :                 dev = class_find_device_by_of_node(&spi_slave_class, node);
    3697                 :          0 :         if (!dev)
    3698                 :            :                 return NULL;
    3699                 :            : 
    3700                 :            :         /* reference got in class_find_device */
    3701                 :          0 :         return container_of(dev, struct spi_controller, dev);
    3702                 :            : }
    3703                 :            : 
    3704                 :          0 : static int of_spi_notify(struct notifier_block *nb, unsigned long action,
    3705                 :            :                          void *arg)
    3706                 :            : {
    3707                 :            :         struct of_reconfig_data *rd = arg;
    3708                 :            :         struct spi_controller *ctlr;
    3709                 :            :         struct spi_device *spi;
    3710                 :            : 
    3711                 :          0 :         switch (of_reconfig_get_state_change(action, arg)) {
    3712                 :            :         case OF_RECONFIG_CHANGE_ADD:
    3713                 :          0 :                 ctlr = of_find_spi_controller_by_node(rd->dn->parent);
    3714                 :          0 :                 if (ctlr == NULL)
    3715                 :            :                         return NOTIFY_OK;       /* not for us */
    3716                 :            : 
    3717                 :          0 :                 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
    3718                 :          0 :                         put_device(&ctlr->dev);
    3719                 :          0 :                         return NOTIFY_OK;
    3720                 :            :                 }
    3721                 :            : 
    3722                 :          0 :                 spi = of_register_spi_device(ctlr, rd->dn);
    3723                 :          0 :                 put_device(&ctlr->dev);
    3724                 :            : 
    3725                 :          0 :                 if (IS_ERR(spi)) {
    3726                 :          0 :                         pr_err("%s: failed to create for '%pOF'\n",
    3727                 :            :                                         __func__, rd->dn);
    3728                 :          0 :                         of_node_clear_flag(rd->dn, OF_POPULATED);
    3729                 :          0 :                         return notifier_from_errno(PTR_ERR(spi));
    3730                 :            :                 }
    3731                 :            :                 break;
    3732                 :            : 
    3733                 :            :         case OF_RECONFIG_CHANGE_REMOVE:
    3734                 :            :                 /* already depopulated? */
    3735                 :          0 :                 if (!of_node_check_flag(rd->dn, OF_POPULATED))
    3736                 :            :                         return NOTIFY_OK;
    3737                 :            : 
    3738                 :            :                 /* find our device by node */
    3739                 :          0 :                 spi = of_find_spi_device_by_node(rd->dn);
    3740                 :          0 :                 if (spi == NULL)
    3741                 :            :                         return NOTIFY_OK;       /* no? not meant for us */
    3742                 :            : 
    3743                 :            :                 /* unregister takes one ref away */
    3744                 :          0 :                 spi_unregister_device(spi);
    3745                 :            : 
    3746                 :            :                 /* and put the reference of the find */
    3747                 :          0 :                 put_device(&spi->dev);
    3748                 :          0 :                 break;
    3749                 :            :         }
    3750                 :            : 
    3751                 :            :         return NOTIFY_OK;
    3752                 :            : }
    3753                 :            : 
    3754                 :            : static struct notifier_block spi_of_notifier = {
    3755                 :            :         .notifier_call = of_spi_notify,
    3756                 :            : };
    3757                 :            : #else /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
    3758                 :            : extern struct notifier_block spi_of_notifier;
    3759                 :            : #endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
    3760                 :            : 
    3761                 :            : #if IS_ENABLED(CONFIG_ACPI)
    3762                 :            : static int spi_acpi_controller_match(struct device *dev, const void *data)
    3763                 :            : {
    3764                 :            :         return ACPI_COMPANION(dev->parent) == data;
    3765                 :            : }
    3766                 :            : 
    3767                 :            : static struct spi_controller *acpi_spi_find_controller_by_adev(struct acpi_device *adev)
    3768                 :            : {
    3769                 :            :         struct device *dev;
    3770                 :            : 
    3771                 :            :         dev = class_find_device(&spi_master_class, NULL, adev,
    3772                 :            :                                 spi_acpi_controller_match);
    3773                 :            :         if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE))
    3774                 :            :                 dev = class_find_device(&spi_slave_class, NULL, adev,
    3775                 :            :                                         spi_acpi_controller_match);
    3776                 :            :         if (!dev)
    3777                 :            :                 return NULL;
    3778                 :            : 
    3779                 :            :         return container_of(dev, struct spi_controller, dev);
    3780                 :            : }
    3781                 :            : 
    3782                 :            : static struct spi_device *acpi_spi_find_device_by_adev(struct acpi_device *adev)
    3783                 :            : {
    3784                 :            :         struct device *dev;
    3785                 :            : 
    3786                 :            :         dev = bus_find_device_by_acpi_dev(&spi_bus_type, adev);
    3787                 :            :         return dev ? to_spi_device(dev) : NULL;
    3788                 :            : }
    3789                 :            : 
    3790                 :            : static int acpi_spi_notify(struct notifier_block *nb, unsigned long value,
    3791                 :            :                            void *arg)
    3792                 :            : {
    3793                 :            :         struct acpi_device *adev = arg;
    3794                 :            :         struct spi_controller *ctlr;
    3795                 :            :         struct spi_device *spi;
    3796                 :            : 
    3797                 :            :         switch (value) {
    3798                 :            :         case ACPI_RECONFIG_DEVICE_ADD:
    3799                 :            :                 ctlr = acpi_spi_find_controller_by_adev(adev->parent);
    3800                 :            :                 if (!ctlr)
    3801                 :            :                         break;
    3802                 :            : 
    3803                 :            :                 acpi_register_spi_device(ctlr, adev);
    3804                 :            :                 put_device(&ctlr->dev);
    3805                 :            :                 break;
    3806                 :            :         case ACPI_RECONFIG_DEVICE_REMOVE:
    3807                 :            :                 if (!acpi_device_enumerated(adev))
    3808                 :            :                         break;
    3809                 :            : 
    3810                 :            :                 spi = acpi_spi_find_device_by_adev(adev);
    3811                 :            :                 if (!spi)
    3812                 :            :                         break;
    3813                 :            : 
    3814                 :            :                 spi_unregister_device(spi);
    3815                 :            :                 put_device(&spi->dev);
    3816                 :            :                 break;
    3817                 :            :         }
    3818                 :            : 
    3819                 :            :         return NOTIFY_OK;
    3820                 :            : }
    3821                 :            : 
    3822                 :            : static struct notifier_block spi_acpi_notifier = {
    3823                 :            :         .notifier_call = acpi_spi_notify,
    3824                 :            : };
    3825                 :            : #else
    3826                 :            : extern struct notifier_block spi_acpi_notifier;
    3827                 :            : #endif
    3828                 :            : 
    3829                 :          3 : static int __init spi_init(void)
    3830                 :            : {
    3831                 :            :         int     status;
    3832                 :            : 
    3833                 :          3 :         buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
    3834                 :          3 :         if (!buf) {
    3835                 :            :                 status = -ENOMEM;
    3836                 :            :                 goto err0;
    3837                 :            :         }
    3838                 :            : 
    3839                 :          3 :         status = bus_register(&spi_bus_type);
    3840                 :          3 :         if (status < 0)
    3841                 :            :                 goto err1;
    3842                 :            : 
    3843                 :          3 :         status = class_register(&spi_master_class);
    3844                 :          3 :         if (status < 0)
    3845                 :            :                 goto err2;
    3846                 :            : 
    3847                 :            :         if (IS_ENABLED(CONFIG_SPI_SLAVE)) {
    3848                 :          3 :                 status = class_register(&spi_slave_class);
    3849                 :          3 :                 if (status < 0)
    3850                 :            :                         goto err3;
    3851                 :            :         }
    3852                 :            : 
    3853                 :            :         if (IS_ENABLED(CONFIG_OF_DYNAMIC))
    3854                 :          3 :                 WARN_ON(of_reconfig_notifier_register(&spi_of_notifier));
    3855                 :            :         if (IS_ENABLED(CONFIG_ACPI))
    3856                 :            :                 WARN_ON(acpi_reconfig_notifier_register(&spi_acpi_notifier));
    3857                 :            : 
    3858                 :            :         return 0;
    3859                 :            : 
    3860                 :            : err3:
    3861                 :          0 :         class_unregister(&spi_master_class);
    3862                 :            : err2:
    3863                 :          0 :         bus_unregister(&spi_bus_type);
    3864                 :            : err1:
    3865                 :          0 :         kfree(buf);
    3866                 :          0 :         buf = NULL;
    3867                 :            : err0:
    3868                 :          0 :         return status;
    3869                 :            : }
    3870                 :            : 
    3871                 :            : /* board_info is normally registered in arch_initcall(),
    3872                 :            :  * but even essential drivers wait till later
    3873                 :            :  *
    3874                 :            :  * REVISIT only boardinfo really needs static linking. the rest (device and
    3875                 :            :  * driver registration) _could_ be dynamically linked (modular) ... costs
    3876                 :            :  * include needing to have boardinfo data structures be much more public.
    3877                 :            :  */
    3878                 :            : postcore_initcall(spi_init);
    

Generated by: LCOV version 1.14