~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

PVRSRV_ERROR PDumpRegPolKM(IMG_CHAR *pszPDumpRegName, IMG_UINT32 ui32RegAddr, IMG_UINT32 ui32RegValue, IMG_UINT32 ui32Mask, PDUMP_POLL_OPERATOR eOperator)

271

{

272

return PDumpRegPolWithFlagsKM(pszPDumpRegName, ui32RegAddr, ui32RegValue, ui32Mask, PDUMP_FLAGS_CONTINUOUS, eOperator);

273

}

274

275

PVRSRV_ERROR PDumpMallocPages (PVRSRV_DEVICE_IDENTIFIER *psDevID,

276

IMG_UINT32 ui32DevVAddr,

277

IMG_CPU_VIRTADDR pvLinAddr,

278

IMG_HANDLE hOSMemHandle,

279

IMG_UINT32 ui32NumBytes,

280

IMG_UINT32 ui32PageSize,

281

IMG_BOOL bShared,

282

IMG_HANDLE hUniqueTag)

283

{

284

PVRSRV_ERROR eErr;

285

IMG_PUINT8 pui8LinAddr;

286

IMG_UINT32 ui32Offset;

287

IMG_UINT32 ui32NumPages;

288

IMG_DEV_PHYADDR sDevPAddr;

289

IMG_UINT32 ui32Page;

290

IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS;

291

292

PDUMP_GET_SCRIPT_STRING();

293

#if defined(SUPPORT_PDUMP_MULTI_PROCESS)

294

295

ui32Flags |= ( _PDumpIsPersistent() || bShared ) ? PDUMP_FLAGS_PERSISTENT : 0;

296

#else

297

PVR_UNREFERENCED_PARAMETER(bShared);

298

ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;

299

#endif

300

301

302

#if !defined(LINUX)

303

PVR_ASSERT(((IMG_UINTPTR_T)pvLinAddr & HOST_PAGEMASK) == 0);

304

#endif

305

306

PVR_ASSERT(((IMG_UINT32) ui32DevVAddr & HOST_PAGEMASK) == 0);

307

PVR_ASSERT(((IMG_UINT32) ui32NumBytes & HOST_PAGEMASK) == 0);

308

309

310

311

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- MALLOC :%s:VA_%08X 0x%08X %u\r\n",

312

psDevID->pszPDumpDevName, ui32DevVAddr, ui32NumBytes, ui32PageSize);

313

if(eErr != PVRSRV_OK)

314

{

315

return eErr;

316

}

317

PDumpOSWriteString2(hScript, ui32Flags);

318

319

320

321

pui8LinAddr = (IMG_PUINT8) pvLinAddr;

322

ui32Offset = 0;

323

ui32NumPages = ui32NumBytes / ui32PageSize;

324

while (ui32NumPages)

325

{

326

ui32NumPages--;

327

328

329

330

331

332

333

334

335

336

337

338

PDumpOSCPUVAddrToDevPAddr(psDevID->eDeviceType,

339

hOSMemHandle,

340

ui32Offset,

341

pui8LinAddr,

342

ui32PageSize,

343

&sDevPAddr);

344

ui32Page = (IMG_UINT32)(sDevPAddr.uiAddr / ui32PageSize);

345

346

pui8LinAddr += ui32PageSize;

347

ui32Offset += ui32PageSize;

348

349

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "MALLOC :%s:PA_%08X%08X %u %u 0x%08X\r\n",

350

psDevID->pszPDumpDevName,

351

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,

352

ui32Page * ui32PageSize,

353

ui32PageSize,

354

ui32PageSize,

355

ui32Page * ui32PageSize);

356

if(eErr != PVRSRV_OK)

357

{

358

return eErr;

359

}

360

PDumpOSWriteString2(hScript, ui32Flags);

361

}

362

return PVRSRV_OK;

363

}

364

365

366

PVRSRV_ERROR PDumpMallocPageTable (PVRSRV_DEVICE_IDENTIFIER *psDevId,

367

IMG_HANDLE hOSMemHandle,

368

IMG_UINT32 ui32Offset,

369

IMG_CPU_VIRTADDR pvLinAddr,

370

IMG_UINT32 ui32PTSize,

371

IMG_UINT32 ui32Flags,

372

IMG_HANDLE hUniqueTag)

373

{

374

PVRSRV_ERROR eErr;

375

IMG_DEV_PHYADDR sDevPAddr;

376

377

PDUMP_GET_SCRIPT_STRING();

378

379

PVR_ASSERT(((IMG_UINTPTR_T)pvLinAddr & (ui32PTSize - 1)) == 0);

380

ui32Flags |= PDUMP_FLAGS_CONTINUOUS;

381

ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;

382

383

384

385

eErr = PDumpOSBufprintf(hScript,

386

ui32MaxLen,

387

"-- MALLOC :%s:PAGE_TABLE 0x%08X %u\r\n",

388

psDevId->pszPDumpDevName,

389

ui32PTSize,

390

ui32PTSize);

391

if(eErr != PVRSRV_OK)

392

{

393

return eErr;

394

}

395

PDumpOSWriteString2(hScript, ui32Flags);

396

397

398

399

400

401

402

403

404

PDumpOSCPUVAddrToDevPAddr(psDevId->eDeviceType,

405

hOSMemHandle,

406

ui32Offset,

407

(IMG_PUINT8) pvLinAddr,

408

ui32PTSize,

409

&sDevPAddr);

410

411

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "MALLOC :%s:PA_%08X%08X 0x%X %u 0x%08X\r\n",

412

psDevId->pszPDumpDevName,

413

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,

414

sDevPAddr.uiAddr,

415

ui32PTSize,

416

ui32PTSize,

417

sDevPAddr.uiAddr);

418

if(eErr != PVRSRV_OK)

419

{

420

return eErr;

421

}

422

PDumpOSWriteString2(hScript, ui32Flags);

423

424

return PVRSRV_OK;

425

}

426

427

PVRSRV_ERROR PDumpFreePages (BM_HEAP *psBMHeap,

428

IMG_DEV_VIRTADDR sDevVAddr,

429

IMG_UINT32 ui32NumBytes,

430

IMG_UINT32 ui32PageSize,

431

IMG_HANDLE hUniqueTag,

432

IMG_BOOL bInterleaved)

433

{

434

PVRSRV_ERROR eErr;

435

IMG_UINT32 ui32NumPages, ui32PageCounter;

436

IMG_DEV_PHYADDR sDevPAddr;

437

IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS;

438

PVRSRV_DEVICE_NODE *psDeviceNode;

439

440

PDUMP_GET_SCRIPT_STRING();

441

442

PVR_ASSERT(((IMG_UINT32) sDevVAddr.uiAddr & (ui32PageSize - 1)) == 0);

443

PVR_ASSERT(((IMG_UINT32) ui32NumBytes & (ui32PageSize - 1)) == 0);

444

445

psDeviceNode = psBMHeap->pBMContext->psDeviceNode;

446

ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;

447

448

449

450

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- FREE :%s:VA_%08X\r\n",

451

psDeviceNode->sDevId.pszPDumpDevName, sDevVAddr.uiAddr);

452

if(eErr != PVRSRV_OK)

453

{

454

return eErr;

455

}

456

457

#if defined(SUPPORT_PDUMP_MULTI_PROCESS)

458

459

{

460

PVRSRV_DEVICE_NODE *psDeviceNode = psBMHeap->pBMContext->psDeviceNode;

461

462

if( psDeviceNode->pfnMMUIsHeapShared(psBMHeap->pMMUHeap) )

463

{

464

ui32Flags |= PDUMP_FLAGS_PERSISTENT;

465

}

466

}

467

#endif

468

PDumpOSWriteString2(hScript, ui32Flags);

469

470

471

472

ui32NumPages = ui32NumBytes / ui32PageSize;

473

for (ui32PageCounter = 0; ui32PageCounter < ui32NumPages; ui32PageCounter++)

474

{

475

if (!bInterleaved || (ui32PageCounter % 2) == 0)

476

{

477

sDevPAddr = psDeviceNode->pfnMMUGetPhysPageAddr(psBMHeap->pMMUHeap, sDevVAddr);

478

479

PVR_ASSERT(sDevPAddr.uiAddr != 0)

480

481

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "FREE :%s:PA_%08X%08X\r\n",

482

psDeviceNode->sDevId.pszPDumpDevName, (IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag, sDevPAddr.uiAddr);

483

if(eErr != PVRSRV_OK)

484

{

485

return eErr;

486

}

487

PDumpOSWriteString2(hScript, ui32Flags);

488

}

489

else

490

{

491

492

}

493

494

sDevVAddr.uiAddr += ui32PageSize;

495

}

496

return PVRSRV_OK;

497

}

498

499

PVRSRV_ERROR PDumpFreePageTable (PVRSRV_DEVICE_IDENTIFIER *psDevID,

500

IMG_HANDLE hOSMemHandle,

501

IMG_CPU_VIRTADDR pvLinAddr,

502

IMG_UINT32 ui32PTSize,

503

IMG_UINT32 ui32Flags,

504

IMG_HANDLE hUniqueTag)

505

{

506

PVRSRV_ERROR eErr;

507

IMG_DEV_PHYADDR sDevPAddr;

508

509

PDUMP_GET_SCRIPT_STRING();

510

511

PVR_UNREFERENCED_PARAMETER(ui32PTSize);

512

ui32Flags |= PDUMP_FLAGS_CONTINUOUS;

513

ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;

514

515

516

PVR_ASSERT(((IMG_UINTPTR_T)pvLinAddr & (ui32PTSize-1UL)) == 0);

517

518

519

520

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "-- FREE :%s:PAGE_TABLE\r\n", psDevID->pszPDumpDevName);

521

if(eErr != PVRSRV_OK)

522

{

523

return eErr;

524

}

525

PDumpOSWriteString2(hScript, ui32Flags);

526

527

528

529

530

531

532

533

534

PDumpOSCPUVAddrToDevPAddr(psDevID->eDeviceType,

535

hOSMemHandle,

536

537

(IMG_PUINT8) pvLinAddr,

538

ui32PTSize,

539

&sDevPAddr);

540

541

{

542

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "FREE :%s:PA_%08X%08X\r\n",

543

psDevID->pszPDumpDevName,

544

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,

545

sDevPAddr.uiAddr);

546

if(eErr != PVRSRV_OK)

547

{

548

return eErr;

549

}

550

PDumpOSWriteString2(hScript, ui32Flags);

551

}

552

553

return PVRSRV_OK;

554

}

555

556

