path: root/perl-install/detect_devices.pm

package detect_devices; # $Id$

use diagnostics;
use strict;
use vars qw($pcitable_addons $usbtable_addons);

#-######################################################################################
#- misc imports
#-######################################################################################
use log;
use common;
use devices;
use run_program;
use c;

#-#####################################################################################
#- Globals
#-#####################################################################################
my @netdevices = map { my $l = $_; map { "$l$_" } (0..3) } qw(eth tr fddi plip);
my %serialprobe;

#-######################################################################################
#- Functions
#-######################################################################################
sub dev_is_devfs() { -e "/dev/.devfsd" } #- no $::prefix, returns false during install and that's nice :)


sub get() {
    #- Detect the default BIOS boot harddrive is kind of tricky. We may have IDE,
    #- SCSI and RAID devices on the same machine. From what I see so far, the default
    #- BIOS boot harddrive will be
    #- 1. The first IDE device if IDE exists. Or
    #- 2. The first SCSI device if SCSI exists. Or
    #- 3. The first RAID device if RAID exists.

    getIDE(), getSCSI(), getDAC960(), getCompaqSmartArray(), getATARAID();
}
sub hds()         { grep { $_->{media_type} eq 'hd' && !isRemovableDrive($_) } get() }
sub tapes()       { grep { $_->{media_type} eq 'tape' } get() }
sub cdroms()      { grep { $_->{media_type} eq 'cdrom' } get() }
sub burners()     { grep { isBurner($_) } cdroms() }
sub dvdroms()     { grep { isDvdDrive($_) } cdroms() }
sub raw_zips()    { grep { member($_->{media_type}, 'fd', 'hd') && isZipDrive($_) } get() }
#-sub jazzs     { grep { member($_->{media_type}, 'fd', 'hd') && isJazzDrive($_) } get() }
sub ls120s()      { grep { member($_->{media_type}, 'fd', 'hd') && isLS120Drive($_) } get() }
sub zips()        {
    map { 
	$_->{device} .= 4; 
	$_->{devfs_device} = $_->{devfs_prefix} . '/part4'; 
	$_;
    } raw_zips();
}

sub cdroms__faking_ide_scsi() { grep { $_->{media_type} eq 'cdrom' } cdroms_and_zips__faking_ide_scsi() }
sub cdroms_and_zips__faking_ide_scsi() {
    my @l = grep { $_->{media_type} eq 'cdrom' || member($_->{media_type}, 'fd', 'hd') && isZipDrive($_) } get();

    if (my @l_need_fake = grep { !$::isStandalone && $_->{bus} eq 'ide' && !($_->{media_type} eq 'cdrom' && !isBurner($_)) } @l) {
	require modules;
	modules::add_probeall('scsi_hostadapter', 'ide-scsi');

	my $nb_cdrom = 1 + max(-1, map { $_->{device} =~ /scd(\d+)/ } @l);
	my $nb_zip = 1 + max(-1, map { if_($_->{device} =~ /sd(\w+)/, ord($1) - ord('a')) } getSCSI());
	my $scsi_hostadapters = modules::get_probeall('scsi_hostadapter');
	my $devfs_host = find_index { $_ eq 'ide-scsi' } @$scsi_hostadapters;
	my $devfs_id = 0;

	foreach my $e (@l_need_fake) {
	    $e->{devfs_prefix} = sprintf('scsi/host%d/bus0/target%d/lun0', $devfs_host, $devfs_id++);
	    my $faked;
	    if ($e->{media_type} eq 'cdrom') {
		$faked = "scd" . $nb_cdrom++;
		log::l("IDEBurner: $e->{device} => $faked and $e->{devfs_prefix}");
	    } else {
		$faked = "sd" . chr(ord('a') + $nb_zip++);
		log::l("IDE Zip: $e->{device} => $faked and $e->{devfs_prefix}");
	    }
	    $e->{device} = $faked;
	}
	get_devfs_devices(@l_need_fake);
    }
    foreach (@l) {
	$_->{device} .= 4 if $_->{media_type} ne 'cdrom';
	$_->{devfs_device} = $_->{devfs_prefix} . '/' . ($_->{media_type} eq 'cdrom' ? 'cd' : 'part4');
    }
    @l;
}

sub floppies() {
    require modules;
    eval { modules::load("floppy") };
    my @fds = $@ ? () : map {
	my $info = (!dev_is_devfs() || -e "/dev/fd$_") && c::floppy_info(devices::make("fd$_"));
	if_($info && $info ne '(null)', { device => "fd$_", devfs_device => "floppy/$_", media_type => 'fd', info => $info })
    } qw(0 1);

    my @ide = ls120s() and eval { modules::load("ide-floppy") };

    eval { modules::load("usb-storage") } if usbStorage();
    my @scsi = grep { $_->{media_type} eq 'fd' } getSCSI();
    @ide, @scsi, @fds;
}
sub floppies_dev() { map { $_->{device} } floppies() }
sub floppy() { first(floppies_dev()) }
#- example ls120, model = "LS-120 SLIM 02 UHD Floppy"

