drivers/atm/he.c

1045

if (!(he_dev->membase = ioremap(membase, HE_REGMAP_SIZE))) {

drivers/atm/he.c

1051

he_writel(he_dev, 0x0, RESET_CNTL);

drivers/atm/he.c

1052

he_writel(he_dev, 0xff, RESET_CNTL);

drivers/atm/he.c

1055

status = he_readl(he_dev, RESET_CNTL);

drivers/atm/he.c

106

static void he_stop(struct he_dev *dev);

drivers/atm/he.c

1062

host_cntl = he_readl(he_dev, HOST_CNTL);

drivers/atm/he.c

1080

he_dev->prod_id[i] = read_prom_byte(he_dev, PROD_ID + i);

drivers/atm/he.c

1082

he_dev->media = read_prom_byte(he_dev, MEDIA);

drivers/atm/he.c

1085

dev->esi[i] = read_prom_byte(he_dev, MAC_ADDR + i);

drivers/atm/he.c

1087

hprintk("%s%s, %pM\n", he_dev->prod_id,

drivers/atm/he.c

1088

he_dev->media & 0x40 ? "SM" : "MM", dev->esi);

drivers/atm/he.c

1089

he_dev->atm_dev->link_rate = he_is622(he_dev) ?

drivers/atm/he.c

1093

lb_swap = he_readl(he_dev, LB_SWAP);

drivers/atm/he.c

1094

if (he_is622(he_dev))

drivers/atm/he.c

110

static u8 read_prom_byte(struct he_dev *he_dev, int addr);

drivers/atm/he.c

1104

he_writel(he_dev, lb_swap, LB_SWAP);

drivers/atm/he.c

1107

he_writel(he_dev, he_is622(he_dev) ? LB_64_ENB : 0x0, SDRAM_CTL);

drivers/atm/he.c

1111

he_writel(he_dev, lb_swap, LB_SWAP);

drivers/atm/he.c

1114

if ((err = he_init_irq(he_dev)) != 0)

drivers/atm/he.c

1120

he_writel(he_dev, host_cntl, HOST_CNTL);

drivers/atm/he.c

114

static struct he_dev *he_devs;

drivers/atm/he.c

1160

he_dev->vcibits = CONFIG_DEFAULT_VCIBITS;

drivers/atm/he.c

1161

he_dev->vpibits = CONFIG_DEFAULT_VPIBITS;

drivers/atm/he.c

1169

he_dev->vpibits = nvpibits;

drivers/atm/he.c

1170

he_dev->vcibits = HE_MAXCIDBITS - nvpibits;

drivers/atm/he.c

1174

he_dev->vcibits = nvcibits;

drivers/atm/he.c

1175

he_dev->vpibits = HE_MAXCIDBITS - nvcibits;

drivers/atm/he.c

1179

if (he_is622(he_dev)) {

drivers/atm/he.c

1180

he_dev->cells_per_row = 40;

drivers/atm/he.c

1181

he_dev->bytes_per_row = 2048;

drivers/atm/he.c

1182

he_dev->r0_numrows = 256;

drivers/atm/he.c

1183

he_dev->tx_numrows = 512;

drivers/atm/he.c

1184

he_dev->r1_numrows = 256;

drivers/atm/he.c

1185

he_dev->r0_startrow = 0;

drivers/atm/he.c

1186

he_dev->tx_startrow = 256;

drivers/atm/he.c

1187

he_dev->r1_startrow = 768;

drivers/atm/he.c

1189

he_dev->cells_per_row = 20;

drivers/atm/he.c

1190

he_dev->bytes_per_row = 1024;

drivers/atm/he.c

1191

he_dev->r0_numrows = 512;

drivers/atm/he.c

1192

he_dev->tx_numrows = 1018;

drivers/atm/he.c

1193

he_dev->r1_numrows = 512;

drivers/atm/he.c

1194

he_dev->r0_startrow = 6;

drivers/atm/he.c

1195

he_dev->tx_startrow = 518;

drivers/atm/he.c

1196

he_dev->r1_startrow = 1536;

drivers/atm/he.c

1199

he_dev->cells_per_lbuf = 4;

drivers/atm/he.c

1200

he_dev->buffer_limit = 4;

drivers/atm/he.c

1201

he_dev->r0_numbuffs = he_dev->r0_numrows *

drivers/atm/he.c

1202

he_dev->cells_per_row / he_dev->cells_per_lbuf;

drivers/atm/he.c

1203

if (he_dev->r0_numbuffs > 2560)

drivers/atm/he.c

1204

he_dev->r0_numbuffs = 2560;

drivers/atm/he.c

1206

he_dev->r1_numbuffs = he_dev->r1_numrows *

drivers/atm/he.c

1207

he_dev->cells_per_row / he_dev->cells_per_lbuf;

drivers/atm/he.c

1208

if (he_dev->r1_numbuffs > 2560)

drivers/atm/he.c

1209

he_dev->r1_numbuffs = 2560;

drivers/atm/he.c

1211

he_dev->tx_numbuffs = he_dev->tx_numrows *

drivers/atm/he.c

1212

he_dev->cells_per_row / he_dev->cells_per_lbuf;

drivers/atm/he.c

1213

if (he_dev->tx_numbuffs > 5120)

drivers/atm/he.c

1214

he_dev->tx_numbuffs = 5120;

drivers/atm/he.c

1218

he_writel(he_dev,

drivers/atm/he.c

1221

(he_is622(he_dev) ? BUS_MULTI(0x28) : BUS_MULTI(0x46)) |

drivers/atm/he.c

1222

(he_is622(he_dev) ? NET_PREF(0x50) : NET_PREF(0x8c)),

drivers/atm/he.c

1225

he_writel(he_dev, BANK_ON |

drivers/atm/he.c

1226

(he_is622(he_dev) ? (REF_RATE(0x384) | WIDE_DATA) : REF_RATE(0x150)),

drivers/atm/he.c

1229

he_writel(he_dev,

drivers/atm/he.c

1230

(he_is622(he_dev) ? RM_BANK_WAIT(1) : RM_BANK_WAIT(0)) |

drivers/atm/he.c

1232

he_writel(he_dev,

drivers/atm/he.c

1233

(he_is622(he_dev) ? TM_BANK_WAIT(2) : TM_BANK_WAIT(1)) |

drivers/atm/he.c

1236

he_writel(he_dev, he_dev->cells_per_lbuf * ATM_CELL_PAYLOAD, LB_CONFIG);

drivers/atm/he.c

1238

he_writel(he_dev,

drivers/atm/he.c

1239

(he_is622(he_dev) ? UT_RD_DELAY(8) : UT_RD_DELAY(0)) |

drivers/atm/he.c

1240

(he_is622(he_dev) ? RC_UT_MODE(0) : RC_UT_MODE(1)) |

drivers/atm/he.c

1241

RX_VALVP(he_dev->vpibits) |

drivers/atm/he.c

1242

RX_VALVC(he_dev->vcibits), RC_CONFIG);

drivers/atm/he.c

1244

he_writel(he_dev, DRF_THRESH(0x20) |

drivers/atm/he.c

1245

(he_is622(he_dev) ? TX_UT_MODE(0) : TX_UT_MODE(1)) |

drivers/atm/he.c

1246

TX_VCI_MASK(he_dev->vcibits) |

drivers/atm/he.c

1247

LBFREE_CNT(he_dev->tx_numbuffs), TX_CONFIG);

drivers/atm/he.c

1249

he_writel(he_dev, 0x0, TXAAL5_PROTO);

drivers/atm/he.c

1251

he_writel(he_dev, PHY_INT_ENB |

drivers/atm/he.c

1252

(he_is622(he_dev) ? PTMR_PRE(67 - 1) : PTMR_PRE(50 - 1)),

drivers/atm/he.c

1258

he_writel_tcm(he_dev, 0, i);

drivers/atm/he.c

1261

he_writel_rcm(he_dev, 0, i);

drivers/atm/he.c

1294

he_writel(he_dev, CONFIG_TSRB, TSRB_BA);

drivers/atm/he.c

1295

he_writel(he_dev, CONFIG_TSRC, TSRC_BA);

drivers/atm/he.c

1296

he_writel(he_dev, CONFIG_TSRD, TSRD_BA);

drivers/atm/he.c

1297

he_writel(he_dev, CONFIG_TMABR, TMABR_BA);

drivers/atm/he.c

1298

he_writel(he_dev, CONFIG_TPDBA, TPD_BA);

drivers/atm/he.c

1328

he_writel(he_dev, 0x08000, RCMLBM_BA);

drivers/atm/he.c

1329

he_writel(he_dev, 0x0e000, RCMRSRB_BA);

drivers/atm/he.c

1330

he_writel(he_dev, 0x0d800, RCMABR_BA);

drivers/atm/he.c

1334

he_init_rx_lbfp0(he_dev);

drivers/atm/he.c

1335

he_init_rx_lbfp1(he_dev);

drivers/atm/he.c

1337

he_writel(he_dev, 0x0, RLBC_H);

drivers/atm/he.c

1338

he_writel(he_dev, 0x0, RLBC_T);

drivers/atm/he.c

1339

he_writel(he_dev, 0x0, RLBC_H2);

drivers/atm/he.c

1341

he_writel(he_dev, 512, RXTHRSH); /* 10% of r0+r1 buffers */

drivers/atm/he.c

1342

he_writel(he_dev, 256, LITHRSH); /* 5% of r0+r1 buffers */

drivers/atm/he.c

1344

he_init_tx_lbfp(he_dev);

drivers/atm/he.c

1346

he_writel(he_dev, he_is622(he_dev) ? 0x104780 : 0x800, UBUFF_BA);

drivers/atm/he.c

1350

if (he_is622(he_dev)) {

drivers/atm/he.c

1351

he_writel(he_dev, 0x000f, G0_INMQ_S);

drivers/atm/he.c

1352

he_writel(he_dev, 0x200f, G0_INMQ_L);

drivers/atm/he.c

1354

he_writel(he_dev, 0x001f, G1_INMQ_S);

drivers/atm/he.c

1355

he_writel(he_dev, 0x201f, G1_INMQ_L);

drivers/atm/he.c

1357

he_writel(he_dev, 0x002f, G2_INMQ_S);

drivers/atm/he.c

1358

he_writel(he_dev, 0x202f, G2_INMQ_L);

drivers/atm/he.c

1360

he_writel(he_dev, 0x003f, G3_INMQ_S);

drivers/atm/he.c

1361

he_writel(he_dev, 0x203f, G3_INMQ_L);

drivers/atm/he.c

1363

he_writel(he_dev, 0x004f, G4_INMQ_S);

drivers/atm/he.c

1364

he_writel(he_dev, 0x204f, G4_INMQ_L);

drivers/atm/he.c

1366

he_writel(he_dev, 0x005f, G5_INMQ_S);

drivers/atm/he.c

1367

he_writel(he_dev, 0x205f, G5_INMQ_L);

drivers/atm/he.c

1369

he_writel(he_dev, 0x006f, G6_INMQ_S);

drivers/atm/he.c

1370

he_writel(he_dev, 0x206f, G6_INMQ_L);

drivers/atm/he.c

1372

he_writel(he_dev, 0x007f, G7_INMQ_S);

drivers/atm/he.c

1373

he_writel(he_dev, 0x207f, G7_INMQ_L);

drivers/atm/he.c

1375

he_writel(he_dev, 0x0000, G0_INMQ_S);

drivers/atm/he.c

1376

he_writel(he_dev, 0x0008, G0_INMQ_L);

drivers/atm/he.c

1378

he_writel(he_dev, 0x0001, G1_INMQ_S);

drivers/atm/he.c

1379

he_writel(he_dev, 0x0009, G1_INMQ_L);

drivers/atm/he.c

1381

he_writel(he_dev, 0x0002, G2_INMQ_S);

drivers/atm/he.c

1382

he_writel(he_dev, 0x000a, G2_INMQ_L);

drivers/atm/he.c

1384

he_writel(he_dev, 0x0003, G3_INMQ_S);

drivers/atm/he.c

1385

he_writel(he_dev, 0x000b, G3_INMQ_L);

drivers/atm/he.c

1387

he_writel(he_dev, 0x0004, G4_INMQ_S);

drivers/atm/he.c

1388

he_writel(he_dev, 0x000c, G4_INMQ_L);

drivers/atm/he.c

1390

he_writel(he_dev, 0x0005, G5_INMQ_S);

drivers/atm/he.c

1391

he_writel(he_dev, 0x000d, G5_INMQ_L);

drivers/atm/he.c

1393

he_writel(he_dev, 0x0006, G6_INMQ_S);

drivers/atm/he.c

1394

he_writel(he_dev, 0x000e, G6_INMQ_L);

drivers/atm/he.c

1396

he_writel(he_dev, 0x0007, G7_INMQ_S);

drivers/atm/he.c

1397

he_writel(he_dev, 0x000f, G7_INMQ_L);

drivers/atm/he.c

1402

he_writel(he_dev, 0x0, MCC);

drivers/atm/he.c

1403

he_writel(he_dev, 0x0, OEC);

drivers/atm/he.c

1404

he_writel(he_dev, 0x0, DCC);

drivers/atm/he.c

1405

he_writel(he_dev, 0x0, CEC);

drivers/atm/he.c

1409

he_init_cs_block(he_dev);

drivers/atm/he.c

1413

if (he_init_cs_block_rcm(he_dev) < 0)

drivers/atm/he.c

1418

he_init_tpdrq(he_dev);

drivers/atm/he.c

1420

he_dev->tpd_pool = dma_pool_create("tpd", &he_dev->pci_dev->dev,

drivers/atm/he.c

1422

if (he_dev->tpd_pool == NULL) {

drivers/atm/he.c

1427

INIT_LIST_HEAD(&he_dev->outstanding_tpds);

drivers/atm/he.c

1429

if (he_init_group(he_dev, 0) != 0)

drivers/atm/he.c

1433

he_writel(he_dev, 0x0, G0_RBPS_S + (group * 32));

drivers/atm/he.c

1434

he_writel(he_dev, 0x0, G0_RBPS_T + (group * 32));

drivers/atm/he.c

1435

he_writel(he_dev, 0x0, G0_RBPS_QI + (group * 32));

drivers/atm/he.c

1436

he_writel(he_dev, RBP_THRESH(0x1) | RBP_QSIZE(0x0),

drivers/atm/he.c

1439

he_writel(he_dev, 0x0, G0_RBPL_S + (group * 32));

drivers/atm/he.c

1440

he_writel(he_dev, 0x0, G0_RBPL_T + (group * 32));

drivers/atm/he.c

1441

he_writel(he_dev, RBP_THRESH(0x1) | RBP_QSIZE(0x0),

drivers/atm/he.c

1443

he_writel(he_dev, 0x0, G0_RBPL_BS + (group * 32));

drivers/atm/he.c

1445

he_writel(he_dev, 0x0, G0_RBRQ_ST + (group * 16));

drivers/atm/he.c

1446

he_writel(he_dev, 0x0, G0_RBRQ_H + (group * 16));

drivers/atm/he.c

1447

he_writel(he_dev, RBRQ_THRESH(0x1) | RBRQ_SIZE(0x0),

drivers/atm/he.c

1449

he_writel(he_dev, 0x0, G0_RBRQ_I + (group * 16));

drivers/atm/he.c

1451

he_writel(he_dev, 0x0, G0_TBRQ_B_T + (group * 16));

drivers/atm/he.c

1452

he_writel(he_dev, 0x0, G0_TBRQ_H + (group * 16));

drivers/atm/he.c

1453

he_writel(he_dev, TBRQ_THRESH(0x1),

drivers/atm/he.c

1455

he_writel(he_dev, 0x0, G0_TBRQ_S + (group * 16));

drivers/atm/he.c

1460

he_dev->hsp = dma_alloc_coherent(&he_dev->pci_dev->dev,

drivers/atm/he.c

1462

&he_dev->hsp_phys, GFP_KERNEL);

drivers/atm/he.c

1463

if (he_dev->hsp == NULL) {

drivers/atm/he.c

1467

he_writel(he_dev, he_dev->hsp_phys, HSP_BA);

drivers/atm/he.c

1472

if (he_isMM(he_dev))

drivers/atm/he.c

1473

suni_init(he_dev->atm_dev);

drivers/atm/he.c

1474

if (he_dev->atm_dev->phy && he_dev->atm_dev->phy->start)

drivers/atm/he.c

1475

he_dev->atm_dev->phy->start(he_dev->atm_dev);

drivers/atm/he.c

1482

val = he_phy_get(he_dev->atm_dev, SUNI_TPOP_APM);

drivers/atm/he.c

1484

he_phy_put(he_dev->atm_dev, val, SUNI_TPOP_APM);

drivers/atm/he.c

1485

he_phy_put(he_dev->atm_dev, SUNI_TACP_IUCHP_CLP, SUNI_TACP_IUCHP);

drivers/atm/he.c

1490

reg = he_readl_mbox(he_dev, CS_ERCTL0);

drivers/atm/he.c

1492

he_writel_mbox(he_dev, reg, CS_ERCTL0);

drivers/atm/he.c

1494

reg = he_readl(he_dev, RC_CONFIG);

drivers/atm/he.c

1496

he_writel(he_dev, reg, RC_CONFIG);

drivers/atm/he.c

1499

he_dev->cs_stper[i].inuse = 0;

drivers/atm/he.c

1500

he_dev->cs_stper[i].pcr = -1;

drivers/atm/he.c

1502

he_dev->total_bw = 0;

drivers/atm/he.c

1507

he_dev->atm_dev->ci_range.vpi_bits = he_dev->vpibits;

drivers/atm/he.c

1508

he_dev->atm_dev->ci_range.vci_bits = he_dev->vcibits;

drivers/atm/he.c

1510

he_dev->irq_peak = 0;

drivers/atm/he.c

1511

he_dev->rbrq_peak = 0;

drivers/atm/he.c

1512

he_dev->rbpl_peak = 0;

drivers/atm/he.c

1513

he_dev->tbrq_peak = 0;

drivers/atm/he.c

1521

he_stop(struct he_dev *he_dev)

drivers/atm/he.c

1528

pci_dev = he_dev->pci_dev;

drivers/atm/he.c

1532

if (he_dev->membase) {

drivers/atm/he.c

1537

tasklet_disable(&he_dev->tasklet);

drivers/atm/he.c

1541

reg = he_readl_mbox(he_dev, CS_ERCTL0);

drivers/atm/he.c

1543

he_writel_mbox(he_dev, reg, CS_ERCTL0);

drivers/atm/he.c

1545

reg = he_readl(he_dev, RC_CONFIG);

drivers/atm/he.c

1547

he_writel(he_dev, reg, RC_CONFIG);

drivers/atm/he.c

1551

if (he_dev->atm_dev->phy && he_dev->atm_dev->phy->stop)

drivers/atm/he.c

1552

he_dev->atm_dev->phy->stop(he_dev->atm_dev);

drivers/atm/he.c

1555

if (he_dev->irq)

drivers/atm/he.c

1556

free_irq(he_dev->irq, he_dev);

drivers/atm/he.c

1558

if (he_dev->irq_base)

drivers/atm/he.c

1559

dma_free_coherent(&he_dev->pci_dev->dev, (CONFIG_IRQ_SIZE + 1)

drivers/atm/he.c

1560

* sizeof(struct he_irq), he_dev->irq_base, he_dev->irq_phys);

drivers/atm/he.c

1562

if (he_dev->hsp)

drivers/atm/he.c

1563

dma_free_coherent(&he_dev->pci_dev->dev, sizeof(struct he_hsp),

drivers/atm/he.c

1564

he_dev->hsp, he_dev->hsp_phys);

drivers/atm/he.c

1566

if (he_dev->rbpl_base) {

drivers/atm/he.c

1567

list_for_each_entry_safe(heb, next, &he_dev->rbpl_outstanding, entry)

drivers/atm/he.c

1568

dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping);

drivers/atm/he.c

1570

dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBPL_SIZE

drivers/atm/he.c

1571

* sizeof(struct he_rbp), he_dev->rbpl_base, he_dev->rbpl_phys);

drivers/atm/he.c

1574

kfree(he_dev->rbpl_virt);

drivers/atm/he.c

1575

bitmap_free(he_dev->rbpl_table);

drivers/atm/he.c

1576

dma_pool_destroy(he_dev->rbpl_pool);

drivers/atm/he.c

1578

if (he_dev->rbrq_base)

drivers/atm/he.c

1579

dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq),

drivers/atm/he.c

1580

he_dev->rbrq_base, he_dev->rbrq_phys);

drivers/atm/he.c

1582

if (he_dev->tbrq_base)

drivers/atm/he.c

1583

dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq),

drivers/atm/he.c

1584

he_dev->tbrq_base, he_dev->tbrq_phys);

drivers/atm/he.c

1586

if (he_dev->tpdrq_base)

drivers/atm/he.c

1587

dma_free_coherent(&he_dev->pci_dev->dev,

drivers/atm/he.c

1589

he_dev->tpdrq_base, he_dev->tpdrq_phys);

drivers/atm/he.c

1591

dma_pool_destroy(he_dev->tpd_pool);

drivers/atm/he.c

1593

if (he_dev->pci_dev) {

drivers/atm/he.c

1594

pci_read_config_word(he_dev->pci_dev, PCI_COMMAND, &command);

drivers/atm/he.c

1596

pci_write_config_word(he_dev->pci_dev, PCI_COMMAND, command);

drivers/atm/he.c

1599

if (he_dev->membase)

drivers/atm/he.c

1600

iounmap(he_dev->membase);

drivers/atm/he.c

1604

__alloc_tpd(struct he_dev *he_dev)

drivers/atm/he.c

1609

tpd = dma_pool_alloc(he_dev->tpd_pool, GFP_ATOMIC, &mapping);

drivers/atm/he.c

1637

he_service_rbrq(struct he_dev *he_dev, int group)

drivers/atm/he.c

1640

((unsigned long)he_dev->rbrq_base |

drivers/atm/he.c

1641

he_dev->hsp->group[group].rbrq_tail);

drivers/atm/he.c

1652

while (he_dev->rbrq_head != rbrq_tail) {

drivers/atm/he.c

1656

he_dev->rbrq_head, group,

drivers/atm/he.c

1657

RBRQ_ADDR(he_dev->rbrq_head),

drivers/atm/he.c

1658

RBRQ_BUFLEN(he_dev->rbrq_head),

drivers/atm/he.c

1659

RBRQ_CID(he_dev->rbrq_head),

drivers/atm/he.c

1660

RBRQ_CRC_ERR(he_dev->rbrq_head) ? " CRC_ERR" : "",

drivers/atm/he.c

1661

RBRQ_LEN_ERR(he_dev->rbrq_head) ? " LEN_ERR" : "",

drivers/atm/he.c

1662

RBRQ_END_PDU(he_dev->rbrq_head) ? " END_PDU" : "",

drivers/atm/he.c

1663

RBRQ_AAL5_PROT(he_dev->rbrq_head) ? " AAL5_PROT" : "",

drivers/atm/he.c

1664

RBRQ_CON_CLOSED(he_dev->rbrq_head) ? " CON_CLOSED" : "",

drivers/atm/he.c

1665

RBRQ_HBUF_ERR(he_dev->rbrq_head) ? " HBUF_ERR" : "");

drivers/atm/he.c

1667

i = RBRQ_ADDR(he_dev->rbrq_head) >> RBP_IDX_OFFSET;

drivers/atm/he.c

1668

heb = he_dev->rbpl_virt[i];

drivers/atm/he.c

1670

cid = RBRQ_CID(he_dev->rbrq_head);

drivers/atm/he.c

1672

vcc = __find_vcc(he_dev, cid);

drivers/atm/he.c

1677

if (!RBRQ_HBUF_ERR(he_dev->rbrq_head)) {

drivers/atm/he.c

1678

clear_bit(i, he_dev->rbpl_table);

drivers/atm/he.c

1680

dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping);

drivers/atm/he.c

1686

if (RBRQ_HBUF_ERR(he_dev->rbrq_head)) {

drivers/atm/he.c

1692

heb->len = RBRQ_BUFLEN(he_dev->rbrq_head) * 4;

drivers/atm/he.c

1693

clear_bit(i, he_dev->rbpl_table);

drivers/atm/he.c

1697

if (RBRQ_CON_CLOSED(he_dev->rbrq_head)) {

drivers/atm/he.c

1704

if (!RBRQ_END_PDU(he_dev->rbrq_head))

drivers/atm/he.c

1707

if (RBRQ_LEN_ERR(he_dev->rbrq_head)

drivers/atm/he.c

1708

|| RBRQ_CRC_ERR(he_dev->rbrq_head)) {

drivers/atm/he.c

1710

RBRQ_CRC_ERR(he_dev->rbrq_head)

drivers/atm/he.c

1712

RBRQ_LEN_ERR(he_dev->rbrq_head)

drivers/atm/he.c

1763

spin_unlock(&he_dev->global_lock);

drivers/atm/he.c

1765

spin_lock(&he_dev->global_lock);

drivers/atm/he.c

1773

dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping);

drivers/atm/he.c

1778

he_dev->rbrq_head = (struct he_rbrq *)

drivers/atm/he.c

1779

((unsigned long) he_dev->rbrq_base |

drivers/atm/he.c

1780

RBRQ_MASK(he_dev->rbrq_head + 1));

drivers/atm/he.c

1786

if (updated > he_dev->rbrq_peak)

drivers/atm/he.c

1787

he_dev->rbrq_peak = updated;

drivers/atm/he.c

1789

he_writel(he_dev, RBRQ_MASK(he_dev->rbrq_head),

drivers/atm/he.c

1797

he_service_tbrq(struct he_dev *he_dev, int group)

drivers/atm/he.c

1800

((unsigned long)he_dev->tbrq_base |

drivers/atm/he.c

1801

he_dev->hsp->group[group].tbrq_tail);

drivers/atm/he.c

1808

while (he_dev->tbrq_head != tbrq_tail) {

drivers/atm/he.c

1813

TBRQ_TPD(he_dev->tbrq_head),

drivers/atm/he.c

1814

TBRQ_EOS(he_dev->tbrq_head) ? " EOS" : "",

drivers/atm/he.c

1815

TBRQ_MULTIPLE(he_dev->tbrq_head) ? " MULTIPLE" : "");

drivers/atm/he.c

1817

list_for_each_entry(__tpd, &he_dev->outstanding_tpds, entry) {

drivers/atm/he.c

1818

if (TPD_ADDR(__tpd->status) == TBRQ_TPD(he_dev->tbrq_head)) {

drivers/atm/he.c

182

he_writel_internal(struct he_dev *he_dev, unsigned val, unsigned addr,

drivers/atm/he.c

1827

TBRQ_TPD(he_dev->tbrq_head));

drivers/atm/he.c

1831

if (TBRQ_EOS(he_dev->tbrq_head)) {

drivers/atm/he.c

1833

he_mkcid(he_dev, tpd->vcc->vpi, tpd->vcc->vci));

drivers/atm/he.c

1842

dma_unmap_single(&he_dev->pci_dev->dev,

drivers/atm/he.c

185

he_writel(he_dev, val, CON_DAT);

drivers/atm/he.c

186

(void) he_readl(he_dev, CON_DAT); /* flush posted writes */

drivers/atm/he.c

1860

dma_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status));

drivers/atm/he.c

1861

he_dev->tbrq_head = (struct he_tbrq *)

drivers/atm/he.c

1862

((unsigned long) he_dev->tbrq_base |

drivers/atm/he.c

1863

TBRQ_MASK(he_dev->tbrq_head + 1));

drivers/atm/he.c

1867

if (updated > he_dev->tbrq_peak)

drivers/atm/he.c

1868

he_dev->tbrq_peak = updated;

drivers/atm/he.c

187

he_writel(he_dev, flags | CON_CTL_WRITE | CON_CTL_ADDR(addr), CON_CTL);

drivers/atm/he.c

1870

he_writel(he_dev, TBRQ_MASK(he_dev->tbrq_head),

drivers/atm/he.c

1876

he_service_rbpl(struct he_dev *he_dev, int group)

drivers/atm/he.c

188

while (he_readl(he_dev, CON_CTL) & CON_CTL_BUSY);

drivers/atm/he.c

1885

rbpl_head = (struct he_rbp *) ((unsigned long)he_dev->rbpl_base |

drivers/atm/he.c

1886

RBPL_MASK(he_readl(he_dev, G0_RBPL_S)));

drivers/atm/he.c

1889

new_tail = (struct he_rbp *) ((unsigned long)he_dev->rbpl_base |

drivers/atm/he.c

1890

RBPL_MASK(he_dev->rbpl_tail+1));

drivers/atm/he.c

1896

i = find_next_zero_bit(he_dev->rbpl_table, RBPL_TABLE_SIZE, he_dev->rbpl_hint);

drivers/atm/he.c

1898

i = find_first_zero_bit(he_dev->rbpl_table, RBPL_TABLE_SIZE);

drivers/atm/he.c

1902

he_dev->rbpl_hint = i + 1;

drivers/atm/he.c

1904

heb = dma_pool_alloc(he_dev->rbpl_pool, GFP_ATOMIC, &mapping);

drivers/atm/he.c

1908

list_add(&heb->entry, &he_dev->rbpl_outstanding);

drivers/atm/he.c

1909

he_dev->rbpl_virt[i] = heb;

drivers/atm/he.c

1910

set_bit(i, he_dev->rbpl_table);

drivers/atm/he.c

1914

he_dev->rbpl_tail = new_tail;

drivers/atm/he.c

1919

he_writel(he_dev, RBPL_MASK(he_dev->rbpl_tail), G0_RBPL_T);

drivers/atm/he.c

1926

struct he_dev *he_dev = (struct he_dev *) data;

drivers/atm/he.c

1931

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

1933

while (he_dev->irq_head != he_dev->irq_tail) {

drivers/atm/he.c

1936

type = ITYPE_TYPE(he_dev->irq_head->isw);

drivers/atm/he.c

1937

group = ITYPE_GROUP(he_dev->irq_head->isw);

drivers/atm/he.c

1944

if (he_service_rbrq(he_dev, group))

drivers/atm/he.c

1945

he_service_rbpl(he_dev, group);

drivers/atm/he.c

1951

he_service_tbrq(he_dev, group);

drivers/atm/he.c

1954

he_service_rbpl(he_dev, group);

drivers/atm/he.c

1962

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

1963

if (he_dev->atm_dev->phy && he_dev->atm_dev->phy->interrupt)

drivers/atm/he.c

1964

he_dev->atm_dev->phy->interrupt(he_dev->atm_dev);

drivers/atm/he.c

1965

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

1974

hprintk("abort 0x%x\n", he_readl(he_dev, ABORT_ADDR));

drivers/atm/he.c

1981

HPRINTK("isw not updated 0x%x\n", he_dev->irq_head->isw);

drivers/atm/he.c

1983

he_service_rbrq(he_dev, 0);

drivers/atm/he.c

1984

he_service_rbpl(he_dev, 0);

drivers/atm/he.c

1985

he_service_tbrq(he_dev, 0);

drivers/atm/he.c

1988

hprintk("bad isw 0x%x?\n", he_dev->irq_head->isw);

drivers/atm/he.c

1991

he_dev->irq_head->isw = ITYPE_INVALID;

drivers/atm/he.c

1993

he_dev->irq_head = (struct he_irq *) NEXT_ENTRY(he_dev->irq_base, he_dev->irq_head, IRQ_MASK);

drivers/atm/he.c

1997

if (updated > he_dev->irq_peak)

drivers/atm/he.c

1998

he_dev->irq_peak = updated;

drivers/atm/he.c

2000

he_writel(he_dev,

drivers/atm/he.c

2003

IRQ_TAIL(he_dev->irq_tail), IRQ0_HEAD);

drivers/atm/he.c

2004

(void) he_readl(he_dev, INT_FIFO); /* 8.1.2 controller errata; flush posted writes */

drivers/atm/he.c

2006

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

201

he_readl_internal(struct he_dev *he_dev, unsigned addr, unsigned flags)

drivers/atm/he.c

2013

struct he_dev *he_dev = (struct he_dev * )dev_id;

drivers/atm/he.c

2016

if (he_dev == NULL)

drivers/atm/he.c

2019

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

2021

he_dev->irq_tail = (struct he_irq *) (((unsigned long)he_dev->irq_base) |

drivers/atm/he.c

2022

(*he_dev->irq_tailoffset << 2));

drivers/atm/he.c

2024

if (he_dev->irq_tail == he_dev->irq_head) {

drivers/atm/he.c

2026

he_dev->irq_tail = (struct he_irq *) ((unsigned long)he_dev->irq_base |

drivers/atm/he.c

2027

((he_readl(he_dev, IRQ0_BASE) & IRQ_MASK) << 2));

drivers/atm/he.c

2028

(void) he_readl(he_dev, INT_FIFO); /* 8.1.2 controller errata */

drivers/atm/he.c

203

he_writel(he_dev, flags | CON_CTL_READ | CON_CTL_ADDR(addr), CON_CTL);

drivers/atm/he.c

2032

if (he_dev->irq_head == he_dev->irq_tail /* && !IRQ_PENDING */)

drivers/atm/he.c

2036

if (he_dev->irq_head != he_dev->irq_tail) {

drivers/atm/he.c

2038

tasklet_schedule(&he_dev->tasklet);

drivers/atm/he.c

2039

he_writel(he_dev, INT_CLEAR_A, INT_FIFO); /* clear interrupt */

drivers/atm/he.c

204

while (he_readl(he_dev, CON_CTL) & CON_CTL_BUSY);

drivers/atm/he.c

2040

(void) he_readl(he_dev, INT_FIFO); /* flush posted writes */

drivers/atm/he.c

2042

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2048

__enqueue_tpd(struct he_dev *he_dev, struct he_tpd *tpd, unsigned cid)

drivers/atm/he.c

205

return he_readl(he_dev, CON_DAT);

drivers/atm/he.c

2053

tpd, cid, he_dev->tpdrq_tail);

drivers/atm/he.c

2056

new_tail = (struct he_tpdrq *) ((unsigned long) he_dev->tpdrq_base |

drivers/atm/he.c

2057

TPDRQ_MASK(he_dev->tpdrq_tail+1));

drivers/atm/he.c

2066

if (new_tail == he_dev->tpdrq_head) {

drivers/atm/he.c

2067

he_dev->tpdrq_head = (struct he_tpdrq *)

drivers/atm/he.c

2068

(((unsigned long)he_dev->tpdrq_base) |

drivers/atm/he.c

2069

TPDRQ_MASK(he_readl(he_dev, TPDRQ_B_H)));

drivers/atm/he.c

2071

if (new_tail == he_dev->tpdrq_head) {

drivers/atm/he.c

2083

dma_unmap_single(&he_dev->pci_dev->dev,

drivers/atm/he.c

2095

dma_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status));

drivers/atm/he.c

2101

list_add_tail(&tpd->entry, &he_dev->outstanding_tpds);

drivers/atm/he.c

2102

he_dev->tpdrq_tail->tpd = TPD_ADDR(tpd->status);

drivers/atm/he.c

2103

he_dev->tpdrq_tail->cid = cid;

drivers/atm/he.c

2106

he_dev->tpdrq_tail = new_tail;

drivers/atm/he.c

2108

he_writel(he_dev, TPDRQ_MASK(he_dev->tpdrq_tail), TPDRQ_T);

drivers/atm/he.c

2109

(void) he_readl(he_dev, TPDRQ_T); /* flush posted writes */

drivers/atm/he.c

2116

struct he_dev *he_dev = HE_DEV(vcc->dev);

drivers/atm/he.c

2130

cid = he_mkcid(he_dev, vpi, vci);

drivers/atm/he.c

2152

pcr_goal = he_dev->atm_dev->link_rate;

drivers/atm/he.c

2172

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

2173

tsr0 = he_readl_tsr0(he_dev, cid);

drivers/atm/he.c

2174

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2194

if ((he_dev->total_bw + pcr_goal)

drivers/atm/he.c

2195

> (he_dev->atm_dev->link_rate * 9 / 10))

drivers/atm/he.c

2201

spin_lock_irqsave(&he_dev->global_lock, flags); /* also protects he_dev->cs_stper[] */

drivers/atm/he.c

2205

if (he_dev->cs_stper[reg].inuse == 0 ||

drivers/atm/he.c

2206

he_dev->cs_stper[reg].pcr == pcr_goal)

drivers/atm/he.c

2211

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2215

he_dev->total_bw += pcr_goal;

drivers/atm/he.c

2218

++he_dev->cs_stper[reg].inuse;

drivers/atm/he.c

2219

he_dev->cs_stper[reg].pcr = pcr_goal;

drivers/atm/he.c

2221

clock = he_is622(he_dev) ? 66667000 : 50000000;

drivers/atm/he.c

2227

he_writel_mbox(he_dev, rate_to_atmf(period/2),

drivers/atm/he.c

2229

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2240

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

2242

he_writel_tsr0(he_dev, tsr0, cid);

drivers/atm/he.c

2243

he_writel_tsr4(he_dev, tsr4 | 1, cid);

drivers/atm/he.c

2244

he_writel_tsr1(he_dev, TSR1_MCR(rate_to_atmf(0)) |

drivers/atm/he.c

2246

he_writel_tsr2(he_dev, TSR2_ACR(rate_to_atmf(pcr_goal)), cid);

drivers/atm/he.c

2247

he_writel_tsr9(he_dev, TSR9_OPEN_CONN, cid);

drivers/atm/he.c

2249

he_writel_tsr3(he_dev, 0x0, cid);

drivers/atm/he.c

2250

he_writel_tsr5(he_dev, 0x0, cid);

drivers/atm/he.c

2251

he_writel_tsr6(he_dev, 0x0, cid);

drivers/atm/he.c

2252

he_writel_tsr7(he_dev, 0x0, cid);

drivers/atm/he.c

2253

he_writel_tsr8(he_dev, 0x0, cid);

drivers/atm/he.c

2254

he_writel_tsr10(he_dev, 0x0, cid);

drivers/atm/he.c

2255

he_writel_tsr11(he_dev, 0x0, cid);

drivers/atm/he.c

2256

he_writel_tsr12(he_dev, 0x0, cid);

drivers/atm/he.c

2257

he_writel_tsr13(he_dev, 0x0, cid);

drivers/atm/he.c

2258

he_writel_tsr14(he_dev, 0x0, cid);

drivers/atm/he.c

2259

(void) he_readl_tsr0(he_dev, cid); /* flush posted writes */

drivers/atm/he.c

2260

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2281

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

2283

rsr0 = he_readl_rsr0(he_dev, cid);

drivers/atm/he.c

2285

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2302

he_writel_rsr4(he_dev, rsr4, cid);

drivers/atm/he.c

2303

he_writel_rsr1(he_dev, rsr1, cid);

drivers/atm/he.c

2306

he_writel_rsr0(he_dev,

drivers/atm/he.c

2308

(void) he_readl_rsr0(he_dev, cid); /* flush posted writes */

drivers/atm/he.c

2310

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2330

struct he_dev *he_dev = HE_DEV(vcc->dev);

drivers/atm/he.c

2340

cid = he_mkcid(he_dev, vcc->vpi, vcc->vci);

drivers/atm/he.c

2351

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

2352

while (he_readl(he_dev, RCC_STAT) & RCC_BUSY) {

drivers/atm/he.c

2360

he_writel_rsr0(he_dev, RSR0_CLOSE_CONN, cid);

drivers/atm/he.c

2361

(void) he_readl_rsr0(he_dev, cid); /* flush posted writes */

drivers/atm/he.c

2362

he_writel_mbox(he_dev, cid, RXCON_CLOSE);

drivers/atm/he.c

2363

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2406

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

2407

he_writel_tsr4_upper(he_dev, TSR4_FLUSH_CONN, cid);

drivers/atm/he.c

2412

he_writel_tsr1(he_dev,

drivers/atm/he.c

2417

he_writel_tsr14_upper(he_dev, TSR14_DELETE, cid);

drivers/atm/he.c

2420

(void) he_readl_tsr4(he_dev, cid); /* flush posted writes */

drivers/atm/he.c

2422

tpd = __alloc_tpd(he_dev);

drivers/atm/he.c

2434

__enqueue_tpd(he_dev, tpd, cid);

drivers/atm/he.c

2435

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2442

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

2449

while (!((tsr4 = he_readl_tsr4(he_dev, cid)) & TSR4_SESSION_ENDED)) {

drivers/atm/he.c

2454

while (TSR0_CONN_STATE(tsr0 = he_readl_tsr0(he_dev, cid)) != 0) {

drivers/atm/he.c

2466

if (he_dev->cs_stper[reg].inuse == 0)

drivers/atm/he.c

2469

--he_dev->cs_stper[reg].inuse;

drivers/atm/he.c

2471

he_dev->total_bw -= he_dev->cs_stper[reg].pcr;

drivers/atm/he.c

2473

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2487

struct he_dev *he_dev = HE_DEV(vcc->dev);

drivers/atm/he.c

2488

unsigned cid = he_mkcid(he_dev, vcc->vpi, vcc->vci);

drivers/atm/he.c

2520

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

2522

tpd = __alloc_tpd(he_dev);

drivers/atm/he.c

2529

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2549

tpd->iovec[slot].addr = dma_map_single(&he_dev->pci_dev->dev, skb->data,

drivers/atm/he.c

2563

__enqueue_tpd(he_dev, tpd, cid);

drivers/atm/he.c

2564

tpd = __alloc_tpd(he_dev);

drivers/atm/he.c

2571

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2578

tpd->iovec[slot].addr = skb_frag_dma_map(&he_dev->pci_dev->dev,

drivers/atm/he.c

2587

tpd->address0 = dma_map_single(&he_dev->pci_dev->dev, skb->data, skb->len, DMA_TO_DEVICE);

drivers/atm/he.c

2597

__enqueue_tpd(he_dev, tpd, cid);

drivers/atm/he.c

2598

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2609

struct he_dev *he_dev = HE_DEV(atm_dev);

drivers/atm/he.c

2622

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

2630

reg.val = he_readl(he_dev, reg.addr);

drivers/atm/he.c

2634

he_readl_rcm(he_dev, reg.addr);

drivers/atm/he.c

2638

he_readl_tcm(he_dev, reg.addr);

drivers/atm/he.c

2642

he_readl_mbox(he_dev, reg.addr);

drivers/atm/he.c

2648

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2671

struct he_dev *he_dev = HE_DEV(atm_dev);

drivers/atm/he.c

2675

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

2676

he_writel(he_dev, val, FRAMER + (addr*4));

drivers/atm/he.c

2677

(void) he_readl(he_dev, FRAMER + (addr*4)); /* flush posted writes */

drivers/atm/he.c

2678

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2686

struct he_dev *he_dev = HE_DEV(atm_dev);

drivers/atm/he.c

2689

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

2690

reg = he_readl(he_dev, FRAMER + (addr*4));

drivers/atm/he.c

2691

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2701

struct he_dev *he_dev = HE_DEV(dev);

drivers/atm/he.c

2717

he_dev->prod_id, he_dev->media & 0x40 ? "SM" : "MM");

drivers/atm/he.c

2722

spin_lock_irqsave(&he_dev->global_lock, flags);

drivers/atm/he.c

2723

mcc += he_readl(he_dev, MCC);

drivers/atm/he.c

2724

oec += he_readl(he_dev, OEC);

drivers/atm/he.c

2725

dcc += he_readl(he_dev, DCC);

drivers/atm/he.c

2726

cec += he_readl(he_dev, CEC);

drivers/atm/he.c

2727

spin_unlock_irqrestore(&he_dev->global_lock, flags);

drivers/atm/he.c

2735

CONFIG_IRQ_SIZE, he_dev->irq_peak);

drivers/atm/he.c

2743

CONFIG_RBRQ_SIZE, he_dev->rbrq_peak);

drivers/atm/he.c

2747

CONFIG_TBRQ_SIZE, he_dev->tbrq_peak);

drivers/atm/he.c

2751

rbpl_head = RBPL_MASK(he_readl(he_dev, G0_RBPL_S));

drivers/atm/he.c

2752

rbpl_tail = RBPL_MASK(he_readl(he_dev, G0_RBPL_T));

drivers/atm/he.c

2770

he_dev->cs_stper[i].pcr,

drivers/atm/he.c

2771

he_dev->cs_stper[i].inuse);

drivers/atm/he.c

2775

he_dev->total_bw, he_dev->atm_dev->link_rate * 10 / 9);

drivers/atm/he.c

2782

static u8 read_prom_byte(struct he_dev *he_dev, int addr)

drivers/atm/he.c

2788

val = readl(he_dev->membase + HOST_CNTL);

drivers/atm/he.c

2793

he_writel(he_dev, val, HOST_CNTL);

drivers/atm/he.c

2797

he_writel(he_dev, val | readtab[i], HOST_CNTL);

drivers/atm/he.c

2803

he_writel(he_dev, val | clocktab[j++] | (((addr >> i) & 1) << 9), HOST_CNTL);

drivers/atm/he.c

2805

he_writel(he_dev, val | clocktab[j++] | (((addr >> i) & 1) << 9), HOST_CNTL);

drivers/atm/he.c

2812

he_writel(he_dev, val, HOST_CNTL);

drivers/atm/he.c

2816

he_writel(he_dev, val | clocktab[j++], HOST_CNTL);

drivers/atm/he.c

2818

tmp_read = he_readl(he_dev, HOST_CNTL);

drivers/atm/he.c

2821

he_writel(he_dev, val | clocktab[j++], HOST_CNTL);

drivers/atm/he.c

2825

he_writel(he_dev, val | ID_CS, HOST_CNTL);

drivers/atm/he.c

328

__find_vcc(struct he_dev *he_dev, unsigned cid)

drivers/atm/he.c

336

vpi = cid >> he_dev->vcibits;

drivers/atm/he.c

337

vci = cid & ((1 << he_dev->vcibits) - 1);

drivers/atm/he.c

342

if (vcc->dev == he_dev->atm_dev &&

drivers/atm/he.c

355

struct he_dev *he_dev = NULL;

drivers/atm/he.c

375

he_dev = kzalloc_obj(struct he_dev);

drivers/atm/he.c

376

if (!he_dev) {

drivers/atm/he.c

380

he_dev->pci_dev = pci_dev;

drivers/atm/he.c

381

he_dev->atm_dev = atm_dev;

drivers/atm/he.c

382

he_dev->atm_dev->dev_data = he_dev;

drivers/atm/he.c

383

atm_dev->dev_data = he_dev;

drivers/atm/he.c

384

he_dev->number = atm_dev->number;

drivers/atm/he.c

385

tasklet_init(&he_dev->tasklet, he_tasklet, (unsigned long) he_dev);

drivers/atm/he.c

386

spin_lock_init(&he_dev->global_lock);

drivers/atm/he.c

389

he_stop(he_dev);

drivers/atm/he.c

393

he_dev->next = NULL;

drivers/atm/he.c

395

he_dev->next = he_devs;

drivers/atm/he.c

396

he_devs = he_dev;

drivers/atm/he.c

402

kfree(he_dev);

drivers/atm/he.c

410

struct he_dev *he_dev;

drivers/atm/he.c

413

he_dev = HE_DEV(atm_dev);

drivers/atm/he.c

417

he_stop(he_dev);

drivers/atm/he.c

419

kfree(he_dev);

drivers/atm/he.c

444

static void he_init_rx_lbfp0(struct he_dev *he_dev)

drivers/atm/he.c

447

unsigned lbufs_per_row = he_dev->cells_per_row / he_dev->cells_per_lbuf;

drivers/atm/he.c

448

unsigned lbuf_bufsize = he_dev->cells_per_lbuf * ATM_CELL_PAYLOAD;

drivers/atm/he.c

449

unsigned row_offset = he_dev->r0_startrow * he_dev->bytes_per_row;

drivers/atm/he.c

452

lbm_offset = he_readl(he_dev, RCMLBM_BA);

drivers/atm/he.c

454

he_writel(he_dev, lbufd_index, RLBF0_H);

drivers/atm/he.c

456

for (i = 0, lbuf_count = 0; i < he_dev->r0_numbuffs; ++i) {

drivers/atm/he.c

460

he_writel_rcm(he_dev, lbuf_addr, lbm_offset);

drivers/atm/he.c

461

he_writel_rcm(he_dev, lbufd_index, lbm_offset + 1);

drivers/atm/he.c

465

row_offset += he_dev->bytes_per_row;

drivers/atm/he.c

470

he_writel(he_dev, lbufd_index - 2, RLBF0_T);

drivers/atm/he.c

471

he_writel(he_dev, he_dev->r0_numbuffs, RLBF0_C);

drivers/atm/he.c

474

static void he_init_rx_lbfp1(struct he_dev *he_dev)

drivers/atm/he.c

477

unsigned lbufs_per_row = he_dev->cells_per_row / he_dev->cells_per_lbuf;

drivers/atm/he.c

478

unsigned lbuf_bufsize = he_dev->cells_per_lbuf * ATM_CELL_PAYLOAD;

drivers/atm/he.c

479

unsigned row_offset = he_dev->r1_startrow * he_dev->bytes_per_row;

drivers/atm/he.c

482

lbm_offset = he_readl(he_dev, RCMLBM_BA) + (2 * lbufd_index);

drivers/atm/he.c

484

he_writel(he_dev, lbufd_index, RLBF1_H);

drivers/atm/he.c

486

for (i = 0, lbuf_count = 0; i < he_dev->r1_numbuffs; ++i) {

drivers/atm/he.c

490

he_writel_rcm(he_dev, lbuf_addr, lbm_offset);

drivers/atm/he.c

491

he_writel_rcm(he_dev, lbufd_index, lbm_offset + 1);

drivers/atm/he.c

495

row_offset += he_dev->bytes_per_row;

drivers/atm/he.c

500

he_writel(he_dev, lbufd_index - 2, RLBF1_T);

drivers/atm/he.c

501

he_writel(he_dev, he_dev->r1_numbuffs, RLBF1_C);

drivers/atm/he.c

504

static void he_init_tx_lbfp(struct he_dev *he_dev)

drivers/atm/he.c

507

unsigned lbufs_per_row = he_dev->cells_per_row / he_dev->cells_per_lbuf;

drivers/atm/he.c

508

unsigned lbuf_bufsize = he_dev->cells_per_lbuf * ATM_CELL_PAYLOAD;

drivers/atm/he.c

509

unsigned row_offset = he_dev->tx_startrow * he_dev->bytes_per_row;

drivers/atm/he.c

511

lbufd_index = he_dev->r0_numbuffs + he_dev->r1_numbuffs;

drivers/atm/he.c

512

lbm_offset = he_readl(he_dev, RCMLBM_BA) + (2 * lbufd_index);

drivers/atm/he.c

514

he_writel(he_dev, lbufd_index, TLBF_H);

drivers/atm/he.c

516

for (i = 0, lbuf_count = 0; i < he_dev->tx_numbuffs; ++i) {

drivers/atm/he.c

520

he_writel_rcm(he_dev, lbuf_addr, lbm_offset);

drivers/atm/he.c

521

he_writel_rcm(he_dev, lbufd_index, lbm_offset + 1);

drivers/atm/he.c

525

row_offset += he_dev->bytes_per_row;

drivers/atm/he.c

530

he_writel(he_dev, lbufd_index - 1, TLBF_T);

drivers/atm/he.c

533

static int he_init_tpdrq(struct he_dev *he_dev)

drivers/atm/he.c

535

he_dev->tpdrq_base = dma_alloc_coherent(&he_dev->pci_dev->dev,

drivers/atm/he.c

537

&he_dev->tpdrq_phys,

drivers/atm/he.c

539

if (he_dev->tpdrq_base == NULL) {

drivers/atm/he.c

544

he_dev->tpdrq_tail = he_dev->tpdrq_base;

drivers/atm/he.c

545

he_dev->tpdrq_head = he_dev->tpdrq_base;

drivers/atm/he.c

547

he_writel(he_dev, he_dev->tpdrq_phys, TPDRQ_B_H);

drivers/atm/he.c

548

he_writel(he_dev, 0, TPDRQ_T);

drivers/atm/he.c

549

he_writel(he_dev, CONFIG_TPDRQ_SIZE - 1, TPDRQ_S);

drivers/atm/he.c

554

static void he_init_cs_block(struct he_dev *he_dev)

drivers/atm/he.c

562

he_writel_mbox(he_dev, 0x0, CS_STTIM0 + reg);

drivers/atm/he.c

566

clock = he_is622(he_dev) ? 66667000 : 50000000;

drivers/atm/he.c

567

rate = he_dev->atm_dev->link_rate;

drivers/atm/he.c

578

he_writel_mbox(he_dev, period, CS_TGRLD0 + reg);

drivers/atm/he.c

582

if (he_is622(he_dev)) {

drivers/atm/he.c

584

he_writel_mbox(he_dev, 0x000800fa, CS_ERTHR0);

drivers/atm/he.c

585

he_writel_mbox(he_dev, 0x000c33cb, CS_ERTHR1);

drivers/atm/he.c

586

he_writel_mbox(he_dev, 0x0010101b, CS_ERTHR2);

drivers/atm/he.c

587

he_writel_mbox(he_dev, 0x00181dac, CS_ERTHR3);

drivers/atm/he.c

588

he_writel_mbox(he_dev, 0x00280600, CS_ERTHR4);

drivers/atm/he.c

591

he_writel_mbox(he_dev, 0x023de8b3, CS_ERCTL0);

drivers/atm/he.c

592

he_writel_mbox(he_dev, 0x1801, CS_ERCTL1);

drivers/atm/he.c

593

he_writel_mbox(he_dev, 0x68b3, CS_ERCTL2);

drivers/atm/he.c

594

he_writel_mbox(he_dev, 0x1280, CS_ERSTAT0);

drivers/atm/he.c

595

he_writel_mbox(he_dev, 0x68b3, CS_ERSTAT1);

drivers/atm/he.c

596

he_writel_mbox(he_dev, 0x14585, CS_RTFWR);

drivers/atm/he.c

598

he_writel_mbox(he_dev, 0x4680, CS_RTATR);

drivers/atm/he.c

601

he_writel_mbox(he_dev, 0x00159ece, CS_TFBSET);

drivers/atm/he.c

602

he_writel_mbox(he_dev, 0x68b3, CS_WCRMAX);

drivers/atm/he.c

603

he_writel_mbox(he_dev, 0x5eb3, CS_WCRMIN);

drivers/atm/he.c

604

he_writel_mbox(he_dev, 0xe8b3, CS_WCRINC);

drivers/atm/he.c

605

he_writel_mbox(he_dev, 0xdeb3, CS_WCRDEC);

drivers/atm/he.c

606

he_writel_mbox(he_dev, 0x68b3, CS_WCRCEIL);

drivers/atm/he.c

609

he_writel_mbox(he_dev, 0x5, CS_OTPPER);

drivers/atm/he.c

610

he_writel_mbox(he_dev, 0x14, CS_OTWPER);

drivers/atm/he.c

613

he_writel_mbox(he_dev, 0x000400ea, CS_ERTHR0);

drivers/atm/he.c

614

he_writel_mbox(he_dev, 0x00063388, CS_ERTHR1);

drivers/atm/he.c

615

he_writel_mbox(he_dev, 0x00081018, CS_ERTHR2);

drivers/atm/he.c

616

he_writel_mbox(he_dev, 0x000c1dac, CS_ERTHR3);

drivers/atm/he.c

617

he_writel_mbox(he_dev, 0x0014051a, CS_ERTHR4);

drivers/atm/he.c

620

he_writel_mbox(he_dev, 0x0235e4b1, CS_ERCTL0);

drivers/atm/he.c

621

he_writel_mbox(he_dev, 0x4701, CS_ERCTL1);

drivers/atm/he.c

622

he_writel_mbox(he_dev, 0x64b1, CS_ERCTL2);

drivers/atm/he.c

623

he_writel_mbox(he_dev, 0x1280, CS_ERSTAT0);

drivers/atm/he.c

624

he_writel_mbox(he_dev, 0x64b1, CS_ERSTAT1);

drivers/atm/he.c

625

he_writel_mbox(he_dev, 0xf424, CS_RTFWR);

drivers/atm/he.c

627

he_writel_mbox(he_dev, 0x4680, CS_RTATR);

drivers/atm/he.c

630

he_writel_mbox(he_dev, 0x000563b7, CS_TFBSET);

drivers/atm/he.c

631

he_writel_mbox(he_dev, 0x64b1, CS_WCRMAX);

drivers/atm/he.c

632

he_writel_mbox(he_dev, 0x5ab1, CS_WCRMIN);

drivers/atm/he.c

633

he_writel_mbox(he_dev, 0xe4b1, CS_WCRINC);

drivers/atm/he.c

634

he_writel_mbox(he_dev, 0xdab1, CS_WCRDEC);

drivers/atm/he.c

635

he_writel_mbox(he_dev, 0x64b1, CS_WCRCEIL);

drivers/atm/he.c

638

he_writel_mbox(he_dev, 0x6, CS_OTPPER);

drivers/atm/he.c

639

he_writel_mbox(he_dev, 0x1e, CS_OTWPER);

drivers/atm/he.c

642

he_writel_mbox(he_dev, 0x8, CS_OTTLIM);

drivers/atm/he.c

645

he_writel_mbox(he_dev, 0x0, CS_HGRRT0 + reg);

drivers/atm/he.c

649

static int he_init_cs_block_rcm(struct he_dev *he_dev)

drivers/atm/he.c

666

he_writel_rcm(he_dev, 0x0, CONFIG_RCMABR + reg);

drivers/atm/he.c

671

he_writel_rcm(he_dev, 0x0, CONFIG_RCMABR + reg);

drivers/atm/he.c

681

rate = he_dev->atm_dev->link_rate;

drivers/atm/he.c

736

buf = rate_cps * he_dev->tx_numbuffs /

drivers/atm/he.c

737

(he_dev->atm_dev->link_rate * 2);

drivers/atm/he.c

740

mult = he_dev->atm_dev->link_rate / ATM_OC3_PCR;

drivers/atm/he.c

759

he_writel_rcm(he_dev, reg,

drivers/atm/he.c

769

static int he_init_group(struct he_dev *he_dev, int group)

drivers/atm/he.c

775

he_writel(he_dev, 0x0, G0_RBPS_S + (group * 32));

drivers/atm/he.c

776

he_writel(he_dev, 0x0, G0_RBPS_T + (group * 32));

drivers/atm/he.c

777

he_writel(he_dev, 0x0, G0_RBPS_QI + (group * 32));

drivers/atm/he.c

778

he_writel(he_dev, RBP_THRESH(0x1) | RBP_QSIZE(0x0),

drivers/atm/he.c

782

he_dev->rbpl_table = bitmap_zalloc(RBPL_TABLE_SIZE, GFP_KERNEL);

drivers/atm/he.c

783

if (!he_dev->rbpl_table) {

drivers/atm/he.c

789

he_dev->rbpl_virt = kmalloc_objs(*he_dev->rbpl_virt, RBPL_TABLE_SIZE);

drivers/atm/he.c

790

if (!he_dev->rbpl_virt) {

drivers/atm/he.c

796

he_dev->rbpl_pool = dma_pool_create("rbpl", &he_dev->pci_dev->dev,

drivers/atm/he.c

798

if (he_dev->rbpl_pool == NULL) {

drivers/atm/he.c

803

he_dev->rbpl_base = dma_alloc_coherent(&he_dev->pci_dev->dev,

drivers/atm/he.c

805

&he_dev->rbpl_phys, GFP_KERNEL);

drivers/atm/he.c

806

if (he_dev->rbpl_base == NULL) {

drivers/atm/he.c

811

INIT_LIST_HEAD(&he_dev->rbpl_outstanding);

drivers/atm/he.c

815

heb = dma_pool_alloc(he_dev->rbpl_pool, GFP_KERNEL, &mapping);

drivers/atm/he.c

819

list_add(&heb->entry, &he_dev->rbpl_outstanding);

drivers/atm/he.c

821

set_bit(i, he_dev->rbpl_table);

drivers/atm/he.c

822

he_dev->rbpl_virt[i] = heb;

drivers/atm/he.c

823

he_dev->rbpl_hint = i + 1;

drivers/atm/he.c

824

he_dev->rbpl_base[i].idx = i << RBP_IDX_OFFSET;

drivers/atm/he.c

825

he_dev->rbpl_base[i].phys = mapping + offsetof(struct he_buff, data);

drivers/atm/he.c

827

he_dev->rbpl_tail = &he_dev->rbpl_base[CONFIG_RBPL_SIZE - 1];

drivers/atm/he.c

829

he_writel(he_dev, he_dev->rbpl_phys, G0_RBPL_S + (group * 32));

drivers/atm/he.c

830

he_writel(he_dev, RBPL_MASK(he_dev->rbpl_tail),

drivers/atm/he.c

832

he_writel(he_dev, (CONFIG_RBPL_BUFSIZE - sizeof(struct he_buff))/4,

drivers/atm/he.c

834

he_writel(he_dev,

drivers/atm/he.c

842

he_dev->rbrq_base = dma_alloc_coherent(&he_dev->pci_dev->dev,

drivers/atm/he.c

844

&he_dev->rbrq_phys, GFP_KERNEL);

drivers/atm/he.c

845

if (he_dev->rbrq_base == NULL) {

drivers/atm/he.c

850

he_dev->rbrq_head = he_dev->rbrq_base;

drivers/atm/he.c

851

he_writel(he_dev, he_dev->rbrq_phys, G0_RBRQ_ST + (group * 16));

drivers/atm/he.c

852

he_writel(he_dev, 0, G0_RBRQ_H + (group * 16));

drivers/atm/he.c

853

he_writel(he_dev,

drivers/atm/he.c

858

he_writel(he_dev, RBRQ_TIME(768) | RBRQ_COUNT(7),

drivers/atm/he.c

861

he_writel(he_dev, RBRQ_TIME(0) | RBRQ_COUNT(1),

drivers/atm/he.c

866

he_dev->tbrq_base = dma_alloc_coherent(&he_dev->pci_dev->dev,

drivers/atm/he.c

868

&he_dev->tbrq_phys, GFP_KERNEL);

drivers/atm/he.c

869

if (he_dev->tbrq_base == NULL) {

drivers/atm/he.c

874

he_dev->tbrq_head = he_dev->tbrq_base;

drivers/atm/he.c

876

he_writel(he_dev, he_dev->tbrq_phys, G0_TBRQ_B_T + (group * 16));

drivers/atm/he.c

877

he_writel(he_dev, 0, G0_TBRQ_H + (group * 16));

drivers/atm/he.c

878

he_writel(he_dev, CONFIG_TBRQ_SIZE - 1, G0_TBRQ_S + (group * 16));

drivers/atm/he.c

879

he_writel(he_dev, CONFIG_TBRQ_THRESH, G0_TBRQ_THRESH + (group * 16));

drivers/atm/he.c

88

#define hprintk(fmt,args...) printk(KERN_ERR DEV_LABEL "%d: " fmt, he_dev->number , ##args)

drivers/atm/he.c

884

dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBRQ_SIZE *

drivers/atm/he.c

885

sizeof(struct he_rbrq), he_dev->rbrq_base,

drivers/atm/he.c

886

he_dev->rbrq_phys);

drivers/atm/he.c

888

list_for_each_entry_safe(heb, next, &he_dev->rbpl_outstanding, entry)

drivers/atm/he.c

889

dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping);

drivers/atm/he.c

891

dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBPL_SIZE *

drivers/atm/he.c

892

sizeof(struct he_rbp), he_dev->rbpl_base,

drivers/atm/he.c

893

he_dev->rbpl_phys);

drivers/atm/he.c

895

dma_pool_destroy(he_dev->rbpl_pool);

drivers/atm/he.c

897

kfree(he_dev->rbpl_virt);

drivers/atm/he.c

899

bitmap_free(he_dev->rbpl_table);

drivers/atm/he.c

904

static int he_init_irq(struct he_dev *he_dev)

drivers/atm/he.c

91

#define HPRINTK(fmt,args...) printk(KERN_DEBUG DEV_LABEL "%d: " fmt, he_dev->number , ##args)

drivers/atm/he.c

911

he_dev->irq_base = dma_alloc_coherent(&he_dev->pci_dev->dev,

drivers/atm/he.c

913

&he_dev->irq_phys, GFP_KERNEL);

drivers/atm/he.c

914

if (he_dev->irq_base == NULL) {

drivers/atm/he.c

918

he_dev->irq_tailoffset = (unsigned *)

drivers/atm/he.c

919

&he_dev->irq_base[CONFIG_IRQ_SIZE];

drivers/atm/he.c

920

*he_dev->irq_tailoffset = 0;

drivers/atm/he.c

921

he_dev->irq_head = he_dev->irq_base;

drivers/atm/he.c

922

he_dev->irq_tail = he_dev->irq_base;

drivers/atm/he.c

925

he_dev->irq_base[i].isw = ITYPE_INVALID;

drivers/atm/he.c

927

he_writel(he_dev, he_dev->irq_phys, IRQ0_BASE);

drivers/atm/he.c

928

he_writel(he_dev,

drivers/atm/he.c

931

he_writel(he_dev, IRQ_INT_A | IRQ_TYPE_LINE, IRQ0_CNTL);

drivers/atm/he.c

932

he_writel(he_dev, 0x0, IRQ0_DATA);

drivers/atm/he.c

934

he_writel(he_dev, 0x0, IRQ1_BASE);

drivers/atm/he.c

935

he_writel(he_dev, 0x0, IRQ1_HEAD);

drivers/atm/he.c

936

he_writel(he_dev, 0x0, IRQ1_CNTL);

drivers/atm/he.c

937

he_writel(he_dev, 0x0, IRQ1_DATA);

drivers/atm/he.c

939

he_writel(he_dev, 0x0, IRQ2_BASE);

drivers/atm/he.c

940

he_writel(he_dev, 0x0, IRQ2_HEAD);

drivers/atm/he.c

941

he_writel(he_dev, 0x0, IRQ2_CNTL);

drivers/atm/he.c

942

he_writel(he_dev, 0x0, IRQ2_DATA);

drivers/atm/he.c

944

he_writel(he_dev, 0x0, IRQ3_BASE);

drivers/atm/he.c

945

he_writel(he_dev, 0x0, IRQ3_HEAD);

drivers/atm/he.c

946

he_writel(he_dev, 0x0, IRQ3_CNTL);

drivers/atm/he.c

947

he_writel(he_dev, 0x0, IRQ3_DATA);

drivers/atm/he.c

951

he_writel(he_dev, 0x0, GRP_10_MAP);

drivers/atm/he.c

952

he_writel(he_dev, 0x0, GRP_32_MAP);

drivers/atm/he.c

953

he_writel(he_dev, 0x0, GRP_54_MAP);

drivers/atm/he.c

954

he_writel(he_dev, 0x0, GRP_76_MAP);

drivers/atm/he.c

956

if (request_irq(he_dev->pci_dev->irq,

drivers/atm/he.c

957

he_irq_handler, IRQF_SHARED, DEV_LABEL, he_dev)) {

drivers/atm/he.c

958

hprintk("irq %d already in use\n", he_dev->pci_dev->irq);

drivers/atm/he.c

962

he_dev->irq = he_dev->pci_dev->irq;

drivers/atm/he.c

969

struct he_dev *he_dev;

drivers/atm/he.c

981

he_dev = HE_DEV(dev);

drivers/atm/he.c

982

pci_dev = he_dev->pci_dev;

drivers/atm/he.h

314

struct he_dev *next;

drivers/atm/he.h

345

#define HE_DEV(dev) ((struct he_dev *) (dev)->dev_data)