tree bf0e5580ce0637339a37027717132ca2a7eebcaf
parent 938bb03d188a1e688fb0bcae49788f540193e80a
author Tejun Heo <tj@kernel.org> 1217953022 +0200
committer Bartlomiej Zolnierkiewicz <bzolnier@gmail.com> 1217953022 +0200

cdrom: don't check CDC_PLAY_AUDIO in cdrom_count_tracks()

According to MMC-3 (or any later versions) READ TOCs are mandatory
commands and have nothing to do with CDC_PLAY_AUDIO.  I have no idea why
the check was put there in the first place but it now only breaks
automatic actions on certain drives.

Note that this test was only effective when ide-cdrom was being used
as sr didn't mask CDC_PLAY_AUDIO according to the capabilities.

Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Jens Axboe <jens.axboe@oracle.com>
Cc: Borislav Petkov <petkovbb@googlemail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
