xref: /openbmc/linux/drivers/media/i2c/max9271.c (revision 8938c48f)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2017-2020 Jacopo Mondi
4  * Copyright (C) 2017-2020 Kieran Bingham
5  * Copyright (C) 2017-2020 Laurent Pinchart
6  * Copyright (C) 2017-2020 Niklas Söderlund
7  * Copyright (C) 2016 Renesas Electronics Corporation
8  * Copyright (C) 2015 Cogent Embedded, Inc.
9  *
10  * This file exports functions to control the Maxim MAX9271 GMSL serializer
11  * chip. This is not a self-contained driver, as MAX9271 is usually embedded in
12  * camera modules with at least one image sensor and optional additional
13  * components, such as uController units or ISPs/DSPs.
14  *
15  * Drivers for the camera modules (i.e. rdacm20/21) are expected to use
16  * functions exported from this library driver to maximize code re-use.
17  */
18 
19 #include <linux/delay.h>
20 #include <linux/i2c.h>
21 #include <linux/module.h>
22 
23 #include "max9271.h"
24 
25 static int max9271_read(struct max9271_device *dev, u8 reg)
26 {
27 	int ret;
28 
29 	dev_dbg(&dev->client->dev, "%s(0x%02x)\n", __func__, reg);
30 
31 	ret = i2c_smbus_read_byte_data(dev->client, reg);
32 	if (ret < 0)
33 		dev_dbg(&dev->client->dev,
34 			"%s: register 0x%02x read failed (%d)\n",
35 			__func__, reg, ret);
36 
37 	return ret;
38 }
39 
40 static int max9271_write(struct max9271_device *dev, u8 reg, u8 val)
41 {
42 	int ret;
43 
44 	dev_dbg(&dev->client->dev, "%s(0x%02x, 0x%02x)\n", __func__, reg, val);
45 
46 	ret = i2c_smbus_write_byte_data(dev->client, reg, val);
47 	if (ret < 0)
48 		dev_err(&dev->client->dev,
49 			"%s: register 0x%02x write failed (%d)\n",
50 			__func__, reg, ret);
51 
52 	return ret;
53 }
54 
55 /*
56  * max9271_pclk_detect() - Detect valid pixel clock from image sensor
57  *
58  * Wait up to 10ms for a valid pixel clock.
59  *
60  * Returns 0 for success, < 0 for pixel clock not properly detected
61  */
62 static int max9271_pclk_detect(struct max9271_device *dev)
63 {
64 	unsigned int i;
65 	int ret;
66 
67 	for (i = 0; i < 100; i++) {
68 		ret = max9271_read(dev, 0x15);
69 		if (ret < 0)
70 			return ret;
71 
72 		if (ret & MAX9271_PCLKDET)
73 			return 0;
74 
75 		usleep_range(50, 100);
76 	}
77 
78 	dev_err(&dev->client->dev, "Unable to detect valid pixel clock\n");
79 
80 	return -EIO;
81 }
82 
83 int max9271_set_serial_link(struct max9271_device *dev, bool enable)
84 {
85 	int ret;
86 	u8 val = MAX9271_REVCCEN | MAX9271_FWDCCEN;
87 
88 	if (enable) {
89 		ret = max9271_pclk_detect(dev);
90 		if (ret)
91 			return ret;
92 
93 		val |= MAX9271_SEREN;
94 	} else {
95 		val |= MAX9271_CLINKEN;
96 	}
97 
98 	/*
99 	 * The serializer temporarily disables the reverse control channel for
100 	 * 350µs after starting/stopping the forward serial link, but the
101 	 * deserializer synchronization time isn't clearly documented.
102 	 *
103 	 * According to the serializer datasheet we should wait 3ms, while
104 	 * according to the deserializer datasheet we should wait 5ms.
105 	 *
106 	 * Short delays here appear to show bit-errors in the writes following.
107 	 * Therefore a conservative delay seems best here.
108 	 */
109 	max9271_write(dev, 0x04, val);
110 	usleep_range(5000, 8000);
111 
112 	return 0;
113 }
114 EXPORT_SYMBOL_GPL(max9271_set_serial_link);
115 
116 int max9271_configure_i2c(struct max9271_device *dev, u8 i2c_config)
117 {
118 	int ret;
119 
120 	ret = max9271_write(dev, 0x0d, i2c_config);
121 	if (ret)
122 		return ret;
123 
124 	/* The delay required after an I2C bus configuration change is not
125 	 * characterized in the serializer manual. Sleep up to 5msec to
126 	 * stay safe.
127 	 */
128 	usleep_range(3500, 5000);
129 
130 	return 0;
131 }
132 EXPORT_SYMBOL_GPL(max9271_configure_i2c);
133 
134 int max9271_set_high_threshold(struct max9271_device *dev, bool enable)
135 {
136 	int ret;
137 
138 	ret = max9271_read(dev, 0x08);
139 	if (ret < 0)
140 		return ret;
141 
142 	/*
143 	 * Enable or disable reverse channel high threshold to increase
144 	 * immunity to power supply noise.
145 	 */
146 	max9271_write(dev, 0x08, enable ? ret | BIT(0) : ret & ~BIT(0));
147 	usleep_range(2000, 2500);
148 
149 	return 0;
150 }
151 EXPORT_SYMBOL_GPL(max9271_set_high_threshold);
152 
153 int max9271_configure_gmsl_link(struct max9271_device *dev)
154 {
155 	/*
156 	 * Configure the GMSL link:
157 	 *
158 	 * - Double input mode, high data rate, 24-bit mode
159 	 * - Latch input data on PCLKIN rising edge
160 	 * - Enable HS/VS encoding
161 	 * - 1-bit parity error detection
162 	 *
163 	 * TODO: Make the GMSL link configuration parametric.
164 	 */
165 	max9271_write(dev, 0x07, MAX9271_DBL | MAX9271_HVEN |
166 		      MAX9271_EDC_1BIT_PARITY);
167 	usleep_range(5000, 8000);
168 
169 	/*
170 	 * Adjust spread spectrum to +4% and auto-detect pixel clock
171 	 * and serial link rate.
172 	 */
173 	max9271_write(dev, 0x02, MAX9271_SPREAD_SPECT_4 | MAX9271_R02_RES |
174 		      MAX9271_PCLK_AUTODETECT | MAX9271_SERIAL_AUTODETECT);
175 	usleep_range(5000, 8000);
176 
177 	return 0;
178 }
179 EXPORT_SYMBOL_GPL(max9271_configure_gmsl_link);
180 
181 int max9271_set_gpios(struct max9271_device *dev, u8 gpio_mask)
182 {
183 	int ret;
184 
185 	ret = max9271_read(dev, 0x0f);
186 	if (ret < 0)
187 		return 0;
188 
189 	ret |= gpio_mask;
190 	ret = max9271_write(dev, 0x0f, ret);
191 	if (ret < 0) {
192 		dev_err(&dev->client->dev, "Failed to set gpio (%d)\n", ret);
193 		return ret;
194 	}
195 
196 	usleep_range(3500, 5000);
197 
198 	return 0;
199 }
200 EXPORT_SYMBOL_GPL(max9271_set_gpios);
201 
202 int max9271_clear_gpios(struct max9271_device *dev, u8 gpio_mask)
203 {
204 	int ret;
205 
206 	ret = max9271_read(dev, 0x0f);
207 	if (ret < 0)
208 		return 0;
209 
210 	ret &= ~gpio_mask;
211 	ret = max9271_write(dev, 0x0f, ret);
212 	if (ret < 0) {
213 		dev_err(&dev->client->dev, "Failed to clear gpio (%d)\n", ret);
214 		return ret;
215 	}
216 
217 	usleep_range(3500, 5000);
218 
219 	return 0;
220 }
221 EXPORT_SYMBOL_GPL(max9271_clear_gpios);
222 
223 int max9271_enable_gpios(struct max9271_device *dev, u8 gpio_mask)
224 {
225 	int ret;
226 
227 	ret = max9271_read(dev, 0x0e);
228 	if (ret < 0)
229 		return 0;
230 
231 	/* BIT(0) reserved: GPO is always enabled. */
232 	ret |= (gpio_mask & ~BIT(0));
233 	ret = max9271_write(dev, 0x0e, ret);
234 	if (ret < 0) {
235 		dev_err(&dev->client->dev, "Failed to enable gpio (%d)\n", ret);
236 		return ret;
237 	}
238 
239 	usleep_range(3500, 5000);
240 
241 	return 0;
242 }
243 EXPORT_SYMBOL_GPL(max9271_enable_gpios);
244 
245 int max9271_disable_gpios(struct max9271_device *dev, u8 gpio_mask)
246 {
247 	int ret;
248 
249 	ret = max9271_read(dev, 0x0e);
250 	if (ret < 0)
251 		return 0;
252 
253 	/* BIT(0) reserved: GPO cannot be disabled */
254 	ret &= ~(gpio_mask | BIT(0));
255 	ret = max9271_write(dev, 0x0e, ret);
256 	if (ret < 0) {
257 		dev_err(&dev->client->dev, "Failed to disable gpio (%d)\n", ret);
258 		return ret;
259 	}
260 
261 	usleep_range(3500, 5000);
262 
263 	return 0;
264 }
265 EXPORT_SYMBOL_GPL(max9271_disable_gpios);
266 
267 int max9271_verify_id(struct max9271_device *dev)
268 {
269 	int ret;
270 
271 	ret = max9271_read(dev, 0x1e);
272 	if (ret < 0) {
273 		dev_err(&dev->client->dev, "MAX9271 ID read failed (%d)\n",
274 			ret);
275 		return ret;
276 	}
277 
278 	if (ret != MAX9271_ID) {
279 		dev_err(&dev->client->dev, "MAX9271 ID mismatch (0x%02x)\n",
280 			ret);
281 		return -ENXIO;
282 	}
283 
284 	return 0;
285 }
286 EXPORT_SYMBOL_GPL(max9271_verify_id);
287 
288 int max9271_set_address(struct max9271_device *dev, u8 addr)
289 {
290 	int ret;
291 
292 	ret = max9271_write(dev, 0x00, addr << 1);
293 	if (ret < 0) {
294 		dev_err(&dev->client->dev,
295 			"MAX9271 I2C address change failed (%d)\n", ret);
296 		return ret;
297 	}
298 	usleep_range(3500, 5000);
299 
300 	return 0;
301 }
302 EXPORT_SYMBOL_GPL(max9271_set_address);
303 
304 int max9271_set_deserializer_address(struct max9271_device *dev, u8 addr)
305 {
306 	int ret;
307 
308 	ret = max9271_write(dev, 0x01, addr << 1);
309 	if (ret < 0) {
310 		dev_err(&dev->client->dev,
311 			"MAX9271 deserializer address set failed (%d)\n", ret);
312 		return ret;
313 	}
314 	usleep_range(3500, 5000);
315 
316 	return 0;
317 }
318 EXPORT_SYMBOL_GPL(max9271_set_deserializer_address);
319 
320 int max9271_set_translation(struct max9271_device *dev, u8 source, u8 dest)
321 {
322 	int ret;
323 
324 	ret = max9271_write(dev, 0x09, source << 1);
325 	if (ret < 0) {
326 		dev_err(&dev->client->dev,
327 			"MAX9271 I2C translation setup failed (%d)\n", ret);
328 		return ret;
329 	}
330 	usleep_range(3500, 5000);
331 
332 	ret = max9271_write(dev, 0x0a, dest << 1);
333 	if (ret < 0) {
334 		dev_err(&dev->client->dev,
335 			"MAX9271 I2C translation setup failed (%d)\n", ret);
336 		return ret;
337 	}
338 	usleep_range(3500, 5000);
339 
340 	return 0;
341 }
342 EXPORT_SYMBOL_GPL(max9271_set_translation);
343 
344 MODULE_DESCRIPTION("Maxim MAX9271 GMSL Serializer");
345 MODULE_AUTHOR("Jacopo Mondi");
346 MODULE_LICENSE("GPL v2");
347