/*
 * Scsi Host Layer for MPT (Message Passing Technology) based controllers
 *
 * Copyright (C) 2012-2014  LSI Corporation
 * Copyright (C) 2013-2015 Avago Technologies
 *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * NO WARRANTY
 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
 * solely responsible for determining the appropriateness of using and
 * distributing the Program and assumes all risks associated with its
 * exercise of rights under this Agreement, including but not limited to
 * the risks and costs of program errors, damage to or loss of data,
 * programs or equipment, and unavailability or interruption of operations.

 * DISCLAIMER OF LIABILITY
 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES

 * You should have received a copy of the GNU General Public License
 * along with this program.
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/unaligned.h>

#include "mpt3sas_base.h"

/**
 * _warpdrive_disable_ddio - Disable direct I/O for all the volumes
 * @ioc: per adapter object
 */
static void
_warpdrive_disable_ddio(struct MPT3SAS_ADAPTER *ioc)
{
 Mpi2RaidVolPage1_t vol_pg1;
 Mpi2ConfigReply_t mpi_reply;
 struct _raid_device *raid_device;
 u16 handle;
 u16 ioc_status;
 unsigned long flags;

 handle = 0xFFFF;
 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
     &vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
  ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
      MPI2_IOCSTATUS_MASK;
  if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
   break;
  handle = le16_to_cpu(vol_pg1.DevHandle);
  spin_lock_irqsave(&ioc->raid_device_lock, flags);
  raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
  if (raid_device)
   raid_device->direct_io_enabled = 0;
  spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
 }
 return;
}


/**
 * mpt3sas_get_num_volumes - Get number of volumes in the ioc
 * @ioc: per adapter object
 */
u8
mpt3sas_get_num_volumes(struct MPT3SAS_ADAPTER *ioc)
{
 Mpi2RaidVolPage1_t vol_pg1;
 Mpi2ConfigReply_t mpi_reply;
 u16 handle;
 u8 vol_cnt = 0;
 u16 ioc_status;

 handle = 0xFFFF;
 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
     &vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
  ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
      MPI2_IOCSTATUS_MASK;
  if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
   break;
  vol_cnt++;
  handle = le16_to_cpu(vol_pg1.DevHandle);
 }
 return vol_cnt;
}


/**
 * mpt3sas_init_warpdrive_properties - Set properties for warpdrive direct I/O.
 * @ioc: per adapter object
 * @raid_device: the raid_device object
 */
void
mpt3sas_init_warpdrive_properties(struct MPT3SAS_ADAPTER *ioc,
 struct _raid_device *raid_device)
{
 Mpi2RaidVolPage0_t *vol_pg0;
 Mpi2RaidPhysDiskPage0_t pd_pg0;
 Mpi2ConfigReply_t mpi_reply;
 u16 sz;
 u8 num_pds, count;
 unsigned long stripe_sz, block_sz;
 u8 stripe_exp, block_exp;
 u64 dev_max_lba;

 if (!ioc->is_warpdrive)
  return;

