raw_data - Linux

crypto/asymmetric_keys/asymmetric_type.c

311

const char *spec = match_data->raw_data;

drivers/comedi/drivers/jr3_pci.h

49

s32 raw_data;

drivers/firmware/edd.c

553

static EDD_DEVICE_ATTR(raw_data, 0444, edd_show_raw_data, edd_has_edd_info);

drivers/gpib/agilent_82357a/agilent_82357a.c

208

static void agilent_82357a_dump_raw_block(const u8 *raw_data, int length)

drivers/gpib/agilent_82357a/agilent_82357a.c

210

print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 8, 1, raw_data, length, true);

drivers/gpib/ni_usb/ni_usb_gpib.c

364

static void ni_usb_dump_raw_block(const u8 *raw_data, int length)

drivers/gpib/ni_usb/ni_usb_gpib.c

366

print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 8, 1, raw_data, length, true);

drivers/gpib/ni_usb/ni_usb_gpib.c

369

static int ni_usb_parse_register_read_block(const u8 *raw_data, unsigned int *results,

drivers/gpib/ni_usb/ni_usb_gpib.c

380

if (raw_data[i++] != NIUSB_REGISTER_READ_DATA_START_ID) {

drivers/gpib/ni_usb/ni_usb_gpib.c

385

results[j++] = raw_data[i++];

drivers/gpib/ni_usb/ni_usb_gpib.c

389

if (raw_data[i++] != NIUSB_REGISTER_READ_DATA_END_ID) {

drivers/gpib/ni_usb/ni_usb_gpib.c

393

if (raw_data[i++] % results_per_chunk != num_results % results_per_chunk) {

drivers/gpib/ni_usb/ni_usb_gpib.c

395

(int)raw_data[i - 1]);

drivers/gpib/ni_usb/ni_usb_gpib.c

399

if (raw_data[i++] != 0) {

drivers/gpib/ni_usb/ni_usb_gpib.c

401

i - 1, (int)raw_data[i - 1]);

drivers/gpib/ni_usb/ni_usb_gpib.c

406

ni_usb_dump_raw_block(raw_data, i);

drivers/gpib/ni_usb/ni_usb_gpib.c

426

static int parse_board_ibrd_readback(const u8 *raw_data, struct ni_usb_status_block *status,

drivers/gpib/ni_usb/ni_usb_gpib.c

440

while (raw_data[i] == NIUSB_IBRD_DATA_ID || raw_data[i] == NIUSB_IBRD_EXTENDED_DATA_ID) {

drivers/gpib/ni_usb/ni_usb_gpib.c

441

if (raw_data[i] == NIUSB_IBRD_DATA_ID) {

drivers/gpib/ni_usb/ni_usb_gpib.c

443

} else if (raw_data[i] == NIUSB_IBRD_EXTENDED_DATA_ID) {

drivers/gpib/ni_usb/ni_usb_gpib.c

445

if (raw_data[++i] != 0) {

drivers/gpib/ni_usb/ni_usb_gpib.c

447

i, (int)raw_data[i]);

drivers/gpib/ni_usb/ni_usb_gpib.c

457

parsed_data[j++] = raw_data[i++];

drivers/gpib/ni_usb/ni_usb_gpib.c

463

i += ni_usb_parse_status_block(&raw_data[i], status);

drivers/gpib/ni_usb/ni_usb_gpib.c

470

*actual_bytes_read = (num_data_blocks - 1) * data_block_length + raw_data[i++];

drivers/gpib/ni_usb/ni_usb_gpib.c

478

if (raw_data[i++] != 0) {

drivers/gpib/ni_usb/ni_usb_gpib.c

480

i - 1, (int)raw_data[i - 1]);

drivers/gpib/ni_usb/ni_usb_gpib.c

483

i += ni_usb_parse_status_block(&raw_data[i], &register_write_status);

drivers/gpib/ni_usb/ni_usb_gpib.c

489

if (raw_data[i++] != 2) {

drivers/gpib/ni_usb/ni_usb_gpib.c

491

(int)raw_data[i - 1]);

drivers/gpib/ni_usb/ni_usb_gpib.c

495

if (raw_data[i++] != 0) {

drivers/gpib/ni_usb/ni_usb_gpib.c

497

i - 1, (int)raw_data[i - 1]);

drivers/gpib/ni_usb/ni_usb_gpib.c

500

i += ni_usb_parse_termination_block(&raw_data[i]);

drivers/gpib/ni_usb/ni_usb_gpib.c

502

ni_usb_dump_raw_block(raw_data, i);

drivers/gpib/ni_usb/ni_usb_gpib.c

506

static int ni_usb_parse_reg_write_status_block(const u8 *raw_data,

drivers/gpib/ni_usb/ni_usb_gpib.c

512

i += ni_usb_parse_status_block(raw_data, status);

drivers/gpib/ni_usb/ni_usb_gpib.c

513

*writes_completed = raw_data[i++];

drivers/gpu/drm/hisilicon/hibmc/dp/dp_hw.c

298

struct hibmc_dp_color_raw raw_data;

drivers/gpu/drm/hisilicon/hibmc/dp/dp_hw.c

308

raw_data = g_rgb_raw[cfg->pattern];

drivers/gpu/drm/hisilicon/hibmc/dp/dp_hw.c

309

drm_dbg_dp(dp->drm_dev, "r:%x g:%x b:%x\n", raw_data.r_value,

drivers/gpu/drm/hisilicon/hibmc/dp/dp_hw.c

310

raw_data.g_value, raw_data.b_value);

drivers/gpu/drm/hisilicon/hibmc/dp/dp_hw.c

313

raw_data.r_value);

drivers/gpu/drm/hisilicon/hibmc/dp/dp_hw.c

315

raw_data.g_value);

drivers/gpu/drm/hisilicon/hibmc/dp/dp_hw.c

317

raw_data.b_value);

drivers/hid/hid-lenovo.c

726

static int lenovo_raw_event_TP_X12_tab(struct hid_device *hdev, u32 raw_data)

drivers/hid/hid-lenovo.c

737

switch (raw_data) {

drivers/hid/hid-letsketch.c

168

u8 *raw_data, int size)

drivers/hid/hid-letsketch.c

174

if (size != LETSKETCH_RAW_DATA_LEN || raw_data[0] != LETSKETCH_RAW_REPORT_ID)

drivers/hid/hid-letsketch.c

177

switch (raw_data[1] & 0xf0) {

drivers/hid/hid-letsketch.c

181

input_report_key(input, BTN_TOUCH, raw_data[1] & 0x01);

drivers/hid/hid-letsketch.c

182

input_report_key(input, BTN_STYLUS, raw_data[1] & 0x02);

drivers/hid/hid-letsketch.c

183

input_report_key(input, BTN_STYLUS2, raw_data[1] & 0x04);

drivers/hid/hid-letsketch.c

185

get_unaligned_le16(raw_data + 2));

drivers/hid/hid-letsketch.c

187

get_unaligned_le16(raw_data + 4));

drivers/hid/hid-letsketch.c

189

get_unaligned_le16(raw_data + 6));

drivers/hid/hid-letsketch.c

199

input_report_key(input, BTN_0 + i, raw_data[4] == (i + 1));

drivers/hid/hid-letsketch.c

203

raw_data[0]);

drivers/hid/hid-nintendo.c

2666

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

drivers/hid/hid-nintendo.c

2673

return joycon_ctlr_handle_event(ctlr, raw_data, size);

drivers/hid/hid-picolcd.h

143

u8 *raw_data, int size);

