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 } 307