scsi: aacraid: get rid of one level of indentation

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

unsigned long byte_count = 0;
nseg = scsi_dma_map(scsicmd);
if (nseg < 0)
return nseg;
if (nseg) {
...
}
return byte_count;

is equal to

unsigned long byte_count = 0;
nseg = scsi_dma_map(scsicmd);
if (nseg <= 0)
return nseg;
...
return byte_count;

No other code has changed.

[mkp: fix checkpatch complaints]

Signed-off-by: Nikola Pajkovsky <npajkovsky@suse.cz>
Reviewed-by: Raghava Aditya Renukunta <RaghavaAditya.Renukunta@microsemi.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

authored by

Nikola Pajkovsky and committed by

Martin K. Petersen 8 years ago a2260323 913e00a5

+127 -132

1 changed file

expand all

unified split

drivers

scsi

aacraid

aachba.c

+127 -132

drivers/scsi/aacraid/aachba.c

··· 3757 3757 struct aac_dev *dev; 3758 3758 unsigned long byte_count = 0; 3759 3759 int nseg; 3760 + struct scatterlist *sg; 3761 + int i; 3760 3762 3761 3763 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 3762 3764 // Get rid of old data ··· 3767 3765 psg->sg[0].count = 0; 3768 3766 3769 3767 nseg = scsi_dma_map(scsicmd); 3770 - if (nseg < 0) 3768 + if (nseg <= 0) 3771 3769 return nseg; 3772 - if (nseg) { 3773 - struct scatterlist *sg; 3774 - int i; 3775 3770 3776 - psg->count = cpu_to_le32(nseg); 3771 + psg->count = cpu_to_le32(nseg); 3777 3772 3778 - scsi_for_each_sg(scsicmd, sg, nseg, i) { 3779 - psg->sg[i].addr = cpu_to_le32(sg_dma_address(sg)); 3780 - psg->sg[i].count = cpu_to_le32(sg_dma_len(sg)); 3781 - byte_count += sg_dma_len(sg); 3782 - } 3783 - /* hba wants the size to be exact */ 3784 - if (byte_count > scsi_bufflen(scsicmd)) { 3785 - u32 temp = le32_to_cpu(psg->sg[i-1].count) - 3786 - (byte_count - scsi_bufflen(scsicmd)); 3787 - psg->sg[i-1].count = cpu_to_le32(temp); 3788 - byte_count = scsi_bufflen(scsicmd); 3789 - } 3790 - /* Check for command underflow */ 3791 - if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 3792 - printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 3793 - byte_count, scsicmd->underflow); 3794 - } 3773 + scsi_for_each_sg(scsicmd, sg, nseg, i) { 3774 + psg->sg[i].addr = cpu_to_le32(sg_dma_address(sg)); 3775 + psg->sg[i].count = cpu_to_le32(sg_dma_len(sg)); 3776 + byte_count += sg_dma_len(sg); 3795 3777 } 3778 + /* hba wants the size to be exact */ 3779 + if (byte_count > scsi_bufflen(scsicmd)) { 3780 + u32 temp = le32_to_cpu(psg->sg[i-1].count) - 3781 + (byte_count - scsi_bufflen(scsicmd)); 3782 + psg->sg[i-1].count = cpu_to_le32(temp); 3783 + byte_count = scsi_bufflen(scsicmd); 3784 + } 3785 + /* Check for command underflow */ 3786 + if (scsicmd->underflow && (byte_count < scsicmd->underflow)) { 3787 + printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 3788 + byte_count, scsicmd->underflow); 3789 + } 3790 + 3796 3791 return byte_count; 3797 3792 } 3798 3793 ··· 3800 3801 unsigned long byte_count = 0; 3801 3802 u64 addr; 3802 3803 int nseg; 3804 + struct scatterlist *sg; 3805 + int i; 3803 3806 3804 3807 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 3805 3808 // Get rid of old data ··· 3811 3810 psg->sg[0].count = 0; 3812 3811 3813 3812 nseg = scsi_dma_map(scsicmd); 3814 - if (nseg < 0) 3813 + if (nseg <= 0) 3815 3814 return nseg; 3816 - if (nseg) { 3817 - struct scatterlist *sg; 3818 - int i; 3819 3815 3820 - scsi_for_each_sg(scsicmd, sg, nseg, i) { 3821 - int count = sg_dma_len(sg); 3822 - addr = sg_dma_address(sg); 3823 - psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff); 3824 - psg->sg[i].addr[1] = cpu_to_le32(addr>>32); 3825 - psg->sg[i].count = cpu_to_le32(count); 3826 - byte_count += count; 3827 - } 3828 - psg->count = cpu_to_le32(nseg); 3829 - /* hba wants the size to be exact */ 3830 - if (byte_count > scsi_bufflen(scsicmd)) { 3831 - u32 temp = le32_to_cpu(psg->sg[i-1].count) - 3832 - (byte_count - scsi_bufflen(scsicmd)); 3833 - psg->sg[i-1].count = cpu_to_le32(temp); 3834 - byte_count = scsi_bufflen(scsicmd); 3835 - } 3836 - /* Check for command underflow */ 3837 - if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 3838 - printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 3839 - byte_count, scsicmd->underflow); 3840 - } 3816 + scsi_for_each_sg(scsicmd, sg, nseg, i) { 3817 + int count = sg_dma_len(sg); 3818 + addr = sg_dma_address(sg); 3819 + psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff); 3820 + psg->sg[i].addr[1] = cpu_to_le32(addr>>32); 3821 + psg->sg[i].count = cpu_to_le32(count); 3822 + byte_count += count; 3841 3823 } 3824 + psg->count = cpu_to_le32(nseg); 3825 + /* hba wants the size to be exact */ 3826 + if (byte_count > scsi_bufflen(scsicmd)) { 3827 + u32 temp = le32_to_cpu(psg->sg[i-1].count) - 3828 + (byte_count - scsi_bufflen(scsicmd)); 3829 + psg->sg[i-1].count = cpu_to_le32(temp); 3830 + byte_count = scsi_bufflen(scsicmd); 3831 + } 3832 + /* Check for command underflow */ 3833 + if (scsicmd->underflow && (byte_count < scsicmd->underflow)) { 3834 + printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 3835 + byte_count, scsicmd->underflow); 3836 + } 3837 + 3842 3838 return byte_count; 3843 3839 } 3844 3840 ··· 3843 3845 { 3844 3846 unsigned long byte_count = 0; 3845 3847 int nseg; 3848 + struct scatterlist *sg; 3849 + int i; 3846 3850 3847 3851 // Get rid of old data 3848 3852 psg->count = 0; ··· 3856 3856 psg->sg[0].flags = 0; 3857 3857 3858 3858 nseg = scsi_dma_map(scsicmd); 3859 - if (nseg < 0) 3859 + if (nseg <= 0) 3860 3860 return nseg; 3861 - if (nseg) { 3862 - struct scatterlist *sg; 3863 - int i; 3864 3861 3865 - scsi_for_each_sg(scsicmd, sg, nseg, i) { 3866 - int count = sg_dma_len(sg); 3867 - u64 addr = sg_dma_address(sg); 3868 - psg->sg[i].next = 0; 3869 - psg->sg[i].prev = 0; 3870 - psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32)); 3871 - psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 3872 - psg->sg[i].count = cpu_to_le32(count); 3873 - psg->sg[i].flags = 0; 3874 - byte_count += count; 3875 - } 3876 - psg->count = cpu_to_le32(nseg); 3877 - /* hba wants the size to be exact */ 3878 - if (byte_count > scsi_bufflen(scsicmd)) { 3879 - u32 temp = le32_to_cpu(psg->sg[i-1].count) - 3880 - (byte_count - scsi_bufflen(scsicmd)); 3881 - psg->sg[i-1].count = cpu_to_le32(temp); 3882 - byte_count = scsi_bufflen(scsicmd); 3883 - } 3884 - /* Check for command underflow */ 3885 - if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 3886 - printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 3887 - byte_count, scsicmd->underflow); 3888 - } 3862 + scsi_for_each_sg(scsicmd, sg, nseg, i) { 3863 + int count = sg_dma_len(sg); 3864 + u64 addr = sg_dma_address(sg); 3865 + psg->sg[i].next = 0; 3866 + psg->sg[i].prev = 0; 3867 + psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32)); 3868 + psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 3869 + psg->sg[i].count = cpu_to_le32(count); 3870 + psg->sg[i].flags = 0; 3871 + byte_count += count; 3889 3872 } 3873 + psg->count = cpu_to_le32(nseg); 3874 + /* hba wants the size to be exact */ 3875 + if (byte_count > scsi_bufflen(scsicmd)) { 3876 + u32 temp = le32_to_cpu(psg->sg[i-1].count) - 3877 + (byte_count - scsi_bufflen(scsicmd)); 3878 + psg->sg[i-1].count = cpu_to_le32(temp); 3879 + byte_count = scsi_bufflen(scsicmd); 3880 + } 3881 + /* Check for command underflow */ 3882 + if (scsicmd->underflow && (byte_count < scsicmd->underflow)) { 3883 + printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 3884 + byte_count, scsicmd->underflow); 3885 + } 3886 + 3890 3887 return byte_count; 3891 3888 } 3892 3889 ··· 3892 3895 { 3893 3896 unsigned long byte_count = 0; 3894 3897 int nseg; 3898 + struct scatterlist *sg; 3899 + int i, conformable = 0; 3900 + u32 min_size = PAGE_SIZE, cur_size; 3895 3901 3896 3902 nseg = scsi_dma_map(scsicmd); 3897 - if (nseg < 0) 3903 + if (nseg <= 0) 3898 3904 return nseg; 3899 - if (nseg) { 3900 - struct scatterlist *sg; 3901 - int i, conformable = 0; 3902 - u32 min_size = PAGE_SIZE, cur_size; 3903 3905 3904 - scsi_for_each_sg(scsicmd, sg, nseg, i) { 3905 - int count = sg_dma_len(sg); 3906 - u64 addr = sg_dma_address(sg); 3906 + scsi_for_each_sg(scsicmd, sg, nseg, i) { 3907 + int count = sg_dma_len(sg); 3908 + u64 addr = sg_dma_address(sg); 3907 3909 3908 - BUG_ON(i >= sg_max); 3909 - rio2->sge[i].addrHigh = cpu_to_le32((u32)(addr>>32)); 3910 - rio2->sge[i].addrLow = cpu_to_le32((u32)(addr & 0xffffffff)); 3911 - cur_size = cpu_to_le32(count); 3912 - rio2->sge[i].length = cur_size; 3913 - rio2->sge[i].flags = 0; 3914 - if (i == 0) { 3915 - conformable = 1; 3916 - rio2->sgeFirstSize = cur_size; 3917 - } else if (i == 1) { 3918 - rio2->sgeNominalSize = cur_size; 3910 + BUG_ON(i >= sg_max); 3911 + rio2->sge[i].addrHigh = cpu_to_le32((u32)(addr>>32)); 3912 + rio2->sge[i].addrLow = cpu_to_le32((u32)(addr & 0xffffffff)); 3913 + cur_size = cpu_to_le32(count); 3914 + rio2->sge[i].length = cur_size; 3915 + rio2->sge[i].flags = 0; 3916 + if (i == 0) { 3917 + conformable = 1; 3918 + rio2->sgeFirstSize = cur_size; 3919 + } else if (i == 1) { 3920 + rio2->sgeNominalSize = cur_size; 3921 + min_size = cur_size; 3922 + } else if ((i+1) < nseg && cur_size != rio2->sgeNominalSize) { 3923 + conformable = 0; 3924 + if (cur_size < min_size) 3919 3925 min_size = cur_size; 3920 - } else if ((i+1) < nseg && cur_size != rio2->sgeNominalSize) { 3921 - conformable = 0; 3922 - if (cur_size < min_size) 3923 - min_size = cur_size; 3924 - } 3925 - byte_count += count; 3926 3926 } 3927 + byte_count += count; 3928 + } 3927 3929 3928 - /* hba wants the size to be exact */ 3929 - if (byte_count > scsi_bufflen(scsicmd)) { 3930 - u32 temp = le32_to_cpu(rio2->sge[i-1].length) - 3931 - (byte_count - scsi_bufflen(scsicmd)); 3932 - rio2->sge[i-1].length = cpu_to_le32(temp); 3933 - byte_count = scsi_bufflen(scsicmd); 3934 - } 3930 + /* hba wants the size to be exact */ 3931 + if (byte_count > scsi_bufflen(scsicmd)) { 3932 + u32 temp = le32_to_cpu(rio2->sge[i-1].length) - 3933 + (byte_count - scsi_bufflen(scsicmd)); 3934 + rio2->sge[i-1].length = cpu_to_le32(temp); 3935 + byte_count = scsi_bufflen(scsicmd); 3936 + } 3935 3937 3936 - rio2->sgeCnt = cpu_to_le32(nseg); 3937 - rio2->flags |= cpu_to_le16(RIO2_SG_FORMAT_IEEE1212); 3938 - /* not conformable: evaluate required sg elements */ 3939 - if (!conformable) { 3940 - int j, nseg_new = nseg, err_found; 3941 - for (i = min_size / PAGE_SIZE; i >= 1; --i) { 3942 - err_found = 0; 3943 - nseg_new = 2; 3944 - for (j = 1; j < nseg - 1; ++j) { 3945 - if (rio2->sge[j].length % (i*PAGE_SIZE)) { 3946 - err_found = 1; 3947 - break; 3948 - } 3949 - nseg_new += (rio2->sge[j].length / (i*PAGE_SIZE)); 3950 - } 3951 - if (!err_found) 3938 + rio2->sgeCnt = cpu_to_le32(nseg); 3939 + rio2->flags |= cpu_to_le16(RIO2_SG_FORMAT_IEEE1212); 3940 + /* not conformable: evaluate required sg elements */ 3941 + if (!conformable) { 3942 + int j, nseg_new = nseg, err_found; 3943 + for (i = min_size / PAGE_SIZE; i >= 1; --i) { 3944 + err_found = 0; 3945 + nseg_new = 2; 3946 + for (j = 1; j < nseg - 1; ++j) { 3947 + if (rio2->sge[j].length % (i*PAGE_SIZE)) { 3948 + err_found = 1; 3952 3949 break; 3950 + } 3951 + nseg_new += (rio2->sge[j].length / (i*PAGE_SIZE)); 3953 3952 } 3954 - if (i > 0 && nseg_new <= sg_max) 3955 - aac_convert_sgraw2(rio2, i, nseg, nseg_new); 3956 - } else 3957 - rio2->flags |= cpu_to_le16(RIO2_SGL_CONFORMANT); 3958 - 3959 - /* Check for command underflow */ 3960 - if (scsicmd->underflow && (byte_count < scsicmd->underflow)) { 3961 - printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 3962 - byte_count, scsicmd->underflow); 3953 + if (!err_found) 3954 + break; 3963 3955 } 3956 + if (i > 0 && nseg_new <= sg_max) 3957 + aac_convert_sgraw2(rio2, i, nseg, nseg_new); 3958 + } else 3959 + rio2->flags |= cpu_to_le16(RIO2_SGL_CONFORMANT); 3960 + 3961 + /* Check for command underflow */ 3962 + if (scsicmd->underflow && (byte_count < scsicmd->underflow)) { 3963 + printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 3964 + byte_count, scsicmd->underflow); 3964 3965 } 3965 3966 3966 3967 return byte_count;