/*
 * This file is mostly copied from libzbc.
 *
 * Copyright (C) 2009-2014, HGST, Inc.  All rights reserved.
 *
 * This software is distributed under the terms of the BSD 2-clause license,
 * "as is," without technical support, and WITHOUT ANY WARRANTY, without
 * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE. You should have received a copy of the BSD 2-clause license along
 * with libzbc. If not, see  <http://opensource.org/licenses/BSD-2-Clause>.
 *
 * Authors: Damien Le Moal (damien.lemoal@hgst.com)
 *          Christophe Louargant (christophe.louargant@hgst.com)
 *
 * Integrated into f2fs-tools by:
 *          Jaegeuk Kim (jaegeuk@kernel.org)
 */

#include <f2fs_fs.h>

#include "zbc.h"

static struct zbc_sg_cmd_s
{

    char                *cdb_cmd_name;
    int                 cdb_opcode;
    int                 cdb_sa;
    size_t              cdb_length;
    int			dir;

} zbc_sg_cmd_list[ZBC_SG_CMD_NUM] = {

    /* ZBC_SG_TEST_UNIT_READY */
    {
        "TEST UNIT READY",
        ZBC_SG_TEST_UNIT_READY_CDB_OPCODE,
        0,
        ZBC_SG_TEST_UNIT_READY_CDB_LENGTH,
	SG_DXFER_NONE
    },

    /* ZBC_SG_INQUIRY */
    {
        "INQUIRY",
        ZBC_SG_INQUIRY_CDB_OPCODE,
        0,
        ZBC_SG_INQUIRY_CDB_LENGTH,
	SG_DXFER_FROM_DEV
    },

    /* ZBC_SG_READ_CAPACITY */
    {
        "READ CAPACITY 16",
        ZBC_SG_READ_CAPACITY_CDB_OPCODE,
        ZBC_SG_READ_CAPACITY_CDB_SA,
        ZBC_SG_READ_CAPACITY_CDB_LENGTH,
	SG_DXFER_FROM_DEV
    },

    /* ZBC_SG_READ */
    {
        "READ 16",
        ZBC_SG_READ_CDB_OPCODE,
        0,
        ZBC_SG_READ_CDB_LENGTH,
	SG_DXFER_FROM_DEV
    },

    /* ZBC_SG_WRITE */
    {
        "WRITE 16",
        ZBC_SG_WRITE_CDB_OPCODE,
        0,
        ZBC_SG_WRITE_CDB_LENGTH,
	SG_DXFER_TO_DEV
    },

    /* ZBC_SG_SYNC_CACHE */
    {
        "SYNCHRONIZE CACHE 16",
        ZBC_SG_SYNC_CACHE_CDB_OPCODE,
        0,
        ZBC_SG_SYNC_CACHE_CDB_LENGTH,
	SG_DXFER_NONE
    },

    /* ZBC_SG_REPORT_ZONES */
    {
        "REPORT ZONES",
        ZBC_SG_REPORT_ZONES_CDB_OPCODE,
        ZBC_SG_REPORT_ZONES_CDB_SA,
        ZBC_SG_REPORT_ZONES_CDB_LENGTH,
	SG_DXFER_FROM_DEV
    },

    /* ZBC_SG_OPEN_ZONE */
    {
        "OPEN ZONE",
        ZBC_SG_OPEN_ZONE_CDB_OPCODE,
        ZBC_SG_OPEN_ZONE_CDB_SA,
        ZBC_SG_OPEN_ZONE_CDB_LENGTH,
	SG_DXFER_NONE
    },

    /* ZBC_SG_CLOSE_ZONE */
    {
        "CLOSE ZONE",
        ZBC_SG_CLOSE_ZONE_CDB_OPCODE,
        ZBC_SG_CLOSE_ZONE_CDB_SA,
        ZBC_SG_CLOSE_ZONE_CDB_LENGTH,
	SG_DXFER_NONE
    },

    /* ZBC_SG_FINISH_ZONE */
    {
        "FINISH ZONE",
        ZBC_SG_FINISH_ZONE_CDB_OPCODE,
        ZBC_SG_FINISH_ZONE_CDB_SA,
        ZBC_SG_FINISH_ZONE_CDB_LENGTH,
	SG_DXFER_NONE
    },

    /* ZBC_SG_RESET_WRITE_POINTER */
    {
        "RESET WRITE POINTER",
        ZBC_SG_RESET_WRITE_POINTER_CDB_OPCODE,
        ZBC_SG_RESET_WRITE_POINTER_CDB_SA,
        ZBC_SG_RESET_WRITE_POINTER_CDB_LENGTH,
	SG_DXFER_NONE
    },

    /* ZBC_SG_SET_ZONES */
    {
        "SET ZONES",
        ZBC_SG_SET_ZONES_CDB_OPCODE,
        ZBC_SG_SET_ZONES_CDB_SA,
        ZBC_SG_SET_ZONES_CDB_LENGTH,
	SG_DXFER_NONE
    },

    /* ZBC_SG_SET_WRITE_POINTER */
    {
        "SET WRITE POINTER",
        ZBC_SG_SET_WRITE_POINTER_CDB_OPCODE,
        ZBC_SG_SET_WRITE_POINTER_CDB_SA,
        ZBC_SG_SET_WRITE_POINTER_CDB_LENGTH,
	SG_DXFER_NONE
    },

    /* ZBC_SG_ATA12 */
    {
	"ATA 12",
	ZBC_SG_ATA12_CDB_OPCODE,
	0,
        ZBC_SG_ATA12_CDB_LENGTH,
	0
    },

    /* ZBC_SG_ATA16 */
    {
	"ATA 16",
	ZBC_SG_ATA16_CDB_OPCODE,
	0,
        ZBC_SG_ATA16_CDB_LENGTH,
	0
    }
};

