Mint in VB und Chipkartenleser (gelöst) - #154366 (Allgemeine technische Fragen)

topeg

2011-11-21 03:55

User since
2006-07-10
2611 Artikel
BenutzerIn

user image

Die einfachen Sachen sind erschöpft. Jetzt wird es kompliziert.
Etwas zu Linux dessen Gerätebehandlung vorweg.
Wenn ein Gerät von Linux gefunden wird, dann läuft eine Erkennung des Gerätes ab um den Passenden Treiber zu finden. Wurde ein passender Treiber identifiziert wird diesem der "Pfad" zum Gerät übergeben. Damit Initalisiert der Treiber das Gerät. Bis jetzt ist es vom "Userspace" aus nicht möglich auf das Gerät zuzugreifen. Dazu müssen "Devices" angelegt werden. Das geschieht meist durch ein Programm das im Hintergrund läuft. Ein Device wird einem Treiber über eine Major- und eine Minor-Nummer zugeordnet. Die Major-Nummer ist die Eindeutige Bezeichnung des Tribers im Kernel, die Minor-Nummer identifiziert das "Gerät" welches vom Treiber verwaltet wird. Ist das Device angelegt so kann ein normaler Nutzer darauf zugreifen.
Was eine Normale Datei von Devices unterscheidet sind die IO-Kommandos die man an sie senden kann. Auch kann man einen InterruptHandler für ein Device einbinden.

Es werden Zwei Device-Gruppen unterschieden Char-Devices und Block-Devices.
Char-Devies sind wie FiFo. Man kann hineinschreiben und daraus lesen, aber man kann darauf kein "seek" anwenden. Eine Serielle Schnittstelle ist ein Char-Device
Block-Devices verhalten sich wie normale Dateien. Eine Festplatte ist ein Block-Device.

Um zu sehen wo es bei dir hapert musst du schauen auf welcher Ebene der Hardwareerkennung es Probleme gibt.
Auch ich hatte mit Problemen mit USB zu kämpfen. Um etwas mehr Informationen zu bekommen hatte ich ein kleines Script geschrieben, das mir alle möglichen Informationen aus /sys zu USB zusammen trägt.

Ich habe etwas gebraucht, bis ich es wieder gefunden habe. :-/

more (105.6kb):

Code (perl): (dl )

#!/usr/bin/perl
use strict;
use warnings;
use File::Find;
use Data::Dumper;
use File::Spec;

use Data::Dumper;

