~ubuntu-branches/ubuntu/trusty/virtualbox-lts-xenial/trusty-proposed

static DECLCALLBACK(int) drvHostSerialSetParameters(PPDMICHARCONNECTOR pInterface, unsigned Bps, char chParity, unsigned cDataBits, unsigned cStopBits)

195

{

196

PDRVHOSTSERIAL pThis = PDMICHAR_2_DRVHOSTSERIAL(pInterface);

197

#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

198

struct termios *termiosSetup;

199

int baud_rate;

200

#elif defined(RT_OS_WINDOWS)

201

LPDCB comSetup;

202

#endif

203

204

LogFlow(("%s: Bps=%u chParity=%c cDataBits=%u cStopBits=%u\n", __FUNCTION__, Bps, chParity, cDataBits, cStopBits));

205

206

#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS)

207

termiosSetup = (struct termios *)RTMemTmpAllocZ(sizeof(struct termios));

208

209

/* Enable receiver */

210

termiosSetup->c_cflag |= (CLOCAL | CREAD);

211

212

switch (Bps)

213

{

214

case 50:

215

baud_rate = B50;

216

break;

217

case 75:

218

baud_rate = B75;

219

break;

220

case 110:

221

baud_rate = B110;

222

break;

223

case 134:

224

baud_rate = B134;

225

break;

226

case 150:

227

baud_rate = B150;

228

break;

229

case 200:

230

baud_rate = B200;

231

break;

232

case 300:

233

baud_rate = B300;

234

break;

235

case 600:

236

baud_rate = B600;

237

break;

238

case 1200:

239

baud_rate = B1200;

240

break;

241

case 1800:

242

baud_rate = B1800;

243

break;

244

case 2400:

245

baud_rate = B2400;

246

break;

247

case 4800:

248

baud_rate = B4800;

249

break;

250

case 9600:

251

baud_rate = B9600;

252

break;

253

case 19200:

254

baud_rate = B19200;

255

break;

256

case 38400:

257

baud_rate = B38400;

258

break;

259

case 57600:

260

baud_rate = B57600;

261

break;

262

case 115200:

263

baud_rate = B115200;

264

break;

265

default:

266

#ifdef RT_OS_LINUX

267

struct serial_struct serialStruct;

268

if (ioctl(RTFileToNative(pThis->hDeviceFile), TIOCGSERIAL, &serialStruct) != -1)

269

{

270

serialStruct.custom_divisor = serialStruct.baud_base / Bps;

271

if (!serialStruct.custom_divisor)

272

serialStruct.custom_divisor = 1;

273

serialStruct.flags &= ~ASYNC_SPD_MASK;

274

serialStruct.flags |= ASYNC_SPD_CUST;

275

ioctl(RTFileToNative(pThis->hDeviceFile), TIOCSSERIAL, &serialStruct);

276

baud_rate = B38400;

277

}

278

else

279

baud_rate = B9600;

280

#else /* !RT_OS_LINUX */

281

baud_rate = B9600;

282

#endif /* !RT_OS_LINUX */

283

}

284

285

cfsetispeed(termiosSetup, baud_rate);

286

cfsetospeed(termiosSetup, baud_rate);

287

288

switch (chParity)

289

{

290

case 'E':

291

termiosSetup->c_cflag |= PARENB;

292

break;

293

case 'O':

294

termiosSetup->c_cflag |= (PARENB | PARODD);

295

break;

296

case 'N':

297

break;

298

default:

299

break;

300

}

301

302

switch (cDataBits)

303

{

304

case 5:

305

termiosSetup->c_cflag |= CS5;

306

break;

307

case 6:

308

termiosSetup->c_cflag |= CS6;

309

break;

310

case 7:

311

termiosSetup->c_cflag |= CS7;

312

break;

313

case 8:

314

termiosSetup->c_cflag |= CS8;

315

break;

316

default:

317

break;

318

}

319

320

switch (cStopBits)

321

{

322

case 2:

323

termiosSetup->c_cflag |= CSTOPB;

324

default:

325

break;

326

}

327

328

/* set serial port to raw input */

329

330

331

tcsetattr(RTFileToNative(pThis->hDeviceFile), TCSANOW, termiosSetup);

332

RTMemTmpFree(termiosSetup);

333

334

#ifdef RT_OS_LINUX

335

336

* XXX In Linux, if a thread calls tcsetattr while the monitor thread is

337

* waiting in ioctl for a modem status change then 8250.c wrongly disables

338

* modem irqs and so the monitor thread never gets released. The workaround

339

* is to send a signal after each tcsetattr.

340

341

RTThreadPoke(pThis->pMonitorThread->Thread);

342

#endif

343

344

#elif defined(RT_OS_WINDOWS)

345

comSetup = (LPDCB)RTMemTmpAllocZ(sizeof(DCB));

346

347

comSetup->DCBlength = sizeof(DCB);

348

349

switch (Bps)

350

{

351

case 110:

352

comSetup->BaudRate = CBR_110;

353

break;

354

case 300:

355

comSetup->BaudRate = CBR_300;

356

break;

357

case 600:

358

comSetup->BaudRate = CBR_600;

359

break;

360

case 1200:

361

comSetup->BaudRate = CBR_1200;

362

break;

363

case 2400:

364

comSetup->BaudRate = CBR_2400;

365

break;

366

case 4800:

367

comSetup->BaudRate = CBR_4800;

368

break;

369

case 9600:

370

comSetup->BaudRate = CBR_9600;

371

break;

372

case 14400:

373

comSetup->BaudRate = CBR_14400;

374

break;

375

case 19200:

376

comSetup->BaudRate = CBR_19200;

377

break;

378

case 38400:

379

comSetup->BaudRate = CBR_38400;

380

break;

381

case 57600:

382

comSetup->BaudRate = CBR_57600;

383

break;

384

case 115200:

385

comSetup->BaudRate = CBR_115200;

386

break;

387

default:

388

comSetup->BaudRate = CBR_9600;

389

}

390

391

comSetup->fBinary = TRUE;

392

comSetup->fOutxCtsFlow = FALSE;

393

comSetup->fOutxDsrFlow = FALSE;

394

comSetup->fDtrControl = DTR_CONTROL_DISABLE;

395

comSetup->fDsrSensitivity = FALSE;

396

comSetup->fTXContinueOnXoff = TRUE;

397

comSetup->fOutX = FALSE;

398

comSetup->fInX = FALSE;

399

comSetup->fErrorChar = FALSE;

400

comSetup->fNull = FALSE;

401

comSetup->fRtsControl = RTS_CONTROL_DISABLE;

402

comSetup->fAbortOnError = FALSE;

403

comSetup->wReserved = 0;

404

comSetup->XonLim = 5;

405

comSetup->XoffLim = 5;

406

comSetup->ByteSize = cDataBits;

407

408

switch (chParity)

409

{

410

case 'E':

411

comSetup->Parity = EVENPARITY;

412

break;

413

case 'O':

414

comSetup->Parity = ODDPARITY;

415

break;

416

case 'N':

417

comSetup->Parity = NOPARITY;

418

break;

419

default:

420

break;

421

}

422

423

switch (cStopBits)

424

{

425

case 1:

426

comSetup->StopBits = ONESTOPBIT;

427

break;

428

case 2:

429

comSetup->StopBits = TWOSTOPBITS;

430

break;

431

default:

432

break;

433

}

434

435

comSetup->XonChar = 0;

436

comSetup->XoffChar = 0;

437

comSetup->ErrorChar = 0;

438

comSetup->EofChar = 0;

439

comSetup->EvtChar = 0;

440

441

SetCommState(pThis->hDeviceFile, comSetup);

442

RTMemTmpFree(comSetup);

443

#endif /* RT_OS_WINDOWS */

444

445

return VINF_SUCCESS;

446

}

