/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-20250219-aucltpnr/packages/diff-html reproducibleA reproducibleB

186

static·inline·void·_nocheck__trace_allwinner_sdhost_set_inserted(bool·inserted)

186

static·inline·void·_nocheck__trace_allwinner_sdhost_set_inserted(bool·inserted)

187

{

187

{

188

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

188

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

189

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

189

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

190

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

190

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

191

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

191

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

193

············qemu_log("%d@%zu.%06zu:allwinner_sdhost_set_inserted·"·"inserted·%u"·"\n",

193

············qemu_log("%d@%zu.%06zu:allwinner_sdhost_set_inserted·"·"inserted·%u"·"\n",

194

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

194

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

195

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

195

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

196

·····················,·inserted);

196

·····················,·inserted);

197

#line·199·"trace/trace-hw_sd.h"

197

#line·199·"trace/trace-hw_sd.h"

198

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

198

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

200

············qemu_log("allwinner_sdhost_set_inserted·"·"inserted·%u"·"\n",·inserted);

200

············qemu_log("allwinner_sdhost_set_inserted·"·"inserted·%u"·"\n",·inserted);

201

#line·203·"trace/trace-hw_sd.h"

201

#line·203·"trace/trace-hw_sd.h"

202

········}

202

········}

203

····}

203

····}

204

}

204

}

205

static·inline·void·trace_allwinner_sdhost_set_inserted(bool·inserted)

205

static·inline·void·trace_allwinner_sdhost_set_inserted(bool·inserted)

217

static·inline·void·_nocheck__trace_allwinner_sdhost_process_desc(uint64_t·desc_addr,·uint32_t·desc_size,·bool·is_write,·uint32_t·max_bytes)

217

static·inline·void·_nocheck__trace_allwinner_sdhost_process_desc(uint64_t·desc_addr,·uint32_t·desc_size,·bool·is_write,·uint32_t·max_bytes)

218

{

218

{

219

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

219

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

220

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

220

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

221

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

221

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

222

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

222

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

224

············qemu_log("%d@%zu.%06zu:allwinner_sdhost_process_desc·"·"desc_addr·0x%"·PRIx64·"·desc_size·%"·PRIu32·"·is_write·%u·max_bytes·%"·PRIu32·"\n",

224

············qemu_log("%d@%zu.%06zu:allwinner_sdhost_process_desc·"·"desc_addr·0x%"·PRIx64·"·desc_size·%"·PRIu32·"·is_write·%u·max_bytes·%"·PRIu32·"\n",

225

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

225

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

226

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

226

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

227

·····················,·desc_addr,·desc_size,·is_write,·max_bytes);

227

·····················,·desc_addr,·desc_size,·is_write,·max_bytes);

228

#line·230·"trace/trace-hw_sd.h"

228

#line·230·"trace/trace-hw_sd.h"

229

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

229

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

231

············qemu_log("allwinner_sdhost_process_desc·"·"desc_addr·0x%"·PRIx64·"·desc_size·%"·PRIu32·"·is_write·%u·max_bytes·%"·PRIu32·"\n",·desc_addr,·desc_size,·is_write,·max_bytes);

231

············qemu_log("allwinner_sdhost_process_desc·"·"desc_addr·0x%"·PRIx64·"·desc_size·%"·PRIu32·"·is_write·%u·max_bytes·%"·PRIu32·"\n",·desc_addr,·desc_size,·is_write,·max_bytes);

232

#line·234·"trace/trace-hw_sd.h"

232

#line·234·"trace/trace-hw_sd.h"

233

········}

233

········}

234

····}

234

····}

235

}

235

}

236

static·inline·void·trace_allwinner_sdhost_process_desc(uint64_t·desc_addr,·uint32_t·desc_size,·bool·is_write,·uint32_t·max_bytes)

236

static·inline·void·trace_allwinner_sdhost_process_desc(uint64_t·desc_addr,·uint32_t·desc_size,·bool·is_write,·uint32_t·max_bytes)

248

static·inline·void·_nocheck__trace_allwinner_sdhost_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

248

static·inline·void·_nocheck__trace_allwinner_sdhost_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

249

{

249

{

250

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

250

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

251

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

251

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

252

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

252

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

253

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

253

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

255

············qemu_log("%d@%zu.%06zu:allwinner_sdhost_read·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%"·PRIu32·"\n",

255

············qemu_log("%d@%zu.%06zu:allwinner_sdhost_read·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%"·PRIu32·"\n",

256

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

256

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

257

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

257

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

258

·····················,·offset,·data,·size);

258

·····················,·offset,·data,·size);

259

#line·261·"trace/trace-hw_sd.h"

259

#line·261·"trace/trace-hw_sd.h"

260

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

260

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

262

············qemu_log("allwinner_sdhost_read·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%"·PRIu32·"\n",·offset,·data,·size);

262

············qemu_log("allwinner_sdhost_read·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%"·PRIu32·"\n",·offset,·data,·size);

263

#line·265·"trace/trace-hw_sd.h"

263

#line·265·"trace/trace-hw_sd.h"

264

········}

264

········}

265

····}

265

····}

266

}

266

}

267

static·inline·void·trace_allwinner_sdhost_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

267

static·inline·void·trace_allwinner_sdhost_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

279

static·inline·void·_nocheck__trace_allwinner_sdhost_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

279

static·inline·void·_nocheck__trace_allwinner_sdhost_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

280

{

280

{

281

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

281

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

282

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

282

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

283

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

283

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

284

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

284

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

286

············qemu_log("%d@%zu.%06zu:allwinner_sdhost_write·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%"·PRIu32·"\n",

286

············qemu_log("%d@%zu.%06zu:allwinner_sdhost_write·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%"·PRIu32·"\n",

287

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

287

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

288

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

288

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

289

·····················,·offset,·data,·size);

289

·····················,·offset,·data,·size);

290

#line·292·"trace/trace-hw_sd.h"

290

#line·292·"trace/trace-hw_sd.h"

291

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

291

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

293

············qemu_log("allwinner_sdhost_write·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%"·PRIu32·"\n",·offset,·data,·size);

293

············qemu_log("allwinner_sdhost_write·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%"·PRIu32·"\n",·offset,·data,·size);

294

#line·296·"trace/trace-hw_sd.h"

294

#line·296·"trace/trace-hw_sd.h"

295

········}

295

········}

296

····}

296

····}

297

}

297

}

298

static·inline·void·trace_allwinner_sdhost_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

298

static·inline·void·trace_allwinner_sdhost_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

310

static·inline·void·_nocheck__trace_allwinner_sdhost_update_irq(uint32_t·irq)

310

static·inline·void·_nocheck__trace_allwinner_sdhost_update_irq(uint32_t·irq)

311

{

311

{

312

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

312

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

313

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

313

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

314

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

314

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

315

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

315

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

317

············qemu_log("%d@%zu.%06zu:allwinner_sdhost_update_irq·"·"IRQ·bits·0x%"·PRIx32·"\n",

317

············qemu_log("%d@%zu.%06zu:allwinner_sdhost_update_irq·"·"IRQ·bits·0x%"·PRIx32·"\n",

318

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

318

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

319

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

319

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

320

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

320

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

321

#line·323·"trace/trace-hw_sd.h"

321

#line·323·"trace/trace-hw_sd.h"

322

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

322

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

324

············qemu_log("allwinner_sdhost_update_irq·"·"IRQ·bits·0x%"·PRIx32·"\n",·irq);

324

············qemu_log("allwinner_sdhost_update_irq·"·"IRQ·bits·0x%"·PRIx32·"\n",·irq);

325

#line·327·"trace/trace-hw_sd.h"

325

#line·327·"trace/trace-hw_sd.h"

326

········}

326

········}

327

····}

327

····}

328

}

328

}

329

static·inline·void·trace_allwinner_sdhost_update_irq(uint32_t·irq)

329

static·inline·void·trace_allwinner_sdhost_update_irq(uint32_t·irq)

341

static·inline·void·_nocheck__trace_bcm2835_sdhost_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

341

static·inline·void·_nocheck__trace_bcm2835_sdhost_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

342

{

342

{

343

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

343

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

344

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

344

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

345

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

345

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

346

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

346

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

348

············qemu_log("%d@%zu.%06zu:bcm2835_sdhost_read·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

348

············qemu_log("%d@%zu.%06zu:bcm2835_sdhost_read·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

349

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

349

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

350

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

350

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

351

·····················,·offset,·data,·size);

351

·····················,·offset,·data,·size);

352

#line·354·"trace/trace-hw_sd.h"

352

#line·354·"trace/trace-hw_sd.h"

353

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

353

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

355

············qemu_log("bcm2835_sdhost_read·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

355

············qemu_log("bcm2835_sdhost_read·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

356

#line·358·"trace/trace-hw_sd.h"

356

#line·358·"trace/trace-hw_sd.h"

357

········}

357

········}

358

····}

358

····}

359

}

359

}

360

static·inline·void·trace_bcm2835_sdhost_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

360

static·inline·void·trace_bcm2835_sdhost_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

372

static·inline·void·_nocheck__trace_bcm2835_sdhost_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

372

static·inline·void·_nocheck__trace_bcm2835_sdhost_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

373

{

373

{

374

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

374

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

375

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

375

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

376

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

376

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

377

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

377

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

379

············qemu_log("%d@%zu.%06zu:bcm2835_sdhost_write·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

379

············qemu_log("%d@%zu.%06zu:bcm2835_sdhost_write·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

380

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

380

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

381

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

381

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

382

·····················,·offset,·data,·size);

382

·····················,·offset,·data,·size);

383

#line·385·"trace/trace-hw_sd.h"

383

#line·385·"trace/trace-hw_sd.h"

384

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

384

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

386

············qemu_log("bcm2835_sdhost_write·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

386

············qemu_log("bcm2835_sdhost_write·"·"offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

387

#line·389·"trace/trace-hw_sd.h"

387

#line·389·"trace/trace-hw_sd.h"

388

········}

388

········}

389

····}

389

····}

390

}

390

}

391

static·inline·void·trace_bcm2835_sdhost_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

391

static·inline·void·trace_bcm2835_sdhost_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

403

static·inline·void·_nocheck__trace_bcm2835_sdhost_edm_change(const·char·*·why,·uint32_t·edm)

403

static·inline·void·_nocheck__trace_bcm2835_sdhost_edm_change(const·char·*·why,·uint32_t·edm)

404

