root/drivers/scsi/esas2r/esas2r_targdb.c

DEFINITIONS

1. esas2r_targ_db_initialize
2. esas2r_targ_db_remove_all
3. esas2r_targ_db_report_changes
4. esas2r_targ_db_add_raid
5. esas2r_targ_db_add_pthru
6. esas2r_targ_db_remove
7. esas2r_targ_db_find_by_sas_addr
8. esas2r_targ_db_find_by_ident
9. esas2r_targ_db_find_next_present
10. esas2r_targ_db_find_by_virt_id
11. esas2r_targ_db_get_tgt_cnt

   1 /*
   2  *  linux/drivers/scsi/esas2r/esas2r_targdb.c
   3  *      For use with ATTO ExpressSAS R6xx SAS/SATA RAID controllers
   4  *
   5  *  Copyright (c) 2001-2013 ATTO Technology, Inc.
   6  *  (mailto:linuxdrivers@attotech.com)
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * NO WARRANTY
  19  * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  20  * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  21  * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  22  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  23  * solely responsible for determining the appropriateness of using and
  24  * distributing the Program and assumes all risks associated with its
  25  * exercise of rights under this Agreement, including but not limited to
  26  * the risks and costs of program errors, damage to or loss of data,
  27  * programs or equipment, and unavailability or interruption of operations.
  28  *
  29  * DISCLAIMER OF LIABILITY
  30  * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  31  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  33  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  34  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  35  * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  36  * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  37  *
  38  * You should have received a copy of the GNU General Public License
  39  * along with this program; if not, write to the Free Software
  40  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
  41  * USA.
  42  */
  43 
  44 #include "esas2r.h"
  45 
  46 void esas2r_targ_db_initialize(struct esas2r_adapter *a)
  47 {
  48         struct esas2r_target *t;
  49 
  50         for (t = a->targetdb; t < a->targetdb_end; t++) {
  51                 memset(t, 0, sizeof(struct esas2r_target));
  52 
  53                 t->target_state = TS_NOT_PRESENT;
  54                 t->buffered_target_state = TS_NOT_PRESENT;
  55                 t->new_target_state = TS_INVALID;
  56         }
  57 }
  58 
  59 void esas2r_targ_db_remove_all(struct esas2r_adapter *a, bool notify)
  60 {
  61         struct esas2r_target *t;
  62         unsigned long flags;
  63 
  64         for (t = a->targetdb; t < a->targetdb_end; t++) {
  65                 if (t->target_state != TS_PRESENT)
  66                         continue;
  67 
  68                 spin_lock_irqsave(&a->mem_lock, flags);
  69                 esas2r_targ_db_remove(a, t);
  70                 spin_unlock_irqrestore(&a->mem_lock, flags);
  71 
  72                 if (notify) {
  73                         esas2r_trace("remove id:%d", esas2r_targ_get_id(t,
  74                                                                         a));
  75                         esas2r_target_state_changed(a, esas2r_targ_get_id(t,
  76                                                                           a),
  77                                                     TS_NOT_PRESENT);
  78                 }
  79         }
  80 }
  81 
  82 void esas2r_targ_db_report_changes(struct esas2r_adapter *a)
  83 {
  84         struct esas2r_target *t;
  85         unsigned long flags;
  86 
  87         esas2r_trace_enter();
  88 
  89         if (test_bit(AF_DISC_PENDING, &a->flags)) {
  90                 esas2r_trace_exit();
  91                 return;
  92         }
  93 
  94         for (t = a->targetdb; t < a->targetdb_end; t++) {
  95                 u8 state = TS_INVALID;
  96 
  97                 spin_lock_irqsave(&a->mem_lock, flags);
  98                 if (t->buffered_target_state != t->target_state)
  99                         state = t->buffered_target_state = t->target_state;
 100 
 101                 spin_unlock_irqrestore(&a->mem_lock, flags);
 102                 if (state != TS_INVALID) {
 103                         esas2r_trace("targ_db_report_changes:%d",
 104                                      esas2r_targ_get_id(
 105                                              t,
 106                                              a));
 107                         esas2r_trace("state:%d", state);
 108 
 109                         esas2r_target_state_changed(a,
 110                                                     esas2r_targ_get_id(t,
 111                                                                        a),
 112                                                     state);
 113                 }
 114         }
 115 
 116         esas2r_trace_exit();
 117 }
 118 
 119 struct esas2r_target *esas2r_targ_db_add_raid(struct esas2r_adapter *a,
 120                                               struct esas2r_disc_context *
 121                                               dc)
 122 {
 123         struct esas2r_target *t;
 124 
 125         esas2r_trace_enter();
 126 
 127         if (dc->curr_virt_id >= ESAS2R_MAX_TARGETS) {
 128                 esas2r_bugon();
 129                 esas2r_trace_exit();
 130                 return NULL;
 131         }
 132 
 133         t = a->targetdb + dc->curr_virt_id;
 134 
 135         if (t->target_state == TS_PRESENT) {
 136                 esas2r_trace_exit();
 137                 return NULL;
 138         }
 139 
 140         esas2r_hdebug("add RAID %s, T:%d", dc->raid_grp_name,
 141                       esas2r_targ_get_id(
 142                               t,
 143                               a));
 144 
 145         if (dc->interleave == 0
 146             || dc->block_size  == 0) {
 147                 /* these are invalid values, don't create the target entry. */
 148 
 149                 esas2r_hdebug("invalid RAID group dimensions");
 150 
 151                 esas2r_trace_exit();
 152 
 153                 return NULL;
 154         }
 155 
 156         t->block_size = dc->block_size;
 157         t->inter_byte = dc->interleave;
 158         t->inter_block = dc->interleave / dc->block_size;
 159         t->virt_targ_id = dc->curr_virt_id;
 160         t->phys_targ_id = ESAS2R_TARG_ID_INV;
 161 
 162         t->flags &= ~TF_PASS_THRU;
 163         t->flags |= TF_USED;
 164 
 165         t->identifier_len = 0;
 166 
 167         t->target_state = TS_PRESENT;
 168 
 169         return t;
 170 }
 171 
 172 struct esas2r_target *esas2r_targ_db_add_pthru(struct esas2r_adapter *a,
 173                                                struct esas2r_disc_context *dc,
 174                                                u8 *ident,
 175                                                u8 ident_len)
 176 {
 177         struct esas2r_target *t;
 178 
 179         esas2r_trace_enter();
 180 
 181         if (dc->curr_virt_id >= ESAS2R_MAX_TARGETS) {
 182                 esas2r_bugon();
 183                 esas2r_trace_exit();
 184                 return NULL;
 185         }
 186 
 187         /* see if we found this device before. */
 188 
 189         t = esas2r_targ_db_find_by_ident(a, ident, ident_len);
 190 
 191         if (t == NULL) {
 192                 t = a->targetdb + dc->curr_virt_id;
 193 
 194                 if (ident_len > sizeof(t->identifier)
 195                     || t->target_state == TS_PRESENT) {
 196                         esas2r_trace_exit();
 197                         return NULL;
 198                 }
 199         }
 200 
 201         esas2r_hdebug("add PT; T:%d, V:%d, P:%d", esas2r_targ_get_id(t, a),
 202                       dc->curr_virt_id,
 203                       dc->curr_phys_id);
 204 
 205         t->block_size = 0;
 206         t->inter_byte = 0;
 207         t->inter_block = 0;
 208         t->virt_targ_id = dc->curr_virt_id;
 209         t->phys_targ_id = dc->curr_phys_id;
 210         t->identifier_len = ident_len;
 211 
 212         memcpy(t->identifier, ident, ident_len);
 213 
 214         t->flags |= TF_PASS_THRU | TF_USED;
 215 
 216         t->target_state = TS_PRESENT;
 217 
 218         return t;
 219 }
 220 
 221 void esas2r_targ_db_remove(struct esas2r_adapter *a, struct esas2r_target *t)
 222 {
 223         esas2r_trace_enter();
 224 
 225         t->target_state = TS_NOT_PRESENT;
 226 
 227         esas2r_trace("remove id:%d", esas2r_targ_get_id(t, a));
 228 
 229         esas2r_trace_exit();
 230 }
 231 
 232 struct esas2r_target *esas2r_targ_db_find_by_sas_addr(struct esas2r_adapter *a,
 233                                                       u64 *sas_addr)
 234 {
 235         struct esas2r_target *t;
 236 
 237         for (t = a->targetdb; t < a->targetdb_end; t++)
 238                 if (t->sas_addr == *sas_addr)
 239                         return t;
 240 
 241         return NULL;
 242 }
 243 
 244 struct esas2r_target *esas2r_targ_db_find_by_ident(struct esas2r_adapter *a,
 245                                                    void *identifier,
 246                                                    u8 ident_len)
 247 {
 248         struct esas2r_target *t;
 249 
 250         for (t = a->targetdb; t < a->targetdb_end; t++) {
 251                 if (ident_len == t->identifier_len
 252                     && memcmp(&t->identifier[0], identifier,
 253                               ident_len) == 0)
 254                         return t;
 255         }
 256 
 257         return NULL;
 258 }
 259 
 260 u16 esas2r_targ_db_find_next_present(struct esas2r_adapter *a, u16 target_id)
 261 {
 262         u16 id = target_id + 1;
 263 
 264         while (id < ESAS2R_MAX_TARGETS) {
 265                 struct esas2r_target *t = a->targetdb + id;
 266 
 267                 if (t->target_state == TS_PRESENT)
 268                         break;
 269 
 270                 id++;
 271         }
 272 
 273         return id;
 274 }
 275 
 276 struct esas2r_target *esas2r_targ_db_find_by_virt_id(struct esas2r_adapter *a,
 277                                                      u16 virt_id)
 278 {
 279         struct esas2r_target *t;
 280 
 281         for (t = a->targetdb; t < a->targetdb_end; t++) {
 282                 if (t->target_state != TS_PRESENT)
 283                         continue;
 284 
 285                 if (t->virt_targ_id == virt_id)
 286                         return t;
 287         }
 288 
 289         return NULL;
 290 }
 291 
 292 u16 esas2r_targ_db_get_tgt_cnt(struct esas2r_adapter *a)
 293 {
 294         u16 devcnt = 0;
 295         struct esas2r_target *t;
 296         unsigned long flags;
 297 
 298         spin_lock_irqsave(&a->mem_lock, flags);
 299         for (t = a->targetdb; t < a->targetdb_end; t++)
 300                 if (t->target_state == TS_PRESENT)
 301                         devcnt++;
 302 
 303         spin_unlock_irqrestore(&a->mem_lock, flags);
 304 
 305         return devcnt;
 306 }