arch/m68k/fpsp040/fpsp.h

63

| because it needs to report an exception back to the user. This

arch/s390/include/asm/ipl.h

136

void *ipl_report_finish(struct ipl_report *report);

arch/s390/include/asm/ipl.h

137

int ipl_report_free(struct ipl_report *report);

arch/s390/include/asm/ipl.h

138

int ipl_report_add_component(struct ipl_report *report, struct kexec_buf *kbuf,

arch/s390/include/asm/ipl.h

140

int ipl_report_add_certificate(struct ipl_report *report, void *key,

arch/s390/include/asm/kexec.h

69

struct ipl_report *report;

arch/s390/include/asm/sclp.h

191

int sclp_pci_report(struct zpci_report_error_header *report, u32 fh, u32 fid);

arch/s390/kernel/ipl.c

2392

int ipl_report_add_component(struct ipl_report *report, struct kexec_buf *kbuf,

arch/s390/kernel/ipl.c

2400

list_add_tail(&comp->list, &report->components);

arch/s390/kernel/ipl.c

2407

report->size += sizeof(comp->entry);

arch/s390/kernel/ipl.c

2412

int ipl_report_add_certificate(struct ipl_report *report, void *key,

arch/s390/kernel/ipl.c

2420

list_add_tail(&cert->list, &report->certificates);

arch/s390/kernel/ipl.c

2426

report->size += sizeof(cert->entry);

arch/s390/kernel/ipl.c

2427

report->size += cert->entry.len;

arch/s390/kernel/ipl.c

2434

struct ipl_report *report;

arch/s390/kernel/ipl.c

2436

report = vzalloc(sizeof(*report));

arch/s390/kernel/ipl.c

2437

if (!report)

arch/s390/kernel/ipl.c

2440

report->ipib = ipib;

arch/s390/kernel/ipl.c

2441

INIT_LIST_HEAD(&report->components);

arch/s390/kernel/ipl.c

2442

INIT_LIST_HEAD(&report->certificates);

arch/s390/kernel/ipl.c

2444

report->size = ALIGN(ipib->hdr.len, 8);

arch/s390/kernel/ipl.c

2445

report->size += sizeof(struct ipl_rl_hdr);

arch/s390/kernel/ipl.c

2446

report->size += sizeof(struct ipl_rb_components);

arch/s390/kernel/ipl.c

2447

report->size += sizeof(struct ipl_rb_certificates);

arch/s390/kernel/ipl.c

2449

return report;

arch/s390/kernel/ipl.c

2452

void *ipl_report_finish(struct ipl_report *report)

arch/s390/kernel/ipl.c

2462

buf = vzalloc(report->size);

arch/s390/kernel/ipl.c

2467

memcpy(ptr, report->ipib, report->ipib->hdr.len);

arch/s390/kernel/ipl.c

2472

ptr += report->ipib->hdr.len;

arch/s390/kernel/ipl.c

2481

list_for_each_entry(comp, &report->components, list) {

arch/s390/kernel/ipl.c

2490

list_for_each_entry(cert, &report->certificates, list) {

arch/s390/kernel/ipl.c

2497

list_for_each_entry(cert, &report->certificates, list) {

arch/s390/kernel/ipl.c

2502

BUG_ON(ptr > buf + report->size);

arch/s390/kernel/ipl.c

2507

int ipl_report_free(struct ipl_report *report)

arch/s390/kernel/ipl.c

2512

list_for_each_entry_safe(comp, ncomp, &report->components, list)

arch/s390/kernel/ipl.c

2515

list_for_each_entry_safe(cert, ncert, &report->certificates, list)

arch/s390/kernel/ipl.c

2518

vfree(report);

arch/s390/kernel/kexec_elf.c

56

ipl_report_add_component(data->report, &buf,

arch/s390/kernel/kexec_image.c

38

ipl_report_add_component(data->report, &buf,

arch/s390/kernel/machine_kexec_file.c

179

return ipl_report_add_component(data->report, &buf, 0, 0);

arch/s390/kernel/machine_kexec_file.c

207

addr = data->memsz + data->report->size;

arch/s390/kernel/machine_kexec_file.c

213

ipl_report_add_certificate(data->report, ptr, addr, len);

arch/s390/kernel/machine_kexec_file.c

219

buf.buffer = ipl_report_finish(data->report);

arch/s390/kernel/machine_kexec_file.c

222

buf.bufsz = data->report->size;

arch/s390/kernel/machine_kexec_file.c

251

data.report = ipl_report_init(&ipl_block);

arch/s390/kernel/machine_kexec_file.c

252

if (IS_ERR(data.report))

arch/s390/kernel/machine_kexec_file.c

253

return data.report;

arch/s390/kernel/machine_kexec_file.c

307

ipl_report_free(data.report);

arch/s390/pci/pci.c

1003

struct zpci_report_error_header *report)

arch/s390/pci/pci.c

1007

return sclp_pci_report(report, zdev->fh, zdev->fid);

arch/s390/pci/pci_report.c

108

struct zpci_report_error *report;

arch/s390/pci/pci_report.c

121

report = (void *)get_zeroed_page(GFP_KERNEL);

arch/s390/pci/pci_report.c

122

if (!report)

arch/s390/pci/pci_report.c

129

buf = report->data.log_data;

arch/s390/pci/pci_report.c

130

end = report->data.log_data + ZPCI_REPORT_DATA_SIZE;

arch/s390/pci/pci_report.c

142

report->header.version = 1;

arch/s390/pci/pci_report.c

143

report->header.action = SCLP_ERRNOTIFY_AQ_INFO_LOG;

arch/s390/pci/pci_report.c

144

report->header.length = buf - (char *)&report->data;

arch/s390/pci/pci_report.c

145

report->data.timestamp = ktime_get_clocktai_seconds();

arch/s390/pci/pci_report.c

146

report->data.err_log_id = ZPCI_ERR_LOG_ID_KERNEL_REPORT;

arch/s390/pci/pci_report.c

148

ret = sclp_pci_report(&report->header, zdev->fh, zdev->fid);

arch/s390/pci/pci_report.c

154

free_page((unsigned long)report);

arch/s390/pci/pci_sysfs.c

147

struct zpci_report_error_header *report = (void *) buf;

arch/s390/pci/pci_sysfs.c

153

if (off || (count < sizeof(*report)))

arch/s390/pci/pci_sysfs.c

156

ret = sclp_pci_report(report, zdev->fh, zdev->fid);

arch/x86/kvm/svm/sev.c

1448

void __user *report = u64_to_user_ptr(argp->data);

arch/x86/kvm/svm/sev.c

1499

if (copy_to_user(report, &params, sizeof(params)))

crypto/acompress.c

141

.report = crypto_acomp_report,

crypto/aead.c

183

.report = crypto_aead_report,

crypto/ahash.c

823

.report = crypto_ahash_report,

crypto/akcipher.c

92

.report = crypto_akcipher_report,

crypto/crypto_user.c

115

if (alg->cra_type && alg->cra_type->report) {

crypto/crypto_user.c

116

if (alg->cra_type->report(skb, alg))

crypto/internal.h

41

int (*report)(struct sk_buff *skb, struct crypto_alg *alg);

crypto/kpp.c

75

.report = crypto_kpp_report,

crypto/lskcipher.c

291

.report = crypto_lskcipher_report,

crypto/rng.c

94

.report = crypto_rng_report,

crypto/scompress.c

341

.report = crypto_scomp_report,

crypto/shash.c

367

.report = crypto_shash_report,

crypto/sig.c

71

.report = crypto_sig_report,

crypto/skcipher.c

618

.report = crypto_skcipher_report,

drivers/block/virtio_blk.c

662

struct virtio_blk_zone_report *report;

drivers/block/virtio_blk.c

671

report = virtblk_alloc_report_buffer(vblk, nr_zones, &buflen);

drivers/block/virtio_blk.c

672

if (!report)

drivers/block/virtio_blk.c

683

memset(report, 0, buflen);

drivers/block/virtio_blk.c

685

ret = virtblk_submit_zone_report(vblk, (char *)report,

drivers/block/virtio_blk.c

690

nz = min_t(u64, virtio64_to_cpu(vblk->vdev, report->nr_zones),

drivers/block/virtio_blk.c

696

ret = virtblk_parse_zone(vblk, &report->zones[i],

drivers/block/virtio_blk.c

702

report->zones[i].z_start) +

drivers/block/virtio_blk.c

714

kvfree(report);

drivers/firmware/arm_scmi/base.c

325

void *report, u32 *src_id)

drivers/firmware/arm_scmi/base.c

329

struct scmi_base_error_report *r = report;

drivers/firmware/arm_scmi/clock.c

1011

void *report, u32 *src_id)

drivers/firmware/arm_scmi/clock.c

1014

struct scmi_clock_rate_notif_report *r = report;

drivers/firmware/arm_scmi/notify.c

338

void *report;

drivers/firmware/arm_scmi/notify.c

391

u32 evt_key, void *report)

drivers/firmware/arm_scmi/notify.c

408

report);

drivers/firmware/arm_scmi/notify.c

473

void *report = NULL;

drivers/firmware/arm_scmi/notify.c

495

report = REVT_FILL_REPORT(r_evt, pd->eh->evt_id, pd->eh->timestamp,

drivers/firmware/arm_scmi/notify.c

497

r_evt->report, &src_id);

drivers/firmware/arm_scmi/notify.c

498

if (!report) {

drivers/firmware/arm_scmi/notify.c

507

scmi_lookup_and_call_event_chain(pd->ni, key, report);

drivers/firmware/arm_scmi/notify.c

511

scmi_lookup_and_call_event_chain(pd->ni, key, report);

drivers/firmware/arm_scmi/notify.c

813

r_evt->report = devm_kzalloc(ni->handle->dev,

drivers/firmware/arm_scmi/notify.c

815

if (!r_evt->report)

drivers/firmware/arm_scmi/notify.h

63

void *report, u32 *src_id);

drivers/firmware/arm_scmi/perf.c

1144

void *report, u32 *src_id)

drivers/firmware/arm_scmi/perf.c

1154

struct scmi_perf_limits_report *r = report;

drivers/firmware/arm_scmi/perf.c

1193

struct scmi_perf_level_report *r = report;

drivers/firmware/arm_scmi/power.c

272

void *report, u32 *src_id)

drivers/firmware/arm_scmi/power.c

275

struct scmi_power_state_changed_report *r = report;

drivers/firmware/arm_scmi/powercap.c

872

void *report, u32 *src_id)

drivers/firmware/arm_scmi/powercap.c

880

struct scmi_powercap_cap_changed_report *r = report;

drivers/firmware/arm_scmi/powercap.c

897

struct scmi_powercap_meas_changed_report *r = report;

drivers/firmware/arm_scmi/reset.c

305

void *report, u32 *src_id)

drivers/firmware/arm_scmi/reset.c

308

struct scmi_reset_issued_report *r = report;

drivers/firmware/arm_scmi/sensors.c

1051

void *report, u32 *src_id)

drivers/firmware/arm_scmi/sensors.c

1059

struct scmi_sensor_trip_point_report *r = report;

drivers/firmware/arm_scmi/sensors.c

1077

struct scmi_sensor_update_report *r = report;

drivers/firmware/arm_scmi/system.c

89

void *report, u32 *src_id)

drivers/firmware/arm_scmi/system.c

93

struct scmi_system_power_state_notifier_report *r = report;

drivers/firmware/arm_scmi/vendors/imx/imx-sm-bbm.c

178

void *report, u32 *src_id)

drivers/firmware/arm_scmi/vendors/imx/imx-sm-bbm.c

181

struct scmi_imx_bbm_notif_report *r = report;

drivers/firmware/arm_scmi/vendors/imx/imx-sm-misc.c

199

void *report, u32 *src_id)

drivers/firmware/arm_scmi/vendors/imx/imx-sm-misc.c

202

struct scmi_imx_misc_ctrl_notify_report *r = report;

drivers/gpu/drm/i915/i915_perf.c

1080

u8 *report = oa_buf_base + head;

drivers/gpu/drm/i915/i915_perf.c

1081

u32 *report32 = (void *)report;

drivers/gpu/drm/i915/i915_perf.c

1111

ret = append_oa_sample(stream, buf, count, offset, report);

drivers/gpu/drm/i915/i915_perf.c

463

static u64 oa_report_id(struct i915_perf_stream *stream, void *report)

drivers/gpu/drm/i915/i915_perf.c

465

return oa_report_header_64bit(stream) ? *(u64 *)report : *(u32 *)report;

drivers/gpu/drm/i915/i915_perf.c

468

static u64 oa_report_reason(struct i915_perf_stream *stream, void *report)

drivers/gpu/drm/i915/i915_perf.c

470

return (oa_report_id(stream, report) >> OAREPORT_REASON_SHIFT) &

drivers/gpu/drm/i915/i915_perf.c

476

static void oa_report_id_clear(struct i915_perf_stream *stream, u32 *report)

drivers/gpu/drm/i915/i915_perf.c

479

*(u64 *)report = 0;

drivers/gpu/drm/i915/i915_perf.c

481

*report = 0;

drivers/gpu/drm/i915/i915_perf.c

484

static bool oa_report_ctx_invalid(struct i915_perf_stream *stream, void *report)

drivers/gpu/drm/i915/i915_perf.c

486

return !(oa_report_id(stream, report) &

drivers/gpu/drm/i915/i915_perf.c

490

static u64 oa_timestamp(struct i915_perf_stream *stream, void *report)

drivers/gpu/drm/i915/i915_perf.c

493

*((u64 *)report + 1) :

drivers/gpu/drm/i915/i915_perf.c

494

*((u32 *)report + 1);

drivers/gpu/drm/i915/i915_perf.c

497

static void oa_timestamp_clear(struct i915_perf_stream *stream, u32 *report)

drivers/gpu/drm/i915/i915_perf.c

500

*(u64 *)&report[2] = 0;

drivers/gpu/drm/i915/i915_perf.c

502

report[1] = 0;

drivers/gpu/drm/i915/i915_perf.c

505

static u32 oa_context_id(struct i915_perf_stream *stream, u32 *report)

drivers/gpu/drm/i915/i915_perf.c

507

u32 ctx_id = oa_report_header_64bit(stream) ? report[4] : report[2];

drivers/gpu/drm/i915/i915_perf.c

512

static void oa_context_id_squash(struct i915_perf_stream *stream, u32 *report)

drivers/gpu/drm/i915/i915_perf.c

515

report[4] = INVALID_CTX_ID;

drivers/gpu/drm/i915/i915_perf.c

517

report[2] = INVALID_CTX_ID;

drivers/gpu/drm/i915/i915_perf.c

588

void *report = stream->oa_buffer.vaddr + tail;

drivers/gpu/drm/i915/i915_perf.c

590

if (oa_report_id(stream, report) ||

drivers/gpu/drm/i915/i915_perf.c

591

oa_timestamp(stream, report))

drivers/gpu/drm/i915/i915_perf.c

668

const u8 *report)

drivers/gpu/drm/i915/i915_perf.c

688

report_size_partial = oa_buf_end - report;

drivers/gpu/drm/i915/i915_perf.c

691

if (copy_to_user(buf, report, report_size_partial))

drivers/gpu/drm/i915/i915_perf.c

698

} else if (copy_to_user(buf, report, report_size)) {

drivers/gpu/drm/i915/i915_perf.c

770

u8 *report = oa_buf_base + head;

drivers/gpu/drm/i915/i915_perf.c

771

u32 *report32 = (void *)report;

drivers/gpu/drm/i915/i915_perf.c

780

reason = oa_report_reason(stream, report);

drivers/gpu/drm/i915/i915_perf.c

823

if (oa_report_ctx_invalid(stream, report) &&

drivers/gpu/drm/i915/i915_perf.c

875

report);

drivers/gpu/drm/xe/xe_oa.c

216

static u64 oa_report_id(struct xe_oa_stream *stream, void *report)

drivers/gpu/drm/xe/xe_oa.c

218

return oa_report_header_64bit(stream) ? *(u64 *)report : *(u32 *)report;

drivers/gpu/drm/xe/xe_oa.c

221

static void oa_report_id_clear(struct xe_oa_stream *stream, u32 *report)

drivers/gpu/drm/xe/xe_oa.c

224

*(u64 *)report = 0;

drivers/gpu/drm/xe/xe_oa.c

226

*report = 0;

drivers/gpu/drm/xe/xe_oa.c

229

static u64 oa_timestamp(struct xe_oa_stream *stream, void *report)

drivers/gpu/drm/xe/xe_oa.c

232

*((u64 *)report + 1) :

drivers/gpu/drm/xe/xe_oa.c

233

*((u32 *)report + 1);

drivers/gpu/drm/xe/xe_oa.c

236

static void oa_timestamp_clear(struct xe_oa_stream *stream, u32 *report)

drivers/gpu/drm/xe/xe_oa.c

239

*(u64 *)&report[2] = 0;

drivers/gpu/drm/xe/xe_oa.c

241

report[1] = 0;

drivers/gpu/drm/xe/xe_oa.c

278

void *report = stream->oa_buffer.vaddr + tail;

drivers/gpu/drm/xe/xe_oa.c

280

if (oa_report_id(stream, report) || oa_timestamp(stream, report))

drivers/gpu/drm/xe/xe_oa.c

315

size_t count, size_t *offset, const u8 *report)

drivers/gpu/drm/xe/xe_oa.c

327

report_size_partial = oa_buf_end - report;

drivers/gpu/drm/xe/xe_oa.c

330

if (copy_to_user(buf, report, report_size_partial))

drivers/gpu/drm/xe/xe_oa.c