{

404

{

405

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

405

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

406

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

406

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

407

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

407

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

408

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

408

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

410

············qemu_log("%d@%zu.%06zu:bcm2835_sdhost_edm_change·"·"(%s)·EDM·now·0x%x"·"\n",

410

············qemu_log("%d@%zu.%06zu:bcm2835_sdhost_edm_change·"·"(%s)·EDM·now·0x%x"·"\n",

411

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

411

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

412

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

412

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

413

·····················,·why,·edm);

413

·····················,·why,·edm);

414

#line·416·"trace/trace-hw_sd.h"

414

#line·416·"trace/trace-hw_sd.h"

415

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

415

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

417

············qemu_log("bcm2835_sdhost_edm_change·"·"(%s)·EDM·now·0x%x"·"\n",·why,·edm);

417

············qemu_log("bcm2835_sdhost_edm_change·"·"(%s)·EDM·now·0x%x"·"\n",·why,·edm);

418

#line·420·"trace/trace-hw_sd.h"

418

#line·420·"trace/trace-hw_sd.h"

419

········}

419

········}

420

····}

420

····}

421

}

421

}

422

static·inline·void·trace_bcm2835_sdhost_edm_change(const·char·*·why,·uint32_t·edm)

422

static·inline·void·trace_bcm2835_sdhost_edm_change(const·char·*·why,·uint32_t·edm)

434

static·inline·void·_nocheck__trace_bcm2835_sdhost_update_irq(uint32_t·irq)

434

static·inline·void·_nocheck__trace_bcm2835_sdhost_update_irq(uint32_t·irq)

435

{

435

{

436

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

436

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

437

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

437

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

438

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

438

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

439

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

439

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

441

············qemu_log("%d@%zu.%06zu:bcm2835_sdhost_update_irq·"·"IRQ·bits·0x%x"·"\n",

441

············qemu_log("%d@%zu.%06zu:bcm2835_sdhost_update_irq·"·"IRQ·bits·0x%x"·"\n",

442

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

442

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

443

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

443

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

444

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

444

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

445

#line·447·"trace/trace-hw_sd.h"

445

#line·447·"trace/trace-hw_sd.h"

446

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

446

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

448

············qemu_log("bcm2835_sdhost_update_irq·"·"IRQ·bits·0x%x"·"\n",·irq);

448

············qemu_log("bcm2835_sdhost_update_irq·"·"IRQ·bits·0x%x"·"\n",·irq);

449

#line·451·"trace/trace-hw_sd.h"

449

#line·451·"trace/trace-hw_sd.h"

450

········}

450

········}

451

····}

451

····}

452

}

452

}

453

static·inline·void·trace_bcm2835_sdhost_update_irq(uint32_t·irq)

453

static·inline·void·trace_bcm2835_sdhost_update_irq(uint32_t·irq)

465

static·inline·void·_nocheck__trace_sdbus_command(const·char·*·bus_name,·uint8_t·cmd,·uint32_t·arg)

465

static·inline·void·_nocheck__trace_sdbus_command(const·char·*·bus_name,·uint8_t·cmd,·uint32_t·arg)

466

{

466

{

467

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

467

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

468

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

468

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

469

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

469

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

470

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

470

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

472

············qemu_log("%d@%zu.%06zu:sdbus_command·"·"@%s·CMD%02d·arg·0x%08x"·"\n",

472

············qemu_log("%d@%zu.%06zu:sdbus_command·"·"@%s·CMD%02d·arg·0x%08x"·"\n",

473

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

473

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

474

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

474

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

475

·····················,·bus_name,·cmd,·arg);

475

·····················,·bus_name,·cmd,·arg);

476

#line·478·"trace/trace-hw_sd.h"

476

#line·478·"trace/trace-hw_sd.h"

477

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

477

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

479

············qemu_log("sdbus_command·"·"@%s·CMD%02d·arg·0x%08x"·"\n",·bus_name,·cmd,·arg);

479

············qemu_log("sdbus_command·"·"@%s·CMD%02d·arg·0x%08x"·"\n",·bus_name,·cmd,·arg);

480

#line·482·"trace/trace-hw_sd.h"

480

#line·482·"trace/trace-hw_sd.h"

481

········}

481

········}

482

····}

482

····}

483

}

483

}

484

static·inline·void·trace_sdbus_command(const·char·*·bus_name,·uint8_t·cmd,·uint32_t·arg)

484

static·inline·void·trace_sdbus_command(const·char·*·bus_name,·uint8_t·cmd,·uint32_t·arg)

496

static·inline·void·_nocheck__trace_sdbus_read(const·char·*·bus_name,·uint8_t·value)

496

static·inline·void·_nocheck__trace_sdbus_read(const·char·*·bus_name,·uint8_t·value)

497

{

497

{

498

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

498

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

499

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

499

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

500

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

500

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

501

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

501

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

503

············qemu_log("%d@%zu.%06zu:sdbus_read·"·"@%s·value·0x%02x"·"\n",

503

············qemu_log("%d@%zu.%06zu:sdbus_read·"·"@%s·value·0x%02x"·"\n",

504

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

504

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

505

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

505

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

506

·····················,·bus_name,·value);

506

·····················,·bus_name,·value);

507

#line·509·"trace/trace-hw_sd.h"

507

#line·509·"trace/trace-hw_sd.h"

508

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

508

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

510

············qemu_log("sdbus_read·"·"@%s·value·0x%02x"·"\n",·bus_name,·value);

510

············qemu_log("sdbus_read·"·"@%s·value·0x%02x"·"\n",·bus_name,·value);

511

#line·513·"trace/trace-hw_sd.h"

511

#line·513·"trace/trace-hw_sd.h"

512

········}

512

········}

513

····}

513

····}

514

}

514

}

515

static·inline·void·trace_sdbus_read(const·char·*·bus_name,·uint8_t·value)

515

static·inline·void·trace_sdbus_read(const·char·*·bus_name,·uint8_t·value)

527

static·inline·void·_nocheck__trace_sdbus_write(const·char·*·bus_name,·uint8_t·value)

527

static·inline·void·_nocheck__trace_sdbus_write(const·char·*·bus_name,·uint8_t·value)

528

{

528

{

529

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

529

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

530

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

530

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

531

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

531

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

532

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

532

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

534

············qemu_log("%d@%zu.%06zu:sdbus_write·"·"@%s·value·0x%02x"·"\n",

534

············qemu_log("%d@%zu.%06zu:sdbus_write·"·"@%s·value·0x%02x"·"\n",

535

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

535

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

536

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

536

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

537

·····················,·bus_name,·value);

537

·····················,·bus_name,·value);

538

#line·540·"trace/trace-hw_sd.h"

538

#line·540·"trace/trace-hw_sd.h"

539

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

539

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

541

············qemu_log("sdbus_write·"·"@%s·value·0x%02x"·"\n",·bus_name,·value);

541

············qemu_log("sdbus_write·"·"@%s·value·0x%02x"·"\n",·bus_name,·value);

542

#line·544·"trace/trace-hw_sd.h"

542

#line·544·"trace/trace-hw_sd.h"

543

········}

543

········}

544

····}

544

····}

545

}

545

}

546

static·inline·void·trace_sdbus_write(const·char·*·bus_name,·uint8_t·value)

546

static·inline·void·trace_sdbus_write(const·char·*·bus_name,·uint8_t·value)

558

static·inline·void·_nocheck__trace_sdbus_set_voltage(const·char·*·bus_name,·uint16_t·millivolts)

558

static·inline·void·_nocheck__trace_sdbus_set_voltage(const·char·*·bus_name,·uint16_t·millivolts)

559

{

559

{

560

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

560

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

561

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

561

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

562

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

562

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

563

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

563

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

565

············qemu_log("%d@%zu.%06zu:sdbus_set_voltage·"·"@%s·%u·(mV)"·"\n",

565

············qemu_log("%d@%zu.%06zu:sdbus_set_voltage·"·"@%s·%u·(mV)"·"\n",

566

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

566

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

567

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

567

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

568

·····················,·bus_name,·millivolts);

568

·····················,·bus_name,·millivolts);

569

#line·571·"trace/trace-hw_sd.h"

569

#line·571·"trace/trace-hw_sd.h"

570

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

570

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

572

············qemu_log("sdbus_set_voltage·"·"@%s·%u·(mV)"·"\n",·bus_name,·millivolts);

572

············qemu_log("sdbus_set_voltage·"·"@%s·%u·(mV)"·"\n",·bus_name,·millivolts);

573

#line·575·"trace/trace-hw_sd.h"

573

#line·575·"trace/trace-hw_sd.h"

574

········}

574

········}

575

····}

575

····}

576

}

576

}

577

static·inline·void·trace_sdbus_set_voltage(const·char·*·bus_name,·uint16_t·millivolts)

577

static·inline·void·trace_sdbus_set_voltage(const·char·*·bus_name,·uint16_t·millivolts)

589

static·inline·void·_nocheck__trace_sdbus_get_dat_lines(const·char·*·bus_name,·uint8_t·dat_lines)

589

static·inline·void·_nocheck__trace_sdbus_get_dat_lines(const·char·*·bus_name,·uint8_t·dat_lines)

590

{

590

{

591

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

591

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

592

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

592

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

593

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

593

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

594

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

594

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

596

············qemu_log("%d@%zu.%06zu:sdbus_get_dat_lines·"·"@%s·dat_lines:·%u"·"\n",

596

············qemu_log("%d@%zu.%06zu:sdbus_get_dat_lines·"·"@%s·dat_lines:·%u"·"\n",

597

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

597

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

598

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

598

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

599

·····················,·bus_name,·dat_lines);

599

·····················,·bus_name,·dat_lines);

600

#line·602·"trace/trace-hw_sd.h"

600

#line·602·"trace/trace-hw_sd.h"

601

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

601

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

603

············qemu_log("sdbus_get_dat_lines·"·"@%s·dat_lines:·%u"·"\n",·bus_name,·dat_lines);

603

············qemu_log("sdbus_get_dat_lines·"·"@%s·dat_lines:·%u"·"\n",·bus_name,·dat_lines);

604

#line·606·"trace/trace-hw_sd.h"

604

#line·606·"trace/trace-hw_sd.h"

605

········}

605

········}

606

····}

606

····}

607

}

607

}

608

static·inline·void·trace_sdbus_get_dat_lines(const·char·*·bus_name,·uint8_t·dat_lines)

608

static·inline·void·trace_sdbus_get_dat_lines(const·char·*·bus_name,·uint8_t·dat_lines)

620

static·inline·void·_nocheck__trace_sdbus_get_cmd_line(const·char·*·bus_name,·bool·cmd_line)

620

static·inline·void·_nocheck__trace_sdbus_get_cmd_line(const·char·*·bus_name,·bool·cmd_line)

621

{

621

{

622

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

622

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

623

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

623

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

624

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

624

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

625

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

625

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

627

············qemu_log("%d@%zu.%06zu:sdbus_get_cmd_line·"·"@%s·cmd_line:·%u"·"\n",

627

············qemu_log("%d@%zu.%06zu:sdbus_get_cmd_line·"·"@%s·cmd_line:·%u"·"\n",

628

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

628

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

629

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

629

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

630

·····················,·bus_name,·cmd_line);

630

·····················,·bus_name,·cmd_line);

631

#line·633·"trace/trace-hw_sd.h"

631

#line·633·"trace/trace-hw_sd.h"

632

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

632

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

634

············qemu_log("sdbus_get_cmd_line·"·"@%s·cmd_line:·%u"·"\n",·bus_name,·cmd_line);

634

············qemu_log("sdbus_get_cmd_line·"·"@%s·cmd_line:·%u"·"\n",·bus_name,·cmd_line);

635

#line·637·"trace/trace-hw_sd.h"

635

#line·637·"trace/trace-hw_sd.h"

636

········}

636

········}