PVRSRV_ERROR PDumpPDRegWithFlags(PDUMP_MMU_ATTRIB *psMMUAttrib,

557

IMG_UINT32 ui32Reg,

558

IMG_UINT32 ui32Data,

559

IMG_UINT32 ui32Flags,

560

IMG_HANDLE hUniqueTag)

561

{

562

PVRSRV_ERROR eErr;

563

IMG_CHAR *pszRegString;

564

PDUMP_GET_SCRIPT_STRING()

565

566

if(psMMUAttrib->pszPDRegRegion != IMG_NULL)

567

{

568

pszRegString = psMMUAttrib->pszPDRegRegion;

569

}

570

else

571

{

572

pszRegString = psMMUAttrib->sDevId.pszPDumpRegName;

573

}

574

575

576

577

#if defined(SGX_FEATURE_36BIT_MMU)

578

eErr = PDumpOSBufprintf(hScript, ui32MaxLen,

579

"WRW :%s:$1 :%s:PA_%08X%08X:0x0\r\n",

580

psMMUAttrib->sDevId.pszPDumpDevName,

581

psMMUAttrib->sDevId.pszPDumpDevName,

582

(IMG_UINT32)hUniqueTag,

583

(ui32Data & psMMUAttrib->ui32PDEMask) << psMMUAttrib->ui32PDEAlignShift);

584

if(eErr != PVRSRV_OK)

585

{

586

return eErr;

587

}

588

PDumpOSWriteString2(hScript, ui32Flags);

589

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "SHR :%s:$1 :%s:$1 0x4\r\n",

590

psMMUAttrib->sDevId.pszPDumpDevName,

591

psMMUAttrib->sDevId.pszPDumpDevName);

592

if(eErr != PVRSRV_OK)

593

{

594

return eErr;

595

}

596

PDumpOSWriteString2(hScript, ui32Flags);

597

eErr = PDumpOSBufprintf(hScript, ui32MaxLen,

598

"WRW :%s:0x%08X: %s:$1\r\n",

599

pszRegString,

600

ui32Reg,

601

psMMUAttrib->sDevId.pszPDumpDevName);

602

if(eErr != PVRSRV_OK)

603

{

604

return eErr;

605

}

606

PDumpOSWriteString2(hScript, ui32Flags);

607

#else

608

eErr = PDumpOSBufprintf(hScript,

609

ui32MaxLen,

610

"WRW :%s:0x%08X :%s:PA_%08X%08X:0x%08X\r\n",

611

pszRegString,

612

ui32Reg,

613

psMMUAttrib->sDevId.pszPDumpDevName,

614

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,

615

(ui32Data & psMMUAttrib->ui32PDEMask) << psMMUAttrib->ui32PDEAlignShift,

616

ui32Data & ~psMMUAttrib->ui32PDEMask);

617

if(eErr != PVRSRV_OK)

618

{

619

return eErr;

620

}

621

PDumpOSWriteString2(hScript, ui32Flags);

622

#endif

623

return PVRSRV_OK;

624

}

625

626

PVRSRV_ERROR PDumpPDReg (PDUMP_MMU_ATTRIB *psMMUAttrib,

627

IMG_UINT32 ui32Reg,

628

IMG_UINT32 ui32Data,

629

IMG_HANDLE hUniqueTag)

630

{

631

return PDumpPDRegWithFlags(psMMUAttrib, ui32Reg, ui32Data, PDUMP_FLAGS_CONTINUOUS, hUniqueTag);

632

}

633

634

PVRSRV_ERROR PDumpMemPolKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,

635

IMG_UINT32 ui32Offset,

636

IMG_UINT32 ui32Value,

637

IMG_UINT32 ui32Mask,

638

PDUMP_POLL_OPERATOR eOperator,

639

IMG_UINT32 ui32Flags,

640

IMG_HANDLE hUniqueTag)

641

{

642

#define MEMPOLL_DELAY (1000)

643

#define MEMPOLL_COUNT (2000000000 / MEMPOLL_DELAY)

644

645

PVRSRV_ERROR eErr;

646

IMG_UINT32 ui32PageOffset;

647

IMG_UINT8 *pui8LinAddr;

648

IMG_DEV_PHYADDR sDevPAddr;

649

IMG_DEV_VIRTADDR sDevVPageAddr;

650

PDUMP_MMU_ATTRIB *psMMUAttrib;

651

652

PDUMP_GET_SCRIPT_STRING();

653

654

if (PDumpOSIsSuspended())

655

{

656

return PVRSRV_OK;

657

}

658

659

if ( _PDumpIsPersistent() )

660

{

661

662

return PVRSRV_OK;

663

}

664

665

666

PVR_ASSERT((ui32Offset + sizeof(IMG_UINT32)) <= psMemInfo->uAllocSize);

667

668

psMMUAttrib = ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->psMMUAttrib;

669

670

671

672

eErr = PDumpOSBufprintf(hScript,

673

ui32MaxLen,

674

"-- POL :%s:VA_%08X 0x%08X 0x%08X %d %d %d\r\n",

675

psMMUAttrib->sDevId.pszPDumpDevName,

676

psMemInfo->sDevVAddr.uiAddr + ui32Offset,

677

ui32Value,

678

ui32Mask,

679

eOperator,

680

MEMPOLL_COUNT,

681

MEMPOLL_DELAY);

682

if(eErr != PVRSRV_OK)

683

{

684

return eErr;

685

}

686

PDumpOSWriteString2(hScript, ui32Flags);

687

688

689

pui8LinAddr = psMemInfo->pvLinAddrKM;

690

691

692

pui8LinAddr += ui32Offset;

693

694

695

696

697

PDumpOSCPUVAddrToPhysPages(psMemInfo->sMemBlk.hOSMemHandle,

698

ui32Offset,

699

pui8LinAddr,

700

psMMUAttrib->ui32DataPageMask,

701

&ui32PageOffset);

702

703

704

sDevVPageAddr.uiAddr = psMemInfo->sDevVAddr.uiAddr + ui32Offset - ui32PageOffset;

705

706

PVR_ASSERT((sDevVPageAddr.uiAddr & psMMUAttrib->ui32DataPageMask) == 0);

707

708

709

BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);

710

711

712

sDevPAddr.uiAddr += ui32PageOffset;

713

714

eErr = PDumpOSBufprintf(hScript,

715

ui32MaxLen,

716

"POL :%s:PA_%08X%08X:0x%08X 0x%08X 0x%08X %d %d %d\r\n",

717

psMMUAttrib->sDevId.pszPDumpDevName,

718

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,

719

sDevPAddr.uiAddr & ~(psMMUAttrib->ui32DataPageMask),

720

sDevPAddr.uiAddr & (psMMUAttrib->ui32DataPageMask),

721

ui32Value,

722

ui32Mask,

723

eOperator,

724

MEMPOLL_COUNT,

725

MEMPOLL_DELAY);

726

if(eErr != PVRSRV_OK)

727

{

728

return eErr;

729

}

730

PDumpOSWriteString2(hScript, ui32Flags);

731

732

return PVRSRV_OK;

733

}

734

735

PVRSRV_ERROR PDumpMemKM(IMG_PVOID pvAltLinAddr,

736

PVRSRV_KERNEL_MEM_INFO *psMemInfo,

737

IMG_UINT32 ui32Offset,

738

IMG_UINT32 ui32Bytes,

739

IMG_UINT32 ui32Flags,

740

IMG_HANDLE hUniqueTag)

741

{

742

PVRSRV_ERROR eErr;

743

IMG_UINT32 ui32NumPages;

744

IMG_UINT32 ui32PageByteOffset;

745

IMG_UINT32 ui32BlockBytes;

746

IMG_UINT8* pui8LinAddr;

747

IMG_UINT8* pui8DataLinAddr = IMG_NULL;

748

IMG_DEV_VIRTADDR sDevVPageAddr;

749

IMG_DEV_VIRTADDR sDevVAddr;

750

IMG_DEV_PHYADDR sDevPAddr;

751

IMG_UINT32 ui32ParamOutPos;

752

PDUMP_MMU_ATTRIB *psMMUAttrib;

753

IMG_UINT32 ui32DataPageSize;

754

755

PDUMP_GET_SCRIPT_AND_FILE_STRING();

756

757

758

if (ui32Bytes == 0 || PDumpOSIsSuspended())

759

{

760

return PVRSRV_OK;

761

}

762

763

psMMUAttrib = ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->psMMUAttrib;

764

765

766

767

PVR_ASSERT((ui32Offset + ui32Bytes) <= psMemInfo->uAllocSize);

768

769

if (!PDumpOSJTInitialised())

770

{

771

return PVRSRV_ERROR_PDUMP_NOT_AVAILABLE;

772

}

773

774

#if defined(SUPPORT_PDUMP_MULTI_PROCESS)

775

776

{

777

BM_HEAP *pHeap = ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap;

778

PVRSRV_DEVICE_NODE *psDeviceNode = pHeap->pBMContext->psDeviceNode;

779

780

if( psDeviceNode->pfnMMUIsHeapShared(pHeap->pMMUHeap) )

781

{

782

ui32Flags |= PDUMP_FLAGS_PERSISTENT;

783

}

784

}

785

#endif

786

787

788

if(pvAltLinAddr)

789

{

790

pui8DataLinAddr = pvAltLinAddr;

791

}

792

else if(psMemInfo->pvLinAddrKM)

793

{

794

pui8DataLinAddr = (IMG_UINT8 *)psMemInfo->pvLinAddrKM + ui32Offset;

795

}

796

pui8LinAddr = (IMG_UINT8 *)psMemInfo->pvLinAddrKM;

797

sDevVAddr = psMemInfo->sDevVAddr;

798

799

800

sDevVAddr.uiAddr += ui32Offset;

801

pui8LinAddr += ui32Offset;

802

803

PVR_ASSERT(pui8DataLinAddr);

804

805

PDumpOSCheckForSplitting(PDumpOSGetStream(PDUMP_STREAM_PARAM2), ui32Bytes, ui32Flags);

806

807

ui32ParamOutPos = PDumpOSGetStreamOffset(PDUMP_STREAM_PARAM2);

808

809

810

811

if(!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),

812

pui8DataLinAddr,

813

ui32Bytes,

814

ui32Flags))

815

{

816

return PVRSRV_ERROR_PDUMP_BUFFER_FULL;

817

}

818

819

if (PDumpOSGetParamFileNum() == 0)

820

{

821

eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%.prm");

822

}

823

else

824

{

825

eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%_%u.prm", PDumpOSGetParamFileNum());

826

}

827

if(eErr != PVRSRV_OK)

828

{

829

return eErr;

830

}

