drivers/scsi/esas2r/esas2r_targdb.c - third_party/linux - Git at Google

 /*
  *  linux/drivers/scsi/esas2r/esas2r_targdb.c
  *      For use with ATTO ExpressSAS R6xx SAS/SATA RAID controllers
  *
  *  Copyright (c) 2001-2013 ATTO Technology, Inc.
  *  (mailto:linuxdrivers@attotech.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; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
  * USA.
  */

 #include "esas2r.h"

 void esas2r_targ_db_initialize(struct esas2r_adapter *a)
 {
 	struct esas2r_target *t;

 	for (t = a->targetdb; t < a->targetdb_end; t++) {
 		memset(t, 0, sizeof(struct esas2r_target));

 		t->target_state = TS_NOT_PRESENT;
 		t->buffered_target_state = TS_NOT_PRESENT;
 		t->new_target_state = TS_INVALID;
 	}
 }

 void esas2r_targ_db_remove_all(struct esas2r_adapter *a, bool notify)
 {
 	struct esas2r_target *t;
 	unsigned long flags;

 	for (t = a->targetdb; t < a->targetdb_end; t++) {
 		if (t->target_state != TS_PRESENT)
 			continue;

 		spin_lock_irqsave(&a->mem_lock, flags);
 		esas2r_targ_db_remove(a, t);
 		spin_unlock_irqrestore(&a->mem_lock, flags);

 		if (notify) {
 			esas2r_trace("remove id:%d", esas2r_targ_get_id(t,
 									a));
 			esas2r_target_state_changed(a, esas2r_targ_get_id(t,
 									  a),
 						    TS_NOT_PRESENT);
 		}
 	}
 }

 void esas2r_targ_db_report_changes(struct esas2r_adapter *a)
 {
 	struct esas2r_target *t;
 	unsigned long flags;

 	esas2r_trace_enter();

 	if (test_bit(AF_DISC_PENDING, &a->flags)) {
 		esas2r_trace_exit();
 		return;
 	}

 	for (t = a->targetdb; t < a->targetdb_end; t++) {
 		u8 state = TS_INVALID;

 		spin_lock_irqsave(&a->mem_lock, flags);
 		if (t->buffered_target_state != t->target_state)
 			state = t->buffered_target_state = t->target_state;

 		spin_unlock_irqrestore(&a->mem_lock, flags);
 		if (state != TS_INVALID) {
 			esas2r_trace("targ_db_report_changes:%d",
 				     esas2r_targ_get_id(
 					     t,
 					     a));
 			esas2r_trace("state:%d", state);

 			esas2r_target_state_changed(a,
 						    esas2r_targ_get_id(t,
 								       a),
 						    state);
 		}
 	}

 	esas2r_trace_exit();
 }

 struct esas2r_target *esas2r_targ_db_add_raid(struct esas2r_adapter *a,
 					      struct esas2r_disc_context *
 					      dc)
 {
 	struct esas2r_target *t;

 	esas2r_trace_enter();

 	if (dc->curr_virt_id >= ESAS2R_MAX_TARGETS) {
 		esas2r_bugon();
 		esas2r_trace_exit();
 		return NULL;
 	}

 	t = a->targetdb + dc->curr_virt_id;

 	if (t->target_state == TS_PRESENT) {
 		esas2r_trace_exit();
 		return NULL;
 	}

 	esas2r_hdebug("add RAID %s, T:%d", dc->raid_grp_name,
 		      esas2r_targ_get_id(
 			      t,
 			      a));

 	if (dc->interleave == 0
 	    || dc->block_size  == 0) {
 		/* these are invalid values, don't create the target entry. */

 		esas2r_hdebug("invalid RAID group dimensions");

 		esas2r_trace_exit();

 		return NULL;
 	}

 	t->block_size = dc->block_size;
 	t->inter_byte = dc->interleave;
 	t->inter_block = dc->interleave / dc->block_size;
 	t->virt_targ_id = dc->curr_virt_id;
 	t->phys_targ_id = ESAS2R_TARG_ID_INV;

 	t->flags &= ~TF_PASS_THRU;
 	t->flags |= TF_USED;

 	t->identifier_len = 0;

 	t->target_state = TS_PRESENT;

 	return t;
 }

 struct esas2r_target *esas2r_targ_db_add_pthru(struct esas2r_adapter *a,
 					       struct esas2r_disc_context *dc,
 					       u8 *ident,
 					       u8 ident_len)
 {
 	struct esas2r_target *t;

 	esas2r_trace_enter();

 	if (dc->curr_virt_id >= ESAS2R_MAX_TARGETS) {
 		esas2r_bugon();
 		esas2r_trace_exit();
 		return NULL;
 	}

 	/* see if we found this device before. */

 	t = esas2r_targ_db_find_by_ident(a, ident, ident_len);

 	if (t == NULL) {
 		t = a->targetdb + dc->curr_virt_id;

 		if (ident_len > sizeof(t->identifier)
 		    || t->target_state == TS_PRESENT) {
 			esas2r_trace_exit();
 			return NULL;
 		}
 	}

 	esas2r_hdebug("add PT; T:%d, V:%d, P:%d", esas2r_targ_get_id(t, a),
 		      dc->curr_virt_id,
 		      dc->curr_phys_id);

 	t->block_size = 0;
 	t->inter_byte = 0;
 	t->inter_block = 0;
 	t->virt_targ_id = dc->curr_virt_id;
 	t->phys_targ_id = dc->curr_phys_id;
 	t->identifier_len = ident_len;

 	memcpy(t->identifier, ident, ident_len);

 	t->flags |= TF_PASS_THRU | TF_USED;

 	t->target_state = TS_PRESENT;

 	return t;
 }

 void esas2r_targ_db_remove(struct esas2r_adapter *a, struct esas2r_target *t)
 {
 	esas2r_trace_enter();

 	t->target_state = TS_NOT_PRESENT;

 	esas2r_trace("remove id:%d", esas2r_targ_get_id(t, a));

 	esas2r_trace_exit();
 }

 struct esas2r_target *esas2r_targ_db_find_by_sas_addr(struct esas2r_adapter *a,
 						      u64 *sas_addr)
 {
 	struct esas2r_target *t;

 	for (t = a->targetdb; t < a->targetdb_end; t++)
 		if (t->sas_addr == *sas_addr)
 			return t;

 	return NULL;
 }

 struct esas2r_target *esas2r_targ_db_find_by_ident(struct esas2r_adapter *a,
 						   void *identifier,
 						   u8 ident_len)
 {
 	struct esas2r_target *t;

 	for (t = a->targetdb; t < a->targetdb_end; t++) {
 		if (ident_len == t->identifier_len
 		    && memcmp(&t->identifier[0], identifier,
 			      ident_len) == 0)
 			return t;
 	}

 	return NULL;
 }

 u16 esas2r_targ_db_find_next_present(struct esas2r_adapter *a, u16 target_id)
 {
 	u16 id = target_id + 1;

 	while (id < ESAS2R_MAX_TARGETS) {
 		struct esas2r_target *t = a->targetdb + id;

 		if (t->target_state == TS_PRESENT)
 			break;

 		id++;
 	}

 	return id;
 }

 struct esas2r_target *esas2r_targ_db_find_by_virt_id(struct esas2r_adapter *a,
 						     u16 virt_id)
 {
 	struct esas2r_target *t;

 	for (t = a->targetdb; t < a->targetdb_end; t++) {
 		if (t->target_state != TS_PRESENT)
 			continue;

 		if (t->virt_targ_id == virt_id)
 			return t;
 	}

 	return NULL;
 }

 u16 esas2r_targ_db_get_tgt_cnt(struct esas2r_adapter *a)
 {
 	u16 devcnt = 0;
 	struct esas2r_target *t;
 	unsigned long flags;

 	spin_lock_irqsave(&a->mem_lock, flags);
 	for (t = a->targetdb; t < a->targetdb_end; t++)
 		if (t->target_state == TS_PRESENT)
 			devcnt++;

 	spin_unlock_irqrestore(&a->mem_lock, flags);

 	return devcnt;
 }
	/*
	* linux/drivers/scsi/esas2r/esas2r_targdb.c
	* For use with ATTO ExpressSAS R6xx SAS/SATA RAID controllers
	*
	* Copyright (c) 2001-2013 ATTO Technology, Inc.
	* (mailto:linuxdrivers@attotech.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; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
	* USA.
	*/

	#include "esas2r.h"

	void esas2r_targ_db_initialize(struct esas2r_adapter *a)
	{
	struct esas2r_target *t;

	for (t = a->targetdb; t < a->targetdb_end; t++) {
	memset(t, 0, sizeof(struct esas2r_target));

	t->target_state = TS_NOT_PRESENT;
	t->buffered_target_state = TS_NOT_PRESENT;
	t->new_target_state = TS_INVALID;
	}
	}

	void esas2r_targ_db_remove_all(struct esas2r_adapter *a, bool notify)
	{
	struct esas2r_target *t;
	unsigned long flags;

	for (t = a->targetdb; t < a->targetdb_end; t++) {
	if (t->target_state != TS_PRESENT)
	continue;

	spin_lock_irqsave(&a->mem_lock, flags);
	esas2r_targ_db_remove(a, t);
	spin_unlock_irqrestore(&a->mem_lock, flags);

	if (notify) {
	esas2r_trace("remove id:%d", esas2r_targ_get_id(t,
	a));
	esas2r_target_state_changed(a, esas2r_targ_get_id(t,
	a),
	TS_NOT_PRESENT);
	}
	}
	}

	void esas2r_targ_db_report_changes(struct esas2r_adapter *a)
	{
	struct esas2r_target *t;
	unsigned long flags;

	esas2r_trace_enter();

	if (test_bit(AF_DISC_PENDING, &a->flags)) {
	esas2r_trace_exit();
	return;
	}

	for (t = a->targetdb; t < a->targetdb_end; t++) {
	u8 state = TS_INVALID;

	spin_lock_irqsave(&a->mem_lock, flags);
	if (t->buffered_target_state != t->target_state)
	state = t->buffered_target_state = t->target_state;

	spin_unlock_irqrestore(&a->mem_lock, flags);
	if (state != TS_INVALID) {
	esas2r_trace("targ_db_report_changes:%d",
	esas2r_targ_get_id(
	t,
	a));
	esas2r_trace("state:%d", state);

	esas2r_target_state_changed(a,
	esas2r_targ_get_id(t,
	a),
	state);
	}
	}

	esas2r_trace_exit();
	}

	struct esas2r_target esas2r_targ_db_add_raid(struct esas2r_adapter a,
	struct esas2r_disc_context *
	dc)
	{
	struct esas2r_target *t;

	esas2r_trace_enter();

	if (dc->curr_virt_id >= ESAS2R_MAX_TARGETS) {
	esas2r_bugon();
	esas2r_trace_exit();
	return NULL;
	}

	t = a->targetdb + dc->curr_virt_id;

	if (t->target_state == TS_PRESENT) {
	esas2r_trace_exit();
	return NULL;
	}

	esas2r_hdebug("add RAID %s, T:%d", dc->raid_grp_name,
	esas2r_targ_get_id(
	t,
	a));

	if (dc->interleave == 0
	\|\| dc->block_size == 0) {
	/* these are invalid values, don't create the target entry. */

	esas2r_hdebug("invalid RAID group dimensions");

	esas2r_trace_exit();

	return NULL;
	}

	t->block_size = dc->block_size;
	t->inter_byte = dc->interleave;
	t->inter_block = dc->interleave / dc->block_size;
	t->virt_targ_id = dc->curr_virt_id;
	t->phys_targ_id = ESAS2R_TARG_ID_INV;

	t->flags &= ~TF_PASS_THRU;
	t->flags \|= TF_USED;

	t->identifier_len = 0;

	t->target_state = TS_PRESENT;

	return t;
	}

	struct esas2r_target esas2r_targ_db_add_pthru(struct esas2r_adapter a,
	struct esas2r_disc_context *dc,
	u8 *ident,
	u8 ident_len)
	{
	struct esas2r_target *t;

	esas2r_trace_enter();

	if (dc->curr_virt_id >= ESAS2R_MAX_TARGETS) {
	esas2r_bugon();
	esas2r_trace_exit();
	return NULL;
	}

	/* see if we found this device before. */

	t = esas2r_targ_db_find_by_ident(a, ident, ident_len);

	if (t == NULL) {
	t = a->targetdb + dc->curr_virt_id;

	if (ident_len > sizeof(t->identifier)
	\|\| t->target_state == TS_PRESENT) {
	esas2r_trace_exit();
	return NULL;
	}
	}

	esas2r_hdebug("add PT; T:%d, V:%d, P:%d", esas2r_targ_get_id(t, a),
	dc->curr_virt_id,
	dc->curr_phys_id);

	t->block_size = 0;
	t->inter_byte = 0;
	t->inter_block = 0;
	t->virt_targ_id = dc->curr_virt_id;
	t->phys_targ_id = dc->curr_phys_id;
	t->identifier_len = ident_len;

	memcpy(t->identifier, ident, ident_len);

	t->flags \|= TF_PASS_THRU \| TF_USED;

	t->target_state = TS_PRESENT;

	return t;
	}

	void esas2r_targ_db_remove(struct esas2r_adapter a, struct esas2r_target t)
	{
	esas2r_trace_enter();

	t->target_state = TS_NOT_PRESENT;

	esas2r_trace("remove id:%d", esas2r_targ_get_id(t, a));

	esas2r_trace_exit();
	}

	struct esas2r_target esas2r_targ_db_find_by_sas_addr(struct esas2r_adapter a,
	u64 *sas_addr)
	{
	struct esas2r_target *t;

	for (t = a->targetdb; t < a->targetdb_end; t++)
	if (t->sas_addr == *sas_addr)
	return t;

	return NULL;
	}

	struct esas2r_target esas2r_targ_db_find_by_ident(struct esas2r_adapter a,
	void *identifier,
	u8 ident_len)
	{
	struct esas2r_target *t;

	for (t = a->targetdb; t < a->targetdb_end; t++) {
	if (ident_len == t->identifier_len
	&& memcmp(&t->identifier[0], identifier,
	ident_len) == 0)
	return t;
	}

	return NULL;
	}

	u16 esas2r_targ_db_find_next_present(struct esas2r_adapter *a, u16 target_id)
	{
	u16 id = target_id + 1;

	while (id < ESAS2R_MAX_TARGETS) {
	struct esas2r_target *t = a->targetdb + id;

	if (t->target_state == TS_PRESENT)
	break;

	id++;
	}

	return id;
	}

	struct esas2r_target esas2r_targ_db_find_by_virt_id(struct esas2r_adapter a,
	u16 virt_id)
	{
	struct esas2r_target *t;

	for (t = a->targetdb; t < a->targetdb_end; t++) {
	if (t->target_state != TS_PRESENT)
	continue;

	if (t->virt_targ_id == virt_id)
	return t;
	}

	return NULL;
	}

	u16 esas2r_targ_db_get_tgt_cnt(struct esas2r_adapter *a)
	{
	u16 devcnt = 0;
	struct esas2r_target *t;
	unsigned long flags;

	spin_lock_irqsave(&a->mem_lock, flags);
	for (t = a->targetdb; t < a->targetdb_end; t++)
	if (t->target_state == TS_PRESENT)
	devcnt++;

	spin_unlock_irqrestore(&a->mem_lock, flags);

	return devcnt;
	}