drivers/hid/hid-picolcd.h

158

u8 *raw_data, int size)

drivers/hid/hid-picolcd.h

277

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

drivers/hid/hid-picolcd.h

284

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

drivers/hid/hid-picolcd.h

299

int report_id, const u8 *raw_data, int size);

drivers/hid/hid-picolcd.h

57

u8 raw_data[64];

drivers/hid/hid-picolcd_cir.c

34

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

drivers/hid/hid-picolcd_cir.c

58

sz = size > 0 ? min((int)raw_data[0], size-1) : 0;

drivers/hid/hid-picolcd_cir.c

60

w = (raw_data[i] << 8) | (raw_data[i+1]);

drivers/hid/hid-picolcd_core.c

118

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

drivers/hid/hid-picolcd_core.c

130

if (raw_data[i] == 0)

drivers/hid/hid-picolcd_core.c

133

if (data->pressed_keys[j] == raw_data[i])

drivers/hid/hid-picolcd_core.c

137

data->pressed_keys[j] = raw_data[i];

drivers/hid/hid-picolcd_core.c

140

input_event(data->input_keys, EV_MSC, MSC_SCAN, raw_data[i]);

drivers/hid/hid-picolcd_core.c

141

if (raw_data[i] < PICOLCD_KEYS)

drivers/hid/hid-picolcd_core.c

142

key_code = data->keycode[raw_data[i]];

drivers/hid/hid-picolcd_core.c

147

raw_data[i], key_code);

drivers/hid/hid-picolcd_core.c

161

if (data->pressed_keys[j] == raw_data[i])

drivers/hid/hid-picolcd_core.c

197

data->version[0] = verinfo->raw_data[1];

drivers/hid/hid-picolcd_core.c

198

data->version[1] = verinfo->raw_data[0];

drivers/hid/hid-picolcd_core.c

201

verinfo->raw_data[1], verinfo->raw_data[0]);

drivers/hid/hid-picolcd_core.c

204

verinfo->raw_data[1], verinfo->raw_data[0]);

drivers/hid/hid-picolcd_core.c

329

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

drivers/hid/hid-picolcd_core.c

345

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

drivers/hid/hid-picolcd_core.c

347

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

drivers/hid/hid-picolcd_core.c

355

memcpy(data->pending->raw_data, raw_data+1, size-1);

drivers/hid/hid-picolcd_core.c

363

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

drivers/hid/hid-picolcd_core.c

69

int report_id, const u8 *raw_data, int size)

drivers/hid/hid-picolcd_core.c

95

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

drivers/hid/hid-picolcd_debugfs.c

102

if (copy_to_user(u, resp->raw_data+3, ret))

drivers/hid/hid-picolcd_debugfs.c

118

u8 raw_data[23];

drivers/hid/hid-picolcd_debugfs.c

125

memset(raw_data, 0, sizeof(raw_data));

drivers/hid/hid-picolcd_debugfs.c

126

raw_data[0] = *off & 0xff;

drivers/hid/hid-picolcd_debugfs.c

127

raw_data[1] = (*off >> 8) & 0xff;

drivers/hid/hid-picolcd_debugfs.c

128

raw_data[2] = min_t(size_t, 20, s);

drivers/hid/hid-picolcd_debugfs.c

129

if (*off + raw_data[2] > 0xff)

drivers/hid/hid-picolcd_debugfs.c

130

raw_data[2] = 0x100 - *off;

drivers/hid/hid-picolcd_debugfs.c

132

if (copy_from_user(raw_data+3, u, min((u8)20, raw_data[2])))

drivers/hid/hid-picolcd_debugfs.c

134

resp = picolcd_send_and_wait(data->hdev, REPORT_EE_WRITE, raw_data,

drivers/hid/hid-picolcd_debugfs.c

135

sizeof(raw_data));

drivers/hid/hid-picolcd_debugfs.c

142

if (memcmp(raw_data, resp->raw_data, 3+raw_data[2]) == 0) {

drivers/hid/hid-picolcd_debugfs.c

143

*off += raw_data[2];

drivers/hid/hid-picolcd_debugfs.c

144

ret = raw_data[2];

drivers/hid/hid-picolcd_debugfs.c

184

u8 raw_data[4];

drivers/hid/hid-picolcd_debugfs.c

190

len_off = _picolcd_flash_setaddr(data, raw_data, *off);

drivers/hid/hid-picolcd_debugfs.c

191

raw_data[len_off] = s > 32 ? 32 : s;

drivers/hid/hid-picolcd_debugfs.c

192

resp = picolcd_send_and_wait(data->hdev, report_id, raw_data, len_off+1);

drivers/hid/hid-picolcd_debugfs.c

197

if (memcmp(raw_data, resp->raw_data, len_off+1) != 0)

drivers/hid/hid-picolcd_debugfs.c

199

if (copy_to_user(u+ret, resp->raw_data+len_off+1, raw_data[len_off])) {

drivers/hid/hid-picolcd_debugfs.c

203

*off += raw_data[len_off];

drivers/hid/hid-picolcd_debugfs.c

204

s -= raw_data[len_off];

drivers/hid/hid-picolcd_debugfs.c

205

ret += raw_data[len_off];

drivers/hid/hid-picolcd_debugfs.c

239

u8 raw_data[3];

drivers/hid/hid-picolcd_debugfs.c

246

len_off = _picolcd_flash_setaddr(data, raw_data, *off);

drivers/hid/hid-picolcd_debugfs.c

247

resp = picolcd_send_and_wait(data->hdev, report_id, raw_data, len_off);

drivers/hid/hid-picolcd_debugfs.c

252

if (memcmp(raw_data, resp->raw_data, len_off) != 0)

drivers/hid/hid-picolcd_debugfs.c

266

u8 raw_data[36];

drivers/hid/hid-picolcd_debugfs.c

272

len_off = _picolcd_flash_setaddr(data, raw_data, *off);

drivers/hid/hid-picolcd_debugfs.c

273

raw_data[len_off] = s > 32 ? 32 : s;

drivers/hid/hid-picolcd_debugfs.c

274

if (copy_from_user(raw_data+len_off+1, u, raw_data[len_off])) {

drivers/hid/hid-picolcd_debugfs.c

278

resp = picolcd_send_and_wait(data->hdev, report_id, raw_data,

drivers/hid/hid-picolcd_debugfs.c

279

len_off+1+raw_data[len_off]);

drivers/hid/hid-picolcd_debugfs.c

284

if (memcmp(raw_data, resp->raw_data, len_off+1+raw_data[len_off]) != 0)

drivers/hid/hid-picolcd_debugfs.c

286

*off += raw_data[len_off];

drivers/hid/hid-picolcd_debugfs.c

287

s -= raw_data[len_off];

drivers/hid/hid-picolcd_debugfs.c

288

ret += raw_data[len_off];

drivers/hid/hid-picolcd_debugfs.c

388

u8 *raw_data;

drivers/hid/hid-picolcd_debugfs.c

401

raw_data = hid_alloc_report_buf(report, GFP_ATOMIC);

drivers/hid/hid-picolcd_debugfs.c

402

if (!raw_data) {

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

412

dump_buff_as_hex(buff, BUFF_SZ, raw_data, raw_size);

drivers/hid/hid-picolcd_debugfs.c

421

snprintf(buff, BUFF_SZ, "\tGPO state: 0x%02x\n", raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

429

snprintf(buff, BUFF_SZ, "\tBrightness: 0x%02x\n", raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

437

snprintf(buff, BUFF_SZ, "\tContrast: 0x%02x\n", raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

446

raw_data[2], raw_data[1], raw_data[2] << 8 | raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

476

raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

478

snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);

drivers/hid/hid-picolcd_debugfs.c

487

raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

489

snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);

drivers/hid/hid-picolcd_debugfs.c

491

if (raw_data[3] == 0) {

drivers/hid/hid-picolcd_debugfs.c

493

} else if (raw_data[3] + 4 <= raw_size) {

drivers/hid/hid-picolcd_debugfs.c

496

dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);

drivers/hid/hid-picolcd_debugfs.c

511

raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

515

raw_data[3], raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

531

raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

533

snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);

drivers/hid/hid-picolcd_debugfs.c

537

raw_data[3], raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

539

snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);

drivers/hid/hid-picolcd_debugfs.c

555

raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

557

snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);

drivers/hid/hid-picolcd_debugfs.c

559

if (raw_data[3] == 0) {

drivers/hid/hid-picolcd_debugfs.c

561

} else if (raw_data[3] + 4 <= raw_size) {

drivers/hid/hid-picolcd_debugfs.c

564

dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);

drivers/hid/hid-picolcd_debugfs.c

571

raw_data[3], raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

573

snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);

drivers/hid/hid-picolcd_debugfs.c

575

if (raw_data[4] == 0) {

drivers/hid/hid-picolcd_debugfs.c

577

} else if (raw_data[4] + 5 <= raw_size) {

drivers/hid/hid-picolcd_debugfs.c

580

dump_buff_as_hex(buff, BUFF_SZ, raw_data+5, raw_data[4]);

drivers/hid/hid-picolcd_debugfs.c

598

raw_data[1] | (raw_data[2] << 8),

drivers/hid/hid-picolcd_debugfs.c

599

raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

627

raw_data[1] | (raw_data[2] << 8),

drivers/hid/hid-picolcd_debugfs.c

628

raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

638

kfree(raw_data);

drivers/hid/hid-picolcd_debugfs.c

644

u8 *raw_data, int size)

drivers/hid/hid-picolcd_debugfs.c

663

if (raw_data[2] < ARRAY_SIZE(error_codes))

drivers/hid/hid-picolcd_debugfs.c

665

raw_data[2], error_codes[raw_data[2]], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

668

raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

676

if (raw_data[1] == 0)

drivers/hid/hid-picolcd_debugfs.c

678

else if (raw_data[2] == 0)

drivers/hid/hid-picolcd_debugfs.c

680

raw_data[1], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

683

raw_data[1], raw_data[1], raw_data[2], raw_data[2]);