831

832

833

834

eErr = PDumpOSBufprintf(hScript,

835

ui32MaxLenScript,

836

"-- LDB :%s:VA_%08X%08X:0x%08X 0x%08X 0x%08X %s\r\n",

837

psMMUAttrib->sDevId.pszPDumpDevName,

838

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,

839

psMemInfo->sDevVAddr.uiAddr,

840

ui32Offset,

841

ui32Bytes,

842

ui32ParamOutPos,

843

pszFileName);

844

if(eErr != PVRSRV_OK)

845

{

846

return eErr;

847

}

848

PDumpOSWriteString2(hScript, ui32Flags);

849

850

851

852

853

PDumpOSCPUVAddrToPhysPages(psMemInfo->sMemBlk.hOSMemHandle,

854

ui32Offset,

855

pui8LinAddr,

856

psMMUAttrib->ui32DataPageMask,

857

&ui32PageByteOffset);

858

ui32DataPageSize = psMMUAttrib->ui32DataPageMask + 1;

859

ui32NumPages = (ui32PageByteOffset + ui32Bytes + psMMUAttrib->ui32DataPageMask) / ui32DataPageSize;

860

861

while(ui32NumPages)

862

{

863

ui32NumPages--;

864

865

866

sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageByteOffset;

867

868

if (ui32DataPageSize <= PDUMP_TEMP_BUFFER_SIZE)

869

{

870

871

PVR_ASSERT((sDevVPageAddr.uiAddr & psMMUAttrib->ui32DataPageMask) == 0);

872

}

873

874

875

BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);

876

877

878

sDevPAddr.uiAddr += ui32PageByteOffset;

879

880

881

if (ui32PageByteOffset + ui32Bytes > ui32DataPageSize)

882

{

883

884

ui32BlockBytes = ui32DataPageSize - ui32PageByteOffset;

885

}

886

else

887

{

888

889

ui32BlockBytes = ui32Bytes;

890

}

891

892

eErr = PDumpOSBufprintf(hScript,

893

ui32MaxLenScript,

894

"LDB :%s:PA_%08X%08X:0x%08X 0x%08X 0x%08X %s\r\n",

895

psMMUAttrib->sDevId.pszPDumpDevName,

896

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,

897

sDevPAddr.uiAddr & ~(psMMUAttrib->ui32DataPageMask),

898

sDevPAddr.uiAddr & (psMMUAttrib->ui32DataPageMask),

899

ui32BlockBytes,

900

ui32ParamOutPos,

901

pszFileName);

902

if(eErr != PVRSRV_OK)

903

{

904

return eErr;

905

}

906

PDumpOSWriteString2(hScript, ui32Flags);

907

908

909

910

#if defined(SGX_FEATURE_VARIABLE_MMU_PAGE_SIZE)

911

912

ui32PageByteOffset = (ui32PageByteOffset + ui32BlockBytes) % ui32DataPageSize;

913

#else

914

915

ui32PageByteOffset = 0;

916

#endif

917

918

ui32Bytes -= ui32BlockBytes;

919

920

sDevVAddr.uiAddr += ui32BlockBytes;

921

922

pui8LinAddr += ui32BlockBytes;

923

924

ui32ParamOutPos += ui32BlockBytes;

925

}

926

927

return PVRSRV_OK;

928

}

929

930

PVRSRV_ERROR PDumpMemPDEntriesKM(PDUMP_MMU_ATTRIB *psMMUAttrib,

931

IMG_HANDLE hOSMemHandle,

932

IMG_CPU_VIRTADDR pvLinAddr,

933

IMG_UINT32 ui32Bytes,

934

IMG_UINT32 ui32Flags,

935

IMG_BOOL bInitialisePages,

936

IMG_HANDLE hUniqueTag1,

937

IMG_HANDLE hUniqueTag2)

938

{

939

PDUMP_MMU_ATTRIB sMMUAttrib;

940

941

942

sMMUAttrib = *psMMUAttrib;

943

sMMUAttrib.ui32PTSize = (IMG_UINT32)HOST_PAGESIZE();

944

return PDumpMemPTEntriesKM( &sMMUAttrib,

945

hOSMemHandle,

946

pvLinAddr,

947

ui32Bytes,

948

ui32Flags,

949

bInitialisePages,

950

hUniqueTag1,

951

hUniqueTag2);

952

}

953

954

PVRSRV_ERROR PDumpMemPTEntriesKM(PDUMP_MMU_ATTRIB *psMMUAttrib,

955

IMG_HANDLE hOSMemHandle,

956

IMG_CPU_VIRTADDR pvLinAddr,

957

IMG_UINT32 ui32Bytes,

958

IMG_UINT32 ui32Flags,

959

IMG_BOOL bInitialisePages,

960

IMG_HANDLE hUniqueTag1,

961

IMG_HANDLE hUniqueTag2)

962

{

963

PVRSRV_ERROR eErr;

964

IMG_UINT32 ui32NumPages;

965

IMG_UINT32 ui32PageOffset;

966

IMG_UINT32 ui32BlockBytes;

967

IMG_UINT8* pui8LinAddr;

968

IMG_DEV_PHYADDR sDevPAddr;

969

IMG_CPU_PHYADDR sCpuPAddr;

970

IMG_UINT32 ui32Offset;

971

IMG_UINT32 ui32ParamOutPos;

972

IMG_UINT32 ui32PageMask;

973

974

PDUMP_GET_SCRIPT_AND_FILE_STRING();

975

ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;

976

977

if (PDumpOSIsSuspended())

978

{

979

return PVRSRV_OK;

980

}

981

982

if (!PDumpOSJTInitialised())

983

{

984

return PVRSRV_ERROR_PDUMP_NOT_AVAILABLE;

985

}

986

987

if (!pvLinAddr)

988

{

989

return PVRSRV_ERROR_INVALID_PARAMS;

990

}

991

992

PDumpOSCheckForSplitting(PDumpOSGetStream(PDUMP_STREAM_PARAM2), ui32Bytes, ui32Flags);

993

994

ui32ParamOutPos = PDumpOSGetStreamOffset(PDUMP_STREAM_PARAM2);

995

996

if (bInitialisePages)

997

{

998

999

1000

1001

if (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),

1002

pvLinAddr,

1003

ui32Bytes,

1004

ui32Flags | PDUMP_FLAGS_CONTINUOUS))

1005

{

1006

return PVRSRV_ERROR_PDUMP_BUFFER_FULL;

1007

}

1008

1009

if (PDumpOSGetParamFileNum() == 0)

1010

{

1011

eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%.prm");

1012

}

1013

else

1014

{

1015

eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%_%u.prm", PDumpOSGetParamFileNum());

1016

}

1017

if(eErr != PVRSRV_OK)

1018

{

1019

return eErr;

1020

}

1021

}

1022

1023

1024

1025

1026

1027

1028

ui32PageMask = psMMUAttrib->ui32PTSize - 1;

1029

1030

1031

1032

1033

ui32PageOffset = (IMG_UINT32)((IMG_UINTPTR_T)pvLinAddr & (psMMUAttrib->ui32PTSize - 1));

1034

ui32NumPages = (ui32PageOffset + ui32Bytes + psMMUAttrib->ui32PTSize - 1) / psMMUAttrib->ui32PTSize;

1035

pui8LinAddr = (IMG_UINT8*) pvLinAddr;

1036

1037

while (ui32NumPages)

1038

{

1039

ui32NumPages--;

1040

1041

1042

1043

1044

1045

1046

sCpuPAddr = OSMapLinToCPUPhys(hOSMemHandle, pui8LinAddr);

1047

sDevPAddr = SysCpuPAddrToDevPAddr(psMMUAttrib->sDevId.eDeviceType, sCpuPAddr);

1048

1049

1050

if (ui32PageOffset + ui32Bytes > psMMUAttrib->ui32PTSize)

1051

{

1052

1053

ui32BlockBytes = psMMUAttrib->ui32PTSize - ui32PageOffset;

1054

}

1055

else

1056

{

1057

1058

ui32BlockBytes = ui32Bytes;

1059

}

1060

1061

1062

1063

1064

if (bInitialisePages)

1065

{

1066

eErr = PDumpOSBufprintf(hScript,

1067

ui32MaxLenScript,

1068

"LDB :%s:PA_%08X%08X:0x%08X 0x%08X 0x%08X %s\r\n",

1069

psMMUAttrib->sDevId.pszPDumpDevName,

1070

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,

1071

sDevPAddr.uiAddr & ~ui32PageMask,

1072

sDevPAddr.uiAddr & ui32PageMask,

1073

ui32BlockBytes,

1074

ui32ParamOutPos,

1075

pszFileName);

1076

if(eErr != PVRSRV_OK)

1077

{

1078

return eErr;

1079

}

1080

PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);

1081

}

1082

else

1083

{

1084

for (ui32Offset = 0; ui32Offset < ui32BlockBytes; ui32Offset += sizeof(IMG_UINT32))

1085

{

1086

IMG_UINT32 ui32PTE = *((IMG_UINT32 *)(IMG_UINTPTR_T)(pui8LinAddr + ui32Offset));

1087

1088

if ((ui32PTE & psMMUAttrib->ui32PDEMask) != 0)

1089

{

1090

1091

#if defined(SGX_FEATURE_36BIT_MMU)

1092

eErr = PDumpOSBufprintf(hScript,

1093

ui32MaxLenScript,

1094

"WRW :%s:$1 :%s:PA_%08X%08X:0x0\r\n",

1095

psMMUAttrib->sDevId.pszPDumpDevName,

1096

psMMUAttrib->sDevId.pszPDumpDevName,

1097

(IMG_UINT32)hUniqueTag2,

1098

(ui32PTE & psMMUAttrib->ui32PDEMask) << psMMUAttrib->ui32PTEAlignShift);

1099

if(eErr != PVRSRV_OK)

1100

{

1101

return eErr;

1102

}

1103

PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);

1104

eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, "SHR :%s:$1 :%s:$1 0x4\r\n",

1105

psMMUAttrib->sDevId.pszPDumpDevName,

1106

psMMUAttrib->sDevId.pszPDumpDevName);

1107

if(eErr != PVRSRV_OK)

1108

{

1109

return eErr;

1110

}

1111

PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);

1112

eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, "OR :%s:$1 :%s:$1 0x%08X\r\n",

1113

psMMUAttrib->sDevId.pszPDumpDevName,

1114

psMMUAttrib->sDevId.pszPDumpDevName,

1115

ui32PTE & ~psMMUAttrib->ui32PDEMask);

1116

if(eErr != PVRSRV_OK)