637

····}

637

····}

638

}

638

}

639

static·inline·void·trace_sdbus_get_cmd_line(const·char·*·bus_name,·bool·cmd_line)

639

static·inline·void·trace_sdbus_get_cmd_line(const·char·*·bus_name,·bool·cmd_line)

651

static·inline·void·_nocheck__trace_sdhci_set_inserted(const·char·*·level)

651

static·inline·void·_nocheck__trace_sdhci_set_inserted(const·char·*·level)

652

{

652

{

653

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

653

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

654

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

654

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

655

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

655

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

656

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

656

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

658

············qemu_log("%d@%zu.%06zu:sdhci_set_inserted·"·"card·state·changed:·%s"·"\n",

658

············qemu_log("%d@%zu.%06zu:sdhci_set_inserted·"·"card·state·changed:·%s"·"\n",

659

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

659

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

660

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

660

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

661

·····················,·level);

661

·····················,·level);

662

#line·664·"trace/trace-hw_sd.h"

662

#line·664·"trace/trace-hw_sd.h"

663

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

663

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

665

············qemu_log("sdhci_set_inserted·"·"card·state·changed:·%s"·"\n",·level);

665

············qemu_log("sdhci_set_inserted·"·"card·state·changed:·%s"·"\n",·level);

666

#line·668·"trace/trace-hw_sd.h"

666

#line·668·"trace/trace-hw_sd.h"

667

········}

667

········}

668

····}

668

····}

669

}

669

}

670

static·inline·void·trace_sdhci_set_inserted(const·char·*·level)

670

static·inline·void·trace_sdhci_set_inserted(const·char·*·level)

682

static·inline·void·_nocheck__trace_sdhci_send_command(uint8_t·cmd,·uint32_t·arg)

682

static·inline·void·_nocheck__trace_sdhci_send_command(uint8_t·cmd,·uint32_t·arg)

683

{

683

{

684

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

684

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

685

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

685

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

686

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

686

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

687

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

687

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

689

············qemu_log("%d@%zu.%06zu:sdhci_send_command·"·"CMD%02u·ARG[0x%08x]"·"\n",

689

············qemu_log("%d@%zu.%06zu:sdhci_send_command·"·"CMD%02u·ARG[0x%08x]"·"\n",

690

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

690

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

691

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

691

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

692

·····················,·cmd,·arg);

692

·····················,·cmd,·arg);

693

#line·695·"trace/trace-hw_sd.h"

693

#line·695·"trace/trace-hw_sd.h"

694

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

694

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

696

············qemu_log("sdhci_send_command·"·"CMD%02u·ARG[0x%08x]"·"\n",·cmd,·arg);

696

············qemu_log("sdhci_send_command·"·"CMD%02u·ARG[0x%08x]"·"\n",·cmd,·arg);

697

#line·699·"trace/trace-hw_sd.h"

697

#line·699·"trace/trace-hw_sd.h"

698

········}

698

········}

699

····}

699

····}

700

}

700

}

701

static·inline·void·trace_sdhci_send_command(uint8_t·cmd,·uint32_t·arg)

701

static·inline·void·trace_sdhci_send_command(uint8_t·cmd,·uint32_t·arg)

713

static·inline·void·_nocheck__trace_sdhci_error(const·char·*·msg)

713

static·inline·void·_nocheck__trace_sdhci_error(const·char·*·msg)

714

{

714

{

715

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

715

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

716

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

716

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

717

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

717

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

718

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

718

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

720

············qemu_log("%d@%zu.%06zu:sdhci_error·"·"%s"·"\n",

720

············qemu_log("%d@%zu.%06zu:sdhci_error·"·"%s"·"\n",

721

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

721

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

722

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

722

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

723

·····················,·msg);

723

·····················,·msg);

724

#line·726·"trace/trace-hw_sd.h"

724

#line·726·"trace/trace-hw_sd.h"

725

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

725

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

727

············qemu_log("sdhci_error·"·"%s"·"\n",·msg);

727

············qemu_log("sdhci_error·"·"%s"·"\n",·msg);

728

#line·730·"trace/trace-hw_sd.h"

728

#line·730·"trace/trace-hw_sd.h"

729

········}

729

········}

730

····}

730

····}

731

}

731

}

732

static·inline·void·trace_sdhci_error(const·char·*·msg)

732

static·inline·void·trace_sdhci_error(const·char·*·msg)

744

static·inline·void·_nocheck__trace_sdhci_response4(uint32_t·r0)

744

static·inline·void·_nocheck__trace_sdhci_response4(uint32_t·r0)

745

{

745

{

746

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

746

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

747

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

747

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

748

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

748

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

749

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

749

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

751

············qemu_log("%d@%zu.%06zu:sdhci_response4·"·"RSPREG[31..0]=0x%08x"·"\n",

751

············qemu_log("%d@%zu.%06zu:sdhci_response4·"·"RSPREG[31..0]=0x%08x"·"\n",

752

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

752

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

753

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

753

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

754

·····················,·r0);

754

·····················,·r0);

755

#line·757·"trace/trace-hw_sd.h"

755

#line·757·"trace/trace-hw_sd.h"

756

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

756

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

758

············qemu_log("sdhci_response4·"·"RSPREG[31..0]=0x%08x"·"\n",·r0);

758

············qemu_log("sdhci_response4·"·"RSPREG[31..0]=0x%08x"·"\n",·r0);

759

#line·761·"trace/trace-hw_sd.h"

759

#line·761·"trace/trace-hw_sd.h"

760

········}

760

········}

761

····}

761

····}

762

}

762

}

763

static·inline·void·trace_sdhci_response4(uint32_t·r0)

763

static·inline·void·trace_sdhci_response4(uint32_t·r0)

775

static·inline·void·_nocheck__trace_sdhci_response16(uint32_t·r3,·uint32_t·r2,·uint32_t·r1,·uint32_t·r0)

775

static·inline·void·_nocheck__trace_sdhci_response16(uint32_t·r3,·uint32_t·r2,·uint32_t·r1,·uint32_t·r0)

776

{

776

{

777

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

777

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

778

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

778

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

779

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

779

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

780

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

780

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

782

············qemu_log("%d@%zu.%06zu:sdhci_response16·"·"RSPREG[127..96]=0x%08x,·RSPREG[95..64]=0x%08x,·RSPREG[63..32]=0x%08x,·RSPREG[31..0]=0x%08x"·"\n",

782

············qemu_log("%d@%zu.%06zu:sdhci_response16·"·"RSPREG[127..96]=0x%08x,·RSPREG[95..64]=0x%08x,·RSPREG[63..32]=0x%08x,·RSPREG[31..0]=0x%08x"·"\n",

783

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

783

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

784

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

784

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

785

·····················,·r3,·r2,·r1,·r0);

785

·····················,·r3,·r2,·r1,·r0);

786

#line·788·"trace/trace-hw_sd.h"

786

#line·788·"trace/trace-hw_sd.h"

787

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

787

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

789

············qemu_log("sdhci_response16·"·"RSPREG[127..96]=0x%08x,·RSPREG[95..64]=0x%08x,·RSPREG[63..32]=0x%08x,·RSPREG[31..0]=0x%08x"·"\n",·r3,·r2,·r1,·r0);

789

············qemu_log("sdhci_response16·"·"RSPREG[127..96]=0x%08x,·RSPREG[95..64]=0x%08x,·RSPREG[63..32]=0x%08x,·RSPREG[31..0]=0x%08x"·"\n",·r3,·r2,·r1,·r0);

790

#line·792·"trace/trace-hw_sd.h"

790

#line·792·"trace/trace-hw_sd.h"

791

········}

791

········}

792

····}

792

····}

793

}

793

}

794

static·inline·void·trace_sdhci_response16(uint32_t·r3,·uint32_t·r2,·uint32_t·r1,·uint32_t·r0)

794

static·inline·void·trace_sdhci_response16(uint32_t·r3,·uint32_t·r2,·uint32_t·r1,·uint32_t·r0)

806

static·inline·void·_nocheck__trace_sdhci_end_transfer(uint8_t·cmd,·uint32_t·arg)

806

static·inline·void·_nocheck__trace_sdhci_end_transfer(uint8_t·cmd,·uint32_t·arg)

807

{

807

{

808

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

808

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

809

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

809

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

810

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

810

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

811

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

811

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

813

············qemu_log("%d@%zu.%06zu:sdhci_end_transfer·"·"Automatically·issue·CMD%02u·0x%08x"·"\n",

813

············qemu_log("%d@%zu.%06zu:sdhci_end_transfer·"·"Automatically·issue·CMD%02u·0x%08x"·"\n",

814

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

814

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

815

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

815

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

816

·····················,·cmd,·arg);

816

·····················,·cmd,·arg);

817

#line·819·"trace/trace-hw_sd.h"

817

#line·819·"trace/trace-hw_sd.h"

818

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

818

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

820

············qemu_log("sdhci_end_transfer·"·"Automatically·issue·CMD%02u·0x%08x"·"\n",·cmd,·arg);

820

············qemu_log("sdhci_end_transfer·"·"Automatically·issue·CMD%02u·0x%08x"·"\n",·cmd,·arg);

821

#line·823·"trace/trace-hw_sd.h"

821

#line·823·"trace/trace-hw_sd.h"

822

········}

822

········}

823

····}

823

····}

824

}

824

}

825

static·inline·void·trace_sdhci_end_transfer(uint8_t·cmd,·uint32_t·arg)

825

static·inline·void·trace_sdhci_end_transfer(uint8_t·cmd,·uint32_t·arg)

837

static·inline·void·_nocheck__trace_sdhci_adma(const·char·*·desc,·uint32_t·sysad)

837

static·inline·void·_nocheck__trace_sdhci_adma(const·char·*·desc,·uint32_t·sysad)

838

{

838

{

839

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

839

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

840

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

840

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

841

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

841

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

842

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

842

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

844

············qemu_log("%d@%zu.%06zu:sdhci_adma·"·"%s:·admasysaddr=0x%"·PRIx32·"\n",

844

············qemu_log("%d@%zu.%06zu:sdhci_adma·"·"%s:·admasysaddr=0x%"·PRIx32·"\n",

845

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

845

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

846

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

846

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

847

·····················,·desc,·sysad);

847

·····················,·desc,·sysad);

848

#line·850·"trace/trace-hw_sd.h"

848

#line·850·"trace/trace-hw_sd.h"

849

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

849

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

851

············qemu_log("sdhci_adma·"·"%s:·admasysaddr=0x%"·PRIx32·"\n",·desc,·sysad);

851

············qemu_log("sdhci_adma·"·"%s:·admasysaddr=0x%"·PRIx32·"\n",·desc,·sysad);

852

#line·854·"trace/trace-hw_sd.h"

852

#line·854·"trace/trace-hw_sd.h"

853

········}

853

········}

