drivers/clk/imx/clk-imx31.c

64

clk[nfc] = imx_clk_divider("nfc", "ahb", base + MXC_CCM_PDR0, 8, 3);

drivers/mtd/nand/raw/arasan-nand-controller.c

1107

static int anfc_init_hw_ecc_controller(struct arasan_nfc *nfc,

drivers/mtd/nand/raw/arasan-nand-controller.c

1124

dev_err(nfc->dev, "Unsupported page size %d\n", mtd->writesize);

drivers/mtd/nand/raw/arasan-nand-controller.c

1146

dev_err(nfc->dev, "Unsupported strength %d\n", ecc->strength);

drivers/mtd/nand/raw/arasan-nand-controller.c

1160

dev_err(nfc->dev, "Unsupported step size %d\n", ecc->strength);

drivers/mtd/nand/raw/arasan-nand-controller.c

1176

anand->errloc = devm_kmalloc_array(nfc->dev, ecc->strength,

drivers/mtd/nand/raw/arasan-nand-controller.c

1181

anand->hw_ecc = devm_kmalloc(nfc->dev, ecc->bytes, GFP_KERNEL);

drivers/mtd/nand/raw/arasan-nand-controller.c

1199

struct arasan_nfc *nfc = to_anfc(chip->controller);

drivers/mtd/nand/raw/arasan-nand-controller.c

1246

ret = anfc_init_hw_ecc_controller(nfc, chip);

drivers/mtd/nand/raw/arasan-nand-controller.c

1249

dev_err(nfc->dev, "Unsupported ECC mode: %d\n",

drivers/mtd/nand/raw/arasan-nand-controller.c

1272

static int anfc_chip_init(struct arasan_nfc *nfc, struct device_node *np)

drivers/mtd/nand/raw/arasan-nand-controller.c

1279

anand = devm_kzalloc(nfc->dev, sizeof(*anand), GFP_KERNEL);

drivers/mtd/nand/raw/arasan-nand-controller.c

1285

if (anand->ncs_idx <= 0 || anand->ncs_idx > nfc->ncs) {

drivers/mtd/nand/raw/arasan-nand-controller.c

1286

dev_err(nfc->dev, "Invalid reg property\n");

drivers/mtd/nand/raw/arasan-nand-controller.c

1290

anand->cs_idx = devm_kcalloc(nfc->dev, anand->ncs_idx,

drivers/mtd/nand/raw/arasan-nand-controller.c

1299

dev_err(nfc->dev, "invalid CS property: %d\n", ret);

drivers/mtd/nand/raw/arasan-nand-controller.c

1310

dev_err(nfc->dev, "Wrong RB %d\n", rb);

drivers/mtd/nand/raw/arasan-nand-controller.c

1318

mtd->dev.parent = nfc->dev;

drivers/mtd/nand/raw/arasan-nand-controller.c

1319

chip->controller = &nfc->controller;

drivers/mtd/nand/raw/arasan-nand-controller.c

1325

dev_err(nfc->dev, "NAND label property is mandatory\n");

drivers/mtd/nand/raw/arasan-nand-controller.c

1331

dev_err(nfc->dev, "Scan operation failed\n");

drivers/mtd/nand/raw/arasan-nand-controller.c

1341

list_add_tail(&anand->node, &nfc->chips);

drivers/mtd/nand/raw/arasan-nand-controller.c

1346

static void anfc_chips_cleanup(struct arasan_nfc *nfc)

drivers/mtd/nand/raw/arasan-nand-controller.c

1352

list_for_each_entry_safe(anand, tmp, &nfc->chips, node) {

drivers/mtd/nand/raw/arasan-nand-controller.c

1361

static int anfc_chips_init(struct arasan_nfc *nfc)

drivers/mtd/nand/raw/arasan-nand-controller.c

1363

struct device_node *np = nfc->dev->of_node;

drivers/mtd/nand/raw/arasan-nand-controller.c

1368

dev_err(nfc->dev, "Incorrect number of NAND chips (%d)\n",

drivers/mtd/nand/raw/arasan-nand-controller.c

1374

ret = anfc_chip_init(nfc, nand_np);

drivers/mtd/nand/raw/arasan-nand-controller.c

1376

anfc_chips_cleanup(nfc);

drivers/mtd/nand/raw/arasan-nand-controller.c

1384

static void anfc_reset(struct arasan_nfc *nfc)

drivers/mtd/nand/raw/arasan-nand-controller.c

1387

writel_relaxed(0, nfc->base + INTR_SIG_EN_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

1390

writel_relaxed(EVENT_MASK, nfc->base + INTR_STS_EN_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

1392

nfc->cur_cs = -1;

drivers/mtd/nand/raw/arasan-nand-controller.c

1395

static int anfc_parse_cs(struct arasan_nfc *nfc)

drivers/mtd/nand/raw/arasan-nand-controller.c

1400

ret = rawnand_dt_parse_gpio_cs(nfc->dev, &nfc->cs_array, &nfc->ncs);

drivers/mtd/nand/raw/arasan-nand-controller.c

1412

if (nfc->cs_array) {

drivers/mtd/nand/raw/arasan-nand-controller.c

1413

if (nfc->ncs > 2 && !nfc->cs_array[0] && !nfc->cs_array[1]) {

drivers/mtd/nand/raw/arasan-nand-controller.c

1414

dev_err(nfc->dev,

drivers/mtd/nand/raw/arasan-nand-controller.c

1419

if (nfc->cs_array[0])

drivers/mtd/nand/raw/arasan-nand-controller.c

1420

nfc->spare_cs = 0;

drivers/mtd/nand/raw/arasan-nand-controller.c

1422

nfc->spare_cs = 1;

drivers/mtd/nand/raw/arasan-nand-controller.c

1425

if (!nfc->cs_array) {

drivers/mtd/nand/raw/arasan-nand-controller.c

1426

nfc->cs_array = anfc_default_cs_array;

drivers/mtd/nand/raw/arasan-nand-controller.c

1427

nfc->ncs = ANFC_MAX_CS;

drivers/mtd/nand/raw/arasan-nand-controller.c

1436

struct arasan_nfc *nfc;

drivers/mtd/nand/raw/arasan-nand-controller.c

1439

nfc = devm_kzalloc(&pdev->dev, sizeof(*nfc), GFP_KERNEL);

drivers/mtd/nand/raw/arasan-nand-controller.c

1440

if (!nfc)

drivers/mtd/nand/raw/arasan-nand-controller.c

1443

nfc->dev = &pdev->dev;

drivers/mtd/nand/raw/arasan-nand-controller.c

1444

nand_controller_init(&nfc->controller);

drivers/mtd/nand/raw/arasan-nand-controller.c

1445

nfc->controller.ops = &anfc_ops;

drivers/mtd/nand/raw/arasan-nand-controller.c

1446

INIT_LIST_HEAD(&nfc->chips);

drivers/mtd/nand/raw/arasan-nand-controller.c

1448

nfc->base = devm_platform_ioremap_resource(pdev, 0);

drivers/mtd/nand/raw/arasan-nand-controller.c

1449

if (IS_ERR(nfc->base))

drivers/mtd/nand/raw/arasan-nand-controller.c

1450

return PTR_ERR(nfc->base);

drivers/mtd/nand/raw/arasan-nand-controller.c

1452

anfc_reset(nfc);

drivers/mtd/nand/raw/arasan-nand-controller.c

1454

nfc->controller_clk = devm_clk_get_enabled(&pdev->dev, "controller");

drivers/mtd/nand/raw/arasan-nand-controller.c

1455

if (IS_ERR(nfc->controller_clk))

drivers/mtd/nand/raw/arasan-nand-controller.c

1456

return PTR_ERR(nfc->controller_clk);

drivers/mtd/nand/raw/arasan-nand-controller.c

1458

nfc->bus_clk = devm_clk_get_enabled(&pdev->dev, "bus");

drivers/mtd/nand/raw/arasan-nand-controller.c

1459

if (IS_ERR(nfc->bus_clk))

drivers/mtd/nand/raw/arasan-nand-controller.c

1460

return PTR_ERR(nfc->bus_clk);

drivers/mtd/nand/raw/arasan-nand-controller.c

1466

ret = anfc_parse_cs(nfc);

drivers/mtd/nand/raw/arasan-nand-controller.c

1470

ret = anfc_chips_init(nfc);

drivers/mtd/nand/raw/arasan-nand-controller.c

1474

platform_set_drvdata(pdev, nfc);

drivers/mtd/nand/raw/arasan-nand-controller.c

1482

struct arasan_nfc *nfc = platform_get_drvdata(pdev);

drivers/mtd/nand/raw/arasan-nand-controller.c

1484

for (i = 0; i < nfc->ncs; i++) {

drivers/mtd/nand/raw/arasan-nand-controller.c

1485

if (nfc->cs_array[i]) {

drivers/mtd/nand/raw/arasan-nand-controller.c

1486

gpiod_put(nfc->cs_array[i]);

drivers/mtd/nand/raw/arasan-nand-controller.c

1490

anfc_chips_cleanup(nfc);

drivers/mtd/nand/raw/arasan-nand-controller.c

234

static int anfc_wait_for_event(struct arasan_nfc *nfc, unsigned int event)

drivers/mtd/nand/raw/arasan-nand-controller.c

239

ret = readl_relaxed_poll_timeout(nfc->base + INTR_STS_REG, val,

drivers/mtd/nand/raw/arasan-nand-controller.c

243

dev_err(nfc->dev, "Timeout waiting for event 0x%x\n", event);

drivers/mtd/nand/raw/arasan-nand-controller.c

247

writel_relaxed(event, nfc->base + INTR_STS_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

252

static int anfc_wait_for_rb(struct arasan_nfc *nfc, struct nand_chip *chip,

drivers/mtd/nand/raw/arasan-nand-controller.c

260

ret = readl_relaxed_poll_timeout(nfc->base + READY_STS_REG, val,

drivers/mtd/nand/raw/arasan-nand-controller.c

264

dev_err(nfc->dev, "Timeout waiting for R/B 0x%x\n",

drivers/mtd/nand/raw/arasan-nand-controller.c

265

readl_relaxed(nfc->base + READY_STS_REG));

drivers/mtd/nand/raw/arasan-nand-controller.c

272

static void anfc_trigger_op(struct arasan_nfc *nfc, struct anfc_op *nfc_op)

drivers/mtd/nand/raw/arasan-nand-controller.c

274

writel_relaxed(nfc_op->pkt_reg, nfc->base + PKT_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

275

writel_relaxed(nfc_op->addr1_reg, nfc->base + MEM_ADDR1_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

276

writel_relaxed(nfc_op->addr2_reg, nfc->base + MEM_ADDR2_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

277

writel_relaxed(nfc_op->cmd_reg, nfc->base + CMD_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

278

writel_relaxed(nfc_op->prog_reg, nfc->base + PROG_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

304

static bool anfc_is_gpio_cs(struct arasan_nfc *nfc, int nfc_cs)

drivers/mtd/nand/raw/arasan-nand-controller.c

306

return nfc_cs >= 0 && nfc->cs_array[nfc_cs];

drivers/mtd/nand/raw/arasan-nand-controller.c

314

static void anfc_assert_cs(struct arasan_nfc *nfc, unsigned int nfc_cs_idx)

drivers/mtd/nand/raw/arasan-nand-controller.c

317

if (nfc->cur_cs == nfc_cs_idx)

drivers/mtd/nand/raw/arasan-nand-controller.c

321

if (anfc_is_gpio_cs(nfc, nfc->cur_cs))

drivers/mtd/nand/raw/arasan-nand-controller.c

322

gpiod_set_value_cansleep(nfc->cs_array[nfc->cur_cs], 1);

drivers/mtd/nand/raw/arasan-nand-controller.c

325

if (anfc_is_gpio_cs(nfc, nfc_cs_idx)) {

drivers/mtd/nand/raw/arasan-nand-controller.c

326

nfc->native_cs = nfc->spare_cs;

drivers/mtd/nand/raw/arasan-nand-controller.c

327

gpiod_set_value_cansleep(nfc->cs_array[nfc_cs_idx], 0);

drivers/mtd/nand/raw/arasan-nand-controller.c

329

nfc->native_cs = nfc_cs_idx;

drivers/mtd/nand/raw/arasan-nand-controller.c

332

nfc->cur_cs = nfc_cs_idx;

drivers/mtd/nand/raw/arasan-nand-controller.c

338

struct arasan_nfc *nfc = to_anfc(chip->controller);

drivers/mtd/nand/raw/arasan-nand-controller.c

342

anfc_assert_cs(nfc, nfc_cs_idx);

drivers/mtd/nand/raw/arasan-nand-controller.c

345

writel_relaxed(anand->data_iface, nfc->base + DATA_INTERFACE_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

346

writel_relaxed(anand->timings, nfc->base + TIMING_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

349

if (nfc->cur_clk != anand->clk) {

drivers/mtd/nand/raw/arasan-nand-controller.c

350

clk_disable_unprepare(nfc->bus_clk);

drivers/mtd/nand/raw/arasan-nand-controller.c

351

ret = clk_set_rate(nfc->bus_clk, anand->clk);

drivers/mtd/nand/raw/arasan-nand-controller.c

353

dev_err(nfc->dev, "Failed to change clock rate\n");

drivers/mtd/nand/raw/arasan-nand-controller.c

357

ret = clk_prepare_enable(nfc->bus_clk);

drivers/mtd/nand/raw/arasan-nand-controller.c

359

dev_err(nfc->dev,

drivers/mtd/nand/raw/arasan-nand-controller.c

364

nfc->cur_clk = anand->clk;

drivers/mtd/nand/raw/arasan-nand-controller.c

395

struct arasan_nfc *nfc = to_anfc(chip->controller);

drivers/mtd/nand/raw/arasan-nand-controller.c

412

ADDR2_CS(nfc->native_cs),

drivers/mtd/nand/raw/arasan-nand-controller.c

423

dma_addr = dma_map_single(nfc->dev, (void *)buf, len, DMA_FROM_DEVICE);

drivers/mtd/nand/raw/arasan-nand-controller.c

424

if (dma_mapping_error(nfc->dev, dma_addr)) {

drivers/mtd/nand/raw/arasan-nand-controller.c

425

dev_err(nfc->dev, "Buffer mapping error");

drivers/mtd/nand/raw/arasan-nand-controller.c

429

writel_relaxed(lower_32_bits(dma_addr), nfc->base + DMA_ADDR0_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

430

writel_relaxed(upper_32_bits(dma_addr), nfc->base + DMA_ADDR1_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

432

anfc_trigger_op(nfc, &nfc_op);

drivers/mtd/nand/raw/arasan-nand-controller.c

434

ret = anfc_wait_for_event(nfc, XFER_COMPLETE);

drivers/mtd/nand/raw/arasan-nand-controller.c

435

dma_unmap_single(nfc->dev, dma_addr, len, DMA_FROM_DEVICE);

drivers/mtd/nand/raw/arasan-nand-controller.c

437

dev_err(nfc->dev, "Error reading page %d\n", page);

drivers/mtd/nand/raw/arasan-nand-controller.c

514

struct arasan_nfc *nfc = to_anfc(chip->controller);

drivers/mtd/nand/raw/arasan-nand-controller.c

530

ADDR2_CS(nfc->native_cs),

drivers/mtd/nand/raw/arasan-nand-controller.c

542

writel_relaxed(anand->ecc_conf, nfc->base + ECC_CONF_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

545

nfc->base + ECC_SP_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

547

dma_addr = dma_map_single(nfc->dev, (void *)buf, len, DMA_TO_DEVICE);

drivers/mtd/nand/raw/arasan-nand-controller.c

548

if (dma_mapping_error(nfc->dev, dma_addr)) {

drivers/mtd/nand/raw/arasan-nand-controller.c

549

dev_err(nfc->dev, "Buffer mapping error");

drivers/mtd/nand/raw/arasan-nand-controller.c

553

writel_relaxed(lower_32_bits(dma_addr), nfc->base + DMA_ADDR0_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

554

writel_relaxed(upper_32_bits(dma_addr), nfc->base + DMA_ADDR1_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

556

anfc_trigger_op(nfc, &nfc_op);

drivers/mtd/nand/raw/arasan-nand-controller.c

557

ret = anfc_wait_for_event(nfc, XFER_COMPLETE);

drivers/mtd/nand/raw/arasan-nand-controller.c

558

dma_unmap_single(nfc->dev, dma_addr, len, DMA_TO_DEVICE);

drivers/mtd/nand/raw/arasan-nand-controller.c

560

dev_err(nfc->dev, "Error writing page %d\n", page);

drivers/mtd/nand/raw/arasan-nand-controller.c

599

struct arasan_nfc *nfc = to_anfc(chip->controller);

drivers/mtd/nand/raw/arasan-nand-controller.c

607

nfc_op->addr2_reg = ADDR2_CS(nfc->native_cs);

drivers/mtd/nand/raw/arasan-nand-controller.c

680

static int anfc_rw_pio_op(struct arasan_nfc *nfc, struct anfc_op *nfc_op)

drivers/mtd/nand/raw/arasan-nand-controller.c

690

ret = anfc_wait_for_event(nfc, dir);

drivers/mtd/nand/raw/arasan-nand-controller.c

692

dev_err(nfc->dev, "PIO %s ready signal not received\n",

drivers/mtd/nand/raw/arasan-nand-controller.c

699

ioread32_rep(nfc->base + DATA_PORT_REG, &buf[offset],

drivers/mtd/nand/raw/arasan-nand-controller.c

702

iowrite32_rep(nfc->base + DATA_PORT_REG, &buf[offset],

drivers/mtd/nand/raw/arasan-nand-controller.c

712

remainder = readl_relaxed(nfc->base + DATA_PORT_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

716

writel_relaxed(remainder, nfc->base + DATA_PORT_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

720

return anfc_wait_for_event(nfc, XFER_COMPLETE);

drivers/mtd/nand/raw/arasan-nand-controller.c

727

struct arasan_nfc *nfc = to_anfc(chip->controller);

drivers/mtd/nand/raw/arasan-nand-controller.c

736

anfc_trigger_op(nfc, &nfc_op);

drivers/mtd/nand/raw/arasan-nand-controller.c

739

ret = anfc_wait_for_rb(nfc, chip, nfc_op.rdy_timeout_ms);

drivers/mtd/nand/raw/arasan-nand-controller.c

744

return anfc_rw_pio_op(nfc, &nfc_op);

drivers/mtd/nand/raw/arasan-nand-controller.c

791

struct arasan_nfc *nfc = to_anfc(chip->controller);

drivers/mtd/nand/raw/arasan-nand-controller.c

800

anfc_trigger_op(nfc, &nfc_op);

drivers/mtd/nand/raw/arasan-nand-controller.c

802

ret = anfc_wait_for_event(nfc, XFER_COMPLETE);

drivers/mtd/nand/raw/arasan-nand-controller.c

807

ret = anfc_wait_for_rb(nfc, chip, nfc_op.rdy_timeout_ms);

drivers/mtd/nand/raw/arasan-nand-controller.c

815

struct arasan_nfc *nfc = to_anfc(chip->controller);

drivers/mtd/nand/raw/arasan-nand-controller.c

827

tmp = readl_relaxed(nfc->base + FLASH_STS_REG);

drivers/mtd/nand/raw/arasan-nand-controller.c

848

struct arasan_nfc *nfc = to_anfc(chip->controller);

drivers/mtd/nand/raw/arasan-nand-controller.c

856

return anfc_wait_for_rb(nfc, chip, nfc_op.rdy_timeout_ms);

drivers/mtd/nand/raw/arasan-nand-controller.c

978

struct arasan_nfc *nfc = to_anfc(chip->controller);

drivers/mtd/nand/raw/arasan-nand-controller.c

979

struct device_node *np = nfc->dev->of_node;

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

152

struct ingenic_nfc *nfc = to_ingenic_nfc(nand->chip.controller);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

166

return ingenic_ecc_calculate(nfc->ecc, &params, dat, ecc_code);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

173

struct ingenic_nfc *nfc = to_ingenic_nfc(nand->chip.controller);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

180

return ingenic_ecc_correct(nfc->ecc, &params, dat, read_ecc);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

186

struct ingenic_nfc *nfc = to_ingenic_nfc(chip->controller);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

199

if (!nfc->ecc) {

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

200

dev_err(nfc->dev, "HW ECC selected, but ECC controller not found\n");

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

209

dev_info(nfc->dev, "using %s (strength %d, size %d, bytes %d)\n",

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

210

(nfc->ecc) ? "hardware ECC" : "software ECC",

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

214

dev_info(nfc->dev, "not using ECC\n");

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

217

dev_err(nfc->dev, "ECC mode %d not supported\n",

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

230

dev_err(nfc->dev,

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

243

if (nfc->soc_info->oob_first)

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

249

else if (nfc->soc_info->oob_layout)

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

250

mtd_set_ooblayout(mtd, nfc->soc_info->oob_layout);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

262

struct ingenic_nfc *nfc = to_ingenic_nfc(chip->controller);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

268

cs->base + nfc->soc_info->cmd_offset);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

273

cs->base + nfc->soc_info->addr_offset);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

278

ioread8_rep(cs->base + nfc->soc_info->data_offset,

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

282

ioread16_rep(cs->base + nfc->soc_info->data_offset,

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

289

iowrite8_rep(cs->base + nfc->soc_info->data_offset,

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

293

iowrite16_rep(cs->base + nfc->soc_info->data_offset,

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

316

struct ingenic_nfc *nfc = to_ingenic_nfc(nand->chip.controller);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

324

cs = &nfc->cs[op->cs];

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

325

jz4780_nemc_assert(nfc->dev, cs->bank, true);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

334

jz4780_nemc_assert(nfc->dev, cs->bank, false);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

345

struct ingenic_nfc *nfc,

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

357

cs = &nfc->cs[chipnr];

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

365

jz4780_nemc_set_type(nfc->dev, cs->bank, JZ4780_NEMC_BANK_NAND);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

401

chip->controller = &nfc->controller;

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

415

list_add_tail(&nand->chip_list, &nfc->chips);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

420

static void ingenic_nand_cleanup_chips(struct ingenic_nfc *nfc)

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

426

while (!list_empty(&nfc->chips)) {

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

427

ingenic_chip = list_first_entry(&nfc->chips,

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

437

static int ingenic_nand_init_chips(struct ingenic_nfc *nfc,

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

445

if (num_chips > nfc->num_banks) {

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

447

num_chips, nfc->num_banks);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

452

ret = ingenic_nand_init_chip(pdev, nfc, np, i);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

454

ingenic_nand_cleanup_chips(nfc);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

468

struct ingenic_nfc *nfc;

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

477

nfc = devm_kzalloc(dev, struct_size(nfc, cs, num_banks), GFP_KERNEL);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

478

if (!nfc)

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

481

nfc->soc_info = device_get_match_data(dev);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

482

if (!nfc->soc_info)

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

489

nfc->ecc = of_ingenic_ecc_get(dev->of_node);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

490

if (IS_ERR(nfc->ecc))

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

491

return PTR_ERR(nfc->ecc);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

493

nfc->dev = dev;

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

494

nfc->num_banks = num_banks;

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

496

nand_controller_init(&nfc->controller);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

497

INIT_LIST_HEAD(&nfc->chips);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

499

ret = ingenic_nand_init_chips(nfc, pdev);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

501

if (nfc->ecc)

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

502

ingenic_ecc_release(nfc->ecc);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

506

platform_set_drvdata(pdev, nfc);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

512

struct ingenic_nfc *nfc = platform_get_drvdata(pdev);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

514

if (nfc->ecc)

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

515

ingenic_ecc_release(nfc->ecc);

drivers/mtd/nand/raw/ingenic/ingenic_nand_drv.c

517

ingenic_nand_cleanup_chips(nfc);

drivers/mtd/nand/raw/marvell_nand.c

1003

ndsr = readl_relaxed(nfc->regs + NDSR);

drivers/mtd/nand/raw/marvell_nand.c

1007

writel_relaxed(ndsr, nfc->regs + NDSR);

drivers/mtd/nand/raw/marvell_nand.c

1021

writel_relaxed(ndsr, nfc->regs + NDSR);

drivers/mtd/nand/raw/marvell_nand.c

1042

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

1057

if (nfc->caps->is_nfcv2)

drivers/mtd/nand/raw/marvell_nand.c

1076

if (nfc->use_dma) {

drivers/mtd/nand/raw/marvell_nand.c

1077

marvell_nfc_xfer_data_dma(nfc, DMA_FROM_DEVICE,

drivers/mtd/nand/raw/marvell_nand.c

1079

memcpy(data_buf, nfc->dma_buf, lt->data_bytes);

drivers/mtd/nand/raw/marvell_nand.c

1080

memcpy(oob_buf, nfc->dma_buf + lt->data_bytes, oob_bytes);

drivers/mtd/nand/raw/marvell_nand.c

1082

marvell_nfc_xfer_data_in_pio(nfc, data_buf, lt->data_bytes);

drivers/mtd/nand/raw/marvell_nand.c

1083

marvell_nfc_xfer_data_in_pio(nfc, oob_buf, oob_bytes);

drivers/mtd/nand/raw/marvell_nand.c

1156

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

1172

if (nfc->caps->is_nfcv2)

drivers/mtd/nand/raw/marvell_nand.c

1186

if (nfc->use_dma) {

drivers/mtd/nand/raw/marvell_nand.c

1187

memcpy(nfc->dma_buf, data_buf, lt->data_bytes);

drivers/mtd/nand/raw/marvell_nand.c

1188

memcpy(nfc->dma_buf + lt->data_bytes, oob_buf, oob_bytes);

drivers/mtd/nand/raw/marvell_nand.c

1189

marvell_nfc_xfer_data_dma(nfc, DMA_TO_DEVICE, lt->data_bytes +

drivers/mtd/nand/raw/marvell_nand.c

1192

marvell_nfc_xfer_data_out_pio(nfc, data_buf, lt->data_bytes);

drivers/mtd/nand/raw/marvell_nand.c

1193

marvell_nfc_xfer_data_out_pio(nfc, oob_buf, oob_bytes);

drivers/mtd/nand/raw/marvell_nand.c

1312

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

1359

marvell_nfc_xfer_data_in_pio(nfc, data,

drivers/mtd/nand/raw/marvell_nand.c

1367

marvell_nfc_xfer_data_in_pio(nfc, spare,

drivers/mtd/nand/raw/marvell_nand.c

1574

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

1623

iowrite32_rep(nfc->regs + NDDB, data, FIFO_REP(data_len));

drivers/mtd/nand/raw/marvell_nand.c

1624

iowrite32_rep(nfc->regs + NDDB, spare, FIFO_REP(spare_len));

drivers/mtd/nand/raw/marvell_nand.c

1717

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

1770

if (nfc->caps->is_nfcv2) {

drivers/mtd/nand/raw/marvell_nand.c

1784

if (nfc->caps->is_nfcv2) {

drivers/mtd/nand/raw/marvell_nand.c

1806

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

1820

ret = marvell_nfc_xfer_data_in_pio(nfc, in, len);

drivers/mtd/nand/raw/marvell_nand.c

1824

ret = marvell_nfc_xfer_data_out_pio(nfc, out, len);

drivers/mtd/nand/raw/marvell_nand.c

1888

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

1890

writel_relaxed(readl(nfc->regs + NDCR) & ~NDCR_ND_RUN,

drivers/mtd/nand/raw/marvell_nand.c

1891

nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

1960

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

1962

writel_relaxed(readl(nfc->regs + NDCR) & ~NDCR_ND_RUN,

drivers/mtd/nand/raw/marvell_nand.c

1963

nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

2185

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

2190

if (nfc->caps->is_nfcv2)

drivers/mtd/nand/raw/marvell_nand.c

2251

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

2255

if (!nfc->caps->is_nfcv2 &&

drivers/mtd/nand/raw/marvell_nand.c

2257

dev_err(nfc->dev,

drivers/mtd/nand/raw/marvell_nand.c

2274

(!nfc->caps->is_nfcv2 && ecc->strength > 1)) {

drivers/mtd/nand/raw/marvell_nand.c

2275

dev_err(nfc->dev,

drivers/mtd/nand/raw/marvell_nand.c

2284

dev_err(nfc->dev, "Requested layout needs at least 128 OOB bytes\n");

drivers/mtd/nand/raw/marvell_nand.c

2327

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

2336

dev_info(nfc->dev,

drivers/mtd/nand/raw/marvell_nand.c

2352

if (!nfc->caps->is_nfcv2 && mtd->writesize != SZ_512 &&

drivers/mtd/nand/raw/marvell_nand.c

2354

dev_err(nfc->dev, "NFCv1 cannot write %d bytes pages\n",

drivers/mtd/nand/raw/marvell_nand.c

2393

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

2394

unsigned int period_ns = 1000000000 / clk_get_rate(nfc->core_clk) * 2;

drivers/mtd/nand/raw/marvell_nand.c

2403

if (nfc->caps->max_mode_number && nfc->caps->max_mode_number < conf->timings.mode)

drivers/mtd/nand/raw/marvell_nand.c

2448

if (nfc->caps->is_nfcv2) {

drivers/mtd/nand/raw/marvell_nand.c

2476

if (nfc->caps->is_nfcv2) {

drivers/mtd/nand/raw/marvell_nand.c

2491

nfc->selected_chip = NULL;

drivers/mtd/nand/raw/marvell_nand.c

2500

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

2501

struct pxa3xx_nand_platform_data *pdata = dev_get_platdata(nfc->dev);

drivers/mtd/nand/raw/marvell_nand.c

2553

dev_err(nfc->dev, "ECC init failed: %d\n", ret);

drivers/mtd/nand/raw/marvell_nand.c

2567

if (pdata || nfc->caps->legacy_of_bindings) {

drivers/mtd/nand/raw/marvell_nand.c

2585

mtd->name = devm_kasprintf(nfc->dev, GFP_KERNEL,

drivers/mtd/nand/raw/marvell_nand.c

2586

"%s:nand.%d", dev_name(nfc->dev),

drivers/mtd/nand/raw/marvell_nand.c

2589

dev_err(nfc->dev, "Failed to allocate mtd->name\n");

drivers/mtd/nand/raw/marvell_nand.c

2603

static int marvell_nand_chip_init(struct device *dev, struct marvell_nfc *nfc,

drivers/mtd/nand/raw/marvell_nand.c

2622

if (pdata || nfc->caps->legacy_of_bindings) {

drivers/mtd/nand/raw/marvell_nand.c

2645

if (pdata || nfc->caps->legacy_of_bindings) {

drivers/mtd/nand/raw/marvell_nand.c

2661

if (cs >= nfc->caps->max_cs_nb) {

drivers/mtd/nand/raw/marvell_nand.c

2663

cs, nfc->caps->max_cs_nb);

drivers/mtd/nand/raw/marvell_nand.c

2667

if (test_and_set_bit(cs, &nfc->assigned_cs)) {

drivers/mtd/nand/raw/marvell_nand.c

2695

if (pdata || nfc->caps->legacy_of_bindings) {

drivers/mtd/nand/raw/marvell_nand.c

2709

if (rb >= nfc->caps->max_rb_nb) {

drivers/mtd/nand/raw/marvell_nand.c

2711

rb, nfc->caps->max_rb_nb);

drivers/mtd/nand/raw/marvell_nand.c

2719

chip->controller = &nfc->controller;

drivers/mtd/nand/raw/marvell_nand.c

2732

marvell_nand->ndtr0 = readl_relaxed(nfc->regs + NDTR0);

drivers/mtd/nand/raw/marvell_nand.c

2733

marvell_nand->ndtr1 = readl_relaxed(nfc->regs + NDTR1);

drivers/mtd/nand/raw/marvell_nand.c

2754

list_add_tail(&marvell_nand->node, &nfc->chips);

drivers/mtd/nand/raw/marvell_nand.c

2759

static void marvell_nand_chips_cleanup(struct marvell_nfc *nfc)

drivers/mtd/nand/raw/marvell_nand.c

2765

list_for_each_entry_safe(entry, temp, &nfc->chips, node) {

drivers/mtd/nand/raw/marvell_nand.c

2774

static int marvell_nand_chips_init(struct device *dev, struct marvell_nfc *nfc)

drivers/mtd/nand/raw/marvell_nand.c

2777

int max_cs = nfc->caps->max_cs_nb;

drivers/mtd/nand/raw/marvell_nand.c

2798

if (nfc->caps->legacy_of_bindings) {

drivers/mtd/nand/raw/marvell_nand.c

2799

ret = marvell_nand_chip_init(dev, nfc, np);

drivers/mtd/nand/raw/marvell_nand.c

2804

ret = marvell_nand_chip_init(dev, nfc, nand_np);

drivers/mtd/nand/raw/marvell_nand.c

2806

marvell_nand_chips_cleanup(nfc);

drivers/mtd/nand/raw/marvell_nand.c

2814

static int marvell_nfc_init_dma(struct marvell_nfc *nfc)

drivers/mtd/nand/raw/marvell_nand.c

2816

struct platform_device *pdev = container_of(nfc->dev,

drivers/mtd/nand/raw/marvell_nand.c

2824

dev_warn(nfc->dev,

drivers/mtd/nand/raw/marvell_nand.c

2829

ret = dma_set_mask_and_coherent(nfc->dev, DMA_BIT_MASK(32));

drivers/mtd/nand/raw/marvell_nand.c

2833

nfc->dma_chan = dma_request_chan(nfc->dev, "data");

drivers/mtd/nand/raw/marvell_nand.c

2834

if (IS_ERR(nfc->dma_chan)) {

drivers/mtd/nand/raw/marvell_nand.c

2835

ret = PTR_ERR(nfc->dma_chan);

drivers/mtd/nand/raw/marvell_nand.c

2836

nfc->dma_chan = NULL;

drivers/mtd/nand/raw/marvell_nand.c

2837

return dev_err_probe(nfc->dev, ret, "DMA channel request failed\n");

drivers/mtd/nand/raw/marvell_nand.c

2852

ret = dmaengine_slave_config(nfc->dma_chan, &config);

drivers/mtd/nand/raw/marvell_nand.c

2854

dev_err(nfc->dev, "Failed to configure DMA channel\n");

drivers/mtd/nand/raw/marvell_nand.c

2864

nfc->dma_buf = kmalloc(MAX_CHUNK_SIZE, GFP_KERNEL | GFP_DMA);

drivers/mtd/nand/raw/marvell_nand.c

2865

if (!nfc->dma_buf) {

drivers/mtd/nand/raw/marvell_nand.c

2870

nfc->use_dma = true;

drivers/mtd/nand/raw/marvell_nand.c

2875

dma_release_channel(nfc->dma_chan);

drivers/mtd/nand/raw/marvell_nand.c

2876

nfc->dma_chan = NULL;

drivers/mtd/nand/raw/marvell_nand.c

2881

static void marvell_nfc_reset(struct marvell_nfc *nfc)

drivers/mtd/nand/raw/marvell_nand.c

2891

NDCR_RD_ID_CNT(NFCV1_READID_LEN), nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

2892

writel_relaxed(0xFFFFFFFF, nfc->regs + NDSR);

drivers/mtd/nand/raw/marvell_nand.c

2893

writel_relaxed(0, nfc->regs + NDECCCTRL);

drivers/mtd/nand/raw/marvell_nand.c

2896

static int marvell_nfc_init(struct marvell_nfc *nfc)

drivers/mtd/nand/raw/marvell_nand.c

2898

struct device_node *np = nfc->dev->of_node;

drivers/mtd/nand/raw/marvell_nand.c

2906

if (nfc->caps->need_system_controller) {

drivers/mtd/nand/raw/marvell_nand.c

2927

if (!nfc->caps->is_nfcv2)

drivers/mtd/nand/raw/marvell_nand.c

2928

marvell_nfc_init_dma(nfc);

drivers/mtd/nand/raw/marvell_nand.c

2930

marvell_nfc_reset(nfc);

drivers/mtd/nand/raw/marvell_nand.c

2938

struct marvell_nfc *nfc;

drivers/mtd/nand/raw/marvell_nand.c

2942

nfc = devm_kzalloc(&pdev->dev, sizeof(struct marvell_nfc),

drivers/mtd/nand/raw/marvell_nand.c

2944

if (!nfc)

drivers/mtd/nand/raw/marvell_nand.c

2947

nfc->dev = dev;

drivers/mtd/nand/raw/marvell_nand.c

2948

nand_controller_init(&nfc->controller);

drivers/mtd/nand/raw/marvell_nand.c

2949

nfc->controller.ops = &marvell_nand_controller_ops;

drivers/mtd/nand/raw/marvell_nand.c

2950

INIT_LIST_HEAD(&nfc->chips);

drivers/mtd/nand/raw/marvell_nand.c

2952

nfc->regs = devm_platform_ioremap_resource(pdev, 0);

drivers/mtd/nand/raw/marvell_nand.c

2953

if (IS_ERR(nfc->regs))

drivers/mtd/nand/raw/marvell_nand.c

2954

return PTR_ERR(nfc->regs);

drivers/mtd/nand/raw/marvell_nand.c

2960

nfc->core_clk = devm_clk_get(&pdev->dev, "core");

drivers/mtd/nand/raw/marvell_nand.c

2963

if (nfc->core_clk == ERR_PTR(-ENOENT))

drivers/mtd/nand/raw/marvell_nand.c

2964

nfc->core_clk = devm_clk_get(&pdev->dev, NULL);

drivers/mtd/nand/raw/marvell_nand.c

2966

if (IS_ERR(nfc->core_clk))

drivers/mtd/nand/raw/marvell_nand.c

2967

return PTR_ERR(nfc->core_clk);

drivers/mtd/nand/raw/marvell_nand.c

2969

ret = clk_prepare_enable(nfc->core_clk);

drivers/mtd/nand/raw/marvell_nand.c

2973

nfc->reg_clk = devm_clk_get(&pdev->dev, "reg");

drivers/mtd/nand/raw/marvell_nand.c

2974

if (IS_ERR(nfc->reg_clk)) {

drivers/mtd/nand/raw/marvell_nand.c

2975

if (PTR_ERR(nfc->reg_clk) != -ENOENT) {

drivers/mtd/nand/raw/marvell_nand.c

2976

ret = PTR_ERR(nfc->reg_clk);

drivers/mtd/nand/raw/marvell_nand.c

2980

nfc->reg_clk = NULL;

drivers/mtd/nand/raw/marvell_nand.c

2983

ret = clk_prepare_enable(nfc->reg_clk);

drivers/mtd/nand/raw/marvell_nand.c

2987

marvell_nfc_disable_int(nfc, NDCR_ALL_INT);

drivers/mtd/nand/raw/marvell_nand.c

2988

marvell_nfc_clear_int(nfc, NDCR_ALL_INT);

drivers/mtd/nand/raw/marvell_nand.c

2990

0, "marvell-nfc", nfc);

drivers/mtd/nand/raw/marvell_nand.c

2996

nfc->caps = (void *)pdev->id_entry->driver_data;

drivers/mtd/nand/raw/marvell_nand.c

2998

nfc->caps = of_device_get_match_data(&pdev->dev);

drivers/mtd/nand/raw/marvell_nand.c

3000

if (!nfc->caps) {

drivers/mtd/nand/raw/marvell_nand.c

3007

ret = marvell_nfc_init(nfc);

drivers/mtd/nand/raw/marvell_nand.c

3011

platform_set_drvdata(pdev, nfc);

drivers/mtd/nand/raw/marvell_nand.c

3013

ret = marvell_nand_chips_init(dev, nfc);

drivers/mtd/nand/raw/marvell_nand.c

3020

if (nfc->use_dma)

drivers/mtd/nand/raw/marvell_nand.c

3021

dma_release_channel(nfc->dma_chan);

drivers/mtd/nand/raw/marvell_nand.c

3023

clk_disable_unprepare(nfc->reg_clk);

drivers/mtd/nand/raw/marvell_nand.c

3025

clk_disable_unprepare(nfc->core_clk);

drivers/mtd/nand/raw/marvell_nand.c

3032

struct marvell_nfc *nfc = platform_get_drvdata(pdev);

drivers/mtd/nand/raw/marvell_nand.c

3034

marvell_nand_chips_cleanup(nfc);

drivers/mtd/nand/raw/marvell_nand.c

3036

if (nfc->use_dma) {

drivers/mtd/nand/raw/marvell_nand.c

3037

dmaengine_terminate_all(nfc->dma_chan);

drivers/mtd/nand/raw/marvell_nand.c

3038

dma_release_channel(nfc->dma_chan);

drivers/mtd/nand/raw/marvell_nand.c

3041

clk_disable_unprepare(nfc->reg_clk);

drivers/mtd/nand/raw/marvell_nand.c

3042

clk_disable_unprepare(nfc->core_clk);

drivers/mtd/nand/raw/marvell_nand.c

3047

struct marvell_nfc *nfc = dev_get_drvdata(dev);

drivers/mtd/nand/raw/marvell_nand.c

3050

list_for_each_entry(chip, &nfc->chips, node)

drivers/mtd/nand/raw/marvell_nand.c

3053

clk_disable_unprepare(nfc->reg_clk);

drivers/mtd/nand/raw/marvell_nand.c

3054

clk_disable_unprepare(nfc->core_clk);

drivers/mtd/nand/raw/marvell_nand.c

3061

struct marvell_nfc *nfc = dev_get_drvdata(dev);

drivers/mtd/nand/raw/marvell_nand.c

3064

ret = clk_prepare_enable(nfc->core_clk);

drivers/mtd/nand/raw/marvell_nand.c

3068

ret = clk_prepare_enable(nfc->reg_clk);

drivers/mtd/nand/raw/marvell_nand.c

3070

clk_disable_unprepare(nfc->core_clk);

drivers/mtd/nand/raw/marvell_nand.c

3078

nfc->selected_chip = NULL;

drivers/mtd/nand/raw/marvell_nand.c

3081

marvell_nfc_reset(nfc);

drivers/mtd/nand/raw/marvell_nand.c

519

static void marvell_nfc_disable_int(struct marvell_nfc *nfc, u32 int_mask)

drivers/mtd/nand/raw/marvell_nand.c

524

reg = readl_relaxed(nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

525

writel_relaxed(reg | int_mask, nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

528

static void marvell_nfc_enable_int(struct marvell_nfc *nfc, u32 int_mask)

drivers/mtd/nand/raw/marvell_nand.c

533

reg = readl_relaxed(nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

534

writel_relaxed(reg & ~int_mask, nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

537

static u32 marvell_nfc_clear_int(struct marvell_nfc *nfc, u32 int_mask)

drivers/mtd/nand/raw/marvell_nand.c

541

reg = readl_relaxed(nfc->regs + NDSR);

drivers/mtd/nand/raw/marvell_nand.c

542

writel_relaxed(int_mask, nfc->regs + NDSR);

drivers/mtd/nand/raw/marvell_nand.c

550

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

562

ndcr = readl_relaxed(nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

569

writel_relaxed(ndcr, nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

574

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

582

ret = readl_relaxed_poll_timeout(nfc->regs + NDCR, val,

drivers/mtd/nand/raw/marvell_nand.c

586

dev_err(nfc->dev, "Timeout on NAND controller run mode\n");

drivers/mtd/nand/raw/marvell_nand.c

587

writel_relaxed(readl(nfc->regs + NDCR) & ~NDCR_ND_RUN,

drivers/mtd/nand/raw/marvell_nand.c

588

nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

612

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

619

dev_err(nfc->dev, "Last operation did not succeed\n");

drivers/mtd/nand/raw/marvell_nand.c

623

ndcr = readl_relaxed(nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

624

writel_relaxed(readl(nfc->regs + NDSR), nfc->regs + NDSR);

drivers/mtd/nand/raw/marvell_nand.c

627

writel_relaxed(ndcr | NDCR_ND_RUN, nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

628

ret = readl_relaxed_poll_timeout(nfc->regs + NDSR, val,

drivers/mtd/nand/raw/marvell_nand.c

632

dev_err(nfc->dev, "Timeout on WRCMDRE\n");

drivers/mtd/nand/raw/marvell_nand.c

637

writel_relaxed(NDSR_WRCMDREQ, nfc->regs + NDSR);

drivers/mtd/nand/raw/marvell_nand.c

646

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

648

dev_dbg(nfc->dev, "\nNDCR: 0x%08x\n"

drivers/mtd/nand/raw/marvell_nand.c

650

(u32)readl_relaxed(nfc->regs + NDCR), nfc_op->ndcb[0],

drivers/mtd/nand/raw/marvell_nand.c

654

nfc->regs + NDCB0);

drivers/mtd/nand/raw/marvell_nand.c

655

writel_relaxed(nfc_op->ndcb[1], nfc->regs + NDCB0);

drivers/mtd/nand/raw/marvell_nand.c

656

writel(nfc_op->ndcb[2], nfc->regs + NDCB0);

drivers/mtd/nand/raw/marvell_nand.c

664

if (!WARN_ON_ONCE(!nfc->caps->is_nfcv2))

drivers/mtd/nand/raw/marvell_nand.c

665

writel(nfc_op->ndcb[3], nfc->regs + NDCB0);

drivers/mtd/nand/raw/marvell_nand.c

672

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

676

ret = readl_relaxed_poll_timeout(nfc->regs + NDSR, val,

drivers/mtd/nand/raw/marvell_nand.c

681

dev_err(nfc->dev, "Timeout on %s (NDSR: 0x%08x)\n",

drivers/mtd/nand/raw/marvell_nand.c

683

if (nfc->dma_chan)

drivers/mtd/nand/raw/marvell_nand.c

684

dmaengine_terminate_all(nfc->dma_chan);

drivers/mtd/nand/raw/marvell_nand.c

692

if (nfc->use_dma && (readl_relaxed(nfc->regs + NDCR) & NDCR_DMA_EN))

drivers/mtd/nand/raw/marvell_nand.c

695

writel_relaxed(flag, nfc->regs + NDSR);

drivers/mtd/nand/raw/marvell_nand.c

708

static int marvell_nfc_poll_status(struct marvell_nfc *nfc, u32 mask,

drivers/mtd/nand/raw/marvell_nand.c

716

st = readl_relaxed(nfc->regs + NDSR);

drivers/mtd/nand/raw/marvell_nand.c

731

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

741

ret = marvell_nfc_poll_status(nfc, NDSR_RDY(0),

drivers/mtd/nand/raw/marvell_nand.c

745

init_completion(&nfc->complete);

drivers/mtd/nand/raw/marvell_nand.c

747

marvell_nfc_enable_int(nfc, NDCR_RDYM);

drivers/mtd/nand/raw/marvell_nand.c

748

ret = wait_for_completion_timeout(&nfc->complete,

drivers/mtd/nand/raw/marvell_nand.c

750

marvell_nfc_disable_int(nfc, NDCR_RDYM);

drivers/mtd/nand/raw/marvell_nand.c

752

pending = marvell_nfc_clear_int(nfc, NDSR_RDY(0) | NDSR_RDY(1));

drivers/mtd/nand/raw/marvell_nand.c

759

dev_err(nfc->dev, "Timeout waiting for RB signal\n");

drivers/mtd/nand/raw/marvell_nand.c

770

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

777

ndcr_generic = readl_relaxed(nfc->regs + NDCR) &

drivers/mtd/nand/raw/marvell_nand.c

779

writel_relaxed(ndcr_generic | marvell_nand->ndcr, nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

782

marvell_nfc_clear_int(nfc, NDCR_ALL_INT);

drivers/mtd/nand/raw/marvell_nand.c

784

if (chip == nfc->selected_chip && die_nr == marvell_nand->selected_die)

drivers/mtd/nand/raw/marvell_nand.c

787

writel_relaxed(marvell_nand->ndtr0, nfc->regs + NDTR0);

drivers/mtd/nand/raw/marvell_nand.c

788

writel_relaxed(marvell_nand->ndtr1, nfc->regs + NDTR1);

drivers/mtd/nand/raw/marvell_nand.c

790

nfc->selected_chip = chip;

drivers/mtd/nand/raw/marvell_nand.c

796

struct marvell_nfc *nfc = dev_id;

drivers/mtd/nand/raw/marvell_nand.c

797

u32 st = readl_relaxed(nfc->regs + NDSR);

drivers/mtd/nand/raw/marvell_nand.c

798

u32 ien = (~readl_relaxed(nfc->regs + NDCR)) & NDCR_ALL_INT;

drivers/mtd/nand/raw/marvell_nand.c

810

marvell_nfc_disable_int(nfc, st & NDCR_ALL_INT);

drivers/mtd/nand/raw/marvell_nand.c

813

complete(&nfc->complete);

drivers/mtd/nand/raw/marvell_nand.c

821

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

822

u32 ndcr = readl_relaxed(nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

825

writel_relaxed(ndcr | NDCR_ECC_EN, nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

832

writel_relaxed(NDECCCTRL_BCH_EN, nfc->regs + NDECCCTRL);

drivers/mtd/nand/raw/marvell_nand.c

838

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/marvell_nand.c

839

u32 ndcr = readl_relaxed(nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

842

writel_relaxed(ndcr & ~NDCR_ECC_EN, nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

844

writel_relaxed(0, nfc->regs + NDECCCTRL);

drivers/mtd/nand/raw/marvell_nand.c

849

static void marvell_nfc_enable_dma(struct marvell_nfc *nfc)

drivers/mtd/nand/raw/marvell_nand.c

853

reg = readl_relaxed(nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

854

writel_relaxed(reg | NDCR_DMA_EN, nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

857

static void marvell_nfc_disable_dma(struct marvell_nfc *nfc)

drivers/mtd/nand/raw/marvell_nand.c

861

reg = readl_relaxed(nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

862

writel_relaxed(reg & ~NDCR_DMA_EN, nfc->regs + NDCR);

drivers/mtd/nand/raw/marvell_nand.c

866

static int marvell_nfc_xfer_data_dma(struct marvell_nfc *nfc,

drivers/mtd/nand/raw/marvell_nand.c

876

marvell_nfc_enable_dma(nfc);

drivers/mtd/nand/raw/marvell_nand.c

878

sg_init_one(&sg, nfc->dma_buf, dma_len);

drivers/mtd/nand/raw/marvell_nand.c

879

ret = dma_map_sg(nfc->dma_chan->device->dev, &sg, 1, direction);

drivers/mtd/nand/raw/marvell_nand.c

881

dev_err(nfc->dev, "Could not map DMA S/G list\n");

drivers/mtd/nand/raw/marvell_nand.c

885

tx = dmaengine_prep_slave_sg(nfc->dma_chan, &sg, 1,

drivers/mtd/nand/raw/marvell_nand.c

890

dev_err(nfc->dev, "Could not prepare DMA S/G list\n");

drivers/mtd/nand/raw/marvell_nand.c

891

dma_unmap_sg(nfc->dma_chan->device->dev, &sg, 1, direction);

drivers/mtd/nand/raw/marvell_nand.c

901

dma_async_issue_pending(nfc->dma_chan);

drivers/mtd/nand/raw/marvell_nand.c

902

ret = marvell_nfc_wait_cmdd(nfc->selected_chip);

drivers/mtd/nand/raw/marvell_nand.c

903

dma_unmap_sg(nfc->dma_chan->device->dev, &sg, 1, direction);

drivers/mtd/nand/raw/marvell_nand.c

904

marvell_nfc_disable_dma(nfc);

drivers/mtd/nand/raw/marvell_nand.c

906

dev_err(nfc->dev, "Timeout waiting for DMA (status: %d)\n",

drivers/mtd/nand/raw/marvell_nand.c

907

dmaengine_tx_status(nfc->dma_chan, cookie, NULL));

drivers/mtd/nand/raw/marvell_nand.c

908

dmaengine_terminate_all(nfc->dma_chan);

drivers/mtd/nand/raw/marvell_nand.c

915

static int marvell_nfc_xfer_data_in_pio(struct marvell_nfc *nfc, u8 *in,

drivers/mtd/nand/raw/marvell_nand.c

923

ioread32_rep(nfc->regs + NDDB, in + i, FIFO_REP(FIFO_DEPTH));

drivers/mtd/nand/raw/marvell_nand.c

928

ioread32_rep(nfc->regs + NDDB, tmp_buf, FIFO_REP(FIFO_DEPTH));

drivers/mtd/nand/raw/marvell_nand.c

935

static int marvell_nfc_xfer_data_out_pio(struct marvell_nfc *nfc, const u8 *out,

drivers/mtd/nand/raw/marvell_nand.c

943

iowrite32_rep(nfc->regs + NDDB, out + i, FIFO_REP(FIFO_DEPTH));

drivers/mtd/nand/raw/marvell_nand.c

949

iowrite32_rep(nfc->regs + NDDB, tmp_buf, FIFO_REP(FIFO_DEPTH));

drivers/mtd/nand/raw/marvell_nand.c

999

struct marvell_nfc *nfc = to_marvell_nfc(chip->controller);

drivers/mtd/nand/raw/meson_nand.c

1031

struct meson_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/meson_nand.c

1053

cmd = nfc->param.chip_select | NFC_CMD_CLE;

drivers/mtd/nand/raw/meson_nand.c

1055

writel(cmd, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

1056

meson_nfc_cmd_idle(nfc, delay_idle);

drivers/mtd/nand/raw/meson_nand.c

1061

cmd = nfc->param.chip_select | NFC_CMD_ALE;

drivers/mtd/nand/raw/meson_nand.c

1063

writel(cmd, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

1065

meson_nfc_cmd_idle(nfc, delay_idle);

drivers/mtd/nand/raw/meson_nand.c

1088

meson_nfc_cmd_idle(nfc, delay_idle);

drivers/mtd/nand/raw/meson_nand.c

1092

meson_nfc_wait_cmd_finish(nfc, 1000);

drivers/mtd/nand/raw/meson_nand.c

1129

static int meson_nfc_clk_init(struct meson_nfc *nfc)

drivers/mtd/nand/raw/meson_nand.c

1136

nfc->core_clk = devm_clk_get(nfc->dev, "core");

drivers/mtd/nand/raw/meson_nand.c

1137

if (IS_ERR(nfc->core_clk)) {

drivers/mtd/nand/raw/meson_nand.c

1138

dev_err(nfc->dev, "failed to get core clock\n");

drivers/mtd/nand/raw/meson_nand.c

1139

return PTR_ERR(nfc->core_clk);

drivers/mtd/nand/raw/meson_nand.c

1142

nfc->device_clk = devm_clk_get(nfc->dev, "device");

drivers/mtd/nand/raw/meson_nand.c

1143

if (IS_ERR(nfc->device_clk)) {

drivers/mtd/nand/raw/meson_nand.c

1144

dev_err(nfc->dev, "failed to get device clock\n");

drivers/mtd/nand/raw/meson_nand.c

1145

return PTR_ERR(nfc->device_clk);

drivers/mtd/nand/raw/meson_nand.c

1148

init.name = devm_kasprintf(nfc->dev,

drivers/mtd/nand/raw/meson_nand.c

1150

dev_name(nfc->dev));

drivers/mtd/nand/raw/meson_nand.c

1158

nfc->nand_divider.reg = nfc->reg_clk;

drivers/mtd/nand/raw/meson_nand.c

1159

nfc->nand_divider.shift = CLK_DIV_SHIFT;

drivers/mtd/nand/raw/meson_nand.c

1160

nfc->nand_divider.width = CLK_DIV_WIDTH;

drivers/mtd/nand/raw/meson_nand.c

1161

nfc->nand_divider.hw.init = &init;

drivers/mtd/nand/raw/meson_nand.c

1162

nfc->nand_divider.flags = CLK_DIVIDER_ONE_BASED |

drivers/mtd/nand/raw/meson_nand.c

1166

nfc->nand_clk = devm_clk_register(nfc->dev, &nfc->nand_divider.hw);

drivers/mtd/nand/raw/meson_nand.c

1167

if (IS_ERR(nfc->nand_clk))

drivers/mtd/nand/raw/meson_nand.c

1168

return PTR_ERR(nfc->nand_clk);

drivers/mtd/nand/raw/meson_nand.c

1172

nfc->reg_clk);

drivers/mtd/nand/raw/meson_nand.c

1174

ret = clk_prepare_enable(nfc->core_clk);

drivers/mtd/nand/raw/meson_nand.c

1176

dev_err(nfc->dev, "failed to enable core clock\n");

drivers/mtd/nand/raw/meson_nand.c

1180

ret = clk_prepare_enable(nfc->device_clk);

drivers/mtd/nand/raw/meson_nand.c

1182

dev_err(nfc->dev, "failed to enable device clock\n");

drivers/mtd/nand/raw/meson_nand.c

1186

ret = clk_prepare_enable(nfc->nand_clk);

drivers/mtd/nand/raw/meson_nand.c

1188

dev_err(nfc->dev, "pre enable NFC divider fail\n");

drivers/mtd/nand/raw/meson_nand.c

1192

ret = clk_set_rate(nfc->nand_clk, 24000000);

drivers/mtd/nand/raw/meson_nand.c

1199

clk_disable_unprepare(nfc->nand_clk);

drivers/mtd/nand/raw/meson_nand.c

1201

clk_disable_unprepare(nfc->device_clk);

drivers/mtd/nand/raw/meson_nand.c

1203

clk_disable_unprepare(nfc->core_clk);

drivers/mtd/nand/raw/meson_nand.c

1207

static void meson_nfc_disable_clk(struct meson_nfc *nfc)

drivers/mtd/nand/raw/meson_nand.c

1209

clk_disable_unprepare(nfc->nand_clk);

drivers/mtd/nand/raw/meson_nand.c

1210

clk_disable_unprepare(nfc->device_clk);

drivers/mtd/nand/raw/meson_nand.c

1211

clk_disable_unprepare(nfc->core_clk);

drivers/mtd/nand/raw/meson_nand.c

1315

struct meson_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/meson_nand.c

1322

mtd->name = devm_kasprintf(nfc->dev, GFP_KERNEL,

drivers/mtd/nand/raw/meson_nand.c

1324

dev_name(nfc->dev),

drivers/mtd/nand/raw/meson_nand.c

1332

dev_err(nfc->dev, "too big write size in raw mode: %d > %ld\n",

drivers/mtd/nand/raw/meson_nand.c

1342

ret = nand_ecc_choose_conf(nand, nfc->data->ecc_caps,

drivers/mtd/nand/raw/meson_nand.c

1345

dev_err(nfc->dev, "failed to ECC init\n");

drivers/mtd/nand/raw/meson_nand.c

1367

dev_err(nfc->dev, "16bits bus width not supported");

drivers/mtd/nand/raw/meson_nand.c

1386

struct meson_nfc *nfc, struct device_node *np)

drivers/mtd/nand/raw/meson_nand.c

1416

if (test_and_set_bit(tmp, &nfc->assigned_cs)) {

drivers/mtd/nand/raw/meson_nand.c

1423

nand->controller = &nfc->controller;

drivers/mtd/nand/raw/meson_nand.c

1426

nand_set_controller_data(nand, nfc);

drivers/mtd/nand/raw/meson_nand.c

1435

nfc->no_rb_pin = true;

drivers/mtd/nand/raw/meson_nand.c

1473

list_add_tail(&meson_chip->node, &nfc->chips);

drivers/mtd/nand/raw/meson_nand.c

1478

static void meson_nfc_nand_chips_cleanup(struct meson_nfc *nfc)

drivers/mtd/nand/raw/meson_nand.c

1483

while (!list_empty(&nfc->chips)) {

drivers/mtd/nand/raw/meson_nand.c

1484

meson_chip = list_first_entry(&nfc->chips,

drivers/mtd/nand/raw/meson_nand.c

1495

struct meson_nfc *nfc)

drivers/mtd/nand/raw/meson_nand.c

1501

ret = meson_nfc_nand_chip_init(dev, nfc, nand_np);

drivers/mtd/nand/raw/meson_nand.c

1503

meson_nfc_nand_chips_cleanup(nfc);

drivers/mtd/nand/raw/meson_nand.c

1513

struct meson_nfc *nfc = id;

drivers/mtd/nand/raw/meson_nand.c

1516

cfg = readl(nfc->reg_base + NFC_REG_CFG);

drivers/mtd/nand/raw/meson_nand.c

1521

writel(cfg, nfc->reg_base + NFC_REG_CFG);

drivers/mtd/nand/raw/meson_nand.c

1523

complete(&nfc->completion);

drivers/mtd/nand/raw/meson_nand.c

1550

struct meson_nfc *nfc;

drivers/mtd/nand/raw/meson_nand.c

1553

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

drivers/mtd/nand/raw/meson_nand.c

1554

if (!nfc)

drivers/mtd/nand/raw/meson_nand.c

1557

nfc->data = of_device_get_match_data(&pdev->dev);

drivers/mtd/nand/raw/meson_nand.c

1558

if (!nfc->data)

drivers/mtd/nand/raw/meson_nand.c

1561

nand_controller_init(&nfc->controller);

drivers/mtd/nand/raw/meson_nand.c

1562

INIT_LIST_HEAD(&nfc->chips);

drivers/mtd/nand/raw/meson_nand.c

1563

init_completion(&nfc->completion);

drivers/mtd/nand/raw/meson_nand.c

1565

nfc->dev = dev;

drivers/mtd/nand/raw/meson_nand.c

1567

nfc->reg_base = devm_platform_ioremap_resource_byname(pdev, "nfc");

drivers/mtd/nand/raw/meson_nand.c

1568

if (IS_ERR(nfc->reg_base))

drivers/mtd/nand/raw/meson_nand.c

1569

return PTR_ERR(nfc->reg_base);

drivers/mtd/nand/raw/meson_nand.c

1571

nfc->reg_clk = devm_platform_ioremap_resource_byname(pdev, "emmc");

drivers/mtd/nand/raw/meson_nand.c

1572

if (IS_ERR(nfc->reg_clk))

drivers/mtd/nand/raw/meson_nand.c

1573

return PTR_ERR(nfc->reg_clk);

drivers/mtd/nand/raw/meson_nand.c

1579

ret = meson_nfc_clk_init(nfc);

drivers/mtd/nand/raw/meson_nand.c

1585

writel(0, nfc->reg_base + NFC_REG_CFG);

drivers/mtd/nand/raw/meson_nand.c

1586

ret = devm_request_irq(dev, irq, meson_nfc_irq, 0, dev_name(dev), nfc);

drivers/mtd/nand/raw/meson_nand.c

1599

platform_set_drvdata(pdev, nfc);

drivers/mtd/nand/raw/meson_nand.c

1601

ret = meson_nfc_nand_chips_init(dev, nfc);

drivers/mtd/nand/raw/meson_nand.c

1609

meson_nfc_disable_clk(nfc);

drivers/mtd/nand/raw/meson_nand.c

1615

struct meson_nfc *nfc = platform_get_drvdata(pdev);

drivers/mtd/nand/raw/meson_nand.c

1617

meson_nfc_nand_chips_cleanup(nfc);

drivers/mtd/nand/raw/meson_nand.c

1619

meson_nfc_disable_clk(nfc);

drivers/mtd/nand/raw/meson_nand.c

266

struct meson_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/meson_nand.c

272

nfc->param.chip_select = meson_chip->sels[chip] ? NAND_CE1 : NAND_CE0;

drivers/mtd/nand/raw/meson_nand.c

273

nfc->param.rb_select = nfc->param.chip_select;

drivers/mtd/nand/raw/meson_nand.c

274

nfc->timing.twb = meson_chip->twb;

drivers/mtd/nand/raw/meson_nand.c

275

nfc->timing.tadl = meson_chip->tadl;

drivers/mtd/nand/raw/meson_nand.c

276

nfc->timing.tbers_max = meson_chip->tbers_max;

drivers/mtd/nand/raw/meson_nand.c

278

if (nfc->clk_rate != meson_chip->clk_rate) {

drivers/mtd/nand/raw/meson_nand.c

279

ret = clk_set_rate(nfc->nand_clk, meson_chip->clk_rate);

drivers/mtd/nand/raw/meson_nand.c

281

dev_err(nfc->dev, "failed to set clock rate\n");

drivers/mtd/nand/raw/meson_nand.c

284

nfc->clk_rate = meson_chip->clk_rate;

drivers/mtd/nand/raw/meson_nand.c

286

if (nfc->bus_timing != meson_chip->bus_timing) {

drivers/mtd/nand/raw/meson_nand.c

288

writel(value, nfc->reg_base + NFC_REG_CFG);

drivers/mtd/nand/raw/meson_nand.c

289

writel((1 << 31), nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

290

nfc->bus_timing = meson_chip->bus_timing;

drivers/mtd/nand/raw/meson_nand.c

294

static void meson_nfc_cmd_idle(struct meson_nfc *nfc, u32 time)

drivers/mtd/nand/raw/meson_nand.c

296

writel(nfc->param.chip_select | NFC_CMD_IDLE | (time & 0x3ff),

drivers/mtd/nand/raw/meson_nand.c

297

nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

300

static void meson_nfc_cmd_seed(struct meson_nfc *nfc, u32 seed)

drivers/mtd/nand/raw/meson_nand.c

303

nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

319

struct meson_nfc *nfc = nand_get_controller_data(mtd_to_nand(mtd));

drivers/mtd/nand/raw/meson_nand.c

348

meson_nfc_cmd_seed(nfc, page);

drivers/mtd/nand/raw/meson_nand.c

350

writel(cmd, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

353

static void meson_nfc_drain_cmd(struct meson_nfc *nfc)

drivers/mtd/nand/raw/meson_nand.c

366

meson_nfc_cmd_idle(nfc, 0);

drivers/mtd/nand/raw/meson_nand.c

367

meson_nfc_cmd_idle(nfc, 0);

drivers/mtd/nand/raw/meson_nand.c

370

static int meson_nfc_wait_cmd_finish(struct meson_nfc *nfc,

drivers/mtd/nand/raw/meson_nand.c

377

ret = readl_relaxed_poll_timeout(nfc->reg_base + NFC_REG_CMD, cmd_size,

drivers/mtd/nand/raw/meson_nand.c

381

dev_err(nfc->dev, "wait for empty CMD FIFO time out\n");

drivers/mtd/nand/raw/meson_nand.c

386

static int meson_nfc_wait_dma_finish(struct meson_nfc *nfc)

drivers/mtd/nand/raw/meson_nand.c

388

meson_nfc_drain_cmd(nfc);

drivers/mtd/nand/raw/meson_nand.c

390

return meson_nfc_wait_cmd_finish(nfc, DMA_BUSY_TIMEOUT);

drivers/mtd/nand/raw/meson_nand.c

455

struct meson_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/meson_nand.c

458

meson_nfc_cmd_idle(nfc, nfc->timing.twb);

drivers/mtd/nand/raw/meson_nand.c

459

meson_nfc_drain_cmd(nfc);

drivers/mtd/nand/raw/meson_nand.c

460

meson_nfc_wait_cmd_finish(nfc, CMD_FIFO_EMPTY_TIMEOUT);

drivers/mtd/nand/raw/meson_nand.c

462

cfg = readl(nfc->reg_base + NFC_REG_CFG);

drivers/mtd/nand/raw/meson_nand.c

464

writel(cfg, nfc->reg_base + NFC_REG_CFG);

drivers/mtd/nand/raw/meson_nand.c

466

reinit_completion(&nfc->completion);

drivers/mtd/nand/raw/meson_nand.c

470

cmd = NFC_CMD_RB | NFC_CMD_RB_INT_NO_PIN | nfc->timing.tbers_max;

drivers/mtd/nand/raw/meson_nand.c

471

writel(cmd, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

473

if (!wait_for_completion_timeout(&nfc->completion,

drivers/mtd/nand/raw/meson_nand.c

483

static int meson_nfc_wait_rb_pin(struct meson_nfc *nfc, int timeout_ms)

drivers/mtd/nand/raw/meson_nand.c

488

meson_nfc_cmd_idle(nfc, nfc->timing.twb);

drivers/mtd/nand/raw/meson_nand.c

489

meson_nfc_drain_cmd(nfc);

drivers/mtd/nand/raw/meson_nand.c

490

meson_nfc_wait_cmd_finish(nfc, CMD_FIFO_EMPTY_TIMEOUT);

drivers/mtd/nand/raw/meson_nand.c

492

cfg = readl(nfc->reg_base + NFC_REG_CFG);

drivers/mtd/nand/raw/meson_nand.c

494

writel(cfg, nfc->reg_base + NFC_REG_CFG);

drivers/mtd/nand/raw/meson_nand.c

496

reinit_completion(&nfc->completion);

drivers/mtd/nand/raw/meson_nand.c

500

| nfc->param.chip_select | nfc->timing.tbers_max;

drivers/mtd/nand/raw/meson_nand.c

501

writel(cmd, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

503

ret = wait_for_completion_timeout(&nfc->completion,

drivers/mtd/nand/raw/meson_nand.c

514

struct meson_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/meson_nand.c

516

if (nfc->no_rb_pin) {

drivers/mtd/nand/raw/meson_nand.c

530

return meson_nfc_wait_rb_pin(nfc, timeout_ms);

drivers/mtd/nand/raw/meson_nand.c

593

struct meson_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/meson_nand.c

597

nfc->daddr = dma_map_single(nfc->dev, databuf, datalen, dir);

drivers/mtd/nand/raw/meson_nand.c

598

ret = dma_mapping_error(nfc->dev, nfc->daddr);

drivers/mtd/nand/raw/meson_nand.c

600

dev_err(nfc->dev, "DMA mapping error\n");

drivers/mtd/nand/raw/meson_nand.c

603

cmd = GENCMDDADDRL(NFC_CMD_ADL, nfc->daddr);

drivers/mtd/nand/raw/meson_nand.c

604

writel(cmd, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

606

cmd = GENCMDDADDRH(NFC_CMD_ADH, nfc->daddr);

drivers/mtd/nand/raw/meson_nand.c

607

writel(cmd, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

610

nfc->iaddr = dma_map_single(nfc->dev, infobuf, infolen, dir);

drivers/mtd/nand/raw/meson_nand.c

611

ret = dma_mapping_error(nfc->dev, nfc->iaddr);

drivers/mtd/nand/raw/meson_nand.c

613

dev_err(nfc->dev, "DMA mapping error\n");

drivers/mtd/nand/raw/meson_nand.c

614

dma_unmap_single(nfc->dev,

drivers/mtd/nand/raw/meson_nand.c

615

nfc->daddr, datalen, dir);

drivers/mtd/nand/raw/meson_nand.c

618

nfc->info_bytes = infolen;

drivers/mtd/nand/raw/meson_nand.c

619

cmd = GENCMDIADDRL(NFC_CMD_AIL, nfc->iaddr);

drivers/mtd/nand/raw/meson_nand.c

620

writel(cmd, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

622

cmd = GENCMDIADDRH(NFC_CMD_AIH, nfc->iaddr);

drivers/mtd/nand/raw/meson_nand.c

623

writel(cmd, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

633

struct meson_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/meson_nand.c

635

dma_unmap_single(nfc->dev, nfc->daddr, datalen, dir);

drivers/mtd/nand/raw/meson_nand.c

637

dma_unmap_single(nfc->dev, nfc->iaddr, infolen, dir);

drivers/mtd/nand/raw/meson_nand.c

638

nfc->info_bytes = 0;

drivers/mtd/nand/raw/meson_nand.c

644

struct meson_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/meson_nand.c

659

writel(cmd, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

661

meson_nfc_drain_cmd(nfc);

drivers/mtd/nand/raw/meson_nand.c

662

meson_nfc_wait_cmd_finish(nfc, 1000);

drivers/mtd/nand/raw/meson_nand.c

673

struct meson_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/meson_nand.c

683

writel(cmd, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

685

meson_nfc_drain_cmd(nfc);

drivers/mtd/nand/raw/meson_nand.c

686

meson_nfc_wait_cmd_finish(nfc, 1000);

drivers/mtd/nand/raw/meson_nand.c

698

struct meson_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/meson_nand.c

699

u32 *addrs = nfc->cmdfifo.rw.addrs;

drivers/mtd/nand/raw/meson_nand.c

700

u32 cs = nfc->param.chip_select;

drivers/mtd/nand/raw/meson_nand.c

707

nfc->cmdfifo.rw.cmd0 = cs | NFC_CMD_CLE | cmd0;

drivers/mtd/nand/raw/meson_nand.c

731

writel_relaxed(nfc->cmdfifo.cmd[i],

drivers/mtd/nand/raw/meson_nand.c

732

nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

735

nfc->cmdfifo.rw.cmd1 = cs | NFC_CMD_CLE | NAND_CMD_READSTART;

drivers/mtd/nand/raw/meson_nand.c

736

writel(nfc->cmdfifo.rw.cmd1, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

739

meson_nfc_cmd_idle(nfc, nfc->timing.tadl);

drivers/mtd/nand/raw/meson_nand.c

752

struct meson_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/meson_nand.c

774

cmd = nfc->param.chip_select | NFC_CMD_CLE | NAND_CMD_PAGEPROG;

drivers/mtd/nand/raw/meson_nand.c

775

writel(cmd, nfc->reg_base + NFC_REG_CMD);

drivers/mtd/nand/raw/meson_nand.c

807

static void meson_nfc_check_ecc_pages_valid(struct meson_nfc *nfc,

drivers/mtd/nand/raw/meson_nand.c

821

dma_sync_single_for_cpu(nfc->dev, nfc->iaddr, nfc->info_bytes,

drivers/mtd/nand/raw/meson_nand.c

831

struct meson_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/meson_nand.c

853

ret = meson_nfc_wait_dma_finish(nfc);

drivers/mtd/nand/raw/meson_nand.c

854

meson_nfc_check_ecc_pages_valid(nfc, nand, raw);

drivers/mtd/nand/raw/mtk_nand.c

1001

init_completion(&nfc->done);

drivers/mtd/nand/raw/mtk_nand.c

1002

reg = nfi_readl(nfc, NFI_CON) | CON_BRD;

drivers/mtd/nand/raw/mtk_nand.c

1003

nfi_writel(nfc, reg, NFI_CON);

drivers/mtd/nand/raw/mtk_nand.c

1004

nfi_writew(nfc, STAR_EN, NFI_STRDATA);

drivers/mtd/nand/raw/mtk_nand.c

1006

rc = wait_for_completion_timeout(&nfc->done, msecs_to_jiffies(500));

drivers/mtd/nand/raw/mtk_nand.c

1008

dev_warn(nfc->dev, "read ahb/dma done timeout\n");

drivers/mtd/nand/raw/mtk_nand.c

1010

rc = readl_poll_timeout_atomic(nfc->regs + NFI_BYTELEN, reg,

drivers/mtd/nand/raw/mtk_nand.c

1014

dev_err(nfc->dev, "subpage done timeout\n");

drivers/mtd/nand/raw/mtk_nand.c

1017

rc = mtk_ecc_wait_done(nfc->ecc, ECC_DECODE);

drivers/mtd/nand/raw/mtk_nand.c

1023

dma_unmap_single(nfc->dev, addr, len, DMA_FROM_DEVICE);

drivers/mtd/nand/raw/mtk_nand.c

1028

mtk_ecc_disable(nfc->ecc);

drivers/mtd/nand/raw/mtk_nand.c

1033

nfi_writel(nfc, 0, NFI_CON);

drivers/mtd/nand/raw/mtk_nand.c

1058

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

1062

memset(nfc->buffer, 0xff, mtd->writesize + mtd->oobsize);

drivers/mtd/nand/raw/mtk_nand.c

1063

ret = mtk_nfc_read_subpage(mtd, chip, 0, mtd->writesize, nfc->buffer,

drivers/mtd/nand/raw/mtk_nand.c

1072

mtk_nand->bad_mark.bm_swap(mtd, nfc->buffer, 1);

drivers/mtd/nand/raw/mtk_nand.c

1087

static inline void mtk_nfc_hw_init(struct mtk_nfc *nfc)

drivers/mtd/nand/raw/mtk_nand.c

1095

nfi_writew(nfc, 0xf1, NFI_CNRNB);

drivers/mtd/nand/raw/mtk_nand.c

1096

nfi_writel(nfc, PAGEFMT_8K_16K, NFI_PAGEFMT);

drivers/mtd/nand/raw/mtk_nand.c

1098

mtk_nfc_hw_reset(nfc);

drivers/mtd/nand/raw/mtk_nand.c

1100

nfi_readl(nfc, NFI_INTR_STA);

drivers/mtd/nand/raw/mtk_nand.c

1101

nfi_writel(nfc, 0, NFI_INTR_EN);

drivers/mtd/nand/raw/mtk_nand.c

1106

struct mtk_nfc *nfc = id;

drivers/mtd/nand/raw/mtk_nand.c

1109

sta = nfi_readw(nfc, NFI_INTR_STA);

drivers/mtd/nand/raw/mtk_nand.c

1110

ien = nfi_readw(nfc, NFI_INTR_EN);

drivers/mtd/nand/raw/mtk_nand.c

1115

nfi_writew(nfc, ~sta & ien, NFI_INTR_EN);

drivers/mtd/nand/raw/mtk_nand.c

1116

complete(&nfc->done);

drivers/mtd/nand/raw/mtk_nand.c

1166

struct mtk_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/mtk_nand.c

1170

mtk_ecc_get_parity_bits(nfc->ecc), 8);

drivers/mtd/nand/raw/mtk_nand.c

1197

struct mtk_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/mtk_nand.c

1198

const u8 *spare = nfc->caps->spare_size;

drivers/mtd/nand/raw/mtk_nand.c

1210

for (i = 0; i < nfc->caps->num_spare_size; i++) {

drivers/mtd/nand/raw/mtk_nand.c

1231

struct mtk_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/mtk_nand.c

1253

nfc->caps->max_sector_size > 512) {

drivers/mtd/nand/raw/mtk_nand.c

1268

free = (nand->ecc.strength * mtk_ecc_get_parity_bits(nfc->ecc)

drivers/mtd/nand/raw/mtk_nand.c

1280

mtk_ecc_get_parity_bits(nfc->ecc);

drivers/mtd/nand/raw/mtk_nand.c

1284

mtk_ecc_get_parity_bits(nfc->ecc);

drivers/mtd/nand/raw/mtk_nand.c

1288

mtk_ecc_adjust_strength(nfc->ecc, &nand->ecc.strength);

drivers/mtd/nand/raw/mtk_nand.c

1300

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

1326

nfc->buffer = devm_kzalloc(dev, len, GFP_KERNEL);

drivers/mtd/nand/raw/mtk_nand.c

1327

if (!nfc->buffer)

drivers/mtd/nand/raw/mtk_nand.c

1339

static int mtk_nfc_nand_chip_init(struct device *dev, struct mtk_nfc *nfc,

drivers/mtd/nand/raw/mtk_nand.c

1377

if (test_and_set_bit(tmp, &nfc->assigned_cs)) {

drivers/mtd/nand/raw/mtk_nand.c

1386

nand->controller = &nfc->controller;

drivers/mtd/nand/raw/mtk_nand.c

1389

nand_set_controller_data(nand, nfc);

drivers/mtd/nand/raw/mtk_nand.c

1414

mtk_nfc_hw_init(nfc);

drivers/mtd/nand/raw/mtk_nand.c

1427

list_add_tail(&chip->node, &nfc->chips);

drivers/mtd/nand/raw/mtk_nand.c

1432

static void mtk_nfc_nand_chips_cleanup(struct mtk_nfc *nfc)

drivers/mtd/nand/raw/mtk_nand.c

1438

while (!list_empty(&nfc->chips)) {

drivers/mtd/nand/raw/mtk_nand.c

1439

mtk_chip = list_first_entry(&nfc->chips,

drivers/mtd/nand/raw/mtk_nand.c

1449

static int mtk_nfc_nand_chips_init(struct device *dev, struct mtk_nfc *nfc)

drivers/mtd/nand/raw/mtk_nand.c

1455

ret = mtk_nfc_nand_chip_init(dev, nfc, nand_np);

drivers/mtd/nand/raw/mtk_nand.c

1457

mtk_nfc_nand_chips_cleanup(nfc);

drivers/mtd/nand/raw/mtk_nand.c

1511

struct mtk_nfc *nfc;

drivers/mtd/nand/raw/mtk_nand.c

1514

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

drivers/mtd/nand/raw/mtk_nand.c

1515

if (!nfc)

drivers/mtd/nand/raw/mtk_nand.c

1518

nand_controller_init(&nfc->controller);

drivers/mtd/nand/raw/mtk_nand.c

1519

INIT_LIST_HEAD(&nfc->chips);

drivers/mtd/nand/raw/mtk_nand.c

1520

nfc->controller.ops = &mtk_nfc_controller_ops;

drivers/mtd/nand/raw/mtk_nand.c

1523

nfc->ecc = of_mtk_ecc_get(np);

drivers/mtd/nand/raw/mtk_nand.c

1524

if (IS_ERR(nfc->ecc))

drivers/mtd/nand/raw/mtk_nand.c

1525

return PTR_ERR(nfc->ecc);

drivers/mtd/nand/raw/mtk_nand.c

1526

else if (!nfc->ecc)

drivers/mtd/nand/raw/mtk_nand.c

1529

nfc->caps = of_device_get_match_data(dev);

drivers/mtd/nand/raw/mtk_nand.c

1530

nfc->dev = dev;

drivers/mtd/nand/raw/mtk_nand.c

1532

nfc->regs = devm_platform_ioremap_resource(pdev, 0);

drivers/mtd/nand/raw/mtk_nand.c

1533

if (IS_ERR(nfc->regs)) {

drivers/mtd/nand/raw/mtk_nand.c

1534

ret = PTR_ERR(nfc->regs);

drivers/mtd/nand/raw/mtk_nand.c

1538

nfc->clk.nfi_clk = devm_clk_get_enabled(dev, "nfi_clk");

drivers/mtd/nand/raw/mtk_nand.c

1539

if (IS_ERR(nfc->clk.nfi_clk)) {

drivers/mtd/nand/raw/mtk_nand.c

1541

ret = PTR_ERR(nfc->clk.nfi_clk);

drivers/mtd/nand/raw/mtk_nand.c

1545

nfc->clk.pad_clk = devm_clk_get_enabled(dev, "pad_clk");

drivers/mtd/nand/raw/mtk_nand.c

1546

if (IS_ERR(nfc->clk.pad_clk)) {

drivers/mtd/nand/raw/mtk_nand.c

1548

ret = PTR_ERR(nfc->clk.pad_clk);

drivers/mtd/nand/raw/mtk_nand.c

1558

ret = devm_request_irq(dev, irq, mtk_nfc_irq, 0x0, "mtk-nand", nfc);

drivers/mtd/nand/raw/mtk_nand.c

1570

platform_set_drvdata(pdev, nfc);

drivers/mtd/nand/raw/mtk_nand.c

1572

ret = mtk_nfc_nand_chips_init(dev, nfc);

drivers/mtd/nand/raw/mtk_nand.c

1581

mtk_ecc_release(nfc->ecc);

drivers/mtd/nand/raw/mtk_nand.c

1588

struct mtk_nfc *nfc = platform_get_drvdata(pdev);

drivers/mtd/nand/raw/mtk_nand.c

1590

mtk_nfc_nand_chips_cleanup(nfc);

drivers/mtd/nand/raw/mtk_nand.c

1591

mtk_ecc_release(nfc->ecc);

drivers/mtd/nand/raw/mtk_nand.c

1597

struct mtk_nfc *nfc = dev_get_drvdata(dev);

drivers/mtd/nand/raw/mtk_nand.c

1599

clk_disable_unprepare(nfc->clk.nfi_clk);

drivers/mtd/nand/raw/mtk_nand.c

1600

clk_disable_unprepare(nfc->clk.pad_clk);

drivers/mtd/nand/raw/mtk_nand.c

1607

struct mtk_nfc *nfc = dev_get_drvdata(dev);

drivers/mtd/nand/raw/mtk_nand.c

1615

ret = clk_prepare_enable(nfc->clk.nfi_clk);

drivers/mtd/nand/raw/mtk_nand.c

1621

ret = clk_prepare_enable(nfc->clk.pad_clk);

drivers/mtd/nand/raw/mtk_nand.c

1624

clk_disable_unprepare(nfc->clk.nfi_clk);

drivers/mtd/nand/raw/mtk_nand.c

1629

list_for_each_entry(chip, &nfc->chips, node) {

drivers/mtd/nand/raw/mtk_nand.c

216

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

218

return nfc->buffer + i * mtk_data_len(chip);

drivers/mtd/nand/raw/mtk_nand.c

223

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

225

return nfc->buffer + i * mtk_data_len(chip) + chip->ecc.size;

drivers/mtd/nand/raw/mtk_nand.c

228

static inline void nfi_writel(struct mtk_nfc *nfc, u32 val, u32 reg)

drivers/mtd/nand/raw/mtk_nand.c

230

writel(val, nfc->regs + reg);

drivers/mtd/nand/raw/mtk_nand.c

233

static inline void nfi_writew(struct mtk_nfc *nfc, u16 val, u32 reg)

drivers/mtd/nand/raw/mtk_nand.c

235

writew(val, nfc->regs + reg);

drivers/mtd/nand/raw/mtk_nand.c

238

static inline void nfi_writeb(struct mtk_nfc *nfc, u8 val, u32 reg)

drivers/mtd/nand/raw/mtk_nand.c

240

writeb(val, nfc->regs + reg);

drivers/mtd/nand/raw/mtk_nand.c

243

static inline u32 nfi_readl(struct mtk_nfc *nfc, u32 reg)

drivers/mtd/nand/raw/mtk_nand.c

245

return readl_relaxed(nfc->regs + reg);

drivers/mtd/nand/raw/mtk_nand.c

248

static inline u16 nfi_readw(struct mtk_nfc *nfc, u32 reg)

drivers/mtd/nand/raw/mtk_nand.c

250

return readw_relaxed(nfc->regs + reg);

drivers/mtd/nand/raw/mtk_nand.c

253

static inline u8 nfi_readb(struct mtk_nfc *nfc, u32 reg)

drivers/mtd/nand/raw/mtk_nand.c

255

return readb_relaxed(nfc->regs + reg);

drivers/mtd/nand/raw/mtk_nand.c

258

static void mtk_nfc_hw_reset(struct mtk_nfc *nfc)

drivers/mtd/nand/raw/mtk_nand.c

260

struct device *dev = nfc->dev;

drivers/mtd/nand/raw/mtk_nand.c

265

nfi_writel(nfc, CON_FIFO_FLUSH | CON_NFI_RST, NFI_CON);

drivers/mtd/nand/raw/mtk_nand.c

268

ret = readl_poll_timeout(nfc->regs + NFI_MASTER_STA, val,

drivers/mtd/nand/raw/mtk_nand.c

276

nfi_writel(nfc, CON_FIFO_FLUSH | CON_NFI_RST, NFI_CON);

drivers/mtd/nand/raw/mtk_nand.c

277

nfi_writew(nfc, STAR_DE, NFI_STRDATA);

drivers/mtd/nand/raw/mtk_nand.c

280

static int mtk_nfc_send_command(struct mtk_nfc *nfc, u8 command)

drivers/mtd/nand/raw/mtk_nand.c

282

struct device *dev = nfc->dev;

drivers/mtd/nand/raw/mtk_nand.c

286

nfi_writel(nfc, command, NFI_CMD);

drivers/mtd/nand/raw/mtk_nand.c

288

ret = readl_poll_timeout_atomic(nfc->regs + NFI_STA, val,

drivers/mtd/nand/raw/mtk_nand.c

298

static int mtk_nfc_send_address(struct mtk_nfc *nfc, int addr)

drivers/mtd/nand/raw/mtk_nand.c

300

struct device *dev = nfc->dev;

drivers/mtd/nand/raw/mtk_nand.c

304

nfi_writel(nfc, addr, NFI_COLADDR);

drivers/mtd/nand/raw/mtk_nand.c

305

nfi_writel(nfc, 0, NFI_ROWADDR);

drivers/mtd/nand/raw/mtk_nand.c

306

nfi_writew(nfc, 1, NFI_ADDRNOB);

drivers/mtd/nand/raw/mtk_nand.c

308

ret = readl_poll_timeout_atomic(nfc->regs + NFI_STA, val,

drivers/mtd/nand/raw/mtk_nand.c

322

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

356

dev_err(nfc->dev, "invalid page len: %d\n", mtd->writesize);

drivers/mtd/nand/raw/mtk_nand.c

367

for (i = 0; i < nfc->caps->num_spare_size; i++) {

drivers/mtd/nand/raw/mtk_nand.c

368

if (nfc->caps->spare_size[i] == spare)

drivers/mtd/nand/raw/mtk_nand.c

372

if (i == nfc->caps->num_spare_size) {

drivers/mtd/nand/raw/mtk_nand.c

373

dev_err(nfc->dev, "invalid spare size %d\n", spare);

drivers/mtd/nand/raw/mtk_nand.c

377

fmt |= i << nfc->caps->pageformat_spare_shift;

drivers/mtd/nand/raw/mtk_nand.c

381

nfi_writel(nfc, fmt, NFI_PAGEFMT);

drivers/mtd/nand/raw/mtk_nand.c

383

nfc->ecc_cfg.strength = chip->ecc.strength;

drivers/mtd/nand/raw/mtk_nand.c

384

nfc->ecc_cfg.len = chip->ecc.size + mtk_nand->fdm.ecc_size;

drivers/mtd/nand/raw/mtk_nand.c

389

static inline void mtk_nfc_wait_ioready(struct mtk_nfc *nfc)

drivers/mtd/nand/raw/mtk_nand.c

394

rc = readb_poll_timeout_atomic(nfc->regs + NFI_PIO_DIRDY, val,

drivers/mtd/nand/raw/mtk_nand.c

397

dev_err(nfc->dev, "data not ready\n");

drivers/mtd/nand/raw/mtk_nand.c

402

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

406

reg = nfi_readl(nfc, NFI_STA) & NFI_FSM_MASK;

drivers/mtd/nand/raw/mtk_nand.c

408

reg = nfi_readw(nfc, NFI_CNFG);

drivers/mtd/nand/raw/mtk_nand.c

410

nfi_writew(nfc, reg, NFI_CNFG);

drivers/mtd/nand/raw/mtk_nand.c

416

reg = (nfc->caps->max_sector << CON_SEC_SHIFT) | CON_BRD;

drivers/mtd/nand/raw/mtk_nand.c

417

nfi_writel(nfc, reg, NFI_CON);

drivers/mtd/nand/raw/mtk_nand.c

420

nfi_writew(nfc, STAR_EN, NFI_STRDATA);

drivers/mtd/nand/raw/mtk_nand.c

423

mtk_nfc_wait_ioready(nfc);

drivers/mtd/nand/raw/mtk_nand.c

425

return nfi_readb(nfc, NFI_DATAR);

drivers/mtd/nand/raw/mtk_nand.c

438

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

441

reg = nfi_readl(nfc, NFI_STA) & NFI_FSM_MASK;

drivers/mtd/nand/raw/mtk_nand.c

444

reg = nfi_readw(nfc, NFI_CNFG) | CNFG_BYTE_RW;

drivers/mtd/nand/raw/mtk_nand.c

445

nfi_writew(nfc, reg, NFI_CNFG);

drivers/mtd/nand/raw/mtk_nand.c

447

reg = nfc->caps->max_sector << CON_SEC_SHIFT | CON_BWR;

drivers/mtd/nand/raw/mtk_nand.c

448

nfi_writel(nfc, reg, NFI_CON);

drivers/mtd/nand/raw/mtk_nand.c

450

nfi_writew(nfc, STAR_EN, NFI_STRDATA);

drivers/mtd/nand/raw/mtk_nand.c

453

mtk_nfc_wait_ioready(nfc);

drivers/mtd/nand/raw/mtk_nand.c

454

nfi_writeb(nfc, byte, NFI_DATAW);

drivers/mtd/nand/raw/mtk_nand.c

468

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

474

mtk_nfc_send_command(nfc, instr->ctx.cmd.opcode);

drivers/mtd/nand/raw/mtk_nand.c

478

mtk_nfc_send_address(nfc, instr->ctx.addr.addrs[i]);

drivers/mtd/nand/raw/mtk_nand.c

489

return readl_poll_timeout(nfc->regs + NFI_STA, status,

drivers/mtd/nand/raw/mtk_nand.c

501

struct mtk_nfc *nfc = nand_get_controller_data(nand);

drivers/mtd/nand/raw/mtk_nand.c

506

nfi_writel(nfc, mtk_nand->sels[cs], NFI_CSEL);

drivers/mtd/nand/raw/mtk_nand.c

513

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

520

mtk_nfc_hw_reset(nfc);

drivers/mtd/nand/raw/mtk_nand.c

521

nfi_writew(nfc, CNFG_OP_CUST, NFI_CNFG);

drivers/mtd/nand/raw/mtk_nand.c

536

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

548

rate = clk_get_rate(nfc->clk.nfi_clk);

drivers/mtd/nand/raw/mtk_nand.c

550

rate /= nfc->caps->nfi_clk_div;

drivers/mtd/nand/raw/mtk_nand.c

617

temp = nfi_readl(nfc, NFI_DEBUG_CON1);

drivers/mtd/nand/raw/mtk_nand.c

620

nfi_writel(nfc, temp, NFI_DEBUG_CON1);

drivers/mtd/nand/raw/mtk_nand.c

636

nfi_writel(nfc, trlt, NFI_ACCCON);

drivers/mtd/nand/raw/mtk_nand.c

643

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

647

nfc->ecc_cfg.mode = ECC_DMA_MODE;

drivers/mtd/nand/raw/mtk_nand.c

648

nfc->ecc_cfg.op = ECC_ENCODE;

drivers/mtd/nand/raw/mtk_nand.c

650

return mtk_ecc_encode(nfc->ecc, &nfc->ecc_cfg, data, size);

drivers/mtd/nand/raw/mtk_nand.c

677

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

685

memset(nfc->buffer, 0xff, mtd->writesize + mtd->oobsize);

drivers/mtd/nand/raw/mtk_nand.c

694

mtk_nand->bad_mark.bm_swap(mtd, nfc->buffer, 1);

drivers/mtd/nand/raw/mtk_nand.c

711

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

715

memset(nfc->buffer, 0xff, mtd->writesize + mtd->oobsize);

drivers/mtd/nand/raw/mtk_nand.c

722

mtk_nand->bad_mark.bm_swap(mtd, nfc->buffer, 1);

drivers/mtd/nand/raw/mtk_nand.c

731

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

740

vall = nfi_readl(nfc, NFI_FDML(i));

drivers/mtd/nand/raw/mtk_nand.c

741

valm = nfi_readl(nfc, NFI_FDMM(i));

drivers/mtd/nand/raw/mtk_nand.c

750

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

769

nfi_writel(nfc, vall, NFI_FDML(i));

drivers/mtd/nand/raw/mtk_nand.c

770

nfi_writel(nfc, valm, NFI_FDMM(i));

drivers/mtd/nand/raw/mtk_nand.c

777

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

778

struct device *dev = nfc->dev;

drivers/mtd/nand/raw/mtk_nand.c

784

ret = dma_mapping_error(nfc->dev, addr);

drivers/mtd/nand/raw/mtk_nand.c

786

dev_err(nfc->dev, "dma mapping error\n");

drivers/mtd/nand/raw/mtk_nand.c

790

reg = nfi_readw(nfc, NFI_CNFG) | CNFG_AHB | CNFG_DMA_BURST_EN;

drivers/mtd/nand/raw/mtk_nand.c

791

nfi_writew(nfc, reg, NFI_CNFG);

drivers/mtd/nand/raw/mtk_nand.c

793

nfi_writel(nfc, chip->ecc.steps << CON_SEC_SHIFT, NFI_CON);

drivers/mtd/nand/raw/mtk_nand.c

794

nfi_writel(nfc, lower_32_bits(addr), NFI_STRADDR);

drivers/mtd/nand/raw/mtk_nand.c

795

nfi_writew(nfc, INTR_AHB_DONE_EN, NFI_INTR_EN);

drivers/mtd/nand/raw/mtk_nand.c

797

init_completion(&nfc->done);

drivers/mtd/nand/raw/mtk_nand.c

799

reg = nfi_readl(nfc, NFI_CON) | CON_BWR;

drivers/mtd/nand/raw/mtk_nand.c

800

nfi_writel(nfc, reg, NFI_CON);

drivers/mtd/nand/raw/mtk_nand.c

801

nfi_writew(nfc, STAR_EN, NFI_STRDATA);

drivers/mtd/nand/raw/mtk_nand.c

803

ret = wait_for_completion_timeout(&nfc->done, msecs_to_jiffies(500));

drivers/mtd/nand/raw/mtk_nand.c

806

nfi_writew(nfc, 0, NFI_INTR_EN);

drivers/mtd/nand/raw/mtk_nand.c

811

ret = readl_poll_timeout_atomic(nfc->regs + NFI_ADDRCNTR, reg,

drivers/mtd/nand/raw/mtk_nand.c

819

dma_unmap_single(nfc->dev, addr, len, DMA_TO_DEVICE);

drivers/mtd/nand/raw/mtk_nand.c

820

nfi_writel(nfc, 0, NFI_CON);

drivers/mtd/nand/raw/mtk_nand.c

828

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

840

reg = nfi_readw(nfc, NFI_CNFG) | CNFG_AUTO_FMT_EN;

drivers/mtd/nand/raw/mtk_nand.c

841

nfi_writew(nfc, reg | CNFG_HW_ECC_EN, NFI_CNFG);

drivers/mtd/nand/raw/mtk_nand.c

843

nfc->ecc_cfg.op = ECC_ENCODE;

drivers/mtd/nand/raw/mtk_nand.c

844

nfc->ecc_cfg.mode = ECC_NFI_MODE;

drivers/mtd/nand/raw/mtk_nand.c

845

ret = mtk_ecc_enable(nfc->ecc, &nfc->ecc_cfg);

drivers/mtd/nand/raw/mtk_nand.c

848

reg = nfi_readw(nfc, NFI_CNFG);

drivers/mtd/nand/raw/mtk_nand.c

850

nfi_writew(nfc, reg, NFI_CNFG);

drivers/mtd/nand/raw/mtk_nand.c

855

memcpy(nfc->buffer, buf, mtd->writesize);

drivers/mtd/nand/raw/mtk_nand.c

856

mtk_nand->bad_mark.bm_swap(mtd, nfc->buffer, raw);

drivers/mtd/nand/raw/mtk_nand.c

857

bufpoi = nfc->buffer;

drivers/mtd/nand/raw/mtk_nand.c

869

mtk_ecc_disable(nfc->ecc);

drivers/mtd/nand/raw/mtk_nand.c

887

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

890

return mtk_nfc_write_page(mtd, chip, nfc->buffer, pg, 1);

drivers/mtd/nand/raw/mtk_nand.c

898

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

906

return mtk_nfc_write_page(mtd, chip, nfc->buffer, page, 1);

drivers/mtd/nand/raw/mtk_nand.c

918

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

924

rc = nfi_readl(nfc, NFI_STA) & STA_EMP_PAGE;

drivers/mtd/nand/raw/mtk_nand.c

932

mtk_ecc_get_stats(nfc->ecc, &stats, sectors);

drivers/mtd/nand/raw/mtk_nand.c

943

struct mtk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mtk_nand.c

965

addr = dma_map_single(nfc->dev, buf, len, DMA_FROM_DEVICE);

drivers/mtd/nand/raw/mtk_nand.c

966

rc = dma_mapping_error(nfc->dev, addr);

drivers/mtd/nand/raw/mtk_nand.c

968

dev_err(nfc->dev, "dma mapping error\n");

drivers/mtd/nand/raw/mtk_nand.c

973

reg = nfi_readw(nfc, NFI_CNFG);

drivers/mtd/nand/raw/mtk_nand.c

977

nfi_writew(nfc, reg, NFI_CNFG);

drivers/mtd/nand/raw/mtk_nand.c

979

nfc->ecc_cfg.mode = ECC_NFI_MODE;

drivers/mtd/nand/raw/mtk_nand.c

980

nfc->ecc_cfg.sectors = sectors;

drivers/mtd/nand/raw/mtk_nand.c

981

nfc->ecc_cfg.op = ECC_DECODE;

drivers/mtd/nand/raw/mtk_nand.c

982

rc = mtk_ecc_enable(nfc->ecc, &nfc->ecc_cfg);

drivers/mtd/nand/raw/mtk_nand.c

984

dev_err(nfc->dev, "ecc enable\n");

drivers/mtd/nand/raw/mtk_nand.c

988

nfi_writew(nfc, reg, NFI_CNFG);

drivers/mtd/nand/raw/mtk_nand.c

989

dma_unmap_single(nfc->dev, addr, len, DMA_FROM_DEVICE);

drivers/mtd/nand/raw/mtk_nand.c

994

nfi_writew(nfc, reg, NFI_CNFG);

drivers/mtd/nand/raw/mtk_nand.c

997

nfi_writel(nfc, sectors << CON_SEC_SHIFT, NFI_CON);

drivers/mtd/nand/raw/mtk_nand.c

998

nfi_writew(nfc, INTR_AHB_DONE_EN, NFI_INTR_EN);

drivers/mtd/nand/raw/mtk_nand.c

999

nfi_writel(nfc, lower_32_bits(addr), NFI_STRADDR);

drivers/mtd/nand/raw/mxic_nand.c

184

static int mxic_nfc_clk_enable(struct mxic_nand_ctlr *nfc)

drivers/mtd/nand/raw/mxic_nand.c

188

ret = clk_prepare_enable(nfc->ps_clk);

drivers/mtd/nand/raw/mxic_nand.c

192

ret = clk_prepare_enable(nfc->send_clk);

drivers/mtd/nand/raw/mxic_nand.c

196

ret = clk_prepare_enable(nfc->send_dly_clk);

drivers/mtd/nand/raw/mxic_nand.c

203

clk_disable_unprepare(nfc->send_clk);

drivers/mtd/nand/raw/mxic_nand.c

205

clk_disable_unprepare(nfc->ps_clk);

drivers/mtd/nand/raw/mxic_nand.c

210

static void mxic_nfc_clk_disable(struct mxic_nand_ctlr *nfc)

drivers/mtd/nand/raw/mxic_nand.c

212

clk_disable_unprepare(nfc->send_clk);

drivers/mtd/nand/raw/mxic_nand.c

213

clk_disable_unprepare(nfc->send_dly_clk);

drivers/mtd/nand/raw/mxic_nand.c

214

clk_disable_unprepare(nfc->ps_clk);

drivers/mtd/nand/raw/mxic_nand.c

217

static void mxic_nfc_set_input_delay(struct mxic_nand_ctlr *nfc, u8 idly_code)

drivers/mtd/nand/raw/mxic_nand.c

223

nfc->regs + IDLY_CODE(0));

drivers/mtd/nand/raw/mxic_nand.c

228

nfc->regs + IDLY_CODE(1));

drivers/mtd/nand/raw/mxic_nand.c

231

static int mxic_nfc_clk_setup(struct mxic_nand_ctlr *nfc, unsigned long freq)

drivers/mtd/nand/raw/mxic_nand.c

235

ret = clk_set_rate(nfc->send_clk, freq);

drivers/mtd/nand/raw/mxic_nand.c

239

ret = clk_set_rate(nfc->send_dly_clk, freq);

drivers/mtd/nand/raw/mxic_nand.c

247

mxic_nfc_set_input_delay(nfc, 0xf);

drivers/mtd/nand/raw/mxic_nand.c

257

ret = clk_set_phase(nfc->send_dly_clk, 9 * freq / 25000000);

drivers/mtd/nand/raw/mxic_nand.c

264

static int mxic_nfc_set_freq(struct mxic_nand_ctlr *nfc, unsigned long freq)

drivers/mtd/nand/raw/mxic_nand.c

271

mxic_nfc_clk_disable(nfc);

drivers/mtd/nand/raw/mxic_nand.c

272

ret = mxic_nfc_clk_setup(nfc, freq);

drivers/mtd/nand/raw/mxic_nand.c

276

ret = mxic_nfc_clk_enable(nfc);

drivers/mtd/nand/raw/mxic_nand.c

285

struct mxic_nand_ctlr *nfc = dev_id;

drivers/mtd/nand/raw/mxic_nand.c

288

sts = readl(nfc->regs + INT_STS);

drivers/mtd/nand/raw/mxic_nand.c

290

complete(&nfc->complete);

drivers/mtd/nand/raw/mxic_nand.c

297

static void mxic_nfc_hw_init(struct mxic_nand_ctlr *nfc)

drivers/mtd/nand/raw/mxic_nand.c

301

HC_CFG_IDLE_SIO_LVL(1), nfc->regs + HC_CFG);

drivers/mtd/nand/raw/mxic_nand.c

302

writel(INT_STS_ALL, nfc->regs + INT_STS_EN);

drivers/mtd/nand/raw/mxic_nand.c

303

writel(INT_RDY_PIN, nfc->regs + INT_SIG_EN);

drivers/mtd/nand/raw/mxic_nand.c

304

writel(0x0, nfc->regs + ONFI_DIN_CNT(0));

drivers/mtd/nand/raw/mxic_nand.c

305

writel(0, nfc->regs + LRD_CFG);

drivers/mtd/nand/raw/mxic_nand.c

306

writel(0, nfc->regs + LRD_CTRL);

drivers/mtd/nand/raw/mxic_nand.c

307

writel(0x0, nfc->regs + HC_EN);

drivers/mtd/nand/raw/mxic_nand.c

310

static void mxic_nfc_cs_enable(struct mxic_nand_ctlr *nfc)

drivers/mtd/nand/raw/mxic_nand.c

312

writel(readl(nfc->regs + HC_CFG) | HC_CFG_MAN_CS_EN,

drivers/mtd/nand/raw/mxic_nand.c

313

nfc->regs + HC_CFG);

drivers/mtd/nand/raw/mxic_nand.c

314

writel(HC_CFG_MAN_CS_ASSERT | readl(nfc->regs + HC_CFG),

drivers/mtd/nand/raw/mxic_nand.c

315

nfc->regs + HC_CFG);

drivers/mtd/nand/raw/mxic_nand.c

318

static void mxic_nfc_cs_disable(struct mxic_nand_ctlr *nfc)

drivers/mtd/nand/raw/mxic_nand.c

320

writel(~HC_CFG_MAN_CS_ASSERT & readl(nfc->regs + HC_CFG),

drivers/mtd/nand/raw/mxic_nand.c

321

nfc->regs + HC_CFG);

drivers/mtd/nand/raw/mxic_nand.c

326

struct mxic_nand_ctlr *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mxic_nand.c

329

ret = wait_for_completion_timeout(&nfc->complete,

drivers/mtd/nand/raw/mxic_nand.c

332

dev_err(nfc->dev, "nand device timeout\n");

drivers/mtd/nand/raw/mxic_nand.c

339

static int mxic_nfc_data_xfer(struct mxic_nand_ctlr *nfc, const void *txbuf,

drivers/mtd/nand/raw/mxic_nand.c

356

ret = readl_poll_timeout(nfc->regs + INT_STS, sts,

drivers/mtd/nand/raw/mxic_nand.c

361

writel(data, nfc->regs + TXD(nbytes % 4));

drivers/mtd/nand/raw/mxic_nand.c

363

ret = readl_poll_timeout(nfc->regs + INT_STS, sts,

drivers/mtd/nand/raw/mxic_nand.c

368

ret = readl_poll_timeout(nfc->regs + INT_STS, sts,

drivers/mtd/nand/raw/mxic_nand.c

374

data = readl(nfc->regs + RXD);

drivers/mtd/nand/raw/mxic_nand.c

379

if (readl(nfc->regs + INT_STS) & INT_RX_NOT_EMPTY)

drivers/mtd/nand/raw/mxic_nand.c

380

dev_warn(nfc->dev, "RX FIFO not empty\n");

drivers/mtd/nand/raw/mxic_nand.c

391

struct mxic_nand_ctlr *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mxic_nand.c

399

mxic_nfc_cs_enable(nfc);

drivers/mtd/nand/raw/mxic_nand.c

400

init_completion(&nfc->complete);

drivers/mtd/nand/raw/mxic_nand.c

406

writel(0, nfc->regs + HC_EN);

drivers/mtd/nand/raw/mxic_nand.c

407

writel(HC_EN_BIT, nfc->regs + HC_EN);

drivers/mtd/nand/raw/mxic_nand.c

409

OP_CMD_BYTES(0), nfc->regs + SS_CTRL(0));

drivers/mtd/nand/raw/mxic_nand.c

411

ret = mxic_nfc_data_xfer(nfc,

drivers/mtd/nand/raw/mxic_nand.c

419

nfc->regs + SS_CTRL(0));

drivers/mtd/nand/raw/mxic_nand.c

420

ret = mxic_nfc_data_xfer(nfc,

drivers/mtd/nand/raw/mxic_nand.c

426

writel(0x0, nfc->regs + ONFI_DIN_CNT(0));

drivers/mtd/nand/raw/mxic_nand.c

428

OP_READ, nfc->regs + SS_CTRL(0));

drivers/mtd/nand/raw/mxic_nand.c

429

ret = mxic_nfc_data_xfer(nfc, NULL,

drivers/mtd/nand/raw/mxic_nand.c

436

nfc->regs + ONFI_DIN_CNT(0));

drivers/mtd/nand/raw/mxic_nand.c

438

nfc->regs + SS_CTRL(0));

drivers/mtd/nand/raw/mxic_nand.c

439

ret = mxic_nfc_data_xfer(nfc,

drivers/mtd/nand/raw/mxic_nand.c

449

mxic_nfc_cs_disable(nfc);

drivers/mtd/nand/raw/mxic_nand.c

457

struct mxic_nand_ctlr *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/mxic_nand.c

471

ret = mxic_nfc_set_freq(nfc, freq);

drivers/mtd/nand/raw/mxic_nand.c

473

dev_err(nfc->dev, "set freq:%ld failed\n", freq);

drivers/mtd/nand/raw/mxic_nand.c

476

writel(DATA_STROB_EDO_EN, nfc->regs + DATA_STROB);

drivers/mtd/nand/raw/mxic_nand.c

490

struct mxic_nand_ctlr *nfc;

drivers/mtd/nand/raw/mxic_nand.c

495

nfc = devm_kzalloc(&pdev->dev, sizeof(struct mxic_nand_ctlr),

drivers/mtd/nand/raw/mxic_nand.c

497

if (!nfc)

drivers/mtd/nand/raw/mxic_nand.c

500

nfc->ps_clk = devm_clk_get(&pdev->dev, "ps");

drivers/mtd/nand/raw/mxic_nand.c

501

if (IS_ERR(nfc->ps_clk))

drivers/mtd/nand/raw/mxic_nand.c

502

return PTR_ERR(nfc->ps_clk);

drivers/mtd/nand/raw/mxic_nand.c

504

nfc->send_clk = devm_clk_get(&pdev->dev, "send");

drivers/mtd/nand/raw/mxic_nand.c

505

if (IS_ERR(nfc->send_clk))

drivers/mtd/nand/raw/mxic_nand.c

506

return PTR_ERR(nfc->send_clk);

drivers/mtd/nand/raw/mxic_nand.c

508

nfc->send_dly_clk = devm_clk_get(&pdev->dev, "send_dly");

drivers/mtd/nand/raw/mxic_nand.c

509

if (IS_ERR(nfc->send_dly_clk))

drivers/mtd/nand/raw/mxic_nand.c

510

return PTR_ERR(nfc->send_dly_clk);

drivers/mtd/nand/raw/mxic_nand.c

512

nfc->regs = devm_platform_ioremap_resource(pdev, 0);

drivers/mtd/nand/raw/mxic_nand.c

513

if (IS_ERR(nfc->regs))

drivers/mtd/nand/raw/mxic_nand.c

514

return PTR_ERR(nfc->regs);

drivers/mtd/nand/raw/mxic_nand.c

516

nand_chip = &nfc->chip;

drivers/mtd/nand/raw/mxic_nand.c

523

nand_chip->priv = nfc;

drivers/mtd/nand/raw/mxic_nand.c

524

nfc->dev = &pdev->dev;

drivers/mtd/nand/raw/mxic_nand.c

525

nfc->controller.ops = &mxic_nand_controller_ops;

drivers/mtd/nand/raw/mxic_nand.c

526

nand_controller_init(&nfc->controller);

drivers/mtd/nand/raw/mxic_nand.c

527

nand_chip->controller = &nfc->controller;

drivers/mtd/nand/raw/mxic_nand.c

533

mxic_nfc_hw_init(nfc);

drivers/mtd/nand/raw/mxic_nand.c

536

0, "mxic-nfc", nfc);

drivers/mtd/nand/raw/mxic_nand.c

548

platform_set_drvdata(pdev, nfc);

drivers/mtd/nand/raw/mxic_nand.c

552

mxic_nfc_clk_disable(nfc);

drivers/mtd/nand/raw/mxic_nand.c

558

struct mxic_nand_ctlr *nfc = platform_get_drvdata(pdev);

drivers/mtd/nand/raw/mxic_nand.c

559

struct nand_chip *chip = &nfc->chip;

drivers/mtd/nand/raw/mxic_nand.c

566

mxic_nfc_clk_disable(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1007

static int pl35x_nand_reset_state(struct pl35x_nandc *nfc)

drivers/mtd/nand/raw/pl35x-nand-controller.c

1015

nfc->conf_regs + PL35X_SMC_MEMC_CFG_CLR);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1018

ret = pl35x_smc_set_buswidth(nfc, PL35X_SMC_OPMODE_BW_8);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1023

ret = pl35x_smc_set_ecc_mode(nfc, NULL, PL35X_SMC_ECC_CFG_MODE_BYPASS);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1035

nfc->conf_regs + PL35X_SMC_ECC_CMD1);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1040

nfc->conf_regs + PL35X_SMC_ECC_CMD2);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1045

static int pl35x_nand_chip_init(struct pl35x_nandc *nfc,

drivers/mtd/nand/raw/pl35x-nand-controller.c

1053

plnand = devm_kzalloc(nfc->dev, sizeof(*plnand), GFP_KERNEL);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1062

dev_err(nfc->dev, "Wrong CS %d\n", cs);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1066

if (test_and_set_bit(cs, &nfc->assigned_cs)) {

drivers/mtd/nand/raw/pl35x-nand-controller.c

1067

dev_err(nfc->dev, "Already assigned CS %d\n", cs);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1076

chip->controller = &nfc->controller;

drivers/mtd/nand/raw/pl35x-nand-controller.c

1078

mtd->dev.parent = nfc->dev;

drivers/mtd/nand/raw/pl35x-nand-controller.c

1081

mtd->name = devm_kasprintf(nfc->dev, GFP_KERNEL,

drivers/mtd/nand/raw/pl35x-nand-controller.c

1084

dev_err(nfc->dev, "Failed to allocate mtd->name\n");

drivers/mtd/nand/raw/pl35x-nand-controller.c

1099

list_add_tail(&plnand->node, &nfc->chips);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1104

static void pl35x_nand_chips_cleanup(struct pl35x_nandc *nfc)

drivers/mtd/nand/raw/pl35x-nand-controller.c

1110

list_for_each_entry_safe(plnand, tmp, &nfc->chips, node) {

drivers/mtd/nand/raw/pl35x-nand-controller.c

1119

static int pl35x_nand_chips_init(struct pl35x_nandc *nfc)

drivers/mtd/nand/raw/pl35x-nand-controller.c

1121

struct device_node *np = nfc->dev->of_node;

drivers/mtd/nand/raw/pl35x-nand-controller.c

1126

dev_err(nfc->dev, "Incorrect number of NAND chips (%d)\n",

drivers/mtd/nand/raw/pl35x-nand-controller.c

1132

ret = pl35x_nand_chip_init(nfc, nand_np);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1134

pl35x_nand_chips_cleanup(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1146

struct pl35x_nandc *nfc;

drivers/mtd/nand/raw/pl35x-nand-controller.c

1149

nfc = devm_kzalloc(&pdev->dev, sizeof(*nfc), GFP_KERNEL);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1150

if (!nfc)

drivers/mtd/nand/raw/pl35x-nand-controller.c

1153

nfc->dev = &pdev->dev;

drivers/mtd/nand/raw/pl35x-nand-controller.c

1154

nand_controller_init(&nfc->controller);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1155

nfc->controller.ops = &pl35x_nandc_ops;

drivers/mtd/nand/raw/pl35x-nand-controller.c

1156

INIT_LIST_HEAD(&nfc->chips);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1158

nfc->conf_regs = devm_ioremap_resource(&smc_amba->dev, &smc_amba->res);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1159

if (IS_ERR(nfc->conf_regs))

drivers/mtd/nand/raw/pl35x-nand-controller.c

1160

return PTR_ERR(nfc->conf_regs);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1162

nfc->io_regs = devm_platform_ioremap_resource(pdev, 0);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1163

if (IS_ERR(nfc->io_regs))

drivers/mtd/nand/raw/pl35x-nand-controller.c

1164

return PTR_ERR(nfc->io_regs);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1166

ret = pl35x_nand_reset_state(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1170

ret = pl35x_nand_chips_init(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1174

platform_set_drvdata(pdev, nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1181

struct pl35x_nandc *nfc = platform_get_drvdata(pdev);

drivers/mtd/nand/raw/pl35x-nand-controller.c

1183

pl35x_nand_chips_cleanup(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

214

static void pl35x_smc_update_regs(struct pl35x_nandc *nfc)

drivers/mtd/nand/raw/pl35x-nand-controller.c

218

nfc->conf_regs + PL35X_SMC_DIRECT_CMD);

drivers/mtd/nand/raw/pl35x-nand-controller.c

221

static int pl35x_smc_set_buswidth(struct pl35x_nandc *nfc, unsigned int bw)

drivers/mtd/nand/raw/pl35x-nand-controller.c

226

writel(bw, nfc->conf_regs + PL35X_SMC_OPMODE);

drivers/mtd/nand/raw/pl35x-nand-controller.c

227

pl35x_smc_update_regs(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

232

static void pl35x_smc_clear_irq(struct pl35x_nandc *nfc)

drivers/mtd/nand/raw/pl35x-nand-controller.c

235

nfc->conf_regs + PL35X_SMC_MEMC_CFG_CLR);

drivers/mtd/nand/raw/pl35x-nand-controller.c

238

static int pl35x_smc_wait_for_irq(struct pl35x_nandc *nfc)

drivers/mtd/nand/raw/pl35x-nand-controller.c

243

ret = readl_poll_timeout(nfc->conf_regs + PL35X_SMC_MEMC_STATUS, reg,

drivers/mtd/nand/raw/pl35x-nand-controller.c

247

dev_err(nfc->dev,

drivers/mtd/nand/raw/pl35x-nand-controller.c

251

pl35x_smc_clear_irq(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

256

static int pl35x_smc_wait_for_ecc_done(struct pl35x_nandc *nfc)

drivers/mtd/nand/raw/pl35x-nand-controller.c

261

ret = readl_poll_timeout(nfc->conf_regs + PL35X_SMC_ECC_STATUS, reg,

drivers/mtd/nand/raw/pl35x-nand-controller.c

265

dev_err(nfc->dev,

drivers/mtd/nand/raw/pl35x-nand-controller.c

271

static int pl35x_smc_set_ecc_mode(struct pl35x_nandc *nfc,

drivers/mtd/nand/raw/pl35x-nand-controller.c

278

ecc_cfg = readl(nfc->conf_regs + PL35X_SMC_ECC_CFG);

drivers/mtd/nand/raw/pl35x-nand-controller.c

281

writel(ecc_cfg, nfc->conf_regs + PL35X_SMC_ECC_CFG);

drivers/mtd/nand/raw/pl35x-nand-controller.c

289

return pl35x_smc_wait_for_ecc_done(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

297

struct pl35x_nandc *nfc = to_pl35x_nandc(chip->controller);

drivers/mtd/nand/raw/pl35x-nand-controller.c

304

ret = pl35x_smc_set_buswidth(nfc, PL35X_SMC_OPMODE_BW_8);

drivers/mtd/nand/raw/pl35x-nand-controller.c

306

ret = pl35x_smc_set_buswidth(nfc, PL35X_SMC_OPMODE_BW_16);

drivers/mtd/nand/raw/pl35x-nand-controller.c

309

dev_err(nfc->dev, "Error in Buswidth\n");

drivers/mtd/nand/raw/pl35x-nand-controller.c

315

struct pl35x_nandc *nfc = to_pl35x_nandc(chip->controller);

drivers/mtd/nand/raw/pl35x-nand-controller.c

318

if (chip == nfc->selected_chip)

drivers/mtd/nand/raw/pl35x-nand-controller.c

322

writel(plnand->timings, nfc->conf_regs + PL35X_SMC_CYCLES);

drivers/mtd/nand/raw/pl35x-nand-controller.c

323

pl35x_smc_update_regs(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

326

writel(plnand->ecc_cfg, nfc->conf_regs + PL35X_SMC_ECC_CFG);

drivers/mtd/nand/raw/pl35x-nand-controller.c

328

nfc->selected_chip = chip;

drivers/mtd/nand/raw/pl35x-nand-controller.c

335

struct pl35x_nandc *nfc = to_pl35x_nandc(chip->controller);

drivers/mtd/nand/raw/pl35x-nand-controller.c

351

buf32[i] = readl(nfc->io_regs + data_phase_addr);

drivers/mtd/nand/raw/pl35x-nand-controller.c

356

buf8[i] = readb(nfc->io_regs + PL35X_SMC_DATA_PHASE);

drivers/mtd/nand/raw/pl35x-nand-controller.c

367

struct pl35x_nandc *nfc = to_pl35x_nandc(chip->controller);

drivers/mtd/nand/raw/pl35x-nand-controller.c

383

writel(buf32[i], nfc->io_regs + data_phase_addr);

drivers/mtd/nand/raw/pl35x-nand-controller.c

388

writeb(buf8[i], nfc->io_regs + PL35X_SMC_DATA_PHASE);

drivers/mtd/nand/raw/pl35x-nand-controller.c

394

static int pl35x_nand_correct_data(struct pl35x_nandc *nfc, unsigned char *buf,

drivers/mtd/nand/raw/pl35x-nand-controller.c

448

static int pl35x_nand_read_eccbytes(struct pl35x_nandc *nfc,

drivers/mtd/nand/raw/pl35x-nand-controller.c

456

ecc_value = readl(nfc->conf_regs + PL35X_SMC_ECC_VALUE(chunk));

drivers/mtd/nand/raw/pl35x-nand-controller.c

466

static int pl35x_nand_recover_data_hwecc(struct pl35x_nandc *nfc,

drivers/mtd/nand/raw/pl35x-nand-controller.c

479

ecc_value = readl(nfc->conf_regs + PL35X_SMC_ECC_VALUE(chunk));

drivers/mtd/nand/raw/pl35x-nand-controller.c

490

stats = pl35x_nand_correct_data(nfc, data, read_ecc, calc_ecc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

506

struct pl35x_nandc *nfc = to_pl35x_nandc(chip->controller);

drivers/mtd/nand/raw/pl35x-nand-controller.c

516

ret = pl35x_smc_set_ecc_mode(nfc, chip, PL35X_SMC_ECC_CFG_MODE_APB);

drivers/mtd/nand/raw/pl35x-nand-controller.c

534

writel(addr1, nfc->io_regs + cmd_addr);

drivers/mtd/nand/raw/pl35x-nand-controller.c

536

writel(addr2, nfc->io_regs + cmd_addr);

drivers/mtd/nand/raw/pl35x-nand-controller.c

541

ret = pl35x_smc_wait_for_ecc_done(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

546

ret = pl35x_nand_read_eccbytes(nfc, chip, nfc->ecc_buf);

drivers/mtd/nand/raw/pl35x-nand-controller.c

553

ret = mtd_ooblayout_set_eccbytes(mtd, nfc->ecc_buf, chip->oob_poi,

drivers/mtd/nand/raw/pl35x-nand-controller.c

563

ret = pl35x_smc_wait_for_irq(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

576

pl35x_smc_set_ecc_mode(nfc, chip, PL35X_SMC_ECC_CFG_MODE_BYPASS);

drivers/mtd/nand/raw/pl35x-nand-controller.c

597

struct pl35x_nandc *nfc = to_pl35x_nandc(chip->controller);

drivers/mtd/nand/raw/pl35x-nand-controller.c

606

ret = pl35x_smc_set_ecc_mode(nfc, chip, PL35X_SMC_ECC_CFG_MODE_APB);

drivers/mtd/nand/raw/pl35x-nand-controller.c

626

writel(addr1, nfc->io_regs + cmd_addr);

drivers/mtd/nand/raw/pl35x-nand-controller.c

628

writel(addr2, nfc->io_regs + cmd_addr);

drivers/mtd/nand/raw/pl35x-nand-controller.c

632

ret = pl35x_smc_wait_for_irq(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

639

ret = pl35x_smc_wait_for_ecc_done(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

646

ret = mtd_ooblayout_get_eccbytes(mtd, nfc->ecc_buf, chip->oob_poi, 0,

drivers/mtd/nand/raw/pl35x-nand-controller.c

651

pl35x_smc_set_ecc_mode(nfc, chip, PL35X_SMC_ECC_CFG_MODE_BYPASS);

drivers/mtd/nand/raw/pl35x-nand-controller.c

654

return pl35x_nand_recover_data_hwecc(nfc, chip, buf, nfc->ecc_buf);

drivers/mtd/nand/raw/pl35x-nand-controller.c

657

pl35x_smc_set_ecc_mode(nfc, chip, PL35X_SMC_ECC_CFG_MODE_BYPASS);

drivers/mtd/nand/raw/pl35x-nand-controller.c

665

struct pl35x_nandc *nfc = to_pl35x_nandc(chip->controller);

drivers/mtd/nand/raw/pl35x-nand-controller.c

722

writel(addr1, nfc->io_regs + cmd_addr);

drivers/mtd/nand/raw/pl35x-nand-controller.c

724

writel(addr2, nfc->io_regs + cmd_addr);

drivers/mtd/nand/raw/pl35x-nand-controller.c

739

ret = pl35x_smc_wait_for_irq(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

787

struct pl35x_nandc *nfc = to_pl35x_nandc(chip->controller);

drivers/mtd/nand/raw/pl35x-nand-controller.c

798

mclk = of_clk_get_by_name(nfc->dev->parent->of_node, "memclk");

drivers/mtd/nand/raw/pl35x-nand-controller.c

800

dev_err(nfc->dev, "Failed to retrieve SMC memclk\n");

drivers/mtd/nand/raw/pl35x-nand-controller.c

865

writel(plnand->timings, nfc->conf_regs + PL35X_SMC_CYCLES);

drivers/mtd/nand/raw/pl35x-nand-controller.c

866

pl35x_smc_update_regs(nfc);

drivers/mtd/nand/raw/pl35x-nand-controller.c

871

static void pl35x_smc_set_ecc_pg_size(struct pl35x_nandc *nfc,

drivers/mtd/nand/raw/pl35x-nand-controller.c

893

plnand->ecc_cfg = readl(nfc->conf_regs + PL35X_SMC_ECC_CFG);

drivers/mtd/nand/raw/pl35x-nand-controller.c

896

writel(plnand->ecc_cfg, nfc->conf_regs + PL35X_SMC_ECC_CFG);

drivers/mtd/nand/raw/pl35x-nand-controller.c

899

static int pl35x_nand_init_hw_ecc_controller(struct pl35x_nandc *nfc,

drivers/mtd/nand/raw/pl35x-nand-controller.c

906

dev_err(nfc->dev,

drivers/mtd/nand/raw/pl35x-nand-controller.c

918

pl35x_smc_set_ecc_pg_size(nfc, chip, mtd->writesize);

drivers/mtd/nand/raw/pl35x-nand-controller.c

920

nfc->ecc_buf = devm_kmalloc(nfc->dev, chip->ecc.bytes * chip->ecc.steps,

drivers/mtd/nand/raw/pl35x-nand-controller.c

922

if (!nfc->ecc_buf)

drivers/mtd/nand/raw/pl35x-nand-controller.c

935

dev_err(nfc->dev, "Unsupported OOB size\n");

drivers/mtd/nand/raw/pl35x-nand-controller.c

946

struct pl35x_nandc *nfc = to_pl35x_nandc(chip->controller);

drivers/mtd/nand/raw/pl35x-nand-controller.c

957

dev_info(nfc->dev,

drivers/mtd/nand/raw/pl35x-nand-controller.c

976

dev_dbg(nfc->dev, "Using on-die ECC\n");

drivers/mtd/nand/raw/pl35x-nand-controller.c

983

dev_dbg(nfc->dev, "Using software ECC (Hamming 1-bit/512B)\n");

drivers/mtd/nand/raw/pl35x-nand-controller.c

987

dev_dbg(nfc->dev, "Using hardware ECC\n");

drivers/mtd/nand/raw/pl35x-nand-controller.c

988

ret = pl35x_nand_init_hw_ecc_controller(nfc, chip);

drivers/mtd/nand/raw/pl35x-nand-controller.c

993

dev_err(nfc->dev, "Unsupported ECC mode: %d\n",

drivers/mtd/nand/raw/rockchip-nand-controller.c

1016

dev_err(nfc->dev, "unsupported ECC strength\n");

drivers/mtd/nand/raw/rockchip-nand-controller.c

1032

struct rk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1062

if (nfc->page_buf && new_page_len > nfc->page_buf_size) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

1063

buf = krealloc(nfc->page_buf, new_page_len,

drivers/mtd/nand/raw/rockchip-nand-controller.c

1067

nfc->page_buf = buf;

drivers/mtd/nand/raw/rockchip-nand-controller.c

1068

nfc->page_buf_size = new_page_len;

drivers/mtd/nand/raw/rockchip-nand-controller.c

1072

if (nfc->oob_buf && new_oob_len > nfc->oob_buf_size) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

1073

buf = krealloc(nfc->oob_buf, new_oob_len,

drivers/mtd/nand/raw/rockchip-nand-controller.c

1076

kfree(nfc->page_buf);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1077

nfc->page_buf = NULL;

drivers/mtd/nand/raw/rockchip-nand-controller.c

1080

nfc->oob_buf = buf;

drivers/mtd/nand/raw/rockchip-nand-controller.c

1081

nfc->oob_buf_size = new_oob_len;

drivers/mtd/nand/raw/rockchip-nand-controller.c

1084

if (!nfc->page_buf) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

1085

nfc->page_buf = kzalloc(new_page_len, GFP_KERNEL | GFP_DMA);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1086

if (!nfc->page_buf)

drivers/mtd/nand/raw/rockchip-nand-controller.c

1088

nfc->page_buf_size = new_page_len;

drivers/mtd/nand/raw/rockchip-nand-controller.c

1091

if (!nfc->oob_buf) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

1092

nfc->oob_buf = kzalloc(new_oob_len, GFP_KERNEL | GFP_DMA);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1093

if (!nfc->oob_buf) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

1094

kfree(nfc->page_buf);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1095

nfc->page_buf = NULL;

drivers/mtd/nand/raw/rockchip-nand-controller.c

1098

nfc->oob_buf_size = new_oob_len;

drivers/mtd/nand/raw/rockchip-nand-controller.c

1118

static int rk_nfc_nand_chip_init(struct device *dev, struct rk_nfc *nfc,

drivers/mtd/nand/raw/rockchip-nand-controller.c

1155

if (test_and_set_bit(tmp, &nfc->assigned_cs)) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

1164

chip->controller = &nfc->controller;

drivers/mtd/nand/raw/rockchip-nand-controller.c

1168

nand_set_controller_data(chip, nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1181

dev_err(nfc->dev, "NAND label property is mandatory\n");

drivers/mtd/nand/raw/rockchip-nand-controller.c

1186

rk_nfc_hw_init(nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1207

list_add_tail(&rknand->node, &nfc->chips);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1212

static void rk_nfc_chips_cleanup(struct rk_nfc *nfc)

drivers/mtd/nand/raw/rockchip-nand-controller.c

1218

list_for_each_entry_safe(rknand, tmp, &nfc->chips, node) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

1227

static int rk_nfc_nand_chips_init(struct device *dev, struct rk_nfc *nfc)

drivers/mtd/nand/raw/rockchip-nand-controller.c

1234

dev_err(nfc->dev, "incorrect number of NAND chips (%d)\n",

drivers/mtd/nand/raw/rockchip-nand-controller.c

1240

ret = rk_nfc_nand_chip_init(dev, nfc, nand_np);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1242

rk_nfc_chips_cleanup(nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1381

struct rk_nfc *nfc;

drivers/mtd/nand/raw/rockchip-nand-controller.c

1384

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

drivers/mtd/nand/raw/rockchip-nand-controller.c

1385

if (!nfc)

drivers/mtd/nand/raw/rockchip-nand-controller.c

1388

nand_controller_init(&nfc->controller);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1389

INIT_LIST_HEAD(&nfc->chips);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1390

nfc->controller.ops = &rk_nfc_controller_ops;

drivers/mtd/nand/raw/rockchip-nand-controller.c

1392

nfc->cfg = of_device_get_match_data(dev);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1393

nfc->dev = dev;

drivers/mtd/nand/raw/rockchip-nand-controller.c

1395

init_completion(&nfc->done);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1397

nfc->regs = devm_platform_ioremap_resource(pdev, 0);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1398

if (IS_ERR(nfc->regs)) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

1399

ret = PTR_ERR(nfc->regs);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1403

nfc->nfc_clk = devm_clk_get(dev, "nfc");

drivers/mtd/nand/raw/rockchip-nand-controller.c

1404

if (IS_ERR(nfc->nfc_clk)) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

1409

nfc->ahb_clk = devm_clk_get(dev, "ahb");

drivers/mtd/nand/raw/rockchip-nand-controller.c

1410

if (IS_ERR(nfc->ahb_clk)) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

1412

ret = PTR_ERR(nfc->ahb_clk);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1416

ret = rk_nfc_enable_clks(dev, nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1426

writel(0, nfc->regs + nfc->cfg->int_en_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1427

ret = devm_request_irq(dev, irq, rk_nfc_irq, 0x0, "rk-nand", nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1433

platform_set_drvdata(pdev, nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1435

ret = rk_nfc_nand_chips_init(dev, nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1443

rk_nfc_disable_clks(nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1450

struct rk_nfc *nfc = platform_get_drvdata(pdev);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1452

kfree(nfc->page_buf);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1453

kfree(nfc->oob_buf);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1454

rk_nfc_chips_cleanup(nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1455

rk_nfc_disable_clks(nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1460

struct rk_nfc *nfc = dev_get_drvdata(dev);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1462

rk_nfc_disable_clks(nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1469

struct rk_nfc *nfc = dev_get_drvdata(dev);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1475

ret = rk_nfc_enable_clks(dev, nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

1480

list_for_each_entry(rknand, &nfc->chips, node) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

226

struct rk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

228

return nfc->page_buf + i * rk_nfc_data_len(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

233

struct rk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

235

return nfc->page_buf + i * rk_nfc_data_len(chip) + chip->ecc.size;

drivers/mtd/nand/raw/rockchip-nand-controller.c

240

struct rk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

244

if (strength == nfc->cfg->ecc_strengths[i]) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

245

reg = nfc->cfg->ecc_cfgs[i];

drivers/mtd/nand/raw/rockchip-nand-controller.c

253

writel(reg, nfc->regs + nfc->cfg->bchctl_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

256

nfc->cur_ecc = strength;

drivers/mtd/nand/raw/rockchip-nand-controller.c

263

struct rk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

269

nfc->selected_bank = -1;

drivers/mtd/nand/raw/rockchip-nand-controller.c

271

val = readl_relaxed(nfc->regs + NFC_FMCTL);

drivers/mtd/nand/raw/rockchip-nand-controller.c

273

writel(val, nfc->regs + NFC_FMCTL);

drivers/mtd/nand/raw/rockchip-nand-controller.c

277

nfc->selected_bank = rknand->sels[cs];

drivers/mtd/nand/raw/rockchip-nand-controller.c

278

nfc->band_offset = NFC_BANK + nfc->selected_bank * NFC_BANK_STEP;

drivers/mtd/nand/raw/rockchip-nand-controller.c

280

val = readl_relaxed(nfc->regs + NFC_FMCTL);

drivers/mtd/nand/raw/rockchip-nand-controller.c

282

val |= FMCTL_CE_SEL(nfc->selected_bank);

drivers/mtd/nand/raw/rockchip-nand-controller.c

284

writel(val, nfc->regs + NFC_FMCTL);

drivers/mtd/nand/raw/rockchip-nand-controller.c

290

if (nfc->cur_timing != rknand->timing) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

291

writel(rknand->timing, nfc->regs + NFC_FMWAIT);

drivers/mtd/nand/raw/rockchip-nand-controller.c

292

nfc->cur_timing = rknand->timing;

drivers/mtd/nand/raw/rockchip-nand-controller.c

299

if (nfc->cur_ecc != ecc->strength)

drivers/mtd/nand/raw/rockchip-nand-controller.c

303

static inline int rk_nfc_wait_ioready(struct rk_nfc *nfc)

drivers/mtd/nand/raw/rockchip-nand-controller.c

308

rc = readl_relaxed_poll_timeout(nfc->regs + NFC_FMCTL, val,

drivers/mtd/nand/raw/rockchip-nand-controller.c

314

static void rk_nfc_read_buf(struct rk_nfc *nfc, u8 *buf, int len)

drivers/mtd/nand/raw/rockchip-nand-controller.c

319

buf[i] = readb_relaxed(nfc->regs + nfc->band_offset +

drivers/mtd/nand/raw/rockchip-nand-controller.c

323

static void rk_nfc_write_buf(struct rk_nfc *nfc, const u8 *buf, int len)

drivers/mtd/nand/raw/rockchip-nand-controller.c

328

writeb(buf[i], nfc->regs + nfc->band_offset + BANK_DATA);

drivers/mtd/nand/raw/rockchip-nand-controller.c

334

struct rk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

336

int reg_offset = nfc->band_offset;

drivers/mtd/nand/raw/rockchip-nand-controller.c

348

nfc->regs + reg_offset + BANK_CMD);

drivers/mtd/nand/raw/rockchip-nand-controller.c

357

nfc->regs + reg_offset + BANK_ADDR);

drivers/mtd/nand/raw/rockchip-nand-controller.c

367

rk_nfc_write_buf(nfc, outbuf, cnt);

drivers/mtd/nand/raw/rockchip-nand-controller.c

370

rk_nfc_read_buf(nfc, inbuf, cnt);

drivers/mtd/nand/raw/rockchip-nand-controller.c

375

if (rk_nfc_wait_ioready(nfc) < 0) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

377

dev_err(nfc->dev, "IO not ready\n");

drivers/mtd/nand/raw/rockchip-nand-controller.c

418

struct rk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

430

if (IS_ERR(nfc->nfc_clk))

drivers/mtd/nand/raw/rockchip-nand-controller.c

431

rate = clk_get_rate(nfc->ahb_clk);

drivers/mtd/nand/raw/rockchip-nand-controller.c

433

rate = clk_get_rate(nfc->nfc_clk);

drivers/mtd/nand/raw/rockchip-nand-controller.c

468

static void rk_nfc_xfer_start(struct rk_nfc *nfc, u8 rw, u8 n_KB,

drivers/mtd/nand/raw/rockchip-nand-controller.c

479

if (nfc->cfg->type == NFC_V6 || nfc->cfg->type == NFC_V8) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

480

bch_reg = readl_relaxed(nfc->regs + nfc->cfg->bchctl_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

482

(nfc->selected_bank << BCHCTL_BANK);

drivers/mtd/nand/raw/rockchip-nand-controller.c

483

writel(bch_reg, nfc->regs + nfc->cfg->bchctl_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

486

writel(dma_reg, nfc->regs + nfc->cfg->dma_cfg_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

487

writel((u32)dma_data, nfc->regs + nfc->cfg->dma_data_buf_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

488

writel((u32)dma_oob, nfc->regs + nfc->cfg->dma_oob_buf_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

489

writel(fl_reg, nfc->regs + nfc->cfg->flctl_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

491

writel(fl_reg, nfc->regs + nfc->cfg->flctl_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

494

static int rk_nfc_wait_for_xfer_done(struct rk_nfc *nfc)

drivers/mtd/nand/raw/rockchip-nand-controller.c

499

ptr = nfc->regs + nfc->cfg->flctl_off;

drivers/mtd/nand/raw/rockchip-nand-controller.c

510

struct rk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

527

memset(nfc->page_buf, 0xff, mtd->writesize + mtd->oobsize);

drivers/mtd/nand/raw/rockchip-nand-controller.c

584

rk_nfc_write_buf(nfc, buf, mtd->writesize + mtd->oobsize);

drivers/mtd/nand/raw/rockchip-nand-controller.c

592

struct rk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

606

memcpy(nfc->page_buf, buf, mtd->writesize);

drivers/mtd/nand/raw/rockchip-nand-controller.c

608

memset(nfc->page_buf, 0xFF, mtd->writesize);

drivers/mtd/nand/raw/rockchip-nand-controller.c

651

if (nfc->cfg->type == NFC_V9)

drivers/mtd/nand/raw/rockchip-nand-controller.c

652

nfc->oob_buf[i] = tmp;

drivers/mtd/nand/raw/rockchip-nand-controller.c

654

nfc->oob_buf[i * (oob_step / 4)] = tmp;

drivers/mtd/nand/raw/rockchip-nand-controller.c

657

dma_data = dma_map_single(nfc->dev, (void *)nfc->page_buf,

drivers/mtd/nand/raw/rockchip-nand-controller.c

659

if (dma_mapping_error(nfc->dev, dma_data))

drivers/mtd/nand/raw/rockchip-nand-controller.c

662

dma_oob = dma_map_single(nfc->dev, nfc->oob_buf,

drivers/mtd/nand/raw/rockchip-nand-controller.c

665

if (dma_mapping_error(nfc->dev, dma_oob)) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

666

dma_unmap_single(nfc->dev, dma_data, mtd->writesize, DMA_TO_DEVICE);

drivers/mtd/nand/raw/rockchip-nand-controller.c

670

reinit_completion(&nfc->done);

drivers/mtd/nand/raw/rockchip-nand-controller.c

671

writel(INT_DMA, nfc->regs + nfc->cfg->int_en_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

673

rk_nfc_xfer_start(nfc, NFC_WRITE, ecc->steps, dma_data,

drivers/mtd/nand/raw/rockchip-nand-controller.c

675

ret = wait_for_completion_timeout(&nfc->done,

drivers/mtd/nand/raw/rockchip-nand-controller.c

678

dev_warn(nfc->dev, "write: wait dma done timeout.\n");

drivers/mtd/nand/raw/rockchip-nand-controller.c

684

ret = rk_nfc_wait_for_xfer_done(nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

686

dma_unmap_single(nfc->dev, dma_data, mtd->writesize,

drivers/mtd/nand/raw/rockchip-nand-controller.c

688

dma_unmap_single(nfc->dev, dma_oob, ecc->steps * oob_step,

drivers/mtd/nand/raw/rockchip-nand-controller.c

695

dev_err(nfc->dev, "write: wait transfer done timeout.\n");

drivers/mtd/nand/raw/rockchip-nand-controller.c

711

struct rk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

728

rk_nfc_read_buf(nfc, nfc->page_buf, mtd->writesize + mtd->oobsize);

drivers/mtd/nand/raw/rockchip-nand-controller.c

765

struct rk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

779

dma_data = dma_map_single(nfc->dev, nfc->page_buf,

drivers/mtd/nand/raw/rockchip-nand-controller.c

782

if (dma_mapping_error(nfc->dev, dma_data))

drivers/mtd/nand/raw/rockchip-nand-controller.c

785

dma_oob = dma_map_single(nfc->dev, nfc->oob_buf,

drivers/mtd/nand/raw/rockchip-nand-controller.c

788

if (dma_mapping_error(nfc->dev, dma_oob)) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

789

dma_unmap_single(nfc->dev, dma_data, mtd->writesize,

drivers/mtd/nand/raw/rockchip-nand-controller.c

806

reinit_completion(&nfc->done);

drivers/mtd/nand/raw/rockchip-nand-controller.c

807

writel(INT_DMA, nfc->regs + nfc->cfg->int_en_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

808

rk_nfc_xfer_start(nfc, NFC_READ, ecc->steps, dma_data,

drivers/mtd/nand/raw/rockchip-nand-controller.c

810

ret = wait_for_completion_timeout(&nfc->done,

drivers/mtd/nand/raw/rockchip-nand-controller.c

813

dev_warn(nfc->dev, "read: wait dma done timeout.\n");

drivers/mtd/nand/raw/rockchip-nand-controller.c

819

ret = rk_nfc_wait_for_xfer_done(nfc);

drivers/mtd/nand/raw/rockchip-nand-controller.c

821

dma_unmap_single(nfc->dev, dma_data, mtd->writesize,

drivers/mtd/nand/raw/rockchip-nand-controller.c

823

dma_unmap_single(nfc->dev, dma_oob, ecc->steps * oob_step,

drivers/mtd/nand/raw/rockchip-nand-controller.c

828

dev_err(nfc->dev, "read: wait transfer done timeout.\n");

drivers/mtd/nand/raw/rockchip-nand-controller.c

838

if (nfc->cfg->type == NFC_V9)

drivers/mtd/nand/raw/rockchip-nand-controller.c

839

tmp = nfc->oob_buf[i];

drivers/mtd/nand/raw/rockchip-nand-controller.c

841

tmp = nfc->oob_buf[i * (oob_step / 4)];

drivers/mtd/nand/raw/rockchip-nand-controller.c

850

bch_st = readl_relaxed(nfc->regs +

drivers/mtd/nand/raw/rockchip-nand-controller.c

851

nfc->cfg->bch_st_off + i * 4);

drivers/mtd/nand/raw/rockchip-nand-controller.c

852

if (bch_st & BIT(nfc->cfg->ecc0.err_flag_bit) ||

drivers/mtd/nand/raw/rockchip-nand-controller.c

853

bch_st & BIT(nfc->cfg->ecc1.err_flag_bit)) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

857

cnt = ECC_ERR_CNT(bch_st, nfc->cfg->ecc0);

drivers/mtd/nand/raw/rockchip-nand-controller.c

861

cnt = ECC_ERR_CNT(bch_st, nfc->cfg->ecc1);

drivers/mtd/nand/raw/rockchip-nand-controller.c

868

memcpy(buf, nfc->page_buf, mtd->writesize);

drivers/mtd/nand/raw/rockchip-nand-controller.c

878

dev_err(nfc->dev, "read page: %x ecc error!\n", page);

drivers/mtd/nand/raw/rockchip-nand-controller.c

890

static inline void rk_nfc_hw_init(struct rk_nfc *nfc)

drivers/mtd/nand/raw/rockchip-nand-controller.c

893

writel(FMCTL_WP, nfc->regs + NFC_FMCTL);

drivers/mtd/nand/raw/rockchip-nand-controller.c

895

writel(0x1081, nfc->regs + NFC_FMWAIT);

drivers/mtd/nand/raw/rockchip-nand-controller.c

896

nfc->cur_timing = 0x1081;

drivers/mtd/nand/raw/rockchip-nand-controller.c

898

writel(0, nfc->regs + nfc->cfg->randmz_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

899

writel(0, nfc->regs + nfc->cfg->dma_cfg_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

900

writel(FLCTL_RST, nfc->regs + nfc->cfg->flctl_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

905

struct rk_nfc *nfc = id;

drivers/mtd/nand/raw/rockchip-nand-controller.c

908

sta = readl_relaxed(nfc->regs + nfc->cfg->int_st_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

909

ien = readl_relaxed(nfc->regs + nfc->cfg->int_en_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

914

writel(sta, nfc->regs + nfc->cfg->int_clr_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

915

writel(~sta & ien, nfc->regs + nfc->cfg->int_en_off);

drivers/mtd/nand/raw/rockchip-nand-controller.c

917

complete(&nfc->done);

drivers/mtd/nand/raw/rockchip-nand-controller.c

922

static int rk_nfc_enable_clks(struct device *dev, struct rk_nfc *nfc)

drivers/mtd/nand/raw/rockchip-nand-controller.c

926

if (!IS_ERR(nfc->nfc_clk)) {

drivers/mtd/nand/raw/rockchip-nand-controller.c

927

ret = clk_prepare_enable(nfc->nfc_clk);

drivers/mtd/nand/raw/rockchip-nand-controller.c

934

ret = clk_prepare_enable(nfc->ahb_clk);

drivers/mtd/nand/raw/rockchip-nand-controller.c

937

clk_disable_unprepare(nfc->nfc_clk);

drivers/mtd/nand/raw/rockchip-nand-controller.c

944

static void rk_nfc_disable_clks(struct rk_nfc *nfc)

drivers/mtd/nand/raw/rockchip-nand-controller.c

946

clk_disable_unprepare(nfc->nfc_clk);

drivers/mtd/nand/raw/rockchip-nand-controller.c

947

clk_disable_unprepare(nfc->ahb_clk);

drivers/mtd/nand/raw/rockchip-nand-controller.c

988

struct rk_nfc *nfc = nand_get_controller_data(chip);

drivers/mtd/nand/raw/rockchip-nand-controller.c

990

const u8 *strengths = nfc->cfg->ecc_strengths;

drivers/mtd/nand/raw/rockchip-nand-controller.c

994

nfc_max_strength = nfc->cfg->ecc_strengths[0];

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1036

static u16 stm32_fmc2_nfc_get_mapping_status(struct stm32_fmc2_nfc *nfc)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1040

regmap_read(nfc->regmap, FMC2_CSQEMSR, &csqemsr);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1049

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1054

u32 *ecc_sta = (u32 *)nfc->ecc_buf;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1055

u16 sta_map = stm32_fmc2_nfc_get_mapping_status(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1108

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1126

sta_map = stm32_fmc2_nfc_get_mapping_status(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1182

struct stm32_fmc2_nfc *nfc = (struct stm32_fmc2_nfc *)dev_id;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1184

if (nfc->irq_state == FMC2_IRQ_SEQ)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1186

stm32_fmc2_nfc_disable_seq_irq(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1187

else if (nfc->irq_state == FMC2_IRQ_BCH)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1189

stm32_fmc2_nfc_disable_bch_irq(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1191

complete(&nfc->complete);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1199

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1200

void __iomem *io_addr_r = nfc->data_base[nfc->cs_sel];

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1204

stm32_fmc2_nfc_set_buswidth_16(nfc, false);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1240

stm32_fmc2_nfc_set_buswidth_16(nfc, true);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1246

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1247

void __iomem *io_addr_w = nfc->data_base[nfc->cs_sel];

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1251

stm32_fmc2_nfc_set_buswidth_16(nfc, false);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1287

stm32_fmc2_nfc_set_buswidth_16(nfc, true);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1293

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1298

if (regmap_read_poll_timeout(nfc->regmap, FMC2_SR, sr,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1301

dev_warn(nfc->dev, "Waitrdy timeout\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1308

regmap_write(nfc->regmap, FMC2_ICR, FMC2_ICR_CIHLF);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1311

return regmap_read_poll_timeout(nfc->regmap, FMC2_ISR, isr,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1320

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1338

nfc->cmd_base[nfc->cs_sel]);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1344

nfc->addr_base[nfc->cs_sel]);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1369

static void stm32_fmc2_nfc_init(struct stm32_fmc2_nfc *nfc)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1373

regmap_read(nfc->regmap, FMC2_PCR, &pcr);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1376

nfc->cs_sel = -1;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1404

if (nfc->dev == nfc->cdev)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1405

regmap_update_bits(nfc->regmap, FMC2_BCR1,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1408

regmap_write(nfc->regmap, FMC2_PCR, pcr);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1409

regmap_write(nfc->regmap, FMC2_PMEM, FMC2_PMEM_DEFAULT);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1410

regmap_write(nfc->regmap, FMC2_PATT, FMC2_PATT_DEFAULT);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1416

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1419

unsigned long hclk = clk_get_rate(nfc->clk);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1564

static int stm32_fmc2_nfc_dma_setup(struct stm32_fmc2_nfc *nfc)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1569

nfc->dma_tx_ch = dma_request_chan(nfc->dev, "tx");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1570

if (IS_ERR(nfc->dma_tx_ch)) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1571

ret = PTR_ERR(nfc->dma_tx_ch);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1573

dev_err(nfc->dev,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1575

nfc->dma_tx_ch = NULL;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1579

ret = dma_get_slave_caps(nfc->dma_tx_ch, &caps);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1582

nfc->tx_dma_max_burst = caps.max_burst;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1584

nfc->dma_rx_ch = dma_request_chan(nfc->dev, "rx");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1585

if (IS_ERR(nfc->dma_rx_ch)) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1586

ret = PTR_ERR(nfc->dma_rx_ch);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1588

dev_err(nfc->dev,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1590

nfc->dma_rx_ch = NULL;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1594

ret = dma_get_slave_caps(nfc->dma_rx_ch, &caps);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1597

nfc->rx_dma_max_burst = caps.max_burst;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1599

nfc->dma_ecc_ch = dma_request_chan(nfc->dev, "ecc");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1600

if (IS_ERR(nfc->dma_ecc_ch)) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1601

ret = PTR_ERR(nfc->dma_ecc_ch);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1603

dev_err(nfc->dev,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1605

nfc->dma_ecc_ch = NULL;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1609

ret = sg_alloc_table(&nfc->dma_ecc_sg, FMC2_MAX_SG, GFP_KERNEL);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1614

nfc->ecc_buf = dmam_alloc_coherent(nfc->dev, FMC2_MAX_ECC_BUF_LEN,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1615

&nfc->dma_ecc_addr, GFP_KERNEL);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1616

if (!nfc->ecc_buf)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1619

ret = sg_alloc_table(&nfc->dma_data_sg, FMC2_MAX_SG, GFP_KERNEL);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1623

init_completion(&nfc->dma_data_complete);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1624

init_completion(&nfc->dma_ecc_complete);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1630

dev_warn(nfc->dev,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1640

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1646

if (nfc->dma_tx_ch && nfc->dma_rx_ch && nfc->dma_ecc_ch) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1733

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1745

dev_err(nfc->dev,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1760

dev_err(nfc->dev, "no valid ECC settings set\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1765

dev_err(nfc->dev, "nand page size is not supported\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1799

static int stm32_fmc2_nfc_parse_child(struct stm32_fmc2_nfc *nfc,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1802

struct stm32_fmc2_nand *nand = &nfc->nand;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1811

dev_err(nfc->dev, "invalid reg property size\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1818

dev_err(nfc->dev, "could not retrieve reg property: %d\n",

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1823

if (cs >= nfc->data->max_ncs) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1824

dev_err(nfc->dev, "invalid reg value: %d\n", cs);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1828

if (nfc->cs_assigned & BIT(cs)) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1829

dev_err(nfc->dev, "cs already assigned: %d\n", cs);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1833

nfc->cs_assigned |= BIT(cs);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1837

nand->wp_gpio = devm_fwnode_gpiod_get(nfc->dev, of_fwnode_handle(dn),

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1842

return dev_err_probe(nfc->dev, ret,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1853

static int stm32_fmc2_nfc_parse_dt(struct stm32_fmc2_nfc *nfc)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1855

struct device_node *dn = nfc->dev->of_node;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1860

dev_err(nfc->dev, "NAND chip not defined\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1865

dev_err(nfc->dev, "too many NAND chips defined\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1870

ret = stm32_fmc2_nfc_parse_child(nfc, child);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1878

static int stm32_fmc2_nfc_set_cdev(struct stm32_fmc2_nfc *nfc)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1880

struct device *dev = nfc->dev;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1889

nfc->cdev = dev->parent;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1900

nfc->cdev = dev;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1909

struct stm32_fmc2_nfc *nfc;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1918

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

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1919

if (!nfc)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1922

nfc->dev = dev;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1923

nand_controller_init(&nfc->base);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1924

nfc->base.ops = &stm32_fmc2_nfc_controller_ops;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1926

nfc->data = of_device_get_match_data(dev);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1927

if (!nfc->data)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1930

if (nfc->data->set_cdev) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1931

ret = nfc->data->set_cdev(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1935

nfc->cdev = dev->parent;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1938

ret = stm32_fmc2_nfc_parse_dt(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1942

ret = of_address_to_resource(nfc->cdev->of_node, 0, &cres);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1946

nfc->io_phys_addr = cres.start;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1948

nfc->regmap = device_node_to_regmap(nfc->cdev->of_node);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1949

if (IS_ERR(nfc->regmap))

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1950

return PTR_ERR(nfc->regmap);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1952

if (nfc->dev == nfc->cdev)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1955

for (chip_cs = 0, mem_region = start_region; chip_cs < nfc->data->max_ncs;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1957

if (!(nfc->cs_assigned & BIT(chip_cs)))

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1960

nfc->data_base[chip_cs] = devm_platform_get_and_ioremap_resource(pdev,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1962

if (IS_ERR(nfc->data_base[chip_cs]))

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1963

return PTR_ERR(nfc->data_base[chip_cs]);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1965

nfc->data_phys_addr[chip_cs] = res->start;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1967

nfc->cmd_base[chip_cs] = devm_platform_ioremap_resource(pdev, mem_region + 1);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1968

if (IS_ERR(nfc->cmd_base[chip_cs]))

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1969

return PTR_ERR(nfc->cmd_base[chip_cs]);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1971

nfc->addr_base[chip_cs] = devm_platform_ioremap_resource(pdev, mem_region + 2);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1972

if (IS_ERR(nfc->addr_base[chip_cs]))

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1973

return PTR_ERR(nfc->addr_base[chip_cs]);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1981

dev_name(dev), nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1987

init_completion(&nfc->complete);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1989

nfc->clk = devm_clk_get_enabled(nfc->cdev, NULL);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1990

if (IS_ERR(nfc->clk)) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1992

return PTR_ERR(nfc->clk);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2005

ret = stm32_fmc2_nfc_dma_setup(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2009

stm32_fmc2_nfc_init(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2011

nand = &nfc->nand;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2016

chip->controller = &nfc->base;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2031

platform_set_drvdata(pdev, nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2042

if (nfc->dma_ecc_ch)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2043

dma_release_channel(nfc->dma_ecc_ch);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2044

if (nfc->dma_tx_ch)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2045

dma_release_channel(nfc->dma_tx_ch);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2046

if (nfc->dma_rx_ch)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2047

dma_release_channel(nfc->dma_rx_ch);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2049

sg_free_table(&nfc->dma_data_sg);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2050

sg_free_table(&nfc->dma_ecc_sg);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2057

struct stm32_fmc2_nfc *nfc = platform_get_drvdata(pdev);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2058

struct stm32_fmc2_nand *nand = &nfc->nand;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2066

if (nfc->dma_ecc_ch)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2067

dma_release_channel(nfc->dma_ecc_ch);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2068

if (nfc->dma_tx_ch)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2069

dma_release_channel(nfc->dma_tx_ch);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2070

if (nfc->dma_rx_ch)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2071

dma_release_channel(nfc->dma_rx_ch);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2073

sg_free_table(&nfc->dma_data_sg);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2074

sg_free_table(&nfc->dma_ecc_sg);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2081

struct stm32_fmc2_nfc *nfc = dev_get_drvdata(dev);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2082

struct stm32_fmc2_nand *nand = &nfc->nand;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2084

clk_disable_unprepare(nfc->clk);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2095

struct stm32_fmc2_nfc *nfc = dev_get_drvdata(dev);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2096

struct stm32_fmc2_nand *nand = &nfc->nand;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2101

ret = clk_prepare_enable(nfc->clk);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2107

stm32_fmc2_nfc_init(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2111

for (chip_cs = 0; chip_cs < nfc->data->max_ncs; chip_cs++) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

2112

if (!(nfc->cs_assigned & BIT(chip_cs)))

drivers/mtd/nand/raw/stm32_fmc2_nand.c

251

int (*set_cdev)(struct stm32_fmc2_nfc *nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

295

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

301

regmap_update_bits(nfc->regmap, FMC2_PCR,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

311

regmap_write(nfc->regmap, FMC2_PMEM, pmem);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

318

regmap_write(nfc->regmap, FMC2_PATT, patt);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

323

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

345

regmap_update_bits(nfc->regmap, FMC2_PCR, pcr_mask, pcr);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

350

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

355

if (nand->cs_used[chipnr] == nfc->cs_sel)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

358

nfc->cs_sel = nand->cs_used[chipnr];

drivers/mtd/nand/raw/stm32_fmc2_nand.c

362

if (nfc->dma_tx_ch) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

364

dma_cfg.dst_addr = nfc->data_phys_addr[nfc->cs_sel];

drivers/mtd/nand/raw/stm32_fmc2_nand.c

366

dma_cfg.dst_maxburst = nfc->tx_dma_max_burst /

drivers/mtd/nand/raw/stm32_fmc2_nand.c

369

ret = dmaengine_slave_config(nfc->dma_tx_ch, &dma_cfg);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

371

dev_err(nfc->dev, "tx DMA engine slave config failed\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

376

if (nfc->dma_rx_ch) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

378

dma_cfg.src_addr = nfc->data_phys_addr[nfc->cs_sel];

drivers/mtd/nand/raw/stm32_fmc2_nand.c

380

dma_cfg.src_maxburst = nfc->rx_dma_max_burst /

drivers/mtd/nand/raw/stm32_fmc2_nand.c

383

ret = dmaengine_slave_config(nfc->dma_rx_ch, &dma_cfg);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

385

dev_err(nfc->dev, "rx DMA engine slave config failed\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

390

if (nfc->dma_ecc_ch) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

396

dma_cfg.src_addr = nfc->io_phys_addr;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

401

ret = dmaengine_slave_config(nfc->dma_ecc_ch, &dma_cfg);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

403

dev_err(nfc->dev, "ECC DMA engine slave config failed\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

408

nfc->dma_ecc_len = chip->ecc.strength == FMC2_ECC_HAM ?

drivers/mtd/nand/raw/stm32_fmc2_nand.c

415

static void stm32_fmc2_nfc_set_buswidth_16(struct stm32_fmc2_nfc *nfc, bool set)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

422

regmap_update_bits(nfc->regmap, FMC2_PCR, FMC2_PCR_PWID, pcr);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

425

static void stm32_fmc2_nfc_set_ecc(struct stm32_fmc2_nfc *nfc, bool enable)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

427

regmap_update_bits(nfc->regmap, FMC2_PCR, FMC2_PCR_ECCEN,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

431

static void stm32_fmc2_nfc_enable_seq_irq(struct stm32_fmc2_nfc *nfc)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

433

nfc->irq_state = FMC2_IRQ_SEQ;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

435

regmap_update_bits(nfc->regmap, FMC2_CSQIER,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

439

static void stm32_fmc2_nfc_disable_seq_irq(struct stm32_fmc2_nfc *nfc)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

441

regmap_update_bits(nfc->regmap, FMC2_CSQIER, FMC2_CSQIER_TCIE, 0);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

443

nfc->irq_state = FMC2_IRQ_UNKNOWN;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

446

static void stm32_fmc2_nfc_clear_seq_irq(struct stm32_fmc2_nfc *nfc)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

448

regmap_write(nfc->regmap, FMC2_CSQICR, FMC2_CSQICR_CLEAR_IRQ);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

451

static void stm32_fmc2_nfc_enable_bch_irq(struct stm32_fmc2_nfc *nfc, int mode)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

453

nfc->irq_state = FMC2_IRQ_BCH;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

456

regmap_update_bits(nfc->regmap, FMC2_BCHIER,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

459

regmap_update_bits(nfc->regmap, FMC2_BCHIER,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

463

static void stm32_fmc2_nfc_disable_bch_irq(struct stm32_fmc2_nfc *nfc)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

465

regmap_update_bits(nfc->regmap, FMC2_BCHIER,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

468

nfc->irq_state = FMC2_IRQ_UNKNOWN;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

471

static void stm32_fmc2_nfc_clear_bch_irq(struct stm32_fmc2_nfc *nfc)

drivers/mtd/nand/raw/stm32_fmc2_nand.c

473

regmap_write(nfc->regmap, FMC2_BCHICR, FMC2_BCHICR_CLEAR_IRQ);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

482

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

484

stm32_fmc2_nfc_set_ecc(nfc, false);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

487

regmap_update_bits(nfc->regmap, FMC2_PCR, FMC2_PCR_WEN,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

490

reinit_completion(&nfc->complete);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

491

stm32_fmc2_nfc_clear_bch_irq(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

492

stm32_fmc2_nfc_enable_bch_irq(nfc, mode);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

495

stm32_fmc2_nfc_set_ecc(nfc, true);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

513

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

517

ret = regmap_read_poll_timeout(nfc->regmap, FMC2_SR, sr,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

521

dev_err(nfc->dev, "ham timeout\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

525

regmap_read(nfc->regmap, FMC2_HECCR, &heccr);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

527

stm32_fmc2_nfc_set_ecc(nfc, false);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

594

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

598

if (!wait_for_completion_timeout(&nfc->complete,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

600

dev_err(nfc->dev, "bch timeout\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

601

stm32_fmc2_nfc_disable_bch_irq(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

606

regmap_read(nfc->regmap, FMC2_BCHPBR1, &bchpbr);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

612

regmap_read(nfc->regmap, FMC2_BCHPBR2, &bchpbr);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

620

regmap_read(nfc->regmap, FMC2_BCHPBR3, &bchpbr);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

626

regmap_read(nfc->regmap, FMC2_BCHPBR4, &bchpbr);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

630

stm32_fmc2_nfc_set_ecc(nfc, false);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

677

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

681

if (!wait_for_completion_timeout(&nfc->complete,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

683

dev_err(nfc->dev, "bch timeout\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

684

stm32_fmc2_nfc_disable_bch_irq(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

688

regmap_bulk_read(nfc->regmap, FMC2_BCHDSR0, ecc_sta, 5);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

690

stm32_fmc2_nfc_set_ecc(nfc, false);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

761

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

770

regmap_update_bits(nfc->regmap, FMC2_PCR, FMC2_PCR_WEN,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

833

cfg[4] = FIELD_PREP(FMC2_CSQCAR2_NANDCEN, nfc->cs_sel);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

845

regmap_bulk_write(nfc->regmap, FMC2_CSQCFGR1, cfg, 5);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

857

struct stm32_fmc2_nfc *nfc = to_stm32_nfc(chip->controller);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

860

struct dma_chan *dma_ch = nfc->dma_rx_ch;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

873

dma_ch = nfc->dma_tx_ch;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

876

for_each_sg(nfc->dma_data_sg.sgl, sg, eccsteps, s) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

881

ret = dma_map_sg(nfc->dev, nfc->dma_data_sg.sgl,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

886

desc_data = dmaengine_prep_slave_sg(dma_ch, nfc->dma_data_sg.sgl,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

894

reinit_completion(&nfc->dma_data_complete);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

895

reinit_completion(&nfc->complete);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

897

desc_data->callback_param = &nfc->dma_data_complete;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

906

for_each_sg(nfc->dma_ecc_sg.sgl, sg, eccsteps, s) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

907

sg_dma_address(sg) = nfc->dma_ecc_addr +

drivers/mtd/nand/raw/stm32_fmc2_nand.c

908

s * nfc->dma_ecc_len;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

909

sg_dma_len(sg) = nfc->dma_ecc_len;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

912

desc_ecc = dmaengine_prep_slave_sg(nfc->dma_ecc_ch,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

913

nfc->dma_ecc_sg.sgl,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

921

reinit_completion(&nfc->dma_ecc_complete);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

923

desc_ecc->callback_param = &nfc->dma_ecc_complete;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

928

dma_async_issue_pending(nfc->dma_ecc_ch);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

931

stm32_fmc2_nfc_clear_seq_irq(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

932

stm32_fmc2_nfc_enable_seq_irq(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

935

regmap_update_bits(nfc->regmap, FMC2_CSQCR,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

939

if (!wait_for_completion_timeout(&nfc->complete, timeout)) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

940

dev_err(nfc->dev, "seq timeout\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

941

stm32_fmc2_nfc_disable_seq_irq(nfc);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

944

dmaengine_terminate_all(nfc->dma_ecc_ch);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

950

if (!wait_for_completion_timeout(&nfc->dma_data_complete, timeout)) {

drivers/mtd/nand/raw/stm32_fmc2_nand.c

951

dev_err(nfc->dev, "data DMA timeout\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

958

if (!wait_for_completion_timeout(&nfc->dma_ecc_complete,

drivers/mtd/nand/raw/stm32_fmc2_nand.c

960

dev_err(nfc->dev, "ECC DMA timeout\n");

drivers/mtd/nand/raw/stm32_fmc2_nand.c

961

dmaengine_terminate_all(nfc->dma_ecc_ch);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

967

dma_unmap_sg(nfc->dev, nfc->dma_data_sg.sgl, eccsteps, dma_data_dir);

drivers/mtd/nand/raw/sunxi_nand.c

1009

memcpy_fromio(data, nfc->regs + NFC_RAM0_BASE,

drivers/mtd/nand/raw/sunxi_nand.c

1021

memcpy_fromio(data, nfc->regs + NFC_RAM0_BASE, ecc->size);

drivers/mtd/nand/raw/sunxi_nand.c

1070

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

1078

ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

1082

ret = sunxi_nfc_dma_op_prepare(nfc, buf, ecc->size, nchunks,

drivers/mtd/nand/raw/sunxi_nand.c

1088

sunxi_nfc_reset_user_data_len(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

1089

sunxi_nfc_set_user_data_len(nfc, USER_DATA_SZ, 0);

drivers/mtd/nand/raw/sunxi_nand.c

1094

NAND_CMD_READSTART, nfc->regs + NFC_REG_RCMD_SET);

drivers/mtd/nand/raw/sunxi_nand.c

1098

if (nfc->caps->has_mdma)

drivers/mtd/nand/raw/sunxi_nand.c

1101

dma_async_issue_pending(nfc->dmac);

drivers/mtd/nand/raw/sunxi_nand.c

1104

nfc->regs + NFC_REG_CMD);

drivers/mtd/nand/raw/sunxi_nand.c

1106

ret = sunxi_nfc_wait_events(nfc, wait, false, 0);

drivers/mtd/nand/raw/sunxi_nand.c

1107

if (ret && !nfc->caps->has_mdma)

drivers/mtd/nand/raw/sunxi_nand.c

1108

dmaengine_terminate_all(nfc->dmac);

drivers/mtd/nand/raw/sunxi_nand.c

1113

sunxi_nfc_dma_op_cleanup(nfc, DMA_FROM_DEVICE, &sg);

drivers/mtd/nand/raw/sunxi_nand.c

1118

status = readl(nfc->regs + NFC_REG_ECC_ST);

drivers/mtd/nand/raw/sunxi_nand.c

1119

pattern_found = readl(nfc->regs + nfc->caps->reg_pat_found);

drivers/mtd/nand/raw/sunxi_nand.c

1120

pattern_found = field_get(NFC_ECC_PAT_FOUND_MSK(nfc), pattern_found);

drivers/mtd/nand/raw/sunxi_nand.c

1154

if (status & NFC_ECC_ERR_MSK(nfc)) {

drivers/mtd/nand/raw/sunxi_nand.c

1204

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

1216

ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

1222

sunxi_nfc_reset_user_data_len(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

1223

sunxi_nfc_set_user_data_len(nfc, USER_DATA_SZ, 0);

drivers/mtd/nand/raw/sunxi_nand.c

1228

nfc->regs + NFC_REG_CMD);

drivers/mtd/nand/raw/sunxi_nand.c

1230

ret = sunxi_nfc_wait_events(nfc, NFC_CMD_INT_FLAG, false, 0);

drivers/mtd/nand/raw/sunxi_nand.c

1451

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

1459

ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

1463

ret = sunxi_nfc_dma_op_prepare(nfc, buf, ecc->size, ecc->steps,

drivers/mtd/nand/raw/sunxi_nand.c

1468

sunxi_nfc_reset_user_data_len(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

1473

sunxi_nfc_set_user_data_len(nfc, USER_DATA_SZ, i);

drivers/mtd/nand/raw/sunxi_nand.c

1483

nfc->regs + NFC_REG_WCMD_SET);

drivers/mtd/nand/raw/sunxi_nand.c

1487

if (nfc->caps->has_mdma)

drivers/mtd/nand/raw/sunxi_nand.c

1490

dma_async_issue_pending(nfc->dmac);

drivers/mtd/nand/raw/sunxi_nand.c

1494

nfc->regs + NFC_REG_CMD);

drivers/mtd/nand/raw/sunxi_nand.c

1496

ret = sunxi_nfc_wait_events(nfc, wait, false, 0);

drivers/mtd/nand/raw/sunxi_nand.c

1497

if (ret && !nfc->caps->has_mdma)

drivers/mtd/nand/raw/sunxi_nand.c

1498

dmaengine_terminate_all(nfc->dmac);

drivers/mtd/nand/raw/sunxi_nand.c

1503

sunxi_nfc_dma_op_cleanup(nfc, DMA_TO_DEVICE, &sg);

drivers/mtd/nand/raw/sunxi_nand.c

1566

struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);

drivers/mtd/nand/raw/sunxi_nand.c

1666

dev_err(nfc->dev, "unsupported tWB\n");

drivers/mtd/nand/raw/sunxi_nand.c

1672

dev_err(nfc->dev, "unsupported tADL\n");

drivers/mtd/nand/raw/sunxi_nand.c

1678

dev_err(nfc->dev, "unsupported tWHR\n");

drivers/mtd/nand/raw/sunxi_nand.c

1685

dev_err(nfc->dev, "unsupported tRHW\n");

drivers/mtd/nand/raw/sunxi_nand.c

1711

real_clk_rate = clk_round_rate(nfc->mod_clk, sunxi_nand->clk_rate);

drivers/mtd/nand/raw/sunxi_nand.c

1713

dev_err(nfc->dev, "Unable to round clk %lu\n",

drivers/mtd/nand/raw/sunxi_nand.c

1795

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

1796

const u8 *strengths = nfc->caps->ecc_strengths;

drivers/mtd/nand/raw/sunxi_nand.c

181

#define NFC_RANDOM_EN(nfc) (nfc->caps->random_en_mask)

drivers/mtd/nand/raw/sunxi_nand.c

182

#define NFC_RANDOM_DIRECTION(nfc) (nfc->caps->random_dir_mask)

drivers/mtd/nand/raw/sunxi_nand.c

1820

for (i = 0; i < nfc->caps->nstrengths; i++) {

drivers/mtd/nand/raw/sunxi_nand.c

183

#define NFC_ECC_MODE_MSK(nfc) (nfc->caps->ecc_mode_mask)

drivers/mtd/nand/raw/sunxi_nand.c

184

#define NFC_ECC_MODE(nfc, x) field_prep(NFC_ECC_MODE_MSK(nfc), (x))

drivers/mtd/nand/raw/sunxi_nand.c

1841

for (i = 0; i < nfc->caps->nstrengths; i++) {

drivers/mtd/nand/raw/sunxi_nand.c

1852

if (i >= nfc->caps->nstrengths) {

drivers/mtd/nand/raw/sunxi_nand.c

1853

dev_err(nfc->dev, "unsupported strength\n");

drivers/mtd/nand/raw/sunxi_nand.c

1872

if (nfc->dmac || nfc->caps->has_mdma) {

drivers/mtd/nand/raw/sunxi_nand.c

1888

sunxi_nand->ecc.ecc_ctl = NFC_ECC_MODE(nfc, i) | NFC_ECC_EXCEPTION |

drivers/mtd/nand/raw/sunxi_nand.c

1892

if (nfc->caps->has_ecc_block_512) {

drivers/mtd/nand/raw/sunxi_nand.c

1895

dev_err(nfc->dev, "512B ECC block not supported\n");

drivers/mtd/nand/raw/sunxi_nand.c

193

#define NFC_ECC_ERR_MSK(nfc) (nfc->caps->ecc_err_mask)

drivers/mtd/nand/raw/sunxi_nand.c

1946

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

1987

cnt = min_t(u32, remaining, nfc->caps->sram_size);

drivers/mtd/nand/raw/sunxi_nand.c

199

#define NFC_ECC_PAT_FOUND_MSK(nfc) (nfc->caps->pat_found_mask)

drivers/mtd/nand/raw/sunxi_nand.c

1992

memcpy_toio(nfc->regs + NFC_RAM0_BASE,

drivers/mtd/nand/raw/sunxi_nand.c

2007

ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

2012

writel(addrs[0], nfc->regs + NFC_REG_ADDR_LOW);

drivers/mtd/nand/raw/sunxi_nand.c

2013

writel(addrs[1], nfc->regs + NFC_REG_ADDR_HIGH);

drivers/mtd/nand/raw/sunxi_nand.c

2018

nfc->regs +

drivers/mtd/nand/raw/sunxi_nand.c

2023

writel(cnt, nfc->regs + NFC_REG_CNT);

drivers/mtd/nand/raw/sunxi_nand.c

2025

writel(cmd, nfc->regs + NFC_REG_CMD);

drivers/mtd/nand/raw/sunxi_nand.c

2027

ret = sunxi_nfc_wait_events(nfc, NFC_CMD_INT_FLAG,

drivers/mtd/nand/raw/sunxi_nand.c

2034

memcpy_fromio(inbuf, nfc->regs + NFC_RAM0_BASE, cnt);

drivers/mtd/nand/raw/sunxi_nand.c

2099

static void sunxi_nand_chips_cleanup(struct sunxi_nfc *nfc)

drivers/mtd/nand/raw/sunxi_nand.c

2105

while (!list_empty(&nfc->chips)) {

drivers/mtd/nand/raw/sunxi_nand.c

2106

sunxi_nand = list_first_entry(&nfc->chips,

drivers/mtd/nand/raw/sunxi_nand.c

2117

static int sunxi_nand_chip_init(struct device *dev, struct sunxi_nfc *nfc,

drivers/mtd/nand/raw/sunxi_nand.c

2159

if (test_and_set_bit(tmp, &nfc->assigned_cs)) {

drivers/mtd/nand/raw/sunxi_nand.c

2175

nand->controller = &nfc->controller;

drivers/mtd/nand/raw/sunxi_nand.c

2199

list_add_tail(&sunxi_nand->node, &nfc->chips);

drivers/mtd/nand/raw/sunxi_nand.c

2204

static int sunxi_nand_chips_init(struct device *dev, struct sunxi_nfc *nfc)

drivers/mtd/nand/raw/sunxi_nand.c

2210

ret = sunxi_nand_chip_init(dev, nfc, nand_np);

drivers/mtd/nand/raw/sunxi_nand.c

2212

sunxi_nand_chips_cleanup(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

2220

static int sunxi_nfc_dma_init(struct sunxi_nfc *nfc, struct resource *r)

drivers/mtd/nand/raw/sunxi_nand.c

2224

if (nfc->caps->has_mdma)

drivers/mtd/nand/raw/sunxi_nand.c

2227

nfc->dmac = dma_request_chan(nfc->dev, "rxtx");

drivers/mtd/nand/raw/sunxi_nand.c

2228

if (IS_ERR(nfc->dmac)) {

drivers/mtd/nand/raw/sunxi_nand.c

2229

ret = PTR_ERR(nfc->dmac);

drivers/mtd/nand/raw/sunxi_nand.c

2234

dev_warn(nfc->dev, "failed to request rxtx DMA channel: %d\n", ret);

drivers/mtd/nand/raw/sunxi_nand.c

2235

nfc->dmac = NULL;

drivers/mtd/nand/raw/sunxi_nand.c

2239

dmac_cfg.src_addr = r->start + nfc->caps->reg_io_data;

drivers/mtd/nand/raw/sunxi_nand.c

2243

dmac_cfg.src_maxburst = nfc->caps->dma_maxburst;

drivers/mtd/nand/raw/sunxi_nand.c

2244

dmac_cfg.dst_maxburst = nfc->caps->dma_maxburst;

drivers/mtd/nand/raw/sunxi_nand.c

2245

dmaengine_slave_config(nfc->dmac, &dmac_cfg);

drivers/mtd/nand/raw/sunxi_nand.c

2254

struct sunxi_nfc *nfc;

drivers/mtd/nand/raw/sunxi_nand.c

2258

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

drivers/mtd/nand/raw/sunxi_nand.c

2259

if (!nfc)

drivers/mtd/nand/raw/sunxi_nand.c

2262

nfc->dev = dev;

drivers/mtd/nand/raw/sunxi_nand.c

2263

nand_controller_init(&nfc->controller);

drivers/mtd/nand/raw/sunxi_nand.c

2264

INIT_LIST_HEAD(&nfc->chips);

drivers/mtd/nand/raw/sunxi_nand.c

2266

nfc->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &r);

drivers/mtd/nand/raw/sunxi_nand.c

2267

if (IS_ERR(nfc->regs))

drivers/mtd/nand/raw/sunxi_nand.c

2268

return PTR_ERR(nfc->regs);

drivers/mtd/nand/raw/sunxi_nand.c

2274

nfc->caps = of_device_get_match_data(dev);

drivers/mtd/nand/raw/sunxi_nand.c

2275

if (!nfc->caps)

drivers/mtd/nand/raw/sunxi_nand.c

2278

nfc->ahb_clk = devm_clk_get_enabled(dev, "ahb");

drivers/mtd/nand/raw/sunxi_nand.c

2279

if (IS_ERR(nfc->ahb_clk)) {

drivers/mtd/nand/raw/sunxi_nand.c

2281

return PTR_ERR(nfc->ahb_clk);

drivers/mtd/nand/raw/sunxi_nand.c

2284

nfc->mod_clk = devm_clk_get_enabled(dev, "mod");

drivers/mtd/nand/raw/sunxi_nand.c

2285

if (IS_ERR(nfc->mod_clk)) {

drivers/mtd/nand/raw/sunxi_nand.c

2287

return PTR_ERR(nfc->mod_clk);

drivers/mtd/nand/raw/sunxi_nand.c

2290

if (nfc->caps->has_ecc_clk) {

drivers/mtd/nand/raw/sunxi_nand.c

2291

nfc->ecc_clk = devm_clk_get_enabled(dev, "ecc");

drivers/mtd/nand/raw/sunxi_nand.c

2292

if (IS_ERR(nfc->ecc_clk)) {

drivers/mtd/nand/raw/sunxi_nand.c

2294

return PTR_ERR(nfc->ecc_clk);

drivers/mtd/nand/raw/sunxi_nand.c

2298

if (nfc->caps->has_mbus_clk) {

drivers/mtd/nand/raw/sunxi_nand.c

2299

nfc->mbus_clk = devm_clk_get_enabled(dev, "mbus");

drivers/mtd/nand/raw/sunxi_nand.c

2300

if (IS_ERR(nfc->mbus_clk)) {

drivers/mtd/nand/raw/sunxi_nand.c

2302

return PTR_ERR(nfc->mbus_clk);

drivers/mtd/nand/raw/sunxi_nand.c

2306

nfc->reset = devm_reset_control_get_optional_exclusive(dev, "ahb");

drivers/mtd/nand/raw/sunxi_nand.c

2307

if (IS_ERR(nfc->reset))

drivers/mtd/nand/raw/sunxi_nand.c

2308

return PTR_ERR(nfc->reset);

drivers/mtd/nand/raw/sunxi_nand.c

2310

ret = reset_control_deassert(nfc->reset);

drivers/mtd/nand/raw/sunxi_nand.c

2316

ret = sunxi_nfc_rst(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

2320

writel(0, nfc->regs + NFC_REG_INT);

drivers/mtd/nand/raw/sunxi_nand.c

2322

0, "sunxi-nand", nfc);

drivers/mtd/nand/raw/sunxi_nand.c

2326

ret = sunxi_nfc_dma_init(nfc, r);

drivers/mtd/nand/raw/sunxi_nand.c

2331

platform_set_drvdata(pdev, nfc);

drivers/mtd/nand/raw/sunxi_nand.c

2333

ret = sunxi_nand_chips_init(dev, nfc);

drivers/mtd/nand/raw/sunxi_nand.c

2342

if (nfc->dmac)

drivers/mtd/nand/raw/sunxi_nand.c

2343

dma_release_channel(nfc->dmac);

drivers/mtd/nand/raw/sunxi_nand.c

2345

reset_control_assert(nfc->reset);

drivers/mtd/nand/raw/sunxi_nand.c

2352

struct sunxi_nfc *nfc = platform_get_drvdata(pdev);

drivers/mtd/nand/raw/sunxi_nand.c

2354

sunxi_nand_chips_cleanup(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

2356

reset_control_assert(nfc->reset);

drivers/mtd/nand/raw/sunxi_nand.c

2358

if (nfc->dmac)

drivers/mtd/nand/raw/sunxi_nand.c

2359

dma_release_channel(nfc->dmac);

drivers/mtd/nand/raw/sunxi_nand.c

371

struct sunxi_nfc *nfc = dev_id;

drivers/mtd/nand/raw/sunxi_nand.c

372

u32 st = readl(nfc->regs + NFC_REG_ST);

drivers/mtd/nand/raw/sunxi_nand.c

373

u32 ien = readl(nfc->regs + NFC_REG_INT);

drivers/mtd/nand/raw/sunxi_nand.c

379

complete(&nfc->complete);

drivers/mtd/nand/raw/sunxi_nand.c

381

writel(st & NFC_INT_MASK, nfc->regs + NFC_REG_ST);

drivers/mtd/nand/raw/sunxi_nand.c

382

writel(~st & ien & NFC_INT_MASK, nfc->regs + NFC_REG_INT);

drivers/mtd/nand/raw/sunxi_nand.c

387

static int sunxi_nfc_wait_events(struct sunxi_nfc *nfc, u32 events,

drivers/mtd/nand/raw/sunxi_nand.c

399

init_completion(&nfc->complete);

drivers/mtd/nand/raw/sunxi_nand.c

401

writel(events, nfc->regs + NFC_REG_INT);

drivers/mtd/nand/raw/sunxi_nand.c

403

ret = wait_for_completion_timeout(&nfc->complete,

drivers/mtd/nand/raw/sunxi_nand.c

410

writel(0, nfc->regs + NFC_REG_INT);

drivers/mtd/nand/raw/sunxi_nand.c

414

ret = readl_poll_timeout(nfc->regs + NFC_REG_ST, status,

drivers/mtd/nand/raw/sunxi_nand.c

419

writel(events & NFC_INT_MASK, nfc->regs + NFC_REG_ST);

drivers/mtd/nand/raw/sunxi_nand.c

422

dev_err(nfc->dev, "wait interrupt timedout\n");

drivers/mtd/nand/raw/sunxi_nand.c

427

static int sunxi_nfc_wait_cmd_fifo_empty(struct sunxi_nfc *nfc)

drivers/mtd/nand/raw/sunxi_nand.c

432

ret = readl_poll_timeout(nfc->regs + NFC_REG_ST, status,

drivers/mtd/nand/raw/sunxi_nand.c

436

dev_err(nfc->dev, "wait for empty cmd FIFO timedout\n");

drivers/mtd/nand/raw/sunxi_nand.c

441

static int sunxi_nfc_rst(struct sunxi_nfc *nfc)

drivers/mtd/nand/raw/sunxi_nand.c

446

writel(0, nfc->regs + NFC_REG_ECC_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

447

writel(NFC_RESET, nfc->regs + NFC_REG_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

449

ret = readl_poll_timeout(nfc->regs + NFC_REG_CTL, ctl,

drivers/mtd/nand/raw/sunxi_nand.c

453

dev_err(nfc->dev, "wait for NAND controller reset timedout\n");

drivers/mtd/nand/raw/sunxi_nand.c

458

static int sunxi_nfc_dma_op_prepare(struct sunxi_nfc *nfc, const void *buf,

drivers/mtd/nand/raw/sunxi_nand.c

474

ret = dma_map_sg(nfc->dev, sg, 1, ddir);

drivers/mtd/nand/raw/sunxi_nand.c

478

if (!nfc->caps->has_mdma) {

drivers/mtd/nand/raw/sunxi_nand.c

479

dmad = dmaengine_prep_slave_sg(nfc->dmac, sg, 1, tdir, DMA_CTRL_ACK);

drivers/mtd/nand/raw/sunxi_nand.c

486

writel(readl(nfc->regs + NFC_REG_CTL) | NFC_RAM_METHOD,

drivers/mtd/nand/raw/sunxi_nand.c

487

nfc->regs + NFC_REG_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

488

writel(nchunks, nfc->regs + NFC_REG_SECTOR_NUM);

drivers/mtd/nand/raw/sunxi_nand.c

489

writel(chunksize, nfc->regs + NFC_REG_CNT);

drivers/mtd/nand/raw/sunxi_nand.c

491

if (nfc->caps->has_mdma) {

drivers/mtd/nand/raw/sunxi_nand.c

492

writel(readl(nfc->regs + NFC_REG_CTL) & ~NFC_DMA_TYPE_NORMAL,

drivers/mtd/nand/raw/sunxi_nand.c

493

nfc->regs + NFC_REG_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

494

writel(chunksize * nchunks, nfc->regs + NFC_REG_MDMA_CNT);

drivers/mtd/nand/raw/sunxi_nand.c

495

writel(sg_dma_address(sg), nfc->regs + NFC_REG_MDMA_ADDR);

drivers/mtd/nand/raw/sunxi_nand.c

507

writel(readl(nfc->regs + NFC_REG_CTL) & ~NFC_RAM_METHOD,

drivers/mtd/nand/raw/sunxi_nand.c

508

nfc->regs + NFC_REG_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

51

#define NFC_REG_ECC_ERR_CNT(nfc, x) ((nfc->caps->reg_ecc_err_cnt + (x)) & ~0x3)

drivers/mtd/nand/raw/sunxi_nand.c

511

dma_unmap_sg(nfc->dev, sg, 1, ddir);

drivers/mtd/nand/raw/sunxi_nand.c

515

static void sunxi_nfc_dma_op_cleanup(struct sunxi_nfc *nfc,

drivers/mtd/nand/raw/sunxi_nand.c

519

dma_unmap_sg(nfc->dev, sg, 1, ddir);

drivers/mtd/nand/raw/sunxi_nand.c

520

writel(readl(nfc->regs + NFC_REG_CTL) & ~NFC_RAM_METHOD,

drivers/mtd/nand/raw/sunxi_nand.c

521

nfc->regs + NFC_REG_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

528

struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);

drivers/mtd/nand/raw/sunxi_nand.c

535

ctl = readl(nfc->regs + NFC_REG_CTL) &

drivers/mtd/nand/raw/sunxi_nand.c

543

writel(mtd->writesize, nfc->regs + NFC_REG_SPARE_AREA(nfc));

drivers/mtd/nand/raw/sunxi_nand.c

545

if (nfc->clk_rate != sunxi_nand->clk_rate) {

drivers/mtd/nand/raw/sunxi_nand.c

546

clk_set_rate(nfc->mod_clk, sunxi_nand->clk_rate);

drivers/mtd/nand/raw/sunxi_nand.c

547

nfc->clk_rate = sunxi_nand->clk_rate;

drivers/mtd/nand/raw/sunxi_nand.c

550

writel(sunxi_nand->timing_ctl, nfc->regs + NFC_REG_TIMING_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

551

writel(sunxi_nand->timing_cfg, nfc->regs + NFC_REG_TIMING_CFG);

drivers/mtd/nand/raw/sunxi_nand.c

552

writel(ctl, nfc->regs + NFC_REG_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

558

struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);

drivers/mtd/nand/raw/sunxi_nand.c

567

cnt = min(len - offs, nfc->caps->sram_size);

drivers/mtd/nand/raw/sunxi_nand.c

569

ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

57

#define NFC_REG_USER_DATA(nfc, x) (nfc->caps->reg_user_data + ((x) * 4))

drivers/mtd/nand/raw/sunxi_nand.c

573

writel(cnt, nfc->regs + NFC_REG_CNT);

drivers/mtd/nand/raw/sunxi_nand.c

575

writel(tmp, nfc->regs + NFC_REG_CMD);

drivers/mtd/nand/raw/sunxi_nand.c

581

ret = sunxi_nfc_wait_events(nfc, NFC_CMD_INT_FLAG, poll, 0);

drivers/mtd/nand/raw/sunxi_nand.c

586

memcpy_fromio(buf + offs, nfc->regs + NFC_RAM0_BASE,

drivers/mtd/nand/raw/sunxi_nand.c

596

struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);

drivers/mtd/nand/raw/sunxi_nand.c

605

cnt = min(len - offs, nfc->caps->sram_size);

drivers/mtd/nand/raw/sunxi_nand.c

607

ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

61

#define NFC_REG_USER_DATA_LEN(nfc, step) \

drivers/mtd/nand/raw/sunxi_nand.c

611

writel(cnt, nfc->regs + NFC_REG_CNT);

drivers/mtd/nand/raw/sunxi_nand.c

612

memcpy_toio(nfc->regs + NFC_RAM0_BASE, buf + offs, cnt);

drivers/mtd/nand/raw/sunxi_nand.c

615

writel(tmp, nfc->regs + NFC_REG_CMD);

drivers/mtd/nand/raw/sunxi_nand.c

62

(nfc->caps->reg_user_data_len + \

drivers/mtd/nand/raw/sunxi_nand.c

621

ret = sunxi_nfc_wait_events(nfc, NFC_CMD_INT_FLAG, poll, 0);

drivers/mtd/nand/raw/sunxi_nand.c

64

#define NFC_REG_SPARE_AREA(nfc) (nfc->caps->reg_spare_area)

drivers/mtd/nand/raw/sunxi_nand.c

66

#define NFC_REG_PAT_ID(nfc) (nfc->caps->reg_pat_id)

drivers/mtd/nand/raw/sunxi_nand.c

734

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

742

ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL) & ~NFC_RANDOM_SEED_MSK;

drivers/mtd/nand/raw/sunxi_nand.c

743

writel(ecc_ctl | NFC_RANDOM_SEED(state), nfc->regs + NFC_REG_ECC_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

748

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

753

writel(readl(nfc->regs + NFC_REG_ECC_CTL) | NFC_RANDOM_EN(nfc),

drivers/mtd/nand/raw/sunxi_nand.c

754

nfc->regs + NFC_REG_ECC_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

759

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

764

writel(readl(nfc->regs + NFC_REG_ECC_CTL) & ~NFC_RANDOM_EN(nfc),

drivers/mtd/nand/raw/sunxi_nand.c

765

nfc->regs + NFC_REG_ECC_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

798

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

800

writel(sunxi_nand->ecc.ecc_ctl, nfc->regs + NFC_REG_ECC_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

805

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

807

writel(0, nfc->regs + NFC_REG_ECC_CTL);

drivers/mtd/nand/raw/sunxi_nand.c

826

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

828

sunxi_nfc_user_data_to_buf(readl(nfc->regs + NFC_REG_USER_DATA(nfc, step)), oob);

drivers/mtd/nand/raw/sunxi_nand.c

839

static void sunxi_nfc_reset_user_data_len(struct sunxi_nfc *nfc)

drivers/mtd/nand/raw/sunxi_nand.c

844

if (!nfc->caps->reg_user_data_len)

drivers/mtd/nand/raw/sunxi_nand.c

847

for (int i = 0; i < nfc->caps->max_ecc_steps; i += loop_step)

drivers/mtd/nand/raw/sunxi_nand.c

848

writel(0, nfc->regs + NFC_REG_USER_DATA_LEN(nfc, i));

drivers/mtd/nand/raw/sunxi_nand.c

851

static void sunxi_nfc_set_user_data_len(struct sunxi_nfc *nfc,

drivers/mtd/nand/raw/sunxi_nand.c

859

if (!nfc->caps->reg_user_data_len)

drivers/mtd/nand/raw/sunxi_nand.c

862

for (i = 0; i < nfc->caps->nuser_data_tab; i++) {

drivers/mtd/nand/raw/sunxi_nand.c

863

if (len == nfc->caps->user_data_len_tab[i]) {

drivers/mtd/nand/raw/sunxi_nand.c

870

dev_warn(nfc->dev,

drivers/mtd/nand/raw/sunxi_nand.c

875

val = readl(nfc->regs + NFC_REG_USER_DATA_LEN(nfc, step));

drivers/mtd/nand/raw/sunxi_nand.c

879

writel(val, nfc->regs + NFC_REG_USER_DATA_LEN(nfc, step));

drivers/mtd/nand/raw/sunxi_nand.c

886

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

897

nfc->regs + NFC_REG_USER_DATA(nfc, step));

drivers/mtd/nand/raw/sunxi_nand.c

917

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

929

if (unlikely(!(readl(nfc->regs + NFC_REG_PAT_ID(nfc)) & 0x1))) {

drivers/mtd/nand/raw/sunxi_nand.c

945

tmp = readl(nfc->regs + NFC_REG_ECC_ERR_CNT(nfc, step));

drivers/mtd/nand/raw/sunxi_nand.c

957

struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);

drivers/mtd/nand/raw/sunxi_nand.c

972

ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

976

sunxi_nfc_reset_user_data_len(nfc);

drivers/mtd/nand/raw/sunxi_nand.c

977

sunxi_nfc_set_user_data_len(nfc, USER_DATA_SZ, 0);

drivers/mtd/nand/raw/sunxi_nand.c

981

nfc->regs + NFC_REG_CMD);

drivers/mtd/nand/raw/sunxi_nand.c

983

ret = sunxi_nfc_wait_events(nfc, NFC_CMD_INT_FLAG, false, 0);

drivers/mtd/nand/raw/sunxi_nand.c

990

pattern_found = readl(nfc->regs + nfc->caps->reg_pat_found);

drivers/mtd/nand/raw/sunxi_nand.c

991

pattern_found = field_get(NFC_ECC_PAT_FOUND_MSK(nfc), pattern_found);

drivers/mtd/nand/raw/sunxi_nand.c

994

readl(nfc->regs + NFC_REG_ECC_ST),

drivers/mtd/nand/raw/vf610_nfc.c

174

static inline u32 vf610_nfc_read(struct vf610_nfc *nfc, uint reg)

drivers/mtd/nand/raw/vf610_nfc.c

176

return readl(nfc->regs + reg);

drivers/mtd/nand/raw/vf610_nfc.c

179

static inline void vf610_nfc_write(struct vf610_nfc *nfc, uint reg, u32 val)

drivers/mtd/nand/raw/vf610_nfc.c

181

writel(val, nfc->regs + reg);

drivers/mtd/nand/raw/vf610_nfc.c

184

static inline void vf610_nfc_set(struct vf610_nfc *nfc, uint reg, u32 bits)

drivers/mtd/nand/raw/vf610_nfc.c

186

vf610_nfc_write(nfc, reg, vf610_nfc_read(nfc, reg) | bits);

drivers/mtd/nand/raw/vf610_nfc.c

189

static inline void vf610_nfc_clear(struct vf610_nfc *nfc, uint reg, u32 bits)

drivers/mtd/nand/raw/vf610_nfc.c

191

vf610_nfc_write(nfc, reg, vf610_nfc_read(nfc, reg) & ~bits);

drivers/mtd/nand/raw/vf610_nfc.c

194

static inline void vf610_nfc_set_field(struct vf610_nfc *nfc, u32 reg,

drivers/mtd/nand/raw/vf610_nfc.c

197

vf610_nfc_write(nfc, reg,

drivers/mtd/nand/raw/vf610_nfc.c

198

(vf610_nfc_read(nfc, reg) & (~mask)) | val << shift);

drivers/mtd/nand/raw/vf610_nfc.c

282

static inline void vf610_nfc_clear_status(struct vf610_nfc *nfc)

drivers/mtd/nand/raw/vf610_nfc.c

284

u32 tmp = vf610_nfc_read(nfc, NFC_IRQ_STATUS);

drivers/mtd/nand/raw/vf610_nfc.c

287

vf610_nfc_write(nfc, NFC_IRQ_STATUS, tmp);

drivers/mtd/nand/raw/vf610_nfc.c

290

static void vf610_nfc_done(struct vf610_nfc *nfc)

drivers/mtd/nand/raw/vf610_nfc.c

301

vf610_nfc_set(nfc, NFC_IRQ_STATUS, IDLE_EN_BIT);

drivers/mtd/nand/raw/vf610_nfc.c

302

vf610_nfc_set(nfc, NFC_FLASH_CMD2, START_BIT);

drivers/mtd/nand/raw/vf610_nfc.c

304

if (!wait_for_completion_timeout(&nfc->cmd_done, timeout))

drivers/mtd/nand/raw/vf610_nfc.c

305

dev_warn(nfc->dev, "Timeout while waiting for BUSY.\n");

drivers/mtd/nand/raw/vf610_nfc.c

307

vf610_nfc_clear_status(nfc);

drivers/mtd/nand/raw/vf610_nfc.c

312

struct vf610_nfc *nfc = data;

drivers/mtd/nand/raw/vf610_nfc.c

314

vf610_nfc_clear(nfc, NFC_IRQ_STATUS, IDLE_EN_BIT);

drivers/mtd/nand/raw/vf610_nfc.c

315

complete(&nfc->cmd_done);

drivers/mtd/nand/raw/vf610_nfc.c

320

static inline void vf610_nfc_ecc_mode(struct vf610_nfc *nfc, int ecc_mode)

drivers/mtd/nand/raw/vf610_nfc.c

322

vf610_nfc_set_field(nfc, NFC_FLASH_CONFIG,

drivers/mtd/nand/raw/vf610_nfc.c

327

static inline void vf610_nfc_run(struct vf610_nfc *nfc, u32 col, u32 row,

drivers/mtd/nand/raw/vf610_nfc.c

330

vf610_nfc_set_field(nfc, NFC_COL_ADDR, COL_ADDR_MASK,

drivers/mtd/nand/raw/vf610_nfc.c

333

vf610_nfc_set_field(nfc, NFC_ROW_ADDR, ROW_ADDR_MASK,

drivers/mtd/nand/raw/vf610_nfc.c

336

vf610_nfc_write(nfc, NFC_SECTOR_SIZE, trfr_sz);

drivers/mtd/nand/raw/vf610_nfc.c

337

vf610_nfc_write(nfc, NFC_FLASH_CMD1, cmd1);

drivers/mtd/nand/raw/vf610_nfc.c

338

vf610_nfc_write(nfc, NFC_FLASH_CMD2, cmd2);

drivers/mtd/nand/raw/vf610_nfc.c

340

dev_dbg(nfc->dev,

drivers/mtd/nand/raw/vf610_nfc.c

344

vf610_nfc_done(nfc);

drivers/mtd/nand/raw/vf610_nfc.c

362

struct vf610_nfc *nfc = chip_to_nfc(chip);

drivers/mtd/nand/raw/vf610_nfc.c

410

vf610_nfc_wr_to_sram(nfc->regs + NFC_MAIN_AREA(0) + offset,

drivers/mtd/nand/raw/vf610_nfc.c

412

trfr_sz, !nfc->data_access);

drivers/mtd/nand/raw/vf610_nfc.c

440

vf610_nfc_clear(nfc, NFC_FLASH_CONFIG, CONFIG_16BIT);

drivers/mtd/nand/raw/vf610_nfc.c

444

vf610_nfc_run(nfc, col, row, cmd1, cmd2, trfr_sz);

drivers/mtd/nand/raw/vf610_nfc.c

452

nfc->regs + NFC_MAIN_AREA(0) + offset,

drivers/mtd/nand/raw/vf610_nfc.c

453

trfr_sz, !nfc->data_access);

drivers/mtd/nand/raw/vf610_nfc.c

457

vf610_nfc_set(nfc, NFC_FLASH_CONFIG, CONFIG_16BIT);

drivers/mtd/nand/raw/vf610_nfc.c

482

struct vf610_nfc *nfc = chip_to_nfc(chip);

drivers/mtd/nand/raw/vf610_nfc.c

486

if (nfc->variant != NFC_VFC610)

drivers/mtd/nand/raw/vf610_nfc.c

489

tmp = vf610_nfc_read(nfc, NFC_ROW_ADDR);

drivers/mtd/nand/raw/vf610_nfc.c

494

vf610_nfc_write(nfc, NFC_ROW_ADDR, tmp);

drivers/mtd/nand/raw/vf610_nfc.c

511

struct vf610_nfc *nfc = chip_to_nfc(chip);

drivers/mtd/nand/raw/vf610_nfc.c

516

int flips_threshold = nfc->chip.ecc.strength / 2;

drivers/mtd/nand/raw/vf610_nfc.c

518

ecc_status = vf610_nfc_read(nfc, ecc_status_off) & 0xff;

drivers/mtd/nand/raw/vf610_nfc.c

524

nfc->data_access = true;

drivers/mtd/nand/raw/vf610_nfc.c

525

nand_read_oob_op(&nfc->chip, page, 0, oob, mtd->oobsize);

drivers/mtd/nand/raw/vf610_nfc.c

526

nfc->data_access = false;

drivers/mtd/nand/raw/vf610_nfc.c

532

return nand_check_erased_ecc_chunk(dat, nfc->chip.ecc.size, oob,

drivers/mtd/nand/raw/vf610_nfc.c

552

struct vf610_nfc *nfc = chip_to_nfc(chip);

drivers/mtd/nand/raw/vf610_nfc.c

570

vf610_nfc_ecc_mode(nfc, nfc->ecc_mode);

drivers/mtd/nand/raw/vf610_nfc.c

571

vf610_nfc_run(nfc, 0, row, cmd1, cmd2, trfr_sz);

drivers/mtd/nand/raw/vf610_nfc.c

572

vf610_nfc_ecc_mode(nfc, ECC_BYPASS);

drivers/mtd/nand/raw/vf610_nfc.c

578

vf610_nfc_rd_from_sram(buf, nfc->regs + NFC_MAIN_AREA(0),

drivers/mtd/nand/raw/vf610_nfc.c

582

nfc->regs + NFC_MAIN_AREA(0) +

drivers/mtd/nand/raw/vf610_nfc.c

600

struct vf610_nfc *nfc = chip_to_nfc(chip);

drivers/mtd/nand/raw/vf610_nfc.c

621

vf610_nfc_wr_to_sram(nfc->regs + NFC_MAIN_AREA(0), buf,

drivers/mtd/nand/raw/vf610_nfc.c

627

vf610_nfc_ecc_mode(nfc, nfc->ecc_mode);

drivers/mtd/nand/raw/vf610_nfc.c

628

vf610_nfc_run(nfc, 0, row, cmd1, cmd2, trfr_sz);

drivers/mtd/nand/raw/vf610_nfc.c

629

vf610_nfc_ecc_mode(nfc, ECC_BYPASS);

drivers/mtd/nand/raw/vf610_nfc.c

644

struct vf610_nfc *nfc = chip_to_nfc(chip);

drivers/mtd/nand/raw/vf610_nfc.c

647

nfc->data_access = true;

drivers/mtd/nand/raw/vf610_nfc.c

649

nfc->data_access = false;

drivers/mtd/nand/raw/vf610_nfc.c

657

struct vf610_nfc *nfc = chip_to_nfc(chip);

drivers/mtd/nand/raw/vf610_nfc.c

661

nfc->data_access = true;

drivers/mtd/nand/raw/vf610_nfc.c

666

nfc->data_access = false;

drivers/mtd/nand/raw/vf610_nfc.c

676

struct vf610_nfc *nfc = chip_to_nfc(chip);

drivers/mtd/nand/raw/vf610_nfc.c

679

nfc->data_access = true;

drivers/mtd/nand/raw/vf610_nfc.c

681

nfc->data_access = false;

drivers/mtd/nand/raw/vf610_nfc.c

689

struct vf610_nfc *nfc = chip_to_nfc(chip);

drivers/mtd/nand/raw/vf610_nfc.c

692

nfc->data_access = true;

drivers/mtd/nand/raw/vf610_nfc.c

695

nfc->data_access = false;

drivers/mtd/nand/raw/vf610_nfc.c

709

static void vf610_nfc_preinit_controller(struct vf610_nfc *nfc)

drivers/mtd/nand/raw/vf610_nfc.c

711

vf610_nfc_clear(nfc, NFC_FLASH_CONFIG, CONFIG_16BIT);

drivers/mtd/nand/raw/vf610_nfc.c

712

vf610_nfc_clear(nfc, NFC_FLASH_CONFIG, CONFIG_ADDR_AUTO_INCR_BIT);

drivers/mtd/nand/raw/vf610_nfc.c

713

vf610_nfc_clear(nfc, NFC_FLASH_CONFIG, CONFIG_BUFNO_AUTO_INCR_BIT);

drivers/mtd/nand/raw/vf610_nfc.c

714

vf610_nfc_clear(nfc, NFC_FLASH_CONFIG, CONFIG_BOOT_MODE_BIT);

drivers/mtd/nand/raw/vf610_nfc.c

715

vf610_nfc_clear(nfc, NFC_FLASH_CONFIG, CONFIG_DMA_REQ_BIT);

drivers/mtd/nand/raw/vf610_nfc.c

716

vf610_nfc_set(nfc, NFC_FLASH_CONFIG, CONFIG_FAST_FLASH_BIT);

drivers/mtd/nand/raw/vf610_nfc.c

717

vf610_nfc_ecc_mode(nfc, ECC_BYPASS);

drivers/mtd/nand/raw/vf610_nfc.c

720

vf610_nfc_set_field(nfc, NFC_FLASH_CONFIG, CONFIG_PAGE_CNT_MASK,

drivers/mtd/nand/raw/vf610_nfc.c

724

static void vf610_nfc_init_controller(struct vf610_nfc *nfc)

drivers/mtd/nand/raw/vf610_nfc.c

726

if (nfc->chip.options & NAND_BUSWIDTH_16)

drivers/mtd/nand/raw/vf610_nfc.c

727

vf610_nfc_set(nfc, NFC_FLASH_CONFIG, CONFIG_16BIT);

drivers/mtd/nand/raw/vf610_nfc.c

729

vf610_nfc_clear(nfc, NFC_FLASH_CONFIG, CONFIG_16BIT);

drivers/mtd/nand/raw/vf610_nfc.c

731

if (nfc->chip.ecc.engine_type == NAND_ECC_ENGINE_TYPE_ON_HOST) {

drivers/mtd/nand/raw/vf610_nfc.c

733

vf610_nfc_set_field(nfc, NFC_FLASH_CONFIG,

drivers/mtd/nand/raw/vf610_nfc.c

739

vf610_nfc_set(nfc, NFC_FLASH_CONFIG, CONFIG_ECC_SRAM_REQ_BIT);

drivers/mtd/nand/raw/vf610_nfc.c

746

struct vf610_nfc *nfc = chip_to_nfc(chip);

drivers/mtd/nand/raw/vf610_nfc.c

748

vf610_nfc_init_controller(nfc);

drivers/mtd/nand/raw/vf610_nfc.c

756

dev_err(nfc->dev, "Unsupported flash page size\n");

drivers/mtd/nand/raw/vf610_nfc.c

764

dev_err(nfc->dev, "Unsupported flash with hwecc\n");

drivers/mtd/nand/raw/vf610_nfc.c

769

dev_err(nfc->dev, "Step size needs to be page size\n");

drivers/mtd/nand/raw/vf610_nfc.c

780

nfc->ecc_mode = ECC_60_BYTE;

drivers/mtd/nand/raw/vf610_nfc.c

783

nfc->ecc_mode = ECC_45_BYTE;

drivers/mtd/nand/raw/vf610_nfc.c

786

dev_err(nfc->dev, "Unsupported ECC strength\n");

drivers/mtd/nand/raw/vf610_nfc.c

810

struct vf610_nfc *nfc;

drivers/mtd/nand/raw/vf610_nfc.c

816

nfc = devm_kzalloc(&pdev->dev, sizeof(*nfc), GFP_KERNEL);

drivers/mtd/nand/raw/vf610_nfc.c

817

if (!nfc)

drivers/mtd/nand/raw/vf610_nfc.c

820

nfc->dev = &pdev->dev;

drivers/mtd/nand/raw/vf610_nfc.c

821

chip = &nfc->chip;

drivers/mtd/nand/raw/vf610_nfc.c

825

mtd->dev.parent = nfc->dev;

drivers/mtd/nand/raw/vf610_nfc.c

832

nfc->regs = devm_platform_ioremap_resource(pdev, 0);

drivers/mtd/nand/raw/vf610_nfc.c

833

if (IS_ERR(nfc->regs))

drivers/mtd/nand/raw/vf610_nfc.c

834

return PTR_ERR(nfc->regs);

drivers/mtd/nand/raw/vf610_nfc.c

836

nfc->clk = devm_clk_get_enabled(&pdev->dev, NULL);

drivers/mtd/nand/raw/vf610_nfc.c

837

if (IS_ERR(nfc->clk)) {

drivers/mtd/nand/raw/vf610_nfc.c

838

dev_err(nfc->dev, "Unable to get and enable clock!\n");

drivers/mtd/nand/raw/vf610_nfc.c

839

return PTR_ERR(nfc->clk);

drivers/mtd/nand/raw/vf610_nfc.c

842

nfc->variant = (unsigned long)device_get_match_data(&pdev->dev);

drivers/mtd/nand/raw/vf610_nfc.c

843

if (!nfc->variant)

drivers/mtd/nand/raw/vf610_nfc.c

846

for_each_available_child_of_node_scoped(nfc->dev->of_node, child) {

drivers/mtd/nand/raw/vf610_nfc.c

850

dev_err(nfc->dev,

drivers/mtd/nand/raw/vf610_nfc.c

860

dev_err(nfc->dev, "NAND chip sub-node missing!\n");

drivers/mtd/nand/raw/vf610_nfc.c

866

init_completion(&nfc->cmd_done);

drivers/mtd/nand/raw/vf610_nfc.c

868

err = devm_request_irq(nfc->dev, irq, vf610_nfc_irq, 0, DRV_NAME, nfc);

drivers/mtd/nand/raw/vf610_nfc.c

870

dev_err(nfc->dev, "Error requesting IRQ!\n");

drivers/mtd/nand/raw/vf610_nfc.c

874

vf610_nfc_preinit_controller(nfc);

drivers/mtd/nand/raw/vf610_nfc.c

876

nand_controller_init(&nfc->base);

drivers/mtd/nand/raw/vf610_nfc.c

877

nfc->base.ops = &vf610_nfc_controller_ops;

drivers/mtd/nand/raw/vf610_nfc.c

878

chip->controller = &nfc->base;

drivers/mtd/nand/raw/vf610_nfc.c

885

platform_set_drvdata(pdev, nfc);

drivers/mtd/nand/raw/vf610_nfc.c

900

struct vf610_nfc *nfc = platform_get_drvdata(pdev);

drivers/mtd/nand/raw/vf610_nfc.c

901

struct nand_chip *chip = &nfc->chip;

drivers/mtd/nand/raw/vf610_nfc.c

912

struct vf610_nfc *nfc = dev_get_drvdata(dev);

drivers/mtd/nand/raw/vf610_nfc.c

914

clk_disable_unprepare(nfc->clk);

drivers/mtd/nand/raw/vf610_nfc.c

920

struct vf610_nfc *nfc = dev_get_drvdata(dev);

drivers/mtd/nand/raw/vf610_nfc.c

923

err = clk_prepare_enable(nfc->clk);

drivers/mtd/nand/raw/vf610_nfc.c

927

vf610_nfc_preinit_controller(nfc);

drivers/mtd/nand/raw/vf610_nfc.c

928

vf610_nfc_init_controller(nfc);

drivers/net/dsa/bcm_sf2.h

225

struct ethtool_rxnfc *nfc, u32 *rule_locs);

drivers/net/dsa/bcm_sf2.h

227

struct ethtool_rxnfc *nfc);

drivers/net/dsa/bcm_sf2_cfp.c

1065

struct ethtool_rxnfc *nfc)

drivers/net/dsa/bcm_sf2_cfp.c

1069

rule = bcm_sf2_cfp_rule_find(priv, port, nfc->fs.location);

drivers/net/dsa/bcm_sf2_cfp.c

1073

memcpy(&nfc->fs, &rule->fs, sizeof(rule->fs));

drivers/net/dsa/bcm_sf2_cfp.c

1075

bcm_sf2_invert_masks(&nfc->fs);

drivers/net/dsa/bcm_sf2_cfp.c

1078

nfc->data = bcm_sf2_cfp_rule_size(priv);

drivers/net/dsa/bcm_sf2_cfp.c

1085

int port, struct ethtool_rxnfc *nfc,

drivers/net/dsa/bcm_sf2_cfp.c

1096

nfc->data = bcm_sf2_cfp_rule_size(priv);

drivers/net/dsa/bcm_sf2_cfp.c

1097

nfc->rule_cnt = rules_cnt;

drivers/net/dsa/bcm_sf2_cfp.c

1103

struct ethtool_rxnfc *nfc, u32 *rule_locs)

drivers/net/dsa/bcm_sf2_cfp.c

1111

switch (nfc->cmd) {

drivers/net/dsa/bcm_sf2_cfp.c

1114

nfc->rule_cnt = bitmap_weight(priv->cfp.unique,

drivers/net/dsa/bcm_sf2_cfp.c

1117

nfc->data |= RX_CLS_LOC_SPECIAL;

drivers/net/dsa/bcm_sf2_cfp.c

1120

ret = bcm_sf2_cfp_rule_get(priv, port, nfc);

drivers/net/dsa/bcm_sf2_cfp.c

1123

ret = bcm_sf2_cfp_rule_get_all(priv, port, nfc, rule_locs);

drivers/net/dsa/bcm_sf2_cfp.c

1137

ret = p->ethtool_ops->get_rxnfc(p, nfc, rule_locs);

drivers/net/dsa/bcm_sf2_cfp.c

1146

struct ethtool_rxnfc *nfc)

drivers/net/dsa/bcm_sf2_cfp.c

1154

switch (nfc->cmd) {

drivers/net/dsa/bcm_sf2_cfp.c

1156

ret = bcm_sf2_cfp_rule_set(ds, port, &nfc->fs);

drivers/net/dsa/bcm_sf2_cfp.c

1160

ret = bcm_sf2_cfp_rule_del(priv, port, nfc->fs.location);

drivers/net/dsa/bcm_sf2_cfp.c

1176

ret = p->ethtool_ops->set_rxnfc(p, nfc);

drivers/net/dsa/bcm_sf2_cfp.c

1179

bcm_sf2_cfp_rule_del(priv, port, nfc->fs.location);

drivers/net/ethernet/broadcom/bcmsysport.c

2137

struct ethtool_rxnfc *nfc)

drivers/net/ethernet/broadcom/bcmsysport.c

2142

index = bcm_sysport_rule_find(priv, nfc->fs.location);

drivers/net/ethernet/broadcom/bcmsysport.c

2146

nfc->fs.ring_cookie = RX_CLS_FLOW_WAKE;

drivers/net/ethernet/broadcom/bcmsysport.c

2152

struct ethtool_rxnfc *nfc)

drivers/net/ethernet/broadcom/bcmsysport.c

2160

if (nfc->fs.location > RXCHK_BRCM_TAG_CID_MASK)

drivers/net/ethernet/broadcom/bcmsysport.c

2164

if (nfc->fs.ring_cookie != RX_CLS_FLOW_WAKE)

drivers/net/ethernet/broadcom/bcmsysport.c

2177

reg |= nfc->fs.location << RXCHK_BRCM_TAG_CID_SHIFT;

drivers/net/ethernet/broadcom/bcmsysport.c

2181

priv->filters_loc[index] = nfc->fs.location;

drivers/net/ethernet/broadcom/bcmsysport.c

2207

struct ethtool_rxnfc *nfc, u32 *rule_locs)

drivers/net/ethernet/broadcom/bcmsysport.c

2212

switch (nfc->cmd) {

drivers/net/ethernet/broadcom/bcmsysport.c

2214

ret = bcm_sysport_rule_get(priv, nfc);

drivers/net/ethernet/broadcom/bcmsysport.c

2224

struct ethtool_rxnfc *nfc)

drivers/net/ethernet/broadcom/bcmsysport.c

2229

switch (nfc->cmd) {

drivers/net/ethernet/broadcom/bcmsysport.c

2231

ret = bcm_sysport_rule_set(priv, nfc);

drivers/net/ethernet/broadcom/bcmsysport.c

2234

ret = bcm_sysport_rule_del(priv, nfc->fs.location);

drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c

317

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c

323

if (nfc->data &

drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c

327

switch (nfc->flow_type) {

drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c

342

dpaa_set_hash(dev, !!nfc->data);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

154

const struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

160

if (nfc->data &

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

168

ret = hclge_comm_init_rss_tuple_cmd(rss_cfg, nfc, ae_dev, req);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

425

static u8 hclge_comm_get_rss_hash_bits(const struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

427

u8 hash_sets = nfc->data & RXH_L4_B_0_1 ? HCLGE_COMM_S_PORT_BIT : 0;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

429

if (nfc->data & RXH_L4_B_2_3)

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

434

if (nfc->data & RXH_IP_SRC)

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

439

if (nfc->data & RXH_IP_DST)

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

444

if (nfc->flow_type == SCTP_V4_FLOW || nfc->flow_type == SCTP_V6_FLOW)

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

451

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

466

tuple_sets = hclge_comm_get_rss_hash_bits(nfc);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

467

switch (nfc->flow_type) {

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

485

(nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)))

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.h

111

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.h

132

const struct ethtool_rxfh_fields *nfc);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

4875

const struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

4882

&hdev->rss_cfg, nfc);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

4893

struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

4899

nfc->data = 0;

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

4901

ret = hclge_comm_get_rss_tuple(&vport->back->rss_cfg, nfc->flow_type,

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

4906

nfc->data = hclge_comm_convert_rss_tuple(tuple_sets);

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c

609

const struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c

618

&hdev->rss_cfg, nfc);

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c

627

struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c

636

nfc->data = 0;

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c

638

ret = hclge_comm_get_rss_tuple(&hdev->rss_cfg, nfc->flow_type,

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c

643

nfc->data = hclge_comm_convert_rss_tuple(tuple_sets);

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

745

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

757

if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

761

switch (nfc->flow_type) {

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

764

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

765

!(nfc->data & RXH_IP_DST) ||

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

766

!(nfc->data & RXH_L4_B_0_1) ||

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

767

!(nfc->data & RXH_L4_B_2_3))

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

771

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

772

!(nfc->data & RXH_IP_DST))

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

774

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

788

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

789

!(nfc->data & RXH_IP_DST))

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

791

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

812

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

813

!(nfc->data & RXH_IP_DST) ||

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

814

(nfc->data & RXH_L4_B_0_1) ||

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

815

(nfc->data & RXH_L4_B_2_3))

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3570

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3576

if (nfc->data & RXH_L4_B_0_1)

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3580

if (nfc->data & RXH_L4_B_2_3)

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3585

if (nfc->flow_type == TCP_V6_FLOW || nfc->flow_type == UDP_V6_FLOW) {

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3588

} else if (nfc->flow_type == TCP_V4_FLOW ||

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3589

nfc->flow_type == UDP_V4_FLOW) {

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3602

if (nfc->data & RXH_IP_SRC)

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3606

if (nfc->data & RXH_IP_DST)

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3616

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3639

if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3643

switch (nfc->flow_type) {

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3684

if ((nfc->data & RXH_L4_B_0_1) ||

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3685

(nfc->data & RXH_L4_B_2_3))

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3693

if ((nfc->data & RXH_L4_B_0_1) ||

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3694

(nfc->data & RXH_L4_B_2_3))

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

3716

i_set = i40e_get_rss_hash_bits(&pf->hw, nfc, i_setc);

drivers/net/ethernet/intel/ice/ice_ethtool.c

2809

static u32 ice_parse_hdrs(const struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/intel/ice/ice_ethtool.c

2813

switch (nfc->flow_type) {

drivers/net/ethernet/intel/ice/ice_ethtool.c

2874

static u64 ice_parse_hash_flds(const struct ethtool_rxfh_fields *nfc, bool symm)

drivers/net/ethernet/intel/ice/ice_ethtool.c

2878

if (nfc->data & RXH_IP_SRC || nfc->data & RXH_IP_DST) {

drivers/net/ethernet/intel/ice/ice_ethtool.c

2879

switch (nfc->flow_type) {

drivers/net/ethernet/intel/ice/ice_ethtool.c

2889

if (nfc->data & RXH_IP_SRC)

drivers/net/ethernet/intel/ice/ice_ethtool.c

2891

if (nfc->data & RXH_IP_DST)

drivers/net/ethernet/intel/ice/ice_ethtool.c

2903

if (nfc->data & RXH_IP_SRC)

drivers/net/ethernet/intel/ice/ice_ethtool.c

2905

if (nfc->data & RXH_IP_DST)

drivers/net/ethernet/intel/ice/ice_ethtool.c

2913

if (nfc->data & RXH_L4_B_0_1 || nfc->data & RXH_L4_B_2_3) {

drivers/net/ethernet/intel/ice/ice_ethtool.c

2914

switch (nfc->flow_type) {

drivers/net/ethernet/intel/ice/ice_ethtool.c

2917

if (nfc->data & RXH_L4_B_0_1)

drivers/net/ethernet/intel/ice/ice_ethtool.c

2919

if (nfc->data & RXH_L4_B_2_3)

drivers/net/ethernet/intel/ice/ice_ethtool.c

2924

if (nfc->data & RXH_L4_B_0_1)

drivers/net/ethernet/intel/ice/ice_ethtool.c

2926

if (nfc->data & RXH_L4_B_2_3)

drivers/net/ethernet/intel/ice/ice_ethtool.c

2931

if (nfc->data & RXH_L4_B_0_1)

drivers/net/ethernet/intel/ice/ice_ethtool.c

2933

if (nfc->data & RXH_L4_B_2_3)

drivers/net/ethernet/intel/ice/ice_ethtool.c

2941

if (nfc->data & RXH_GTP_TEID) {

drivers/net/ethernet/intel/ice/ice_ethtool.c

2942

switch (nfc->flow_type) {

drivers/net/ethernet/intel/ice/ice_ethtool.c

2973

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/intel/ice/ice_ethtool.c

2994

hashed_flds = ice_parse_hash_flds(nfc, symm);

drivers/net/ethernet/intel/ice/ice_ethtool.c

3001

hdrs = ice_parse_hdrs(nfc);

drivers/net/ethernet/intel/ice/ice_ethtool.c

3024

ice_get_rxfh_fields(struct net_device *netdev, struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/intel/ice/ice_ethtool.c

3036

nfc->data = 0;

drivers/net/ethernet/intel/ice/ice_ethtool.c

3043

hdrs = ice_parse_hdrs(nfc);

drivers/net/ethernet/intel/ice/ice_ethtool.c

3059

nfc->data |= (u64)RXH_IP_SRC;

drivers/net/ethernet/intel/ice/ice_ethtool.c

3063

nfc->data |= (u64)RXH_IP_DST;

drivers/net/ethernet/intel/ice/ice_ethtool.c

3068

nfc->data |= (u64)RXH_L4_B_0_1;

drivers/net/ethernet/intel/ice/ice_ethtool.c

3073

nfc->data |= (u64)RXH_L4_B_2_3;

drivers/net/ethernet/intel/ice/ice_ethtool.c

3080

nfc->data |= (u64)RXH_GTP_TEID;

drivers/net/ethernet/intel/igb/igb_ethtool.c

2578

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/intel/igb/igb_ethtool.c

2587

if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |

drivers/net/ethernet/intel/igb/igb_ethtool.c

2591

switch (nfc->flow_type) {

drivers/net/ethernet/intel/igb/igb_ethtool.c

2594

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/igb/igb_ethtool.c

2595

!(nfc->data & RXH_IP_DST) ||

drivers/net/ethernet/intel/igb/igb_ethtool.c

2596

!(nfc->data & RXH_L4_B_0_1) ||

drivers/net/ethernet/intel/igb/igb_ethtool.c

2597

!(nfc->data & RXH_L4_B_2_3))

drivers/net/ethernet/intel/igb/igb_ethtool.c

2601

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/igb/igb_ethtool.c

2602

!(nfc->data & RXH_IP_DST))

drivers/net/ethernet/intel/igb/igb_ethtool.c

2604

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

drivers/net/ethernet/intel/igb/igb_ethtool.c

2616

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/igb/igb_ethtool.c

2617

!(nfc->data & RXH_IP_DST))

drivers/net/ethernet/intel/igb/igb_ethtool.c

2619

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

drivers/net/ethernet/intel/igb/igb_ethtool.c

2638

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/igb/igb_ethtool.c

2639

!(nfc->data & RXH_IP_DST) ||

drivers/net/ethernet/intel/igb/igb_ethtool.c

2640

(nfc->data & RXH_L4_B_0_1) ||

drivers/net/ethernet/intel/igb/igb_ethtool.c

2641

(nfc->data & RXH_L4_B_2_3))

drivers/net/ethernet/intel/igc/igc_ethtool.c

1122

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/intel/igc/igc_ethtool.c

1131

if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |

drivers/net/ethernet/intel/igc/igc_ethtool.c

1135

switch (nfc->flow_type) {

drivers/net/ethernet/intel/igc/igc_ethtool.c

1138

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/igc/igc_ethtool.c

1139

!(nfc->data & RXH_IP_DST) ||

drivers/net/ethernet/intel/igc/igc_ethtool.c

1140

!(nfc->data & RXH_L4_B_0_1) ||

drivers/net/ethernet/intel/igc/igc_ethtool.c

1141

!(nfc->data & RXH_L4_B_2_3))

drivers/net/ethernet/intel/igc/igc_ethtool.c

1145

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/igc/igc_ethtool.c

1146

!(nfc->data & RXH_IP_DST))

drivers/net/ethernet/intel/igc/igc_ethtool.c

1148

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

drivers/net/ethernet/intel/igc/igc_ethtool.c

1160

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/igc/igc_ethtool.c

1161

!(nfc->data & RXH_IP_DST))

drivers/net/ethernet/intel/igc/igc_ethtool.c

1163

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

drivers/net/ethernet/intel/igc/igc_ethtool.c

1182

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/igc/igc_ethtool.c

1183

!(nfc->data & RXH_IP_DST) ||

drivers/net/ethernet/intel/igc/igc_ethtool.c

1184

(nfc->data & RXH_L4_B_0_1) ||

drivers/net/ethernet/intel/igc/igc_ethtool.c

1185

(nfc->data & RXH_L4_B_2_3))

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3088

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3098

if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3102

switch (nfc->flow_type) {

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3105

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3106

!(nfc->data & RXH_IP_DST) ||

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3107

!(nfc->data & RXH_L4_B_0_1) ||

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3108

!(nfc->data & RXH_L4_B_2_3))

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3112

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3113

!(nfc->data & RXH_IP_DST))

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3115

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3127

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3128

!(nfc->data & RXH_IP_DST))

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3130

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3149

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3150

!(nfc->data & RXH_IP_DST) ||

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3151

(nfc->data & RXH_L4_B_0_1) ||

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3152

(nfc->data & RXH_L4_B_2_3))

drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.h

1127

struct ethtool_rxnfc *nfc, u32 location);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.h

1129

struct ethtool_rxnfc *nfc, u32 *rule_locs);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.h

1131

struct ethtool_rxnfc *nfc);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

581

struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

593

nfc->data = RXH_IP_SRC | RXH_IP_DST;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

595

nfc->data |= RXH_VLAN;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

597

switch (nfc->flow_type) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

601

nfc->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

606

nfc->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

611

nfc->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

616

nfc->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

634

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

652

if (!(nfc->data & RXH_IP_SRC) || !(nfc->data & RXH_IP_DST))

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

655

if (nfc->data & RXH_VLAN)

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

660

switch (nfc->flow_type) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

666

switch (nfc->data & rxh_l4) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

679

switch (nfc->data & rxh_l4) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

692

switch (nfc->data & rxh_l4) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

705

switch (nfc->data & rxh_l4) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

747

struct ethtool_rxnfc *nfc, u32 *rules)

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

753

switch (nfc->cmd) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

756

nfc->rule_cnt = pfvf->flow_cfg->nr_flows;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

762

ret = otx2_get_flow(pfvf, nfc, nfc->fs.location);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

766

ret = otx2_get_all_flows(pfvf, nfc, rules);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

774

static int otx2_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *nfc)

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

781

switch (nfc->cmd) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

784

ret = otx2_add_flow(pfvf, nfc);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c

788

ret = otx2_remove_flow(pfvf, nfc->fs.location);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1091

int otx2_add_flow(struct otx2_nic *pfvf, struct ethtool_rxnfc *nfc)

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1094

struct ethtool_rx_flow_spec *fsp = &nfc->fs;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

1145

flow->rss_ctx_id = nfc->rss_context;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

497

int otx2_get_flow(struct otx2_nic *pfvf, struct ethtool_rxnfc *nfc,

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

507

nfc->fs = iter->flow_spec;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

508

nfc->rss_context = iter->rss_ctx_id;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

516

int otx2_get_all_flows(struct otx2_nic *pfvf, struct ethtool_rxnfc *nfc,

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

519

u32 rule_cnt = nfc->rule_cnt;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

524

nfc->data = otx2_get_maxflows(pfvf->flow_cfg);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

526

err = otx2_get_flow(pfvf, nfc, location);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_flows.c

531

nfc->rule_cnt = rule_cnt;

drivers/net/ethernet/mellanox/mlx5/core/en/fs_ethtool.h

15

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/mellanox/mlx5/core/en/fs_ethtool.h

18

struct ethtool_rxfh_fields *nfc);

drivers/net/ethernet/mellanox/mlx5/core/en/fs_ethtool.h

30

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/mellanox/mlx5/core/en/fs_ethtool.h

35

struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

898

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

907

rss_idx = nfc->rss_context;

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

909

flow_type = flow_type_mask(nfc->flow_type);

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

924

if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

928

if (nfc->data & RXH_IP_SRC)

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

930

if (nfc->data & RXH_IP_DST)

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

932

if (nfc->data & RXH_L4_B_0_1)

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

934

if (nfc->data & RXH_L4_B_2_3)

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

945

struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

952

rss_idx = nfc->rss_context;

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

954

flow_type = flow_type_mask(nfc->flow_type);

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

963

nfc->data = 0;

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

966

nfc->data |= RXH_IP_SRC;

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

968

nfc->data |= RXH_IP_DST;

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

970

nfc->data |= RXH_L4_B_0_1;

drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c

972

nfc->data |= RXH_L4_B_2_3;

drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c

1465

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c

1477

if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |

drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c

1482

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c

1483

!(nfc->data & RXH_IP_DST))

drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c

1486

nfp_rss_flag = ethtool_flow_to_nfp_flag(nfc->flow_type);

drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c

1490

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

drivers/net/ethernet/sun/niu.c

7095

struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/sun/niu.c

7100

nfc->data = 0;

drivers/net/ethernet/sun/niu.c

7102

if (!niu_ethflow_to_class(nfc->flow_type, &class))

drivers/net/ethernet/sun/niu.c

7107

nfc->data = RXH_DISCARD;

drivers/net/ethernet/sun/niu.c

7109

nfc->data = niu_flowkey_to_ethflow(np->parent->flow_key[class -

drivers/net/ethernet/sun/niu.c

7191

struct ethtool_rxnfc *nfc)

drivers/net/ethernet/sun/niu.c

7195

struct ethtool_rx_flow_spec *fsp = &nfc->fs;

drivers/net/ethernet/sun/niu.c

7200

idx = tcam_get_index(np, (u16)nfc->fs.location);

drivers/net/ethernet/sun/niu.c

7205

parent->index, (u16)nfc->fs.location, idx);

drivers/net/ethernet/sun/niu.c

7264

nfc->data = tcam_get_size(np);

drivers/net/ethernet/sun/niu.c

7270

struct ethtool_rxnfc *nfc,

drivers/net/ethernet/sun/niu.c

7280

nfc->data = tcam_get_size(np);

drivers/net/ethernet/sun/niu.c

7283

for (cnt = 0, i = 0; i < nfc->data; i++) {

drivers/net/ethernet/sun/niu.c

7288

if (cnt == nfc->rule_cnt) {

drivers/net/ethernet/sun/niu.c

7297

nfc->rule_cnt = cnt;

drivers/net/ethernet/sun/niu.c

7334

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/sun/niu.c

7342

if (!niu_ethflow_to_class(nfc->flow_type, &class))

drivers/net/ethernet/sun/niu.c

7349

if (nfc->data & RXH_DISCARD) {

drivers/net/ethernet/sun/niu.c

7374

if (!niu_ethflow_to_flowkey(nfc->data, &flow_key))

drivers/net/ethernet/sun/niu.c

7454

struct ethtool_rxnfc *nfc)

drivers/net/ethernet/sun/niu.c

7458

struct ethtool_rx_flow_spec *fsp = &nfc->fs;

drivers/net/ethernet/sun/niu.c

7468

idx = nfc->fs.location;

drivers/net/ethernet/wangxun/libwx/wx_ethtool.c

612

struct ethtool_rxfh_fields *nfc)

drivers/net/ethernet/wangxun/libwx/wx_ethtool.c

616

nfc->data = RXH_IP_SRC | RXH_IP_DST;

drivers/net/ethernet/wangxun/libwx/wx_ethtool.c

621

if (entry->flow_type == nfc->flow_type) {

drivers/net/ethernet/wangxun/libwx/wx_ethtool.c

623

nfc->data |= entry->data;

drivers/net/ethernet/wangxun/libwx/wx_ethtool.c

633

const struct ethtool_rxfh_fields *nfc,

drivers/net/ethernet/wangxun/libwx/wx_ethtool.c

639

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/ethernet/wangxun/libwx/wx_ethtool.c

640

!(nfc->data & RXH_IP_DST))

drivers/net/ethernet/wangxun/libwx/wx_ethtool.c

646

if (entry->flow_type == nfc->flow_type) {

drivers/net/ethernet/wangxun/libwx/wx_ethtool.c

647

if (nfc->data & entry->data)

drivers/net/ethernet/wangxun/libwx/wx_ethtool.h

51

const struct ethtool_rxfh_fields *nfc,

drivers/net/vmxnet3/vmxnet3_ethtool.c

1010

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/vmxnet3/vmxnet3_ethtool.c

1011

!(nfc->data & RXH_IP_DST) ||

drivers/net/vmxnet3/vmxnet3_ethtool.c

1012

(nfc->data & RXH_L4_B_0_1) ||

drivers/net/vmxnet3/vmxnet3_ethtool.c

1013

(nfc->data & RXH_L4_B_2_3))

drivers/net/vmxnet3/vmxnet3_ethtool.c

911

const struct ethtool_rxfh_fields *nfc,

drivers/net/vmxnet3/vmxnet3_ethtool.c

929

if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |

drivers/net/vmxnet3/vmxnet3_ethtool.c

933

switch (nfc->flow_type) {

drivers/net/vmxnet3/vmxnet3_ethtool.c

936

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/vmxnet3/vmxnet3_ethtool.c

937

!(nfc->data & RXH_IP_DST) ||

drivers/net/vmxnet3/vmxnet3_ethtool.c

938

!(nfc->data & RXH_L4_B_0_1) ||

drivers/net/vmxnet3/vmxnet3_ethtool.c

939

!(nfc->data & RXH_L4_B_2_3))

drivers/net/vmxnet3/vmxnet3_ethtool.c

943

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/vmxnet3/vmxnet3_ethtool.c

944

!(nfc->data & RXH_IP_DST))

drivers/net/vmxnet3/vmxnet3_ethtool.c

946

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

drivers/net/vmxnet3/vmxnet3_ethtool.c

958

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/vmxnet3/vmxnet3_ethtool.c

959

!(nfc->data & RXH_IP_DST))

drivers/net/vmxnet3/vmxnet3_ethtool.c

961

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

drivers/net/vmxnet3/vmxnet3_ethtool.c

975

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/vmxnet3/vmxnet3_ethtool.c

976

!(nfc->data & RXH_IP_DST))

drivers/net/vmxnet3/vmxnet3_ethtool.c

978

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

drivers/net/vmxnet3/vmxnet3_ethtool.c

994

if (!(nfc->data & RXH_IP_SRC) ||

drivers/net/vmxnet3/vmxnet3_ethtool.c

995

!(nfc->data & RXH_IP_DST))

drivers/net/vmxnet3/vmxnet3_ethtool.c

997

switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

include/linux/mtd/rawnand.h

1130

static inline void nand_controller_init(struct nand_controller *nfc)

include/linux/mtd/rawnand.h

1132

mutex_init(&nfc->lock);

include/net/dsa.h

1090

struct ethtool_rxnfc *nfc, u32 *rule_locs);

include/net/dsa.h

1092

struct ethtool_rxnfc *nfc);

net/dsa/user.c

1754

struct ethtool_rxnfc *nfc, u32 *rule_locs)

net/dsa/user.c

1762

return ds->ops->get_rxnfc(ds, dp->index, nfc, rule_locs);

net/dsa/user.c

1766

struct ethtool_rxnfc *nfc)

net/dsa/user.c

1774

return ds->ops->set_rxnfc(ds, dp->index, nfc);