1117

{

1118

return eErr;

1119

}

1120

PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);

1121

eErr = PDumpOSBufprintf(hScript,

1122

ui32MaxLenScript,

1123

"WRW :%s:PA_%08X%08X:0x%08X :%s:$1\r\n",

1124

psMMUAttrib->sDevId.pszPDumpDevName,

1125

(IMG_UINT32)hUniqueTag1,

1126

(sDevPAddr.uiAddr + ui32Offset) & ~ui32PageMask,

1127

(sDevPAddr.uiAddr + ui32Offset) & ui32PageMask,

1128

psMMUAttrib->sDevId.pszPDumpDevName);

1129

if(eErr != PVRSRV_OK)

1130

{

1131

return eErr;

1132

}

1133

PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);

1134

#else

1135

eErr = PDumpOSBufprintf(hScript,

1136

ui32MaxLenScript,

1137

"WRW :%s:PA_%08X%08X:0x%08X :%s:PA_%08X%08X:0x%08X\r\n",

1138

psMMUAttrib->sDevId.pszPDumpDevName,

1139

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,

1140

(sDevPAddr.uiAddr + ui32Offset) & ~ui32PageMask,

1141

(sDevPAddr.uiAddr + ui32Offset) & ui32PageMask,

1142

psMMUAttrib->sDevId.pszPDumpDevName,

1143

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag2,

1144

(ui32PTE & psMMUAttrib->ui32PDEMask) << psMMUAttrib->ui32PTEAlignShift,

1145

ui32PTE & ~psMMUAttrib->ui32PDEMask);

1146

if(eErr != PVRSRV_OK)

1147

{

1148

return eErr;

1149

}

1150

PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);

1151

#endif

1152

}

1153

else

1154

{

1155

#if !defined(FIX_HW_BRN_31620)

1156

PVR_ASSERT((ui32PTE & psMMUAttrib->ui32PTEValid) == 0UL);

1157

#endif

1158

eErr = PDumpOSBufprintf(hScript,

1159

ui32MaxLenScript,

1160

"WRW :%s:PA_%08X%08X:0x%08X 0x%08X%08X\r\n",

1161

psMMUAttrib->sDevId.pszPDumpDevName,

1162

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,

1163

(sDevPAddr.uiAddr + ui32Offset) & ~ui32PageMask,

1164

(sDevPAddr.uiAddr + ui32Offset) & ui32PageMask,

1165

(ui32PTE << psMMUAttrib->ui32PTEAlignShift),

1166

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag2);

1167

if(eErr != PVRSRV_OK)

1168

{

1169

return eErr;

1170

}

1171

PDumpOSWriteString2(hScript, ui32Flags | PDUMP_FLAGS_CONTINUOUS);

1172

}

1173

}

1174

}

1175

1176

1177

1178

1179

ui32PageOffset = 0;

1180

1181

ui32Bytes -= ui32BlockBytes;

1182

1183

pui8LinAddr += ui32BlockBytes;

1184

1185

ui32ParamOutPos += ui32BlockBytes;

1186

}

1187

1188

return PVRSRV_OK;

1189

}

1190

1191

PVRSRV_ERROR PDumpPDDevPAddrKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,

1192

IMG_UINT32 ui32Offset,

1193

IMG_DEV_PHYADDR sPDDevPAddr,

1194

IMG_HANDLE hUniqueTag1,

1195

IMG_HANDLE hUniqueTag2)

1196

{

1197

PVRSRV_ERROR eErr;

1198

IMG_UINT32 ui32PageByteOffset;

1199

IMG_DEV_VIRTADDR sDevVAddr;

1200

IMG_DEV_VIRTADDR sDevVPageAddr;

1201

IMG_DEV_PHYADDR sDevPAddr;

1202

IMG_UINT32 ui32Flags = PDUMP_FLAGS_CONTINUOUS;

1203

IMG_UINT32 ui32ParamOutPos;

1204

PDUMP_MMU_ATTRIB *psMMUAttrib;

1205

IMG_UINT32 ui32PageMask;

1206

1207

PDUMP_GET_SCRIPT_AND_FILE_STRING();

1208

1209

if (!PDumpOSJTInitialised())

1210

{

1211

return PVRSRV_ERROR_PDUMP_NOT_AVAILABLE;

1212

}

1213

1214

psMMUAttrib = ((BM_BUF*)psMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->psMMUAttrib;

1215

ui32PageMask = psMMUAttrib->ui32PTSize - 1;

1216

1217

ui32ParamOutPos = PDumpOSGetStreamOffset(PDUMP_STREAM_PARAM2);

1218

1219

1220

if(!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_PARAM2),

1221

(IMG_UINT8 *)&sPDDevPAddr,

1222

sizeof(IMG_DEV_PHYADDR),

1223

ui32Flags))

1224

{

1225

return PVRSRV_ERROR_PDUMP_BUFFER_FULL;

1226

}

1227

1228

if (PDumpOSGetParamFileNum() == 0)

1229

{

1230

eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%.prm");

1231

}

1232

else

1233

{

1234

eErr = PDumpOSSprintf(pszFileName, ui32MaxLenFileName, "%%0%%_%u.prm", PDumpOSGetParamFileNum());

1235

}

1236

if(eErr != PVRSRV_OK)

1237

{

1238

return eErr;

1239

}

1240

1241

1242

eErr = PDumpOSBufprintf(hScript,

1243

ui32MaxLenScript,

1244

"-- LDB :%s:PA_0x%08X%08X:0x%08X 0x%08X 0x%08X %s\r\n",

1245

psMMUAttrib->sDevId.pszPDumpDevName,

1246

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,

1247

sPDDevPAddr.uiAddr & ~ui32PageMask,

1248

sPDDevPAddr.uiAddr & ui32PageMask,

1249

sizeof(IMG_DEV_PHYADDR),

1250

ui32ParamOutPos,

1251

pszFileName);

1252

if(eErr != PVRSRV_OK)

1253

{

1254

return eErr;

1255

}

1256

PDumpOSWriteString2(hScript, ui32Flags);

1257

1258

1259

sDevVAddr = psMemInfo->sDevVAddr;

1260

ui32PageByteOffset = sDevVAddr.uiAddr & ui32PageMask;

1261

1262

sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageByteOffset;

1263

PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);

1264

1265

BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);

1266

sDevPAddr.uiAddr += ui32PageByteOffset + ui32Offset;

1267

1268

if ((sPDDevPAddr.uiAddr & psMMUAttrib->ui32PDEMask) != 0UL)

1269

{

1270

#if defined(SGX_FEATURE_36BIT_MMU)

1271

eErr = PDumpOSBufprintf(hScript,

1272

ui32MaxLenScript,

1273

"WRW :%s:$1 :%s:PA_%08X%08X:0x0\r\n",

1274

psMMUAttrib->sDevId.pszPDumpDevName,

1275

psMMUAttrib->sDevId.pszPDumpDevName,

1276

(IMG_UINT32)hUniqueTag2,

1277

sPDDevPAddr.uiAddr);

1278

if(eErr != PVRSRV_OK)

1279

{

1280

return eErr;

1281

}

1282

PDumpOSWriteString2(hScript, ui32Flags);

1283

1284

eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, "AND :%s:$2 :%s:$1 0xFFFFFFFF\r\n",

1285

psMMUAttrib->sDevId.pszPDumpDevName,

1286

psMMUAttrib->sDevId.pszPDumpDevName);

1287

if(eErr != PVRSRV_OK)

1288

{

1289

return eErr;

1290

}

1291

PDumpOSWriteString2(hScript, ui32Flags);

1292

1293

eErr = PDumpOSBufprintf(hScript,

1294

ui32MaxLenScript,

1295

"WRW :%s:PA_%08X%08X:0x%08X :%s:$2\r\n",

1296

psMMUAttrib->sDevId.pszPDumpDevName,

1297

(IMG_UINT32)hUniqueTag1,

1298

(sDevPAddr.uiAddr) & ~(psMMUAttrib->ui32DataPageMask),

1299

(sDevPAddr.uiAddr) & (psMMUAttrib->ui32DataPageMask),

1300

psMMUAttrib->sDevId.pszPDumpDevName);

1301

if(eErr != PVRSRV_OK)

1302

{

1303

return eErr;

1304

}

1305

PDumpOSWriteString2(hScript, ui32Flags);

1306

1307

eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript, "SHR :%s:$2 :%s:$1 0x20\r\n",

1308

psMMUAttrib->sDevId.pszPDumpDevName,

1309

psMMUAttrib->sDevId.pszPDumpDevName);

1310

if(eErr != PVRSRV_OK)

1311

{

1312

return eErr;

1313

}

1314

PDumpOSWriteString2(hScript, ui32Flags);

1315

1316

eErr = PDumpOSBufprintf(hScript,

1317

ui32MaxLenScript,

1318

"WRW :%s:PA_%08X%08X:0x%08X :%s:$2\r\n",

1319

psMMUAttrib->sDevId.pszPDumpDevName,

1320

(IMG_UINT32)hUniqueTag1,

1321

(sDevPAddr.uiAddr + 4) & ~(psMMUAttrib->ui32DataPageMask),

1322

(sDevPAddr.uiAddr + 4) & (psMMUAttrib->ui32DataPageMask),

1323

psMMUAttrib->sDevId.pszPDumpDevName);

1324

if(eErr != PVRSRV_OK)

1325

{

1326

return eErr;

1327

}

1328

PDumpOSWriteString2(hScript, ui32Flags);

1329

#else

1330

eErr = PDumpOSBufprintf(hScript,

1331

ui32MaxLenScript,

1332

"WRW :%s:PA_%08X%08X:0x%08X :%s:PA_%08X%08X:0x%08X\r\n",

1333

psMMUAttrib->sDevId.pszPDumpDevName,

1334

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,

1335

sDevPAddr.uiAddr & ~ui32PageMask,

1336

sDevPAddr.uiAddr & ui32PageMask,

1337

psMMUAttrib->sDevId.pszPDumpDevName,

1338

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag2,

1339

sPDDevPAddr.uiAddr & psMMUAttrib->ui32PDEMask,

1340

sPDDevPAddr.uiAddr & ~psMMUAttrib->ui32PDEMask);

1341

if(eErr != PVRSRV_OK)

1342

{

1343

return eErr;

1344

}

1345

#endif

1346

}

1347

else

1348

