tree 809ba05d44d79387c8142fb8d3974801ca222508
parent 786231af0a4ac6d78cef51fa7e9c3dd63f016195
author Mike Christie <michaelc@cs.wisc.edu> 1215823832 -0500
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1217099688 -0400

[SCSI] fix shared tag map setup

Currently qla4xxx and stex pass in their can_queue values into
scsi_activate_tcq because they wanted the tag map that large.
The problem with this is that it ends up also setting the queue
depth to that large value. All we want to do this in this case
is set the device queue depth and the other device settings.
We do not need to touch the tag map sizing because the drivers
had setup that map according to their can_queue limits when the
shared map was created.

The scsi mid layer in request_fn will then handle the case where we
have more requests than available tags when it checks the host
queue ready function.

Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