447

448

/* -=-=-=-=- receive thread -=-=-=-=- */

449

450

/**

451

* Send thread loop.

452

453

* @returns VINF_SUCCESS.

454

* @param ThreadSelf Thread handle to this thread.

455

* @param pvUser User argument.

456

457

static DECLCALLBACK(int) drvHostSerialSendThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)

458

{

459

PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);

460

461

if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)

462

return VINF_SUCCESS;

463

464

#ifdef RT_OS_WINDOWS

465

/* Make sure that the halt event semaphore is reset. */

466

DWORD dwRet = WaitForSingleObject(pThis->hHaltEventSem, 0);

467

468

HANDLE haWait[2];

469

haWait[0] = pThis->hEventSend;

470

haWait[1] = pThis->hHaltEventSem;

471

#endif

472

473

while (pThread->enmState == PDMTHREADSTATE_RUNNING)

474

{

475

int rc = RTSemEventWait(pThis->SendSem, RT_INDEFINITE_WAIT);

476

if (RT_FAILURE(rc))

477

break;

478

479

480

* Write the character to the host device.

481

482

while (pThread->enmState == PDMTHREADSTATE_RUNNING)

483

{

484

/* copy the send queue so we get a linear buffer with the maximal size. */

485

uint8_t ch = pThis->u8SendByte;

486

#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

487

488

size_t cbWritten;

489

rc = RTFileWrite(pThis->hDeviceFile, &ch, 1, &cbWritten);

490

if (rc == VERR_TRY_AGAIN)

491

cbWritten = 0;

492

if (cbWritten < 1 && (RT_SUCCESS(rc) || rc == VERR_TRY_AGAIN))

493

{

494

/* ok, block till the device is ready for more (O_NONBLOCK) effect. */

495

rc = VINF_SUCCESS;

496

while (pThread->enmState == PDMTHREADSTATE_RUNNING)

497

{

498

/* wait */

499

fd_set WrSet;

500

FD_ZERO(&WrSet);

501

FD_SET(RTFileToNative(pThis->hDeviceFile), &WrSet);

502

fd_set XcptSet;

503

FD_ZERO(&XcptSet);

504

FD_SET(RTFileToNative(pThis->hDeviceFile), &XcptSet);

505

# ifdef DEBUG

506

uint64_t u64Now = RTTimeMilliTS();

507

# endif

508

rc = select(RTFileToNative(pThis->hDeviceFile) + 1, NULL, &WrSet, &XcptSet, NULL);

509

/** @todo check rc? */

510

511

# ifdef DEBUG

512

Log2(("select wait for %dms\n", RTTimeMilliTS() - u64Now));

513

# endif

514

/* try write more */

515

rc = RTFileWrite(pThis->hDeviceFile, &ch, 1, &cbWritten);

516

if (rc == VERR_TRY_AGAIN)

517

cbWritten = 0;

518

else if (RT_FAILURE(rc))

519

break;

520

else if (cbWritten >= 1)

521

break;

522

rc = VINF_SUCCESS;

523

} /* wait/write loop */

524

}

525

526

#elif defined(RT_OS_WINDOWS)

527

/* perform an overlapped write operation. */

528

DWORD cbWritten;

529

memset(&pThis->overlappedSend, 0, sizeof(pThis->overlappedSend));

530

pThis->overlappedSend.hEvent = pThis->hEventSend;

531

if (!WriteFile(pThis->hDeviceFile, &ch, 1, &cbWritten, &pThis->overlappedSend))

532

{

533

dwRet = GetLastError();

534

if (dwRet == ERROR_IO_PENDING)

535

{

536

537

* write blocked, wait for completion or wakeup...

538

539

dwRet = WaitForMultipleObjects(2, haWait, FALSE, INFINITE);

540

if (dwRet != WAIT_OBJECT_0)

541

{

542

AssertMsg(pThread->enmState != PDMTHREADSTATE_RUNNING, ("The halt event semaphore is set but the thread is still in running state\n"));

543

break;

544

}

545

}

546

else

547

rc = RTErrConvertFromWin32(dwRet);

548

}

549

550

#endif /* RT_OS_WINDOWS */

551

if (RT_FAILURE(rc))

552

{

553

LogRel(("HostSerial#%d: Serial Write failed with %Rrc; terminating send thread\n", pDrvIns->iInstance, rc));

554

return rc;

555

}

556

ASMAtomicXchgBool(&pThis->fSending, false);

557

break;

558

} /* write loop */

559

}

