/srv/pokybuild/yocto-worker/reproducible/build/build-st/tmp/work/x86_64-linux/diffoscope-native/208-r0/recipe-sysroot-native/usr/bin/diffoscope.real --no-default-limits --max-report-size 262144000 --exclude-directory-metadata yes --html-dir /srv/autobuilder/valkyrie.yocto.io/pub/repro-fail/oe-reproducible-20250308-s52sakkc/packages/diff-html reproducibleA reproducibleB

249

static·inline·void·_nocheck__trace_parallel_ioport_read(const·char·*·desc,·uint16_t·addr,·uint8_t·value)

249

static·inline·void·_nocheck__trace_parallel_ioport_read(const·char·*·desc,·uint16_t·addr,·uint8_t·value)

250

{

250

{

251

····if·(trace_event_get_state(TRACE_PARALLEL_IOPORT_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

251

····if·(trace_event_get_state(TRACE_PARALLEL_IOPORT_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

252

········if·(message_with_timestamp)·{

252

········if·(message_with_timestamp)·{

253

············struct·timeval·_now;

253

············struct·timeval·_now;

254

············gettimeofday(&_now,·NULL);

254

············gettimeofday(&_now,·NULL);

256

············qemu_log("%d@%zu.%06zu:parallel_ioport_read·"·"read·[%s]·addr·0x%02x·val·0x%02x"·"\n",

256

············qemu_log("%d@%zu.%06zu:parallel_ioport_read·"·"read·[%s]·addr·0x%02x·val·0x%02x"·"\n",

257

·····················qemu_get_thread_id(),

257

·····················qemu_get_thread_id(),

258

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

258

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

259

·····················,·desc,·addr,·value);

259

·····················,·desc,·addr,·value);

260

#line·262·"trace/trace-hw_char.h"

260

#line·262·"trace/trace-hw_char.h"

261

········}·else·{

261

········}·else·{

263

············qemu_log("parallel_ioport_read·"·"read·[%s]·addr·0x%02x·val·0x%02x"·"\n",·desc,·addr,·value);

263

············qemu_log("parallel_ioport_read·"·"read·[%s]·addr·0x%02x·val·0x%02x"·"\n",·desc,·addr,·value);

264

#line·266·"trace/trace-hw_char.h"

264

#line·266·"trace/trace-hw_char.h"

265

········}

265

········}

266

····}

266

····}

267

}

267

}

268

static·inline·void·trace_parallel_ioport_read(const·char·*·desc,·uint16_t·addr,·uint8_t·value)

268

static·inline·void·trace_parallel_ioport_read(const·char·*·desc,·uint16_t·addr,·uint8_t·value)

280

static·inline·void·_nocheck__trace_parallel_ioport_write(const·char·*·desc,·uint16_t·addr,·uint8_t·value)

280

static·inline·void·_nocheck__trace_parallel_ioport_write(const·char·*·desc,·uint16_t·addr,·uint8_t·value)

281

{

281

{

282

····if·(trace_event_get_state(TRACE_PARALLEL_IOPORT_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

282

····if·(trace_event_get_state(TRACE_PARALLEL_IOPORT_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

283

········if·(message_with_timestamp)·{

283

········if·(message_with_timestamp)·{

284

············struct·timeval·_now;

284

············struct·timeval·_now;

285

············gettimeofday(&_now,·NULL);

285

············gettimeofday(&_now,·NULL);

287

············qemu_log("%d@%zu.%06zu:parallel_ioport_write·"·"write·[%s]·addr·0x%02x·val·0x%02x"·"\n",

287

············qemu_log("%d@%zu.%06zu:parallel_ioport_write·"·"write·[%s]·addr·0x%02x·val·0x%02x"·"\n",

288

·····················qemu_get_thread_id(),

288

·····················qemu_get_thread_id(),

289

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

289

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

290

·····················,·desc,·addr,·value);

290

·····················,·desc,·addr,·value);

291

#line·293·"trace/trace-hw_char.h"

291

#line·293·"trace/trace-hw_char.h"

292

········}·else·{

292

········}·else·{

294

············qemu_log("parallel_ioport_write·"·"write·[%s]·addr·0x%02x·val·0x%02x"·"\n",·desc,·addr,·value);

294

············qemu_log("parallel_ioport_write·"·"write·[%s]·addr·0x%02x·val·0x%02x"·"\n",·desc,·addr,·value);

295

#line·297·"trace/trace-hw_char.h"

295

#line·297·"trace/trace-hw_char.h"

296

········}

296

········}

297

····}

297

····}

298

}

298

}

299

static·inline·void·trace_parallel_ioport_write(const·char·*·desc,·uint16_t·addr,·uint8_t·value)

299

static·inline·void·trace_parallel_ioport_write(const·char·*·desc,·uint16_t·addr,·uint8_t·value)

311

static·inline·void·_nocheck__trace_serial_read(uint16_t·addr,·uint8_t·value)

311

static·inline·void·_nocheck__trace_serial_read(uint16_t·addr,·uint8_t·value)

312

{

312

{

313

····if·(trace_event_get_state(TRACE_SERIAL_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

313

····if·(trace_event_get_state(TRACE_SERIAL_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

314

········if·(message_with_timestamp)·{

314

········if·(message_with_timestamp)·{

315

············struct·timeval·_now;

315

············struct·timeval·_now;

316

············gettimeofday(&_now,·NULL);

316

············gettimeofday(&_now,·NULL);

318

············qemu_log("%d@%zu.%06zu:serial_read·"·"read·addr·0x%02x·val·0x%02x"·"\n",

318

············qemu_log("%d@%zu.%06zu:serial_read·"·"read·addr·0x%02x·val·0x%02x"·"\n",

319

·····················qemu_get_thread_id(),

319

·····················qemu_get_thread_id(),

320

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

320

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

321

·····················,·addr,·value);

321

·····················,·addr,·value);

322

#line·324·"trace/trace-hw_char.h"

322

#line·324·"trace/trace-hw_char.h"

323

········}·else·{

323

········}·else·{

325

············qemu_log("serial_read·"·"read·addr·0x%02x·val·0x%02x"·"\n",·addr,·value);

325

············qemu_log("serial_read·"·"read·addr·0x%02x·val·0x%02x"·"\n",·addr,·value);

326

#line·328·"trace/trace-hw_char.h"

326

#line·328·"trace/trace-hw_char.h"

327

········}

327

········}

328

····}

328

····}

329

}

329

}

330

static·inline·void·trace_serial_read(uint16_t·addr,·uint8_t·value)

330

static·inline·void·trace_serial_read(uint16_t·addr,·uint8_t·value)

342

static·inline·void·_nocheck__trace_serial_write(uint16_t·addr,·uint8_t·value)

342

static·inline·void·_nocheck__trace_serial_write(uint16_t·addr,·uint8_t·value)

343

{

343

{

344

····if·(trace_event_get_state(TRACE_SERIAL_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

344

····if·(trace_event_get_state(TRACE_SERIAL_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

345

········if·(message_with_timestamp)·{

345

········if·(message_with_timestamp)·{

346

············struct·timeval·_now;

346

············struct·timeval·_now;

347

············gettimeofday(&_now,·NULL);

347

············gettimeofday(&_now,·NULL);

349

············qemu_log("%d@%zu.%06zu:serial_write·"·"write·addr·0x%02x·val·0x%02x"·"\n",

349

············qemu_log("%d@%zu.%06zu:serial_write·"·"write·addr·0x%02x·val·0x%02x"·"\n",

350

·····················qemu_get_thread_id(),

350

·····················qemu_get_thread_id(),

351

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

351

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

352

·····················,·addr,·value);

352

·····················,·addr,·value);

353

#line·355·"trace/trace-hw_char.h"

353

#line·355·"trace/trace-hw_char.h"

354

········}·else·{

354

········}·else·{

356

············qemu_log("serial_write·"·"write·addr·0x%02x·val·0x%02x"·"\n",·addr,·value);

356

············qemu_log("serial_write·"·"write·addr·0x%02x·val·0x%02x"·"\n",·addr,·value);

357

#line·359·"trace/trace-hw_char.h"

357

#line·359·"trace/trace-hw_char.h"

358

········}

358

········}

359

····}

359

····}

360

}

360

}

361

static·inline·void·trace_serial_write(uint16_t·addr,·uint8_t·value)

361

static·inline·void·trace_serial_write(uint16_t·addr,·uint8_t·value)

373

static·inline·void·_nocheck__trace_serial_update_parameters(uint64_t·baudrate,·char·parity,·int·data_bits,·int·stop_bits)

373

static·inline·void·_nocheck__trace_serial_update_parameters(uint64_t·baudrate,·char·parity,·int·data_bits,·int·stop_bits)

374

{

374

{

375

····if·(trace_event_get_state(TRACE_SERIAL_UPDATE_PARAMETERS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

375

····if·(trace_event_get_state(TRACE_SERIAL_UPDATE_PARAMETERS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

376

········if·(message_with_timestamp)·{

376

········if·(message_with_timestamp)·{

377

············struct·timeval·_now;

377

············struct·timeval·_now;

378

············gettimeofday(&_now,·NULL);

378

············gettimeofday(&_now,·NULL);

380

············qemu_log("%d@%zu.%06zu:serial_update_parameters·"·"baudrate=%"PRIu64"·parity='%c'·data=%d·stop=%d"·"\n",

380

············qemu_log("%d@%zu.%06zu:serial_update_parameters·"·"baudrate=%"PRIu64"·parity='%c'·data=%d·stop=%d"·"\n",

381

·····················qemu_get_thread_id(),

381

·····················qemu_get_thread_id(),

382

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

382

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

383

·····················,·baudrate,·parity,·data_bits,·stop_bits);

383

·····················,·baudrate,·parity,·data_bits,·stop_bits);

384

#line·386·"trace/trace-hw_char.h"

384

#line·386·"trace/trace-hw_char.h"

385

········}·else·{

385

········}·else·{

387

············qemu_log("serial_update_parameters·"·"baudrate=%"PRIu64"·parity='%c'·data=%d·stop=%d"·"\n",·baudrate,·parity,·data_bits,·stop_bits);

387

············qemu_log("serial_update_parameters·"·"baudrate=%"PRIu64"·parity='%c'·data=%d·stop=%d"·"\n",·baudrate,·parity,·data_bits,·stop_bits);

388

#line·390·"trace/trace-hw_char.h"

388

#line·390·"trace/trace-hw_char.h"

389

········}

389

········}

390

····}

390

····}

391

}

391

}

392

static·inline·void·trace_serial_update_parameters(uint64_t·baudrate,·char·parity,·int·data_bits,·int·stop_bits)

392

static·inline·void·trace_serial_update_parameters(uint64_t·baudrate,·char·parity,·int·data_bits,·int·stop_bits)

404

static·inline·void·_nocheck__trace_virtio_serial_send_control_event(unsigned·int·port,·uint16_t·event,·uint16_t·value)

404

static·inline·void·_nocheck__trace_virtio_serial_send_control_event(unsigned·int·port,·uint16_t·event,·uint16_t·value)

405

{

405

{

406

····if·(trace_event_get_state(TRACE_VIRTIO_SERIAL_SEND_CONTROL_EVENT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

406

····if·(trace_event_get_state(TRACE_VIRTIO_SERIAL_SEND_CONTROL_EVENT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

407

········if·(message_with_timestamp)·{

407

········if·(message_with_timestamp)·{

408

············struct·timeval·_now;

408

············struct·timeval·_now;

409

············gettimeofday(&_now,·NULL);

409

············gettimeofday(&_now,·NULL);

411

············qemu_log("%d@%zu.%06zu:virtio_serial_send_control_event·"·"port·%u,·event·%u,·value·%u"·"\n",

411

············qemu_log("%d@%zu.%06zu:virtio_serial_send_control_event·"·"port·%u,·event·%u,·value·%u"·"\n",

412

·····················qemu_get_thread_id(),

412

·····················qemu_get_thread_id(),

413

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

413

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

414

·····················,·port,·event,·value);

414

·····················,·port,·event,·value);

415

#line·417·"trace/trace-hw_char.h"

415

#line·417·"trace/trace-hw_char.h"

416

········}·else·{

416

········}·else·{

418

············qemu_log("virtio_serial_send_control_event·"·"port·%u,·event·%u,·value·%u"·"\n",·port,·event,·value);

418

············qemu_log("virtio_serial_send_control_event·"·"port·%u,·event·%u,·value·%u"·"\n",·port,·event,·value);

419

#line·421·"trace/trace-hw_char.h"

419

#line·421·"trace/trace-hw_char.h"

420

········}

420

········}

421

····}

421

····}

422

}

422

}

423

static·inline·void·trace_virtio_serial_send_control_event(unsigned·int·port,·uint16_t·event,·uint16_t·value)

423

static·inline·void·trace_virtio_serial_send_control_event(unsigned·int·port,·uint16_t·event,·uint16_t·value)

435

static·inline·void·_nocheck__trace_virtio_serial_throttle_port(unsigned·int·port,·bool·throttle)

435

static·inline·void·_nocheck__trace_virtio_serial_throttle_port(unsigned·int·port,·bool·throttle)

436

{

436

{

437

····if·(trace_event_get_state(TRACE_VIRTIO_SERIAL_THROTTLE_PORT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

437

····if·(trace_event_get_state(TRACE_VIRTIO_SERIAL_THROTTLE_PORT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

438

········if·(message_with_timestamp)·{

438

········if·(message_with_timestamp)·{

439

············struct·timeval·_now;

439

············struct·timeval·_now;

440

············gettimeofday(&_now,·NULL);

440

············gettimeofday(&_now,·NULL);

442

············qemu_log("%d@%zu.%06zu:virtio_serial_throttle_port·"·"port·%u,·throttle·%d"·"\n",

442

············qemu_log("%d@%zu.%06zu:virtio_serial_throttle_port·"·"port·%u,·throttle·%d"·"\n",

443

·····················qemu_get_thread_id(),

443

·····················qemu_get_thread_id(),

444

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

444

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

445

·····················,·port,·throttle);

445

·····················,·port,·throttle);

446

#line·448·"trace/trace-hw_char.h"

446

#line·448·"trace/trace-hw_char.h"

447

········}·else·{

447

········}·else·{

449

············qemu_log("virtio_serial_throttle_port·"·"port·%u,·throttle·%d"·"\n",·port,·throttle);

449

············qemu_log("virtio_serial_throttle_port·"·"port·%u,·throttle·%d"·"\n",·port,·throttle);

450

#line·452·"trace/trace-hw_char.h"

450

#line·452·"trace/trace-hw_char.h"

451

········}

451

········}

452

····}

452

····}

453

}

453

}

454

static·inline·void·trace_virtio_serial_throttle_port(unsigned·int·port,·bool·throttle)

454

static·inline·void·trace_virtio_serial_throttle_port(unsigned·int·port,·bool·throttle)

466

static·inline·void·_nocheck__trace_virtio_serial_handle_control_message(uint16_t·event,·uint16_t·value)

466

static·inline·void·_nocheck__trace_virtio_serial_handle_control_message(uint16_t·event,·uint16_t·value)

467

{

467

{

468

····if·(trace_event_get_state(TRACE_VIRTIO_SERIAL_HANDLE_CONTROL_MESSAGE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

468

····if·(trace_event_get_state(TRACE_VIRTIO_SERIAL_HANDLE_CONTROL_MESSAGE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

469

········if·(message_with_timestamp)·{

469

········if·(message_with_timestamp)·{

470

············struct·timeval·_now;

470

············struct·timeval·_now;

471

············gettimeofday(&_now,·NULL);

471

············gettimeofday(&_now,·NULL);

473

············qemu_log("%d@%zu.%06zu:virtio_serial_handle_control_message·"·"event·%u,·value·%u"·"\n",

473

············qemu_log("%d@%zu.%06zu:virtio_serial_handle_control_message·"·"event·%u,·value·%u"·"\n",

474

·····················qemu_get_thread_id(),

474

·····················qemu_get_thread_id(),

475

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

475

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

476

·····················,·event,·value);

476

·····················,·event,·value);

477

#line·479·"trace/trace-hw_char.h"

477

#line·479·"trace/trace-hw_char.h"

478

········}·else·{

478

········}·else·{

480

············qemu_log("virtio_serial_handle_control_message·"·"event·%u,·value·%u"·"\n",·event,·value);

480

············qemu_log("virtio_serial_handle_control_message·"·"event·%u,·value·%u"·"\n",·event,·value);

481

#line·483·"trace/trace-hw_char.h"

481

#line·483·"trace/trace-hw_char.h"

482

········}

482

········}

483

····}

483

····}

484

}

484

}

485

static·inline·void·trace_virtio_serial_handle_control_message(uint16_t·event,·uint16_t·value)

485

static·inline·void·trace_virtio_serial_handle_control_message(uint16_t·event,·uint16_t·value)

497

static·inline·void·_nocheck__trace_virtio_serial_handle_control_message_port(unsigned·int·port)

497

static·inline·void·_nocheck__trace_virtio_serial_handle_control_message_port(unsigned·int·port)

498

{

498

{

499

····if·(trace_event_get_state(TRACE_VIRTIO_SERIAL_HANDLE_CONTROL_MESSAGE_PORT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

499

····if·(trace_event_get_state(TRACE_VIRTIO_SERIAL_HANDLE_CONTROL_MESSAGE_PORT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

500

········if·(message_with_timestamp)·{

500

········if·(message_with_timestamp)·{

501

············struct·timeval·_now;

501

············struct·timeval·_now;

502

············gettimeofday(&_now,·NULL);

502

············gettimeofday(&_now,·NULL);

504

············qemu_log("%d@%zu.%06zu:virtio_serial_handle_control_message_port·"·"port·%u"·"\n",

504

············qemu_log("%d@%zu.%06zu:virtio_serial_handle_control_message_port·"·"port·%u"·"\n",

505

·····················qemu_get_thread_id(),

505

·····················qemu_get_thread_id(),

506

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

506

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

507

·····················,·port);

507

·····················,·port);

508

#line·510·"trace/trace-hw_char.h"

508

#line·510·"trace/trace-hw_char.h"

509

········}·else·{

509

········}·else·{

511

············qemu_log("virtio_serial_handle_control_message_port·"·"port·%u"·"\n",·port);

511

············qemu_log("virtio_serial_handle_control_message_port·"·"port·%u"·"\n",·port);

512

#line·514·"trace/trace-hw_char.h"

512

#line·514·"trace/trace-hw_char.h"

513

········}

513

········}

514

····}

514

····}

515

}

515

}

516

static·inline·void·trace_virtio_serial_handle_control_message_port(unsigned·int·port)

516

static·inline·void·trace_virtio_serial_handle_control_message_port(unsigned·int·port)

528

static·inline·void·_nocheck__trace_virtio_console_flush_buf(unsigned·int·port,·size_t·len,·ssize_t·ret)

528

static·inline·void·_nocheck__trace_virtio_console_flush_buf(unsigned·int·port,·size_t·len,·ssize_t·ret)

529

{

529

{

530

····if·(trace_event_get_state(TRACE_VIRTIO_CONSOLE_FLUSH_BUF)·&&·qemu_loglevel_mask(LOG_TRACE))·{

530

····if·(trace_event_get_state(TRACE_VIRTIO_CONSOLE_FLUSH_BUF)·&&·qemu_loglevel_mask(LOG_TRACE))·{

531

········if·(message_with_timestamp)·{

531

········if·(message_with_timestamp)·{

532

············struct·timeval·_now;

532

············struct·timeval·_now;

533

············gettimeofday(&_now,·NULL);

533

············gettimeofday(&_now,·NULL);

535

············qemu_log("%d@%zu.%06zu:virtio_console_flush_buf·"·"port·%u,·in_len·%zu,·out_len·%zd"·"\n",

535

············qemu_log("%d@%zu.%06zu:virtio_console_flush_buf·"·"port·%u,·in_len·%zu,·out_len·%zd"·"\n",

536

·····················qemu_get_thread_id(),

536

·····················qemu_get_thread_id(),

537

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

537

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

538

·····················,·port,·len,·ret);

538

·····················,·port,·len,·ret);

539

#line·541·"trace/trace-hw_char.h"

539

#line·541·"trace/trace-hw_char.h"

540

········}·else·{

540

········}·else·{

542

············qemu_log("virtio_console_flush_buf·"·"port·%u,·in_len·%zu,·out_len·%zd"·"\n",·port,·len,·ret);

542

············qemu_log("virtio_console_flush_buf·"·"port·%u,·in_len·%zu,·out_len·%zd"·"\n",·port,·len,·ret);

543

#line·545·"trace/trace-hw_char.h"

543

#line·545·"trace/trace-hw_char.h"

544

········}

544

········}

545

····}

545

····}

546

}

546

}

547

static·inline·void·trace_virtio_console_flush_buf(unsigned·int·port,·size_t·len,·ssize_t·ret)

547

static·inline·void·trace_virtio_console_flush_buf(unsigned·int·port,·size_t·len,·ssize_t·ret)

559

static·inline·void·_nocheck__trace_virtio_console_chr_read(unsigned·int·port,·int·size)

559

static·inline·void·_nocheck__trace_virtio_console_chr_read(unsigned·int·port,·int·size)

560

{

560

{

561

····if·(trace_event_get_state(TRACE_VIRTIO_CONSOLE_CHR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

561

····if·(trace_event_get_state(TRACE_VIRTIO_CONSOLE_CHR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

562

········if·(message_with_timestamp)·{

562

········if·(message_with_timestamp)·{

563

············struct·timeval·_now;

563

············struct·timeval·_now;

564

············gettimeofday(&_now,·NULL);

564

············gettimeofday(&_now,·NULL);

566

············qemu_log("%d@%zu.%06zu:virtio_console_chr_read·"·"port·%u,·size·%d"·"\n",

566

············qemu_log("%d@%zu.%06zu:virtio_console_chr_read·"·"port·%u,·size·%d"·"\n",

567

·····················qemu_get_thread_id(),

567

·····················qemu_get_thread_id(),

568

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

568

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

569

·····················,·port,·size);

569

·····················,·port,·size);

570

#line·572·"trace/trace-hw_char.h"

570

#line·572·"trace/trace-hw_char.h"

571

········}·else·{

571

········}·else·{

573

············qemu_log("virtio_console_chr_read·"·"port·%u,·size·%d"·"\n",·port,·size);

573

············qemu_log("virtio_console_chr_read·"·"port·%u,·size·%d"·"\n",·port,·size);

574

#line·576·"trace/trace-hw_char.h"

574

#line·576·"trace/trace-hw_char.h"

575

········}

575

········}

576

····}

576

····}

577

}

577

}

578

static·inline·void·trace_virtio_console_chr_read(unsigned·int·port,·int·size)

578

static·inline·void·trace_virtio_console_chr_read(unsigned·int·port,·int·size)

590

static·inline·void·_nocheck__trace_virtio_console_chr_event(unsigned·int·port,·int·event)

590

static·inline·void·_nocheck__trace_virtio_console_chr_event(unsigned·int·port,·int·event)

591

{

591

{

592

····if·(trace_event_get_state(TRACE_VIRTIO_CONSOLE_CHR_EVENT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

592

····if·(trace_event_get_state(TRACE_VIRTIO_CONSOLE_CHR_EVENT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

593

········if·(message_with_timestamp)·{

593

········if·(message_with_timestamp)·{

594

············struct·timeval·_now;

594

············struct·timeval·_now;

595

············gettimeofday(&_now,·NULL);

595

············gettimeofday(&_now,·NULL);

597

············qemu_log("%d@%zu.%06zu:virtio_console_chr_event·"·"port·%u,·event·%d"·"\n",

597

············qemu_log("%d@%zu.%06zu:virtio_console_chr_event·"·"port·%u,·event·%d"·"\n",

598

·····················qemu_get_thread_id(),

598

·····················qemu_get_thread_id(),

599

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

599

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

600

·····················,·port,·event);

600

·····················,·port,·event);

601

#line·603·"trace/trace-hw_char.h"

601

#line·603·"trace/trace-hw_char.h"

602

········}·else·{

602

········}·else·{

604

············qemu_log("virtio_console_chr_event·"·"port·%u,·event·%d"·"\n",·port,·event);

604

············qemu_log("virtio_console_chr_event·"·"port·%u,·event·%d"·"\n",·port,·event);

605

#line·607·"trace/trace-hw_char.h"

605

#line·607·"trace/trace-hw_char.h"

606

········}

606

········}

607

····}

607

····}

608

}

608

}

609

static·inline·void·trace_virtio_console_chr_event(unsigned·int·port,·int·event)

609

static·inline·void·trace_virtio_console_chr_event(unsigned·int·port,·int·event)

621

static·inline·void·_nocheck__trace_goldfish_tty_read(void·*·dev,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

621

static·inline·void·_nocheck__trace_goldfish_tty_read(void·*·dev,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

622

{

622

{

623

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

623

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

624

········if·(message_with_timestamp)·{

624

········if·(message_with_timestamp)·{

625

············struct·timeval·_now;

625

············struct·timeval·_now;

626

············gettimeofday(&_now,·NULL);

626

············gettimeofday(&_now,·NULL);

628

············qemu_log("%d@%zu.%06zu:goldfish_tty_read·"·"tty:·%p·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",

628

············qemu_log("%d@%zu.%06zu:goldfish_tty_read·"·"tty:·%p·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",

629

·····················qemu_get_thread_id(),

629

·····················qemu_get_thread_id(),

630

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

630

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

631

·····················,·dev,·addr,·size,·value);

631

·····················,·dev,·addr,·size,·value);

632

#line·634·"trace/trace-hw_char.h"

632

#line·634·"trace/trace-hw_char.h"

633

········}·else·{

633

········}·else·{

635

············qemu_log("goldfish_tty_read·"·"tty:·%p·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",·dev,·addr,·size,·value);

635

············qemu_log("goldfish_tty_read·"·"tty:·%p·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",·dev,·addr,·size,·value);

636

#line·638·"trace/trace-hw_char.h"

636

#line·638·"trace/trace-hw_char.h"

637

········}

637

········}

638

····}

638

····}

639

}

639

}

640

static·inline·void·trace_goldfish_tty_read(void·*·dev,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

640

static·inline·void·trace_goldfish_tty_read(void·*·dev,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

652

static·inline·void·_nocheck__trace_goldfish_tty_write(void·*·dev,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

652

static·inline·void·_nocheck__trace_goldfish_tty_write(void·*·dev,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

653

{

653

{

654

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

654

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

655

········if·(message_with_timestamp)·{

655

········if·(message_with_timestamp)·{

656

············struct·timeval·_now;

656

············struct·timeval·_now;

657

············gettimeofday(&_now,·NULL);

657

············gettimeofday(&_now,·NULL);

659

············qemu_log("%d@%zu.%06zu:goldfish_tty_write·"·"tty:·%p·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",

659

············qemu_log("%d@%zu.%06zu:goldfish_tty_write·"·"tty:·%p·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",

660

·····················qemu_get_thread_id(),

660

·····················qemu_get_thread_id(),

661

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

661

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

662

·····················,·dev,·addr,·size,·value);

662

·····················,·dev,·addr,·size,·value);

663

#line·665·"trace/trace-hw_char.h"

663

#line·665·"trace/trace-hw_char.h"

664

········}·else·{

664

········}·else·{

666

············qemu_log("goldfish_tty_write·"·"tty:·%p·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",·dev,·addr,·size,·value);

666

············qemu_log("goldfish_tty_write·"·"tty:·%p·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",·dev,·addr,·size,·value);

667

#line·669·"trace/trace-hw_char.h"

667

#line·669·"trace/trace-hw_char.h"

668

········}

668

········}

669

····}

669

····}

670

}

670

}

671

static·inline·void·trace_goldfish_tty_write(void·*·dev,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

671

static·inline·void·trace_goldfish_tty_write(void·*·dev,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

683

static·inline·void·_nocheck__trace_goldfish_tty_can_receive(void·*·dev,·unsigned·int·available)

683

static·inline·void·_nocheck__trace_goldfish_tty_can_receive(void·*·dev,·unsigned·int·available)

684

{

684

{

685

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_CAN_RECEIVE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

685

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_CAN_RECEIVE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

686

········if·(message_with_timestamp)·{

686

········if·(message_with_timestamp)·{

687

············struct·timeval·_now;

687

············struct·timeval·_now;

688

············gettimeofday(&_now,·NULL);

688

············gettimeofday(&_now,·NULL);

690

············qemu_log("%d@%zu.%06zu:goldfish_tty_can_receive·"·"tty:·%p·available:·%u"·"\n",

690

············qemu_log("%d@%zu.%06zu:goldfish_tty_can_receive·"·"tty:·%p·available:·%u"·"\n",

691

·····················qemu_get_thread_id(),

691

·····················qemu_get_thread_id(),

692

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

692

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

693

·····················,·dev,·available);

693

·····················,·dev,·available);

694

#line·696·"trace/trace-hw_char.h"

694

#line·696·"trace/trace-hw_char.h"

695

········}·else·{

695

········}·else·{

697

············qemu_log("goldfish_tty_can_receive·"·"tty:·%p·available:·%u"·"\n",·dev,·available);

697

············qemu_log("goldfish_tty_can_receive·"·"tty:·%p·available:·%u"·"\n",·dev,·available);

698

#line·700·"trace/trace-hw_char.h"

698

#line·700·"trace/trace-hw_char.h"

699

········}

699

········}

700

····}

700

····}

701

}

701

}

702

static·inline·void·trace_goldfish_tty_can_receive(void·*·dev,·unsigned·int·available)

702

static·inline·void·trace_goldfish_tty_can_receive(void·*·dev,·unsigned·int·available)

714

static·inline·void·_nocheck__trace_goldfish_tty_receive(void·*·dev,·unsigned·int·size)

714

static·inline·void·_nocheck__trace_goldfish_tty_receive(void·*·dev,·unsigned·int·size)

715

{

715

{

716

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_RECEIVE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

716

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_RECEIVE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

717

········if·(message_with_timestamp)·{

717

········if·(message_with_timestamp)·{

718

············struct·timeval·_now;

718

············struct·timeval·_now;

719

············gettimeofday(&_now,·NULL);

719

············gettimeofday(&_now,·NULL);

721

············qemu_log("%d@%zu.%06zu:goldfish_tty_receive·"·"tty:·%p·size:·%u"·"\n",

721

············qemu_log("%d@%zu.%06zu:goldfish_tty_receive·"·"tty:·%p·size:·%u"·"\n",

722

·····················qemu_get_thread_id(),

722

·····················qemu_get_thread_id(),

723

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

723

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

724

·····················,·dev,·size);

724

·····················,·dev,·size);

725

#line·727·"trace/trace-hw_char.h"

725

#line·727·"trace/trace-hw_char.h"

726

········}·else·{

726

········}·else·{

728

············qemu_log("goldfish_tty_receive·"·"tty:·%p·size:·%u"·"\n",·dev,·size);

728

············qemu_log("goldfish_tty_receive·"·"tty:·%p·size:·%u"·"\n",·dev,·size);

729

#line·731·"trace/trace-hw_char.h"

729

#line·731·"trace/trace-hw_char.h"

730

········}

730

········}

731

····}

731

····}

732

}

732

}

733

static·inline·void·trace_goldfish_tty_receive(void·*·dev,·unsigned·int·size)

733

static·inline·void·trace_goldfish_tty_receive(void·*·dev,·unsigned·int·size)

745

static·inline·void·_nocheck__trace_goldfish_tty_reset(void·*·dev)

745

static·inline·void·_nocheck__trace_goldfish_tty_reset(void·*·dev)

746

{

746

{

747

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

747

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

748

········if·(message_with_timestamp)·{

748

········if·(message_with_timestamp)·{

749

············struct·timeval·_now;

749

············struct·timeval·_now;

750

············gettimeofday(&_now,·NULL);

750

············gettimeofday(&_now,·NULL);

752

············qemu_log("%d@%zu.%06zu:goldfish_tty_reset·"·"tty:·%p"·"\n",

752

············qemu_log("%d@%zu.%06zu:goldfish_tty_reset·"·"tty:·%p"·"\n",

753

·····················qemu_get_thread_id(),

753

·····················qemu_get_thread_id(),

754

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

754

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

755

·····················,·dev);

755

·····················,·dev);

756

#line·758·"trace/trace-hw_char.h"

756

#line·758·"trace/trace-hw_char.h"

757

········}·else·{

757

········}·else·{

759

············qemu_log("goldfish_tty_reset·"·"tty:·%p"·"\n",·dev);

759

············qemu_log("goldfish_tty_reset·"·"tty:·%p"·"\n",·dev);

760

#line·762·"trace/trace-hw_char.h"

760

#line·762·"trace/trace-hw_char.h"

761

········}

761

········}

762

····}

762

····}

763

}

763

}

764

static·inline·void·trace_goldfish_tty_reset(void·*·dev)

764

static·inline·void·trace_goldfish_tty_reset(void·*·dev)

776

static·inline·void·_nocheck__trace_goldfish_tty_realize(void·*·dev)

776

static·inline·void·_nocheck__trace_goldfish_tty_realize(void·*·dev)

777

{

777

{

778

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_REALIZE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

778

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_REALIZE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

779

········if·(message_with_timestamp)·{

779

········if·(message_with_timestamp)·{

780

············struct·timeval·_now;

780

············struct·timeval·_now;

781

············gettimeofday(&_now,·NULL);

781

············gettimeofday(&_now,·NULL);

783

············qemu_log("%d@%zu.%06zu:goldfish_tty_realize·"·"tty:·%p"·"\n",

783

············qemu_log("%d@%zu.%06zu:goldfish_tty_realize·"·"tty:·%p"·"\n",

784

·····················qemu_get_thread_id(),

784

·····················qemu_get_thread_id(),

785

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

785

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

786

·····················,·dev);

786

·····················,·dev);

787

#line·789·"trace/trace-hw_char.h"

787

#line·789·"trace/trace-hw_char.h"

788

········}·else·{

788

········}·else·{

790

············qemu_log("goldfish_tty_realize·"·"tty:·%p"·"\n",·dev);

790

············qemu_log("goldfish_tty_realize·"·"tty:·%p"·"\n",·dev);

791

#line·793·"trace/trace-hw_char.h"

791

#line·793·"trace/trace-hw_char.h"

792

········}

792

········}

793

····}

793

····}

794

}

794

}

795

static·inline·void·trace_goldfish_tty_realize(void·*·dev)

795

static·inline·void·trace_goldfish_tty_realize(void·*·dev)

807

static·inline·void·_nocheck__trace_goldfish_tty_unrealize(void·*·dev)

807

static·inline·void·_nocheck__trace_goldfish_tty_unrealize(void·*·dev)

808

{

808

{

809

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_UNREALIZE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

809

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_UNREALIZE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

810

········if·(message_with_timestamp)·{

810

········if·(message_with_timestamp)·{

811

············struct·timeval·_now;

811

············struct·timeval·_now;

812

············gettimeofday(&_now,·NULL);

812

············gettimeofday(&_now,·NULL);

814

············qemu_log("%d@%zu.%06zu:goldfish_tty_unrealize·"·"tty:·%p"·"\n",

814

············qemu_log("%d@%zu.%06zu:goldfish_tty_unrealize·"·"tty:·%p"·"\n",

815

·····················qemu_get_thread_id(),

815

·····················qemu_get_thread_id(),

816

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

816

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

817

·····················,·dev);

817

·····················,·dev);

818

#line·820·"trace/trace-hw_char.h"

818

#line·820·"trace/trace-hw_char.h"

819

········}·else·{

819

········}·else·{

821

············qemu_log("goldfish_tty_unrealize·"·"tty:·%p"·"\n",·dev);

821

············qemu_log("goldfish_tty_unrealize·"·"tty:·%p"·"\n",·dev);

822

#line·824·"trace/trace-hw_char.h"

822

#line·824·"trace/trace-hw_char.h"

823

········}

823

········}

824

····}

824

····}

825

}

825

}

826

static·inline·void·trace_goldfish_tty_unrealize(void·*·dev)

826

static·inline·void·trace_goldfish_tty_unrealize(void·*·dev)

838

static·inline·void·_nocheck__trace_goldfish_tty_instance_init(void·*·dev)

838

static·inline·void·_nocheck__trace_goldfish_tty_instance_init(void·*·dev)

839

{

839

{

840

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_INSTANCE_INIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

840

····if·(trace_event_get_state(TRACE_GOLDFISH_TTY_INSTANCE_INIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

841

········if·(message_with_timestamp)·{

841

········if·(message_with_timestamp)·{

842

············struct·timeval·_now;

842

············struct·timeval·_now;

843

············gettimeofday(&_now,·NULL);

843

············gettimeofday(&_now,·NULL);

845

············qemu_log("%d@%zu.%06zu:goldfish_tty_instance_init·"·"tty:·%p"·"\n",

845

············qemu_log("%d@%zu.%06zu:goldfish_tty_instance_init·"·"tty:·%p"·"\n",

846

·····················qemu_get_thread_id(),

846

·····················qemu_get_thread_id(),

847

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

847

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

848

·····················,·dev);

848

·····················,·dev);

849

#line·851·"trace/trace-hw_char.h"

849

#line·851·"trace/trace-hw_char.h"

850

········}·else·{

850

········}·else·{

852

············qemu_log("goldfish_tty_instance_init·"·"tty:·%p"·"\n",·dev);

852

············qemu_log("goldfish_tty_instance_init·"·"tty:·%p"·"\n",·dev);

853

#line·855·"trace/trace-hw_char.h"

853

#line·855·"trace/trace-hw_char.h"

854

········}

854

········}

855

····}

855

····}

856

}

856

}

857

static·inline·void·trace_goldfish_tty_instance_init(void·*·dev)

857

static·inline·void·trace_goldfish_tty_instance_init(void·*·dev)

869

static·inline·void·_nocheck__trace_grlib_apbuart_event(int·event)

869

static·inline·void·_nocheck__trace_grlib_apbuart_event(int·event)

870

{

870

{

871

····if·(trace_event_get_state(TRACE_GRLIB_APBUART_EVENT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

871

····if·(trace_event_get_state(TRACE_GRLIB_APBUART_EVENT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

872

········if·(message_with_timestamp)·{

872

········if·(message_with_timestamp)·{

873

············struct·timeval·_now;

873

············struct·timeval·_now;

874

············gettimeofday(&_now,·NULL);

874

············gettimeofday(&_now,·NULL);

876

············qemu_log("%d@%zu.%06zu:grlib_apbuart_event·"·"event:%d"·"\n",

876

············qemu_log("%d@%zu.%06zu:grlib_apbuart_event·"·"event:%d"·"\n",

877

·····················qemu_get_thread_id(),

877

·····················qemu_get_thread_id(),

878

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

878

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

879

·····················,·event);

879

·····················,·event);

880

#line·882·"trace/trace-hw_char.h"

880

#line·882·"trace/trace-hw_char.h"

881

········}·else·{

881

········}·else·{

883

············qemu_log("grlib_apbuart_event·"·"event:%d"·"\n",·event);

883

············qemu_log("grlib_apbuart_event·"·"event:%d"·"\n",·event);

884

#line·886·"trace/trace-hw_char.h"

884

#line·886·"trace/trace-hw_char.h"

885

········}

885

········}

886

····}

886

····}

887

}

887

}

888

static·inline·void·trace_grlib_apbuart_event(int·event)

888

static·inline·void·trace_grlib_apbuart_event(int·event)

900

static·inline·void·_nocheck__trace_grlib_apbuart_writel_unknown(uint64_t·addr,·uint32_t·value)

900

static·inline·void·_nocheck__trace_grlib_apbuart_writel_unknown(uint64_t·addr,·uint32_t·value)

901

{

901

{

902

····if·(trace_event_get_state(TRACE_GRLIB_APBUART_WRITEL_UNKNOWN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

902

····if·(trace_event_get_state(TRACE_GRLIB_APBUART_WRITEL_UNKNOWN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

903

········if·(message_with_timestamp)·{

903

········if·(message_with_timestamp)·{

904

············struct·timeval·_now;

904

············struct·timeval·_now;

905

············gettimeofday(&_now,·NULL);

905

············gettimeofday(&_now,·NULL);

907

············qemu_log("%d@%zu.%06zu:grlib_apbuart_writel_unknown·"·"addr·0x%"PRIx64"·value·0x%x"·"\n",

907

············qemu_log("%d@%zu.%06zu:grlib_apbuart_writel_unknown·"·"addr·0x%"PRIx64"·value·0x%x"·"\n",

908

·····················qemu_get_thread_id(),

908

·····················qemu_get_thread_id(),

909

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

909

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

910

·····················,·addr,·value);

910

·····················,·addr,·value);

911

#line·913·"trace/trace-hw_char.h"

911

#line·913·"trace/trace-hw_char.h"

912

········}·else·{

912

········}·else·{

914

············qemu_log("grlib_apbuart_writel_unknown·"·"addr·0x%"PRIx64"·value·0x%x"·"\n",·addr,·value);

914

············qemu_log("grlib_apbuart_writel_unknown·"·"addr·0x%"PRIx64"·value·0x%x"·"\n",·addr,·value);

915

#line·917·"trace/trace-hw_char.h"

915

#line·917·"trace/trace-hw_char.h"

916

········}

916

········}

917

····}

917

····}

918

}

918

}

919

static·inline·void·trace_grlib_apbuart_writel_unknown(uint64_t·addr,·uint32_t·value)

919

static·inline·void·trace_grlib_apbuart_writel_unknown(uint64_t·addr,·uint32_t·value)

931

static·inline·void·_nocheck__trace_grlib_apbuart_readl_unknown(uint64_t·addr)

931

static·inline·void·_nocheck__trace_grlib_apbuart_readl_unknown(uint64_t·addr)

932

{

932

{

933

····if·(trace_event_get_state(TRACE_GRLIB_APBUART_READL_UNKNOWN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

933

····if·(trace_event_get_state(TRACE_GRLIB_APBUART_READL_UNKNOWN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

934

········if·(message_with_timestamp)·{

934

········if·(message_with_timestamp)·{

935

············struct·timeval·_now;

935

············struct·timeval·_now;

936

············gettimeofday(&_now,·NULL);

936

············gettimeofday(&_now,·NULL);

938

············qemu_log("%d@%zu.%06zu:grlib_apbuart_readl_unknown·"·"addr·0x%"PRIx64·"\n",

938

············qemu_log("%d@%zu.%06zu:grlib_apbuart_readl_unknown·"·"addr·0x%"PRIx64·"\n",

939

·····················qemu_get_thread_id(),

939

·····················qemu_get_thread_id(),

940

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

940

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

941

·····················,·addr);

941

·····················,·addr);

942

#line·944·"trace/trace-hw_char.h"

942

#line·944·"trace/trace-hw_char.h"

943

········}·else·{

943

········}·else·{

945

············qemu_log("grlib_apbuart_readl_unknown·"·"addr·0x%"PRIx64·"\n",·addr);

945

············qemu_log("grlib_apbuart_readl_unknown·"·"addr·0x%"PRIx64·"\n",·addr);

946

#line·948·"trace/trace-hw_char.h"

946

#line·948·"trace/trace-hw_char.h"

947

········}

947

········}

948

····}

948

····}

949

}

949

}

950

static·inline·void·trace_grlib_apbuart_readl_unknown(uint64_t·addr)

950

static·inline·void·trace_grlib_apbuart_readl_unknown(uint64_t·addr)

962

static·inline·void·_nocheck__trace_escc_hard_reset(void)

962

static·inline·void·_nocheck__trace_escc_hard_reset(void)

963

{

963

{

964

····if·(trace_event_get_state(TRACE_ESCC_HARD_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

964

····if·(trace_event_get_state(TRACE_ESCC_HARD_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

965

········if·(message_with_timestamp)·{

965

········if·(message_with_timestamp)·{

966

············struct·timeval·_now;

966

············struct·timeval·_now;

967

············gettimeofday(&_now,·NULL);

967

············gettimeofday(&_now,·NULL);

969

············qemu_log("%d@%zu.%06zu:escc_hard_reset·"·"hard·reset"·"\n",

969

············qemu_log("%d@%zu.%06zu:escc_hard_reset·"·"hard·reset"·"\n",

970

·····················qemu_get_thread_id(),

970

·····················qemu_get_thread_id(),

971

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

971

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

972

·····················);

972

·····················);

973

#line·975·"trace/trace-hw_char.h"

973

#line·975·"trace/trace-hw_char.h"

974

········}·else·{

974

········}·else·{

976

············qemu_log("escc_hard_reset·"·"hard·reset"·"\n");

976

············qemu_log("escc_hard_reset·"·"hard·reset"·"\n");

977

#line·979·"trace/trace-hw_char.h"

977

#line·979·"trace/trace-hw_char.h"

978

········}

978

········}

979

····}

979

····}

980

}

980

}

981

static·inline·void·trace_escc_hard_reset(void)

981

static·inline·void·trace_escc_hard_reset(void)

993

static·inline·void·_nocheck__trace_escc_soft_reset_chn(char·channel)

993

static·inline·void·_nocheck__trace_escc_soft_reset_chn(char·channel)

994

{

994

{

995

····if·(trace_event_get_state(TRACE_ESCC_SOFT_RESET_CHN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

995

····if·(trace_event_get_state(TRACE_ESCC_SOFT_RESET_CHN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

996

········if·(message_with_timestamp)·{

996

········if·(message_with_timestamp)·{

997

············struct·timeval·_now;

997

············struct·timeval·_now;

998

············gettimeofday(&_now,·NULL);

998

············gettimeofday(&_now,·NULL);

1000

············qemu_log("%d@%zu.%06zu:escc_soft_reset_chn·"·"soft·reset·channel·%c"·"\n",

1000

············qemu_log("%d@%zu.%06zu:escc_soft_reset_chn·"·"soft·reset·channel·%c"·"\n",

1001

·····················qemu_get_thread_id(),

1001

·····················qemu_get_thread_id(),

1002

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1002

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1003

·····················,·channel);

1003

·····················,·channel);

1004

#line·1006·"trace/trace-hw_char.h"

1004

#line·1006·"trace/trace-hw_char.h"

1005

········}·else·{

1005

········}·else·{

1007

············qemu_log("escc_soft_reset_chn·"·"soft·reset·channel·%c"·"\n",·channel);

1007

············qemu_log("escc_soft_reset_chn·"·"soft·reset·channel·%c"·"\n",·channel);

1008

#line·1010·"trace/trace-hw_char.h"

1008

#line·1010·"trace/trace-hw_char.h"

1009

········}

1009

········}

1010

····}

1010

····}

1011

}

1011

}

1012

static·inline·void·trace_escc_soft_reset_chn(char·channel)

1012

static·inline·void·trace_escc_soft_reset_chn(char·channel)

1024

static·inline·void·_nocheck__trace_escc_put_queue(char·channel,·int·b)

1024

static·inline·void·_nocheck__trace_escc_put_queue(char·channel,·int·b)

1025

{

1025

{

1026

····if·(trace_event_get_state(TRACE_ESCC_PUT_QUEUE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1026

····if·(trace_event_get_state(TRACE_ESCC_PUT_QUEUE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1027

········if·(message_with_timestamp)·{

1027

········if·(message_with_timestamp)·{

1028

············struct·timeval·_now;

1028

············struct·timeval·_now;

1029

············gettimeofday(&_now,·NULL);

1029

············gettimeofday(&_now,·NULL);

1031

············qemu_log("%d@%zu.%06zu:escc_put_queue·"·"channel·%c·put:·0x%02x"·"\n",

1031

············qemu_log("%d@%zu.%06zu:escc_put_queue·"·"channel·%c·put:·0x%02x"·"\n",

1032

·····················qemu_get_thread_id(),

1032

·····················qemu_get_thread_id(),

1033

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1033

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1034

·····················,·channel,·b);

1034

·····················,·channel,·b);

1035

#line·1037·"trace/trace-hw_char.h"

1035

#line·1037·"trace/trace-hw_char.h"

1036

········}·else·{

1036

········}·else·{

1038

············qemu_log("escc_put_queue·"·"channel·%c·put:·0x%02x"·"\n",·channel,·b);

1038

············qemu_log("escc_put_queue·"·"channel·%c·put:·0x%02x"·"\n",·channel,·b);

1039

#line·1041·"trace/trace-hw_char.h"

1039

#line·1041·"trace/trace-hw_char.h"

1040

········}

1040

········}

1041

····}

1041

····}

1042

}

1042

}

1043

static·inline·void·trace_escc_put_queue(char·channel,·int·b)

1043

static·inline·void·trace_escc_put_queue(char·channel,·int·b)

1055

static·inline·void·_nocheck__trace_escc_get_queue(char·channel,·int·val)

1055

static·inline·void·_nocheck__trace_escc_get_queue(char·channel,·int·val)

1056

{

1056

{

1057

····if·(trace_event_get_state(TRACE_ESCC_GET_QUEUE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1057

····if·(trace_event_get_state(TRACE_ESCC_GET_QUEUE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1058

········if·(message_with_timestamp)·{

1058

········if·(message_with_timestamp)·{

1059

············struct·timeval·_now;

1059

············struct·timeval·_now;

1060

············gettimeofday(&_now,·NULL);

1060

············gettimeofday(&_now,·NULL);

1062

············qemu_log("%d@%zu.%06zu:escc_get_queue·"·"channel·%c·get·0x%02x"·"\n",

1062

············qemu_log("%d@%zu.%06zu:escc_get_queue·"·"channel·%c·get·0x%02x"·"\n",

1063

·····················qemu_get_thread_id(),

1063

·····················qemu_get_thread_id(),

1064

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1064

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1065

·····················,·channel,·val);

1065

·····················,·channel,·val);

1066

#line·1068·"trace/trace-hw_char.h"

1066

#line·1068·"trace/trace-hw_char.h"

1067

········}·else·{

1067

········}·else·{

1069

············qemu_log("escc_get_queue·"·"channel·%c·get·0x%02x"·"\n",·channel,·val);

1069

············qemu_log("escc_get_queue·"·"channel·%c·get·0x%02x"·"\n",·channel,·val);

1070

#line·1072·"trace/trace-hw_char.h"

1070

#line·1072·"trace/trace-hw_char.h"

1071

········}

1071

········}

1072

····}

1072

····}

1073

}

1073

}

1074

static·inline·void·trace_escc_get_queue(char·channel,·int·val)

1074

static·inline·void·trace_escc_get_queue(char·channel,·int·val)

1086

static·inline·void·_nocheck__trace_escc_update_irq(int·irq)

1086

static·inline·void·_nocheck__trace_escc_update_irq(int·irq)

1087

{

1087

{

1088

····if·(trace_event_get_state(TRACE_ESCC_UPDATE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1088

····if·(trace_event_get_state(TRACE_ESCC_UPDATE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1089

········if·(message_with_timestamp)·{

1089

········if·(message_with_timestamp)·{

1090

············struct·timeval·_now;

1090

············struct·timeval·_now;

1091

············gettimeofday(&_now,·NULL);

1091

············gettimeofday(&_now,·NULL);

1093

············qemu_log("%d@%zu.%06zu:escc_update_irq·"·"IRQ·=·%d"·"\n",

1093

············qemu_log("%d@%zu.%06zu:escc_update_irq·"·"IRQ·=·%d"·"\n",

1094

·····················qemu_get_thread_id(),

1094

·····················qemu_get_thread_id(),

1095

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1095

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1096

·····················,·irq);

1096

·····················,·irq);

1097

#line·1099·"trace/trace-hw_char.h"

1097

#line·1099·"trace/trace-hw_char.h"

1098

········}·else·{

1098

········}·else·{

1100

············qemu_log("escc_update_irq·"·"IRQ·=·%d"·"\n",·irq);

1100

············qemu_log("escc_update_irq·"·"IRQ·=·%d"·"\n",·irq);

1101

#line·1103·"trace/trace-hw_char.h"

1101

#line·1103·"trace/trace-hw_char.h"

1102

········}

1102

········}

1103

····}

1103

····}

1104

}

1104

}

1105

static·inline·void·trace_escc_update_irq(int·irq)

1105

static·inline·void·trace_escc_update_irq(int·irq)

1117

static·inline·void·_nocheck__trace_escc_update_parameters(char·channel,·int·speed,·int·parity,·int·data_bits,·int·stop_bits)

1117

static·inline·void·_nocheck__trace_escc_update_parameters(char·channel,·int·speed,·int·parity,·int·data_bits,·int·stop_bits)

1118

{

1118

{

1119

····if·(trace_event_get_state(TRACE_ESCC_UPDATE_PARAMETERS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1119

····if·(trace_event_get_state(TRACE_ESCC_UPDATE_PARAMETERS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1120

········if·(message_with_timestamp)·{

1120

········if·(message_with_timestamp)·{

1121

············struct·timeval·_now;

1121

············struct·timeval·_now;

1122

············gettimeofday(&_now,·NULL);

1122

············gettimeofday(&_now,·NULL);

1124

············qemu_log("%d@%zu.%06zu:escc_update_parameters·"·"channel·%c:·speed=%d·parity=%c·data=%d·stop=%d"·"\n",

1124

············qemu_log("%d@%zu.%06zu:escc_update_parameters·"·"channel·%c:·speed=%d·parity=%c·data=%d·stop=%d"·"\n",

1125

·····················qemu_get_thread_id(),

1125

·····················qemu_get_thread_id(),

1126

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1126

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1127

·····················,·channel,·speed,·parity,·data_bits,·stop_bits);

1127

·····················,·channel,·speed,·parity,·data_bits,·stop_bits);

1128

#line·1130·"trace/trace-hw_char.h"

1128

#line·1130·"trace/trace-hw_char.h"

1129

········}·else·{

1129

········}·else·{

1131

············qemu_log("escc_update_parameters·"·"channel·%c:·speed=%d·parity=%c·data=%d·stop=%d"·"\n",·channel,·speed,·parity,·data_bits,·stop_bits);

1131

············qemu_log("escc_update_parameters·"·"channel·%c:·speed=%d·parity=%c·data=%d·stop=%d"·"\n",·channel,·speed,·parity,·data_bits,·stop_bits);

1132

#line·1134·"trace/trace-hw_char.h"

1132

#line·1134·"trace/trace-hw_char.h"

1133

········}

1133

········}

1134

····}

1134

····}

1135

}

1135

}

1136

static·inline·void·trace_escc_update_parameters(char·channel,·int·speed,·int·parity,·int·data_bits,·int·stop_bits)

1136

static·inline·void·trace_escc_update_parameters(char·channel,·int·speed,·int·parity,·int·data_bits,·int·stop_bits)

1148

static·inline·void·_nocheck__trace_escc_mem_writeb_ctrl(char·channel,·uint32_t·reg,·uint32_t·val)

1148

static·inline·void·_nocheck__trace_escc_mem_writeb_ctrl(char·channel,·uint32_t·reg,·uint32_t·val)

1149

{

1149

{

1150

····if·(trace_event_get_state(TRACE_ESCC_MEM_WRITEB_CTRL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1150

····if·(trace_event_get_state(TRACE_ESCC_MEM_WRITEB_CTRL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1151

········if·(message_with_timestamp)·{

1151

········if·(message_with_timestamp)·{

1152

············struct·timeval·_now;

1152

············struct·timeval·_now;

1153

············gettimeofday(&_now,·NULL);

1153

············gettimeofday(&_now,·NULL);

1155

············qemu_log("%d@%zu.%06zu:escc_mem_writeb_ctrl·"·"Write·channel·%c,·reg[%d]·=·0x%2.2x"·"\n",

1155

············qemu_log("%d@%zu.%06zu:escc_mem_writeb_ctrl·"·"Write·channel·%c,·reg[%d]·=·0x%2.2x"·"\n",

1156

·····················qemu_get_thread_id(),

1156

·····················qemu_get_thread_id(),

1157

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1157

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1158

·····················,·channel,·reg,·val);

1158

·····················,·channel,·reg,·val);

1159

#line·1161·"trace/trace-hw_char.h"

1159

#line·1161·"trace/trace-hw_char.h"

1160

········}·else·{

1160

········}·else·{

1162

············qemu_log("escc_mem_writeb_ctrl·"·"Write·channel·%c,·reg[%d]·=·0x%2.2x"·"\n",·channel,·reg,·val);

1162

············qemu_log("escc_mem_writeb_ctrl·"·"Write·channel·%c,·reg[%d]·=·0x%2.2x"·"\n",·channel,·reg,·val);

1163

#line·1165·"trace/trace-hw_char.h"

1163

#line·1165·"trace/trace-hw_char.h"

1164

········}

1164

········}

1165

····}

1165

····}

1166

}

1166

}

1167

static·inline·void·trace_escc_mem_writeb_ctrl(char·channel,·uint32_t·reg,·uint32_t·val)

1167

static·inline·void·trace_escc_mem_writeb_ctrl(char·channel,·uint32_t·reg,·uint32_t·val)

1179

static·inline·void·_nocheck__trace_escc_mem_writeb_data(char·channel,·uint32_t·val)

1179

static·inline·void·_nocheck__trace_escc_mem_writeb_data(char·channel,·uint32_t·val)

1180

{

1180

{

1181

····if·(trace_event_get_state(TRACE_ESCC_MEM_WRITEB_DATA)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1181

····if·(trace_event_get_state(TRACE_ESCC_MEM_WRITEB_DATA)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1182

········if·(message_with_timestamp)·{

1182

········if·(message_with_timestamp)·{

1183

············struct·timeval·_now;

1183

············struct·timeval·_now;

1184

············gettimeofday(&_now,·NULL);

1184

············gettimeofday(&_now,·NULL);

1186

············qemu_log("%d@%zu.%06zu:escc_mem_writeb_data·"·"Write·channel·%c,·ch·%d"·"\n",

1186

············qemu_log("%d@%zu.%06zu:escc_mem_writeb_data·"·"Write·channel·%c,·ch·%d"·"\n",

1187

·····················qemu_get_thread_id(),

1187

·····················qemu_get_thread_id(),

1188

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1188

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1189

·····················,·channel,·val);

1189

·····················,·channel,·val);

1190

#line·1192·"trace/trace-hw_char.h"

1190

#line·1192·"trace/trace-hw_char.h"

1191

········}·else·{

1191

········}·else·{

1193

············qemu_log("escc_mem_writeb_data·"·"Write·channel·%c,·ch·%d"·"\n",·channel,·val);

1193

············qemu_log("escc_mem_writeb_data·"·"Write·channel·%c,·ch·%d"·"\n",·channel,·val);

1194

#line·1196·"trace/trace-hw_char.h"

1194

#line·1196·"trace/trace-hw_char.h"

1195

········}

1195

········}

1196

····}

1196

····}

1197

}

1197

}

1198

static·inline·void·trace_escc_mem_writeb_data(char·channel,·uint32_t·val)

1198

static·inline·void·trace_escc_mem_writeb_data(char·channel,·uint32_t·val)

1210

static·inline·void·_nocheck__trace_escc_mem_readb_ctrl(char·channel,·uint32_t·reg,·uint8_t·val)

1210

static·inline·void·_nocheck__trace_escc_mem_readb_ctrl(char·channel,·uint32_t·reg,·uint8_t·val)

1211

{

1211

{

1212

····if·(trace_event_get_state(TRACE_ESCC_MEM_READB_CTRL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1212

····if·(trace_event_get_state(TRACE_ESCC_MEM_READB_CTRL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1213

········if·(message_with_timestamp)·{

1213

········if·(message_with_timestamp)·{

1214

············struct·timeval·_now;

1214

············struct·timeval·_now;

1215

············gettimeofday(&_now,·NULL);

1215

············gettimeofday(&_now,·NULL);

1217

············qemu_log("%d@%zu.%06zu:escc_mem_readb_ctrl·"·"Read·channel·%c,·reg[%d]·=·0x%2.2x"·"\n",

1217

············qemu_log("%d@%zu.%06zu:escc_mem_readb_ctrl·"·"Read·channel·%c,·reg[%d]·=·0x%2.2x"·"\n",

1218

·····················qemu_get_thread_id(),

1218

·····················qemu_get_thread_id(),

1219

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1219

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1220

·····················,·channel,·reg,·val);

1220

·····················,·channel,·reg,·val);

1221

#line·1223·"trace/trace-hw_char.h"

1221

#line·1223·"trace/trace-hw_char.h"

1222

········}·else·{

1222

········}·else·{

1224

············qemu_log("escc_mem_readb_ctrl·"·"Read·channel·%c,·reg[%d]·=·0x%2.2x"·"\n",·channel,·reg,·val);

1224

············qemu_log("escc_mem_readb_ctrl·"·"Read·channel·%c,·reg[%d]·=·0x%2.2x"·"\n",·channel,·reg,·val);

1225

#line·1227·"trace/trace-hw_char.h"

1225

#line·1227·"trace/trace-hw_char.h"

1226

········}

1226

········}

1227

····}

1227

····}

1228

}

1228

}

1229

static·inline·void·trace_escc_mem_readb_ctrl(char·channel,·uint32_t·reg,·uint8_t·val)

1229

static·inline·void·trace_escc_mem_readb_ctrl(char·channel,·uint32_t·reg,·uint8_t·val)

1241

static·inline·void·_nocheck__trace_escc_mem_readb_data(char·channel,·uint32_t·ret)

1241

static·inline·void·_nocheck__trace_escc_mem_readb_data(char·channel,·uint32_t·ret)

1242

{

1242

{

1243

····if·(trace_event_get_state(TRACE_ESCC_MEM_READB_DATA)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1243

····if·(trace_event_get_state(TRACE_ESCC_MEM_READB_DATA)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1244

········if·(message_with_timestamp)·{

1244

········if·(message_with_timestamp)·{

1245

············struct·timeval·_now;

1245

············struct·timeval·_now;

1246

············gettimeofday(&_now,·NULL);

1246

············gettimeofday(&_now,·NULL);

1248

············qemu_log("%d@%zu.%06zu:escc_mem_readb_data·"·"Read·channel·%c,·ch·%d"·"\n",

1248

············qemu_log("%d@%zu.%06zu:escc_mem_readb_data·"·"Read·channel·%c,·ch·%d"·"\n",

1249

·····················qemu_get_thread_id(),

1249

·····················qemu_get_thread_id(),

1250

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1250

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1251

·····················,·channel,·ret);

1251

·····················,·channel,·ret);

1252

#line·1254·"trace/trace-hw_char.h"

1252

#line·1254·"trace/trace-hw_char.h"

1253

········}·else·{

1253

········}·else·{

1255

············qemu_log("escc_mem_readb_data·"·"Read·channel·%c,·ch·%d"·"\n",·channel,·ret);

1255

············qemu_log("escc_mem_readb_data·"·"Read·channel·%c,·ch·%d"·"\n",·channel,·ret);

1256

#line·1258·"trace/trace-hw_char.h"

1256

#line·1258·"trace/trace-hw_char.h"

1257

········}

1257

········}

1258

····}

1258

····}

1259

}

1259

}

1260

static·inline·void·trace_escc_mem_readb_data(char·channel,·uint32_t·ret)

1260

static·inline·void·trace_escc_mem_readb_data(char·channel,·uint32_t·ret)

1272

static·inline·void·_nocheck__trace_escc_serial_receive_byte(char·channel,·int·ch)

1272

static·inline·void·_nocheck__trace_escc_serial_receive_byte(char·channel,·int·ch)

1273

{

1273

{

1274

····if·(trace_event_get_state(TRACE_ESCC_SERIAL_RECEIVE_BYTE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1274

····if·(trace_event_get_state(TRACE_ESCC_SERIAL_RECEIVE_BYTE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1275

········if·(message_with_timestamp)·{

1275

········if·(message_with_timestamp)·{

1276

············struct·timeval·_now;

1276

············struct·timeval·_now;

1277

············gettimeofday(&_now,·NULL);

1277

············gettimeofday(&_now,·NULL);

1279

············qemu_log("%d@%zu.%06zu:escc_serial_receive_byte·"·"channel·%c·put·ch·%d"·"\n",

1279

············qemu_log("%d@%zu.%06zu:escc_serial_receive_byte·"·"channel·%c·put·ch·%d"·"\n",

1280

·····················qemu_get_thread_id(),

1280

·····················qemu_get_thread_id(),

1281

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1281

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1282

·····················,·channel,·ch);

1282

·····················,·channel,·ch);

1283

#line·1285·"trace/trace-hw_char.h"

1283

#line·1285·"trace/trace-hw_char.h"

1284

········}·else·{

1284

········}·else·{

1286

············qemu_log("escc_serial_receive_byte·"·"channel·%c·put·ch·%d"·"\n",·channel,·ch);

1286

············qemu_log("escc_serial_receive_byte·"·"channel·%c·put·ch·%d"·"\n",·channel,·ch);

1287

#line·1289·"trace/trace-hw_char.h"

1287

#line·1289·"trace/trace-hw_char.h"

1288

········}

1288

········}

1289

····}

1289

····}

1290

}

1290

}

1291

static·inline·void·trace_escc_serial_receive_byte(char·channel,·int·ch)

1291

static·inline·void·trace_escc_serial_receive_byte(char·channel,·int·ch)

1303

static·inline·void·_nocheck__trace_escc_sunkbd_event_in(int·ch,·const·char·*·name,·int·down)

1303

static·inline·void·_nocheck__trace_escc_sunkbd_event_in(int·ch,·const·char·*·name,·int·down)

1304

{

1304

{

1305

····if·(trace_event_get_state(TRACE_ESCC_SUNKBD_EVENT_IN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1305

····if·(trace_event_get_state(TRACE_ESCC_SUNKBD_EVENT_IN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1306

········if·(message_with_timestamp)·{

1306

········if·(message_with_timestamp)·{

1307

············struct·timeval·_now;

1307

············struct·timeval·_now;

1308

············gettimeofday(&_now,·NULL);

1308

············gettimeofday(&_now,·NULL);

1310

············qemu_log("%d@%zu.%06zu:escc_sunkbd_event_in·"·"QKeyCode·0x%2.2x·[%s],·down·%d"·"\n",

1310

············qemu_log("%d@%zu.%06zu:escc_sunkbd_event_in·"·"QKeyCode·0x%2.2x·[%s],·down·%d"·"\n",

1311

·····················qemu_get_thread_id(),

1311

·····················qemu_get_thread_id(),

1312

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1312

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1313

·····················,·ch,·name,·down);

1313

·····················,·ch,·name,·down);

1314

#line·1316·"trace/trace-hw_char.h"

1314

#line·1316·"trace/trace-hw_char.h"

1315

········}·else·{

1315

········}·else·{

1317

············qemu_log("escc_sunkbd_event_in·"·"QKeyCode·0x%2.2x·[%s],·down·%d"·"\n",·ch,·name,·down);

1317

············qemu_log("escc_sunkbd_event_in·"·"QKeyCode·0x%2.2x·[%s],·down·%d"·"\n",·ch,·name,·down);

1318

#line·1320·"trace/trace-hw_char.h"

1318

#line·1320·"trace/trace-hw_char.h"

1319

········}

1319

········}

1320

····}

1320

····}

1321

}

1321

}

1322

static·inline·void·trace_escc_sunkbd_event_in(int·ch,·const·char·*·name,·int·down)

1322

static·inline·void·trace_escc_sunkbd_event_in(int·ch,·const·char·*·name,·int·down)

1334

static·inline·void·_nocheck__trace_escc_sunkbd_event_out(int·ch)

1334

static·inline·void·_nocheck__trace_escc_sunkbd_event_out(int·ch)

1335

{

1335

{

1336

····if·(trace_event_get_state(TRACE_ESCC_SUNKBD_EVENT_OUT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1336

····if·(trace_event_get_state(TRACE_ESCC_SUNKBD_EVENT_OUT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1337

········if·(message_with_timestamp)·{

1337

········if·(message_with_timestamp)·{

1338

············struct·timeval·_now;

1338

············struct·timeval·_now;

1339

············gettimeofday(&_now,·NULL);

1339

············gettimeofday(&_now,·NULL);

1341

············qemu_log("%d@%zu.%06zu:escc_sunkbd_event_out·"·"Translated·keycode·0x%2.2x"·"\n",

1341

············qemu_log("%d@%zu.%06zu:escc_sunkbd_event_out·"·"Translated·keycode·0x%2.2x"·"\n",

1342

·····················qemu_get_thread_id(),

1342

·····················qemu_get_thread_id(),

1343

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1343

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1344

·····················,·ch);

1344

·····················,·ch);

1345

#line·1347·"trace/trace-hw_char.h"

1345

#line·1347·"trace/trace-hw_char.h"

1346

········}·else·{

1346

········}·else·{

1348

············qemu_log("escc_sunkbd_event_out·"·"Translated·keycode·0x%2.2x"·"\n",·ch);

1348

············qemu_log("escc_sunkbd_event_out·"·"Translated·keycode·0x%2.2x"·"\n",·ch);

1349

#line·1351·"trace/trace-hw_char.h"

1349

#line·1351·"trace/trace-hw_char.h"

1350

········}

1350

········}

1351

····}

1351

····}

1352

}

1352

}

1353

static·inline·void·trace_escc_sunkbd_event_out(int·ch)

1353

static·inline·void·trace_escc_sunkbd_event_out(int·ch)

1365

static·inline·void·_nocheck__trace_escc_kbd_command(int·val)

1365

static·inline·void·_nocheck__trace_escc_kbd_command(int·val)

1366

{

1366

{

1367

····if·(trace_event_get_state(TRACE_ESCC_KBD_COMMAND)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1367

····if·(trace_event_get_state(TRACE_ESCC_KBD_COMMAND)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1368

········if·(message_with_timestamp)·{

1368

········if·(message_with_timestamp)·{

1369

············struct·timeval·_now;

1369

············struct·timeval·_now;

1370

············gettimeofday(&_now,·NULL);

1370

············gettimeofday(&_now,·NULL);

1372

············qemu_log("%d@%zu.%06zu:escc_kbd_command·"·"Command·%d"·"\n",

1372

············qemu_log("%d@%zu.%06zu:escc_kbd_command·"·"Command·%d"·"\n",

1373

·····················qemu_get_thread_id(),

1373

·····················qemu_get_thread_id(),

1374

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1374

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1375

·····················,·val);

1375

·····················,·val);

1376

#line·1378·"trace/trace-hw_char.h"

1376

#line·1378·"trace/trace-hw_char.h"

1377

········}·else·{

1377

········}·else·{

1379

············qemu_log("escc_kbd_command·"·"Command·%d"·"\n",·val);

1379

············qemu_log("escc_kbd_command·"·"Command·%d"·"\n",·val);

1380

#line·1382·"trace/trace-hw_char.h"

1380

#line·1382·"trace/trace-hw_char.h"

1381

········}

1381

········}

1382

····}

1382

····}

1383

}

1383

}

1384

static·inline·void·trace_escc_kbd_command(int·val)

1384

static·inline·void·trace_escc_kbd_command(int·val)

1396

static·inline·void·_nocheck__trace_escc_sunmouse_event(int·dx,·int·dy,·int·buttons_state)

1396

static·inline·void·_nocheck__trace_escc_sunmouse_event(int·dx,·int·dy,·int·buttons_state)

1397

{

1397

{

1398

····if·(trace_event_get_state(TRACE_ESCC_SUNMOUSE_EVENT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1398

····if·(trace_event_get_state(TRACE_ESCC_SUNMOUSE_EVENT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1399

········if·(message_with_timestamp)·{

1399

········if·(message_with_timestamp)·{

1400

············struct·timeval·_now;

1400

············struct·timeval·_now;

1401

············gettimeofday(&_now,·NULL);

1401

············gettimeofday(&_now,·NULL);

1403

············qemu_log("%d@%zu.%06zu:escc_sunmouse_event·"·"dx=%d·dy=%d·buttons=0x%01x"·"\n",

1403

············qemu_log("%d@%zu.%06zu:escc_sunmouse_event·"·"dx=%d·dy=%d·buttons=0x%01x"·"\n",

1404

·····················qemu_get_thread_id(),

1404

·····················qemu_get_thread_id(),

1405

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1405

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1406

·····················,·dx,·dy,·buttons_state);

1406

·····················,·dx,·dy,·buttons_state);

1407

#line·1409·"trace/trace-hw_char.h"

1407

#line·1409·"trace/trace-hw_char.h"

1408

········}·else·{

1408

········}·else·{

1410

············qemu_log("escc_sunmouse_event·"·"dx=%d·dy=%d·buttons=0x%01x"·"\n",·dx,·dy,·buttons_state);

1410

············qemu_log("escc_sunmouse_event·"·"dx=%d·dy=%d·buttons=0x%01x"·"\n",·dx,·dy,·buttons_state);

1411

#line·1413·"trace/trace-hw_char.h"

1411

#line·1413·"trace/trace-hw_char.h"

1412

········}

1412

········}

1413

····}

1413

····}

1414

}

1414

}

1415

static·inline·void·trace_escc_sunmouse_event(int·dx,·int·dy,·int·buttons_state)

1415

static·inline·void·trace_escc_sunmouse_event(int·dx,·int·dy,·int·buttons_state)

1427

static·inline·void·_nocheck__trace_pl011_irq_state(int·level)

1427

static·inline·void·_nocheck__trace_pl011_irq_state(int·level)

1428

{

1428

{

1429

····if·(trace_event_get_state(TRACE_PL011_IRQ_STATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1429

····if·(trace_event_get_state(TRACE_PL011_IRQ_STATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1430

········if·(message_with_timestamp)·{

1430

········if·(message_with_timestamp)·{

1431

············struct·timeval·_now;

1431

············struct·timeval·_now;

1432

············gettimeofday(&_now,·NULL);

1432

············gettimeofday(&_now,·NULL);

1434

············qemu_log("%d@%zu.%06zu:pl011_irq_state·"·"irq·state·%d"·"\n",

1434

············qemu_log("%d@%zu.%06zu:pl011_irq_state·"·"irq·state·%d"·"\n",

1435

·····················qemu_get_thread_id(),

1435

·····················qemu_get_thread_id(),

1436

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1436

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1437

·····················,·level);

1437

·····················,·level);

1438

#line·1440·"trace/trace-hw_char.h"

1438

#line·1440·"trace/trace-hw_char.h"

1439

········}·else·{

1439

········}·else·{

1441

············qemu_log("pl011_irq_state·"·"irq·state·%d"·"\n",·level);

1441

············qemu_log("pl011_irq_state·"·"irq·state·%d"·"\n",·level);

1442

#line·1444·"trace/trace-hw_char.h"

1442

#line·1444·"trace/trace-hw_char.h"

1443

········}

1443

········}

1444

····}

1444

····}

1445

}

1445

}

1446

static·inline·void·trace_pl011_irq_state(int·level)

1446

static·inline·void·trace_pl011_irq_state(int·level)

1458

static·inline·void·_nocheck__trace_pl011_read(uint32_t·addr,·uint32_t·value)

1458

static·inline·void·_nocheck__trace_pl011_read(uint32_t·addr,·uint32_t·value)

1459

{

1459

{

1460

····if·(trace_event_get_state(TRACE_PL011_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1460

····if·(trace_event_get_state(TRACE_PL011_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1461

········if·(message_with_timestamp)·{

1461

········if·(message_with_timestamp)·{

1462

············struct·timeval·_now;

1462

············struct·timeval·_now;

1463

············gettimeofday(&_now,·NULL);

1463

············gettimeofday(&_now,·NULL);

1465

············qemu_log("%d@%zu.%06zu:pl011_read·"·"addr·0x%08x·value·0x%08x"·"\n",

1465

············qemu_log("%d@%zu.%06zu:pl011_read·"·"addr·0x%08x·value·0x%08x"·"\n",

1466

·····················qemu_get_thread_id(),

1466

·····················qemu_get_thread_id(),

1467

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1467

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1468

·····················,·addr,·value);

1468

·····················,·addr,·value);

1469

#line·1471·"trace/trace-hw_char.h"

1469

#line·1471·"trace/trace-hw_char.h"

1470

········}·else·{

1470

········}·else·{

1472

············qemu_log("pl011_read·"·"addr·0x%08x·value·0x%08x"·"\n",·addr,·value);

1472

············qemu_log("pl011_read·"·"addr·0x%08x·value·0x%08x"·"\n",·addr,·value);

1473

#line·1475·"trace/trace-hw_char.h"

1473

#line·1475·"trace/trace-hw_char.h"

1474

········}

1474

········}

1475

····}

1475

····}

1476

}

1476

}

1477

static·inline·void·trace_pl011_read(uint32_t·addr,·uint32_t·value)

1477

static·inline·void·trace_pl011_read(uint32_t·addr,·uint32_t·value)

1489

static·inline·void·_nocheck__trace_pl011_read_fifo(int·read_count)

1489

static·inline·void·_nocheck__trace_pl011_read_fifo(int·read_count)

1490

{

1490

{

1491

····if·(trace_event_get_state(TRACE_PL011_READ_FIFO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1491

····if·(trace_event_get_state(TRACE_PL011_READ_FIFO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1492

········if·(message_with_timestamp)·{

1492

········if·(message_with_timestamp)·{

1493

············struct·timeval·_now;

1493

············struct·timeval·_now;

1494

············gettimeofday(&_now,·NULL);

1494

············gettimeofday(&_now,·NULL);

1496

············qemu_log("%d@%zu.%06zu:pl011_read_fifo·"·"FIFO·read,·read_count·now·%d"·"\n",

1496

············qemu_log("%d@%zu.%06zu:pl011_read_fifo·"·"FIFO·read,·read_count·now·%d"·"\n",

1497

·····················qemu_get_thread_id(),

1497

·····················qemu_get_thread_id(),

1498

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1498

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1499

·····················,·read_count);

1499

·····················,·read_count);

1500

#line·1502·"trace/trace-hw_char.h"

1500

#line·1502·"trace/trace-hw_char.h"

1501

········}·else·{

1501

········}·else·{

1503

············qemu_log("pl011_read_fifo·"·"FIFO·read,·read_count·now·%d"·"\n",·read_count);

1503

············qemu_log("pl011_read_fifo·"·"FIFO·read,·read_count·now·%d"·"\n",·read_count);

1504

#line·1506·"trace/trace-hw_char.h"

1504

#line·1506·"trace/trace-hw_char.h"

1505

········}

1505

········}

1506

····}

1506

····}

1507

}

1507

}

1508

static·inline·void·trace_pl011_read_fifo(int·read_count)

1508

static·inline·void·trace_pl011_read_fifo(int·read_count)

1520

static·inline·void·_nocheck__trace_pl011_write(uint32_t·addr,·uint32_t·value)

1520

static·inline·void·_nocheck__trace_pl011_write(uint32_t·addr,·uint32_t·value)

1521

{

1521

{

1522

····if·(trace_event_get_state(TRACE_PL011_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1522

····if·(trace_event_get_state(TRACE_PL011_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1523

········if·(message_with_timestamp)·{

1523

········if·(message_with_timestamp)·{

1524

············struct·timeval·_now;

1524

············struct·timeval·_now;

1525

············gettimeofday(&_now,·NULL);

1525

············gettimeofday(&_now,·NULL);

1527

············qemu_log("%d@%zu.%06zu:pl011_write·"·"addr·0x%08x·value·0x%08x"·"\n",

1527

············qemu_log("%d@%zu.%06zu:pl011_write·"·"addr·0x%08x·value·0x%08x"·"\n",

1528

·····················qemu_get_thread_id(),

1528

·····················qemu_get_thread_id(),

1529

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1529

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1530

·····················,·addr,·value);

1530

·····················,·addr,·value);

1531

#line·1533·"trace/trace-hw_char.h"

1531

#line·1533·"trace/trace-hw_char.h"

1532

········}·else·{

1532

········}·else·{

1534

············qemu_log("pl011_write·"·"addr·0x%08x·value·0x%08x"·"\n",·addr,·value);

1534

············qemu_log("pl011_write·"·"addr·0x%08x·value·0x%08x"·"\n",·addr,·value);

1535

#line·1537·"trace/trace-hw_char.h"

1535

#line·1537·"trace/trace-hw_char.h"

1536

········}

1536

········}

1537

····}

1537

····}

1538

}

1538

}

1539

static·inline·void·trace_pl011_write(uint32_t·addr,·uint32_t·value)

1539

static·inline·void·trace_pl011_write(uint32_t·addr,·uint32_t·value)

1551

static·inline·void·_nocheck__trace_pl011_can_receive(uint32_t·lcr,·int·read_count,·int·r)

1551

static·inline·void·_nocheck__trace_pl011_can_receive(uint32_t·lcr,·int·read_count,·int·r)

1552

{

1552

{

1553

····if·(trace_event_get_state(TRACE_PL011_CAN_RECEIVE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1553

····if·(trace_event_get_state(TRACE_PL011_CAN_RECEIVE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1554

········if·(message_with_timestamp)·{

1554

········if·(message_with_timestamp)·{

1555

············struct·timeval·_now;

1555

············struct·timeval·_now;

1556

············gettimeofday(&_now,·NULL);

1556

············gettimeofday(&_now,·NULL);

1558

············qemu_log("%d@%zu.%06zu:pl011_can_receive·"·"LCR·0x%08x·read_count·%d·returning·%d"·"\n",

1558

············qemu_log("%d@%zu.%06zu:pl011_can_receive·"·"LCR·0x%08x·read_count·%d·returning·%d"·"\n",

1559

·····················qemu_get_thread_id(),

1559

·····················qemu_get_thread_id(),

1560

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1560

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1561

·····················,·lcr,·read_count,·r);

1561

·····················,·lcr,·read_count,·r);

1562

#line·1564·"trace/trace-hw_char.h"

1562

#line·1564·"trace/trace-hw_char.h"

1563

········}·else·{

1563

········}·else·{

1565

············qemu_log("pl011_can_receive·"·"LCR·0x%08x·read_count·%d·returning·%d"·"\n",·lcr,·read_count,·r);

1565

············qemu_log("pl011_can_receive·"·"LCR·0x%08x·read_count·%d·returning·%d"·"\n",·lcr,·read_count,·r);

1566

#line·1568·"trace/trace-hw_char.h"

1566

#line·1568·"trace/trace-hw_char.h"

1567

········}

1567

········}

1568

····}

1568

····}

1569

}

1569

}

1570

static·inline·void·trace_pl011_can_receive(uint32_t·lcr,·int·read_count,·int·r)

1570

static·inline·void·trace_pl011_can_receive(uint32_t·lcr,·int·read_count,·int·r)

1582

static·inline·void·_nocheck__trace_pl011_put_fifo(uint32_t·c,·int·read_count)

1582

static·inline·void·_nocheck__trace_pl011_put_fifo(uint32_t·c,·int·read_count)

1583

{

1583

{

1584

····if·(trace_event_get_state(TRACE_PL011_PUT_FIFO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1584

····if·(trace_event_get_state(TRACE_PL011_PUT_FIFO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1585

········if·(message_with_timestamp)·{

1585

········if·(message_with_timestamp)·{

1586

············struct·timeval·_now;

1586

············struct·timeval·_now;

1587

············gettimeofday(&_now,·NULL);

1587

············gettimeofday(&_now,·NULL);

1589

············qemu_log("%d@%zu.%06zu:pl011_put_fifo·"·"new·char·0x%x·read_count·now·%d"·"\n",

1589

············qemu_log("%d@%zu.%06zu:pl011_put_fifo·"·"new·char·0x%x·read_count·now·%d"·"\n",

1590

·····················qemu_get_thread_id(),

1590

·····················qemu_get_thread_id(),

1591

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1591

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1592

·····················,·c,·read_count);

1592

·····················,·c,·read_count);

1593

#line·1595·"trace/trace-hw_char.h"

1593

#line·1595·"trace/trace-hw_char.h"

1594

········}·else·{

1594

········}·else·{

1596

············qemu_log("pl011_put_fifo·"·"new·char·0x%x·read_count·now·%d"·"\n",·c,·read_count);

1596

············qemu_log("pl011_put_fifo·"·"new·char·0x%x·read_count·now·%d"·"\n",·c,·read_count);

1597

#line·1599·"trace/trace-hw_char.h"

1597

#line·1599·"trace/trace-hw_char.h"

1598

········}

1598

········}

1599

····}

1599

····}

1600

}

1600

}

1601

static·inline·void·trace_pl011_put_fifo(uint32_t·c,·int·read_count)

1601

static·inline·void·trace_pl011_put_fifo(uint32_t·c,·int·read_count)

1613

static·inline·void·_nocheck__trace_pl011_put_fifo_full(void)

1613

static·inline·void·_nocheck__trace_pl011_put_fifo_full(void)

1614

{

1614

{

1615

····if·(trace_event_get_state(TRACE_PL011_PUT_FIFO_FULL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1615

····if·(trace_event_get_state(TRACE_PL011_PUT_FIFO_FULL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1616

········if·(message_with_timestamp)·{

1616

········if·(message_with_timestamp)·{

1617

············struct·timeval·_now;

1617

············struct·timeval·_now;

1618

············gettimeofday(&_now,·NULL);

1618

············gettimeofday(&_now,·NULL);

1620

············qemu_log("%d@%zu.%06zu:pl011_put_fifo_full·"·"FIFO·now·full,·RXFF·set"·"\n",

1620

············qemu_log("%d@%zu.%06zu:pl011_put_fifo_full·"·"FIFO·now·full,·RXFF·set"·"\n",

1621

·····················qemu_get_thread_id(),

1621

·····················qemu_get_thread_id(),

1622

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1622

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1623

·····················);

1623

·····················);

1624

#line·1626·"trace/trace-hw_char.h"

1624

#line·1626·"trace/trace-hw_char.h"

1625

········}·else·{

1625

········}·else·{

1627

············qemu_log("pl011_put_fifo_full·"·"FIFO·now·full,·RXFF·set"·"\n");

1627

············qemu_log("pl011_put_fifo_full·"·"FIFO·now·full,·RXFF·set"·"\n");

1628

#line·1630·"trace/trace-hw_char.h"

1628

#line·1630·"trace/trace-hw_char.h"

1629

········}

1629

········}

1630

····}

1630

····}

1631

}

1631

}

1632

static·inline·void·trace_pl011_put_fifo_full(void)

1632

static·inline·void·trace_pl011_put_fifo_full(void)

1644

static·inline·void·_nocheck__trace_pl011_baudrate_change(unsigned·int·baudrate,·uint64_t·clock,·uint32_t·ibrd,·uint32_t·fbrd)

1644

static·inline·void·_nocheck__trace_pl011_baudrate_change(unsigned·int·baudrate,·uint64_t·clock,·uint32_t·ibrd,·uint32_t·fbrd)

1645

{

1645

{

1646

····if·(trace_event_get_state(TRACE_PL011_BAUDRATE_CHANGE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1646

····if·(trace_event_get_state(TRACE_PL011_BAUDRATE_CHANGE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1647

········if·(message_with_timestamp)·{

1647

········if·(message_with_timestamp)·{

1648

············struct·timeval·_now;

1648

············struct·timeval·_now;

1649

············gettimeofday(&_now,·NULL);

1649

············gettimeofday(&_now,·NULL);

1651

············qemu_log("%d@%zu.%06zu:pl011_baudrate_change·"·"new·baudrate·%u·(clk:·%"·PRIu64·"hz,·ibrd:·%"·PRIu32·",·fbrd:·%"·PRIu32·")"·"\n",

1651

············qemu_log("%d@%zu.%06zu:pl011_baudrate_change·"·"new·baudrate·%u·(clk:·%"·PRIu64·"hz,·ibrd:·%"·PRIu32·",·fbrd:·%"·PRIu32·")"·"\n",

1652

·····················qemu_get_thread_id(),

1652

·····················qemu_get_thread_id(),

1653

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1653

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1654

·····················,·baudrate,·clock,·ibrd,·fbrd);

1654

·····················,·baudrate,·clock,·ibrd,·fbrd);

1655

#line·1657·"trace/trace-hw_char.h"

1655

#line·1657·"trace/trace-hw_char.h"

1656

········}·else·{

1656

········}·else·{

1658

············qemu_log("pl011_baudrate_change·"·"new·baudrate·%u·(clk:·%"·PRIu64·"hz,·ibrd:·%"·PRIu32·",·fbrd:·%"·PRIu32·")"·"\n",·baudrate,·clock,·ibrd,·fbrd);

1658

············qemu_log("pl011_baudrate_change·"·"new·baudrate·%u·(clk:·%"·PRIu64·"hz,·ibrd:·%"·PRIu32·",·fbrd:·%"·PRIu32·")"·"\n",·baudrate,·clock,·ibrd,·fbrd);

1659

#line·1661·"trace/trace-hw_char.h"

1659

#line·1661·"trace/trace-hw_char.h"

1660

········}

1660

········}

1661

····}

1661

····}

1662

}

1662

}

1663

static·inline·void·trace_pl011_baudrate_change(unsigned·int·baudrate,·uint64_t·clock,·uint32_t·ibrd,·uint32_t·fbrd)

1663

static·inline·void·trace_pl011_baudrate_change(unsigned·int·baudrate,·uint64_t·clock,·uint32_t·ibrd,·uint32_t·fbrd)

1675

static·inline·void·_nocheck__trace_cmsdk_apb_uart_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1675

static·inline·void·_nocheck__trace_cmsdk_apb_uart_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1676

{

1676

{

1677

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1677

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1678

········if·(message_with_timestamp)·{

1678

········if·(message_with_timestamp)·{

1679

············struct·timeval·_now;

1679

············struct·timeval·_now;

1680

············gettimeofday(&_now,·NULL);

1680

············gettimeofday(&_now,·NULL);

1682

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_read·"·"CMSDK·APB·UART·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

1682

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_read·"·"CMSDK·APB·UART·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

1683

·····················qemu_get_thread_id(),

1683

·····················qemu_get_thread_id(),

1684

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1684

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1685

·····················,·offset,·data,·size);

1685

·····················,·offset,·data,·size);

1686

#line·1688·"trace/trace-hw_char.h"

1686

#line·1688·"trace/trace-hw_char.h"

1687

········}·else·{

1687

········}·else·{

1689

············qemu_log("cmsdk_apb_uart_read·"·"CMSDK·APB·UART·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

1689

············qemu_log("cmsdk_apb_uart_read·"·"CMSDK·APB·UART·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

1690

#line·1692·"trace/trace-hw_char.h"

1690

#line·1692·"trace/trace-hw_char.h"

1691

········}

1691

········}

1692

····}

1692

····}

1693

}

1693

}

1694

static·inline·void·trace_cmsdk_apb_uart_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1694

static·inline·void·trace_cmsdk_apb_uart_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1706

static·inline·void·_nocheck__trace_cmsdk_apb_uart_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

1706

static·inline·void·_nocheck__trace_cmsdk_apb_uart_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

1707

{

1707

{

1708

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1708

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1709

········if·(message_with_timestamp)·{

1709

········if·(message_with_timestamp)·{

1710

············struct·timeval·_now;

1710

············struct·timeval·_now;

1711

············gettimeofday(&_now,·NULL);

1711

············gettimeofday(&_now,·NULL);

1713

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_write·"·"CMSDK·APB·UART·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

1713

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_write·"·"CMSDK·APB·UART·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

1714

·····················qemu_get_thread_id(),

1714

·····················qemu_get_thread_id(),

1715

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1715

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1716

·····················,·offset,·data,·size);

1716

·····················,·offset,·data,·size);

1717

#line·1719·"trace/trace-hw_char.h"

1717

#line·1719·"trace/trace-hw_char.h"

1718

········}·else·{

1718

········}·else·{

1720

············qemu_log("cmsdk_apb_uart_write·"·"CMSDK·APB·UART·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

1720

············qemu_log("cmsdk_apb_uart_write·"·"CMSDK·APB·UART·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

1721

#line·1723·"trace/trace-hw_char.h"

1721

#line·1723·"trace/trace-hw_char.h"

1722

········}

1722

········}

1723

····}

1723

····}

1724

}

1724

}

1725

static·inline·void·trace_cmsdk_apb_uart_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

1725

static·inline·void·trace_cmsdk_apb_uart_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

1737

static·inline·void·_nocheck__trace_cmsdk_apb_uart_reset(void)

1737

static·inline·void·_nocheck__trace_cmsdk_apb_uart_reset(void)

1738

{

1738

{

1739

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1739

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1740

········if·(message_with_timestamp)·{

1740

········if·(message_with_timestamp)·{

1741

············struct·timeval·_now;

1741

············struct·timeval·_now;

1742

············gettimeofday(&_now,·NULL);

1742

············gettimeofday(&_now,·NULL);

1744

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_reset·"·"CMSDK·APB·UART:·reset"·"\n",

1744

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_reset·"·"CMSDK·APB·UART:·reset"·"\n",

1745

·····················qemu_get_thread_id(),

1745

·····················qemu_get_thread_id(),

1746

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1746

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1747

·····················);

1747

·····················);

1748

#line·1750·"trace/trace-hw_char.h"

1748

#line·1750·"trace/trace-hw_char.h"

1749

········}·else·{

1749

········}·else·{

1751

············qemu_log("cmsdk_apb_uart_reset·"·"CMSDK·APB·UART:·reset"·"\n");

1751

············qemu_log("cmsdk_apb_uart_reset·"·"CMSDK·APB·UART:·reset"·"\n");

1752

#line·1754·"trace/trace-hw_char.h"

1752

#line·1754·"trace/trace-hw_char.h"

1753

········}

1753

········}

1754

····}

1754

····}

1755

}

1755

}

1756

static·inline·void·trace_cmsdk_apb_uart_reset(void)

1756

static·inline·void·trace_cmsdk_apb_uart_reset(void)

1768

static·inline·void·_nocheck__trace_cmsdk_apb_uart_receive(uint8_t·c)

1768

static·inline·void·_nocheck__trace_cmsdk_apb_uart_receive(uint8_t·c)

1769

{

1769

{

1770

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_RECEIVE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1770

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_RECEIVE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1771

········if·(message_with_timestamp)·{

1771

········if·(message_with_timestamp)·{

1772

············struct·timeval·_now;

1772

············struct·timeval·_now;

1773

············gettimeofday(&_now,·NULL);

1773

············gettimeofday(&_now,·NULL);

1775

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_receive·"·"CMSDK·APB·UART:·got·character·0x%x·from·backend"·"\n",

1775

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_receive·"·"CMSDK·APB·UART:·got·character·0x%x·from·backend"·"\n",

1776

·····················qemu_get_thread_id(),

1776

·····················qemu_get_thread_id(),

1777

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1777

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1778

·····················,·c);

1778

·····················,·c);

1779

#line·1781·"trace/trace-hw_char.h"

1779

#line·1781·"trace/trace-hw_char.h"

1780

········}·else·{

1780

········}·else·{

1782

············qemu_log("cmsdk_apb_uart_receive·"·"CMSDK·APB·UART:·got·character·0x%x·from·backend"·"\n",·c);

1782

············qemu_log("cmsdk_apb_uart_receive·"·"CMSDK·APB·UART:·got·character·0x%x·from·backend"·"\n",·c);

1783

#line·1785·"trace/trace-hw_char.h"

1783

#line·1785·"trace/trace-hw_char.h"

1784

········}

1784

········}

1785

····}

1785

····}

1786

}

1786

}

1787

static·inline·void·trace_cmsdk_apb_uart_receive(uint8_t·c)

1787

static·inline·void·trace_cmsdk_apb_uart_receive(uint8_t·c)

1799

static·inline·void·_nocheck__trace_cmsdk_apb_uart_tx_pending(void)

1799

static·inline·void·_nocheck__trace_cmsdk_apb_uart_tx_pending(void)

1800

{

1800

{

1801

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_TX_PENDING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1801

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_TX_PENDING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1802

········if·(message_with_timestamp)·{

1802

········if·(message_with_timestamp)·{

1803

············struct·timeval·_now;

1803

············struct·timeval·_now;

1804

············gettimeofday(&_now,·NULL);

1804

············gettimeofday(&_now,·NULL);

1806

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_tx_pending·"·"CMSDK·APB·UART:·character·send·to·backend·pending"·"\n",

1806

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_tx_pending·"·"CMSDK·APB·UART:·character·send·to·backend·pending"·"\n",

1807

·····················qemu_get_thread_id(),

1807

·····················qemu_get_thread_id(),

1808

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1808

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1809

·····················);

1809

·····················);

1810

#line·1812·"trace/trace-hw_char.h"

1810

#line·1812·"trace/trace-hw_char.h"

1811

········}·else·{

1811

········}·else·{

1813

············qemu_log("cmsdk_apb_uart_tx_pending·"·"CMSDK·APB·UART:·character·send·to·backend·pending"·"\n");

1813

············qemu_log("cmsdk_apb_uart_tx_pending·"·"CMSDK·APB·UART:·character·send·to·backend·pending"·"\n");

1814

#line·1816·"trace/trace-hw_char.h"

1814

#line·1816·"trace/trace-hw_char.h"

1815

········}

1815

········}

1816

····}

1816

····}

1817

}

1817

}

1818

static·inline·void·trace_cmsdk_apb_uart_tx_pending(void)

1818

static·inline·void·trace_cmsdk_apb_uart_tx_pending(void)

1830

static·inline·void·_nocheck__trace_cmsdk_apb_uart_tx(uint8_t·c)

1830

static·inline·void·_nocheck__trace_cmsdk_apb_uart_tx(uint8_t·c)

1831

{

1831

{

1832

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_TX)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1832

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_TX)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1833

········if·(message_with_timestamp)·{

1833

········if·(message_with_timestamp)·{

1834

············struct·timeval·_now;

1834

············struct·timeval·_now;

1835

············gettimeofday(&_now,·NULL);

1835

············gettimeofday(&_now,·NULL);

1837

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_tx·"·"CMSDK·APB·UART:·character·0x%x·sent·to·backend"·"\n",

1837

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_tx·"·"CMSDK·APB·UART:·character·0x%x·sent·to·backend"·"\n",

1838

·····················qemu_get_thread_id(),

1838

·····················qemu_get_thread_id(),

1839

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1839

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1840

·····················,·c);

1840

·····················,·c);

1841

#line·1843·"trace/trace-hw_char.h"

1841

#line·1843·"trace/trace-hw_char.h"

1842

········}·else·{

1842

········}·else·{

1844

············qemu_log("cmsdk_apb_uart_tx·"·"CMSDK·APB·UART:·character·0x%x·sent·to·backend"·"\n",·c);

1844

············qemu_log("cmsdk_apb_uart_tx·"·"CMSDK·APB·UART:·character·0x%x·sent·to·backend"·"\n",·c);

1845

#line·1847·"trace/trace-hw_char.h"

1845

#line·1847·"trace/trace-hw_char.h"

1846

········}

1846

········}

1847

····}

1847

····}

1848

}

1848

}

1849

static·inline·void·trace_cmsdk_apb_uart_tx(uint8_t·c)

1849

static·inline·void·trace_cmsdk_apb_uart_tx(uint8_t·c)

1861

static·inline·void·_nocheck__trace_cmsdk_apb_uart_set_params(int·speed)

1861

static·inline·void·_nocheck__trace_cmsdk_apb_uart_set_params(int·speed)

1862

{

1862

{

1863

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_SET_PARAMS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1863

····if·(trace_event_get_state(TRACE_CMSDK_APB_UART_SET_PARAMS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1864

········if·(message_with_timestamp)·{

1864

········if·(message_with_timestamp)·{

1865

············struct·timeval·_now;

1865

············struct·timeval·_now;

1866

············gettimeofday(&_now,·NULL);

1866

············gettimeofday(&_now,·NULL);

1868

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_set_params·"·"CMSDK·APB·UART:·params·set·to·%d·8N1"·"\n",

1868

············qemu_log("%d@%zu.%06zu:cmsdk_apb_uart_set_params·"·"CMSDK·APB·UART:·params·set·to·%d·8N1"·"\n",

1869

·····················qemu_get_thread_id(),

1869

·····················qemu_get_thread_id(),

1870

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1870

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1871

·····················,·speed);

1871

·····················,·speed);

1872

#line·1874·"trace/trace-hw_char.h"

1872

#line·1874·"trace/trace-hw_char.h"

1873

········}·else·{

1873

········}·else·{

1875

············qemu_log("cmsdk_apb_uart_set_params·"·"CMSDK·APB·UART:·params·set·to·%d·8N1"·"\n",·speed);

1875

············qemu_log("cmsdk_apb_uart_set_params·"·"CMSDK·APB·UART:·params·set·to·%d·8N1"·"\n",·speed);

1876

#line·1878·"trace/trace-hw_char.h"

1876

#line·1878·"trace/trace-hw_char.h"

1877

········}

1877

········}

1878

····}

1878

····}

1879

}

1879

}

1880

static·inline·void·trace_cmsdk_apb_uart_set_params(int·speed)

1880

static·inline·void·trace_cmsdk_apb_uart_set_params(int·speed)

1892

static·inline·void·_nocheck__trace_nrf51_uart_read(uint64_t·addr,·uint64_t·r,·unsigned·int·size)

1892

static·inline·void·_nocheck__trace_nrf51_uart_read(uint64_t·addr,·uint64_t·r,·unsigned·int·size)

1893

{

1893

{

1894

····if·(trace_event_get_state(TRACE_NRF51_UART_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1894

····if·(trace_event_get_state(TRACE_NRF51_UART_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1895

········if·(message_with_timestamp)·{

1895

········if·(message_with_timestamp)·{

1896

············struct·timeval·_now;

1896

············struct·timeval·_now;

1897

············gettimeofday(&_now,·NULL);

1897

············gettimeofday(&_now,·NULL);

1899

············qemu_log("%d@%zu.%06zu:nrf51_uart_read·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx64·"·size·%u"·"\n",

1899

············qemu_log("%d@%zu.%06zu:nrf51_uart_read·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx64·"·size·%u"·"\n",

1900

·····················qemu_get_thread_id(),

1900

·····················qemu_get_thread_id(),

1901

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1901

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1902

·····················,·addr,·r,·size);

1902

·····················,·addr,·r,·size);

1903

#line·1905·"trace/trace-hw_char.h"

1903

#line·1905·"trace/trace-hw_char.h"

1904

········}·else·{

1904

········}·else·{

1906

············qemu_log("nrf51_uart_read·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx64·"·size·%u"·"\n",·addr,·r,·size);

1906

············qemu_log("nrf51_uart_read·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx64·"·size·%u"·"\n",·addr,·r,·size);

1907

#line·1909·"trace/trace-hw_char.h"

1907

#line·1909·"trace/trace-hw_char.h"

1908

········}

1908

········}

1909

····}

1909

····}

1910

}

1910

}

1911

static·inline·void·trace_nrf51_uart_read(uint64_t·addr,·uint64_t·r,·unsigned·int·size)

1911

static·inline·void·trace_nrf51_uart_read(uint64_t·addr,·uint64_t·r,·unsigned·int·size)

1923

static·inline·void·_nocheck__trace_nrf51_uart_write(uint64_t·addr,·uint64_t·value,·unsigned·int·size)

1923

static·inline·void·_nocheck__trace_nrf51_uart_write(uint64_t·addr,·uint64_t·value,·unsigned·int·size)

1924

{

1924

{

1925

····if·(trace_event_get_state(TRACE_NRF51_UART_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1925

····if·(trace_event_get_state(TRACE_NRF51_UART_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1926

········if·(message_with_timestamp)·{

1926

········if·(message_with_timestamp)·{

1927

············struct·timeval·_now;

1927

············struct·timeval·_now;

1928

············gettimeofday(&_now,·NULL);

1928

············gettimeofday(&_now,·NULL);

1930

············qemu_log("%d@%zu.%06zu:nrf51_uart_write·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx64·"·size·%u"·"\n",

1930

············qemu_log("%d@%zu.%06zu:nrf51_uart_write·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx64·"·size·%u"·"\n",

1931

·····················qemu_get_thread_id(),

1931

·····················qemu_get_thread_id(),

1932

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1932

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1933

·····················,·addr,·value,·size);

1933

·····················,·addr,·value,·size);

1934

#line·1936·"trace/trace-hw_char.h"

1934

#line·1936·"trace/trace-hw_char.h"

1935

········}·else·{

1935

········}·else·{

1937

············qemu_log("nrf51_uart_write·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx64·"·size·%u"·"\n",·addr,·value,·size);

1937

············qemu_log("nrf51_uart_write·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx64·"·size·%u"·"\n",·addr,·value,·size);

1938

#line·1940·"trace/trace-hw_char.h"

1938

#line·1940·"trace/trace-hw_char.h"

1939

········}

1939

········}

1940

····}

1940

····}

1941

}

1941

}

1942

static·inline·void·trace_nrf51_uart_write(uint64_t·addr,·uint64_t·value,·unsigned·int·size)

1942

static·inline·void·trace_nrf51_uart_write(uint64_t·addr,·uint64_t·value,·unsigned·int·size)

1954

static·inline·void·_nocheck__trace_shakti_uart_read(uint64_t·addr,·uint16_t·r,·unsigned·int·size)

1954

static·inline·void·_nocheck__trace_shakti_uart_read(uint64_t·addr,·uint16_t·r,·unsigned·int·size)

1955

{

1955

{

1956

····if·(trace_event_get_state(TRACE_SHAKTI_UART_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1956

····if·(trace_event_get_state(TRACE_SHAKTI_UART_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1957

········if·(message_with_timestamp)·{

1957

········if·(message_with_timestamp)·{

1958

············struct·timeval·_now;

1958

············struct·timeval·_now;

1959

············gettimeofday(&_now,·NULL);

1959

············gettimeofday(&_now,·NULL);

1961

············qemu_log("%d@%zu.%06zu:shakti_uart_read·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx16·"·size·%u"·"\n",

1961

············qemu_log("%d@%zu.%06zu:shakti_uart_read·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx16·"·size·%u"·"\n",

1962

·····················qemu_get_thread_id(),

1962

·····················qemu_get_thread_id(),

1963

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1963

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1964

·····················,·addr,·r,·size);

1964

·····················,·addr,·r,·size);

1965

#line·1967·"trace/trace-hw_char.h"

1965

#line·1967·"trace/trace-hw_char.h"

1966

········}·else·{

1966

········}·else·{

1968

············qemu_log("shakti_uart_read·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx16·"·size·%u"·"\n",·addr,·r,·size);

1968

············qemu_log("shakti_uart_read·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx16·"·size·%u"·"\n",·addr,·r,·size);

1969

#line·1971·"trace/trace-hw_char.h"

1969

#line·1971·"trace/trace-hw_char.h"

1970

········}

1970

········}

1971

····}

1971

····}

1972

}

1972

}

1973

static·inline·void·trace_shakti_uart_read(uint64_t·addr,·uint16_t·r,·unsigned·int·size)

1973

static·inline·void·trace_shakti_uart_read(uint64_t·addr,·uint16_t·r,·unsigned·int·size)

1985

static·inline·void·_nocheck__trace_shakti_uart_write(uint64_t·addr,·uint64_t·value,·unsigned·int·size)

1985

static·inline·void·_nocheck__trace_shakti_uart_write(uint64_t·addr,·uint64_t·value,·unsigned·int·size)

1986

{

1986

{

1987

····if·(trace_event_get_state(TRACE_SHAKTI_UART_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1987

····if·(trace_event_get_state(TRACE_SHAKTI_UART_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1988

········if·(message_with_timestamp)·{

1988

········if·(message_with_timestamp)·{

1989

············struct·timeval·_now;

1989

············struct·timeval·_now;

1990

············gettimeofday(&_now,·NULL);

1990

············gettimeofday(&_now,·NULL);

1992

············qemu_log("%d@%zu.%06zu:shakti_uart_write·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx64·"·size·%u"·"\n",

1992

············qemu_log("%d@%zu.%06zu:shakti_uart_write·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx64·"·size·%u"·"\n",

1993

·····················qemu_get_thread_id(),

1993

·····················qemu_get_thread_id(),

1994

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1994

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1995

·····················,·addr,·value,·size);

1995

·····················,·addr,·value,·size);

1996

#line·1998·"trace/trace-hw_char.h"

1996

#line·1998·"trace/trace-hw_char.h"

1997

········}·else·{

1997

········}·else·{

1999

············qemu_log("shakti_uart_write·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx64·"·size·%u"·"\n",·addr,·value,·size);

1999

············qemu_log("shakti_uart_write·"·"addr·0x%"·PRIx64·"·value·0x%"·PRIx64·"·size·%u"·"\n",·addr,·value,·size);

2000

#line·2002·"trace/trace-hw_char.h"

2000

#line·2002·"trace/trace-hw_char.h"

2001

········}

2001

········}

2002

····}

2002

····}

2003

}

2003

}

2004

static·inline·void·trace_shakti_uart_write(uint64_t·addr,·uint64_t·value,·unsigned·int·size)

2004

static·inline·void·trace_shakti_uart_write(uint64_t·addr,·uint64_t·value,·unsigned·int·size)

2016

static·inline·void·_nocheck__trace_exynos_uart_dmabusy(uint32_t·channel)

2016

static·inline·void·_nocheck__trace_exynos_uart_dmabusy(uint32_t·channel)

2017

{

2017

{

2018

····if·(trace_event_get_state(TRACE_EXYNOS_UART_DMABUSY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2018

····if·(trace_event_get_state(TRACE_EXYNOS_UART_DMABUSY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2019

········if·(message_with_timestamp)·{

2019

········if·(message_with_timestamp)·{

2020

············struct·timeval·_now;

2020

············struct·timeval·_now;

2021

············gettimeofday(&_now,·NULL);

2021

············gettimeofday(&_now,·NULL);

2023

············qemu_log("%d@%zu.%06zu:exynos_uart_dmabusy·"·"UART%d:·DMA·busy·(Rx·buffer·empty)"·"\n",

2023

············qemu_log("%d@%zu.%06zu:exynos_uart_dmabusy·"·"UART%d:·DMA·busy·(Rx·buffer·empty)"·"\n",

2024

·····················qemu_get_thread_id(),

2024

·····················qemu_get_thread_id(),

2025

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2025

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2026

·····················,·channel);

2026

·····················,·channel);

2027

#line·2029·"trace/trace-hw_char.h"

2027

#line·2029·"trace/trace-hw_char.h"

2028

········}·else·{

2028

········}·else·{

2030

············qemu_log("exynos_uart_dmabusy·"·"UART%d:·DMA·busy·(Rx·buffer·empty)"·"\n",·channel);

2030

············qemu_log("exynos_uart_dmabusy·"·"UART%d:·DMA·busy·(Rx·buffer·empty)"·"\n",·channel);

2031

#line·2033·"trace/trace-hw_char.h"

2031

#line·2033·"trace/trace-hw_char.h"

2032

········}

2032

········}

2033

····}

2033

····}

2034

}

2034

}

2035

static·inline·void·trace_exynos_uart_dmabusy(uint32_t·channel)

2035

static·inline·void·trace_exynos_uart_dmabusy(uint32_t·channel)

2047

static·inline·void·_nocheck__trace_exynos_uart_dmaready(uint32_t·channel)

2047

static·inline·void·_nocheck__trace_exynos_uart_dmaready(uint32_t·channel)

2048

{

2048

{

2049

····if·(trace_event_get_state(TRACE_EXYNOS_UART_DMAREADY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2049

····if·(trace_event_get_state(TRACE_EXYNOS_UART_DMAREADY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2050

········if·(message_with_timestamp)·{

2050

········if·(message_with_timestamp)·{

2051

············struct·timeval·_now;

2051

············struct·timeval·_now;

2052

············gettimeofday(&_now,·NULL);

2052

············gettimeofday(&_now,·NULL);

2054

············qemu_log("%d@%zu.%06zu:exynos_uart_dmaready·"·"UART%d:·DMA·ready"·"\n",

2054

············qemu_log("%d@%zu.%06zu:exynos_uart_dmaready·"·"UART%d:·DMA·ready"·"\n",

2055

·····················qemu_get_thread_id(),

2055

·····················qemu_get_thread_id(),

2056

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2056

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2057

·····················,·channel);

2057

·····················,·channel);

2058

#line·2060·"trace/trace-hw_char.h"

2058

#line·2060·"trace/trace-hw_char.h"

2059

········}·else·{

2059

········}·else·{

2061

············qemu_log("exynos_uart_dmaready·"·"UART%d:·DMA·ready"·"\n",·channel);

2061

············qemu_log("exynos_uart_dmaready·"·"UART%d:·DMA·ready"·"\n",·channel);

2062

#line·2064·"trace/trace-hw_char.h"

2062

#line·2064·"trace/trace-hw_char.h"

2063

········}

2063

········}

2064

····}

2064

····}

2065

}

2065

}

2066

static·inline·void·trace_exynos_uart_dmaready(uint32_t·channel)

2066

static·inline·void·trace_exynos_uart_dmaready(uint32_t·channel)

2078

static·inline·void·_nocheck__trace_exynos_uart_irq_raised(uint32_t·channel,·uint32_t·reg)

2078

static·inline·void·_nocheck__trace_exynos_uart_irq_raised(uint32_t·channel,·uint32_t·reg)

2079

{

2079

{

2080

····if·(trace_event_get_state(TRACE_EXYNOS_UART_IRQ_RAISED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2080

····if·(trace_event_get_state(TRACE_EXYNOS_UART_IRQ_RAISED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2081

········if·(message_with_timestamp)·{

2081

········if·(message_with_timestamp)·{

2082

············struct·timeval·_now;

2082

············struct·timeval·_now;

2083

············gettimeofday(&_now,·NULL);

2083

············gettimeofday(&_now,·NULL);

2085

············qemu_log("%d@%zu.%06zu:exynos_uart_irq_raised·"·"UART%d:·IRQ·raised:·0x%08"PRIx32·"\n",

2085

············qemu_log("%d@%zu.%06zu:exynos_uart_irq_raised·"·"UART%d:·IRQ·raised:·0x%08"PRIx32·"\n",

2086

·····················qemu_get_thread_id(),

2086

·····················qemu_get_thread_id(),

2087

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2087

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2088

·····················,·channel,·reg);

2088

·····················,·channel,·reg);

2089

#line·2091·"trace/trace-hw_char.h"

2089

#line·2091·"trace/trace-hw_char.h"

2090

········}·else·{

2090

········}·else·{

2092

············qemu_log("exynos_uart_irq_raised·"·"UART%d:·IRQ·raised:·0x%08"PRIx32·"\n",·channel,·reg);

2092

············qemu_log("exynos_uart_irq_raised·"·"UART%d:·IRQ·raised:·0x%08"PRIx32·"\n",·channel,·reg);

2093

#line·2095·"trace/trace-hw_char.h"

2093

#line·2095·"trace/trace-hw_char.h"

2094

········}

2094

········}

2095

····}

2095

····}

2096

}

2096

}

2097

static·inline·void·trace_exynos_uart_irq_raised(uint32_t·channel,·uint32_t·reg)

2097

static·inline·void·trace_exynos_uart_irq_raised(uint32_t·channel,·uint32_t·reg)

2109

static·inline·void·_nocheck__trace_exynos_uart_irq_lowered(uint32_t·channel)

2109

static·inline·void·_nocheck__trace_exynos_uart_irq_lowered(uint32_t·channel)

2110

{

2110

{

2111

····if·(trace_event_get_state(TRACE_EXYNOS_UART_IRQ_LOWERED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2111

····if·(trace_event_get_state(TRACE_EXYNOS_UART_IRQ_LOWERED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2112

········if·(message_with_timestamp)·{

2112

········if·(message_with_timestamp)·{

2113

············struct·timeval·_now;

2113

············struct·timeval·_now;

2114

············gettimeofday(&_now,·NULL);

2114

············gettimeofday(&_now,·NULL);

2116

············qemu_log("%d@%zu.%06zu:exynos_uart_irq_lowered·"·"UART%d:·IRQ·lowered"·"\n",

2116

············qemu_log("%d@%zu.%06zu:exynos_uart_irq_lowered·"·"UART%d:·IRQ·lowered"·"\n",

2117

·····················qemu_get_thread_id(),

2117

·····················qemu_get_thread_id(),

2118

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2118

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2119

·····················,·channel);

2119

·····················,·channel);

2120

#line·2122·"trace/trace-hw_char.h"

2120

#line·2122·"trace/trace-hw_char.h"

2121

········}·else·{

2121

········}·else·{

2123

············qemu_log("exynos_uart_irq_lowered·"·"UART%d:·IRQ·lowered"·"\n",·channel);

2123

············qemu_log("exynos_uart_irq_lowered·"·"UART%d:·IRQ·lowered"·"\n",·channel);

2124

#line·2126·"trace/trace-hw_char.h"

2124

#line·2126·"trace/trace-hw_char.h"

2125

········}

2125

········}

2126

····}

2126

····}

2127

}

2127

}

2128

static·inline·void·trace_exynos_uart_irq_lowered(uint32_t·channel)

2128

static·inline·void·trace_exynos_uart_irq_lowered(uint32_t·channel)

2140

static·inline·void·_nocheck__trace_exynos_uart_update_params(uint32_t·channel,·int·speed,·uint8_t·parity,·int·data,·int·stop,·uint64_t·wordtime)

2140

static·inline·void·_nocheck__trace_exynos_uart_update_params(uint32_t·channel,·int·speed,·uint8_t·parity,·int·data,·int·stop,·uint64_t·wordtime)

2141

{

2141

{

2142

····if·(trace_event_get_state(TRACE_EXYNOS_UART_UPDATE_PARAMS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2142

····if·(trace_event_get_state(TRACE_EXYNOS_UART_UPDATE_PARAMS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2143

········if·(message_with_timestamp)·{

2143

········if·(message_with_timestamp)·{

2144

············struct·timeval·_now;

2144

············struct·timeval·_now;

2145

············gettimeofday(&_now,·NULL);

2145

············gettimeofday(&_now,·NULL);

2147

············qemu_log("%d@%zu.%06zu:exynos_uart_update_params·"·"UART%d:·speed:·%d,·parity:·%c,·data·bits:·%d,·stop·bits:·%d·wordtime:·%"PRId64"ns"·"\n",

2147

············qemu_log("%d@%zu.%06zu:exynos_uart_update_params·"·"UART%d:·speed:·%d,·parity:·%c,·data·bits:·%d,·stop·bits:·%d·wordtime:·%"PRId64"ns"·"\n",

2148

·····················qemu_get_thread_id(),

2148

·····················qemu_get_thread_id(),

2149

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2149

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2150

·····················,·channel,·speed,·parity,·data,·stop,·wordtime);

2150

·····················,·channel,·speed,·parity,·data,·stop,·wordtime);

2151

#line·2153·"trace/trace-hw_char.h"

2151

#line·2153·"trace/trace-hw_char.h"

2152

········}·else·{

2152

········}·else·{

2154

············qemu_log("exynos_uart_update_params·"·"UART%d:·speed:·%d,·parity:·%c,·data·bits:·%d,·stop·bits:·%d·wordtime:·%"PRId64"ns"·"\n",·channel,·speed,·parity,·data,·stop,·wordtime);

2154

············qemu_log("exynos_uart_update_params·"·"UART%d:·speed:·%d,·parity:·%c,·data·bits:·%d,·stop·bits:·%d·wordtime:·%"PRId64"ns"·"\n",·channel,·speed,·parity,·data,·stop,·wordtime);

2155

#line·2157·"trace/trace-hw_char.h"

2155

#line·2157·"trace/trace-hw_char.h"

2156

········}

2156

········}

2157

····}

2157

····}

2158

}

2158

}

2159

static·inline·void·trace_exynos_uart_update_params(uint32_t·channel,·int·speed,·uint8_t·parity,·int·data,·int·stop,·uint64_t·wordtime)

2159

static·inline·void·trace_exynos_uart_update_params(uint32_t·channel,·int·speed,·uint8_t·parity,·int·data,·int·stop,·uint64_t·wordtime)

2171

static·inline·void·_nocheck__trace_exynos_uart_write(uint32_t·channel,·uint32_t·offset,·const·char·*·name,·uint64_t·val)

2171

static·inline·void·_nocheck__trace_exynos_uart_write(uint32_t·channel,·uint32_t·offset,·const·char·*·name,·uint64_t·val)

2172

{

2172

{

2173

····if·(trace_event_get_state(TRACE_EXYNOS_UART_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2173

····if·(trace_event_get_state(TRACE_EXYNOS_UART_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2174

········if·(message_with_timestamp)·{

2174

········if·(message_with_timestamp)·{

2175

············struct·timeval·_now;

2175

············struct·timeval·_now;

2176

············gettimeofday(&_now,·NULL);

2176

············gettimeofday(&_now,·NULL);

2178

············qemu_log("%d@%zu.%06zu:exynos_uart_write·"·"UART%d:·<0x%04x>·%s·<-·0x%"·PRIx64·"\n",

2178

············qemu_log("%d@%zu.%06zu:exynos_uart_write·"·"UART%d:·<0x%04x>·%s·<-·0x%"·PRIx64·"\n",

2179

·····················qemu_get_thread_id(),

2179

·····················qemu_get_thread_id(),

2180

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2180

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2181

·····················,·channel,·offset,·name,·val);

2181

·····················,·channel,·offset,·name,·val);

2182

#line·2184·"trace/trace-hw_char.h"

2182

#line·2184·"trace/trace-hw_char.h"

2183

········}·else·{

2183

········}·else·{

2185

············qemu_log("exynos_uart_write·"·"UART%d:·<0x%04x>·%s·<-·0x%"·PRIx64·"\n",·channel,·offset,·name,·val);

2185

············qemu_log("exynos_uart_write·"·"UART%d:·<0x%04x>·%s·<-·0x%"·PRIx64·"\n",·channel,·offset,·name,·val);

2186

#line·2188·"trace/trace-hw_char.h"

2186

#line·2188·"trace/trace-hw_char.h"

2187

········}

2187

········}

2188

····}

2188

····}

2189

}

2189

}

2190

static·inline·void·trace_exynos_uart_write(uint32_t·channel,·uint32_t·offset,·const·char·*·name,·uint64_t·val)

2190

static·inline·void·trace_exynos_uart_write(uint32_t·channel,·uint32_t·offset,·const·char·*·name,·uint64_t·val)

2202

static·inline·void·_nocheck__trace_exynos_uart_read(uint32_t·channel,·uint32_t·offset,·const·char·*·name,·uint64_t·val)

2202

static·inline·void·_nocheck__trace_exynos_uart_read(uint32_t·channel,·uint32_t·offset,·const·char·*·name,·uint64_t·val)

2203

{

2203

{

2204

····if·(trace_event_get_state(TRACE_EXYNOS_UART_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2204

····if·(trace_event_get_state(TRACE_EXYNOS_UART_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2205

········if·(message_with_timestamp)·{

2205

········if·(message_with_timestamp)·{

2206

············struct·timeval·_now;

2206

············struct·timeval·_now;

2207

············gettimeofday(&_now,·NULL);

2207

············gettimeofday(&_now,·NULL);

2209

············qemu_log("%d@%zu.%06zu:exynos_uart_read·"·"UART%d:·<0x%04x>·%s·->·0x%"·PRIx64·"\n",

2209

············qemu_log("%d@%zu.%06zu:exynos_uart_read·"·"UART%d:·<0x%04x>·%s·->·0x%"·PRIx64·"\n",

2210

·····················qemu_get_thread_id(),

2210

·····················qemu_get_thread_id(),

2211

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2211

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2212

·····················,·channel,·offset,·name,·val);

2212

·····················,·channel,·offset,·name,·val);

2213

#line·2215·"trace/trace-hw_char.h"

2213

#line·2215·"trace/trace-hw_char.h"

2214

········}·else·{

2214

········}·else·{

2216

············qemu_log("exynos_uart_read·"·"UART%d:·<0x%04x>·%s·->·0x%"·PRIx64·"\n",·channel,·offset,·name,·val);

2216

············qemu_log("exynos_uart_read·"·"UART%d:·<0x%04x>·%s·->·0x%"·PRIx64·"\n",·channel,·offset,·name,·val);

2217

#line·2219·"trace/trace-hw_char.h"

2217

#line·2219·"trace/trace-hw_char.h"

2218

········}

2218

········}

2219

····}

2219

····}

2220

}

2220

}

2221

static·inline·void·trace_exynos_uart_read(uint32_t·channel,·uint32_t·offset,·const·char·*·name,·uint64_t·val)

2221

static·inline·void·trace_exynos_uart_read(uint32_t·channel,·uint32_t·offset,·const·char·*·name,·uint64_t·val)

2233

static·inline·void·_nocheck__trace_exynos_uart_rx_fifo_reset(uint32_t·channel)

2233

static·inline·void·_nocheck__trace_exynos_uart_rx_fifo_reset(uint32_t·channel)

2234

{

2234

{

2235

····if·(trace_event_get_state(TRACE_EXYNOS_UART_RX_FIFO_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2235

····if·(trace_event_get_state(TRACE_EXYNOS_UART_RX_FIFO_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2236

········if·(message_with_timestamp)·{

2236

········if·(message_with_timestamp)·{

2237

············struct·timeval·_now;

2237

············struct·timeval·_now;

2238

············gettimeofday(&_now,·NULL);

2238

············gettimeofday(&_now,·NULL);

2240

············qemu_log("%d@%zu.%06zu:exynos_uart_rx_fifo_reset·"·"UART%d:·Rx·FIFO·Reset"·"\n",

2240

············qemu_log("%d@%zu.%06zu:exynos_uart_rx_fifo_reset·"·"UART%d:·Rx·FIFO·Reset"·"\n",

2241

·····················qemu_get_thread_id(),

2241

·····················qemu_get_thread_id(),

2242

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2242

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2243

·····················,·channel);

2243

·····················,·channel);

2244

#line·2246·"trace/trace-hw_char.h"

2244

#line·2246·"trace/trace-hw_char.h"

2245

········}·else·{

2245

········}·else·{

2247

············qemu_log("exynos_uart_rx_fifo_reset·"·"UART%d:·Rx·FIFO·Reset"·"\n",·channel);

2247

············qemu_log("exynos_uart_rx_fifo_reset·"·"UART%d:·Rx·FIFO·Reset"·"\n",·channel);

2248

#line·2250·"trace/trace-hw_char.h"

2248

#line·2250·"trace/trace-hw_char.h"

2249

········}

2249

········}

2250

····}

2250

····}

2251

}

2251

}

2252

static·inline·void·trace_exynos_uart_rx_fifo_reset(uint32_t·channel)

2252

static·inline·void·trace_exynos_uart_rx_fifo_reset(uint32_t·channel)

2264

static·inline·void·_nocheck__trace_exynos_uart_tx_fifo_reset(uint32_t·channel)

2264

static·inline·void·_nocheck__trace_exynos_uart_tx_fifo_reset(uint32_t·channel)

2265

{

2265

{

2266

····if·(trace_event_get_state(TRACE_EXYNOS_UART_TX_FIFO_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2266

····if·(trace_event_get_state(TRACE_EXYNOS_UART_TX_FIFO_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2267

········if·(message_with_timestamp)·{

2267

········if·(message_with_timestamp)·{

2268

············struct·timeval·_now;

2268

············struct·timeval·_now;

2269

············gettimeofday(&_now,·NULL);

2269

············gettimeofday(&_now,·NULL);

2271

············qemu_log("%d@%zu.%06zu:exynos_uart_tx_fifo_reset·"·"UART%d:·Tx·FIFO·Reset"·"\n",

2271

············qemu_log("%d@%zu.%06zu:exynos_uart_tx_fifo_reset·"·"UART%d:·Tx·FIFO·Reset"·"\n",

2272

·····················qemu_get_thread_id(),

2272

·····················qemu_get_thread_id(),

2273

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2273

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2274

·····················,·channel);

2274

·····················,·channel);

2275

#line·2277·"trace/trace-hw_char.h"

2275

#line·2277·"trace/trace-hw_char.h"

2276

········}·else·{

2276

········}·else·{

2278

············qemu_log("exynos_uart_tx_fifo_reset·"·"UART%d:·Tx·FIFO·Reset"·"\n",·channel);

2278

············qemu_log("exynos_uart_tx_fifo_reset·"·"UART%d:·Tx·FIFO·Reset"·"\n",·channel);

2279

#line·2281·"trace/trace-hw_char.h"

2279

#line·2281·"trace/trace-hw_char.h"

2280

········}

2280

········}

2281

····}

2281

····}

2282

}

2282

}

2283

static·inline·void·trace_exynos_uart_tx_fifo_reset(uint32_t·channel)

2283

static·inline·void·trace_exynos_uart_tx_fifo_reset(uint32_t·channel)

2295

static·inline·void·_nocheck__trace_exynos_uart_tx(uint32_t·channel,·uint8_t·ch)

2295

static·inline·void·_nocheck__trace_exynos_uart_tx(uint32_t·channel,·uint8_t·ch)

2296

{

2296

{

2297

····if·(trace_event_get_state(TRACE_EXYNOS_UART_TX)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2297

····if·(trace_event_get_state(TRACE_EXYNOS_UART_TX)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2298

········if·(message_with_timestamp)·{

2298

········if·(message_with_timestamp)·{

2299

············struct·timeval·_now;

2299

············struct·timeval·_now;

2300

············gettimeofday(&_now,·NULL);

2300

············gettimeofday(&_now,·NULL);

2302

············qemu_log("%d@%zu.%06zu:exynos_uart_tx·"·"UART%d:·Tx·0x%02"PRIx32·"\n",

2302

············qemu_log("%d@%zu.%06zu:exynos_uart_tx·"·"UART%d:·Tx·0x%02"PRIx32·"\n",

2303

·····················qemu_get_thread_id(),

2303

·····················qemu_get_thread_id(),

2304

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2304

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2305

·····················,·channel,·ch);

2305

·····················,·channel,·ch);

2306

#line·2308·"trace/trace-hw_char.h"

2306

#line·2308·"trace/trace-hw_char.h"

2307

········}·else·{

2307

········}·else·{

2309

············qemu_log("exynos_uart_tx·"·"UART%d:·Tx·0x%02"PRIx32·"\n",·channel,·ch);

2309

············qemu_log("exynos_uart_tx·"·"UART%d:·Tx·0x%02"PRIx32·"\n",·channel,·ch);

2310

#line·2312·"trace/trace-hw_char.h"

2310

#line·2312·"trace/trace-hw_char.h"

2311

········}

2311

········}

2312

····}

2312

····}

2313

}

2313

}

2314

static·inline·void·trace_exynos_uart_tx(uint32_t·channel,·uint8_t·ch)

2314

static·inline·void·trace_exynos_uart_tx(uint32_t·channel,·uint8_t·ch)

2326

static·inline·void·_nocheck__trace_exynos_uart_intclr(uint32_t·channel,·uint32_t·reg)

2326

static·inline·void·_nocheck__trace_exynos_uart_intclr(uint32_t·channel,·uint32_t·reg)

2327

{

2327

{

2328

····if·(trace_event_get_state(TRACE_EXYNOS_UART_INTCLR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2328

····if·(trace_event_get_state(TRACE_EXYNOS_UART_INTCLR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2329

········if·(message_with_timestamp)·{

2329

········if·(message_with_timestamp)·{

2330

············struct·timeval·_now;

2330

············struct·timeval·_now;

2331

············gettimeofday(&_now,·NULL);

2331

············gettimeofday(&_now,·NULL);

2333

············qemu_log("%d@%zu.%06zu:exynos_uart_intclr·"·"UART%d:·interrupts·cleared:·0x%08"PRIx32·"\n",

2333

············qemu_log("%d@%zu.%06zu:exynos_uart_intclr·"·"UART%d:·interrupts·cleared:·0x%08"PRIx32·"\n",

2334

·····················qemu_get_thread_id(),

2334

·····················qemu_get_thread_id(),

2335

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2335

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2336

·····················,·channel,·reg);

2336

·····················,·channel,·reg);

2337

#line·2339·"trace/trace-hw_char.h"

2337

#line·2339·"trace/trace-hw_char.h"

2338

········}·else·{

2338

········}·else·{

2340

············qemu_log("exynos_uart_intclr·"·"UART%d:·interrupts·cleared:·0x%08"PRIx32·"\n",·channel,·reg);

2340

············qemu_log("exynos_uart_intclr·"·"UART%d:·interrupts·cleared:·0x%08"PRIx32·"\n",·channel,·reg);

2341

#line·2343·"trace/trace-hw_char.h"

2341

#line·2343·"trace/trace-hw_char.h"

2342

········}

2342

········}

2343

····}

2343

····}

2344

}

2344

}

2345

static·inline·void·trace_exynos_uart_intclr(uint32_t·channel,·uint32_t·reg)

2345

static·inline·void·trace_exynos_uart_intclr(uint32_t·channel,·uint32_t·reg)

2357

static·inline·void·_nocheck__trace_exynos_uart_ro_write(uint32_t·channel,·const·char·*·name,·uint32_t·reg)

2357

static·inline·void·_nocheck__trace_exynos_uart_ro_write(uint32_t·channel,·const·char·*·name,·uint32_t·reg)

2358

{

2358

{

2359

····if·(trace_event_get_state(TRACE_EXYNOS_UART_RO_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2359

····if·(trace_event_get_state(TRACE_EXYNOS_UART_RO_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2360

········if·(message_with_timestamp)·{

2360

········if·(message_with_timestamp)·{

2361

············struct·timeval·_now;

2361

············struct·timeval·_now;

2362

············gettimeofday(&_now,·NULL);

2362

············gettimeofday(&_now,·NULL);

2364

············qemu_log("%d@%zu.%06zu:exynos_uart_ro_write·"·"UART%d:·Trying·to·write·into·RO·register:·%s·[0x%04"PRIx32"]"·"\n",

2364

············qemu_log("%d@%zu.%06zu:exynos_uart_ro_write·"·"UART%d:·Trying·to·write·into·RO·register:·%s·[0x%04"PRIx32"]"·"\n",

2365

·····················qemu_get_thread_id(),

2365

·····················qemu_get_thread_id(),

2366

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2366

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2367

·····················,·channel,·name,·reg);

2367

·····················,·channel,·name,·reg);

2368

#line·2370·"trace/trace-hw_char.h"

2368

#line·2370·"trace/trace-hw_char.h"

2369

········}·else·{

2369

········}·else·{

2371

············qemu_log("exynos_uart_ro_write·"·"UART%d:·Trying·to·write·into·RO·register:·%s·[0x%04"PRIx32"]"·"\n",·channel,·name,·reg);

2371

············qemu_log("exynos_uart_ro_write·"·"UART%d:·Trying·to·write·into·RO·register:·%s·[0x%04"PRIx32"]"·"\n",·channel,·name,·reg);

2372

#line·2374·"trace/trace-hw_char.h"

2372

#line·2374·"trace/trace-hw_char.h"

2373

········}

2373

········}

2374

····}

2374

····}

2375

}

2375

}

2376

static·inline·void·trace_exynos_uart_ro_write(uint32_t·channel,·const·char·*·name,·uint32_t·reg)

2376

static·inline·void·trace_exynos_uart_ro_write(uint32_t·channel,·const·char·*·name,·uint32_t·reg)

2388

static·inline·void·_nocheck__trace_exynos_uart_rx(uint32_t·channel,·uint8_t·ch)

2388

static·inline·void·_nocheck__trace_exynos_uart_rx(uint32_t·channel,·uint8_t·ch)

2389

{

2389

{

2390

····if·(trace_event_get_state(TRACE_EXYNOS_UART_RX)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2390

····if·(trace_event_get_state(TRACE_EXYNOS_UART_RX)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2391

········if·(message_with_timestamp)·{

2391

········if·(message_with_timestamp)·{

2392

············struct·timeval·_now;

2392

············struct·timeval·_now;

2393

············gettimeofday(&_now,·NULL);

2393

············gettimeofday(&_now,·NULL);

2395

············qemu_log("%d@%zu.%06zu:exynos_uart_rx·"·"UART%d:·Rx·0x%02"PRIx32·"\n",

2395

············qemu_log("%d@%zu.%06zu:exynos_uart_rx·"·"UART%d:·Rx·0x%02"PRIx32·"\n",

2396

·····················qemu_get_thread_id(),

2396

·····················qemu_get_thread_id(),

2397

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2397

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2398

·····················,·channel,·ch);

2398

·····················,·channel,·ch);

2399

#line·2401·"trace/trace-hw_char.h"

2399

#line·2401·"trace/trace-hw_char.h"

2400

········}·else·{

2400

········}·else·{

2402

············qemu_log("exynos_uart_rx·"·"UART%d:·Rx·0x%02"PRIx32·"\n",·channel,·ch);

2402

············qemu_log("exynos_uart_rx·"·"UART%d:·Rx·0x%02"PRIx32·"\n",·channel,·ch);

2403

#line·2405·"trace/trace-hw_char.h"

2403

#line·2405·"trace/trace-hw_char.h"

2404

········}

2404

········}

2405

····}

2405

····}

2406

}

2406

}

2407

static·inline·void·trace_exynos_uart_rx(uint32_t·channel,·uint8_t·ch)

2407

static·inline·void·trace_exynos_uart_rx(uint32_t·channel,·uint8_t·ch)

2419

static·inline·void·_nocheck__trace_exynos_uart_rx_error(uint32_t·channel)

2419

static·inline·void·_nocheck__trace_exynos_uart_rx_error(uint32_t·channel)

2420

{

2420

{

2421

····if·(trace_event_get_state(TRACE_EXYNOS_UART_RX_ERROR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2421

····if·(trace_event_get_state(TRACE_EXYNOS_UART_RX_ERROR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2422

········if·(message_with_timestamp)·{

2422

········if·(message_with_timestamp)·{

2423

············struct·timeval·_now;

2423

············struct·timeval·_now;

2424

············gettimeofday(&_now,·NULL);

2424

············gettimeofday(&_now,·NULL);

2426

············qemu_log("%d@%zu.%06zu:exynos_uart_rx_error·"·"UART%d:·Rx·error"·"\n",

2426

············qemu_log("%d@%zu.%06zu:exynos_uart_rx_error·"·"UART%d:·Rx·error"·"\n",

2427

·····················qemu_get_thread_id(),

2427

·····················qemu_get_thread_id(),

2428

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2428

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2429

·····················,·channel);

2429

·····················,·channel);

2430

#line·2432·"trace/trace-hw_char.h"

2430

#line·2432·"trace/trace-hw_char.h"

2431

········}·else·{

2431

········}·else·{

2433

············qemu_log("exynos_uart_rx_error·"·"UART%d:·Rx·error"·"\n",·channel);

2433

············qemu_log("exynos_uart_rx_error·"·"UART%d:·Rx·error"·"\n",·channel);

2434

#line·2436·"trace/trace-hw_char.h"

2434

#line·2436·"trace/trace-hw_char.h"

2435

········}

2435

········}

2436

····}

2436

····}

2437

}

2437

}

2438

static·inline·void·trace_exynos_uart_rx_error(uint32_t·channel)

2438

static·inline·void·trace_exynos_uart_rx_error(uint32_t·channel)

2450

static·inline·void·_nocheck__trace_exynos_uart_wo_read(uint32_t·channel,·const·char·*·name,·uint32_t·reg)

2450

static·inline·void·_nocheck__trace_exynos_uart_wo_read(uint32_t·channel,·const·char·*·name,·uint32_t·reg)

2451

{

2451

{

2452

····if·(trace_event_get_state(TRACE_EXYNOS_UART_WO_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2452

····if·(trace_event_get_state(TRACE_EXYNOS_UART_WO_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2453

········if·(message_with_timestamp)·{

2453

········if·(message_with_timestamp)·{

2454

············struct·timeval·_now;

2454

············struct·timeval·_now;

2455

············gettimeofday(&_now,·NULL);

2455

············gettimeofday(&_now,·NULL);

2457

············qemu_log("%d@%zu.%06zu:exynos_uart_wo_read·"·"UART%d:·Trying·to·read·from·WO·register:·%s·[0x%04"PRIx32"]"·"\n",

2457

············qemu_log("%d@%zu.%06zu:exynos_uart_wo_read·"·"UART%d:·Trying·to·read·from·WO·register:·%s·[0x%04"PRIx32"]"·"\n",

2458

·····················qemu_get_thread_id(),

2458

·····················qemu_get_thread_id(),

2459

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2459

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2460

·····················,·channel,·name,·reg);

2460

·····················,·channel,·name,·reg);

2461

#line·2463·"trace/trace-hw_char.h"

2461

#line·2463·"trace/trace-hw_char.h"

2462

········}·else·{

2462

········}·else·{

2464

············qemu_log("exynos_uart_wo_read·"·"UART%d:·Trying·to·read·from·WO·register:·%s·[0x%04"PRIx32"]"·"\n",·channel,·name,·reg);

2464

············qemu_log("exynos_uart_wo_read·"·"UART%d:·Trying·to·read·from·WO·register:·%s·[0x%04"PRIx32"]"·"\n",·channel,·name,·reg);

2465

#line·2467·"trace/trace-hw_char.h"

2465

#line·2467·"trace/trace-hw_char.h"

2466

········}

2466

········}

2467

····}

2467

····}

2468

}

2468

}

2469

static·inline·void·trace_exynos_uart_wo_read(uint32_t·channel,·const·char·*·name,·uint32_t·reg)

2469

static·inline·void·trace_exynos_uart_wo_read(uint32_t·channel,·const·char·*·name,·uint32_t·reg)

2481

static·inline·void·_nocheck__trace_exynos_uart_rxsize(uint32_t·channel,·uint32_t·size)

2481

static·inline·void·_nocheck__trace_exynos_uart_rxsize(uint32_t·channel,·uint32_t·size)

2482

{

2482

{

2483

····if·(trace_event_get_state(TRACE_EXYNOS_UART_RXSIZE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2483

····if·(trace_event_get_state(TRACE_EXYNOS_UART_RXSIZE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2484

········if·(message_with_timestamp)·{

2484

········if·(message_with_timestamp)·{

2485

············struct·timeval·_now;

2485

············struct·timeval·_now;

2486

············gettimeofday(&_now,·NULL);

2486

············gettimeofday(&_now,·NULL);

2488

············qemu_log("%d@%zu.%06zu:exynos_uart_rxsize·"·"UART%d:·Rx·FIFO·size:·%d"·"\n",

2488

············qemu_log("%d@%zu.%06zu:exynos_uart_rxsize·"·"UART%d:·Rx·FIFO·size:·%d"·"\n",

2489

·····················qemu_get_thread_id(),

2489

·····················qemu_get_thread_id(),

2490

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2490

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2491

·····················,·channel,·size);

2491

·····················,·channel,·size);

2492

#line·2494·"trace/trace-hw_char.h"

2492

#line·2494·"trace/trace-hw_char.h"

2493

········}·else·{

2493

········}·else·{

2495

············qemu_log("exynos_uart_rxsize·"·"UART%d:·Rx·FIFO·size:·%d"·"\n",·channel,·size);

2495

············qemu_log("exynos_uart_rxsize·"·"UART%d:·Rx·FIFO·size:·%d"·"\n",·channel,·size);

2496

#line·2498·"trace/trace-hw_char.h"

2496

#line·2498·"trace/trace-hw_char.h"

2497

········}

2497

········}

2498

····}

2498

····}

2499

}

2499

}

2500

static·inline·void·trace_exynos_uart_rxsize(uint32_t·channel,·uint32_t·size)

2500

static·inline·void·trace_exynos_uart_rxsize(uint32_t·channel,·uint32_t·size)

2512

static·inline·void·_nocheck__trace_exynos_uart_channel_error(uint32_t·channel)

2512

static·inline·void·_nocheck__trace_exynos_uart_channel_error(uint32_t·channel)

2513

{

2513

{

2514

····if·(trace_event_get_state(TRACE_EXYNOS_UART_CHANNEL_ERROR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2514

····if·(trace_event_get_state(TRACE_EXYNOS_UART_CHANNEL_ERROR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2515

········if·(message_with_timestamp)·{

2515

········if·(message_with_timestamp)·{

2516

············struct·timeval·_now;

2516

············struct·timeval·_now;

2517

············gettimeofday(&_now,·NULL);

2517

············gettimeofday(&_now,·NULL);

2519

············qemu_log("%d@%zu.%06zu:exynos_uart_channel_error·"·"Wrong·UART·channel·number:·%d"·"\n",

2519

············qemu_log("%d@%zu.%06zu:exynos_uart_channel_error·"·"Wrong·UART·channel·number:·%d"·"\n",

2520

·····················qemu_get_thread_id(),

2520

·····················qemu_get_thread_id(),

2521

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2521

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2522

·····················,·channel);

2522

·····················,·channel);

2523

#line·2525·"trace/trace-hw_char.h"

2523

#line·2525·"trace/trace-hw_char.h"

2524

········}·else·{

2524

········}·else·{

2526

············qemu_log("exynos_uart_channel_error·"·"Wrong·UART·channel·number:·%d"·"\n",·channel);

2526

············qemu_log("exynos_uart_channel_error·"·"Wrong·UART·channel·number:·%d"·"\n",·channel);

2527

#line·2529·"trace/trace-hw_char.h"

2527

#line·2529·"trace/trace-hw_char.h"

2528

········}

2528

········}

2529

····}

2529

····}

2530

}

2530

}

2531

static·inline·void·trace_exynos_uart_channel_error(uint32_t·channel)

2531

static·inline·void·trace_exynos_uart_channel_error(uint32_t·channel)

2543

static·inline·void·_nocheck__trace_exynos_uart_rx_timeout(uint32_t·channel,·uint32_t·stat,·uint32_t·intsp)

2543

static·inline·void·_nocheck__trace_exynos_uart_rx_timeout(uint32_t·channel,·uint32_t·stat,·uint32_t·intsp)

2544

{

2544

{

2545

····if·(trace_event_get_state(TRACE_EXYNOS_UART_RX_TIMEOUT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2545

····if·(trace_event_get_state(TRACE_EXYNOS_UART_RX_TIMEOUT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2546

········if·(message_with_timestamp)·{

2546

········if·(message_with_timestamp)·{

2547

············struct·timeval·_now;

2547

············struct·timeval·_now;

2548

············gettimeofday(&_now,·NULL);

2548

············gettimeofday(&_now,·NULL);

2550

············qemu_log("%d@%zu.%06zu:exynos_uart_rx_timeout·"·"UART%d:·Rx·timeout·stat=0x%x·intsp=0x%x"·"\n",

2550

············qemu_log("%d@%zu.%06zu:exynos_uart_rx_timeout·"·"UART%d:·Rx·timeout·stat=0x%x·intsp=0x%x"·"\n",

2551

·····················qemu_get_thread_id(),

2551

·····················qemu_get_thread_id(),

2552

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2552

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2553

·····················,·channel,·stat,·intsp);

2553

·····················,·channel,·stat,·intsp);

2554

#line·2556·"trace/trace-hw_char.h"

2554

#line·2556·"trace/trace-hw_char.h"

2555

········}·else·{

2555

········}·else·{

2557

············qemu_log("exynos_uart_rx_timeout·"·"UART%d:·Rx·timeout·stat=0x%x·intsp=0x%x"·"\n",·channel,·stat,·intsp);

2557

············qemu_log("exynos_uart_rx_timeout·"·"UART%d:·Rx·timeout·stat=0x%x·intsp=0x%x"·"\n",·channel,·stat,·intsp);

2558

#line·2560·"trace/trace-hw_char.h"

2558

#line·2560·"trace/trace-hw_char.h"

2559

········}

2559

········}

2560

····}

2560

····}

2561

}

2561

}

2562

static·inline·void·trace_exynos_uart_rx_timeout(uint32_t·channel,·uint32_t·stat,·uint32_t·intsp)

2562

static·inline·void·trace_exynos_uart_rx_timeout(uint32_t·channel,·uint32_t·stat,·uint32_t·intsp)

2574

static·inline·void·_nocheck__trace_cadence_uart_baudrate(unsigned·baudrate)

2574

static·inline·void·_nocheck__trace_cadence_uart_baudrate(unsigned·baudrate)

2575

{

2575

{

2576

····if·(trace_event_get_state(TRACE_CADENCE_UART_BAUDRATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2576

····if·(trace_event_get_state(TRACE_CADENCE_UART_BAUDRATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2577

········if·(message_with_timestamp)·{

2577

········if·(message_with_timestamp)·{

2578

············struct·timeval·_now;

2578

············struct·timeval·_now;

2579

············gettimeofday(&_now,·NULL);

2579

············gettimeofday(&_now,·NULL);

2581

············qemu_log("%d@%zu.%06zu:cadence_uart_baudrate·"·"baudrate·%u"·"\n",

2581

············qemu_log("%d@%zu.%06zu:cadence_uart_baudrate·"·"baudrate·%u"·"\n",

2582

·····················qemu_get_thread_id(),

2582

·····················qemu_get_thread_id(),

2583

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2583

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2584

·····················,·baudrate);

2584

·····················,·baudrate);

2585

#line·2587·"trace/trace-hw_char.h"

2585

#line·2587·"trace/trace-hw_char.h"

2586

········}·else·{

2586

········}·else·{

2588

············qemu_log("cadence_uart_baudrate·"·"baudrate·%u"·"\n",·baudrate);

2588

············qemu_log("cadence_uart_baudrate·"·"baudrate·%u"·"\n",·baudrate);

2589

#line·2591·"trace/trace-hw_char.h"

2589

#line·2591·"trace/trace-hw_char.h"

2590

········}

2590

········}

2591

····}

2591

····}

2592

}

2592

}

2593

static·inline·void·trace_cadence_uart_baudrate(unsigned·baudrate)

2593

static·inline·void·trace_cadence_uart_baudrate(unsigned·baudrate)

2605

static·inline·void·_nocheck__trace_sh_serial_read(char·*·id,·unsigned·size,·uint64_t·offs,·uint64_t·val)

2605

static·inline·void·_nocheck__trace_sh_serial_read(char·*·id,·unsigned·size,·uint64_t·offs,·uint64_t·val)

2606

{

2606

{

2607

····if·(trace_event_get_state(TRACE_SH_SERIAL_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2607

····if·(trace_event_get_state(TRACE_SH_SERIAL_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2608

········if·(message_with_timestamp)·{

2608

········if·(message_with_timestamp)·{

2609

············struct·timeval·_now;

2609

············struct·timeval·_now;

2610

············gettimeofday(&_now,·NULL);

2610

············gettimeofday(&_now,·NULL);

2612

············qemu_log("%d@%zu.%06zu:sh_serial_read·"·"·%s·size·%d·offs·0x%02"·PRIx64·"·->·0x%02"·PRIx64·"\n",

2612

············qemu_log("%d@%zu.%06zu:sh_serial_read·"·"·%s·size·%d·offs·0x%02"·PRIx64·"·->·0x%02"·PRIx64·"\n",

2613

·····················qemu_get_thread_id(),

2613

·····················qemu_get_thread_id(),

2614

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2614

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2615

·····················,·id,·size,·offs,·val);

2615

·····················,·id,·size,·offs,·val);

2616

#line·2618·"trace/trace-hw_char.h"

2616

#line·2618·"trace/trace-hw_char.h"

2617

········}·else·{

2617

········}·else·{

2619

············qemu_log("sh_serial_read·"·"·%s·size·%d·offs·0x%02"·PRIx64·"·->·0x%02"·PRIx64·"\n",·id,·size,·offs,·val);

2619

············qemu_log("sh_serial_read·"·"·%s·size·%d·offs·0x%02"·PRIx64·"·->·0x%02"·PRIx64·"\n",·id,·size,·offs,·val);

2620

#line·2622·"trace/trace-hw_char.h"

2620

#line·2622·"trace/trace-hw_char.h"

2621

········}

2621

········}

2622

····}

2622

····}

2623

}

2623

}

2624

static·inline·void·trace_sh_serial_read(char·*·id,·unsigned·size,·uint64_t·offs,·uint64_t·val)

2624

static·inline·void·trace_sh_serial_read(char·*·id,·unsigned·size,·uint64_t·offs,·uint64_t·val)

2636

static·inline·void·_nocheck__trace_sh_serial_write(char·*·id,·unsigned·size,·uint64_t·offs,·uint64_t·val)

2636

static·inline·void·_nocheck__trace_sh_serial_write(char·*·id,·unsigned·size,·uint64_t·offs,·uint64_t·val)

2637

{

2637

{

2638

····if·(trace_event_get_state(TRACE_SH_SERIAL_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2638

····if·(trace_event_get_state(TRACE_SH_SERIAL_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2639

········if·(message_with_timestamp)·{

2639

········if·(message_with_timestamp)·{

2640

············struct·timeval·_now;

2640

············struct·timeval·_now;

2641

············gettimeofday(&_now,·NULL);

2641

············gettimeofday(&_now,·NULL);

2643

············qemu_log("%d@%zu.%06zu:sh_serial_write·"·"%s·size·%d·offs·0x%02"·PRIx64·"·<-·0x%02"·PRIx64·"\n",

2643

············qemu_log("%d@%zu.%06zu:sh_serial_write·"·"%s·size·%d·offs·0x%02"·PRIx64·"·<-·0x%02"·PRIx64·"\n",

2644

·····················qemu_get_thread_id(),

2644

·····················qemu_get_thread_id(),

2645

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2645

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2646

·····················,·id,·size,·offs,·val);

2646

·····················,·id,·size,·offs,·val);

2647

#line·2649·"trace/trace-hw_char.h"

2647

#line·2649·"trace/trace-hw_char.h"

2648

········}·else·{

2648

········}·else·{

2650

············qemu_log("sh_serial_write·"·"%s·size·%d·offs·0x%02"·PRIx64·"·<-·0x%02"·PRIx64·"\n",·id,·size,·offs,·val);

2650

············qemu_log("sh_serial_write·"·"%s·size·%d·offs·0x%02"·PRIx64·"·<-·0x%02"·PRIx64·"\n",·id,·size,·offs,·val);

2651

#line·2653·"trace/trace-hw_char.h"

2651

#line·2653·"trace/trace-hw_char.h"

2652

········}

2652

········}

2653

····}

2653

····}

2654

}

2654

}

2655

static·inline·void·trace_sh_serial_write(char·*·id,·unsigned·size,·uint64_t·offs,·uint64_t·val)

2655

static·inline·void·trace_sh_serial_write(char·*·id,·unsigned·size,·uint64_t·offs,·uint64_t·val)