{

1349

PVR_ASSERT(!(sDevPAddr.uiAddr & psMMUAttrib->ui32PTEValid));

1350

eErr = PDumpOSBufprintf(hScript,

1351

ui32MaxLenScript,

1352

"WRW :%s:PA_%08X%08X:0x%08X 0x%08X\r\n",

1353

psMMUAttrib->sDevId.pszPDumpDevName,

1354

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,

1355

sDevPAddr.uiAddr & ~ui32PageMask,

1356

sDevPAddr.uiAddr & ui32PageMask,

1357

sPDDevPAddr.uiAddr);

1358

if(eErr != PVRSRV_OK)

1359

{

1360

return eErr;

1361

}

1362

}

1363

PDumpOSWriteString2(hScript, ui32Flags);

1364

1365

return PVRSRV_OK;

1366

}

1367

1368

PVRSRV_ERROR PDumpCommentKM(IMG_CHAR *pszComment, IMG_UINT32 ui32Flags)

1369

{

1370

PVRSRV_ERROR eErr;

1371

IMG_CHAR pszCommentPrefix[] = "-- ";

1372

#if defined(PDUMP_DEBUG_OUTFILES)

1373

IMG_CHAR pszTemp[256];

1374

#endif

1375

IMG_UINT32 ui32LenCommentPrefix;

1376

PDUMP_GET_SCRIPT_STRING();

1377

PDUMP_DBG(("PDumpCommentKM"));

1378

#if defined(PDUMP_DEBUG_OUTFILES)

1379

1380

ui32Flags |= ( _PDumpIsPersistent() ) ? PDUMP_FLAGS_PERSISTENT : 0;

1381

#endif

1382

1383

PDumpOSVerifyLineEnding(pszComment, ui32MaxLen);

1384

1385

1386

ui32LenCommentPrefix = PDumpOSBuflen(pszCommentPrefix, sizeof(pszCommentPrefix));

1387

1388

1389

1390

if (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_SCRIPT2),

1391

(IMG_UINT8*)pszCommentPrefix,

1392

ui32LenCommentPrefix,

1393

ui32Flags))

1394

{

1395

#if defined(PDUMP_DEBUG_OUTFILES)

1396

if(ui32Flags & PDUMP_FLAGS_CONTINUOUS)

1397

{

1398

PVR_DPF((PVR_DBG_WARNING, "Incomplete comment, %d: %s (continuous set)",

1399

g_ui32EveryLineCounter, pszComment));

1400

return PVRSRV_ERROR_PDUMP_BUFFER_FULL;

1401

}

1402

else if(ui32Flags & PDUMP_FLAGS_PERSISTENT)

1403

{

1404

PVR_DPF((PVR_DBG_WARNING, "Incomplete comment, %d: %s (persistent set)",

1405

g_ui32EveryLineCounter, pszComment));

1406

return PVRSRV_ERROR_CMD_NOT_PROCESSED;

1407

}

1408

else

1409

{

1410

PVR_DPF((PVR_DBG_WARNING, "Incomplete comment, %d: %s",

1411

g_ui32EveryLineCounter, pszComment));

1412

return PVRSRV_ERROR_CMD_NOT_PROCESSED;

1413

}

1414

#else

1415

PVR_DPF((PVR_DBG_WARNING, "Incomplete comment, %s",

1416

pszComment));

1417

return PVRSRV_ERROR_CMD_NOT_PROCESSED;

1418

#endif

1419

}

1420

1421

#if defined(PDUMP_DEBUG_OUTFILES)

1422

1423

eErr = PDumpOSSprintf(pszTemp, 256, "%d-%d %s",

1424

_PDumpGetPID(),

1425

g_ui32EveryLineCounter,

1426

pszComment);

1427

1428

1429

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "%s",

1430

pszTemp);

1431

#else

1432

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "%s",

1433

pszComment);

1434

#endif

1435

if( (eErr != PVRSRV_OK) &&

1436

(eErr != PVRSRV_ERROR_PDUMP_BUF_OVERFLOW))

1437

{

1438

return eErr;

1439

}

1440

PDumpOSWriteString2(hScript, ui32Flags);

1441

return PVRSRV_OK;

1442

}

1443

1444

PVRSRV_ERROR PDumpCommentWithFlags(IMG_UINT32 ui32Flags, IMG_CHAR * pszFormat, ...)

1445

{

1446

PVRSRV_ERROR eErr;

1447

PDUMP_va_list ap;

1448

PDUMP_GET_MSG_STRING();

1449

1450

1451

PDUMP_va_start(ap, pszFormat);

1452

eErr = PDumpOSVSprintf(pszMsg, ui32MaxLen, pszFormat, ap);

1453

PDUMP_va_end(ap);

1454

1455

if(eErr != PVRSRV_OK)

1456

{

1457

return eErr;

1458

}

1459

return PDumpCommentKM(pszMsg, ui32Flags);

1460

}

1461

1462

PVRSRV_ERROR PDumpComment(IMG_CHAR *pszFormat, ...)

1463

{

1464

PVRSRV_ERROR eErr;

1465

PDUMP_va_list ap;

1466

PDUMP_GET_MSG_STRING();

1467

1468

1469

PDUMP_va_start(ap, pszFormat);

1470

eErr = PDumpOSVSprintf(pszMsg, ui32MaxLen, pszFormat, ap);

1471

PDUMP_va_end(ap);

1472

1473

if(eErr != PVRSRV_OK)

1474

{

1475

return eErr;

1476

}

1477

return PDumpCommentKM(pszMsg, PDUMP_FLAGS_CONTINUOUS);

1478

}

1479

1480

PVRSRV_ERROR PDumpDriverInfoKM(IMG_CHAR *pszString, IMG_UINT32 ui32Flags)

1481

{

1482

PVRSRV_ERROR eErr;

1483

IMG_UINT32 ui32MsgLen;

1484

PDUMP_GET_MSG_STRING();

1485

1486

1487

eErr = PDumpOSSprintf(pszMsg, ui32MaxLen, "%s", pszString);

1488

if(eErr != PVRSRV_OK)

1489

{

1490

return eErr;

1491

}

1492

1493

1494

PDumpOSVerifyLineEnding(pszMsg, ui32MaxLen);

1495

ui32MsgLen = PDumpOSBuflen(pszMsg, ui32MaxLen);

1496

1497

if (!PDumpOSWriteString(PDumpOSGetStream(PDUMP_STREAM_DRIVERINFO),

1498

(IMG_UINT8*)pszMsg,

1499

ui32MsgLen,

1500

ui32Flags))

1501

{

1502

if (ui32Flags & PDUMP_FLAGS_CONTINUOUS)

1503

{

1504

return PVRSRV_ERROR_PDUMP_BUFFER_FULL;

1505

}

1506

else

1507

{

1508

return PVRSRV_ERROR_CMD_NOT_PROCESSED;

1509

}

1510

}

1511

return PVRSRV_OK;

1512

}

1513

1514

PVRSRV_ERROR PDumpBitmapKM( PVRSRV_DEVICE_NODE *psDeviceNode,

1515

IMG_CHAR *pszFileName,

1516

IMG_UINT32 ui32FileOffset,

1517

IMG_UINT32 ui32Width,

1518

IMG_UINT32 ui32Height,

1519

IMG_UINT32 ui32StrideInBytes,

1520

IMG_DEV_VIRTADDR sDevBaseAddr,

1521

IMG_HANDLE hDevMemContext,

1522

IMG_UINT32 ui32Size,

1523

PDUMP_PIXEL_FORMAT ePixelFormat,

1524

PDUMP_MEM_FORMAT eMemFormat,

1525

IMG_UINT32 ui32PDumpFlags)

1526

{

1527

PVRSRV_DEVICE_IDENTIFIER *psDevId = &psDeviceNode->sDevId;

1528

IMG_UINT32 ui32MMUContextID;

1529

PVRSRV_ERROR eErr;

1530

PDUMP_GET_SCRIPT_STRING();

1531

1532

if ( _PDumpIsPersistent() )

1533

{

1534

return PVRSRV_OK;

1535

}

1536

1537

PDumpCommentWithFlags(ui32PDumpFlags, "\r\n-- Dump bitmap of render\r\n");

1538

1539

1540

ui32MMUContextID = psDeviceNode->pfnMMUGetContextID( hDevMemContext );

1541

1542

eErr = PDumpOSBufprintf(hScript,

1543

ui32MaxLen,

1544

"SII %s %s.bin :%s:v%x:0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\r\n",

1545

pszFileName,

1546

pszFileName,

1547

psDevId->pszPDumpDevName,

1548

ui32MMUContextID,

1549

sDevBaseAddr.uiAddr,

1550

ui32Size,

1551

ui32FileOffset,

1552

ePixelFormat,

1553

ui32Width,

1554

ui32Height,

1555

ui32StrideInBytes,

1556

eMemFormat);

1557

if(eErr != PVRSRV_OK)

1558

{

1559

return eErr;

1560

}

1561

1562

PDumpOSWriteString2( hScript, ui32PDumpFlags);

1563

return PVRSRV_OK;

1564

}

1565

1566

PVRSRV_ERROR PDumpReadRegKM ( IMG_CHAR *pszPDumpRegName,

1567

IMG_CHAR *pszFileName,

1568

IMG_UINT32 ui32FileOffset,

1569

IMG_UINT32 ui32Address,

1570

IMG_UINT32 ui32Size,

1571

IMG_UINT32 ui32PDumpFlags)

1572

{

1573

PVRSRV_ERROR eErr;

1574

PDUMP_GET_SCRIPT_STRING();

1575

1576

PVR_UNREFERENCED_PARAMETER(ui32Size);

1577

1578

eErr = PDumpOSBufprintf(hScript,

1579

ui32MaxLen,

1580

"SAB :%s:0x%08X 0x%08X %s\r\n",

1581

pszPDumpRegName,

1582

ui32Address,

1583

ui32FileOffset,

1584

pszFileName);

1585

if(eErr != PVRSRV_OK)

1586

{

1587

return eErr;

1588

}

1589

1590

PDumpOSWriteString2( hScript, ui32PDumpFlags);

1591

1592

return PVRSRV_OK;

1593

}

1594

1595

IMG_BOOL PDumpTestNextFrame(IMG_UINT32 ui32CurrentFrame)

1596

{

1597

IMG_BOOL bFrameDumped;

1598

1599

1600

1601

(IMG_VOID) PDumpSetFrameKM(ui32CurrentFrame + 1);

1602

bFrameDumped = PDumpIsCaptureFrameKM();

1603

(IMG_VOID) PDumpSetFrameKM(ui32CurrentFrame);

1604

1605

return bFrameDumped;

1606

}

1607

1608

