arch/arm64/include/asm/atomic_ll_sc.h

138

#define ATOMIC64_OP_RETURN(name, mb, acq, rel, cl, op, asm_op, constraint)\

arch/arm64/include/asm/atomic_ll_sc.h

154

: cl); \

arch/arm64/include/asm/atomic_ll_sc.h

159

#define ATOMIC64_FETCH_OP(name, mb, acq, rel, cl, op, asm_op, constraint)\

arch/arm64/include/asm/atomic_ll_sc.h

175

: cl); \

arch/arm64/include/asm/atomic_ll_sc.h

239

#define __CMPXCHG_CASE(w, sfx, name, sz, mb, acq, rel, cl, constraint) \

arch/arm64/include/asm/atomic_ll_sc.h

268

: cl); \

arch/arm64/include/asm/atomic_ll_sc.h

304

#define __CMPXCHG128(name, mb, rel, cl...) \

arch/arm64/include/asm/atomic_ll_sc.h

327

: "cc", ##cl); \

arch/arm64/include/asm/atomic_ll_sc.h

42

#define ATOMIC_OP_RETURN(name, mb, acq, rel, cl, op, asm_op, constraint)\

arch/arm64/include/asm/atomic_ll_sc.h

58

: cl); \

arch/arm64/include/asm/atomic_ll_sc.h

63

#define ATOMIC_FETCH_OP(name, mb, acq, rel, cl, op, asm_op, constraint) \

arch/arm64/include/asm/atomic_ll_sc.h

79

: cl); \

arch/arm64/include/asm/atomic_lse.h

143

#define ATOMIC64_FETCH_OP(name, mb, op, asm_op, cl...) \

arch/arm64/include/asm/atomic_lse.h

155

: cl); \

arch/arm64/include/asm/atomic_lse.h

248

#define __CMPXCHG_CASE(w, sfx, name, sz, mb, cl...) \

arch/arm64/include/asm/atomic_lse.h

260

: cl); \

arch/arm64/include/asm/atomic_lse.h

284

#define __CMPXCHG128(name, mb, cl...) \

arch/arm64/include/asm/atomic_lse.h

303

: cl); \

arch/arm64/include/asm/atomic_lse.h

36

#define ATOMIC_FETCH_OP(name, mb, op, asm_op, cl...) \

arch/arm64/include/asm/atomic_lse.h

48

: cl); \

arch/arm64/include/asm/cmpxchg.h

21

#define __XCHG_CASE(w, sfx, name, sz, mb, nop_lse, acq, acq_lse, rel, cl) \

arch/arm64/include/asm/cmpxchg.h

40

: cl); \

arch/mips/include/asm/octeon/cvmx-lmcx-defs.h

1883

uint64_t cl:4;

arch/mips/include/asm/octeon/cvmx-lmcx-defs.h

1903

uint64_t cl:4;

arch/mips/include/asm/octeon/cvmx-pciercx-defs.h

67

__BITFIELD_FIELD(uint32_t cl:1,

arch/mips/kernel/smp-cps.c

214

int cl, c, v;

arch/mips/kernel/smp-cps.c

220

for (cl = 0; cl < nclusters; cl++) {

arch/mips/kernel/smp-cps.c

221

if (cl > 0)

arch/mips/kernel/smp-cps.c

226

power_up_other_cluster(cl);

arch/mips/kernel/smp-cps.c

228

ncores = mips_cps_numcores(cl);

arch/mips/kernel/smp-cps.c

230

core_vpes = core_vpe_count(cl, c);

arch/mips/kernel/smp-cps.c

237

if (!cl && !c)

arch/mips/kernel/smp-cps.c

242

cpu_set_cluster(&cpu_data[nvpes + v], cl);

arch/mips/kernel/smp-cps.c

297

unsigned int nclusters, ncores, core_vpes, nvpe = 0, c, cl, cca;

arch/mips/kernel/smp-cps.c

352

for (cl = 0; cl < nclusters; cl++) {

arch/mips/kernel/smp-cps.c

354

ncores = mips_cps_numcores(cl);

arch/mips/kernel/smp-cps.c

358

mips_cps_cluster_bootcfg[cl].core_config = core_bootcfg;

arch/mips/kernel/smp-cps.c

360

mips_cps_cluster_bootcfg[cl].core_power =

arch/mips/kernel/smp-cps.c

363

if (!mips_cps_cluster_bootcfg[cl].core_power)

arch/mips/kernel/smp-cps.c

369

core_vpes = core_vpe_count(cl, c);

arch/mips/kernel/smp-cps.c

373

cpumask_set_cpu(nvpe++, &mips_cps_cluster_bootcfg[cl].cpumask);

arch/mips/kernel/smp-cps.c

380

cl = cpu_cluster(&current_cpu_data);

arch/mips/kernel/smp-cps.c

382

cluster_bootcfg = &mips_cps_cluster_bootcfg[cl];

arch/mips/kernel/smp-cps.c

392

for (cl = 0; cl < nclusters; cl++) {

arch/mips/kernel/smp-cps.c

393

cluster_bootcfg = &mips_cps_cluster_bootcfg[cl];

arch/mips/kernel/smp-cps.c

394

ncores = mips_cps_numcores(cl);

arch/mips/lantiq/clk.c

92

clk->cl.dev_id, clk->cl.con_id, rate);

arch/mips/lantiq/clk.h

59

struct clk_lookup cl;

arch/mips/lantiq/falcon/sysctrl.c

168

clk->cl.dev_id = dev;

arch/mips/lantiq/falcon/sysctrl.c

169

clk->cl.con_id = NULL;

arch/mips/lantiq/falcon/sysctrl.c

170

clk->cl.clk = clk;

arch/mips/lantiq/falcon/sysctrl.c

178

clkdev_add(&clk->cl);

arch/mips/lantiq/xway/gptu.c

128

clk->cl.dev_id = dev_name(dev);

arch/mips/lantiq/xway/gptu.c

129

clk->cl.con_id = con;

arch/mips/lantiq/xway/gptu.c

130

clk->cl.clk = clk;

arch/mips/lantiq/xway/gptu.c

134

clkdev_add(&clk->cl);

arch/mips/lantiq/xway/sysctrl.c

338

clk->cl.dev_id = dev;

arch/mips/lantiq/xway/sysctrl.c

339

clk->cl.con_id = con;

arch/mips/lantiq/xway/sysctrl.c

340

clk->cl.clk = clk;

arch/mips/lantiq/xway/sysctrl.c

352

clkdev_add(&clk->cl);

arch/mips/lantiq/xway/sysctrl.c

363

clk->cl.dev_id = dev;

arch/mips/lantiq/xway/sysctrl.c

364

clk->cl.con_id = con;

arch/mips/lantiq/xway/sysctrl.c

365

clk->cl.clk = clk;

arch/mips/lantiq/xway/sysctrl.c

369

clkdev_add(&clk->cl);

arch/mips/lantiq/xway/sysctrl.c

382

clk->cl.dev_id = "17000000.pci";

arch/mips/lantiq/xway/sysctrl.c

383

clk->cl.con_id = NULL;

arch/mips/lantiq/xway/sysctrl.c

384

clk->cl.clk = clk;

arch/mips/lantiq/xway/sysctrl.c

391

clkdev_add(&clk->cl);

arch/mips/lantiq/xway/sysctrl.c

396

clk_ext->cl.dev_id = "17000000.pci";

arch/mips/lantiq/xway/sysctrl.c

397

clk_ext->cl.con_id = "external";

arch/mips/lantiq/xway/sysctrl.c

398

clk_ext->cl.clk = clk_ext;

arch/mips/lantiq/xway/sysctrl.c

401

clkdev_add(&clk_ext->cl);

arch/mips/lantiq/xway/sysctrl.c

431

clk->cl.dev_id = "1f103000.cgu";

arch/mips/lantiq/xway/sysctrl.c

432

clk->cl.con_id = name;

arch/mips/lantiq/xway/sysctrl.c

433

clk->cl.clk = clk;

arch/mips/lantiq/xway/sysctrl.c

438

clkdev_add(&clk->cl);

arch/powerpc/include/asm/cmpxchg.h

16

#define XCHG_GEN(type, sfx, cl) \

arch/powerpc/include/asm/cmpxchg.h

35

: "cc", cl); \

arch/powerpc/include/asm/cmpxchg.h

40

#define CMPXCHG_GEN(type, sfx, br, br2, cl) \

arch/powerpc/include/asm/cmpxchg.h

68

: "cc", cl); \

arch/powerpc/math-emu/math_efp.c

639

int ch, cl;

arch/powerpc/math-emu/math_efp.c

648

cl = (IR1 == cmp) ? 1 : 0;

arch/powerpc/math-emu/math_efp.c

649

IR = (ch << 3) | (cl << 2) | ((ch | cl) << 1) |

arch/powerpc/math-emu/math_efp.c

650

((ch & cl) << 0);

arch/sparc/kernel/setup_64.c

652

u32 cl, sv, gw;

arch/sparc/kernel/setup_64.c

654

cl = prom_getintdefault (chosen, "client-ip", 0);

arch/sparc/kernel/setup_64.c

657

if (cl && sv) {

arch/sparc/kernel/setup_64.c

658

ic_myaddr = cl;

arch/um/drivers/ubd_kern.c

124

.cl = 1 })

arch/um/drivers/ubd_kern.c

127

.cl = 1 })

arch/um/include/shared/os.h

135

flags.cl = 1;

arch/um/include/shared/os.h

73

unsigned int cl : 1; /* FD_CLOEXEC */

arch/um/include/shared/os.h

77

.t = 0, .a = 0, .e = 0, .cl = 0 })

arch/um/os-Linux/file.c

192

if (flags.cl && fcntl(fd, F_SETFD, 1)) {

arch/x86/boot/boot.h

239

u8 cl, ch, ecx2, ecx3;

arch/x86/boot/compressed/ident_map_64.c

235

char *cl, *start, *end;

arch/x86/boot/compressed/ident_map_64.c

251

for (cl = start; cl != end; cl += flush_size)

arch/x86/boot/compressed/ident_map_64.c

252

clflush(cl);

arch/x86/boot/edd.c

112

ei->legacy_max_cylinder = oreg.ch + ((oreg.cl & 0xc0) << 2);

arch/x86/boot/edd.c

114

ei->legacy_sectors_per_track = oreg.cl & 0x3f;

arch/x86/boot/video.c

36

if ((oreg.ch & 0x1f) > (oreg.cl & 0x1f))

arch/x86/include/asm/asm.h

112

#define _ASM_ARG4B cl

arch/x86/include/asm/asm.h

76

#define _ASM_ARG3B cl

arch/x86/kernel/apic/vector.c

1043

static void __vector_cleanup(struct vector_cleanup *cl, bool check_irr)

arch/x86/kernel/apic/vector.c

1051

hlist_for_each_entry_safe(apicd, tmp, &cl->head, clist) {

arch/x86/kernel/apic/vector.c

1079

mod_timer(&cl->timer, jiffies + 1);

arch/x86/kernel/apic/vector.c

1084

struct vector_cleanup *cl = container_of(tmr, typeof(*cl), timer);

arch/x86/kernel/apic/vector.c

1088

__vector_cleanup(cl, true);

arch/x86/kernel/apic/vector.c

1099

struct vector_cleanup *cl = per_cpu_ptr(&vector_cleanup, cpu);

arch/x86/kernel/apic/vector.c

1101

hlist_add_head(&apicd->clist, &cl->head);

arch/x86/kernel/apic/vector.c

1117

if (!timer_pending(&cl->timer)) {

arch/x86/kernel/apic/vector.c

1118

cl->timer.expires = jiffies + 1;

arch/x86/kernel/apic/vector.c

1119

add_timer_on(&cl->timer, cpu);

arch/x86/kernel/apic/vector.c

861

static void __vector_cleanup(struct vector_cleanup *cl, bool check_irr);

arch/x86/kernel/apic/vector.c

865

struct vector_cleanup *cl = this_cpu_ptr(&vector_cleanup);

arch/x86/kernel/apic/vector.c

870

__vector_cleanup(cl, false);

arch/x86/kernel/apic/vector.c

873

WARN_ON_ONCE(timer_delete_sync_try(&cl->timer) < 0);

arch/x86/kernel/apic/vector.c

874

WARN_ON_ONCE(!hlist_empty(&cl->head));

arch/x86/kvm/emulate.c

328

case 1: __EM_ASM_1(op##b, cl); break; \

arch/x86/kvm/emulate.c

337

case 1: __EM_ASM_1_EX(op##b, cl); break; \

arch/x86/kvm/emulate.c

373

case 1: __EM_ASM_2(op##b, al, cl); break; \

arch/x86/kvm/emulate.c

374

case 2: __EM_ASM_2(op##w, ax, cl); break; \

arch/x86/kvm/emulate.c

375

case 4: __EM_ASM_2(op##l, eax, cl); break; \

arch/x86/kvm/emulate.c

376

ON64(case 8: __EM_ASM_2(op##q, rax, cl); break;) \

arch/x86/kvm/emulate.c

383

case 2: __EM_ASM_3(op##w, ax, dx, cl); break; \

arch/x86/kvm/emulate.c

384

case 4: __EM_ASM_3(op##l, eax, edx, cl); break; \

arch/x86/kvm/emulate.c

385

ON64(case 8: __EM_ASM_3(op##q, rax, rdx, cl); break;) \

drivers/acpi/acpi_pcc.c

35

struct mbox_client cl;

drivers/acpi/acpi_pcc.c

41

static void pcc_rx_callback(struct mbox_client *cl, void *m)

drivers/acpi/acpi_pcc.c

43

struct pcc_data *data = container_of(cl, struct pcc_data, cl);

drivers/acpi/acpi_pcc.c

61

data->cl.rx_callback = pcc_rx_callback;

drivers/acpi/acpi_pcc.c

62

data->cl.knows_txdone = true;

drivers/acpi/acpi_pcc.c

68

data->pcc_chan = pcc_mbox_request_channel(&data->cl, ctx->subspace_id);

drivers/acpi/cppc_acpi.c

382

static void cppc_chan_tx_done(struct mbox_client *cl, void *msg, int ret)

drivers/atm/idt77252.c

1600

unsigned long cl, avail;

drivers/atm/idt77252.c

1619

cl = avail;

drivers/atm/idt77252.c

1630

if ((cl >= avail) && (card->soft_tst[e].vc == NULL)) {

drivers/atm/idt77252.c

1644

cl -= card->tst_size;

drivers/atm/idt77252.c

1650

cl += n;

drivers/atm/nicstar.c

1575

unsigned long cl;

drivers/atm/nicstar.c

1597

cl = NS_TST_NUM_ENTRIES;

drivers/atm/nicstar.c

1601

if (cl >= NS_TST_NUM_ENTRIES && card->tste2vc[e] == NULL) {

drivers/atm/nicstar.c

1604

cl -= NS_TST_NUM_ENTRIES;

drivers/atm/nicstar.c

1611

cl += n;

drivers/auxdisplay/panel.c

1005

pin_to_bits(lcd.pins.cl, lcd_bits[LCD_PORT_D][LCD_BIT_CL],

drivers/auxdisplay/panel.c

1587

lcd.pins.cl = lcd_cl_pin;

drivers/auxdisplay/panel.c

212

int cl;

drivers/auxdisplay/panel.c

868

lcd.pins.cl = PIN_STROBE;

drivers/auxdisplay/panel.c

930

lcd.pins.cl = lcd_cl_pin;

drivers/auxdisplay/panel.c

951

if (lcd.pins.cl == PIN_NOT_SET)

drivers/auxdisplay/panel.c

952

lcd.pins.cl = DEFAULT_LCD_PIN_SCL;

drivers/auxdisplay/panel.c

984

if (lcd.pins.cl == PIN_NOT_SET)

drivers/auxdisplay/panel.c

985

lcd.pins.cl = PIN_NONE;

drivers/bus/ti-sysc.c

327

struct clk_lookup *cl;

drivers/bus/ti-sysc.c

357

cl = kzalloc_obj(*cl);

drivers/bus/ti-sysc.c

358

if (!cl)

drivers/bus/ti-sysc.c

361

cl->con_id = n;

drivers/bus/ti-sysc.c

362

cl->dev_id = dev_name(ddata->dev);

drivers/bus/ti-sysc.c

363

cl->clk = clock;

drivers/bus/ti-sysc.c

364

clkdev_add(cl);

drivers/clk/clkdev.c

121

static void __clkdev_add(struct clk_lookup *cl)

drivers/clk/clkdev.c

124

list_add_tail(&cl->node, &clocks);

drivers/clk/clkdev.c

128

void clkdev_add(struct clk_lookup *cl)

drivers/clk/clkdev.c

130

if (!cl->clk_hw)

drivers/clk/clkdev.c

131

cl->clk_hw = __clk_get_hw(cl->clk);

drivers/clk/clkdev.c

132

__clkdev_add(cl);

drivers/clk/clkdev.c

136

void clkdev_add_table(struct clk_lookup *cl, size_t num)

drivers/clk/clkdev.c

140

cl->clk_hw = __clk_get_hw(cl->clk);

drivers/clk/clkdev.c

141

list_add_tail(&cl->node, &clocks);

drivers/clk/clkdev.c

142

cl++;

drivers/clk/clkdev.c

151

struct clk_lookup cl;

drivers/clk/clkdev.c

173

cla->cl.clk_hw = hw;

drivers/clk/clkdev.c

181

cla->cl.con_id = cla->con_id;

drivers/clk/clkdev.c

191

cla->cl.dev_id = cla->dev_id;

drivers/clk/clkdev.c

196

return &cla->cl;

drivers/clk/clkdev.c

215

return &cla->cl;

drivers/clk/clkdev.c

222

struct clk_lookup *cl;

drivers/clk/clkdev.c

224

cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);

drivers/clk/clkdev.c

225

if (cl)

drivers/clk/clkdev.c

226

__clkdev_add(cl);

drivers/clk/clkdev.c

228

return cl;

drivers/clk/clkdev.c

243

struct clk_lookup *cl;

drivers/clk/clkdev.c

247

cl = vclkdev_create(__clk_get_hw(clk), con_id, dev_fmt, ap);

drivers/clk/clkdev.c

250

return cl;

drivers/clk/clkdev.c

266

struct clk_lookup *cl;

drivers/clk/clkdev.c

270

cl = vclkdev_create(hw, con_id, dev_fmt, ap);

drivers/clk/clkdev.c

273

return cl;

drivers/clk/clkdev.c

297

void clkdev_drop(struct clk_lookup *cl)

drivers/clk/clkdev.c

300

list_del(&cl->node);

drivers/clk/clkdev.c

302

kfree(cl);

drivers/clk/clkdev.c

309

struct clk_lookup *cl;

drivers/clk/clkdev.c

313

cl = vclkdev_create(hw, con_id, dev_id, ap);

drivers/clk/clkdev.c

316

return cl;

drivers/clk/clkdev.c

320

struct clk_lookup **cl, const char *con_id, const char *dev_id)

drivers/clk/clkdev.c

329

*cl = __clk_register_clkdev(hw, con_id, "%s", dev_id);

drivers/clk/clkdev.c

331

*cl = __clk_register_clkdev(hw, con_id, NULL);

drivers/clk/clkdev.c

333

return *cl ? 0 : -ENOMEM;

drivers/clk/clkdev.c

353

struct clk_lookup *cl;

drivers/clk/clkdev.c

358

return do_clk_register_clkdev(__clk_get_hw(clk), &cl, con_id,

drivers/clk/clkdev.c

38

struct clk_lookup *p, *cl = NULL;

drivers/clk/clkdev.c

380

struct clk_lookup *cl;

drivers/clk/clkdev.c

382

return do_clk_register_clkdev(hw, &cl, con_id, dev_id);

drivers/clk/clkdev.c

409

struct clk_lookup *cl;

drivers/clk/clkdev.c

412

rval = do_clk_register_clkdev(hw, &cl, con_id, dev_id);

drivers/clk/clkdev.c

416

return devm_add_action_or_reset(dev, devm_clkdev_release, cl);

drivers/clk/clkdev.c

62

cl = p;

drivers/clk/clkdev.c

69

return cl;

drivers/clk/clkdev.c

74

struct clk_lookup *cl;

drivers/clk/clkdev.c

78

cl = clk_find(dev_id, con_id);

drivers/clk/clkdev.c

79

if (cl)

drivers/clk/clkdev.c

80

hw = cl->clk_hw;

drivers/clk/hisilicon/clk-hi3660-stub.c

132

stub_clk_chan.cl.dev = dev;

drivers/clk/hisilicon/clk-hi3660-stub.c

133

stub_clk_chan.cl.tx_done = NULL;

drivers/clk/hisilicon/clk-hi3660-stub.c

134

stub_clk_chan.cl.tx_block = false;

drivers/clk/hisilicon/clk-hi3660-stub.c

135

stub_clk_chan.cl.knows_txdone = false;

drivers/clk/hisilicon/clk-hi3660-stub.c

138

stub_clk_chan.mbox = mbox_request_channel(&stub_clk_chan.cl, 0);

drivers/clk/hisilicon/clk-hi3660-stub.c

42

struct mbox_client cl;

drivers/clk/hisilicon/clk-hi3660-stub.c

88

dev_dbg(stub_clk_chan.cl.dev, "set rate msg[0]=0x%x msg[1]=0x%x\n",

drivers/clk/hisilicon/clk-hi6220-stub.c

220

stub_clk->cl.dev = dev;

drivers/clk/hisilicon/clk-hi6220-stub.c

221

stub_clk->cl.tx_done = NULL;

drivers/clk/hisilicon/clk-hi6220-stub.c

222

stub_clk->cl.tx_block = true;

drivers/clk/hisilicon/clk-hi6220-stub.c

223

stub_clk->cl.tx_tout = 500;

drivers/clk/hisilicon/clk-hi6220-stub.c

224

stub_clk->cl.knows_txdone = false;

drivers/clk/hisilicon/clk-hi6220-stub.c

227

stub_clk->mbox = mbox_request_channel(&stub_clk->cl, 0);

drivers/clk/hisilicon/clk-hi6220-stub.c

50

struct mbox_client cl;

drivers/clk/ti/adpll.c

146

struct clk_lookup *cl;

drivers/clk/ti/adpll.c

203

struct clk_lookup *cl;

drivers/clk/ti/adpll.c

217

cl = clkdev_create(clock, con_id, NULL);

drivers/clk/ti/adpll.c

218

if (!cl)

drivers/clk/ti/adpll.c

220

d->clocks[index].cl = cl;

drivers/clk/ti/adpll.c

770

if (ac->cl)

drivers/clk/ti/adpll.c

771

clkdev_drop(ac->cl);

drivers/clk/ti/clk.c

571

struct clk_lookup *cl;

drivers/clk/ti/clk.c

579

cl = kzalloc_obj(*cl);

drivers/clk/ti/clk.c

580

if (!cl)

drivers/clk/ti/clk.c

583

cl->con_id = con;

drivers/clk/ti/clk.c

584

cl->clk = clk;

drivers/clk/ti/clk.c

586

clkdev_add(cl);

drivers/cpufreq/tegra194-cpufreq.c

34

#define MMCRAB_CLUSTER_BASE(cl) (0x30000 + (cl * 0x10000))

drivers/cpufreq/tegra194-cpufreq.c

35

#define CLUSTER_ACTMON_BASE(data, cl) \

drivers/cpufreq/tegra194-cpufreq.c

36

(data->regs + (MMCRAB_CLUSTER_BASE(cl) + data->soc->actmon_cntr_base))

drivers/cpufreq/tegra194-cpufreq.c

37

#define CORE_ACTMON_CNTR_REG(data, cl, cpu) (CLUSTER_ACTMON_BASE(data, cl) + CORE_OFFSET(cpu))

drivers/crypto/bcm/cipher.c

1619

static void spu_rx_callback(struct mbox_client *cl, void *msg)

drivers/crypto/hisilicon/sec2/sec_crypto.c

1699

u8 cm, cl;

drivers/crypto/hisilicon/sec2/sec_crypto.c

1702

cl = c_req->c_ivin[0] + 1;

drivers/crypto/hisilicon/sec2/sec_crypto.c

1703

c_req->c_ivin[ctx->c_ctx.ivsize - cl] = 0x00;

drivers/crypto/hisilicon/sec2/sec_crypto.c

1704

memset(&c_req->c_ivin[ctx->c_ctx.ivsize - cl], 0, cl);

drivers/crypto/hisilicon/sec2/sec_crypto.c

2445

u8 cl;

drivers/crypto/hisilicon/sec2/sec_crypto.c

2447

cl = aead_req->iv[0] + 1;

drivers/crypto/hisilicon/sec2/sec_crypto.c

2448

if (cl < IV_CL_MIN || cl > IV_CL_MAX)

drivers/crypto/hisilicon/sec2/sec_crypto.c

2451

if (cl < IV_CL_MID && aead_req->cryptlen >> (BYTE_BITS * cl))

drivers/crypto/starfive/jh7110-hash.c

70

unsigned char *cl;

drivers/crypto/starfive/jh7110-hash.c

83

cl = (unsigned char *)key;

drivers/crypto/starfive/jh7110-hash.c

84

for (loop = 0; loop < (klen & 0x3); loop++, cl++)

drivers/crypto/starfive/jh7110-hash.c

85

writeb(*cl, cryp->base + STARFIVE_HASH_SHAWKR);

drivers/devfreq/hisi_uncore_freq.c

112

uncore->cl = (struct mbox_client) {

drivers/devfreq/hisi_uncore_freq.c

118

pcc_chan = pcc_mbox_request_channel(&uncore->cl, uncore->chan_id);

drivers/devfreq/hisi_uncore_freq.c

78

struct mbox_client cl;

drivers/dma/bcm-sba-raid.c

1434

static void sba_receive_message(struct mbox_client *cl, void *msg)

drivers/firmware/arm_scmi/transports/mailbox.c

189

struct mbox_client *cl;

drivers/firmware/arm_scmi/transports/mailbox.c

207

cl = &smbox->cl;

drivers/firmware/arm_scmi/transports/mailbox.c

208

cl->dev = cdev;

drivers/firmware/arm_scmi/transports/mailbox.c

209

cl->tx_prepare = tx ? tx_prepare : NULL;

drivers/firmware/arm_scmi/transports/mailbox.c

210

cl->rx_callback = rx_callback;

drivers/firmware/arm_scmi/transports/mailbox.c

211

cl->tx_block = false;

drivers/firmware/arm_scmi/transports/mailbox.c

212

cl->knows_txdone = tx;

drivers/firmware/arm_scmi/transports/mailbox.c

214

smbox->chan = mbox_request_channel(cl, tx ? 0 : p2a_chan);

drivers/firmware/arm_scmi/transports/mailbox.c

225

smbox->chan_receiver = mbox_request_channel(cl, a2p_rx_chan);

drivers/firmware/arm_scmi/transports/mailbox.c

235

smbox->chan_platform_receiver = mbox_request_channel(cl, p2a_rx_chan);

drivers/firmware/arm_scmi/transports/mailbox.c

32

struct mbox_client cl;

drivers/firmware/arm_scmi/transports/mailbox.c

42

#define client_to_scmi_mailbox(c) container_of(c, struct scmi_mailbox, cl)

drivers/firmware/arm_scmi/transports/mailbox.c

46

static void tx_prepare(struct mbox_client *cl, void *m)

drivers/firmware/arm_scmi/transports/mailbox.c

48

struct scmi_mailbox *smbox = client_to_scmi_mailbox(cl);

drivers/firmware/arm_scmi/transports/mailbox.c

54

static void rx_callback(struct mbox_client *cl, void *m)

drivers/firmware/arm_scmi/transports/mailbox.c

56

struct scmi_mailbox *smbox = client_to_scmi_mailbox(cl);

drivers/firmware/arm_scmi/transports/mailbox.c

67

if (cl->knows_txdone &&

drivers/firmware/arm_scpi.c

237

struct mbox_client cl;

drivers/firmware/arm_scpi.c

415

struct scpi_chan *ch = container_of(c, struct scpi_chan, cl);

drivers/firmware/arm_scpi.c

429

struct scpi_chan *ch = container_of(c, struct scpi_chan, cl);

drivers/firmware/arm_scpi.c

943

struct mbox_client *cl = &pchan->cl;

drivers/firmware/arm_scpi.c

964

cl->dev = dev;

drivers/firmware/arm_scpi.c

965

cl->rx_callback = scpi_handle_remote_msg;

drivers/firmware/arm_scpi.c

966

cl->tx_prepare = scpi_tx_prepare;

drivers/firmware/arm_scpi.c

967

cl->tx_block = true;

drivers/firmware/arm_scpi.c

968

cl->tx_tout = 20;

drivers/firmware/arm_scpi.c

969

cl->knows_txdone = false; /* controller can't ack */

drivers/firmware/arm_scpi.c

978

pchan->chan = mbox_request_channel(cl, idx);

drivers/firmware/imx/imx-dsp.c

107

cl = &dsp_chan->cl;

drivers/firmware/imx/imx-dsp.c

108

cl->dev = dev;

drivers/firmware/imx/imx-dsp.c

109

cl->tx_block = false;

drivers/firmware/imx/imx-dsp.c

110

cl->knows_txdone = true;

drivers/firmware/imx/imx-dsp.c

111

cl->rx_callback = imx_dsp_handle_rx;

drivers/firmware/imx/imx-dsp.c

115

dsp_chan->ch = mbox_request_channel_byname(cl, chan_name);

drivers/firmware/imx/imx-dsp.c

52

struct imx_dsp_chan *chan = container_of(c, struct imx_dsp_chan, cl);

drivers/firmware/imx/imx-dsp.c

70

dsp_chan->ch = mbox_request_channel_byname(&dsp_chan->cl, dsp_chan->name);

drivers/firmware/imx/imx-dsp.c

91

struct mbox_client *cl;

drivers/firmware/imx/imx-scu-irq.c

202

struct mbox_client *cl;

drivers/firmware/imx/imx-scu-irq.c

222

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

drivers/firmware/imx/imx-scu-irq.c

223

if (!cl)

drivers/firmware/imx/imx-scu-irq.c

226

cl->dev = dev;

drivers/firmware/imx/imx-scu-irq.c

227

cl->rx_callback = imx_scu_irq_callback;

drivers/firmware/imx/imx-scu-irq.c

232

ch = mbox_request_channel_byname(cl, "gip3");

drivers/firmware/imx/imx-scu-irq.c

258

devm_kfree(dev, cl);

drivers/firmware/imx/imx-scu.c

106

static void imx_scu_tx_done(struct mbox_client *cl, void *mssg, int r)

drivers/firmware/imx/imx-scu.c

108

struct imx_sc_chan *sc_chan = container_of(cl, struct imx_sc_chan, cl);

drivers/firmware/imx/imx-scu.c

115

struct imx_sc_chan *sc_chan = container_of(c, struct imx_sc_chan, cl);

drivers/firmware/imx/imx-scu.c

266

struct mbox_client *cl;

drivers/firmware/imx/imx-scu.c

29

struct mbox_client cl;

drivers/firmware/imx/imx-scu.c

297

cl = &sc_chan->cl;

drivers/firmware/imx/imx-scu.c

298

cl->dev = dev;

drivers/firmware/imx/imx-scu.c

299

cl->tx_block = false;

drivers/firmware/imx/imx-scu.c

300

cl->knows_txdone = true;

drivers/firmware/imx/imx-scu.c

301

cl->rx_callback = imx_scu_rx_callback;

drivers/firmware/imx/imx-scu.c

305

cl->tx_done = imx_scu_tx_done;

drivers/firmware/imx/imx-scu.c

312

sc_chan->ch = mbox_request_channel_byname(cl, chan_name);

drivers/firmware/mtk-adsp-ipc.c

54

struct mtk_adsp_chan *chan = container_of(c, struct mtk_adsp_chan, cl);

drivers/firmware/mtk-adsp-ipc.c

75

struct mbox_client *cl;

drivers/firmware/mtk-adsp-ipc.c

87

cl = &adsp_chan->cl;

drivers/firmware/mtk-adsp-ipc.c

88

cl->dev = dev->parent;

drivers/firmware/mtk-adsp-ipc.c

89

cl->tx_block = false;

drivers/firmware/mtk-adsp-ipc.c

90

cl->knows_txdone = false;

drivers/firmware/mtk-adsp-ipc.c

91

cl->tx_prepare = NULL;

drivers/firmware/mtk-adsp-ipc.c

92

cl->rx_callback = mtk_adsp_ipc_recv;

drivers/firmware/mtk-adsp-ipc.c

96

adsp_chan->ch = mbox_request_channel_byname(cl, adsp_mbox_ch_names[i]);

drivers/firmware/raspberrypi.c

124

dev_err(fw->cl.dev, "Request 0x%08x returned status 0x%08x\n",

drivers/firmware/raspberrypi.c

197

dev_info(fw->cl.dev, "Attached to firmware from %ptT\n", &date_and_time);

drivers/firmware/raspberrypi.c

289

fw->cl.dev = dev;

drivers/firmware/raspberrypi.c

29

struct mbox_client cl;

drivers/firmware/raspberrypi.c

290

fw->cl.rx_callback = response_callback;

drivers/firmware/raspberrypi.c

291

fw->cl.tx_block = true;

drivers/firmware/raspberrypi.c

293

fw->chan = mbox_request_channel(&fw->cl, 0);

drivers/firmware/raspberrypi.c

39

static void response_callback(struct mbox_client *cl, void *msg)

drivers/firmware/raspberrypi.c

41

struct rpi_firmware *fw = container_of(cl, struct rpi_firmware, cl);

drivers/firmware/raspberrypi.c

67

dev_err(fw->cl.dev, "mbox_send_message returned %d\n", ret);

drivers/firmware/samsung/exynos-acpm.c

141

struct mbox_client cl;

drivers/firmware/samsung/exynos-acpm.c

187

#define client_to_acpm_chan(c) container_of(c, struct acpm_chan, cl)

drivers/firmware/samsung/exynos-acpm.c

565

struct mbox_client *cl = &achan->cl;

drivers/firmware/samsung/exynos-acpm.c

578

cl->dev = dev;

drivers/firmware/samsung/exynos-acpm.c

580

achan->chan = mbox_request_channel(cl, 0);

drivers/firmware/thead,th1520-aon.c

125

dev_err(aon_chan->cl.dev, "RPC send msg failed: %d\n", ret);

drivers/firmware/thead,th1520-aon.c

130

dev_err(aon_chan->cl.dev, "RPC send msg timeout\n");

drivers/firmware/thead,th1520-aon.c

179

dev_err(aon_chan->cl.dev, "failed to power %s resource %d ret %d\n",

drivers/firmware/thead,th1520-aon.c

20

struct mbox_client cl;

drivers/firmware/thead,th1520-aon.c

204

struct mbox_client *cl;

drivers/firmware/thead,th1520-aon.c

211

cl = &aon_chan->cl;

drivers/firmware/thead,th1520-aon.c

212

cl->dev = dev;

drivers/firmware/thead,th1520-aon.c

213

cl->tx_block = true;

drivers/firmware/thead,th1520-aon.c

214

cl->tx_tout = MAX_TX_TIMEOUT;

drivers/firmware/thead,th1520-aon.c

215

cl->rx_callback = th1520_aon_rx_callback;

drivers/firmware/thead,th1520-aon.c

217

aon_chan->ch = mbox_request_channel_byname(cl, "aon");

drivers/firmware/thead,th1520-aon.c

79

container_of(c, struct th1520_aon_chan, cl);

drivers/firmware/ti_sci.c

116

struct mbox_client cl;

drivers/firmware/ti_sci.c

127

#define cl_to_ti_sci_info(c) container_of(c, struct ti_sci_info, cl)

drivers/firmware/ti_sci.c

235

static void ti_sci_rx_callback(struct mbox_client *cl, void *m)

drivers/firmware/ti_sci.c

237

struct ti_sci_info *info = cl_to_ti_sci_info(cl);

drivers/firmware/ti_sci.c

3917

struct mbox_client *cl;

drivers/firmware/ti_sci.c

3985

cl = &info->cl;

drivers/firmware/ti_sci.c

3986

cl->dev = dev;

drivers/firmware/ti_sci.c

3987

cl->tx_block = false;

drivers/firmware/ti_sci.c

3988

cl->rx_callback = ti_sci_rx_callback;

drivers/firmware/ti_sci.c

3989

cl->knows_txdone = true;

drivers/firmware/ti_sci.c

3994

info->chan_rx = mbox_request_channel_byname(cl, "rx");

drivers/firmware/ti_sci.c

4000

info->chan_tx = mbox_request_channel_byname(cl, "tx");

drivers/firmware/turris-mox-rwtm.c

157

static void mox_rwtm_rx_callback(struct mbox_client *cl, void *data)

drivers/firmware/turris-mox-rwtm.c

159

struct mox_rwtm *rwtm = dev_get_drvdata(cl->dev);

drivers/gpu/drm/bridge/parade-ps8622.c

104

err = ps8622_set(cl, 0x04, 0xe2, 0x80);

drivers/gpu/drm/bridge/parade-ps8622.c

112

err = ps8622_set(cl, 0x04, 0x8a, 0x0c);

drivers/gpu/drm/bridge/parade-ps8622.c

117

err = ps8622_set(cl, 0x04, 0x89, 0x08);

drivers/gpu/drm/bridge/parade-ps8622.c

122

err = ps8622_set(cl, 0x04, 0x71, 0x2d);

drivers/gpu/drm/bridge/parade-ps8622.c

127

err = ps8622_set(cl, 0x04, 0x7d, 0x07);

drivers/gpu/drm/bridge/parade-ps8622.c

132

err = ps8622_set(cl, 0x04, 0x7b, 0x00);

drivers/gpu/drm/bridge/parade-ps8622.c

137

err = ps8622_set(cl, 0x04, 0x7a, 0xfd);

drivers/gpu/drm/bridge/parade-ps8622.c

142

err = ps8622_set(cl, 0x04, 0xc0, 0x12);

drivers/gpu/drm/bridge/parade-ps8622.c

147

err = ps8622_set(cl, 0x04, 0xc1, 0x92);

drivers/gpu/drm/bridge/parade-ps8622.c

152

err = ps8622_set(cl, 0x04, 0xc2, 0x1c);

drivers/gpu/drm/bridge/parade-ps8622.c

157

err = ps8622_set(cl, 0x04, 0x32, 0x80);

drivers/gpu/drm/bridge/parade-ps8622.c

162

err = ps8622_set(cl, 0x04, 0x00, 0xb0);

drivers/gpu/drm/bridge/parade-ps8622.c

167

err = ps8622_set(cl, 0x04, 0x15, 0x40);

drivers/gpu/drm/bridge/parade-ps8622.c

172

err = ps8622_set(cl, 0x04, 0x54, 0x10);

drivers/gpu/drm/bridge/parade-ps8622.c

178

err = ps8622_set(cl, 0x01, 0x02, 0x80 | ps8622->max_lane_count);

drivers/gpu/drm/bridge/parade-ps8622.c

183

err = ps8622_set(cl, 0x01, 0x21, 0x80 | ps8622->lane_count);

drivers/gpu/drm/bridge/parade-ps8622.c

187

err = ps8622_set(cl, 0x00, 0x52, 0x20);

drivers/gpu/drm/bridge/parade-ps8622.c

192

err = ps8622_set(cl, 0x00, 0xf1, 0x03);

drivers/gpu/drm/bridge/parade-ps8622.c

196

err = ps8622_set(cl, 0x00, 0x62, 0x41);

drivers/gpu/drm/bridge/parade-ps8622.c

201

err = ps8622_set(cl, 0x00, 0xf6, 0x01);

drivers/gpu/drm/bridge/parade-ps8622.c

206

err = ps8622_set(cl, 0x00, 0x77, 0x06);

drivers/gpu/drm/bridge/parade-ps8622.c

211

err = ps8622_set(cl, 0x00, 0x4c, 0x04);

drivers/gpu/drm/bridge/parade-ps8622.c

216

err = ps8622_set(cl, 0x01, 0xc0, 0x00);

drivers/gpu/drm/bridge/parade-ps8622.c

221

err = ps8622_set(cl, 0x01, 0xc1, 0x1c);

drivers/gpu/drm/bridge/parade-ps8622.c

226

err = ps8622_set(cl, 0x01, 0xc2, 0xf8);

drivers/gpu/drm/bridge/parade-ps8622.c

231

err = ps8622_set(cl, 0x01, 0xc3, 0x44);

drivers/gpu/drm/bridge/parade-ps8622.c

236

err = ps8622_set(cl, 0x01, 0xc4, 0x32);

drivers/gpu/drm/bridge/parade-ps8622.c

241

err = ps8622_set(cl, 0x01, 0xc5, 0x53);

drivers/gpu/drm/bridge/parade-ps8622.c

246

err = ps8622_set(cl, 0x01, 0xc6, 0x4c);

drivers/gpu/drm/bridge/parade-ps8622.c

251

err = ps8622_set(cl, 0x01, 0xc7, 0x56);

drivers/gpu/drm/bridge/parade-ps8622.c

256

err = ps8622_set(cl, 0x01, 0xc8, 0x35);

drivers/gpu/drm/bridge/parade-ps8622.c

261

err = ps8622_set(cl, 0x01, 0xca, 0x01);

drivers/gpu/drm/bridge/parade-ps8622.c

266

err = ps8622_set(cl, 0x01, 0xcb, 0x05);

drivers/gpu/drm/bridge/parade-ps8622.c

273

err = ps8622_set(cl, 0x01, 0xa5, 0xa0);

drivers/gpu/drm/bridge/parade-ps8622.c

278

err = ps8622_set(cl, 0x01, 0xa7,

drivers/gpu/drm/bridge/parade-ps8622.c

284

err = ps8622_set(cl, 0x01, 0xa5, 0x80);

drivers/gpu/drm/bridge/parade-ps8622.c

290

err = ps8622_set(cl, 0x01, 0xcc, 0x13);

drivers/gpu/drm/bridge/parade-ps8622.c

295

err = ps8622_set(cl, 0x02, 0xb1, 0x20);

drivers/gpu/drm/bridge/parade-ps8622.c

300

err = ps8622_set(cl, 0x04, 0x10, 0x16);

drivers/gpu/drm/bridge/parade-ps8622.c

306

err = ps8622_set(cl, 0x04, 0x59, 0x60);

drivers/gpu/drm/bridge/parade-ps8622.c

311

err = ps8622_set(cl, 0x04, 0x54, 0x14);

drivers/gpu/drm/bridge/parade-ps8622.c

316

err = ps8622_set(cl, 0x02, 0xa1, 0x91);

drivers/gpu/drm/bridge/parade-ps8622.c

85

struct i2c_client *cl = ps8622->client;

drivers/gpu/drm/bridge/parade-ps8622.c

89

err = ps8622_set(cl, 0x02, 0xa1, 0x01);

drivers/gpu/drm/bridge/parade-ps8622.c

94

err = ps8622_set(cl, 0x04, 0x14, 0x01);

drivers/gpu/drm/bridge/parade-ps8622.c

99

err = ps8622_set(cl, 0x04, 0xe3, 0x20);

drivers/gpu/drm/drm_lease.c

478

struct drm_mode_create_lease *cl = data;

drivers/gpu/drm/drm_lease.c

494

if (cl->flags && (cl->flags & ~(O_CLOEXEC | O_NONBLOCK))) {

drivers/gpu/drm/drm_lease.c

507

object_count = cl->object_count;

drivers/gpu/drm/drm_lease.c

512

object_ids = memdup_array_user(u64_to_user_ptr(cl->object_ids),

drivers/gpu/drm/drm_lease.c

532

fd = get_unused_fd_flags(cl->flags & (O_CLOEXEC | O_NONBLOCK));

drivers/gpu/drm/drm_lease.c

566

cl->fd = fd;

drivers/gpu/drm/drm_lease.c

567

cl->lessee_id = lessee->lessee_id;

drivers/gpu/drm/i915/display/vlv_dpio_phy_regs.h

12

#define _CHV_CMN(cl, dw) (0x8100 - (cl) * 0x80 + (dw) * 4)

drivers/gpu/drm/mediatek/mtk_crtc.c

279

static void ddp_cmdq_cb(struct mbox_client *cl, void *mssg)

drivers/gpu/drm/mediatek/mtk_crtc.c

282

struct cmdq_client *cmdq_cl = container_of(cl, struct cmdq_client, client);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv50.c

141

const struct nvkm_enum *en, *re, *cl, *sc;

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv50.c

175

cl = nvkm_enum_find(vm_client, st2);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv50.c

176

if (cl && cl->data) sc = nvkm_enum_find(cl->data, st3);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv50.c

189

st2, cl ? cl->name : "", st3, sc ? sc->name : "",

drivers/gpu/host1x/bus.c

401

struct host1x_client *client, *cl;

drivers/gpu/host1x/bus.c

436

list_for_each_entry_safe(client, cl, &device->clients, list)

drivers/hid/intel-ish-hid/ishtp/bus.c

689

int ishtp_cl_device_bind(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/bus.c

695

if (!cl->fw_client_id || cl->state != ISHTP_CL_CONNECTED)

drivers/hid/intel-ish-hid/ishtp/bus.c

699

spin_lock_irqsave(&cl->dev->device_list_lock, flags);

drivers/hid/intel-ish-hid/ishtp/bus.c

700

list_for_each_entry(cl_device, &cl->dev->device_list,

drivers/hid/intel-ish-hid/ishtp/bus.c

703

cl_device->fw_client->client_id == cl->fw_client_id) {

drivers/hid/intel-ish-hid/ishtp/bus.c

704

cl->device = cl_device;

drivers/hid/intel-ish-hid/ishtp/bus.c

709

spin_unlock_irqrestore(&cl->dev->device_list_lock, flags);

drivers/hid/intel-ish-hid/ishtp/bus.c

727

struct ishtp_cl *cl;

drivers/hid/intel-ish-hid/ishtp/bus.c

731

list_for_each_entry(cl, &ishtp_dev->cl_list, link) {

drivers/hid/intel-ish-hid/ishtp/bus.c

732

cl->state = ISHTP_CL_DISCONNECTED;

drivers/hid/intel-ish-hid/ishtp/bus.c

733

if (warm_reset && cl->device && cl->device->reference_count)

drivers/hid/intel-ish-hid/ishtp/bus.c

741

wake_up_interruptible(&cl->wait_ctrl_res);

drivers/hid/intel-ish-hid/ishtp/bus.c

744

ishtp_cl_flush_queues(cl);

drivers/hid/intel-ish-hid/ishtp/bus.c

747

ishtp_cl_free_rx_ring(cl);

drivers/hid/intel-ish-hid/ishtp/bus.c

748

ishtp_cl_free_tx_ring(cl);

drivers/hid/intel-ish-hid/ishtp/bus.h

49

int ishtp_cl_device_bind(struct ishtp_cl *cl);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

103

spin_lock_irqsave(&cl->free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

104

while (!list_empty(&cl->free_rb_list.list)) {

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

105

rb = list_entry(cl->free_rb_list.list.next, struct ishtp_cl_rb,

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

111

spin_unlock_irqrestore(&cl->free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

113

spin_lock_irqsave(&cl->in_process_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

114

while (!list_empty(&cl->in_process_list.list)) {

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

115

rb = list_entry(cl->in_process_list.list.next,

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

121

spin_unlock_irqrestore(&cl->in_process_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

130

void ishtp_cl_free_tx_ring(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

135

spin_lock_irqsave(&cl->tx_free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

137

while (!list_empty(&cl->tx_free_list.list)) {

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

138

tx_buf = list_entry(cl->tx_free_list.list.next,

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

141

--cl->tx_ring_free_size;

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

145

spin_unlock_irqrestore(&cl->tx_free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

147

spin_lock_irqsave(&cl->tx_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

149

while (!list_empty(&cl->tx_list.list)) {

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

150

tx_buf = list_entry(cl->tx_list.list.next,

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

156

spin_unlock_irqrestore(&cl->tx_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

182

struct ishtp_cl_rb *ishtp_io_rb_init(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

19

int ishtp_cl_alloc_rx_ring(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

191

rb->cl = cl;

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

21

size_t len = cl->device->fw_client->props.max_msg_length;

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

231

struct ishtp_cl *cl;

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

235

if (!rb || !rb->cl)

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

238

cl = rb->cl;

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

239

spin_lock_irqsave(&cl->free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

240

list_add_tail(&rb->list, &cl->free_rb_list.list);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

241

spin_unlock_irqrestore(&cl->free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

247

if (!cl->out_flow_ctrl_creds)

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

248

rets = ishtp_cl_read_start(cl);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

262

struct ishtp_cl_rb *ishtp_cl_rx_get_rb(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

267

spin_lock_irqsave(&cl->in_process_spinlock, rx_flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

268

rb = list_first_entry_or_null(&cl->in_process_list.list,

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

27

for (j = 0; j < cl->rx_ring_size; ++j) {

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

272

spin_unlock_irqrestore(&cl->in_process_spinlock, rx_flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

28

rb = ishtp_io_rb_init(cl);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

36

spin_lock_irqsave(&cl->free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

37

list_add_tail(&rb->list, &cl->free_rb_list.list);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

38

spin_unlock_irqrestore(&cl->free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

44

dev_err(&cl->device->dev, "error in allocating Rx buffers\n");

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

45

ishtp_cl_free_rx_ring(cl);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

57

int ishtp_cl_alloc_tx_ring(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

59

size_t len = cl->device->fw_client->props.max_msg_length;

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

63

cl->tx_ring_free_size = 0;

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

66

for (j = 0; j < cl->tx_ring_size; ++j) {

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

79

spin_lock_irqsave(&cl->tx_free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

80

list_add_tail(&tx_buf->list, &cl->tx_free_list.list);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

81

++cl->tx_ring_free_size;

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

82

spin_unlock_irqrestore(&cl->tx_free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

86

dev_err(&cl->device->dev, "error in allocating Tx pool\n");

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

87

ishtp_cl_free_tx_ring(cl);

drivers/hid/intel-ish-hid/ishtp/client-buffers.c

97

void ishtp_cl_free_rx_ring(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

1004

cl = rb->cl;

drivers/hid/intel-ish-hid/ishtp/client.c

1005

if (!cl || !(cl->host_client_id == ishtp_hdr->host_addr &&

drivers/hid/intel-ish-hid/ishtp/client.c

1006

cl->fw_client_id == ishtp_hdr->fw_addr) ||

drivers/hid/intel-ish-hid/ishtp/client.c

1007

!(cl->state == ISHTP_CL_CONNECTED))

drivers/hid/intel-ish-hid/ishtp/client.c

1013

dev_err(&cl->device->dev,

drivers/hid/intel-ish-hid/ishtp/client.c

1017

cl->status = -ENOMEM;

drivers/hid/intel-ish-hid/ishtp/client.c

1029

dev_err(&cl->device->dev,

drivers/hid/intel-ish-hid/ishtp/client.c

1035

cl->status = -EIO;

drivers/hid/intel-ish-hid/ishtp/client.c

1045

cl->status = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

1049

--cl->out_flow_ctrl_creds;

drivers/hid/intel-ish-hid/ishtp/client.c

1054

spin_lock(&cl->free_list_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

1056

if (!list_empty(&cl->free_rb_list.list)) {

drivers/hid/intel-ish-hid/ishtp/client.c

1057

new_rb = list_entry(cl->free_rb_list.list.next,

drivers/hid/intel-ish-hid/ishtp/client.c

106

struct ishtp_cl *cl;

drivers/hid/intel-ish-hid/ishtp/client.c

1060

spin_unlock(&cl->free_list_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

1061

new_rb->cl = cl;

drivers/hid/intel-ish-hid/ishtp/client.c

1067

ishtp_hbm_cl_flow_control_req(dev, cl);

drivers/hid/intel-ish-hid/ishtp/client.c

1069

spin_unlock(&cl->free_list_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

1073

++cl->recv_msg_num_frags;

drivers/hid/intel-ish-hid/ishtp/client.c

108

cl = kmalloc_obj(struct ishtp_cl);

drivers/hid/intel-ish-hid/ishtp/client.c

109

if (!cl)

drivers/hid/intel-ish-hid/ishtp/client.c

1093

cl = complete_rb->cl;

drivers/hid/intel-ish-hid/ishtp/client.c

1094

cl->ts_rx = ktime_get();

drivers/hid/intel-ish-hid/ishtp/client.c

1095

++cl->recv_msg_cnt_ipc;

drivers/hid/intel-ish-hid/ishtp/client.c

1114

struct ishtp_cl *cl;

drivers/hid/intel-ish-hid/ishtp/client.c

112

ishtp_cl_init(cl, cl_device->ishtp_dev);

drivers/hid/intel-ish-hid/ishtp/client.c

1124

cl = rb->cl;

drivers/hid/intel-ish-hid/ishtp/client.c

1125

if (!cl || !(cl->host_client_id == hbm->host_client_id &&

drivers/hid/intel-ish-hid/ishtp/client.c

1126

cl->fw_client_id == hbm->fw_client_id) ||

drivers/hid/intel-ish-hid/ishtp/client.c

1127

!(cl->state == ISHTP_CL_CONNECTED))

drivers/hid/intel-ish-hid/ishtp/client.c

113

return cl;

drivers/hid/intel-ish-hid/ishtp/client.c

1135

dev_err(&cl->device->dev,

drivers/hid/intel-ish-hid/ishtp/client.c

1139

cl->status = -ENOMEM;

drivers/hid/intel-ish-hid/ishtp/client.c

1151

dev_err(&cl->device->dev,

drivers/hid/intel-ish-hid/ishtp/client.c

1156

cl->status = -EIO;

drivers/hid/intel-ish-hid/ishtp/client.c

1174

cl->status = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

1178

--cl->out_flow_ctrl_creds;

drivers/hid/intel-ish-hid/ishtp/client.c

1183

spin_lock(&cl->free_list_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

1185

if (!list_empty(&cl->free_rb_list.list)) {

drivers/hid/intel-ish-hid/ishtp/client.c

1186

new_rb = list_entry(cl->free_rb_list.list.next,

drivers/hid/intel-ish-hid/ishtp/client.c

1189

spin_unlock(&cl->free_list_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

1190

new_rb->cl = cl;

drivers/hid/intel-ish-hid/ishtp/client.c

1196

ishtp_hbm_cl_flow_control_req(dev, cl);

drivers/hid/intel-ish-hid/ishtp/client.c

1198

spin_unlock(&cl->free_list_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

1202

++cl->recv_msg_num_frags;

drivers/hid/intel-ish-hid/ishtp/client.c

1219

cl = complete_rb->cl;

drivers/hid/intel-ish-hid/ishtp/client.c

1220

cl->ts_rx = ktime_get();

drivers/hid/intel-ish-hid/ishtp/client.c

1221

++cl->recv_msg_cnt_dma;

drivers/hid/intel-ish-hid/ishtp/client.c

1228

void *ishtp_get_client_data(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

123

void ishtp_cl_free(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

1230

return cl->client_data;

drivers/hid/intel-ish-hid/ishtp/client.c

1234

void ishtp_set_client_data(struct ishtp_cl *cl, void *data)

drivers/hid/intel-ish-hid/ishtp/client.c

1236

cl->client_data = data;

drivers/hid/intel-ish-hid/ishtp/client.c

1240

struct ishtp_device *ishtp_get_ishtp_device(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

1242

return cl->dev;

drivers/hid/intel-ish-hid/ishtp/client.c

1246

void ishtp_set_tx_ring_size(struct ishtp_cl *cl, int size)

drivers/hid/intel-ish-hid/ishtp/client.c

1248

cl->tx_ring_size = size;

drivers/hid/intel-ish-hid/ishtp/client.c

1252

void ishtp_set_rx_ring_size(struct ishtp_cl *cl, int size)

drivers/hid/intel-ish-hid/ishtp/client.c

1254

cl->rx_ring_size = size;

drivers/hid/intel-ish-hid/ishtp/client.c

1258

void ishtp_set_connection_state(struct ishtp_cl *cl, int state)

drivers/hid/intel-ish-hid/ishtp/client.c

1260

cl->state = state;

drivers/hid/intel-ish-hid/ishtp/client.c

1264

int ishtp_get_connection_state(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

1266

return cl->state;

drivers/hid/intel-ish-hid/ishtp/client.c

1270

void ishtp_cl_set_fw_client_id(struct ishtp_cl *cl, int fw_client_id)

drivers/hid/intel-ish-hid/ishtp/client.c

1272

cl->fw_client_id = fw_client_id;

drivers/hid/intel-ish-hid/ishtp/client.c

128

if (!cl)

drivers/hid/intel-ish-hid/ishtp/client.c

131

dev = cl->dev;

drivers/hid/intel-ish-hid/ishtp/client.c

136

ishtp_cl_free_rx_ring(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

137

ishtp_cl_free_tx_ring(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

138

kfree(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

154

int ishtp_cl_link(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

160

if (WARN_ON(!cl || !cl->dev))

drivers/hid/intel-ish-hid/ishtp/client.c

163

dev = cl->dev;

drivers/hid/intel-ish-hid/ishtp/client.c

176

dev_err(&cl->device->dev, "id exceeded %d", ISHTP_CLIENTS_MAX);

drivers/hid/intel-ish-hid/ishtp/client.c

181

cl->host_client_id = id;

drivers/hid/intel-ish-hid/ishtp/client.c

187

list_add_tail(&cl->link, &dev->cl_list);

drivers/hid/intel-ish-hid/ishtp/client.c

189

cl->state = ISHTP_CL_INITIALIZING;

drivers/hid/intel-ish-hid/ishtp/client.c

205

void ishtp_cl_unlink(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

212

if (!cl || !cl->dev)

drivers/hid/intel-ish-hid/ishtp/client.c

215

dev = cl->dev;

drivers/hid/intel-ish-hid/ishtp/client.c

219

clear_bit(cl->host_client_id, dev->host_clients_map);

drivers/hid/intel-ish-hid/ishtp/client.c

23

static void ishtp_read_list_flush(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

230

if (cl->host_client_id == pos->host_client_id) {

drivers/hid/intel-ish-hid/ishtp/client.c

247

int ishtp_cl_disconnect(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

251

if (WARN_ON(!cl || !cl->dev))

drivers/hid/intel-ish-hid/ishtp/client.c

254

dev = cl->dev;

drivers/hid/intel-ish-hid/ishtp/client.c

256

dev->print_log(dev, "%s() state %d\n", __func__, cl->state);

drivers/hid/intel-ish-hid/ishtp/client.c

258

if (cl->state != ISHTP_CL_DISCONNECTING) {

drivers/hid/intel-ish-hid/ishtp/client.c

263

if (ishtp_hbm_cl_disconnect_req(dev, cl)) {

drivers/hid/intel-ish-hid/ishtp/client.c

265

dev_err(&cl->device->dev, "failed to disconnect.\n");

drivers/hid/intel-ish-hid/ishtp/client.c

269

wait_event_interruptible_timeout(cl->wait_ctrl_res,

drivers/hid/intel-ish-hid/ishtp/client.c

271

cl->state == ISHTP_CL_DISCONNECTED),

drivers/hid/intel-ish-hid/ishtp/client.c

284

if (cl->state == ISHTP_CL_DISCONNECTED) {

drivers/hid/intel-ish-hid/ishtp/client.c

29

spin_lock_irqsave(&cl->dev->read_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client.c

30

list_for_each_entry_safe(rb, next, &cl->dev->read_list.list, list)

drivers/hid/intel-ish-hid/ishtp/client.c

301

static bool ishtp_cl_is_other_connecting(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

307

if (WARN_ON(!cl || !cl->dev))

drivers/hid/intel-ish-hid/ishtp/client.c

31

if (rb->cl && ishtp_cl_cmp_id(cl, rb->cl)) {

drivers/hid/intel-ish-hid/ishtp/client.c

310

dev = cl->dev;

drivers/hid/intel-ish-hid/ishtp/client.c

313

if ((pos->state == ISHTP_CL_CONNECTING) && (pos != cl) &&

drivers/hid/intel-ish-hid/ishtp/client.c

314

cl->fw_client_id == pos->fw_client_id) {

drivers/hid/intel-ish-hid/ishtp/client.c

33

spin_lock(&cl->free_list_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

335

static int ishtp_cl_connect_to_fw(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

34

list_add_tail(&rb->list, &cl->free_rb_list.list);

drivers/hid/intel-ish-hid/ishtp/client.c

340

if (WARN_ON(!cl || !cl->dev))

drivers/hid/intel-ish-hid/ishtp/client.c

343

dev = cl->dev;

drivers/hid/intel-ish-hid/ishtp/client.c

345

if (ishtp_cl_is_other_connecting(cl)) {

drivers/hid/intel-ish-hid/ishtp/client.c

35

spin_unlock(&cl->free_list_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

350

if (ishtp_hbm_cl_connect_req(dev, cl)) {

drivers/hid/intel-ish-hid/ishtp/client.c

355

rets = wait_event_interruptible_timeout(cl->wait_ctrl_res,

drivers/hid/intel-ish-hid/ishtp/client.c

357

(cl->state == ISHTP_CL_CONNECTED ||

drivers/hid/intel-ish-hid/ishtp/client.c

358

cl->state == ISHTP_CL_DISCONNECTED)),

drivers/hid/intel-ish-hid/ishtp/client.c

37

spin_unlock_irqrestore(&cl->dev->read_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client.c

371

if (cl->state != ISHTP_CL_CONNECTED) {

drivers/hid/intel-ish-hid/ishtp/client.c

377

rets = cl->status;

drivers/hid/intel-ish-hid/ishtp/client.c

383

rets = ishtp_cl_device_bind(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

386

ishtp_cl_disconnect(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

404

int ishtp_cl_connect(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

409

if (!cl || !cl->dev)

drivers/hid/intel-ish-hid/ishtp/client.c

412

dev = cl->dev;

drivers/hid/intel-ish-hid/ishtp/client.c

414

dev->print_log(dev, "%s() current_state = %d\n", __func__, cl->state);

drivers/hid/intel-ish-hid/ishtp/client.c

416

rets = ishtp_cl_connect_to_fw(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

422

rets = ishtp_cl_alloc_rx_ring(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

426

ishtp_cl_disconnect(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

430

rets = ishtp_cl_alloc_tx_ring(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

434

ishtp_cl_free_rx_ring(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

435

ishtp_cl_disconnect(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

442

rets = ishtp_cl_read_start(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

469

int ishtp_cl_establish_connection(struct ishtp_cl *cl, const guid_t *uuid,

drivers/hid/intel-ish-hid/ishtp/client.c

476

if (!cl || !cl->dev)

drivers/hid/intel-ish-hid/ishtp/client.c

479

dev = cl->dev;

drivers/hid/intel-ish-hid/ishtp/client.c

481

ishtp_set_connection_state(cl, ISHTP_CL_INITIALIZING);

drivers/hid/intel-ish-hid/ishtp/client.c

485

cl->host_client_id = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

486

cl->fw_client_id = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

487

cl->ishtp_flow_ctrl_creds = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

488

cl->out_flow_ctrl_creds = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

49

int ishtp_cl_flush_queues(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

490

cl->last_tx_path = CL_TX_PATH_IPC;

drivers/hid/intel-ish-hid/ishtp/client.c

491

cl->last_dma_acked = 1;

drivers/hid/intel-ish-hid/ishtp/client.c

492

cl->last_dma_addr = NULL;

drivers/hid/intel-ish-hid/ishtp/client.c

493

cl->last_ipc_acked = 1;

drivers/hid/intel-ish-hid/ishtp/client.c

495

cl->sending = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

496

cl->err_send_msg = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

497

cl->err_send_fc = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

499

cl->send_msg_cnt_ipc = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

500

cl->send_msg_cnt_dma = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

501

cl->recv_msg_cnt_ipc = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

502

cl->recv_msg_cnt_dma = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

503

cl->recv_msg_num_frags = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

504

cl->ishtp_flow_ctrl_cnt = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

505

cl->out_flow_ctrl_cnt = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

509

rets = ishtp_cl_link(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

51

if (WARN_ON(!cl || !cl->dev))

drivers/hid/intel-ish-hid/ishtp/client.c

523

ishtp_set_tx_ring_size(cl, tx_size);

drivers/hid/intel-ish-hid/ishtp/client.c

524

ishtp_set_rx_ring_size(cl, rx_size);

drivers/hid/intel-ish-hid/ishtp/client.c

526

ishtp_cl_set_fw_client_id(cl, ishtp_get_fw_client_id(fw_client));

drivers/hid/intel-ish-hid/ishtp/client.c

528

ishtp_set_connection_state(cl, ISHTP_CL_CONNECTING);

drivers/hid/intel-ish-hid/ishtp/client.c

535

rets = ishtp_cl_connect_to_fw(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

537

rets = ishtp_cl_read_start(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

54

ishtp_read_list_flush(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

542

rets = ishtp_cl_connect(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

557

void ishtp_cl_destroy_connection(struct ishtp_cl *cl, bool reset)

drivers/hid/intel-ish-hid/ishtp/client.c

559

if (!cl)

drivers/hid/intel-ish-hid/ishtp/client.c

567

ishtp_set_connection_state(cl, ISHTP_CL_DISCONNECTED);

drivers/hid/intel-ish-hid/ishtp/client.c

569

if (cl->state != ISHTP_CL_DISCONNECTED) {

drivers/hid/intel-ish-hid/ishtp/client.c

570

ishtp_set_connection_state(cl, ISHTP_CL_DISCONNECTING);

drivers/hid/intel-ish-hid/ishtp/client.c

571

ishtp_cl_disconnect(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

575

ishtp_cl_unlink(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

576

ishtp_cl_flush_queues(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

590

int ishtp_cl_read_start(struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

599

if (WARN_ON(!cl || !cl->dev))

drivers/hid/intel-ish-hid/ishtp/client.c

602

dev = cl->dev;

drivers/hid/intel-ish-hid/ishtp/client.c

604

if (cl->state != ISHTP_CL_CONNECTED)

drivers/hid/intel-ish-hid/ishtp/client.c

610

i = ishtp_fw_cl_by_id(dev, cl->fw_client_id);

drivers/hid/intel-ish-hid/ishtp/client.c

612

dev_err(&cl->device->dev, "no such fw client %d\n",

drivers/hid/intel-ish-hid/ishtp/client.c

613

cl->fw_client_id);

drivers/hid/intel-ish-hid/ishtp/client.c

618

spin_lock_irqsave(&cl->free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client.c

619

if (list_empty(&cl->free_rb_list.list)) {

drivers/hid/intel-ish-hid/ishtp/client.c

620

dev_warn(&cl->device->dev,

drivers/hid/intel-ish-hid/ishtp/client.c

624

spin_unlock_irqrestore(&cl->free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client.c

627

rb = list_entry(cl->free_rb_list.list.next, struct ishtp_cl_rb, list);

drivers/hid/intel-ish-hid/ishtp/client.c

629

spin_unlock_irqrestore(&cl->free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client.c

631

rb->cl = cl;

drivers/hid/intel-ish-hid/ishtp/client.c

644

if (ishtp_hbm_cl_flow_control_req(dev, cl)) {

drivers/hid/intel-ish-hid/ishtp/client.c

655

spin_lock_irqsave(&cl->free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client.c

656

list_add_tail(&rb->list, &cl->free_rb_list.list);

drivers/hid/intel-ish-hid/ishtp/client.c

657

spin_unlock_irqrestore(&cl->free_list_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client.c

674

int ishtp_cl_send(struct ishtp_cl *cl, uint8_t *buf, size_t length)

drivers/hid/intel-ish-hid/ishtp/client.c

68

static void ishtp_cl_init(struct ishtp_cl *cl, struct ishtp_device *dev)

drivers/hid/intel-ish-hid/ishtp/client.c

682

if (WARN_ON(!cl || !cl->dev))

drivers/hid/intel-ish-hid/ishtp/client.c

685

dev = cl->dev;

drivers/hid/intel-ish-hid/ishtp/client.c

687

if (cl->state != ISHTP_CL_CONNECTED) {

drivers/hid/intel-ish-hid/ishtp/client.c

688

++cl->err_send_msg;

drivers/hid/intel-ish-hid/ishtp/client.c

693

++cl->err_send_msg;

drivers/hid/intel-ish-hid/ishtp/client.c

698

id = ishtp_fw_cl_by_id(dev, cl->fw_client_id);

drivers/hid/intel-ish-hid/ishtp/client.c

70

memset(cl, 0, sizeof(struct ishtp_cl));

drivers/hid/intel-ish-hid/ishtp/client.c

700

++cl->err_send_msg;

drivers/hid/intel-ish-hid/ishtp/client.c

705

++cl->err_send_msg;

drivers/hid/intel-ish-hid/ishtp/client.c

71

init_waitqueue_head(&cl->wait_ctrl_res);

drivers/hid/intel-ish-hid/ishtp/client.c

710

spin_lock_irqsave(&cl->tx_free_list_spinlock, tx_free_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

711

if (list_empty(&cl->tx_free_list.list)) {

drivers/hid/intel-ish-hid/ishtp/client.c

712

spin_unlock_irqrestore(&cl->tx_free_list_spinlock,

drivers/hid/intel-ish-hid/ishtp/client.c

714

++cl->err_send_msg;

drivers/hid/intel-ish-hid/ishtp/client.c

718

cl_msg = list_first_entry(&cl->tx_free_list.list,

drivers/hid/intel-ish-hid/ishtp/client.c

72

spin_lock_init(&cl->free_list_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

721

spin_unlock_irqrestore(&cl->tx_free_list_spinlock,

drivers/hid/intel-ish-hid/ishtp/client.c

73

spin_lock_init(&cl->in_process_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

731

--cl->tx_ring_free_size;

drivers/hid/intel-ish-hid/ishtp/client.c

733

spin_unlock_irqrestore(&cl->tx_free_list_spinlock, tx_free_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

736

spin_lock_irqsave(&cl->tx_list_spinlock, tx_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

737

have_msg_to_send = !list_empty(&cl->tx_list.list);

drivers/hid/intel-ish-hid/ishtp/client.c

738

list_add_tail(&cl_msg->list, &cl->tx_list.list);

drivers/hid/intel-ish-hid/ishtp/client.c

739

spin_unlock_irqrestore(&cl->tx_list_spinlock, tx_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

74

spin_lock_init(&cl->tx_list_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

741

if (!have_msg_to_send && cl->ishtp_flow_ctrl_creds > 0)

drivers/hid/intel-ish-hid/ishtp/client.c

742

ishtp_cl_send_msg(dev, cl);

drivers/hid/intel-ish-hid/ishtp/client.c

75

spin_lock_init(&cl->tx_free_list_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

759

struct ishtp_cl *cl = rb->cl;

drivers/hid/intel-ish-hid/ishtp/client.c

76

spin_lock_init(&cl->fc_spinlock);

drivers/hid/intel-ish-hid/ishtp/client.c

761

spin_lock_irqsave(&cl->in_process_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client.c

766

schedule_work_flag = list_empty(&cl->in_process_list.list);

drivers/hid/intel-ish-hid/ishtp/client.c

767

list_add_tail(&rb->list, &cl->in_process_list.list);

drivers/hid/intel-ish-hid/ishtp/client.c

768

spin_unlock_irqrestore(&cl->in_process_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/client.c

77

INIT_LIST_HEAD(&cl->link);

drivers/hid/intel-ish-hid/ishtp/client.c

771

ishtp_cl_bus_rx_event(cl->device);

drivers/hid/intel-ish-hid/ishtp/client.c

78

cl->dev = dev;

drivers/hid/intel-ish-hid/ishtp/client.c

784

struct ishtp_cl *cl = prm;

drivers/hid/intel-ish-hid/ishtp/client.c

787

struct ishtp_device *dev = (cl ? cl->dev : NULL);

drivers/hid/intel-ish-hid/ishtp/client.c

80

INIT_LIST_HEAD(&cl->free_rb_list.list);

drivers/hid/intel-ish-hid/ishtp/client.c

802

if (cl->state != ISHTP_CL_CONNECTED)

drivers/hid/intel-ish-hid/ishtp/client.c

805

spin_lock_irqsave(&cl->tx_list_spinlock, tx_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

806

if (list_empty(&cl->tx_list.list)) {

drivers/hid/intel-ish-hid/ishtp/client.c

807

spin_unlock_irqrestore(&cl->tx_list_spinlock, tx_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

81

INIT_LIST_HEAD(&cl->tx_list.list);

drivers/hid/intel-ish-hid/ishtp/client.c

811

if (cl->ishtp_flow_ctrl_creds != 1 && !cl->sending) {

drivers/hid/intel-ish-hid/ishtp/client.c

812

spin_unlock_irqrestore(&cl->tx_list_spinlock, tx_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

816

if (!cl->sending) {

drivers/hid/intel-ish-hid/ishtp/client.c

817

--cl->ishtp_flow_ctrl_creds;

drivers/hid/intel-ish-hid/ishtp/client.c

818

cl->last_ipc_acked = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

819

cl->last_tx_path = CL_TX_PATH_IPC;

drivers/hid/intel-ish-hid/ishtp/client.c

82

INIT_LIST_HEAD(&cl->tx_free_list.list);

drivers/hid/intel-ish-hid/ishtp/client.c

820

cl->sending = 1;

drivers/hid/intel-ish-hid/ishtp/client.c

823

cl_msg = list_entry(cl->tx_list.list.next, struct ishtp_cl_tx_ring,

drivers/hid/intel-ish-hid/ishtp/client.c

825

rem = cl_msg->send_buf.size - cl->tx_offs;

drivers/hid/intel-ish-hid/ishtp/client.c

828

ishtp_hdr.host_addr = cl->host_client_id;

drivers/hid/intel-ish-hid/ishtp/client.c

829

ishtp_hdr.fw_addr = cl->fw_client_id;

drivers/hid/intel-ish-hid/ishtp/client.c

83

INIT_LIST_HEAD(&cl->in_process_list.list);

drivers/hid/intel-ish-hid/ishtp/client.c

831

pmsg = cl_msg->send_buf.data + cl->tx_offs;

drivers/hid/intel-ish-hid/ishtp/client.c

839

cl->tx_offs = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

840

cl->sending = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

849

cl->tx_offs += dev->mtu;

drivers/hid/intel-ish-hid/ishtp/client.c

85

cl->rx_ring_size = CL_DEF_RX_RING_SIZE;

drivers/hid/intel-ish-hid/ishtp/client.c

850

rem = cl_msg->send_buf.size - cl->tx_offs;

drivers/hid/intel-ish-hid/ishtp/client.c

855

spin_unlock_irqrestore(&cl->tx_list_spinlock, tx_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

857

spin_lock_irqsave(&cl->tx_free_list_spinlock, tx_free_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

858

list_add_tail(&cl_msg->list, &cl->tx_free_list.list);

drivers/hid/intel-ish-hid/ishtp/client.c

859

++cl->tx_ring_free_size;

drivers/hid/intel-ish-hid/ishtp/client.c

86

cl->tx_ring_size = CL_DEF_TX_RING_SIZE;

drivers/hid/intel-ish-hid/ishtp/client.c

860

spin_unlock_irqrestore(&cl->tx_free_list_spinlock,

drivers/hid/intel-ish-hid/ishtp/client.c

87

cl->tx_ring_free_size = cl->tx_ring_size;

drivers/hid/intel-ish-hid/ishtp/client.c

872

struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

875

if (cl->last_tx_path == CL_TX_PATH_DMA && cl->last_dma_acked == 0)

drivers/hid/intel-ish-hid/ishtp/client.c

878

cl->tx_offs = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

879

ipc_tx_send(cl);

drivers/hid/intel-ish-hid/ishtp/client.c

880

++cl->send_msg_cnt_ipc;

drivers/hid/intel-ish-hid/ishtp/client.c

891

struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

90

cl->last_tx_path = CL_TX_PATH_IPC;

drivers/hid/intel-ish-hid/ishtp/client.c

901

if (cl->last_tx_path == CL_TX_PATH_IPC && cl->last_ipc_acked == 0)

drivers/hid/intel-ish-hid/ishtp/client.c

904

spin_lock_irqsave(&cl->tx_list_spinlock, tx_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

905

if (list_empty(&cl->tx_list.list)) {

drivers/hid/intel-ish-hid/ishtp/client.c

906

spin_unlock_irqrestore(&cl->tx_list_spinlock, tx_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

91

cl->last_dma_acked = 1;

drivers/hid/intel-ish-hid/ishtp/client.c

910

cl_msg = list_entry(cl->tx_list.list.next, struct ishtp_cl_tx_ring,

drivers/hid/intel-ish-hid/ishtp/client.c

915

spin_unlock_irqrestore(&cl->tx_list_spinlock, tx_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

917

ishtp_cl_send_msg_ipc(dev, cl);

drivers/hid/intel-ish-hid/ishtp/client.c

92

cl->last_dma_addr = NULL;

drivers/hid/intel-ish-hid/ishtp/client.c

922

spin_unlock_irqrestore(&cl->tx_list_spinlock, tx_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

924

--cl->ishtp_flow_ctrl_creds;

drivers/hid/intel-ish-hid/ishtp/client.c

925

cl->last_dma_acked = 0;

drivers/hid/intel-ish-hid/ishtp/client.c

926

cl->last_dma_addr = msg_addr;

drivers/hid/intel-ish-hid/ishtp/client.c

927

cl->last_tx_path = CL_TX_PATH_DMA;

drivers/hid/intel-ish-hid/ishtp/client.c

93

cl->last_ipc_acked = 1;

drivers/hid/intel-ish-hid/ishtp/client.c

944

dma_xfer.fw_client_id = cl->fw_client_id;

drivers/hid/intel-ish-hid/ishtp/client.c

945

dma_xfer.host_client_id = cl->host_client_id;

drivers/hid/intel-ish-hid/ishtp/client.c

951

spin_lock_irqsave(&cl->tx_free_list_spinlock, tx_free_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

952

list_add_tail(&cl_msg->list, &cl->tx_free_list.list);

drivers/hid/intel-ish-hid/ishtp/client.c

953

++cl->tx_ring_free_size;

drivers/hid/intel-ish-hid/ishtp/client.c

954

spin_unlock_irqrestore(&cl->tx_free_list_spinlock, tx_free_flags);

drivers/hid/intel-ish-hid/ishtp/client.c

955

++cl->send_msg_cnt_dma;

drivers/hid/intel-ish-hid/ishtp/client.c

965

void ishtp_cl_send_msg(struct ishtp_device *dev, struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/client.c

968

ishtp_cl_send_msg_dma(dev, cl);

drivers/hid/intel-ish-hid/ishtp/client.c

970

ishtp_cl_send_msg_ipc(dev, cl);

drivers/hid/intel-ish-hid/ishtp/client.c

984

struct ishtp_cl *cl;

drivers/hid/intel-ish-hid/ishtp/client.h

113

void ishtp_cl_send_msg(struct ishtp_device *dev, struct ishtp_cl *cl);

drivers/hid/intel-ish-hid/ishtp/client.h

116

int ishtp_cl_read_start(struct ishtp_cl *cl);

drivers/hid/intel-ish-hid/ishtp/client.h

119

int ishtp_cl_alloc_rx_ring(struct ishtp_cl *cl);

drivers/hid/intel-ish-hid/ishtp/client.h

120

int ishtp_cl_alloc_tx_ring(struct ishtp_cl *cl);

drivers/hid/intel-ish-hid/ishtp/client.h

121

void ishtp_cl_free_rx_ring(struct ishtp_cl *cl);

drivers/hid/intel-ish-hid/ishtp/client.h

122

void ishtp_cl_free_tx_ring(struct ishtp_cl *cl);

drivers/hid/intel-ish-hid/ishtp/client.h

136

struct ishtp_cl_rb *ishtp_io_rb_init(struct ishtp_cl *cl);

drivers/hid/intel-ish-hid/ishtp/hbm.c

262

struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/hbm.c

270

spin_lock_irqsave(&cl->fc_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/hbm.c

273

ishtp_hbm_cl_hdr(cl, ISHTP_FLOW_CONTROL_CMD, &flow_ctrl, len);

drivers/hid/intel-ish-hid/ishtp/hbm.c

279

if (cl->out_flow_ctrl_creds) {

drivers/hid/intel-ish-hid/ishtp/hbm.c

280

spin_unlock_irqrestore(&cl->fc_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/hbm.c

284

cl->recv_msg_num_frags = 0;

drivers/hid/intel-ish-hid/ishtp/hbm.c

288

++cl->out_flow_ctrl_creds;

drivers/hid/intel-ish-hid/ishtp/hbm.c

289

++cl->out_flow_ctrl_cnt;

drivers/hid/intel-ish-hid/ishtp/hbm.c

290

cl->ts_out_fc = ktime_get();

drivers/hid/intel-ish-hid/ishtp/hbm.c

291

if (cl->ts_rx) {

drivers/hid/intel-ish-hid/ishtp/hbm.c

292

ktime_t ts_diff = ktime_sub(cl->ts_out_fc, cl->ts_rx);

drivers/hid/intel-ish-hid/ishtp/hbm.c

293

if (ktime_after(ts_diff, cl->ts_max_fc_delay))

drivers/hid/intel-ish-hid/ishtp/hbm.c

294

cl->ts_max_fc_delay = ts_diff;

drivers/hid/intel-ish-hid/ishtp/hbm.c

297

++cl->err_send_fc;

drivers/hid/intel-ish-hid/ishtp/hbm.c

300

spin_unlock_irqrestore(&cl->fc_spinlock, flags);

drivers/hid/intel-ish-hid/ishtp/hbm.c

313

int ishtp_hbm_cl_disconnect_req(struct ishtp_device *dev, struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/hbm.c

320

ishtp_hbm_cl_hdr(cl, CLIENT_DISCONNECT_REQ_CMD, &disconn_req, len);

drivers/hid/intel-ish-hid/ishtp/hbm.c

335

struct ishtp_cl *cl = NULL;

drivers/hid/intel-ish-hid/ishtp/hbm.c

339

list_for_each_entry(cl, &dev->cl_list, link) {

drivers/hid/intel-ish-hid/ishtp/hbm.c

340

if (!rs->status && ishtp_hbm_cl_addr_equal(cl, rs)) {

drivers/hid/intel-ish-hid/ishtp/hbm.c

341

cl->state = ISHTP_CL_DISCONNECTED;

drivers/hid/intel-ish-hid/ishtp/hbm.c

342

wake_up_interruptible(&cl->wait_ctrl_res);

drivers/hid/intel-ish-hid/ishtp/hbm.c

358

int ishtp_hbm_cl_connect_req(struct ishtp_device *dev, struct ishtp_cl *cl)

drivers/hid/intel-ish-hid/ishtp/hbm.c

365

ishtp_hbm_cl_hdr(cl, CLIENT_CONNECT_REQ_CMD, &conn_req, len);

drivers/hid/intel-ish-hid/ishtp/hbm.c

380

struct ishtp_cl *cl = NULL;

drivers/hid/intel-ish-hid/ishtp/hbm.c

384

list_for_each_entry(cl, &dev->cl_list, link) {

drivers/hid/intel-ish-hid/ishtp/hbm.c

385

if (ishtp_hbm_cl_addr_equal(cl, rs)) {

drivers/hid/intel-ish-hid/ishtp/hbm.c

387

cl->state = ISHTP_CL_CONNECTED;

drivers/hid/intel-ish-hid/ishtp/hbm.c

388

cl->status = 0;

drivers/hid/intel-ish-hid/ishtp/hbm.c

390

cl->state = ISHTP_CL_DISCONNECTED;

drivers/hid/intel-ish-hid/ishtp/hbm.c

391

cl->status = -ENODEV;

drivers/hid/intel-ish-hid/ishtp/hbm.c

393

wake_up_interruptible(&cl->wait_ctrl_res);

drivers/hid/intel-ish-hid/ishtp/hbm.c

410

struct ishtp_cl *cl;

drivers/hid/intel-ish-hid/ishtp/hbm.c

417

list_for_each_entry(cl, &dev->cl_list, link) {

drivers/hid/intel-ish-hid/ishtp/hbm.c

418

if (ishtp_hbm_cl_addr_equal(cl, disconnect_req)) {

drivers/hid/intel-ish-hid/ishtp/hbm.c

419

cl->state = ISHTP_CL_DISCONNECTED;

drivers/hid/intel-ish-hid/ishtp/hbm.c

423

ishtp_hbm_cl_hdr(cl, CLIENT_DISCONNECT_RES_CMD, data,

drivers/hid/intel-ish-hid/ishtp/hbm.c

447

struct ishtp_cl *cl;

drivers/hid/intel-ish-hid/ishtp/hbm.c

466

list_for_each_entry(cl, &dev->cl_list, link) {

drivers/hid/intel-ish-hid/ishtp/hbm.c

467

if (cl->fw_client_id == dma_xfer->fw_client_id &&

drivers/hid/intel-ish-hid/ishtp/hbm.c

468

cl->host_client_id == dma_xfer->host_client_id)

drivers/hid/intel-ish-hid/ishtp/hbm.c

475

if (cl->last_dma_addr >=

drivers/hid/intel-ish-hid/ishtp/hbm.c

477

cl->last_dma_addr <

drivers/hid/intel-ish-hid/ishtp/hbm.c

480

cl->last_dma_acked = 1;

drivers/hid/intel-ish-hid/ishtp/hbm.c

482

if (!list_empty(&cl->tx_list.list) &&

drivers/hid/intel-ish-hid/ishtp/hbm.c

483

cl->ishtp_flow_ctrl_creds) {

drivers/hid/intel-ish-hid/ishtp/hbm.c

487

ishtp_cl_send_msg(dev, cl);

drivers/hid/intel-ish-hid/ishtp/hbm.c

55

static inline void ishtp_hbm_cl_hdr(struct ishtp_cl *cl, uint8_t hbm_cmd,

drivers/hid/intel-ish-hid/ishtp/hbm.c

63

cmd->host_addr = cl->host_client_id;

drivers/hid/intel-ish-hid/ishtp/hbm.c

64

cmd->fw_addr = cl->fw_client_id;

drivers/hid/intel-ish-hid/ishtp/hbm.c

76

static inline bool ishtp_hbm_cl_addr_equal(struct ishtp_cl *cl, void *buf)

drivers/hid/intel-ish-hid/ishtp/hbm.c

786

struct ishtp_cl *cl = NULL;

drivers/hid/intel-ish-hid/ishtp/hbm.c

790

list_for_each_entry(cl, &dev->cl_list, link) {

drivers/hid/intel-ish-hid/ishtp/hbm.c

791

if (cl->host_client_id == flow_control->host_addr &&

drivers/hid/intel-ish-hid/ishtp/hbm.c

792

cl->fw_client_id ==

drivers/hid/intel-ish-hid/ishtp/hbm.c

80

return cl->host_client_id == cmd->host_addr &&

drivers/hid/intel-ish-hid/ishtp/hbm.c

800

if (cl->ishtp_flow_ctrl_creds)

drivers/hid/intel-ish-hid/ishtp/hbm.c

803

(unsigned int)cl->fw_client_id,

drivers/hid/intel-ish-hid/ishtp/hbm.c

804

(unsigned int)cl->host_client_id,

drivers/hid/intel-ish-hid/ishtp/hbm.c

805

cl->ishtp_flow_ctrl_creds);

drivers/hid/intel-ish-hid/ishtp/hbm.c

807

++cl->ishtp_flow_ctrl_creds;

drivers/hid/intel-ish-hid/ishtp/hbm.c

808

++cl->ishtp_flow_ctrl_cnt;

drivers/hid/intel-ish-hid/ishtp/hbm.c

809

cl->last_ipc_acked = 1;

drivers/hid/intel-ish-hid/ishtp/hbm.c

81

cl->fw_client_id == cmd->fw_addr;

drivers/hid/intel-ish-hid/ishtp/hbm.c

811

&cl->tx_list_spinlock,

drivers/hid/intel-ish-hid/ishtp/hbm.c

813

if (!list_empty(&cl->tx_list.list)) {

drivers/hid/intel-ish-hid/ishtp/hbm.c

819

&cl->tx_list_spinlock,

drivers/hid/intel-ish-hid/ishtp/hbm.c

821

ishtp_cl_send_msg(dev, cl);

drivers/hid/intel-ish-hid/ishtp/hbm.c

824

&cl->tx_list_spinlock,

drivers/hid/intel-ish-hid/ishtp/hbm.h

297

struct ishtp_cl *cl);

drivers/hid/intel-ish-hid/ishtp/hbm.h

298

int ishtp_hbm_cl_disconnect_req(struct ishtp_device *dev, struct ishtp_cl *cl);

drivers/hid/intel-ish-hid/ishtp/hbm.h

299

int ishtp_hbm_cl_connect_req(struct ishtp_device *dev, struct ishtp_cl *cl);

drivers/hsi/clients/cmt_speech.c

1006

dev_err(&cl->device, "Unable to alloc HSI messages\n");

drivers/hsi/clients/cmt_speech.c

1011

dev_err(&cl->device, "Unable to alloc HSI messages for data\n");

drivers/hsi/clients/cmt_speech.c

1014

err = hsi_claim_port(cl, 1);

drivers/hsi/clients/cmt_speech.c

1016

dev_err(&cl->device,

drivers/hsi/clients/cmt_speech.c

1020

hsi_if->master = ssip_slave_get_master(cl);

drivers/hsi/clients/cmt_speech.c

1023

dev_err(&cl->device, "Could not get HSI master client\n");

drivers/hsi/clients/cmt_speech.c

1028

dev_err(&cl->device,

drivers/hsi/clients/cmt_speech.c

1038

dev_dbg(&cl->device, "cs_hsi_start...done\n");

drivers/hsi/clients/cmt_speech.c

1046

hsi_release_port(cl);

drivers/hsi/clients/cmt_speech.c

1054

dev_dbg(&cl->device, "cs_hsi_start...done/error\n\n");

drivers/hsi/clients/cmt_speech.c

1061

dev_dbg(&hi->cl->device, "cs_hsi_stop\n");

drivers/hsi/clients/cmt_speech.c

1067

hsi_release_port(hi->cl);

drivers/hsi/clients/cmt_speech.c

1295

ret = cs_hsi_start(&cs_char_data.hi, cs_char_data.cl, p, CS_MMAP_SIZE);

drivers/hsi/clients/cmt_speech.c

1297

dev_err(&cs_char_data.cl->device, "Unable to initialize HSI\n");

drivers/hsi/clients/cmt_speech.c

1371

struct hsi_client *cl = to_hsi_client(dev);

drivers/hsi/clients/cmt_speech.c

1377

cs_char_data.cl = cl;

drivers/hsi/clients/cmt_speech.c

1382

cs_char_data.channel_id_cmd = hsi_get_channel_id_by_name(cl,

drivers/hsi/clients/cmt_speech.c

1390

cs_char_data.channel_id_data = hsi_get_channel_id_by_name(cl,

drivers/hsi/clients/cmt_speech.c

144

dev_err(&cs_char_data.cl->device,

drivers/hsi/clients/cmt_speech.c

188

dev_dbg(&cs_char_data.cl->device, "data notification "

drivers/hsi/clients/cmt_speech.c

222

dev_dbg(&cs_char_data.cl->device, "control cmd destructor\n");

drivers/hsi/clients/cmt_speech.c

225

dev_err(&hi->cl->device, "Cmd flushed while driver active\n");

drivers/hsi/clients/cmt_speech.c

299

dev_dbg(&cs_char_data.cl->device, "Freeing data %s message\n", dir);

drivers/hsi/clients/cmt_speech.c

303

dev_err(&cs_char_data.cl->device,

drivers/hsi/clients/cmt_speech.c

370

dev_err(&hi->cl->device, "HSI %s error, msg %d, state %u\n",

drivers/hsi/clients/cmt_speech.c

38

struct hsi_client *cl;

drivers/hsi/clients/cmt_speech.c

433

dev_err(&hi->cl->device, "Control RX error detected\n");

drivers/hsi/clients/cmt_speech.c

438

dev_dbg(&hi->cl->device, "Read on control: %08X\n", cmd);

drivers/hsi/clients/cmt_speech.c

464

dev_err(&hi->cl->device, "Control peek RX error detected\n");

drivers/hsi/clients/cmt_speech.c

471

dev_dbg(&hi->cl->device, "Peek on control complete, reading\n");

drivers/hsi/clients/cmt_speech.c

474

ret = hsi_async_read(hi->cl, msg);

drivers/hsi/clients/cmt_speech.c

486

dev_err(&hi->cl->device, "Control read already pending (%d)\n",

drivers/hsi/clients/cmt_speech.c

492

dev_err(&hi->cl->device, "Control read error (%d)\n",

drivers/hsi/clients/cmt_speech.c

498

dev_dbg(&hi->cl->device, "Issuing RX on control\n");

drivers/hsi/clients/cmt_speech.c

504

ret = hsi_async_read(hi->cl, msg);

drivers/hsi/clients/cmt_speech.c

520

dev_err(&hi->cl->device,

drivers/hsi/clients/cmt_speech.c

537

dev_err(&hi->cl->device,

drivers/hsi/clients/cmt_speech.c

549

dev_dbg(&hi->cl->device,

drivers/hsi/clients/cmt_speech.c

551

ret = hsi_async_write(hi->cl, msg);

drivers/hsi/clients/cmt_speech.c

553

dev_err(&hi->cl->device,

drivers/hsi/clients/cmt_speech.c

566

dev_err(&hi->cl->device, "Restarting control reads\n");

drivers/hsi/clients/cmt_speech.c

611

dev_err(&hi->cl->device, "Data received in invalid state\n");

drivers/hsi/clients/cmt_speech.c

627

ret = hsi_async_read(hi->cl, msg);

drivers/hsi/clients/cmt_speech.c

658

dev_dbg(&hi->cl->device, "Data read already pending (%u)\n",

drivers/hsi/clients/cmt_speech.c

671

ret = hsi_async_read(hi->cl, rxmsg);

drivers/hsi/clients/cmt_speech.c

699

dev_err(&hi->cl->device, "Not configured, aborting\n");

drivers/hsi/clients/cmt_speech.c

704

dev_err(&hi->cl->device, "HSI error, aborting\n");

drivers/hsi/clients/cmt_speech.c

709

dev_err(&hi->cl->device, "Write pending on data channel.\n");

drivers/hsi/clients/cmt_speech.c

721

ret = hsi_async_write(hi->cl, txmsg);

drivers/hsi/clients/cmt_speech.c

772

dev_dbg(&hi->cl->device, "setting wake line to %d (%p)\n",

drivers/hsi/clients/cmt_speech.c

773

new_state, hi->cl);

drivers/hsi/clients/cmt_speech.c

784

dev_dbg(&hi->cl->device, "wake line set to %d (%p)\n",

drivers/hsi/clients/cmt_speech.c

785

new_state, hi->cl);

drivers/hsi/clients/cmt_speech.c

80

struct hsi_client *cl;

drivers/hsi/clients/cmt_speech.c

822

dev_err(&hi->cl->device, "No space for the requested buffer "

drivers/hsi/clients/cmt_speech.c

840

dev_dbg(&hi->cl->device, "hsi_data_sync break, idle\n");

drivers/hsi/clients/cmt_speech.c

864

dev_dbg(&hi->cl->device,

drivers/hsi/clients/cmt_speech.c

874

dev_dbg(&hi->cl->device, "hsi_data_sync done with res %d\n", r);

drivers/hsi/clients/cmt_speech.c

889

dev_dbg(&hi->cl->device,

drivers/hsi/clients/cmt_speech.c

894

dev_dbg(&hi->cl->device,

drivers/hsi/clients/cmt_speech.c

901

dev_dbg(&hi->cl->device, "DL buf #%u at %u\n",

drivers/hsi/clients/cmt_speech.c

908

dev_dbg(&hi->cl->device, "UL buf #%u at %u\n",

drivers/hsi/clients/cmt_speech.c

918

dev_dbg(&hi->cl->device,

drivers/hsi/clients/cmt_speech.c

984

static int cs_hsi_start(struct cs_hsi_iface **hi, struct hsi_client *cl,

drivers/hsi/clients/cmt_speech.c

990

dev_dbg(&cl->device, "cs_hsi_start\n");

drivers/hsi/clients/cmt_speech.c

997

hsi_if->cl = cl;

drivers/hsi/clients/hsi_char.c

105

struct hsi_client *cl;

drivers/hsi/clients/hsi_char.c

227

struct hsc_client_data *cl_data = hsi_client_drvdata(msg->cl);

drivers/hsi/clients/hsi_char.c

247

struct hsc_client_data *cl_data = hsi_client_drvdata(msg->cl);

drivers/hsi/clients/hsi_char.c

267

struct hsc_client_data *cl_data = hsi_client_drvdata(msg->cl);

drivers/hsi/clients/hsi_char.c

275

struct hsc_client_data *cl_data = hsi_client_drvdata(msg->cl);

drivers/hsi/clients/hsi_char.c

294

hsi_flush(msg->cl);

drivers/hsi/clients/hsi_char.c

295

ret = hsi_async_read(msg->cl, msg);

drivers/hsi/clients/hsi_char.c

300

static int hsc_break_request(struct hsi_client *cl)

drivers/hsi/clients/hsi_char.c

302

struct hsc_client_data *cl_data = hsi_client_drvdata(cl);

drivers/hsi/clients/hsi_char.c

317

ret = hsi_async_read(cl, msg);

drivers/hsi/clients/hsi_char.c

324

static int hsc_break_send(struct hsi_client *cl)

drivers/hsi/clients/hsi_char.c

335

ret = hsi_async_write(cl, msg);

drivers/hsi/clients/hsi_char.c

342

static int hsc_rx_set(struct hsi_client *cl, struct hsc_rx_config *rxc)

drivers/hsi/clients/hsi_char.c

355

tmp = cl->rx_cfg;

drivers/hsi/clients/hsi_char.c

356

cl->rx_cfg.mode = rxc->mode;

drivers/hsi/clients/hsi_char.c

357

cl->rx_cfg.num_hw_channels = rxc->channels;

drivers/hsi/clients/hsi_char.c

358

cl->rx_cfg.flow = rxc->flow;

drivers/hsi/clients/hsi_char.c

359

ret = hsi_setup(cl);

drivers/hsi/clients/hsi_char.c

361

cl->rx_cfg = tmp;

drivers/hsi/clients/hsi_char.c

365

hsc_break_request(cl);

drivers/hsi/clients/hsi_char.c

370

static inline void hsc_rx_get(struct hsi_client *cl, struct hsc_rx_config *rxc)

drivers/hsi/clients/hsi_char.c

372

rxc->mode = cl->rx_cfg.mode;

drivers/hsi/clients/hsi_char.c

373

rxc->channels = cl->rx_cfg.num_hw_channels;

drivers/hsi/clients/hsi_char.c

374

rxc->flow = cl->rx_cfg.flow;

drivers/hsi/clients/hsi_char.c

377

static int hsc_tx_set(struct hsi_client *cl, struct hsc_tx_config *txc)

drivers/hsi/clients/hsi_char.c

390

tmp = cl->tx_cfg;

drivers/hsi/clients/hsi_char.c

391

cl->tx_cfg.mode = txc->mode;

drivers/hsi/clients/hsi_char.c

392

cl->tx_cfg.num_hw_channels = txc->channels;

drivers/hsi/clients/hsi_char.c

393

cl->tx_cfg.speed = txc->speed;

drivers/hsi/clients/hsi_char.c

394

cl->tx_cfg.arb_mode = txc->arb_mode;

drivers/hsi/clients/hsi_char.c

395

ret = hsi_setup(cl);

drivers/hsi/clients/hsi_char.c

397

cl->tx_cfg = tmp;

drivers/hsi/clients/hsi_char.c

404

static inline void hsc_tx_get(struct hsi_client *cl, struct hsc_tx_config *txc)

drivers/hsi/clients/hsi_char.c

406

txc->mode = cl->tx_cfg.mode;

drivers/hsi/clients/hsi_char.c

407

txc->channels = cl->tx_cfg.num_hw_channels;

drivers/hsi/clients/hsi_char.c

408

txc->speed = cl->tx_cfg.speed;

drivers/hsi/clients/hsi_char.c

409

txc->arb_mode = cl->tx_cfg.arb_mode;

drivers/hsi/clients/hsi_char.c

425

if (channel->ch >= channel->cl->rx_cfg.num_hw_channels)

drivers/hsi/clients/hsi_char.c

437

ret = hsi_async_read(channel->cl, msg);

drivers/hsi/clients/hsi_char.c

447

hsi_flush(channel->cl);

drivers/hsi/clients/hsi_char.c

482

if (channel->ch >= channel->cl->tx_cfg.num_hw_channels)

drivers/hsi/clients/hsi_char.c

498

ret = hsi_async_write(channel->cl, msg);

drivers/hsi/clients/hsi_char.c

506

hsi_flush(channel->cl);

drivers/hsi/clients/hsi_char.c

535

hsi_flush(channel->cl);

drivers/hsi/clients/hsi_char.c

543

ret = hsi_start_tx(channel->cl);

drivers/hsi/clients/hsi_char.c

547

ret = hsi_stop_tx(channel->cl);

drivers/hsi/clients/hsi_char.c

553

return hsc_break_send(channel->cl);

drivers/hsi/clients/hsi_char.c

557

return hsc_rx_set(channel->cl, &rxc);

drivers/hsi/clients/hsi_char.c

559

hsc_rx_get(channel->cl, &rxc);

drivers/hsi/clients/hsi_char.c

566

return hsc_tx_set(channel->cl, &txc);

drivers/hsi/clients/hsi_char.c

568

hsc_tx_get(channel->cl, &txc);

drivers/hsi/clients/hsi_char.c

584

hsi_flush(cl_data->cl);

drivers/hsi/clients/hsi_char.c

585

hsi_release_port(cl_data->cl);

drivers/hsi/clients/hsi_char.c

610

ret = hsi_claim_port(cl_data->cl, 0);

drivers/hsi/clients/hsi_char.c

613

hsi_setup(cl_data->cl);

drivers/hsi/clients/hsi_char.c

641

hsi_stop_tx(channel->cl);

drivers/hsi/clients/hsi_char.c

680

struct hsi_client *cl = to_hsi_client(dev);

drivers/hsi/clients/hsi_char.c

690

hsc_baseminor = HSC_BASEMINOR(hsi_id(cl), hsi_port_id(cl));

drivers/hsi/clients/hsi_char.c

706

hsi_client_set_drvdata(cl, cl_data);

drivers/hsi/clients/hsi_char.c

709

cl_data->cl = cl;

drivers/hsi/clients/hsi_char.c

713

channel->cl = cl;

drivers/hsi/clients/hsi_char.c

735

struct hsi_client *cl = to_hsi_client(dev);

drivers/hsi/clients/hsi_char.c

736

struct hsc_client_data *cl_data = hsi_client_drvdata(cl);

drivers/hsi/clients/hsi_char.c

741

hsi_client_set_drvdata(cl, NULL);

drivers/hsi/clients/hsi_char.c

85

struct hsi_client *cl;

drivers/hsi/clients/nokia-modem.c

129

struct hsi_client *cl = to_hsi_client(dev);

drivers/hsi/clients/nokia-modem.c

130

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/clients/nokia-modem.c

176

ssip.tx_cfg = cl->tx_cfg;

drivers/hsi/clients/nokia-modem.c

177

ssip.rx_cfg = cl->rx_cfg;

drivers/hsi/clients/nokia-modem.c

199

cmtspeech.tx_cfg = cl->tx_cfg;

drivers/hsi/clients/nokia-modem.c

200

cmtspeech.rx_cfg = cl->rx_cfg;

drivers/hsi/clients/ssi_protocol.c

1003

dev_dbg(&cl->device, "Dropping tx data: CMT is OFFLINE\n");

drivers/hsi/clients/ssi_protocol.c

1009

dev_info(&cl->device, "TX queue full %d\n", ssi->txqueue_len);

drivers/hsi/clients/ssi_protocol.c

1015

dev_dbg(&cl->device, "Start TX qlen %d\n", ssi->txqueue_len);

drivers/hsi/clients/ssi_protocol.c

1016

hsi_start_tx(cl);

drivers/hsi/clients/ssi_protocol.c

1019

dev_dbg(&cl->device, "Start TX on SEND READY qlen %d\n",

drivers/hsi/clients/ssi_protocol.c

1044

dev_err(&ssi->cl->device, "CMT reset detected!\n");

drivers/hsi/clients/ssi_protocol.c

1045

ssip_error(ssi->cl);

drivers/hsi/clients/ssi_protocol.c

1076

struct hsi_client *cl = to_hsi_client(dev);

drivers/hsi/clients/ssi_protocol.c

1091

hsi_client_set_drvdata(cl, ssi);

drivers/hsi/clients/ssi_protocol.c

1092

ssi->cl = cl;

drivers/hsi/clients/ssi_protocol.c

1095

ssi->channel_id_cmd = hsi_get_channel_id_by_name(cl, "mcsaab-control");

drivers/hsi/clients/ssi_protocol.c

1102

ssi->channel_id_data = hsi_get_channel_id_by_name(cl, "mcsaab-data");

drivers/hsi/clients/ssi_protocol.c

1152

struct hsi_client *cl = to_hsi_client(dev);

drivers/hsi/clients/ssi_protocol.c

1153

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

1158

hsi_client_set_drvdata(cl, NULL);

drivers/hsi/clients/ssi_protocol.c

139

struct hsi_client *cl;

drivers/hsi/clients/ssi_protocol.c

217

struct ssi_protocol *ssi = hsi_client_drvdata(msg->cl);

drivers/hsi/clients/ssi_protocol.c

219

dev_dbg(&msg->cl->device, "Release cmd 0x%08x\n", ssip_get_cmd(msg));

drivers/hsi/clients/ssi_protocol.c

331

if (slave->device.parent == ssi->cl->device.parent) {

drivers/hsi/clients/ssi_protocol.c

332

master = ssi->cl;

drivers/hsi/clients/ssi_protocol.c

385

static void ssip_reset(struct hsi_client *cl)

drivers/hsi/clients/ssi_protocol.c

387

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

393

hsi_flush(cl);

drivers/hsi/clients/ssi_protocol.c

396

hsi_stop_tx(cl);

drivers/hsi/clients/ssi_protocol.c

399

ssi_waketest(cl, 0); /* FIXME: To be removed */

drivers/hsi/clients/ssi_protocol.c

413

dev_dbg(&cl->device, "Pending TX data\n");

drivers/hsi/clients/ssi_protocol.c

421

static void ssip_dump_state(struct hsi_client *cl)

drivers/hsi/clients/ssi_protocol.c

423

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

427

dev_err(&cl->device, "Main state: %d\n", ssi->main_state);

drivers/hsi/clients/ssi_protocol.c

428

dev_err(&cl->device, "Recv state: %d\n", ssi->recv_state);

drivers/hsi/clients/ssi_protocol.c

429

dev_err(&cl->device, "Send state: %d\n", ssi->send_state);

drivers/hsi/clients/ssi_protocol.c

430

dev_err(&cl->device, "CMT %s\n", (ssi->main_state == ACTIVE) ?

drivers/hsi/clients/ssi_protocol.c

432

dev_err(&cl->device, "Wake test %d\n",

drivers/hsi/clients/ssi_protocol.c

434

dev_err(&cl->device, "Data RX id: %d\n", ssi->rxid);

drivers/hsi/clients/ssi_protocol.c

435

dev_err(&cl->device, "Data TX id: %d\n", ssi->txid);

drivers/hsi/clients/ssi_protocol.c

438

dev_err(&cl->device, "pending TX data (%p)\n", msg);

drivers/hsi/clients/ssi_protocol.c

442

static void ssip_error(struct hsi_client *cl)

drivers/hsi/clients/ssi_protocol.c

444

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

447

ssip_dump_state(cl);

drivers/hsi/clients/ssi_protocol.c

448

ssip_reset(cl);

drivers/hsi/clients/ssi_protocol.c

451

hsi_async_read(cl, msg);

drivers/hsi/clients/ssi_protocol.c

457

struct hsi_client *cl = ssi->cl;

drivers/hsi/clients/ssi_protocol.c

459

dev_dbg(&cl->device, "Keep alive kick in: m(%d) r(%d) s(%d)\n",

drivers/hsi/clients/ssi_protocol.c

484

struct hsi_client *cl = ssi->cl;

drivers/hsi/clients/ssi_protocol.c

486

dev_err(&cl->device, "Watchdog triggered\n");

drivers/hsi/clients/ssi_protocol.c

487

ssip_error(cl);

drivers/hsi/clients/ssi_protocol.c

493

struct hsi_client *cl = ssi->cl;

drivers/hsi/clients/ssi_protocol.c

495

dev_err(&cl->device, "Watchdog triggered\n");

drivers/hsi/clients/ssi_protocol.c

496

ssip_error(cl);

drivers/hsi/clients/ssi_protocol.c

499

static void ssip_send_bootinfo_req_cmd(struct hsi_client *cl)

drivers/hsi/clients/ssi_protocol.c

501

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

504

dev_dbg(&cl->device, "Issuing BOOT INFO REQ command\n");

drivers/hsi/clients/ssi_protocol.c

508

hsi_async_write(cl, msg);

drivers/hsi/clients/ssi_protocol.c

509

dev_dbg(&cl->device, "Issuing RX command\n");

drivers/hsi/clients/ssi_protocol.c

512

hsi_async_read(cl, msg);

drivers/hsi/clients/ssi_protocol.c

515

static void ssip_start_rx(struct hsi_client *cl)

drivers/hsi/clients/ssi_protocol.c

517

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

520

dev_dbg(&cl->device, "RX start M(%d) R(%d)\n", ssi->main_state,

drivers/hsi/clients/ssi_protocol.c

537

dev_dbg(&cl->device, "Send READY\n");

drivers/hsi/clients/ssi_protocol.c

538

hsi_async_write(cl, msg);

drivers/hsi/clients/ssi_protocol.c

541

static void ssip_stop_rx(struct hsi_client *cl)

drivers/hsi/clients/ssi_protocol.c

543

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

545

dev_dbg(&cl->device, "RX stop M(%d)\n", ssi->main_state);

drivers/hsi/clients/ssi_protocol.c

560

struct hsi_client *cl = msg->cl;

drivers/hsi/clients/ssi_protocol.c

561

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

569

hsi_async_write(cl, data);

drivers/hsi/clients/ssi_protocol.c

572

static int ssip_xmit(struct hsi_client *cl)

drivers/hsi/clients/ssi_protocol.c

574

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

601

dev_dbg(&cl->device, "Send STRANS (%d frames)\n",

drivers/hsi/clients/ssi_protocol.c

604

return hsi_async_write(cl, msg);

drivers/hsi/clients/ssi_protocol.c

641

struct hsi_client *cl = msg->cl;

drivers/hsi/clients/ssi_protocol.c

642

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

646

dev_err(&cl->device, "RX data error\n");

drivers/hsi/clients/ssi_protocol.c

648

ssip_error(cl);

drivers/hsi/clients/ssi_protocol.c

657

static void ssip_rx_bootinforeq(struct hsi_client *cl, u32 cmd)

drivers/hsi/clients/ssi_protocol.c

659

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

668

dev_err(&cl->device, "Boot info req on active state\n");

drivers/hsi/clients/ssi_protocol.c

669

ssip_error(cl);

drivers/hsi/clients/ssi_protocol.c

678

ssi_waketest(cl, 1); /* FIXME: To be removed */

drivers/hsi/clients/ssi_protocol.c

684

dev_dbg(&cl->device, "Send BOOTINFO_RESP\n");

drivers/hsi/clients/ssi_protocol.c

686

dev_warn(&cl->device, "boot info req verid mismatch\n");

drivers/hsi/clients/ssi_protocol.c

690

hsi_async_write(cl, msg);

drivers/hsi/clients/ssi_protocol.c

693

dev_dbg(&cl->device, "Wrong state M(%d)\n", ssi->main_state);

drivers/hsi/clients/ssi_protocol.c

698

static void ssip_rx_bootinforesp(struct hsi_client *cl, u32 cmd)

drivers/hsi/clients/ssi_protocol.c

700

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

703

dev_warn(&cl->device, "boot info resp verid mismatch\n");

drivers/hsi/clients/ssi_protocol.c

710

dev_dbg(&cl->device, "boot info resp ignored M(%d)\n",

drivers/hsi/clients/ssi_protocol.c

715

static void ssip_rx_waketest(struct hsi_client *cl, u32 cmd)

drivers/hsi/clients/ssi_protocol.c

717

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

722

dev_dbg(&cl->device, "wake lines test ignored M(%d)\n",

drivers/hsi/clients/ssi_protocol.c

730

ssi_waketest(cl, 0); /* FIXME: To be removed */

drivers/hsi/clients/ssi_protocol.c

737

dev_notice(&cl->device, "WAKELINES TEST %s\n",

drivers/hsi/clients/ssi_protocol.c

740

ssip_error(cl);

drivers/hsi/clients/ssi_protocol.c

743

dev_dbg(&cl->device, "CMT is ONLINE\n");

drivers/hsi/clients/ssi_protocol.c

748

static void ssip_rx_ready(struct hsi_client *cl)

drivers/hsi/clients/ssi_protocol.c

750

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

754

dev_dbg(&cl->device, "READY on wrong state: S(%d) M(%d)\n",

drivers/hsi/clients/ssi_protocol.c

760

dev_dbg(&cl->device, "Ignore spurious READY command\n");

drivers/hsi/clients/ssi_protocol.c

766

ssip_xmit(cl);

drivers/hsi/clients/ssi_protocol.c

769

static void ssip_rx_strans(struct hsi_client *cl, u32 cmd)

drivers/hsi/clients/ssi_protocol.c

771

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

776

dev_dbg(&cl->device, "RX strans: %d frames\n", len);

drivers/hsi/clients/ssi_protocol.c

779

dev_err(&cl->device, "START TRANS wrong state: S(%d) M(%d)\n",

drivers/hsi/clients/ssi_protocol.c

786

dev_err(&cl->device, "START TRANS id %d expected %d\n",

drivers/hsi/clients/ssi_protocol.c

795

dev_err(&cl->device, "No memory for rx skb\n");

drivers/hsi/clients/ssi_protocol.c

801

dev_err(&cl->device, "No memory for RX data msg\n");

drivers/hsi/clients/ssi_protocol.c

805

hsi_async_read(cl, msg);

drivers/hsi/clients/ssi_protocol.c

811

ssip_error(cl);

drivers/hsi/clients/ssi_protocol.c

816

struct hsi_client *cl = msg->cl;

drivers/hsi/clients/ssi_protocol.c

821

dev_err(&cl->device, "RX error detected\n");

drivers/hsi/clients/ssi_protocol.c

823

ssip_error(cl);

drivers/hsi/clients/ssi_protocol.c

826

hsi_async_read(cl, msg);

drivers/hsi/clients/ssi_protocol.c

827

dev_dbg(&cl->device, "RX cmd: 0x%08x\n", cmd);

drivers/hsi/clients/ssi_protocol.c

833

ssip_rx_bootinforeq(cl, cmd);

drivers/hsi/clients/ssi_protocol.c

836

ssip_rx_bootinforesp(cl, cmd);

drivers/hsi/clients/ssi_protocol.c

839

ssip_rx_waketest(cl, cmd);

drivers/hsi/clients/ssi_protocol.c

842

ssip_rx_strans(cl, cmd);

drivers/hsi/clients/ssi_protocol.c

845

ssip_rx_ready(cl);

drivers/hsi/clients/ssi_protocol.c

848

dev_warn(&cl->device, "command 0x%08x not supported\n", cmd);

drivers/hsi/clients/ssi_protocol.c

855

struct hsi_client *cl = msg->cl;

drivers/hsi/clients/ssi_protocol.c

856

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

865

hsi_stop_tx(cl);

drivers/hsi/clients/ssi_protocol.c

870

ssip_xmit(cl);

drivers/hsi/clients/ssi_protocol.c

877

struct hsi_client *cl = msg->cl;

drivers/hsi/clients/ssi_protocol.c

878

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

882

dev_err(&cl->device, "TX data error\n");

drivers/hsi/clients/ssi_protocol.c

883

ssip_error(cl);

drivers/hsi/clients/ssi_protocol.c

893

dev_dbg(&cl->device, "Send SWBREAK\n");

drivers/hsi/clients/ssi_protocol.c

894

hsi_async_write(cl, cmsg);

drivers/hsi/clients/ssi_protocol.c

897

ssip_xmit(cl);

drivers/hsi/clients/ssi_protocol.c

903

static void ssip_port_event(struct hsi_client *cl, unsigned long event)

drivers/hsi/clients/ssi_protocol.c

907

ssip_start_rx(cl);

drivers/hsi/clients/ssi_protocol.c

910

ssip_stop_rx(cl);

drivers/hsi/clients/ssi_protocol.c

919

struct hsi_client *cl = to_hsi_client(dev->dev.parent);

drivers/hsi/clients/ssi_protocol.c

920

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

923

err = hsi_claim_port(cl, 1);

drivers/hsi/clients/ssi_protocol.c

925

dev_err(&cl->device, "SSI port already claimed\n");

drivers/hsi/clients/ssi_protocol.c

928

err = hsi_register_port_event(cl, ssip_port_event);

drivers/hsi/clients/ssi_protocol.c

930

dev_err(&cl->device, "Register HSI port event failed (%d)\n",

drivers/hsi/clients/ssi_protocol.c

932

hsi_release_port(cl);

drivers/hsi/clients/ssi_protocol.c

935

dev_dbg(&cl->device, "Configuring SSI port\n");

drivers/hsi/clients/ssi_protocol.c

936

hsi_setup(cl);

drivers/hsi/clients/ssi_protocol.c

939

ssi_waketest(cl, 1); /* FIXME: To be removed */

drivers/hsi/clients/ssi_protocol.c

945

ssip_send_bootinfo_req_cmd(cl);

drivers/hsi/clients/ssi_protocol.c

952

struct hsi_client *cl = to_hsi_client(dev->dev.parent);

drivers/hsi/clients/ssi_protocol.c

954

ssip_reset(cl);

drivers/hsi/clients/ssi_protocol.c

955

hsi_unregister_port_event(cl);

drivers/hsi/clients/ssi_protocol.c

956

hsi_release_port(cl);

drivers/hsi/clients/ssi_protocol.c

965

struct hsi_client *cl = ssi->cl;

drivers/hsi/clients/ssi_protocol.c

967

ssip_xmit(cl);

drivers/hsi/clients/ssi_protocol.c

972

struct hsi_client *cl = to_hsi_client(dev->dev.parent);

drivers/hsi/clients/ssi_protocol.c

973

struct ssi_protocol *ssi = hsi_client_drvdata(cl);

drivers/hsi/clients/ssi_protocol.c

995

dev_dbg(&cl->device, "Dropping tx data: No memory\n");

drivers/hsi/controllers/omap_ssi_core.c

140

void ssi_waketest(struct hsi_client *cl, unsigned int enable)

drivers/hsi/controllers/omap_ssi_core.c

142

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/controllers/omap_ssi_core.c

164

struct hsi_port *port = to_hsi_port(msg->cl->device.parent);

drivers/hsi/controllers/omap_ssi_port.c

186

struct hsi_port *port = hsi_get_port(msg->cl);

drivers/hsi/controllers/omap_ssi_port.c

203

struct hsi_port *port = hsi_get_port(msg->cl);

drivers/hsi/controllers/omap_ssi_port.c

28

static inline int hsi_dummy_cl(struct hsi_client *cl __maybe_unused)

drivers/hsi/controllers/omap_ssi_port.c

282

struct hsi_port *port = hsi_get_port(msg->cl);

drivers/hsi/controllers/omap_ssi_port.c

334

struct hsi_port *port = hsi_get_port(msg->cl);

drivers/hsi/controllers/omap_ssi_port.c

372

struct hsi_port *port = hsi_get_port(msg->cl);

drivers/hsi/controllers/omap_ssi_port.c

426

static void ssi_flush_queue(struct list_head *queue, struct hsi_client *cl)

drivers/hsi/controllers/omap_ssi_port.c

433

if ((cl) && (cl != msg->cl))

drivers/hsi/controllers/omap_ssi_port.c

446

static int ssi_setup(struct hsi_client *cl)

drivers/hsi/controllers/omap_ssi_port.c

448

struct hsi_port *port = to_hsi_port(cl->device.parent);

drivers/hsi/controllers/omap_ssi_port.c

460

if (cl->tx_cfg.speed)

drivers/hsi/controllers/omap_ssi_port.c

461

omap_ssi->max_speed = cl->tx_cfg.speed;

drivers/hsi/controllers/omap_ssi_port.c

464

dev_err(&cl->device, "Invalid TX speed %d Mb/s (div %d)\n",

drivers/hsi/controllers/omap_ssi_port.c

465

cl->tx_cfg.speed, div);

drivers/hsi/controllers/omap_ssi_port.c

477

writel_relaxed(cl->tx_cfg.num_hw_channels, sst + SSI_SST_CHANNELS_REG);

drivers/hsi/controllers/omap_ssi_port.c

478

writel_relaxed(cl->tx_cfg.arb_mode, sst + SSI_SST_ARBMODE_REG);

drivers/hsi/controllers/omap_ssi_port.c

479

writel_relaxed(cl->tx_cfg.mode, sst + SSI_SST_MODE_REG);

drivers/hsi/controllers/omap_ssi_port.c

482

writel_relaxed(cl->rx_cfg.num_hw_channels, ssr + SSI_SSR_CHANNELS_REG);

drivers/hsi/controllers/omap_ssi_port.c

486

(cl->rx_cfg.mode != SSI_MODE_FRAME))

drivers/hsi/controllers/omap_ssi_port.c

487

ssi_flush_queue(&omap_port->brkqueue, cl);

drivers/hsi/controllers/omap_ssi_port.c

488

writel_relaxed(cl->rx_cfg.mode, ssr + SSI_SSR_MODE_REG);

drivers/hsi/controllers/omap_ssi_port.c

489

omap_port->channels = max(cl->rx_cfg.num_hw_channels,

drivers/hsi/controllers/omap_ssi_port.c

490

cl->tx_cfg.num_hw_channels);

drivers/hsi/controllers/omap_ssi_port.c

495

omap_port->sst.channels = cl->tx_cfg.num_hw_channels;

drivers/hsi/controllers/omap_ssi_port.c

496

omap_port->sst.arb_mode = cl->tx_cfg.arb_mode;

drivers/hsi/controllers/omap_ssi_port.c

497

omap_port->sst.mode = cl->tx_cfg.mode;

drivers/hsi/controllers/omap_ssi_port.c

501

omap_port->ssr.channels = cl->rx_cfg.num_hw_channels;

drivers/hsi/controllers/omap_ssi_port.c

502

omap_port->ssr.mode = cl->rx_cfg.mode;

drivers/hsi/controllers/omap_ssi_port.c

510

static int ssi_flush(struct hsi_client *cl)

drivers/hsi/controllers/omap_ssi_port.c

512

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/controllers/omap_ssi_port.c

532

if (!msg || (port != hsi_get_port(msg->cl)))

drivers/hsi/controllers/omap_ssi_port.c

587

static int ssi_start_tx(struct hsi_client *cl)

drivers/hsi/controllers/omap_ssi_port.c

589

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/controllers/omap_ssi_port.c

606

static int ssi_stop_tx(struct hsi_client *cl)

drivers/hsi/controllers/omap_ssi_port.c

608

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/controllers/omap_ssi_port.c

654

static void ssi_cleanup_queues(struct hsi_client *cl)

drivers/hsi/controllers/omap_ssi_port.c

656

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/controllers/omap_ssi_port.c

667

ssi_flush_queue(&omap_port->brkqueue, cl);

drivers/hsi/controllers/omap_ssi_port.c

676

if ((msg->cl == cl) && (msg->status == HSI_STATUS_PROCEEDING)) {

drivers/hsi/controllers/omap_ssi_port.c

682

ssi_flush_queue(&omap_port->txqueue[i], cl);

drivers/hsi/controllers/omap_ssi_port.c

689

if ((msg->cl == cl) && (msg->status == HSI_STATUS_PROCEEDING)) {

drivers/hsi/controllers/omap_ssi_port.c

693

ssi_flush_queue(&omap_port->rxqueue[i], cl);

drivers/hsi/controllers/omap_ssi_port.c

714

static void ssi_cleanup_gdd(struct hsi_controller *ssi, struct hsi_client *cl)

drivers/hsi/controllers/omap_ssi_port.c

717

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/controllers/omap_ssi_port.c

726

if ((!msg) || (msg->cl != cl))

drivers/hsi/controllers/omap_ssi_port.c

755

static int ssi_release(struct hsi_client *cl)

drivers/hsi/controllers/omap_ssi_port.c

757

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/controllers/omap_ssi_port.c

764

ssi_cleanup_gdd(ssi, cl);

drivers/hsi/controllers/omap_ssi_port.c

766

ssi_cleanup_queues(cl);

drivers/hsi/hsi_core.c

101

cl->device.archdata = *info->archdata;

drivers/hsi/hsi_core.c

102

if (device_register(&cl->device) < 0) {

drivers/hsi/hsi_core.c

104

put_device(&cl->device);

drivers/hsi/hsi_core.c

108

return cl;

drivers/hsi/hsi_core.c

110

kfree(cl->tx_cfg.channels);

drivers/hsi/hsi_core.c

112

kfree(cl);

drivers/hsi/hsi_core.c

200

struct hsi_client *cl;

drivers/hsi/hsi_core.c

206

cl = kzalloc_obj(*cl);

drivers/hsi/hsi_core.c

207

if (!cl)

drivers/hsi/hsi_core.c

217

&cl->rx_cfg.mode);

drivers/hsi/hsi_core.c

222

&cl->tx_cfg.mode);

drivers/hsi/hsi_core.c

226

cl->rx_cfg.mode = mode;

drivers/hsi/hsi_core.c

227

cl->tx_cfg.mode = mode;

drivers/hsi/hsi_core.c

231

&cl->tx_cfg.speed);

drivers/hsi/hsi_core.c

234

cl->rx_cfg.speed = cl->tx_cfg.speed;

drivers/hsi/hsi_core.c

237

&cl->rx_cfg.flow);

drivers/hsi/hsi_core.c

242

&cl->rx_cfg.arb_mode);

drivers/hsi/hsi_core.c

254

cl->rx_cfg.num_channels = cells;

drivers/hsi/hsi_core.c

255

cl->tx_cfg.num_channels = cells;

drivers/hsi/hsi_core.c

256

cl->rx_cfg.channels = kzalloc_objs(channel, cells);

drivers/hsi/hsi_core.c

257

if (!cl->rx_cfg.channels) {

drivers/hsi/hsi_core.c

262

cl->tx_cfg.channels = kzalloc_objs(channel, cells);

drivers/hsi/hsi_core.c

263

if (!cl->tx_cfg.channels) {

drivers/hsi/hsi_core.c

283

cl->rx_cfg.channels[i] = channel;

drivers/hsi/hsi_core.c

284

cl->tx_cfg.channels[i] = channel;

drivers/hsi/hsi_core.c

287

cl->rx_cfg.num_hw_channels = max_chan + 1;

drivers/hsi/hsi_core.c

288

cl->tx_cfg.num_hw_channels = max_chan + 1;

drivers/hsi/hsi_core.c

290

cl->device.bus = &hsi_bus_type;

drivers/hsi/hsi_core.c

291

cl->device.parent = &port->device;

drivers/hsi/hsi_core.c

292

cl->device.release = hsi_client_release;

drivers/hsi/hsi_core.c

293

cl->device.of_node = client;

drivers/hsi/hsi_core.c

295

dev_set_name(&cl->device, "%s", name);

drivers/hsi/hsi_core.c

296

if (device_register(&cl->device) < 0) {

drivers/hsi/hsi_core.c

298

put_device(&cl->device);

drivers/hsi/hsi_core.c

304

kfree(cl->tx_cfg.channels);

drivers/hsi/hsi_core.c

306

kfree(cl->rx_cfg.channels);

drivers/hsi/hsi_core.c

308

kfree(cl);

drivers/hsi/hsi_core.c

427

static inline int hsi_dummy_cl(struct hsi_client *cl __maybe_unused)

drivers/hsi/hsi_core.c

577

int hsi_async(struct hsi_client *cl, struct hsi_msg *msg)

drivers/hsi/hsi_core.c

579

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/hsi_core.c

581

if (!hsi_port_claimed(cl))

drivers/hsi/hsi_core.c

585

msg->cl = cl;

drivers/hsi/hsi_core.c

598

int hsi_claim_port(struct hsi_client *cl, unsigned int share)

drivers/hsi/hsi_core.c

60

struct hsi_client *cl = to_hsi_client(dev);

drivers/hsi/hsi_core.c

600

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/hsi_core.c

614

cl->pclaimed = 1;

drivers/hsi/hsi_core.c

62

kfree(cl->tx_cfg.channels);

drivers/hsi/hsi_core.c

626

void hsi_release_port(struct hsi_client *cl)

drivers/hsi/hsi_core.c

628

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/hsi_core.c

63

kfree(cl->rx_cfg.channels);

drivers/hsi/hsi_core.c

632

port->release(cl);

drivers/hsi/hsi_core.c

633

if (cl->pclaimed)

drivers/hsi/hsi_core.c

636

cl->pclaimed = 0;

drivers/hsi/hsi_core.c

64

kfree(cl);

drivers/hsi/hsi_core.c

647

struct hsi_client *cl = container_of(nb, struct hsi_client, nb);

drivers/hsi/hsi_core.c

649

(*cl->ehandler)(cl, event);

drivers/hsi/hsi_core.c

666

int hsi_register_port_event(struct hsi_client *cl,

drivers/hsi/hsi_core.c

669

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/hsi_core.c

671

if (!handler || cl->ehandler)

drivers/hsi/hsi_core.c

673

if (!hsi_port_claimed(cl))

drivers/hsi/hsi_core.c

675

cl->ehandler = handler;

drivers/hsi/hsi_core.c

676

cl->nb.notifier_call = hsi_event_notifier_call;

drivers/hsi/hsi_core.c

678

return blocking_notifier_chain_register(&port->n_head, &cl->nb);

drivers/hsi/hsi_core.c

691

int hsi_unregister_port_event(struct hsi_client *cl)

drivers/hsi/hsi_core.c

693

struct hsi_port *port = hsi_get_port(cl);

drivers/hsi/hsi_core.c

696

WARN_ON(!hsi_port_claimed(cl));

drivers/hsi/hsi_core.c

698

err = blocking_notifier_chain_unregister(&port->n_head, &cl->nb);

drivers/hsi/hsi_core.c

70

struct hsi_client *cl;

drivers/hsi/hsi_core.c

700

cl->ehandler = NULL;

drivers/hsi/hsi_core.c

73

cl = kzalloc_obj(*cl);

drivers/hsi/hsi_core.c

738

int hsi_get_channel_id_by_name(struct hsi_client *cl, char *name)

drivers/hsi/hsi_core.c

74

if (!cl)

drivers/hsi/hsi_core.c

742

if (!cl->rx_cfg.channels)

drivers/hsi/hsi_core.c

745

for (i = 0; i < cl->rx_cfg.num_channels; i++)

drivers/hsi/hsi_core.c

746

if (!strcmp(cl->rx_cfg.channels[i].name, name))

drivers/hsi/hsi_core.c

747

return cl->rx_cfg.channels[i].id;

drivers/hsi/hsi_core.c

77

cl->tx_cfg = info->tx_cfg;

drivers/hsi/hsi_core.c

78

if (cl->tx_cfg.channels) {

drivers/hsi/hsi_core.c

79

size = cl->tx_cfg.num_channels * sizeof(*cl->tx_cfg.channels);

drivers/hsi/hsi_core.c

80

cl->tx_cfg.channels = kmemdup(info->tx_cfg.channels, size,

drivers/hsi/hsi_core.c

82

if (!cl->tx_cfg.channels)

drivers/hsi/hsi_core.c

86

cl->rx_cfg = info->rx_cfg;

drivers/hsi/hsi_core.c

87

if (cl->rx_cfg.channels) {

drivers/hsi/hsi_core.c

88

size = cl->rx_cfg.num_channels * sizeof(*cl->rx_cfg.channels);

drivers/hsi/hsi_core.c

89

cl->rx_cfg.channels = kmemdup(info->rx_cfg.channels, size,

drivers/hsi/hsi_core.c

91

if (!cl->rx_cfg.channels)

drivers/hsi/hsi_core.c

95

cl->device.bus = &hsi_bus_type;

drivers/hsi/hsi_core.c

96

cl->device.parent = &port->device;

drivers/hsi/hsi_core.c

97

cl->device.release = hsi_client_release;

drivers/hsi/hsi_core.c

98

dev_set_name(&cl->device, "%s", info->name);

drivers/hsi/hsi_core.c

99

cl->device.platform_data = info->platform_data;

drivers/hwmon/asb100.c

843

struct i2c_client *cl;

drivers/hwmon/asb100.c

857

cl = data->lm75[bank - 1];

drivers/hwmon/asb100.c

862

res = i2c_smbus_read_word_swapped(cl, 0);

drivers/hwmon/asb100.c

865

res = i2c_smbus_read_byte_data(cl, 1);

drivers/hwmon/asb100.c

868

res = i2c_smbus_read_word_swapped(cl, 2);

drivers/hwmon/asb100.c

872

res = i2c_smbus_read_word_swapped(cl, 3);

drivers/hwmon/asb100.c

888

struct i2c_client *cl;

drivers/hwmon/asb100.c

902

cl = data->lm75[bank - 1];

drivers/hwmon/asb100.c

907

i2c_smbus_write_byte_data(cl, 1, value & 0xff);

drivers/hwmon/asb100.c

910

i2c_smbus_write_word_swapped(cl, 2, value);

drivers/hwmon/asb100.c

913

i2c_smbus_write_word_swapped(cl, 3, value);

drivers/hwmon/w83781d.c

1258

struct i2c_client *cl;

drivers/hwmon/w83781d.c

1269

cl = data->lm75[bank - 1];

drivers/hwmon/w83781d.c

1273

res = i2c_smbus_read_word_swapped(cl, 0);

drivers/hwmon/w83781d.c

1276

res = i2c_smbus_read_byte_data(cl, 1);

drivers/hwmon/w83781d.c

1279

res = i2c_smbus_read_word_swapped(cl, 2);

drivers/hwmon/w83781d.c

1283

res = i2c_smbus_read_word_swapped(cl, 3);

drivers/hwmon/w83781d.c

1298

struct i2c_client *cl;

drivers/hwmon/w83781d.c

1310

cl = data->lm75[bank - 1];

drivers/hwmon/w83781d.c

1314

i2c_smbus_write_byte_data(cl, 1, value & 0xff);

drivers/hwmon/w83781d.c

1317

i2c_smbus_write_word_swapped(cl, 2, value);

drivers/hwmon/w83781d.c

1320

i2c_smbus_write_word_swapped(cl, 3, value);

drivers/hwmon/xgene-hwmon.c

472

static void xgene_hwmon_rx_cb(struct mbox_client *cl, void *msg)

drivers/hwmon/xgene-hwmon.c

474

struct xgene_hwmon_dev *ctx = to_xgene_hwmon_dev(cl);

drivers/hwmon/xgene-hwmon.c

522

static void xgene_hwmon_pcc_rx_cb(struct mbox_client *cl, void *msg)

drivers/hwmon/xgene-hwmon.c

524

struct xgene_hwmon_dev *ctx = to_xgene_hwmon_dev(cl);

drivers/hwmon/xgene-hwmon.c

589

static void xgene_hwmon_tx_done(struct mbox_client *cl, void *msg, int ret)

drivers/hwmon/xgene-hwmon.c

592

dev_dbg(cl->dev, "TX did not complete: CMD sent:%x, ret:%d\n",

drivers/hwmon/xgene-hwmon.c

595

dev_dbg(cl->dev, "TX completed. CMD sent:%x, ret:%d\n",

drivers/hwmon/xgene-hwmon.c

612

struct mbox_client *cl;

drivers/hwmon/xgene-hwmon.c

621

cl = &ctx->mbox_client;

drivers/hwmon/xgene-hwmon.c

635

cl->dev = &pdev->dev;

drivers/hwmon/xgene-hwmon.c

636

cl->tx_done = xgene_hwmon_tx_done;

drivers/hwmon/xgene-hwmon.c

637

cl->tx_block = false;

drivers/hwmon/xgene-hwmon.c

638

cl->tx_tout = MBOX_OP_TIMEOUTMS;

drivers/hwmon/xgene-hwmon.c

639

cl->knows_txdone = false;

drivers/hwmon/xgene-hwmon.c

641

cl->rx_callback = xgene_hwmon_rx_cb;

drivers/hwmon/xgene-hwmon.c

642

ctx->mbox_chan = mbox_request_channel(cl, 0);

drivers/hwmon/xgene-hwmon.c

667

cl->rx_callback = xgene_hwmon_pcc_rx_cb;

drivers/hwmon/xgene-hwmon.c

668

pcc_chan = pcc_mbox_request_channel(cl, ctx->mbox_idx);

drivers/hwmon/xgene-hwmon.c

73

#define to_xgene_hwmon_dev(cl) \

drivers/hwmon/xgene-hwmon.c

74

container_of(cl, struct xgene_hwmon_dev, mbox_client)

drivers/i2c/busses/i2c-xgene-slimpro.c

106

#define to_slimpro_i2c_dev(cl) \

drivers/i2c/busses/i2c-xgene-slimpro.c

107

container_of(cl, struct slimpro_i2c_dev, mbox_client)

drivers/i2c/busses/i2c-xgene-slimpro.c

129

static void slimpro_i2c_rx_cb(struct mbox_client *cl, void *mssg)

drivers/i2c/busses/i2c-xgene-slimpro.c

131

struct slimpro_i2c_dev *ctx = to_slimpro_i2c_dev(cl);

drivers/i2c/busses/i2c-xgene-slimpro.c

146

static void slimpro_i2c_pcc_rx_cb(struct mbox_client *cl, void *msg)

drivers/i2c/busses/i2c-xgene-slimpro.c

148

struct slimpro_i2c_dev *ctx = to_slimpro_i2c_dev(cl);

drivers/i2c/busses/i2c-xgene-slimpro.c

440

struct mbox_client *cl;

drivers/i2c/busses/i2c-xgene-slimpro.c

449

cl = &ctx->mbox_client;

drivers/i2c/busses/i2c-xgene-slimpro.c

452

cl->dev = &pdev->dev;

drivers/i2c/busses/i2c-xgene-slimpro.c

454

cl->tx_tout = MAILBOX_OP_TIMEOUT;

drivers/i2c/busses/i2c-xgene-slimpro.c

455

cl->knows_txdone = false;

drivers/i2c/busses/i2c-xgene-slimpro.c

457

cl->tx_block = true;

drivers/i2c/busses/i2c-xgene-slimpro.c

458

cl->rx_callback = slimpro_i2c_rx_cb;

drivers/i2c/busses/i2c-xgene-slimpro.c

459

ctx->mbox_chan = mbox_request_channel(cl, MAILBOX_I2C_INDEX);

drivers/i2c/busses/i2c-xgene-slimpro.c

476

cl->tx_block = false;

drivers/i2c/busses/i2c-xgene-slimpro.c

477

cl->rx_callback = slimpro_i2c_pcc_rx_cb;

drivers/i2c/busses/i2c-xgene-slimpro.c

478

pcc_chan = pcc_mbox_request_channel(cl, ctx->mbox_idx);

drivers/input/tablet/hanwang.c

33

#define HANWANG_TABLET_DEVICE(vend, cl, sc, pr) \

drivers/input/tablet/hanwang.c

37

.bInterfaceClass = (cl), \

drivers/irqchip/irq-mips-gic.c

1000

mips_cm_lock_other(cl, 0, 0, CM_GCR_Cx_OTHER_BLOCK_GLOBAL);

drivers/irqchip/irq-mips-gic.c

1009

pr_warn("No CPU cores on the cluster %d skip it\n", cl);

drivers/irqchip/irq-mips-gic.c

136

unsigned int cpu, cl;

drivers/irqchip/irq-mips-gic.c

141

cl = cpu_cluster(&cpu_data[cpu]);

drivers/irqchip/irq-mips-gic.c

142

if (cl == cpu_cluster(&current_cpu_data))

drivers/irqchip/irq-mips-gic.c

144

if (mips_cps_numcores(cl) == 0)

drivers/irqchip/irq-mips-gic.c

146

mips_cm_lock_other(cl, 0, 0, CM_GCR_Cx_OTHER_BLOCK_GLOBAL);

drivers/irqchip/irq-mips-gic.c

372

unsigned int cpu, cl, old_cpu, old_cl;

drivers/irqchip/irq-mips-gic.c

390

cl = cpu_cluster(&cpu_data[cpu]);

drivers/irqchip/irq-mips-gic.c

398

if (cl != old_cl) {

drivers/irqchip/irq-mips-gic.c

417

if (cl != old_cl)

drivers/irqchip/irq-mips-gic.c

903

unsigned int cpu_vec, i, gicconfig, cl, nclusters;

drivers/irqchip/irq-mips-gic.c

992

for (cl = 0; cl < nclusters; cl++) {

drivers/irqchip/irq-mips-gic.c

993

if (cl == cpu_cluster(&current_cpu_data)) {

drivers/irqchip/irq-mips-gic.c

999

} else if (mips_cps_numcores(cl) != 0) {

drivers/leds/leds-lp5521.c

118

dev_err(&chip->cl->dev, "error in resetting chip\n");

drivers/leds/leds-lp5521.c

122

dev_err(&chip->cl->dev,

drivers/leds/leds-lp5523.c

171

dev_err(&chip->cl->dev,

drivers/leds/leds-lp5562.c

241

dev_err(&chip->cl->dev, "invalid pattern data\n");

drivers/leds/leds-lp5569.c

161

dev_err(&chip->cl->dev,

drivers/leds/leds-lp55xx-common.c

1059

dev_err(&chip->cl->dev, "empty brightness configuration\n");

drivers/leds/leds-lp55xx-common.c

1091

struct device *dev = &chip->cl->dev;

drivers/leds/leds-lp55xx-common.c

1109

struct device *dev = &chip->cl->dev;

drivers/leds/leds-lp55xx-common.c

1303

chip->cl = client;

drivers/leds/leds-lp55xx-common.c

234

dev_err(&chip->cl->dev, "wrong pattern format\n");

drivers/leds/leds-lp55xx-common.c

254

dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n",

drivers/leds/leds-lp55xx-common.c

462

struct device *dev = &chip->cl->dev;

drivers/leds/leds-lp55xx-common.c

482

pdata->label ? : chip->cl->name, chan);

drivers/leds/leds-lp55xx-common.c

537

struct device *dev = &chip->cl->dev;

drivers/leds/leds-lp55xx-common.c

560

const char *name = chip->cl->name;

drivers/leds/leds-lp55xx-common.c

561

struct device *dev = &chip->cl->dev;

drivers/leds/leds-lp55xx-common.c

932

return i2c_smbus_write_byte_data(chip->cl, reg, val);

drivers/leds/leds-lp55xx-common.c

940

ret = i2c_smbus_read_byte_data(chip->cl, reg);

drivers/leds/leds-lp55xx-common.c

969

clk = devm_clk_get_enabled(&chip->cl->dev, "32k_clk");

drivers/leds/leds-lp55xx-common.c

976

dev_info(&chip->cl->dev, "%dHz external clock used\n", LP55XX_CLK_32K);

drivers/leds/leds-lp55xx-common.c

981

dev_info(&chip->cl->dev, "internal clock used\n");

drivers/leds/leds-lp55xx-common.c

998

struct device *dev = &chip->cl->dev;

drivers/leds/leds-lp55xx-common.h

195

struct i2c_client *cl;

drivers/leds/leds-tca6507.c

345

struct i2c_client *cl = tca->client;

drivers/leds/leds-tca6507.c

358

i2c_smbus_write_byte_data(cl, r, file[r]);

drivers/macintosh/therm_windtunnel.c

121

write_reg( struct i2c_client *cl, int reg, int data, int len )

drivers/macintosh/therm_windtunnel.c

133

if( i2c_master_send(cl, tmp, len) != len )

drivers/macintosh/therm_windtunnel.c

139

read_reg( struct i2c_client *cl, int reg, int len )

drivers/macintosh/therm_windtunnel.c

146

if( i2c_master_send(cl, buf, 1) != 1 )

drivers/macintosh/therm_windtunnel.c

148

if( i2c_master_recv(cl, buf, len) != len )

drivers/macintosh/therm_windtunnel.c

358

attach_fan( struct i2c_client *cl )

drivers/macintosh/therm_windtunnel.c

364

if( read_reg(cl, 0x3d, 1) != 0x30 || read_reg(cl, 0x3e, 1) != 0x41 )

drivers/macintosh/therm_windtunnel.c

366

printk("ADM1030 fan controller [@%02x]\n", cl->addr );

drivers/macintosh/therm_windtunnel.c

368

x.fan = cl;

drivers/macintosh/therm_windtunnel.c

374

attach_thermostat( struct i2c_client *cl )

drivers/macintosh/therm_windtunnel.c

381

if( (temp=read_reg(cl, 0, 2)) < 0 )

drivers/macintosh/therm_windtunnel.c

387

hyst_temp = read_reg(cl, 2, 2);

drivers/macintosh/therm_windtunnel.c

388

os_temp = read_reg(cl, 3, 2);

drivers/macintosh/therm_windtunnel.c

392

printk("DS1775 digital thermometer [@%02x]\n", cl->addr );

drivers/macintosh/therm_windtunnel.c

401

x.thermostat = cl;

drivers/macintosh/therm_windtunnel.c

416

do_probe(struct i2c_client *cl)

drivers/macintosh/therm_windtunnel.c

418

const struct i2c_device_id *id = i2c_client_get_device_id(cl);

drivers/macintosh/therm_windtunnel.c

419

struct i2c_adapter *adapter = cl->adapter;

drivers/macintosh/therm_windtunnel.c

428

ret = attach_fan(cl);

drivers/macintosh/therm_windtunnel.c

431

ret = attach_thermostat(cl);

drivers/mailbox/arm_mhuv2.c

559

if (chan->cl) {

drivers/mailbox/arm_mhuv2.c

593

if (!chan->cl) {

drivers/mailbox/arm_mhuv2.c

694

if (!chan->cl) {

drivers/mailbox/arm_mhuv3.c

896

if (!chan->cl) {

drivers/mailbox/arm_mhuv3.c

936

if (!chan->cl) {

drivers/mailbox/cv1800-mailbox.c

63

if (mbox->content[i] && mbox->chans[i].cl) {

drivers/mailbox/exynos-mailbox.c

84

if (mbox->chans[i].cl == NULL)

drivers/mailbox/mailbox.c

100

if (chan->cl->tx_done)

drivers/mailbox/mailbox.c

101

chan->cl->tx_done(chan->cl, mssg, r);

drivers/mailbox/mailbox.c

103

if (r != -ETIME && chan->cl->tx_block)

drivers/mailbox/mailbox.c

117

if (chan->active_req && chan->cl) {

drivers/mailbox/mailbox.c

150

if (chan->cl->rx_callback)

drivers/mailbox/mailbox.c

151

chan->cl->rx_callback(chan->cl, mssg);

drivers/mailbox/mailbox.c

249

if (!chan || !chan->cl)

drivers/mailbox/mailbox.c

260

if (chan->cl->tx_block) {

drivers/mailbox/mailbox.c

264

if (!chan->cl->tx_tout) /* wait forever */

drivers/mailbox/mailbox.c

267

wait = msecs_to_jiffies(chan->cl->tx_tout);

drivers/mailbox/mailbox.c

309

static int __mbox_bind_client(struct mbox_chan *chan, struct mbox_client *cl)

drivers/mailbox/mailbox.c

311

struct device *dev = cl->dev;

drivers/mailbox/mailbox.c

314

if (chan->cl || !try_module_get(chan->mbox->dev->driver->owner)) {

drivers/mailbox/mailbox.c

323

chan->cl = cl;

drivers/mailbox/mailbox.c

326

if (chan->txdone_method == TXDONE_BY_POLL && cl->knows_txdone)

drivers/mailbox/mailbox.c

360

int mbox_bind_client(struct mbox_chan *chan, struct mbox_client *cl)

drivers/mailbox/mailbox.c

364

return __mbox_bind_client(chan, cl);

drivers/mailbox/mailbox.c

385

struct mbox_chan *mbox_request_channel(struct mbox_client *cl, int index)

drivers/mailbox/mailbox.c

396

dev = cl->dev;

drivers/mailbox/mailbox.c

441

ret = __mbox_bind_client(chan, cl);

drivers/mailbox/mailbox.c

450

struct mbox_chan *mbox_request_channel_byname(struct mbox_client *cl,

drivers/mailbox/mailbox.c

453

int index = device_property_match_string(cl->dev, "mbox-names", name);

drivers/mailbox/mailbox.c

456

dev_err(cl->dev, "%s() could not locate channel named \"%s\"\n",

drivers/mailbox/mailbox.c

460

return mbox_request_channel(cl, index);

drivers/mailbox/mailbox.c

471

if (!chan || !chan->cl)

drivers/mailbox/mailbox.c

479

chan->cl = NULL;

drivers/mailbox/mailbox.c

533

chan->cl = NULL;

drivers/mailbox/mailbox.c

67

if (chan->cl->tx_prepare)

drivers/mailbox/mailbox.c

68

chan->cl->tx_prepare(chan->cl, data);

drivers/mailbox/pcc.c

363

pcc_mbox_request_channel(struct mbox_client *cl, int subspace_id)

drivers/mailbox/pcc.c

375

if (IS_ERR(chan) || chan->cl) {

drivers/mailbox/pcc.c

386

rc = mbox_bind_client(chan, cl);

drivers/mailbox/pcc.c

409

if (!chan || !chan->cl)

drivers/mailbox/qcom-cpucp-mbox.c

63

if (chan->cl)

drivers/mailbox/sprd-mailbox.c

146

if (chan->cl)

drivers/mailbox/tegra-hsp.c

903

if (mb->channel.chan->cl)

drivers/md/bcache/bcache.h

251

struct closure cl;

drivers/md/bcache/bcache.h

517

struct closure cl;

drivers/md/bcache/bcache.h

946

struct closure *cl)

drivers/md/bcache/bcache.h

948

closure_get(cl);

drivers/md/bcache/btree.c

1365

struct closure cl;

drivers/md/bcache/btree.c

1374

closure_init_stack(&cl);

drivers/md/bcache/btree.c

1466

bch_btree_node_write(new_nodes[i], &cl);

drivers/md/bcache/btree.c

1473

closure_sync(&cl);

drivers/md/bcache/btree.c

1515

closure_sync(&cl);

drivers/md/bcache/btree.c

2244

struct closure cl;

drivers/md/bcache/btree.c

2247

closure_init_stack(&cl);

drivers/md/bcache/btree.c

2307

bch_btree_node_write(n2, &cl);

drivers/md/bcache/btree.c

2318

bch_btree_node_write(n1, &cl);

drivers/md/bcache/btree.c

2326

bch_btree_node_write(n3, &cl);

drivers/md/bcache/btree.c

2329

closure_sync(&cl);

drivers/md/bcache/btree.c

2334

closure_sync(&cl);

drivers/md/bcache/btree.c

2338

closure_sync(&cl);

drivers/md/bcache/btree.c

2376

struct closure cl;

drivers/md/bcache/btree.c

238

struct closure *cl = bio->bi_private;

drivers/md/bcache/btree.c

2380

closure_init_stack(&cl);

drivers/md/bcache/btree.c

2399

bch_btree_node_write(b, &cl);

drivers/md/bcache/btree.c

240

closure_put(cl);

drivers/md/bcache/btree.c

2405

closure_sync(&cl);

drivers/md/bcache/btree.c

246

struct closure cl;

drivers/md/bcache/btree.c

251

closure_init_stack(&cl);

drivers/md/bcache/btree.c

2522

struct closure cl;

drivers/md/bcache/btree.c

2524

closure_init_stack(&cl);

drivers/md/bcache/btree.c

2539

bch_journal_meta(b->c, &cl);

drivers/md/bcache/btree.c

2540

closure_sync(&cl);

drivers/md/bcache/btree.c

256

bio->bi_private = &cl;

drivers/md/bcache/btree.c

262

closure_sync(&cl);

drivers/md/bcache/btree.c

315

closure_return_with_destructor(cl, btree_node_write_unlock);

drivers/md/bcache/btree.c

323

__btree_node_write_done(&cl->work);

drivers/md/bcache/btree.c

328

struct closure *cl = bio->bi_private;

drivers/md/bcache/btree.c

329

struct btree *b = container_of(cl, struct btree, io);

drivers/md/bcache/btree.c

335

closure_put(cl);

drivers/md/bcache/btree.c

340

struct closure *cl = &b->io;

drivers/md/bcache/btree.c

351

b->bio->bi_private = cl;

drivers/md/bcache/btree.c

387

continue_at(cl, btree_node_write_done, NULL);

drivers/md/bcache/btree.c

398

closure_sync(cl);

drivers/md/bcache/btree.c

399

continue_at_nobarrier(cl, __btree_node_write_done, NULL);

drivers/md/bcache/btree.c

421

closure_init(&b->io, parent ?: &b->c->cl);

drivers/md/bcache/btree.c

454

struct closure cl;

drivers/md/bcache/btree.c

456

closure_init_stack(&cl);

drivers/md/bcache/btree.c

459

bch_btree_node_write(b, &cl);

drivers/md/bcache/btree.c

462

closure_sync(&cl);

drivers/md/bcache/btree.c

608

struct closure cl;

drivers/md/bcache/btree.c

610

closure_init_stack(&cl);

drivers/md/bcache/btree.c

650

__bch_btree_node_write(b, &cl);

drivers/md/bcache/btree.c

653

closure_sync(&cl);

drivers/md/bcache/btree.c

749

struct closure cl;

drivers/md/bcache/btree.c

751

closure_init_stack(&cl);

drivers/md/bcache/io.c

169

struct closure *cl = bio->bi_private;

drivers/md/bcache/io.c

173

closure_put(cl);

drivers/md/bcache/journal.c

30

struct closure *cl = bio->bi_private;

drivers/md/bcache/journal.c

32

closure_put(cl);

drivers/md/bcache/journal.c

43

struct closure cl;

drivers/md/bcache/journal.c

48

closure_init_stack(&cl);

drivers/md/bcache/journal.c

61

bio->bi_private = &cl;

drivers/md/bcache/journal.c

64

closure_bio_submit(ca->set, bio, &cl);

drivers/md/bcache/journal.c

65

closure_sync(&cl);

drivers/md/bcache/journal.c

659

continue_at_nobarrier(cl, journal_write, bch_journal_wq);

drivers/md/bcache/journal.c

687

closure_return_with_destructor(cl, journal_write_unlock);

drivers/md/bcache/journal.c

694

continue_at(cl, journal_write, bch_journal_wq);

drivers/md/bcache/journal.c

744

closure_bio_submit(c, bio, cl);

drivers/md/bcache/journal.c

746

continue_at(cl, journal_write_done, NULL);

drivers/md/bcache/journal.c

754

journal_write_unlocked(&cl->work);

drivers/md/bcache/journal.c

760

struct closure *cl = &c->journal.io;

drivers/md/bcache/journal.c

767

closure_call(cl, journal_write_unlocked, NULL, &c->cl);

drivers/md/bcache/journal.c

778

struct closure cl;

drivers/md/bcache/journal.c

782

closure_init_stack(&cl);

drivers/md/bcache/journal.c

798

closure_wait(&c->journal.wait, &cl);

drivers/md/bcache/journal.c

823

closure_sync(&cl);

drivers/md/bcache/journal.c

885

void bch_journal_meta(struct cache_set *c, struct closure *cl)

drivers/md/bcache/journal.c

892

ref = bch_journal(c, &keys, cl);

drivers/md/bcache/journal.h

167

void bch_journal_meta(struct cache_set *c, struct closure *cl);

drivers/md/bcache/movinggc.c

110

closure_call(&op->cl, bch_data_insert, NULL, cl);

drivers/md/bcache/movinggc.c

113

continue_at(cl, write_moving_finish, op->wq);

drivers/md/bcache/movinggc.c

118

closure_type(io, struct moving_io, cl);

drivers/md/bcache/movinggc.c

123

continue_at(cl, write_moving, io->op.wq);

drivers/md/bcache/movinggc.c

131

struct closure cl;

drivers/md/bcache/movinggc.c

133

closure_init_stack(&cl);

drivers/md/bcache/movinggc.c

16

struct closure cl;

drivers/md/bcache/movinggc.c

172

closure_call(&io->cl, read_moving_submit, NULL, &cl);

drivers/md/bcache/movinggc.c

182

closure_sync(&cl);

drivers/md/bcache/movinggc.c

40

closure_type(io, struct moving_io, cl);

drivers/md/bcache/movinggc.c

47

closure_type(io, struct moving_io, cl);

drivers/md/bcache/movinggc.c

59

closure_return_with_destructor(cl, moving_io_destructor);

drivers/md/bcache/movinggc.c

66

struct moving_io, cl);

drivers/md/bcache/movinggc.c

88

bio->bi_private = &io->cl;

drivers/md/bcache/movinggc.c

94

closure_type(io, struct moving_io, cl);

drivers/md/bcache/request.c

1027

closure_bio_submit(s->iop.c, bio, cl);

drivers/md/bcache/request.c

1048

flush->bi_private = cl;

drivers/md/bcache/request.c

1050

closure_bio_submit(s->iop.c, flush, cl);

drivers/md/bcache/request.c

1057

closure_bio_submit(s->iop.c, bio, cl);

drivers/md/bcache/request.c

1061

closure_call(&s->iop.cl, bch_data_insert, NULL, cl);

drivers/md/bcache/request.c

1062

continue_at(cl, cached_dev_write_complete, NULL);

drivers/md/bcache/request.c

1067

closure_type(s, struct search, cl);

drivers/md/bcache/request.c

1071

bch_journal_meta(s->iop.c, cl);

drivers/md/bcache/request.c

1075

closure_bio_submit(s->iop.c, bio, cl);

drivers/md/bcache/request.c

1077

continue_at(cl, cached_dev_bio_complete, NULL);

drivers/md/bcache/request.c

108

static void bch_data_invalidate(struct closure *cl)

drivers/md/bcache/request.c

110

struct data_insert_op *op = container_of(cl, struct data_insert_op, cl);

drivers/md/bcache/request.c

1215

continue_at_nobarrier(&s->cl,

drivers/md/bcache/request.c

1271

closure_type(s, struct search, cl);

drivers/md/bcache/request.c

1274

bch_journal_meta(s->iop.c, cl);

drivers/md/bcache/request.c

1276

continue_at(cl, search_free, NULL);

drivers/md/bcache/request.c

1282

struct closure *cl;

drivers/md/bcache/request.c

1292

cl = &s->cl;

drivers/md/bcache/request.c

1301

continue_at_nobarrier(&s->cl,

drivers/md/bcache/request.c

1314

closure_call(&s->iop.cl, bch_data_insert, NULL, cl);

drivers/md/bcache/request.c

1316

closure_call(&s->iop.cl, cache_lookup, NULL, cl);

drivers/md/bcache/request.c

1319

continue_at(cl, search_free, NULL);

drivers/md/bcache/request.c

136

continue_at(cl, bch_data_insert_keys, op->wq);

drivers/md/bcache/request.c

141

closure_type(op, struct data_insert_op, cl);

drivers/md/bcache/request.c

166

bch_data_insert_keys(&cl->work);

drivers/md/bcache/request.c

171

struct closure *cl = bio->bi_private;

drivers/md/bcache/request.c

172

struct data_insert_op *op = container_of(cl, struct data_insert_op, cl);

drivers/md/bcache/request.c

179

set_closure_fn(cl, bch_data_insert_error, op->wq);

drivers/md/bcache/request.c

181

set_closure_fn(cl, NULL, NULL);

drivers/md/bcache/request.c

189

closure_type(op, struct data_insert_op, cl);

drivers/md/bcache/request.c

193

return bch_data_invalidate(cl);

drivers/md/bcache/request.c

213

continue_at(cl, bch_data_insert_keys, op->wq);

drivers/md/bcache/request.c

230

n->bi_private = cl;

drivers/md/bcache/request.c

252

continue_at(cl, bch_data_insert_keys, op->wq);

drivers/md/bcache/request.c

272

return bch_data_invalidate(cl);

drivers/md/bcache/request.c

282

continue_at(cl, bch_data_insert_keys, op->wq);

drivers/md/bcache/request.c

284

closure_return(cl);

drivers/md/bcache/request.c

310

closure_type(op, struct data_insert_op, cl);

drivers/md/bcache/request.c

317

bch_data_insert_start(&cl->work);

drivers/md/bcache/request.c

479

struct closure cl;

drivers/md/bcache/request.c

502

struct closure *cl = bio->bi_private;

drivers/md/bcache/request.c

503

struct search *s = container_of(cl, struct search, cl);

drivers/md/bcache/request.c

575

n->bi_private = &s->cl;

drivers/md/bcache/request.c

594

closure_type(s, struct search, iop.cl);

drivers/md/bcache/request.c

60

closure_type(op, struct data_insert_op, cl);

drivers/md/bcache/request.c

605

continue_at(cl, cache_lookup, bcache_wq);

drivers/md/bcache/request.c

630

closure_return(cl);

drivers/md/bcache/request.c

637

struct closure *cl = bio->bi_private;

drivers/md/bcache/request.c

640

struct search *s = container_of(cl, struct search, cl);

drivers/md/bcache/request.c

648

closure_put(cl);

drivers/md/bcache/request.c

653

struct closure *cl = bio->bi_private;

drivers/md/bcache/request.c

656

struct search *s = container_of(cl, struct search, cl);

drivers/md/bcache/request.c

67

op->flush_journal ? cl : NULL);

drivers/md/bcache/request.c

680

closure_put(cl);

drivers/md/bcache/request.c

710

bio->bi_private = &s->cl;

drivers/md/bcache/request.c

717

closure_type(s, struct search, cl);

drivers/md/bcache/request.c

725

closure_debug_destroy(cl);

drivers/md/bcache/request.c

737

closure_init(&s->cl, NULL);

drivers/md/bcache/request.c

768

closure_type(s, struct search, cl);

drivers/md/bcache/request.c

772

search_free(&cl->work);

drivers/md/bcache/request.c

779

closure_type(s, struct search, cl);

drivers/md/bcache/request.c

787

cached_dev_bio_complete(&cl->work);

drivers/md/bcache/request.c

792

closure_type(s, struct search, cl);

drivers/md/bcache/request.c

812

closure_bio_submit(s->iop.c, bio, cl);

drivers/md/bcache/request.c

815

continue_at(cl, cached_dev_read_error_done, NULL);

drivers/md/bcache/request.c

82

continue_at(cl, bch_data_insert_start, op->wq);

drivers/md/bcache/request.c

820

closure_type(s, struct search, cl);

drivers/md/bcache/request.c

829

cached_dev_bio_complete(&cl->work);

drivers/md/bcache/request.c

830

closure_put(&d->cl);

drivers/md/bcache/request.c

835

closure_type(s, struct search, cl);

drivers/md/bcache/request.c

863

closure_get(&dc->disk.cl);

drivers/md/bcache/request.c

869

closure_call(&s->iop.cl, bch_data_insert, NULL, cl);

drivers/md/bcache/request.c

87

closure_return(cl);

drivers/md/bcache/request.c

872

continue_at(cl, cached_dev_cache_miss_done, NULL);

drivers/md/bcache/request.c

877

closure_type(s, struct search, cl);

drivers/md/bcache/request.c

885

continue_at_nobarrier(cl, cached_dev_read_error, bcache_wq);

drivers/md/bcache/request.c

887

continue_at_nobarrier(cl, cached_dev_read_done, bcache_wq);

drivers/md/bcache/request.c

889

continue_at_nobarrier(cl, cached_dev_bio_complete, NULL);

drivers/md/bcache/request.c

939

cache_bio->bi_private = &s->cl;

drivers/md/bcache/request.c

949

closure_bio_submit(s->iop.c, cache_bio, &s->cl);

drivers/md/bcache/request.c

956

miss->bi_private = &s->cl;

drivers/md/bcache/request.c

958

closure_bio_submit(s->iop.c, miss, &s->cl);

drivers/md/bcache/request.c

964

struct closure *cl = &s->cl;

drivers/md/bcache/request.c

966

closure_call(&s->iop.cl, cache_lookup, NULL, cl);

drivers/md/bcache/request.c

967

continue_at(cl, cached_dev_read_done_bh, NULL);

drivers/md/bcache/request.c

974

closure_type(s, struct search, cl);

drivers/md/bcache/request.c

978

cached_dev_bio_complete(&cl->work);

drivers/md/bcache/request.c

983

struct closure *cl = &s->cl;

drivers/md/bcache/request.h

6

struct closure cl;

drivers/md/bcache/stats.c

127

closure_return(&acc->cl);

drivers/md/bcache/stats.c

180

closure_return(&acc->cl);

drivers/md/bcache/stats.c

230

closure_init(&acc->cl, parent);

drivers/md/bcache/stats.h

28

struct closure cl;

drivers/md/bcache/super.c

1076

struct closure cl;

drivers/md/bcache/super.c

1078

closure_init_stack(&cl);

drivers/md/bcache/super.c

1081

bch_write_bdev_super(dc, &cl);

drivers/md/bcache/super.c

1082

closure_sync(&cl);

drivers/md/bcache/super.c

1172

closure_put(&dc->disk.cl);

drivers/md/bcache/super.c

1189

closure_get(&dc->disk.cl);

drivers/md/bcache/super.c

1264

struct closure cl;

drivers/md/bcache/super.c

1266

closure_init_stack(&cl);

drivers/md/bcache/super.c

1276

bch_write_bdev_super(dc, &cl);

drivers/md/bcache/super.c

1277

closure_sync(&cl);

drivers/md/bcache/super.c

1355

closure_type(dc, struct cached_dev, disk.cl);

drivers/md/bcache/super.c

1389

closure_type(dc, struct cached_dev, disk.cl);

drivers/md/bcache/super.c

1399

continue_at(cl, cached_dev_free, system_percpu_wq);

drivers/md/bcache/super.c

1410

closure_init(&dc->disk.cl, NULL);

drivers/md/bcache/super.c

1411

set_closure_fn(&dc->disk.cl, cached_dev_flush, system_percpu_wq);

drivers/md/bcache/super.c

1417

bch_cache_accounting_init(&dc->accounting, &dc->disk.cl);

drivers/md/bcache/super.c

1505

closure_type(d, struct bcache_device, cl);

drivers/md/bcache/super.c

1518

closure_type(d, struct bcache_device, cl);

drivers/md/bcache/super.c

1524

continue_at(cl, flash_dev_free, system_percpu_wq);

drivers/md/bcache/super.c

1534

closure_init(&d->cl, NULL);

drivers/md/bcache/super.c

1535

set_closure_fn(&d->cl, flash_dev_flush, system_percpu_wq);

drivers/md/bcache/super.c

1675

closure_type(c, struct cache_set, cl);

drivers/md/bcache/super.c

1710

closure_debug_destroy(&c->cl);

drivers/md/bcache/super.c

1757

closure_return(cl);

drivers/md/bcache/super.c

1843

continue_at(cl, cache_set_flush, system_percpu_wq);

drivers/md/bcache/super.c

1872

closure_init(&c->cl, NULL);

drivers/md/bcache/super.c

1873

set_closure_fn(&c->cl, cache_set_free, system_percpu_wq);

drivers/md/bcache/super.c

1875

closure_init(&c->caching, &c->cl);

drivers/md/bcache/super.c

1879

closure_set_stopped(&c->cl);

drivers/md/bcache/super.c

1880

closure_put(&c->cl);

drivers/md/bcache/super.c

1885

bch_cache_accounting_init(&c->accounting, &c->cl);

drivers/md/bcache/super.c

1983

struct closure cl;

drivers/md/bcache/super.c

1987

closure_init_stack(&cl);

drivers/md/bcache/super.c

2034

err = uuid_read(c, j, &cl);

drivers/md/bcache/super.c

2104

bch_btree_node_write(c->root, &cl);

drivers/md/bcache/super.c

2118

bch_journal_meta(c, &cl);

drivers/md/bcache/super.c

2125

closure_sync(&cl);

drivers/md/bcache/super.c

2147

closure_sync(&cl);

drivers/md/bcache/super.c

338

struct closure *cl = &dc->sb_write;

drivers/md/bcache/super.c

342

closure_init(cl, parent);

drivers/md/bcache/super.c

348

closure_get(cl);

drivers/md/bcache/super.c

352

closure_return_with_destructor(cl, bch_write_bdev_super_unlock);

drivers/md/bcache/super.c

374

struct closure *cl = &c->sb_write;

drivers/md/bcache/super.c

380

closure_init(cl, &c->cl);

drivers/md/bcache/super.c

391

closure_get(cl);

drivers/md/bcache/super.c

394

closure_return_with_destructor(cl, bcache_write_super_unlock);

drivers/md/bcache/super.c

401

struct closure *cl = bio->bi_private;

drivers/md/bcache/super.c

402

struct cache_set *c = container_of(cl, struct cache_set, uuid_write);

drivers/md/bcache/super.c

406

closure_put(cl);

drivers/md/bcache/super.c

419

struct closure *cl = &c->uuid_write;

drivers/md/bcache/super.c

426

closure_init(cl, parent);

drivers/md/bcache/super.c

435

bio->bi_private = cl;

drivers/md/bcache/super.c

454

closure_return_with_destructor(cl, uuid_io_unlock);

drivers/md/bcache/super.c

457

static char *uuid_read(struct cache_set *c, struct jset *j, struct closure *cl)

drivers/md/bcache/super.c

465

uuid_io(c, REQ_OP_READ, k, cl);

drivers/md/bcache/super.c

472

closure_sync(cl);

drivers/md/bcache/super.c

501

struct closure cl;

drivers/md/bcache/super.c

505

closure_init_stack(&cl);

drivers/md/bcache/super.c

513

uuid_io(c, REQ_OP_WRITE, &k.key, &cl);

drivers/md/bcache/super.c

514

closure_sync(&cl);

drivers/md/bcache/super.c

592

struct closure *cl = &ca->prio;

drivers/md/bcache/super.c

595

closure_init_stack(cl);

drivers/md/bcache/super.c

607

closure_sync(cl);

drivers/md/bcache/super.c

614

struct closure cl;

drivers/md/bcache/super.c

633

closure_init_stack(&cl);

drivers/md/bcache/super.c

672

bch_journal_meta(ca->set, &cl);

drivers/md/bcache/super.c

673

closure_sync(&cl);

drivers/md/bcache/super.c

742

closure_get(&d->cl);

drivers/md/bcache/super.c

750

closure_put(&d->cl);

drivers/md/bcache/super.c

785

closure_queue(&d->cl);

drivers/md/bcache/super.c

894

closure_debug_destroy(&d->cl);

drivers/md/bcache/writeback.c

323

struct closure cl;

drivers/md/bcache/writeback.c

346

closure_type(io, struct dirty_io, cl);

drivers/md/bcache/writeback.c

353

closure_type(io, struct dirty_io, cl);

drivers/md/bcache/writeback.c

387

closure_return_with_destructor(cl, dirty_io_destructor);

drivers/md/bcache/writeback.c

400

closure_put(&io->cl);

drivers/md/bcache/writeback.c

405

closure_type(io, struct dirty_io, cl);

drivers/md/bcache/writeback.c

413

closure_wait(&dc->writeback_ordering_wait, cl);

drivers/md/bcache/writeback.c

423

continue_at(cl, write_dirty, io->dc->writeback_write_wq);

drivers/md/bcache/writeback.c

443

closure_bio_submit(io->dc->disk.c, &io->bio, cl);

drivers/md/bcache/writeback.c

449

continue_at(cl, write_dirty_finish, io->dc->writeback_write_wq);

drivers/md/bcache/writeback.c

467

closure_type(io, struct dirty_io, cl);

drivers/md/bcache/writeback.c

469

closure_bio_submit(io->dc->disk.c, &io->bio, cl);

drivers/md/bcache/writeback.c

471

continue_at(cl, write_dirty, io->dc->writeback_write_wq);

drivers/md/bcache/writeback.c

481

struct closure cl;

drivers/md/bcache/writeback.c

486

closure_init_stack(&cl);

drivers/md/bcache/writeback.c

567

closure_call(&io->cl, read_dirty_submit, NULL, &cl);

drivers/md/bcache/writeback.c

591

closure_sync(&cl);

drivers/md/bcache/writeback.c

787

struct closure cl;

drivers/md/bcache/writeback.c

789

closure_init_stack(&cl);

drivers/md/bcache/writeback.c

793

bch_write_bdev_super(dc, &cl);

drivers/md/bcache/writeback.c

794

closure_sync(&cl);

drivers/media/pci/pt1/pt1.c

1001

cl = dvb_module_probe("dvb_pll",

drivers/media/pci/pt1/pt1.c

1005

if (!cl)

drivers/media/pci/pt1/pt1.c

1007

pt1->adaps[i]->tuner_i2c_client = cl;

drivers/media/pci/pt1/pt1.c

191

static int config_demod(struct i2c_client *cl, enum pt1_fe_clk clk)

drivers/media/pci/pt1/pt1.c

198

is_sat = !strncmp(cl->name, TC90522_I2C_DEV_SAT,

drivers/media/pci/pt1/pt1.c

205

msg[0].addr = cl->addr;

drivers/media/pci/pt1/pt1.c

210

msg[1].addr = cl->addr;

drivers/media/pci/pt1/pt1.c

214

ret = i2c_transfer(cl->adapter, msg, 2);

drivers/media/pci/pt1/pt1.c

241

ret = i2c_master_send(cl, cfg_data[i], 2);

drivers/media/pci/pt1/pt1.c

256

struct i2c_client *cl;

drivers/media/pci/pt1/pt1.c

263

cl = pt1->adaps[i]->demod_i2c_client;

drivers/media/pci/pt1/pt1.c

264

if (strncmp(cl->name, TC90522_I2C_DEV_TER,

drivers/media/pci/pt1/pt1.c

268

ret = i2c_master_send(cl, buf, 2);

drivers/media/pci/pt1/pt1.c

275

cl = pt1->adaps[i]->demod_i2c_client;

drivers/media/pci/pt1/pt1.c

276

if (strncmp(cl->name, TC90522_I2C_DEV_SAT,

drivers/media/pci/pt1/pt1.c

280

ret = i2c_master_send(cl, buf, 2);

drivers/media/pci/pt1/pt1.c

972

struct i2c_client *cl;

drivers/media/pci/pt1/pt1.c

979

cl = dvb_module_probe("tc90522", info->type, &pt1->i2c_adap,

drivers/media/pci/pt1/pt1.c

981

if (!cl)

drivers/media/pci/pt1/pt1.c

983

pt1->adaps[i]->demod_i2c_client = cl;

drivers/media/pci/pt1/pt1.c

985

if (!strncmp(cl->name, TC90522_I2C_DEV_SAT,

drivers/media/pci/pt1/pt1.c

992

cl = dvb_module_probe("qm1d1b0004",

drivers/media/pci/pt3/pt3.c

372

struct i2c_client *cl;

drivers/media/pci/pt3/pt3.c

381

cl = dvb_module_probe("tc90522", info->type, &pt3->i2c_adap,

drivers/media/pci/pt3/pt3.c

383

if (!cl)

drivers/media/pci/pt3/pt3.c

385

pt3->adaps[i]->i2c_demod = cl;

drivers/media/pci/pt3/pt3.c

387

if (!strncmp(cl->name, TC90522_I2C_DEV_SAT,

drivers/media/pci/pt3/pt3.c

394

cl = dvb_module_probe("qm1d1c0042", info->type, cfg.tuner_i2c,

drivers/media/pci/pt3/pt3.c

402

cl = dvb_module_probe("mxl301rf", info->type, cfg.tuner_i2c,

drivers/media/pci/pt3/pt3.c

405

if (!cl)

drivers/media/pci/pt3/pt3.c

407

pt3->adaps[i]->i2c_tuner = cl;

drivers/media/platform/amphion/vpu.h

117

struct mbox_client cl;

drivers/media/platform/amphion/vpu_mbox.c

17

static void vpu_mbox_rx_callback(struct mbox_client *cl, void *msg)

drivers/media/platform/amphion/vpu_mbox.c

19

struct vpu_mbox *rx = container_of(cl, struct vpu_mbox, cl);

drivers/media/platform/amphion/vpu_mbox.c

28

struct mbox_client *cl;

drivers/media/platform/amphion/vpu_mbox.c

35

cl = &mbox->cl;

drivers/media/platform/amphion/vpu_mbox.c

36

cl->dev = dev;

drivers/media/platform/amphion/vpu_mbox.c

38

cl->tx_block = true;

drivers/media/platform/amphion/vpu_mbox.c

39

cl->tx_tout = 1000;

drivers/media/platform/amphion/vpu_mbox.c

41

cl->tx_block = false;

drivers/media/platform/amphion/vpu_mbox.c

43

cl->knows_txdone = false;

drivers/media/platform/amphion/vpu_mbox.c

44

cl->rx_callback = vpu_mbox_rx_callback;

drivers/media/platform/amphion/vpu_mbox.c

46

ch = mbox_request_channel_byname(cl, mbox->name);

drivers/media/platform/mediatek/mdp3/mtk-mdp3-cmdq.c

505

static void mdp_handle_cmdq_callback(struct mbox_client *cl, void *mssg)

drivers/media/usb/dvb-usb-v2/gl861.c

418

struct i2c_client *cl;

drivers/media/usb/dvb-usb-v2/gl861.c

424

cl = dvb_module_probe("tc90522", info->type,

drivers/media/usb/dvb-usb-v2/gl861.c

426

if (!cl)

drivers/media/usb/dvb-usb-v2/gl861.c

431

priv->i2c_client_demod = cl;

drivers/media/usb/dvb-usb-v2/gl861.c

449

struct i2c_client *cl;

drivers/media/usb/dvb-usb-v2/gl861.c

457

cl = dvb_module_probe("dvb_pll", info->type,

drivers/media/usb/dvb-usb-v2/gl861.c

459

if (!cl)

drivers/media/usb/dvb-usb-v2/gl861.c

461

priv->i2c_client_tuner = cl;

drivers/mfd/lp3943.c

105

static int lp3943_probe(struct i2c_client *cl)

drivers/mfd/lp3943.c

108

struct device *dev = &cl->dev;

drivers/mfd/lp3943.c

114

lp3943->regmap = devm_regmap_init_i2c(cl, &lp3943_regmap_config);

drivers/mfd/lp3943.c

121

i2c_set_clientdata(cl, lp3943);

drivers/mfd/lp8788.c

169

static int lp8788_probe(struct i2c_client *cl)

drivers/mfd/lp8788.c

172

struct lp8788_platform_data *pdata = dev_get_platdata(&cl->dev);

drivers/mfd/lp8788.c

175

lp = devm_kzalloc(&cl->dev, sizeof(struct lp8788), GFP_KERNEL);

drivers/mfd/lp8788.c

179

lp->regmap = devm_regmap_init_i2c(cl, &lp8788_regmap_config);

drivers/mfd/lp8788.c

182

dev_err(&cl->dev, "regmap init i2c err: %d\n", ret);

drivers/mfd/lp8788.c

187

lp->dev = &cl->dev;

drivers/mfd/lp8788.c

188

i2c_set_clientdata(cl, lp);

drivers/mfd/lp8788.c

194

ret = lp8788_irq_init(lp, cl->irq);

drivers/mfd/lp8788.c

210

static void lp8788_remove(struct i2c_client *cl)

drivers/mfd/lp8788.c

212

struct lp8788 *lp = i2c_get_clientdata(cl);

drivers/mfd/ti-lmu.c

135

static int ti_lmu_probe(struct i2c_client *cl)

drivers/mfd/ti-lmu.c

137

const struct i2c_device_id *id = i2c_client_get_device_id(cl);

drivers/mfd/ti-lmu.c

138

struct device *dev = &cl->dev;

drivers/mfd/ti-lmu.c

156

lmu->dev = &cl->dev;

drivers/mfd/ti-lmu.c

165

lmu->regmap = devm_regmap_init_i2c(cl, &regmap_cfg);

drivers/mfd/ti-lmu.c

192

i2c_set_clientdata(cl, lmu);

drivers/misc/eeprom/ee1004.c

251

struct i2c_client *cl;

drivers/misc/eeprom/ee1004.c

253

cl = i2c_new_dummy_device(client->adapter, EE1004_ADDR_SET_PAGE + cnr);

drivers/misc/eeprom/ee1004.c

254

if (IS_ERR(cl)) {

drivers/misc/eeprom/ee1004.c

255

err = PTR_ERR(cl);

drivers/misc/eeprom/ee1004.c

259

bd->set_page[cnr] = cl;

drivers/misc/mei/bus-fixup.c

133

return __mei_cl_send_timeout(cldev->cl, buf, size, 0, mode, MKHI_SEND_MAX_TIMEOUT_MSEC);

drivers/misc/mei/bus-fixup.c

153

ret = __mei_cl_send_timeout(cldev->cl, (u8 *)&req, sizeof(req), 0,

drivers/misc/mei/bus-fixup.c

161

bytes_recv = __mei_cl_recv(cldev->cl, buf, sizeof(buf), NULL, 0,

drivers/misc/mei/bus-fixup.c

206

return __mei_cl_send_timeout(cldev->cl, (u8 *)&req, sizeof(req), 0,

drivers/misc/mei/bus-fixup.c

368

static int mei_nfc_if_version(struct mei_cl *cl,

drivers/misc/mei/bus-fixup.c

382

bus = cl->dev;

drivers/misc/mei/bus-fixup.c

386

ret = __mei_cl_send(cl, (u8 *)&cmd, sizeof(cmd), 0,

drivers/misc/mei/bus-fixup.c

401

bytes_recv = __mei_cl_recv(cl, (u8 *)reply, if_version_length, &vtag,

drivers/misc/mei/bus-fixup.c

452

struct mei_cl *cl;

drivers/misc/mei/bus-fixup.c

462

cl = mei_cl_alloc_linked(bus);

drivers/misc/mei/bus-fixup.c

463

if (IS_ERR(cl)) {

drivers/misc/mei/bus-fixup.c

464

ret = PTR_ERR(cl);

drivers/misc/mei/bus-fixup.c

465

cl = NULL;

drivers/misc/mei/bus-fixup.c

477

ret = mei_cl_connect(cl, me_cl, NULL);

drivers/misc/mei/bus-fixup.c

486

ret = mei_nfc_if_version(cl, &ver);

drivers/misc/mei/bus-fixup.c

504

if (mei_cl_disconnect(cl) < 0)

drivers/misc/mei/bus-fixup.c

507

mei_cl_flush_queues(cl, NULL);

drivers/misc/mei/bus-fixup.c

510

mei_cl_unlink(cl);

drivers/misc/mei/bus-fixup.c

513

kfree(cl);

drivers/misc/mei/bus.c

100

cl->writing_state == MEI_WRITE_COMPLETE ||

drivers/misc/mei/bus.c

101

(!mei_cl_is_connected(cl)));

drivers/misc/mei/bus.c

1010

ret = __mei_cl_recv(cl, (u8 *)&rx_msg, sizeof(rx_msg), NULL, MEI_CL_IO_SGL, 0);

drivers/misc/mei/bus.c

108

if (!mei_cl_is_connected(cl)) {

drivers/misc/mei/bus.c

114

cb = mei_cl_alloc_cb(cl, length, MEI_FOP_WRITE, NULL);

drivers/misc/mei/bus.c

131

rets = mei_cl_write(cl, cb, timeout);

drivers/misc/mei/bus.c

1320

struct mei_device *mdev = cldev->cl->dev;

drivers/misc/mei/bus.c

1321

struct mei_cl *cl;

drivers/misc/mei/bus.c

1323

mei_cl_flush_queues(cldev->cl, NULL);

drivers/misc/mei/bus.c

1327

list_for_each_entry(cl, &mdev->file_list, link)

drivers/misc/mei/bus.c

1328

WARN_ON(cl == cldev->cl);

drivers/misc/mei/bus.c

1330

kfree(cldev->cl);

drivers/misc/mei/bus.c

1364

struct mei_cl *cl;

drivers/misc/mei/bus.c

1370

cl = mei_cl_allocate(bus);

drivers/misc/mei/bus.c

1371

if (!cl) {

drivers/misc/mei/bus.c

1382

cldev->cl = cl;

drivers/misc/mei/bus.c

154

ssize_t __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length, u8 *vtag,

drivers/misc/mei/bus.c

163

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/bus.c

166

bus = cl->dev;

drivers/misc/mei/bus.c

175

cb = mei_cl_read_cb(cl, NULL);

drivers/misc/mei/bus.c

179

rets = mei_cl_read_start(cl, length, NULL);

drivers/misc/mei/bus.c

190

if (!waitqueue_active(&cl->rx_wait)) {

drivers/misc/mei/bus.c

196

(cl->rx_wait,

drivers/misc/mei/bus.c

197

mei_cl_read_cb(cl, NULL) ||

drivers/misc/mei/bus.c

198

(!mei_cl_is_connected(cl)),

drivers/misc/mei/bus.c

209

(cl->rx_wait,

drivers/misc/mei/bus.c

210

mei_cl_read_cb(cl, NULL) ||

drivers/misc/mei/bus.c

211

(!mei_cl_is_connected(cl)))) {

drivers/misc/mei/bus.c

220

if (!mei_cl_is_connected(cl)) {

drivers/misc/mei/bus.c

226

cb = mei_cl_read_cb(cl, NULL);

drivers/misc/mei/bus.c

252

mei_cl_del_rd_completed(cl, cb);

drivers/misc/mei/bus.c

275

struct mei_cl *cl = cldev->cl;

drivers/misc/mei/bus.c

277

return __mei_cl_send(cl, buf, length, vtag, MEI_CL_IO_TX_BLOCKING);

drivers/misc/mei/bus.c

298

struct mei_cl *cl = cldev->cl;

drivers/misc/mei/bus.c

300

return __mei_cl_send_timeout(cl, buf, length, vtag, MEI_CL_IO_TX_BLOCKING, timeout);

drivers/misc/mei/bus.c

320

struct mei_cl *cl = cldev->cl;

drivers/misc/mei/bus.c

322

return __mei_cl_recv(cl, buf, length, vtag, 0, 0);

drivers/misc/mei/bus.c

35

ssize_t __mei_cl_send(struct mei_cl *cl, const u8 *buf, size_t length, u8 vtag,

drivers/misc/mei/bus.c

362

struct mei_cl *cl = cldev->cl;

drivers/misc/mei/bus.c

364

return __mei_cl_recv(cl, buf, length, vtag, 0, timeout);

drivers/misc/mei/bus.c

38

return __mei_cl_send_timeout(cl, buf, length, vtag, mode, MAX_SCHEDULE_TIMEOUT);

drivers/misc/mei/bus.c

437

if (mei_cl_is_connected(cldev->cl))

drivers/misc/mei/bus.c

438

mei_cl_read_start(cldev->cl, mei_cl_mtu(cldev->cl), NULL);

drivers/misc/mei/bus.c

465

bool mei_cl_bus_notify_event(struct mei_cl *cl)

drivers/misc/mei/bus.c

467

struct mei_cl_device *cldev = cl->cldev;

drivers/misc/mei/bus.c

472

if (!cl->notify_ev)

drivers/misc/mei/bus.c

477

cl->notify_ev = false;

drivers/misc/mei/bus.c

490

bool mei_cl_bus_rx_event(struct mei_cl *cl)

drivers/misc/mei/bus.c

492

struct mei_cl_device *cldev = cl->cldev;

drivers/misc/mei/bus.c

526

if (mei_cl_is_connected(cldev->cl))

drivers/misc/mei/bus.c

527

ret = mei_cl_read_start(cldev->cl, mei_cl_mtu(cldev->cl), NULL);

drivers/misc/mei/bus.c

55

ssize_t __mei_cl_send_timeout(struct mei_cl *cl, const u8 *buf, size_t length, u8 vtag,

drivers/misc/mei/bus.c

567

ret = mei_cl_notify_request(cldev->cl, NULL, 1);

drivers/misc/mei/bus.c

62

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/bus.c

626

return mei_cl_mtu(cldev->cl);

drivers/misc/mei/bus.c

639

return mei_cl_is_connected(cldev->cl);

drivers/misc/mei/bus.c

65

bus = cl->dev;

drivers/misc/mei/bus.c

674

static inline struct mei_cl_vtag *mei_cl_bus_vtag(struct mei_cl *cl)

drivers/misc/mei/bus.c

676

return list_first_entry_or_null(&cl->vtag_map,

drivers/misc/mei/bus.c

691

struct mei_cl *cl = cldev->cl;

drivers/misc/mei/bus.c

698

if (mei_cl_vt_support_check(cl) || mei_cl_bus_vtag(cl))

drivers/misc/mei/bus.c

705

list_add_tail(&cl_vtag->list, &cl->vtag_map);

drivers/misc/mei/bus.c

717

struct mei_cl *cl = cldev->cl;

drivers/misc/mei/bus.c

720

cl_vtag = mei_cl_bus_vtag(cl);

drivers/misc/mei/bus.c

731

struct mei_cl *cl;

drivers/misc/mei/bus.c

74

if (!mei_cl_is_connected(cl)) {

drivers/misc/mei/bus.c

743

cl = cldev->cl;

drivers/misc/mei/bus.c

747

if (cl->state == MEI_FILE_UNINITIALIZED) {

drivers/misc/mei/bus.c

748

ret = mei_cl_link(cl);

drivers/misc/mei/bus.c

752

cl->cldev = cldev;

drivers/misc/mei/bus.c

755

ret = mei_cl_dma_alloc_and_map(cl, NULL, buffer_id, size);

drivers/misc/mei/bus.c

757

mei_cl_unlink(cl);

drivers/misc/mei/bus.c

762

return cl->dma.vaddr;

drivers/misc/mei/bus.c

769

struct mei_cl *cl;

drivers/misc/mei/bus.c

775

cl = cldev->cl;

drivers/misc/mei/bus.c

779

ret = mei_cl_dma_unmap(cl, NULL);

drivers/misc/mei/bus.c

781

mei_cl_flush_queues(cl, NULL);

drivers/misc/mei/bus.c

782

mei_cl_unlink(cl);

drivers/misc/mei/bus.c

799

struct mei_cl *cl;

drivers/misc/mei/bus.c

80

if (!mei_me_cl_is_active(cl->me_cl)) {

drivers/misc/mei/bus.c

802

cl = cldev->cl;

drivers/misc/mei/bus.c

805

if (cl->state == MEI_FILE_UNINITIALIZED) {

drivers/misc/mei/bus.c

806

ret = mei_cl_link(cl);

drivers/misc/mei/bus.c

810

cl->cldev = cldev;

drivers/misc/mei/bus.c

813

if (mei_cl_is_connected(cl)) {

drivers/misc/mei/bus.c

828

ret = mei_cl_connect(cl, cldev->me_cl, NULL);

drivers/misc/mei/bus.c

836

mei_cl_unlink(cl);

drivers/misc/mei/bus.c

87

rets = mei_cl_vt_support_check(cl);

drivers/misc/mei/bus.c

874

struct mei_cl *cl;

drivers/misc/mei/bus.c

880

cl = cldev->cl;

drivers/misc/mei/bus.c

890

if (!mei_cl_is_connected(cl)) {

drivers/misc/mei/bus.c

896

err = mei_cl_disconnect(cl);

drivers/misc/mei/bus.c

902

if (!cl->dma_mapped) {

drivers/misc/mei/bus.c

903

mei_cl_flush_queues(cl, NULL);

drivers/misc/mei/bus.c

904

mei_cl_unlink(cl);

drivers/misc/mei/bus.c

92

if (length > mei_cl_mtu(cl)) {

drivers/misc/mei/bus.c

933

struct mei_cl *cl;

drivers/misc/mei/bus.c

948

cl = cldev->cl;

drivers/misc/mei/bus.c

97

while (cl->tx_cb_queued >= bus->tx_queue_limit) {

drivers/misc/mei/bus.c

99

rets = wait_event_interruptible(cl->tx_wait,

drivers/misc/mei/bus.c

997

ret = __mei_cl_send(cl, (u8 *)ext_hdr, buf_sz, 0, MEI_CL_IO_SGL);

drivers/misc/mei/client.c

1007

static bool mei_cl_is_other_connecting(struct mei_cl *cl)

drivers/misc/mei/client.c

1012

dev = cl->dev;

drivers/misc/mei/client.c

1016

mei_cl_me_id(cl) == mei_cl_me_id(cb->cl))

drivers/misc/mei/client.c

1031

static int mei_cl_send_connect(struct mei_cl *cl, struct mei_cl_cb *cb)

drivers/misc/mei/client.c

1036

dev = cl->dev;

drivers/misc/mei/client.c

1038

ret = mei_hbm_cl_connect_req(dev, cl);

drivers/misc/mei/client.c

1039

cl->status = ret;

drivers/misc/mei/client.c

1041

cl->state = MEI_FILE_DISCONNECT_REPLY;

drivers/misc/mei/client.c

1046

cl->timer_count = dev->timeouts.connect;

drivers/misc/mei/client.c

1060

int mei_cl_irq_connect(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/client.c

1063

struct mei_device *dev = cl->dev;

drivers/misc/mei/client.c

1068

if (mei_cl_is_other_connecting(cl))

drivers/misc/mei/client.c

1079

rets = mei_cl_send_connect(cl, cb);

drivers/misc/mei/client.c

1097

int mei_cl_connect(struct mei_cl *cl, struct mei_me_client *me_cl,

drivers/misc/mei/client.c

1104

if (WARN_ON(!cl || !cl->dev || !me_cl))

drivers/misc/mei/client.c

1107

dev = cl->dev;

drivers/misc/mei/client.c

1109

rets = mei_cl_set_connecting(cl, me_cl);

drivers/misc/mei/client.c

1113

if (mei_cl_is_fixed_address(cl)) {

drivers/misc/mei/client.c

1114

cl->state = MEI_FILE_CONNECTED;

drivers/misc/mei/client.c

1122

cl_err(dev, cl, "rpm: get failed %d\n", rets);

drivers/misc/mei/client.c

1126

cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_CONNECT, fp);

drivers/misc/mei/client.c

1133

if (!mei_cl_is_other_connecting(cl) && mei_hbuf_acquire(dev)) {

drivers/misc/mei/client.c

1134

rets = mei_cl_send_connect(cl, cb);

drivers/misc/mei/client.c

1140

wait_event_timeout(cl->wait,

drivers/misc/mei/client.c

1141

(cl->state == MEI_FILE_CONNECTED ||

drivers/misc/mei/client.c

1142

cl->state == MEI_FILE_DISCONNECTED ||

drivers/misc/mei/client.c

1143

cl->state == MEI_FILE_DISCONNECT_REQUIRED ||

drivers/misc/mei/client.c

1144

cl->state == MEI_FILE_DISCONNECT_REPLY),

drivers/misc/mei/client.c

1148

if (!mei_cl_is_connected(cl)) {

drivers/misc/mei/client.c

1149

if (cl->state == MEI_FILE_DISCONNECT_REQUIRED) {

drivers/misc/mei/client.c

1150

mei_io_list_flush_cl(&dev->ctrl_rd_list, cl);

drivers/misc/mei/client.c

1151

mei_io_list_flush_cl(&dev->ctrl_wr_list, cl);

drivers/misc/mei/client.c

1155

__mei_cl_disconnect(cl);

drivers/misc/mei/client.c

1161

if (!cl->status)

drivers/misc/mei/client.c

1162

cl->status = -EFAULT;

drivers/misc/mei/client.c

1165

rets = cl->status;

drivers/misc/mei/client.c

1167

cl_dbg(dev, cl, "rpm: autosuspend\n");

drivers/misc/mei/client.c

1173

if (!mei_cl_is_connected(cl))

drivers/misc/mei/client.c

1174

mei_cl_set_disconnected(cl);

drivers/misc/mei/client.c

1188

struct mei_cl *cl;

drivers/misc/mei/client.c

1191

cl = mei_cl_allocate(dev);

drivers/misc/mei/client.c

1192

if (!cl) {

drivers/misc/mei/client.c

1197

ret = mei_cl_link(cl);

drivers/misc/mei/client.c

1201

return cl;

drivers/misc/mei/client.c

1203

kfree(cl);

drivers/misc/mei/client.c

1214

static int mei_cl_tx_flow_ctrl_creds(struct mei_cl *cl)

drivers/misc/mei/client.c

1216

if (WARN_ON(!cl || !cl->me_cl))

drivers/misc/mei/client.c

1219

if (cl->tx_flow_ctrl_creds > 0)

drivers/misc/mei/client.c

1222

if (mei_cl_is_fixed_address(cl))

drivers/misc/mei/client.c

1225

if (mei_cl_is_single_recv_buf(cl)) {

drivers/misc/mei/client.c

1226

if (cl->me_cl->tx_flow_ctrl_creds > 0)

drivers/misc/mei/client.c

1242

static int mei_cl_tx_flow_ctrl_creds_reduce(struct mei_cl *cl)

drivers/misc/mei/client.c

1244

if (WARN_ON(!cl || !cl->me_cl))

drivers/misc/mei/client.c

1247

if (mei_cl_is_fixed_address(cl))

drivers/misc/mei/client.c

1250

if (mei_cl_is_single_recv_buf(cl)) {

drivers/misc/mei/client.c

1251

if (WARN_ON(cl->me_cl->tx_flow_ctrl_creds <= 0))

drivers/misc/mei/client.c

1253

cl->me_cl->tx_flow_ctrl_creds--;

drivers/misc/mei/client.c

1255

if (WARN_ON(cl->tx_flow_ctrl_creds <= 0))

drivers/misc/mei/client.c

1257

cl->tx_flow_ctrl_creds--;

drivers/misc/mei/client.c

1297

const struct file *mei_cl_fp_by_vtag(const struct mei_cl *cl, u8 vtag)

drivers/misc/mei/client.c

1301

list_for_each_entry(vtag_l, &cl->vtag_map, list)

drivers/misc/mei/client.c

1303

if ((cl->cldev && mei_cldev_enabled(cl->cldev)) ||

drivers/misc/mei/client.c

1316

static void mei_cl_reset_read_by_vtag(const struct mei_cl *cl, u8 vtag)

drivers/misc/mei/client.c

1320

list_for_each_entry(vtag_l, &cl->vtag_map, list) {

drivers/misc/mei/client.c

1322

if ((cl->cldev && mei_cldev_enabled(cl->cldev)) ||

drivers/misc/mei/client.c

1336

static void mei_cl_read_vtag_add_fc(struct mei_cl *cl)

drivers/misc/mei/client.c

1340

list_for_each_entry(cl_vtag, &cl->vtag_map, list) {

drivers/misc/mei/client.c

1342

if (mei_cl_enqueue_ctrl_wr_cb(cl,

drivers/misc/mei/client.c

1343

mei_cl_mtu(cl),

drivers/misc/mei/client.c

1346

cl->rx_flow_ctrl_creds++;

drivers/misc/mei/client.c

1361

int mei_cl_vt_support_check(const struct mei_cl *cl)

drivers/misc/mei/client.c

1363

struct mei_device *dev = cl->dev;

drivers/misc/mei/client.c

1368

if (!cl->me_cl)

drivers/misc/mei/client.c

1371

return cl->me_cl->props.vt_supported ? 0 : -EOPNOTSUPP;

drivers/misc/mei/client.c

1382

void mei_cl_add_rd_completed(struct mei_cl *cl, struct mei_cl_cb *cb)

drivers/misc/mei/client.c

1386

if (!mei_cl_vt_support_check(cl)) {

drivers/misc/mei/client.c

1387

fp = mei_cl_fp_by_vtag(cl, cb->vtag);

drivers/misc/mei/client.c

1394

mei_cl_reset_read_by_vtag(cl, cb->vtag);

drivers/misc/mei/client.c

1395

mei_cl_read_vtag_add_fc(cl);

drivers/misc/mei/client.c

1398

spin_lock(&cl->rd_completed_lock);

drivers/misc/mei/client.c

1399

list_add_tail(&cb->list, &cl->rd_completed);

drivers/misc/mei/client.c

1400

spin_unlock(&cl->rd_completed_lock);

drivers/misc/mei/client.c

1410

void mei_cl_del_rd_completed(struct mei_cl *cl, struct mei_cl_cb *cb)

drivers/misc/mei/client.c

1412

spin_lock(&cl->rd_completed_lock);

drivers/misc/mei/client.c

1414

spin_unlock(&cl->rd_completed_lock);

drivers/misc/mei/client.c

1456

int mei_cl_irq_notify(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/client.c

1459

struct mei_device *dev = cl->dev;

drivers/misc/mei/client.c

1474

ret = mei_hbm_cl_notify_req(dev, cl, request);

drivers/misc/mei/client.c

1476

cl->status = ret;

drivers/misc/mei/client.c

1496

int mei_cl_notify_request(struct mei_cl *cl,

drivers/misc/mei/client.c

1504

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/client.c

1507

dev = cl->dev;

drivers/misc/mei/client.c

1510

cl_dbg(dev, cl, "notifications not supported\n");

drivers/misc/mei/client.c

1514

if (!mei_cl_is_connected(cl))

drivers/misc/mei/client.c

1520

cl_err(dev, cl, "rpm: get failed %d\n", rets);

drivers/misc/mei/client.c

1525

cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, fop_type, fp);

drivers/misc/mei/client.c

1532

if (mei_hbm_cl_notify_req(dev, cl, request)) {

drivers/misc/mei/client.c

1540

wait_event_timeout(cl->wait,

drivers/misc/mei/client.c

1541

cl->notify_en == request ||

drivers/misc/mei/client.c

1542

cl->status ||

drivers/misc/mei/client.c

1543

!mei_cl_is_connected(cl),

drivers/misc/mei/client.c

1547

if (cl->notify_en != request && !cl->status)

drivers/misc/mei/client.c

1548

cl->status = -EFAULT;

drivers/misc/mei/client.c

1550

rets = cl->status;

drivers/misc/mei/client.c

1553

cl_dbg(dev, cl, "rpm: autosuspend\n");

drivers/misc/mei/client.c

1567

void mei_cl_notify(struct mei_cl *cl)

drivers/misc/mei/client.c

1571

if (!cl || !cl->dev)

drivers/misc/mei/client.c

1574

dev = cl->dev;

drivers/misc/mei/client.c

1576

if (!cl->notify_en)

drivers/misc/mei/client.c

1579

cl_dbg(dev, cl, "notify event");

drivers/misc/mei/client.c

1580

cl->notify_ev = true;

drivers/misc/mei/client.c

1581

if (!mei_cl_bus_notify_event(cl))

drivers/misc/mei/client.c

1582

wake_up_interruptible(&cl->ev_wait);

drivers/misc/mei/client.c

1584

if (cl->ev_async)

drivers/misc/mei/client.c

1585

kill_fasync(&cl->ev_async, SIGIO, POLL_PRI);

drivers/misc/mei/client.c

1600

int mei_cl_notify_get(struct mei_cl *cl, bool block, bool *notify_ev)

drivers/misc/mei/client.c

1607

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/client.c

1610

dev = cl->dev;

drivers/misc/mei/client.c

1613

cl_dbg(dev, cl, "notifications not supported\n");

drivers/misc/mei/client.c

1617

if (!mei_cl_is_connected(cl))

drivers/misc/mei/client.c

1620

if (cl->notify_ev)

drivers/misc/mei/client.c

1627

rets = wait_event_interruptible(cl->ev_wait, cl->notify_ev);

drivers/misc/mei/client.c

1634

*notify_ev = cl->notify_ev;

drivers/misc/mei/client.c

1635

cl->notify_ev = false;

drivers/misc/mei/client.c

1648

int mei_cl_read_start(struct mei_cl *cl, size_t length, const struct file *fp)

drivers/misc/mei/client.c

1654

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/client.c

1657

dev = cl->dev;

drivers/misc/mei/client.c

1659

if (!mei_cl_is_connected(cl))

drivers/misc/mei/client.c

1662

if (!mei_me_cl_is_active(cl->me_cl)) {

drivers/misc/mei/client.c

1663

cl_err(dev, cl, "no such me client\n");

drivers/misc/mei/client.c

1667

if (mei_cl_is_fixed_address(cl))

drivers/misc/mei/client.c

1671

if (cl->rx_flow_ctrl_creds) {

drivers/misc/mei/client.c

1672

mei_cl_set_read_by_fp(cl, fp);

drivers/misc/mei/client.c

1676

cb = mei_cl_enqueue_ctrl_wr_cb(cl, length, MEI_FOP_READ, fp);

drivers/misc/mei/client.c

1680

mei_cl_set_read_by_fp(cl, fp);

drivers/misc/mei/client.c

1685

cl_err(dev, cl, "rpm: get failed %d\n", rets);

drivers/misc/mei/client.c

1691

rets = mei_hbm_cl_flow_control_req(dev, cl);

drivers/misc/mei/client.c

1695

list_move_tail(&cb->list, &cl->rd_pending);

drivers/misc/mei/client.c

1697

cl->rx_flow_ctrl_creds++;

drivers/misc/mei/client.c

1700

cl_dbg(dev, cl, "rpm: autosuspend\n");

drivers/misc/mei/client.c

1751

is_hbm = cb->cl->me_cl->client_id == 0;

drivers/misc/mei/client.c

1752

is_gsc = ((!is_hbm) && cb->cl->dev->hbm_f_gsc_supported && mei_ext_hdr_is_gsc(cb->ext_hdr));

drivers/misc/mei/client.c

1773

mei_hdr->host_addr = mei_cl_host_addr(cb->cl);

drivers/misc/mei/client.c

1774

mei_hdr->me_addr = mei_cl_me_id(cb->cl);

drivers/misc/mei/client.c

1811

int mei_cl_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/client.c

1828

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/client.c

1831

dev = cl->dev;

drivers/misc/mei/client.c

1837

rets = first_chunk ? mei_cl_tx_flow_ctrl_creds(cl) : 1;

drivers/misc/mei/client.c

1842

cl_dbg(dev, cl, "No flow control credentials: not sending.\n");

drivers/misc/mei/client.c

1902

cl->status = 0;

drivers/misc/mei/client.c

1903

cl->writing_state = MEI_WRITING;

drivers/misc/mei/client.c

1907

if (mei_cl_tx_flow_ctrl_creds_reduce(cl)) {

drivers/misc/mei/client.c

1921

cl->status = rets;

drivers/misc/mei/client.c

1938

ssize_t mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb, unsigned long timeout)

drivers/misc/mei/client.c

1954

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/client.c

1960

dev = cl->dev;

drivers/misc/mei/client.c

1965

cl_dbg(dev, cl, "buf_len=%zd\n", buf_len);

drivers/misc/mei/client.c

1973

cl_err(dev, cl, "rpm: get failed %zd\n", rets);

drivers/misc/mei/client.c

1978

cl->writing_state = MEI_IDLE;

drivers/misc/mei/client.c

1981

rets = mei_cl_tx_flow_ctrl_creds(cl);

drivers/misc/mei/client.c

1995

cl_dbg(dev, cl, "No flow control credentials: not sending.\n");

drivers/misc/mei/client.c

2001

cl_dbg(dev, cl, "Cannot acquire the host buffer: not sending.\n");

drivers/misc/mei/client.c

2043

rets = mei_cl_tx_flow_ctrl_creds_reduce(cl);

drivers/misc/mei/client.c

2047

cl->writing_state = MEI_WRITING;

drivers/misc/mei/client.c

2059

if (blocking && cl->writing_state != MEI_WRITE_COMPLETE) {

drivers/misc/mei/client.c

2062

rets = wait_event_interruptible_timeout(cl->tx_wait,

drivers/misc/mei/client.c

2063

cl->writing_state == MEI_WRITE_COMPLETE ||

drivers/misc/mei/client.c

2064

(!mei_cl_is_connected(cl)),

drivers/misc/mei/client.c

2070

mei_io_tx_list_free_cl(&dev->write_list, cl, NULL);

drivers/misc/mei/client.c

2071

mei_io_tx_list_free_cl(&dev->write_waiting_list, cl, NULL);

drivers/misc/mei/client.c

2081

if (cl->writing_state != MEI_WRITE_COMPLETE) {

drivers/misc/mei/client.c

2089

cl_dbg(dev, cl, "rpm: autosuspend\n");

drivers/misc/mei/client.c

2105

void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb)

drivers/misc/mei/client.c

2107

struct mei_device *dev = cl->dev;

drivers/misc/mei/client.c

2112

cl->writing_state = MEI_WRITE_COMPLETE;

drivers/misc/mei/client.c

2113

if (waitqueue_active(&cl->tx_wait))

drivers/misc/mei/client.c

2114

wake_up_interruptible(&cl->tx_wait);

drivers/misc/mei/client.c

2120

mei_cl_add_rd_completed(cl, cb);

drivers/misc/mei/client.c

2121

if (!mei_cl_is_fixed_address(cl) &&

drivers/misc/mei/client.c

2122

!WARN_ON(!cl->rx_flow_ctrl_creds))

drivers/misc/mei/client.c

2123

cl->rx_flow_ctrl_creds--;

drivers/misc/mei/client.c

2124

if (!mei_cl_bus_rx_event(cl))

drivers/misc/mei/client.c

2125

wake_up_interruptible(&cl->rx_wait);

drivers/misc/mei/client.c

2134

if (waitqueue_active(&cl->wait))

drivers/misc/mei/client.c

2135

wake_up(&cl->wait);

drivers/misc/mei/client.c

2140

mei_cl_set_disconnected(cl);

drivers/misc/mei/client.c

2155

struct mei_cl *cl;

drivers/misc/mei/client.c

2157

list_for_each_entry(cl, &dev->file_list, link)

drivers/misc/mei/client.c

2158

mei_cl_set_disconnected(cl);

drivers/misc/mei/client.c

2164

struct mei_cl *cl;

drivers/misc/mei/client.c

2166

list_for_each_entry(cl, &dev->file_list, link)

drivers/misc/mei/client.c

2167

if (cl->dma.buffer_id == buffer_id)

drivers/misc/mei/client.c

2168

return cl;

drivers/misc/mei/client.c

2181

int mei_cl_irq_dma_map(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/client.c

2184

struct mei_device *dev = cl->dev;

drivers/misc/mei/client.c

2197

ret = mei_hbm_cl_dma_map_req(dev, cl);

drivers/misc/mei/client.c

2199

cl->status = ret;

drivers/misc/mei/client.c

2217

int mei_cl_irq_dma_unmap(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/client.c

2220

struct mei_device *dev = cl->dev;

drivers/misc/mei/client.c

2233

ret = mei_hbm_cl_dma_unmap_req(dev, cl);

drivers/misc/mei/client.c

2235

cl->status = ret;

drivers/misc/mei/client.c

2244

static int mei_cl_dma_alloc(struct mei_cl *cl, u8 buf_id, size_t size)

drivers/misc/mei/client.c

2246

cl->dma.vaddr = dmam_alloc_coherent(&cl->dev->dev, size,

drivers/misc/mei/client.c

2247

&cl->dma.daddr, GFP_KERNEL);

drivers/misc/mei/client.c

2248

if (!cl->dma.vaddr)

drivers/misc/mei/client.c

2251

cl->dma.buffer_id = buf_id;

drivers/misc/mei/client.c

2252

cl->dma.size = size;

drivers/misc/mei/client.c

2257

static void mei_cl_dma_free(struct mei_cl *cl)

drivers/misc/mei/client.c

2259

cl->dma.buffer_id = 0;

drivers/misc/mei/client.c

2260

dmam_free_coherent(&cl->dev->dev,

drivers/misc/mei/client.c

2261

cl->dma.size, cl->dma.vaddr, cl->dma.daddr);

drivers/misc/mei/client.c

2262

cl->dma.size = 0;

drivers/misc/mei/client.c

2263

cl->dma.vaddr = NULL;

drivers/misc/mei/client.c

2264

cl->dma.daddr = 0;

drivers/misc/mei/client.c

2284

int mei_cl_dma_alloc_and_map(struct mei_cl *cl, const struct file *fp,

drivers/misc/mei/client.c

2291

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/client.c

2294

dev = cl->dev;

drivers/misc/mei/client.c

2297

cl_dbg(dev, cl, "client dma is not supported\n");

drivers/misc/mei/client.c

2304

if (mei_cl_is_connected(cl))

drivers/misc/mei/client.c

2307

if (cl->dma_mapped)

drivers/misc/mei/client.c

2311

cl_dbg(dev, cl, "client dma with id %d is already allocated\n",

drivers/misc/mei/client.c

2312

cl->dma.buffer_id);

drivers/misc/mei/client.c

2319

cl_err(dev, cl, "rpm: get failed %d\n", rets);

drivers/misc/mei/client.c

2323

rets = mei_cl_dma_alloc(cl, buffer_id, size);

drivers/misc/mei/client.c

2329

cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DMA_MAP, fp);

drivers/misc/mei/client.c

2336

if (mei_hbm_cl_dma_map_req(dev, cl)) {

drivers/misc/mei/client.c

2343

cl->status = 0;

drivers/misc/mei/client.c

2346

wait_event_timeout(cl->wait,

drivers/misc/mei/client.c

2347

cl->dma_mapped || cl->status,

drivers/misc/mei/client.c

2351

if (!cl->dma_mapped && !cl->status)

drivers/misc/mei/client.c

2352

cl->status = -EFAULT;

drivers/misc/mei/client.c

2354

rets = cl->status;

drivers/misc/mei/client.c

2358

mei_cl_dma_free(cl);

drivers/misc/mei/client.c

2360

cl_dbg(dev, cl, "rpm: autosuspend\n");

drivers/misc/mei/client.c

2377

int mei_cl_dma_unmap(struct mei_cl *cl, const struct file *fp)

drivers/misc/mei/client.c

2383

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/client.c

2386

dev = cl->dev;

drivers/misc/mei/client.c

2389

cl_dbg(dev, cl, "client dma is not supported\n");

drivers/misc/mei/client.c

2394

if (mei_cl_is_connected(cl))

drivers/misc/mei/client.c

2397

if (!cl->dma_mapped)

drivers/misc/mei/client.c

2403

cl_err(dev, cl, "rpm: get failed %d\n", rets);

drivers/misc/mei/client.c

2407

cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DMA_UNMAP, fp);

drivers/misc/mei/client.c

2414

if (mei_hbm_cl_dma_unmap_req(dev, cl)) {

drivers/misc/mei/client.c

2421

cl->status = 0;

drivers/misc/mei/client.c

2424

wait_event_timeout(cl->wait,

drivers/misc/mei/client.c

2425

!cl->dma_mapped || cl->status,

drivers/misc/mei/client.c

2429

if (cl->dma_mapped && !cl->status)

drivers/misc/mei/client.c

2430

cl->status = -EFAULT;

drivers/misc/mei/client.c

2432

rets = cl->status;

drivers/misc/mei/client.c

2435

mei_cl_dma_free(cl);

drivers/misc/mei/client.c

2437

cl_dbg(dev, cl, "rpm: autosuspend\n");

drivers/misc/mei/client.c

319

cb->cl->tx_cb_queued++;

drivers/misc/mei/client.c

331

if (!WARN_ON(cb->cl->tx_cb_queued == 0))

drivers/misc/mei/client.c

332

cb->cl->tx_cb_queued--;

drivers/misc/mei/client.c

345

static void mei_cl_set_read_by_fp(const struct mei_cl *cl,

drivers/misc/mei/client.c

350

list_for_each_entry(cl_vtag, &cl->vtag_map, list) {

drivers/misc/mei/client.c

367

static struct mei_cl_cb *mei_io_cb_init(struct mei_cl *cl,

drivers/misc/mei/client.c

379

cb->cl = cl;

drivers/misc/mei/client.c

395

const struct mei_cl *cl)

drivers/misc/mei/client.c

400

if (cl == cb->cl) {

drivers/misc/mei/client.c

416

const struct mei_cl *cl,

drivers/misc/mei/client.c

422

if (cl == cb->cl && (!fp || fp == cb->fp))

drivers/misc/mei/client.c

447

static void mei_cl_free_pending(struct mei_cl *cl)

drivers/misc/mei/client.c

451

cb = list_first_entry_or_null(&cl->rd_pending, struct mei_cl_cb, list);

drivers/misc/mei/client.c

465

struct mei_cl_cb *mei_cl_alloc_cb(struct mei_cl *cl, size_t length,

drivers/misc/mei/client.c

471

cb = mei_io_cb_init(cl, fop_type, fp);

drivers/misc/mei/client.c

500

struct mei_cl_cb *mei_cl_enqueue_ctrl_wr_cb(struct mei_cl *cl, size_t length,

drivers/misc/mei/client.c

508

length = max_t(size_t, length, mei_cl_mtu(cl));

drivers/misc/mei/client.c

510

cb = mei_cl_alloc_cb(cl, length, fop_type, fp);

drivers/misc/mei/client.c

514

list_add_tail(&cb->list, &cl->dev->ctrl_wr_list);

drivers/misc/mei/client.c

527

struct mei_cl_cb *mei_cl_read_cb(struct mei_cl *cl, const struct file *fp)

drivers/misc/mei/client.c

532

spin_lock(&cl->rd_completed_lock);

drivers/misc/mei/client.c

533

list_for_each_entry(cb, &cl->rd_completed, list)

drivers/misc/mei/client.c

538

spin_unlock(&cl->rd_completed_lock);

drivers/misc/mei/client.c

550

int mei_cl_flush_queues(struct mei_cl *cl, const struct file *fp)

drivers/misc/mei/client.c

554

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/client.c

557

dev = cl->dev;

drivers/misc/mei/client.c

559

cl_dbg(dev, cl, "remove list entry belonging to cl\n");

drivers/misc/mei/client.c

560

mei_io_tx_list_free_cl(&cl->dev->write_list, cl, fp);

drivers/misc/mei/client.c

561

mei_io_tx_list_free_cl(&cl->dev->write_waiting_list, cl, fp);

drivers/misc/mei/client.c

564

mei_io_list_flush_cl(&cl->dev->ctrl_wr_list, cl);

drivers/misc/mei/client.c

565

mei_io_list_flush_cl(&cl->dev->ctrl_rd_list, cl);

drivers/misc/mei/client.c

566

mei_cl_free_pending(cl);

drivers/misc/mei/client.c

568

spin_lock(&cl->rd_completed_lock);

drivers/misc/mei/client.c

569

mei_io_list_free_fp(&cl->rd_completed, fp);

drivers/misc/mei/client.c

570

spin_unlock(&cl->rd_completed_lock);

drivers/misc/mei/client.c

581

static void mei_cl_init(struct mei_cl *cl, struct mei_device *dev)

drivers/misc/mei/client.c

583

memset(cl, 0, sizeof(*cl));

drivers/misc/mei/client.c

584

init_waitqueue_head(&cl->wait);

drivers/misc/mei/client.c

585

init_waitqueue_head(&cl->rx_wait);

drivers/misc/mei/client.c

586

init_waitqueue_head(&cl->tx_wait);

drivers/misc/mei/client.c

587

init_waitqueue_head(&cl->ev_wait);

drivers/misc/mei/client.c

588

INIT_LIST_HEAD(&cl->vtag_map);

drivers/misc/mei/client.c

589

spin_lock_init(&cl->rd_completed_lock);

drivers/misc/mei/client.c

590

INIT_LIST_HEAD(&cl->rd_completed);

drivers/misc/mei/client.c

591

INIT_LIST_HEAD(&cl->rd_pending);

drivers/misc/mei/client.c

592

INIT_LIST_HEAD(&cl->link);

drivers/misc/mei/client.c

593

cl->writing_state = MEI_IDLE;

drivers/misc/mei/client.c

594

cl->state = MEI_FILE_UNINITIALIZED;

drivers/misc/mei/client.c

595

cl->dev = dev;

drivers/misc/mei/client.c

606

struct mei_cl *cl;

drivers/misc/mei/client.c

608

cl = kmalloc_obj(*cl);

drivers/misc/mei/client.c

609

if (!cl)

drivers/misc/mei/client.c

612

mei_cl_init(cl, dev);

drivers/misc/mei/client.c

614

return cl;

drivers/misc/mei/client.c

626

int mei_cl_link(struct mei_cl *cl)

drivers/misc/mei/client.c

631

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/client.c

634

dev = cl->dev;

drivers/misc/mei/client.c

650

cl->host_client_id = id;

drivers/misc/mei/client.c

651

list_add_tail(&cl->link, &dev->file_list);

drivers/misc/mei/client.c

655

cl->state = MEI_FILE_INITIALIZING;

drivers/misc/mei/client.c

657

cl_dbg(dev, cl, "link cl\n");

drivers/misc/mei/client.c

668

int mei_cl_unlink(struct mei_cl *cl)

drivers/misc/mei/client.c

673

if (!cl)

drivers/misc/mei/client.c

676

if (WARN_ON(!cl->dev))

drivers/misc/mei/client.c

679

dev = cl->dev;

drivers/misc/mei/client.c

681

cl_dbg(dev, cl, "unlink client");

drivers/misc/mei/client.c

683

if (cl->state == MEI_FILE_UNINITIALIZED)

drivers/misc/mei/client.c

690

if (cl->host_client_id)

drivers/misc/mei/client.c

691

clear_bit(cl->host_client_id, dev->host_clients_map);

drivers/misc/mei/client.c

693

list_del_init(&cl->link);

drivers/misc/mei/client.c

695

cl->state = MEI_FILE_UNINITIALIZED;

drivers/misc/mei/client.c

696

cl->writing_state = MEI_IDLE;

drivers/misc/mei/client.c

698

WARN_ON(!list_empty(&cl->rd_completed) ||

drivers/misc/mei/client.c

699

!list_empty(&cl->rd_pending) ||

drivers/misc/mei/client.c

700

!list_empty(&cl->link));

drivers/misc/mei/client.c

746

static void mei_cl_wake_all(struct mei_cl *cl)

drivers/misc/mei/client.c

748

struct mei_device *dev = cl->dev;

drivers/misc/mei/client.c

751

if (waitqueue_active(&cl->rx_wait)) {

drivers/misc/mei/client.c

752

cl_dbg(dev, cl, "Waking up reading client!\n");

drivers/misc/mei/client.c

753

wake_up_interruptible(&cl->rx_wait);

drivers/misc/mei/client.c

756

if (waitqueue_active(&cl->tx_wait)) {

drivers/misc/mei/client.c

757

cl_dbg(dev, cl, "Waking up writing client!\n");

drivers/misc/mei/client.c

758

wake_up_interruptible(&cl->tx_wait);

drivers/misc/mei/client.c

761

if (waitqueue_active(&cl->ev_wait)) {

drivers/misc/mei/client.c

762

cl_dbg(dev, cl, "Waking up waiting for event clients!\n");

drivers/misc/mei/client.c

763

wake_up_interruptible(&cl->ev_wait);

drivers/misc/mei/client.c

766

if (waitqueue_active(&cl->wait)) {

drivers/misc/mei/client.c

767

cl_dbg(dev, cl, "Waking up ctrl write clients!\n");

drivers/misc/mei/client.c

768

wake_up(&cl->wait);

drivers/misc/mei/client.c

778

static void mei_cl_set_disconnected(struct mei_cl *cl)

drivers/misc/mei/client.c

780

struct mei_device *dev = cl->dev;

drivers/misc/mei/client.c

782

if (cl->state == MEI_FILE_DISCONNECTED ||

drivers/misc/mei/client.c

783

cl->state <= MEI_FILE_INITIALIZING)

drivers/misc/mei/client.c

786

cl->state = MEI_FILE_DISCONNECTED;

drivers/misc/mei/client.c

787

mei_io_tx_list_free_cl(&dev->write_list, cl, NULL);

drivers/misc/mei/client.c

788

mei_io_tx_list_free_cl(&dev->write_waiting_list, cl, NULL);

drivers/misc/mei/client.c

789

mei_io_list_flush_cl(&dev->ctrl_rd_list, cl);

drivers/misc/mei/client.c

790

mei_io_list_flush_cl(&dev->ctrl_wr_list, cl);

drivers/misc/mei/client.c

791

mei_cl_wake_all(cl);

drivers/misc/mei/client.c

792

cl->rx_flow_ctrl_creds = 0;

drivers/misc/mei/client.c

793

cl->tx_flow_ctrl_creds = 0;

drivers/misc/mei/client.c

794

cl->timer_count = 0;

drivers/misc/mei/client.c

796

if (!cl->me_cl)

drivers/misc/mei/client.c

799

if (!WARN_ON(cl->me_cl->connect_count == 0))

drivers/misc/mei/client.c

800

cl->me_cl->connect_count--;

drivers/misc/mei/client.c

802

if (cl->me_cl->connect_count == 0)

drivers/misc/mei/client.c

803

cl->me_cl->tx_flow_ctrl_creds = 0;

drivers/misc/mei/client.c

805

mei_me_cl_put(cl->me_cl);

drivers/misc/mei/client.c

806

cl->me_cl = NULL;

drivers/misc/mei/client.c

809

static int mei_cl_set_connecting(struct mei_cl *cl, struct mei_me_client *me_cl)

drivers/misc/mei/client.c

822

cl->me_cl = me_cl;

drivers/misc/mei/client.c

823

cl->state = MEI_FILE_CONNECTING;

drivers/misc/mei/client.c

824

cl->me_cl->connect_count++;

drivers/misc/mei/client.c

837

static int mei_cl_send_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb)

drivers/misc/mei/client.c

842

dev = cl->dev;

drivers/misc/mei/client.c

844

ret = mei_hbm_cl_disconnect_req(dev, cl);

drivers/misc/mei/client.c

845

cl->status = ret;

drivers/misc/mei/client.c

847

cl->state = MEI_FILE_DISCONNECT_REPLY;

drivers/misc/mei/client.c

852

cl->timer_count = dev->timeouts.connect;

drivers/misc/mei/client.c

868

int mei_cl_irq_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/client.c

871

struct mei_device *dev = cl->dev;

drivers/misc/mei/client.c

884

ret = mei_cl_send_disconnect(cl, cb);

drivers/misc/mei/client.c

899

static int __mei_cl_disconnect(struct mei_cl *cl)

drivers/misc/mei/client.c

905

dev = cl->dev;

drivers/misc/mei/client.c

907

cl->state = MEI_FILE_DISCONNECTING;

drivers/misc/mei/client.c

909

cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DISCONNECT, NULL);

drivers/misc/mei/client.c

916

rets = mei_cl_send_disconnect(cl, cb);

drivers/misc/mei/client.c

918

cl_err(dev, cl, "failed to disconnect.\n");

drivers/misc/mei/client.c

924

wait_event_timeout(cl->wait,

drivers/misc/mei/client.c

925

cl->state == MEI_FILE_DISCONNECT_REPLY ||

drivers/misc/mei/client.c

926

cl->state == MEI_FILE_DISCONNECTED,

drivers/misc/mei/client.c

930

rets = cl->status;

drivers/misc/mei/client.c

931

if (cl->state != MEI_FILE_DISCONNECT_REPLY &&

drivers/misc/mei/client.c

932

cl->state != MEI_FILE_DISCONNECTED) {

drivers/misc/mei/client.c

933

cl_dbg(dev, cl, "timeout on disconnect from FW client.\n");

drivers/misc/mei/client.c

939

mei_cl_set_disconnected(cl);

drivers/misc/mei/client.c

941

cl_dbg(dev, cl, "successfully disconnected from FW client.\n");

drivers/misc/mei/client.c

956

int mei_cl_disconnect(struct mei_cl *cl)

drivers/misc/mei/client.c

961

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/client.c

964

dev = cl->dev;

drivers/misc/mei/client.c

966

cl_dbg(dev, cl, "disconnecting");

drivers/misc/mei/client.c

968

if (!mei_cl_is_connected(cl))

drivers/misc/mei/client.c

971

if (mei_cl_is_fixed_address(cl)) {

drivers/misc/mei/client.c

972

mei_cl_set_disconnected(cl);

drivers/misc/mei/client.c

978

cl_dbg(dev, cl, "Device is powering down, don't bother with disconnection\n");

drivers/misc/mei/client.c

979

mei_cl_set_disconnected(cl);

drivers/misc/mei/client.c

986

cl_err(dev, cl, "rpm: get failed %d\n", rets);

drivers/misc/mei/client.c

990

rets = __mei_cl_disconnect(cl);

drivers/misc/mei/client.c

992

cl_dbg(dev, cl, "rpm: autosuspend\n");

drivers/misc/mei/client.h

129

int mei_cl_link(struct mei_cl *cl);

drivers/misc/mei/client.h

130

int mei_cl_unlink(struct mei_cl *cl);

drivers/misc/mei/client.h

134

struct mei_cl_cb *mei_cl_read_cb(struct mei_cl *cl, const struct file *fp);

drivers/misc/mei/client.h

136

void mei_cl_add_rd_completed(struct mei_cl *cl, struct mei_cl_cb *cb);

drivers/misc/mei/client.h

137

void mei_cl_del_rd_completed(struct mei_cl *cl, struct mei_cl_cb *cb);

drivers/misc/mei/client.h

139

struct mei_cl_cb *mei_cl_alloc_cb(struct mei_cl *cl, size_t length,

drivers/misc/mei/client.h

142

struct mei_cl_cb *mei_cl_enqueue_ctrl_wr_cb(struct mei_cl *cl, size_t length,

drivers/misc/mei/client.h

145

int mei_cl_flush_queues(struct mei_cl *cl, const struct file *fp);

drivers/misc/mei/client.h

148

const struct file *mei_cl_fp_by_vtag(const struct mei_cl *cl, u8 vtag);

drivers/misc/mei/client.h

149

int mei_cl_vt_support_check(const struct mei_cl *cl);

drivers/misc/mei/client.h

161

static inline bool mei_cl_is_connected(const struct mei_cl *cl)

drivers/misc/mei/client.h

163

return cl->state == MEI_FILE_CONNECTED;

drivers/misc/mei/client.h

173

static inline u8 mei_cl_me_id(const struct mei_cl *cl)

drivers/misc/mei/client.h

175

return cl->me_cl ? cl->me_cl->client_id : 0;

drivers/misc/mei/client.h

185

static inline size_t mei_cl_mtu(const struct mei_cl *cl)

drivers/misc/mei/client.h

187

return cl->me_cl ? cl->me_cl->props.max_msg_length : 0;

drivers/misc/mei/client.h

197

static inline bool mei_cl_is_fixed_address(const struct mei_cl *cl)

drivers/misc/mei/client.h

199

return cl->me_cl && cl->me_cl->props.fixed_address;

drivers/misc/mei/client.h

210

static inline bool mei_cl_is_single_recv_buf(const struct mei_cl *cl)

drivers/misc/mei/client.h

212

return cl->me_cl->props.single_recv_buf;

drivers/misc/mei/client.h

222

static inline const uuid_le *mei_cl_uuid(const struct mei_cl *cl)

drivers/misc/mei/client.h

224

return mei_me_cl_uuid(cl->me_cl);

drivers/misc/mei/client.h

234

static inline u8 mei_cl_host_addr(const struct mei_cl *cl)

drivers/misc/mei/client.h

236

return mei_cl_is_fixed_address(cl) ? 0 : cl->host_client_id;

drivers/misc/mei/client.h

239

int mei_cl_disconnect(struct mei_cl *cl);

drivers/misc/mei/client.h

240

int mei_cl_irq_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/client.h

242

int mei_cl_connect(struct mei_cl *cl, struct mei_me_client *me_cl,

drivers/misc/mei/client.h

244

int mei_cl_irq_connect(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/client.h

246

int mei_cl_read_start(struct mei_cl *cl, size_t length, const struct file *fp);

drivers/misc/mei/client.h

247

ssize_t mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb, unsigned long timeout);

drivers/misc/mei/client.h

248

int mei_cl_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/client.h

251

void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb);

drivers/misc/mei/client.h

257

int mei_cl_notify_request(struct mei_cl *cl,

drivers/misc/mei/client.h

259

int mei_cl_irq_notify(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/client.h

261

int mei_cl_notify_get(struct mei_cl *cl, bool block, bool *notify_ev);

drivers/misc/mei/client.h

262

void mei_cl_notify(struct mei_cl *cl);

drivers/misc/mei/client.h

266

int mei_cl_irq_dma_map(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/client.h

268

int mei_cl_irq_dma_unmap(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/client.h

270

int mei_cl_dma_alloc_and_map(struct mei_cl *cl, const struct file *fp,

drivers/misc/mei/client.h

272

int mei_cl_dma_unmap(struct mei_cl *cl, const struct file *fp);

drivers/misc/mei/client.h

275

#define MEI_CL_PRM(cl) (cl)->host_client_id, mei_cl_me_id(cl)

drivers/misc/mei/client.h

277

#define cl_dbg(dev, cl, format, arg...) \

drivers/misc/mei/client.h

278

dev_dbg(&(dev)->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg)

drivers/misc/mei/client.h

280

#define cl_warn(dev, cl, format, arg...) \

drivers/misc/mei/client.h

281

dev_warn(&(dev)->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg)

drivers/misc/mei/client.h

283

#define cl_err(dev, cl, format, arg...) \

drivers/misc/mei/client.h

284

dev_err(&(dev)->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg)

drivers/misc/mei/debugfs.c

61

struct mei_cl *cl;

drivers/misc/mei/debugfs.c

75

list_for_each_entry(cl, &dev->file_list, link) {

drivers/misc/mei/debugfs.c

78

i, mei_cl_me_id(cl), cl->host_client_id, cl->state,

drivers/misc/mei/debugfs.c

79

!list_empty(&cl->rd_completed), cl->writing_state,

drivers/misc/mei/debugfs.c

80

cl->tx_cb_queued);

drivers/misc/mei/hbm.c

1001

struct mei_cl *cl;

drivers/misc/mei/hbm.c

1004

cl = NULL;

drivers/misc/mei/hbm.c

1007

cl = cb->cl;

drivers/misc/mei/hbm.c

1012

if (mei_hbm_cl_addr_equal(cl, rs)) {

drivers/misc/mei/hbm.c

1018

if (!cl)

drivers/misc/mei/hbm.c

1023

mei_hbm_cl_connect_res(dev, cl, rs);

drivers/misc/mei/hbm.c

1026

mei_hbm_cl_disconnect_res(dev, cl, rs);

drivers/misc/mei/hbm.c

1029

mei_hbm_cl_notify_start_res(dev, cl, rs);

drivers/misc/mei/hbm.c

1032

mei_hbm_cl_notify_stop_res(dev, cl, rs);

drivers/misc/mei/hbm.c

1038

cl->timer_count = 0;

drivers/misc/mei/hbm.c

1039

wake_up(&cl->wait);

drivers/misc/mei/hbm.c

1055

struct mei_cl *cl;

drivers/misc/mei/hbm.c

1058

cl = mei_hbm_cl_find_by_cmd(dev, disconnect_req);

drivers/misc/mei/hbm.c

1059

if (cl) {

drivers/misc/mei/hbm.c

1060

cl_warn(dev, cl, "fw disconnect request received\n");

drivers/misc/mei/hbm.c

1061

cl->state = MEI_FILE_DISCONNECTING;

drivers/misc/mei/hbm.c

1062

cl->timer_count = 0;

drivers/misc/mei/hbm.c

1064

cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DISCONNECT_RSP,

drivers/misc/mei/hbm.c

150

void mei_hbm_cl_hdr(struct mei_cl *cl, u8 hbm_cmd, void *buf, size_t len)

drivers/misc/mei/hbm.c

157

cmd->host_addr = mei_cl_host_addr(cl);

drivers/misc/mei/hbm.c

158

cmd->me_addr = mei_cl_me_id(cl);

drivers/misc/mei/hbm.c

172

static inline int mei_hbm_cl_write(struct mei_device *dev, struct mei_cl *cl,

drivers/misc/mei/hbm.c

178

mei_hbm_cl_hdr(cl, hbm_cmd, buf, len);

drivers/misc/mei/hbm.c

193

bool mei_hbm_cl_addr_equal(struct mei_cl *cl, struct mei_hbm_cl_cmd *cmd)

drivers/misc/mei/hbm.c

195

return mei_cl_host_addr(cl) == cmd->host_addr &&

drivers/misc/mei/hbm.c

196

mei_cl_me_id(cl) == cmd->me_addr;

drivers/misc/mei/hbm.c

211

struct mei_cl *cl;

drivers/misc/mei/hbm.c

213

list_for_each_entry(cl, &dev->file_list, link)

drivers/misc/mei/hbm.c

214

if (mei_hbm_cl_addr_equal(cl, cmd))

drivers/misc/mei/hbm.c

215

return cl;

drivers/misc/mei/hbm.c

494

struct mei_cl *cl, u8 start)

drivers/misc/mei/hbm.c

502

mei_hbm_cl_hdr(cl, MEI_HBM_NOTIFY_REQ_CMD, &req, sizeof(req));

drivers/misc/mei/hbm.c

508

cl_err(dev, cl, "notify request failed: ret = %d\n", ret);

drivers/misc/mei/hbm.c

538

struct mei_cl *cl,

drivers/misc/mei/hbm.c

544

cl_dbg(dev, cl, "hbm: notify start response status=%d\n", rs->status);

drivers/misc/mei/hbm.c

548

cl->notify_en = true;

drivers/misc/mei/hbm.c

549

cl->status = 0;

drivers/misc/mei/hbm.c

551

cl->status = -EINVAL;

drivers/misc/mei/hbm.c

564

struct mei_cl *cl,

drivers/misc/mei/hbm.c

570

cl_dbg(dev, cl, "hbm: notify stop response status=%d\n", rs->status);

drivers/misc/mei/hbm.c

574

cl->notify_en = false;

drivers/misc/mei/hbm.c

575

cl->status = 0;

drivers/misc/mei/hbm.c

578

cl->status = -EINVAL;

drivers/misc/mei/hbm.c

591

struct mei_cl *cl;

drivers/misc/mei/hbm.c

593

cl = mei_hbm_cl_find_by_cmd(dev, cmd);

drivers/misc/mei/hbm.c

594

if (cl)

drivers/misc/mei/hbm.c

595

mei_cl_notify(cl);

drivers/misc/mei/hbm.c

606

int mei_hbm_cl_dma_map_req(struct mei_device *dev, struct mei_cl *cl)

drivers/misc/mei/hbm.c

617

req.client_buffer_id = cl->dma.buffer_id;

drivers/misc/mei/hbm.c

618

req.address_lsb = lower_32_bits(cl->dma.daddr);

drivers/misc/mei/hbm.c

619

req.address_msb = upper_32_bits(cl->dma.daddr);

drivers/misc/mei/hbm.c

620

req.size = cl->dma.size;

drivers/misc/mei/hbm.c

624

cl_err(dev, cl, "dma map request failed: ret = %d\n", ret);

drivers/misc/mei/hbm.c

637

int mei_hbm_cl_dma_unmap_req(struct mei_device *dev, struct mei_cl *cl)

drivers/misc/mei/hbm.c

648

req.client_buffer_id = cl->dma.buffer_id;

drivers/misc/mei/hbm.c

652

cl_err(dev, cl, "dma unmap request failed: ret = %d\n", ret);

drivers/misc/mei/hbm.c

660

struct mei_cl *cl;

drivers/misc/mei/hbm.c

663

cl = NULL;

drivers/misc/mei/hbm.c

667

if (!cb->cl->dma.buffer_id || cb->cl->dma_mapped)

drivers/misc/mei/hbm.c

670

cl = cb->cl;

drivers/misc/mei/hbm.c

673

if (!cl)

drivers/misc/mei/hbm.c

677

cl_err(dev, cl, "cl dma map failed %d\n", res->status);

drivers/misc/mei/hbm.c

678

cl->status = -EFAULT;

drivers/misc/mei/hbm.c

680

cl_dbg(dev, cl, "cl dma map succeeded\n");

drivers/misc/mei/hbm.c

681

cl->dma_mapped = 1;

drivers/misc/mei/hbm.c

682

cl->status = 0;

drivers/misc/mei/hbm.c

684

wake_up(&cl->wait);

drivers/misc/mei/hbm.c

690

struct mei_cl *cl;

drivers/misc/mei/hbm.c

693

cl = NULL;

drivers/misc/mei/hbm.c

697

if (!cb->cl->dma.buffer_id || !cb->cl->dma_mapped)

drivers/misc/mei/hbm.c

700

cl = cb->cl;

drivers/misc/mei/hbm.c

703

if (!cl)

drivers/misc/mei/hbm.c

707

cl_err(dev, cl, "cl dma unmap failed %d\n", res->status);

drivers/misc/mei/hbm.c

708

cl->status = -EFAULT;

drivers/misc/mei/hbm.c

710

cl_dbg(dev, cl, "cl dma unmap succeeded\n");

drivers/misc/mei/hbm.c

711

cl->dma_mapped = 0;

drivers/misc/mei/hbm.c

712

cl->status = 0;

drivers/misc/mei/hbm.c

714

wake_up(&cl->wait);

drivers/misc/mei/hbm.c

820

int mei_hbm_cl_flow_control_req(struct mei_device *dev, struct mei_cl *cl)

drivers/misc/mei/hbm.c

824

cl_dbg(dev, cl, "sending flow control\n");

drivers/misc/mei/hbm.c

825

return mei_hbm_cl_write(dev, cl, MEI_FLOW_CONTROL_CMD,

drivers/misc/mei/hbm.c

873

struct mei_cl *cl;

drivers/misc/mei/hbm.c

881

cl = mei_hbm_cl_find_by_cmd(dev, fctrl);

drivers/misc/mei/hbm.c

882

if (cl) {

drivers/misc/mei/hbm.c

883

cl->tx_flow_ctrl_creds++;

drivers/misc/mei/hbm.c

884

cl_dbg(dev, cl, "flow control creds = %d.\n",

drivers/misc/mei/hbm.c

885

cl->tx_flow_ctrl_creds);

drivers/misc/mei/hbm.c

898

int mei_hbm_cl_disconnect_req(struct mei_device *dev, struct mei_cl *cl)

drivers/misc/mei/hbm.c

902

return mei_hbm_cl_write(dev, cl, CLIENT_DISCONNECT_REQ_CMD,

drivers/misc/mei/hbm.c

914

int mei_hbm_cl_disconnect_rsp(struct mei_device *dev, struct mei_cl *cl)

drivers/misc/mei/hbm.c

918

return mei_hbm_cl_write(dev, cl, CLIENT_DISCONNECT_RES_CMD,

drivers/misc/mei/hbm.c

930

static void mei_hbm_cl_disconnect_res(struct mei_device *dev, struct mei_cl *cl,

drivers/misc/mei/hbm.c

936

cl_dbg(dev, cl, "hbm: disconnect response status=%d\n", rs->status);

drivers/misc/mei/hbm.c

939

cl->state = MEI_FILE_DISCONNECT_REPLY;

drivers/misc/mei/hbm.c

940

cl->status = 0;

drivers/misc/mei/hbm.c

951

int mei_hbm_cl_connect_req(struct mei_device *dev, struct mei_cl *cl)

drivers/misc/mei/hbm.c

955

return mei_hbm_cl_write(dev, cl, CLIENT_CONNECT_REQ_CMD,

drivers/misc/mei/hbm.c

967

static void mei_hbm_cl_connect_res(struct mei_device *dev, struct mei_cl *cl,

drivers/misc/mei/hbm.c

973

cl_dbg(dev, cl, "hbm: connect response status=%s\n",

drivers/misc/mei/hbm.c

977

cl->state = MEI_FILE_CONNECTED;

drivers/misc/mei/hbm.c

979

cl->state = MEI_FILE_DISCONNECT_REPLY;

drivers/misc/mei/hbm.c

981

mei_me_cl_del(dev, cl->me_cl);

drivers/misc/mei/hbm.c

986

cl->status = mei_cl_conn_status_to_errno(rs->status);

drivers/misc/mei/hbm.h

46

int mei_hbm_cl_flow_control_req(struct mei_device *dev, struct mei_cl *cl);

drivers/misc/mei/hbm.h

47

int mei_hbm_cl_disconnect_req(struct mei_device *dev, struct mei_cl *cl);

drivers/misc/mei/hbm.h

48

int mei_hbm_cl_disconnect_rsp(struct mei_device *dev, struct mei_cl *cl);

drivers/misc/mei/hbm.h

49

int mei_hbm_cl_connect_req(struct mei_device *dev, struct mei_cl *cl);

drivers/misc/mei/hbm.h

54

struct mei_cl *cl, u8 request);

drivers/misc/mei/hbm.h

55

int mei_hbm_cl_dma_map_req(struct mei_device *dev, struct mei_cl *cl);

drivers/misc/mei/hbm.h

56

int mei_hbm_cl_dma_unmap_req(struct mei_device *dev, struct mei_cl *cl);

drivers/misc/mei/interrupt.c

115

cb = list_first_entry_or_null(&cl->rd_pending, struct mei_cl_cb, list);

drivers/misc/mei/interrupt.c

117

if (!mei_cl_is_fixed_address(cl)) {

drivers/misc/mei/interrupt.c

118

cl_err(dev, cl, "pending read cb not found\n");

drivers/misc/mei/interrupt.c

121

cb = mei_cl_alloc_cb(cl, mei_cl_mtu(cl), MEI_FOP_READ, cl->fp);

drivers/misc/mei/interrupt.c

124

list_add_tail(&cb->list, &cl->rd_pending);

drivers/misc/mei/interrupt.c

145

cl_err(dev, cl, "unknown extended header\n");

drivers/misc/mei/interrupt.c

154

cl_dbg(dev, cl, "no vtag or gsc found in extended header.\n");

drivers/misc/mei/interrupt.c

161

cl_dbg(dev, cl, "vtag: %d\n", vtag_hdr->vtag);

drivers/misc/mei/interrupt.c

163

cl_err(dev, cl, "mismatched tag: %d != %d\n",

drivers/misc/mei/interrupt.c

175

cl_err(dev, cl, "gsc extended header is not supported\n");

drivers/misc/mei/interrupt.c

181

cl_err(dev, cl, "no data allowed in cb with gsc\n");

drivers/misc/mei/interrupt.c

186

cl_err(dev, cl, "gsc extended header is too big %u\n", ext_hdr_len);

drivers/misc/mei/interrupt.c

193

if (!mei_cl_is_connected(cl)) {

drivers/misc/mei/interrupt.c

194

cl_dbg(dev, cl, "not connected\n");

drivers/misc/mei/interrupt.c

205

cl_err(dev, cl, "message is too big len %d idx %zu\n",

drivers/misc/mei/interrupt.c

212

cl_dbg(dev, cl, "message overflow. size %zu len %d idx %zu\n",

drivers/misc/mei/interrupt.c

229

cl_dbg(dev, cl, "completed read length = %zu\n", cb->buf_idx);

drivers/misc/mei/interrupt.c

253

static int mei_cl_irq_disconnect_rsp(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/interrupt.c

256

struct mei_device *dev = cl->dev;

drivers/misc/mei/interrupt.c

269

ret = mei_hbm_cl_disconnect_rsp(dev, cl);

drivers/misc/mei/interrupt.c

285

static int mei_cl_irq_read(struct mei_cl *cl, struct mei_cl_cb *cb,

drivers/misc/mei/interrupt.c

288

struct mei_device *dev = cl->dev;

drivers/misc/mei/interrupt.c

293

if (!list_empty(&cl->rd_pending))

drivers/misc/mei/interrupt.c

304

ret = mei_hbm_cl_flow_control_req(dev, cl);

drivers/misc/mei/interrupt.c

306

cl->status = ret;

drivers/misc/mei/interrupt.c

314

list_move_tail(&cb->list, &cl->rd_pending);

drivers/misc/mei/interrupt.c

32

struct mei_cl *cl;

drivers/misc/mei/interrupt.c

35

cl = cb->cl;

drivers/misc/mei/interrupt.c

363

struct mei_cl *cl;

drivers/misc/mei/interrupt.c

38

cl_dbg(dev, cl, "completing call back.\n");

drivers/misc/mei/interrupt.c

39

mei_cl_complete(cl, cb);

drivers/misc/mei/interrupt.c

454

list_for_each_entry(cl, &dev->file_list, link) {

drivers/misc/mei/interrupt.c

455

if (mei_cl_hbm_equal(cl, mei_hdr)) {

drivers/misc/mei/interrupt.c

456

cl_dbg(dev, cl, "got a message\n");

drivers/misc/mei/interrupt.c

457

ret = mei_cl_irq_read_msg(cl, mei_hdr, meta_hdr, cmpl_list);

drivers/misc/mei/interrupt.c

508

struct mei_cl *cl;

drivers/misc/mei/interrupt.c

52

static inline int mei_cl_hbm_equal(struct mei_cl *cl,

drivers/misc/mei/interrupt.c

528

cl = cb->cl;

drivers/misc/mei/interrupt.c

530

cl->status = 0;

drivers/misc/mei/interrupt.c

531

cl_dbg(dev, cl, "MEI WRITE COMPLETE\n");

drivers/misc/mei/interrupt.c

532

cl->writing_state = MEI_WRITE_COMPLETE;

drivers/misc/mei/interrupt.c

539

cl = cb->cl;

drivers/misc/mei/interrupt.c

543

ret = mei_cl_irq_disconnect(cl, cb, cmpl_list);

drivers/misc/mei/interrupt.c

55

return mei_cl_host_addr(cl) == mei_hdr->host_addr &&

drivers/misc/mei/interrupt.c

550

ret = mei_cl_irq_read(cl, cb, cmpl_list);

drivers/misc/mei/interrupt.c

557

ret = mei_cl_irq_connect(cl, cb, cmpl_list);

drivers/misc/mei/interrupt.c

56

mei_cl_me_id(cl) == mei_hdr->me_addr;

drivers/misc/mei/interrupt.c

564

ret = mei_cl_irq_disconnect_rsp(cl, cb, cmpl_list);

drivers/misc/mei/interrupt.c

571

ret = mei_cl_irq_notify(cl, cb, cmpl_list);

drivers/misc/mei/interrupt.c

576

ret = mei_cl_irq_dma_map(cl, cb, cmpl_list);

drivers/misc/mei/interrupt.c

581

ret = mei_cl_irq_dma_unmap(cl, cb, cmpl_list);

drivers/misc/mei/interrupt.c

593

cl = cb->cl;

drivers/misc/mei/interrupt.c

594

ret = mei_cl_irq_write(cl, cb, cmpl_list);

drivers/misc/mei/interrupt.c

608

static void mei_connect_timeout(struct mei_cl *cl)

drivers/misc/mei/interrupt.c

610

struct mei_device *dev = cl->dev;

drivers/misc/mei/interrupt.c

612

if (cl->state == MEI_FILE_CONNECTING) {

drivers/misc/mei/interrupt.c

614

cl->state = MEI_FILE_DISCONNECT_REQUIRED;

drivers/misc/mei/interrupt.c

615

wake_up(&cl->wait);

drivers/misc/mei/interrupt.c

643

struct mei_cl *cl;

drivers/misc/mei/interrupt.c

669

list_for_each_entry(cl, &dev->file_list, link) {

drivers/misc/mei/interrupt.c

670

if (cl->timer_count) {

drivers/misc/mei/interrupt.c

671

if (--cl->timer_count == 0) {

drivers/misc/mei/interrupt.c

673

mei_connect_timeout(cl);

drivers/misc/mei/interrupt.c

93

static int mei_cl_irq_read_msg(struct mei_cl *cl,

drivers/misc/mei/interrupt.c

98

struct mei_device *dev = cl->dev;

drivers/misc/mei/main.c

118

struct mei_cl *cl = file->private_data;

drivers/misc/mei/main.c

122

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/main.c

125

dev = cl->dev;

drivers/misc/mei/main.c

129

mei_cl_vtag_remove_by_fp(cl, file);

drivers/misc/mei/main.c

131

if (!list_empty(&cl->vtag_map)) {

drivers/misc/mei/main.c

132

cl_dbg(dev, cl, "not the last vtag\n");

drivers/misc/mei/main.c

133

mei_cl_flush_queues(cl, file);

drivers/misc/mei/main.c

138

rets = mei_cl_disconnect(cl);

drivers/misc/mei/main.c

143

if (!list_empty(&cl->vtag_map)) {

drivers/misc/mei/main.c

144

cl_dbg(dev, cl, "not the last vtag after disconnect\n");

drivers/misc/mei/main.c

145

mei_cl_flush_queues(cl, file);

drivers/misc/mei/main.c

149

mei_cl_flush_queues(cl, NULL);

drivers/misc/mei/main.c

150

cl_dbg(dev, cl, "removing\n");

drivers/misc/mei/main.c

152

mei_cl_unlink(cl);

drivers/misc/mei/main.c

153

kfree(cl);

drivers/misc/mei/main.c

177

struct mei_cl *cl = file->private_data;

drivers/misc/mei/main.c

183

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/main.c

186

dev = cl->dev;

drivers/misc/mei/main.c

205

cb = mei_cl_read_cb(cl, file);

drivers/misc/mei/main.c

212

rets = mei_cl_read_start(cl, length, file);

drivers/misc/mei/main.c

214

cl_dbg(dev, cl, "mei start read failure status = %zd\n", rets);

drivers/misc/mei/main.c

224

if (wait_event_interruptible(cl->rx_wait,

drivers/misc/mei/main.c

225

mei_cl_read_cb(cl, file) ||

drivers/misc/mei/main.c

226

!mei_cl_is_connected(cl))) {

drivers/misc/mei/main.c

233

if (!mei_cl_is_connected(cl)) {

drivers/misc/mei/main.c

238

cb = mei_cl_read_cb(cl, file);

drivers/misc/mei/main.c

248

cl_dbg(dev, cl, "read operation failed %zd\n", rets);

drivers/misc/mei/main.c

252

cl_dbg(dev, cl, "buf.size = %zu buf.idx = %zu offset = %lld\n",

drivers/misc/mei/main.c

264

cl_dbg(dev, cl, "failed to copy data to userland\n");

drivers/misc/mei/main.c

276

mei_cl_del_rd_completed(cl, cb);

drivers/misc/mei/main.c

280

cl_dbg(dev, cl, "end mei read rets = %zd\n", rets);

drivers/misc/mei/main.c

293

static u8 mei_cl_vtag_by_fp(const struct mei_cl *cl, const struct file *fp)

drivers/misc/mei/main.c

300

list_for_each_entry(cl_vtag, &cl->vtag_map, list)

drivers/misc/mei/main.c

319

struct mei_cl *cl = file->private_data;

drivers/misc/mei/main.c

324

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/main.c

327

dev = cl->dev;

drivers/misc/mei/main.c

336

if (!mei_cl_is_connected(cl)) {

drivers/misc/mei/main.c

337

cl_dbg(dev, cl, "is not connected");

drivers/misc/mei/main.c

342

if (!mei_me_cl_is_active(cl->me_cl)) {

drivers/misc/mei/main.c

347

if (length > mei_cl_mtu(cl)) {

drivers/misc/mei/main.c

357

while (cl->tx_cb_queued >= dev->tx_queue_limit) {

drivers/misc/mei/main.c

363

rets = wait_event_interruptible(cl->tx_wait,

drivers/misc/mei/main.c

364

cl->writing_state == MEI_WRITE_COMPLETE ||

drivers/misc/mei/main.c

365

(!mei_cl_is_connected(cl)));

drivers/misc/mei/main.c

372

if (!mei_cl_is_connected(cl)) {

drivers/misc/mei/main.c

378

cb = mei_cl_alloc_cb(cl, length, MEI_FOP_WRITE, file);

drivers/misc/mei/main.c

383

cb->vtag = mei_cl_vtag_by_fp(cl, file);

drivers/misc/mei/main.c

387

cl_dbg(dev, cl, "failed to copy data from userland\n");

drivers/misc/mei/main.c

393

rets = mei_cl_write(cl, cb, MAX_SCHEDULE_TIMEOUT);

drivers/misc/mei/main.c

416

struct mei_cl *cl;

drivers/misc/mei/main.c

419

cl = file->private_data;

drivers/misc/mei/main.c

420

dev = cl->dev;

drivers/misc/mei/main.c

422

if (cl->state != MEI_FILE_INITIALIZING &&

drivers/misc/mei/main.c

423

cl->state != MEI_FILE_DISCONNECTED)

drivers/misc/mei/main.c

430

cl_dbg(dev, cl, "Cannot connect to FW Client UUID = %pUl\n",

drivers/misc/mei/main.c

440

cl_dbg(dev, cl, "Connection forbidden to FW Client UUID = %pUl\n",

drivers/misc/mei/main.c

447

cl_dbg(dev, cl, "Connect to FW Client ID = %d\n", me_cl->client_id);

drivers/misc/mei/main.c

448

cl_dbg(dev, cl, "FW Client - Protocol Version = %d\n", me_cl->props.protocol_version);

drivers/misc/mei/main.c

449

cl_dbg(dev, cl, "FW Client - Max Msg Len = %d\n", me_cl->props.max_msg_length);

drivers/misc/mei/main.c

454

cl_dbg(dev, cl, "Can connect?\n");

drivers/misc/mei/main.c

456

rets = mei_cl_connect(cl, me_cl, file);

drivers/misc/mei/main.c

458

if (rets && cl->status == -EFAULT &&

drivers/misc/mei/main.c

50

struct mei_cl *cl;

drivers/misc/mei/main.c

536

struct mei_cl *cl;

drivers/misc/mei/main.c

540

cl = file->private_data;

drivers/misc/mei/main.c

541

dev = cl->dev;

drivers/misc/mei/main.c

543

cl_dbg(dev, cl, "FW Client %pUl vtag %d\n", in_client_uuid, vtag);

drivers/misc/mei/main.c

545

switch (cl->state) {

drivers/misc/mei/main.c

547

if (mei_cl_vtag_by_fp(cl, file) != vtag) {

drivers/misc/mei/main.c

548

cl_err(dev, cl, "reconnect with different vtag\n");

drivers/misc/mei/main.c

554

if (!IS_ERR(mei_cl_fp_by_vtag(cl, vtag))) {

drivers/misc/mei/main.c

555

cl_err(dev, cl, "vtag already filled\n");

drivers/misc/mei/main.c

560

if (pos == cl)

drivers/misc/mei/main.c

574

cl_dbg(dev, cl, "replacing with existing cl\n");

drivers/misc/mei/main.c

575

mei_cl_unlink(cl);

drivers/misc/mei/main.c

576

kfree(cl);

drivers/misc/mei/main.c

578

cl = pos;

drivers/misc/mei/main.c

586

list_add_tail(&cl_vtag->list, &cl->vtag_map);

drivers/misc/mei/main.c

592

while (cl->state != MEI_FILE_INITIALIZING &&

drivers/misc/mei/main.c

593

cl->state != MEI_FILE_DISCONNECTED &&

drivers/misc/mei/main.c

594

cl->state != MEI_FILE_CONNECTED) {

drivers/misc/mei/main.c

596

wait_event_timeout(cl->wait,

drivers/misc/mei/main.c

597

(cl->state == MEI_FILE_CONNECTED ||

drivers/misc/mei/main.c

598

cl->state == MEI_FILE_DISCONNECTED ||

drivers/misc/mei/main.c

599

cl->state == MEI_FILE_DISCONNECT_REQUIRED ||

drivers/misc/mei/main.c

600

cl->state == MEI_FILE_DISCONNECT_REPLY),

drivers/misc/mei/main.c

605

if (!mei_cl_is_connected(cl))

drivers/misc/mei/main.c

608

client->max_msg_length = cl->me_cl->props.max_msg_length;

drivers/misc/mei/main.c

609

client->protocol_version = cl->me_cl->props.protocol_version;

drivers/misc/mei/main.c

625

struct mei_cl *cl = file->private_data;

drivers/misc/mei/main.c

631

return mei_cl_notify_request(cl, file, (u8)request);

drivers/misc/mei/main.c

644

struct mei_cl *cl = file->private_data;

drivers/misc/mei/main.c

649

rets = mei_cl_notify_get(cl, block, &notify_ev);

drivers/misc/mei/main.c

669

struct mei_cl *cl = file->private_data;

drivers/misc/mei/main.c

679

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/main.c

68

cl = mei_cl_alloc_linked(dev);

drivers/misc/mei/main.c

682

dev = cl->dev;

drivers/misc/mei/main.c

684

cl_dbg(dev, cl, "IOCTL cmd = 0x%x", cmd);

drivers/misc/mei/main.c

69

if (IS_ERR(cl)) {

drivers/misc/mei/main.c

694

cl_dbg(dev, cl, "IOCTL_MEI_CONNECT_CLIENT\n");

drivers/misc/mei/main.c

696

cl_dbg(dev, cl, "failed to copy data from userland\n");

drivers/misc/mei/main.c

70

err = PTR_ERR(cl);

drivers/misc/mei/main.c

717

cl_dbg(dev, cl, "failed to copy data to userland\n");

drivers/misc/mei/main.c

725

cl_dbg(dev, cl, "IOCTL_MEI_CONNECT_CLIENT_VTAG\n");

drivers/misc/mei/main.c

728

cl_dbg(dev, cl, "failed to copy data from userland\n");

drivers/misc/mei/main.c

739

cl_dbg(dev, cl, "FW Client %pUl does not support vtags\n",

drivers/misc/mei/main.c

74

cl->fp = file;

drivers/misc/mei/main.c

745

cl_dbg(dev, cl, "vtag can't be zero\n");

drivers/misc/mei/main.c

75

file->private_data = cl;

drivers/misc/mei/main.c

757

cl_dbg(dev, cl, "failed to copy data to userland\n");

drivers/misc/mei/main.c

765

cl_dbg(dev, cl, "IOCTL_MEI_NOTIFY_SET\n");

drivers/misc/mei/main.c

768

cl_dbg(dev, cl, "failed to copy data from userland\n");

drivers/misc/mei/main.c

776

cl_dbg(dev, cl, "IOCTL_MEI_NOTIFY_GET\n");

drivers/misc/mei/main.c

781

cl_dbg(dev, cl, "copy connect data to user\n");

drivers/misc/mei/main.c

784

cl_dbg(dev, cl, "failed to copy data to userland\n");

drivers/misc/mei/main.c

811

struct mei_cl *cl = file->private_data;

drivers/misc/mei/main.c

816

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/main.c

819

dev = cl->dev;

drivers/misc/mei/main.c

823

notify_en = cl->notify_en && (req_events & EPOLLPRI);

drivers/misc/mei/main.c

826

!mei_cl_is_connected(cl)) {

drivers/misc/mei/main.c

832

poll_wait(file, &cl->ev_wait, wait);

drivers/misc/mei/main.c

833

if (cl->notify_ev)

drivers/misc/mei/main.c

838

poll_wait(file, &cl->rx_wait, wait);

drivers/misc/mei/main.c

840

if (mei_cl_read_cb(cl, file))

drivers/misc/mei/main.c

843

mei_cl_read_start(cl, mei_cl_mtu(cl), file);

drivers/misc/mei/main.c

847

poll_wait(file, &cl->tx_wait, wait);

drivers/misc/mei/main.c

848

if (cl->tx_cb_queued < dev->tx_queue_limit)

drivers/misc/mei/main.c

864

static bool mei_cl_is_write_queued(struct mei_cl *cl)

drivers/misc/mei/main.c

866

struct mei_device *dev = cl->dev;

drivers/misc/mei/main.c

870

if (cb->cl == cl)

drivers/misc/mei/main.c

873

if (cb->cl == cl)

drivers/misc/mei/main.c

890

struct mei_cl *cl = fp->private_data;

drivers/misc/mei/main.c

894

if (WARN_ON(!cl || !cl->dev))

drivers/misc/mei/main.c

897

dev = cl->dev;

drivers/misc/mei/main.c

901

if (dev->dev_state != MEI_DEV_ENABLED || !mei_cl_is_connected(cl)) {

drivers/misc/mei/main.c

906

while (mei_cl_is_write_queued(cl)) {

drivers/misc/mei/main.c

908

rets = wait_event_interruptible(cl->tx_wait,

drivers/misc/mei/main.c

909

cl->writing_state == MEI_WRITE_COMPLETE ||

drivers/misc/mei/main.c

910

!mei_cl_is_connected(cl));

drivers/misc/mei/main.c

917

if (!mei_cl_is_connected(cl)) {

drivers/misc/mei/main.c

94

static void mei_cl_vtag_remove_by_fp(const struct mei_cl *cl,

drivers/misc/mei/main.c

942

struct mei_cl *cl = file->private_data;

drivers/misc/mei/main.c

944

if (!mei_cl_is_connected(cl))

drivers/misc/mei/main.c

947

return fasync_helper(fd, file, band, &cl->ev_async);

drivers/misc/mei/main.c

99

list_for_each_entry_safe(vtag_l, next, &cl->vtag_map, list) {

drivers/misc/mei/mei_dev.h

236

struct mei_cl *cl;

drivers/misc/mei/mei_dev.h

399

ssize_t __mei_cl_send(struct mei_cl *cl, const u8 *buf, size_t length, u8 vtag,

drivers/misc/mei/mei_dev.h

401

ssize_t __mei_cl_send_timeout(struct mei_cl *cl, const u8 *buf, size_t length, u8 vtag,

drivers/misc/mei/mei_dev.h

403

ssize_t __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length, u8 *vtag,

drivers/misc/mei/mei_dev.h

405

bool mei_cl_bus_rx_event(struct mei_cl *cl);

drivers/misc/mei/mei_dev.h

406

bool mei_cl_bus_notify_event(struct mei_cl *cl);

drivers/mmc/host/sdhci-pci.h

113

#define SDHCI_PCI_DEVICE_CLASS(vend, cl, cl_msk, cfg) { \

drivers/mmc/host/sdhci-pci.h

116

.class = (cl), .class_mask = (cl_msk), \

drivers/mtd/nand/raw/cafe_nand.c

571

u8 ah, al, bh, bl, ch, cl;

drivers/mtd/nand/raw/cafe_nand.c

579

cl = gf64_mul(gf64_mul(ah, bh), 0x21) ^ gf64_mul(al, bl);

drivers/mtd/nand/raw/cafe_nand.c

581

return (ch << 6) ^ cl;

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

10393

cmd.u.params.cl = class;

drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h

3582

__u8 cl;

drivers/net/hamradio/scc.c

1253

cl(scc, R1, TxINT_ENAB); /* force an ABORT, but don't */

drivers/net/hamradio/scc.c

1254

cl(scc, R15, TxUIE); /* count it. */

drivers/net/hamradio/scc.c

1327

cl(scc, R15, DCDIE);

drivers/net/hamradio/scc.c

1331

cl(scc, R15, SYNCIE);

drivers/net/hamradio/scc.c

418

cl(scc, R10, ABUNDER); /* send CRC */

drivers/net/hamradio/scc.c

475

cl(scc,R3,ENT_HM|RxENABLE); /* disable the receiver */

drivers/net/hamradio/scc.c

723

cl(scc,R14,BRENABL); /* disable baudrate generator */

drivers/net/hamradio/scc.c

926

cl(scc, R3, RxENABLE|ENT_HM); /* switch off receiver */

drivers/net/hamradio/scc.c

927

cl(scc, R15, DCDIE|SYNCIE); /* No DCD changes, please */

drivers/net/hamradio/scc.c

943

cl(scc,R5,RTS|TxENAB);

drivers/net/hamradio/scc.c

964

cl(scc, R3, RxENABLE);

drivers/net/hamradio/scc.c

965

cl(scc, R15, DCDIE|SYNCIE);

drivers/net/hamradio/scc.c

977

cl(scc,R5,RTS|TxENAB); /* disable tx */

drivers/net/usb/cx82310_eth.c

343

#define USB_DEVICE_CLASS(vend, prod, cl, sc, pr) \

drivers/net/usb/cx82310_eth.c

348

.bDeviceClass = (cl), \

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

386

mt792x_acpi_get_mtcl_map_v3(int row, int column, struct mt792x_asar_cl_v3 *cl)

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

391

mode_be = (cl->mode_be > 0x02) ? 0 : cl->mode_be;

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

393

if (cl->version > 2 && cl->clbe[row] & BIT(column))

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

400

mt792x_acpi_get_mtcl_map(int row, int column, struct mt792x_asar_cl *cl)

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

405

mode_6g = (cl->mode_6g > 0x02) ? 0 : cl->mode_6g;

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

406

mode_5g9 = (cl->mode_5g9 > 0x01) ? 0 : cl->mode_5g9;

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

408

if ((cl->cl6g[row] & BIT(column)) || cl->mode_6g == 0x02)

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

410

if (cl->version > 1 && cl->cl5g9[row] & BIT(column))

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

420

struct mt792x_asar_cl_v3 *cl = sar->countrylist_v3;

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

426

if (!cl)

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

433

return mt792x_acpi_get_mtcl_map_v3(row, col, cl);

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

437

return mt792x_acpi_get_mtcl_map_v3(3, 7, cl);

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

449

struct mt792x_asar_cl *cl = sar->countrylist;

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

452

if (!cl)

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

459

return mt792x_acpi_get_mtcl_map(row, col, cl);

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

464

return mt792x_acpi_get_mtcl_map(0, 6, cl);

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

466

return mt792x_acpi_get_mtcl_map(0, 7, cl);

drivers/platform/x86/intel/int3472/clk_and_regulator.c

140

int3472->clock.cl = clkdev_create(int3472->clock.clk, NULL, int3472->sensor_name);

drivers/platform/x86/intel/int3472/clk_and_regulator.c

141

if (!int3472->clock.cl) {

drivers/platform/x86/intel/int3472/clk_and_regulator.c

158

if (int3472->clock.cl)

drivers/platform/x86/intel/int3472/clk_and_regulator.c

170

if (int3472->clock.cl)

drivers/platform/x86/intel/int3472/clk_and_regulator.c

180

if (!int3472->clock.cl)

drivers/platform/x86/intel/int3472/clk_and_regulator.c

183

clkdev_drop(int3472->clock.cl);

drivers/pmdomain/mediatek/mtk-mfg-pmdomain.c

248

struct mbox_client cl;

drivers/pmdomain/mediatek/mtk-mfg-pmdomain.c

645

static void mtk_mfg_mbox_rx_callback(struct mbox_client *cl, void *mssg)

drivers/pmdomain/mediatek/mtk-mfg-pmdomain.c

647

struct mtk_mfg_mbox *mb = container_of(cl, struct mtk_mfg_mbox, cl);

drivers/pmdomain/mediatek/mtk-mfg-pmdomain.c

813

gf->cl.dev = dev;

drivers/pmdomain/mediatek/mtk-mfg-pmdomain.c

814

gf->cl.rx_callback = mtk_mfg_mbox_rx_callback;

drivers/pmdomain/mediatek/mtk-mfg-pmdomain.c

815

gf->cl.tx_tout = GPUEB_TIMEOUT_US / USEC_PER_MSEC;

drivers/pmdomain/mediatek/mtk-mfg-pmdomain.c

816

gf->ch = mbox_request_channel_byname(&gf->cl, "gpufreq");

drivers/pmdomain/mediatek/mtk-mfg-pmdomain.c

828

slp->cl.dev = dev;

drivers/pmdomain/mediatek/mtk-mfg-pmdomain.c

829

slp->cl.tx_tout = GPUEB_TIMEOUT_US / USEC_PER_MSEC;

drivers/pmdomain/mediatek/mtk-mfg-pmdomain.c

830

slp->cl.tx_block = true;

drivers/pmdomain/mediatek/mtk-mfg-pmdomain.c

831

slp->ch = mbox_request_channel_byname(&slp->cl, "sleep");

drivers/power/supply/lp8727_charger.c

524

static int lp8727_probe(struct i2c_client *cl)

drivers/power/supply/lp8727_charger.c

530

if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK))

drivers/power/supply/lp8727_charger.c

533

if (cl->dev.of_node) {

drivers/power/supply/lp8727_charger.c

534

pdata = lp8727_parse_dt(&cl->dev);

drivers/power/supply/lp8727_charger.c

538

pdata = dev_get_platdata(&cl->dev);

drivers/power/supply/lp8727_charger.c

541

pchg = devm_kzalloc(&cl->dev, sizeof(*pchg), GFP_KERNEL);

drivers/power/supply/lp8727_charger.c

545

pchg->client = cl;

drivers/power/supply/lp8727_charger.c

546

pchg->dev = &cl->dev;

drivers/power/supply/lp8727_charger.c

548

i2c_set_clientdata(cl, pchg);

drivers/power/supply/lp8727_charger.c

573

static void lp8727_remove(struct i2c_client *cl)

drivers/power/supply/lp8727_charger.c

575

struct lp8727_chg *pchg = i2c_get_clientdata(cl);

drivers/regulator/lp872x.c

881

static int lp872x_probe(struct i2c_client *cl)

drivers/regulator/lp872x.c

883

const struct i2c_device_id *id = i2c_client_get_device_id(cl);

drivers/regulator/lp872x.c

892

if (cl->dev.of_node) {

drivers/regulator/lp872x.c

893

pdata = lp872x_populate_pdata_from_dt(&cl->dev,

drivers/regulator/lp872x.c

898

pdata = dev_get_platdata(&cl->dev);

drivers/regulator/lp872x.c

901

lp = devm_kzalloc(&cl->dev, sizeof(struct lp872x), GFP_KERNEL);

drivers/regulator/lp872x.c

907

lp->regmap = devm_regmap_init_i2c(cl, &lp872x_regmap_config);

drivers/regulator/lp872x.c

910

dev_err(&cl->dev, "regmap init i2c err: %d\n", ret);

drivers/regulator/lp872x.c

914

lp->dev = &cl->dev;

drivers/regulator/lp872x.c

917

i2c_set_clientdata(cl, lp);

drivers/remoteproc/imx_dsp_rproc.c

133

struct mbox_client cl;

drivers/remoteproc/imx_dsp_rproc.c

524

static void imx_dsp_rproc_rx_tx_callback(struct mbox_client *cl, void *data)

drivers/remoteproc/imx_dsp_rproc.c

526

struct rproc *rproc = dev_get_drvdata(cl->dev);

drivers/remoteproc/imx_dsp_rproc.c

554

static void imx_dsp_rproc_rxdb_callback(struct mbox_client *cl, void *data)

drivers/remoteproc/imx_dsp_rproc.c

556

struct rproc *rproc = dev_get_drvdata(cl->dev);

drivers/remoteproc/imx_dsp_rproc.c

572

struct mbox_client *cl;

drivers/remoteproc/imx_dsp_rproc.c

578

cl = &priv->cl;

drivers/remoteproc/imx_dsp_rproc.c

579

cl->dev = dev;

drivers/remoteproc/imx_dsp_rproc.c

580

cl->tx_block = true;

drivers/remoteproc/imx_dsp_rproc.c

581

cl->tx_tout = 100;

drivers/remoteproc/imx_dsp_rproc.c

582

cl->knows_txdone = false;

drivers/remoteproc/imx_dsp_rproc.c

583

cl->rx_callback = imx_dsp_rproc_rx_tx_callback;

drivers/remoteproc/imx_dsp_rproc.c

586

priv->tx_ch = mbox_request_channel_byname(cl, "tx");

drivers/remoteproc/imx_dsp_rproc.c

589

dev_dbg(cl->dev, "failed to request tx mailbox channel: %d\n",

drivers/remoteproc/imx_dsp_rproc.c

595

priv->rx_ch = mbox_request_channel_byname(cl, "rx");

drivers/remoteproc/imx_dsp_rproc.c

598

dev_dbg(cl->dev, "failed to request rx mailbox channel: %d\n",

drivers/remoteproc/imx_dsp_rproc.c

603

cl = &priv->cl_rxdb;

drivers/remoteproc/imx_dsp_rproc.c

604

cl->dev = dev;

drivers/remoteproc/imx_dsp_rproc.c

605

cl->rx_callback = imx_dsp_rproc_rxdb_callback;

drivers/remoteproc/imx_dsp_rproc.c

611

priv->rxdb_ch = mbox_request_channel_byname(cl, "rxdb");

drivers/remoteproc/imx_dsp_rproc.c

614

dev_dbg(cl->dev, "failed to request mbox chan rxdb, ret %d\n",

drivers/remoteproc/imx_rproc.c

115

struct mbox_client cl;

drivers/remoteproc/imx_rproc.c

847

static void imx_rproc_rx_callback(struct mbox_client *cl, void *msg)

drivers/remoteproc/imx_rproc.c

849

struct rproc *rproc = dev_get_drvdata(cl->dev);

drivers/remoteproc/imx_rproc.c

859

struct mbox_client *cl;

drivers/remoteproc/imx_rproc.c

876

cl = &priv->cl;

drivers/remoteproc/imx_rproc.c

877

cl->dev = dev;

drivers/remoteproc/imx_rproc.c

878

cl->tx_block = tx_block;

drivers/remoteproc/imx_rproc.c

879

cl->tx_tout = 100;

drivers/remoteproc/imx_rproc.c

880

cl->knows_txdone = false;

drivers/remoteproc/imx_rproc.c

881

cl->rx_callback = imx_rproc_rx_callback;

drivers/remoteproc/imx_rproc.c

883

priv->tx_ch = mbox_request_channel_byname(cl, "tx");

drivers/remoteproc/imx_rproc.c

885

return dev_err_probe(cl->dev, PTR_ERR(priv->tx_ch),

drivers/remoteproc/imx_rproc.c

888

priv->rx_ch = mbox_request_channel_byname(cl, "rx");

drivers/remoteproc/imx_rproc.c

891

return dev_err_probe(cl->dev, PTR_ERR(priv->rx_ch),

drivers/remoteproc/stm32_rproc.c

299

static void stm32_rproc_mb_callback(struct mbox_client *cl, void *data)

drivers/remoteproc/stm32_rproc.c

301

struct rproc *rproc = dev_get_drvdata(cl->dev);

drivers/remoteproc/stm32_rproc.c

302

struct stm32_mbox *mb = container_of(cl, struct stm32_mbox, client);

drivers/remoteproc/stm32_rproc.c

364

struct mbox_client *cl;

drivers/remoteproc/stm32_rproc.c

372

cl = &ddata->mb[i].client;

drivers/remoteproc/stm32_rproc.c

373

cl->dev = dev->parent;

drivers/remoteproc/stm32_rproc.c

375

ddata->mb[i].chan = mbox_request_channel_byname(cl, name);

drivers/remoteproc/xlnx_r5_remoteproc.c

227

static void zynqmp_r5_mb_rx_cb(struct mbox_client *cl, void *msg)

drivers/remoteproc/xlnx_r5_remoteproc.c

233

ipi = container_of(cl, struct mbox_info, mbox_cl);

drivers/remoteproc/xlnx_r5_remoteproc.c

240

dev_warn(cl->dev, "msg size exceeded than %d\n",

drivers/remoteproc/xlnx_r5_remoteproc.c

249

dev_err(cl->dev, "ack failed to mbox rx_chan\n");

drivers/sbus/char/oradax.c

230

static const struct class cl = {

drivers/sbus/char/oradax.c

328

ret = class_register(&cl);

drivers/sbus/char/oradax.c

332

if (device_create(&cl, NULL, first, NULL, dax_name) == NULL) {

drivers/sbus/char/oradax.c

349

device_destroy(&cl, first);

drivers/sbus/char/oradax.c

351

class_unregister(&cl);

drivers/sbus/char/oradax.c

364

device_destroy(&cl, first);

drivers/sbus/char/oradax.c

365

class_unregister(&cl);

drivers/scsi/megaraid/megaraid_sas.h

2093

union megasas_evt_class_locale cl;

drivers/scsi/megaraid/megaraid_sas_base.c

425

class_locale.word = le32_to_cpu(evt_detail->cl.word);

drivers/soc/fsl/dpio/qbman-portal.c

652

const uint32_t *cl = (uint32_t *)d;

drivers/soc/fsl/dpio/qbman-portal.c

682

memcpy(&p[1], &cl[1], EQ_DESC_SIZE_WITHOUT_FD - 1);

drivers/soc/fsl/dpio/qbman-portal.c

694

p[0] = cl[0] | s->eqcr.pi_vb;

drivers/soc/fsl/dpio/qbman-portal.c

735

const uint32_t *cl = (uint32_t *)(d);

drivers/soc/fsl/dpio/qbman-portal.c

764

memcpy(&p[1], &cl[1], EQ_DESC_SIZE_WITHOUT_FD - 1);

drivers/soc/fsl/dpio/qbman-portal.c

774

p[0] = cl[0] | s->eqcr.pi_vb;

drivers/soc/fsl/dpio/qbman-portal.c

812

const uint32_t *cl;

drivers/soc/fsl/dpio/qbman-portal.c

835

cl = (uint32_t *)(&d[i]);

drivers/soc/fsl/dpio/qbman-portal.c

837

memcpy(&p[1], &cl[1], EQ_DESC_SIZE_WITHOUT_FD - 1);

drivers/soc/fsl/dpio/qbman-portal.c

849

cl = (uint32_t *)(&d[i]);

drivers/soc/fsl/dpio/qbman-portal.c

850

p[0] = cl[0] | s->eqcr.pi_vb;

drivers/soc/fsl/dpio/qbman-portal.c

882

const uint32_t *cl;

drivers/soc/fsl/dpio/qbman-portal.c

905

cl = (uint32_t *)(&d[i]);

drivers/soc/fsl/dpio/qbman-portal.c

907

memcpy(&p[1], &cl[1], EQ_DESC_SIZE_WITHOUT_FD - 1);

drivers/soc/fsl/dpio/qbman-portal.c

917

cl = (uint32_t *)(&d[i]);

drivers/soc/fsl/dpio/qbman-portal.c

918

p[0] = cl[0] | s->eqcr.pi_vb;

drivers/soc/hisilicon/kunpeng_hccs.c

150

static void hccs_chan_tx_done(struct mbox_client *cl, void *msg, int ret)

drivers/soc/hisilicon/kunpeng_hccs.c

160

static void hccs_pcc_rx_callback(struct mbox_client *cl, void *mssg)

drivers/soc/hisilicon/kunpeng_hccs.c

163

container_of(cl, struct hccs_mbox_client_info, client);

drivers/soc/hisilicon/kunpeng_hccs.c

176

struct mbox_client *cl = &cl_info->client;

drivers/soc/hisilicon/kunpeng_hccs.c

182

cl->dev = dev;

drivers/soc/hisilicon/kunpeng_hccs.c

183

cl->tx_block = false;

drivers/soc/hisilicon/kunpeng_hccs.c

184

cl->knows_txdone = true;

drivers/soc/hisilicon/kunpeng_hccs.c

185

cl->tx_done = hccs_chan_tx_done;

drivers/soc/hisilicon/kunpeng_hccs.c

186

cl->rx_callback = hdev->verspec_data->rx_callback;

drivers/soc/hisilicon/kunpeng_hccs.c

189

pcc_chan = pcc_mbox_request_channel(cl, hdev->chan_id);

drivers/soc/hisilicon/kunpeng_hccs.h

71

void (*rx_callback)(struct mbox_client *cl, void *mssg);

drivers/soc/samsung/gs101-pmu.c

194

#define CLUSTER_CPU_RANGE(cl, cpu) \

drivers/soc/samsung/gs101-pmu.c

195

regmap_reg_range(GS101_CLUSTER_CPU_IN(cl, cpu), \

drivers/soc/samsung/gs101-pmu.c

196

GS101_CLUSTER_CPU_IN(cl, cpu)), \

drivers/soc/samsung/gs101-pmu.c

197

regmap_reg_range(GS101_CLUSTER_CPU_INT_IN(cl, cpu), \

drivers/soc/samsung/gs101-pmu.c

198

GS101_CLUSTER_CPU_INT_IN(cl, cpu))

drivers/soc/samsung/gs101-pmu.c

210

#define CLUSTER_NONCPU_RANGE(cl) \

drivers/soc/samsung/gs101-pmu.c

211

regmap_reg_range(GS101_CLUSTER_NONCPU_IN(cl), \

drivers/soc/samsung/gs101-pmu.c

212

GS101_CLUSTER_NONCPU_IN(cl)), \

drivers/soc/samsung/gs101-pmu.c

213

regmap_reg_range(GS101_CLUSTER_NONCPU_INT_IN(cl), \

drivers/soc/samsung/gs101-pmu.c

214

GS101_CLUSTER_NONCPU_INT_IN(cl)), \

drivers/soc/samsung/gs101-pmu.c

215

regmap_reg_range(GS101_CLUSTER_NONCPU_DUALRAIL_CTRL_IN(cl), \

drivers/soc/samsung/gs101-pmu.c

216

GS101_CLUSTER_NONCPU_DUALRAIL_CTRL_IN(cl))

drivers/soc/samsung/gs101-pmu.c

39

#define CLUSTER_CPU_RANGE(cl, cpu) \

drivers/soc/samsung/gs101-pmu.c

40

regmap_reg_range(GS101_CLUSTER_CPU_CONFIGURATION(cl, cpu), \

drivers/soc/samsung/gs101-pmu.c

41

GS101_CLUSTER_CPU_OPTION(cl, cpu)), \

drivers/soc/samsung/gs101-pmu.c

42

regmap_reg_range(GS101_CLUSTER_CPU_OUT(cl, cpu), \

drivers/soc/samsung/gs101-pmu.c

43

GS101_CLUSTER_CPU_IN(cl, cpu)), \

drivers/soc/samsung/gs101-pmu.c

44

regmap_reg_range(GS101_CLUSTER_CPU_INT_IN(cl, cpu), \

drivers/soc/samsung/gs101-pmu.c

45

GS101_CLUSTER_CPU_INT_DIR(cl, cpu))

drivers/soc/samsung/gs101-pmu.c

58

#define CLUSTER_NONCPU_RANGE(cl) \

drivers/soc/samsung/gs101-pmu.c

59

regmap_reg_range(GS101_CLUSTER_NONCPU_CONFIGURATION(cl), \

drivers/soc/samsung/gs101-pmu.c

60

GS101_CLUSTER_NONCPU_OPTION(cl)), \

drivers/soc/samsung/gs101-pmu.c

61

regmap_reg_range(GS101_CLUSTER_NONCPU_OUT(cl), \

drivers/soc/samsung/gs101-pmu.c

62

GS101_CLUSTER_NONCPU_IN(cl)), \

drivers/soc/samsung/gs101-pmu.c

63

regmap_reg_range(GS101_CLUSTER_NONCPU_INT_IN(cl), \

drivers/soc/samsung/gs101-pmu.c

64

GS101_CLUSTER_NONCPU_INT_DIR(cl)), \

drivers/soc/samsung/gs101-pmu.c

65

regmap_reg_range(GS101_CLUSTER_NONCPU_DUALRAIL_CTRL_OUT(cl), \

drivers/soc/samsung/gs101-pmu.c

66

GS101_CLUSTER_NONCPU_DUALRAIL_POS_OUT(cl)), \

drivers/soc/samsung/gs101-pmu.c

67

regmap_reg_range(GS101_CLUSTER_NONCPU_DUALRAIL_CTRL_IN(cl), \

drivers/soc/samsung/gs101-pmu.c

68

GS101_CLUSTER_NONCPU_DUALRAIL_CTRL_IN(cl))

drivers/soc/xilinx/zynqmp_power.c

127

static void ipi_receive_callback(struct mbox_client *cl, void *data)

drivers/staging/iio/addac/adt7316-i2c.c

22

struct i2c_client *cl = client;

drivers/staging/iio/addac/adt7316-i2c.c

25

ret = i2c_smbus_write_byte(cl, reg);

drivers/staging/iio/addac/adt7316-i2c.c

27

dev_err(&cl->dev, "I2C fail to select reg\n");

drivers/staging/iio/addac/adt7316-i2c.c

33

dev_err(&cl->dev, "I2C read error\n");

drivers/staging/iio/addac/adt7316-i2c.c

44

struct i2c_client *cl = client;

drivers/staging/iio/addac/adt7316-i2c.c

47

ret = i2c_smbus_write_byte_data(cl, reg, data);

drivers/staging/iio/addac/adt7316-i2c.c

49

dev_err(&cl->dev, "I2C write error\n");

drivers/staging/iio/addac/adt7316-i2c.c

56

struct i2c_client *cl = client;

drivers/staging/iio/addac/adt7316-i2c.c

63

ret = adt7316_i2c_read(cl, reg, &data[i]);

drivers/staging/iio/addac/adt7316-i2c.c

65

dev_err(&cl->dev, "I2C multi read error\n");

drivers/staging/iio/addac/adt7316-i2c.c

75

struct i2c_client *cl = client;

drivers/staging/iio/addac/adt7316-i2c.c

82

ret = adt7316_i2c_write(cl, reg, data[i]);

drivers/staging/iio/addac/adt7316-i2c.c

84

dev_err(&cl->dev, "I2C multi write error\n");

drivers/staging/media/av7110/av7110_hw.c

934

u16 ch, cl;

drivers/staging/media/av7110/av7110_hw.c

938

cl = (yuv & 0xffff);

drivers/staging/media/av7110/av7110_hw.c

941

color, ch, cl);

drivers/tty/n_gsm.c

1688

int cl = clen;

drivers/tty/n_gsm.c

1692

len = gsm_read_ea_val(&addr, data, cl);

drivers/tty/n_gsm.c

1703

if ((cl - len) < 1)

drivers/tty/n_gsm.c

1707

cl -= len;

drivers/tty/n_gsm.c

1710

len = gsm_read_ea_val(&modem, dp, cl);

drivers/tty/n_gsm.c

1715

gsm_process_modem(tty, dlci, modem, cl);

drivers/tty/n_gsm.c

597

unsigned int i, cl;

drivers/tty/n_gsm.c

613

cl = 0; /* convergence layer type 1 */

drivers/tty/n_gsm.c

616

cl = 1; /* convergence layer type 2 */

drivers/tty/n_gsm.c

626

FIELD_PREP(PN_I_CL_FIELD_ADAPTION, cl);

drivers/tty/serial/tegra-tcu.c

162

static void tegra_tcu_receive(struct mbox_client *cl, void *msg)

drivers/tty/serial/tegra-tcu.c

164

struct tegra_tcu *tcu = container_of(cl, struct tegra_tcu, rx_client);

drivers/video/backlight/arcxcnn_bl.c

241

static int arcxcnn_probe(struct i2c_client *cl)

drivers/video/backlight/arcxcnn_bl.c

246

if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_BYTE_DATA))

drivers/video/backlight/arcxcnn_bl.c

249

lp = devm_kzalloc(&cl->dev, sizeof(*lp), GFP_KERNEL);

drivers/video/backlight/arcxcnn_bl.c

253

lp->client = cl;

drivers/video/backlight/arcxcnn_bl.c

254

lp->dev = &cl->dev;

drivers/video/backlight/arcxcnn_bl.c

255

lp->pdata = dev_get_platdata(&cl->dev);

drivers/video/backlight/arcxcnn_bl.c

298

i2c_set_clientdata(cl, lp);

drivers/video/backlight/arcxcnn_bl.c

362

static void arcxcnn_remove(struct i2c_client *cl)

drivers/video/backlight/arcxcnn_bl.c

364

struct arcxcnn *lp = i2c_get_clientdata(cl);

drivers/video/backlight/lp855x_bl.c

395

static int lp855x_probe(struct i2c_client *cl)

drivers/video/backlight/lp855x_bl.c

397

const struct i2c_device_id *id = i2c_client_get_device_id(cl);

drivers/video/backlight/lp855x_bl.c

399

struct device *dev = &cl->dev;

drivers/video/backlight/lp855x_bl.c

403

if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK))

drivers/video/backlight/lp855x_bl.c

410

lp->client = cl;

drivers/video/backlight/lp855x_bl.c

513

i2c_set_clientdata(cl, lp);

drivers/video/backlight/lp855x_bl.c

547

static void lp855x_remove(struct i2c_client *cl)

drivers/video/backlight/lp855x_bl.c

549

struct lp855x *lp = i2c_get_clientdata(cl);

fs/ceph/acl.c

35

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/acl.c

77

pr_err_ratelimited_client(cl, "%llx.%llx failed, err=%d\n",

fs/ceph/addr.c

1070

struct ceph_client *cl = fsc->client;

fs/ceph/addr.c

1077

doutc(cl, " no snap context with dirty data?\n");

fs/ceph/addr.c

1081

doutc(cl, " oldest snapc is %p seq %lld (%d snaps)\n",

fs/ceph/addr.c

1094

doutc(cl, " cyclic, start at %lu\n", ceph_wbc->index);

fs/ceph/addr.c

1100

doutc(cl, " not cyclic, %lu to %lu\n",

fs/ceph/addr.c

1110

doutc(cl, " non-head snapc, range whole\n");

fs/ceph/addr.c

1141

struct ceph_client *cl = fsc->client;

fs/ceph/addr.c

1146

doutc(cl, "!dirty or !mapping %p\n", folio);

fs/ceph/addr.c

1153

doutc(cl, "folio snapc %p %lld != oldest %p %lld\n",

fs/ceph/addr.c

1165

doutc(cl, "folio at %lu beyond eof %llu\n",

fs/ceph/addr.c

117

doutc(cl, "%llx.%llx %p idx %lu head %d/%d -> %d/%d "

fs/ceph/addr.c

1178

doutc(cl, "end of strip unit %p\n", folio);

fs/ceph/addr.c

1251

struct ceph_client *cl = fsc->client;

fs/ceph/addr.c

1265

pr_err_client(cl, "inode->i_blkbits=%hhu\n",

fs/ceph/addr.c

1291

struct ceph_client *cl = fsc->client;

fs/ceph/addr.c

1302

doutc(cl, "? %p idx %lu, folio_test_writeback %#x, "

fs/ceph/addr.c

1310

doutc(cl, "waiting on writeback %p\n", folio);

fs/ceph/addr.c

1333

doutc(cl, "%p !folio_clear_dirty_for_io\n", folio);

fs/ceph/addr.c

1360

doutc(cl, "%llx.%llx will write folio %p idx %lu\n",

fs/ceph/addr.c

1408

struct ceph_client *cl = fsc->client;

fs/ceph/addr.c

144

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/addr.c

150

doutc(cl, "%llx.%llx idx %lu partial dirty page %zu~%zu\n",

fs/ceph/addr.c

1500

doutc(cl, "got pages at %llu~%llu\n", offset, len);

fs/ceph/addr.c

1541

doutc(cl, "got pages at %llu~%llu\n", offset, len);

fs/ceph/addr.c

1545

pr_warn_client(cl,

fs/ceph/addr.c

157

doutc(cl, "%llx.%llx idx %lu full dirty page\n",

fs/ceph/addr.c

1627

struct ceph_client *cl = fsc->client;

fs/ceph/addr.c

1634

doutc(cl, "%llx.%llx (mode=%s)\n", ceph_vinop(inode),

fs/ceph/addr.c

1676

doutc(cl, "pagevec_lookup_range_tag for tag %#x got %d\n",

fs/ceph/addr.c

1693

doutc(cl, "reached end fbatch, trying for more\n");

fs/ceph/addr.c

1721

doutc(cl, "folio_batch release on %d folios (%p)\n",

fs/ceph/addr.c

1729

doutc(cl, "looping back to beginning of file\n");

fs/ceph/addr.c

1750

doutc(cl, "%llx.%llx dend - startone, rc = %d\n", ceph_vinop(inode),

fs/ceph/addr.c

1784

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/addr.c

1788

doutc(cl, " %llx.%llx folio %p is shutdown\n",

fs/ceph/addr.c

1810

doutc(cl, " %llx.%llx folio %p snapc %p not current or oldest\n",

fs/ceph/addr.c

1817

doutc(cl, " %llx.%llx folio %p snapc %p not current, but oldest\n",

fs/ceph/addr.c

1888

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/addr.c

1891

doutc(cl, "%llx.%llx file %p folio %p %d~%d (%d)\n", ceph_vinop(inode),

fs/ceph/addr.c

1952

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/addr.c

1964

doutc(cl, "%llx.%llx %llu trying to get caps\n",

fs/ceph/addr.c

1976

doutc(cl, "%llx.%llx %llu got cap refs on %s\n", ceph_vinop(inode),

fs/ceph/addr.c

1985

doutc(cl, "%llx.%llx %llu drop cap refs %s ret %x\n",

fs/ceph/addr.c

2027

doutc(cl, "%llx.%llx %llu read inline data ret %x\n",

fs/ceph/addr.c

2042

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/addr.c

2069

doutc(cl, "%llx.%llx %llu~%zd getting caps i_size %llu\n",

fs/ceph/addr.c

2081

doutc(cl, "%llx.%llx %llu~%zd got cap refs on %s\n", ceph_vinop(inode),

fs/ceph/addr.c

2130

doutc(cl, "%llx.%llx %llu~%zd dropping cap refs on %s ret %x\n",

fs/ceph/addr.c

2145

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/addr.c

215

struct ceph_client *cl = fsc->client;

fs/ceph/addr.c

2166

doutc(cl, "%p %llx.%llx len %zu locked_page %p\n", inode,

fs/ceph/addr.c

2192

struct ceph_client *cl = fsc->client;

fs/ceph/addr.c

2206

doutc(cl, "%llx.%llx inline_version %llu\n", ceph_vinop(inode),

fs/ceph/addr.c

225

doutc(cl, "result %d subreq->len=%zu i_size=%lld\n", req->r_result,

fs/ceph/addr.c

2338

doutc(cl, "%llx.%llx inline_version %llu = %d\n",

fs/ceph/addr.c

2368

struct ceph_client *cl = fsc->client;

fs/ceph/addr.c

2403

doutc(cl, "pool %lld ns %.*s no perm cached\n", pool,

fs/ceph/addr.c

2406

doutc(cl, "pool %lld no perm cached\n", pool);

fs/ceph/addr.c

2531

doutc(cl, "pool %lld ns %.*s result = %d\n", pool,

fs/ceph/addr.c

2534

doutc(cl, "pool %lld result = %d\n", pool, err);

fs/ceph/addr.c

2540

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/addr.c

2570

doutc(cl, "pool %lld no read perm\n", pool);

fs/ceph/addr.c

2574

doutc(cl, "pool %lld no write perm\n", pool);

fs/ceph/addr.c

356

struct ceph_client *cl = fsc->client;

fs/ceph/addr.c

398

doutc(cl, "%llx.%llx pos=%llu orig_len=%zu len=%llu\n",

fs/ceph/addr.c

423

doutc(cl, "%llx.%llx failed to allocate pages, %d\n",

fs/ceph/addr.c

455

doutc(cl, "%llx.%llx result %d\n", ceph_vinop(inode), err);

fs/ceph/addr.c

462

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/addr.c

497

doutc(cl, "%llx.%llx, error getting cap\n", ceph_vinop(inode));

fs/ceph/addr.c

502

doutc(cl, "%llx.%llx, no cache cap\n", ceph_vinop(inode));

fs/ceph/addr.c

626

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/addr.c

632

doutc(cl, " capsnap %p snapc %p has %d dirty pages\n",

fs/ceph/addr.c

665

doutc(cl, " head snapc %p has %d dirty pages\n", snapc,

fs/ceph/addr.c

724

struct ceph_client *cl = fsc->client;

fs/ceph/addr.c

736

doutc(cl, "%llx.%llx folio %p idx %lu\n", ceph_vinop(inode), folio,

fs/ceph/addr.c

745

doutc(cl, "%llx.%llx folio %p not dirty?\n", ceph_vinop(inode),

fs/ceph/addr.c

751

doutc(cl, "%llx.%llx folio %p snapc %p not writeable - noop\n",

fs/ceph/addr.c

763

doutc(cl, "%llx.%llx folio at %lu beyond eof %llu\n",

fs/ceph/addr.c

773

doutc(cl, "%llx.%llx folio %p index %lu on %llu~%llu snapc %p seq %lld\n",

fs/ceph/addr.c

816

doutc(cl, "%llx.%llx %llu~%llu (%llu bytes, %sencrypted)\n",

fs/ceph/addr.c

837

doutc(cl, "%llx.%llx interrupted page %p\n",

fs/ceph/addr.c

84

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/addr.c

845

doutc(cl, "%llx.%llx setting mapping error %d %p\n",

fs/ceph/addr.c

850

doutc(cl, "%llx.%llx cleaned page %p\n",

fs/ceph/addr.c

877

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/addr.c

890

doutc(cl, "%llx.%llx rc %d\n", ceph_vinop(inode), rc);

fs/ceph/addr.c

90

doutc(cl, "%llx.%llx %p idx %lu -- already dirty\n",

fs/ceph/addr.c

912

pr_warn_client(cl,

fs/ceph/addr.c

948

doutc(cl, "unlocking %p\n", page);

fs/ceph/addr.c

956

doutc(cl, "%llx.%llx wrote %llu bytes cleaned %d pages\n",

fs/ceph/addr.c

983

struct ceph_client *cl = fsc->client;

fs/ceph/addr.c

987

pr_warn_ratelimited_client(cl,

fs/ceph/caps.c

1125

struct ceph_client *cl = session->s_mdsc->fsc->client;

fs/ceph/caps.c

1133

doutc(cl, "inode is NULL\n");

fs/ceph/caps.c

1139

doutc(cl, "%p from %p %llx.%llx\n", cap, inode, ceph_vinop(inode));

fs/ceph/caps.c

1152

doutc(cl, "delaying %p removal from session %p\n", cap,

fs/ceph/caps.c

1397

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

1406

doutc(cl, "%p %llx.%llx cap %p session %p %s -> %s (revoking %s)\n",

fs/ceph/caps.c

1525

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

1530

pr_err_client(cl,

fs/ceph/caps.c

1624

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

1629

doutc(cl, "%p %llx.%llx session %p\n", inode, ceph_vinop(inode),

fs/ceph/caps.c

1645

doutc(cl, "already flushed %p, skipping\n", capsnap);

fs/ceph/caps.c

1677

doutc(cl, "%p %llx.%llx auth cap %p not mds%d, stop\n",

fs/ceph/caps.c

1699

doutc(cl, "%p %llx.%llx capsnap %p tid %llu %s\n", inode,

fs/ceph/caps.c

1706

pr_err_client(cl, "error sending cap flushsnap, "

fs/ceph/caps.c

1722

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

1727

doutc(cl, "%p %llx.%llx\n", inode, ceph_vinop(inode));

fs/ceph/caps.c

1733

doutc(cl, " no capsnap needs flush, doing nothing\n");

fs/ceph/caps.c

1737

doutc(cl, " no auth cap (migrating?), doing nothing\n");

fs/ceph/caps.c

1743

doutc(cl, " oops, wrong session %p mutex\n", session);

fs/ceph/caps.c

1789

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

1796

pr_warn_client(cl, "%p %llx.%llx mask %s, "

fs/ceph/caps.c

1803

doutc(cl, "%p %llx.%llx %s dirty %s -> %s\n", inode,

fs/ceph/caps.c

1818

doutc(cl, "%p %llx.%llx now dirty snapc %p auth cap %p\n",

fs/ceph/caps.c

1914

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

1925

doutc(cl, "flushing %s, flushing_caps %s -> %s\n",

fs/ceph/caps.c

1931

doutc(cl, "%p %llx.%llx now !dirty\n", inode, ceph_vinop(inode));

fs/ceph/caps.c

1962

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

1974

doutc(cl, "%p %llx.%llx success\n", inode,

fs/ceph/caps.c

1980

doutc(cl, "%p %llx.%llx failed\n", inode, ceph_vinop(inode));

fs/ceph/caps.c

2014

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

207

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

2089

doutc(cl, "%p %llx.%llx file_want %s used %s dirty %s "

fs/ceph/caps.c

2113

doutc(cl, "trying to invalidate on %p %llx.%llx\n",

fs/ceph/caps.c

2116

doutc(cl, "queuing invalidate\n");

fs/ceph/caps.c

2144

doutc(cl, " mds%d cap %p used %s issued %s implemented %s revoking %s\n",

fs/ceph/caps.c

2153

doutc(cl, "completed revocation of %s\n",

fs/ceph/caps.c

2175

doutc(cl, "force to flush caps\n");

fs/ceph/caps.c

218

doutc(cl, "ctx=%p need=%d\n", ctx, need);

fs/ceph/caps.c

2184

doutc(cl, "requesting new max_size\n");

fs/ceph/caps.c

2190

doutc(cl, "i_size approaching max_size\n");

fs/ceph/caps.c

2197

doutc(cl, "flushing dirty caps\n");

fs/ceph/caps.c

2201

doutc(cl, "flushing snap caps\n");

fs/ceph/caps.c

2363

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

2453

doutc(cl, "%p %llx.%llx wait on tid %llu %llu\n", inode,

fs/ceph/caps.c

2481

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

2486

doutc(cl, "%p %llx.%llx%s\n", inode, ceph_vinop(inode),

fs/ceph/caps.c

2498

doutc(cl, "dirty caps are %s\n", ceph_cap_string(dirty));

fs/ceph/caps.c

2519

doutc(cl, "%p %llx.%llx%s result=%d\n", inode, ceph_vinop(inode),

fs/ceph/caps.c

2533

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

2539

doutc(cl, "%p %llx.%llx wait=%d\n", inode, ceph_vinop(inode), wait);

fs/ceph/caps.c

2569

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

2595

pr_err_client(cl, "%p auth cap %p not mds%d ???\n",

fs/ceph/caps.c

2605

doutc(cl, "%p %llx.%llx cap %p tid %llu %s\n",

fs/ceph/caps.c

2621

doutc(cl, "%p %llx.%llx capsnap %p tid %llu %s\n",

fs/ceph/caps.c

2631

pr_err_client(cl, "error sending cap flushsnap,"

fs/ceph/caps.c

2647

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

2652

doutc(cl, "mds%d\n", session->s_mds);

fs/ceph/caps.c

2664

pr_err_client(cl, "%p %llx.%llx auth cap %p not mds%d ???\n",

fs/ceph/caps.c

2699

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

2706

doutc(cl, "mds%d\n", session->s_mds);

fs/ceph/caps.c

2718

pr_err_client(cl, "%p %llx.%llx auth cap %p not mds%d ???\n",

fs/ceph/caps.c

2766

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

278

pr_warn_client(cl, "ctx=%p ENOMEM need=%d got=%d\n", ctx, need,

fs/ceph/caps.c

2790

doutc(cl, "%p %llx.%llx wb %d -> %d (?)\n", inode,

fs/ceph/caps.c

2819

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

2824

doutc(cl, "%p %llx.%llx need %s want %s\n", inode,

fs/ceph/caps.c

2833

doutc(cl, "%p %llx.%llx error filelock\n", inode,

fs/ceph/caps.c

2854

doutc(cl, "%p %llx.%llx endoff %llu > maxsize %llu\n",

fs/ceph/caps.c

2865

doutc(cl, "%p %llx.%llx cap_snap_pending\n", inode,

fs/ceph/caps.c

2884

doutc(cl, "%p %llx.%llx have %s but not %s (revoking %s)\n",

fs/ceph/caps.c

2926

doutc(cl, "%p %llx.%llx need %s but mds%d readonly\n",

fs/ceph/caps.c

2934

doutc(cl, "%p %llx.%llx inode is shutdown\n",

fs/ceph/caps.c

2941

doutc(cl, "%p %llx.%llx need %s > mds_wanted %s\n",

fs/ceph/caps.c

2948

doutc(cl, "%p %llx.%llx have %s need %s\n", inode,

fs/ceph/caps.c

2965

doutc(cl, "%p %llx.%llx ret %d got %s\n", inode,

fs/ceph/caps.c

2978

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

2984

doutc(cl, "write %p %llx.%llx at large endoff %llu, req max_size\n",

fs/ceph/caps.c

304

doutc(cl, "ctx=%p %d = %d used + %d resv + %d avail\n", ctx,

fs/ceph/caps.c

313

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

318

doutc(cl, "ctx=%p count=%d\n", ctx, ctx->count);

fs/ceph/caps.c

3202

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

3206

doutc(cl, "%p follows %llu\n", capsnap, capsnap->follows);

fs/ceph/caps.c

3237

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

3260

doutc(cl, "%p %llx.%llx wb %d -> %d (?)\n", inode,

fs/ceph/caps.c

3301

doutc(cl, "%p %llx.%llx had %s%s%s\n", inode, ceph_vinop(inode),

fs/ceph/caps.c

3347

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

335

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

3371

doutc(cl, "on %p %llx.%llx head %d/%d -> %d/%d %s\n",

fs/ceph/caps.c

3404

doutc(cl, "%p %llx.%llx cap_snap %p snap %lld %d/%d -> %d/%d %s%s\n",

fs/ceph/caps.c

3432

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

3435

doutc(cl, "%p %llx.%llx\n", inode, ceph_vinop(inode));

fs/ceph/caps.c

3494

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

3520

doutc(cl, "%p %llx.%llx cap %p mds%d seq %d %s\n", inode,

fs/ceph/caps.c

3523

doutc(cl, " size %llu max_size %llu, i_size %llu\n", size,

fs/ceph/caps.c

3584

doutc(cl, "%p %llx.%llx mode 0%o uid.gid %d.%d\n", inode,

fs/ceph/caps.c

3592

pr_warn_ratelimited_client(cl,

fs/ceph/caps.c

3612

doutc(cl, " got new xattrs v%llu on %p %llx.%llx len %d\n",

fs/ceph/caps.c

3664

doutc(cl, "max_size %lld -> %llu\n", ci->i_max_size,

fs/ceph/caps.c

367

doutc(cl, "ctx=%p (%d) %d = %d used + %d resv + %d avail\n", ctx,

fs/ceph/caps.c

3679

doutc(cl, " my wanted = %s, used = %s, dirty %s\n",

fs/ceph/caps.c

3702

doutc(cl, "revocation: %s -> %s (revoking %s)\n",

fs/ceph/caps.c

3724

doutc(cl, "caps unchanged: %s -> %s\n",

fs/ceph/caps.c

3728

doutc(cl, "grant: %s -> %s\n", ceph_cap_string(cap->issued),

fs/ceph/caps.c

3819

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

3856

doutc(cl, "%p %llx.%llx mds%d seq %d on %s cleaned %s, flushing %s -> %s\n",

fs/ceph/caps.c

3880

doutc(cl, " mds%d still flushing cap on %p %llx.%llx\n",

fs/ceph/caps.c

3885

doutc(cl, " %p %llx.%llx now !flushing\n", inode,

fs/ceph/caps.c

3889

doutc(cl, " %p %llx.%llx now clean\n", inode,

fs/ceph/caps.c

390

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

3929

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

393

doutc(cl, "%p %d = %d used + %d resv + %d avail\n", cap,

fs/ceph/caps.c

3934

doutc(cl, "removing capsnap %p, %p %llx.%llx ci %p\n", capsnap,

fs/ceph/caps.c

3975

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

3981

doutc(cl, "%p %llx.%llx ci %p mds%d follows %lld\n", inode,

fs/ceph/caps.c

3988

doutc(cl, " cap_snap %p follows %lld "

fs/ceph/caps.c

3997

doutc(cl, " skipping cap_snap %p follows %lld\n",

fs/ceph/caps.c

4027

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

4050

doutc(cl, "%p %llx.%llx mds%d seq %d to %lld truncate seq %d\n",

fs/ceph/caps.c

4070

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

4089

doutc(cl, " cap %llx.%llx export to peer %d piseq %u pmseq %u\n",

fs/ceph/caps.c

4110

pr_err_ratelimited_client(cl, "issued != implemented: "

fs/ceph/caps.c

4124

doutc(cl, " updating import cap %p mds%d\n", tcap,

fs/ceph/caps.c

4206

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

4231

doutc(cl, " cap %llx.%llx import from peer %d piseq %u pmseq %u\n",

fs/ceph/caps.c

4258

doutc(cl, " remove export cap %p mds%d flags %d\n",

fs/ceph/caps.c

4263

pr_err_ratelimited_client(cl, "mismatched seq/mseq: "

fs/ceph/caps.c

4332

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

4452

doutc(cl, " caps mds%d op %s ino %llx.%llx inode %p seq %u iseq %u mseq %u\n",

fs/ceph/caps.c

4462

doutc(cl, " i don't have ino %llx\n", vino.ino);

fs/ceph/caps.c

4517

doutc(cl, " no cap on %p ino %llx.%llx from mds%d\n",

fs/ceph/caps.c

4557

pr_err_client(cl, "unknown cap op %d %s\n", op,

fs/ceph/caps.c

4599

pr_err_client(cl, "corrupt message\n");

fs/ceph/caps.c

4613

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

4621

doutc(cl, "begin\n");

fs/ceph/caps.c

4628

doutc(cl, "caps added recently. Exiting loop");

fs/ceph/caps.c

4640

doutc(cl, "on %p %llx.%llx\n", inode,

fs/ceph/caps.c

4656

doutc(cl, "done\n");

fs/ceph/caps.c

4667

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

4671

doutc(cl, "begin\n");

fs/ceph/caps.c

4678

doutc(cl, "%p %llx.%llx\n", inode, ceph_vinop(inode));

fs/ceph/caps.c

4686

doutc(cl, "done\n");

fs/ceph/caps.c

4700

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

4702

doutc(cl, "begin\n");

fs/ceph/caps.c

4707

doutc(cl, "done\n");

fs/ceph/caps.c

4848

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

4858

doutc(cl, "%p %llx.%llx mds%d used|dirty %s drop %s unless %s\n",

fs/ceph/caps.c

4882

doutc(cl, "%p %llx.%llx cap %p %s -> %s, "

fs/ceph/caps.c

4897

doutc(cl, "%p %llx.%llx cap %p %s (force)\n",

fs/ceph/caps.c

4914

doutc(cl, "%p %llx.%llx cap %p %s (noop)\n",

fs/ceph/caps.c

4941

struct ceph_client *cl;

fs/ceph/caps.c

4961

cl = ceph_inode_to_client(dir);

fs/ceph/caps.c

4965

doutc(cl, "%p mds%d seq %d\n", dentry, mds,

fs/ceph/caps.c

4987

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/caps.c

4993

doutc(cl, "removing capsnaps, ci is %p, %p %llx.%llx\n",

fs/ceph/caps.c

5013

struct ceph_client *cl = fsc->client;

fs/ceph/caps.c

5021

doutc(cl, "removing cap %p, ci is %p, %p %llx.%llx\n",

fs/ceph/caps.c

5049

pr_warn_ratelimited_client(cl,

fs/ceph/caps.c

5058

pr_warn_ratelimited_client(cl,

fs/ceph/caps.c

5084

pr_warn_ratelimited_client(cl,

fs/ceph/caps.c

582

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

608

doutc(cl, " marking %p NOT complete\n", inode);

fs/ceph/caps.c

658

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

667

doutc(cl, "%p %llx.%llx mds%d cap %llx %s seq %d\n", inode,

fs/ceph/caps.c

747

doutc(cl, "issued %s, mds wanted %s, actual %s, queueing\n",

fs/ceph/caps.c

766

doutc(cl, "inode %p %llx.%llx cap %p %s now %s seq %d mds%d\n",

fs/ceph/caps.c

791

struct ceph_client *cl = cap->session->s_mdsc->fsc->client;

fs/ceph/caps.c

799

doutc(cl, "%p %llx.%llx cap %p issued %s but STALE (gen %u vs %u)\n",

fs/ceph/caps.c

816

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

827

doutc(cl, "%p %llx.%llx cap %p issued %s\n", inode,

fs/ceph/caps.c

873

struct ceph_client *cl = s->s_mdsc->fsc->client;

fs/ceph/caps.c

877

doutc(cl, "%p %llx.%llx cap %p mds%d\n", inode,

fs/ceph/caps.c

881

doutc(cl, "%p %llx.%llx cap %p mds%d NOP, iterating over caps\n",

fs/ceph/caps.c

895

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/caps.c

901

doutc(cl, "mask %p %llx.%llx snap issued %s (mask %s)\n",

fs/ceph/caps.c

912

doutc(cl, "mask %p %llx.%llx cap %p issued %s (mask %s)\n",

fs/ceph/caps.c

924

doutc(cl, "mask %p %llx.%llx combo issued %s (mask %s)\n",

fs/ceph/crypto.c

164

struct ceph_client *cl = ceph_inode_to_client(parent);

fs/ceph/crypto.c

178

doutc(cl, "failed to parse long snapshot name: %s\n", str);

fs/ceph/crypto.c

183

pr_err_client(cl, "failed to parse long snapshot name\n");

fs/ceph/crypto.c

191

doutc(cl, "failed to parse inode number: %s\n", str);

fs/ceph/crypto.c

201

doutc(cl, "can't find inode %s (%s)\n", inode_number, name);

fs/ceph/crypto.c

208

struct ceph_client *cl = ceph_inode_to_client(parent);

fs/ceph/crypto.c

270

doutc(cl, "base64-encoded ciphertext name = %.*s\n", elen, p);

fs/ceph/crypto.c

433

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/crypto.c

435

doutc(cl, "%p %llx.%llx len %u offs %u blk %llu\n", inode,

fs/ceph/crypto.c

444

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/crypto.c

446

doutc(cl, "%p %llx.%llx len %u offs %u blk %llu\n", inode,

fs/ceph/crypto.c

515

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/crypto.c

523

doutc(cl, "%p %llx.%llx empty array, ret 0\n", inode,

fs/ceph/crypto.c

538

pr_warn_client(cl,

fs/ceph/crypto.c

547

doutc(cl, "%p %llx.%llx [%d] 0x%llx~0x%llx fret %d\n", inode,

fs/ceph/crypto.c

556

doutc(cl, "ret %d\n", ret);

fs/ceph/dir.c

1026

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/dir.c

1044

doutc(cl, "%p %llx.%llx/'%pd' to '%s'\n", dir, ceph_vinop(dir), dentry,

fs/ceph/dir.c

1100

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/dir.c

1114

doutc(cl, "mksnap %llx.%llx/'%pd' dentry %p\n",

fs/ceph/dir.c

1117

doutc(cl, "mkdir %llx.%llx/'%pd' dentry %p mode 0%ho\n",

fs/ceph/dir.c

1192

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/dir.c

1210

doutc(cl, "%p %llx.%llx/'%pd' to '%pd'\n", dir, ceph_vinop(dir),

fs/ceph/dir.c

1249

struct ceph_client *cl = fsc->client;

fs/ceph/dir.c

1255

pr_warn_client(cl,

fs/ceph/dir.c

1288

pr_warn_client(cl, "failure path=(%llx)%s result=%d!\n",

fs/ceph/dir.c

1339

struct ceph_client *cl = fsc->client;

fs/ceph/dir.c

135

struct ceph_client *cl = ceph_inode_to_client(dir);

fs/ceph/dir.c

1352

doutc(cl, "rmsnap %llx.%llx/'%pd' dn\n", ceph_vinop(dir),

fs/ceph/dir.c

1356

doutc(cl, "unlink/rmdir %llx.%llx/'%pd' inode %llx.%llx\n",

fs/ceph/dir.c

1405

doutc(cl, "async unlink on %llx.%llx/'%pd' caps=%s",

fs/ceph/dir.c

1474

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/dir.c

149

doutc(cl, " folio %lu not found\n", ptr_pgoff);

fs/ceph/dir.c

1504

doutc(cl, "%llx.%llx/'%pd' to %llx.%llx/'%pd'\n",

fs/ceph/dir.c

1552

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/dir.c

1554

doutc(cl, "%p %p '%pd'\n", di, dn, dn);

fs/ceph/dir.c

1586

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/dir.c

1588

doutc(cl, "%p %p '%pd' (offset 0x%llx)\n", di, dn, dn, di->offset);

fs/ceph/dir.c

1854

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/dir.c

1887

doutc(cl, "dentry %p = %d\n", dentry, valid);

fs/ceph/dir.c

193

struct ceph_client *cl = ceph_inode_to_client(dir);

fs/ceph/dir.c

1930

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/dir.c

1952

doutc(cl, "dir %p %llx.%llx v%u dentry %p '%pd' = %d\n", dir,

fs/ceph/dir.c

1965

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/dir.c

1975

doutc(cl, "%p '%pd' inode %p offset 0x%llx nokey %d\n",

fs/ceph/dir.c

1983

doutc(cl, "%p '%pd' inode %p is SNAPPED\n", dentry,

fs/ceph/dir.c

200

doutc(cl, "%p %llx.%llx v%u at %llx\n", dir, ceph_vinop(dir),

fs/ceph/dir.c

2041

doutc(cl, "%p '%pd', lookup result=%d\n", dentry,

fs/ceph/dir.c

2048

doutc(cl, "%p '%pd' %s\n", dentry, dentry, valid ? "valid" : "invalid");

fs/ceph/dir.c

2109

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/dir.c

2113

doutc(cl, "dentry %p '%pd'\n", dentry, dentry);

fs/ceph/dir.c

231

doutc(cl, "%p %llx.%llx cache idx %llu\n", dir,

fs/ceph/dir.c

268

doutc(cl, " %llx dentry %p %pd %p\n", di->offset,

fs/ceph/dir.c

324

struct ceph_client *cl = fsc->client;

fs/ceph/dir.c

330

doutc(cl, "%p %llx.%llx file %p pos %llx\n", inode,

fs/ceph/dir.c

337

doutc(cl, "%p %llx.%llx off 0 -> '.'\n", inode,

fs/ceph/dir.c

352

doutc(cl, "%p %llx.%llx off 1 -> '..'\n", inode,

fs/ceph/dir.c

407

doutc(cl, "fetching %p %llx.%llx frag %x offset '%s'\n",

fs/ceph/dir.c

461

doutc(cl, "%p %llx.%llx got and parsed readdir result=%d"

fs/ceph/dir.c

496

doutc(cl, "%p %llx.%llx !did_prepopulate\n", inode,

fs/ceph/dir.c

524

doutc(cl, "%p %llx.%llx frag %x num %d pos %llx chunk first %llx\n",

fs/ceph/dir.c

546

pr_warn_client(cl,

fs/ceph/dir.c

556

doutc(cl, "%p %llx.%llx (%d/%d) -> %llx '%.*s' %p\n", inode,

fs/ceph/dir.c

569

doutc(cl, "filldir stopping us...\n");

fs/ceph/dir.c

600

doutc(cl, "%p %llx.%llx next frag is %x\n", inode,

fs/ceph/dir.c

616

doutc(cl, " marking %p %llx.%llx complete and ordered\n",

fs/ceph/dir.c

624

doutc(cl, " marking %llx.%llx complete\n",

fs/ceph/dir.c

631

doutc(cl, "%p %llx.%llx file %p done.\n", inode, ceph_vinop(inode),

fs/ceph/dir.c

678

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/dir.c

698

doutc(cl, "%p %llx.%llx dropping %p content\n",

fs/ceph/dir.c

727

struct ceph_client *cl = ceph_inode_to_client(parent);

fs/ceph/dir.c

736

doutc(cl, "ENOENT on snapdir %p '%pd', linking to "

fs/ceph/dir.c

759

struct ceph_client *cl = req->r_mdsc->fsc->client;

fs/ceph/dir.c

765

doutc(cl,

fs/ceph/dir.c

800

struct ceph_client *cl = fsc->client;

fs/ceph/dir.c

806

doutc(cl, "%p %llx.%llx/'%pd' dentry %p\n", dir, ceph_vinop(dir),

fs/ceph/dir.c

830

doutc(cl, " dir %llx.%llx flags are 0x%lx\n",

fs/ceph/dir.c

841

doutc(cl, " dir %llx.%llx complete, -ENOENT\n",

fs/ceph/dir.c

880

doutc(cl, "result=%p\n", dentry);

fs/ceph/dir.c

915

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/dir.c

932

doutc(cl, "%p %llx.%llx/'%pd' dentry %p mode 0%ho rdev %d\n",

fs/ceph/export.c

115

doutc(cl, "%p %llx.%llx with parent %p %llx.%llx\n", inode,

fs/ceph/export.c

123

doutc(cl, "%p %llx.%llx\n", inode, ceph_vinop(inode));

fs/ceph/export.c

216

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/export.c

289

doutc(cl, "%llx.%llx\n err=%d\n", vino.ino, vino.snap, err);

fs/ceph/export.c

291

doutc(cl, "%llx.%llx parent %llx hash %x err=%d", vino.ino,

fs/ceph/export.c

372

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/export.c

412

doutc(cl, "child %p %p %llx.%llx err=%ld\n", child, inode,

fs/ceph/export.c

47

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/export.c

90

doutc(cl, "%p %llx.%llx ret=%d\n", inode, ceph_vinop(inode), ret);

fs/ceph/export.c

97

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/file.c

1011

doutc(cl, "%p %llx.%llx regular file %p\n", inode,

fs/ceph/file.c

1048

struct ceph_client *cl = fsc->client;

fs/ceph/file.c

1057

doutc(cl, "on inode %p %llx.%llx %llx~%llx\n", inode,

fs/ceph/file.c

1093

doutc(cl, "orig %llu~%llu reading %llu~%llu", off, len,

fs/ceph/file.c

1148

doutc(cl, "%llu~%llu got %zd i_size %llu%s\n", off, len,

fs/ceph/file.c

1195

doutc(cl, "zero gap %llu~%llu\n", off + ret,

fs/ceph/file.c

1241

doutc(cl, "result %zd retry_op %d\n", ret, *retry_op);

fs/ceph/file.c

1250

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/file.c

1252

doutc(cl, "on file %p %llx~%zx %s\n", file, iocb->ki_pos,

fs/ceph/file.c

1282

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/file.c

1296

doutc(cl, "%p %llx.%llx rc %d\n", inode, ceph_vinop(inode), ret);

fs/ceph/file.c

1335

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/file.c

1340

doutc(cl, "req %p inode %p %llx.%llx, rc %d bytes %u\n", req,

fs/ceph/file.c

1482

struct ceph_client *cl = fsc->client;

fs/ceph/file.c

1501

doutc(cl, "sync_direct_%s on file %p %lld~%u snapc %p seq %lld\n",

fs/ceph/file.c

1514

doutc(cl, "invalidate_inode_pages2_range returned %d\n",

fs/ceph/file.c

1711

struct ceph_client *cl = fsc->client;

fs/ceph/file.c

1726

doutc(cl, "on file %p %lld~%u snapc %p seq %lld\n", file, pos,

fs/ceph/file.c

1771

doutc(cl, "ino %llx %lld~%llu adjusted %lld~%llu -- %srmw\n",

fs/ceph/file.c

1982

doutc(cl, "write failed with %d\n", ret);

fs/ceph/file.c

1991

doutc(cl, "encryption failed with %d\n", ret);

fs/ceph/file.c

2010

doutc(cl, "write op %lld~%llu\n", write_pos, write_len);

fs/ceph/file.c

2041

doutc(cl, "osd write returned %d\n", ret);

fs/ceph/file.c

206

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/file.c

2071

doutc(cl, "invalidate_inode_pages2_range returned %d\n",

fs/ceph/file.c

2077

doutc(cl, "written %d\n", written);

fs/ceph/file.c

2091

doutc(cl, "returning %d\n", ret);

fs/ceph/file.c

210

doutc(cl, "%p %llx.%llx %p 0%o (%s)\n", inode, ceph_vinop(inode),

fs/ceph/file.c

2110

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/file.c

2116

doutc(cl, "%llu~%u trying to get caps on %p %llx.%llx\n",

fs/ceph/file.c

2145

doutc(cl, "sync %p %llx.%llx %llu~%u got cap refs on %s\n",

fs/ceph/file.c

2165

doutc(cl, "async %p %llx.%llx %llu~%u got cap refs on %s\n",

fs/ceph/file.c

2173

doutc(cl, "%p %llx.%llx dropping cap refs on %s = %d\n",

fs/ceph/file.c

2236

doutc(cl, "may hit hole, ppos %lld < size %lld, reading more\n",

fs/ceph/file.c

2334

struct ceph_client *cl = fsc->client;

fs/ceph/file.c

2402

doutc(cl, "%p %llx.%llx %llu~%zd getting caps. i_size %llu\n",

fs/ceph/file.c

2420

doutc(cl, "%p %llx.%llx %llu~%zd got cap refs on %s\n",

fs/ceph/file.c

2481

doutc(cl, "%p %llx.%llx %llu~%u dropping cap refs on %s\n",

fs/ceph/file.c

2487

doutc(cl, "%p %llx.%llx %llu~%u" "got EOLDSNAPC, retrying\n",

fs/ceph/file.c

25

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/file.c

265

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/file.c

2675

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/file.c

2682

doutc(cl, "%p %llx.%llx mode %x, offset %llu length %llu\n",

fs/ceph/file.c

278

doutc(cl, "%p %llx.%llx %p 0%o (symlink)\n", inode,

fs/ceph/file.c

2812

struct ceph_client *cl = ceph_inode_to_client(src_inode);

fs/ceph/file.c

2823

doutc(cl, "Copy beyond EOF (%llu + %zu > %llu)\n", src_off,

fs/ceph/file.c

283

doutc(cl, "%p %llx.%llx %p 0%o (special)\n", inode,

fs/ceph/file.c

2900

struct ceph_client *cl = fsc->client;

fs/ceph/file.c

2942

pr_notice_client(cl,

fs/ceph/file.c

2945

doutc(cl, "returned %d\n", ret);

fs/ceph/file.c

2972

struct ceph_client *cl = src_fsc->client;

fs/ceph/file.c

3015

doutc(cl, "Invalid src/dst files layout\n");

fs/ceph/file.c

303

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/file.c

3033

doutc(cl, "failed to write src file (%zd)\n", ret);

fs/ceph/file.c

3038

doutc(cl, "failed to write dst file (%zd)\n", ret);

fs/ceph/file.c

3050

doutc(cl, "get_rd_wr_caps returned %d\n", err);

fs/ceph/file.c

3065

doutc(cl, "Failed to invalidate inode pages (%zd)\n",

fs/ceph/file.c

3087

doutc(cl, "Initial partial copy of %u bytes\n", src_objlen);

fs/ceph/file.c

3098

doutc(cl, "Failed partial copy (%zd)\n", ret);

fs/ceph/file.c

3120

doutc(cl, "Copied %zu bytes out of %zu\n", bytes, len);

fs/ceph/file.c

3148

doutc(cl, "Final partial copy of %zu bytes\n", len);

fs/ceph/file.c

315

doutc(cl, "%p %llx.%llx want %s issued %s updating mds_wanted\n",

fs/ceph/file.c

3154

doutc(cl, "Failed partial copy (%zd)\n", bytes);

fs/ceph/file.c

348

doutc(cl, "%p %llx.%llx open result=%d\n", inode, ceph_vinop(inode),

fs/ceph/file.c

363

struct ceph_client *cl = fsc->client;

fs/ceph/file.c

375

doutc(cl, "file %p is already opened\n", file);

fs/ceph/file.c

389

doutc(cl, "%p %llx.%llx file %p flags %d (%d)\n", inode,

fs/ceph/file.c

440

doutc(cl, "open %p fmode %d want %s issued %s using existing\n",

fs/ceph/file.c

462

doutc(cl, "open fmode %d wants %s\n", fmode, ceph_cap_string(wanted));

fs/ceph/file.c

476

doutc(cl, "open result=%d on %llx.%llx\n", err, ceph_vinop(inode));

fs/ceph/file.c

53

doutc(cl, "unused open flags: %x\n", flags);

fs/ceph/file.c

556

struct ceph_client *cl = ceph_inode_to_client(dir);

fs/ceph/file.c

567

pr_warn_client(cl,

fs/ceph/file.c

599

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/file.c

618

pr_warn_client(cl,

fs/ceph/file.c

638

pr_warn_client(cl,

fs/ceph/file.c

645

pr_warn_client(cl, "no req->r_target_inode for 0x%llx\n",

fs/ceph/file.c

668

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/file.c

731

doutc(cl, "failed to fill inode: %d\n", ret);

fs/ceph/file.c

739

doutc(cl, "d_adding new inode 0x%llx to 0x%llx/%s\n",

fs/ceph/file.c

779

struct ceph_client *cl = fsc->client;

fs/ceph/file.c

790

doutc(cl, "%p %llx.%llx dentry %p '%pd' %s flags %d mode 0%o\n",

fs/ceph/file.c

961

doutc(cl, "finish_no_open on dn %p\n", dn);

fs/ceph/file.c

966

pr_warn_client(cl,

fs/ceph/file.c

972

doutc(cl, "finish_open on dn %p\n", dn);

fs/ceph/file.c

987

doutc(cl, "result=%d\n", err);

fs/ceph/file.c

993

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/file.c

998

doutc(cl, "%p %llx.%llx dir file %p\n", inode,

fs/ceph/inode.c

1001

doutc(cl, "%p ino %llx.%llx v %llu had %llu\n", inode, ceph_vinop(inode),

fs/ceph/inode.c

1009

pr_warn_once_client(cl,

fs/ceph/inode.c

1016

pr_warn_once_client(cl,

fs/ceph/inode.c

1042

pr_err_client(cl, "ENOMEM xattr blob %d bytes\n",

fs/ceph/inode.c

1097

doutc(cl, "%p %llx.%llx mode 0%o uid.gid %d.%d\n", inode,

fs/ceph/inode.c

1156

pr_warn_client(cl,

fs/ceph/inode.c

1169

doutc(cl, "max_size %lld -> %llu\n",

fs/ceph/inode.c

1233

pr_err_client(cl,

fs/ceph/inode.c

1241

pr_err_client(cl,

fs/ceph/inode.c

1251

pr_err_client(cl,

fs/ceph/inode.c

1288

pr_err_client(cl, "%p %llx.%llx BAD mode 0%o\n", inode,

fs/ceph/inode.c

1310

doutc(cl, " marking %p complete (empty)\n",

fs/ceph/inode.c

1320

doutc(cl, " %p got snap_caps %s\n", inode,

fs/ceph/inode.c

1337

pr_warn_client(cl, "mds issued no caps on %llx.%llx\n",

fs/ceph/inode.c

1384

struct ceph_client *cl = ceph_inode_to_client(dir);

fs/ceph/inode.c

1391

doutc(cl, "%p duration %lu ms ttl %lu\n", dentry, duration, ttl);

fs/ceph/inode.c

1492

struct ceph_client *cl = ceph_inode_to_client(in);

fs/ceph/inode.c

1524

pr_err_client(cl, "error %ld %p inode %p ino %llx.%llx\n",

fs/ceph/inode.c

1530

doutc(cl, "dn %p (%d) spliced with %p (%d) inode %p ino %llx.%llx\n",

fs/ceph/inode.c

1537

doutc(cl, "dn %p attached to %p ino %llx.%llx\n", dn,

fs/ceph/inode.c

1561

struct ceph_client *cl = fsc->client;

fs/ceph/inode.c

1565

doutc(cl, "%p is_dentry %d is_target %d\n", req,

fs/ceph/inode.c

1569

doutc(cl, "reply is empty!\n");

fs/ceph/inode.c

1633

doutc(cl, "d_lookup on parent=%p name=%.*s got %p\n",

fs/ceph/inode.c

1638

doutc(cl, "d_alloc %p '%.*s' = %p\n", parent,

fs/ceph/inode.c

1655

doutc(cl, " dn %p points to wrong inode %p\n",

fs/ceph/inode.c

1681

pr_err_client(cl, "badness %p %llx.%llx\n", in,

fs/ceph/inode.c

1732

doutc(cl, "no dentry lease or dir cap\n");

fs/ceph/inode.c

1739

doutc(cl, " src %p '%pd' dst %p '%pd'\n",

fs/ceph/inode.c

1741

doutc(cl, "doing d_move %p -> %p\n", req->r_old_dentry, dn);

fs/ceph/inode.c

1748

doutc(cl, " src %p '%pd' dst %p '%pd'\n",

fs/ceph/inode.c

1755

doutc(cl, "dn %p gets new offset %lld\n",

fs/ceph/inode.c

1769

doutc(cl, "null dentry\n");

fs/ceph/inode.c

1771

doutc(cl, "d_delete %p\n", dn);

fs/ceph/inode.c

1800

doutc(cl, " %p links to %p %llx.%llx, not %llx.%llx\n",

fs/ceph/inode.c

181

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/inode.c

1812

doutc(cl, " final dn %p\n", dn);

fs/ceph/inode.c

1823

doutc(cl, " linking snapped dir %p to dn %p\n", in,

fs/ceph/inode.c

1855

doutc(cl, "done err=%d\n", err);

fs/ceph/inode.c

1866

struct ceph_client *cl = session->s_mdsc->fsc->client;

fs/ceph/inode.c

1881

doutc(cl, "badness got %d\n", err);

fs/ceph/inode.c

1887

pr_err_client(cl, "inode badness on %p got %d\n", in,

fs/ceph/inode.c

1916

struct ceph_client *cl = ceph_inode_to_client(dir);

fs/ceph/inode.c

1948

doutc(cl, "dn %p idx %d\n", dn, ctl->index);

fs/ceph/inode.c

1952

doutc(cl, "disable readdir cache\n");

fs/ceph/inode.c

1965

struct ceph_client *cl = session->s_mdsc->fsc->client;

fs/ceph/inode.c

198

doutc(cl, "no inode found for %llx.%llx\n", vino.ino, vino.snap);

fs/ceph/inode.c

1993

doutc(cl, "got new frag %x -> %x\n", frag,

fs/ceph/inode.c

2001

doutc(cl, "%d items under SNAPDIR dn %p\n",

fs/ceph/inode.c

2004

doutc(cl, "%d items under dn %p\n", rinfo->dir_nr, parent);

fs/ceph/inode.c

202

doutc(cl, "on %llx=%llx.%llx got %p new %d\n",

fs/ceph/inode.c

2048

doutc(cl, "d_lookup on parent=%p name=%.*s got %p\n",

fs/ceph/inode.c

2053

doutc(cl, "d_alloc %p '%.*s' = %p\n", parent,

fs/ceph/inode.c

2056

doutc(cl, "d_alloc badness\n");

fs/ceph/inode.c

2069

doutc(cl, " dn %p points to wrong inode %p\n",

fs/ceph/inode.c

2092

doutc(cl, "new_inode badness\n");

fs/ceph/inode.c

2103

pr_err_client(cl, "badness on %p %llx.%llx\n", in,

fs/ceph/inode.c

2121

doutc(cl, " skip splicing dn %p to inode %p"

fs/ceph/inode.c

213

struct ceph_client *cl = ceph_inode_to_client(parent);

fs/ceph/inode.c

2154

doutc(cl, "done\n");

fs/ceph/inode.c

2160

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/inode.c

2165

doutc(cl, "set_size %p %llu -> %llu\n", inode, i_size_read(inode), size);

fs/ceph/inode.c

2180

struct ceph_client *cl = fsc->client;

fs/ceph/inode.c

2186

doutc(cl, "%p %llx.%llx mask=%lx\n", inode,

fs/ceph/inode.c

2189

doutc(cl, "%p %llx.%llx already queued, mask=%lx\n",

fs/ceph/inode.c

2197

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/inode.c

2207

pr_warn_ratelimited_client(cl,

fs/ceph/inode.c

2217

doutc(cl, "%p %llx.%llx gen %d revoking %d\n", inode,

fs/ceph/inode.c

2230

pr_err_client(cl, "invalidate_inode_pages2 %llx.%llx failed\n",

fs/ceph/inode.c

2237

doutc(cl, "%p %llx.%llx gen %d successful\n", inode,

fs/ceph/inode.c

2242

doutc(cl, "%p %llx.%llx gen %d raced, now %d revoking %d\n",

fs/ceph/inode.c

226

pr_warn_once_client(cl, "bad snapdir parent type (mode=0%o)\n",

fs/ceph/inode.c

2261

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/inode.c

2270

doutc(cl, "%p %llx.%llx none pending\n", inode,

fs/ceph/inode.c

2283

doutc(cl, "%p %llx.%llx flushing snaps first\n", inode,

fs/ceph/inode.c

2295

doutc(cl, "%p %llx.%llx (%d) to %lld\n", inode, ceph_vinop(inode),

fs/ceph/inode.c

232

pr_warn_once_client(cl, "bad snapdir inode type (mode=0%o)\n",

fs/ceph/inode.c

2324

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/inode.c

2327

doutc(cl, "writeback %p %llx.%llx\n", inode, ceph_vinop(inode));

fs/ceph/inode.c

2399

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/inode.c

2422

doutc(cl, "size %lld -> %lld got cap refs on %s, issued %s\n",

fs/ceph/inode.c

2479

doutc(cl, "hit hole, ppos %lld < size %lld\n", pos, i_size);

fs/ceph/inode.c

2488

doutc(cl, "encrypt block boff/bsize %d/%lu\n", boff,

fs/ceph/inode.c

2516

doutc(cl, "%p %llx.%llx size dropping cap refs on %s\n", inode,

fs/ceph/inode.c

2535

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/inode.c

258

doutc(cl, "Failed to alloc snapdir fscrypt_auth\n");

fs/ceph/inode.c

2601

doutc(cl, "%p %llx.%llx issued %s\n", inode, ceph_vinop(inode),

fs/ceph/inode.c

2613

doutc(cl, "%p %llx.%llx fscrypt_auth len %u to %u)\n", inode,

fs/ceph/inode.c

2644

doutc(cl, "%p %llx.%llx uid %d -> %d\n", inode,

fs/ceph/inode.c

2662

doutc(cl, "%p %llx.%llx gid %d -> %d\n", inode,

fs/ceph/inode.c

2678

doutc(cl, "%p %llx.%llx mode 0%o -> 0%o\n", inode,

fs/ceph/inode.c

2695

doutc(cl, "%p %llx.%llx atime %ptSp -> %ptSp\n",

fs/ceph/inode.c

2716

doutc(cl, "%p %llx.%llx size %lld -> %lld\n", inode,

fs/ceph/inode.c

2770

doutc(cl, "%p %llx.%llx mtime %ptSp -> %ptSp\n",

fs/ceph/inode.c

2795

doutc(cl, "%p %llx.%llx ctime %ptSp -> %ptSp (%s)\n",

fs/ceph/inode.c

2815

doutc(cl, "%p %llx.%llx ATTR_FILE ... hrm!\n", inode,

fs/ceph/inode.c

2857

doutc(cl, "%p %llx.%llx result=%d (%s locally, %d remote), retry it!\n",

fs/ceph/inode.c

2866

doutc(cl, "%p %llx.%llx result=%d (%s locally, %d remote)\n", inode,

fs/ceph/inode.c

2956

struct ceph_client *cl = fsc->client;

fs/ceph/inode.c

2963

doutc(cl, "inode %p %llx.%llx SNAPDIR\n", inode,

fs/ceph/inode.c

2968

doutc(cl, "inode %p %llx.%llx mask %s mode 0%o\n", inode,

fs/ceph/inode.c

2996

doutc(cl, "result=%d\n", err);

fs/ceph/inode.c

3004

struct ceph_client *cl = fsc->client;

fs/ceph/inode.c

3034

doutc(cl, "xattr_value_len:%zu, size:%zu\n", xattr_value_len, size);

fs/ceph/inode.c

3049

doutc(cl, "result=%d\n", err);

fs/ceph/inode.c

305

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/inode.c

336

doutc(cl, "added %p %llx.%llx frag %x\n", inode, ceph_vinop(inode), f);

fs/ceph/inode.c

369

struct ceph_client *cl = ceph_inode_to_client(&ci->netfs.inode);

fs/ceph/inode.c

393

doutc(cl, "frag(%x) %x splits by %d (%d ways)\n", v, t,

fs/ceph/inode.c

404

doutc(cl, "frag(%x) = %x\n", v, t);

fs/ceph/inode.c

428

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/inode.c

453

doutc(cl, "removed %p %llx.%llx frag %x (no ref)\n",

fs/ceph/inode.c

459

doutc(cl, "cleared %p %llx.%llx frag %x referral\n",

fs/ceph/inode.c

473

pr_err_client(cl, "ENOMEM on mds ref %p %llx.%llx fg %x\n",

fs/ceph/inode.c

484

doutc(cl, "%p %llx.%llx frag %x ndist=%d\n", inode,

fs/ceph/inode.c

513

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/inode.c

549

doutc(cl, "%p %llx.%llx\n", inode, ceph_vinop(inode));

fs/ceph/inode.c

555

pr_err_client(cl, "%p %llx.%llx invalid split %d/%u, "

fs/ceph/inode.c

589

doutc(cl, " frag %x split by %d\n", frag->frag, frag->split_by);

fs/ceph/inode.c

737

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/inode.c

741

doutc(cl, "%p ino %llx.%llx\n", inode, ceph_vinop(inode));

fs/ceph/inode.c

765

doutc(cl, " dropping residual ref to snap realm %p\n",

fs/ceph/inode.c

807

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/inode.c

814

doutc(cl, "size %lld -> %llu\n", isize, size);

fs/ceph/inode.c

816

pr_err_client(cl, "non-zero size for directory\n");

fs/ceph/inode.c

829

doutc(cl, "truncate_seq %u -> %u\n",

fs/ceph/inode.c

859

doutc(cl, "truncate_size %lld -> %llu, encrypted %d\n",

fs/ceph/inode.c

866

doutc(cl, "truncate_pagecache_size %lld -> %llu\n",

fs/ceph/inode.c

880

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/inode.c

894

doutc(cl, "ctime %ptSp -> %ptSp inc w/ cap\n", &ictime, ctime);

fs/ceph/inode.c

900

doutc(cl, "mtime %ptSp -> %ptSp tw %d -> %d\n", &imtime, mtime,

fs/ceph/inode.c

909

doutc(cl, "mtime %ptSp -> %ptSp inc\n", &imtime, mtime);

fs/ceph/inode.c

913

doutc(cl, "atime %ptSp -> %ptSp inc\n", &iatime, atime);

fs/ceph/inode.c

933

doutc(cl, "%p mds time_warp_seq %llu < %u\n", inode,

fs/ceph/inode.c

942

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/inode.c

952

pr_err_client(cl,

fs/ceph/inode.c

982

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/ioctl.c

248

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/ioctl.c

262

doutc(cl, "file %p %p %llx.%llx already lazy\n", file, inode,

fs/ceph/ioctl.c

265

doutc(cl, "file %p %p %llx.%llx marked lazy\n", file, inode,

fs/ceph/locks.c

115

doutc(cl, "rule: %d, op: %d, owner: %llx, pid: %llu, "

fs/ceph/locks.c

152

doutc(cl, "rule: %d, op: %d, pid: %llu, start: %llu, "

fs/ceph/locks.c

162

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/locks.c

180

doutc(cl, "request %llu was interrupted\n", req->r_tid);

fs/ceph/locks.c

254

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/locks.c

266

doutc(cl, "fl_owner: %p\n", fl->c.flc_owner);

fs/ceph/locks.c

301

doutc(cl, "locking locally\n");

fs/ceph/locks.c

309

doutc(cl, "got %d on posix_lock_file, undid lock\n",

fs/ceph/locks.c

321

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/locks.c

332

doutc(cl, "fl_file: %p\n", fl->c.flc_file);

fs/ceph/locks.c

369

doutc(cl, "got %d on locks_lock_file_wait, undid lock\n",

fs/ceph/locks.c

382

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/locks.c

398

doutc(cl, "counted %d flock locks and %d fcntl locks\n",

fs/ceph/locks.c

409

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/locks.c

429

doutc(cl, "Have unknown lock type %d\n",

fs/ceph/locks.c

448

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/locks.c

454

doutc(cl, "encoding %d flock and %d fcntl locks\n", num_flock_locks,

fs/ceph/locks.c

80

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

1169

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

1177

pr_err_client(cl, "%p failed to reserve caps: %d\n",

fs/ceph/mds_client.c

1184

doutc(cl, "%p tid %lld\n", req, req->r_tid);

fs/ceph/mds_client.c

1295

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

1307

doutc(cl, "using resend_mds mds%d\n", req->r_resend_mds);

fs/ceph/mds_client.c

1324

doutc(cl, "using snapdir's parent %p %llx.%llx\n",

fs/ceph/mds_client.c

1345

doutc(cl, "using nonsnap parent %p %llx.%llx\n",

fs/ceph/mds_client.c

1365

doutc(cl, "%p %llx.%llx is_hash=%d (0x%x) mode %d\n", inode,

fs/ceph/mds_client.c

1382

doutc(cl, "%p %llx.%llx frag %u mds%d (%d/%d)\n",

fs/ceph/mds_client.c

1397

doutc(cl, "%p %llx.%llx frag %u mds%d (auth)\n",

fs/ceph/mds_client.c

1422

doutc(cl, "%p %llx.%llx mds%d (%scap %p)\n", inode,

fs/ceph/mds_client.c

1435

doutc(cl, "chose random mds%d\n", mds);

fs/ceph/mds_client.c

1549

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

1591

pr_err_client(cl, "ENOMEM creating session open msg\n");

fs/ceph/mds_client.c

1631

pr_err_client(cl, "encode_supported_features failed!\n");

fs/ceph/mds_client.c

1638

pr_err_client(cl, "encode_metric_spec failed!\n");

fs/ceph/mds_client.c

1720

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

1722

doutc(cl, "to mds%d\n", target);

fs/ceph/mds_client.c

1737

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

1743

doutc(cl, "for mds%d (%d targets)\n", session->s_mds,

fs/ceph/mds_client.c

1759

struct ceph_client *cl = session->s_mdsc->fsc->client;

fs/ceph/mds_client.c

1765

doutc(cl, "mds%d\n", session->s_mds);

fs/ceph/mds_client.c

1783

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

1787

doutc(cl, "mds%d\n", session->s_mds);

fs/ceph/mds_client.c

1792

pr_warn_ratelimited_client(cl, " dropping unsafe request %llu\n",

fs/ceph/mds_client.c

1822

struct ceph_client *cl = session->s_mdsc->fsc->client;

fs/ceph/mds_client.c

1829

doutc(cl, "%p mds%d\n", session, session->s_mds);

fs/ceph/mds_client.c

1860

doutc(cl, "finishing cap %p removal\n", cap);

fs/ceph/mds_client.c

1889

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/mds_client.c

1897

doutc(cl, " removing cap %p, ci is %p, inode is %p\n",

fs/ceph/mds_client.c

2003

struct ceph_client *cl = session->s_mdsc->fsc->client;

fs/ceph/mds_client.c

2005

doutc(cl, "session %p mds%d\n", session, session->s_mds);

fs/ceph/mds_client.c

2019

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2025

pr_info_client(cl, "mds%d caps stale\n", session->s_mds);

fs/ceph/mds_client.c

2032

doutc(cl, "ignoring mds%d (%s)\n", session->s_mds,

fs/ceph/mds_client.c

2037

doutc(cl, "to mds%d (%s)\n", session->s_mds,

fs/ceph/mds_client.c

2050

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2053

doutc(cl, "to mds%d (%s)s seq %lld\n", session->s_mds,

fs/ceph/mds_client.c

2071

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2083

pr_info_client(cl, "mds%d caps renewed\n",

fs/ceph/mds_client.c

2087

pr_info_client(cl, "mds%d caps still stale\n",

fs/ceph/mds_client.c

2091

doutc(cl, "mds%d ttl now %lu, was %s, now %s\n", session->s_mds,

fs/ceph/mds_client.c

2105

struct ceph_client *cl = session->s_mdsc->fsc->client;

fs/ceph/mds_client.c

2108

doutc(cl, "mds%d state %s seq %lld\n", session->s_mds,

fs/ceph/mds_client.c

2166

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2186

doutc(cl, "%p %llx.%llx cap %p mine %s oissued %s used %s wanted %s\n",

fs/ceph/mds_client.c

2229

doutc(cl, "%p %llx.%llx cap %p pruned, count now %d\n",

fs/ceph/mds_client.c

2249

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2252

doutc(cl, "mds%d start: %d / %d, trim %d\n", session->s_mds,

fs/ceph/mds_client.c

2258

doutc(cl, "mds%d done: %d / %d, trimmed %d\n",

fs/ceph/mds_client.c

2270

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2279

doutc(cl, "still flushing tid %llu <= %llu\n",

fs/ceph/mds_client.c

2296

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2298

doutc(cl, "want %llu\n", want_flush_tid);

fs/ceph/mds_client.c

2303

doutc(cl, "ok, flushed thru %llu\n", want_flush_tid);

fs/ceph/mds_client.c

2312

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2371

doutc(cl, "mds%d %p\n", session->s_mds, msg);

fs/ceph/mds_client.c

2391

doutc(cl, "mds%d %p\n", session->s_mds, msg);

fs/ceph/mds_client.c

2396

pr_err_client(cl, "mds%d, failed to allocate message\n",

fs/ceph/mds_client.c

2420

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2427

doutc(cl, "cap release work queued\n");

fs/ceph/mds_client.c

2430

doutc(cl, "failed to queue cap release work\n");

fs/ceph/mds_client.c

2458

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2463

doutc(cl, "caps reclaim work queued\n");

fs/ceph/mds_client.c

2465

doutc(cl, "failed to queue caps release work\n");

fs/ceph/mds_client.c

2483

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2488

doutc(cl, "caps unlink work queued\n");

fs/ceph/mds_client.c

2490

doutc(cl, "failed to queue caps unlink work\n");

fs/ceph/mds_client.c

2498

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2500

doutc(cl, "begin\n");

fs/ceph/mds_client.c

2514

doutc(cl, "on %p %llx.%llx\n", inode,

fs/ceph/mds_client.c

2522

doutc(cl, "done\n");

fs/ceph/mds_client.c

2711

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2737

doutc(cl, "path+%d: %p SNAPDIR\n", pos, cur);

fs/ceph/mds_client.c

2836

doutc(cl, "on %p %d built %llx '%.*s'\n", dentry, d_count(dentry),

fs/ceph/mds_client.c

2906

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

2914

doutc(cl, " inode %p %llx.%llx\n", rinode, ceph_ino(rinode),

fs/ceph/mds_client.c

2918

doutc(cl, " dentry %p %llx/%.*s\n", rdentry, path_info->vino.ino,

fs/ceph/mds_client.c

2927

doutc(cl, " path %.*s\n", path_info->pathlen, rpath);

fs/ceph/mds_client.c

3001

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

3137

pr_warn_once_client(cl,

fs/ceph/mds_client.c

3147

pr_err_ratelimited_client(cl,

fs/ceph/mds_client.c

3311

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

3330

pr_warn_ratelimited_client(cl, "request tid %llu seq overflow\n",

fs/ceph/mds_client.c

3346

doutc(cl, "%p tid %lld %s (attempt %d)\n", req, req->r_tid,

fs/ceph/mds_client.c

3415

doutc(cl, " r_parent = %p\n", req->r_parent);

fs/ceph/mds_client.c

3445

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

3458

doutc(cl, "metadata corrupted\n");

fs/ceph/mds_client.c

3464

doutc(cl, "timed out\n");

fs/ceph/mds_client.c

3469

doutc(cl, "forced umount\n");

fs/ceph/mds_client.c

3476

doutc(cl, "mdsmap err %d\n", err);

fs/ceph/mds_client.c

3480

doutc(cl, "no mdsmap, waiting for map\n");

fs/ceph/mds_client.c

3503

doutc(cl, "no mds or not active, waiting for map\n");

fs/ceph/mds_client.c

3521

doutc(cl, "mds%d session %p state %s\n", mds, session,

fs/ceph/mds_client.c

3617

doutc(cl, "session changed for auth cap %d -> %d\n",

fs/ceph/mds_client.c

3645

doutc(cl, "early error %d\n", err);

fs/ceph/mds_client.c

3659

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

3669

doutc(cl, " wake request %p tid %llu\n", req,

fs/ceph/mds_client.c

3682

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

3686

doutc(cl, "kick_requests mds%d\n", mds);

fs/ceph/mds_client.c

3696

doutc(cl, " kicking tid %llu\n", req->r_tid);

fs/ceph/mds_client.c

3707

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

3729

doutc(cl, "wait for async create returned: %d\n", err);

fs/ceph/mds_client.c

3737

doutc(cl, "wait for async create returned: %d\n", err);

fs/ceph/mds_client.c

3742

doutc(cl, "submit_request on %p for inode %p\n", req, dir);

fs/ceph/mds_client.c

3756

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

3760

doutc(cl, "do_request waiting\n");

fs/ceph/mds_client.c

3774

doutc(cl, "do_request waited, got %d\n", err);

fs/ceph/mds_client.c

3781

doutc(cl, "aborted request %lld with %d\n", req->r_tid, err);

fs/ceph/mds_client.c

3812

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

3815

doutc(cl, "do_request on %p\n", req);

fs/ceph/mds_client.c

3821

doutc(cl, "do_request %p done, result %d\n", req, err);

fs/ceph/mds_client.c

3833

struct ceph_client *cl = req->r_mdsc->fsc->client;

fs/ceph/mds_client.c

3835

doutc(cl, "invalidate_dir_request %p %p (complete, lease(s))\n",

fs/ceph/mds_client.c

3857

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

3868

pr_err_client(cl, "got corrupt (short) reply\n");

fs/ceph/mds_client.c

3878

doutc(cl, "on unknown tid %llu\n", tid);

fs/ceph/mds_client.c

3882

doutc(cl, "handle_reply %p\n", req);

fs/ceph/mds_client.c

3886

pr_err_client(cl, "got %llu on session mds%d not mds%d\n",

fs/ceph/mds_client.c

3896

pr_warn_client(cl, "got a dup %s reply on %llu from mds%d\n",

fs/ceph/mds_client.c

3902

pr_warn_client(cl, "got unsafe after safe on %llu from mds%d\n",

fs/ceph/mds_client.c

3926

doutc(cl, "got safe reply %llu, mds%d\n", tid, mds);

fs/ceph/mds_client.c

3936

doutc(cl, "tid %lld result %d\n", tid, result);

fs/ceph/mds_client.c

3976

pr_err_client(cl, "got corrupt reply mds%d(tid:%lld)\n",

fs/ceph/mds_client.c

4041

doutc(cl, "reply arrived after request %lld was aborted\n", tid);

fs/ceph/mds_client.c

4070

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

4088

doutc(cl, "forward tid %llu to mds%d - req dne\n", tid, next_mds);

fs/ceph/mds_client.c

4093

doutc(cl, "forward tid %llu aborted, unregistering\n", tid);

fs/ceph/mds_client.c

4109

pr_warn_ratelimited_client(cl, "forward tid %llu seq overflow\n",

fs/ceph/mds_client.c

4113

doutc(cl, "forward tid %llu to mds%d (we resend)\n", tid, next_mds);

fs/ceph/mds_client.c

4131

pr_err_client(cl, "decode error err=%d\n", err);

fs/ceph/mds_client.c

416

struct ceph_client *cl = req->r_mdsc->fsc->client;

fs/ceph/mds_client.c

4170

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

4221

pr_warn_client(cl, "mds%d session blocklisted\n",

fs/ceph/mds_client.c

4229

doutc(cl, "cap_auths_num %d\n", cap_auths_num);

fs/ceph/mds_client.c

4239

pr_err_client(cl, "No memory for cap_auths\n");

fs/ceph/mds_client.c

4257

pr_err_client(cl, "No memory for gids\n");

fs/ceph/mds_client.c

4273

pr_err_client(cl, "No memory for path\n");

fs/ceph/mds_client.c

4290

pr_err_client(cl, "No memory for fs_name\n");

fs/ceph/mds_client.c

4299

doutc(cl, "uid %lld, num_gids %u, path %s, fs_name %s, root_squash %d, readable %d, writeable %d\n",

fs/ceph/mds_client.c

4331

doutc(cl, "mds%d %s %p state %s seq %llu\n", mds,

fs/ceph/mds_client.c

4337

pr_info_client(cl, "mds%d came back\n", session->s_mds);

fs/ceph/mds_client.c

4343

pr_info_client(cl, "mds%d reconnect success\n",

fs/ceph/mds_client.c

4348

pr_notice_client(cl, "mds%d is already opened\n",

fs/ceph/mds_client.c

4378

pr_info_client(cl, "mds%d reconnect denied\n",

fs/ceph/mds_client.c

4388

pr_info_client(cl, "mds%d caps went stale, renewing\n",

fs/ceph/mds_client.c

439

pr_err_client(cl, "dir contents are larger than expected\n");

fs/ceph/mds_client.c

4410

doutc(cl, "force_session_readonly %p\n", session);

fs/ceph/mds_client.c

4419

pr_info_client(cl, "mds%d rejected session\n",

fs/ceph/mds_client.c

4430

pr_err_client(cl, "bad op %d mds%d\n", op, mds);

fs/ceph/mds_client.c

4447

pr_err_client(cl, "corrupt message mds%d len %d\n", mds,

fs/ceph/mds_client.c

4462

struct ceph_client *cl = req->r_mdsc->fsc->client;

fs/ceph/mds_client.c

4467

doutc(cl, "releasing r_dir_caps=%s\n", ceph_cap_string(dcaps));

fs/ceph/mds_client.c

4474

struct ceph_client *cl = req->r_mdsc->fsc->client;

fs/ceph/mds_client.c

4479

doutc(cl, "releasing r_dir_caps=%s\n", ceph_cap_string(dcaps));

fs/ceph/mds_client.c

460

doutc(cl, "parsed dir dname '%.*s'\n", _name_len, _name);

fs/ceph/mds_client.c

4638

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/mds_client.c

4671

doutc(cl, " adding %p ino %llx.%llx cap %p %lld %s\n", inode,

fs/ceph/mds_client.c

4827

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

4866

doutc(cl, " adding snap realm %llx seq %lld parent %llx\n",

fs/ceph/mds_client.c

4896

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

4905

pr_info_client(cl, "mds%d reconnect start\n", mds);

fs/ceph/mds_client.c

4921

doutc(cl, "session %p state %s\n", session,

fs/ceph/mds_client.c

5056

pr_err_client(cl, "error %d preparing reconnect for mds%d\n",

fs/ceph/mds_client.c

5076

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

5078

doutc(cl, "new %u old %u\n", newmap->m_epoch, oldmap->m_epoch);

fs/ceph/mds_client.c

5094

doutc(cl, "mds%d state %s%s -> %s%s (session %s)\n",

fs/ceph/mds_client.c

5152

pr_info_client(cl, "mds%d recovery completed\n",

fs/ceph/mds_client.c

5197

pr_err_client(cl,

fs/ceph/mds_client.c

520

pr_err_client(cl, "unable to decode %.*s, got %d\n",

fs/ceph/mds_client.c

5203

doutc(cl, "send reconnect to export target mds.%d\n", i);

fs/ceph/mds_client.c

5219

doutc(cl, " connecting to export targets of laggy mds%d\n", i);

fs/ceph/mds_client.c

5246

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

5258

doutc(cl, "from mds%d\n", mds);

fs/ceph/mds_client.c

5276

doutc(cl, "%s, ino %llx %p %.*s\n", ceph_lease_op_name(h->action),

fs/ceph/mds_client.c

5281

doutc(cl, "no inode %llx\n", vino.ino);

fs/ceph/mds_client.c

5288

doutc(cl, "no parent dentry on inode %p\n", inode);

fs/ceph/mds_client.c

5348

pr_err_client(cl, "corrupt lease message\n");

fs/ceph/mds_client.c

5356

struct ceph_client *cl = session->s_mdsc->fsc->client;

fs/ceph/mds_client.c

5362

doutc(cl, "identry %p %s to mds%d\n", dentry, ceph_lease_op_name(action),

fs/ceph/mds_client.c

5396

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

5408

pr_info_client(cl, "auto reconnect after blocklisted\n");

fs/ceph/mds_client.c

5414

struct ceph_client *cl = s->s_mdsc->fsc->client;

fs/ceph/mds_client.c

5420

pr_info_client(cl, "mds%d hung\n", s->s_mds);

fs/ceph/mds_client.c

5440

struct ceph_client *cl = s->s_mdsc->fsc->client;

fs/ceph/mds_client.c

5449

doutc(cl, "resending session close request for mds%d\n", s->s_mds);

fs/ceph/mds_client.c

545

pr_err_client(cl, "problem parsing dir contents %d\n", err);

fs/ceph/mds_client.c

5452

pr_err_client(cl, "unable to close session to mds%d: %d\n",

fs/ceph/mds_client.c

5619

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

5627

doutc(cl, "waiting for requests\n");

fs/ceph/mds_client.c

5634

doutc(cl, "timed out on tid %llu\n", req->r_tid);

fs/ceph/mds_client.c

5640

doutc(cl, "done\n");

fs/ceph/mds_client.c

5645

struct ceph_client *cl = s->s_mdsc->fsc->client;

fs/ceph/mds_client.c

5655

doutc(cl, "request mdlog flush to mds%d (%s)s seq %lld\n",

fs/ceph/mds_client.c

5660

pr_err_client(cl, "failed to request mdlog flush to mds%d (%s) seq %lld\n",

fs/ceph/mds_client.c

5675

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

5682

doutc(cl, "fsname check fs_name=%s match.fs_name=%s\n",

fs/ceph/mds_client.c

5690

doutc(cl, "match.uid %lld\n", auth->match.uid);

fs/ceph/mds_client.c

5730

doutc(cl, "server path %s, tpath %s, match.path %s\n",

fs/ceph/mds_client.c

5754

doutc(cl, "_tpath %s\n", _tpath);

fs/ceph/mds_client.c

576

struct ceph_client *cl = s->s_mdsc->fsc->client;

fs/ceph/mds_client.c

5784

doutc(cl, "matched\n");

fs/ceph/mds_client.c

5794

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

5798

doutc(cl, "tpath '%s', mask %d, caller_uid %d, caller_gid %d\n",

fs/ceph/mds_client.c

580

doutc(cl, "got %u sets of delegated inodes\n", sets);

fs/ceph/mds_client.c

5824

doutc(cl, "root_squash_perms %d, rw_perms_s %p\n", root_squash_perms,

fs/ceph/mds_client.c

5827

doutc(cl, "access allowed\n");

fs/ceph/mds_client.c

5832

doutc(cl, "root_squash is enabled and user(%d %d) isn't allowed to write",

fs/ceph/mds_client.c

5836

doutc(cl, "mds auth caps readable/writeable %d/%d while request r/w %d/%d",

fs/ceph/mds_client.c

5840

doutc(cl, "access denied\n");

fs/ceph/mds_client.c

5874

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

5880

doutc(cl, "want %lld\n", want_tid);

fs/ceph/mds_client.c

589

pr_warn_ratelimited_client(cl,

fs/ceph/mds_client.c

5914

doutc(cl, "wait on %llu (want %llu)\n",

fs/ceph/mds_client.c

5933

doutc(cl, "done\n");

fs/ceph/mds_client.c

5938

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

5944

doutc(cl, "sync\n");

fs/ceph/mds_client.c

5961

doutc(cl, "sync want tid %lld flush_seq %lld\n", want_tid, want_flush);

fs/ceph/mds_client.c

5983

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

5988

doutc(cl, "begin\n");

fs/ceph/mds_client.c

599

doutc(cl, "added delegated inode 0x%llx\n", start - 1);

fs/ceph/mds_client.c

6006

doutc(cl, "waiting for sessions to close\n");

fs/ceph/mds_client.c

601

pr_warn_client(cl,

fs/ceph/mds_client.c

6035

doutc(cl, "done\n");

fs/ceph/mds_client.c

6127

struct ceph_client *cl = fsc->client;

fs/ceph/mds_client.c

6139

doutc(cl, "epoch %u\n", epoch);

fs/ceph/mds_client.c

6184

pr_err_client(cl, "error decoding fsmap %d. Shutting down mount.\n",

fs/ceph/mds_client.c

6200

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

6215

doutc(cl, "epoch %u len %d\n", epoch, (int)maplen);

fs/ceph/mds_client.c

6220

doutc(cl, "epoch %u <= our %u\n", epoch, mdsc->mdsmap->m_epoch);

fs/ceph/mds_client.c

6254

pr_err_client(cl, "error decoding mdsmap %d. Shutting down mount.\n",

fs/ceph/mds_client.c

6297

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

6337

pr_err_client(cl, "received unknown message type %d %s\n",

fs/ceph/mds_client.c

752

struct ceph_client *cl = s->s_mdsc->fsc->client;

fs/ceph/mds_client.c

792

pr_err_client(cl, "mds parse_reply err %d\n", err);

fs/ceph/mds_client.c

840

struct ceph_client *cl = fsc->client;

fs/ceph/mds_client.c

865

pr_warn_client(cl, "dentry %p:%pd async unlink bit is not set\n",

fs/ceph/mds_client.c

882

doutc(cl, "dentry %p:%pd conflict with old %p:%pd\n", dentry, dentry,

fs/ceph/mds_client.c

967

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mds_client.c

985

doutc(cl, "realloc to %d\n", newmax);

fs/ceph/mds_client.c

998

doutc(cl, "mds%d\n", mds);

fs/ceph/mdsmap.c

121

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/mdsmap.c

239

doutc(cl, "%d/%d %lld mds%d.%d %s %s%s\n", i+1, n, global_id,

fs/ceph/mdsmap.c

244

pr_warn_client(cl, "got incorrect mds(%d)\n", mds);

fs/ceph/mdsmap.c

249

doutc(cl, "got incorrect state(%s)\n",

fs/ceph/mdsmap.c

373

pr_warn_client(cl, "fsname %s doesn't match mds_namespace %s\n",

fs/ceph/mdsmap.c

413

doutc(cl, "m_enabled: %d, m_damaged: %d, m_num_laggy: %d\n",

fs/ceph/mdsmap.c

416

doutc(cl, "success epoch %u\n", m->m_epoch);

fs/ceph/mdsmap.c

422

pr_err_client(cl, "corrupt mdsmap\n");

fs/ceph/metric.c

34

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/metric.c

55

pr_err_client(cl, "to mds%d, failed to allocate message\n",

fs/ceph/quota.c

115

pr_warn_client(cl, "Failed to alloc quotarealms_inode\n");

fs/ceph/quota.c

134

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/quota.c

167

doutc(cl, "Can't lookup inode %llx (err: %ld)\n", realm->ino,

fs/ceph/quota.c

218

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/quota.c

234

pr_err_ratelimited_client(cl,

fs/ceph/quota.c

330

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/quota.c

346

pr_err_ratelimited_client(cl,

fs/ceph/quota.c

398

pr_warn_client(cl, "Invalid quota check op (%d)\n", op);

fs/ceph/quota.c

46

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/quota.c

55

pr_err_client(cl, "corrupt message mds%d len %d\n",

fs/ceph/quota.c

66

pr_warn_client(cl, "failed to find inode %llx\n", vino.ino);

fs/ceph/quota.c

89

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

1020

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

1051

doutc(cl, "from mds%d op %s split %llx tracelen %d\n", mds,

fs/ceph/snap.c

1083

doutc(cl, "splitting snap_realm %llx %p\n", realm->ino, realm);

fs/ceph/snap.c

1108

doutc(cl, " leaving %p %llx.%llx in newer realm %llx %p\n",

fs/ceph/snap.c

1113

doutc(cl, " will move %p %llx.%llx to split realm %llx %p\n",

fs/ceph/snap.c

1175

pr_err_client(cl, "corrupt snap message from mds%d\n", mds);

fs/ceph/snap.c

1191

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

1214

doutc(cl, "found snapid map %llx -> %x\n", exist->snap,

fs/ceph/snap.c

1259

doutc(cl, "found snapid map %llx -> %x\n", exist->snap,

fs/ceph/snap.c

1264

doutc(cl, "create snapid map %llx -> %x\n", sm->snap, sm->dev);

fs/ceph/snap.c

1289

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

1311

doutc(cl, "trim snapid map %llx -> %x\n", sm->snap, sm->dev);

fs/ceph/snap.c

1319

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

1338

pr_err_client(cl, "snapid map %llx -> %x still in use\n",

fs/ceph/snap.c

153

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

166

doutc(cl, "%llx %p\n", r->ino, r);

fs/ceph/snap.c

192

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

195

doutc(cl, "%p %llx\n", realm, realm->ino);

fs/ceph/snap.c

295

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

309

doutc(cl, "%llx %p: %llx %p -> %llx %p\n", realm->ino, realm,

fs/ceph/snap.c

340

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

368

doutc(cl, "%llx %p: %p seq %lld (%u snaps) (unchanged)\n",

fs/ceph/snap.c

408

doutc(cl, "%llx %p: %p seq %lld (%u snaps)\n", realm->ino, realm,

fs/ceph/snap.c

426

pr_err_client(cl, "%llx %p fail %d\n", realm->ino, realm, err);

fs/ceph/snap.c

437

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

463

doutc(cl, "%llx %p, %s\n", realm->ino, realm,

fs/ceph/snap.c

534

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/snap.c

560

doutc(cl, "%p %llx.%llx already pending\n", inode,

fs/ceph/snap.c

566

doutc(cl, "%p %llx.%llx nothing dirty|writing\n", inode,

fs/ceph/snap.c

587

doutc(cl, "%p %llx.%llx no new_snap|dirty_page|writing\n",

fs/ceph/snap.c

593

doutc(cl, "%p %llx.%llx cap_snap %p queuing under %p %s %s\n",

fs/ceph/snap.c

627

doutc(cl, "%p %llx.%llx cap_snap %p snapc %p seq %llu used WR,"

fs/ceph/snap.c

646

doutc(cl, " new snapc is %p\n", new_snapc);

fs/ceph/snap.c

667

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

680

doutc(cl, "%p %llx.%llx cap_snap %p snapc %p %llu %s "

fs/ceph/snap.c

694

doutc(cl, "%p %llx.%llx cap_snap %p snapc %p %llu %s "

fs/ceph/snap.c

704

doutc(cl, "%p %llx.%llx cap_snap %p snapc %p %llu %s s=%llu\n",

fs/ceph/snap.c

725

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

730

doutc(cl, "%p %llx inode\n", realm, realm->ino);

fs/ceph/snap.c

749

pr_err_client(cl,

fs/ceph/snap.c

769

doutc(cl, "%p %llx done\n", realm, realm->ino);

fs/ceph/snap.c

783

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

798

doutc(cl, "deletion=%d\n", deletion);

fs/ceph/snap.c

828

doutc(cl, "updating %llx %p %lld -> %lld\n", realm->ino,

fs/ceph/snap.c

852

doutc(cl, "%llx %p seq %lld new\n", realm->ino, realm,

fs/ceph/snap.c

856

doutc(cl, "%llx %p seq %lld unchanged\n", realm->ino, realm,

fs/ceph/snap.c

860

doutc(cl, "done with %llx %p, rebuild_snapcs=%d, %p %p\n", realm->ino,

fs/ceph/snap.c

909

pr_err_client(cl, "error %d\n", err);

fs/ceph/snap.c

923

pr_err_client(cl, "failed to blocklist %s: %d\n",

fs/ceph/snap.c

944

struct ceph_client *cl = mdsc->fsc->client;

fs/ceph/snap.c

949

doutc(cl, "begin\n");

fs/ceph/snap.c

964

doutc(cl, "done\n");

fs/ceph/super.c

1051

struct ceph_client *cl = fsc->client;

fs/ceph/super.c

1058

doutc(cl, "opening '%s'\n", path);

fs/ceph/super.c

1078

doutc(cl, "success\n");

fs/ceph/super.c

1084

doutc(cl, "success, root dentry is %p\n", root);

fs/ceph/super.c

1143

struct ceph_client *cl = fsc->client;

fs/ceph/super.c

1148

doutc(cl, "mount start %p\n", fsc);

fs/ceph/super.c

1171

doutc(cl, "mount opening path '%s'\n", path);

fs/ceph/super.c

1186

doutc(cl, "mount success\n");

fs/ceph/super.c

1199

struct ceph_client *cl = fsc->client;

fs/ceph/super.c

1202

doutc(cl, "%p\n", s);

fs/ceph/super.c

1237

struct ceph_client *cl = fsc->client;

fs/ceph/super.c

1239

doutc(cl, "%p\n", sb);

fs/ceph/super.c

1242

doutc(cl, "monitor(s)/mount options don't match\n");

fs/ceph/super.c

1247

doutc(cl, "fsid doesn't match\n");

fs/ceph/super.c

1251

doutc(cl, "flags differ\n");

fs/ceph/super.c

1256

doutc(cl, "client is blocklisted (and CLEANRECOVER is not set)\n");

fs/ceph/super.c

1261

doutc(cl, "client has been forcibly unmounted\n");

fs/ceph/super.c

127

struct ceph_client *cl = fsc->client;

fs/ceph/super.c

130

doutc(cl, "(non-blocking)\n");

fs/ceph/super.c

133

doutc(cl, "(non-blocking) done\n");

fs/ceph/super.c

137

doutc(cl, "(blocking)\n");

fs/ceph/super.c

140

doutc(cl, "(blocking) done\n");

fs/ceph/super.c

1530

struct ceph_client *cl = fsc->client;

fs/ceph/super.c

1534

doutc(cl, "%p\n", s);

fs/ceph/super.c

1561

pr_warn_client(cl, "umount timed out, %ld\n", timeleft);

fs/ceph/super.c

1563

pr_warn_client(cl, "umount was killed, %ld\n", timeleft);

fs/ceph/super.c

1576

pr_warn_client(cl, "umount timed out, %ld\n", timeleft);

fs/ceph/super.c

1578

pr_warn_client(cl, "umount was killed, %ld\n", timeleft);

fs/ceph/xattr.c

1011

doutc(cl, "%p %llx.%llx name '%s' ver=%lld index_ver=%lld\n", inode,

fs/ceph/xattr.c

1022

pr_warn_ratelimited_client(cl,

fs/ceph/xattr.c

1066

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/xattr.c

1073

doutc(cl, "%p %llx.%llx ver=%lld index_ver=%lld\n", inode,

fs/ceph/xattr.c

1110

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/xattr.c

1135

doutc(cl, "name %s value size %zu\n", name, size);

fs/ceph/xattr.c

1164

doutc(cl, "xattr.ver (before): %lld\n", ci->i_xattrs.version);

fs/ceph/xattr.c

1167

doutc(cl, "xattr.ver (after): %lld\n", ci->i_xattrs.version);

fs/ceph/xattr.c

1178

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/xattr.c

1237

doutc(cl, "sync version: %llu size: %d max: %llu\n",

fs/ceph/xattr.c

1253

doutc(cl, "%p %llx.%llx name '%s' issued %s\n", inode,

fs/ceph/xattr.c

1263

doutc(cl, " pre-allocating new blob size=%d\n",

fs/ceph/xattr.c

1303

pr_warn_ratelimited_client(cl,

fs/ceph/xattr.c

573

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/xattr.c

61

struct ceph_client *cl = fsc->client;

fs/ceph/xattr.c

630

doutc(cl, "count=%d\n", ci->i_xattrs.count);

fs/ceph/xattr.c

658

doutc(cl, "p=%p\n", p);

fs/ceph/xattr.c

661

doutc(cl, "added %p %llx.%llx xattr %p %.*s=%.*s%s\n", inode,

fs/ceph/xattr.c

672

struct ceph_client *cl = ceph_inode_to_client(&ci->netfs.inode);

fs/ceph/xattr.c

693

doutc(cl, "%s found %.*s%s\n", name, len, xattr->val,

fs/ceph/xattr.c

699

doutc(cl, "%s not found\n", name);

fs/ceph/xattr.c

73

doutc(cl, "%p\n", &ci->netfs.inode);

fs/ceph/xattr.c

740

struct ceph_client *cl = ceph_inode_to_client(&ci->netfs.inode);

fs/ceph/xattr.c

745

doutc(cl, "count=%d\n", ci->i_xattrs.count);

fs/ceph/xattr.c

752

doutc(cl, "dest=%s %p (%s) (%d/%d)\n", dest, xattr, xattr->name,

fs/ceph/xattr.c

764

struct ceph_client *cl = ceph_inode_to_client(&ci->netfs.inode);

fs/ceph/xattr.c

770

doutc(cl, "p=%p\n", p);

fs/ceph/xattr.c

776

doutc(cl, "next p=%p (%.*s)\n", p, xattr->name_len, xattr->name);

fs/ceph/xattr.c

793

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/xattr.c

805

doutc(cl, "len=%d\n",

fs/ceph/xattr.c

881

struct ceph_client *cl = ceph_inode_to_client(&ci->netfs.inode);

fs/ceph/xattr.c

890

doutc(cl, "c=%d names.size=%d vals.size=%d\n", ci->i_xattrs.count,

fs/ceph/xattr.c

908

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/ceph/xattr.c

914

doutc(cl, "%p %llx.%llx\n", inode, ceph_vinop(inode));

fs/ceph/xattr.c

972

struct ceph_client *cl = ceph_inode_to_client(inode);

fs/dlm/config.c

425

struct dlm_cluster *cl = NULL;

fs/dlm/config.c

429

cl = kzalloc_obj(struct dlm_cluster, GFP_NOFS);

fs/dlm/config.c

433

if (!cl || !sps || !cms)

fs/dlm/config.c

436

cl->sps = sps;

fs/dlm/config.c

437

cl->cms = cms;

fs/dlm/config.c

439

config_group_init_type_name(&cl->group, name, &cluster_type);

fs/dlm/config.c

443

configfs_add_default_group(&sps->ss_group, &cl->group);

fs/dlm/config.c

444

configfs_add_default_group(&cms->cs_group, &cl->group);

fs/dlm/config.c

448

return &cl->group;

fs/dlm/config.c

451

kfree(cl);

fs/dlm/config.c

459

struct dlm_cluster *cl = config_item_to_cluster(i);

fs/dlm/config.c

461

configfs_remove_default_groups(&cl->group);

fs/dlm/config.c

471

struct dlm_cluster *cl = config_item_to_cluster(i);

fs/dlm/config.c

473

kfree(cl->sps);

fs/dlm/config.c

474

kfree(cl->cms);

fs/dlm/config.c

475

kfree(cl);

fs/nfs/file.c

578

struct nfs_client *cl = NFS_SERVER(inode)->nfs_client;

fs/nfs/file.c

600

if (cl->rpc_ops->enable_swap)

fs/nfs/file.c

601

cl->rpc_ops->enable_swap(inode);

fs/nfs/file.c

611

struct nfs_client *cl = NFS_SERVER(inode)->nfs_client;

fs/nfs/file.c

614

if (cl->rpc_ops->disable_swap)

fs/nfs/file.c

615

cl->rpc_ops->disable_swap(file_inode(file));

fs/nfs/nfs4state.c

2682

struct rpc_clnt *cl = clp->cl_rpcclient;

fs/nfs/nfs4state.c

2684

while (cl != cl->cl_parent)

fs/nfs/nfs4state.c

2685

cl = cl->cl_parent;

fs/nfs/nfs4state.c

2696

if (!atomic_read(&cl->cl_swapper))

fs/nfsd/export.c

1276

struct auth_domain *cl, struct auth_domain *gsscl,

fs/nfsd/export.c

1283

if (!cl)

fs/nfsd/export.c

1287

exp = exp_find(cd, cl, fsid_type, fsidv, reqp);

fs/nfsd/export.h

139

struct auth_domain *cl, struct auth_domain *gsscl,

fs/nfsd/nfs4state.c

2692

bool nfsd4_mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp)

fs/nfsd/nfs4state.c

2696

if (!cl->cl_mach_cred)

fs/nfsd/nfs4state.c

2698

if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech)

fs/nfsd/nfs4state.c

2702

if (cl->cl_cred.cr_raw_principal)

fs/nfsd/nfs4state.c

2703

return 0 == strcmp(cl->cl_cred.cr_raw_principal,

fs/nfsd/nfs4state.c

2707

return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal);

fs/nfsd/nfs4state.c

2731

find_stateid_locked(struct nfs4_client *cl, stateid_t *t)

fs/nfsd/nfs4state.c

2735

ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);

fs/nfsd/nfs4state.c

2742

find_stateid_by_type(struct nfs4_client *cl, stateid_t *t,

fs/nfsd/nfs4state.c

2747

spin_lock(&cl->cl_lock);

fs/nfsd/nfs4state.c

2748

s = find_stateid_locked(cl, t);

fs/nfsd/nfs4state.c

2756

spin_unlock(&cl->cl_lock);

fs/nfsd/nfs4state.c

5033

struct nfs4_client *cl = s->sc_client;

fs/nfsd/nfs4state.c

5044

spin_unlock(&cl->cl_lock);

fs/nfsd/nfs4state.c

5050

spin_unlock(&cl->cl_lock);

fs/nfsd/nfs4state.c

5057

spin_unlock(&cl->cl_lock);

fs/nfsd/nfs4state.c

5061

spin_unlock(&cl->cl_lock);

fs/nfsd/nfs4state.c

5065

static void nfsd40_drop_revoked_stid(struct nfs4_client *cl,

fs/nfsd/nfs4state.c

5076

if (cl->cl_minorversion == 0) {

fs/nfsd/nfs4state.c

5079

spin_lock(&cl->cl_lock);

fs/nfsd/nfs4state.c

5080

st = find_stateid_locked(cl, stid);

fs/nfsd/nfs4state.c

5084

spin_unlock(&cl->cl_lock);

fs/nfsd/nfs4state.c

5698

static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl,

fs/nfsd/nfs4state.c

5703

ret = find_stateid_by_type(cl, s, SC_TYPE_DELEG, SC_STATUS_REVOKED);

fs/nfsd/nfs4state.c

5716

nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,

fs/nfsd/nfs4state.c

5723

deleg = find_deleg_stateid(cl, &open->op_delegate_stateid);

fs/nfsd/nfs4state.c

5733

nfsd40_drop_revoked_stid(cl, &open->op_delegate_stateid);

fs/nfsd/nfs4state.c

6427

struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;

fs/nfsd/nfs4state.c

6443

status = nfs4_check_deleg(cl, open, &dp);

fs/nfsd/nfs4state.c

7188

static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)

fs/nfsd/nfs4state.c

7196

spin_lock(&cl->cl_lock);

fs/nfsd/nfs4state.c

7197

s = find_stateid_locked(cl, stateid);

fs/nfsd/nfs4state.c

7220

spin_unlock(&cl->cl_lock);

fs/nfsd/nfs4state.c

7222

nfsd40_drop_revoked_stid(cl, stateid);

fs/nfsd/nfs4state.c

7502

struct nfs4_client *cl = cstate->clp;

fs/nfsd/nfs4state.c

7506

nfsd4_validate_stateid(cl, &stateid->ts_id_stateid);

fs/nfsd/nfs4state.c

7548

struct nfs4_client *cl = cstate->clp;

fs/nfsd/nfs4state.c

7551

spin_lock(&cl->cl_lock);

fs/nfsd/nfs4state.c

7552

s = find_stateid_locked(cl, stateid);

fs/nfsd/nfs4state.c

7570

spin_unlock(&cl->cl_lock);

fs/nfsd/nfs4state.c

7586

spin_unlock(&cl->cl_lock);

fs/nfsd/nfs4state.c

7592

spin_unlock(&cl->cl_lock);

fs/nfsd/nfs4state.c

8257

struct nfs4_client *cl = oo->oo_owner.so_client;

fs/nfsd/nfs4state.c

8263

lo = find_lockowner_str(cl, &lock->lk_new_owner);

fs/nfsd/nfs4state.c

8266

lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);

fs/nfsd/nfs4state.c

887

struct nfs4_client *cl;

fs/nfsd/nfs4state.c

892

cl = new->co_client;

fs/nfsd/nfs4state.c

896

if (co->co_client == cl) {

fs/nfsd/nfs4state.c

909

struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab,

fs/nfsd/nfs4state.c

920

spin_lock(&cl->cl_lock);

fs/nfsd/nfs4state.c

922

new_id = idr_alloc_cyclic(&cl->cl_stateids, stid, 1, 0, GFP_NOWAIT);

fs/nfsd/nfs4state.c

923

spin_unlock(&cl->cl_lock);

fs/nfsd/nfs4state.c

929

stid->sc_client = cl;

fs/nfsd/nfs4state.c

931

stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;

fs/nfsd/state.h

800

struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab,

fs/nfsd/xdr4.h

948

bool nfsd4_mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp);

fs/nls/mac-celtic.c

558

unsigned char cl = uni & 0x00ff;

fs/nls/mac-celtic.c

565

if (uni2charset && uni2charset[cl])

fs/nls/mac-celtic.c

566

out[0] = uni2charset[cl];

fs/nls/mac-centeuro.c

488

unsigned char cl = uni & 0x00ff;

fs/nls/mac-centeuro.c

495

if (uni2charset && uni2charset[cl])

fs/nls/mac-centeuro.c

496

out[0] = uni2charset[cl];

fs/nls/mac-croatian.c

558

unsigned char cl = uni & 0x00ff;

fs/nls/mac-croatian.c

565

if (uni2charset && uni2charset[cl])

fs/nls/mac-croatian.c

566

out[0] = uni2charset[cl];

fs/nls/mac-cyrillic.c

453

unsigned char cl = uni & 0x00ff;

fs/nls/mac-cyrillic.c

460

if (uni2charset && uni2charset[cl])

fs/nls/mac-cyrillic.c

461

out[0] = uni2charset[cl];

fs/nls/mac-gaelic.c

523

unsigned char cl = uni & 0x00ff;

fs/nls/mac-gaelic.c

530

if (uni2charset && uni2charset[cl])

fs/nls/mac-gaelic.c

531

out[0] = uni2charset[cl];

fs/nls/mac-greek.c

453

unsigned char cl = uni & 0x00ff;

fs/nls/mac-greek.c

460

if (uni2charset && uni2charset[cl])

fs/nls/mac-greek.c

461

out[0] = uni2charset[cl];

fs/nls/mac-iceland.c

558

unsigned char cl = uni & 0x00ff;

fs/nls/mac-iceland.c

565

if (uni2charset && uni2charset[cl])

fs/nls/mac-iceland.c

566

out[0] = uni2charset[cl];

fs/nls/mac-inuit.c

488

unsigned char cl = uni & 0x00ff;

fs/nls/mac-inuit.c

495

if (uni2charset && uni2charset[cl])

fs/nls/mac-inuit.c

496

out[0] = uni2charset[cl];

fs/nls/mac-roman.c

593

unsigned char cl = uni & 0x00ff;

fs/nls/mac-roman.c

600

if (uni2charset && uni2charset[cl])

fs/nls/mac-roman.c

601

out[0] = uni2charset[cl];

fs/nls/mac-romanian.c

558

unsigned char cl = uni & 0x00ff;

fs/nls/mac-romanian.c

565

if (uni2charset && uni2charset[cl])

fs/nls/mac-romanian.c

566

out[0] = uni2charset[cl];

fs/nls/mac-turkish.c

558

unsigned char cl = uni & 0x00ff;

fs/nls/mac-turkish.c

565

if (uni2charset && uni2charset[cl])

fs/nls/mac-turkish.c

566

out[0] = uni2charset[cl];

fs/nls/nls_ascii.c

123

unsigned char cl = uni & 0x00ff;

fs/nls/nls_ascii.c

130

if (uni2charset && uni2charset[cl])

fs/nls/nls_ascii.c

131

out[0] = uni2charset[cl];

fs/nls/nls_base.c

512

unsigned char cl = uni & 0x00ff;

fs/nls/nls_base.c

519

if (uni2charset && uni2charset[cl])

fs/nls/nls_base.c

520

out[0] = uni2charset[cl];

fs/nls/nls_cp1250.c

304

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp1250.c

311

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp1250.c

312

out[0] = uni2charset[cl];

fs/nls/nls_cp1251.c

258

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp1251.c

265

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp1251.c

266

out[0] = uni2charset[cl];

fs/nls/nls_cp1255.c

339

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp1255.c

346

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp1255.c

347

out[0] = uni2charset[cl];

fs/nls/nls_cp437.c

344

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp437.c

351

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp437.c

352

out[0] = uni2charset[cl];

fs/nls/nls_cp737.c

307

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp737.c

314

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp737.c

315

out[0] = uni2charset[cl];

fs/nls/nls_cp775.c

276

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp775.c

283

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp775.c

284

out[0] = uni2charset[cl];

fs/nls/nls_cp850.c

272

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp850.c

279

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp850.c

280

out[0] = uni2charset[cl];

fs/nls/nls_cp852.c

294

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp852.c

301

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp852.c

302

out[0] = uni2charset[cl];

fs/nls/nls_cp855.c

256

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp855.c

263

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp855.c

264

out[0] = uni2charset[cl];

fs/nls/nls_cp857.c

258

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp857.c

265

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp857.c

266

out[0] = uni2charset[cl];

fs/nls/nls_cp860.c

321

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp860.c

328

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp860.c

329

out[0] = uni2charset[cl];

fs/nls/nls_cp861.c

344

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp861.c

351

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp861.c

352

out[0] = uni2charset[cl];

fs/nls/nls_cp862.c

378

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp862.c

385

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp862.c

386

out[0] = uni2charset[cl];

fs/nls/nls_cp863.c

338

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp863.c

345

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp863.c

346

out[0] = uni2charset[cl];

fs/nls/nls_cp864.c

364

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp864.c

371

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp864.c

372

out[0] = uni2charset[cl];

fs/nls/nls_cp865.c

344

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp865.c

351

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp865.c

352

out[0] = uni2charset[cl];

fs/nls/nls_cp866.c

262

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp866.c

269

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp866.c

270

out[0] = uni2charset[cl];

fs/nls/nls_cp869.c

272

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp869.c

279

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp869.c

280

out[0] = uni2charset[cl];

fs/nls/nls_cp874.c

230

unsigned char cl = uni & 0x00ff;

fs/nls/nls_cp874.c

237

if (uni2charset && uni2charset[cl])

fs/nls/nls_cp874.c

238

out[0] = uni2charset[cl];

fs/nls/nls_cp932.c

7841

unsigned char cl = uni&0xFF;

fs/nls/nls_cp932.c

7847

if (ch == 0xFF && 0x61 <= cl && cl <= 0x9F) {

fs/nls/nls_cp932.c

7848

out[0] = cl + 0x40;

fs/nls/nls_cp932.c

7856

out[0] = uni2charset[cl*2];

fs/nls/nls_cp932.c

7857

out[1] = uni2charset[cl*2+1];

fs/nls/nls_cp932.c

7862

if (cl <= 0x7F) {

fs/nls/nls_cp932.c

7863

out[0] = cl;

fs/nls/nls_cp932.c

7865

} else if (0xA0 <= cl) {

fs/nls/nls_cp932.c

7866

out[0] = u2c_00hi[cl - 0xA0][0];

fs/nls/nls_cp932.c

7867

out[1] = u2c_00hi[cl - 0xA0][1];

fs/nls/nls_cp932.c

7880

unsigned char ch, cl;

fs/nls/nls_cp932.c

7898

cl = rawstring[1];

fs/nls/nls_cp932.c

7900

if (charset2uni && cl) {

fs/nls/nls_cp932.c

7901

*uni = charset2uni[cl];

fs/nls/nls_cp936.c

11004

unsigned char cl = uni&0xFF;

fs/nls/nls_cp936.c

11018

out0 = u2c_00[cl*2];

fs/nls/nls_cp936.c

11019

out1 = u2c_00[cl*2+1];

fs/nls/nls_cp936.c

11021

if (cl<0x80) {

fs/nls/nls_cp936.c

11022

out[0] = cl;

fs/nls/nls_cp936.c

11039

out[0] = uni2charset[cl*2];

fs/nls/nls_cp936.c

11040

out[1] = uni2charset[cl*2+1];

fs/nls/nls_cp936.c

11052

unsigned char ch, cl;

fs/nls/nls_cp936.c

11069

cl = rawstring[1];

fs/nls/nls_cp936.c

11072

if (charset2uni && cl) {

fs/nls/nls_cp936.c

11073

*uni = charset2uni[cl];

fs/nls/nls_cp949.c

13865

unsigned char cl = uni&0xFF;

fs/nls/nls_cp949.c

13877

out[0] = uni2charset[cl*2];

fs/nls/nls_cp949.c

13878

out[1] = uni2charset[cl*2+1];

fs/nls/nls_cp949.c

13882

} else if (ch==0 && cl) {

fs/nls/nls_cp949.c

13883

out[0] = cl;

fs/nls/nls_cp949.c

13895

unsigned char ch, cl;

fs/nls/nls_cp949.c

13908

cl = rawstring[1];

fs/nls/nls_cp949.c

13911

if (charset2uni && cl) {

fs/nls/nls_cp949.c

13912

*uni = charset2uni[cl];

fs/nls/nls_cp950.c

9401

unsigned char cl = uni&0xFF;

fs/nls/nls_cp950.c

9413

out[0] = uni2charset[cl*2];

fs/nls/nls_cp950.c

9414

out[1] = uni2charset[cl*2+1];

fs/nls/nls_cp950.c

9418

} else if (ch==0 && cl) {

fs/nls/nls_cp950.c

9419

out[0] = cl;

fs/nls/nls_cp950.c

9431

unsigned char ch, cl;

fs/nls/nls_cp950.c

9444

cl = rawstring[1];

fs/nls/nls_cp950.c

9447

if (charset2uni && cl) {

fs/nls/nls_cp950.c

9448

*uni = charset2uni[cl];

fs/nls/nls_euc-jp.c

439

unsigned char ch, cl;

fs/nls/nls_euc-jp.c

444

n = 3; ch = out[0]; cl = out[1];

fs/nls/nls_euc-jp.c

446

MAP_SJIS2EUC(ch, cl, 0xF5, out[1], out[2], 0xF5);

fs/nls/nls_iso8859-1.c

214

unsigned char cl = uni & 0x00ff;

fs/nls/nls_iso8859-1.c

221

if (uni2charset && uni2charset[cl])

fs/nls/nls_iso8859-1.c

222

out[0] = uni2charset[cl];

fs/nls/nls_iso8859-13.c

242

unsigned char cl = uni & 0x00ff;

fs/nls/nls_iso8859-13.c

249

if (uni2charset && uni2charset[cl])

fs/nls/nls_iso8859-13.c

250

out[0] = uni2charset[cl];

fs/nls/nls_iso8859-14.c

298

unsigned char cl = uni & 0x00ff;

fs/nls/nls_iso8859-14.c

305

if (uni2charset && uni2charset[cl])

fs/nls/nls_iso8859-14.c

306

out[0] = uni2charset[cl];

fs/nls/nls_iso8859-15.c

264

unsigned char cl = uni & 0x00ff;

fs/nls/nls_iso8859-15.c

271

if (uni2charset && uni2charset[cl])

fs/nls/nls_iso8859-15.c

272

out[0] = uni2charset[cl];

fs/nls/nls_iso8859-2.c

265

unsigned char cl = uni & 0x00ff;

fs/nls/nls_iso8859-2.c

272

if (uni2charset && uni2charset[cl])

fs/nls/nls_iso8859-2.c

273

out[0] = uni2charset[cl];

fs/nls/nls_iso8859-3.c

265

unsigned char cl = uni & 0x00ff;

fs/nls/nls_iso8859-3.c

272

if (uni2charset && uni2charset[cl])

fs/nls/nls_iso8859-3.c

273

out[0] = uni2charset[cl];

fs/nls/nls_iso8859-4.c

265

unsigned char cl = uni & 0x00ff;

fs/nls/nls_iso8859-4.c

272

if (uni2charset && uni2charset[cl])

fs/nls/nls_iso8859-4.c

273

out[0] = uni2charset[cl];

fs/nls/nls_iso8859-5.c

229

unsigned char cl = uni & 0x00ff;

fs/nls/nls_iso8859-5.c

236

if (uni2charset && uni2charset[cl])

fs/nls/nls_iso8859-5.c

237

out[0] = uni2charset[cl];

fs/nls/nls_iso8859-6.c

220

unsigned char cl = uni & 0x00ff;

fs/nls/nls_iso8859-6.c

227

if (uni2charset && uni2charset[cl])

fs/nls/nls_iso8859-6.c

228

out[0] = uni2charset[cl];

fs/nls/nls_iso8859-7.c

274

unsigned char cl = uni & 0x00ff;

fs/nls/nls_iso8859-7.c

281

if (uni2charset && uni2charset[cl])

fs/nls/nls_iso8859-7.c

282

out[0] = uni2charset[cl];

fs/nls/nls_iso8859-9.c

229

unsigned char cl = uni & 0x00ff;

fs/nls/nls_iso8859-9.c

236

if (uni2charset && uni2charset[cl])

fs/nls/nls_iso8859-9.c

237

out[0] = uni2charset[cl];

fs/nls/nls_koi8-r.c

280

unsigned char cl = uni & 0x00ff;

fs/nls/nls_koi8-r.c

287

if (uni2charset && uni2charset[cl])

fs/nls/nls_koi8-r.c

288

out[0] = uni2charset[cl];

fs/nls/nls_koi8-u.c

287

unsigned char cl = uni & 0x00ff;

fs/nls/nls_koi8-u.c

294

if (uni2charset && uni2charset[cl])

fs/nls/nls_koi8-u.c

295

out[0] = uni2charset[cl];

fs/ntfs3/fslog.c

467

u16 cl, fl, ul;

fs/ntfs3/fslog.c

477

cl = le16_to_cpu(ra->log_clients);

fs/ntfs3/fslog.c

479

if (cl > 1)

fs/ntfs3/fslog.c

487

off += cl * sizeof(struct CLIENT_REC);

fs/ntfs3/fslog.c

507

if ((fl != LFS_NO_CLIENT && fl >= cl) ||

fs/ntfs3/fslog.c

508

(ul != LFS_NO_CLIENT && ul >= cl))

fs/ocfs2/inode.c

1529

struct ocfs2_chain_list *cl = &di->id2.i_chain;

fs/ocfs2/inode.c

1533

if (le16_to_cpu(cl->cl_count) != ocfs2_chain_recs_per_inode(sb)) {

fs/ocfs2/inode.c

1536

le16_to_cpu(cl->cl_count));

fs/ocfs2/inode.c

1539

if (le16_to_cpu(cl->cl_next_free_rec) > le16_to_cpu(cl->cl_count)) {

fs/ocfs2/inode.c

1542

le16_to_cpu(cl->cl_next_free_rec));

fs/ocfs2/inode.c

1547

le16_to_cpu(cl->cl_bpc) != bpc) {

fs/ocfs2/inode.c

1550

le16_to_cpu(cl->cl_bpc));

fs/ocfs2/ioctl.c

542

struct ocfs2_chain_list *cl = NULL;

fs/ocfs2/ioctl.c

565

cl = &(gb_dinode->id2.i_chain);

fs/ocfs2/ioctl.c

571

if (ffg->iff_chunksize > le16_to_cpu(cl->cl_cpg)) {

fs/ocfs2/ioctl.c

584

chunks_in_group = le16_to_cpu(cl->cl_cpg) / ffg->iff_chunksize + 1;

fs/ocfs2/ioctl.c

586

for (i = 0; i < le16_to_cpu(cl->cl_next_free_rec); i++) {

fs/ocfs2/ioctl.c

587

rec = &(cl->cl_recs[i]);

fs/ocfs2/move_extents.c

379

struct ocfs2_chain_list *cl;

fs/ocfs2/move_extents.c

399

cl = &(ac_dinode->id2.i_chain);

fs/ocfs2/move_extents.c

400

rec = &(cl->cl_recs[0]);

fs/ocfs2/move_extents.c

415

for (i = 0; i < le16_to_cpu(cl->cl_next_free_rec); i++) {

fs/ocfs2/move_extents.c

417

rec = &(cl->cl_recs[i]);

fs/ocfs2/resize.c

143

cr = (&cl->cl_recs[chain]);

fs/ocfs2/resize.c

464

struct ocfs2_chain_list *cl;

fs/ocfs2/resize.c

526

cl = &fe->id2.i_chain;

fs/ocfs2/resize.c

527

cr = &cl->cl_recs[input->chain];

fs/ocfs2/resize.c

549

if (input->chain == le16_to_cpu(cl->cl_next_free_rec)) {

fs/ocfs2/resize.c

550

le16_add_cpu(&cl->cl_next_free_rec, 1);

fs/ocfs2/resize.c

87

struct ocfs2_chain_list *cl = &fe->id2.i_chain;

fs/ocfs2/resize.c

91

u16 cl_bpc = le16_to_cpu(cl->cl_bpc);

fs/ocfs2/resize.c

92

u16 cl_cpg = le16_to_cpu(cl->cl_cpg);

fs/ocfs2/suballoc.c

149

static u32 ocfs2_bits_per_group(struct ocfs2_chain_list *cl)

fs/ocfs2/suballoc.c

1508

static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl)

fs/ocfs2/suballoc.c

151

return (u32)le16_to_cpu(cl->cl_cpg) * (u32)le16_to_cpu(cl->cl_bpc);

fs/ocfs2/suballoc.c

1512

BUG_ON(!cl->cl_next_free_rec);

fs/ocfs2/suballoc.c

1515

while (curr < le16_to_cpu(cl->cl_next_free_rec)) {

fs/ocfs2/suballoc.c

1516

if (le32_to_cpu(cl->cl_recs[curr].c_free) >

fs/ocfs2/suballoc.c

1517

le32_to_cpu(cl->cl_recs[best].c_free))

fs/ocfs2/suballoc.c

1522

BUG_ON(best >= le16_to_cpu(cl->cl_next_free_rec));

fs/ocfs2/suballoc.c

1709

struct ocfs2_chain_list *cl = (struct ocfs2_chain_list *) &di->id2.i_chain;

fs/ocfs2/suballoc.c

1720

le32_add_cpu(&cl->cl_recs[chain].c_free, -num_bits);

fs/ocfs2/suballoc.c

1734

struct ocfs2_chain_list *cl;

fs/ocfs2/suballoc.c

1736

cl = (struct ocfs2_chain_list *)&di->id2.i_chain;

fs/ocfs2/suballoc.c

1739

le32_add_cpu(&cl->cl_recs[chain].c_free, num_bits);

fs/ocfs2/suballoc.c

1744

struct ocfs2_chain_list *cl)

fs/ocfs2/suballoc.c

1746

unsigned int bpc = le16_to_cpu(cl->cl_bpc);

fs/ocfs2/suballoc.c

1769

struct ocfs2_chain_list *cl = &di->id2.i_chain;

fs/ocfs2/suballoc.c

1784

if (ocfs2_bg_discontig_fix_by_rec(res, rec, cl)) {

fs/ocfs2/suballoc.c

1876

struct ocfs2_chain_list *cl = (struct ocfs2_chain_list *) &fe->id2.i_chain;

fs/ocfs2/suballoc.c

1885

le64_to_cpu(cl->cl_recs[chain].c_blkno),

fs/ocfs2/suballoc.c

2027

struct ocfs2_chain_list *cl;

fs/ocfs2/suballoc.c

2072

cl = (struct ocfs2_chain_list *) &fe->id2.i_chain;

fs/ocfs2/suballoc.c

2073

if (!le16_to_cpu(cl->cl_next_free_rec) ||

fs/ocfs2/suballoc.c

2074

le16_to_cpu(cl->cl_next_free_rec) > le16_to_cpu(cl->cl_count)) {

fs/ocfs2/suballoc.c

2079

le16_to_cpu(cl->cl_next_free_rec),

fs/ocfs2/suballoc.c

2080

le16_to_cpu(cl->cl_count));

fs/ocfs2/suballoc.c

2084

victim = ocfs2_find_victim_chain(cl);

fs/ocfs2/suballoc.c

2109

for (i = 0; i < le16_to_cpu(cl->cl_next_free_rec); i ++) {

fs/ocfs2/suballoc.c

2112

if (le32_to_cpu(cl->cl_recs[i].c_free) < bits_wanted)

fs/ocfs2/suballoc.c

2131

if (i == le16_to_cpu(cl->cl_next_free_rec) &&

fs/ocfs2/suballoc.c

2666

struct ocfs2_chain_list *cl = &fe->id2.i_chain;

fs/ocfs2/suballoc.c

2670

rec = &(cl->cl_recs[idx]);

fs/ocfs2/suballoc.c

2674

le16_to_cpu(cl->cl_cpg)));

fs/ocfs2/suballoc.c

2712

fe->i_clusters = cpu_to_le32(tmp_used - le16_to_cpu(cl->cl_cpg));

fs/ocfs2/suballoc.c

2726

count = le32_to_cpu(rec->c_total) / le16_to_cpu(cl->cl_bpc);

fs/ocfs2/suballoc.c

2732

next_free_rec = le16_to_cpu(cl->cl_next_free_rec);

fs/ocfs2/suballoc.c

2736

if (cl->cl_recs[i].c_free == cl->cl_recs[i].c_total)

fs/ocfs2/suballoc.c

2742

le16_add_cpu(&cl->cl_next_free_rec, -len);

fs/ocfs2/suballoc.c

2766

cl = &fe->id2.i_chain;

fs/ocfs2/suballoc.c

2807

rec = &(cl->cl_recs[idx]);

fs/ocfs2/suballoc.c

2844

struct ocfs2_chain_list *cl = &fe->id2.i_chain;

fs/ocfs2/suballoc.c

2856

BUG_ON((count + start_bit) > ocfs2_bits_per_group(cl));

fs/ocfs2/suballoc.c

2894

rec = &(cl->cl_recs[idx]);

fs/ocfs2/suballoc.c

2907

(le16_to_cpu(cl->cl_next_free_rec) == 1)) {

fs/ocfs2/suballoc.c

393

struct ocfs2_chain_list *cl,

fs/ocfs2/suballoc.c

405

le16_to_cpu(cl->cl_bpc));

fs/ocfs2/suballoc.c

407

le16_add_cpu(&bg->bg_bits, clusters * le16_to_cpu(cl->cl_bpc));

fs/ocfs2/suballoc.c

409

clusters * le16_to_cpu(cl->cl_bpc));

fs/ocfs2/suballoc.c

419

struct ocfs2_chain_list *cl)

fs/ocfs2/suballoc.c

449

bg->bg_next_group = cl->cl_recs[my_chain].c_blkno;

fs/ocfs2/suballoc.c

452

if (group_clusters == le16_to_cpu(cl->cl_cpg))

fs/ocfs2/suballoc.c

453

bg->bg_bits = cpu_to_le16(ocfs2_bits_per_group(cl));

fs/ocfs2/suballoc.c

455

ocfs2_bg_discontig_add_extent(osb, bg, cl, group_blkno,

fs/ocfs2/suballoc.c

475

static inline u16 ocfs2_find_smallest_chain(struct ocfs2_chain_list *cl)

fs/ocfs2/suballoc.c

480

while (curr < le16_to_cpu(cl->cl_count)) {

fs/ocfs2/suballoc.c

481

if (le32_to_cpu(cl->cl_recs[best].c_total) >

fs/ocfs2/suballoc.c

482

le32_to_cpu(cl->cl_recs[curr].c_total))

fs/ocfs2/suballoc.c

493

struct ocfs2_chain_list *cl)

fs/ocfs2/suballoc.c

499

unsigned int alloc_rec = ocfs2_find_smallest_chain(cl);

fs/ocfs2/suballoc.c

502

le16_to_cpu(cl->cl_cpg), &bit_off,

fs/ocfs2/suballoc.c

524

bg_blkno, num_bits, alloc_rec, cl);

fs/ocfs2/suballoc.c

558

struct ocfs2_chain_list *cl,

fs/ocfs2/suballoc.c

565

unsigned int needed = le16_to_cpu(cl->cl_cpg) -

fs/ocfs2/suballoc.c

566

le16_to_cpu(bg->bg_bits) / le16_to_cpu(cl->cl_bpc);

fs/ocfs2/suballoc.c

593

ocfs2_bg_discontig_add_extent(osb, bg, cl, p_blkno,

fs/ocfs2/suballoc.c

597

needed = le16_to_cpu(cl->cl_cpg) -

fs/ocfs2/suballoc.c

598

le16_to_cpu(bg->bg_bits) / le16_to_cpu(cl->cl_bpc);

fs/ocfs2/suballoc.c

650

struct ocfs2_chain_list *cl)

fs/ocfs2/suballoc.c

655

unsigned int min_bits = le16_to_cpu(cl->cl_cpg) >> 1;

fs/ocfs2/suballoc.c

657

unsigned int alloc_rec = ocfs2_find_smallest_chain(cl);

fs/ocfs2/suballoc.c

704

bg_blkno, num_bits, alloc_rec, cl);

fs/ocfs2/suballoc.c

71

static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl);

fs/ocfs2/suballoc.c

711

bg_bh, ac, cl, min_bits);

fs/ocfs2/suballoc.c

733

struct ocfs2_chain_list *cl;

fs/ocfs2/suballoc.c

742

cl = &fe->id2.i_chain;

fs/ocfs2/suballoc.c

744

le16_to_cpu(cl->cl_cpg),

fs/ocfs2/suballoc.c

753

le16_to_cpu(cl->cl_cpg));

fs/ocfs2/suballoc.c

769

ac, cl);

fs/ocfs2/suballoc.c

774

ac, cl);

fs/ocfs2/suballoc.c

78

struct ocfs2_chain_list *cl);

fs/ocfs2/suballoc.c

793

le32_add_cpu(&cl->cl_recs[alloc_rec].c_free,

fs/ocfs2/suballoc.c

795

le32_add_cpu(&cl->cl_recs[alloc_rec].c_total,

fs/ocfs2/suballoc.c

797

cl->cl_recs[alloc_rec].c_blkno = bg->bg_blkno;

fs/ocfs2/suballoc.c

798

if (le16_to_cpu(cl->cl_next_free_rec) < le16_to_cpu(cl->cl_count))

fs/ocfs2/suballoc.c

799

le16_add_cpu(&cl->cl_next_free_rec, 1);

fs/ocfs2/suballoc.c

804

le32_add_cpu(&fe->i_clusters, le16_to_cpu(cl->cl_cpg));

fs/resctrl/rdtgroup.c

2687

int ret, cl;

fs/resctrl/rdtgroup.c

2717

cl = strlen(s->name);

fs/resctrl/rdtgroup.c

2725

cl += 4;

fs/resctrl/rdtgroup.c

2727

if (cl > max_name_width)

fs/resctrl/rdtgroup.c

2728

max_name_width = cl;

include/acpi/pcc.h

38

pcc_mbox_request_channel(struct mbox_client *cl, int subspace_id);

include/acpi/pcc.h

42

pcc_mbox_request_channel(struct mbox_client *cl, int subspace_id)

include/linux/ceph/mon_client.h

110

extern int ceph_monc_init(struct ceph_mon_client *monc, struct ceph_client *cl);

include/linux/clkdev.h

33

void clkdev_add(struct clk_lookup *cl);

include/linux/clkdev.h

34

void clkdev_drop(struct clk_lookup *cl);

include/linux/closure.h

171

void closure_sub(struct closure *cl, int v);

include/linux/closure.h

172

void closure_put(struct closure *cl);

include/linux/closure.h

174

bool closure_wait(struct closure_waitlist *list, struct closure *cl);

include/linux/closure.h

175

void __closure_sync(struct closure *cl);

include/linux/closure.h

177

static inline unsigned closure_nr_remaining(struct closure *cl)

include/linux/closure.h

179

return atomic_read(&cl->remaining) & CLOSURE_REMAINING_MASK;

include/linux/closure.h

188

static inline void closure_sync(struct closure *cl)

include/linux/closure.h

191

BUG_ON(closure_nr_remaining(cl) != 1 && !cl->closure_get_happened);

include/linux/closure.h

194

if (cl->closure_get_happened)

include/linux/closure.h

195

__closure_sync(cl);

include/linux/closure.h

198

int __closure_sync_timeout(struct closure *cl, unsigned long timeout);

include/linux/closure.h

200

static inline int closure_sync_timeout(struct closure *cl, unsigned long timeout)

include/linux/closure.h

203

BUG_ON(closure_nr_remaining(cl) != 1 && !cl->closure_get_happened);

include/linux/closure.h

205

return cl->closure_get_happened

include/linux/closure.h

206

? __closure_sync_timeout(cl, timeout)

include/linux/closure.h

212

void closure_debug_create(struct closure *cl);

include/linux/closure.h

213

void closure_debug_destroy(struct closure *cl);

include/linux/closure.h

217

static inline void closure_debug_create(struct closure *cl) {}

include/linux/closure.h

218

static inline void closure_debug_destroy(struct closure *cl) {}

include/linux/closure.h

222

static inline void closure_set_ip(struct closure *cl)

include/linux/closure.h

225

cl->ip = _THIS_IP_;

include/linux/closure.h

229

static inline void closure_set_ret_ip(struct closure *cl)

include/linux/closure.h

232

cl->ip = _RET_IP_;

include/linux/closure.h

236

static inline void closure_set_waiting(struct closure *cl, unsigned long f)

include/linux/closure.h

239

cl->waiting_on = f;

include/linux/closure.h

243

static inline void closure_set_stopped(struct closure *cl)

include/linux/closure.h

245

atomic_sub(CLOSURE_RUNNING, &cl->remaining);

include/linux/closure.h

248

static inline void set_closure_fn(struct closure *cl, closure_fn *fn,

include/linux/closure.h

251

closure_set_ip(cl);

include/linux/closure.h

252

cl->fn = fn;

include/linux/closure.h

253

cl->wq = wq;

include/linux/closure.h

256

static inline void closure_queue(struct closure *cl)

include/linux/closure.h

258

struct workqueue_struct *wq = cl->wq;

include/linux/closure.h

267

INIT_WORK(&cl->work, cl->work.func);

include/linux/closure.h

268

BUG_ON(!queue_work(wq, &cl->work));

include/linux/closure.h

270

cl->fn(&cl->work);

include/linux/closure.h

276

static inline void closure_get(struct closure *cl)

include/linux/closure.h

278

cl->closure_get_happened = true;

include/linux/closure.h

281

BUG_ON((atomic_inc_return(&cl->remaining) &

include/linux/closure.h

284

atomic_inc(&cl->remaining);

include/linux/closure.h

291

static inline bool closure_get_not_zero(struct closure *cl)

include/linux/closure.h

293

unsigned old = atomic_read(&cl->remaining);

include/linux/closure.h

298

} while (!atomic_try_cmpxchg_acquire(&cl->remaining, &old, old + 1));

include/linux/closure.h

309

static inline void closure_init(struct closure *cl, struct closure *parent)

include/linux/closure.h

311

cl->fn = NULL;

include/linux/closure.h

312

cl->parent = parent;

include/linux/closure.h

316

atomic_set(&cl->remaining, CLOSURE_REMAINING_INITIALIZER);

include/linux/closure.h

317

cl->closure_get_happened = false;

include/linux/closure.h

319

closure_debug_create(cl);

include/linux/closure.h

320

closure_set_ip(cl);

include/linux/closure.h

323

static inline void closure_init_stack(struct closure *cl)

include/linux/closure.h

325

memset(cl, 0, sizeof(struct closure));

include/linux/closure.h

326

atomic_set(&cl->remaining, CLOSURE_REMAINING_INITIALIZER);

include/linux/closure.h

328

cl->magic = CLOSURE_MAGIC_STACK;

include/linux/closure.h

332

static inline void closure_init_stack_release(struct closure *cl)

include/linux/closure.h

334

memset(cl, 0, sizeof(struct closure));

include/linux/closure.h

335

atomic_set_release(&cl->remaining, CLOSURE_REMAINING_INITIALIZER);

include/linux/closure.h

337

cl->magic = CLOSURE_MAGIC_STACK;

include/linux/closure.h

354

struct closure *cl = container_of(ws, struct closure, work); \

include/linux/closure.h

355

type *name = container_of(cl, type, member)

include/linux/closure.h

386

void closure_return_sync(struct closure *cl);

include/linux/closure.h

427

static inline void closure_call(struct closure *cl, closure_fn fn,

include/linux/closure.h

431

closure_init(cl, parent);

include/linux/closure.h

432

continue_at_nobarrier(cl, fn, wq);

include/linux/closure.h

437

struct closure cl; \

include/linux/closure.h

439

closure_init_stack(&cl); \

include/linux/closure.h

442

closure_wait(waitlist, &cl); \

include/linux/closure.h

445

closure_sync(&cl); \

include/linux/closure.h

448

closure_sync(&cl); \

include/linux/closure.h

459

struct closure cl; \

include/linux/closure.h

462

closure_init_stack(&cl); \

include/linux/closure.h

465

closure_wait(waitlist, &cl); \

include/linux/closure.h

473

closure_sync_timeout(&cl, _t); \

include/linux/closure.h

476

closure_sync(&cl); \

include/linux/firmware/imx/dsp.h

19

struct mbox_client cl;

include/linux/firmware/mediatek/mtk-adsp-ipc.h

34

struct mbox_client cl;

include/linux/hsi/hsi.h

138

static inline void hsi_client_set_drvdata(struct hsi_client *cl, void *data)

include/linux/hsi/hsi.h

140

dev_set_drvdata(&cl->device, data);

include/linux/hsi/hsi.h

143

static inline void *hsi_client_drvdata(struct hsi_client *cl)

include/linux/hsi/hsi.h

145

return dev_get_drvdata(&cl->device);

include/linux/hsi/hsi.h

148

int hsi_register_port_event(struct hsi_client *cl,

include/linux/hsi/hsi.h

150

int hsi_unregister_port_event(struct hsi_client *cl);

include/linux/hsi/hsi.h

187

struct hsi_client *cl;

include/linux/hsi/hsi.h

230

int (*setup)(struct hsi_client *cl);

include/linux/hsi/hsi.h

231

int (*flush)(struct hsi_client *cl);

include/linux/hsi/hsi.h

232

int (*start_tx)(struct hsi_client *cl);

include/linux/hsi/hsi.h

233

int (*stop_tx)(struct hsi_client *cl);

include/linux/hsi/hsi.h

234

int (*release)(struct hsi_client *cl);

include/linux/hsi/hsi.h

240

#define hsi_get_port(cl) to_hsi_port((cl)->device.parent)

include/linux/hsi/hsi.h

243

int hsi_claim_port(struct hsi_client *cl, unsigned int share);

include/linux/hsi/hsi.h

244

void hsi_release_port(struct hsi_client *cl);

include/linux/hsi/hsi.h

246

static inline int hsi_port_claimed(struct hsi_client *cl)

include/linux/hsi/hsi.h

248

return cl->pclaimed;

include/linux/hsi/hsi.h

319

int hsi_async(struct hsi_client *cl, struct hsi_msg *msg);

include/linux/hsi/hsi.h

321

int hsi_get_channel_id_by_name(struct hsi_client *cl, char *name);

include/linux/hsi/hsi.h

329

static inline unsigned int hsi_id(struct hsi_client *cl)

include/linux/hsi/hsi.h

331

return to_hsi_controller(cl->device.parent->parent)->id;

include/linux/hsi/hsi.h

340

static inline unsigned int hsi_port_id(struct hsi_client *cl)

include/linux/hsi/hsi.h

342

return to_hsi_port(cl->device.parent)->num;

include/linux/hsi/hsi.h

354

static inline int hsi_setup(struct hsi_client *cl)

include/linux/hsi/hsi.h

356

if (!hsi_port_claimed(cl))

include/linux/hsi/hsi.h

358

return hsi_get_port(cl)->setup(cl);

include/linux/hsi/hsi.h

370

static inline int hsi_flush(struct hsi_client *cl)

include/linux/hsi/hsi.h

372

if (!hsi_port_claimed(cl))

include/linux/hsi/hsi.h

374

return hsi_get_port(cl)->flush(cl);

include/linux/hsi/hsi.h

384

static inline int hsi_async_read(struct hsi_client *cl, struct hsi_msg *msg)

include/linux/hsi/hsi.h

387

return hsi_async(cl, msg);

include/linux/hsi/hsi.h

397

static inline int hsi_async_write(struct hsi_client *cl, struct hsi_msg *msg)

include/linux/hsi/hsi.h

400

return hsi_async(cl, msg);

include/linux/hsi/hsi.h

409

static inline int hsi_start_tx(struct hsi_client *cl)

include/linux/hsi/hsi.h

411

if (!hsi_port_claimed(cl))

include/linux/hsi/hsi.h

413

return hsi_get_port(cl)->start_tx(cl);

include/linux/hsi/hsi.h

422

static inline int hsi_stop_tx(struct hsi_client *cl)

include/linux/hsi/hsi.h

424

if (!hsi_port_claimed(cl))

include/linux/hsi/hsi.h

426

return hsi_get_port(cl)->stop_tx(cl);

include/linux/hsi/ssi_protocol.h

27

void ssi_waketest(struct hsi_client *cl, unsigned int enable);

include/linux/intel-ish-client-if.h

101

void ishtp_cl_destroy_connection(struct ishtp_cl *cl, bool reset);

include/linux/intel-ish-client-if.h

102

int ishtp_cl_send(struct ishtp_cl *cl, uint8_t *buf, size_t length);

include/linux/intel-ish-client-if.h

103

int ishtp_cl_flush_queues(struct ishtp_cl *cl);

include/linux/intel-ish-client-if.h

105

struct ishtp_cl_rb *ishtp_cl_rx_get_rb(struct ishtp_cl *cl);

include/linux/intel-ish-client-if.h

106

void *ishtp_get_client_data(struct ishtp_cl *cl);

include/linux/intel-ish-client-if.h

107

void ishtp_set_client_data(struct ishtp_cl *cl, void *data);

include/linux/intel-ish-client-if.h

108

struct ishtp_device *ishtp_get_ishtp_device(struct ishtp_cl *cl);

include/linux/intel-ish-client-if.h

109

void ishtp_set_tx_ring_size(struct ishtp_cl *cl, int size);

include/linux/intel-ish-client-if.h

110

void ishtp_set_rx_ring_size(struct ishtp_cl *cl, int size);

include/linux/intel-ish-client-if.h

111

void ishtp_set_connection_state(struct ishtp_cl *cl, int state);

include/linux/intel-ish-client-if.h

112

int ishtp_get_connection_state(struct ishtp_cl *cl);

include/linux/intel-ish-client-if.h

113

void ishtp_cl_set_fw_client_id(struct ishtp_cl *cl, int fw_client_id);

include/linux/intel-ish-client-if.h

70

struct ishtp_cl *cl;

include/linux/intel-ish-client-if.h

94

void ishtp_cl_free(struct ishtp_cl *cl);

include/linux/intel-ish-client-if.h

95

int ishtp_cl_link(struct ishtp_cl *cl);

include/linux/intel-ish-client-if.h

96

void ishtp_cl_unlink(struct ishtp_cl *cl);

include/linux/intel-ish-client-if.h

97

int ishtp_cl_disconnect(struct ishtp_cl *cl);

include/linux/intel-ish-client-if.h

98

int ishtp_cl_connect(struct ishtp_cl *cl);

include/linux/intel-ish-client-if.h

99

int ishtp_cl_establish_connection(struct ishtp_cl *cl, const guid_t *uuid,

include/linux/mailbox_client.h

35

void (*rx_callback)(struct mbox_client *cl, void *mssg);

include/linux/mailbox_client.h

36

void (*tx_prepare)(struct mbox_client *cl, void *mssg);

include/linux/mailbox_client.h

37

void (*tx_done)(struct mbox_client *cl, void *mssg, int r);

include/linux/mailbox_client.h

40

int mbox_bind_client(struct mbox_chan *chan, struct mbox_client *cl);

include/linux/mailbox_client.h

41

struct mbox_chan *mbox_request_channel_byname(struct mbox_client *cl,

include/linux/mailbox_client.h

43

struct mbox_chan *mbox_request_channel(struct mbox_client *cl, int index);

include/linux/mailbox_controller.h

124

struct mbox_client *cl;

include/linux/mei_cl_bus.h

48

struct mei_cl *cl;

include/linux/platform_data/x86/int3472.h

119

struct clk_lookup *cl;

include/linux/soc/samsung/exynos-regs-pmu.h

718

#define GS101_CLUSTER_CPU_OFFSET(cl, cpu) ((cl) + ((cpu) * 0x80))

include/linux/soc/samsung/exynos-regs-pmu.h

719

#define GS101_CLUSTER_CPU_CONFIGURATION(cl, cpu) \

include/linux/soc/samsung/exynos-regs-pmu.h

720

(GS101_CLUSTER_CPU_OFFSET(cl, cpu) + 0x00)

include/linux/soc/samsung/exynos-regs-pmu.h

721

#define GS101_CLUSTER_CPU_STATUS(cl, cpu) \

include/linux/soc/samsung/exynos-regs-pmu.h

722

(GS101_CLUSTER_CPU_OFFSET(cl, cpu) + 0x04)

include/linux/soc/samsung/exynos-regs-pmu.h

723

#define GS101_CLUSTER_CPU_STATES(cl, cpu) \

include/linux/soc/samsung/exynos-regs-pmu.h

724

(GS101_CLUSTER_CPU_OFFSET(cl, cpu) + 0x08)

include/linux/soc/samsung/exynos-regs-pmu.h

725

#define GS101_CLUSTER_CPU_OPTION(cl, cpu) \

include/linux/soc/samsung/exynos-regs-pmu.h

726

(GS101_CLUSTER_CPU_OFFSET(cl, cpu) + 0x0c)

include/linux/soc/samsung/exynos-regs-pmu.h

727

#define GS101_CLUSTER_CPU_OUT(cl, cpu) \

include/linux/soc/samsung/exynos-regs-pmu.h

728

(GS101_CLUSTER_CPU_OFFSET(cl, cpu) + 0x20)

include/linux/soc/samsung/exynos-regs-pmu.h

729

#define GS101_CLUSTER_CPU_IN(cl, cpu) \

include/linux/soc/samsung/exynos-regs-pmu.h

730

(GS101_CLUSTER_CPU_OFFSET(cl, cpu) + 0x24)

include/linux/soc/samsung/exynos-regs-pmu.h

731

#define GS101_CLUSTER_CPU_INT_IN(cl, cpu) \

include/linux/soc/samsung/exynos-regs-pmu.h

732

(GS101_CLUSTER_CPU_OFFSET(cl, cpu) + 0x40)

include/linux/soc/samsung/exynos-regs-pmu.h

733

#define GS101_CLUSTER_CPU_INT_EN(cl, cpu) \

include/linux/soc/samsung/exynos-regs-pmu.h

734

(GS101_CLUSTER_CPU_OFFSET(cl, cpu) + 0x44)

include/linux/soc/samsung/exynos-regs-pmu.h

735

#define GS101_CLUSTER_CPU_INT_TYPE(cl, cpu) \

include/linux/soc/samsung/exynos-regs-pmu.h

736

(GS101_CLUSTER_CPU_OFFSET(cl, cpu) + 0x48)

include/linux/soc/samsung/exynos-regs-pmu.h

737

#define GS101_CLUSTER_CPU_INT_DIR(cl, cpu) \

include/linux/soc/samsung/exynos-regs-pmu.h

738

(GS101_CLUSTER_CPU_OFFSET(cl, cpu) + 0x4c)

include/linux/soc/samsung/exynos-regs-pmu.h

740

#define GS101_CLUSTER_NONCPU_OFFSET(cl) (0x1200 + ((cl) * 0x200))

include/linux/soc/samsung/exynos-regs-pmu.h

741

#define GS101_CLUSTER_NONCPU_CONFIGURATION(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

742

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x00)

include/linux/soc/samsung/exynos-regs-pmu.h

743

#define GS101_CLUSTER_NONCPU_STATUS(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

744

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x04)

include/linux/soc/samsung/exynos-regs-pmu.h

745

#define GS101_CLUSTER_NONCPU_STATES(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

746

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x08)

include/linux/soc/samsung/exynos-regs-pmu.h

747

#define GS101_CLUSTER_NONCPU_OPTION(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

748

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x0c)

include/linux/soc/samsung/exynos-regs-pmu.h

749

#define GS101_CLUSTER_NONCPU_OUT(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

750

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x20)

include/linux/soc/samsung/exynos-regs-pmu.h

751

#define GS101_CLUSTER_NONCPU_IN(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

752

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x24)

include/linux/soc/samsung/exynos-regs-pmu.h

753

#define GS101_CLUSTER_NONCPU_INT_IN(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

754

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x40)

include/linux/soc/samsung/exynos-regs-pmu.h

755

#define GS101_CLUSTER_NONCPU_INT_EN(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

756

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x44)

include/linux/soc/samsung/exynos-regs-pmu.h

757

#define GS101_CLUSTER_NONCPU_INT_TYPE(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

758

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x48)

include/linux/soc/samsung/exynos-regs-pmu.h

759

#define GS101_CLUSTER_NONCPU_INT_DIR(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

760

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x4c)

include/linux/soc/samsung/exynos-regs-pmu.h

761

#define GS101_CLUSTER_NONCPU_DUALRAIL_CTRL_OUT(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

762

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x60)

include/linux/soc/samsung/exynos-regs-pmu.h

763

#define GS101_CLUSTER_NONCPU_DUALRAIL_POS_OUT(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

764

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x64)

include/linux/soc/samsung/exynos-regs-pmu.h

765

#define GS101_CLUSTER_NONCPU_DUALRAIL_CTRL_IN(cl) \

include/linux/soc/samsung/exynos-regs-pmu.h

766

(GS101_CLUSTER_NONCPU_OFFSET(cl) + 0x6c)

include/linux/usb.h

1044

#define USB_DEVICE_INTERFACE_CLASS(vend, prod, cl) \

include/linux/usb.h

1049

.bInterfaceClass = (cl)

include/linux/usb.h

1092

#define USB_DEVICE_INFO(cl, sc, pr) \

include/linux/usb.h

1094

.bDeviceClass = (cl), \

include/linux/usb.h

1107

#define USB_INTERFACE_INFO(cl, sc, pr) \

include/linux/usb.h

1109

.bInterfaceClass = (cl), \

include/linux/usb.h

1127

#define USB_DEVICE_AND_INTERFACE_INFO(vend, prod, cl, sc, pr) \

include/linux/usb.h

1132

.bInterfaceClass = (cl), \

include/linux/usb.h

1149

#define USB_VENDOR_AND_INTERFACE_INFO(vend, cl, sc, pr) \

include/linux/usb.h

1153

.bInterfaceClass = (cl), \

include/net/pkt_cls.h

163

__cls_set_class(unsigned long *clp, unsigned long cl)

include/net/pkt_cls.h

165

return xchg(clp, cl);

include/net/pkt_cls.h

171

unsigned long cl;

include/net/pkt_cls.h

173

cl = q->ops->cl_ops->bind_tcf(q, base, r->classid);

include/net/pkt_cls.h

174

cl = __cls_set_class(&r->class, cl);

include/net/pkt_cls.h

175

if (cl)

include/net/pkt_cls.h

176

q->ops->cl_ops->unbind_tcf(q, cl);

include/net/pkt_cls.h

197

unsigned long cl;

include/net/pkt_cls.h

199

if ((cl = __cls_set_class(&r->class, 0)) != 0)

include/net/pkt_cls.h

200

q->ops->cl_ops->unbind_tcf(q, cl);

include/net/pkt_cls.h

213

static inline void tc_cls_bind_class(u32 classid, unsigned long cl,

include/net/pkt_cls.h

218

if (cl)

include/net/pkt_sched.h

20

int (*fn)(struct Qdisc *, unsigned long cl, struct qdisc_walker *);

include/net/pkt_sched.h

275

unsigned long cl,

include/net/pkt_sched.h

278

if (arg->count >= arg->skip && arg->fn(sch, cl, arg) < 0) {

include/net/sch_generic.h

267

int (*graft)(struct Qdisc *, unsigned long cl,

include/net/sch_generic.h

270

struct Qdisc * (*leaf)(struct Qdisc *, unsigned long cl);

include/net/sch_generic.h

650

struct Qdisc_class_common *cl;

include/net/sch_generic.h

657

hlist_for_each_entry(cl, &hash->hash[h], hnode) {

include/net/sch_generic.h

658

if (cl->classid == id)

include/net/sch_generic.h

659

return cl;

include/net/sch_generic.h

664

static inline bool qdisc_class_in_use(const struct Qdisc_class_common *cl)

include/net/sch_generic.h

666

return cl->filter_cnt > 0;

include/net/sch_generic.h

669

static inline void qdisc_class_get(struct Qdisc_class_common *cl)

include/net/sch_generic.h

673

if (check_add_overflow(cl->filter_cnt, 1, &res))

include/net/sch_generic.h

676

cl->filter_cnt = res;

include/net/sch_generic.h

679

static inline void qdisc_class_put(struct Qdisc_class_common *cl)

include/net/sch_generic.h

683

if (check_sub_overflow(cl->filter_cnt, 1, &res))

include/net/sch_generic.h

686

cl->filter_cnt = res;

include/net/sch_priv.h

19

struct Qdisc *mq_leaf(struct Qdisc *sch, unsigned long cl);

include/net/sch_priv.h

21

int mq_dump_class(struct Qdisc *sch, unsigned long cl,

include/net/sch_priv.h

23

int mq_dump_class_stats(struct Qdisc *sch, unsigned long cl,

include/soc/fsl/qman.h

337

u8 cl; /* _res[6-7], as[4-5], ds[2-3], cs[0-1] */

include/soc/fsl/qman.h

463

st->cl = ((as & QM_FQD_XS_MASK) << QM_FQD_AS_OFF) |

include/soc/fsl/qman.h

470

return fqd->context_a.stashing.cl;

lib/closure.c

103

bool closure_wait(struct closure_waitlist *waitlist, struct closure *cl)

lib/closure.c

105

if (atomic_read(&cl->remaining) & CLOSURE_WAITING)

lib/closure.c

108

cl->closure_get_happened = true;

lib/closure.c

109

closure_set_waiting(cl, _RET_IP_);

lib/closure.c

110

atomic_add(CLOSURE_WAITING + 1, &cl->remaining);

lib/closure.c

111

llist_add(&cl->list, &waitlist->list);

lib/closure.c

124

struct closure *cl = container_of(ws, struct closure, work);

lib/closure.c

125

struct closure_syncer *s = cl->s;

lib/closure.c

135

void __sched __closure_sync(struct closure *cl)

lib/closure.c

139

cl->s = &s;

lib/closure.c

140

continue_at(cl, closure_sync_fn, NULL);

lib/closure.c

160

void __sched closure_return_sync(struct closure *cl)

lib/closure.c

164

cl->s = &s;

lib/closure.c

165

set_closure_fn(cl, closure_sync_fn, NULL);

lib/closure.c

168

&cl->remaining);

lib/closure.c

183

if (cl->parent)

lib/closure.c

184

closure_put(cl->parent);

lib/closure.c

188

int __sched __closure_sync_timeout(struct closure *cl, unsigned long timeout)

lib/closure.c

193

cl->s = &s;

lib/closure.c

194

continue_at(cl, closure_sync_fn, NULL);

lib/closure.c

206

unsigned old, new, v = atomic_read(&cl->remaining);

lib/closure.c

213

} while ((v = atomic_cmpxchg(&cl->remaining, old, new)) != old);

lib/closure.c

230

void closure_debug_create(struct closure *cl)

lib/closure.c

234

BUG_ON(cl->magic == CLOSURE_MAGIC_ALIVE);

lib/closure.c

235

cl->magic = CLOSURE_MAGIC_ALIVE;

lib/closure.c

238

list_add(&cl->all, &closure_list);

lib/closure.c

243

void closure_debug_destroy(struct closure *cl)

lib/closure.c

247

if (cl->magic == CLOSURE_MAGIC_STACK)

lib/closure.c

250

BUG_ON(cl->magic != CLOSURE_MAGIC_ALIVE);

lib/closure.c

251

cl->magic = CLOSURE_MAGIC_DEAD;

lib/closure.c

254

list_del(&cl->all);

lib/closure.c

261

struct closure *cl;

lib/closure.c

265

list_for_each_entry(cl, &closure_list, all) {

lib/closure.c

266

int r = atomic_read(&cl->remaining);

lib/closure.c

269

cl, (void *) cl->ip, cl->fn, cl->parent,

lib/closure.c

274

work_data_bits(&cl->work)) ? "Q" : "",

lib/closure.c

279

(void *) cl->waiting_on);

lib/closure.c

30

static inline void closure_put_after_sub(struct closure *cl, int flags)

lib/closure.c

37

cl->closure_get_happened = false;

lib/closure.c

39

if (cl->fn && !(flags & CLOSURE_DESTRUCTOR)) {

lib/closure.c

40

atomic_set(&cl->remaining,

lib/closure.c

42

closure_queue(cl);

lib/closure.c

44

struct closure *parent = cl->parent;

lib/closure.c

45

closure_fn *destructor = cl->fn;

lib/closure.c

47

closure_debug_destroy(cl);

lib/closure.c

50

destructor(&cl->work);

lib/closure.c

59

void closure_sub(struct closure *cl, int v)

lib/closure.c

61

closure_put_after_sub(cl, atomic_sub_return_release(v, &cl->remaining));

lib/closure.c

68

void closure_put(struct closure *cl)

lib/closure.c

70

closure_put_after_sub(cl, atomic_dec_return_release(&cl->remaining));

lib/closure.c

80

struct closure *cl, *t;

lib/closure.c

89

llist_for_each_entry_safe(cl, t, reverse, list) {

lib/closure.c

90

closure_set_waiting(cl, 0);

lib/closure.c

91

closure_sub(cl, CLOSURE_WAITING + 1);

net/9p/trans_rdma.c

501

struct sockaddr_in cl = {

net/9p/trans_rdma.c

508

cl.sin_port = htons((ushort)port);

net/9p/trans_rdma.c

509

err = rdma_bind_addr(rdma->cm_id, (struct sockaddr *)&cl);

net/bluetooth/bnep/sock.c

102

if (copy_from_user(&cl, argp, sizeof(cl)))

net/bluetooth/bnep/sock.c

105

if (cl.cnum <= 0)

net/bluetooth/bnep/sock.c

108

err = bnep_get_connlist(&cl);

net/bluetooth/bnep/sock.c

109

if (!err && copy_to_user(argp, &cl, sizeof(cl)))

net/bluetooth/bnep/sock.c

147

struct bnep_connlist_req cl;

net/bluetooth/bnep/sock.c

152

if (get_user(cl.cnum, p) || get_user(uci, p + 1))

net/bluetooth/bnep/sock.c

155

cl.ci = compat_ptr(uci);

net/bluetooth/bnep/sock.c

157

if (cl.cnum <= 0)

net/bluetooth/bnep/sock.c

160

err = bnep_get_connlist(&cl);

net/bluetooth/bnep/sock.c

162

if (!err && put_user(cl.cnum, p))

net/bluetooth/bnep/sock.c

55

struct bnep_connlist_req cl;

net/bluetooth/cmtp/sock.c

113

if (copy_from_user(&cl, argp, sizeof(cl)))

net/bluetooth/cmtp/sock.c

116

if (cl.cnum <= 0)

net/bluetooth/cmtp/sock.c

119

err = cmtp_get_connlist(&cl);

net/bluetooth/cmtp/sock.c

120

if (!err && copy_to_user(argp, &cl, sizeof(cl)))

net/bluetooth/cmtp/sock.c

149

struct cmtp_connlist_req cl;

net/bluetooth/cmtp/sock.c

154

if (get_user(cl.cnum, p) || get_user(uci, p + 1))

net/bluetooth/cmtp/sock.c

157

cl.ci = compat_ptr(uci);

net/bluetooth/cmtp/sock.c

159

if (cl.cnum <= 0)

net/bluetooth/cmtp/sock.c

162

err = cmtp_get_connlist(&cl);

net/bluetooth/cmtp/sock.c

164

if (!err && put_user(cl.cnum, p))

net/bluetooth/cmtp/sock.c

70

struct cmtp_connlist_req cl;

net/bluetooth/hci_conn.c

2680

struct hci_conn_list_req req, *cl;

net/bluetooth/hci_conn.c

2693

cl = kmalloc(size, GFP_KERNEL);

net/bluetooth/hci_conn.c

2694

if (!cl)

net/bluetooth/hci_conn.c

2699

kfree(cl);

net/bluetooth/hci_conn.c

2703

ci = cl->conn_info;

net/bluetooth/hci_conn.c

2718

cl->dev_id = hdev->id;

net/bluetooth/hci_conn.c

2719

cl->conn_num = n;

net/bluetooth/hci_conn.c

2724

err = copy_to_user(arg, cl, size);

net/bluetooth/hci_conn.c

2725

kfree(cl);

net/bluetooth/hidp/sock.c

100

if (copy_from_user(&cl, argp, sizeof(cl)))

net/bluetooth/hidp/sock.c

103

if (cl.cnum <= 0)

net/bluetooth/hidp/sock.c

106

err = hidp_get_connlist(&cl);

net/bluetooth/hidp/sock.c

107

if (!err && copy_to_user(argp, &cl, sizeof(cl)))

net/bluetooth/hidp/sock.c

154

struct hidp_connlist_req cl;

net/bluetooth/hidp/sock.c

158

if (get_user(cl.cnum, p) || get_user(uci, p + 1))

net/bluetooth/hidp/sock.c

161

cl.ci = compat_ptr(uci);

net/bluetooth/hidp/sock.c

163

if (cl.cnum <= 0)

net/bluetooth/hidp/sock.c

166

err = hidp_get_connlist(&cl);

net/bluetooth/hidp/sock.c

168

if (!err && put_user(cl.cnum, p))

net/bluetooth/hidp/sock.c

54

struct hidp_connlist_req cl;

net/ceph/mon_client.c

1161

int ceph_monc_init(struct ceph_mon_client *monc, struct ceph_client *cl)

net/ceph/mon_client.c

1167

monc->client = cl;

net/ceph/mon_client.c

1176

monc->auth = ceph_auth_init(cl->options->name, cl->options->key,

net/ceph/mon_client.c

1177

cl->options->con_modes);

net/core/flow_dissector.c

328

struct nf_conn_labels *cl;

net/core/flow_dissector.c

358

cl = nf_ct_labels_find(ct);

net/core/flow_dissector.c

359

if (cl)

net/core/flow_dissector.c

360

memcpy(key->ct_labels, cl->bits, sizeof(key->ct_labels));

net/netfilter/ipvs/ip_vs_wrr.c

116

mark->cl = list_entry(&svc->destinations, struct ip_vs_dest, n_list);

net/netfilter/ipvs/ip_vs_wrr.c

143

mark->cl = list_entry(&svc->destinations, struct ip_vs_dest, n_list);

net/netfilter/ipvs/ip_vs_wrr.c

169

dest = mark->cl;

net/netfilter/ipvs/ip_vs_wrr.c

217

mark->cl = dest;

net/netfilter/ipvs/ip_vs_wrr.c

224

mark->cl = dest;

net/netfilter/ipvs/ip_vs_wrr.c

230

mark->cl = dest;

net/netfilter/ipvs/ip_vs_wrr.c

60

struct ip_vs_dest *cl; /* current dest or head */

net/openvswitch/conntrack.c

171

struct nf_conn_labels *cl = NULL;

net/openvswitch/conntrack.c

176

cl = nf_ct_labels_find(ct);

net/openvswitch/conntrack.c

178

if (cl)

net/openvswitch/conntrack.c

179

memcpy(labels, cl->bits, OVS_CT_LABELS_LEN);

net/openvswitch/conntrack.c

366

struct nf_conn_labels *cl;

net/openvswitch/conntrack.c

368

cl = nf_ct_labels_find(ct);

net/openvswitch/conntrack.c

369

if (!cl) {

net/openvswitch/conntrack.c

371

cl = nf_ct_labels_find(ct);

net/openvswitch/conntrack.c

374

return cl;

net/openvswitch/conntrack.c

385

struct nf_conn_labels *cl, *master_cl;

net/openvswitch/conntrack.c

394

cl = ovs_ct_get_conn_labels(ct);

net/openvswitch/conntrack.c

395

if (!cl)

net/openvswitch/conntrack.c

400

*cl = *master_cl;

net/openvswitch/conntrack.c

403

u32 *dst = (u32 *)cl->bits;

net/openvswitch/conntrack.c

417

memcpy(&key->ct.labels, cl->bits, OVS_CT_LABELS_LEN);

net/openvswitch/conntrack.c

426

struct nf_conn_labels *cl;

net/openvswitch/conntrack.c

429

cl = ovs_ct_get_conn_labels(ct);

net/openvswitch/conntrack.c

430

if (!cl)

net/openvswitch/conntrack.c

439

memcpy(&key->ct.labels, cl->bits, OVS_CT_LABELS_LEN);

net/openvswitch/flow_netlink.c

1255

const struct ovs_key_ct_labels *cl;

net/openvswitch/flow_netlink.c

1257

cl = nla_data(a[OVS_KEY_ATTR_CT_LABELS]);

net/openvswitch/flow_netlink.c

1258

SW_FLOW_KEY_MEMCPY(match, ct.labels, cl->ct_labels,

net/openvswitch/flow_netlink.c

1259

sizeof(*cl), is_mask);

net/sched/cls_api.c

1255

static int __tcf_qdisc_cl_find(struct Qdisc *q, u32 parent, unsigned long *cl,

net/sched/cls_api.c

1265

*cl = cops->find(q, parent);

net/sched/cls_api.c

1266

if (*cl == 0) {

net/sched/cls_api.c

1276

unsigned long cl, int ifindex,

net/sched/cls_api.c

1291

block = cops->tcf_block(q, cl, extack);

net/sched/cls_api.c

1350

u32 *parent, unsigned long *cl,

net/sched/cls_api.c

1363

err = __tcf_qdisc_cl_find(*q, *parent, cl, ifindex, extack);

net/sched/cls_api.c

1367

block = __tcf_block_find(net, *q, *cl, ifindex, block_index, extack);

net/sched/cls_api.c

2253

unsigned long cl;

net/sched/cls_api.c

2274

cl = 0;

net/sched/cls_api.c

2316

err = __tcf_qdisc_cl_find(q, parent, &cl, t->tcm_ifindex, extack);

net/sched/cls_api.c

2320

block = __tcf_block_find(net, q, cl, t->tcm_ifindex, t->tcm_block_index,

net/sched/cls_api.c

2430

err = tp->ops->change(net, skb, tp, cl, t->tcm_handle, tca, &fh,

net/sched/cls_api.c

2488

unsigned long cl = 0;

net/sched/cls_api.c

2530

err = __tcf_qdisc_cl_find(q, parent, &cl, t->tcm_ifindex, extack);

net/sched/cls_api.c

2534

block = __tcf_block_find(net, q, cl, t->tcm_ifindex, t->tcm_block_index,

net/sched/cls_api.c

2647

unsigned long cl = 0;

net/sched/cls_api.c

2688

err = __tcf_qdisc_cl_find(q, parent, &cl, t->tcm_ifindex, extack);

net/sched/cls_api.c

2692

block = __tcf_block_find(net, q, cl, t->tcm_ifindex, t->tcm_block_index,

net/sched/cls_api.c

2887

unsigned long cl = 0;

net/sched/cls_api.c

2906

cl = cops->find(q, tcm->tcm_parent);

net/sched/cls_api.c

2907

if (cl == 0)

net/sched/cls_api.c

2910

block = cops->tcf_block(q, cl, NULL);

net/sched/cls_api.c

3124

unsigned long cl;

net/sched/cls_api.c

3136

cl = 0;

net/sched/cls_api.c

3138

block = tcf_block_find(net, &q, &parent, &cl,

net/sched/cls_api.c

3272

unsigned long cl = 0;

net/sched/cls_api.c

3291

cl = cops->find(q, tcm->tcm_parent);

net/sched/cls_api.c

3292

if (cl == 0)

net/sched/cls_api.c

3295

block = cops->tcf_block(q, cl, NULL);

net/sched/cls_basic.c

261

static void basic_bind_class(void *fh, u32 classid, unsigned long cl, void *q,

net/sched/cls_basic.c

266

tc_cls_bind_class(classid, cl, q, &f->res, base);

net/sched/cls_bpf.c

630

static void cls_bpf_bind_class(void *fh, u32 classid, unsigned long cl,

net/sched/cls_bpf.c

635

tc_cls_bind_class(classid, cl, q, &prog->res, base);

net/sched/cls_flower.c

3813

static void fl_bind_class(void *fh, u32 classid, unsigned long cl, void *q,

net/sched/cls_flower.c

3818

tc_cls_bind_class(classid, cl, q, &f->res, base);

net/sched/cls_fw.c

425

static void fw_bind_class(void *fh, u32 classid, unsigned long cl, void *q,

net/sched/cls_fw.c

430

tc_cls_bind_class(classid, cl, q, &f->res, base);

net/sched/cls_matchall.c

381

static void mall_bind_class(void *fh, u32 classid, unsigned long cl, void *q,

net/sched/cls_matchall.c

386

tc_cls_bind_class(classid, cl, q, &head->res, base);

net/sched/cls_route.c

653

static void route4_bind_class(void *fh, u32 classid, unsigned long cl, void *q,

net/sched/cls_route.c

658

tc_cls_bind_class(classid, cl, q, &f->res, base);

net/sched/cls_u32.c

1334

static void u32_bind_class(void *fh, u32 classid, unsigned long cl, void *q,

net/sched/cls_u32.c

1339

tc_cls_bind_class(classid, cl, q, &n->res, base);

net/sched/sch_api.c

1169

unsigned long cl;

net/sched/sch_api.c

1179

cl = cops->find(parent, classid);

net/sched/sch_api.c

1180

if (!cl) {

net/sched/sch_api.c

1196

err = cops->graft(parent, cl, new, &old, extack);

net/sched/sch_api.c

1418

static int check_loop_fn(struct Qdisc *q, unsigned long cl,

net/sched/sch_api.c

1437

check_loop_fn(struct Qdisc *q, unsigned long cl, struct qdisc_walker *w)

net/sched/sch_api.c

1443

leaf = cops->leaf(q, cl);

net/sched/sch_api.c

1943

unsigned long cl, u32 portid, u32 seq, u16 flags,

net/sched/sch_api.c

1966

if (cl_ops->dump && cl_ops->dump(q, cl, skb, tcm) < 0)

net/sched/sch_api.c

1973

if (cl_ops->dump_stats && cl_ops->dump_stats(q, cl, &d) < 0)

net/sched/sch_api.c

1995

unsigned long cl, int event, struct netlink_ext_ack *extack)

net/sched/sch_api.c

2007

if (tc_fill_tclass(skb, q, cl, portid, n->nlmsg_seq, 0, event, extack) < 0) {

net/sched/sch_api.c

2018

unsigned long cl, struct netlink_ext_ack *extack)

net/sched/sch_api.c

2027

if (tc_fill_tclass(skb, q, cl, portid, n->nlmsg_seq, 0, RTM_NEWTCLASS,

net/sched/sch_api.c

2040

struct Qdisc *q, unsigned long cl,

net/sched/sch_api.c

2055

if (tc_fill_tclass(skb, q, cl, portid, n->nlmsg_seq, 0,

net/sched/sch_api.c

2064

err = cops->delete(q, cl, extack);

net/sched/sch_api.c

2080

unsigned long cl;

net/sched/sch_api.c

2092

tp->ops->bind_class(n, a->classid, a->cl, q, a->base);

net/sched/sch_api.c

2105

static int tc_bind_class_walker(struct Qdisc *q, unsigned long cl,

net/sched/sch_api.c

2113

block = cops->tcf_block(q, cl, NULL);

net/sched/sch_api.c

2127

arg.base = cl;

net/sched/sch_api.c

2128

arg.cl = a->new_cl;

net/sched/sch_api.c

2169

unsigned long cl = 0;

net/sched/sch_api.c

2237

cl = cops->find(q, clid);

net/sched/sch_api.c

2239

if (cl == 0) {

net/sched/sch_api.c

2252

err = tclass_del_notify(net, cops, skb, n, q, cl, extack);

net/sched/sch_api.c

2257

err = tclass_get_notify(net, skb, n, q, cl, extack);

net/sched/sch_api.c

2276

new_cl = cl;

net/sched/sch_api.c

2283

if (cl != new_cl)

net/sched/sch_api.c

2321

static int qdisc_class_dump(struct Qdisc *q, unsigned long cl,

net/sched/sch_api.c

2326

return tc_fill_tclass(a->skb, q, cl, NETLINK_CB(a->cb->skb).portid,

net/sched/sch_api.c

342

unsigned long cl;

net/sched/sch_api.c

349

cl = cops->find(p, classid);

net/sched/sch_api.c

351

if (cl == 0) {

net/sched/sch_api.c

355

return cops->leaf(p, cl);

net/sched/sch_api.c

682

struct Qdisc_class_common *cl;

net/sched/sch_api.c

702

hlist_for_each_entry_safe(cl, next, &ohash[i], hnode) {

net/sched/sch_api.c

703

h = qdisc_class_hash(cl->classid, nmask);

net/sched/sch_api.c

704

hlist_add_head(&cl->hnode, &nhash[h]);

net/sched/sch_api.c

737

struct Qdisc_class_common *cl)

net/sched/sch_api.c

741

INIT_HLIST_NODE(&cl->hnode);

net/sched/sch_api.c

742

h = qdisc_class_hash(cl->classid, clhash->hashmask);

net/sched/sch_api.c

743

hlist_add_head(&cl->hnode, &clhash->hash[h]);

net/sched/sch_api.c

749

struct Qdisc_class_common *cl)

net/sched/sch_api.c

751

hlist_del(&cl->hnode);

net/sched/sch_api.c

779

unsigned long cl;

net/sched/sch_api.c

805

cl = cops->find(sch, parentid);

net/sched/sch_api.c

806

cops->qlen_notify(sch, cl);

net/sched/sch_cake.c

3094

static void cake_unbind(struct Qdisc *q, unsigned long cl)

net/sched/sch_cake.c

3098

static struct tcf_block *cake_tcf_block(struct Qdisc *sch, unsigned long cl,

net/sched/sch_cake.c

3103

if (cl)

net/sched/sch_cake.c

3108

static int cake_dump_class(struct Qdisc *sch, unsigned long cl,

net/sched/sch_cake.c

3111

tcm->tcm_handle |= TC_H_MIN(cl);

net/sched/sch_cake.c

3115

static int cake_dump_class_stats(struct Qdisc *sch, unsigned long cl,

net/sched/sch_cake.c

3122

u32 idx = cl - 1;

net/sched/sch_cake.c

3317

static int cake_mq_graft(struct Qdisc *sch, unsigned long cl, struct Qdisc *new,

net/sched/sch_cbs.c

478

static int cbs_dump_class(struct Qdisc *sch, unsigned long cl,

net/sched/sch_cbs.c

483

if (cl != 1 || !q->qdisc) /* only one class */

net/sched/sch_drr.c

102

cl->quantum = quantum;

net/sched/sch_drr.c

108

cl = kzalloc_obj(struct drr_class);

net/sched/sch_drr.c

109

if (cl == NULL)

net/sched/sch_drr.c

112

gnet_stats_basic_sync_init(&cl->bstats);

net/sched/sch_drr.c

113

INIT_LIST_HEAD(&cl->alist);

net/sched/sch_drr.c

114

cl->common.classid = classid;

net/sched/sch_drr.c

115

cl->quantum = quantum;

net/sched/sch_drr.c

116

cl->qdisc = qdisc_create_dflt(sch->dev_queue,

net/sched/sch_drr.c

119

if (cl->qdisc == NULL)

net/sched/sch_drr.c

120

cl->qdisc = &noop_qdisc;

net/sched/sch_drr.c

122

qdisc_hash_add(cl->qdisc, true);

net/sched/sch_drr.c

125

err = gen_replace_estimator(&cl->bstats, NULL, &cl->rate_est,

net/sched/sch_drr.c

129

qdisc_put(cl->qdisc);

net/sched/sch_drr.c

130

kfree(cl);

net/sched/sch_drr.c

136

qdisc_class_hash_insert(&q->clhash, &cl->common);

net/sched/sch_drr.c

141

*arg = (unsigned long)cl;

net/sched/sch_drr.c

145

static void drr_destroy_class(struct Qdisc *sch, struct drr_class *cl)

net/sched/sch_drr.c

147

gen_kill_estimator(&cl->rate_est);

net/sched/sch_drr.c

148

qdisc_put(cl->qdisc);

net/sched/sch_drr.c

149

kfree(cl);

net/sched/sch_drr.c

156

struct drr_class *cl = (struct drr_class *)arg;

net/sched/sch_drr.c

158

if (qdisc_class_in_use(&cl->common)) {

net/sched/sch_drr.c

165

qdisc_purge_queue(cl->qdisc);

net/sched/sch_drr.c

166

qdisc_class_hash_remove(&q->clhash, &cl->common);

net/sched/sch_drr.c

170

drr_destroy_class(sch, cl);

net/sched/sch_drr.c

179

static struct tcf_block *drr_tcf_block(struct Qdisc *sch, unsigned long cl,

net/sched/sch_drr.c

184

if (cl) {

net/sched/sch_drr.c

195

struct drr_class *cl = drr_find_class(sch, classid);

net/sched/sch_drr.c

197

if (cl)

net/sched/sch_drr.c

198

qdisc_class_get(&cl->common);

net/sched/sch_drr.c

200

return (unsigned long)cl;

net/sched/sch_drr.c

205

struct drr_class *cl = (struct drr_class *)arg;

net/sched/sch_drr.c

207

qdisc_class_put(&cl->common);

net/sched/sch_drr.c

214

struct drr_class *cl = (struct drr_class *)arg;

net/sched/sch_drr.c

218

cl->common.classid, NULL);

net/sched/sch_drr.c

223

*old = qdisc_replace(sch, new, &cl->qdisc);

net/sched/sch_drr.c

229

struct drr_class *cl = (struct drr_class *)arg;

net/sched/sch_drr.c

231

return cl->qdisc;

net/sched/sch_drr.c

236

struct drr_class *cl = (struct drr_class *)arg;

net/sched/sch_drr.c

238

list_del_init(&cl->alist);

net/sched/sch_drr.c

244

struct drr_class *cl = (struct drr_class *)arg;

net/sched/sch_drr.c

248

tcm->tcm_handle = cl->common.classid;

net/sched/sch_drr.c

249

tcm->tcm_info = cl->qdisc->handle;

net/sched/sch_drr.c

254

if (nla_put_u32(skb, TCA_DRR_QUANTUM, cl->quantum))

net/sched/sch_drr.c

266

struct drr_class *cl = (struct drr_class *)arg;

net/sched/sch_drr.c

267

__u32 qlen = qdisc_qlen_sum(cl->qdisc);

net/sched/sch_drr.c

268

struct Qdisc *cl_q = cl->qdisc;

net/sched/sch_drr.c

273

xstats.deficit = cl->deficit;

net/sched/sch_drr.c

275

if (gnet_stats_copy_basic(d, NULL, &cl->bstats, true) < 0 ||

net/sched/sch_drr.c

276

gnet_stats_copy_rate_est(d, &cl->rate_est) < 0 ||

net/sched/sch_drr.c

286

struct drr_class *cl;

net/sched/sch_drr.c

293

hlist_for_each_entry(cl, &q->clhash.hash[i], common.hnode) {

net/sched/sch_drr.c

294

if (!tc_qdisc_stats_dump(sch, (unsigned long)cl, arg))

net/sched/sch_drr.c

304

struct drr_class *cl;

net/sched/sch_drr.c

310

cl = drr_find_class(sch, skb->priority);

net/sched/sch_drr.c

311

if (cl != NULL)

net/sched/sch_drr.c

312

return cl;

net/sched/sch_drr.c

330

cl = (struct drr_class *)res.class;

net/sched/sch_drr.c

331

if (cl == NULL)

net/sched/sch_drr.c

332

cl = drr_find_class(sch, res.classid);

net/sched/sch_drr.c

333

return cl;

net/sched/sch_drr.c

343

struct drr_class *cl;

net/sched/sch_drr.c

346

cl = drr_classify(skb, sch, &err);

net/sched/sch_drr.c

347

if (cl == NULL) {

net/sched/sch_drr.c

354

err = qdisc_enqueue(skb, cl->qdisc, to_free);

net/sched/sch_drr.c

357

cl->qstats.drops++;

net/sched/sch_drr.c

363

if (!cl_is_active(cl)) {

net/sched/sch_drr.c

364

list_add_tail(&cl->alist, &q->active);

net/sched/sch_drr.c

365

cl->deficit = cl->quantum;

net/sched/sch_drr.c

376

struct drr_class *cl;

net/sched/sch_drr.c

38

static bool cl_is_active(struct drr_class *cl)

net/sched/sch_drr.c

383

cl = list_first_entry(&q->active, struct drr_class, alist);

net/sched/sch_drr.c

384

skb = cl->qdisc->ops->peek(cl->qdisc);

net/sched/sch_drr.c

386

qdisc_warn_nonwc(__func__, cl->qdisc);

net/sched/sch_drr.c

391

if (len <= cl->deficit) {

net/sched/sch_drr.c

392

cl->deficit -= len;

net/sched/sch_drr.c

393

skb = qdisc_dequeue_peeked(cl->qdisc);

net/sched/sch_drr.c

396

if (cl->qdisc->q.qlen == 0)

net/sched/sch_drr.c

397

list_del_init(&cl->alist);

net/sched/sch_drr.c

399

bstats_update(&cl->bstats, skb);

net/sched/sch_drr.c

40

return !list_empty(&cl->alist);

net/sched/sch_drr.c

406

cl->deficit += cl->quantum;

net/sched/sch_drr.c

407

list_move_tail(&cl->alist, &q->active);

net/sched/sch_drr.c

432

struct drr_class *cl;

net/sched/sch_drr.c

436

hlist_for_each_entry(cl, &q->clhash.hash[i], common.hnode) {

net/sched/sch_drr.c

437

if (cl->qdisc->q.qlen)

net/sched/sch_drr.c

438

list_del_init(&cl->alist);

net/sched/sch_drr.c

439

qdisc_reset(cl->qdisc);

net/sched/sch_drr.c

447

struct drr_class *cl;

net/sched/sch_drr.c

454

hlist_for_each_entry_safe(cl, next, &q->clhash.hash[i],

net/sched/sch_drr.c

456

drr_destroy_class(sch, cl);

net/sched/sch_drr.c

63

struct drr_class *cl = (struct drr_class *)*arg;

net/sched/sch_drr.c

88

if (cl != NULL) {

net/sched/sch_drr.c

90

err = gen_replace_estimator(&cl->bstats, NULL,

net/sched/sch_drr.c

91

&cl->rate_est,

net/sched/sch_dualpi2.c

1095

static void dualpi2_unbind(struct Qdisc *q, unsigned long cl)

net/sched/sch_dualpi2.c

1099

static struct tcf_block *dualpi2_tcf_block(struct Qdisc *sch, unsigned long cl,

net/sched/sch_dualpi2.c

1104

if (cl)

net/sched/sch_ets.c

104

static u32 ets_class_id(struct Qdisc *sch, const struct ets_class *cl)

net/sched/sch_ets.c

107

int band = cl - q->classes;

net/sched/sch_ets.c

201

static bool ets_class_is_strict(struct ets_sched *q, const struct ets_class *cl)

net/sched/sch_ets.c

203

unsigned int band = cl - q->classes;

net/sched/sch_ets.c

212

struct ets_class *cl = ets_class_from_arg(sch, *arg);

net/sched/sch_ets.c

222

if (!cl) {

net/sched/sch_ets.c

240

if (ets_class_is_strict(q, cl)) {

net/sched/sch_ets.c

251

cl->quantum = quantum;

net/sched/sch_ets.c

262

struct ets_class *cl = ets_class_from_arg(sch, arg);

net/sched/sch_ets.c

266

ets_class_id(sch, cl), NULL);

net/sched/sch_ets.c

273

*old = qdisc_replace(sch, new, &cl->qdisc);

net/sched/sch_ets.c

280

struct ets_class *cl = ets_class_from_arg(sch, arg);

net/sched/sch_ets.c

282

return cl->qdisc;

net/sched/sch_ets.c

297

struct ets_class *cl = ets_class_from_arg(sch, arg);

net/sched/sch_ets.c

304

if (!ets_class_is_strict(q, cl) && sch->q.qlen)

net/sched/sch_ets.c

305

list_del_init(&cl->alist);

net/sched/sch_ets.c

311

struct ets_class *cl = ets_class_from_arg(sch, arg);

net/sched/sch_ets.c

316

tcm->tcm_handle = ets_class_id(sch, cl);

net/sched/sch_ets.c

317

tcm->tcm_info = cl->qdisc->handle;

net/sched/sch_ets.c

322

if (!ets_class_is_strict(q, cl)) {

net/sched/sch_ets.c

323

if (nla_put_u32(skb, TCA_ETS_QUANTA_BAND, cl->quantum))

net/sched/sch_ets.c

336

struct ets_class *cl = ets_class_from_arg(sch, arg);

net/sched/sch_ets.c

337

struct Qdisc *cl_q = cl->qdisc;

net/sched/sch_ets.c

361

ets_qdisc_tcf_block(struct Qdisc *sch, unsigned long cl,

net/sched/sch_ets.c

366

if (cl) {

net/sched/sch_ets.c

426

struct ets_class *cl;

net/sched/sch_ets.c

429

cl = ets_classify(skb, sch, &err);

net/sched/sch_ets.c

430

if (!cl) {

net/sched/sch_ets.c

437

err = qdisc_enqueue(skb, cl->qdisc, to_free);

net/sched/sch_ets.c

440

cl->qstats.drops++;

net/sched/sch_ets.c

446

if (!cl_is_active(cl) && !ets_class_is_strict(q, cl)) {

net/sched/sch_ets.c

447

list_add_tail(&cl->alist, &q->active);

net/sched/sch_ets.c

448

cl->deficit = cl->quantum;

net/sched/sch_ets.c

468

struct ets_class *cl;

net/sched/sch_ets.c

475

cl = &q->classes[band];

net/sched/sch_ets.c

476

skb = qdisc_dequeue_peeked(cl->qdisc);

net/sched/sch_ets.c

484

cl = list_first_entry(&q->active, struct ets_class, alist);

net/sched/sch_ets.c

485

skb = cl->qdisc->ops->peek(cl->qdisc);

net/sched/sch_ets.c

487

qdisc_warn_nonwc(__func__, cl->qdisc);

net/sched/sch_ets.c

492

if (len <= cl->deficit) {

net/sched/sch_ets.c

493

cl->deficit -= len;

net/sched/sch_ets.c

494

skb = qdisc_dequeue_peeked(cl->qdisc);

net/sched/sch_ets.c

497

if (cl->qdisc->q.qlen == 0)

net/sched/sch_ets.c

498

list_del_init(&cl->alist);

net/sched/sch_ets.c

502

cl->deficit += cl->quantum;

net/sched/sch_ets.c

503

list_move_tail(&cl->alist, &q->active);

net/sched/sch_ets.c

77

static bool cl_is_active(struct ets_class *cl)

net/sched/sch_ets.c

79

return !list_empty(&cl->alist);

net/sched/sch_fq_codel.c

623

static void fq_codel_unbind(struct Qdisc *q, unsigned long cl)

net/sched/sch_fq_codel.c

627

static struct tcf_block *fq_codel_tcf_block(struct Qdisc *sch, unsigned long cl,

net/sched/sch_fq_codel.c

632

if (cl)

net/sched/sch_fq_codel.c

637

static int fq_codel_dump_class(struct Qdisc *sch, unsigned long cl,

net/sched/sch_fq_codel.c

640

tcm->tcm_handle |= TC_H_MIN(cl);

net/sched/sch_fq_codel.c

644

static int fq_codel_dump_class_stats(struct Qdisc *sch, unsigned long cl,

net/sched/sch_fq_codel.c

648

u32 idx = cl - 1;

net/sched/sch_hfsc.c

1000

update_vf(cl, 0, cur_time);

net/sched/sch_hfsc.c

1002

init_vf(cl, len);

net/sched/sch_hfsc.c

1028

cl = kzalloc_obj(struct hfsc_class);

net/sched/sch_hfsc.c

1029

if (cl == NULL)

net/sched/sch_hfsc.c

1032

RB_CLEAR_NODE(&cl->el_node);

net/sched/sch_hfsc.c

1034

err = tcf_block_get(&cl->block, &cl->filter_list, sch, extack);

net/sched/sch_hfsc.c

1036

kfree(cl);

net/sched/sch_hfsc.c

1041

err = gen_new_estimator(&cl->bstats, NULL, &cl->rate_est,

net/sched/sch_hfsc.c

1044

tcf_block_put(cl->block);

net/sched/sch_hfsc.c

1045

kfree(cl);

net/sched/sch_hfsc.c

1051

hfsc_change_rsc(cl, rsc, 0);

net/sched/sch_hfsc.c

1053

hfsc_change_fsc(cl, fsc);

net/sched/sch_hfsc.c

1055

hfsc_change_usc(cl, usc, 0);

net/sched/sch_hfsc.c

1057

cl->cl_common.classid = classid;

net/sched/sch_hfsc.c

1058

cl->sched = q;

net/sched/sch_hfsc.c

1059

cl->cl_parent = parent;

net/sched/sch_hfsc.c

1060

cl->qdisc = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops,

net/sched/sch_hfsc.c

1062

if (cl->qdisc == NULL)

net/sched/sch_hfsc.c

1063

cl->qdisc = &noop_qdisc;

net/sched/sch_hfsc.c

1065

qdisc_hash_add(cl->qdisc, true);

net/sched/sch_hfsc.c

1066

INIT_LIST_HEAD(&cl->children);

net/sched/sch_hfsc.c

1067

cl->vt_tree = RB_ROOT;

net/sched/sch_hfsc.c

1068

cl->cf_tree = RB_ROOT;

net/sched/sch_hfsc.c

1077

qdisc_class_hash_insert(&q->clhash, &cl->cl_common);

net/sched/sch_hfsc.c

1078

list_add_tail(&cl->siblings, &parent->children);

net/sched/sch_hfsc.c

1086

*arg = (unsigned long)cl;

net/sched/sch_hfsc.c

1091

hfsc_destroy_class(struct Qdisc *sch, struct hfsc_class *cl)

net/sched/sch_hfsc.c

1095

tcf_block_put(cl->block);

net/sched/sch_hfsc.c

1096

qdisc_put(cl->qdisc);

net/sched/sch_hfsc.c

1097

gen_kill_estimator(&cl->rate_est);

net/sched/sch_hfsc.c

1098

if (cl != &q->root)

net/sched/sch_hfsc.c

1099

kfree(cl);

net/sched/sch_hfsc.c

1107

struct hfsc_class *cl = (struct hfsc_class *)arg;

net/sched/sch_hfsc.c

1109

if (cl->level > 0 || qdisc_class_in_use(&cl->cl_common) ||

net/sched/sch_hfsc.c

1110

cl == &q->root) {

net/sched/sch_hfsc.c

1117

list_del(&cl->siblings);

net/sched/sch_hfsc.c

1118

hfsc_adjust_levels(cl->cl_parent);

net/sched/sch_hfsc.c

1120

qdisc_purge_queue(cl->qdisc);

net/sched/sch_hfsc.c

1121

qdisc_class_hash_remove(&q->clhash, &cl->cl_common);

net/sched/sch_hfsc.c

1125

hfsc_destroy_class(sch, cl);

net/sched/sch_hfsc.c

1133

struct hfsc_class *head, *cl;

net/sched/sch_hfsc.c

1139

(cl = hfsc_find_class(skb->priority, sch)) != NULL)

net/sched/sch_hfsc.c

1140

if (cl->level == 0)

net/sched/sch_hfsc.c

1141

return cl;

net/sched/sch_hfsc.c

1158

cl = (struct hfsc_class *)res.class;

net/sched/sch_hfsc.c

1159

if (!cl) {

net/sched/sch_hfsc.c

1160

cl = hfsc_find_class(res.classid, sch);

net/sched/sch_hfsc.c

1161

if (!cl)

net/sched/sch_hfsc.c

1163

if (cl->level >= head->level)

net/sched/sch_hfsc.c

1167

if (cl->level == 0)

net/sched/sch_hfsc.c

1168

return cl; /* hit leaf class */

net/sched/sch_hfsc.c

1171

tcf = rcu_dereference_bh(cl->filter_list);

net/sched/sch_hfsc.c

1172

head = cl;

net/sched/sch_hfsc.c

1176

cl = hfsc_find_class(TC_H_MAKE(TC_H_MAJ(sch->handle),

net/sched/sch_hfsc.c

1178

if (cl == NULL || cl->level > 0)

net/sched/sch_hfsc.c

1181

return cl;

net/sched/sch_hfsc.c

1188

struct hfsc_class *cl = (struct hfsc_class *)arg;

net/sched/sch_hfsc.c

1190

if (cl->level > 0)

net/sched/sch_hfsc.c

1194

cl->cl_common.classid, NULL);

net/sched/sch_hfsc.c

1199

*old = qdisc_replace(sch, new, &cl->qdisc);

net/sched/sch_hfsc.c

1206

struct hfsc_class *cl = (struct hfsc_class *)arg;

net/sched/sch_hfsc.c

1208

if (cl->level == 0)

net/sched/sch_hfsc.c

1209

return cl->qdisc;

net/sched/sch_hfsc.c

1217

struct hfsc_class *cl = (struct hfsc_class *)arg;

net/sched/sch_hfsc.c

1222

if (cl->cl_nactive)

net/sched/sch_hfsc.c

1223

update_vf(cl, 0, 0);

net/sched/sch_hfsc.c

1224

if (cl->cl_flags & HFSC_RSC)

net/sched/sch_hfsc.c

1225

eltree_remove(cl);

net/sched/sch_hfsc.c

1238

struct hfsc_class *cl = hfsc_find_class(classid, sch);

net/sched/sch_hfsc.c

1240

if (cl != NULL) {

net/sched/sch_hfsc.c

1241

if (p != NULL && p->level <= cl->level)

net/sched/sch_hfsc.c

1243

qdisc_class_get(&cl->cl_common);

net/sched/sch_hfsc.c

1246

return (unsigned long)cl;

net/sched/sch_hfsc.c

1252

struct hfsc_class *cl = (struct hfsc_class *)arg;

net/sched/sch_hfsc.c

1254

qdisc_class_put(&cl->cl_common);

net/sched/sch_hfsc.c

1261

struct hfsc_class *cl = (struct hfsc_class *)arg;

net/sched/sch_hfsc.c

1263

if (cl == NULL)

net/sched/sch_hfsc.c

1264

cl = &q->root;

net/sched/sch_hfsc.c

1266

return cl->block;

net/sched/sch_hfsc.c

1287

hfsc_dump_curves(struct sk_buff *skb, struct hfsc_class *cl)

net/sched/sch_hfsc.c

1289

if ((cl->cl_flags & HFSC_RSC) &&

net/sched/sch_hfsc.c

1290

(hfsc_dump_sc(skb, TCA_HFSC_RSC, &cl->cl_rsc) < 0))

net/sched/sch_hfsc.c

1293

if ((cl->cl_flags & HFSC_FSC) &&

net/sched/sch_hfsc.c

1294

(hfsc_dump_sc(skb, TCA_HFSC_FSC, &cl->cl_fsc) < 0))

net/sched/sch_hfsc.c

1297

if ((cl->cl_flags & HFSC_USC) &&

net/sched/sch_hfsc.c

1298

(hfsc_dump_sc(skb, TCA_HFSC_USC, &cl->cl_usc) < 0))

net/sched/sch_hfsc.c

1311

struct hfsc_class *cl = (struct hfsc_class *)arg;

net/sched/sch_hfsc.c

1314

tcm->tcm_parent = cl->cl_parent ? cl->cl_parent->cl_common.classid :

net/sched/sch_hfsc.c

1316

tcm->tcm_handle = cl->cl_common.classid;

net/sched/sch_hfsc.c

1317

if (cl->level == 0)

net/sched/sch_hfsc.c

1318

tcm->tcm_info = cl->qdisc->handle;

net/sched/sch_hfsc.c

1323

if (hfsc_dump_curves(skb, cl) < 0)

net/sched/sch_hfsc.c

1336

struct hfsc_class *cl = (struct hfsc_class *)arg;

net/sched/sch_hfsc.c

1340

qdisc_qstats_qlen_backlog(cl->qdisc, &qlen, &cl->qstats.backlog);

net/sched/sch_hfsc.c

1341

xstats.level = cl->level;

net/sched/sch_hfsc.c

1342

xstats.period = cl->cl_vtperiod;

net/sched/sch_hfsc.c

1343

xstats.work = cl->cl_total;

net/sched/sch_hfsc.c

1344

xstats.rtwork = cl->cl_cumul;

net/sched/sch_hfsc.c

1346

if (gnet_stats_copy_basic(d, NULL, &cl->bstats, true) < 0 ||

net/sched/sch_hfsc.c

1347

gnet_stats_copy_rate_est(d, &cl->rate_est) < 0 ||

net/sched/sch_hfsc.c

1348

gnet_stats_copy_queue(d, NULL, &cl->qstats, qlen) < 0)

net/sched/sch_hfsc.c

1360

struct hfsc_class *cl;

net/sched/sch_hfsc.c

1367

hlist_for_each_entry(cl, &q->clhash.hash[i],

net/sched/sch_hfsc.c

1369

if (!tc_qdisc_stats_dump(sch, (unsigned long)cl, arg))

net/sched/sch_hfsc.c

1379

struct hfsc_class *cl;

net/sched/sch_hfsc.c

1382

cl = eltree_get_minel(q);

net/sched/sch_hfsc.c

1383

if (cl)

net/sched/sch_hfsc.c

1384

next_time = cl->cl_e;

net/sched/sch_hfsc.c

1453

hfsc_reset_class(struct hfsc_class *cl)

net/sched/sch_hfsc.c

1455

cl->cl_total = 0;

net/sched/sch_hfsc.c

1456

cl->cl_cumul = 0;

net/sched/sch_hfsc.c

1457

cl->cl_d = 0;

net/sched/sch_hfsc.c

1458

cl->cl_e = 0;

net/sched/sch_hfsc.c

1459

cl->cl_vt = 0;

net/sched/sch_hfsc.c

1460

cl->cl_vtadj = 0;

net/sched/sch_hfsc.c

1461

cl->cl_cvtmin = 0;

net/sched/sch_hfsc.c

1462

cl->cl_cvtoff = 0;

net/sched/sch_hfsc.c

1463

cl->cl_vtperiod = 0;

net/sched/sch_hfsc.c

1464

cl->cl_parentperiod = 0;

net/sched/sch_hfsc.c

1465

cl->cl_f = 0;

net/sched/sch_hfsc.c

1466

cl->cl_myf = 0;

net/sched/sch_hfsc.c

1467

cl->cl_cfmin = 0;

net/sched/sch_hfsc.c

1468

cl->cl_nactive = 0;

net/sched/sch_hfsc.c

1470

cl->vt_tree = RB_ROOT;

net/sched/sch_hfsc.c

1471

cl->cf_tree = RB_ROOT;

net/sched/sch_hfsc.c

1472

qdisc_reset(cl->qdisc);

net/sched/sch_hfsc.c

1474

if (cl->cl_flags & HFSC_RSC)

net/sched/sch_hfsc.c

1475

rtsc_init(&cl->cl_deadline, &cl->cl_rsc, 0, 0);

net/sched/sch_hfsc.c

1476

if (cl->cl_flags & HFSC_FSC)

net/sched/sch_hfsc.c

1477

rtsc_init(&cl->cl_virtual, &cl->cl_fsc, 0, 0);

net/sched/sch_hfsc.c

1478

if (cl->cl_flags & HFSC_USC)

net/sched/sch_hfsc.c

1479

rtsc_init(&cl->cl_ulimit, &cl->cl_usc, 0, 0);

net/sched/sch_hfsc.c

1486

struct hfsc_class *cl;

net/sched/sch_hfsc.c

1490

hlist_for_each_entry(cl, &q->clhash.hash[i], cl_common.hnode)

net/sched/sch_hfsc.c

1491

hfsc_reset_class(cl);

net/sched/sch_hfsc.c

1502

struct hfsc_class *cl;

net/sched/sch_hfsc.c

1506

hlist_for_each_entry(cl, &q->clhash.hash[i], cl_common.hnode) {

net/sched/sch_hfsc.c

1507

tcf_block_put(cl->block);

net/sched/sch_hfsc.c

1508

cl->block = NULL;

net/sched/sch_hfsc.c

1512

hlist_for_each_entry_safe(cl, next, &q->clhash.hash[i],

net/sched/sch_hfsc.c

1514

hfsc_destroy_class(sch, cl);

net/sched/sch_hfsc.c

1541

struct hfsc_class *cl;

net/sched/sch_hfsc.c

1545

cl = hfsc_classify(skb, sch, &err);

net/sched/sch_hfsc.c

1546

if (cl == NULL) {

net/sched/sch_hfsc.c

1553

first = !cl->qdisc->q.qlen;

net/sched/sch_hfsc.c

1554

err = qdisc_enqueue(skb, cl->qdisc, to_free);

net/sched/sch_hfsc.c

1557

cl->qstats.drops++;

net/sched/sch_hfsc.c

1566

if (first && !cl_in_el_or_vttree(cl)) {

net/sched/sch_hfsc.c

1567

if (cl->cl_flags & HFSC_RSC)

net/sched/sch_hfsc.c

1568

init_ed(cl, len);

net/sched/sch_hfsc.c

1569

if (cl->cl_flags & HFSC_FSC)

net/sched/sch_hfsc.c

1570

init_vf(cl, len);

net/sched/sch_hfsc.c

1576

if (cl->cl_flags & HFSC_RSC)

net/sched/sch_hfsc.c

1577

cl->qdisc->ops->peek(cl->qdisc);

net/sched/sch_hfsc.c

1588

struct hfsc_class *cl;

net/sched/sch_hfsc.c

1604

cl = eltree_get_mindl(q, cur_time);

net/sched/sch_hfsc.c

1605

if (cl) {

net/sched/sch_hfsc.c

1612

cl = vttree_get_minvt(&q->root, cur_time);

net/sched/sch_hfsc.c

1613

if (cl == NULL) {

net/sched/sch_hfsc.c

1620

skb = qdisc_dequeue_peeked(cl->qdisc);

net/sched/sch_hfsc.c

1622

qdisc_warn_nonwc("HFSC", cl->qdisc);

net/sched/sch_hfsc.c

1626

bstats_update(&cl->bstats, skb);

net/sched/sch_hfsc.c

1627

update_vf(cl, qdisc_pkt_len(skb), cur_time);

net/sched/sch_hfsc.c

1629

cl->cl_cumul += qdisc_pkt_len(skb);

net/sched/sch_hfsc.c

1631

if (cl->cl_flags & HFSC_RSC) {

net/sched/sch_hfsc.c

1632

if (cl->qdisc->q.qlen != 0) {

net/sched/sch_hfsc.c

1634

next_len = qdisc_peek_len(cl->qdisc);

net/sched/sch_hfsc.c

1639

if (cl->qdisc->q.qlen != 0) {

net/sched/sch_hfsc.c

1641

update_ed(cl, next_len);

net/sched/sch_hfsc.c

1643

update_d(cl, next_len);

net/sched/sch_hfsc.c

1647

eltree_remove(cl);

net/sched/sch_hfsc.c

178

static bool cl_in_el_or_vttree(struct hfsc_class *cl)

net/sched/sch_hfsc.c

180

return ((cl->cl_flags & HFSC_FSC) && cl->cl_nactive) ||

net/sched/sch_hfsc.c

181

((cl->cl_flags & HFSC_RSC) && !RB_EMPTY_NODE(&cl->el_node));

net/sched/sch_hfsc.c

190

eltree_insert(struct hfsc_class *cl)

net/sched/sch_hfsc.c

192

struct rb_node **p = &cl->sched->eligible.rb_node;

net/sched/sch_hfsc.c

199

if (cl->cl_e >= cl1->cl_e)

net/sched/sch_hfsc.c

204

rb_link_node(&cl->el_node, parent, p);

net/sched/sch_hfsc.c

205

rb_insert_color(&cl->el_node, &cl->sched->eligible);

net/sched/sch_hfsc.c

209

eltree_remove(struct hfsc_class *cl)

net/sched/sch_hfsc.c

211

if (!RB_EMPTY_NODE(&cl->el_node)) {

net/sched/sch_hfsc.c

212

rb_erase(&cl->el_node, &cl->sched->eligible);

net/sched/sch_hfsc.c

213

RB_CLEAR_NODE(&cl->el_node);

net/sched/sch_hfsc.c

218

eltree_update(struct hfsc_class *cl)

net/sched/sch_hfsc.c

220

eltree_remove(cl);

net/sched/sch_hfsc.c

221

eltree_insert(cl);

net/sched/sch_hfsc.c

228

struct hfsc_class *p, *cl = NULL;

net/sched/sch_hfsc.c

235

if (cl == NULL || p->cl_d < cl->cl_d)

net/sched/sch_hfsc.c

236

cl = p;

net/sched/sch_hfsc.c

238

return cl;

net/sched/sch_hfsc.c

258

vttree_insert(struct hfsc_class *cl)

net/sched/sch_hfsc.c

260

struct rb_node **p = &cl->cl_parent->vt_tree.rb_node;

net/sched/sch_hfsc.c

267

if (cl->cl_vt >= cl1->cl_vt)

net/sched/sch_hfsc.c

272

rb_link_node(&cl->vt_node, parent, p);

net/sched/sch_hfsc.c

273

rb_insert_color(&cl->vt_node, &cl->cl_parent->vt_tree);

net/sched/sch_hfsc.c

277

vttree_remove(struct hfsc_class *cl)

net/sched/sch_hfsc.c

279

rb_erase(&cl->vt_node, &cl->cl_parent->vt_tree);

net/sched/sch_hfsc.c

283

vttree_update(struct hfsc_class *cl)

net/sched/sch_hfsc.c

285

vttree_remove(cl);

net/sched/sch_hfsc.c

286

vttree_insert(cl);

net/sched/sch_hfsc.c

290

vttree_firstfit(struct hfsc_class *cl, u64 cur_time)

net/sched/sch_hfsc.c

295

for (n = rb_first(&cl->vt_tree); n != NULL; n = rb_next(n)) {

net/sched/sch_hfsc.c

307

vttree_get_minvt(struct hfsc_class *cl, u64 cur_time)

net/sched/sch_hfsc.c

310

if (cl->cl_cfmin > cur_time)

net/sched/sch_hfsc.c

313

while (cl->level > 0) {

net/sched/sch_hfsc.c

314

cl = vttree_firstfit(cl, cur_time);

net/sched/sch_hfsc.c

315

if (cl == NULL)

net/sched/sch_hfsc.c

320

if (cl->cl_parent->cl_cvtmin < cl->cl_vt)

net/sched/sch_hfsc.c

321

cl->cl_parent->cl_cvtmin = cl->cl_vt;

net/sched/sch_hfsc.c

323

return cl;

net/sched/sch_hfsc.c

327

cftree_insert(struct hfsc_class *cl)

net/sched/sch_hfsc.c

329

struct rb_node **p = &cl->cl_parent->cf_tree.rb_node;

net/sched/sch_hfsc.c

336

if (cl->cl_f >= cl1->cl_f)

net/sched/sch_hfsc.c

341

rb_link_node(&cl->cf_node, parent, p);

net/sched/sch_hfsc.c

342

rb_insert_color(&cl->cf_node, &cl->cl_parent->cf_tree);

net/sched/sch_hfsc.c

346

cftree_remove(struct hfsc_class *cl)

net/sched/sch_hfsc.c

348

rb_erase(&cl->cf_node, &cl->cl_parent->cf_tree);

net/sched/sch_hfsc.c

352

cftree_update(struct hfsc_class *cl)

net/sched/sch_hfsc.c

354

cftree_remove(cl);

net/sched/sch_hfsc.c

355

cftree_insert(cl);

net/sched/sch_hfsc.c

617

init_ed(struct hfsc_class *cl, unsigned int next_len)

net/sched/sch_hfsc.c

622

rtsc_min(&cl->cl_deadline, &cl->cl_rsc, cur_time, cl->cl_cumul);

net/sched/sch_hfsc.c

629

cl->cl_eligible = cl->cl_deadline;

net/sched/sch_hfsc.c

630

if (cl->cl_rsc.sm1 <= cl->cl_rsc.sm2) {

net/sched/sch_hfsc.c

631

cl->cl_eligible.dx = 0;

net/sched/sch_hfsc.c

632

cl->cl_eligible.dy = 0;

net/sched/sch_hfsc.c

636

cl->cl_e = rtsc_y2x(&cl->cl_eligible, cl->cl_cumul);

net/sched/sch_hfsc.c

637

cl->cl_d = rtsc_y2x(&cl->cl_deadline, cl->cl_cumul + next_len);

net/sched/sch_hfsc.c

639

eltree_insert(cl);

net/sched/sch_hfsc.c

643

update_ed(struct hfsc_class *cl, unsigned int next_len)

net/sched/sch_hfsc.c

645

cl->cl_e = rtsc_y2x(&cl->cl_eligible, cl->cl_cumul);

net/sched/sch_hfsc.c

646

cl->cl_d = rtsc_y2x(&cl->cl_deadline, cl->cl_cumul + next_len);

net/sched/sch_hfsc.c

648

eltree_update(cl);

net/sched/sch_hfsc.c

652

update_d(struct hfsc_class *cl, unsigned int next_len)

net/sched/sch_hfsc.c

654

cl->cl_d = rtsc_y2x(&cl->cl_deadline, cl->cl_cumul + next_len);

net/sched/sch_hfsc.c

658

update_cfmin(struct hfsc_class *cl)

net/sched/sch_hfsc.c

660

struct rb_node *n = rb_first(&cl->cf_tree);

net/sched/sch_hfsc.c

664

cl->cl_cfmin = 0;

net/sched/sch_hfsc.c

668

cl->cl_cfmin = p->cl_f;

net/sched/sch_hfsc.c

672

init_vf(struct hfsc_class *cl, unsigned int len)

net/sched/sch_hfsc.c

681

for (; cl->cl_parent != NULL; cl = cl->cl_parent) {

net/sched/sch_hfsc.c

682

if (go_active && cl->cl_nactive++ == 0)

net/sched/sch_hfsc.c

688

n = rb_last(&cl->cl_parent->vt_tree);

net/sched/sch_hfsc.c

697

if (cl->cl_parent->cl_cvtmin != 0)

net/sched/sch_hfsc.c

698

vt = (cl->cl_parent->cl_cvtmin + vt)/2;

net/sched/sch_hfsc.c

700

if (cl->cl_parent->cl_vtperiod !=

net/sched/sch_hfsc.c

701

cl->cl_parentperiod || vt > cl->cl_vt)

net/sched/sch_hfsc.c

702

cl->cl_vt = vt;

net/sched/sch_hfsc.c

710

cl->cl_vt = cl->cl_parent->cl_cvtoff;

net/sched/sch_hfsc.c

711

cl->cl_parent->cl_cvtmin = 0;

net/sched/sch_hfsc.c

715

rtsc_min(&cl->cl_virtual, &cl->cl_fsc, cl->cl_vt, cl->cl_total);

net/sched/sch_hfsc.c

716

cl->cl_vtadj = 0;

net/sched/sch_hfsc.c

718

cl->cl_vtperiod++; /* increment vt period */

net/sched/sch_hfsc.c

719

cl->cl_parentperiod = cl->cl_parent->cl_vtperiod;

net/sched/sch_hfsc.c

720

if (cl->cl_parent->cl_nactive == 0)

net/sched/sch_hfsc.c

721

cl->cl_parentperiod++;

net/sched/sch_hfsc.c

722

cl->cl_f = 0;

net/sched/sch_hfsc.c

724

vttree_insert(cl);

net/sched/sch_hfsc.c

725

cftree_insert(cl);

net/sched/sch_hfsc.c

727

if (cl->cl_flags & HFSC_USC) {

net/sched/sch_hfsc.c

733

rtsc_min(&cl->cl_ulimit, &cl->cl_usc, cur_time,

net/sched/sch_hfsc.c

734

cl->cl_total);

net/sched/sch_hfsc.c

736

cl->cl_myf = rtsc_y2x(&cl->cl_ulimit,

net/sched/sch_hfsc.c

737

cl->cl_total);

net/sched/sch_hfsc.c

741

f = max(cl->cl_myf, cl->cl_cfmin);

net/sched/sch_hfsc.c

742

if (f != cl->cl_f) {

net/sched/sch_hfsc.c

743

cl->cl_f = f;

net/sched/sch_hfsc.c

744

cftree_update(cl);

net/sched/sch_hfsc.c

746

update_cfmin(cl->cl_parent);

net/sched/sch_hfsc.c

751

update_vf(struct hfsc_class *cl, unsigned int len, u64 cur_time)

net/sched/sch_hfsc.c

756

if (cl->qdisc->q.qlen == 0 && cl->cl_flags & HFSC_FSC)

net/sched/sch_hfsc.c

759

for (; cl->cl_parent != NULL; cl = cl->cl_parent) {

net/sched/sch_hfsc.c

760

cl->cl_total += len;

net/sched/sch_hfsc.c

762

if (!(cl->cl_flags & HFSC_FSC) || cl->cl_nactive == 0)

net/sched/sch_hfsc.c

765

if (go_passive && --cl->cl_nactive == 0)

net/sched/sch_hfsc.c

771

cl->cl_vt = rtsc_y2x(&cl->cl_virtual, cl->cl_total) + cl->cl_vtadj;

net/sched/sch_hfsc.c

778

if (cl->cl_vt < cl->cl_parent->cl_cvtmin) {

net/sched/sch_hfsc.c

779

cl->cl_vtadj += cl->cl_parent->cl_cvtmin - cl->cl_vt;

net/sched/sch_hfsc.c

780

cl->cl_vt = cl->cl_parent->cl_cvtmin;

net/sched/sch_hfsc.c

787

if (cl->cl_vt > cl->cl_parent->cl_cvtoff)

net/sched/sch_hfsc.c

788

cl->cl_parent->cl_cvtoff = cl->cl_vt;

net/sched/sch_hfsc.c

791

vttree_remove(cl);

net/sched/sch_hfsc.c

793

cftree_remove(cl);

net/sched/sch_hfsc.c

794

update_cfmin(cl->cl_parent);

net/sched/sch_hfsc.c

800

vttree_update(cl);

net/sched/sch_hfsc.c

803

if (cl->cl_flags & HFSC_USC) {

net/sched/sch_hfsc.c

804

cl->cl_myf = rtsc_y2x(&cl->cl_ulimit, cl->cl_total);

net/sched/sch_hfsc.c

806

cl->cl_myf = cl->cl_myfadj + rtsc_y2x(&cl->cl_ulimit,

net/sched/sch_hfsc.c

807

cl->cl_total);

net/sched/sch_hfsc.c

821

if (cl->cl_myf < myf_bound) {

net/sched/sch_hfsc.c

822

delta = cur_time - cl->cl_myf;

net/sched/sch_hfsc.c

823

cl->cl_myfadj += delta;

net/sched/sch_hfsc.c

824

cl->cl_myf += delta;

net/sched/sch_hfsc.c

829

f = max(cl->cl_myf, cl->cl_cfmin);

net/sched/sch_hfsc.c

830

if (f != cl->cl_f) {

net/sched/sch_hfsc.c

831

cl->cl_f = f;

net/sched/sch_hfsc.c

832

cftree_update(cl);

net/sched/sch_hfsc.c

833

update_cfmin(cl->cl_parent);

net/sched/sch_hfsc.c

839

hfsc_adjust_levels(struct hfsc_class *cl)

net/sched/sch_hfsc.c

846

list_for_each_entry(p, &cl->children, siblings) {

net/sched/sch_hfsc.c

850

cl->level = level;

net/sched/sch_hfsc.c

851

} while ((cl = cl->cl_parent) != NULL);

net/sched/sch_hfsc.c

867

hfsc_change_rsc(struct hfsc_class *cl, struct tc_service_curve *rsc,

net/sched/sch_hfsc.c

870

sc2isc(rsc, &cl->cl_rsc);

net/sched/sch_hfsc.c

871

rtsc_init(&cl->cl_deadline, &cl->cl_rsc, cur_time, cl->cl_cumul);

net/sched/sch_hfsc.c

872

cl->cl_eligible = cl->cl_deadline;

net/sched/sch_hfsc.c

873

if (cl->cl_rsc.sm1 <= cl->cl_rsc.sm2) {

net/sched/sch_hfsc.c

874

cl->cl_eligible.dx = 0;

net/sched/sch_hfsc.c

875

cl->cl_eligible.dy = 0;

net/sched/sch_hfsc.c

877

cl->cl_flags |= HFSC_RSC;

net/sched/sch_hfsc.c

881

hfsc_change_fsc(struct hfsc_class *cl, struct tc_service_curve *fsc)

net/sched/sch_hfsc.c

883

sc2isc(fsc, &cl->cl_fsc);

net/sched/sch_hfsc.c

884

rtsc_init(&cl->cl_virtual, &cl->cl_fsc, cl->cl_vt, cl->cl_total);

net/sched/sch_hfsc.c

885

cl->cl_flags |= HFSC_FSC;

net/sched/sch_hfsc.c

889

hfsc_change_usc(struct hfsc_class *cl, struct tc_service_curve *usc,

net/sched/sch_hfsc.c

892

sc2isc(usc, &cl->cl_usc);

net/sched/sch_hfsc.c

893

rtsc_init(&cl->cl_ulimit, &cl->cl_usc, cur_time, cl->cl_total);

net/sched/sch_hfsc.c

894

cl->cl_flags |= HFSC_USC;

net/sched/sch_hfsc.c

898

hfsc_upgrade_rt(struct hfsc_class *cl)

net/sched/sch_hfsc.c

900

cl->cl_fsc = cl->cl_rsc;

net/sched/sch_hfsc.c

901

rtsc_init(&cl->cl_virtual, &cl->cl_fsc, cl->cl_vt, cl->cl_total);

net/sched/sch_hfsc.c

902

cl->cl_flags |= HFSC_FSC;

net/sched/sch_hfsc.c

917

struct hfsc_class *cl = (struct hfsc_class *)*arg;

net/sched/sch_hfsc.c

951

if (cl != NULL) {

net/sched/sch_hfsc.c

956

if (cl->cl_parent &&

net/sched/sch_hfsc.c

957

cl->cl_parent->cl_common.classid != parentid)

net/sched/sch_hfsc.c

959

if (cl->cl_parent == NULL && parentid != TC_H_ROOT)

net/sched/sch_hfsc.c

965

err = gen_replace_estimator(&cl->bstats, NULL,

net/sched/sch_hfsc.c

966

&cl->rate_est,

net/sched/sch_hfsc.c

975

old_flags = cl->cl_flags;

net/sched/sch_hfsc.c

978

hfsc_change_rsc(cl, rsc, cur_time);

net/sched/sch_hfsc.c

980

hfsc_change_fsc(cl, fsc);

net/sched/sch_hfsc.c

982

hfsc_change_usc(cl, usc, cur_time);

net/sched/sch_hfsc.c

984

if (cl->qdisc->q.qlen != 0)

net/sched/sch_hfsc.c

985

len = qdisc_peek_len(cl->qdisc);

net/sched/sch_hfsc.c

990

if (cl->qdisc->q.qlen != 0) {

net/sched/sch_hfsc.c

991

if (cl->cl_flags & HFSC_RSC) {

net/sched/sch_hfsc.c

993

update_ed(cl, len);

net/sched/sch_hfsc.c

995

init_ed(cl, len);

net/sched/sch_hfsc.c

998

if (cl->cl_flags & HFSC_FSC) {

net/sched/sch_htb.c

1003

struct htb_class *cl;

net/sched/sch_htb.c

1007

hlist_for_each_entry(cl, &q->clhash.hash[i], common.hnode) {

net/sched/sch_htb.c

1008

if (cl->level)

net/sched/sch_htb.c

1009

memset(&cl->inner, 0, sizeof(cl->inner));

net/sched/sch_htb.c

1011

if (cl->leaf.q && !q->offload)

net/sched/sch_htb.c

1012

qdisc_reset(cl->leaf.q);

net/sched/sch_htb.c

1014

cl->prio_activity = 0;

net/sched/sch_htb.c

1015

cl->cmode = HTB_CAN_SEND;

net/sched/sch_htb.c

1245

struct htb_class *cl = (struct htb_class *)arg;

net/sched/sch_htb.c

1253

tcm->tcm_parent = cl->parent ? cl->parent->common.classid : TC_H_ROOT;

net/sched/sch_htb.c

1254

tcm->tcm_handle = cl->common.classid;

net/sched/sch_htb.c

1255

if (!cl->level && cl->leaf.q)

net/sched/sch_htb.c

1256

tcm->tcm_info = cl->leaf.q->handle;

net/sched/sch_htb.c

1264

psched_ratecfg_getrate(&opt.rate, &cl->rate);

net/sched/sch_htb.c

1265

opt.buffer = PSCHED_NS2TICKS(cl->buffer);

net/sched/sch_htb.c

1266

psched_ratecfg_getrate(&opt.ceil, &cl->ceil);

net/sched/sch_htb.c

1267

opt.cbuffer = PSCHED_NS2TICKS(cl->cbuffer);

net/sched/sch_htb.c

1268

opt.quantum = cl->quantum;

net/sched/sch_htb.c

1269

opt.prio = cl->prio;

net/sched/sch_htb.c

1270

opt.level = cl->level;

net/sched/sch_htb.c

1275

if ((cl->rate.rate_bytes_ps >= (1ULL << 32)) &&

net/sched/sch_htb.c

1276

nla_put_u64_64bit(skb, TCA_HTB_RATE64, cl->rate.rate_bytes_ps,

net/sched/sch_htb.c

1279

if ((cl->ceil.rate_bytes_ps >= (1ULL << 32)) &&

net/sched/sch_htb.c

1280

nla_put_u64_64bit(skb, TCA_HTB_CEIL64, cl->ceil.rate_bytes_ps,

net/sched/sch_htb.c

1292

struct htb_class *cl)

net/sched/sch_htb.c

1298

gnet_stats_basic_sync_init(&cl->bstats);

net/sched/sch_htb.c

1304

while (p && p->level < cl->level)

net/sched/sch_htb.c

1307

if (p != cl)

net/sched/sch_htb.c

1318

_bstats_update(&cl->bstats, bytes, packets);

net/sched/sch_htb.c

1324

struct htb_class *cl = (struct htb_class *)arg;

net/sched/sch_htb.c

1327

.drops = cl->drops,

net/sched/sch_htb.c

1328

.overlimits = cl->overlimits,

net/sched/sch_htb.c

1332

if (!cl->level && cl->leaf.q)

net/sched/sch_htb.c

1333

qdisc_qstats_qlen_backlog(cl->leaf.q, &qlen, &qs.backlog);

net/sched/sch_htb.c

1335

cl->xstats.tokens = clamp_t(s64, PSCHED_NS2TICKS(cl->tokens),

net/sched/sch_htb.c

1337

cl->xstats.ctokens = clamp_t(s64, PSCHED_NS2TICKS(cl->ctokens),

net/sched/sch_htb.c

1341

if (!cl->level) {

net/sched/sch_htb.c

1342

if (cl->leaf.q)

net/sched/sch_htb.c

1343

cl->bstats = cl->leaf.q->bstats;

net/sched/sch_htb.c

1345

gnet_stats_basic_sync_init(&cl->bstats);

net/sched/sch_htb.c

1346

_bstats_update(&cl->bstats,

net/sched/sch_htb.c

1347

u64_stats_read(&cl->bstats_bias.bytes),

net/sched/sch_htb.c

1348

u64_stats_read(&cl->bstats_bias.packets));

net/sched/sch_htb.c

1350

htb_offload_aggregate_stats(q, cl);

net/sched/sch_htb.c

1354

if (gnet_stats_copy_basic(d, NULL, &cl->bstats, true) < 0 ||

net/sched/sch_htb.c

1355

gnet_stats_copy_rate_est(d, &cl->rate_est) < 0 ||

net/sched/sch_htb.c

1359

return gnet_stats_copy_app(d, &cl->xstats, sizeof(cl->xstats));

net/sched/sch_htb.c

1400

static struct netdev_queue *htb_offload_get_queue(struct htb_class *cl)

net/sched/sch_htb.c

1404

queue = cl->leaf.offload_queue;

net/sched/sch_htb.c

1405

if (!(cl->leaf.q->flags & TCQ_F_BUILTIN))

net/sched/sch_htb.c

1406

WARN_ON(cl->leaf.q->dev_queue != queue);

net/sched/sch_htb.c

1447

struct htb_class *cl = (struct htb_class *)arg;

net/sched/sch_htb.c

1451

if (cl->level)

net/sched/sch_htb.c

1455

dev_queue = htb_offload_get_queue(cl);

net/sched/sch_htb.c

1459

cl->common.classid, extack);

net/sched/sch_htb.c

1470

*old = qdisc_replace(sch, new, &cl->leaf.q);

net/sched/sch_htb.c

1482

struct htb_class *cl = (struct htb_class *)arg;

net/sched/sch_htb.c

1483

return !cl->level ? cl->leaf.q : NULL;

net/sched/sch_htb.c

1488

struct htb_class *cl = (struct htb_class *)arg;

net/sched/sch_htb.c

1490

htb_deactivate(qdisc_priv(sch), cl);

net/sched/sch_htb.c

1493

static inline int htb_parent_last_child(struct htb_class *cl)

net/sched/sch_htb.c

1495

if (!cl->parent)

net/sched/sch_htb.c

1498

if (cl->parent->children > 1)

net/sched/sch_htb.c

1504

static void htb_parent_to_leaf(struct Qdisc *sch, struct htb_class *cl,

net/sched/sch_htb.c

1508

struct htb_class *parent = cl->parent;

net/sched/sch_htb.c

1510

WARN_ON(cl->level || !cl->leaf.q || cl->prio_activity);

net/sched/sch_htb.c

1524

parent->leaf.offload_queue = cl->leaf.offload_queue;

net/sched/sch_htb.c

1540

static int htb_destroy_class_offload(struct Qdisc *sch, struct htb_class *cl,

net/sched/sch_htb.c

1546

struct Qdisc *q = cl->leaf.q;

net/sched/sch_htb.c

1550

if (cl->level)

net/sched/sch_htb.c

1554

dev_queue = htb_offload_get_queue(cl);

net/sched/sch_htb.c

1567

if (cl->parent) {

net/sched/sch_htb.c

1568

_bstats_update(&cl->parent->bstats_bias,

net/sched/sch_htb.c

1577

.classid = cl->common.classid,

net/sched/sch_htb.c

1592

if (!err && offload_opt.classid != TC_H_MIN(cl->common.classid)) {

net/sched/sch_htb.c

1597

htb_offload_move_qdisc(sch, moved_cl, cl, destroying);

net/sched/sch_htb.c

1603

static void htb_destroy_class(struct Qdisc *sch, struct htb_class *cl)

net/sched/sch_htb.c

1605

if (!cl->level) {

net/sched/sch_htb.c

1606

WARN_ON(!cl->leaf.q);

net/sched/sch_htb.c

1607

qdisc_put(cl->leaf.q);

net/sched/sch_htb.c

1609

gen_kill_estimator(&cl->rate_est);

net/sched/sch_htb.c

1610

tcf_block_put(cl->block);

net/sched/sch_htb.c

1611

kfree(cl);

net/sched/sch_htb.c

1621

struct htb_class *cl;

net/sched/sch_htb.c

1634

hlist_for_each_entry(cl, &q->clhash.hash[i], common.hnode) {

net/sched/sch_htb.c

1635

tcf_block_put(cl->block);

net/sched/sch_htb.c

1636

cl->block = NULL;

net/sched/sch_htb.c

1644

hlist_for_each_entry_safe(cl, next, &q->clhash.hash[i],

net/sched/sch_htb.c

1649

htb_destroy_class(sch, cl);

net/sched/sch_htb.c

1655

if (cl->level)

net/sched/sch_htb.c

1660

last_child = htb_parent_last_child(cl);

net/sched/sch_htb.c

1661

htb_destroy_class_offload(sch, cl, last_child,

net/sched/sch_htb.c

1664

&cl->common);

net/sched/sch_htb.c

1665

if (cl->parent)

net/sched/sch_htb.c

1666

cl->parent->children--;

net/sched/sch_htb.c

1668

htb_parent_to_leaf(sch, cl, NULL);

net/sched/sch_htb.c

1669

htb_destroy_class(sch, cl);

net/sched/sch_htb.c

1696

struct htb_class *cl = (struct htb_class *)arg;

net/sched/sch_htb.c

1705

if (cl->children || qdisc_class_in_use(&cl->common)) {

net/sched/sch_htb.c

1710

if (!cl->level && htb_parent_last_child(cl))

net/sched/sch_htb.c

1714

err = htb_destroy_class_offload(sch, cl, last_child, false,

net/sched/sch_htb.c

1724

dev_queue = htb_offload_get_queue(cl);

net/sched/sch_htb.c

1727

cl->parent->common.classid,

net/sched/sch_htb.c

1735

if (!cl->level)

net/sched/sch_htb.c

1736

qdisc_purge_queue(cl->leaf.q);

net/sched/sch_htb.c

1739

qdisc_class_hash_remove(&q->clhash, &cl->common);

net/sched/sch_htb.c

1740

if (cl->parent)

net/sched/sch_htb.c

1741

cl->parent->children--;

net/sched/sch_htb.c

1743

htb_deactivate(q, cl);

net/sched/sch_htb.c

1745

if (cl->cmode != HTB_CAN_SEND)

net/sched/sch_htb.c

1746

htb_safe_rb_erase(&cl->pq_node,

net/sched/sch_htb.c

1747

&q->hlevel[cl->level].wait_pq);

net/sched/sch_htb.c

1750

htb_parent_to_leaf(sch, cl, new_q);

net/sched/sch_htb.c

1754

htb_destroy_class(sch, cl);

net/sched/sch_htb.c

1764

struct htb_class *cl = (struct htb_class *)*arg, *parent;

net/sched/sch_htb.c

1817

if (!cl) { /* new class */

net/sched/sch_htb.c

1847

cl = kzalloc_obj(*cl);

net/sched/sch_htb.c

1848

if (!cl)

net/sched/sch_htb.c

1851

gnet_stats_basic_sync_init(&cl->bstats);

net/sched/sch_htb.c

1852

gnet_stats_basic_sync_init(&cl->bstats_bias);

net/sched/sch_htb.c

1854

err = tcf_block_get(&cl->block, &cl->filter_list, sch, extack);

net/sched/sch_htb.c

1856

kfree(cl);

net/sched/sch_htb.c

1860

err = gen_new_estimator(&cl->bstats, NULL,

net/sched/sch_htb.c

1861

&cl->rate_est,

net/sched/sch_htb.c

1869

cl->children = 0;

net/sched/sch_htb.c

1870

RB_CLEAR_NODE(&cl->pq_node);

net/sched/sch_htb.c

1873

RB_CLEAR_NODE(&cl->node[prio]);

net/sched/sch_htb.c

1875

cl->common.classid = classid;

net/sched/sch_htb.c

1892

.classid = cl->common.classid,

net/sched/sch_htb.c

1915

.classid = cl->common.classid,

net/sched/sch_htb.c

1964

cl->leaf.q = new_q ? new_q : &noop_qdisc;

net/sched/sch_htb.c

1966

cl->leaf.offload_queue = dev_queue;

net/sched/sch_htb.c

1968

cl->parent = parent;

net/sched/sch_htb.c

1971

cl->tokens = PSCHED_TICKS2NS(hopt->buffer);

net/sched/sch_htb.c

1972

cl->ctokens = PSCHED_TICKS2NS(hopt->cbuffer);

net/sched/sch_htb.c

1973

cl->mbuffer = 60ULL * NSEC_PER_SEC; /* 1min */

net/sched/sch_htb.c

1974

cl->t_c = ktime_get_ns();

net/sched/sch_htb.c

1975

cl->cmode = HTB_CAN_SEND;

net/sched/sch_htb.c

1978

qdisc_class_hash_insert(&q->clhash, &cl->common);

net/sched/sch_htb.c

1981

if (cl->leaf.q != &noop_qdisc)

net/sched/sch_htb.c

1982

qdisc_hash_add(cl->leaf.q, true);

net/sched/sch_htb.c

1985

err = gen_replace_estimator(&cl->bstats, NULL,

net/sched/sch_htb.c

1986

&cl->rate_est,

net/sched/sch_htb.c

1999

.classid = cl->common.classid,

net/sched/sch_htb.c

2020

psched_ratecfg_precompute(&cl->rate, &hopt->rate, rate64);

net/sched/sch_htb.c

2021

psched_ratecfg_precompute(&cl->ceil, &hopt->ceil, ceil64);

net/sched/sch_htb.c

2026

if (!cl->level) {

net/sched/sch_htb.c

2027

u64 quantum = cl->rate.rate_bytes_ps;

net/sched/sch_htb.c

2030

cl->quantum = min_t(u64, quantum, INT_MAX);

net/sched/sch_htb.c

2032

if (!hopt->quantum && cl->quantum < 1000) {

net/sched/sch_htb.c

2034

cl->quantum = 1000;

net/sched/sch_htb.c

2036

if (!hopt->quantum && cl->quantum > 200000) {

net/sched/sch_htb.c

2038

cl->quantum = 200000;

net/sched/sch_htb.c

2041

cl->quantum = hopt->quantum;

net/sched/sch_htb.c

2042

if ((cl->prio = hopt->prio) >= TC_HTB_NUMPRIO)

net/sched/sch_htb.c

2043

cl->prio = TC_HTB_NUMPRIO - 1;

net/sched/sch_htb.c

2046

cl->buffer = PSCHED_TICKS2NS(hopt->buffer);

net/sched/sch_htb.c

2047

cl->cbuffer = PSCHED_TICKS2NS(hopt->cbuffer);

net/sched/sch_htb.c

2055

cl->common.classid, (warn == -1 ? "small" : "big"));

net/sched/sch_htb.c

2059

*arg = (unsigned long)cl;

net/sched/sch_htb.c

2063

gen_kill_estimator(&cl->rate_est);

net/sched/sch_htb.c

2065

tcf_block_put(cl->block);

net/sched/sch_htb.c

2066

kfree(cl);

net/sched/sch_htb.c

2075

struct htb_class *cl = (struct htb_class *)arg;

net/sched/sch_htb.c

2077

return cl ? cl->block : q->block;

net/sched/sch_htb.c

2083

struct htb_class *cl = htb_find(classid, sch);

net/sched/sch_htb.c

2094

if (cl)

net/sched/sch_htb.c

2095

qdisc_class_get(&cl->common);

net/sched/sch_htb.c

2096

return (unsigned long)cl;

net/sched/sch_htb.c

2101

struct htb_class *cl = (struct htb_class *)arg;

net/sched/sch_htb.c

2103

qdisc_class_put(&cl->common);

net/sched/sch_htb.c

2109

struct htb_class *cl;

net/sched/sch_htb.c

2116

hlist_for_each_entry(cl, &q->clhash.hash[i], common.hnode) {

net/sched/sch_htb.c

2117

if (!tc_qdisc_stats_dump(sch, (unsigned long)cl, arg))

net/sched/sch_htb.c

223

struct htb_class *cl;

net/sched/sch_htb.c

234

cl = htb_find(skb->priority, sch);

net/sched/sch_htb.c

235

if (cl) {

net/sched/sch_htb.c

236

if (cl->level == 0)

net/sched/sch_htb.c

237

return cl;

net/sched/sch_htb.c

239

tcf = rcu_dereference_bh(cl->filter_list);

net/sched/sch_htb.c

257

cl = (void *)res.class;

net/sched/sch_htb.c

258

if (!cl) {

net/sched/sch_htb.c

261

cl = htb_find(res.classid, sch);

net/sched/sch_htb.c

262

if (!cl)

net/sched/sch_htb.c

265

if (!cl->level)

net/sched/sch_htb.c

266

return cl; /* we hit leaf; return it */

net/sched/sch_htb.c

269

tcf = rcu_dereference_bh(cl->filter_list);

net/sched/sch_htb.c

272

cl = htb_find(TC_H_MAKE(TC_H_MAJ(sch->handle), q->defcls), sch);

net/sched/sch_htb.c

273

if (!cl || cl->level)

net/sched/sch_htb.c

275

return cl;

net/sched/sch_htb.c

288

struct htb_class *cl, int prio)

net/sched/sch_htb.c

297

if (cl->common.classid > c->common.classid)

net/sched/sch_htb.c

302

rb_link_node(&cl->node[prio], parent, p);

net/sched/sch_htb.c

303

rb_insert_color(&cl->node[prio], root);

net/sched/sch_htb.c

317

struct htb_class *cl, s64 delay)

net/sched/sch_htb.c

319

struct rb_node **p = &q->hlevel[cl->level].wait_pq.rb_node, *parent = NULL;

net/sched/sch_htb.c

321

cl->pq_key = q->now + delay;

net/sched/sch_htb.c

322

if (cl->pq_key == q->now)

net/sched/sch_htb.c

323

cl->pq_key++;

net/sched/sch_htb.c

326

if (q->near_ev_cache[cl->level] > cl->pq_key)

net/sched/sch_htb.c

327

q->near_ev_cache[cl->level] = cl->pq_key;

net/sched/sch_htb.c

333

if (cl->pq_key >= c->pq_key)

net/sched/sch_htb.c

338

rb_link_node(&cl->pq_node, parent, p);

net/sched/sch_htb.c

339

rb_insert_color(&cl->pq_node, &q->hlevel[cl->level].wait_pq);

net/sched/sch_htb.c

365

struct htb_class *cl, int mask)

net/sched/sch_htb.c

367

q->row_mask[cl->level] |= mask;

net/sched/sch_htb.c

371

htb_add_to_id_tree(&q->hlevel[cl->level].hprio[prio].row, cl, prio);

net/sched/sch_htb.c

397

struct htb_class *cl, int mask)

net/sched/sch_htb.c

400

struct htb_level *hlevel = &q->hlevel[cl->level];

net/sched/sch_htb.c

407

if (hprio->ptr == cl->node + prio)

net/sched/sch_htb.c

410

htb_safe_rb_erase(cl->node + prio, &hprio->row);

net/sched/sch_htb.c

414

q->row_mask[cl->level] &= ~m;

net/sched/sch_htb.c

426

static void htb_activate_prios(struct htb_sched *q, struct htb_class *cl)

net/sched/sch_htb.c

428

struct htb_class *p = cl->parent;

net/sched/sch_htb.c

429

long m, mask = cl->prio_activity;

net/sched/sch_htb.c

431

while (cl->cmode == HTB_MAY_BORROW && p && mask) {

net/sched/sch_htb.c

446

htb_add_to_id_tree(&p->inner.clprio[prio].feed, cl, prio);

net/sched/sch_htb.c

449

cl = p;

net/sched/sch_htb.c

450

p = cl->parent;

net/sched/sch_htb.c

453

if (cl->cmode == HTB_CAN_SEND && mask)

net/sched/sch_htb.c

454

htb_add_class_to_row(q, cl, mask);

net/sched/sch_htb.c

466

static void htb_deactivate_prios(struct htb_sched *q, struct htb_class *cl)

net/sched/sch_htb.c

468

struct htb_class *p = cl->parent;

net/sched/sch_htb.c

469

long m, mask = cl->prio_activity;

net/sched/sch_htb.c

471

while (cl->cmode == HTB_MAY_BORROW && p && mask) {

net/sched/sch_htb.c

478

if (p->inner.clprio[prio].ptr == cl->node + prio) {

net/sched/sch_htb.c

483

p->inner.clprio[prio].last_ptr_id = cl->common.classid;

net/sched/sch_htb.c

487

htb_safe_rb_erase(cl->node + prio,

net/sched/sch_htb.c

495

cl = p;

net/sched/sch_htb.c

496

p = cl->parent;

net/sched/sch_htb.c

499

if (cl->cmode == HTB_CAN_SEND && mask)

net/sched/sch_htb.c

500

htb_remove_class_from_row(q, cl, mask);

net/sched/sch_htb.c

503

static inline s64 htb_lowater(const struct htb_class *cl)

net/sched/sch_htb.c

506

return cl->cmode != HTB_CANT_SEND ? -cl->cbuffer : 0;

net/sched/sch_htb.c

510

static inline s64 htb_hiwater(const struct htb_class *cl)

net/sched/sch_htb.c

513

return cl->cmode == HTB_CAN_SEND ? -cl->buffer : 0;

net/sched/sch_htb.c

533

htb_class_mode(struct htb_class *cl, s64 *diff)

net/sched/sch_htb.c

537

if ((toks = (cl->ctokens + *diff)) < htb_lowater(cl)) {

net/sched/sch_htb.c

542

if ((toks = (cl->tokens + *diff)) >= htb_hiwater(cl))

net/sched/sch_htb.c

562

htb_change_class_mode(struct htb_sched *q, struct htb_class *cl, s64 *diff)

net/sched/sch_htb.c

564

enum htb_cmode new_mode = htb_class_mode(cl, diff);

net/sched/sch_htb.c

566

if (new_mode == cl->cmode)

net/sched/sch_htb.c

570

cl->overlimits++;

net/sched/sch_htb.c

574

if (cl->prio_activity) { /* not necessary: speed optimization */

net/sched/sch_htb.c

575

if (cl->cmode != HTB_CANT_SEND)

net/sched/sch_htb.c

576

htb_deactivate_prios(q, cl);

net/sched/sch_htb.c

577

cl->cmode = new_mode;

net/sched/sch_htb.c

579

htb_activate_prios(q, cl);

net/sched/sch_htb.c

581

cl->cmode = new_mode;

net/sched/sch_htb.c

593

static inline void htb_activate(struct htb_sched *q, struct htb_class *cl)

net/sched/sch_htb.c

595

WARN_ON(cl->level || !cl->leaf.q);

net/sched/sch_htb.c

597

if (!cl->prio_activity) {

net/sched/sch_htb.c

598

cl->prio_activity = 1 << cl->prio;

net/sched/sch_htb.c

599

htb_activate_prios(q, cl);

net/sched/sch_htb.c

611

static inline void htb_deactivate(struct htb_sched *q, struct htb_class *cl)

net/sched/sch_htb.c

613

if (!cl->prio_activity)

net/sched/sch_htb.c

615

htb_deactivate_prios(q, cl);

net/sched/sch_htb.c

616

cl->prio_activity = 0;

net/sched/sch_htb.c

625

struct htb_class *cl = htb_classify(skb, sch, &ret);

net/sched/sch_htb.c

627

if (cl == HTB_DIRECT) {

net/sched/sch_htb.c

636

} else if (!cl) {

net/sched/sch_htb.c

642

} else if ((ret = qdisc_enqueue(skb, cl->leaf.q,

net/sched/sch_htb.c

646

cl->drops++;

net/sched/sch_htb.c

650

htb_activate(q, cl);

net/sched/sch_htb.c

658

static inline void htb_accnt_tokens(struct htb_class *cl, int bytes, s64 diff)

net/sched/sch_htb.c

660

s64 toks = diff + cl->tokens;

net/sched/sch_htb.c

662

if (toks > cl->buffer)

net/sched/sch_htb.c

663

toks = cl->buffer;

net/sched/sch_htb.c

664

toks -= (s64) psched_l2t_ns(&cl->rate, bytes);

net/sched/sch_htb.c

665

if (toks <= -cl->mbuffer)

net/sched/sch_htb.c

666

toks = 1 - cl->mbuffer;

net/sched/sch_htb.c

668

cl->tokens = toks;

net/sched/sch_htb.c

671

static inline void htb_accnt_ctokens(struct htb_class *cl, int bytes, s64 diff)

net/sched/sch_htb.c

673

s64 toks = diff + cl->ctokens;

net/sched/sch_htb.c

675

if (toks > cl->cbuffer)

net/sched/sch_htb.c

676

toks = cl->cbuffer;

net/sched/sch_htb.c

677

toks -= (s64) psched_l2t_ns(&cl->ceil, bytes);

net/sched/sch_htb.c

678

if (toks <= -cl->mbuffer)

net/sched/sch_htb.c

679

toks = 1 - cl->mbuffer;

net/sched/sch_htb.c

681

cl->ctokens = toks;

net/sched/sch_htb.c

699

static void htb_charge_class(struct htb_sched *q, struct htb_class *cl,

net/sched/sch_htb.c

706

while (cl) {

net/sched/sch_htb.c

707

diff = min_t(s64, q->now - cl->t_c, cl->mbuffer);

net/sched/sch_htb.c

708

if (cl->level >= level) {

net/sched/sch_htb.c

709

if (cl->level == level)

net/sched/sch_htb.c

710

cl->xstats.lends++;

net/sched/sch_htb.c

711

htb_accnt_tokens(cl, bytes, diff);

net/sched/sch_htb.c

713

cl->xstats.borrows++;

net/sched/sch_htb.c

714

cl->tokens += diff; /* we moved t_c; update tokens */

net/sched/sch_htb.c

716

htb_accnt_ctokens(cl, bytes, diff);

net/sched/sch_htb.c

717

cl->t_c = q->now;

net/sched/sch_htb.c

719

old_mode = cl->cmode;

net/sched/sch_htb.c

721

htb_change_class_mode(q, cl, &diff);

net/sched/sch_htb.c

722

if (old_mode != cl->cmode) {

net/sched/sch_htb.c

724

htb_safe_rb_erase(&cl->pq_node, &q->hlevel[cl->level].wait_pq);

net/sched/sch_htb.c

725

if (cl->cmode != HTB_CAN_SEND)

net/sched/sch_htb.c

726

htb_add_to_wait_tree(q, cl, diff);

net/sched/sch_htb.c

730

if (cl->level)

net/sched/sch_htb.c

731

bstats_update(&cl->bstats, skb);

net/sched/sch_htb.c

733

cl = cl->parent;

net/sched/sch_htb.c

758

struct htb_class *cl;

net/sched/sch_htb.c

765

cl = rb_entry(p, struct htb_class, pq_node);

net/sched/sch_htb.c

766

if (cl->pq_key > q->now)

net/sched/sch_htb.c

767

return cl->pq_key;

net/sched/sch_htb.c

770

diff = min_t(s64, q->now - cl->t_c, cl->mbuffer);

net/sched/sch_htb.c

771

htb_change_class_mode(q, cl, &diff);

net/sched/sch_htb.c

772

if (cl->cmode != HTB_CAN_SEND)

net/sched/sch_htb.c

773

htb_add_to_wait_tree(q, cl, diff);

net/sched/sch_htb.c

793

struct htb_class *cl =

net/sched/sch_htb.c

796

if (id > cl->common.classid) {

net/sched/sch_htb.c

798

} else if (id < cl->common.classid) {

net/sched/sch_htb.c

855

struct htb_class *cl;

net/sched/sch_htb.c

858

cl = rb_entry(*sp->pptr, struct htb_class, node[prio]);

net/sched/sch_htb.c

859

if (!cl->level)

net/sched/sch_htb.c

860

return cl;

net/sched/sch_htb.c

861

clp = &cl->inner.clprio[prio];

net/sched/sch_htb.c

878

struct htb_class *cl, *start;

net/sched/sch_htb.c

883

start = cl = htb_lookup_leaf(hprio, prio);

net/sched/sch_htb.c

887

if (unlikely(!cl))

net/sched/sch_htb.c

895

if (unlikely(cl->leaf.q->q.qlen == 0)) {

net/sched/sch_htb.c

897

htb_deactivate(q, cl);

net/sched/sch_htb.c

905

if (cl == start) /* fix start if we just deleted it */

net/sched/sch_htb.c

907

cl = next;

net/sched/sch_htb.c

911

skb = cl->leaf.q->dequeue(cl->leaf.q);

net/sched/sch_htb.c

915

qdisc_warn_nonwc("htb", cl->leaf.q);

net/sched/sch_htb.c

916

htb_next_rb_node(level ? &cl->parent->inner.clprio[prio].ptr:

net/sched/sch_htb.c

918

cl = htb_lookup_leaf(hprio, prio);

net/sched/sch_htb.c

920

} while (cl != start);

net/sched/sch_htb.c

923

bstats_update(&cl->bstats, skb);

net/sched/sch_htb.c

924

cl->leaf.deficit[level] -= qdisc_pkt_len(skb);

net/sched/sch_htb.c

925

if (cl->leaf.deficit[level] < 0) {

net/sched/sch_htb.c

926

cl->leaf.deficit[level] += cl->quantum;

net/sched/sch_htb.c

927

htb_next_rb_node(level ? &cl->parent->inner.clprio[prio].ptr :

net/sched/sch_htb.c

933

if (!cl->leaf.q->q.qlen)

net/sched/sch_htb.c

934

htb_deactivate(q, cl);

net/sched/sch_htb.c

935

htb_charge_class(q, cl, level, skb);

net/sched/sch_ingress.c

200

static struct tcf_block *clsact_tcf_block(struct Qdisc *sch, unsigned long cl,

net/sched/sch_ingress.c

205

switch (cl) {

net/sched/sch_ingress.c

40

static void ingress_unbind_filter(struct Qdisc *sch, unsigned long cl)

net/sched/sch_ingress.c

48

static struct tcf_block *ingress_tcf_block(struct Qdisc *sch, unsigned long cl,

net/sched/sch_mq.c

179

static struct netdev_queue *mq_queue_get(struct Qdisc *sch, unsigned long cl)

net/sched/sch_mq.c

182

unsigned long ntx = cl - 1;

net/sched/sch_mq.c

196

static int mq_graft(struct Qdisc *sch, unsigned long cl, struct Qdisc *new,

net/sched/sch_mq.c

199

struct netdev_queue *dev_queue = mq_queue_get(sch, cl);

net/sched/sch_mq.c

213

graft_offload.graft_params.queue = cl - 1;

net/sched/sch_mq.c

222

struct Qdisc *mq_leaf(struct Qdisc *sch, unsigned long cl)

net/sched/sch_mq.c

224

struct netdev_queue *dev_queue = mq_queue_get(sch, cl);

net/sched/sch_mq.c

240

int mq_dump_class(struct Qdisc *sch, unsigned long cl,

net/sched/sch_mq.c

243

struct netdev_queue *dev_queue = mq_queue_get(sch, cl);

net/sched/sch_mq.c

246

tcm->tcm_handle |= TC_H_MIN(cl);

net/sched/sch_mq.c

252

int mq_dump_class_stats(struct Qdisc *sch, unsigned long cl,

net/sched/sch_mq.c

255

struct netdev_queue *dev_queue = mq_queue_get(sch, cl);

net/sched/sch_mqprio.c

452

unsigned long cl)

net/sched/sch_mqprio.c

455

unsigned long ntx = cl - 1;

net/sched/sch_mqprio.c

462

static int mqprio_graft(struct Qdisc *sch, unsigned long cl, struct Qdisc *new,

net/sched/sch_mqprio.c

466

struct netdev_queue *dev_queue = mqprio_queue_get(sch, cl);

net/sched/sch_mqprio.c

611

static struct Qdisc *mqprio_leaf(struct Qdisc *sch, unsigned long cl)

net/sched/sch_mqprio.c

613

struct netdev_queue *dev_queue = mqprio_queue_get(sch, cl);

net/sched/sch_mqprio.c

640

static int mqprio_dump_class(struct Qdisc *sch, unsigned long cl,

net/sched/sch_mqprio.c

643

if (cl < TC_H_MIN_PRIORITY) {

net/sched/sch_mqprio.c

644

struct netdev_queue *dev_queue = mqprio_queue_get(sch, cl);

net/sched/sch_mqprio.c

646

int tc = netdev_txq_to_tc(dev, cl - 1);

net/sched/sch_mqprio.c

656

tcm->tcm_handle |= TC_H_MIN(cl);

net/sched/sch_mqprio.c

660

static int mqprio_dump_class_stats(struct Qdisc *sch, unsigned long cl,

net/sched/sch_mqprio.c

665

if (cl >= TC_H_MIN_PRIORITY) {

net/sched/sch_mqprio.c

671

struct netdev_tc_txq tc = dev->tc_to_txq[cl & TC_BITMASK];

net/sched/sch_mqprio.c

705

struct netdev_queue *dev_queue = mqprio_queue_get(sch, cl);

net/sched/sch_multiq.c

319

static void multiq_unbind(struct Qdisc *q, unsigned long cl)

net/sched/sch_multiq.c

323

static int multiq_dump_class(struct Qdisc *sch, unsigned long cl,

net/sched/sch_multiq.c

328

tcm->tcm_handle |= TC_H_MIN(cl);

net/sched/sch_multiq.c

329

tcm->tcm_info = q->queues[cl - 1]->handle;

net/sched/sch_multiq.c

333

static int multiq_dump_class_stats(struct Qdisc *sch, unsigned long cl,

net/sched/sch_multiq.c

339

cl_q = q->queues[cl - 1];

net/sched/sch_multiq.c

361

static struct tcf_block *multiq_tcf_block(struct Qdisc *sch, unsigned long cl,

net/sched/sch_multiq.c

366

if (cl)

net/sched/sch_netem.c

1295

static int netem_dump_class(struct Qdisc *sch, unsigned long cl,

net/sched/sch_netem.c

1300

if (cl != 1 || !q->qdisc) /* only one class */

net/sched/sch_prio.c

341

static void prio_unbind(struct Qdisc *q, unsigned long cl)

net/sched/sch_prio.c

345

static int prio_dump_class(struct Qdisc *sch, unsigned long cl, struct sk_buff *skb,

net/sched/sch_prio.c

350

tcm->tcm_handle |= TC_H_MIN(cl);

net/sched/sch_prio.c

351

tcm->tcm_info = q->queues[cl-1]->handle;

net/sched/sch_prio.c

355

static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl,

net/sched/sch_prio.c

361

cl_q = q->queues[cl - 1];

net/sched/sch_prio.c

384

static struct tcf_block *prio_tcf_block(struct Qdisc *sch, unsigned long cl,

net/sched/sch_prio.c

389

if (cl)

net/sched/sch_qfq.c

1000

cl->deficit -= (int) len;

net/sched/sch_qfq.c

1002

if (cl->qdisc->q.qlen == 0) /* no more packets, remove from list */

net/sched/sch_qfq.c

1003

list_del_init(&cl->alist);

net/sched/sch_qfq.c

1004

else if (cl->deficit < qdisc_peek_len(cl->qdisc)) {

net/sched/sch_qfq.c

1005

cl->deficit += agg->lmax;

net/sched/sch_qfq.c

1006

list_move_tail(&cl->alist, &agg->active);

net/sched/sch_qfq.c

1013

struct qfq_class **cl,

net/sched/sch_qfq.c

1018

*cl = list_first_entry(&agg->active, struct qfq_class, alist);

net/sched/sch_qfq.c

1019

skb = (*cl)->qdisc->ops->peek((*cl)->qdisc);

net/sched/sch_qfq.c

1021

qdisc_warn_nonwc("qfq_dequeue", (*cl)->qdisc);

net/sched/sch_qfq.c

1104

struct qfq_class *cl;

net/sched/sch_qfq.c

1113

skb = qfq_peek_skb(in_serv_agg, &cl, &len);

net/sched/sch_qfq.c

1150

skb = qfq_peek_skb(in_serv_agg, &cl, &len);

net/sched/sch_qfq.c

1157

skb = agg_dequeue(in_serv_agg, cl, len);

net/sched/sch_qfq.c

1232

struct qfq_class *cl;

net/sched/sch_qfq.c

1236

cl = qfq_classify(skb, sch, &err);

net/sched/sch_qfq.c

1237

if (cl == NULL) {

net/sched/sch_qfq.c

1243

pr_debug("qfq_enqueue: cl = %x\n", cl->common.classid);

net/sched/sch_qfq.c

1245

if (unlikely(cl->agg->lmax < len)) {

net/sched/sch_qfq.c

1247

cl->agg->lmax, len, cl->common.classid);

net/sched/sch_qfq.c

1248

err = qfq_change_agg(sch, cl, cl->agg->class_weight, len);

net/sched/sch_qfq.c

1250

cl->qstats.drops++;

net/sched/sch_qfq.c

1256

err = qdisc_enqueue(skb, cl->qdisc, to_free);

net/sched/sch_qfq.c

1260

cl->qstats.drops++;

net/sched/sch_qfq.c

1266

_bstats_update(&cl->bstats, len, gso_segs);

net/sched/sch_qfq.c

1270

agg = cl->agg;

net/sched/sch_qfq.c

1272

if (cl_is_active(cl)) {

net/sched/sch_qfq.c

1273

if (unlikely(skb == cl->qdisc->ops->peek(cl->qdisc)) &&

net/sched/sch_qfq.c

1275

== cl && cl->deficit < len)

net/sched/sch_qfq.c

1276

list_move_tail(&cl->alist, &agg->active);

net/sched/sch_qfq.c

1282

cl->deficit = agg->lmax;

net/sched/sch_qfq.c

1283

list_add_tail(&cl->alist, &agg->active);

net/sched/sch_qfq.c

1285

if (list_first_entry(&agg->active, struct qfq_class, alist) != cl ||

net/sched/sch_qfq.c

1432

struct qfq_class *cl = (struct qfq_class *)arg;

net/sched/sch_qfq.c

1434

if (list_empty(&cl->alist))

net/sched/sch_qfq.c

1436

qfq_deactivate_class(q, cl);

net/sched/sch_qfq.c

1481

struct qfq_class *cl;

net/sched/sch_qfq.c

1485

hlist_for_each_entry(cl, &q->clhash.hash[i], common.hnode) {

net/sched/sch_qfq.c

1486

if (cl_is_active(cl))

net/sched/sch_qfq.c

1487

qfq_deactivate_class(q, cl);

net/sched/sch_qfq.c

1489

qdisc_reset(cl->qdisc);

net/sched/sch_qfq.c

1497

struct qfq_class *cl;

net/sched/sch_qfq.c

1504

hlist_for_each_entry_safe(cl, next, &q->clhash.hash[i],

net/sched/sch_qfq.c

1506

qfq_rm_from_agg(q, cl);

net/sched/sch_qfq.c

1507

qfq_destroy_class(sch, cl);

net/sched/sch_qfq.c

205

static bool cl_is_active(struct qfq_class *cl)

net/sched/sch_qfq.c

207

return !list_empty(&cl->alist);

net/sched/sch_qfq.c

322

struct qfq_class *cl)

net/sched/sch_qfq.c

324

cl->agg = agg;

net/sched/sch_qfq.c

327

if (cl->qdisc->q.qlen > 0) { /* adding an active class */

net/sched/sch_qfq.c

328

list_add_tail(&cl->alist, &agg->active);

net/sched/sch_qfq.c

330

cl && q->in_serv_agg != agg) /* agg was inactive */

net/sched/sch_qfq.c

350

static void qfq_deactivate_class(struct qfq_sched *q, struct qfq_class *cl)

net/sched/sch_qfq.c

352

struct qfq_aggregate *agg = cl->agg;

net/sched/sch_qfq.c

355

list_del_init(&cl->alist); /* remove from RR queue of the aggregate */

net/sched/sch_qfq.c

361

static void qfq_rm_from_agg(struct qfq_sched *q, struct qfq_class *cl)

net/sched/sch_qfq.c

363

struct qfq_aggregate *agg = cl->agg;

net/sched/sch_qfq.c

365

cl->agg = NULL;

net/sched/sch_qfq.c

374

static void qfq_deact_rm_from_agg(struct qfq_sched *q, struct qfq_class *cl)

net/sched/sch_qfq.c

376

if (cl_is_active(cl)) /* class is active */

net/sched/sch_qfq.c

377

qfq_deactivate_class(q, cl);

net/sched/sch_qfq.c

379

qfq_rm_from_agg(q, cl);

net/sched/sch_qfq.c

383

static int qfq_change_agg(struct Qdisc *sch, struct qfq_class *cl, u32 weight,

net/sched/sch_qfq.c

400

qfq_deact_rm_from_agg(q, cl);

net/sched/sch_qfq.c

401

qfq_add_to_agg(q, new_agg, cl);

net/sched/sch_qfq.c

411

struct qfq_class *cl = (struct qfq_class *)*arg;

net/sched/sch_qfq.c

446

if (cl != NULL) {

net/sched/sch_qfq.c

448

old_weight = cl->agg->class_weight;

net/sched/sch_qfq.c

449

old_lmax = cl->agg->lmax;

net/sched/sch_qfq.c

455

delta_w = weight - (cl ? old_weight : 0);

net/sched/sch_qfq.c

464

if (cl != NULL) { /* modify existing class */

net/sched/sch_qfq.c

466

err = gen_replace_estimator(&cl->bstats, NULL,

net/sched/sch_qfq.c

467

&cl->rate_est,

net/sched/sch_qfq.c

479

cl = kzalloc_obj(struct qfq_class);

net/sched/sch_qfq.c

480

if (cl == NULL)

net/sched/sch_qfq.c

483

gnet_stats_basic_sync_init(&cl->bstats);

net/sched/sch_qfq.c

484

cl->common.classid = classid;

net/sched/sch_qfq.c

485

cl->deficit = lmax;

net/sched/sch_qfq.c

486

INIT_LIST_HEAD(&cl->alist);

net/sched/sch_qfq.c

488

cl->qdisc = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops,

net/sched/sch_qfq.c

490

if (cl->qdisc == NULL)

net/sched/sch_qfq.c

491

cl->qdisc = &noop_qdisc;

net/sched/sch_qfq.c

494

err = gen_new_estimator(&cl->bstats, NULL,

net/sched/sch_qfq.c

495

&cl->rate_est,

net/sched/sch_qfq.c

503

if (cl->qdisc != &noop_qdisc)

net/sched/sch_qfq.c

504

qdisc_hash_add(cl->qdisc, true);

net/sched/sch_qfq.c

514

gen_kill_estimator(&cl->rate_est);

net/sched/sch_qfq.c

521

qfq_deact_rm_from_agg(q, cl);

net/sched/sch_qfq.c

523

qdisc_class_hash_insert(&q->clhash, &cl->common);

net/sched/sch_qfq.c

524

qfq_add_to_agg(q, new_agg, cl);

net/sched/sch_qfq.c

528

*arg = (unsigned long)cl;

net/sched/sch_qfq.c

533

qdisc_put(cl->qdisc);

net/sched/sch_qfq.c

534

kfree(cl);

net/sched/sch_qfq.c

539

static void qfq_destroy_class(struct Qdisc *sch, struct qfq_class *cl)

net/sched/sch_qfq.c

541

gen_kill_estimator(&cl->rate_est);

net/sched/sch_qfq.c

542

qdisc_put(cl->qdisc);

net/sched/sch_qfq.c

543

kfree(cl);

net/sched/sch_qfq.c

550

struct qfq_class *cl = (struct qfq_class *)arg;

net/sched/sch_qfq.c

552

if (qdisc_class_in_use(&cl->common)) {

net/sched/sch_qfq.c

559

qdisc_purge_queue(cl->qdisc);

net/sched/sch_qfq.c

560

qdisc_class_hash_remove(&q->clhash, &cl->common);

net/sched/sch_qfq.c

561

qfq_rm_from_agg(q, cl);

net/sched/sch_qfq.c

565

qfq_destroy_class(sch, cl);

net/sched/sch_qfq.c

574

static struct tcf_block *qfq_tcf_block(struct Qdisc *sch, unsigned long cl,

net/sched/sch_qfq.c

579

if (cl)

net/sched/sch_qfq.c

588

struct qfq_class *cl = qfq_find_class(sch, classid);

net/sched/sch_qfq.c

590

if (cl)

net/sched/sch_qfq.c

591

qdisc_class_get(&cl->common);

net/sched/sch_qfq.c

593

return (unsigned long)cl;

net/sched/sch_qfq.c

598

struct qfq_class *cl = (struct qfq_class *)arg;

net/sched/sch_qfq.c

600

qdisc_class_put(&cl->common);

net/sched/sch_qfq.c

607

struct qfq_class *cl = (struct qfq_class *)arg;

net/sched/sch_qfq.c

611

cl->common.classid, NULL);

net/sched/sch_qfq.c

616

*old = qdisc_replace(sch, new, &cl->qdisc);

net/sched/sch_qfq.c

622

struct qfq_class *cl = (struct qfq_class *)arg;

net/sched/sch_qfq.c

624

return cl->qdisc;

net/sched/sch_qfq.c

630

struct qfq_class *cl = (struct qfq_class *)arg;

net/sched/sch_qfq.c

635

tcm->tcm_handle = cl->common.classid;

net/sched/sch_qfq.c

636

tcm->tcm_info = cl->qdisc->handle;

net/sched/sch_qfq.c

643

class_weight = cl->agg->class_weight;

net/sched/sch_qfq.c

644

lmax = cl->agg->lmax;

net/sched/sch_qfq.c

659

struct qfq_class *cl = (struct qfq_class *)arg;

net/sched/sch_qfq.c

665

xstats.weight = cl->agg->class_weight;

net/sched/sch_qfq.c

666

xstats.lmax = cl->agg->lmax;

net/sched/sch_qfq.c

669

if (gnet_stats_copy_basic(d, NULL, &cl->bstats, true) < 0 ||

net/sched/sch_qfq.c

670

gnet_stats_copy_rate_est(d, &cl->rate_est) < 0 ||

net/sched/sch_qfq.c

671

qdisc_qstats_copy(d, cl->qdisc) < 0)

net/sched/sch_qfq.c

680

struct qfq_class *cl;

net/sched/sch_qfq.c

687

hlist_for_each_entry(cl, &q->clhash.hash[i], common.hnode) {

net/sched/sch_qfq.c

688

if (!tc_qdisc_stats_dump(sch, (unsigned long)cl, arg))

net/sched/sch_qfq.c

698

struct qfq_class *cl;

net/sched/sch_qfq.c

705

cl = qfq_find_class(sch, skb->priority);

net/sched/sch_qfq.c

706

if (cl != NULL)

net/sched/sch_qfq.c

707

return cl;

net/sched/sch_qfq.c

725

cl = (struct qfq_class *)res.class;

net/sched/sch_qfq.c

726

if (cl == NULL)

net/sched/sch_qfq.c

727

cl = qfq_find_class(sch, res.classid);

net/sched/sch_qfq.c

728

return cl;

net/sched/sch_qfq.c

993

struct qfq_class *cl, unsigned int len)

net/sched/sch_qfq.c

995

struct sk_buff *skb = qdisc_dequeue_peeked(cl->qdisc);

net/sched/sch_red.c

473

static int red_dump_class(struct Qdisc *sch, unsigned long cl,

net/sched/sch_sfb.c

615

static int sfb_dump_class(struct Qdisc *sch, unsigned long cl,

net/sched/sch_sfb.c

656

static int sfb_delete(struct Qdisc *sch, unsigned long cl,

net/sched/sch_sfb.c

669

static struct tcf_block *sfb_tcf_block(struct Qdisc *sch, unsigned long cl,

net/sched/sch_sfb.c

674

if (cl)

net/sched/sch_sfq.c

883

static void sfq_unbind(struct Qdisc *q, unsigned long cl)

net/sched/sch_sfq.c

887

static struct tcf_block *sfq_tcf_block(struct Qdisc *sch, unsigned long cl,

net/sched/sch_sfq.c

892

if (cl)

net/sched/sch_sfq.c

897

static int sfq_dump_class(struct Qdisc *sch, unsigned long cl,

net/sched/sch_sfq.c

900

tcm->tcm_handle |= TC_H_MIN(cl);

net/sched/sch_sfq.c

904

static int sfq_dump_class_stats(struct Qdisc *sch, unsigned long cl,

net/sched/sch_sfq.c

908

sfq_index idx = q->ht[cl - 1];

net/sched/sch_skbprio.c

242

static int skbprio_dump_class(struct Qdisc *sch, unsigned long cl,

net/sched/sch_skbprio.c

245

tcm->tcm_handle |= TC_H_MIN(cl);

net/sched/sch_skbprio.c

249

static int skbprio_dump_class_stats(struct Qdisc *sch, unsigned long cl,

net/sched/sch_skbprio.c

253

if (gnet_stats_copy_queue(d, NULL, &q->qstats[cl - 1],

net/sched/sch_skbprio.c

254

q->qstats[cl - 1].qlen) < 0)

net/sched/sch_taprio.c

2164

unsigned long cl)

net/sched/sch_taprio.c

2167

unsigned long ntx = cl - 1;

net/sched/sch_taprio.c

2175

static int taprio_graft(struct Qdisc *sch, unsigned long cl,

net/sched/sch_taprio.c

2181

struct netdev_queue *dev_queue = taprio_queue_get(sch, cl);

net/sched/sch_taprio.c

2196

*old = q->qdiscs[cl - 1];

net/sched/sch_taprio.c

2205

q->qdiscs[cl - 1] = new;

net/sched/sch_taprio.c

2447

static struct Qdisc *taprio_leaf(struct Qdisc *sch, unsigned long cl)

net/sched/sch_taprio.c

2451

unsigned int ntx = cl - 1;

net/sched/sch_taprio.c

2468

static int taprio_dump_class(struct Qdisc *sch, unsigned long cl,

net/sched/sch_taprio.c

2471

struct Qdisc *child = taprio_leaf(sch, cl);

net/sched/sch_taprio.c

2474

tcm->tcm_handle |= TC_H_MIN(cl);

net/sched/sch_taprio.c

2480

static int taprio_dump_class_stats(struct Qdisc *sch, unsigned long cl,

net/sched/sch_taprio.c

2485

struct Qdisc *child = taprio_leaf(sch, cl);

net/sched/sch_taprio.c

2489

.queue = cl - 1,

net/sched/sch_tbf.c

552

static int tbf_dump_class(struct Qdisc *sch, unsigned long cl,

net/sunrpc/svc_xprt.c

85

struct svc_xprt_class *cl;

net/sunrpc/svc_xprt.c

91

list_for_each_entry(cl, &svc_xprt_class_list, xcl_list) {

net/sunrpc/svc_xprt.c

92

if (strcmp(xcl->xcl_name, cl->xcl_name) == 0)

samples/mei/mei-amt-version.c

101

static void mei_deinit(struct mei *cl)

samples/mei/mei-amt-version.c

103

if (cl->fd != -1)

samples/mei/mei-amt-version.c

104

close(cl->fd);

samples/mei/mei-amt-version.c

105

cl->fd = -1;

samples/mei/mei-amt-version.c

106

cl->buf_size = 0;

samples/mei/mei-amt-version.c

107

cl->prot_ver = 0;

samples/mei/mei-amt-version.c

108

cl->initialized = false;

samples/mei/mei-amt-version.c

115

struct mei_client *cl;

samples/mei/mei-amt-version.c

135

cl = &data.out_client_properties;

samples/mei/mei-amt-version.c

136

mei_msg(me, "max_message_length %d\n", cl->max_msg_length);

samples/mei/mei-amt-version.c

137

mei_msg(me, "protocol_version %d\n", cl->protocol_version);

samples/mei/mei-amt-version.c

140

(cl->protocol_version != req_protocol_version)) {

samples/mei/mei-amt-version.c

145

me->buf_size = cl->max_msg_length;

samples/mei/mei-amt-version.c

146

me->prot_ver = cl->protocol_version;

security/apparmor/file.c

709

struct cred_label *cl = (struct cred_label *)p;

security/apparmor/file.c

711

if (aa_file_perm(OP_INHERIT, cl->cred, cl->label, file,

security/apparmor/file.c

722

struct cred_label cl = {

security/apparmor/file.c

732

n = iterate_fd(files, 0, match_file, &cl);

security/apparmor/file.c

742

} while ((n = iterate_fd(files, n, match_file, &cl)) != 0);

security/apparmor/lsm.c

1024

struct aa_label *cl, *tl;

security/apparmor/lsm.c

1034

cl = aa_get_newest_cred_label(cred);

security/apparmor/lsm.c

1035

error = aa_may_signal(cred, cl, tc, tl, sig);

security/apparmor/lsm.c

1036

aa_put_label(cl);

security/apparmor/lsm.c

1038

cl = __begin_current_label_crit_section(&needput);

security/apparmor/lsm.c

1039

error = aa_may_signal(current_cred(), cl, tc, tl, sig);

security/apparmor/lsm.c

1040

__end_current_label_crit_section(cl, needput);

sound/soc/apple/mca.c

1014

struct mca_cluster *cl = &mca->clusters[i];

sound/soc/apple/mca.c

1016

if (!IS_ERR_OR_NULL(cl->clk_parent))

sound/soc/apple/mca.c

1017

clk_put(cl->clk_parent);

sound/soc/apple/mca.c

1019

if (!IS_ERR_OR_NULL(cl->pd_dev))

sound/soc/apple/mca.c

1020

dev_pm_domain_detach(cl->pd_dev, true);

sound/soc/apple/mca.c

1091

struct mca_cluster *cl = &clusters[i];

sound/soc/apple/mca.c

1096

cl->host = mca;

sound/soc/apple/mca.c

1097

cl->no = i;

sound/soc/apple/mca.c

1098

cl->base = base + CLUSTER_STRIDE * i;

sound/soc/apple/mca.c

1099

cl->port_driver = -1;

sound/soc/apple/mca.c

1100

cl->clk_parent = of_clk_get(pdev->dev.of_node, i);

sound/soc/apple/mca.c

1101

if (IS_ERR(cl->clk_parent)) {

sound/soc/apple/mca.c

1103

i, PTR_ERR(cl->clk_parent));

sound/soc/apple/mca.c

1104

ret = PTR_ERR(cl->clk_parent);

sound/soc/apple/mca.c

1107

cl->pd_dev = dev_pm_domain_attach_by_id(&pdev->dev, i + 1);

sound/soc/apple/mca.c

1108

if (IS_ERR(cl->pd_dev)) {

sound/soc/apple/mca.c

111

#define REG_DMA_ADAPTER_A(cl) (0x8000 * (cl))

sound/soc/apple/mca.c

1111

PTR_ERR(cl->pd_dev));

sound/soc/apple/mca.c

1112

ret = PTR_ERR(cl->pd_dev);

sound/soc/apple/mca.c

112

#define REG_DMA_ADAPTER_B(cl) (0x8000 * (cl) + 0x4000)

sound/soc/apple/mca.c

167

static void mca_modify(struct mca_cluster *cl, int regoffset, u32 mask, u32 val)

sound/soc/apple/mca.c

169

__iomem void *ptr = cl->base + regoffset;

sound/soc/apple/mca.c

195

struct mca_cluster *cl = mca_dai_to_cluster(dai);

sound/soc/apple/mca.c

205

mca_modify(cl, serdes_conf, SERDES_CONF_SYNC_SEL,

sound/soc/apple/mca.c

207

mca_modify(cl, serdes_conf, SERDES_CONF_SYNC_SEL,

sound/soc/apple/mca.c

209

mca_modify(cl, serdes_unit + REG_SERDES_STATUS,

sound/soc/apple/mca.c

217

WARN_ON(readl_relaxed(cl->base + serdes_unit + REG_SERDES_STATUS) &

sound/soc/apple/mca.c

219

mca_modify(cl, serdes_conf, SERDES_CONF_SYNC_SEL,

sound/soc/apple/mca.c

221

mca_modify(cl, serdes_conf, SERDES_CONF_SYNC_SEL,

sound/soc/apple/mca.c

222

FIELD_PREP(SERDES_CONF_SYNC_SEL, cl->no + 1));

sound/soc/apple/mca.c

232

struct mca_cluster *cl = mca_dai_to_cluster(dai);

sound/soc/apple/mca.c

240

mca_modify(cl, serdes_unit + REG_SERDES_STATUS,

sound/soc/apple/mca.c

248

mca_modify(cl, serdes_unit + REG_SERDES_STATUS,

sound/soc/apple/mca.c

259

static int mca_fe_enable_clocks(struct mca_cluster *cl)

sound/soc/apple/mca.c

261

struct mca_data *mca = cl->host;

sound/soc/apple/mca.c

264

ret = clk_prepare_enable(cl->clk_parent);

sound/soc/apple/mca.c

268

cl->no, ret);

sound/soc/apple/mca.c

277

cl->pd_link = device_link_add(mca->dev, cl->pd_dev,

sound/soc/apple/mca.c

280

if (!cl->pd_link) {

sound/soc/apple/mca.c

282

"cluster %d: unable to prop-up power domain\n", cl->no);

sound/soc/apple/mca.c

283

clk_disable_unprepare(cl->clk_parent);

sound/soc/apple/mca.c

287

writel_relaxed(cl->no + 1, cl->base + REG_SYNCGEN_MCLK_SEL);

sound/soc/apple/mca.c

288

mca_modify(cl, REG_SYNCGEN_STATUS, SYNCGEN_STATUS_EN,

sound/soc/apple/mca.c

290

mca_modify(cl, REG_STATUS, STATUS_MCLK_EN, STATUS_MCLK_EN);

sound/soc/apple/mca.c

295

static void mca_fe_disable_clocks(struct mca_cluster *cl)

sound/soc/apple/mca.c

297

mca_modify(cl, REG_SYNCGEN_STATUS, SYNCGEN_STATUS_EN, 0);

sound/soc/apple/mca.c

298

mca_modify(cl, REG_STATUS, STATUS_MCLK_EN, 0);

sound/soc/apple/mca.c

300

device_link_del(cl->pd_link);

sound/soc/apple/mca.c

301

clk_disable_unprepare(cl->clk_parent);

sound/soc/apple/mca.c

304

static bool mca_fe_clocks_in_use(struct mca_cluster *cl)

sound/soc/apple/mca.c

306

struct mca_data *mca = cl->host;

sound/soc/apple/mca.c

314

if (be_cl->port_driver != cl->no)

sound/soc/apple/mca.c

331

struct mca_cluster *cl = mca_dai_to_cluster(dai);

sound/soc/apple/mca.c

332

struct mca_data *mca = cl->host;

sound/soc/apple/mca.c

336

if (cl->port_driver < 0)

sound/soc/apple/mca.c

339

fe_cl = &mca->clusters[cl->port_driver];

sound/soc/apple/mca.c

353

cl->clocks_in_use[substream->stream] = true;

sound/soc/apple/mca.c

361

struct mca_cluster *cl = mca_dai_to_cluster(dai);

sound/soc/apple/mca.c

362

struct mca_data *mca = cl->host;

sound/soc/apple/mca.c

365

if (cl->port_driver < 0)

sound/soc/apple/mca.c

373

fe_cl = &mca->clusters[cl->port_driver];

sound/soc/apple/mca.c

377

cl->clocks_in_use[substream->stream] = false;

sound/soc/apple/mca.c

393

static int mca_configure_serdes(struct mca_cluster *cl, int serdes_unit,

sound/soc/apple/mca.c

397

__iomem void *serdes_base = cl->base + serdes_unit;

sound/soc/apple/mca.c

420

serdes_conf |= FIELD_PREP(SERDES_CONF_SYNC_SEL, cl->no + 1);

sound/soc/apple/mca.c

435

mca_modify(cl,

sound/soc/apple/mca.c

461

dev_err(cl->host->dev,

sound/soc/apple/mca.c

470

struct mca_cluster *cl = mca_dai_to_cluster(dai);

sound/soc/apple/mca.c

473

if (cl->tdm_slots) {

sound/soc/apple/mca.c

475

mask = cl->tdm_tx_mask;

sound/soc/apple/mca.c

477

mask = cl->tdm_rx_mask;

sound/soc/apple/mca.c

492

struct mca_cluster *cl = mca_dai_to_cluster(dai);

sound/soc/apple/mca.c

494

cl->tdm_slots = slots;

sound/soc/apple/mca.c

495

cl->tdm_slot_width = slot_width;

sound/soc/apple/mca.c

496

cl->tdm_tx_mask = tx_mask;

sound/soc/apple/mca.c

497

cl->tdm_rx_mask = rx_mask;

sound/soc/apple/mca.c

504

struct mca_cluster *cl = mca_dai_to_cluster(dai);

sound/soc/apple/mca.c

505

struct mca_data *mca = cl->host;

sound/soc/apple/mca.c

544

mca_modify(cl, CLUSTER_TX_OFF + REG_TX_SERDES_CONF,

sound/soc/apple/mca.c

546

mca_modify(cl, CLUSTER_RX_OFF + REG_RX_SERDES_CONF,

sound/soc/apple/mca.c

549

cl->base + CLUSTER_TX_OFF + REG_TX_SERDES_BITSTART);

sound/soc/apple/mca.c

551

cl->base + CLUSTER_RX_OFF + REG_RX_SERDES_BITSTART);

sound/soc/apple/mca.c

562

struct mca_cluster *cl = mca_dai_to_cluster(dai);

sound/soc/apple/mca.c

564

cl->bclk_ratio = ratio;

sound/soc/apple/mca.c

591

struct mca_cluster *cl = mca_dai_to_cluster(dai);

sound/soc/apple/mca.c

592

struct mca_data *mca = cl->host;

sound/soc/apple/mca.c

602

if (!cl->tdm_slot_width) {

sound/soc/apple/mca.c

611

tdm_slot_width = cl->tdm_slot_width;

sound/soc/apple/mca.c

612

tdm_slots = cl->tdm_slots;

sound/soc/apple/mca.c

613

tdm_mask = is_tx ? cl->tdm_tx_mask : cl->tdm_rx_mask;

sound/soc/apple/mca.c

616

if (cl->bclk_ratio)

sound/soc/apple/mca.c

617

bclk_ratio = cl->bclk_ratio;

sound/soc/apple/mca.c

65

#define PORT_DATA_SEL_TXA(cl) (1 << ((cl)*2))

sound/soc/apple/mca.c

653

ret = mca_configure_serdes(cl, is_tx ? CLUSTER_TX_OFF : CLUSTER_RX_OFF,

sound/soc/apple/mca.c

66

#define PORT_DATA_SEL_TXB(cl) (2 << ((cl)*2))

sound/soc/apple/mca.c

672

writel_relaxed(regval, mca->switch_base + REG_DMA_ADAPTER_A(cl->no));

sound/soc/apple/mca.c

676

mca->switch_base + REG_DMA_ADAPTER_A(cl->no));

sound/soc/apple/mca.c

679

mca->switch_base + REG_DMA_ADAPTER_B(cl->no));

sound/soc/apple/mca.c

682

if (!mca_fe_clocks_in_use(cl)) {

sound/soc/apple/mca.c

687

cl->base + REG_SYNCGEN_HI_PERIOD);

sound/soc/apple/mca.c

689

cl->base + REG_SYNCGEN_LO_PERIOD);

sound/soc/apple/mca.c

691

cl->base + REG_MCLK_CONF);

sound/soc/apple/mca.c

693

ret = clk_set_rate(cl->clk_parent, bclk_ratio * samp_rate);

sound/soc/apple/mca.c

696

cl->no, ret);

sound/soc/apple/mca.c

713

static bool mca_be_started(struct mca_cluster *cl)

sound/soc/apple/mca.c

718

if (cl->port_started[stream])

sound/soc/apple/mca.c

728

struct mca_cluster *cl = mca_dai_to_cluster(dai);

sound/soc/apple/mca.c

730

struct mca_data *mca = cl->host;

sound/soc/apple/mca.c

749

if (mca_be_started(cl)) {

sound/soc/apple/mca.c

755

if (cl->port_driver != fe_cl->no)

sound/soc/apple/mca.c

758

cl->port_started[substream->stream] = true;

sound/soc/apple/mca.c

763

cl->base + REG_PORT_ENABLES);

sound/soc/apple/mca.c

765

cl->base + REG_PORT_CLOCK_SEL);

sound/soc/apple/mca.c

767

cl->base + REG_PORT_DATA_SEL);

sound/soc/apple/mca.c

769

cl->port_driver = fe_cl->no;

sound/soc/apple/mca.c

771

cl->port_started[substream->stream] = true;

sound/soc/apple/mca.c

779

struct mca_cluster *cl = mca_dai_to_cluster(dai);

sound/soc/apple/mca.c

780

struct mca_data *mca = cl->host;

sound/soc/apple/mca.c

782

cl->port_started[substream->stream] = false;

sound/soc/apple/mca.c

784

if (!mca_be_started(cl)) {

sound/soc/apple/mca.c

789

writel_relaxed(0, cl->base + REG_PORT_ENABLES);

sound/soc/apple/mca.c

790

writel_relaxed(0, cl->base + REG_PORT_DATA_SEL);

sound/soc/apple/mca.c

792

cl->port_driver = -1;

sound/soc/apple/mca.c

838

struct mca_cluster *cl = mca_dai_to_cluster(snd_soc_rtd_to_cpu(rtd, 0));

sound/soc/apple/mca.c

839

struct dma_chan *chan = cl->dma_chans[substream->stream];

sound/soc/apple/mca.c

919

static struct dma_chan *mca_request_dma_channel(struct mca_cluster *cl, unsigned int stream)

sound/soc/apple/mca.c

923

char *name = devm_kasprintf(cl->host->dev, GFP_KERNEL,

sound/soc/apple/mca.c

924

is_tx ? "tx%da" : "rx%da", cl->no);

sound/soc/apple/mca.c

926

char *name = devm_kasprintf(cl->host->dev, GFP_KERNEL,

sound/soc/apple/mca.c

927

is_tx ? "tx%da" : "rx%db", cl->no);

sound/soc/apple/mca.c

929

return of_dma_request_slave_channel(cl->host->dev->of_node, name);

sound/soc/apple/mca.c

937

struct mca_cluster *cl = mca_dai_to_cluster(snd_soc_rtd_to_cpu(rtd, 0));

sound/soc/apple/mca.c

947

if (!substream || !cl->dma_chans[i])

sound/soc/apple/mca.c

950

dma_release_channel(cl->dma_chans[i]);

sound/soc/apple/mca.c

951

cl->dma_chans[i] = NULL;

sound/soc/apple/mca.c

959

struct mca_cluster *cl = mca_dai_to_cluster(snd_soc_rtd_to_cpu(rtd, 0));

sound/soc/apple/mca.c

973

chan = mca_request_dma_channel(cl, i);

sound/soc/apple/mca.c

982

i, cl->no, chan);

sound/soc/apple/mca.c

989

cl->dma_chans[i] = chan;

sound/soc/codecs/rt1019.c

393

unsigned int cn = 0, cl = 0, rx_slotnum;

sound/soc/codecs/rt1019.c

414

cl = RT1019_TDM_CL_20;

sound/soc/codecs/rt1019.c

417

cl = RT1019_TDM_CL_24;

sound/soc/codecs/rt1019.c

420

cl = RT1019_TDM_CL_32;

sound/soc/codecs/rt1019.c

423

cl = RT1019_TDM_CL_8;

sound/soc/codecs/rt1019.c

473

RT1019_TDM_CL_MASK, cl);

sound/soc/codecs/rt1318.c

1039

RT1318_I2S_TX_CHL_MASK | RT1318_I2S_RX_CHL_MASK, cl);

sound/soc/codecs/rt1318.c

954

unsigned int cn = 0, cl = 0, rx_slotnum;

sound/soc/codecs/rt1318.c

978

cl |= RT1318_I2S_TX_CHL_20;

sound/soc/codecs/rt1318.c

979

cl |= RT1318_I2S_RX_CHL_20;

sound/soc/codecs/rt1318.c

982

cl |= RT1318_I2S_TX_CHL_24;

sound/soc/codecs/rt1318.c

983

cl |= RT1318_I2S_RX_CHL_24;

sound/soc/codecs/rt1318.c

986

cl |= RT1318_I2S_TX_CHL_32;

sound/soc/codecs/rt1318.c

987

cl |= RT1318_I2S_RX_CHL_32;

sound/soc/codecs/rt1318.c

990

cl |= RT1318_I2S_TX_CHL_8;

sound/soc/codecs/rt1318.c

991

cl |= RT1318_I2S_RX_CHL_8;

sound/soc/codecs/rt5682.c

2067

unsigned int cl, val = 0;

sound/soc/codecs/rt5682.c

2102

cl = RT5682_I2S1_TX_CHL_8 | RT5682_I2S1_RX_CHL_8;

sound/soc/codecs/rt5682.c

2106

cl = RT5682_I2S1_TX_CHL_16 | RT5682_I2S1_RX_CHL_16;

sound/soc/codecs/rt5682.c

2110

cl = RT5682_I2S1_TX_CHL_20 | RT5682_I2S1_RX_CHL_20;

sound/soc/codecs/rt5682.c

2114

cl = RT5682_I2S1_TX_CHL_24 | RT5682_I2S1_RX_CHL_24;

sound/soc/codecs/rt5682.c

2118

cl = RT5682_I2S1_TX_CHL_32 | RT5682_I2S1_RX_CHL_32;

sound/soc/codecs/rt5682.c

2127

RT5682_I2S1_TX_CHL_MASK | RT5682_I2S1_RX_CHL_MASK, cl);

sound/soc/codecs/rt5682s.c

1985

unsigned int cl, val = 0, tx_slotnum;

sound/soc/codecs/rt5682s.c

2031

cl = RT5682S_I2S1_TX_CHL_8 | RT5682S_I2S1_RX_CHL_8;

sound/soc/codecs/rt5682s.c

2035

cl = RT5682S_I2S1_TX_CHL_16 | RT5682S_I2S1_RX_CHL_16;

sound/soc/codecs/rt5682s.c

2039

cl = RT5682S_I2S1_TX_CHL_20 | RT5682S_I2S1_RX_CHL_20;

sound/soc/codecs/rt5682s.c

2043

cl = RT5682S_I2S1_TX_CHL_24 | RT5682S_I2S1_RX_CHL_24;

sound/soc/codecs/rt5682s.c

2047

cl = RT5682S_I2S1_TX_CHL_32 | RT5682S_I2S1_RX_CHL_32;

sound/soc/codecs/rt5682s.c

2056

RT5682S_I2S1_TX_CHL_MASK | RT5682S_I2S1_RX_CHL_MASK, cl);

sound/soc/intel/avs/cldma.c

100

ret = wait_for_completion_timeout(&cl->completion,

sound/soc/intel/avs/cldma.c

103

dev_err(cl->dev, "cldma IOC timeout\n");

sound/soc/intel/avs/cldma.c

107

if (!(cl->sd_status & SD_INT_COMPLETE)) {

sound/soc/intel/avs/cldma.c

108

dev_err(cl->dev, "cldma transfer error, SD status: 0x%08x\n",

sound/soc/intel/avs/cldma.c

109

cl->sd_status);

sound/soc/intel/avs/cldma.c

113

if (!cl->remaining)

sound/soc/intel/avs/cldma.c

116

reinit_completion(&cl->completion);

sound/soc/intel/avs/cldma.c

117

hda_cldma_fill(cl);

sound/soc/intel/avs/cldma.c

119

snd_hdac_adsp_updatel(cl, AVS_ADSP_REG_ADSPIC, AVS_ADSP_ADSPIC_CLDMA,

sound/soc/intel/avs/cldma.c

124

void hda_cldma_transfer(struct hda_cldma *cl, unsigned long start_delay)

sound/soc/intel/avs/cldma.c

126

if (!cl->remaining)

sound/soc/intel/avs/cldma.c

129

reinit_completion(&cl->completion);

sound/soc/intel/avs/cldma.c

131

hda_cldma_fill(cl);

sound/soc/intel/avs/cldma.c

133

schedule_delayed_work(&cl->memcpy_work, start_delay);

sound/soc/intel/avs/cldma.c

136

int hda_cldma_start(struct hda_cldma *cl)

sound/soc/intel/avs/cldma.c

141

snd_hdac_adsp_updatel(cl, AVS_ADSP_REG_ADSPIC, AVS_ADSP_ADSPIC_CLDMA,

sound/soc/intel/avs/cldma.c

143

snd_hdac_stream_updateb(cl, SD_CTL, SD_INT_MASK | SD_CTL_DMA_START,

sound/soc/intel/avs/cldma.c

147

return snd_hdac_stream_readb_poll(cl, SD_CTL, reg, reg & SD_CTL_DMA_START,

sound/soc/intel/avs/cldma.c

151

int hda_cldma_stop(struct hda_cldma *cl)

sound/soc/intel/avs/cldma.c

157

snd_hdac_adsp_updatel(cl, AVS_ADSP_REG_ADSPIC, AVS_ADSP_ADSPIC_CLDMA, 0);

sound/soc/intel/avs/cldma.c

158

snd_hdac_stream_updateb(cl, SD_CTL, SD_INT_MASK | SD_CTL_DMA_START, 0);

sound/soc/intel/avs/cldma.c

161

ret = snd_hdac_stream_readb_poll(cl, SD_CTL, reg, !(reg & SD_CTL_DMA_START),

sound/soc/intel/avs/cldma.c

163

cancel_delayed_work_sync(&cl->memcpy_work);

sound/soc/intel/avs/cldma.c

168

int hda_cldma_reset(struct hda_cldma *cl)

sound/soc/intel/avs/cldma.c

173

ret = hda_cldma_stop(cl);

sound/soc/intel/avs/cldma.c

175

dev_err(cl->dev, "cldma stop failed: %d\n", ret);

sound/soc/intel/avs/cldma.c

179

snd_hdac_stream_updateb(cl, SD_CTL, SD_CTL_STREAM_RESET, SD_CTL_STREAM_RESET);

sound/soc/intel/avs/cldma.c

180

ret = snd_hdac_stream_readb_poll(cl, SD_CTL, reg, (reg & SD_CTL_STREAM_RESET),

sound/soc/intel/avs/cldma.c

183

dev_err(cl->dev, "cldma set SRST failed: %d\n", ret);

sound/soc/intel/avs/cldma.c

187

snd_hdac_stream_updateb(cl, SD_CTL, SD_CTL_STREAM_RESET, 0);

sound/soc/intel/avs/cldma.c

188

ret = snd_hdac_stream_readb_poll(cl, SD_CTL, reg, !(reg & SD_CTL_STREAM_RESET),

sound/soc/intel/avs/cldma.c

191

dev_err(cl->dev, "cldma unset SRST failed: %d\n", ret);

sound/soc/intel/avs/cldma.c

198

void hda_cldma_set_data(struct hda_cldma *cl, void *data, unsigned int size)

sound/soc/intel/avs/cldma.c

201

cl->position = data;

sound/soc/intel/avs/cldma.c

202

cl->remaining = size;

sound/soc/intel/avs/cldma.c

205

static void cldma_setup_bdle(struct hda_cldma *cl, u32 bdle_size)

sound/soc/intel/avs/cldma.c

207

struct snd_dma_buffer *dmab = &cl->dmab_data;

sound/soc/intel/avs/cldma.c

208

__le32 *bdl = (__le32 *)cl->dmab_bdl.area;

sound/soc/intel/avs/cldma.c

209

int remaining = cl->buffer_size;

sound/soc/intel/avs/cldma.c

212

cl->num_periods = 0;

sound/soc/intel/avs/cldma.c

230

cl->num_periods++;

sound/soc/intel/avs/cldma.c

234

void hda_cldma_setup(struct hda_cldma *cl)

sound/soc/intel/avs/cldma.c

236

dma_addr_t bdl_addr = cl->dmab_bdl.addr;

sound/soc/intel/avs/cldma.c

238

cldma_setup_bdle(cl, cl->buffer_size / 2);

sound/soc/intel/avs/cldma.c

240

snd_hdac_stream_writel(cl, SD_BDLPL, AZX_SD_BDLPL_BDLPLBA(lower_32_bits(bdl_addr)));

sound/soc/intel/avs/cldma.c

241

snd_hdac_stream_writel(cl, SD_BDLPU, upper_32_bits(bdl_addr));

sound/soc/intel/avs/cldma.c

243

snd_hdac_stream_writel(cl, SD_CBL, cl->buffer_size);

sound/soc/intel/avs/cldma.c

244

snd_hdac_stream_writeb(cl, SD_LVI, cl->num_periods - 1);

sound/soc/intel/avs/cldma.c

246

snd_hdac_stream_updatel(cl, SD_CTL, AZX_SD_CTL_STRM_MASK, AZX_SD_CTL_STRM(cl));

sound/soc/intel/avs/cldma.c

248

snd_hdac_stream_writel(cl, CL_SPBFCTL, 1);

sound/soc/intel/avs/cldma.c

251

void hda_cldma_interrupt(struct hda_cldma *cl)

sound/soc/intel/avs/cldma.c

254

snd_hdac_adsp_updatel(cl, AVS_ADSP_REG_ADSPIC, AVS_ADSP_ADSPIC_CLDMA, 0);

sound/soc/intel/avs/cldma.c

256

cl->sd_status = snd_hdac_stream_readb(cl, SD_STS);

sound/soc/intel/avs/cldma.c

257

dev_dbg(cl->dev, "%s sd_status: 0x%08x\n", __func__, cl->sd_status);

sound/soc/intel/avs/cldma.c

259

complete(&cl->completion);

sound/soc/intel/avs/cldma.c

262

int hda_cldma_init(struct hda_cldma *cl, struct hdac_bus *bus, void __iomem *dsp_ba,

sound/soc/intel/avs/cldma.c

267

ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV_SG, bus->dev, buffer_size, &cl->dmab_data);

sound/soc/intel/avs/cldma.c

271

ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, bus->dev, BDL_SIZE, &cl->dmab_bdl);

sound/soc/intel/avs/cldma.c

273

snd_dma_free_pages(&cl->dmab_data);

sound/soc/intel/avs/cldma.c

277

cl->dev = bus->dev;

sound/soc/intel/avs/cldma.c

278

cl->bus = bus;

sound/soc/intel/avs/cldma.c

279

cl->dsp_ba = dsp_ba;

sound/soc/intel/avs/cldma.c

280

cl->buffer_size = buffer_size;

sound/soc/intel/avs/cldma.c

281

cl->sd_addr = dsp_ba + AZX_CL_SD_BASE;

sound/soc/intel/avs/cldma.c

286

void hda_cldma_free(struct hda_cldma *cl)

sound/soc/intel/avs/cldma.c

288

snd_dma_free_pages(&cl->dmab_data);

sound/soc/intel/avs/cldma.c

289

snd_dma_free_pages(&cl->dmab_bdl);

sound/soc/intel/avs/cldma.c

60

void hda_cldma_fill(struct hda_cldma *cl)

sound/soc/intel/avs/cldma.c

64

if (cl->remaining > cl->buffer_size)

sound/soc/intel/avs/cldma.c

65

size = cl->buffer_size;

sound/soc/intel/avs/cldma.c

67

size = cl->remaining;

sound/soc/intel/avs/cldma.c

69

offset = snd_hdac_stream_readl(cl, CL_SD_SPIB);

sound/soc/intel/avs/cldma.c

70

if (offset + size > cl->buffer_size) {

sound/soc/intel/avs/cldma.c

73

ss = cl->buffer_size - offset;

sound/soc/intel/avs/cldma.c

74

memcpy(cl->dmab_data.area + offset, cl->position, ss);

sound/soc/intel/avs/cldma.c

77

cl->position += ss;

sound/soc/intel/avs/cldma.c

78

cl->remaining -= ss;

sound/soc/intel/avs/cldma.c

81

memcpy(cl->dmab_data.area + offset, cl->position, size);

sound/soc/intel/avs/cldma.c

82

cl->position += size;

sound/soc/intel/avs/cldma.c

83

cl->remaining -= size;

sound/soc/intel/avs/cldma.c

85

snd_hdac_stream_writel(cl, CL_SD_SPIB, offset + size);

sound/soc/intel/avs/cldma.c

90

struct hda_cldma *cl = container_of(work, struct hda_cldma, memcpy_work.work);

sound/soc/intel/avs/cldma.c

93

ret = hda_cldma_start(cl);

sound/soc/intel/avs/cldma.c

95

dev_err(cl->dev, "cldma set RUN failed: %d\n", ret);

sound/soc/intel/avs/cldma.h

18

void hda_cldma_fill(struct hda_cldma *cl);

sound/soc/intel/avs/cldma.h

19

void hda_cldma_transfer(struct hda_cldma *cl, unsigned long start_delay);

sound/soc/intel/avs/cldma.h

21

int hda_cldma_start(struct hda_cldma *cl);

sound/soc/intel/avs/cldma.h

22

int hda_cldma_stop(struct hda_cldma *cl);

sound/soc/intel/avs/cldma.h

23

int hda_cldma_reset(struct hda_cldma *cl);

sound/soc/intel/avs/cldma.h

25

void hda_cldma_set_data(struct hda_cldma *cl, void *data, unsigned int size);

sound/soc/intel/avs/cldma.h

26

void hda_cldma_setup(struct hda_cldma *cl);

sound/soc/intel/avs/cldma.h

27

void hda_cldma_interrupt(struct hda_cldma *cl);

sound/soc/intel/avs/cldma.h

28

int hda_cldma_init(struct hda_cldma *cl, struct hdac_bus *bus, void __iomem *dsp_ba,

sound/soc/intel/avs/cldma.h

30

void hda_cldma_free(struct hda_cldma *cl);

sound/soc/intel/avs/loader.c

140

struct hda_cldma *cl = &code_loader;

sound/soc/intel/avs/loader.c

152

ret = hda_cldma_reset(cl);

sound/soc/intel/avs/loader.c

157

hda_cldma_setup(cl);

sound/soc/intel/avs/loader.c

177

hda_cldma_set_data(cl, (void *)fw->data, fw->size);

sound/soc/intel/avs/loader.c

179

hda_cldma_transfer(cl, 0);

sound/soc/intel/avs/loader.c

183

hda_cldma_stop(cl);

sound/soc/intel/avs/loader.c

196

struct hda_cldma *cl = &code_loader;

sound/soc/intel/avs/loader.c

199

hda_cldma_set_data(cl, (void *)lib->data, lib->size);

sound/soc/intel/avs/loader.c

201

hda_cldma_transfer(cl, msecs_to_jiffies(AVS_CLDMA_START_DELAY_MS));

sound/soc/intel/avs/loader.c

205

hda_cldma_stop(cl);

sound/soc/intel/avs/loader.c

217

struct hda_cldma *cl = &code_loader;

sound/soc/intel/avs/loader.c

236

hda_cldma_set_data(cl, (void *)mod->data, mod->size);

sound/soc/intel/avs/loader.c

237

hda_cldma_transfer(cl, msecs_to_jiffies(AVS_CLDMA_START_DELAY_MS));

sound/soc/intel/avs/loader.c

239

hda_cldma_stop(cl);

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

100

if (!cl)

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

103

clk = cl->clk;

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

106

clkdev_drop(cl);

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

114

struct clk_lookup *cl;

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

138

cl = kzalloc_obj(*cl);

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

139

if (!cl)

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

142

cl->clk = clk;

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

143

cl->con_id = gate->name;

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

144

cl->dev_id = dev_name(afe->dev);

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

145

clkdev_add(cl);

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

147

afe_priv->lookup[i] = cl;

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

92

struct clk_lookup *cl;

sound/soc/mediatek/mt8186/mt8186-audsys-clk.c

99

cl = afe_priv->lookup[i];

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

150

struct clk_lookup *cl;

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

157

cl = afe_priv->lookup[i];

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

158

if (!cl)

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

161

clk = cl->clk;

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

164

clkdev_drop(cl);

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

172

struct clk_lookup *cl;

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

196

cl = kzalloc_obj(*cl);

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

197

if (!cl)

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

200

cl->clk = clk;

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

201

cl->con_id = gate->name;

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

202

cl->dev_id = dev_name(afe->dev);

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

203

cl->clk_hw = NULL;

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

204

clkdev_add(cl);

sound/soc/mediatek/mt8188/mt8188-audsys-clk.c

206

afe_priv->lookup[i] = cl;

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

156

struct clk_lookup *cl;

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

163

cl = afe_priv->lookup[i];

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

164

if (!cl)

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

167

clk = cl->clk;

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

170

clkdev_drop(cl);

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

178

struct clk_lookup *cl;

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

202

cl = kzalloc_obj(*cl);

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

203

if (!cl)

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

206

cl->clk = clk;

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

207

cl->con_id = gate->name;

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

208

cl->dev_id = dev_name(afe->dev);

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

209

clkdev_add(cl);

sound/soc/mediatek/mt8195/mt8195-audsys-clk.c

211

afe_priv->lookup[i] = cl;

sound/soc/ti/davinci-mcasp.c

891

struct snd_pcm_hw_constraint_list *cl = &mcasp->chconstr[stream];

sound/soc/ti/davinci-mcasp.c

892

unsigned int *list = (unsigned int *) cl->list;

sound/soc/ti/davinci-mcasp.c

907

cl->count = count;

tools/arch/x86/include/asm/asm.h

105

#define _ASM_ARG4B cl

tools/arch/x86/include/asm/asm.h

69

#define _ASM_ARG3B cl

tools/perf/tests/hists_cumulate.c

171

#define CDSO(cl) (dso__short_name(map__dso(cl->ms.map)))

tools/perf/tests/hists_cumulate.c

172

#define CSYM(cl) (cl->ms.sym->name)

tools/perf/ui/browsers/hists.c

167

static char callchain_list__folded(const struct callchain_list *cl)

tools/perf/ui/browsers/hists.c

169

return cl->has_children ? tree__folded_sign(cl->unfolded) : ' ';

tools/perf/ui/browsers/hists.c

172

static void callchain_list__set_folding(struct callchain_list *cl, bool unfold)

tools/perf/ui/browsers/hists.c

174

cl->unfolded = unfold ? cl->has_children : false;

tools/perf/ui/browsers/hists.c

317

static bool callchain_list__toggle_fold(struct callchain_list *cl)

tools/perf/ui/browsers/hists.c

319

if (!cl)

tools/perf/ui/browsers/hists.c

322

if (!cl->has_children)

tools/perf/ui/browsers/hists.c

325

cl->unfolded = !cl->unfolded;

tools/perf/ui/browsers/hists.c

447

struct callchain_list *cl = container_of(ms, struct callchain_list, ms);

tools/perf/ui/browsers/hists.c

456

has_children = callchain_list__toggle_fold(cl);

tools/perf/util/callchain.c

1193

char *callchain_list__sym_name(struct callchain_list *cl,

tools/perf/util/callchain.c

1200

if (cl->ms.sym) {

tools/perf/util/callchain.c

1201

const char *inlined = cl->ms.sym->inlined ? " (inlined)" : "";

tools/perf/util/callchain.c

1203

if (show_srcline && cl->srcline)

tools/perf/util/callchain.c

1205

cl->ms.sym->name, cl->srcline,

tools/perf/util/callchain.c

1209

cl->ms.sym->name, inlined);

tools/perf/util/callchain.c

1211

printed = scnprintf(bf, bfsize, "%#" PRIx64, cl->ip);

tools/perf/util/callchain.c

1215

cl->ms.map ?

tools/perf/util/callchain.c

1216

dso__short_name(map__dso(cl->ms.map)) :

tools/perf/util/callchain.h

288

char *callchain_list__sym_name(struct callchain_list *cl,

tools/perf/util/data-convert-bt.c

1129

#define ADD_FIELD(cl, t, n) \

tools/perf/util/data-convert-bt.c

1132

if (bt_ctf_event_class_add_field(cl, t, n)) { \

tools/perf/util/perf-regs-arch/perf_regs_x86.c

35

SDT_NAME_REG(cl, cx),