########################################################################
########################################################################
{ package usb::dev;

our $base='/sys/bus/usb/devices/';

sub new
{
  my $class=shift;
  my $self={};
  $self->{id}=shift();
  $self->{path}=shift();
  bless($self,$class);
}

sub id { $_[0]->{id}; }
sub path { $base.$_[0]->{path}; }
sub childs
{
  my $self=shift;
  my @l;
  for my $path (glob($base.$self->{path}.'/*'))
  {
    next unless($path=~m#/([\d.-]+)$#);
    my $id=$1;
    $path=~s/^\Q$base\E//;
    push(@l,usb::dev->new($id,$path));
  }
  return @l;
}

sub product
{
  my $self=shift;
  open(my $fh, '<', $base.$self->{path}."/product") or return '';
  my $n=<$fh>;
  chomp($n);
  return $n;
}

sub id_product
{
  my $self=shift;
  open(my $fh, '<', $base.$self->{path}."/idProduct") or return '';
  my $n=<$fh>;
  chomp($n);
  return $n;
}

sub id_vendor
{
  my $self=shift;
  open(my $fh, '<', $base.$self->{path}."/idVendor") or return '';
  my $n=<$fh>;
  chomp($n);
  return $n;
}

sub version
{
  my $self=shift;
  open(my $fh, '<', $base.$self->{path}."/version") or return '';
  my $n=<$fh>;
  chomp($n);
  return $n;
}

sub uevent
{
  my $self=shift;
  open(my $fh, '<', $base.$self->{path}."/uevent") or return {};
  my $ret={};
  while(my $line=<$fh>)
  {
    chomp($line);
    next unless($line=~/^\s*(\w+)=(.*?)$/);
    $ret->{$1}=$2;
  }
  close($fh);
  return $ret;
}

sub interfaces
{
  my $self=shift;
  open(my $fh, '<', $base.$self->{path}."/version") or return '';
  my $n=<$fh>;
  chomp($n);
  close($fh);
  return () unless($n);

  my @ret;
  for my $id (1..$n)
  {
    my $p=$base.$self->{path}.'/'.$self->id().":$id.0";
    next unless(-d $p);
    push(@ret,usb::dev::Interface->new($p));
  }
  return @ret;
}

sub inputs
{
  my $self=shift;
  my @ret;

  my $p=$base.$self->{path}.'/input';

  if(-d $p)
  {
    for my $inp (glob($p.'/*'))
    {

      push(@ret, usb::dev::Input->new($inp));
    }
  }

  return @ret;
}

1; }

#-----------------------------------------------------------------------

{ package usb::dev::Interface;

sub new
{
  my $class=shift;
  my $self={};
  $self->{path}=shift;
  bless($self,$class);
}

sub path{ $_[0]->{path}; }


sub uevent
{
  my $self=shift;
  open(my $fh, '<', $self->{path}."/uevent") or return {};
  my $ret={};
  while(my $line=<$fh>)
  {
    chomp($line);
    next unless($line=~/^\s*(\w+)=(.*?)$/);
    $ret->{$1}=$2;
  }
  close($fh);
  return $ret;
}

sub driver
{
  my $self=shift;
  my $name=$self->uevent()->{DRIVER};
  return usb::dev::Driver->new($name) if($name);
  return undef;
}

sub inputs
{
  my $self=shift;

  my $p=$self->{path}.'/input';

  return () unless(-d $p);

  my @ret;
  for my $inp (glob($p.'/*'))
  { push(@ret, usb::dev::Input->new($inp)); }
  return @ret;
}

1; }

#-----------------------------------------------------------------------

{ package usb::dev::Input;

sub new
{
  my $class=shift;
  my $self={};
  $self->{__path}=shift;
  bless($self,$class);
  $self->_read();
  return $self;
}

sub path{ $_[0]->{__path}; }

sub id
{
  my $self=shift();
  my $name=$self->path();
  $name=~s#^.+/##;
  return $name;
}

sub name { $_[0]->{NAME} // '???'; }
sub phys { $_[0]->{PHYS} // '???'; }
sub product { $_[0]->{PRODUCT} // '???'; }

sub _read
{
  my $self=shift;
  open(my $fh, '<', $self->path()."/uevent") or return;
  while(my $line=<$fh>)
  {
    chomp($line);
    next unless($line=~/^\s*(\w+)=(.*?)$/);
    $self->{$1}=$2;
  }
  close($fh);
}

sub events
{
  my $self=shift;

  my @ret;
  for my $p (glob($self->path().'/event*'))
  {
    next unless(-d $p);
    push(@ret,usb::dev::Input::Event->new($p));
  }
  return @ret;
}

1; }

{ package usb::dev::Input::Event;

sub new
{
  my $class=shift;
  my $self={};
  $self->{__path}=shift;
  bless($self,$class);
  $self->_read();
  return $self;
}

sub path{ $_[0]->{__path}; }

sub name
{
  my $self=shift();
  my $name=$self->path();
  $name=~s#^.+/##;
  return $name;
}

sub major { $_[0]->{MAJOR} // '???'; }
sub minor { $_[0]->{MINOR} // '???'; }
sub device { '/dev/'.($_[0]->{DEVNAME} // '???'); }

sub _read
{
  my $self=shift;
  open(my $fh, '<', $self->path()."/uevent") or return;
  while(my $line=<$fh>)
  {
    chomp($line);
    next unless($line=~/^\s*(\w+)=(.*?)$/);
    $self->{$1}=$2;
  }
  close($fh);
}

1; }

#-----------------------------------------------------------------------

{ package usb::dev::Driver;

my $path='/sys/bus/usb/drivers/';

sub new
{
  my $class=shift;
  my $name=shift;

  return undef unless(-d $path.$name);

  my $driver=File::Spec->rel2abs($path.$name,readlink($path.$name.'module'));

  my $self={};
  $self->{name}=$name;
  $self->{path}=$driver;
  bless($self,$class);
}

sub name{ $_[0]->{name}; }
sub module_name
{
  my $self=shift;
  my $name=readlink($self->{path}."/module");
  $name=~s#^.+/##;
  return $name;
}

sub module
{ return sys::Module->new($_[0]->module_name()) }

1;}

#-----------------------------------------------------------------------

{ package sys::Module;

my $path='/sys/module/';

sub new
{
  my $class=shift;
  my $name=shift;

  return undef unless(-d $path.$name);

  my $self={};
  $self->{name}=$name;
  bless($self,$class);
}

sub name{ $_[0]->{name}; }

sub drivers
{
  my $self=shift;
  return map{s#^.*/##; $_}grep{!/\./}glob($path.$self->{name}.'/drivers/*');
}

sub holders
{
  my $self=shift;
  return map{s#^.*/##; $_}grep{!/\./}glob($path.$self->{name}.'/holders/*');
}

sub state
{
  my $self=shift;
  my $ret='UNKNOWN';
  open(my $fh, '<', $path.$self->{name}.'/initstate') or return $ret;
  $ret=<$fh>;
  chomp($ret);
  return $ret;
}

sub count
{
  my $self=shift;
  my $ret=-1;
  open(my $fh, '<', $path.$self->{name}.'/refcnt') or return $ret;
  $ret=<$fh>;
  chomp($ret);
  return $ret;
}

1;}
########################################################################
########################################################################

package main;

my @devices;
for my $path (glob("$usb::dev::base/usb*"))
{
  next unless($path=~/(\d+)$/);
  my $id=$1;
  push(@devices,usb::dev->new($id,"usb$id"));
}

print "ALL USB-DEVICES\n";
for(@devices)
{
  list('  ',$_);
}

########################################################################

sub list
{
  my $s=shift() // '';
  my $dev=shift;
  print_out($s,$dev);
  my @childs=$dev->childs();
  if(@childs)
  {
    print "\n".$s."CHILDS:\n";
    for(@childs)
    {
      #print_out("$s  ",$_);
      list("$s  ",$_);
      print "$s  ####################\n";
    }
  }
}

sub print_out
{
  my $s=shift;
  my $dev=shift;
  print $s."PATH    = ".$dev->path()."\n";
  print $s."ID      = ".$dev->id()."\n";
  print $s."TYP     = ".$dev->product()."\n";
  print $s."PRODUKT = ".$dev->id_vendor().":".$dev->id_product()."(".$dev->version().")"."\n";
  print $s."...\n";
  print format_hash($s,$dev->uevent());

  my @if=$dev->interfaces();
  if(@if)
  {
    print $s."INTERFACES:\n";
    for my $if(@if)
    {
      print format_interface("$s  ",$if);
      print "$s  ====================\n";
    }
  }

  my @inp=$dev->inputs();
  if(@inp)
  {
    print $s."INPUTS:\n";
    for($dev->inputs())
    {
      print format_input("$s  ",$_);
      print "$s  ====================\n";
    }
  }
}

sub format_interface
{
  my $s=shift;
  my $if=shift;

  my $ret='';

  $ret.=format_hash($s,$if->uevent());

  my $driver=$if->driver();
  if($driver)
  {
    $ret.=$s."DRIVER:\n";
    $ret.=format_driver("$s  ",$driver);
    $ret.="$s++++++++++++++++++++\n";
  }

  my @inp=$if->inputs();
  if(@inp)
  {
    $ret.=$s."INPUTS:\n";
    for my $inp (@inp)
    {
      $ret.=format_input("$s  ",$inp);
      $ret.="$s  --------------------\n";
    }
    $ret.="$s++++++++++++++++++++\n";
  }

  return $ret;
}

sub format_hash
{
  my $s=shift;
  my $hash=shift;
  my $ret='';
  my $length=0;
  for(keys(%$hash))
  { $length=length($_) if($length<length($_)); }
  for(sort keys(%$hash))
  { $ret.=__str_format($s,$_,$length)." = $hash->{$_}\n"; }
  return $ret;
}

sub format_input
{
  my $s=shift;
  my $inp=shift;
  my $ret='';

  $ret.= $s."ID      = ".$inp->id()."\n";
  $ret.= $s."NAME    = ".$inp->name()."\n";
  $ret.= $s."PHYS    = ".$inp->phys()."\n";
  $ret.= $s."PRODUCT = ".$inp->product()."\n";
  $ret.= $s."EVENTS:\n";
  for my $ev ($inp->events())
  {
    $ret.="$s  NAME   = ".$ev->name()."\n";
    $ret.="$s  MAJOR  = ".$ev->major()."\n";
    $ret.="$s  MINOR  = ".$ev->minor()."\n";
    $ret.="$s  DEVICE = ".$ev->device()."\n";
    $ret.="$s  ....................\n";
  }
  return $ret;
}

sub format_driver
{
  my $s=shift;
  my $drv=shift;
  my $ret='';

  $ret.= $s."NAME  = ".$drv->name()."\n";
  $ret.= $s."MODUL = ".$drv->module_name()."\n";
  my $modul=$drv->module();
  if($modul)
  {
    $ret.= $s."  Drivers  = ".join(', ',$modul->drivers())."\n";
    $ret.= $s."  Holders  = ".join(', ',$modul->holders())."\n";
    $ret.= $s."  RefCount = ".join(', ',$modul->count())."\n";
    $ret.= $s."  State    = ".join(', ',$modul->state())."\n";
  }
  return $ret;
}

sub __str_format
{
  my $s=shift;
  my $str=shift;
  my $len=shift;
  $str.=" "x$len;
  return $s.substr($str,0,$len);
}

Das ist ein Script welches fast alles zusammen trägt, was der Kernel über die USB-Geräte mitteilt.
Bedenke das ich das Script nur für meine persönliche Verwendung geschrieben habe. Es erklärt nichts und man manchen Stellen ist es nicht sehr ordentlich geschrieben. Ich hatte es damals in wenigen Stunden zusammen gestrickt. Also eine kleine Erklärung:

Die Ausgabe ist eine Baumstruktur. Alle an USB Angeschlossene Geräte werden in der Reihenfolge aufgeführt wie sie physikalisch aneinander hängen.

Die Ausgabe der Informationen über jedes Device ist wiederum als Baum dargestellt.
Ein USB-Device kann Interfaces oder Inputs haben
Jedes Interface hat einen Driver und eventuell Inputs
Jeder Driver hat ein Modul
Ein Input kann Events haben.
Ein Event repräsentiert ein Character Device.
(Block Devices werden etwas anders dargestellt und sind nicht aufgeführt, da ich es nicht brauchte)

Beispiel:

more (1.7kb):

Code: (dl )

PATH    = /sys/bus/usb/devices/usb1/1-1/1-1.3/1-1.3.1
ID      = 1-1.3.1
TYP     = 
PRODUKT = 046a:0011( 2.00)
...
BUSNUM  = 001
DEVICE  = /proc/bus/usb/001/009
DEVNAME = bus/usb/001/009
DEVNUM  = 009
DEVTYPE = usb_device
DRIVER  = usb
MAJOR   = 189
MINOR   = 8
PRODUCT = 46a/11/100
TYPE    = 0/0/0
INTERFACES:
  DEVICE    = /proc/bus/usb/001/009
  DEVTYPE   = usb_interface
  DRIVER    = usbhid
  INTERFACE = 3/1/1
  MODALIAS  = usb:v046Ap0011d0100dc00dsc00dp00ic03isc01ip01
  PRODUCT   = 46a/11/100
  TYPE      = 0/0/0
  DRIVER:
    NAME  = usbhid
    MODUL = usbhid
      Drivers  = hid:generic-usb, usb:usbhid
      Holders  = 
      RefCount = 0
      State    = live
   ++++++++++++++++++++
   INPUTS:
     ID      = input5
     NAME    = "HID 046a:0011"
     PHYS    = "usb-0000:00:02.1-1.3.1/input0"
     PRODUCT = 3/46a/11/111
     EVENTS:
       NAME   = event5
       MAJOR  = 13
       MINOR  = 69
       DEVICE = /dev/input/event5
       ....................
     --------------------
   ++++++++++++++++++++
   ====================

Wenn du dich durch die Ausgabe arbeitest kannst du sehen, in wie weit das Gerät in Linux eingebunden ist, welcher Treiber verwendet wird und wo welche Devices angelegt werden. Möglicherweise hilft das herauszufinden wo es Probleme gibt.