854

····}

854

····}

855

}

855

}

856

static·inline·void·trace_sdhci_adma(const·char·*·desc,·uint32_t·sysad)

856

static·inline·void·trace_sdhci_adma(const·char·*·desc,·uint32_t·sysad)

868

static·inline·void·_nocheck__trace_sdhci_adma_loop(uint64_t·addr,·uint16_t·length,·uint8_t·attr)

868

static·inline·void·_nocheck__trace_sdhci_adma_loop(uint64_t·addr,·uint16_t·length,·uint8_t·attr)

869

{

869

{

870

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

870

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

871

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

871

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

872

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

872

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

873

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

873

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

875

············qemu_log("%d@%zu.%06zu:sdhci_adma_loop·"·"addr=0x%08"·PRIx64·",·len=%d,·attr=0x%x"·"\n",

875

············qemu_log("%d@%zu.%06zu:sdhci_adma_loop·"·"addr=0x%08"·PRIx64·",·len=%d,·attr=0x%x"·"\n",

876

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

876

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

877

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

877

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

878

·····················,·addr,·length,·attr);

878

·····················,·addr,·length,·attr);

879

#line·881·"trace/trace-hw_sd.h"

879

#line·881·"trace/trace-hw_sd.h"

880

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

880

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

882

············qemu_log("sdhci_adma_loop·"·"addr=0x%08"·PRIx64·",·len=%d,·attr=0x%x"·"\n",·addr,·length,·attr);

882

············qemu_log("sdhci_adma_loop·"·"addr=0x%08"·PRIx64·",·len=%d,·attr=0x%x"·"\n",·addr,·length,·attr);

883

#line·885·"trace/trace-hw_sd.h"

883

#line·885·"trace/trace-hw_sd.h"

884

········}

884

········}

885

····}

885

····}

886

}

886

}

887

static·inline·void·trace_sdhci_adma_loop(uint64_t·addr,·uint16_t·length,·uint8_t·attr)

887

static·inline·void·trace_sdhci_adma_loop(uint64_t·addr,·uint16_t·length,·uint8_t·attr)

899

static·inline·void·_nocheck__trace_sdhci_adma_transfer_completed(void)

899

static·inline·void·_nocheck__trace_sdhci_adma_transfer_completed(void)

900

{

900

{

901

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

901

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

902

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

902

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

903

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

903

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

904

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

904

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

906

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

906

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

907

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

907

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

908

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

908

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

909

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

909

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

910

#line·912·"trace/trace-hw_sd.h"

910

#line·912·"trace/trace-hw_sd.h"

911

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

911

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

913

············qemu_log("sdhci_adma_transfer_completed·"·""·"\n");

913

············qemu_log("sdhci_adma_transfer_completed·"·""·"\n");

914

#line·916·"trace/trace-hw_sd.h"

914

#line·916·"trace/trace-hw_sd.h"

915

········}

915

········}

916

····}

916

····}

917

}

917

}

918

static·inline·void·trace_sdhci_adma_transfer_completed(void)

918

static·inline·void·trace_sdhci_adma_transfer_completed(void)

930

static·inline·void·_nocheck__trace_sdhci_access(const·char·*·access,·unsigned·int·size,·uint64_t·offset,·const·char·*·dir,·uint64_t·val,·uint64_t·val2)

930

static·inline·void·_nocheck__trace_sdhci_access(const·char·*·access,·unsigned·int·size,·uint64_t·offset,·const·char·*·dir,·uint64_t·val,·uint64_t·val2)

931

{

931

{

932

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

932

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

933

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

933

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

934

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

934

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

935

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

935

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

937

············qemu_log("%d@%zu.%06zu:sdhci_access·"·"%s%u:·addr[0x%04"·PRIx64·"]·%s·0x%08"·PRIx64·"·(%"·PRIu64·")"·"\n",

937

············qemu_log("%d@%zu.%06zu:sdhci_access·"·"%s%u:·addr[0x%04"·PRIx64·"]·%s·0x%08"·PRIx64·"·(%"·PRIu64·")"·"\n",

938

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

938

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

939

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

939

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

940

·····················,·access,·size,·offset,·dir,·val,·val2);

940

·····················,·access,·size,·offset,·dir,·val,·val2);

941

#line·943·"trace/trace-hw_sd.h"

941

#line·943·"trace/trace-hw_sd.h"

942

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

942

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

944

············qemu_log("sdhci_access·"·"%s%u:·addr[0x%04"·PRIx64·"]·%s·0x%08"·PRIx64·"·(%"·PRIu64·")"·"\n",·access,·size,·offset,·dir,·val,·val2);

944

············qemu_log("sdhci_access·"·"%s%u:·addr[0x%04"·PRIx64·"]·%s·0x%08"·PRIx64·"·(%"·PRIu64·")"·"\n",·access,·size,·offset,·dir,·val,·val2);

945

#line·947·"trace/trace-hw_sd.h"

945

#line·947·"trace/trace-hw_sd.h"

946

········}

946

········}

947

····}

947

····}

948

}

948

}

949

static·inline·void·trace_sdhci_access(const·char·*·access,·unsigned·int·size,·uint64_t·offset,·const·char·*·dir,·uint64_t·val,·uint64_t·val2)

949

static·inline·void·trace_sdhci_access(const·char·*·access,·unsigned·int·size,·uint64_t·offset,·const·char·*·dir,·uint64_t·val,·uint64_t·val2)

961

static·inline·void·_nocheck__trace_sdhci_read_dataport(uint16_t·data_count)

961

static·inline·void·_nocheck__trace_sdhci_read_dataport(uint16_t·data_count)

962

{

962

{

963

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

963

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

964

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

964

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

965

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

965

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

966

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

966

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

968

············qemu_log("%d@%zu.%06zu:sdhci_read_dataport·"·"all·%u·bytes·of·data·have·been·read·from·input·buffer"·"\n",

968

············qemu_log("%d@%zu.%06zu:sdhci_read_dataport·"·"all·%u·bytes·of·data·have·been·read·from·input·buffer"·"\n",

969

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

969

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

970

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

970

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

971

·····················,·data_count);

971

·····················,·data_count);

972

#line·974·"trace/trace-hw_sd.h"

972

#line·974·"trace/trace-hw_sd.h"

973

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

973

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

975

············qemu_log("sdhci_read_dataport·"·"all·%u·bytes·of·data·have·been·read·from·input·buffer"·"\n",·data_count);

975

············qemu_log("sdhci_read_dataport·"·"all·%u·bytes·of·data·have·been·read·from·input·buffer"·"\n",·data_count);

976

#line·978·"trace/trace-hw_sd.h"

976

#line·978·"trace/trace-hw_sd.h"

977

········}

977

········}

978

····}

978

····}

979

}

979

}

980

static·inline·void·trace_sdhci_read_dataport(uint16_t·data_count)

980

static·inline·void·trace_sdhci_read_dataport(uint16_t·data_count)

992

static·inline·void·_nocheck__trace_sdhci_write_dataport(uint16_t·data_count)

992

static·inline·void·_nocheck__trace_sdhci_write_dataport(uint16_t·data_count)

993

{

993

{

994

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

994

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

995

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

995

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

996

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

996

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

997

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

997

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

999

············qemu_log("%d@%zu.%06zu:sdhci_write_dataport·"·"write·buffer·filled·with·%u·bytes·of·data"·"\n",

999

············qemu_log("%d@%zu.%06zu:sdhci_write_dataport·"·"write·buffer·filled·with·%u·bytes·of·data"·"\n",

1000

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

1000

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

1001

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

1001

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

1002

·····················,·data_count);

1002

·····················,·data_count);

1003

#line·1005·"trace/trace-hw_sd.h"

1003

#line·1005·"trace/trace-hw_sd.h"

1004

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

1004

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

1006

············qemu_log("sdhci_write_dataport·"·"write·buffer·filled·with·%u·bytes·of·data"·"\n",·data_count);

1006

············qemu_log("sdhci_write_dataport·"·"write·buffer·filled·with·%u·bytes·of·data"·"\n",·data_count);

1007

#line·1009·"trace/trace-hw_sd.h"

1007

#line·1009·"trace/trace-hw_sd.h"

1008

········}

1008

········}

1009

····}

1009

····}

1010

}

1010

}

1011

static·inline·void·trace_sdhci_write_dataport(uint16_t·data_count)

1011

static·inline·void·trace_sdhci_write_dataport(uint16_t·data_count)

1023

static·inline·void·_nocheck__trace_sdhci_capareg(const·char·*·desc,·uint16_t·val)

1023

static·inline·void·_nocheck__trace_sdhci_capareg(const·char·*·desc,·uint16_t·val)

1024

{

1024

{

1025

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

1025

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

1026

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

1026

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

1027

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

1027

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

1028

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

1028

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

1030

············qemu_log("%d@%zu.%06zu:sdhci_capareg·"·"%s:·%u"·"\n",

1030

············qemu_log("%d@%zu.%06zu:sdhci_capareg·"·"%s:·%u"·"\n",

1031

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

1031

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

1032

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

1032

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

1033

·····················,·desc,·val);

1033

·····················,·desc,·val);

1034

#line·1036·"trace/trace-hw_sd.h"

1034

#line·1036·"trace/trace-hw_sd.h"

1035

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

1035

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

1037

············qemu_log("sdhci_capareg·"·"%s:·%u"·"\n",·desc,·val);

1037

············qemu_log("sdhci_capareg·"·"%s:·%u"·"\n",·desc,·val);

1038

#line·1040·"trace/trace-hw_sd.h"

1038

#line·1040·"trace/trace-hw_sd.h"

1039

········}

1039

········}

1040

····}

1040

····}

1041

}

1041

}

1042

static·inline·void·trace_sdhci_capareg(const·char·*·desc,·uint16_t·val)

1042

static·inline·void·trace_sdhci_capareg(const·char·*·desc,·uint16_t·val)

1054

static·inline·void·_nocheck__trace_sdcard_normal_command(const·char·*·proto,·const·char·*·cmd_desc,·uint8_t·cmd,·uint32_t·arg,·const·char·*·state)

1054

static·inline·void·_nocheck__trace_sdcard_normal_command(const·char·*·proto,·const·char·*·cmd_desc,·uint8_t·cmd,·uint32_t·arg,·const·char·*·state)

1055