560

561

return VINF_SUCCESS;

562

}

563

564

/**

565

* Unblock the send thread so it can respond to a state change.

566

567

* @returns a VBox status code.

568

* @param pDrvIns The driver instance.

569

* @param pThread The send thread.

570

571

static DECLCALLBACK(int) drvHostSerialWakeupSendThread(PPDMDRVINS pDrvIns, PPDMTHREAD /*pThread*/)

572

{

573

PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);

574

int rc;

575

576

rc = RTSemEventSignal(pThis->SendSem);

577

if (RT_FAILURE(rc))

578

return rc;

579

580

#ifdef RT_OS_WINDOWS

581

if (!SetEvent(pThis->hHaltEventSem))

582

return RTErrConvertFromWin32(GetLastError());

583

#endif

584

585

return VINF_SUCCESS;

586

}

587

588

/* -=-=-=-=- receive thread -=-=-=-=- */

589

590

/**

591

* Receive thread loop.

592

593

* This thread pushes data from the host serial device up the driver

594

* chain toward the serial device.

595

596

* @returns VINF_SUCCESS.

597

* @param ThreadSelf Thread handle to this thread.

598

* @param pvUser User argument.

599

600

static DECLCALLBACK(int) drvHostSerialRecvThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)

601

{

602

PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);

603

uint8_t abBuffer[256];

604

uint8_t *pbBuffer = NULL;

605

size_t cbRemaining = 0; /* start by reading host data */

606

int rc = VINF_SUCCESS;

607

int rcThread = VINF_SUCCESS;

608

609

if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)

610

return VINF_SUCCESS;

611

612

#ifdef RT_OS_WINDOWS

613

/* Make sure that the halt event semaphore is reset. */

614

DWORD dwRet = WaitForSingleObject(pThis->hHaltEventSem, 0);

615

616

HANDLE ahWait[2];

617

ahWait[0] = pThis->hEventRecv;

618

ahWait[1] = pThis->hHaltEventSem;

619

#endif

620

621

while (pThread->enmState == PDMTHREADSTATE_RUNNING)

622