drivers/hid/hid-picolcd_debugfs.c

691

if (raw_data[1] == 0) {

drivers/hid/hid-picolcd_debugfs.c

694

} else if (raw_data[1] + 1 <= size) {

drivers/hid/hid-picolcd_debugfs.c

696

raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

698

dump_buff_as_hex(buff, BUFF_SZ, raw_data+2, raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

702

raw_data[1]-1);

drivers/hid/hid-picolcd_debugfs.c

712

raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

714

snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);

drivers/hid/hid-picolcd_debugfs.c

716

if (raw_data[3] == 0) {

drivers/hid/hid-picolcd_debugfs.c

719

} else if (raw_data[3] + 4 <= size) {

drivers/hid/hid-picolcd_debugfs.c

722

dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);

drivers/hid/hid-picolcd_debugfs.c

737

raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

739

snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);

drivers/hid/hid-picolcd_debugfs.c

741

if (raw_data[3] == 0) {

drivers/hid/hid-picolcd_debugfs.c

743

} else if (raw_data[3] + 4 <= size) {

drivers/hid/hid-picolcd_debugfs.c

746

dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);

drivers/hid/hid-picolcd_debugfs.c

753

raw_data[3], raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

755

snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);

drivers/hid/hid-picolcd_debugfs.c

757

if (raw_data[4] == 0) {

drivers/hid/hid-picolcd_debugfs.c

759

} else if (raw_data[4] + 5 <= size) {

drivers/hid/hid-picolcd_debugfs.c

762

dump_buff_as_hex(buff, BUFF_SZ, raw_data+5, raw_data[4]);

drivers/hid/hid-picolcd_debugfs.c

777

raw_data[2], raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

78

u8 raw_data[3];

drivers/hid/hid-picolcd_debugfs.c

803

raw_data[1], raw_data[2], raw_data[3], raw_data[4]);

drivers/hid/hid-picolcd_debugfs.c

806

raw_data[5]);

drivers/hid/hid-picolcd_debugfs.c

814

(raw_data[2] << 8) | raw_data[1]);

drivers/hid/hid-picolcd_debugfs.c

817

(raw_data[4] << 8) | raw_data[3]);

drivers/hid/hid-picolcd_debugfs.c

825

raw_data[1], raw_data[2]);

drivers/hid/hid-picolcd_debugfs.c

87

raw_data[0] = *off & 0xff;

drivers/hid/hid-picolcd_debugfs.c

88

raw_data[1] = (*off >> 8) & 0xff;

drivers/hid/hid-picolcd_debugfs.c

89

raw_data[2] = s < 20 ? s : 20;

drivers/hid/hid-picolcd_debugfs.c

90

if (*off + raw_data[2] > 0xff)

drivers/hid/hid-picolcd_debugfs.c

91

raw_data[2] = 0x100 - *off;

drivers/hid/hid-picolcd_debugfs.c

92

resp = picolcd_send_and_wait(data->hdev, REPORT_EE_READ, raw_data,

drivers/hid/hid-picolcd_debugfs.c

93

sizeof(raw_data));

drivers/hid/hid-picolcd_debugfs.c

99

ret = resp->raw_data[2];

drivers/hid/hid-playstation.c

1557

int raw_data = (short)le16_to_cpu(ds_report->gyro[i]);

drivers/hid/hid-playstation.c

1559

raw_data, ds->gyro_calib_data[i].sens_denom);

drivers/hid/hid-playstation.c

1566

int raw_data = (short)le16_to_cpu(ds_report->accel[i]);

drivers/hid/hid-playstation.c

1568

raw_data - ds->accel_calib_data[i].bias,

drivers/hid/hid-playstation.c

2492

int raw_data = (short)le16_to_cpu(ds4_report->gyro[i]);

drivers/hid/hid-playstation.c

2494

raw_data, ds4->gyro_calib_data[i].sens_denom);

drivers/hid/hid-playstation.c

2501

int raw_data = (short)le16_to_cpu(ds4_report->accel[i]);

drivers/hid/hid-playstation.c

2503

raw_data - ds4->accel_calib_data[i].bias,

drivers/hid/hid-saitek.c

101

if (raw_data[1] & 0x01)

drivers/hid/hid-saitek.c

103

else if (raw_data[1] & 0x02)

drivers/hid/hid-saitek.c

105

else if (raw_data[1] & 0x04)

drivers/hid/hid-saitek.c

109

raw_data[1] &= ~0x07;

drivers/hid/hid-saitek.c

115

raw_data[1] |= 0x04;

drivers/hid/hid-saitek.c

123

if (raw_data[1] & 0x80)

drivers/hid/hid-saitek.c

125

else if (raw_data[2] & 0x01)

drivers/hid/hid-saitek.c

127

else if (raw_data[2] & 0x02)

drivers/hid/hid-saitek.c

131

raw_data[1] &= ~0x80;

drivers/hid/hid-saitek.c

132

