/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2002 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * s1394_fcp.c
 *    1394 Services Layer FCP Support Routines
 */

#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/cmn_err.h>
#include <sys/types.h>
#include <sys/kmem.h>

#include <sys/1394/t1394.h>
#include <sys/1394/s1394.h>
#include <sys/1394/h1394.h>

static int s1394_fcp_register_common(s1394_target_t *target,
    t1394_fcp_evts_t *evts, s1394_fa_type_t type, s1394_fa_descr_t *descr);
static int s1394_fcp_unregister_common(s1394_target_t *target,
    s1394_fa_type_t type);
static void s1394_fcp_resp_recv_write_request(cmd1394_cmd_t *req);
static void s1394_fcp_cmd_recv_write_request(cmd1394_cmd_t *req);
static void s1394_fcp_recv_write_request(cmd1394_cmd_t *req,
    s1394_fa_type_t type);
static void s1394_fcp_recv_write_unclaimed(s1394_hal_t *hal,
    cmd1394_cmd_t *req);


/*
 * number of retries to notify registered targets in case target list
 * changes while the list rwlock is dropped for the time of callback
 */
uint_t s1394_fcp_notify_retry_cnt = 3;

s1394_fa_descr_t s1394_fcp_ctl_descr = {
        IEC61883_FCP_RESP_ADDR,
        IEC61883_FCP_RESP_SIZE,
        T1394_ADDR_WRENBL,
        { NULL, s1394_fcp_resp_recv_write_request, NULL },
        IEC61883_FCP_CMD_ADDR
};

s1394_fa_descr_t s1394_fcp_tgt_descr = {
        IEC61883_FCP_CMD_ADDR,
        IEC61883_FCP_CMD_SIZE,
        T1394_ADDR_WRENBL,
        { NULL, s1394_fcp_cmd_recv_write_request, NULL },
        IEC61883_FCP_RESP_ADDR
};


int
s1394_fcp_hal_init(s1394_hal_t *hal)
{
        int     ret = DDI_SUCCESS;

        if ((ddi_prop_exists(DDI_DEV_T_ANY, hal->halinfo.dip, DDI_PROP_DONTPASS,
            "h1394-fcp-claim-on-demand")) == 0) {
                /* if not on-demand, claim addresses now */
                ret = s1394_fa_claim_addr(hal, S1394_FA_TYPE_FCP_CTL,
                                        &s1394_fcp_ctl_descr);
                if (ret == DDI_SUCCESS) {
                        ret = s1394_fa_claim_addr(hal, S1394_FA_TYPE_FCP_TGT,
                                                &s1394_fcp_tgt_descr);
                        if (ret != DDI_SUCCESS) {
                                s1394_fa_free_addr(hal, S1394_FA_TYPE_FCP_CTL);
                        }
                }
        }

        return (ret);
}

int
s1394_fcp_register_ctl(s1394_target_t *target, t1394_fcp_evts_t *evts)
{
        return (s1394_fcp_register_common(target, evts, S1394_FA_TYPE_FCP_CTL,
                        &s1394_fcp_ctl_descr));
}

int
s1394_fcp_register_tgt(s1394_target_t *target, t1394_fcp_evts_t *evts)
{
        return (s1394_fcp_register_common(target, evts, S1394_FA_TYPE_FCP_TGT,
                        &s1394_fcp_tgt_descr));
}

int
s1394_fcp_unregister_ctl(s1394_target_t *target)
{
        return (s1394_fcp_unregister_common(target, S1394_FA_TYPE_FCP_CTL));
}

int
s1394_fcp_unregister_tgt(s1394_target_t *target)
{
        return (s1394_fcp_unregister_common(target, S1394_FA_TYPE_FCP_TGT));
}


static int
s1394_fcp_register_common(s1394_target_t *target, t1394_fcp_evts_t *evts,
    s1394_fa_type_t type, s1394_fa_descr_t *descr)
{
        s1394_hal_t     *hal = target->on_hal;
        s1394_fcp_target_t *fcp;

        rw_enter(&hal->target_list_rwlock, RW_WRITER);

        if (s1394_fa_list_is_empty(hal, type)) {
                if (s1394_fa_claim_addr(hal, type, descr) != DDI_SUCCESS) {
                        rw_exit(&hal->target_list_rwlock);
                        return (DDI_FAILURE);
                }
        }

        /* Add on the target list */
        s1394_fa_list_add(hal, target, type);

        fcp = &target->target_fa[type].fat_u.fcp;
        fcp->fc_evts = *evts;

        rw_exit(&hal->target_list_rwlock);

        return (DDI_SUCCESS);
}

