blob: b96c1a00bf243d124ccdbbe47ec56db7fd1e968c [file] [log] [blame]
Martin Fuzzeya2e99a72018-10-24 10:21:18 +02001// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Driver for one wire controller in some i.MX Socs
4 *
5 * There are currently two silicon variants:
6 * V1: i.MX21, i.MX27, i.MX31, i.MX51
7 * V2: i.MX25, i.MX35, i.MX50, i.MX53
8 * Newer i.MX SoCs such as the i.MX6 do not have one wire controllers.
9 *
10 * The V1 controller only supports single bit operations.
11 * The V2 controller is backwards compatible on the register level but adds
12 * byte size operations and a "search ROM accelerator mode"
13 *
14 * This driver does not currently support the search ROM accelerator
15 *
16 * Copyright (c) 2018 Flowbird
17 * Martin Fuzzey <martin.fuzzey@flowbird.group>
18 */
19
Martin Fuzzeya2e99a72018-10-24 10:21:18 +020020#include <common.h>
Martin Fuzzey3f832692021-01-13 11:21:03 +010021#include <asm/arch/clock.h>
Martin Fuzzeya2e99a72018-10-24 10:21:18 +020022#include <dm.h>
Simon Glass336d4612020-02-03 07:36:16 -070023#include <dm/device_compat.h>
Simon Glasscd93d622020-05-10 11:40:13 -060024#include <linux/bitops.h>
Simon Glassc05ed002020-05-10 11:40:11 -060025#include <linux/delay.h>
Martin Fuzzeya2e99a72018-10-24 10:21:18 +020026#include <linux/io.h>
27#include <w1.h>
28
29struct mxc_w1_regs {
30 u16 control;
31#define MXC_W1_CONTROL_RPP BIT(7)
32#define MXC_W1_CONTROL_PST BIT(6)
33#define MXC_W1_CONTROL_WR(x) BIT(5 - (x))
34#define MXC_W1_CONTROL_RDST BIT(3)
35
36 u16 time_divider;
37 u16 reset;
38
39 /* Registers below on V2 silicon only */
40 u16 command;
41 u16 tx_rx;
42 u16 interrupt;
43#define MXC_W1_INTERRUPT_TBE BIT(2)
44#define MXC_W1_INTERRUPT_TSRE BIT(3)
45#define MXC_W1_INTERRUPT_RBF BIT(4)
46#define MXC_W1_INTERRUPT_RSRF BIT(5)
47
48 u16 interrupt_en;
49};
50
51struct mxc_w1_pdata {
52 struct mxc_w1_regs *regs;
53};
54
55/*
56 * this is the low level routine to read/write a bit on the One Wire
57 * interface on the hardware. It does write 0 if parameter bit is set
58 * to 0, otherwise a write 1/read.
59 */
60static u8 mxc_w1_touch_bit(struct mxc_w1_pdata *pdata, u8 bit)
61{
62 u16 *ctrl_addr = &pdata->regs->control;
63 u16 mask = MXC_W1_CONTROL_WR(bit);
64 unsigned int timeout_cnt = 400; /* Takes max. 120us according to
65 * datasheet.
66 */
67
68 writew(mask, ctrl_addr);
69
70 while (timeout_cnt--) {
71 if (!(readw(ctrl_addr) & mask))
72 break;
73
74 udelay(1);
75 }
76
77 return (readw(ctrl_addr) & MXC_W1_CONTROL_RDST) ? 1 : 0;
78}
79
80static u8 mxc_w1_read_byte(struct udevice *dev)
81{
Simon Glassc69cda22020-12-03 16:55:20 -070082 struct mxc_w1_pdata *pdata = dev_get_plat(dev);
Martin Fuzzeya2e99a72018-10-24 10:21:18 +020083 struct mxc_w1_regs *regs = pdata->regs;
84 u16 status;
85
86 if (dev_get_driver_data(dev) < 2) {
87 int i;
88 u8 ret = 0;
89
90 for (i = 0; i < 8; i++)
91 ret |= (mxc_w1_touch_bit(pdata, 1) << i);
92
93 return ret;
94 }
95
96 readw(&regs->tx_rx);
97 writew(0xFF, &regs->tx_rx);
98
99 do {
100 udelay(1); /* Without this bytes are sometimes duplicated... */
101 status = readw(&regs->interrupt);
102 } while (!(status & MXC_W1_INTERRUPT_RBF));
103
104 return (u8)readw(&regs->tx_rx);
105}
106
107static void mxc_w1_write_byte(struct udevice *dev, u8 byte)
108{
Simon Glassc69cda22020-12-03 16:55:20 -0700109 struct mxc_w1_pdata *pdata = dev_get_plat(dev);
Martin Fuzzeya2e99a72018-10-24 10:21:18 +0200110 struct mxc_w1_regs *regs = pdata->regs;
111 u16 status;
112
113 if (dev_get_driver_data(dev) < 2) {
114 int i;
115
116 for (i = 0; i < 8; i++)
117 mxc_w1_touch_bit(pdata, (byte >> i) & 0x1);
118
119 return;
120 }
121
122 readw(&regs->tx_rx);
123 writew(byte, &regs->tx_rx);
124
125 do {
126 udelay(1);
127 status = readw(&regs->interrupt);
128 } while (!(status & MXC_W1_INTERRUPT_TSRE));
129}
130
131static bool mxc_w1_reset(struct udevice *dev)
132{
Simon Glassc69cda22020-12-03 16:55:20 -0700133 struct mxc_w1_pdata *pdata = dev_get_plat(dev);
Martin Fuzzeya2e99a72018-10-24 10:21:18 +0200134 u16 reg_val;
135
136 writew(MXC_W1_CONTROL_RPP, &pdata->regs->control);
137
138 do {
139 reg_val = readw(&pdata->regs->control);
140 } while (reg_val & MXC_W1_CONTROL_RPP);
141
142 return !(reg_val & MXC_W1_CONTROL_PST);
143}
144
145static u8 mxc_w1_triplet(struct udevice *dev, bool bdir)
146{
Simon Glassc69cda22020-12-03 16:55:20 -0700147 struct mxc_w1_pdata *pdata = dev_get_plat(dev);
Martin Fuzzeya2e99a72018-10-24 10:21:18 +0200148 u8 id_bit = mxc_w1_touch_bit(pdata, 1);
149 u8 comp_bit = mxc_w1_touch_bit(pdata, 1);
150 u8 retval;
151
152 if (id_bit && comp_bit)
153 return 0x03; /* error */
154
155 if (!id_bit && !comp_bit) {
156 /* Both bits are valid, take the direction given */
157 retval = bdir ? 0x04 : 0;
158 } else {
159 /* Only one bit is valid, take that direction */
160 bdir = id_bit;
161 retval = id_bit ? 0x05 : 0x02;
162 }
163
164 mxc_w1_touch_bit(pdata, bdir);
165
166 return retval;
167}
168
Simon Glassd1998a92020-12-03 16:55:21 -0700169static int mxc_w1_of_to_plat(struct udevice *dev)
Martin Fuzzeya2e99a72018-10-24 10:21:18 +0200170{
Simon Glassc69cda22020-12-03 16:55:20 -0700171 struct mxc_w1_pdata *pdata = dev_get_plat(dev);
Martin Fuzzeya2e99a72018-10-24 10:21:18 +0200172 fdt_addr_t addr;
173
Masahiro Yamada25484932020-07-17 14:36:48 +0900174 addr = dev_read_addr(dev);
Martin Fuzzeya2e99a72018-10-24 10:21:18 +0200175 if (addr == FDT_ADDR_T_NONE)
176 return -EINVAL;
177
178 pdata->regs = (struct mxc_w1_regs *)addr;
179
180 return 0;
181};
182
183static int mxc_w1_probe(struct udevice *dev)
184{
Simon Glassc69cda22020-12-03 16:55:20 -0700185 struct mxc_w1_pdata *pdata = dev_get_plat(dev);
Martin Fuzzeya2e99a72018-10-24 10:21:18 +0200186 unsigned int clkrate = mxc_get_clock(MXC_IPG_PERCLK);
187 unsigned int clkdiv;
188
189 if (clkrate < 10000000) {
190 dev_err(dev, "input clock frequency (%u Hz) too low\n",
191 clkrate);
192 return -EINVAL;
193 }
194
195 clkdiv = clkrate / 1000000;
196 clkrate /= clkdiv;
197 if (clkrate < 980000 || clkrate > 1020000) {
198 dev_err(dev, "Incorrect time base frequency %u Hz\n", clkrate);
199 return -EINVAL;
200 }
201
202 writew(clkdiv - 1, &pdata->regs->time_divider);
203
204 return 0;
205}
206
207static const struct w1_ops mxc_w1_ops = {
208 .read_byte = mxc_w1_read_byte,
209 .reset = mxc_w1_reset,
210 .triplet = mxc_w1_triplet,
211 .write_byte = mxc_w1_write_byte,
212};
213
214static const struct udevice_id mxc_w1_id[] = {
215 { .compatible = "fsl,imx21-owire", .data = 1 },
216 { .compatible = "fsl,imx27-owire", .data = 1 },
217 { .compatible = "fsl,imx31-owire", .data = 1 },
218 { .compatible = "fsl,imx51-owire", .data = 1 },
219
220 { .compatible = "fsl,imx25-owire", .data = 2 },
221 { .compatible = "fsl,imx35-owire", .data = 2 },
222 { .compatible = "fsl,imx50-owire", .data = 2 },
223 { .compatible = "fsl,imx53-owire", .data = 2 },
224 { },
225};
226
227U_BOOT_DRIVER(mxc_w1_drv) = {
228 .id = UCLASS_W1,
229 .name = "mxc_w1_drv",
230 .of_match = mxc_w1_id,
Simon Glassd1998a92020-12-03 16:55:21 -0700231 .of_to_plat = mxc_w1_of_to_plat,
Martin Fuzzeya2e99a72018-10-24 10:21:18 +0200232 .ops = &mxc_w1_ops,
Simon Glasscaa4daa2020-12-03 16:55:18 -0700233 .plat_auto = sizeof(struct mxc_w1_pdata),
Martin Fuzzeya2e99a72018-10-24 10:21:18 +0200234 .probe = mxc_w1_probe,
235};