{

1055

{

1056

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

1056

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

1057

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

1057

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

1058

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

1058

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

1059

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

1059

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

1061

············qemu_log("%d@%zu.%06zu:sdcard_normal_command·"·"%s·%20s/·CMD%02d·arg·0x%08x·(state·%s)"·"\n",

1061

············qemu_log("%d@%zu.%06zu:sdcard_normal_command·"·"%s·%20s/·CMD%02d·arg·0x%08x·(state·%s)"·"\n",

1062

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

1062

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

1063

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

1063

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

1064

·····················,·proto,·cmd_desc,·cmd,·arg,·state);

1064

·····················,·proto,·cmd_desc,·cmd,·arg,·state);

1065

#line·1067·"trace/trace-hw_sd.h"

1065

#line·1067·"trace/trace-hw_sd.h"

1066

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

1066

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

1068

············qemu_log("sdcard_normal_command·"·"%s·%20s/·CMD%02d·arg·0x%08x·(state·%s)"·"\n",·proto,·cmd_desc,·cmd,·arg,·state);

1068

············qemu_log("sdcard_normal_command·"·"%s·%20s/·CMD%02d·arg·0x%08x·(state·%s)"·"\n",·proto,·cmd_desc,·cmd,·arg,·state);

1069

#line·1071·"trace/trace-hw_sd.h"

1069

#line·1071·"trace/trace-hw_sd.h"

1070

········}

1070

········}

1071

····}

1071

····}

1072

}

1072

}

1073

static·inline·void·trace_sdcard_normal_command(const·char·*·proto,·const·char·*·cmd_desc,·uint8_t·cmd,·uint32_t·arg,·const·char·*·state)

1073

static·inline·void·trace_sdcard_normal_command(const·char·*·proto,·const·char·*·cmd_desc,·uint8_t·cmd,·uint32_t·arg,·const·char·*·state)

1085

static·inline·void·_nocheck__trace_sdcard_app_command(const·char·*·proto,·const·char·*·acmd_desc,·uint8_t·acmd,·uint32_t·arg,·const·char·*·state)

1085

static·inline·void·_nocheck__trace_sdcard_app_command(const·char·*·proto,·const·char·*·acmd_desc,·uint8_t·acmd,·uint32_t·arg,·const·char·*·state)

1086

{

1086

{

1087

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

1087

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

1088

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

1088

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

1089

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

1089

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

1090

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

1090

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

1092

············qemu_log("%d@%zu.%06zu:sdcard_app_command·"·"%s·%23s/ACMD%02d·arg·0x%08x·(state·%s)"·"\n",

1092

············qemu_log("%d@%zu.%06zu:sdcard_app_command·"·"%s·%23s/ACMD%02d·arg·0x%08x·(state·%s)"·"\n",

1093

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

1093

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

1094

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

1094

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

1095

·····················,·proto,·acmd_desc,·acmd,·arg,·state);

1095

·····················,·proto,·acmd_desc,·acmd,·arg,·state);

1096

#line·1098·"trace/trace-hw_sd.h"

1096

#line·1098·"trace/trace-hw_sd.h"

1097

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

1097

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

1099

············qemu_log("sdcard_app_command·"·"%s·%23s/ACMD%02d·arg·0x%08x·(state·%s)"·"\n",·proto,·acmd_desc,·acmd,·arg,·state);

1099

············qemu_log("sdcard_app_command·"·"%s·%23s/ACMD%02d·arg·0x%08x·(state·%s)"·"\n",·proto,·acmd_desc,·acmd,·arg,·state);

1100

#line·1102·"trace/trace-hw_sd.h"

1100

#line·1102·"trace/trace-hw_sd.h"

1101

········}

1101

········}

1102

····}

1102

····}

1103

}

1103

}

1104

static·inline·void·trace_sdcard_app_command(const·char·*·proto,·const·char·*·acmd_desc,·uint8_t·acmd,·uint32_t·arg,·const·char·*·state)

1104

static·inline·void·trace_sdcard_app_command(const·char·*·proto,·const·char·*·acmd_desc,·uint8_t·acmd,·uint32_t·arg,·const·char·*·state)

1116

static·inline·void·_nocheck__trace_sdcard_response(const·char·*·rspdesc,·int·rsplen)

1116

static·inline·void·_nocheck__trace_sdcard_response(const·char·*·rspdesc,·int·rsplen)

1117

{

1117

{

1118

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

1118

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

1119

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

1119

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

1120

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

1120

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

1121

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

1121

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

1123

············qemu_log("%d@%zu.%06zu:sdcard_response·"·"%s·(sz:%d)"·"\n",

1123

············qemu_log("%d@%zu.%06zu:sdcard_response·"·"%s·(sz:%d)"·"\n",

1124

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

1124

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

1125

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

1125

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

1126

·····················,·rspdesc,·rsplen);

1126

·····················,·rspdesc,·rsplen);

1127

#line·1129·"trace/trace-hw_sd.h"

1127

#line·1129·"trace/trace-hw_sd.h"

1128

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

1128

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

1130

············qemu_log("sdcard_response·"·"%s·(sz:%d)"·"\n",·rspdesc,·rsplen);

1130

············qemu_log("sdcard_response·"·"%s·(sz:%d)"·"\n",·rspdesc,·rsplen);

1131

#line·1133·"trace/trace-hw_sd.h"

1131

#line·1133·"trace/trace-hw_sd.h"

1132

········}

1132

········}

1133

····}

1133

····}

1134

}

1134

}

1135

static·inline·void·trace_sdcard_response(const·char·*·rspdesc,·int·rsplen)

1135

static·inline·void·trace_sdcard_response(const·char·*·rspdesc,·int·rsplen)

1147

static·inline·void·_nocheck__trace_sdcard_powerup(void)

1147

static·inline·void·_nocheck__trace_sdcard_powerup(void)

1148

{

1148

{

1149

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

1149

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

1150

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

1150

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

1151

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

1151

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

1152

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

1152

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

1154

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

1154

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

1155

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

1155

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

1156

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

1156

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

1157

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

1157

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

1158

#line·1160·"trace/trace-hw_sd.h"

1158

#line·1160·"trace/trace-hw_sd.h"

1159

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

1159

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

1161

············qemu_log("sdcard_powerup·"·""·"\n");

1161

············qemu_log("sdcard_powerup·"·""·"\n");

1162

#line·1164·"trace/trace-hw_sd.h"

1162

#line·1164·"trace/trace-hw_sd.h"

1163

········}

1163

········}

1164

····}

1164

····}

1165

}

1165

}

1166

static·inline·void·trace_sdcard_powerup(void)

1166

static·inline·void·trace_sdcard_powerup(void)

1178

static·inline·void·_nocheck__trace_sdcard_inquiry_cmd41(void)

1178

static·inline·void·_nocheck__trace_sdcard_inquiry_cmd41(void)

1179

{

1179

{

1180

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

1180

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

1181

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

1181

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

1182

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

1182

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

1183

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

1183

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

1185

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

1185

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

1186

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

1186

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

1187

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

1187

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

1188

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

1188

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

1189

#line·1191·"trace/trace-hw_sd.h"

1189

#line·1191·"trace/trace-hw_sd.h"

1190

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

1190

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

1192

············qemu_log("sdcard_inquiry_cmd41·"·""·"\n");

1192

············qemu_log("sdcard_inquiry_cmd41·"·""·"\n");

1193

#line·1195·"trace/trace-hw_sd.h"

1193

#line·1195·"trace/trace-hw_sd.h"

1194

········}

1194

········}

1195

····}

1195

····}

1196

}

1196

}

1197

static·inline·void·trace_sdcard_inquiry_cmd41(void)

1197

static·inline·void·trace_sdcard_inquiry_cmd41(void)

1209

static·inline·void·_nocheck__trace_sdcard_reset(void)

1209

static·inline·void·_nocheck__trace_sdcard_reset(void)

1210

{

1210

{

1211

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

1211

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

1212

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

1212

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

1213

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

1213

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

1214

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

1214

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

1216

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

1216

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

1217

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

1217

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

1218

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

1218

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

1219

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

1219

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

1220

#line·1222·"trace/trace-hw_sd.h"

1220

#line·1222·"trace/trace-hw_sd.h"

1221

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

1221

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

1223

············qemu_log("sdcard_reset·"·""·"\n");

1223

············qemu_log("sdcard_reset·"·""·"\n");

1224

#line·1226·"trace/trace-hw_sd.h"

1224

#line·1226·"trace/trace-hw_sd.h"

1225

········}

1225

········}

1226

····}

1226

····}

1227

}

1227

}

1228

static·inline·void·trace_sdcard_reset(void)

1228

static·inline·void·trace_sdcard_reset(void)

1240

static·inline·void·_nocheck__trace_sdcard_set_blocklen(uint16_t·length)

1240

static·inline·void·_nocheck__trace_sdcard_set_blocklen(uint16_t·length)

1241

{

1241

{

1242

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

1242

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

1243

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

1243

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

1244

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

1244

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

1245

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

1245

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

1247

············qemu_log("%d@%zu.%06zu:sdcard_set_blocklen·"·"0x%03x"·"\n",

1247

············qemu_log("%d@%zu.%06zu:sdcard_set_blocklen·"·"0x%03x"·"\n",

1248

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

1248

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

1249

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

1249

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

1250

·····················,·length);

1250

·····················,·length);

1251

#line·1253·"trace/trace-hw_sd.h"

1251

#line·1253·"trace/trace-hw_sd.h"

1252

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

1252

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

1254

············qemu_log("sdcard_set_blocklen·"·"0x%03x"·"\n",·length);

1254

············qemu_log("sdcard_set_blocklen·"·"0x%03x"·"\n",·length);

1255

#line·1257·"trace/trace-hw_sd.h"

1255

#line·1257·"trace/trace-hw_sd.h"

1256

········}

1256

········}

1257

····}

1257

····}

1258

}

1258

}

1259

static·inline·void·trace_sdcard_set_blocklen(uint16_t·length)

1259

static·inline·void·trace_sdcard_set_blocklen(uint16_t·length)

1271

static·inline·void·_nocheck__trace_sdcard_inserted(bool·readonly)

1271

static·inline·void·_nocheck__trace_sdcard_inserted(bool·readonly)

1272

{

1272

{

1273

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

1273

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

1274

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

1274

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

1275

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

1275

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

1276

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

1276

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

1278

············qemu_log("%d@%zu.%06zu:sdcard_inserted·"·"read_only:·%u"·"\n",

1278

············qemu_log("%d@%zu.%06zu:sdcard_inserted·"·"read_only:·%u"·"\n",

1279

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

1279

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

1280

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

1280

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

1281

·····················,·readonly);

1281

·····················,·readonly);

1282

#line·1284·"trace/trace-hw_sd.h"

1282

#line·1284·"trace/trace-hw_sd.h"

1283

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

1283

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

1285

············qemu_log("sdcard_inserted·"·"read_only:·%u"·"\n",·readonly);

1285

············qemu_log("sdcard_inserted·"·"read_only:·%u"·"\n",·readonly);

1286

#line·1288·"trace/trace-hw_sd.h"

1286

#line·1288·"trace/trace-hw_sd.h"

1287

········}

1287

········}

