drivers/gpu/drm/bridge/sil-sii8620.c

2166

struct device_node *musb, *muic;

drivers/gpu/drm/bridge/sil-sii8620.c

2170

musb = of_graph_get_remote_node(ctx->dev->of_node, 1, -1);

drivers/gpu/drm/bridge/sil-sii8620.c

2172

muic = of_get_next_parent(musb);

drivers/usb/musb/da8xx.c

105

static void da8xx_musb_disable(struct musb *musb)

drivers/usb/musb/da8xx.c

107

void __iomem *reg_base = musb->ctrl_base;

drivers/usb/musb/da8xx.c

117

static void da8xx_musb_set_vbus(struct musb *musb, int is_on)

drivers/usb/musb/da8xx.c

119

WARN_ON(is_on && is_peripheral_active(musb));

drivers/usb/musb/da8xx.c

126

struct musb *musb = timer_container_of(musb, t,

drivers/usb/musb/da8xx.c

128

void __iomem *mregs = musb->mregs;

drivers/usb/musb/da8xx.c

137

dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,

drivers/usb/musb/da8xx.c

138

usb_otg_state_string(musb->xceiv->otg->state));

drivers/usb/musb/da8xx.c

140

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/da8xx.c

141

switch (musb->xceiv->otg->state) {

drivers/usb/musb/da8xx.c

144

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/da8xx.c

146

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/da8xx.c

148

musb->xceiv->otg->state = OTG_STATE_B_IDLE;

drivers/usb/musb/da8xx.c

149

MUSB_DEV_MODE(musb);

drivers/usb/musb/da8xx.c

151

musb->xceiv->otg->state = OTG_STATE_A_IDLE;

drivers/usb/musb/da8xx.c

152

MUSB_HST_MODE(musb);

drivers/usb/musb/da8xx.c

163

mod_timer(&musb->dev_timer, jiffies + POLL_SECONDS * HZ);

drivers/usb/musb/da8xx.c

166

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;

drivers/usb/musb/da8xx.c

167

musb_writel(musb->ctrl_base, DA8XX_USB_INTR_SRC_SET_REG,

drivers/usb/musb/da8xx.c

186

mod_timer(&musb->dev_timer, jiffies + POLL_SECONDS * HZ);

drivers/usb/musb/da8xx.c

188

musb->xceiv->otg->state = OTG_STATE_A_IDLE;

drivers/usb/musb/da8xx.c

193

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/da8xx.c

196

static void __maybe_unused da8xx_musb_try_idle(struct musb *musb, unsigned long timeout)

drivers/usb/musb/da8xx.c

204

if (musb->is_active || (musb->a_wait_bcon == 0 &&

drivers/usb/musb/da8xx.c

205

musb->xceiv->otg->state == OTG_STATE_A_WAIT_BCON)) {

drivers/usb/musb/da8xx.c

206

dev_dbg(musb->controller, "%s active, deleting timer\n",

drivers/usb/musb/da8xx.c

207

usb_otg_state_string(musb->xceiv->otg->state));

drivers/usb/musb/da8xx.c

208

timer_delete(&musb->dev_timer);

drivers/usb/musb/da8xx.c

213

if (time_after(last_timer, timeout) && timer_pending(&musb->dev_timer)) {

drivers/usb/musb/da8xx.c

214

dev_dbg(musb->controller, "Longer idle timer already pending, ignoring...\n");

drivers/usb/musb/da8xx.c

219

dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n",

drivers/usb/musb/da8xx.c

220

usb_otg_state_string(musb->xceiv->otg->state),

drivers/usb/musb/da8xx.c

222

mod_timer(&musb->dev_timer, timeout);

drivers/usb/musb/da8xx.c

225

static int da8xx_babble_recover(struct musb *musb)

drivers/usb/musb/da8xx.c

227

dev_dbg(musb->controller, "resetting controller to recover from babble\n");

drivers/usb/musb/da8xx.c

228

musb_writel(musb->ctrl_base, DA8XX_USB_CTRL_REG, DA8XX_SOFT_RESET_MASK);

drivers/usb/musb/da8xx.c

234

struct musb *musb = hci;

drivers/usb/musb/da8xx.c

235

void __iomem *reg_base = musb->ctrl_base;

drivers/usb/musb/da8xx.c

240

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/da8xx.c

253

dev_dbg(musb->controller, "USB IRQ %08x\n", status);

drivers/usb/musb/da8xx.c

255

musb->int_rx = (status & DA8XX_INTR_RX_MASK) >> DA8XX_INTR_RX_SHIFT;

drivers/usb/musb/da8xx.c

256

musb->int_tx = (status & DA8XX_INTR_TX_MASK) >> DA8XX_INTR_TX_SHIFT;

drivers/usb/musb/da8xx.c

257

musb->int_usb = (status & DA8XX_INTR_USB_MASK) >> DA8XX_INTR_USB_SHIFT;

drivers/usb/musb/da8xx.c

269

void __iomem *mregs = musb->mregs;

drivers/usb/musb/da8xx.c

273

err = musb->int_usb & MUSB_INTR_VBUSERROR;

drivers/usb/musb/da8xx.c

286

musb->int_usb &= ~MUSB_INTR_VBUSERROR;

drivers/usb/musb/da8xx.c

287

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL;

drivers/usb/musb/da8xx.c

288

mod_timer(&musb->dev_timer, jiffies + POLL_SECONDS * HZ);

drivers/usb/musb/da8xx.c

291

MUSB_HST_MODE(musb);

drivers/usb/musb/da8xx.c

292

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;

drivers/usb/musb/da8xx.c

293

portstate(musb->port1_status |= USB_PORT_STAT_POWER);

drivers/usb/musb/da8xx.c

294

timer_delete(&musb->dev_timer);

drivers/usb/musb/da8xx.c

295

} else if (!(musb->int_usb & MUSB_INTR_BABBLE)) {

drivers/usb/musb/da8xx.c

304

musb->is_active = 0;

drivers/usb/musb/da8xx.c

305

MUSB_DEV_MODE(musb);

drivers/usb/musb/da8xx.c

306

musb->xceiv->otg->state = OTG_STATE_B_IDLE;

drivers/usb/musb/da8xx.c

307

portstate(musb->port1_status &= ~USB_PORT_STAT_POWER);

drivers/usb/musb/da8xx.c

310

dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n",

drivers/usb/musb/da8xx.c

312

usb_otg_state_string(musb->xceiv->otg->state),

drivers/usb/musb/da8xx.c

318

if (musb->int_tx || musb->int_rx || musb->int_usb)

drivers/usb/musb/da8xx.c

319

ret |= musb_interrupt(musb);

drivers/usb/musb/da8xx.c

327

if (musb->xceiv->otg->state == OTG_STATE_B_IDLE)

drivers/usb/musb/da8xx.c

328

mod_timer(&musb->dev_timer, jiffies + POLL_SECONDS * HZ);

drivers/usb/musb/da8xx.c

330

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/da8xx.c

335

static int da8xx_musb_set_mode(struct musb *musb, u8 musb_mode)

drivers/usb/musb/da8xx.c

337

struct da8xx_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/da8xx.c

357

static int da8xx_musb_init(struct musb *musb)

drivers/usb/musb/da8xx.c

359

struct da8xx_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/da8xx.c

360

void __iomem *reg_base = musb->ctrl_base;

drivers/usb/musb/da8xx.c

364

musb->mregs += DA8XX_MENTOR_CORE_OFFSET;

drivers/usb/musb/da8xx.c

379

musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);

drivers/usb/musb/da8xx.c

380

if (IS_ERR_OR_NULL(musb->xceiv)) {

drivers/usb/musb/da8xx.c

385

timer_setup(&musb->dev_timer, otg_timer, 0);

drivers/usb/musb/da8xx.c

409

musb->isr = da8xx_musb_interrupt;

drivers/usb/musb/da8xx.c

419

static int da8xx_musb_exit(struct musb *musb)

drivers/usb/musb/da8xx.c

421

struct da8xx_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/da8xx.c

423

timer_delete_sync(&musb->dev_timer);

drivers/usb/musb/da8xx.c

429

usb_put_phy(musb->xceiv);

drivers/usb/musb/da8xx.c

452

struct musb *musb = c->musb;

drivers/usb/musb/da8xx.c

453

void __iomem *reg_base = musb->ctrl_base;

drivers/usb/musb/da8xx.c

459

da8xx_dma_controller_create(struct musb *musb, void __iomem *base)

drivers/usb/musb/da8xx.c

463

controller = cppi41_dma_controller_create(musb, base);

drivers/usb/musb/da8xx.c

576

glue->musb = platform_device_register_full(&pinfo);

drivers/usb/musb/da8xx.c

577

ret = PTR_ERR_OR_ZERO(glue->musb);

drivers/usb/musb/da8xx.c

594

platform_device_unregister(glue->musb);

drivers/usb/musb/da8xx.c

70

struct platform_device *musb;

drivers/usb/musb/da8xx.c

86

static void da8xx_musb_enable(struct musb *musb)

drivers/usb/musb/da8xx.c

88

void __iomem *reg_base = musb->ctrl_base;

drivers/usb/musb/da8xx.c

92

mask = ((musb->epmask & DA8XX_USB_TX_EP_MASK) << DA8XX_INTR_TX_SHIFT) |

drivers/usb/musb/da8xx.c

93

((musb->epmask & DA8XX_USB_RX_EP_MASK) << DA8XX_INTR_RX_SHIFT) |

drivers/usb/musb/jz4740.c

103

static int jz4740_musb_init(struct musb *musb)

drivers/usb/musb/jz4740.c

105

struct device *dev = musb->controller->parent;

drivers/usb/musb/jz4740.c

114

glue->musb = musb;

drivers/usb/musb/jz4740.c

117

musb->phy = devm_of_phy_get_by_index(dev, dev->of_node, 0);

drivers/usb/musb/jz4740.c

118

if (IS_ERR(musb->phy)) {

drivers/usb/musb/jz4740.c

119

err = PTR_ERR(musb->phy);

drivers/usb/musb/jz4740.c

125

musb->phy = NULL;

drivers/usb/musb/jz4740.c

129

if (musb->phy) {

drivers/usb/musb/jz4740.c

130

err = phy_init(musb->phy);

drivers/usb/musb/jz4740.c

136

err = phy_power_on(musb->phy);

drivers/usb/musb/jz4740.c

143

musb->xceiv = devm_usb_get_phy_by_phandle(dev, "phys", 0);

drivers/usb/musb/jz4740.c

145

musb->xceiv = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);

drivers/usb/musb/jz4740.c

146

if (IS_ERR(musb->xceiv)) {

drivers/usb/musb/jz4740.c

148

return PTR_ERR(musb->xceiv);

drivers/usb/musb/jz4740.c

163

musb->dyn_fifo = true;

drivers/usb/musb/jz4740.c

165

musb->isr = jz4740_musb_interrupt;

drivers/usb/musb/jz4740.c

170

if (musb->phy)

drivers/usb/musb/jz4740.c

171

phy_power_off(musb->phy);

drivers/usb/musb/jz4740.c

173

if (musb->phy)

drivers/usb/musb/jz4740.c

174

phy_exit(musb->phy);

drivers/usb/musb/jz4740.c

178

static int jz4740_musb_exit(struct musb *musb)

drivers/usb/musb/jz4740.c

180

struct jz4740_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/jz4740.c

183

if (musb->phy) {

drivers/usb/musb/jz4740.c

184

phy_power_off(musb->phy);

drivers/usb/musb/jz4740.c

185

phy_exit(musb->phy);

drivers/usb/musb/jz4740.c

23

struct musb *musb;

drivers/usb/musb/jz4740.c

239

struct platform_device *musb;

drivers/usb/musb/jz4740.c

254

musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);

drivers/usb/musb/jz4740.c

255

if (!musb) {

drivers/usb/musb/jz4740.c

273

musb->dev.parent = dev;

drivers/usb/musb/jz4740.c

274

musb->dev.dma_mask = &musb->dev.coherent_dma_mask;

drivers/usb/musb/jz4740.c

275

musb->dev.coherent_dma_mask = DMA_BIT_MASK(32);

drivers/usb/musb/jz4740.c

276

device_set_of_node_from_dev(&musb->dev, dev);

drivers/usb/musb/jz4740.c

278

glue->pdev = musb;

drivers/usb/musb/jz4740.c

283

ret = platform_device_add_resources(musb, pdev->resource,

drivers/usb/musb/jz4740.c

290

ret = platform_device_add_data(musb, pdata, sizeof(*pdata));

drivers/usb/musb/jz4740.c

296

ret = platform_device_add(musb);

drivers/usb/musb/jz4740.c

307

platform_device_put(musb);

drivers/usb/musb/jz4740.c

32

struct musb *musb = __hci;

drivers/usb/musb/jz4740.c

34

if (IS_ENABLED(CONFIG_USB_INVENTRA_DMA) && musb->dma_controller)

drivers/usb/musb/jz4740.c

35

retval_dma = dma_controller_irq(irq, musb->dma_controller);

drivers/usb/musb/jz4740.c

37

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/jz4740.c

39

musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);

drivers/usb/musb/jz4740.c

40

musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);

drivers/usb/musb/jz4740.c

41

musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);

drivers/usb/musb/jz4740.c

48

musb->int_usb &= MUSB_INTR_SUSPEND | MUSB_INTR_RESUME |

drivers/usb/musb/jz4740.c

51

if (musb->int_usb || musb->int_tx || musb->int_rx)

drivers/usb/musb/jz4740.c

52

retval = musb_interrupt(musb);

drivers/usb/musb/jz4740.c

54

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/jz4740.c

83

struct usb_phy *phy = glue->musb->xceiv;

drivers/usb/musb/mediatek.c

102

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/mediatek.c

153

struct musb *musb = __hci;

drivers/usb/musb/mediatek.c

155

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/mediatek.c

156

musb->int_usb = musb_clearb(musb->mregs, MUSB_INTRUSB);

drivers/usb/musb/mediatek.c

157

musb->int_rx = musb_clearw(musb->mregs, MUSB_INTRRX);

drivers/usb/musb/mediatek.c

158

musb->int_tx = musb_clearw(musb->mregs, MUSB_INTRTX);

drivers/usb/musb/mediatek.c

160

if ((musb->int_usb & MUSB_INTR_RESET) && !is_host_active(musb)) {

drivers/usb/musb/mediatek.c

162

musb_ep_select(musb->mregs, 0);

drivers/usb/musb/mediatek.c

163

musb_writeb(musb->mregs, MUSB_FADDR, 0);

drivers/usb/musb/mediatek.c

166

if (musb->int_usb || musb->int_tx || musb->int_rx)

drivers/usb/musb/mediatek.c

167

retval = musb_interrupt(musb);

drivers/usb/musb/mediatek.c

169

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/mediatek.c

177

struct musb *musb = (struct musb *)dev_id;

drivers/usb/musb/mediatek.c

180

l1_ints = musb_readl(musb->mregs, USB_L1INTS) &

drivers/usb/musb/mediatek.c

181

musb_readl(musb->mregs, USB_L1INTM);

drivers/usb/musb/mediatek.c

184

retval = generic_interrupt(irq, musb);

drivers/usb/musb/mediatek.c

188

retval = dma_controller_irq(irq, musb->dma_controller);

drivers/usb/musb/mediatek.c

218

static int mtk_musb_set_mode(struct musb *musb, u8 mode)

drivers/usb/musb/mediatek.c

220

struct device *dev = musb->controller;

drivers/usb/musb/mediatek.c

246

if (musb->port_mode != MUSB_OTG) {

drivers/usb/musb/mediatek.c

255

static int mtk_musb_init(struct musb *musb)

drivers/usb/musb/mediatek.c

257

struct device *dev = musb->controller;

drivers/usb/musb/mediatek.c

261

glue->musb = musb;

drivers/usb/musb/mediatek.c

262

musb->phy = glue->phy;

drivers/usb/musb/mediatek.c

263

musb->xceiv = glue->xceiv;

drivers/usb/musb/mediatek.c

264

musb->is_host = false;

drivers/usb/musb/mediatek.c

265

musb->isr = mtk_musb_interrupt;

drivers/usb/musb/mediatek.c

268

musb_writew(musb->mregs, MUSB_TXTOGEN, MTK_TOGGLE_EN);

drivers/usb/musb/mediatek.c

269

musb_writew(musb->mregs, MUSB_RXTOGEN, MTK_TOGGLE_EN);

drivers/usb/musb/mediatek.c

271

if (musb->port_mode == MUSB_OTG) {

drivers/usb/musb/mediatek.c

288

musb_writel(musb->mregs, MUSB_HSDMA_INTR,

drivers/usb/musb/mediatek.c

291

musb_writel(musb->mregs, USB_L1INTM, TX_INT_STATUS | RX_INT_STATUS |

drivers/usb/musb/mediatek.c

298

if (musb->port_mode == MUSB_OTG)

drivers/usb/musb/mediatek.c

305

struct musb *musb = qh->hw_ep->musb;

drivers/usb/musb/mediatek.c

309

toggle = musb_readw(musb->mregs, is_out ? MUSB_TXTOG : MUSB_RXTOG);

drivers/usb/musb/mediatek.c

315

struct musb *musb = qh->hw_ep->musb;

drivers/usb/musb/mediatek.c

322

value = musb_readw(musb->mregs, MUSB_TXTOG);

drivers/usb/musb/mediatek.c

324

musb_writew(musb->mregs, MUSB_TXTOG, value);

drivers/usb/musb/mediatek.c

326

value = musb_readw(musb->mregs, MUSB_RXTOG);

drivers/usb/musb/mediatek.c

328

musb_writew(musb->mregs, MUSB_RXTOG, value);

drivers/usb/musb/mediatek.c

334

static int mtk_musb_exit(struct musb *musb)

drivers/usb/musb/mediatek.c

336

struct device *dev = musb->controller;

drivers/usb/musb/mediatek.c

44

struct musb *musb;

drivers/usb/musb/mediatek.c

68

struct musb *musb = glue->musb;

drivers/usb/musb/mediatek.c

69

u8 devctl = readb(musb->mregs + MUSB_DEVCTL);

drivers/usb/musb/mediatek.c

77

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;

drivers/usb/musb/mediatek.c

84

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/mediatek.c

85

MUSB_HST_MODE(musb);

drivers/usb/musb/mediatek.c

88

musb->xceiv->otg->state = OTG_STATE_B_IDLE;

drivers/usb/musb/mediatek.c

92

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/mediatek.c

96

MUSB_DEV_MODE(musb);

drivers/usb/musb/mpfs.c

105

dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,

drivers/usb/musb/mpfs.c

106

usb_otg_state_string(musb->xceiv->otg->state));

drivers/usb/musb/mpfs.c

108

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/mpfs.c

109

switch (musb->xceiv->otg->state) {

drivers/usb/musb/mpfs.c

112

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/mpfs.c

114

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/mpfs.c

116

musb->xceiv->otg->state = OTG_STATE_B_IDLE;

drivers/usb/musb/mpfs.c

117

MUSB_DEV_MODE(musb);

drivers/usb/musb/mpfs.c

118

mod_timer(&musb->dev_timer, jiffies + POLL_SECONDS * HZ);

drivers/usb/musb/mpfs.c

120

musb->xceiv->otg->state = OTG_STATE_A_IDLE;

drivers/usb/musb/mpfs.c

121

MUSB_HST_MODE(musb);

drivers/usb/musb/mpfs.c

126

mod_timer(&musb->dev_timer, jiffies + POLL_SECONDS * HZ);

drivers/usb/musb/mpfs.c

129

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;

drivers/usb/musb/mpfs.c

147

mod_timer(&musb->dev_timer, jiffies + POLL_SECONDS * HZ);

drivers/usb/musb/mpfs.c

149

musb->xceiv->otg->state = OTG_STATE_A_IDLE;

drivers/usb/musb/mpfs.c

154

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/mpfs.c

157

static void __maybe_unused mpfs_musb_try_idle(struct musb *musb, unsigned long timeout)

drivers/usb/musb/mpfs.c

165

if (musb->is_active || (musb->a_wait_bcon == 0 &&

drivers/usb/musb/mpfs.c

166

musb->xceiv->otg->state == OTG_STATE_A_WAIT_BCON)) {

drivers/usb/musb/mpfs.c

167

dev_dbg(musb->controller, "%s active, deleting timer\n",

drivers/usb/musb/mpfs.c

168

usb_otg_state_string(musb->xceiv->otg->state));

drivers/usb/musb/mpfs.c

169

timer_delete(&musb->dev_timer);

drivers/usb/musb/mpfs.c

174

if (time_after(last_timer, timeout) && timer_pending(&musb->dev_timer)) {

drivers/usb/musb/mpfs.c

175

dev_dbg(musb->controller, "Longer idle timer already pending, ignoring...\n");

drivers/usb/musb/mpfs.c

180

dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n",

drivers/usb/musb/mpfs.c

181

usb_otg_state_string(musb->xceiv->otg->state),

drivers/usb/musb/mpfs.c

183

mod_timer(&musb->dev_timer, timeout);

drivers/usb/musb/mpfs.c

190

struct musb *musb = __hci;

drivers/usb/musb/mpfs.c

192

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/mpfs.c

194

musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);

drivers/usb/musb/mpfs.c

195

musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);

drivers/usb/musb/mpfs.c

196

musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);

drivers/usb/musb/mpfs.c

198

if (musb->int_usb || musb->int_tx || musb->int_rx) {

drivers/usb/musb/mpfs.c

199

musb_writeb(musb->mregs, MUSB_INTRUSB, musb->int_usb);

drivers/usb/musb/mpfs.c

200

musb_writew(musb->mregs, MUSB_INTRTX, musb->int_tx);

drivers/usb/musb/mpfs.c

201

musb_writew(musb->mregs, MUSB_INTRRX, musb->int_rx);

drivers/usb/musb/mpfs.c

202

ret = musb_interrupt(musb);

drivers/usb/musb/mpfs.c

206

if (musb->xceiv->otg->state == OTG_STATE_B_IDLE)

drivers/usb/musb/mpfs.c

207

mod_timer(&musb->dev_timer, jiffies + POLL_SECONDS * HZ);

drivers/usb/musb/mpfs.c

209

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/mpfs.c

214

static int mpfs_musb_init(struct musb *musb)

drivers/usb/musb/mpfs.c

216

struct device *dev = musb->controller;

drivers/usb/musb/mpfs.c

218

musb->xceiv = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);

drivers/usb/musb/mpfs.c

219

if (IS_ERR(musb->xceiv)) {

drivers/usb/musb/mpfs.c

221

return PTR_ERR(musb->xceiv);

drivers/usb/musb/mpfs.c

224

timer_setup(&musb->dev_timer, otg_timer, 0);

drivers/usb/musb/mpfs.c

226

musb->dyn_fifo = true;

drivers/usb/musb/mpfs.c

227

musb->isr = mpfs_musb_interrupt;

drivers/usb/musb/mpfs.c

229

musb_platform_set_vbus(musb, 1);

drivers/usb/musb/mpfs.c

234

static int mpfs_musb_exit(struct musb *musb)

drivers/usb/musb/mpfs.c

236

timer_delete_sync(&musb->dev_timer);

drivers/usb/musb/mpfs.c

27

struct platform_device *musb;

drivers/usb/musb/mpfs.c

294

glue->musb = musb_pdev;

drivers/usb/musb/mpfs.c

359

platform_device_unregister(glue->musb);

drivers/usb/musb/mpfs.c

52

static void mpfs_musb_set_vbus(struct musb *musb, int is_on)

drivers/usb/musb/mpfs.c

61

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/mpfs.c

64

musb->is_active = 1;

drivers/usb/musb/mpfs.c

65

musb->xceiv->otg->default_a = 1;

drivers/usb/musb/mpfs.c

66

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;

drivers/usb/musb/mpfs.c

68

MUSB_HST_MODE(musb);

drivers/usb/musb/mpfs.c

70

musb->is_active = 0;

drivers/usb/musb/mpfs.c

76

musb->xceiv->otg->default_a = 0;

drivers/usb/musb/mpfs.c

77

musb->xceiv->otg->state = OTG_STATE_B_IDLE;

drivers/usb/musb/mpfs.c

80

MUSB_DEV_MODE(musb);

drivers/usb/musb/mpfs.c

83

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/mpfs.c

85

dev_dbg(musb->controller, "VBUS %s, devctl %02x\n",

drivers/usb/musb/mpfs.c

86

usb_otg_state_string(musb->xceiv->otg->state),

drivers/usb/musb/mpfs.c

87

musb_readb(musb->mregs, MUSB_DEVCTL));

drivers/usb/musb/mpfs.c

94

struct musb *musb = timer_container_of(musb, t,

drivers/usb/musb/mpfs.c

96

void __iomem *mregs = musb->mregs;

drivers/usb/musb/musb_core.c

1001

dev_err(musb->controller, "Babble\n");

drivers/usb/musb/musb_core.c

1002

musb_recover_from_babble(musb);

drivers/usb/musb/musb_core.c

1004

musb_dbg(musb, "BUS RESET as %s", musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

1005

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_core.c

1007

musb_g_reset(musb);

drivers/usb/musb/musb_core.c

1011

musb_dbg(musb, "HNP: in %s, %d msec timeout",

drivers/usb/musb/musb_core.c

1012

musb_otg_state_string(musb),

drivers/usb/musb/musb_core.c

1013

TA_WAIT_BCON(musb));

drivers/usb/musb/musb_core.c

1014

mod_timer(&musb->otg_timer, jiffies

drivers/usb/musb/musb_core.c

1015

+ msecs_to_jiffies(TA_WAIT_BCON(musb)));

drivers/usb/musb/musb_core.c

1018

timer_delete(&musb->otg_timer);

drivers/usb/musb/musb_core.c

1019

musb_g_reset(musb);

drivers/usb/musb/musb_core.c

1022

musb_dbg(musb, "HNP: RESET (%s), to b_peripheral",

drivers/usb/musb/musb_core.c

1023

musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

1024

musb_set_state(musb, OTG_STATE_B_PERIPHERAL);

drivers/usb/musb/musb_core.c

1025

musb_g_reset(musb);

drivers/usb/musb/musb_core.c

1028

musb_set_state(musb, OTG_STATE_B_PERIPHERAL);

drivers/usb/musb/musb_core.c

1031

musb_g_reset(musb);

drivers/usb/musb/musb_core.c

1034

musb_dbg(musb, "Unhandled BUS RESET as %s",

drivers/usb/musb/musb_core.c

1035

musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

1051

static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,

drivers/usb/musb/musb_core.c

1056

musb_dbg(musb, "<== DevCtl=%02x, int_usb=0x%x", devctl, int_usb);

drivers/usb/musb/musb_core.c

106

static inline struct musb *dev_to_musb(struct device *dev)

drivers/usb/musb/musb_core.c

1063

musb_handle_intr_resume(musb, devctl);

drivers/usb/musb/musb_core.c

1069

if (musb_handle_intr_sessreq(musb, devctl))

drivers/usb/musb/musb_core.c

1075

musb_handle_intr_vbuserr(musb, devctl);

drivers/usb/musb/musb_core.c

1080

musb_handle_intr_suspend(musb, devctl);

drivers/usb/musb/musb_core.c

1085

musb_handle_intr_connect(musb, devctl, int_usb);

drivers/usb/musb/musb_core.c

1090

musb_handle_intr_disconnect(musb, devctl);

drivers/usb/musb/musb_core.c

1095

musb_handle_intr_reset(musb);

drivers/usb/musb/musb_core.c

1112

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_core.c

1117

dev_dbg(musb->controller, "START_OF_FRAME\n");

drivers/usb/musb/musb_core.c

1122

ep = musb->endpoints;

drivers/usb/musb/musb_core.c

1123

for (epnum = 1; (epnum < musb->nr_endpoints)

drivers/usb/musb/musb_core.c

1124

&& (musb->epmask >= (1 << epnum));

drivers/usb/musb/musb_core.c

1136

musb_h_tx_start(musb, epnum);

drivers/usb/musb/musb_core.c

1138

cppi_hostdma_start(musb, epnum);

drivers/usb/musb/musb_core.c

1144

schedule_delayed_work(&musb->irq_work, 0);

drivers/usb/musb/musb_core.c

1151

static void musb_disable_interrupts(struct musb *musb)

drivers/usb/musb/musb_core.c

1153

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_core.c

1157

musb->intrtxe = 0;

drivers/usb/musb/musb_core.c

1159

musb->intrrxe = 0;

drivers/usb/musb/musb_core.c

1168

static void musb_enable_interrupts(struct musb *musb)

drivers/usb/musb/musb_core.c

1170

void __iomem *regs = musb->mregs;

drivers/usb/musb/musb_core.c

1173

musb->intrtxe = musb->epmask;

drivers/usb/musb/musb_core.c

1174

musb_writew(regs, MUSB_INTRTXE, musb->intrtxe);

drivers/usb/musb/musb_core.c

1175

musb->intrrxe = musb->epmask & 0xfffe;

drivers/usb/musb/musb_core.c

1176

musb_writew(regs, MUSB_INTRRXE, musb->intrrxe);

drivers/usb/musb/musb_core.c

1184

void musb_start(struct musb *musb)

drivers/usb/musb/musb_core.c

1186

void __iomem *regs = musb->mregs;

drivers/usb/musb/musb_core.c

1190

musb_dbg(musb, "<== devctl %02x", devctl);

drivers/usb/musb/musb_core.c

1192

musb_enable_interrupts(musb);

drivers/usb/musb/musb_core.c

1200

if (musb->config->maximum_speed == USB_SPEED_HIGH ||

drivers/usb/musb/musb_core.c

1201

musb->config->maximum_speed == USB_SPEED_UNKNOWN)

drivers/usb/musb/musb_core.c

1205

musb->is_active = 0;

drivers/usb/musb/musb_core.c

1214

if (musb->port_mode != MUSB_HOST &&

drivers/usb/musb/musb_core.c

1215

musb_get_state(musb) != OTG_STATE_A_WAIT_BCON &&

drivers/usb/musb/musb_core.c

1217

musb->is_active = 1;

drivers/usb/musb/musb_core.c

1222

musb_platform_enable(musb);

drivers/usb/musb/musb_core.c

1233

void musb_stop(struct musb *musb)

drivers/usb/musb/musb_core.c

1236

musb_platform_disable(musb);

drivers/usb/musb/musb_core.c

1237

musb_disable_interrupts(musb);

drivers/usb/musb/musb_core.c

1238

musb_writeb(musb->mregs, MUSB_DEVCTL, 0);

drivers/usb/musb/musb_core.c

1247

musb_platform_try_idle(musb, 0);

drivers/usb/musb/musb_core.c

1380

fifo_setup(struct musb *musb, struct musb_hw_ep *hw_ep,

drivers/usb/musb/musb_core.c

1383

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_core.c

1397

(1 << (musb->config->ram_bits + 2)))

drivers/usb/musb/musb_core.c

1401

if ((offset + maxpacket) > (1 << (musb->config->ram_bits + 2)))

drivers/usb/musb/musb_core.c

1412

musb->bulk_ep = hw_ep;

drivers/usb/musb/musb_core.c

1445

musb->epmask |= (1 << hw_ep->epnum);

drivers/usb/musb/musb_core.c

1454

static int ep_config_from_table(struct musb *musb)

drivers/usb/musb/musb_core.c

1459

struct musb_hw_ep *hw_ep = musb->endpoints;

drivers/usb/musb/musb_core.c

1461

if (musb->config->fifo_cfg) {

drivers/usb/musb/musb_core.c

1462

cfg = musb->config->fifo_cfg;

drivers/usb/musb/musb_core.c

1463

n = musb->config->fifo_cfg_size;

drivers/usb/musb/musb_core.c

1501

offset = fifo_setup(musb, hw_ep, &ep0_cfg, 0);

drivers/usb/musb/musb_core.c

1511

if (epn >= musb->config->num_eps) {

drivers/usb/musb/musb_core.c

1516

offset = fifo_setup(musb, hw_ep + epn, cfg++, offset);

drivers/usb/musb/musb_core.c

1523

musb->nr_endpoints = max(epn, musb->nr_endpoints);

drivers/usb/musb/musb_core.c

1528

n + 1, musb->config->num_eps * 2 - 1,

drivers/usb/musb/musb_core.c

1529

offset, (1 << (musb->config->ram_bits + 2)));

drivers/usb/musb/musb_core.c

1531

if (!musb->bulk_ep) {

drivers/usb/musb/musb_core.c

1544

static int ep_config_from_hw(struct musb *musb)

drivers/usb/musb/musb_core.c

1548

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_core.c

1551

musb_dbg(musb, "<== static silicon ep config");

drivers/usb/musb/musb_core.c

1555

for (epnum = 1; epnum < musb->config->num_eps; epnum++) {

drivers/usb/musb/musb_core.c

1557

hw_ep = musb->endpoints + epnum;

drivers/usb/musb/musb_core.c

1559

ret = musb_read_fifosize(musb, hw_ep, epnum);

drivers/usb/musb/musb_core.c

1573

if (musb->bulk_ep)

drivers/usb/musb/musb_core.c

1575

musb->bulk_ep = hw_ep;

drivers/usb/musb/musb_core.c

1578

if (!musb->bulk_ep) {

drivers/usb/musb/musb_core.c

1591

static int musb_core_init(u16 musb_type, struct musb *musb)

drivers/usb/musb/musb_core.c

1596

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_core.c

1606

musb->dyn_fifo = true;

drivers/usb/musb/musb_core.c

1610

musb->bulk_combine = true;

drivers/usb/musb/musb_core.c

1614

musb->bulk_split = true;

drivers/usb/musb/musb_core.c

1618

musb->hb_iso_rx = true;

drivers/usb/musb/musb_core.c

1622

musb->hb_iso_tx = true;

drivers/usb/musb/musb_core.c

1630

musb->is_multipoint = 1;

drivers/usb/musb/musb_core.c

1633

musb->is_multipoint = 0;

drivers/usb/musb/musb_core.c

1643

musb->hwvers = musb_readw(mbase, MUSB_HWVERS);

drivers/usb/musb/musb_core.c

1645

musb_driver_name, type, MUSB_HWVERS_MAJOR(musb->hwvers),

drivers/usb/musb/musb_core.c

1646

MUSB_HWVERS_MINOR(musb->hwvers),

drivers/usb/musb/musb_core.c

1647

(musb->hwvers & MUSB_HWVERS_RC) ? "RC" : "");

drivers/usb/musb/musb_core.c

1650

musb_configure_ep0(musb);

drivers/usb/musb/musb_core.c

1653

musb->nr_endpoints = 1;

drivers/usb/musb/musb_core.c

1654

musb->epmask = 1;

drivers/usb/musb/musb_core.c

1656

if (musb->dyn_fifo)

drivers/usb/musb/musb_core.c

1657

status = ep_config_from_table(musb);

drivers/usb/musb/musb_core.c

1659

status = ep_config_from_hw(musb);

drivers/usb/musb/musb_core.c

1665

for (i = 0; i < musb->nr_endpoints; i++) {

drivers/usb/musb/musb_core.c

1666

struct musb_hw_ep *hw_ep = musb->endpoints + i;

drivers/usb/musb/musb_core.c

1668

hw_ep->fifo = musb->io.fifo_offset(i) + mbase;

drivers/usb/musb/musb_core.c

1670

if (musb->ops->quirks & MUSB_IN_TUSB) {

drivers/usb/musb/musb_core.c

1671

hw_ep->fifo_async = musb->async + 0x400 +

drivers/usb/musb/musb_core.c

1672

musb->io.fifo_offset(i);

drivers/usb/musb/musb_core.c

1673

hw_ep->fifo_sync = musb->sync + 0x400 +

drivers/usb/musb/musb_core.c

1674

musb->io.fifo_offset(i);

drivers/usb/musb/musb_core.c

1676

musb->sync_va + 0x400 + musb->io.fifo_offset(i);

drivers/usb/musb/musb_core.c

1686

hw_ep->regs = musb->io.ep_offset(i, 0) + mbase;

drivers/usb/musb/musb_core.c

1691

musb_dbg(musb, "%s: hw_ep %d%s, %smax %d",

drivers/usb/musb/musb_core.c

1699

musb_dbg(musb, "%s: hw_ep %d%s, %smax %d",

drivers/usb/musb/musb_core.c

1707

musb_dbg(musb, "hw_ep %d not configured", i);

drivers/usb/musb/musb_core.c

1722

irqreturn_t musb_interrupt(struct musb *musb)

drivers/usb/musb/musb_core.c

1729

if (!musb->int_usb && !musb->int_tx && !musb->int_rx)

drivers/usb/musb/musb_core.c

1732

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/musb_core.c

1734

trace_musb_isr(musb);

drivers/usb/musb/musb_core.c

1756

if (musb->int_usb)

drivers/usb/musb/musb_core.c

1757

retval |= musb_stage0_irq(musb, musb->int_usb, devctl);

drivers/usb/musb/musb_core.c

1759

if (musb->int_tx & 1) {

drivers/usb/musb/musb_core.c

1760

if (is_host_active(musb))

drivers/usb/musb/musb_core.c

1761

retval |= musb_h_ep0_irq(musb);

drivers/usb/musb/musb_core.c

1763

retval |= musb_g_ep0_irq(musb);

drivers/usb/musb/musb_core.c

1766

musb->int_tx &= ~BIT(0);

drivers/usb/musb/musb_core.c

1769

status = musb->int_tx;

drivers/usb/musb/musb_core.c

1773

if (is_host_active(musb))

drivers/usb/musb/musb_core.c

1774

musb_host_tx(musb, epnum);

drivers/usb/musb/musb_core.c

1776

musb_g_tx(musb, epnum);

drivers/usb/musb/musb_core.c

1779

status = musb->int_rx;

drivers/usb/musb/musb_core.c

1783

if (is_host_active(musb))

drivers/usb/musb/musb_core.c

1784

musb_host_rx(musb, epnum);

drivers/usb/musb/musb_core.c

1786

musb_g_rx(musb, epnum);

drivers/usb/musb/musb_core.c

1800

void musb_dma_completion(struct musb *musb, u8 epnum, u8 transmit)

drivers/usb/musb/musb_core.c

1805

if (!is_cppi_enabled(musb)) {

drivers/usb/musb/musb_core.c

1807

if (is_host_active(musb))

drivers/usb/musb/musb_core.c

1808

musb_h_ep0_irq(musb);

drivers/usb/musb/musb_core.c

1810

musb_g_ep0_irq(musb);

drivers/usb/musb/musb_core.c

1815

if (is_host_active(musb))

drivers/usb/musb/musb_core.c

1816

musb_host_tx(musb, epnum);

drivers/usb/musb/musb_core.c

1818

musb_g_tx(musb, epnum);

drivers/usb/musb/musb_core.c

1821

if (is_host_active(musb))

drivers/usb/musb/musb_core.c

1822

musb_host_rx(musb, epnum);

drivers/usb/musb/musb_core.c

1824

musb_g_rx(musb, epnum);

drivers/usb/musb/musb_core.c

1857

struct musb *musb = dev_to_musb(dev);

drivers/usb/musb/musb_core.c

1861

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_core.c

1862

ret = sprintf(buf, "%s\n", musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

1863

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_core.c

1872

struct musb *musb = dev_to_musb(dev);

drivers/usb/musb/musb_core.c

1876

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_core.c

1878

status = musb_platform_set_mode(musb, MUSB_HOST);

drivers/usb/musb/musb_core.c

1880

status = musb_platform_set_mode(musb, MUSB_PERIPHERAL);

drivers/usb/musb/musb_core.c

1882

status = musb_platform_set_mode(musb, MUSB_OTG);

drivers/usb/musb/musb_core.c

1885

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_core.c

1895

struct musb *musb = dev_to_musb(dev);

drivers/usb/musb/musb_core.c

1904

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_core.c

1906

musb->a_wait_bcon = val ? max_t(int, val, OTG_TIME_A_WAIT_BCON) : 0 ;

drivers/usb/musb/musb_core.c

1907

if (musb_get_state(musb) == OTG_STATE_A_WAIT_BCON)

drivers/usb/musb/musb_core.c

1908

musb->is_active = 0;

drivers/usb/musb/musb_core.c

1909

musb_platform_try_idle(musb, jiffies + msecs_to_jiffies(val));

drivers/usb/musb/musb_core.c

1910

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_core.c

1918

struct musb *musb = dev_to_musb(dev);

drivers/usb/musb/musb_core.c

1925

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_core.c

1926

val = musb->a_wait_bcon;

drivers/usb/musb/musb_core.c

1927

vbus = musb_platform_get_vbus_status(musb);

drivers/usb/musb/musb_core.c

1930

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/musb_core.c

1937

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_core.c

1951

struct musb *musb = dev_to_musb(dev);

drivers/usb/musb/musb_core.c

1961

musb_g_wakeup(musb);

drivers/usb/musb/musb_core.c

1973

ATTRIBUTE_GROUPS(musb);

drivers/usb/musb/musb_core.c

1984

static bool musb_state_needs_recheck(struct musb *musb, u8 devctl,

drivers/usb/musb/musb_core.c

1987

if (musb->quirk_retries && !musb->flush_irq_work) {

drivers/usb/musb/musb_core.c

1988

trace_musb_state(musb, devctl, desc);

drivers/usb/musb/musb_core.c

1989

schedule_delayed_work(&musb->irq_work,

drivers/usb/musb/musb_core.c

1991

musb->quirk_retries--;

drivers/usb/musb/musb_core.c

2007

static void musb_pm_runtime_check_session(struct musb *musb)

drivers/usb/musb/musb_core.c

2012

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/musb_core.c

2019

musb_state_needs_recheck(musb, devctl,

drivers/usb/musb/musb_core.c

2023

if (musb_state_needs_recheck(musb, devctl,

drivers/usb/musb/musb_core.c

2028

if (musb_state_needs_recheck(musb, devctl,

drivers/usb/musb/musb_core.c

2031

if (!musb->session)

drivers/usb/musb/musb_core.c

2033

trace_musb_state(musb, devctl, "Allow PM on possible host mode disconnect");

drivers/usb/musb/musb_core.c

2034

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_core.c

2035

musb->session = false;

drivers/usb/musb/musb_core.c

2043

if (s == musb->session)

drivers/usb/musb/musb_core.c

2048

trace_musb_state(musb, devctl, "Block PM on active session");

drivers/usb/musb/musb_core.c

2049

error = pm_runtime_get_sync(musb->controller);

drivers/usb/musb/musb_core.c

2051

dev_err(musb->controller, "Could not enable: %i\n",

drivers/usb/musb/musb_core.c

2053

musb->quirk_retries = 3;

drivers/usb/musb/musb_core.c

2061

schedule_delayed_work(&musb->irq_work,

drivers/usb/musb/musb_core.c

2064

trace_musb_state(musb, devctl, "Allow PM with no session");

drivers/usb/musb/musb_core.c

2065

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_core.c

2068

musb->session = s;

drivers/usb/musb/musb_core.c

2074

struct musb *musb = container_of(data, struct musb, irq_work.work);

drivers/usb/musb/musb_core.c

2077

error = pm_runtime_resume_and_get(musb->controller);

drivers/usb/musb/musb_core.c

2079

dev_err(musb->controller, "Could not enable: %i\n", error);

drivers/usb/musb/musb_core.c

2084

musb_pm_runtime_check_session(musb);

drivers/usb/musb/musb_core.c

2086

if (musb_get_state(musb) != musb->xceiv_old_state) {

drivers/usb/musb/musb_core.c

2087

musb->xceiv_old_state = musb_get_state(musb);

drivers/usb/musb/musb_core.c

2088

sysfs_notify(&musb->controller->kobj, NULL, "mode");

drivers/usb/musb/musb_core.c

2091

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_core.c

2094

static void musb_recover_from_babble(struct musb *musb)

drivers/usb/musb/musb_core.c

2099

musb_disable_interrupts(musb);

drivers/usb/musb/musb_core.c

2107

ret = musb_platform_recover(musb);

drivers/usb/musb/musb_core.c

2109

musb_enable_interrupts(musb);

drivers/usb/musb/musb_core.c

2114

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/musb_core.c

2116

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/musb_core.c

2119

musb_root_disconnect(musb);

drivers/usb/musb/musb_core.c

2125

if (musb->dyn_fifo)

drivers/usb/musb/musb_core.c

2126

ret = ep_config_from_table(musb);

drivers/usb/musb/musb_core.c

2128

ret = ep_config_from_hw(musb);

drivers/usb/musb/musb_core.c

2132

musb_start(musb);

drivers/usb/musb/musb_core.c

2139

static struct musb *allocate_instance(struct device *dev,

drivers/usb/musb/musb_core.c

2142

struct musb *musb;

drivers/usb/musb/musb_core.c

2147

musb = devm_kzalloc(dev, sizeof(*musb), GFP_KERNEL);

drivers/usb/musb/musb_core.c

2148

if (!musb)

drivers/usb/musb/musb_core.c

2151

INIT_LIST_HEAD(&musb->control);

drivers/usb/musb/musb_core.c

2152

INIT_LIST_HEAD(&musb->in_bulk);

drivers/usb/musb/musb_core.c

2153

INIT_LIST_HEAD(&musb->out_bulk);

drivers/usb/musb/musb_core.c

2154

INIT_LIST_HEAD(&musb->pending_list);

drivers/usb/musb/musb_core.c

2156

musb->vbuserr_retry = VBUSERR_RETRY_COUNT;

drivers/usb/musb/musb_core.c

2157

musb->a_wait_bcon = OTG_TIME_A_WAIT_BCON;

drivers/usb/musb/musb_core.c

2158

musb->mregs = mbase;

drivers/usb/musb/musb_core.c

2159

musb->ctrl_base = mbase;

drivers/usb/musb/musb_core.c

2160

musb->nIrq = -ENODEV;

drivers/usb/musb/musb_core.c

2161

musb->config = config;

drivers/usb/musb/musb_core.c

2162

BUG_ON(musb->config->num_eps > MUSB_C_NUM_EPS);

drivers/usb/musb/musb_core.c

2163

for (epnum = 0, ep = musb->endpoints;

drivers/usb/musb/musb_core.c

2164

epnum < musb->config->num_eps;

drivers/usb/musb/musb_core.c

2166

ep->musb = musb;

drivers/usb/musb/musb_core.c

2170

musb->controller = dev;

drivers/usb/musb/musb_core.c

2172

ret = musb_host_alloc(musb);

drivers/usb/musb/musb_core.c

2176

dev_set_drvdata(dev, musb);

drivers/usb/musb/musb_core.c

2178

return musb;

drivers/usb/musb/musb_core.c

2184

static void musb_free(struct musb *musb)

drivers/usb/musb/musb_core.c

2191

if (musb->nIrq >= 0) {

drivers/usb/musb/musb_core.c

2192

if (musb->irq_wake)

drivers/usb/musb/musb_core.c

2193

disable_irq_wake(musb->nIrq);

drivers/usb/musb/musb_core.c

2194

free_irq(musb->nIrq, musb);

drivers/usb/musb/musb_core.c

2197

musb_host_free(musb);

drivers/usb/musb/musb_core.c

2201

int (*callback)(struct musb *musb, void *data);

drivers/usb/musb/musb_core.c

2211

static int musb_run_resume_work(struct musb *musb)

drivers/usb/musb/musb_core.c

2217

spin_lock_irqsave(&musb->list_lock, flags);

drivers/usb/musb/musb_core.c

2218

list_for_each_entry_safe(w, _w, &musb->pending_list, node) {

drivers/usb/musb/musb_core.c

2220

error = w->callback(musb, w->data);

drivers/usb/musb/musb_core.c

2222

dev_err(musb->controller,

drivers/usb/musb/musb_core.c

2228

devm_kfree(musb->controller, w);

drivers/usb/musb/musb_core.c

2230

spin_unlock_irqrestore(&musb->list_lock, flags);

drivers/usb/musb/musb_core.c

2244

int musb_queue_resume_work(struct musb *musb,

drivers/usb/musb/musb_core.c

2245

int (*callback)(struct musb *musb, void *data),

drivers/usb/musb/musb_core.c

2256

spin_lock_irqsave(&musb->list_lock, flags);

drivers/usb/musb/musb_core.c

2257

is_suspended = musb->is_runtime_suspended;

drivers/usb/musb/musb_core.c

2260

w = devm_kzalloc(musb->controller, sizeof(*w), GFP_ATOMIC);

drivers/usb/musb/musb_core.c

2269

list_add_tail(&w->node, &musb->pending_list);

drivers/usb/musb/musb_core.c

2274

spin_unlock_irqrestore(&musb->list_lock, flags);

drivers/usb/musb/musb_core.c

2277

error = callback(musb, data);

drivers/usb/musb/musb_core.c

2285

struct musb *musb;

drivers/usb/musb/musb_core.c

2288

musb = container_of(work, struct musb, deassert_reset_work.work);

drivers/usb/musb/musb_core.c

2290

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_core.c

2292

if (musb->port1_status & USB_PORT_STAT_RESET)

drivers/usb/musb/musb_core.c

2293

musb_port_reset(musb, false);

drivers/usb/musb/musb_core.c

2295

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_core.c

2310

struct musb *musb;

drivers/usb/musb/musb_core.c

2323

musb = allocate_instance(dev, plat->config, ctrl);

drivers/usb/musb/musb_core.c

2324

if (!musb) {

drivers/usb/musb/musb_core.c

2329

spin_lock_init(&musb->lock);

drivers/usb/musb/musb_core.c

2330

spin_lock_init(&musb->list_lock);

drivers/usb/musb/musb_core.c

2331

musb->min_power = plat->min_power;

drivers/usb/musb/musb_core.c

2332

musb->ops = plat->platform_ops;

drivers/usb/musb/musb_core.c

2333

musb->port_mode = plat->mode;

drivers/usb/musb/musb_core.c

2357

status = musb_platform_init(musb);

drivers/usb/musb/musb_core.c

2361

if (!musb->isr) {

drivers/usb/musb/musb_core.c

2368

if (musb->ops->quirks & MUSB_INDEXED_EP) {

drivers/usb/musb/musb_core.c

2369

musb->io.ep_offset = musb_indexed_ep_offset;

drivers/usb/musb/musb_core.c

2370

musb->io.ep_select = musb_indexed_ep_select;

drivers/usb/musb/musb_core.c

2372

musb->io.ep_offset = musb_flat_ep_offset;

drivers/usb/musb/musb_core.c

2373

musb->io.ep_select = musb_flat_ep_select;

drivers/usb/musb/musb_core.c

2376

if (musb->ops->quirks & MUSB_G_NO_SKB_RESERVE)

drivers/usb/musb/musb_core.c

2377

musb->g.quirk_avoids_skb_reserve = 1;

drivers/usb/musb/musb_core.c

2380

if (musb->ops->ep_offset)

drivers/usb/musb/musb_core.c

2381

musb->io.ep_offset = musb->ops->ep_offset;

drivers/usb/musb/musb_core.c

2382

if (musb->ops->ep_select)

drivers/usb/musb/musb_core.c

2383

musb->io.ep_select = musb->ops->ep_select;

drivers/usb/musb/musb_core.c

2385

if (musb->ops->fifo_mode)

drivers/usb/musb/musb_core.c

2386

fifo_mode = musb->ops->fifo_mode;

drivers/usb/musb/musb_core.c

2390

if (musb->ops->fifo_offset)

drivers/usb/musb/musb_core.c

2391

musb->io.fifo_offset = musb->ops->fifo_offset;

drivers/usb/musb/musb_core.c

2393

musb->io.fifo_offset = musb_default_fifo_offset;

drivers/usb/musb/musb_core.c

2395

if (musb->ops->busctl_offset)

drivers/usb/musb/musb_core.c

2396

musb->io.busctl_offset = musb->ops->busctl_offset;

drivers/usb/musb/musb_core.c

2398

musb->io.busctl_offset = musb_default_busctl_offset;

drivers/usb/musb/musb_core.c

2400

if (musb->ops->readb)

drivers/usb/musb/musb_core.c

2401

musb_readb = musb->ops->readb;

drivers/usb/musb/musb_core.c

2402

if (musb->ops->writeb)

drivers/usb/musb/musb_core.c

2403

musb_writeb = musb->ops->writeb;

drivers/usb/musb/musb_core.c

2404

if (musb->ops->clearb)

drivers/usb/musb/musb_core.c

2405

musb_clearb = musb->ops->clearb;

drivers/usb/musb/musb_core.c

2409

if (musb->ops->readw)

drivers/usb/musb/musb_core.c

2410

musb_readw = musb->ops->readw;

drivers/usb/musb/musb_core.c

2411

if (musb->ops->writew)

drivers/usb/musb/musb_core.c

2412

musb_writew = musb->ops->writew;

drivers/usb/musb/musb_core.c

2413

if (musb->ops->clearw)

drivers/usb/musb/musb_core.c

2414

musb_clearw = musb->ops->clearw;

drivers/usb/musb/musb_core.c

2419

if (!musb->ops->dma_init || !musb->ops->dma_exit) {

drivers/usb/musb/musb_core.c

2424

musb_dma_controller_create = musb->ops->dma_init;

drivers/usb/musb/musb_core.c

2425

musb_dma_controller_destroy = musb->ops->dma_exit;

drivers/usb/musb/musb_core.c

2428

if (musb->ops->read_fifo)

drivers/usb/musb/musb_core.c

2429

musb->io.read_fifo = musb->ops->read_fifo;

drivers/usb/musb/musb_core.c

2431

musb->io.read_fifo = musb_default_read_fifo;

drivers/usb/musb/musb_core.c

2433

if (musb->ops->write_fifo)

drivers/usb/musb/musb_core.c

2434

musb->io.write_fifo = musb->ops->write_fifo;

drivers/usb/musb/musb_core.c

2436

musb->io.write_fifo = musb_default_write_fifo;

drivers/usb/musb/musb_core.c

2438

if (musb->ops->get_toggle)

drivers/usb/musb/musb_core.c

2439

musb->io.get_toggle = musb->ops->get_toggle;

drivers/usb/musb/musb_core.c

2441

musb->io.get_toggle = musb_default_get_toggle;

drivers/usb/musb/musb_core.c

2443

if (musb->ops->set_toggle)

drivers/usb/musb/musb_core.c

2444

musb->io.set_toggle = musb->ops->set_toggle;

drivers/usb/musb/musb_core.c

2446

musb->io.set_toggle = musb_default_set_toggle;

drivers/usb/musb/musb_core.c

2448

if (IS_ENABLED(CONFIG_USB_PHY) && musb->xceiv && !musb->xceiv->io_ops) {

drivers/usb/musb/musb_core.c

2449

musb->xceiv->io_dev = musb->controller;

drivers/usb/musb/musb_core.c

2450

musb->xceiv->io_priv = musb->mregs;

drivers/usb/musb/musb_core.c

2451

musb->xceiv->io_ops = &musb_ulpi_access;

drivers/usb/musb/musb_core.c

2454

if (musb->ops->phy_callback)

drivers/usb/musb/musb_core.c

2455

musb_phy_callback = musb->ops->phy_callback;

drivers/usb/musb/musb_core.c

2464

pm_runtime_use_autosuspend(musb->controller);

drivers/usb/musb/musb_core.c

2465

pm_runtime_set_autosuspend_delay(musb->controller, 500);

drivers/usb/musb/musb_core.c

2466

pm_runtime_enable(musb->controller);

drivers/usb/musb/musb_core.c

2467

pm_runtime_get_sync(musb->controller);

drivers/usb/musb/musb_core.c

2469

status = usb_phy_init(musb->xceiv);

drivers/usb/musb/musb_core.c

2474

musb->dma_controller =

drivers/usb/musb/musb_core.c

2475

musb_dma_controller_create(musb, musb->mregs);

drivers/usb/musb/musb_core.c

2476

if (IS_ERR(musb->dma_controller)) {

drivers/usb/musb/musb_core.c

2477

status = PTR_ERR(musb->dma_controller);

drivers/usb/musb/musb_core.c

2483

musb_platform_disable(musb);

drivers/usb/musb/musb_core.c

2484

musb_disable_interrupts(musb);

drivers/usb/musb/musb_core.c

2485

musb_writeb(musb->mregs, MUSB_DEVCTL, 0);

drivers/usb/musb/musb_core.c

2488

musb_writeb(musb->mregs, MUSB_POWER, 0);

drivers/usb/musb/musb_core.c

2491

INIT_DELAYED_WORK(&musb->irq_work, musb_irq_work);

drivers/usb/musb/musb_core.c

2492

INIT_DELAYED_WORK(&musb->deassert_reset_work, musb_deassert_reset);

drivers/usb/musb/musb_core.c

2493

INIT_DELAYED_WORK(&musb->finish_resume_work, musb_host_finish_resume);

drivers/usb/musb/musb_core.c

2498

: MUSB_CONTROLLER_HDRC, musb);

drivers/usb/musb/musb_core.c

2502

timer_setup(&musb->otg_timer, musb_otg_timer_func, 0);

drivers/usb/musb/musb_core.c

2505

if (request_irq(nIrq, musb->isr, IRQF_SHARED, dev_name(dev), musb)) {

drivers/usb/musb/musb_core.c

2510

musb->nIrq = nIrq;

drivers/usb/musb/musb_core.c

2513

musb->irq_wake = 1;

drivers/usb/musb/musb_core.c

2516

musb->irq_wake = 0;

drivers/usb/musb/musb_core.c

2521

u8 busctl = musb_readb(musb->mregs, MUSB_ULPI_BUSCONTROL);

drivers/usb/musb/musb_core.c

2523

musb_writeb(musb->mregs, MUSB_ULPI_BUSCONTROL, busctl);

drivers/usb/musb/musb_core.c

2526

MUSB_DEV_MODE(musb);

drivers/usb/musb/musb_core.c

2527

musb_set_state(musb, OTG_STATE_B_IDLE);

drivers/usb/musb/musb_core.c

2529

switch (musb->port_mode) {

drivers/usb/musb/musb_core.c

2531

status = musb_host_setup(musb, plat->power);

drivers/usb/musb/musb_core.c

2534

status = musb_platform_set_mode(musb, MUSB_HOST);

drivers/usb/musb/musb_core.c

2537

status = musb_gadget_setup(musb);

drivers/usb/musb/musb_core.c

2540

status = musb_platform_set_mode(musb, MUSB_PERIPHERAL);

drivers/usb/musb/musb_core.c

2543

status = musb_host_setup(musb, plat->power);

drivers/usb/musb/musb_core.c

2546

status = musb_gadget_setup(musb);

drivers/usb/musb/musb_core.c

2548

musb_host_cleanup(musb);

drivers/usb/musb/musb_core.c

2551

status = musb_platform_set_mode(musb, MUSB_OTG);

drivers/usb/musb/musb_core.c

2554

dev_err(dev, "unsupported port mode %d\n", musb->port_mode);

drivers/usb/musb/musb_core.c

2561

musb_init_debugfs(musb);

drivers/usb/musb/musb_core.c

2563

musb->is_initialized = 1;

drivers/usb/musb/musb_core.c

2564

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_core.c

2569

cancel_delayed_work_sync(&musb->irq_work);

drivers/usb/musb/musb_core.c

2570

cancel_delayed_work_sync(&musb->finish_resume_work);

drivers/usb/musb/musb_core.c

2571

cancel_delayed_work_sync(&musb->deassert_reset_work);

drivers/usb/musb/musb_core.c

2572

if (musb->dma_controller)

drivers/usb/musb/musb_core.c

2573

musb_dma_controller_destroy(musb->dma_controller);

drivers/usb/musb/musb_core.c

2576

usb_phy_shutdown(musb->xceiv);

drivers/usb/musb/musb_core.c

2579

pm_runtime_dont_use_autosuspend(musb->controller);

drivers/usb/musb/musb_core.c

2580

pm_runtime_put_sync(musb->controller);

drivers/usb/musb/musb_core.c

2581

pm_runtime_disable(musb->controller);

drivers/usb/musb/musb_core.c

2584

if (musb->irq_wake)

drivers/usb/musb/musb_core.c

2586

musb_platform_exit(musb);

drivers/usb/musb/musb_core.c

2589

dev_err_probe(musb->controller, status, "%s failed\n", __func__);

drivers/usb/musb/musb_core.c

2591

musb_free(musb);

drivers/usb/musb/musb_core.c

2623

struct musb *musb = dev_to_musb(dev);

drivers/usb/musb/musb_core.c

2631

musb_exit_debugfs(musb);

drivers/usb/musb/musb_core.c

2633

cancel_delayed_work_sync(&musb->irq_work);

drivers/usb/musb/musb_core.c

2634

cancel_delayed_work_sync(&musb->finish_resume_work);

drivers/usb/musb/musb_core.c

2635

cancel_delayed_work_sync(&musb->deassert_reset_work);

drivers/usb/musb/musb_core.c

2636

pm_runtime_get_sync(musb->controller);

drivers/usb/musb/musb_core.c

2637

musb_host_cleanup(musb);

drivers/usb/musb/musb_core.c

2638

musb_gadget_cleanup(musb);

drivers/usb/musb/musb_core.c

2640

musb_platform_disable(musb);

drivers/usb/musb/musb_core.c

2641

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_core.c

2642

musb_disable_interrupts(musb);

drivers/usb/musb/musb_core.c

2643

musb_writeb(musb->mregs, MUSB_DEVCTL, 0);

drivers/usb/musb/musb_core.c

2644

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_core.c

2645

musb_platform_exit(musb);

drivers/usb/musb/musb_core.c

2647

pm_runtime_dont_use_autosuspend(musb->controller);

drivers/usb/musb/musb_core.c

2648

pm_runtime_put_sync(musb->controller);

drivers/usb/musb/musb_core.c

2649

pm_runtime_disable(musb->controller);

drivers/usb/musb/musb_core.c

2651

if (musb->dma_controller)

drivers/usb/musb/musb_core.c

2652

musb_dma_controller_destroy(musb->dma_controller);

drivers/usb/musb/musb_core.c

2653

usb_phy_shutdown(musb->xceiv);

drivers/usb/musb/musb_core.c

2654

musb_free(musb);

drivers/usb/musb/musb_core.c

2660

static void musb_save_context(struct musb *musb)

drivers/usb/musb/musb_core.c

2663

void __iomem *musb_base = musb->mregs;

drivers/usb/musb/musb_core.c

2666

musb->context.frame = musb_readw(musb_base, MUSB_FRAME);

drivers/usb/musb/musb_core.c

2667

musb->context.testmode = musb_readb(musb_base, MUSB_TESTMODE);

drivers/usb/musb/musb_core.c

2668

musb->context.busctl = musb_readb(musb_base, MUSB_ULPI_BUSCONTROL);

drivers/usb/musb/musb_core.c

2669

musb->context.power = musb_readb(musb_base, MUSB_POWER);

drivers/usb/musb/musb_core.c

2670

musb->context.intrusbe = musb_readb(musb_base, MUSB_INTRUSBE);

drivers/usb/musb/musb_core.c

2671

musb->context.index = musb_readb(musb_base, MUSB_INDEX);

drivers/usb/musb/musb_core.c

2672

musb->context.devctl = musb_readb(musb_base, MUSB_DEVCTL);

drivers/usb/musb/musb_core.c

2674

for (i = 0; i < musb->config->num_eps; ++i) {

drivers/usb/musb/musb_core.c

2675

epio = musb->endpoints[i].regs;

drivers/usb/musb/musb_core.c

2680

musb->context.index_regs[i].txmaxp =

drivers/usb/musb/musb_core.c

2682

musb->context.index_regs[i].txcsr =

drivers/usb/musb/musb_core.c

2684

musb->context.index_regs[i].rxmaxp =

drivers/usb/musb/musb_core.c

2686

musb->context.index_regs[i].rxcsr =

drivers/usb/musb/musb_core.c

2689

if (musb->dyn_fifo) {

drivers/usb/musb/musb_core.c

2690

musb->context.index_regs[i].txfifoadd =

drivers/usb/musb/musb_core.c

2692

musb->context.index_regs[i].rxfifoadd =

drivers/usb/musb/musb_core.c

2694

musb->context.index_regs[i].txfifosz =

drivers/usb/musb/musb_core.c

2696

musb->context.index_regs[i].rxfifosz =

drivers/usb/musb/musb_core.c

2700

musb->context.index_regs[i].txtype =

drivers/usb/musb/musb_core.c

2702

musb->context.index_regs[i].txinterval =

drivers/usb/musb/musb_core.c

2704

musb->context.index_regs[i].rxtype =

drivers/usb/musb/musb_core.c

2706

musb->context.index_regs[i].rxinterval =

drivers/usb/musb/musb_core.c

2709

musb->context.index_regs[i].txfunaddr =

drivers/usb/musb/musb_core.c

2710

musb_read_txfunaddr(musb, i);

drivers/usb/musb/musb_core.c

2711

musb->context.index_regs[i].txhubaddr =

drivers/usb/musb/musb_core.c

2712

musb_read_txhubaddr(musb, i);

drivers/usb/musb/musb_core.c

2713

musb->context.index_regs[i].txhubport =

drivers/usb/musb/musb_core.c

2714

musb_read_txhubport(musb, i);

drivers/usb/musb/musb_core.c

2716

musb->context.index_regs[i].rxfunaddr =

drivers/usb/musb/musb_core.c

2717

musb_read_rxfunaddr(musb, i);

drivers/usb/musb/musb_core.c

2718

musb->context.index_regs[i].rxhubaddr =

drivers/usb/musb/musb_core.c

2719

musb_read_rxhubaddr(musb, i);

drivers/usb/musb/musb_core.c

2720

musb->context.index_regs[i].rxhubport =

drivers/usb/musb/musb_core.c

2721

musb_read_rxhubport(musb, i);

drivers/usb/musb/musb_core.c

2725

static void musb_restore_context(struct musb *musb)

drivers/usb/musb/musb_core.c

2728

void __iomem *musb_base = musb->mregs;

drivers/usb/musb/musb_core.c

2732

musb_writew(musb_base, MUSB_FRAME, musb->context.frame);

drivers/usb/musb/musb_core.c

2733

musb_writeb(musb_base, MUSB_TESTMODE, musb->context.testmode);

drivers/usb/musb/musb_core.c

2734

musb_writeb(musb_base, MUSB_ULPI_BUSCONTROL, musb->context.busctl);

drivers/usb/musb/musb_core.c

2739

musb->context.power &= ~(MUSB_POWER_SUSPENDM | MUSB_POWER_RESUME);

drivers/usb/musb/musb_core.c

2740

power |= musb->context.power;

drivers/usb/musb/musb_core.c

2743

musb_writew(musb_base, MUSB_INTRTXE, musb->intrtxe);

drivers/usb/musb/musb_core.c

2744

musb_writew(musb_base, MUSB_INTRRXE, musb->intrrxe);

drivers/usb/musb/musb_core.c

2745

musb_writeb(musb_base, MUSB_INTRUSBE, musb->context.intrusbe);

drivers/usb/musb/musb_core.c

2746

if (musb->context.devctl & MUSB_DEVCTL_SESSION)

drivers/usb/musb/musb_core.c

2747

musb_writeb(musb_base, MUSB_DEVCTL, musb->context.devctl);

drivers/usb/musb/musb_core.c

2749

for (i = 0; i < musb->config->num_eps; ++i) {

drivers/usb/musb/musb_core.c

2750

epio = musb->endpoints[i].regs;

drivers/usb/musb/musb_core.c

2756

musb->context.index_regs[i].txmaxp);

drivers/usb/musb/musb_core.c

2758

musb->context.index_regs[i].txcsr);

drivers/usb/musb/musb_core.c

2760

musb->context.index_regs[i].rxmaxp);

drivers/usb/musb/musb_core.c

2762

musb->context.index_regs[i].rxcsr);

drivers/usb/musb/musb_core.c

2764

if (musb->dyn_fifo) {

drivers/usb/musb/musb_core.c

2766

musb->context.index_regs[i].txfifosz);

drivers/usb/musb/musb_core.c

2768

musb->context.index_regs[i].rxfifosz);

drivers/usb/musb/musb_core.c

2770

musb->context.index_regs[i].txfifoadd);

drivers/usb/musb/musb_core.c

2772

musb->context.index_regs[i].rxfifoadd);

drivers/usb/musb/musb_core.c

2776

musb->context.index_regs[i].txtype);

drivers/usb/musb/musb_core.c

2778

musb->context.index_regs[i].txinterval);

drivers/usb/musb/musb_core.c

2780

musb->context.index_regs[i].rxtype);

drivers/usb/musb/musb_core.c

2783

musb->context.index_regs[i].rxinterval);

drivers/usb/musb/musb_core.c

2784

musb_write_txfunaddr(musb, i,

drivers/usb/musb/musb_core.c

2785

musb->context.index_regs[i].txfunaddr);

drivers/usb/musb/musb_core.c

2786

musb_write_txhubaddr(musb, i,

drivers/usb/musb/musb_core.c

2787

musb->context.index_regs[i].txhubaddr);

drivers/usb/musb/musb_core.c

2788

musb_write_txhubport(musb, i,

drivers/usb/musb/musb_core.c

2789

musb->context.index_regs[i].txhubport);

drivers/usb/musb/musb_core.c

2791

musb_write_rxfunaddr(musb, i,

drivers/usb/musb/musb_core.c

2792

musb->context.index_regs[i].rxfunaddr);

drivers/usb/musb/musb_core.c

2793

musb_write_rxhubaddr(musb, i,

drivers/usb/musb/musb_core.c

2794

musb->context.index_regs[i].rxhubaddr);

drivers/usb/musb/musb_core.c

2795

musb_write_rxhubport(musb, i,

drivers/usb/musb/musb_core.c

2796

musb->context.index_regs[i].rxhubport);

drivers/usb/musb/musb_core.c

2798

musb_writeb(musb_base, MUSB_INDEX, musb->context.index);

drivers/usb/musb/musb_core.c

2803

struct musb *musb = dev_to_musb(dev);

drivers/usb/musb/musb_core.c

2813

musb_platform_disable(musb);

drivers/usb/musb/musb_core.c

2814

musb_disable_interrupts(musb);

drivers/usb/musb/musb_core.c

2816

musb->flush_irq_work = true;

drivers/usb/musb/musb_core.c

2817

while (flush_delayed_work(&musb->irq_work))

drivers/usb/musb/musb_core.c

2819

musb->flush_irq_work = false;

drivers/usb/musb/musb_core.c

2821

if (!(musb->ops->quirks & MUSB_PRESERVE_SESSION))

drivers/usb/musb/musb_core.c

2822

musb_writeb(musb->mregs, MUSB_DEVCTL, 0);

drivers/usb/musb/musb_core.c

2824

WARN_ON(!list_empty(&musb->pending_list));

drivers/usb/musb/musb_core.c

2826

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_core.c

2828

if (is_peripheral_active(musb)) {

drivers/usb/musb/musb_core.c

2832

} else if (is_host_active(musb)) {

drivers/usb/musb/musb_core.c

2838

musb_save_context(musb);

drivers/usb/musb/musb_core.c

2840

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_core.c

2846

struct musb *musb = dev_to_musb(dev);

drivers/usb/musb/musb_core.c

2862

musb_restore_context(musb);

drivers/usb/musb/musb_core.c

2864

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/musb_core.c

2866

if ((devctl & mask) != (musb->context.devctl & mask))

drivers/usb/musb/musb_core.c

2867

musb->port1_status = 0;

drivers/usb/musb/musb_core.c

2869

musb_enable_interrupts(musb);

drivers/usb/musb/musb_core.c

2870

musb_platform_enable(musb);

drivers/usb/musb/musb_core.c

2873

if (musb->port_mode == MUSB_HOST &&

drivers/usb/musb/musb_core.c

2874

!(musb->ops->quirks & MUSB_PRESERVE_SESSION)) {

drivers/usb/musb/musb_core.c

2876

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/musb_core.c

2879

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_core.c

2880

error = musb_run_resume_work(musb);

drivers/usb/musb/musb_core.c

2882

dev_err(musb->controller, "resume work failed with %i\n",

drivers/usb/musb/musb_core.c

2884

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_core.c

2893

struct musb *musb = dev_to_musb(dev);

drivers/usb/musb/musb_core.c

2895

musb_save_context(musb);

drivers/usb/musb/musb_core.c

2896

musb->is_runtime_suspended = 1;

drivers/usb/musb/musb_core.c

2903

struct musb *musb = dev_to_musb(dev);

drivers/usb/musb/musb_core.c

2916

if (!musb->is_initialized)

drivers/usb/musb/musb_core.c

2919

musb_restore_context(musb);

drivers/usb/musb/musb_core.c

2921

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_core.c

2922

error = musb_run_resume_work(musb);

drivers/usb/musb/musb_core.c

2924

dev_err(musb->controller, "resume work failed with %i\n",

drivers/usb/musb/musb_core.c

2926

musb->is_runtime_suspended = 0;

drivers/usb/musb/musb_core.c

2927

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_core.c

317

struct musb *musb = hw_ep->musb;

drivers/usb/musb/musb_core.c

325

dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",

drivers/usb/musb/musb_core.c

361

struct musb *musb = hw_ep->musb;

drivers/usb/musb/musb_core.c

367

dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",

drivers/usb/musb/musb_core.c

437

(*musb_dma_controller_create)(struct musb *musb, void __iomem *base);

drivers/usb/musb/musb_core.c

449

return hw_ep->musb->io.read_fifo(hw_ep, len, dst);

drivers/usb/musb/musb_core.c

454

return hw_ep->musb->io.write_fifo(hw_ep, len, src);

drivers/usb/musb/musb_core.c

457

static u8 musb_read_devctl(struct musb *musb)

drivers/usb/musb/musb_core.c

459

return musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/musb_core.c

474

int musb_set_host(struct musb *musb)

drivers/usb/musb/musb_core.c

479

if (!musb)

drivers/usb/musb/musb_core.c

482

devctl = musb_read_devctl(musb);

drivers/usb/musb/musb_core.c

484

trace_musb_state(musb, devctl, "Already in host mode");

drivers/usb/musb/musb_core.c

489

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/musb_core.c

491

error = readx_poll_timeout(musb_read_devctl, musb, devctl,

drivers/usb/musb/musb_core.c

495

dev_err(musb->controller, "%s: could not set host: %02x\n",

drivers/usb/musb/musb_core.c

501

devctl = musb_read_devctl(musb);

drivers/usb/musb/musb_core.c

502

trace_musb_state(musb, devctl, "Host mode set");

drivers/usb/musb/musb_core.c

505

musb->is_active = 1;

drivers/usb/musb/musb_core.c

506

musb_set_state(musb, OTG_STATE_A_IDLE);

drivers/usb/musb/musb_core.c

507

MUSB_HST_MODE(musb);

drivers/usb/musb/musb_core.c

521

int musb_set_peripheral(struct musb *musb)

drivers/usb/musb/musb_core.c

526

if (!musb)

drivers/usb/musb/musb_core.c

529

devctl = musb_read_devctl(musb);

drivers/usb/musb/musb_core.c

531

trace_musb_state(musb, devctl, "Already in peripheral mode");

drivers/usb/musb/musb_core.c

536

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/musb_core.c

538

error = readx_poll_timeout(musb_read_devctl, musb, devctl,

drivers/usb/musb/musb_core.c

542

dev_err(musb->controller, "%s: could not set peripheral: %02x\n",

drivers/usb/musb/musb_core.c

548

devctl = musb_read_devctl(musb);

drivers/usb/musb/musb_core.c

549

trace_musb_state(musb, devctl, "Peripheral mode set");

drivers/usb/musb/musb_core.c

552

musb->is_active = 0;

drivers/usb/musb/musb_core.c

553

musb_set_state(musb, OTG_STATE_B_IDLE);

drivers/usb/musb/musb_core.c

554

MUSB_DEV_MODE(musb);

drivers/usb/musb/musb_core.c

582

void musb_load_testpacket(struct musb *musb)

drivers/usb/musb/musb_core.c

584

void __iomem *regs = musb->endpoints[0].regs;

drivers/usb/musb/musb_core.c

586

musb_ep_select(musb->mregs, 0);

drivers/usb/musb/musb_core.c

587

musb_write_fifo(musb->control_ep,

drivers/usb/musb/musb_core.c

599

struct musb *musb = timer_container_of(musb, t, otg_timer);

drivers/usb/musb/musb_core.c

602

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_core.c

603

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_core.c

605

musb_dbg(musb,

drivers/usb/musb/musb_core.c

607

musb_g_disconnect(musb);

drivers/usb/musb/musb_core.c

608

musb_set_state(musb, OTG_STATE_B_PERIPHERAL);

drivers/usb/musb/musb_core.c

609

musb->is_active = 0;

drivers/usb/musb/musb_core.c

613

musb_dbg(musb, "HNP: %s timeout",

drivers/usb/musb/musb_core.c

614

musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

615

musb_platform_set_vbus(musb, 0);

drivers/usb/musb/musb_core.c

616

musb_set_state(musb, OTG_STATE_A_WAIT_VFALL);

drivers/usb/musb/musb_core.c

619

musb_dbg(musb, "HNP: Unhandled mode %s",

drivers/usb/musb/musb_core.c

620

musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

622

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_core.c

628

void musb_hnp_stop(struct musb *musb)

drivers/usb/musb/musb_core.c

630

struct usb_hcd *hcd = musb->hcd;

drivers/usb/musb/musb_core.c

631

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_core.c

634

musb_dbg(musb, "HNP: stop from %s", musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

636

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_core.c

638

musb_g_disconnect(musb);

drivers/usb/musb/musb_core.c

639

musb_dbg(musb, "HNP: back to %s", musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

642

musb_dbg(musb, "HNP: Disabling HR");

drivers/usb/musb/musb_core.c

645

musb_set_state(musb, OTG_STATE_B_PERIPHERAL);

drivers/usb/musb/musb_core.c

646

MUSB_DEV_MODE(musb);

drivers/usb/musb/musb_core.c

653

musb_dbg(musb, "HNP: Stopping in unknown state %s",

drivers/usb/musb/musb_core.c

654

musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

662

musb->port1_status &= ~(USB_PORT_STAT_C_CONNECTION << 16);

drivers/usb/musb/musb_core.c

665

static void musb_recover_from_babble(struct musb *musb);

drivers/usb/musb/musb_core.c

667

static void musb_handle_intr_resume(struct musb *musb, u8 devctl)

drivers/usb/musb/musb_core.c

669

musb_dbg(musb, "RESUME (%s)", musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

672

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_core.c

675

musb->port1_status |=

drivers/usb/musb/musb_core.c

678

musb->rh_timer = jiffies

drivers/usb/musb/musb_core.c

680

musb_set_state(musb, OTG_STATE_A_HOST);

drivers/usb/musb/musb_core.c

681

musb->is_active = 1;

drivers/usb/musb/musb_core.c

682

musb_host_resume_root_hub(musb);

drivers/usb/musb/musb_core.c

683

schedule_delayed_work(&musb->finish_resume_work,

drivers/usb/musb/musb_core.c

687

musb_set_state(musb, OTG_STATE_B_PERIPHERAL);

drivers/usb/musb/musb_core.c

688

musb->is_active = 1;

drivers/usb/musb/musb_core.c

689

MUSB_DEV_MODE(musb);

drivers/usb/musb/musb_core.c

694

musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

697

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_core.c

700

musb_set_state(musb, OTG_STATE_A_HOST);

drivers/usb/musb/musb_core.c

701

musb_host_resume_root_hub(musb);

drivers/usb/musb/musb_core.c

711

musb->int_usb |= MUSB_INTR_DISCONNECT;

drivers/usb/musb/musb_core.c

712

musb->int_usb &= ~MUSB_INTR_SUSPEND;

drivers/usb/musb/musb_core.c

715

musb_g_resume(musb);

drivers/usb/musb/musb_core.c

718

musb->int_usb &= ~MUSB_INTR_SUSPEND;

drivers/usb/musb/musb_core.c

723

musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

729

static irqreturn_t musb_handle_intr_sessreq(struct musb *musb, u8 devctl)

drivers/usb/musb/musb_core.c

731

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_core.c

735

musb_dbg(musb, "SessReq while on B state");

drivers/usb/musb/musb_core.c

739

musb_dbg(musb, "SESSION_REQUEST (%s)", musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

749

musb->ep0_stage = MUSB_EP0_START;

drivers/usb/musb/musb_core.c

750

musb_set_state(musb, OTG_STATE_A_IDLE);

drivers/usb/musb/musb_core.c

751

MUSB_HST_MODE(musb);

drivers/usb/musb/musb_core.c

752

musb_platform_set_vbus(musb, 1);

drivers/usb/musb/musb_core.c

757

static void musb_handle_intr_vbuserr(struct musb *musb, u8 devctl)

drivers/usb/musb/musb_core.c

777

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_core.c

787

if (musb->vbuserr_retry) {

drivers/usb/musb/musb_core.c

788

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_core.c

790

musb->vbuserr_retry--;

drivers/usb/musb/musb_core.c

795

musb->port1_status |=

drivers/usb/musb/musb_core.c

804

dev_printk(ignore ? KERN_DEBUG : KERN_ERR, musb->controller,

drivers/usb/musb/musb_core.c

806

musb_otg_state_string(musb),

drivers/usb/musb/musb_core.c

820

VBUSERR_RETRY_COUNT - musb->vbuserr_retry,

drivers/usb/musb/musb_core.c

821

musb->port1_status);

drivers/usb/musb/musb_core.c

825

musb_platform_set_vbus(musb, 0);

drivers/usb/musb/musb_core.c

828

static void musb_handle_intr_suspend(struct musb *musb, u8 devctl)

drivers/usb/musb/musb_core.c

830

musb_dbg(musb, "SUSPEND (%s) devctl %02x",

drivers/usb/musb/musb_core.c

831

musb_otg_state_string(musb), devctl);

drivers/usb/musb/musb_core.c

833

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_core.c

842

musb_hnp_stop(musb);

drivers/usb/musb/musb_core.c

843

musb_host_resume_root_hub(musb);

drivers/usb/musb/musb_core.c

844

musb_root_disconnect(musb);

drivers/usb/musb/musb_core.c

845

musb_platform_try_idle(musb, jiffies

drivers/usb/musb/musb_core.c

846

+ msecs_to_jiffies(musb->a_wait_bcon

drivers/usb/musb/musb_core.c

851

if (!musb->is_active)

drivers/usb/musb/musb_core.c

855

musb_g_suspend(musb);

drivers/usb/musb/musb_core.c

856

musb->is_active = musb->g.b_hnp_enable;

drivers/usb/musb/musb_core.c

857

if (musb->is_active) {

drivers/usb/musb/musb_core.c

858

musb_set_state(musb, OTG_STATE_B_WAIT_ACON);

drivers/usb/musb/musb_core.c

859

musb_dbg(musb, "HNP: Setting timer for b_ase0_brst");

drivers/usb/musb/musb_core.c

860

mod_timer(&musb->otg_timer, jiffies

drivers/usb/musb/musb_core.c

866

if (musb->a_wait_bcon != 0)

drivers/usb/musb/musb_core.c

867

musb_platform_try_idle(musb, jiffies

drivers/usb/musb/musb_core.c

868

+ msecs_to_jiffies(musb->a_wait_bcon));

drivers/usb/musb/musb_core.c

871

musb_set_state(musb, OTG_STATE_A_SUSPEND);

drivers/usb/musb/musb_core.c

872

musb->is_active = musb->hcd->self.b_hnp_enable;

drivers/usb/musb/musb_core.c

876

musb_dbg(musb, "REVISIT: SUSPEND as B_HOST");

drivers/usb/musb/musb_core.c

880

musb->is_active = 0;

drivers/usb/musb/musb_core.c

885

static void musb_handle_intr_connect(struct musb *musb, u8 devctl, u8 int_usb)

drivers/usb/musb/musb_core.c

887

struct usb_hcd *hcd = musb->hcd;

drivers/usb/musb/musb_core.c

889

musb->is_active = 1;

drivers/usb/musb/musb_core.c

890

musb->ep0_stage = MUSB_EP0_START;

drivers/usb/musb/musb_core.c

892

musb->intrtxe = musb->epmask;

drivers/usb/musb/musb_core.c

893

musb_writew(musb->mregs, MUSB_INTRTXE, musb->intrtxe);

drivers/usb/musb/musb_core.c

894

musb->intrrxe = musb->epmask & 0xfffe;

drivers/usb/musb/musb_core.c

895

musb_writew(musb->mregs, MUSB_INTRRXE, musb->intrrxe);

drivers/usb/musb/musb_core.c

896

musb_writeb(musb->mregs, MUSB_INTRUSBE, 0xf7);

drivers/usb/musb/musb_core.c

897

musb->port1_status &= ~(USB_PORT_STAT_LOW_SPEED

drivers/usb/musb/musb_core.c

901

musb->port1_status |= USB_PORT_STAT_CONNECTION

drivers/usb/musb/musb_core.c

906

musb->port1_status |= USB_PORT_STAT_LOW_SPEED;

drivers/usb/musb/musb_core.c

909

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_core.c

912

musb_dbg(musb, "HNP: SUSPEND+CONNECT, now b_host");

drivers/usb/musb/musb_core.c

916

musb_dbg(musb, "CONNECT as b_peripheral???");

drivers/usb/musb/musb_core.c

919

musb_dbg(musb, "HNP: CONNECT, now b_host");

drivers/usb/musb/musb_core.c

921

musb_set_state(musb, OTG_STATE_B_HOST);

drivers/usb/musb/musb_core.c

922

if (musb->hcd)

drivers/usb/musb/musb_core.c

923

musb->hcd->self.is_b_host = 1;

drivers/usb/musb/musb_core.c

924

timer_delete(&musb->otg_timer);

drivers/usb/musb/musb_core.c

929

musb_set_state(musb, OTG_STATE_A_HOST);

drivers/usb/musb/musb_core.c

936

musb_host_poke_root_hub(musb);

drivers/usb/musb/musb_core.c

938

musb_dbg(musb, "CONNECT (%s) devctl %02x",

drivers/usb/musb/musb_core.c

939

musb_otg_state_string(musb), devctl);

drivers/usb/musb/musb_core.c

942

static void musb_handle_intr_disconnect(struct musb *musb, u8 devctl)

drivers/usb/musb/musb_core.c

944

musb_dbg(musb, "DISCONNECT (%s) as %s, devctl %02x",

drivers/usb/musb/musb_core.c

945

musb_otg_state_string(musb),

drivers/usb/musb/musb_core.c

946

MUSB_MODE(musb), devctl);

drivers/usb/musb/musb_core.c

948

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_core.c

951

musb_host_resume_root_hub(musb);

drivers/usb/musb/musb_core.c

952

musb_root_disconnect(musb);

drivers/usb/musb/musb_core.c

953

if (musb->a_wait_bcon != 0)

drivers/usb/musb/musb_core.c

954

musb_platform_try_idle(musb, jiffies

drivers/usb/musb/musb_core.c

955

+ msecs_to_jiffies(musb->a_wait_bcon));

drivers/usb/musb/musb_core.c

963

musb_root_disconnect(musb);

drivers/usb/musb/musb_core.c

964

if (musb->hcd)

drivers/usb/musb/musb_core.c

965

musb->hcd->self.is_b_host = 0;

drivers/usb/musb/musb_core.c

966

musb_set_state(musb, OTG_STATE_B_PERIPHERAL);

drivers/usb/musb/musb_core.c

967

MUSB_DEV_MODE(musb);

drivers/usb/musb/musb_core.c

968

musb_g_disconnect(musb);

drivers/usb/musb/musb_core.c

971

musb_hnp_stop(musb);

drivers/usb/musb/musb_core.c

972

musb_root_disconnect(musb);

drivers/usb/musb/musb_core.c

977

musb_g_disconnect(musb);

drivers/usb/musb/musb_core.c

981

musb_otg_state_string(musb));

drivers/usb/musb/musb_core.c

990

static void musb_handle_intr_reset(struct musb *musb)

drivers/usb/musb/musb_core.c

992

if (is_host_active(musb)) {

drivers/usb/musb/musb_core.h

106

#define MUSB_MODE(musb) ((musb)->is_host ? "Host" : "Peripheral")

drivers/usb/musb/musb_core.h

158

int (*init)(struct musb *musb);

drivers/usb/musb/musb_core.h

159

int (*exit)(struct musb *musb);

drivers/usb/musb/musb_core.h

161

void (*enable)(struct musb *musb);

drivers/usb/musb/musb_core.h

162

void (*disable)(struct musb *musb);

drivers/usb/musb/musb_core.h

180

(*dma_init) (struct musb *musb, void __iomem *base);

drivers/usb/musb/musb_core.h

182

int (*set_mode)(struct musb *musb, u8 mode);

drivers/usb/musb/musb_core.h

183

void (*try_idle)(struct musb *musb, unsigned long timeout);

drivers/usb/musb/musb_core.h

184

int (*recover)(struct musb *musb);

drivers/usb/musb/musb_core.h

186

int (*vbus_status)(struct musb *musb);

drivers/usb/musb/musb_core.h

187

void (*set_vbus)(struct musb *musb, int on);

drivers/usb/musb/musb_core.h

189

void (*pre_root_reset_end)(struct musb *musb);

drivers/usb/musb/musb_core.h

190

void (*post_root_reset_end)(struct musb *musb);

drivers/usb/musb/musb_core.h

192

void (*clear_ep_rxintr)(struct musb *musb, int epnum);

drivers/usb/musb/musb_core.h

201

struct musb *musb;

drivers/usb/musb/musb_core.h

27

struct musb;

drivers/usb/musb/musb_core.h

378

#define can_bulk_split(musb, type) \

drivers/usb/musb/musb_core.h

379

(((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_split)

drivers/usb/musb/musb_core.h

382

#define can_bulk_combine(musb, type) \

drivers/usb/musb/musb_core.h

383

(((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_combine)

drivers/usb/musb/musb_core.h

423

static inline struct musb *gadget_to_musb(struct usb_gadget *g)

drivers/usb/musb/musb_core.h

425

return container_of(g, struct musb, g);

drivers/usb/musb/musb_core.h

452

static inline int musb_read_fifosize(struct musb *musb,

drivers/usb/musb/musb_core.h

455

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_core.h

459

reg = musb_readb(mbase, musb->io.ep_offset(epnum, MUSB_FIFOSIZE));

drivers/usb/musb/musb_core.h

464

musb->nr_endpoints++;

drivers/usb/musb/musb_core.h

465

musb->epmask |= (1 << epnum);

drivers/usb/musb/musb_core.h

482

static inline void musb_configure_ep0(struct musb *musb)

drivers/usb/musb/musb_core.h

484

musb->endpoints[0].max_packet_sz_tx = MUSB_EP0_FIFOSIZE;

drivers/usb/musb/musb_core.h

485

musb->endpoints[0].max_packet_sz_rx = MUSB_EP0_FIFOSIZE;

drivers/usb/musb/musb_core.h

486

musb->endpoints[0].is_shared_fifo = true;

drivers/usb/musb/musb_core.h

493

extern void musb_stop(struct musb *musb);

drivers/usb/musb/musb_core.h

494

extern void musb_start(struct musb *musb);

drivers/usb/musb/musb_core.h

499

extern int musb_set_host(struct musb *musb);

drivers/usb/musb/musb_core.h

500

extern int musb_set_peripheral(struct musb *musb);

drivers/usb/musb/musb_core.h

502

extern void musb_load_testpacket(struct musb *);

drivers/usb/musb/musb_core.h

504

extern irqreturn_t musb_interrupt(struct musb *);

drivers/usb/musb/musb_core.h

506

extern void musb_hnp_stop(struct musb *musb);

drivers/usb/musb/musb_core.h

508

int musb_queue_resume_work(struct musb *musb,

drivers/usb/musb/musb_core.h

509

int (*callback)(struct musb *musb, void *data),

drivers/usb/musb/musb_core.h

512

static inline void musb_platform_set_vbus(struct musb *musb, int is_on)

drivers/usb/musb/musb_core.h

514

if (musb->ops->set_vbus)

drivers/usb/musb/musb_core.h

515

musb->ops->set_vbus(musb, is_on);

drivers/usb/musb/musb_core.h

518

static inline void musb_platform_enable(struct musb *musb)

drivers/usb/musb/musb_core.h

520

if (musb->ops->enable)

drivers/usb/musb/musb_core.h

521

musb->ops->enable(musb);

drivers/usb/musb/musb_core.h

524

static inline void musb_platform_disable(struct musb *musb)

drivers/usb/musb/musb_core.h

526

if (musb->ops->disable)

drivers/usb/musb/musb_core.h

527

musb->ops->disable(musb);

drivers/usb/musb/musb_core.h

530

static inline int musb_platform_set_mode(struct musb *musb, u8 mode)

drivers/usb/musb/musb_core.h

532

if (!musb->ops->set_mode)

drivers/usb/musb/musb_core.h

535

return musb->ops->set_mode(musb, mode);

drivers/usb/musb/musb_core.h

538

static inline void musb_platform_try_idle(struct musb *musb,

drivers/usb/musb/musb_core.h

541

if (musb->ops->try_idle)

drivers/usb/musb/musb_core.h

542

musb->ops->try_idle(musb, timeout);

drivers/usb/musb/musb_core.h

545

static inline int musb_platform_recover(struct musb *musb)

drivers/usb/musb/musb_core.h

547

if (!musb->ops->recover)

drivers/usb/musb/musb_core.h

550

return musb->ops->recover(musb);

drivers/usb/musb/musb_core.h

553

static inline int musb_platform_get_vbus_status(struct musb *musb)

drivers/usb/musb/musb_core.h

555

if (!musb->ops->vbus_status)

drivers/usb/musb/musb_core.h

558

return musb->ops->vbus_status(musb);

drivers/usb/musb/musb_core.h

561

static inline int musb_platform_init(struct musb *musb)

drivers/usb/musb/musb_core.h

563

if (!musb->ops->init)

drivers/usb/musb/musb_core.h

566

return musb->ops->init(musb);

drivers/usb/musb/musb_core.h

569

static inline int musb_platform_exit(struct musb *musb)

drivers/usb/musb/musb_core.h

571

if (!musb->ops->exit)

drivers/usb/musb/musb_core.h

574

return musb->ops->exit(musb);

drivers/usb/musb/musb_core.h

577

static inline void musb_platform_pre_root_reset_end(struct musb *musb)

drivers/usb/musb/musb_core.h

579

if (musb->ops->pre_root_reset_end)

drivers/usb/musb/musb_core.h

580

musb->ops->pre_root_reset_end(musb);

drivers/usb/musb/musb_core.h

583

static inline void musb_platform_post_root_reset_end(struct musb *musb)

drivers/usb/musb/musb_core.h

585

if (musb->ops->post_root_reset_end)

drivers/usb/musb/musb_core.h

586

musb->ops->post_root_reset_end(musb);

drivers/usb/musb/musb_core.h

589

static inline void musb_platform_clear_ep_rxintr(struct musb *musb, int epnum)

drivers/usb/musb/musb_core.h

591

if (musb->ops->clear_ep_rxintr)

drivers/usb/musb/musb_core.h

592

musb->ops->clear_ep_rxintr(musb, epnum);

drivers/usb/musb/musb_core.h

595

static inline void musb_set_state(struct musb *musb,

drivers/usb/musb/musb_core.h

598

if (musb->xceiv)

drivers/usb/musb/musb_core.h

599

musb->xceiv->otg->state = otg_state;

drivers/usb/musb/musb_core.h

601

musb->otg_state = otg_state;

drivers/usb/musb/musb_core.h

604

static inline enum usb_otg_state musb_get_state(struct musb *musb)

drivers/usb/musb/musb_core.h

606

if (musb->xceiv)

drivers/usb/musb/musb_core.h

607

return musb->xceiv->otg->state;

drivers/usb/musb/musb_core.h

609

return musb->otg_state;

drivers/usb/musb/musb_core.h

612

static inline const char *musb_otg_state_string(struct musb *musb)

drivers/usb/musb/musb_core.h

614

return usb_otg_state_string(musb_get_state(musb));

drivers/usb/musb/musb_cppi41.c

103

struct musb *musb = hw_ep->musb;

drivers/usb/musb/musb_cppi41.c

104

void __iomem *epio = musb->endpoints[epnum].regs;

drivers/usb/musb/musb_cppi41.c

107

musb_ep_select(musb->mregs, hw_ep->epnum);

drivers/usb/musb/musb_cppi41.c

120

struct musb *musb = hw_ep->musb;

drivers/usb/musb/musb_cppi41.c

139

musb_ep_select(musb->mregs, hw_ep->epnum);

drivers/usb/musb/musb_cppi41.c

145

musb_dma_completion(musb, hw_ep->epnum, cppi41_channel->is_tx);

drivers/usb/musb/musb_cppi41.c

177

musb_ep_select(musb->mregs, hw_ep->epnum);

drivers/usb/musb/musb_cppi41.c

189

struct musb *musb;

drivers/usb/musb/musb_cppi41.c

195

musb = controller->controller.musb;

drivers/usb/musb/musb_cppi41.c

197

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_cppi41.c

216

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_cppi41.c

227

struct musb *musb = hw_ep->musb;

drivers/usb/musb/musb_cppi41.c

241

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_cppi41.c

258

if (is_host_active(musb))

drivers/usb/musb/musb_cppi41.c

292

if (is_host_active(musb)) {

drivers/usb/musb/musb_cppi41.c

293

if (musb->port1_status & USB_PORT_STAT_HIGH_SPEED)

drivers/usb/musb/musb_cppi41.c

296

if (musb->g.speed == USB_SPEED_HIGH)

drivers/usb/musb/musb_cppi41.c

326

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_cppi41.c

343

struct musb *musb = controller->controller.musb;

drivers/usb/musb/musb_cppi41.c

359

musb_writel(musb->ctrl_base, USB_CTRL_TX_MODE, new_mode);

drivers/usb/musb/musb_cppi41.c

362

musb_writel(musb->ctrl_base, USB_CTRL_RX_MODE, new_mode);

drivers/usb/musb/musb_cppi41.c

370

struct musb *musb = controller->controller.musb;

drivers/usb/musb/musb_cppi41.c

388

musb_writel(musb->ctrl_base, DA8XX_USB_MODE, new_mode);

drivers/usb/musb/musb_cppi41.c

407

musb_writel(controller->controller.musb->ctrl_base,

drivers/usb/musb/musb_cppi41.c

420

struct musb *musb = cppi41_channel->controller->controller.musb;

drivers/usb/musb/musb_cppi41.c

439

musb_writel(musb->ctrl_base,

drivers/usb/musb/musb_cppi41.c

449

musb_writel(musb->ctrl_base,

drivers/usb/musb/musb_cppi41.c

534

if (is_host_active(cppi41_channel->controller->controller.musb)) {

drivers/usb/musb/musb_cppi41.c

559

struct musb *musb = controller->controller.musb;

drivers/usb/musb/musb_cppi41.c

561

if (is_host_active(musb)) {

drivers/usb/musb/musb_cppi41.c

577

struct musb *musb = controller->controller.musb;

drivers/usb/musb/musb_cppi41.c

61

if (!is_host_active(cppi41_channel->controller->controller.musb))

drivers/usb/musb/musb_cppi41.c

617

if (musb->ops->quirks & MUSB_DA8XX)

drivers/usb/musb/musb_cppi41.c

626

musb_writel(musb->ctrl_base, controller->tdown_reg,

drivers/usb/musb/musb_cppi41.c

632

musb_writel(musb->ctrl_base, controller->tdown_reg, tdbit);

drivers/usb/musb/musb_cppi41.c

667

struct musb *musb = controller->controller.musb;

drivers/usb/musb/musb_cppi41.c

668

struct device *dev = musb->controller;

drivers/usb/musb/musb_cppi41.c

73

struct musb *musb = hw_ep->musb;

drivers/usb/musb/musb_cppi41.c

748

cppi41_dma_controller_create(struct musb *musb, void __iomem *base)

drivers/usb/musb/musb_cppi41.c

754

if (!musb->controller->parent->of_node) {

drivers/usb/musb/musb_cppi41.c

755

dev_err(musb->controller, "Need DT for the DMA engine.\n");

drivers/usb/musb/musb_cppi41.c

772

controller->controller.musb = musb;

drivers/usb/musb/musb_cppi41.c

774

if (musb->ops->quirks & MUSB_DA8XX) {

drivers/usb/musb/musb_cppi41.c

79

if (!is_host_active(musb))

drivers/usb/musb/musb_cppi41.c

82

musb_ep_select(musb->mregs, hw_ep->epnum);

drivers/usb/musb/musb_cppi41.c

94

musb_dbg(musb, "Restoring DATA1 toggle.");

drivers/usb/musb/musb_debug.h

20

void musb_dbg(struct musb *musb, const char *fmt, ...);

drivers/usb/musb/musb_debug.h

23

void musb_init_debugfs(struct musb *musb);

drivers/usb/musb/musb_debug.h

24

void musb_exit_debugfs(struct musb *musb);

drivers/usb/musb/musb_debug.h

26

static inline void musb_init_debugfs(struct musb *musb)

drivers/usb/musb/musb_debug.h

29

static inline void musb_exit_debugfs(struct musb *musb)

drivers/usb/musb/musb_debugfs.c

100

musb_readw(musb->mregs, musb_regmap[i].offset));

drivers/usb/musb/musb_debugfs.c

104

musb_readl(musb->mregs, musb_regmap[i].offset));

drivers/usb/musb/musb_debugfs.c

109

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_debugfs.c

116

struct musb *musb = s->private;

drivers/usb/musb/musb_debugfs.c

119

pm_runtime_get_sync(musb->controller);

drivers/usb/musb/musb_debugfs.c

120

test = musb_readb(musb->mregs, MUSB_TESTMODE);

drivers/usb/musb/musb_debugfs.c

121

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_debugfs.c

165

struct musb *musb = s->private;

drivers/usb/musb/musb_debugfs.c

174

pm_runtime_get_sync(musb->controller);

drivers/usb/musb/musb_debugfs.c

175

test = musb_readb(musb->mregs, MUSB_TESTMODE);

drivers/usb/musb/musb_debugfs.c

177

dev_err(musb->controller, "Error: test mode is already set. "

drivers/usb/musb/musb_debugfs.c

202

musb_load_testpacket(musb);

drivers/usb/musb/musb_debugfs.c

214

musb_writeb(musb->mregs, MUSB_TESTMODE, test);

drivers/usb/musb/musb_debugfs.c

217

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_debugfs.c

231

struct musb *musb = s->private;

drivers/usb/musb/musb_debugfs.c

235

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_debugfs.c

238

pm_runtime_get_sync(musb->controller);

drivers/usb/musb/musb_debugfs.c

240

reg = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/musb_debugfs.c

243

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_debugfs.c

263

struct musb *musb = s->private;

drivers/usb/musb/musb_debugfs.c

272

pm_runtime_get_sync(musb->controller);

drivers/usb/musb/musb_debugfs.c

274

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_debugfs.c

276

musb_root_disconnect(musb);

drivers/usb/musb/musb_debugfs.c

277

reg = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/musb_debugfs.c

279

musb_writeb(musb->mregs, MUSB_DEVCTL, reg);

drivers/usb/musb/musb_debugfs.c

285

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_debugfs.c

293

musb->context.devctl |= MUSB_DEVCTL_SESSION;

drivers/usb/musb/musb_debugfs.c

294

reg = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/musb_debugfs.c

296

musb_writeb(musb->mregs, MUSB_DEVCTL, reg);

drivers/usb/musb/musb_debugfs.c

303

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_debugfs.c

319

void musb_init_debugfs(struct musb *musb)

drivers/usb/musb/musb_debugfs.c

323

root = debugfs_create_dir(dev_name(musb->controller), usb_debug_root);

drivers/usb/musb/musb_debugfs.c

324

musb->debugfs_root = root;

drivers/usb/musb/musb_debugfs.c

326

debugfs_create_file("regdump", S_IRUGO, root, musb, &musb_regdump_fops);

drivers/usb/musb/musb_debugfs.c

327

debugfs_create_file("testmode", S_IRUGO | S_IWUSR, root, musb,

drivers/usb/musb/musb_debugfs.c

329

debugfs_create_file("softconnect", S_IRUGO | S_IWUSR, root, musb,

drivers/usb/musb/musb_debugfs.c

333

void /* __init_or_exit */ musb_exit_debugfs(struct musb *musb)

drivers/usb/musb/musb_debugfs.c

335

debugfs_remove_recursive(musb->debugfs_root);

drivers/usb/musb/musb_debugfs.c

86

struct musb *musb = s->private;

drivers/usb/musb/musb_debugfs.c

90

pm_runtime_get_sync(musb->controller);

drivers/usb/musb/musb_debugfs.c

96

musb_readb(musb->mregs, musb_regmap[i].offset));

drivers/usb/musb/musb_dma.h

154

struct musb *musb;

drivers/usb/musb/musb_dma.h

170

extern void musb_dma_completion(struct musb *musb, u8 epnum, u8 transmit);

drivers/usb/musb/musb_dma.h

174

musb_dma_controller_create(struct musb *m, void __iomem *io)

drivers/usb/musb/musb_dma.h

184

(*musb_dma_controller_create)(struct musb *, void __iomem *);

drivers/usb/musb/musb_dma.h

191

musbhs_dma_controller_create(struct musb *musb, void __iomem *base);

drivers/usb/musb/musb_dma.h

194

musbhs_dma_controller_create_noirq(struct musb *musb, void __iomem *base);

drivers/usb/musb/musb_dma.h

198

tusb_dma_controller_create(struct musb *musb, void __iomem *base);

drivers/usb/musb/musb_dma.h

202

cppi41_dma_controller_create(struct musb *musb, void __iomem *base);

drivers/usb/musb/musb_dma.h

206

ux500_dma_controller_create(struct musb *musb, void __iomem *base);

drivers/usb/musb/musb_dma.h

53

#define musb_dma_ux500(musb) (musb->ops->quirks & MUSB_DMA_UX500)

drivers/usb/musb/musb_dma.h

55

#define musb_dma_ux500(musb) 0

drivers/usb/musb/musb_dma.h

59

#define musb_dma_cppi41(musb) (musb->ops->quirks & MUSB_DMA_CPPI41)

drivers/usb/musb/musb_dma.h

61

#define musb_dma_cppi41(musb) 0

drivers/usb/musb/musb_dma.h

65

#define tusb_dma_omap(musb) (musb->ops->quirks & MUSB_DMA_TUSB_OMAP)

drivers/usb/musb/musb_dma.h

67

#define tusb_dma_omap(musb) 0

drivers/usb/musb/musb_dma.h

71

#define musb_dma_inventra(musb) (musb->ops->quirks & MUSB_DMA_INVENTRA)

drivers/usb/musb/musb_dma.h

73

#define musb_dma_inventra(musb) 0

drivers/usb/musb/musb_dma.h

77

#define is_cppi_enabled(musb) musb_dma_cppi41(musb)

drivers/usb/musb/musb_dma.h

79

#define is_cppi_enabled(musb) 0

drivers/usb/musb/musb_dsps.c

1005

struct musb *musb = platform_get_drvdata(glue->musb);

drivers/usb/musb/musb_dsps.c

1008

if (!musb)

drivers/usb/musb/musb_dsps.c

1013

mbase = musb->ctrl_base;

drivers/usb/musb/musb_dsps.c

1021

if (musb->xceiv->otg->state == OTG_STATE_B_IDLE &&

drivers/usb/musb/musb_dsps.c

1022

musb->port_mode == MUSB_OTG)

drivers/usb/musb/musb_dsps.c

104

struct platform_device *musb; /* child musb pdev */

drivers/usb/musb/musb_dsps.c

136

struct musb *musb = platform_get_drvdata(glue->musb);

drivers/usb/musb/musb_dsps.c

144

mod_timer(&musb->dev_timer, jiffies + wait);

drivers/usb/musb/musb_dsps.c

168

static void dsps_musb_enable(struct musb *musb)

drivers/usb/musb/musb_dsps.c

170

struct device *dev = musb->controller;

drivers/usb/musb/musb_dsps.c

173

void __iomem *reg_base = musb->ctrl_base;

drivers/usb/musb/musb_dsps.c

177

epmask = ((musb->epmask & wrp->txep_mask) << wrp->txep_shift) |

drivers/usb/musb/musb_dsps.c

178

((musb->epmask & wrp->rxep_mask) << wrp->rxep_shift);

drivers/usb/musb/musb_dsps.c

187

if (musb->xceiv->otg->state == OTG_STATE_B_IDLE)

drivers/usb/musb/musb_dsps.c

194

static void dsps_musb_disable(struct musb *musb)

drivers/usb/musb/musb_dsps.c

196

struct device *dev = musb->controller;

drivers/usb/musb/musb_dsps.c

199

void __iomem *reg_base = musb->ctrl_base;

drivers/usb/musb/musb_dsps.c

204

timer_delete_sync(&musb->dev_timer);

drivers/usb/musb/musb_dsps.c

208

static int dsps_check_status(struct musb *musb, void *unused)

drivers/usb/musb/musb_dsps.c

210

void __iomem *mregs = musb->mregs;

drivers/usb/musb/musb_dsps.c

211

struct device *dev = musb->controller;

drivers/usb/musb/musb_dsps.c

218

timer_delete(&musb->dev_timer);

drivers/usb/musb/musb_dsps.c

225

dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,

drivers/usb/musb/musb_dsps.c

226

usb_otg_state_string(musb->xceiv->otg->state));

drivers/usb/musb/musb_dsps.c

228

switch (musb->xceiv->otg->state) {

drivers/usb/musb/musb_dsps.c

230

if (musb->port_mode == MUSB_HOST) {

drivers/usb/musb/musb_dsps.c

231

musb->xceiv->otg->state = OTG_STATE_A_WAIT_BCON;

drivers/usb/musb/musb_dsps.c

239

if (musb->port_mode == MUSB_HOST) {

drivers/usb/musb/musb_dsps.c

243

musb_writeb(musb->mregs, MUSB_DEVCTL, 0);

drivers/usb/musb/musb_dsps.c

251

musb->xceiv->otg->state = OTG_STATE_B_IDLE;

drivers/usb/musb/musb_dsps.c

252

MUSB_DEV_MODE(musb);

drivers/usb/musb/musb_dsps.c

254

musb->xceiv->otg->state = OTG_STATE_A_IDLE;

drivers/usb/musb/musb_dsps.c

255

MUSB_HST_MODE(musb);

drivers/usb/musb/musb_dsps.c

258

if (musb->port_mode == MUSB_PERIPHERAL)

drivers/usb/musb/musb_dsps.c

268

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;

drivers/usb/musb/musb_dsps.c

269

musb_writel(musb->ctrl_base, wrp->coreintr_set,

drivers/usb/musb/musb_dsps.c

281

struct musb *musb = timer_container_of(musb, t, dev_timer);

drivers/usb/musb/musb_dsps.c

282

struct device *dev = musb->controller;

drivers/usb/musb/musb_dsps.c

294

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_dsps.c

295

err = musb_queue_resume_work(musb, dsps_check_status, NULL);

drivers/usb/musb/musb_dsps.c

298

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_dsps.c

302

static void dsps_musb_clear_ep_rxintr(struct musb *musb, int epnum)

drivers/usb/musb/musb_dsps.c

305

struct dsps_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/musb_dsps.c

310

musb_writel(musb->ctrl_base, wrp->epintr_status, epintr);

drivers/usb/musb/musb_dsps.c

315

struct musb *musb = hci;

drivers/usb/musb/musb_dsps.c

316

void __iomem *reg_base = musb->ctrl_base;

drivers/usb/musb/musb_dsps.c

317

struct device *dev = musb->controller;

drivers/usb/musb/musb_dsps.c

324

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_dsps.c

328

musb->int_rx = (epintr & wrp->rxep_bitmap) >> wrp->rxep_shift;

drivers/usb/musb/musb_dsps.c

329

musb->int_tx = (epintr & wrp->txep_bitmap) >> wrp->txep_shift;

drivers/usb/musb/musb_dsps.c

339

musb->int_usb = (usbintr & wrp->usb_bitmap) >> wrp->usb_shift;

drivers/usb/musb/musb_dsps.c

343

dev_dbg(musb->controller, "usbintr (%x) epintr(%x)\n",

drivers/usb/musb/musb_dsps.c

348

void __iomem *mregs = musb->mregs;

drivers/usb/musb/musb_dsps.c

352

err = musb->int_usb & MUSB_INTR_VBUSERROR;

drivers/usb/musb/musb_dsps.c

365

musb->int_usb &= ~MUSB_INTR_VBUSERROR;

drivers/usb/musb/musb_dsps.c

366

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL;

drivers/usb/musb/musb_dsps.c

370

MUSB_HST_MODE(musb);

drivers/usb/musb/musb_dsps.c

371

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;

drivers/usb/musb/musb_dsps.c

374

musb->is_active = 0;

drivers/usb/musb/musb_dsps.c

375

MUSB_DEV_MODE(musb);

drivers/usb/musb/musb_dsps.c

376

musb->xceiv->otg->state = OTG_STATE_B_IDLE;

drivers/usb/musb/musb_dsps.c

380

dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n",

drivers/usb/musb/musb_dsps.c

382

usb_otg_state_string(musb->xceiv->otg->state),

drivers/usb/musb/musb_dsps.c

388

if (musb->int_tx || musb->int_rx || musb->int_usb)

drivers/usb/musb/musb_dsps.c

389

ret |= musb_interrupt(musb);

drivers/usb/musb/musb_dsps.c

392

switch (musb->xceiv->otg->state) {

drivers/usb/musb/musb_dsps.c

402

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_dsps.c

407

static int dsps_musb_dbg_init(struct musb *musb, struct dsps_glue *glue)

drivers/usb/musb/musb_dsps.c

412

sprintf(buf, "%s.dsps", dev_name(musb->controller));

drivers/usb/musb/musb_dsps.c

418

glue->regset.base = musb->ctrl_base;

drivers/usb/musb/musb_dsps.c

424

static int dsps_musb_init(struct musb *musb)

drivers/usb/musb/musb_dsps.c

426

struct device *dev = musb->controller;

drivers/usb/musb/musb_dsps.c

439

musb->ctrl_base = reg_base;

drivers/usb/musb/musb_dsps.c

442

musb->xceiv = devm_usb_get_phy_by_phandle(dev->parent, "phys", 0);

drivers/usb/musb/musb_dsps.c

443

if (IS_ERR(musb->xceiv))

drivers/usb/musb/musb_dsps.c

444

return PTR_ERR(musb->xceiv);

drivers/usb/musb/musb_dsps.c

446

musb->phy = devm_phy_get(dev->parent, "usb2-phy");

drivers/usb/musb/musb_dsps.c

453

if (IS_ERR(musb->phy)) {

drivers/usb/musb/musb_dsps.c

454

musb->phy = NULL;

drivers/usb/musb/musb_dsps.c

456

ret = phy_init(musb->phy);

drivers/usb/musb/musb_dsps.c

459

ret = phy_power_on(musb->phy);

drivers/usb/musb/musb_dsps.c

461

phy_exit(musb->phy);

drivers/usb/musb/musb_dsps.c

466

timer_setup(&musb->dev_timer, otg_timer, 0);

drivers/usb/musb/musb_dsps.c

471

musb->isr = dsps_interrupt;

drivers/usb/musb/musb_dsps.c

476

musb_writel(musb->ctrl_base, wrp->phy_utmi, val);

drivers/usb/musb/musb_dsps.c

484

val = musb_readb(musb->mregs, MUSB_BABBLE_CTL);

drivers/usb/musb/musb_dsps.c

488

musb_writeb(musb->mregs, MUSB_BABBLE_CTL, val);

drivers/usb/musb/musb_dsps.c

493

return dsps_musb_dbg_init(musb, glue);

drivers/usb/musb/musb_dsps.c

496

static int dsps_musb_exit(struct musb *musb)

drivers/usb/musb/musb_dsps.c

498

struct device *dev = musb->controller;

drivers/usb/musb/musb_dsps.c

501

timer_delete_sync(&musb->dev_timer);

drivers/usb/musb/musb_dsps.c

502

phy_power_off(musb->phy);

drivers/usb/musb/musb_dsps.c

503

phy_exit(musb->phy);

drivers/usb/musb/musb_dsps.c

509

static int dsps_musb_set_mode(struct musb *musb, u8 mode)

drivers/usb/musb/musb_dsps.c

511

struct device *dev = musb->controller;

drivers/usb/musb/musb_dsps.c

514

void __iomem *ctrl_base = musb->ctrl_base;

drivers/usb/musb/musb_dsps.c

556

static bool dsps_sw_babble_control(struct musb *musb)

drivers/usb/musb/musb_dsps.c

561

babble_ctl = musb_readb(musb->mregs, MUSB_BABBLE_CTL);

drivers/usb/musb/musb_dsps.c

562

dev_dbg(musb->controller, "babble: MUSB_BABBLE_CTL value %x\n",

drivers/usb/musb/musb_dsps.c

568

dev_dbg(musb->controller, "STUCK_J is %s\n",

drivers/usb/musb/musb_dsps.c

578

babble_ctl = musb_readb(musb->mregs, MUSB_BABBLE_CTL);

drivers/usb/musb/musb_dsps.c

580

musb_writeb(musb->mregs, MUSB_BABBLE_CTL, babble_ctl);

drivers/usb/musb/musb_dsps.c

583

dev_dbg(musb->controller, "Set TXIDLE, wait J to clear\n");

drivers/usb/musb/musb_dsps.c

585

babble_ctl = musb_readb(musb->mregs, MUSB_BABBLE_CTL);

drivers/usb/musb/musb_dsps.c

596

dev_dbg(musb->controller, "J not cleared, misc (%x)\n",

drivers/usb/musb/musb_dsps.c

607

static int dsps_musb_recover(struct musb *musb)

drivers/usb/musb/musb_dsps.c

609

struct device *dev = musb->controller;

drivers/usb/musb/musb_dsps.c

614

session_restart = dsps_sw_babble_control(musb);

drivers/usb/musb/musb_dsps.c

642

struct musb *musb = c->musb;

drivers/usb/musb/musb_dsps.c

643

struct dsps_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/musb_dsps.c

653

dsps_dma_controller_create(struct musb *musb, void __iomem *base)

drivers/usb/musb/musb_dsps.c

656

struct dsps_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/musb_dsps.c

659

controller = cppi41_dma_controller_create(musb, base);

drivers/usb/musb/musb_dsps.c

729

struct platform_device *musb;

drivers/usb/musb/musb_dsps.c

751

musb = platform_device_alloc("musb-hdrc",

drivers/usb/musb/musb_dsps.c

753

if (!musb) {

drivers/usb/musb/musb_dsps.c

758

musb->dev.parent = dev;

drivers/usb/musb/musb_dsps.c

759

musb->dev.dma_mask = &musb_dmamask;

drivers/usb/musb/musb_dsps.c

760

musb->dev.coherent_dma_mask = musb_dmamask;

drivers/usb/musb/musb_dsps.c

761

device_set_of_node_from_dev(&musb->dev, &parent->dev);

drivers/usb/musb/musb_dsps.c

763

glue->musb = musb;

drivers/usb/musb/musb_dsps.c

765

ret = platform_device_add_resources(musb, resources,

drivers/usb/musb/musb_dsps.c

804

ret = platform_device_add_data(musb, &pdata, sizeof(pdata));

drivers/usb/musb/musb_dsps.c

810

ret = platform_device_add(musb);

drivers/usb/musb/musb_dsps.c

818

platform_device_put(musb);

drivers/usb/musb/musb_dsps.c

825

struct musb *musb = platform_get_drvdata(glue->musb);

drivers/usb/musb/musb_dsps.c

827

if (!musb)

drivers/usb/musb/musb_dsps.c

909

platform_device_unregister(glue->musb);

drivers/usb/musb/musb_dsps.c

920

platform_device_unregister(glue->musb);

drivers/usb/musb/musb_dsps.c

971

struct musb *musb = platform_get_drvdata(glue->musb);

drivers/usb/musb/musb_dsps.c

975

if (!musb)

drivers/usb/musb/musb_dsps.c

985

timer_delete_sync(&musb->dev_timer);

drivers/usb/musb/musb_dsps.c

987

mbase = musb->ctrl_base;

drivers/usb/musb/musb_gadget.c

1018

musb_dbg(musb, "packet size beyond hardware FIFO size");

drivers/usb/musb/musb_gadget.c

1022

musb->intrrxe |= (1 << epnum);

drivers/usb/musb/musb_gadget.c

1023

musb_writew(mbase, MUSB_INTRRXE, musb->intrrxe);

drivers/usb/musb/musb_gadget.c

1055

if (is_dma_capable() && musb->dma_controller) {

drivers/usb/musb/musb_gadget.c

1056

struct dma_controller *c = musb->dma_controller;

drivers/usb/musb/musb_gadget.c

106

dma_sync_single_for_cpu(musb->controller,

drivers/usb/musb/musb_gadget.c

1075

schedule_delayed_work(&musb->irq_work, 0);

drivers/usb/musb/musb_gadget.c

1078

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1088

struct musb *musb;

drivers/usb/musb/musb_gadget.c

1094

musb = musb_ep->musb;

drivers/usb/musb/musb_gadget.c

1096

epio = musb->endpoints[epnum].regs;

drivers/usb/musb/musb_gadget.c

1098

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1099

musb_ep_select(musb->mregs, epnum);

drivers/usb/musb/musb_gadget.c

1103

musb->intrtxe &= ~(1 << epnum);

drivers/usb/musb/musb_gadget.c

1104

musb_writew(musb->mregs, MUSB_INTRTXE, musb->intrtxe);

drivers/usb/musb/musb_gadget.c

1107

musb->intrrxe &= ~(1 << epnum);

drivers/usb/musb/musb_gadget.c

1108

musb_writew(musb->mregs, MUSB_INTRRXE, musb->intrrxe);

drivers/usb/musb/musb_gadget.c

1118

schedule_delayed_work(&musb->irq_work, 0);

drivers/usb/musb/musb_gadget.c

1120

spin_unlock_irqrestore(&(musb->lock), flags);

drivers/usb/musb/musb_gadget.c

1122

musb_dbg(musb, "%s", musb_ep->end_point.name);

drivers/usb/musb/musb_gadget.c

1163

void musb_ep_restart(struct musb *musb, struct musb_request *req)

drivers/usb/musb/musb_gadget.c

1169

musb_ep_select(musb->mregs, req->epnum);

drivers/usb/musb/musb_gadget.c

1171

txstate(musb, req);

drivers/usb/musb/musb_gadget.c

1180

static int musb_ep_restart_resume_work(struct musb *musb, void *data)

drivers/usb/musb/musb_gadget.c

1184

musb_ep_restart(musb, req);

drivers/usb/musb/musb_gadget.c

1194

struct musb *musb;

drivers/usb/musb/musb_gadget.c

1204

musb = musb_ep->musb;

drivers/usb/musb/musb_gadget.c

1207

request->musb = musb;

drivers/usb/musb/musb_gadget.c

1212

status = pm_runtime_get(musb->controller);

drivers/usb/musb/musb_gadget.c

1214

dev_err(musb->controller,

drivers/usb/musb/musb_gadget.c

1217

pm_runtime_put_noidle(musb->controller);

drivers/usb/musb/musb_gadget.c

1231

map_dma_buffer(request, musb, musb_ep);

drivers/usb/musb/musb_gadget.c

1233

spin_lock_irqsave(&musb->lock, lockflags);

drivers/usb/musb/musb_gadget.c

1237

musb_dbg(musb, "req %p queued to %s while ep %s",

drivers/usb/musb/musb_gadget.c

1240

unmap_dma_buffer(request, musb);

drivers/usb/musb/musb_gadget.c

1249

status = musb_queue_resume_work(musb,

drivers/usb/musb/musb_gadget.c

1253

dev_err(musb->controller, "%s resume work: %i\n",

drivers/usb/musb/musb_gadget.c

1260

spin_unlock_irqrestore(&musb->lock, lockflags);

drivers/usb/musb/musb_gadget.c

1261

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_gadget.c

127

__releases(ep->musb->lock)

drivers/usb/musb/musb_gadget.c

1273

struct musb *musb = musb_ep->musb;

drivers/usb/musb/musb_gadget.c

128

__acquires(ep->musb->lock)

drivers/usb/musb/musb_gadget.c

1280

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1287

dev_err(musb->controller, "request %p not queued to %s\n",

drivers/usb/musb/musb_gadget.c

1299

struct dma_controller *c = musb->dma_controller;

drivers/usb/musb/musb_gadget.c

1301

musb_ep_select(musb->mregs, musb_ep->current_epnum);

drivers/usb/musb/musb_gadget.c

131

struct musb *musb;

drivers/usb/musb/musb_gadget.c

1316

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1330

struct musb *musb = musb_ep->musb;

drivers/usb/musb/musb_gadget.c

1331

void __iomem *epio = musb->endpoints[epnum].regs;

drivers/usb/musb/musb_gadget.c

1340

mbase = musb->mregs;

drivers/usb/musb/musb_gadget.c

1342

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1354

musb_dbg(musb, "request in progress, cannot halt %s",

drivers/usb/musb/musb_gadget.c

1363

musb_dbg(musb, "FIFO busy, cannot halt %s",

drivers/usb/musb/musb_gadget.c

1373

musb_dbg(musb, "%s: %s stall", ep->name, value ? "set" : "clear");

drivers/usb/musb/musb_gadget.c

139

musb = req->musb;

drivers/usb/musb/musb_gadget.c

1400

musb_dbg(musb, "restarting the request");

drivers/usb/musb/musb_gadget.c

1401

musb_ep_restart(musb, request);

drivers/usb/musb/musb_gadget.c

1405

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

142

spin_unlock(&musb->lock);

drivers/usb/musb/musb_gadget.c

1431

struct musb *musb = musb_ep->musb;

drivers/usb/musb/musb_gadget.c

1433

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_gadget.c

1436

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

144

if (!dma_mapping_error(&musb->g.dev, request->dma))

drivers/usb/musb/musb_gadget.c

1442

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

145

unmap_dma_buffer(req, musb);

drivers/usb/musb/musb_gadget.c

1450

struct musb *musb = musb_ep->musb;

drivers/usb/musb/musb_gadget.c

1452

void __iomem *epio = musb->endpoints[epnum].regs;

drivers/usb/musb/musb_gadget.c

1457

mbase = musb->mregs;

drivers/usb/musb/musb_gadget.c

1459

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1463

musb_writew(mbase, MUSB_INTRTXE, musb->intrtxe & ~(1 << epnum));

drivers/usb/musb/musb_gadget.c

1487

musb_writew(mbase, MUSB_INTRTXE, musb->intrtxe);

drivers/usb/musb/musb_gadget.c

1488

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

149

spin_lock(&musb->lock);

drivers/usb/musb/musb_gadget.c

1508

struct musb *musb = gadget_to_musb(gadget);

drivers/usb/musb/musb_gadget.c

1510

return (int)musb_readw(musb->mregs, MUSB_FRAME);

drivers/usb/musb/musb_gadget.c

1515

struct musb *musb = gadget_to_musb(gadget);

drivers/usb/musb/musb_gadget.c

1516

void __iomem *mregs = musb->mregs;

drivers/usb/musb/musb_gadget.c

1522

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1524

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_gadget.c

1530

if (musb->may_wakeup && musb->is_suspended)

drivers/usb/musb/musb_gadget.c

1536

musb_dbg(musb, "Sending SRP: devctl: %02x", devctl);

drivers/usb/musb/musb_gadget.c

1553

if (musb->xceiv) {

drivers/usb/musb/musb_gadget.c

1554

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1555

otg_start_srp(musb->xceiv->otg);

drivers/usb/musb/musb_gadget.c

1556

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1560

musb_platform_try_idle(musb,

drivers/usb/musb/musb_gadget.c

1566

musb_dbg(musb, "Unhandled wake: %s",

drivers/usb/musb/musb_gadget.c

1567

musb_otg_state_string(musb));

drivers/usb/musb/musb_gadget.c

1576

musb_dbg(musb, "issue wakeup");

drivers/usb/musb/musb_gadget.c

1585

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1596

static void musb_pullup(struct musb *musb, int is_on)

drivers/usb/musb/musb_gadget.c

1600

power = musb_readb(musb->mregs, MUSB_POWER);

drivers/usb/musb/musb_gadget.c

1608

musb_dbg(musb, "gadget D+ pullup %s",

drivers/usb/musb/musb_gadget.c

161

struct musb *musb = ep->musb;

drivers/usb/musb/musb_gadget.c

1610

musb_writeb(musb->mregs, MUSB_POWER, power);

drivers/usb/musb/musb_gadget.c

1616

musb_dbg(musb, "<= %s =>\n", __func__);

drivers/usb/musb/musb_gadget.c

1629

struct musb *musb = gadget_to_musb(gadget);

drivers/usb/musb/musb_gadget.c

163

void __iomem *epio = ep->musb->endpoints[ep->current_epnum].regs;

drivers/usb/musb/musb_gadget.c

1631

return usb_phy_set_power(musb->xceiv, mA);

drivers/usb/musb/musb_gadget.c

1636

struct musb *musb;

drivers/usb/musb/musb_gadget.c

1639

musb = container_of(work, struct musb, gadget_work.work);

drivers/usb/musb/musb_gadget.c

1640

pm_runtime_get_sync(musb->controller);

drivers/usb/musb/musb_gadget.c

1641

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1642

musb_pullup(musb, musb->softconnect);

drivers/usb/musb/musb_gadget.c

1643

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1644

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_gadget.c

1649

struct musb *musb = gadget_to_musb(gadget);

drivers/usb/musb/musb_gadget.c

1657

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1658

if (is_on != musb->softconnect) {

drivers/usb/musb/musb_gadget.c

1659

musb->softconnect = is_on;

drivers/usb/musb/musb_gadget.c

1660

schedule_delayed_work(&musb->gadget_work, 0);

drivers/usb/musb/musb_gadget.c

1662

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

168

struct dma_controller *c = ep->musb->dma_controller;

drivers/usb/musb/musb_gadget.c

1692

init_peripheral_ep(struct musb *musb, struct musb_ep *ep, u8 epnum, int is_in)

drivers/usb/musb/musb_gadget.c

1694

struct musb_hw_ep *hw_ep = musb->endpoints + epnum;

drivers/usb/musb/musb_gadget.c

1699

ep->musb = musb;

drivers/usb/musb/musb_gadget.c

1714

musb->g.ep0 = &ep->end_point;

drivers/usb/musb/musb_gadget.c

1724

list_add_tail(&ep->end_point.ep_list, &musb->g.ep_list);

drivers/usb/musb/musb_gadget.c

1740

static inline void musb_g_init_endpoints(struct musb *musb)

drivers/usb/musb/musb_gadget.c

1746

INIT_LIST_HEAD(&(musb->g.ep_list));

drivers/usb/musb/musb_gadget.c

1748

for (epnum = 0, hw_ep = musb->endpoints;

drivers/usb/musb/musb_gadget.c

1749

epnum < musb->nr_endpoints;

drivers/usb/musb/musb_gadget.c

1752

init_peripheral_ep(musb, &hw_ep->ep_in, epnum, 0);

drivers/usb/musb/musb_gadget.c

1755

init_peripheral_ep(musb, &hw_ep->ep_in,

drivers/usb/musb/musb_gadget.c

1759

init_peripheral_ep(musb, &hw_ep->ep_out,

drivers/usb/musb/musb_gadget.c

1769

int musb_gadget_setup(struct musb *musb)

drivers/usb/musb/musb_gadget.c

1778

musb->g.ops = &musb_gadget_operations;

drivers/usb/musb/musb_gadget.c

1779

musb->g.max_speed = USB_SPEED_HIGH;

drivers/usb/musb/musb_gadget.c

1780

musb->g.speed = USB_SPEED_UNKNOWN;

drivers/usb/musb/musb_gadget.c

1782

MUSB_DEV_MODE(musb);

drivers/usb/musb/musb_gadget.c

1783

musb_set_state(musb, OTG_STATE_B_IDLE);

drivers/usb/musb/musb_gadget.c

1786

musb->g.name = musb_driver_name;

drivers/usb/musb/musb_gadget.c

1788

musb->g.is_otg = 0;

drivers/usb/musb/musb_gadget.c

1789

INIT_DELAYED_WORK(&musb->gadget_work, musb_gadget_work);

drivers/usb/musb/musb_gadget.c

1790

musb_g_init_endpoints(musb);

drivers/usb/musb/musb_gadget.c

1792

musb->is_active = 0;

drivers/usb/musb/musb_gadget.c

1793

musb_platform_try_idle(musb, 0);

drivers/usb/musb/musb_gadget.c

1795

status = usb_add_gadget_udc(musb->controller, &musb->g);

drivers/usb/musb/musb_gadget.c

1801

musb->g.dev.parent = NULL;

drivers/usb/musb/musb_gadget.c

1802

device_unregister(&musb->g.dev);

drivers/usb/musb/musb_gadget.c

1806

void musb_gadget_cleanup(struct musb *musb)

drivers/usb/musb/musb_gadget.c

1808

if (musb->port_mode == MUSB_HOST)

drivers/usb/musb/musb_gadget.c

1811

cancel_delayed_work_sync(&musb->gadget_work);

drivers/usb/musb/musb_gadget.c

1812

usb_del_gadget_udc(&musb->g);

drivers/usb/musb/musb_gadget.c

1829

struct musb *musb = gadget_to_musb(g);

drivers/usb/musb/musb_gadget.c

1838

pm_runtime_get_sync(musb->controller);

drivers/usb/musb/musb_gadget.c

1840

musb->softconnect = 0;

drivers/usb/musb/musb_gadget.c

1841

musb->gadget_driver = driver;

drivers/usb/musb/musb_gadget.c

1843

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1844

musb->is_active = 1;

drivers/usb/musb/musb_gadget.c

1846

if (musb->xceiv)

drivers/usb/musb/musb_gadget.c

1847

otg_set_peripheral(musb->xceiv->otg, &musb->g);

drivers/usb/musb/musb_gadget.c

1849

phy_set_mode(musb->phy, PHY_MODE_USB_DEVICE);

drivers/usb/musb/musb_gadget.c

1851

musb_set_state(musb, OTG_STATE_B_IDLE);

drivers/usb/musb/musb_gadget.c

1852

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1854

musb_start(musb);

drivers/usb/musb/musb_gadget.c

1860

if (musb->xceiv && musb->xceiv->last_event == USB_EVENT_ID)

drivers/usb/musb/musb_gadget.c

1861

musb_platform_set_vbus(musb, 1);

drivers/usb/musb/musb_gadget.c

1863

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_gadget.c

1879

struct musb *musb = gadget_to_musb(g);

drivers/usb/musb/musb_gadget.c

1882

pm_runtime_get_sync(musb->controller);

drivers/usb/musb/musb_gadget.c

1889

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

189

musb_dbg(musb, "%s: abort DMA --> %d", ep->name, value);

drivers/usb/musb/musb_gadget.c

1891

musb_hnp_stop(musb);

drivers/usb/musb/musb_gadget.c

1893

(void) musb_gadget_vbus_draw(&musb->g, 0);

drivers/usb/musb/musb_gadget.c

1895

musb_set_state(musb, OTG_STATE_UNDEFINED);

drivers/usb/musb/musb_gadget.c

1896

musb_stop(musb);

drivers/usb/musb/musb_gadget.c

1898

if (musb->xceiv)

drivers/usb/musb/musb_gadget.c

1899

otg_set_peripheral(musb->xceiv->otg, NULL);

drivers/usb/musb/musb_gadget.c

1901

phy_set_mode(musb->phy, PHY_MODE_INVALID);

drivers/usb/musb/musb_gadget.c

1903

musb->is_active = 0;

drivers/usb/musb/musb_gadget.c

1904

musb->gadget_driver = NULL;

drivers/usb/musb/musb_gadget.c

1905

musb_platform_try_idle(musb, 0);

drivers/usb/musb/musb_gadget.c

1906

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

1916

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/musb_gadget.c

1925

void musb_g_resume(struct musb *musb)

drivers/usb/musb/musb_gadget.c

1927

musb->is_suspended = 0;

drivers/usb/musb/musb_gadget.c

1928

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_gadget.c

1933

musb->is_active = 1;

drivers/usb/musb/musb_gadget.c

1934

if (musb->gadget_driver && musb->gadget_driver->resume) {

drivers/usb/musb/musb_gadget.c

1935

spin_unlock(&musb->lock);

drivers/usb/musb/musb_gadget.c

1936

musb->gadget_driver->resume(&musb->g);

drivers/usb/musb/musb_gadget.c

1937

spin_lock(&musb->lock);

drivers/usb/musb/musb_gadget.c

1942

musb_otg_state_string(musb));

drivers/usb/musb/musb_gadget.c

1947

void musb_g_suspend(struct musb *musb)

drivers/usb/musb/musb_gadget.c

1951

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/musb_gadget.c

1952

musb_dbg(musb, "musb_g_suspend: devctl %02x", devctl);

drivers/usb/musb/musb_gadget.c

1954

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_gadget.c

1957

musb_set_state(musb, OTG_STATE_B_PERIPHERAL);

drivers/usb/musb/musb_gadget.c

1960

musb->is_suspended = 1;

drivers/usb/musb/musb_gadget.c

1961

if (musb->gadget_driver && musb->gadget_driver->suspend) {

drivers/usb/musb/musb_gadget.c

1962

spin_unlock(&musb->lock);

drivers/usb/musb/musb_gadget.c

1963

musb->gadget_driver->suspend(&musb->g);

drivers/usb/musb/musb_gadget.c

1964

spin_lock(&musb->lock);

drivers/usb/musb/musb_gadget.c

1972

musb_otg_state_string(musb));

drivers/usb/musb/musb_gadget.c

1977

void musb_g_wakeup(struct musb *musb)

drivers/usb/musb/musb_gadget.c

1979

musb_gadget_wakeup(&musb->g);

drivers/usb/musb/musb_gadget.c

1983

void musb_g_disconnect(struct musb *musb)

drivers/usb/musb/musb_gadget.c

1985

void __iomem *mregs = musb->mregs;

drivers/usb/musb/musb_gadget.c

1988

musb_dbg(musb, "musb_g_disconnect: devctl %02x", devctl);

drivers/usb/musb/musb_gadget.c

1994

(void) musb_gadget_vbus_draw(&musb->g, 0);

drivers/usb/musb/musb_gadget.c

1996

musb->g.speed = USB_SPEED_UNKNOWN;

drivers/usb/musb/musb_gadget.c

1997

if (musb->gadget_driver && musb->gadget_driver->disconnect) {

drivers/usb/musb/musb_gadget.c

1998

spin_unlock(&musb->lock);

drivers/usb/musb/musb_gadget.c

1999

musb->gadget_driver->disconnect(&musb->g);

drivers/usb/musb/musb_gadget.c

2000

spin_lock(&musb->lock);

drivers/usb/musb/musb_gadget.c

2003

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_gadget.c

2005

musb_dbg(musb, "Unhandled disconnect %s, setting a_idle",

drivers/usb/musb/musb_gadget.c

2006

musb_otg_state_string(musb));

drivers/usb/musb/musb_gadget.c

2007

musb_set_state(musb, OTG_STATE_A_IDLE);

drivers/usb/musb/musb_gadget.c

2008

MUSB_HST_MODE(musb);

drivers/usb/musb/musb_gadget.c

2011

musb_set_state(musb, OTG_STATE_A_WAIT_BCON);

drivers/usb/musb/musb_gadget.c

2012

MUSB_HST_MODE(musb);

drivers/usb/musb/musb_gadget.c

2018

musb_set_state(musb, OTG_STATE_B_IDLE);

drivers/usb/musb/musb_gadget.c

2019

usb_gadget_set_state(&musb->g, USB_STATE_NOTATTACHED);

drivers/usb/musb/musb_gadget.c

2025

musb->is_active = 0;

drivers/usb/musb/musb_gadget.c

2028

void musb_g_reset(struct musb *musb)

drivers/usb/musb/musb_gadget.c

2029

__releases(musb->lock)

drivers/usb/musb/musb_gadget.c

2030

__acquires(musb->lock)

drivers/usb/musb/musb_gadget.c

2032

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_gadget.c

2036

musb_dbg(musb, "<== %s driver '%s'",

drivers/usb/musb/musb_gadget.c

2039

musb->gadget_driver

drivers/usb/musb/musb_gadget.c

2040

? musb->gadget_driver->driver.name

drivers/usb/musb/musb_gadget.c

2045

if (musb->gadget_driver && musb->g.speed != USB_SPEED_UNKNOWN) {

drivers/usb/musb/musb_gadget.c

2046

spin_unlock(&musb->lock);

drivers/usb/musb/musb_gadget.c

2047

usb_gadget_udc_reset(&musb->g, musb->gadget_driver);

drivers/usb/musb/musb_gadget.c

2048

spin_lock(&musb->lock);

drivers/usb/musb/musb_gadget.c

2058

musb->g.speed = (power & MUSB_POWER_HSMODE)

drivers/usb/musb/musb_gadget.c

2062

musb->is_active = 1;

drivers/usb/musb/musb_gadget.c

2063

musb->is_suspended = 0;

drivers/usb/musb/musb_gadget.c

2064

MUSB_DEV_MODE(musb);

drivers/usb/musb/musb_gadget.c

2065

musb->address = 0;

drivers/usb/musb/musb_gadget.c

2066

musb->ep0_state = MUSB_EP0_STAGE_SETUP;

drivers/usb/musb/musb_gadget.c

2068

musb->may_wakeup = 0;

drivers/usb/musb/musb_gadget.c

2069

musb->g.b_hnp_enable = 0;

drivers/usb/musb/musb_gadget.c

2070

musb->g.a_alt_hnp_support = 0;

drivers/usb/musb/musb_gadget.c

2071

musb->g.a_hnp_support = 0;

drivers/usb/musb/musb_gadget.c

2072

musb->g.quirk_zlp_not_supp = 1;

drivers/usb/musb/musb_gadget.c

2077

if (!musb->g.is_otg) {

drivers/usb/musb/musb_gadget.c

2083

musb_set_state(musb, OTG_STATE_B_PERIPHERAL);

drivers/usb/musb/musb_gadget.c

2084

musb->g.is_a_peripheral = 0;

drivers/usb/musb/musb_gadget.c

2086

musb_set_state(musb, OTG_STATE_B_PERIPHERAL);

drivers/usb/musb/musb_gadget.c

2087

musb->g.is_a_peripheral = 0;

drivers/usb/musb/musb_gadget.c

2089

musb_set_state(musb, OTG_STATE_A_PERIPHERAL);

drivers/usb/musb/musb_gadget.c

209

static inline int max_ep_writesize(struct musb *musb, struct musb_ep *ep)

drivers/usb/musb/musb_gadget.c

2090

musb->g.is_a_peripheral = 1;

drivers/usb/musb/musb_gadget.c

2094

(void) musb_gadget_vbus_draw(&musb->g, 8);

drivers/usb/musb/musb_gadget.c

211

if (can_bulk_split(musb, ep->type))

drivers/usb/musb/musb_gadget.c

224

static void txstate(struct musb *musb, struct musb_request *req)

drivers/usb/musb/musb_gadget.c

228

void __iomem *epio = musb->endpoints[epnum].regs;

drivers/usb/musb/musb_gadget.c

237

musb_dbg(musb, "ep:%s disabled - ignore request",

drivers/usb/musb/musb_gadget.c

244

musb_dbg(musb, "dma pending...");

drivers/usb/musb/musb_gadget.c

252

fifo_count = min(max_ep_writesize(musb, musb_ep),

drivers/usb/musb/musb_gadget.c

256

musb_dbg(musb, "%s old packet still ready , txcsr %03x",

drivers/usb/musb/musb_gadget.c

262

musb_dbg(musb, "%s stalling, txcsr %03x",

drivers/usb/musb/musb_gadget.c

267

musb_dbg(musb, "hw_ep%d, maxpacket %d, fifo count %d, txcsr %03x",

drivers/usb/musb/musb_gadget.c

273

struct dma_controller *c = musb->dma_controller;

drivers/usb/musb/musb_gadget.c

284

if (musb_dma_inventra(musb) || musb_dma_ux500(musb)) {

drivers/usb/musb/musb_gadget.c

324

can_bulk_split(musb,

drivers/usb/musb/musb_gadget.c

334

if (is_cppi_enabled(musb)) {

drivers/usb/musb/musb_gadget.c

34

struct musb *musb, struct musb_ep *musb_ep)

drivers/usb/musb/musb_gadget.c

37

struct dma_controller *dma = musb->dma_controller;

drivers/usb/musb/musb_gadget.c

370

} else if (tusb_dma_omap(musb))

drivers/usb/musb/musb_gadget.c

384

unmap_dma_buffer(req, musb);

drivers/usb/musb/musb_gadget.c

395

musb_dbg(musb, "%s TX/IN %s len %d/%d, txcsr %04x, fifo %d/%d",

drivers/usb/musb/musb_gadget.c

407

void musb_g_tx(struct musb *musb, u8 epnum)

drivers/usb/musb/musb_gadget.c

412

u8 __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_gadget.c

413

struct musb_ep *musb_ep = &musb->endpoints[epnum].ep_in;

drivers/usb/musb/musb_gadget.c

414

void __iomem *epio = musb->endpoints[epnum].regs;

drivers/usb/musb/musb_gadget.c

422

musb_dbg(musb, "<== %s, txcsr %04x", musb_ep->end_point.name, csr);

drivers/usb/musb/musb_gadget.c

442

dev_vdbg(musb->controller, "underrun on ep%d, req %p\n",

drivers/usb/musb/musb_gadget.c

451

musb_dbg(musb, "%s dma still busy?", musb_ep->end_point.name);

drivers/usb/musb/musb_gadget.c

467

musb_dbg(musb, "TXCSR%d %04x, DMA off, len %zu, req %p",

drivers/usb/musb/musb_gadget.c

504

musb_dbg(musb, "%s idle now",

drivers/usb/musb/musb_gadget.c

510

txstate(musb, req);

drivers/usb/musb/musb_gadget.c

519

static void rxstate(struct musb *musb, struct musb_request *req)

drivers/usb/musb/musb_gadget.c

524

void __iomem *epio = musb->endpoints[epnum].regs;

drivers/usb/musb/musb_gadget.c

528

struct musb_hw_ep *hw_ep = &musb->endpoints[epnum];

drivers/usb/musb/musb_gadget.c

540

musb_dbg(musb, "ep:%s disabled - ignore request",

drivers/usb/musb/musb_gadget.c

547

musb_dbg(musb, "DMA pending...");

drivers/usb/musb/musb_gadget.c

552

musb_dbg(musb, "%s stalling, RXCSR %04x",

drivers/usb/musb/musb_gadget.c

557

if (is_cppi_enabled(musb) && is_buffer_mapped(req)) {

drivers/usb/musb/musb_gadget.c

558

struct dma_controller *c = musb->dma_controller;

drivers/usb/musb/musb_gadget.c

60

musb->controller,

drivers/usb/musb/musb_gadget.c

602

if (musb_dma_inventra(musb)) {

drivers/usb/musb/musb_gadget.c

608

c = musb->dma_controller;

drivers/usb/musb/musb_gadget.c

66

ret = dma_mapping_error(musb->controller, dma_addr);

drivers/usb/musb/musb_gadget.c

677

if ((musb_dma_ux500(musb)) &&

drivers/usb/musb/musb_gadget.c

684

c = musb->dma_controller;

drivers/usb/musb/musb_gadget.c

727

musb_dbg(musb, "%s OUT/RX pio fifo %d/%d, maxpacket %d",

drivers/usb/musb/musb_gadget.c

73

dma_sync_single_for_device(musb->controller,

drivers/usb/musb/musb_gadget.c

734

if (tusb_dma_omap(musb)) {

drivers/usb/musb/musb_gadget.c

735

struct dma_controller *c = musb->dma_controller;

drivers/usb/musb/musb_gadget.c

754

unmap_dma_buffer(req, musb);

drivers/usb/musb/musb_gadget.c

791

void musb_g_rx(struct musb *musb, u8 epnum)

drivers/usb/musb/musb_gadget.c

796

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_gadget.c

798

void __iomem *epio = musb->endpoints[epnum].regs;

drivers/usb/musb/musb_gadget.c

800

struct musb_hw_ep *hw_ep = &musb->endpoints[epnum];

drivers/usb/musb/musb_gadget.c

819

musb_dbg(musb, "<== %s, rxcsr %04x%s %p", musb_ep->end_point.name,

drivers/usb/musb/musb_gadget.c

834

musb_dbg(musb, "%s iso overrun on %p", musb_ep->name, request);

drivers/usb/musb/musb_gadget.c

840

musb_dbg(musb, "%s, incomprx", musb_ep->end_point.name);

drivers/usb/musb/musb_gadget.c

845

musb_dbg(musb, "%s busy, csr %04x",

drivers/usb/musb/musb_gadget.c

85

struct musb *musb)

drivers/usb/musb/musb_gadget.c

904

rxstate(musb, req);

drivers/usb/musb/musb_gadget.c

916

struct musb *musb;

drivers/usb/musb/musb_gadget.c

929

musb = musb_ep->musb;

drivers/usb/musb/musb_gadget.c

93

dev_vdbg(musb->controller,

drivers/usb/musb/musb_gadget.c

930

mbase = musb->mregs;

drivers/usb/musb/musb_gadget.c

933

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget.c

951

ok = musb->hb_iso_tx;

drivers/usb/musb/musb_gadget.c

953

ok = musb->hb_iso_rx;

drivers/usb/musb/musb_gadget.c

956

musb_dbg(musb, "no support for high bandwidth ISO");

drivers/usb/musb/musb_gadget.c

979

musb_dbg(musb, "packet size beyond hardware FIFO size");

drivers/usb/musb/musb_gadget.c

98

dma_unmap_single(musb->controller,

drivers/usb/musb/musb_gadget.c

983

musb->intrtxe |= (1 << epnum);

drivers/usb/musb/musb_gadget.c

984

musb_writew(mbase, MUSB_INTRTXE, musb->intrtxe);

drivers/usb/musb/musb_gadget.c

992

if (can_bulk_split(musb, musb_ep->type))

drivers/usb/musb/musb_gadget.h

114

extern void musb_ep_restart(struct musb *, struct musb_request *);

drivers/usb/musb/musb_gadget.h

16

extern irqreturn_t musb_g_ep0_irq(struct musb *);

drivers/usb/musb/musb_gadget.h

17

extern void musb_g_tx(struct musb *, u8);

drivers/usb/musb/musb_gadget.h

18

extern void musb_g_rx(struct musb *, u8);

drivers/usb/musb/musb_gadget.h

19

extern void musb_g_reset(struct musb *);

drivers/usb/musb/musb_gadget.h

20

extern void musb_g_suspend(struct musb *);

drivers/usb/musb/musb_gadget.h

21

extern void musb_g_resume(struct musb *);

drivers/usb/musb/musb_gadget.h

22

extern void musb_g_wakeup(struct musb *);

drivers/usb/musb/musb_gadget.h

23

extern void musb_g_disconnect(struct musb *);

drivers/usb/musb/musb_gadget.h

24

extern void musb_gadget_cleanup(struct musb *);

drivers/usb/musb/musb_gadget.h

25

extern int musb_gadget_setup(struct musb *);

drivers/usb/musb/musb_gadget.h

28

static inline irqreturn_t musb_g_ep0_irq(struct musb *musb)

drivers/usb/musb/musb_gadget.h

33

static inline void musb_g_tx(struct musb *musb, u8 epnum) {}

drivers/usb/musb/musb_gadget.h

34

static inline void musb_g_rx(struct musb *musb, u8 epnum) {}

drivers/usb/musb/musb_gadget.h

35

static inline void musb_g_reset(struct musb *musb) {}

drivers/usb/musb/musb_gadget.h

36

static inline void musb_g_suspend(struct musb *musb) {}

drivers/usb/musb/musb_gadget.h

37

static inline void musb_g_resume(struct musb *musb) {}

drivers/usb/musb/musb_gadget.h

38

static inline void musb_g_wakeup(struct musb *musb) {}

drivers/usb/musb/musb_gadget.h

39

static inline void musb_g_disconnect(struct musb *musb) {}

drivers/usb/musb/musb_gadget.h

40

static inline void musb_gadget_cleanup(struct musb *musb) {}

drivers/usb/musb/musb_gadget.h

41

static inline int musb_gadget_setup(struct musb *musb)

drivers/usb/musb/musb_gadget.h

57

struct musb *musb;

drivers/usb/musb/musb_gadget.h

78

struct musb *musb;

drivers/usb/musb/musb_gadget_ep0.c

1003

musb = ep->musb;

drivers/usb/musb/musb_gadget_ep0.c

1004

base = musb->mregs;

drivers/usb/musb/musb_gadget_ep0.c

1005

regs = musb->control_ep->regs;

drivers/usb/musb/musb_gadget_ep0.c

1008

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_gadget_ep0.c

101

ep = &musb->endpoints[epnum].ep_out;

drivers/usb/musb/musb_gadget_ep0.c

1016

csr = musb->ackpend;

drivers/usb/musb/musb_gadget_ep0.c

1018

switch (musb->ep0_state) {

drivers/usb/musb/musb_gadget_ep0.c

102

regs = musb->endpoints[epnum].regs;

drivers/usb/musb/musb_gadget_ep0.c

1037

musb->ep0_state = MUSB_EP0_STAGE_IDLE;

drivers/usb/musb/musb_gadget_ep0.c

1038

musb->ackpend = 0;

drivers/usb/musb/musb_gadget_ep0.c

1041

musb_dbg(musb, "ep0 can't halt in state %d", musb->ep0_state);

drivers/usb/musb/musb_gadget_ep0.c

1046

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_gadget_ep0.c

133

musb_write_fifo(&musb->endpoints[0], len, result);

drivers/usb/musb/musb_gadget_ep0.c

151

service_in_request(struct musb *musb, const struct usb_ctrlrequest *ctrlrequest)

drivers/usb/musb/musb_gadget_ep0.c

159

handled = service_tx_status_request(musb,

drivers/usb/musb/musb_gadget_ep0.c

175

static void musb_g_ep0_giveback(struct musb *musb, struct usb_request *req)

drivers/usb/musb/musb_gadget_ep0.c

177

musb_g_giveback(&musb->endpoints[0].ep_in, req, 0);

drivers/usb/musb/musb_gadget_ep0.c

183

static inline void musb_try_b_hnp_enable(struct musb *musb)

drivers/usb/musb/musb_gadget_ep0.c

185

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_gadget_ep0.c

188

musb_dbg(musb, "HNP: Setting HR");

drivers/usb/musb/musb_gadget_ep0.c

204

service_zero_data_request(struct musb *musb,

drivers/usb/musb/musb_gadget_ep0.c

206

__releases(musb->lock)

drivers/usb/musb/musb_gadget_ep0.c

207

__acquires(musb->lock)

drivers/usb/musb/musb_gadget_ep0.c

21

#define next_ep0_request(musb) next_in_request(&(musb)->endpoints[0])

drivers/usb/musb/musb_gadget_ep0.c

210

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_gadget_ep0.c

219

musb->set_address = true;

drivers/usb/musb/musb_gadget_ep0.c

220

musb->address = (u8) (ctrlrequest->wValue & 0x7f);

drivers/usb/musb/musb_gadget_ep0.c

230

musb->may_wakeup = 0;

drivers/usb/musb/musb_gadget_ep0.c

249

ep = musb->endpoints + epnum;

drivers/usb/musb/musb_gadget_ep0.c

285

musb_dbg(musb, "restarting the request");

drivers/usb/musb/musb_gadget_ep0.c

286

musb_ep_restart(musb, request);

drivers/usb/musb/musb_gadget_ep0.c

305

musb->may_wakeup = 1;

drivers/usb/musb/musb_gadget_ep0.c

308

if (musb->g.speed != USB_SPEED_HIGH)

drivers/usb/musb/musb_gadget_ep0.c

316

musb->test_mode_nr =

drivers/usb/musb/musb_gadget_ep0.c

321

musb->test_mode_nr =

drivers/usb/musb/musb_gadget_ep0.c

326

musb->test_mode_nr =

drivers/usb/musb/musb_gadget_ep0.c

331

musb->test_mode_nr =

drivers/usb/musb/musb_gadget_ep0.c

338

musb->test_mode_nr =

drivers/usb/musb/musb_gadget_ep0.c

344

musb->test_mode_nr =

drivers/usb/musb/musb_gadget_ep0.c

350

musb->test_mode_nr =

drivers/usb/musb/musb_gadget_ep0.c

356

musb->test_mode_nr =

drivers/usb/musb/musb_gadget_ep0.c

365

musb->test_mode = true;

drivers/usb/musb/musb_gadget_ep0.c

368

if (!musb->g.is_otg)

drivers/usb/musb/musb_gadget_ep0.c

370

musb->g.b_hnp_enable = 1;

drivers/usb/musb/musb_gadget_ep0.c

371

musb_try_b_hnp_enable(musb);

drivers/usb/musb/musb_gadget_ep0.c

374

if (!musb->g.is_otg)

drivers/usb/musb/musb_gadget_ep0.c

376

musb->g.a_hnp_support = 1;

drivers/usb/musb/musb_gadget_ep0.c

379

if (!musb->g.is_otg)

drivers/usb/musb/musb_gadget_ep0.c

381

musb->g.a_alt_hnp_support = 1;

drivers/usb/musb/musb_gadget_ep0.c

409

ep = musb->endpoints + epnum;

drivers/usb/musb/musb_gadget_ep0.c

460

static void ep0_rxstate(struct musb *musb)

drivers/usb/musb/musb_gadget_ep0.c

462

void __iomem *regs = musb->control_ep->regs;

drivers/usb/musb/musb_gadget_ep0.c

467

request = next_ep0_request(musb);

drivers/usb/musb/musb_gadget_ep0.c

484

musb_read_fifo(&musb->endpoints[0], count, buf);

drivers/usb/musb/musb_gadget_ep0.c

489

musb->ep0_state = MUSB_EP0_STAGE_STATUSIN;

drivers/usb/musb/musb_gadget_ep0.c

501

musb->ackpend = csr;

drivers/usb/musb/musb_gadget_ep0.c

502

musb_g_ep0_giveback(musb, req);

drivers/usb/musb/musb_gadget_ep0.c

503

if (!musb->ackpend)

drivers/usb/musb/musb_gadget_ep0.c

505

musb->ackpend = 0;

drivers/usb/musb/musb_gadget_ep0.c

507

musb_ep_select(musb->mregs, 0);

drivers/usb/musb/musb_gadget_ep0.c

51

struct musb *musb,

drivers/usb/musb/musb_gadget_ep0.c

517

static void ep0_txstate(struct musb *musb)

drivers/usb/musb/musb_gadget_ep0.c

519

void __iomem *regs = musb->control_ep->regs;

drivers/usb/musb/musb_gadget_ep0.c

520

struct musb_request *req = next_ep0_request(musb);

drivers/usb/musb/musb_gadget_ep0.c

528

musb_dbg(musb, "odd; csr0 %04x", musb_readw(regs, MUSB_CSR0));

drivers/usb/musb/musb_gadget_ep0.c

538

musb_write_fifo(&musb->endpoints[0], fifo_count, fifo_src);

drivers/usb/musb/musb_gadget_ep0.c

54

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_gadget_ep0.c

545

musb->ep0_state = MUSB_EP0_STAGE_STATUSOUT;

drivers/usb/musb/musb_gadget_ep0.c

556

musb->ackpend = csr;

drivers/usb/musb/musb_gadget_ep0.c

557

musb_g_ep0_giveback(musb, request);

drivers/usb/musb/musb_gadget_ep0.c

558

if (!musb->ackpend)

drivers/usb/musb/musb_gadget_ep0.c

560

musb->ackpend = 0;

drivers/usb/musb/musb_gadget_ep0.c

564

musb_ep_select(musb->mregs, 0);

drivers/usb/musb/musb_gadget_ep0.c

575

musb_read_setup(struct musb *musb, struct usb_ctrlrequest *req)

drivers/usb/musb/musb_gadget_ep0.c

578

void __iomem *regs = musb->control_ep->regs;

drivers/usb/musb/musb_gadget_ep0.c

580

musb_read_fifo(&musb->endpoints[0], sizeof *req, (u8 *)req);

drivers/usb/musb/musb_gadget_ep0.c

585

musb_dbg(musb, "SETUP req%02x.%02x v%04x i%04x l%d",

drivers/usb/musb/musb_gadget_ep0.c

593

r = next_ep0_request(musb);

drivers/usb/musb/musb_gadget_ep0.c

595

musb_g_ep0_giveback(musb, &r->request);

drivers/usb/musb/musb_gadget_ep0.c

605

musb->set_address = false;

drivers/usb/musb/musb_gadget_ep0.c

606

musb->ackpend = MUSB_CSR0_P_SVDRXPKTRDY;

drivers/usb/musb/musb_gadget_ep0.c

609

musb->ackpend |= MUSB_CSR0_TXPKTRDY;

drivers/usb/musb/musb_gadget_ep0.c

610

musb->ep0_state = MUSB_EP0_STAGE_ACKWAIT;

drivers/usb/musb/musb_gadget_ep0.c

612

musb->ep0_state = MUSB_EP0_STAGE_TX;

drivers/usb/musb/musb_gadget_ep0.c

617

musb->ackpend = 0;

drivers/usb/musb/musb_gadget_ep0.c

619

musb->ep0_state = MUSB_EP0_STAGE_RX;

drivers/usb/musb/musb_gadget_ep0.c

623

forward_to_driver(struct musb *musb, const struct usb_ctrlrequest *ctrlrequest)

drivers/usb/musb/musb_gadget_ep0.c

624

__releases(musb->lock)

drivers/usb/musb/musb_gadget_ep0.c

625

__acquires(musb->lock)

drivers/usb/musb/musb_gadget_ep0.c

628

if (!musb->gadget_driver)

drivers/usb/musb/musb_gadget_ep0.c

63

result[0] = musb->g.is_selfpowered << USB_DEVICE_SELF_POWERED;

drivers/usb/musb/musb_gadget_ep0.c

630

spin_unlock(&musb->lock);

drivers/usb/musb/musb_gadget_ep0.c

631

retval = musb->gadget_driver->setup(&musb->g, ctrlrequest);

drivers/usb/musb/musb_gadget_ep0.c

632

spin_lock(&musb->lock);

drivers/usb/musb/musb_gadget_ep0.c

64

result[0] |= musb->may_wakeup << USB_DEVICE_REMOTE_WAKEUP;

drivers/usb/musb/musb_gadget_ep0.c

641

irqreturn_t musb_g_ep0_irq(struct musb *musb)

drivers/usb/musb/musb_gadget_ep0.c

645

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_gadget_ep0.c

646

void __iomem *regs = musb->endpoints[0].regs;

drivers/usb/musb/musb_gadget_ep0.c

65

if (musb->g.is_otg) {

drivers/usb/musb/musb_gadget_ep0.c

653

musb_dbg(musb, "csr %04x, count %d, ep0stage %s",

drivers/usb/musb/musb_gadget_ep0.c

654

csr, len, decode_ep0stage(musb->ep0_state));

drivers/usb/musb/musb_gadget_ep0.c

66

result[0] |= musb->g.b_hnp_enable

drivers/usb/musb/musb_gadget_ep0.c

669

musb->ep0_state = MUSB_EP0_STAGE_IDLE;

drivers/usb/musb/musb_gadget_ep0.c

678

switch (musb->ep0_state) {

drivers/usb/musb/musb_gadget_ep0.c

68

result[0] |= musb->g.a_alt_hnp_support

drivers/usb/musb/musb_gadget_ep0.c

680

musb->ep0_state = MUSB_EP0_STAGE_STATUSOUT;

drivers/usb/musb/musb_gadget_ep0.c

683

musb->ep0_state = MUSB_EP0_STAGE_STATUSIN;

drivers/usb/musb/musb_gadget_ep0.c

687

decode_ep0stage(musb->ep0_state));

drivers/usb/musb/musb_gadget_ep0.c

697

switch (musb->ep0_state) {

drivers/usb/musb/musb_gadget_ep0.c

70

result[0] |= musb->g.a_hnp_support

drivers/usb/musb/musb_gadget_ep0.c

702

ep0_txstate(musb);

drivers/usb/musb/musb_gadget_ep0.c

710

ep0_rxstate(musb);

drivers/usb/musb/musb_gadget_ep0.c

723

if (musb->set_address) {

drivers/usb/musb/musb_gadget_ep0.c

724

musb->set_address = false;

drivers/usb/musb/musb_gadget_ep0.c

725

musb_writeb(mbase, MUSB_FADDR, musb->address);

drivers/usb/musb/musb_gadget_ep0.c

729

else if (musb->test_mode) {

drivers/usb/musb/musb_gadget_ep0.c

730

musb_dbg(musb, "entering TESTMODE");

drivers/usb/musb/musb_gadget_ep0.c

732

if (MUSB_TEST_PACKET == musb->test_mode_nr)

drivers/usb/musb/musb_gadget_ep0.c

733

musb_load_testpacket(musb);

drivers/usb/musb/musb_gadget_ep0.c

736

musb->test_mode_nr);

drivers/usb/musb/musb_gadget_ep0.c

745

req = next_ep0_request(musb);

drivers/usb/musb/musb_gadget_ep0.c

747

musb_g_ep0_giveback(musb, &req->request);

drivers/usb/musb/musb_gadget_ep0.c

758

musb->ep0_state = MUSB_EP0_STAGE_IDLE;

drivers/usb/musb/musb_gadget_ep0.c

769

musb->ep0_state = MUSB_EP0_STAGE_SETUP;

drivers/usb/musb/musb_gadget_ep0.c

782

musb_read_setup(musb, &setup);

drivers/usb/musb/musb_gadget_ep0.c

786

if (unlikely(musb->g.speed == USB_SPEED_UNKNOWN)) {

drivers/usb/musb/musb_gadget_ep0.c

793

musb->g.speed = (power & MUSB_POWER_HSMODE)

drivers/usb/musb/musb_gadget_ep0.c

798

switch (musb->ep0_state) {

drivers/usb/musb/musb_gadget_ep0.c

807

musb, &setup);

drivers/usb/musb/musb_gadget_ep0.c

815

musb->ackpend |= MUSB_CSR0_P_DATAEND;

drivers/usb/musb/musb_gadget_ep0.c

819

musb->ep0_state =

drivers/usb/musb/musb_gadget_ep0.c

828

handled = service_in_request(musb, &setup);

drivers/usb/musb/musb_gadget_ep0.c

830

musb->ackpend = MUSB_CSR0_TXPKTRDY

drivers/usb/musb/musb_gadget_ep0.c

832

musb->ep0_state =

drivers/usb/musb/musb_gadget_ep0.c

842

musb_dbg(musb, "handled %d, csr %04x, ep0stage %s",

drivers/usb/musb/musb_gadget_ep0.c

844

decode_ep0stage(musb->ep0_state));

drivers/usb/musb/musb_gadget_ep0.c

855

handled = forward_to_driver(musb, &setup);

drivers/usb/musb/musb_gadget_ep0.c

859

musb_dbg(musb, "stall (%d)", handled);

drivers/usb/musb/musb_gadget_ep0.c

860

musb->ackpend |= MUSB_CSR0_P_SENDSTALL;

drivers/usb/musb/musb_gadget_ep0.c

861

musb->ep0_state = MUSB_EP0_STAGE_IDLE;

drivers/usb/musb/musb_gadget_ep0.c

864

musb->ackpend);

drivers/usb/musb/musb_gadget_ep0.c

865

musb->ackpend = 0;

drivers/usb/musb/musb_gadget_ep0.c

881

musb->ep0_state = MUSB_EP0_STAGE_IDLE;

drivers/usb/musb/musb_gadget_ep0.c

907

struct musb *musb;

drivers/usb/musb/musb_gadget_ep0.c

916

musb = ep->musb;

drivers/usb/musb/musb_gadget_ep0.c

917

regs = musb->control_ep->regs;

drivers/usb/musb/musb_gadget_ep0.c

920

req->musb = musb;

drivers/usb/musb/musb_gadget_ep0.c

925

spin_lock_irqsave(&musb->lock, lockflags);

drivers/usb/musb/musb_gadget_ep0.c

932

switch (musb->ep0_state) {

drivers/usb/musb/musb_gadget_ep0.c

939

musb_dbg(musb, "ep0 request queued in state %d",

drivers/usb/musb/musb_gadget_ep0.c

940

musb->ep0_state);

drivers/usb/musb/musb_gadget_ep0.c

948

musb_dbg(musb, "queue to %s (%s), length=%d",

drivers/usb/musb/musb_gadget_ep0.c

952

musb_ep_select(musb->mregs, 0);

drivers/usb/musb/musb_gadget_ep0.c

955

if (musb->ep0_state == MUSB_EP0_STAGE_TX)

drivers/usb/musb/musb_gadget_ep0.c

956

ep0_txstate(musb);

drivers/usb/musb/musb_gadget_ep0.c

959

else if (musb->ep0_state == MUSB_EP0_STAGE_ACKWAIT) {

drivers/usb/musb/musb_gadget_ep0.c

963

musb->ep0_state = MUSB_EP0_STAGE_STATUSIN;

drivers/usb/musb/musb_gadget_ep0.c

965

musb->ackpend | MUSB_CSR0_P_DATAEND);

drivers/usb/musb/musb_gadget_ep0.c

966

musb->ackpend = 0;

drivers/usb/musb/musb_gadget_ep0.c

967

musb_g_ep0_giveback(ep->musb, r);

drivers/usb/musb/musb_gadget_ep0.c

974

} else if (musb->ackpend) {

drivers/usb/musb/musb_gadget_ep0.c

975

musb_writew(regs, MUSB_CSR0, musb->ackpend);

drivers/usb/musb/musb_gadget_ep0.c

976

musb->ackpend = 0;

drivers/usb/musb/musb_gadget_ep0.c

980

spin_unlock_irqrestore(&musb->lock, lockflags);

drivers/usb/musb/musb_gadget_ep0.c

99

ep = &musb->endpoints[epnum].ep_in;

drivers/usb/musb/musb_gadget_ep0.c

993

struct musb *musb;

drivers/usb/musb/musb_host.c

1010

musb_dbg(musb, "start no-DATA");

drivers/usb/musb/musb_host.c

1013

musb_dbg(musb, "start IN-DATA");

drivers/usb/musb/musb_host.c

1014

musb->ep0_stage = MUSB_EP0_IN;

drivers/usb/musb/musb_host.c

1018

musb_dbg(musb, "start OUT-DATA");

drivers/usb/musb/musb_host.c

1019

musb->ep0_stage = MUSB_EP0_OUT;

drivers/usb/musb/musb_host.c

1030

musb_dbg(musb, "Sending %d byte%s to ep0 fifo %p",

drivers/usb/musb/musb_host.c

1041

ERR("bogus ep0 stage %d\n", musb->ep0_stage);

drivers/usb/musb/musb_host.c

1054

irqreturn_t musb_h_ep0_irq(struct musb *musb)

drivers/usb/musb/musb_host.c

1059

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_host.c

1060

struct musb_hw_ep *hw_ep = musb->control_ep;

drivers/usb/musb/musb_host.c

1075

musb_dbg(musb, "<== csr0 %04x, qh %p, count %d, urb %p, stage %d",

drivers/usb/musb/musb_host.c

1076

csr, qh, len, urb, musb->ep0_stage);

drivers/usb/musb/musb_host.c

1079

if (MUSB_EP0_STATUS == musb->ep0_stage) {

drivers/usb/musb/musb_host.c

1086

musb_dbg(musb, "STALLING ENDPOINT");

drivers/usb/musb/musb_host.c

1090

musb_dbg(musb, "no response, csr0 %04x", csr);

drivers/usb/musb/musb_host.c

1094

musb_dbg(musb, "control NAK timeout");

drivers/usb/musb/musb_host.c

1109

musb_dbg(musb, "aborting");

drivers/usb/musb/musb_host.c

114

if (dev_WARN_ONCE(musb->controller, retries-- < 1,

drivers/usb/musb/musb_host.c

1142

if (musb_h_ep0_continue(musb, len, urb)) {

drivers/usb/musb/musb_host.c

1144

csr = (MUSB_EP0_IN == musb->ep0_stage)

drivers/usb/musb/musb_host.c

1160

musb->ep0_stage = MUSB_EP0_STATUS;

drivers/usb/musb/musb_host.c

1162

musb_dbg(musb, "ep0 STATUS, csr %04x", csr);

drivers/usb/musb/musb_host.c

1168

musb->ep0_stage = MUSB_EP0_IDLE;

drivers/usb/musb/musb_host.c

1172

musb_advance_schedule(musb, urb, hw_ep, 1);

drivers/usb/musb/musb_host.c

1195

void musb_host_tx(struct musb *musb, u8 epnum)

drivers/usb/musb/musb_host.c

1202

struct musb_hw_ep *hw_ep = musb->endpoints + epnum;

drivers/usb/musb/musb_host.c

1207

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_host.c

1216

musb_dbg(musb, "extra TX%d ready, csr %04x", epnum, tx_csr);

drivers/usb/musb/musb_host.c

1222

trace_musb_urb_tx(musb, urb);

drivers/usb/musb/musb_host.c

1223

musb_dbg(musb, "OUT/TX%d end, csr %04x%s", epnum, tx_csr,

drivers/usb/musb/musb_host.c

1229

musb_dbg(musb, "TX end %d stall", epnum);

drivers/usb/musb/musb_host.c

1236

musb_dbg(musb, "TX 3strikes on ep=%d", epnum);

drivers/usb/musb/musb_host.c

1242

&& !list_is_singular(&musb->out_bulk)) {

drivers/usb/musb/musb_host.c

1243

musb_dbg(musb, "NAK timeout on TX%d ep", epnum);

drivers/usb/musb/musb_host.c

1244

musb_bulk_nak_timeout(musb, hw_ep, 0);

drivers/usb/musb/musb_host.c

1246

musb_dbg(musb, "TX ep%d device not responding", epnum);

drivers/usb/musb/musb_host.c

1267

musb->dma_controller->channel_abort(dma);

drivers/usb/musb/musb_host.c

1292

musb_dbg(musb, "extra TX%d ready, csr %04x", epnum, tx_csr);

drivers/usb/musb/musb_host.c

1351

musb_dbg(musb,

drivers/usb/musb/musb_host.c

1409

musb_advance_schedule(musb, urb, hw_ep, USB_DIR_OUT);

drivers/usb/musb/musb_host.c

1412

if (musb_tx_dma_program(musb->dma_controller, hw_ep, qh, urb,

drivers/usb/musb/musb_host.c

1414

if (is_cppi_enabled(musb) || tusb_dma_omap(musb))

drivers/usb/musb/musb_host.c

1419

musb_dbg(musb, "not complete, but DMA enabled?");

drivers/usb/musb/musb_host.c

1433

usb_hcd_unmap_urb_for_dma(musb->hcd, urb);

drivers/usb/musb/musb_host.c

1442

dev_err(musb->controller, "error: sg list empty\n");

drivers/usb/musb/musb_host.c

1565

if (musb_dma_cppi41(hw_ep->musb))

drivers/usb/musb/musb_host.c

1612

struct musb *musb = hw_ep->musb;

drivers/usb/musb/musb_host.c

1637

musb_dbg(musb, "** OVERFLOW %d into %d",

drivers/usb/musb/musb_host.c

172

if (is_cppi_enabled(ep->musb))

drivers/usb/musb/musb_host.c

1729

void musb_host_rx(struct musb *musb, u8 epnum)

drivers/usb/musb/musb_host.c

1732

struct musb_hw_ep *hw_ep = musb->endpoints + epnum;

drivers/usb/musb/musb_host.c

1733

struct dma_controller *c = musb->dma_controller;

drivers/usb/musb/musb_host.c

1737

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_host.c

1760

musb_dbg(musb, "BOGUS RX%d ready, csr %04x, count %d",

drivers/usb/musb/musb_host.c

1766

trace_musb_urb_rx(musb, urb);

drivers/usb/musb/musb_host.c

1771

musb_dbg(musb, "RX end %d STALL", epnum);

drivers/usb/musb/musb_host.c

1777

dev_err(musb->controller, "ep%d RX three-strikes error", epnum);

drivers/usb/musb/musb_host.c

1794

musb_dbg(musb, "RX end %d NAK timeout", epnum);

drivers/usb/musb/musb_host.c

1806

&& !list_is_singular(&musb->in_bulk)) {

drivers/usb/musb/musb_host.c

1807

musb_bulk_nak_timeout(musb, hw_ep, 1);

drivers/usb/musb/musb_host.c

1817

musb_dbg(musb, "RX end %d ISO data error", epnum);

drivers/usb/musb/musb_host.c

1822

musb_dbg(musb, "end %d high bandwidth incomplete ISO packet RX",

drivers/usb/musb/musb_host.c

1832

musb->dma_controller->channel_abort(dma);

drivers/usb/musb/musb_host.c

1853

if (!musb_dma_inventra(musb) && !musb_dma_ux500(musb) &&

drivers/usb/musb/musb_host.c

1862

musb->dma_controller->channel_abort(dma);

drivers/usb/musb/musb_host.c

1867

musb_dbg(musb, "RXCSR%d %04x, reqpkt, len %zu%s", epnum, rx_csr,

drivers/usb/musb/musb_host.c

1885

if (musb_dma_inventra(musb) || musb_dma_ux500(musb) ||

drivers/usb/musb/musb_host.c

1886

musb_dma_cppi41(musb)) {

drivers/usb/musb/musb_host.c

1888

musb_dbg(hw_ep->musb,

drivers/usb/musb/musb_host.c

1914

if ((musb_dma_inventra(musb) || musb_dma_ux500(musb) ||

drivers/usb/musb/musb_host.c

1915

musb_dma_cppi41(musb)) && dma) {

drivers/usb/musb/musb_host.c

1916

musb_dbg(hw_ep->musb,

drivers/usb/musb/musb_host.c

1928

dev_err(musb->controller, "error: rx_dma failed\n");

drivers/usb/musb/musb_host.c

1935

usb_hcd_unmap_urb_for_dma(musb->hcd, urb);

drivers/usb/musb/musb_host.c

1949

dev_err(musb->controller, "error: sg list empty\n");

drivers/usb/musb/musb_host.c

1958

done = musb_host_packet_rx(musb, urb, epnum,

drivers/usb/musb/musb_host.c

1966

done = musb_host_packet_rx(musb, urb,

drivers/usb/musb/musb_host.c

1969

musb_dbg(musb, "read %spacket", done ? "last " : "");

drivers/usb/musb/musb_host.c

197

musb_start_urb(struct musb *musb, int is_in, struct musb_qh *qh)

drivers/usb/musb/musb_host.c

1984

musb_advance_schedule(musb, urb, hw_ep, USB_DIR_IN);

drivers/usb/musb/musb_host.c

1994

struct musb *musb,

drivers/usb/musb/musb_host.c

200

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_host.c

2009

head = &musb->control;

drivers/usb/musb/musb_host.c

2010

hw_ep = musb->control_ep;

drivers/usb/musb/musb_host.c

2026

for (epnum = 1, hw_ep = musb->endpoints + 1;

drivers/usb/musb/musb_host.c

2027

epnum < musb->nr_endpoints;

drivers/usb/musb/musb_host.c

2034

if (hw_ep == musb->bulk_ep)

drivers/usb/musb/musb_host.c

2057

hw_ep = musb->endpoints + epnum;

drivers/usb/musb/musb_host.c

2071

hw_ep = musb->bulk_ep;

drivers/usb/musb/musb_host.c

2073

head = &musb->in_bulk;

drivers/usb/musb/musb_host.c

2075

head = &musb->out_bulk;

drivers/usb/musb/musb_host.c

2089

dev_err(musb->controller,

drivers/usb/musb/musb_host.c

2098

hw_ep = musb->endpoints + best_end;

drivers/usb/musb/musb_host.c

2099

musb_dbg(musb, "qh %p periodic slot %d", qh, best_end);

drivers/usb/musb/musb_host.c

2109

musb_start_urb(musb, is_in, qh);

drivers/usb/musb/musb_host.c

2119

struct musb *musb = hcd_to_musb(hcd);

drivers/usb/musb/musb_host.c

2128

if (!is_host_active(musb) || !musb->is_active)

drivers/usb/musb/musb_host.c

2131

trace_musb_urb_enq(musb, urb);

drivers/usb/musb/musb_host.c

2133

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_host.c

2138

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_host.c

2159

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_host.c

216

musb->ep0_stage = MUSB_EP0_START;

drivers/usb/musb/musb_host.c

2161

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_host.c

2182

ok = (usb_pipein(urb->pipe) && musb->hb_iso_rx)

drivers/usb/musb/musb_host.c

2183

|| (usb_pipeout(urb->pipe) && musb->hb_iso_tx);

drivers/usb/musb/musb_host.c

2185

dev_err(musb->controller,

drivers/usb/musb/musb_host.c

2250

if (musb->is_multipoint) {

drivers/usb/musb/musb_host.c

2272

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_host.c

2281

ret = musb_schedule(musb, qh,

drivers/usb/musb/musb_host.c

2290

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_host.c

2294

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_host.c

2296

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_host.c

2311

struct musb *musb = ep->musb;

drivers/usb/musb/musb_host.c

2314

void __iomem *regs = ep->musb->mregs;

drivers/usb/musb/musb_host.c

232

trace_musb_urb_start(musb, urb);

drivers/usb/musb/musb_host.c

2325

status = ep->musb->dma_controller->channel_abort(dma);

drivers/usb/musb/musb_host.c

2326

musb_dbg(musb, "abort %cX%d DMA for urb %p --> %d",

drivers/usb/musb/musb_host.c

2340

musb_platform_clear_ep_rxintr(musb, ep->epnum);

drivers/usb/musb/musb_host.c

2359

musb_advance_schedule(ep->musb, urb, ep, is_in);

drivers/usb/musb/musb_host.c

236

musb_ep_program(musb, epnum, urb, !is_in, buf, offset, len);

drivers/usb/musb/musb_host.c

2365

struct musb *musb = hcd_to_musb(hcd);

drivers/usb/musb/musb_host.c

2371

trace_musb_urb_deq(musb, urb);

drivers/usb/musb/musb_host.c

2373

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_host.c

2400

musb_giveback(musb, urb, 0);

drivers/usb/musb/musb_host.c

2415

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_host.c

2425

struct musb *musb = hcd_to_musb(hcd);

drivers/usb/musb/musb_host.c

2429

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_host.c

2455

musb_advance_schedule(musb, urb, qh->hw_ep, is_in);

drivers/usb/musb/musb_host.c

246

musb_dbg(musb, "check whether there's still time for periodic Tx");

drivers/usb/musb/musb_host.c

2463

musb_giveback(musb, next_urb(qh), -ESHUTDOWN);

drivers/usb/musb/musb_host.c

2470

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_host.c

2475

struct musb *musb = hcd_to_musb(hcd);

drivers/usb/musb/musb_host.c

2477

return musb_readw(musb->mregs, MUSB_FRAME);

drivers/usb/musb/musb_host.c

2482

struct musb *musb = hcd_to_musb(hcd);

drivers/usb/musb/musb_host.c

2488

musb->port1_status = 0;

drivers/usb/musb/musb_host.c

2500

struct musb *musb = hcd_to_musb(hcd);

drivers/usb/musb/musb_host.c

2504

ret = musb_port_suspend(musb, true);

drivers/usb/musb/musb_host.c

2508

if (!is_host_active(musb))

drivers/usb/musb/musb_host.c

2511

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_host.c

2519

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/musb_host.c

2521

musb_set_state(musb, OTG_STATE_A_WAIT_BCON);

drivers/usb/musb/musb_host.c

2527

if (musb->is_active) {

drivers/usb/musb/musb_host.c

2529

musb_otg_state_string(musb));

drivers/usb/musb/musb_host.c

2537

struct musb *musb = hcd_to_musb(hcd);

drivers/usb/musb/musb_host.c

2539

if (musb->config &&

drivers/usb/musb/musb_host.c

2540

musb->config->host_port_deassert_reset_at_resume)

drivers/usb/musb/musb_host.c

2541

musb_port_reset(musb, false);

drivers/usb/musb/musb_host.c

259

musb_dbg(musb, "SOF for %d", epnum);

drivers/usb/musb/musb_host.c

2625

struct musb *musb = hcd_to_musb(hcd);

drivers/usb/musb/musb_host.c

2634

if (musb->hwvers < MUSB_HWVERS_1800)

drivers/usb/musb/musb_host.c

2650

struct musb *musb = hcd_to_musb(hcd);

drivers/usb/musb/musb_host.c

2655

if (musb->hwvers < MUSB_HWVERS_1800)

drivers/usb/musb/musb_host.c

2665

.hcd_priv_size = sizeof(struct musb *),

drivers/usb/musb/musb_host.c

267

musb_dbg(musb, "Start TX%d %s", epnum,

drivers/usb/musb/musb_host.c

2694

int musb_host_alloc(struct musb *musb)

drivers/usb/musb/musb_host.c

2696

struct device *dev = musb->controller;

drivers/usb/musb/musb_host.c

2699

musb->hcd = usb_create_hcd(&musb_hc_driver, dev, dev_name(dev));

drivers/usb/musb/musb_host.c

2700

if (!musb->hcd)

drivers/usb/musb/musb_host.c

2703

*musb->hcd->hcd_priv = (unsigned long) musb;

drivers/usb/musb/musb_host.c

2704

musb->hcd->self.uses_pio_for_control = 1;

drivers/usb/musb/musb_host.c

2705

musb->hcd->uses_new_polling = 1;

drivers/usb/musb/musb_host.c

2706

musb->hcd->has_tt = 1;

drivers/usb/musb/musb_host.c

2711

void musb_host_cleanup(struct musb *musb)

drivers/usb/musb/musb_host.c

2713

if (musb->port_mode == MUSB_PERIPHERAL)

drivers/usb/musb/musb_host.c

2715

usb_remove_hcd(musb->hcd);

drivers/usb/musb/musb_host.c

2718

void musb_host_free(struct musb *musb)

drivers/usb/musb/musb_host.c

272

else if (is_cppi_enabled(musb) || tusb_dma_omap(musb))

drivers/usb/musb/musb_host.c

2720

usb_put_hcd(musb->hcd);

drivers/usb/musb/musb_host.c

2723

int musb_host_setup(struct musb *musb, int power_budget)

drivers/usb/musb/musb_host.c

2726

struct usb_hcd *hcd = musb->hcd;

drivers/usb/musb/musb_host.c

2728

if (musb->port_mode == MUSB_HOST) {

drivers/usb/musb/musb_host.c

2729

MUSB_HST_MODE(musb);

drivers/usb/musb/musb_host.c

2730

musb_set_state(musb, OTG_STATE_A_IDLE);

drivers/usb/musb/musb_host.c

2733

if (musb->xceiv) {

drivers/usb/musb/musb_host.c

2734

otg_set_host(musb->xceiv->otg, &hcd->self);

drivers/usb/musb/musb_host.c

2735

musb->xceiv->otg->host = &hcd->self;

drivers/usb/musb/musb_host.c

2737

phy_set_mode(musb->phy, PHY_MODE_USB_HOST);

drivers/usb/musb/musb_host.c

2753

void musb_host_resume_root_hub(struct musb *musb)

drivers/usb/musb/musb_host.c

2755

usb_hcd_resume_root_hub(musb->hcd);

drivers/usb/musb/musb_host.c

2758

void musb_host_poke_root_hub(struct musb *musb)

drivers/usb/musb/musb_host.c

2760

MUSB_HST_MODE(musb);

drivers/usb/musb/musb_host.c

2761

if (musb->hcd->status_urb)

drivers/usb/musb/musb_host.c

2762

usb_hcd_poll_rh_status(musb->hcd);

drivers/usb/musb/musb_host.c

2764

usb_hcd_resume_root_hub(musb->hcd);

drivers/usb/musb/musb_host.c

278

static void musb_giveback(struct musb *musb, struct urb *urb, int status)

drivers/usb/musb/musb_host.c

279

__releases(musb->lock)

drivers/usb/musb/musb_host.c

280

__acquires(musb->lock)

drivers/usb/musb/musb_host.c

282

trace_musb_urb_gb(musb, urb);

drivers/usb/musb/musb_host.c

284

usb_hcd_unlink_urb_from_ep(musb->hcd, urb);

drivers/usb/musb/musb_host.c

285

spin_unlock(&musb->lock);

drivers/usb/musb/musb_host.c

286

usb_hcd_giveback_urb(musb->hcd, urb, status);

drivers/usb/musb/musb_host.c

287

spin_lock(&musb->lock);

drivers/usb/musb/musb_host.c

297

static void musb_advance_schedule(struct musb *musb, struct urb *urb,

drivers/usb/musb/musb_host.c

312

toggle = musb->io.get_toggle(qh, !is_in);

drivers/usb/musb/musb_host.c

322

musb_giveback(musb, urb, status);

drivers/usb/musb/musb_host.c

336

struct dma_controller *dma = musb->dma_controller;

drivers/usb/musb/musb_host.c

385

musb_dbg(musb, "... next ep%d %cX urb %p",

drivers/usb/musb/musb_host.c

387

musb_start_urb(musb, is_in, qh);

drivers/usb/musb/musb_host.c

414

musb_host_packet_rx(struct musb *musb, struct urb *urb, u8 epnum, u8 iso_err)

drivers/usb/musb/musb_host.c

422

struct musb_hw_ep *hw_ep = musb->endpoints + epnum;

drivers/usb/musb/musb_host.c

430

musb_dbg(musb, "RX%d count %d, buffer %p len %d/%d", epnum, rx_count,

drivers/usb/musb/musb_host.c

452

musb_dbg(musb, "OVERFLOW %d into %d", rx_count, length);

drivers/usb/musb/musb_host.c

470

musb_dbg(musb, "OVERFLOW %d into %d", rx_count, length);

drivers/usb/musb/musb_host.c

515

musb_rx_reinit(struct musb *musb, struct musb_qh *qh, u8 epnum)

drivers/usb/musb/musb_host.c

517

struct musb_hw_ep *ep = musb->endpoints + epnum;

drivers/usb/musb/musb_host.c

553

if (musb->is_multipoint) {

drivers/usb/musb/musb_host.c

554

musb_write_rxfunaddr(musb, epnum, qh->addr_reg);

drivers/usb/musb/musb_host.c

555

musb_write_rxhubaddr(musb, epnum, qh->h_addr_reg);

drivers/usb/musb/musb_host.c

556

musb_write_rxhubport(musb, epnum, qh->h_port_reg);

drivers/usb/musb/musb_host.c

558

musb_writeb(musb->mregs, MUSB_FADDR, qh->addr_reg);

drivers/usb/musb/musb_host.c

600

can_bulk_split(hw_ep->musb, qh->type)))

drivers/usb/musb/musb_host.c

634

if (musb_dma_inventra(hw_ep->musb) || musb_dma_ux500(hw_ep->musb))

drivers/usb/musb/musb_host.c

637

else if (is_cppi_enabled(hw_ep->musb) || tusb_dma_omap(hw_ep->musb))

drivers/usb/musb/musb_host.c

670

static void musb_ep_program(struct musb *musb, u8 epnum,

drivers/usb/musb/musb_host.c

677

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_host.c

678

struct musb_hw_ep *hw_ep = musb->endpoints + epnum;

drivers/usb/musb/musb_host.c

685

musb_dbg(musb, "%s hw%d urb %p spd%d dev%d ep%d%s "

drivers/usb/musb/musb_host.c

704

dma_controller = musb->dma_controller;

drivers/usb/musb/musb_host.c

729

int_txe = musb->intrtxe;

drivers/usb/musb/musb_host.c

74

struct musb *hcd_to_musb(struct usb_hcd *hcd)

drivers/usb/musb/musb_host.c

759

csr |= musb->io.set_toggle(qh, is_out, urb);

drivers/usb/musb/musb_host.c

76

return *(struct musb **) hcd->hcd_priv;

drivers/usb/musb/musb_host.c

772

if (musb->is_multipoint) {

drivers/usb/musb/musb_host.c

773

musb_write_txfunaddr(musb, epnum, qh->addr_reg);

drivers/usb/musb/musb_host.c

774

musb_write_txhubaddr(musb, epnum, qh->h_addr_reg);

drivers/usb/musb/musb_host.c

775

musb_write_txhubport(musb, epnum, qh->h_port_reg);

drivers/usb/musb/musb_host.c

783

if (can_bulk_split(musb, qh->type)) {

drivers/usb/musb/musb_host.c

796

if (musb->is_multipoint)

drivers/usb/musb/musb_host.c

80

static void musb_ep_program(struct musb *musb, u8 epnum,

drivers/usb/musb/musb_host.c

801

if (can_bulk_split(musb, qh->type))

drivers/usb/musb/musb_host.c

818

dev_err(musb->controller,

drivers/usb/musb/musb_host.c

843

musb_rx_reinit(musb, qh, epnum);

drivers/usb/musb/musb_host.c

844

csr |= musb->io.set_toggle(qh, is_out, urb);

drivers/usb/musb/musb_host.c

864

if ((is_cppi_enabled(musb) || tusb_dma_omap(musb)) && dma_channel) {

drivers/usb/musb/musb_host.c

89

struct musb *musb = ep->musb;

drivers/usb/musb/musb_host.c

890

musb_dbg(musb, "RXCSR%d := %04x", epnum, csr);

drivers/usb/musb/musb_host.c

899

static void musb_bulk_nak_timeout(struct musb *musb, struct musb_hw_ep *ep,

drivers/usb/musb/musb_host.c

904

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_host.c

926

cur_qh = first_qh(&musb->in_bulk);

drivers/usb/musb/musb_host.c

936

cur_qh = first_qh(&musb->out_bulk);

drivers/usb/musb/musb_host.c

942

musb->dma_controller->channel_abort(dma);

drivers/usb/musb/musb_host.c

946

toggle = musb->io.get_toggle(cur_qh, !is_in);

drivers/usb/musb/musb_host.c

951

list_move_tail(&cur_qh->ring, &musb->in_bulk);

drivers/usb/musb/musb_host.c

954

next_qh = first_qh(&musb->in_bulk);

drivers/usb/musb/musb_host.c

960

list_move_tail(&cur_qh->ring, &musb->out_bulk);

drivers/usb/musb/musb_host.c

963

next_qh = first_qh(&musb->out_bulk);

drivers/usb/musb/musb_host.c

970

musb_start_urb(musb, is_in, next_qh);

drivers/usb/musb/musb_host.c

978

static bool musb_h_ep0_continue(struct musb *musb, u16 len, struct urb *urb)

drivers/usb/musb/musb_host.c

983

struct musb_hw_ep *hw_ep = musb->control_ep;

drivers/usb/musb/musb_host.c

987

switch (musb->ep0_stage) {

drivers/usb/musb/musb_host.h

101

static inline void musb_port_reset(struct musb *musb, bool do_reset) {}

drivers/usb/musb/musb_host.h

55

extern struct musb *hcd_to_musb(struct usb_hcd *);

drivers/usb/musb/musb_host.h

56

extern irqreturn_t musb_h_ep0_irq(struct musb *);

drivers/usb/musb/musb_host.h

57

extern int musb_host_alloc(struct musb *);

drivers/usb/musb/musb_host.h

58

extern int musb_host_setup(struct musb *, int);

drivers/usb/musb/musb_host.h

59

extern void musb_host_cleanup(struct musb *);

drivers/usb/musb/musb_host.h

60

extern void musb_host_tx(struct musb *, u8);

drivers/usb/musb/musb_host.h

61

extern void musb_host_rx(struct musb *, u8);

drivers/usb/musb/musb_host.h

62

extern void musb_root_disconnect(struct musb *musb);

drivers/usb/musb/musb_host.h

63

extern void musb_host_free(struct musb *);

drivers/usb/musb/musb_host.h

64

extern void musb_host_resume_root_hub(struct musb *musb);

drivers/usb/musb/musb_host.h

65

extern void musb_host_poke_root_hub(struct musb *musb);

drivers/usb/musb/musb_host.h

66

extern int musb_port_suspend(struct musb *musb, bool do_suspend);

drivers/usb/musb/musb_host.h

67

extern void musb_port_reset(struct musb *musb, bool do_reset);

drivers/usb/musb/musb_host.h

70

static inline struct musb *hcd_to_musb(struct usb_hcd *hcd)

drivers/usb/musb/musb_host.h

75

static inline irqreturn_t musb_h_ep0_irq(struct musb *musb)

drivers/usb/musb/musb_host.h

80

static inline int musb_host_alloc(struct musb *musb)

drivers/usb/musb/musb_host.h

85

static inline int musb_host_setup(struct musb *musb, int power_budget)

drivers/usb/musb/musb_host.h

90

static inline void musb_host_cleanup(struct musb *musb) {}

drivers/usb/musb/musb_host.h

91

static inline void musb_host_free(struct musb *musb) {}

drivers/usb/musb/musb_host.h

92

static inline void musb_host_tx(struct musb *musb, u8 epnum) {}

drivers/usb/musb/musb_host.h

93

static inline void musb_host_rx(struct musb *musb, u8 epnum) {}

drivers/usb/musb/musb_host.h

94

static inline void musb_root_disconnect(struct musb *musb) {}

drivers/usb/musb/musb_host.h

95

static inline void musb_host_resume_root_hub(struct musb *musb) {}

drivers/usb/musb/musb_host.h

96

static inline void musb_host_poke_root_hub(struct musb *musb) {}

drivers/usb/musb/musb_host.h

97

static inline int musb_port_suspend(struct musb *musb, bool do_suspend)

drivers/usb/musb/musb_io.h

15

#define musb_ep_select(_mbase, _epnum) musb->io.ep_select((_mbase), (_epnum))

drivers/usb/musb/musb_regs.h

282

static inline void musb_write_rxfunaddr(struct musb *musb, u8 epnum,

drivers/usb/musb/musb_regs.h

285

musb_writeb(musb->mregs,

drivers/usb/musb/musb_regs.h

286

musb->io.busctl_offset(epnum, MUSB_RXFUNCADDR),

drivers/usb/musb/musb_regs.h

290

static inline void musb_write_rxhubaddr(struct musb *musb, u8 epnum,

drivers/usb/musb/musb_regs.h

293

musb_writeb(musb->mregs, musb->io.busctl_offset(epnum, MUSB_RXHUBADDR),

drivers/usb/musb/musb_regs.h

297

static inline void musb_write_rxhubport(struct musb *musb, u8 epnum,

drivers/usb/musb/musb_regs.h

300

musb_writeb(musb->mregs, musb->io.busctl_offset(epnum, MUSB_RXHUBPORT),

drivers/usb/musb/musb_regs.h

304

static inline void musb_write_txfunaddr(struct musb *musb, u8 epnum,

drivers/usb/musb/musb_regs.h

307

musb_writeb(musb->mregs,

drivers/usb/musb/musb_regs.h

308

musb->io.busctl_offset(epnum, MUSB_TXFUNCADDR),

drivers/usb/musb/musb_regs.h

312

static inline void musb_write_txhubaddr(struct musb *musb, u8 epnum,

drivers/usb/musb/musb_regs.h

315

musb_writeb(musb->mregs, musb->io.busctl_offset(epnum, MUSB_TXHUBADDR),

drivers/usb/musb/musb_regs.h

319

static inline void musb_write_txhubport(struct musb *musb, u8 epnum,

drivers/usb/musb/musb_regs.h

322

musb_writeb(musb->mregs, musb->io.busctl_offset(epnum, MUSB_TXHUBPORT),

drivers/usb/musb/musb_regs.h

326

static inline u8 musb_read_rxfunaddr(struct musb *musb, u8 epnum)

drivers/usb/musb/musb_regs.h

328

return musb_readb(musb->mregs,

drivers/usb/musb/musb_regs.h

329

musb->io.busctl_offset(epnum, MUSB_RXFUNCADDR));

drivers/usb/musb/musb_regs.h

332

static inline u8 musb_read_rxhubaddr(struct musb *musb, u8 epnum)

drivers/usb/musb/musb_regs.h

334

return musb_readb(musb->mregs,

drivers/usb/musb/musb_regs.h

335

musb->io.busctl_offset(epnum, MUSB_RXHUBADDR));

drivers/usb/musb/musb_regs.h

338

static inline u8 musb_read_rxhubport(struct musb *musb, u8 epnum)

drivers/usb/musb/musb_regs.h

340

return musb_readb(musb->mregs,

drivers/usb/musb/musb_regs.h

341

musb->io.busctl_offset(epnum, MUSB_RXHUBPORT));

drivers/usb/musb/musb_regs.h

344

static inline u8 musb_read_txfunaddr(struct musb *musb, u8 epnum)

drivers/usb/musb/musb_regs.h

346

return musb_readb(musb->mregs,

drivers/usb/musb/musb_regs.h

347

musb->io.busctl_offset(epnum, MUSB_TXFUNCADDR));

drivers/usb/musb/musb_regs.h

350

static inline u8 musb_read_txhubaddr(struct musb *musb, u8 epnum)

drivers/usb/musb/musb_regs.h

352

return musb_readb(musb->mregs,

drivers/usb/musb/musb_regs.h

353

musb->io.busctl_offset(epnum, MUSB_TXHUBADDR));

drivers/usb/musb/musb_regs.h

356

static inline u8 musb_read_txhubport(struct musb *musb, u8 epnum)

drivers/usb/musb/musb_regs.h

358

return musb_readb(musb->mregs,

drivers/usb/musb/musb_regs.h

359

musb->io.busctl_offset(epnum, MUSB_TXHUBPORT));

drivers/usb/musb/musb_trace.c

13

void musb_dbg(struct musb *musb, const char *fmt, ...)

drivers/usb/musb/musb_trace.c

22

trace_musb_log(musb, &vaf);

drivers/usb/musb/musb_trace.h

11

#define TRACE_SYSTEM musb

drivers/usb/musb/musb_trace.h

154

TP_PROTO(struct musb *musb),

drivers/usb/musb/musb_trace.h

155

TP_ARGS(musb),

drivers/usb/musb/musb_trace.h

157

__string(name, dev_name(musb->controller))

drivers/usb/musb/musb_trace.h

164

__entry->int_usb = musb->int_usb;

drivers/usb/musb/musb_trace.h

165

__entry->int_tx = musb->int_tx;

drivers/usb/musb/musb_trace.h

166

__entry->int_rx = musb->int_rx;

drivers/usb/musb/musb_trace.h

175

TP_PROTO(struct musb *musb, struct urb *urb),

drivers/usb/musb/musb_trace.h

176

TP_ARGS(musb, urb),

drivers/usb/musb/musb_trace.h

178

__string(name, dev_name(musb->controller))

drivers/usb/musb/musb_trace.h

207

TP_PROTO(struct musb *musb, struct urb *urb),

drivers/usb/musb/musb_trace.h

208

TP_ARGS(musb, urb)

drivers/usb/musb/musb_trace.h

212

TP_PROTO(struct musb *musb, struct urb *urb),

drivers/usb/musb/musb_trace.h

213

TP_ARGS(musb, urb)

drivers/usb/musb/musb_trace.h

217

TP_PROTO(struct musb *musb, struct urb *urb),

drivers/usb/musb/musb_trace.h

218

TP_ARGS(musb, urb)

drivers/usb/musb/musb_trace.h

222

TP_PROTO(struct musb *musb, struct urb *urb),

drivers/usb/musb/musb_trace.h

223

TP_ARGS(musb, urb)

drivers/usb/musb/musb_trace.h

227

TP_PROTO(struct musb *musb, struct urb *urb),

drivers/usb/musb/musb_trace.h

228

TP_ARGS(musb, urb)

drivers/usb/musb/musb_trace.h

232

TP_PROTO(struct musb *musb, struct urb *urb),

drivers/usb/musb/musb_trace.h

233

TP_ARGS(musb, urb)

drivers/usb/musb/musb_trace.h

27

TP_PROTO(struct musb *musb, struct va_format *vaf),

drivers/usb/musb/musb_trace.h

28

TP_ARGS(musb, vaf),

drivers/usb/musb/musb_trace.h

30

__string(name, dev_name(musb->controller))

drivers/usb/musb/musb_trace.h

318

__string(name, dev_name(ch->hw_ep->musb->controller))

drivers/usb/musb/musb_trace.h

41

TP_PROTO(struct musb *musb, u8 devctl, const char *desc),

drivers/usb/musb/musb_trace.h

42

TP_ARGS(musb, devctl, desc),

drivers/usb/musb/musb_trace.h

44

__string(name, dev_name(musb->controller))

drivers/usb/musb/musb_virthub.c

100

musb->is_active = musb->xceiv &&

drivers/usb/musb/musb_virthub.c

101

musb->xceiv->otg->host->b_hnp_enable;

drivers/usb/musb/musb_virthub.c

102

musb_platform_try_idle(musb, 0);

drivers/usb/musb/musb_virthub.c

105

musb_dbg(musb, "bogus rh suspend? %s",

drivers/usb/musb/musb_virthub.c

106

musb_otg_state_string(musb));

drivers/usb/musb/musb_virthub.c

113

musb_dbg(musb, "Root port resuming, power %02x", power);

drivers/usb/musb/musb_virthub.c

115

musb->port1_status |= MUSB_PORT_STAT_RESUME;

drivers/usb/musb/musb_virthub.c

116

schedule_delayed_work(&musb->finish_resume_work,

drivers/usb/musb/musb_virthub.c

122

void musb_port_reset(struct musb *musb, bool do_reset)

drivers/usb/musb/musb_virthub.c

125

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_virthub.c

127

if (musb_get_state(musb) == OTG_STATE_B_IDLE) {

drivers/usb/musb/musb_virthub.c

128

musb_dbg(musb, "HNP: Returning from HNP; no hub reset from b_idle");

drivers/usb/musb/musb_virthub.c

129

musb->port1_status &= ~USB_PORT_STAT_RESET;

drivers/usb/musb/musb_virthub.c

133

if (!is_host_active(musb))

drivers/usb/musb/musb_virthub.c

149

long remain = (unsigned long) musb->rh_timer - jiffies;

drivers/usb/musb/musb_virthub.c

151

if (musb->rh_timer > 0 && remain > 0) {

drivers/usb/musb/musb_virthub.c

154

&musb->deassert_reset_work, remain);

drivers/usb/musb/musb_virthub.c

162

schedule_delayed_work(&musb->deassert_reset_work,

drivers/usb/musb/musb_virthub.c

171

musb->port1_status |= USB_PORT_STAT_RESET;

drivers/usb/musb/musb_virthub.c

172

musb->port1_status &= ~USB_PORT_STAT_ENABLE;

drivers/usb/musb/musb_virthub.c

173

schedule_delayed_work(&musb->deassert_reset_work,

drivers/usb/musb/musb_virthub.c

176

musb_dbg(musb, "root port reset stopped");

drivers/usb/musb/musb_virthub.c

177

musb_platform_pre_root_reset_end(musb);

drivers/usb/musb/musb_virthub.c

180

musb_platform_post_root_reset_end(musb);

drivers/usb/musb/musb_virthub.c

184

musb_dbg(musb, "high-speed device connected");

drivers/usb/musb/musb_virthub.c

185

musb->port1_status |= USB_PORT_STAT_HIGH_SPEED;

drivers/usb/musb/musb_virthub.c

188

musb->port1_status &= ~USB_PORT_STAT_RESET;

drivers/usb/musb/musb_virthub.c

189

musb->port1_status |= USB_PORT_STAT_ENABLE

drivers/usb/musb/musb_virthub.c

192

usb_hcd_poll_rh_status(musb->hcd);

drivers/usb/musb/musb_virthub.c

194

musb->vbuserr_retry = VBUSERR_RETRY_COUNT;

drivers/usb/musb/musb_virthub.c

198

void musb_root_disconnect(struct musb *musb)

drivers/usb/musb/musb_virthub.c

200

musb->port1_status = USB_PORT_STAT_POWER

drivers/usb/musb/musb_virthub.c

203

usb_hcd_poll_rh_status(musb->hcd);

drivers/usb/musb/musb_virthub.c

204

musb->is_active = 0;

drivers/usb/musb/musb_virthub.c

206

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_virthub.c

208

if (musb->xceiv && musb->xceiv->otg->host->b_hnp_enable) {

drivers/usb/musb/musb_virthub.c

209

musb_set_state(musb, OTG_STATE_A_PERIPHERAL);

drivers/usb/musb/musb_virthub.c

210

musb->g.is_a_peripheral = 1;

drivers/usb/musb/musb_virthub.c

215

musb_set_state(musb, OTG_STATE_A_WAIT_BCON);

drivers/usb/musb/musb_virthub.c

216

musb->is_active = 0;

drivers/usb/musb/musb_virthub.c

219

musb_set_state(musb, OTG_STATE_B_IDLE);

drivers/usb/musb/musb_virthub.c

222

musb_dbg(musb, "host disconnect (%s)",

drivers/usb/musb/musb_virthub.c

223

musb_otg_state_string(musb));

drivers/usb/musb/musb_virthub.c

23

struct musb *musb;

drivers/usb/musb/musb_virthub.c

234

struct musb *musb = hcd_to_musb(hcd);

drivers/usb/musb/musb_virthub.c

238

if (musb->port1_status & 0xffff0000) {

drivers/usb/musb/musb_virthub.c

245

static int musb_has_gadget(struct musb *musb)

drivers/usb/musb/musb_virthub.c

256

return musb->port_mode == MUSB_HOST;

drivers/usb/musb/musb_virthub.c

268

struct musb *musb = hcd_to_musb(hcd);

drivers/usb/musb/musb_virthub.c

27

musb = container_of(work, struct musb, finish_resume_work.work);

drivers/usb/musb/musb_virthub.c

274

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_virthub.c

277

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_virthub.c

29

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musb_virthub.c

304

musb_port_suspend(musb, false);

drivers/usb/musb/musb_virthub.c

308

musb_platform_set_vbus(musb, 0);

drivers/usb/musb/musb_virthub.c

31

power = musb_readb(musb->mregs, MUSB_POWER);

drivers/usb/musb/musb_virthub.c

319

musb_dbg(musb, "clear feature %d", wValue);

drivers/usb/musb/musb_virthub.c

320

musb->port1_status &= ~(1 << wValue);

drivers/usb/musb/musb_virthub.c

33

musb_dbg(musb, "root port resume stopped, power %02x", power);

drivers/usb/musb/musb_virthub.c

34

musb_writeb(musb->mregs, MUSB_POWER, power);

drivers/usb/musb/musb_virthub.c

349

put_unaligned(cpu_to_le32(musb->port1_status

drivers/usb/musb/musb_virthub.c

354

musb_dbg(musb, "port status %08x", musb->port1_status);

drivers/usb/musb/musb_virthub.c

372

if (!hcd->self.is_b_host && musb_has_gadget(musb))

drivers/usb/musb/musb_virthub.c

376

musb_port_reset(musb, true);

drivers/usb/musb/musb_virthub.c

379

musb_port_suspend(musb, true);

drivers/usb/musb/musb_virthub.c

382

if (unlikely(is_host_active(musb)))

drivers/usb/musb/musb_virthub.c

402

musb_load_testpacket(musb);

drivers/usb/musb/musb_virthub.c

409

musb_writeb(musb->mregs, MUSB_DEVCTL,

drivers/usb/musb/musb_virthub.c

41

musb->is_active = 1;

drivers/usb/musb/musb_virthub.c

419

musb_writeb(musb->mregs, MUSB_TESTMODE, temp);

drivers/usb/musb/musb_virthub.c

42

musb->port1_status &= ~(USB_PORT_STAT_SUSPEND | MUSB_PORT_STAT_RESUME);

drivers/usb/musb/musb_virthub.c

424

musb_dbg(musb, "set feature %d", wValue);

drivers/usb/musb/musb_virthub.c

425

musb->port1_status |= 1 << wValue;

drivers/usb/musb/musb_virthub.c

43

musb->port1_status |= USB_PORT_STAT_C_SUSPEND << 16;

drivers/usb/musb/musb_virthub.c

433

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_virthub.c

436

musb_start(musb);

drivers/usb/musb/musb_virthub.c

44

usb_hcd_poll_rh_status(musb->hcd);

drivers/usb/musb/musb_virthub.c

46

musb_set_state(musb, OTG_STATE_A_HOST);

drivers/usb/musb/musb_virthub.c

48

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musb_virthub.c

51

int musb_port_suspend(struct musb *musb, bool do_suspend)

drivers/usb/musb/musb_virthub.c

54

void __iomem *mbase = musb->mregs;

drivers/usb/musb/musb_virthub.c

56

if (!is_host_active(musb))

drivers/usb/musb/musb_virthub.c

84

musb_dbg(musb, "Root port suspended, power %02x", power);

drivers/usb/musb/musb_virthub.c

86

musb->port1_status |= USB_PORT_STAT_SUSPEND;

drivers/usb/musb/musb_virthub.c

87

switch (musb_get_state(musb)) {

drivers/usb/musb/musb_virthub.c

89

musb_set_state(musb, OTG_STATE_A_SUSPEND);

drivers/usb/musb/musb_virthub.c

90

musb->is_active = musb->xceiv &&

drivers/usb/musb/musb_virthub.c

91

musb->xceiv->otg->host->b_hnp_enable;

drivers/usb/musb/musb_virthub.c

92

if (musb->is_active)

drivers/usb/musb/musb_virthub.c

93

mod_timer(&musb->otg_timer, jiffies

drivers/usb/musb/musb_virthub.c

96

musb_platform_try_idle(musb, 0);

drivers/usb/musb/musb_virthub.c

99

musb_set_state(musb, OTG_STATE_B_WAIT_ACON);

drivers/usb/musb/musbhsdma.c

149

struct musb *musb = controller->private_data;

drivers/usb/musb/musbhsdma.c

154

musb_dbg(musb, "%p, pkt_sz %d, addr %pad, len %d, mode %d",

drivers/usb/musb/musbhsdma.c

187

struct musb *musb = controller->private_data;

drivers/usb/musb/musbhsdma.c

189

musb_dbg(musb, "ep%d-%s pkt_sz %d, dma_addr %pad length %d, mode %d",

drivers/usb/musb/musbhsdma.c

206

if ((musb->hwvers >= MUSB_HWVERS_1800) && (dma_addr % 4))

drivers/usb/musb/musbhsdma.c

224

struct musb *musb = musb_channel->controller->private_data;

drivers/usb/musb/musbhsdma.c

232

offset = musb->io.ep_offset(musb_channel->epnum,

drivers/usb/musb/musbhsdma.c

245

offset = musb->io.ep_offset(musb_channel->epnum,

drivers/usb/musb/musbhsdma.c

269

struct musb *musb = controller->private_data;

drivers/usb/musb/musbhsdma.c

285

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/musbhsdma.c

290

musb_dbg(musb, "spurious DMA irq");

drivers/usb/musb/musbhsdma.c

304

musb_dbg(musb, "int_hsdma = 0x%x", int_hsdma);

drivers/usb/musb/musbhsdma.c

329

musb_dbg(musb, "ch %p, 0x%x -> 0x%x (%zu / %d) %s",

drivers/usb/musb/musbhsdma.c

345

int offset = musb->io.ep_offset(epnum,

drivers/usb/musb/musbhsdma.c

366

musb_dma_completion(musb, musb_channel->epnum,

drivers/usb/musb/musbhsdma.c

374

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/musbhsdma.c

394

dma_controller_alloc(struct musb *musb, void __iomem *base)

drivers/usb/musb/musbhsdma.c

403

controller->private_data = musb;

drivers/usb/musb/musbhsdma.c

414

musbhs_dma_controller_create(struct musb *musb, void __iomem *base)

drivers/usb/musb/musbhsdma.c

417

struct device *dev = musb->controller;

drivers/usb/musb/musbhsdma.c

426

controller = dma_controller_alloc(musb, base);

drivers/usb/musb/musbhsdma.c

431

dev_name(musb->controller), controller)) {

drivers/usb/musb/musbhsdma.c

445

musbhs_dma_controller_create_noirq(struct musb *musb, void __iomem *base)

drivers/usb/musb/musbhsdma.c

449

controller = dma_controller_alloc(musb, base);

drivers/usb/musb/musbhsdma.c

78

struct musb *musb = controller->private_data;

drivers/usb/musb/musbhsdma.c

83

dev_err(musb->controller,

drivers/usb/musb/omap2430.c

100

musb_readb(musb->mregs, MUSB_DEVCTL));

drivers/usb/musb/omap2430.c

104

dev_dbg(musb->controller, "ID GND\n");

drivers/usb/musb/omap2430.c

105

switch (musb->xceiv->otg->state) {

drivers/usb/musb/omap2430.c

107

error = musb_set_host(musb);

drivers/usb/musb/omap2430.c

110

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;

drivers/usb/musb/omap2430.c

119

otg_set_vbus(musb->xceiv->otg, 1);

drivers/usb/musb/omap2430.c

122

musb->xceiv->otg->state = OTG_STATE_A_IDLE;

drivers/usb/musb/omap2430.c

123

musb->xceiv->last_event = USB_EVENT_ID;

drivers/usb/musb/omap2430.c

124

if (musb->gadget_driver) {

drivers/usb/musb/omap2430.c

127

otg_set_vbus(musb->xceiv->otg, 1);

drivers/usb/musb/omap2430.c

134

dev_dbg(musb->controller, "VBUS Connect\n");

drivers/usb/musb/omap2430.c

136

musb->xceiv->otg->state = OTG_STATE_B_IDLE;

drivers/usb/musb/omap2430.c

137

musb->xceiv->last_event = USB_EVENT_VBUS;

drivers/usb/musb/omap2430.c

143

dev_dbg(musb->controller, "VBUS Disconnect\n");

drivers/usb/musb/omap2430.c

145

musb->xceiv->last_event = USB_EVENT_NONE;

drivers/usb/musb/omap2430.c

146

musb_set_peripheral(musb);

drivers/usb/musb/omap2430.c

147

otg_set_vbus(musb->xceiv->otg, 0);

drivers/usb/musb/omap2430.c

152

dev_dbg(musb->controller, "ID float\n");

drivers/usb/musb/omap2430.c

154

pm_runtime_put_autosuspend(musb->controller);

drivers/usb/musb/omap2430.c

155

atomic_notifier_call_chain(&musb->xceiv->notifier,

drivers/usb/musb/omap2430.c

156

musb->xceiv->last_event, NULL);

drivers/usb/musb/omap2430.c

172

struct musb *musb = __hci;

drivers/usb/musb/omap2430.c

174

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/omap2430.c

176

musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);

drivers/usb/musb/omap2430.c

177

musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);

drivers/usb/musb/omap2430.c

178

musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);

drivers/usb/musb/omap2430.c

180

if (musb->int_usb || musb->int_tx || musb->int_rx)

drivers/usb/musb/omap2430.c

181

retval = musb_interrupt(musb);

drivers/usb/musb/omap2430.c

183

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/omap2430.c

188

static int omap2430_musb_init(struct musb *musb)

drivers/usb/musb/omap2430.c

192

struct device *dev = musb->controller;

drivers/usb/musb/omap2430.c

200

musb->phy = devm_phy_get(dev->parent, "usb2-phy");

drivers/usb/musb/omap2430.c

208

musb->xceiv = devm_usb_get_phy_by_phandle(dev->parent, "usb-phy", 0);

drivers/usb/musb/omap2430.c

210

if (IS_ERR(musb->xceiv)) {

drivers/usb/musb/omap2430.c

211

status = PTR_ERR(musb->xceiv);

drivers/usb/musb/omap2430.c

220

if (IS_ERR(musb->phy)) {

drivers/usb/musb/omap2430.c

222

return PTR_ERR(musb->phy);

drivers/usb/musb/omap2430.c

224

musb->isr = omap2430_musb_interrupt;

drivers/usb/musb/omap2430.c

225

phy_init(musb->phy);

drivers/usb/musb/omap2430.c

226

phy_power_on(musb->phy);

drivers/usb/musb/omap2430.c

228

l = musb_readl(musb->mregs, OTG_INTERFSEL);

drivers/usb/musb/omap2430.c

238

musb_writel(musb->mregs, OTG_INTERFSEL, l);

drivers/usb/musb/omap2430.c

242

musb_readl(musb->mregs, OTG_REVISION),

drivers/usb/musb/omap2430.c

243

musb_readl(musb->mregs, OTG_SYSCONFIG),

drivers/usb/musb/omap2430.c

244

musb_readl(musb->mregs, OTG_SYSSTATUS),

drivers/usb/musb/omap2430.c

245

musb_readl(musb->mregs, OTG_INTERFSEL),

drivers/usb/musb/omap2430.c

246

musb_readl(musb->mregs, OTG_SIMENABLE));

drivers/usb/musb/omap2430.c

251

static void omap2430_musb_enable(struct musb *musb)

drivers/usb/musb/omap2430.c

253

struct device *dev = musb->controller;

drivers/usb/musb/omap2430.c

261

static void omap2430_musb_disable(struct musb *musb)

drivers/usb/musb/omap2430.c

263

struct device *dev = musb->controller;

drivers/usb/musb/omap2430.c

271

static int omap2430_musb_exit(struct musb *musb)

drivers/usb/musb/omap2430.c

273

struct device *dev = musb->controller;

drivers/usb/musb/omap2430.c

276

omap2430_low_level_exit(musb);

drivers/usb/musb/omap2430.c

277

phy_power_off(musb->phy);

drivers/usb/musb/omap2430.c

278

phy_exit(musb->phy);

drivers/usb/musb/omap2430.c

279

musb->phy = NULL;

drivers/usb/musb/omap2430.c

306

struct platform_device *musb;

drivers/usb/musb/omap2430.c

322

musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);

drivers/usb/musb/omap2430.c

323

if (!musb)

drivers/usb/musb/omap2430.c

326

musb->dev.parent = &pdev->dev;

drivers/usb/musb/omap2430.c

327

musb->dev.dma_mask = &omap2430_dmamask;

drivers/usb/musb/omap2430.c

328

musb->dev.coherent_dma_mask = omap2430_dmamask;

drivers/usb/musb/omap2430.c

33

struct platform_device *musb;

drivers/usb/musb/omap2430.c

338

device_set_of_node_from_dev(&musb->dev, &pdev->dev);

drivers/usb/musb/omap2430.c

343

glue->musb = musb;

drivers/usb/musb/omap2430.c

397

ret = platform_device_add_resources(musb, pdev->resource, pdev->num_resources);

drivers/usb/musb/omap2430.c

41

#define glue_to_musb(g) platform_get_drvdata(g->musb)

drivers/usb/musb/omap2430.c

438

ret = platform_device_add_resources(musb, musb_res, i);

drivers/usb/musb/omap2430.c

445

ret = platform_device_add_data(musb, pdata, sizeof(*pdata));

drivers/usb/musb/omap2430.c

45

static inline void omap2430_low_level_exit(struct musb *musb)

drivers/usb/musb/omap2430.c

453

ret = platform_device_add(musb);

drivers/usb/musb/omap2430.c

467

platform_device_put(musb);

drivers/usb/musb/omap2430.c

476

platform_device_unregister(glue->musb);

drivers/usb/musb/omap2430.c

487

struct musb *musb = glue_to_musb(glue);

drivers/usb/musb/omap2430.c

489

if (!musb)

drivers/usb/musb/omap2430.c

492

musb->context.otg_interfsel = musb_readl(musb->mregs,

drivers/usb/musb/omap2430.c

495

omap2430_low_level_exit(musb);

drivers/usb/musb/omap2430.c

498

phy_power_off(musb->phy);

drivers/usb/musb/omap2430.c

499

phy_exit(musb->phy);

drivers/usb/musb/omap2430.c

50

l = musb_readl(musb->mregs, OTG_FORCESTDBY);

drivers/usb/musb/omap2430.c

510

struct musb *musb = glue_to_musb(glue);

drivers/usb/musb/omap2430.c

512

if (!musb)

drivers/usb/musb/omap2430.c

516

phy_init(musb->phy);

drivers/usb/musb/omap2430.c

517

phy_power_on(musb->phy);

drivers/usb/musb/omap2430.c

52

musb_writel(musb->mregs, OTG_FORCESTDBY, l);

drivers/usb/musb/omap2430.c

520

omap2430_low_level_init(musb);

drivers/usb/musb/omap2430.c

521

musb_writel(musb->mregs, OTG_INTERFSEL,

drivers/usb/musb/omap2430.c

522

musb->context.otg_interfsel);

drivers/usb/musb/omap2430.c

536

struct musb *musb = glue_to_musb(glue);

drivers/usb/musb/omap2430.c

538

phy_power_off(musb->phy);

drivers/usb/musb/omap2430.c

539

phy_exit(musb->phy);

drivers/usb/musb/omap2430.c

55

static inline void omap2430_low_level_init(struct musb *musb)

drivers/usb/musb/omap2430.c

573

struct musb *musb = glue_to_musb(glue);

drivers/usb/musb/omap2430.c

575

phy_init(musb->phy);

drivers/usb/musb/omap2430.c

576

phy_power_on(musb->phy);

drivers/usb/musb/omap2430.c

59

l = musb_readl(musb->mregs, OTG_FORCESTDBY);

drivers/usb/musb/omap2430.c

61

musb_writel(musb->mregs, OTG_FORCESTDBY, l);

drivers/usb/musb/omap2430.c

93

struct musb *musb = glue_to_musb(glue);

drivers/usb/musb/omap2430.c

96

pm_runtime_get_sync(musb->controller);

drivers/usb/musb/omap2430.c

98

dev_dbg(musb->controller, "VBUS %s, devctl %02x\n",

drivers/usb/musb/omap2430.c

99

usb_otg_state_string(musb->xceiv->otg->state),

drivers/usb/musb/sunxi.c

106

struct musb *musb = glue->musb;

drivers/usb/musb/sunxi.c

110

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/sunxi.c

112

devctl = readb(musb->mregs + SUNXI_MUSB_DEVCTL);

drivers/usb/musb/sunxi.c

115

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;

drivers/usb/musb/sunxi.c

116

MUSB_HST_MODE(musb);

drivers/usb/musb/sunxi.c

120

musb->xceiv->otg->state = OTG_STATE_B_IDLE;

drivers/usb/musb/sunxi.c

121

MUSB_DEV_MODE(musb);

drivers/usb/musb/sunxi.c

124

writeb(devctl, musb->mregs + SUNXI_MUSB_DEVCTL);

drivers/usb/musb/sunxi.c

126

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/sunxi.c

146

static void sunxi_musb_set_vbus(struct musb *musb, int is_on)

drivers/usb/musb/sunxi.c

148

struct sunxi_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/sunxi.c

152

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;

drivers/usb/musb/sunxi.c

160

static void sunxi_musb_pre_root_reset_end(struct musb *musb)

drivers/usb/musb/sunxi.c

162

struct sunxi_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/sunxi.c

167

static void sunxi_musb_post_root_reset_end(struct musb *musb)

drivers/usb/musb/sunxi.c

169

struct sunxi_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/sunxi.c

176

struct musb *musb = __hci;

drivers/usb/musb/sunxi.c

179

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/sunxi.c

181

musb->int_usb = readb(musb->mregs + SUNXI_MUSB_INTRUSB);

drivers/usb/musb/sunxi.c

182

if (musb->int_usb)

drivers/usb/musb/sunxi.c

183

writeb(musb->int_usb, musb->mregs + SUNXI_MUSB_INTRUSB);

drivers/usb/musb/sunxi.c

185

if ((musb->int_usb & MUSB_INTR_RESET) && !is_host_active(musb)) {

drivers/usb/musb/sunxi.c

187

musb_ep_select(musb->mregs, 0);

drivers/usb/musb/sunxi.c

188

musb_writeb(musb->mregs, MUSB_FADDR, 0);

drivers/usb/musb/sunxi.c

191

musb->int_tx = readw(musb->mregs + SUNXI_MUSB_INTRTX);

drivers/usb/musb/sunxi.c

192

if (musb->int_tx)

drivers/usb/musb/sunxi.c

193

writew(musb->int_tx, musb->mregs + SUNXI_MUSB_INTRTX);

drivers/usb/musb/sunxi.c

195

musb->int_rx = readw(musb->mregs + SUNXI_MUSB_INTRRX);

drivers/usb/musb/sunxi.c

196

if (musb->int_rx)

drivers/usb/musb/sunxi.c

197

writew(musb->int_rx, musb->mregs + SUNXI_MUSB_INTRRX);

drivers/usb/musb/sunxi.c

199

musb_interrupt(musb);

drivers/usb/musb/sunxi.c

201

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/sunxi.c

222

static int sunxi_musb_init(struct musb *musb)

drivers/usb/musb/sunxi.c

224

struct sunxi_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/sunxi.c

227

sunxi_musb = musb;

drivers/usb/musb/sunxi.c

228

musb->phy = glue->phy;

drivers/usb/musb/sunxi.c

229

musb->xceiv = glue->xceiv;

drivers/usb/musb/sunxi.c

232

ret = sunxi_sram_claim(musb->controller->parent);

drivers/usb/musb/sunxi.c

247

writeb(SUNXI_MUSB_VEND0_PIO_MODE, musb->mregs + SUNXI_MUSB_VEND0);

drivers/usb/musb/sunxi.c

259

musb->isr = sunxi_musb_interrupt;

drivers/usb/musb/sunxi.c

262

pm_runtime_get(musb->controller);

drivers/usb/musb/sunxi.c

273

sunxi_sram_release(musb->controller->parent);

drivers/usb/musb/sunxi.c

277

static int sunxi_musb_exit(struct musb *musb)

drivers/usb/musb/sunxi.c

279

struct sunxi_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/sunxi.c

281

pm_runtime_put(musb->controller);

drivers/usb/musb/sunxi.c

294

sunxi_sram_release(musb->controller->parent);

drivers/usb/musb/sunxi.c

299

static void sunxi_musb_enable(struct musb *musb)

drivers/usb/musb/sunxi.c

301

struct sunxi_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/sunxi.c

303

glue->musb = musb;

drivers/usb/musb/sunxi.c

312

static void sunxi_musb_disable(struct musb *musb)

drivers/usb/musb/sunxi.c

314

struct sunxi_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/sunxi.c

320

sunxi_musb_dma_controller_create(struct musb *musb, void __iomem *base)

drivers/usb/musb/sunxi.c

329

static int sunxi_musb_set_mode(struct musb *musb, u8 mode)

drivers/usb/musb/sunxi.c

331

struct sunxi_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/sunxi.c

345

dev_err(musb->controller->parent,

drivers/usb/musb/sunxi.c

353

if (musb->port_mode != MUSB_OTG) {

drivers/usb/musb/sunxi.c

354

dev_err(musb->controller->parent,

drivers/usb/musb/sunxi.c

359

if (musb->port1_status & USB_PORT_STAT_ENABLE)

drivers/usb/musb/sunxi.c

360

musb_root_disconnect(musb);

drivers/usb/musb/sunxi.c

373

static int sunxi_musb_recover(struct musb *musb)

drivers/usb/musb/sunxi.c

375

struct sunxi_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/sunxi.c

78

static struct musb *sunxi_musb;

drivers/usb/musb/sunxi.c

82

struct musb *musb;

drivers/usb/musb/tusb6010.c

1000

static void tusb_setup_cpu_interface(struct musb *musb)

drivers/usb/musb/tusb6010.c

1002

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

101

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

1027

static int tusb_musb_start(struct musb *musb)

drivers/usb/musb/tusb6010.c

1029

struct tusb6010_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/tusb6010.c

1030

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

1050

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/tusb6010.c

1058

musb->tusb_revision = tusb_get_revision(musb);

drivers/usb/musb/tusb6010.c

1059

tusb_print_revision(musb);

drivers/usb/musb/tusb6010.c

1060

if (musb->tusb_revision < 2) {

drivers/usb/musb/tusb6010.c

1062

musb->tusb_revision);

drivers/usb/musb/tusb6010.c

1071

tusb_set_clock_source(musb, 1);

drivers/usb/musb/tusb6010.c

1082

tusb_setup_cpu_interface(musb);

drivers/usb/musb/tusb6010.c

1093

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/tusb6010.c

1098

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/tusb6010.c

1106

static int tusb_musb_init(struct musb *musb)

drivers/usb/musb/tusb6010.c

1113

musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);

drivers/usb/musb/tusb6010.c

1114

if (IS_ERR_OR_NULL(musb->xceiv))

drivers/usb/musb/tusb6010.c

1117

pdev = to_platform_device(musb->controller);

drivers/usb/musb/tusb6010.c

1126

musb->async = mem->start;

drivers/usb/musb/tusb6010.c

1135

musb->sync = mem->start;

drivers/usb/musb/tusb6010.c

114

dev_dbg(musb->controller, "Enabled tusb wbus quirk ctrl %08x ena %08x\n",

drivers/usb/musb/tusb6010.c

1143

musb->sync_va = sync;

drivers/usb/musb/tusb6010.c

1148

musb->mregs += TUSB_BASE_OFFSET;

drivers/usb/musb/tusb6010.c

1150

ret = tusb_musb_start(musb);

drivers/usb/musb/tusb6010.c

1156

musb->isr = tusb_musb_interrupt;

drivers/usb/musb/tusb6010.c

1158

musb->xceiv->set_power = tusb_draw_power;

drivers/usb/musb/tusb6010.c

1159

the_musb = musb;

drivers/usb/musb/tusb6010.c

1161

timer_setup(&musb->dev_timer, musb_do_idle, 0);

drivers/usb/musb/tusb6010.c

1168

usb_put_phy(musb->xceiv);

drivers/usb/musb/tusb6010.c

1173

static int tusb_musb_exit(struct musb *musb)

drivers/usb/musb/tusb6010.c

1175

struct tusb6010_glue *glue = dev_get_drvdata(musb->controller->parent);

drivers/usb/musb/tusb6010.c

1177

timer_delete_sync(&musb->dev_timer);

drivers/usb/musb/tusb6010.c

1183

iounmap(musb->sync_va);

drivers/usb/musb/tusb6010.c

1185

usb_put_phy(musb->xceiv);

drivers/usb/musb/tusb6010.c

1226

struct platform_device *musb;

drivers/usb/musb/tusb6010.c

123

dev_dbg(musb->controller, "Disabled tusb wbus quirk ctrl %08x ena %08x\n",

drivers/usb/musb/tusb6010.c

1273

glue->musb = musb = platform_device_register_full(&pinfo);

drivers/usb/musb/tusb6010.c

1274

if (IS_ERR(musb)) {

drivers/usb/musb/tusb6010.c

1275

ret = PTR_ERR(musb);

drivers/usb/musb/tusb6010.c

1287

platform_device_unregister(glue->musb);

drivers/usb/musb/tusb6010.c

227

struct musb *musb = hw_ep->musb;

drivers/usb/musb/tusb6010.c

234

dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",

drivers/usb/musb/tusb6010.c

277

struct musb *musb = hw_ep->musb;

drivers/usb/musb/tusb6010.c

282

dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",

drivers/usb/musb/tusb6010.c

322

static struct musb *the_musb;

drivers/usb/musb/tusb6010.c

332

struct musb *musb = the_musb;

drivers/usb/musb/tusb6010.c

333

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

34

struct platform_device *musb;

drivers/usb/musb/tusb6010.c

346

if (x->otg->default_a || mA < (musb->min_power << 1))

drivers/usb/musb/tusb6010.c

351

musb->is_bus_powered = 1;

drivers/usb/musb/tusb6010.c

354

musb->is_bus_powered = 0;

drivers/usb/musb/tusb6010.c

359

dev_dbg(musb->controller, "draw max %d mA VBUS\n", mA);

drivers/usb/musb/tusb6010.c

367

static void tusb_set_clock_source(struct musb *musb, unsigned mode)

drivers/usb/musb/tusb6010.c

369

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

394

static void tusb_allow_idle(struct musb *musb, u32 wakeup_enables)

drivers/usb/musb/tusb6010.c

396

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

40

static void tusb_musb_set_vbus(struct musb *musb, int is_on);

drivers/usb/musb/tusb6010.c

400

&& (musb->tusb_revision == TUSB_REV_30))

drivers/usb/musb/tusb6010.c

401

tusb_wbus_quirk(musb, 1);

drivers/usb/musb/tusb6010.c

403

tusb_set_clock_source(musb, 0);

drivers/usb/musb/tusb6010.c

415

if (is_host_active(musb)) {

drivers/usb/musb/tusb6010.c

425

dev_dbg(musb->controller, "idle, wake on %02x\n", wakeup_enables);

drivers/usb/musb/tusb6010.c

431

static int tusb_musb_vbus_status(struct musb *musb)

drivers/usb/musb/tusb6010.c

433

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

460

struct musb *musb = timer_container_of(musb, t, dev_timer);

drivers/usb/musb/tusb6010.c

463

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/tusb6010.c

465

switch (musb->xceiv->otg->state) {

drivers/usb/musb/tusb6010.c

467

if ((musb->a_wait_bcon != 0)

drivers/usb/musb/tusb6010.c

468

&& (musb->idle_timeout == 0

drivers/usb/musb/tusb6010.c

469

|| time_after(jiffies, musb->idle_timeout))) {

drivers/usb/musb/tusb6010.c

470

dev_dbg(musb->controller, "Nothing connected %s, turning off VBUS\n",

drivers/usb/musb/tusb6010.c

471

usb_otg_state_string(musb->xceiv->otg->state));

drivers/usb/musb/tusb6010.c

475

tusb_musb_set_vbus(musb, 0);

drivers/usb/musb/tusb6010.c

481

if (!musb->is_active) {

drivers/usb/musb/tusb6010.c

485

if (is_host_active(musb) && (musb->port1_status >> 16))

drivers/usb/musb/tusb6010.c

488

if (!musb->gadget_driver) {

drivers/usb/musb/tusb6010.c

49

static u8 tusb_get_revision(struct musb *musb)

drivers/usb/musb/tusb6010.c

496

tusb_allow_idle(musb, wakeups);

drivers/usb/musb/tusb6010.c

499

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/tusb6010.c

51

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

515

static void tusb_musb_try_idle(struct musb *musb, unsigned long timeout)

drivers/usb/musb/tusb6010.c

524

if (musb->is_active || ((musb->a_wait_bcon == 0)

drivers/usb/musb/tusb6010.c

525

&& (musb->xceiv->otg->state == OTG_STATE_A_WAIT_BCON))) {

drivers/usb/musb/tusb6010.c

526

dev_dbg(musb->controller, "%s active, deleting timer\n",

drivers/usb/musb/tusb6010.c

527

usb_otg_state_string(musb->xceiv->otg->state));

drivers/usb/musb/tusb6010.c

528

timer_delete(&musb->dev_timer);

drivers/usb/musb/tusb6010.c

534

if (!timer_pending(&musb->dev_timer))

drivers/usb/musb/tusb6010.c

537

dev_dbg(musb->controller, "Longer idle timer already pending, ignoring\n");

drivers/usb/musb/tusb6010.c

543

dev_dbg(musb->controller, "%s inactive, for idle timer for %lu ms\n",

drivers/usb/musb/tusb6010.c

544

usb_otg_state_string(musb->xceiv->otg->state),

drivers/usb/musb/tusb6010.c

546

mod_timer(&musb->dev_timer, timeout);

drivers/usb/musb/tusb6010.c

556

static void tusb_musb_set_vbus(struct musb *musb, int is_on)

drivers/usb/musb/tusb6010.c

558

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

561

struct usb_otg *otg = musb->xceiv->otg;

drivers/usb/musb/tusb6010.c

570

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/tusb6010.c

575

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;

drivers/usb/musb/tusb6010.c

579

MUSB_HST_MODE(musb);

drivers/usb/musb/tusb6010.c

588

switch (musb->xceiv->otg->state) {

drivers/usb/musb/tusb6010.c

591

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL;

drivers/usb/musb/tusb6010.c

594

musb->xceiv->otg->state = OTG_STATE_A_IDLE;

drivers/usb/musb/tusb6010.c

597

musb->xceiv->otg->state = OTG_STATE_A_IDLE;

drivers/usb/musb/tusb6010.c

599

musb->is_active = 0;

drivers/usb/musb/tusb6010.c

601

MUSB_HST_MODE(musb);

drivers/usb/musb/tusb6010.c

603

musb->is_active = 0;

drivers/usb/musb/tusb6010.c

605

musb->xceiv->otg->state = OTG_STATE_B_IDLE;

drivers/usb/musb/tusb6010.c

606

MUSB_DEV_MODE(musb);

drivers/usb/musb/tusb6010.c

617

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/tusb6010.c

619

dev_dbg(musb->controller, "VBUS %s, devctl %02x otg %3x conf %08x prcm %08x\n",

drivers/usb/musb/tusb6010.c

620

usb_otg_state_string(musb->xceiv->otg->state),

drivers/usb/musb/tusb6010.c

621

musb_readb(musb->mregs, MUSB_DEVCTL),

drivers/usb/musb/tusb6010.c

633

static int tusb_musb_set_mode(struct musb *musb, u8 musb_mode)

drivers/usb/musb/tusb6010.c

635

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

66

static void tusb_print_revision(struct musb *musb)

drivers/usb/musb/tusb6010.c

663

dev_dbg(musb->controller, "Trying to set mode %i\n", musb_mode);

drivers/usb/musb/tusb6010.c

68

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

683

tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)

drivers/usb/musb/tusb6010.c

687

struct usb_otg *otg = musb->xceiv->otg;

drivers/usb/musb/tusb6010.c

694

dev_dbg(musb->controller, "Default-%c\n", default_a ? 'A' : 'B');

drivers/usb/musb/tusb6010.c

696

tusb_musb_set_vbus(musb, default_a);

drivers/usb/musb/tusb6010.c

709

musb->port1_status &=

drivers/usb/musb/tusb6010.c

71

rev = musb->tusb_revision;

drivers/usb/musb/tusb6010.c

718

dev_dbg(musb->controller, "Forcing disconnect (no interrupt)\n");

drivers/usb/musb/tusb6010.c

719

if (musb->xceiv->otg->state != OTG_STATE_B_IDLE) {

drivers/usb/musb/tusb6010.c

721

musb->xceiv->otg->state = OTG_STATE_B_IDLE;

drivers/usb/musb/tusb6010.c

722

musb->int_usb |= MUSB_INTR_DISCONNECT;

drivers/usb/musb/tusb6010.c

724

musb->is_active = 0;

drivers/usb/musb/tusb6010.c

726

dev_dbg(musb->controller, "vbus change, %s, otg %03x\n",

drivers/usb/musb/tusb6010.c

727

usb_otg_state_string(musb->xceiv->otg->state), otg_stat);

drivers/usb/musb/tusb6010.c

729

schedule_delayed_work(&musb->irq_work, 0);

drivers/usb/musb/tusb6010.c

732

dev_dbg(musb->controller, "vbus change, %s, otg %03x\n",

drivers/usb/musb/tusb6010.c

733

usb_otg_state_string(musb->xceiv->otg->state), otg_stat);

drivers/usb/musb/tusb6010.c

735

switch (musb->xceiv->otg->state) {

drivers/usb/musb/tusb6010.c

737

dev_dbg(musb->controller, "Got SRP, turning on VBUS\n");

drivers/usb/musb/tusb6010.c

738

musb_platform_set_vbus(musb, 1);

drivers/usb/musb/tusb6010.c

741

if (musb->a_wait_bcon != 0)

drivers/usb/musb/tusb6010.c

742

musb->is_active = 0;

drivers/usb/musb/tusb6010.c

744

musb->is_active = 1;

drivers/usb/musb/tusb6010.c

762

if (musb->vbuserr_retry) {

drivers/usb/musb/tusb6010.c

763

musb->vbuserr_retry--;

drivers/usb/musb/tusb6010.c

764

tusb_musb_set_vbus(musb, 1);

drivers/usb/musb/tusb6010.c

766

musb->vbuserr_retry

drivers/usb/musb/tusb6010.c

768

tusb_musb_set_vbus(musb, 0);

drivers/usb/musb/tusb6010.c

781

dev_dbg(musb->controller, "%s timer, %03x\n",

drivers/usb/musb/tusb6010.c

782

usb_otg_state_string(musb->xceiv->otg->state), otg_stat);

drivers/usb/musb/tusb6010.c

784

switch (musb->xceiv->otg->state) {

drivers/usb/musb/tusb6010.c

789

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/tusb6010.c

793

dev_dbg(musb->controller, "devctl %02x\n", devctl);

drivers/usb/musb/tusb6010.c

796

musb->xceiv->otg->state = OTG_STATE_A_WAIT_BCON;

drivers/usb/musb/tusb6010.c

797

musb->is_active = 0;

drivers/usb/musb/tusb6010.c

799

+ msecs_to_jiffies(musb->a_wait_bcon);

drivers/usb/musb/tusb6010.c

803

tusb_musb_set_vbus(musb, 0);

drivers/usb/musb/tusb6010.c

807

if (musb->a_wait_bcon != 0)

drivers/usb/musb/tusb6010.c

809

+ msecs_to_jiffies(musb->a_wait_bcon);

drivers/usb/musb/tusb6010.c

819

schedule_delayed_work(&musb->irq_work, 0);

drivers/usb/musb/tusb6010.c

826

struct musb *musb = __hci;

drivers/usb/musb/tusb6010.c

827

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

831

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/tusb6010.c

838

dev_dbg(musb->controller, "TUSB IRQ %08x\n", int_src);

drivers/usb/musb/tusb6010.c

840

musb->int_usb = (u8) int_src;

drivers/usb/musb/tusb6010.c

847

if (musb->tusb_revision == TUSB_REV_30)

drivers/usb/musb/tusb6010.c

848

tusb_wbus_quirk(musb, 0);

drivers/usb/musb/tusb6010.c

859

dev_dbg(musb->controller, "TUSB NOR not ready\n");

drivers/usb/musb/tusb6010.c

863

tusb_set_clock_source(musb, 1);

drivers/usb/musb/tusb6010.c

868

musb->is_active = 1;

drivers/usb/musb/tusb6010.c

869

schedule_delayed_work(&musb->irq_work, 0);

drivers/usb/musb/tusb6010.c

871

dev_dbg(musb->controller, "wake %sactive %02x\n",

drivers/usb/musb/tusb6010.c

872

musb->is_active ? "" : "in", reg);

drivers/usb/musb/tusb6010.c

878

timer_delete(&musb->dev_timer);

drivers/usb/musb/tusb6010.c

884

idle_timeout = tusb_otg_ints(musb, int_src, tbase);

drivers/usb/musb/tusb6010.c

893

dev_dbg(musb->controller, "DMA IRQ %08x\n", dma_src);

drivers/usb/musb/tusb6010.c

902

musb->int_rx = (((musb_src >> 16) & 0xffff) << 1);

drivers/usb/musb/tusb6010.c

903

musb->int_tx = (musb_src & 0xffff);

drivers/usb/musb/tusb6010.c

905

musb->int_rx = 0;

drivers/usb/musb/tusb6010.c

906

musb->int_tx = 0;

drivers/usb/musb/tusb6010.c

910

musb_interrupt(musb);

drivers/usb/musb/tusb6010.c

916

tusb_musb_try_idle(musb, idle_timeout);

drivers/usb/musb/tusb6010.c

919

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/tusb6010.c

931

static void tusb_musb_enable(struct musb *musb)

drivers/usb/musb/tusb6010.c

933

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

957

irq_set_irq_type(musb->nIrq, IRQ_TYPE_LEVEL_LOW);

drivers/usb/musb/tusb6010.c

975

static void tusb_musb_disable(struct musb *musb)

drivers/usb/musb/tusb6010.c

977

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010.c

987

timer_delete(&musb->dev_timer);

drivers/usb/musb/tusb6010.c

99

static void tusb_wbus_quirk(struct musb *musb, int enabled)

drivers/usb/musb/tusb6010_omap.c

102

struct musb *musb = chdat->musb;

drivers/usb/musb/tusb6010_omap.c

103

struct device *dev = musb->controller;

drivers/usb/musb/tusb6010_omap.c

106

void __iomem *mbase = musb->mregs;

drivers/usb/musb/tusb6010_omap.c

109

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/tusb6010_omap.c

111

dev_dbg(musb->controller, "ep%i %s dma callback\n",

drivers/usb/musb/tusb6010_omap.c

123

dev_dbg(musb->controller, "Corrupt %s XFR_SIZE: 0x%08lx\n",

drivers/usb/musb/tusb6010_omap.c

131

dev_dbg(musb->controller, "DMA remaining %lu/%u\n", remaining, chdat->transfer_len);

drivers/usb/musb/tusb6010_omap.c

137

dev_dbg(musb->controller, "Using PIO for remaining %lu bytes\n", pio);

drivers/usb/musb/tusb6010_omap.c

158

musb_dma_completion(musb, chdat->epnum, chdat->tx);

drivers/usb/musb/tusb6010_omap.c

169

dev_dbg(musb->controller, "terminating short tx packet\n");

drivers/usb/musb/tusb6010_omap.c

178

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/tusb6010_omap.c

186

struct musb *musb = chdat->musb;

drivers/usb/musb/tusb6010_omap.c

187

struct device *dev = musb->controller;

drivers/usb/musb/tusb6010_omap.c

189

void __iomem *mbase = musb->mregs;

drivers/usb/musb/tusb6010_omap.c

226

dev_dbg(musb->controller, "Busy %s dma, not using: %08x\n",

drivers/usb/musb/tusb6010_omap.c

241

dev_dbg(musb->controller, "could not get dma for ep%i\n", chdat->epnum);

drivers/usb/musb/tusb6010_omap.c

285

dev_dbg(musb->controller,

drivers/usb/musb/tusb6010_omap.c

299

dev_err(musb->controller, "DMA slave config failed: %d\n", ret);

drivers/usb/musb/tusb6010_omap.c

30

struct musb *musb;

drivers/usb/musb/tusb6010_omap.c

307

dev_err(musb->controller, "DMA prep_slave_single failed\n");

drivers/usb/musb/tusb6010_omap.c

315

dev_dbg(musb->controller,

drivers/usb/musb/tusb6010_omap.c

428

struct musb *musb;

drivers/usb/musb/tusb6010_omap.c

434

musb = tusb_dma->controller.musb;

drivers/usb/musb/tusb6010_omap.c

438

dev_dbg(musb->controller, "Not allowing DMA for ep0 %s\n", tx ? "tx" : "rx");

drivers/usb/musb/tusb6010_omap.c

455

chdat->musb = tusb_dma->controller.musb;

drivers/usb/musb/tusb6010_omap.c

482

dev_dbg(musb->controller, "ep%i %s dma: %s dmareq%i\n",

drivers/usb/musb/tusb6010_omap.c

493

dev_dbg(musb->controller, "ep%i: Could not get a DMA channel\n", chdat->epnum);

drivers/usb/musb/tusb6010_omap.c

502

struct musb *musb = chdat->musb;

drivers/usb/musb/tusb6010_omap.c

504

dev_dbg(musb->controller, "Release for ep%i\n", chdat->epnum);

drivers/usb/musb/tusb6010_omap.c

538

struct musb *musb = tusb_dma->controller.musb;

drivers/usb/musb/tusb6010_omap.c

554

dma_data->chan = dma_request_chan(musb->controller,

drivers/usb/musb/tusb6010_omap.c

557

dev_err(musb->controller,

drivers/usb/musb/tusb6010_omap.c

583

tusb_dma_controller_create(struct musb *musb, void __iomem *base)

drivers/usb/musb/tusb6010_omap.c

585

void __iomem *tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010_omap.c

591

musb_writel(musb->ctrl_base, TUSB_DMA_INT_MASK, 0x7fffffff);

drivers/usb/musb/tusb6010_omap.c

592

musb_writel(musb->ctrl_base, TUSB_DMA_EP_MAP, 0);

drivers/usb/musb/tusb6010_omap.c

603

tusb_dma->controller.musb = musb;

drivers/usb/musb/tusb6010_omap.c

604

tusb_dma->tbase = musb->ctrl_base;

drivers/usb/musb/tusb6010_omap.c

611

if (musb->tusb_revision >= TUSB_REV_30)

drivers/usb/musb/tusb6010_omap.c

66

dev_dbg(chdat->musb->controller, "ep%i dmareq0 is busy for ep%i\n",

drivers/usb/musb/ux500.c

100

event, usb_otg_state_string(musb->xceiv->otg->state));

drivers/usb/musb/ux500.c

104

dev_dbg(musb->controller, "ID GND\n");

drivers/usb/musb/ux500.c

105

ux500_musb_set_vbus(musb, 1);

drivers/usb/musb/ux500.c

108

dev_dbg(musb->controller, "VBUS Connect\n");

drivers/usb/musb/ux500.c

111

dev_dbg(musb->controller, "VBUS Disconnect\n");

drivers/usb/musb/ux500.c

112

if (is_host_active(musb))

drivers/usb/musb/ux500.c

113

ux500_musb_set_vbus(musb, 0);

drivers/usb/musb/ux500.c

115

musb->xceiv->otg->state = OTG_STATE_B_IDLE;

drivers/usb/musb/ux500.c

118

dev_dbg(musb->controller, "ID float\n");

drivers/usb/musb/ux500.c

128

struct musb *musb = __hci;

drivers/usb/musb/ux500.c

130

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/ux500.c

132

musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);

drivers/usb/musb/ux500.c

133

musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);

drivers/usb/musb/ux500.c

134

musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);

drivers/usb/musb/ux500.c

136

if (musb->int_usb || musb->int_tx || musb->int_rx)

drivers/usb/musb/ux500.c

137

retval = musb_interrupt(musb);

drivers/usb/musb/ux500.c

139

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/ux500.c

144

static int ux500_musb_init(struct musb *musb)

drivers/usb/musb/ux500.c

148

musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);

drivers/usb/musb/ux500.c

149

if (IS_ERR_OR_NULL(musb->xceiv)) {

drivers/usb/musb/ux500.c

154

musb->nb.notifier_call = musb_otg_notifications;

drivers/usb/musb/ux500.c

155

status = usb_register_notifier(musb->xceiv, &musb->nb);

drivers/usb/musb/ux500.c

157

dev_dbg(musb->controller, "notification register failed\n");

drivers/usb/musb/ux500.c

161

musb->isr = ux500_musb_interrupt;

drivers/usb/musb/ux500.c

166

static int ux500_musb_exit(struct musb *musb)

drivers/usb/musb/ux500.c

168

usb_unregister_notifier(musb->xceiv, &musb->nb);

drivers/usb/musb/ux500.c

170

usb_put_phy(musb->xceiv);

drivers/usb/musb/ux500.c

221

struct platform_device *musb;

drivers/usb/musb/ux500.c

243

musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);

drivers/usb/musb/ux500.c

244

if (!musb) {

drivers/usb/musb/ux500.c

262

musb->dev.parent = &pdev->dev;

drivers/usb/musb/ux500.c

263

musb->dev.dma_mask = &pdev->dev.coherent_dma_mask;

drivers/usb/musb/ux500.c

264

musb->dev.coherent_dma_mask = pdev->dev.coherent_dma_mask;

drivers/usb/musb/ux500.c

265

device_set_of_node_from_dev(&musb->dev, &pdev->dev);

drivers/usb/musb/ux500.c

268

glue->musb = musb;

drivers/usb/musb/ux500.c

276

ret = platform_device_add_resources(musb, pdev->resource, pdev->num_resources);

drivers/usb/musb/ux500.c

282

ret = platform_device_add_data(musb, pdata, sizeof(*pdata));

drivers/usb/musb/ux500.c

288

ret = platform_device_add(musb);

drivers/usb/musb/ux500.c

29

struct platform_device *musb;

drivers/usb/musb/ux500.c

300

platform_device_put(musb);

drivers/usb/musb/ux500.c

310

platform_device_unregister(glue->musb);

drivers/usb/musb/ux500.c

318

struct musb *musb = glue_to_musb(glue);

drivers/usb/musb/ux500.c

32

#define glue_to_musb(g) platform_get_drvdata(g->musb)

drivers/usb/musb/ux500.c

320

if (musb)

drivers/usb/musb/ux500.c

321

usb_phy_set_suspend(musb->xceiv, 1);

drivers/usb/musb/ux500.c

331

struct musb *musb = glue_to_musb(glue);

drivers/usb/musb/ux500.c

34

static void ux500_musb_set_vbus(struct musb *musb, int is_on)

drivers/usb/musb/ux500.c

340

if (musb)

drivers/usb/musb/ux500.c

341

usb_phy_set_suspend(musb->xceiv, 0);

drivers/usb/musb/ux500.c

43

devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

drivers/usb/musb/ux500.c

46

if (musb->xceiv->otg->state == OTG_STATE_A_IDLE) {

drivers/usb/musb/ux500.c

49

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/ux500.c

54

while (musb_readb(musb->mregs, MUSB_DEVCTL) & 0x80) {

drivers/usb/musb/ux500.c

57

dev_err(musb->controller,

drivers/usb/musb/ux500.c

64

musb->is_active = 1;

drivers/usb/musb/ux500.c

65

musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;

drivers/usb/musb/ux500.c

67

MUSB_HST_MODE(musb);

drivers/usb/musb/ux500.c

70

musb->is_active = 0;

drivers/usb/musb/ux500.c

76

MUSB_DEV_MODE(musb);

drivers/usb/musb/ux500.c

78

musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

drivers/usb/musb/ux500.c

89

dev_dbg(musb->controller, "VBUS %s, devctl %02x\n",

drivers/usb/musb/ux500.c

90

usb_otg_state_string(musb->xceiv->otg->state),

drivers/usb/musb/ux500.c

91

musb_readb(musb->mregs, MUSB_DEVCTL));

drivers/usb/musb/ux500.c

97

struct musb *musb = container_of(nb, struct musb, nb);

drivers/usb/musb/ux500.c

99

dev_dbg(musb->controller, "musb_otg_notifications %ld %s\n",

drivers/usb/musb/ux500_dma.c

134

struct musb *musb = controller->private_data;

drivers/usb/musb/ux500_dma.c

157

dev_dbg(musb->controller, "hw_ep=%d, is_tx=0x%x, channel=%d\n",

drivers/usb/musb/ux500_dma.c

166

struct musb *musb = ux500_channel->controller->private_data;

drivers/usb/musb/ux500_dma.c

168

dev_dbg(musb->controller, "channel=%d\n", ux500_channel->ch_num);

drivers/usb/musb/ux500_dma.c

211

struct musb *musb = controller->private_data;

drivers/usb/musb/ux500_dma.c

212

void __iomem *epio = musb->endpoints[ux500_channel->hw_ep->epnum].regs;

drivers/usb/musb/ux500_dma.c

215

dev_dbg(musb->controller, "channel=%d, is_tx=%d\n",

drivers/usb/musb/ux500_dma.c

269

struct musb *musb = controller->private_data;

drivers/usb/musb/ux500_dma.c

270

struct device *dev = musb->controller;

drivers/usb/musb/ux500_dma.c

284

dev_err(musb->controller, "No platform data\n");

drivers/usb/musb/ux500_dma.c

358

ux500_dma_controller_create(struct musb *musb, void __iomem *base)

drivers/usb/musb/ux500_dma.c

361

struct platform_device *pdev = to_platform_device(musb->controller);

drivers/usb/musb/ux500_dma.c

369

controller->private_data = musb;

drivers/usb/musb/ux500_dma.c

374

dev_err(musb->controller, "no memory resource defined\n");

drivers/usb/musb/ux500_dma.c

56

struct musb *musb = hw_ep->musb;

drivers/usb/musb/ux500_dma.c

59

dev_dbg(musb->controller, "DMA rx transfer done on hw_ep=%d\n",

drivers/usb/musb/ux500_dma.c

62

spin_lock_irqsave(&musb->lock, flags);

drivers/usb/musb/ux500_dma.c

65

musb_dma_completion(musb, hw_ep->epnum, ux500_channel->is_tx);

drivers/usb/musb/ux500_dma.c

66

spin_unlock_irqrestore(&musb->lock, flags);

drivers/usb/musb/ux500_dma.c

82

struct musb *musb = ux500_channel->controller->private_data;

drivers/usb/musb/ux500_dma.c

83

dma_addr_t usb_fifo_addr = (musb->io.fifo_offset(hw_ep->epnum) +

drivers/usb/musb/ux500_dma.c

86

dev_dbg(musb->controller,