map returns a list so the solution to your missing value conundrum is to return an empty list for suppressed values. I'm not sure I'd solve this particular problem using a map and the following technique, but the technique is worth knowing about in any case:

use strict;
use warnings;

my %info = map {chomp; my @parts = split '=';
    @parts == 2 && length $parts[1] ? @parts : ()
    } <DATA>;

print "$_: $info{$_}\n" for sort keys %info;

__DATA__
key=value
nokey=
[download]

Prints:

key: value
[download]

use warnings;
use strict;
use Data::Dumper;
$Data::Dumper::Sortkeys = 1;

my %info;
while (<DATA>) {
    chomp;
    my ($k, $v) = split /=/;
    $info{$k} = $v if length $v;
}
print Dumper(\%info);

__DATA__
a=5
b=6
c=
d=7
[download]

$VAR1 = {
          'a' => '5',
          'b' => '6',
          'd' => '7'
[download]

while (<DATA>) {
    chomp;
    my ($k, $v) = split /=/;
    $info{$k} = (length $v) ? $v : 666;
}
[download]

In the spirit of TIMTOWTDI, here's a method that involves capturing your split() output in an arrayref:

... map { chomp; [split'=']; } <$fh>;
[download]

which is subsequently filtered through a second map():

%{$self->{info}} = map { EXPR } map { chomp; [split'=']; } <$fh>;
[download]

To exclude a key, EXPR is:

    defined $_->[1] ? @$_ : ()
[download]

To use a default value (here I've used the string: undef), EXPR is:

    $_->[1] //= q{undef}; @$_
[download]

or instead of using the ?: in the "decoding" map for the elimination case you could instead use a grep:

%{$self->{info}} = map {@$_} grep {defined $_->[1]} map {chomp; [split
+'='];} <$fh>;
[download]

In any case generating the array ref doesn't actually seem to be a win in terms of succinctness or comprehensibility.

True laziness is hard work

Yet another way, using the 3-argument form of split, which guarantees that the input string is split into two parts and no more or less. The second part would be a string of length 0, instead of an undefined value.

%{$self->{info}} = map {@$_} grep {$_->[1]} map {chomp; [split '=', $_
+, 2];} <$fh>;
[download]

I prefer this form of split in handling key=value type strings, since it handles the cases where a value could have an embedded '=' (PASSWORD=blah=argh!), whereas the shorter one-(or, two-)argument forms would return truncated values.

Yet another alternative, using only one map:

%{$self->{info}} = map {chomp; my ($k, $v) = split '=', $_, 2; $v ? ($
+k => $v) : (); } <$fh>;
[download]

If we want to supply default values:

# assuming default values are in %defaults
%{$self->{info}} = map {chomp; my ($k, $v) = split '=', $_, 2; $k => $
+v || $defaults{$k}; } <$fh>;
[download]

Nothing prevents you from inserting code as complex as you need into the map:

... = map { chomp; my ($right,$left)= split'='; if ($left) { ($right,$
+left) } else { () } } <$fh>;
[download]

is there a way to exclude the key itself

    %{$self->{info}} = map /^([^=]+)=(.+)$/, <$fh>;
[download]