1288

····}

1288

····}

1289

}

1289

}

1290

static·inline·void·trace_sdcard_inserted(bool·readonly)

1290

static·inline·void·trace_sdcard_inserted(bool·readonly)

1302

static·inline·void·_nocheck__trace_sdcard_ejected(void)

1302

static·inline·void·_nocheck__trace_sdcard_ejected(void)

1303

{

1303

{

1304

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

1304

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

1305

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

1305

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

1306

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

1306

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

1307

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

1307

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

1309

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

1309

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

1310

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

1310

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

1311

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

1311

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

1312

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

1312

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

1313

#line·1315·"trace/trace-hw_sd.h"

1313

#line·1315·"trace/trace-hw_sd.h"

1314

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

1314

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

1316

············qemu_log("sdcard_ejected·"·""·"\n");

1316

············qemu_log("sdcard_ejected·"·""·"\n");

1317

#line·1319·"trace/trace-hw_sd.h"

1317

#line·1319·"trace/trace-hw_sd.h"

1318

········}

1318

········}

1319

····}

1319

····}

1320

}

1320

}

1321

static·inline·void·trace_sdcard_ejected(void)

1321

static·inline·void·trace_sdcard_ejected(void)

1333

static·inline·void·_nocheck__trace_sdcard_erase(uint32_t·first,·uint32_t·last)

1333

static·inline·void·_nocheck__trace_sdcard_erase(uint32_t·first,·uint32_t·last)

1334

{

1334

{

1335

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

1335

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

1336

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

1336

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

1337

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

1337

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

1338

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

1338

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

1340

············qemu_log("%d@%zu.%06zu:sdcard_erase·"·"addr·first·0x%"·PRIx32"·last·0x%"·PRIx32·"\n",

1340

············qemu_log("%d@%zu.%06zu:sdcard_erase·"·"addr·first·0x%"·PRIx32"·last·0x%"·PRIx32·"\n",

1341

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

1341

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

1342

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

1342

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

1343

·····················,·first,·last);

1343

·····················,·first,·last);

1344

#line·1346·"trace/trace-hw_sd.h"

1344

#line·1346·"trace/trace-hw_sd.h"

1345

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

1345

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

1347

············qemu_log("sdcard_erase·"·"addr·first·0x%"·PRIx32"·last·0x%"·PRIx32·"\n",·first,·last);

1347

············qemu_log("sdcard_erase·"·"addr·first·0x%"·PRIx32"·last·0x%"·PRIx32·"\n",·first,·last);

1348

#line·1350·"trace/trace-hw_sd.h"

1348

#line·1350·"trace/trace-hw_sd.h"

1349

········}

1349

········}

1350

····}

1350

····}

1351

}

1351

}

1352

static·inline·void·trace_sdcard_erase(uint32_t·first,·uint32_t·last)

1352

static·inline·void·trace_sdcard_erase(uint32_t·first,·uint32_t·last)

1364

static·inline·void·_nocheck__trace_sdcard_lock(void)

1364

static·inline·void·_nocheck__trace_sdcard_lock(void)

1365

{

1365

{

1366

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

1366

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

1367

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

1367

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

1368

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

1368

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

1369

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

1369

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

1371

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

1371

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

1372

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

1372

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

1373

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

1373

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

1374

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

1374

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

1375

#line·1377·"trace/trace-hw_sd.h"

1375

#line·1377·"trace/trace-hw_sd.h"

1376

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

1376

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

1378

············qemu_log("sdcard_lock·"·""·"\n");

1378

············qemu_log("sdcard_lock·"·""·"\n");

1379

#line·1381·"trace/trace-hw_sd.h"

1379

#line·1381·"trace/trace-hw_sd.h"

1380

········}

1380

········}

1381

····}

1381

····}

1382

}

1382

}

1383

static·inline·void·trace_sdcard_lock(void)

1383

static·inline·void·trace_sdcard_lock(void)

1395

static·inline·void·_nocheck__trace_sdcard_unlock(void)

1395

static·inline·void·_nocheck__trace_sdcard_unlock(void)

1396

{

1396

{

1397

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

1397

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

1398

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

1398

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

1399

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

1399

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

1400

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

1400

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

1402

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

1402

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

1403

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

1403

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

1404

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

1404

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

1405

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

1405

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

1406

#line·1408·"trace/trace-hw_sd.h"

1406

#line·1408·"trace/trace-hw_sd.h"

1407

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

1407

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

1409

············qemu_log("sdcard_unlock·"·""·"\n");

1409

············qemu_log("sdcard_unlock·"·""·"\n");

1410

#line·1412·"trace/trace-hw_sd.h"

1410

#line·1412·"trace/trace-hw_sd.h"

1411

········}

1411

········}

1412

····}

1412

····}

1413

}

1413

}

1414

static·inline·void·trace_sdcard_unlock(void)

1414

static·inline·void·trace_sdcard_unlock(void)

1426

static·inline·void·_nocheck__trace_sdcard_read_block(uint64_t·addr,·uint32_t·len)

1426

static·inline·void·_nocheck__trace_sdcard_read_block(uint64_t·addr,·uint32_t·len)

1427

{

1427

{

1428

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

1428

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

1429

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

1429

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

1430

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

1430

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

1431

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

1431

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

1433

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

1433

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

1434

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

1434

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

1435

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

1435

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

1436

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

1436

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

1437

#line·1439·"trace/trace-hw_sd.h"

1437

#line·1439·"trace/trace-hw_sd.h"

1438

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

1438

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

1440

············qemu_log("sdcard_read_block·"·"addr·0x%"·PRIx64·"·size·0x%x"·"\n",·addr,·len);

1440

············qemu_log("sdcard_read_block·"·"addr·0x%"·PRIx64·"·size·0x%x"·"\n",·addr,·len);

1441

#line·1443·"trace/trace-hw_sd.h"

1441

#line·1443·"trace/trace-hw_sd.h"

1442

········}

1442

········}

1443

····}

1443

····}

1444

}

1444

}

1445

static·inline·void·trace_sdcard_read_block(uint64_t·addr,·uint32_t·len)

1445

static·inline·void·trace_sdcard_read_block(uint64_t·addr,·uint32_t·len)

1457

static·inline·void·_nocheck__trace_sdcard_write_block(uint64_t·addr,·uint32_t·len)

1457

static·inline·void·_nocheck__trace_sdcard_write_block(uint64_t·addr,·uint32_t·len)

1458

{

1458

{

1459

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

1459

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

1460

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

1460

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

1461

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

1461

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

1462

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

1462

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

1464

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

1464

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

1465

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

1465

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

1466

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

1466

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

1467

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

1467

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

1468

#line·1470·"trace/trace-hw_sd.h"

1468

#line·1470·"trace/trace-hw_sd.h"

1469

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

1469

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

1471

············qemu_log("sdcard_write_block·"·"addr·0x%"·PRIx64·"·size·0x%x"·"\n",·addr,·len);

1471

············qemu_log("sdcard_write_block·"·"addr·0x%"·PRIx64·"·size·0x%x"·"\n",·addr,·len);

1472

#line·1474·"trace/trace-hw_sd.h"

1472

#line·1474·"trace/trace-hw_sd.h"

1473

········}

1473

········}

1474

····}

1474

····}

1475

}

1475

}

1476

static·inline·void·trace_sdcard_write_block(uint64_t·addr,·uint32_t·len)

1476

static·inline·void·trace_sdcard_write_block(uint64_t·addr,·uint32_t·len)

1488

static·inline·void·_nocheck__trace_sdcard_write_data(const·char·*·proto,·const·char·*·cmd_desc,·uint8_t·cmd,·uint8_t·value)

1488

static·inline·void·_nocheck__trace_sdcard_write_data(const·char·*·proto,·const·char·*·cmd_desc,·uint8_t·cmd,·uint8_t·value)

1489

{

1489

{

1490

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

1490

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

1491

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

1491

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

1492

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

1492

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

1493

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

1493

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

1495

············qemu_log("%d@%zu.%06zu:sdcard_write_data·"·"%s·%20s/·CMD%02d·value·0x%02x"·"\n",

1495

············qemu_log("%d@%zu.%06zu:sdcard_write_data·"·"%s·%20s/·CMD%02d·value·0x%02x"·"\n",

1496

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

1496

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

1497

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

1497

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

1498

·····················,·proto,·cmd_desc,·cmd,·value);

1498

·····················,·proto,·cmd_desc,·cmd,·value);

1499

#line·1501·"trace/trace-hw_sd.h"

1499

#line·1501·"trace/trace-hw_sd.h"

1500

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

1500

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

1502

············qemu_log("sdcard_write_data·"·"%s·%20s/·CMD%02d·value·0x%02x"·"\n",·proto,·cmd_desc,·cmd,·value);

1502

············qemu_log("sdcard_write_data·"·"%s·%20s/·CMD%02d·value·0x%02x"·"\n",·proto,·cmd_desc,·cmd,·value);

1503

#line·1505·"trace/trace-hw_sd.h"

1503

#line·1505·"trace/trace-hw_sd.h"

1504

········}

1504

········}

1505

····}

1505

····}

1506

}

1506

}

1507

static·inline·void·trace_sdcard_write_data(const·char·*·proto,·const·char·*·cmd_desc,·uint8_t·cmd,·uint8_t·value)

1507

static·inline·void·trace_sdcard_write_data(const·char·*·proto,·const·char·*·cmd_desc,·uint8_t·cmd,·uint8_t·value)

1519

static·inline·void·_nocheck__trace_sdcard_read_data(const·char·*·proto,·const·char·*·cmd_desc,·uint8_t·cmd,·uint32_t·length)

1519

static·inline·void·_nocheck__trace_sdcard_read_data(const·char·*·proto,·const·char·*·cmd_desc,·uint8_t·cmd,·uint32_t·length)

1520

{

1520

{

1521

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

1521

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

1522

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

1522

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

1523

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

1523

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

1524

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

1524

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

1526

············qemu_log("%d@%zu.%06zu:sdcard_read_data·"·"%s·%20s/·CMD%02d·len·%"·PRIu32·"\n",

1526

············qemu_log("%d@%zu.%06zu:sdcard_read_data·"·"%s·%20s/·CMD%02d·len·%"·PRIu32·"\n",

1527

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

1527

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

1528

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

1528

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

1529

·····················,·proto,·cmd_desc,·cmd,·length);

1529

·····················,·proto,·cmd_desc,·cmd,·length);

1530

#line·1532·"trace/trace-hw_sd.h"

1530

#line·1532·"trace/trace-hw_sd.h"

1531

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

1531

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

1533

············qemu_log("sdcard_read_data·"·"%s·%20s/·CMD%02d·len·%"·PRIu32·"\n",·proto,·cmd_desc,·cmd,·length);

1533

············qemu_log("sdcard_read_data·"·"%s·%20s/·CMD%02d·len·%"·PRIu32·"\n",·proto,·cmd_desc,·cmd,·length);

1534

#line·1536·"trace/trace-hw_sd.h"

1534

#line·1536·"trace/trace-hw_sd.h"

1535

········}

1535

········}