static void zbc_sg_cmd_set_bytes(uint8_t *cmd, void *buf, int bytes)
{
	uint8_t *v = (uint8_t *) buf;
	int i;

	for (i = 0; i < bytes; i++) {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
		/* The least significant byte is stored last */
		cmd[bytes - i - 1] = v[i];
#else
		/* The most significant byte is stored first */
		cmd[i] = v[i];
#endif
	}
	return;
}

static void zbc_sg_cmd_get_bytes(uint8_t *val, union converter *conv, int bytes)
{
	uint8_t *v = (uint8_t *) val;
	int i;

	memset(conv, 0, sizeof(union converter));

	for(i = 0; i < bytes; i++) {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
		conv->val_buf[bytes - i - 1] = v[i];
#else
		conv->val_buf[i] = v[i];
#endif
	}
	return;
}

static inline void zbc_sg_cmd_set_int64(uint8_t *buf, uint64_t val)
{
	zbc_sg_cmd_set_bytes(buf, &val, 8);
	return;
}

static inline void zbc_sg_cmd_set_int32(uint8_t *buf, uint32_t val)
{
	zbc_sg_cmd_set_bytes(buf, &val, 4);
	return;
}

static inline uint32_t zbc_sg_cmd_get_int32(uint8_t *buf)
{
	union converter conv;

	zbc_sg_cmd_get_bytes(buf, &conv, 4);
	return conv.val32;
}

static inline uint64_t zbc_sg_cmd_get_int64(uint8_t *buf)
{
	union converter conv;

	zbc_sg_cmd_get_bytes(buf, &conv, 8);
	return( conv.val64 );

}

static void zbc_sg_cmd_destroy(zbc_sg_cmd_t *cmd)
{
	/* Free the command */
	if (!cmd)
		return;

	if (cmd->out_buf && cmd->out_buf_needfree) {
		free(cmd->out_buf);
		cmd->out_buf = NULL;
		cmd->out_bufsz = 0;
	}
	memset(cmd, 0, sizeof(*cmd));
	return;
}