{

623

if (!cbRemaining)

624

{

625

/* Get a block of data from the host serial device. */

626

627

#if defined(RT_OS_DARWIN) /* poll is broken on x86 darwin, returns POLLNVAL. */

628

fd_set RdSet;

629

FD_ZERO(&RdSet);

630

FD_SET(RTFileToNative(pThis->hDeviceFileR), &RdSet);

631

FD_SET(RTPipeToNative(pThis->hWakeupPipeR), &RdSet);

632

fd_set XcptSet;

633

FD_ZERO(&XcptSet);

634

FD_SET(RTFileToNative(pThis->hDeviceFile), &XcptSet);

635

FD_SET(RTPipeToNative(pThis->hWakeupPipeR), &XcptSet);

636

# if 1 /* it seems like this select is blocking the write... */

637

rc = select(RT_MAX(RTPipeToNative(pThis->hWakeupPipeR), RTFileToNative(pThis->hDeviceFileR)) + 1,

638

&RdSet, NULL, &XcptSet, NULL);

639

# else

640

struct timeval tv = { 0, 1000 };

641

rc = select(RTPipeToNative(pThis->hWakeupPipeR), RTFileToNative(pThis->hDeviceFileR) + 1,

642

&RdSet, NULL, &XcptSet, &tv);

643

# endif

644

if (rc == -1)

645

{

646

int err = errno;

647

rcThread = RTErrConvertFromErrno(err);

648

LogRel(("HostSerial#%d: select failed with errno=%d / %Rrc, terminating the worker thread.\n", pDrvIns->iInstance, err, rcThread));

649

break;

650

}

651

652

/* this might have changed in the meantime */

653

if (pThread->enmState != PDMTHREADSTATE_RUNNING)

654

break;

655

if (rc == 0)

656

continue;

657

658

/* drain the wakeup pipe */

659

size_t cbRead;

660

if ( FD_ISSET(RTPipeToNative(pThis->hWakeupPipeR), &RdSet)

661

|| FD_ISSET(RTPipeToNative(pThis->hWakeupPipeR), &XcptSet))

662

{

663

rc = RTPipeRead(pThis->hWakeupPipeR, abBuffer, 1, &cbRead);

664

if (RT_FAILURE(rc))

665

{

666

LogRel(("HostSerial#%d: draining the wakeup pipe failed with %Rrc, terminating the worker thread.\n", pDrvIns->iInstance, rc));

667

rcThread = rc;

668

break;

669

}

670

continue;

671

}

672

673

/* read data from the serial port. */

674

rc = RTFileRead(pThis->hDeviceFileR, abBuffer, sizeof(abBuffer), &cbRead);

675

if (RT_FAILURE(rc))

676

{

677

LogRel(("HostSerial#%d: (1) Read failed with %Rrc, terminating the worker thread.\n", pDrvIns->iInstance, rc));

678

rcThread = rc;

679

break;

680

}

681

cbRemaining = cbRead;

682

683

#elif defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

684

685

size_t cbRead;

686

struct pollfd aFDs[2];

687

aFDs[0].fd = RTFileToNative(pThis->hDeviceFile);

688

aFDs[0].events = POLLIN;

689

aFDs[0].revents = 0;

690

aFDs[1].fd = RTPipeToNative(pThis->hWakeupPipeR);

691

aFDs[1].events = POLLIN | POLLERR | POLLHUP;

692

aFDs[1].revents = 0;

693

rc = poll(aFDs, RT_ELEMENTS(aFDs), -1);

694

if (rc < 0)

695

{

696

int err = errno;

697

if (err == EINTR)

698

{

699

700

* EINTR errors should be harmless, even if they are not supposed to occur in our setup.

701

702

Log(("rc=%d revents=%#x,%#x errno=%p %s\n", rc, aFDs[0].revents, aFDs[1].revents, err, strerror(err)));

703

RTThreadYield();

704

continue;

705

}

706

707

rcThread = RTErrConvertFromErrno(err);

708

LogRel(("HostSerial#%d: poll failed with errno=%d / %Rrc, terminating the worker thread.\n", pDrvIns->iInstance, err, rcThread));

709

break;

710

}

711

/* this might have changed in the meantime */

712

if (pThread->enmState != PDMTHREADSTATE_RUNNING)

713

break;

714

if (rc > 0 && aFDs[1].revents)

715

{

716

if (aFDs[1].revents & (POLLHUP | POLLERR | POLLNVAL))

717

break;

718

/* notification to terminate -- drain the pipe */

719

RTPipeRead(pThis->hWakeupPipeR, &abBuffer, 1, &cbRead);

720

continue;

721

}

722

rc = RTFileRead(pThis->hDeviceFile, abBuffer, sizeof(abBuffer), &cbRead);

723

if (RT_FAILURE(rc))

724

{

725

/* don't terminate worker thread when data unavailable */

726

if (rc == VERR_TRY_AGAIN)

727

continue;

728

729

LogRel(("HostSerial#%d: (2) Read failed with %Rrc, terminating the worker thread.\n", pDrvIns->iInstance, rc));

730

rcThread = rc;

731

break;

732

}

733

cbRemaining = cbRead;

734

735

#elif defined(RT_OS_WINDOWS)

736

737

DWORD dwEventMask = 0;

738

DWORD dwNumberOfBytesTransferred;

739

740

memset(&pThis->overlappedRecv, 0, sizeof(pThis->overlappedRecv));

741

pThis->overlappedRecv.hEvent = pThis->hEventRecv;

742

743

if (!WaitCommEvent(pThis->hDeviceFile, &dwEventMask, &pThis->overlappedRecv))

744

{

745

dwRet = GetLastError();

746

if (dwRet == ERROR_IO_PENDING)

747

{

748

dwRet = WaitForMultipleObjects(2, ahWait, FALSE, INFINITE);

749

if (dwRet != WAIT_OBJECT_0)

750

{

751

/* notification to terminate */

752

AssertMsg(pThread->enmState != PDMTHREADSTATE_RUNNING, ("The halt event semaphore is set but the thread is still in running state\n"));

753

break;

754

}

755

}

756

else

757

{

758

rcThread = RTErrConvertFromWin32(dwRet);

759

LogRel(("HostSerial#%d: Wait failed with error %Rrc; terminating the worker thread.\n", pDrvIns->iInstance, rcThread));

760

break;

761

}

762

}

763

/* this might have changed in the meantime */

764

if (pThread->enmState != PDMTHREADSTATE_RUNNING)

765

break;

766

767

/* Check the event */

768

if (dwEventMask & EV_RXCHAR)

769

{

770

if (!ReadFile(pThis->hDeviceFile, abBuffer, sizeof(abBuffer), &dwNumberOfBytesTransferred, &pThis->overlappedRecv))

771

{

772

rcThread = RTErrConvertFromWin32(GetLastError());

773

LogRel(("HostSerial#%d: Read failed with error %Rrc; terminating the worker thread.\n", pDrvIns->iInstance, rcThread));

774

break;

775

}

776

cbRemaining = dwNumberOfBytesTransferred;

777

}

778

else if (dwEventMask & EV_BREAK)

779

{

780

Log(("HostSerial#%d: Detected break\n"));

781

rc = pThis->pDrvCharPort->pfnNotifyBreak(pThis->pDrvCharPort);

782

}

783

else

784

{

785

/* The status lines have changed. Notify the device. */

786

DWORD dwNewStatusLinesState = 0;

787

uint32_t uNewStatusLinesState = 0;

788

789

/* Get the new state */

790

if (GetCommModemStatus(pThis->hDeviceFile, &dwNewStatusLinesState))

791

{

792

if (dwNewStatusLinesState & MS_RLSD_ON)

793

uNewStatusLinesState |= PDMICHARPORT_STATUS_LINES_DCD;

794

if (dwNewStatusLinesState & MS_RING_ON)

795

uNewStatusLinesState |= PDMICHARPORT_STATUS_LINES_RI;

796

if (dwNewStatusLinesState & MS_DSR_ON)

797

uNewStatusLinesState |= PDMICHARPORT_STATUS_LINES_DSR;

798

if (dwNewStatusLinesState & MS_CTS_ON)

799

uNewStatusLinesState |= PDMICHARPORT_STATUS_LINES_CTS;

800

rc = pThis->pDrvCharPort->pfnNotifyStatusLinesChanged(pThis->pDrvCharPort, uNewStatusLinesState);

801

if (RT_FAILURE(rc))

802

{

803

/* Notifying device failed, continue but log it */

804

LogRel(("HostSerial#%d: Notifying device failed with error %Rrc; continuing.\n", pDrvIns->iInstance, rc));

805

}

806

}

807

else

808

{

809

/* Getting new state failed, continue but log it */

810

LogRel(("HostSerial#%d: Getting status lines state failed with error %Rrc; continuing.\n", pDrvIns->iInstance, RTErrConvertFromWin32(GetLastError())));

811

}

812

}

813

#endif

814

815

Log(("Read %d bytes.\n", cbRemaining));

816

pbBuffer = abBuffer;

817

}

818

else

819

{

820

/* Send data to the guest. */

821

size_t cbProcessed = cbRemaining;

822

rc = pThis->pDrvCharPort->pfnNotifyRead(pThis->pDrvCharPort, pbBuffer, &cbProcessed);

823

if (RT_SUCCESS(rc))

824

{

825

Assert(cbProcessed); Assert(cbProcessed <= cbRemaining);

826

pbBuffer += cbProcessed;

827

cbRemaining -= cbProcessed;

828

STAM_COUNTER_ADD(&pThis->StatBytesRead, cbProcessed);

829

}

830

else if (rc == VERR_TIMEOUT)

831

{

832

/* Normal case, just means that the guest didn't accept a new

833

* character before the timeout elapsed. Just retry. */

834

rc = VINF_SUCCESS;

835

}

836

else

837

{

838

LogRel(("HostSerial#%d: NotifyRead failed with %Rrc, terminating the worker thread.\n", pDrvIns->iInstance, rc));

839

rcThread = rc;

840

break;

841

}

842

}

843

}