1536

····}

1536

····}

1537

}

1537

}

1538

static·inline·void·trace_sdcard_read_data(const·char·*·proto,·const·char·*·cmd_desc,·uint8_t·cmd,·uint32_t·length)

1538

static·inline·void·trace_sdcard_read_data(const·char·*·proto,·const·char·*·cmd_desc,·uint8_t·cmd,·uint32_t·length)

1550

static·inline·void·_nocheck__trace_sdcard_set_voltage(uint16_t·millivolts)

1550

static·inline·void·_nocheck__trace_sdcard_set_voltage(uint16_t·millivolts)

1551

{

1551

{

1552

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

1552

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

1553

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

1553

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

1554

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

1554

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

1555

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

1555

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

1557

············qemu_log("%d@%zu.%06zu:sdcard_set_voltage·"·"%u·mV"·"\n",

1557

············qemu_log("%d@%zu.%06zu:sdcard_set_voltage·"·"%u·mV"·"\n",

1558

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

1558

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

1559

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

1559

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

1560

·····················,·millivolts);

1560

·····················,·millivolts);

1561

#line·1563·"trace/trace-hw_sd.h"

1561

#line·1563·"trace/trace-hw_sd.h"

1562

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

1562

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

1564

············qemu_log("sdcard_set_voltage·"·"%u·mV"·"\n",·millivolts);

1564

············qemu_log("sdcard_set_voltage·"·"%u·mV"·"\n",·millivolts);

1565

#line·1567·"trace/trace-hw_sd.h"

1565

#line·1567·"trace/trace-hw_sd.h"

1566

········}

1566

········}

1567

····}

1567

····}

1568

}

1568

}

1569

static·inline·void·trace_sdcard_set_voltage(uint16_t·millivolts)

1569

static·inline·void·trace_sdcard_set_voltage(uint16_t·millivolts)

1581

static·inline·void·_nocheck__trace_pxa2xx_mmci_read(uint8_t·size,·uint32_t·addr,·uint32_t·value)

1581

static·inline·void·_nocheck__trace_pxa2xx_mmci_read(uint8_t·size,·uint32_t·addr,·uint32_t·value)

1582

{

1582

{

1583

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

1583

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

1584

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

1584

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

1585

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

1585

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

1586

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

1586

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

1588

············qemu_log("%d@%zu.%06zu:pxa2xx_mmci_read·"·"size·%d·addr·0x%02x·value·0x%08x"·"\n",

1588

············qemu_log("%d@%zu.%06zu:pxa2xx_mmci_read·"·"size·%d·addr·0x%02x·value·0x%08x"·"\n",

1589

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

1589

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

1590

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

1590

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

1591

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

1591

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

1592

#line·1594·"trace/trace-hw_sd.h"

1592

#line·1594·"trace/trace-hw_sd.h"

1593

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

1593

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

1595

············qemu_log("pxa2xx_mmci_read·"·"size·%d·addr·0x%02x·value·0x%08x"·"\n",·size,·addr,·value);

1595

············qemu_log("pxa2xx_mmci_read·"·"size·%d·addr·0x%02x·value·0x%08x"·"\n",·size,·addr,·value);

1596

#line·1598·"trace/trace-hw_sd.h"

1596

#line·1598·"trace/trace-hw_sd.h"

1597

········}

1597

········}

1598

····}

1598

····}

1599

}

1599

}

1600

static·inline·void·trace_pxa2xx_mmci_read(uint8_t·size,·uint32_t·addr,·uint32_t·value)

1600

static·inline·void·trace_pxa2xx_mmci_read(uint8_t·size,·uint32_t·addr,·uint32_t·value)

1612

static·inline·void·_nocheck__trace_pxa2xx_mmci_write(uint8_t·size,·uint32_t·addr,·uint32_t·value)

1612

static·inline·void·_nocheck__trace_pxa2xx_mmci_write(uint8_t·size,·uint32_t·addr,·uint32_t·value)

1613

{

1613

{

1614

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

1614

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

1615

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

1615

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

1616

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

1616

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

1617

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

1617

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

1619

············qemu_log("%d@%zu.%06zu:pxa2xx_mmci_write·"·"size·%d·addr·0x%02x·value·0x%08x"·"\n",

1619

············qemu_log("%d@%zu.%06zu:pxa2xx_mmci_write·"·"size·%d·addr·0x%02x·value·0x%08x"·"\n",

1620

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

1620

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

1621

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

1621

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

1622

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

1622

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

1623

#line·1625·"trace/trace-hw_sd.h"

1623

#line·1625·"trace/trace-hw_sd.h"

1624

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

1624

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

1626

············qemu_log("pxa2xx_mmci_write·"·"size·%d·addr·0x%02x·value·0x%08x"·"\n",·size,·addr,·value);

1626

············qemu_log("pxa2xx_mmci_write·"·"size·%d·addr·0x%02x·value·0x%08x"·"\n",·size,·addr,·value);

1627

#line·1629·"trace/trace-hw_sd.h"

1627

#line·1629·"trace/trace-hw_sd.h"

1628

········}

1628

········}

1629

····}

1629

····}

1630

}

1630

}

1631

static·inline·void·trace_pxa2xx_mmci_write(uint8_t·size,·uint32_t·addr,·uint32_t·value)

1631

static·inline·void·trace_pxa2xx_mmci_write(uint8_t·size,·uint32_t·addr,·uint32_t·value)

1643

static·inline·void·_nocheck__trace_pl181_command_send(uint8_t·cmd,·uint32_t·arg)

1643

static·inline·void·_nocheck__trace_pl181_command_send(uint8_t·cmd,·uint32_t·arg)

1644

{

1644

{

1645

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

1645

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

1646

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

1646

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

1647

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

1647

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

1648

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

1648

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

1650

············qemu_log("%d@%zu.%06zu:pl181_command_send·"·"sending·CMD%02d·arg·0x%08"·PRIx32·"\n",

1650

············qemu_log("%d@%zu.%06zu:pl181_command_send·"·"sending·CMD%02d·arg·0x%08"·PRIx32·"\n",

1651

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

1651

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

1652

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

1652

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

1653

·····················,·cmd,·arg);

1653

·····················,·cmd,·arg);

1654

#line·1656·"trace/trace-hw_sd.h"

1654

#line·1656·"trace/trace-hw_sd.h"

1655

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

1655

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

1657

············qemu_log("pl181_command_send·"·"sending·CMD%02d·arg·0x%08"·PRIx32·"\n",·cmd,·arg);

1657

············qemu_log("pl181_command_send·"·"sending·CMD%02d·arg·0x%08"·PRIx32·"\n",·cmd,·arg);

1658

#line·1660·"trace/trace-hw_sd.h"

1658

#line·1660·"trace/trace-hw_sd.h"

1659

········}

1659

········}

1660

····}

1660

····}

1661

}

1661

}

1662

static·inline·void·trace_pl181_command_send(uint8_t·cmd,·uint32_t·arg)

1662

static·inline·void·trace_pl181_command_send(uint8_t·cmd,·uint32_t·arg)

1674

static·inline·void·_nocheck__trace_pl181_command_sent(void)

1674

static·inline·void·_nocheck__trace_pl181_command_sent(void)

1675

{

1675

{

1676

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

1676

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

1677

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

1677

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

1678

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

1678

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

1679

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

1679

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

1681

············qemu_log("%d@%zu.%06zu:pl181_command_sent·"·"command·sent"·"\n",

1681

············qemu_log("%d@%zu.%06zu:pl181_command_sent·"·"command·sent"·"\n",

1682

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

1682

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

1683

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

1683

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

1684

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

1684

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

1685

#line·1687·"trace/trace-hw_sd.h"

1685

#line·1687·"trace/trace-hw_sd.h"

1686

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

1686

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

1688

············qemu_log("pl181_command_sent·"·"command·sent"·"\n");

1688

············qemu_log("pl181_command_sent·"·"command·sent"·"\n");

1689

#line·1691·"trace/trace-hw_sd.h"

1689

#line·1691·"trace/trace-hw_sd.h"

1690

········}

1690

········}

1691

····}

1691

····}

1692

}

1692

}

1693

static·inline·void·trace_pl181_command_sent(void)

1693

static·inline·void·trace_pl181_command_sent(void)

1705

static·inline·void·_nocheck__trace_pl181_command_response_pending(void)

1705

static·inline·void·_nocheck__trace_pl181_command_response_pending(void)

1706

{

1706

{

1707

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

1707

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

1708

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

1708

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

1709

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

1709

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

1710

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

1710

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

1712

············qemu_log("%d@%zu.%06zu:pl181_command_response_pending·"·"response·received"·"\n",

1712

············qemu_log("%d@%zu.%06zu:pl181_command_response_pending·"·"response·received"·"\n",

1713

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

1713

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

1714

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

1714

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

1715

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

1715

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

1716

#line·1718·"trace/trace-hw_sd.h"

1716

#line·1718·"trace/trace-hw_sd.h"

1717

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

1717

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

1719

············qemu_log("pl181_command_response_pending·"·"response·received"·"\n");

1719

············qemu_log("pl181_command_response_pending·"·"response·received"·"\n");

1720

#line·1722·"trace/trace-hw_sd.h"

1720

#line·1722·"trace/trace-hw_sd.h"

1721

········}

1721

········}

1722

····}

1722

····}

1723

}

1723

}

1724

static·inline·void·trace_pl181_command_response_pending(void)

1724

static·inline·void·trace_pl181_command_response_pending(void)

1736

static·inline·void·_nocheck__trace_pl181_command_timeout(void)

1736

static·inline·void·_nocheck__trace_pl181_command_timeout(void)

1737

{

1737

{

1738

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

1738

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

1739

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

1739

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

1740

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

1740

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

1741

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

1741

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

1743

············qemu_log("%d@%zu.%06zu:pl181_command_timeout·"·"command·timeouted"·"\n",

1743

············qemu_log("%d@%zu.%06zu:pl181_command_timeout·"·"command·timeouted"·"\n",

1744

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

1744

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

1745

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

1745

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

1746

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

1746

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

1747

#line·1749·"trace/trace-hw_sd.h"

1747

#line·1749·"trace/trace-hw_sd.h"

1748

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

1748

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

1750

············qemu_log("pl181_command_timeout·"·"command·timeouted"·"\n");

1750

············qemu_log("pl181_command_timeout·"·"command·timeouted"·"\n");

1751

#line·1753·"trace/trace-hw_sd.h"

1751

#line·1753·"trace/trace-hw_sd.h"

1752

········}

1752

········}

1753

····}

1753

····}

1754

}

1754

}

1755

static·inline·void·trace_pl181_command_timeout(void)

1755

