// SPDX-License-Identifier: GPL-2.0-or-later /* * w1-uart - UART 1-Wire bus driver * * Uses the UART interface (via Serial Device Bus) to create the 1-Wire * timing patterns. Implements the following 1-Wire master interface: * * - reset_bus: requests baud-rate 9600 * * - touch_bit: requests baud-rate 115200 * * Author: Christoph Winklhofer */ #include #include #include #include #include #include #include #include /* UART packet contains start and stop bit */ #define W1_UART_BITS_PER_PACKET (BITS_PER_BYTE + 2) /* Timeout to wait for completion of serdev-receive */ #define W1_UART_TIMEOUT msecs_to_jiffies(500) /** * struct w1_uart_config - configuration for 1-Wire operation * @baudrate: baud-rate returned from serdev * @delay_us: delay to complete a 1-Wire cycle (in us) * @tx_byte: byte to generate 1-Wire timing pattern */ struct w1_uart_config { unsigned int baudrate; unsigned int delay_us; u8 tx_byte; }; /** * struct w1_uart_device - 1-Wire UART device structure * @serdev: serial device * @bus: w1-bus master * @cfg_reset: config for 1-Wire reset * @cfg_touch_0: config for 1-Wire write-0 cycle * @cfg_touch_1: config for 1-Wire write-1 and read cycle * @rx_byte_received: completion for serdev receive * @rx_mutex: mutex to protect rx_err and rx_byte * @rx_err: indicates an error in serdev-receive * @rx_byte: result byte from serdev-receive */ struct w1_uart_device { struct serdev_device *serdev; struct w1_bus_master bus; struct w1_uart_config cfg_reset; struct w1_uart_config cfg_touch_0; struct w1_uart_config cfg_touch_1; struct completion rx_byte_received; /* * protect rx_err and rx_byte from concurrent access in * w1-callbacks and serdev-receive. */ struct mutex rx_mutex; int rx_err; u8 rx_byte; }; /** * struct w1_uart_limits - limits for 1-Wire operations * @baudrate: Requested baud-rate to create 1-Wire timing pattern * @bit_min_us: minimum time for a bit (in us) * @bit_max_us: maximum time for a bit (in us) * @sample_us: timespan to sample 1-Wire response * @cycle_us: duration of the 1-Wire cycle */ struct w1_uart_limits { unsigned int baudrate; unsigned int bit_min_us; unsigned int bit_max_us; unsigned int sample_us; unsigned int cycle_us; }; static inline unsigned int baud_to_bit_ns(unsigned int baud) { return NSEC_PER_SEC / baud; } static inline unsigned int to_ns(unsigned int us) { return us * NSEC_PER_USEC; } /* * Set baud-rate, delay and tx-byte to create a 1-Wire pulse and adapt * the tx-byte according to the actual baud-rate. * * Reject when: * - time for a bit outside min/max range * - a 1-Wire response is not detectable for sent byte */ static int w1_uart_set_config(struct serdev_device *serdev, const struct w1_uart_limits *limits, struct w1_uart_config *w1cfg) { unsigned int packet_ns; unsigned int bits_low; unsigned int bit_ns; unsigned int low_ns; w1cfg->baudrate = serdev_device_set_baudrate(serdev, limits->baudrate); if (w1cfg->baudrate == 0) return -EINVAL; /* Compute in nanoseconds for accuracy */ bit_ns = baud_to_bit_ns(w1cfg->baudrate); bits_low = to_ns(limits->bit_min_us) / bit_ns; /* start bit is always low */ low_ns = bit_ns * (bits_low + 1); if (low_ns < to_ns(limits->bit_min_us)) return -EINVAL; if (low_ns > to_ns(limits->bit_max_us)) return -EINVAL; /* 1-Wire response detectable for sent byte */ if (limits->sample_us > 0 && bit_ns * BITS_PER_BYTE < low_ns + to_ns(limits->sample_us)) return -EINVAL; /* delay: 1-Wire cycle takes longer than the UART packet */ packet_ns = bit_ns * W1_UART_BITS_PER_PACKET; w1cfg->delay_us = 0; if (to_ns(limits->cycle_us) > packet_ns) w1cfg->delay_us = (to_ns(limits->cycle_us) - packet_ns) / NSEC_PER_USEC; /* byte to create 1-Wire pulse */ w1cfg->tx_byte = 0xff << bits_low; return 0; } /* * Configuration for reset and presence detect * - bit_min_us is 480us, add margin and use 485us * - limits for sample time 60us-75us, use 65us */ static int w1_uart_set_config_reset(struct w1_uart_device *w1dev) { struct serdev_device *serdev = w1dev->serdev; struct device_node *np = serdev->dev.of_node; struct w1_uart_limits limits = { .baudrate = 9600, .bit_min_us = 485, .bit_max_us = 640, .sample_us = 65, .cycle_us = 960 }; of_property_read_u32(np, "reset-bps", &limits.baudrate); return w1_uart_set_config(serdev, &limits, &w1dev->cfg_reset); } /* * Configuration for write-0 cycle (touch bit 0) * - bit_min_us is 60us, add margin and use 65us * - no sampling required, sample_us = 0 */ static int w1_uart_set_config_touch_0(struct w1_uart_device *w1dev) { struct serdev_device *serdev = w1dev->serdev; struct device_node *np = serdev->dev.of_node; struct w1_uart_limits limits = { .baudrate = 115200, .bit_min_us = 65, .bit_max_us = 120, .sample_us = 0, .cycle_us = 70 }; of_property_read_u32(np, "write-0-bps", &limits.baudrate); return w1_uart_set_config(serdev, &limits, &w1dev->cfg_touch_0); } /* * Configuration for write-1 and read cycle (touch bit 1) * - bit_min_us is 5us, add margin and use 6us * - limits for sample time 5us-15us, use 15us */ static int w1_uart_set_config_touch_1(struct w1_uart_device *w1dev) { struct serdev_device *serdev = w1dev->serdev; struct device_node *np = serdev->dev.of_node; struct w1_uart_limits limits = { .baudrate = 115200, .bit_min_us = 6, .bit_max_us = 15, .sample_us = 15, .cycle_us = 70 }; of_property_read_u32(np, "write-1-bps", &limits.baudrate); return w1_uart_set_config(serdev, &limits, &w1dev->cfg_touch_1); } /* * Configure and open the serial device */ static int w1_uart_serdev_open(struct w1_uart_device *w1dev) { struct serdev_device *serdev = w1dev->serdev; struct device *dev = &serdev->dev; int ret; ret = devm_serdev_device_open(dev, serdev); if (ret < 0) return ret; ret = serdev_device_set_parity(serdev, SERDEV_PARITY_NONE); if (ret < 0) { dev_err(dev, "set parity failed\n"); return ret; } ret = w1_uart_set_config_reset(w1dev); if (ret < 0) { dev_err(dev, "config for reset failed\n"); return ret; } ret = w1_uart_set_config_touch_0(w1dev); if (ret < 0) { dev_err(dev, "config for touch-0 failed\n"); return ret; } ret = w1_uart_set_config_touch_1(w1dev); if (ret < 0) { dev_err(dev, "config for touch-1 failed\n"); return ret; } serdev_device_set_flow_control(serdev, false); return 0; } /* * Send one byte (tx_byte) and read one byte (rx_byte) via serdev. */ static int w1_uart_serdev_tx_rx(struct w1_uart_device *w1dev, const struct w1_uart_config *w1cfg, u8 *rx_byte) { struct serdev_device *serdev = w1dev->serdev; int ret; serdev_device_write_flush(serdev); serdev_device_set_baudrate(serdev, w1cfg->baudrate); /* write and immediately read one byte */ reinit_completion(&w1dev->rx_byte_received); ret = serdev_device_write_buf(serdev, &w1cfg->tx_byte, 1); if (ret != 1) return -EIO; ret = wait_for_completion_interruptible_timeout( &w1dev->rx_byte_received, W1_UART_TIMEOUT); if (ret <= 0) return -EIO; /* locking could fail when serdev is unexpectedly receiving. */ if (!mutex_trylock(&w1dev->rx_mutex)) return -EIO; ret = w1dev->rx_err; if (ret == 0) *rx_byte = w1dev->rx_byte; mutex_unlock(&w1dev->rx_mutex); if (w1cfg->delay_us > 0) fsleep(w1cfg->delay_us); return ret; } static size_t w1_uart_serdev_receive_buf(struct serdev_device *serdev, const u8 *buf, size_t count) { struct w1_uart_device *w1dev = serdev_device_get_drvdata(serdev); mutex_lock(&w1dev->rx_mutex); /* sent a single byte and receive one single byte */ if (count == 1) { w1dev->rx_byte = buf[0]; w1dev->rx_err = 0; } else { w1dev->rx_err = -EIO; } mutex_unlock(&w1dev->rx_mutex); complete(&w1dev->rx_byte_received); return count; } static const struct serdev_device_ops w1_uart_serdev_ops = { .receive_buf = w1_uart_serdev_receive_buf, .write_wakeup = serdev_device_write_wakeup, }; /* * 1-wire reset and presence detect: A present slave will manipulate * the received byte by pulling the 1-Wire low. */ static u8 w1_uart_reset_bus(void *data) { struct w1_uart_device *w1dev = data; const struct w1_uart_config *w1cfg = &w1dev->cfg_reset; int ret; u8 val; ret = w1_uart_serdev_tx_rx(w1dev, w1cfg, &val); if (ret < 0) return -1; /* Device present (0) or no device (1) */ return val != w1cfg->tx_byte ? 0 : 1; } /* * 1-Wire read and write cycle: Only the read-0 manipulates the * received byte, all others left the line untouched. */ static u8 w1_uart_touch_bit(void *data, u8 bit) { struct w1_uart_device *w1dev = data; const struct w1_uart_config *w1cfg = bit ? &w1dev->cfg_touch_1 : &w1dev->cfg_touch_0; int ret; u8 val; ret = w1_uart_serdev_tx_rx(w1dev, w1cfg, &val); /* return inactive bus state on error */ if (ret < 0) return 1; return val == w1cfg->tx_byte ? 1 : 0; } static int w1_uart_probe(struct serdev_device *serdev) { struct device *dev = &serdev->dev; struct w1_uart_device *w1dev; int ret; w1dev = devm_kzalloc(dev, sizeof(*w1dev), GFP_KERNEL); if (!w1dev) return -ENOMEM; w1dev->bus.data = w1dev; w1dev->bus.reset_bus = w1_uart_reset_bus; w1dev->bus.touch_bit = w1_uart_touch_bit; w1dev->serdev = serdev; init_completion(&w1dev->rx_byte_received); mutex_init(&w1dev->rx_mutex); ret = w1_uart_serdev_open(w1dev); if (ret < 0) return ret; serdev_device_set_drvdata(serdev, w1dev); serdev_device_set_client_ops(serdev, &w1_uart_serdev_ops); return w1_add_master_device(&w1dev->bus); } static void w1_uart_remove(struct serdev_device *serdev) { struct w1_uart_device *w1dev = serdev_device_get_drvdata(serdev); /* * Waits until w1-uart callbacks are finished, serdev is closed * and its device data released automatically by devres (waits * until serdev-receive is finished). */ w1_remove_master_device(&w1dev->bus); } static const struct of_device_id w1_uart_of_match[] = { { .compatible = "w1-uart" }, {}, }; MODULE_DEVICE_TABLE(of, w1_uart_of_match); static struct serdev_device_driver w1_uart_driver = { .driver = { .name = "w1-uart", .of_match_table = w1_uart_of_match, }, .probe = w1_uart_probe, .remove = w1_uart_remove, }; module_serdev_device_driver(w1_uart_driver); MODULE_DESCRIPTION("UART w1 bus driver"); MODULE_AUTHOR("Christoph Winklhofer "); MODULE_LICENSE("GPL");