static PVRSRV_ERROR PDumpSignatureRegister (PVRSRV_DEVICE_IDENTIFIER *psDevId,

1609

IMG_CHAR *pszFileName,

1610

IMG_UINT32 ui32Address,

1611

IMG_UINT32 ui32Size,

1612

IMG_UINT32 *pui32FileOffset,

1613

IMG_UINT32 ui32Flags)

1614

{

1615

PVRSRV_ERROR eErr;

1616

PDUMP_GET_SCRIPT_STRING();

1617

1618

eErr = PDumpOSBufprintf(hScript,

1619

ui32MaxLen,

1620

"SAB :%s:0x%08X 0x%08X %s\r\n",

1621

psDevId->pszPDumpRegName,

1622

ui32Address,

1623

*pui32FileOffset,

1624

pszFileName);

1625

if(eErr != PVRSRV_OK)

1626

{

1627

return eErr;

1628

}

1629

1630

PDumpOSWriteString2(hScript, ui32Flags);

1631

*pui32FileOffset += ui32Size;

1632

return PVRSRV_OK;

1633

}

1634

1635

static IMG_VOID PDumpRegisterRange(PVRSRV_DEVICE_IDENTIFIER *psDevId,

1636

IMG_CHAR *pszFileName,

1637

IMG_UINT32 *pui32Registers,

1638

IMG_UINT32 ui32NumRegisters,

1639

IMG_UINT32 *pui32FileOffset,

1640

IMG_UINT32 ui32Size,

1641

IMG_UINT32 ui32Flags)

1642

{

1643

IMG_UINT32 i;

1644

for (i = 0; i < ui32NumRegisters; i++)

1645

{

1646

PDumpSignatureRegister(psDevId, pszFileName, pui32Registers[i], ui32Size, pui32FileOffset, ui32Flags);

1647

}

1648

}

1649

1650

PVRSRV_ERROR PDump3DSignatureRegisters(PVRSRV_DEVICE_IDENTIFIER *psDevId,

1651

IMG_UINT32 ui32DumpFrameNum,

1652

IMG_BOOL bLastFrame,

1653

IMG_UINT32 *pui32Registers,

1654

IMG_UINT32 ui32NumRegisters)

1655

{

1656

PVRSRV_ERROR eErr;

1657

IMG_UINT32 ui32FileOffset, ui32Flags;

1658

1659

PDUMP_GET_FILE_STRING();

1660

1661

ui32Flags = bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0;

1662

ui32FileOffset = 0;

1663

1664

PDumpCommentWithFlags(ui32Flags, "\r\n-- Dump 3D signature registers\r\n");

1665

eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%u_3d.sig", ui32DumpFrameNum);

1666

if(eErr != PVRSRV_OK)

1667

{

1668

return eErr;

1669

}

1670

1671

PDumpRegisterRange(psDevId,

1672

pszFileName,

1673

pui32Registers,

1674

ui32NumRegisters,

1675

&ui32FileOffset,

1676

sizeof(IMG_UINT32),

1677

ui32Flags);

1678

1679

return PVRSRV_OK;

1680

}

1681

1682

PVRSRV_ERROR PDumpTASignatureRegisters (PVRSRV_DEVICE_IDENTIFIER *psDevId,

1683

IMG_UINT32 ui32DumpFrameNum,

1684

IMG_UINT32 ui32TAKickCount,

1685

IMG_BOOL bLastFrame,

1686

IMG_UINT32 *pui32Registers,

1687

IMG_UINT32 ui32NumRegisters)

1688

{

1689

PVRSRV_ERROR eErr;

1690

IMG_UINT32 ui32FileOffset, ui32Flags;

1691

1692

PDUMP_GET_FILE_STRING();

1693

1694

ui32Flags = bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0;

1695

ui32FileOffset = ui32TAKickCount * ui32NumRegisters * sizeof(IMG_UINT32);

1696

1697

PDumpCommentWithFlags(ui32Flags, "\r\n-- Dump TA signature registers\r\n");

1698

eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%u_ta.sig", ui32DumpFrameNum);

1699

if(eErr != PVRSRV_OK)

1700

{

1701

return eErr;

1702

}

1703

1704

PDumpRegisterRange(psDevId,

1705

pszFileName,

1706

pui32Registers,

1707

ui32NumRegisters,

1708

&ui32FileOffset,

1709

sizeof(IMG_UINT32),

1710

ui32Flags);

1711

return PVRSRV_OK;

1712

}

1713

1714

PVRSRV_ERROR PDumpCounterRegisters (PVRSRV_DEVICE_IDENTIFIER *psDevId,

1715

IMG_UINT32 ui32DumpFrameNum,

1716

IMG_BOOL bLastFrame,

1717

IMG_UINT32 *pui32Registers,

1718

IMG_UINT32 ui32NumRegisters)

1719

{

1720

PVRSRV_ERROR eErr;

1721

IMG_UINT32 ui32FileOffset, ui32Flags;

1722

1723

PDUMP_GET_FILE_STRING();

1724

1725

ui32Flags = bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0UL;

1726

ui32FileOffset = 0UL;

1727

1728

PDumpCommentWithFlags(ui32Flags, "\r\n-- Dump counter registers\r\n");

1729

eErr = PDumpOSSprintf(pszFileName, ui32MaxLen, "out%u.perf", ui32DumpFrameNum);

1730

if(eErr != PVRSRV_OK)

1731

{

1732

return eErr;

1733

}

1734

1735

PDumpRegisterRange(psDevId,

1736

pszFileName,

1737

pui32Registers,

1738

ui32NumRegisters,

1739

&ui32FileOffset,

1740

sizeof(IMG_UINT32),

1741

ui32Flags);

1742

1743

return PVRSRV_OK;

1744

}

1745

1746

PVRSRV_ERROR PDumpRegRead(IMG_CHAR *pszPDumpRegName,

1747

const IMG_UINT32 ui32RegOffset,

1748

IMG_UINT32 ui32Flags)

1749

{

1750

PVRSRV_ERROR eErr;

1751

PDUMP_GET_SCRIPT_STRING();

1752

1753

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "RDW :%s:0x%X\r\n",

1754

pszPDumpRegName,

1755

ui32RegOffset);

1756

if(eErr != PVRSRV_OK)

1757

{

1758

return eErr;

1759

}

1760

PDumpOSWriteString2(hScript, ui32Flags);

1761

return PVRSRV_OK;

1762

}

1763

1764

PVRSRV_ERROR PDumpSaveMemKM (PVRSRV_DEVICE_IDENTIFIER *psDevId,

1765

IMG_CHAR *pszFileName,

1766

IMG_UINT32 ui32FileOffset,

1767

IMG_DEV_VIRTADDR sDevBaseAddr,

1768

IMG_UINT32 ui32Size,

1769

IMG_UINT32 ui32MMUContextID,

1770

IMG_UINT32 ui32PDumpFlags)

1771

{

1772

PVRSRV_ERROR eErr;

1773

PDUMP_GET_SCRIPT_STRING();

1774

1775

eErr = PDumpOSBufprintf(hScript,

1776

ui32MaxLen,

1777

"SAB :%s:v%x:0x%08X 0x%08X 0x%08X %s.bin\r\n",

1778

psDevId->pszPDumpDevName,

1779

ui32MMUContextID,

1780

sDevBaseAddr.uiAddr,

1781

ui32Size,

1782

ui32FileOffset,

1783

pszFileName);

1784

if(eErr != PVRSRV_OK)

1785

{

1786

return eErr;

1787

}

1788

1789

PDumpOSWriteString2(hScript, ui32PDumpFlags);

1790

return PVRSRV_OK;

1791

}

1792

1793

PVRSRV_ERROR PDumpCycleCountRegRead(PVRSRV_DEVICE_IDENTIFIER *psDevId,

1794

const IMG_UINT32 ui32RegOffset,

1795

IMG_BOOL bLastFrame)

1796

{

1797

PVRSRV_ERROR eErr;

1798

PDUMP_GET_SCRIPT_STRING();

1799

1800

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "RDW :%s:0x%X\r\n",

1801

psDevId->pszPDumpRegName,

1802

ui32RegOffset);

1803

if(eErr != PVRSRV_OK)

1804

{

1805

return eErr;

1806

}

1807

PDumpOSWriteString2(hScript, bLastFrame ? PDUMP_FLAGS_LASTFRAME : 0);

1808

return PVRSRV_OK;

1809

}

1810

1811

1812

PVRSRV_ERROR PDumpSignatureBuffer (PVRSRV_DEVICE_IDENTIFIER *psDevId,

1813

IMG_CHAR *pszFileName,

1814

IMG_CHAR *pszBufferType,

1815

IMG_UINT32 ui32FileOffset,

1816

IMG_DEV_VIRTADDR sDevBaseAddr,

1817

IMG_UINT32 ui32Size,

1818

IMG_UINT32 ui32MMUContextID,

1819

IMG_UINT32 ui32PDumpFlags)

1820

{

1821

PDumpCommentWithFlags(ui32PDumpFlags, "\r\n-- Dump microkernel %s signature Buffer\r\n",

1822

pszBufferType);

1823

PDumpCommentWithFlags(ui32PDumpFlags, "Buffer format (sizes in 32-bit words):\r\n");

1824

PDumpCommentWithFlags(ui32PDumpFlags, "\tNumber of signatures per sample (1)\r\n");

1825

PDumpCommentWithFlags(ui32PDumpFlags, "\tNumber of samples (1)\r\n");

1826

PDumpCommentWithFlags(ui32PDumpFlags, "\tSignature register offsets (1 * number of signatures)\r\n");

1827

PDumpCommentWithFlags(ui32PDumpFlags, "\tSignature sample values (number of samples * number of signatures)\r\n");

1828

PDumpCommentWithFlags(ui32PDumpFlags, "Note: If buffer is full, last sample is final state after test completed\r\n");

1829

return PDumpSaveMemKM(psDevId, pszFileName, ui32FileOffset, sDevBaseAddr, ui32Size,

1830

ui32MMUContextID, ui32PDumpFlags);

1831

}

1832

1833

1834

PVRSRV_ERROR PDumpHWPerfCBKM (PVRSRV_DEVICE_IDENTIFIER *psDevId,

1835

IMG_CHAR *pszFileName,

1836

IMG_UINT32 ui32FileOffset,

1837

IMG_DEV_VIRTADDR sDevBaseAddr,

1838

IMG_UINT32 ui32Size,

1839

IMG_UINT32 ui32MMUContextID,

1840

IMG_UINT32 ui32PDumpFlags)

1841