sub removables() {
    floppies(), cdroms_and_zips__faking_ide_scsi();
}

sub get_sys_cdrom_info {
    my (@drives) = @_;

    my @drives_order;
    foreach (cat_("/proc/sys/dev/cdrom/info")) {
	my ($t, $l) = split ':';
	my @l;
	@l = split(' ', $l) if $l;
	if ($t eq 'drive name') {
	    @drives_order = map {
		s/^sr/scd/;
		my $dev = $_;
		find { $_->{device} eq $dev } @drives;
	    } @l;
	} else {
	    my $capacity;
	    if ($t eq 'Can write CD-R') {
		$capacity = 'burner';
	    } elsif ($t eq 'Can read DVD') {
		$capacity = 'DVD';
	    }
	    if ($capacity) {
		each_index {
		    ($drives_order[$::i] || {})->{capacity} .= "$capacity " if $_;
		} @l;
	    }
	}
    }
}

sub get_usb_storage_info {
    my (@l) = @_;

    my %usbs = map {
	my $s = cat_(glob_("$_/*"));
	my ($host) = $s =~ /^\s*Host scsi(\d+):/m; #-#
	my ($vendor_name) = $s =~ /^\s*Vendor: (.*)/m;
	my ($vendor, $id) = $s =~ /^\s*GUID: (....)(....)/m;
	if_(defined $host, $host => { vendor_name => $vendor_name, usb_vendor => hex $vendor, usb_id => hex $id });
    } glob_('/proc/scsi/usb-storage-*') or return;

    #- only the entries matching the following conditions can be usb-storage devices
    @l = grep { $_->{channel} == 0 && $_->{id} == 0 && $_->{lun} == 0 } @l;
    my %l; push @{$l{$_->{host}}}, $_ foreach @l;

    my @informed;
    foreach my $host (keys %usbs) {
	my @choices = @{$l{$host} || []} or log::l("weird, host$host from /proc/scsi/usb-storage-*/* is not in /proc/scsi/scsi"), next;
	if (@choices > 1) {
	    @choices = grep { $_->{info} =~ /^\Q$usbs{$host}{vendor_name}/ } @choices;
	    @choices or log::l("weird, can't find the good entry host$host from /proc/scsi/usb-storage-*/* in /proc/scsi/scsi"), next;
	    @choices == 1 or log::l("argh, can't determine the good entry host$host from /proc/scsi/usb-storage-*/* in /proc/scsi/scsi"), next
	}
	add2hash($choices[0], $usbs{$host});
	push @informed, $choices[0];
    }
    @informed or return;

    foreach my $usb (usb_probe()) {
	if (my $e = find { $_->{usb_vendor} == $usb->{vendor} && $_->{usb_id} == $usb->{id} } @informed) {
	    $e->{"usb_$_"} = $usb->{$_} foreach keys %$usb;
	}
    }
}

sub get_devfs_devices {
    my (@l) = @_;

    my %h = (cdrom => 'cd', hd => 'disc');

    foreach (@l) {
	my $t = $h{$_->{media_type}} or next;
	$_->{devfs_device} = $_->{devfs_prefix} . '/' . $t;
    }
}

sub isBurner { 
    my ($e) = @_;
    $e->{capacity} =~ /burner/ and return 1;
      
    #- do not work for SCSI
    my $f = tryOpen($e->{device}); #- SCSI burner are not detected this way.
    $f && c::isBurner(fileno($f));
}
sub isDvdDrive {
    my ($e) = @_;
    $e->{capacity} =~ /DVD/ || $e->{info} =~ /DVD/ and return 1;

    #- do not work for SCSI
    my $f = tryOpen($e->{device});
    $f && c::isDvdDrive(fileno($f));
}
sub isZipDrive { $_[0]{info} =~ /ZIP\s+\d+/ } #- accept ZIP 100, untested for bigger ZIP drive.
sub isJazzDrive { $_[0]{info} =~ /\bJAZZ?\b/i } #- accept "iomega jaz 1GB"
sub isLS120Drive { $_[0]{info} =~ /LS-?120|144MB/ }
sub isRemovableUsb { $_[0]{usb_media_type} && index($_[0]{usb_media_type}, 'Mass Storage|') == 0 && usb2removable($_[0]) }
sub isFloppyUsb { $_[0]{usb_driver} && $_[0]{usb_driver} eq 'Removable:floppy' }
sub isRemovableDrive { 
    my ($e) = @_;
    isZipDrive($e) || isLS120Drive($e) || $e->{media_type} && $e->{media_type} eq 'fd' || isRemovableUsb($e) || $e->{usb_media_type} && index($e->{usb_media_type}, 'Mass Storage|Floppy (UFI)') == 0;
}

