Lines Matching refs:bus
173 static int aspeed_i2c_reset(struct aspeed_i2c_bus *bus);
175 static int aspeed_i2c_recover_bus(struct aspeed_i2c_bus *bus)
181 spin_lock_irqsave(&bus->lock, flags);
182 command = readl(bus->base + ASPEED_I2C_CMD_REG);
188 dev_dbg(bus->dev, "SCL hung (state %x), attempting recovery\n",
191 reinit_completion(&bus->cmd_complete);
192 writel(ASPEED_I2CD_M_STOP_CMD, bus->base + ASPEED_I2C_CMD_REG);
193 spin_unlock_irqrestore(&bus->lock, flags);
196 &bus->cmd_complete, bus->adap.timeout);
198 spin_lock_irqsave(&bus->lock, flags);
201 else if (bus->cmd_err)
204 else if (!(readl(bus->base + ASPEED_I2C_CMD_REG) &
209 dev_dbg(bus->dev, "SDA hung (state %x), attempting recovery\n",
212 reinit_completion(&bus->cmd_complete);
215 bus->base + ASPEED_I2C_CMD_REG);
216 spin_unlock_irqrestore(&bus->lock, flags);
219 &bus->cmd_complete, bus->adap.timeout);
221 spin_lock_irqsave(&bus->lock, flags);
224 else if (bus->cmd_err)
227 else if (!(readl(bus->base + ASPEED_I2C_CMD_REG) &
233 spin_unlock_irqrestore(&bus->lock, flags);
238 spin_unlock_irqrestore(&bus->lock, flags);
240 return aspeed_i2c_reset(bus);
244 static u32 aspeed_i2c_slave_irq(struct aspeed_i2c_bus *bus, u32 irq_status)
247 struct i2c_client *slave = bus->slave;
261 bus->slave_state = ASPEED_I2C_SLAVE_STOP;
265 bus->slave_state == ASPEED_I2C_SLAVE_READ_PROCESSED) {
267 bus->slave_state = ASPEED_I2C_SLAVE_STOP;
271 if (bus->slave_state == ASPEED_I2C_SLAVE_STOP) {
273 bus->slave_state = ASPEED_I2C_SLAVE_INACTIVE;
282 bus->slave_state = ASPEED_I2C_SLAVE_START;
289 if (bus->slave_state == ASPEED_I2C_SLAVE_INACTIVE)
292 command = readl(bus->base + ASPEED_I2C_CMD_REG);
293 dev_dbg(bus->dev, "slave irq status 0x%08x, cmd 0x%08x\n",
298 value = readl(bus->base + ASPEED_I2C_BYTE_BUF_REG) >> 8;
300 if (bus->slave_state == ASPEED_I2C_SLAVE_START) {
302 bus->slave_state =
305 bus->slave_state =
311 switch (bus->slave_state) {
314 dev_err(bus->dev, "Unexpected ACK on read request.\n");
315 bus->slave_state = ASPEED_I2C_SLAVE_READ_PROCESSED;
317 writel(value, bus->base + ASPEED_I2C_BYTE_BUF_REG);
318 writel(ASPEED_I2CD_S_TX_CMD, bus->base + ASPEED_I2C_CMD_REG);
322 dev_err(bus->dev,
328 writel(value, bus->base + ASPEED_I2C_BYTE_BUF_REG);
329 writel(ASPEED_I2CD_S_TX_CMD, bus->base + ASPEED_I2C_CMD_REG);
332 bus->slave_state = ASPEED_I2C_SLAVE_WRITE_RECEIVED;
345 dev_err(bus->dev, "unknown slave_state: %d\n",
346 bus->slave_state);
347 bus->slave_state = ASPEED_I2C_SLAVE_INACTIVE;
355 /* precondition: bus.lock has been acquired. */
356 static void aspeed_i2c_do_start(struct aspeed_i2c_bus *bus)
359 struct i2c_msg *msg = &bus->msgs[bus->msgs_index];
366 * command when the bus comes back to the idle state.
368 if (bus->slave_state != ASPEED_I2C_SLAVE_INACTIVE) {
369 bus->master_state = ASPEED_I2C_MASTER_PENDING;
374 bus->master_state = ASPEED_I2C_MASTER_START;
375 bus->buf_index = 0;
384 writel(slave_addr, bus->base + ASPEED_I2C_BYTE_BUF_REG);
385 writel(command, bus->base + ASPEED_I2C_CMD_REG);
388 /* precondition: bus.lock has been acquired. */
389 static void aspeed_i2c_do_stop(struct aspeed_i2c_bus *bus)
391 bus->master_state = ASPEED_I2C_MASTER_STOP;
392 writel(ASPEED_I2CD_M_STOP_CMD, bus->base + ASPEED_I2C_CMD_REG);
395 /* precondition: bus.lock has been acquired. */
396 static void aspeed_i2c_next_msg_or_stop(struct aspeed_i2c_bus *bus)
398 if (bus->msgs_index + 1 < bus->msgs_count) {
399 bus->msgs_index++;
400 aspeed_i2c_do_start(bus);
402 aspeed_i2c_do_stop(bus);
419 static u32 aspeed_i2c_master_irq(struct aspeed_i2c_bus *bus, u32 irq_status)
427 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
439 dev_dbg(bus->dev, "received error interrupt: 0x%08x\n",
442 if (bus->master_state != ASPEED_I2C_MASTER_INACTIVE) {
443 bus->cmd_err = ret;
444 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
450 if (bus->master_state == ASPEED_I2C_MASTER_INACTIVE ||
451 bus->master_state == ASPEED_I2C_MASTER_PENDING)
454 /* We are in an invalid state; reset bus to a known state. */
455 if (!bus->msgs) {
456 dev_err(bus->dev, "bus in unknown state. irq_status: 0x%x\n",
458 bus->cmd_err = -EIO;
459 if (bus->master_state != ASPEED_I2C_MASTER_STOP &&
460 bus->master_state != ASPEED_I2C_MASTER_INACTIVE)
461 aspeed_i2c_do_stop(bus);
464 msg = &bus->msgs[bus->msgs_index];
471 if (bus->master_state == ASPEED_I2C_MASTER_START) {
481 writel(readl(bus->base + ASPEED_I2C_CMD_REG) &
483 bus->base + ASPEED_I2C_CMD_REG);
484 bus->master_state = ASPEED_I2C_MASTER_PENDING;
485 dev_dbg(bus->dev,
492 bus->cmd_err = -ENXIO;
493 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
498 bus->cmd_err = -ENXIO;
499 aspeed_i2c_do_stop(bus);
504 aspeed_i2c_do_stop(bus);
508 bus->master_state = ASPEED_I2C_MASTER_RX_FIRST;
510 bus->master_state = ASPEED_I2C_MASTER_TX_FIRST;
513 switch (bus->master_state) {
516 dev_dbg(bus->dev, "slave NACKed TX\n");
520 dev_err(bus->dev, "slave failed to ACK TX\n");
526 if (bus->buf_index < msg->len) {
527 bus->master_state = ASPEED_I2C_MASTER_TX;
528 writel(msg->buf[bus->buf_index++],
529 bus->base + ASPEED_I2C_BYTE_BUF_REG);
531 bus->base + ASPEED_I2C_CMD_REG);
533 aspeed_i2c_next_msg_or_stop(bus);
543 dev_err(bus->dev, "master failed to RX\n");
548 recv_byte = readl(bus->base + ASPEED_I2C_BYTE_BUF_REG) >> 8;
549 msg->buf[bus->buf_index++] = recv_byte;
553 bus->cmd_err = -EPROTO;
554 aspeed_i2c_do_stop(bus);
562 if (bus->buf_index < msg->len) {
563 bus->master_state = ASPEED_I2C_MASTER_RX;
565 if (bus->buf_index + 1 == msg->len)
567 writel(command, bus->base + ASPEED_I2C_CMD_REG);
569 aspeed_i2c_next_msg_or_stop(bus);
574 dev_err(bus->dev,
577 bus->cmd_err = -EIO;
583 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
586 dev_err(bus->dev,
589 bus->cmd_err = -EIO;
594 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
595 bus->cmd_err = -EINVAL;
599 bus->cmd_err = -EIO;
600 aspeed_i2c_do_stop(bus);
603 bus->msgs = NULL;
604 if (bus->cmd_err)
605 bus->master_xfer_result = bus->cmd_err;
607 bus->master_xfer_result = bus->msgs_index + 1;
608 complete(&bus->cmd_complete);
615 struct aspeed_i2c_bus *bus = dev_id;
618 spin_lock(&bus->lock);
619 irq_received = readl(bus->base + ASPEED_I2C_INTR_STS_REG);
622 bus->base + ASPEED_I2C_INTR_STS_REG);
623 readl(bus->base + ASPEED_I2C_INTR_STS_REG);
635 if (bus->master_state != ASPEED_I2C_MASTER_INACTIVE &&
636 bus->master_state != ASPEED_I2C_MASTER_PENDING) {
637 irq_handled = aspeed_i2c_master_irq(bus, irq_remaining);
640 irq_handled |= aspeed_i2c_slave_irq(bus, irq_remaining);
642 irq_handled = aspeed_i2c_slave_irq(bus, irq_remaining);
645 irq_handled |= aspeed_i2c_master_irq(bus,
653 if (bus->master_state == ASPEED_I2C_MASTER_PENDING &&
654 bus->slave_state == ASPEED_I2C_SLAVE_INACTIVE)
655 aspeed_i2c_do_start(bus);
657 irq_handled = aspeed_i2c_master_irq(bus, irq_remaining);
662 dev_err(bus->dev,
669 bus->base + ASPEED_I2C_INTR_STS_REG);
670 readl(bus->base + ASPEED_I2C_INTR_STS_REG);
672 spin_unlock(&bus->lock);
679 struct aspeed_i2c_bus *bus = i2c_get_adapdata(adap);
682 spin_lock_irqsave(&bus->lock, flags);
683 bus->cmd_err = 0;
685 /* If bus is busy in a single master environment, attempt recovery. */
686 if (!bus->multi_master &&
687 (readl(bus->base + ASPEED_I2C_CMD_REG) &
691 spin_unlock_irqrestore(&bus->lock, flags);
692 ret = aspeed_i2c_recover_bus(bus);
695 spin_lock_irqsave(&bus->lock, flags);
698 bus->cmd_err = 0;
699 bus->msgs = msgs;
700 bus->msgs_index = 0;
701 bus->msgs_count = num;
703 reinit_completion(&bus->cmd_complete);
704 aspeed_i2c_do_start(bus);
705 spin_unlock_irqrestore(&bus->lock, flags);
707 time_left = wait_for_completion_timeout(&bus->cmd_complete,
708 bus->adap.timeout);
713 * recovery. But if the bus is idle, we still need to reset the
716 if (bus->multi_master &&
717 (readl(bus->base + ASPEED_I2C_CMD_REG) &
719 aspeed_i2c_recover_bus(bus);
721 aspeed_i2c_reset(bus);
727 spin_lock_irqsave(&bus->lock, flags);
728 if (bus->master_state == ASPEED_I2C_MASTER_PENDING)
729 bus->master_state = ASPEED_I2C_MASTER_INACTIVE;
730 spin_unlock_irqrestore(&bus->lock, flags);
735 return bus->master_xfer_result;
744 /* precondition: bus.lock has been acquired. */
745 static void __aspeed_i2c_reg_slave(struct aspeed_i2c_bus *bus, u16 slave_addr)
750 addr_reg_val = readl(bus->base + ASPEED_I2C_DEV_ADDR_REG);
753 writel(addr_reg_val, bus->base + ASPEED_I2C_DEV_ADDR_REG);
756 func_ctrl_reg_val = readl(bus->base + ASPEED_I2C_FUN_CTRL_REG);
758 writel(func_ctrl_reg_val, bus->base + ASPEED_I2C_FUN_CTRL_REG);
760 bus->slave_state = ASPEED_I2C_SLAVE_INACTIVE;
765 struct aspeed_i2c_bus *bus = i2c_get_adapdata(client->adapter);
768 spin_lock_irqsave(&bus->lock, flags);
769 if (bus->slave) {
770 spin_unlock_irqrestore(&bus->lock, flags);
774 __aspeed_i2c_reg_slave(bus, client->addr);
776 bus->slave = client;
777 spin_unlock_irqrestore(&bus->lock, flags);
784 struct aspeed_i2c_bus *bus = i2c_get_adapdata(client->adapter);
788 spin_lock_irqsave(&bus->lock, flags);
789 if (!bus->slave) {
790 spin_unlock_irqrestore(&bus->lock, flags);
795 func_ctrl_reg_val = readl(bus->base + ASPEED_I2C_FUN_CTRL_REG);
797 writel(func_ctrl_reg_val, bus->base + ASPEED_I2C_FUN_CTRL_REG);
799 bus->slave = NULL;
800 spin_unlock_irqrestore(&bus->lock, flags);
900 /* precondition: bus.lock has been acquired. */
901 static int aspeed_i2c_init_clk(struct aspeed_i2c_bus *bus)
905 divisor = DIV_ROUND_UP(bus->parent_clk_frequency, bus->bus_frequency);
906 clk_reg_val = readl(bus->base + ASPEED_I2C_AC_TIMING_REG1);
910 clk_reg_val |= bus->get_clk_reg_val(bus->dev, divisor);
911 writel(clk_reg_val, bus->base + ASPEED_I2C_AC_TIMING_REG1);
912 writel(ASPEED_NO_TIMEOUT_CTRL, bus->base + ASPEED_I2C_AC_TIMING_REG2);
917 /* precondition: bus.lock has been acquired. */
918 static int aspeed_i2c_init(struct aspeed_i2c_bus *bus,
925 writel(0, bus->base + ASPEED_I2C_FUN_CTRL_REG);
927 ret = aspeed_i2c_init_clk(bus);
932 bus->multi_master = true;
937 writel(readl(bus->base + ASPEED_I2C_FUN_CTRL_REG) | fun_ctrl_reg,
938 bus->base + ASPEED_I2C_FUN_CTRL_REG);
942 if (bus->slave)
943 __aspeed_i2c_reg_slave(bus, bus->slave->addr);
947 writel(ASPEED_I2CD_INTR_ALL, bus->base + ASPEED_I2C_INTR_CTRL_REG);
952 static int aspeed_i2c_reset(struct aspeed_i2c_bus *bus)
954 struct platform_device *pdev = to_platform_device(bus->dev);
958 spin_lock_irqsave(&bus->lock, flags);
961 writel(0, bus->base + ASPEED_I2C_INTR_CTRL_REG);
962 writel(0xffffffff, bus->base + ASPEED_I2C_INTR_STS_REG);
964 ret = aspeed_i2c_init(bus, pdev);
966 spin_unlock_irqrestore(&bus->lock, flags);
973 .compatible = "aspeed,ast2400-i2c-bus",
977 .compatible = "aspeed,ast2500-i2c-bus",
981 .compatible = "aspeed,ast2600-i2c-bus",
991 struct aspeed_i2c_bus *bus;
996 bus = devm_kzalloc(&pdev->dev, sizeof(*bus), GFP_KERNEL);
997 if (!bus)
1001 bus->base = devm_ioremap_resource(&pdev->dev, res);
1002 if (IS_ERR(bus->base))
1003 return PTR_ERR(bus->base);
1008 bus->parent_clk_frequency = clk_get_rate(parent_clk);
1012 bus->rst = devm_reset_control_get_shared(&pdev->dev, NULL);
1013 if (IS_ERR(bus->rst)) {
1016 return PTR_ERR(bus->rst);
1018 reset_control_deassert(bus->rst);
1021 "bus-frequency", &bus->bus_frequency);
1024 "Could not read bus-frequency property\n");
1025 bus->bus_frequency = I2C_MAX_STANDARD_MODE_FREQ;
1030 bus->get_clk_reg_val = aspeed_i2c_24xx_get_clk_reg_val;
1032 bus->get_clk_reg_val = (u32 (*)(struct device *, u32))
1036 spin_lock_init(&bus->lock);
1037 init_completion(&bus->cmd_complete);
1038 bus->adap.owner = THIS_MODULE;
1039 bus->adap.retries = 0;
1040 bus->adap.algo = &aspeed_i2c_algo;
1041 bus->adap.dev.parent = &pdev->dev;
1042 bus->adap.dev.of_node = pdev->dev.of_node;
1043 strlcpy(bus->adap.name, pdev->name, sizeof(bus->adap.name));
1044 i2c_set_adapdata(&bus->adap, bus);
1046 bus->dev = &pdev->dev;
1049 writel(0, bus->base + ASPEED_I2C_INTR_CTRL_REG);
1050 writel(0xffffffff, bus->base + ASPEED_I2C_INTR_STS_REG);
1052 * bus.lock does not need to be held because the interrupt handler has
1055 ret = aspeed_i2c_init(bus, pdev);
1061 0, dev_name(&pdev->dev), bus);
1065 ret = i2c_add_adapter(&bus->adap);
1069 platform_set_drvdata(pdev, bus);
1071 dev_info(bus->dev, "i2c bus %d registered, irq %d\n",
1072 bus->adap.nr, irq);
1079 struct aspeed_i2c_bus *bus = platform_get_drvdata(pdev);
1082 spin_lock_irqsave(&bus->lock, flags);
1085 writel(0, bus->base + ASPEED_I2C_FUN_CTRL_REG);
1086 writel(0, bus->base + ASPEED_I2C_INTR_CTRL_REG);
1088 spin_unlock_irqrestore(&bus->lock, flags);
1090 reset_control_assert(bus->rst);
1092 i2c_del_adapter(&bus->adap);
1101 .name = "aspeed-i2c-bus",