{

1842

PDumpCommentWithFlags(ui32PDumpFlags, "\r\n-- Dump Hardware Performance Circular Buffer\r\n");

1843

return PDumpSaveMemKM(psDevId, pszFileName, ui32FileOffset, sDevBaseAddr, ui32Size,

1844

ui32MMUContextID, ui32PDumpFlags);

1845

}

1846

1847

1848

PVRSRV_ERROR PDumpCBP(PPVRSRV_KERNEL_MEM_INFO psROffMemInfo,

1849

IMG_UINT32 ui32ROffOffset,

1850

IMG_UINT32 ui32WPosVal,

1851

IMG_UINT32 ui32PacketSize,

1852

IMG_UINT32 ui32BufferSize,

1853

IMG_UINT32 ui32Flags,

1854

IMG_HANDLE hUniqueTag)

1855

{

1856

PVRSRV_ERROR eErr;

1857

IMG_UINT32 ui32PageOffset;

1858

IMG_UINT8 *pui8LinAddr;

1859

IMG_DEV_VIRTADDR sDevVAddr;

1860

IMG_DEV_PHYADDR sDevPAddr;

1861

IMG_DEV_VIRTADDR sDevVPageAddr;

1862

1863

PDUMP_MMU_ATTRIB *psMMUAttrib;

1864

1865

PDUMP_GET_SCRIPT_STRING();

1866

1867

psMMUAttrib = ((BM_BUF*)psROffMemInfo->sMemBlk.hBuffer)->pMapping->pBMHeap->psMMUAttrib;

1868

1869

1870

PVR_ASSERT((ui32ROffOffset + sizeof(IMG_UINT32)) <= psROffMemInfo->uAllocSize);

1871

1872

pui8LinAddr = psROffMemInfo->pvLinAddrKM;

1873

sDevVAddr = psROffMemInfo->sDevVAddr;

1874

1875

1876

pui8LinAddr += ui32ROffOffset;

1877

sDevVAddr.uiAddr += ui32ROffOffset;

1878

1879

1880

1881

1882

PDumpOSCPUVAddrToPhysPages(psROffMemInfo->sMemBlk.hOSMemHandle,

1883

ui32ROffOffset,

1884

pui8LinAddr,

1885

psMMUAttrib->ui32DataPageMask,

1886

&ui32PageOffset);

1887

1888

1889

sDevVPageAddr.uiAddr = sDevVAddr.uiAddr - ui32PageOffset;

1890

1891

PVR_ASSERT((sDevVPageAddr.uiAddr & 0xFFF) == 0);

1892

1893

1894

BM_GetPhysPageAddr(psROffMemInfo, sDevVPageAddr, &sDevPAddr);

1895

1896

1897

sDevPAddr.uiAddr += ui32PageOffset;

1898

1899

eErr = PDumpOSBufprintf(hScript,

1900

ui32MaxLen,

1901

"CBP :%s:PA_%08X%08X:0x%08X 0x%08X 0x%08X 0x%08X\r\n",

1902

psMMUAttrib->sDevId.pszPDumpDevName,

1903

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,

1904

sDevPAddr.uiAddr & ~(psMMUAttrib->ui32DataPageMask),

1905

sDevPAddr.uiAddr & (psMMUAttrib->ui32DataPageMask),

1906

ui32WPosVal,

1907

ui32PacketSize,

1908

ui32BufferSize);

1909

if(eErr != PVRSRV_OK)

1910

{

1911

return eErr;

1912

}

1913

PDumpOSWriteString2(hScript, ui32Flags);

1914

return PVRSRV_OK;

1915

}

1916

1917

1918

PVRSRV_ERROR PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags)

1919

{

1920

PVRSRV_ERROR eErr;

1921

PDUMP_GET_SCRIPT_STRING();

1922

PDUMP_DBG(("PDumpIDLWithFlags"));

1923

1924

eErr = PDumpOSBufprintf(hScript, ui32MaxLen, "IDL %u\r\n", ui32Clocks);

1925

if(eErr != PVRSRV_OK)

1926

{

1927

return eErr;

1928

}

1929

PDumpOSWriteString2(hScript, ui32Flags);

1930

return PVRSRV_OK;

1931

}

1932

1933

1934

PVRSRV_ERROR PDumpIDL(IMG_UINT32 ui32Clocks)

1935

{

1936

return PDumpIDLWithFlags(ui32Clocks, PDUMP_FLAGS_CONTINUOUS);

1937

}

1938

1939

PVRSRV_ERROR PDumpMemUM(PVRSRV_PER_PROCESS_DATA *psPerProc,

1940

IMG_PVOID pvAltLinAddrUM,

1941

IMG_PVOID pvLinAddrUM,

1942

PVRSRV_KERNEL_MEM_INFO *psMemInfo,

1943

IMG_UINT32 ui32Offset,

1944

IMG_UINT32 ui32Bytes,

1945

IMG_UINT32 ui32Flags,

1946

IMG_HANDLE hUniqueTag)

1947

{

1948

IMG_VOID *pvAddrUM;

1949

IMG_VOID *pvAddrKM;

1950

IMG_UINT32 ui32BytesDumped;

1951

IMG_UINT32 ui32CurrentOffset;

1952

1953

if (psMemInfo->pvLinAddrKM != IMG_NULL && pvAltLinAddrUM == IMG_NULL)

1954

{

1955

1956

return PDumpMemKM(IMG_NULL,

1957

psMemInfo,

1958

ui32Offset,

1959

ui32Bytes,

1960

ui32Flags,

1961

hUniqueTag);

1962

}

1963

1964

pvAddrUM = (pvAltLinAddrUM != IMG_NULL) ? pvAltLinAddrUM : ((pvLinAddrUM != IMG_NULL) ? VPTR_PLUS(pvLinAddrUM, ui32Offset) : IMG_NULL);

1965

1966

pvAddrKM = GetTempBuffer();

1967

1968

1969

PVR_ASSERT(pvAddrUM != IMG_NULL && pvAddrKM != IMG_NULL);

1970

if (pvAddrUM == IMG_NULL || pvAddrKM == IMG_NULL)

1971

{

1972

PVR_DPF((PVR_DBG_ERROR, "PDumpMemUM: Nothing to dump"));

1973

return PVRSRV_ERROR_INVALID_PARAMS;

1974

}

1975

1976

if (ui32Bytes > PDUMP_TEMP_BUFFER_SIZE)

1977

{

1978

PDumpCommentWithFlags(ui32Flags, "Dumping 0x%08x bytes of memory, in blocks of 0x%08x bytes", ui32Bytes, (IMG_UINT32)PDUMP_TEMP_BUFFER_SIZE);

1979

}

1980

1981

ui32CurrentOffset = ui32Offset;

1982

for (ui32BytesDumped = 0; ui32BytesDumped < ui32Bytes;)

1983

{

1984

PVRSRV_ERROR eError;

1985

IMG_UINT32 ui32BytesToDump = MIN(PDUMP_TEMP_BUFFER_SIZE, ui32Bytes - ui32BytesDumped);

1986

1987

eError = OSCopyFromUser(psPerProc,

1988

pvAddrKM,

1989

pvAddrUM,

1990

ui32BytesToDump);

1991

if (eError != PVRSRV_OK)

1992

{

1993

PVR_DPF((PVR_DBG_ERROR, "PDumpMemUM: OSCopyFromUser failed (%d)", eError));

1994

return eError;

1995

}

1996

1997

eError = PDumpMemKM(pvAddrKM,

1998

psMemInfo,

1999

ui32CurrentOffset,

2000

ui32BytesToDump,

2001

ui32Flags,

2002

hUniqueTag);

2003

2004

if (eError != PVRSRV_OK)

2005

{

2006

2007

if (ui32BytesDumped != 0)

2008

{

2009

PVR_DPF((PVR_DBG_ERROR, "PDumpMemUM: PDumpMemKM failed (%d)", eError));

2010

}

2011

PVR_ASSERT(ui32BytesDumped == 0);

2012

return eError;

2013

}

2014

2015

VPTR_INC(pvAddrUM, ui32BytesToDump);

2016

ui32CurrentOffset += ui32BytesToDump;

2017

ui32BytesDumped += ui32BytesToDump;

2018

}

2019

2020

return PVRSRV_OK;

2021

}

2022

2023

2024

static PVRSRV_ERROR _PdumpAllocMMUContext(IMG_UINT32 *pui32MMUContextID)

2025

{

2026

IMG_UINT32 i;

2027

2028

2029

for(i=0; i<MAX_PDUMP_MMU_CONTEXTS; i++)

2030

{

2031

if((gui16MMUContextUsage & (1U << i)) == 0)

2032

{

2033

2034

gui16MMUContextUsage |= 1U << i;

2035

*pui32MMUContextID = i;

2036

return PVRSRV_OK;

2037

}

2038

}

2039

2040

PVR_DPF((PVR_DBG_ERROR, "_PdumpAllocMMUContext: no free MMU context ids"));

2041

2042

return PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND;

2043

}

2044

2045

2046

static PVRSRV_ERROR _PdumpFreeMMUContext(IMG_UINT32 ui32MMUContextID)

2047

{

2048

if(ui32MMUContextID < MAX_PDUMP_MMU_CONTEXTS)

2049

{

2050

2051

gui16MMUContextUsage &= ~(1U << ui32MMUContextID);

2052

return PVRSRV_OK;

2053

}

2054

2055

PVR_DPF((PVR_DBG_ERROR, "_PdumpFreeMMUContext: MMU context ids invalid"));

2056

2057

return PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND;

2058

}

2059

2060

2061

PVRSRV_ERROR PDumpSetMMUContext(PVRSRV_DEVICE_TYPE eDeviceType,

2062

IMG_CHAR *pszMemSpace,

2063

IMG_UINT32 *pui32MMUContextID,

2064

IMG_UINT32 ui32MMUType,

2065

IMG_HANDLE hUniqueTag1,

2066

IMG_HANDLE hOSMemHandle,

2067

IMG_VOID *pvPDCPUAddr)

2068

{

2069

IMG_UINT8 *pui8LinAddr = (IMG_UINT8 *)pvPDCPUAddr;

2070

IMG_CPU_PHYADDR sCpuPAddr;

2071

IMG_DEV_PHYADDR sDevPAddr;

2072

IMG_UINT32 ui32MMUContextID;

2073

PVRSRV_ERROR eErr;

2074

PDUMP_GET_SCRIPT_STRING();

2075

2076

eErr = _PdumpAllocMMUContext(&ui32MMUContextID);

2077

if(eErr != PVRSRV_OK)

2078

{

2079

PVR_DPF((PVR_DBG_ERROR, "PDumpSetMMUContext: _PdumpAllocMMUContext failed: %d", eErr));

2080

return eErr;

2081

}

2082

2083

2084

2085

sCpuPAddr = OSMapLinToCPUPhys(hOSMemHandle, pui8LinAddr);

2086

sDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);

