1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * drivers/extcon/extcon-tusb320.c - TUSB320 extcon driver
4  *
5  * Copyright (C) 2020 National Instruments Corporation
6  * Author: Michael Auchter <michael.auchter@ni.com>
7  */
8 
9 #include <linux/bitfield.h>
10 #include <linux/extcon-provider.h>
11 #include <linux/i2c.h>
12 #include <linux/init.h>
13 #include <linux/interrupt.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/regmap.h>
17 #include <linux/usb/typec.h>
18 #include <linux/usb/typec_altmode.h>
19 #include <linux/usb/role.h>
20 
21 #define TUSB320_REG8				0x8
22 #define TUSB320_REG8_CURRENT_MODE_ADVERTISE	GENMASK(7, 6)
23 #define TUSB320_REG8_CURRENT_MODE_ADVERTISE_USB	0x0
24 #define TUSB320_REG8_CURRENT_MODE_ADVERTISE_15A	0x1
25 #define TUSB320_REG8_CURRENT_MODE_ADVERTISE_30A	0x2
26 #define TUSB320_REG8_CURRENT_MODE_DETECT	GENMASK(5, 4)
27 #define TUSB320_REG8_CURRENT_MODE_DETECT_DEF	0x0
28 #define TUSB320_REG8_CURRENT_MODE_DETECT_MED	0x1
29 #define TUSB320_REG8_CURRENT_MODE_DETECT_ACC	0x2
30 #define TUSB320_REG8_CURRENT_MODE_DETECT_HI	0x3
31 #define TUSB320_REG8_ACCESSORY_CONNECTED	GENMASK(3, 1)
32 #define TUSB320_REG8_ACCESSORY_CONNECTED_NONE	0x0
33 #define TUSB320_REG8_ACCESSORY_CONNECTED_AUDIO	0x4
34 #define TUSB320_REG8_ACCESSORY_CONNECTED_ACHRG	0x5
35 #define TUSB320_REG8_ACCESSORY_CONNECTED_DBGDFP	0x6
36 #define TUSB320_REG8_ACCESSORY_CONNECTED_DBGUFP	0x7
37 #define TUSB320_REG8_ACTIVE_CABLE_DETECTION	BIT(0)
38 
39 #define TUSB320_REG9				0x9
40 #define TUSB320_REG9_ATTACHED_STATE		GENMASK(7, 6)
41 #define TUSB320_REG9_CABLE_DIRECTION		BIT(5)
42 #define TUSB320_REG9_INTERRUPT_STATUS		BIT(4)
43 
44 #define TUSB320_REGA				0xa
45 #define TUSB320L_REGA_DISABLE_TERM		BIT(0)
46 #define TUSB320_REGA_I2C_SOFT_RESET		BIT(3)
47 #define TUSB320_REGA_MODE_SELECT_SHIFT		4
48 #define TUSB320_REGA_MODE_SELECT_MASK		0x3
49 
50 #define TUSB320L_REGA0_REVISION			0xa0
51 
52 enum tusb320_attached_state {
53 	TUSB320_ATTACHED_STATE_NONE,
54 	TUSB320_ATTACHED_STATE_DFP,
55 	TUSB320_ATTACHED_STATE_UFP,
56 	TUSB320_ATTACHED_STATE_ACC,
57 };
58 
59 enum tusb320_mode {
60 	TUSB320_MODE_PORT,
61 	TUSB320_MODE_UFP,
62 	TUSB320_MODE_DFP,
63 	TUSB320_MODE_DRP,
64 };
65 
66 struct tusb320_priv;
67 
68 struct tusb320_ops {
69 	int (*set_mode)(struct tusb320_priv *priv, enum tusb320_mode mode);
70 	int (*get_revision)(struct tusb320_priv *priv, unsigned int *revision);
71 };
72 
73 struct tusb320_priv {
74 	struct device *dev;
75 	struct regmap *regmap;
76 	struct extcon_dev *edev;
77 	struct tusb320_ops *ops;
78 	enum tusb320_attached_state state;
79 	struct typec_port *port;
80 	struct typec_capability	cap;
81 	enum typec_port_type port_type;
82 	enum typec_pwr_opmode pwr_opmode;
83 	struct fwnode_handle *connector_fwnode;
84 	struct usb_role_switch *role_sw;
85 };
86 
87 static const char * const tusb_attached_states[] = {
88 	[TUSB320_ATTACHED_STATE_NONE] = "not attached",
89 	[TUSB320_ATTACHED_STATE_DFP]  = "downstream facing port",
90 	[TUSB320_ATTACHED_STATE_UFP]  = "upstream facing port",
91 	[TUSB320_ATTACHED_STATE_ACC]  = "accessory",
92 };
93 
94 static const unsigned int tusb320_extcon_cable[] = {
95 	EXTCON_USB,
96 	EXTCON_USB_HOST,
97 	EXTCON_NONE,
98 };
99 
100 static int tusb320_check_signature(struct tusb320_priv *priv)
101 {
102 	static const char sig[] = { '\0', 'T', 'U', 'S', 'B', '3', '2', '0' };
103 	unsigned val;
104 	int i, ret;
105 
106 	for (i = 0; i < sizeof(sig); i++) {
107 		ret = regmap_read(priv->regmap, sizeof(sig) - 1 - i, &val);
108 		if (ret < 0)
109 			return ret;
110 		if (val != sig[i]) {
111 			dev_err(priv->dev, "signature mismatch!\n");
112 			return -ENODEV;
113 		}
114 	}
115 
116 	return 0;
117 }
118 
119 static int tusb320_set_mode(struct tusb320_priv *priv, enum tusb320_mode mode)
120 {
121 	int ret;
122 
123 	/* Mode cannot be changed while cable is attached */
124 	if (priv->state != TUSB320_ATTACHED_STATE_NONE)
125 		return -EBUSY;
126 
127 	/* Write mode */
128 	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
129 		TUSB320_REGA_MODE_SELECT_MASK << TUSB320_REGA_MODE_SELECT_SHIFT,
130 		mode << TUSB320_REGA_MODE_SELECT_SHIFT);
131 	if (ret) {
132 		dev_err(priv->dev, "failed to write mode: %d\n", ret);
133 		return ret;
134 	}
135 
136 	return 0;
137 }
138 
139 static int tusb320l_set_mode(struct tusb320_priv *priv, enum tusb320_mode mode)
140 {
141 	int ret;
142 
143 	/* Disable CC state machine */
144 	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
145 		TUSB320L_REGA_DISABLE_TERM, 1);
146 	if (ret) {
147 		dev_err(priv->dev,
148 			"failed to disable CC state machine: %d\n", ret);
149 		return ret;
150 	}
151 
152 	/* Write mode */
153 	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
154 		TUSB320_REGA_MODE_SELECT_MASK << TUSB320_REGA_MODE_SELECT_SHIFT,
155 		mode << TUSB320_REGA_MODE_SELECT_SHIFT);
156 	if (ret) {
157 		dev_err(priv->dev, "failed to write mode: %d\n", ret);
158 		goto err;
159 	}
160 
161 	msleep(5);
162 err:
163 	/* Re-enable CC state machine */
164 	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
165 		TUSB320L_REGA_DISABLE_TERM, 0);
166 	if (ret)
167 		dev_err(priv->dev,
168 			"failed to re-enable CC state machine: %d\n", ret);
169 
170 	return ret;
171 }
172 
173 static int tusb320_reset(struct tusb320_priv *priv)
174 {
175 	int ret;
176 
177 	/* Set mode to default (follow PORT pin) */
178 	ret = priv->ops->set_mode(priv, TUSB320_MODE_PORT);
179 	if (ret && ret != -EBUSY) {
180 		dev_err(priv->dev,
181 			"failed to set mode to PORT: %d\n", ret);
182 		return ret;
183 	}
184 
185 	/* Perform soft reset */
186 	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
187 			TUSB320_REGA_I2C_SOFT_RESET, 1);
188 	if (ret) {
189 		dev_err(priv->dev,
190 			"failed to write soft reset bit: %d\n", ret);
191 		return ret;
192 	}
193 
194 	/* Wait for chip to go through reset */
195 	msleep(95);
196 
197 	return 0;
198 }
199 
200 static int tusb320l_get_revision(struct tusb320_priv *priv, unsigned int *revision)
201 {
202 	return regmap_read(priv->regmap, TUSB320L_REGA0_REVISION, revision);
203 }
204 
205 static struct tusb320_ops tusb320_ops = {
206 	.set_mode = tusb320_set_mode,
207 };
208 
209 static struct tusb320_ops tusb320l_ops = {
210 	.set_mode = tusb320l_set_mode,
211 	.get_revision = tusb320l_get_revision,
212 };
213 
214 static int tusb320_set_adv_pwr_mode(struct tusb320_priv *priv)
215 {
216 	u8 mode;
217 
218 	if (priv->pwr_opmode == TYPEC_PWR_MODE_USB)
219 		mode = TUSB320_REG8_CURRENT_MODE_ADVERTISE_USB;
220 	else if (priv->pwr_opmode == TYPEC_PWR_MODE_1_5A)
221 		mode = TUSB320_REG8_CURRENT_MODE_ADVERTISE_15A;
222 	else if (priv->pwr_opmode == TYPEC_PWR_MODE_3_0A)
223 		mode = TUSB320_REG8_CURRENT_MODE_ADVERTISE_30A;
224 	else	/* No other mode is supported. */
225 		return -EINVAL;
226 
227 	return regmap_write_bits(priv->regmap, TUSB320_REG8,
228 				 TUSB320_REG8_CURRENT_MODE_ADVERTISE,
229 				 FIELD_PREP(TUSB320_REG8_CURRENT_MODE_ADVERTISE,
230 					    mode));
231 }
232 
233 static int tusb320_port_type_set(struct typec_port *port,
234 				 enum typec_port_type type)
235 {
236 	struct tusb320_priv *priv = typec_get_drvdata(port);
237 
238 	if (type == TYPEC_PORT_SRC)
239 		return priv->ops->set_mode(priv, TUSB320_MODE_DFP);
240 	else if (type == TYPEC_PORT_SNK)
241 		return priv->ops->set_mode(priv, TUSB320_MODE_UFP);
242 	else if (type == TYPEC_PORT_DRP)
243 		return priv->ops->set_mode(priv, TUSB320_MODE_DRP);
244 	else
245 		return priv->ops->set_mode(priv, TUSB320_MODE_PORT);
246 }
247 
248 static const struct typec_operations tusb320_typec_ops = {
249 	.port_type_set	= tusb320_port_type_set,
250 };
251 
252 static void tusb320_extcon_irq_handler(struct tusb320_priv *priv, u8 reg)
253 {
254 	int state, polarity;
255 
256 	state = FIELD_GET(TUSB320_REG9_ATTACHED_STATE, reg);
257 	polarity = !!(reg & TUSB320_REG9_CABLE_DIRECTION);
258 
259 	dev_dbg(priv->dev, "attached state: %s, polarity: %d\n",
260 		tusb_attached_states[state], polarity);
261 
262 	extcon_set_state(priv->edev, EXTCON_USB,
263 			 state == TUSB320_ATTACHED_STATE_UFP);
264 	extcon_set_state(priv->edev, EXTCON_USB_HOST,
265 			 state == TUSB320_ATTACHED_STATE_DFP);
266 	extcon_set_property(priv->edev, EXTCON_USB,
267 			    EXTCON_PROP_USB_TYPEC_POLARITY,
268 			    (union extcon_property_value)polarity);
269 	extcon_set_property(priv->edev, EXTCON_USB_HOST,
270 			    EXTCON_PROP_USB_TYPEC_POLARITY,
271 			    (union extcon_property_value)polarity);
272 	extcon_sync(priv->edev, EXTCON_USB);
273 	extcon_sync(priv->edev, EXTCON_USB_HOST);
274 
275 	priv->state = state;
276 }
277 
278 static void tusb320_typec_irq_handler(struct tusb320_priv *priv, u8 reg9)
279 {
280 	struct typec_port *port = priv->port;
281 	struct device *dev = priv->dev;
282 	int typec_mode;
283 	enum usb_role usb_role;
284 	enum typec_role pwr_role;
285 	enum typec_data_role data_role;
286 	u8 state, mode, accessory;
287 	int ret, reg8;
288 	bool ori;
289 
290 	ret = regmap_read(priv->regmap, TUSB320_REG8, &reg8);
291 	if (ret) {
292 		dev_err(dev, "error during reg8 i2c read, ret=%d!\n", ret);
293 		return;
294 	}
295 
296 	ori = reg9 & TUSB320_REG9_CABLE_DIRECTION;
297 	typec_set_orientation(port, ori ? TYPEC_ORIENTATION_REVERSE :
298 					  TYPEC_ORIENTATION_NORMAL);
299 
300 	state = FIELD_GET(TUSB320_REG9_ATTACHED_STATE, reg9);
301 	accessory = FIELD_GET(TUSB320_REG8_ACCESSORY_CONNECTED, reg8);
302 
303 	switch (state) {
304 	case TUSB320_ATTACHED_STATE_DFP:
305 		typec_mode = TYPEC_MODE_USB2;
306 		usb_role = USB_ROLE_HOST;
307 		pwr_role = TYPEC_SOURCE;
308 		data_role = TYPEC_HOST;
309 		break;
310 	case TUSB320_ATTACHED_STATE_UFP:
311 		typec_mode = TYPEC_MODE_USB2;
312 		usb_role = USB_ROLE_DEVICE;
313 		pwr_role = TYPEC_SINK;
314 		data_role = TYPEC_DEVICE;
315 		break;
316 	case TUSB320_ATTACHED_STATE_ACC:
317 		/*
318 		 * Accessory detected. For debug accessories, just make some
319 		 * qualified guesses as to the role for lack of a better option.
320 		 */
321 		if (accessory == TUSB320_REG8_ACCESSORY_CONNECTED_AUDIO ||
322 		    accessory == TUSB320_REG8_ACCESSORY_CONNECTED_ACHRG) {
323 			typec_mode = TYPEC_MODE_AUDIO;
324 			usb_role = USB_ROLE_NONE;
325 			pwr_role = TYPEC_SINK;
326 			data_role = TYPEC_DEVICE;
327 			break;
328 		} else if (accessory ==
329 			   TUSB320_REG8_ACCESSORY_CONNECTED_DBGDFP) {
330 			typec_mode = TYPEC_MODE_DEBUG;
331 			pwr_role = TYPEC_SOURCE;
332 			usb_role = USB_ROLE_HOST;
333 			data_role = TYPEC_HOST;
334 			break;
335 		} else if (accessory ==
336 			   TUSB320_REG8_ACCESSORY_CONNECTED_DBGUFP) {
337 			typec_mode = TYPEC_MODE_DEBUG;
338 			pwr_role = TYPEC_SINK;
339 			usb_role = USB_ROLE_DEVICE;
340 			data_role = TYPEC_DEVICE;
341 			break;
342 		}
343 
344 		dev_warn(priv->dev, "unexpected ACCESSORY_CONNECTED state %d\n",
345 			 accessory);
346 
347 		fallthrough;
348 	default:
349 		typec_mode = TYPEC_MODE_USB2;
350 		usb_role = USB_ROLE_NONE;
351 		pwr_role = TYPEC_SINK;
352 		data_role = TYPEC_DEVICE;
353 		break;
354 	}
355 
356 	typec_set_vconn_role(port, pwr_role);
357 	typec_set_pwr_role(port, pwr_role);
358 	typec_set_data_role(port, data_role);
359 	typec_set_mode(port, typec_mode);
360 	usb_role_switch_set_role(priv->role_sw, usb_role);
361 
362 	mode = FIELD_GET(TUSB320_REG8_CURRENT_MODE_DETECT, reg8);
363 	if (mode == TUSB320_REG8_CURRENT_MODE_DETECT_DEF)
364 		typec_set_pwr_opmode(port, TYPEC_PWR_MODE_USB);
365 	else if (mode == TUSB320_REG8_CURRENT_MODE_DETECT_MED)
366 		typec_set_pwr_opmode(port, TYPEC_PWR_MODE_1_5A);
367 	else if (mode == TUSB320_REG8_CURRENT_MODE_DETECT_HI)
368 		typec_set_pwr_opmode(port, TYPEC_PWR_MODE_3_0A);
369 	else	/* Charge through accessory */
370 		typec_set_pwr_opmode(port, TYPEC_PWR_MODE_USB);
371 }
372 
373 static irqreturn_t tusb320_state_update_handler(struct tusb320_priv *priv,
374 						bool force_update)
375 {
376 	unsigned int reg;
377 
378 	if (regmap_read(priv->regmap, TUSB320_REG9, &reg)) {
379 		dev_err(priv->dev, "error during i2c read!\n");
380 		return IRQ_NONE;
381 	}
382 
383 	if (!force_update && !(reg & TUSB320_REG9_INTERRUPT_STATUS))
384 		return IRQ_NONE;
385 
386 	tusb320_extcon_irq_handler(priv, reg);
387 
388 	/*
389 	 * Type-C support is optional. Only call the Type-C handler if a
390 	 * port had been registered previously.
391 	 */
392 	if (priv->port)
393 		tusb320_typec_irq_handler(priv, reg);
394 
395 	regmap_write(priv->regmap, TUSB320_REG9, reg);
396 
397 	return IRQ_HANDLED;
398 }
399 
400 static irqreturn_t tusb320_irq_handler(int irq, void *dev_id)
401 {
402 	struct tusb320_priv *priv = dev_id;
403 
404 	return tusb320_state_update_handler(priv, false);
405 }
406 
407 static const struct regmap_config tusb320_regmap_config = {
408 	.reg_bits = 8,
409 	.val_bits = 8,
410 };
411 
412 static int tusb320_extcon_probe(struct tusb320_priv *priv)
413 {
414 	int ret;
415 
416 	priv->edev = devm_extcon_dev_allocate(priv->dev, tusb320_extcon_cable);
417 	if (IS_ERR(priv->edev)) {
418 		dev_err(priv->dev, "failed to allocate extcon device\n");
419 		return PTR_ERR(priv->edev);
420 	}
421 
422 	ret = devm_extcon_dev_register(priv->dev, priv->edev);
423 	if (ret < 0) {
424 		dev_err(priv->dev, "failed to register extcon device\n");
425 		return ret;
426 	}
427 
428 	extcon_set_property_capability(priv->edev, EXTCON_USB,
429 				       EXTCON_PROP_USB_TYPEC_POLARITY);
430 	extcon_set_property_capability(priv->edev, EXTCON_USB_HOST,
431 				       EXTCON_PROP_USB_TYPEC_POLARITY);
432 
433 	return 0;
434 }
435 
436 static int tusb320_typec_probe(struct i2c_client *client,
437 			       struct tusb320_priv *priv)
438 {
439 	struct fwnode_handle *connector;
440 	const char *cap_str;
441 	int ret;
442 
443 	/* The Type-C connector is optional, for backward compatibility. */
444 	connector = device_get_named_child_node(&client->dev, "connector");
445 	if (!connector)
446 		return 0;
447 
448 	/* Type-C connector found. */
449 	ret = typec_get_fw_cap(&priv->cap, connector);
450 	if (ret)
451 		goto err_put;
452 
453 	priv->port_type = priv->cap.type;
454 
455 	/* This goes into register 0x8 field CURRENT_MODE_ADVERTISE */
456 	ret = fwnode_property_read_string(connector, "typec-power-opmode", &cap_str);
457 	if (ret)
458 		goto err_put;
459 
460 	ret = typec_find_pwr_opmode(cap_str);
461 	if (ret < 0)
462 		goto err_put;
463 
464 	priv->pwr_opmode = ret;
465 
466 	/* Initialize the hardware with the devicetree settings. */
467 	ret = tusb320_set_adv_pwr_mode(priv);
468 	if (ret)
469 		goto err_put;
470 
471 	priv->cap.revision		= USB_TYPEC_REV_1_1;
472 	priv->cap.accessory[0]		= TYPEC_ACCESSORY_AUDIO;
473 	priv->cap.accessory[1]		= TYPEC_ACCESSORY_DEBUG;
474 	priv->cap.orientation_aware	= true;
475 	priv->cap.driver_data		= priv;
476 	priv->cap.ops			= &tusb320_typec_ops;
477 	priv->cap.fwnode		= connector;
478 
479 	priv->port = typec_register_port(&client->dev, &priv->cap);
480 	if (IS_ERR(priv->port)) {
481 		ret = PTR_ERR(priv->port);
482 		goto err_put;
483 	}
484 
485 	/* Find any optional USB role switch that needs reporting to */
486 	priv->role_sw = fwnode_usb_role_switch_get(connector);
487 	if (IS_ERR(priv->role_sw)) {
488 		ret = PTR_ERR(priv->role_sw);
489 		goto err_unreg;
490 	}
491 
492 	priv->connector_fwnode = connector;
493 
494 	return 0;
495 
496 err_unreg:
497 	typec_unregister_port(priv->port);
498 
499 err_put:
500 	fwnode_handle_put(connector);
501 
502 	return ret;
503 }
504 
505 static void tusb320_typec_remove(struct tusb320_priv *priv)
506 {
507 	usb_role_switch_put(priv->role_sw);
508 	typec_unregister_port(priv->port);
509 	fwnode_handle_put(priv->connector_fwnode);
510 }
511 
512 static int tusb320_probe(struct i2c_client *client)
513 {
514 	struct tusb320_priv *priv;
515 	const void *match_data;
516 	unsigned int revision;
517 	int ret;
518 
519 	priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
520 	if (!priv)
521 		return -ENOMEM;
522 
523 	priv->dev = &client->dev;
524 	i2c_set_clientdata(client, priv);
525 
526 	priv->regmap = devm_regmap_init_i2c(client, &tusb320_regmap_config);
527 	if (IS_ERR(priv->regmap))
528 		return PTR_ERR(priv->regmap);
529 
530 	ret = tusb320_check_signature(priv);
531 	if (ret)
532 		return ret;
533 
534 	match_data = device_get_match_data(&client->dev);
535 	if (!match_data)
536 		return -EINVAL;
537 
538 	priv->ops = (struct tusb320_ops*)match_data;
539 
540 	if (priv->ops->get_revision) {
541 		ret = priv->ops->get_revision(priv, &revision);
542 		if (ret)
543 			dev_warn(priv->dev,
544 				"failed to read revision register: %d\n", ret);
545 		else
546 			dev_info(priv->dev, "chip revision %d\n", revision);
547 	}
548 
549 	ret = tusb320_extcon_probe(priv);
550 	if (ret)
551 		return ret;
552 
553 	ret = tusb320_typec_probe(client, priv);
554 	if (ret)
555 		return ret;
556 
557 	/* update initial state */
558 	tusb320_state_update_handler(priv, true);
559 
560 	/* Reset chip to its default state */
561 	ret = tusb320_reset(priv);
562 	if (ret)
563 		dev_warn(priv->dev, "failed to reset chip: %d\n", ret);
564 	else
565 		/*
566 		 * State and polarity might change after a reset, so update
567 		 * them again and make sure the interrupt status bit is cleared.
568 		 */
569 		tusb320_state_update_handler(priv, true);
570 
571 	ret = devm_request_threaded_irq(priv->dev, client->irq, NULL,
572 					tusb320_irq_handler,
573 					IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
574 					client->name, priv);
575 	if (ret)
576 		tusb320_typec_remove(priv);
577 
578 	return ret;
579 }
580 
581 static void tusb320_remove(struct i2c_client *client)
582 {
583 	struct tusb320_priv *priv = i2c_get_clientdata(client);
584 
585 	tusb320_typec_remove(priv);
586 }
587 
588 static const struct of_device_id tusb320_extcon_dt_match[] = {
589 	{ .compatible = "ti,tusb320", .data = &tusb320_ops, },
590 	{ .compatible = "ti,tusb320l", .data = &tusb320l_ops, },
591 	{ }
592 };
593 MODULE_DEVICE_TABLE(of, tusb320_extcon_dt_match);
594 
595 static struct i2c_driver tusb320_extcon_driver = {
596 	.probe		= tusb320_probe,
597 	.remove		= tusb320_remove,
598 	.driver		= {
599 		.name	= "extcon-tusb320",
600 		.of_match_table = tusb320_extcon_dt_match,
601 	},
602 };
603 
604 static int __init tusb320_init(void)
605 {
606 	return i2c_add_driver(&tusb320_extcon_driver);
607 }
608 subsys_initcall(tusb320_init);
609 
610 static void __exit tusb320_exit(void)
611 {
612 	i2c_del_driver(&tusb320_extcon_driver);
613 }
614 module_exit(tusb320_exit);
615 
616 MODULE_AUTHOR("Michael Auchter <michael.auchter@ni.com>");
617 MODULE_DESCRIPTION("TI TUSB320 extcon driver");
618 MODULE_LICENSE("GPL v2");
619