844

845

return rcThread;

846

}

847

848

/**

849

* Unblock the send thread so it can respond to a state change.

850

851

* @returns a VBox status code.

852

* @param pDrvIns The driver instance.

853

* @param pThread The send thread.

854

855

static DECLCALLBACK(int) drvHostSerialWakeupRecvThread(PPDMDRVINS pDrvIns, PPDMTHREAD /*pThread*/)

856

{

857

PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);

858

#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

859

size_t cbIgnored;

860

return RTPipeWrite(pThis->hWakeupPipeW, "", 1, &cbIgnored);

861

862

#elif defined(RT_OS_WINDOWS)

863

if (!SetEvent(pThis->hHaltEventSem))

864

return RTErrConvertFromWin32(GetLastError());

865

return VINF_SUCCESS;

866

#else

867

# error adapt me!

868

#endif

869

}

870

871

#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

872

/* -=-=-=-=- Monitor thread -=-=-=-=- */

873

874

/**

875

* Monitor thread loop.

876

877

* This thread monitors the status lines and notifies the device

878

* if they change.

879

880

* @returns VINF_SUCCESS.

881

* @param ThreadSelf Thread handle to this thread.

882

* @param pvUser User argument.

883

884

static DECLCALLBACK(int) drvHostSerialMonitorThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)

885

{

886

PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);

887

int rc = VINF_SUCCESS;

888

unsigned long const uStatusLinesToCheck = TIOCM_CAR | TIOCM_RNG | TIOCM_DSR | TIOCM_CTS;

889

890

if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)

891

return VINF_SUCCESS;

892

893

894

{

895

unsigned int statusLines;

896

897

898

* Get the status line state.

899

900

rc = ioctl(RTFileToNative(pThis->hDeviceFile), TIOCMGET, &statusLines);

901

if (rc < 0)

902

{

903

PDMDrvHlpVMSetRuntimeError(pDrvIns, 0 /*fFlags*/, "DrvHostSerialFail",

904

N_("Ioctl failed for serial host device '%s' (%Rrc). The device will not work properly"),

905

pThis->pszDevicePath, RTErrConvertFromErrno(errno));

906

break;

907

}

908

909

uint32_t newStatusLine = 0;

910

911

if (statusLines & TIOCM_CAR)

912

newStatusLine |= PDMICHARPORT_STATUS_LINES_DCD;

913

if (statusLines & TIOCM_RNG)

914

newStatusLine |= PDMICHARPORT_STATUS_LINES_RI;

915

if (statusLines & TIOCM_DSR)

916

newStatusLine |= PDMICHARPORT_STATUS_LINES_DSR;

917

if (statusLines & TIOCM_CTS)

918

newStatusLine |= PDMICHARPORT_STATUS_LINES_CTS;

919

pThis->pDrvCharPort->pfnNotifyStatusLinesChanged(pThis->pDrvCharPort, newStatusLine);

920

921

if (PDMTHREADSTATE_RUNNING != pThread->enmState)

922

break;

923

924

# ifdef RT_OS_LINUX

925

926

* Wait for status line change.

927

928

* XXX In Linux, if a thread calls tcsetattr while the monitor thread is

929

* waiting in ioctl for a modem status change then 8250.c wrongly disables

930

* modem irqs and so the monitor thread never gets released. The workaround

931

* is to send a signal after each tcsetattr.

932

933

ioctl(RTFileToNative(pThis->hDeviceFile), TIOCMIWAIT, uStatusLinesToCheck);

934

# else

935

/* Poll for status line change. */

936

if (!((statusLines ^ pThis->fStatusLines) & uStatusLinesToCheck))

937

PDMR3ThreadSleep(pThread, 500); /* 0.5 sec */

938

pThis->fStatusLines = statusLines;

939

# endif

940

}

941

while (PDMTHREADSTATE_RUNNING == pThread->enmState);

942

943

return VINF_SUCCESS;

944

}

945

946

/**

947

* Unblock the monitor thread so it can respond to a state change.

948

* We need to execute this code exactly once during initialization.

949

* But we don't want to block --- therefore this dedicated thread.

950

951

* @returns a VBox status code.

952

* @param pDrvIns The driver instance.

953

* @param pThread The send thread.

954

955

static DECLCALLBACK(int) drvHostSerialWakeupMonitorThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)

956

{

957

# ifdef RT_OS_LINUX

958

PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);

959

int rc = VINF_SUCCESS;

960

961

rc = RTThreadPoke(pThread->Thread);

962

if (RT_FAILURE(rc))

963

PDMDrvHlpVMSetRuntimeError(pDrvIns, 0 /*fFlags*/, "DrvHostSerialFail",

