arch/mips/include/asm/mach-loongson2ef/cs5536/cs5536_vsm.h

26

DECLARE_CS5536_MODULE(ohci)

drivers/firewire/init_ohci1394_dma.c

104

static inline void __init init_ohci1394_initialize(struct ohci *ohci)

drivers/firewire/init_ohci1394_dma.c

110

bus_options = reg_read(ohci, OHCI1394_BusOptions);

drivers/firewire/init_ohci1394_dma.c

114

reg_write(ohci, OHCI1394_BusOptions, bus_options);

drivers/firewire/init_ohci1394_dma.c

117

reg_write(ohci, OHCI1394_NodeID, 0x0000ffc0);

drivers/firewire/init_ohci1394_dma.c

120

reg_write(ohci, OHCI1394_HCControlSet,

drivers/firewire/init_ohci1394_dma.c

124

reg_write(ohci, OHCI1394_LinkControlClear, 0xffffffff);

drivers/firewire/init_ohci1394_dma.c

127

reg_write(ohci, OHCI1394_LinkControlSet,

drivers/firewire/init_ohci1394_dma.c

131

reg_write(ohci, OHCI1394_LinkControlClear, 0x00000400);

drivers/firewire/init_ohci1394_dma.c

134

reg_write(ohci, OHCI1394_IsoRecvIntMaskClear, 0xffffffff);

drivers/firewire/init_ohci1394_dma.c

135

reg_write(ohci, OHCI1394_IsoRecvIntEventClear, 0xffffffff);

drivers/firewire/init_ohci1394_dma.c

136

reg_write(ohci, OHCI1394_IsoXmitIntMaskClear, 0xffffffff);

drivers/firewire/init_ohci1394_dma.c

137

reg_write(ohci, OHCI1394_IsoXmitIntEventClear, 0xffffffff);

drivers/firewire/init_ohci1394_dma.c

140

reg_write(ohci, OHCI1394_AsReqFilterHiSet, 0x80000000);

drivers/firewire/init_ohci1394_dma.c

143

reg_write(ohci, OHCI1394_ATRetries,

drivers/firewire/init_ohci1394_dma.c

149

reg_write(ohci, OHCI1394_HCControlClear,

drivers/firewire/init_ohci1394_dma.c

153

reg_write(ohci, OHCI1394_HCControlSet, OHCI1394_HCControl_linkEnable);

drivers/firewire/init_ohci1394_dma.c

156

num_ports = get_phy_reg(ohci, 2) & 0xf;

drivers/firewire/init_ohci1394_dma.c

160

set_phy_reg(ohci, 7, i);

drivers/firewire/init_ohci1394_dma.c

161

status = get_phy_reg(ohci, 8);

drivers/firewire/init_ohci1394_dma.c

164

set_phy_reg(ohci, 8, status & ~1);

drivers/firewire/init_ohci1394_dma.c

178

static inline void __init init_ohci1394_wait_for_busresets(struct ohci *ohci)

drivers/firewire/init_ohci1394_dma.c

184

events = reg_read(ohci, OHCI1394_IntEventSet);

drivers/firewire/init_ohci1394_dma.c

186

reg_write(ohci, OHCI1394_IntEventClear,

drivers/firewire/init_ohci1394_dma.c

198

static inline void __init init_ohci1394_enable_physical_dma(struct ohci *ohci)

drivers/firewire/init_ohci1394_dma.c

200

reg_write(ohci, OHCI1394_PhyReqFilterHiSet, 0xffffffff);

drivers/firewire/init_ohci1394_dma.c

201

reg_write(ohci, OHCI1394_PhyReqFilterLoSet, 0xffffffff);

drivers/firewire/init_ohci1394_dma.c

202

reg_write(ohci, OHCI1394_PhyUpperBound, 0xffff0000);

drivers/firewire/init_ohci1394_dma.c

211

static inline void __init init_ohci1394_reset_and_init_dma(struct ohci *ohci)

drivers/firewire/init_ohci1394_dma.c

214

init_ohci1394_soft_reset(ohci);

drivers/firewire/init_ohci1394_dma.c

217

reg_write(ohci, OHCI1394_HCControlSet, OHCI1394_HCControl_LPS);

drivers/firewire/init_ohci1394_dma.c

220

reg_write(ohci, OHCI1394_IntEventClear, 0xffffffff);

drivers/firewire/init_ohci1394_dma.c

221

reg_write(ohci, OHCI1394_IntMaskClear, 0xffffffff);

drivers/firewire/init_ohci1394_dma.c

225

init_ohci1394_initialize(ohci);

drivers/firewire/init_ohci1394_dma.c

230

init_ohci1394_wait_for_busresets(ohci);

drivers/firewire/init_ohci1394_dma.c

233

init_ohci1394_enable_physical_dma(ohci);

drivers/firewire/init_ohci1394_dma.c

247

struct ohci ohci;

drivers/firewire/init_ohci1394_dma.c

257

ohci.registers = (void __iomem *)fix_to_virt(FIX_OHCI1394_BASE);

drivers/firewire/init_ohci1394_dma.c

259

init_ohci1394_reset_and_init_dma(&ohci);

drivers/firewire/init_ohci1394_dma.c

40

static inline void reg_write(const struct ohci *ohci, int offset, u32 data)

drivers/firewire/init_ohci1394_dma.c

42

writel(data, ohci->registers + offset);

drivers/firewire/init_ohci1394_dma.c

45

static inline u32 reg_read(const struct ohci *ohci, int offset)

drivers/firewire/init_ohci1394_dma.c

47

return readl(ohci->registers + offset);

drivers/firewire/init_ohci1394_dma.c

53

static inline u8 __init get_phy_reg(struct ohci *ohci, u8 addr)

drivers/firewire/init_ohci1394_dma.c

58

reg_write(ohci, OHCI1394_PhyControl, (addr << 8) | 0x00008000);

drivers/firewire/init_ohci1394_dma.c

61

if (reg_read(ohci, OHCI1394_PhyControl) & 0x80000000)

drivers/firewire/init_ohci1394_dma.c

65

r = reg_read(ohci, OHCI1394_PhyControl);

drivers/firewire/init_ohci1394_dma.c

71

static inline void __init set_phy_reg(struct ohci *ohci, u8 addr, u8 data)

drivers/firewire/init_ohci1394_dma.c

75

reg_write(ohci, OHCI1394_PhyControl, (addr << 8) | data | 0x00004000);

drivers/firewire/init_ohci1394_dma.c

78

if (!(reg_read(ohci, OHCI1394_PhyControl) & 0x00004000))

drivers/firewire/init_ohci1394_dma.c

85

static inline void __init init_ohci1394_soft_reset(struct ohci *ohci)

drivers/firewire/init_ohci1394_dma.c

89

reg_write(ohci, OHCI1394_HCControlSet, OHCI1394_HCControl_softReset);

drivers/firewire/init_ohci1394_dma.c

92

if (!(reg_read(ohci, OHCI1394_HCControlSet)

drivers/firewire/ohci.c

1018

desc = dmam_alloc_coherent(ctx->ohci->card.device, PAGE_SIZE, &bus_addr, GFP_ATOMIC);

drivers/firewire/ohci.c

1039

static int context_init(struct context *ctx, struct fw_ohci *ohci,

drivers/firewire/ohci.c

1042

ctx->ohci = ohci;

drivers/firewire/ohci.c

1073

struct fw_card *card = &ctx->ohci->card;

drivers/firewire/ohci.c

1116

struct fw_ohci *ohci = ctx->ohci;

drivers/firewire/ohci.c

1118

reg_write(ohci, COMMAND_PTR(ctx->regs),

drivers/firewire/ohci.c

1120

reg_write(ohci, CONTROL_CLEAR(ctx->regs), ~0);

drivers/firewire/ohci.c

1121

reg_write(ohci, CONTROL_SET(ctx->regs), CONTEXT_RUN | extra);

drivers/firewire/ohci.c

1123

flush_writes(ohci);

drivers/firewire/ohci.c

1151

if (unlikely(ctx->ohci->quirks & QUIRK_IR_WAKE) &&

drivers/firewire/ohci.c

1164

struct fw_ohci *ohci = ctx->ohci;

drivers/firewire/ohci.c

1168

reg_write(ohci, CONTROL_CLEAR(ctx->regs), CONTEXT_RUN);

drivers/firewire/ohci.c

1172

reg = reg_read(ohci, CONTROL_SET(ctx->regs));

drivers/firewire/ohci.c

1179

ohci_err(ohci, "DMA context still active (0x%08x)\n", reg);

drivers/firewire/ohci.c

1195

struct fw_ohci *ohci = context->ohci;

drivers/firewire/ohci.c

1232

if (ctx == &ohci->at_response_ctx) {

drivers/firewire/ohci.c

127

struct fw_ohci *ohci;

drivers/firewire/ohci.c

1283

payload_bus = dma_map_single(ohci->card.device,

drivers/firewire/ohci.c

1287

if (dma_mapping_error(ohci->card.device, payload_bus)) {

drivers/firewire/ohci.c

1313

if (ohci->generation != packet->generation) {

drivers/firewire/ohci.c

1315

dma_unmap_single(ohci->card.device, payload_bus,

drivers/firewire/ohci.c

1324

reg_write(ohci, CONTROL_SET(context->regs), CONTEXT_WAKE);

drivers/firewire/ohci.c

1359

struct fw_ohci *ohci = ctx->context.ohci;

drivers/firewire/ohci.c

1375

dma_unmap_single(ohci->card.device, packet->payload_bus,

drivers/firewire/ohci.c

1432

fw_card_get(&ohci->card);

drivers/firewire/ohci.c

1433

dev = device_find_child(ohci->card.device, (const void *)params, find_fw_device);

drivers/firewire/ohci.c

1434

fw_card_put(&ohci->card);

drivers/firewire/ohci.c

1450

packet->callback(packet, &ohci->card, packet->ack);

drivers/firewire/ohci.c

1455

static u32 get_cycle_time(struct fw_ohci *ohci);

drivers/firewire/ohci.c

1457

static void handle_local_rom(struct fw_ohci *ohci,

drivers/firewire/ohci.c

1478

(void *) ohci->config_rom + i, length);

drivers/firewire/ohci.c

1482

response.timestamp = cycle_time_to_ohci_tstamp(get_cycle_time(ohci));

drivers/firewire/ohci.c

1483

fw_core_handle_response(&ohci->card, &response);

drivers/firewire/ohci.c

1486

static void handle_local_lock(struct fw_ohci *ohci,

drivers/firewire/ohci.c

1513

reg_write(ohci, OHCI1394_CSRData, lock_data);

drivers/firewire/ohci.c

1514

reg_write(ohci, OHCI1394_CSRCompareData, lock_arg);

drivers/firewire/ohci.c

1515

reg_write(ohci, OHCI1394_CSRControl, sel);

drivers/firewire/ohci.c

1518

if (reg_read(ohci, OHCI1394_CSRControl) & 0x80000000) {

drivers/firewire/ohci.c

1519

lock_old = cpu_to_be32(reg_read(ohci,

drivers/firewire/ohci.c

1527

ohci_err(ohci, "swap not done (CSR lock timeout)\n");

drivers/firewire/ohci.c

1532

response.timestamp = cycle_time_to_ohci_tstamp(get_cycle_time(ohci));

drivers/firewire/ohci.c

1533

fw_core_handle_response(&ohci->card, &response);

drivers/firewire/ohci.c

1538

struct fw_ohci *ohci = ctx->context.ohci;

drivers/firewire/ohci.c

1541

if (ctx == &ohci->at_request_ctx) {

drivers/firewire/ohci.c

1543

packet->callback(packet, &ohci->card, packet->ack);

drivers/firewire/ohci.c

1551

handle_local_rom(ohci, packet, csr);

drivers/firewire/ohci.c

1557

handle_local_lock(ohci, packet, csr);

drivers/firewire/ohci.c

1560

if (ctx == &ohci->at_request_ctx)

drivers/firewire/ohci.c

1561

fw_core_handle_request(&ohci->card, packet);

drivers/firewire/ohci.c

1563

fw_core_handle_response(&ohci->card, packet);

drivers/firewire/ohci.c

1567

if (ctx == &ohci->at_response_ctx) {

drivers/firewire/ohci.c

1569

packet->callback(packet, &ohci->card, packet->ack);

drivers/firewire/ohci.c

1575

struct fw_ohci *ohci = ctx->context.ohci;

drivers/firewire/ohci.c

1579

spin_lock_irqsave(&ohci->lock, flags);

drivers/firewire/ohci.c

1581

if (async_header_get_destination(packet->header) == ohci->node_id &&

drivers/firewire/ohci.c

1582

ohci->generation == packet->generation) {

drivers/firewire/ohci.c

1583

spin_unlock_irqrestore(&ohci->lock, flags);

drivers/firewire/ohci.c

1586

packet->timestamp = cycle_time_to_ohci_tstamp(get_cycle_time(ohci));

drivers/firewire/ohci.c

1593

spin_unlock_irqrestore(&ohci->lock, flags);

drivers/firewire/ohci.c

1597

packet->timestamp = cycle_time_to_ohci_tstamp(get_cycle_time(ohci));

drivers/firewire/ohci.c

1599

packet->callback(packet, &ohci->card, packet->ack);

drivers/firewire/ohci.c

1603

static void detect_dead_context(struct fw_ohci *ohci,

drivers/firewire/ohci.c

1627

ctl = reg_read(ohci, CONTROL_SET(regs));

drivers/firewire/ohci.c

1629

ohci_err(ohci, "DMA context %s has stopped, error code: %s\n",

drivers/firewire/ohci.c

1633

static void handle_dead_contexts(struct fw_ohci *ohci)

drivers/firewire/ohci.c

1638

detect_dead_context(ohci, "ATReq", OHCI1394_AsReqTrContextBase);

drivers/firewire/ohci.c

1639

detect_dead_context(ohci, "ATRsp", OHCI1394_AsRspTrContextBase);

drivers/firewire/ohci.c

1640

detect_dead_context(ohci, "ARReq", OHCI1394_AsReqRcvContextBase);

drivers/firewire/ohci.c

1641

detect_dead_context(ohci, "ARRsp", OHCI1394_AsRspRcvContextBase);

drivers/firewire/ohci.c

1643

if (!(ohci->it_context_support & (1 << i)))

drivers/firewire/ohci.c

1646

detect_dead_context(ohci, name, OHCI1394_IsoXmitContextBase(i));

drivers/firewire/ohci.c

1649

if (!(ohci->ir_context_support & (1 << i)))

drivers/firewire/ohci.c

1652

detect_dead_context(ohci, name, OHCI1394_IsoRcvContextBase(i));

drivers/firewire/ohci.c

1683

static u32 get_cycle_time(struct fw_ohci *ohci)

drivers/firewire/ohci.c

1690

if (has_reboot_by_cycle_timer_read_quirk(ohci))

drivers/firewire/ohci.c

1693

c2 = reg_read(ohci, OHCI1394_IsochronousCycleTimer);

drivers/firewire/ohci.c

1695

if (ohci->quirks & QUIRK_CYCLE_TIMER) {

drivers/firewire/ohci.c

1698

c2 = reg_read(ohci, OHCI1394_IsochronousCycleTimer);

drivers/firewire/ohci.c

1702

c2 = reg_read(ohci, OHCI1394_IsochronousCycleTimer);

drivers/firewire/ohci.c

1722

static u32 update_bus_time(struct fw_ohci *ohci)

drivers/firewire/ohci.c

1724

u32 cycle_time_seconds = get_cycle_time(ohci) >> 25;

drivers/firewire/ohci.c

1726

if (unlikely(!ohci->bus_time_running)) {

drivers/firewire/ohci.c

1727

reg_write(ohci, OHCI1394_IntMaskSet, OHCI1394_cycle64Seconds);

drivers/firewire/ohci.c

1728

ohci->bus_time = (lower_32_bits(ktime_get_seconds()) & ~0x7f) |

drivers/firewire/ohci.c

1730

ohci->bus_time_running = true;

drivers/firewire/ohci.c

1733

if ((ohci->bus_time & 0x40) != (cycle_time_seconds & 0x40))

drivers/firewire/ohci.c

1734

ohci->bus_time += 0x40;

drivers/firewire/ohci.c

1736

return ohci->bus_time | cycle_time_seconds;

drivers/firewire/ohci.c

1739

static int get_status_for_port(struct fw_ohci *ohci, int port_index,

drivers/firewire/ohci.c

1744

scoped_guard(mutex, &ohci->phy_reg_mutex) {

drivers/firewire/ohci.c

1745

reg = write_phy_reg(ohci, 7, port_index);

drivers/firewire/ohci.c

1749

reg = read_phy_reg(ohci, 8);

drivers/firewire/ohci.c

1772

static int get_self_id_pos(struct fw_ohci *ohci, u32 self_id,

drivers/firewire/ohci.c

1779

u32 entry = ohci->self_id_buffer[i];

drivers/firewire/ohci.c

1790

static int detect_initiated_reset(struct fw_ohci *ohci, bool *is_initiated_reset)

drivers/firewire/ohci.c

1794

guard(mutex)(&ohci->phy_reg_mutex);

drivers/firewire/ohci.c

1797

reg = write_phy_reg(ohci, 7, 0xe0);

drivers/firewire/ohci.c

1801

reg = read_phy_reg(ohci, 8);

drivers/firewire/ohci.c

1807

reg = write_phy_reg(ohci, 8, reg);

drivers/firewire/ohci.c

1812

reg = read_phy_reg(ohci, 12);

drivers/firewire/ohci.c

1827

static int find_and_insert_self_id(struct fw_ohci *ohci, int self_id_count)

drivers/firewire/ohci.c

1839

reg = reg_read(ohci, OHCI1394_NodeID);

drivers/firewire/ohci.c

1841

ohci_notice(ohci,

drivers/firewire/ohci.c

1847

reg = ohci_read_phy_reg(&ohci->card, 4);

drivers/firewire/ohci.c

1852

reg = ohci_read_phy_reg(&ohci->card, 1);

drivers/firewire/ohci.c

1860

err = get_status_for_port(ohci, i, &status);

drivers/firewire/ohci.c

1867

err = detect_initiated_reset(ohci, &is_initiated_reset);

drivers/firewire/ohci.c

1872

pos = get_self_id_pos(ohci, self_id, self_id_count);

drivers/firewire/ohci.c

1874

memmove(&(ohci->self_id_buffer[pos+1]),

drivers/firewire/ohci.c

1875

&(ohci->self_id_buffer[pos]),

drivers/firewire/ohci.c

1876

(self_id_count - pos) * sizeof(*ohci->self_id_buffer));

drivers/firewire/ohci.c

1877

ohci->self_id_buffer[pos] = self_id;

drivers/firewire/ohci.c

1885

struct fw_ohci *ohci = data;

drivers/firewire/ohci.c

1892

reg = reg_read(ohci, OHCI1394_NodeID);

drivers/firewire/ohci.c

1894

ohci_notice(ohci,

drivers/firewire/ohci.c

1899

ohci_notice(ohci, "malconfigured bus\n");

drivers/firewire/ohci.c

1902

ohci->node_id = reg & (OHCI1394_NodeID_busNumber |

drivers/firewire/ohci.c

1906

if (!(ohci->is_root && is_new_root))

drivers/firewire/ohci.c

1907

reg_write(ohci, OHCI1394_LinkControlSet,

drivers/firewire/ohci.c

1909

ohci->is_root = is_new_root;

drivers/firewire/ohci.c

1911

reg = reg_read(ohci, OHCI1394_SelfIDCount);

drivers/firewire/ohci.c

1913

ohci_notice(ohci, "self ID receive error\n");

drivers/firewire/ohci.c

1917

trace_self_id_complete(ohci->card.index, reg, ohci->self_id, has_be_header_quirk(ohci));

drivers/firewire/ohci.c

1928

ohci_notice(ohci, "bad selfIDSize (%08x)\n", reg);

drivers/firewire/ohci.c

1932

quadlet = cond_le32_to_cpu(ohci->self_id[0], has_be_header_quirk(ohci));

drivers/firewire/ohci.c

1937

u32 id = cond_le32_to_cpu(ohci->self_id[i], has_be_header_quirk(ohci));

drivers/firewire/ohci.c

1938

u32 id2 = cond_le32_to_cpu(ohci->self_id[i + 1], has_be_header_quirk(ohci));

drivers/firewire/ohci.c

1949

ohci_notice(ohci, "ignoring spurious self IDs\n");

drivers/firewire/ohci.c

1954

ohci_notice(ohci, "bad self ID %d/%d (%08x != ~%08x)\n",

drivers/firewire/ohci.c

1958

ohci->self_id_buffer[j] = id;

drivers/firewire/ohci.c

1961

if (ohci->quirks & QUIRK_TI_SLLZ059) {

drivers/firewire/ohci.c

1962

self_id_count = find_and_insert_self_id(ohci, self_id_count);

drivers/firewire/ohci.c

1964

ohci_notice(ohci,

drivers/firewire/ohci.c

1971

ohci_notice(ohci, "no self IDs\n");

drivers/firewire/ohci.c

1990

reg = reg_read(ohci, OHCI1394_SelfIDCount);

drivers/firewire/ohci.c

1993

ohci_notice(ohci, "new bus reset, discarding self ids\n");

drivers/firewire/ohci.c

1998

scoped_guard(spinlock_irq, &ohci->lock) {

drivers/firewire/ohci.c

1999

ohci->generation = -1; // prevent AT packet queueing

drivers/firewire/ohci.c

2000

context_stop(&ohci->at_request_ctx.context);

drivers/firewire/ohci.c

2001

context_stop(&ohci->at_response_ctx.context);

drivers/firewire/ohci.c

2009

at_context_flush(&ohci->at_request_ctx);

drivers/firewire/ohci.c

2010

at_context_flush(&ohci->at_response_ctx);

drivers/firewire/ohci.c

2012

scoped_guard(spinlock_irq, &ohci->lock) {

drivers/firewire/ohci.c

2013

ohci->generation = generation;

drivers/firewire/ohci.c

2014

reg_write(ohci, OHCI1394_IntEventClear, OHCI1394_busReset);

drivers/firewire/ohci.c

2015

reg_write(ohci, OHCI1394_IntMaskSet, OHCI1394_busReset);

drivers/firewire/ohci.c

2017

if (ohci->quirks & QUIRK_RESET_PACKET)

drivers/firewire/ohci.c

2018

ohci->request_generation = generation;

drivers/firewire/ohci.c

2025

if (ohci->next_config_rom != NULL) {

drivers/firewire/ohci.c

2026

if (ohci->next_config_rom != ohci->config_rom) {

drivers/firewire/ohci.c

2027

free_rom = ohci->config_rom;

drivers/firewire/ohci.c

2028

free_rom_bus = ohci->config_rom_bus;

drivers/firewire/ohci.c

2030

ohci->config_rom = ohci->next_config_rom;

drivers/firewire/ohci.c

2031

ohci->config_rom_bus = ohci->next_config_rom_bus;

drivers/firewire/ohci.c

2032

ohci->next_config_rom = NULL;

drivers/firewire/ohci.c

2037

reg_write(ohci, OHCI1394_BusOptions, be32_to_cpu(ohci->config_rom[2]));

drivers/firewire/ohci.c

2038

ohci->config_rom[0] = ohci->next_header;

drivers/firewire/ohci.c

2039

reg_write(ohci, OHCI1394_ConfigROMhdr, be32_to_cpu(ohci->next_header));

drivers/firewire/ohci.c

2043

reg_write(ohci, OHCI1394_PhyReqFilterHiSet, ~0);

drivers/firewire/ohci.c

2044

reg_write(ohci, OHCI1394_PhyReqFilterLoSet, ~0);

drivers/firewire/ohci.c

2049

dmam_free_coherent(ohci->card.device, CONFIG_ROM_SIZE, free_rom, free_rom_bus);

drivers/firewire/ohci.c

2051

fw_core_handle_bus_reset(&ohci->card, ohci->node_id, generation,

drivers/firewire/ohci.c

2052

self_id_count, ohci->self_id_buffer,

drivers/firewire/ohci.c

2053

ohci->csr_state_setclear_abdicate);

drivers/firewire/ohci.c

2054

ohci->csr_state_setclear_abdicate = false;

drivers/firewire/ohci.c

2061

struct fw_ohci *ohci = data;

drivers/firewire/ohci.c

2065

event = reg_read(ohci, OHCI1394_IntEventClear);

drivers/firewire/ohci.c

2074

reg_write(ohci, OHCI1394_IntEventClear,

drivers/firewire/ohci.c

2076

trace_irqs(ohci->card.index, event);

drivers/firewire/ohci.c

2080

reg_write(ohci, OHCI1394_IntMaskClear, OHCI1394_busReset);

drivers/firewire/ohci.c

2083

queue_work(ohci->card.async_wq, &ohci->ar_request_ctx.work);

drivers/firewire/ohci.c

2086

queue_work(ohci->card.async_wq, &ohci->ar_response_ctx.work);

drivers/firewire/ohci.c

2089

queue_work(ohci->card.async_wq, &ohci->at_request_ctx.work);

drivers/firewire/ohci.c

2092

queue_work(ohci->card.async_wq, &ohci->at_response_ctx.work);

drivers/firewire/ohci.c

2095

iso_event = reg_read(ohci, OHCI1394_IsoRecvIntEventClear);

drivers/firewire/ohci.c

2096

reg_write(ohci, OHCI1394_IsoRecvIntEventClear, iso_event);

drivers/firewire/ohci.c

2100

fw_iso_context_schedule_flush_completions(&ohci->ir_context_list[i].base);

drivers/firewire/ohci.c

2106

iso_event = reg_read(ohci, OHCI1394_IsoXmitIntEventClear);

drivers/firewire/ohci.c

2107

reg_write(ohci, OHCI1394_IsoXmitIntEventClear, iso_event);

drivers/firewire/ohci.c

2111

fw_iso_context_schedule_flush_completions(&ohci->it_context_list[i].base);

drivers/firewire/ohci.c

2117

ohci_err(ohci, "register access failure\n");

drivers/firewire/ohci.c

2120

reg_read(ohci, OHCI1394_PostedWriteAddressHi);

drivers/firewire/ohci.c

2121

reg_read(ohci, OHCI1394_PostedWriteAddressLo);

drivers/firewire/ohci.c

2122

reg_write(ohci, OHCI1394_IntEventClear,

drivers/firewire/ohci.c

2124

dev_err_ratelimited(ohci->card.device, "PCI posted write error\n");

drivers/firewire/ohci.c

2128

dev_notice_ratelimited(ohci->card.device, "isochronous cycle too long\n");

drivers/firewire/ohci.c

2129

reg_write(ohci, OHCI1394_LinkControlSet,

drivers/firewire/ohci.c

2140

dev_notice_ratelimited(ohci->card.device, "isochronous cycle inconsistent\n");

drivers/firewire/ohci.c

2144

handle_dead_contexts(ohci);

drivers/firewire/ohci.c

2147

guard(spinlock)(&ohci->lock);

drivers/firewire/ohci.c

2148

update_bus_time(ohci);

drivers/firewire/ohci.c

2150

flush_writes(ohci);

drivers/firewire/ohci.c

2158

static int software_reset(struct fw_ohci *ohci)

drivers/firewire/ohci.c

2163

reg_write(ohci, OHCI1394_HCControlSet, OHCI1394_HCControl_softReset);

drivers/firewire/ohci.c

2165

val = reg_read(ohci, OHCI1394_HCControlSet);

drivers/firewire/ohci.c

2187

static int configure_1394a_enhancements(struct fw_ohci *ohci)

drivers/firewire/ohci.c

2193

if (!(reg_read(ohci, OHCI1394_HCControlSet) &

drivers/firewire/ohci.c

2199

ret = read_phy_reg(ohci, 2);

drivers/firewire/ohci.c

2203

ret = read_paged_phy_reg(ohci, 1, 8);

drivers/firewire/ohci.c

2210

if (ohci->quirks & QUIRK_NO_1394A)

drivers/firewire/ohci.c

2221

ret = update_phy_reg(ohci, 5, clear, set);

drivers/firewire/ohci.c

2229

reg_write(ohci, offset, OHCI1394_HCControl_aPhyEnhanceEnable);

drivers/firewire/ohci.c

2232

reg_write(ohci, OHCI1394_HCControlClear,

drivers/firewire/ohci.c

2238

static int probe_tsb41ba3d(struct fw_ohci *ohci)

drivers/firewire/ohci.c

2244

reg = read_phy_reg(ohci, 2);

drivers/firewire/ohci.c

2251

reg = read_paged_phy_reg(ohci, 1, i + 10);

drivers/firewire/ohci.c

2263

struct fw_ohci *ohci = fw_ohci(card);

drivers/firewire/ohci.c

2267

ret = software_reset(ohci);

drivers/firewire/ohci.c

2269

ohci_err(ohci, "failed to reset ohci card\n");

drivers/firewire/ohci.c

2286

reg_write(ohci, OHCI1394_HCControlSet,

drivers/firewire/ohci.c

2289

flush_writes(ohci);

drivers/firewire/ohci.c

2293

lps = reg_read(ohci, OHCI1394_HCControlSet) &

drivers/firewire/ohci.c

2298

ohci_err(ohci, "failed to set Link Power Status\n");

drivers/firewire/ohci.c

2302

if (ohci->quirks & QUIRK_TI_SLLZ059) {

drivers/firewire/ohci.c

2303

ret = probe_tsb41ba3d(ohci);

drivers/firewire/ohci.c

2307

ohci_notice(ohci, "local TSB41BA3D phy\n");

drivers/firewire/ohci.c

2309

ohci->quirks &= ~QUIRK_TI_SLLZ059;

drivers/firewire/ohci.c

2312

reg_write(ohci, OHCI1394_HCControlClear,

drivers/firewire/ohci.c

2315

reg_write(ohci, OHCI1394_SelfIDBuffer, ohci->self_id_bus);

drivers/firewire/ohci.c

2316

reg_write(ohci, OHCI1394_LinkControlSet,

drivers/firewire/ohci.c

2320

reg_write(ohci, OHCI1394_ATRetries,

drivers/firewire/ohci.c

2326

ohci->bus_time_running = false;

drivers/firewire/ohci.c

2329

if (ohci->ir_context_support & (1 << i))

drivers/firewire/ohci.c

2330

reg_write(ohci, OHCI1394_IsoRcvContextControlClear(i),

drivers/firewire/ohci.c

2333

version = reg_read(ohci, OHCI1394_Version) & 0x00ff00ff;

drivers/firewire/ohci.c

2335

reg_write(ohci, OHCI1394_InitialChannelsAvailableHi,

drivers/firewire/ohci.c

2341

reg_write(ohci, OHCI1394_FairnessControl, 0x3f);

drivers/firewire/ohci.c

2342

ohci->pri_req_max = reg_read(ohci, OHCI1394_FairnessControl) & 0x3f;

drivers/firewire/ohci.c

2343

reg_write(ohci, OHCI1394_FairnessControl, 0);

drivers/firewire/ohci.c

2344

card->priority_budget_implemented = ohci->pri_req_max != 0;

drivers/firewire/ohci.c

2346

reg_write(ohci, OHCI1394_PhyUpperBound, FW_MAX_PHYSICAL_RANGE >> 16);

drivers/firewire/ohci.c

2347

reg_write(ohci, OHCI1394_IntEventClear, ~0);

drivers/firewire/ohci.c

2348

reg_write(ohci, OHCI1394_IntMaskClear, ~0);

drivers/firewire/ohci.c

2350

ret = configure_1394a_enhancements(ohci);

drivers/firewire/ohci.c

2379

ohci->next_config_rom = dmam_alloc_coherent(ohci->card.device, CONFIG_ROM_SIZE,

drivers/firewire/ohci.c

2380

&ohci->next_config_rom_bus, GFP_KERNEL);

drivers/firewire/ohci.c

2381

if (ohci->next_config_rom == NULL)

drivers/firewire/ohci.c

2384

copy_config_rom(ohci->next_config_rom, config_rom, length);

drivers/firewire/ohci.c

2390

ohci->next_config_rom = ohci->config_rom;

drivers/firewire/ohci.c

2391

ohci->next_config_rom_bus = ohci->config_rom_bus;

drivers/firewire/ohci.c

2394

ohci->next_header = ohci->next_config_rom[0];

drivers/firewire/ohci.c

2395

ohci->next_config_rom[0] = 0;

drivers/firewire/ohci.c

2396

reg_write(ohci, OHCI1394_ConfigROMhdr, 0);

drivers/firewire/ohci.c

2397

reg_write(ohci, OHCI1394_BusOptions,

drivers/firewire/ohci.c

2398

be32_to_cpu(ohci->next_config_rom[2]));

drivers/firewire/ohci.c

2399

reg_write(ohci, OHCI1394_ConfigROMmap, ohci->next_config_rom_bus);

drivers/firewire/ohci.c

2401

reg_write(ohci, OHCI1394_AsReqFilterHiSet, 0x80000000);

drivers/firewire/ohci.c

2414

reg_write(ohci, OHCI1394_IntMaskSet, irqs);

drivers/firewire/ohci.c

2416

reg_write(ohci, OHCI1394_HCControlSet,

drivers/firewire/ohci.c

2420

reg_write(ohci, OHCI1394_LinkControlSet,

drivers/firewire/ohci.c

2424

ar_context_run(&ohci->ar_request_ctx);

drivers/firewire/ohci.c

2425

ar_context_run(&ohci->ar_response_ctx);

drivers/firewire/ohci.c

2427

flush_writes(ohci);

drivers/firewire/ohci.c

2430

fw_schedule_bus_reset(&ohci->card, false, true);

drivers/firewire/ohci.c

2438

struct fw_ohci *ohci = pci_get_drvdata(pdev);

drivers/firewire/ohci.c

2443

if (!(reg_read(ohci, OHCI1394_HCControlSet) & OHCI1394_HCControl_LPS))

drivers/firewire/ohci.c

2446

reg_write(ohci, OHCI1394_IntMaskClear, ~0);

drivers/firewire/ohci.c

2447

flush_writes(ohci);

drivers/firewire/ohci.c

2452

flush_work(&ohci->ar_request_ctx.work);

drivers/firewire/ohci.c

2453

flush_work(&ohci->ar_response_ctx.work);

drivers/firewire/ohci.c

2454

flush_work(&ohci->at_request_ctx.work);

drivers/firewire/ohci.c

2455

flush_work(&ohci->at_response_ctx.work);

drivers/firewire/ohci.c

2457

for (i = 0; i < ohci->n_ir; ++i) {

drivers/firewire/ohci.c

2458

if (!(ohci->ir_context_mask & BIT(i)))

drivers/firewire/ohci.c

2459

flush_work(&ohci->ir_context_list[i].base.work);

drivers/firewire/ohci.c

2461

for (i = 0; i < ohci->n_it; ++i) {

drivers/firewire/ohci.c

2462

if (!(ohci->it_context_mask & BIT(i)))

drivers/firewire/ohci.c

2463

flush_work(&ohci->it_context_list[i].base.work);

drivers/firewire/ohci.c

2466

at_context_flush(&ohci->at_request_ctx);

drivers/firewire/ohci.c

2467

at_context_flush(&ohci->at_response_ctx);

drivers/firewire/ohci.c

2473

struct fw_ohci *ohci;

drivers/firewire/ohci.c

2477

ohci = fw_ohci(card);

drivers/firewire/ohci.c

2506

next_config_rom = dmam_alloc_coherent(ohci->card.device, CONFIG_ROM_SIZE,

drivers/firewire/ohci.c

2511

scoped_guard(spinlock_irq, &ohci->lock) {

drivers/firewire/ohci.c

2518

if (ohci->next_config_rom == NULL) {

drivers/firewire/ohci.c

2519

ohci->next_config_rom = next_config_rom;

drivers/firewire/ohci.c

2520

ohci->next_config_rom_bus = next_config_rom_bus;

drivers/firewire/ohci.c

2524

copy_config_rom(ohci->next_config_rom, config_rom, length);

drivers/firewire/ohci.c

2526

ohci->next_header = config_rom[0];

drivers/firewire/ohci.c

2527

ohci->next_config_rom[0] = 0;

drivers/firewire/ohci.c

2529

reg_write(ohci, OHCI1394_ConfigROMmap, ohci->next_config_rom_bus);

drivers/firewire/ohci.c

2534

dmam_free_coherent(ohci->card.device, CONFIG_ROM_SIZE, next_config_rom,

drivers/firewire/ohci.c

2546

fw_schedule_bus_reset(&ohci->card, true, true);

drivers/firewire/ohci.c

2553

struct fw_ohci *ohci = fw_ohci(card);

drivers/firewire/ohci.c

2555

at_context_transmit(&ohci->at_request_ctx, packet);

drivers/firewire/ohci.c

2560

struct fw_ohci *ohci = fw_ohci(card);

drivers/firewire/ohci.c

2562

at_context_transmit(&ohci->at_response_ctx, packet);

drivers/firewire/ohci.c

2567

struct fw_ohci *ohci = fw_ohci(card);

drivers/firewire/ohci.c

2568

struct at_context *ctx = &ohci->at_request_ctx;

drivers/firewire/ohci.c

2581

dma_unmap_single(ohci->card.device, packet->payload_bus,

drivers/firewire/ohci.c

2588

packet->timestamp = cycle_time_to_ohci_tstamp(get_cycle_time(ohci));

drivers/firewire/ohci.c

2590

packet->callback(packet, &ohci->card, packet->ack);

drivers/firewire/ohci.c

2601

struct fw_ohci *ohci = fw_ohci(card);

drivers/firewire/ohci.c

2612

guard(spinlock_irqsave)(&ohci->lock);

drivers/firewire/ohci.c

2614

if (ohci->generation != generation)

drivers/firewire/ohci.c

2624

reg_write(ohci, OHCI1394_PhyReqFilterLoSet, 1 << n);

drivers/firewire/ohci.c

2626

reg_write(ohci, OHCI1394_PhyReqFilterHiSet, 1 << (n - 32));

drivers/firewire/ohci.c

2628

flush_writes(ohci);

drivers/firewire/ohci.c

2635

struct fw_ohci *ohci = fw_ohci(card);

drivers/firewire/ohci.c

2641

if (ohci->is_root &&

drivers/firewire/ohci.c

2642

(reg_read(ohci, OHCI1394_LinkControlSet) &

drivers/firewire/ohci.c

2647

if (ohci->csr_state_setclear_abdicate)

drivers/firewire/ohci.c

2653

return reg_read(ohci, OHCI1394_NodeID) << 16;

drivers/firewire/ohci.c

2656

return get_cycle_time(ohci);

drivers/firewire/ohci.c

2664

guard(spinlock_irqsave)(&ohci->lock);

drivers/firewire/ohci.c

2665

return update_bus_time(ohci);

drivers/firewire/ohci.c

2668

value = reg_read(ohci, OHCI1394_ATRetries);

drivers/firewire/ohci.c

2672

return (reg_read(ohci, OHCI1394_FairnessControl) & 0x3f) |

drivers/firewire/ohci.c

2673

(ohci->pri_req_max << 8);

drivers/firewire/ohci.c

2683

struct fw_ohci *ohci = fw_ohci(card);

drivers/firewire/ohci.c

2687

if ((value & CSR_STATE_BIT_CMSTR) && ohci->is_root) {

drivers/firewire/ohci.c

2688

reg_write(ohci, OHCI1394_LinkControlClear,

drivers/firewire/ohci.c

2690

flush_writes(ohci);

drivers/firewire/ohci.c

2693

ohci->csr_state_setclear_abdicate = false;

drivers/firewire/ohci.c

2697

if ((value & CSR_STATE_BIT_CMSTR) && ohci->is_root) {

drivers/firewire/ohci.c

2698

reg_write(ohci, OHCI1394_LinkControlSet,

drivers/firewire/ohci.c

2700

flush_writes(ohci);

drivers/firewire/ohci.c

2703

ohci->csr_state_setclear_abdicate = true;

drivers/firewire/ohci.c

2707

reg_write(ohci, OHCI1394_NodeID, value >> 16);

drivers/firewire/ohci.c

2708

flush_writes(ohci);

drivers/firewire/ohci.c

2712

reg_write(ohci, OHCI1394_IsochronousCycleTimer, value);

drivers/firewire/ohci.c

2713

reg_write(ohci, OHCI1394_IntEventSet,

drivers/firewire/ohci.c

2715

flush_writes(ohci);

drivers/firewire/ohci.c

2720

guard(spinlock_irqsave)(&ohci->lock);

drivers/firewire/ohci.c

2721

ohci->bus_time = (update_bus_time(ohci) & 0x40) | (value & ~0x7f);

drivers/firewire/ohci.c

2727

reg_write(ohci, OHCI1394_ATRetries, value);

drivers/firewire/ohci.c

2728

flush_writes(ohci);

drivers/firewire/ohci.c

2732

reg_write(ohci, OHCI1394_FairnessControl, value & 0x3f);

drivers/firewire/ohci.c

2733

flush_writes(ohci);

drivers/firewire/ohci.c

2800

dma_sync_single_range_for_cpu(context->ohci->card.device,

drivers/firewire/ohci.c

2839

dma_sync_single_range_for_cpu(context->ohci->card.device,

drivers/firewire/ohci.c

2859

dma_sync_single_range_for_cpu(ctx->context.ohci->card.device,

drivers/firewire/ohci.c

2899

dma_sync_single_range_for_cpu(context->ohci->card.device,

drivers/firewire/ohci.c

2946

static void set_multichannel_mask(struct fw_ohci *ohci, u64 channels)

drivers/firewire/ohci.c

2950

reg_write(ohci, OHCI1394_IRMultiChanMaskHiClear, ~hi);

drivers/firewire/ohci.c

2951

reg_write(ohci, OHCI1394_IRMultiChanMaskLoClear, ~lo);

drivers/firewire/ohci.c

2952

reg_write(ohci, OHCI1394_IRMultiChanMaskHiSet, hi);

drivers/firewire/ohci.c

2953

reg_write(ohci, OHCI1394_IRMultiChanMaskLoSet, lo);

drivers/firewire/ohci.c

2954

ohci->mc_channels = channels;

drivers/firewire/ohci.c

2960

struct fw_ohci *ohci = fw_ohci(card);

drivers/firewire/ohci.c

2968

scoped_guard(spinlock_irq, &ohci->lock) {

drivers/firewire/ohci.c

2971

mask = &ohci->it_context_mask;

drivers/firewire/ohci.c

2977

ctx = &ohci->it_context_list[index];

drivers/firewire/ohci.c

298

static bool has_reboot_by_cycle_timer_read_quirk(const struct fw_ohci *ohci)

drivers/firewire/ohci.c

2982

channels = &ohci->ir_context_channels;

drivers/firewire/ohci.c

2983

mask = &ohci->ir_context_mask;

drivers/firewire/ohci.c

2990

ctx = &ohci->ir_context_list[index];

drivers/firewire/ohci.c

2995

mask = &ohci->ir_context_mask;

drivers/firewire/ohci.c

2997

index = !ohci->mc_allocated ? ffs(*mask) - 1 : -1;

drivers/firewire/ohci.c

2999

ohci->mc_allocated = true;

drivers/firewire/ohci.c

300

return !!(ohci->quirks & QUIRK_REBOOT_BY_CYCLE_TIMER_READ);

drivers/firewire/ohci.c

3002

ctx = &ohci->ir_context_list[index];

drivers/firewire/ohci.c

3026

ret = context_init(&ctx->context, ohci, regs, callback);

drivers/firewire/ohci.c

3034

set_multichannel_mask(ohci, 0);

drivers/firewire/ohci.c

3040

scoped_guard(spinlock_irq, &ohci->lock) {

drivers/firewire/ohci.c

3047

ohci->mc_allocated = false;

drivers/firewire/ohci.c

3060

struct fw_ohci *ohci = ctx->context.ohci;

drivers/firewire/ohci.c

3070

index = ctx - ohci->it_context_list;

drivers/firewire/ohci.c

3076

reg_write(ohci, OHCI1394_IsoXmitIntEventClear, 1 << index);

drivers/firewire/ohci.c

3077

reg_write(ohci, OHCI1394_IsoXmitIntMaskSet, 1 << index);

drivers/firewire/ohci.c

3085

index = ctx - ohci->ir_context_list;

drivers/firewire/ohci.c

3092

reg_write(ohci, OHCI1394_IsoRecvIntEventClear, 1 << index);

drivers/firewire/ohci.c

3093

reg_write(ohci, OHCI1394_IsoRecvIntMaskSet, 1 << index);

drivers/firewire/ohci.c

3094

reg_write(ohci, CONTEXT_MATCH(ctx->context.regs), match);

drivers/firewire/ohci.c

3108

struct fw_ohci *ohci = fw_ohci(base->card);

drivers/firewire/ohci.c

3114

index = ctx - ohci->it_context_list;

drivers/firewire/ohci.c

3115

reg_write(ohci, OHCI1394_IsoXmitIntMaskClear, 1 << index);

drivers/firewire/ohci.c

3120

index = ctx - ohci->ir_context_list;

drivers/firewire/ohci.c

3121

reg_write(ohci, OHCI1394_IsoRecvIntMaskClear, 1 << index);

drivers/firewire/ohci.c

3124

flush_writes(ohci);

drivers/firewire/ohci.c

3132

struct fw_ohci *ohci = fw_ohci(base->card);

drivers/firewire/ohci.c

3144

guard(spinlock_irqsave)(&ohci->lock);

drivers/firewire/ohci.c

3148

index = ctx - ohci->it_context_list;

drivers/firewire/ohci.c

3149

ohci->it_context_mask |= 1 << index;

drivers/firewire/ohci.c

3153

index = ctx - ohci->ir_context_list;

drivers/firewire/ohci.c

3154

ohci->ir_context_mask |= 1 << index;

drivers/firewire/ohci.c

3155

ohci->ir_context_channels |= 1ULL << base->channel;

drivers/firewire/ohci.c

3159

index = ctx - ohci->ir_context_list;

drivers/firewire/ohci.c

3160

ohci->ir_context_mask |= 1 << index;

drivers/firewire/ohci.c

3161

ohci->ir_context_channels |= ohci->mc_channels;

drivers/firewire/ohci.c

3162

ohci->mc_channels = 0;

drivers/firewire/ohci.c

3163

ohci->mc_allocated = false;

drivers/firewire/ohci.c

3170

struct fw_ohci *ohci = fw_ohci(base->card);

drivers/firewire/ohci.c

3175

guard(spinlock_irqsave)(&ohci->lock);

drivers/firewire/ohci.c

3178

if (~ohci->ir_context_channels & ~ohci->mc_channels & *channels) {

drivers/firewire/ohci.c

3179

*channels = ohci->ir_context_channels;

drivers/firewire/ohci.c

3182

set_multichannel_mask(ohci, *channels);

drivers/firewire/ohci.c

3191

static void __maybe_unused ohci_resume_iso_dma(struct fw_ohci *ohci)

drivers/firewire/ohci.c

3196

for (i = 0 ; i < ohci->n_ir ; i++) {

drivers/firewire/ohci.c

3197

ctx = &ohci->ir_context_list[i];

drivers/firewire/ohci.c

3202

for (i = 0 ; i < ohci->n_it ; i++) {

drivers/firewire/ohci.c

3203

ctx = &ohci->it_context_list[i];

drivers/firewire/ohci.c

3290

dma_sync_single_range_for_device(ctx->context.ohci->card.device,

drivers/firewire/ohci.c

330

#define has_reboot_by_cycle_timer_read_quirk(ohci) false

drivers/firewire/ohci.c

3318

struct device *device = ctx->context.ohci->card.device;

drivers/firewire/ohci.c

3436

dma_sync_single_range_for_device(ctx->context.ohci->card.device,

drivers/firewire/ohci.c

3457

guard(spinlock_irqsave)(&ctx->context.ohci->lock);

drivers/firewire/ohci.c

3476

reg_write(ctx->ohci, CONTROL_SET(ctx->regs), CONTEXT_WAKE);

drivers/firewire/ohci.c

3563

struct fw_ohci *ohci = pci_get_drvdata(pdev);

drivers/firewire/ohci.c

3567

ar_context_release(&ohci->ar_response_ctx);

drivers/firewire/ohci.c

3568

ar_context_release(&ohci->ar_request_ctx);

drivers/firewire/ohci.c

3576

struct fw_ohci *ohci;

drivers/firewire/ohci.c

3586

ohci = devres_alloc(release_ohci, sizeof(*ohci), GFP_KERNEL);

drivers/firewire/ohci.c

3587

if (ohci == NULL)

drivers/firewire/ohci.c

3589

fw_card_initialize(&ohci->card, &ohci_driver, &dev->dev);

drivers/firewire/ohci.c

3590

pci_set_drvdata(dev, ohci);

drivers/firewire/ohci.c

3592

devres_add(&dev->dev, ohci);

drivers/firewire/ohci.c

3603

spin_lock_init(&ohci->lock);

drivers/firewire/ohci.c

3604

mutex_init(&ohci->phy_reg_mutex);

drivers/firewire/ohci.c

3608

ohci_err(ohci, "invalid MMIO resource\n");

drivers/firewire/ohci.c

3612

ohci->registers = pcim_iomap_region(dev, 0, ohci_driver_name);

drivers/firewire/ohci.c

3613

if (IS_ERR(ohci->registers)) {

drivers/firewire/ohci.c

3614

ohci_err(ohci, "request and map MMIO resource unavailable\n");

drivers/firewire/ohci.c

3624

ohci->quirks = ohci_quirks[i].flags;

drivers/firewire/ohci.c

3628

ohci->quirks = param_quirks;

drivers/firewire/ohci.c

3631

ohci->quirks |= QUIRK_REBOOT_BY_CYCLE_TIMER_READ;

drivers/firewire/ohci.c

3640

ohci->misc_buffer = dmam_alloc_coherent(&dev->dev, PAGE_SIZE, &ohci->misc_buffer_bus,

drivers/firewire/ohci.c

3642

if (!ohci->misc_buffer)

drivers/firewire/ohci.c

3645

err = ar_context_init(&ohci->ar_request_ctx, ohci, 0,

drivers/firewire/ohci.c

3650

err = ar_context_init(&ohci->ar_response_ctx, ohci, PAGE_SIZE/4,

drivers/firewire/ohci.c

3655

err = context_init(&ohci->at_request_ctx.context, ohci,

drivers/firewire/ohci.c

3659

INIT_WORK(&ohci->at_request_ctx.work, ohci_at_context_work);

drivers/firewire/ohci.c

3661

err = context_init(&ohci->at_response_ctx.context, ohci,

drivers/firewire/ohci.c

3665

INIT_WORK(&ohci->at_response_ctx.work, ohci_at_context_work);

drivers/firewire/ohci.c

3667

reg_write(ohci, OHCI1394_IsoRecvIntMaskSet, ~0);

drivers/firewire/ohci.c

3668

ohci->ir_context_channels = ~0ULL;

drivers/firewire/ohci.c

3669

ohci->ir_context_support = reg_read(ohci, OHCI1394_IsoRecvIntMaskSet);

drivers/firewire/ohci.c

3670

reg_write(ohci, OHCI1394_IsoRecvIntMaskClear, ~0);

drivers/firewire/ohci.c

3671

ohci->ir_context_mask = ohci->ir_context_support;

drivers/firewire/ohci.c

3672

ohci->n_ir = hweight32(ohci->ir_context_mask);

drivers/firewire/ohci.c

3673

ohci->ir_context_list = devm_kcalloc(&dev->dev, ohci->n_ir, sizeof(struct iso_context), GFP_KERNEL);

drivers/firewire/ohci.c

3674

if (!ohci->ir_context_list)

drivers/firewire/ohci.c

3677

reg_write(ohci, OHCI1394_IsoXmitIntMaskSet, ~0);

drivers/firewire/ohci.c

3678

ohci->it_context_support = reg_read(ohci, OHCI1394_IsoXmitIntMaskSet);

drivers/firewire/ohci.c

3680

if (!ohci->it_context_support) {

drivers/firewire/ohci.c

3681

ohci_notice(ohci, "overriding IsoXmitIntMask\n");

drivers/firewire/ohci.c

3682

ohci->it_context_support = 0xf;

drivers/firewire/ohci.c

3684

reg_write(ohci, OHCI1394_IsoXmitIntMaskClear, ~0);

drivers/firewire/ohci.c

3685

ohci->it_context_mask = ohci->it_context_support;

drivers/firewire/ohci.c

3686

ohci->n_it = hweight32(ohci->it_context_mask);

drivers/firewire/ohci.c

3687

ohci->it_context_list = devm_kcalloc(&dev->dev, ohci->n_it, sizeof(struct iso_context), GFP_KERNEL);

drivers/firewire/ohci.c

3688

if (!ohci->it_context_list)

drivers/firewire/ohci.c

3691

ohci->self_id = ohci->misc_buffer + PAGE_SIZE/2;

drivers/firewire/ohci.c

3692

ohci->self_id_bus = ohci->misc_buffer_bus + PAGE_SIZE/2;

drivers/firewire/ohci.c

3694

bus_options = reg_read(ohci, OHCI1394_BusOptions);

drivers/firewire/ohci.c

3697

guid = ((u64) reg_read(ohci, OHCI1394_GUIDHi) << 32) |

drivers/firewire/ohci.c

3698

reg_read(ohci, OHCI1394_GUIDLo);

drivers/firewire/ohci.c

3701

if (!(ohci->quirks & QUIRK_NO_MSI))

drivers/firewire/ohci.c

3716

ohci);

drivers/firewire/ohci.c

3718

ohci_err(ohci, "failed to allocate interrupt %d\n", irq);

drivers/firewire/ohci.c

3722

err = fw_card_add(&ohci->card, max_receive, link_speed, guid, ohci->n_it + ohci->n_ir);

drivers/firewire/ohci.c

3726

version = reg_read(ohci, OHCI1394_Version) & 0x00ff00ff;

drivers/firewire/ohci.c

3727

ohci_notice(ohci,

drivers/firewire/ohci.c

3730

version >> 16, version & 0xff, ohci->card.index,

drivers/firewire/ohci.c

3731

ohci->n_ir, ohci->n_it, ohci->quirks,

drivers/firewire/ohci.c

3732

reg_read(ohci, OHCI1394_PhyUpperBound) ?

drivers/firewire/ohci.c

3738

free_irq(irq, ohci);

drivers/firewire/ohci.c

3747

struct fw_ohci *ohci = pci_get_drvdata(dev);

drivers/firewire/ohci.c

3750

fw_core_remove_card(&ohci->card);

drivers/firewire/ohci.c

3752

software_reset(ohci);

drivers/firewire/ohci.c

3756

free_irq(irq, ohci);

drivers/firewire/ohci.c

3765

struct fw_ohci *ohci = pci_get_drvdata(pdev);

drivers/firewire/ohci.c

3767

software_reset(ohci);

drivers/firewire/ohci.c

3777

struct fw_ohci *ohci = pci_get_drvdata(pdev);

drivers/firewire/ohci.c

3783

if (!reg_read(ohci, OHCI1394_GUIDLo) &&

drivers/firewire/ohci.c

3784

!reg_read(ohci, OHCI1394_GUIDHi)) {

drivers/firewire/ohci.c

3785

reg_write(ohci, OHCI1394_GUIDLo, (u32)ohci->card.guid);

drivers/firewire/ohci.c

3786

reg_write(ohci, OHCI1394_GUIDHi, (u32)(ohci->card.guid >> 32));

drivers/firewire/ohci.c

3789

err = ohci_enable(&ohci->card, NULL, 0);

drivers/firewire/ohci.c

3793

ohci_resume_iso_dma(ohci);

drivers/firewire/ohci.c

404

static inline void reg_write(const struct fw_ohci *ohci, int offset, u32 data)

drivers/firewire/ohci.c

406

writel(data, ohci->registers + offset);

drivers/firewire/ohci.c

409

static inline u32 reg_read(const struct fw_ohci *ohci, int offset)

drivers/firewire/ohci.c

411

return readl(ohci->registers + offset);

drivers/firewire/ohci.c

414

static inline void flush_writes(const struct fw_ohci *ohci)

drivers/firewire/ohci.c

417

reg_read(ohci, OHCI1394_Version);

drivers/firewire/ohci.c

426

static int read_phy_reg(struct fw_ohci *ohci, int addr)

drivers/firewire/ohci.c

431

reg_write(ohci, OHCI1394_PhyControl, OHCI1394_PhyControl_Read(addr));

drivers/firewire/ohci.c

433

val = reg_read(ohci, OHCI1394_PhyControl);

drivers/firewire/ohci.c

447

ohci_err(ohci, "failed to read phy reg %d\n", addr);

drivers/firewire/ohci.c

453

static int write_phy_reg(const struct fw_ohci *ohci, int addr, u32 val)

drivers/firewire/ohci.c

457

reg_write(ohci, OHCI1394_PhyControl,

drivers/firewire/ohci.c

460

val = reg_read(ohci, OHCI1394_PhyControl);

drivers/firewire/ohci.c

470

ohci_err(ohci, "failed to write phy reg %d, val %u\n", addr, val);

drivers/firewire/ohci.c

476

static int update_phy_reg(struct fw_ohci *ohci, int addr,

drivers/firewire/ohci.c

479

int ret = read_phy_reg(ohci, addr);

drivers/firewire/ohci.c

490

return write_phy_reg(ohci, addr, (ret & ~clear_bits) | set_bits);

drivers/firewire/ohci.c

493

static int read_paged_phy_reg(struct fw_ohci *ohci, int page, int addr)

drivers/firewire/ohci.c

497

ret = update_phy_reg(ohci, 7, PHY_PAGE_SELECT, page << 5);

drivers/firewire/ohci.c

501

return read_phy_reg(ohci, addr);

drivers/firewire/ohci.c

506

struct fw_ohci *ohci = fw_ohci(card);

drivers/firewire/ohci.c

508

guard(mutex)(&ohci->phy_reg_mutex);

drivers/firewire/ohci.c

510

return read_phy_reg(ohci, addr);

drivers/firewire/ohci.c

516

struct fw_ohci *ohci = fw_ohci(card);

drivers/firewire/ohci.c

518

guard(mutex)(&ohci->phy_reg_mutex);

drivers/firewire/ohci.c

520

return update_phy_reg(ohci, addr, clear_bits, set_bits);

drivers/firewire/ohci.c

53

#define ohci_notice(ohci, f, args...) dev_notice(ohci->card.device, f, ##args)

drivers/firewire/ohci.c

538

reg_write(ctx->ohci, CONTROL_SET(ctx->regs), CONTEXT_WAKE);

drivers/firewire/ohci.c

54

#define ohci_err(ohci, f, args...) dev_err(ohci->card.device, f, ##args)

drivers/firewire/ohci.c

543

struct device *dev = ctx->ohci->card.device;

drivers/firewire/ohci.c

564

struct fw_ohci *ohci = ctx->ohci;

drivers/firewire/ohci.c

566

if (reg_read(ohci, CONTROL_CLEAR(ctx->regs)) & CONTEXT_RUN) {

drivers/firewire/ohci.c

567

reg_write(ohci, CONTROL_CLEAR(ctx->regs), CONTEXT_RUN);

drivers/firewire/ohci.c

568

flush_writes(ohci);

drivers/firewire/ohci.c

570

ohci_err(ohci, "AR error: %s; DMA stopped\n", error_msg);

drivers/firewire/ohci.c

652

dma_sync_single_for_cpu(ctx->ohci->card.device, ctx->dma_addrs[i], PAGE_SIZE,

drivers/firewire/ohci.c

657

dma_sync_single_for_cpu(ctx->ohci->card.device, ctx->dma_addrs[i],

drivers/firewire/ohci.c

667

static bool has_be_header_quirk(const struct fw_ohci *ohci)

drivers/firewire/ohci.c

669

return !!(ohci->quirks & QUIRK_BE_HEADERS);

drivers/firewire/ohci.c

677

static bool has_be_header_quirk(const struct fw_ohci *ohci)

drivers/firewire/ohci.c

685

struct fw_ohci *ohci = ctx->ohci;

drivers/firewire/ohci.c

690

p.header[0] = cond_le32_to_cpu(buffer[0], has_be_header_quirk(ohci));

drivers/firewire/ohci.c

691

p.header[1] = cond_le32_to_cpu(buffer[1], has_be_header_quirk(ohci));

drivers/firewire/ohci.c

692

p.header[2] = cond_le32_to_cpu(buffer[2], has_be_header_quirk(ohci));

drivers/firewire/ohci.c

704

p.header[3] = cond_le32_to_cpu(buffer[3], has_be_header_quirk(ohci));

drivers/firewire/ohci.c

713

p.header[3] = cond_le32_to_cpu(buffer[3], has_be_header_quirk(ohci));

drivers/firewire/ohci.c

738

status = cond_le32_to_cpu(buffer[length], has_be_header_quirk(ohci));

drivers/firewire/ohci.c

744

p.generation = ohci->request_generation;

drivers/firewire/ohci.c

767

if (!(ohci->quirks & QUIRK_RESET_PACKET))

drivers/firewire/ohci.c

768

ohci->request_generation = (p.header[2] >> 16) & 0xff;

drivers/firewire/ohci.c

769

} else if (ctx == &ohci->ar_request_ctx) {

drivers/firewire/ohci.c

770

fw_core_handle_request(&ohci->card, &p);

drivers/firewire/ohci.c

772

fw_core_handle_response(&ohci->card, &p);

drivers/firewire/ohci.c

798

dma_sync_single_for_device(ctx->ohci->card.device, ctx->dma_addrs[i], PAGE_SIZE,

drivers/firewire/ohci.c

846

static int ar_context_init(struct ar_context *ctx, struct fw_ohci *ohci,

drivers/firewire/ohci.c

849

struct device *dev = ohci->card.device;

drivers/firewire/ohci.c

857

ctx->ohci = ohci;

drivers/firewire/ohci.c

903

ctx->descriptors = ohci->misc_buffer + descriptors_offset;

drivers/firewire/ohci.c

904

ctx->descriptors_bus = ohci->misc_buffer_bus + descriptors_offset;

drivers/firewire/ohci.c

929

reg_write(ctx->ohci, COMMAND_PTR(ctx->regs), ctx->descriptors_bus | 1);

drivers/firewire/ohci.c

930

reg_write(ctx->ohci, CONTROL_SET(ctx->regs), CONTEXT_RUN);

drivers/firewire/ohci.c

96

struct fw_ohci *ohci;

drivers/firewire/ohci.c

979

guard(spinlock_irqsave)(&ctx->ohci->lock);

drivers/mfd/omap-usb-host.c

194

struct platform_device *ohci;

drivers/mfd/omap-usb-host.c

240

ohci = omap_usbhs_alloc_child(OMAP_OHCI_DEVICE, resources, 2, pdata,

drivers/mfd/omap-usb-host.c

242

if (!ohci) {

drivers/phy/samsung/phy-exynos5250-usb2.c

201

u32 ohci;

drivers/phy/samsung/phy-exynos5250-usb2.c

309

ohci = readl(drv->reg_phy + EXYNOS_5250_HOSTOHCICTRL);

drivers/phy/samsung/phy-exynos5250-usb2.c

311

ohci |= 0x1 << 3;

drivers/phy/samsung/phy-exynos5250-usb2.c

312

writel(ohci, drv->reg_phy + EXYNOS_5250_HOSTOHCICTRL);

drivers/usb/host/ohci-at91.c

184

struct ohci_hcd *ohci;

drivers/usb/host/ohci-at91.c

237

ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-at91.c

238

ohci->num_ports = board->ports;

drivers/usb/host/ohci-at91.c

245

ohci->hc_control = OHCI_CTRL_RWC;

drivers/usb/host/ohci-at91.c

617

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-at91.c

645

ohci->rh_state = OHCI_RH_HALTED;

drivers/usb/host/ohci-at91.c

648

(void) ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-da8xx.c

219

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-da8xx.c

233

ohci->num_ports = 1;

drivers/usb/host/ohci-da8xx.c

247

rh_a = ohci_readl(ohci, &ohci->regs->roothub.a);

drivers/usb/host/ohci-da8xx.c

256

ohci_writel(ohci, rh_a, &ohci->regs->roothub.a);

drivers/usb/host/ohci-da8xx.c

468

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-da8xx.c

473

if (time_before(jiffies, ohci->next_statechange))

drivers/usb/host/ohci-da8xx.c

475

ohci->next_statechange = jiffies;

drivers/usb/host/ohci-da8xx.c

490

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-da8xx.c

493

if (time_before(jiffies, ohci->next_statechange))

drivers/usb/host/ohci-da8xx.c

495

ohci->next_statechange = jiffies;

drivers/usb/host/ohci-dbg.c

23

#define ohci_dbg_sw(ohci, next, size, format, arg...) \

drivers/usb/host/ohci-dbg.c

255

static void ohci_dump_td (const struct ohci_hcd *ohci, const char *label,

drivers/usb/host/ohci-dbg.c

258

u32 tmp = hc32_to_cpup (ohci, &td->hwINFO);

drivers/usb/host/ohci-dbg.c

260

ohci_dbg (ohci, "%s td %p%s; urb %p index %d; hw next td %08x\n",

drivers/usb/host/ohci-dbg.c

264

hc32_to_cpup (ohci, &td->hwNextTD));

drivers/usb/host/ohci-dbg.c

281

ohci_dbg (ohci, " info %08x CC=%x %s DI=%d %s %s\n", tmp,

drivers/usb/host/ohci-dbg.c

285

cbp = hc32_to_cpup (ohci, &td->hwCBP);

drivers/usb/host/ohci-dbg.c

286

be = hc32_to_cpup (ohci, &td->hwBE);

drivers/usb/host/ohci-dbg.c

287

ohci_dbg (ohci, " cbp %08x be %08x (len %d)\n", cbp, be,

drivers/usb/host/ohci-dbg.c

291

ohci_dbg (ohci, " info %08x CC=%x FC=%d DI=%d SF=%04x\n", tmp,

drivers/usb/host/ohci-dbg.c

296

ohci_dbg (ohci, " bp0 %08x be %08x\n",

drivers/usb/host/ohci-dbg.c

297

hc32_to_cpup (ohci, &td->hwCBP) & ~0x0fff,

drivers/usb/host/ohci-dbg.c

298

hc32_to_cpup (ohci, &td->hwBE));

drivers/usb/host/ohci-dbg.c

30

ohci_dbg(ohci,format, ## arg ); \

drivers/usb/host/ohci-dbg.c

300

u16 psw = ohci_hwPSW (ohci, td, i);

drivers/usb/host/ohci-dbg.c

302

ohci_dbg (ohci, " psw [%d] = %2x, CC=%x %s=%d\n", i,

drivers/usb/host/ohci-dbg.c

312

ohci_dump_ed (const struct ohci_hcd *ohci, const char *label,

drivers/usb/host/ohci-dbg.c

315

u32 tmp = hc32_to_cpu (ohci, ed->hwINFO);

drivers/usb/host/ohci-dbg.c

318

ohci_dbg (ohci, "%s, ed %p state 0x%x type %s; next ed %08x\n",

drivers/usb/host/ohci-dbg.c

321

hc32_to_cpup (ohci, &ed->hwNextED));

drivers/usb/host/ohci-dbg.c

327

ohci_dbg (ohci,

drivers/usb/host/ohci-dbg.c

337

tmp = hc32_to_cpup (ohci, &ed->hwHeadP);

drivers/usb/host/ohci-dbg.c

338

ohci_dbg (ohci, " tds: head %08x %s%s tail %08x%s\n",

drivers/usb/host/ohci-dbg.c

34

#define ohci_dbg_nosw(ohci, next, size, format, arg...) \

drivers/usb/host/ohci-dbg.c

342

hc32_to_cpup (ohci, &ed->hwTailP),

drivers/usb/host/ohci-dbg.c

353

ohci_dump_td (ohci, " ->", td);

drivers/usb/host/ohci-dbg.c

393

struct ohci_hcd *ohci;

drivers/usb/host/ohci-dbg.c

400

show_list (struct ohci_hcd *ohci, char *buf, size_t count, struct ed *ed)

drivers/usb/host/ohci-dbg.c

413

u32 info = hc32_to_cpu (ohci, ed->hwINFO);

drivers/usb/host/ohci-dbg.c

414

u32 headp = hc32_to_cpu (ohci, ed->hwHeadP);

drivers/usb/host/ohci-dbg.c

43

struct ohci_hcd *ohci,

drivers/usb/host/ohci-dbg.c

437

info = hc32_to_cpup (ohci, &td->hwINFO);

drivers/usb/host/ohci-dbg.c

438

cbp = hc32_to_cpup (ohci, &td->hwCBP);

drivers/usb/host/ohci-dbg.c

439

be = hc32_to_cpup (ohci, &td->hwBE);

drivers/usb/host/ohci-dbg.c

467

struct ohci_hcd *ohci;

drivers/usb/host/ohci-dbg.c

471

ohci = buf->ohci;

drivers/usb/host/ohci-dbg.c

475

spin_lock_irqsave (&ohci->lock, flags);

drivers/usb/host/ohci-dbg.c

476

temp = show_list(ohci, buf->page, size, ohci->ed_controltail);

drivers/usb/host/ohci-dbg.c

477

temp += show_list(ohci, buf->page + temp, size - temp,

drivers/usb/host/ohci-dbg.c

478

ohci->ed_bulktail);

drivers/usb/host/ohci-dbg.c

479

spin_unlock_irqrestore (&ohci->lock, flags);

drivers/usb/host/ohci-dbg.c

488

struct ohci_hcd *ohci;

drivers/usb/host/ohci-dbg.c

49

ohci_dbg_sw (ohci, next, size, "%s 0x%08x%s%s%s%s%s%s%s%s%s\n",

drivers/usb/host/ohci-dbg.c

500

ohci = buf->ohci;

drivers/usb/host/ohci-dbg.c

509

spin_lock_irqsave (&ohci->lock, flags);

drivers/usb/host/ohci-dbg.c

511

ed = ohci->periodic[i];

drivers/usb/host/ohci-dbg.c

515

temp = scnprintf (next, size, "%2d [%3d]:", i, ohci->load [i]);

drivers/usb/host/ohci-dbg.c

531

u32 info = hc32_to_cpu (ohci, ed->hwINFO);

drivers/usb/host/ohci-dbg.c

552

cpu_to_hc32(ohci, ED_H)) ?

drivers/usb/host/ohci-dbg.c

574

spin_unlock_irqrestore (&ohci->lock, flags);

drivers/usb/host/ohci-dbg.c

584

struct ohci_hcd *ohci;

drivers/usb/host/ohci-dbg.c

591

ohci = buf->ohci;

drivers/usb/host/ohci-dbg.c

592

hcd = ohci_to_hcd(ohci);

drivers/usb/host/ohci-dbg.c

593

regs = ohci->regs;

drivers/usb/host/ohci-dbg.c

597

spin_lock_irqsave (&ohci->lock, flags);

drivers/usb/host/ohci-dbg.c

601

ohci_dbg_nosw(ohci, &next, &size,

drivers/usb/host/ohci-dbg.c

616

ohci_dump_status(ohci, &next, &size);

drivers/usb/host/ohci-dbg.c

619

if (ohci->hcca)

drivers/usb/host/ohci-dbg.c

620

ohci_dbg_nosw(ohci, &next, &size,

drivers/usb/host/ohci-dbg.c

621

"hcca frame 0x%04x\n", ohci_frame_no(ohci));

drivers/usb/host/ohci-dbg.c

624

rdata = ohci_readl (ohci, &regs->fminterval);

drivers/usb/host/ohci-dbg.c

632

rdata = ohci_readl (ohci, &regs->fmremaining);

drivers/usb/host/ohci-dbg.c

639

rdata = ohci_readl (ohci, &regs->periodicstart);

drivers/usb/host/ohci-dbg.c

645

rdata = ohci_readl (ohci, &regs->lsthresh);

drivers/usb/host/ohci-dbg.c

65

struct ohci_hcd *ohci,

drivers/usb/host/ohci-dbg.c

652

HCD_POLL_RH(ohci_to_hcd(ohci)) ? "ON" : "off");

drivers/usb/host/ohci-dbg.c

657

ohci_dump_roothub (ohci, 1, &next, &size);

drivers/usb/host/ohci-dbg.c

660

spin_unlock_irqrestore (&ohci->lock, flags);

drivers/usb/host/ohci-dbg.c

665

static struct debug_buffer *alloc_buffer(struct ohci_hcd *ohci,

drivers/usb/host/ohci-dbg.c

673

buf->ohci = ohci;

drivers/usb/host/ohci-dbg.c

72

ohci_dbg_sw (ohci, next, size, "%s %08x\n", label, value);

drivers/usb/host/ohci-dbg.c

762

static inline void create_debug_files (struct ohci_hcd *ohci)

drivers/usb/host/ohci-dbg.c

764

struct usb_bus *bus = &ohci_to_hcd(ohci)->self;

drivers/usb/host/ohci-dbg.c

768

ohci->debug_dir = root;

drivers/usb/host/ohci-dbg.c

770

debugfs_create_file("async", S_IRUGO, root, ohci, &debug_async_fops);

drivers/usb/host/ohci-dbg.c

771

debugfs_create_file("periodic", S_IRUGO, root, ohci,

drivers/usb/host/ohci-dbg.c

773

debugfs_create_file("registers", S_IRUGO, root, ohci,

drivers/usb/host/ohci-dbg.c

776

ohci_dbg (ohci, "created debug files\n");

drivers/usb/host/ohci-dbg.c

779

static inline void remove_debug_files (struct ohci_hcd *ohci)

drivers/usb/host/ohci-dbg.c

781

debugfs_remove_recursive(ohci->debug_dir);

drivers/usb/host/ohci-dbg.c

86

static const char *rh_state_string(struct ohci_hcd *ohci)

drivers/usb/host/ohci-dbg.c

88

switch (ohci->rh_state) {

drivers/usb/host/ohci-hcd.c

1001

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hcd.c

1003

ohci_dump(ohci);

drivers/usb/host/ohci-hcd.c

1005

if (quirk_nec(ohci))

drivers/usb/host/ohci-hcd.c

1006

flush_work(&ohci->nec_work);

drivers/usb/host/ohci-hcd.c

1007

timer_delete_sync(&ohci->io_watchdog);

drivers/usb/host/ohci-hcd.c

1008

ohci->prev_frame_no = IO_WATCHDOG_OFF;

drivers/usb/host/ohci-hcd.c

1010

ohci_writel (ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);

drivers/usb/host/ohci-hcd.c

1011

ohci_usb_reset(ohci);

drivers/usb/host/ohci-hcd.c

1015

if (quirk_amdiso(ohci))

drivers/usb/host/ohci-hcd.c

1018

remove_debug_files (ohci);

drivers/usb/host/ohci-hcd.c

1019

ohci_mem_cleanup (ohci);

drivers/usb/host/ohci-hcd.c

1020

if (ohci->hcca) {

drivers/usb/host/ohci-hcd.c

1023

(unsigned long)ohci->hcca,

drivers/usb/host/ohci-hcd.c

1024

sizeof(*ohci->hcca));

drivers/usb/host/ohci-hcd.c

1027

sizeof(*ohci->hcca),

drivers/usb/host/ohci-hcd.c

1028

ohci->hcca, ohci->hcca_dma);

drivers/usb/host/ohci-hcd.c

1029

ohci->hcca = NULL;

drivers/usb/host/ohci-hcd.c

1030

ohci->hcca_dma = 0;

drivers/usb/host/ohci-hcd.c

1039

int ohci_restart(struct ohci_hcd *ohci)

drivers/usb/host/ohci-hcd.c

1045

ohci_init(ohci);

drivers/usb/host/ohci-hcd.c

1046

spin_lock_irq(&ohci->lock);

drivers/usb/host/ohci-hcd.c

1047

ohci->rh_state = OHCI_RH_HALTED;

drivers/usb/host/ohci-hcd.c

1050

if (!list_empty (&ohci->pending))

drivers/usb/host/ohci-hcd.c

1051

ohci_dbg(ohci, "abort schedule...\n");

drivers/usb/host/ohci-hcd.c

1052

list_for_each_entry (priv, &ohci->pending, pending) {

drivers/usb/host/ohci-hcd.c

1059

ed->hwINFO |= cpu_to_hc32(ohci, ED_DEQUEUE);

drivers/usb/host/ohci-hcd.c

1060

ed_deschedule (ohci, ed);

drivers/usb/host/ohci-hcd.c

1062

ed->ed_next = ohci->ed_rm_list;

drivers/usb/host/ohci-hcd.c

1064

ohci->ed_rm_list = ed;

drivers/usb/host/ohci-hcd.c

1069

ohci_dbg(ohci, "bogus ed %p state %d\n",

drivers/usb/host/ohci-hcd.c

1076

ohci_work(ohci);

drivers/usb/host/ohci-hcd.c

1077

spin_unlock_irq(&ohci->lock);

drivers/usb/host/ohci-hcd.c

1082

for (i = 0; i < NUM_INTS; i++) ohci->load [i] = 0;

drivers/usb/host/ohci-hcd.c

1083

for (i = 0; i < NUM_INTS; i++) ohci->hcca->int_table [i] = 0;

drivers/usb/host/ohci-hcd.c

1086

ohci->ed_rm_list = NULL;

drivers/usb/host/ohci-hcd.c

1089

ohci->ed_controltail = NULL;

drivers/usb/host/ohci-hcd.c

1090

ohci->ed_bulktail = NULL;

drivers/usb/host/ohci-hcd.c

1092

if ((temp = ohci_run (ohci)) < 0) {

drivers/usb/host/ohci-hcd.c

1093

ohci_err (ohci, "can't restart, %d\n", temp);

drivers/usb/host/ohci-hcd.c

1096

ohci_dbg(ohci, "restart complete\n");

drivers/usb/host/ohci-hcd.c

1107

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hcd.c

1115

spin_lock_irqsave (&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

1116

ohci_writel(ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);

drivers/usb/host/ohci-hcd.c

1117

(void)ohci_readl(ohci, &ohci->regs->intrdisable);

drivers/usb/host/ohci-hcd.c

1120

spin_unlock_irqrestore (&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

1135

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-hcd.c

1143

ohci_usb_reset(ohci);

drivers/usb/host/ohci-hcd.c

1146

ohci->hc_control = ohci_readl(ohci, &ohci->regs->control);

drivers/usb/host/ohci-hcd.c

1147

if (ohci->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {

drivers/usb/host/ohci-hcd.c

1150

switch (ohci->hc_control & OHCI_CTRL_HCFS) {

drivers/usb/host/ohci-hcd.c

1159

spin_lock_irq(&ohci->lock);

drivers/usb/host/ohci-hcd.c

1160

ohci_rh_resume(ohci);

drivers/usb/host/ohci-hcd.c

1161

ohci_rh_suspend(ohci, 0);

drivers/usb/host/ohci-hcd.c

1162

spin_unlock_irq(&ohci->lock);

drivers/usb/host/ohci-hcd.c

1167

ohci_dbg(ohci, "powerup ports\n");

drivers/usb/host/ohci-hcd.c

1168

for (port = 0; port < ohci->num_ports; port++)

drivers/usb/host/ohci-hcd.c

1169

ohci_writel(ohci, RH_PS_PPS,

drivers/usb/host/ohci-hcd.c

1170

&ohci->regs->roothub.portstatus[port]);

drivers/usb/host/ohci-hcd.c

1172

ohci_writel(ohci, OHCI_INTR_MIE, &ohci->regs->intrenable);

drivers/usb/host/ohci-hcd.c

1173

ohci_readl(ohci, &ohci->regs->intrenable);

drivers/usb/host/ohci-hcd.c

152

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hcd.c

161

ed = ed_get(ohci, urb->ep, urb->dev, pipe, urb->interval);

drivers/usb/host/ohci-hcd.c

202

urb_priv->td [i] = td_alloc (ohci, mem_flags);

drivers/usb/host/ohci-hcd.c

205

urb_free_priv (ohci, urb_priv);

drivers/usb/host/ohci-hcd.c

210

spin_lock_irqsave (&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

217

if (ohci->rh_state != OHCI_RH_RUNNING) {

drivers/usb/host/ohci-hcd.c

227

retval = ed_schedule (ohci, ed);

drivers/usb/host/ohci-hcd.c

234

if (ohci->prev_frame_no == IO_WATCHDOG_OFF &&

drivers/usb/host/ohci-hcd.c

235

list_empty(&ohci->eds_in_use) &&

drivers/usb/host/ohci-hcd.c

236

!(ohci->flags & OHCI_QUIRK_QEMU)) {

drivers/usb/host/ohci-hcd.c

237

ohci->prev_frame_no = ohci_frame_no(ohci);

drivers/usb/host/ohci-hcd.c

238

mod_timer(&ohci->io_watchdog,

drivers/usb/host/ohci-hcd.c

241

list_add(&ed->in_use_list, &ohci->eds_in_use);

drivers/usb/host/ohci-hcd.c

244

u16 frame = ohci_frame_no(ohci);

drivers/usb/host/ohci-hcd.c

254

u16 next = ohci_frame_no(ohci) + 1;

drivers/usb/host/ohci-hcd.c

283

ohci_dbg(ohci, "iso underrun %p (%u+%u < %u)\n",

drivers/usb/host/ohci-hcd.c

298

td_submit_urb (ohci, urb);

drivers/usb/host/ohci-hcd.c

302

urb_free_priv (ohci, urb_priv);

drivers/usb/host/ohci-hcd.c

303

spin_unlock_irqrestore (&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

315

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hcd.c

320

spin_lock_irqsave (&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

330

start_ed_unlink(ohci, urb_priv->ed);

drivers/usb/host/ohci-hcd.c

332

if (ohci->rh_state != OHCI_RH_RUNNING) {

drivers/usb/host/ohci-hcd.c

334

ohci_work(ohci);

drivers/usb/host/ohci-hcd.c

337

spin_unlock_irqrestore (&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

350

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hcd.c

362

spin_lock_irqsave (&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

364

if (ohci->rh_state != OHCI_RH_RUNNING) {

drivers/usb/host/ohci-hcd.c

367

ohci_work(ohci);

drivers/usb/host/ohci-hcd.c

374

ohci_warn(ohci, "ED unlink timeout\n");

drivers/usb/host/ohci-hcd.c

377

spin_unlock_irqrestore (&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

382

td_free (ohci, ed->dummy);

drivers/usb/host/ohci-hcd.c

383

ed_free (ohci, ed);

drivers/usb/host/ohci-hcd.c

391

ohci_err (ohci, "leak ed %p (#%02x) state %d%s\n",

drivers/usb/host/ohci-hcd.c

394

td_free (ohci, ed->dummy);

drivers/usb/host/ohci-hcd.c

398

spin_unlock_irqrestore (&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

403

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hcd.c

405

return ohci_frame_no(ohci);

drivers/usb/host/ohci-hcd.c

408

static void ohci_usb_reset (struct ohci_hcd *ohci)

drivers/usb/host/ohci-hcd.c

410

ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hcd.c

411

ohci->hc_control &= OHCI_CTRL_RWC;

drivers/usb/host/ohci-hcd.c

412

ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);

drivers/usb/host/ohci-hcd.c

413

ohci->rh_state = OHCI_RH_HALTED;

drivers/usb/host/ohci-hcd.c

422

struct ohci_hcd *ohci;

drivers/usb/host/ohci-hcd.c

424

ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hcd.c

425

ohci_writel(ohci, (u32) ~0, &ohci->regs->intrdisable);

drivers/usb/host/ohci-hcd.c

428

ohci_writel(ohci, OHCI_HCR, &ohci->regs->cmdstatus);

drivers/usb/host/ohci-hcd.c

429

ohci_readl(ohci, &ohci->regs->cmdstatus); /* flush the writes */

drivers/usb/host/ohci-hcd.c

432

ohci_writel(ohci, ohci->fminterval, &ohci->regs->fminterval);

drivers/usb/host/ohci-hcd.c

433

ohci->rh_state = OHCI_RH_HALTED;

drivers/usb/host/ohci-hcd.c

438

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-hcd.c

441

spin_lock_irqsave(&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

443

spin_unlock_irqrestore(&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

452

static int ohci_init (struct ohci_hcd *ohci)

drivers/usb/host/ohci-hcd.c

455

struct usb_hcd *hcd = ohci_to_hcd(ohci);

drivers/usb/host/ohci-hcd.c

462

ohci->flags |= OHCI_QUIRK_HUB_POWER;

drivers/usb/host/ohci-hcd.c

464

ohci->rh_state = OHCI_RH_HALTED;

drivers/usb/host/ohci-hcd.c

465

ohci->regs = hcd->regs;

drivers/usb/host/ohci-hcd.c

473

if (!no_handshake && ohci_readl (ohci,

drivers/usb/host/ohci-hcd.c

474

&ohci->regs->control) & OHCI_CTRL_IR) {

drivers/usb/host/ohci-hcd.c

477

ohci_dbg (ohci, "USB HC TakeOver from BIOS/SMM\n");

drivers/usb/host/ohci-hcd.c

485

ohci_writel (ohci, OHCI_INTR_OC, &ohci->regs->intrenable);

drivers/usb/host/ohci-hcd.c

486

ohci_writel (ohci, OHCI_OCR, &ohci->regs->cmdstatus);

drivers/usb/host/ohci-hcd.c

487

while (ohci_readl (ohci, &ohci->regs->control) & OHCI_CTRL_IR) {

drivers/usb/host/ohci-hcd.c

490

ohci_err (ohci, "USB HC takeover failed!"

drivers/usb/host/ohci-hcd.c

495

ohci_usb_reset (ohci);

drivers/usb/host/ohci-hcd.c

500

ohci_writel (ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);

drivers/usb/host/ohci-hcd.c

503

if (ohci_readl (ohci, &ohci->regs->control) & OHCI_CTRL_RWC)

drivers/usb/host/ohci-hcd.c

504

ohci->hc_control |= OHCI_CTRL_RWC;

drivers/usb/host/ohci-hcd.c

507

if (ohci->num_ports == 0)

drivers/usb/host/ohci-hcd.c

508

ohci->num_ports = roothub_a(ohci) & RH_A_NDP;

drivers/usb/host/ohci-hcd.c

510

if (ohci->hcca)

drivers/usb/host/ohci-hcd.c

513

timer_setup(&ohci->io_watchdog, io_watchdog_func, 0);

drivers/usb/host/ohci-hcd.c

514

ohci->prev_frame_no = IO_WATCHDOG_OFF;

drivers/usb/host/ohci-hcd.c

517

ohci->hcca = gen_pool_dma_alloc_align(hcd->localmem_pool,

drivers/usb/host/ohci-hcd.c

518

sizeof(*ohci->hcca),

drivers/usb/host/ohci-hcd.c

519

&ohci->hcca_dma, 256);

drivers/usb/host/ohci-hcd.c

521

ohci->hcca = dma_alloc_coherent(hcd->self.controller,

drivers/usb/host/ohci-hcd.c

522

sizeof(*ohci->hcca),

drivers/usb/host/ohci-hcd.c

523

&ohci->hcca_dma,

drivers/usb/host/ohci-hcd.c

525

if (!ohci->hcca)

drivers/usb/host/ohci-hcd.c

528

if ((ret = ohci_mem_init (ohci)) < 0)

drivers/usb/host/ohci-hcd.c

531

create_debug_files (ohci);

drivers/usb/host/ohci-hcd.c

543

static int ohci_run (struct ohci_hcd *ohci)

drivers/usb/host/ohci-hcd.c

546

int first = ohci->fminterval == 0;

drivers/usb/host/ohci-hcd.c

547

struct usb_hcd *hcd = ohci_to_hcd(ohci);

drivers/usb/host/ohci-hcd.c

549

ohci->rh_state = OHCI_RH_HALTED;

drivers/usb/host/ohci-hcd.c

554

val = ohci_readl (ohci, &ohci->regs->fminterval);

drivers/usb/host/ohci-hcd.c

555

ohci->fminterval = val & 0x3fff;

drivers/usb/host/ohci-hcd.c

556

if (ohci->fminterval != FI)

drivers/usb/host/ohci-hcd.c

557

ohci_dbg (ohci, "fminterval delta %d\n",

drivers/usb/host/ohci-hcd.c

558

ohci->fminterval - FI);

drivers/usb/host/ohci-hcd.c

559

ohci->fminterval |= FSMP (ohci->fminterval) << 16;

drivers/usb/host/ohci-hcd.c

569

if ((ohci->hc_control & OHCI_CTRL_RWC) != 0)

drivers/usb/host/ohci-hcd.c

572

switch (ohci->hc_control & OHCI_CTRL_HCFS) {

drivers/usb/host/ohci-hcd.c

578

ohci->hc_control &= OHCI_CTRL_RWC;

drivers/usb/host/ohci-hcd.c

579

ohci->hc_control |= OHCI_USB_RESUME;

drivers/usb/host/ohci-hcd.c

584

ohci->hc_control &= OHCI_CTRL_RWC;

drivers/usb/host/ohci-hcd.c

585

ohci->hc_control |= OHCI_USB_RESET;

drivers/usb/host/ohci-hcd.c

589

ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);

drivers/usb/host/ohci-hcd.c

591

(void) ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hcd.c

594

memset (ohci->hcca, 0, sizeof (struct ohci_hcca));

drivers/usb/host/ohci-hcd.c

597

spin_lock_irq (&ohci->lock);

drivers/usb/host/ohci-hcd.c

601

ohci_writel (ohci, OHCI_HCR, &ohci->regs->cmdstatus);

drivers/usb/host/ohci-hcd.c

603

while ((ohci_readl (ohci, &ohci->regs->cmdstatus) & OHCI_HCR) != 0) {

drivers/usb/host/ohci-hcd.c

605

spin_unlock_irq (&ohci->lock);

drivers/usb/host/ohci-hcd.c

606

ohci_err (ohci, "USB HC reset timed out!\n");

drivers/usb/host/ohci-hcd.c

621

if (ohci->flags & OHCI_QUIRK_INITRESET) {

drivers/usb/host/ohci-hcd.c

622

ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);

drivers/usb/host/ohci-hcd.c

624

(void) ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hcd.c

629

ohci_writel (ohci, 0, &ohci->regs->ed_controlhead);

drivers/usb/host/ohci-hcd.c

630

ohci_writel (ohci, 0, &ohci->regs->ed_bulkhead);

drivers/usb/host/ohci-hcd.c

633

ohci_writel (ohci, (u32) ohci->hcca_dma, &ohci->regs->hcca);

drivers/usb/host/ohci-hcd.c

635

periodic_reinit (ohci);

drivers/usb/host/ohci-hcd.c

640

if ((ohci_readl (ohci, &ohci->regs->fminterval) & 0x3fff0000) == 0

drivers/usb/host/ohci-hcd.c

641

|| !ohci_readl (ohci, &ohci->regs->periodicstart)) {

drivers/usb/host/ohci-hcd.c

642

if (!(ohci->flags & OHCI_QUIRK_INITRESET)) {

drivers/usb/host/ohci-hcd.c

643

ohci->flags |= OHCI_QUIRK_INITRESET;

drivers/usb/host/ohci-hcd.c

644

ohci_dbg (ohci, "enabling initreset quirk\n");

drivers/usb/host/ohci-hcd.c

647

spin_unlock_irq (&ohci->lock);

drivers/usb/host/ohci-hcd.c

648

ohci_err (ohci, "init err (%08x %04x)\n",

drivers/usb/host/ohci-hcd.c

649

ohci_readl (ohci, &ohci->regs->fminterval),

drivers/usb/host/ohci-hcd.c

650

ohci_readl (ohci, &ohci->regs->periodicstart));

drivers/usb/host/ohci-hcd.c

659

ohci->hc_control &= OHCI_CTRL_RWC;

drivers/usb/host/ohci-hcd.c

660

ohci->hc_control |= OHCI_CONTROL_INIT | OHCI_USB_OPER;

drivers/usb/host/ohci-hcd.c

661

ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);

drivers/usb/host/ohci-hcd.c

662

ohci->rh_state = OHCI_RH_RUNNING;

drivers/usb/host/ohci-hcd.c

665

ohci_writel (ohci, RH_HS_DRWE, &ohci->regs->roothub.status);

drivers/usb/host/ohci-hcd.c

669

ohci_writel (ohci, ~0, &ohci->regs->intrstatus);

drivers/usb/host/ohci-hcd.c

670

ohci_writel (ohci, mask, &ohci->regs->intrenable);

drivers/usb/host/ohci-hcd.c

673

val = roothub_a (ohci);

drivers/usb/host/ohci-hcd.c

677

if (ohci->flags & OHCI_QUIRK_SUPERIO) {

drivers/usb/host/ohci-hcd.c

683

} else if ((ohci->flags & OHCI_QUIRK_AMD756) ||

drivers/usb/host/ohci-hcd.c

684

(ohci->flags & OHCI_QUIRK_HUB_POWER)) {

drivers/usb/host/ohci-hcd.c

690

ohci_writel(ohci, val, &ohci->regs->roothub.a);

drivers/usb/host/ohci-hcd.c

692

ohci_writel (ohci, RH_HS_LPSC, &ohci->regs->roothub.status);

drivers/usb/host/ohci-hcd.c

693

ohci_writel (ohci, (val & RH_A_NPS) ? 0 : RH_B_PPCM,

drivers/usb/host/ohci-hcd.c

694

&ohci->regs->roothub.b);

drivers/usb/host/ohci-hcd.c

696

(void) ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hcd.c

698

ohci->next_statechange = jiffies + STATECHANGE_DELAY;

drivers/usb/host/ohci-hcd.c

699

spin_unlock_irq (&ohci->lock);

drivers/usb/host/ohci-hcd.c

704

ohci_dump(ohci);

drivers/usb/host/ohci-hcd.c

713

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-hcd.c

715

ohci_hcd_init(ohci);

drivers/usb/host/ohci-hcd.c

717

return ohci_init(ohci);

drivers/usb/host/ohci-hcd.c

724

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-hcd.c

727

ret = ohci_run(ohci);

drivers/usb/host/ohci-hcd.c

729

ohci_err(ohci, "can't start\n");

drivers/usb/host/ohci-hcd.c

749

struct ohci_hcd *ohci = timer_container_of(ohci, t,

drivers/usb/host/ohci-hcd.c

759

spin_lock_irqsave(&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

768

status = ohci_readl(ohci, &ohci->regs->intrstatus);

drivers/usb/host/ohci-hcd.c

769

if (!(status & OHCI_INTR_WDH) && ohci->wdh_cnt == ohci->prev_wdh_cnt) {

drivers/usb/host/ohci-hcd.c

770

if (ohci->prev_donehead) {

drivers/usb/host/ohci-hcd.c

771

ohci_err(ohci, "HcDoneHead not written back; disabled\n");

drivers/usb/host/ohci-hcd.c

773

usb_hc_died(ohci_to_hcd(ohci));

drivers/usb/host/ohci-hcd.c

774

ohci_dump(ohci);

drivers/usb/host/ohci-hcd.c

775

_ohci_shutdown(ohci_to_hcd(ohci));

drivers/usb/host/ohci-hcd.c

784

list_for_each_entry(ed, &ohci->eds_in_use, in_use_list) {

drivers/usb/host/ohci-hcd.c

787

OKAY_TO_TAKEBACK(ohci, ed)) {

drivers/usb/host/ohci-hcd.c

788

unsigned tmp = hc32_to_cpu(ohci, ed->hwINFO);

drivers/usb/host/ohci-hcd.c

790

ohci_dbg(ohci, "takeback pending TD for dev %d ep 0x%x\n",

drivers/usb/host/ohci-hcd.c

794

add_to_done_list(ohci, ed->pending_td);

drivers/usb/host/ohci-hcd.c

811

head = hc32_to_cpu(ohci, READ_ONCE(ed->hwHeadP)) & TD_MASK;

drivers/usb/host/ohci-hcd.c

825

ed->takeback_wdh_cnt = ohci->wdh_cnt + 2;

drivers/usb/host/ohci-hcd.c

83

static void ohci_dump(struct ohci_hcd *ohci);

drivers/usb/host/ohci-hcd.c

830

ohci_work(ohci);

drivers/usb/host/ohci-hcd.c

832

if (ohci->rh_state == OHCI_RH_RUNNING) {

drivers/usb/host/ohci-hcd.c

842

frame_no = ohci_frame_no(ohci);

drivers/usb/host/ohci-hcd.c

843

if (frame_no == ohci->prev_frame_no) {

drivers/usb/host/ohci-hcd.c

848

for (i = 0; i < ohci->num_ports; ++i) {

drivers/usb/host/ohci-hcd.c

849

tmp = roothub_portstatus(ohci, i);

drivers/usb/host/ohci-hcd.c

856

ohci_err(ohci, "frame counter not updating; disabled\n");

drivers/usb/host/ohci-hcd.c

860

if (!list_empty(&ohci->eds_in_use)) {

drivers/usb/host/ohci-hcd.c

862

ohci->prev_wdh_cnt = ohci->wdh_cnt;

drivers/usb/host/ohci-hcd.c

863

ohci->prev_donehead = ohci_readl(ohci,

drivers/usb/host/ohci-hcd.c

864

&ohci->regs->donehead);

drivers/usb/host/ohci-hcd.c

865

mod_timer(&ohci->io_watchdog,

drivers/usb/host/ohci-hcd.c

871

ohci->prev_frame_no = prev_frame_no;

drivers/usb/host/ohci-hcd.c

872

spin_unlock_irqrestore(&ohci->lock, flags);

drivers/usb/host/ohci-hcd.c

879

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hcd.c

880

struct ohci_regs __iomem *regs = ohci->regs;

drivers/usb/host/ohci-hcd.c

887

ints = ohci_readl(ohci, &regs->intrstatus);

drivers/usb/host/ohci-hcd.c

894

ohci->rh_state = OHCI_RH_HALTED;

drivers/usb/host/ohci-hcd.c

895

ohci_dbg (ohci, "device removed!\n");

drivers/usb/host/ohci-hcd.c

901

ints &= ohci_readl(ohci, &regs->intrenable);

drivers/usb/host/ohci-hcd.c

904

if (ints == 0 || unlikely(ohci->rh_state == OHCI_RH_HALTED))

drivers/usb/host/ohci-hcd.c

909

if (quirk_nec(ohci)) {

drivers/usb/host/ohci-hcd.c

913

ohci_err (ohci, "OHCI Unrecoverable Error, scheduling NEC chip restart\n");

drivers/usb/host/ohci-hcd.c

915

ohci_writel (ohci, OHCI_INTR_UE, &regs->intrdisable);

drivers/usb/host/ohci-hcd.c

917

schedule_work (&ohci->nec_work);

drivers/usb/host/ohci-hcd.c

919

ohci_err (ohci, "OHCI Unrecoverable Error, disabled\n");

drivers/usb/host/ohci-hcd.c

920

ohci->rh_state = OHCI_RH_HALTED;

drivers/usb/host/ohci-hcd.c

924

ohci_dump(ohci);

drivers/usb/host/ohci-hcd.c

925

ohci_usb_reset (ohci);

drivers/usb/host/ohci-hcd.c

929

ohci_dbg(ohci, "rhsc\n");

drivers/usb/host/ohci-hcd.c

930

ohci->next_statechange = jiffies + STATECHANGE_DELAY;

drivers/usb/host/ohci-hcd.c

931

ohci_writel(ohci, OHCI_INTR_RD | OHCI_INTR_RHSC,

drivers/usb/host/ohci-hcd.c

942

ohci_writel(ohci, OHCI_INTR_RHSC, &regs->intrdisable);

drivers/usb/host/ohci-hcd.c

951

ohci_dbg(ohci, "resume detect\n");

drivers/usb/host/ohci-hcd.c

952

ohci_writel(ohci, OHCI_INTR_RD, &regs->intrstatus);

drivers/usb/host/ohci-hcd.c

954

if (ohci->autostop) {

drivers/usb/host/ohci-hcd.c

955

spin_lock (&ohci->lock);

drivers/usb/host/ohci-hcd.c

956

ohci_rh_resume (ohci);

drivers/usb/host/ohci-hcd.c

957

spin_unlock (&ohci->lock);

drivers/usb/host/ohci-hcd.c

962

spin_lock(&ohci->lock);

drivers/usb/host/ohci-hcd.c

964

update_done_list(ohci);

drivers/usb/host/ohci-hcd.c

971

ohci_work(ohci);

drivers/usb/host/ohci-hcd.c

972

if ((ints & OHCI_INTR_SF) != 0 && !ohci->ed_rm_list

drivers/usb/host/ohci-hcd.c

973

&& ohci->rh_state == OHCI_RH_RUNNING)

drivers/usb/host/ohci-hcd.c

974

ohci_writel (ohci, OHCI_INTR_SF, &regs->intrdisable);

drivers/usb/host/ohci-hcd.c

976

if (ohci->rh_state == OHCI_RH_RUNNING) {

drivers/usb/host/ohci-hcd.c

977

ohci_writel (ohci, ints, &regs->intrstatus);

drivers/usb/host/ohci-hcd.c

979

++ohci->wdh_cnt;

drivers/usb/host/ohci-hcd.c

981

ohci_writel (ohci, OHCI_INTR_MIE, &regs->intrenable);

drivers/usb/host/ohci-hcd.c

983

(void) ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hcd.c

985

spin_unlock(&ohci->lock);

drivers/usb/host/ohci-hcd.c

988

if (ohci->rh_state != OHCI_RH_HALTED) {

drivers/usb/host/ohci-hcd.c

989

ints = ohci_readl(ohci, &regs->intrstatus);

drivers/usb/host/ohci-hcd.c

990

if (ints && (ints & ohci_readl(ohci, &regs->intrenable)))

drivers/usb/host/ohci-hub.c

102

if (ohci->flags & OHCI_QUIRK_GLOBAL_SUSPEND) {

drivers/usb/host/ohci-hub.c

103

__hc32 __iomem *portstat = ohci->regs->roothub.portstatus;

drivers/usb/host/ohci-hub.c

107

for (i = 0; i < ohci->num_ports; (++i, ++portstat)) {

drivers/usb/host/ohci-hub.c

108

temp = ohci_readl(ohci, portstat);

drivers/usb/host/ohci-hub.c

111

ohci_writel(ohci, RH_PS_PSS, portstat);

drivers/usb/host/ohci-hub.c

116

if (ohci_to_hcd(ohci)->self.root_hub->do_remote_wakeup || autostop) {

drivers/usb/host/ohci-hub.c

117

ohci->hc_control |= OHCI_CTRL_RWE;

drivers/usb/host/ohci-hub.c

119

ohci_writel(ohci, OHCI_INTR_RHSC | OHCI_INTR_RD,

drivers/usb/host/ohci-hub.c

120

&ohci->regs->intrdisable);

drivers/usb/host/ohci-hub.c

121

ohci->hc_control &= ~OHCI_CTRL_RWE;

drivers/usb/host/ohci-hub.c

127

ohci->hc_control &= ~OHCI_CTRL_HCFS;

drivers/usb/host/ohci-hub.c

128

ohci->hc_control |= OHCI_USB_SUSPEND;

drivers/usb/host/ohci-hub.c

129

ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

130

(void) ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

134

ohci->next_statechange = jiffies + msecs_to_jiffies (5);

drivers/usb/host/ohci-hub.c

135

ohci->autostop = 0;

drivers/usb/host/ohci-hub.c

136

ohci->rh_state = OHCI_RH_SUSPENDED;

drivers/usb/host/ohci-hub.c

152

static int ohci_rh_resume (struct ohci_hcd *ohci)

drivers/usb/host/ohci-hub.c

153

__releases(ohci->lock)

drivers/usb/host/ohci-hub.c

154

__acquires(ohci->lock)

drivers/usb/host/ohci-hub.c

156

struct usb_hcd *hcd = ohci_to_hcd (ohci);

drivers/usb/host/ohci-hub.c

159

int autostopped = ohci->autostop;

drivers/usb/host/ohci-hub.c

161

ohci->autostop = 0;

drivers/usb/host/ohci-hub.c

162

ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

164

if (ohci->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {

drivers/usb/host/ohci-hub.c

166

if (ohci->rh_state != OHCI_RH_RUNNING) {

drivers/usb/host/ohci-hub.c

167

ohci_dbg (ohci, "BIOS/SMM active, control %03x\n",

drivers/usb/host/ohci-hub.c

168

ohci->hc_control);

drivers/usb/host/ohci-hub.c

172

ohci_dbg (ohci, "duplicate resume\n");

drivers/usb/host/ohci-hub.c

175

} else switch (ohci->hc_control & OHCI_CTRL_HCFS) {

drivers/usb/host/ohci-hub.c

177

ohci->hc_control &= ~(OHCI_CTRL_HCFS|OHCI_SCHED_ENABLES);

drivers/usb/host/ohci-hub.c

178

ohci->hc_control |= OHCI_USB_RESUME;

drivers/usb/host/ohci-hub.c

179

ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

180

(void) ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

181

ohci_dbg (ohci, "%s root hub\n",

drivers/usb/host/ohci-hub.c

186

ohci_dbg(ohci, "%swakeup root hub\n",

drivers/usb/host/ohci-hub.c

191

ohci_dbg (ohci, "snapshot resume? reinit\n");

drivers/usb/host/ohci-hub.c

195

ohci_dbg (ohci, "lost power\n");

drivers/usb/host/ohci-hub.c

200

spin_unlock_irq (&ohci->lock);

drivers/usb/host/ohci-hub.c

201

status = ohci_restart (ohci);

drivers/usb/host/ohci-hub.c

205

spin_lock_irq (&ohci->lock);

drivers/usb/host/ohci-hub.c

213

spin_unlock_irq (&ohci->lock);

drivers/usb/host/ohci-hub.c

218

temp = ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

221

ohci_err (ohci, "controller won't resume\n");

drivers/usb/host/ohci-hub.c

222

spin_lock_irq(&ohci->lock);

drivers/usb/host/ohci-hub.c

227

ohci_writel (ohci, 0, &ohci->regs->ed_controlhead);

drivers/usb/host/ohci-hub.c

228

ohci_writel (ohci, 0, &ohci->regs->ed_controlcurrent);

drivers/usb/host/ohci-hub.c

229

ohci_writel (ohci, 0, &ohci->regs->ed_bulkhead);

drivers/usb/host/ohci-hub.c

230

ohci_writel (ohci, 0, &ohci->regs->ed_bulkcurrent);

drivers/usb/host/ohci-hub.c

231

ohci_writel (ohci, 0, &ohci->regs->ed_periodcurrent);

drivers/usb/host/ohci-hub.c

232

ohci_writel (ohci, (u32) ohci->hcca_dma, &ohci->regs->hcca);

drivers/usb/host/ohci-hub.c

235

periodic_reinit (ohci);

drivers/usb/host/ohci-hub.c

244

ohci_writel (ohci, OHCI_INTR_INIT, &ohci->regs->intrenable);

drivers/usb/host/ohci-hub.c

245

if (ohci->ed_rm_list)

drivers/usb/host/ohci-hub.c

246

ohci_writel (ohci, OHCI_INTR_SF, &ohci->regs->intrenable);

drivers/usb/host/ohci-hub.c

249

ohci_writel (ohci, OHCI_USB_OPER, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

250

(void) ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

254

temp = ohci->hc_control;

drivers/usb/host/ohci-hub.c

257

ohci->hc_control = temp;

drivers/usb/host/ohci-hub.c

258

ohci_writel (ohci, temp, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

259

(void) ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

264

spin_lock_irq (&ohci->lock);

drivers/usb/host/ohci-hub.c

269

ohci->next_statechange = jiffies + STATECHANGE_DELAY;

drivers/usb/host/ohci-hub.c

274

if (!ohci->ed_rm_list) {

drivers/usb/host/ohci-hub.c

275

if (ohci->ed_controltail) {

drivers/usb/host/ohci-hub.c

276

ohci_writel (ohci,

drivers/usb/host/ohci-hub.c

277

find_head (ohci->ed_controltail)->dma,

drivers/usb/host/ohci-hub.c

278

&ohci->regs->ed_controlhead);

drivers/usb/host/ohci-hub.c

282

if (ohci->ed_bulktail) {

drivers/usb/host/ohci-hub.c

283

ohci_writel (ohci, find_head (ohci->ed_bulktail)->dma,

drivers/usb/host/ohci-hub.c

284

&ohci->regs->ed_bulkhead);

drivers/usb/host/ohci-hub.c

292

ohci_dbg (ohci, "restarting schedules ... %08x\n", enables);

drivers/usb/host/ohci-hub.c

293

ohci->hc_control |= enables;

drivers/usb/host/ohci-hub.c

294

ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

296

ohci_writel (ohci, temp, &ohci->regs->cmdstatus);

drivers/usb/host/ohci-hub.c

297

(void) ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

300

ohci->rh_state = OHCI_RH_RUNNING;

drivers/usb/host/ohci-hub.c

306

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hub.c

309

spin_lock_irq (&ohci->lock);

drivers/usb/host/ohci-hub.c

314

rc = ohci_rh_suspend (ohci, 0);

drivers/usb/host/ohci-hub.c

315

spin_unlock_irq (&ohci->lock);

drivers/usb/host/ohci-hub.c

318

timer_delete_sync(&ohci->io_watchdog);

drivers/usb/host/ohci-hub.c

319

ohci->prev_frame_no = IO_WATCHDOG_OFF;

drivers/usb/host/ohci-hub.c

326

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hub.c

329

if (time_before (jiffies, ohci->next_statechange))

drivers/usb/host/ohci-hub.c

332

spin_lock_irq (&ohci->lock);

drivers/usb/host/ohci-hub.c

337

rc = ohci_rh_resume (ohci);

drivers/usb/host/ohci-hub.c

338

spin_unlock_irq (&ohci->lock);

drivers/usb/host/ohci-hub.c

347

static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,

drivers/usb/host/ohci-hub.c

357

rhsc_enable = ohci_readl(ohci, &ohci->regs->intrenable) &

drivers/usb/host/ohci-hub.c

360

switch (ohci->hc_control & OHCI_CTRL_HCFS) {

drivers/usb/host/ohci-hub.c

365

ohci_writel(ohci, rhsc_enable, &ohci->regs->intrenable);

drivers/usb/host/ohci-hub.c

371

if (!ohci->autostop) {

drivers/usb/host/ohci-hub.c

373

!device_may_wakeup(&ohci_to_hcd(ohci)

drivers/usb/host/ohci-hub.c

378

ohci->autostop = 1;

drivers/usb/host/ohci-hub.c

379

ohci->next_statechange = jiffies + HZ;

drivers/usb/host/ohci-hub.c

385

ohci->autostop = 0;

drivers/usb/host/ohci-hub.c

386

ohci->next_statechange = jiffies +

drivers/usb/host/ohci-hub.c

389

ohci->next_statechange)

drivers/usb/host/ohci-hub.c

390

&& !ohci->ed_rm_list

drivers/usb/host/ohci-hub.c

391

&& !(ohci->hc_control &

drivers/usb/host/ohci-hub.c

393

ohci_rh_suspend(ohci, 1);

drivers/usb/host/ohci-hub.c

404

if (ohci->autostop)

drivers/usb/host/ohci-hub.c

405

ohci_rh_resume(ohci);

drivers/usb/host/ohci-hub.c

407

usb_hcd_resume_root_hub(ohci_to_hcd(ohci));

drivers/usb/host/ohci-hub.c

410

} else if (!ohci->autostop &&

drivers/usb/host/ohci-hub.c

411

!ohci_to_hcd(ohci)->self.root_hub->

drivers/usb/host/ohci-hub.c

421

ohci_writel(ohci, rhsc_enable,

drivers/usb/host/ohci-hub.c

422

&ohci->regs->intrenable);

drivers/usb/host/ohci-hub.c

435

static inline int ohci_rh_resume(struct ohci_hcd *ohci)

drivers/usb/host/ohci-hub.c

443

static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,

drivers/usb/host/ohci-hub.c

447

if (ohci_readl(ohci, &ohci->regs->intrenable) & OHCI_INTR_RHSC)

drivers/usb/host/ohci-hub.c

458

ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrenable);

drivers/usb/host/ohci-hub.c

47

static int ohci_rh_suspend (struct ohci_hcd *ohci, int autostop)

drivers/usb/host/ohci-hub.c

470

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hub.c

476

spin_lock_irqsave (&ohci->lock, flags);

drivers/usb/host/ohci-hub.c

48

__releases(ohci->lock)

drivers/usb/host/ohci-hub.c

481

if ((ohci->flags & OHCI_QUIRK_AMD756)

drivers/usb/host/ohci-hub.c

482

&& (roothub_a (ohci) & RH_A_NDP) > MAX_ROOT_PORTS) {

drivers/usb/host/ohci-hub.c

483

ohci_warn (ohci, "bogus NDP, rereads as NDP=%d\n",

drivers/usb/host/ohci-hub.c

484

ohci_readl (ohci, &ohci->regs->roothub.a) & RH_A_NDP);

drivers/usb/host/ohci-hub.c

49

__acquires(ohci->lock)

drivers/usb/host/ohci-hub.c

490

if (roothub_status (ohci) & (RH_HS_LPSC | RH_HS_OCIC))

drivers/usb/host/ohci-hub.c

494

if (ohci->num_ports > 7) {

drivers/usb/host/ohci-hub.c

500

ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrstatus);

drivers/usb/host/ohci-hub.c

501

rhsc_status = ohci_readl(ohci, &ohci->regs->intrstatus) &

drivers/usb/host/ohci-hub.c

505

for (i = 0; i < ohci->num_ports; i++) {

drivers/usb/host/ohci-hub.c

506

u32 status = roothub_portstatus (ohci, i);

drivers/usb/host/ohci-hub.c

521

if (ohci_root_hub_state_changes(ohci, changed,

drivers/usb/host/ohci-hub.c

529

spin_unlock_irqrestore (&ohci->lock, flags);

drivers/usb/host/ohci-hub.c

53

ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

539

struct ohci_hcd *ohci,

drivers/usb/host/ohci-hub.c

54

switch (ohci->hc_control & OHCI_CTRL_HCFS) {

drivers/usb/host/ohci-hub.c

542

u32 rh = roothub_a (ohci);

drivers/usb/host/ohci-hub.c

549

desc->bNbrPorts = ohci->num_ports;

drivers/usb/host/ohci-hub.c

550

temp = 1 + (ohci->num_ports / 8);

drivers/usb/host/ohci-hub.c

56

ohci_dbg (ohci, "resume/suspend?\n");

drivers/usb/host/ohci-hub.c

565

rh = roothub_b (ohci);

drivers/usb/host/ohci-hub.c

569

if (ohci->num_ports > 7) {

drivers/usb/host/ohci-hub.c

57

ohci->hc_control &= ~OHCI_CTRL_HCFS;

drivers/usb/host/ohci-hub.c

58

ohci->hc_control |= OHCI_USB_RESET;

drivers/usb/host/ohci-hub.c

582

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hub.c

59

ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

590

status = ohci_readl(ohci, &ohci->regs->roothub.portstatus [port]);

drivers/usb/host/ohci-hub.c

595

ohci_writel(ohci, RH_PS_PRS, &ohci->regs->roothub.portstatus [port]);

drivers/usb/host/ohci-hub.c

60

(void) ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

620

static inline int root_port_reset (struct ohci_hcd *ohci, unsigned port)

drivers/usb/host/ohci-hub.c

622

__hc32 __iomem *portstat = &ohci->regs->roothub.portstatus [port];

drivers/usb/host/ohci-hub.c

624

u16 now = ohci_readl(ohci, &ohci->regs->fmnumber);

drivers/usb/host/ohci-hub.c

638

temp = ohci_readl (ohci, portstat);

drivers/usb/host/ohci-hub.c

64

ohci_dbg (ohci, "needs reinit!\n");

drivers/usb/host/ohci-hub.c

652

ohci_dbg(ohci,

drivers/usb/host/ohci-hub.c

661

ohci_writel (ohci, RH_PS_PRSC, portstat);

drivers/usb/host/ohci-hub.c

664

ohci_writel (ohci, RH_PS_PRS, portstat);

drivers/usb/host/ohci-hub.c

666

now = ohci_readl(ohci, &ohci->regs->fmnumber);

drivers/usb/host/ohci-hub.c

67

if (!ohci->autostop) {

drivers/usb/host/ohci-hub.c

68

ohci_dbg (ohci, "already suspended\n");

drivers/usb/host/ohci-hub.c

684

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-hub.c

685

int ports = ohci->num_ports;

drivers/usb/host/ohci-hub.c

696

ohci_writel (ohci, RH_HS_OCIC,

drivers/usb/host/ohci-hub.c

697

&ohci->regs->roothub.status);

drivers/usb/host/ohci-hub.c

72

ohci_dbg (ohci, "%s root hub\n",

drivers/usb/host/ohci-hub.c

738

ohci_writel (ohci, temp,

drivers/usb/host/ohci-hub.c

739

&ohci->regs->roothub.portstatus [wIndex]);

drivers/usb/host/ohci-hub.c

743

ohci_hub_descriptor (ohci, (struct usb_hub_descriptor *) buf);

drivers/usb/host/ohci-hub.c

746

temp = roothub_status (ohci) & ~(RH_HS_CRWE | RH_HS_DRWE);

drivers/usb/host/ohci-hub.c

753

temp = roothub_portstatus (ohci, wIndex);

drivers/usb/host/ohci-hub.c

757

dbg_port(ohci, "GetStatus", wIndex, temp);

drivers/usb/host/ohci-hub.c

76

if (!autostop && (ohci->hc_control & OHCI_SCHED_ENABLES)) {

drivers/usb/host/ohci-hub.c

77

ohci->hc_control &= ~OHCI_SCHED_ENABLES;

drivers/usb/host/ohci-hub.c

778

ohci->start_hnp(ohci);

drivers/usb/host/ohci-hub.c

78

ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

781

ohci_writel (ohci, RH_PS_PSS,

drivers/usb/host/ohci-hub.c

782

&ohci->regs->roothub.portstatus [wIndex]);

drivers/usb/host/ohci-hub.c

785

ohci_writel (ohci, RH_PS_PPS,

drivers/usb/host/ohci-hub.c

786

&ohci->regs->roothub.portstatus [wIndex]);

drivers/usb/host/ohci-hub.c

789

retval = root_port_reset (ohci, wIndex);

drivers/usb/host/ohci-hub.c

79

ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-hub.c

80

ohci_writel (ohci, OHCI_INTR_SF, &ohci->regs->intrstatus);

drivers/usb/host/ohci-hub.c

85

ohci_dbg (ohci, "stopping schedules ...\n");

drivers/usb/host/ohci-hub.c

86

ohci->autostop = 0;

drivers/usb/host/ohci-hub.c

87

spin_unlock_irq (&ohci->lock);

drivers/usb/host/ohci-hub.c

89

spin_lock_irq (&ohci->lock);

drivers/usb/host/ohci-hub.c

91

update_done_list(ohci);

drivers/usb/host/ohci-hub.c

92

ohci_work(ohci);

drivers/usb/host/ohci-hub.c

95

ohci_writel(ohci, OHCI_INTR_SF, &ohci->regs->intrdisable);

drivers/usb/host/ohci-mem.c

27

static void ohci_hcd_init (struct ohci_hcd *ohci)

drivers/usb/host/ohci-mem.c

29

ohci->next_statechange = jiffies;

drivers/usb/host/ohci-mem.c

30

spin_lock_init (&ohci->lock);

drivers/usb/host/ohci-mem.c

31

INIT_LIST_HEAD (&ohci->pending);

drivers/usb/host/ohci-mem.c

32

INIT_LIST_HEAD(&ohci->eds_in_use);

drivers/usb/host/ohci-mem.c

37

static int ohci_mem_init (struct ohci_hcd *ohci)

drivers/usb/host/ohci-mem.c

43

if (ohci_to_hcd(ohci)->localmem_pool)

drivers/usb/host/ohci-mem.c

46

ohci->td_cache = dma_pool_create ("ohci_td",

drivers/usb/host/ohci-mem.c

47

ohci_to_hcd(ohci)->self.controller,

drivers/usb/host/ohci-mem.c

51

if (!ohci->td_cache)

drivers/usb/host/ohci-mem.c

53

ohci->ed_cache = dma_pool_create ("ohci_ed",

drivers/usb/host/ohci-mem.c

54

ohci_to_hcd(ohci)->self.controller,

drivers/usb/host/ohci-mem.c

58

if (!ohci->ed_cache) {

drivers/usb/host/ohci-mem.c

59

dma_pool_destroy (ohci->td_cache);

drivers/usb/host/ohci-mem.c

65

static void ohci_mem_cleanup (struct ohci_hcd *ohci)

drivers/usb/host/ohci-mem.c

67

dma_pool_destroy(ohci->td_cache);

drivers/usb/host/ohci-mem.c

68

ohci->td_cache = NULL;

drivers/usb/host/ohci-mem.c

69

dma_pool_destroy(ohci->ed_cache);

drivers/usb/host/ohci-mem.c

70

ohci->ed_cache = NULL;

drivers/usb/host/ohci-omap.c

114

&ohci_to_hcd(ohci)->self);

drivers/usb/host/ohci-omap.c

125

ohci->start_hnp = start_hnp;

drivers/usb/host/ohci-omap.c

138

ohci->hc_control = OHCI_CTRL_RWC;

drivers/usb/host/ohci-omap.c

139

writel(OHCI_CTRL_RWC, &ohci->regs->control);

drivers/usb/host/ohci-omap.c

144

u32 rh = roothub_a (ohci);

drivers/usb/host/ohci-omap.c

151

ohci_to_hcd(ohci)->power_budget = 250;

drivers/usb/host/ohci-omap.c

161

ohci_writel(ohci, rh, &ohci->regs->roothub.a);

drivers/usb/host/ohci-omap.c

162

ohci->flags &= ~OHCI_QUIRK_HUB_POWER;

drivers/usb/host/ohci-omap.c

166

ohci_to_hcd(ohci)->power_budget = 0;

drivers/usb/host/ohci-omap.c

352

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-omap.c

357

if (time_before(jiffies, ohci->next_statechange))

drivers/usb/host/ohci-omap.c

359

ohci->next_statechange = jiffies;

drivers/usb/host/ohci-omap.c

372

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-omap.c

375

if (time_before(jiffies, ohci->next_statechange))

drivers/usb/host/ohci-omap.c

377

ohci->next_statechange = jiffies;

drivers/usb/host/ohci-omap.c

70

static void start_hnp(struct ohci_hcd *ohci)

drivers/usb/host/ohci-omap.c

72

struct usb_hcd *hcd = ohci_to_hcd(ohci);

drivers/usb/host/ohci-omap.c

81

writel (RH_PS_PSS, &ohci->regs->roothub.portstatus [port]);

drivers/usb/host/ohci-omap.c

92

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-pci.c

109

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-pci.c

117

ohci->flags |= OHCI_QUIRK_BE_MMIO;

drivers/usb/host/ohci-pci.c

118

ohci_dbg (ohci, "enabled big endian Toshiba quirk\n");

drivers/usb/host/ohci-pci.c

121

ohci_err (ohci, "unsupported big endian Toshiba quirk\n");

drivers/usb/host/ohci-pci.c

131

struct ohci_hcd *ohci = container_of(work, struct ohci_hcd, nec_work);

drivers/usb/host/ohci-pci.c

134

status = ohci_restart(ohci);

drivers/usb/host/ohci-pci.c

136

ohci_err(ohci, "Restarting NEC controller failed in %s, %d\n",

drivers/usb/host/ohci-pci.c

142

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-pci.c

144

ohci->flags |= OHCI_QUIRK_NEC;

drivers/usb/host/ohci-pci.c

145

INIT_WORK(&ohci->nec_work, ohci_quirk_nec_worker);

drivers/usb/host/ohci-pci.c

146

ohci_dbg (ohci, "enabled NEC chipset lost interrupt quirk\n");

drivers/usb/host/ohci-pci.c

153

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-pci.c

156

ohci->flags |= OHCI_QUIRK_AMD_PLL;

drivers/usb/host/ohci-pci.c

160

ohci->flags |= OHCI_QUIRK_AMD_PREFETCH;

drivers/usb/host/ohci-pci.c

161

ohci_dbg(ohci, "enabled AMD prefetch quirk\n");

drivers/usb/host/ohci-pci.c

164

ohci->flags |= OHCI_QUIRK_GLOBAL_SUSPEND;

drivers/usb/host/ohci-pci.c

189

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-pci.c

191

ohci->flags |= OHCI_QUIRK_QEMU;

drivers/usb/host/ohci-pci.c

192

ohci_dbg(ohci, "enabled qemu quirk\n");

drivers/usb/host/ohci-pci.c

263

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-pci.c

272

int (*quirk)(struct usb_hcd *ohci);

drivers/usb/host/ohci-pci.c

285

ohci->hc_control |= OHCI_CTRL_RWC;

drivers/usb/host/ohci-pci.c

46

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-pci.c

48

ohci->flags = OHCI_QUIRK_AMD756;

drivers/usb/host/ohci-pci.c

49

ohci_dbg (ohci, "AMD756 erratum 4 workaround\n");

drivers/usb/host/ohci-pci.c

61

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-pci.c

63

ohci_dbg (ohci, "WARNING: OPTi workarounds unavailable\n");

drivers/usb/host/ohci-pci.c

80

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-pci.c

82

ohci->flags |= OHCI_QUIRK_SUPERIO;

drivers/usb/host/ohci-pci.c

83

ohci_dbg (ohci, "Using NSC SuperIO setup\n");

drivers/usb/host/ohci-pci.c

96

struct ohci_hcd *ohci = hcd_to_ohci (hcd);

drivers/usb/host/ohci-pci.c

98

ohci->flags |= OHCI_QUIRK_ZFMICRO;

drivers/usb/host/ohci-pci.c

99

ohci_dbg(ohci, "enabled Compaq ZFMicro chipset quirks\n");

drivers/usb/host/ohci-platform.c

123

ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-platform.c

127

ohci->flags |= OHCI_QUIRK_BE_MMIO;

drivers/usb/host/ohci-platform.c

130

ohci->flags |= OHCI_QUIRK_BE_DESC;

drivers/usb/host/ohci-platform.c

133

ohci->flags |= OHCI_QUIRK_BE_MMIO | OHCI_QUIRK_BE_DESC;

drivers/usb/host/ohci-platform.c

136

ohci->flags |= OHCI_QUIRK_FRAME_NO;

drivers/usb/host/ohci-platform.c

140

ohci->hc_control = OHCI_CTRL_RWC;

drivers/usb/host/ohci-platform.c

143

&ohci->num_ports);

drivers/usb/host/ohci-platform.c

169

ohci->flags |= OHCI_QUIRK_BE_DESC;

drivers/usb/host/ohci-platform.c

171

ohci->flags |= OHCI_QUIRK_BE_MMIO;

drivers/usb/host/ohci-platform.c

173

ohci->flags |= OHCI_QUIRK_FRAME_NO;

drivers/usb/host/ohci-platform.c

175

ohci->num_ports = pdata->num_ports;

drivers/usb/host/ohci-platform.c

178

if (ohci->flags & OHCI_QUIRK_BE_MMIO) {

drivers/usb/host/ohci-platform.c

186

if (ohci->flags & OHCI_QUIRK_BE_DESC) {

drivers/usb/host/ohci-platform.c

94

struct ohci_hcd *ohci;

drivers/usb/host/ohci-ppc-of.c

131

ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-ppc-of.c

133

ohci->flags |= OHCI_QUIRK_BE_MMIO | OHCI_QUIRK_BE_DESC;

drivers/usb/host/ohci-ppc-of.c

135

ohci->flags |= OHCI_QUIRK_FRAME_NO;

drivers/usb/host/ohci-ppc-of.c

137

ohci->flags |= OHCI_QUIRK_FRAME_NO;

drivers/usb/host/ohci-ppc-of.c

140

ohci_hcd_init(ohci);

drivers/usb/host/ohci-ppc-of.c

163

writel_be((readl_be(&ohci->regs->control) |

drivers/usb/host/ohci-ppc-of.c

164

OHCI_USB_SUSPEND), &ohci->regs->control);

drivers/usb/host/ohci-ppc-of.c

165

(void) readl_be(&ohci->regs->control);

drivers/usb/host/ohci-ppc-of.c

26

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-ppc-of.c

29

if ((ret = ohci_init(ohci)) < 0)

drivers/usb/host/ohci-ppc-of.c

32

if ((ret = ohci_run(ohci)) < 0) {

drivers/usb/host/ohci-ppc-of.c

89

struct ohci_hcd *ohci;

drivers/usb/host/ohci-ps3.c

14

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-ps3.c

16

ohci->flags |= OHCI_QUIRK_BE_MMIO;

drivers/usb/host/ohci-ps3.c

17

ohci_hcd_init(ohci);

drivers/usb/host/ohci-ps3.c

18

return ohci_init(ohci);

drivers/usb/host/ohci-ps3.c

24

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-ps3.c

29

ohci_writel(ohci, 0x7f000000 | RH_A_PSM | RH_A_OCPM,

drivers/usb/host/ohci-ps3.c

30

&ohci->regs->roothub.a);

drivers/usb/host/ohci-ps3.c

31

ohci_writel(ohci, 0x00060000, &ohci->regs->roothub.b);

drivers/usb/host/ohci-ps3.c

33

result = ohci_run(ohci);

drivers/usb/host/ohci-pxa27x.c

409

struct ohci_hcd *ohci;

drivers/usb/host/ohci-pxa27x.c

473

ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-pxa27x.c

474

ohci->num_ports = 3;

drivers/usb/host/ohci-pxa27x.c

524

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-pxa27x.c

529

if (time_before(jiffies, ohci->next_statechange))

drivers/usb/host/ohci-pxa27x.c

531

ohci->next_statechange = jiffies;

drivers/usb/host/ohci-pxa27x.c

546

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-pxa27x.c

549

if (time_before(jiffies, ohci->next_statechange))

drivers/usb/host/ohci-pxa27x.c

551

ohci->next_statechange = jiffies;

drivers/usb/host/ohci-q.c

1002

head = hc32_to_cpu(ohci, ed->hwHeadP) & TD_MASK;

drivers/usb/host/ohci-q.c

1004

ohci->rh_state == OHCI_RH_RUNNING)

drivers/usb/host/ohci-q.c

1013

ed->hwHeadP &= ~cpu_to_hc32(ohci, ED_H);

drivers/usb/host/ohci-q.c

1016

ed->hwINFO &= ~cpu_to_hc32(ohci, ED_SKIP | ED_DEQUEUE);

drivers/usb/host/ohci-q.c

1054

savebits = *prev & ~cpu_to_hc32 (ohci, TD_MASK);

drivers/usb/host/ohci-q.c

1062

tdINFO = hc32_to_cpup(ohci, &td->hwINFO);

drivers/usb/host/ohci-q.c

1064

ed->hwHeadP &= ~cpu_to_hc32(ohci, ED_C);

drivers/usb/host/ohci-q.c

1066

ed->hwHeadP |= cpu_to_hc32(ohci, ED_C);

drivers/usb/host/ohci-q.c

1069

td_done (ohci, urb, td);

drivers/usb/host/ohci-q.c

1075

finish_urb(ohci, urb, 0);

drivers/usb/host/ohci-q.c

109

static int balance (struct ohci_hcd *ohci, int interval, int load)

drivers/usb/host/ohci-q.c

1090

} else if (ohci->rh_state == OHCI_RH_RUNNING) {

drivers/usb/host/ohci-q.c

1091

ed_schedule(ohci, ed);

drivers/usb/host/ohci-q.c

1093

ed->ed_next = ohci->ed_rm_list;

drivers/usb/host/ohci-q.c

1094

ohci->ed_rm_list = ed;

drivers/usb/host/ohci-q.c

1096

if (last == &ohci->ed_rm_list)

drivers/usb/host/ohci-q.c

1105

if (ohci->rh_state == OHCI_RH_RUNNING && !ohci->ed_rm_list) {

drivers/usb/host/ohci-q.c

1108

if (ohci->ed_controltail) {

drivers/usb/host/ohci-q.c

1110

if (quirk_zfmicro(ohci))

drivers/usb/host/ohci-q.c

1112

if (!(ohci->hc_control & OHCI_CTRL_CLE)) {

drivers/usb/host/ohci-q.c

1114

ohci_writel (ohci, 0,

drivers/usb/host/ohci-q.c

1115

&ohci->regs->ed_controlcurrent);

drivers/usb/host/ohci-q.c

1118

if (ohci->ed_bulktail) {

drivers/usb/host/ohci-q.c

1120

if (quirk_zfmicro(ohci))

drivers/usb/host/ohci-q.c

1122

if (!(ohci->hc_control & OHCI_CTRL_BLE)) {

drivers/usb/host/ohci-q.c

1124

ohci_writel (ohci, 0,

drivers/usb/host/ohci-q.c

1125

&ohci->regs->ed_bulkcurrent);

drivers/usb/host/ohci-q.c

1131

ohci->hc_control |= control;

drivers/usb/host/ohci-q.c

1132

if (quirk_zfmicro(ohci))

drivers/usb/host/ohci-q.c

1134

ohci_writel (ohci, ohci->hc_control,

drivers/usb/host/ohci-q.c

1135

&ohci->regs->control);

drivers/usb/host/ohci-q.c

1138

if (quirk_zfmicro(ohci))

drivers/usb/host/ohci-q.c

1140

ohci_writel (ohci, command, &ohci->regs->cmdstatus);

drivers/usb/host/ohci-q.c

1150

static void takeback_td(struct ohci_hcd *ohci, struct td *td)

drivers/usb/host/ohci-q.c

1158

status = td_done(ohci, urb, td);

drivers/usb/host/ohci-q.c

1163

finish_urb(ohci, urb, status);

drivers/usb/host/ohci-q.c

1168

start_ed_unlink(ohci, ed);

drivers/usb/host/ohci-q.c

1171

} else if ((ed->hwINFO & cpu_to_hc32(ohci, ED_SKIP | ED_DEQUEUE))

drivers/usb/host/ohci-q.c

1172

== cpu_to_hc32(ohci, ED_SKIP)) {

drivers/usb/host/ohci-q.c

1174

if (!(td->hwINFO & cpu_to_hc32(ohci, TD_DONE))) {

drivers/usb/host/ohci-q.c

1175

ed->hwINFO &= ~cpu_to_hc32(ohci, ED_SKIP);

drivers/usb/host/ohci-q.c

1179

ohci_writel(ohci, OHCI_CLF,

drivers/usb/host/ohci-q.c

1180

&ohci->regs->cmdstatus);

drivers/usb/host/ohci-q.c

1183

ohci_writel(ohci, OHCI_BLF,

drivers/usb/host/ohci-q.c

1184

&ohci->regs->cmdstatus);

drivers/usb/host/ohci-q.c

1198

static void process_done_list(struct ohci_hcd *ohci)

drivers/usb/host/ohci-q.c

1202

while (ohci->dl_start) {

drivers/usb/host/ohci-q.c

1203

td = ohci->dl_start;

drivers/usb/host/ohci-q.c

1204

if (td == ohci->dl_end)

drivers/usb/host/ohci-q.c

1205

ohci->dl_start = ohci->dl_end = NULL;

drivers/usb/host/ohci-q.c

1207

ohci->dl_start = td->next_dl_td;

drivers/usb/host/ohci-q.c

1209

takeback_td(ohci, td);

drivers/usb/host/ohci-q.c

121

if (branch < 0 || ohci->load [branch] > ohci->load [i]) {

drivers/usb/host/ohci-q.c

1217

static void ohci_work(struct ohci_hcd *ohci)

drivers/usb/host/ohci-q.c

1219

if (ohci->working) {

drivers/usb/host/ohci-q.c

1220

ohci->restart_work = 1;

drivers/usb/host/ohci-q.c

1223

ohci->working = 1;

drivers/usb/host/ohci-q.c

1226

process_done_list(ohci);

drivers/usb/host/ohci-q.c

1227

if (ohci->ed_rm_list)

drivers/usb/host/ohci-q.c

1228

finish_unlinks(ohci);

drivers/usb/host/ohci-q.c

1230

if (ohci->restart_work) {

drivers/usb/host/ohci-q.c

1231

ohci->restart_work = 0;

drivers/usb/host/ohci-q.c

1234

ohci->working = 0;

drivers/usb/host/ohci-q.c

126

if ((ohci->load [j] + load) > 900)

drivers/usb/host/ohci-q.c

143

static void periodic_link (struct ohci_hcd *ohci, struct ed *ed)

drivers/usb/host/ohci-q.c

147

ohci_dbg(ohci, "link %sed %p branch %d [%dus.], interval %d\n",

drivers/usb/host/ohci-q.c

148

(ed->hwINFO & cpu_to_hc32 (ohci, ED_ISO)) ? "iso " : "",

drivers/usb/host/ohci-q.c

152

struct ed **prev = &ohci->periodic [i];

drivers/usb/host/ohci-q.c

153

__hc32 *prev_p = &ohci->hcca->int_table [i];

drivers/usb/host/ohci-q.c

173

*prev_p = cpu_to_hc32(ohci, ed->dma);

drivers/usb/host/ohci-q.c

176

ohci->load [i] += ed->load;

drivers/usb/host/ohci-q.c

178

ohci_to_hcd(ohci)->self.bandwidth_allocated += ed->load / ed->interval;

drivers/usb/host/ohci-q.c

183

static int ed_schedule (struct ohci_hcd *ohci, struct ed *ed)

drivers/usb/host/ohci-q.c

204

if (ohci->ed_controltail == NULL) {

drivers/usb/host/ohci-q.c

205

WARN_ON (ohci->hc_control & OHCI_CTRL_CLE);

drivers/usb/host/ohci-q.c

206

ohci_writel (ohci, ed->dma,

drivers/usb/host/ohci-q.c

207

&ohci->regs->ed_controlhead);

drivers/usb/host/ohci-q.c

209

ohci->ed_controltail->ed_next = ed;

drivers/usb/host/ohci-q.c

210

ohci->ed_controltail->hwNextED = cpu_to_hc32 (ohci,

drivers/usb/host/ohci-q.c

213

ed->ed_prev = ohci->ed_controltail;

drivers/usb/host/ohci-q.c

214

if (!ohci->ed_controltail && !ohci->ed_rm_list) {

drivers/usb/host/ohci-q.c

216

ohci->hc_control |= OHCI_CTRL_CLE;

drivers/usb/host/ohci-q.c

217

ohci_writel (ohci, 0, &ohci->regs->ed_controlcurrent);

drivers/usb/host/ohci-q.c

218

ohci_writel (ohci, ohci->hc_control,

drivers/usb/host/ohci-q.c

219

&ohci->regs->control);

drivers/usb/host/ohci-q.c

221

ohci->ed_controltail = ed;

drivers/usb/host/ohci-q.c

225

if (ohci->ed_bulktail == NULL) {

drivers/usb/host/ohci-q.c

226

WARN_ON (ohci->hc_control & OHCI_CTRL_BLE);

drivers/usb/host/ohci-q.c

227

ohci_writel (ohci, ed->dma, &ohci->regs->ed_bulkhead);

drivers/usb/host/ohci-q.c

229

ohci->ed_bulktail->ed_next = ed;

drivers/usb/host/ohci-q.c

230

ohci->ed_bulktail->hwNextED = cpu_to_hc32 (ohci,

drivers/usb/host/ohci-q.c

233

ed->ed_prev = ohci->ed_bulktail;

drivers/usb/host/ohci-q.c

234

if (!ohci->ed_bulktail && !ohci->ed_rm_list) {

drivers/usb/host/ohci-q.c

236

ohci->hc_control |= OHCI_CTRL_BLE;

drivers/usb/host/ohci-q.c

237

ohci_writel (ohci, 0, &ohci->regs->ed_bulkcurrent);

drivers/usb/host/ohci-q.c

238

ohci_writel (ohci, ohci->hc_control,

drivers/usb/host/ohci-q.c

239

&ohci->regs->control);

drivers/usb/host/ohci-q.c

241

ohci->ed_bulktail = ed;

drivers/usb/host/ohci-q.c

247

branch = balance (ohci, ed->interval, ed->load);

drivers/usb/host/ohci-q.c

249

ohci_dbg (ohci,

drivers/usb/host/ohci-q.c

256

periodic_link (ohci, ed);

drivers/usb/host/ohci-q.c

270

static void periodic_unlink (struct ohci_hcd *ohci, struct ed *ed)

drivers/usb/host/ohci-q.c

276

struct ed **prev = &ohci->periodic [i];

drivers/usb/host/ohci-q.c

277

__hc32 *prev_p = &ohci->hcca->int_table [i];

drivers/usb/host/ohci-q.c

287

ohci->load [i] -= ed->load;

drivers/usb/host/ohci-q.c

289

ohci_to_hcd(ohci)->self.bandwidth_allocated -= ed->load / ed->interval;

drivers/usb/host/ohci-q.c

291

ohci_dbg(ohci, "unlink %sed %p branch %d [%dus.], interval %d\n",

drivers/usb/host/ohci-q.c

292

(ed->hwINFO & cpu_to_hc32 (ohci, ED_ISO)) ? "iso " : "",

drivers/usb/host/ohci-q.c

317

static void ed_deschedule (struct ohci_hcd *ohci, struct ed *ed)

drivers/usb/host/ohci-q.c

319

ed->hwINFO |= cpu_to_hc32 (ohci, ED_SKIP);

drivers/usb/host/ohci-q.c

338

ohci->hc_control &= ~OHCI_CTRL_CLE;

drivers/usb/host/ohci-q.c

339

ohci_writel (ohci, ohci->hc_control,

drivers/usb/host/ohci-q.c

340

&ohci->regs->control);

drivers/usb/host/ohci-q.c

343

ohci_writel (ohci,

drivers/usb/host/ohci-q.c

344

hc32_to_cpup (ohci, &ed->hwNextED),

drivers/usb/host/ohci-q.c

345

&ohci->regs->ed_controlhead);

drivers/usb/host/ohci-q.c

351

if (ohci->ed_controltail == ed) {

drivers/usb/host/ohci-q.c

352

ohci->ed_controltail = ed->ed_prev;

drivers/usb/host/ohci-q.c

353

if (ohci->ed_controltail)

drivers/usb/host/ohci-q.c

354

ohci->ed_controltail->ed_next = NULL;

drivers/usb/host/ohci-q.c

364

ohci->hc_control &= ~OHCI_CTRL_BLE;

drivers/usb/host/ohci-q.c

365

ohci_writel (ohci, ohci->hc_control,

drivers/usb/host/ohci-q.c

366

&ohci->regs->control);

drivers/usb/host/ohci-q.c

369

ohci_writel (ohci,

drivers/usb/host/ohci-q.c

370

hc32_to_cpup (ohci, &ed->hwNextED),

drivers/usb/host/ohci-q.c

371

&ohci->regs->ed_bulkhead);

drivers/usb/host/ohci-q.c

377

if (ohci->ed_bulktail == ed) {

drivers/usb/host/ohci-q.c

378

ohci->ed_bulktail = ed->ed_prev;

drivers/usb/host/ohci-q.c

379

if (ohci->ed_bulktail)

drivers/usb/host/ohci-q.c

380

ohci->ed_bulktail->ed_next = NULL;

drivers/usb/host/ohci-q.c

389

periodic_unlink (ohci, ed);

drivers/usb/host/ohci-q.c

401

struct ohci_hcd *ohci,

drivers/usb/host/ohci-q.c

41

finish_urb(struct ohci_hcd *ohci, struct urb *urb, int status)

drivers/usb/host/ohci-q.c

410

spin_lock_irqsave (&ohci->lock, flags);

drivers/usb/host/ohci-q.c

418

ed = ed_alloc (ohci, GFP_ATOMIC);

drivers/usb/host/ohci-q.c

42

__releases(ohci->lock)

drivers/usb/host/ohci-q.c

425

td = td_alloc (ohci, GFP_ATOMIC);

drivers/usb/host/ohci-q.c

428

ed_free (ohci, ed);

drivers/usb/host/ohci-q.c

43

__acquires(ohci->lock)

drivers/usb/host/ohci-q.c

433

ed->hwTailP = cpu_to_hc32 (ohci, td->td_dma);

drivers/usb/host/ohci-q.c

45

struct device *dev = ohci_to_hcd(ohci)->self.controller;

drivers/usb/host/ohci-q.c

466

ed->hwINFO = cpu_to_hc32(ohci, info);

drivers/usb/host/ohci-q.c

472

spin_unlock_irqrestore (&ohci->lock, flags);

drivers/usb/host/ohci-q.c

484

static void start_ed_unlink (struct ohci_hcd *ohci, struct ed *ed)

drivers/usb/host/ohci-q.c

486

ed->hwINFO |= cpu_to_hc32 (ohci, ED_DEQUEUE);

drivers/usb/host/ohci-q.c

487

ed_deschedule (ohci, ed);

drivers/usb/host/ohci-q.c

490

ed->ed_next = ohci->ed_rm_list;

drivers/usb/host/ohci-q.c

492

ohci->ed_rm_list = ed;

drivers/usb/host/ohci-q.c

495

ohci_writel (ohci, OHCI_INTR_SF, &ohci->regs->intrstatus);

drivers/usb/host/ohci-q.c

496

ohci_writel (ohci, OHCI_INTR_SF, &ohci->regs->intrenable);

drivers/usb/host/ohci-q.c

498

(void) ohci_readl (ohci, &ohci->regs->control);

drivers/usb/host/ohci-q.c

505

ed->tick = ohci_frame_no(ohci) + 1;

drivers/usb/host/ohci-q.c

516

td_fill (struct ohci_hcd *ohci, u32 info,

drivers/usb/host/ohci-q.c

52

urb_free_priv (ohci, urb->hcpriv);

drivers/usb/host/ohci-q.c

557

td->hwINFO = cpu_to_hc32 (ohci, info);

drivers/usb/host/ohci-q.c

559

td->hwCBP = cpu_to_hc32 (ohci, data & 0xFFFFF000);

drivers/usb/host/ohci-q.c

560

*ohci_hwPSWp(ohci, td, 0) = cpu_to_hc16 (ohci,

drivers/usb/host/ohci-q.c

563

td->hwCBP = cpu_to_hc32 (ohci, data);

drivers/usb/host/ohci-q.c

566

td->hwBE = cpu_to_hc32 (ohci, data + len - 1);

drivers/usb/host/ohci-q.c

569

td->hwNextTD = cpu_to_hc32 (ohci, td_pt->td_dma);

drivers/usb/host/ohci-q.c

576

td->td_hash = ohci->td_hash [hash];

drivers/usb/host/ohci-q.c

577

ohci->td_hash [hash] = td;

drivers/usb/host/ohci-q.c

59

ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs--;

drivers/usb/host/ohci-q.c

592

struct ohci_hcd *ohci,

drivers/usb/host/ohci-q.c

596

struct device *dev = ohci_to_hcd(ohci)->self.controller;

drivers/usb/host/ohci-q.c

60

if (ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0) {

drivers/usb/host/ohci-q.c

61

if (quirk_amdiso(ohci))

drivers/usb/host/ohci-q.c

613

urb_priv->ed->hwHeadP &= ~cpu_to_hc32 (ohci, ED_C);

drivers/usb/host/ohci-q.c

616

list_add (&urb_priv->pending, &ohci->pending);

drivers/usb/host/ohci-q.c

63

if (quirk_amdprefetch(ohci))

drivers/usb/host/ohci-q.c

648

periodic = ohci_to_hcd(ohci)->self.bandwidth_int_reqs++ == 0

drivers/usb/host/ohci-q.c

649

&& ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0;

drivers/usb/host/ohci-q.c

664

td_fill(ohci, info, data, n, urb, cnt);

drivers/usb/host/ohci-q.c

68

ohci_to_hcd(ohci)->self.bandwidth_int_reqs--;

drivers/usb/host/ohci-q.c

681

td_fill (ohci, info, 0, 0, urb, cnt);

drivers/usb/host/ohci-q.c

687

ohci_writel (ohci, OHCI_BLF, &ohci->regs->cmdstatus);

drivers/usb/host/ohci-q.c

696

td_fill (ohci, info, urb->setup_dma, 8, urb, cnt++);

drivers/usb/host/ohci-q.c

701

td_fill (ohci, info, data, data_len, urb, cnt++);

drivers/usb/host/ohci-q.c

706

td_fill (ohci, info, data, 0, urb, cnt++);

drivers/usb/host/ohci-q.c

709

ohci_writel (ohci, OHCI_CLF, &ohci->regs->cmdstatus);

drivers/usb/host/ohci-q.c

726

td_fill (ohci, TD_CC | TD_ISO | frame,

drivers/usb/host/ohci-q.c

73

usb_hcd_unlink_urb_from_ep(ohci_to_hcd(ohci), urb);

drivers/usb/host/ohci-q.c

730

if (ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0) {

drivers/usb/host/ohci-q.c

731

if (quirk_amdiso(ohci))

drivers/usb/host/ohci-q.c

733

if (quirk_amdprefetch(ohci))

drivers/usb/host/ohci-q.c

736

periodic = ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs++ == 0

drivers/usb/host/ohci-q.c

737

&& ohci_to_hcd(ohci)->self.bandwidth_int_reqs == 0;

drivers/usb/host/ohci-q.c

74

spin_unlock (&ohci->lock);

drivers/usb/host/ohci-q.c

744

ohci->hc_control |= OHCI_CTRL_PLE|OHCI_CTRL_IE;

drivers/usb/host/ohci-q.c

745

ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);

drivers/usb/host/ohci-q.c

75

usb_hcd_giveback_urb(ohci_to_hcd(ohci), urb, status);

drivers/usb/host/ohci-q.c

756

static int td_done(struct ohci_hcd *ohci, struct urb *urb, struct td *td)

drivers/usb/host/ohci-q.c

758

u32 tdINFO = hc32_to_cpup (ohci, &td->hwINFO);

drivers/usb/host/ohci-q.c

76

spin_lock (&ohci->lock);

drivers/usb/host/ohci-q.c

766

u16 tdPSW = ohci_hwPSW(ohci, td, 0);

drivers/usb/host/ohci-q.c

79

if (ohci_to_hcd(ohci)->self.bandwidth_isoc_reqs == 0

drivers/usb/host/ohci-q.c

790

ohci_dbg(ohci,

drivers/usb/host/ohci-q.c

80

&& ohci_to_hcd(ohci)->self.bandwidth_int_reqs == 0) {

drivers/usb/host/ohci-q.c

800

u32 tdBE = hc32_to_cpup (ohci, &td->hwBE);

drivers/usb/host/ohci-q.c

81

ohci->hc_control &= ~(OHCI_CTRL_PLE|OHCI_CTRL_IE);

drivers/usb/host/ohci-q.c

817

hc32_to_cpup (ohci, &td->hwCBP)

drivers/usb/host/ohci-q.c

82

ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);

drivers/usb/host/ohci-q.c

822

ohci_dbg(ohci,

drivers/usb/host/ohci-q.c

833

static void ed_halted(struct ohci_hcd *ohci, struct td *td, int cc)

drivers/usb/host/ohci-q.c

839

__hc32 toggle = ed->hwHeadP & cpu_to_hc32 (ohci, ED_C);

drivers/usb/host/ohci-q.c

844

ed->hwINFO |= cpu_to_hc32 (ohci, ED_SKIP);

drivers/usb/host/ohci-q.c

846

ed->hwHeadP &= ~cpu_to_hc32 (ohci, ED_H);

drivers/usb/host/ohci-q.c

888

ohci_dbg (ohci,

drivers/usb/host/ohci-q.c

893

hc32_to_cpu (ohci, td->hwINFO),

drivers/usb/host/ohci-q.c

899

static void add_to_done_list(struct ohci_hcd *ohci, struct td *td)

drivers/usb/host/ohci-q.c

917

if (ohci->dl_end)

drivers/usb/host/ohci-q.c

918

ohci->dl_end->next_dl_td = td_prev;

drivers/usb/host/ohci-q.c

920

ohci->dl_start = td_prev;

drivers/usb/host/ohci-q.c

926

ohci->dl_end = td->next_dl_td = td;

drivers/usb/host/ohci-q.c

935

static void update_done_list(struct ohci_hcd *ohci)

drivers/usb/host/ohci-q.c

940

td_dma = hc32_to_cpup (ohci, &ohci->hcca->done_head);

drivers/usb/host/ohci-q.c

941

ohci->hcca->done_head = 0;

drivers/usb/host/ohci-q.c

950

td = dma_to_td (ohci, td_dma);

drivers/usb/host/ohci-q.c

952

ohci_err (ohci, "bad entry %8x\n", td_dma);

drivers/usb/host/ohci-q.c

956

td->hwINFO |= cpu_to_hc32 (ohci, TD_DONE);

drivers/usb/host/ohci-q.c

957

cc = TD_CC_GET (hc32_to_cpup (ohci, &td->hwINFO));

drivers/usb/host/ohci-q.c

964

&& (td->ed->hwHeadP & cpu_to_hc32 (ohci, ED_H)))

drivers/usb/host/ohci-q.c

965

ed_halted(ohci, td, cc);

drivers/usb/host/ohci-q.c

967

td_dma = hc32_to_cpup (ohci, &td->hwNextTD);

drivers/usb/host/ohci-q.c

968

add_to_done_list(ohci, td);

drivers/usb/host/ohci-q.c

975

static void finish_unlinks(struct ohci_hcd *ohci)

drivers/usb/host/ohci-q.c

977

unsigned tick = ohci_frame_no(ohci);

drivers/usb/host/ohci-q.c

981

for (last = &ohci->ed_rm_list, ed = *last; ed != NULL; ed = *last) {

drivers/usb/host/ohci-q.c

989

if (likely(ohci->rh_state == OHCI_RH_RUNNING) &&

drivers/usb/host/ohci-sa1111.c

59

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-sa1111.c

61

ohci_hcd_init(ohci);

drivers/usb/host/ohci-sa1111.c

62

return ohci_init(ohci);

drivers/usb/host/ohci-sa1111.c

67

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-sa1111.c

70

ret = ohci_run(ohci);

drivers/usb/host/ohci-sa1111.c

72

ohci_err(ohci, "can't start\n");

drivers/usb/host/ohci-sm501.c

213

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-sm501.c

217

if (time_before(jiffies, ohci->next_statechange))

drivers/usb/host/ohci-sm501.c

219

ohci->next_statechange = jiffies;

drivers/usb/host/ohci-sm501.c

233

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-sm501.c

235

if (time_before(jiffies, ohci->next_statechange))

drivers/usb/host/ohci-sm501.c

237

ohci->next_statechange = jiffies;

drivers/usb/host/ohci-spear.c

116

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-spear.c

121

if (time_before(jiffies, ohci->next_statechange))

drivers/usb/host/ohci-spear.c

123

ohci->next_statechange = jiffies;

drivers/usb/host/ohci-spear.c

137

struct ohci_hcd *ohci = hcd_to_ohci(hcd);

drivers/usb/host/ohci-spear.c

140

if (time_before(jiffies, ohci->next_statechange))

drivers/usb/host/ohci-spear.c

142

ohci->next_statechange = jiffies;

drivers/usb/host/ohci.h

384

void (*start_hnp)(struct ohci_hcd *ohci);

drivers/usb/host/ohci.h

443

static inline int quirk_nec(struct ohci_hcd *ohci)

drivers/usb/host/ohci.h

445

return ohci->flags & OHCI_QUIRK_NEC;

drivers/usb/host/ohci.h

447

static inline int quirk_zfmicro(struct ohci_hcd *ohci)

drivers/usb/host/ohci.h

449

return ohci->flags & OHCI_QUIRK_ZFMICRO;

drivers/usb/host/ohci.h

451

static inline int quirk_amdiso(struct ohci_hcd *ohci)

drivers/usb/host/ohci.h

453

return ohci->flags & OHCI_QUIRK_AMD_PLL;

drivers/usb/host/ohci.h

455

static inline int quirk_amdprefetch(struct ohci_hcd *ohci)

drivers/usb/host/ohci.h

457

return ohci->flags & OHCI_QUIRK_AMD_PREFETCH;

drivers/usb/host/ohci.h

460

static inline int quirk_nec(struct ohci_hcd *ohci)

drivers/usb/host/ohci.h

464

static inline int quirk_zfmicro(struct ohci_hcd *ohci)

drivers/usb/host/ohci.h

468

static inline int quirk_amdiso(struct ohci_hcd *ohci)

drivers/usb/host/ohci.h

472

static inline int quirk_amdprefetch(struct ohci_hcd *ohci)

drivers/usb/host/ohci.h

483

static inline struct usb_hcd *ohci_to_hcd (const struct ohci_hcd *ohci)

drivers/usb/host/ohci.h

485

return container_of ((void *) ohci, struct usb_hcd, hcd_priv);

drivers/usb/host/ohci.h

490

#define ohci_dbg(ohci, fmt, args...) \

drivers/usb/host/ohci.h

491

dev_dbg (ohci_to_hcd(ohci)->self.controller , fmt , ## args )

drivers/usb/host/ohci.h

492

#define ohci_err(ohci, fmt, args...) \

drivers/usb/host/ohci.h

493

dev_err (ohci_to_hcd(ohci)->self.controller , fmt , ## args )

drivers/usb/host/ohci.h

494

#define ohci_info(ohci, fmt, args...) \

drivers/usb/host/ohci.h

495

dev_info (ohci_to_hcd(ohci)->self.controller , fmt , ## args )

drivers/usb/host/ohci.h

496

#define ohci_warn(ohci, fmt, args...) \

drivers/usb/host/ohci.h

497

dev_warn (ohci_to_hcd(ohci)->self.controller , fmt , ## args )

drivers/usb/host/ohci.h

538

#define big_endian_desc(ohci) (ohci->flags & OHCI_QUIRK_BE_DESC)

drivers/usb/host/ohci.h

540

#define big_endian_desc(ohci) 1 /* only big endian */

drivers/usb/host/ohci.h

543

#define big_endian_desc(ohci) 0 /* only little endian */

drivers/usb/host/ohci.h

548

#define big_endian_mmio(ohci) (ohci->flags & OHCI_QUIRK_BE_MMIO)

drivers/usb/host/ohci.h

550

#define big_endian_mmio(ohci) 1 /* only big endian */

drivers/usb/host/ohci.h

553

#define big_endian_mmio(ohci) 0 /* only little endian */

drivers/usb/host/ohci.h

561

static inline unsigned int _ohci_readl (const struct ohci_hcd *ohci,

drivers/usb/host/ohci.h

565

return big_endian_mmio(ohci) ?

drivers/usb/host/ohci.h

573

static inline void _ohci_writel (const struct ohci_hcd *ohci,

drivers/usb/host/ohci.h

577

big_endian_mmio(ohci) ?

drivers/usb/host/ohci.h

592

static inline __hc16 cpu_to_hc16 (const struct ohci_hcd *ohci, const u16 x)

drivers/usb/host/ohci.h

594

return big_endian_desc(ohci) ?

drivers/usb/host/ohci.h

599

static inline __hc16 cpu_to_hc16p (const struct ohci_hcd *ohci, const u16 *x)

drivers/usb/host/ohci.h

601

return big_endian_desc(ohci) ?

drivers/usb/host/ohci.h

606

static inline __hc32 cpu_to_hc32 (const struct ohci_hcd *ohci, const u32 x)

drivers/usb/host/ohci.h

608

return big_endian_desc(ohci) ?

drivers/usb/host/ohci.h

613

static inline __hc32 cpu_to_hc32p (const struct ohci_hcd *ohci, const u32 *x)

drivers/usb/host/ohci.h

615

return big_endian_desc(ohci) ?

drivers/usb/host/ohci.h

621

static inline u16 hc16_to_cpu (const struct ohci_hcd *ohci, const __hc16 x)

drivers/usb/host/ohci.h

623

return big_endian_desc(ohci) ?

drivers/usb/host/ohci.h

628

static inline u16 hc16_to_cpup (const struct ohci_hcd *ohci, const __hc16 *x)

drivers/usb/host/ohci.h

630

return big_endian_desc(ohci) ?

drivers/usb/host/ohci.h

635

static inline u32 hc32_to_cpu (const struct ohci_hcd *ohci, const __hc32 x)

drivers/usb/host/ohci.h

637

return big_endian_desc(ohci) ?

drivers/usb/host/ohci.h

642

static inline u32 hc32_to_cpup (const struct ohci_hcd *ohci, const __hc32 *x)

drivers/usb/host/ohci.h

644

return big_endian_desc(ohci) ?

drivers/usb/host/ohci.h

661

static inline u16 ohci_frame_no(const struct ohci_hcd *ohci)

drivers/usb/host/ohci.h

664

if (big_endian_desc(ohci)) {

drivers/usb/host/ohci.h

665

tmp = be32_to_cpup((__force __be32 *)&ohci->hcca->frame_no);

drivers/usb/host/ohci.h

666

if (!(ohci->flags & OHCI_QUIRK_FRAME_NO))

drivers/usb/host/ohci.h

669

tmp = le32_to_cpup((__force __le32 *)&ohci->hcca->frame_no);

drivers/usb/host/ohci.h

674

static inline __hc16 *ohci_hwPSWp(const struct ohci_hcd *ohci,

drivers/usb/host/ohci.h

677

return (__hc16 *)(big_endian_desc(ohci) ?

drivers/usb/host/ohci.h

681

static inline u16 ohci_hwPSW(const struct ohci_hcd *ohci,

drivers/usb/host/ohci.h

684

return hc16_to_cpup(ohci, ohci_hwPSWp(ohci, td, index));

drivers/usb/host/ohci.h

694

static inline void periodic_reinit (struct ohci_hcd *ohci)

drivers/usb/host/ohci.h

696

u32 fi = ohci->fminterval & 0x03fff;

drivers/usb/host/ohci.h

697

u32 fit = ohci_readl(ohci, &ohci->regs->fminterval) & FIT;

drivers/usb/host/ohci.h

699

ohci_writel (ohci, (fit ^ FIT) | ohci->fminterval,

drivers/usb/host/ohci.h

700

&ohci->regs->fminterval);

drivers/usb/host/ohci.h

701

ohci_writel (ohci, ((9 * fi) / 10) & 0x3fff,

drivers/usb/host/ohci.h

702

&ohci->regs->periodicstart);

drivers/usb/host/ohci.h

737

extern int ohci_restart(struct ohci_hcd *ohci);

drivers/usb/host/ohci.h

75

#define OKAY_TO_TAKEBACK(ohci, ed) \

drivers/usb/host/ohci.h

76

((int) (ohci->wdh_cnt - ed->takeback_wdh_cnt) >= 0)

drivers/usb/host/ssb-hcd.c

103

static struct platform_device *ssb_hcd_create_pdev(struct ssb_device *dev, bool ohci, u32 addr, u32 len)

drivers/usb/host/ssb-hcd.c

118

hci_dev = platform_device_alloc(ohci ? "ohci-platform" :

drivers/usb/host/ssb-hcd.c

130

if (ohci)