raw_data[2] &= ~0x03;

drivers/hid/hid-saitek.c

141

raw_data[1] |= 0x80;

drivers/hid/hid-saitek.c

94

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

drivers/hid/hid-sensor-custom.c

418

char *raw_data, void *priv)

drivers/hid/hid-sensor-custom.c

450

kfifo_in(&sensor_inst->data_fifo, (unsigned char *)raw_data,

drivers/hid/hid-sensor-hub.c

312

hsdev->pending.raw_data = buffer;

drivers/hid/hid-sensor-hub.c

375

ret_val = *(s8 *)hsdev->pending.raw_data;

drivers/hid/hid-sensor-hub.c

377

ret_val = *(u8 *)hsdev->pending.raw_data;

drivers/hid/hid-sensor-hub.c

381

ret_val = *(s16 *)hsdev->pending.raw_data;

drivers/hid/hid-sensor-hub.c

383

ret_val = *(u16 *)hsdev->pending.raw_data;

drivers/hid/hid-sensor-hub.c

386

ret_val = *(u32 *)hsdev->pending.raw_data;

drivers/hid/hid-sensor-hub.c

391

kfree(hsdev->pending.raw_data);

drivers/hid/hid-sensor-hub.c

518

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

drivers/hid/hid-sensor-hub.c

538

ptr = raw_data;

drivers/hid/hid-sensor-hub.c

576

memcpy(hsdev->pending.raw_data + hsdev->pending.index,

drivers/hid/hid-sensor-hub.c

585

hsdev->pending.raw_data = kmemdup(ptr, sz, GFP_ATOMIC);

drivers/hid/hid-sensor-hub.c

586

if (hsdev->pending.raw_data)

drivers/hid/hid-wiimote-core.c

1623

u8 *raw_data, int size)

drivers/hid/hid-wiimote-core.c

1635

if (h->id == raw_data[0] && h->size < size) {

drivers/hid/hid-wiimote-core.c

1637

h->func(wdata, &raw_data[1]);

drivers/hid/hid-wiimote-core.c

1644

hid_warn(hdev, "Unhandled report %hhu size %d\n", raw_data[0],

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

447

rv = loader_xfer_cmd(dev, &query, sizeof(query), recv_msg.raw_data,

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

460

recv_msg.raw_data, sizeof(struct loader_xfer_fragment_ack));

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

464

rv = loader_xfer_cmd(dev, &start, sizeof(start), recv_msg.raw_data,

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

194

__u8 raw_data[LOADER_MSG_SIZE];

drivers/hid/wacom_sys.c

102

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

drivers/hid/wacom_sys.c

132

value = hid_field_extract(hdev, raw_data+1, offset + j * size, size);

drivers/hid/wacom_sys.c

164

raw_data, report_size);

drivers/hid/wacom_sys.c

170

u8 *raw_data, int size)

drivers/hid/wacom_sys.c

177

if (wacom_wac_pen_serial_enforce(hdev, report, raw_data, size))

drivers/hid/wacom_sys.c

180

wacom->wacom_wac.data = raw_data;

drivers/hid/wacom_sys.c

53

u8 *raw_data, int size)

drivers/hid/wacom_sys.c

65

if (!kfifo_in(fifo, raw_data, size))

drivers/hwmon/aht10.c

158

static int crc8_check(u8 *raw_data, int count)

drivers/hwmon/aht10.c

164

return crc8(crc8_table, raw_data, count, CRC8_INIT_VALUE);

drivers/hwmon/aht10.c

177

u8 raw_data[AHT20_MEAS_SIZE];

drivers/hwmon/aht10.c

189

res = i2c_master_recv(client, raw_data, data->meas_size);

drivers/hwmon/aht10.c

196

if (data->crc8 && crc8_check(raw_data, data->meas_size))

drivers/hwmon/aht10.c

199

hum = ((u32)raw_data[1] << 12u) |

drivers/hwmon/aht10.c

200

((u32)raw_data[2] << 4u) |

drivers/hwmon/aht10.c

201

((raw_data[3] & 0xF0u) >> 4u);

drivers/hwmon/aht10.c

203

temp = ((u32)(raw_data[3] & 0x0Fu) << 16u) |

drivers/hwmon/aht10.c

204

((u32)raw_data[4] << 8u) |

drivers/hwmon/aht10.c

205

raw_data[5];

drivers/hwmon/aspeed-pwm-tacho.c

530

u32 raw_data, tach_div, clk_source, msec, usec, val;

drivers/hwmon/aspeed-pwm-tacho.c

559

raw_data = val & RESULT_VALUE_MASK;

drivers/hwmon/aspeed-pwm-tacho.c

571

if (raw_data == 0)

drivers/hwmon/aspeed-pwm-tacho.c

574

return (clk_source * 60) / (2 * raw_data * tach_div);

drivers/hwmon/sht4x.c

118

ret = i2c_master_recv(client, raw_data, SHT4X_RESPONSE_LENGTH);

drivers/hwmon/sht4x.c

125

t_ticks = raw_data[0] << 8 | raw_data[1];

drivers/hwmon/sht4x.c

126

rh_ticks = raw_data[3] << 8 | raw_data[4];

drivers/hwmon/sht4x.c

128

crc = crc8(sht4x_crc8_table, &raw_data[0], SHT4X_WORD_LEN, CRC8_INIT_VALUE);

drivers/hwmon/sht4x.c

129

if (crc != raw_data[2]) {

drivers/hwmon/sht4x.c

134

crc = crc8(sht4x_crc8_table, &raw_data[3], SHT4X_WORD_LEN, CRC8_INIT_VALUE);

drivers/hwmon/sht4x.c

135

if (crc != raw_data[5]) {

drivers/hwmon/sht4x.c

94

u8 raw_data[SHT4X_RESPONSE_LENGTH];

drivers/iio/accel/hid-sensor-accel-3d.c

250

size_t raw_len, char *raw_data,

drivers/iio/accel/hid-sensor-accel-3d.c

264

*(u32 *)raw_data;

drivers/iio/accel/hid-sensor-accel-3d.c

271

*(int64_t *)raw_data);

drivers/iio/adc/ad4695.c

1017

xfers[0].rx_buf = &st->raw_data;

drivers/iio/adc/ad4695.c

1034

*val = sign_extend32(st->raw_data, realbits - 1);

drivers/iio/adc/ad4695.c

1036

*val = st->raw_data;

drivers/iio/adc/ad4695.c

164

u16 raw_data;

drivers/iio/chemical/ccs811.c

231

*val = be16_to_cpu(data->buffer.raw_data) & CCS811_VOLTAGE_MASK;

drivers/iio/chemical/ccs811.c

234

*val = be16_to_cpu(data->buffer.raw_data) >> 10;

drivers/iio/chemical/ccs811.c

72

__be16 raw_data;

drivers/iio/gyro/hid-sensor-gyro-3d.c

202

size_t raw_len, char *raw_data,

drivers/iio/gyro/hid-sensor-gyro-3d.c

216

*(u32 *)raw_data;

drivers/iio/gyro/hid-sensor-gyro-3d.c

222

*(s64 *)raw_data);

drivers/iio/humidity/hid-sensor-humidity.c

144

char *raw_data, void *pdev)

drivers/iio/humidity/hid-sensor-humidity.c

151

humid_st->scan.humidity_data = *(s32 *)raw_data;

drivers/iio/light/hid-sensor-als.c

266

size_t raw_len, char *raw_data,

drivers/iio/light/hid-sensor-als.c

272

u32 sample_data = *(u32 *)raw_data;