 if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_EXPOSE_ALL_DISKS) {
  ioc_info(ioc, "WarpDrive : Direct IO is disabled globally as drives are exposed\n");
  return;
 }
 if (mpt3sas_get_num_volumes(ioc) > 1) {
  _warpdrive_disable_ddio(ioc);
  ioc_info(ioc, "WarpDrive : Direct IO is disabled globally as number of drives > 1\n");
  return;
 }
 if ((mpt3sas_config_get_number_pds(ioc, raid_device->handle,
     &num_pds)) || !num_pds) {
  ioc_info(ioc, "WarpDrive : Direct IO is disabled Failure in computing number of drives\n");
  return;
 }

 sz = struct_size(vol_pg0, PhysDisk, num_pds);
 vol_pg0 = kzalloc(sz, GFP_KERNEL);
 if (!vol_pg0) {
  ioc_info(ioc, "WarpDrive : Direct IO is disabled Memory allocation failure for RVPG0\n");
  return;
 }

 if ((mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
      MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
  ioc_info(ioc, "WarpDrive : Direct IO is disabled Failure in retrieving RVPG0\n");
  kfree(vol_pg0);
  return;
 }

 /*
  * WARPDRIVE:If number of physical disks in a volume exceeds the max pds
  * assumed for WARPDRIVE, disable direct I/O
 */
 if (num_pds > MPT_MAX_WARPDRIVE_PDS) {
  ioc_warn(ioc, "WarpDrive : Direct IO is disabled for the drive with handle(0x%04x): num_mem=%d, max_mem_allowed=%d\n",
    raid_device->handle, num_pds, MPT_MAX_WARPDRIVE_PDS);
  kfree(vol_pg0);
  return;
 }
 for (count = 0; count < num_pds; count++) {
  if (mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
      &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM,
      vol_pg0->PhysDisk[count].PhysDiskNum) ||
      le16_to_cpu(pd_pg0.DevHandle) ==
      MPT3SAS_INVALID_DEVICE_HANDLE) {
   ioc_info(ioc, "WarpDrive : Direct IO is disabled for the drive with handle(0x%04x) member handle retrieval failed for member number=%d\n",
     raid_device->handle,
     vol_pg0->PhysDisk[count].PhysDiskNum);
   goto out_error;
  }
  /* Disable direct I/O if member drive lba exceeds 4 bytes */
  dev_max_lba = le64_to_cpu(pd_pg0.DeviceMaxLBA);
  if (dev_max_lba >> 32) {
   ioc_info(ioc, "WarpDrive : Direct IO is disabled for the drive with handle(0x%04x) member handle (0x%04x) unsupported max lba 0x%016llx\n",
     raid_device->handle,
     le16_to_cpu(pd_pg0.DevHandle),
     (u64)dev_max_lba);
   goto out_error;
  }

  raid_device->pd_handle[count] = le16_to_cpu(pd_pg0.DevHandle);
 }

 /*
  * Assumption for WD: Direct I/O is not supported if the volume is
  * not RAID0
 */
 if (raid_device->volume_type != MPI2_RAID_VOL_TYPE_RAID0) {
  ioc_info(ioc, "WarpDrive : Direct IO is disabled for the drive with handle(0x%04x): type=%d, s_sz=%uK, blk_size=%u\n",
    raid_device->handle, raid_device->volume_type,
    (le32_to_cpu(vol_pg0->StripeSize) *
     le16_to_cpu(vol_pg0->BlockSize)) / 1024,
    le16_to_cpu(vol_pg0->BlockSize));
  goto out_error;
 }

 stripe_sz = le32_to_cpu(vol_pg0->StripeSize);
 stripe_exp = find_first_bit(&stripe_sz, 32);
 if (stripe_exp == 32) {
  ioc_info(ioc, "WarpDrive : Direct IO is disabled for the drive with handle(0x%04x) invalid stripe sz %uK\n",
    raid_device->handle,
    (le32_to_cpu(vol_pg0->StripeSize) *
     le16_to_cpu(vol_pg0->BlockSize)) / 1024);
  goto out_error;
 }
 raid_device->stripe_exponent = stripe_exp;
 block_sz = le16_to_cpu(vol_pg0->BlockSize);
 block_exp = find_first_bit(&block_sz, 16);
 if (block_exp == 16) {
  ioc_info(ioc, "WarpDrive : Direct IO is disabled for the drive with handle(0x%04x) invalid block sz %u\n",
    raid_device->handle, le16_to_cpu(vol_pg0->BlockSize));
  goto out_error;
 }
 raid_device->block_exponent = block_exp;
 raid_device->direct_io_enabled = 1;

 ioc_info(ioc, "WarpDrive : Direct IO is Enabled for the drive with handle(0x%04x)\n",
   raid_device->handle);
 /*
  * WARPDRIVE: Though the following fields are not used for direct IO,
  * stored for future purpose:
 */
 raid_device->max_lba = le64_to_cpu(vol_pg0->MaxLBA);
 raid_device->stripe_sz = le32_to_cpu(vol_pg0->StripeSize);
 raid_device->block_sz = le16_to_cpu(vol_pg0->BlockSize);


 kfree(vol_pg0);
 return;

out_error:
 raid_device->direct_io_enabled = 0;
 for (count = 0; count < num_pds; count++)
  raid_device->pd_handle[count] = 0;
 kfree(vol_pg0);
 return;
}

/**
 * mpt3sas_setup_direct_io - setup MPI request for WARPDRIVE Direct I/O
 * @ioc: per adapter object
 * @scmd: pointer to scsi command object
 * @raid_device: pointer to raid device data structure
 * @mpi_request: pointer to the SCSI_IO reqest message frame
 */
void
mpt3sas_setup_direct_io(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
 struct _raid_device *raid_device, Mpi25SCSIIORequest_t *mpi_request)
{
 sector_t v_lba, p_lba, stripe_off, column, io_size;
 u32 stripe_sz, stripe_exp;
 u8 num_pds, cmd = scmd->cmnd[0];
 struct scsiio_tracker *st = scsi_cmd_priv(scmd);

 if (cmd != READ_10 && cmd != WRITE_10 &&
     cmd != READ_16 && cmd != WRITE_16)
  return;

 if (cmd == READ_10 || cmd == WRITE_10)
  v_lba = get_unaligned_be32(&mpi_request->CDB.CDB32[2]);
 else
  v_lba = get_unaligned_be64(&mpi_request->CDB.CDB32[2]);

 io_size = scsi_bufflen(scmd) >> raid_device->block_exponent;

 if (v_lba + io_size - 1 > raid_device->max_lba)
  return;

 stripe_sz = raid_device->stripe_sz;
 stripe_exp = raid_device->stripe_exponent;
 stripe_off = v_lba & (stripe_sz - 1);

 /* Return unless IO falls within a stripe */
 if (stripe_off + io_size > stripe_sz)
  return;

 num_pds = raid_device->num_pds;
 p_lba = v_lba >> stripe_exp;
 column = sector_div(p_lba, num_pds);
 p_lba = (p_lba << stripe_exp) + stripe_off;
 mpi_request->DevHandle = cpu_to_le16(raid_device->pd_handle[column]);

 if (cmd == READ_10 || cmd == WRITE_10)
  put_unaligned_be32(lower_32_bits(p_lba),
       &mpi_request->CDB.CDB32[2]);
 else
  put_unaligned_be64(p_lba, &mpi_request->CDB.CDB32[2]);

 st->direct_io = 1;
}