964

N_("Suspending serial monitor thread failed for serial device '%s' (%Rrc). The shutdown may take longer than expected"),

965

pThis->pszDevicePath, RTErrConvertFromErrno(rc));

966

967

# else /* !RT_OS_LINUX*/

968

969

/* In polling mode there is nobody to wake up (PDMThread will cancel the sleep). */

970

NOREF(pDrvIns);

971

NOREF(pThread);

972

973

# endif /* RT_OS_LINUX */

974

975

return VINF_SUCCESS;

976

}

977

#endif /* RT_OS_LINUX || RT_OS_DARWIN || RT_OS_SOLARIS */

978

979

/**

980

* Set the modem lines.

981

982

* @returns VBox status code

983

* @param pInterface Pointer to the interface structure.

984

* @param RequestToSend Set to true if this control line should be made active.

985

* @param DataTerminalReady Set to true if this control line should be made active.

986

987

static DECLCALLBACK(int) drvHostSerialSetModemLines(PPDMICHARCONNECTOR pInterface, bool RequestToSend, bool DataTerminalReady)

988

{

989

PDRVHOSTSERIAL pThis = PDMICHAR_2_DRVHOSTSERIAL(pInterface);

990

991

#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

992

int modemStateSet = 0;

993

int modemStateClear = 0;

994

995

if (RequestToSend)

996

modemStateSet |= TIOCM_RTS;

997

else

998

modemStateClear |= TIOCM_RTS;

999

1000

if (DataTerminalReady)

1001

modemStateSet |= TIOCM_DTR;

1002

else

1003

modemStateClear |= TIOCM_DTR;

1004

1005

if (modemStateSet)

1006

ioctl(RTFileToNative(pThis->hDeviceFile), TIOCMBIS, &modemStateSet);

1007

1008

if (modemStateClear)

1009

ioctl(RTFileToNative(pThis->hDeviceFile), TIOCMBIC, &modemStateClear);

1010

1011

#elif defined(RT_OS_WINDOWS)

1012

if (RequestToSend)

1013

EscapeCommFunction(pThis->hDeviceFile, SETRTS);

1014

else

1015

EscapeCommFunction(pThis->hDeviceFile, CLRRTS);

1016

1017

if (DataTerminalReady)

1018

EscapeCommFunction(pThis->hDeviceFile, SETDTR);

1019

else

1020

EscapeCommFunction(pThis->hDeviceFile, CLRDTR);

1021

1022

#endif

1023

1024

return VINF_SUCCESS;

1025

}

1026

1027

/**

1028

* Sets the TD line into break condition.

1029

1030

* @returns VBox status code.

1031

* @param pInterface Pointer to the interface structure containing the called function pointer.

1032

* @param fBreak Set to true to let the device send a break false to put into normal operation.

1033

* @thread Any thread.

1034

1035

static DECLCALLBACK(int) drvHostSerialSetBreak(PPDMICHARCONNECTOR pInterface, bool fBreak)

1036

{

1037

PDRVHOSTSERIAL pThis = PDMICHAR_2_DRVHOSTSERIAL(pInterface);

1038

1039

#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

1040

if (fBreak)

1041

ioctl(RTFileToNative(pThis->hDeviceFile), TIOCSBRK);

1042

else

1043

ioctl(RTFileToNative(pThis->hDeviceFile), TIOCCBRK);

1044

1045

#elif defined(RT_OS_WINDOWS)

1046

if (fBreak)

1047

SetCommBreak(pThis->hDeviceFile);

1048

else

1049

ClearCommBreak(pThis->hDeviceFile);

1050

#endif

1051

1052

return VINF_SUCCESS;

1053

}

1054

1055

/* -=-=-=-=- driver interface -=-=-=-=- */

1056

1057

/**

1058

* Destruct a char driver instance.

1059

1060

* Most VM resources are freed by the VM. This callback is provided so that

1061

* any non-VM resources can be freed correctly.

1062

1063

* @param pDrvIns The driver instance data.

1064

1065

static DECLCALLBACK(void) drvHostSerialDestruct(PPDMDRVINS pDrvIns)

1066

{

1067

PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);

1068

LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));

1069

PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);

1070

1071

/* Empty the send queue */

1072

if (pThis->SendSem != NIL_RTSEMEVENT)

1073

{

1074

RTSemEventDestroy(pThis->SendSem);

1075

pThis->SendSem = NIL_RTSEMEVENT;

1076

}

1077

1078

#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

1079

1080

int rc = RTPipeClose(pThis->hWakeupPipeW); AssertRC(rc);

1081

pThis->hWakeupPipeW = NIL_RTPIPE;

1082

rc = RTPipeClose(pThis->hWakeupPipeR); AssertRC(rc);

1083

pThis->hWakeupPipeR = NIL_RTPIPE;

1084

1085

# if defined(RT_OS_DARWIN)

1086

if (pThis->hDeviceFileR != NIL_RTFILE)

1087

{

1088

if (pThis->hDeviceFileR != pThis->hDeviceFile)

1089

{

1090

rc = RTFileClose(pThis->hDeviceFileR);

1091

AssertRC(rc);

1092

}

1093

pThis->hDeviceFileR = NIL_RTFILE;

1094

}

1095

# endif

1096

if (pThis->hDeviceFile != NIL_RTFILE)

1097

{

1098

rc = RTFileClose(pThis->hDeviceFile); AssertRC(rc);

1099

pThis->hDeviceFile = NIL_RTFILE;

1100

}