static int zbc_sg_cmd_init(zbc_sg_cmd_t *cmd, int cmd_code,
				uint8_t *out_buf, size_t out_bufsz)
{
	int ret = 0;

	if ((!cmd) || (cmd_code < 0) || (cmd_code >= ZBC_SG_CMD_NUM) ) {
		ERR_MSG("Invalid command specified\n");
		return -EINVAL;
	}

	/* Set command */
	memset(cmd, 0, sizeof(zbc_sg_cmd_t));
	cmd->code = cmd_code;
	cmd->cdb_sz = zbc_sg_cmd_list[cmd_code].cdb_length;
	cmd->cdb_opcode = zbc_sg_cmd_list[cmd_code].cdb_opcode;
	cmd->cdb_sa = zbc_sg_cmd_list[cmd_code].cdb_sa;

	/* Set output buffer */
	if (out_buf) {
		/* Set specified buffer */
		if (!out_bufsz) {
			ERR_MSG("Invalid 0 output buffer size\n");
			ret = -EINVAL;
			goto out;
		}
		cmd->out_buf = out_buf;
		cmd->out_bufsz = out_bufsz;
	} else if (out_bufsz) {
		/* Allocate a buffer */
		ret = posix_memalign((void **)&cmd->out_buf,
				sysconf(_SC_PAGESIZE), out_bufsz);
		if ( ret != 0 ) {
			ERR_MSG("No memory for output buffer (%zu B)\n",
					out_bufsz);
			ret = -ENOMEM;
			goto out;
		}
		memset(cmd->out_buf, 0, out_bufsz);
		cmd->out_bufsz = out_bufsz;
		cmd->out_buf_needfree = 1;
	}

	/* OK: setup SGIO header */
	memset(&cmd->io_hdr, 0, sizeof(sg_io_hdr_t));

	cmd->io_hdr.interface_id    = 'S';
	cmd->io_hdr.timeout         = 20000;
	cmd->io_hdr.flags           = 0; //SG_FLAG_DIRECT_IO;

	cmd->io_hdr.cmd_len         = cmd->cdb_sz;
	cmd->io_hdr.cmdp            = &cmd->cdb[0];

	cmd->io_hdr.dxfer_direction = zbc_sg_cmd_list[cmd_code].dir;
	cmd->io_hdr.dxfer_len       = cmd->out_bufsz;
	cmd->io_hdr.dxferp          = cmd->out_buf;

	cmd->io_hdr.mx_sb_len       = ZBC_SG_SENSE_MAX_LENGTH;
	cmd->io_hdr.sbp             = cmd->sense_buf;
out:
	if (ret != 0)
		zbc_sg_cmd_destroy(cmd);

	return ret;
}

static char *zbc_sg_cmd_name(zbc_sg_cmd_t *cmd)
{
	char *name;

	if ((cmd->code >= 0)
			&& (cmd->code < ZBC_SG_CMD_NUM)) {
		name = zbc_sg_cmd_list[cmd->code].cdb_cmd_name;
	} else {
		name = "(UNKNOWN COMMAND)";
	}

	return name;
}

static void zbc_sg_set_sense(struct f2fs_configuration *c, uint8_t *sense_buf)
{
	if (sense_buf == NULL) {
		c->zbd_errno.sk       = 0x00;
		c->zbd_errno.asc_ascq = 0x0000;
	} else {
		if ((sense_buf[0] & 0x7F) == 0x72
				|| (sense_buf[0] & 0x7F) == 0x73) {
			/* store sense key, ASC/ASCQ */
			c->zbd_errno.sk       = sense_buf[1] & 0x0F;
			c->zbd_errno.asc_ascq = ((int)sense_buf[2] << 8) |
							(int)sense_buf[3];
		} else if ((sense_buf[0] & 0x7F) == 0x70
				|| (sense_buf[0] & 0x7F) == 0x71) {
			/* store sense key, ASC/ASCQ */
			c->zbd_errno.sk       = sense_buf[2] & 0x0F;
			c->zbd_errno.asc_ascq = ((int)sense_buf[12] << 8) |
							(int)sense_buf[13];
		}
	}
	return;
}