337

} else if (copy_to_user(buf, report, report_size)) {

drivers/gpu/drm/xe/xe_oa.c

367

u8 *report = oa_buf_base + head;

drivers/gpu/drm/xe/xe_oa.c

369

ret = xe_oa_append_report(stream, buf, count, offset, report);

drivers/gpu/drm/xe/xe_oa.c

375

oa_report_id_clear(stream, (void *)report);

drivers/gpu/drm/xe/xe_oa.c

376

oa_timestamp_clear(stream, (void *)report);

drivers/gpu/drm/xe/xe_oa.c

379

u32 part = oa_buf_end - report;

drivers/gpu/drm/xe/xe_oa.c

383

memset(report, 0, report_size);

drivers/gpu/drm/xe/xe_oa.c

385

memset(report, 0, part);

drivers/hid/bpf/hid_bpf_dispatch.c

236

struct hid_report *report = report_enum->report_id_hash[j];

drivers/hid/bpf/hid_bpf_dispatch.c

238

if (report)

drivers/hid/bpf/hid_bpf_dispatch.c

239

max_report_len = max(max_report_len, hid_report_len(report));

drivers/hid/bpf/hid_bpf_dispatch.c

360

struct hid_report *report;

drivers/hid/bpf/hid_bpf_dispatch.c

380

report = hid_ops->hid_get_report(report_enum, buf);

drivers/hid/bpf/hid_bpf_dispatch.c

381

if (!report)

drivers/hid/bpf/hid_bpf_dispatch.c

384

report_len = hid_report_len(report);

drivers/hid/bpf/progs/Huion__Dial-2.bpf.c

533

__u8 report[8] = {PAD_REPORT_ID, 0x0, 0x0, 0x0, 0x00, button};

drivers/hid/bpf/progs/Huion__Dial-2.bpf.c

535

__builtin_memcpy(data, report, sizeof(report));

drivers/hid/bpf/progs/Huion__Dial-2.bpf.c

536

return sizeof(report);

drivers/hid/bpf/progs/Huion__Dial-2.bpf.c

552

__u8 report[] = {PAD_REPORT_ID, 0x0, 0x0, 0x0, dial, button};

drivers/hid/bpf/progs/Huion__Dial-2.bpf.c

554

__builtin_memcpy(data, report, sizeof(report));

drivers/hid/bpf/progs/Huion__Dial-2.bpf.c

555

return sizeof(report);

drivers/hid/bpf/progs/Huion__Inspiroy-2-M.bpf.c

489

__u8 report[6] = {PAD_REPORT_ID, 0x0, 0x0, 0x0, wheel, button};

drivers/hid/bpf/progs/Huion__Inspiroy-2-M.bpf.c

491

__builtin_memcpy(data, report, sizeof(report));

drivers/hid/bpf/progs/Huion__Inspiroy-2-M.bpf.c

492

return sizeof(report);

drivers/hid/bpf/progs/Huion__Inspiroy-2-S.bpf.c

483

__u8 report[6] = {PAD_REPORT_ID, 0x0, 0x0, 0x0, wheel, button};

drivers/hid/bpf/progs/Huion__Inspiroy-2-S.bpf.c

485

__builtin_memcpy(data, report, sizeof(report));

drivers/hid/bpf/progs/Huion__Inspiroy-2-S.bpf.c

486

return sizeof(report);

drivers/hid/bpf/progs/XPPen__Deco01V3.bpf.c

278

__u8 report[8] = {PAD_REPORT_ID, button_mask, 0x00};

drivers/hid/bpf/progs/XPPen__Deco01V3.bpf.c

280

__builtin_memcpy(data, report, sizeof(report));

drivers/hid/bpf/progs/XPPen__Deco02.bpf.c

341

__u8 report[8] = { REPORT_ID_BUTTONS, dial_code, button_mask, 0x00 };

drivers/hid/bpf/progs/XPPen__Deco02.bpf.c

343

__builtin_memcpy(data, report, sizeof(report));

drivers/hid/bpf/progs/XPPen__DecoMini4.bpf.c

196

__u8 report[8] = {PAD_REPORT_ID, button_mask, 0x00};

drivers/hid/bpf/progs/XPPen__DecoMini4.bpf.c

198

__builtin_memcpy(data, report, sizeof(report));

drivers/hid/hid-alps.c

435

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-apple.c

625

struct hid_report *report;

drivers/hid/hid-apple.c

631

report = report_enum->report_id_hash[hdev->battery_report_id];

drivers/hid/hid-apple.c

633

if (!report || report->maxfield < 1)

drivers/hid/hid-apple.c

639

hid_hw_request(hdev, report, HID_REQ_GET_REPORT);

drivers/hid/hid-apple.c

780

struct hid_report *report;

drivers/hid/hid-apple.c

782

list_for_each_entry(report, &hdev->report_enum[HID_INPUT_REPORT].report_list, list) {

drivers/hid/hid-apple.c

783

for (i = 0; i < report->maxfield; i++) {

drivers/hid/hid-apple.c

784

hid = report->field[i]->usage->hid;

drivers/hid/hid-appleir.c

182

static int appleir_raw_event(struct hid_device *hid, struct hid_report *report,

drivers/hid/hid-appletb-bl.c

124

if (aux1_field->report != brightness_field->report)

drivers/hid/hid-appletb-bl.c

49

struct hid_report *report = bl->brightness_field->report;

drivers/hid/hid-appletb-bl.c

50

struct hid_device *hdev = report->device;

drivers/hid/hid-appletb-bl.c

75

hid_hw_request(hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-appletb-kbd.c

107

hid_hw_request(hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-appletb-kbd.c

91

struct hid_report *report = kbd->mode_field->report;

drivers/hid/hid-appletb-kbd.c

92

struct hid_device *hdev = report->device;

drivers/hid/hid-asus.c

386

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-asus.c

403

if (report->id == FEATURE_KBD_LED_REPORT_ID1 || report->id == FEATURE_KBD_LED_REPORT_ID2)

drivers/hid/hid-asus.c

406

if (report->id == FEATURE_KBD_REPORT_ID) {

drivers/hid/hid-asus.c

951

hi->report->id != T100CHI_MOUSE_REPORT_ID)

drivers/hid/hid-asus.c

956

switch (hi->report->id) {

drivers/hid/hid-axff.c

109

axff->report = report;

drivers/hid/hid-axff.c

110

hid_hw_request(hid, axff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-axff.c

28

struct hid_report *report;

drivers/hid/hid-axff.c

35

struct hid_report *report = axff->report;

drivers/hid/hid-axff.c

48

for (i = 0; i < report->maxfield; i++) {

drivers/hid/hid-axff.c

49

for (j = 0; j < report->field[i]->report_count; j++) {

drivers/hid/hid-axff.c

50

report->field[i]->value[j] =

drivers/hid/hid-axff.c

57

hid_hw_request(hid, axff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-axff.c

65

struct hid_report *report;

drivers/hid/hid-axff.c

85

report = list_first_entry(report_list, struct hid_report, list);

drivers/hid/hid-axff.c

86

for (i = 0; i < report->maxfield; i++) {

drivers/hid/hid-axff.c

87

for (j = 0; j < report->field[i]->report_count; j++) {

drivers/hid/hid-axff.c

88

report->field[i]->value[j] = 0x00;

drivers/hid/hid-betopff.c

115

betopff->report = report;

drivers/hid/hid-betopff.c

116

hid_hw_request(hid, betopff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-betopff.c

34

struct hid_report *report;

drivers/hid/hid-betopff.c

47

betopff->report->field[2]->value[0] = left / 256;

drivers/hid/hid-betopff.c

48

betopff->report->field[3]->value[0] = right / 256;

drivers/hid/hid-betopff.c

50

hid_hw_request(hid, betopff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-betopff.c

58

struct hid_report *report;

drivers/hid/hid-betopff.c

79

report = list_first_entry(report_list, struct hid_report, list);

drivers/hid/hid-betopff.c

88

if (report->maxfield < 4) {

drivers/hid/hid-betopff.c

90

report->maxfield);

drivers/hid/hid-betopff.c

93

for (i = 0; i < report->maxfield; i++) {

drivers/hid/hid-betopff.c

94

if (report->field[i]->report_count < 1) {

drivers/hid/hid-betopff.c

98

for (j = 0; j < report->field[i]->report_count; j++) {

drivers/hid/hid-betopff.c

99

report->field[i]->value[j] = 0x00;

drivers/hid/hid-bigbenff.c

176

struct hid_report *report;

drivers/hid/hid-bigbenff.c

202

struct hid_field *report_field = bigben->report->field[0];

drivers/hid/hid-bigbenff.c

209

buf = hid_alloc_report_buf(bigben->report, GFP_KERNEL);

drivers/hid/hid-bigbenff.c

213

len = hid_report_len(bigben->report);

drivers/hid/hid-bigbenff.c

229

hid_output_report(bigben->report, buf);

drivers/hid/hid-bigbenff.c

235

hid_hw_raw_request(bigben->hid, bigben->report->id, buf, len,

drivers/hid/hid-bigbenff.c

236

bigben->report->type, HID_REQ_SET_REPORT);

drivers/hid/hid-bigbenff.c

253

hid_output_report(bigben->report, buf);

drivers/hid/hid-bigbenff.c

259

hid_hw_raw_request(bigben->hid, bigben->report->id, buf, len,

drivers/hid/hid-bigbenff.c

260

bigben->report->type, HID_REQ_SET_REPORT);

drivers/hid/hid-bigbenff.c

398

bigben->report = hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 8);

drivers/hid/hid-bigbenff.c

399

if (!bigben->report) {

drivers/hid/hid-chicony.c

26

static int ch_report_wireless(struct hid_report *report, u8 *data, int size)

drivers/hid/hid-chicony.c

28

struct hid_device *hdev = report->device;

drivers/hid/hid-chicony.c

31

if (report->id != CH_WIRELESS_CTL_REPORT_ID || report->maxfield != 1)

drivers/hid/hid-chicony.c

34

input = report->field[0]->hidinput->input;

drivers/hid/hid-chicony.c

49

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-chicony.c

51

if (report->application == HID_GD_WIRELESS_RADIO_CTLS)

drivers/hid/hid-chicony.c

52

return ch_report_wireless(report, data, size);

drivers/hid/hid-cmedia.c

97

static int cmhid_raw_event(struct hid_device *hid, struct hid_report *report,

drivers/hid/hid-core.c

103

report->id = id;

drivers/hid/hid-core.c

1036

struct hid_report *report;

drivers/hid/hid-core.c

104

report->type = type;

drivers/hid/hid-core.c

105

report->size = 0;

drivers/hid/hid-core.c

1058

report = list_first_entry_or_null(

drivers/hid/hid-core.c

106

report->device = device;

drivers/hid/hid-core.c

1062

report = hid->report_enum[type].report_id_hash[id];

drivers/hid/hid-core.c

1064

if (!report) {

drivers/hid/hid-core.c

1068

if (report->maxfield <= field_index) {

drivers/hid/hid-core.c

107

report->application = application;

drivers/hid/hid-core.c

1073

if (report->field[field_index]->report_count < report_counts) {

drivers/hid/hid-core.c

1078

return report;

drivers/hid/hid-core.c

108

report_enum->report_id_hash[id] = report;

drivers/hid/hid-core.c

110

list_add_tail(&report->list, &report_enum->report_list);

drivers/hid/hid-core.c

111

INIT_LIST_HEAD(&report->field_entry_list);

drivers/hid/hid-core.c

113

return report;

drivers/hid/hid-core.c

121

static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages)

drivers/hid/hid-core.c

125

if (report->maxfield == HID_MAX_FIELDS) {

drivers/hid/hid-core.c

126

hid_err(report->device, "too many fields in report\n");

drivers/hid/hid-core.c

136

field->index = report->maxfield++;

drivers/hid/hid-core.c

137

report->field[field->index] = field;

drivers/hid/hid-core.c

1395

static u32 __extract(u8 *report, unsigned offset, int n)

drivers/hid/hid-core.c

1405

value |= ((u32)report[idx] >> bit_shift) << bit_nr;

drivers/hid/hid-core.c

1416

u32 hid_field_extract(const struct hid_device *hid, u8 *report,

drivers/hid/hid-core.c

142

field->report = report;

drivers/hid/hid-core.c

1425

return __extract(report, offset, n);

drivers/hid/hid-core.c

1438

static void __implement(u8 *report, unsigned offset, int n, u32 value)

drivers/hid/hid-core.c

1445

report[idx] &= ~(0xff << bit_shift);

drivers/hid/hid-core.c

1446

report[idx] |= value << bit_shift;

drivers/hid/hid-core.c

1457

report[idx] &= ~(bit_mask << bit_shift);

drivers/hid/hid-core.c

1458

report[idx] |= value << bit_shift;

drivers/hid/hid-core.c

1462

static void implement(const struct hid_device *hid, u8 *report,

drivers/hid/hid-core.c

1480

__implement(report, offset, n, value);

drivers/hid/hid-core.c

1504

static int hid_match_report(struct hid_device *hid, struct hid_report *report)

drivers/hid/hid-core.c

1513

id->report_type == report->type)

drivers/hid/hid-core.c

1693

struct hid_report *report,

drivers/hid/hid-core.c

1702

for (a = 0; a < report->maxfield; a++)

drivers/hid/hid-core.c

1703

hid_input_fetch_field(hid, report->field[a], data);

drivers/hid/hid-core.c

1705

if (!list_empty(&report->field_entry_list)) {

drivers/hid/hid-core.c

1708

&report->field_entry_list,

drivers/hid/hid-core.c

1723

for (a = 0; a < report->maxfield; a++) {

drivers/hid/hid-core.c

1724

field = report->field[a];

drivers/hid/hid-core.c

1732

for (a = 0; a < report->maxfield; a++) {

drivers/hid/hid-core.c

1733

field = report->field[a];

drivers/hid/hid-core.c

1751

struct hid_report *report,

drivers/hid/hid-core.c

1764

&report->field_entry_list,

drivers/hid/hid-core.c

1777

list_add_tail(&entry->list, &report->field_entry_list);

drivers/hid/hid-core.c

1781

struct hid_report *report)

drivers/hid/hid-core.c

1789

for (a = 0; a < report->maxfield; a++) {

drivers/hid/hid-core.c

1790

field = report->field[a];

drivers/hid/hid-core.c

1803

report->field_entries = entries;

drivers/hid/hid-core.c

1813

for (a = 0; a < report->maxfield; a++) {

drivers/hid/hid-core.c

1814

field = report->field[a];

drivers/hid/hid-core.c

1818

__hid_insert_field_entry(hid, report,

drivers/hid/hid-core.c

1824

__hid_insert_field_entry(hid, report, &entries[usages],

drivers/hid/hid-core.c

1833

struct hid_report *report;

drivers/hid/hid-core.c

1836

list_for_each_entry(report, &report_enum->report_list, list)

drivers/hid/hid-core.c

1837

hid_report_process_ordering(hid, report);

drivers/hid/hid-core.c

1865

static size_t hid_compute_report_size(struct hid_report *report)

drivers/hid/hid-core.c

1867

if (report->size)

drivers/hid/hid-core.c

1868

return ((report->size - 1) >> 3) + 1;

drivers/hid/hid-core.c

1878

void hid_output_report(struct hid_report *report, __u8 *data)

drivers/hid/hid-core.c

1882

if (report->id > 0)

drivers/hid/hid-core.c

1883

*data++ = report->id;

drivers/hid/hid-core.c

1885

memset(data, 0, hid_compute_report_size(report));

drivers/hid/hid-core.c

1886

for (n = 0; n < report->maxfield; n++)

drivers/hid/hid-core.c

1887

hid_output_field(report->device, report->field[n], data);

drivers/hid/hid-core.c

1894

u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags)

drivers/hid/hid-core.c

1904

u32 len = hid_report_len(report) + 7 + (report->id == 0);

drivers/hid/hid-core.c

1925

hid_dump_input(field->report->device, field->usage + offset, value);

drivers/hid/hid-core.c

1928

hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n",

drivers/hid/hid-core.c

1934

hid_err(field->report->device, "value %d is out of range\n", value);

drivers/hid/hid-core.c

1947

struct hid_report *report;

drivers/hid/hid-core.c

1950

list_for_each_entry(report, report_list, list) {

drivers/hid/hid-core.c

1951

if (report->application != application)

drivers/hid/hid-core.c

1954

for (i = 0; i < report->maxfield; i++) {

drivers/hid/hid-core.c

1955

struct hid_field *field = report->field[i];

drivers/hid/hid-core.c

1971

struct hid_report *report;

drivers/hid/hid-core.c

1978

report = report_enum->report_id_hash[n];

drivers/hid/hid-core.c

1979

if (report == NULL)

drivers/hid/hid-core.c

1982

return report;

drivers/hid/hid-core.c

1989

int __hid_request(struct hid_device *hid, struct hid_report *report,

drivers/hid/hid-core.c

1996

buf = hid_alloc_report_buf(report, GFP_KERNEL);

drivers/hid/hid-core.c

2001

len = hid_report_len(report);

drivers/hid/hid-core.c

2003

if (report->id == 0) {

drivers/hid/hid-core.c

2010

hid_output_report(report, data_buf);

drivers/hid/hid-core.c

2012

ret = hid_hw_raw_request(hid, report->id, buf, len, report->type, reqtype);

drivers/hid/hid-core.c

2019

hid_input_report(hid, report->type, buf, ret, 0);

drivers/hid/hid-core.c

2033

struct hid_report *report;

drivers/hid/hid-core.c

2040

report = hid_get_report(report_enum, data);

drivers/hid/hid-core.c

2041

if (!report)

drivers/hid/hid-core.c

2049

rsize = hid_compute_report_size(report);

drivers/hid/hid-core.c

2061

report->id, rsize, csize);

drivers/hid/hid-core.c

2067

hid->hiddev_report_event(hid, report);

drivers/hid/hid-core.c

2074

if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) {

drivers/hid/hid-core.c

2075

hid_process_report(hid, report, cdata, interrupt);

drivers/hid/hid-core.c

2077

if (hdrv && hdrv->report)

drivers/hid/hid-core.c

2078

hdrv->report(hid, report);

drivers/hid/hid-core.c

2082

hidinput_report_event(hid, report);

drivers/hid/hid-core.c

2095

struct hid_report *report;

drivers/hid/hid-core.c

2132

report = hid_get_report(report_enum, data);

drivers/hid/hid-core.c

2134

if (!report) {

drivers/hid/hid-core.c

2139

if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {

drivers/hid/hid-core.c

2140

ret = hdrv->raw_event(hid, report, data, size);

drivers/hid/hid-core.c

2465

struct hid_report *report, enum hid_class_request reqtype)

drivers/hid/hid-core.c

2468

return hdev->ll_driver->request(hdev, report, reqtype);

drivers/hid/hid-core.c

2470

__hid_request(hdev, report, reqtype);

drivers/hid/hid-core.c

289

struct hid_report *report;

drivers/hid/hid-core.c

299

report = hid_register_report(parser->device, report_type,

drivers/hid/hid-core.c

301

if (!report) {

drivers/hid/hid-core.c

319

offset = report->size;

drivers/hid/hid-core.c

320

report->size += parser->global.report_size * parser->global.report_count;

drivers/hid/hid-core.c

326

if (report->size > (max_buffer_size - 1) << 3) {

drivers/hid/hid-core.c

337

field = hid_register_field(report, usages);

drivers/hid/hid-core.c

693

static void hid_free_report(struct hid_report *report)

drivers/hid/hid-core.c

697

kfree(report->field_entries);

drivers/hid/hid-core.c

699

for (n = 0; n < report->maxfield; n++)

drivers/hid/hid-core.c

700

kvfree(report->field[n]);

drivers/hid/hid-core.c

701

kfree(report);

drivers/hid/hid-core.c

716

struct hid_report *report = report_enum->report_id_hash[j];

drivers/hid/hid-core.c

717

if (report)

drivers/hid/hid-core.c

718

hid_free_report(report);

drivers/hid/hid-core.c

89

struct hid_report *report;

drivers/hid/hid-core.c

96

report = kzalloc_obj(struct hid_report);

drivers/hid/hid-core.c

97

if (!report)

drivers/hid/hid-cougar.c

257

static int cougar_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-cp2112.c

1000

ret = cp2112_hid_get(hdev, number, (u8 *)&report.contents,

drivers/hid/hid-cp2112.c

1001

sizeof(report.contents), HID_FEATURE_REPORT);

drivers/hid/hid-cp2112.c

101

u8 report; /* CP2112_DATA_READ_REQUEST */

drivers/hid/hid-cp2112.c

1010

if (report.length < 2) {

drivers/hid/hid-cp2112.c

1012

kattr->attr.name, report.length);

drivers/hid/hid-cp2112.c

1016

length = report.length > ret - 1 ? ret - 1 : report.length;

drivers/hid/hid-cp2112.c

1017

length = (length - 2) / sizeof(report.string[0]);

drivers/hid/hid-cp2112.c

1018

ret = utf16s_to_utf8s(report.string, length, UTF16_LITTLE_ENDIAN, buf,

drivers/hid/hid-cp2112.c

107

u8 report; /* CP2112_DATA_WRITE_READ_REQUEST */

drivers/hid/hid-cp2112.c

115

u8 report; /* CP2112_DATA_WRITE_REQUEST */

drivers/hid/hid-cp2112.c

122

u8 report; /* CP2112_DATA_READ_FORCE_SEND */

drivers/hid/hid-cp2112.c

127

u8 report; /* CP2112_TRANSFER_STATUS_RESPONSE */

drivers/hid/hid-cp2112.c

137

u8 report; /* CP2112_*_STRING */

drivers/hid/hid-cp2112.c

1384

static int cp2112_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-cp2112.c

403

struct cp2112_force_read_report report;

drivers/hid/hid-cp2112.c

408

report.report = CP2112_DATA_READ_FORCE_SEND;

drivers/hid/hid-cp2112.c

409

report.length = cpu_to_be16(size);

drivers/hid/hid-cp2112.c

413

ret = cp2112_hid_output(hdev, &report.report, sizeof(report),

drivers/hid/hid-cp2112.c

436

struct cp2112_read_req_report *report = buf;

drivers/hid/hid-cp2112.c

441

report->report = CP2112_DATA_READ_REQUEST;

drivers/hid/hid-cp2112.c

442

report->slave_address = slave_address << 1;

drivers/hid/hid-cp2112.c

443

report->length = cpu_to_be16(length);

drivers/hid/hid-cp2112.c

444

return sizeof(*report);

drivers/hid/hid-cp2112.c

450

struct cp2112_write_read_req_report *report = buf;

drivers/hid/hid-cp2112.c

453

|| data_length > sizeof(report->target_address) - 1)

drivers/hid/hid-cp2112.c

456

report->report = CP2112_DATA_WRITE_READ_REQUEST;

drivers/hid/hid-cp2112.c

457

report->slave_address = slave_address << 1;

drivers/hid/hid-cp2112.c

458

report->length = cpu_to_be16(length);

drivers/hid/hid-cp2112.c

459

report->target_address_length = data_length + 1;

drivers/hid/hid-cp2112.c

460

report->target_address[0] = command;

drivers/hid/hid-cp2112.c

461

memcpy(&report->target_address[1], data, data_length);

drivers/hid/hid-cp2112.c

468

struct cp2112_write_req_report *report = buf;

drivers/hid/hid-cp2112.c

470

if (data_length > sizeof(report->data) - 1)

drivers/hid/hid-cp2112.c

473

report->report = CP2112_DATA_WRITE_REQUEST;

drivers/hid/hid-cp2112.c

474

report->slave_address = slave_address << 1;

drivers/hid/hid-cp2112.c

475

report->length = data_length + 1;

drivers/hid/hid-cp2112.c

476

report->data[0] = command;

drivers/hid/hid-cp2112.c

477

memcpy(&report->data[1], data, data_length);

drivers/hid/hid-cp2112.c

484

struct cp2112_write_req_report *report = buf;

drivers/hid/hid-cp2112.c

486

if (data_length > sizeof(report->data))

drivers/hid/hid-cp2112.c

489

report->report = CP2112_DATA_WRITE_REQUEST;

drivers/hid/hid-cp2112.c

490

report->slave_address = slave_address << 1;

drivers/hid/hid-cp2112.c

491

report->length = data_length;

drivers/hid/hid-cp2112.c

492

memcpy(report->data, data, data_length);

drivers/hid/hid-cp2112.c

500

struct cp2112_write_read_req_report *report = buf;

drivers/hid/hid-cp2112.c

503

addr_length > sizeof(report->target_address))

drivers/hid/hid-cp2112.c

506

report->report = CP2112_DATA_WRITE_READ_REQUEST;

drivers/hid/hid-cp2112.c

507

report->slave_address = slave_address << 1;

drivers/hid/hid-cp2112.c

508

report->length = cpu_to_be16(read_length);

drivers/hid/hid-cp2112.c

509

report->target_address_length = addr_length;

drivers/hid/hid-cp2112.c

510

memcpy(report->target_address, addr, addr_length);

drivers/hid/hid-cp2112.c

77

u8 report; /* CP2112_SMBUS_CONFIG */

drivers/hid/hid-cp2112.c

870

if (WARN_ON(cfg->report != CP2112_USB_CONFIG))

drivers/hid/hid-cp2112.c

88

u8 report; /* CP2112_USB_CONFIG */

drivers/hid/hid-cp2112.c

967

struct cp2112_string_report report;

drivers/hid/hid-cp2112.c

970

memset(&report, 0, sizeof(report));

drivers/hid/hid-cp2112.c

973

report.string, ARRAY_SIZE(report.string));

drivers/hid/hid-cp2112.c

974

report.report = number;

drivers/hid/hid-cp2112.c

975

report.length = ret * sizeof(report.string[0]) + 2;

drivers/hid/hid-cp2112.c

976

report.type = USB_DT_STRING;

drivers/hid/hid-cp2112.c

978

ret = cp2112_hid_output(hdev, &report.report, report.length + 1,

drivers/hid/hid-cp2112.c

980

if (ret != report.length + 1) {

drivers/hid/hid-cp2112.c

996

struct cp2112_string_report report;

drivers/hid/hid-creative-sb0540.c

150

struct hid_report *report, u8 *data, int len)

drivers/hid/hid-debug.c

3055

struct hid_report *report;

drivers/hid/hid-debug.c

3064

report = (struct hid_report *) list;

drivers/hid/hid-debug.c

3067

if (report->id)

drivers/hid/hid-debug.c

3068

seq_printf(f, "(%d)", report->id);

drivers/hid/hid-debug.c

3069

seq_printf(f, "[%s]", table[report->type]);

drivers/hid/hid-debug.c

3071

for (k = 0; k < report->maxfield; k++) {

drivers/hid/hid-debug.c

3074

hid_dump_field(report->field[k], 6, f);

drivers/hid/hid-debug.c

3635

struct hid_report *report;

drivers/hid/hid-debug.c

3639

list_for_each_entry(report, &hid->report_enum[k].report_list, list) {

drivers/hid/hid-debug.c

3640

for (i = 0; i < report->maxfield; i++) {

drivers/hid/hid-debug.c

3641

for ( j = 0; j < report->field[i]->maxusage; j++) {

drivers/hid/hid-debug.c

3642

usage = report->field[i]->usage + j;

drivers/hid/hid-dr.c

102

if (report->field[0]->report_count < 7) {

drivers/hid/hid-dr.c

119

drff->report = report;

drivers/hid/hid-dr.c

120

drff->report->field[0]->value[0] = 0xf3;

drivers/hid/hid-dr.c

121

drff->report->field[0]->value[1] = 0x00;

drivers/hid/hid-dr.c

122

drff->report->field[0]->value[2] = 0x00;

drivers/hid/hid-dr.c

123

drff->report->field[0]->value[3] = 0x00;

drivers/hid/hid-dr.c

124

drff->report->field[0]->value[4] = 0x00;

drivers/hid/hid-dr.c

125

drff->report->field[0]->value[5] = 0x00;

drivers/hid/hid-dr.c

126

drff->report->field[0]->value[6] = 0x00;

drivers/hid/hid-dr.c

127

hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-dr.c

28

struct hid_report *report;

drivers/hid/hid-dr.c

53

drff->report->field[0]->value[0] = 0x51;

drivers/hid/hid-dr.c

54

drff->report->field[0]->value[1] = 0x00;

drivers/hid/hid-dr.c

55

drff->report->field[0]->value[2] = weak;

drivers/hid/hid-dr.c

56

drff->report->field[0]->value[4] = strong;

drivers/hid/hid-dr.c

57

hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-dr.c

59

drff->report->field[0]->value[0] = 0xfa;

drivers/hid/hid-dr.c

60

drff->report->field[0]->value[1] = 0xfe;

drivers/hid/hid-dr.c

62

drff->report->field[0]->value[0] = 0xf3;

drivers/hid/hid-dr.c

63

drff->report->field[0]->value[1] = 0x00;

drivers/hid/hid-dr.c

66

drff->report->field[0]->value[2] = 0x00;

drivers/hid/hid-dr.c

67

drff->report->field[0]->value[4] = 0x00;

drivers/hid/hid-dr.c

69

hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-dr.c

77

struct hid_report *report;

drivers/hid/hid-dr.c

96

report = list_first_entry(report_list, struct hid_report, list);

drivers/hid/hid-dr.c

97

if (report->maxfield < 1) {

drivers/hid/hid-elan.c

360

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-elan.c

70

if (field->report->id == ELAN_SINGLE_FINGER ||

drivers/hid/hid-elan.c

71

field->report->id == ELAN_MT_FIRST_FINGER ||

drivers/hid/hid-elan.c

72

field->report->id == ELAN_MT_SECOND_FINGER ||

drivers/hid/hid-elan.c

73

field->report->id == ELAN_MT_I2C)

drivers/hid/hid-elo.c

80

static int elo_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-elo.c

90

switch (report->id) {

drivers/hid/hid-elo.c

99

hid_info(hdev, "unknown report type %d\n", report->id);

drivers/hid/hid-emsff.c

19

struct hid_report *report;

drivers/hid/hid-emsff.c

37

emsff->report->field[0]->value[1] = weak;

drivers/hid/hid-emsff.c

38

emsff->report->field[0]->value[2] = strong;

drivers/hid/hid-emsff.c

41

hid_hw_request(hid, emsff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-emsff.c

49

struct hid_report *report;

drivers/hid/hid-emsff.c

68

report = list_first_entry(report_list, struct hid_report, list);

drivers/hid/hid-emsff.c

69

if (report->maxfield < 1) {

drivers/hid/hid-emsff.c

74

if (report->field[0]->report_count < 7) {

drivers/hid/hid-emsff.c

91

emsff->report = report;

drivers/hid/hid-emsff.c

92

emsff->report->field[0]->value[0] = 0x01;

drivers/hid/hid-emsff.c

93

emsff->report->field[0]->value[1] = 0x00;

drivers/hid/hid-emsff.c

94

emsff->report->field[0]->value[2] = 0x00;

drivers/hid/hid-emsff.c

95

emsff->report->field[0]->value[3] = 0x00;

drivers/hid/hid-emsff.c

96

emsff->report->field[0]->value[4] = 0x00;

drivers/hid/hid-emsff.c

97

emsff->report->field[0]->value[5] = 0x00;

drivers/hid/hid-emsff.c

98

emsff->report->field[0]->value[6] = 0x00;

drivers/hid/hid-emsff.c

99

hid_hw_request(hid, emsff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-ft260.c

1065

static int ft260_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-ft260.c

1071

if (xfer->report >= FT260_I2C_REPORT_MIN &&

drivers/hid/hid-ft260.c

1072

xfer->report <= FT260_I2C_REPORT_MAX) {

drivers/hid/hid-ft260.c

1073

ft260_dbg("i2c resp: rep %#02x len %d\n", xfer->report,

drivers/hid/hid-ft260.c

1079

xfer->report, xfer->length);

drivers/hid/hid-ft260.c

1091

hid_err(hdev, "unhandled report %#02x\n", xfer->report);

drivers/hid/hid-ft260.c

140

u8 report; /* FT260_CHIP_VERSION */

drivers/hid/hid-ft260.c

146

u8 report; /* FT260_SYSTEM_SETTINGS */

drivers/hid/hid-ft260.c

168

u8 report; /* FT260_I2C_STATUS */

drivers/hid/hid-ft260.c

177

u8 report; /* FT260_SYSTEM_SETTINGS */

drivers/hid/hid-ft260.c

183

u8 report; /* FT260_SYSTEM_SETTINGS */

drivers/hid/hid-ft260.c

189

u8 report; /* FT260_SYSTEM_SETTINGS */

drivers/hid/hid-ft260.c

196

u8 report; /* FT260_SYSTEM_SETTINGS */

drivers/hid/hid-ft260.c

201

u8 report; /* FT260_SYSTEM_SETTINGS */

drivers/hid/hid-ft260.c

209

u8 report; /* FT260_I2C_REPORT */

drivers/hid/hid-ft260.c

217

u8 report; /* FT260_I2C_READ_REQ */

drivers/hid/hid-ft260.c

224

u8 report; /* FT260_I2C_REPORT */

drivers/hid/hid-ft260.c

291

struct ft260_set_i2c_reset_report report;

drivers/hid/hid-ft260.c

294

report.request = FT260_SET_I2C_RESET;

drivers/hid/hid-ft260.c

296

ret = ft260_hid_feature_report_set(hdev, (u8 *)&report, sizeof(report));

drivers/hid/hid-ft260.c

309

struct ft260_get_i2c_status_report report;

drivers/hid/hid-ft260.c

314

(u8 *)&report, sizeof(report));

drivers/hid/hid-ft260.c

322

report.bus_status);

drivers/hid/hid-ft260.c

327

(u8 *)&report, sizeof(report));

drivers/hid/hid-ft260.c

333

dev->clock = le16_to_cpu(report.clock);

drivers/hid/hid-ft260.c

334

ft260_dbg("bus_status %#02x, clock %u\n", report.bus_status,

drivers/hid/hid-ft260.c

337

if (report.bus_status & (FT260_I2C_STATUS_CTRL_BUSY | bus_busy))

drivers/hid/hid-ft260.c

345

if (report.bus_status & FT260_I2C_STATUS_ERROR) {

drivers/hid/hid-ft260.c

346

hid_err(hdev, "i2c bus error: %#02x\n", report.bus_status);

drivers/hid/hid-ft260.c

439

rep->report = FT260_I2C_DATA_REPORT_ID(wr_len);

drivers/hid/hid-ft260.c

446

rep->report, addr, idx, len, wr_len,

drivers/hid/hid-ft260.c

483

rep->report = FT260_I2C_DATA_REPORT_ID(len);

drivers/hid/hid-ft260.c

489

rep->report, addr, cmd, rep->length, len);

drivers/hid/hid-ft260.c

519

rep.report = FT260_I2C_READ_REQ;

drivers/hid/hid-ft260.c

525

rep.report, rep.address, len, rd_len, flag);

drivers/hid/hid-ft260.c

876

rep.report = id; \

drivers/hid/hid-gaff.c

111

gaff->report = report;

drivers/hid/hid-gaff.c

112

gaff->report->field[0]->value[0] = 0x51;

drivers/hid/hid-gaff.c

113

gaff->report->field[0]->value[1] = 0x00;

drivers/hid/hid-gaff.c

114

gaff->report->field[0]->value[2] = 0x00;

drivers/hid/hid-gaff.c

115

gaff->report->field[0]->value[3] = 0x00;

drivers/hid/hid-gaff.c

116

hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-gaff.c

118

gaff->report->field[0]->value[0] = 0xfa;

drivers/hid/hid-gaff.c

119

gaff->report->field[0]->value[1] = 0xfe;

drivers/hid/hid-gaff.c

121

hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-gaff.c

26

struct hid_report *report;

drivers/hid/hid-gaff.c

44

gaff->report->field[0]->value[0] = 0x51;

drivers/hid/hid-gaff.c

45

gaff->report->field[0]->value[1] = 0x0;

drivers/hid/hid-gaff.c

46

gaff->report->field[0]->value[2] = right;

drivers/hid/hid-gaff.c

47

gaff->report->field[0]->value[3] = 0;

drivers/hid/hid-gaff.c

48

gaff->report->field[0]->value[4] = left;

drivers/hid/hid-gaff.c

49

gaff->report->field[0]->value[5] = 0;

drivers/hid/hid-gaff.c

51

hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-gaff.c

53

gaff->report->field[0]->value[0] = 0xfa;

drivers/hid/hid-gaff.c

54

gaff->report->field[0]->value[1] = 0xfe;

drivers/hid/hid-gaff.c

55

gaff->report->field[0]->value[2] = 0x0;

drivers/hid/hid-gaff.c

56

gaff->report->field[0]->value[4] = 0x0;

drivers/hid/hid-gaff.c

58

hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-gaff.c

66

struct hid_report *report;

drivers/hid/hid-gaff.c

88

report = list_entry(report_ptr, struct hid_report, list);

drivers/hid/hid-gaff.c

89

if (report->maxfield < 1) {

drivers/hid/hid-gaff.c

94

if (report->field[0]->report_count < 6) {

drivers/hid/hid-gfrm.c

50

static int gfrm_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-goodix-spi.c

276

static int goodix_hid_get_report_length(struct hid_report *report)

drivers/hid/hid-goodix-spi.c

278

return ((report->size - 1) >> 3) + 1 +

drivers/hid/hid-goodix-spi.c

279

report->device->report_enum[report->type].numbered + 2;

drivers/hid/hid-goodix-spi.c

285

struct hid_report *report;

drivers/hid/hid-goodix-spi.c

288

list_for_each_entry(report, &hid->report_enum[type].report_list, list) {

drivers/hid/hid-goodix-spi.c

289

size = goodix_hid_get_report_length(report);

drivers/hid/hid-google-hammer.c

435

struct hid_report *report;

drivers/hid/hid-google-hammer.c

440

report = hdev->report_enum[HID_INPUT_REPORT].report_id_hash[0x0];

drivers/hid/hid-google-hammer.c

442

if (!report || report->maxfield < 1)

drivers/hid/hid-google-hammer.c

445

len = hid_report_len(report) + 1;

drivers/hid/hid-google-hammer.c

451

rlen = hid_hw_raw_request(hdev, report->id, buf, len, report->type, HID_REQ_GET_REPORT);

drivers/hid/hid-google-hammer.c

458

for (a = 0; a < report->maxfield; a++) {

drivers/hid/hid-google-hammer.c

459

struct hid_field *field = report->field[a];

drivers/hid/hid-google-stadiaff.c

19

struct hid_report *report;

drivers/hid/hid-google-stadiaff.c

31

struct hid_field *rumble_field = stadiaff->report->field[0];

drivers/hid/hid-google-stadiaff.c

39

hid_hw_request(stadiaff->hid, stadiaff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-google-stadiaff.c

63

struct hid_report *report;

drivers/hid/hid-google-stadiaff.c

75

report = hid_validate_values(hid, HID_OUTPUT_REPORT,

drivers/hid/hid-google-stadiaff.c

77

if (!report)

drivers/hid/hid-google-stadiaff.c

95

stadiaff->report = report;

drivers/hid/hid-haptic.c

27

hid_hw_request(hdev, field->report, HID_REQ_GET_REPORT);

drivers/hid/hid-haptic.c

32

haptic->auto_trigger_report = field->report;

drivers/hid/hid-haptic.c

72

haptic->manual_trigger_report = field->report;

drivers/hid/hid-holtekff.c

126

struct hid_report *report;

drivers/hid/hid-holtekff.c

145

report = list_entry(report_list->next, struct hid_report, list);

drivers/hid/hid-holtekff.c

147

if (report->maxfield < 1 || report->field[0]->report_count != 7) {

drivers/hid/hid-holtekff.c

158

holtekff->field = report->field[0];

drivers/hid/hid-holtekff.c

87

hid_hw_request(hid, holtekff->field->report, HID_REQ_SET_REPORT);

drivers/hid/hid-input.c

137

struct hid_report *report;

drivers/hid/hid-input.c

1374

if (field->report->type == HID_OUTPUT_REPORT) {

drivers/hid/hid-input.c

141

list_for_each_entry(report, &hid->report_enum[k].report_list, list) {

drivers/hid/hid-input.c

142

for (i = 0; i < report->maxfield; i++) {

drivers/hid/hid-input.c

143

for (j = 0; j < report->field[i]->maxusage; j++) {

drivers/hid/hid-input.c

144

usage = report->field[i]->usage + j;

drivers/hid/hid-input.c

1522

static void hid_report_release_tool(struct hid_report *report, struct input_dev *input,

drivers/hid/hid-input.c

1537

report->tool = 0;

drivers/hid/hid-input.c

1540

static void hid_report_set_tool(struct hid_report *report, struct input_dev *input,

drivers/hid/hid-input.c

1543

if (report->tool != new_tool)

drivers/hid/hid-input.c

1544

hid_report_release_tool(report, input, report->tool);

drivers/hid/hid-input.c

1547

report->tool = new_tool;

drivers/hid/hid-input.c

1553

struct hid_report *report = field->report;

drivers/hid/hid-input.c

1605

report->tool_active |= !!value;

drivers/hid/hid-input.c

1612

hid_report_set_tool(report, input, BTN_TOOL_RUBBER);

drivers/hid/hid-input.c

1613

else if (report->tool != BTN_TOOL_RUBBER)

drivers/hid/hid-input.c

1622

hid_report_release_tool(report, input, BTN_TOOL_RUBBER);

drivers/hid/hid-input.c

1630

report->tool_active |= !!value;

drivers/hid/hid-input.c

1636

hid_report_set_tool(report, input, BTN_TOOL_RUBBER);

drivers/hid/hid-input.c

1637

else if (!report->tool_active)

drivers/hid/hid-input.c

1639

hid_report_release_tool(report, input, BTN_TOOL_RUBBER);

drivers/hid/hid-input.c

1645

report->tool_active |= !!value;

drivers/hid/hid-input.c

1647

if (report->tool_active) {

drivers/hid/hid-input.c

1652

if (!report->tool)

drivers/hid/hid-input.c

1653

report->tool = usage->code;

drivers/hid/hid-input.c

1656

hid_report_set_tool(report, input, report->tool);

drivers/hid/hid-input.c

1658

hid_report_release_tool(report, input, usage->code);

drivers/hid/hid-input.c

1662

report->tool_active = false;

drivers/hid/hid-input.c

1668

report->tool_active |= !!value;

drivers/hid/hid-input.c

1671

if (report->tool == BTN_TOOL_RUBBER)

drivers/hid/hid-input.c

1683

report->tool_active = true;

drivers/hid/hid-input.c

1763

void hidinput_report_event(struct hid_device *hid, struct hid_report *report)

drivers/hid/hid-input.c

1778

struct hid_report *report;

drivers/hid/hid-input.c

1781

list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {

drivers/hid/hid-input.c

1782

for (i = 0; i < report->maxfield; i++) {

drivers/hid/hid-input.c

1783

*field = report->field[i];

drivers/hid/hid-input.c

1794

struct hid_report *report;

drivers/hid/hid-input.c

1798

list_for_each_entry(report,

drivers/hid/hid-input.c

1801

for (i = 0; i < report->maxfield; i++) {

drivers/hid/hid-input.c

1802

field = report->field[i];

drivers/hid/hid-input.c

1814

struct hid_report *report;

drivers/hid/hid-input.c

1819

list_for_each_entry(report,

drivers/hid/hid-input.c

1822

for (i = 0; i < report->maxfield; i++) {

drivers/hid/hid-input.c

1823

field = report->field[i];

drivers/hid/hid-input.c

1839

struct hid_report *report;

drivers/hid/hid-input.c

1861

report = field->report;

drivers/hid/hid-input.c

1865

return hid->ll_driver->request(hid, report, HID_REQ_SET_REPORT);

drivers/hid/hid-input.c

1868

len = hid_report_len(report);

drivers/hid/hid-input.c

1869

buf = hid_alloc_report_buf(report, GFP_KERNEL);

drivers/hid/hid-input.c

1873

hid_output_report(report, buf);

drivers/hid/hid-input.c

1877

hid_hw_raw_request(hid, report->id, buf, len, HID_OUTPUT_REPORT,

drivers/hid/hid-input.c

1921

struct hid_report *report, bool use_logical_max)

drivers/hid/hid-input.c

1928

if (report->maxfield == 0)

drivers/hid/hid-input.c

1931

for (i = 0; i < report->maxfield; i++) {

drivers/hid/hid-input.c

1933

report->field[i]->logical_maximum :

drivers/hid/hid-input.c

1934

report->field[i]->logical_minimum;

drivers/hid/hid-input.c

1940

if (report->field[i]->report_count != 1)

drivers/hid/hid-input.c

1943

for (j = 0; j < report->field[i]->maxusage; j++) {

drivers/hid/hid-input.c

1944

usage = &report->field[i]->usage[j];

drivers/hid/hid-input.c

1959

if (!get_report_completed && report->maxfield > 1) {

drivers/hid/hid-input.c

1963

hid_hw_request(hid, report, HID_REQ_GET_REPORT);

drivers/hid/hid-input.c

1968

report->field[i]->value[j] = value;

drivers/hid/hid-input.c

2170

struct hid_report *report;

drivers/hid/hid-input.c

2182

list_for_each_entry(report, &hid->report_enum[k].report_list,

drivers/hid/hid-input.c

2185

for (i = 0; i < report->maxfield; i++)

drivers/hid/hid-input.c

2186

if (report->field[i]->hidinput == hidinput)

drivers/hid/hid-input.c

2187

report->field[i]->hidinput = NULL;

drivers/hid/hid-input.c

2194

static struct hid_input *hidinput_match(struct hid_report *report)

drivers/hid/hid-input.c

2196

struct hid_device *hid = report->device;

drivers/hid/hid-input.c

2200

if (hidinput->report &&

drivers/hid/hid-input.c

2201

hidinput->report->id == report->id)

drivers/hid/hid-input.c

2208

static struct hid_input *hidinput_match_application(struct hid_report *report)

drivers/hid/hid-input.c

2210

struct hid_device *hid = report->device;

drivers/hid/hid-input.c

2214

if (hidinput->application == report->application)

drivers/hid/hid-input.c

2221

if ((report->application == HID_GD_SYSTEM_CONTROL ||

drivers/hid/hid-input.c

2222

report->application == HID_CP_CONSUMER_CONTROL) &&

drivers/hid/hid-input.c

2232

struct hid_report *report)

drivers/hid/hid-input.c

2245

for (i = 0; i < report->maxfield; i++) {

drivers/hid/hid-input.c

2246

field = report->field[i];

drivers/hid/hid-input.c

2280

report->field[k]->slot_idx = slot_idx;

drivers/hid/hid-input.c

2286

for (i = 0; i < report->maxfield; i++)

drivers/hid/hid-input.c

2287

for (j = 0; j < report->field[i]->maxusage; j++)

drivers/hid/hid-input.c

2288

hidinput_configure_usage(hidinput, report->field[i],

drivers/hid/hid-input.c

2289

report->field[i]->usage + j,

drivers/hid/hid-input.c

2302

struct hid_report *report;

drivers/hid/hid-input.c

2332

list_for_each_entry(report, &hid->report_enum[k].report_list, list) {

drivers/hid/hid-input.c

2334

if (!report->maxfield)

drivers/hid/hid-input.c

2337

application = report->application;

drivers/hid/hid-input.c

2344

hidinput = hidinput_match(report);

drivers/hid/hid-input.c

2347

hidinput = hidinput_match_application(report);

drivers/hid/hid-input.c

2355

hidinput_configure_usages(hidinput, report);

drivers/hid/hid-input.c

2358

hidinput->report = report;

drivers/hid/hid-input.c

2360

list_add_tail(&report->hidinput_list,

drivers/hid/hid-input.c

566

dev->battery_report_id = field->report->id;

drivers/hid/hid-kye.c

532

struct hid_report *report;

drivers/hid/hid-kye.c

537

report = list_entry(head, struct hid_report, list);

drivers/hid/hid-kye.c

538

if (report->id == 5)

drivers/hid/hid-kye.c

547

if (report->maxfield < 1 || report->field[0]->report_count < 7) {

drivers/hid/hid-kye.c

552

value = report->field[0]->value;

drivers/hid/hid-kye.c

570

hid_hw_request(hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-kysona.c

243

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-lenovo.c

1132

struct hid_report *report;

drivers/hid/hid-lenovo.c

1134

report = hdev->report_enum[HID_OUTPUT_REPORT].report_id_hash[3];

drivers/hid/hid-lenovo.c

1135

report->field[0]->value[0] = (data_pointer->led_state >> 0) & 1;

drivers/hid/hid-lenovo.c

1136

report->field[0]->value[1] = (data_pointer->led_state >> 1) & 1;

drivers/hid/hid-lenovo.c

1137

hid_hw_request(hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-lenovo.c

298

field->report->id == 5) {

drivers/hid/hid-lenovo.c

342

field->report->id == 21) {

drivers/hid/hid-lenovo.c

774

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-lenovo.c

796

&& size >= 3 && report->id == 0x03))

drivers/hid/hid-lenovo.c

892

struct hid_report *report;

drivers/hid/hid-lenovo.c

895

report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[4];

drivers/hid/hid-lenovo.c

897

report->field[0]->value[0] = data_pointer->press_to_select ? 0x01 : 0x02;

drivers/hid/hid-lenovo.c

898

report->field[0]->value[0] |= data_pointer->dragging ? 0x04 : 0x08;

drivers/hid/hid-lenovo.c

899

report->field[0]->value[0] |= data_pointer->release_to_select ? 0x10 : 0x20;

drivers/hid/hid-lenovo.c

900

report->field[0]->value[0] |= data_pointer->select_right ? 0x80 : 0x40;

drivers/hid/hid-lenovo.c

901

report->field[1]->value[0] = 0x03; // unknown setting, imitate windows driver

drivers/hid/hid-lenovo.c

902

report->field[2]->value[0] = data_pointer->sensitivity;

drivers/hid/hid-lenovo.c

903

report->field[3]->value[0] = data_pointer->press_speed;

drivers/hid/hid-lenovo.c

905

hid_hw_request(hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-letsketch.c

167

struct hid_report *report,

drivers/hid/hid-lg-g15.c

893

static int lg_g15_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-lg.c

739

static int lg_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-lg.c

745

return lg4ff_raw_event(hdev, report, rd, size, drv_data);

drivers/hid/hid-lg2ff.c

19

struct hid_report *report;

drivers/hid/hid-lg2ff.c

36

lg2ff->report->field[0]->value[0] = 0x51;

drivers/hid/hid-lg2ff.c

37

lg2ff->report->field[0]->value[2] = weak;

drivers/hid/hid-lg2ff.c

38

lg2ff->report->field[0]->value[4] = strong;

drivers/hid/hid-lg2ff.c

40

lg2ff->report->field[0]->value[0] = 0xf3;

drivers/hid/hid-lg2ff.c

41

lg2ff->report->field[0]->value[2] = 0x00;

drivers/hid/hid-lg2ff.c

42

lg2ff->report->field[0]->value[4] = 0x00;

drivers/hid/hid-lg2ff.c

45

hid_hw_request(hid, lg2ff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg2ff.c

52

struct hid_report *report;

drivers/hid/hid-lg2ff.c

65

report = hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 7);

drivers/hid/hid-lg2ff.c

66

if (!report)

drivers/hid/hid-lg2ff.c

81

lg2ff->report = report;

drivers/hid/hid-lg2ff.c

82

report->field[0]->value[0] = 0xf3;

drivers/hid/hid-lg2ff.c

83

report->field[0]->value[1] = 0x00;

drivers/hid/hid-lg2ff.c

84

report->field[0]->value[2] = 0x00;

drivers/hid/hid-lg2ff.c

85

report->field[0]->value[3] = 0x00;

drivers/hid/hid-lg2ff.c

86

report->field[0]->value[4] = 0x00;

drivers/hid/hid-lg2ff.c

87

report->field[0]->value[5] = 0x00;

drivers/hid/hid-lg2ff.c

88

report->field[0]->value[6] = 0x00;

drivers/hid/hid-lg2ff.c

90

hid_hw_request(hid, report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg3ff.c

100

report->field[0]->value[32] = 0x00;

drivers/hid/hid-lg3ff.c

101

report->field[0]->value[33] = 0x7F;

drivers/hid/hid-lg3ff.c

102

report->field[0]->value[34] = 0x7F;

drivers/hid/hid-lg3ff.c

104

hid_hw_request(hid, report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg3ff.c

49

struct hid_report *report = list_entry(report_list->next, struct hid_report, list);

drivers/hid/hid-lg3ff.c

56

memset(report->field[0]->value, 0,

drivers/hid/hid-lg3ff.c

57

sizeof(__s32) * report->field[0]->report_count);

drivers/hid/hid-lg3ff.c

69

report->field[0]->value[0] = 0x51;

drivers/hid/hid-lg3ff.c

75

report->field[0]->value[1] = (unsigned char)(-x);

drivers/hid/hid-lg3ff.c

76

report->field[0]->value[31] = (unsigned char)(-y);

drivers/hid/hid-lg3ff.c

78

hid_hw_request(hid, report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg3ff.c

87

struct hid_report *report = list_entry(report_list->next, struct hid_report, list);

drivers/hid/hid-lg3ff.c

94

report->field[0]->value[0] = 0x51;

drivers/hid/hid-lg3ff.c

95

report->field[0]->value[1] = 0x00;

drivers/hid/hid-lg3ff.c

96

report->field[0]->value[2] = 0x00;

drivers/hid/hid-lg3ff.c

97

report->field[0]->value[3] = 0x7F;

drivers/hid/hid-lg3ff.c

98

report->field[0]->value[4] = 0x7F;

drivers/hid/hid-lg3ff.c

99

report->field[0]->value[31] = 0x00;

drivers/hid/hid-lg4ff.c

1106

value = entry->report->field[0]->value;

drivers/hid/hid-lg4ff.c

1116

hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg4ff.c

1265

struct hid_report *report = list_entry(report_list->next, struct hid_report, list);

drivers/hid/hid-lg4ff.c

1295

entry->report = report;

drivers/hid/hid-lg4ff.c

326

int lg4ff_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-lg4ff.c

426

value = entry->report->field[0]->value;

drivers/hid/hid-lg4ff.c

446

hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg4ff.c

459

hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg4ff.c

488

value = entry->report->field[0]->value;

drivers/hid/hid-lg4ff.c

501

hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg4ff.c

532

hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg4ff.c

543

hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg4ff.c

568

value = entry->report->field[0]->value;

drivers/hid/hid-lg4ff.c

579

hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg4ff.c

602

value = entry->report->field[0]->value;

drivers/hid/hid-lg4ff.c

614

hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg4ff.c

638

value = entry->report->field[0]->value;

drivers/hid/hid-lg4ff.c

658

hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg4ff.c

670

hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg4ff.c

685

hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg4ff.c

782

value = entry->report->field[0]->value;

drivers/hid/hid-lg4ff.c

791

hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);

drivers/hid/hid-lg4ff.c

84

struct hid_report *report;

drivers/hid/hid-lg4ff.h

10

int lg4ff_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-lg4ff.h

17

static inline int lg4ff_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-lgff.c

103

struct hid_report *report = list_entry(report_list->next, struct hid_report, list);

drivers/hid/hid-lgff.c

104

__s32 *value = report->field[0]->value;

drivers/hid/hid-lgff.c

113

hid_hw_request(hid, report, HID_REQ_SET_REPORT);

drivers/hid/hid-lgff.c

61

struct hid_report *report = list_entry(report_list->next, struct hid_report, list);

drivers/hid/hid-lgff.c

73

report->field[0]->value[0] = 0x51;

drivers/hid/hid-lgff.c

74

report->field[0]->value[1] = 0x08;

drivers/hid/hid-lgff.c

75

report->field[0]->value[2] = x;

drivers/hid/hid-lgff.c

76

report->field[0]->value[3] = y;

drivers/hid/hid-lgff.c

78

hid_hw_request(hid, report, HID_REQ_SET_REPORT);

drivers/hid/hid-lgff.c

88

report->field[0]->value[0] = 0x42;

drivers/hid/hid-lgff.c

89

report->field[0]->value[1] = 0x00;

drivers/hid/hid-lgff.c

90

report->field[0]->value[2] = left;

drivers/hid/hid-lgff.c

91

report->field[0]->value[3] = right;

drivers/hid/hid-lgff.c

93

hid_hw_request(hid, report, HID_REQ_SET_REPORT);

drivers/hid/hid-logitech-dj.c

1244

u8 report = data[0];

drivers/hid/hid-logitech-dj.c

1247

if (report > REPORT_TYPE_RFREPORT_LAST) {

drivers/hid/hid-logitech-dj.c

1248

hid_err(hdev, "Unexpected input report number %d\n", report);

drivers/hid/hid-logitech-dj.c

1255

if (dj_dev && (dj_dev->reports_supported & BIT(report))) {

drivers/hid/hid-logitech-dj.c

1265

dbg_hid("No dj-devs handling input report number %d\n", report);

drivers/hid/hid-logitech-dj.c

1272

struct hid_report *report;

drivers/hid/hid-logitech-dj.c

1278

report = output_report_enum->report_id_hash[REPORT_ID_DJ_SHORT];

drivers/hid/hid-logitech-dj.c

1280

if (!report) {

drivers/hid/hid-logitech-dj.c

1286

report->field[0]->value[i] = data[i];

drivers/hid/hid-logitech-dj.c

1288

hid_hw_request(hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-logitech-dj.c

1634

struct hid_report *report, u8 *data,

drivers/hid/hid-logitech-dj.c

1704

struct hid_report *report, u8 *data,

drivers/hid/hid-logitech-dj.c

1781

struct hid_report *report, u8 *data,

drivers/hid/hid-logitech-dj.c

1832

return logi_dj_dj_event(hdev, report, data, size);

drivers/hid/hid-logitech-dj.c

1838

return logi_dj_dj_event(hdev, report, data, size);

drivers/hid/hid-logitech-dj.c

1844

return logi_dj_hidpp_event(hdev, report, data, size);

drivers/hid/hid-logitech-dj.c

1850

return logi_dj_hidpp_event(hdev, report, data, size);

drivers/hid/hid-logitech-hidpp.c

1343

struct hidpp_report *report = (struct hidpp_report *)data;

drivers/hid/hid-logitech-hidpp.c

1347

if (report->fap.feature_index != hidpp->battery.feature_index ||

drivers/hid/hid-logitech-hidpp.c

1348

report->fap.funcindex_clientid != EVENT_BATTERY_LEVEL_STATUS_BROADCAST)

drivers/hid/hid-logitech-hidpp.c

1351

status = hidpp20_batterylevel_map_status_capacity(report->fap.params,

drivers/hid/hid-logitech-hidpp.c

1525

struct hidpp_report *report = (struct hidpp_report *)data;

drivers/hid/hid-logitech-hidpp.c

1528

if (report->fap.feature_index != hidpp->battery.voltage_feature_index ||

drivers/hid/hid-logitech-hidpp.c

1529

report->fap.funcindex_clientid != EVENT_BATTERY_VOLTAGE_STATUS_BROADCAST)

drivers/hid/hid-logitech-hidpp.c

1532

status = hidpp20_battery_map_status_voltage(report->fap.params, &voltage,

drivers/hid/hid-logitech-hidpp.c

1732

struct hidpp_report *report = (struct hidpp_report *)data;

drivers/hid/hid-logitech-hidpp.c

1733

u8 *params = (u8 *)report->fap.params;

drivers/hid/hid-logitech-hidpp.c

1737

if (report->fap.feature_index != hidpp->battery.feature_index ||

drivers/hid/hid-logitech-hidpp.c

1738

report->fap.funcindex_clientid != EVENT_UNIFIED_BATTERY_STATUS_EVENT)

drivers/hid/hid-logitech-hidpp.c

1973

struct hidpp_report *report = (struct hidpp_report *)data;

drivers/hid/hid-logitech-hidpp.c

1976

if (report->fap.feature_index != hidpp->battery.adc_measurement_feature_index ||

drivers/hid/hid-logitech-hidpp.c

1977

report->fap.funcindex_clientid != EVENT_ADC_MEASUREMENT_STATUS_BROADCAST)

drivers/hid/hid-logitech-hidpp.c

1980

status = hidpp20_map_adc_measurement_1f20(report->fap.params, &voltage);

drivers/hid/hid-logitech-hidpp.c

2130

struct hidpp_report *report = (struct hidpp_report *)data;

drivers/hid/hid-logitech-hidpp.c

2134

function = report->fap.funcindex_clientid;

drivers/hid/hid-logitech-hidpp.c

2137

if (report->fap.feature_index != hidpp->battery.solar_feature_index ||

drivers/hid/hid-logitech-hidpp.c

2143

capacity = report->fap.params[0];

drivers/hid/hid-logitech-hidpp.c

2147

lux = (report->fap.params[1] << 8) | report->fap.params[2];

drivers/hid/hid-logitech-hidpp.c

3042

struct hidpp_report *report = (struct hidpp_report *)data;

drivers/hid/hid-logitech-hidpp.c

3069

if ((report->fap.feature_index != wd->mt_feature_index) ||

drivers/hid/hid-logitech-hidpp.c

3070

(report->fap.funcindex_clientid != EVENT_TOUCHPAD_RAW_XY))

drivers/hid/hid-logitech-hidpp.c

3845

struct hidpp_report *report = (struct hidpp_report *)data;

drivers/hid/hid-logitech-hidpp.c

3858

if (hidpp_match_answer(question, report) ||

drivers/hid/hid-logitech-hidpp.c

3859

hidpp_match_error(question, report)) {

drivers/hid/hid-logitech-hidpp.c

3860

*answer = *report;

drivers/hid/hid-logitech-hidpp.c

3873

if (unlikely(hidpp_report_is_connect_event(hidpp, report))) {

drivers/hid/hid-logitech-hidpp.c

3940

static int hidpp_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-logitech-hidpp.c

4313

struct hid_report *report;

drivers/hid/hid-logitech-hidpp.c

4316

report = re->report_id_hash[id];

drivers/hid/hid-logitech-hidpp.c

4317

if (!report || !report->maxfield)

drivers/hid/hid-logitech-hidpp.c

4320

return report->field[0]->report_count + 1;

drivers/hid/hid-logitech-hidpp.c

4369

struct hid_report *report;

drivers/hid/hid-logitech-hidpp.c

4372

report = list_first_entry_or_null(report_list, struct hid_report, list);

drivers/hid/hid-logitech-hidpp.c

4373

return report && report->application == application;

drivers/hid/hid-logitech-hidpp.c

476

struct hidpp_report *report)

drivers/hid/hid-logitech-hidpp.c

479

(report->fap.feature_index == hidpp->wireless_feature_index)) ||

drivers/hid/hid-logitech-hidpp.c

480

((report->report_id == REPORT_ID_HIDPP_SHORT) &&

drivers/hid/hid-logitech-hidpp.c

481

(report->rap.sub_id == 0x41));

drivers/hid/hid-logitech-hidpp.c

800

struct hidpp_report *report = (struct hidpp_report *)data;

drivers/hid/hid-logitech-hidpp.c

804

if (report->report_id != REPORT_ID_HIDPP_SHORT)

drivers/hid/hid-logitech-hidpp.c

807

switch (report->rap.sub_id) {

drivers/hid/hid-logitech-hidpp.c

810

level = hidpp10_battery_status_map_level(report->rawbytes[1]);

drivers/hid/hid-logitech-hidpp.c

811

status = hidpp10_battery_status_map_status(report->rawbytes[2]);

drivers/hid/hid-logitech-hidpp.c

814

capacity = report->rap.params[0];

drivers/hid/hid-logitech-hidpp.c

816

status = hidpp10_battery_mileage_map_status(report->rawbytes[3]);

drivers/hid/hid-magicmouse.c

387

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-magicmouse.c

493

magicmouse_raw_event(hdev, report, data + 2, data[1]);

drivers/hid/hid-magicmouse.c

494

magicmouse_raw_event(hdev, report, data + 2 + data[1],

drivers/hid/hid-magicmouse.c

527

field->report->id == MOUSE2_REPORT_ID) {

drivers/hid/hid-magicmouse.c

819

struct hid_report *report;

drivers/hid/hid-magicmouse.c

827

report = report_enum->report_id_hash[hdev->battery_report_id];

drivers/hid/hid-magicmouse.c

829

if (!report || report->maxfield < 1)

drivers/hid/hid-magicmouse.c

835

hid_hw_request(hdev, report, HID_REQ_GET_REPORT);

drivers/hid/hid-magicmouse.c

857

struct hid_report *report;

drivers/hid/hid-magicmouse.c

906

report = hid_register_report(hdev, HID_INPUT_REPORT, MOUSE_REPORT_ID, 0);

drivers/hid/hid-magicmouse.c

910

report = hid_register_report(hdev, HID_INPUT_REPORT, MOUSE2_REPORT_ID, 0);

drivers/hid/hid-magicmouse.c

916

report = hid_register_report(hdev, HID_INPUT_REPORT,

drivers/hid/hid-magicmouse.c

920

report = hid_register_report(hdev, HID_INPUT_REPORT,

drivers/hid/hid-magicmouse.c

925

report = hid_register_report(hdev, HID_INPUT_REPORT,

drivers/hid/hid-magicmouse.c

927

report = hid_register_report(hdev, HID_INPUT_REPORT,

drivers/hid/hid-magicmouse.c

931

if (!report) {

drivers/hid/hid-magicmouse.c

936

report->size = 6;

drivers/hid/hid-mcp2200.c

296

static int mcp2200_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-mcp2221.c

849

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-megaworld.c

19

struct hid_report *report;

drivers/hid/hid-megaworld.c

33

hid_hw_request(hid, mwctrl->report, HID_REQ_SET_REPORT);

drivers/hid/hid-megaworld.c

41

struct hid_report *report;

drivers/hid/hid-megaworld.c

55

report = hid_validate_values(hid, HID_OUTPUT_REPORT, 0, i, 1);

drivers/hid/hid-megaworld.c

56

if (!report)

drivers/hid/hid-megaworld.c

72

mwctrl->report = report;

drivers/hid/hid-megaworld.c

80

report->field[0]->value[0] = 0x02;

drivers/hid/hid-megaworld.c

82

mwctrl->strong = &report->field[2]->value[0];

drivers/hid/hid-megaworld.c

83

mwctrl->weak = &report->field[3]->value[0];

drivers/hid/hid-mf.c

104

mf->report = report;

drivers/hid/hid-mf.c

105

mf->report->field[0]->value[0] = 0x00;

drivers/hid/hid-mf.c

106

mf->report->field[0]->value[1] = 0x00;

drivers/hid/hid-mf.c

107

hid_hw_request(hid, mf->report, HID_REQ_SET_REPORT);

drivers/hid/hid-mf.c

31

struct hid_report *report;

drivers/hid/hid-mf.c

50

mf->report->field[0]->value[0] = weak;

drivers/hid/hid-mf.c

51

mf->report->field[0]->value[1] = strong;

drivers/hid/hid-mf.c

52

hid_hw_request(hid, mf->report, HID_REQ_SET_REPORT);

drivers/hid/hid-mf.c

65

struct hid_report *report;

drivers/hid/hid-mf.c

76

report = list_entry(report_ptr, struct hid_report, list);

drivers/hid/hid-mf.c

78

if (report->maxfield < 1 || report->field[0]->report_count < 2) {

drivers/hid/hid-multitouch.c

1298

struct hid_report *report = rdata->report;

drivers/hid/hid-multitouch.c

1342

input = report->field[0]->hidinput->input;

drivers/hid/hid-multitouch.c

1349

for (r = 0; r < report->maxfield; r++) {

drivers/hid/hid-multitouch.c

1350

field = report->field[r];

drivers/hid/hid-multitouch.c

1469

rdata = mt_find_report_data(td, field->report);

drivers/hid/hid-multitouch.c

1546

rdata = mt_find_report_data(td, field->report);

drivers/hid/hid-multitouch.c

1562

rdata = mt_find_report_data(td, field->report);

drivers/hid/hid-multitouch.c

1601

static void mt_report(struct hid_device *hid, struct hid_report *report)

drivers/hid/hid-multitouch.c

1604

struct hid_field *field = report->field[0];

drivers/hid/hid-multitouch.c

1610

rdata = mt_find_report_data(td, report);

drivers/hid/hid-multitouch.c

1620

for (int f = 0; f < report->maxfield && all_zero_report; f++) {

drivers/hid/hid-multitouch.c

1621

struct hid_field *fld = report->field[f];

drivers/hid/hid-multitouch.c

1659

struct hid_report *report = field->report;

drivers/hid/hid-multitouch.c

167

struct hid_report *report;

drivers/hid/hid-multitouch.c

1676

report_len = hid_report_len(report);

drivers/hid/hid-multitouch.c

1677

buf = hid_alloc_report_buf(report, GFP_KERNEL);

drivers/hid/hid-multitouch.c

1683

hid_hw_raw_request(hdev, report->id, buf, report_len,

drivers/hid/hid-multitouch.c

1786

struct hid_report *report;

drivers/hid/hid-multitouch.c

1798

list_for_each_entry(report, &hi->reports, hidinput_list) {

drivers/hid/hid-multitouch.c

1799

rdata = mt_find_report_data(td, report);

drivers/hid/hid-multitouch.c

1844

if (hi->report && td->mtclass.quirks & MT_QUIRK_YOGABOOK9I) {

drivers/hid/hid-multitouch.c

1845

switch (hi->report->id) {

drivers/hid/hid-multitouch.c

1889

struct hid_report *report;

drivers/hid/hid-multitouch.c

1892

list_for_each_entry(report,

drivers/hid/hid-multitouch.c

1896

if (!report->maxfield)

drivers/hid/hid-multitouch.c

1899

for (i = 0; i < report->maxfield; i++)

drivers/hid/hid-multitouch.c

1900

if (report->field[i]->maxusage >= 1)

drivers/hid/hid-multitouch.c

1901

mt_fix_const_field(report->field[i], usage);

drivers/hid/hid-multitouch.c

2604

.report = mt_report,

drivers/hid/hid-multitouch.c

506

static void mt_get_feature(struct hid_device *hdev, struct hid_report *report)

drivers/hid/hid-multitouch.c

509

u32 size = hid_report_len(report);

drivers/hid/hid-multitouch.c

519

buf = hid_alloc_report_buf(report, GFP_KERNEL);

drivers/hid/hid-multitouch.c

523

ret = hid_hw_raw_request(hdev, report->id, buf, size,

drivers/hid/hid-multitouch.c

527

report->id);

drivers/hid/hid-multitouch.c

530

if (report->id != buf[0]) {

drivers/hid/hid-multitouch.c

552

mt_get_feature(hdev, field->report);

drivers/hid/hid-multitouch.c

569

mt_get_feature(hdev, field->report);

drivers/hid/hid-multitouch.c

583

mt_get_feature(hdev, field->report);

drivers/hid/hid-multitouch.c

629

struct hid_report *report)

drivers/hid/hid-multitouch.c

631

unsigned int application = report->application;

drivers/hid/hid-multitouch.c

656

mt_application->report_id = report->id;

drivers/hid/hid-multitouch.c

664

struct hid_report *report)

drivers/hid/hid-multitouch.c

666

unsigned int application = report->application;

drivers/hid/hid-multitouch.c

672

tmp->report_id == report->id) {

drivers/hid/hid-multitouch.c

680

mt_application = mt_allocate_application(td, report);

drivers/hid/hid-multitouch.c

686

struct hid_report *report)

drivers/hid/hid-multitouch.c

697

rdata->report = report;

drivers/hid/hid-multitouch.c

698

rdata->application = mt_find_application(td, report);

drivers/hid/hid-multitouch.c

705

for (r = 0; r < report->maxfield; r++) {

drivers/hid/hid-multitouch.c

706

field = report->field[r];

drivers/hid/hid-multitouch.c

731

struct hid_report *report)

drivers/hid/hid-multitouch.c

736

if (report == tmp->report) {

drivers/hid/hid-multitouch.c

743

rdata = mt_allocate_report_data(td, report);

drivers/hid/hid-nintendo.c

1014

report = (struct joycon_input_report *)ctlr->input_buf;

drivers/hid/hid-nintendo.c

1016

*reply = &report->subcmd_reply.data[5];

drivers/hid/hid-nintendo.c

2420

struct joycon_input_report *report;

drivers/hid/hid-nintendo.c

2429

report = (struct joycon_input_report *)ctlr->input_buf;

drivers/hid/hid-nintendo.c

2432

ctlr->mac_addr[j] = report->subcmd_reply.data[i];

drivers/hid/hid-nintendo.c

2455

ctlr->ctlr_type = report->subcmd_reply.data[2];

drivers/hid/hid-nintendo.c

2575

struct joycon_input_report *report;

drivers/hid/hid-nintendo.c

2591

report = (struct joycon_input_report *)data;

drivers/hid/hid-nintendo.c

2592

if (report->subcmd_reply.id == ctlr->subcmd_ack_match)

drivers/hid/hid-nintendo.c

2618

struct hid_report *report, u8 *raw_data, int size)

drivers/hid/hid-nintendo.c

995

struct joycon_input_report *report;

drivers/hid/hid-ntrig.c

111

struct hid_report *report = hdev->report_enum[HID_FEATURE_REPORT].

drivers/hid/hid-ntrig.c

114

if (!report || report->maxfield < 1 ||

drivers/hid/hid-ntrig.c

115

report->field[0]->report_count < 1)

drivers/hid/hid-ntrig.c

118

hid_hw_request(hdev, report, HID_REQ_GET_REPORT);

drivers/hid/hid-ntrig.c

120

return (int)report->field[0]->value[0];

drivers/hid/hid-ntrig.c

125

struct hid_report *report;

drivers/hid/hid-ntrig.c

131

report = hdev->report_enum[HID_FEATURE_REPORT].

drivers/hid/hid-ntrig.c

134

if (!report)

drivers/hid/hid-ntrig.c

137

hid_hw_request(hdev, report, HID_REQ_GET_REPORT);

drivers/hid/hid-ntrig.c

864

if (hidinput->report->maxfield < 1)

drivers/hid/hid-ntrig.c

867

switch (hidinput->report->field[0]->application) {

drivers/hid/hid-ntrig.c

884

input->name = (hidinput->report->field[0]->physical) ?

drivers/hid/hid-ntrig.c

897

struct hid_report *report;

drivers/hid/hid-ntrig.c

935

report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0x0a];

drivers/hid/hid-ntrig.c

936

if (report) {

drivers/hid/hid-ntrig.c

940

hid_hw_request(hdev, report, HID_REQ_GET_REPORT);

drivers/hid/hid-nvidia-shield.c

1036

static int shield_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-nvidia-shield.c

1041

return thunderstrike_parse_report(dev, report, data, size);

drivers/hid/hid-nvidia-shield.c

229

struct thunderstrike_hostcmd_req_report *report, u8 cmd_id)

drivers/hid/hid-nvidia-shield.c

231

memset(report, 0, sizeof(*report));

drivers/hid/hid-nvidia-shield.c

232

report->report_id = THUNDERSTRIKE_HOSTCMD_REQ_REPORT_ID;

drivers/hid/hid-nvidia-shield.c

233

report->cmd_id = cmd_id;

drivers/hid/hid-nvidia-shield.c

303

struct thunderstrike_hostcmd_req_report *report = ts->req_report_dmabuf;

drivers/hid/hid-nvidia-shield.c

307

ret = hid_hw_raw_request(shield_dev->hdev, report->report_id,

drivers/hid/hid-nvidia-shield.c

323

struct thunderstrike_hostcmd_req_report *report;

drivers/hid/hid-nvidia-shield.c

326

report = ts->req_report_dmabuf;

drivers/hid/hid-nvidia-shield.c

330

report, THUNDERSTRIKE_HOSTCMD_ID_FW_VERSION);

drivers/hid/hid-nvidia-shield.c

335

thunderstrike_hostcmd_req_report_init(report, THUNDERSTRIKE_HOSTCMD_ID_LED);

drivers/hid/hid-nvidia-shield.c

336

report->led.update = 1;

drivers/hid/hid-nvidia-shield.c

337

report->led.state = ts->led_value;

drivers/hid/hid-nvidia-shield.c

343

report, THUNDERSTRIKE_HOSTCMD_ID_BATTERY);

drivers/hid/hid-nvidia-shield.c

347

report, THUNDERSTRIKE_HOSTCMD_ID_CHARGER);

drivers/hid/hid-nvidia-shield.c

353

report, THUNDERSTRIKE_HOSTCMD_ID_BOARD_INFO);

drivers/hid/hid-nvidia-shield.c

359

report, THUNDERSTRIKE_HOSTCMD_ID_HAPTICS);

drivers/hid/hid-nvidia-shield.c

361

report->haptics.update = 1;

drivers/hid/hid-nvidia-shield.c

363

report->haptics.motors = ts->haptics_val;

drivers/hid/hid-nvidia-shield.c

735

struct hid_report *report, u8 *data,

drivers/hid/hid-nvidia-shield.c

741

switch (report->id) {

drivers/hid/hid-picolcd.h

134

struct hid_device *hdev, struct hid_report *report);

drivers/hid/hid-picolcd.h

142

struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-picolcd.h

153

struct hid_device *hdev, struct hid_report *report)

drivers/hid/hid-picolcd.h

157

struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-picolcd.h

203

struct hid_report *report);

drivers/hid/hid-picolcd.h

212

struct hid_report *report)

drivers/hid/hid-picolcd.h

232

struct hid_report *report);

drivers/hid/hid-picolcd.h

239

struct hid_report *report)

drivers/hid/hid-picolcd.h

255

struct hid_report *report);

drivers/hid/hid-picolcd.h

262

struct hid_report *report)

drivers/hid/hid-picolcd.h

277

struct hid_report *report, u8 *raw_data, int size);

drivers/hid/hid-picolcd.h

279

int picolcd_init_cir(struct picolcd_data *data, struct hid_report *report);

drivers/hid/hid-picolcd.h

284

struct hid_report *report, u8 *raw_data, int size)

drivers/hid/hid-picolcd.h

288

static inline int picolcd_init_cir(struct picolcd_data *data, struct hid_report *report)

drivers/hid/hid-picolcd_backlight.c

25

struct hid_report *report = picolcd_out_report(REPORT_BRIGHTNESS, data->hdev);

drivers/hid/hid-picolcd_backlight.c

28

if (!report || report->maxfield != 1 || report->field[0]->report_count != 1)

drivers/hid/hid-picolcd_backlight.c

34

hid_set_field(report->field[0], 0,

drivers/hid/hid-picolcd_backlight.c

37

hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-picolcd_backlight.c

47

int picolcd_init_backlight(struct picolcd_data *data, struct hid_report *report)

drivers/hid/hid-picolcd_backlight.c

52

if (!report)

drivers/hid/hid-picolcd_backlight.c

54

if (report->maxfield != 1 || report->field[0]->report_count != 1 ||

drivers/hid/hid-picolcd_backlight.c

55

report->field[0]->report_size != 8) {

drivers/hid/hid-picolcd_cir.c

34

struct hid_report *report, u8 *raw_data, int size)

drivers/hid/hid-picolcd_cir.c

95

int picolcd_init_cir(struct picolcd_data *data, struct hid_report *report)

drivers/hid/hid-picolcd_core.c

102

hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-picolcd_core.c

117

struct hid_report *report, u8 *raw_data, int size)

drivers/hid/hid-picolcd_core.c

219

struct hid_report *report = picolcd_out_report(REPORT_RESET, hdev);

drivers/hid/hid-picolcd_core.c

223

if (!data || !report || report->maxfield != 1)

drivers/hid/hid-picolcd_core.c

231

hid_set_field(report->field[0], 0, 1);

drivers/hid/hid-picolcd_core.c

236

hid_hw_request(hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-picolcd_core.c

268

struct hid_report *report = NULL;

drivers/hid/hid-picolcd_core.c

274

report = picolcd_out_report(REPORT_EXIT_FLASHER, data->hdev);

drivers/hid/hid-picolcd_core.c

277

report = picolcd_out_report(REPORT_EXIT_KEYBOARD, data->hdev);

drivers/hid/hid-picolcd_core.c

282

if (!report || report->maxfield != 1)

drivers/hid/hid-picolcd_core.c

286

hid_set_field(report->field[0], 0, timeout & 0xff);

drivers/hid/hid-picolcd_core.c

287

hid_set_field(report->field[0], 1, (timeout >> 8) & 0xff);

drivers/hid/hid-picolcd_core.c

288

hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-picolcd_core.c

328

struct hid_report *report, u8 *raw_data, int size)

drivers/hid/hid-picolcd_core.c

338

size, report->id);

drivers/hid/hid-picolcd_core.c

342

if (report->id == REPORT_KEY_STATE) {

drivers/hid/hid-picolcd_core.c

344

picolcd_raw_keypad(data, report, raw_data+1, size-1);

drivers/hid/hid-picolcd_core.c

345

} else if (report->id == REPORT_IR_DATA) {

drivers/hid/hid-picolcd_core.c

346

picolcd_raw_cir(data, report, raw_data+1, size-1);

drivers/hid/hid-picolcd_core.c

356

data->pending->in_report = report;

drivers/hid/hid-picolcd_core.c

362

picolcd_debug_raw_event(data, hdev, report, raw_data, size);

drivers/hid/hid-picolcd_core.c

406

struct hid_report *report)

drivers/hid/hid-picolcd_core.c

412

if (!report)

drivers/hid/hid-picolcd_core.c

414

if (report->maxfield != 1 || report->field[0]->report_count != 2 ||

drivers/hid/hid-picolcd_core.c

415

report->field[0]->report_size != 8) {

drivers/hid/hid-picolcd_core.c

56

struct hid_report *report = NULL;

drivers/hid/hid-picolcd_core.c

58

list_for_each_entry(report, feature_report_list, list) {

drivers/hid/hid-picolcd_core.c

59

if (report->id == id)

drivers/hid/hid-picolcd_core.c

60

return report;

drivers/hid/hid-picolcd_core.c

73

struct hid_report *report = picolcd_out_report(report_id, hdev);

drivers/hid/hid-picolcd_core.c

77

if (!report || !data)

drivers/hid/hid-picolcd_core.c

86

work->out_report = report;

drivers/hid/hid-picolcd_core.c

92

for (i = k = 0; i < report->maxfield; i++)

drivers/hid/hid-picolcd_core.c

93

for (j = 0; j < report->field[i]->report_count; j++) {

drivers/hid/hid-picolcd_core.c

94

hid_set_field(report->field[i], j, k < size ? raw_data[k] : 0);

drivers/hid/hid-picolcd_debugfs.c

386

struct hid_device *hdev, struct hid_report *report)

drivers/hid/hid-picolcd_debugfs.c

389

int raw_size = (report->size >> 3) + 1;

drivers/hid/hid-picolcd_debugfs.c

401

raw_data = hid_alloc_report_buf(report, GFP_ATOMIC);

drivers/hid/hid-picolcd_debugfs.c

408

report->id, raw_size);

drivers/hid/hid-picolcd_debugfs.c

410

raw_data[0] = report->id;

drivers/hid/hid-picolcd_debugfs.c

411

hid_output_report(report, raw_data);

drivers/hid/hid-picolcd_debugfs.c

415

switch (report->id) {

drivers/hid/hid-picolcd_debugfs.c

419

"REPORT_LED_STATE", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

427

"REPORT_BRIGHTNESS", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

435

"REPORT_CONTRAST", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

443

"REPORT_RESET", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

452

"REPORT_LCD_CMD", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

459

"REPORT_LCD_CMD", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

466

"REPORT_LCD_CMD", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

473

"REPORT_EE_READ", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

484

"REPORT_EE_WRITE", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

506

"REPORT_ERASE_MEMORY", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

526

"REPORT_READ_MEMORY", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

550

"REPORT_WRITE_MEMORY", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

595

"REPORT_EXIT_KEYBOARD", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

604

"REPORT_VERSION", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

609

"REPORT_DEVID", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

614

"REPORT_SPLASH_SIZE", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

619

"REPORT_HOOK_VERSION", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

624

"REPORT_VERSION", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

633

"<unknown>", report->id, raw_size-1);

drivers/hid/hid-picolcd_debugfs.c

643

struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-picolcd_debugfs.c

657

switch (report->id) {

drivers/hid/hid-picolcd_debugfs.c

661

"REPORT_ERROR_CODE", report->id, size-1);

drivers/hid/hid-picolcd_debugfs.c

674

"REPORT_KEY_STATE", report->id, size-1);

drivers/hid/hid-picolcd_debugfs.c

689

"REPORT_IR_DATA", report->id, size-1);

drivers/hid/hid-picolcd_debugfs.c

709

"REPORT_EE_DATA", report->id, size-1);

drivers/hid/hid-picolcd_debugfs.c

732

"REPORT_MEMORY", report->id, size-1);

drivers/hid/hid-picolcd_debugfs.c

774

"REPORT_VERSION", report->id, size-1);

drivers/hid/hid-picolcd_debugfs.c

782

"REPORT_BL_ERASE_MEMORY", report->id, size-1);

drivers/hid/hid-picolcd_debugfs.c

788

"REPORT_BL_READ_MEMORY", report->id, size-1);

drivers/hid/hid-picolcd_debugfs.c

794

"REPORT_BL_WRITE_MEMORY", report->id, size-1);

drivers/hid/hid-picolcd_debugfs.c

800

"REPORT_DEVID", report->id, size-1);

drivers/hid/hid-picolcd_debugfs.c

811

"REPORT_SPLASH_SIZE", report->id, size-1);

drivers/hid/hid-picolcd_debugfs.c

822

"REPORT_HOOK_VERSION", report->id, size-1);

drivers/hid/hid-picolcd_debugfs.c

830

"<unknown>", report->id, size-1);

drivers/hid/hid-picolcd_fb.c

187

struct hid_report *report = picolcd_out_report(REPORT_LCD_CMD, data->hdev);

drivers/hid/hid-picolcd_fb.c

193

if (!report || report->maxfield != 1)

drivers/hid/hid-picolcd_fb.c

198

for (j = 0; j < report->field[0]->maxusage; j++)

drivers/hid/hid-picolcd_fb.c

200

hid_set_field(report->field[0], j, i << 2);

drivers/hid/hid-picolcd_fb.c

202

hid_set_field(report->field[0], j, mapcmd[j]);

drivers/hid/hid-picolcd_fb.c

204

hid_set_field(report->field[0], j, 0);

drivers/hid/hid-picolcd_fb.c

205

hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-picolcd_lcd.c

29

struct hid_report *report = picolcd_out_report(REPORT_CONTRAST, data->hdev);

drivers/hid/hid-picolcd_lcd.c

32

if (!report || report->maxfield != 1 || report->field[0]->report_count != 1)

drivers/hid/hid-picolcd_lcd.c

37

hid_set_field(report->field[0], 0, data->lcd_contrast);

drivers/hid/hid-picolcd_lcd.c

39

hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-picolcd_lcd.c

49

int picolcd_init_lcd(struct picolcd_data *data, struct hid_report *report)

drivers/hid/hid-picolcd_lcd.c

54

if (!report)

drivers/hid/hid-picolcd_lcd.c

56

if (report->maxfield != 1 || report->field[0]->report_count != 1 ||

drivers/hid/hid-picolcd_lcd.c

57

report->field[0]->report_size != 8) {

drivers/hid/hid-picolcd_leds.c

104

if (!report)

drivers/hid/hid-picolcd_leds.c

106

if (report->maxfield != 1 || report->field[0]->report_count != 1 ||

drivers/hid/hid-picolcd_leds.c

107

report->field[0]->report_size != 8) {

drivers/hid/hid-picolcd_leds.c

34

struct hid_report *report;

drivers/hid/hid-picolcd_leds.c

39

report = picolcd_out_report(REPORT_LED_STATE, data->hdev);

drivers/hid/hid-picolcd_leds.c

40

if (!report || report->maxfield != 1 || report->field[0]->report_count != 1)

drivers/hid/hid-picolcd_leds.c

44

hid_set_field(report->field[0], 0, data->led_state);

drivers/hid/hid-picolcd_leds.c

46

hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-picolcd_leds.c

96

int picolcd_init_leds(struct picolcd_data *data, struct hid_report *report)

drivers/hid/hid-pl.c

110

report = list_entry(report_ptr, struct hid_report, list);

drivers/hid/hid-pl.c

111

if (report->maxfield < 1) {

drivers/hid/hid-pl.c

117

if (report->field[0]->report_count >= 4) {

drivers/hid/hid-pl.c

118

report->field[0]->value[0] = 0x00;

drivers/hid/hid-pl.c

119

report->field[0]->value[1] = 0x00;

drivers/hid/hid-pl.c

120

strong = &report->field[0]->value[2];

drivers/hid/hid-pl.c

121

weak = &report->field[0]->value[3];

drivers/hid/hid-pl.c

123

} else if (report->field[0]->maxusage == 1 &&

drivers/hid/hid-pl.c

124

report->field[0]->usage[0].hid ==

drivers/hid/hid-pl.c

126

report->maxfield >= 4 &&

drivers/hid/hid-pl.c

127

report->field[0]->report_count >= 1 &&

drivers/hid/hid-pl.c

128

report->field[1]->report_count >= 1 &&

drivers/hid/hid-pl.c

129

report->field[2]->report_count >= 1 &&

drivers/hid/hid-pl.c

130

report->field[3]->report_count >= 1) {

drivers/hid/hid-pl.c

131

report->field[0]->value[0] = 0x00;

drivers/hid/hid-pl.c

132

report->field[1]->value[0] = 0x00;

drivers/hid/hid-pl.c

133

strong = &report->field[2]->value[0];

drivers/hid/hid-pl.c

134

weak = &report->field[3]->value[0];

drivers/hid/hid-pl.c

157

plff->report = report;

drivers/hid/hid-pl.c

164

hid_hw_request(hid, plff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-pl.c

41

struct hid_report *report;

drivers/hid/hid-pl.c

64

hid_hw_request(hid, plff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-pl.c

72

struct hid_report *report;

drivers/hid/hid-playstation.c

1295

struct dualsense_output_report *report)

drivers/hid/hid-playstation.c

1300

if (report->bt) {

drivers/hid/hid-playstation.c

1305

crc = ~crc32_le(crc, report->data, report->len - 4);

drivers/hid/hid-playstation.c

1307

report->bt->crc32 = cpu_to_le32(crc);

drivers/hid/hid-playstation.c

1310

hid_hw_output_report(hdev, report->data, report->len);

drivers/hid/hid-playstation.c

1316

struct dualsense_output_report report;

drivers/hid/hid-playstation.c

1319

dualsense_init_output_report(ds, &report, ds->output_report_dmabuf);

drivers/hid/hid-playstation.c

1320

common = report.common;

drivers/hid/hid-playstation.c

1424

dualsense_send_output_report(ds, &report);

drivers/hid/hid-playstation.c

1427

static int dualsense_parse_report(struct ps_device *ps_dev, struct hid_report *report,

drivers/hid/hid-playstation.c

1444

if (hdev->bus == BUS_USB && report->id == DS_INPUT_REPORT_USB &&

drivers/hid/hid-playstation.c

1447

} else if (hdev->bus == BUS_BLUETOOTH && report->id == DS_INPUT_REPORT_BT &&

drivers/hid/hid-playstation.c

1459

hid_err(hdev, "Unhandled reportID=%d\n", report->id);

drivers/hid/hid-playstation.c

1658

struct dualsense_output_report report;

drivers/hid/hid-playstation.c

1665

dualsense_init_output_report(ds, &report, buf);

drivers/hid/hid-playstation.c

1673

report.common->valid_flag2 = DS_OUTPUT_VALID_FLAG2_LIGHTBAR_SETUP_CONTROL_ENABLE;

drivers/hid/hid-playstation.c

1674

report.common->lightbar_setup = DS_OUTPUT_LIGHTBAR_SETUP_LIGHT_OUT; /* Fade light out. */

drivers/hid/hid-playstation.c

1675

dualsense_send_output_report(ds, &report);

drivers/hid/hid-playstation.c

2279

struct dualshock4_output_report report;

drivers/hid/hid-playstation.c

2282

dualshock4_init_output_report(ds4, &report, ds4->output_report_dmabuf);

drivers/hid/hid-playstation.c

2283

common = report.common;

drivers/hid/hid-playstation.c

2335

if (report.bt) {

drivers/hid/hid-playstation.c

2342

report.bt->hw_control = DS4_OUTPUT_HWCTL_HID | DS4_OUTPUT_HWCTL_CRC32;

drivers/hid/hid-playstation.c

2345

report.bt->hw_control |= ds4->bt_poll_interval;

drivers/hid/hid-playstation.c

2350

crc = ~crc32_le(crc, report.data, report.len - 4);

drivers/hid/hid-playstation.c

2352

report.bt->crc32 = cpu_to_le32(crc);

drivers/hid/hid-playstation.c

2355

hid_hw_output_report(ds4->base.hdev, report.data, report.len);

drivers/hid/hid-playstation.c

2358

static int dualshock4_parse_report(struct ps_device *ps_dev, struct hid_report *report,

drivers/hid/hid-playstation.c

2375

if (hdev->bus == BUS_USB && report->id == DS4_INPUT_REPORT_USB &&

drivers/hid/hid-playstation.c

2383

} else if (hdev->bus == BUS_BLUETOOTH && report->id == DS4_INPUT_REPORT_BT &&

drivers/hid/hid-playstation.c

2398

report->id == DS4_INPUT_REPORT_BT_MINIMAL &&

drivers/hid/hid-playstation.c

2410

hid_err(hdev, "Unhandled reportID=%d\n", report->id);

drivers/hid/hid-playstation.c

2554

static int dualshock4_dongle_parse_report(struct ps_device *ps_dev, struct hid_report *report,

drivers/hid/hid-playstation.c

2603

return dualshock4_parse_report(ps_dev, report, data, size);

drivers/hid/hid-playstation.c

2819

static int ps_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-playstation.c

2825

return dev->parse_report(dev, report, data, size);

drivers/hid/hid-playstation.c

55

int (*parse_report)(struct ps_device *dev, struct hid_report *report, u8 *data, int size);

drivers/hid/hid-primax.c

17

static int px_raw_event(struct hid_device *hid, struct hid_report *report,

drivers/hid/hid-primax.c

22

switch (report->id) {

drivers/hid/hid-primax.c

52

hid_info(hid, "unknown report type %d\n", report->id);

drivers/hid/hid-prodikeys.c

264

struct hid_report *report;

drivers/hid/hid-prodikeys.c

266

list_for_each_entry(report,

drivers/hid/hid-prodikeys.c

268

if (!(6 == report->id))

drivers/hid/hid-prodikeys.c

271

if (report->maxfield < 1) {

drivers/hid/hid-prodikeys.c

275

if (report->field[0]->report_count != 2) {

drivers/hid/hid-prodikeys.c

279

pm->pcmidi_report6 = report;

drivers/hid/hid-prodikeys.c

289

struct hid_report *report = pm->pcmidi_report6;

drivers/hid/hid-prodikeys.c

290

report->field[0]->value[0] = 0x01;

drivers/hid/hid-prodikeys.c

291

report->field[0]->value[1] = state;

drivers/hid/hid-prodikeys.c

293

hid_hw_request(hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-prodikeys.c

765

static int pk_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-prodikeys.c

772

if (report->id == data[0])

drivers/hid/hid-prodikeys.c

773

switch (report->id) {

drivers/hid/hid-prodikeys.c

778

report->id, data, size);

drivers/hid/hid-pxrc.c

53

static int pxrc_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-rapoo.c

70

static int rapoo_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size)

drivers/hid/hid-rapoo.c

77

if (report->id == 1 && size >= 2) {

drivers/hid/hid-retrode.c

22

struct hid_field *field = hi->report->field[0];

drivers/hid/hid-retrode.c

27

switch (field->report->id) {

drivers/hid/hid-retrode.c

34

number = field->report->id;

drivers/hid/hid-retrode.c

39

number = field->report->id - 2;

drivers/hid/hid-retrode.c

42

hid_err(hdev, "Got unhandled report id %d\n", field->report->id);

drivers/hid/hid-rmi.c

105

static int rmi_write_report(struct hid_device *hdev, u8 *report, int len);

drivers/hid/hid-rmi.c

165

static int rmi_write_report(struct hid_device *hdev, u8 *report, int len)

drivers/hid/hid-rmi.c

174

ret = hid_hw_raw_request(hdev, report[0], report,

drivers/hid/hid-rmi.c

177

ret = hid_hw_output_report(hdev, (void *)report, len);

drivers/hid/hid-rmi.c

375

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-rmi.c

422

static void rmi_report(struct hid_device *hid, struct hid_report *report)

drivers/hid/hid-rmi.c

424

struct hid_field *field = report->field[0];

drivers/hid/hid-rmi.c

429

switch (report->id) {

drivers/hid/hid-rmi.c

561

unsigned id, struct hid_report **report)

drivers/hid/hid-rmi.c

565

*report = hdev->report_enum[type].report_id_hash[id];

drivers/hid/hid-rmi.c

566

if (*report) {

drivers/hid/hid-rmi.c

567

for (i = 0; i < (*report)->maxfield; i++) {

drivers/hid/hid-rmi.c

568

unsigned app = (*report)->field[i]->application;

drivers/hid/hid-rmi.c

772

.report = rmi_report,

drivers/hid/hid-roccat-arvo.c

407

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-roccat-isku.c

402

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-roccat-kone.c

844

static int kone_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-roccat-koneplus.c

514

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-roccat-konepure.c

175

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-roccat-kovaplus.c

605

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-roccat-pyra.c

547

static int pyra_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-roccat-ryos.c

183

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-roccat-savu.c

173

struct hid_report *report, u8 *data, int size)

drivers/hid/hid-roccat.c

118

report = &device->cbuf[reader->cbuf_start];

drivers/hid/hid-roccat.c

125

if (copy_to_user(buffer, report->value, len)) {

drivers/hid/hid-roccat.c

251

struct roccat_report *report;

drivers/hid/hid-roccat.c

263

report = &device->cbuf[device->cbuf_end];

drivers/hid/hid-roccat.c

266

kfree(report->value);

drivers/hid/hid-roccat.c

268

report->value = new_value;

drivers/hid/hid-roccat.c

78

struct roccat_report *report;

drivers/hid/hid-saitek.c

94

struct hid_report *report, u8 *raw_data, int size)

drivers/hid/hid-sensor-custom.c

476

struct hid_report *report,

drivers/hid/hid-sensor-custom.c

498

sensor_field->attribute.report_id = report->id;

drivers/hid/hid-sensor-custom.c

533

struct hid_report *report;

drivers/hid/hid-sensor-custom.c

537

list_for_each_entry(report, &report_enum->report_list, list) {

drivers/hid/hid-sensor-custom.c

538

for (i = 0; i < report->maxfield; ++i) {

drivers/hid/hid-sensor-custom.c

539

field = report->field[i];

drivers/hid/hid-sensor-custom.c

549

report,

drivers/hid/hid-sensor-hub.c

193

struct hid_report *report;

drivers/hid/hid-sensor-hub.c

202

report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT);

drivers/hid/hid-sensor-hub.c

203

if (!report || (field_index >= report->maxfield)) {

drivers/hid/hid-sensor-hub.c

212

ret = hid_set_field(report->field[field_index], i,

drivers/hid/hid-sensor-hub.c

223

ret = hid_set_field(report->field[field_index], i,

drivers/hid/hid-sensor-hub.c

228

hid_hw_request(hsdev->hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-sensor-hub.c

241

struct hid_report *report;

drivers/hid/hid-sensor-hub.c

252

report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT);

drivers/hid/hid-sensor-hub.c

253

if (!report || (field_index >= report->maxfield) ||

drivers/hid/hid-sensor-hub.c

254

report->field[field_index]->report_count < 1) {

drivers/hid/hid-sensor-hub.c

258

hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT);

drivers/hid/hid-sensor-hub.c

262

report_size = DIV_ROUND_UP(report->field[field_index]->report_size,

drivers/hid/hid-sensor-hub.c

264

report->field[field_index]->report_count;

drivers/hid/hid-sensor-hub.c

271

val_ptr = (u8 *)report->field[field_index]->value;

drivers/hid/hid-sensor-hub.c

272

for (i = 0; i < report->field[field_index]->report_count; ++i) {

drivers/hid/hid-sensor-hub.c

277

report->field[field_index]->report_size / 8);

drivers/hid/hid-sensor-hub.c

279

buffer_index += (report->field[field_index]->report_size / 8);

drivers/hid/hid-sensor-hub.c

298

struct hid_report *report;

drivers/hid/hid-sensor-hub.c

301

report = sensor_hub_report(report_id, hsdev->hdev,

drivers/hid/hid-sensor-hub.c

303

if (!report)

drivers/hid/hid-sensor-hub.c

319

hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT);

drivers/hid/hid-sensor-hub.c

355

struct hid_report *report;

drivers/hid/hid-sensor-hub.c

359

report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT);

drivers/hid/hid-sensor-hub.c

360

if (!report || (field_index >= report->maxfield))

drivers/hid/hid-sensor-hub.c

363

field = report->field[field_index];

drivers/hid/hid-sensor-hub.c

382

struct hid_report *report;

drivers/hid/hid-sensor-hub.c

396

list_for_each_entry(report, &report_enum->report_list, list) {

drivers/hid/hid-sensor-hub.c

397

for (i = 0; i < report->maxfield; ++i) {

drivers/hid/hid-sensor-hub.c

398

field = report->field[i];

drivers/hid/hid-sensor-hub.c

411

report->id,

drivers/hid/hid-sensor-hub.c

470

struct hid_report *report, u8 *raw_data, int size)

drivers/hid/hid-sensor-hub.c

483

report->id, size, report->type);

drivers/hid/hid-sensor-hub.c

484

hid_dbg(hdev, "maxfield:%d\n", report->maxfield);

drivers/hid/hid-sensor-hub.c

485

if (report->type != HID_INPUT_REPORT)

drivers/hid/hid-sensor-hub.c

489

if (report->id)

drivers/hid/hid-sensor-hub.c

494

for (i = 0; i < report->maxfield; ++i) {

drivers/hid/hid-sensor-hub.c

496

i, report->field[i]->usage->collection_index,

drivers/hid/hid-sensor-hub.c

497

report->field[i]->usage->hid,

drivers/hid/hid-sensor-hub.c

498

(report->field[i]->report_size *

drivers/hid/hid-sensor-hub.c

499

report->field[i]->report_count)/8);

drivers/hid/hid-sensor-hub.c

500

sz = (report->field[i]->report_size *

drivers/hid/hid-sensor-hub.c

501

report->field[i]->report_count)/8;

drivers/hid/hid-sensor-hub.c

503

report->field[i]->usage->collection_index];

drivers/hid/hid-sensor-hub.c

508

report->field[i]->physical ? report->field[i]->physical :

drivers/hid/hid-sensor-hub.c

509

report->field[i]->application,

drivers/hid/hid-sensor-hub.c

510

report->field[i]->usage[0].collection_index,

drivers/hid/hid-sensor-hub.c

517

report->field[i]->usage->hid ||

drivers/hid/hid-sensor-hub.c

519

report->field[i]->logical)) {

drivers/hid/hid-sensor-hub.c

529

if (report->field[i]->logical)

drivers/hid/hid-sensor-hub.c

531

report->field[i]->logical, sz, ptr,

drivers/hid/hid-sensor-hub.c

535

report->field[i]->usage->hid, sz, ptr,

drivers/hid/hid-sensor-hub.c

58

struct hid_report *report;

drivers/hid/hid-sensor-hub.c

60

list_for_each_entry(report, &hdev->report_enum[dir].report_list, list) {

drivers/hid/hid-sensor-hub.c

61

if (report->id == id)

drivers/hid/hid-sensor-hub.c

62

return report;

drivers/hid/hid-sjoy.c

100

sjoyff->report = report;

drivers/hid/hid-sjoy.c

101

sjoyff->report->field[0]->value[0] = 0x01;

drivers/hid/hid-sjoy.c

102

sjoyff->report->field[0]->value[1] = 0x00;

drivers/hid/hid-sjoy.c

103

sjoyff->report->field[0]->value[2] = 0x00;

drivers/hid/hid-sjoy.c

104

hid_hw_request(hid, sjoyff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-sjoy.c

26

struct hid_report *report;

drivers/hid/hid-sjoy.c

43

sjoyff->report->field[0]->value[1] = right;

drivers/hid/hid-sjoy.c

44

sjoyff->report->field[0]->value[2] = left;

drivers/hid/hid-sjoy.c

46

hid_hw_request(hid, sjoyff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-sjoy.c

54

struct hid_report *report;

drivers/hid/hid-sjoy.c

75

report = list_entry(report_ptr, struct hid_report, list);

drivers/hid/hid-sjoy.c

76

if (report->maxfield < 1) {

drivers/hid/hid-sjoy.c

81

if (report->field[0]->report_count < 3) {

drivers/hid/hid-sony.c

1009

static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-sony.c

1290

static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };

drivers/hid/hid-sony.c

1294

buf = kmemdup(report, sizeof(report), GFP_KERNEL);

drivers/hid/hid-sony.c

1298

ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),

drivers/hid/hid-sony.c

1337

struct hid_report *report = list_entry(report_list->next,

drivers/hid/hid-sony.c

1339

s32 *value = report->field[0]->value;

drivers/hid/hid-sony.c

1350

hid_hw_request(hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-sony.c

1585

struct sixaxis_output_report *report =

drivers/hid/hid-sony.c

1590

memcpy(report, &default_report, sizeof(struct sixaxis_output_report));

drivers/hid/hid-sony.c

1593

report->rumble.right_motor_on = sc->right ? 1 : 0;

drivers/hid/hid-sony.c

1594

report->rumble.left_motor_force = sc->left;

drivers/hid/hid-sony.c

1597

report->leds_bitmap |= sc->led_state[0] << 1;

drivers/hid/hid-sony.c

1598

report->leds_bitmap |= sc->led_state[1] << 2;

drivers/hid/hid-sony.c

1599

report->leds_bitmap |= sc->led_state[2] << 3;

drivers/hid/hid-sony.c

1600

report->leds_bitmap |= sc->led_state[3] << 4;

drivers/hid/hid-sony.c

1603

if ((report->leds_bitmap & 0x1E) == 0)

drivers/hid/hid-sony.c

1604

report->leds_bitmap |= 0x20;

drivers/hid/hid-sony.c

1617

report->led[3 - n].duty_off = sc->led_delay_off[n];

drivers/hid/hid-sony.c

1618

report->led[3 - n].duty_on = sc->led_delay_on[n];

drivers/hid/hid-sony.c

1624

hid_hw_output_report(sc->hdev, (u8 *)report,

drivers/hid/hid-sony.c

1627

hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,

drivers/hid/hid-sony.c

1635

struct motion_output_report_02 *report =

drivers/hid/hid-sony.c

1638

memset(report, 0, MOTION_REPORT_0x02_SIZE);

drivers/hid/hid-sony.c

1640

report->type = 0x02; /* set leds */

drivers/hid/hid-sony.c

1641

report->r = sc->led_state[0];

drivers/hid/hid-sony.c

1642

report->g = sc->led_state[1];

drivers/hid/hid-sony.c

1643

report->b = sc->led_state[2];

drivers/hid/hid-sony.c

1646

report->rumble = max(sc->right, sc->left);

drivers/hid/hid-sony.c

1649

hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);

drivers/hid/hid-steam.c

1734

struct hid_report *report, u8 *data,

drivers/hid/hid-steam.c

493

u8 report[10] = {ID_TRIGGER_HAPTIC_PULSE, 8};

drivers/hid/hid-steam.c

499

report[2] = pad;

drivers/hid/hid-steam.c

500

report[3] = duration & 0xFF;

drivers/hid/hid-steam.c

501

report[4] = duration >> 8;

drivers/hid/hid-steam.c

502

report[5] = interval & 0xFF;

drivers/hid/hid-steam.c

503

report[6] = interval >> 8;

drivers/hid/hid-steam.c

504

report[7] = count & 0xFF;

drivers/hid/hid-steam.c

505

report[8] = count >> 8;

drivers/hid/hid-steam.c

506

report[9] = gain;

drivers/hid/hid-steam.c

509

ret = steam_send_report(steam, report, sizeof(report));

drivers/hid/hid-steam.c

519

u8 report[11] = {ID_TRIGGER_RUMBLE_CMD, 9};

drivers/hid/hid-steam.c

521

report[3] = intensity & 0xFF;

drivers/hid/hid-steam.c

522

report[4] = intensity >> 8;

drivers/hid/hid-steam.c

523

report[5] = left_speed & 0xFF;

drivers/hid/hid-steam.c

524

report[6] = left_speed >> 8;

drivers/hid/hid-steam.c

525

report[7] = right_speed & 0xFF;

drivers/hid/hid-steam.c

526

report[8] = right_speed >> 8;

drivers/hid/hid-steam.c

527

report[9] = left_gain;

drivers/hid/hid-steam.c

528

report[10] = right_gain;

drivers/hid/hid-steam.c

531

ret = steam_send_report(steam, report, sizeof(report));

drivers/hid/hid-steelseries.c

134

struct hid_report *report = list_entry(report_list->next, struct hid_report, list);

drivers/hid/hid-steelseries.c

135

__s32 *value = report->field[0]->value;

drivers/hid/hid-steelseries.c

154

hid_hw_request(hdev, report, HID_REQ_SET_REPORT);

drivers/hid/hid-steelseries.c

628

struct hid_report *report, u8 *read_buf,

drivers/hid/hid-tmff.c

112

hid_hw_request(hid, tmff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-tmff.c

121

struct hid_report *report;

drivers/hid/hid-tmff.c

141

list_for_each_entry(report, report_list, list) {

drivers/hid/hid-tmff.c

144

for (fieldnum = 0; fieldnum < report->maxfield; ++fieldnum) {

drivers/hid/hid-tmff.c

145

struct hid_field *field = report->field[fieldnum];

drivers/hid/hid-tmff.c

163

if (tmff->report && tmff->report != report) {

drivers/hid/hid-tmff.c

173

tmff->report = report;

drivers/hid/hid-tmff.c

189

if (!tmff->report) {

drivers/hid/hid-tmff.c

43

struct hid_report *report;

drivers/hid/hid-tmff.c

94

hid_hw_request(hid, tmff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-uclogic-core.c

136

if (!hi->report)

drivers/hid/hid-uclogic-core.c

143

if (hi->report->id == params->pen.id) {

drivers/hid/hid-uclogic-core.c

151

if (hi->report->id == frame->id) {

drivers/hid/hid-uclogic-core.c

164

field = hi->report->field[0];

drivers/hid/hid-uclogic-core.c

489

struct hid_report *report,

drivers/hid/hid-uclogic-core.c

492

unsigned int report_id = report->id;

drivers/hid/hid-uclogic-core.c

500

if (report->type != HID_INPUT_REPORT)

drivers/hid/hid-udraw-ps3.c

101

static int udraw_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-vivaldi-common.c

35

struct hid_report *report = field->report;

drivers/hid/hid-vivaldi-common.c

52

report_data = buf = hid_alloc_report_buf(report, GFP_KERNEL);

drivers/hid/hid-vivaldi-common.c

56

report_len = hid_report_len(report);

drivers/hid/hid-vivaldi-common.c

57

if (!report->id) {

drivers/hid/hid-vivaldi-common.c

69

ret = hid_hw_raw_request(hdev, report->id, report_data,

drivers/hid/hid-vivaldi-common.c

74

field->report->id);

drivers/hid/hid-vivaldi-common.c

78

if (!report->id) {

drivers/hid/hid-vivaldi-common.c

91

field->report->id);

drivers/hid/hid-waltop.c

652

static int waltop_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-waltop.c

656

if (report->type == HID_INPUT_REPORT && report->id == 16 && size >= 8) {

drivers/hid/hid-waltop.c

672

report->type == HID_INPUT_REPORT &&

drivers/hid/hid-waltop.c

673

report->id == 16 &&

drivers/hid/hid-wiimote-core.c

1622

static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-zpff.c

22

struct hid_report *report;

drivers/hid/hid-zpff.c

45

zpff->report->field[2]->value[0] = left;

drivers/hid/hid-zpff.c

46

zpff->report->field[3]->value[0] = right;

drivers/hid/hid-zpff.c

48

hid_hw_request(hid, zpff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-zpff.c

56

struct hid_report *report;

drivers/hid/hid-zpff.c

69

report = hid_validate_values(hid, HID_OUTPUT_REPORT, 0, i, 1);

drivers/hid/hid-zpff.c

70

if (!report)

drivers/hid/hid-zpff.c

86

zpff->report = report;

drivers/hid/hid-zpff.c

87

zpff->report->field[0]->value[0] = 0x00;

drivers/hid/hid-zpff.c

88

zpff->report->field[1]->value[0] = 0x02;

drivers/hid/hid-zpff.c

89

zpff->report->field[2]->value[0] = 0x00;

drivers/hid/hid-zpff.c

90

zpff->report->field[3]->value[0] = 0x00;

drivers/hid/hid-zpff.c

91

hid_hw_request(hid, zpff->report, HID_REQ_SET_REPORT);

drivers/hid/hid-zydacron.c

109

static int zc_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/hid-zydacron.c

117

if (report->id == data[0] && (hdev->claimed & HID_CLAIMED_INPUT)) {

drivers/hid/hid-zydacron.c

129

switch (report->id) {

drivers/hid/i2c-hid/i2c-hid-core.c

594

static int i2c_hid_get_report_length(struct hid_report *report)

drivers/hid/i2c-hid/i2c-hid-core.c

596

return ((report->size - 1) >> 3) + 1 +

drivers/hid/i2c-hid/i2c-hid-core.c

597

report->device->report_enum[report->type].numbered + 2;

drivers/hid/i2c-hid/i2c-hid-core.c

606

struct hid_report *report;

drivers/hid/i2c-hid/i2c-hid-core.c

611

list_for_each_entry(report, &hid->report_enum[type].report_list, list) {

drivers/hid/i2c-hid/i2c-hid-core.c

612

size = i2c_hid_get_report_length(report);

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

283

report = reports_list->reports;

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

286

recv_msg = container_of(&report->msg,

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

288

report_len = report->size;

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

306

report += sizeof(*report) + payload_len;

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

76

struct report *report;

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

66

struct report reports[];

drivers/hid/surface-hid/surface_kbd.c

164

if (len != hid_report_len(field->report))

drivers/hid/surface-hid/surface_kbd.c

167

if (rprt_id != field->report->id)

drivers/hid/surface-hid/surface_kbd.c

202

u8 report[KBD_FEATURE_REPORT_SIZE];

drivers/hid/surface-hid/surface_kbd.c

211

if (len < ARRAY_SIZE(report))

drivers/hid/surface-hid/surface_kbd.c

214

status = ssam_kbd_get_feature_report(shid, report, ARRAY_SIZE(report));

drivers/hid/surface-hid/surface_kbd.c

218

if (rprt_id != report[0])

drivers/hid/surface-hid/surface_kbd.c

221

memcpy(buf, report, ARRAY_SIZE(report));

drivers/hid/usbhid/hid-core.c

1320

static int usbhid_idle(struct hid_device *hid, int report, int idle,

drivers/hid/usbhid/hid-core.c

1331

return hid_set_idle(dev, ifnum, report, idle);

drivers/hid/usbhid/hid-core.c

339

struct hid_report *report;

drivers/hid/usbhid/hid-core.c

344

report = usbhid->out[usbhid->outtail].report;

drivers/hid/usbhid/hid-core.c

347

usbhid->urbout->transfer_buffer_length = hid_report_len(report);

drivers/hid/usbhid/hid-core.c

369

struct hid_report *report;

drivers/hid/usbhid/hid-core.c

375

report = usbhid->ctrl[usbhid->ctrltail].report;

drivers/hid/usbhid/hid-core.c

379

len = hid_report_len(report);

drivers/hid/usbhid/hid-core.c

404

usbhid->cr->wValue = cpu_to_le16(((report->type + 1) << 8) |

drivers/hid/usbhid/hid-core.c

405

report->id);

drivers/hid/usbhid/hid-core.c

486

usbhid->ctrl[usbhid->ctrltail].report->type,

drivers/hid/usbhid/hid-core.c

523

static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *report,

drivers/hid/usbhid/hid-core.c

533

if (usbhid->urbout && dir == USB_DIR_OUT && report->type == HID_OUTPUT_REPORT) {

drivers/hid/usbhid/hid-core.c

539

usbhid->out[usbhid->outhead].raw_report = hid_alloc_report_buf(report, GFP_ATOMIC);

drivers/hid/usbhid/hid-core.c

544

hid_output_report(report, usbhid->out[usbhid->outhead].raw_report);

drivers/hid/usbhid/hid-core.c

545

usbhid->out[usbhid->outhead].report = report;

drivers/hid/usbhid/hid-core.c

588

usbhid->ctrl[usbhid->ctrlhead].raw_report = hid_alloc_report_buf(report, GFP_ATOMIC);

drivers/hid/usbhid/hid-core.c

593

hid_output_report(report, usbhid->ctrl[usbhid->ctrlhead].raw_report);

drivers/hid/usbhid/hid-core.c

595

usbhid->ctrl[usbhid->ctrlhead].report = report;

drivers/hid/usbhid/hid-core.c

632

static void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir)

drivers/hid/usbhid/hid-core.c

638

__usbhid_submit_report(hid, report, dir);

drivers/hid/usbhid/hid-core.c

657

static int hid_set_idle(struct usb_device *dev, int ifnum, int report, int idle)

drivers/hid/usbhid/hid-core.c

660

HID_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE, (idle << 8) | report,

drivers/hid/usbhid/hid-core.c

771

struct hid_report *report;

drivers/hid/usbhid/hid-core.c

777

list_for_each_entry(report, &report_enum->report_list, list)

drivers/hid/usbhid/hid-core.c

778

usbhid_submit_report(hid, report, USB_DIR_IN);

drivers/hid/usbhid/hid-core.c

781

list_for_each_entry(report, &report_enum->report_list, list)

drivers/hid/usbhid/hid-core.c

782

usbhid_submit_report(hid, report, USB_DIR_IN);

drivers/hid/usbhid/hid-core.c

805

struct hid_report *report;

drivers/hid/usbhid/hid-core.c

810

list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {

drivers/hid/usbhid/hid-core.c

811

for (i = 0; i < report->maxfield; i++) {

drivers/hid/usbhid/hid-core.c

812

field = report->field[i];

drivers/hid/usbhid/hid-core.c

833

usbhid_submit_report(hid, field->report, USB_DIR_OUT);

drivers/hid/usbhid/hid-core.c

843

struct hid_report *report;

drivers/hid/usbhid/hid-core.c

846

list_for_each_entry(report, &hid->report_enum[type].report_list, list) {

drivers/hid/usbhid/hid-core.c

847

size = ((report->size - 1) >> 3) + 1 + hid->report_enum[type].numbered;

drivers/hid/usbhid/hid-pidff.c

1035

struct hid_report *report,

drivers/hid/usbhid/hid-pidff.c

1038

for (int i = 0; i < report->maxfield; i++) {

drivers/hid/usbhid/hid-pidff.c

1039

struct hid_field *fld = report->field[i];

drivers/hid/usbhid/hid-pidff.c

1060

struct hid_report *report, int count, int strict,

drivers/hid/usbhid/hid-pidff.c

1066

if (!report) {

drivers/hid/usbhid/hid-pidff.c

1073

int found = pidff_find_field_with_usage(&index, report,

drivers/hid/usbhid/hid-pidff.c

1078

usage[i].field = report->field[found];

drivers/hid/usbhid/hid-pidff.c

1079

usage[i].value = &report->field[found]->value[index];

drivers/hid/usbhid/hid-pidff.c

1122

struct hid_report *report;

drivers/hid/usbhid/hid-pidff.c

1125

list_for_each_entry(report,

drivers/hid/usbhid/hid-pidff.c

1127

if (report->maxfield < 1)

drivers/hid/usbhid/hid-pidff.c

1129

ret = pidff_check_usage(report->field[0]->logical);

drivers/hid/usbhid/hid-pidff.c

1133

pidff->reports[ret] = report;

drivers/hid/usbhid/hid-pidff.c

1144

i = report->field[0]->usage[0].collection_index;

drivers/hid/usbhid/hid-pidff.c

1153

pidff->reports[ret] = report;

drivers/hid/usbhid/hid-pidff.c

1176

static struct hid_field *pidff_find_special_field(struct hid_report *report,

drivers/hid/usbhid/hid-pidff.c

1179

if (!report) {

drivers/hid/usbhid/hid-pidff.c

1184

for (int i = 0; i < report->maxfield; i++) {

drivers/hid/usbhid/hid-pidff.c

1185

if (report->field[i]->logical == (HID_UP_PID | usage) &&

drivers/hid/usbhid/hid-pidff.c

1186

report->field[i]->report_count > 0) {

drivers/hid/usbhid/hid-pidff.c

1188

report->field[i]->logical_minimum == 1)

drivers/hid/usbhid/hid-pidff.c

1189

return report->field[i];

drivers/hid/usbhid/hid-pidff.c

1399

#define PIDFF_FIND_FIELDS(name, report, strict) \

drivers/hid/usbhid/hid-pidff.c

1401

pidff->reports[report], \

drivers/hid/usbhid/hiddev.c

112

struct hid_report *report;

drivers/hid/usbhid/hiddev.c

123

list_for_each_entry(report, &report_enum->report_list, list) {

drivers/hid/usbhid/hiddev.c

124

for (i = 0; i < report->maxfield; i++) {

drivers/hid/usbhid/hiddev.c

125

field = report->field[i];

drivers/hid/usbhid/hiddev.c

128

uref->report_id = report->id;

drivers/hid/usbhid/hiddev.c

176

uref.report_id = field->report->id;

drivers/hid/usbhid/hiddev.c

186

void hiddev_report_event(struct hid_device *hid, struct hid_report *report)

drivers/hid/usbhid/hiddev.c

188

unsigned type = report->type;

drivers/hid/usbhid/hiddev.c

196

uref.report_id = report->id;

drivers/hid/usbhid/hiddev.c

433

struct hid_report *report;

drivers/hid/usbhid/hiddev.c

454

if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)

drivers/hid/usbhid/hiddev.c

457

if (uref->field_index >= report->maxfield)

drivers/hid/usbhid/hiddev.c

460

report->maxfield);

drivers/hid/usbhid/hiddev.c

462

field = report->field[uref->field_index];

drivers/hid/usbhid/hiddev.c

488

if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)

drivers/hid/usbhid/hiddev.c

491

if (uref->field_index >= report->maxfield)

drivers/hid/usbhid/hiddev.c

494

report->maxfield);

drivers/hid/usbhid/hiddev.c

496

field = report->field[uref->field_index];

drivers/hid/usbhid/hiddev.c

603

struct hid_report *report;

drivers/hid/usbhid/hiddev.c

61

struct hid_report *report;

drivers/hid/usbhid/hiddev.c

703

report = hiddev_lookup_report(hid, &rinfo);

drivers/hid/usbhid/hiddev.c

704

if (report == NULL)

drivers/hid/usbhid/hiddev.c

707

hid_hw_request(hid, report, HID_REQ_GET_REPORT);

drivers/hid/usbhid/hiddev.c

722

report = hiddev_lookup_report(hid, &rinfo);

drivers/hid/usbhid/hiddev.c

723

if (report == NULL)

drivers/hid/usbhid/hiddev.c

726

hid_hw_request(hid, report, HID_REQ_SET_REPORT);

drivers/hid/usbhid/hiddev.c

738

report = hiddev_lookup_report(hid, &rinfo);

drivers/hid/usbhid/hiddev.c

739

if (report == NULL)

drivers/hid/usbhid/hiddev.c

742

rinfo.num_fields = report->maxfield;

drivers/hid/usbhid/hiddev.c

757

report = hiddev_lookup_report(hid, &rinfo);

drivers/hid/usbhid/hiddev.c

758

if (report == NULL)

drivers/hid/usbhid/hiddev.c

761

if (finfo.field_index >= report->maxfield)

drivers/hid/usbhid/hiddev.c

764

report->maxfield);

drivers/hid/usbhid/hiddev.c

766

field = report->field[finfo.field_index];

drivers/hid/usbhid/hiddev.c

80

report = list_entry(list, struct hid_report, list);

drivers/hid/usbhid/hiddev.c

81

rinfo->report_id = report->id;

drivers/hid/usbhid/hiddev.c

85

report = report_enum->report_id_hash[rid];

drivers/hid/usbhid/hiddev.c

86

if (!report)

drivers/hid/usbhid/hiddev.c

89

list = report->list.next;

drivers/hid/usbhid/hiddev.c

93

report = list_entry(list, struct hid_report, list);

drivers/hid/usbhid/hiddev.c

94

rinfo->report_id = report->id;

drivers/hid/wacom.h

243

void wacom_wac_report(struct hid_device *hdev, struct hid_report *report);

drivers/hid/wacom_sys.c

104

struct hid_report *report, u8 *raw_data, int report_size)

drivers/hid/wacom_sys.c

117

for (i = 0; i < report->maxfield; i++) {

drivers/hid/wacom_sys.c

118

for (j = 0; j < report->field[i]->maxusage; j++) {

drivers/hid/wacom_sys.c

119

struct hid_field *field = report->field[i];

drivers/hid/wacom_sys.c

171

static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,

drivers/hid/wacom_sys.c

179

if (wacom_wac_pen_serial_enforce(hdev, report, raw_data, size))

drivers/hid/wacom_sys.c

2250

struct hid_report *report;

drivers/hid/wacom_sys.c

2255

list_for_each_entry(report, &report_enum->report_list, list) {

drivers/hid/wacom_sys.c

2256

size_t report_size = hid_report_len(report);

drivers/hid/wacom_sys.c

238

wacom->wacom_wac.mode_report = field->report->id;

drivers/hid/wacom_sys.c

276

field->index + 2 < field->report->maxfield) {

drivers/hid/wacom_sys.c

277

struct hid_field *a = field->report->field[field->index + 1];

drivers/hid/wacom_sys.c

278

struct hid_field *b = field->report->field[field->index + 2];

drivers/hid/wacom_sys.c

2949

.report = wacom_wac_report,

drivers/hid/wacom_sys.c

328

n = hid_report_len(field->report);

drivers/hid/wacom_sys.c

329

data = hid_alloc_report_buf(field->report, GFP_KERNEL);

drivers/hid/wacom_sys.c

332

data[0] = field->report->id;

drivers/hid/wacom_sys.c

357

hid_data->inputmode = field->report->id;

drivers/hid/wacom_sys.c

362

if (field->report->id == 0x0B &&

drivers/hid/wacom_sys.c

365

wacom->wacom_wac.mode_report = field->report->id;

drivers/hid/wacom_sys.c

371

wacom->wacom_wac.mode_report = field->report->id;

drivers/hid/wacom_sys.c

377

if (field->report->id == 0x03 &&

drivers/hid/wacom_sys.c

380

wacom->wacom_wac.mode_report = field->report->id;

drivers/hid/wacom_sys.c

389

n = hid_report_len(field->report);

drivers/hid/wacom_sys.c

390

data = hid_alloc_report_buf(field->report, GFP_KERNEL);

drivers/hid/wacom_sys.c

393

data[0] = field->report->id;

drivers/hid/wacom_wac.c

1978

struct hid_report *report)

drivers/hid/wacom_wac.c

1984

struct hid_report *report)

drivers/hid/wacom_wac.c

2280

struct hid_report *report)

drivers/hid/wacom_wac.c

2289

struct hid_report *report, struct hid_field *field)

drivers/hid/wacom_wac.c

2557

struct hid_report *report)

drivers/hid/wacom_wac.c

2567

struct hid_report *report)

drivers/hid/wacom_wac.c

2690

wacom_wac->hid_data.cc_report = field->report->id;

drivers/hid/wacom_wac.c

2822

struct hid_report *report)

drivers/hid/wacom_wac.c

2840

for (i = 0; i < report->maxfield; i++) {

drivers/hid/wacom_wac.c

2841

struct hid_field *field = report->field[i];

drivers/hid/wacom_wac.c

2861

hid_data->cc_report = report->id;

drivers/hid/wacom_wac.c

2871

struct hid_field *field = report->field[hid_data->cc_index];

drivers/hid/wacom_wac.c

2885

struct hid_report *report)

drivers/hid/wacom_wac.c

2958

struct hid_report *report, int collection_index,

drivers/hid/wacom_wac.c

2963

for (r = field_index; r < report->maxfield; r++) {

drivers/hid/wacom_wac.c

2967

field = report->field[r];

drivers/hid/wacom_wac.c

2983

static int wacom_wac_collection(struct hid_device *hdev, struct hid_report *report,

drivers/hid/wacom_wac.c

2989

wacom_report_events(hdev, report, collection_index, field_index);

drivers/hid/wacom_wac.c

2998

if (report->type != HID_INPUT_REPORT)

drivers/hid/wacom_wac.c

3004

wacom_wac_pen_report(hdev, report);

drivers/hid/wacom_wac.c

3006

wacom_wac_finger_report(hdev, report);

drivers/hid/wacom_wac.c

3011

void wacom_wac_report(struct hid_device *hdev, struct hid_report *report)

drivers/hid/wacom_wac.c

3024

for (r = 0; r < report->maxfield; r++) {

drivers/hid/wacom_wac.c

3025

field = report->field[r];

drivers/hid/wacom_wac.c

3037

wacom_wac_battery_pre_report(hdev, report);

drivers/hid/wacom_wac.c

3040

wacom_wac_pad_pre_report(hdev, report);

drivers/hid/wacom_wac.c

3042

wacom_wac_pen_pre_report(hdev, report);

drivers/hid/wacom_wac.c

3044

wacom_wac_finger_pre_report(hdev, report);

drivers/hid/wacom_wac.c

3046

for (r = 0; r < report->maxfield; r++) {

drivers/hid/wacom_wac.c

3047

field = report->field[r];

drivers/hid/wacom_wac.c

3050

if (wacom_wac_collection(hdev, report,

drivers/hid/wacom_wac.c

3057

wacom_wac_battery_report(hdev, report);

drivers/hid/wacom_wac.c

3060

wacom_wac_pad_report(hdev, report, field);

drivers/hv/hv_balloon.c

1661

dm_device.pr_dev_info.report = hv_free_page_report;

drivers/hv/hv_balloon.c

1669

dm_device.pr_dev_info.report = NULL;

drivers/hv/hv_balloon.c

1679

if (dm_device.pr_dev_info.report) {

drivers/hv/hv_balloon.c

1681

dm_device.pr_dev_info.report = NULL;

drivers/hwmon/aquacomputer_d5next.c

1327

static int aqc_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size)

drivers/hwmon/aquacomputer_d5next.c

1332

if (report->id != STATUS_REPORT_ID)

drivers/hwmon/asus_rog_ryujin.c

387

static int rog_ryujin_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data,

drivers/hwmon/corsair-cpro.c

156

static int ccp_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size)

drivers/hwmon/corsair-psu.c

840

static int corsairpsu_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data,

drivers/hwmon/gigabyte_waterforce.c

255

static int waterforce_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data,

drivers/hwmon/nzxt-kraken2.c

101

if (size < 7 || report->id != STATUS_REPORT_ID)

drivers/hwmon/nzxt-kraken2.c

97

struct hid_report *report, u8 *data, int size)

drivers/hwmon/nzxt-kraken3.c

730

static int kraken3_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size)

drivers/hwmon/nzxt-kraken3.c

738

if (report->id == FIRMWARE_REPORT_ID) {

drivers/hwmon/nzxt-kraken3.c

749

if (report->id != STATUS_REPORT_ID)

drivers/hwmon/nzxt-smart2.c

223

struct fan_config_report *report = data;

drivers/hwmon/nzxt-smart2.c

229

if (report->magic != 0x03)

drivers/hwmon/nzxt-smart2.c

235

drvdata->fan_type[i] = report->fan_type[i];

drivers/hwmon/nzxt-smart2.c

244

struct fan_status_report *report = data;

drivers/hwmon/nzxt-smart2.c

264

if (drvdata->fan_type[i] == report->fan_type[i])

drivers/hwmon/nzxt-smart2.c

276

i, drvdata->fan_type[i], report->fan_type[i]);

drivers/hwmon/nzxt-smart2.c

277

drvdata->fan_type[i] = report->fan_type[i];

drivers/hwmon/nzxt-smart2.c

280

switch (report->type) {

drivers/hwmon/nzxt-smart2.c

284

get_unaligned_le16(&report->fan_speed.fan_rpm[i]);

drivers/hwmon/nzxt-smart2.c

286

report->fan_speed.duty_percent[i];

drivers/hwmon/nzxt-smart2.c

296

get_unaligned_le16(&report->fan_voltage.fan_in[i]);

drivers/hwmon/nzxt-smart2.c

298

get_unaligned_le16(&report->fan_voltage.fan_current[i]);

drivers/hwmon/nzxt-smart2.c

469

struct set_fan_speed_report report = {

drivers/hwmon/nzxt-smart2.c

479

report.duty_percent[channel] = duty_percent;

drivers/hwmon/nzxt-smart2.c

480

ret = send_output_report(drvdata, &report, sizeof(report));

drivers/hwmon/nzxt-smart2.c

563

u8 report[] = {

drivers/hwmon/nzxt-smart2.c

575

ret = send_output_report(drvdata, report, sizeof(report));

drivers/hwmon/nzxt-smart2.c

689

struct hid_report *report, u8 *data, int size)

drivers/input/mouse/elan_i2c.h

112

int (*get_report)(struct i2c_client *client, u8 *report,

drivers/input/mouse/elan_i2c_core.c

1007

static void elan_report_trackpoint(struct elan_tp_data *data, u8 *report)

drivers/input/mouse/elan_i2c_core.c

1010

u8 *packet = &report[ETP_REPORT_ID_OFFSET + 1];

drivers/input/mouse/elan_i2c_core.c

1040

u8 report[ETP_MAX_REPORT_LEN];

drivers/input/mouse/elan_i2c_core.c

1052

error = data->ops->get_report(data->client, report, data->report_len);

drivers/input/mouse/elan_i2c_core.c

1056

switch (report[ETP_REPORT_ID_OFFSET]) {

drivers/input/mouse/elan_i2c_core.c

1058

elan_report_absolute(data, report, false);

drivers/input/mouse/elan_i2c_core.c

1061

elan_report_absolute(data, report, true);

drivers/input/mouse/elan_i2c_core.c

1065

elan_report_trackpoint(data, report);

drivers/input/mouse/elan_i2c_core.c

1069

report[ETP_REPORT_ID_OFFSET]);

drivers/input/mouse/elan_i2c_i2c.c

725

u8 *report, unsigned int report_len)

drivers/input/mouse/elan_i2c_i2c.c

729

len = i2c_master_recv(client, report, report_len);

drivers/input/mouse/elan_i2c_smbus.c

487

u8 *report, unsigned int report_len)

drivers/input/mouse/elan_i2c_smbus.c

495

&report[ETP_SMBUS_REPORT_OFFSET]);

drivers/input/mouse/elan_i2c_smbus.c

501

if (report[ETP_REPORT_ID_OFFSET] == ETP_TP_REPORT_ID2)

drivers/input/touchscreen/msg2638.c

146

goto report;

drivers/input/touchscreen/msg2638.c

158

goto report;

drivers/input/touchscreen/msg2638.c

166

goto report;

drivers/input/touchscreen/msg2638.c

175

report:

drivers/input/touchscreen/pixcir_i2c_ts.c

104

memset(report, 0, sizeof(struct pixcir_report_data));

drivers/input/touchscreen/pixcir_i2c_ts.c

131

report->num_touches = touch;

drivers/input/touchscreen/pixcir_i2c_ts.c

135

touchscreen_set_mt_pos(&report->pos[i], &tsdata->prop,

drivers/input/touchscreen/pixcir_i2c_ts.c

139

report->ids[i] = bufptr[4];

drivers/input/touchscreen/pixcir_i2c_ts.c

148

struct pixcir_report_data *report)

drivers/input/touchscreen/pixcir_i2c_ts.c

155

n = report->num_touches;

drivers/input/touchscreen/pixcir_i2c_ts.c

160

input_mt_assign_slots(ts->input, slots, report->pos, n, 0);

drivers/input/touchscreen/pixcir_i2c_ts.c

165

report->ids[i]);

drivers/input/touchscreen/pixcir_i2c_ts.c

168

report->ids[i]);

drivers/input/touchscreen/pixcir_i2c_ts.c

179

report->pos[i].x);

drivers/input/touchscreen/pixcir_i2c_ts.c

181

report->pos[i].y);

drivers/input/touchscreen/pixcir_i2c_ts.c

184

i, slot, report->pos[i].x, report->pos[i].y);

drivers/input/touchscreen/pixcir_i2c_ts.c

194

struct pixcir_report_data report;

drivers/input/touchscreen/pixcir_i2c_ts.c

198

pixcir_ts_parse(tsdata, &report);

drivers/input/touchscreen/pixcir_i2c_ts.c

201

pixcir_ts_report(tsdata, &report);

drivers/input/touchscreen/pixcir_i2c_ts.c

204

if (report.num_touches) {

drivers/input/touchscreen/pixcir_i2c_ts.c

94

struct pixcir_report_data *report)

drivers/media/pci/saa7134/saa7134-alsa.c

197

unsigned long report, status;

drivers/media/pci/saa7134/saa7134-alsa.c

201

report = saa_readl(SAA7134_IRQ_REPORT);

drivers/media/pci/saa7134/saa7134-alsa.c

204

if (report & SAA7134_IRQ_REPORT_DONE_RA3) {

drivers/media/pci/saa7134/saa7134-core.c

1296

u32 report = saa_readl(SAA7134_IRQ_REPORT);

drivers/media/pci/saa7134/saa7134-core.c

1298

print_irqstatus(dev,42,report,status);

drivers/media/pci/saa7134/saa7134-core.c

478

unsigned long report, unsigned long status)

drivers/media/pci/saa7134/saa7134-core.c

483

loop, jiffies, report, status);

drivers/media/pci/saa7134/saa7134-core.c

485

if (!(report & (1 << i)))

drivers/media/pci/saa7134/saa7134-core.c

489

if (report & SAA7134_IRQ_REPORT_DONE_RA0) {

drivers/media/pci/saa7134/saa7134-core.c

502

unsigned long report,status;

drivers/media/pci/saa7134/saa7134-core.c

509

report = saa_readl(SAA7134_IRQ_REPORT);

drivers/media/pci/saa7134/saa7134-core.c

515

if ((report & SAA7134_IRQ_REPORT_DONE_RA3) &&

drivers/media/pci/saa7134/saa7134-core.c

519

report &= ~SAA7134_IRQ_REPORT_DONE_RA3;

drivers/media/pci/saa7134/saa7134-core.c

522

if (0 == report) {

drivers/media/pci/saa7134/saa7134-core.c

528

saa_writel(SAA7134_IRQ_REPORT,report);

drivers/media/pci/saa7134/saa7134-core.c

530

print_irqstatus(dev,loop,report,status);

drivers/media/pci/saa7134/saa7134-core.c

533

if ((report & SAA7134_IRQ_REPORT_RDCAP) ||

drivers/media/pci/saa7134/saa7134-core.c

534

(report & SAA7134_IRQ_REPORT_INTL))

drivers/media/pci/saa7134/saa7134-core.c

538

if ((report & SAA7134_IRQ_REPORT_DONE_RA0) &&

drivers/media/pci/saa7134/saa7134-core.c

542

if ((report & SAA7134_IRQ_REPORT_DONE_RA0) &&

drivers/media/pci/saa7134/saa7134-core.c

546

if ((report & SAA7134_IRQ_REPORT_DONE_RA2) &&

drivers/media/pci/saa7134/saa7134-core.c

554

if (report & SAA7134_IRQ_REPORT_GPIO16) {

drivers/media/pci/saa7134/saa7134-core.c

572

if (report & SAA7134_IRQ_REPORT_GPIO18) {

drivers/media/pci/saa7134/saa7134-core.c

593

print_irqstatus(dev,loop,report,status);

drivers/media/pci/saa7134/saa7134-core.c

594

if (report & SAA7134_IRQ_REPORT_PE) {

drivers/media/pci/saa7134/saa7134-core.c

599

} else if (report & SAA7134_IRQ_REPORT_GPIO16) {

drivers/media/pci/saa7134/saa7134-core.c

605

} else if (report & SAA7134_IRQ_REPORT_GPIO18) {

drivers/media/radio/radio-si476x.c

1187

struct si476x_acf_status_report report;

drivers/media/radio/radio-si476x.c

1191

err = radio->ops->acf_status(radio->core, &report);

drivers/media/radio/radio-si476x.c

1199

return simple_read_from_buffer(user_buf, count, ppos, &report,

drivers/media/radio/radio-si476x.c

1200

sizeof(report));

drivers/media/radio/radio-si476x.c

1215

struct si476x_rds_blockcount_report report;

drivers/media/radio/radio-si476x.c

1220

&report);

drivers/media/radio/radio-si476x.c

1228

return simple_read_from_buffer(user_buf, count, ppos, &report,

drivers/media/radio/radio-si476x.c

1229

sizeof(report));

drivers/media/radio/radio-si476x.c

1244

struct si476x_agc_status_report report;

drivers/media/radio/radio-si476x.c

1248

err = radio->ops->agc_status(radio->core, &report);

drivers/media/radio/radio-si476x.c

1256

return simple_read_from_buffer(user_buf, count, ppos, &report,

drivers/media/radio/radio-si476x.c

1257

sizeof(report));

drivers/media/radio/radio-si476x.c

1272

struct si476x_rsq_status_report report;

drivers/media/radio/radio-si476x.c

1283

err = radio->ops->rsq_status(radio->core, &args, &report);

drivers/media/radio/radio-si476x.c

1291

return simple_read_from_buffer(user_buf, count, ppos, &report,

drivers/media/radio/radio-si476x.c

1292

sizeof(report));

drivers/media/radio/radio-si476x.c

1307

struct si476x_rsq_status_report report;

drivers/media/radio/radio-si476x.c

1318

err = radio->ops->rsq_status(radio->core, &args, &report);

drivers/media/radio/radio-si476x.c

1326

return simple_read_from_buffer(user_buf, count, ppos, &report,

drivers/media/radio/radio-si476x.c

1327

sizeof(report));

drivers/media/radio/radio-si476x.c

376

struct si476x_rsq_status_report report;

drivers/media/radio/radio-si476x.c

434

&args, &report);

drivers/media/radio/radio-si476x.c

442

tuner->signal = (report.rssi + 128) * 257;

drivers/media/radio/radio-si476x.c

654

struct si476x_rsq_status_report report;

drivers/media/radio/radio-si476x.c

663

err = radio->ops->rsq_status(radio->core, &args, &report);

drivers/media/radio/radio-si476x.c

666

report.readfreq);

drivers/media/radio/si470x/radio-si470x-usb.c

200

unsigned char *report = buf;

drivers/media/radio/si470x/radio-si470x-usb.c

207

report[0], 2,

drivers/media/radio/si470x/radio-si470x-usb.c

223

unsigned char *report = buf;

drivers/media/radio/si470x/radio-si470x-usb.c

230

report[0], 2,

drivers/mfd/si476x-cmd.c

1168

struct si476x_rsq_status_report *report)

drivers/mfd/si476x-cmd.c

1188

if (err < 0 || report == NULL)

drivers/mfd/si476x-cmd.c

1191

report->multhint = 0x80 & resp[1];

drivers/mfd/si476x-cmd.c

1192

report->multlint = 0x40 & resp[1];

drivers/mfd/si476x-cmd.c

1193

report->snrhint = 0x08 & resp[1];

drivers/mfd/si476x-cmd.c

1194

report->snrlint = 0x04 & resp[1];

drivers/mfd/si476x-cmd.c

1195

report->rssihint = 0x02 & resp[1];

drivers/mfd/si476x-cmd.c

1196

report->rssilint = 0x01 & resp[1];

drivers/mfd/si476x-cmd.c

1198

report->bltf = 0x80 & resp[2];

drivers/mfd/si476x-cmd.c

1199

report->snr_ready = 0x20 & resp[2];

drivers/mfd/si476x-cmd.c

1200

report->rssiready = 0x08 & resp[2];

drivers/mfd/si476x-cmd.c

1201

report->afcrl = 0x02 & resp[2];

drivers/mfd/si476x-cmd.c

1202

report->valid = 0x01 & resp[2];

drivers/mfd/si476x-cmd.c

1204

report->readfreq = get_unaligned_be16(resp + 3);

drivers/mfd/si476x-cmd.c

1205

report->freqoff = resp[5];

drivers/mfd/si476x-cmd.c

1206

report->rssi = resp[6];

drivers/mfd/si476x-cmd.c

1207

report->snr = resp[7];

drivers/mfd/si476x-cmd.c

1208

report->lassi = resp[9];

drivers/mfd/si476x-cmd.c

1209

report->hassi = resp[10];

drivers/mfd/si476x-cmd.c

1210

report->mult = resp[11];

drivers/mfd/si476x-cmd.c

1211

report->dev = resp[12];

drivers/mfd/si476x-cmd.c

1212

report->readantcap = get_unaligned_be16(resp + 13);

drivers/mfd/si476x-cmd.c

1213

report->assi = resp[15];

drivers/mfd/si476x-cmd.c

1214

report->usn = resp[16];

drivers/mfd/si476x-cmd.c

1221

struct si476x_rsq_status_report *report)

drivers/mfd/si476x-cmd.c

1242

if (err < 0 || report == NULL)

drivers/mfd/si476x-cmd.c

1245

report->multhint = 0x80 & resp[1];

drivers/mfd/si476x-cmd.c

1246

report->multlint = 0x40 & resp[1];

drivers/mfd/si476x-cmd.c

1247

report->snrhint = 0x08 & resp[1];

drivers/mfd/si476x-cmd.c

1248

report->snrlint = 0x04 & resp[1];

drivers/mfd/si476x-cmd.c

1249

report->rssihint = 0x02 & resp[1];

drivers/mfd/si476x-cmd.c

1250

report->rssilint = 0x01 & resp[1];

drivers/mfd/si476x-cmd.c

1252

report->bltf = 0x80 & resp[2];

drivers/mfd/si476x-cmd.c

1253

report->snr_ready = 0x20 & resp[2];

drivers/mfd/si476x-cmd.c

1254

report->rssiready = 0x08 & resp[2];

drivers/mfd/si476x-cmd.c

1255

report->afcrl = 0x02 & resp[2];

drivers/mfd/si476x-cmd.c

1256

report->valid = 0x01 & resp[2];

drivers/mfd/si476x-cmd.c

1258

report->readfreq = get_unaligned_be16(resp + 3);

drivers/mfd/si476x-cmd.c

1259

report->freqoff = resp[5];

drivers/mfd/si476x-cmd.c

1260

report->rssi = resp[6];

drivers/mfd/si476x-cmd.c

1261

report->snr = resp[7];

drivers/mfd/si476x-cmd.c

1262

report->lassi = resp[9];

drivers/mfd/si476x-cmd.c

1263

report->hassi = resp[10];

drivers/mfd/si476x-cmd.c

1264

report->mult = resp[11];

drivers/mfd/si476x-cmd.c

1265

report->dev = resp[12];

drivers/mfd/si476x-cmd.c

1266

report->readantcap = get_unaligned_be16(resp + 13);

drivers/mfd/si476x-cmd.c

1267

report->assi = resp[15];

drivers/mfd/si476x-cmd.c

1268

report->usn = resp[16];

drivers/mfd/si476x-cmd.c

1276

struct si476x_rsq_status_report *report)

drivers/mfd/si476x-cmd.c

1297

if (err < 0 || report == NULL)

drivers/mfd/si476x-cmd.c

1300

report->multhint = 0x80 & resp[1];

drivers/mfd/si476x-cmd.c

1301

report->multlint = 0x40 & resp[1];

drivers/mfd/si476x-cmd.c

1302

report->snrhint = 0x08 & resp[1];

drivers/mfd/si476x-cmd.c

1303

report->snrlint = 0x04 & resp[1];

drivers/mfd/si476x-cmd.c

1304

report->rssihint = 0x02 & resp[1];

drivers/mfd/si476x-cmd.c

1305

report->rssilint = 0x01 & resp[1];

drivers/mfd/si476x-cmd.c

1307

report->bltf = 0x80 & resp[2];

drivers/mfd/si476x-cmd.c

1308

report->snr_ready = 0x20 & resp[2];

drivers/mfd/si476x-cmd.c

1309

report->rssiready = 0x08 & resp[2];

drivers/mfd/si476x-cmd.c

1310

report->injside = 0x04 & resp[2];

drivers/mfd/si476x-cmd.c

1311

report->afcrl = 0x02 & resp[2];

drivers/mfd/si476x-cmd.c

1312

report->valid = 0x01 & resp[2];

drivers/mfd/si476x-cmd.c

1314

report->readfreq = get_unaligned_be16(resp + 3);

drivers/mfd/si476x-cmd.c

1315

report->freqoff = resp[5];

drivers/mfd/si476x-cmd.c

1316

report->rssi = resp[6];

drivers/mfd/si476x-cmd.c

1317

report->snr = resp[7];

drivers/mfd/si476x-cmd.c

1318

report->issi = resp[8];

drivers/mfd/si476x-cmd.c

1319

report->lassi = resp[9];

drivers/mfd/si476x-cmd.c

1320

report->hassi = resp[10];

drivers/mfd/si476x-cmd.c

1321

report->mult = resp[11];

drivers/mfd/si476x-cmd.c

1322

report->dev = resp[12];

drivers/mfd/si476x-cmd.c

1323

report->readantcap = get_unaligned_be16(resp + 13);

drivers/mfd/si476x-cmd.c

1324

report->assi = resp[15];

drivers/mfd/si476x-cmd.c

1325

report->usn = resp[16];

drivers/mfd/si476x-cmd.c

1327

report->pilotdev = resp[17];

drivers/mfd/si476x-cmd.c

1328

report->rdsdev = resp[18];

drivers/mfd/si476x-cmd.c

1329

report->assidev = resp[19];

drivers/mfd/si476x-cmd.c

1330

report->strongdev = resp[20];

drivers/mfd/si476x-cmd.c

1331

report->rdspi = get_unaligned_be16(resp + 21);

drivers/mfd/si476x-cmd.c

1371

struct si476x_agc_status_report *report)

drivers/mfd/si476x-cmd.c

1376

if (!report)

drivers/mfd/si476x-cmd.c

1386

report->mxhi = resp[1] & SI476X_AGC_MXHI;

drivers/mfd/si476x-cmd.c

1387

report->mxlo = resp[1] & SI476X_AGC_MXLO;

drivers/mfd/si476x-cmd.c

1388

report->lnahi = resp[1] & SI476X_AGC_LNAHI;

drivers/mfd/si476x-cmd.c

1389

report->lnalo = resp[1] & SI476X_AGC_LNALO;

drivers/mfd/si476x-cmd.c

1390

report->fmagc1 = resp[2];

drivers/mfd/si476x-cmd.c

1391

report->fmagc2 = resp[3];

drivers/mfd/si476x-cmd.c

1392

report->pgagain = resp[4];

drivers/mfd/si476x-cmd.c

1393

report->fmwblang = resp[5];

drivers/mfd/si476x-cmd.c

1399

struct si476x_agc_status_report *report)

drivers/mfd/si476x-cmd.c

1404

if (!report)

drivers/mfd/si476x-cmd.c

1414

report->mxhi = resp[1] & SI476X_AGC_MXHI;

drivers/mfd/si476x-cmd.c

1415

report->mxlo = resp[1] & SI476X_AGC_MXLO;

drivers/mfd/si476x-cmd.c

1416

report->lnahi = resp[1] & SI476X_AGC_LNAHI;

drivers/mfd/si476x-cmd.c

1417

report->lnalo = resp[1] & SI476X_AGC_LNALO;

drivers/mfd/si476x-cmd.c

1511

struct si476x_rsq_status_report *report)

drivers/mfd/si476x-cmd.c

1517

report);

drivers/mfd/si476x-cmd.c

1522

struct si476x_agc_status_report *report)

drivers/mfd/si476x-cmd.c

1527

return si476x_cmds_vtable[core->revision].agc_status(core, report);

drivers/mfd/si476x-cmd.c

741

struct si476x_rsq_status_report *report)

drivers/mfd/si476x-cmd.c

761

if (!report)

drivers/mfd/si476x-cmd.c

764

report->snrhint = 0x08 & resp[1];

drivers/mfd/si476x-cmd.c

765

report->snrlint = 0x04 & resp[1];

drivers/mfd/si476x-cmd.c

766

report->rssihint = 0x02 & resp[1];

drivers/mfd/si476x-cmd.c

767

report->rssilint = 0x01 & resp[1];

drivers/mfd/si476x-cmd.c

769

report->bltf = 0x80 & resp[2];

drivers/mfd/si476x-cmd.c

770

report->snr_ready = 0x20 & resp[2];

drivers/mfd/si476x-cmd.c

771

report->rssiready = 0x08 & resp[2];

drivers/mfd/si476x-cmd.c

772

report->afcrl = 0x02 & resp[2];

drivers/mfd/si476x-cmd.c

773

report->valid = 0x01 & resp[2];

drivers/mfd/si476x-cmd.c

775

report->readfreq = get_unaligned_be16(resp + 3);

drivers/mfd/si476x-cmd.c

776

report->freqoff = resp[5];

drivers/mfd/si476x-cmd.c

777

report->rssi = resp[6];

drivers/mfd/si476x-cmd.c

778

report->snr = resp[7];

drivers/mfd/si476x-cmd.c

779

report->lassi = resp[9];

drivers/mfd/si476x-cmd.c

780

report->hassi = resp[10];

drivers/mfd/si476x-cmd.c

781

report->mult = resp[11];

drivers/mfd/si476x-cmd.c

782

report->dev = resp[12];

drivers/mfd/si476x-cmd.c

789

struct si476x_acf_status_report *report)

drivers/mfd/si476x-cmd.c

797

if (!report)

drivers/mfd/si476x-cmd.c

807

report->blend_int = resp[1] & SI476X_ACF_BLEND_INT;

drivers/mfd/si476x-cmd.c

808

report->hblend_int = resp[1] & SI476X_ACF_HIBLEND_INT;

drivers/mfd/si476x-cmd.c

809

report->hicut_int = resp[1] & SI476X_ACF_HICUT_INT;

drivers/mfd/si476x-cmd.c

810

report->chbw_int = resp[1] & SI476X_ACF_CHBW_INT;

drivers/mfd/si476x-cmd.c

811

report->softmute_int = resp[1] & SI476X_ACF_SOFTMUTE_INT;

drivers/mfd/si476x-cmd.c

812

report->smute = resp[2] & SI476X_ACF_SMUTE;

drivers/mfd/si476x-cmd.c

813

report->smattn = resp[3] & SI476X_ACF_SMATTN;

drivers/mfd/si476x-cmd.c

814

report->chbw = resp[4];

drivers/mfd/si476x-cmd.c

815

report->hicut = resp[5];

drivers/mfd/si476x-cmd.c

816

report->hiblend = resp[6];

drivers/mfd/si476x-cmd.c

817

report->pilot = resp[7] & SI476X_ACF_PILOT;

drivers/mfd/si476x-cmd.c

818

report->stblend = resp[7] & SI476X_ACF_STBLEND;

drivers/mfd/si476x-cmd.c

825

struct si476x_acf_status_report *report)

drivers/mfd/si476x-cmd.c

833

if (!report)

drivers/mfd/si476x-cmd.c

843

report->blend_int = resp[1] & SI476X_ACF_BLEND_INT;

drivers/mfd/si476x-cmd.c

844

report->hblend_int = resp[1] & SI476X_ACF_HIBLEND_INT;

drivers/mfd/si476x-cmd.c

845

report->hicut_int = resp[1] & SI476X_ACF_HICUT_INT;

drivers/mfd/si476x-cmd.c

846

report->chbw_int = resp[1] & SI476X_ACF_CHBW_INT;

drivers/mfd/si476x-cmd.c

847

report->softmute_int = resp[1] & SI476X_ACF_SOFTMUTE_INT;

drivers/mfd/si476x-cmd.c

848

report->smute = resp[2] & SI476X_ACF_SMUTE;

drivers/mfd/si476x-cmd.c

849

report->smattn = resp[3] & SI476X_ACF_SMATTN;

drivers/mfd/si476x-cmd.c

850

report->chbw = resp[4];

drivers/mfd/si476x-cmd.c

851

report->hicut = resp[5];

drivers/mfd/si476x-cmd.c

904

struct si476x_rds_status_report *report)

drivers/mfd/si476x-cmd.c

922

if (err < 0 || report == NULL)

drivers/mfd/si476x-cmd.c

925

report->rdstpptyint = 0x10 & resp[1];

drivers/mfd/si476x-cmd.c

926

report->rdspiint = 0x08 & resp[1];

drivers/mfd/si476x-cmd.c

927

report->rdssyncint = 0x02 & resp[1];

drivers/mfd/si476x-cmd.c

928

report->rdsfifoint = 0x01 & resp[1];

drivers/mfd/si476x-cmd.c

930

report->tpptyvalid = 0x10 & resp[2];

drivers/mfd/si476x-cmd.c

931

report->pivalid = 0x08 & resp[2];

drivers/mfd/si476x-cmd.c

932

report->rdssync = 0x02 & resp[2];

drivers/mfd/si476x-cmd.c

933

report->rdsfifolost = 0x01 & resp[2];

drivers/mfd/si476x-cmd.c

935

report->tp = 0x20 & resp[3];

drivers/mfd/si476x-cmd.c

936

report->pty = 0x1f & resp[3];

drivers/mfd/si476x-cmd.c

938

report->pi = get_unaligned_be16(resp + 4);

drivers/mfd/si476x-cmd.c

939

report->rdsfifoused = resp[6];

drivers/mfd/si476x-cmd.c

941

report->ble[V4L2_RDS_BLOCK_A] = 0xc0 & resp[7];

drivers/mfd/si476x-cmd.c

942

report->ble[V4L2_RDS_BLOCK_B] = 0x30 & resp[7];

drivers/mfd/si476x-cmd.c

943

report->ble[V4L2_RDS_BLOCK_C] = 0x0c & resp[7];

drivers/mfd/si476x-cmd.c

944

report->ble[V4L2_RDS_BLOCK_D] = 0x03 & resp[7];

drivers/mfd/si476x-cmd.c

946

report->rds[V4L2_RDS_BLOCK_A].block = V4L2_RDS_BLOCK_A;

drivers/mfd/si476x-cmd.c

947

report->rds[V4L2_RDS_BLOCK_A].msb = resp[8];

drivers/mfd/si476x-cmd.c

948

report->rds[V4L2_RDS_BLOCK_A].lsb = resp[9];

drivers/mfd/si476x-cmd.c

950

report->rds[V4L2_RDS_BLOCK_B].block = V4L2_RDS_BLOCK_B;

drivers/mfd/si476x-cmd.c

951

report->rds[V4L2_RDS_BLOCK_B].msb = resp[10];

drivers/mfd/si476x-cmd.c

952

report->rds[V4L2_RDS_BLOCK_B].lsb = resp[11];

drivers/mfd/si476x-cmd.c

954

report->rds[V4L2_RDS_BLOCK_C].block = V4L2_RDS_BLOCK_C;

drivers/mfd/si476x-cmd.c

955

report->rds[V4L2_RDS_BLOCK_C].msb = resp[12];

drivers/mfd/si476x-cmd.c

956

report->rds[V4L2_RDS_BLOCK_C].lsb = resp[13];

drivers/mfd/si476x-cmd.c

958

report->rds[V4L2_RDS_BLOCK_D].block = V4L2_RDS_BLOCK_D;

drivers/mfd/si476x-cmd.c

959

report->rds[V4L2_RDS_BLOCK_D].msb = resp[14];

drivers/mfd/si476x-cmd.c

960

report->rds[V4L2_RDS_BLOCK_D].lsb = resp[15];

drivers/mfd/si476x-cmd.c

968

struct si476x_rds_blockcount_report *report)

drivers/mfd/si476x-cmd.c

976

if (!report)

drivers/mfd/si476x-cmd.c

985

report->expected = get_unaligned_be16(resp + 2);

drivers/mfd/si476x-cmd.c

986

report->received = get_unaligned_be16(resp + 4);

drivers/mfd/si476x-cmd.c

987

report->uncorrectable = get_unaligned_be16(resp + 6);

drivers/mfd/si476x-i2c.c

366

struct si476x_rds_status_report report;

drivers/mfd/si476x-i2c.c

369

err = si476x_core_cmd_fm_rds_status(core, true, false, false, &report);

drivers/mfd/si476x-i2c.c

371

int i = report.rdsfifoused;

drivers/mfd/si476x-i2c.c

376

(i == 1), &report);

drivers/mfd/si476x-i2c.c

380

kfifo_in(&core->rds_fifo, report.rds,

drivers/mfd/si476x-i2c.c

381

sizeof(report.rds));

drivers/mfd/si476x-i2c.c

383

(int)sizeof(report.rds), report.rds);

drivers/net/amt.c

1184

bool report = false;

drivers/net/amt.c

1202

report = true;

drivers/net/amt.c

1226

report = true;

drivers/net/amt.c

1252

if (!report)

drivers/net/amt.c

2481

goto report;

drivers/net/amt.c

2491

report:

drivers/net/ethernet/intel/ice/ice_lib.c

2097

goto report;

drivers/net/ethernet/intel/ice/ice_lib.c

2110

report:

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

618

enum ethtool_report report)

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

620

switch (report) {

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

688

enum ethtool_report report)

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

694

ptys2ethtool_link_mode(&ptys2ethtool_map[i], report));

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

699

enum ethtool_report report)

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

706

report);

drivers/net/fddi/skfp/smt.c

806

static void update_dac(struct s_smc *smc, int report)

drivers/net/fddi/skfp/smt.c

812

if (report && (cond != smc->mib.m[MAC0].fddiMACDuplicateAddressCond))

drivers/net/fddi/skfp/smt.c

99

static void update_dac(struct s_smc *smc, int report);

drivers/net/phy/sfp.c

2298

static int sfp_sm_mod_probe(struct sfp *sfp, bool report)

drivers/net/phy/sfp.c

2312

if (report)

drivers/net/phy/sfp.c

2338

if (report)

drivers/net/phy/sfp.c

2388

if (report)

drivers/net/wireless/ath/ath10k/htc.c

251

const struct ath10k_htc_credit_report *report,

drivers/net/wireless/ath/ath10k/htc.c

259

if (len % sizeof(*report))

drivers/net/wireless/ath/ath10k/htc.c

262

n_reports = len / sizeof(*report);

drivers/net/wireless/ath/ath10k/htc.c

265

for (i = 0; i < n_reports; i++, report++) {

drivers/net/wireless/ath/ath10k/htc.c

266

if (report->eid >= ATH10K_HTC_EP_COUNT)

drivers/net/wireless/ath/ath10k/htc.c

269

ep = &htc->endpoint[report->eid];

drivers/net/wireless/ath/ath10k/htc.c

270

ep->tx_credits += report->credits;

drivers/net/wireless/ath/ath10k/htc.c

273

report->eid, report->credits, ep->tx_credits);

drivers/net/wireless/ath/ath10k/htc.c

286

const struct ath10k_htc_lookahead_report *report,

drivers/net/wireless/ath/ath10k/htc.c

299

if (report->pre_valid != ((~report->post_valid) & 0xFF))

drivers/net/wireless/ath/ath10k/htc.c

305

report->pre_valid, report->post_valid);

drivers/net/wireless/ath/ath10k/htc.c

308

memcpy((u8 *)next_lookaheads, report->lookahead, 4);

drivers/net/wireless/ath/ath10k/htc.c

318

const struct ath10k_htc_lookahead_bundle *report,

drivers/net/wireless/ath/ath10k/htc.c

325

int bundle_cnt = len / sizeof(*report);

drivers/net/wireless/ath/ath10k/htc.c

338

report->lookahead, 4);

drivers/net/wireless/ath/ath10k/htc.c

339

report++;

drivers/net/wireless/ath/ath11k/htc.c

152

const struct ath11k_htc_credit_report *report,

drivers/net/wireless/ath/ath11k/htc.c

160

if (len % sizeof(*report))

drivers/net/wireless/ath/ath11k/htc.c

163

n_reports = len / sizeof(*report);

drivers/net/wireless/ath/ath11k/htc.c

166

for (i = 0; i < n_reports; i++, report++) {

drivers/net/wireless/ath/ath11k/htc.c

167

if (report->eid >= ATH11K_HTC_EP_COUNT)

drivers/net/wireless/ath/ath11k/htc.c

170

ep = &htc->endpoint[report->eid];

drivers/net/wireless/ath/ath11k/htc.c

171

ep->tx_credits += report->credits;

drivers/net/wireless/ath/ath11k/htc.c

174

report->eid, report->credits, ep->tx_credits);

drivers/net/wireless/ath/ath11k/spectral.c

468

struct ath11k_spectral_summary_report *report)

drivers/net/wireless/ath/ath11k/spectral.c

470

report->timestamp = __le32_to_cpu(summary->timestamp);

drivers/net/wireless/ath/ath11k/spectral.c

471

report->agc_total_gain = FIELD_GET(SPECTRAL_SUMMARY_INFO0_AGC_TOTAL_GAIN,

drivers/net/wireless/ath/ath11k/spectral.c

473

report->out_of_band_flag = FIELD_GET(SPECTRAL_SUMMARY_INFO0_OB_FLAG,

drivers/net/wireless/ath/ath11k/spectral.c

475

report->grp_idx = FIELD_GET(SPECTRAL_SUMMARY_INFO0_GRP_IDX,

drivers/net/wireless/ath/ath11k/spectral.c

477

report->rf_saturation = FIELD_GET(SPECTRAL_SUMMARY_INFO0_RECENT_RFSAT,

drivers/net/wireless/ath/ath11k/spectral.c

479

report->inb_pwr_db = FIELD_GET(SPECTRAL_SUMMARY_INFO0_INBAND_PWR_DB,

drivers/net/wireless/ath/ath11k/spectral.c

481

report->false_scan = FIELD_GET(SPECTRAL_SUMMARY_INFO0_FALSE_SCAN,

drivers/net/wireless/ath/ath11k/spectral.c

483

report->detector_id = FIELD_GET(SPECTRAL_SUMMARY_INFO0_DETECTOR_ID,

drivers/net/wireless/ath/ath11k/spectral.c

485

report->primary80 = FIELD_GET(SPECTRAL_SUMMARY_INFO0_PRI80,

drivers/net/wireless/ath/ath11k/spectral.c

487

report->peak_idx = FIELD_GET(SPECTRAL_SUMMARY_INFO2_PEAK_SIGNED_IDX,

drivers/net/wireless/ath/ath11k/spectral.c

489

report->peak_mag = FIELD_GET(SPECTRAL_SUMMARY_INFO2_PEAK_MAGNITUDE,

drivers/net/wireless/ath/ath11k/spectral.c

491

report->gain_change = FIELD_GET(SPECTRAL_SUMMARY_INFO2_GAIN_CHANGE,

drivers/net/wireless/ath/ath11k/spectral.c

494

memcpy(&report->meta, meta, sizeof(*meta));

drivers/net/wireless/ath/ath11k/spectral.c

501

struct ath11k_spectral_search_report *report)

drivers/net/wireless/ath/ath11k/spectral.c

503

report->timestamp = __le32_to_cpu(search->timestamp);

drivers/net/wireless/ath/ath11k/spectral.c

504

report->detector_id = FIELD_GET(SPECTRAL_FFT_REPORT_INFO0_DETECTOR_ID,

drivers/net/wireless/ath/ath11k/spectral.c

506

report->fft_count = FIELD_GET(SPECTRAL_FFT_REPORT_INFO0_FFT_NUM,

drivers/net/wireless/ath/ath11k/spectral.c

508

report->radar_check = FIELD_GET(SPECTRAL_FFT_REPORT_INFO0_RADAR_CHECK,

drivers/net/wireless/ath/ath11k/spectral.c

510

report->peak_idx = FIELD_GET(SPECTRAL_FFT_REPORT_INFO0_PEAK_SIGNED_IDX,

drivers/net/wireless/ath/ath11k/spectral.c

512

report->chain_idx = FIELD_GET(SPECTRAL_FFT_REPORT_INFO0_CHAIN_IDX,

drivers/net/wireless/ath/ath11k/spectral.c

514

report->base_pwr_db = FIELD_GET(SPECTRAL_FFT_REPORT_INFO1_BASE_PWR_DB,

drivers/net/wireless/ath/ath11k/spectral.c

516

report->total_gain_db = FIELD_GET(SPECTRAL_FFT_REPORT_INFO1_TOTAL_GAIN_DB,

drivers/net/wireless/ath/ath11k/spectral.c

518

report->strong_bin_count = FIELD_GET(SPECTRAL_FFT_REPORT_INFO2_NUM_STRONG_BINS,

drivers/net/wireless/ath/ath11k/spectral.c

520

report->peak_mag = FIELD_GET(SPECTRAL_FFT_REPORT_INFO2_PEAK_MAGNITUDE,

drivers/net/wireless/ath/ath11k/spectral.c

522

report->avg_pwr_db = FIELD_GET(SPECTRAL_FFT_REPORT_INFO2_AVG_PWR_DB,

drivers/net/wireless/ath/ath11k/spectral.c

524

report->rel_pwr_db = FIELD_GET(SPECTRAL_FFT_REPORT_INFO2_REL_PWR_DB,

drivers/net/wireless/ath/ath12k/htc.c

146

const struct ath12k_htc_credit_report *report,

drivers/net/wireless/ath/ath12k/htc.c

154

if (len % sizeof(*report))

drivers/net/wireless/ath/ath12k/htc.c

157

n_reports = len / sizeof(*report);

drivers/net/wireless/ath/ath12k/htc.c

160

for (i = 0; i < n_reports; i++, report++) {

drivers/net/wireless/ath/ath12k/htc.c

161

if (report->eid >= ATH12K_HTC_EP_COUNT)

drivers/net/wireless/ath/ath12k/htc.c

164

ep = &htc->endpoint[report->eid];

drivers/net/wireless/ath/ath12k/htc.c

165

ep->tx_credits += report->credits;

drivers/net/wireless/ath/ath12k/htc.c

168

report->eid, report->credits, ep->tx_credits);

drivers/net/wireless/ath/ath6kl/htc_pipe.c

853

struct htc_credit_report *report;

drivers/net/wireless/ath/ath6kl/htc_pipe.c

888

report = (struct htc_credit_report *) record_buf;

drivers/net/wireless/ath/ath6kl/htc_pipe.c

889

htc_process_credit_report(target, report,

drivers/net/wireless/ath/ath6kl/htc_pipe.c

890

record->len / sizeof(*report),

drivers/net/wireless/ath/wil6210/wmi.h

3672

u8 report[];

drivers/net/wireless/broadcom/b43/xmit.c

847

struct ieee80211_tx_info *report,

drivers/net/wireless/broadcom/b43/xmit.c

856

retry_limit = report->status.rates[0].count;

drivers/net/wireless/broadcom/b43/xmit.c

857

ieee80211_tx_info_clear_status(report);

drivers/net/wireless/broadcom/b43/xmit.c

861

report->flags |= IEEE80211_TX_STAT_ACK;

drivers/net/wireless/broadcom/b43/xmit.c

864

if (!(report->flags & IEEE80211_TX_CTL_NO_ACK)) {

drivers/net/wireless/broadcom/b43/xmit.c

871

report->status.rates[0].count = 0;

drivers/net/wireless/broadcom/b43/xmit.c

880

report->status.rates[0].count = 0;

drivers/net/wireless/broadcom/b43/xmit.c

881

report->status.rates[1].count = status->frame_count;

drivers/net/wireless/broadcom/b43/xmit.c

884

report->status.rates[0].count = retry_limit;

drivers/net/wireless/broadcom/b43/xmit.c

885

report->status.rates[1].count = status->frame_count -

drivers/net/wireless/broadcom/b43/xmit.c

889

report->status.rates[0].count = status->frame_count;

drivers/net/wireless/broadcom/b43/xmit.c

890

report->status.rates[1].idx = -1;

drivers/net/wireless/broadcom/b43/xmit.h

362

struct ieee80211_tx_info *report,

drivers/net/wireless/intel/iwlegacy/common.c

2640

struct il_spectrum_notification *report = &(pkt->u.spectrum_notif);

drivers/net/wireless/intel/iwlegacy/common.c

2642

if (!report->state) {

drivers/net/wireless/intel/iwlegacy/common.c

2647

memcpy(&il->measure_report, report, sizeof(*report));

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

76

struct iwl_spectrum_notification *report = (void *)pkt->data;

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

78

if (!report->state) {

drivers/net/wireless/intel/iwlwifi/dvm/rx.c

84

memcpy(&priv->measure_report, report, sizeof(*report));

drivers/net/wireless/intel/iwlwifi/mld/rx.c

1847

goto report;

drivers/net/wireless/intel/iwlwifi/mld/rx.c

1868

goto report;

drivers/net/wireless/intel/iwlwifi/mld/rx.c

1873

goto report;

drivers/net/wireless/intel/iwlwifi/mld/rx.c

1890

goto report;

drivers/net/wireless/intel/iwlwifi/mld/rx.c

1898

report:

drivers/net/wireless/intel/iwlwifi/mvm/d3.c

1460

goto report;

drivers/net/wireless/intel/iwlwifi/mvm/d3.c

1518

goto report;

drivers/net/wireless/intel/iwlwifi/mvm/d3.c

1555

goto report;

drivers/net/wireless/intel/iwlwifi/mvm/d3.c

1578

report:

drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c

359

goto report;

drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c

376

goto report;

drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c

380

goto report;

drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c

398

goto report;

drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c

406

report:

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/rx.c

1801

bool hw_rfkill, prev, report;

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/rx.c

1811

report = hw_rfkill;

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/rx.c

1813

report = test_bit(STATUS_RFKILL_OPMODE, &trans->status);

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/rx.c

1820

if (prev != report)

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/rx.c

1821

iwl_trans_pcie_rf_kill(trans, report, from_irq);

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

1015

bool report;

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

1026

report = test_bit(STATUS_RFKILL_OPMODE, &trans->status);

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

1028

if (prev != report)

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

1029

iwl_trans_pcie_rf_kill(trans, report, false);

drivers/net/wireless/realtek/rtlwifi/rtl8192ce/trx.c

52

u8 report, cck_highpwr;

drivers/net/wireless/realtek/rtlwifi/rtl8192ce/trx.c

66

report = cck_buf->cck_agc_rpt & 0xc0;

drivers/net/wireless/realtek/rtlwifi/rtl8192ce/trx.c

67

report = report >> 6;

drivers/net/wireless/realtek/rtlwifi/rtl8192ce/trx.c

68

switch (report) {

drivers/net/wireless/realtek/rtlwifi/rtl8192ce/trx.c

85

report = p_drvinfo->cfosho[0] & 0x60;

drivers/net/wireless/realtek/rtlwifi/rtl8192ce/trx.c

86

report = report >> 5;

drivers/net/wireless/realtek/rtlwifi/rtl8192ce/trx.c

87

switch (report) {

drivers/net/wireless/realtek/rtlwifi/rtl8192cu/mac.c

597

u8 report, cck_highpwr;

drivers/net/wireless/realtek/rtlwifi/rtl8192cu/mac.c

607

report = cck_buf->cck_agc_rpt & 0xc0;

drivers/net/wireless/realtek/rtlwifi/rtl8192cu/mac.c

608

report = report >> 6;

drivers/net/wireless/realtek/rtlwifi/rtl8192cu/mac.c

609

switch (report) {

drivers/net/wireless/realtek/rtlwifi/rtl8192cu/mac.c

626

report = p_drvinfo->cfosho[0] & 0x60;

drivers/net/wireless/realtek/rtlwifi/rtl8192cu/mac.c

627

report = report >> 5;

drivers/net/wireless/realtek/rtlwifi/rtl8192cu/mac.c

628

switch (report) {

drivers/net/wireless/realtek/rtlwifi/rtl8192d/trx_common.c

49

u8 report, cck_highpwr;

drivers/net/wireless/realtek/rtlwifi/rtl8192d/trx_common.c

59

report = cck_buf->cck_agc_rpt & 0xc0;

drivers/net/wireless/realtek/rtlwifi/rtl8192d/trx_common.c

60

report = report >> 6;

drivers/net/wireless/realtek/rtlwifi/rtl8192d/trx_common.c

61

switch (report) {

drivers/net/wireless/realtek/rtlwifi/rtl8192d/trx_common.c

78

report = p_drvinfo->cfosho[0] & 0x60;

drivers/net/wireless/realtek/rtlwifi/rtl8192d/trx_common.c

79

report = report >> 5;

drivers/net/wireless/realtek/rtlwifi/rtl8192d/trx_common.c

80

switch (report) {

drivers/net/wireless/realtek/rtlwifi/rtl8192se/trx.c

58

u8 report, cck_highpwr;

drivers/net/wireless/realtek/rtlwifi/rtl8192se/trx.c

70

report = cck_buf->cck_agc_rpt & 0xc0;

drivers/net/wireless/realtek/rtlwifi/rtl8192se/trx.c

71

report = report >> 6;

drivers/net/wireless/realtek/rtlwifi/rtl8192se/trx.c

72

switch (report) {

drivers/net/wireless/realtek/rtlwifi/rtl8192se/trx.c

88

report = p_drvinfo->cfosho[0] & 0x60;

drivers/net/wireless/realtek/rtlwifi/rtl8192se/trx.c

89

report = report >> 5;

drivers/net/wireless/realtek/rtlwifi/rtl8192se/trx.c

90

switch (report) {

drivers/net/wireless/realtek/rtlwifi/rtl8723ae/trx.c

49

u8 report, cck_highpwr;

drivers/net/wireless/realtek/rtlwifi/rtl8723ae/trx.c

67

report = cck_buf->cck_agc_rpt & 0xc0;

drivers/net/wireless/realtek/rtlwifi/rtl8723ae/trx.c

68

report = report >> 6;

drivers/net/wireless/realtek/rtlwifi/rtl8723ae/trx.c

69

switch (report) {

drivers/net/wireless/realtek/rtlwifi/rtl8723ae/trx.c

85

report = p_drvinfo->cfosho[0] & 0x60;

drivers/net/wireless/realtek/rtlwifi/rtl8723ae/trx.c

86

report = report >> 5;

drivers/net/wireless/realtek/rtlwifi/rtl8723ae/trx.c

87

switch (report) {

drivers/net/wireless/realtek/rtw88/main.h

626

bool report;

drivers/net/wireless/realtek/rtw88/tx.c

176

pkt_info->report = true;

drivers/net/wireless/realtek/rtw88/tx.c

58

le32_encode_bits(pkt_info->report, RTW_TX_DESC_W2_SPE_RPT) |

drivers/net/wireless/realtek/rtw89/core.c

1562

u32 dword = FIELD_PREP(RTW89_TXWD_INFO3_SPE_RPT, desc_info->report);

drivers/net/wireless/realtek/rtw89/core.c

1758

FIELD_PREP(BE_TXD_INFO2_SPE_RPT_V1, desc_info->report);

drivers/net/wireless/realtek/rtw89/core.h

1221

bool report;

drivers/net/wireless/realtek/rtw89/mac.h

1732

tx_req->desc_info.report = true;

drivers/net/wireless/realtek/rtw89/phy.c

26

const struct rtw89_ra_report *report)

drivers/net/wireless/realtek/rtw89/phy.c

28

u32 bit_rate = report->bit_rate;

drivers/net/wireless/realtek/rtw89/phy.c

35

if (report->might_fallback_legacy)

drivers/net/wireless/realtek/rtw89/phy.c

3947

const struct rtw89_c2h_rfk_report *report =

drivers/net/wireless/realtek/rtw89/phy.c

3951

wait->state = report->state;

drivers/net/wireless/realtek/rtw89/phy.c

3952

wait->version = report->version;

drivers/net/wireless/realtek/rtw89/phy.c

3959

(int)(len - sizeof(report->hdr)), &report->state);

drivers/net/wireless/realtek/rtw89/phy.c

3965

const struct rtw89_c2h_rf_tas_info *report =

drivers/net/wireless/realtek/rtw89/phy.c

3968

rtw89_phy_c2h_rfk_tas_pwr(rtwdev, &report->content);

drivers/net/wireless/realtek/rtw89/phy.c

5823

u16 report, u16 score)

drivers/net/wireless/realtek/rtw89/phy.c

5829

numer = report * score + (env->ccx_period >> 1);

drivers/net/wireless/ti/wl1251/event.h

96

struct event_debug_report report;

drivers/nvme/host/zns.c

178

struct nvme_zone_report *report;

drivers/nvme/host/zns.c

187

report = nvme_zns_alloc_report_buffer(ns, nr_zones, &buflen);

drivers/nvme/host/zns.c

188

if (!report)

drivers/nvme/host/zns.c

200

memset(report, 0, buflen);

drivers/nvme/host/zns.c

203

ret = nvme_submit_sync_cmd(ns->queue, &c, report, buflen);

drivers/nvme/host/zns.c

210

nz = min((unsigned int)le64_to_cpu(report->nr_zones), nr_zones);

drivers/nvme/host/zns.c

215

ret = nvme_zone_parse_entry(ns, &report->entries[i],

drivers/nvme/host/zns.c

230

kvfree(report);

drivers/regulator/core.c

919

const char *report;

drivers/regulator/core.c

926

report = "unknown";

drivers/regulator/core.c

928

report = "enabled";

drivers/regulator/core.c

930

report = "disabled";

drivers/regulator/core.c

932

return sprintf(buf, "%s\n", report);

drivers/regulator/rt5190a-regulator.c

154

unsigned int report;

drivers/regulator/rt5190a-regulator.c

185

event_tbl[i].report,

drivers/s390/char/sclp_pci.c

106

if (report->length > (PAGE_SIZE - sizeof(struct err_notify_sccb)))

drivers/s390/char/sclp_pci.c

112

int sclp_pci_report(struct zpci_report_error_header *report, u32 fh, u32 fid)

drivers/s390/char/sclp_pci.c

119

ret = sclp_pci_check_report(report);

drivers/s390/char/sclp_pci.c

146

sccb->evbuf.header.length = sizeof(sccb->evbuf) + report->length;

drivers/s390/char/sclp_pci.c

150

sccb->evbuf.action = report->action;

drivers/s390/char/sclp_pci.c

155

memcpy(sccb->evbuf.data, report->data, report->length);

drivers/s390/char/sclp_pci.c

91

static int sclp_pci_check_report(struct zpci_report_error_header *report)

drivers/s390/char/sclp_pci.c

93

if (report->version != 1)

drivers/s390/char/sclp_pci.c

96

switch (report->action) {

drivers/staging/greybus/audio_module.c

121

report = report | soc_button_id;

drivers/staging/greybus/audio_module.c

123

report = report & ~soc_button_id;

drivers/staging/greybus/audio_module.c

125

module->button_status = report;

drivers/staging/greybus/audio_module.c

127

snd_soc_jack_report(&module->button.jack, report, module->button_mask);

drivers/staging/greybus/audio_module.c

23

int report;

drivers/staging/greybus/audio_module.c

50

report = req->jack_attribute & module->jack_mask;

drivers/staging/greybus/audio_module.c

51

if (!report) {

drivers/staging/greybus/audio_module.c

61

module->jack_type, report);

drivers/staging/greybus/audio_module.c

63

module->jack_type = report;

drivers/staging/greybus/audio_module.c

64

snd_soc_jack_report(&module->headset.jack, report, module->jack_mask);

drivers/staging/greybus/audio_module.c

72

int soc_button_id, report;

drivers/staging/greybus/audio_module.c

93

report = module->button_status & module->button_mask;

drivers/staging/greybus/hid.c

117

memcpy(request->report, buf, len);

drivers/staging/greybus/hid.c

147

request->report, op->request->payload_size, 1);

drivers/staging/greybus/hid.c

152

static int gb_hid_report_len(struct hid_report *report)

drivers/staging/greybus/hid.c

154

return ((report->size - 1) >> 3) + 1 +

drivers/staging/greybus/hid.c

155

report->device->report_enum[report->type].numbered;

drivers/staging/greybus/hid.c

161

struct hid_report *report;

drivers/staging/greybus/hid.c

164

list_for_each_entry(report, &hid->report_enum[type].report_list, list) {

drivers/staging/greybus/hid.c

165

size = gb_hid_report_len(report);

drivers/staging/greybus/hid.c

190

static void gb_hid_init_report(struct gb_hid *ghid, struct hid_report *report)

drivers/staging/greybus/hid.c

194

size = gb_hid_report_len(report);

drivers/staging/greybus/hid.c

195

if (gb_hid_get_report(ghid, report->type, report->id, ghid->inbuf,

drivers/staging/greybus/hid.c

204

hid_report_raw_event(ghid->hid, report->type, ghid->inbuf, size, 1);

drivers/staging/greybus/hid.c

210

struct hid_report *report;

drivers/staging/greybus/hid.c

212

list_for_each_entry(report,

drivers/staging/greybus/hid.c

215

gb_hid_init_report(ghid, report);

drivers/staging/greybus/hid.c

217

list_for_each_entry(report,

drivers/staging/greybus/hid.c

220

gb_hid_init_report(ghid, report);

drivers/staging/rtl8723bs/core/rtw_pwrctrl.c

617

struct reportpwrstate_parm report;

drivers/staging/rtl8723bs/core/rtw_pwrctrl.c

619

report.state = PS_STATE_S2;

drivers/staging/rtl8723bs/core/rtw_pwrctrl.c

620

cpwm_int_hdl(adapter, &report);

drivers/staging/rtl8723bs/core/rtw_pwrctrl.c

641

struct reportpwrstate_parm report;

drivers/staging/rtl8723bs/core/rtw_pwrctrl.c

643

report.state = PS_STATE_S2;

drivers/staging/rtl8723bs/core/rtw_pwrctrl.c

644

cpwm_int_hdl(padapter, &report);

drivers/staging/rtl8723bs/hal/rtl8723bs_recv.c

24

struct recv_stat report;

drivers/staging/rtl8723bs/hal/rtl8723bs_recv.c

25

struct rxreport_8723b *prxreport = (struct rxreport_8723b *)&report;

drivers/staging/rtl8723bs/hal/rtl8723bs_recv.c

27

report.rxdw0 = prxstat->rxdw0;

drivers/staging/rtl8723bs/hal/rtl8723bs_recv.c

28

report.rxdw1 = prxstat->rxdw1;

drivers/staging/rtl8723bs/hal/rtl8723bs_recv.c

29

report.rxdw2 = prxstat->rxdw2;

drivers/staging/rtl8723bs/hal/rtl8723bs_recv.c

30

report.rxdw3 = prxstat->rxdw3;

drivers/staging/rtl8723bs/hal/rtl8723bs_recv.c

31

report.rxdw4 = prxstat->rxdw4;

drivers/staging/rtl8723bs/hal/rtl8723bs_recv.c

32

report.rxdw5 = prxstat->rxdw5;

drivers/vfio/vfio_main.c

1168

struct vfio_device_feature_dma_logging_report report;

drivers/vfio/vfio_main.c

1178

sizeof(report));

drivers/vfio/vfio_main.c

1182

if (copy_from_user(&report, arg, minsz))

drivers/vfio/vfio_main.c

1185

if (report.page_size < SZ_4K || !is_power_of_2(report.page_size))

drivers/vfio/vfio_main.c

1188

if (check_add_overflow(report.iova, report.length, &iova_end) ||

drivers/vfio/vfio_main.c

1192

iter = iova_bitmap_alloc(report.iova, report.length,

drivers/vfio/vfio_main.c

1193

report.page_size,

drivers/vfio/vfio_main.c

1194

u64_to_user_ptr(report.bitmap));

drivers/virt/coco/arm-cca-guest/arm-cca-guest.c

177

report->outblob = no_free_ptr(token);

drivers/virt/coco/arm-cca-guest/arm-cca-guest.c

179

report->outblob_len = token_size;

drivers/virt/coco/arm-cca-guest/arm-cca-guest.c

90

static int arm_cca_report_new(struct tsm_report *report, void *data)

drivers/virt/coco/arm-cca-guest/arm-cca-guest.c

99

struct tsm_report_desc *desc = &report->desc;

drivers/virt/coco/guest/report.c

109

rc = try_advance_write_generation(report);

drivers/virt/coco/guest/report.c

112

report->desc.privlevel = val;

drivers/virt/coco/guest/report.c

133

struct tsm_report *report = to_tsm_report(cfg);

drivers/virt/coco/guest/report.c

139

rc = try_advance_write_generation(report);

drivers/virt/coco/guest/report.c

148

kfree(report->desc.service_provider);

drivers/virt/coco/guest/report.c

150

report->desc.service_provider = sp;

drivers/virt/coco/guest/report.c

159

struct tsm_report *report = to_tsm_report(cfg);

drivers/virt/coco/guest/report.c

163

rc = try_advance_write_generation(report);

drivers/virt/coco/guest/report.c

167

report->desc.service_guid = guid_null;

drivers/virt/coco/guest/report.c

169

rc = guid_parse(buf, &report->desc.service_guid);

drivers/virt/coco/guest/report.c

180

struct tsm_report *report = to_tsm_report(cfg);

drivers/virt/coco/guest/report.c

189

rc = try_advance_write_generation(report);

drivers/virt/coco/guest/report.c

192

report->desc.service_manifest_version = val;

drivers/virt/coco/guest/report.c

201

struct tsm_report *report = to_tsm_report(cfg);

drivers/virt/coco/guest/report.c

205

rc = try_advance_write_generation(report);

drivers/virt/coco/guest/report.c

209

report->desc.inblob_len = count;

drivers/virt/coco/guest/report.c

210

memcpy(report->desc.inblob, buf, count);

drivers/virt/coco/guest/report.c

217

struct tsm_report *report = to_tsm_report(cfg);

drivers/virt/coco/guest/report.c

218

struct tsm_report_state *state = to_state(report);

drivers/virt/coco/guest/report.c

235

static ssize_t __read_report(struct tsm_report *report, void *buf, size_t count,

drivers/virt/coco/guest/report.c

243

out = report->outblob;

drivers/virt/coco/guest/report.c

244

len = report->outblob_len;

drivers/virt/coco/guest/report.c

246

out = report->manifestblob;

drivers/virt/coco/guest/report.c

247

len = report->manifestblob_len;

drivers/virt/coco/guest/report.c

249

out = report->auxblob;

drivers/virt/coco/guest/report.c

250

len = report->auxblob_len;

drivers/virt/coco/guest/report.c

262

static ssize_t read_cached_report(struct tsm_report *report, void *buf,

drivers/virt/coco/guest/report.c

265

struct tsm_report_state *state = to_state(report);

drivers/virt/coco/guest/report.c

268

if (!report->desc.inblob_len)

drivers/virt/coco/guest/report.c

275

if (!report->outblob ||

drivers/virt/coco/guest/report.c

279

return __read_report(report, buf, count, select);

drivers/virt/coco/guest/report.c

282

static ssize_t tsm_report_read(struct tsm_report *report, void *buf,

drivers/virt/coco/guest/report.c

285

struct tsm_report_state *state = to_state(report);

drivers/virt/coco/guest/report.c

290

rc = read_cached_report(report, buf, count, select);

drivers/virt/coco/guest/report.c

299

if (!report->desc.inblob_len)

drivers/virt/coco/guest/report.c

303

if (report->outblob &&

drivers/virt/coco/guest/report.c

307

kvfree(report->outblob);

drivers/virt/coco/guest/report.c

308

kvfree(report->auxblob);

drivers/virt/coco/guest/report.c

309

kvfree(report->manifestblob);

drivers/virt/coco/guest/report.c

310

report->outblob = NULL;

drivers/virt/coco/guest/report.c

311

report->auxblob = NULL;

drivers/virt/coco/guest/report.c

312

report->manifestblob = NULL;

drivers/virt/coco/guest/report.c

313

rc = ops->report_new(report, provider.data);

drivers/virt/coco/guest/report.c

318

return __read_report(report, buf, count, select);

drivers/virt/coco/guest/report.c

324

struct tsm_report *report = to_tsm_report(cfg);

drivers/virt/coco/guest/report.c

326

return tsm_report_read(report, buf, count, TSM_REPORT);

drivers/virt/coco/guest/report.c

333

struct tsm_report *report = to_tsm_report(cfg);

drivers/virt/coco/guest/report.c

335

return tsm_report_read(report, buf, count, TSM_CERTS);

drivers/virt/coco/guest/report.c

342

struct tsm_report *report = to_tsm_report(cfg);

drivers/virt/coco/guest/report.c

344

return tsm_report_read(report, buf, count, TSM_MANIFEST);

drivers/virt/coco/guest/report.c

369

struct tsm_report *report = to_tsm_report(cfg);

drivers/virt/coco/guest/report.c

370

struct tsm_report_state *state = to_state(report);

drivers/virt/coco/guest/report.c

372

kvfree(report->manifestblob);

drivers/virt/coco/guest/report.c

373

kvfree(report->auxblob);

drivers/virt/coco/guest/report.c

374

kvfree(report->outblob);

drivers/virt/coco/guest/report.c

375

kfree(report->desc.service_provider);

drivers/virt/coco/guest/report.c

42

struct tsm_report report;

drivers/virt/coco/guest/report.c

59

return &state->report;

drivers/virt/coco/guest/report.c

62

static struct tsm_report_state *to_state(struct tsm_report *report)

drivers/virt/coco/guest/report.c

64

return container_of(report, struct tsm_report_state, report);

drivers/virt/coco/guest/report.c

67

static int try_advance_write_generation(struct tsm_report *report)

drivers/virt/coco/guest/report.c

69

struct tsm_report_state *state = to_state(report);

drivers/virt/coco/guest/report.c

88

struct tsm_report *report = to_tsm_report(cfg);

drivers/virt/coco/sev-guest/sev-guest.c

346

static int sev_svsm_report_new(struct tsm_report *report, void *data)

drivers/virt/coco/sev-guest/sev-guest.c

349

struct tsm_report_desc *desc = &report->desc;

drivers/virt/coco/sev-guest/sev-guest.c

463

report->outblob = no_free_ptr(rbuf);

drivers/virt/coco/sev-guest/sev-guest.c

464

report->outblob_len = rep_len;

drivers/virt/coco/sev-guest/sev-guest.c

467

report->manifestblob = no_free_ptr(mbuf);

drivers/virt/coco/sev-guest/sev-guest.c

468

report->manifestblob_len = man_len;

drivers/virt/coco/sev-guest/sev-guest.c

472

report->auxblob = no_free_ptr(cbuf);

drivers/virt/coco/sev-guest/sev-guest.c

473

report->auxblob_len = certs_len;

drivers/virt/coco/sev-guest/sev-guest.c

481

static int sev_report_new(struct tsm_report *report, void *data)

drivers/virt/coco/sev-guest/sev-guest.c

484

struct tsm_report_desc *desc = &report->desc;

drivers/virt/coco/sev-guest/sev-guest.c

499

return sev_svsm_report_new(report, data);

drivers/virt/coco/sev-guest/sev-guest.c

544

report->outblob = no_free_ptr(rbuf);

drivers/virt/coco/sev-guest/sev-guest.c

545

report->outblob_len = hdr.report_size;

drivers/virt/coco/sev-guest/sev-guest.c

576

report->auxblob = no_free_ptr(cbuf);

drivers/virt/coco/sev-guest/sev-guest.c

577

report->auxblob_len = certs_size;

drivers/virt/coco/tdx-guest/tdx-guest.c

269

static int tdx_report_new_locked(struct tsm_report *report, void *data)

drivers/virt/coco/tdx-guest/tdx-guest.c

273

struct tsm_report_desc *desc = &report->desc;

drivers/virt/coco/tdx-guest/tdx-guest.c

321

report->outblob = buf;

drivers/virt/coco/tdx-guest/tdx-guest.c

322

report->outblob_len = out_len;

drivers/virt/coco/tdx-guest/tdx-guest.c

332

static int tdx_report_new(struct tsm_report *report, void *data)

drivers/virt/coco/tdx-guest/tdx-guest.c

335

return tdx_report_new_locked(report, data);

drivers/virtio/virtio_balloon.c

1015

vb->pr_dev_info.report = virtballoon_free_page_report;

fs/exfat/exfat_fs.h

554

void __exfat_fs_error(struct super_block *sb, int report, const char *fmt, ...)

fs/exfat/misc.c

26

void __exfat_fs_error(struct super_block *sb, int report, const char *fmt, ...)

fs/exfat/misc.c

32

if (report) {

fs/fat/fat.h

444

void __fat_fs_error(struct super_block *sb, int report, const char *fmt, ...);

fs/fat/misc.c

21

void __fat_fs_error(struct super_block *sb, int report, const char *fmt, ...)

fs/fat/misc.c

27

if (report) {

fs/fserror.c

55

struct fs_error_report report = {

fs/fserror.c

65

fsnotify(FS_ERROR, &report, FSNOTIFY_EVENT_ERROR, NULL, NULL,

fs/nfs/flexfilelayout/flexfilelayout.c

782

bool report;

fs/nfs/flexfilelayout/flexfilelayout.c

785

report = nfs4_ff_layoutstat_start_io(

fs/nfs/flexfilelayout/flexfilelayout.c

792

if (report)

fs/nfs/flexfilelayout/flexfilelayout.c

817

bool report;

fs/nfs/flexfilelayout/flexfilelayout.c

820

report = nfs4_ff_layoutstat_start_io(

fs/nfs/flexfilelayout/flexfilelayout.c

831

if (report)

fs/notify/fanotify/fanotify.c

714

struct fs_error_report *report =

fs/notify/fanotify/fanotify.c

720

if (WARN_ON_ONCE(!report))

fs/notify/fanotify/fanotify.c

728

fee->error = report->error;

fs/notify/fanotify/fanotify.c

732

inode = report->inode;

fs/unicode/mkutf8data.c

1752

int report;

fs/unicode/mkutf8data.c

1760

report = 0;

fs/unicode/mkutf8data.c

1769

report++;

fs/unicode/mkutf8data.c

1771

report++;

fs/unicode/mkutf8data.c

1774

report++;

fs/unicode/mkutf8data.c

1776

report++;

fs/unicode/mkutf8data.c

1778

report++;

fs/unicode/mkutf8data.c

1782

report++;

fs/unicode/mkutf8data.c

1785

report++;

fs/unicode/mkutf8data.c

1788

report++;

fs/unicode/mkutf8data.c

1793

report++;

fs/unicode/mkutf8data.c

1797

report++;

fs/unicode/mkutf8data.c

1800

report++;

fs/unicode/mkutf8data.c

1804

report++;

fs/unicode/mkutf8data.c

1807

if (report) {

include/linux/greybus/greybus_protocols.h

641

__u8 report[];

include/linux/greybus/greybus_protocols.h

646

__u8 report[0];

include/linux/hid.h

1004

void hid_output_report(struct hid_report *report, __u8 *data);

include/linux/hid.h

1006

u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags);

include/linux/hid.h

1030

__u32 hid_field_extract(const struct hid_device *hid, __u8 *report,

include/linux/hid.h

1181

struct hid_report *report, enum hid_class_request reqtype);

include/linux/hid.h

1219

static inline int hid_hw_idle(struct hid_device *hdev, int report, int idle,

include/linux/hid.h

1223

return hdev->ll_driver->idle(hdev, report, idle, reqtype);

include/linux/hid.h

1264

static inline u32 hid_report_len(struct hid_report *report)

include/linux/hid.h

1266

return DIV_ROUND_UP(report->size, 8) + (report->id > 0);

include/linux/hid.h

546

struct hid_report *report; /* associated report */

include/linux/hid.h

596

struct hid_report *report;

include/linux/hid.h

601

struct hid_report *report;

include/linux/hid.h

617

struct hid_report *report;

include/linux/hid.h

868

int (*raw_event)(struct hid_device *hdev, struct hid_report *report,

include/linux/hid.h

873

void (*report)(struct hid_device *hdev, struct hid_report *report);

include/linux/hid.h

932

struct hid_report *report, int reqtype);

include/linux/hid.h

942

int (*idle)(struct hid_device *hdev, int report, int idle, int reqtype);

include/linux/hid.h

991

extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);

include/linux/hiddev.h

45

void hiddev_report_event(struct hid_device *hid, struct hid_report *report);

include/linux/hiddev.h

53

static inline void hiddev_report_event(struct hid_device *hid, struct hid_report *report) { }

include/linux/netfilter.h

490

u32 portid, u32 report);

include/linux/page_reporting.h

13

int (*report)(struct page_reporting_dev_info *prdev,

include/linux/tsm.h

106

int (*report_new)(struct tsm_report *report, void *data);

include/net/netfilter/nf_conntrack.h

199

bool nf_ct_delete(struct nf_conn *ct, u32 pid, int report);

include/net/netfilter/nf_conntrack.h

238

int report;

include/net/netfilter/nf_conntrack_ecache.h

129

u32 portid, int report)

include/net/netfilter/nf_conntrack_ecache.h

133

return nf_conntrack_eventmask_report(1 << event, ct, portid, report);

include/net/netfilter/nf_conntrack_ecache.h

151

u32 portid, int report);

include/net/netfilter/nf_conntrack_ecache.h

169

int report)

include/net/netfilter/nf_conntrack_ecache.h

58

int report;

include/net/netfilter/nf_conntrack_ecache.h

64

int report;

include/net/netfilter/nf_conntrack_ecache.h

78

u32 portid, int report);

include/net/netfilter/nf_conntrack_ecache.h

90

int report)

include/net/netfilter/nf_conntrack_expect.h

122

u32 portid, int report);

include/net/netfilter/nf_conntrack_expect.h

135

void *data, u32 portid, int report);

include/net/netfilter/nf_conntrack_expect.h

146

u32 portid, int report, unsigned int flags);

include/net/netfilter/nf_tables.h

1411

int event, u16 flags, int family, int report, gfp_t gfp);

include/net/netfilter/nf_tables.h

1675

u8 report:1;

include/net/netfilter/nf_tables.h

1891

ctx->report = trans->report;

include/net/netfilter/nf_tables.h

223

bool report;

include/net/netlink.h

539

unsigned int group, int report, gfp_t flags);

include/net/xfrm.h

712

int (*report)(struct net *net, u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);

include/sound/pcm.h

346

const struct snd_pcm_audio_tstamp_report *report)

include/sound/pcm.h

350

tmp = report->accuracy_report;

include/sound/pcm.h

352

tmp |= report->actual_type;

include/sound/pcm.h

354

tmp |= report->valid;

include/sound/pcm.h

358

*accuracy = report->accuracy;

include/sound/soc-jack.h

64

int report;

kernel/liveupdate/kexec_handover.c

1473

goto report;

kernel/liveupdate/kexec_handover.c

1541

report:

lib/dhry_run.c

38

goto report;

lib/dhry_run.c

47

report:

mm/kmsan/core.c

350

goto report;

mm/kmsan/core.c

359

goto report;

mm/kmsan/core.c

366

goto report;

mm/kmsan/core.c

370

report:

mm/page_reporting.c

225

err = prdev->report(prdev, sgl, PAGE_REPORTING_CAPACITY);

mm/page_reporting.c

296

err = prdev->report(prdev, sgl, leftover);

net/ncsi/ncsi-manage.c

61

goto report;

net/ncsi/ncsi-manage.c

78

goto report;

net/ncsi/ncsi-manage.c

85

report:

net/netfilter/nf_conntrack_core.c

2374

nf_ct_delete(ct, iter_data->portid, iter_data->report);

net/netfilter/nf_conntrack_core.c

644

bool nf_ct_delete(struct nf_conn *ct, u32 portid, int report)

net/netfilter/nf_conntrack_core.c

662

portid, report) < 0) {

net/netfilter/nf_conntrack_ecache.c

174

u32 portid, int report)

net/netfilter/nf_conntrack_ecache.c

192

item.report = report;

net/netfilter/nf_conntrack_ecache.c

231

item.report = 0;

net/netfilter/nf_conntrack_ecache.c

243

u32 portid, int report)

net/netfilter/nf_conntrack_ecache.c

265

.report = report

net/netfilter/nf_conntrack_expect.c

48

u32 portid, int report)

net/netfilter/nf_conntrack_expect.c

514

u32 portid, int report, unsigned int flags)

net/netfilter/nf_conntrack_expect.c

525

nf_ct_expect_event_report(IPEXP_NEW, expect, portid, report);

net/netfilter/nf_conntrack_expect.c

562

u32 portid, int report)

net/netfilter/nf_conntrack_expect.c

579

nf_ct_unlink_expect_report(exp, portid, report);

net/netfilter/nf_conntrack_expect.c

66

nf_ct_expect_event_report(IPEXP_DESTROY, exp, portid, report);

net/netfilter/nf_conntrack_netlink.c

1591

u32 portid, int report, u8 family)

net/netfilter/nf_conntrack_netlink.c

1597

.report = report,

net/netfilter/nf_conntrack_netlink.c

2863

u32 portid, u32 report)

net/netfilter/nf_conntrack_netlink.c

2885

err = nf_ct_expect_related_report(exp, portid, report, 0);

net/netfilter/nf_conntrack_netlink.c

3106

if (!item->report && !nfnetlink_has_listeners(net, group))

net/netfilter/nf_conntrack_netlink.c

3123

nfnetlink_send(skb, net, item->portid, group, item->report, GFP_ATOMIC);

net/netfilter/nf_conntrack_netlink.c

3599

u_int8_t u3, u32 portid, int report)

net/netfilter/nf_conntrack_netlink.c

3634

err = nf_ct_expect_related_report(exp, portid, report, 0);

net/netfilter/nf_conntrack_netlink.c

771

if (!item->report && !nfnetlink_has_listeners(net, group))

net/netfilter/nf_conntrack_netlink.c

867

err = nfnetlink_send(skb, net, item->portid, group, item->report,

net/netfilter/nf_tables_api.c

10653

if (len > 0 && NFT_CB(skb).report == NFT_CB(batch_skb).report) {

net/netfilter/nf_tables_api.c

10661

NFT_CB(batch_skb).report, GFP_KERNEL);

net/netfilter/nf_tables_api.c

10667

NFT_CB(batch_skb).report, GFP_KERNEL);

net/netfilter/nf_tables_api.c

1219

bool report;

net/netfilter/nf_tables_api.c

1223

static void nft_notify_enqueue(struct sk_buff *skb, bool report,

net/netfilter/nf_tables_api.c

1226

NFT_CB(skb).report = report;

net/netfilter/nf_tables_api.c

1237

if (!ctx->report &&

net/netfilter/nf_tables_api.c

1256

nft_notify_enqueue(skb, ctx->report, &nft_net->notify_list);

net/netfilter/nf_tables_api.c

171

ctx->report = nlmsg_report(nlh);

net/netfilter/nf_tables_api.c

194

trans->report = ctx->report;

net/netfilter/nf_tables_api.c

2120

if (!ctx->report &&

net/netfilter/nf_tables_api.c

2140

nft_notify_enqueue(skb, ctx->report, &nft_net->notify_list);

net/netfilter/nf_tables_api.c

3753

if (!ctx->report &&

net/netfilter/nf_tables_api.c

3780

nft_notify_enqueue(skb, ctx->report, &nft_net->notify_list);

net/netfilter/nf_tables_api.c

5008

if (!ctx->report &&

net/netfilter/nf_tables_api.c

5025

nft_notify_enqueue(skb, ctx->report, &nft_net->notify_list);

net/netfilter/nf_tables_api.c

6598

if (!ctx->report && !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES))

net/netfilter/nf_tables_api.c

6616

nft_notify_enqueue(skb, ctx->report, &nft_net->notify_list);

net/netfilter/nf_tables_api.c

8630

u16 flags, int family, int report, gfp_t gfp)

net/netfilter/nf_tables_api.c

8636

if (!report &&

net/netfilter/nf_tables_api.c

8652

nft_notify_enqueue(skb, report, &nft_net->notify_list);

net/netfilter/nf_tables_api.c

8660

u16 flags, int family, int report, gfp_t gfp)

net/netfilter/nf_tables_api.c

8675

flags, family, report, gfp);

net/netfilter/nf_tables_api.c

8684

ctx->report, GFP_KERNEL);

net/netfilter/nf_tables_api.c

9562

if (!ctx->report &&

net/netfilter/nf_tables_api.c

9581

nft_notify_enqueue(skb, ctx->report, &nft_net->notify_list);

net/netfilter/nft_quota.c

23

bool *report)

net/netfilter/nft_quota.c

28

if (report)

net/netfilter/nft_quota.c

29

*report = consumed >= quota;

net/netfilter/nft_quota.c

60

bool overquota, report;

net/netfilter/nft_quota.c

62

overquota = nft_overquota(priv, pkt->skb, &report);

net/netfilter/nft_quota.c

66

if (report &&

net/netlink/af_netlink.c

2579

unsigned int group, int report, gfp_t flags)

net/netlink/af_netlink.c

2586

if (report) {

net/netlink/af_netlink.c

2598

if (report) {

net/sctp/sm_make_chunk.c

1898

struct __sctp_missing report;

net/sctp/sm_make_chunk.c

1901

len = SCTP_PAD4(sizeof(report));

net/sctp/sm_make_chunk.c

1910

report.num_missing = htonl(1);

net/sctp/sm_make_chunk.c

1911

report.type = paramtype;

net/sctp/sm_make_chunk.c

1913

sizeof(report));

net/sctp/sm_make_chunk.c

1914

sctp_addto_chunk(*errp, sizeof(report), &report);

net/xfrm/xfrm_state.c

2870

if (km->report) {

net/xfrm/xfrm_state.c

2871

ret = km->report(net, proto, sel, addr);

net/xfrm/xfrm_user.c

4214

.report = xfrm_send_report,

sound/hda/codecs/realtek/alc269.c

104

int report = 0;

sound/hda/codecs/realtek/alc269.c

107

report |= SND_JACK_BTN_0;

sound/hda/codecs/realtek/alc269.c

110

report |= SND_JACK_BTN_1;

sound/hda/codecs/realtek/alc269.c

114

report |= SND_JACK_BTN_2;

sound/hda/codecs/realtek/alc269.c

118

report |= SND_JACK_BTN_3;

sound/hda/codecs/realtek/alc269.c

120

snd_hda_jack_set_button_state(codec, jack->nid, report);

sound/soc/codecs/88pm860x-codec.c

1207

int status, shrt, report = 0, mic_report = 0;

sound/soc/codecs/88pm860x-codec.c

1223

report |= SND_JACK_HEADPHONE;

sound/soc/codecs/88pm860x-codec.c

1230

report |= pm860x->det.hs_shrt;

sound/soc/codecs/88pm860x-codec.c

1233

report |= pm860x->det.hook_det;

sound/soc/codecs/88pm860x-codec.c

1236

report |= pm860x->det.lo_shrt;

sound/soc/codecs/88pm860x-codec.c

1238

if (report)

sound/soc/codecs/88pm860x-codec.c

1239

snd_soc_jack_report(pm860x->det.hp_jack, report, mask);

sound/soc/codecs/88pm860x-codec.c

1245

report, mask);

sound/soc/codecs/arizona-jack.c

539

int ret, reading, state, report;

sound/soc/codecs/arizona-jack.c

579

report = SND_JACK_LINEOUT;

sound/soc/codecs/arizona-jack.c

581

report = SND_JACK_HEADPHONE;

sound/soc/codecs/arizona-jack.c

583

snd_soc_jack_report(info->jack, report, SND_JACK_LINEOUT | SND_JACK_HEADPHONE);

sound/soc/codecs/cs42l43-jack.c

741

int ret, report;

sound/soc/codecs/cs42l43-jack.c

765

report = CS42L43_JACK_OPTICAL;

sound/soc/codecs/cs42l43-jack.c

767

report = cs42l43_run_type_detect(priv);

sound/soc/codecs/cs42l43-jack.c

768

if (report < 0) {

sound/soc/codecs/cs42l43-jack.c

769

dev_err(priv->dev, "Jack detect failed: %d\n", report);

sound/soc/codecs/cs42l43-jack.c

774

snd_soc_jack_report(priv->jack_hp, report, report);

sound/soc/codecs/cs42l43-jack.c

836

int report;

sound/soc/codecs/cs42l43-jack.c

844

.report = CS42L43_JACK_HEADSET,

sound/soc/codecs/cs42l43-jack.c

853

.report = CS42L43_JACK_HEADSET,

sound/soc/codecs/cs42l43-jack.c

858

.report = CS42L43_JACK_HEADPHONE,

sound/soc/codecs/cs42l43-jack.c

863

.report = CS42L43_JACK_LINEOUT,

sound/soc/codecs/cs42l43-jack.c

868

.report = CS42L43_JACK_LINEIN,

sound/soc/codecs/cs42l43-jack.c

874

.report = CS42L43_JACK_LINEIN,

sound/soc/codecs/cs42l43-jack.c

879

.report = CS42L43_JACK_OPTICAL,

sound/soc/codecs/cs42l43-jack.c

981

cs42l43_jack_override_modes[override].report,

sound/soc/codecs/cs42l43-jack.c

982

cs42l43_jack_override_modes[override].report);

sound/soc/codecs/cx2072x.c

1446

.report = SND_JACK_HEADSET | SND_JACK_BTN_0,

sound/soc/codecs/da7218.c

2237

int report;

sound/soc/codecs/da7218.c

2242

report = SND_JACK_HEADPHONE;

sound/soc/codecs/da7218.c

2244

report = 0;

sound/soc/codecs/da7218.c

2246

snd_soc_jack_report(da7218->jack, report, SND_JACK_HEADPHONE);

sound/soc/codecs/da7219-aad.c

117

int report = 0, ret;

sound/soc/codecs/da7219-aad.c

252

report |= SND_JACK_HEADPHONE;

sound/soc/codecs/da7219-aad.c

254

report |= SND_JACK_LINEOUT;

sound/soc/codecs/da7219-aad.c

332

snd_soc_jack_report(da7219_aad->jack, report,

sound/soc/codecs/da7219-aad.c

358

int i, ret, report = 0, mask = 0;

sound/soc/codecs/da7219-aad.c

398

report |= SND_JACK_MECHANICAL;

sound/soc/codecs/da7219-aad.c

424

report |= SND_JACK_HEADSET;

sound/soc/codecs/da7219-aad.c

438

report |= SND_JACK_BTN_0 >> i;

sound/soc/codecs/da7219-aad.c

442

snd_soc_jack_report(da7219_aad->jack, report, mask);

sound/soc/codecs/da7219-aad.c

448

report &= ~(SND_JACK_BTN_0 >> i);

sound/soc/codecs/da7219-aad.c

456

report = 0;

sound/soc/codecs/da7219-aad.c

486

snd_soc_jack_report(da7219_aad->jack, report, mask);

sound/soc/codecs/mt6359-accdet.c

321

int report = 0;

sound/soc/codecs/mt6359-accdet.c

326

report = priv->jack_type | priv->btn_type;

sound/soc/codecs/mt6359-accdet.c

327

snd_soc_jack_report(priv->jack, report, MT6359_ACCDET_JACK_MASK);

sound/soc/codecs/rt5645.c

3323

int val, btn_type, gpio_state = 0, report = 0;

sound/soc/codecs/rt5645.c

3338

report = rt5645_jack_detect(rt5645->component, gpio_state);

sound/soc/codecs/rt5645.c

3341

report, SND_JACK_HEADPHONE);

sound/soc/codecs/rt5645.c

3343

report, SND_JACK_MICROPHONE);

sound/soc/codecs/rt5645.c

3356

report = rt5645_jack_detect(rt5645->component, 1);

sound/soc/codecs/rt5645.c

3362

report = SND_JACK_HEADSET;

sound/soc/codecs/rt5645.c

3373

report |= SND_JACK_BTN_0;

sound/soc/codecs/rt5645.c

3378

report |= SND_JACK_BTN_1;

sound/soc/codecs/rt5645.c

3383

report |= SND_JACK_BTN_2;

sound/soc/codecs/rt5645.c

3388

report |= SND_JACK_BTN_3;

sound/soc/codecs/rt5645.c

3400

report = rt5645->jack_type;

sound/soc/codecs/rt5645.c

3407

report = 0;

sound/soc/codecs/rt5645.c

3415

snd_soc_jack_report(rt5645->hp_jack, report, SND_JACK_HEADPHONE);

sound/soc/codecs/rt5645.c

3416

snd_soc_jack_report(rt5645->mic_jack, report, SND_JACK_MICROPHONE);

sound/soc/codecs/rt5645.c

3419

report, SND_JACK_BTN_0 | SND_JACK_BTN_1 |

sound/soc/codecs/rt5651.c

1788

int report;

sound/soc/codecs/rt5651.c

1806

report = rt5651_detect_headset(component);

sound/soc/codecs/rt5651.c

1807

dev_dbg(component->dev, "detect report %#02x\n", report);

sound/soc/codecs/rt5651.c

1808

snd_soc_jack_report(rt5651->hp_jack, report, SND_JACK_HEADSET);

sound/soc/codecs/rt5659.c

1356

int val, btn_type, report = 0;

sound/soc/codecs/rt5659.c

1366

report = rt5659_headset_detect(rt5659->component, 1);

sound/soc/codecs/rt5659.c

1369

report = SND_JACK_HEADSET;

sound/soc/codecs/rt5659.c

1382

report |= SND_JACK_BTN_0;

sound/soc/codecs/rt5659.c

1387

report |= SND_JACK_BTN_1;

sound/soc/codecs/rt5659.c

1392

report |= SND_JACK_BTN_2;

sound/soc/codecs/rt5659.c

1397

report |= SND_JACK_BTN_3;

sound/soc/codecs/rt5659.c

1411

report = rt5659->jack_type;

sound/soc/codecs/rt5659.c

1415

report = rt5659_headset_detect(rt5659->component, 0);

sound/soc/codecs/rt5659.c

1418

snd_soc_jack_report(rt5659->hs_jack, report, SND_JACK_HEADSET |

sound/soc/codecs/rt5663.c

1905

int btn_type, report = 0;

sound/soc/codecs/rt5663.c

1916

report = rt5663_v2_jack_detect(

sound/soc/codecs/rt5663.c

1920

report = rt5663_jack_detect(rt5663->component, 1);

sound/soc/codecs/rt5663.c

1932

report = SND_JACK_HEADSET;

sound/soc/codecs/rt5663.c

1945

report |= SND_JACK_BTN_0;

sound/soc/codecs/rt5663.c

1950

report |= SND_JACK_BTN_1;

sound/soc/codecs/rt5663.c

1955

report |= SND_JACK_BTN_2;

sound/soc/codecs/rt5663.c

1960

report |= SND_JACK_BTN_3;

sound/soc/codecs/rt5663.c

1973

report = rt5663->jack_type;

sound/soc/codecs/rt5663.c

1986

report = rt5663_v2_jack_detect(rt5663->component, 0);

sound/soc/codecs/rt5663.c

1989

report = rt5663_jack_detect(rt5663->component, 0);

sound/soc/codecs/rt5663.c

1995

dev_dbg(component->dev, "%s jack report: 0x%04x\n", __func__, report);

sound/soc/codecs/rt5663.c

1996

snd_soc_jack_report(rt5663->hs_jack, report, SND_JACK_HEADSET |

sound/soc/codecs/rt5670.c

518

int val, btn_type, report = jack->status;

sound/soc/codecs/rt5670.c

530

report = rt5670_headset_detect(rt5670->component, 1);

sound/soc/codecs/rt5670.c

538

report = SND_JACK_HEADSET;

sound/soc/codecs/rt5670.c

542

report |= SND_JACK_BTN_1;

sound/soc/codecs/rt5670.c

545

report |= SND_JACK_BTN_0;

sound/soc/codecs/rt5670.c

548

report |= SND_JACK_BTN_2;

sound/soc/codecs/rt5670.c

558

report = rt5670->jack_type;

sound/soc/codecs/rt5670.c

565

report = 0;

sound/soc/codecs/rt5670.c

574

return report;

sound/soc/codecs/rt5670.c

586

rt5670->hp_gpio.report = SND_JACK_HEADSET |

sound/soc/codecs/ts3a227e.c

157

int report = 0;

sound/soc/codecs/ts3a227e.c

163

report = SND_JACK_HEADPHONE;

sound/soc/codecs/ts3a227e.c

165

report |= SND_JACK_MICROPHONE;

sound/soc/codecs/ts3a227e.c

168

report |= ts3a227e_buttons[i];

sound/soc/codecs/ts3a227e.c

170

snd_soc_jack_report(ts3a227e->jack, report, TS3A227E_JACK_MASK);

sound/soc/codecs/twl6040.c

271

struct snd_soc_jack *jack, int report)

sound/soc/codecs/twl6040.c

281

snd_soc_jack_report(jack, report, report);

sound/soc/codecs/twl6040.c

283

snd_soc_jack_report(jack, 0, report);

sound/soc/codecs/twl6040.c

289

struct snd_soc_jack *jack, int report)

sound/soc/codecs/twl6040.c

295

hs_jack->report = report;

sound/soc/codecs/twl6040.c

297

twl6040_hs_jack_report(component, hs_jack->jack, hs_jack->report);

sound/soc/codecs/twl6040.c

308

twl6040_hs_jack_report(component, hs_jack->jack, hs_jack->report);

sound/soc/codecs/twl6040.c

48

int report;

sound/soc/codecs/twl6040.h

25

struct snd_soc_jack *jack, int report);

sound/soc/codecs/wm8350.c

1245

int report;

sound/soc/codecs/wm8350.c

1249

report = jack->report;

sound/soc/codecs/wm8350.c

1251

report = 0;

sound/soc/codecs/wm8350.c

1253

snd_soc_jack_report(jack->jack, report, jack->report);

sound/soc/codecs/wm8350.c

1321

struct snd_soc_jack *jack, int report)

sound/soc/codecs/wm8350.c

1330

priv->hpl.report = report;

sound/soc/codecs/wm8350.c

1336

priv->hpr.report = report;

sound/soc/codecs/wm8350.c

1344

if (report) {

sound/soc/codecs/wm8350.c

1370

int report = 0;

sound/soc/codecs/wm8350.c

1378

report |= priv->mic.short_report;

sound/soc/codecs/wm8350.c

1380

report |= priv->mic.report;

sound/soc/codecs/wm8350.c

1382

snd_soc_jack_report(priv->mic.jack, report,

sound/soc/codecs/wm8350.c

1383

priv->mic.report | priv->mic.short_report);

sound/soc/codecs/wm8350.c

1407

priv->mic.report = detect_report;

sound/soc/codecs/wm8350.c

55

int report;

sound/soc/codecs/wm8350.h

20

struct snd_soc_jack *jack, int report);

sound/soc/codecs/wm8994.c

3583

int report;

sound/soc/codecs/wm8994.c

3597

report = 0;

sound/soc/codecs/wm8994.c

3600

report = SND_JACK_HEADSET;

sound/soc/codecs/wm8994.c

3604

report = SND_JACK_HEADPHONE;

sound/soc/codecs/wm8994.c

3606

report |= SND_JACK_BTN_0;

sound/soc/codecs/wm8994.c

3608

if (report)

sound/soc/codecs/wm8994.c

3613

snd_soc_jack_report(priv->micdet[0].jack, report,

sound/soc/codecs/wm8994.c

3616

report = 0;

sound/soc/codecs/wm8994.c

3619

report = SND_JACK_HEADSET;

sound/soc/codecs/wm8994.c

3623

report = SND_JACK_HEADPHONE;

sound/soc/codecs/wm8994.c

3625

report |= SND_JACK_BTN_0;

sound/soc/codecs/wm8994.c

3627

if (report)

sound/soc/codecs/wm8994.c

3632

snd_soc_jack_report(priv->micdet[1].jack, report,

sound/soc/codecs/wm8994.c

3675

int report;

sound/soc/codecs/wm8994.c

3677

report = 0;

sound/soc/codecs/wm8994.c

3679

report |= SND_JACK_BTN_0;

sound/soc/codecs/wm8994.c

3682

report |= SND_JACK_BTN_1;

sound/soc/codecs/wm8994.c

3685

report |= SND_JACK_BTN_2;

sound/soc/codecs/wm8994.c

3688

report |= SND_JACK_BTN_3;

sound/soc/codecs/wm8994.c

3691

report |= SND_JACK_BTN_4;

sound/soc/codecs/wm8994.c

3694

report |= SND_JACK_BTN_5;

sound/soc/codecs/wm8994.c

3696

snd_soc_jack_report(wm8994->micdet[0].jack, report,

sound/soc/codecs/wm8996.c

2289

int val, reg, report;

sound/soc/codecs/wm8996.c

2294

report = SND_JACK_HEADPHONE;

sound/soc/codecs/wm8996.c

2315

report = SND_JACK_LINEOUT;

sound/soc/codecs/wm8996.c

2317

report = SND_JACK_HEADPHONE;

sound/soc/codecs/wm8996.c

2321

report |= SND_JACK_MICROPHONE;

sound/soc/codecs/wm8996.c

2323

snd_soc_jack_report(wm8996->jack, report,

sound/soc/fsl/imx-es8328.c

31

.report = SND_JACK_HEADSET,

sound/soc/generic/simple-card-utils.c

824

sjack->gpio.report = mask;

sound/soc/intel/boards/bdw-rt5677.c

104

.report = SND_JACK_HEADPHONE,

sound/soc/intel/boards/bdw-rt5677.c

110

.report = SND_JACK_MICROPHONE,

sound/soc/intel/boards/bytcr_rt5640.c

479

.report = SND_JACK_HEADSET,

sound/soc/intel/boards/bytcr_rt5640.c

486

.report = SND_JACK_HEADSET,

sound/soc/intel/boards/bytcr_rt5640.c

521

int jack_status, report;

sound/soc/intel/boards/bytcr_rt5640.c

528

report = rt5640_detect_headset(component, rt5640_jack2_gpio.desc);

sound/soc/intel/boards/bytcr_rt5640.c

531

return report;

sound/soc/intel/boards/bytcr_rt5651.c

586

int report;

sound/soc/intel/boards/bytcr_rt5651.c

664

report = 0;

sound/soc/intel/boards/bytcr_rt5651.c

666

report = SND_JACK_HEADSET | SND_JACK_BTN_0;

sound/soc/intel/boards/bytcr_rt5651.c

668

report = SND_JACK_HEADSET;

sound/soc/intel/boards/bytcr_rt5651.c

670

if (report) {

sound/soc/intel/boards/bytcr_rt5651.c

672

report, &priv->jack,

sound/soc/intel/boards/bytcr_rt5651.c

680

if (report & SND_JACK_BTN_0)

sound/soc/intel/boards/cht_bsw_max98090_ti.c

165

.report = SND_JACK_HEADPHONE | SND_JACK_LINEOUT,

sound/soc/intel/boards/cht_bsw_max98090_ti.c

171

.report = SND_JACK_MICROPHONE,

sound/soc/rockchip/rk3288_hdmi_analog.c

113

.report = SND_JACK_HEADPHONE,

sound/soc/samsung/aries_wm8994.c

153

.report = SND_JACK_BTN_0,

sound/soc/samsung/midas_wm1811.c

151

.report = SND_JACK_HEADSET,

sound/soc/samsung/midas_wm1811.c

157

.report = SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2,

sound/soc/sdca/sdca_jack.c

194

unsigned int report = 0;

sound/soc/sdca/sdca_jack.c

222

report = SND_JACK_LINEIN;

sound/soc/sdca/sdca_jack.c

229

report = SND_JACK_LINEOUT;

sound/soc/sdca/sdca_jack.c

232

report = SND_JACK_MICROPHONE;

sound/soc/sdca/sdca_jack.c

235

report = SND_JACK_HEADPHONE;

sound/soc/sdca/sdca_jack.c

238

report = SND_JACK_HEADSET;

sound/soc/sdca/sdca_jack.c

244

snd_soc_jack_report(jack_state->jack, report, 0xFFFF);

sound/soc/soc-jack.c

214

int report;

sound/soc/soc-jack.c

221

report = gpio->report;

sound/soc/soc-jack.c

223

report = 0;

sound/soc/soc-jack.c

226

report = gpio->jack_status_check(gpio->data);

sound/soc/soc-jack.c

228

snd_soc_jack_report(jack, report, gpio->report);

sound/soc/sunxi/sun4i-codec.c

1596

.report = SND_JACK_HEADPHONE,

sound/soc/tegra/tegra_asoc_machine.c

33

.report = SND_JACK_HEADPHONE,

sound/soc/tegra/tegra_asoc_machine.c

48

.report = SND_JACK_HEADSET,

sound/soc/tegra/tegra_asoc_machine.c

74

.report = SND_JACK_MICROPHONE,

sound/soc/ti/ams-delta.c

217

.report = SND_JACK_HEADSET,

sound/soc/ti/omap-twl4030.c

131

.report = SND_JACK_HEADSET,

sound/soc/ti/rx51.c

203

.report = SND_JACK_HEADSET,

tools/lib/bpf/libbpf.c

3563

goto report;

tools/lib/bpf/libbpf.c

3644

report:

tools/lib/subcmd/subcmd-util.h

22

report(" Fatal: ", err, params);

tools/mm/slabinfo.c

1353

report(slab);

tools/mm/slabinfo.c

612

report(s);

tools/perf/builtin-kwork.c

1016

if (kwork->report == KWORK_REPORT_TOP) {

tools/perf/builtin-kwork.c

1146

if (kwork->report == KWORK_REPORT_TOP) {

tools/perf/builtin-kwork.c

1376

if (kwork->report == KWORK_REPORT_RUNTIME) {

tools/perf/builtin-kwork.c

1380

} else if (kwork->report == KWORK_REPORT_LATENCY) { // avg delay

tools/perf/builtin-kwork.c

1395

if (kwork->report == KWORK_REPORT_RUNTIME) {

tools/perf/builtin-kwork.c

1411

else if (kwork->report == KWORK_REPORT_LATENCY) {

tools/perf/builtin-kwork.c

1438

if (kwork->report == KWORK_REPORT_RUNTIME) {

tools/perf/builtin-kwork.c

1441

} else if (kwork->report == KWORK_REPORT_LATENCY) {

tools/perf/builtin-kwork.c

1448

if (kwork->report == KWORK_REPORT_RUNTIME) {

tools/perf/builtin-kwork.c

1453

} else if (kwork->report == KWORK_REPORT_LATENCY) {

tools/perf/builtin-kwork.c

1738

switch (kwork->report) {

tools/perf/builtin-kwork.c

1752

pr_debug("Invalid report type %d\n", kwork->report);

tools/perf/builtin-kwork.c

1820

if (kwork->report == KWORK_REPORT_TIMEHIST)

tools/perf/builtin-kwork.c

210

if (kwork->report == KWORK_REPORT_LATENCY)

tools/perf/builtin-kwork.c

2502

kwork.report = KWORK_REPORT_RUNTIME;

tools/perf/builtin-kwork.c

2513

kwork.report = KWORK_REPORT_LATENCY;

tools/perf/builtin-kwork.c

2523

kwork.report = KWORK_REPORT_TIMEHIST;

tools/perf/builtin-kwork.c

2533

kwork.report = KWORK_REPORT_TOP;

tools/perf/builtin-kwork.c

438

if ((kwork->report != KWORK_REPORT_TOP) &&

tools/perf/builtin-report.c

1035

static int tasks_print(struct report *rep, FILE *fp)

tools/perf/builtin-report.c

1056

static int __cmd_report(struct report *rep)

tools/perf/builtin-report.c

1266

struct report *rep = opt->value;

tools/perf/builtin-report.c

128

struct report *rep = cb;

tools/perf/builtin-report.c

1325

struct report report = {

tools/perf/builtin-report.c

1342

OPT_BOOLEAN(0, "stats", &report.stats_mode, "Display event stats"),

tools/perf/builtin-report.c

1343

OPT_BOOLEAN(0, "tasks", &report.tasks_mode, "Display recorded tasks"),

tools/perf/builtin-report.c

1344

OPT_BOOLEAN(0, "mmaps", &report.mmaps_mode, "Display recorded tasks memory maps"),

tools/perf/builtin-report.c

1356

OPT_BOOLEAN('T', "threads", &report.show_threads,

tools/perf/builtin-report.c

1358

OPT_STRING(0, "pretty", &report.pretty_printing_style, "key",

tools/perf/builtin-report.c

1361

OPT_BOOLEAN(0, "tui", &report.use_tui, "Use the TUI interface"),

tools/perf/builtin-report.c

1364

OPT_BOOLEAN(0, "gtk", &report.use_gtk, "Use the GTK2 interface"),

tools/perf/builtin-report.c

1366

OPT_BOOLEAN(0, "stdio", &report.use_stdio,

tools/perf/builtin-report.c

1368

OPT_BOOLEAN(0, "header", &report.header, "Show data header."),

tools/perf/builtin-report.c

1369

OPT_BOOLEAN(0, "header-only", &report.header_only,

tools/perf/builtin-report.c

1390

OPT_INTEGER(0, "max-stack", &report.max_stack,

tools/perf/builtin-report.c

1394

OPT_BOOLEAN('G', "inverted", &report.inverted_callchain,

tools/perf/builtin-report.c

1409

OPT_STRING(0, "symbol-filter", &report.symbol_filter_str, "filter",

tools/perf/builtin-report.c

1422

OPT_STRING('C', "cpu", &report.cpu_list, "cpu",

tools/perf/builtin-report.c

1426

OPT_BOOLEAN('I', "show-info", &report.show_full_info,

tools/perf/builtin-report.c

1440

OPT_BOOLEAN_SET(0, "group", &symbol_conf.event_group, &report.group_set,

tools/perf/builtin-report.c

1462

OPT_BOOLEAN(0, "mem-mode", &report.mem_mode, "mem access profile"),

tools/perf/builtin-report.c

1465

OPT_CALLBACK(0, "percent-limit", &report, "percent",

tools/perf/builtin-report.c

1476

OPT_BOOLEAN(0, "stitch-lbr", &report.stitch_lbr,

tools/perf/builtin-report.c

1478

OPT_INTEGER(0, "socket-filter", &report.socket_filter,

tools/perf/builtin-report.c

1487

OPT_STRING(0, "time", &report.time_str, "str",

tools/perf/builtin-report.c

1498

OPTS_EVSWITCH(&report.evswitch),

tools/perf/builtin-report.c

1499

OPT_BOOLEAN(0, "total-cycles", &report.total_cycles_mode,

tools/perf/builtin-report.c

1501

OPT_BOOLEAN(0, "disable-order", &report.disable_order,

tools/perf/builtin-report.c

1503

OPT_BOOLEAN(0, "skip-empty", &report.skip_empty,

tools/perf/builtin-report.c

1530

ret = perf_config(report__config, &report);

tools/perf/builtin-report.c

1543

report.symbol_filter_str = argv[0];

tools/perf/builtin-report.c

1567

if (report.mmaps_mode)

tools/perf/builtin-report.c

1568

report.tasks_mode = true;

tools/perf/builtin-report.c

1570

if (dump_trace && report.disable_order)

tools/perf/builtin-report.c

1580

if (report.inverted_callchain)

tools/perf/builtin-report.c

1586

(int)itrace_synth_opts.callchain_sz > report.max_stack)

tools/perf/builtin-report.c

1587

report.max_stack = itrace_synth_opts.callchain_sz;

tools/perf/builtin-report.c

1600

symbol_conf.skip_empty = report.skip_empty;

tools/perf/builtin-report.c

1602

perf_tool__init(&report.tool, ordered_events);

tools/perf/builtin-report.c

1603

report.tool.sample = process_sample_event;

tools/perf/builtin-report.c

1604

report.tool.mmap = perf_event__process_mmap;

tools/perf/builtin-report.c

1605

report.tool.mmap2 = perf_event__process_mmap2;

tools/perf/builtin-report.c

1606

report.tool.comm = perf_event__process_comm;

tools/perf/builtin-report.c

1607

report.tool.namespaces = perf_event__process_namespaces;

tools/perf/builtin-report.c

1608

report.tool.cgroup = perf_event__process_cgroup;

tools/perf/builtin-report.c

1609

report.tool.exit = perf_event__process_exit;

tools/perf/builtin-report.c

1610

report.tool.fork = perf_event__process_fork;

tools/perf/builtin-report.c

1611

report.tool.context_switch = perf_event__process_switch;

tools/perf/builtin-report.c

1612

report.tool.lost = perf_event__process_lost;

tools/perf/builtin-report.c

1613

report.tool.read = process_read_event;

tools/perf/builtin-report.c

1614

report.tool.attr = process_attr;

tools/perf/builtin-report.c

1616

report.tool.tracing_data = perf_event__process_tracing_data;

tools/perf/builtin-report.c

1618

report.tool.build_id = perf_event__process_build_id;

tools/perf/builtin-report.c

1619

report.tool.id_index = perf_event__process_id_index;

tools/perf/builtin-report.c

1620

report.tool.auxtrace_info = perf_event__process_auxtrace_info;

tools/perf/builtin-report.c

1621

report.tool.auxtrace = perf_event__process_auxtrace;

tools/perf/builtin-report.c

1622

report.tool.event_update = perf_event__process_event_update;

tools/perf/builtin-report.c

1623

report.tool.feature = process_feature_event;

tools/perf/builtin-report.c

1624

report.tool.ordering_requires_timestamps = true;

tools/perf/builtin-report.c

1625

report.tool.merge_deferred_callchains = !dump_trace;

tools/perf/builtin-report.c

1627

session = perf_session__new(&data, &report.tool);

tools/perf/builtin-report.c

1633

ret = evswitch__init(&report.evswitch, session->evlist, stderr);

tools/perf/builtin-report.c

1640

if (report.queue_size) {

tools/perf/builtin-report.c

1642

report.queue_size);

tools/perf/builtin-report.c

1647

report.session = session;

tools/perf/builtin-report.c

1654

setup_forced_leader(&report, session->evlist);

tools/perf/builtin-report.c

1668

memset(&report.brtype_stat, 0, sizeof(struct branch_type_stat));

tools/perf/builtin-report.c

1689

if (report.mem_mode) {

tools/perf/builtin-report.c

1706

if (report.use_stdio)

tools/perf/builtin-report.c

1709

else if (report.use_tui)

tools/perf/builtin-report.c

171

struct report *rep = arg;

tools/perf/builtin-report.c

1713

else if (report.use_gtk)

tools/perf/builtin-report.c

1718

if (report.header || report.header_only || report.show_threads)

tools/perf/builtin-report.c

1720

if (report.header || report.header_only)

tools/perf/builtin-report.c

1721

report.tool.show_feat_hdr = SHOW_FEAT_HEADER;

tools/perf/builtin-report.c

1722

if (report.show_full_info)

tools/perf/builtin-report.c

1723

report.tool.show_feat_hdr = SHOW_FEAT_HEADER_FULL_INFO;

tools/perf/builtin-report.c

1724

if (report.stats_mode || report.tasks_mode)

tools/perf/builtin-report.c

1726

if (report.stats_mode && report.tasks_mode) {

tools/perf/builtin-report.c

1731

if (report.total_cycles_mode) {

tools/perf/builtin-report.c

1733

report.total_cycles_mode = false;

tools/perf/builtin-report.c

1740

report.data_type = true;

tools/perf/builtin-report.c

1757

if (report.data_type && use_browser == 1) {

tools/perf/builtin-report.c

1763

if (report.disable_order || !perf_session__has_switch_events(session)) {

tools/perf/builtin-report.c

1770

if (report.disable_order)

tools/perf/builtin-report.c

1793

report.symbol_ipc = true;

tools/perf/builtin-report.c

1813

if ((report.header || report.header_only) && !quiet) {

tools/perf/builtin-report.c

1815

report.show_full_info);

tools/perf/builtin-report.c

1816

if (report.header_only) {

tools/perf/builtin-report.c

1828

!report.stats_mode && !report.tasks_mode) {

tools/perf/builtin-report.c

1838

if (ui__has_annotation() || report.symbol_ipc || report.data_type ||

tools/perf/builtin-report.c

1839

report.total_cycles_mode) {

tools/perf/builtin-report.c

1863

if (report.time_str) {

tools/perf/builtin-report.c

1864

ret = perf_time__parse_for_ranges(report.time_str, session,

tools/perf/builtin-report.c

1865

&report.ptime_range,

tools/perf/builtin-report.c

1866

&report.range_size,

tools/perf/builtin-report.c

1867

&report.range_num);

tools/perf/builtin-report.c

1872

report.ptime_range,

tools/perf/builtin-report.c

1873

report.range_num);

tools/perf/builtin-report.c

1888

ret = __cmd_report(&report);

tools/perf/builtin-report.c

1904

if (report.ptime_range) {

tools/perf/builtin-report.c

1906

zfree(&report.ptime_range);

tools/perf/builtin-report.c

1909

if (report.block_reports) {

tools/perf/builtin-report.c

1910

block_info__free_report(report.block_reports,

tools/perf/builtin-report.c

1911

report.nr_block_reports);

tools/perf/builtin-report.c

1912

report.block_reports = NULL;

tools/perf/builtin-report.c

214

struct report *rep = arg;

tools/perf/builtin-report.c

236

static void setup_forced_leader(struct report *report,

tools/perf/builtin-report.c

239

if (report->group_set)

tools/perf/builtin-report.c

247

struct report *rep = container_of(tool, struct report, tool);

tools/perf/builtin-report.c

275

struct report *rep = container_of(tool, struct report, tool);

tools/perf/builtin-report.c

355

struct report *rep = container_of(tool, struct report, tool);

tools/perf/builtin-report.c

371

static int report__setup_sample_type(struct report *rep)

tools/perf/builtin-report.c

478

static size_t hists__fprintf_nr_sample_events(struct hists *hists, struct report *rep,

tools/perf/builtin-report.c

546

static int evlist__tui_block_hists_browse(struct evlist *evlist, struct report *rep)

tools/perf/builtin-report.c

562

static int evlist__tty_browse_hists(struct evlist *evlist, struct report *rep, const char *help)

tools/perf/builtin-report.c

620

static void report__warn_kptr_restrict(const struct report *rep)

tools/perf/builtin-report.c

649

static int report__gtk_browse_hists(struct report *rep, const char *help)

tools/perf/builtin-report.c

664

static int report__browse_hists(struct report *rep)

tools/perf/builtin-report.c

708

static int report__collapse_hists(struct report *rep)

tools/perf/builtin-report.c

758

struct report *rep = arg;

tools/perf/builtin-report.c

770

static void report__output_resort(struct report *rep)

tools/perf/builtin-report.c

801

struct report *rep = container_of(tool, struct report, tool);

tools/perf/builtin-report.c

821

static void stats_setup(struct report *rep)

tools/perf/builtin-report.c

831

static int stats_print(struct report *rep)

tools/perf/builtin-report.c

840

static void tasks_setup(struct report *rep)

tools/perf/util/bpf_kwork.c

106

if (kwork->report == KWORK_REPORT_RUNTIME) {

tools/perf/util/bpf_kwork.c

109

} else if (kwork->report == KWORK_REPORT_LATENCY) {

tools/perf/util/bpf_kwork.c

122

if (kwork->report == KWORK_REPORT_RUNTIME) {

tools/perf/util/bpf_kwork.c

125

} else if (kwork->report == KWORK_REPORT_LATENCY) {

tools/perf/util/bpf_kwork.c

292

if (kwork->report == KWORK_REPORT_RUNTIME) {

tools/perf/util/bpf_kwork.c

298

} else if (kwork->report == KWORK_REPORT_LATENCY) {

tools/perf/util/bpf_kwork.c

305

pr_debug("Invalid bpf report type %d\n", kwork->report);

tools/perf/util/bpf_kwork.c

93

if (kwork->report == KWORK_REPORT_RUNTIME) {

tools/perf/util/kwork.h

226

enum kwork_report_type report;

tools/testing/selftests/kvm/x86/nested_tsc_adjust_test.c

153

report(uc.args[1]);

tools/testing/selftests/mm/gup_longterm.c

101

goto report;

tools/testing/selftests/mm/gup_longterm.c

111

goto report;

tools/testing/selftests/mm/gup_longterm.c

132

goto report;

tools/testing/selftests/mm/gup_longterm.c

145

goto report;

tools/testing/selftests/mm/gup_longterm.c

238

goto report;

tools/testing/selftests/mm/gup_longterm.c

296

report:

tools/testing/selftests/powerpc/pmu/count_instructions.c

30

u64 overhead, bool report)

tools/testing/selftests/powerpc/pmu/count_instructions.c

49

if (report) {

tools/testing/selftests/powerpc/pmu/count_stcx_fail.c

30

u64 overhead, bool report)

tools/testing/selftests/powerpc/pmu/count_stcx_fail.c

51

if (report) {

tools/testing/selftests/powerpc/pmu/ebb/instruction_count_test.c

26

uint64_t overhead, bool report)

tools/testing/selftests/powerpc/pmu/ebb/instruction_count_test.c

50

if (report) {