1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * Driver for Microchip USB251xB USB 2.0 Hi-Speed Hub Controller |
4 | * Configuration via SMBus. |
5 | * |
6 | * Copyright (c) 2017 SKIDATA AG |
7 | * |
8 | * This work is based on the USB3503 driver by Dongjin Kim and |
9 | * a not-accepted patch by Fabien Lahoudere, see: |
10 | * https://patchwork.kernel.org/patch/9257715/ |
11 | */ |
12 | |
13 | #include <linux/delay.h> |
14 | #include <linux/gpio/consumer.h> |
15 | #include <linux/gpio/driver.h> |
16 | #include <linux/i2c.h> |
17 | #include <linux/module.h> |
18 | #include <linux/nls.h> |
19 | #include <linux/of.h> |
20 | #include <linux/regulator/consumer.h> |
21 | #include <linux/slab.h> |
22 | |
23 | /* Internal Register Set Addresses & Default Values acc. to DS00001692C */ |
24 | #define USB251XB_ADDR_VENDOR_ID_LSB 0x00 |
25 | #define USB251XB_ADDR_VENDOR_ID_MSB 0x01 |
26 | #define USB251XB_DEF_VENDOR_ID 0x0424 |
27 | |
28 | #define USB251XB_ADDR_PRODUCT_ID_LSB 0x02 |
29 | #define USB251XB_ADDR_PRODUCT_ID_MSB 0x03 |
30 | |
31 | #define USB251XB_ADDR_DEVICE_ID_LSB 0x04 |
32 | #define USB251XB_ADDR_DEVICE_ID_MSB 0x05 |
33 | #define USB251XB_DEF_DEVICE_ID 0x0BB3 |
34 | |
35 | #define USB251XB_ADDR_CONFIG_DATA_1 0x06 |
36 | #define USB251XB_DEF_CONFIG_DATA_1 0x9B |
37 | #define USB251XB_ADDR_CONFIG_DATA_2 0x07 |
38 | #define USB251XB_DEF_CONFIG_DATA_2 0x20 |
39 | #define USB251XB_ADDR_CONFIG_DATA_3 0x08 |
40 | #define USB251XB_DEF_CONFIG_DATA_3 0x02 |
41 | |
42 | #define USB251XB_ADDR_NON_REMOVABLE_DEVICES 0x09 |
43 | #define USB251XB_DEF_NON_REMOVABLE_DEVICES 0x00 |
44 | |
45 | #define USB251XB_ADDR_PORT_DISABLE_SELF 0x0A |
46 | #define USB251XB_DEF_PORT_DISABLE_SELF 0x00 |
47 | #define USB251XB_ADDR_PORT_DISABLE_BUS 0x0B |
48 | #define USB251XB_DEF_PORT_DISABLE_BUS 0x00 |
49 | |
50 | #define USB251XB_ADDR_MAX_POWER_SELF 0x0C |
51 | #define USB251XB_DEF_MAX_POWER_SELF 0x01 |
52 | #define USB251XB_ADDR_MAX_POWER_BUS 0x0D |
53 | #define USB251XB_DEF_MAX_POWER_BUS 0x32 |
54 | |
55 | #define USB251XB_ADDR_MAX_CURRENT_SELF 0x0E |
56 | #define USB251XB_DEF_MAX_CURRENT_SELF 0x01 |
57 | #define USB251XB_ADDR_MAX_CURRENT_BUS 0x0F |
58 | #define USB251XB_DEF_MAX_CURRENT_BUS 0x32 |
59 | |
60 | #define USB251XB_ADDR_POWER_ON_TIME 0x10 |
61 | #define USB251XB_DEF_POWER_ON_TIME 0x32 |
62 | |
63 | #define USB251XB_ADDR_LANGUAGE_ID_HIGH 0x11 |
64 | #define USB251XB_ADDR_LANGUAGE_ID_LOW 0x12 |
65 | #define USB251XB_DEF_LANGUAGE_ID 0x0000 |
66 | |
67 | #define USB251XB_STRING_BUFSIZE 62 |
68 | #define USB251XB_ADDR_MANUFACTURER_STRING_LEN 0x13 |
69 | #define USB251XB_ADDR_MANUFACTURER_STRING 0x16 |
70 | #define USB251XB_DEF_MANUFACTURER_STRING "Microchip" |
71 | |
72 | #define USB251XB_ADDR_PRODUCT_STRING_LEN 0x14 |
73 | #define USB251XB_ADDR_PRODUCT_STRING 0x54 |
74 | |
75 | #define USB251XB_ADDR_SERIAL_STRING_LEN 0x15 |
76 | #define USB251XB_ADDR_SERIAL_STRING 0x92 |
77 | #define USB251XB_DEF_SERIAL_STRING "" |
78 | |
79 | #define USB251XB_ADDR_BATTERY_CHARGING_ENABLE 0xD0 |
80 | #define USB251XB_DEF_BATTERY_CHARGING_ENABLE 0x00 |
81 | |
82 | #define USB251XB_ADDR_BOOST_UP 0xF6 |
83 | #define USB251XB_DEF_BOOST_UP 0x00 |
84 | #define USB251XB_ADDR_BOOST_57 0xF7 |
85 | #define USB251XB_DEF_BOOST_57 0x00 |
86 | #define USB251XB_ADDR_BOOST_14 0xF8 |
87 | #define USB251XB_DEF_BOOST_14 0x00 |
88 | |
89 | #define USB251XB_ADDR_PORT_SWAP 0xFA |
90 | #define USB251XB_DEF_PORT_SWAP 0x00 |
91 | |
92 | #define USB251XB_ADDR_PORT_MAP_12 0xFB |
93 | #define USB251XB_DEF_PORT_MAP_12 0x00 |
94 | #define USB251XB_ADDR_PORT_MAP_34 0xFC |
95 | #define USB251XB_DEF_PORT_MAP_34 0x00 /* USB251{3B/i,4B/i,7/i} only */ |
96 | #define USB251XB_ADDR_PORT_MAP_56 0xFD |
97 | #define USB251XB_DEF_PORT_MAP_56 0x00 /* USB2517/i only */ |
98 | #define USB251XB_ADDR_PORT_MAP_7 0xFE |
99 | #define USB251XB_DEF_PORT_MAP_7 0x00 /* USB2517/i only */ |
100 | |
101 | #define USB251XB_ADDR_STATUS_COMMAND 0xFF |
102 | #define USB251XB_STATUS_COMMAND_SMBUS_DOWN 0x04 |
103 | #define USB251XB_STATUS_COMMAND_RESET 0x02 |
104 | #define USB251XB_STATUS_COMMAND_ATTACH 0x01 |
105 | |
106 | #define USB251XB_I2C_REG_SZ 0x100 |
107 | #define USB251XB_I2C_WRITE_SZ 0x10 |
108 | |
109 | #define DRIVER_NAME "usb251xb" |
110 | #define DRIVER_DESC "Microchip USB 2.0 Hi-Speed Hub Controller" |
111 | |
112 | struct usb251xb { |
113 | struct device *dev; |
114 | struct i2c_client *i2c; |
115 | struct regulator *vdd; |
116 | u8 skip_config; |
117 | struct gpio_desc *gpio_reset; |
118 | u16 vendor_id; |
119 | u16 product_id; |
120 | u16 device_id; |
121 | u8 conf_data1; |
122 | u8 conf_data2; |
123 | u8 conf_data3; |
124 | u8 non_rem_dev; |
125 | u8 port_disable_sp; |
126 | u8 port_disable_bp; |
127 | u8 max_power_sp; |
128 | u8 max_power_bp; |
129 | u8 max_current_sp; |
130 | u8 max_current_bp; |
131 | u8 power_on_time; |
132 | u16 lang_id; |
133 | u8 manufacturer_len; |
134 | u8 product_len; |
135 | u8 serial_len; |
136 | char manufacturer[USB251XB_STRING_BUFSIZE]; |
137 | char product[USB251XB_STRING_BUFSIZE]; |
138 | char serial[USB251XB_STRING_BUFSIZE]; |
139 | u8 bat_charge_en; |
140 | u8 boost_up; |
141 | u8 boost_57; |
142 | u8 boost_14; |
143 | u8 port_swap; |
144 | u8 port_map12; |
145 | u8 port_map34; |
146 | u8 port_map56; |
147 | u8 port_map7; |
148 | u8 status; |
149 | }; |
150 | |
151 | struct usb251xb_data { |
152 | u16 product_id; |
153 | u8 port_cnt; |
154 | bool led_support; |
155 | bool bat_support; |
156 | char product_str[USB251XB_STRING_BUFSIZE / 2]; /* ASCII string */ |
157 | }; |
158 | |
159 | static const struct usb251xb_data usb2422_data = { |
160 | .product_id = 0x2422, |
161 | .port_cnt = 2, |
162 | .led_support = false, |
163 | .bat_support = true, |
164 | .product_str = "USB2422" , |
165 | }; |
166 | |
167 | static const struct usb251xb_data usb2512b_data = { |
168 | .product_id = 0x2512, |
169 | .port_cnt = 2, |
170 | .led_support = false, |
171 | .bat_support = true, |
172 | .product_str = "USB2512B" , |
173 | }; |
174 | |
175 | static const struct usb251xb_data usb2512bi_data = { |
176 | .product_id = 0x2512, |
177 | .port_cnt = 2, |
178 | .led_support = false, |
179 | .bat_support = true, |
180 | .product_str = "USB2512Bi" , |
181 | }; |
182 | |
183 | static const struct usb251xb_data usb2513b_data = { |
184 | .product_id = 0x2513, |
185 | .port_cnt = 3, |
186 | .led_support = false, |
187 | .bat_support = true, |
188 | .product_str = "USB2513B" , |
189 | }; |
190 | |
191 | static const struct usb251xb_data usb2513bi_data = { |
192 | .product_id = 0x2513, |
193 | .port_cnt = 3, |
194 | .led_support = false, |
195 | .bat_support = true, |
196 | .product_str = "USB2513Bi" , |
197 | }; |
198 | |
199 | static const struct usb251xb_data usb2514b_data = { |
200 | .product_id = 0x2514, |
201 | .port_cnt = 4, |
202 | .led_support = false, |
203 | .bat_support = true, |
204 | .product_str = "USB2514B" , |
205 | }; |
206 | |
207 | static const struct usb251xb_data usb2514bi_data = { |
208 | .product_id = 0x2514, |
209 | .port_cnt = 4, |
210 | .led_support = false, |
211 | .bat_support = true, |
212 | .product_str = "USB2514Bi" , |
213 | }; |
214 | |
215 | static const struct usb251xb_data usb2517_data = { |
216 | .product_id = 0x2517, |
217 | .port_cnt = 7, |
218 | .led_support = true, |
219 | .bat_support = false, |
220 | .product_str = "USB2517" , |
221 | }; |
222 | |
223 | static const struct usb251xb_data usb2517i_data = { |
224 | .product_id = 0x2517, |
225 | .port_cnt = 7, |
226 | .led_support = true, |
227 | .bat_support = false, |
228 | .product_str = "USB2517i" , |
229 | }; |
230 | |
231 | #ifdef CONFIG_GPIOLIB |
232 | static int usb251xb_check_dev_children(struct device *dev, void *child) |
233 | { |
234 | if (dev->type == &i2c_adapter_type) { |
235 | return device_for_each_child(dev, data: child, |
236 | fn: usb251xb_check_dev_children); |
237 | } |
238 | |
239 | return (dev == child); |
240 | } |
241 | |
242 | static int usb251x_check_gpio_chip(struct usb251xb *hub) |
243 | { |
244 | struct gpio_chip *gc = gpiod_to_chip(desc: hub->gpio_reset); |
245 | struct i2c_adapter *adap = hub->i2c->adapter; |
246 | int ret; |
247 | |
248 | if (!hub->gpio_reset) |
249 | return 0; |
250 | |
251 | if (!gc) |
252 | return -EINVAL; |
253 | |
254 | ret = usb251xb_check_dev_children(dev: &adap->dev, child: gc->parent); |
255 | if (ret) { |
256 | dev_err(hub->dev, "Reset GPIO chip is at the same i2c-bus\n" ); |
257 | return -EINVAL; |
258 | } |
259 | |
260 | return 0; |
261 | } |
262 | #else |
263 | static int usb251x_check_gpio_chip(struct usb251xb *hub) |
264 | { |
265 | return 0; |
266 | } |
267 | #endif |
268 | |
269 | static void usb251xb_reset(struct usb251xb *hub) |
270 | { |
271 | if (!hub->gpio_reset) |
272 | return; |
273 | |
274 | i2c_lock_bus(adapter: hub->i2c->adapter, I2C_LOCK_SEGMENT); |
275 | |
276 | gpiod_set_value_cansleep(desc: hub->gpio_reset, value: 1); |
277 | usleep_range(min: 1, max: 10); /* >=1us RESET_N asserted */ |
278 | gpiod_set_value_cansleep(desc: hub->gpio_reset, value: 0); |
279 | |
280 | /* wait for hub recovery/stabilization */ |
281 | usleep_range(min: 500, max: 750); /* >=500us after RESET_N deasserted */ |
282 | |
283 | i2c_unlock_bus(adapter: hub->i2c->adapter, I2C_LOCK_SEGMENT); |
284 | } |
285 | |
286 | static int usb251xb_connect(struct usb251xb *hub) |
287 | { |
288 | struct device *dev = hub->dev; |
289 | int err, i; |
290 | char i2c_wb[USB251XB_I2C_REG_SZ]; |
291 | |
292 | memset(i2c_wb, 0, USB251XB_I2C_REG_SZ); |
293 | |
294 | if (hub->skip_config) { |
295 | dev_info(dev, "Skip hub configuration, only attach.\n" ); |
296 | i2c_wb[0] = 0x01; |
297 | i2c_wb[1] = USB251XB_STATUS_COMMAND_ATTACH; |
298 | |
299 | usb251xb_reset(hub); |
300 | |
301 | err = i2c_smbus_write_i2c_block_data(client: hub->i2c, |
302 | USB251XB_ADDR_STATUS_COMMAND, length: 2, values: i2c_wb); |
303 | if (err) { |
304 | dev_err(dev, "attaching hub failed: %d\n" , err); |
305 | return err; |
306 | } |
307 | return 0; |
308 | } |
309 | |
310 | i2c_wb[USB251XB_ADDR_VENDOR_ID_MSB] = (hub->vendor_id >> 8) & 0xFF; |
311 | i2c_wb[USB251XB_ADDR_VENDOR_ID_LSB] = hub->vendor_id & 0xFF; |
312 | i2c_wb[USB251XB_ADDR_PRODUCT_ID_MSB] = (hub->product_id >> 8) & 0xFF; |
313 | i2c_wb[USB251XB_ADDR_PRODUCT_ID_LSB] = hub->product_id & 0xFF; |
314 | i2c_wb[USB251XB_ADDR_DEVICE_ID_MSB] = (hub->device_id >> 8) & 0xFF; |
315 | i2c_wb[USB251XB_ADDR_DEVICE_ID_LSB] = hub->device_id & 0xFF; |
316 | i2c_wb[USB251XB_ADDR_CONFIG_DATA_1] = hub->conf_data1; |
317 | i2c_wb[USB251XB_ADDR_CONFIG_DATA_2] = hub->conf_data2; |
318 | i2c_wb[USB251XB_ADDR_CONFIG_DATA_3] = hub->conf_data3; |
319 | i2c_wb[USB251XB_ADDR_NON_REMOVABLE_DEVICES] = hub->non_rem_dev; |
320 | i2c_wb[USB251XB_ADDR_PORT_DISABLE_SELF] = hub->port_disable_sp; |
321 | i2c_wb[USB251XB_ADDR_PORT_DISABLE_BUS] = hub->port_disable_bp; |
322 | i2c_wb[USB251XB_ADDR_MAX_POWER_SELF] = hub->max_power_sp; |
323 | i2c_wb[USB251XB_ADDR_MAX_POWER_BUS] = hub->max_power_bp; |
324 | i2c_wb[USB251XB_ADDR_MAX_CURRENT_SELF] = hub->max_current_sp; |
325 | i2c_wb[USB251XB_ADDR_MAX_CURRENT_BUS] = hub->max_current_bp; |
326 | i2c_wb[USB251XB_ADDR_POWER_ON_TIME] = hub->power_on_time; |
327 | i2c_wb[USB251XB_ADDR_LANGUAGE_ID_HIGH] = (hub->lang_id >> 8) & 0xFF; |
328 | i2c_wb[USB251XB_ADDR_LANGUAGE_ID_LOW] = hub->lang_id & 0xFF; |
329 | i2c_wb[USB251XB_ADDR_MANUFACTURER_STRING_LEN] = hub->manufacturer_len; |
330 | i2c_wb[USB251XB_ADDR_PRODUCT_STRING_LEN] = hub->product_len; |
331 | i2c_wb[USB251XB_ADDR_SERIAL_STRING_LEN] = hub->serial_len; |
332 | memcpy(&i2c_wb[USB251XB_ADDR_MANUFACTURER_STRING], hub->manufacturer, |
333 | USB251XB_STRING_BUFSIZE); |
334 | memcpy(&i2c_wb[USB251XB_ADDR_SERIAL_STRING], hub->serial, |
335 | USB251XB_STRING_BUFSIZE); |
336 | memcpy(&i2c_wb[USB251XB_ADDR_PRODUCT_STRING], hub->product, |
337 | USB251XB_STRING_BUFSIZE); |
338 | i2c_wb[USB251XB_ADDR_BATTERY_CHARGING_ENABLE] = hub->bat_charge_en; |
339 | i2c_wb[USB251XB_ADDR_BOOST_UP] = hub->boost_up; |
340 | i2c_wb[USB251XB_ADDR_BOOST_57] = hub->boost_57; |
341 | i2c_wb[USB251XB_ADDR_BOOST_14] = hub->boost_14; |
342 | i2c_wb[USB251XB_ADDR_PORT_SWAP] = hub->port_swap; |
343 | i2c_wb[USB251XB_ADDR_PORT_MAP_12] = hub->port_map12; |
344 | i2c_wb[USB251XB_ADDR_PORT_MAP_34] = hub->port_map34; |
345 | i2c_wb[USB251XB_ADDR_PORT_MAP_56] = hub->port_map56; |
346 | i2c_wb[USB251XB_ADDR_PORT_MAP_7] = hub->port_map7; |
347 | i2c_wb[USB251XB_ADDR_STATUS_COMMAND] = USB251XB_STATUS_COMMAND_ATTACH; |
348 | |
349 | usb251xb_reset(hub); |
350 | |
351 | /* write registers */ |
352 | for (i = 0; i < (USB251XB_I2C_REG_SZ / USB251XB_I2C_WRITE_SZ); i++) { |
353 | int offset = i * USB251XB_I2C_WRITE_SZ; |
354 | char wbuf[USB251XB_I2C_WRITE_SZ + 1]; |
355 | |
356 | /* The first data byte transferred tells the hub how many data |
357 | * bytes will follow (byte count). |
358 | */ |
359 | wbuf[0] = USB251XB_I2C_WRITE_SZ; |
360 | memcpy(&wbuf[1], &i2c_wb[offset], USB251XB_I2C_WRITE_SZ); |
361 | |
362 | dev_dbg(dev, "writing %d byte block %d to 0x%02X\n" , |
363 | USB251XB_I2C_WRITE_SZ, i, offset); |
364 | |
365 | err = i2c_smbus_write_i2c_block_data(client: hub->i2c, command: offset, |
366 | USB251XB_I2C_WRITE_SZ + 1, |
367 | values: wbuf); |
368 | if (err) |
369 | goto out_err; |
370 | } |
371 | |
372 | dev_info(dev, "Hub configuration was successful.\n" ); |
373 | return 0; |
374 | |
375 | out_err: |
376 | dev_err(dev, "configuring block %d failed: %d\n" , i, err); |
377 | return err; |
378 | } |
379 | |
380 | static void usb251xb_get_ports_field(struct usb251xb *hub, |
381 | const char *prop_name, u8 port_cnt, |
382 | bool ds_only, u8 *fld) |
383 | { |
384 | struct device *dev = hub->dev; |
385 | struct property *prop; |
386 | const __be32 *p; |
387 | u32 port; |
388 | |
389 | of_property_for_each_u32(dev->of_node, prop_name, prop, p, port) { |
390 | if ((port >= ds_only ? 1 : 0) && (port <= port_cnt)) |
391 | *fld |= BIT(port); |
392 | else |
393 | dev_warn(dev, "port %u doesn't exist\n" , port); |
394 | } |
395 | } |
396 | |
397 | static int usb251xb_get_ofdata(struct usb251xb *hub, |
398 | const struct usb251xb_data *data) |
399 | { |
400 | struct device *dev = hub->dev; |
401 | struct device_node *np = dev->of_node; |
402 | int len; |
403 | u32 property_u32 = 0; |
404 | const char *cproperty_char; |
405 | char str[USB251XB_STRING_BUFSIZE / 2]; |
406 | |
407 | if (!np) { |
408 | dev_err(dev, "failed to get ofdata\n" ); |
409 | return -ENODEV; |
410 | } |
411 | |
412 | hub->skip_config = of_property_read_bool(np, propname: "skip-config" ); |
413 | |
414 | hub->gpio_reset = devm_gpiod_get_optional(dev, con_id: "reset" , flags: GPIOD_OUT_HIGH); |
415 | if (IS_ERR(ptr: hub->gpio_reset)) |
416 | return dev_err_probe(dev, err: PTR_ERR(ptr: hub->gpio_reset), |
417 | fmt: "unable to request GPIO reset pin\n" ); |
418 | |
419 | if (of_property_read_u16(np, propname: "vendor-id" , out_value: &hub->vendor_id)) |
420 | hub->vendor_id = USB251XB_DEF_VENDOR_ID; |
421 | |
422 | if (of_property_read_u16(np, propname: "product-id" , out_value: &hub->product_id)) |
423 | hub->product_id = data->product_id; |
424 | |
425 | if (of_property_read_u16(np, propname: "device-id" , out_value: &hub->device_id)) |
426 | hub->device_id = USB251XB_DEF_DEVICE_ID; |
427 | |
428 | hub->conf_data1 = USB251XB_DEF_CONFIG_DATA_1; |
429 | if (of_property_read_bool(np, propname: "self-powered" )) { |
430 | hub->conf_data1 |= BIT(7); |
431 | |
432 | /* Configure Over-Current sens when self-powered */ |
433 | hub->conf_data1 &= ~BIT(2); |
434 | if (of_property_read_bool(np, propname: "ganged-sensing" )) |
435 | hub->conf_data1 &= ~BIT(1); |
436 | else if (of_property_read_bool(np, propname: "individual-sensing" )) |
437 | hub->conf_data1 |= BIT(1); |
438 | } else if (of_property_read_bool(np, propname: "bus-powered" )) { |
439 | hub->conf_data1 &= ~BIT(7); |
440 | |
441 | /* Disable Over-Current sense when bus-powered */ |
442 | hub->conf_data1 |= BIT(2); |
443 | } |
444 | |
445 | if (of_property_read_bool(np, propname: "disable-hi-speed" )) |
446 | hub->conf_data1 |= BIT(5); |
447 | |
448 | if (of_property_read_bool(np, propname: "multi-tt" )) |
449 | hub->conf_data1 |= BIT(4); |
450 | else if (of_property_read_bool(np, propname: "single-tt" )) |
451 | hub->conf_data1 &= ~BIT(4); |
452 | |
453 | if (of_property_read_bool(np, propname: "disable-eop" )) |
454 | hub->conf_data1 |= BIT(3); |
455 | |
456 | if (of_property_read_bool(np, propname: "individual-port-switching" )) |
457 | hub->conf_data1 |= BIT(0); |
458 | else if (of_property_read_bool(np, propname: "ganged-port-switching" )) |
459 | hub->conf_data1 &= ~BIT(0); |
460 | |
461 | hub->conf_data2 = USB251XB_DEF_CONFIG_DATA_2; |
462 | if (of_property_read_bool(np, propname: "dynamic-power-switching" )) |
463 | hub->conf_data2 |= BIT(7); |
464 | |
465 | if (!of_property_read_u32(np, propname: "oc-delay-us" , out_value: &property_u32)) { |
466 | if (property_u32 == 100) { |
467 | /* 100 us*/ |
468 | hub->conf_data2 &= ~BIT(5); |
469 | hub->conf_data2 &= ~BIT(4); |
470 | } else if (property_u32 == 4000) { |
471 | /* 4 ms */ |
472 | hub->conf_data2 &= ~BIT(5); |
473 | hub->conf_data2 |= BIT(4); |
474 | } else if (property_u32 == 16000) { |
475 | /* 16 ms */ |
476 | hub->conf_data2 |= BIT(5); |
477 | hub->conf_data2 |= BIT(4); |
478 | } else { |
479 | /* 8 ms (DEFAULT) */ |
480 | hub->conf_data2 |= BIT(5); |
481 | hub->conf_data2 &= ~BIT(4); |
482 | } |
483 | } |
484 | |
485 | if (of_property_read_bool(np, propname: "compound-device" )) |
486 | hub->conf_data2 |= BIT(3); |
487 | |
488 | hub->conf_data3 = USB251XB_DEF_CONFIG_DATA_3; |
489 | if (of_property_read_bool(np, propname: "port-mapping-mode" )) |
490 | hub->conf_data3 |= BIT(3); |
491 | |
492 | if (data->led_support && of_get_property(node: np, name: "led-usb-mode" , NULL)) |
493 | hub->conf_data3 &= ~BIT(1); |
494 | |
495 | if (of_property_read_bool(np, propname: "string-support" )) |
496 | hub->conf_data3 |= BIT(0); |
497 | |
498 | hub->non_rem_dev = USB251XB_DEF_NON_REMOVABLE_DEVICES; |
499 | usb251xb_get_ports_field(hub, prop_name: "non-removable-ports" , port_cnt: data->port_cnt, |
500 | ds_only: true, fld: &hub->non_rem_dev); |
501 | |
502 | hub->port_disable_sp = USB251XB_DEF_PORT_DISABLE_SELF; |
503 | usb251xb_get_ports_field(hub, prop_name: "sp-disabled-ports" , port_cnt: data->port_cnt, |
504 | ds_only: true, fld: &hub->port_disable_sp); |
505 | |
506 | hub->port_disable_bp = USB251XB_DEF_PORT_DISABLE_BUS; |
507 | usb251xb_get_ports_field(hub, prop_name: "bp-disabled-ports" , port_cnt: data->port_cnt, |
508 | ds_only: true, fld: &hub->port_disable_bp); |
509 | |
510 | hub->max_power_sp = USB251XB_DEF_MAX_POWER_SELF; |
511 | if (!of_property_read_u32(np, propname: "sp-max-total-current-microamp" , |
512 | out_value: &property_u32)) |
513 | hub->max_power_sp = min_t(u8, property_u32 / 2000, 50); |
514 | |
515 | hub->max_power_bp = USB251XB_DEF_MAX_POWER_BUS; |
516 | if (!of_property_read_u32(np, propname: "bp-max-total-current-microamp" , |
517 | out_value: &property_u32)) |
518 | hub->max_power_bp = min_t(u8, property_u32 / 2000, 255); |
519 | |
520 | hub->max_current_sp = USB251XB_DEF_MAX_CURRENT_SELF; |
521 | if (!of_property_read_u32(np, propname: "sp-max-removable-current-microamp" , |
522 | out_value: &property_u32)) |
523 | hub->max_current_sp = min_t(u8, property_u32 / 2000, 50); |
524 | |
525 | hub->max_current_bp = USB251XB_DEF_MAX_CURRENT_BUS; |
526 | if (!of_property_read_u32(np, propname: "bp-max-removable-current-microamp" , |
527 | out_value: &property_u32)) |
528 | hub->max_current_bp = min_t(u8, property_u32 / 2000, 255); |
529 | |
530 | hub->power_on_time = USB251XB_DEF_POWER_ON_TIME; |
531 | if (!of_property_read_u32(np, propname: "power-on-time-ms" , out_value: &property_u32)) |
532 | hub->power_on_time = min_t(u8, property_u32 / 2, 255); |
533 | |
534 | if (of_property_read_u16(np, propname: "language-id" , out_value: &hub->lang_id)) |
535 | hub->lang_id = USB251XB_DEF_LANGUAGE_ID; |
536 | |
537 | if (of_property_read_u8(np, propname: "boost-up" , out_value: &hub->boost_up)) |
538 | hub->boost_up = USB251XB_DEF_BOOST_UP; |
539 | |
540 | cproperty_char = of_get_property(node: np, name: "manufacturer" , NULL); |
541 | strscpy(p: str, q: cproperty_char ? : USB251XB_DEF_MANUFACTURER_STRING, |
542 | size: sizeof(str)); |
543 | hub->manufacturer_len = strlen(str) & 0xFF; |
544 | memset(hub->manufacturer, 0, USB251XB_STRING_BUFSIZE); |
545 | len = min_t(size_t, USB251XB_STRING_BUFSIZE / 2, strlen(str)); |
546 | len = utf8s_to_utf16s(s: str, len, endian: UTF16_LITTLE_ENDIAN, |
547 | pwcs: (wchar_t *)hub->manufacturer, |
548 | USB251XB_STRING_BUFSIZE); |
549 | |
550 | cproperty_char = of_get_property(node: np, name: "product" , NULL); |
551 | strscpy(p: str, q: cproperty_char ? : data->product_str, size: sizeof(str)); |
552 | hub->product_len = strlen(str) & 0xFF; |
553 | memset(hub->product, 0, USB251XB_STRING_BUFSIZE); |
554 | len = min_t(size_t, USB251XB_STRING_BUFSIZE / 2, strlen(str)); |
555 | len = utf8s_to_utf16s(s: str, len, endian: UTF16_LITTLE_ENDIAN, |
556 | pwcs: (wchar_t *)hub->product, |
557 | USB251XB_STRING_BUFSIZE); |
558 | |
559 | cproperty_char = of_get_property(node: np, name: "serial" , NULL); |
560 | strscpy(p: str, q: cproperty_char ? : USB251XB_DEF_SERIAL_STRING, |
561 | size: sizeof(str)); |
562 | hub->serial_len = strlen(str) & 0xFF; |
563 | memset(hub->serial, 0, USB251XB_STRING_BUFSIZE); |
564 | len = min_t(size_t, USB251XB_STRING_BUFSIZE / 2, strlen(str)); |
565 | len = utf8s_to_utf16s(s: str, len, endian: UTF16_LITTLE_ENDIAN, |
566 | pwcs: (wchar_t *)hub->serial, |
567 | USB251XB_STRING_BUFSIZE); |
568 | |
569 | /* |
570 | * The datasheet documents the register as 'Port Swap' but in real the |
571 | * register controls the USB DP/DM signal swapping for each port. |
572 | */ |
573 | hub->port_swap = USB251XB_DEF_PORT_SWAP; |
574 | usb251xb_get_ports_field(hub, prop_name: "swap-dx-lanes" , port_cnt: data->port_cnt, |
575 | ds_only: false, fld: &hub->port_swap); |
576 | |
577 | /* The following parameters are currently not exposed to devicetree, but |
578 | * may be as soon as needed. |
579 | */ |
580 | hub->bat_charge_en = USB251XB_DEF_BATTERY_CHARGING_ENABLE; |
581 | hub->boost_57 = USB251XB_DEF_BOOST_57; |
582 | hub->boost_14 = USB251XB_DEF_BOOST_14; |
583 | hub->port_map12 = USB251XB_DEF_PORT_MAP_12; |
584 | hub->port_map34 = USB251XB_DEF_PORT_MAP_34; |
585 | hub->port_map56 = USB251XB_DEF_PORT_MAP_56; |
586 | hub->port_map7 = USB251XB_DEF_PORT_MAP_7; |
587 | |
588 | return 0; |
589 | } |
590 | |
591 | static const struct of_device_id usb251xb_of_match[] = { |
592 | { |
593 | .compatible = "microchip,usb2422" , |
594 | .data = &usb2422_data, |
595 | }, { |
596 | .compatible = "microchip,usb2512b" , |
597 | .data = &usb2512b_data, |
598 | }, { |
599 | .compatible = "microchip,usb2512bi" , |
600 | .data = &usb2512bi_data, |
601 | }, { |
602 | .compatible = "microchip,usb2513b" , |
603 | .data = &usb2513b_data, |
604 | }, { |
605 | .compatible = "microchip,usb2513bi" , |
606 | .data = &usb2513bi_data, |
607 | }, { |
608 | .compatible = "microchip,usb2514b" , |
609 | .data = &usb2514b_data, |
610 | }, { |
611 | .compatible = "microchip,usb2514bi" , |
612 | .data = &usb2514bi_data, |
613 | }, { |
614 | .compatible = "microchip,usb2517" , |
615 | .data = &usb2517_data, |
616 | }, { |
617 | .compatible = "microchip,usb2517i" , |
618 | .data = &usb2517i_data, |
619 | }, { |
620 | /* sentinel */ |
621 | } |
622 | }; |
623 | MODULE_DEVICE_TABLE(of, usb251xb_of_match); |
624 | |
625 | static void usb251xb_regulator_disable_action(void *data) |
626 | { |
627 | struct usb251xb *hub = data; |
628 | |
629 | regulator_disable(regulator: hub->vdd); |
630 | } |
631 | |
632 | static int usb251xb_probe(struct usb251xb *hub) |
633 | { |
634 | struct device *dev = hub->dev; |
635 | struct device_node *np = dev->of_node; |
636 | const struct usb251xb_data *usb_data = of_device_get_match_data(dev); |
637 | int err; |
638 | |
639 | if (np && usb_data) { |
640 | err = usb251xb_get_ofdata(hub, data: usb_data); |
641 | if (err) { |
642 | dev_err(dev, "failed to get ofdata: %d\n" , err); |
643 | return err; |
644 | } |
645 | } |
646 | |
647 | /* |
648 | * usb251x SMBus-slave SCL lane is muxed with CFG_SEL0 pin. So if anyone |
649 | * tries to work with the bus at the moment the hub reset is released, |
650 | * it may cause an invalid config being latched by usb251x. Particularly |
651 | * one of the config modes makes the hub loading a default registers |
652 | * value without SMBus-slave interface activation. If the hub |
653 | * accidentally gets this mode, this will cause the driver SMBus- |
654 | * functions failure. Normally we could just lock the SMBus-segment the |
655 | * hub i2c-interface resides for the device-specific reset timing. But |
656 | * the GPIO controller, which is used to handle the hub reset, might be |
657 | * placed at the same i2c-bus segment. In this case an error should be |
658 | * returned since we can't safely use the GPIO controller to clear the |
659 | * reset state (it may affect the hub configuration) and we can't lock |
660 | * the i2c-bus segment (it will cause a deadlock). |
661 | */ |
662 | err = usb251x_check_gpio_chip(hub); |
663 | if (err) |
664 | return err; |
665 | |
666 | hub->vdd = devm_regulator_get(dev, id: "vdd" ); |
667 | if (IS_ERR(ptr: hub->vdd)) |
668 | return PTR_ERR(ptr: hub->vdd); |
669 | |
670 | err = regulator_enable(regulator: hub->vdd); |
671 | if (err) |
672 | return err; |
673 | |
674 | err = devm_add_action_or_reset(dev, |
675 | usb251xb_regulator_disable_action, hub); |
676 | if (err) |
677 | return err; |
678 | |
679 | err = usb251xb_connect(hub); |
680 | if (err) { |
681 | dev_err(dev, "Failed to connect hub (%d)\n" , err); |
682 | return err; |
683 | } |
684 | |
685 | dev_info(dev, "Hub probed successfully\n" ); |
686 | |
687 | return 0; |
688 | } |
689 | |
690 | static int usb251xb_i2c_probe(struct i2c_client *i2c) |
691 | { |
692 | struct usb251xb *hub; |
693 | |
694 | hub = devm_kzalloc(dev: &i2c->dev, size: sizeof(struct usb251xb), GFP_KERNEL); |
695 | if (!hub) |
696 | return -ENOMEM; |
697 | |
698 | i2c_set_clientdata(client: i2c, data: hub); |
699 | hub->dev = &i2c->dev; |
700 | hub->i2c = i2c; |
701 | |
702 | return usb251xb_probe(hub); |
703 | } |
704 | |
705 | static int __maybe_unused usb251xb_suspend(struct device *dev) |
706 | { |
707 | struct i2c_client *client = to_i2c_client(dev); |
708 | struct usb251xb *hub = i2c_get_clientdata(client); |
709 | |
710 | return regulator_disable(regulator: hub->vdd); |
711 | } |
712 | |
713 | static int __maybe_unused usb251xb_resume(struct device *dev) |
714 | { |
715 | struct i2c_client *client = to_i2c_client(dev); |
716 | struct usb251xb *hub = i2c_get_clientdata(client); |
717 | int err; |
718 | |
719 | err = regulator_enable(regulator: hub->vdd); |
720 | if (err) |
721 | return err; |
722 | |
723 | return usb251xb_connect(hub); |
724 | } |
725 | |
726 | static SIMPLE_DEV_PM_OPS(usb251xb_pm_ops, usb251xb_suspend, usb251xb_resume); |
727 | |
728 | static const struct i2c_device_id usb251xb_id[] = { |
729 | { "usb2422" , 0 }, |
730 | { "usb2512b" , 0 }, |
731 | { "usb2512bi" , 0 }, |
732 | { "usb2513b" , 0 }, |
733 | { "usb2513bi" , 0 }, |
734 | { "usb2514b" , 0 }, |
735 | { "usb2514bi" , 0 }, |
736 | { "usb2517" , 0 }, |
737 | { "usb2517i" , 0 }, |
738 | { /* sentinel */ } |
739 | }; |
740 | MODULE_DEVICE_TABLE(i2c, usb251xb_id); |
741 | |
742 | static struct i2c_driver usb251xb_i2c_driver = { |
743 | .driver = { |
744 | .name = DRIVER_NAME, |
745 | .of_match_table = usb251xb_of_match, |
746 | .pm = &usb251xb_pm_ops, |
747 | }, |
748 | .probe = usb251xb_i2c_probe, |
749 | .id_table = usb251xb_id, |
750 | }; |
751 | |
752 | module_i2c_driver(usb251xb_i2c_driver); |
753 | |
754 | MODULE_AUTHOR("Richard Leitner <richard.leitner@skidata.com>" ); |
755 | MODULE_DESCRIPTION("USB251x/xBi USB 2.0 Hub Controller Driver" ); |
756 | MODULE_LICENSE("GPL" ); |
757 | |