sub getSCSI() {
    my $err = sub { log::l("ERROR: unexpected line in /proc/scsi/scsi: $_[0]") };

    my ($first, @l) = common::join_lines(cat_("/proc/scsi/scsi")) or return;
    $first =~ /^Attached devices:/ or $err->($first);

    @l = map_index {
	my ($host, $channel, $id, $lun) = m/^Host: scsi(\d+) Channel: (\d+) Id: (\d+) Lun: (\d+)/ or $err->($_);
	my ($vendor, $model) = /^\s*Vendor:\s*(.*?)\s+Model:\s*(.*?)\s+Rev:/m or $err->($_);
	my ($type) = /^\s*Type:\s*(.*)/m or $err->($_);
	{ info => "$vendor $model", host => $host, channel => $channel, id => $id, lun => $lun, 
	  device => "sg$::i", devfs_prefix => sprintf('scsi/host%d/bus%d/target%d/lun%d', $host, $channel, $id, $lun),
          raw_type => $type, bus => 'SCSI' };
    } @l;

    get_usb_storage_info(@l);

    each_index {
	my $dev = "sd" . chr($::i + ord('a'));
	put_in_hash $_, { device => $dev, media_type => isFloppyUsb($_) ? 'fd' : 'hd' };
    } grep { $_->{raw_type} =~ /Direct-Access|Optical Device/ } @l;

    each_index {
	put_in_hash $_, { device => "st$::i", media_type => 'tape' };
    } grep { $_->{raw_type} =~ /Sequential-Access/ } @l;

    each_index {
	put_in_hash $_, { device => "scd$::i", media_type => 'cdrom' };
    } grep { $_->{raw_type} =~ /CD-ROM|WORM/ } @l;

    # Old hp scanners report themselves as "Processor"s
    # (see linux/include/scsi/scsi.h and sans-find-scanner.1)
    each_index {
	put_in_hash $_, { media_type => 'scanner' };
    } grep { $_->{raw_type} =~ /Scanner/ || $_->{raw_type} =~ /Processor / } @l;

    get_devfs_devices(@l);
    get_sys_cdrom_info(@l);
    @l;
}

my %eide_hds = (
    "ASUS" => "Asus",
    "CD-ROM CDU" => "Sony",
    "CD-ROM Drive/F5D" => "ASUSTeK",
    "Compaq" => "Compaq",
    "CONNER" => "Conner Peripherals",
    "IBM" => "IBM",
    "FUJITSU" => "Fujitsu",
    "HITACHI" => "Hitachi",
    "Lite-On" => "Lite-On Technology Corp.",
    "LTN" => "Lite-On Technology Corp.",
    "IOMEGA" => "Iomega",
    "MAXTOR" => "Maxtor",
    "Maxtor" => "Maxtor",
    "Micropolis" => "Micropolis",
    "Pioneer" => "Pioneer",
    "PLEXTOR" => "Plextor",
    "QUANTUM" => "Quantum", 
    "SAMSUNG" => "Samsung",
    "Seagate " => "Seagate Technology",
    "ST3" => "Seagate Technology",
    "TEAC" => "Teac",
    "TOSHIBA" => "Toshiba",
    "WDC" => "Western Digital Corp.",
);


sub getIDE() {
    my @idi;

    #- what about a system with absolutely no IDE on it, like some sparc machine.
    -e "/proc/ide" or return ();

    #- Great. 2.2 kernel, things are much easier and less error prone.
    foreach my $d (sort @{[glob_('/proc/ide/hd*')]}) {
	cat_("$d/driver") =~ /ide-scsi/ and next; #- already appears in /proc/scsi/scsi
	my $t = chomp_(cat_("$d/media"));
	my $type = ${{ disk => 'hd', cdrom => 'cdrom', tape => 'tape', floppy => 'fd' }}{$t} or next;
	my $info = chomp_(cat_("$d/model")) || "(none)";

	my $num = ord(($d =~ /(.)$/)[0]) - ord 'a';
	my ($vendor, $model) = map { 
	    if_($info =~ /^$_(-|\s)*(.*)/, $eide_hds{$_}, $2);
	} keys %eide_hds;

	my ($channel, $id) = ($num / 2, $num % 2);
	my $devfs_prefix = sprintf('ide/host0/bus%d/target%d/lun0', $channel, $id);

	push @idi, { media_type => $type, device => basename($d), 
		     devfs_prefix => $devfs_prefix,
		     info => $info, channel => $channel, id => $id, bus => 'ide', 
		     if_($vendor, Vendor => $vendor), if_($model, Model => $model) };
    }
    get_devfs_devices(@idi);
    get_sys_cdrom_info(@idi);
    @idi;
}

