Lines Matching refs:isp
113 static void enable_vbus_draw(struct isp1301 *isp, unsigned mA)
122 static void enable_vbus_draw(struct isp1301 *isp, unsigned mA)
132 static void enable_vbus_source(struct isp1301 *isp)
141 static inline void notresponding(struct isp1301 *isp)
154 isp1301_get_u8(struct isp1301 *isp, u8 reg)
156 return i2c_smbus_read_byte_data(isp->client, reg + 0);
160 isp1301_get_u16(struct isp1301 *isp, u8 reg)
162 return i2c_smbus_read_word_data(isp->client, reg);
166 isp1301_set_bits(struct isp1301 *isp, u8 reg, u8 bits)
168 return i2c_smbus_write_byte_data(isp->client, reg + 0, bits);
172 isp1301_clear_bits(struct isp1301 *isp, u8 reg, u8 bits)
174 return i2c_smbus_write_byte_data(isp->client, reg + 1, bits);
257 static inline const char *state_name(struct isp1301 *isp)
259 return state_string(isp->otg.state);
272 static void power_down(struct isp1301 *isp)
274 isp->otg.state = OTG_STATE_UNDEFINED;
276 // isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_GLOBAL_PWR_DN);
277 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND);
279 isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_ID_PULLDOWN);
280 isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
283 static void power_up(struct isp1301 *isp)
285 // isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_2, MC2_GLOBAL_PWR_DN);
286 isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND);
291 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
296 static int host_suspend(struct isp1301 *isp)
303 if (!isp->otg.host)
309 dev = isp->otg.host->controller;
314 static int host_resume(struct isp1301 *isp)
321 if (!isp->otg.host)
324 dev = isp->otg.host->controller;
329 static int gadget_suspend(struct isp1301 *isp)
331 isp->otg.gadget->b_hnp_enable = 0;
332 isp->otg.gadget->a_hnp_support = 0;
333 isp->otg.gadget->a_alt_hnp_support = 0;
334 return usb_gadget_vbus_disconnect(isp->otg.gadget);
346 static void isp1301_defer_work(struct isp1301 *isp, int work)
350 if (isp && !test_and_set_bit(work, &isp->todo)) {
351 (void) get_device(&isp->client->dev);
352 status = schedule_work(&isp->work);
353 if (!status && !isp->working)
354 dev_vdbg(&isp->client->dev,
360 static void a_idle(struct isp1301 *isp, const char *tag)
364 if (isp->otg.state == OTG_STATE_A_IDLE)
367 isp->otg.default_a = 1;
368 if (isp->otg.host) {
369 isp->otg.host->is_b_host = 0;
370 host_suspend(isp);
372 if (isp->otg.gadget) {
373 isp->otg.gadget->is_a_peripheral = 1;
374 gadget_suspend(isp);
376 isp->otg.state = OTG_STATE_A_IDLE;
379 isp->last_otg_ctrl = l;
380 pr_debug(" --> %s/%s\n", state_name(isp), tag);
384 static void b_idle(struct isp1301 *isp, const char *tag)
388 if (isp->otg.state == OTG_STATE_B_IDLE)
391 isp->otg.default_a = 0;
392 if (isp->otg.host) {
393 isp->otg.host->is_b_host = 1;
394 host_suspend(isp);
396 if (isp->otg.gadget) {
397 isp->otg.gadget->is_a_peripheral = 0;
398 gadget_suspend(isp);
400 isp->otg.state = OTG_STATE_B_IDLE;
403 isp->last_otg_ctrl = l;
404 pr_debug(" --> %s/%s\n", state_name(isp), tag);
408 dump_regs(struct isp1301 *isp, const char *label)
411 u8 ctrl = isp1301_get_u8(isp, ISP1301_OTG_CONTROL_1);
412 u8 status = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
413 u8 src = isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE);
416 omap_readl(OTG_CTRL), label, state_name(isp),
436 static void check_state(struct isp1301 *isp, const char *tag)
501 if (isp->otg.state == state && !extra)
504 state_string(state), fsm, state_name(isp),
510 static inline void check_state(struct isp1301 *isp, const char *tag) { }
515 static void update_otg1(struct isp1301 *isp, u8 int_src)
525 else if (isp->otg.state == OTG_STATE_A_WAIT_VFALL) {
526 a_idle(isp, "vfall");
532 if (isp->otg.state == OTG_STATE_B_IDLE
533 || isp->otg.state == OTG_STATE_UNDEFINED) {
534 a_idle(isp, "init");
539 if (isp->otg.state == OTG_STATE_A_IDLE
540 || isp->otg.state == OTG_STATE_UNDEFINED) {
541 b_idle(isp, "init");
549 static void update_otg2(struct isp1301 *isp, u8 otg_status)
564 static void otg_update_isp(struct isp1301 *isp)
570 otg_change = otg_ctrl ^ isp->last_otg_ctrl;
571 isp->last_otg_ctrl = otg_ctrl;
574 switch (isp->otg.state) {
580 if (isp->otg.gadget->b_hnp_enable) {
581 isp->otg.state = OTG_STATE_B_WAIT_ACON;
608 if (!(isp->otg.host))
611 switch (isp->otg.state) {
618 notresponding(isp);
622 isp->otg.state = OTG_STATE_A_WAIT_VFALL;
630 isp->otg.state = OTG_STATE_A_WAIT_VRISE;
643 isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, set);
644 isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, clr);
650 switch (isp->otg.state) {
654 isp->otg.state = OTG_STATE_B_PERIPHERAL;
660 isp->otg.state = OTG_STATE_A_PERIPHERAL;
671 check_state(isp, __func__);
672 dump_regs(isp, "otg->isp1301");
680 struct isp1301 *isp = _isp;
685 isp1301_defer_work(isp, WORK_UPDATE_ISP);
691 notresponding(isp);
697 if (isp->otg.state == OTG_STATE_B_SRP_INIT)
698 b_idle(isp, "srp_timeout");
706 state_name(isp), omap_readl(OTG_CTRL));
707 notresponding(isp);
715 isp->otg.state = OTG_STATE_B_PERIPHERAL;
724 state_name(isp), omap_readl(OTG_CTRL));
726 isp1301_defer_work(isp, WORK_UPDATE_OTG);
727 switch (isp->otg.state) {
729 if (!isp->otg.host)
731 isp1301_defer_work(isp, WORK_HOST_RESUME);
752 state_name(isp), otg_ctrl);
753 notresponding(isp);
758 isp->otg.state = OTG_STATE_A_WAIT_VFALL;
767 state_name(isp), otg_irq, otg_ctrl);
772 isp->otg.state = OTG_STATE_A_VBUS_ERR;
785 state_name(isp),
789 isp1301_defer_work(isp, WORK_UPDATE_ISP);
793 switch (isp->otg.state) {
795 b_idle(isp, __func__);
800 isp1301_defer_work(isp, WORK_UPDATE_ISP);
809 if (isp->otg.host) {
810 switch (isp->otg.state) {
812 isp->otg.state = OTG_STATE_B_HOST;
817 isp->otg.state = OTG_STATE_A_HOST;
821 isp->otg.state = OTG_STATE_A_WAIT_BCON;
827 isp1301_defer_work(isp, WORK_HOST_RESUME);
835 usb_bus_start_enum(isp->otg.host,
836 isp->otg.host->otg_port);
839 check_state(isp, __func__);
845 static int isp1301_otg_init(struct isp1301 *isp)
852 dump_regs(isp, __func__);
867 update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE));
868 update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS));
870 check_state(isp, __func__);
872 state_name(isp), __func__, omap_readl(OTG_CTRL));
908 static int otg_bind(struct isp1301 *isp)
921 IRQF_DISABLED, DRIVER_NAME, isp);
930 static void otg_unbind(struct isp1301 *isp)
934 free_irq(otg_dev->resource[1].start, isp);
945 static void b_peripheral(struct isp1301 *isp)
952 usb_gadget_vbus_connect(isp->otg.gadget);
955 enable_vbus_draw(isp, 8);
956 otg_update_isp(isp);
958 enable_vbus_draw(isp, 100);
960 isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_DP_PULLUP);
961 isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_DP_PULLDOWN);
962 isp->otg.state = OTG_STATE_B_PERIPHERAL;
964 dump_regs(isp, "2periph");
968 static void isp_update_otg(struct isp1301 *isp, u8 stat)
971 enum usb_otg_state state = isp->otg.state;
974 pr_debug("OTG: BDIS_ACON, %s\n", state_name(isp));
977 isp_stat = isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE);
979 if (isp->otg.default_a) {
982 a_idle(isp, "idle");
985 enable_vbus_source(isp);
994 isp->otg.state = OTG_STATE_A_HOST;
998 a_idle(isp, "vfell");
1002 isp->otg.state = OTG_STATE_A_VBUS_ERR;
1005 isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
1011 usb_gadget_vbus_disconnect(isp->otg.gadget);
1017 a_idle(isp, "id");
1018 if (isp->otg.host && state == OTG_STATE_A_IDLE)
1019 isp1301_defer_work(isp, WORK_HOST_RESUME);
1028 if (isp->otg.default_a) {
1031 isp->otg.state = OTG_STATE_A_WAIT_VFALL;
1041 host_suspend(isp);
1042 isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1,
1044 isp->otg.state = OTG_STATE_B_IDLE;
1053 isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
1055 switch (isp->otg.state) {
1061 enable_vbus_draw(isp, 0);
1064 isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1,
1066 isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1,
1068 dump_regs(isp, __func__);
1072 b_idle(isp, __func__);
1077 if (isp->otg.gadget && (isp_bstat & OTG_B_SESS_VLD)) {
1079 update_otg1(isp, isp_stat);
1080 update_otg2(isp, isp_bstat);
1082 b_peripheral(isp);
1090 state_name(isp));
1095 if (state != isp->otg.state)
1096 pr_debug(" isp, %s -> %s\n",
1097 state_string(state), state_name(isp));
1103 update_otg1(isp, isp_stat);
1104 update_otg2(isp, isp_bstat);
1105 check_state(isp, __func__);
1108 dump_regs(isp, "isp1301->otg");
1113 static u8 isp1301_clear_latch(struct isp1301 *isp)
1115 u8 latch = isp1301_get_u8(isp, ISP1301_INTERRUPT_LATCH);
1116 isp1301_clear_bits(isp, ISP1301_INTERRUPT_LATCH, latch);
1123 struct isp1301 *isp = container_of(work, struct isp1301, work);
1127 isp->working = 1;
1129 stop = test_bit(WORK_STOP, &isp->todo);
1133 if (test_and_clear_bit(WORK_UPDATE_ISP, &isp->todo)) {
1134 otg_update_isp(isp);
1135 put_device(&isp->client->dev);
1139 if (test_and_clear_bit(WORK_UPDATE_OTG, &isp->todo)) {
1140 u8 stat = isp1301_clear_latch(isp);
1142 isp_update_otg(isp, stat);
1143 put_device(&isp->client->dev);
1146 if (test_and_clear_bit(WORK_HOST_RESUME, &isp->todo)) {
1153 switch (isp->otg.state) {
1156 isp->otg.state = OTG_STATE_A_HOST;
1165 isp->otg.state = OTG_STATE_B_HOST;
1174 state_name(isp));
1176 host_resume(isp);
1178 put_device(&isp->client->dev);
1181 if (test_and_clear_bit(WORK_TIMER, &isp->todo)) {
1183 dump_regs(isp, "timer");
1185 mod_timer(&isp->timer, jiffies + TIMER_JIFFIES);
1187 put_device(&isp->client->dev);
1190 if (isp->todo)
1191 dev_vdbg(&isp->client->dev,
1193 isp->todo);
1195 dev_dbg(&isp->client->dev, "stop\n");
1198 } while (isp->todo);
1199 isp->working = 0;
1202 static irqreturn_t isp1301_irq(int irq, void *isp)
1204 isp1301_defer_work(isp, WORK_UPDATE_OTG);
1217 struct isp1301 *isp;
1219 isp = dev_get_drvdata(dev);
1223 if (isp->i2c_release)
1224 isp->i2c_release(dev);
1225 kfree (isp);
1232 struct isp1301 *isp;
1234 isp = i2c_get_clientdata(i2c);
1236 isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
1237 isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
1238 free_irq(i2c->irq, isp);
1240 otg_unbind(isp);
1245 isp->timer.data = 0;
1246 set_bit(WORK_STOP, &isp->todo);
1247 del_timer_sync(&isp->timer);
1273 static int isp1301_otg_enable(struct isp1301 *isp)
1275 power_up(isp);
1276 isp1301_otg_init(isp);
1281 isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
1283 isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
1286 dev_info(&isp->client->dev, "ready for dual-role USB ...\n");
1297 struct isp1301 *isp = container_of(otg, struct isp1301, otg);
1299 if (!otg || isp != the_transceiver)
1304 power_down(isp);
1305 isp->otg.host = NULL;
1310 isp->otg.host = host;
1311 dev_dbg(&isp->client->dev, "registered host\n");
1312 host_suspend(isp);
1313 if (isp->otg.gadget)
1314 return isp1301_otg_enable(isp);
1318 isp->otg.host = host;
1320 power_up(isp);
1323 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
1325 dev_info(&isp->client->dev, "A-Host sessions ok\n");
1326 isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
1328 isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
1336 isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_VBUS_DRV);
1338 dump_regs(isp, __func__);
1343 dev_dbg(&isp->client->dev, "host sessions not allowed\n");
1352 struct isp1301 *isp = container_of(otg, struct isp1301, otg);
1357 if (!otg || isp != the_transceiver)
1362 if (!isp->otg.default_a)
1363 enable_vbus_draw(isp, 0);
1364 usb_gadget_vbus_disconnect(isp->otg.gadget);
1365 isp->otg.gadget = NULL;
1366 power_down(isp);
1371 isp->otg.gadget = gadget;
1372 dev_dbg(&isp->client->dev, "registered gadget\n");
1374 if (isp->otg.host)
1375 return isp1301_otg_enable(isp);
1379 isp->otg.gadget = gadget;
1386 power_up(isp);
1387 isp->otg.state = OTG_STATE_B_IDLE;
1390 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
1392 isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
1394 isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
1396 dev_info(&isp->client->dev, "B-Peripheral sessions ok\n");
1397 dump_regs(isp, __func__);
1403 if (isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE) & INTR_VBUS_VLD)
1404 b_peripheral(isp);
1409 dev_dbg(&isp->client->dev, "peripheral sessions not allowed\n");
1430 struct isp1301 *isp = container_of(dev, struct isp1301, otg);
1433 if (!dev || isp != the_transceiver
1434 || isp->otg.state != OTG_STATE_B_IDLE)
1444 isp->otg.state = OTG_STATE_B_SRP_INIT;
1446 pr_debug("otg: SRP, %s ... %06x\n", state_name(isp),
1449 check_state(isp, __func__);
1458 struct isp1301 *isp = container_of(dev, struct isp1301, otg);
1461 if (!dev || isp != the_transceiver)
1463 if (isp->otg.default_a && (isp->otg.host == NULL
1464 || !isp->otg.host->b_hnp_enable))
1466 if (!isp->otg.default_a && (isp->otg.gadget == NULL
1467 || !isp->otg.gadget->b_hnp_enable))
1473 switch (isp->otg.state) {
1475 isp->otg.state = OTG_STATE_B_PERIPHERAL;
1480 usb_gadget_vbus_connect(isp->otg.gadget);
1493 state_name(isp), omap_readl(OTG_CTRL));
1494 check_state(isp, __func__);
1508 struct isp1301 *isp;
1513 isp = kzalloc(sizeof *isp, GFP_KERNEL);
1514 if (!isp)
1517 INIT_WORK(&isp->work, isp1301_work);
1518 init_timer(&isp->timer);
1519 isp->timer.function = isp1301_timer;
1520 isp->timer.data = (unsigned long) isp;
1522 i2c_set_clientdata(i2c, isp);
1523 isp->client = i2c;
1526 status = isp1301_get_u16(isp, ISP1301_VENDOR_ID);
1531 status = isp1301_get_u16(isp, ISP1301_PRODUCT_ID);
1536 isp->i2c_release = i2c->dev.release;
1545 isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_MASK);
1547 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_BI_DI);
1548 isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_2, ~MC2_BI_DI);
1550 isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1,
1552 isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1,
1555 isp1301_clear_bits(isp, ISP1301_INTERRUPT_LATCH, ~0);
1556 isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
1557 isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
1560 status = otg_bind(isp);
1569 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1,
1571 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2,
1578 isp->irq_type = IRQF_TRIGGER_FALLING;
1581 isp->irq_type |= IRQF_SAMPLE_RANDOM;
1583 isp->irq_type, DRIVER_NAME, isp);
1590 isp->otg.dev = &i2c->dev;
1591 isp->otg.label = DRIVER_NAME;
1593 isp->otg.set_host = isp1301_set_host,
1594 isp->otg.set_peripheral = isp1301_set_peripheral,
1595 isp->otg.set_power = isp1301_set_power,
1596 isp->otg.start_srp = isp1301_start_srp,
1597 isp->otg.start_hnp = isp1301_start_hnp,
1599 enable_vbus_draw(isp, 0);
1600 power_down(isp);
1601 the_transceiver = isp;
1604 update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE));
1605 update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS));
1608 dump_regs(isp, __func__);
1611 mod_timer(&isp->timer, jiffies + TIMER_JIFFIES);
1615 status = otg_set_transceiver(&isp->otg);
1623 kfree(isp);