Lines Matching +full:smbus +full:- +full:timeout +full:- +full:disable
1 // SPDX-License-Identifier: GPL-2.0+
11 #include <linux/dma-mapping.h>
28 #define DRIVER_NAME "imx-lpi2c"
193 writel(enable, lpi2c_imx->base + LPI2C_MIER);
202 temp = readl(lpi2c_imx->base + LPI2C_MSR);
206 writel(temp, lpi2c_imx->base + LPI2C_MSR);
207 return -EAGAIN;
214 dev_dbg(&lpi2c_imx->adapter.dev, "bus not work\n");
215 if (lpi2c_imx->adapter.bus_recovery_info)
216 i2c_recover_bus(&lpi2c_imx->adapter);
217 return -ETIMEDOUT;
227 unsigned int bitrate = lpi2c_imx->bitrate;
241 lpi2c_imx->mode = mode;
249 temp = readl(lpi2c_imx->base + LPI2C_MCR);
251 writel(temp, lpi2c_imx->base + LPI2C_MCR);
252 writel(0x7f00, lpi2c_imx->base + LPI2C_MSR);
255 writel(temp, lpi2c_imx->base + LPI2C_MTDR);
265 writel(GEN_STOP << 8, lpi2c_imx->base + LPI2C_MTDR);
268 temp = readl(lpi2c_imx->base + LPI2C_MSR);
273 dev_dbg(&lpi2c_imx->adapter.dev, "stop timeout\n");
274 if (lpi2c_imx->adapter.bus_recovery_info)
275 i2c_recover_bus(&lpi2c_imx->adapter);
293 clk_rate = lpi2c_imx->rate_per;
295 if (lpi2c_imx->mode == HS || lpi2c_imx->mode == ULTRA_FAST)
301 clk_cycle = clk_rate / ((1 << prescale) * lpi2c_imx->bitrate)
302 - 3 - (filt >> 1);
304 clklo = clk_cycle - clkhi;
310 return -EINVAL;
313 if (lpi2c_imx->mode == ULTRA_FAST)
319 if (lpi2c_imx->mode == ULTRA_FAST)
322 writel(temp, lpi2c_imx->base + LPI2C_MCFGR1);
326 writel(temp, lpi2c_imx->base + LPI2C_MCFGR2);
333 if (lpi2c_imx->mode == HS)
334 writel(temp, lpi2c_imx->base + LPI2C_MCCR1);
336 writel(temp, lpi2c_imx->base + LPI2C_MCCR0);
346 ret = pm_runtime_resume_and_get(lpi2c_imx->adapter.dev.parent);
351 writel(temp, lpi2c_imx->base + LPI2C_MCR);
352 writel(0, lpi2c_imx->base + LPI2C_MCR);
358 temp = readl(lpi2c_imx->base + LPI2C_MCR);
360 writel(temp, lpi2c_imx->base + LPI2C_MCR);
365 pm_runtime_mark_last_busy(lpi2c_imx->adapter.dev.parent);
366 pm_runtime_put_autosuspend(lpi2c_imx->adapter.dev.parent);
375 temp = readl(lpi2c_imx->base + LPI2C_MCR);
377 writel(temp, lpi2c_imx->base + LPI2C_MCR);
379 pm_runtime_mark_last_busy(lpi2c_imx->adapter.dev.parent);
380 pm_runtime_put_autosuspend(lpi2c_imx->adapter.dev.parent);
389 time_left = wait_for_completion_timeout(&lpi2c_imx->complete, HZ);
391 return time_left ? 0 : -ETIMEDOUT;
400 txcnt = readl(lpi2c_imx->base + LPI2C_MFSR) & 0xff;
402 if (readl(lpi2c_imx->base + LPI2C_MSR) & MSR_NDF) {
403 dev_dbg(&lpi2c_imx->adapter.dev, "NDF detected\n");
404 return -EIO;
408 dev_dbg(&lpi2c_imx->adapter.dev, "txfifo empty timeout\n");
409 if (lpi2c_imx->adapter.bus_recovery_info)
410 i2c_recover_bus(&lpi2c_imx->adapter);
411 return -ETIMEDOUT;
422 writel(lpi2c_imx->txfifosize >> 1, lpi2c_imx->base + LPI2C_MFCR);
429 remaining = lpi2c_imx->msglen - lpi2c_imx->delivered;
431 if (remaining > (lpi2c_imx->rxfifosize >> 1))
432 temp = lpi2c_imx->rxfifosize >> 1;
436 writel(temp << 16, lpi2c_imx->base + LPI2C_MFCR);
443 txcnt = readl(lpi2c_imx->base + LPI2C_MFSR) & 0xff;
445 while (txcnt < lpi2c_imx->txfifosize) {
446 if (lpi2c_imx->delivered == lpi2c_imx->msglen)
449 data = lpi2c_imx->tx_buf[lpi2c_imx->delivered++];
450 writel(data, lpi2c_imx->base + LPI2C_MTDR);
454 if (lpi2c_imx->delivered < lpi2c_imx->msglen)
457 complete(&lpi2c_imx->complete);
466 data = readl(lpi2c_imx->base + LPI2C_MRDR);
470 lpi2c_imx->rx_buf[lpi2c_imx->delivered++] = data & 0xff;
474 * First byte is the length of remaining packet in the SMBus block
475 * data read. Add it to msgs->len.
477 if (lpi2c_imx->block_data) {
478 blocklen = lpi2c_imx->rx_buf[0];
479 lpi2c_imx->msglen += blocklen;
482 remaining = lpi2c_imx->msglen - lpi2c_imx->delivered;
485 complete(&lpi2c_imx->complete);
493 if (lpi2c_imx->block_data) {
494 lpi2c_imx->block_data = 0;
497 writel(temp, lpi2c_imx->base + LPI2C_MTDR);
498 } else if (!(lpi2c_imx->delivered & 0xff)) {
499 temp = (remaining > CHUNK_DATA ? CHUNK_DATA : remaining) - 1;
501 writel(temp, lpi2c_imx->base + LPI2C_MTDR);
510 lpi2c_imx->tx_buf = msgs->buf;
520 lpi2c_imx->rx_buf = msgs->buf;
521 lpi2c_imx->block_data = msgs->flags & I2C_M_RECV_LEN;
524 temp = msgs->len > CHUNK_DATA ? CHUNK_DATA - 1 : msgs->len - 1;
526 writel(temp, lpi2c_imx->base + LPI2C_MTDR);
533 if (!lpi2c_imx->can_use_dma)
540 return !(msg->len < I2C_DMA_THRESHOLD);
546 reinit_completion(&lpi2c_imx->complete);
548 if (msg->flags & I2C_M_RD)
560 time = 8 * lpi2c_imx->dma->dma_len * 1000 / lpi2c_imx->bitrate;
571 struct lpi2c_imx_dma *dma = lpi2c_imx->dma;
572 u16 rx_remain = dma->dma_len;
582 dma->rx_cmd_buf = kcalloc(cmd_num, sizeof(u16), GFP_KERNEL);
583 dma->rx_cmd_buf_len = cmd_num * sizeof(u16);
585 if (!dma->rx_cmd_buf) {
586 dev_err(&lpi2c_imx->adapter.dev, "Alloc RX cmd buffer failed\n");
587 return -ENOMEM;
591 temp = rx_remain > CHUNK_DATA ? CHUNK_DATA - 1 : rx_remain - 1;
593 rx_remain -= CHUNK_DATA;
594 dma->rx_cmd_buf[i] = temp;
605 time_left = wait_for_completion_timeout(&lpi2c_imx->complete, time);
607 dev_err(&lpi2c_imx->adapter.dev, "I/O Error in DMA Data Transfer\n");
608 return -ETIMEDOUT;
616 struct dma_chan *chan = dma->dma_data_dir == DMA_FROM_DEVICE
617 ? dma->chan_rx : dma->chan_tx;
619 dma_unmap_single(chan->device->dev, dma->dma_addr,
620 dma->dma_len, dma->dma_data_dir);
622 dma->dma_data_dir = DMA_NONE;
627 dmaengine_terminate_sync(dma->chan_tx);
628 dma_unmap_single(dma->chan_tx->device->dev, dma->dma_tx_addr,
629 dma->rx_cmd_buf_len, DMA_TO_DEVICE);
634 if (dma->dma_data_dir == DMA_FROM_DEVICE)
635 dmaengine_terminate_sync(dma->chan_rx);
636 else if (dma->dma_data_dir == DMA_TO_DEVICE)
637 dmaengine_terminate_sync(dma->chan_tx);
646 complete(&lpi2c_imx->complete);
652 struct lpi2c_imx_dma *dma = lpi2c_imx->dma;
653 struct dma_chan *txchan = dma->chan_tx;
656 dma->dma_tx_addr = dma_map_single(txchan->device->dev,
657 dma->rx_cmd_buf, dma->rx_cmd_buf_len,
659 if (dma_mapping_error(txchan->device->dev, dma->dma_tx_addr)) {
660 dev_err(&lpi2c_imx->adapter.dev, "DMA map failed, use pio\n");
661 return -EINVAL;
664 rx_cmd_desc = dmaengine_prep_slave_single(txchan, dma->dma_tx_addr,
665 dma->rx_cmd_buf_len, DMA_MEM_TO_DEV,
668 dev_err(&lpi2c_imx->adapter.dev, "DMA prep slave sg failed, use pio\n");
674 dev_err(&lpi2c_imx->adapter.dev, "submitting DMA failed, use pio\n");
683 dma_unmap_single(txchan->device->dev, dma->dma_tx_addr,
684 dma->rx_cmd_buf_len, DMA_TO_DEVICE);
685 return -EINVAL;
688 dma_unmap_single(txchan->device->dev, dma->dma_tx_addr,
689 dma->rx_cmd_buf_len, DMA_TO_DEVICE);
691 return -EINVAL;
696 struct lpi2c_imx_dma *dma = lpi2c_imx->dma;
701 if (dma->dma_msg_flag & I2C_M_RD) {
702 chan = dma->chan_rx;
703 dma->dma_data_dir = DMA_FROM_DEVICE;
704 dma->dma_transfer_dir = DMA_DEV_TO_MEM;
706 chan = dma->chan_tx;
707 dma->dma_data_dir = DMA_TO_DEVICE;
708 dma->dma_transfer_dir = DMA_MEM_TO_DEV;
711 dma->dma_addr = dma_map_single(chan->device->dev,
712 dma->dma_buf, dma->dma_len, dma->dma_data_dir);
713 if (dma_mapping_error(chan->device->dev, dma->dma_addr)) {
714 dev_err(&lpi2c_imx->adapter.dev, "DMA map failed, use pio\n");
715 return -EINVAL;
718 desc = dmaengine_prep_slave_single(chan, dma->dma_addr,
719 dma->dma_len, dma->dma_transfer_dir,
722 dev_err(&lpi2c_imx->adapter.dev, "DMA prep slave sg failed, use pio\n");
726 reinit_completion(&lpi2c_imx->complete);
727 desc->callback = lpi2c_dma_callback;
728 desc->callback_param = lpi2c_imx;
732 dev_err(&lpi2c_imx->adapter.dev, "submitting DMA failed, use pio\n");
737 dma->using_pio_mode = false;
745 return -EINVAL;
750 return -EINVAL;
757 for (i = fifosize / 2; i > 0; i--)
770 struct lpi2c_imx_dma *dma = lpi2c_imx->dma;
773 if (dma->dma_msg_flag & I2C_M_RD) {
779 cmd_num = DIV_ROUND_UP(dma->dma_len, CHUNK_DATA);
780 dma->tx_burst_num = lpi2c_imx_find_max_burst_num(lpi2c_imx->txfifosize,
782 dma->rx_burst_num = lpi2c_imx_find_max_burst_num(lpi2c_imx->rxfifosize,
783 dma->dma_len);
785 dma->tx_burst_num = lpi2c_imx_find_max_burst_num(lpi2c_imx->txfifosize,
786 dma->dma_len);
792 struct lpi2c_imx_dma *dma = lpi2c_imx->dma;
798 if (dma->dma_msg_flag & I2C_M_RD) {
799 tx.dst_addr = dma->phy_addr + LPI2C_MTDR;
801 tx.dst_maxburst = dma->tx_burst_num;
803 ret = dmaengine_slave_config(dma->chan_tx, &tx);
807 rx.src_addr = dma->phy_addr + LPI2C_MRDR;
809 rx.src_maxburst = dma->rx_burst_num;
811 ret = dmaengine_slave_config(dma->chan_rx, &rx);
815 tx.dst_addr = dma->phy_addr + LPI2C_MTDR;
817 tx.dst_maxburst = dma->tx_burst_num;
819 ret = dmaengine_slave_config(dma->chan_tx, &tx);
829 struct lpi2c_imx_dma *dma = lpi2c_imx->dma;
839 if (dma->dma_msg_flag & I2C_M_RD) {
841 writel(dma->tx_burst_num | (dma->rx_burst_num - 1) << 16,
842 lpi2c_imx->base + LPI2C_MFCR);
844 writel(MDER_TDDE | MDER_RDDE, lpi2c_imx->base + LPI2C_MDER);
847 writel(dma->tx_burst_num, lpi2c_imx->base + LPI2C_MFCR);
849 writel(MDER_TDDE, lpi2c_imx->base + LPI2C_MDER);
861 * Bits 8-10 are the command data field and Bits 0-7 are the transmit
877 struct lpi2c_imx_dma *dma = lpi2c_imx->dma;
881 dma->using_pio_mode = true;
883 dma->dma_len = msg->len;
884 dma->dma_msg_flag = msg->flags;
885 dma->dma_buf = i2c_get_dma_safe_msg_buf(msg, I2C_DMA_THRESHOLD);
886 if (!dma->dma_buf)
887 return -ENOMEM;
891 dev_err(&lpi2c_imx->adapter.dev, "Failed to configure DMA (%d)\n", ret);
899 dev_err(&lpi2c_imx->adapter.dev, "DMA submission failed (%d)\n", ret);
903 if (dma->dma_msg_flag & I2C_M_RD) {
918 if ((readl(lpi2c_imx->base + LPI2C_MSR) & MSR_NDF) && !ret) {
919 ret = -EIO;
923 if (dma->dma_msg_flag & I2C_M_RD)
924 dma_unmap_single(dma->chan_tx->device->dev, dma->dma_tx_addr,
925 dma->rx_cmd_buf_len, DMA_TO_DEVICE);
931 if (dma->dma_msg_flag & I2C_M_RD)
936 /* Disable I2C DMA function */
937 writel(0, lpi2c_imx->base + LPI2C_MDER);
939 if (dma->dma_msg_flag & I2C_M_RD)
940 kfree(dma->rx_cmd_buf);
943 i2c_put_dma_safe_msg_buf(dma->dma_buf, msg, false);
945 i2c_put_dma_safe_msg_buf(dma->dma_buf, msg, true);
964 goto disable;
966 /* quick smbus */
970 lpi2c_imx->rx_buf = NULL;
971 lpi2c_imx->tx_buf = NULL;
972 lpi2c_imx->delivered = 0;
973 lpi2c_imx->msglen = msgs[i].len;
974 init_completion(&lpi2c_imx->complete);
978 if (result && lpi2c_imx->dma->using_pio_mode)
997 temp = readl(lpi2c_imx->base + LPI2C_MSR);
999 result = -EIO;
1001 disable:
1004 dev_dbg(&lpi2c_imx->adapter.dev, "<%s> exit with: %s: %d\n", __func__,
1019 writel(0, lpi2c_imx->base + LPI2C_SIER);
1025 sasr = readl(lpi2c_imx->base + LPI2C_SASR);
1028 i2c_slave_event(lpi2c_imx->target, I2C_SLAVE_READ_REQUESTED, &value);
1029 writel(value, lpi2c_imx->base + LPI2C_STDR);
1033 i2c_slave_event(lpi2c_imx->target, I2C_SLAVE_WRITE_REQUESTED, &value);
1039 i2c_slave_event(lpi2c_imx->target, I2C_SLAVE_STOP, &value);
1043 i2c_slave_event(lpi2c_imx->target, I2C_SLAVE_READ_PROCESSED, &value);
1044 writel(value, lpi2c_imx->base + LPI2C_STDR);
1049 value = readl(lpi2c_imx->base + LPI2C_SRDR);
1050 i2c_slave_event(lpi2c_imx->target, I2C_SLAVE_WRITE_RECEIVED, &value);
1055 writel(ssr & SSR_CLEAR_BITS, lpi2c_imx->base + LPI2C_SSR);
1064 enabled = readl(lpi2c_imx->base + LPI2C_MIER);
1067 temp = readl(lpi2c_imx->base + LPI2C_MSR);
1071 complete(&lpi2c_imx->complete);
1084 if (lpi2c_imx->target) {
1085 u32 scr = readl(lpi2c_imx->base + LPI2C_SCR);
1086 u32 ssr = readl(lpi2c_imx->base + LPI2C_SSR);
1087 u32 sier_filter = ssr & readl(lpi2c_imx->base + LPI2C_SIER);
1109 writel(SCR_RST, lpi2c_imx->base + LPI2C_SCR);
1110 writel(0, lpi2c_imx->base + LPI2C_SCR);
1113 writel((lpi2c_imx->target->addr << 1), lpi2c_imx->base + LPI2C_SAMR);
1115 writel(SCFGR1_RXSTALL | SCFGR1_TXDSTALL, lpi2c_imx->base + LPI2C_SCFGR1);
1140 writel(temp, lpi2c_imx->base + LPI2C_SCFGR2);
1148 writel(SCR_SEN | SCR_FILTEN, lpi2c_imx->base + LPI2C_SCR);
1151 writel(SLAVE_INT_FLAG, lpi2c_imx->base + LPI2C_SIER);
1156 struct lpi2c_imx_struct *lpi2c_imx = i2c_get_adapdata(client->adapter);
1159 if (lpi2c_imx->target)
1160 return -EBUSY;
1162 lpi2c_imx->target = client;
1164 ret = pm_runtime_resume_and_get(lpi2c_imx->adapter.dev.parent);
1166 dev_err(&lpi2c_imx->adapter.dev, "failed to resume i2c controller");
1177 struct lpi2c_imx_struct *lpi2c_imx = i2c_get_adapdata(client->adapter);
1180 if (!lpi2c_imx->target)
1181 return -EINVAL;
1184 writel(0, lpi2c_imx->base + LPI2C_SAMR);
1186 writel(SCR_RST, lpi2c_imx->base + LPI2C_SCR);
1187 writel(0, lpi2c_imx->base + LPI2C_SCR);
1189 lpi2c_imx->target = NULL;
1191 ret = pm_runtime_put_sync(lpi2c_imx->adapter.dev.parent);
1193 dev_err(&lpi2c_imx->adapter.dev, "failed to suspend i2c controller");
1201 struct i2c_bus_recovery_info *bri = &lpi2c_imx->rinfo;
1203 bri->pinctrl = devm_pinctrl_get(&pdev->dev);
1204 if (IS_ERR(bri->pinctrl))
1205 return PTR_ERR(bri->pinctrl);
1207 lpi2c_imx->adapter.bus_recovery_info = bri;
1214 if (dma->chan_rx)
1215 dma_release_channel(dma->chan_rx);
1217 if (dma->chan_tx)
1218 dma_release_channel(dma->chan_tx);
1231 return -ENOMEM;
1233 dma->phy_addr = phy_addr;
1236 dma->chan_tx = dma_request_chan(dev, "tx");
1237 if (IS_ERR(dma->chan_tx)) {
1238 ret = PTR_ERR(dma->chan_tx);
1239 if (ret != -ENODEV && ret != -EPROBE_DEFER)
1241 dma->chan_tx = NULL;
1246 dma->chan_rx = dma_request_chan(dev, "rx");
1247 if (IS_ERR(dma->chan_rx)) {
1248 ret = PTR_ERR(dma->chan_rx);
1249 if (ret != -ENODEV && ret != -EPROBE_DEFER)
1251 dma->chan_rx = NULL;
1255 lpi2c_imx->can_use_dma = true;
1256 lpi2c_imx->dma = dma;
1278 { .compatible = "fsl,imx7ulp-lpi2c" },
1291 lpi2c_imx = devm_kzalloc(&pdev->dev, sizeof(*lpi2c_imx), GFP_KERNEL);
1293 return -ENOMEM;
1295 lpi2c_imx->base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
1296 if (IS_ERR(lpi2c_imx->base))
1297 return PTR_ERR(lpi2c_imx->base);
1303 lpi2c_imx->adapter.owner = THIS_MODULE;
1304 lpi2c_imx->adapter.algo = &lpi2c_imx_algo;
1305 lpi2c_imx->adapter.dev.parent = &pdev->dev;
1306 lpi2c_imx->adapter.dev.of_node = pdev->dev.of_node;
1307 strscpy(lpi2c_imx->adapter.name, pdev->name,
1308 sizeof(lpi2c_imx->adapter.name));
1309 phy_addr = (dma_addr_t)res->start;
1311 ret = devm_clk_bulk_get_all(&pdev->dev, &lpi2c_imx->clks);
1313 return dev_err_probe(&pdev->dev, ret, "can't get I2C peripheral clock\n");
1314 lpi2c_imx->num_clks = ret;
1316 ret = of_property_read_u32(pdev->dev.of_node,
1317 "clock-frequency", &lpi2c_imx->bitrate);
1319 lpi2c_imx->bitrate = I2C_MAX_STANDARD_MODE_FREQ;
1321 ret = devm_request_irq(&pdev->dev, irq, lpi2c_imx_isr, IRQF_NO_SUSPEND,
1322 pdev->name, lpi2c_imx);
1324 return dev_err_probe(&pdev->dev, ret, "can't claim irq %d\n", irq);
1326 i2c_set_adapdata(&lpi2c_imx->adapter, lpi2c_imx);
1329 ret = clk_bulk_prepare_enable(lpi2c_imx->num_clks, lpi2c_imx->clks);
1337 ret = devm_clk_rate_exclusive_get(&pdev->dev, lpi2c_imx->clks[0].clk);
1339 return dev_err_probe(&pdev->dev, ret,
1342 lpi2c_imx->rate_per = clk_get_rate(lpi2c_imx->clks[0].clk);
1343 if (!lpi2c_imx->rate_per)
1344 return dev_err_probe(&pdev->dev, -EINVAL,
1347 pm_runtime_set_autosuspend_delay(&pdev->dev, I2C_PM_TIMEOUT);
1348 pm_runtime_use_autosuspend(&pdev->dev);
1349 pm_runtime_get_noresume(&pdev->dev);
1350 pm_runtime_set_active(&pdev->dev);
1351 pm_runtime_enable(&pdev->dev);
1353 temp = readl(lpi2c_imx->base + LPI2C_PARAM);
1354 lpi2c_imx->txfifosize = 1 << (temp & 0x0f);
1355 lpi2c_imx->rxfifosize = 1 << ((temp >> 8) & 0x0f);
1360 if (ret == -EPROBE_DEFER)
1364 ret = lpi2c_dma_init(&pdev->dev, phy_addr);
1366 if (ret == -EPROBE_DEFER)
1368 dev_info(&pdev->dev, "use pio mode\n");
1371 ret = i2c_add_adapter(&lpi2c_imx->adapter);
1375 pm_runtime_mark_last_busy(&pdev->dev);
1376 pm_runtime_put_autosuspend(&pdev->dev);
1378 dev_info(&lpi2c_imx->adapter.dev, "LPI2C adapter registered\n");
1383 pm_runtime_put(&pdev->dev);
1384 pm_runtime_disable(&pdev->dev);
1385 pm_runtime_dont_use_autosuspend(&pdev->dev);
1394 i2c_del_adapter(&lpi2c_imx->adapter);
1396 pm_runtime_disable(&pdev->dev);
1397 pm_runtime_dont_use_autosuspend(&pdev->dev);
1404 clk_bulk_disable(lpi2c_imx->num_clks, lpi2c_imx->clks);
1416 ret = clk_bulk_enable(lpi2c_imx->num_clks, lpi2c_imx->clks);
1444 if (lpi2c_imx->target)
1459 * after runtime PM is re-enabled (in resume_early()). However, this
1468 * Finally, the resume() callback re-enables autosuspend, ensuring