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) {
449 bus->cmd_err = ret;
450 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
456 if (bus->master_state == ASPEED_I2C_MASTER_INACTIVE ||
457 bus->master_state == ASPEED_I2C_MASTER_PENDING)
460 /* We are in an invalid state; reset bus to a known state. */
461 if (!bus->msgs) {
462 dev_err(bus->dev, "bus in unknown state. irq_status: 0x%x\n",
464 bus->cmd_err = -EIO;
465 if (bus->master_state != ASPEED_I2C_MASTER_STOP &&
466 bus->master_state != ASPEED_I2C_MASTER_INACTIVE)
467 aspeed_i2c_do_stop(bus);
470 msg = &bus->msgs[bus->msgs_index];
477 if (bus->master_state == ASPEED_I2C_MASTER_START) {
487 writel(readl(bus->base + ASPEED_I2C_CMD_REG) &
489 bus->base + ASPEED_I2C_CMD_REG);
490 bus->master_state = ASPEED_I2C_MASTER_PENDING;
491 dev_dbg(bus->dev,
498 bus->cmd_err = -ENXIO;
499 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
504 bus->cmd_err = -ENXIO;
505 aspeed_i2c_do_stop(bus);
510 aspeed_i2c_do_stop(bus);
514 bus->master_state = ASPEED_I2C_MASTER_RX_FIRST;
516 bus->master_state = ASPEED_I2C_MASTER_TX_FIRST;
519 switch (bus->master_state) {
522 dev_dbg(bus->dev, "slave NACKed TX\n");
526 dev_err(bus->dev, "slave failed to ACK TX\n");
532 if (bus->buf_index < msg->len) {
533 bus->master_state = ASPEED_I2C_MASTER_TX;
534 writel(msg->buf[bus->buf_index++],
535 bus->base + ASPEED_I2C_BYTE_BUF_REG);
537 bus->base + ASPEED_I2C_CMD_REG);
539 aspeed_i2c_next_msg_or_stop(bus);
549 dev_err(bus->dev, "master failed to RX\n");
554 recv_byte = readl(bus->base + ASPEED_I2C_BYTE_BUF_REG) >> 8;
555 msg->buf[bus->buf_index++] = recv_byte;
559 bus->cmd_err = -EPROTO;
560 aspeed_i2c_do_stop(bus);
568 if (bus->buf_index < msg->len) {
569 bus->master_state = ASPEED_I2C_MASTER_RX;
571 if (bus->buf_index + 1 == msg->len)
573 writel(command, bus->base + ASPEED_I2C_CMD_REG);
575 aspeed_i2c_next_msg_or_stop(bus);
580 dev_err(bus->dev,
583 bus->cmd_err = -EIO;
589 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
592 dev_err(bus->dev,
595 bus->cmd_err = -EIO;
600 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
601 bus->cmd_err = -EINVAL;
605 bus->cmd_err = -EIO;
606 aspeed_i2c_do_stop(bus);
609 bus->msgs = NULL;
610 if (bus->cmd_err)
611 bus->master_xfer_result = bus->cmd_err;
613 bus->master_xfer_result = bus->msgs_index + 1;
614 complete(&bus->cmd_complete);
621 struct aspeed_i2c_bus *bus = dev_id;
624 spin_lock(&bus->lock);
625 irq_received = readl(bus->base + ASPEED_I2C_INTR_STS_REG);
628 bus->base + ASPEED_I2C_INTR_STS_REG);
629 readl(bus->base + ASPEED_I2C_INTR_STS_REG);
641 if (bus->master_state != ASPEED_I2C_MASTER_INACTIVE &&
642 bus->master_state != ASPEED_I2C_MASTER_PENDING) {
643 irq_handled = aspeed_i2c_master_irq(bus, irq_remaining);
646 irq_handled |= aspeed_i2c_slave_irq(bus, irq_remaining);
648 irq_handled = aspeed_i2c_slave_irq(bus, irq_remaining);
651 irq_handled |= aspeed_i2c_master_irq(bus,
659 if (bus->master_state == ASPEED_I2C_MASTER_PENDING &&
660 bus->slave_state == ASPEED_I2C_SLAVE_INACTIVE)
661 aspeed_i2c_do_start(bus);
663 irq_handled = aspeed_i2c_master_irq(bus, irq_remaining);
668 dev_err(bus->dev,
675 bus->base + ASPEED_I2C_INTR_STS_REG);
676 readl(bus->base + ASPEED_I2C_INTR_STS_REG);
678 spin_unlock(&bus->lock);
685 struct aspeed_i2c_bus *bus = i2c_get_adapdata(adap);
688 spin_lock_irqsave(&bus->lock, flags);
689 bus->cmd_err = 0;
691 /* If bus is busy in a single master environment, attempt recovery. */
692 if (!bus->multi_master &&
693 (readl(bus->base + ASPEED_I2C_CMD_REG) &
697 spin_unlock_irqrestore(&bus->lock, flags);
698 ret = aspeed_i2c_recover_bus(bus);
701 spin_lock_irqsave(&bus->lock, flags);
704 bus->cmd_err = 0;
705 bus->msgs = msgs;
706 bus->msgs_index = 0;
707 bus->msgs_count = num;
709 reinit_completion(&bus->cmd_complete);
710 aspeed_i2c_do_start(bus);
711 spin_unlock_irqrestore(&bus->lock, flags);
713 time_left = wait_for_completion_timeout(&bus->cmd_complete,
714 bus->adap.timeout);
719 * recovery. But if the bus is idle, we still need to reset the
722 if (bus->multi_master &&
723 (readl(bus->base + ASPEED_I2C_CMD_REG) &
725 aspeed_i2c_recover_bus(bus);
727 aspeed_i2c_reset(bus);
733 spin_lock_irqsave(&bus->lock, flags);
734 if (bus->master_state == ASPEED_I2C_MASTER_PENDING)
735 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
736 spin_unlock_irqrestore(&bus->lock, flags);
741 return bus->master_xfer_result;
750 /* precondition: bus.lock has been acquired. */
751 static void __aspeed_i2c_reg_slave(struct aspeed_i2c_bus *bus, u16 slave_addr)
760 * end up with additional phantom devices responding on the bus.
763 writel(addr_reg_val, bus->base + ASPEED_I2C_DEV_ADDR_REG);
766 func_ctrl_reg_val = readl(bus->base + ASPEED_I2C_FUN_CTRL_REG);
768 writel(func_ctrl_reg_val, bus->base + ASPEED_I2C_FUN_CTRL_REG);
770 bus->slave_state = ASPEED_I2C_SLAVE_INACTIVE;
775 struct aspeed_i2c_bus *bus = i2c_get_adapdata(client->adapter);
778 spin_lock_irqsave(&bus->lock, flags);
779 if (bus->slave) {
780 spin_unlock_irqrestore(&bus->lock, flags);
784 __aspeed_i2c_reg_slave(bus, client->addr);
786 bus->slave = client;
787 spin_unlock_irqrestore(&bus->lock, flags);
794 struct aspeed_i2c_bus *bus = i2c_get_adapdata(client->adapter);
798 spin_lock_irqsave(&bus->lock, flags);
799 if (!bus->slave) {
800 spin_unlock_irqrestore(&bus->lock, flags);
805 func_ctrl_reg_val = readl(bus->base + ASPEED_I2C_FUN_CTRL_REG);
807 writel(func_ctrl_reg_val, bus->base + ASPEED_I2C_FUN_CTRL_REG);
809 bus->slave = NULL;
810 spin_unlock_irqrestore(&bus->lock, flags);
910 /* precondition: bus.lock has been acquired. */
911 static int aspeed_i2c_init_clk(struct aspeed_i2c_bus *bus)
915 divisor = DIV_ROUND_UP(bus->parent_clk_frequency, bus->bus_frequency);
916 clk_reg_val = readl(bus->base + ASPEED_I2C_AC_TIMING_REG1);
920 clk_reg_val |= bus->get_clk_reg_val(bus->dev, divisor);
921 writel(clk_reg_val, bus->base + ASPEED_I2C_AC_TIMING_REG1);
922 writel(ASPEED_NO_TIMEOUT_CTRL, bus->base + ASPEED_I2C_AC_TIMING_REG2);
927 /* precondition: bus.lock has been acquired. */
928 static int aspeed_i2c_init(struct aspeed_i2c_bus *bus,
935 writel(0, bus->base + ASPEED_I2C_FUN_CTRL_REG);
937 ret = aspeed_i2c_init_clk(bus);
942 bus->multi_master = true;
947 writel(readl(bus->base + ASPEED_I2C_FUN_CTRL_REG) | fun_ctrl_reg,
948 bus->base + ASPEED_I2C_FUN_CTRL_REG);
952 if (bus->slave)
953 __aspeed_i2c_reg_slave(bus, bus->slave->addr);
957 writel(ASPEED_I2CD_INTR_ALL, bus->base + ASPEED_I2C_INTR_CTRL_REG);
962 static int aspeed_i2c_reset(struct aspeed_i2c_bus *bus)
964 struct platform_device *pdev = to_platform_device(bus->dev);
968 spin_lock_irqsave(&bus->lock, flags);
971 writel(0, bus->base + ASPEED_I2C_INTR_CTRL_REG);
972 writel(0xffffffff, bus->base + ASPEED_I2C_INTR_STS_REG);
974 ret = aspeed_i2c_init(bus, pdev);
976 spin_unlock_irqrestore(&bus->lock, flags);
983 .compatible = "aspeed,ast2400-i2c-bus",
987 .compatible = "aspeed,ast2500-i2c-bus",
991 .compatible = "aspeed,ast2600-i2c-bus",
1001 struct aspeed_i2c_bus *bus;
1005 bus = devm_kzalloc(&pdev->dev, sizeof(*bus), GFP_KERNEL);
1006 if (!bus)
1009 bus->base = devm_platform_get_and_ioremap_resource(pdev, 0, NULL);
1010 if (IS_ERR(bus->base))
1011 return PTR_ERR(bus->base);
1016 bus->parent_clk_frequency = clk_get_rate(parent_clk);
1020 bus->rst = devm_reset_control_get_shared(&pdev->dev, NULL);
1021 if (IS_ERR(bus->rst)) {
1024 return PTR_ERR(bus->rst);
1026 reset_control_deassert(bus->rst);
1029 "bus-frequency", &bus->bus_frequency);
1032 "Could not read bus-frequency property\n");
1033 bus->bus_frequency = I2C_MAX_STANDARD_MODE_FREQ;
1038 bus->get_clk_reg_val = aspeed_i2c_24xx_get_clk_reg_val;
1040 bus->get_clk_reg_val = (u32 (*)(struct device *, u32))
1044 spin_lock_init(&bus->lock);
1045 init_completion(&bus->cmd_complete);
1046 bus->adap.owner = THIS_MODULE;
1047 bus->adap.retries = 0;
1048 bus->adap.algo = &aspeed_i2c_algo;
1049 bus->adap.dev.parent = &pdev->dev;
1050 bus->adap.dev.of_node = pdev->dev.of_node;
1051 strscpy(bus->adap.name, pdev->name, sizeof(bus->adap.name));
1052 i2c_set_adapdata(&bus->adap, bus);
1054 bus->dev = &pdev->dev;
1057 writel(0, bus->base + ASPEED_I2C_INTR_CTRL_REG);
1058 writel(0xffffffff, bus->base + ASPEED_I2C_INTR_STS_REG);
1060 * bus.lock does not need to be held because the interrupt handler has
1063 ret = aspeed_i2c_init(bus, pdev);
1069 0, dev_name(&pdev->dev), bus);
1073 ret = i2c_add_adapter(&bus->adap);
1077 platform_set_drvdata(pdev, bus);
1079 dev_info(bus->dev, "i2c bus %d registered, irq %d\n",
1080 bus->adap.nr, irq);
1087 struct aspeed_i2c_bus *bus = platform_get_drvdata(pdev);
1090 spin_lock_irqsave(&bus->lock, flags);
1093 writel(0, bus->base + ASPEED_I2C_FUN_CTRL_REG);
1094 writel(0, bus->base + ASPEED_I2C_INTR_CTRL_REG);
1096 spin_unlock_irqrestore(&bus->lock, flags);
1098 reset_control_assert(bus->rst);
1100 i2c_del_adapter(&bus->adap);
1107 .name = "aspeed-i2c-bus",