]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blob - src/patches/suse-2.6.27.31/patches.drivers/lpfc-8.2.8.1-update
projects / people / pmueller / ipfire-2.x.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Move xen patchset to new version's subdir.
[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.31 / patches.drivers / lpfc-8.2.8.1-update
1 From: Jamie Wellnitz <jamie.wellnitz@emulex.com>
2 Subject: Update lpfc to 8.2.8.1
3 References: bnc#420767
4
5 This patch adds a few features (including FC authentication and a few
6 management ioctls) to lpfc 8.2.8 and generates 8.2.8.1.
7
8 Signed-off-by: Hannes Reinecke <hare@suse.de>
9
10 ---
11 drivers/scsi/lpfc/Makefile | 5
12 drivers/scsi/lpfc/lpfc.h | 129 +
13 drivers/scsi/lpfc/lpfc_attr.c | 976 ++++++++++++-
14 drivers/scsi/lpfc/lpfc_auth.c | 838 +++++++++++
15 drivers/scsi/lpfc/lpfc_auth.h | 92 +
16 drivers/scsi/lpfc/lpfc_auth_access.c | 598 ++++++++
17 drivers/scsi/lpfc/lpfc_auth_access.h | 245 +++
18 drivers/scsi/lpfc/lpfc_crtn.h | 37
19 drivers/scsi/lpfc/lpfc_disc.h | 3
20 drivers/scsi/lpfc/lpfc_els.c | 663 +++++++++
21 drivers/scsi/lpfc/lpfc_hbadisc.c | 154 +-
22 drivers/scsi/lpfc/lpfc_hw.h | 52
23 drivers/scsi/lpfc/lpfc_init.c | 154 +-
24 drivers/scsi/lpfc/lpfc_ioctl.c | 2519 +++++++++++++++++++++++++++++++++++
25 drivers/scsi/lpfc/lpfc_ioctl.h | 184 ++
26 drivers/scsi/lpfc/lpfc_logmsg.h | 1
27 drivers/scsi/lpfc/lpfc_mbox.c | 2
28 drivers/scsi/lpfc/lpfc_menlo.c | 1174 ++++++++++++++++
29 drivers/scsi/lpfc/lpfc_scsi.c | 36
30 drivers/scsi/lpfc/lpfc_security.c | 339 ++++
31 drivers/scsi/lpfc/lpfc_security.h | 24
32 drivers/scsi/lpfc/lpfc_sli.c | 59
33 drivers/scsi/lpfc/lpfc_sli.h | 3
34 drivers/scsi/lpfc/lpfc_version.h | 2
35 drivers/scsi/lpfc/lpfc_vport.c | 16
36 25 files changed, 8149 insertions(+), 156 deletions(-)
37
38 --- a/drivers/scsi/lpfc/lpfc_attr.c
39 +++ b/drivers/scsi/lpfc/lpfc_attr.c
40 @@ -41,6 +41,7 @@
41 #include "lpfc_compat.h"
42 #include "lpfc_crtn.h"
43 #include "lpfc_vport.h"
44 +#include "lpfc_auth_access.h"
45
46 #define LPFC_DEF_DEVLOSS_TMO 30
47 #define LPFC_MIN_DEVLOSS_TMO 1
48 @@ -50,6 +51,15 @@
49 #define LPFC_LINK_SPEED_BITMAP 0x00000117
50 #define LPFC_LINK_SPEED_STRING "0, 1, 2, 4, 8"
51
52 +extern struct bin_attribute sysfs_menlo_attr;
53 +
54 +/*
55 + * Write key size should be multiple of 4. If write key is changed
56 + * make sure that library write key is also changed.
57 + */
58 +#define LPFC_REG_WRITE_KEY_SIZE 4
59 +#define LPFC_REG_WRITE_KEY "EMLX"
60 +
61 /**
62 * lpfc_jedec_to_ascii: Hex to ascii convertor according to JEDEC rules.
63 * @incr: integer to convert.
64 @@ -551,7 +561,7 @@ lpfc_do_offline(struct lpfc_hba *phba, u
65 * -EIO reset not configured or error posting the event
66 * zero for success
67 **/
68 -static int
69 +int
70 lpfc_selective_reset(struct lpfc_hba *phba)
71 {
72 struct completion online_compl;
73 @@ -1080,6 +1090,141 @@ lpfc_poll_store(struct device *dev, stru
74 return strlen(buf);
75 }
76
77 +static ssize_t
78 +lpfc_auth_state_show(struct device *dev, struct device_attribute *attr,
79 + char *buf)
80 +{
81 + struct Scsi_Host *shost = class_to_shost(dev);
82 + struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
83 + switch (vport->auth.auth_state) {
84 + case LPFC_AUTH_UNKNOWN:
85 + if (vport->auth.auth_msg_state == LPFC_AUTH_NEGOTIATE ||
86 + vport->auth.auth_msg_state == LPFC_DHCHAP_CHALLENGE ||
87 + vport->auth.auth_msg_state == LPFC_DHCHAP_REPLY ||
88 + vport->auth.auth_msg_state == LPFC_DHCHAP_SUCCESS_REPLY)
89 + return snprintf(buf, PAGE_SIZE, "Authenticating\n");
90 + else
91 + return snprintf(buf, PAGE_SIZE, "Not Authenticated\n");
92 + case LPFC_AUTH_FAIL:
93 + return snprintf(buf, PAGE_SIZE, "Failed\n");
94 + case LPFC_AUTH_SUCCESS:
95 + if (vport->auth.auth_msg_state == LPFC_AUTH_NEGOTIATE ||
96 + vport->auth.auth_msg_state == LPFC_DHCHAP_CHALLENGE ||
97 + vport->auth.auth_msg_state == LPFC_DHCHAP_REPLY ||
98 + vport->auth.auth_msg_state == LPFC_DHCHAP_SUCCESS_REPLY)
99 + return snprintf(buf, PAGE_SIZE, "Authenticating\n");
100 + else if (vport->auth.auth_msg_state == LPFC_DHCHAP_SUCCESS)
101 + return snprintf(buf, PAGE_SIZE, "Authenticated\n");
102 + }
103 + return snprintf(buf, PAGE_SIZE, "Unknown\n");
104 +}
105 +
106 +static ssize_t
107 +lpfc_auth_dir_show(struct device *dev, struct device_attribute *attr,
108 + char *buf)
109 +{
110 + struct Scsi_Host *shost = class_to_shost(dev);
111 + struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
112 + if (!vport->cfg_enable_auth ||
113 + vport->auth.auth_state != LPFC_AUTH_SUCCESS)
114 + return snprintf(buf, PAGE_SIZE, "Unknown\n");
115 + if (vport->auth.direction == AUTH_DIRECTION_LOCAL)
116 + return snprintf(buf, PAGE_SIZE, "Local Authenticated\n");
117 + else if (vport->auth.direction == AUTH_DIRECTION_REMOTE)
118 + return snprintf(buf, PAGE_SIZE, "Remote Authenticated\n");
119 + else if (vport->auth.direction == AUTH_DIRECTION_BIDI)
120 + return snprintf(buf, PAGE_SIZE, "Bidi Authentication\n");
121 + return snprintf(buf, PAGE_SIZE, "Unknown\n");
122 +}
123 +
124 +static ssize_t
125 +lpfc_auth_protocol_show(struct device *dev, struct device_attribute *attr,
126 + char *buf)
127 +{
128 + struct Scsi_Host *shost = class_to_shost(dev);
129 + struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
130 + if (vport->cfg_enable_auth &&
131 + vport->auth.auth_state == LPFC_AUTH_SUCCESS)
132 + return snprintf(buf, PAGE_SIZE, "1 (DH-CHAP)\n");
133 + else
134 + return snprintf(buf, PAGE_SIZE, "Unknown\n");
135 +}
136 +
137 +static ssize_t
138 +lpfc_auth_dhgroup_show(struct device *dev, struct device_attribute *attr,
139 + char *buf)
140 +{
141 + struct Scsi_Host *shost = class_to_shost(dev);
142 + struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
143 + if (!vport->cfg_enable_auth ||
144 + vport->auth.auth_state != LPFC_AUTH_SUCCESS)
145 + return snprintf(buf, PAGE_SIZE, "Unknown\n");
146 + switch (vport->auth.group_id) {
147 + case DH_GROUP_NULL:
148 + return snprintf(buf, PAGE_SIZE, "0 (NULL)\n");
149 + case DH_GROUP_1024:
150 + return snprintf(buf, PAGE_SIZE, "1 (1024)\n");
151 + case DH_GROUP_1280:
152 + return snprintf(buf, PAGE_SIZE, "2 (1280)\n");
153 + case DH_GROUP_1536:
154 + return snprintf(buf, PAGE_SIZE, "3 (1536)\n");
155 + case DH_GROUP_2048:
156 + return snprintf(buf, PAGE_SIZE, "4 (2048)\n");
157 + }
158 + return snprintf(buf, PAGE_SIZE, "%d (Unrecognized)\n",
159 + vport->auth.group_id);
160 +}
161 +
162 +static ssize_t
163 +lpfc_auth_hash_show(struct device *dev, struct device_attribute *attr,
164 + char *buf)
165 +{
166 + struct Scsi_Host *shost = class_to_shost(dev);
167 + struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
168 + if (!vport->cfg_enable_auth ||
169 + vport->auth.auth_state != LPFC_AUTH_SUCCESS)
170 + return snprintf(buf, PAGE_SIZE, "Unknown\n");
171 + switch (vport->auth.hash_id) {
172 + case FC_SP_HASH_MD5:
173 + return snprintf(buf, PAGE_SIZE, "5 (MD5)\n");
174 + case FC_SP_HASH_SHA1:
175 + return snprintf(buf, PAGE_SIZE, "6 (SHA1)\n");
176 + }
177 + return snprintf(buf, PAGE_SIZE, "%d (Unrecognized)\n",
178 + vport->auth.hash_id);
179 +}
180 +static ssize_t
181 +lpfc_auth_last_show(struct device *dev, struct device_attribute *attr,
182 + char *buf)
183 +{
184 + struct Scsi_Host *shost = class_to_shost(dev);
185 + struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
186 + struct timeval last_time;
187 + if (!vport->cfg_enable_auth || vport->auth.last_auth == 0)
188 + return snprintf(buf, PAGE_SIZE, "%d\n", -1);
189 + jiffies_to_timeval((jiffies - vport->auth.last_auth), &last_time);
190 + return snprintf(buf, PAGE_SIZE, "%ld\n", last_time.tv_sec);
191 +}
192 +
193 +static ssize_t
194 +lpfc_auth_next_show(struct device *dev, struct device_attribute *attr,
195 + char *buf)
196 +{
197 + struct Scsi_Host *shost = class_to_shost(dev);
198 + struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
199 + unsigned long next_jiff;
200 + struct timeval next_time;
201 + if (!vport->cfg_enable_auth ||
202 + vport->auth.last_auth == 0 ||
203 + vport->auth.reauth_interval == 0)
204 + return snprintf(buf, PAGE_SIZE, "%d\n", -1);
205 + /* calculate the amount of time left until next auth */
206 + next_jiff = (msecs_to_jiffies(vport->auth.reauth_interval * 60000) +
207 + vport->auth.last_auth) - jiffies;
208 + jiffies_to_timeval(next_jiff, &next_time);
209 + return snprintf(buf, PAGE_SIZE, "%ld\n", next_time.tv_sec);
210 +}
211 +
212 /**
213 * lpfc_param_show: Return a cfg attribute value in decimal.
214 *
215 @@ -1512,7 +1657,38 @@ static DEVICE_ATTR(max_xri, S_IRUGO, lpf
216 static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
217 static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
218 static DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, NULL);
219 +static DEVICE_ATTR(auth_state, S_IRUGO, lpfc_auth_state_show, NULL);
220 +static DEVICE_ATTR(auth_dir, S_IRUGO, lpfc_auth_dir_show, NULL);
221 +static DEVICE_ATTR(auth_protocol, S_IRUGO, lpfc_auth_protocol_show, NULL);
222 +static DEVICE_ATTR(auth_dhgroup, S_IRUGO, lpfc_auth_dhgroup_show, NULL);
223 +static DEVICE_ATTR(auth_hash, S_IRUGO, lpfc_auth_hash_show, NULL);
224 +static DEVICE_ATTR(auth_last, S_IRUGO, lpfc_auth_last_show, NULL);
225 +static DEVICE_ATTR(auth_next, S_IRUGO, lpfc_auth_next_show, NULL);
226 +
227 +static int
228 +lpfc_parse_wwn(const char *ns, uint8_t *nm)
229 +{
230 + unsigned int i, j;
231 + memset(nm, 0, 8);
232 +
233 + /* Validate and store the new name */
234 + for (i = 0, j = 0; i < 16; i++) {
235 + if ((*ns >= 'a') && (*ns <= 'f'))
236 + j = ((j << 4) | ((*ns++ - 'a') + 10));
237 + else if ((*ns >= 'A') && (*ns <= 'F'))
238 + j = ((j << 4) | ((*ns++ - 'A') + 10));
239 + else if ((*ns >= '0') && (*ns <= '9'))
240 + j = ((j << 4) | (*ns++ - '0'));
241 + else
242 + return -EINVAL;
243 + if (i % 2) {
244 + nm[i/2] = j & 0xff;
245 + j = 0;
246 + }
247 + }
248
249 + return 0;
250 +}
251
252 static char *lpfc_soft_wwn_key = "C99G71SL8032A";
253
254 @@ -1908,6 +2084,87 @@ lpfc_vport_param_store(nodev_tmo)
255
256 static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR,
257 lpfc_nodev_tmo_show, lpfc_nodev_tmo_store);
258 +static ssize_t
259 +lpfc_authenticate(struct device *dev, struct device_attribute *attr,
260 + const char *buf, size_t count)
261 +{
262 + struct Scsi_Host *shost = class_to_shost(dev);
263 + struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
264 + struct lpfc_hba *phba = vport->phba;
265 + struct lpfc_nodelist *ndlp;
266 + int status;
267 + struct lpfc_name wwpn;
268 +
269 + if (lpfc_parse_wwn(buf, wwpn.u.wwn))
270 + return -EINVAL;
271 +
272 + if (vport->port_state == LPFC_VPORT_FAILED) {
273 + lpfc_issue_lip(shost);
274 + return strlen(buf);
275 + }
276 + if ((vport->fc_flag & FC_OFFLINE_MODE) ||
277 + (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) ||
278 + (!vport->cfg_enable_auth))
279 + return -EPERM;
280 +
281 + /* If vport already in the middle of authentication do not restart */
282 + if ((vport->auth.auth_msg_state == LPFC_AUTH_NEGOTIATE) ||
283 + (vport->auth.auth_msg_state == LPFC_DHCHAP_CHALLENGE) ||
284 + (vport->auth.auth_msg_state == LPFC_DHCHAP_REPLY))
285 + return -EAGAIN;
286 +
287 + if (wwn_to_u64(wwpn.u.wwn) == AUTH_FABRIC_WWN)
288 + ndlp = lpfc_findnode_did(vport, Fabric_DID);
289 + else
290 + ndlp = lpfc_findnode_wwnn(vport, &wwpn);
291 + if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
292 + return -EPERM;
293 + status = lpfc_start_node_authentication(ndlp);
294 + if (status)
295 + return status;
296 + return strlen(buf);
297 +}
298 +static DEVICE_ATTR(lpfc_authenticate, S_IRUGO | S_IWUSR, NULL,
299 + lpfc_authenticate);
300 +
301 +static ssize_t
302 +lpfc_update_auth_config(struct device *dev, struct device_attribute *attr,
303 + const char *buf, size_t count)
304 +{
305 + struct Scsi_Host *shost = class_to_shost(dev);
306 + struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
307 + struct lpfc_hba *phba = vport->phba;
308 + struct lpfc_nodelist *ndlp;
309 + struct lpfc_name wwpn;
310 + int status;
311 +
312 + if (lpfc_parse_wwn(buf, wwpn.u.wwn))
313 + return -EINVAL;
314 +
315 + if ((vport->fc_flag & FC_OFFLINE_MODE) ||
316 + (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) ||
317 + (!vport->cfg_enable_auth))
318 + return -EPERM;
319 +
320 + /* If vport already in the middle of authentication do not restart */
321 + if ((vport->auth.auth_msg_state == LPFC_AUTH_NEGOTIATE) ||
322 + (vport->auth.auth_msg_state == LPFC_DHCHAP_CHALLENGE) ||
323 + (vport->auth.auth_msg_state == LPFC_DHCHAP_REPLY))
324 + return -EAGAIN;
325 +
326 + if (wwn_to_u64(wwpn.u.wwn) == AUTH_FABRIC_WWN)
327 + ndlp = lpfc_findnode_did(vport, Fabric_DID);
328 + else
329 + ndlp = lpfc_findnode_wwnn(vport, &wwpn);
330 + if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
331 + return -EPERM;
332 + status = lpfc_get_auth_config(ndlp, &wwpn);
333 + if (status)
334 + return -EPERM;
335 + return strlen(buf);
336 +}
337 +static DEVICE_ATTR(lpfc_update_auth_config, S_IRUGO | S_IWUSR,
338 + NULL, lpfc_update_auth_config);
339
340 /*
341 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
342 @@ -2753,6 +3010,48 @@ LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Messa
343 "MSI-X (2), if possible");
344
345 /*
346 +# lpfc_enable_auth: controls FC Authentication.
347 +# 0 = Authentication OFF
348 +# 1 = Authentication ON
349 +# Value range [0,1]. Default value is 0.
350 +*/
351 +static int lpfc_enable_auth;
352 +module_param(lpfc_enable_auth, int, 0);
353 +MODULE_PARM_DESC(lpfc_enable_auth, "Enable FC Authentication");
354 +lpfc_vport_param_show(enable_auth);
355 +lpfc_vport_param_init(enable_auth, 0, 0, 1);
356 +static int
357 +lpfc_enable_auth_set(struct lpfc_vport *vport, int val)
358 +{
359 + if (val == vport->cfg_enable_auth)
360 + return 0;
361 + if (val == 0) {
362 + spin_lock_irq(&fc_security_user_lock);
363 + list_del(&vport->sc_users);
364 + spin_unlock_irq(&fc_security_user_lock);
365 + vport->cfg_enable_auth = val;
366 + lpfc_fc_queue_security_work(vport,
367 + &vport->sc_offline_work);
368 + return 0;
369 + } else if (val == 1) {
370 + spin_lock_irq(&fc_security_user_lock);
371 + list_add_tail(&vport->sc_users, &fc_security_user_list);
372 + spin_unlock_irq(&fc_security_user_lock);
373 + vport->cfg_enable_auth = val;
374 + lpfc_fc_queue_security_work(vport,
375 + &vport->sc_online_work);
376 + return 0;
377 + }
378 + lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
379 + "0431 lpfc_enable_auth attribute cannot be set to %d, "
380 + "allowed range is [0, 1]\n", val);
381 + return -EINVAL;
382 +}
383 +lpfc_vport_param_store(enable_auth);
384 +static DEVICE_ATTR(lpfc_enable_auth, S_IRUGO | S_IWUSR,
385 + lpfc_enable_auth_show, lpfc_enable_auth_store);
386 +
387 +/*
388 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
389 # 0 = HBA resets disabled
390 # 1 = HBA resets enabled (default)
391 @@ -2825,6 +3124,16 @@ struct device_attribute *lpfc_hba_attrs[
392 &dev_attr_lpfc_poll,
393 &dev_attr_lpfc_poll_tmo,
394 &dev_attr_lpfc_use_msi,
395 + &dev_attr_lpfc_enable_auth,
396 + &dev_attr_lpfc_authenticate,
397 + &dev_attr_lpfc_update_auth_config,
398 + &dev_attr_auth_state,
399 + &dev_attr_auth_dir,
400 + &dev_attr_auth_protocol,
401 + &dev_attr_auth_dhgroup,
402 + &dev_attr_auth_hash,
403 + &dev_attr_auth_last,
404 + &dev_attr_auth_next,
405 &dev_attr_lpfc_soft_wwnn,
406 &dev_attr_lpfc_soft_wwpn,
407 &dev_attr_lpfc_soft_wwn_enable,
408 @@ -2855,6 +3164,14 @@ struct device_attribute *lpfc_vport_attr
409 &dev_attr_nport_evt_cnt,
410 &dev_attr_npiv_info,
411 &dev_attr_lpfc_enable_da_id,
412 + &dev_attr_auth_state,
413 + &dev_attr_auth_dir,
414 + &dev_attr_auth_protocol,
415 + &dev_attr_auth_dhgroup,
416 + &dev_attr_auth_hash,
417 + &dev_attr_auth_last,
418 + &dev_attr_auth_next,
419 +
420 &dev_attr_lpfc_max_scsicmpl_time,
421 &dev_attr_lpfc_stat_data_ctrl,
422 NULL,
423 @@ -2888,21 +3205,23 @@ sysfs_ctlreg_write(struct kobject *kobj,
424 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
425 struct lpfc_hba *phba = vport->phba;
426
427 - if ((off + count) > FF_REG_AREA_SIZE)
428 + if ((off + count) > FF_REG_AREA_SIZE + LPFC_REG_WRITE_KEY_SIZE)
429 return -ERANGE;
430
431 - if (count == 0) return 0;
432 + if (count <= LPFC_REG_WRITE_KEY_SIZE)
433 + return 0;
434
435 if (off % 4 || count % 4 || (unsigned long)buf % 4)
436 return -EINVAL;
437
438 - if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
439 - return -EPERM;
440 - }
441 + /* This is to protect HBA registers from accidental writes. */
442 + if (memcmp(buf, LPFC_REG_WRITE_KEY, LPFC_REG_WRITE_KEY_SIZE))
443 + return -EINVAL;
444
445 spin_lock_irq(&phba->hbalock);
446 - for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t))
447 - writel(*((uint32_t *)(buf + buf_off)),
448 + for (buf_off = 0; buf_off < count - LPFC_REG_WRITE_KEY_SIZE;
449 + buf_off += sizeof(uint32_t))
450 + writel(*((uint32_t *)(buf + buf_off + LPFC_REG_WRITE_KEY_SIZE)),
451 phba->ctrl_regs_memmap_p + off + buf_off);
452
453 spin_unlock_irq(&phba->hbalock);
454 @@ -2971,21 +3290,211 @@ static struct bin_attribute sysfs_ctlreg
455 .write = sysfs_ctlreg_write,
456 };
457
458 +static struct lpfc_sysfs_mbox *
459 +lpfc_get_sysfs_mbox(struct lpfc_hba *phba, uint8_t create)
460 +{
461 + struct lpfc_sysfs_mbox *sysfs_mbox;
462 + pid_t pid;
463 +
464 + pid = current->pid;
465 +
466 + spin_lock_irq(&phba->hbalock);
467 + list_for_each_entry(sysfs_mbox, &phba->sysfs_mbox_list, list) {
468 + if (sysfs_mbox->pid == pid) {
469 + spin_unlock_irq(&phba->hbalock);
470 + return sysfs_mbox;
471 + }
472 + }
473 + if (!create) {
474 + spin_unlock_irq(&phba->hbalock);
475 + return NULL;
476 + }
477 + spin_unlock_irq(&phba->hbalock);
478 + sysfs_mbox = kzalloc(sizeof(struct lpfc_sysfs_mbox),
479 + GFP_KERNEL);
480 + if (!sysfs_mbox)
481 + return NULL;
482 + sysfs_mbox->state = SMBOX_IDLE;
483 + sysfs_mbox->pid = pid;
484 + spin_lock_irq(&phba->hbalock);
485 + list_add_tail(&sysfs_mbox->list, &phba->sysfs_mbox_list);
486 +
487 + spin_unlock_irq(&phba->hbalock);
488 + return sysfs_mbox;
489 +
490 +}
491 /**
492 * sysfs_mbox_idle: frees the sysfs mailbox.
493 * @phba: lpfc_hba pointer
494 **/
495 static void
496 -sysfs_mbox_idle(struct lpfc_hba *phba)
497 +sysfs_mbox_idle(struct lpfc_hba *phba,
498 + struct lpfc_sysfs_mbox *sysfs_mbox)
499 {
500 - phba->sysfs_mbox.state = SMBOX_IDLE;
501 - phba->sysfs_mbox.offset = 0;
502 -
503 - if (phba->sysfs_mbox.mbox) {
504 - mempool_free(phba->sysfs_mbox.mbox,
505 + list_del_init(&sysfs_mbox->list);
506 + if (sysfs_mbox->mbox) {
507 + mempool_free(sysfs_mbox->mbox,
508 phba->mbox_mem_pool);
509 - phba->sysfs_mbox.mbox = NULL;
510 }
511 +
512 + if (sysfs_mbox->mbext)
513 + kfree(sysfs_mbox->mbext);
514 +
515 + /* If txmit buffer allocated free txmit buffer */
516 + if (sysfs_mbox->txmit_buff) {
517 + if (sysfs_mbox->txmit_buff->virt)
518 + __lpfc_mbuf_free(phba,
519 + sysfs_mbox->txmit_buff->virt,
520 + sysfs_mbox->txmit_buff->phys);
521 + kfree(sysfs_mbox->txmit_buff);
522 + }
523 +
524 + /* If rcv buffer allocated free txmit buffer */
525 + if (sysfs_mbox->rcv_buff) {
526 + if (sysfs_mbox->rcv_buff->virt)
527 + __lpfc_mbuf_free(phba,
528 + sysfs_mbox->rcv_buff->virt,
529 + sysfs_mbox->rcv_buff->phys);
530 + kfree(sysfs_mbox->rcv_buff);
531 + }
532 +
533 + kfree(sysfs_mbox);
534 +}
535 +
536 +static size_t
537 +lpfc_syfs_mbox_copy_rcv_buff(struct lpfc_hba *phba,
538 + struct lpfc_sysfs_mbox *sysfs_mbox,
539 + char *buf, loff_t off, size_t count)
540 +{
541 + uint32_t size;
542 + spin_lock_irq(&phba->hbalock);
543 + if (!sysfs_mbox->mbox) {
544 + sysfs_mbox_idle(phba, sysfs_mbox);
545 + spin_unlock_irq(&phba->hbalock);
546 + return -EAGAIN;
547 + }
548 +
549 + if (sysfs_mbox->mbox->mb.mbxCommand == MBX_READ_EVENT_LOG)
550 + size = sysfs_mbox->mbox->mb.un.
551 + varRdEventLog.rcv_bde64.tus.f.bdeSize;
552 + else
553 + size = sysfs_mbox->mbox->mb.un.
554 + varBIUdiag.un.s2.rcv_bde64.tus.f.bdeSize;
555 +
556 +
557 + if ((count + off) > size) {
558 + sysfs_mbox_idle(phba, sysfs_mbox);
559 + spin_unlock_irq(&phba->hbalock);
560 + return -ERANGE;
561 + }
562 + if (count > LPFC_BPL_SIZE) {
563 + sysfs_mbox_idle(phba, sysfs_mbox);
564 + spin_unlock_irq(&phba->hbalock);
565 + return -ERANGE;
566 + }
567 + if (sysfs_mbox->extoff != off) {
568 + sysfs_mbox_idle(phba, sysfs_mbox);
569 + spin_unlock_irq(&phba->hbalock);
570 + return -EAGAIN;
571 + }
572 +
573 + memcpy(buf, (uint8_t *) sysfs_mbox->rcv_buff->virt + off, count);
574 + sysfs_mbox->extoff = off + count;
575 +
576 + if (sysfs_mbox->extoff >= size)
577 + sysfs_mbox_idle(phba, sysfs_mbox);
578 +
579 + spin_unlock_irq(&phba->hbalock);
580 +
581 + return count;
582 +}
583 +
584 +static size_t
585 +lpfc_syfs_mbox_copy_extdata(struct lpfc_hba *phba,
586 + struct lpfc_sysfs_mbox * sysfs_mbox,
587 + char *buf, loff_t off, size_t count)
588 +{
589 + uint32_t size;
590 +
591 + spin_lock_irq(&phba->hbalock);
592 + if (!sysfs_mbox->mbox) {
593 + sysfs_mbox_idle(phba, sysfs_mbox);
594 + spin_unlock_irq(&phba->hbalock);
595 + return -EAGAIN;
596 + }
597 +
598 + size = sysfs_mbox->mbox_data.out_ext_wlen * sizeof(uint32_t);
599 +
600 + if ((count + off) > size) {
601 + sysfs_mbox_idle(phba, sysfs_mbox);
602 + spin_unlock_irq(&phba->hbalock);
603 + return -ERANGE;
604 + }
605 +
606 + if (size > MAILBOX_EXT_SIZE) {
607 + sysfs_mbox_idle(phba, sysfs_mbox);
608 + spin_unlock_irq(&phba->hbalock);
609 + return -ERANGE;
610 + }
611 +
612 + if (sysfs_mbox->extoff != off) {
613 + sysfs_mbox_idle(phba, sysfs_mbox);
614 + spin_unlock_irq(&phba->hbalock);
615 + return -EAGAIN;
616 + }
617 +
618 + memcpy(buf, (uint8_t *) sysfs_mbox->mbext + off, count);
619 + sysfs_mbox->extoff = off + count;
620 +
621 + if (sysfs_mbox->extoff >= size)
622 + sysfs_mbox_idle(phba, sysfs_mbox);
623 +
624 + spin_unlock_irq(&phba->hbalock);
625 +
626 + return count;
627 +}
628 +
629 +static size_t
630 +lpfc_syfs_mbox_copy_txmit_buff(struct lpfc_hba *phba,
631 + struct lpfc_sysfs_mbox *sysfs_mbox,
632 + char *buf, loff_t off, size_t count)
633 +{
634 + uint32_t size;
635 + spin_lock_irq(&phba->hbalock);
636 + if (!sysfs_mbox->mbox ||
637 + (sysfs_mbox->offset != sizeof(struct lpfc_sysfs_mbox_data))) {
638 + sysfs_mbox_idle(phba, sysfs_mbox);
639 + spin_unlock_irq(&phba->hbalock);
640 + return -EAGAIN;
641 + }
642 +
643 + size = sysfs_mbox->mbox->mb.un.varBIUdiag.un.s2.xmit_bde64.
644 + tus.f.bdeSize;
645 +
646 + if ((count + off) > size) {
647 + sysfs_mbox_idle(phba, sysfs_mbox);
648 + spin_unlock_irq(&phba->hbalock);
649 + return -ERANGE;
650 + }
651 +
652 + if (size > LPFC_BPL_SIZE) {
653 + sysfs_mbox_idle(phba, sysfs_mbox);
654 + spin_unlock_irq(&phba->hbalock);
655 + return -ERANGE;
656 + }
657 +
658 + if (sysfs_mbox->extoff != off) {
659 + sysfs_mbox_idle(phba, sysfs_mbox);
660 + spin_unlock_irq(&phba->hbalock);
661 + return -EAGAIN;
662 + }
663 +
664 + memcpy((uint8_t *) sysfs_mbox->txmit_buff->virt + off, buf, count);
665 + sysfs_mbox->extoff = off + count;
666 +
667 + spin_unlock_irq(&phba->hbalock);
668 +
669 + return count;
670 }
671
672 /**
673 @@ -3018,6 +3527,9 @@ sysfs_mbox_write(struct kobject *kobj, s
674 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
675 struct lpfc_hba *phba = vport->phba;
676 struct lpfcMboxq *mbox = NULL;
677 + struct lpfc_sysfs_mbox *sysfs_mbox;
678 + uint8_t *ext;
679 + uint32_t size;
680
681 if ((count + off) > MAILBOX_CMD_SIZE)
682 return -ERANGE;
683 @@ -3029,34 +3541,232 @@ sysfs_mbox_write(struct kobject *kobj, s
684 return 0;
685
686 if (off == 0) {
687 + sysfs_mbox = lpfc_get_sysfs_mbox(phba, 1);
688 + if (sysfs_mbox == NULL)
689 + return -ENOMEM;
690 + /*
691 + * If sysfs expect the reading of buffer and
692 + * app doesnot know how to do it, use a different
693 + * context.
694 + */
695 + if (sysfs_mbox->state == SMBOX_READING_BUFF ||
696 + sysfs_mbox->state == SMBOX_READING_MBEXT) {
697 + spin_lock_irq(&phba->hbalock);
698 + sysfs_mbox_idle(phba, sysfs_mbox);
699 + spin_unlock_irq(&phba->hbalock);
700 + sysfs_mbox = lpfc_get_sysfs_mbox(phba, 1);
701 + if (sysfs_mbox == NULL)
702 + return -ENOMEM;
703 + }
704 + } else {
705 + sysfs_mbox = lpfc_get_sysfs_mbox(phba, 0);
706 + if (sysfs_mbox == NULL)
707 + return -EAGAIN;
708 + }
709 + spin_lock_irq(&phba->hbalock);
710 + if (sysfs_mbox->state == SMBOX_WRITING_MBEXT) {
711 + if (!sysfs_mbox->mbox ||
712 + (sysfs_mbox->offset !=
713 + sizeof(struct lpfc_sysfs_mbox_data))) {
714 + sysfs_mbox_idle(phba, sysfs_mbox);
715 + spin_unlock_irq(&phba->hbalock);
716 + return -EAGAIN;
717 + }
718 +
719 + size = sysfs_mbox->mbox_data.in_ext_wlen * sizeof(uint32_t);
720 +
721 + if ((count + sysfs_mbox->extoff) > size) {
722 + sysfs_mbox_idle(phba, sysfs_mbox);
723 + spin_unlock_irq(&phba->hbalock);
724 + return -ERANGE;
725 + }
726 +
727 + if (size > MAILBOX_EXT_SIZE) {
728 + sysfs_mbox_idle(phba, sysfs_mbox);
729 + spin_unlock_irq(&phba->hbalock);
730 + return -ERANGE;
731 + }
732 +
733 + if (!sysfs_mbox->mbext) {
734 + spin_unlock_irq(&phba->hbalock);
735 +
736 + ext = kzalloc(MAILBOX_EXT_SIZE, GFP_KERNEL);
737 + if (!ext) {
738 + spin_lock_irq(&phba->hbalock);
739 + sysfs_mbox_idle(phba, sysfs_mbox);
740 + spin_unlock_irq(&phba->hbalock);
741 + return -ENOMEM;
742 + }
743 +
744 + spin_lock_irq(&phba->hbalock);
745 + sysfs_mbox->mbext = ext;
746 + }
747 +
748 + if (sysfs_mbox->extoff != off) {
749 + sysfs_mbox_idle(phba, sysfs_mbox);
750 + spin_unlock_irq(&phba->hbalock);
751 + return -EAGAIN;
752 + }
753 +
754 + memcpy((uint8_t *) sysfs_mbox->mbext + off, buf, count);
755 + sysfs_mbox->extoff = off + count;
756 +
757 + spin_unlock_irq(&phba->hbalock);
758 +
759 + return count;
760 + }
761 +
762 + spin_unlock_irq(&phba->hbalock);
763 +
764 + if (sysfs_mbox->state == SMBOX_WRITING_BUFF)
765 + return lpfc_syfs_mbox_copy_txmit_buff(phba,
766 + sysfs_mbox, buf, off, count);
767 +
768 + if ((count + off) > sizeof(struct lpfc_sysfs_mbox_data)) {
769 + spin_lock_irq(&phba->hbalock);
770 + sysfs_mbox_idle(phba, sysfs_mbox);
771 + spin_unlock_irq(&phba->hbalock);
772 + return -ERANGE;
773 + }
774 +
775 + if (off == 0) {
776 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
777 - if (!mbox)
778 + if (!mbox) {
779 + spin_lock_irq(&phba->hbalock);
780 + sysfs_mbox_idle(phba, sysfs_mbox);
781 + spin_unlock_irq(&phba->hbalock);
782 return -ENOMEM;
783 + }
784 memset(mbox, 0, sizeof (LPFC_MBOXQ_t));
785 }
786
787 spin_lock_irq(&phba->hbalock);
788
789 if (off == 0) {
790 - if (phba->sysfs_mbox.mbox)
791 + if (sysfs_mbox->mbox)
792 mempool_free(mbox, phba->mbox_mem_pool);
793 else
794 - phba->sysfs_mbox.mbox = mbox;
795 - phba->sysfs_mbox.state = SMBOX_WRITING;
796 + sysfs_mbox->mbox = mbox;
797 + sysfs_mbox->state = SMBOX_WRITING;
798 } else {
799 - if (phba->sysfs_mbox.state != SMBOX_WRITING ||
800 - phba->sysfs_mbox.offset != off ||
801 - phba->sysfs_mbox.mbox == NULL) {
802 - sysfs_mbox_idle(phba);
803 + if (sysfs_mbox->state != SMBOX_WRITING ||
804 + sysfs_mbox->offset != off ||
805 + sysfs_mbox->mbox == NULL) {
806 + sysfs_mbox_idle(phba, sysfs_mbox);
807 spin_unlock_irq(&phba->hbalock);
808 return -EAGAIN;
809 }
810 }
811
812 - memcpy((uint8_t *) & phba->sysfs_mbox.mbox->mb + off,
813 + memcpy((uint8_t *) & sysfs_mbox->mbox_data + off,
814 buf, count);
815
816 - phba->sysfs_mbox.offset = off + count;
817 + sysfs_mbox->offset = off + count;
818 +
819 + if (sysfs_mbox->offset == sizeof(struct lpfc_sysfs_mbox_data)) {
820 + memcpy((uint8_t *) & sysfs_mbox->mbox->mb,
821 + (uint8_t *) &sysfs_mbox->mbox_data.mbox,
822 + sizeof(MAILBOX_t));
823 + }
824 +
825 + if ((sysfs_mbox->offset == sizeof(struct lpfc_sysfs_mbox_data)) &&
826 + (sysfs_mbox->mbox_data.in_ext_wlen ||
827 + sysfs_mbox->mbox_data.out_ext_wlen)) {
828 +
829 + if (!sysfs_mbox->mbext) {
830 + spin_unlock_irq(&phba->hbalock);
831 +
832 + ext = kzalloc(MAILBOX_EXT_SIZE, GFP_KERNEL);
833 + if (!ext) {
834 + spin_lock_irq(&phba->hbalock);
835 + sysfs_mbox_idle(phba, sysfs_mbox);
836 + spin_unlock_irq(&phba->hbalock);
837 + return -ENOMEM;
838 + }
839 +
840 + spin_lock_irq(&phba->hbalock);
841 + sysfs_mbox->mbext = ext;
842 + }
843 + }
844 +
845 + if ((sysfs_mbox->offset == sizeof(struct lpfc_sysfs_mbox_data)) &&
846 + (sysfs_mbox->mbox_data.in_ext_wlen)) {
847 + sysfs_mbox->state = SMBOX_WRITING_MBEXT;
848 + }
849 +
850 + if ((sysfs_mbox->offset == sizeof(struct lpfc_sysfs_mbox_data)) &&
851 + (sysfs_mbox->mbox->mb.mbxCommand == MBX_RUN_BIU_DIAG64)) {
852 + sysfs_mbox->state = SMBOX_WRITING_BUFF;
853 + spin_unlock_irq(&phba->hbalock);
854 +
855 + /* Allocate txmit buffer */
856 + sysfs_mbox->txmit_buff =
857 + kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
858 + if (!sysfs_mbox->txmit_buff) {
859 + spin_lock_irq(&phba->hbalock);
860 + sysfs_mbox_idle(phba, sysfs_mbox);
861 + spin_unlock_irq(&phba->hbalock);
862 + return -ENOMEM;
863 + }
864 + INIT_LIST_HEAD(&sysfs_mbox->txmit_buff->list);
865 + sysfs_mbox->txmit_buff->virt =
866 + lpfc_mbuf_alloc(phba, 0,
867 + &(sysfs_mbox->txmit_buff->phys));
868 + if (!sysfs_mbox->txmit_buff->virt) {
869 + spin_lock_irq(&phba->hbalock);
870 + sysfs_mbox_idle(phba, sysfs_mbox);
871 + spin_unlock_irq(&phba->hbalock);
872 + return -ENOMEM;
873 + }
874 +
875 + /* Allocate rcv buffer */
876 + sysfs_mbox->rcv_buff =
877 + kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
878 + if (!sysfs_mbox->rcv_buff) {
879 + spin_lock_irq(&phba->hbalock);
880 + sysfs_mbox_idle(phba, sysfs_mbox);
881 + spin_unlock_irq(&phba->hbalock);
882 + return -ENOMEM;
883 + }
884 + INIT_LIST_HEAD(&sysfs_mbox->rcv_buff->list);
885 + sysfs_mbox->rcv_buff->virt =
886 + lpfc_mbuf_alloc(phba, 0,
887 + &(sysfs_mbox->rcv_buff->phys));
888 + if (!sysfs_mbox->rcv_buff->virt) {
889 + spin_lock_irq(&phba->hbalock);
890 + sysfs_mbox_idle(phba, sysfs_mbox);
891 + spin_unlock_irq(&phba->hbalock);
892 + return -ENOMEM;
893 + }
894 + return count;
895 + }
896 + if ((sysfs_mbox->offset == sizeof(struct lpfc_sysfs_mbox_data)) &&
897 + (sysfs_mbox->mbox->mb.mbxCommand == MBX_READ_EVENT_LOG)) {
898 + sysfs_mbox->state = SMBOX_WRITING;
899 + spin_unlock_irq(&phba->hbalock);
900 +
901 +
902 + /* Allocate rcv buffer */
903 + sysfs_mbox->rcv_buff =
904 + kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
905 + if (!sysfs_mbox->rcv_buff) {
906 + spin_lock_irq(&phba->hbalock);
907 + sysfs_mbox_idle(phba, sysfs_mbox);
908 + spin_unlock_irq(&phba->hbalock);
909 + return -ENOMEM;
910 + }
911 + INIT_LIST_HEAD(&sysfs_mbox->rcv_buff->list);
912 + sysfs_mbox->rcv_buff->virt =
913 + lpfc_mbuf_alloc(phba, 0,
914 + &(sysfs_mbox->rcv_buff->phys));
915 + if (!sysfs_mbox->rcv_buff->virt) {
916 + spin_lock_irq(&phba->hbalock);
917 + sysfs_mbox_idle(phba, sysfs_mbox);
918 + spin_unlock_irq(&phba->hbalock);
919 + return -ENOMEM;
920 + }
921 + return count;
922 + }
923
924 spin_unlock_irq(&phba->hbalock);
925
926 @@ -3095,6 +3805,42 @@ sysfs_mbox_read(struct kobject *kobj, st
927 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
928 struct lpfc_hba *phba = vport->phba;
929 int rc;
930 + int wait_4_menlo_maint = 0;
931 + struct lpfc_sysfs_mbox *sysfs_mbox;
932 + ssize_t ret;
933 + sysfs_mbox = lpfc_get_sysfs_mbox(phba, 0);
934 +
935 + if (!sysfs_mbox)
936 + return -EPERM;
937 +
938 + /*
939 + * If sysfs expect the writing of buffer and
940 + * app doesnot know how to do it, fail the mailbox
941 + * command.
942 + */
943 + if ((sysfs_mbox->state == SMBOX_WRITING_BUFF) &&
944 + (sysfs_mbox->extoff == 0)) {
945 + spin_lock_irq(&phba->hbalock);
946 + sysfs_mbox_idle(phba, sysfs_mbox);
947 + spin_unlock_irq(&phba->hbalock);
948 + return -EINVAL;
949 + }
950 + if (sysfs_mbox->state == SMBOX_READING_BUFF) {
951 + ret = lpfc_syfs_mbox_copy_rcv_buff(phba, sysfs_mbox,
952 + buf, off, count);
953 + lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
954 + "1245 mbox: cmd 0x%x, 0x%x ret %x\n",
955 + sysfs_mbox->mbox->mb.mbxCommand,
956 + sysfs_mbox->mbox->mb.un.varWords[0],
957 + (uint32_t)ret);
958 + return ret;
959 + }
960 +
961 + if (sysfs_mbox->state == SMBOX_READING_MBEXT) {
962 + ret = lpfc_syfs_mbox_copy_extdata(phba, sysfs_mbox,
963 + buf, off, count);
964 + return ret;
965 + }
966
967 if (off > MAILBOX_CMD_SIZE)
968 return -ERANGE;
969 @@ -3111,16 +3857,18 @@ sysfs_mbox_read(struct kobject *kobj, st
970 spin_lock_irq(&phba->hbalock);
971
972 if (phba->over_temp_state == HBA_OVER_TEMP) {
973 - sysfs_mbox_idle(phba);
974 + sysfs_mbox_idle(phba, sysfs_mbox);
975 spin_unlock_irq(&phba->hbalock);
976 return -EACCES;
977 }
978
979 if (off == 0 &&
980 - phba->sysfs_mbox.state == SMBOX_WRITING &&
981 - phba->sysfs_mbox.offset >= 2 * sizeof(uint32_t)) {
982 + ((sysfs_mbox->state == SMBOX_WRITING) ||
983 + (sysfs_mbox->state == SMBOX_WRITING_MBEXT) ||
984 + (sysfs_mbox->state == SMBOX_WRITING_BUFF) ) &&
985 + sysfs_mbox->offset >= 2 * sizeof(uint32_t)) {
986
987 - switch (phba->sysfs_mbox.mbox->mb.mbxCommand) {
988 + switch (sysfs_mbox->mbox->mb.mbxCommand) {
989 /* Offline only */
990 case MBX_INIT_LINK:
991 case MBX_DOWN_LINK:
992 @@ -3133,12 +3881,11 @@ sysfs_mbox_read(struct kobject *kobj, st
993 case MBX_RUN_DIAGS:
994 case MBX_RESTART:
995 case MBX_SET_MASK:
996 - case MBX_SET_DEBUG:
997 if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
998 printk(KERN_WARNING "mbox_read:Command 0x%x "
999 "is illegal in on-line state\n",
1000 - phba->sysfs_mbox.mbox->mb.mbxCommand);
1001 - sysfs_mbox_idle(phba);
1002 + sysfs_mbox->mbox->mb.mbxCommand);
1003 + sysfs_mbox_idle(phba,sysfs_mbox);
1004 spin_unlock_irq(&phba->hbalock);
1005 return -EPERM;
1006 }
1007 @@ -3160,11 +3907,63 @@ sysfs_mbox_read(struct kobject *kobj, st
1008 case MBX_LOAD_EXP_ROM:
1009 case MBX_BEACON:
1010 case MBX_DEL_LD_ENTRY:
1011 - case MBX_SET_VARIABLE:
1012 + case MBX_SET_DEBUG:
1013 case MBX_WRITE_WWN:
1014 + case MBX_READ_EVENT_LOG_STATUS:
1015 + case MBX_WRITE_EVENT_LOG:
1016 case MBX_PORT_CAPABILITIES:
1017 case MBX_PORT_IOV_CONTROL:
1018 break;
1019 + case MBX_SET_VARIABLE:
1020 + lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1021 + "1226 mbox: set_variable 0x%x, 0x%x\n",
1022 + sysfs_mbox->mbox->mb.un.varWords[0],
1023 + sysfs_mbox->mbox->mb.un.varWords[1]);
1024 + if ((sysfs_mbox->mbox->mb.un.varWords[0] ==
1025 + SETVAR_MLOMNT) &&
1026 + (sysfs_mbox->mbox->mb.un.varWords[1] == 1)) {
1027 + wait_4_menlo_maint = 1;
1028 + phba->wait_4_mlo_maint_flg = 1;
1029 + }
1030 + break;
1031 + case MBX_RUN_BIU_DIAG64:
1032 + if (sysfs_mbox->mbox->mb.un.varBIUdiag.un.s2.
1033 + xmit_bde64.tus.f.bdeSize) {
1034 + sysfs_mbox->mbox->mb.un.varBIUdiag.un.s2.
1035 + xmit_bde64.addrHigh =
1036 + putPaddrHigh(sysfs_mbox->
1037 + txmit_buff->phys);
1038 + sysfs_mbox->mbox->mb.un.varBIUdiag.un.s2.
1039 + xmit_bde64.addrLow =
1040 + putPaddrLow(sysfs_mbox->
1041 + txmit_buff->phys);
1042 + }
1043 +
1044 + if (sysfs_mbox->mbox->mb.un.varBIUdiag.un.s2.
1045 + rcv_bde64.tus.f.bdeSize) {
1046 + sysfs_mbox->mbox->mb.un.varBIUdiag.un.s2.
1047 + rcv_bde64.addrHigh =
1048 + putPaddrHigh(sysfs_mbox->
1049 + rcv_buff->phys);
1050 + sysfs_mbox->mbox->mb.un.varBIUdiag.un.s2.
1051 + rcv_bde64.addrLow =
1052 + putPaddrLow(sysfs_mbox->rcv_buff->phys);
1053 + }
1054 + break;
1055 + case MBX_READ_EVENT_LOG:
1056 +
1057 + if (sysfs_mbox->mbox->mb.un.varRdEventLog.
1058 + rcv_bde64.tus.f.bdeSize) {
1059 + sysfs_mbox->mbox->mb.un.varRdEventLog.
1060 + rcv_bde64.addrHigh =
1061 + putPaddrHigh(sysfs_mbox->
1062 + rcv_buff->phys);
1063 + sysfs_mbox->mbox->mb.un.varRdEventLog.
1064 + rcv_bde64.addrLow =
1065 + putPaddrLow(sysfs_mbox->rcv_buff->phys);
1066 + }
1067 + break;
1068 +
1069 case MBX_READ_SPARM64:
1070 case MBX_READ_LA:
1071 case MBX_READ_LA64:
1072 @@ -3173,38 +3972,51 @@ sysfs_mbox_read(struct kobject *kobj, st
1073 case MBX_CONFIG_PORT:
1074 case MBX_RUN_BIU_DIAG:
1075 printk(KERN_WARNING "mbox_read: Illegal Command 0x%x\n",
1076 - phba->sysfs_mbox.mbox->mb.mbxCommand);
1077 - sysfs_mbox_idle(phba);
1078 + sysfs_mbox->mbox->mb.mbxCommand);
1079 + sysfs_mbox_idle(phba,sysfs_mbox);
1080 spin_unlock_irq(&phba->hbalock);
1081 return -EPERM;
1082 default:
1083 printk(KERN_WARNING "mbox_read: Unknown Command 0x%x\n",
1084 - phba->sysfs_mbox.mbox->mb.mbxCommand);
1085 - sysfs_mbox_idle(phba);
1086 + sysfs_mbox->mbox->mb.mbxCommand);
1087 + sysfs_mbox_idle(phba,sysfs_mbox);
1088 spin_unlock_irq(&phba->hbalock);
1089 return -EPERM;
1090 }
1091
1092 + if (sysfs_mbox->mbox_data.in_ext_wlen ||
1093 + sysfs_mbox->mbox_data.out_ext_wlen) {
1094 + sysfs_mbox->mbox->context2 = sysfs_mbox->mbext;
1095 + sysfs_mbox->mbox->in_ext_byte_len =
1096 + sysfs_mbox->mbox_data.in_ext_wlen *
1097 + sizeof(uint32_t);
1098 + sysfs_mbox->mbox->out_ext_byte_len =
1099 + sysfs_mbox->mbox_data.out_ext_wlen *
1100 + sizeof(uint32_t);
1101 + sysfs_mbox->mbox->mbox_offset_word =
1102 + sysfs_mbox->mbox_data.mboffset;
1103 + }
1104 +
1105 /* If HBA encountered an error attention, allow only DUMP
1106 * or RESTART mailbox commands until the HBA is restarted.
1107 */
1108 if (phba->pport->stopped &&
1109 - phba->sysfs_mbox.mbox->mb.mbxCommand != MBX_DUMP_MEMORY &&
1110 - phba->sysfs_mbox.mbox->mb.mbxCommand != MBX_RESTART &&
1111 - phba->sysfs_mbox.mbox->mb.mbxCommand != MBX_WRITE_VPARMS &&
1112 - phba->sysfs_mbox.mbox->mb.mbxCommand != MBX_WRITE_WWN)
1113 + sysfs_mbox->mbox->mb.mbxCommand != MBX_DUMP_MEMORY &&
1114 + sysfs_mbox->mbox->mb.mbxCommand != MBX_RESTART &&
1115 + sysfs_mbox->mbox->mb.mbxCommand != MBX_WRITE_VPARMS &&
1116 + sysfs_mbox->mbox->mb.mbxCommand != MBX_WRITE_WWN)
1117 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
1118 "1259 mbox: Issued mailbox cmd "
1119 "0x%x while in stopped state.\n",
1120 - phba->sysfs_mbox.mbox->mb.mbxCommand);
1121 + sysfs_mbox->mbox->mb.mbxCommand);
1122
1123 - phba->sysfs_mbox.mbox->vport = vport;
1124 + sysfs_mbox->mbox->vport = vport;
1125
1126 /* Don't allow mailbox commands to be sent when blocked
1127 * or when in the middle of discovery
1128 */
1129 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
1130 - sysfs_mbox_idle(phba);
1131 + sysfs_mbox_idle(phba,sysfs_mbox);
1132 spin_unlock_irq(&phba->hbalock);
1133 return -EAGAIN;
1134 }
1135 @@ -3214,43 +4026,86 @@ sysfs_mbox_read(struct kobject *kobj, st
1136
1137 spin_unlock_irq(&phba->hbalock);
1138 rc = lpfc_sli_issue_mbox (phba,
1139 - phba->sysfs_mbox.mbox,
1140 + sysfs_mbox->mbox,
1141 MBX_POLL);
1142 spin_lock_irq(&phba->hbalock);
1143
1144 } else {
1145 spin_unlock_irq(&phba->hbalock);
1146 rc = lpfc_sli_issue_mbox_wait (phba,
1147 - phba->sysfs_mbox.mbox,
1148 + sysfs_mbox->mbox,
1149 lpfc_mbox_tmo_val(phba,
1150 - phba->sysfs_mbox.mbox->mb.mbxCommand) * HZ);
1151 + sysfs_mbox->mbox->mb.mbxCommand) * HZ);
1152 spin_lock_irq(&phba->hbalock);
1153 }
1154
1155 if (rc != MBX_SUCCESS) {
1156 if (rc == MBX_TIMEOUT) {
1157 - phba->sysfs_mbox.mbox = NULL;
1158 + sysfs_mbox->mbox = NULL;
1159 }
1160 - sysfs_mbox_idle(phba);
1161 + sysfs_mbox_idle(phba,sysfs_mbox);
1162 spin_unlock_irq(&phba->hbalock);
1163 return (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
1164 }
1165 - phba->sysfs_mbox.state = SMBOX_READING;
1166 + if (wait_4_menlo_maint) {
1167 + lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
1168 + "1229 waiting for menlo mnt\n");
1169 + spin_unlock_irq(&phba->hbalock);
1170 + if (phba->wait_4_mlo_maint_flg)
1171 + wait_event_interruptible_timeout(
1172 + phba->wait_4_mlo_m_q,
1173 + phba->wait_4_mlo_maint_flg == 0,
1174 + 60 * HZ);
1175 + spin_lock_irq(&phba->hbalock);
1176 + if (phba->wait_4_mlo_maint_flg) {
1177 + sysfs_mbox_idle(phba,sysfs_mbox);
1178 + phba->wait_4_mlo_maint_flg = 0;
1179 + spin_unlock_irq(&phba->hbalock);
1180 + return -EINTR;
1181 + } else
1182 + spin_unlock_irq(&phba->hbalock);
1183 +
1184 + spin_lock_irq(&phba->hbalock);
1185 + if (phba->wait_4_mlo_maint_flg != 0) {
1186 + sysfs_mbox_idle(phba,sysfs_mbox);
1187 + phba->wait_4_mlo_maint_flg = 0;
1188 + spin_unlock_irq(&phba->hbalock);
1189 + return -ETIME;
1190 + }
1191 +
1192 + }
1193 + sysfs_mbox->state = SMBOX_READING;
1194 }
1195 - else if (phba->sysfs_mbox.offset != off ||
1196 - phba->sysfs_mbox.state != SMBOX_READING) {
1197 - printk(KERN_WARNING "mbox_read: Bad State\n");
1198 - sysfs_mbox_idle(phba);
1199 + else if (sysfs_mbox->offset != off ||
1200 + sysfs_mbox->state != SMBOX_READING) {
1201 + sysfs_mbox_idle(phba,sysfs_mbox);
1202 spin_unlock_irq(&phba->hbalock);
1203 return -EAGAIN;
1204 }
1205
1206 - memcpy(buf, (uint8_t *) & phba->sysfs_mbox.mbox->mb + off, count);
1207 + memcpy(buf, (uint8_t *) & sysfs_mbox->mbox->mb + off, count);
1208 +
1209 + sysfs_mbox->offset = off + count;
1210
1211 - phba->sysfs_mbox.offset = off + count;
1212 + if ((sysfs_mbox->offset == MAILBOX_CMD_SIZE) &&
1213 + ((sysfs_mbox->mbox->mb.mbxCommand == MBX_RUN_BIU_DIAG64) ||
1214 + (sysfs_mbox->mbox->mb.mbxCommand == MBX_READ_EVENT_LOG))) {
1215 + sysfs_mbox->state = SMBOX_READING_BUFF;
1216 + sysfs_mbox->extoff = 0;
1217 + spin_unlock_irq(&phba->hbalock);
1218 + return count;
1219 + }
1220 +
1221 + if ((sysfs_mbox->offset == MAILBOX_CMD_SIZE) &&
1222 + sysfs_mbox->mbox_data.out_ext_wlen) {
1223 + sysfs_mbox->state = SMBOX_READING_MBEXT;
1224 + sysfs_mbox->extoff = 0;
1225 + spin_unlock_irq(&phba->hbalock);
1226 + return count;
1227 + }
1228
1229 - if (phba->sysfs_mbox.offset == MAILBOX_CMD_SIZE)
1230 - sysfs_mbox_idle(phba);
1231 + if (sysfs_mbox->offset == MAILBOX_CMD_SIZE)
1232 + sysfs_mbox_idle(phba,sysfs_mbox);
1233
1234 spin_unlock_irq(&phba->hbalock);
1235
1236 @@ -3262,7 +4117,7 @@ static struct bin_attribute sysfs_mbox_a
1237 .name = "mbox",
1238 .mode = S_IRUSR | S_IWUSR,
1239 },
1240 - .size = MAILBOX_CMD_SIZE,
1241 + .size = MAILBOX_MAX_XMIT_SIZE,
1242 .read = sysfs_mbox_read,
1243 .write = sysfs_mbox_write,
1244 };
1245 @@ -3317,6 +4172,7 @@ lpfc_free_sysfs_attr(struct lpfc_vport *
1246 &sysfs_drvr_stat_data_attr);
1247 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
1248 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
1249 + sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_menlo_attr);
1250 }
1251
1252
1253 @@ -3935,7 +4791,6 @@ lpfc_get_cfgparam(struct lpfc_hba *phba)
1254 phba->cfg_soft_wwpn = 0L;
1255 lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
1256 /* Also reinitialize the host templates with new values. */
1257 - lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
1258 lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
1259 /*
1260 * Since the sg_tablesize is module parameter, the sg_dma_buf_size
1261 @@ -3970,5 +4825,6 @@ lpfc_get_vport_cfgparam(struct lpfc_vpor
1262 lpfc_max_luns_init(vport, lpfc_max_luns);
1263 lpfc_scan_down_init(vport, lpfc_scan_down);
1264 lpfc_enable_da_id_init(vport, lpfc_enable_da_id);
1265 + lpfc_enable_auth_init(vport, lpfc_enable_auth);
1266 return;
1267 }
1268 --- /dev/null
1269 +++ b/drivers/scsi/lpfc/lpfc_auth_access.c
1270 @@ -0,0 +1,598 @@
1271 +/*******************************************************************
1272 + * This file is part of the Emulex Linux Device Driver for *
1273 + * Fibre Channel Host Bus Adapters. *
1274 + * Copyright (C) 2006-2007 Emulex. All rights reserved. *
1275 + * EMULEX and SLI are trademarks of Emulex. *
1276 + * www.emulex.com *
1277 + * *
1278 + * This program is free software; you can redistribute it and/or *
1279 + * modify it under the terms of version 2 of the GNU General *
1280 + * Public License as published by the Free Software Foundation. *
1281 + * This program is distributed in the hope that it will be useful. *
1282 + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
1283 + * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
1284 + * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
1285 + * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
1286 + * TO BE LEGALLY INVALID. See the GNU General Public License for *
1287 + * more details, a copy of which can be found in the file COPYING *
1288 + * included with this package. *
1289 + *******************************************************************/
1290 +#include <linux/blkdev.h>
1291 +#include <linux/pci.h>
1292 +#include <linux/kthread.h>
1293 +#include <linux/interrupt.h>
1294 +
1295 +#include <linux/module.h>
1296 +#include <linux/init.h>
1297 +#include <linux/sched.h> /* workqueue stuff, HZ */
1298 +#include <scsi/scsi_device.h>
1299 +#include <scsi/scsi_host.h>
1300 +#include <scsi/scsi_transport.h>
1301 +#include <scsi/scsi_transport_fc.h>
1302 +#include <scsi/scsi_cmnd.h>
1303 +#include <linux/time.h>
1304 +#include <linux/jiffies.h>
1305 +#include <linux/security.h>
1306 +#include <net/sock.h>
1307 +#include <net/netlink.h>
1308 +
1309 +#include <scsi/scsi.h>
1310 +
1311 +#include "lpfc_hw.h"
1312 +#include "lpfc_sli.h"
1313 +#include "lpfc_nl.h"
1314 +#include "lpfc_disc.h"
1315 +#include "lpfc_scsi.h"
1316 +#include "lpfc.h"
1317 +#include "lpfc_logmsg.h"
1318 +#include "lpfc_crtn.h"
1319 +#include "lpfc_vport.h"
1320 +#include "lpfc_auth_access.h"
1321 +
1322 +/* fc security */
1323 +struct workqueue_struct *security_work_q = NULL;
1324 +struct list_head fc_security_user_list;
1325 +int fc_service_state = FC_SC_SERVICESTATE_UNKNOWN;
1326 +static int fc_service_pid;
1327 +DEFINE_SPINLOCK(fc_security_user_lock);
1328 +
1329 +static inline struct lpfc_vport *
1330 +lpfc_fc_find_vport(unsigned long host_no)
1331 +{
1332 + struct lpfc_vport *vport;
1333 + struct Scsi_Host *shost;
1334 +
1335 + list_for_each_entry(vport, &fc_security_user_list, sc_users) {
1336 + shost = lpfc_shost_from_vport(vport);
1337 + if (shost && (shost->host_no == host_no))
1338 + return vport;
1339 + }
1340 +
1341 + return NULL;
1342 +}
1343 +
1344 +
1345 +/**
1346 + * lpfc_fc_sc_add_timer
1347 + *
1348 + *
1349 + **/
1350 +
1351 +void
1352 +lpfc_fc_sc_add_timer(struct fc_security_request *req, int timeout,
1353 + void (*complete)(struct fc_security_request *))
1354 +{
1355 +
1356 + init_timer(&req->timer);
1357 +
1358 +
1359 + req->timer.data = (unsigned long)req;
1360 + req->timer.expires = jiffies + timeout;
1361 + req->timer.function = (void (*)(unsigned long)) complete;
1362 +
1363 + add_timer(&req->timer);
1364 +}
1365 +/**
1366 + * lpfc_fc_sc_req_times_out
1367 + *
1368 + *
1369 + **/
1370 +
1371 +void
1372 +lpfc_fc_sc_req_times_out(struct fc_security_request *req)
1373 +{
1374 +
1375 + unsigned long flags;
1376 + int found = 0;
1377 + struct fc_security_request *fc_sc_req;
1378 + struct lpfc_vport *vport = req->vport;
1379 + struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1380 +
1381 + if (!req)
1382 + return;
1383 +
1384 + spin_lock_irqsave(shost->host_lock, flags);
1385 +
1386 + /* To avoid a completion race check to see if request is on the list */
1387 +
1388 + list_for_each_entry(fc_sc_req, &vport->sc_response_wait_queue, rlist)
1389 + if (fc_sc_req == req) {
1390 + found = 1;
1391 + break;
1392 + }
1393 +
1394 + if (!found) {
1395 + spin_unlock_irqrestore(shost->host_lock, flags);
1396 + return;
1397 + }
1398 +
1399 + list_del(&fc_sc_req->rlist);
1400 +
1401 + spin_unlock_irqrestore(shost->host_lock, flags);
1402 +
1403 + lpfc_printf_vlog(vport, KERN_WARNING, LOG_SECURITY,
1404 + "1019 Request tranid %d timed out\n",
1405 + fc_sc_req->tran_id);
1406 +
1407 + switch (fc_sc_req->req_type) {
1408 +
1409 + case FC_NL_SC_GET_CONFIG_REQ:
1410 + lpfc_security_config(shost, -ETIMEDOUT,
1411 + fc_sc_req->data);
1412 + break;
1413 +
1414 + case FC_NL_SC_DHCHAP_MAKE_CHALLENGE_REQ:
1415 + lpfc_dhchap_make_challenge(shost, -ETIMEDOUT,
1416 + fc_sc_req->data, 0);
1417 + break;
1418 +
1419 + case FC_NL_SC_DHCHAP_MAKE_RESPONSE_REQ:
1420 + lpfc_dhchap_make_response(shost, -ETIMEDOUT,
1421 + fc_sc_req->data, 0);
1422 + break;
1423 +
1424 + case FC_NL_SC_DHCHAP_AUTHENTICATE_REQ:
1425 + lpfc_dhchap_authenticate(shost, -ETIMEDOUT, fc_sc_req->data, 0);
1426 + break;
1427 + }
1428 +
1429 + kfree(fc_sc_req);
1430 +
1431 +}
1432 +
1433 +
1434 +static inline struct fc_security_request *
1435 +lpfc_fc_find_sc_request(u32 tran_id, u32 type, struct lpfc_vport *vport)
1436 +{
1437 + struct fc_security_request *fc_sc_req;
1438 +
1439 + list_for_each_entry(fc_sc_req, &vport->sc_response_wait_queue, rlist)
1440 + if (fc_sc_req->tran_id == tran_id &&
1441 + fc_sc_req->req_type == type)
1442 + return fc_sc_req;
1443 + return NULL;
1444 +}
1445 +
1446 +
1447 +
1448 +/**
1449 + * lpfc_fc_sc_request
1450 + *
1451 + *
1452 + **/
1453 +
1454 +int
1455 +lpfc_fc_sc_request(struct lpfc_vport *vport,
1456 + u32 msg_type,
1457 + struct fc_auth_req *auth_req,
1458 + u32 auth_req_len, /* includes length of struct fc_auth_req */
1459 + struct fc_auth_rsp *auth_rsp,
1460 + u32 auth_rsp_len) /* includes length of struct fc_auth_rsp */
1461 +{
1462 + struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1463 + struct fc_security_request *fc_sc_req;
1464 + struct fc_nl_sc_message *fc_nl_sc_msg;
1465 + unsigned long flags;
1466 + u32 len;
1467 + u32 seq = ++vport->sc_tran_id;
1468 +
1469 + if (fc_service_state != FC_SC_SERVICESTATE_ONLINE)
1470 + return -EINVAL;
1471 +
1472 + if (vport->port_state == FC_PORTSTATE_DELETED)
1473 + return -EINVAL;
1474 +
1475 + fc_sc_req = kzalloc(sizeof(struct fc_security_request), GFP_KERNEL);
1476 + if (!fc_sc_req)
1477 + return -ENOMEM;
1478 +
1479 + fc_sc_req->req_type = msg_type;
1480 + fc_sc_req->data = auth_rsp;
1481 + fc_sc_req->data_len = auth_rsp_len;
1482 + fc_sc_req->vport = vport;
1483 + fc_sc_req->tran_id = seq;
1484 +
1485 + len = sizeof(struct fc_nl_sc_message) + auth_req_len;
1486 + fc_nl_sc_msg = kzalloc(sizeof(struct fc_nl_sc_message) + auth_req_len,
1487 + GFP_KERNEL);
1488 + if (!fc_nl_sc_msg)
1489 + return -ENOMEM;
1490 + fc_nl_sc_msg->msgtype = msg_type;
1491 + fc_nl_sc_msg->data_len = auth_req_len;
1492 + memcpy(fc_nl_sc_msg->data, auth_req, auth_req_len);
1493 + fc_nl_sc_msg->tran_id = seq;
1494 +
1495 + spin_lock_irqsave(shost->host_lock, flags);
1496 + list_add_tail(&fc_sc_req->rlist, &vport->sc_response_wait_queue);
1497 + spin_unlock_irqrestore(shost->host_lock, flags);
1498 + scsi_nl_send_vendor_msg(fc_service_pid, shost->host_no,
1499 + (SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX),
1500 + (char *) fc_nl_sc_msg, len);
1501 + lpfc_fc_sc_add_timer(fc_sc_req, FC_SC_REQ_TIMEOUT,
1502 + lpfc_fc_sc_req_times_out);
1503 + return 0;
1504 +}
1505 +
1506 +/**
1507 + * lpfc_fc_security_get_config
1508 + *
1509 + *
1510 + **/
1511 +
1512 +int
1513 +lpfc_fc_security_get_config(struct Scsi_Host *shost,
1514 + struct fc_auth_req *auth_req,
1515 + u32 auth_req_len,
1516 + struct fc_auth_rsp *auth_rsp,
1517 + u32 auth_rsp_len)
1518 +{
1519 +
1520 + return(lpfc_fc_sc_request((struct lpfc_vport *) shost->hostdata,
1521 + FC_NL_SC_GET_CONFIG_REQ, auth_req,
1522 + auth_req_len, auth_rsp, auth_rsp_len));
1523 +
1524 +}
1525 +EXPORT_SYMBOL(lpfc_fc_security_get_config);
1526 +
1527 +/**
1528 + * lpfc_fc_security_dhchap_make_challenge
1529 + *
1530 + *
1531 + **/
1532 +
1533 +int
1534 +lpfc_fc_security_dhchap_make_challenge(struct Scsi_Host *shost,
1535 + struct fc_auth_req *auth_req,
1536 + u32 auth_req_len,
1537 + struct fc_auth_rsp *auth_rsp,
1538 + u32 auth_rsp_len)
1539 +{
1540 +
1541 + return(lpfc_fc_sc_request((struct lpfc_vport *) shost->hostdata,
1542 + FC_NL_SC_DHCHAP_MAKE_CHALLENGE_REQ,
1543 + auth_req, auth_req_len, auth_rsp, auth_rsp_len));
1544 +
1545 +}
1546 +EXPORT_SYMBOL(lpfc_fc_security_dhchap_make_challenge);
1547 +
1548 +/**
1549 + * lpfc_fc_security_dhchap_make_response
1550 + *
1551 + *
1552 + **/
1553 +
1554 +int
1555 +lpfc_fc_security_dhchap_make_response(struct Scsi_Host *shost,
1556 + struct fc_auth_req *auth_req,
1557 + u32 auth_req_len,
1558 + struct fc_auth_rsp *auth_rsp,
1559 + u32 auth_rsp_len)
1560 +{
1561 +
1562 + return(lpfc_fc_sc_request((struct lpfc_vport *) shost->hostdata,
1563 + FC_NL_SC_DHCHAP_MAKE_RESPONSE_REQ,
1564 + auth_req, auth_req_len, auth_rsp, auth_rsp_len));
1565 +
1566 +}
1567 +EXPORT_SYMBOL(lpfc_fc_security_dhchap_make_response);
1568 +
1569 +
1570 +/**
1571 + * lpfc_fc_security_dhchap_authenticate
1572 + *
1573 + *
1574 + **/
1575 +
1576 +int
1577 +lpfc_fc_security_dhchap_authenticate(struct Scsi_Host *shost,
1578 + struct fc_auth_req *auth_req,
1579 + u32 auth_req_len,
1580 + struct fc_auth_rsp *auth_rsp,
1581 + u32 auth_rsp_len)
1582 +{
1583 +
1584 + return(lpfc_fc_sc_request((struct lpfc_vport *) shost->hostdata,
1585 + FC_NL_SC_DHCHAP_AUTHENTICATE_REQ,
1586 + auth_req, auth_req_len, auth_rsp, auth_rsp_len));
1587 +
1588 +}
1589 +EXPORT_SYMBOL(lpfc_fc_security_dhchap_authenticate);
1590 +
1591 +/**
1592 + * lpfc_fc_queue_security_work - Queue work to the fc_host security workqueue.
1593 + * @shost: Pointer to Scsi_Host bound to fc_host.
1594 + * @work: Work to queue for execution.
1595 + *
1596 + * Return value:
1597 + * 1 - work queued for execution
1598 + * 0 - work is already queued
1599 + * -EINVAL - work queue doesn't exist
1600 + **/
1601 +int
1602 +lpfc_fc_queue_security_work(struct lpfc_vport *vport, struct work_struct *work)
1603 +{
1604 + if (unlikely(!security_work_q)) {
1605 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
1606 + "1021 ERROR: attempted to queue security work, "
1607 + "when no workqueue created.\n");
1608 + dump_stack();
1609 +
1610 + return -EINVAL;
1611 + }
1612 +
1613 + return queue_work(security_work_q, work);
1614 +
1615 +}
1616 +
1617 +
1618 +
1619 + /**
1620 + * lpfc_fc_sc_schedule_notify_all
1621 + *
1622 + *
1623 + **/
1624 +
1625 +void
1626 +lpfc_fc_sc_schedule_notify_all(int message)
1627 +{
1628 + struct lpfc_vport *vport;
1629 + unsigned long flags;
1630 +
1631 + spin_lock_irqsave(&fc_security_user_lock, flags);
1632 +
1633 + list_for_each_entry(vport, &fc_security_user_list, sc_users) {
1634 +
1635 + switch (message) {
1636 +
1637 + case FC_NL_SC_REG:
1638 + lpfc_fc_queue_security_work(vport,
1639 + &vport->sc_online_work);
1640 + break;
1641 +
1642 + case FC_NL_SC_DEREG:
1643 + lpfc_fc_queue_security_work(vport,
1644 + &vport->sc_offline_work);
1645 + break;
1646 + }
1647 + }
1648 +
1649 + spin_unlock_irqrestore(&fc_security_user_lock, flags);
1650 +}
1651 +
1652 +
1653 +
1654 +/**
1655 + * lpfc_fc_sc_security_online
1656 + *
1657 + *
1658 + **/
1659 +
1660 +void
1661 +lpfc_fc_sc_security_online(struct work_struct *work)
1662 +{
1663 + struct lpfc_vport *vport = container_of(work, struct lpfc_vport,
1664 + sc_online_work);
1665 + lpfc_security_service_online(lpfc_shost_from_vport(vport));
1666 + return;
1667 +}
1668 +
1669 +/**
1670 + * lpfc_fc_sc_security_offline
1671 + *
1672 + *
1673 + **/
1674 +void
1675 +lpfc_fc_sc_security_offline(struct work_struct *work)
1676 +{
1677 + struct lpfc_vport *vport = container_of(work, struct lpfc_vport,
1678 + sc_offline_work);
1679 + lpfc_security_service_offline(lpfc_shost_from_vport(vport));
1680 + return;
1681 +}
1682 +
1683 +
1684 +/**
1685 + * lpfc_fc_sc_process_msg
1686 + *
1687 + *
1688 + **/
1689 +static void
1690 +lpfc_fc_sc_process_msg(struct work_struct *work)
1691 +{
1692 + struct fc_sc_msg_work_q_wrapper *wqw =
1693 + container_of(work, struct fc_sc_msg_work_q_wrapper, work);
1694 +
1695 + switch (wqw->msgtype) {
1696 +
1697 + case FC_NL_SC_GET_CONFIG_RSP:
1698 + lpfc_security_config(lpfc_shost_from_vport(wqw->fc_sc_req->
1699 + vport), wqw->status,
1700 + wqw->fc_sc_req->data);
1701 + break;
1702 +
1703 + case FC_NL_SC_DHCHAP_MAKE_CHALLENGE_RSP:
1704 + lpfc_dhchap_make_challenge(lpfc_shost_from_vport(wqw->
1705 + fc_sc_req->vport), wqw->status,
1706 + wqw->fc_sc_req->data, wqw->data_len);
1707 + break;
1708 +
1709 + case FC_NL_SC_DHCHAP_MAKE_RESPONSE_RSP:
1710 + lpfc_dhchap_make_response(lpfc_shost_from_vport(wqw->
1711 + fc_sc_req->vport), wqw->status,
1712 + wqw->fc_sc_req->data, wqw->data_len);
1713 + break;
1714 +
1715 + case FC_NL_SC_DHCHAP_AUTHENTICATE_RSP:
1716 + lpfc_dhchap_authenticate(lpfc_shost_from_vport(wqw->fc_sc_req->
1717 + vport),
1718 + wqw->status,
1719 + wqw->fc_sc_req->data, wqw->data_len);
1720 + break;
1721 + }
1722 +
1723 + kfree(wqw->fc_sc_req);
1724 + kfree(wqw);
1725 +
1726 + return;
1727 +}
1728 +
1729 +
1730 +/**
1731 + * lpfc_fc_sc_schedule_msg
1732 + *
1733 + *
1734 + **/
1735 +
1736 +int
1737 +lpfc_fc_sc_schedule_msg(struct Scsi_Host *shost,
1738 + struct fc_nl_sc_message *fc_nl_sc_msg, int rcvlen)
1739 +{
1740 + struct fc_security_request *fc_sc_req;
1741 + u32 req_type;
1742 + struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1743 + int err = 0;
1744 + struct fc_sc_msg_work_q_wrapper *wqw;
1745 + unsigned long flags;
1746 +
1747 + if (vport->port_state == FC_PORTSTATE_DELETED) {
1748 + printk(KERN_WARNING
1749 + "%s: Host being deleted.\n", __func__);
1750 + return -EBADR;
1751 + }
1752 +
1753 + wqw = kzalloc(sizeof(struct fc_sc_msg_work_q_wrapper), GFP_KERNEL);
1754 +
1755 + if (!wqw)
1756 + return -ENOMEM;
1757 +
1758 + switch (fc_nl_sc_msg->msgtype) {
1759 + case FC_NL_SC_GET_CONFIG_RSP:
1760 + req_type = FC_NL_SC_GET_CONFIG_REQ;
1761 + break;
1762 +
1763 + case FC_NL_SC_DHCHAP_MAKE_CHALLENGE_RSP:
1764 + req_type = FC_NL_SC_DHCHAP_MAKE_CHALLENGE_REQ;
1765 + break;
1766 +
1767 + case FC_NL_SC_DHCHAP_MAKE_RESPONSE_RSP:
1768 + req_type = FC_NL_SC_DHCHAP_MAKE_RESPONSE_REQ;
1769 + break;
1770 +
1771 + case FC_NL_SC_DHCHAP_AUTHENTICATE_RSP:
1772 + req_type = FC_NL_SC_DHCHAP_AUTHENTICATE_REQ;
1773 + break;
1774 +
1775 + default:
1776 + kfree(wqw);
1777 + return -EINVAL;
1778 + }
1779 +
1780 + spin_lock_irqsave(shost->host_lock, flags);
1781 +
1782 + fc_sc_req = lpfc_fc_find_sc_request(fc_nl_sc_msg->tran_id,
1783 + req_type, vport);
1784 +
1785 + if (!fc_sc_req) {
1786 + spin_unlock_irqrestore(shost->host_lock, flags);
1787 + lpfc_printf_vlog(vport, KERN_WARNING, LOG_SECURITY,
1788 + "1022 Security request does not exist.\n");
1789 + kfree(wqw);
1790 + return -EBADR;
1791 + }
1792 +
1793 + list_del(&fc_sc_req->rlist);
1794 +
1795 + spin_unlock_irqrestore(shost->host_lock, flags);
1796 +
1797 + del_singleshot_timer_sync(&fc_sc_req->timer);
1798 +
1799 + wqw->status = 0;
1800 + wqw->fc_sc_req = fc_sc_req;
1801 + wqw->data_len = rcvlen;
1802 + wqw->msgtype = fc_nl_sc_msg->msgtype;
1803 +
1804 + if (!fc_sc_req->data ||
1805 + (fc_sc_req->data_len < fc_nl_sc_msg->data_len)) {
1806 + wqw->status = -ENOBUFS;
1807 + wqw->data_len = 0;
1808 + lpfc_printf_vlog(vport, KERN_WARNING, LOG_SECURITY,
1809 + "1023 Warning - data may have been truncated. "
1810 + "data:%p reqdl:%x mesdl:%x\n",
1811 + fc_sc_req->data,
1812 + fc_sc_req->data_len, fc_nl_sc_msg->data_len);
1813 + } else {
1814 + memcpy(fc_sc_req->data, fc_nl_sc_msg->data,
1815 + fc_nl_sc_msg->data_len);
1816 + }
1817 +
1818 + INIT_WORK(&wqw->work, lpfc_fc_sc_process_msg);
1819 + lpfc_fc_queue_security_work(vport, &wqw->work);
1820 +
1821 + return err;
1822 +}
1823 +
1824 +int
1825 +lpfc_rcv_nl_msg(struct Scsi_Host *shost, void *payload,
1826 + uint32_t len, uint32_t pid)
1827 +{
1828 + struct fc_nl_sc_message *msg = (struct fc_nl_sc_message *)payload;
1829 + int err = 0;
1830 +
1831 + switch (msg->msgtype) {
1832 + case FC_NL_SC_REG:
1833 + fc_service_pid = pid;
1834 + fc_service_state = FC_SC_SERVICESTATE_ONLINE;
1835 + lpfc_fc_sc_schedule_notify_all(FC_NL_SC_REG);
1836 + break;
1837 + case FC_NL_SC_DEREG:
1838 + fc_service_pid = pid;
1839 + fc_service_state = FC_SC_SERVICESTATE_OFFLINE;
1840 + lpfc_fc_sc_schedule_notify_all(FC_NL_SC_DEREG);
1841 + break;
1842 + case FC_NL_SC_GET_CONFIG_RSP:
1843 + case FC_NL_SC_DHCHAP_MAKE_CHALLENGE_RSP:
1844 + case FC_NL_SC_DHCHAP_MAKE_RESPONSE_RSP:
1845 + case FC_NL_SC_DHCHAP_AUTHENTICATE_RSP:
1846 + err = lpfc_fc_sc_schedule_msg(shost, msg, len);
1847 + break;
1848 + default:
1849 + printk(KERN_WARNING "%s: unknown msg type 0x%x len %d\n",
1850 + __func__, msg->msgtype, len);
1851 + break;
1852 + }
1853 + return err;
1854 +}
1855 +
1856 +void
1857 +lpfc_rcv_nl_event(struct notifier_block *this,
1858 + unsigned long event,
1859 + void *ptr)
1860 +{
1861 + struct netlink_notify *n = ptr;
1862 + if ((event == NETLINK_URELEASE) &&
1863 + (n->protocol == NETLINK_SCSITRANSPORT) && (n->pid)) {
1864 + printk(KERN_WARNING "Warning - Security Service Offline\n");
1865 + fc_service_state = FC_SC_SERVICESTATE_OFFLINE;
1866 + lpfc_fc_sc_schedule_notify_all(FC_NL_SC_DEREG);
1867 + }
1868 +}
1869 --- /dev/null
1870 +++ b/drivers/scsi/lpfc/lpfc_auth_access.h
1871 @@ -0,0 +1,245 @@
1872 +/*******************************************************************
1873 + * This file is part of the Emulex Linux Device Driver for *
1874 + * Fibre Channel Host Bus Adapters. *
1875 + * Copyright (C) 2006-2007 Emulex. All rights reserved. *
1876 + * EMULEX and SLI are trademarks of Emulex. *
1877 + * www.emulex.com *
1878 + * *
1879 + * This program is free software; you can redistribute it and/or *
1880 + * modify it under the terms of version 2 of the GNU General *
1881 + * Public License as published by the Free Software Foundation. *
1882 + * This program is distributed in the hope that it will be useful. *
1883 + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
1884 + * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
1885 + * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
1886 + * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
1887 + * TO BE LEGALLY INVALID. See the GNU General Public License for *
1888 + * more details, a copy of which can be found in the file COPYING *
1889 + * included with this package. *
1890 + *******************************************************************/
1891 +
1892 +#define to_fc_internal(tmpl) container_of(tmpl, struct fc_internal, t)
1893 +
1894 +/* scsi_nl_hdr->version value */
1895 +#define SCSI_NL_VERSION 1
1896 +
1897 +/* scsi_nl_hdr->magic value */
1898 +#define SCSI_NL_MAGIC 0xA1B2
1899 +
1900 +/* scsi_nl_hdr->transport value */
1901 +#define SCSI_NL_TRANSPORT 0
1902 +#define SCSI_NL_TRANSPORT_FC 1
1903 +#define SCSI_NL_MAX_TRANSPORTS 2
1904 +
1905 +#define FC_NL_GROUP_CNT 0
1906 +
1907 + /* Note: when specifying vendor_id to fc_host_post_vendor_event()
1908 + * be sure to read the Vendor Type and ID formatting requirements
1909 + * specified in scsi_netlink.h
1910 + */
1911 +
1912 +#define FC_SC_REQ_TIMEOUT (60*HZ)
1913 +
1914 +enum fc_sc_service_state {
1915 + FC_SC_SERVICESTATE_UNKNOWN,
1916 + FC_SC_SERVICESTATE_ONLINE,
1917 + FC_SC_SERVICESTATE_OFFLINE,
1918 + FC_SC_SERVICESTATE_ERROR,
1919 +};
1920 +
1921 +struct fc_security_request {
1922 + struct list_head rlist;
1923 + int pid;
1924 + u32 tran_id;
1925 + u32 req_type;
1926 + struct timer_list timer;
1927 + struct lpfc_vport *vport;
1928 + u32 data_len;
1929 + void *data;
1930 +};
1931 +
1932 +struct fc_sc_msg_work_q_wrapper {
1933 + struct work_struct work;
1934 + struct fc_security_request *fc_sc_req;
1935 + u32 data_len;
1936 + int status;
1937 + u32 msgtype;
1938 +};
1939 +struct fc_sc_notify_work_q_wrapper {
1940 + struct work_struct work;
1941 + struct Scsi_Host *shost;
1942 + int msg;
1943 +};
1944 +
1945 +#define FC_DHCHAP 1
1946 +#define FC_FCAP 2
1947 +#define FC_FCPAP 3
1948 +#define FC_KERBEROS 4
1949 +
1950 +#define FC_AUTHMODE_UNKNOWN 0
1951 +#define FC_AUTHMODE_NONE 1
1952 +#define FC_AUTHMODE_ACTIVE 2
1953 +#define FC_AUTHMODE_PASSIVE 3
1954 +
1955 +#define FC_SP_HASH_MD5 0x5
1956 +#define FC_SP_HASH_SHA1 0x6
1957 +
1958 +#define DH_GROUP_NULL 0x00
1959 +#define DH_GROUP_1024 0x01
1960 +#define DH_GROUP_1280 0x02
1961 +#define DH_GROUP_1536 0x03
1962 +#define DH_GROUP_2048 0x04
1963 +
1964 +#define MAX_AUTH_REQ_SIZE 1024
1965 +#define MAX_AUTH_RSP_SIZE 1024
1966 +
1967 +#define AUTH_FABRIC_WWN 0xFFFFFFFFFFFFFFFFLL
1968 +
1969 +struct fc_auth_req {
1970 + uint64_t local_wwpn;
1971 + uint64_t remote_wwpn;
1972 + union {
1973 + struct dhchap_challenge_req {
1974 + uint32_t transaction_id;
1975 + uint32_t dh_group_id;
1976 + uint32_t hash_id;
1977 + } dhchap_challenge;
1978 + struct dhchap_reply_req {
1979 + uint32_t transaction_id;
1980 + uint32_t dh_group_id;
1981 + uint32_t hash_id;
1982 + uint32_t bidirectional;
1983 + uint32_t received_challenge_len;
1984 + uint32_t received_public_key_len;
1985 + uint8_t data[0];
1986 + } dhchap_reply;
1987 + struct dhchap_success_req {
1988 + uint32_t transaction_id;
1989 + uint32_t dh_group_id;
1990 + uint32_t hash_id;
1991 + uint32_t our_challenge_len;
1992 + uint32_t received_response_len;
1993 + uint32_t received_public_key_len;
1994 + uint32_t received_challenge_len;
1995 + uint8_t data[0];
1996 + } dhchap_success;
1997 + }u;
1998 +} __attribute__ ((packed));
1999 +
2000 +struct fc_auth_rsp {
2001 + uint64_t local_wwpn;
2002 + uint64_t remote_wwpn;
2003 + union {
2004 + struct authinfo {
2005 + uint8_t auth_mode;
2006 + uint16_t auth_timeout;
2007 + uint8_t bidirectional;
2008 + uint8_t type_priority[4];
2009 + uint16_t type_len;
2010 + uint8_t hash_priority[4];
2011 + uint16_t hash_len;
2012 + uint8_t dh_group_priority[8];
2013 + uint16_t dh_group_len;
2014 + uint32_t reauth_interval;
2015 + } dhchap_security_config;
2016 + struct dhchap_challenge_rsp {
2017 + uint32_t transaction_id;
2018 + uint32_t our_challenge_len;
2019 + uint32_t our_public_key_len;
2020 + uint8_t data[0];
2021 + } dhchap_challenge;
2022 + struct dhchap_reply_rsp {
2023 + uint32_t transaction_id;
2024 + uint32_t our_challenge_rsp_len;
2025 + uint32_t our_public_key_len;
2026 + uint32_t our_challenge_len;
2027 + uint8_t data[0];
2028 + } dhchap_reply;
2029 + struct dhchap_success_rsp {
2030 + uint32_t transaction_id;
2031 + uint32_t authenticated;
2032 + uint32_t response_len;
2033 + uint8_t data[0];
2034 + } dhchap_success;
2035 + }u;
2036 +}__attribute__ ((packed));
2037 +
2038 +int
2039 +lpfc_fc_security_get_config(struct Scsi_Host *shost,
2040 + struct fc_auth_req *auth_req,
2041 + u32 req_len,
2042 + struct fc_auth_rsp *auth_rsp,
2043 + u32 rsp_len);
2044 +int
2045 +lpfc_fc_security_dhchap_make_challenge(struct Scsi_Host *shost,
2046 + struct fc_auth_req *auth_req,
2047 + u32 req_len,
2048 + struct fc_auth_rsp *auth_rsp,
2049 + u32 rsp_len);
2050 +int
2051 +lpfc_fc_security_dhchap_make_response(struct Scsi_Host *shost,
2052 + struct fc_auth_req *auth_req,
2053 + u32 req_len,
2054 + struct fc_auth_rsp *auth_rsp,
2055 + u32 rsp_len);
2056 +int
2057 +lpfc_fc_security_dhchap_authenticate(struct Scsi_Host *shost,
2058 + struct fc_auth_req *auth_req,
2059 + u32 req_len,
2060 + struct fc_auth_rsp *auth_rsp,
2061 + u32 rsp_len);
2062 +
2063 +int lpfc_fc_queue_security_work(struct lpfc_vport *,
2064 + struct work_struct *);
2065 +
2066 +/*
2067 + * FC Transport Message Types
2068 + */
2069 + /* user -> kernel */
2070 +#define FC_NL_EVENTS_REG 0x0001
2071 +#define FC_NL_EVENTS_DEREG 0x0002
2072 +#define FC_NL_SC_REG 0x0003
2073 +#define FC_NL_SC_DEREG 0x0004
2074 +#define FC_NL_SC_GET_CONFIG_RSP 0x0005
2075 +#define FC_NL_SC_SET_CONFIG_RSP 0x0006
2076 +#define FC_NL_SC_DHCHAP_MAKE_CHALLENGE_RSP 0x0007
2077 +#define FC_NL_SC_DHCHAP_MAKE_RESPONSE_RSP 0x0008
2078 +#define FC_NL_SC_DHCHAP_AUTHENTICATE_RSP 0x0009
2079 + /* kernel -> user */
2080 +//#define FC_NL_ASYNC_EVENT 0x0100
2081 +#define FC_NL_SC_GET_CONFIG_REQ 0x0020
2082 +#define FC_NL_SC_SET_CONFIG_REQ 0x0030
2083 +#define FC_NL_SC_DHCHAP_MAKE_CHALLENGE_REQ 0x0040
2084 +#define FC_NL_SC_DHCHAP_MAKE_RESPONSE_REQ 0x0050
2085 +#define FC_NL_SC_DHCHAP_AUTHENTICATE_REQ 0x0060
2086 +
2087 +/*
2088 + * Message Structures :
2089 + */
2090 +
2091 +/* macro to round up message lengths to 8byte boundary */
2092 +#define FC_NL_MSGALIGN(len) (((len) + 7) & ~7)
2093 +
2094 +#define FC_NETLINK_API_VERSION 1
2095 +
2096 +/* Single Netlink Message type to send all FC Transport messages */
2097 +#define FC_TRANSPORT_MSG NLMSG_MIN_TYPE + 1
2098 +
2099 +/* SCSI_TRANSPORT_MSG event message header */
2100 +/*
2101 +struct scsi_nl_hdr {
2102 + uint8_t version;
2103 + uint8_t transport;
2104 + uint16_t magic;
2105 + uint16_t msgtype;
2106 + uint16_t msglen;
2107 +} __attribute__((aligned(sizeof(uint64_t))));
2108 +*/
2109 +struct fc_nl_sc_message {
2110 + uint16_t msgtype;
2111 + uint16_t rsvd;
2112 + uint32_t tran_id;
2113 + uint32_t data_len;
2114 + uint8_t data[0];
2115 +} __attribute__((aligned(sizeof(uint64_t))));
2116 +
2117 --- /dev/null
2118 +++ b/drivers/scsi/lpfc/lpfc_auth.c
2119 @@ -0,0 +1,838 @@
2120 +/*******************************************************************
2121 + * This file is part of the Emulex Linux Device Driver for *
2122 + * Fibre Channel Host Bus Adapters. *
2123 + * Copyright (C) 2006-2008 Emulex. All rights reserved. *
2124 + * EMULEX and SLI are trademarks of Emulex. *
2125 + * www.emulex.com *
2126 + * *
2127 + * This program is free software; you can redistribute it and/or *
2128 + * modify it under the terms of version 2 of the GNU General *
2129 + * Public License as published by the Free Software Foundation. *
2130 + * This program is distributed in the hope that it will be useful. *
2131 + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
2132 + * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
2133 + * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
2134 + * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
2135 + * TO BE LEGALLY INVALID. See the GNU General Public License for *
2136 + * more details, a copy of which can be found in the file COPYING *
2137 + * included with this package. *
2138 + *******************************************************************/
2139 +/* See Fibre Channel protocol T11 FC-SP for details */
2140 +#include <linux/pci.h>
2141 +#include <linux/interrupt.h>
2142 +
2143 +#include <scsi/scsi.h>
2144 +#include <scsi/scsi_tcq.h>
2145 +#include <scsi/scsi_transport_fc.h>
2146 +
2147 +#include "lpfc_hw.h"
2148 +#include "lpfc_sli.h"
2149 +#include "lpfc_nl.h"
2150 +#include "lpfc_disc.h"
2151 +#include "lpfc.h"
2152 +#include "lpfc_crtn.h"
2153 +#include "lpfc_logmsg.h"
2154 +#include "lpfc_auth_access.h"
2155 +#include "lpfc_auth.h"
2156 +
2157 +void
2158 +lpfc_start_authentication(struct lpfc_vport *vport,
2159 + struct lpfc_nodelist *ndlp)
2160 +{
2161 + uint32_t nego_payload_len;
2162 + uint8_t *nego_payload;
2163 +
2164 + nego_payload = kmalloc(MAX_AUTH_REQ_SIZE, GFP_KERNEL);
2165 + if (!nego_payload)
2166 + return;
2167 + vport->auth.trans_id++;
2168 + vport->auth.auth_msg_state = LPFC_AUTH_NEGOTIATE;
2169 + nego_payload_len = lpfc_build_auth_neg(vport, nego_payload);
2170 + lpfc_issue_els_auth(vport, ndlp, AUTH_NEGOTIATE,
2171 + nego_payload, nego_payload_len);
2172 + kfree(nego_payload);
2173 +}
2174 +
2175 +void
2176 +lpfc_dhchap_make_challenge(struct Scsi_Host *shost, int status,
2177 + void *rsp, uint32_t rsp_len)
2178 +{
2179 + struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
2180 + struct lpfc_nodelist *ndlp;
2181 + uint32_t chal_payload_len;
2182 + uint8_t *chal_payload;
2183 + struct fc_auth_rsp *auth_rsp = rsp;
2184 +
2185 + ndlp = lpfc_findnode_did(vport, Fabric_DID);
2186 + if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
2187 + kfree(rsp);
2188 + return;
2189 + }
2190 +
2191 + lpfc_printf_vlog(vport, KERN_INFO, LOG_SECURITY,
2192 + "1003 Send dhchap challenge local_wwpn "
2193 + "%llX remote_wwpn %llX \n",
2194 + (unsigned long long)auth_rsp->local_wwpn,
2195 + (unsigned long long)auth_rsp->remote_wwpn);
2196 +
2197 + chal_payload = kmalloc(MAX_AUTH_REQ_SIZE, GFP_KERNEL);
2198 + if (!chal_payload) {
2199 + kfree(rsp);
2200 + return;
2201 + }
2202 + vport->auth.auth_msg_state = LPFC_DHCHAP_CHALLENGE;
2203 + chal_payload_len = lpfc_build_dhchap_challenge(vport,
2204 + chal_payload, rsp);
2205 + lpfc_issue_els_auth(vport, ndlp, DHCHAP_CHALLENGE,
2206 + chal_payload, chal_payload_len);
2207 + kfree(chal_payload);
2208 + kfree(rsp);
2209 +}
2210 +
2211 +
2212 +void
2213 +lpfc_dhchap_make_response(struct Scsi_Host *shost, int status,
2214 + void *rsp, uint32_t rsp_len)
2215 +{
2216 + struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
2217 + struct lpfc_nodelist *ndlp;
2218 + uint32_t reply_payload_len;
2219 + uint8_t *reply_payload;
2220 + struct fc_auth_rsp *auth_rsp = rsp;
2221 +
2222 + ndlp = lpfc_findnode_did(vport, Fabric_DID);
2223 + if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
2224 + kfree(rsp);
2225 + return;
2226 + }
2227 +
2228 + lpfc_printf_vlog(vport, KERN_INFO, LOG_SECURITY,
2229 + "1004 Send dhchap reply local_wwpn "
2230 + "%llX remote_wwpn %llX \n",
2231 + (unsigned long long)auth_rsp->local_wwpn,
2232 + (unsigned long long)auth_rsp->remote_wwpn);
2233 +
2234 + reply_payload = kmalloc(MAX_AUTH_REQ_SIZE, GFP_KERNEL);
2235 + if (!reply_payload) {
2236 + kfree(rsp);
2237 + return;
2238 + }
2239 +
2240 + vport->auth.auth_msg_state = LPFC_DHCHAP_REPLY;
2241 + reply_payload_len = lpfc_build_dhchap_reply(vport, reply_payload, rsp);
2242 + lpfc_issue_els_auth(vport, ndlp, DHCHAP_REPLY,
2243 + reply_payload, reply_payload_len);
2244 + kfree(reply_payload);
2245 + kfree(rsp);
2246 +
2247 +}
2248 +
2249 +
2250 +void
2251 +lpfc_dhchap_authenticate(struct Scsi_Host *shost,
2252 + int status, void *rsp,
2253 + uint32_t rsp_len)
2254 +{
2255 + struct fc_auth_rsp *auth_rsp = (struct fc_auth_rsp *)rsp;
2256 + struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
2257 + struct lpfc_nodelist *ndlp;
2258 +
2259 + ndlp = lpfc_findnode_did(vport, Fabric_DID);
2260 + if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
2261 + kfree(rsp);
2262 + return;
2263 + }
2264 + if (status != 0) {
2265 + lpfc_issue_els_auth_reject(vport, ndlp,
2266 + AUTH_ERR, AUTHENTICATION_FAILED);
2267 + kfree(rsp);
2268 + return;
2269 + }
2270 +
2271 + if (auth_rsp->u.dhchap_success.authenticated) {
2272 + uint32_t suc_payload_len;
2273 + uint8_t *suc_payload;
2274 +
2275 + suc_payload = kmalloc(MAX_AUTH_REQ_SIZE, GFP_KERNEL);
2276 + if (!suc_payload) {
2277 + lpfc_issue_els_auth_reject(vport, ndlp,
2278 + AUTH_ERR, AUTHENTICATION_FAILED);
2279 + kfree(rsp);
2280 + return;
2281 + }
2282 + suc_payload_len = lpfc_build_dhchap_success(vport,
2283 + suc_payload, rsp);
2284 + if (suc_payload_len == sizeof(uint32_t)) {
2285 + /* Authentication is complete after sending this SUCCESS */
2286 + vport->auth.auth_msg_state = LPFC_DHCHAP_SUCCESS;
2287 + } else {
2288 + /* Need to wait for SUCCESS from Auth Initiator */
2289 + vport->auth.auth_msg_state = LPFC_DHCHAP_SUCCESS_REPLY;
2290 + }
2291 + lpfc_issue_els_auth(vport, ndlp, DHCHAP_SUCCESS,
2292 + suc_payload, suc_payload_len);
2293 + kfree(suc_payload);
2294 + vport->auth.direction |= AUTH_DIRECTION_LOCAL;
2295 + } else {
2296 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2297 + "1005 AUTHENTICATION_FAILURE Nport:x%x\n",
2298 + ndlp->nlp_DID);
2299 + lpfc_issue_els_auth_reject(vport, ndlp,
2300 + AUTH_ERR, AUTHENTICATION_FAILED);
2301 + if (vport->auth.auth_state == LPFC_AUTH_SUCCESS) {
2302 + lpfc_port_auth_failed(ndlp);
2303 + }
2304 + }
2305 +
2306 + kfree(rsp);
2307 +}
2308 +
2309 +int
2310 +lpfc_unpack_auth_negotiate(struct lpfc_vport *vport, uint8_t *message,
2311 + uint8_t *reason, uint8_t *explanation)
2312 +{
2313 + uint32_t prot_len;
2314 + uint32_t param_len;
2315 + int i, j = 0;
2316 +
2317 + /* Following is the format of the message. Name Format.
2318 + * uint16_t nameTag;
2319 + * uint16_t nameLength;
2320 + * uint8_t name[8];
2321 + * AUTH_Negotiate Message
2322 + * uint32_t NumberOfAuthProtocals
2323 + * uint32_t AuthProtParameter#1Len
2324 + * uint32_t AuthProtID#1 (DH-CHAP = 0x1)
2325 + * AUTH_Negotiate DH-CHAP
2326 + * uint16_t DH-CHAPParameterTag (HashList = 0x1)
2327 + * uint16_t DH-CHAPParameterWordCount (number of uint32_t entries)
2328 + * uint8_t DH-CHAPParameter[]; (uint32_t entries)
2329 + * uint16_t DH-CHAPParameterTag (DHglDList = 0x2)
2330 + * uint16_t DH-CHAPParameterWordCount (number of uint32_t entries)
2331 + * uint8_t DH-CHAPParameter[]; (uint32_t entries)
2332 + * DHCHAP_Challenge Message
2333 + * uint32_t hashIdentifier;
2334 + * uint32_t dhgroupIdentifier;
2335 + * uint32_t challengevalueLen;
2336 + * uint8_t challengeValue[];
2337 + * uint32_t dhvalueLen;
2338 + * uint8_t dhvalue[];
2339 + */
2340 +
2341 + /* Name Tag */
2342 + if (be16_to_cpu(*(uint16_t *)message) != NAME_TAG) {
2343 + *reason = AUTH_ERR;
2344 + *explanation = BAD_PAYLOAD;
2345 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2346 + "1006 Bad Name tag in auth message 0x%x\n",
2347 + be16_to_cpu(*(uint16_t *)message));
2348 + return 1;
2349 + }
2350 + message += sizeof(uint16_t);
2351 +
2352 + /* Name Length */
2353 + if (be16_to_cpu(*(uint16_t *)message) != NAME_LEN) {
2354 + *reason = AUTH_ERR;
2355 + *explanation = BAD_PAYLOAD;
2356 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2357 + "1007 Bad Name length in auth message 0x%x\n",
2358 + be16_to_cpu(*(uint16_t *)message));
2359 + return 1;
2360 + }
2361 + message += sizeof(uint16_t);
2362 +
2363 + /* Skip over Remote Port Name */
2364 + message += NAME_LEN;
2365 +
2366 + /* Number of Auth Protocols must be 1 DH-CHAP */
2367 + if (be32_to_cpu(*(uint32_t *)message) != 1) {
2368 + *reason = AUTH_ERR;
2369 + *explanation = BAD_PAYLOAD;
2370 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2371 + "1008 Bad Number of Protocols 0x%x\n",
2372 + be32_to_cpu(*(uint32_t *)message));
2373 + return 1;
2374 + }
2375 + message += sizeof(uint32_t);
2376 +
2377 + /* Protocol Parameter Length */
2378 + prot_len = be32_to_cpu(*(uint32_t *)message);
2379 + message += sizeof(uint32_t);
2380 +
2381 + /* Protocol Parameter type */
2382 + if (be32_to_cpu(*(uint32_t *)message) != FC_DHCHAP) {
2383 + *reason = AUTH_ERR;
2384 + *explanation = BAD_PAYLOAD;
2385 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2386 + "1009 Bad param type 0x%x\n",
2387 + be32_to_cpu(*(uint32_t *)message));
2388 + return 1;
2389 + }
2390 + message += sizeof(uint32_t);
2391 +
2392 + /* Parameter #1 Tag */
2393 + if (be16_to_cpu(*(uint16_t *)message) != HASH_LIST_TAG) {
2394 + *reason = AUTH_ERR;
2395 + *explanation = BAD_PAYLOAD;
2396 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2397 + "1010 Bad Tag 1 0x%x\n",
2398 + be16_to_cpu(*(uint16_t *)message));
2399 + return 1;
2400 + }
2401 + message += sizeof(uint16_t);
2402 +
2403 + /* Parameter #1 Length */
2404 + param_len = be16_to_cpu(*(uint16_t *)message);
2405 + message += sizeof(uint16_t);
2406 +
2407 + /* Choose a hash function */
2408 + for (i = 0; i < vport->auth.hash_len; i++) {
2409 + for (j = 0; j < param_len; j++) {
2410 + if (vport->auth.hash_priority[i] ==
2411 + be32_to_cpu(((uint32_t *)message)[j]))
2412 + break;
2413 + }
2414 + if (j != param_len)
2415 + break;
2416 + }
2417 + if (i == vport->auth.hash_len && j == param_len) {
2418 + *reason = AUTH_ERR;
2419 + *explanation = BAD_PAYLOAD;
2420 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2421 + "1011 Auth_neg no hash function chosen.\n");
2422 + return 1;
2423 + }
2424 + vport->auth.hash_id = vport->auth.hash_priority[i];
2425 + message += sizeof(uint32_t) * param_len;
2426 +
2427 + /* Parameter #2 Tag */
2428 + if (be16_to_cpu(*(uint16_t *)message) != DHGID_LIST_TAG) {
2429 + *reason = AUTH_ERR;
2430 + *explanation = BAD_PAYLOAD;
2431 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2432 + "1012 Auth_negotiate Bad Tag 2 0x%x\n",
2433 + be16_to_cpu(*(uint16_t *)message));
2434 + return 1;
2435 + }
2436 + message += sizeof(uint16_t);
2437 +
2438 + /* Parameter #2 Length */
2439 + param_len = be16_to_cpu(*(uint16_t *)message);
2440 + message += sizeof(uint16_t);
2441 +
2442 + /* Choose a DH Group */
2443 + for (i = 0; i < vport->auth.dh_group_len; i++) {
2444 + for (j = 0; j < param_len; j++) {
2445 + if (vport->auth.dh_group_priority[i] ==
2446 + be32_to_cpu(((uint32_t *)message)[j]))
2447 + break;
2448 + }
2449 + if (j != param_len)
2450 + break;
2451 + }
2452 + if (i == vport->auth.dh_group_len && j == param_len) {
2453 + *reason = AUTH_ERR;
2454 + *explanation = BAD_PAYLOAD;
2455 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2456 + "1013 Auth_negotiate no DH_group found. \n");
2457 + return 1;
2458 + }
2459 + vport->auth.group_id = vport->auth.dh_group_priority[i];
2460 + message += sizeof(uint32_t) * param_len;
2461 +
2462 + return 0;
2463 +}
2464 +
2465 +int
2466 +lpfc_unpack_dhchap_challenge(struct lpfc_vport *vport, uint8_t *message,
2467 + uint8_t *reason, uint8_t *explanation)
2468 +{
2469 + int i;
2470 +
2471 + /* Following is the format of the message DHCHAP_Challenge.
2472 + * uint16_t nameTag;
2473 + * uint16_t nameLength;
2474 + * uint8_t name[8];
2475 + * uint32_t hashIdentifier;
2476 + * uint32_t dhgroupIdentifier;
2477 + * uint32_t challengevalueLen;
2478 + * uint8_t challengeValue[];
2479 + * uint32_t dhvalueLen;
2480 + * uint8_t dhvalue[];
2481 + */
2482 +
2483 + /* Name Tag */
2484 + if (be16_to_cpu(*(uint16_t *)message) != NAME_TAG) {
2485 + *reason = AUTH_ERR;
2486 + *explanation = BAD_PAYLOAD;
2487 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2488 + "1014 dhchap challenge bad name tag 0x%x. \n",
2489 + be16_to_cpu(*(uint16_t *)message));
2490 + return 1;
2491 + }
2492 + message += sizeof(uint16_t);
2493 +
2494 + /* Name Length */
2495 + if (be16_to_cpu(*(uint16_t *)message) != NAME_LEN) {
2496 + *reason = AUTH_ERR;
2497 + *explanation = BAD_PAYLOAD;
2498 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2499 + "1015 dhchap challenge bad name length "
2500 + "0x%x.\n", be16_to_cpu(*(uint16_t *)message));
2501 + return 1;
2502 + }
2503 + message += sizeof(uint16_t);
2504 +
2505 + /* Remote Port Name */
2506 + message += NAME_LEN;
2507 +
2508 + /* Hash ID */
2509 + vport->auth.hash_id = be32_to_cpu(*(uint32_t *)message); /* Hash id */
2510 + for (i = 0; i < vport->auth.hash_len; i++) {
2511 + if (vport->auth.hash_id == vport->auth.hash_priority[i])
2512 + break;
2513 + }
2514 + if (i == vport->auth.hash_len) {
2515 + *reason = LOGIC_ERR;
2516 + *explanation = BAD_ALGORITHM;
2517 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2518 + "1016 dhchap challenge Hash ID not Supported "
2519 + "0x%x. \n", vport->auth.hash_id);
2520 + return 1;
2521 + }
2522 + message += sizeof(uint32_t);
2523 +
2524 + vport->auth.group_id =
2525 + be32_to_cpu(*(uint32_t *)message); /* DH group id */
2526 + for (i = 0; i < vport->auth.dh_group_len; i++) {
2527 + if (vport->auth.group_id == vport->auth.dh_group_priority[i])
2528 + break;
2529 + }
2530 + if (i == vport->auth.dh_group_len) {
2531 + *reason = LOGIC_ERR;
2532 + *explanation = BAD_DHGROUP;
2533 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2534 + "1017 dhchap challenge could not find DH "
2535 + "Group. \n");
2536 + return 1;
2537 + }
2538 + message += sizeof(uint32_t);
2539 +
2540 + vport->auth.challenge_len =
2541 + be32_to_cpu(*(uint32_t *)message); /* Challenge Len */
2542 + message += sizeof(uint32_t);
2543 +
2544 + /* copy challenge to vport */
2545 + if (vport->auth.challenge != NULL) {
2546 + kfree(vport->auth.challenge);
2547 + }
2548 + vport->auth.challenge = kmalloc(vport->auth.challenge_len, GFP_KERNEL);
2549 + if (!vport->auth.challenge) {
2550 + *reason = AUTH_ERR;
2551 + return 1;
2552 + }
2553 + memcpy (vport->auth.challenge, message, vport->auth.challenge_len);
2554 + message += vport->auth.challenge_len;
2555 +
2556 + vport->auth.dh_pub_key_len =
2557 + be32_to_cpu(*(uint32_t *)message); /* DH Value Len */
2558 + message += sizeof(uint32_t);
2559 +
2560 + if (vport->auth.dh_pub_key_len != 0) {
2561 + if (vport->auth.group_id == DH_GROUP_NULL) {
2562 + *reason = LOGIC_ERR;
2563 + *explanation = BAD_DHGROUP;
2564 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
2565 + "1018 dhchap challenge No Public key "
2566 + "for non-NULL DH Group.\n");
2567 + return 1;
2568 + }
2569 +
2570 + /* Copy to the vport to save for authentication */
2571 + if (vport->auth.dh_pub_key != NULL)
2572 + kfree(vport->auth.dh_pub_key);
2573 + vport->auth.dh_pub_key = kmalloc(vport->auth.dh_pub_key_len,
2574 + GFP_KERNEL);
2575 + if (!vport->auth.dh_pub_key) {
2576 + *reason = AUTH_ERR;
2577 + return 1;
2578 + }
2579 + memcpy(vport->auth.dh_pub_key, message,
2580 + vport->auth.dh_pub_key_len);
2581 + }
2582 + return 0;
2583 +}
2584 +
2585 +int
2586 +lpfc_unpack_dhchap_reply(struct lpfc_vport *vport, uint8_t *message,
2587 + struct fc_auth_req *fc_req)
2588 +{
2589 + uint32_t rsp_len;
2590 + uint32_t dh_len;
2591 + uint32_t challenge_len;
2592 +
2593 + /* Following is the format of the message DHCHAP_Reply.
2594 + * uint32_t Response Value Length;
2595 + * uint8_t Response Value[];
2596 + * uint32_t DH Value Length;
2597 + * uint8_t DH Value[];
2598 + * uint32_t Challenge Value Length;
2599 + * uint8_t Challenge Value[];
2600 + */
2601 +
2602 + rsp_len = be32_to_cpu(*(uint32_t *)message); /* Response Len */
2603 + message += sizeof(uint32_t);
2604 + memcpy (fc_req->u.dhchap_success.data + vport->auth.challenge_len,
2605 + message, rsp_len);
2606 + fc_req->u.dhchap_success.received_response_len = rsp_len;
2607 + message += rsp_len;
2608 +
2609 + dh_len = be32_to_cpu(*(uint32_t *)message); /* DH Len */
2610 + message += sizeof(uint32_t);
2611 + memcpy (fc_req->u.dhchap_success.data + vport->auth.challenge_len +
2612 + rsp_len, message, dh_len);
2613 + fc_req->u.dhchap_success.received_public_key_len = dh_len;
2614 + message += dh_len;
2615 +
2616 + challenge_len = be32_to_cpu(*(uint32_t *)message); /* Challenge Len */
2617 + message += sizeof(uint32_t);
2618 + memcpy (fc_req->u.dhchap_success.data + vport->auth.challenge_len
2619 + + rsp_len + dh_len,
2620 + message, challenge_len);
2621 + fc_req->u.dhchap_success.received_challenge_len = challenge_len;
2622 + message += challenge_len;
2623 +
2624 + return (rsp_len + dh_len + challenge_len);
2625 +}
2626 +
2627 +int
2628 +lpfc_unpack_dhchap_success(struct lpfc_vport *vport, uint8_t *message,
2629 + struct fc_auth_req *fc_req)
2630 +{
2631 + uint32_t rsp_len = 0;
2632 +
2633 + /* DHCHAP_Success.
2634 + * uint32_t responseValueLen;
2635 + * uint8_t response[];
2636 + */
2637 +
2638 + rsp_len = be32_to_cpu(*(uint32_t *)message); /* Response Len */
2639 + message += sizeof(uint32_t);
2640 + memcpy(fc_req->u.dhchap_success.data + vport->auth.challenge_len,
2641 + message, rsp_len);
2642 + fc_req->u.dhchap_success.received_response_len = rsp_len;
2643 +
2644 + memcpy(fc_req->u.dhchap_success.data +
2645 + vport->auth.challenge_len + rsp_len,
2646 + vport->auth.dh_pub_key, vport->auth.dh_pub_key_len);
2647 +
2648 + fc_req->u.dhchap_success.received_public_key_len =
2649 + vport->auth.dh_pub_key_len;
2650 +
2651 + fc_req->u.dhchap_success.received_challenge_len = 0;
2652 +
2653 + return (vport->auth.challenge_len + rsp_len +
2654 + vport->auth.dh_pub_key_len);
2655 + return 0;
2656 +}
2657 +
2658 +int
2659 +lpfc_build_auth_neg(struct lpfc_vport *vport, uint8_t *message)
2660 +{
2661 + uint8_t *message_start = message;
2662 + uint8_t *params_start;
2663 + uint32_t *params_len;
2664 + uint32_t len;
2665 + int i;
2666 +
2667 + /* Because some of the fields are not static in length
2668 + * and number we will pack on the fly.This will be expanded
2669 + * in the future to optionally offer DHCHAP or FCAP or both.
2670 + * The packing is done in Big Endian byte order DHCHAP_Reply.
2671 + *
2672 + * uint16_t nameTag;
2673 + * uint16_t nameLength;
2674 + * uint8_t name[8];
2675 + * uint32_t available; For now we will only offer one
2676 + protocol ( DHCHAP ) for authentication.
2677 + * uint32_t potocolParamsLenId#1;
2678 + * uint32_t protocolId#1; 1 : DHCHAP. The protocol list is
2679 + * in order of preference.
2680 + * uint16_t parameter#1Tag 1 : HashList
2681 + * uint16_t parameter#1Len 2 : Count of how many parameter values
2682 + * follow in order of preference.
2683 + * uint16_t parameter#1value#1 5 : MD5 Hash Function
2684 + * uint16_t parameter#1value#2 6 : SHA-1 Hash Function
2685 + * uint16_t parameter#2Tag 2 : DHglDList
2686 + * uint16_t parameter#2Len 1 : Only One is supported now
2687 + * uint16_t parameter#2value#1 0 : NULL DH-CHAP Algorithm
2688 + * uint16_t parameter#2value#2 ...
2689 + * uint32_t protocolParamsLenId#2;
2690 + * uint32_t protocolId#2; 2 = FCAP
2691 + * uint16_t parameter#1Tag
2692 + * uint16_t parameter#1Len
2693 + * uint16_t parameter#1value#1
2694 + * uint16_t parameter#1value#2 ...
2695 + * uint16_t parameter#2Tag
2696 + * uint16_t parameter#2Len
2697 + * uint16_t parameter#2value#1
2698 + * uint16_t parameter#2value#2 ...
2699 + */
2700 +
2701 +
2702 + /* Name Tag */
2703 + *((uint16_t *)message) = cpu_to_be16(NAME_TAG);
2704 + message += sizeof(uint16_t);
2705 +
2706 + /* Name Len */
2707 + *((uint16_t *)message) = cpu_to_be16(NAME_LEN);
2708 + message += sizeof(uint16_t);
2709 +
2710 + memcpy(message, vport->fc_portname.u.wwn, sizeof(uint64_t));
2711 +
2712 + message += sizeof(uint64_t);
2713 +
2714 + /* Protocols Available */
2715 + *((uint32_t *)message) = cpu_to_be32(PROTS_NUM);
2716 + message += sizeof(uint32_t);
2717 +
2718 + /* First Protocol Params Len */
2719 + params_len = (uint32_t *)message;
2720 + message += sizeof(uint32_t);
2721 +
2722 + /* Start of first Param */
2723 + params_start = message;
2724 +
2725 + /* Protocol Id */
2726 + *((uint32_t *)message) = cpu_to_be32(FC_DHCHAP);
2727 + message += sizeof(uint32_t);
2728 +
2729 + /* Hash List Tag */
2730 + *((uint16_t *)message) = cpu_to_be16(HASH_LIST_TAG);
2731 + message += sizeof(uint16_t);
2732 +
2733 + /* Hash Value Len */
2734 + *((uint16_t *)message) = cpu_to_be16(vport->auth.hash_len);
2735 + message += sizeof(uint16_t);
2736 +
2737 + /* Hash Value each 4 byte words */
2738 + for (i = 0; i < vport->auth.hash_len; i++) {
2739 + *((uint32_t *)message) =
2740 + cpu_to_be32(vport->auth.hash_priority[i]);
2741 + message += sizeof(uint32_t);
2742 + }
2743 +
2744 + /* DHgIDList Tag */
2745 + *((uint16_t *)message) = cpu_to_be16(DHGID_LIST_TAG);
2746 + message += sizeof(uint16_t);
2747 +
2748 + /* DHgIDListValue Len */
2749 + *((uint16_t *)message) = cpu_to_be16(vport->auth.dh_group_len);
2750 +
2751 + message += sizeof(uint16_t);
2752 +
2753 + /* DHgIDList each 4 byte words */
2754 +
2755 + for (i = 0; i < vport->auth.dh_group_len; i++) {
2756 + *((uint32_t *)message) =
2757 + cpu_to_be32(vport->auth.dh_group_priority[i]);
2758 + message += sizeof(uint32_t);
2759 + }
2760 +
2761 + *params_len = cpu_to_be32(message - params_start);
2762 +
2763 + len = (uint32_t)(message - message_start);
2764 +
2765 + return len;
2766 +}
2767 +
2768 +int
2769 +lpfc_build_dhchap_challenge(struct lpfc_vport *vport, uint8_t *message,
2770 + struct fc_auth_rsp *fc_rsp)
2771 +{
2772 + uint8_t *message_start = message;
2773 +
2774 + /* Because some of the fields are not static in length and number
2775 + * we will pack on the fly. The packing is done in Big Endian byte
2776 + * order DHCHAP_Challenge.
2777 + *
2778 + * uint16_t nameTag;
2779 + * uint16_t nameLength;
2780 + * uint8_t name[8];
2781 + * uint32_t Hash_Identifier;
2782 + * uint32_t DH_Group_Identifier;
2783 + * uint32_t Challenge_Value_Length;
2784 + * uint8_t Challenge_Value[];
2785 + * uint32_t DH_Value_Length;
2786 + * uint8_t DH_Value[];
2787 + */
2788 +
2789 + /* Name Tag */
2790 + *((uint16_t *)message) = cpu_to_be16(NAME_TAG);
2791 + message += sizeof(uint16_t);
2792 +
2793 + /* Name Len */
2794 + *((uint16_t *)message) = cpu_to_be16(NAME_LEN);
2795 + message += sizeof(uint16_t);
2796 +
2797 + memcpy(message, vport->fc_portname.u.wwn, NAME_LEN);
2798 + message += NAME_LEN;
2799 +
2800 + /* Hash Value each 4 byte words */
2801 + *((uint32_t *)message) = cpu_to_be32(vport->auth.hash_id);
2802 + message += sizeof(uint32_t);
2803 +
2804 + /* DH group id each 4 byte words */
2805 + *((uint32_t *)message) = cpu_to_be32(vport->auth.group_id);
2806 + message += sizeof(uint32_t);
2807 +
2808 + /* Challenge Length */
2809 + *((uint32_t *)message) = cpu_to_be32(fc_rsp->u.
2810 + dhchap_challenge.our_challenge_len);
2811 + message += sizeof(uint32_t);
2812 +
2813 + /* copy challenge to vport to save */
2814 + if (vport->auth.challenge)
2815 + kfree(vport->auth.challenge);
2816 + vport->auth.challenge_len = fc_rsp->u.
2817 + dhchap_challenge.our_challenge_len;
2818 + vport->auth.challenge = kmalloc(vport->auth.challenge_len, GFP_KERNEL);
2819 +
2820 + if (!vport->auth.challenge)
2821 + return 0;
2822 +
2823 + memcpy(vport->auth.challenge, fc_rsp->u.dhchap_challenge.data,
2824 + fc_rsp->u.dhchap_challenge.our_challenge_len);
2825 +
2826 + /* Challenge */
2827 + memcpy(message, fc_rsp->u.dhchap_challenge.data,
2828 + fc_rsp->u.dhchap_challenge.our_challenge_len);
2829 + message += fc_rsp->u.dhchap_challenge.our_challenge_len;
2830 +
2831 + /* Public Key length */
2832 + *((uint32_t *)message) = cpu_to_be32(fc_rsp->u.
2833 + dhchap_challenge.our_public_key_len);
2834 + message += sizeof(uint32_t);
2835 +
2836 + /* Public Key */
2837 + memcpy(message, fc_rsp->u.dhchap_challenge.data +
2838 + fc_rsp->u.dhchap_challenge.our_challenge_len,
2839 + fc_rsp->u.dhchap_challenge.our_public_key_len);
2840 + message += fc_rsp->u.dhchap_challenge.our_public_key_len;
2841 +
2842 + return ((uint32_t)(message - message_start));
2843 +
2844 +}
2845 +
2846 +int
2847 +lpfc_build_dhchap_reply(struct lpfc_vport *vport, uint8_t *message,
2848 + struct fc_auth_rsp *fc_rsp)
2849 +
2850 +{
2851 + uint8_t *message_start = message;
2852 +
2853 + /*
2854 + * Because some of the fields are not static in length and
2855 + * number we will pack on the fly. The packing is done in
2856 + * Big Endian byte order DHCHAP_Reply.
2857 + *
2858 + * uint32_t ResonseLength;
2859 + * uint8_t ResponseValue[];
2860 + * uint32_t DHLength;
2861 + * uint8_t DHValue[]; Our Public key
2862 + * uint32_t ChallengeLength; Used for bi-directional authentication
2863 + * uint8_t ChallengeValue[];
2864 + *
2865 + * The combined key ( g^x mod p )^y mod p is used as the last
2866 + * hash of the password.
2867 + *
2868 + * g is the base 2 or 5.
2869 + * y is our private key.
2870 + * ( g^y mod p ) is our public key which we send.
2871 + * ( g^x mod p ) is their public key which we received.
2872 + */
2873 + /* Response Value Length */
2874 + *((uint32_t *)message) = cpu_to_be32(fc_rsp->u.dhchap_reply.
2875 + our_challenge_rsp_len);
2876 +
2877 + message += sizeof(uint32_t);
2878 + /* Response Value */
2879 + memcpy(message, fc_rsp->u.dhchap_reply.data,
2880 + fc_rsp->u.dhchap_reply.our_challenge_rsp_len);
2881 +
2882 + message += fc_rsp->u.dhchap_reply.our_challenge_rsp_len;
2883 + /* DH Value Length */
2884 + *((uint32_t *)message) = cpu_to_be32(fc_rsp->u.dhchap_reply.
2885 + our_public_key_len);
2886 +
2887 + message += sizeof(uint32_t);
2888 + /* DH Value */
2889 + memcpy(message, fc_rsp->u.dhchap_reply.data +
2890 + fc_rsp->u.dhchap_reply.our_challenge_rsp_len,
2891 + fc_rsp->u.dhchap_reply.our_public_key_len);
2892 +
2893 + message += fc_rsp->u.dhchap_reply.our_public_key_len;
2894 +
2895 + if (vport->auth.bidirectional) {
2896 +
2897 + /* copy to vport to save */
2898 + if (vport->auth.challenge)
2899 + kfree(vport->auth.challenge);
2900 + vport->auth.challenge_len = fc_rsp->u.dhchap_reply.
2901 + our_challenge_len;
2902 + vport->auth.challenge = kmalloc(vport->auth.challenge_len,
2903 + GFP_KERNEL);
2904 + if (!vport->auth.challenge)
2905 + return 0;
2906 +
2907 + memcpy(vport->auth.challenge, fc_rsp->u.dhchap_reply.data +
2908 + fc_rsp->u.dhchap_reply.our_challenge_rsp_len +
2909 + fc_rsp->u.dhchap_reply.our_public_key_len,
2910 + fc_rsp->u.dhchap_reply.our_challenge_len);
2911 + /* Challenge Value Length */
2912 + *((uint32_t *)message) = cpu_to_be32(fc_rsp->u.
2913 + dhchap_reply.our_challenge_len);
2914 + message += sizeof(uint32_t);
2915 + /* Challenge Value */
2916 + memcpy(message, fc_rsp->u.dhchap_reply.data +
2917 + fc_rsp->u.dhchap_reply.our_challenge_rsp_len +
2918 + fc_rsp->u.dhchap_reply.our_public_key_len,
2919 + fc_rsp->u.dhchap_reply.our_challenge_len);
2920 +
2921 + message += fc_rsp->u.dhchap_reply.our_challenge_len;
2922 +
2923 + } else {
2924 + *((uint32_t *)message) = 0; /* Challenge Len for No
2925 + bidirectional authentication */
2926 + message += sizeof(uint32_t); /* Challenge Value Not Present */
2927 + }
2928 +
2929 + return ((uint32_t)(message - message_start));
2930 +
2931 +}
2932 +
2933 +int
2934 +lpfc_build_dhchap_success(struct lpfc_vport *vport, uint8_t *message,
2935 + struct fc_auth_rsp *fc_rsp)
2936 +{
2937 + uint8_t *message_start = message;
2938 +
2939 + /*
2940 + * Because some of the fields are not static in length and number
2941 + * we will pack on the fly. The packing is done in Big Endian byte
2942 + * order DHCHAP_Success.
2943 + * uint32_t responseValueLen;
2944 + * uint8_t response[];.
2945 + */
2946 +
2947 + *((uint32_t *)message) = cpu_to_be32(fc_rsp->u.
2948 + dhchap_success.response_len);
2949 + message += sizeof(uint32_t);
2950 +
2951 + memcpy(message, fc_rsp->u.dhchap_success.data,
2952 + fc_rsp->u.dhchap_success.response_len);
2953 + message += fc_rsp->u.dhchap_success.response_len;
2954 +
2955 + return ((uint32_t)(message - message_start));
2956 +}
2957 +
2958 --- /dev/null
2959 +++ b/drivers/scsi/lpfc/lpfc_auth.h
2960 @@ -0,0 +1,92 @@
2961 +/*******************************************************************
2962 + * This file is part of the Emulex Linux Device Driver for *
2963 + * Fibre Channel Host Bus Adapters. *
2964 + * Copyright (C) 2006-2007 Emulex. All rights reserved. *
2965 + * EMULEX and SLI are trademarks of Emulex. *
2966 + * www.emulex.com *
2967 + * *
2968 + * This program is free software; you can redistribute it and/or *
2969 + * modify it under the terms of version 2 of the GNU General *
2970 + * Public License as published by the Free Software Foundation. *
2971 + * This program is distributed in the hope that it will be useful. *
2972 + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
2973 + * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
2974 + * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
2975 + * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
2976 + * TO BE LEGALLY INVALID. See the GNU General Public License for *
2977 + * more details, a copy of which can be found in the file COPYING *
2978 + * included with this package. *
2979 + *******************************************************************/
2980 +
2981 +#define N_DH_GROUP 4
2982 +#define ELS_CMD_AUTH_BYTE 0x90
2983 +
2984 +#define AUTH_REJECT 0xA
2985 +#define AUTH_NEGOTIATE 0xB
2986 +#define AUTH_DONE 0xC
2987 +
2988 +#define DHCHAP_CHALLENGE 0x10
2989 +#define DHCHAP_REPLY 0x11
2990 +#define DHCHAP_SUCCESS 0x12
2991 +
2992 +#define FCAP_REQUEST 0x13
2993 +#define FCAP_ACK 0x14
2994 +#define FCAP_CONFIRM 0x15
2995 +
2996 +#define PROTS_NUM 0x01
2997 +
2998 +#define NAME_TAG 0x01
2999 +#define NAME_LEN 0x08
3000 +
3001 +#define HASH_LIST_TAG 0x01
3002 +
3003 +#define DHGID_LIST_TAG 0x02
3004 +
3005 +#define HBA_SECURITY 0x20
3006 +
3007 +#define AUTH_ERR 0x1
3008 +#define LOGIC_ERR 0x2
3009 +
3010 +#define BAD_DHGROUP 0x2
3011 +#define BAD_ALGORITHM 0x3
3012 +#define AUTHENTICATION_FAILED 0x5
3013 +#define BAD_PAYLOAD 0x6
3014 +#define BAD_PROTOCOL 0x7
3015 +#define RESTART 0x8
3016 +
3017 +#define AUTH_VERSION 0x1
3018 +
3019 +#define MAX_AUTH_MESSAGE_SIZE 1024
3020 +
3021 +struct lpfc_auth_reject {
3022 + uint8_t reason;
3023 + uint8_t explanation;
3024 + uint8_t reserved[2];
3025 +} __attribute__ ((packed));
3026 +
3027 +struct lpfc_auth_message { /* Structure is in Big Endian format */
3028 + uint8_t command_code;
3029 + uint8_t flags;
3030 + uint8_t message_code;
3031 + uint8_t protocol_ver;
3032 + uint32_t message_len;
3033 + uint32_t trans_id;
3034 + uint8_t data[0];
3035 +} __attribute__ ((packed));
3036 +
3037 +int lpfc_build_auth_neg(struct lpfc_vport *vport, uint8_t *message);
3038 +int lpfc_build_dhchap_challenge(struct lpfc_vport *vport, uint8_t *message,
3039 + struct fc_auth_rsp *fc_rsp);
3040 +int lpfc_build_dhchap_reply(struct lpfc_vport *vport, uint8_t *message,
3041 + struct fc_auth_rsp *fc_rsp);
3042 +int lpfc_build_dhchap_success(struct lpfc_vport *vport, uint8_t *message,
3043 + struct fc_auth_rsp *fc_rsp);
3044 +
3045 +int lpfc_unpack_auth_negotiate(struct lpfc_vport *vport, uint8_t *message,
3046 + uint8_t *reason, uint8_t *explanation);
3047 +int lpfc_unpack_dhchap_challenge(struct lpfc_vport *vport, uint8_t *message,
3048 + uint8_t *reason, uint8_t *explanation);
3049 +int lpfc_unpack_dhchap_reply(struct lpfc_vport *vport, uint8_t *message,
3050 + struct fc_auth_req *fc_req);
3051 +int lpfc_unpack_dhchap_success(struct lpfc_vport *vport, uint8_t *message,
3052 + struct fc_auth_req *fc_req);
3053 --- a/drivers/scsi/lpfc/lpfc_crtn.h
3054 +++ b/drivers/scsi/lpfc/lpfc_crtn.h
3055 @@ -21,6 +21,12 @@
3056 typedef int (*node_filter)(struct lpfc_nodelist *, void *);
3057
3058 struct fc_rport;
3059 +int lpfc_issue_els_auth(struct lpfc_vport *, struct lpfc_nodelist *,
3060 + uint8_t message_code, uint8_t *payload,
3061 + uint32_t payload_len);
3062 +int lpfc_issue_els_auth_reject(struct lpfc_vport *vport,
3063 + struct lpfc_nodelist *ndlp,
3064 + uint8_t reason, uint8_t explanation);
3065 void lpfc_dump_mem(struct lpfc_hba *, LPFC_MBOXQ_t *, uint16_t);
3066 void lpfc_read_nv(struct lpfc_hba *, LPFC_MBOXQ_t *);
3067 void lpfc_config_async(struct lpfc_hba *, LPFC_MBOXQ_t *, uint32_t);
3068 @@ -80,7 +86,10 @@ void lpfc_cleanup(struct lpfc_vport *);
3069 void lpfc_disc_timeout(unsigned long);
3070
3071 struct lpfc_nodelist *__lpfc_findnode_rpi(struct lpfc_vport *, uint16_t);
3072 +struct lpfc_nodelist *lpfc_findnode_wwnn(struct lpfc_vport *,
3073 + struct lpfc_name *);
3074
3075 +void lpfc_port_auth_failed(struct lpfc_nodelist *);
3076 void lpfc_worker_wake_up(struct lpfc_hba *);
3077 int lpfc_workq_post_event(struct lpfc_hba *, void *, void *, uint32_t);
3078 int lpfc_do_work(void *);
3079 @@ -95,6 +104,9 @@ void lpfc_more_plogi(struct lpfc_vport *
3080 void lpfc_more_adisc(struct lpfc_vport *);
3081 void lpfc_end_rscn(struct lpfc_vport *);
3082 int lpfc_els_chk_latt(struct lpfc_vport *);
3083 +struct lpfc_iocbq *lpfc_prep_els_iocb(struct lpfc_vport *, uint8_t, uint16_t,
3084 + uint8_t, struct lpfc_nodelist *, uint32_t,
3085 + uint32_t);
3086 int lpfc_els_abort_flogi(struct lpfc_hba *);
3087 int lpfc_initial_flogi(struct lpfc_vport *);
3088 int lpfc_initial_fdisc(struct lpfc_vport *);
3089 @@ -117,6 +129,8 @@ int lpfc_els_rsp_prli_acc(struct lpfc_vp
3090 void lpfc_cancel_retry_delay_tmo(struct lpfc_vport *, struct lpfc_nodelist *);
3091 void lpfc_els_retry_delay(unsigned long);
3092 void lpfc_els_retry_delay_handler(struct lpfc_nodelist *);
3093 +void lpfc_reauth_node(unsigned long);
3094 +void lpfc_reauthentication_handler(struct lpfc_nodelist *);
3095 void lpfc_els_unsol_event(struct lpfc_hba *, struct lpfc_sli_ring *,
3096 struct lpfc_iocbq *);
3097 int lpfc_els_handle_rscn(struct lpfc_vport *);
3098 @@ -258,7 +272,6 @@ void lpfc_free_sysfs_attr(struct lpfc_vp
3099 extern struct device_attribute *lpfc_hba_attrs[];
3100 extern struct device_attribute *lpfc_vport_attrs[];
3101 extern struct scsi_host_template lpfc_template;
3102 -extern struct scsi_host_template lpfc_vport_template;
3103 extern struct fc_function_template lpfc_transport_functions;
3104 extern struct fc_function_template lpfc_vport_transport_functions;
3105 extern int lpfc_sli_mode;
3106 @@ -276,6 +289,22 @@ void destroy_port(struct lpfc_vport *);
3107 int lpfc_get_instance(void);
3108 void lpfc_host_attrib_init(struct Scsi_Host *);
3109
3110 +int lpfc_selective_reset(struct lpfc_hba *);
3111 +int lpfc_security_wait(struct lpfc_hba *);
3112 +int lpfc_get_security_enabled(struct Scsi_Host *);
3113 +void lpfc_security_service_online(struct Scsi_Host *);
3114 +void lpfc_security_service_offline(struct Scsi_Host *);
3115 +void lpfc_security_config(struct Scsi_Host *, int status, void *);
3116 +int lpfc_security_config_wait(struct lpfc_vport *vport);
3117 +void lpfc_dhchap_make_challenge(struct Scsi_Host *, int , void *, uint32_t);
3118 +void lpfc_dhchap_make_response(struct Scsi_Host *, int , void *, uint32_t);
3119 +void lpfc_dhchap_authenticate(struct Scsi_Host *, int , void *, uint32_t);
3120 +int lpfc_start_node_authentication(struct lpfc_nodelist *);
3121 +int lpfc_get_auth_config(struct lpfc_nodelist *, struct lpfc_name *);
3122 +void lpfc_start_discovery(struct lpfc_vport *vport);
3123 +void lpfc_start_authentication(struct lpfc_vport *, struct lpfc_nodelist *);
3124 +int lpfc_rcv_nl_msg(struct Scsi_Host *, void *, uint32_t, uint32_t);
3125 +
3126 extern void lpfc_debugfs_initialize(struct lpfc_vport *);
3127 extern void lpfc_debugfs_terminate(struct lpfc_vport *);
3128 extern void lpfc_debugfs_disc_trc(struct lpfc_vport *, int, char *, uint32_t,
3129 @@ -284,6 +313,11 @@ extern void lpfc_debugfs_slow_ring_trc(s
3130 uint32_t, uint32_t);
3131 extern struct lpfc_hbq_init *lpfc_hbq_defs[];
3132
3133 +extern uint8_t lpfc_security_service_state;
3134 +extern spinlock_t fc_security_user_lock;
3135 +extern struct list_head fc_security_user_list;
3136 +extern int fc_service_state;
3137 +
3138 /* Interface exported by fabric iocb scheduler */
3139 void lpfc_fabric_abort_nport(struct lpfc_nodelist *);
3140 void lpfc_fabric_abort_hba(struct lpfc_hba *);
3141 @@ -293,6 +327,7 @@ void lpfc_adjust_queue_depth(struct lpfc
3142 void lpfc_ramp_down_queue_handler(struct lpfc_hba *);
3143 void lpfc_ramp_up_queue_handler(struct lpfc_hba *);
3144 void lpfc_scsi_dev_block(struct lpfc_hba *);
3145 +void lpfc_scsi_dev_rescan(struct lpfc_hba *);
3146
3147 void
3148 lpfc_send_els_failure_event(struct lpfc_hba *, struct lpfc_iocbq *,
3149 --- a/drivers/scsi/lpfc/lpfc_disc.h
3150 +++ b/drivers/scsi/lpfc/lpfc_disc.h
3151 @@ -37,6 +37,7 @@ enum lpfc_work_type {
3152 LPFC_EVT_KILL,
3153 LPFC_EVT_ELS_RETRY,
3154 LPFC_EVT_DEV_LOSS,
3155 + LPFC_EVT_REAUTH,
3156 LPFC_EVT_FASTPATH_MGMT_EVT,
3157 };
3158
3159 @@ -99,10 +100,12 @@ struct lpfc_nodelist {
3160 #define NLP_USG_FREE_ACK_BIT 0x8 /* Indicate ndlp memory free invoked */
3161
3162 struct timer_list nlp_delayfunc; /* Used for delayed ELS cmds */
3163 + struct timer_list nlp_reauth_tmr; /* Used for re-authentication */
3164 struct fc_rport *rport; /* Corresponding FC transport
3165 port structure */
3166 struct lpfc_vport *vport;
3167 struct lpfc_work_evt els_retry_evt;
3168 + struct lpfc_work_evt els_reauth_evt;
3169 struct lpfc_work_evt dev_loss_evt;
3170 unsigned long last_ramp_up_time; /* jiffy of last ramp up */
3171 unsigned long last_q_full_time; /* jiffy of last queue full */
3172 --- a/drivers/scsi/lpfc/lpfc_els.c
3173 +++ b/drivers/scsi/lpfc/lpfc_els.c
3174 @@ -38,6 +38,9 @@
3175 #include "lpfc_crtn.h"
3176 #include "lpfc_vport.h"
3177 #include "lpfc_debugfs.h"
3178 +#include "lpfc_auth_access.h"
3179 +#include "lpfc_auth.h"
3180 +#include "lpfc_security.h"
3181
3182 static int lpfc_els_retry(struct lpfc_hba *, struct lpfc_iocbq *,
3183 struct lpfc_iocbq *);
3184 @@ -143,7 +146,7 @@ lpfc_els_chk_latt(struct lpfc_vport *vpo
3185 * Pointer to the newly allocated/prepared els iocb data structure
3186 * NULL - when els iocb data structure allocation/preparation failed
3187 **/
3188 -static struct lpfc_iocbq *
3189 +struct lpfc_iocbq *
3190 lpfc_prep_els_iocb(struct lpfc_vport *vport, uint8_t expectRsp,
3191 uint16_t cmdSize, uint8_t retry,
3192 struct lpfc_nodelist *ndlp, uint32_t did,
3193 @@ -653,6 +656,7 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phb
3194 struct lpfc_nodelist *ndlp = cmdiocb->context1;
3195 struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp;
3196 struct serv_parm *sp;
3197 + struct lpfc_name wwpn;
3198 int rc;
3199
3200 /* Check to see if link went down during discovery */
3201 @@ -703,7 +707,10 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phb
3202 prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, list);
3203
3204 sp = prsp->virt + sizeof(uint32_t);
3205 -
3206 + if (sp->cmn.security)
3207 + ndlp->nlp_flag |= NLP_SC_REQ;
3208 + else
3209 + ndlp->nlp_flag &= ~NLP_SC_REQ;
3210 /* FLOGI completes successfully */
3211 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3212 "0101 FLOGI completes sucessfully "
3213 @@ -711,6 +718,20 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phb
3214 irsp->un.ulpWord[4], sp->cmn.e_d_tov,
3215 sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution);
3216
3217 + if (vport->cfg_enable_auth) {
3218 + u64_to_wwn(AUTH_FABRIC_WWN, wwpn.u.wwn);
3219 + if (lpfc_get_auth_config(ndlp, &wwpn))
3220 + goto flogifail;
3221 + } else {
3222 + vport->auth.security_active = 0;
3223 + if (sp->cmn.security) {
3224 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
3225 + "1055 Authentication parameter is "
3226 + "disabled, but is required by "
3227 + "the fabric.\n");
3228 + goto flogifail;
3229 + }
3230 + }
3231 if (vport->port_state == LPFC_FLOGI) {
3232 /*
3233 * If Common Service Parameters indicate Nport
3234 @@ -800,6 +821,10 @@ lpfc_issue_els_flogi(struct lpfc_vport *
3235 sp = (struct serv_parm *) pcmd;
3236
3237 /* Setup CSPs accordingly for Fabric */
3238 +
3239 + if (vport->cfg_enable_auth)
3240 + sp->cmn.security = 1;
3241 +
3242 sp->cmn.e_d_tov = 0;
3243 sp->cmn.w2.r_a_tov = 0;
3244 sp->cls1.classValid = 0;
3245 @@ -965,6 +990,17 @@ lpfc_initial_fdisc(struct lpfc_vport *vp
3246 struct lpfc_hba *phba = vport->phba;
3247 struct lpfc_nodelist *ndlp;
3248
3249 + if (vport->cfg_enable_auth) {
3250 + if (lpfc_security_wait(phba)) {
3251 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
3252 + "1049 Authentication is enabled but "
3253 + "authentication service is not "
3254 + "running\n");
3255 + vport->auth.auth_mode = FC_AUTHMODE_UNKNOWN;
3256 + return 0;
3257 + }
3258 + }
3259 +
3260 /* First look for the Fabric ndlp */
3261 ndlp = lpfc_findnode_did(vport, Fabric_DID);
3262 if (!ndlp) {
3263 @@ -2697,6 +2733,17 @@ lpfc_els_retry(struct lpfc_hba *phba, st
3264 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
3265 lpfc_issue_els_logo(vport, ndlp, cmdiocb->retry);
3266 return 1;
3267 + case ELS_CMD_AUTH_NEG:
3268 + case ELS_CMD_DH_CHA:
3269 + case ELS_CMD_DH_REP:
3270 + case ELS_CMD_DH_SUC:
3271 + ndlp->nlp_prev_state = ndlp->nlp_state;
3272 + ndlp->nlp_state = NLP_STE_NPR_NODE;
3273 + lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
3274 + "0143 Authentication LS_RJT Logical "
3275 + "busy\n");
3276 + lpfc_start_authentication(vport, ndlp);
3277 + return 1;
3278 }
3279 }
3280 /* No retry ELS command <elsCmd> to remote NPORT <did> */
3281 @@ -5085,6 +5132,363 @@ lpfc_els_flush_all_cmd(struct lpfc_hba
3282 return;
3283 }
3284
3285 +static void
3286 +lpfc_els_rcv_auth_neg(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3287 + struct lpfc_nodelist *ndlp)
3288 +{
3289 + struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3290 + struct lpfc_dmabuf *pcmd = cmdiocb->context2;
3291 + struct lpfc_auth_message *authcmd;
3292 + uint8_t reason, explanation;
3293 + uint32_t message_len;
3294 + uint32_t trans_id;
3295 + struct fc_auth_req *fc_req;
3296 + struct fc_auth_rsp *fc_rsp;
3297 +
3298 + authcmd = pcmd->virt;
3299 + message_len = be32_to_cpu(authcmd->message_len);
3300 + trans_id = be32_to_cpu(authcmd->trans_id);
3301 +
3302 + lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
3303 +
3304 + vport->auth.trans_id = trans_id;
3305 +
3306 + if (lpfc_unpack_auth_negotiate(vport, authcmd->data,
3307 + &reason, &explanation)) {
3308 + lpfc_issue_els_auth_reject(vport, ndlp, reason, explanation);
3309 + return;
3310 + }
3311 + vport->auth.direction = AUTH_DIRECTION_NONE;
3312 + lpfc_printf_vlog(vport, KERN_WARNING, LOG_SECURITY,
3313 + "1033 Received auth_negotiate from Nport:x%x\n",
3314 + ndlp->nlp_DID);
3315 +
3316 + fc_req = kzalloc(sizeof(struct fc_auth_req), GFP_KERNEL);
3317 +
3318 + fc_req->local_wwpn = wwn_to_u64(vport->fc_portname.u.wwn);
3319 + if (ndlp->nlp_type & NLP_FABRIC)
3320 + fc_req->remote_wwpn = AUTH_FABRIC_WWN;
3321 + else
3322 + fc_req->remote_wwpn = wwn_to_u64(ndlp->nlp_portname.u.wwn);
3323 + fc_req->u.dhchap_challenge.transaction_id = vport->auth.trans_id;
3324 + fc_req->u.dhchap_challenge.dh_group_id = vport->auth.group_id;
3325 + fc_req->u.dhchap_challenge.hash_id = vport->auth.hash_id;
3326 +
3327 + fc_rsp = kzalloc(MAX_AUTH_RSP_SIZE, GFP_KERNEL);
3328 +
3329 + if (lpfc_fc_security_dhchap_make_challenge(shost,
3330 + fc_req, sizeof(struct fc_auth_req),
3331 + fc_rsp, MAX_AUTH_RSP_SIZE)) {
3332 + kfree(fc_rsp);
3333 + lpfc_issue_els_auth_reject(vport, ndlp, LOGIC_ERR, 0);
3334 + }
3335 +
3336 + kfree(fc_req);
3337 +
3338 +}
3339 +
3340 +static void
3341 +lpfc_els_rcv_chap_chal(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3342 + struct lpfc_nodelist *ndlp)
3343 +{
3344 +
3345 + struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3346 + struct lpfc_dmabuf *pcmd = cmdiocb->context2;
3347 + struct lpfc_auth_message *authcmd;
3348 + uint8_t reason, explanation;
3349 + uint32_t message_len;
3350 + uint32_t trans_id;
3351 + struct fc_auth_req *fc_req;
3352 + struct fc_auth_rsp *fc_rsp;
3353 + uint32_t fc_req_len;
3354 +
3355 + authcmd = pcmd->virt;
3356 + message_len = be32_to_cpu(authcmd->message_len);
3357 + trans_id = be32_to_cpu(authcmd->trans_id);
3358 +
3359 + lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
3360 +
3361 + if (vport->auth.auth_msg_state != LPFC_AUTH_NEGOTIATE) {
3362 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
3363 + "1034 Not Expecting Challenge - Rejecting "
3364 + "Challenge.\n");
3365 + lpfc_issue_els_auth_reject(vport, ndlp, AUTH_ERR, BAD_PROTOCOL);
3366 + return;
3367 + }
3368 +
3369 + if (trans_id != vport->auth.trans_id) {
3370 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
3371 + "1035 Transport ID does not match - Rejecting "
3372 + "Challenge.\n");
3373 + lpfc_issue_els_auth_reject(vport, ndlp, AUTH_ERR, BAD_PAYLOAD);
3374 + return;
3375 + }
3376 +
3377 + if (lpfc_unpack_dhchap_challenge(vport, authcmd->data,
3378 + &reason, &explanation)) {
3379 + lpfc_issue_els_auth_reject(vport, ndlp, reason, explanation);
3380 + return;
3381 + }
3382 + vport->auth.direction = AUTH_DIRECTION_NONE;
3383 +
3384 + fc_req_len = (sizeof(struct fc_auth_req) +
3385 + vport->auth.challenge_len +
3386 + vport->auth.dh_pub_key_len);
3387 + fc_req = kzalloc(fc_req_len, GFP_KERNEL);
3388 + fc_req->local_wwpn = wwn_to_u64(vport->fc_portname.u.wwn);
3389 + if (ndlp->nlp_type & NLP_FABRIC)
3390 + fc_req->remote_wwpn = AUTH_FABRIC_WWN;
3391 + else
3392 + fc_req->remote_wwpn = wwn_to_u64(ndlp->nlp_portname.u.wwn);
3393 + fc_req->u.dhchap_reply.transaction_id = vport->auth.trans_id;
3394 + fc_req->u.dhchap_reply.dh_group_id = vport->auth.group_id;
3395 + fc_req->u.dhchap_reply.hash_id = vport->auth.hash_id;
3396 + fc_req->u.dhchap_reply.bidirectional = vport->auth.bidirectional;
3397 + fc_req->u.dhchap_reply.received_challenge_len =
3398 + vport->auth.challenge_len;
3399 + fc_req->u.dhchap_reply.received_public_key_len =
3400 + vport->auth.dh_pub_key_len;
3401 + memcpy(fc_req->u.dhchap_reply.data, vport->auth.challenge,
3402 + vport->auth.challenge_len);
3403 + if (vport->auth.group_id != DH_GROUP_NULL) {
3404 + memcpy(fc_req->u.dhchap_reply.data + vport->auth.challenge_len,
3405 + vport->auth.dh_pub_key, vport->auth.dh_pub_key_len);
3406 + }
3407 +
3408 + fc_rsp = kzalloc(MAX_AUTH_RSP_SIZE, GFP_KERNEL);
3409 +
3410 + if (lpfc_fc_security_dhchap_make_response(shost,
3411 + fc_req, fc_req_len,
3412 + fc_rsp, MAX_AUTH_RSP_SIZE)) {
3413 + kfree(fc_rsp);
3414 + lpfc_issue_els_auth_reject(vport, ndlp, LOGIC_ERR, 0);
3415 + }
3416 +
3417 + kfree(fc_req);
3418 +
3419 +}
3420 +
3421 +static void
3422 +lpfc_els_rcv_auth_rjt(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3423 + struct lpfc_nodelist *ndlp)
3424 +{
3425 +
3426 + struct lpfc_dmabuf *pcmd = cmdiocb->context2;
3427 + struct lpfc_auth_message *authcmd;
3428 + uint32_t message_len;
3429 + uint32_t trans_id;
3430 + struct lpfc_auth_reject *rjt;
3431 + struct lpfc_hba *phba = vport->phba;
3432 +
3433 + authcmd = pcmd->virt;
3434 + rjt = (struct lpfc_auth_reject *)authcmd->data;
3435 +
3436 + message_len = be32_to_cpu(authcmd->message_len);
3437 + trans_id = be32_to_cpu(authcmd->trans_id);
3438 +
3439 + lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
3440 +
3441 + if (vport->auth.auth_state == LPFC_AUTH_SUCCESS) {
3442 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
3443 + "1036 Authentication transaction reject - "
3444 + "re-auth request reason 0x%x exp 0x%x\n",
3445 + rjt->reason, rjt->explanation);
3446 + lpfc_port_auth_failed(ndlp);
3447 + if (vport->auth.auth_msg_state == LPFC_DHCHAP_SUCCESS) {
3448 + /* start authentication */
3449 + lpfc_start_authentication(vport, ndlp);
3450 + }
3451 + } else {
3452 + if (rjt->reason == LOGIC_ERR && rjt->explanation == RESTART) {
3453 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
3454 + "1037 Authentication transaction "
3455 + "reject - restarting authentication. "
3456 + "reason 0x%x exp 0x%x\n",
3457 + rjt->reason, rjt->explanation);
3458 + /* restart auth */
3459 + lpfc_start_authentication(vport, ndlp);
3460 + } else {
3461 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
3462 + "1057 Authentication transaction "
3463 + "reject. reason 0x%x exp 0x%x\n",
3464 + rjt->reason, rjt->explanation);
3465 + vport->auth.auth_msg_state = LPFC_AUTH_REJECT;
3466 + if (!(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
3467 + (phba->link_state != LPFC_CLEAR_LA)) {
3468 + /* If Auth failed enable link interrupt. */
3469 + lpfc_issue_clear_la(phba, vport);
3470 + }
3471 + }
3472 + }
3473 +}
3474 +
3475 +static void
3476 +lpfc_els_rcv_chap_reply(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3477 + struct lpfc_nodelist *ndlp)
3478 +{
3479 +
3480 + struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3481 + struct lpfc_dmabuf *pcmd = cmdiocb->context2;
3482 + struct lpfc_auth_message *authcmd;
3483 + uint32_t message_len;
3484 + uint32_t trans_id;
3485 + struct fc_auth_req *fc_req;
3486 + struct fc_auth_rsp *fc_rsp;
3487 + uint32_t data_len;
3488 +
3489 + authcmd = pcmd->virt;
3490 + message_len = be32_to_cpu(authcmd->message_len);
3491 + trans_id = be32_to_cpu(authcmd->trans_id);
3492 +
3493 + lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
3494 +
3495 + fc_req = kzalloc(MAX_AUTH_REQ_SIZE, GFP_KERNEL);
3496 +
3497 + fc_req->local_wwpn = wwn_to_u64(vport->fc_portname.u.wwn);
3498 + if (ndlp->nlp_type & NLP_FABRIC)
3499 + fc_req->remote_wwpn = AUTH_FABRIC_WWN;
3500 + else
3501 + fc_req->remote_wwpn = wwn_to_u64(ndlp->nlp_portname.u.wwn);
3502 +
3503 + if (vport->auth.auth_msg_state != LPFC_DHCHAP_CHALLENGE) {
3504 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
3505 + "1039 Not Expecting Reply - rejecting. State "
3506 + "0x%x\n", vport->auth.auth_state);
3507 +
3508 + lpfc_issue_els_auth_reject(vport, ndlp, AUTH_ERR, BAD_PROTOCOL);
3509 + return;
3510 + }
3511 +
3512 + if (trans_id != vport->auth.trans_id) {
3513 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
3514 + "1040 Bad Reply trans_id- rejecting. "
3515 + "Trans_id: 0x%x Expecting: 0x%x \n",
3516 + trans_id, vport->auth.trans_id);
3517 + lpfc_issue_els_auth_reject(vport, ndlp, AUTH_ERR, BAD_PAYLOAD);
3518 + return;
3519 + }
3520 +
3521 + /* Zero is a valid length to be returned */
3522 + data_len = lpfc_unpack_dhchap_reply(vport, authcmd->data, fc_req);
3523 + fc_req->u.dhchap_success.hash_id = vport->auth.hash_id;
3524 + fc_req->u.dhchap_success.dh_group_id = vport->auth.group_id;
3525 + fc_req->u.dhchap_success.transaction_id = vport->auth.trans_id;
3526 + fc_req->u.dhchap_success.our_challenge_len = vport->auth.challenge_len;
3527 + memcpy(fc_req->u.dhchap_success.data, vport->auth.challenge,
3528 + vport->auth.challenge_len);
3529 +
3530 + fc_rsp = kzalloc(MAX_AUTH_RSP_SIZE, GFP_KERNEL);
3531 +
3532 + if (lpfc_fc_security_dhchap_authenticate(shost, fc_req,
3533 + (sizeof(struct fc_auth_req) +
3534 + data_len + vport->auth.challenge_len),
3535 + fc_rsp, MAX_AUTH_RSP_SIZE)) {
3536 + kfree(fc_rsp);
3537 + lpfc_issue_els_auth_reject(vport, ndlp, LOGIC_ERR, 0);
3538 + }
3539 +
3540 + kfree(fc_req);
3541 +
3542 +}
3543 +
3544 +static void
3545 +lpfc_els_rcv_chap_suc(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3546 + struct lpfc_nodelist *ndlp)
3547 +{
3548 +
3549 + struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3550 + struct lpfc_dmabuf *pcmd = cmdiocb->context2;
3551 + struct lpfc_auth_message *authcmd;
3552 + uint32_t message_len;
3553 + uint32_t trans_id;
3554 + struct fc_auth_req *fc_req;
3555 + struct fc_auth_rsp *fc_rsp;
3556 + uint32_t data_len;
3557 +
3558 + authcmd = pcmd->virt;
3559 + message_len = be32_to_cpu(authcmd->message_len);
3560 + trans_id = be32_to_cpu(authcmd->trans_id);
3561 +
3562 + lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
3563 +
3564 + if (vport->auth.auth_msg_state != LPFC_DHCHAP_REPLY &&
3565 + vport->auth.auth_msg_state != LPFC_DHCHAP_SUCCESS_REPLY) {
3566 + lpfc_issue_els_auth_reject(vport, ndlp, AUTH_ERR, BAD_PROTOCOL);
3567 + return;
3568 + }
3569 +
3570 + if (trans_id != vport->auth.trans_id) {
3571 + lpfc_issue_els_auth_reject(vport, ndlp, AUTH_ERR, BAD_PAYLOAD);
3572 + return;
3573 + }
3574 +
3575 + if (vport->auth.auth_msg_state == LPFC_DHCHAP_REPLY &&
3576 + vport->auth.bidirectional) {
3577 +
3578 + fc_req = kzalloc(MAX_AUTH_REQ_SIZE, GFP_KERNEL);
3579 + if (!fc_req)
3580 + return;
3581 +
3582 + fc_req->local_wwpn = wwn_to_u64(vport->fc_portname.u.wwn);
3583 + if (ndlp->nlp_type & NLP_FABRIC)
3584 + fc_req->remote_wwpn = AUTH_FABRIC_WWN;
3585 + else
3586 + fc_req->remote_wwpn =
3587 + wwn_to_u64(ndlp->nlp_portname.u.wwn);
3588 + fc_req->u.dhchap_success.hash_id = vport->auth.hash_id;
3589 + fc_req->u.dhchap_success.dh_group_id = vport->auth.group_id;
3590 + fc_req->u.dhchap_success.transaction_id = vport->auth.trans_id;
3591 + fc_req->u.dhchap_success.our_challenge_len =
3592 + vport->auth.challenge_len;
3593 +
3594 + memcpy(fc_req->u.dhchap_success.data, vport->auth.challenge,
3595 + vport->auth.challenge_len);
3596 +
3597 + /* Zero is a valid return length */
3598 + data_len = lpfc_unpack_dhchap_success(vport,
3599 + authcmd->data,
3600 + fc_req);
3601 +
3602 + fc_rsp = kzalloc(MAX_AUTH_RSP_SIZE, GFP_KERNEL);
3603 + if (!fc_rsp)
3604 + return;
3605 +
3606 + if (lpfc_fc_security_dhchap_authenticate(shost,
3607 + fc_req, sizeof(struct fc_auth_req) + data_len,
3608 + fc_rsp, MAX_AUTH_RSP_SIZE)) {
3609 + kfree(fc_rsp);
3610 + lpfc_issue_els_auth_reject(vport, ndlp, LOGIC_ERR, 0);
3611 + }
3612 +
3613 + kfree(fc_req);
3614 +
3615 + } else {
3616 + vport->auth.auth_msg_state = LPFC_DHCHAP_SUCCESS;
3617 +
3618 + kfree(vport->auth.challenge);
3619 + vport->auth.challenge = NULL;
3620 + vport->auth.challenge_len = 0;
3621 +
3622 + if (vport->auth.auth_state != LPFC_AUTH_SUCCESS) {
3623 + vport->auth.auth_state = LPFC_AUTH_SUCCESS;
3624 + lpfc_printf_vlog(vport, KERN_INFO, LOG_SECURITY,
3625 + "1041 Authentication Successful\n");
3626 +
3627 + lpfc_start_discovery(vport);
3628 +
3629 + } else {
3630 + lpfc_printf_vlog(vport, KERN_INFO, LOG_SECURITY,
3631 + "1042 Re-Authentication Successful\n");
3632 + }
3633 + /* If config requires re-authentication start the timer */
3634 + vport->auth.last_auth = jiffies;
3635 + if (vport->auth.reauth_interval)
3636 + mod_timer(&ndlp->nlp_reauth_tmr, jiffies +
3637 + vport->auth.reauth_interval * 60 * HZ);
3638 + }
3639 + vport->auth.direction |= AUTH_DIRECTION_REMOTE;
3640 +}
3641 +
3642 /**
3643 * lpfc_send_els_failure_event: Posts an ELS command failure event.
3644 * @phba: Pointer to hba context object.
3645 @@ -5462,6 +5866,48 @@ lpfc_els_unsol_buffer(struct lpfc_hba *p
3646 if (newnode)
3647 lpfc_nlp_put(ndlp);
3648 break;
3649 + case ELS_CMD_AUTH_RJT:
3650 + lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3651 + "RCV AUTH_RJT: did:x%x/ste:x%x flg:x%x",
3652 + did, vport->port_state, ndlp->nlp_flag);
3653 +
3654 + lpfc_els_rcv_auth_rjt(vport, elsiocb, ndlp);
3655 + break;
3656 + case ELS_CMD_AUTH_NEG:
3657 + lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3658 + "RCV AUTH_NEG: did:x%x/ste:x%x flg:x%x",
3659 + did, vport->port_state, ndlp->nlp_flag);
3660 +
3661 + lpfc_els_rcv_auth_neg(vport, elsiocb, ndlp);
3662 + break;
3663 + case ELS_CMD_DH_CHA:
3664 + lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3665 + "RCV DH_CHA: did:x%x/ste:x%x flg:x%x",
3666 + did, vport->port_state, ndlp->nlp_flag);
3667 +
3668 + lpfc_els_rcv_chap_chal(vport, elsiocb, ndlp);
3669 + break;
3670 + case ELS_CMD_DH_REP:
3671 + lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3672 + "RCV DH_REP: did:x%x/ste:x%x flg:x%x",
3673 + did, vport->port_state, ndlp->nlp_flag);
3674 +
3675 + lpfc_els_rcv_chap_reply(vport, elsiocb, ndlp);
3676 + break;
3677 + case ELS_CMD_DH_SUC:
3678 + lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3679 + "RCV DH_SUC: did:x%x/ste:x%x flg:x%x",
3680 + did, vport->port_state, ndlp->nlp_flag);
3681 +
3682 + lpfc_els_rcv_chap_suc(vport, elsiocb, ndlp);
3683 + break;
3684 +
3685 + case ELS_CMD_AUTH_DONE:
3686 + lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3687 + "RCV AUTH_DONE: did:x%x/ste:x%x flg:x%x",
3688 + did, vport->port_state, ndlp->nlp_flag);
3689 +
3690 +
3691 default:
3692 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3693 "RCV ELS cmd: cmd:x%x did:x%x/ste:x%x",
3694 @@ -5747,7 +6193,7 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba
3695 } else {
3696 if (vport == phba->pport)
3697 lpfc_issue_fabric_reglogin(vport);
3698 - else
3699 + else if (!vport->cfg_enable_auth)
3700 lpfc_do_scr_ns_plogi(phba, vport);
3701 }
3702
3703 @@ -5840,6 +6286,9 @@ lpfc_cmpl_els_fdisc(struct lpfc_hba *phb
3704 struct lpfc_nodelist *next_np;
3705 IOCB_t *irsp = &rspiocb->iocb;
3706 struct lpfc_iocbq *piocb;
3707 + struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp;
3708 + struct serv_parm *sp;
3709 + struct lpfc_name wwpn;
3710
3711 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3712 "0123 FDISC completes. x%x/x%x prevDID: x%x\n",
3713 @@ -5867,11 +6316,26 @@ lpfc_cmpl_els_fdisc(struct lpfc_hba *phb
3714 irsp->ulpStatus, irsp->un.ulpWord[4]);
3715 goto fdisc_failed;
3716 }
3717 - if (vport->fc_vport->vport_state == FC_VPORT_INITIALIZING)
3718 - lpfc_vport_set_state(vport, FC_VPORT_FAILED);
3719 - lpfc_nlp_put(ndlp);
3720 - /* giving up on FDISC. Cancel discovery timer */
3721 - lpfc_can_disctmo(vport);
3722 + prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, list);
3723 + sp = prsp->virt + sizeof(uint32_t);
3724 + if (sp->cmn.security)
3725 + ndlp->nlp_flag |= NLP_SC_REQ;
3726 + else
3727 + ndlp->nlp_flag &= ~NLP_SC_REQ;
3728 + if (vport->cfg_enable_auth) {
3729 + u64_to_wwn(AUTH_FABRIC_WWN, wwpn.u.wwn);
3730 + if (lpfc_get_auth_config(ndlp, &wwpn))
3731 + goto fdisc_failed;
3732 + } else {
3733 + vport->auth.security_active = 0;
3734 + if (sp->cmn.security) {
3735 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
3736 + "1056 Authentication mode is "
3737 + "disabled, but is required "
3738 + "by the fabric.\n");
3739 + goto fdisc_failed;
3740 + }
3741 + }
3742 spin_lock_irq(shost->host_lock);
3743 vport->fc_flag |= FC_FABRIC;
3744 if (vport->phba->fc_topology == TOPOLOGY_LOOP)
3745 @@ -5905,7 +6369,7 @@ lpfc_cmpl_els_fdisc(struct lpfc_hba *phb
3746
3747 if (vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)
3748 lpfc_register_new_vport(phba, vport, ndlp);
3749 - else
3750 + else if (!vport->cfg_enable_auth)
3751 lpfc_do_scr_ns_plogi(phba, vport);
3752 goto out;
3753 fdisc_failed:
3754 @@ -5980,6 +6444,10 @@ lpfc_issue_els_fdisc(struct lpfc_vport *
3755 sp->cls2.seqDelivery = 1;
3756 sp->cls3.seqDelivery = 1;
3757
3758 + /* Set the security service parameter */
3759 + if (vport->cfg_enable_auth)
3760 + sp->cmn.security = 1;
3761 +
3762 pcmd += sizeof(uint32_t); /* CSP Word 2 */
3763 pcmd += sizeof(uint32_t); /* CSP Word 3 */
3764 pcmd += sizeof(uint32_t); /* CSP Word 4 */
3765 @@ -6474,3 +6942,180 @@ void lpfc_fabric_abort_hba(struct lpfc_h
3766 (piocb->iocb_cmpl) (phba, piocb, piocb);
3767 }
3768 }
3769 +static void
3770 +lpfc_cmpl_els_auth(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3771 + struct lpfc_iocbq *rspiocb)
3772 +{
3773 + IOCB_t *irsp = &rspiocb->iocb;
3774 + struct lpfc_vport *vport = cmdiocb->vport;
3775 + struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
3776 +
3777 + /* Check to see if link went down during discovery */
3778 + if (lpfc_els_chk_latt(vport)) {
3779 + vport->auth.auth_msg_state = LPFC_AUTH_NONE;
3780 + lpfc_els_free_iocb(phba, cmdiocb);
3781 + return;
3782 + }
3783 +
3784 + if (irsp->ulpStatus) {
3785 + if (irsp->ulpStatus == IOSTAT_LS_RJT) {
3786 + lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
3787 + "1043 Authentication LS_RJT\n");
3788 + }
3789 + /* Check for retry */
3790 + if (!lpfc_els_retry(phba, cmdiocb, rspiocb)) {
3791 + if (irsp->ulpStatus != IOSTAT_LS_RJT) {
3792 + lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
3793 + "1045 Issue AUTH_NEG failed."
3794 + "Status:%x\n",
3795 + irsp->ulpStatus);
3796 + }
3797 + if (vport->auth.auth_mode == FC_AUTHMODE_ACTIVE) {
3798 + lpfc_can_disctmo(vport);
3799 + lpfc_port_auth_failed(ndlp);
3800 + }
3801 + }
3802 + if (!(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
3803 + (phba->link_state != LPFC_CLEAR_LA))
3804 + lpfc_issue_clear_la(phba, vport);
3805 + lpfc_els_free_iocb(phba, cmdiocb);
3806 + return;
3807 + }
3808 +
3809 + if (vport->auth.auth_msg_state == LPFC_DHCHAP_SUCCESS ||
3810 + vport->auth.auth_msg_state == LPFC_DHCHAP_SUCCESS_REPLY) {
3811 +
3812 + kfree(vport->auth.challenge);
3813 + vport->auth.challenge = NULL;
3814 + vport->auth.challenge_len = 0;
3815 + kfree(vport->auth.dh_pub_key);
3816 + vport->auth.dh_pub_key = NULL;
3817 + vport->auth.dh_pub_key_len = 0;
3818 +
3819 + if (vport->auth.auth_msg_state == LPFC_DHCHAP_SUCCESS) {
3820 + if (vport->auth.auth_state != LPFC_AUTH_SUCCESS) {
3821 + lpfc_printf_vlog(vport, KERN_WARNING,
3822 + LOG_SECURITY, "1046 "
3823 + "Authentication Successful\n");
3824 + vport->auth.auth_state = LPFC_AUTH_SUCCESS;
3825 + lpfc_start_discovery(vport);
3826 + } else {
3827 + lpfc_printf_vlog(vport, KERN_WARNING,
3828 + LOG_SECURITY,
3829 + "1047 Re-Authentication"
3830 + " Successful\n");
3831 + }
3832 + }
3833 + /* restart authentication timer */
3834 + vport->auth.last_auth = jiffies;
3835 + if (vport->auth.reauth_interval)
3836 + mod_timer(&ndlp->nlp_reauth_tmr,
3837 + jiffies +
3838 + vport->auth.reauth_interval * 60 * HZ);
3839 + }
3840 + lpfc_els_free_iocb(phba, cmdiocb);
3841 +}
3842 +
3843 +int
3844 +lpfc_issue_els_auth(struct lpfc_vport *vport,
3845 + struct lpfc_nodelist *ndlp,
3846 + uint8_t message_code,
3847 + uint8_t *payload,
3848 + uint32_t payload_len)
3849 +{
3850 + struct lpfc_hba *phba = vport->phba;
3851 + struct lpfc_iocbq *elsiocb;
3852 + struct lpfc_auth_message *authreq;
3853 +
3854 + elsiocb = lpfc_prep_els_iocb(vport, 1,
3855 + sizeof(struct lpfc_auth_message) + payload_len,
3856 + 0, ndlp, ndlp->nlp_DID, ELS_CMD_AUTH);
3857 +
3858 + if (!elsiocb)
3859 + return 1;
3860 + authreq = (struct lpfc_auth_message *)
3861 + (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
3862 + authreq->command_code = ELS_CMD_AUTH_BYTE;
3863 + authreq->flags = 0;
3864 + authreq->message_code = message_code;
3865 + authreq->protocol_ver = AUTH_VERSION;
3866 + authreq->message_len = cpu_to_be32(payload_len);
3867 + authreq->trans_id = cpu_to_be32(vport->auth.trans_id);
3868 + memcpy(authreq->data, payload, payload_len);
3869 +
3870 + elsiocb->iocb_cmpl = lpfc_cmpl_els_auth;
3871 +
3872 + if (lpfc_sli_issue_iocb(phba, &phba->sli.ring[LPFC_ELS_RING],
3873 + elsiocb, 0) == IOCB_ERROR) {
3874 + lpfc_els_free_iocb(phba, elsiocb);
3875 + return 1;
3876 + }
3877 +
3878 + return 0;
3879 +}
3880 +
3881 +static void
3882 +lpfc_cmpl_els_auth_reject(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3883 + struct lpfc_iocbq *rspiocb)
3884 +{
3885 + struct lpfc_vport *vport = cmdiocb->vport;
3886 + IOCB_t *irsp = &rspiocb->iocb;
3887 +
3888 + if (irsp->ulpStatus) {
3889 + /* Check for retry */
3890 + if (!lpfc_els_retry(phba, cmdiocb, rspiocb)) {
3891 + lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
3892 + "1048 Issue AUTH_REJECT failed.\n");
3893 + }
3894 + } else
3895 + vport->port_state = LPFC_VPORT_UNKNOWN;
3896 +
3897 + lpfc_els_free_iocb(phba, cmdiocb);
3898 +}
3899 +
3900 +int
3901 +lpfc_issue_els_auth_reject(struct lpfc_vport *vport,
3902 + struct lpfc_nodelist *ndlp,
3903 + uint8_t reason, uint8_t explanation)
3904 +{
3905 + struct lpfc_hba *phba = vport->phba;
3906 + struct lpfc_iocbq *elsiocb;
3907 + struct lpfc_sli_ring *pring;
3908 + struct lpfc_sli *psli;
3909 + struct lpfc_auth_message *authreq;
3910 + struct lpfc_auth_reject *reject;
3911 +
3912 + psli = &phba->sli;
3913 + pring = &psli->ring[LPFC_ELS_RING];
3914 +
3915 + vport->auth.auth_msg_state = LPFC_AUTH_REJECT;
3916 +
3917 + elsiocb = lpfc_prep_els_iocb(vport, 1, sizeof(struct lpfc_auth_message)
3918 + + sizeof(struct lpfc_auth_reject), 0, ndlp,
3919 + ndlp->nlp_DID, ELS_CMD_AUTH);
3920 +
3921 + if (!elsiocb)
3922 + return 1;
3923 +
3924 + authreq = (struct lpfc_auth_message *)
3925 + (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
3926 + authreq->command_code = ELS_CMD_AUTH_BYTE;
3927 + authreq->flags = 0;
3928 + authreq->message_code = AUTH_REJECT;
3929 + authreq->protocol_ver = AUTH_VERSION;
3930 + reject = (struct lpfc_auth_reject *)authreq->data;
3931 + memset(reject, 0, sizeof(struct lpfc_auth_reject));
3932 + reject->reason = reason;
3933 + reject->explanation = explanation;
3934 +
3935 + authreq->message_len = cpu_to_be32(sizeof(struct lpfc_auth_reject));
3936 + authreq->trans_id = cpu_to_be32(vport->auth.trans_id);
3937 + elsiocb->iocb_cmpl = lpfc_cmpl_els_auth_reject;
3938 +
3939 + if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
3940 + lpfc_els_free_iocb(phba, elsiocb);
3941 + return 1;
3942 + }
3943 +
3944 + return 0;
3945 +}
3946 --- a/drivers/scsi/lpfc/lpfc.h
3947 +++ b/drivers/scsi/lpfc/lpfc.h
3948 @@ -217,18 +217,81 @@ struct lpfc_stats {
3949 uint32_t fcpLocalErr;
3950 };
3951
3952 +struct lpfc_dmabufext {
3953 + struct lpfc_dmabuf dma;
3954 + uint32_t size;
3955 + uint32_t flag;
3956 +};
3957 +
3958 enum sysfs_mbox_state {
3959 SMBOX_IDLE,
3960 SMBOX_WRITING,
3961 - SMBOX_READING
3962 + SMBOX_WRITING_MBEXT,
3963 + SMBOX_READING_MBEXT,
3964 + SMBOX_READING,
3965 + SMBOX_WRITING_BUFF,
3966 + SMBOX_READING_BUFF
3967 +};
3968 +
3969 +struct lpfc_sysfs_mbox_data {
3970 + MAILBOX_t mbox;
3971 + uint32_t mboffset;
3972 + uint32_t in_ext_wlen;
3973 + uint32_t out_ext_wlen;
3974 };
3975
3976 struct lpfc_sysfs_mbox {
3977 + struct lpfc_sysfs_mbox_data mbox_data;
3978 enum sysfs_mbox_state state;
3979 size_t offset;
3980 struct lpfcMboxq * mbox;
3981 + /* process id of the mgmt application */
3982 + pid_t pid;
3983 + struct list_head list;
3984 + uint8_t * mbext;
3985 + uint32_t extoff;
3986 + struct lpfc_dmabuf * txmit_buff;
3987 + struct lpfc_dmabuf * rcv_buff;
3988 +};
3989 +#define MENLO_DID 0x0000FC0E
3990 +
3991 +enum sysfs_menlo_state {
3992 + SMENLO_IDLE,
3993 + SMENLO_WRITING,
3994 + SMENLO_WRITING_MBEXT,
3995 + SMENLO_READING
3996 +};
3997 +
3998 +struct lpfc_sysfs_menlo_hdr {
3999 + uint32_t cmd;
4000 + uint32_t cmdsize;
4001 + uint32_t rspsize;
4002 +};
4003 +
4004 +struct lpfc_menlo_genreq64 {
4005 + size_t offset;
4006 + struct lpfc_iocbq *cmdiocbq;
4007 + struct lpfc_iocbq *rspiocbq;
4008 + struct lpfc_dmabuf *bmp;
4009 + struct lpfc_dmabufext *indmp;
4010 + struct ulp_bde64 *cmdbpl;
4011 + struct lpfc_dmabufext *outdmp;
4012 + uint32_t timeout;
4013 + struct list_head inhead;
4014 + struct list_head outhead;
4015 };
4016
4017 +struct lpfc_sysfs_menlo {
4018 + enum sysfs_menlo_state state;
4019 + /* process id of the mgmt application */
4020 + struct lpfc_sysfs_menlo_hdr cmdhdr;
4021 + struct lpfc_menlo_genreq64 cr;
4022 + struct lpfc_menlo_genreq64 cx;
4023 + pid_t pid;
4024 + struct list_head list;
4025 +};
4026 +
4027 +
4028 struct lpfc_hba;
4029
4030
4031 @@ -261,6 +324,52 @@ enum hba_state {
4032 LPFC_HBA_ERROR = -1
4033 };
4034
4035 +enum auth_state {
4036 + LPFC_AUTH_UNKNOWN = 0,
4037 + LPFC_AUTH_SUCCESS = 1,
4038 + LPFC_AUTH_FAIL = 2,
4039 +};
4040 +enum auth_msg_state {
4041 + LPFC_AUTH_NONE = 0,
4042 + LPFC_AUTH_REJECT = 1, /* Sent a Reject */
4043 + LPFC_AUTH_NEGOTIATE = 2, /* Auth Negotiate */
4044 + LPFC_DHCHAP_CHALLENGE = 3, /* Challenge */
4045 + LPFC_DHCHAP_REPLY = 4, /* Reply */
4046 + LPFC_DHCHAP_SUCCESS_REPLY = 5, /* Success with Reply */
4047 + LPFC_DHCHAP_SUCCESS = 6, /* Success */
4048 + LPFC_AUTH_DONE = 7,
4049 +};
4050 +
4051 +struct lpfc_auth {
4052 + uint8_t auth_mode;
4053 + uint8_t bidirectional;
4054 + uint8_t hash_priority[4];
4055 + uint32_t hash_len;
4056 + uint8_t dh_group_priority[8];
4057 + uint32_t dh_group_len;
4058 + uint32_t reauth_interval;
4059 +
4060 + uint8_t security_active;
4061 + enum auth_state auth_state;
4062 + enum auth_msg_state auth_msg_state;
4063 + uint32_t trans_id; /* current transaction id. Can be set
4064 + by incomming transactions as well */
4065 + uint32_t group_id;
4066 + uint32_t hash_id;
4067 + uint32_t direction;
4068 +#define AUTH_DIRECTION_NONE 0
4069 +#define AUTH_DIRECTION_REMOTE 0x1
4070 +#define AUTH_DIRECTION_LOCAL 0x2
4071 +#define AUTH_DIRECTION_BIDI (AUTH_DIRECTION_LOCAL|AUTH_DIRECTION_REMOTE)
4072 +
4073 + uint8_t *challenge;
4074 + uint32_t challenge_len;
4075 + uint8_t *dh_pub_key;
4076 + uint32_t dh_pub_key_len;
4077 +
4078 + unsigned long last_auth;
4079 +};
4080 +
4081 struct lpfc_vport {
4082 struct list_head listentry;
4083 struct lpfc_hba *phba;
4084 @@ -356,6 +465,14 @@ struct lpfc_vport {
4085 #define FC_UNLOADING 0x2 /* HBA in process of unloading drvr */
4086 char *vname; /* Application assigned name */
4087
4088 + /* Fields used for accessing auth service */
4089 + struct lpfc_auth auth;
4090 + uint32_t sc_tran_id;
4091 + struct list_head sc_response_wait_queue;
4092 + struct list_head sc_users;
4093 + struct work_struct sc_online_work;
4094 + struct work_struct sc_offline_work;
4095 +
4096 /* Vport Config Parameters */
4097 uint32_t cfg_scan_down;
4098 uint32_t cfg_lun_queue_depth;
4099 @@ -371,6 +488,7 @@ struct lpfc_vport {
4100 uint32_t cfg_max_luns;
4101 uint32_t cfg_enable_da_id;
4102 uint32_t cfg_max_scsicmpl_time;
4103 + uint32_t cfg_enable_auth;
4104
4105 uint32_t dev_loss_tmo_changed;
4106
4107 @@ -445,6 +563,7 @@ struct lpfc_hba {
4108 struct lpfc_dmabuf slim2p;
4109
4110 MAILBOX_t *mbox;
4111 + uint32_t *mbox_ext;
4112 uint32_t *inb_ha_copy;
4113 uint32_t *inb_counter;
4114 uint32_t inb_last_counter;
4115 @@ -573,7 +692,9 @@ struct lpfc_hba {
4116 uint64_t fc4OutputRequests;
4117 uint64_t fc4ControlRequests;
4118
4119 - struct lpfc_sysfs_mbox sysfs_mbox;
4120 + /* List of mailbox commands issued through sysfs */
4121 + struct list_head sysfs_mbox_list;
4122 + struct list_head sysfs_menlo_list;
4123
4124 /* fastpath list. */
4125 spinlock_t scsi_buf_list_lock;
4126 @@ -595,11 +716,13 @@ struct lpfc_hba {
4127 struct fc_host_statistics link_stats;
4128 enum intr_type_t intr_type;
4129 struct msix_entry msix_entries[LPFC_MSIX_VECTORS];
4130 + struct lpfcdfc_host *dfc_host;
4131
4132 struct list_head port_list;
4133 struct lpfc_vport *pport; /* physical lpfc_vport pointer */
4134 uint16_t max_vpi; /* Maximum virtual nports */
4135 -#define LPFC_MAX_VPI 0xFFFF /* Max number of VPI supported */
4136 +#define LPFC_MAX_VPI 0xFFFF /* Max number of VPI supported */
4137 +#define LPFC_INTR_VPI 100 /* Intermediate VPI supported */
4138 unsigned long *vpi_bmask; /* vpi allocation table */
4139
4140 /* Data structure used by fabric iocb scheduler */
4141 --- a/drivers/scsi/lpfc/lpfc_hbadisc.c
4142 +++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
4143 @@ -59,6 +59,47 @@ static uint8_t lpfcAlpaArray[] = {
4144
4145 static void lpfc_disc_timeout_handler(struct lpfc_vport *);
4146 static void lpfc_disc_flush_list(struct lpfc_vport *vport);
4147 +void
4148 +lpfc_start_discovery(struct lpfc_vport *vport)
4149 +{
4150 + struct lpfc_hba *phba = vport->phba;
4151 + struct lpfc_vport **vports;
4152 + int i;
4153 +
4154 + if (vport->auth.security_active &&
4155 + vport->auth.auth_state != LPFC_AUTH_SUCCESS) {
4156 + lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
4157 + "0285 Authentication not complete.\n");
4158 + return;
4159 + }
4160 + if (vport->port_type == LPFC_NPIV_PORT) {
4161 + lpfc_do_scr_ns_plogi(phba, vport);
4162 + return;
4163 + }
4164 +
4165 + vports = lpfc_create_vport_work_array(phba);
4166 + if (vports != NULL)
4167 + for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
4168 + if (vports[i]->port_type == LPFC_PHYSICAL_PORT)
4169 + continue;
4170 + if (phba->fc_topology == TOPOLOGY_LOOP) {
4171 + lpfc_vport_set_state(vports[i],
4172 + FC_VPORT_LINKDOWN);
4173 + continue;
4174 + }
4175 + if (phba->link_flag & LS_NPIV_FAB_SUPPORTED)
4176 + lpfc_initial_fdisc(vports[i]);
4177 + else {
4178 + lpfc_vport_set_state(vports[i],
4179 + FC_VPORT_NO_FABRIC_SUPP);
4180 + lpfc_printf_vlog(vports[i], KERN_ERR, LOG_ELS,
4181 + "0259 No NPIV Fabric "
4182 + "support\n");
4183 + }
4184 + }
4185 + lpfc_destroy_vport_work_array(phba, vports);
4186 + lpfc_do_scr_ns_plogi(phba, vport);
4187 +}
4188
4189 void
4190 lpfc_terminate_rport_io(struct fc_rport *rport)
4191 @@ -416,6 +457,15 @@ lpfc_work_list_done(struct lpfc_hba *phb
4192 */
4193 lpfc_nlp_put(ndlp);
4194 break;
4195 + case LPFC_EVT_REAUTH:
4196 + ndlp = (struct lpfc_nodelist *) (evtp->evt_arg1);
4197 + lpfc_reauthentication_handler(ndlp);
4198 + free_evt = 0; /* evt is part of ndlp */
4199 + /* decrement the node reference count held
4200 + * for this queued work
4201 + */
4202 + lpfc_nlp_put(ndlp);
4203 + break;
4204 case LPFC_EVT_DEV_LOSS:
4205 ndlp = (struct lpfc_nodelist *)(evtp->evt_arg1);
4206 lpfc_dev_loss_tmo_handler(ndlp);
4207 @@ -648,6 +698,9 @@ lpfc_cleanup_rpis(struct lpfc_vport *vpo
4208 continue;
4209 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
4210 continue;
4211 + /* Stop re-authentication timer of all nodes. */
4212 + del_timer_sync(&ndlp->nlp_reauth_tmr);
4213 +
4214 if ((phba->sli3_options & LPFC_SLI3_VPORT_TEARDOWN) ||
4215 ((vport->port_type == LPFC_NPIV_PORT) &&
4216 (ndlp->nlp_DID == NameServer_DID)))
4217 @@ -697,6 +750,23 @@ lpfc_linkdown_port(struct lpfc_vport *vp
4218
4219 lpfc_port_link_failure(vport);
4220
4221 + vport->auth.auth_state = LPFC_AUTH_UNKNOWN;
4222 + vport->auth.auth_msg_state = LPFC_AUTH_NONE;
4223 +}
4224 +
4225 +void
4226 +lpfc_port_auth_failed(struct lpfc_nodelist *ndlp)
4227 +{
4228 + struct lpfc_vport *vport = ndlp->vport;
4229 +
4230 + vport->auth.auth_state = LPFC_AUTH_FAIL;
4231 + vport->auth.auth_msg_state = LPFC_AUTH_NONE;
4232 + lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
4233 + if (ndlp->nlp_type & NLP_FABRIC) {
4234 + lpfc_port_link_failure(vport);
4235 + lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4236 + lpfc_issue_els_logo(vport, ndlp, 0);
4237 + }
4238 }
4239
4240 int
4241 @@ -801,7 +871,6 @@ lpfc_linkup_port(struct lpfc_vport *vpor
4242 return;
4243
4244 fc_host_post_event(shost, fc_get_event_number(), FCH_EVT_LINKUP, 0);
4245 -
4246 spin_lock_irq(shost->host_lock);
4247 vport->fc_flag &= ~(FC_PT2PT | FC_PT2PT_PLOGI | FC_ABORT_DISCOVERY |
4248 FC_RSCN_MODE | FC_NLP_MORE | FC_RSCN_DISCOVERY);
4249 @@ -1424,8 +1493,6 @@ lpfc_mbx_cmpl_fabric_reg_login(struct lp
4250 MAILBOX_t *mb = &pmb->mb;
4251 struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
4252 struct lpfc_nodelist *ndlp;
4253 - struct lpfc_vport **vports;
4254 - int i;
4255
4256 ndlp = (struct lpfc_nodelist *) pmb->context2;
4257 pmb->context1 = NULL;
4258 @@ -1463,33 +1530,9 @@ lpfc_mbx_cmpl_fabric_reg_login(struct lp
4259 ndlp->nlp_type |= NLP_FABRIC;
4260 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
4261
4262 - if (vport->port_state == LPFC_FABRIC_CFG_LINK) {
4263 - vports = lpfc_create_vport_work_array(phba);
4264 - if (vports != NULL)
4265 - for(i = 0;
4266 - i <= phba->max_vpi && vports[i] != NULL;
4267 - i++) {
4268 - if (vports[i]->port_type == LPFC_PHYSICAL_PORT)
4269 - continue;
4270 - if (phba->fc_topology == TOPOLOGY_LOOP) {
4271 - lpfc_vport_set_state(vports[i],
4272 - FC_VPORT_LINKDOWN);
4273 - continue;
4274 - }
4275 - if (phba->link_flag & LS_NPIV_FAB_SUPPORTED)
4276 - lpfc_initial_fdisc(vports[i]);
4277 - else {
4278 - lpfc_vport_set_state(vports[i],
4279 - FC_VPORT_NO_FABRIC_SUPP);
4280 - lpfc_printf_vlog(vport, KERN_ERR,
4281 - LOG_ELS,
4282 - "0259 No NPIV "
4283 - "Fabric support\n");
4284 - }
4285 - }
4286 - lpfc_destroy_vport_work_array(phba, vports);
4287 - lpfc_do_scr_ns_plogi(phba, vport);
4288 - }
4289 + if (vport->port_state == LPFC_FABRIC_CFG_LINK &&
4290 + !vport->cfg_enable_auth)
4291 + lpfc_start_discovery(vport);
4292
4293 lpfc_mbuf_free(phba, mp->virt, mp->phys);
4294 kfree(mp);
4295 @@ -1894,9 +1937,13 @@ lpfc_enable_node(struct lpfc_vport *vpor
4296 sizeof (struct lpfc_nodelist) - sizeof (struct list_head));
4297 INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp);
4298 INIT_LIST_HEAD(&ndlp->dev_loss_evt.evt_listp);
4299 + INIT_LIST_HEAD(&ndlp->els_reauth_evt.evt_listp);
4300 init_timer(&ndlp->nlp_delayfunc);
4301 ndlp->nlp_delayfunc.function = lpfc_els_retry_delay;
4302 ndlp->nlp_delayfunc.data = (unsigned long)ndlp;
4303 + init_timer(&ndlp->nlp_reauth_tmr);
4304 + ndlp->nlp_reauth_tmr.function = lpfc_reauth_node;
4305 + ndlp->nlp_reauth_tmr.data = (unsigned long)ndlp;
4306 ndlp->nlp_DID = did;
4307 ndlp->vport = vport;
4308 ndlp->nlp_sid = NLP_NO_SID;
4309 @@ -2264,9 +2311,12 @@ lpfc_cleanup_node(struct lpfc_vport *vpo
4310
4311 ndlp->nlp_last_elscmd = 0;
4312 del_timer_sync(&ndlp->nlp_delayfunc);
4313 + del_timer_sync(&ndlp->nlp_reauth_tmr);
4314
4315 list_del_init(&ndlp->els_retry_evt.evt_listp);
4316 list_del_init(&ndlp->dev_loss_evt.evt_listp);
4317 + if (!list_empty(&ndlp->els_reauth_evt.evt_listp))
4318 + list_del_init(&ndlp->els_reauth_evt.evt_listp);
4319
4320 lpfc_unreg_rpi(vport, ndlp);
4321
4322 @@ -3073,7 +3123,14 @@ lpfc_filter_by_wwpn(struct lpfc_nodelist
4323 sizeof(ndlp->nlp_portname)) == 0;
4324 }
4325
4326 -static struct lpfc_nodelist *
4327 +static int
4328 +lpfc_filter_by_wwnn(struct lpfc_nodelist *ndlp, void *param)
4329 +{
4330 + return memcmp(&ndlp->nlp_nodename, param,
4331 + sizeof(ndlp->nlp_nodename)) == 0;
4332 +}
4333 +
4334 +struct lpfc_nodelist *
4335 __lpfc_find_node(struct lpfc_vport *vport, node_filter filter, void *param)
4336 {
4337 struct lpfc_nodelist *ndlp;
4338 @@ -3086,6 +3143,22 @@ __lpfc_find_node(struct lpfc_vport *vpor
4339 }
4340
4341 /*
4342 + * Search node lists for a remote port matching filter criteria
4343 + * Caller needs to hold host_lock before calling this routine.
4344 + */
4345 +struct lpfc_nodelist *
4346 +lpfc_find_node(struct lpfc_vport *vport, node_filter filter, void *param)
4347 +{
4348 + struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4349 + struct lpfc_nodelist *ndlp;
4350 +
4351 + spin_lock_irq(shost->host_lock);
4352 + ndlp = __lpfc_find_node(vport, filter, param);
4353 + spin_unlock_irq(shost->host_lock);
4354 + return ndlp;
4355 +}
4356 +
4357 +/*
4358 * This routine looks up the ndlp lists for the given RPI. If rpi found it
4359 * returns the node list element pointer else return NULL.
4360 */
4361 @@ -3111,6 +3184,21 @@ lpfc_findnode_wwpn(struct lpfc_vport *vp
4362 return ndlp;
4363 }
4364
4365 +/*
4366 + * This routine looks up the ndlp lists for the given WWNN. If WWNN found it
4367 + * returns the node element list pointer else return NULL.
4368 + */
4369 +struct lpfc_nodelist *
4370 +lpfc_findnode_wwnn(struct lpfc_vport *vport, struct lpfc_name *wwnn)
4371 +{
4372 + struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4373 + struct lpfc_nodelist *ndlp;
4374 +
4375 + spin_lock_irq(shost->host_lock);
4376 + ndlp = __lpfc_find_node(vport, lpfc_filter_by_wwnn, wwnn);
4377 + spin_unlock_irq(shost->host_lock);
4378 + return ndlp;
4379 +}
4380 void
4381 lpfc_nlp_init(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
4382 uint32_t did)
4383 @@ -3118,9 +3206,13 @@ lpfc_nlp_init(struct lpfc_vport *vport,
4384 memset(ndlp, 0, sizeof (struct lpfc_nodelist));
4385 INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp);
4386 INIT_LIST_HEAD(&ndlp->dev_loss_evt.evt_listp);
4387 + INIT_LIST_HEAD(&ndlp->els_reauth_evt.evt_listp);
4388 init_timer(&ndlp->nlp_delayfunc);
4389 ndlp->nlp_delayfunc.function = lpfc_els_retry_delay;
4390 ndlp->nlp_delayfunc.data = (unsigned long)ndlp;
4391 + init_timer(&ndlp->nlp_reauth_tmr);
4392 + ndlp->nlp_reauth_tmr.function = lpfc_reauth_node;
4393 + ndlp->nlp_reauth_tmr.data = (unsigned long)ndlp;
4394 ndlp->nlp_DID = did;
4395 ndlp->vport = vport;
4396 ndlp->nlp_sid = NLP_NO_SID;
4397 --- a/drivers/scsi/lpfc/lpfc_hw.h
4398 +++ b/drivers/scsi/lpfc/lpfc_hw.h
4399 @@ -64,6 +64,7 @@
4400 #define SLI3_IOCB_CMD_SIZE 128
4401 #define SLI3_IOCB_RSP_SIZE 64
4402
4403 +#define BUF_SZ_4K 4096
4404
4405 /* Common Transport structures and definitions */
4406
4407 @@ -350,7 +351,8 @@ struct csp {
4408
4409 uint16_t huntgroup:1; /* FC Word 1, bit 23 */
4410 uint16_t simplex:1; /* FC Word 1, bit 22 */
4411 - uint16_t word1Reserved1:3; /* FC Word 1, bit 21:19 */
4412 + uint16_t security:1; /* FC Word 1, bit 21 */
4413 + uint16_t word1Reserved1:2; /* FC Word 1, bit 20:19 */
4414 uint16_t dhd:1; /* FC Word 1, bit 18 */
4415 uint16_t contIncSeqCnt:1; /* FC Word 1, bit 17 */
4416 uint16_t payloadlength:1; /* FC Word 1, bit 16 */
4417 @@ -367,7 +369,8 @@ struct csp {
4418 uint16_t payloadlength:1; /* FC Word 1, bit 16 */
4419 uint16_t contIncSeqCnt:1; /* FC Word 1, bit 17 */
4420 uint16_t dhd:1; /* FC Word 1, bit 18 */
4421 - uint16_t word1Reserved1:3; /* FC Word 1, bit 21:19 */
4422 + uint16_t word1Reserved1:2; /* FC Word 1, bit 20:19 */
4423 + uint16_t security:1; /* FC Word 1, bit 21 */
4424 uint16_t simplex:1; /* FC Word 1, bit 22 */
4425 uint16_t huntgroup:1; /* FC Word 1, bit 23 */
4426 #endif
4427 @@ -506,6 +509,17 @@ struct serv_parm { /* Structure is in Bi
4428 #define ELS_CMD_SCR 0x62000000
4429 #define ELS_CMD_RNID 0x78000000
4430 #define ELS_CMD_LIRR 0x7A000000
4431 +/*
4432 + * ELS commands for authentication
4433 + * ELS_CMD_AUTH<<24 | AUTH_NEGOTIATE<<8 | AUTH_VERSION
4434 + */
4435 +#define ELS_CMD_AUTH 0x90000000
4436 +#define ELS_CMD_AUTH_RJT 0x90000A01
4437 +#define ELS_CMD_AUTH_NEG 0x90000B01
4438 +#define ELS_CMD_AUTH_DONE 0x90000C01
4439 +#define ELS_CMD_DH_CHA 0x90001001
4440 +#define ELS_CMD_DH_REP 0x90001101
4441 +#define ELS_CMD_DH_SUC 0x90001201
4442 #else /* __LITTLE_ENDIAN_BITFIELD */
4443 #define ELS_CMD_MASK 0xffff
4444 #define ELS_RSP_MASK 0xff
4445 @@ -542,6 +556,17 @@ struct serv_parm { /* Structure is in Bi
4446 #define ELS_CMD_SCR 0x62
4447 #define ELS_CMD_RNID 0x78
4448 #define ELS_CMD_LIRR 0x7A
4449 +/*
4450 + * ELS commands for authentication
4451 + * ELS_CMD_AUTH | AUTH_NEGOTIATE<<16 | AUTH_VERSION<<24
4452 + */
4453 +#define ELS_CMD_AUTH 0x00000090
4454 +#define ELS_CMD_AUTH_RJT 0x010A0090
4455 +#define ELS_CMD_AUTH_NEG 0x010B0090
4456 +#define ELS_CMD_AUTH_DONE 0x010C0090
4457 +#define ELS_CMD_DH_CHA 0x01100090
4458 +#define ELS_CMD_DH_REP 0x01110090
4459 +#define ELS_CMD_DH_SUC 0x01120090
4460 #endif
4461
4462 /*
4463 @@ -1319,6 +1344,9 @@ typedef struct { /* FireFly BIU registe
4464 #define MBX_HEARTBEAT 0x31
4465 #define MBX_WRITE_VPARMS 0x32
4466 #define MBX_ASYNCEVT_ENABLE 0x33
4467 +#define MBX_READ_EVENT_LOG_STATUS 0x37
4468 +#define MBX_READ_EVENT_LOG 0x38
4469 +#define MBX_WRITE_EVENT_LOG 0x39
4470
4471 #define MBX_PORT_CAPABILITIES 0x3B
4472 #define MBX_PORT_IOV_CONTROL 0x3C
4473 @@ -1457,6 +1485,7 @@ typedef struct { /* FireFly BIU registe
4474 #define MBXERR_BAD_RCV_LENGTH 14
4475 #define MBXERR_DMA_ERROR 15
4476 #define MBXERR_ERROR 16
4477 +#define MBXERR_UNKNOWN_CMD 18
4478 #define MBX_NOT_FINISHED 255
4479
4480 #define MBX_BUSY 0xffffff /* Attempted cmd to busy Mailbox */
4481 @@ -1624,6 +1653,13 @@ typedef struct {
4482 } un;
4483 } BIU_DIAG_VAR;
4484
4485 +/* Structure for MB command READ_EVENT_LOG (0x38) */
4486 +typedef struct {
4487 + uint32_t rsvd1;
4488 + uint32_t offset;
4489 + struct ulp_bde64 rcv_bde64;
4490 +}READ_EVENT_LOG_VAR;
4491 +
4492 /* Structure for MB Command INIT_LINK (05) */
4493
4494 typedef struct {
4495 @@ -2744,6 +2780,10 @@ typedef struct {
4496 /* Union of all Mailbox Command types */
4497 #define MAILBOX_CMD_WSIZE 32
4498 #define MAILBOX_CMD_SIZE (MAILBOX_CMD_WSIZE * sizeof(uint32_t))
4499 +#define MAILBOX_EXT_WSIZE 512
4500 +#define MAILBOX_EXT_SIZE (MAILBOX_EXT_WSIZE * sizeof(uint32_t))
4501 +#define MAILBOX_HBA_EXT_OFFSET 0x100
4502 +#define MAILBOX_MAX_XMIT_SIZE 1024
4503
4504 typedef union {
4505 uint32_t varWords[MAILBOX_CMD_WSIZE - 1]; /* first word is type/
4506 @@ -2783,6 +2823,7 @@ typedef union {
4507 UNREG_VPI_VAR varUnregVpi; /* cmd = 0x97 (UNREG_VPI) */
4508 ASYNCEVT_ENABLE_VAR varCfgAsyncEvent; /*cmd = x33 (CONFIG_ASYNC) */
4509 struct config_msi_var varCfgMSI;/* cmd = x30 (CONFIG_MSI) */
4510 + READ_EVENT_LOG_VAR varRdEventLog; /* cmd = 0x38 (READ_EVENT_LOG) */
4511 } MAILVARIANTS;
4512
4513 /*
4514 @@ -3364,14 +3405,16 @@ typedef struct _IOCB { /* IOCB structure
4515 #define SLI1_SLIM_SIZE (4 * 1024)
4516
4517 /* Up to 498 IOCBs will fit into 16k
4518 - * 256 (MAILBOX_t) + 140 (PCB_t) + ( 32 (IOCB_t) * 498 ) = < 16384
4519 + * 256 (MAILBOX_t) + 512 mailbox extension +
4520 + * 140 (PCB_t) + ( 32 (IOCB_t) * 498 ) = < 16384
4521 */
4522 #define SLI2_SLIM_SIZE (64 * 1024)
4523
4524 /* Maximum IOCBs that will fit in SLI2 slim */
4525 #define MAX_SLI2_IOCB 498
4526 #define MAX_SLIM_IOCB_SIZE (SLI2_SLIM_SIZE - \
4527 - (sizeof(MAILBOX_t) + sizeof(PCB_t)))
4528 + (sizeof(MAILBOX_t) + sizeof(PCB_t) + \
4529 + sizeof(uint32_t) * MAILBOX_EXT_WSIZE))
4530
4531 /* HBQ entries are 4 words each = 4k */
4532 #define LPFC_TOTAL_HBQ_SIZE (sizeof(struct lpfc_hbq_entry) * \
4533 @@ -3379,6 +3422,7 @@ typedef struct _IOCB { /* IOCB structure
4534
4535 struct lpfc_sli2_slim {
4536 MAILBOX_t mbx;
4537 + uint32_t mbx_ext_words[MAILBOX_EXT_WSIZE];
4538 PCB_t pcb;
4539 IOCB_t IOCBs[MAX_SLIM_IOCB_SIZE];
4540 };
4541 --- a/drivers/scsi/lpfc/lpfc_init.c
4542 +++ b/drivers/scsi/lpfc/lpfc_init.c
4543 @@ -44,7 +44,22 @@
4544 #include "lpfc_crtn.h"
4545 #include "lpfc_vport.h"
4546 #include "lpfc_version.h"
4547 -
4548 +#include "lpfc_auth_access.h"
4549 +#include "lpfc_security.h"
4550 +#include <net/sock.h>
4551 +#include <linux/netlink.h>
4552 +
4553 +/* vendor ID used in SCSI netlink calls */
4554 +#define LPFC_NL_VENDOR_ID (SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX)
4555 +const char *security_work_q_name = "fc_sc_wq";
4556 +extern struct workqueue_struct *security_work_q;
4557 +extern struct list_head fc_security_user_list;
4558 +extern int fc_service_state;
4559 +void lpfc_fc_sc_security_online(struct work_struct *work);
4560 +void lpfc_fc_sc_security_offline(struct work_struct *work);
4561 +int lpfc_fc_queue_security_work(struct lpfc_vport *, struct work_struct *);
4562 +void lpfc_rcv_nl_event(struct notifier_block *, unsigned long , void *);
4563 +#include "lpfc_ioctl.h"
4564 static int lpfc_parse_vpd(struct lpfc_hba *, uint8_t *, int);
4565 static void lpfc_get_hba_model_desc(struct lpfc_hba *, uint8_t *, uint8_t *);
4566 static int lpfc_post_rcv_buf(struct lpfc_hba *);
4567 @@ -54,6 +69,26 @@ static struct scsi_transport_template *l
4568 static DEFINE_IDR(lpfc_hba_index);
4569
4570 /**
4571 + * lpfc_hba_max_vpi - Get the maximum supported VPI for an HBA
4572 + * @device: The PCI device ID for this HBA
4573 + *
4574 + * Description:
4575 + * This routine will return the maximum supported VPI limit for each HBA. In
4576 + * most cases the maximum VPI limit will be 0xFFFF, which indicates that the
4577 + * driver supports whatever the HBA can support. In some cases the driver
4578 + * supports fewer VPI that the HBA supports.
4579 + */
4580 +static inline uint16_t
4581 +lpfc_hba_max_vpi(unsigned short device)
4582 +{
4583 + if ((device == PCI_DEVICE_ID_HELIOS) ||
4584 + (device == PCI_DEVICE_ID_ZEPHYR))
4585 + return LPFC_INTR_VPI;
4586 + else
4587 + return LPFC_MAX_VPI;
4588 +}
4589 +
4590 +/**
4591 * lpfc_config_port_prep: Perform lpfc initialization prior to config port.
4592 * @phba: pointer to lpfc hba data structure.
4593 *
4594 @@ -444,9 +479,20 @@ lpfc_config_port_post(struct lpfc_hba *p
4595 /* Set up error attention (ERATT) polling timer */
4596 mod_timer(&phba->eratt_poll, jiffies + HZ * LPFC_ERATT_POLL_INTERVAL);
4597
4598 + if (vport->cfg_enable_auth) {
4599 + if (lpfc_security_service_state == SECURITY_OFFLINE) {
4600 + lpfc_printf_log(vport->phba, KERN_ERR, LOG_SECURITY,
4601 + "1000 Authentication is enabled but "
4602 + "authentication service is not running\n");
4603 + vport->auth.auth_mode = FC_AUTHMODE_UNKNOWN;
4604 + phba->link_state = LPFC_HBA_ERROR;
4605 + mempool_free(pmb, phba->mbox_mem_pool);
4606 + return 0;
4607 + }
4608 + }
4609 +
4610 lpfc_init_link(phba, pmb, phba->cfg_topology, phba->cfg_link_speed);
4611 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
4612 - lpfc_set_loopback_flag(phba);
4613 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
4614 if (rc != MBX_SUCCESS) {
4615 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4616 @@ -886,8 +932,7 @@ lpfc_handle_eratt(struct lpfc_hba *phba)
4617 fc_host_post_vendor_event(shost, fc_get_event_number(),
4618 sizeof(temp_event_data),
4619 (char *) &temp_event_data,
4620 - SCSI_NL_VID_TYPE_PCI
4621 - | PCI_VENDOR_ID_EMULEX);
4622 + LPFC_NL_VENDOR_ID);
4623
4624 spin_lock_irq(&phba->hbalock);
4625 phba->over_temp_state = HBA_OVER_TEMP;
4626 @@ -909,7 +954,7 @@ lpfc_handle_eratt(struct lpfc_hba *phba)
4627 shost = lpfc_shost_from_vport(vport);
4628 fc_host_post_vendor_event(shost, fc_get_event_number(),
4629 sizeof(event_data), (char *) &event_data,
4630 - SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
4631 + LPFC_NL_VENDOR_ID);
4632
4633 lpfc_offline_eratt(phba);
4634 }
4635 @@ -1675,8 +1720,15 @@ lpfc_cleanup(struct lpfc_vport *vport)
4636 void
4637 lpfc_stop_vport_timers(struct lpfc_vport *vport)
4638 {
4639 + struct fc_security_request *fc_sc_req;
4640 del_timer_sync(&vport->els_tmofunc);
4641 del_timer_sync(&vport->fc_fdmitmo);
4642 + while (!list_empty(&vport->sc_response_wait_queue)) {
4643 + fc_sc_req = list_get_first(&vport->sc_response_wait_queue,
4644 + struct fc_security_request, rlist);
4645 + del_timer_sync(&fc_sc_req->timer);
4646 + kfree(fc_sc_req);
4647 + }
4648 lpfc_can_disctmo(vport);
4649 return;
4650 }
4651 @@ -1963,12 +2015,7 @@ lpfc_create_port(struct lpfc_hba *phba,
4652 struct Scsi_Host *shost;
4653 int error = 0;
4654
4655 - if (dev != &phba->pcidev->dev)
4656 - shost = scsi_host_alloc(&lpfc_vport_template,
4657 - sizeof(struct lpfc_vport));
4658 - else
4659 - shost = scsi_host_alloc(&lpfc_template,
4660 - sizeof(struct lpfc_vport));
4661 + shost = scsi_host_alloc(&lpfc_template, sizeof(struct lpfc_vport));
4662 if (!shost)
4663 goto out;
4664
4665 @@ -2017,6 +2064,15 @@ lpfc_create_port(struct lpfc_hba *phba,
4666 error = scsi_add_host(shost, dev);
4667 if (error)
4668 goto out_put_shost;
4669 + vport->auth.challenge = NULL;
4670 + vport->auth.challenge_len = 0;
4671 + vport->auth.dh_pub_key = NULL;
4672 + vport->auth.dh_pub_key_len = 0;
4673 +
4674 + INIT_WORK(&vport->sc_online_work, lpfc_fc_sc_security_online);
4675 + INIT_WORK(&vport->sc_offline_work, lpfc_fc_sc_security_offline);
4676 + INIT_LIST_HEAD(&vport->sc_users);
4677 + INIT_LIST_HEAD(&vport->sc_response_wait_queue);
4678
4679 spin_lock_irq(&phba->hbalock);
4680 list_add_tail(&vport->listentry, &phba->port_list);
4681 @@ -2387,7 +2443,7 @@ lpfc_pci_probe_one(struct pci_dev *pdev,
4682 * establish the host.
4683 */
4684 lpfc_get_cfgparam(phba);
4685 - phba->max_vpi = LPFC_MAX_VPI;
4686 + phba->max_vpi = lpfc_hba_max_vpi(phba->pcidev->device);
4687
4688 /* Initialize timers used by driver */
4689 init_timer(&phba->hb_tmofunc);
4690 @@ -2453,6 +2509,8 @@ lpfc_pci_probe_one(struct pci_dev *pdev,
4691
4692 memset(phba->slim2p.virt, 0, SLI2_SLIM_SIZE);
4693 phba->mbox = phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, mbx);
4694 + phba->mbox_ext = (phba->slim2p.virt +
4695 + offsetof(struct lpfc_sli2_slim, mbx_ext_words));
4696 phba->pcb = (phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, pcb));
4697 phba->IOCBs = (phba->slim2p.virt +
4698 offsetof(struct lpfc_sli2_slim, IOCBs));
4699 @@ -2548,11 +2606,30 @@ lpfc_pci_probe_one(struct pci_dev *pdev,
4700 /* Initialize list to save ELS buffers */
4701 INIT_LIST_HEAD(&phba->elsbuf);
4702
4703 + /* Initialize list of sysfs mailbox commands */
4704 + INIT_LIST_HEAD(&phba->sysfs_mbox_list);
4705 + /* Initialize list of sysfs menlo commands */
4706 + INIT_LIST_HEAD(&phba->sysfs_menlo_list);
4707 +
4708 vport = lpfc_create_port(phba, phba->brd_no, &phba->pcidev->dev);
4709 if (!vport)
4710 goto out_kthread_stop;
4711
4712 shost = lpfc_shost_from_vport(vport);
4713 +
4714 + if ((lpfc_get_security_enabled)(shost)) {
4715 + unsigned long flags;
4716 + /* Triggers fcauthd to register if it is running */
4717 + fc_host_post_event(shost, fc_get_event_number(),
4718 + FCH_EVT_PORT_ONLINE, shost->host_no);
4719 + spin_lock_irqsave(&fc_security_user_lock, flags);
4720 + list_add_tail(&vport->sc_users, &fc_security_user_list);
4721 + spin_unlock_irqrestore(&fc_security_user_lock, flags);
4722 + if (fc_service_state == FC_SC_SERVICESTATE_ONLINE) {
4723 + lpfc_fc_queue_security_work(vport,
4724 + &vport->sc_online_work);
4725 + }
4726 + }
4727 phba->pport = vport;
4728 lpfc_debugfs_initialize(vport);
4729
4730 @@ -2610,6 +2687,14 @@ lpfc_pci_probe_one(struct pci_dev *pdev,
4731 phba->intr_type = INTx;
4732 }
4733
4734 + phba->dfc_host = lpfcdfc_host_add(pdev, shost, phba);
4735 + if (!phba->dfc_host) {
4736 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
4737 + "1201 Failed to allocate dfc_host \n");
4738 + error = -ENOMEM;
4739 + goto out_free_irq;
4740 + }
4741 +
4742 if (lpfc_alloc_sysfs_attr(vport)) {
4743 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4744 "1476 Failed to allocate sysfs attr\n");
4745 @@ -2658,6 +2743,8 @@ out_remove_device:
4746 vport->load_flag |= FC_UNLOADING;
4747 spin_unlock_irq(shost->host_lock);
4748 out_free_irq:
4749 + if (phba->dfc_host)
4750 + lpfcdfc_host_del(phba->dfc_host);
4751 lpfc_stop_phba_timers(phba);
4752 phba->pport->work_port_events = 0;
4753
4754 @@ -2720,6 +2807,12 @@ lpfc_pci_remove_one(struct pci_dev *pdev
4755 struct lpfc_hba *phba = vport->phba;
4756 int bars = pci_select_bars(pdev, IORESOURCE_MEM);
4757
4758 + /* In case PCI channel permanently disabled, rescan SCSI devices */
4759 + if (pdev->error_state == pci_channel_io_perm_failure)
4760 + lpfc_scsi_dev_rescan(phba);
4761 + lpfcdfc_host_del(phba->dfc_host);
4762 + phba->dfc_host = NULL;
4763 +
4764 spin_lock_irq(&phba->hbalock);
4765 vport->load_flag |= FC_UNLOADING;
4766 spin_unlock_irq(&phba->hbalock);
4767 @@ -3076,12 +3169,34 @@ lpfc_init(void)
4768 return -ENOMEM;
4769 }
4770 }
4771 + error = scsi_nl_add_driver(LPFC_NL_VENDOR_ID, &lpfc_template,
4772 + lpfc_rcv_nl_msg, lpfc_rcv_nl_event);
4773 + if (error)
4774 + goto out_release_transport;
4775 + security_work_q = create_singlethread_workqueue(security_work_q_name);
4776 + if (!security_work_q)
4777 + goto out_nl_remove_driver;
4778 + INIT_LIST_HEAD(&fc_security_user_list);
4779 error = pci_register_driver(&lpfc_driver);
4780 - if (error) {
4781 - fc_release_transport(lpfc_transport_template);
4782 - if (lpfc_enable_npiv)
4783 - fc_release_transport(lpfc_vport_transport_template);
4784 - }
4785 + if (error)
4786 + goto out_destroy_workqueue;
4787 + error = lpfc_cdev_init();
4788 + if (error)
4789 + goto out_pci_unregister;
4790 +
4791 + return error;
4792 +
4793 +out_pci_unregister:
4794 + pci_unregister_driver(&lpfc_driver);
4795 +out_destroy_workqueue:
4796 + destroy_workqueue(security_work_q);
4797 + security_work_q = NULL;
4798 +out_nl_remove_driver:
4799 + scsi_nl_remove_driver(LPFC_NL_VENDOR_ID);
4800 +out_release_transport:
4801 + fc_release_transport(lpfc_transport_template);
4802 + if (lpfc_enable_npiv)
4803 + fc_release_transport(lpfc_vport_transport_template);
4804
4805 return error;
4806 }
4807 @@ -3097,9 +3212,14 @@ static void __exit
4808 lpfc_exit(void)
4809 {
4810 pci_unregister_driver(&lpfc_driver);
4811 + if (security_work_q)
4812 + destroy_workqueue(security_work_q);
4813 + security_work_q = NULL;
4814 + scsi_nl_remove_driver(LPFC_NL_VENDOR_ID);
4815 fc_release_transport(lpfc_transport_template);
4816 if (lpfc_enable_npiv)
4817 fc_release_transport(lpfc_vport_transport_template);
4818 + lpfc_cdev_exit();
4819 }
4820
4821 module_init(lpfc_init);
4822 --- /dev/null
4823 +++ b/drivers/scsi/lpfc/lpfc_ioctl.c
4824 @@ -0,0 +1,2519 @@
4825 +/*******************************************************************
4826 + * This file is part of the Emulex Linux Device Driver for *
4827 + * Fibre Channel Host Bus Adapters. *
4828 + * Copyright (C) 2006-2008 Emulex. All rights reserved. *
4829 + * EMULEX and SLI are trademarks of Emulex. *
4830 + * www.emulex.com *
4831 + * *
4832 + * This program is free software; you can redistribute it and/or *
4833 + * modify it under the terms of version 2 of the GNU General *
4834 + * Public License as published by the Free Software Foundation. *
4835 + * This program is distributed in the hope that it will be useful. *
4836 + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
4837 + * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
4838 + * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
4839 + * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
4840 + * TO BE LEGALLY INVALID. See the GNU General Public License for *
4841 + * more details, a copy of which can be found in the file COPYING *
4842 + * included with this package. *
4843 + *******************************************************************/
4844 +
4845 +#include <linux/delay.h>
4846 +#include <linux/blkdev.h>
4847 +#include <linux/interrupt.h>
4848 +#include <linux/pci.h>
4849 +
4850 +#include <scsi/scsi_host.h>
4851 +#include <scsi/scsi_transport_fc.h>
4852 +
4853 +#include "lpfc_hw.h"
4854 +#include "lpfc_sli.h"
4855 +#include "lpfc_nl.h"
4856 +#include "lpfc_disc.h"
4857 +#include "lpfc_scsi.h"
4858 +#include "lpfc.h"
4859 +#include "lpfc_crtn.h"
4860 +#include "lpfc_ioctl.h"
4861 +#include "lpfc_logmsg.h"
4862 +#include "lpfc_vport.h"
4863 +
4864 +
4865 +struct lpfcdfc_event {
4866 + struct list_head node;
4867 + int ref;
4868 + wait_queue_head_t wq;
4869 +
4870 + /* Event type and waiter identifiers */
4871 + uint32_t type_mask;
4872 + uint32_t req_id;
4873 + uint32_t reg_id;
4874 +
4875 + /* next two flags are here for the auto-delete logic */
4876 + unsigned long wait_time_stamp;
4877 + int waiting;
4878 +
4879 + /* seen and not seen events */
4880 + struct list_head events_to_get;
4881 + struct list_head events_to_see;
4882 +};
4883 +
4884 +struct event_data {
4885 + struct list_head node;
4886 + uint32_t type;
4887 + uint32_t immed_dat;
4888 + void * data;
4889 + uint32_t len;
4890 +};
4891 +
4892 +
4893 +/* values for a_topology */
4894 +#define LNK_LOOP 0x1
4895 +#define LNK_PUBLIC_LOOP 0x2
4896 +#define LNK_FABRIC 0x3
4897 +#define LNK_PT2PT 0x4
4898 +
4899 +/* values for a_linkState */
4900 +#define LNK_DOWN 0x1
4901 +#define LNK_UP 0x2
4902 +#define LNK_FLOGI 0x3
4903 +#define LNK_DISCOVERY 0x4
4904 +#define LNK_REDISCOVERY 0x5
4905 +#define LNK_READY 0x6
4906 +
4907 +struct lpfcdfc_host {
4908 + struct list_head node;
4909 + int inst;
4910 + struct lpfc_hba * phba;
4911 + struct lpfc_vport *vport;
4912 + struct Scsi_Host * host;
4913 + struct pci_dev * dev;
4914 + void (*base_ct_unsol_event)(struct lpfc_hba *,
4915 + struct lpfc_sli_ring *,
4916 + struct lpfc_iocbq *);
4917 + /* Threads waiting for async event */
4918 + struct list_head ev_waiters;
4919 + uint32_t blocked;
4920 + uint32_t ref_count;
4921 +};
4922 +
4923 +
4924 +
4925 +
4926 +static void lpfc_ioctl_timeout_iocb_cmpl(struct lpfc_hba *,
4927 + struct lpfc_iocbq *, struct lpfc_iocbq *);
4928 +
4929 +static struct lpfc_dmabufext *
4930 +dfc_cmd_data_alloc(struct lpfc_hba *, char *,
4931 + struct ulp_bde64 *, uint32_t);
4932 +static int dfc_cmd_data_free(struct lpfc_hba *, struct lpfc_dmabufext *);
4933 +static int dfc_rsp_data_copy(struct lpfc_hba *, uint8_t *,
4934 + struct lpfc_dmabufext *,
4935 + uint32_t);
4936 +static int lpfc_issue_ct_rsp(struct lpfc_hba *, uint32_t, struct lpfc_dmabuf *,
4937 + struct lpfc_dmabufext *);
4938 +
4939 +static struct lpfcdfc_host * lpfcdfc_host_from_hba(struct lpfc_hba *);
4940 +
4941 +static DEFINE_MUTEX(lpfcdfc_lock);
4942 +
4943 +static struct list_head lpfcdfc_hosts = LIST_HEAD_INIT(lpfcdfc_hosts);
4944 +
4945 +static int lpfcdfc_major = 0;
4946 +
4947 +static int
4948 +lpfc_ioctl_hba_rnid(struct lpfc_hba * phba,
4949 + struct lpfcCmdInput * cip,
4950 + void *dataout)
4951 +{
4952 + struct nport_id idn;
4953 + struct lpfc_sli *psli;
4954 + struct lpfc_iocbq *cmdiocbq = NULL;
4955 + struct lpfc_iocbq *rspiocbq = NULL;
4956 + RNID *prsp;
4957 + uint32_t *pcmd;
4958 + uint32_t *psta;
4959 + IOCB_t *rsp;
4960 + struct lpfc_sli_ring *pring;
4961 + void *context2;
4962 + int i0;
4963 + int rtnbfrsiz;
4964 + struct lpfc_nodelist *pndl;
4965 + int rc = 0;
4966 +
4967 + psli = &phba->sli;
4968 + pring = &psli->ring[LPFC_ELS_RING];
4969 +
4970 + if (copy_from_user((uint8_t *) &idn, (void __user *) cip->lpfc_arg1,
4971 + sizeof(struct nport_id))) {
4972 + rc = EIO;
4973 + return rc;
4974 + }
4975 +
4976 + if (idn.idType == LPFC_WWNN_TYPE)
4977 + pndl = lpfc_findnode_wwnn(phba->pport,
4978 + (struct lpfc_name *) idn.wwpn);
4979 + else
4980 + pndl = lpfc_findnode_wwpn(phba->pport,
4981 + (struct lpfc_name *) idn.wwpn);
4982 +
4983 + if (!pndl || !NLP_CHK_NODE_ACT(pndl))
4984 + return ENODEV;
4985 +
4986 + for (i0 = 0;
4987 + i0 < 10 && (pndl->nlp_flag & NLP_ELS_SND_MASK) == NLP_RNID_SND;
4988 + i0++) {
4989 + mdelay(1000);
4990 + }
4991 +
4992 + if (i0 == 10) {
4993 + pndl->nlp_flag &= ~NLP_RNID_SND;
4994 + return EBUSY;
4995 + }
4996 +
4997 + cmdiocbq = lpfc_prep_els_iocb(phba->pport, 1, (2 * sizeof(uint32_t)), 0,
4998 + pndl, pndl->nlp_DID, ELS_CMD_RNID);
4999 + if (!cmdiocbq)
5000 + return ENOMEM;
5001 +
5002 + /*
5003 + * Context2 is used by prep/free to locate cmd and rsp buffers,
5004 + * but context2 is also used by iocb_wait to hold a rspiocb ptr.
5005 + * The rsp iocbq can be returned from the completion routine for
5006 + * iocb_wait, so save the prep/free value locally . It will be
5007 + * restored after returning from iocb_wait.
5008 + */
5009 + context2 = cmdiocbq->context2;
5010 +
5011 + if ((rspiocbq = lpfc_sli_get_iocbq(phba)) == NULL) {
5012 + rc = ENOMEM;
5013 + goto sndrndqwt;
5014 + }
5015 + rsp = &(rspiocbq->iocb);
5016 +
5017 + pcmd = (uint32_t *) (((struct lpfc_dmabuf *) cmdiocbq->context2)->virt);
5018 + *pcmd++ = ELS_CMD_RNID;
5019 +
5020 + memset((void *) pcmd, 0, sizeof (RNID));
5021 + ((RNID *) pcmd)->Format = 0;
5022 + ((RNID *) pcmd)->Format = RNID_TOPOLOGY_DISC;
5023 + cmdiocbq->context1 = NULL;
5024 + cmdiocbq->context2 = NULL;
5025 + cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
5026 +
5027 + pndl->nlp_flag |= NLP_RNID_SND;
5028 + cmdiocbq->iocb.ulpTimeout = (phba->fc_ratov * 2) + 3 ;
5029 +
5030 + rc = lpfc_sli_issue_iocb_wait(phba, pring, cmdiocbq, rspiocbq,
5031 + (phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT);
5032 + pndl->nlp_flag &= ~NLP_RNID_SND;
5033 + cmdiocbq->context2 = context2;
5034 +
5035 + if (rc == IOCB_TIMEDOUT) {
5036 + lpfc_sli_release_iocbq(phba, rspiocbq);
5037 + cmdiocbq->context1 = NULL;
5038 + cmdiocbq->iocb_cmpl = lpfc_ioctl_timeout_iocb_cmpl;
5039 + return EIO;
5040 + }
5041 +
5042 + if (rc != IOCB_SUCCESS) {
5043 + rc = EIO;
5044 + goto sndrndqwt;
5045 + }
5046 +
5047 + if (rsp->ulpStatus == IOSTAT_SUCCESS) {
5048 + struct lpfc_dmabuf *buf_ptr1, *buf_ptr;
5049 + buf_ptr1 = (struct lpfc_dmabuf *)(cmdiocbq->context2);
5050 + buf_ptr = list_entry(buf_ptr1->list.next, struct lpfc_dmabuf,
5051 + list);
5052 + psta = (uint32_t*)buf_ptr->virt;
5053 + prsp = (RNID *) (psta + 1); /* then rnid response data */
5054 + rtnbfrsiz = prsp->CommonLen + prsp->SpecificLen +
5055 + sizeof (uint32_t);
5056 + memcpy((uint8_t *) dataout, (uint8_t *) psta, rtnbfrsiz);
5057 +
5058 + if (rtnbfrsiz > cip->lpfc_outsz)
5059 + rtnbfrsiz = cip->lpfc_outsz;
5060 + if (copy_to_user
5061 + ((void __user *) cip->lpfc_arg2, (uint8_t *) & rtnbfrsiz,
5062 + sizeof (int)))
5063 + rc = EIO;
5064 + } else if (rsp->ulpStatus == IOSTAT_LS_RJT) {
5065 + uint8_t ls_rjt[8];
5066 + uint32_t *ls_rjtrsp;
5067 +
5068 + ls_rjtrsp = (uint32_t*)(ls_rjt + 4);
5069 +
5070 + /* construct the LS_RJT payload */
5071 + ls_rjt[0] = 0x01;
5072 + ls_rjt[1] = 0x00;
5073 + ls_rjt[2] = 0x00;
5074 + ls_rjt[3] = 0x00;
5075 +
5076 + *ls_rjtrsp = be32_to_cpu(rspiocbq->iocb.un.ulpWord[4]);
5077 + rtnbfrsiz = 8;
5078 + memcpy((uint8_t *) dataout, (uint8_t *) ls_rjt, rtnbfrsiz);
5079 + if (copy_to_user
5080 + ((void __user *) cip->lpfc_arg2, (uint8_t *) & rtnbfrsiz,
5081 + sizeof (int)))
5082 + rc = EIO;
5083 + } else
5084 + rc = EACCES;
5085 +
5086 +sndrndqwt:
5087 + if (cmdiocbq)
5088 + lpfc_els_free_iocb(phba, cmdiocbq);
5089 +
5090 + if (rspiocbq)
5091 + lpfc_sli_release_iocbq(phba, rspiocbq);
5092 +
5093 + return rc;
5094 +}
5095 +
5096 +static void
5097 +lpfc_ioctl_timeout_iocb_cmpl(struct lpfc_hba * phba,
5098 + struct lpfc_iocbq * cmd_iocb_q,
5099 + struct lpfc_iocbq * rsp_iocb_q)
5100 +{
5101 + struct lpfc_timedout_iocb_ctxt *iocb_ctxt = cmd_iocb_q->context1;
5102 +
5103 + if (!iocb_ctxt) {
5104 + if (cmd_iocb_q->context2)
5105 + lpfc_els_free_iocb(phba, cmd_iocb_q);
5106 + else
5107 + lpfc_sli_release_iocbq(phba,cmd_iocb_q);
5108 + return;
5109 + }
5110 +
5111 + if (iocb_ctxt->outdmp)
5112 + dfc_cmd_data_free(phba, iocb_ctxt->outdmp);
5113 +
5114 + if (iocb_ctxt->indmp)
5115 + dfc_cmd_data_free(phba, iocb_ctxt->indmp);
5116 +
5117 + if (iocb_ctxt->mp) {
5118 + lpfc_mbuf_free(phba,
5119 + iocb_ctxt->mp->virt,
5120 + iocb_ctxt->mp->phys);
5121 + kfree(iocb_ctxt->mp);
5122 + }
5123 +
5124 + if (iocb_ctxt->bmp) {
5125 + lpfc_mbuf_free(phba,
5126 + iocb_ctxt->bmp->virt,
5127 + iocb_ctxt->bmp->phys);
5128 + kfree(iocb_ctxt->bmp);
5129 + }
5130 +
5131 + lpfc_sli_release_iocbq(phba,cmd_iocb_q);
5132 +
5133 + if (iocb_ctxt->rspiocbq)
5134 + lpfc_sli_release_iocbq(phba, iocb_ctxt->rspiocbq);
5135 +
5136 + kfree(iocb_ctxt);
5137 +}
5138 +
5139 +
5140 +static int
5141 +lpfc_ioctl_send_els(struct lpfc_hba * phba,
5142 + struct lpfcCmdInput * cip, void *dataout)
5143 +{
5144 + struct lpfc_sli *psli = &phba->sli;
5145 + struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
5146 + struct lpfc_iocbq *cmdiocbq, *rspiocbq;
5147 + struct lpfc_dmabufext *pcmdext = NULL, *prspext = NULL;
5148 + struct lpfc_nodelist *pndl;
5149 + struct ulp_bde64 *bpl;
5150 + IOCB_t *rsp;
5151 + struct lpfc_dmabuf *pcmd, *prsp, *pbuflist = NULL;
5152 + uint16_t rpi = 0;
5153 + struct nport_id destID;
5154 + int rc = 0;
5155 + uint32_t cmdsize;
5156 + uint32_t rspsize;
5157 + uint32_t elscmd;
5158 + int iocb_status;
5159 +
5160 + elscmd = *(uint32_t *)cip->lpfc_arg2;
5161 + cmdsize = cip->lpfc_arg4;
5162 + rspsize = cip->lpfc_outsz;
5163 +
5164 + if (copy_from_user((uint8_t *)&destID, (void __user *)cip->lpfc_arg1,
5165 + sizeof(struct nport_id)))
5166 + return EIO;
5167 +
5168 + if ((rspiocbq = lpfc_sli_get_iocbq(phba)) == NULL)
5169 + return ENOMEM;
5170 +
5171 + rsp = &rspiocbq->iocb;
5172 +
5173 + if (destID.idType == 0)
5174 + pndl = lpfc_findnode_wwpn(phba->pport,
5175 + (struct lpfc_name *)&destID.wwpn);
5176 + else {
5177 + destID.d_id = (destID.d_id & Mask_DID);
5178 + pndl = lpfc_findnode_did(phba->pport, destID.d_id);
5179 + }
5180 +
5181 + if (!pndl || !NLP_CHK_NODE_ACT(pndl)) {
5182 + if (destID.idType == 0) {
5183 + lpfc_sli_release_iocbq(phba, rspiocbq);
5184 + return ENODEV;
5185 + }
5186 + if (!pndl) {
5187 + pndl = kmalloc(sizeof (struct lpfc_nodelist),
5188 + GFP_KERNEL);
5189 + if (!pndl) {
5190 + lpfc_sli_release_iocbq(phba, rspiocbq);
5191 + return ENODEV;
5192 + }
5193 + lpfc_nlp_init(phba->pport, pndl, destID.d_id);
5194 + lpfc_nlp_set_state(phba->pport, pndl, NLP_STE_NPR_NODE);
5195 + } else {
5196 + pndl = lpfc_enable_node(phba->pport, pndl,
5197 + NLP_STE_NPR_NODE);
5198 + if (!pndl) {
5199 + lpfc_sli_release_iocbq(phba, rspiocbq);
5200 + return ENODEV;
5201 + }
5202 + }
5203 + } else {
5204 + lpfc_nlp_get(pndl);
5205 + rpi = pndl->nlp_rpi;
5206 + }
5207 +
5208 + cmdiocbq = lpfc_prep_els_iocb(phba->pport, 1, cmdsize, 0, pndl,
5209 + pndl->nlp_DID, elscmd);
5210 +
5211 + /* release the new pndl once the iocb complete */
5212 + lpfc_nlp_put(pndl);
5213 +
5214 + if (cmdiocbq == NULL) {
5215 + lpfc_sli_release_iocbq(phba, rspiocbq);
5216 + return EIO;
5217 + }
5218 +
5219 + pcmd = (struct lpfc_dmabuf *) cmdiocbq->context2;
5220 + prsp = (struct lpfc_dmabuf *) pcmd->list.next;
5221 +
5222 + /*
5223 + * If we exceed the size of the allocated mbufs we need to
5224 + * free them and allocate our own.
5225 + */
5226 + if ((cmdsize > LPFC_BPL_SIZE) || (rspsize > LPFC_BPL_SIZE)) {
5227 + lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
5228 + kfree(pcmd);
5229 + lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
5230 + kfree(prsp);
5231 + cmdiocbq->context2 = NULL;
5232 +
5233 + pbuflist = (struct lpfc_dmabuf *) cmdiocbq->context3;
5234 + bpl = (struct ulp_bde64 *) pbuflist->virt;
5235 + pcmdext = dfc_cmd_data_alloc(phba, cip->lpfc_arg2,
5236 + bpl, cmdsize);
5237 + if (!pcmdext) {
5238 + lpfc_els_free_iocb(phba, cmdiocbq);
5239 + lpfc_sli_release_iocbq(phba, rspiocbq);
5240 + return ENOMEM;
5241 + }
5242 + bpl += pcmdext->flag;
5243 + prspext = dfc_cmd_data_alloc(phba, NULL, bpl, rspsize);
5244 + if (!prspext) {
5245 + dfc_cmd_data_free(phba, pcmdext);
5246 + lpfc_els_free_iocb(phba, cmdiocbq);
5247 + lpfc_sli_release_iocbq(phba, rspiocbq);
5248 + return ENOMEM;
5249 + }
5250 + } else {
5251 + /* Copy the command from user space */
5252 + if (copy_from_user((uint8_t *) pcmd->virt,
5253 + (void __user *) cip->lpfc_arg2,
5254 + cmdsize)) {
5255 + lpfc_els_free_iocb(phba, cmdiocbq);
5256 + lpfc_sli_release_iocbq(phba, rspiocbq);
5257 + return EIO;
5258 + }
5259 + }
5260 +
5261 + cmdiocbq->iocb.ulpContext = rpi;
5262 + cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
5263 + cmdiocbq->context1 = NULL;
5264 + cmdiocbq->context2 = NULL;
5265 +
5266 + iocb_status = lpfc_sli_issue_iocb_wait(phba, pring, cmdiocbq, rspiocbq,
5267 + (phba->fc_ratov*2) + LPFC_DRVR_TIMEOUT);
5268 + rc = iocb_status;
5269 +
5270 + if (rc == IOCB_SUCCESS) {
5271 + if (rsp->ulpStatus == IOSTAT_SUCCESS) {
5272 + if (rspsize < (rsp->un.ulpWord[0] & 0xffffff)) {
5273 + rc = ERANGE;
5274 + } else {
5275 + rspsize = rsp->un.ulpWord[0] & 0xffffff;
5276 + if (pbuflist) {
5277 + if (dfc_rsp_data_copy(
5278 + phba,
5279 + (uint8_t *) cip->lpfc_dataout,
5280 + prspext,
5281 + rspsize)) {
5282 + rc = EIO;
5283 + } else {
5284 + cip->lpfc_outsz = 0;
5285 + }
5286 + } else {
5287 + if (copy_to_user( (void __user *)
5288 + cip->lpfc_dataout,
5289 + (uint8_t *) prsp->virt,
5290 + rspsize)) {
5291 + rc = EIO;
5292 + } else {
5293 + cip->lpfc_outsz = 0;
5294 + }
5295 + }
5296 + }
5297 + } else if (rsp->ulpStatus == IOSTAT_LS_RJT) {
5298 + uint8_t ls_rjt[8];
5299 +
5300 + /* construct the LS_RJT payload */
5301 + ls_rjt[0] = 0x01;
5302 + ls_rjt[1] = 0x00;
5303 + ls_rjt[2] = 0x00;
5304 + ls_rjt[3] = 0x00;
5305 + memcpy(&ls_rjt[4], (uint8_t *) &rsp->un.ulpWord[4],
5306 + sizeof(uint32_t));
5307 +
5308 + if (rspsize < 8)
5309 + rc = ERANGE;
5310 + else
5311 + rspsize = 8;
5312 +
5313 + memcpy(dataout, ls_rjt, rspsize);
5314 + } else
5315 + rc = EIO;
5316 +
5317 + if (copy_to_user((void __user *)cip->lpfc_arg3,
5318 + (uint8_t *)&rspsize, sizeof(uint32_t)))
5319 + rc = EIO;
5320 + } else {
5321 + rc = EIO;
5322 + }
5323 +
5324 + if (pbuflist) {
5325 + dfc_cmd_data_free(phba, pcmdext);
5326 + dfc_cmd_data_free(phba, prspext);
5327 + } else
5328 + cmdiocbq->context2 = (uint8_t *) pcmd;
5329 +
5330 + if (iocb_status != IOCB_TIMEDOUT)
5331 + lpfc_els_free_iocb(phba, cmdiocbq);
5332 +
5333 + lpfc_sli_release_iocbq(phba, rspiocbq);
5334 + return rc;
5335 +}
5336 +
5337 +static int
5338 +lpfc_ioctl_send_mgmt_rsp(struct lpfc_hba * phba,
5339 + struct lpfcCmdInput * cip)
5340 +{
5341 + struct Scsi_Host *shost = lpfc_shost_from_vport(phba->pport);
5342 + struct ulp_bde64 *bpl;
5343 + struct lpfc_dmabuf *bmp = NULL;
5344 + struct lpfc_dmabufext *indmp = NULL;
5345 + uint32_t tag = (uint32_t)cip->lpfc_flag; /* XRI for XMIT_SEQUENCE */
5346 + unsigned long reqbfrcnt = (unsigned long)cip->lpfc_arg2;
5347 + int rc = 0;
5348 + unsigned long iflag;
5349 +
5350 + if (!reqbfrcnt || (reqbfrcnt > (80 * BUF_SZ_4K))) {
5351 + rc = ERANGE;
5352 + return rc;
5353 + }
5354 +
5355 + bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
5356 + if (!bmp) {
5357 + rc = ENOMEM;
5358 + goto send_mgmt_rsp_exit;
5359 + }
5360 + spin_lock_irqsave(shost->host_lock, iflag);
5361 + bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
5362 + spin_unlock_irqrestore(shost->host_lock, iflag); /* remove */
5363 + if (!bmp->virt) {
5364 + rc = ENOMEM;
5365 + goto send_mgmt_rsp_free_bmp;
5366 + }
5367 +
5368 + INIT_LIST_HEAD(&bmp->list);
5369 + bpl = (struct ulp_bde64 *) bmp->virt;
5370 +
5371 + indmp = dfc_cmd_data_alloc(phba, cip->lpfc_arg1, bpl, reqbfrcnt);
5372 + if (!indmp) {
5373 + rc = ENOMEM;
5374 + goto send_mgmt_rsp_free_bmpvirt;
5375 + }
5376 + rc = lpfc_issue_ct_rsp(phba, tag, bmp, indmp);
5377 + if (rc) {
5378 + if (rc == IOCB_TIMEDOUT)
5379 + rc = ETIMEDOUT;
5380 + else if (rc == IOCB_ERROR)
5381 + rc = EACCES;
5382 + }
5383 +
5384 + dfc_cmd_data_free(phba, indmp);
5385 +send_mgmt_rsp_free_bmpvirt:
5386 + lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
5387 +send_mgmt_rsp_free_bmp:
5388 + kfree(bmp);
5389 +send_mgmt_rsp_exit:
5390 + return rc;
5391 +}
5392 +
5393 +static int
5394 +lpfc_ioctl_send_mgmt_cmd(struct lpfc_hba * phba,
5395 + struct lpfcCmdInput * cip, void *dataout)
5396 +{
5397 + struct Scsi_Host *shost = lpfc_shost_from_vport(phba->pport);
5398 + struct lpfc_nodelist *pndl = NULL;
5399 + struct ulp_bde64 *bpl = NULL;
5400 + struct lpfc_name findwwn;
5401 + uint32_t finddid, timeout;
5402 + struct lpfc_iocbq *cmdiocbq = NULL, *rspiocbq = NULL;
5403 + struct lpfc_dmabufext *indmp = NULL, *outdmp = NULL;
5404 + IOCB_t *cmd = NULL, *rsp = NULL;
5405 + struct lpfc_dmabuf *bmp = NULL;
5406 + struct lpfc_sli *psli = NULL;
5407 + struct lpfc_sli_ring *pring = NULL;
5408 + int i0 = 0, rc = 0, reqbfrcnt, snsbfrcnt;
5409 + struct lpfc_timedout_iocb_ctxt *iocb_ctxt;
5410 +
5411 + psli = &phba->sli;
5412 + pring = &psli->ring[LPFC_ELS_RING];
5413 +
5414 + if (!(psli->sli_flag & LPFC_SLI2_ACTIVE)) {
5415 + rc = EACCES;
5416 + goto send_mgmt_cmd_exit;
5417 + }
5418 +
5419 + reqbfrcnt = cip->lpfc_arg4;
5420 + snsbfrcnt = cip->lpfc_arg5;
5421 +
5422 + if (!reqbfrcnt || !snsbfrcnt
5423 + || (reqbfrcnt + snsbfrcnt > 80 * BUF_SZ_4K)) {
5424 + rc = ERANGE;
5425 + goto send_mgmt_cmd_exit;
5426 + }
5427 +
5428 + if (phba->pport->port_state != LPFC_VPORT_READY) {
5429 + rc = ENODEV;
5430 + goto send_mgmt_cmd_exit;
5431 + }
5432 +
5433 + if (cip->lpfc_cmd == LPFC_HBA_SEND_MGMT_CMD) {
5434 + rc = copy_from_user(&findwwn, (void __user *)cip->lpfc_arg3,
5435 + sizeof(struct lpfc_name));
5436 + if (rc) {
5437 + rc = EIO;
5438 + goto send_mgmt_cmd_exit;
5439 + }
5440 + pndl = lpfc_findnode_wwpn(phba->pport, &findwwn);
5441 + /* Do additional get to pndl found so that at the end of the
5442 + * function we can do unditional lpfc_nlp_put on it.
5443 + */
5444 + if (pndl && NLP_CHK_NODE_ACT(pndl))
5445 + lpfc_nlp_get(pndl);
5446 + } else {
5447 + finddid = (uint32_t)(unsigned long)cip->lpfc_arg3;
5448 + pndl = lpfc_findnode_did(phba->pport, finddid);
5449 + if (!pndl || !NLP_CHK_NODE_ACT(pndl)) {
5450 + if (phba->pport->fc_flag & FC_FABRIC) {
5451 + if (!pndl) {
5452 + pndl = kmalloc(sizeof
5453 + (struct lpfc_nodelist),
5454 + GFP_KERNEL);
5455 + if (!pndl) {
5456 + rc = ENODEV;
5457 + goto send_mgmt_cmd_exit;
5458 + }
5459 + lpfc_nlp_init(phba->pport, pndl,
5460 + finddid);
5461 + lpfc_nlp_set_state(phba->pport,
5462 + pndl, NLP_STE_PLOGI_ISSUE);
5463 + /* Indicate free ioctl allocated
5464 + * memory for ndlp after it's done
5465 + */
5466 + NLP_SET_FREE_REQ(pndl);
5467 + } else
5468 + lpfc_enable_node(phba->pport,
5469 + pndl, NLP_STE_PLOGI_ISSUE);
5470 +
5471 + if (lpfc_issue_els_plogi(phba->pport,
5472 + pndl->nlp_DID, 0)) {
5473 + rc = ENODEV;
5474 + goto send_mgmt_cmd_free_pndl_exit;
5475 + }
5476 +
5477 + /* Allow the node to complete discovery */
5478 + while (i0++ < 4) {
5479 + if (pndl->nlp_state ==
5480 + NLP_STE_UNMAPPED_NODE)
5481 + break;
5482 + msleep(500);
5483 + }
5484 +
5485 + if (i0 == 4) {
5486 + rc = ENODEV;
5487 + goto send_mgmt_cmd_free_pndl_exit;
5488 + }
5489 + } else {
5490 + rc = ENODEV;
5491 + goto send_mgmt_cmd_exit;
5492 + }
5493 + } else
5494 + /* Do additional get to pndl found so at the end of
5495 + * the function we can do unconditional lpfc_nlp_put.
5496 + */
5497 + lpfc_nlp_get(pndl);
5498 + }
5499 +
5500 + if (!pndl || !NLP_CHK_NODE_ACT(pndl)) {
5501 + rc = ENODEV;
5502 + goto send_mgmt_cmd_exit;
5503 + }
5504 +
5505 + if (pndl->nlp_flag & NLP_ELS_SND_MASK) {
5506 + rc = ENODEV;
5507 + goto send_mgmt_cmd_free_pndl_exit;
5508 + }
5509 +
5510 + spin_lock_irq(shost->host_lock);
5511 + cmdiocbq = lpfc_sli_get_iocbq(phba);
5512 + if (!cmdiocbq) {
5513 + rc = ENOMEM;
5514 + spin_unlock_irq(shost->host_lock);
5515 + goto send_mgmt_cmd_free_pndl_exit;
5516 + }
5517 + cmd = &cmdiocbq->iocb;
5518 +
5519 + rspiocbq = lpfc_sli_get_iocbq(phba);
5520 + if (!rspiocbq) {
5521 + rc = ENOMEM;
5522 + goto send_mgmt_cmd_free_cmdiocbq;
5523 + }
5524 + spin_unlock_irq(shost->host_lock);
5525 +
5526 + rsp = &rspiocbq->iocb;
5527 +
5528 + bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
5529 + if (!bmp) {
5530 + rc = ENOMEM;
5531 + spin_lock_irq(shost->host_lock);
5532 + goto send_mgmt_cmd_free_rspiocbq;
5533 + }
5534 +
5535 + spin_lock_irq(shost->host_lock);
5536 + bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
5537 + if (!bmp->virt) {
5538 + rc = ENOMEM;
5539 + goto send_mgmt_cmd_free_bmp;
5540 + }
5541 + spin_unlock_irq(shost->host_lock);
5542 +
5543 + INIT_LIST_HEAD(&bmp->list);
5544 + bpl = (struct ulp_bde64 *) bmp->virt;
5545 + indmp = dfc_cmd_data_alloc(phba, cip->lpfc_arg1, bpl, reqbfrcnt);
5546 + if (!indmp) {
5547 + rc = ENOMEM;
5548 + spin_lock_irq(shost->host_lock);
5549 + goto send_mgmt_cmd_free_bmpvirt;
5550 + }
5551 +
5552 + /* flag contains total number of BPLs for xmit */
5553 + bpl += indmp->flag;
5554 +
5555 + outdmp = dfc_cmd_data_alloc(phba, NULL, bpl, snsbfrcnt);
5556 + if (!outdmp) {
5557 + rc = ENOMEM;
5558 + spin_lock_irq(shost->host_lock);
5559 + goto send_mgmt_cmd_free_indmp;
5560 + }
5561 +
5562 + cmd->un.genreq64.bdl.ulpIoTag32 = 0;
5563 + cmd->un.genreq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
5564 + cmd->un.genreq64.bdl.addrLow = putPaddrLow(bmp->phys);
5565 + cmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
5566 + cmd->un.genreq64.bdl.bdeSize =
5567 + (outdmp->flag + indmp->flag) * sizeof (struct ulp_bde64);
5568 + cmd->ulpCommand = CMD_GEN_REQUEST64_CR;
5569 + cmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
5570 + cmd->un.genreq64.w5.hcsw.Dfctl = 0;
5571 + cmd->un.genreq64.w5.hcsw.Rctl = FC_UNSOL_CTL;
5572 + cmd->un.genreq64.w5.hcsw.Type = FC_COMMON_TRANSPORT_ULP;
5573 + cmd->ulpBdeCount = 1;
5574 + cmd->ulpLe = 1;
5575 + cmd->ulpClass = CLASS3;
5576 + cmd->ulpContext = pndl->nlp_rpi;
5577 + cmd->ulpOwner = OWN_CHIP;
5578 + cmdiocbq->vport = phba->pport;
5579 + cmdiocbq->context1 = NULL;
5580 + cmdiocbq->context2 = NULL;
5581 + cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
5582 +
5583 + if (cip->lpfc_flag == 0 )
5584 + timeout = phba->fc_ratov * 2 ;
5585 + else
5586 + timeout = cip->lpfc_flag;
5587 +
5588 + cmd->ulpTimeout = timeout;
5589 +
5590 + rc = lpfc_sli_issue_iocb_wait(phba, pring, cmdiocbq, rspiocbq,
5591 + timeout + LPFC_DRVR_TIMEOUT);
5592 +
5593 + if (rc == IOCB_TIMEDOUT) {
5594 + lpfc_sli_release_iocbq(phba, rspiocbq);
5595 + iocb_ctxt = kmalloc(sizeof(struct lpfc_timedout_iocb_ctxt),
5596 + GFP_KERNEL);
5597 + if (!iocb_ctxt) {
5598 + rc = EACCES;
5599 + goto send_mgmt_cmd_free_pndl_exit;
5600 + }
5601 +
5602 + cmdiocbq->context1 = iocb_ctxt;
5603 + cmdiocbq->context2 = NULL;
5604 + iocb_ctxt->rspiocbq = NULL;
5605 + iocb_ctxt->mp = NULL;
5606 + iocb_ctxt->bmp = bmp;
5607 + iocb_ctxt->outdmp = outdmp;
5608 + iocb_ctxt->lpfc_cmd = NULL;
5609 + iocb_ctxt->indmp = indmp;
5610 +
5611 + cmdiocbq->iocb_cmpl = lpfc_ioctl_timeout_iocb_cmpl;
5612 + rc = EACCES;
5613 + goto send_mgmt_cmd_free_pndl_exit;
5614 + }
5615 +
5616 + if (rc != IOCB_SUCCESS) {
5617 + rc = EACCES;
5618 + goto send_mgmt_cmd_free_outdmp;
5619 + }
5620 +
5621 + if (rsp->ulpStatus) {
5622 + if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
5623 + switch (rsp->un.ulpWord[4] & 0xff) {
5624 + case IOERR_SEQUENCE_TIMEOUT:
5625 + rc = ETIMEDOUT;
5626 + break;
5627 + case IOERR_INVALID_RPI:
5628 + rc = EFAULT;
5629 + break;
5630 + default:
5631 + rc = EACCES;
5632 + break;
5633 + }
5634 + goto send_mgmt_cmd_free_outdmp;
5635 + }
5636 + } else
5637 + outdmp->flag = rsp->un.genreq64.bdl.bdeSize;
5638 +
5639 + /* Copy back response data */
5640 + if (outdmp->flag > snsbfrcnt) {
5641 + rc = ERANGE;
5642 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
5643 + "1209 C_CT Request error Data: x%x x%x\n",
5644 + outdmp->flag, BUF_SZ_4K);
5645 + goto send_mgmt_cmd_free_outdmp;
5646 + }
5647 +
5648 + /* copy back size of response, and response itself */
5649 + memcpy(dataout, &outdmp->flag, sizeof (int));
5650 + rc = dfc_rsp_data_copy (phba, cip->lpfc_arg2, outdmp, outdmp->flag);
5651 + if (rc)
5652 + rc = EIO;
5653 +
5654 +send_mgmt_cmd_free_outdmp:
5655 + spin_lock_irq(shost->host_lock);
5656 + dfc_cmd_data_free(phba, outdmp);
5657 +send_mgmt_cmd_free_indmp:
5658 + dfc_cmd_data_free(phba, indmp);
5659 +send_mgmt_cmd_free_bmpvirt:
5660 + lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
5661 +send_mgmt_cmd_free_bmp:
5662 + kfree(bmp);
5663 +send_mgmt_cmd_free_rspiocbq:
5664 + lpfc_sli_release_iocbq(phba, rspiocbq);
5665 +send_mgmt_cmd_free_cmdiocbq:
5666 + lpfc_sli_release_iocbq(phba, cmdiocbq);
5667 + spin_unlock_irq(shost->host_lock);
5668 +send_mgmt_cmd_free_pndl_exit:
5669 + lpfc_nlp_put(pndl);
5670 +send_mgmt_cmd_exit:
5671 + return rc;
5672 +}
5673 +
5674 +static inline struct lpfcdfc_event *
5675 +lpfcdfc_event_new(uint32_t ev_mask,
5676 + int ev_reg_id,
5677 + uint32_t ev_req_id)
5678 +{
5679 + struct lpfcdfc_event * evt = kzalloc(sizeof(*evt), GFP_KERNEL);
5680 + if (evt == NULL)
5681 + return NULL;
5682 +
5683 + INIT_LIST_HEAD(&evt->events_to_get);
5684 + INIT_LIST_HEAD(&evt->events_to_see);
5685 + evt->type_mask = ev_mask;
5686 + evt->req_id = ev_req_id;
5687 + evt->reg_id = ev_reg_id;
5688 + evt->wait_time_stamp = jiffies;
5689 + init_waitqueue_head(&evt->wq);
5690 +
5691 + return evt;
5692 +}
5693 +
5694 +static inline void lpfcdfc_event_free(struct lpfcdfc_event * evt)
5695 +{
5696 + struct event_data * ed;
5697 +
5698 + list_del(&evt->node);
5699 +
5700 + while(!list_empty(&evt->events_to_get)) {
5701 + ed = list_entry(evt->events_to_get.next, typeof(*ed), node);
5702 + list_del(&ed->node);
5703 + kfree(ed->data);
5704 + kfree(ed);
5705 + }
5706 +
5707 + while(!list_empty(&evt->events_to_see)) {
5708 + ed = list_entry(evt->events_to_see.next, typeof(*ed), node);
5709 + list_del(&ed->node);
5710 + kfree(ed->data);
5711 + kfree(ed);
5712 + }
5713 +
5714 + kfree(evt);
5715 +}
5716 +
5717 +#define lpfcdfc_event_ref(evt) evt->ref++
5718 +
5719 +#define lpfcdfc_event_unref(evt) \
5720 + if (--evt->ref < 0) \
5721 + lpfcdfc_event_free(evt);
5722 +
5723 +static int
5724 +lpfc_ioctl_hba_get_event(struct lpfc_hba * phba,
5725 + struct lpfcCmdInput * cip,
5726 + void **dataout, int *data_size)
5727 +{
5728 + uint32_t ev_mask = ((uint32_t)(unsigned long)cip->lpfc_arg3 &
5729 + FC_REG_EVENT_MASK);
5730 + int ev_reg_id = (uint32_t) cip->lpfc_flag;
5731 + uint32_t ev_req_id = 0;
5732 + struct lpfcdfc_host * dfchba;
5733 + struct lpfcdfc_event * evt;
5734 + struct event_data * evt_dat = NULL;
5735 + int ret_val = 0;
5736 +
5737 + /* All other events supported through NET_LINK_EVENTs */
5738 + if (ev_mask != FC_REG_CT_EVENT)
5739 + return ENOENT;
5740 +
5741 + mutex_lock(&lpfcdfc_lock);
5742 + list_for_each_entry(dfchba, &lpfcdfc_hosts, node)
5743 + if (dfchba->phba == phba)
5744 + break;
5745 + mutex_unlock(&lpfcdfc_lock);
5746 +
5747 + BUG_ON(&dfchba->node == &lpfcdfc_hosts);
5748 +
5749 + if ((ev_mask == FC_REG_CT_EVENT) &&
5750 + copy_from_user(&ev_req_id, (void __user *)cip->lpfc_arg2,
5751 + sizeof (uint32_t)))
5752 + return EIO;
5753 +
5754 + mutex_lock(&lpfcdfc_lock);
5755 + list_for_each_entry(evt, &dfchba->ev_waiters, node)
5756 + if (evt->reg_id == ev_reg_id) {
5757 + if(list_empty(&evt->events_to_get))
5758 + break;
5759 + lpfcdfc_event_ref(evt);
5760 + evt->wait_time_stamp = jiffies;
5761 + evt_dat = list_entry(evt->events_to_get.prev,
5762 + struct event_data, node);
5763 + list_del(&evt_dat->node);
5764 + break;
5765 + }
5766 + mutex_unlock(&lpfcdfc_lock);
5767 +
5768 + if (evt_dat == NULL)
5769 + return ENOENT;
5770 +
5771 + BUG_ON((ev_mask & evt_dat->type) == 0);
5772 +
5773 + if (evt_dat->len > cip->lpfc_outsz)
5774 + evt_dat->len = cip->lpfc_outsz;
5775 +
5776 + if (copy_to_user((void __user *)cip->lpfc_arg2, &evt_dat->immed_dat,
5777 + sizeof (uint32_t)) ||
5778 + copy_to_user((void __user *)cip->lpfc_arg1, &evt_dat->len,
5779 + sizeof (uint32_t))) {
5780 + ret_val = EIO;
5781 + goto error_get_event_exit;
5782 + }
5783 +
5784 + if (evt_dat->len > 0) {
5785 + *data_size = evt_dat->len;
5786 + *dataout = kmalloc(*data_size, GFP_KERNEL);
5787 + if (*dataout)
5788 + memcpy(*dataout, evt_dat->data, *data_size);
5789 + else
5790 + *data_size = 0;
5791 +
5792 + } else
5793 + *data_size = 0;
5794 + ret_val = 0;
5795 +
5796 +error_get_event_exit:
5797 +
5798 + kfree(evt_dat->data);
5799 + kfree(evt_dat);
5800 + mutex_lock(&lpfcdfc_lock);
5801 + lpfcdfc_event_unref(evt);
5802 + mutex_unlock(&lpfcdfc_lock);
5803 +
5804 + return ret_val;
5805 +}
5806 +
5807 +static int
5808 +lpfc_ioctl_hba_set_event(struct lpfc_hba * phba,
5809 + struct lpfcCmdInput * cip)
5810 +{
5811 + uint32_t ev_mask = ((uint32_t)(unsigned long)cip->lpfc_arg3 &
5812 + FC_REG_EVENT_MASK);
5813 + int ev_reg_id = cip->lpfc_flag;
5814 + uint32_t ev_req_id = 0;
5815 +
5816 + struct lpfcdfc_host * dfchba;
5817 + struct lpfcdfc_event * evt;
5818 +
5819 + int ret_val = 0;
5820 +
5821 + /* All other events supported through NET_LINK_EVENTs */
5822 + if (ev_mask != FC_REG_CT_EVENT)
5823 + return ENOENT;
5824 +
5825 + mutex_lock(&lpfcdfc_lock);
5826 + list_for_each_entry(dfchba, &lpfcdfc_hosts, node) {
5827 + if (dfchba->phba == phba)
5828 + break;
5829 + }
5830 + mutex_unlock(&lpfcdfc_lock);
5831 + BUG_ON(&dfchba->node == &lpfcdfc_hosts);
5832 +
5833 + if (ev_mask == FC_REG_CT_EVENT)
5834 + ev_req_id = ((uint32_t)(unsigned long)cip->lpfc_arg2);
5835 +
5836 + mutex_lock(&lpfcdfc_lock);
5837 + list_for_each_entry(evt, &dfchba->ev_waiters, node) {
5838 + if (evt->reg_id == ev_reg_id) {
5839 + lpfcdfc_event_ref(evt);
5840 + evt->wait_time_stamp = jiffies;
5841 + break;
5842 + }
5843 + }
5844 + mutex_unlock(&lpfcdfc_lock);
5845 +
5846 + if (&evt->node == &dfchba->ev_waiters) {
5847 + /* no event waiting struct yet - first call */
5848 + evt = lpfcdfc_event_new(ev_mask, ev_reg_id, ev_req_id);
5849 + if (evt == NULL)
5850 + return ENOMEM;
5851 +
5852 + mutex_lock(&lpfcdfc_lock);
5853 + list_add(&evt->node, &dfchba->ev_waiters);
5854 + lpfcdfc_event_ref(evt);
5855 + mutex_unlock(&lpfcdfc_lock);
5856 + }
5857 +
5858 + evt->waiting = 1;
5859 + if (wait_event_interruptible(evt->wq,
5860 + (!list_empty(&evt->events_to_see) ||
5861 + dfchba->blocked))) {
5862 + mutex_lock(&lpfcdfc_lock);
5863 + lpfcdfc_event_unref(evt); /* release ref */
5864 + lpfcdfc_event_unref(evt); /* delete */
5865 + mutex_unlock(&lpfcdfc_lock);
5866 + return EINTR;
5867 + }
5868 +
5869 + mutex_lock(&lpfcdfc_lock);
5870 + if (dfchba->blocked) {
5871 + lpfcdfc_event_unref(evt);
5872 + lpfcdfc_event_unref(evt);
5873 + mutex_unlock(&lpfcdfc_lock);
5874 + return ENODEV;
5875 + }
5876 + mutex_unlock(&lpfcdfc_lock);
5877 +
5878 + evt->wait_time_stamp = jiffies;
5879 + evt->waiting = 0;
5880 +
5881 + BUG_ON(list_empty(&evt->events_to_see));
5882 +
5883 + mutex_lock(&lpfcdfc_lock);
5884 + list_move(evt->events_to_see.prev, &evt->events_to_get);
5885 + lpfcdfc_event_unref(evt); /* release ref */
5886 + mutex_unlock(&lpfcdfc_lock);
5887 +
5888 + return ret_val;
5889 +}
5890 +
5891 +static int
5892 +lpfc_ioctl_loopback_mode(struct lpfc_hba *phba,
5893 + struct lpfcCmdInput *cip, void *dataout)
5894 +{
5895 + struct Scsi_Host *shost;
5896 + struct lpfc_sli *psli = &phba->sli;
5897 + struct lpfc_sli_ring *pring = &psli->ring[LPFC_FCP_RING];
5898 + uint32_t link_flags = cip->lpfc_arg4;
5899 + uint32_t timeout = cip->lpfc_arg5 * 100;
5900 + struct lpfc_vport **vports;
5901 + LPFC_MBOXQ_t *pmboxq;
5902 + int mbxstatus;
5903 + int i = 0;
5904 + int rc = 0;
5905 +
5906 + if ((phba->link_state == LPFC_HBA_ERROR) ||
5907 + (psli->sli_flag & LPFC_BLOCK_MGMT_IO) ||
5908 + (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
5909 + return EACCES;
5910 +
5911 + if ((pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL)) == 0)
5912 + return ENOMEM;
5913 +
5914 + vports = lpfc_create_vport_work_array(phba);
5915 + if (vports != NULL) {
5916 + for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++){
5917 + shost = lpfc_shost_from_vport(vports[i]);
5918 + scsi_block_requests(shost);
5919 + }
5920 + lpfc_destroy_vport_work_array(phba, vports);
5921 + }
5922 + else {
5923 + shost = lpfc_shost_from_vport(phba->pport);
5924 + scsi_block_requests(shost);
5925 + }
5926 +
5927 + while (pring->txcmplq_cnt) {
5928 + if (i++ > 500) /* wait up to 5 seconds */
5929 + break;
5930 +
5931 + mdelay(10);
5932 + }
5933 +
5934 + memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
5935 + pmboxq->mb.mbxCommand = MBX_DOWN_LINK;
5936 + pmboxq->mb.mbxOwner = OWN_HOST;
5937 +
5938 + mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO);
5939 +
5940 + if ((mbxstatus == MBX_SUCCESS) && (pmboxq->mb.mbxStatus == 0)) {
5941 +
5942 + /* wait for link down before proceeding */
5943 + i = 0;
5944 + while (phba->link_state != LPFC_LINK_DOWN) {
5945 + if (i++ > timeout) {
5946 + rc = ETIMEDOUT;
5947 + goto loopback_mode_exit;
5948 + }
5949 + msleep(10);
5950 + }
5951 +
5952 + memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
5953 + if (link_flags == INTERNAL_LOOP_BACK)
5954 + pmboxq->mb.un.varInitLnk.link_flags = FLAGS_LOCAL_LB;
5955 + else
5956 + pmboxq->mb.un.varInitLnk.link_flags =
5957 + FLAGS_TOPOLOGY_MODE_LOOP;
5958 +
5959 + pmboxq->mb.mbxCommand = MBX_INIT_LINK;
5960 + pmboxq->mb.mbxOwner = OWN_HOST;
5961 +
5962 + mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
5963 + LPFC_MBOX_TMO);
5964 +
5965 + if ((mbxstatus != MBX_SUCCESS) || (pmboxq->mb.mbxStatus))
5966 + rc = ENODEV;
5967 + else {
5968 + phba->link_flag |= LS_LOOPBACK_MODE;
5969 + /* wait for the link attention interrupt */
5970 + msleep(100);
5971 +
5972 + i = 0;
5973 + while (phba->link_state != LPFC_HBA_READY) {
5974 + if (i++ > timeout) {
5975 + rc = ETIMEDOUT;
5976 + break;
5977 + }
5978 + msleep(10);
5979 + }
5980 + }
5981 + } else
5982 + rc = ENODEV;
5983 +
5984 +loopback_mode_exit:
5985 + vports = lpfc_create_vport_work_array(phba);
5986 + if (vports != NULL) {
5987 + for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++){
5988 + shost = lpfc_shost_from_vport(vports[i]);
5989 + scsi_unblock_requests(shost);
5990 + }
5991 + lpfc_destroy_vport_work_array(phba, vports);
5992 + }
5993 + else {
5994 + shost = lpfc_shost_from_vport(phba->pport);
5995 + scsi_unblock_requests(shost);
5996 + }
5997 +
5998 + /*
5999 + * Let SLI layer release mboxq if mbox command completed after timeout.
6000 + */
6001 + if (mbxstatus != MBX_TIMEOUT)
6002 + mempool_free( pmboxq, phba->mbox_mem_pool);
6003 +
6004 + return rc;
6005 +}
6006 +
6007 +static int lpfcdfc_loop_self_reg(struct lpfc_hba *phba, uint16_t * rpi)
6008 +{
6009 + LPFC_MBOXQ_t *mbox;
6010 + struct lpfc_dmabuf *dmabuff;
6011 + int status;
6012 +
6013 + mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6014 + if (mbox == NULL)
6015 + return ENOMEM;
6016 +
6017 + status = lpfc_reg_login(phba, 0, phba->pport->fc_myDID,
6018 + (uint8_t *)&phba->pport->fc_sparam, mbox, 0);
6019 + if (status) {
6020 + mempool_free(mbox, phba->mbox_mem_pool);
6021 + return ENOMEM;
6022 + }
6023 +
6024 + dmabuff = (struct lpfc_dmabuf *) mbox->context1;
6025 + mbox->context1 = NULL;
6026 + status = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
6027 +
6028 + if ((status != MBX_SUCCESS) || (mbox->mb.mbxStatus)) {
6029 + lpfc_mbuf_free(phba, dmabuff->virt, dmabuff->phys);
6030 + kfree(dmabuff);
6031 + if (status != MBX_TIMEOUT)
6032 + mempool_free(mbox, phba->mbox_mem_pool);
6033 + return ENODEV;
6034 + }
6035 +
6036 + *rpi = mbox->mb.un.varWords[0];
6037 +
6038 + lpfc_mbuf_free(phba, dmabuff->virt, dmabuff->phys);
6039 + kfree(dmabuff);
6040 + mempool_free(mbox, phba->mbox_mem_pool);
6041 +
6042 + return 0;
6043 +}
6044 +
6045 +static int lpfcdfc_loop_self_unreg(struct lpfc_hba *phba, uint16_t rpi)
6046 +{
6047 + LPFC_MBOXQ_t * mbox;
6048 + int status;
6049 +
6050 + /* Allocate mboxq structure */
6051 + mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6052 + if (mbox == NULL)
6053 + return ENOMEM;
6054 +
6055 + lpfc_unreg_login(phba, 0, rpi, mbox);
6056 + status = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
6057 +
6058 + if ((status != MBX_SUCCESS) || (mbox->mb.mbxStatus)) {
6059 + if (status != MBX_TIMEOUT)
6060 + mempool_free(mbox, phba->mbox_mem_pool);
6061 + return EIO;
6062 + }
6063 +
6064 + mempool_free(mbox, phba->mbox_mem_pool);
6065 + return 0;
6066 +}
6067 +
6068 +
6069 +static int lpfcdfc_loop_get_xri(struct lpfc_hba *phba, uint16_t rpi,
6070 + uint16_t *txxri, uint16_t * rxxri)
6071 +{
6072 + struct lpfc_sli *psli = &phba->sli;
6073 + struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
6074 +
6075 + struct lpfcdfc_host * dfchba;
6076 + struct lpfcdfc_event * evt;
6077 +
6078 + struct lpfc_iocbq *cmdiocbq, *rspiocbq;
6079 + IOCB_t *cmd, *rsp;
6080 +
6081 + struct lpfc_dmabuf * dmabuf;
6082 + struct ulp_bde64 *bpl = NULL;
6083 + struct lpfc_sli_ct_request *ctreq = NULL;
6084 +
6085 + int ret_val = 0;
6086 +
6087 + *txxri = 0;
6088 + *rxxri = 0;
6089 +
6090 + mutex_lock(&lpfcdfc_lock);
6091 + list_for_each_entry(dfchba, &lpfcdfc_hosts, node) {
6092 + if (dfchba->phba == phba)
6093 + break;
6094 + }
6095 + mutex_unlock(&lpfcdfc_lock);
6096 + BUG_ON(&dfchba->node == &lpfcdfc_hosts);
6097 +
6098 + evt = lpfcdfc_event_new(FC_REG_CT_EVENT, current->pid,
6099 + SLI_CT_ELX_LOOPBACK);
6100 + if (evt == NULL)
6101 + return ENOMEM;
6102 +
6103 + mutex_lock(&lpfcdfc_lock);
6104 + list_add(&evt->node, &dfchba->ev_waiters);
6105 + lpfcdfc_event_ref(evt);
6106 + mutex_unlock(&lpfcdfc_lock);
6107 +
6108 + cmdiocbq = lpfc_sli_get_iocbq(phba);
6109 + rspiocbq = lpfc_sli_get_iocbq(phba);
6110 +
6111 + dmabuf = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
6112 + if (dmabuf) {
6113 + dmabuf->virt = lpfc_mbuf_alloc(phba, 0, &dmabuf->phys);
6114 + INIT_LIST_HEAD(&dmabuf->list);
6115 + bpl = (struct ulp_bde64 *) dmabuf->virt;
6116 + memset(bpl, 0, sizeof(*bpl));
6117 + ctreq = (struct lpfc_sli_ct_request *)(bpl + 1);
6118 + bpl->addrHigh =
6119 + le32_to_cpu(putPaddrHigh(dmabuf->phys + sizeof(*bpl)));
6120 + bpl->addrLow =
6121 + le32_to_cpu(putPaddrLow(dmabuf->phys + sizeof(*bpl)));
6122 + bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
6123 + bpl->tus.f.bdeSize = ELX_LOOPBACK_HEADER_SZ;
6124 + bpl->tus.w = le32_to_cpu(bpl->tus.w);
6125 + }
6126 +
6127 + if (cmdiocbq == NULL || rspiocbq == NULL ||
6128 + dmabuf == NULL || bpl == NULL || ctreq == NULL) {
6129 + ret_val = ENOMEM;
6130 + goto err_get_xri_exit;
6131 + }
6132 +
6133 + cmd = &cmdiocbq->iocb;
6134 + rsp = &rspiocbq->iocb;
6135 +
6136 + memset(ctreq, 0, ELX_LOOPBACK_HEADER_SZ);
6137 +
6138 + ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
6139 + ctreq->RevisionId.bits.InId = 0;
6140 + ctreq->FsType = SLI_CT_ELX_LOOPBACK;
6141 + ctreq->FsSubType = 0;
6142 + ctreq->CommandResponse.bits.CmdRsp = ELX_LOOPBACK_XRI_SETUP;
6143 + ctreq->CommandResponse.bits.Size = 0;
6144 +
6145 +
6146 + cmd->un.xseq64.bdl.addrHigh = putPaddrHigh(dmabuf->phys);
6147 + cmd->un.xseq64.bdl.addrLow = putPaddrLow(dmabuf->phys);
6148 + cmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
6149 + cmd->un.xseq64.bdl.bdeSize = sizeof(*bpl);
6150 +
6151 + cmd->un.xseq64.w5.hcsw.Fctl = LA;
6152 + cmd->un.xseq64.w5.hcsw.Dfctl = 0;
6153 + cmd->un.xseq64.w5.hcsw.Rctl = FC_UNSOL_CTL;
6154 + cmd->un.xseq64.w5.hcsw.Type = FC_COMMON_TRANSPORT_ULP;
6155 +
6156 + cmd->ulpCommand = CMD_XMIT_SEQUENCE64_CR;
6157 + cmd->ulpBdeCount = 1;
6158 + cmd->ulpLe = 1;
6159 + cmd->ulpClass = CLASS3;
6160 + cmd->ulpContext = rpi;
6161 +
6162 + cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
6163 + cmdiocbq->vport = phba->pport;
6164 +
6165 + ret_val = lpfc_sli_issue_iocb_wait(phba, pring, cmdiocbq, rspiocbq,
6166 + (phba->fc_ratov * 2)
6167 + + LPFC_DRVR_TIMEOUT);
6168 + if (ret_val)
6169 + goto err_get_xri_exit;
6170 +
6171 + *txxri = rsp->ulpContext;
6172 +
6173 + evt->waiting = 1;
6174 + evt->wait_time_stamp = jiffies;
6175 + ret_val = wait_event_interruptible_timeout(
6176 + evt->wq, !list_empty(&evt->events_to_see),
6177 + ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT) * HZ);
6178 + if (list_empty(&evt->events_to_see))
6179 + ret_val = (ret_val) ? EINTR : ETIMEDOUT;
6180 + else {
6181 + ret_val = IOCB_SUCCESS;
6182 + mutex_lock(&lpfcdfc_lock);
6183 + list_move(evt->events_to_see.prev, &evt->events_to_get);
6184 + mutex_unlock(&lpfcdfc_lock);
6185 + *rxxri = (list_entry(evt->events_to_get.prev,
6186 + typeof(struct event_data),
6187 + node))->immed_dat;
6188 + }
6189 + evt->waiting = 0;
6190 +
6191 +err_get_xri_exit:
6192 + mutex_lock(&lpfcdfc_lock);
6193 + lpfcdfc_event_unref(evt); /* release ref */
6194 + lpfcdfc_event_unref(evt); /* delete */
6195 + mutex_unlock(&lpfcdfc_lock);
6196 +
6197 + if(dmabuf) {
6198 + if(dmabuf->virt)
6199 + lpfc_mbuf_free(phba, dmabuf->virt, dmabuf->phys);
6200 + kfree(dmabuf);
6201 + }
6202 +
6203 + if (cmdiocbq && (ret_val != IOCB_TIMEDOUT))
6204 + lpfc_sli_release_iocbq(phba, cmdiocbq);
6205 + if (rspiocbq)
6206 + lpfc_sli_release_iocbq(phba, rspiocbq);
6207 +
6208 + return ret_val;
6209 +}
6210 +
6211 +static int lpfcdfc_loop_post_rxbufs(struct lpfc_hba *phba, uint16_t rxxri,
6212 + size_t len)
6213 +{
6214 + struct lpfc_sli *psli = &phba->sli;
6215 + struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
6216 + struct lpfc_iocbq *cmdiocbq;
6217 + IOCB_t *cmd = NULL;
6218 + struct list_head head, *curr, *next;
6219 + struct lpfc_dmabuf *rxbmp;
6220 + struct lpfc_dmabuf *dmp;
6221 + struct lpfc_dmabuf *mp[2] = {NULL, NULL};
6222 + struct ulp_bde64 *rxbpl = NULL;
6223 + uint32_t num_bde;
6224 + struct lpfc_dmabufext *rxbuffer = NULL;
6225 + int ret_val = 0;
6226 + int i = 0;
6227 +
6228 + cmdiocbq = lpfc_sli_get_iocbq(phba);
6229 + rxbmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
6230 + if (rxbmp != NULL) {
6231 + rxbmp->virt = lpfc_mbuf_alloc(phba, 0, &rxbmp->phys);
6232 + INIT_LIST_HEAD(&rxbmp->list);
6233 + rxbpl = (struct ulp_bde64 *) rxbmp->virt;
6234 + rxbuffer = dfc_cmd_data_alloc(phba, NULL, rxbpl, len);
6235 + }
6236 +
6237 + if(cmdiocbq == NULL || rxbmp == NULL ||
6238 + rxbpl == NULL || rxbuffer == NULL) {
6239 + ret_val = ENOMEM;
6240 + goto err_post_rxbufs_exit;
6241 + }
6242 +
6243 + /* Queue buffers for the receive exchange */
6244 + num_bde = (uint32_t)rxbuffer->flag;
6245 + dmp = &rxbuffer->dma;
6246 +
6247 + cmd = &cmdiocbq->iocb;
6248 + i = 0;
6249 +
6250 + INIT_LIST_HEAD(&head);
6251 + list_add_tail(&head, &dmp->list);
6252 + list_for_each_safe(curr, next, &head) {
6253 + mp[i] = list_entry(curr, struct lpfc_dmabuf, list);
6254 + list_del(curr);
6255 +
6256 + if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
6257 + mp[i]->buffer_tag = lpfc_sli_get_buffer_tag(phba);
6258 + cmd->un.quexri64cx.buff.bde.addrHigh =
6259 + putPaddrHigh(mp[i]->phys);
6260 + cmd->un.quexri64cx.buff.bde.addrLow =
6261 + putPaddrLow(mp[i]->phys);
6262 + cmd->un.quexri64cx.buff.bde.tus.f.bdeSize =
6263 + ((struct lpfc_dmabufext *)mp[i])->size;
6264 + cmd->un.quexri64cx.buff.buffer_tag = mp[i]->buffer_tag;
6265 + cmd->ulpCommand = CMD_QUE_XRI64_CX;
6266 + cmd->ulpPU = 0;
6267 + cmd->ulpLe = 1;
6268 + cmd->ulpBdeCount = 1;
6269 + cmd->unsli3.que_xri64cx_ext_words.ebde_count = 0;
6270 +
6271 + } else {
6272 + cmd->un.cont64[i].addrHigh = putPaddrHigh(mp[i]->phys);
6273 + cmd->un.cont64[i].addrLow = putPaddrLow(mp[i]->phys);
6274 + cmd->un.cont64[i].tus.f.bdeSize =
6275 + ((struct lpfc_dmabufext *)mp[i])->size;
6276 + cmd->ulpBdeCount = ++i;
6277 +
6278 + if ((--num_bde > 0) && (i < 2))
6279 + continue;
6280 +
6281 + cmd->ulpCommand = CMD_QUE_XRI_BUF64_CX;
6282 + cmd->ulpLe = 1;
6283 + }
6284 +
6285 + cmd->ulpClass = CLASS3;
6286 + cmd->ulpContext = rxxri;
6287 +
6288 + ret_val = lpfc_sli_issue_iocb(phba, pring, cmdiocbq, 0);
6289 +
6290 + if (ret_val == IOCB_ERROR) {
6291 + dfc_cmd_data_free(phba, (struct lpfc_dmabufext *)mp[0]);
6292 + if (mp[1])
6293 + dfc_cmd_data_free(phba,
6294 + (struct lpfc_dmabufext *)mp[1]);
6295 + dmp = list_entry(next, struct lpfc_dmabuf, list);
6296 + ret_val = EIO;
6297 + goto err_post_rxbufs_exit;
6298 + }
6299 +
6300 + lpfc_sli_ringpostbuf_put(phba, pring, mp[0]);
6301 + if (mp[1]) {
6302 + lpfc_sli_ringpostbuf_put(phba, pring, mp[1]);
6303 + mp[1] = NULL;
6304 + }
6305 +
6306 + /* The iocb was freed by lpfc_sli_issue_iocb */
6307 + if ((cmdiocbq = lpfc_sli_get_iocbq(phba)) == NULL) {
6308 + dmp = list_entry(next, struct lpfc_dmabuf, list);
6309 + ret_val = EIO;
6310 + goto err_post_rxbufs_exit;
6311 + }
6312 + cmd = &cmdiocbq->iocb;
6313 + i = 0;
6314 + }
6315 + list_del(&head);
6316 +
6317 +err_post_rxbufs_exit:
6318 +
6319 + if(rxbmp) {
6320 + if(rxbmp->virt)
6321 + lpfc_mbuf_free(phba, rxbmp->virt, rxbmp->phys);
6322 + kfree(rxbmp);
6323 + }
6324 +
6325 + if (cmdiocbq)
6326 + lpfc_sli_release_iocbq(phba, cmdiocbq);
6327 +
6328 + return ret_val;
6329 +}
6330 +static int
6331 +lpfc_ioctl_loopback_test(struct lpfc_hba *phba,
6332 + struct lpfcCmdInput *cip, void *dataout)
6333 +{
6334 + struct lpfcdfc_host * dfchba;
6335 + struct lpfcdfc_event * evt;
6336 + struct event_data * evdat;
6337 +
6338 + struct lpfc_sli *psli = &phba->sli;
6339 + struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
6340 + uint32_t size = cip->lpfc_outsz;
6341 + uint32_t full_size = size + ELX_LOOPBACK_HEADER_SZ;
6342 + size_t segment_len = 0, segment_offset = 0, current_offset = 0;
6343 + uint16_t rpi;
6344 + struct lpfc_iocbq *cmdiocbq, *rspiocbq;
6345 + IOCB_t *cmd, *rsp;
6346 + struct lpfc_sli_ct_request *ctreq;
6347 + struct lpfc_dmabuf *txbmp;
6348 + struct ulp_bde64 *txbpl = NULL;
6349 + struct lpfc_dmabufext *txbuffer = NULL;
6350 + struct list_head head;
6351 + struct lpfc_dmabuf *curr;
6352 + uint16_t txxri, rxxri;
6353 + uint32_t num_bde;
6354 + uint8_t *ptr = NULL, *rx_databuf = NULL;
6355 + int rc;
6356 +
6357 + if ((phba->link_state == LPFC_HBA_ERROR) ||
6358 + (psli->sli_flag & LPFC_BLOCK_MGMT_IO) ||
6359 + (!(psli->sli_flag & LPFC_SLI2_ACTIVE)))
6360 + return EACCES;
6361 +
6362 + if (!lpfc_is_link_up(phba) || !(phba->link_flag & LS_LOOPBACK_MODE))
6363 + return EACCES;
6364 +
6365 + if ((size == 0) || (size > 80 * BUF_SZ_4K))
6366 + return ERANGE;
6367 +
6368 + mutex_lock(&lpfcdfc_lock);
6369 + list_for_each_entry(dfchba, &lpfcdfc_hosts, node) {
6370 + if (dfchba->phba == phba)
6371 + break;
6372 + }
6373 + mutex_unlock(&lpfcdfc_lock);
6374 + BUG_ON(&dfchba->node == &lpfcdfc_hosts);
6375 +
6376 + rc = lpfcdfc_loop_self_reg(phba, &rpi);
6377 + if (rc)
6378 + return rc;
6379 +
6380 + rc = lpfcdfc_loop_get_xri(phba, rpi, &txxri, &rxxri);
6381 + if (rc) {
6382 + lpfcdfc_loop_self_unreg(phba, rpi);
6383 + return rc;
6384 + }
6385 +
6386 + rc = lpfcdfc_loop_post_rxbufs(phba, rxxri, full_size);
6387 + if (rc) {
6388 + lpfcdfc_loop_self_unreg(phba, rpi);
6389 + return rc;
6390 + }
6391 +
6392 + evt = lpfcdfc_event_new(FC_REG_CT_EVENT, current->pid,
6393 + SLI_CT_ELX_LOOPBACK);
6394 + if (evt == NULL) {
6395 + lpfcdfc_loop_self_unreg(phba, rpi);
6396 + return ENOMEM;
6397 + }
6398 +
6399 + mutex_lock(&lpfcdfc_lock);
6400 + list_add(&evt->node, &dfchba->ev_waiters);
6401 + lpfcdfc_event_ref(evt);
6402 + mutex_unlock(&lpfcdfc_lock);
6403 +
6404 + cmdiocbq = lpfc_sli_get_iocbq(phba);
6405 + rspiocbq = lpfc_sli_get_iocbq(phba);
6406 + txbmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
6407 +
6408 + if (txbmp) {
6409 + txbmp->virt = lpfc_mbuf_alloc(phba, 0, &txbmp->phys);
6410 + INIT_LIST_HEAD(&txbmp->list);
6411 + txbpl = (struct ulp_bde64 *) txbmp->virt;
6412 + if (txbpl)
6413 + txbuffer = dfc_cmd_data_alloc(phba, NULL,
6414 + txbpl, full_size);
6415 + }
6416 +
6417 + if (cmdiocbq == NULL || rspiocbq == NULL
6418 + || txbmp == NULL || txbpl == NULL || txbuffer == NULL) {
6419 + rc = ENOMEM;
6420 + goto err_loopback_test_exit;
6421 + }
6422 +
6423 + cmd = &cmdiocbq->iocb;
6424 + rsp = &rspiocbq->iocb;
6425 +
6426 + INIT_LIST_HEAD(&head);
6427 + list_add_tail(&head, &txbuffer->dma.list);
6428 + list_for_each_entry(curr, &head, list) {
6429 + segment_len = ((struct lpfc_dmabufext *)curr)->size;
6430 + if (current_offset == 0) {
6431 + ctreq = curr->virt;
6432 + memset(ctreq, 0, ELX_LOOPBACK_HEADER_SZ);
6433 + ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
6434 + ctreq->RevisionId.bits.InId = 0;
6435 + ctreq->FsType = SLI_CT_ELX_LOOPBACK;
6436 + ctreq->FsSubType = 0;
6437 + ctreq->CommandResponse.bits.CmdRsp = ELX_LOOPBACK_DATA ;
6438 + ctreq->CommandResponse.bits.Size = size;
6439 + segment_offset = ELX_LOOPBACK_HEADER_SZ;
6440 + } else
6441 + segment_offset = 0;
6442 +
6443 + BUG_ON(segment_offset >= segment_len);
6444 + if (copy_from_user (curr->virt + segment_offset,
6445 + (void __user *)cip->lpfc_arg1
6446 + + current_offset,
6447 + segment_len - segment_offset)) {
6448 + rc = EIO;
6449 + list_del(&head);
6450 + goto err_loopback_test_exit;
6451 + }
6452 +
6453 + current_offset += segment_len - segment_offset;
6454 + BUG_ON(current_offset > size);
6455 + }
6456 + list_del(&head);
6457 +
6458 + /* Build the XMIT_SEQUENCE iocb */
6459 +
6460 + num_bde = (uint32_t)txbuffer->flag;
6461 +
6462 + cmd->un.xseq64.bdl.addrHigh = putPaddrHigh(txbmp->phys);
6463 + cmd->un.xseq64.bdl.addrLow = putPaddrLow(txbmp->phys);
6464 + cmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
6465 + cmd->un.xseq64.bdl.bdeSize = (num_bde * sizeof(struct ulp_bde64));
6466 +
6467 + cmd->un.xseq64.w5.hcsw.Fctl = (LS | LA);
6468 + cmd->un.xseq64.w5.hcsw.Dfctl = 0;
6469 + cmd->un.xseq64.w5.hcsw.Rctl = FC_UNSOL_CTL;
6470 + cmd->un.xseq64.w5.hcsw.Type = FC_COMMON_TRANSPORT_ULP;
6471 +
6472 + cmd->ulpCommand = CMD_XMIT_SEQUENCE64_CX;
6473 + cmd->ulpBdeCount = 1;
6474 + cmd->ulpLe = 1;
6475 + cmd->ulpClass = CLASS3;
6476 + cmd->ulpContext = txxri;
6477 +
6478 + cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
6479 + cmdiocbq->vport = phba->pport;
6480 +
6481 + rc = lpfc_sli_issue_iocb_wait(phba, pring, cmdiocbq, rspiocbq,
6482 + (phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT);
6483 +
6484 + if ((rc != IOCB_SUCCESS) || (rsp->ulpStatus != IOCB_SUCCESS)) {
6485 + rc = EIO;
6486 + goto err_loopback_test_exit;
6487 + }
6488 +
6489 + evt->waiting = 1;
6490 + rc = wait_event_interruptible_timeout(
6491 + evt->wq, !list_empty(&evt->events_to_see),
6492 + ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT) * HZ);
6493 + evt->waiting = 0;
6494 + if (list_empty(&evt->events_to_see))
6495 + rc = (rc) ? EINTR : ETIMEDOUT;
6496 + else {
6497 + ptr = dataout;
6498 + mutex_lock(&lpfcdfc_lock);
6499 + list_move(evt->events_to_see.prev, &evt->events_to_get);
6500 + evdat = list_entry(evt->events_to_get.prev,
6501 + typeof(*evdat), node);
6502 + mutex_unlock(&lpfcdfc_lock);
6503 + rx_databuf = evdat->data;
6504 + if (evdat->len != full_size) {
6505 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
6506 + "1603 Loopback test did not receive expected "
6507 + "data length. actual length 0x%x expected "
6508 + "length 0x%x\n",
6509 + evdat->len, full_size);
6510 + rc = EIO;
6511 + }
6512 + else if (rx_databuf == NULL)
6513 + rc = EIO;
6514 + else {
6515 + rx_databuf += ELX_LOOPBACK_HEADER_SZ;
6516 + memcpy(ptr, rx_databuf, size);
6517 + rc = IOCB_SUCCESS;
6518 + }
6519 + }
6520 +
6521 +err_loopback_test_exit:
6522 + lpfcdfc_loop_self_unreg(phba, rpi);
6523 +
6524 + mutex_lock(&lpfcdfc_lock);
6525 + lpfcdfc_event_unref(evt); /* release ref */
6526 + lpfcdfc_event_unref(evt); /* delete */
6527 + mutex_unlock(&lpfcdfc_lock);
6528 +
6529 + if (cmdiocbq != NULL)
6530 + lpfc_sli_release_iocbq(phba, cmdiocbq);
6531 +
6532 + if (rspiocbq != NULL)
6533 + lpfc_sli_release_iocbq(phba, rspiocbq);
6534 +
6535 + if (txbmp != NULL) {
6536 + if (txbpl != NULL) {
6537 + if (txbuffer != NULL)
6538 + dfc_cmd_data_free(phba, txbuffer);
6539 + lpfc_mbuf_free(phba, txbmp->virt, txbmp->phys);
6540 + }
6541 + kfree(txbmp);
6542 + }
6543 + return rc;
6544 +}
6545 +
6546 +static int
6547 +dfc_rsp_data_copy(struct lpfc_hba * phba,
6548 + uint8_t * outdataptr, struct lpfc_dmabufext * mlist,
6549 + uint32_t size)
6550 +{
6551 + struct lpfc_dmabufext *mlast = NULL;
6552 + int cnt, offset = 0;
6553 + struct list_head head, *curr, *next;
6554 +
6555 + if (!mlist)
6556 + return 0;
6557 +
6558 + list_add_tail(&head, &mlist->dma.list);
6559 +
6560 + list_for_each_safe(curr, next, &head) {
6561 + mlast = list_entry(curr, struct lpfc_dmabufext , dma.list);
6562 + if (!size)
6563 + break;
6564 +
6565 + /* We copy chucks of 4K */
6566 + if (size > BUF_SZ_4K)
6567 + cnt = BUF_SZ_4K;
6568 + else
6569 + cnt = size;
6570 +
6571 + if (outdataptr) {
6572 + pci_dma_sync_single_for_device(phba->pcidev,
6573 + mlast->dma.phys, LPFC_BPL_SIZE, PCI_DMA_TODEVICE);
6574 +
6575 + /* Copy data to user space */
6576 + if (copy_to_user
6577 + ((void __user *) (outdataptr + offset),
6578 + (uint8_t *) mlast->dma.virt, cnt))
6579 + return 1;
6580 + }
6581 + offset += cnt;
6582 + size -= cnt;
6583 + }
6584 + list_del(&head);
6585 + return 0;
6586 +}
6587 +
6588 +static int
6589 +lpfc_issue_ct_rsp(struct lpfc_hba * phba, uint32_t tag,
6590 + struct lpfc_dmabuf * bmp,
6591 + struct lpfc_dmabufext * inp)
6592 +{
6593 + struct lpfc_sli *psli;
6594 + IOCB_t *icmd;
6595 + struct lpfc_iocbq *ctiocb;
6596 + struct lpfc_sli_ring *pring;
6597 + uint32_t num_entry;
6598 + int rc = 0;
6599 +
6600 + psli = &phba->sli;
6601 + pring = &psli->ring[LPFC_ELS_RING];
6602 + num_entry = inp->flag;
6603 + inp->flag = 0;
6604 +
6605 + /* Allocate buffer for command iocb */
6606 + ctiocb = lpfc_sli_get_iocbq(phba);
6607 + if (!ctiocb) {
6608 + rc = ENOMEM;
6609 + goto issue_ct_rsp_exit;
6610 + }
6611 + icmd = &ctiocb->iocb;
6612 +
6613 + icmd->un.xseq64.bdl.ulpIoTag32 = 0;
6614 + icmd->un.xseq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
6615 + icmd->un.xseq64.bdl.addrLow = putPaddrLow(bmp->phys);
6616 + icmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
6617 + icmd->un.xseq64.bdl.bdeSize = (num_entry * sizeof (struct ulp_bde64));
6618 + icmd->un.xseq64.w5.hcsw.Fctl = (LS | LA);
6619 + icmd->un.xseq64.w5.hcsw.Dfctl = 0;
6620 + icmd->un.xseq64.w5.hcsw.Rctl = FC_SOL_CTL;
6621 + icmd->un.xseq64.w5.hcsw.Type = FC_COMMON_TRANSPORT_ULP;
6622 +
6623 + pci_dma_sync_single_for_device(phba->pcidev, bmp->phys, LPFC_BPL_SIZE,
6624 + PCI_DMA_TODEVICE);
6625 +
6626 + /* Fill in rest of iocb */
6627 + icmd->ulpCommand = CMD_XMIT_SEQUENCE64_CX;
6628 + icmd->ulpBdeCount = 1;
6629 + icmd->ulpLe = 1;
6630 + icmd->ulpClass = CLASS3;
6631 + icmd->ulpContext = (ushort) tag;
6632 + icmd->ulpTimeout = phba->fc_ratov * 2;
6633 +
6634 + /* Xmit CT response on exchange <xid> */
6635 + lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
6636 + "1200 Xmit CT response on exchange x%x Data: x%x x%x\n",
6637 + icmd->ulpContext, icmd->ulpIoTag, phba->link_state);
6638 +
6639 + ctiocb->iocb_cmpl = NULL;
6640 + ctiocb->iocb_flag |= LPFC_IO_LIBDFC;
6641 + ctiocb->vport = phba->pport;
6642 + rc = lpfc_sli_issue_iocb_wait(phba, pring, ctiocb, NULL,
6643 + phba->fc_ratov * 2 + LPFC_DRVR_TIMEOUT);
6644 +
6645 + if (rc == IOCB_TIMEDOUT) {
6646 + ctiocb->context1 = NULL;
6647 + ctiocb->context2 = NULL;
6648 + ctiocb->iocb_cmpl = lpfc_ioctl_timeout_iocb_cmpl;
6649 + return rc;
6650 + }
6651 +
6652 + /* Calling routine takes care of IOCB_ERROR => EIO translation */
6653 + if (rc != IOCB_SUCCESS)
6654 + rc = IOCB_ERROR;
6655 +
6656 + lpfc_sli_release_iocbq(phba, ctiocb);
6657 +issue_ct_rsp_exit:
6658 + return rc;
6659 +}
6660 +
6661 +
6662 +static void
6663 +lpfcdfc_ct_unsol_event(struct lpfc_hba * phba,
6664 + struct lpfc_sli_ring * pring,
6665 + struct lpfc_iocbq * piocbq)
6666 +{
6667 + struct lpfcdfc_host * dfchba = lpfcdfc_host_from_hba(phba);
6668 + uint32_t evt_req_id = 0;
6669 + uint32_t cmd;
6670 + uint32_t len;
6671 + struct lpfc_dmabuf *dmabuf = NULL;
6672 + struct lpfcdfc_event * evt;
6673 + struct event_data * evt_dat = NULL;
6674 + struct lpfc_iocbq * iocbq;
6675 + size_t offset = 0;
6676 + struct list_head head;
6677 + struct ulp_bde64 * bde;
6678 + dma_addr_t dma_addr;
6679 + int i;
6680 + struct lpfc_dmabuf *bdeBuf1 = piocbq->context2;
6681 + struct lpfc_dmabuf *bdeBuf2 = piocbq->context3;
6682 + struct lpfc_hbq_entry *hbqe;
6683 +
6684 + BUG_ON(&dfchba->node == &lpfcdfc_hosts);
6685 + INIT_LIST_HEAD(&head);
6686 + if (piocbq->iocb.ulpBdeCount == 0 ||
6687 + piocbq->iocb.un.cont64[0].tus.f.bdeSize == 0)
6688 + goto error_unsol_ct_exit;
6689 +
6690 + if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)
6691 + dmabuf = bdeBuf1;
6692 + else {
6693 + dma_addr = getPaddr(piocbq->iocb.un.cont64[0].addrHigh,
6694 + piocbq->iocb.un.cont64[0].addrLow);
6695 + dmabuf = lpfc_sli_ringpostbuf_get(phba, pring, dma_addr);
6696 + }
6697 + BUG_ON(dmabuf == NULL);
6698 + evt_req_id = ((struct lpfc_sli_ct_request *)(dmabuf->virt))->FsType;
6699 + cmd = ((struct lpfc_sli_ct_request *)
6700 + (dmabuf->virt))->CommandResponse.bits.CmdRsp;
6701 + len = ((struct lpfc_sli_ct_request *)
6702 + (dmabuf->virt))->CommandResponse.bits.Size;
6703 + if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
6704 + lpfc_sli_ringpostbuf_put(phba, pring, dmabuf);
6705 +
6706 + mutex_lock(&lpfcdfc_lock);
6707 + list_for_each_entry(evt, &dfchba->ev_waiters, node) {
6708 + if (!(evt->type_mask & FC_REG_CT_EVENT) ||
6709 + evt->req_id != evt_req_id)
6710 + continue;
6711 +
6712 + lpfcdfc_event_ref(evt);
6713 +
6714 + if ((evt_dat = kzalloc(sizeof(*evt_dat), GFP_KERNEL)) == NULL) {
6715 + lpfcdfc_event_unref(evt);
6716 + break;
6717 + }
6718 +
6719 + mutex_unlock(&lpfcdfc_lock);
6720 +
6721 + INIT_LIST_HEAD(&head);
6722 + list_add_tail(&head, &piocbq->list);
6723 + if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
6724 + /* take accumulated byte count from the last iocbq */
6725 + iocbq = list_entry(head.prev, typeof(*iocbq), list);
6726 + evt_dat->len = iocbq->iocb.unsli3.rcvsli3.acc_len;
6727 + } else {
6728 + list_for_each_entry(iocbq, &head, list) {
6729 + for (i = 0; i < iocbq->iocb.ulpBdeCount; i++)
6730 + evt_dat->len +=
6731 + iocbq->iocb.un.cont64[i].tus.f.bdeSize;
6732 + }
6733 + }
6734 +
6735 +
6736 + evt_dat->data = kzalloc(evt_dat->len, GFP_KERNEL);
6737 + if (evt_dat->data == NULL) {
6738 + kfree (evt_dat);
6739 + mutex_lock(&lpfcdfc_lock);
6740 + lpfcdfc_event_unref(evt);
6741 + mutex_unlock(&lpfcdfc_lock);
6742 + goto error_unsol_ct_exit;
6743 + }
6744 +
6745 + list_for_each_entry(iocbq, &head, list) {
6746 + if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
6747 + bdeBuf1 = iocbq->context2;
6748 + bdeBuf2 = iocbq->context3;
6749 + }
6750 + for (i = 0; i < iocbq->iocb.ulpBdeCount; i++) {
6751 + int size = 0;
6752 + if (phba->sli3_options &
6753 + LPFC_SLI3_HBQ_ENABLED) {
6754 + BUG_ON(i>1);
6755 + if (i == 0) {
6756 + hbqe = (struct lpfc_hbq_entry *)
6757 + &iocbq->iocb.un.ulpWord[0];
6758 + size = hbqe->bde.tus.f.bdeSize;
6759 + dmabuf = bdeBuf1;
6760 + } else if (i == 1) {
6761 + hbqe = (struct lpfc_hbq_entry *)
6762 + &iocbq->iocb.unsli3.
6763 + sli3Words[4];
6764 + size = hbqe->bde.tus.f.bdeSize;
6765 + dmabuf = bdeBuf2;
6766 + }
6767 + if ((offset + size) > evt_dat->len)
6768 + size = evt_dat->len - offset;
6769 + } else {
6770 + size = iocbq->iocb.un.cont64[i].
6771 + tus.f.bdeSize;
6772 + bde = &iocbq->iocb.un.cont64[i];
6773 + dma_addr = getPaddr(bde->addrHigh,
6774 + bde->addrLow);
6775 + dmabuf = lpfc_sli_ringpostbuf_get(phba,
6776 + pring, dma_addr);
6777 + }
6778 + if (dmabuf == NULL) {
6779 + kfree (evt_dat->data);
6780 + kfree (evt_dat);
6781 + mutex_lock(&lpfcdfc_lock);
6782 + lpfcdfc_event_unref(evt);
6783 + mutex_unlock(&lpfcdfc_lock);
6784 + goto error_unsol_ct_exit;
6785 + }
6786 + memcpy ((char *)(evt_dat->data) + offset,
6787 + dmabuf->virt, size);
6788 + offset += size;
6789 + if (evt_req_id != SLI_CT_ELX_LOOPBACK &&
6790 + !(phba->sli3_options &
6791 + LPFC_SLI3_HBQ_ENABLED))
6792 + lpfc_sli_ringpostbuf_put(phba, pring,
6793 + dmabuf);
6794 + else {
6795 + switch (cmd) {
6796 + case ELX_LOOPBACK_DATA:
6797 + dfc_cmd_data_free(phba,
6798 + (struct lpfc_dmabufext *)
6799 + dmabuf);
6800 + break;
6801 + case ELX_LOOPBACK_XRI_SETUP:
6802 + if (!(phba->sli3_options &
6803 + LPFC_SLI3_HBQ_ENABLED))
6804 + lpfc_post_buffer(phba,
6805 + pring,
6806 + 1);
6807 + else
6808 + lpfc_in_buf_free(phba,
6809 + dmabuf);
6810 + break;
6811 + default:
6812 + if (!(phba->sli3_options &
6813 + LPFC_SLI3_HBQ_ENABLED))
6814 + lpfc_post_buffer(phba,
6815 + pring,
6816 + 1);
6817 + break;
6818 + }
6819 + }
6820 + }
6821 + }
6822 +
6823 + mutex_lock(&lpfcdfc_lock);
6824 + evt_dat->immed_dat = piocbq->iocb.ulpContext;
6825 + evt_dat->type = FC_REG_CT_EVENT;
6826 + list_add(&evt_dat->node, &evt->events_to_see);
6827 + wake_up_interruptible(&evt->wq);
6828 + lpfcdfc_event_unref(evt);
6829 + if (evt_req_id == SLI_CT_ELX_LOOPBACK)
6830 + break;
6831 + }
6832 + mutex_unlock(&lpfcdfc_lock);
6833 +
6834 +error_unsol_ct_exit:
6835 + if(!list_empty(&head))
6836 + list_del(&head);
6837 + if (evt_req_id != SLI_CT_ELX_LOOPBACK &&
6838 + dfchba->base_ct_unsol_event != NULL)
6839 + (dfchba->base_ct_unsol_event)(phba, pring, piocbq);
6840 +
6841 + return;
6842 +}
6843 +
6844 +
6845 +struct lpfc_dmabufext *
6846 +__dfc_cmd_data_alloc(struct lpfc_hba * phba,
6847 + char *indataptr, struct ulp_bde64 * bpl, uint32_t size,
6848 + int nocopydata)
6849 +{
6850 + struct lpfc_dmabufext *mlist = NULL;
6851 + struct lpfc_dmabufext *dmp;
6852 + int cnt, offset = 0, i = 0;
6853 + struct pci_dev *pcidev;
6854 +
6855 + pcidev = phba->pcidev;
6856 +
6857 + while (size) {
6858 + /* We get chunks of 4K */
6859 + if (size > BUF_SZ_4K)
6860 + cnt = BUF_SZ_4K;
6861 + else
6862 + cnt = size;
6863 +
6864 + /* allocate struct lpfc_dmabufext buffer header */
6865 + dmp = kmalloc(sizeof (struct lpfc_dmabufext), GFP_KERNEL);
6866 + if (dmp == 0)
6867 + goto out;
6868 +
6869 + INIT_LIST_HEAD(&dmp->dma.list);
6870 +
6871 + /* Queue it to a linked list */
6872 + if (mlist)
6873 + list_add_tail(&dmp->dma.list, &mlist->dma.list);
6874 + else
6875 + mlist = dmp;
6876 +
6877 + /* allocate buffer */
6878 + dmp->dma.virt = dma_alloc_coherent(&pcidev->dev,
6879 + cnt,
6880 + &(dmp->dma.phys),
6881 + GFP_KERNEL);
6882 +
6883 + if (dmp->dma.virt == NULL)
6884 + goto out;
6885 +
6886 + dmp->size = cnt;
6887 +
6888 + if (indataptr || nocopydata) {
6889 + if (indataptr)
6890 + /* Copy data from user space in */
6891 + if (copy_from_user ((uint8_t *) dmp->dma.virt,
6892 + (void __user *) (indataptr + offset),
6893 + cnt)) {
6894 + goto out;
6895 + }
6896 +
6897 + pci_dma_sync_single_for_device(phba->pcidev,
6898 + dmp->dma.phys, LPFC_BPL_SIZE, PCI_DMA_TODEVICE);
6899 +
6900 + } else
6901 + memset((uint8_t *)dmp->dma.virt, 0, cnt);
6902 + bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
6903 +
6904 + /* build buffer ptr list for IOCB */
6905 + bpl->addrLow = le32_to_cpu(putPaddrLow(dmp->dma.phys));
6906 + bpl->addrHigh = le32_to_cpu(putPaddrHigh(dmp->dma.phys));
6907 + bpl->tus.f.bdeSize = (ushort) cnt;
6908 + bpl->tus.w = le32_to_cpu(bpl->tus.w);
6909 + bpl++;
6910 +
6911 + i++;
6912 + offset += cnt;
6913 + size -= cnt;
6914 + }
6915 +
6916 + mlist->flag = i;
6917 + return mlist;
6918 +out:
6919 + dfc_cmd_data_free(phba, mlist);
6920 + return NULL;
6921 +}
6922 +
6923 +static struct lpfc_dmabufext *
6924 +dfc_cmd_data_alloc(struct lpfc_hba * phba,
6925 + char *indataptr, struct ulp_bde64 * bpl, uint32_t size)
6926 +{
6927 + /* if indataptr is null it is a rsp buffer. */
6928 + return __dfc_cmd_data_alloc(phba, indataptr, bpl, size,
6929 + 0 /* don't copy user data */);
6930 +}
6931 +
6932 +int
6933 +__dfc_cmd_data_free(struct lpfc_hba * phba, struct lpfc_dmabufext * mlist)
6934 +{
6935 + return dfc_cmd_data_free(phba, mlist);
6936 +}
6937 +static int
6938 +dfc_cmd_data_free(struct lpfc_hba * phba, struct lpfc_dmabufext * mlist)
6939 +{
6940 + struct lpfc_dmabufext *mlast;
6941 + struct pci_dev *pcidev;
6942 + struct list_head head, *curr, *next;
6943 +
6944 + if ((!mlist) || (!lpfc_is_link_up(phba) &&
6945 + (phba->link_flag & LS_LOOPBACK_MODE))) {
6946 + return 0;
6947 + }
6948 +
6949 + pcidev = phba->pcidev;
6950 + list_add_tail(&head, &mlist->dma.list);
6951 +
6952 + list_for_each_safe(curr, next, &head) {
6953 + mlast = list_entry(curr, struct lpfc_dmabufext , dma.list);
6954 + if (mlast->dma.virt)
6955 + dma_free_coherent(&pcidev->dev,
6956 + mlast->size,
6957 + mlast->dma.virt,
6958 + mlast->dma.phys);
6959 + kfree(mlast);
6960 + }
6961 + return 0;
6962 +}
6963 +
6964 +
6965 +/* The only reason we need that reverce find, is because we
6966 + * are bent on keeping original calling conventions.
6967 + */
6968 +static struct lpfcdfc_host *
6969 +lpfcdfc_host_from_hba(struct lpfc_hba * phba)
6970 +{
6971 + struct lpfcdfc_host * dfchba;
6972 +
6973 + mutex_lock(&lpfcdfc_lock);
6974 + list_for_each_entry(dfchba, &lpfcdfc_hosts, node) {
6975 + if (dfchba->phba == phba)
6976 + break;
6977 + }
6978 + mutex_unlock(&lpfcdfc_lock);
6979 +
6980 + return dfchba;
6981 +}
6982 +
6983 +struct lpfcdfc_host *
6984 +lpfcdfc_host_add (struct pci_dev * dev,
6985 + struct Scsi_Host * host,
6986 + struct lpfc_hba * phba)
6987 +{
6988 + struct lpfcdfc_host * dfchba = NULL;
6989 + struct lpfc_sli_ring_mask * prt = NULL;
6990 +
6991 + dfchba = kzalloc(sizeof(*dfchba), GFP_KERNEL);
6992 + if (dfchba == NULL)
6993 + return NULL;
6994 +
6995 + dfchba->inst = phba->brd_no;
6996 + dfchba->phba = phba;
6997 + dfchba->vport = phba->pport;
6998 + dfchba->host = host;
6999 + dfchba->dev = dev;
7000 + dfchba->blocked = 0;
7001 +
7002 + spin_lock_irq(&phba->hbalock);
7003 + prt = phba->sli.ring[LPFC_ELS_RING].prt;
7004 + dfchba->base_ct_unsol_event = prt[2].lpfc_sli_rcv_unsol_event;
7005 + prt[2].lpfc_sli_rcv_unsol_event = lpfcdfc_ct_unsol_event;
7006 + prt[3].lpfc_sli_rcv_unsol_event = lpfcdfc_ct_unsol_event;
7007 + spin_unlock_irq(&phba->hbalock);
7008 + mutex_lock(&lpfcdfc_lock);
7009 + list_add_tail(&dfchba->node, &lpfcdfc_hosts);
7010 + INIT_LIST_HEAD(&dfchba->ev_waiters);
7011 + mutex_unlock(&lpfcdfc_lock);
7012 +
7013 + return dfchba;
7014 +}
7015 +
7016 +
7017 +void
7018 +lpfcdfc_host_del (struct lpfcdfc_host * dfchba)
7019 +{
7020 + struct Scsi_Host * host;
7021 + struct lpfc_hba * phba = NULL;
7022 + struct lpfc_sli_ring_mask * prt = NULL;
7023 + struct lpfcdfc_event * evt;
7024 +
7025 + mutex_lock(&lpfcdfc_lock);
7026 + dfchba->blocked = 1;
7027 +
7028 + list_for_each_entry(evt, &dfchba->ev_waiters, node) {
7029 + wake_up_interruptible(&evt->wq);
7030 + }
7031 +
7032 + while (dfchba->ref_count) {
7033 + mutex_unlock(&lpfcdfc_lock);
7034 + msleep(2000);
7035 + mutex_lock(&lpfcdfc_lock);
7036 + }
7037 +
7038 + if (dfchba->dev->driver) {
7039 + host = pci_get_drvdata(dfchba->dev);
7040 + if ((host != NULL) &&
7041 + (struct lpfc_vport *)host->hostdata == dfchba->vport) {
7042 + phba = dfchba->phba;
7043 + mutex_unlock(&lpfcdfc_lock);
7044 + spin_lock_irq(&phba->hbalock);
7045 + prt = phba->sli.ring[LPFC_ELS_RING].prt;
7046 + prt[2].lpfc_sli_rcv_unsol_event =
7047 + dfchba->base_ct_unsol_event;
7048 + prt[3].lpfc_sli_rcv_unsol_event =
7049 + dfchba->base_ct_unsol_event;
7050 + spin_unlock_irq(&phba->hbalock);
7051 + mutex_lock(&lpfcdfc_lock);
7052 + }
7053 + }
7054 + list_del_init(&dfchba->node);
7055 + mutex_unlock(&lpfcdfc_lock);
7056 + kfree (dfchba);
7057 +}
7058 +
7059 +/*
7060 + * Retrieve lpfc_hba * matching instance (board no)
7061 + * If found return lpfc_hba *
7062 + * If not found return NULL
7063 + */
7064 +static struct lpfcdfc_host *
7065 +lpfcdfc_get_phba_by_inst(int inst)
7066 +{
7067 + struct Scsi_Host * host = NULL;
7068 + struct lpfcdfc_host * dfchba;
7069 +
7070 + mutex_lock(&lpfcdfc_lock);
7071 + list_for_each_entry(dfchba, &lpfcdfc_hosts, node) {
7072 + if (dfchba->inst == inst) {
7073 + if (dfchba->dev->driver) {
7074 + host = pci_get_drvdata(dfchba->dev);
7075 + if ((host != NULL) &&
7076 + (struct lpfc_vport *)host->hostdata ==
7077 + dfchba->vport) {
7078 + mutex_unlock(&lpfcdfc_lock);
7079 + BUG_ON(dfchba->phba->brd_no != inst);
7080 + return dfchba;
7081 + }
7082 + }
7083 + mutex_unlock(&lpfcdfc_lock);
7084 + return NULL;
7085 + }
7086 + }
7087 + mutex_unlock(&lpfcdfc_lock);
7088 +
7089 + return NULL;
7090 +}
7091 +
7092 +static int
7093 +lpfcdfc_do_ioctl(struct lpfcCmdInput *cip)
7094 +{
7095 + struct lpfcdfc_host * dfchba = NULL;
7096 + struct lpfc_hba *phba = NULL;
7097 + int rc;
7098 + uint32_t total_mem;
7099 + void *dataout;
7100 +
7101 +
7102 + /* Some ioctls are per module and do not need phba */
7103 + switch (cip->lpfc_cmd) {
7104 + case LPFC_GET_DFC_REV:
7105 + break;
7106 + default:
7107 + dfchba = lpfcdfc_get_phba_by_inst(cip->lpfc_brd);
7108 + if (dfchba == NULL)
7109 + return EINVAL;
7110 + phba = dfchba->phba;
7111 + break;
7112 + };
7113 +
7114 + if (phba)
7115 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7116 + "1601 libdfc ioctl entry Data: x%x x%lx x%lx x%x\n",
7117 + cip->lpfc_cmd, (unsigned long) cip->lpfc_arg1,
7118 + (unsigned long) cip->lpfc_arg2, cip->lpfc_outsz);
7119 + mutex_lock(&lpfcdfc_lock);
7120 + if (dfchba && dfchba->blocked) {
7121 + mutex_unlock(&lpfcdfc_lock);
7122 + return EINVAL;
7123 + }
7124 + if (dfchba)
7125 + dfchba->ref_count++;
7126 + mutex_unlock(&lpfcdfc_lock);
7127 + if (cip->lpfc_outsz >= BUF_SZ_4K) {
7128 +
7129 + /*
7130 + * Allocate memory for ioctl data. If buffer is bigger than 64k,
7131 + * then we allocate 64k and re-use that buffer over and over to
7132 + * xfer the whole block. This is because Linux kernel has a
7133 + * problem allocating more than 120k of kernel space memory. Saw
7134 + * problem with GET_FCPTARGETMAPPING...
7135 + */
7136 + if (cip->lpfc_outsz <= (64 * 1024))
7137 + total_mem = cip->lpfc_outsz;
7138 + else
7139 + total_mem = 64 * 1024;
7140 + } else {
7141 + /* Allocate memory for ioctl data */
7142 + total_mem = BUF_SZ_4K;
7143 + }
7144 +
7145 + /*
7146 + * For LPFC_HBA_GET_EVENT allocate memory which is needed to store
7147 + * event info. Allocating maximum possible buffer size (64KB) can fail
7148 + * some times under heavy IO.
7149 + */
7150 + if (cip->lpfc_cmd == LPFC_HBA_GET_EVENT) {
7151 + dataout = NULL;
7152 + } else {
7153 + dataout = kmalloc(total_mem, GFP_KERNEL);
7154 +
7155 + if (!dataout && dfchba != NULL) {
7156 + mutex_lock(&lpfcdfc_lock);
7157 + if (dfchba)
7158 + dfchba->ref_count--;
7159 + mutex_unlock(&lpfcdfc_lock);
7160 + return ENOMEM;
7161 + }
7162 + }
7163 +
7164 + switch (cip->lpfc_cmd) {
7165 +
7166 + case LPFC_GET_DFC_REV:
7167 + ((struct DfcRevInfo *) dataout)->a_Major = DFC_MAJOR_REV;
7168 + ((struct DfcRevInfo *) dataout)->a_Minor = DFC_MINOR_REV;
7169 + cip->lpfc_outsz = sizeof (struct DfcRevInfo);
7170 + rc = 0;
7171 + break;
7172 +
7173 + case LPFC_SEND_ELS:
7174 + rc = lpfc_ioctl_send_els(phba, cip, dataout);
7175 + break;
7176 +
7177 + case LPFC_HBA_SEND_MGMT_RSP:
7178 + rc = lpfc_ioctl_send_mgmt_rsp(phba, cip);
7179 + break;
7180 +
7181 + case LPFC_HBA_SEND_MGMT_CMD:
7182 + case LPFC_CT:
7183 + rc = lpfc_ioctl_send_mgmt_cmd(phba, cip, dataout);
7184 + break;
7185 +
7186 + case LPFC_HBA_GET_EVENT:
7187 + rc = lpfc_ioctl_hba_get_event(phba, cip, &dataout, &total_mem);
7188 + if ((total_mem) && (copy_to_user ((void __user *)
7189 + cip->lpfc_dataout, (uint8_t *) dataout, total_mem)))
7190 + rc = EIO;
7191 + /* This is to prevent copy_to_user at end of the function. */
7192 + cip->lpfc_outsz = 0;
7193 + break;
7194 +
7195 + case LPFC_HBA_SET_EVENT:
7196 + rc = lpfc_ioctl_hba_set_event(phba, cip);
7197 + break;
7198 +
7199 + case LPFC_LOOPBACK_MODE:
7200 + rc = lpfc_ioctl_loopback_mode(phba, cip, dataout);
7201 + break;
7202 +
7203 + case LPFC_LOOPBACK_TEST:
7204 + rc = lpfc_ioctl_loopback_test(phba, cip, dataout);
7205 + break;
7206 +
7207 + case LPFC_HBA_RNID:
7208 + rc = lpfc_ioctl_hba_rnid(phba, cip, dataout);
7209 + break;
7210 +
7211 + default:
7212 + rc = EINVAL;
7213 + break;
7214 + }
7215 +
7216 + if (phba)
7217 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7218 + "1602 libdfc ioctl exit Data: x%x x%x x%lx\n",
7219 + rc, cip->lpfc_outsz, (unsigned long) cip->lpfc_dataout);
7220 + /* Copy data to user space config method */
7221 + if (rc == 0) {
7222 + if (cip->lpfc_outsz) {
7223 + if (copy_to_user
7224 + ((void __user *) cip->lpfc_dataout,
7225 + (uint8_t *) dataout, cip->lpfc_outsz)) {
7226 + rc = EIO;
7227 + }
7228 + }
7229 + }
7230 +
7231 + kfree(dataout);
7232 + mutex_lock(&lpfcdfc_lock);
7233 + if (dfchba)
7234 + dfchba->ref_count--;
7235 + mutex_unlock(&lpfcdfc_lock);
7236 +
7237 + return rc;
7238 +}
7239 +
7240 +static int
7241 +lpfcdfc_ioctl(struct inode *inode,
7242 + struct file *file, unsigned int cmd, unsigned long arg)
7243 +{
7244 + int rc;
7245 + struct lpfcCmdInput *ci;
7246 +
7247 + if (!arg)
7248 + return -EINVAL;
7249 +
7250 + ci = (struct lpfcCmdInput *) kmalloc(sizeof (struct lpfcCmdInput),
7251 + GFP_KERNEL);
7252 +
7253 + if (!ci)
7254 + return -ENOMEM;
7255 +
7256 + if ((rc = copy_from_user
7257 + ((uint8_t *) ci, (void __user *) arg,
7258 + sizeof (struct lpfcCmdInput)))) {
7259 + kfree(ci);
7260 + return -EIO;
7261 + }
7262 +
7263 + rc = lpfcdfc_do_ioctl(ci);
7264 +
7265 + kfree(ci);
7266 + return -rc;
7267 +}
7268 +
7269 +#ifdef CONFIG_COMPAT
7270 +static long
7271 +lpfcdfc_compat_ioctl(struct file * file, unsigned int cmd, unsigned long arg)
7272 +{
7273 + struct lpfcCmdInput32 arg32;
7274 + struct lpfcCmdInput arg64;
7275 + int ret;
7276 +
7277 + if(copy_from_user(&arg32, (void __user *)arg,
7278 + sizeof(struct lpfcCmdInput32)))
7279 + return -EFAULT;
7280 +
7281 + arg64.lpfc_brd = arg32.lpfc_brd;
7282 + arg64.lpfc_ring = arg32.lpfc_ring;
7283 + arg64.lpfc_iocb = arg32.lpfc_iocb;
7284 + arg64.lpfc_flag = arg32.lpfc_flag;
7285 + arg64.lpfc_arg1 = (void *)(unsigned long) arg32.lpfc_arg1;
7286 + arg64.lpfc_arg2 = (void *)(unsigned long) arg32.lpfc_arg2;
7287 + arg64.lpfc_arg3 = (void *)(unsigned long) arg32.lpfc_arg3;
7288 + arg64.lpfc_dataout = (void *)(unsigned long) arg32.lpfc_dataout;
7289 + arg64.lpfc_cmd = arg32.lpfc_cmd;
7290 + arg64.lpfc_outsz = arg32.lpfc_outsz;
7291 + arg64.lpfc_arg4 = arg32.lpfc_arg4;
7292 + arg64.lpfc_arg5 = arg32.lpfc_arg5;
7293 +
7294 + ret = lpfcdfc_do_ioctl(&arg64);
7295 +
7296 + arg32.lpfc_brd = arg64.lpfc_brd;
7297 + arg32.lpfc_ring = arg64.lpfc_ring;
7298 + arg32.lpfc_iocb = arg64.lpfc_iocb;
7299 + arg32.lpfc_flag = arg64.lpfc_flag;
7300 + arg32.lpfc_arg1 = (u32)(unsigned long) arg64.lpfc_arg1;
7301 + arg32.lpfc_arg2 = (u32)(unsigned long) arg64.lpfc_arg2;
7302 + arg32.lpfc_arg3 = (u32)(unsigned long) arg64.lpfc_arg3;
7303 + arg32.lpfc_dataout = (u32)(unsigned long) arg64.lpfc_dataout;
7304 + arg32.lpfc_cmd = arg64.lpfc_cmd;
7305 + arg32.lpfc_outsz = arg64.lpfc_outsz;
7306 + arg32.lpfc_arg4 = arg64.lpfc_arg4;
7307 + arg32.lpfc_arg5 = arg64.lpfc_arg5;
7308 +
7309 + if(copy_to_user((void __user *)arg, &arg32,
7310 + sizeof(struct lpfcCmdInput32)))
7311 + return -EFAULT;
7312 +
7313 + return -ret;
7314 +}
7315 +#endif
7316 +
7317 +static struct file_operations lpfc_fops = {
7318 + .owner = THIS_MODULE,
7319 + .ioctl = lpfcdfc_ioctl,
7320 +#ifdef CONFIG_COMPAT
7321 + .compat_ioctl = lpfcdfc_compat_ioctl,
7322 +#endif
7323 +};
7324 +
7325 +int
7326 +lpfc_cdev_init(void)
7327 +{
7328 +
7329 + lpfcdfc_major = register_chrdev(0, LPFC_CHAR_DEV_NAME, &lpfc_fops);
7330 + if (lpfcdfc_major < 0) {
7331 + printk(KERN_ERR "%s:%d Unable to register \"%s\" device.\n",
7332 + __func__, __LINE__, LPFC_CHAR_DEV_NAME);
7333 + return lpfcdfc_major;
7334 + }
7335 +
7336 + return 0;
7337 +}
7338 +
7339 +void
7340 +lpfc_cdev_exit(void)
7341 +{
7342 + unregister_chrdev(lpfcdfc_major, LPFC_CHAR_DEV_NAME);
7343 +}
7344 --- /dev/null
7345 +++ b/drivers/scsi/lpfc/lpfc_ioctl.h
7346 @@ -0,0 +1,184 @@
7347 +/*******************************************************************
7348 + * This file is part of the Emulex Linux Device Driver for *
7349 + * Fibre Channel Host Bus Adapters. *
7350 + * Copyright (C) 2006 Emulex. All rights reserved. *
7351 + * EMULEX and SLI are trademarks of Emulex. *
7352 + * www.emulex.com *
7353 + * *
7354 + * This program is free software; you can redistribute it and/or *
7355 + * modify it under the terms of version 2 of the GNU General *
7356 + * Public License as published by the Free Software Foundation. *
7357 + * This program is distributed in the hope that it will be useful. *
7358 + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
7359 + * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
7360 + * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
7361 + * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
7362 + * TO BE LEGALLY INVALID. See the GNU General Public License for *
7363 + * more details, a copy of which can be found in the file COPYING *
7364 + * included with this package. *
7365 + *******************************************************************/
7366 +
7367 +#define DFC_MAJOR_REV 81
7368 +#define DFC_MINOR_REV 0
7369 +
7370 +#define LPFC_MAX_EVENT 128
7371 +
7372 +#define LPFC_CT 0x42 /* Send CT passthru command */
7373 +#define LPFC_HBA_RNID 0x52 /* Send an RNID request */
7374 +#define LPFC_HBA_REFRESHINFO 0x56 /* Do a refresh of the stats */
7375 +#define LPFC_SEND_ELS 0x57 /* Send out an ELS command */
7376 +#define LPFC_HBA_SET_EVENT 0x59 /* Set FCP event(s) */
7377 +#define LPFC_HBA_GET_EVENT 0x5a /* Get FCP event(s) */
7378 +#define LPFC_HBA_SEND_MGMT_CMD 0x5b /* Send a management command */
7379 +#define LPFC_HBA_SEND_MGMT_RSP 0x5c /* Send a management response */
7380 +
7381 +#define LPFC_GET_DFC_REV 0x68 /* Get the rev of the ioctl
7382 + driver */
7383 +#define LPFC_LOOPBACK_TEST 0x72 /* Run Loopback test */
7384 +#define LPFC_LOOPBACK_MODE 0x73 /* Enter Loopback mode */
7385 +/* LPFC_LAST_IOCTL_USED 0x73 Last LPFC Ioctl used */
7386 +
7387 +#define INTERNAL_LOOP_BACK 0x1
7388 +#define EXTERNAL_LOOP_BACK 0x2
7389 +
7390 +/* the DfcRevInfo structure */
7391 +struct DfcRevInfo {
7392 + uint32_t a_Major;
7393 + uint32_t a_Minor;
7394 +} ;
7395 +
7396 +#define LPFC_WWPN_TYPE 0
7397 +#define LPFC_PORTID_TYPE 1
7398 +#define LPFC_WWNN_TYPE 2
7399 +
7400 +struct nport_id {
7401 + uint32_t idType; /* 0 - wwpn, 1 - d_id, 2 - wwnn */
7402 + uint32_t d_id;
7403 + uint8_t wwpn[8];
7404 +};
7405 +
7406 +#define LPFC_EVENT_LIP_OCCURRED 1
7407 +#define LPFC_EVENT_LINK_UP 2
7408 +#define LPFC_EVENT_LINK_DOWN 3
7409 +#define LPFC_EVENT_LIP_RESET_OCCURRED 4
7410 +#define LPFC_EVENT_RSCN 5
7411 +#define LPFC_EVENT_PROPRIETARY 0xFFFF
7412 +
7413 +struct lpfc_hba_event_info {
7414 + uint32_t event_code;
7415 + uint32_t port_id;
7416 + union {
7417 + uint32_t rscn_event_info;
7418 + uint32_t pty_event_info;
7419 + } event;
7420 +};
7421 +
7422 +
7423 +#define LPFC_CHAR_DEV_NAME "lpfcdfc"
7424 +
7425 +/*
7426 + * Diagnostic (DFC) Command & Input structures: (LPFC)
7427 + */
7428 +struct lpfcCmdInput {
7429 + short lpfc_brd;
7430 + short lpfc_ring;
7431 + short lpfc_iocb;
7432 + short lpfc_flag;
7433 + void *lpfc_arg1;
7434 + void *lpfc_arg2;
7435 + void *lpfc_arg3;
7436 + char *lpfc_dataout;
7437 + uint32_t lpfc_cmd;
7438 + uint32_t lpfc_outsz;
7439 + uint32_t lpfc_arg4;
7440 + uint32_t lpfc_arg5;
7441 +};
7442 +/* Used for ioctl command */
7443 +#define LPFC_DFC_CMD_IOCTL_MAGIC 0xFC
7444 +#define LPFC_DFC_CMD_IOCTL _IOWR(LPFC_DFC_CMD_IOCTL_MAGIC, 0x1,\
7445 + struct lpfcCmdInput)
7446 +
7447 +#ifdef CONFIG_COMPAT
7448 +/* 32 bit version */
7449 +struct lpfcCmdInput32 {
7450 + short lpfc_brd;
7451 + short lpfc_ring;
7452 + short lpfc_iocb;
7453 + short lpfc_flag;
7454 + u32 lpfc_arg1;
7455 + u32 lpfc_arg2;
7456 + u32 lpfc_arg3;
7457 + u32 lpfc_dataout;
7458 + uint32_t lpfc_cmd;
7459 + uint32_t lpfc_outsz;
7460 + uint32_t lpfc_arg4;
7461 + uint32_t lpfc_arg5;
7462 +};
7463 +#endif
7464 +
7465 +#define SLI_CT_ELX_LOOPBACK 0x10
7466 +
7467 +enum ELX_LOOPBACK_CMD {
7468 + ELX_LOOPBACK_XRI_SETUP,
7469 + ELX_LOOPBACK_DATA,
7470 +};
7471 +
7472 +
7473 +struct lpfc_link_info {
7474 + uint32_t a_linkEventTag;
7475 + uint32_t a_linkUp;
7476 + uint32_t a_linkDown;
7477 + uint32_t a_linkMulti;
7478 + uint32_t a_DID;
7479 + uint8_t a_topology;
7480 + uint8_t a_linkState;
7481 + uint8_t a_alpa;
7482 + uint8_t a_alpaCnt;
7483 + uint8_t a_alpaMap[128];
7484 + uint8_t a_wwpName[8];
7485 + uint8_t a_wwnName[8];
7486 +};
7487 +
7488 +enum lpfc_host_event_code {
7489 + LPFCH_EVT_LIP = 0x1,
7490 + LPFCH_EVT_LINKUP = 0x2,
7491 + LPFCH_EVT_LINKDOWN = 0x3,
7492 + LPFCH_EVT_LIPRESET = 0x4,
7493 + LPFCH_EVT_RSCN = 0x5,
7494 + LPFCH_EVT_ADAPTER_CHANGE = 0x103,
7495 + LPFCH_EVT_PORT_UNKNOWN = 0x200,
7496 + LPFCH_EVT_PORT_OFFLINE = 0x201,
7497 + LPFCH_EVT_PORT_ONLINE = 0x202,
7498 + LPFCH_EVT_PORT_FABRIC = 0x204,
7499 + LPFCH_EVT_LINK_UNKNOWN = 0x500,
7500 + LPFCH_EVT_VENDOR_UNIQUE = 0xffff,
7501 +};
7502 +
7503 +#define ELX_LOOPBACK_HEADER_SZ \
7504 + (size_t)(&((struct lpfc_sli_ct_request *)NULL)->un)
7505 +
7506 +struct lpfc_host_event {
7507 + uint32_t seq_num;
7508 + enum lpfc_host_event_code event_code;
7509 + uint32_t data;
7510 +};
7511 +
7512 +struct lpfc_timedout_iocb_ctxt {
7513 + struct lpfc_iocbq *rspiocbq;
7514 + struct lpfc_dmabuf *mp;
7515 + struct lpfc_dmabuf *bmp;
7516 + struct lpfc_scsi_buf *lpfc_cmd;
7517 + struct lpfc_dmabufext *outdmp;
7518 + struct lpfc_dmabufext *indmp;
7519 +};
7520 +
7521 +#ifdef __KERNEL__
7522 +struct lpfcdfc_host;
7523 +
7524 +/* Initialize/Un-initialize char device */
7525 +int lpfc_cdev_init(void);
7526 +void lpfc_cdev_exit(void);
7527 +void lpfcdfc_host_del(struct lpfcdfc_host *);
7528 +struct lpfcdfc_host *lpfcdfc_host_add(struct pci_dev *, struct Scsi_Host *,
7529 + struct lpfc_hba *);
7530 +#endif /* __KERNEL__ */
7531 --- a/drivers/scsi/lpfc/lpfc_logmsg.h
7532 +++ b/drivers/scsi/lpfc/lpfc_logmsg.h
7533 @@ -32,6 +32,7 @@
7534 #define LOG_FCP_ERROR 0x1000 /* log errors, not underruns */
7535 #define LOG_LIBDFC 0x2000 /* Libdfc events */
7536 #define LOG_VPORT 0x4000 /* NPIV events */
7537 +#define LOG_SECURITY 0x8000 /* FC Security */
7538 #define LOG_ALL_MSG 0xffff /* LOG all messages */
7539
7540 #define lpfc_printf_vlog(vport, level, mask, fmt, arg...) \
7541 --- a/drivers/scsi/lpfc/lpfc_mbox.c
7542 +++ b/drivers/scsi/lpfc/lpfc_mbox.c
7543 @@ -1083,7 +1083,7 @@ lpfc_config_port(struct lpfc_hba *phba,
7544 phba->pcb->feature = FEATURE_INITIAL_SLI2;
7545
7546 /* Setup Mailbox pointers */
7547 - phba->pcb->mailBoxSize = sizeof(MAILBOX_t);
7548 + phba->pcb->mailBoxSize = sizeof(MAILBOX_t) + MAILBOX_EXT_SIZE;
7549 offset = (uint8_t *)phba->mbox - (uint8_t *)phba->slim2p.virt;
7550 pdma_addr = phba->slim2p.phys + offset;
7551 phba->pcb->mbAddrHigh = putPaddrHigh(pdma_addr);
7552 --- /dev/null
7553 +++ b/drivers/scsi/lpfc/lpfc_menlo.c
7554 @@ -0,0 +1,1174 @@
7555 +/*******************************************************************
7556 + * This file is part of the Emulex Linux Device Driver for *
7557 + * Fibre Channel Host Bus Adapters. *
7558 + * Copyright (C) 2007-2008 Emulex. All rights reserved. *
7559 + * EMULEX and SLI are trademarks of Emulex. *
7560 + * www.emulex.com *
7561 + * *
7562 + * This program is free software; you can redistribute it and/or *
7563 + * modify it under the terms of version 2 of the GNU General *
7564 + * Public License as published by the Free Software Foundation. *
7565 + * This program is distributed in the hope that it will be useful. *
7566 + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
7567 + * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
7568 + * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
7569 + * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
7570 + * TO BE LEGALLY INVALID. See the GNU General Public License for *
7571 + * more details, a copy of which can be found in the file COPYING *
7572 + * included with this package. *
7573 + *******************************************************************/
7574 +
7575 +#include <linux/ctype.h>
7576 +#include <linux/delay.h>
7577 +#include <linux/pci.h>
7578 +#include <linux/interrupt.h>
7579 +
7580 +#include <scsi/scsi.h>
7581 +#include <scsi/scsi_device.h>
7582 +#include <scsi/scsi_host.h>
7583 +#include <scsi/scsi_tcq.h>
7584 +#include <scsi/scsi_transport_fc.h>
7585 +
7586 +#include "lpfc_hw.h"
7587 +#include "lpfc_sli.h"
7588 +#include "lpfc_nl.h"
7589 +#include "lpfc_disc.h"
7590 +#include "lpfc_scsi.h"
7591 +#include "lpfc.h"
7592 +#include "lpfc_logmsg.h"
7593 +#include "lpfc_version.h"
7594 +#include "lpfc_compat.h"
7595 +#include "lpfc_crtn.h"
7596 +#include "lpfc_vport.h"
7597 +
7598 +#define MENLO_CMD_FW_DOWNLOAD 0x00000002
7599 +
7600 +static void lpfc_menlo_iocb_timeout_cmpl(struct lpfc_hba *,
7601 + struct lpfc_iocbq *, struct lpfc_iocbq *);
7602 +
7603 +extern int
7604 +__dfc_cmd_data_free(struct lpfc_hba * phba, struct lpfc_dmabufext * mlist);
7605 +
7606 +extern struct lpfc_dmabufext *
7607 +__dfc_cmd_data_alloc(struct lpfc_hba * phba,
7608 + char *indataptr, struct ulp_bde64 * bpl, uint32_t size,
7609 + int nocopydata);
7610 +/*
7611 + * The size for the menlo interface is set at 336k because it only uses
7612 + * one bpl. A bpl can contain 85 BDE descriptors. Each BDE can represent
7613 + * up to 4k. I used 84 BDE entries to do this calculation because the
7614 + * 1st sysfs_menlo_write is for just the cmd header which is 12 bytes.
7615 + * size = PAGE_SZ * (sizeof(bpl) / sizeof(BDE)) -1;
7616 + */
7617 +#define SYSFS_MENLO_ATTR_SIZE 344064
7618 +typedef struct menlo_get_cmd
7619 +{
7620 + uint32_t code; /* Command code */
7621 + uint32_t context; /* Context */
7622 + uint32_t length; /* Max response length */
7623 +} menlo_get_cmd_t;
7624 +
7625 +typedef struct menlo_init_rsp
7626 +{
7627 + uint32_t code;
7628 + uint32_t bb_credit; /* Menlo FC BB Credit */
7629 + uint32_t frame_size; /* Menlo FC receive frame size */
7630 + uint32_t fw_version; /* Menlo firmware version */
7631 + uint32_t reset_status; /* Reason for previous reset */
7632 +
7633 +#define MENLO_RESET_STATUS_NORMAL 0
7634 +#define MENLO_RESET_STATUS_PANIC 1
7635 +
7636 + uint32_t maint_status; /* Menlo Maintenance Mode status at link up */
7637 +
7638 +
7639 +#define MENLO_MAINTENANCE_MODE_DISABLE 0
7640 +#define MENLO_MAINTENANCE_MODE_ENABLE 1
7641 + uint32_t fw_type;
7642 + uint32_t fru_data_valid; /* 0=invalid, 1=valid */
7643 +} menlo_init_rsp_t;
7644 +
7645 +#define MENLO_CMD_GET_INIT 0x00000007
7646 +#define MENLO_FW_TYPE_OPERATIONAL 0xABCD0001
7647 +#define MENLO_FW_TYPE_GOLDEN 0xABCD0002
7648 +#define MENLO_FW_TYPE_DIAG 0xABCD0003
7649 +
7650 +void
7651 +BE_swap32_buffer(void *srcp, uint32_t cnt)
7652 +{
7653 + uint32_t *src = srcp;
7654 + uint32_t *dest = srcp;
7655 + uint32_t ldata;
7656 + int i;
7657 +
7658 + for (i = 0; i < (int)cnt; i += sizeof (uint32_t)) {
7659 + ldata = *src;
7660 + ldata = cpu_to_le32(ldata);
7661 + *dest = ldata;
7662 + src++;
7663 + dest++;
7664 + }
7665 +}
7666 +
7667 +
7668 +static int
7669 +lpfc_alloc_menlo_genrequest64(struct lpfc_hba * phba,
7670 + struct lpfc_menlo_genreq64 *sysfs_menlo,
7671 + struct lpfc_sysfs_menlo_hdr *cmdhdr)
7672 +{
7673 + struct Scsi_Host *shost = lpfc_shost_from_vport(phba->pport);
7674 + struct ulp_bde64 *bpl = NULL;
7675 + IOCB_t *cmd = NULL, *rsp = NULL;
7676 + struct lpfc_sli *psli = NULL;
7677 + struct lpfc_sli_ring *pring = NULL;
7678 + int rc = 0;
7679 + uint32_t cmdsize;
7680 + uint32_t rspsize;
7681 +
7682 + psli = &phba->sli;
7683 + pring = &psli->ring[LPFC_ELS_RING];
7684 +
7685 + if (!(psli->sli_flag & LPFC_SLI2_ACTIVE)) {
7686 + rc = EACCES;
7687 + goto send_menlomgmt_cmd_exit;
7688 + }
7689 +
7690 + if (!sysfs_menlo) {
7691 + rc = EINVAL;
7692 + goto send_menlomgmt_cmd_exit;
7693 + }
7694 +
7695 + cmdsize = cmdhdr->cmdsize;
7696 + rspsize = cmdhdr->rspsize;
7697 +
7698 + if (!cmdsize || !rspsize || (cmdsize + rspsize > 80 * BUF_SZ_4K)) {
7699 + rc = ERANGE;
7700 + goto send_menlomgmt_cmd_exit;
7701 + }
7702 +
7703 + spin_lock_irq(shost->host_lock);
7704 + sysfs_menlo->cmdiocbq = lpfc_sli_get_iocbq(phba);
7705 + if (!sysfs_menlo->cmdiocbq) {
7706 + rc = ENOMEM;
7707 + spin_unlock_irq(shost->host_lock);
7708 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7709 + "1202 alloc_menlo_genreq64: couldn't alloc cmdiocbq\n");
7710 + goto send_menlomgmt_cmd_exit;
7711 + }
7712 + cmd = &sysfs_menlo->cmdiocbq->iocb;
7713 +
7714 + sysfs_menlo->rspiocbq = lpfc_sli_get_iocbq(phba);
7715 + if (!sysfs_menlo->rspiocbq) {
7716 + rc = ENOMEM;
7717 + spin_unlock_irq(shost->host_lock);
7718 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7719 + "1203 alloc_menlo_genreq64: couldn't alloc rspiocbq\n");
7720 + goto send_menlomgmt_cmd_exit;
7721 + }
7722 + spin_unlock_irq(shost->host_lock);
7723 +
7724 + rsp = &sysfs_menlo->rspiocbq->iocb;
7725 +
7726 +
7727 + sysfs_menlo->bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
7728 + if (!sysfs_menlo->bmp) {
7729 + rc = ENOMEM;
7730 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7731 + "1204 alloc_menlo_genreq64: couldn't alloc bmp\n");
7732 + goto send_menlomgmt_cmd_exit;
7733 + }
7734 +
7735 + spin_lock_irq(shost->host_lock);
7736 + sysfs_menlo->bmp->virt = lpfc_mbuf_alloc(phba, 0,
7737 + &sysfs_menlo->bmp->phys);
7738 + if (!sysfs_menlo->bmp->virt) {
7739 + rc = ENOMEM;
7740 + spin_unlock_irq(shost->host_lock);
7741 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7742 + "1205 alloc_menlo_genreq64: couldn't alloc bpl\n");
7743 + goto send_menlomgmt_cmd_exit;
7744 + }
7745 + spin_unlock_irq(shost->host_lock);
7746 +
7747 + INIT_LIST_HEAD(&sysfs_menlo->bmp->list);
7748 + bpl = (struct ulp_bde64 *) sysfs_menlo->bmp->virt;
7749 + memset((uint8_t*)bpl, 0 , 1024);
7750 + sysfs_menlo->indmp = __dfc_cmd_data_alloc(phba, NULL, bpl, cmdsize, 1);
7751 + if (!sysfs_menlo->indmp) {
7752 + rc = ENOMEM;
7753 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7754 + "1206 alloc_menlo_genreq64: couldn't alloc cmdbuf\n");
7755 + goto send_menlomgmt_cmd_exit;
7756 + }
7757 + sysfs_menlo->cmdbpl = bpl;
7758 + INIT_LIST_HEAD(&sysfs_menlo->inhead);
7759 + list_add_tail(&sysfs_menlo->inhead, &sysfs_menlo->indmp->dma.list);
7760 +
7761 + /* flag contains total number of BPLs for xmit */
7762 +
7763 + bpl += sysfs_menlo->indmp->flag;
7764 +
7765 + sysfs_menlo->outdmp = __dfc_cmd_data_alloc(phba, NULL, bpl, rspsize, 0);
7766 + if (!sysfs_menlo->outdmp) {
7767 + rc = ENOMEM;
7768 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7769 + "1207 alloc_menlo_genreq64: couldn't alloc rspbuf\n");
7770 + goto send_menlomgmt_cmd_exit;
7771 + }
7772 + INIT_LIST_HEAD(&sysfs_menlo->outhead);
7773 + list_add_tail(&sysfs_menlo->outhead, &sysfs_menlo->outdmp->dma.list);
7774 +
7775 + cmd->un.genreq64.bdl.ulpIoTag32 = 0;
7776 + cmd->un.genreq64.bdl.addrHigh = putPaddrHigh(sysfs_menlo->bmp->phys);
7777 + cmd->un.genreq64.bdl.addrLow = putPaddrLow(sysfs_menlo->bmp->phys);
7778 + cmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
7779 + cmd->un.genreq64.bdl.bdeSize =
7780 + (sysfs_menlo->outdmp->flag + sysfs_menlo->indmp->flag)
7781 + * sizeof(struct ulp_bde64);
7782 + cmd->ulpCommand = CMD_GEN_REQUEST64_CR;
7783 + cmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
7784 + cmd->un.genreq64.w5.hcsw.Dfctl = 0;
7785 + cmd->un.genreq64.w5.hcsw.Rctl = FC_FCP_CMND;
7786 + cmd->un.genreq64.w5.hcsw.Type = MENLO_TRANSPORT_TYPE; /* 0xfe */
7787 + cmd->un.ulpWord[4] = MENLO_DID; /* 0x0000FC0E */
7788 + cmd->ulpBdeCount = 1;
7789 + cmd->ulpClass = CLASS3;
7790 + cmd->ulpContext = MENLO_CONTEXT; /* 0 */
7791 + cmd->ulpOwner = OWN_CHIP;
7792 + cmd->ulpPU = MENLO_PU; /* 3 */
7793 + cmd->ulpLe = 1; /* Limited Edition */
7794 + sysfs_menlo->cmdiocbq->vport = phba->pport;
7795 + sysfs_menlo->cmdiocbq->context1 = NULL;
7796 + sysfs_menlo->cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
7797 + /* We want the firmware to timeout before we do */
7798 + cmd->ulpTimeout = MENLO_TIMEOUT - 5;
7799 +
7800 + sysfs_menlo->timeout = cmd->ulpTimeout;
7801 +
7802 +send_menlomgmt_cmd_exit:
7803 + return rc;
7804 +}
7805 +
7806 +void
7807 +sysfs_menlo_genreq_free(struct lpfc_hba *phba,
7808 + struct lpfc_menlo_genreq64 *sysfs_menlo)
7809 +{
7810 + if ( !list_empty(&sysfs_menlo->outhead))
7811 + list_del_init( &sysfs_menlo->outhead);
7812 +
7813 + if (!list_empty(&sysfs_menlo->inhead))
7814 + list_del_init( &sysfs_menlo->inhead);
7815 +
7816 + if (sysfs_menlo->outdmp) {
7817 + __dfc_cmd_data_free(phba, sysfs_menlo->outdmp);
7818 + sysfs_menlo->outdmp = NULL;
7819 + }
7820 + if (sysfs_menlo->indmp) {
7821 + __dfc_cmd_data_free(phba, sysfs_menlo->indmp);
7822 + sysfs_menlo->indmp = NULL;
7823 + }
7824 + if (sysfs_menlo->bmp) {
7825 + lpfc_mbuf_free(phba, sysfs_menlo->bmp->virt,
7826 + sysfs_menlo->bmp->phys);
7827 + kfree(sysfs_menlo->bmp);
7828 + sysfs_menlo->bmp = NULL;
7829 + }
7830 + if (sysfs_menlo->rspiocbq) {
7831 + lpfc_sli_release_iocbq(phba, sysfs_menlo->rspiocbq);
7832 + sysfs_menlo->rspiocbq = NULL;
7833 + }
7834 +
7835 + if (sysfs_menlo->cmdiocbq) {
7836 + lpfc_sli_release_iocbq(phba, sysfs_menlo->cmdiocbq);
7837 + sysfs_menlo->cmdiocbq = NULL;
7838 + }
7839 +}
7840 +
7841 +static void
7842 +sysfs_menlo_idle(struct lpfc_hba *phba,
7843 + struct lpfc_sysfs_menlo *sysfs_menlo)
7844 +{
7845 + struct Scsi_Host *shost = lpfc_shost_from_vport(phba->pport);
7846 +
7847 + spin_lock_irq(&phba->hbalock);
7848 + list_del_init(&sysfs_menlo->list);
7849 + spin_unlock_irq(&phba->hbalock);
7850 + spin_lock_irq(shost->host_lock);
7851 +
7852 + if (sysfs_menlo->cr.cmdiocbq)
7853 + sysfs_menlo_genreq_free(phba, &sysfs_menlo->cr);
7854 + if (sysfs_menlo->cx.cmdiocbq)
7855 + sysfs_menlo_genreq_free(phba, &sysfs_menlo->cx);
7856 +
7857 + spin_unlock_irq(shost->host_lock);
7858 + kfree(sysfs_menlo);
7859 +}
7860 +
7861 +static void
7862 +lpfc_menlo_iocb_timeout_cmpl(struct lpfc_hba *phba,
7863 + struct lpfc_iocbq *cmdq,
7864 + struct lpfc_iocbq *rspq)
7865 +{
7866 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7867 + "1241 Menlo IOCB timeout: deleting %p\n",
7868 + cmdq->context3);
7869 + sysfs_menlo_idle(phba, (struct lpfc_sysfs_menlo *)cmdq->context3);
7870 +}
7871 +
7872 +static void
7873 +lpfc_menlo_iocb_cmpl(struct lpfc_hba *phba,
7874 + struct lpfc_iocbq *cmdq,
7875 + struct lpfc_iocbq *rspq)
7876 +{
7877 + struct lpfc_sysfs_menlo * sysfs_menlo =
7878 + (struct lpfc_sysfs_menlo *)cmdq->context2;
7879 + struct lpfc_dmabufext *mlast = NULL;
7880 + IOCB_t *rsp = NULL;
7881 + IOCB_t *cmd = NULL;
7882 + uint32_t * tmpptr = NULL;
7883 + menlo_init_rsp_t *mlorsp = NULL;
7884 +
7885 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7886 + "1254 Menlo IOCB complete: %p\n",
7887 + cmdq->context2);
7888 + rsp = &rspq->iocb;
7889 + cmd = &cmdq->iocb;
7890 + if ( !sysfs_menlo ) {
7891 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7892 + "1255 Menlo IOCB complete:NULL CTX \n");
7893 + return;
7894 + }
7895 + if ( rsp->ulpStatus ) {
7896 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7897 + "1242 iocb async cmpl: ulpStatus 0x%x "
7898 + "ulpWord[4] 0x%x\n",
7899 + rsp->ulpStatus, rsp->un.ulpWord[4]);
7900 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7901 + "1260 cr:%.08x %.08x %.08x %.08x "
7902 + "%.08x %.08x %.08x %.08x\n",
7903 + cmd->un.ulpWord[0], cmd->un.ulpWord[1],
7904 + cmd->un.ulpWord[2], cmd->un.ulpWord[3],
7905 + cmd->un.ulpWord[4], cmd->un.ulpWord[5],
7906 + *(uint32_t *)&cmd->un1, *((uint32_t *)&cmd->un1 + 1));
7907 + mlast = list_get_first(&sysfs_menlo->cr.inhead,
7908 + struct lpfc_dmabufext,
7909 + dma.list);
7910 + if (!mlast) {
7911 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
7912 + "1231 bad bpl:\n");
7913 + goto lpfc_menlo_iocb_cmpl_ext;
7914 + }
7915 + tmpptr = ( uint32_t *) mlast->dma.virt;
7916 + BE_swap32_buffer ((uint8_t *) tmpptr,
7917 + sizeof( menlo_get_cmd_t));
7918 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7919 + "1261 cmd:%.08x %.08x %.08x\n",
7920 + *tmpptr, *(tmpptr+1), *(tmpptr+2));
7921 + goto lpfc_menlo_iocb_cmpl_ext;
7922 + }
7923 +
7924 + mlast = list_get_first(&sysfs_menlo->cr.outhead,
7925 + struct lpfc_dmabufext,
7926 + dma.list);
7927 + if (!mlast) {
7928 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
7929 + "1256 bad bpl:\n");
7930 + goto lpfc_menlo_iocb_cmpl_ext;
7931 + }
7932 + mlorsp = ( menlo_init_rsp_t *) mlast->dma.virt;
7933 + BE_swap32_buffer ((uint8_t *) mlorsp,
7934 + sizeof( menlo_init_rsp_t));
7935 +
7936 + if (mlorsp->code != 0) {
7937 + lpfc_printf_log (phba, KERN_ERR, LOG_LINK_EVENT,
7938 + "1243 Menlo command error. code=%d.\n", mlorsp->code);
7939 + goto lpfc_menlo_iocb_cmpl_ext;
7940 +
7941 + }
7942 +
7943 + switch (mlorsp->fw_type)
7944 + {
7945 + case MENLO_FW_TYPE_OPERATIONAL: /* Menlo Operational */
7946 + break;
7947 + case MENLO_FW_TYPE_GOLDEN: /* Menlo Golden */
7948 + lpfc_printf_log (phba, KERN_ERR, LOG_LINK_EVENT,
7949 + "1246 FCoE chip is running golden firmware. "
7950 + "Update FCoE chip firmware immediately %x\n",
7951 + mlorsp->fw_type);
7952 + break;
7953 + case MENLO_FW_TYPE_DIAG: /* Menlo Diag */
7954 + lpfc_printf_log (phba, KERN_ERR, LOG_LINK_EVENT,
7955 + "1247 FCoE chip is running diagnostic "
7956 + "firmware. Operational use suspended. %x\n",
7957 + mlorsp->fw_type);
7958 + break;
7959 + default:
7960 + lpfc_printf_log (phba, KERN_ERR, LOG_LINK_EVENT,
7961 + "1248 FCoE chip is running unknown "
7962 + "firmware x%x.\n", mlorsp->fw_type);
7963 + break;
7964 + }
7965 + if (!mlorsp->fru_data_valid
7966 + && (mlorsp->fw_type == MENLO_FW_TYPE_OPERATIONAL)
7967 + && (!mlorsp->maint_status))
7968 + lpfc_printf_log (phba, KERN_ERR, LOG_LINK_EVENT,
7969 + "1249 Invalid FRU data found on adapter."
7970 + "Return adapter to Emulex for repair\n");
7971 +
7972 +lpfc_menlo_iocb_cmpl_ext:
7973 + sysfs_menlo_idle(phba, (struct lpfc_sysfs_menlo *)cmdq->context2);
7974 +}
7975 +
7976 +static struct lpfc_sysfs_menlo *
7977 +lpfc_get_sysfs_menlo(struct lpfc_hba *phba, uint8_t create)
7978 +{
7979 + struct lpfc_sysfs_menlo *sysfs_menlo;
7980 + pid_t pid;
7981 +
7982 + pid = current->pid;
7983 +
7984 + spin_lock_irq(&phba->hbalock);
7985 + list_for_each_entry(sysfs_menlo, &phba->sysfs_menlo_list, list) {
7986 + if (sysfs_menlo->pid == pid) {
7987 + spin_unlock_irq(&phba->hbalock);
7988 + return sysfs_menlo;
7989 + }
7990 + }
7991 + if (!create) {
7992 + spin_unlock_irq(&phba->hbalock);
7993 + return NULL;
7994 + }
7995 + spin_unlock_irq(&phba->hbalock);
7996 + sysfs_menlo = kzalloc(sizeof(struct lpfc_sysfs_menlo),
7997 + GFP_KERNEL);
7998 + if (!sysfs_menlo)
7999 + return NULL;
8000 + sysfs_menlo->state = SMENLO_IDLE;
8001 + sysfs_menlo->pid = pid;
8002 + spin_lock_irq(&phba->hbalock);
8003 + list_add_tail(&sysfs_menlo->list, &phba->sysfs_menlo_list);
8004 +
8005 + spin_unlock_irq(&phba->hbalock);
8006 + return sysfs_menlo;
8007 +
8008 +}
8009 +
8010 +static ssize_t
8011 +lpfc_menlo_write(struct lpfc_hba *phba,
8012 + char *buf, loff_t off, size_t count)
8013 +{
8014 + struct lpfc_sysfs_menlo *sysfs_menlo;
8015 + struct lpfc_dmabufext *mlast = NULL;
8016 + struct lpfc_sysfs_menlo_hdr cmdhdrCR;
8017 + struct lpfc_menlo_genreq64 *genreq = NULL;
8018 + loff_t temp_off = 0;
8019 + struct ulp_bde64 *bpl = NULL;
8020 + int mlastcnt = 0;
8021 + uint32_t * tmpptr = NULL;
8022 + uint32_t addr_high = 0;
8023 + uint32_t addr_low = 0;
8024 + int hdr_offset = sizeof(struct lpfc_sysfs_menlo_hdr);
8025 +
8026 + if (off % 4 || count % 4 || (unsigned long)buf % 4)
8027 + return -EINVAL;
8028 +
8029 + if (count == 0)
8030 + return 0;
8031 +
8032 + if (off == 0) {
8033 + ssize_t rc;
8034 + struct lpfc_sysfs_menlo_hdr *cmdhdr =
8035 + (struct lpfc_sysfs_menlo_hdr *)buf;
8036 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8037 + "1208 menlo_write: cmd %x cmdsz %d rspsz %d\n",
8038 + cmdhdr->cmd, cmdhdr->cmdsize,
8039 + cmdhdr->rspsize);
8040 + if (count != sizeof(struct lpfc_sysfs_menlo_hdr)) {
8041 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
8042 + "1210 Invalid cmd size: cmd %x "
8043 + "cmdsz %d rspsz %d\n",
8044 + cmdhdr->cmd, cmdhdr->cmdsize,
8045 + cmdhdr->rspsize);
8046 + return -EINVAL;
8047 + }
8048 +
8049 + sysfs_menlo = lpfc_get_sysfs_menlo(phba, 1);
8050 + if (!sysfs_menlo)
8051 + return -ENOMEM;
8052 + sysfs_menlo->cmdhdr = *cmdhdr;
8053 + if (cmdhdr->cmd == MENLO_CMD_FW_DOWNLOAD) {
8054 + sysfs_menlo->cmdhdr.cmdsize
8055 + -= sizeof(struct lpfc_sysfs_menlo_hdr);
8056 +
8057 + rc = lpfc_alloc_menlo_genrequest64(phba,
8058 + &sysfs_menlo->cx,
8059 + &sysfs_menlo->cmdhdr);
8060 + if (rc != 0) {
8061 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
8062 + "1211 genreq alloc failed: %d\n",
8063 + (int) rc);
8064 + sysfs_menlo_idle(phba,sysfs_menlo);
8065 + return -ENOMEM;
8066 + }
8067 + cmdhdrCR.cmd = cmdhdr->cmd;
8068 + cmdhdrCR.cmdsize = sizeof(struct lpfc_sysfs_menlo_hdr);
8069 + cmdhdrCR.rspsize = 4;
8070 + } else
8071 + cmdhdrCR = *cmdhdr;
8072 +
8073 + rc = lpfc_alloc_menlo_genrequest64(phba,
8074 + &sysfs_menlo->cr,&cmdhdrCR);
8075 + if (rc != 0) {
8076 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
8077 + "1223 menlo_write: couldn't alloc genreq %d\n",
8078 + (int) rc);
8079 + sysfs_menlo_idle(phba,sysfs_menlo);
8080 + return -ENOMEM;
8081 + }
8082 + } else {
8083 + sysfs_menlo = lpfc_get_sysfs_menlo(phba, 0);
8084 + if (!sysfs_menlo)
8085 + return -EAGAIN;
8086 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8087 + "1212 menlo_write: sysfs_menlo %p cmd %x cmdsz %d"
8088 + " rspsz %d cr-off %d cx-off %d count %d\n",
8089 + sysfs_menlo,
8090 + sysfs_menlo->cmdhdr.cmd,
8091 + sysfs_menlo->cmdhdr.cmdsize,
8092 + sysfs_menlo->cmdhdr.rspsize,
8093 + (int)sysfs_menlo->cr.offset,
8094 + (int)sysfs_menlo->cx.offset,
8095 + (int)count);
8096 + }
8097 +
8098 + if ((count + sysfs_menlo->cr.offset) > sysfs_menlo->cmdhdr.cmdsize) {
8099 + if ( sysfs_menlo->cmdhdr.cmdsize != 4) {
8100 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
8101 + "1213 FCoE cmd overflow: off %d + cnt %d > cmdsz %d\n",
8102 + (int)sysfs_menlo->cr.offset,
8103 + (int)count,
8104 + (int)sysfs_menlo->cmdhdr.cmdsize);
8105 + sysfs_menlo_idle(phba, sysfs_menlo);
8106 + return -ERANGE;
8107 + }
8108 + }
8109 +
8110 + spin_lock_irq(&phba->hbalock);
8111 + if (sysfs_menlo->cmdhdr.cmd == MENLO_CMD_FW_DOWNLOAD)
8112 + genreq = &sysfs_menlo->cx;
8113 + else
8114 + genreq = &sysfs_menlo->cr;
8115 +
8116 + if (off == 0) {
8117 + if (sysfs_menlo->cmdhdr.cmd == MENLO_CMD_FW_DOWNLOAD) {
8118 + tmpptr = NULL;
8119 + genreq = &sysfs_menlo->cr;
8120 +
8121 + if (!mlast) {
8122 + mlast = list_get_first(&genreq->inhead,
8123 + struct lpfc_dmabufext,
8124 + dma.list);
8125 + }
8126 + if (mlast) {
8127 + bpl = genreq->cmdbpl;
8128 + memcpy((uint8_t *) mlast->dma.virt, buf, count);
8129 + genreq->offset += count;
8130 + tmpptr = (uint32_t *)mlast->dma.virt;
8131 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8132 + "1258 cmd %x cmdsz %d rspsz %d "
8133 + "copied %d addrL:%x addrH:%x\n",
8134 + *tmpptr,
8135 + *(tmpptr+1),
8136 + *(tmpptr+2),
8137 + (int)count,
8138 + bpl->addrLow,bpl->addrHigh);
8139 + } else {
8140 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
8141 + "1230 Could not find buffer for FCoE"
8142 + " cmd:off %d indmp %p %d\n", (int)off,
8143 + genreq->indmp,(int)count);
8144 + }
8145 + }
8146 +
8147 + sysfs_menlo->state = SMENLO_WRITING;
8148 + spin_unlock_irq(&phba->hbalock);
8149 + return count;
8150 + } else {
8151 + ssize_t adj_off = off - sizeof(struct lpfc_sysfs_menlo_hdr);
8152 + int found = 0;
8153 + if (sysfs_menlo->state != SMENLO_WRITING ||
8154 + genreq->offset != adj_off) {
8155 + spin_unlock_irq(&phba->hbalock);
8156 + sysfs_menlo_idle(phba, sysfs_menlo);
8157 + return -EAGAIN;
8158 + }
8159 + mlast = NULL;
8160 + temp_off = sizeof(struct lpfc_sysfs_menlo_hdr);
8161 + if (genreq->indmp) {
8162 + list_for_each_entry(mlast,
8163 + &genreq->inhead, dma.list) {
8164 + if (temp_off == off)
8165 + break;
8166 + else
8167 + temp_off += BUF_SZ_4K;
8168 + mlastcnt++;
8169 + }
8170 + }
8171 + addr_low = le32_to_cpu( putPaddrLow(mlast->dma.phys) );
8172 + addr_high = le32_to_cpu( putPaddrHigh(mlast->dma.phys) );
8173 + bpl = genreq->cmdbpl;
8174 + bpl += mlastcnt;
8175 + if (bpl->addrLow != addr_low || bpl->addrHigh != addr_high) {
8176 + mlast = NULL;
8177 + list_for_each_entry(mlast,
8178 + &genreq->inhead, dma.list) {
8179 +
8180 + addr_low = le32_to_cpu(
8181 + putPaddrLow(mlast->dma.phys) );
8182 + addr_high = le32_to_cpu(
8183 + putPaddrHigh(mlast->dma.phys) );
8184 + if (bpl->addrLow == addr_low
8185 + && bpl->addrHigh == addr_high) {
8186 + found = 1;
8187 + break;
8188 + }
8189 + if ( mlastcnt < 3 )
8190 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8191 + "1234 menlo_write: off:%d "
8192 + " mlastcnt:%d addl:%x addl:%x "
8193 + " addrh:%x addrh:%x mlast:%p\n",
8194 + (int)genreq->offset,
8195 + mlastcnt,
8196 + bpl->addrLow,
8197 + addr_low,
8198 + bpl->addrHigh,
8199 + addr_high,mlast);
8200 + }
8201 + } else
8202 + found = 1;
8203 +
8204 + if (!found) {
8205 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
8206 + "1235 Could not find buffer for FCoE"
8207 + " cmd: off:%d poff:%d cnt:%d"
8208 + " mlastcnt:%d addl:%x addh:%x mdsz:%d \n",
8209 + (int)genreq->offset,
8210 + (int)off,
8211 + (int)count,
8212 + mlastcnt,
8213 + bpl->addrLow,
8214 + bpl->addrHigh,
8215 + (int)sysfs_menlo->cmdhdr.cmdsize);
8216 + mlast = NULL;
8217 + }
8218 +
8219 + }
8220 +
8221 + if (mlast) {
8222 + if (sysfs_menlo->cmdhdr.cmd == MENLO_CMD_FW_DOWNLOAD ) {
8223 + bpl = genreq->cmdbpl;
8224 + bpl += mlastcnt;
8225 + tmpptr = (uint32_t *)mlast->dma.virt;
8226 + if ( genreq->offset < hdr_offset ) {
8227 + memcpy((uint8_t *) mlast->dma.virt,
8228 + buf+hdr_offset,
8229 + count-hdr_offset);
8230 + bpl->tus.f.bdeSize = (ushort)count-hdr_offset;
8231 + mlast->size = (ushort)count-hdr_offset;
8232 + } else {
8233 + memcpy((uint8_t *) mlast->dma.virt, buf, count);
8234 + bpl->tus.f.bdeSize = (ushort)count;
8235 + mlast->size = (ushort)count;
8236 + }
8237 + bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
8238 + bpl->tus.w = le32_to_cpu(bpl->tus.w);
8239 +
8240 + } else
8241 + memcpy((uint8_t *) mlast->dma.virt, buf, count);
8242 +
8243 + if (sysfs_menlo->cmdhdr.cmd == MENLO_CMD_FW_DOWNLOAD
8244 + && genreq->offset < hdr_offset) {
8245 + if (sysfs_menlo->cr.indmp
8246 + && sysfs_menlo->cr.indmp->dma.virt) {
8247 + mlast = sysfs_menlo->cr.indmp;
8248 + memcpy((uint8_t *) mlast->dma.virt,
8249 + buf, hdr_offset);
8250 + tmpptr = (uint32_t *)mlast->dma.virt;
8251 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8252 + "1237 cmd %x cmd1 %x cmd2 %x "
8253 + "copied %d\n",
8254 + *tmpptr,
8255 + *(tmpptr+1),
8256 + *(tmpptr+2),
8257 + hdr_offset);
8258 + }
8259 + }
8260 + genreq->offset += count;
8261 + } else {
8262 + spin_unlock_irq(&phba->hbalock);
8263 + sysfs_menlo_idle(phba,sysfs_menlo);
8264 + return -ERANGE;
8265 + }
8266 +
8267 + spin_unlock_irq(&phba->hbalock);
8268 + return count;
8269 +
8270 +}
8271 +
8272 +
8273 +static ssize_t
8274 +sysfs_menlo_write(struct kobject *kobj, struct bin_attribute *bin_attr,
8275 + char *buf, loff_t off, size_t count)
8276 +{
8277 + struct device *dev = container_of(kobj, struct device, kobj);
8278 + struct Scsi_Host *shost = class_to_shost(dev);
8279 + struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
8280 + struct lpfc_hba *phba = vport->phba;
8281 +
8282 + return lpfc_menlo_write(phba, buf, off, count);
8283 +}
8284 +
8285 +
8286 +static ssize_t
8287 +sysfs_menlo_issue_iocb_wait(struct lpfc_hba *phba,
8288 + struct lpfc_menlo_genreq64 *req,
8289 + struct lpfc_sysfs_menlo *sysfs_menlo)
8290 +{
8291 + struct lpfc_sli *psli = NULL;
8292 + struct lpfc_sli_ring *pring = NULL;
8293 + int rc = 0;
8294 + IOCB_t *rsp = NULL;
8295 + struct lpfc_iocbq *cmdiocbq = NULL;
8296 +
8297 + psli = &phba->sli;
8298 + pring = &psli->ring[LPFC_ELS_RING];
8299 + rsp = &req->rspiocbq->iocb;
8300 + cmdiocbq = req->cmdiocbq;
8301 +
8302 + rc = lpfc_sli_issue_iocb_wait(phba, pring, req->cmdiocbq, req->rspiocbq,
8303 + req->timeout);
8304 +
8305 + if (rc == IOCB_TIMEDOUT) {
8306 +
8307 + cmdiocbq->context2 = NULL;
8308 + cmdiocbq->context3 = sysfs_menlo;
8309 + cmdiocbq->iocb_cmpl = lpfc_menlo_iocb_timeout_cmpl;
8310 + lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
8311 + "1227 FCoE IOCB TMO: handler set for %p\n",
8312 + cmdiocbq->context3);
8313 + return -EACCES;
8314 + }
8315 +
8316 + if (rc != IOCB_SUCCESS) {
8317 + rc = -EFAULT;
8318 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
8319 + "1216 FCoE IOCB failed: off %d rc=%d \n",
8320 + (int)req->offset, rc);
8321 + goto sysfs_menlo_issue_iocb_wait_exit;
8322 + }
8323 +
8324 + if (rsp->ulpStatus) {
8325 + if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
8326 + switch (rsp->un.ulpWord[4] & 0xff) {
8327 + case IOERR_SEQUENCE_TIMEOUT:
8328 + rc = -ETIMEDOUT;
8329 + break;
8330 + case IOERR_INVALID_RPI:
8331 + rc = -EFAULT;
8332 + break;
8333 + default:
8334 + rc = -EFAULT;
8335 + break;
8336 + }
8337 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8338 + "1217 mlo_issueIocb:2 off %d rc=%d "
8339 + "ulpWord[4] 0x%x\n",
8340 + (int)req->offset, rc, rsp->un.ulpWord[4]);
8341 + }
8342 + }
8343 +sysfs_menlo_issue_iocb_wait_exit:
8344 + return rc;
8345 +}
8346 +
8347 +
8348 +static ssize_t
8349 +sysfs_menlo_issue_iocb(struct lpfc_hba *phba, struct lpfc_menlo_genreq64 *req,
8350 + struct lpfc_sysfs_menlo *sysfs_menlo)
8351 +{
8352 + struct lpfc_sli *psli = NULL;
8353 + struct lpfc_sli_ring *pring = NULL;
8354 + int rc = 0;
8355 + IOCB_t *rsp = NULL;
8356 + struct lpfc_iocbq *cmdiocbq = NULL;
8357 +
8358 + psli = &phba->sli;
8359 + pring = &psli->ring[LPFC_ELS_RING];
8360 + rsp = &req->rspiocbq->iocb;
8361 + cmdiocbq = req->cmdiocbq;
8362 + cmdiocbq->context2 = sysfs_menlo;
8363 + cmdiocbq->iocb_cmpl = lpfc_menlo_iocb_cmpl;
8364 + lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
8365 + "1257 lpfc_menlo_issue_iocb: handler set for %p\n",
8366 + cmdiocbq->context3);
8367 +
8368 + rc = lpfc_sli_issue_iocb(phba, pring, req->cmdiocbq, 0);
8369 +
8370 + if (rc == IOCB_TIMEDOUT) {
8371 +
8372 + cmdiocbq->context2 = NULL;
8373 + cmdiocbq->context3 = sysfs_menlo;
8374 + cmdiocbq->iocb_cmpl = lpfc_menlo_iocb_timeout_cmpl;
8375 + lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
8376 + "1228 FCoE IOCB TMO: handler set for %p\n",
8377 + cmdiocbq->context3);
8378 + return -EACCES;
8379 + }
8380 +
8381 + if (rc != IOCB_SUCCESS) {
8382 + rc = -EFAULT;
8383 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
8384 + "1238 FCoE IOCB failed: off %d rc=%d \n",
8385 + (int)req->offset, rc);
8386 + goto sysfs_menlo_issue_iocb_exit;
8387 + }
8388 +
8389 + if (rsp->ulpStatus) {
8390 + if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
8391 + switch (rsp->un.ulpWord[4] & 0xff) {
8392 + case IOERR_SEQUENCE_TIMEOUT:
8393 + rc = -ETIMEDOUT;
8394 + break;
8395 + case IOERR_INVALID_RPI:
8396 + rc = -EFAULT;
8397 + break;
8398 + default:
8399 + rc = -EFAULT;
8400 + break;
8401 + }
8402 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8403 + "1239 mlo_issueIocb:2 off %d rc=%d "
8404 + "ulpWord[4] 0x%x\n",
8405 + (int)req->offset, rc, rsp->un.ulpWord[4]);
8406 + }
8407 + }
8408 +sysfs_menlo_issue_iocb_exit:
8409 + return rc;
8410 +}
8411 +
8412 +static ssize_t
8413 +lpfc_menlo_read(struct lpfc_hba *phba, char *buf, loff_t off, size_t count,
8414 + int wait)
8415 +{
8416 + struct lpfc_sli *psli = NULL;
8417 + struct lpfc_sli_ring *pring = NULL;
8418 + int rc = 0;
8419 + struct lpfc_sysfs_menlo *sysfs_menlo;
8420 + struct lpfc_dmabufext *mlast = NULL;
8421 + loff_t temp_off = 0;
8422 + struct lpfc_menlo_genreq64 *genreq = NULL;
8423 + IOCB_t *cmd = NULL, *rsp = NULL;
8424 + uint32_t * uptr = NULL;
8425 +
8426 +
8427 + psli = &phba->sli;
8428 + pring = &psli->ring[LPFC_ELS_RING];
8429 +
8430 + if (off > SYSFS_MENLO_ATTR_SIZE)
8431 + return -ERANGE;
8432 +
8433 + if ((count + off) > SYSFS_MENLO_ATTR_SIZE)
8434 + count = SYSFS_MENLO_ATTR_SIZE - off;
8435 +
8436 + if (off % 4 || count % 4 || (unsigned long)buf % 4)
8437 + return -EINVAL;
8438 +
8439 + if (off && count == 0)
8440 + return 0;
8441 +
8442 + sysfs_menlo = lpfc_get_sysfs_menlo(phba, 0);
8443 +
8444 + if (!sysfs_menlo)
8445 + return -EPERM;
8446 +
8447 + if (!(psli->sli_flag & LPFC_SLI2_ACTIVE)) {
8448 + sysfs_menlo_idle(phba, sysfs_menlo);
8449 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
8450 + "1214 Can not issue FCoE cmd,"
8451 + " SLI not active: off %d rc= -EACCESS\n",
8452 + (int)off);
8453 + return -EACCES;
8454 + }
8455 +
8456 +
8457 + if ((phba->link_state < LPFC_LINK_UP)
8458 + && !(psli->sli_flag & LPFC_MENLO_MAINT)
8459 + && wait) {
8460 + rc = -EPERM;
8461 + lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
8462 + "1215 Can not issue FCoE cmd:"
8463 + " not ready or not in maint mode"
8464 + " off %d rc=%d \n",
8465 + (int)off, rc);
8466 + spin_lock_irq(&phba->hbalock);
8467 + goto lpfc_menlo_read_err_exit;
8468 + }
8469 +
8470 + if (off == 0 && sysfs_menlo->state == SMENLO_WRITING) {
8471 + if (sysfs_menlo->cmdhdr.cmd == MENLO_CMD_FW_DOWNLOAD) {
8472 + spin_lock_irq(&phba->hbalock);
8473 + genreq = &sysfs_menlo->cr;
8474 + spin_unlock_irq(&phba->hbalock);
8475 + }
8476 + if ( wait )
8477 + rc = sysfs_menlo_issue_iocb_wait(phba,
8478 + &sysfs_menlo->cr,
8479 + sysfs_menlo);
8480 + else {
8481 + rc = sysfs_menlo_issue_iocb(phba,
8482 + &sysfs_menlo->cr,
8483 + sysfs_menlo);
8484 + return rc;
8485 + }
8486 +
8487 + spin_lock_irq(&phba->hbalock);
8488 + if (rc < 0) {
8489 + lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
8490 + "1224 FCoE iocb failed: off %d rc=%d \n",
8491 + (int)off, rc);
8492 + if (rc != -EACCES)
8493 + goto lpfc_menlo_read_err_exit;
8494 + else {
8495 + spin_unlock_irq(&phba->hbalock);
8496 + return rc;
8497 + }
8498 + }
8499 +
8500 + if (sysfs_menlo->cmdhdr.cmd == MENLO_CMD_FW_DOWNLOAD) {
8501 + cmd = &sysfs_menlo->cx.cmdiocbq->iocb;
8502 + rsp = &sysfs_menlo->cr.rspiocbq->iocb;
8503 + mlast = list_get_first(&sysfs_menlo->cr.outhead,
8504 + struct lpfc_dmabufext,
8505 + dma.list);
8506 + if ( *((uint32_t *) mlast->dma.virt) != 0 ) {
8507 + memcpy(buf,(uint8_t *) mlast->dma.virt, count);
8508 + goto lpfc_menlo_read_err_exit;
8509 + }
8510 + mlast = NULL;
8511 +
8512 + cmd->ulpCommand = CMD_GEN_REQUEST64_CX;
8513 + cmd->ulpContext = rsp->ulpContext;
8514 + cmd->ulpPU = 1; /* RelOffset */
8515 + cmd->un.ulpWord[4] = 0; /* offset 0 */
8516 +
8517 + spin_unlock_irq(&phba->hbalock);
8518 + rc = sysfs_menlo_issue_iocb_wait(phba, &sysfs_menlo->cx,
8519 + sysfs_menlo);
8520 + spin_lock_irq(&phba->hbalock);
8521 + if (rc < 0) {
8522 + uptr = (uint32_t *) rsp;
8523 +
8524 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8525 + "1225 menlo_read: off %d rc=%d "
8526 + "rspxri %d cmdxri %d \n",
8527 + (int)off, rc, rsp->ulpContext,
8528 + cmd->ulpContext);
8529 + uptr = (uint32_t *)
8530 + &sysfs_menlo->cr.cmdiocbq->iocb;
8531 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8532 + "1236 cr:%.08x %.08x %.08x %.08x "
8533 + "%.08x %.08x %.08x %.08x %.08x\n",
8534 + *uptr, *(uptr+1), *(uptr+2),
8535 + *(uptr+3), *(uptr+4), *(uptr+5),
8536 + *(uptr+6), *(uptr+7), *(uptr+8));
8537 + uptr = (uint32_t *)rsp;
8538 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8539 + "1232 cr-rsp:%.08x %.08x %.08x %.08x "
8540 + "%.08x %.08x %.08x %.08x %.08x\n",
8541 + *uptr, *(uptr+1), *(uptr+2),
8542 + *(uptr+3), *(uptr+4), *(uptr+5),
8543 + *(uptr+6), *(uptr+7), *(uptr+8));
8544 + uptr = (uint32_t *)cmd;
8545 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8546 + "1233 cx:%.08x %.08x %.08x %.08x "
8547 + "%.08x %.08x %.08x %.08x %.08x\n",
8548 + *uptr, *(uptr+1), *(uptr+2),
8549 + *(uptr+3), *(uptr+4), *(uptr+5),
8550 + *(uptr+6), *(uptr+7), *(uptr+8));
8551 + if (rc != -EACCES)
8552 + goto lpfc_menlo_read_err_exit;
8553 + else {
8554 + spin_unlock_irq(&phba->hbalock);
8555 + return rc;
8556 + }
8557 + }
8558 + }
8559 + sysfs_menlo->state = SMENLO_READING;
8560 + sysfs_menlo->cr.offset = 0;
8561 +
8562 + } else
8563 + spin_lock_irq(&phba->hbalock);
8564 +
8565 + if (sysfs_menlo->cmdhdr.cmd == MENLO_CMD_FW_DOWNLOAD)
8566 + genreq = &sysfs_menlo->cx;
8567 + else
8568 + genreq = &sysfs_menlo->cr;
8569 +
8570 + /* Copy back response data */
8571 + if (sysfs_menlo->cmdhdr.rspsize > count) {
8572 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8573 + "1218 MloMgnt Rqst err Data: x%x %d %d %d %d\n",
8574 + genreq->outdmp->flag,
8575 + sysfs_menlo->cmdhdr.rspsize,
8576 + (int)count, (int)off, (int)genreq->offset);
8577 + }
8578 +
8579 + if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
8580 + rc = -EAGAIN;
8581 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8582 + "1219 menlo_read:4 off %d rc=%d \n",
8583 + (int)off, rc);
8584 + goto lpfc_menlo_read_err_exit;
8585 + }
8586 + else if ( sysfs_menlo->state != SMENLO_READING) {
8587 + rc = -EAGAIN;
8588 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8589 + "1220 menlo_read:5 off %d reg off %d rc=%d state %x\n",
8590 + (int)off,(int)genreq->offset, sysfs_menlo->state, rc);
8591 + goto lpfc_menlo_read_err_exit;
8592 + }
8593 + temp_off = 0;
8594 + mlast = NULL;
8595 + list_for_each_entry(mlast, &genreq->outhead, dma.list) {
8596 + if (temp_off == off)
8597 + break;
8598 + else
8599 + temp_off += BUF_SZ_4K;
8600 + }
8601 + if (mlast)
8602 + memcpy(buf,(uint8_t *) mlast->dma.virt, count);
8603 + else {
8604 + rc = -ERANGE;
8605 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8606 + "1221 menlo_read:6 off %d rc=%d \n",
8607 + (int)off, rc);
8608 + goto lpfc_menlo_read_err_exit;
8609 + }
8610 + genreq->offset += count;
8611 +
8612 +
8613 + if (genreq->offset >= sysfs_menlo->cmdhdr.rspsize) {
8614 + lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
8615 + "1222 menlo_read: done off %d rc=%d"
8616 + " cnt %d rsp_code %x\n",
8617 + (int)off, rc, (int)count,*((uint32_t *)buf));
8618 + rc = count;
8619 + goto lpfc_menlo_read_err_exit;
8620 + }
8621 +
8622 + if (count >= sysfs_menlo->cmdhdr.rspsize)
8623 + rc = sysfs_menlo->cmdhdr.rspsize;
8624 + else /* Can there be a > 4k response */
8625 + rc = count;
8626 + if (genreq->offset < sysfs_menlo->cmdhdr.rspsize) {
8627 + spin_unlock_irq(&phba->hbalock);
8628 + return rc;
8629 + }
8630 +
8631 +lpfc_menlo_read_err_exit:
8632 + spin_unlock_irq(&phba->hbalock);
8633 + sysfs_menlo_idle(phba,sysfs_menlo);
8634 + return rc;
8635 +}
8636 +
8637 +
8638 +static ssize_t
8639 +sysfs_menlo_read(struct kobject *kobj, struct bin_attribute *bin_attr,
8640 + char *buf, loff_t off, size_t count)
8641 +{
8642 + struct device *dev = container_of(kobj, struct device, kobj);
8643 + struct Scsi_Host *shost = class_to_shost(dev);
8644 + struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
8645 + struct lpfc_hba *phba = vport->phba;
8646 +
8647 + return lpfc_menlo_read(phba, buf, off, count, 1);
8648 +}
8649 +int need_non_blocking = 0;
8650 +void lpfc_check_menlo_cfg(struct lpfc_hba *phba)
8651 +{
8652 + uint32_t cmd_size;
8653 + uint32_t rsp_size;
8654 + menlo_get_cmd_t *cmd = NULL;
8655 + menlo_init_rsp_t *rsp = NULL;
8656 + int rc = 0;
8657 +
8658 + lpfc_printf_log (phba, KERN_INFO, LOG_LINK_EVENT,
8659 + "1253 Checking FCoE chip firmware.\n");
8660 + if ( need_non_blocking ) /* Need non blocking issue_iocb */
8661 + return;
8662 +
8663 + cmd_size = sizeof (menlo_get_cmd_t);
8664 + cmd = kmalloc(cmd_size, GFP_KERNEL);
8665 + if (!cmd ) {
8666 + lpfc_printf_log (phba, KERN_ERR, LOG_LINK_EVENT,
8667 + "1240 Unable to allocate command buffer memory.\n");
8668 + return;
8669 + }
8670 +
8671 + rsp_size = sizeof (menlo_init_rsp_t);
8672 + rsp = kmalloc(rsp_size, GFP_KERNEL);
8673 + if (!rsp ) {
8674 + lpfc_printf_log (phba, KERN_ERR, LOG_LINK_EVENT,
8675 + "1244 Unable to allocate response buffer memory.\n");
8676 + kfree(rsp);
8677 + return;
8678 + }
8679 +
8680 + memset(cmd,0, cmd_size);
8681 + memset(rsp,0, rsp_size);
8682 +
8683 + cmd->code = MENLO_CMD_GET_INIT;
8684 + cmd->context = cmd_size;
8685 + cmd->length = rsp_size;
8686 + rc = lpfc_menlo_write (phba, (char *) cmd, 0, cmd_size);
8687 + if ( rc != cmd_size ) {
8688 + lpfc_printf_log (phba, KERN_ERR, LOG_LINK_EVENT,
8689 + "1250 Menlo command error. code=%d.\n", rc);
8690 +
8691 + kfree (cmd);
8692 + kfree (rsp);
8693 + return;
8694 + }
8695 + cmd->code = MENLO_CMD_GET_INIT;
8696 + cmd->context = 0;
8697 + cmd->length = rsp_size;
8698 + BE_swap32_buffer ((uint8_t *) cmd, cmd_size);
8699 + rc = lpfc_menlo_write (phba, (char *) cmd, cmd_size, cmd_size);
8700 + if ( rc != cmd_size ) {
8701 + lpfc_printf_log (phba, KERN_ERR, LOG_LINK_EVENT,
8702 + "1251 Menlo command error. code=%d.\n", rc);
8703 +
8704 + kfree (cmd);
8705 + kfree (rsp);
8706 + return;
8707 + }
8708 + rc = lpfc_menlo_read (phba, (char *) rsp, 0, rsp_size,0);
8709 + if ( rc && rc != rsp_size ) {
8710 + lpfc_printf_log (phba, KERN_ERR, LOG_LINK_EVENT,
8711 + "1252 Menlo command error. code=%d.\n", rc);
8712 +
8713 + }
8714 + kfree (cmd);
8715 + kfree (rsp);
8716 + return;
8717 +}
8718 +
8719 +struct bin_attribute sysfs_menlo_attr = {
8720 + .attr = {
8721 + .name = "menlo",
8722 + .mode = S_IRUSR | S_IWUSR,
8723 + .owner = THIS_MODULE,
8724 + },
8725 + .size = SYSFS_MENLO_ATTR_SIZE,
8726 + .read = sysfs_menlo_read,
8727 + .write = sysfs_menlo_write,
8728 +};
8729 --- a/drivers/scsi/lpfc/lpfc_scsi.c
8730 +++ b/drivers/scsi/lpfc/lpfc_scsi.c
8731 @@ -42,7 +42,6 @@
8732
8733 #define LPFC_RESET_WAIT 2
8734 #define LPFC_ABORT_WAIT 2
8735 -
8736 /**
8737 * lpfc_update_stats: Update statistical data for the command completion.
8738 * @phba: Pointer to HBA object.
8739 @@ -336,6 +335,22 @@ lpfc_scsi_dev_block(struct lpfc_hba *phb
8740 lpfc_destroy_vport_work_array(phba, vports);
8741 }
8742
8743 +void
8744 +lpfc_scsi_dev_rescan(struct lpfc_hba *phba)
8745 +{
8746 + struct lpfc_vport **vports;
8747 + struct Scsi_Host *shost;
8748 + int i;
8749 +
8750 + vports = lpfc_create_vport_work_array(phba);
8751 + if (vports != NULL)
8752 + for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
8753 + shost = lpfc_shost_from_vport(vports[i]);
8754 + scsi_scan_host(shost);
8755 + }
8756 + lpfc_destroy_vport_work_array(phba, vports);
8757 +}
8758 +
8759 /*
8760 * This routine allocates a scsi buffer, which contains all the necessary
8761 * information needed to initiate a SCSI I/O. The non-DMAable buffer region
8762 @@ -1841,22 +1856,3 @@ struct scsi_host_template lpfc_template
8763 .max_sectors = 0xFFFF,
8764 };
8765
8766 -struct scsi_host_template lpfc_vport_template = {
8767 - .module = THIS_MODULE,
8768 - .name = LPFC_DRIVER_NAME,
8769 - .info = lpfc_info,
8770 - .queuecommand = lpfc_queuecommand,
8771 - .eh_abort_handler = lpfc_abort_handler,
8772 - .eh_device_reset_handler= lpfc_device_reset_handler,
8773 - .eh_bus_reset_handler = lpfc_bus_reset_handler,
8774 - .slave_alloc = lpfc_slave_alloc,
8775 - .slave_configure = lpfc_slave_configure,
8776 - .slave_destroy = lpfc_slave_destroy,
8777 - .scan_finished = lpfc_scan_finished,
8778 - .this_id = -1,
8779 - .sg_tablesize = LPFC_DEFAULT_SG_SEG_CNT,
8780 - .cmd_per_lun = LPFC_CMD_PER_LUN,
8781 - .use_clustering = ENABLE_CLUSTERING,
8782 - .shost_attrs = lpfc_vport_attrs,
8783 - .max_sectors = 0xFFFF,
8784 -};
8785 --- /dev/null
8786 +++ b/drivers/scsi/lpfc/lpfc_security.c
8787 @@ -0,0 +1,339 @@
8788 +/*******************************************************************
8789 + * This file is part of the Emulex Linux Device Driver for *
8790 + * Fibre Channel Host Bus Adapters. *
8791 + * Copyright (C) 2006-2008 Emulex. All rights reserved. *
8792 + * EMULEX and SLI are trademarks of Emulex. *
8793 + * www.emulex.com *
8794 + * *
8795 + * This program is free software; you can redistribute it and/or *
8796 + * modify it under the terms of version 2 of the GNU General *
8797 + * Public License as published by the Free Software Foundation. *
8798 + * This program is distributed in the hope that it will be useful. *
8799 + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
8800 + * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
8801 + * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
8802 + * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
8803 + * TO BE LEGALLY INVALID. See the GNU General Public License for *
8804 + * more details, a copy of which can be found in the file COPYING *
8805 + * included with this package. *
8806 + *******************************************************************/
8807 +
8808 +#include <linux/delay.h>
8809 +#include <linux/pci.h>
8810 +#include <linux/interrupt.h>
8811 +
8812 +#include <scsi/scsi_tcq.h>
8813 +#include <scsi/scsi_transport_fc.h>
8814 +
8815 +#include "lpfc_hw.h"
8816 +#include "lpfc_sli.h"
8817 +#include "lpfc_nl.h"
8818 +#include "lpfc_disc.h"
8819 +#include "lpfc.h"
8820 +#include "lpfc_crtn.h"
8821 +#include "lpfc_logmsg.h"
8822 +#include "lpfc_security.h"
8823 +#include "lpfc_auth_access.h"
8824 +#include "lpfc_vport.h"
8825 +
8826 +uint8_t lpfc_security_service_state = SECURITY_OFFLINE;
8827 +
8828 +void
8829 +lpfc_security_service_online(struct Scsi_Host *shost)
8830 +{
8831 + struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
8832 +
8833 + lpfc_security_service_state = SECURITY_ONLINE;
8834 + if (vport->cfg_enable_auth &&
8835 + vport->auth.auth_mode == FC_AUTHMODE_UNKNOWN &&
8836 + vport->phba->link_state == LPFC_HBA_ERROR)
8837 + lpfc_selective_reset(vport->phba);
8838 +}
8839 +
8840 +void
8841 +lpfc_security_service_offline(struct Scsi_Host *shost)
8842 +{
8843 + lpfc_security_service_state = SECURITY_OFFLINE;
8844 +}
8845 +
8846 +void
8847 +lpfc_security_config(struct Scsi_Host *shost, int status, void *rsp)
8848 +{
8849 + struct fc_auth_rsp *auth_rsp = (struct fc_auth_rsp *)rsp;
8850 + struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
8851 + struct lpfc_nodelist *ndlp;
8852 + uint32_t old_interval, new_interval;
8853 + unsigned long new_jiffies, temp_jiffies;
8854 + uint8_t last_auth_mode;
8855 +
8856 + if (status)
8857 + return;
8858 + ndlp = lpfc_findnode_did(vport, Fabric_DID);
8859 + if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
8860 + return;
8861 +
8862 + vport->auth.bidirectional =
8863 + auth_rsp->u.dhchap_security_config.bidirectional;
8864 + memcpy(&vport->auth.hash_priority[0],
8865 + &auth_rsp->u.dhchap_security_config.hash_priority[0],
8866 + sizeof(vport->auth.hash_priority));
8867 + vport->auth.hash_len = auth_rsp->u.dhchap_security_config.hash_len;
8868 + memcpy(&vport->auth.dh_group_priority[0],
8869 + &auth_rsp->u.dhchap_security_config.
8870 + dh_group_priority[0],
8871 + sizeof(vport->auth.dh_group_priority));
8872 + vport->auth.dh_group_len =
8873 + auth_rsp->u.dhchap_security_config.dh_group_len;
8874 + old_interval = vport->auth.reauth_interval;
8875 + vport->auth.reauth_interval =
8876 + auth_rsp->u.dhchap_security_config.reauth_interval;
8877 + new_interval = vport->auth.reauth_interval;
8878 + /*
8879 + * If interval changed we need to adjust the running timer
8880 + * If enabled then start timer now.
8881 + * If disabled then stop the timer.
8882 + * If changed to chorter then elapsed time, then set to fire now
8883 + * If changed to longer than elapsed time, extend the timer.
8884 + */
8885 + if (old_interval != new_interval &&
8886 + vport->auth.auth_state == LPFC_AUTH_SUCCESS) {
8887 + new_jiffies = msecs_to_jiffies(new_interval * 60000);
8888 + del_timer_sync(&ndlp->nlp_reauth_tmr);
8889 + if (old_interval == 0)
8890 + temp_jiffies = jiffies + new_jiffies;
8891 + if (new_interval == 0)
8892 + temp_jiffies = 0;
8893 + else if (new_jiffies < (jiffies - vport->auth.last_auth))
8894 + temp_jiffies = jiffies + msecs_to_jiffies(1);
8895 + else
8896 + temp_jiffies = jiffies + (new_jiffies -
8897 + (jiffies - vport->auth.last_auth));
8898 + if (temp_jiffies)
8899 + mod_timer(&ndlp->nlp_reauth_tmr, temp_jiffies);
8900 + }
8901 + last_auth_mode = vport->auth.auth_mode;
8902 + vport->auth.auth_mode =
8903 + auth_rsp->u.dhchap_security_config.auth_mode;
8904 + lpfc_printf_vlog(vport, KERN_INFO, LOG_SECURITY,
8905 + "1025 Received security config local_wwpn:"
8906 + "%llX remote_wwpn:%llX \nmode:0x%x "
8907 + "hash(%d):%x:%x:%x:%x bidir:0x%x "
8908 + "dh_group(%d):%x:%x:%x:%x:%x:%x:%x:%x "
8909 + "reauth_interval:0x%x\n",
8910 + (unsigned long long)auth_rsp->local_wwpn,
8911 + (unsigned long long)auth_rsp->remote_wwpn,
8912 + auth_rsp->u.dhchap_security_config.auth_mode,
8913 + auth_rsp->u.dhchap_security_config.hash_len,
8914 + auth_rsp->u.dhchap_security_config.hash_priority[0],
8915 + auth_rsp->u.dhchap_security_config.hash_priority[1],
8916 + auth_rsp->u.dhchap_security_config.hash_priority[2],
8917 + auth_rsp->u.dhchap_security_config.hash_priority[3],
8918 + auth_rsp->u.dhchap_security_config.bidirectional,
8919 + auth_rsp->u.dhchap_security_config.dh_group_len,
8920 + auth_rsp->u.dhchap_security_config.dh_group_priority[0],
8921 + auth_rsp->u.dhchap_security_config.dh_group_priority[1],
8922 + auth_rsp->u.dhchap_security_config.dh_group_priority[2],
8923 + auth_rsp->u.dhchap_security_config.dh_group_priority[3],
8924 + auth_rsp->u.dhchap_security_config.dh_group_priority[4],
8925 + auth_rsp->u.dhchap_security_config.dh_group_priority[5],
8926 + auth_rsp->u.dhchap_security_config.dh_group_priority[6],
8927 + auth_rsp->u.dhchap_security_config.dh_group_priority[7],
8928 + auth_rsp->u.dhchap_security_config.reauth_interval);
8929 + kfree(auth_rsp);
8930 + if (vport->auth.auth_mode == FC_AUTHMODE_ACTIVE)
8931 + vport->auth.security_active = 1;
8932 + else if (vport->auth.auth_mode == FC_AUTHMODE_PASSIVE) {
8933 + if (ndlp->nlp_flag & NLP_SC_REQ)
8934 + vport->auth.security_active = 1;
8935 + else {
8936 + lpfc_printf_vlog(vport, KERN_INFO, LOG_SECURITY,
8937 + "1038 Authentication not "
8938 + "required by the fabric. "
8939 + "Disabled.\n");
8940 + vport->auth.security_active = 0;
8941 + }
8942 + } else {
8943 + vport->auth.security_active = 0;
8944 + /*
8945 + * If switch require authentication and authentication
8946 + * is disabled for this HBA/Fabric port, fail the
8947 + * discovery.
8948 + */
8949 + if (ndlp->nlp_flag & NLP_SC_REQ) {
8950 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
8951 + "1050 Authentication mode is "
8952 + "disabled, but is required by "
8953 + "the fabric.\n");
8954 + lpfc_vport_set_state(vport, FC_VPORT_FAILED);
8955 + /* Cancel discovery timer */
8956 + lpfc_can_disctmo(vport);
8957 + }
8958 + }
8959 + if (last_auth_mode == FC_AUTHMODE_UNKNOWN) {
8960 + if (vport->auth.security_active)
8961 + lpfc_start_authentication(vport, ndlp);
8962 + else
8963 + lpfc_start_discovery(vport);
8964 + }
8965 +}
8966 +
8967 +int
8968 +lpfc_get_security_enabled(struct Scsi_Host *shost)
8969 +{
8970 + struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
8971 +
8972 + return(vport->cfg_enable_auth);
8973 +}
8974 +
8975 +int
8976 +lpfc_security_wait(struct lpfc_hba *phba)
8977 +{
8978 + int i = 0;
8979 + if (lpfc_security_service_state == SECURITY_ONLINE)
8980 + return 0;
8981 + lpfc_printf_log(phba, KERN_WARNING, LOG_SECURITY,
8982 + "1058 Waiting for authentication service...\n");
8983 + while (lpfc_security_service_state == SECURITY_OFFLINE) {
8984 + i++;
8985 + if (i > SECURITY_WAIT_TMO * 2)
8986 + return -ETIMEDOUT;
8987 + /* Delay for half of a second */
8988 + msleep(500);
8989 + }
8990 + lpfc_printf_log(phba, KERN_WARNING, LOG_SECURITY,
8991 + "1059 Authentication service online.\n");
8992 + return 0;
8993 +}
8994 +
8995 +int
8996 +lpfc_security_config_wait(struct lpfc_vport *vport)
8997 +{
8998 + int i = 0;
8999 +
9000 + while (vport->auth.auth_mode == FC_AUTHMODE_UNKNOWN) {
9001 + i++;
9002 + if (i > 120) {
9003 + return -ETIMEDOUT;
9004 + }
9005 + /* Delay for half of a second */
9006 + msleep(500);
9007 + }
9008 + return 0;
9009 +}
9010 +
9011 +void
9012 +lpfc_reauth_node(unsigned long ptr)
9013 +{
9014 + struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) ptr;
9015 + struct lpfc_vport *vport = ndlp->vport;
9016 + struct lpfc_hba *phba = vport->phba;
9017 + unsigned long flags;
9018 + struct lpfc_work_evt *evtp = &ndlp->els_reauth_evt;
9019 +
9020 + ndlp = (struct lpfc_nodelist *) ptr;
9021 + phba = ndlp->vport->phba;
9022 +
9023 + spin_lock_irqsave(&phba->hbalock, flags);
9024 + if (!list_empty(&evtp->evt_listp)) {
9025 + spin_unlock_irqrestore(&phba->hbalock, flags);
9026 + return;
9027 + }
9028 +
9029 + /* We need to hold the node resource by incrementing the reference
9030 + * count until this queued work is done
9031 + */
9032 + evtp->evt_arg1 = lpfc_nlp_get(ndlp);
9033 + if (evtp->evt_arg1) {
9034 + evtp->evt = LPFC_EVT_REAUTH;
9035 + list_add_tail(&evtp->evt_listp, &phba->work_list);
9036 + lpfc_worker_wake_up(phba);
9037 + }
9038 + spin_unlock_irqrestore(&phba->hbalock, flags);
9039 + return;
9040 +}
9041 +
9042 +void
9043 +lpfc_reauthentication_handler(struct lpfc_nodelist *ndlp)
9044 +{
9045 + struct lpfc_vport *vport = ndlp->vport;
9046 + if (vport->auth.auth_msg_state != LPFC_DHCHAP_SUCCESS)
9047 + return;
9048 +
9049 + if (lpfc_start_node_authentication(ndlp)) {
9050 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
9051 + "1029 Reauthentication Failure\n");
9052 + if (vport->auth.auth_state == LPFC_AUTH_SUCCESS)
9053 + lpfc_port_auth_failed(ndlp);
9054 + }
9055 +}
9056 +
9057 +/*
9058 + * This function will kick start authentication for a node.
9059 + * This is used for re-authentication of a node or a user
9060 + * initiated node authentication.
9061 + */
9062 +int
9063 +lpfc_start_node_authentication(struct lpfc_nodelist *ndlp)
9064 +{
9065 + struct lpfc_vport *vport;
9066 + int ret;
9067 +
9068 + vport = ndlp->vport;
9069 + /* If there is authentication timer cancel the timer */
9070 + del_timer_sync(&ndlp->nlp_reauth_tmr);
9071 + ret = lpfc_get_auth_config(ndlp, &ndlp->nlp_portname);
9072 + if (ret)
9073 + return ret;
9074 + ret = lpfc_security_config_wait(vport);
9075 + if (ret) {
9076 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
9077 + "1032 Start Authentication: get config "
9078 + "timed out.\n");
9079 + return ret;
9080 + }
9081 + return 0;
9082 +}
9083 +
9084 +int
9085 +lpfc_get_auth_config(struct lpfc_nodelist *ndlp, struct lpfc_name *rwwn)
9086 +{
9087 + struct lpfc_vport *vport;
9088 + struct fc_auth_req auth_req;
9089 + struct fc_auth_rsp *auth_rsp;
9090 + struct Scsi_Host *shost;
9091 + int ret;
9092 +
9093 + vport = ndlp->vport;
9094 + shost = lpfc_shost_from_vport(vport);
9095 +
9096 + auth_req.local_wwpn = wwn_to_u64(vport->fc_portname.u.wwn);
9097 + if (ndlp->nlp_type & NLP_FABRIC)
9098 + auth_req.remote_wwpn = AUTH_FABRIC_WWN;
9099 + else
9100 + auth_req.remote_wwpn = wwn_to_u64(rwwn->u.wwn);
9101 + if (lpfc_security_service_state == SECURITY_OFFLINE) {
9102 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
9103 + "1053 Start Authentication: "
9104 + "Security service offline.\n");
9105 + return -EINVAL;
9106 + }
9107 + auth_rsp = kmalloc(sizeof(struct fc_auth_rsp), GFP_KERNEL);
9108 + if (!auth_rsp) {
9109 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
9110 + "1028 Start Authentication: No buffers\n");
9111 + return -ENOMEM;
9112 + }
9113 + vport->auth.auth_mode = FC_AUTHMODE_UNKNOWN;
9114 + ret = lpfc_fc_security_get_config(shost, &auth_req,
9115 + sizeof(struct fc_auth_req),
9116 + auth_rsp,
9117 + sizeof(struct fc_auth_rsp));
9118 + if (ret) {
9119 + lpfc_printf_vlog(vport, KERN_ERR, LOG_SECURITY,
9120 + "1031 Start Authentication: Get config "
9121 + "failed.\n");
9122 + kfree(auth_rsp);
9123 + return ret;
9124 + }
9125 + return 0;
9126 +}
9127 --- /dev/null
9128 +++ b/drivers/scsi/lpfc/lpfc_security.h
9129 @@ -0,0 +1,24 @@
9130 +/*******************************************************************
9131 + * This file is part of the Emulex Linux Device Driver for *
9132 + * Fibre Channel Host Bus Adapters. *
9133 + * Copyright (C) 2006-2007 Emulex. All rights reserved. *
9134 + * EMULEX and SLI are trademarks of Emulex. *
9135 + * www.emulex.com *
9136 + * *
9137 + * This program is free software; you can redistribute it and/or *
9138 + * modify it under the terms of version 2 of the GNU General *
9139 + * Public License as published by the Free Software Foundation. *
9140 + * This program is distributed in the hope that it will be useful. *
9141 + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
9142 + * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
9143 + * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
9144 + * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
9145 + * TO BE LEGALLY INVALID. See the GNU General Public License for *
9146 + * more details, a copy of which can be found in the file COPYING *
9147 + * included with this package. *
9148 + *******************************************************************/
9149 +
9150 +#define SECURITY_OFFLINE 0x0
9151 +#define SECURITY_ONLINE 0x1
9152 +
9153 +#define SECURITY_WAIT_TMO 30 /* seconds to wait for the auth service */
9154 --- a/drivers/scsi/lpfc/lpfc_sli.c
9155 +++ b/drivers/scsi/lpfc/lpfc_sli.c
9156 @@ -796,7 +796,7 @@ lpfc_sli_hbq_to_firmware(struct lpfc_hba
9157 hbqe->bde.addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
9158 hbqe->bde.addrLow = le32_to_cpu(putPaddrLow(physaddr));
9159 hbqe->bde.tus.f.bdeSize = hbq_buf->size;
9160 - hbqe->bde.tus.f.bdeFlags = 0;
9161 + hbqe->bde.tus.f.bdeFlags = BUFF_TYPE_BDE_64;
9162 hbqe->bde.tus.w = le32_to_cpu(hbqe->bde.tus.w);
9163 hbqe->buffer_tag = le32_to_cpu(hbq_buf->tag);
9164 /* Sync SLIM */
9165 @@ -1051,6 +1051,9 @@ lpfc_sli_chk_mbx_command(uint8_t mbxComm
9166 case MBX_REG_VPI:
9167 case MBX_UNREG_VPI:
9168 case MBX_HEARTBEAT:
9169 + case MBX_READ_EVENT_LOG_STATUS:
9170 + case MBX_READ_EVENT_LOG:
9171 + case MBX_WRITE_EVENT_LOG:
9172 case MBX_PORT_CAPABILITIES:
9173 case MBX_PORT_IOV_CONTROL:
9174 ret = mbxCommand;
9175 @@ -3546,9 +3549,35 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phb
9176 mb->mbxOwner = OWN_CHIP;
9177
9178 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
9179 - /* First copy command data to host SLIM area */
9180 + /* Populate mbox extension offset word. */
9181 + if (pmbox->in_ext_byte_len || pmbox->out_ext_byte_len) {
9182 + *(((uint32_t *)mb) + pmbox->mbox_offset_word)
9183 + = (uint8_t *)phba->mbox_ext
9184 + - (uint8_t *)phba->mbox;
9185 + }
9186 +
9187 + /* Copy the mailbox extension data */
9188 + if (pmbox->in_ext_byte_len && pmbox->context2) {
9189 + lpfc_sli_pcimem_bcopy(pmbox->context2,
9190 + (uint8_t*)phba->mbox_ext,
9191 + pmbox->in_ext_byte_len);
9192 + }
9193 + /* Copy command data to host SLIM area */
9194 lpfc_sli_pcimem_bcopy(mb, phba->mbox, MAILBOX_CMD_SIZE);
9195 +
9196 } else {
9197 + /* Populate mbox extension offset word. */
9198 + if (pmbox->in_ext_byte_len || pmbox->out_ext_byte_len)
9199 + *(((uint32_t *)mb) + pmbox->mbox_offset_word)
9200 + = MAILBOX_HBA_EXT_OFFSET;
9201 +
9202 + /* Copy the mailbox extension data */
9203 + if (pmbox->in_ext_byte_len && pmbox->context2) {
9204 + lpfc_memcpy_to_slim(phba->MBslimaddr +
9205 + MAILBOX_HBA_EXT_OFFSET,
9206 + pmbox->context2, pmbox->in_ext_byte_len);
9207 +
9208 + }
9209 if (mb->mbxCommand == MBX_CONFIG_PORT) {
9210 /* copy command data into host mbox for cmpl */
9211 lpfc_sli_pcimem_bcopy(mb, phba->mbox, MAILBOX_CMD_SIZE);
9212 @@ -3658,15 +3687,22 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phb
9213 if (psli->sli_flag & LPFC_SLI2_ACTIVE) {
9214 /* copy results back to user */
9215 lpfc_sli_pcimem_bcopy(phba->mbox, mb, MAILBOX_CMD_SIZE);
9216 + /* Copy the mailbox extension data */
9217 + if (pmbox->out_ext_byte_len && pmbox->context2) {
9218 + lpfc_sli_pcimem_bcopy(phba->mbox_ext,
9219 + pmbox->context2,
9220 + pmbox->out_ext_byte_len);
9221 + }
9222 } else {
9223 /* First copy command data */
9224 lpfc_memcpy_from_slim(mb, phba->MBslimaddr,
9225 MAILBOX_CMD_SIZE);
9226 - if ((mb->mbxCommand == MBX_DUMP_MEMORY) &&
9227 - pmbox->context2) {
9228 - lpfc_memcpy_from_slim((void *)pmbox->context2,
9229 - phba->MBslimaddr + DMP_RSP_OFFSET,
9230 - mb->un.varDmp.word_cnt);
9231 + /* Copy the mailbox extension data */
9232 + if (pmbox->out_ext_byte_len && pmbox->context2) {
9233 + lpfc_memcpy_from_slim(pmbox->context2,
9234 + phba->MBslimaddr +
9235 + MAILBOX_HBA_EXT_OFFSET,
9236 + pmbox->out_ext_byte_len);
9237 }
9238 }
9239
9240 @@ -5395,6 +5431,15 @@ lpfc_sp_intr_handler(int irq, void *dev_
9241 if (pmb->mbox_cmpl) {
9242 lpfc_sli_pcimem_bcopy(mbox, pmbox,
9243 MAILBOX_CMD_SIZE);
9244 + /* Copy the mailbox extension data */
9245 + if (pmb->out_ext_byte_len &&
9246 + pmb->context2) {
9247 + lpfc_sli_pcimem_bcopy(
9248 + phba->mbox_ext,
9249 + pmb->context2,
9250 + pmb->out_ext_byte_len);
9251 + }
9252 +
9253 }
9254 if (pmb->mbox_flag & LPFC_MBX_IMED_UNREG) {
9255 pmb->mbox_flag &= ~LPFC_MBX_IMED_UNREG;
9256 --- a/drivers/scsi/lpfc/lpfc_sli.h
9257 +++ b/drivers/scsi/lpfc/lpfc_sli.h
9258 @@ -88,6 +88,9 @@ typedef struct lpfcMboxq {
9259
9260 void (*mbox_cmpl) (struct lpfc_hba *, struct lpfcMboxq *);
9261 uint8_t mbox_flag;
9262 + uint16_t in_ext_byte_len;
9263 + uint16_t out_ext_byte_len;
9264 + uint8_t mbox_offset_word;
9265
9266 } LPFC_MBOXQ_t;
9267
9268 --- a/drivers/scsi/lpfc/lpfc_version.h
9269 +++ b/drivers/scsi/lpfc/lpfc_version.h
9270 @@ -18,7 +18,7 @@
9271 * included with this package. *
9272 *******************************************************************/
9273
9274 -#define LPFC_DRIVER_VERSION "8.2.8"
9275 +#define LPFC_DRIVER_VERSION "8.2.8.1"
9276
9277 #define LPFC_DRIVER_NAME "lpfc"
9278 #define LPFC_SP_DRIVER_HANDLER_NAME "lpfc:sp"
9279 --- a/drivers/scsi/lpfc/lpfc_vport.c
9280 +++ b/drivers/scsi/lpfc/lpfc_vport.c
9281 @@ -42,6 +42,7 @@
9282 #include "lpfc_crtn.h"
9283 #include "lpfc_version.h"
9284 #include "lpfc_vport.h"
9285 +#include "lpfc_auth_access.h"
9286
9287 inline void lpfc_vport_set_state(struct lpfc_vport *vport,
9288 enum fc_vport_state new_state)
9289 @@ -394,6 +395,21 @@ lpfc_vport_create(struct fc_vport *fc_vp
9290 goto error_out;
9291 }
9292
9293 + shost = lpfc_shost_from_vport(vport);
9294 +
9295 + if ((lpfc_get_security_enabled)(shost)) {
9296 + spin_lock_irq(&fc_security_user_lock);
9297 +
9298 + list_add_tail(&vport->sc_users, &fc_security_user_list);
9299 +
9300 + spin_unlock_irq(&fc_security_user_lock);
9301 +
9302 + if (fc_service_state == FC_SC_SERVICESTATE_ONLINE) {
9303 + lpfc_fc_queue_security_work(vport,
9304 + &vport->sc_online_work);
9305 + }
9306 + }
9307 +
9308 *(struct lpfc_vport **)fc_vport->dd_data = vport;
9309 vport->fc_vport = fc_vport;
9310
9311 --- a/drivers/scsi/lpfc/Makefile
9312 +++ b/drivers/scsi/lpfc/Makefile
9313 @@ -1,7 +1,7 @@
9314 #/*******************************************************************
9315 # * This file is part of the Emulex Linux Device Driver for *
9316 # * Fibre Channel Host Bus Adapters. *
9317 -# * Copyright (C) 2004-2006 Emulex. All rights reserved. *
9318 +# * Copyright (C) 2004-2008 Emulex. All rights reserved. *
9319 # * EMULEX and SLI are trademarks of Emulex. *
9320 # * www.emulex.com *
9321 # * *
9322 @@ -28,4 +28,5 @@ obj-$(CONFIG_SCSI_LPFC) := lpfc.o
9323
9324 lpfc-objs := lpfc_mem.o lpfc_sli.o lpfc_ct.o lpfc_els.o lpfc_hbadisc.o \
9325 lpfc_init.o lpfc_mbox.o lpfc_nportdisc.o lpfc_scsi.o lpfc_attr.o \
9326 - lpfc_vport.o lpfc_debugfs.o
9327 + lpfc_vport.o lpfc_debugfs.o lpfc_security.o lpfc_auth_access.o \
9328 + lpfc_auth.o lpfc_ioctl.o lpfc_menlo.o
Peter's tree of IPFire 2.x