drivers/iio/light/hid-sensor-als.c

294

*(s64 *)raw_data);

drivers/iio/light/hid-sensor-prox.c

186

size_t raw_len, char *raw_data,

drivers/iio/light/hid-sensor-prox.c

205

prox_state->human_presence[chan] = *(u8 *)raw_data * multiplier;

drivers/iio/light/hid-sensor-prox.c

208

prox_state->human_presence[chan] = *(u16 *)raw_data * multiplier;

drivers/iio/light/hid-sensor-prox.c

211

prox_state->human_presence[chan] = *(u32 *)raw_data * multiplier;

drivers/iio/light/rpr0521.c

708

__le16 raw_data;

drivers/iio/light/rpr0521.c

720

&raw_data, sizeof(raw_data));

drivers/iio/light/rpr0521.c

730

*val = le16_to_cpu(raw_data);

drivers/iio/light/vcnl4035.c

163

int raw_data;

drivers/iio/light/vcnl4035.c

173

ret = regmap_read(data->regmap, reg, &raw_data);

drivers/iio/light/vcnl4035.c

178

*val = raw_data;

drivers/iio/magnetometer/hid-sensor-magn-3d.c

295

size_t raw_len, char *raw_data,

drivers/iio/magnetometer/hid-sensor-magn-3d.c

321

*(s64 *)raw_data);

drivers/iio/magnetometer/hid-sensor-magn-3d.c

330

*iio_val = *((u32 *)raw_data);

drivers/iio/orientation/hid-sensor-incl-3d.c

215

size_t raw_len, char *raw_data,

drivers/iio/orientation/hid-sensor-incl-3d.c

224

incl_state->scan.incl_val[CHANNEL_SCAN_INDEX_X] = *(u32 *)raw_data;

drivers/iio/orientation/hid-sensor-incl-3d.c

227

incl_state->scan.incl_val[CHANNEL_SCAN_INDEX_Y] = *(u32 *)raw_data;

drivers/iio/orientation/hid-sensor-incl-3d.c

230

incl_state->scan.incl_val[CHANNEL_SCAN_INDEX_Z] = *(u32 *)raw_data;

drivers/iio/orientation/hid-sensor-incl-3d.c

235

*(s64 *)raw_data);

drivers/iio/orientation/hid-sensor-rotation.c

248

size_t raw_len, char *raw_data,

drivers/iio/orientation/hid-sensor-rotation.c

256

rot_state->scan.sampled_vals[0] = ((s16 *)raw_data)[0];

drivers/iio/orientation/hid-sensor-rotation.c

257

rot_state->scan.sampled_vals[1] = ((s16 *)raw_data)[1];

drivers/iio/orientation/hid-sensor-rotation.c

258

rot_state->scan.sampled_vals[2] = ((s16 *)raw_data)[2];

drivers/iio/orientation/hid-sensor-rotation.c

259

rot_state->scan.sampled_vals[3] = ((s16 *)raw_data)[3];

drivers/iio/orientation/hid-sensor-rotation.c

261

memcpy(&rot_state->scan.sampled_vals, raw_data,

drivers/iio/orientation/hid-sensor-rotation.c

269

*(s64 *)raw_data);

drivers/iio/position/hid-sensor-custom-intel-hinge.c

212

char *raw_data, void *priv)

drivers/iio/position/hid-sensor-custom-intel-hinge.c

223

st->scan.hinge_val[offset] = *(u32 *)raw_data;

drivers/iio/position/hid-sensor-custom-intel-hinge.c

227

*(int64_t *)raw_data);

drivers/iio/pressure/hid-sensor-press.c

179

size_t raw_len, char *raw_data,

drivers/iio/pressure/hid-sensor-press.c

188

press_state->scan.press_data = *(u32 *)raw_data;

drivers/iio/pressure/hid-sensor-press.c

193

&press_state->common_attributes, *(s64 *)raw_data);

drivers/iio/temperature/hid-sensor-temperature.c

143

char *raw_data, void *pdev)

drivers/iio/temperature/hid-sensor-temperature.c

150

temp_st->scan.temperature_data = *(s32 *)raw_data;

drivers/infiniband/hw/hfi1/mad.h

58

} raw_data;

drivers/input/joystick/grip_mp.c

166

u8 raw_data; /* raw data from gameport */

drivers/input/joystick/grip_mp.c

176

raw_data = gameport_read(gameport);

drivers/input/joystick/grip_mp.c

177

if (raw_data & 1)

drivers/input/joystick/grip_mp.c

181

raw_data = gameport_read(gameport);

drivers/input/joystick/grip_mp.c

182

portvals |= 1 << ((raw_data >> 4) & 3); /* Demux B4, B5 */

drivers/input/joystick/grip_mp.c

186

raw_data = gameport_read(gameport);

drivers/input/joystick/grip_mp.c

187

portvals = raw_data & 0xf0;

drivers/input/joystick/grip_mp.c

189

if (raw_data & 0x31)

drivers/input/joystick/grip_mp.c

193

if (!poll_until(0x10, 0, 308, gameport, &raw_data))

drivers/input/joystick/grip_mp.c

200