static int zbc_sg_cmd_exec(struct f2fs_configuration *c, zbc_sg_cmd_t *cmd)
{
	int ret;

	/* Send the SG_IO command */
	ret = ioctl(c->fd, SG_IO, &cmd->io_hdr);
	if (ret) {
		ERR_MSG("SG_IO ioctl failed (%s)\n", strerror(errno));
		goto out;
	}

	/* Reset errno */
	zbc_sg_set_sense(c, NULL);

	DBG(1, "Command %s done: status 0x%02x (0x%02x), host status 0x%04x, driver status 0x%04x (flags 0x%04x)\n",
			zbc_sg_cmd_name(cmd),
			(unsigned int)cmd->io_hdr.status,
			(unsigned int)cmd->io_hdr.masked_status,
			(unsigned int)cmd->io_hdr.host_status,
			(unsigned int)zbc_sg_cmd_driver_status(cmd),
			(unsigned int)zbc_sg_cmd_driver_flags(cmd));

	/* Check status */
	if (((cmd->code == ZBC_SG_ATA12) || (cmd->code == ZBC_SG_ATA16))
			&& (cmd->cdb[2] & (1 << 5)) ) {

		/* ATA command status */
		if (cmd->io_hdr.status != ZBC_SG_CHECK_CONDITION) {
			zbc_sg_set_sense(c, cmd->sense_buf);
			ret = -EIO;
			goto out;
		}

		if ((zbc_sg_cmd_driver_status(cmd) == ZBC_SG_DRIVER_SENSE)
				&& (cmd->io_hdr.sb_len_wr > 21)
				&& (cmd->sense_buf[21] != 0x50) ) {
			zbc_sg_set_sense(c, cmd->sense_buf);
			ret = -EIO;
			goto out;
		}
		cmd->io_hdr.status = 0;
	}

	if (cmd->io_hdr.status
			|| (cmd->io_hdr.host_status != ZBC_SG_DID_OK)
			|| (zbc_sg_cmd_driver_status(cmd) &&
			(zbc_sg_cmd_driver_status(cmd) != ZBC_SG_DRIVER_SENSE)) ) {

		ERR_MSG("Command %s failed with status 0x%02x (0x%02x), host status 0x%04x, driver status 0x%04x (flags 0x%04x)\n",
				zbc_sg_cmd_name(cmd),
				(unsigned int)cmd->io_hdr.status,
				(unsigned int)cmd->io_hdr.masked_status,
				(unsigned int)cmd->io_hdr.host_status,
				(unsigned int)zbc_sg_cmd_driver_status(cmd),
				(unsigned int)zbc_sg_cmd_driver_flags(cmd));
		zbc_sg_set_sense(c, cmd->sense_buf);
		ret = -EIO;
		goto out;
	}

	if (cmd->io_hdr.resid) {
		ERR_MSG("Transfer missing %d B of data\n",
				cmd->io_hdr.resid);
		cmd->out_bufsz -= cmd->io_hdr.resid;
	}
out:
	return ret;
}

#define ZBC_SCSI_REPORT_ZONES_BUFSZ     524288