sub getCompaqSmartArray() {
    my (@idi, $f);

    foreach ('array/ida', 'cpqarray/ida', 'cciss/cciss') {
	my $prefix = "/proc/driver/$_"; #- kernel 2.4 places it here
	$prefix = "/proc/$_" if !-e "${prefix}0"; #- kernel 2.2

	my ($name) = m|/(.*)|;
	for (my $i = 0; -r ($f = "${prefix}$i"); $i++) {
	    foreach (cat_($f)) {
		if (my ($device) = m|^\s*($name/.*?):|) {
		    push @idi, { device => $device, prefix => $device . 'p', info => "Compaq RAID logical disk",
				 media_type => 'hd', bus => 'ida' };
		}
	    }
	}
    }
    @idi;
}

sub getDAC960() {
    my %idi;

    #- We are looking for lines of this format:DAC960#0:
    #- /dev/rd/c0d0: RAID-7, Online, 17928192 blocks, Write Thru0123456790123456789012
    foreach (syslog()) {
	my ($device, $info) = m|/dev/(rd/.*?): (.*?),| or next;
	$idi{$device} = { info => $info, media_type => 'hd', device => $device, prefix => $device . 'p', bus => 'dac960' };
    }
    values %idi;
}

sub getATARAID() {
    my %l;
    foreach (syslog()) {
	my ($device) = m|^\s*(ataraid/d\d+):| or next;
	$l{$device} = { info => 'ATARAID block device', media_type => 'hd', device => $device, prefix => $device . 'p', bus => 'ataraid' };
	log::l("ATARAID: $device");
    }
    values %l;
}


# cpu_name : arch() =~ /^alpha/ ? "cpu	" :
# arch() =~ /^ppc/ ? "processor" : "vendor_id"

# cpu_model : arch() =~ /^alpha/ ? "cpu model" :
# arch() =~ /^ppc/ ? "cpu  " : "model name"

# cpu_freq = arch() =~ /^alpha/ ? "cycle frequency [Hz]" :
# arch() =~ /^ppc/ ? "clock" : "cpu MHz"

sub getCPUs() { 
    my (@cpus, $cpu);
    foreach (cat_("/proc/cpuinfo")) {
	   if (/^processor/) { # ix86 specific
		  push @cpus, $cpu if $cpu;
		  $cpu = {};
	   }
	   $cpu->{$1} = $2 if /^([^\t]+).*:\s(.*)$/;
    }
    push @cpus, $cpu;
    @cpus;
}

sub getSoundDevices() {
    (arch() =~ /ppc/ ? \&modules::load_category : \&modules::probe_category)->('multimedia/sound');
}

sub isTVcard { $_[0]{driver} =~ /bttv|saa7134/ }

sub getTVcards() { 
    grep { isTVcard($_) } detect_devices::probeall();
}

sub getSerialModem {
    my ($modem, $o_mouse) = @_;
    my $mouse = $o_mouse || {};
    $mouse->{device} = readlink "/dev/mouse";
    my $serdev = arch() =~ /ppc/ ? "macserial" : "serial";
    eval { modules::load($serdev) };

    probeSerialDevices();
    foreach ('modem', map { "ttyS$_" } (0..7)) {
	next if $mouse->{device} =~ /$_/;
	next unless -e "/dev/$_";
	hasModem("/dev/$_") and $modem->{device} = $_, last;
    }

    #- add an alias for macserial on PPC
    modules::add_alias('serial', $serdev) if arch() =~ /ppc/ && $modem->{device};
    my @devs = pcmcia_probe();
    foreach (@devs) { $_->{type} =~ /serial/ and $modem->{device} = $_->{device} }
    $modem;
}

sub getModem() {
    my @pci_modems = grep { $_->{driver} =~ /www.linmodems.org/ } probeall();
    getSerialModem({}), @pci_modems;
}

sub getSpeedtouch() {
    grep { $_->{description} eq 'Alcatel|USB ADSL Modem (Speed Touch)' } probeall();
}
sub getSagem() {
    grep { $_->{description} eq 'Analog Devices Inc.|USB ADSL modem' } probeall();
}

sub getNet() {
    grep { !(($::isStandalone || $::live) && /plip/) && c::hasNetDevice($_) } @netdevices;
}

#sub getISDN() {
#    mapgrep(sub {member (($_[0] =~ /\s*(\w*):/), @netdevices), $1 }, split(/\n/, cat_("/proc/net/dev")));
#}

$pcitable_addons = <<'EOF';
# add here lines conforming the pcitable format (0xXXXX\t0xXXXX\t"\w+"\t".*")
EOF

$usbtable_addons = <<'EOF';
# add here lines conforming the usbtable format (0xXXXX\t0xXXXX\t"\w+"\t".*")
EOF

