Lines Matching refs:isp
116 static void enable_vbus_draw(struct isp1301 *isp, unsigned mA)
123 static void enable_vbus_source(struct isp1301 *isp)
132 static inline void notresponding(struct isp1301 *isp)
155 isp1301_get_u8(struct isp1301 *isp, u8 reg)
157 return i2c_smbus_read_byte_data(&isp->client, reg + 0);
161 isp1301_get_u16(struct isp1301 *isp, u8 reg)
163 return i2c_smbus_read_word_data(&isp->client, reg);
167 isp1301_set_bits(struct isp1301 *isp, u8 reg, u8 bits)
169 return i2c_smbus_write_byte_data(&isp->client, reg + 0, bits);
173 isp1301_clear_bits(struct isp1301 *isp, u8 reg, u8 bits)
175 return i2c_smbus_write_byte_data(&isp->client, reg + 1, bits);
258 static inline const char *state_name(struct isp1301 *isp)
260 return state_string(isp->otg.state);
279 static void power_down(struct isp1301 *isp)
281 isp->otg.state = OTG_STATE_UNDEFINED;
283 // isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_GLOBAL_PWR_DN);
284 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND_REG);
286 isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_ID_PULLDOWN);
287 isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
290 static void power_up(struct isp1301 *isp)
292 // isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_2, MC2_GLOBAL_PWR_DN);
293 isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND_REG);
298 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
303 static int host_suspend(struct isp1301 *isp)
310 if (!isp->otg.host)
316 dev = isp->otg.host->controller;
321 static int host_resume(struct isp1301 *isp)
328 if (!isp->otg.host)
331 dev = isp->otg.host->controller;
336 static int gadget_suspend(struct isp1301 *isp)
338 isp->otg.gadget->b_hnp_enable = 0;
339 isp->otg.gadget->a_hnp_support = 0;
340 isp->otg.gadget->a_alt_hnp_support = 0;
341 return usb_gadget_vbus_disconnect(isp->otg.gadget);
354 isp1301_defer_work(struct isp1301 *isp, int work)
358 if (isp && !test_and_set_bit(work, &isp->todo)) {
359 (void) get_device(&isp->client.dev);
360 status = schedule_work(&isp->work);
361 if (!status && !isp->working)
362 dev_vdbg(&isp->client.dev,
368 static void a_idle(struct isp1301 *isp, const char *tag)
370 if (isp->otg.state == OTG_STATE_A_IDLE)
373 isp->otg.default_a = 1;
374 if (isp->otg.host) {
375 isp->otg.host->is_b_host = 0;
376 host_suspend(isp);
378 if (isp->otg.gadget) {
379 isp->otg.gadget->is_a_peripheral = 1;
380 gadget_suspend(isp);
382 isp->otg.state = OTG_STATE_A_IDLE;
383 isp->last_otg_ctrl = OTG_CTRL_REG = OTG_CTRL_REG & OTG_XCEIV_OUTPUTS;
384 pr_debug(" --> %s/%s\n", state_name(isp), tag);
388 static void b_idle(struct isp1301 *isp, const char *tag)
390 if (isp->otg.state == OTG_STATE_B_IDLE)
393 isp->otg.default_a = 0;
394 if (isp->otg.host) {
395 isp->otg.host->is_b_host = 1;
396 host_suspend(isp);
398 if (isp->otg.gadget) {
399 isp->otg.gadget->is_a_peripheral = 0;
400 gadget_suspend(isp);
402 isp->otg.state = OTG_STATE_B_IDLE;
403 isp->last_otg_ctrl = OTG_CTRL_REG = OTG_CTRL_REG & OTG_XCEIV_OUTPUTS;
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 OTG_CTRL_REG, 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), OTG_CTRL_REG);
509 static inline void check_state(struct isp1301 *isp, const char *tag) { }
514 static void update_otg1(struct isp1301 *isp, u8 int_src)
524 else if (isp->otg.state == OTG_STATE_A_WAIT_VFALL) {
525 a_idle(isp, "vfall");
531 if (isp->otg.state == OTG_STATE_B_IDLE
532 || isp->otg.state == OTG_STATE_UNDEFINED) {
533 a_idle(isp, "init");
538 if (isp->otg.state == OTG_STATE_A_IDLE
539 || isp->otg.state == OTG_STATE_UNDEFINED) {
540 b_idle(isp, "init");
548 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);
648 switch (isp->otg.state) {
652 isp->otg.state = OTG_STATE_B_PERIPHERAL;
658 isp->otg.state = OTG_STATE_A_PERIPHERAL;
667 check_state(isp, __FUNCTION__);
668 dump_regs(isp, "otg->isp1301");
676 struct isp1301 *isp = _isp;
681 isp1301_defer_work(isp, WORK_UPDATE_ISP);
687 notresponding(isp);
693 if (isp->otg.state == OTG_STATE_B_SRP_INIT)
694 b_idle(isp, "srp_timeout");
702 state_name(isp), OTG_CTRL_REG);
703 notresponding(isp);
711 isp->otg.state = OTG_STATE_B_PERIPHERAL;
720 state_name(isp), OTG_CTRL_REG);
722 isp1301_defer_work(isp, WORK_UPDATE_OTG);
723 switch (isp->otg.state) {
725 if (!isp->otg.host)
727 isp1301_defer_work(isp, WORK_HOST_RESUME);
748 state_name(isp), otg_ctrl);
749 notresponding(isp);
754 isp->otg.state = OTG_STATE_A_WAIT_VFALL;
763 state_name(isp), otg_irq, otg_ctrl);
768 isp->otg.state = OTG_STATE_A_VBUS_ERR;
781 state_name(isp),
785 isp1301_defer_work(isp, WORK_UPDATE_ISP);
789 switch (isp->otg.state) {
791 b_idle(isp, __FUNCTION__);
796 isp1301_defer_work(isp, WORK_UPDATE_ISP);
805 if (isp->otg.host) {
806 switch (isp->otg.state) {
808 isp->otg.state = OTG_STATE_B_HOST;
813 isp->otg.state = OTG_STATE_A_HOST;
817 isp->otg.state = OTG_STATE_A_WAIT_BCON;
823 isp1301_defer_work(isp, WORK_HOST_RESUME);
831 usb_bus_start_enum(isp->otg.host,
832 isp->otg.host->otg_port);
835 check_state(isp, __FUNCTION__);
841 static int otg_init(struct isp1301 *isp)
846 dump_regs(isp, __FUNCTION__);
859 update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE));
860 update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS));
862 check_state(isp, __FUNCTION__);
864 state_name(isp), __FUNCTION__, OTG_CTRL_REG);
897 static int otg_bind(struct isp1301 *isp)
910 IRQF_DISABLED, DRIVER_NAME, isp);
919 static void otg_unbind(struct isp1301 *isp)
923 free_irq(otg_dev->resource[1].start, isp);
934 static void b_peripheral(struct isp1301 *isp)
937 usb_gadget_vbus_connect(isp->otg.gadget);
940 enable_vbus_draw(isp, 8);
941 otg_update_isp(isp);
943 enable_vbus_draw(isp, 100);
945 isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_DP_PULLUP);
946 isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_DP_PULLDOWN);
947 isp->otg.state = OTG_STATE_B_PERIPHERAL;
949 dump_regs(isp, "2periph");
953 static void isp_update_otg(struct isp1301 *isp, u8 stat)
956 enum usb_otg_state state = isp->otg.state;
959 pr_debug("OTG: BDIS_ACON, %s\n", state_name(isp));
962 isp_stat = isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE);
964 if (isp->otg.default_a) {
967 a_idle(isp, "idle");
970 enable_vbus_source(isp);
979 isp->otg.state = OTG_STATE_A_HOST;
983 a_idle(isp, "vfell");
987 isp->otg.state = OTG_STATE_A_VBUS_ERR;
990 isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
996 usb_gadget_vbus_disconnect(isp->otg.gadget);
1002 a_idle(isp, "id");
1003 if (isp->otg.host && state == OTG_STATE_A_IDLE)
1004 isp1301_defer_work(isp, WORK_HOST_RESUME);
1011 if (isp->otg.default_a) {
1014 isp->otg.state = OTG_STATE_A_WAIT_VFALL;
1024 host_suspend(isp);
1025 isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1,
1027 isp->otg.state = OTG_STATE_B_IDLE;
1035 isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
1037 switch (isp->otg.state) {
1043 enable_vbus_draw(isp, 0);
1046 isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1,
1048 isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1,
1050 dump_regs(isp, __FUNCTION__);
1054 b_idle(isp, __FUNCTION__);
1058 if (isp->otg.gadget && (isp_bstat & OTG_B_SESS_VLD)) {
1060 update_otg1(isp, isp_stat);
1061 update_otg2(isp, isp_bstat);
1063 b_peripheral(isp);
1071 state_name(isp));
1076 if (state != isp->otg.state)
1077 pr_debug(" isp, %s -> %s\n",
1078 state_string(state), state_name(isp));
1084 update_otg1(isp, isp_stat);
1085 update_otg2(isp, isp_bstat);
1086 check_state(isp, __FUNCTION__);
1089 dump_regs(isp, "isp1301->otg");
1094 static u8 isp1301_clear_latch(struct isp1301 *isp)
1096 u8 latch = isp1301_get_u8(isp, ISP1301_INTERRUPT_LATCH);
1097 isp1301_clear_bits(isp, ISP1301_INTERRUPT_LATCH, latch);
1104 struct isp1301 *isp = data;
1108 isp->working = 1;
1110 stop = test_bit(WORK_STOP, &isp->todo);
1114 if (test_and_clear_bit(WORK_UPDATE_ISP, &isp->todo)) {
1115 otg_update_isp(isp);
1116 put_device(&isp->client.dev);
1120 if (test_and_clear_bit(WORK_UPDATE_OTG, &isp->todo)) {
1121 u8 stat = isp1301_clear_latch(isp);
1123 isp_update_otg(isp, stat);
1124 put_device(&isp->client.dev);
1127 if (test_and_clear_bit(WORK_HOST_RESUME, &isp->todo)) {
1134 switch (isp->otg.state) {
1137 isp->otg.state = OTG_STATE_A_HOST;
1146 isp->otg.state = OTG_STATE_B_HOST;
1155 state_name(isp));
1157 host_resume(isp);
1159 put_device(&isp->client.dev);
1162 if (test_and_clear_bit(WORK_TIMER, &isp->todo)) {
1164 dump_regs(isp, "timer");
1166 mod_timer(&isp->timer, jiffies + TIMER_JIFFIES);
1168 put_device(&isp->client.dev);
1171 if (isp->todo)
1172 dev_vdbg(&isp->client.dev,
1174 isp->todo);
1176 dev_dbg(&isp->client.dev, "stop\n");
1179 } while (isp->todo);
1180 isp->working = 0;
1183 static irqreturn_t isp1301_irq(int irq, void *isp)
1185 isp1301_defer_work(isp, WORK_UPDATE_OTG);
1198 struct isp1301 *isp;
1200 isp = container_of(dev, struct isp1301, client.dev);
1203 if (isp->i2c_release)
1204 isp->i2c_release(dev);
1205 kfree (isp);
1212 struct isp1301 *isp;
1214 isp = container_of(i2c, struct isp1301, client);
1216 isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
1217 isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
1218 free_irq(isp->irq, isp);
1220 otg_unbind(isp);
1225 isp->timer.data = 0;
1226 set_bit(WORK_STOP, &isp->todo);
1227 del_timer_sync(&isp->timer);
1253 static int isp1301_otg_enable(struct isp1301 *isp)
1255 power_up(isp);
1256 otg_init(isp);
1261 isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
1263 isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
1266 dev_info(&isp->client.dev, "ready for dual-role USB ...\n");
1277 struct isp1301 *isp = container_of(otg, struct isp1301, otg);
1279 if (!otg || isp != the_transceiver)
1284 power_down(isp);
1285 isp->otg.host = 0;
1290 isp->otg.host = host;
1291 dev_dbg(&isp->client.dev, "registered host\n");
1292 host_suspend(isp);
1293 if (isp->otg.gadget)
1294 return isp1301_otg_enable(isp);
1298 isp->otg.host = host;
1300 power_up(isp);
1303 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
1305 dev_info(&isp->client.dev, "A-Host sessions ok\n");
1306 isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
1308 isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
1316 isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_VBUS_DRV);
1318 dump_regs(isp, __FUNCTION__);
1323 dev_dbg(&isp->client.dev, "host sessions not allowed\n");
1332 struct isp1301 *isp = container_of(otg, struct isp1301, otg);
1334 if (!otg || isp != the_transceiver)
1339 if (!isp->otg.default_a)
1340 enable_vbus_draw(isp, 0);
1341 usb_gadget_vbus_disconnect(isp->otg.gadget);
1342 isp->otg.gadget = 0;
1343 power_down(isp);
1348 isp->otg.gadget = gadget;
1349 dev_dbg(&isp->client.dev, "registered gadget\n");
1351 if (isp->otg.host)
1352 return isp1301_otg_enable(isp);
1356 isp->otg.gadget = gadget;
1361 power_up(isp);
1362 isp->otg.state = OTG_STATE_B_IDLE;
1365 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
1367 isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
1369 isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
1371 dev_info(&isp->client.dev, "B-Peripheral sessions ok\n");
1372 dump_regs(isp, __FUNCTION__);
1378 if (isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE) & INTR_VBUS_VLD)
1379 b_peripheral(isp);
1384 dev_dbg(&isp->client.dev, "peripheral sessions not allowed\n");
1405 struct isp1301 *isp = container_of(dev, struct isp1301, otg);
1408 if (!dev || isp != the_transceiver
1409 || isp->otg.state != OTG_STATE_B_IDLE)
1419 isp->otg.state = OTG_STATE_B_SRP_INIT;
1421 pr_debug("otg: SRP, %s ... %06x\n", state_name(isp), OTG_CTRL_REG);
1423 check_state(isp, __FUNCTION__);
1432 struct isp1301 *isp = container_of(dev, struct isp1301, otg);
1434 if (!dev || isp != the_transceiver)
1436 if (isp->otg.default_a && (isp->otg.host == NULL
1437 || !isp->otg.host->b_hnp_enable))
1439 if (!isp->otg.default_a && (isp->otg.gadget == NULL
1440 || !isp->otg.gadget->b_hnp_enable))
1446 switch (isp->otg.state) {
1448 isp->otg.state = OTG_STATE_B_PERIPHERAL;
1453 usb_gadget_vbus_connect(isp->otg.gadget);
1464 state_name(isp), OTG_CTRL_REG);
1465 check_state(isp, __FUNCTION__);
1479 struct isp1301 *isp;
1485 isp = kzalloc(sizeof *isp, GFP_KERNEL);
1486 if (!isp)
1489 INIT_WORK(&isp->work, isp1301_work, isp);
1490 init_timer(&isp->timer);
1491 isp->timer.function = isp1301_timer;
1492 isp->timer.data = (unsigned long) isp;
1494 isp->irq = -1;
1495 isp->client.addr = address;
1496 i2c_set_clientdata(&isp->client, isp);
1497 isp->client.adapter = bus;
1498 isp->client.driver = &isp1301_driver;
1499 strlcpy(isp->client.name, DRIVER_NAME, I2C_NAME_SIZE);
1500 i2c = &isp->client;
1504 status = isp1301_get_u16(isp, ISP1301_VENDOR_ID);
1510 status = isp1301_get_u16(isp, ISP1301_PRODUCT_ID);
1523 kfree(isp);
1526 isp->i2c_release = i2c->dev.release;
1535 isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_MASK);
1537 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_BI_DI);
1538 isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_2, ~MC2_BI_DI);
1540 isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1,
1542 isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1,
1545 isp1301_clear_bits(isp, ISP1301_INTERRUPT_LATCH, ~0);
1546 isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
1547 isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
1550 status = otg_bind(isp);
1559 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1,
1561 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2,
1566 isp->irq = OMAP_GPIO_IRQ(2);
1572 status = request_irq(isp->irq, isp1301_irq,
1573 IRQF_SAMPLE_RANDOM, DRIVER_NAME, isp);
1576 isp->irq, status);
1584 isp->otg.dev = &isp->client.dev;
1585 isp->otg.label = DRIVER_NAME;
1587 isp->otg.set_host = isp1301_set_host,
1588 isp->otg.set_peripheral = isp1301_set_peripheral,
1589 isp->otg.set_power = isp1301_set_power,
1590 isp->otg.start_srp = isp1301_start_srp,
1591 isp->otg.start_hnp = isp1301_start_hnp,
1593 enable_vbus_draw(isp, 0);
1594 power_down(isp);
1595 the_transceiver = isp;
1598 update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE));
1599 update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS));
1602 dump_regs(isp, __FUNCTION__);
1605 mod_timer(&isp->timer, jiffies + TIMER_JIFFIES);
1609 status = otg_set_transceiver(&isp->otg);