xref: /openbmc/u-boot/drivers/w1/w1-gpio.c (revision 592cd5de)
1 /* SPDX-License-Identifier:	GPL-2.0+
2  *
3  * Copyright (c) 2015 Free Electrons
4  * Copyright (c) 2015 NextThing Co
5  *
6  * Maxime Ripard <maxime.ripard@free-electrons.com>
7  *
8  */
9 
10 #include <common.h>
11 #include <dm.h>
12 #include <w1.h>
13 
14 #include <asm/gpio.h>
15 
16 #define W1_TIMING_A	6
17 #define W1_TIMING_B	64
18 #define W1_TIMING_C	60
19 #define W1_TIMING_D	10
20 #define W1_TIMING_E	9
21 #define W1_TIMING_F	55
22 #define W1_TIMING_G	0
23 #define W1_TIMING_H	480
24 #define W1_TIMING_I	70
25 #define W1_TIMING_J	410
26 
27 struct w1_gpio_pdata {
28 	struct gpio_desc	gpio;
29 	u64			search_id;
30 };
31 
w1_gpio_read_bit(struct udevice * dev)32 static bool w1_gpio_read_bit(struct udevice *dev)
33 {
34 	struct w1_gpio_pdata *pdata = dev_get_platdata(dev);
35 	int val;
36 
37 	dm_gpio_set_dir_flags(&pdata->gpio, GPIOD_IS_OUT);
38 	udelay(W1_TIMING_A);
39 
40 	dm_gpio_set_dir_flags(&pdata->gpio, GPIOD_IS_IN);
41 	udelay(W1_TIMING_E);
42 
43 	val = dm_gpio_get_value(&pdata->gpio);
44 	if (val < 0)
45 		debug("error in retrieving GPIO value");
46 	udelay(W1_TIMING_F);
47 
48 	return val;
49 }
50 
w1_gpio_read_byte(struct udevice * dev)51 static u8 w1_gpio_read_byte(struct udevice *dev)
52 {
53 	int i;
54 	u8 ret = 0;
55 
56 	for (i = 0; i < 8; ++i)
57 		ret |= (w1_gpio_read_bit(dev) ? 1 : 0) << i;
58 
59 	return ret;
60 }
61 
w1_gpio_write_bit(struct udevice * dev,bool bit)62 static void w1_gpio_write_bit(struct udevice *dev, bool bit)
63 {
64 	struct w1_gpio_pdata *pdata = dev_get_platdata(dev);
65 
66 	dm_gpio_set_dir_flags(&pdata->gpio, GPIOD_IS_OUT);
67 
68 	bit ? udelay(W1_TIMING_A) : udelay(W1_TIMING_C);
69 
70 	dm_gpio_set_value(&pdata->gpio, 1);
71 
72 	bit ? udelay(W1_TIMING_B) : udelay(W1_TIMING_D);
73 }
74 
w1_gpio_write_byte(struct udevice * dev,u8 byte)75 static void w1_gpio_write_byte(struct udevice *dev, u8 byte)
76 {
77 	int i;
78 
79 	for (i = 0; i < 8; ++i)
80 		w1_gpio_write_bit(dev, (byte >> i) & 0x1);
81 }
82 
w1_gpio_reset(struct udevice * dev)83 static bool w1_gpio_reset(struct udevice *dev)
84 {
85 	struct w1_gpio_pdata *pdata = dev_get_platdata(dev);
86 	int val;
87 
88 	/* initiate the reset pulse. first we must pull the bus to low */
89 	dm_gpio_set_dir_flags(&pdata->gpio, GPIOD_IS_OUT | GPIOD_IS_OUT_ACTIVE);
90 	udelay(W1_TIMING_G);
91 
92 	dm_gpio_set_value(&pdata->gpio, 0);
93 	/* wait for the specified time with the bus kept low */
94 	udelay(W1_TIMING_H);
95 
96 	/* now we must read the presence pulse */
97 	dm_gpio_set_dir_flags(&pdata->gpio, GPIOD_IS_IN);
98 	udelay(W1_TIMING_I);
99 
100 	val = dm_gpio_get_value(&pdata->gpio);
101 	if (val < 0)
102 		debug("error in retrieving GPIO value");
103 
104 	/* if nobody pulled the bus down , it means nobody is on the bus */
105 	if (val != 0)
106 		return 1;
107 	/* we have the bus pulled down, let's wait for the specified presence time */
108 	udelay(W1_TIMING_J);
109 
110 	/* read again, the other end should leave the bus free */
111 	val = dm_gpio_get_value(&pdata->gpio);
112 	if (val < 0)
113 		debug("error in retrieving GPIO value");
114 
115 	/* bus is not going up again, so we have an error */
116 	if (val != 1)
117 		return 1;
118 
119 	/* all good, presence detected */
120 	return 0;
121 }
122 
w1_gpio_triplet(struct udevice * dev,bool bdir)123 static u8 w1_gpio_triplet(struct udevice *dev, bool bdir)
124 {
125 	u8 id_bit   = w1_gpio_read_bit(dev);
126 	u8 comp_bit = w1_gpio_read_bit(dev);
127 	u8 retval;
128 
129 	if (id_bit && comp_bit)
130 		return 0x03;  /* error */
131 
132 	if (!id_bit && !comp_bit) {
133 		/* Both bits are valid, take the direction given */
134 		retval = bdir ? 0x04 : 0;
135 	} else {
136 		/* Only one bit is valid, take that direction */
137 		bdir = id_bit;
138 		retval = id_bit ? 0x05 : 0x02;
139 	}
140 
141 	w1_gpio_write_bit(dev, bdir);
142 	return retval;
143 }
144 
145 static const struct w1_ops w1_gpio_ops = {
146 	.read_byte	= w1_gpio_read_byte,
147 	.reset		= w1_gpio_reset,
148 	.triplet	= w1_gpio_triplet,
149 	.write_byte	= w1_gpio_write_byte,
150 };
151 
w1_gpio_ofdata_to_platdata(struct udevice * dev)152 static int w1_gpio_ofdata_to_platdata(struct udevice *dev)
153 {
154 	struct w1_gpio_pdata *pdata = dev_get_platdata(dev);
155 	int ret;
156 
157 	ret = gpio_request_by_name(dev, "gpios", 0, &pdata->gpio, 0);
158 	if (ret < 0)
159 		printf("Error claiming GPIO %d\n", ret);
160 
161 	return ret;
162 };
163 
164 static const struct udevice_id w1_gpio_id[] = {
165 	{ "w1-gpio", 0 },
166 	{ },
167 };
168 
169 U_BOOT_DRIVER(w1_gpio_drv) = {
170 	.id				= UCLASS_W1,
171 	.name				= "w1_gpio_drv",
172 	.of_match			= w1_gpio_id,
173 	.ofdata_to_platdata		= w1_gpio_ofdata_to_platdata,
174 	.ops				= &w1_gpio_ops,
175 	.platdata_auto_alloc_size	= sizeof(struct w1_gpio_pdata),
176 };
177