Lines Matching refs:bus
171 static int aspeed_i2c_reset(struct aspeed_i2c_bus *bus);
173 static int aspeed_i2c_recover_bus(struct aspeed_i2c_bus *bus)
179 spin_lock_irqsave(&bus->lock, flags);
180 command = readl(bus->base + ASPEED_I2C_CMD_REG);
186 dev_dbg(bus->dev, "SCL hung (state %x), attempting recovery\n",
189 reinit_completion(&bus->cmd_complete);
190 writel(ASPEED_I2CD_M_STOP_CMD, bus->base + ASPEED_I2C_CMD_REG);
191 spin_unlock_irqrestore(&bus->lock, flags);
194 &bus->cmd_complete, bus->adap.timeout);
196 spin_lock_irqsave(&bus->lock, flags);
199 else if (bus->cmd_err)
202 else if (!(readl(bus->base + ASPEED_I2C_CMD_REG) &
207 dev_dbg(bus->dev, "SDA hung (state %x), attempting recovery\n",
210 reinit_completion(&bus->cmd_complete);
213 bus->base + ASPEED_I2C_CMD_REG);
214 spin_unlock_irqrestore(&bus->lock, flags);
217 &bus->cmd_complete, bus->adap.timeout);
219 spin_lock_irqsave(&bus->lock, flags);
222 else if (bus->cmd_err)
225 else if (!(readl(bus->base + ASPEED_I2C_CMD_REG) &
231 spin_unlock_irqrestore(&bus->lock, flags);
236 spin_unlock_irqrestore(&bus->lock, flags);
238 return aspeed_i2c_reset(bus);
242 static u32 aspeed_i2c_slave_irq(struct aspeed_i2c_bus *bus, u32 irq_status)
245 struct i2c_client *slave = bus->slave;
260 bus->slave_state = ASPEED_I2C_SLAVE_STOP;
264 bus->slave_state == ASPEED_I2C_SLAVE_READ_PROCESSED) {
266 bus->slave_state = ASPEED_I2C_SLAVE_STOP;
270 if (bus->slave_state == ASPEED_I2C_SLAVE_STOP) {
272 bus->slave_state = ASPEED_I2C_SLAVE_INACTIVE;
281 bus->slave_state = ASPEED_I2C_SLAVE_START;
288 if (bus->slave_state == ASPEED_I2C_SLAVE_INACTIVE)
291 command = readl(bus->base + ASPEED_I2C_CMD_REG);
292 dev_dbg(bus->dev, "slave irq status 0x%08x, cmd 0x%08x\n",
297 value = readl(bus->base + ASPEED_I2C_BYTE_BUF_REG) >> 8;
299 if (bus->slave_state == ASPEED_I2C_SLAVE_START) {
301 bus->slave_state =
304 bus->slave_state =
310 switch (bus->slave_state) {
313 dev_err(bus->dev, "Unexpected ACK on read request.\n");
314 bus->slave_state = ASPEED_I2C_SLAVE_READ_PROCESSED;
316 writel(value, bus->base + ASPEED_I2C_BYTE_BUF_REG);
317 writel(ASPEED_I2CD_S_TX_CMD, bus->base + ASPEED_I2C_CMD_REG);
321 dev_err(bus->dev,
327 writel(value, bus->base + ASPEED_I2C_BYTE_BUF_REG);
328 writel(ASPEED_I2CD_S_TX_CMD, bus->base + ASPEED_I2C_CMD_REG);
331 bus->slave_state = ASPEED_I2C_SLAVE_WRITE_RECEIVED;
335 * returns an errno, the bus driver should nack the next incoming byte.
338 writel(ASPEED_I2CD_M_S_RX_CMD_LAST, bus->base + ASPEED_I2C_CMD_REG);
350 dev_err(bus->dev, "unknown slave_state: %d\n",
351 bus->slave_state);
352 bus->slave_state = ASPEED_I2C_SLAVE_INACTIVE;
360 /* precondition: bus.lock has been acquired. */
361 static void aspeed_i2c_do_start(struct aspeed_i2c_bus *bus)
364 struct i2c_msg *msg = &bus->msgs[bus->msgs_index];
371 * command when the bus comes back to the idle state.
373 if (bus->slave_state != ASPEED_I2C_SLAVE_INACTIVE) {
374 bus->master_state = ASPEED_I2C_MASTER_PENDING;
379 bus->master_state = ASPEED_I2C_MASTER_START;
380 bus->buf_index = 0;
389 writel(slave_addr, bus->base + ASPEED_I2C_BYTE_BUF_REG);
390 writel(command, bus->base + ASPEED_I2C_CMD_REG);
393 /* precondition: bus.lock has been acquired. */
394 static void aspeed_i2c_do_stop(struct aspeed_i2c_bus *bus)
396 bus->master_state = ASPEED_I2C_MASTER_STOP;
397 writel(ASPEED_I2CD_M_STOP_CMD, bus->base + ASPEED_I2C_CMD_REG);
400 /* precondition: bus.lock has been acquired. */
401 static void aspeed_i2c_next_msg_or_stop(struct aspeed_i2c_bus *bus)
403 if (bus->msgs_index + 1 < bus->msgs_count) {
404 bus->msgs_index++;
405 aspeed_i2c_do_start(bus);
407 aspeed_i2c_do_stop(bus);
424 static u32 aspeed_i2c_master_irq(struct aspeed_i2c_bus *bus, u32 irq_status)
432 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
444 dev_dbg(bus->dev, "received error interrupt: 0x%08x\n",
447 if (bus->master_state != ASPEED_I2C_MASTER_INACTIVE) {
448 bus->cmd_err = ret;
449 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
455 if (bus->master_state == ASPEED_I2C_MASTER_INACTIVE ||
456 bus->master_state == ASPEED_I2C_MASTER_PENDING)
459 /* We are in an invalid state; reset bus to a known state. */
460 if (!bus->msgs) {
461 dev_err(bus->dev, "bus in unknown state. irq_status: 0x%x\n",
463 bus->cmd_err = -EIO;
464 if (bus->master_state != ASPEED_I2C_MASTER_STOP &&
465 bus->master_state != ASPEED_I2C_MASTER_INACTIVE)
466 aspeed_i2c_do_stop(bus);
469 msg = &bus->msgs[bus->msgs_index];
476 if (bus->master_state == ASPEED_I2C_MASTER_START) {
486 writel(readl(bus->base + ASPEED_I2C_CMD_REG) &
488 bus->base + ASPEED_I2C_CMD_REG);
489 bus->master_state = ASPEED_I2C_MASTER_PENDING;
490 dev_dbg(bus->dev,
497 bus->cmd_err = -ENXIO;
498 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
503 bus->cmd_err = -ENXIO;
504 aspeed_i2c_do_stop(bus);
509 aspeed_i2c_do_stop(bus);
513 bus->master_state = ASPEED_I2C_MASTER_RX_FIRST;
515 bus->master_state = ASPEED_I2C_MASTER_TX_FIRST;
518 switch (bus->master_state) {
521 dev_dbg(bus->dev, "slave NACKed TX\n");
525 dev_err(bus->dev, "slave failed to ACK TX\n");
531 if (bus->buf_index < msg->len) {
532 bus->master_state = ASPEED_I2C_MASTER_TX;
533 writel(msg->buf[bus->buf_index++],
534 bus->base + ASPEED_I2C_BYTE_BUF_REG);
536 bus->base + ASPEED_I2C_CMD_REG);
538 aspeed_i2c_next_msg_or_stop(bus);
548 dev_err(bus->dev, "master failed to RX\n");
553 recv_byte = readl(bus->base + ASPEED_I2C_BYTE_BUF_REG) >> 8;
554 msg->buf[bus->buf_index++] = recv_byte;
558 bus->cmd_err = -EPROTO;
559 aspeed_i2c_do_stop(bus);
567 if (bus->buf_index < msg->len) {
568 bus->master_state = ASPEED_I2C_MASTER_RX;
570 if (bus->buf_index + 1 == msg->len)
572 writel(command, bus->base + ASPEED_I2C_CMD_REG);
574 aspeed_i2c_next_msg_or_stop(bus);
579 dev_err(bus->dev,
582 bus->cmd_err = -EIO;
588 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
591 dev_err(bus->dev,
594 bus->cmd_err = -EIO;
599 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
600 bus->cmd_err = -EINVAL;
604 bus->cmd_err = -EIO;
605 aspeed_i2c_do_stop(bus);
608 bus->msgs = NULL;
609 if (bus->cmd_err)
610 bus->master_xfer_result = bus->cmd_err;
612 bus->master_xfer_result = bus->msgs_index + 1;
613 complete(&bus->cmd_complete);
620 struct aspeed_i2c_bus *bus = dev_id;
623 spin_lock(&bus->lock);
624 irq_received = readl(bus->base + ASPEED_I2C_INTR_STS_REG);
627 bus->base + ASPEED_I2C_INTR_STS_REG);
628 readl(bus->base + ASPEED_I2C_INTR_STS_REG);
640 if (bus->master_state != ASPEED_I2C_MASTER_INACTIVE &&
641 bus->master_state != ASPEED_I2C_MASTER_PENDING) {
642 irq_handled = aspeed_i2c_master_irq(bus, irq_remaining);
645 irq_handled |= aspeed_i2c_slave_irq(bus, irq_remaining);
647 irq_handled = aspeed_i2c_slave_irq(bus, irq_remaining);
650 irq_handled |= aspeed_i2c_master_irq(bus,
658 if (bus->master_state == ASPEED_I2C_MASTER_PENDING &&
659 bus->slave_state == ASPEED_I2C_SLAVE_INACTIVE)
660 aspeed_i2c_do_start(bus);
662 irq_handled = aspeed_i2c_master_irq(bus, irq_remaining);
667 dev_err(bus->dev,
674 bus->base + ASPEED_I2C_INTR_STS_REG);
675 readl(bus->base + ASPEED_I2C_INTR_STS_REG);
677 spin_unlock(&bus->lock);
684 struct aspeed_i2c_bus *bus = i2c_get_adapdata(adap);
687 spin_lock_irqsave(&bus->lock, flags);
688 bus->cmd_err = 0;
690 /* If bus is busy in a single master environment, attempt recovery. */
691 if (!bus->multi_master &&
692 (readl(bus->base + ASPEED_I2C_CMD_REG) &
696 spin_unlock_irqrestore(&bus->lock, flags);
697 ret = aspeed_i2c_recover_bus(bus);
700 spin_lock_irqsave(&bus->lock, flags);
703 bus->cmd_err = 0;
704 bus->msgs = msgs;
705 bus->msgs_index = 0;
706 bus->msgs_count = num;
708 reinit_completion(&bus->cmd_complete);
709 aspeed_i2c_do_start(bus);
710 spin_unlock_irqrestore(&bus->lock, flags);
712 time_left = wait_for_completion_timeout(&bus->cmd_complete,
713 bus->adap.timeout);
718 * recovery. But if the bus is idle, we still need to reset the
721 if (bus->multi_master &&
722 (readl(bus->base + ASPEED_I2C_CMD_REG) &
724 aspeed_i2c_recover_bus(bus);
726 aspeed_i2c_reset(bus);
732 spin_lock_irqsave(&bus->lock, flags);
733 if (bus->master_state == ASPEED_I2C_MASTER_PENDING)
734 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
735 spin_unlock_irqrestore(&bus->lock, flags);
740 return bus->master_xfer_result;
749 /* precondition: bus.lock has been acquired. */
750 static void __aspeed_i2c_reg_slave(struct aspeed_i2c_bus *bus, u16 slave_addr)
759 * end up with additional phantom devices responding on the bus.
762 writel(addr_reg_val, bus->base + ASPEED_I2C_DEV_ADDR_REG);
765 func_ctrl_reg_val = readl(bus->base + ASPEED_I2C_FUN_CTRL_REG);
767 writel(func_ctrl_reg_val, bus->base + ASPEED_I2C_FUN_CTRL_REG);
769 bus->slave_state = ASPEED_I2C_SLAVE_INACTIVE;
774 struct aspeed_i2c_bus *bus = i2c_get_adapdata(client->adapter);
777 spin_lock_irqsave(&bus->lock, flags);
778 if (bus->slave) {
779 spin_unlock_irqrestore(&bus->lock, flags);
783 __aspeed_i2c_reg_slave(bus, client->addr);
785 bus->slave = client;
786 spin_unlock_irqrestore(&bus->lock, flags);
793 struct aspeed_i2c_bus *bus = i2c_get_adapdata(client->adapter);
797 spin_lock_irqsave(&bus->lock, flags);
798 if (!bus->slave) {
799 spin_unlock_irqrestore(&bus->lock, flags);
804 func_ctrl_reg_val = readl(bus->base + ASPEED_I2C_FUN_CTRL_REG);
806 writel(func_ctrl_reg_val, bus->base + ASPEED_I2C_FUN_CTRL_REG);
808 bus->slave = NULL;
809 spin_unlock_irqrestore(&bus->lock, flags);
909 /* precondition: bus.lock has been acquired. */
910 static int aspeed_i2c_init_clk(struct aspeed_i2c_bus *bus)
914 divisor = DIV_ROUND_UP(bus->parent_clk_frequency, bus->bus_frequency);
915 clk_reg_val = readl(bus->base + ASPEED_I2C_AC_TIMING_REG1);
919 clk_reg_val |= bus->get_clk_reg_val(bus->dev, divisor);
920 writel(clk_reg_val, bus->base + ASPEED_I2C_AC_TIMING_REG1);
921 writel(ASPEED_NO_TIMEOUT_CTRL, bus->base + ASPEED_I2C_AC_TIMING_REG2);
926 /* precondition: bus.lock has been acquired. */
927 static int aspeed_i2c_init(struct aspeed_i2c_bus *bus,
934 writel(0, bus->base + ASPEED_I2C_FUN_CTRL_REG);
936 ret = aspeed_i2c_init_clk(bus);
941 bus->multi_master = true;
946 writel(readl(bus->base + ASPEED_I2C_FUN_CTRL_REG) | fun_ctrl_reg,
947 bus->base + ASPEED_I2C_FUN_CTRL_REG);
951 if (bus->slave)
952 __aspeed_i2c_reg_slave(bus, bus->slave->addr);
956 writel(ASPEED_I2CD_INTR_ALL, bus->base + ASPEED_I2C_INTR_CTRL_REG);
961 static int aspeed_i2c_reset(struct aspeed_i2c_bus *bus)
963 struct platform_device *pdev = to_platform_device(bus->dev);
967 spin_lock_irqsave(&bus->lock, flags);
970 writel(0, bus->base + ASPEED_I2C_INTR_CTRL_REG);
971 writel(0xffffffff, bus->base + ASPEED_I2C_INTR_STS_REG);
973 ret = aspeed_i2c_init(bus, pdev);
975 spin_unlock_irqrestore(&bus->lock, flags);
982 .compatible = "aspeed,ast2400-i2c-bus",
986 .compatible = "aspeed,ast2500-i2c-bus",
990 .compatible = "aspeed,ast2600-i2c-bus",
1000 struct aspeed_i2c_bus *bus;
1004 bus = devm_kzalloc(&pdev->dev, sizeof(*bus), GFP_KERNEL);
1005 if (!bus)
1008 bus->base = devm_platform_get_and_ioremap_resource(pdev, 0, NULL);
1009 if (IS_ERR(bus->base))
1010 return PTR_ERR(bus->base);
1015 bus->parent_clk_frequency = clk_get_rate(parent_clk);
1019 bus->rst = devm_reset_control_get_shared(&pdev->dev, NULL);
1020 if (IS_ERR(bus->rst)) {
1023 return PTR_ERR(bus->rst);
1025 reset_control_deassert(bus->rst);
1028 "bus-frequency", &bus->bus_frequency);
1031 "Could not read bus-frequency property\n");
1032 bus->bus_frequency = I2C_MAX_STANDARD_MODE_FREQ;
1037 bus->get_clk_reg_val = aspeed_i2c_24xx_get_clk_reg_val;
1039 bus->get_clk_reg_val = (u32 (*)(struct device *, u32))
1043 spin_lock_init(&bus->lock);
1044 init_completion(&bus->cmd_complete);
1045 bus->adap.owner = THIS_MODULE;
1046 bus->adap.retries = 0;
1047 bus->adap.algo = &aspeed_i2c_algo;
1048 bus->adap.dev.parent = &pdev->dev;
1049 bus->adap.dev.of_node = pdev->dev.of_node;
1050 strscpy(bus->adap.name, pdev->name, sizeof(bus->adap.name));
1051 i2c_set_adapdata(&bus->adap, bus);
1053 bus->dev = &pdev->dev;
1056 writel(0, bus->base + ASPEED_I2C_INTR_CTRL_REG);
1057 writel(0xffffffff, bus->base + ASPEED_I2C_INTR_STS_REG);
1059 * bus.lock does not need to be held because the interrupt handler has
1062 ret = aspeed_i2c_init(bus, pdev);
1068 0, dev_name(&pdev->dev), bus);
1072 ret = i2c_add_adapter(&bus->adap);
1076 platform_set_drvdata(pdev, bus);
1078 dev_info(bus->dev, "i2c bus %d registered, irq %d\n",
1079 bus->adap.nr, irq);
1086 struct aspeed_i2c_bus *bus = platform_get_drvdata(pdev);
1089 spin_lock_irqsave(&bus->lock, flags);
1092 writel(0, bus->base + ASPEED_I2C_FUN_CTRL_REG);
1093 writel(0, bus->base + ASPEED_I2C_INTR_CTRL_REG);
1095 spin_unlock_irqrestore(&bus->lock, flags);
1097 reset_control_assert(bus->rst);
1099 i2c_del_adapter(&bus->adap);
1106 .name = "aspeed-i2c-bus",