drivers/w1/masters/w1-uart.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * w1-uart - UART 1-Wire bus driver
   4  *
   5  * Uses the UART interface (via Serial Device Bus) to create the 1-Wire
   6  * timing patterns. Implements the following 1-Wire master interface:
   7  *
   8  * - reset_bus: requests baud-rate 9600
   9  *
  10  * - touch_bit: requests baud-rate 115200
  11  *
  12  * Author: Christoph Winklhofer <cj.winklhofer@gmail.com>
  13  */
  14
  15 #include <linux/completion.h>
  16 #include <linux/delay.h>
  17 #include <linux/jiffies.h>
  18 #include <linux/module.h>
  19 #include <linux/mutex.h>
  20 #include <linux/of.h>
  21 #include <linux/serdev.h>
  22 #include <linux/w1.h>
  23
  24 /* UART packet contains start and stop bit */
  25 #define W1_UART_BITS_PER_PACKET (BITS_PER_BYTE + 2)
  26
  27 /* Timeout to wait for completion of serdev-receive */
  28 #define W1_UART_TIMEOUT msecs_to_jiffies(500)
  29
  30 /**
  31  * struct w1_uart_config - configuration for 1-Wire operation
  32  * @baudrate: baud-rate returned from serdev
  33  * @delay_us: delay to complete a 1-Wire cycle (in us)
  34  * @tx_byte: byte to generate 1-Wire timing pattern
  35  */
  36 struct w1_uart_config {
  37         unsigned int baudrate;
  38         unsigned int delay_us;
  39         u8 tx_byte;
  40 };
  41
  42 /**
  43  * struct w1_uart_device - 1-Wire UART device structure
  44  * @serdev: serial device
  45  * @bus: w1-bus master
  46  * @cfg_reset: config for 1-Wire reset
  47  * @cfg_touch_0: config for 1-Wire write-0 cycle
  48  * @cfg_touch_1: config for 1-Wire write-1 and read cycle
  49  * @rx_byte_received: completion for serdev receive
  50  * @rx_mutex: mutex to protect rx_err and rx_byte
  51  * @rx_err: indicates an error in serdev-receive
  52  * @rx_byte: result byte from serdev-receive
  53  */
  54 struct w1_uart_device {
  55         struct serdev_device *serdev;
  56         struct w1_bus_master bus;
  57
  58         struct w1_uart_config cfg_reset;
  59         struct w1_uart_config cfg_touch_0;
  60         struct w1_uart_config cfg_touch_1;
  61
  62         struct completion rx_byte_received;
  63         /*
  64          * protect rx_err and rx_byte from concurrent access in
  65          * w1-callbacks and serdev-receive.
  66          */
  67         struct mutex rx_mutex;
  68         int rx_err;
  69         u8 rx_byte;
  70 };
  71
  72 /**
  73  * struct w1_uart_limits - limits for 1-Wire operations
  74  * @baudrate: Requested baud-rate to create 1-Wire timing pattern
  75  * @bit_min_us: minimum time for a bit (in us)
  76  * @bit_max_us: maximum time for a bit (in us)
  77  * @sample_us: timespan to sample 1-Wire response
  78  * @cycle_us: duration of the 1-Wire cycle
  79  */
  80 struct w1_uart_limits {
  81         unsigned int baudrate;
  82         unsigned int bit_min_us;
  83         unsigned int bit_max_us;
  84         unsigned int sample_us;
  85         unsigned int cycle_us;
  86 };
  87
  88 static inline unsigned int baud_to_bit_ns(unsigned int baud)
  89 {
  90         return NSEC_PER_SEC / baud;
  91 }
  92
  93 static inline unsigned int to_ns(unsigned int us)
  94 {
  95         return us * NSEC_PER_USEC;
  96 }
  97
  98 /*
  99  * Set baud-rate, delay and tx-byte to create a 1-Wire pulse and adapt
 100  * the tx-byte according to the actual baud-rate.
 101  *
 102  * Reject when:
 103  * - time for a bit outside min/max range
 104  * - a 1-Wire response is not detectable for sent byte
 105  */
 106 static int w1_uart_set_config(struct serdev_device *serdev,
 107                               const struct w1_uart_limits *limits,
 108                               struct w1_uart_config *w1cfg)
 109 {
 110         unsigned int packet_ns;
 111         unsigned int bits_low;
 112         unsigned int bit_ns;
 113         unsigned int low_ns;
 114
 115         w1cfg->baudrate = serdev_device_set_baudrate(serdev, limits->baudrate);
 116         if (w1cfg->baudrate == 0)
 117                 return -EINVAL;
 118
 119         /* Compute in nanoseconds for accuracy */
 120         bit_ns = baud_to_bit_ns(w1cfg->baudrate);
 121         bits_low = to_ns(limits->bit_min_us) / bit_ns;
 122         /* start bit is always low */
 123         low_ns = bit_ns * (bits_low + 1);
 124
 125         if (low_ns < to_ns(limits->bit_min_us))
 126                 return -EINVAL;
 127
 128         if (low_ns > to_ns(limits->bit_max_us))
 129                 return -EINVAL;
 130
 131         /* 1-Wire response detectable for sent byte */
 132         if (limits->sample_us > 0 &&
 133             bit_ns * BITS_PER_BYTE < low_ns + to_ns(limits->sample_us))
 134                 return -EINVAL;
 135
 136         /* delay: 1-Wire cycle takes longer than the UART packet */
 137         packet_ns = bit_ns * W1_UART_BITS_PER_PACKET;
 138         w1cfg->delay_us = 0;
 139         if (to_ns(limits->cycle_us) > packet_ns)
 140                 w1cfg->delay_us =
 141                         (to_ns(limits->cycle_us) - packet_ns) / NSEC_PER_USEC;
 142
 143         /* byte to create 1-Wire pulse */
 144         w1cfg->tx_byte = 0xff << bits_low;
 145
 146         return 0;
 147 }
 148
 149 /*
 150  * Configuration for reset and presence detect
 151  * - bit_min_us is 480us, add margin and use 485us
 152  * - limits for sample time 60us-75us, use 65us
 153  */
 154 static int w1_uart_set_config_reset(struct w1_uart_device *w1dev)
 155 {
 156         struct serdev_device *serdev = w1dev->serdev;
 157         struct device_node *np = serdev->dev.of_node;
 158
 159         struct w1_uart_limits limits = { .baudrate = 9600,
 160                                          .bit_min_us = 485,
 161                                          .bit_max_us = 640,
 162                                          .sample_us = 65,
 163                                          .cycle_us = 960 };
 164
 165         of_property_read_u32(np, "reset-bps", &limits.baudrate);
 166
 167         return w1_uart_set_config(serdev, &limits, &w1dev->cfg_reset);
 168 }
 169
 170 /*
 171  * Configuration for write-0 cycle (touch bit 0)
 172  * - bit_min_us is 60us, add margin and use 65us
 173  * - no sampling required, sample_us = 0
 174  */
 175 static int w1_uart_set_config_touch_0(struct w1_uart_device *w1dev)
 176 {
 177         struct serdev_device *serdev = w1dev->serdev;
 178         struct device_node *np = serdev->dev.of_node;
 179
 180         struct w1_uart_limits limits = { .baudrate = 115200,
 181                                          .bit_min_us = 65,
 182                                          .bit_max_us = 120,
 183                                          .sample_us = 0,
 184                                          .cycle_us = 70 };
 185
 186         of_property_read_u32(np, "write-0-bps", &limits.baudrate);
 187
 188         return w1_uart_set_config(serdev, &limits, &w1dev->cfg_touch_0);
 189 }
 190
 191 /*
 192  * Configuration for write-1 and read cycle (touch bit 1)
 193  * - bit_min_us is 5us, add margin and use 6us
 194  * - limits for sample time 5us-15us, use 15us
 195  */
 196 static int w1_uart_set_config_touch_1(struct w1_uart_device *w1dev)
 197 {
 198         struct serdev_device *serdev = w1dev->serdev;
 199         struct device_node *np = serdev->dev.of_node;
 200
 201         struct w1_uart_limits limits = { .baudrate = 115200,
 202                                          .bit_min_us = 6,
 203                                          .bit_max_us = 15,
 204                                          .sample_us = 15,
 205                                          .cycle_us = 70 };
 206
 207         of_property_read_u32(np, "write-1-bps", &limits.baudrate);
 208
 209         return w1_uart_set_config(serdev, &limits, &w1dev->cfg_touch_1);
 210 }
 211
 212 /*
 213  * Configure and open the serial device
 214  */
 215 static int w1_uart_serdev_open(struct w1_uart_device *w1dev)
 216 {
 217         struct serdev_device *serdev = w1dev->serdev;
 218         struct device *dev = &serdev->dev;
 219         int ret;
 220
 221         ret = devm_serdev_device_open(dev, serdev);
 222         if (ret < 0)
 223                 return ret;
 224
 225         ret = serdev_device_set_parity(serdev, SERDEV_PARITY_NONE);
 226         if (ret < 0) {
 227                 dev_err(dev, "set parity failed\n");
 228                 return ret;
 229         }
 230
 231         ret = w1_uart_set_config_reset(w1dev);
 232         if (ret < 0) {
 233                 dev_err(dev, "config for reset failed\n");
 234                 return ret;
 235         }
 236
 237         ret = w1_uart_set_config_touch_0(w1dev);
 238         if (ret < 0) {
 239                 dev_err(dev, "config for touch-0 failed\n");
 240                 return ret;
 241         }
 242
 243         ret = w1_uart_set_config_touch_1(w1dev);
 244         if (ret < 0) {
 245                 dev_err(dev, "config for touch-1 failed\n");
 246                 return ret;
 247         }
 248
 249         serdev_device_set_flow_control(serdev, false);
 250
 251         return 0;
 252 }
 253
 254 /*
 255  * Send one byte (tx_byte) and read one byte (rx_byte) via serdev.
 256  */
 257 static int w1_uart_serdev_tx_rx(struct w1_uart_device *w1dev,
 258                                 const struct w1_uart_config *w1cfg, u8 *rx_byte)
 259 {
 260         struct serdev_device *serdev = w1dev->serdev;
 261         int ret;
 262
 263         serdev_device_write_flush(serdev);
 264         serdev_device_set_baudrate(serdev, w1cfg->baudrate);
 265
 266         /* write and immediately read one byte */
 267         reinit_completion(&w1dev->rx_byte_received);
 268         ret = serdev_device_write_buf(serdev, &w1cfg->tx_byte, 1);
 269         if (ret != 1)
 270                 return -EIO;
 271         ret = wait_for_completion_interruptible_timeout(
 272                 &w1dev->rx_byte_received, W1_UART_TIMEOUT);
 273         if (ret <= 0)
 274                 return -EIO;
 275
 276         /* locking could fail when serdev is unexpectedly receiving. */
 277         if (!mutex_trylock(&w1dev->rx_mutex))
 278                 return -EIO;
 279
 280         ret = w1dev->rx_err;
 281         if (ret == 0)
 282                 *rx_byte = w1dev->rx_byte;
 283
 284         mutex_unlock(&w1dev->rx_mutex);
 285
 286         if (w1cfg->delay_us > 0)
 287                 fsleep(w1cfg->delay_us);
 288
 289         return ret;
 290 }
 291
 292 static size_t w1_uart_serdev_receive_buf(struct serdev_device *serdev,
 293                                           const u8 *buf, size_t count)
 294 {
 295         struct w1_uart_device *w1dev = serdev_device_get_drvdata(serdev);
 296
 297         mutex_lock(&w1dev->rx_mutex);
 298
 299         /* sent a single byte and receive one single byte */
 300         if (count == 1) {
 301                 w1dev->rx_byte = buf[0];
 302                 w1dev->rx_err = 0;
 303         } else {
 304                 w1dev->rx_err = -EIO;
 305         }
 306
 307         mutex_unlock(&w1dev->rx_mutex);
 308         complete(&w1dev->rx_byte_received);
 309
 310         return count;
 311 }
 312
 313 static const struct serdev_device_ops w1_uart_serdev_ops = {
 314         .receive_buf = w1_uart_serdev_receive_buf,
 315         .write_wakeup = serdev_device_write_wakeup,
 316 };
 317
 318 /*
 319  * 1-wire reset and presence detect: A present slave will manipulate
 320  * the received byte by pulling the 1-Wire low.
 321  */
 322 static u8 w1_uart_reset_bus(void *data)
 323 {
 324         struct w1_uart_device *w1dev = data;
 325         const struct w1_uart_config *w1cfg = &w1dev->cfg_reset;
 326         int ret;
 327         u8 val;
 328
 329         ret = w1_uart_serdev_tx_rx(w1dev, w1cfg, &val);
 330         if (ret < 0)
 331                 return -1;
 332
 333         /* Device present (0) or no device (1) */
 334         return val != w1cfg->tx_byte ? 0 : 1;
 335 }
 336
 337 /*
 338  * 1-Wire read and write cycle: Only the read-0 manipulates the
 339  * received byte, all others left the line untouched.
 340  */
 341 static u8 w1_uart_touch_bit(void *data, u8 bit)
 342 {
 343         struct w1_uart_device *w1dev = data;
 344         const struct w1_uart_config *w1cfg = bit ? &w1dev->cfg_touch_1 :
 345                                                    &w1dev->cfg_touch_0;
 346         int ret;
 347         u8 val;
 348
 349         ret = w1_uart_serdev_tx_rx(w1dev, w1cfg, &val);
 350
 351         /* return inactive bus state on error */
 352         if (ret < 0)
 353                 return 1;
 354
 355         return val == w1cfg->tx_byte ? 1 : 0;
 356 }
 357
 358 static int w1_uart_probe(struct serdev_device *serdev)
 359 {
 360         struct device *dev = &serdev->dev;
 361         struct w1_uart_device *w1dev;
 362         int ret;
 363
 364         w1dev = devm_kzalloc(dev, sizeof(*w1dev), GFP_KERNEL);
 365         if (!w1dev)
 366                 return -ENOMEM;
 367         w1dev->bus.data = w1dev;
 368         w1dev->bus.reset_bus = w1_uart_reset_bus;
 369         w1dev->bus.touch_bit = w1_uart_touch_bit;
 370         w1dev->serdev = serdev;
 371
 372         init_completion(&w1dev->rx_byte_received);
 373         mutex_init(&w1dev->rx_mutex);
 374
 375         ret = w1_uart_serdev_open(w1dev);
 376         if (ret < 0)
 377                 return ret;
 378         serdev_device_set_drvdata(serdev, w1dev);
 379         serdev_device_set_client_ops(serdev, &w1_uart_serdev_ops);
 380
 381         return w1_add_master_device(&w1dev->bus);
 382 }
 383
 384 static void w1_uart_remove(struct serdev_device *serdev)
 385 {
 386         struct w1_uart_device *w1dev = serdev_device_get_drvdata(serdev);
 387
 388         /*
 389          * Waits until w1-uart callbacks are finished, serdev is closed
 390          * and its device data released automatically by devres (waits
 391          * until serdev-receive is finished).
 392          */
 393         w1_remove_master_device(&w1dev->bus);
 394 }
 395
 396 static const struct of_device_id w1_uart_of_match[] = {
 397         { .compatible = "w1-uart" },
 398         {},
 399 };
 400 MODULE_DEVICE_TABLE(of, w1_uart_of_match);
 401
 402 static struct serdev_device_driver w1_uart_driver = {
 403         .driver = {
 404                 .name           = "w1-uart",
 405                 .of_match_table = w1_uart_of_match,
 406         },
 407         .probe  = w1_uart_probe,
 408         .remove = w1_uart_remove,
 409 };
 410
 411 module_serdev_device_driver(w1_uart_driver);
 412
 413 MODULE_DESCRIPTION("UART w1 bus driver");
 414 MODULE_AUTHOR("Christoph Winklhofer <cj.winklhofer@gmail.com>");
 415 MODULE_LICENSE("GPL");