int zbc_scsi_report_zones(struct f2fs_configuration *c)
{
	zbc_sg_cmd_t cmd;
	uint8_t *buf;
	zbc_zone_t *z, *zones = NULL;
	int i, buf_nz, ret;
	size_t bufsz;
	uint32_t idx = 0, nr_zones = 0;
	uint64_t next_lba = 0;
	int phase = 0;
next:
	bufsz = ZBC_ZONE_DESCRIPTOR_OFFSET;
	if (phase) {
		if (c->nr_zones - idx == 0)
			return 0;

		bufsz += (size_t)(c->nr_zones - idx) *
					ZBC_ZONE_DESCRIPTOR_LENGTH;
		if (bufsz > ZBC_SCSI_REPORT_ZONES_BUFSZ)
			bufsz = ZBC_SCSI_REPORT_ZONES_BUFSZ;
	}

	/* For in kernel ATA translation: align to 512 B */
	bufsz = (bufsz + 511) & ~511;

	/* Allocate and intialize report zones command */
	ret = zbc_sg_cmd_init(&cmd, ZBC_SG_REPORT_ZONES, NULL, bufsz);
	if (ret) {
		ERR_MSG("zbc_sg_cmd_init failed\n");
		return ret;
	}

	/* Fill command CDB:
	 * +=============================================================================+
	 * |  Bit|   7    |   6    |   5    |   4    |   3    |   2    |   1    |   0    |
	 * |Byte |        |        |        |        |        |        |        |        |
	 * |=====+==========================+============================================|
	 * | 0   |                           Operation Code (95h)                        |
	 * |-----+-----------------------------------------------------------------------|
	 * | 1   |      Reserved            |       Service Action (00h)                 |
	 * |-----+-----------------------------------------------------------------------|
	 * | 2   | (MSB)                                                                 |
	 * |- - -+---                        Zone Start LBA                           ---|
	 * | 9   |                                                                 (LSB) |
	 * |-----+-----------------------------------------------------------------------|
	 * | 10  | (MSB)                                                                 |
	 * |- - -+---                        Allocation Length                        ---|
	 * | 13  |                                                                 (LSB) |
	 * |-----+-----------------------------------------------------------------------|
	 * | 14  |Partial |Reserved|                 Reporting Options                   |
	 * |-----+-----------------------------------------------------------------------|
	 * | 15  |                           Control                                     |
	 * +=============================================================================+
	 */
	cmd.cdb[0] = ZBC_SG_REPORT_ZONES_CDB_OPCODE;
	cmd.cdb[1] = ZBC_SG_REPORT_ZONES_CDB_SA;
	zbc_sg_cmd_set_int64(&cmd.cdb[2], next_lba);
	zbc_sg_cmd_set_int32(&cmd.cdb[10], (unsigned int) bufsz);
	cmd.cdb[14] = 0;

	/* Send the SG_IO command */
	ret = zbc_sg_cmd_exec(c, &cmd);
	if (ret != 0)
		goto out;

	if (cmd.out_bufsz < ZBC_ZONE_DESCRIPTOR_OFFSET) {
		ERR_MSG("Not enough data received (need at least %d B, got %zu B)\n",
				ZBC_ZONE_DESCRIPTOR_OFFSET,
				cmd.out_bufsz);
		ret = -EIO;
		goto out;
	}

	/* Process output:
	 * +=============================================================================+
	 * |  Bit|   7    |   6    |   5    |   4    |   3    |   2    |   1    |   0    |
	 * |Byte |        |        |        |        |        |        |        |        |
	 * |=====+=======================================================================|
	 * |  0  | (MSB)                                                                 |
	 * |- - -+---               Zone List Length (n - 64)                         ---|
	 * |  3  |                                                                 (LSB) |
	 * |-----+-----------------------------------------------------------------------|
	 * |  4  |              Reserved             |               Same                |
	 * |-----+-----------------------------------------------------------------------|
	 * |  5  |                                                                       |
	 * |- - -+---                        Reserved                                 ---|
	 * |  7  |                                                                       |
	 * |-----+-----------------------------------------------------------------------|
	 * |  8  | (MSB)                                                                 |
	 * |- - -+---                      Maximum LBA                                ---|
	 * | 15  |                                                                 (LSB) |
	 * |-----+-----------------------------------------------------------------------|
	 * | 16  | (MSB)                                                                 |
	 * |- - -+---                        Reserved                                 ---|
	 * | 63  |                                                                 (LSB) |
	 * |=====+=======================================================================|
	 * |     |                       Vendor-Specific Parameters                      |
	 * |=====+=======================================================================|
	 * | 64  | (MSB)                                                                 |
	 * |- - -+---                  Zone Descriptor [first]                        ---|
	 * | 127 |                                                                 (LSB) |
	 * |-----+-----------------------------------------------------------------------|
	 * |                                    .                                        |
	 * |                                    .                                        |
	 * |                                    .                                        |
	 * |-----+-----------------------------------------------------------------------|
	 * |n-63 |                                                                       |
	 * |- - -+---                   Zone Descriptor [last]                        ---|
	 * | n   |                                                                       |
	 * +=============================================================================+
	 */

	/* Get number of zones in result */
	buf = (uint8_t *)cmd.out_buf;
	nr_zones = zbc_sg_cmd_get_int32(buf) / ZBC_ZONE_DESCRIPTOR_LENGTH;

	/* read # of zones and then get all the zone info */
	if (phase == 0) {
		c->nr_zones = nr_zones;
		c->nr_conventional = 0;
		zbc_sg_cmd_destroy(&cmd);
		phase++;
		goto next;
	}

	if (nr_zones > c->nr_zones - idx)
		nr_zones = c->nr_zones - idx;

	buf_nz = (cmd.out_bufsz - ZBC_ZONE_DESCRIPTOR_OFFSET) /
						ZBC_ZONE_DESCRIPTOR_LENGTH;
	if (nr_zones > buf_nz)
		nr_zones = buf_nz;

	if (!nr_zones) {
		ERR_MSG("No more zones\n");
		goto out;
	}

	/* Allocate zone array */
	zones = (zbc_zone_t *)malloc(sizeof(zbc_zone_t) * nr_zones);
	if (!zones) {
		ERR_MSG("No memory\n");
		goto out;
	}
	memset(zones, 0, sizeof(zbc_zone_t) * nr_zones);

	/* Get zone descriptors:
	 * +=============================================================================+
	 * |  Bit|   7    |   6    |   5    |   4    |   3    |   2    |   1    |   0    |
	 * |Byte |        |        |        |        |        |        |        |        |
	 * |=====+=======================================================================|
	 * |  0  |             Reserved              |            Zone type              |
	 * |-----+-----------------------------------------------------------------------|
	 * |  1  |          Zone condition           |    Reserved     |non-seq |  Reset |
	 * |-----+-----------------------------------------------------------------------|
	 * |  2  |                                                                       |
	 * |- - -+---                             Reserved                            ---|
	 * |  7  |                                                                       |
	 * |-----+-----------------------------------------------------------------------|
	 * |  8  | (MSB)                                                                 |
	 * |- - -+---                           Zone Length                           ---|
	 * | 15  |                                                                 (LSB) |
	 * |-----+-----------------------------------------------------------------------|
	 * | 16  | (MSB)                                                                 |
	 * |- - -+---                          Zone Start LBA                         ---|
	 * | 23  |                                                                 (LSB) |
	 * |-----+-----------------------------------------------------------------------|
	 * | 24  | (MSB)                                                                 |
	 * |- - -+---                         Write Pointer LBA                       ---|
	 * | 31  |                                                                 (LSB) |
	 * |-----+-----------------------------------------------------------------------|
	 * | 32  |                                                                       |
	 * |- - -+---                             Reserved                            ---|
	 * | 63  |                                                                       |
	 * +=============================================================================+
	 */
	buf += ZBC_ZONE_DESCRIPTOR_OFFSET;

	for(i = 0; i < nr_zones; i++) {
		zones[i].zbz_type = buf[0] & 0x0f;
		zones[i].zbz_condition = (buf[1] >> 4) & 0x0f;
		zones[i].zbz_length = zbc_sg_cmd_get_int64(&buf[8]);
		zones[i].zbz_start = zbc_sg_cmd_get_int64(&buf[16]);
		zones[i].zbz_write_pointer = zbc_sg_cmd_get_int64(&buf[24]);
		zones[i].zbz_flags = buf[1] & 0x03;

		buf += ZBC_ZONE_DESCRIPTOR_LENGTH;
	}

	for (i = 0; i < nr_zones; i++) {
		z = &zones[i];
		if ( zbc_zone_conventional(z) ) {
			c->nr_conventional++;
			DBG(1, "Zone %05d: type 0x%x (%s), cond 0x%x (%s), LBA %llu, %llu sectors, wp N/A\n",
				i + idx,
				zbc_zone_type(z),
				zbc_zone_type_str(zbc_zone_type(z)),
				zbc_zone_condition(z),
				zbc_zone_condition_str(zbc_zone_condition(z)),
				zbc_zone_start_lba(z),
				zbc_zone_length(z));
		} else {
			DBG(1, "Zone %05d: type 0x%x (%s), cond 0x%x (%s), need_reset %d, non_seq %d, LBA %llu, %llu sectors, wp %llu\n",
				i + idx,
				zbc_zone_type(z),
				zbc_zone_type_str(zbc_zone_type(z)),
				zbc_zone_condition(z),
				zbc_zone_condition_str(zbc_zone_condition(z)),
				zbc_zone_need_reset(z),
				zbc_zone_non_seq(z),
				zbc_zone_start_lba(z),
				zbc_zone_length(z),
				zbc_zone_wp_lba(z));
		}
	}

	idx += nr_zones;
	next_lba = zones[nr_zones - 1].zbz_start + zones[nr_zones - 1].zbz_length;
	c->zone_sectors = zones[nr_zones - 1].zbz_length;
	phase++;
	zbc_sg_cmd_destroy(&cmd);
	free(zones);
	goto next;
out:
	zbc_sg_cmd_destroy(&cmd);
	return ret;
}