static int
s1394_fcp_unregister_common(s1394_target_t *target, s1394_fa_type_t type)
{
        s1394_hal_t     *hal = target->on_hal;
        int             result;

        rw_enter(&hal->target_list_rwlock, RW_WRITER);

        result = s1394_fa_list_remove(hal, target, type);
        if (result == DDI_SUCCESS) {
                if (s1394_fa_list_is_empty(hal, type)) {
                        s1394_fa_free_addr(hal, type);
                }
        }

        rw_exit(&hal->target_list_rwlock);

        return (result);
}

/*
 * s1394_fcp_write_check_cmd()
 *    Check if an FCP command is formed correctly;
 *    set cmd_result and return DDI_FAILURE if not.
 */
int
s1394_fcp_write_check_cmd(cmd1394_cmd_t *cmd)
{
        int     len;

        /* 4-byte writes must be quadlet writes */
        if (cmd->cmd_type == CMD1394_ASYNCH_WR_BLOCK) {
                len = cmd->cmd_u.b.blk_length;
                if (len == 4) {
                        cmd->cmd_result = CMD1394_ETYPE_ERROR;
                        return (DDI_FAILURE);
                }
        } else {
                len = 4;
        }

        /*
         * request must be within FCP range. we avoid extra checks by
         * using the fact that command and response are of the same size
         */
        if ((cmd->cmd_addr & IEEE1394_ADDR_OFFSET_MASK) + len >
            IEC61883_FCP_CMD_SIZE) {
                cmd->cmd_result = CMD1394_EADDRESS_ERROR;
                return (DDI_FAILURE);
        }

        /* some options don't make sense for FCP commands */
        if (cmd->cmd_options & CMD1394_OVERRIDE_ADDR) {
                cmd->cmd_result = CMD1394_EINVALID_COMMAND;
                return (DDI_FAILURE);
        }

        return (DDI_SUCCESS);
}

static void
s1394_fcp_resp_recv_write_request(cmd1394_cmd_t *req)
{
        s1394_fcp_recv_write_request(req, S1394_FA_TYPE_FCP_CTL);
}

static void
s1394_fcp_cmd_recv_write_request(cmd1394_cmd_t *req)
{
        s1394_fcp_recv_write_request(req, S1394_FA_TYPE_FCP_TGT);
}

/*
 * s1394_fcp_recv_write_request()
 *    Common write request handler
 */
static void
s1394_fcp_recv_write_request(cmd1394_cmd_t *req, s1394_fa_type_t type)
{
        s1394_hal_t     *hal = (s1394_hal_t *)req->cmd_callback_arg;
        s1394_target_t  *target;
        s1394_fa_target_t *fat;
        uint_t          saved_gen;
        int             num_retries = 0;
        int             (*cb)(cmd1394_cmd_t *req);
        boolean_t       restored = B_FALSE;
        int             ret = T1394_REQ_UNCLAIMED;

        rw_enter(&hal->target_list_rwlock, RW_READER);

start:
        target = hal->hal_fa[type].fal_head;

        if (target) {
                s1394_fa_restore_cmd(hal, req);
                restored = B_TRUE;

                /* Find a target that claims the request */
                do {
                        fat = &target->target_fa[type];

                        cb = fat->fat_u.fcp.fc_evts.fcp_write_request;
                        if (cb == NULL) {
                                continue;
                        }
                        req->cmd_callback_arg = fat->fat_u.fcp.fc_evts.fcp_arg;

                        saved_gen = s1394_fa_list_gen(hal, type);

                        rw_exit(&hal->target_list_rwlock);
                        ret = cb(req);
                        rw_enter(&hal->target_list_rwlock, RW_READER);

                        if (ret == T1394_REQ_CLAIMED) {
                                break;
                        }

                        /*
                         * List could change while we dropped the lock. In such
                         * case, start all over again, because missing a write
                         * request can have more serious consequences for a
                         * target than receiving same request more than once
                         */
                        if (saved_gen != s1394_fa_list_gen(hal, type)) {
                                num_retries++;
                                if (num_retries <= s1394_fcp_notify_retry_cnt) {
                                        goto start;
                                } else {
                                        break;
                                }
                        }

                        target = fat->fat_next;
                } while (target != NULL);
        }

        rw_exit(&hal->target_list_rwlock);

        if (ret != T1394_REQ_CLAIMED) {
                if (restored) {
                        s1394_fa_convert_cmd(hal, req);
                }
                s1394_fcp_recv_write_unclaimed(hal, req);
        }
}

/*
 * none of the targets claimed the request - send an appropriate response
 */
static void
s1394_fcp_recv_write_unclaimed(s1394_hal_t *hal, cmd1394_cmd_t *req)
{
        req->cmd_result = IEEE1394_RESP_ADDRESS_ERROR;
        (void) s1394_send_response(hal, req);
}