tree e4b4cfae172b0ef68556b78ae6ac5c281b57510f
parent 67768f675ffa587d6081ed1d259e796823023926
author FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp> 1203259560 +0900
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1204571293 -0600

[SCSI] ps3rom: disable clustering

ps3rom does:

scsi_for_each_sg(cmd, sgpnt, scsi_sg_count(cmd), k) {
	kaddr = kmap_atomic(sg_page(sgpnt), KM_IRQ0);

We cannot do something like that with the clustering enabled (or we
can use scsi_kmap_atomic_sg).

Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
Cc: Geert Uytterhoeven <Geert.Uytterhoeven@sonycom.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