1101

1102

#elif defined(RT_OS_WINDOWS)

1103

CloseHandle(pThis->hEventRecv);

1104

CloseHandle(pThis->hEventSend);

1105

CancelIo(pThis->hDeviceFile);

1106

CloseHandle(pThis->hDeviceFile);

1107

1108

#endif

1109

1110

if (pThis->pszDevicePath)

1111

{

1112

MMR3HeapFree(pThis->pszDevicePath);

1113

pThis->pszDevicePath = NULL;

1114

}

1115

}

1116

1117

/**

1118

* Construct a char driver instance.

1119

1120

* @copydoc FNPDMDRVCONSTRUCT

1121

1122

static DECLCALLBACK(int) drvHostSerialConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t /*fFlags*/)

1123

{

1124

PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);

1125

LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));

1126

PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);

1127

1128

1129

* Init basic data members and interfaces.

1130

1131

#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

1132

pThis->hDeviceFile = NIL_RTFILE;

1133

# ifdef RT_OS_DARWIN

1134

pThis->hDeviceFileR = NIL_RTFILE;

1135

# endif

1136

pThis->hWakeupPipeR = NIL_RTPIPE;

1137

pThis->hWakeupPipeW = NIL_RTPIPE;

1138

#elif defined(RT_OS_WINDOWS)

1139

pThis->hEventRecv = INVALID_HANDLE_VALUE;

1140

pThis->hEventSend = INVALID_HANDLE_VALUE;

1141

pThis->hDeviceFile = INVALID_HANDLE_VALUE;

1142

#endif

1143

pThis->SendSem = NIL_RTSEMEVENT;

1144

/* IBase. */

1145

pDrvIns->IBase.pfnQueryInterface = drvHostSerialQueryInterface;

1146

/* ICharConnector. */

1147

pThis->ICharConnector.pfnWrite = drvHostSerialWrite;

1148

pThis->ICharConnector.pfnSetParameters = drvHostSerialSetParameters;

1149

pThis->ICharConnector.pfnSetModemLines = drvHostSerialSetModemLines;

1150

pThis->ICharConnector.pfnSetBreak = drvHostSerialSetBreak;

1151

1152

1153

* Query configuration.

1154

1155

/* Device */

1156

int rc = CFGMR3QueryStringAlloc(pCfg, "DevicePath", &pThis->pszDevicePath);

1157

if (RT_FAILURE(rc))

1158

{

1159

AssertMsgFailed(("Configuration error: query for \"DevicePath\" string returned %Rra.\n", rc));

1160

return rc;

1161

}

1162

1163

1164

* Open the device

1165

1166

#ifdef RT_OS_WINDOWS

1167

1168

pThis->hHaltEventSem = CreateEvent(NULL, FALSE, FALSE, NULL);

1169

AssertReturn(pThis->hHaltEventSem != NULL, VERR_NO_MEMORY);

1170

1171

pThis->hEventRecv = CreateEvent(NULL, FALSE, FALSE, NULL);

1172

AssertReturn(pThis->hEventRecv != NULL, VERR_NO_MEMORY);

1173

1174

pThis->hEventSend = CreateEvent(NULL, FALSE, FALSE, NULL);

1175

AssertReturn(pThis->hEventSend != NULL, VERR_NO_MEMORY);

1176

1177

HANDLE hFile = CreateFile(pThis->pszDevicePath,

1178

GENERIC_READ | GENERIC_WRITE,

1179

0, // must be opened with exclusive access

1180

NULL, // no SECURITY_ATTRIBUTES structure

1181

OPEN_EXISTING, // must use OPEN_EXISTING

1182

FILE_FLAG_OVERLAPPED, // overlapped I/O

1183

NULL); // no template file

1184

if (hFile == INVALID_HANDLE_VALUE)

1185

rc = RTErrConvertFromWin32(GetLastError());

1186

else

1187

{

1188

pThis->hDeviceFile = hFile;

1189

/* for overlapped read */

1190

if (!SetCommMask(hFile, EV_RXCHAR | EV_CTS | EV_DSR | EV_RING | EV_RLSD))

1191

{

1192

LogRel(("HostSerial#%d: SetCommMask failed with error %d.\n", pDrvIns->iInstance, GetLastError()));

1193

return VERR_FILE_IO_ERROR;

1194

}

1195

rc = VINF_SUCCESS;

1196

}

1197

1198

#else /* !RT_OS_WINDOWS */

1199

1200

uint32_t fOpen = RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE;

1201

# ifdef RT_OS_LINUX

1202

/* This seems to be necessary on some Linux hosts, otherwise we hang here forever. */

1203

fOpen |= RTFILE_O_NON_BLOCK;

1204

# endif

1205

rc = RTFileOpen(&pThis->hDeviceFile, pThis->pszDevicePath, fOpen);

1206

# ifdef RT_OS_LINUX

1207

/* RTFILE_O_NON_BLOCK not supported? */

1208

if (rc == VERR_INVALID_PARAMETER)

1209

rc = RTFileOpen(&pThis->hDeviceFile, pThis->pszDevicePath, fOpen & ~RTFILE_O_NON_BLOCK);

1210

# endif

1211

# ifdef RT_OS_DARWIN

1212

if (RT_SUCCESS(rc))

1213

rc = RTFileOpen(&pThis->hDeviceFileR, pThis->pszDevicePath, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);

1214

# endif

1215

1216

1217

#endif /* !RT_OS_WINDOWS */

1218

1219

if (RT_FAILURE(rc))

1220

