summaryrefslogtreecommitdiff
Unidiff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--libopie2/opiecore/device/odevice_zaurus.cpp17
1 files changed, 14 insertions, 3 deletions
diff --git a/libopie2/opiecore/device/odevice_zaurus.cpp b/libopie2/opiecore/device/odevice_zaurus.cpp
index 7302d2c..b7f3104 100644
--- a/libopie2/opiecore/device/odevice_zaurus.cpp
+++ b/libopie2/opiecore/device/odevice_zaurus.cpp
@@ -425,276 +425,287 @@ bool Zaurus::setLedState( OLed which, OLedState st )
425{ 425{
426 // Currently not supported on non_embedix kernels 426 // Currently not supported on non_embedix kernels
427 if (!m_embedix) 427 if (!m_embedix)
428 { 428 {
429 qDebug( "Zaurus::setLedState: ODevice handling for non-embedix kernels not yet implemented" ); 429 qDebug( "Zaurus::setLedState: ODevice handling for non-embedix kernels not yet implemented" );
430 return false; 430 return false;
431 } 431 }
432 432
433 static int fd = ::open ( "/dev/sharp_led", O_RDWR|O_NONBLOCK ); 433 static int fd = ::open ( "/dev/sharp_led", O_RDWR|O_NONBLOCK );
434 434
435 if ( which == Led_Mail ) { 435 if ( which == Led_Mail ) {
436 if ( fd >= 0 ) { 436 if ( fd >= 0 ) {
437 struct sharp_led_status leds; 437 struct sharp_led_status leds;
438 ::memset ( &leds, 0, sizeof( leds )); 438 ::memset ( &leds, 0, sizeof( leds ));
439 leds. which = SHARP_LED_MAIL_EXISTS; 439 leds. which = SHARP_LED_MAIL_EXISTS;
440 bool ok = true; 440 bool ok = true;
441 441
442 switch ( st ) { 442 switch ( st ) {
443 case Led_Off : leds. status = LED_MAIL_NO_UNREAD_MAIL; break; 443 case Led_Off : leds. status = LED_MAIL_NO_UNREAD_MAIL; break;
444 case Led_On : leds. status = LED_MAIL_NEWMAIL_EXISTS; break; 444 case Led_On : leds. status = LED_MAIL_NEWMAIL_EXISTS; break;
445 case Led_BlinkSlow: leds. status = LED_MAIL_UNREAD_MAIL_EX; break; 445 case Led_BlinkSlow: leds. status = LED_MAIL_UNREAD_MAIL_EX; break;
446 default : ok = false; 446 default : ok = false;
447 } 447 }
448 448
449 if ( ok && ( ::ioctl ( fd, SHARP_LED_SETSTATUS, &leds ) >= 0 )) { 449 if ( ok && ( ::ioctl ( fd, SHARP_LED_SETSTATUS, &leds ) >= 0 )) {
450 m_leds [0] = st; 450 m_leds [0] = st;
451 return true; 451 return true;
452 } 452 }
453 } 453 }
454 } 454 }
455 return false; 455 return false;
456} 456}
457 457
458int Zaurus::displayBrightnessResolution() const 458int Zaurus::displayBrightnessResolution() const
459{ 459{
460 int res = 1; 460 int res = 1;
461 if (m_embedix) 461 if (m_embedix)
462 { 462 {
463 int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_RDWR|O_NONBLOCK ); 463 int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_RDWR|O_NONBLOCK );
464 if ( fd ) 464 if ( fd )
465 { 465 {
466 int value = ::ioctl( fd, SHARP_FL_IOCTL_GET_STEP, 0 ); 466 int value = ::ioctl( fd, SHARP_FL_IOCTL_GET_STEP, 0 );
467 ::close( fd ); 467 ::close( fd );
468 return value ? value : res; 468 return value ? value : res;
469 } 469 }
470 } 470 }
471 else 471 else
472 { 472 {
473 int fd = ::open( m_backlightdev + "max_brightness", O_RDONLY|O_NONBLOCK ); 473 int fd = ::open( m_backlightdev + "max_brightness", O_RDONLY|O_NONBLOCK );
474 if ( fd ) 474 if ( fd )
475 { 475 {
476 char buf[100]; 476 char buf[100];
477 if ( ::read( fd, &buf[0], sizeof buf ) ) ::sscanf( &buf[0], "%d", &res ); 477 if ( ::read( fd, &buf[0], sizeof buf ) ) ::sscanf( &buf[0], "%d", &res );
478 ::close( fd ); 478 ::close( fd );
479 } 479 }
480 } 480 }
481 return res; 481 return res;
482} 482}
483 483
484bool Zaurus::setDisplayBrightness( int bright ) 484bool Zaurus::setDisplayBrightness( int bright )
485{ 485{
486 //qDebug( "Zaurus::setDisplayBrightness( %d )", bright ); 486 //qDebug( "Zaurus::setDisplayBrightness( %d )", bright );
487 bool res = false; 487 bool res = false;
488 488
489 if ( bright > 255 ) bright = 255; 489 if ( bright > 255 ) bright = 255;
490 if ( bright < 0 ) bright = 0; 490 if ( bright < 0 ) bright = 0;
491 491
492 int numberOfSteps = displayBrightnessResolution(); 492 int numberOfSteps = displayBrightnessResolution();
493 int val = ( bright == 1 ) ? 1 : ( bright * numberOfSteps ) / 255; 493 int val = ( bright == 1 ) ? 1 : ( bright * numberOfSteps ) / 255;
494 494
495 if ( m_embedix ) 495 if ( m_embedix )
496 { 496 {
497 int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_WRONLY|O_NONBLOCK ); 497 int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_WRONLY|O_NONBLOCK );
498 if ( fd ) 498 if ( fd )
499 { 499 {
500 res = ( ::ioctl( fd, SHARP_FL_IOCTL_STEP_CONTRAST, val ) == 0 ); 500 res = ( ::ioctl( fd, SHARP_FL_IOCTL_STEP_CONTRAST, val ) == 0 );
501 ::close( fd ); 501 ::close( fd );
502 } 502 }
503 } 503 }
504 else 504 else
505 { 505 {
506 int fd = ::open( m_backlightdev + "brightness", O_WRONLY|O_NONBLOCK ); 506 int fd = ::open( m_backlightdev + "brightness", O_WRONLY|O_NONBLOCK );
507 if ( fd ) 507 if ( fd )
508 { 508 {
509 char buf[100]; 509 char buf[100];
510 int len = ::snprintf( &buf[0], sizeof buf, "%d", val ); 510 int len = ::snprintf( &buf[0], sizeof buf, "%d", val );
511 res = ( ::write( fd, &buf[0], len ) == 0 ); 511 res = ( ::write( fd, &buf[0], len ) == 0 );
512 ::close( fd ); 512 ::close( fd );
513 } 513 }
514 } 514 }
515 return res; 515 return res;
516} 516}
517 517
518bool Zaurus::setDisplayStatus( bool on ) 518bool Zaurus::setDisplayStatus( bool on )
519{ 519{
520 bool res = false; 520 bool res = false;
521 if ( m_embedix ) 521 if ( m_embedix )
522 { 522 {
523 int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_WRONLY|O_NONBLOCK ); 523 int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_WRONLY|O_NONBLOCK );
524 if ( fd ) 524 if ( fd )
525 { 525 {
526 int ioctlnum = on ? SHARP_FL_IOCTL_ON : SHARP_FL_IOCTL_OFF; 526 int ioctlnum = on ? SHARP_FL_IOCTL_ON : SHARP_FL_IOCTL_OFF;
527 res = ( ::ioctl ( fd, ioctlnum, 0 ) == 0 ); 527 res = ( ::ioctl ( fd, ioctlnum, 0 ) == 0 );
528 ::close ( fd ); 528 ::close ( fd );
529 } 529 }
530 } 530 }
531 else 531 else
532 { 532 {
533 int fd = ::open( m_backlightdev + "power", O_WRONLY|O_NONBLOCK ); 533 int fd = ::open( m_backlightdev + "power", O_WRONLY|O_NONBLOCK );
534 if ( fd ) 534 if ( fd )
535 { 535 {
536 char buf[10]; 536 char buf[10];
537 buf[0] = on ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN; 537 buf[0] = on ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
538 buf[1] = '\0'; 538 buf[1] = '\0';
539 res = ( ::write( fd, &buf[0], 2 ) == 0 ); 539 res = ( ::write( fd, &buf[0], 2 ) == 0 );
540 ::close( fd ); 540 ::close( fd );
541 } 541 }
542 } 542 }
543 return res; 543 return res;
544} 544}
545 545
546Transformation Zaurus::rotation() const 546Transformation Zaurus::rotation() const
547{ 547{
548 qDebug( "Zaurus::rotation()" ); 548 qDebug( "Zaurus::rotation()" );
549 Transformation rot; 549 Transformation rot;
550 550
551 switch ( d->m_model ) { 551 switch ( d->m_model ) {
552 case Model_Zaurus_SLC3000: // fallthrough 552 case Model_Zaurus_SLC3000: // fallthrough
553 case Model_Zaurus_SLC1000: // fallthrough 553 case Model_Zaurus_SLC1000:
554 {
555 OHingeStatus hs = readHingeSensor();
556 qDebug( "Zaurus::rotation() - hinge sensor = %d", (int) hs );
557 if ( hs == CASE_PORTRAIT ) rot = Rot0;
558 else if ( hs == CASE_UNKNOWN ) rot = Rot270;
559 else rot = Rot270;
560 }
561 break;
562
563 // SLC7x0 needs a special case here, because we were able to set the W100
564 // hardware default rotation on kernel 2.6 to Rot0
554 case Model_Zaurus_SLC7x0: 565 case Model_Zaurus_SLC7x0:
555 { 566 {
556 OHingeStatus hs = readHingeSensor(); 567 OHingeStatus hs = readHingeSensor();
557 qDebug( "Zaurus::rotation() - hinge sensor = %d", (int) hs ); 568 qDebug( "Zaurus::rotation() - hinge sensor = %d", (int) hs );
558 569
559 if ( m_embedix ) 570 if ( m_embedix )
560 { 571 {
561 if ( hs == CASE_PORTRAIT ) rot = Rot0; 572 if ( hs == CASE_PORTRAIT ) rot = Rot0;
562 else if ( hs == CASE_UNKNOWN ) rot = Rot0; 573 else if ( hs == CASE_UNKNOWN ) rot = Rot270;
563 else rot = Rot270; 574 else rot = Rot270;
564 } 575 }
565 else 576 else
566 { 577 {
567 if ( hs == CASE_PORTRAIT ) rot = Rot90; 578 if ( hs == CASE_PORTRAIT ) rot = Rot90;
568 else if ( hs == CASE_UNKNOWN ) rot = Rot0; 579 else if ( hs == CASE_UNKNOWN ) rot = Rot0;
569 else rot = Rot0; 580 else rot = Rot0;
570 } 581 }
571 } 582 }
572 break; 583 break;
573 case Model_Zaurus_SL6000: 584 case Model_Zaurus_SL6000:
574 case Model_Zaurus_SLB600: 585 case Model_Zaurus_SLB600:
575 case Model_Zaurus_SLA300: 586 case Model_Zaurus_SLA300:
576 case Model_Zaurus_SL5500: 587 case Model_Zaurus_SL5500:
577 case Model_Zaurus_SL5000: 588 case Model_Zaurus_SL5000:
578 default: 589 default:
579 rot = d->m_rotation; 590 rot = d->m_rotation;
580 break; 591 break;
581 } 592 }
582 593
583 return rot; 594 return rot;
584} 595}
585ODirection Zaurus::direction() const 596ODirection Zaurus::direction() const
586{ 597{
587 ODirection dir; 598 ODirection dir;
588 599
589 switch ( d->m_model ) { 600 switch ( d->m_model ) {
590 case Model_Zaurus_SLC3000: // fallthrough 601 case Model_Zaurus_SLC3000: // fallthrough
591 case Model_Zaurus_SLC1000: // fallthrough 602 case Model_Zaurus_SLC1000: // fallthrough
592 case Model_Zaurus_SLC7x0: { 603 case Model_Zaurus_SLC7x0: {
593 OHingeStatus hs = readHingeSensor(); 604 OHingeStatus hs = readHingeSensor();
594 if ( hs == CASE_PORTRAIT ) dir = CCW; 605 if ( hs == CASE_PORTRAIT ) dir = CCW;
595 else if ( hs == CASE_UNKNOWN ) dir = CCW; 606 else if ( hs == CASE_UNKNOWN ) dir = CCW;
596 else dir = CW; 607 else dir = CW;
597 } 608 }
598 break; 609 break;
599 case Model_Zaurus_SL6000: 610 case Model_Zaurus_SL6000:
600 case Model_Zaurus_SLA300: 611 case Model_Zaurus_SLA300:
601 case Model_Zaurus_SLB600: 612 case Model_Zaurus_SLB600:
602 case Model_Zaurus_SL5500: 613 case Model_Zaurus_SL5500:
603 case Model_Zaurus_SL5000: 614 case Model_Zaurus_SL5000:
604 default: dir = d->m_direction; 615 default: dir = d->m_direction;
605 break; 616 break;
606 } 617 }
607 return dir; 618 return dir;
608 619
609} 620}
610 621
611bool Zaurus::hasHingeSensor() const 622bool Zaurus::hasHingeSensor() const
612{ 623{
613 return d->m_model == Model_Zaurus_SLC7x0 || d->m_model == Model_Zaurus_SLC3000 || d->m_model == Model_Zaurus_SLC1000; 624 return d->m_model == Model_Zaurus_SLC7x0 || d->m_model == Model_Zaurus_SLC3000 || d->m_model == Model_Zaurus_SLC1000;
614} 625}
615 626
616OHingeStatus Zaurus::readHingeSensor() const 627OHingeStatus Zaurus::readHingeSensor() const
617{ 628{
618 if (m_embedix) 629 if (m_embedix)
619 { 630 {
620 int handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK); 631 int handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK);
621 if (handle == -1) 632 if (handle == -1)
622 { 633 {
623 qWarning("Zaurus::readHingeSensor() - failed (%s)", "unknown reason" ); //FIXME: use strerror 634 qWarning("Zaurus::readHingeSensor() - failed (%s)", "unknown reason" ); //FIXME: use strerror
624 return CASE_UNKNOWN; 635 return CASE_UNKNOWN;
625 } 636 }
626 else 637 else
627 { 638 {
628 int retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION); 639 int retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION);
629 ::close (handle); 640 ::close (handle);
630 if ( retval == CASE_CLOSED || retval == CASE_PORTRAIT || retval == CASE_LANDSCAPE ) 641 if ( retval == CASE_CLOSED || retval == CASE_PORTRAIT || retval == CASE_LANDSCAPE )
631 { 642 {
632 qDebug( "Zaurus::readHingeSensor() - result = %d", retval ); 643 qDebug( "Zaurus::readHingeSensor() - result = %d", retval );
633 return static_cast<OHingeStatus>( retval ); 644 return static_cast<OHingeStatus>( retval );
634 } 645 }
635 else 646 else
636 { 647 {
637 qWarning("Zaurus::readHingeSensor() - couldn't compute hinge status!" ); 648 qWarning("Zaurus::readHingeSensor() - couldn't compute hinge status!" );
638 return CASE_UNKNOWN; 649 return CASE_UNKNOWN;
639 } 650 }
640 } 651 }
641 } 652 }
642 else 653 else
643 { 654 {
644 // corgi keyboard is event source 0 in OZ kernel 2.6 655 // corgi keyboard is event source 0 in OZ kernel 2.6
645 OInputDevice* keyboard = OInputSystem::instance()->device( "event0" ); 656 OInputDevice* keyboard = OInputSystem::instance()->device( "event0" );
646 if ( keyboard && keyboard->isHeld( OInputDevice::Key_KP0 ) ) return CASE_LANDSCAPE; 657 if ( keyboard && keyboard->isHeld( OInputDevice::Key_KP0 ) ) return CASE_LANDSCAPE;
647 else if ( keyboard && keyboard->isHeld( OInputDevice::Key_KP1 ) ) return CASE_PORTRAIT; 658 else if ( keyboard && keyboard->isHeld( OInputDevice::Key_KP1 ) ) return CASE_PORTRAIT;
648 else if ( keyboard && keyboard->isHeld( OInputDevice::Key_KP2 ) ) return CASE_CLOSED; 659 else if ( keyboard && keyboard->isHeld( OInputDevice::Key_KP2 ) ) return CASE_CLOSED;
649 qWarning("Zaurus::readHingeSensor() - couldn't compute hinge status!" ); 660 qWarning("Zaurus::readHingeSensor() - couldn't compute hinge status!" );
650 return CASE_UNKNOWN; 661 return CASE_UNKNOWN;
651 } 662 }
652} 663}
653 664
654/* 665/*
655 * Take code from iPAQ device. 666 * Take code from iPAQ device.
656 * That way we switch the cursor directions depending on status of hinge sensor, eg. hardware direction. 667 * That way we switch the cursor directions depending on status of hinge sensor, eg. hardware direction.
657 * I hope that is ok - Alwin 668 * I hope that is ok - Alwin
658 */ 669 */
659bool Zaurus::filter ( int /*unicode*/, int keycode, int modifiers, bool isPress, bool autoRepeat ) 670bool Zaurus::filter ( int /*unicode*/, int keycode, int modifiers, bool isPress, bool autoRepeat )
660{ 671{
661 int newkeycode = keycode; 672 int newkeycode = keycode;
662 673
663 if (d->m_model != Model_Zaurus_SLC7x0 && d->m_model != Model_Zaurus_SLC3000 && d->m_model != Model_Zaurus_SLC1000) return false; 674 if (d->m_model != Model_Zaurus_SLC7x0 && d->m_model != Model_Zaurus_SLC3000 && d->m_model != Model_Zaurus_SLC1000) return false;
664 675
665 /* map cursor keys depending on the hinge status */ 676 /* map cursor keys depending on the hinge status */
666 switch ( keycode ) { 677 switch ( keycode ) {
667 // Rotate cursor keys 678 // Rotate cursor keys
668 case Key_Left : 679 case Key_Left :
669 case Key_Right: 680 case Key_Right:
670 case Key_Up : 681 case Key_Up :
671 case Key_Down : 682 case Key_Down :
672 { 683 {
673 if (rotation()==Rot90) { 684 if (rotation()==Rot90) {
674 newkeycode = Key_Left + ( keycode - Key_Left + 3 ) % 4; 685 newkeycode = Key_Left + ( keycode - Key_Left + 3 ) % 4;
675 } 686 }
676 } 687 }
677 break; 688 break;
678 689
679 } 690 }
680 if (newkeycode!=keycode) { 691 if (newkeycode!=keycode) {
681 if ( newkeycode != Key_unknown ) { 692 if ( newkeycode != Key_unknown ) {
682 QWSServer::sendKeyEvent ( -1, newkeycode, modifiers, isPress, autoRepeat ); 693 QWSServer::sendKeyEvent ( -1, newkeycode, modifiers, isPress, autoRepeat );
683 } 694 }
684 return true; 695 return true;
685 } 696 }
686 return false; 697 return false;
687} 698}
688 699
689bool Zaurus::suspend() { 700bool Zaurus::suspend() {
690 if ( !isQWS( ) ) // only qwsserver is allowed to suspend 701 if ( !isQWS( ) ) // only qwsserver is allowed to suspend
691 return false; 702 return false;
692 703
693 bool res = false; 704 bool res = false;
694 QCopEnvelope( "QPE/System", "aboutToSuspend()" ); 705 QCopEnvelope( "QPE/System", "aboutToSuspend()" );
695 706
696 struct timeval tvs, tvn; 707 struct timeval tvs, tvn;
697 ::gettimeofday ( &tvs, 0 ); 708 ::gettimeofday ( &tvs, 0 );
698 709
699 ::sync(); // flush fs caches 710 ::sync(); // flush fs caches
700 res = ( ::system ( "apm --suspend" ) == 0 ); 711 res = ( ::system ( "apm --suspend" ) == 0 );