static·inline·void·trace_pl181_command_timeout(void)

1767

static·inline·void·_nocheck__trace_pl181_fifo_push(uint32_t·data)

1767

static·inline·void·_nocheck__trace_pl181_fifo_push(uint32_t·data)

1768

{

1768

{

1769

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

1769

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

1770

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

1770

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

1771

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

1771

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

1772

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

1772

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

1774

············qemu_log("%d@%zu.%06zu:pl181_fifo_push·"·"FIFO·push·0x%08"·PRIx32·"\n",

1774

············qemu_log("%d@%zu.%06zu:pl181_fifo_push·"·"FIFO·push·0x%08"·PRIx32·"\n",

1775

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

1775

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

1776

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

1776

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

1777

·····················,·data);

1777

·····················,·data);

1778

#line·1780·"trace/trace-hw_sd.h"

1778

#line·1780·"trace/trace-hw_sd.h"

1779

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

1779

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

1781

············qemu_log("pl181_fifo_push·"·"FIFO·push·0x%08"·PRIx32·"\n",·data);

1781

············qemu_log("pl181_fifo_push·"·"FIFO·push·0x%08"·PRIx32·"\n",·data);

1782

#line·1784·"trace/trace-hw_sd.h"

1782

#line·1784·"trace/trace-hw_sd.h"

1783

········}

1783

········}

1784

····}

1784

····}

1785

}

1785

}

1786

static·inline·void·trace_pl181_fifo_push(uint32_t·data)

1786

static·inline·void·trace_pl181_fifo_push(uint32_t·data)

1798

static·inline·void·_nocheck__trace_pl181_fifo_pop(uint32_t·data)

1798

static·inline·void·_nocheck__trace_pl181_fifo_pop(uint32_t·data)

1799

{

1799

{

1800

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

1800

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

1801

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

1801

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

1802

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

1802

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

1803

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

1803

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

1805

············qemu_log("%d@%zu.%06zu:pl181_fifo_pop·"·"FIFO·pop·0x%08"·PRIx32·"\n",

1805

············qemu_log("%d@%zu.%06zu:pl181_fifo_pop·"·"FIFO·pop·0x%08"·PRIx32·"\n",

1806

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

1806

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

1807

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

1807

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

1808

·····················,·data);

1808

·····················,·data);

1809

#line·1811·"trace/trace-hw_sd.h"

1809

#line·1811·"trace/trace-hw_sd.h"

1810

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

1810

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

1812

············qemu_log("pl181_fifo_pop·"·"FIFO·pop·0x%08"·PRIx32·"\n",·data);

1812

············qemu_log("pl181_fifo_pop·"·"FIFO·pop·0x%08"·PRIx32·"\n",·data);

1813

#line·1815·"trace/trace-hw_sd.h"

1813

#line·1815·"trace/trace-hw_sd.h"

1814

········}

1814

········}

1815

····}

1815

····}

1816

}

1816

}

1817

static·inline·void·trace_pl181_fifo_pop(uint32_t·data)

1817

static·inline·void·trace_pl181_fifo_pop(uint32_t·data)

1829

static·inline·void·_nocheck__trace_pl181_fifo_transfer_complete(void)

1829

static·inline·void·_nocheck__trace_pl181_fifo_transfer_complete(void)

1830

{

1830

{

1831

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

1831

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

1832

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

1832

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

1833

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

1833

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

1834

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

1834

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

1836

············qemu_log("%d@%zu.%06zu:pl181_fifo_transfer_complete·"·"FIFO·transfer·complete"·"\n",

1836

············qemu_log("%d@%zu.%06zu:pl181_fifo_transfer_complete·"·"FIFO·transfer·complete"·"\n",

1837

·····················qemu_get_thread_id(),

1837

·····················qemu_get_thread_id(),

1838

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1838

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1839

·····················);

1839

·····················);

1840

#line·1842·"trace/trace-hw_sd.h"

1840

#line·1842·"trace/trace-hw_sd.h"

1841

········}·else·{

1841

········}·else·{

1843

············qemu_log("pl181_fifo_transfer_complete·"·"FIFO·transfer·complete"·"\n");

1843

············qemu_log("pl181_fifo_transfer_complete·"·"FIFO·transfer·complete"·"\n");

1844

#line·1846·"trace/trace-hw_sd.h"

1844

#line·1846·"trace/trace-hw_sd.h"

1845

········}

1845

········}

1846

····}

1846

····}

1847

}

1847

}

1848

static·inline·void·trace_pl181_fifo_transfer_complete(void)

1848

static·inline·void·trace_pl181_fifo_transfer_complete(void)

1860

static·inline·void·_nocheck__trace_pl181_data_engine_idle(void)

1860

static·inline·void·_nocheck__trace_pl181_data_engine_idle(void)

1861

{

1861

{

1862

····if·(trace_event_get_state(TRACE_PL181_DATA_ENGINE_IDLE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1862

····if·(trace_event_get_state(TRACE_PL181_DATA_ENGINE_IDLE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1863

········if·(message_with_timestamp)·{

1863

········if·(message_with_timestamp)·{

1864

············struct·timeval·_now;

1864

············struct·timeval·_now;

1865

············gettimeofday(&_now,·NULL);

1865

············gettimeofday(&_now,·NULL);

1867

············qemu_log("%d@%zu.%06zu:pl181_data_engine_idle·"·"data·engine·idle"·"\n",

1867

············qemu_log("%d@%zu.%06zu:pl181_data_engine_idle·"·"data·engine·idle"·"\n",

1868

·····················qemu_get_thread_id(),

1868

·····················qemu_get_thread_id(),

1869

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1869

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1870

·····················);

1870

·····················);

1871

#line·1873·"trace/trace-hw_sd.h"

1871

#line·1873·"trace/trace-hw_sd.h"

1872

········}·else·{

1872

········}·else·{

1874

············qemu_log("pl181_data_engine_idle·"·"data·engine·idle"·"\n");

1874

············qemu_log("pl181_data_engine_idle·"·"data·engine·idle"·"\n");

1875

#line·1877·"trace/trace-hw_sd.h"

1875

#line·1877·"trace/trace-hw_sd.h"

1876

········}

1876

········}

1877

····}

1877

····}

1878

}

1878

}

1879

static·inline·void·trace_pl181_data_engine_idle(void)

1879

static·inline·void·trace_pl181_data_engine_idle(void)

1891

static·inline·void·_nocheck__trace_aspeed_sdhci_read(uint64_t·addr,·uint32_t·size,·uint64_t·data)

1891

static·inline·void·_nocheck__trace_aspeed_sdhci_read(uint64_t·addr,·uint32_t·size,·uint64_t·data)

1892

{

1892

{

1893

····if·(trace_event_get_state(TRACE_ASPEED_SDHCI_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1893

····if·(trace_event_get_state(TRACE_ASPEED_SDHCI_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1894

········if·(message_with_timestamp)·{

1894

········if·(message_with_timestamp)·{

1895

············struct·timeval·_now;

1895

············struct·timeval·_now;

1896

············gettimeofday(&_now,·NULL);

1896

············gettimeofday(&_now,·NULL);

1898

············qemu_log("%d@%zu.%06zu:aspeed_sdhci_read·"·"@0x%"·PRIx64·"·size·%u:·0x%"·PRIx64·"\n",

1898

············qemu_log("%d@%zu.%06zu:aspeed_sdhci_read·"·"@0x%"·PRIx64·"·size·%u:·0x%"·PRIx64·"\n",

1899

·····················qemu_get_thread_id(),

1899

·····················qemu_get_thread_id(),

1900

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1900

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1901

·····················,·addr,·size,·data);

1901

·····················,·addr,·size,·data);

1902

#line·1904·"trace/trace-hw_sd.h"

1902

#line·1904·"trace/trace-hw_sd.h"

1903

········}·else·{

1903

········}·else·{

1905

············qemu_log("aspeed_sdhci_read·"·"@0x%"·PRIx64·"·size·%u:·0x%"·PRIx64·"\n",·addr,·size,·data);

1905

············qemu_log("aspeed_sdhci_read·"·"@0x%"·PRIx64·"·size·%u:·0x%"·PRIx64·"\n",·addr,·size,·data);

1906

#line·1908·"trace/trace-hw_sd.h"

1906

#line·1908·"trace/trace-hw_sd.h"

1907

········}

1907

········}

1908

····}

1908

····}

1909

}

1909

}

1910

static·inline·void·trace_aspeed_sdhci_read(uint64_t·addr,·uint32_t·size,·uint64_t·data)

1910

static·inline·void·trace_aspeed_sdhci_read(uint64_t·addr,·uint32_t·size,·uint64_t·data)

1922

static·inline·void·_nocheck__trace_aspeed_sdhci_write(uint64_t·addr,·uint32_t·size,·uint64_t·data)

1922

static·inline·void·_nocheck__trace_aspeed_sdhci_write(uint64_t·addr,·uint32_t·size,·uint64_t·data)

1923

{

1923

{

1924

····if·(trace_event_get_state(TRACE_ASPEED_SDHCI_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1924

····if·(trace_event_get_state(TRACE_ASPEED_SDHCI_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1925

········if·(message_with_timestamp)·{

1925

········if·(message_with_timestamp)·{

1926

············struct·timeval·_now;

1926

············struct·timeval·_now;

1927

············gettimeofday(&_now,·NULL);

1927

············gettimeofday(&_now,·NULL);

1929

············qemu_log("%d@%zu.%06zu:aspeed_sdhci_write·"·"@0x%"·PRIx64·"·size·%u:·0x%"·PRIx64·"\n",

1929

············qemu_log("%d@%zu.%06zu:aspeed_sdhci_write·"·"@0x%"·PRIx64·"·size·%u:·0x%"·PRIx64·"\n",

1930

·····················qemu_get_thread_id(),

1930

·····················qemu_get_thread_id(),

1931

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1931

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1932

·····················,·addr,·size,·data);

1932

·····················,·addr,·size,·data);

1933

#line·1935·"trace/trace-hw_sd.h"

1933

#line·1935·"trace/trace-hw_sd.h"

1934

········}·else·{

1934

········}·else·{

1936

············qemu_log("aspeed_sdhci_write·"·"@0x%"·PRIx64·"·size·%u:·0x%"·PRIx64·"\n",·addr,·size,·data);

1936

············qemu_log("aspeed_sdhci_write·"·"@0x%"·PRIx64·"·size·%u:·0x%"·PRIx64·"\n",·addr,·size,·data);

1937

#line·1939·"trace/trace-hw_sd.h"

1937

#line·1939·"trace/trace-hw_sd.h"

1938

········}

1938

········}

1939

····}

1939

····}

1940

}

1940

}

1941

static·inline·void·trace_aspeed_sdhci_write(uint64_t·addr,·uint32_t·size,·uint64_t·data)

1941

static·inline·void·trace_aspeed_sdhci_write(uint64_t·addr,·uint32_t·size,·uint64_t·data)