if (raw_data & 0x20) { /* 3 data bits/read */

drivers/input/joystick/grip_mp.c

201

portvals |= raw_data >> 4; /* Compare B4-B7 before & after trigger */

drivers/input/joystick/grip_mp.c

217

if (!poll_until(0, 0x10, 77, gameport, &raw_data))

drivers/input/joystick/grip_mp.c

219

raw_data = (raw_data >> 5) & data_mask;

drivers/input/joystick/grip_mp.c

223

pkt = (pkt << bits_per_read) | raw_data;

drivers/input/joystick/grip_mp.c

225

if (!poll_until(0x10, 0, 77, gameport, &raw_data))

drivers/input/joystick/grip_mp.c

229

if (raw_data)

drivers/input/joystick/grip_mp.c

244

if (!poll_until(0x30, 0, 77, gameport, &raw_data))

drivers/input/joystick/grip_mp.c

247

raw_data = gameport_read(gameport);

drivers/input/joystick/grip_mp.c

249

if (raw_data & 1)

drivers/input/joystick/grip_mp.c

254

if (!poll_until(0, 0x20, 77, gameport, &raw_data))

drivers/input/joystick/grip_mp.c

268

if (!poll_until(0x20, 0, 77, gameport, &raw_data))

drivers/input/joystick/grip_mp.c

271

raw_data = gameport_read(gameport);

drivers/input/joystick/grip_mp.c

272

if (raw_data & 1)

drivers/input/joystick/grip_mp.c

279

if (!poll_until(0x20, 0x10, 116, gameport, &raw_data))

drivers/input/joystick/grip_mp.c

282

if (!poll_until(0x30, 0, 193, gameport, &raw_data))

drivers/input/joystick/grip_mp.c

285

if (raw_data & 1)

drivers/media/usb/as102/as10x_cmd.h

456

union as10x_raw_data raw_data;

drivers/media/v4l2-core/v4l2-compat-ioctl32.c

104

__u8 raw_data[200]; /* user-defined */

drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h

3967

u32 raw_data[4];

drivers/net/ethernet/broadcom/bnx2x/bnx2x_init.h

51

u32 raw_data;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

13340

target[i].raw_data = be32_to_cpu(source[j + 1]);

drivers/net/ethernet/qlogic/qed/qed_hsi.h

5895

struct regpair raw_data;

drivers/net/ethernet/qlogic/qed/qed_mcp.c

4156

u8 raw_data[QED_MCP_DBG_DATA_MAX_SIZE], *p_tmp_buf = p_buf;

drivers/net/ethernet/qlogic/qed/qed_mcp.c

4162

p_header = (u32 *)raw_data;

drivers/net/ethernet/qlogic/qed/qed_mcp.c

4163

p_payload = (u32 *)(raw_data + QED_MCP_DBG_DATA_MAX_HEADER_SIZE);

drivers/net/ethernet/qlogic/qed/qed_mcp.c

4178

rc = __qed_mcp_send_debug_data(p_hwfn, p_ptt, raw_data,

drivers/net/ethernet/qlogic/qed/qed_mcp.c

4200

return __qed_mcp_send_debug_data(p_hwfn, p_ptt, raw_data,

drivers/net/ethernet/qlogic/qed/qed_mcp.c

698

u8 raw_data[MCP_DRV_NVM_BUF_LEN];

drivers/net/ethernet/qlogic/qed/qed_mcp.c

704

mb_params.p_data_dst = raw_data;

drivers/net/ethernet/qlogic/qed/qed_mcp.c

719

memcpy(o_buf, raw_data, *o_txn_size);

drivers/net/ethernet/qlogic/qed/qed_mfw_hsi.h

1074

u8 raw_data[MCP_DRV_NVM_BUF_LEN];

drivers/net/wireless/realtek/rtw89/fw.c

2183

u32 fmt_idx, u8 para_int, bool raw_data)

drivers/net/wireless/realtek/rtw89/fw.c

2200

if (raw_data) {

drivers/nvme/common/keyring.c

60

if (!match_data->raw_data) {

drivers/nvme/common/keyring.c

64

match_id = match_data->raw_data;

drivers/platform/chrome/wilco_ec/debugfs.c

123

memset(debug_info->raw_data, 0, sizeof(debug_info->raw_data));

drivers/platform/chrome/wilco_ec/debugfs.c

124

msg.response_data = debug_info->raw_data;

drivers/platform/chrome/wilco_ec/debugfs.c

141

fmt_len = hex_dump_to_buffer(debug_info->raw_data,

drivers/platform/chrome/wilco_ec/debugfs.c

26

u8 raw_data[EC_MAILBOX_DATA_SIZE];

drivers/platform/x86/dell/dell-wmi-ddv.c

105

u8 raw_data[];

drivers/platform/x86/dell/dell-wmi-ddv.c

215

buffer_size = struct_size(buffer, raw_data, le32_to_cpu(buffer->raw_size));

drivers/platform/x86/dell/dell-wmi-ddv.c

284

if (rem != 1 || buffer->raw_data[buffer_size - 1] != 0xff) {

drivers/platform/x86/dell/dell-wmi-ddv.c

326

entry = (struct fan_sensor_entry *)data->fans.buffer->raw_data;

drivers/platform/x86/dell/dell-wmi-ddv.c

352

entry = (struct thermal_sensor_entry *)data->temps.buffer->raw_data;

drivers/platform/x86/dell/dell-wmi-ddv.c

409

entry = (struct fan_sensor_entry *)data->fans.buffer->raw_data;

drivers/platform/x86/dell/dell-wmi-ddv.c

440

entry = (struct thermal_sensor_entry *)data->temps.buffer->raw_data;

drivers/platform/x86/dell/dell-wmi-ddv.c

999

ret = seq_write(seq, buffer->raw_data, le32_to_cpu(buffer->raw_size));

drivers/rtc/rtc-hid-sensor-time.c

101

time_buf->tm_mon = (int)hid_time_value(raw_len, raw_data)-1;

drivers/rtc/rtc-hid-sensor-time.c

104

time_buf->tm_mday = (int)hid_time_value(raw_len, raw_data);

drivers/rtc/rtc-hid-sensor-time.c

107

time_buf->tm_hour = (int)hid_time_value(raw_len, raw_data);

drivers/rtc/rtc-hid-sensor-time.c

110

time_buf->tm_min = (int)hid_time_value(raw_len, raw_data);

drivers/rtc/rtc-hid-sensor-time.c

113

time_buf->tm_sec = (int)hid_time_value(raw_len, raw_data);

drivers/rtc/rtc-hid-sensor-time.c

62

static u32 hid_time_value(size_t raw_len, char *raw_data)

drivers/rtc/rtc-hid-sensor-time.c

66

return *(u8 *)raw_data;

drivers/rtc/rtc-hid-sensor-time.c

68

return *(u16 *)raw_data;

drivers/rtc/rtc-hid-sensor-time.c

70

return *(u32 *)raw_data;

drivers/rtc/rtc-hid-sensor-time.c

78

char *raw_data, void *priv)

drivers/rtc/rtc-hid-sensor-time.c

91

time_buf->tm_year = *(u8 *)raw_data;

drivers/rtc/rtc-hid-sensor-time.c

97

(int)hid_time_value(raw_len, raw_data)-1900;

drivers/scsi/esas2r/atvda.h

513

u8 raw_data[6];

drivers/staging/greybus/raw.c

237

struct raw_data *raw_data;

drivers/staging/greybus/raw.c

238

struct raw_data *temp;

drivers/staging/greybus/raw.c

250

list_for_each_entry_safe(raw_data, temp, &raw->list, entry) {

drivers/staging/greybus/raw.c

251

list_del(&raw_data->entry);

drivers/staging/greybus/raw.c

252

kfree(raw_data);

drivers/staging/greybus/raw.c

311

struct raw_data *raw_data;

drivers/staging/greybus/raw.c

317

raw_data = list_first_entry(&raw->list, struct raw_data, entry);

drivers/staging/greybus/raw.c

318

if (raw_data->len > count) {

drivers/staging/greybus/raw.c

323

if (copy_to_user(buf, &raw_data->data[0], raw_data->len)) {

drivers/staging/greybus/raw.c

328

list_del(&raw_data->entry);

drivers/staging/greybus/raw.c

329

raw->list_data -= raw_data->len;

drivers/staging/greybus/raw.c

330

retval = raw_data->len;

drivers/staging/greybus/raw.c

331

kfree(raw_data);

drivers/staging/greybus/raw.c

61

struct raw_data *raw_data;

drivers/staging/greybus/raw.c

77

raw_data = kmalloc_flex(*raw_data, data, len);

drivers/staging/greybus/raw.c

78

if (!raw_data) {

drivers/staging/greybus/raw.c

84

raw_data->len = len;

drivers/staging/greybus/raw.c

85

memcpy(&raw_data->data[0], data, len);

drivers/staging/greybus/raw.c

87

list_add_tail(&raw_data->entry, &raw->list);

drivers/tty/ipwireless/hardware.c

426

__le16 raw_data;

drivers/tty/ipwireless/hardware.c

430

raw_data = cpu_to_le16(d);

drivers/tty/ipwireless/hardware.c

431

outw(raw_data, hw->base_port + IODWR);

drivers/tty/ipwireless/hardware.c

440

__le16 raw_data;

drivers/tty/ipwireless/hardware.c

444

raw_data = cpu_to_le16(d);

drivers/tty/ipwireless/hardware.c

445

outw(raw_data, hw->base_port);

drivers/tty/ipwireless/hardware.c

872

__le16 raw_data = inw(hw->base_port + IODRR);

drivers/tty/ipwireless/hardware.c

873

unsigned short data = le16_to_cpu(raw_data);

drivers/tty/ipwireless/hardware.c

889

__le16 raw_data = inw(hw->base_port);

drivers/tty/ipwireless/hardware.c

890

unsigned short data = le16_to_cpu(raw_data);

fs/nfsd/nfs4proc.c

1715

char *ipaddr, *dev_name, *raw_data;

fs/nfsd/nfs4proc.c

1751

raw_data = kzalloc(raw_len, GFP_KERNEL);

fs/nfsd/nfs4proc.c

1752

if (!raw_data)

fs/nfsd/nfs4proc.c

1755

snprintf(raw_data, raw_len, NFSD42_INTERSSC_MOUNTOPS, ipaddr);

fs/nfsd/nfs4proc.c

1775

ss_mnt = vfs_kern_mount(type, SB_KERNMOUNT, dev_name, raw_data);

fs/nfsd/nfs4proc.c

1789

kfree(raw_data);

include/linux/hid-sensor-hub.h

55

u8 *raw_data;

include/linux/hid-sensor-hub.h

96

u32 usage_id, size_t raw_len, char *raw_data,

include/linux/key-type.h

54

const void *raw_data; /* Raw match data */

include/linux/trace_events.h

944

void perf_trace_run_bpf_submit(void *raw_data, int size, int rctx,

include/linux/trace_events.h

950

perf_trace_buf_submit(void *raw_data, int size, int rctx, u16 type,

include/linux/trace_events.h

954

perf_tp_event(type, count, raw_data, size, regs, head, rctx, task);

include/rdma/ib_mad.h

387

} raw_data;

include/uapi/linux/videodev2.h

1785

__u32 raw_data[32];

include/uapi/linux/videodev2.h

2531

__u8 raw_data[200]; /* user-defined */

include/uapi/linux/videodev2.h

2542

__u8 raw_data[200]; /* user-defined */

kernel/events/core.c

11391

void perf_trace_run_bpf_submit(void *raw_data, int size, int rctx,

kernel/events/core.c

11397

*(struct pt_regs **)raw_data = regs;

kernel/events/core.c

11398

if (!trace_call_bpf(call, raw_data) || hlist_empty(head)) {

kernel/events/core.c

11403

perf_tp_event(call->event.type, count, raw_data, size, regs, head,

kernel/trace/trace_entries.h

285

FTRACE_ENTRY(raw_data, raw_data_entry,

kernel/trace/trace_event_perf.c

400

char *raw_data;

kernel/trace/trace_event_perf.c

416

raw_data = this_cpu_ptr(perf_trace_buf[rctx]);

kernel/trace/trace_event_perf.c

419

memset(&raw_data[size - sizeof(u64)], 0, sizeof(u64));

kernel/trace/trace_event_perf.c

420

return raw_data;

net/dns_resolver/dns_key.c

241

const char *src = key->description, *dsp = match_data->raw_data;

security/keys/keyring.c

1205

if (key != ctx->match_data.raw_data)

security/keys/keyring.c

1223

.match_data.raw_data = A,

security/keys/keyring.c

570

return strcmp(key->description, match_data->raw_data) == 0;

security/keys/keyring.c

953

.match_data.raw_data = description,

security/keys/proc.c

169

.match_data.raw_data = key,

security/keys/process_keys.c

196

.match_data.raw_data = buf,

security/keys/process_keys.c

590

return key == match_data->raw_data;

security/keys/process_keys.c

759

ctx.match_data.raw_data = key;

security/keys/request_key.c

590

.match_data.raw_data = description,

security/keys/request_key.c

793

.match_data.raw_data = description,

security/keys/request_key_auth.c

283

.match_data.raw_data = description,

sound/usb/format.c

516

__le64 raw_data = 0;

sound/usb/format.c

527

iface, &raw_data, sizeof(raw_data));

sound/usb/format.c

531

data = le64_to_cpu(raw_data);

tools/lib/bpf/bpf_gen_internal.h

60

void bpf_gen__load_btf(struct bpf_gen *gen, const void *raw_data, __u32 raw_size);

tools/lib/bpf/btf.c

1181

munmap(btf->raw_data, btf->raw_size);

tools/lib/bpf/btf.c

1184

free(btf->raw_data);

tools/lib/bpf/btf.c

1186

btf->raw_data = NULL;

tools/lib/bpf/btf.c

1246

btf->raw_data = calloc(1, btf->raw_size);

tools/lib/bpf/btf.c

1247

if (!btf->raw_data) {

tools/lib/bpf/btf.c

1252

hdr = btf->raw_data;

tools/lib/bpf/btf.c

1257

btf->types_data = btf->raw_data + hdr->hdr_len;

tools/lib/bpf/btf.c

1258

btf->strs_data = btf->raw_data + hdr->hdr_len;

tools/lib/bpf/btf.c

1268

memcpy(btf->raw_data + hdr->hdr_len, layouts, sizeof(layouts));

tools/lib/bpf/btf.c

1322

btf->raw_data = (void *)data;

tools/lib/bpf/btf.c

1325

btf->raw_data = malloc(size);

tools/lib/bpf/btf.c

1326

if (!btf->raw_data) {

tools/lib/bpf/btf.c

1330

memcpy(btf->raw_data, data, size);

tools/lib/bpf/btf.c

1339

btf->strs_data = btf->raw_data + btf->hdr.hdr_len + btf->hdr.str_off;

tools/lib/bpf/btf.c

1340

btf->types_data = btf->raw_data + btf->hdr.hdr_len + btf->hdr.type_off;

tools/lib/bpf/btf.c

1699

void *raw_data;

tools/lib/bpf/btf.c

1708

raw_data = btf_get_raw_data(btf, &raw_size, false);

tools/lib/bpf/btf.c

1709

if (!raw_data) {

tools/lib/bpf/btf.c

1714

btf->raw_data = raw_data;

tools/lib/bpf/btf.c

1748

btf->fd = bpf_btf_load(raw_data, raw_size, &opts);

tools/lib/bpf/btf.c

1801

data = swap_endian ? btf->raw_data_swapped : btf->raw_data;

tools/lib/bpf/btf.c

1870

btf->raw_data = data;

tools/lib/bpf/btf.c

1980

if (btf->raw_data)

tools/lib/bpf/btf.c

2020

memcpy(layout, btf->raw_data + btf->hdr.hdr_len + btf->hdr.layout_off,

tools/lib/bpf/btf.c

288

struct btf_header *hdr = btf->raw_data;

tools/lib/bpf/btf.c

407

btf->layout = btf->raw_data + btf->hdr.hdr_len + btf->hdr.layout_off;

tools/lib/bpf/btf.c

64

void *raw_data;

tools/lib/bpf/libbpf.c

3167

const void *raw_data;

tools/lib/bpf/libbpf.c

3174

raw_data = btf__raw_data(orig_btf, &sz);

tools/lib/bpf/libbpf.c

3175

if (!raw_data)

tools/lib/bpf/libbpf.c

3182

const struct btf_header *old_hdr = raw_data;

tools/lib/bpf/libbpf.c

3195

memcpy(new_raw_data, raw_data, sz);

tools/lib/bpf/libbpf.c

3213

btf = btf__new(raw_data, sz);

tools/lib/bpf/libbpf.c

3673

const void *raw_data = btf__raw_data(kern_btf, &raw_size);

tools/lib/bpf/libbpf.c

3675

if (!raw_data)

tools/lib/bpf/libbpf.c

3677

bpf_gen__load_btf(obj->gen_loader, raw_data, raw_size);

tools/lib/bpf/linker.c

122

void *raw_data;

tools/lib/bpf/linker.c

1236

if (memcmp(dst_sec->raw_data, src_sec->data->d_buf, dst_sec->sec_sz) != 0)

tools/lib/bpf/linker.c

1249

static void exec_sec_bswap(void *raw_data, int size)

tools/lib/bpf/linker.c

1252

struct bpf_insn *insn = raw_data;

tools/lib/bpf/linker.c

1297

tmp = realloc(dst->raw_data, dst_final_sz);

tools/lib/bpf/linker.c

1312

dst->raw_data = tmp;

tools/lib/bpf/linker.c

1315

memset(dst->raw_data + dst->sec_sz, 0, dst_align_sz - dst->sec_sz);

tools/lib/bpf/linker.c

1317

memcpy(dst->raw_data + dst_align_sz, src->data->d_buf, src->shdr->sh_size);

tools/lib/bpf/linker.c

1321

exec_sec_bswap(dst->raw_data + dst_align_sz, src->shdr->sh_size);

tools/lib/bpf/linker.c

1441

Elf64_Sym *syms = symtab->raw_data;

tools/lib/bpf/linker.c

214

free(sec->raw_data);

tools/lib/bpf/linker.c

2244

dst_rel = dst_sec->raw_data + src_sec->dst_off;

tools/lib/bpf/linker.c

2272

insn = dst_linked_sec->raw_data + dst_rel->r_offset;

tools/lib/bpf/linker.c

2791

exec_sec_bswap(sec->raw_data, sec->sec_sz);

tools/lib/bpf/linker.c

2793

sec->data->d_buf = sec->raw_data;

tools/lib/bpf/linker.c

2821

size_t align, const void *raw_data, size_t raw_sz)

tools/lib/bpf/linker.c

2853

data->d_buf = (void *)raw_data;

tools/lib/bpf/linker.c

2865

const void *raw_data;

tools/lib/bpf/linker.c

2915

raw_data = btf__raw_data(linker->btf, &raw_sz);

tools/lib/bpf/linker.c

2916

if (!raw_data)

tools/lib/bpf/linker.c

2919

err = emit_elf_data_sec(linker, BTF_ELF_SEC, 8, raw_data, raw_sz);

tools/lib/bpf/linker.c

2927

raw_data = btf_ext__raw_data(linker->btf_ext, &raw_sz);

tools/lib/bpf/linker.c

2928

if (!raw_data)

tools/lib/bpf/linker.c

2931

err = emit_elf_data_sec(linker, BTF_EXT_ELF_SEC, 8, raw_data, raw_sz);

tools/lib/bpf/linker.c

341

syms = libbpf_reallocarray(symtab->raw_data, sym_cnt + 1, sizeof(*sym));

tools/lib/bpf/linker.c

348

symtab->raw_data = syms;

tools/perf/builtin-kmem.c

759

.data = sample->raw_data,

tools/perf/builtin-script.c

1822

int printed = binary__fprintf(sample->raw_data, nr_bytes, 8,

tools/perf/builtin-script.c

1826

printed += fprintf(fp, "%17s \"%s\"\n", "BPF string:", (char *)(sample->raw_data));

tools/perf/builtin-script.c

2019

struct powerpc_vpadtl_entry *dtl = (struct powerpc_vpadtl_entry *)data->raw_data;

tools/perf/builtin-script.c

2471

if (PRINT_FIELD(TRACE) && sample->raw_data) {

tools/perf/builtin-script.c

2476

sample->raw_data, sample->raw_size,

tools/perf/builtin-trace.c

275

memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \

tools/perf/builtin-trace.c

2790

memcpy(argbuf, sample->raw_data + args_size, *augmented_args_size);

tools/perf/builtin-trace.c

288

memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \

tools/perf/builtin-trace.c

3205

binary__fprintf(sample->raw_data, sample->raw_size, 8,

tools/perf/builtin-trace.c

3251

val = (uintptr_t)(sample->raw_data + offset);

tools/perf/builtin-trace.c

327

return sample->raw_data + field->offset;

tools/perf/builtin-trace.c

3370

sample->raw_data, sample->raw_size,

tools/perf/builtin-trace.c

3695

sample->raw_data == NULL) {

tools/perf/dlfilters/dlfilter-test-api-v0.c

217

CHECK(!sample->raw_data);

tools/perf/dlfilters/dlfilter-test-api-v0.c

64

const void *raw_data; /* Refer PERF_SAMPLE_RAW in <linux/perf_event.h> */

tools/perf/dlfilters/dlfilter-test-api-v2.c

232

CHECK(!sample->raw_data);

tools/perf/dlfilters/dlfilter-test-api-v2.c

70

const void *raw_data; /* Refer PERF_SAMPLE_RAW in <linux/perf_event.h> */

tools/perf/include/perf/perf_dlfilter.h

65

const void *raw_data; /* Refer PERF_SAMPLE_RAW in <linux/perf_event.h> */

tools/perf/tests/sample-parsing.c

109

if (memcmp(s1->raw_data, s2->raw_data, s1->raw_size)) {

tools/perf/tests/sample-parsing.c

233

const u32 raw_data[] = {0x12345678, 0x0a0b0c0d, 0x11020304, 0x05060708, 0 };

tools/perf/tests/sample-parsing.c

257

.raw_size = sizeof(raw_data),

tools/perf/tests/sample-parsing.c

260

.raw_data = (void *)raw_data,

tools/perf/util/amd-sample-raw.c

300

struct perf_ibs_data *data = sample->raw_data;

tools/perf/util/amd-sample-raw.c

335

struct perf_ibs_data *data = sample->raw_data;

tools/perf/util/amd-sample-raw.c

352

struct perf_ibs_data *data = sample->raw_data;

tools/perf/util/amd-sample-raw.c

363

struct perf_ibs_data *data = sample->raw_data;

tools/perf/util/bpf_off_cpu.c

387

void *raw_data = (void *)data.array + n * sizeof(u64);

tools/perf/util/bpf_off_cpu.c

406

memcpy(raw_data, &raw_size, sizeof(raw_size));

tools/perf/util/bpf_off_cpu.c

407

memcpy(raw_data + sizeof(u32), off_cpu_raw, i * sizeof(u64));

tools/perf/util/data-convert-bt.c

309

void *data = sample->raw_data;

tools/perf/util/data-convert-bt.c

503

((u32 *)(sample->raw_data))[i]);

tools/perf/util/data-convert-json.c

248

if (sample->raw_data) {

tools/perf/util/data-convert-json.c

259

tep_print_field(&s, sample->raw_data, fields[i]);

tools/perf/util/dlfilter.c

542

ASSIGN(raw_data);

tools/perf/util/evsel.c

3364

u64 *array = data->raw_data;

tools/perf/util/evsel.c

3611

data->raw_data = (void *)array;

tools/perf/util/evsel.c

3911

dynamic_data = *(int *)(sample->raw_data + field->offset);

tools/perf/util/evsel.c

3933

return sample->raw_data + offset;

tools/perf/util/evsel.c

3940

void *ptr = sample->raw_data + field->offset;

tools/perf/util/hist.c

1244

.raw_data = sample->raw_data,

tools/perf/util/hist.c

1494

zfree(&he->raw_data);

tools/perf/util/hist.c

573

if (he->raw_data) {

tools/perf/util/hist.c

574

he->raw_data = memdup(he->raw_data, he->raw_size);

tools/perf/util/hist.c

575

if (he->raw_data == NULL)

tools/perf/util/hist.c

606

zfree(&he->raw_data);

tools/perf/util/hist.c

844

.raw_data = sample->raw_data,

tools/perf/util/hist.h

301

void *raw_data;