sub install_addons {
    my ($prefix) = @_;

    #- this test means install_addons can only be called after ldetect-lst has been installed.
    if (-d "$prefix/usr/share/ldetect-lst") {
	my $update = 0;
	foreach ([ 'pcitable.d', $pcitable_addons ], [ 'usbtable.d', $usbtable_addons ]) {
	    my ($dir, $str) = @$_;
	    -d "$prefix/usr/share/ldetect-lst/$dir" && $str =~ /^[^#]/m and $update = 1 and
	      output "$prefix/usr/share/ldetect-lst/$dir/95drakx.lst", $str;
	}
	$update and run_program::rooted($prefix, "/usr/sbin/update-ldetect-lst");
    }
}

sub add_addons {
    my ($addons, @l) = @_;

    foreach (split "\n", $addons) {
	/^\s/ and die "bad detect_devices::probeall_addons line \"$_\"";
	s/^#.*//;
	s/"(.*?)"/$1/g;
	next if /^$/;
	my ($vendor, $id, $driver, $description) = split("\t", $_, 4) or die "bad detect_devices::probeall_addons line \"$_\"";
	foreach (@l) {
	    $_->{vendor} == hex $vendor && $_->{id} == hex $id or next;
	    put_in_hash($_, { driver => $driver, description => $description });
	}
    }
    @l;
}

sub pci_probe() {
    add_addons($pcitable_addons, map {
	my %l;
	@l{qw(vendor id subvendor subid pci_bus pci_device pci_function media_type driver description)} = split "\t";
	$l{$_} = hex $l{$_} foreach qw(vendor id subvendor subid);
	$l{bus} = 'PCI';
	\%l
    } c::pci_probe());
}

sub usb_probe() {
    -e "/proc/bus/usb/devices" or return;

    add_addons($usbtable_addons, map {
	my %l;
	@l{qw(vendor id media_type driver description pci_bus pci_device)} = split "\t";
	$l{$_} = hex $l{$_} foreach qw(vendor id);
	$l{bus} = 'USB';
	\%l
    } c::usb_probe());
}

sub firewire_probe() {
    my ($e, @l);
    foreach (cat_('/proc/bus/ieee1394/devices')) {
	if (m!Vendor/Model ID: (.*) \[(\w+)\] / (.*) \[(\w+)\]!) {
	    push @l, $e = { 
			   vendor => hex($2), id => hex($4), 
			   description => join('|', $1, $3),
			   bus => 'Firewire',
			  };
	} elsif (/Software Specifier ID: (\w+)/) {
	    $e->{specifier_id} = hex $1;
	} elsif (/Software Version: (\w+)/) {
	    $e->{specifier_version} = hex $1;	    
	}
    }
    foreach (@l) {
	if ($e->{specifier_id} == 0x00609e && $e->{specifier_version} == 0x010483) {
	    add2hash($_, { driver => 'sbp2', description => "Generic Firewire Storage Controller" });
	}
    }
    @l;
}

sub pcmcia_probe() {
    -e '/var/run/stab' || -e '/var/lib/pcmcia/stab' or return ();

    my (@devs, $desc);
    foreach (cat_('/var/run/stab'), cat_('/var/lib/pcmcia/stab')) {
	if (/^Socket\s+\d+:\s+(.*)/) {
	    $desc = $1;
	} else {
	    my (undef, $type, $module, undef, $device) = split;
	    push @devs, { description => $desc, driver => $module, type => $type, device => $device };
	}
    }
    @devs;
}

# pcmcia_probe provides field "device", used in network.pm
# => probeall with $probe_type is unsafe
sub probeall() {
    return if $::noauto;

    require sbus_probing::main;
    pci_probe(), usb_probe(), firewire_probe(), pcmcia_probe(), sbus_probing::main::probe();
}
sub matching_desc {
    my ($regexp) = @_;
    grep { $_->{description} =~ /$regexp/i } probeall();
}
sub stringlist() { 
    map {
	sprintf("%-16s: %s%s%s", 
		$_->{driver} || 'unknown', 
		$_->{description} eq '(null)' ? sprintf("Vendor=0x%04x Device=0x%04x", $_->{vendor}, $_->{id}) : $_->{description},
		$_->{media_type} ? sprintf(" [%s]", $_->{media_type}) : '',
		$_->{subid} && $_->{subid} != 0xffff ? sprintf(" SubVendor=0x%04x SubDevice=0x%04x", $_->{subvendor}, $_->{subid}) : '',
	       )
    } probeall(); 
}

sub tryOpen($) {
    my $F;
    sysopen $F, devices::make($_[0]), c::O_NONBLOCK() and $F;
}

sub tryWrite($) {
    my $F;
    sysopen $F, devices::make($_[0]), 1 | c::O_NONBLOCK() and $F;
}

sub syslog() {
    -r "/tmp/syslog" and return map { /<\d+>(.*)/ } cat_("/tmp/syslog");
    my $LD_LOADER = $ENV{LD_LOADER} || "";
    `$LD_LOADER /bin/dmesg`;
}

sub get_mac_model() {
    my $mac_model = cat_("/proc/device-tree/model") || die "Can't open /proc/device-tree/model";
    log::l("Mac model: $mac_model");
    $mac_model;	
}

sub get_mac_generation() {
    my $generation = cat_("/proc/cpuinfo") || die "Can't open /proc/cpuinfo";
    my @genarray = split(/\n/, $generation);
    my $count = 0;
    while ($count <= @genarray) {
	if ($genarray[$count] =~ /pmac-generation/) {
	    @genarray = split(/:/, $genarray[$count]);
	    return $genarray[1];
	}
	$count++;
    }
    return "Unknown Generation";	
}

sub hasSMP() { !$::testing && c::detectSMP() }
sub hasPCMCIA() { $::o->{pcmcia} } #- because /proc/pcmcia seems not to be present on 2.4 at least (or use /var/run/stab)

#- try to detect a laptop, we assume pcmcia service is an indication of a laptop or
#- the following regexp to match graphics card apparently only used for such systems.
sub isLaptop() {
    hasPCMCIA() || (matching_desc('C&T.*655[45]\d') || matching_desc('C&T.*68554') ||
		    matching_desc('Neomagic.*Magic(Media|Graph)') ||
		    matching_desc('ViRGE.MX') || matching_desc('S3.*Savage.*[IM]X') ||
		    matching_desc('ATI.*(Mobility|LT)'))
                || cat_('/proc/cpuinfo') =~ /\bmobile\b/i;
}

sub usbMice()      { grep { $_->{media_type} =~ /\|Mouse/ && $_->{driver} !~ /Tablet:wacom/ ||
			  $_->{driver} =~ /Mouse:USB/ } usb_probe() }
sub usbWacom()     { grep { $_->{driver} =~ /Tablet:wacom/ } usb_probe() }
sub usbKeyboards() { grep { $_->{media_type} =~ /\|Keyboard/ } usb_probe() }
sub usbStorage()   { grep { $_->{media_type} =~ /Mass Storage\|/ } usb_probe() }

sub usbKeyboard2country_code {
    my ($usb_kbd) = @_;
    my ($F, $tmp);
    sysopen($F, sprintf("/proc/bus/usb/%03d/%03d", $usb_kbd->{pci_bus}, $usb_kbd->{pci_device}), 0) and
      sysseek $F, 0x28, 0 and
      sysread $F, $tmp, 1 and
      unpack("C", $tmp);
}

sub probeSerialDevices() {
    foreach (0..3) {
	#- make sure the device are created before probing,
	devices::make("/dev/ttyS$_");
	#- and make sure the device is a real terminal (major is 4).
	int((stat "/dev/ttyS$_")[6]/256) == 4 or $serialprobe{"/dev/ttyS$_"} = undef;
    }

    #- for device already probed, we can safely (assuming device are
    #- not moved during install :-)
    #- include /dev/mouse device if using an X server.
    mkdir_p("/var/lock");
    -l "/dev/mouse" and $serialprobe{"/dev/" . readlink "/dev/mouse"} = undef;
    foreach (keys %serialprobe) { m|^/dev/(.*)| and touch "/var/lock/LCK..$1" }

    print STDERR "Please wait while probing serial ports...\n";
    #- start probing all serial ports... really faster than before ...
    #- ... but still take some time :-)
    my %current; foreach (run_program::get_stdout('serial_probe')) {
	$serialprobe{$current{DEVICE}} = { %current } and %current = () if /^\s*$/ && $current{DEVICE};
	$current{$1} = $2 if /^([^=]+)=(.*?)\s*$/;
    }

    foreach (values %serialprobe) {
	$_->{DESCRIPTION} =~ /modem/i and $_->{CLASS} = 'MODEM'; #- hack to make sure a modem is detected.
	$_->{DESCRIPTION} =~ /olitec/i and $_->{CLASS} = 'MODEM'; #- hack to make sure such modem gets detected.
	log::l("probed $_->{DESCRIPTION} of class $_->{CLASS} on device $_->{DEVICE}");
    }
}

sub probeSerial($) { $serial�����>��
��o&�^�6K�᮫���{��"ζ�1�h|z��<�ӭ.�/[�\��"F��)۬��(
\���&1�=xa+l�x�֚i�6j�1�A=�|�'V�J\I1�;�;6MgK�-[/c���ld��c�6{�"����
�x"�o����D���x�K��u]Uk]��oh7��j0a,�����Ԁ���h�Cϊ�
vn�:�+�Z��(إ��ng�j�#������Q�
�%�K�d
�M�PXAm�K!d_��s�c��f�������D�m�0_����L�q�~�3�0l6�ۥ������6P&��-d��\���j��W
o������W�/O�}��t�ϽI��������M��Y�y�l���Pm=���_�4���pt����u���>I}�s^�7}��;�����,Ï���}�6vW��g'�{�M����.���J�w�y?�k��������c(�_EFC���R�_�O������'4��j�����w��Z?ܾ/���p��,-xzʸ�Cwz�O�`���}ͯW}��V�ݮ���o������/3՘�l�<}㛙�}^�49Y�N����q�o�/�����K���p�x����Ofw[�߽��=�o�־�'��f����bz�n��%���^�����A���]��W\>��G����|>닰�7/�����.�5Y����+AS��|���O��;}�gGg����/��+߉҇���DZd�v���:����Ta�:��9��k�6�'��Skn��[o���[|�>{_��3k���hbu�O������l>.&���}��L}��Q�~�^�{�����{���{�/�%����=L�����/%����~�<����o�W�m獹�0���,6���x\�6��I�����,O����
�U�����7{g�7��_�t�yksIYm�|)o�u�%?�������l��+5�["w��Y��G���;��}k��̯+Sp�����G���(6]ԗ�h�=Z��~�s��Zw�]��]�!���%�;�������o��;Gz��'���]=a��)^X����獇�l}9;����9�ue���
ů�}C�~����q����Mj��7*��f��|6_������z��ltf~߷��=���Y¹d����qh�`��}����kƷ]Փ�p�N����]vF�O���v^����l{��4�w�e����q�m���'a���8�V>�����M�^_����2��}�����,���4v̮��5����>�Lףɿ�~�1��'���g��-=�{���a/��a�	�zհ���P�ۮ�\�٦���{�D�&��|>��.wR���:��>��W��y�����e=C���8����b��נ��7���RӠ�=9�?tϰ䗏g����$�a�Ƹi+�=�i��������/�i�����H�'�k��s2}�ǣ��tZ�qZ�~���c򽷣���ݏ���v��ߋ��X�/���R}�u��������ow���~��G��<-�#a��}�����`wY�Z�K@�6Z?Kg���=����U�ߓb����=��‡��&�+�uU]��ˮ݌��/��1ݖ
�9�_��7j�h�mj~��F������ ���삄 &�
��@�}����w"K��J}���^v���=1B���޷Jm��ªW	�F���3)���l���6�>�Z���}�ު��K�3[�����E���[;c�����}i�{�:��J;�d{�v{n�{�RN��Y}ϧϫ}ݹV��xV����Kq�������;w}���7o/�o�q֭i��{��=��Mʱ��!�������鳼AU}�TS[Am=�	BDA�
wwhPV���87����5����c��E���^����;}���(�HUV���z{��Ju�G)S媟{���tz08��|��=�
H�(��rYff�fA���(
5���
�ɟ)T}ɨWTw����

@����*�4
�lp�
!��懳I�S%.ڨT�F[��`�@5��	5﷒����|�݊�cv������*��Sl��2tt[��sL���zm�Uw���V닚{�7;ݸ���*Uo�z��Z:�w��tr�heZ�c��sbG���h�������M�B�͞�i�.�}/��禗�a֍Z�B�J�hS
5���n��{���5i��Zђ|Z��
D����a�A|x��ʕ	w�gو�]0��J��⽏�#
��n����]Y��|�o}���B����{W-��V���K�f�V�3�³B�:�R��R��'n���W��&��=5I@�x{;���+��h�Sr�ogey�u�Q�n�
C�85*Ͻ���
�B���g�{;���u����r}��{3�1�%��if�KmJQ��mEv���J���^�K���+gN����
t6�ZX�
��qRYN�u@N�m�
�	PZ�K`{����KiT{5AK�1׉��}�ꏭ��-P�
�%Lܺ}�q�4!��)v��ӓ�����J�Mķ�留�]�y���
J�=�V���E[;�}q�tJfZԨ��.������+e���	���eAQ�D���Y5��MC3m��@��r�q��mkѸҽnC�Et1������F]l@V؝۳�����p-�+XBI4�Uka	Mkf���˝�����{���T���N���ND	�@�M	�S&4&5?&��&�='�i�1�i�=OI�Jh�	�2C&!4�6�~���(h�0�@4�P$"�5?�2M�=H�H������yF�P4@�h
��D 
iO�M'��zL	3Q=MD��)�4�54�ڃ!��F@ hh(7�"�&��x���l��2��m@�M=M�6��
$  h���D�L�d�J��T��U?�=�zOQ��h�j
�h[�B�j�����XTrT������|g�MQ"�Ե��}v��›�J��
�_2j�����?�G�'��>+��ľ�es��
�x$��������������ZG
:#��v6&,ZFњD�0�n�
 5L�
Y
�	AêY.9�� ��0�%�T�XuaI�Y2sh2JL
L�d�C�\0�.:����"].�)��p�h���2kCKe�k��^��zP~0
"B���U���aW�
�P�n[��'����@�X��_��N��(k5X 8����e��|��͐���pX�V	;XP:,�`�	@�.�N�(�S��?�!k�
`O����bI�ƃ��$�X~%�#��$�<1eG��x}�D���I��!4TJS�pdBM"8;0�ē�H��!�c��=O$G�{.���!��#.�	�ò��,5�X��Ob�;�D�y##!b�E9�n=��z��JXpTyI�G�F�N�"&����=�ŠwŁ��< �$҅ D�CHPP
CAACH�Y��d9
f	%��/+�&B��;�Zl�=7'��l�=�����)ᐳ����ѳ��]%���T�*h��=�!�q�rl�s
pX����:GG'���ѳ
���:GG�F�P�4t�QNg�vy1o�f�)���
F�[7Ǩ�;<,h�Y�m8�bٳ�g'g'����M��h�����!��gG�=�������<==���h���vrth���豑b��p�N
���8L�77e�F��=G��S��Mѳ�l��ó��f��y,�7��FΏSr�ٸ΋œó���mb,�d�[ɲ���8�����:��=Y������������Â�)��+�n���W���zqA����h�^��/'g�E9<��Y����<4a�Gf��ө=�Nl�%��G��C��R�RJ�s���u
짬4l�l�ٸta����ttrl�GG%�-�/&C�S�'v�<;:<;8��dѸvvsĖ�=6vS��Ֆ�V�vsV�NM�����y:6�#���른z;6rxxpb&��'�ޏ�e������G���G��죱Ov�W+��]�+���^�t�Ŏ	�Ԝ@�k�N�u�0Z	�\�k��\.c�엁oF�%�;=��,��e�vvp{X{x�[Բ��w�����<�
ruܖ�d��Ƭ�G����f�z�l�Y���tXtth�:�Kx<;;;�YgGG'�g��)���D�Sã�d��ѳ8Y{;=���yF�Kwm�w�rMY^�G'G���OG�U�Z��z�'f��M�e�v���V0��z�Z�e��
�ܲ�tvzGN�8)������j<������{Oil�%�L�G�����;6l�:�R���+v��)�Ù�8�F�Kn�4xtrl���M�E=F�[OGf�O\-�٣�w�-����ܖ�Gg��|D�$���� �ٗwo�w��?�|��?����O���������0'���6͞|G��T�n���g����#�z��p:~��O/7 	Ghl�����|(F��H�n&�^d�#��Q����?�/�]�g�qs3�T����D�L5_y�|	��8�Pp��< �ɯ���"vҤ�_�_ô,�l��߿�k�}��zi+U����ϗ���ӾO�F>��������a���b*.����lN:�*L͈#Rt'Yim�/d��镸FC8f7N��-�'�M,�V�p�I����u�҄���v��6@� π
	b�b ?һD����e�d)|0/<��[r�6')�tU�k�x�	s���7����������!�7�1�:��v�X�D3�d�%��^?�5�o�?���*���"�J
@�=`�Ɉ]D��������D�	К�0x'�ZW�A�iW���	]�~��f����,�|O�y���Eu\����I"H�I�@qn@	�M3�t�ܨ-�O��qRpD�?��U~f����fd�Ȗ�(��c"b
Z�\Z� ��M2�9	�m��q�Q:z�|��"K�צ�M�E��6bl�h	�X�By��Kn��;{��W��'Lo�H���A^ ���τ�L��0&4E��؀����/�D�3�?% 
	    if_(/^kmod: failed.*md-personality-(.)/ ||
		/^md: personality (.) is not loaded/, $personalities{$1}) } syslog() or last;
	eval { modules::load(@needed_perso) };
	raidAutoStartIoctl() or raidAutoStartRaidtab(@parts);
    }
}

sub usb_description2removable {
    local ($_) = @_;
    return 'camera' if /\bcamera\b/i;
    return 'memory_card' if /\bmemory\s?stick\b/i || /\bcompact\s?flash\b/i || /\bsmart\s?media\b/i;
    return 'memory_card' if /DiskOnKey/i || /IBM-DMDM/i;
    return 'zip' if /\bzip\s?(100|250|750)/i;
    return 'floppy' if /\bLS-?120\b/i;
    return;
}

sub usb2removable {
    my ($e) = @_;
    $e->{usb_driver} or return;

    if ($e->{usb_driver} =~ /Removable:(.*)/) {
	return $1;
    } elsif (my $name = usb_description2removable($e->{usb_description})) {
	return $name;
    }
    undef;
}

sub suggest_mount_point {
    my ($e) = @_;

    my $name = $e->{media_type};
    if (member($name, 'hd', 'fd')) {
	if (exists $e->{usb_driver}) {
	    return usb2removable($e) || 'removable';
	}
	if (isZipDrive($e)) {
	    $name = 'zip';
	} elsif ($name eq 'fd') {
	    $name = 'floppy';
	} else {
	    log::l("set_removable_mntpoints: don't know what to with hd $e->{device}");
	}
    }
    $name;
}

1;