2087

2088

sDevPAddr.uiAddr &= ~((PVRSRV_4K_PAGE_SIZE) -1);

2089

2090

eErr = PDumpOSBufprintf(hScript,

2091

ui32MaxLen,

2092

"MMU :%s:v%d %d :%s:PA_%08X%08X\r\n",

2093

pszMemSpace,

2094

ui32MMUContextID,

2095

ui32MMUType,

2096

pszMemSpace,

2097

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag1,

2098

sDevPAddr.uiAddr);

2099

if(eErr != PVRSRV_OK)

2100

{

2101

return eErr;

2102

}

2103

PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);

2104

2105

2106

*pui32MMUContextID = ui32MMUContextID;

2107

2108

return PVRSRV_OK;

2109

}

2110

2111

2112

PVRSRV_ERROR PDumpClearMMUContext(PVRSRV_DEVICE_TYPE eDeviceType,

2113

IMG_CHAR *pszMemSpace,

2114

IMG_UINT32 ui32MMUContextID,

2115

IMG_UINT32 ui32MMUType)

2116

{

2117

PVRSRV_ERROR eErr;

2118

PDUMP_GET_SCRIPT_STRING();

2119

PVR_UNREFERENCED_PARAMETER(eDeviceType);

2120

PVR_UNREFERENCED_PARAMETER(ui32MMUType);

2121

2122

2123

PDumpComment("Clear MMU Context for memory space %s\r\n", pszMemSpace);

2124

eErr = PDumpOSBufprintf(hScript,

2125

ui32MaxLen,

2126

"MMU :%s:v%d\r\n",

2127

pszMemSpace,

2128

ui32MMUContextID);

2129

if(eErr != PVRSRV_OK)

2130

{

2131

return eErr;

2132

}

2133

PDumpOSWriteString2(hScript, PDUMP_FLAGS_CONTINUOUS);

2134

2135

eErr = _PdumpFreeMMUContext(ui32MMUContextID);

2136

if(eErr != PVRSRV_OK)

2137

{

2138

PVR_DPF((PVR_DBG_ERROR, "PDumpClearMMUContext: _PdumpFreeMMUContext failed: %d", eErr));

2139

return eErr;

2140

}

2141

2142

return PVRSRV_OK;

2143

}

2144

2145

PVRSRV_ERROR PDumpStoreMemToFile(PDUMP_MMU_ATTRIB *psMMUAttrib,

2146

IMG_CHAR *pszFileName,

2147

IMG_UINT32 ui32FileOffset,

2148

PVRSRV_KERNEL_MEM_INFO *psMemInfo,

2149

IMG_UINT32 uiAddr,

2150

IMG_UINT32 ui32Size,

2151

IMG_UINT32 ui32PDumpFlags,

2152

IMG_HANDLE hUniqueTag)

2153

{

2154

IMG_DEV_PHYADDR sDevPAddr;

2155

IMG_DEV_VIRTADDR sDevVPageAddr;

2156

IMG_UINT32 ui32PageOffset;

2157

2158

PDUMP_GET_SCRIPT_STRING();

2159

2160

2161

2162

2163

ui32PageOffset = (IMG_UINT32)((IMG_UINTPTR_T)psMemInfo->pvLinAddrKM & psMMUAttrib->ui32DataPageMask);

2164

2165

2166

sDevVPageAddr.uiAddr = uiAddr - ui32PageOffset;

2167

2168

2169

BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);

2170

2171

2172

sDevPAddr.uiAddr += ui32PageOffset;

2173

2174

PDumpOSBufprintf(hScript,

2175

ui32MaxLen,

2176

"SAB :%s:PA_%08X%08X:0x%08X 0x%08X 0x%08X %s\r\n",

2177

psMMUAttrib->sDevId.pszPDumpDevName,

2178

(IMG_UINT32)(IMG_UINTPTR_T)hUniqueTag,

2179

sDevPAddr.uiAddr & ~psMMUAttrib->ui32DataPageMask,

2180

sDevPAddr.uiAddr & psMMUAttrib->ui32DataPageMask,

2181

ui32Size,

2182

ui32FileOffset,

2183

pszFileName);

2184

2185

PDumpOSWriteString2(hScript, ui32PDumpFlags);

2186

2187

return PVRSRV_OK;

2188

}

2189

2190

PVRSRV_ERROR PDumpRegBasedCBP(IMG_CHAR *pszPDumpRegName,

2191

IMG_UINT32 ui32RegOffset,

2192

IMG_UINT32 ui32WPosVal,

2193

IMG_UINT32 ui32PacketSize,

2194

IMG_UINT32 ui32BufferSize,

2195

IMG_UINT32 ui32Flags)

2196

{

2197

PDUMP_GET_SCRIPT_STRING();

2198

2199

PDumpOSBufprintf(hScript,

2200

ui32MaxLen,

2201

"CBP :%s:0x%08X 0x%08X 0x%08X 0x%08X\r\n",

2202

pszPDumpRegName,

2203

ui32RegOffset,

2204

ui32WPosVal,

2205

ui32PacketSize,

2206

ui32BufferSize);

2207

PDumpOSWriteString2(hScript, ui32Flags);

2208

2209

return PVRSRV_OK;

2210

}

2211

2212

2213

2214

#include "syscommon.h"

2215

2216

IMG_EXPORT IMG_VOID PDumpConnectionNotify(IMG_VOID)

2217

{

2218

SYS_DATA *psSysData;

2219

PVRSRV_DEVICE_NODE *psThis;

2220

PVR_DPF((PVR_DBG_WARNING, "PDump has connected."));

2221

2222

2223

SysAcquireData(&psSysData);

2224

2225

psThis = psSysData->psDeviceNodeList;

2226

while (psThis)

2227

{

2228

if (psThis->pfnPDumpInitDevice)

2229

{

2230

2231

psThis->pfnPDumpInitDevice(psThis);

2232

}

2233

psThis = psThis->psNext;

2234

}

2235

}

2236

2237

IMG_UINT32 DbgWrite(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32BCount, IMG_UINT32 ui32Flags)

2238

{

2239

IMG_UINT32 ui32BytesWritten = 0;

2240

IMG_UINT32 ui32Off = 0;

2241

PDBG_STREAM_CONTROL psCtrl = psStream->psCtrl;

2242

2243

2244

if ((ui32Flags & PDUMP_FLAGS_NEVER) != 0)

2245

{

2246

return ui32BCount;

2247

}

2248

2249

#if defined(SUPPORT_PDUMP_MULTI_PROCESS)

2250

2251

if ( (_PDumpIsProcessActive() == IMG_FALSE ) &&

2252

((ui32Flags & PDUMP_FLAGS_PERSISTENT) == 0) )

2253

{

2254

return ui32BCount;

2255

}

2256

#endif

2257

2258

2259

if ( ((ui32Flags & PDUMP_FLAGS_PERSISTENT) != 0) && (psCtrl->bInitPhaseComplete) )

2260

{

2261

while (ui32BCount > 0)

2262

{

2263

2264

2265

2266

ui32BytesWritten = PDumpOSDebugDriverWrite( psStream,

2267

PDUMP_WRITE_MODE_PERSISTENT,

2268

&pui8Data[ui32Off], ui32BCount, 1, 0);

2269

2270

if (ui32BytesWritten == 0)

2271

{

2272

PDumpOSReleaseExecution();

2273

}

2274

2275

if (ui32BytesWritten != 0xFFFFFFFFU)

2276

{

2277

ui32Off += ui32BytesWritten;

2278

ui32BCount -= ui32BytesWritten;

2279

}

2280

else

2281

{

2282

PVR_DPF((PVR_DBG_ERROR, "DbgWrite: Failed to send persistent data"));

2283

if( (psCtrl->ui32Flags & DEBUG_FLAGS_READONLY) != 0)

2284

{

2285

2286

PDumpSuspendKM();

2287

}

2288

return 0xFFFFFFFFU;

2289

}

2290

}

2291

2292

2293

ui32BCount = ui32Off; ui32Off = 0; ui32BytesWritten = 0;

2294

}

2295

2296

while (((IMG_UINT32) ui32BCount > 0) && (ui32BytesWritten != 0xFFFFFFFFU))

2297

{

2298

if ((ui32Flags & PDUMP_FLAGS_CONTINUOUS) != 0)

2299

{

2300

2301

2302

if (((psCtrl->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0) &&

2303

(psCtrl->ui32Start == 0xFFFFFFFFU) &&

2304

(psCtrl->ui32End == 0xFFFFFFFFU) &&

2305

psCtrl->bInitPhaseComplete)

2306

{

2307

ui32BytesWritten = ui32BCount;

2308

}

2309

else

2310

{

2311

ui32BytesWritten = PDumpOSDebugDriverWrite( psStream,

2312

PDUMP_WRITE_MODE_CONTINUOUS,

2313

&pui8Data[ui32Off], ui32BCount, 1, 0);

2314

}

2315

}

2316

else

2317

{

2318

if (ui32Flags & PDUMP_FLAGS_LASTFRAME)

2319

{

2320

IMG_UINT32 ui32DbgFlags;

2321

2322

ui32DbgFlags = 0;

2323

if (ui32Flags & PDUMP_FLAGS_RESETLFBUFFER)

2324

{

2325

ui32DbgFlags |= WRITELF_FLAGS_RESETBUF;

2326

}

2327

2328

ui32BytesWritten = PDumpOSDebugDriverWrite( psStream,

2329

PDUMP_WRITE_MODE_LASTFRAME,

2330

&pui8Data[ui32Off], ui32BCount, 1, ui32DbgFlags);

2331

}

2332

else

2333

{

2334

ui32BytesWritten = PDumpOSDebugDriverWrite( psStream,

2335

PDUMP_WRITE_MODE_BINCM,

2336

&pui8Data[ui32Off], ui32BCount, 1, 0);

2337

}

2338

}

2339

2340

2341

2342

2343

if (ui32BytesWritten == 0)

2344

{

2345

PDumpOSReleaseExecution();

2346

}

2347

2348

if (ui32BytesWritten != 0xFFFFFFFFU)

2349

{

2350

ui32Off += ui32BytesWritten;

2351

ui32BCount -= ui32BytesWritten;

2352

}

2353

2354

2355

}

2356

2357

2358

2359

return ui32BytesWritten;

2360

}

2361

2362

2363

2364

#else

2365

#endif

Older »