{

1221

AssertMsgFailed(("Could not open host device %s, rc=%Rrc\n", pThis->pszDevicePath, rc));

1222

switch (rc)

1223

{

1224

case VERR_ACCESS_DENIED:

1225

return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,

1226

#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

1227

N_("Cannot open host device '%s' for read/write access. Check the permissions "

1228

"of that device ('/bin/ls -l %s'): Most probably you need to be member "

1229

"of the device group. Make sure that you logout/login after changing "

1230

"the group settings of the current user"),

1231

#else

1232

N_("Cannot open host device '%s' for read/write access. Check the permissions "

1233

"of that device"),

1234

#endif

1235

pThis->pszDevicePath, pThis->pszDevicePath);

1236

default:

1237

return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,

1238

N_("Failed to open host device '%s'"),

1239

pThis->pszDevicePath);

1240

}

1241

}

1242

1243

/* Set to non blocking I/O */

1244

#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

1245

1246

fcntl(RTFileToNative(pThis->hDeviceFile), F_SETFL, O_NONBLOCK);

1247

# ifdef RT_OS_DARWIN

1248

fcntl(RTFileToNative(pThis->hDeviceFileR), F_SETFL, O_NONBLOCK);

1249

# endif

1250

rc = RTPipeCreate(&pThis->hWakeupPipeR, &pThis->hWakeupPipeW, 0 /*fFlags*/);

1251

AssertRCReturn(rc, rc);

1252

1253

#elif defined(RT_OS_WINDOWS)

1254

1255

/* Set the COMMTIMEOUTS to get non blocking I/O */

1256

COMMTIMEOUTS comTimeout;

1257

1258

comTimeout.ReadIntervalTimeout = MAXDWORD;

1259

comTimeout.ReadTotalTimeoutMultiplier = 0;

1260

comTimeout.ReadTotalTimeoutConstant = 0;

1261

comTimeout.WriteTotalTimeoutMultiplier = 0;

1262

comTimeout.WriteTotalTimeoutConstant = 0;

1263

1264

SetCommTimeouts(pThis->hDeviceFile, &comTimeout);

1265

1266

#endif

1267

1268

1269

* Get the ICharPort interface of the above driver/device.

1270

1271

pThis->pDrvCharPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMICHARPORT);

1272

if (!pThis->pDrvCharPort)

1273

return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE, RT_SRC_POS, N_("HostSerial#%d has no char port interface above"), pDrvIns->iInstance);

1274

1275

1276

* Create the receive, send and monitor threads plus the related send semaphore.

1277

1278

rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pRecvThread, pThis, drvHostSerialRecvThread, drvHostSerialWakeupRecvThread, 0, RTTHREADTYPE_IO, "SerRecv");

1279

if (RT_FAILURE(rc))

1280

return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostSerial#%d cannot create receive thread"), pDrvIns->iInstance);

1281

1282

rc = RTSemEventCreate(&pThis->SendSem);

1283

AssertRC(rc);

1284

1285

rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pSendThread, pThis, drvHostSerialSendThread, drvHostSerialWakeupSendThread, 0, RTTHREADTYPE_IO, "SerSend");

1286

if (RT_FAILURE(rc))

1287

return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostSerial#%d cannot create send thread"), pDrvIns->iInstance);

1288

1289

#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)

1290

/* Linux & darwin needs a separate thread which monitors the status lines. */

1291

# ifndef RT_OS_LINUX

1292

ioctl(RTFileToNative(pThis->hDeviceFile), TIOCMGET, &pThis->fStatusLines);

1293

# endif

1294

rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pMonitorThread, pThis, drvHostSerialMonitorThread, drvHostSerialWakeupMonitorThread, 0, RTTHREADTYPE_IO, "SerMon");

1295

if (RT_FAILURE(rc))

1296

return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostSerial#%d cannot create monitor thread"), pDrvIns->iInstance);

1297

#endif

1298

1299

1300

* Register release statistics.

1301

1302

PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesWritten, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes written", "/Devices/HostSerial%d/Written", pDrvIns->iInstance);

1303

PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesRead, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes read", "/Devices/HostSerial%d/Read", pDrvIns->iInstance);

1304

#ifdef RT_OS_DARWIN /* new Write code, not darwin specific. */

1305

PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatSendOverflows, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes overflowed", "/Devices/HostSerial%d/SendOverflow", pDrvIns->iInstance);

1306

#endif

1307

1308

return VINF_SUCCESS;

1309

}

1310

1311

/**

1312

* Char driver registration record.

1313

1314

const PDMDRVREG g_DrvHostSerial =

1315

{

1316

/* u32Version */

1317

PDM_DRVREG_VERSION,

1318

/* szName */

1319

"Host Serial",

1320

/* szRCMod */

1321

"",

1322

/* szR0Mod */

1323

"",

1324

/* pszDescription */

1325

"Host serial driver.",

1326

/* fFlags */

1327

PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,

1328

/* fClass. */

1329

PDM_DRVREG_CLASS_CHAR,

1330

/* cMaxInstances */

1331

~0U,

1332

/* cbInstance */

1333

sizeof(DRVHOSTSERIAL),

1334

/* pfnConstruct */

1335

drvHostSerialConstruct,

1336

/* pfnDestruct */

1337

drvHostSerialDestruct,

1338

/* pfnRelocate */

1339

NULL,

1340

/* pfnIOCtl */

1341

NULL,

1342

/* pfnPowerOn */

1343

NULL,

1344

/* pfnReset */

1345

NULL,

1346

/* pfnSuspend */

1347

NULL,

1348

/* pfnResume */

1349

NULL,

1350

/* pfnAttach */

1351

NULL,

1352

/* pfnDetach */

1353

NULL,

1354

/* pfnPowerOff */

1355

NULL,

1356

/* pfnSoftReset */

1357

NULL,

1358

/* u32EndVersion */

1359

PDM_DRVREG_VERSION

1360

};

1361

Older »