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
tusb320_check_signature(struct tusb320_priv * priv)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
tusb320_set_mode(struct tusb320_priv * priv,enum tusb320_mode mode)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
tusb320l_set_mode(struct tusb320_priv * priv,enum tusb320_mode mode)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
tusb320_reset(struct tusb320_priv * priv)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
tusb320l_get_revision(struct tusb320_priv * priv,unsigned int * revision)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
tusb320_set_adv_pwr_mode(struct tusb320_priv * priv)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
tusb320_port_type_set(struct typec_port * port,enum typec_port_type type)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
tusb320_extcon_irq_handler(struct tusb320_priv * priv,u8 reg)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
tusb320_typec_irq_handler(struct tusb320_priv * priv,u8 reg9)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, ®8);
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
tusb320_state_update_handler(struct tusb320_priv * priv,bool force_update)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, ®)) {
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
tusb320_irq_handler(int irq,void * dev_id)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
tusb320_extcon_probe(struct tusb320_priv * priv)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
tusb320_typec_probe(struct i2c_client * client,struct tusb320_priv * priv)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
tusb320_typec_remove(struct tusb320_priv * priv)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
tusb320_probe(struct i2c_client * client)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
tusb320_remove(struct i2c_client * client)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
tusb320_init(void)604 static int __init tusb320_init(void)
605 {
606 return i2c_add_driver(&tusb320_extcon_driver);
607 }
608 subsys_initcall(tusb320_init);
609
tusb320_exit(void)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