// SPDX-License-Identifier: GPL-2.0 /* * Driver for the NXP ISP1760 chip * * Copyright 2022 Linaro, Rui Miguel Silva * * This is based on linux kernel driver, original developed: * Copyright 2014 Laurent Pinchart * Copyright 2007 Sebastian Siewior * */ #include #include #include #include #include #include #include #include #include #include #include "isp1760-core.h" #include "isp1760-hcd.h" #include "isp1760-regs.h" #define msleep(a) udelay((a) * 1000) static int isp1760_init_core(struct isp1760_device *isp) { struct isp1760_hcd *hcd = &isp->hcd; /* * Reset the host controller, including the CPU interface * configuration. */ isp1760_field_set(hcd->fields, SW_RESET_RESET_ALL); msleep(100); /* Setup HW Mode Control: This assumes a level active-low interrupt */ if ((isp->devflags & ISP1760_FLAG_ANALOG_OC) && hcd->is_isp1763) return -EINVAL; if (isp->devflags & ISP1760_FLAG_BUS_WIDTH_16) isp1760_field_clear(hcd->fields, HW_DATA_BUS_WIDTH); if (isp->devflags & ISP1760_FLAG_BUS_WIDTH_8) isp1760_field_set(hcd->fields, HW_DATA_BUS_WIDTH); if (isp->devflags & ISP1760_FLAG_ANALOG_OC) isp1760_field_set(hcd->fields, HW_ANA_DIGI_OC); if (isp->devflags & ISP1760_FLAG_DACK_POL_HIGH) isp1760_field_set(hcd->fields, HW_DACK_POL_HIGH); if (isp->devflags & ISP1760_FLAG_DREQ_POL_HIGH) isp1760_field_set(hcd->fields, HW_DREQ_POL_HIGH); if (isp->devflags & ISP1760_FLAG_INTR_POL_HIGH) isp1760_field_set(hcd->fields, HW_INTR_HIGH_ACT); if (isp->devflags & ISP1760_FLAG_INTR_EDGE_TRIG) isp1760_field_set(hcd->fields, HW_INTR_EDGE_TRIG); /* * The ISP1761 has a dedicated DC IRQ line but supports sharing the HC * IRQ line for both the host and device controllers. Hardcode IRQ * sharing for now and disable the DC interrupts globally to avoid * spurious interrupts during HCD registration. */ if (isp->devflags & ISP1760_FLAG_ISP1761) { isp1760_reg_write(hcd->regs, ISP176x_DC_MODE, 0); isp1760_field_set(hcd->fields, HW_COMN_IRQ); } /* * PORT 1 Control register of the ISP1760 is the OTG control register * on ISP1761. * * TODO: Really support OTG. For now we configure port 1 in device mode */ if (((isp->devflags & ISP1760_FLAG_ISP1761) || (isp->devflags & ISP1760_FLAG_ISP1763)) && (isp->devflags & ISP1760_FLAG_PERIPHERAL_EN)) { isp1760_field_set(hcd->fields, HW_DM_PULLDOWN); isp1760_field_set(hcd->fields, HW_DP_PULLDOWN); isp1760_field_set(hcd->fields, HW_OTG_DISABLE); } else { isp1760_field_set(hcd->fields, HW_SW_SEL_HC_DC); isp1760_field_set(hcd->fields, HW_VBUS_DRV); isp1760_field_set(hcd->fields, HW_SEL_CP_EXT); } printf("%s bus width: %u, oc: %s\n", hcd->is_isp1763 ? "isp1763" : "isp1760", isp->devflags & ISP1760_FLAG_BUS_WIDTH_8 ? 8 : isp->devflags & ISP1760_FLAG_BUS_WIDTH_16 ? 16 : 32, hcd->is_isp1763 ? "not available" : isp->devflags & ISP1760_FLAG_ANALOG_OC ? "analog" : "digital"); return 0; } void isp1760_set_pullup(struct isp1760_device *isp, bool enable) { struct isp1760_hcd *hcd = &isp->hcd; if (enable) isp1760_field_set(hcd->fields, HW_DP_PULLUP); else isp1760_field_set(hcd->fields, HW_DP_PULLUP_CLEAR); } /* * ISP1760/61: * * 60kb divided in: * - 32 blocks @ 256 bytes * - 20 blocks @ 1024 bytes * - 4 blocks @ 8192 bytes */ static const struct isp1760_memory_layout isp176x_memory_conf = { .blocks[0] = 32, .blocks_size[0] = 256, .blocks[1] = 20, .blocks_size[1] = 1024, .blocks[2] = 4, .blocks_size[2] = 8192, .slot_num = 32, .payload_blocks = 32 + 20 + 4, .payload_area_size = 0xf000, }; /* * ISP1763: * * 20kb divided in: * - 8 blocks @ 256 bytes * - 2 blocks @ 1024 bytes * - 4 blocks @ 4096 bytes */ static const struct isp1760_memory_layout isp1763_memory_conf = { .blocks[0] = 8, .blocks_size[0] = 256, .blocks[1] = 2, .blocks_size[1] = 1024, .blocks[2] = 4, .blocks_size[2] = 4096, .slot_num = 16, .payload_blocks = 8 + 2 + 4, .payload_area_size = 0x5000, }; static const struct regmap_config isp1760_hc_regmap_conf = { .width = REGMAP_SIZE_16, }; static const struct reg_field isp1760_hc_reg_fields[] = { [HCS_PPC] = REG_FIELD(ISP176x_HC_HCSPARAMS, 4, 4), [HCS_N_PORTS] = REG_FIELD(ISP176x_HC_HCSPARAMS, 0, 3), [HCC_ISOC_CACHE] = REG_FIELD(ISP176x_HC_HCCPARAMS, 7, 7), [HCC_ISOC_THRES] = REG_FIELD(ISP176x_HC_HCCPARAMS, 4, 6), [CMD_LRESET] = REG_FIELD(ISP176x_HC_USBCMD, 7, 7), [CMD_RESET] = REG_FIELD(ISP176x_HC_USBCMD, 1, 1), [CMD_RUN] = REG_FIELD(ISP176x_HC_USBCMD, 0, 0), [STS_PCD] = REG_FIELD(ISP176x_HC_USBSTS, 2, 2), [HC_FRINDEX] = REG_FIELD(ISP176x_HC_FRINDEX, 0, 13), [FLAG_CF] = REG_FIELD(ISP176x_HC_CONFIGFLAG, 0, 0), [HC_ISO_PTD_DONEMAP] = REG_FIELD(ISP176x_HC_ISO_PTD_DONEMAP, 0, 31), [HC_ISO_PTD_SKIPMAP] = REG_FIELD(ISP176x_HC_ISO_PTD_SKIPMAP, 0, 31), [HC_ISO_PTD_LASTPTD] = REG_FIELD(ISP176x_HC_ISO_PTD_LASTPTD, 0, 31), [HC_INT_PTD_DONEMAP] = REG_FIELD(ISP176x_HC_INT_PTD_DONEMAP, 0, 31), [HC_INT_PTD_SKIPMAP] = REG_FIELD(ISP176x_HC_INT_PTD_SKIPMAP, 0, 31), [HC_INT_PTD_LASTPTD] = REG_FIELD(ISP176x_HC_INT_PTD_LASTPTD, 0, 31), [HC_ATL_PTD_DONEMAP] = REG_FIELD(ISP176x_HC_ATL_PTD_DONEMAP, 0, 31), [HC_ATL_PTD_SKIPMAP] = REG_FIELD(ISP176x_HC_ATL_PTD_SKIPMAP, 0, 31), [HC_ATL_PTD_LASTPTD] = REG_FIELD(ISP176x_HC_ATL_PTD_LASTPTD, 0, 31), [PORT_OWNER] = REG_FIELD(ISP176x_HC_PORTSC1, 13, 13), [PORT_POWER] = REG_FIELD(ISP176x_HC_PORTSC1, 12, 12), [PORT_LSTATUS] = REG_FIELD(ISP176x_HC_PORTSC1, 10, 11), [PORT_RESET] = REG_FIELD(ISP176x_HC_PORTSC1, 8, 8), [PORT_SUSPEND] = REG_FIELD(ISP176x_HC_PORTSC1, 7, 7), [PORT_RESUME] = REG_FIELD(ISP176x_HC_PORTSC1, 6, 6), [PORT_PE] = REG_FIELD(ISP176x_HC_PORTSC1, 2, 2), [PORT_CSC] = REG_FIELD(ISP176x_HC_PORTSC1, 1, 1), [PORT_CONNECT] = REG_FIELD(ISP176x_HC_PORTSC1, 0, 0), [ALL_ATX_RESET] = REG_FIELD(ISP176x_HC_HW_MODE_CTRL, 31, 31), [HW_ANA_DIGI_OC] = REG_FIELD(ISP176x_HC_HW_MODE_CTRL, 15, 15), [HW_COMN_IRQ] = REG_FIELD(ISP176x_HC_HW_MODE_CTRL, 10, 10), [HW_DATA_BUS_WIDTH] = REG_FIELD(ISP176x_HC_HW_MODE_CTRL, 8, 8), [HW_DACK_POL_HIGH] = REG_FIELD(ISP176x_HC_HW_MODE_CTRL, 6, 6), [HW_DREQ_POL_HIGH] = REG_FIELD(ISP176x_HC_HW_MODE_CTRL, 5, 5), [HW_INTR_HIGH_ACT] = REG_FIELD(ISP176x_HC_HW_MODE_CTRL, 2, 2), [HW_INTR_EDGE_TRIG] = REG_FIELD(ISP176x_HC_HW_MODE_CTRL, 1, 1), [HW_GLOBAL_INTR_EN] = REG_FIELD(ISP176x_HC_HW_MODE_CTRL, 0, 0), [HC_CHIP_REV] = REG_FIELD(ISP176x_HC_CHIP_ID, 16, 31), [HC_CHIP_ID_HIGH] = REG_FIELD(ISP176x_HC_CHIP_ID, 8, 15), [HC_CHIP_ID_LOW] = REG_FIELD(ISP176x_HC_CHIP_ID, 0, 7), [HC_SCRATCH] = REG_FIELD(ISP176x_HC_SCRATCH, 0, 31), [SW_RESET_RESET_ALL] = REG_FIELD(ISP176x_HC_RESET, 0, 0), [ISO_BUF_FILL] = REG_FIELD(ISP176x_HC_BUFFER_STATUS, 2, 2), [INT_BUF_FILL] = REG_FIELD(ISP176x_HC_BUFFER_STATUS, 1, 1), [ATL_BUF_FILL] = REG_FIELD(ISP176x_HC_BUFFER_STATUS, 0, 0), [MEM_BANK_SEL] = REG_FIELD(ISP176x_HC_MEMORY, 16, 17), [MEM_START_ADDR] = REG_FIELD(ISP176x_HC_MEMORY, 0, 15), [HC_INTERRUPT] = REG_FIELD(ISP176x_HC_INTERRUPT, 0, 9), [HC_ATL_IRQ_ENABLE] = REG_FIELD(ISP176x_HC_INTERRUPT_ENABLE, 8, 8), [HC_INT_IRQ_ENABLE] = REG_FIELD(ISP176x_HC_INTERRUPT_ENABLE, 7, 7), [HC_ISO_IRQ_MASK_OR] = REG_FIELD(ISP176x_HC_ISO_IRQ_MASK_OR, 0, 31), [HC_INT_IRQ_MASK_OR] = REG_FIELD(ISP176x_HC_INT_IRQ_MASK_OR, 0, 31), [HC_ATL_IRQ_MASK_OR] = REG_FIELD(ISP176x_HC_ATL_IRQ_MASK_OR, 0, 31), [HC_ISO_IRQ_MASK_AND] = REG_FIELD(ISP176x_HC_ISO_IRQ_MASK_AND, 0, 31), [HC_INT_IRQ_MASK_AND] = REG_FIELD(ISP176x_HC_INT_IRQ_MASK_AND, 0, 31), [HC_ATL_IRQ_MASK_AND] = REG_FIELD(ISP176x_HC_ATL_IRQ_MASK_AND, 0, 31), [HW_OTG_DISABLE] = REG_FIELD(ISP176x_HC_OTG_CTRL_SET, 10, 10), [HW_SW_SEL_HC_DC] = REG_FIELD(ISP176x_HC_OTG_CTRL_SET, 7, 7), [HW_VBUS_DRV] = REG_FIELD(ISP176x_HC_OTG_CTRL_SET, 4, 4), [HW_SEL_CP_EXT] = REG_FIELD(ISP176x_HC_OTG_CTRL_SET, 3, 3), [HW_DM_PULLDOWN] = REG_FIELD(ISP176x_HC_OTG_CTRL_SET, 2, 2), [HW_DP_PULLDOWN] = REG_FIELD(ISP176x_HC_OTG_CTRL_SET, 1, 1), [HW_DP_PULLUP] = REG_FIELD(ISP176x_HC_OTG_CTRL_SET, 0, 0), [HW_OTG_DISABLE_CLEAR] = REG_FIELD(ISP176x_HC_OTG_CTRL_CLEAR, 10, 10), [HW_SW_SEL_HC_DC_CLEAR] = REG_FIELD(ISP176x_HC_OTG_CTRL_CLEAR, 7, 7), [HW_VBUS_DRV_CLEAR] = REG_FIELD(ISP176x_HC_OTG_CTRL_CLEAR, 4, 4), [HW_SEL_CP_EXT_CLEAR] = REG_FIELD(ISP176x_HC_OTG_CTRL_CLEAR, 3, 3), [HW_DM_PULLDOWN_CLEAR] = REG_FIELD(ISP176x_HC_OTG_CTRL_CLEAR, 2, 2), [HW_DP_PULLDOWN_CLEAR] = REG_FIELD(ISP176x_HC_OTG_CTRL_CLEAR, 1, 1), [HW_DP_PULLUP_CLEAR] = REG_FIELD(ISP176x_HC_OTG_CTRL_CLEAR, 0, 0), /* Make sure the array is sized properly during compilation */ [HC_FIELD_MAX] = {}, }; static const struct regmap_config isp1763_hc_regmap_conf = { .width = REGMAP_SIZE_16, }; static const struct reg_field isp1763_hc_reg_fields[] = { [CMD_LRESET] = REG_FIELD(ISP1763_HC_USBCMD, 7, 7), [CMD_RESET] = REG_FIELD(ISP1763_HC_USBCMD, 1, 1), [CMD_RUN] = REG_FIELD(ISP1763_HC_USBCMD, 0, 0), [STS_PCD] = REG_FIELD(ISP1763_HC_USBSTS, 2, 2), [HC_FRINDEX] = REG_FIELD(ISP1763_HC_FRINDEX, 0, 13), [FLAG_CF] = REG_FIELD(ISP1763_HC_CONFIGFLAG, 0, 0), [HC_ISO_PTD_DONEMAP] = REG_FIELD(ISP1763_HC_ISO_PTD_DONEMAP, 0, 15), [HC_ISO_PTD_SKIPMAP] = REG_FIELD(ISP1763_HC_ISO_PTD_SKIPMAP, 0, 15), [HC_ISO_PTD_LASTPTD] = REG_FIELD(ISP1763_HC_ISO_PTD_LASTPTD, 0, 15), [HC_INT_PTD_DONEMAP] = REG_FIELD(ISP1763_HC_INT_PTD_DONEMAP, 0, 15), [HC_INT_PTD_SKIPMAP] = REG_FIELD(ISP1763_HC_INT_PTD_SKIPMAP, 0, 15), [HC_INT_PTD_LASTPTD] = REG_FIELD(ISP1763_HC_INT_PTD_LASTPTD, 0, 15), [HC_ATL_PTD_DONEMAP] = REG_FIELD(ISP1763_HC_ATL_PTD_DONEMAP, 0, 15), [HC_ATL_PTD_SKIPMAP] = REG_FIELD(ISP1763_HC_ATL_PTD_SKIPMAP, 0, 15), [HC_ATL_PTD_LASTPTD] = REG_FIELD(ISP1763_HC_ATL_PTD_LASTPTD, 0, 15), [PORT_OWNER] = REG_FIELD(ISP1763_HC_PORTSC1, 13, 13), [PORT_POWER] = REG_FIELD(ISP1763_HC_PORTSC1, 12, 12), [PORT_LSTATUS] = REG_FIELD(ISP1763_HC_PORTSC1, 10, 11), [PORT_RESET] = REG_FIELD(ISP1763_HC_PORTSC1, 8, 8), [PORT_SUSPEND] = REG_FIELD(ISP1763_HC_PORTSC1, 7, 7), [PORT_RESUME] = REG_FIELD(ISP1763_HC_PORTSC1, 6, 6), [PORT_PE] = REG_FIELD(ISP1763_HC_PORTSC1, 2, 2), [PORT_CSC] = REG_FIELD(ISP1763_HC_PORTSC1, 1, 1), [PORT_CONNECT] = REG_FIELD(ISP1763_HC_PORTSC1, 0, 0), [HW_DATA_BUS_WIDTH] = REG_FIELD(ISP1763_HC_HW_MODE_CTRL, 4, 4), [HW_DACK_POL_HIGH] = REG_FIELD(ISP1763_HC_HW_MODE_CTRL, 6, 6), [HW_DREQ_POL_HIGH] = REG_FIELD(ISP1763_HC_HW_MODE_CTRL, 5, 5), [HW_INTF_LOCK] = REG_FIELD(ISP1763_HC_HW_MODE_CTRL, 3, 3), [HW_INTR_HIGH_ACT] = REG_FIELD(ISP1763_HC_HW_MODE_CTRL, 2, 2), [HW_INTR_EDGE_TRIG] = REG_FIELD(ISP1763_HC_HW_MODE_CTRL, 1, 1), [HW_GLOBAL_INTR_EN] = REG_FIELD(ISP1763_HC_HW_MODE_CTRL, 0, 0), [SW_RESET_RESET_ATX] = REG_FIELD(ISP1763_HC_RESET, 3, 3), [SW_RESET_RESET_ALL] = REG_FIELD(ISP1763_HC_RESET, 0, 0), [HC_CHIP_ID_HIGH] = REG_FIELD(ISP1763_HC_CHIP_ID, 0, 15), [HC_CHIP_ID_LOW] = REG_FIELD(ISP1763_HC_CHIP_REV, 8, 15), [HC_CHIP_REV] = REG_FIELD(ISP1763_HC_CHIP_REV, 0, 7), [HC_SCRATCH] = REG_FIELD(ISP1763_HC_SCRATCH, 0, 15), [ISO_BUF_FILL] = REG_FIELD(ISP1763_HC_BUFFER_STATUS, 2, 2), [INT_BUF_FILL] = REG_FIELD(ISP1763_HC_BUFFER_STATUS, 1, 1), [ATL_BUF_FILL] = REG_FIELD(ISP1763_HC_BUFFER_STATUS, 0, 0), [MEM_START_ADDR] = REG_FIELD(ISP1763_HC_MEMORY, 0, 15), [HC_DATA] = REG_FIELD(ISP1763_HC_DATA, 0, 15), [HC_INTERRUPT] = REG_FIELD(ISP1763_HC_INTERRUPT, 0, 10), [HC_ATL_IRQ_ENABLE] = REG_FIELD(ISP1763_HC_INTERRUPT_ENABLE, 8, 8), [HC_INT_IRQ_ENABLE] = REG_FIELD(ISP1763_HC_INTERRUPT_ENABLE, 7, 7), [HC_ISO_IRQ_MASK_OR] = REG_FIELD(ISP1763_HC_ISO_IRQ_MASK_OR, 0, 15), [HC_INT_IRQ_MASK_OR] = REG_FIELD(ISP1763_HC_INT_IRQ_MASK_OR, 0, 15), [HC_ATL_IRQ_MASK_OR] = REG_FIELD(ISP1763_HC_ATL_IRQ_MASK_OR, 0, 15), [HC_ISO_IRQ_MASK_AND] = REG_FIELD(ISP1763_HC_ISO_IRQ_MASK_AND, 0, 15), [HC_INT_IRQ_MASK_AND] = REG_FIELD(ISP1763_HC_INT_IRQ_MASK_AND, 0, 15), [HC_ATL_IRQ_MASK_AND] = REG_FIELD(ISP1763_HC_ATL_IRQ_MASK_AND, 0, 15), [HW_HC_2_DIS] = REG_FIELD(ISP1763_HC_OTG_CTRL_SET, 15, 15), [HW_OTG_DISABLE] = REG_FIELD(ISP1763_HC_OTG_CTRL_SET, 10, 10), [HW_SW_SEL_HC_DC] = REG_FIELD(ISP1763_HC_OTG_CTRL_SET, 7, 7), [HW_VBUS_DRV] = REG_FIELD(ISP1763_HC_OTG_CTRL_SET, 4, 4), [HW_SEL_CP_EXT] = REG_FIELD(ISP1763_HC_OTG_CTRL_SET, 3, 3), [HW_DM_PULLDOWN] = REG_FIELD(ISP1763_HC_OTG_CTRL_SET, 2, 2), [HW_DP_PULLDOWN] = REG_FIELD(ISP1763_HC_OTG_CTRL_SET, 1, 1), [HW_DP_PULLUP] = REG_FIELD(ISP1763_HC_OTG_CTRL_SET, 0, 0), [HW_HC_2_DIS_CLEAR] = REG_FIELD(ISP1763_HC_OTG_CTRL_CLEAR, 15, 15), [HW_OTG_DISABLE_CLEAR] = REG_FIELD(ISP1763_HC_OTG_CTRL_CLEAR, 10, 10), [HW_SW_SEL_HC_DC_CLEAR] = REG_FIELD(ISP1763_HC_OTG_CTRL_CLEAR, 7, 7), [HW_VBUS_DRV_CLEAR] = REG_FIELD(ISP1763_HC_OTG_CTRL_CLEAR, 4, 4), [HW_SEL_CP_EXT_CLEAR] = REG_FIELD(ISP1763_HC_OTG_CTRL_CLEAR, 3, 3), [HW_DM_PULLDOWN_CLEAR] = REG_FIELD(ISP1763_HC_OTG_CTRL_CLEAR, 2, 2), [HW_DP_PULLDOWN_CLEAR] = REG_FIELD(ISP1763_HC_OTG_CTRL_CLEAR, 1, 1), [HW_DP_PULLUP_CLEAR] = REG_FIELD(ISP1763_HC_OTG_CTRL_CLEAR, 0, 0), /* Make sure the array is sized properly during compilation */ [HC_FIELD_MAX] = {}, }; int isp1760_register(struct isp1760_device *isp, struct resource *mem, int irq, unsigned long irqflags) { const struct regmap_config *hc_regmap; const struct reg_field *hc_reg_fields; struct isp1760_hcd *hcd; struct regmap_field *f; unsigned int devflags; struct udevice *dev; int ret; int i; hcd = &isp->hcd; devflags = isp->devflags; dev = isp->dev; hcd->is_isp1763 = !!(devflags & ISP1760_FLAG_ISP1763); if (!hcd->is_isp1763 && (devflags & ISP1760_FLAG_BUS_WIDTH_8)) { dev_err(dev, "isp1760/61 do not support data width 8\n"); return -EINVAL; } if (hcd->is_isp1763) { hc_regmap = &isp1763_hc_regmap_conf; hc_reg_fields = &isp1763_hc_reg_fields[0]; } else { hc_regmap = &isp1760_hc_regmap_conf; hc_reg_fields = &isp1760_hc_reg_fields[0]; } hcd->base = devm_ioremap(dev, mem->start, resource_size(mem)); if (IS_ERR(hcd->base)) return PTR_ERR(hcd->base); hcd->regs = devm_regmap_init(dev, NULL, NULL, hc_regmap); if (IS_ERR(hcd->regs)) return PTR_ERR(hcd->regs); for (i = 0; i < HC_FIELD_MAX; i++) { f = devm_regmap_field_alloc(dev, hcd->regs, hc_reg_fields[i]); if (IS_ERR(f)) return PTR_ERR(f); hcd->fields[i] = f; } if (hcd->is_isp1763) hcd->memory_layout = &isp1763_memory_conf; else hcd->memory_layout = &isp176x_memory_conf; ret = isp1760_init_core(isp); if (ret < 0) return ret; hcd->dev = dev; ret = isp1760_hcd_register(hcd, mem, irq, irqflags, dev); if (ret < 0) return ret; ret = isp1760_hcd_lowlevel_init(hcd); if (ret < 0) return ret; dev_set_drvdata(dev, isp); return 0; } void isp1760_unregister(struct isp1760_device *isp) { isp1760_hcd_unregister(&isp->hcd); }