GNU Linux-libre 4.19.263-gnu1
[releases.git] / drivers / target / sbp / sbp_target.c
1 /*
2  * SBP2 target driver (SCSI over IEEE1394 in target mode)
3  *
4  * Copyright (C) 2011  Chris Boot <bootc@bootc.net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19  */
20
21 #define KMSG_COMPONENT "sbp_target"
22 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
23
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/types.h>
28 #include <linux/string.h>
29 #include <linux/configfs.h>
30 #include <linux/ctype.h>
31 #include <linux/delay.h>
32 #include <linux/firewire.h>
33 #include <linux/firewire-constants.h>
34 #include <scsi/scsi_proto.h>
35 #include <scsi/scsi_tcq.h>
36 #include <target/target_core_base.h>
37 #include <target/target_core_backend.h>
38 #include <target/target_core_fabric.h>
39 #include <asm/unaligned.h>
40
41 #include "sbp_target.h"
42
43 /* FireWire address region for management and command block address handlers */
44 static const struct fw_address_region sbp_register_region = {
45         .start  = CSR_REGISTER_BASE + 0x10000,
46         .end    = 0x1000000000000ULL,
47 };
48
49 static const u32 sbp_unit_directory_template[] = {
50         0x1200609e, /* unit_specifier_id: NCITS/T10 */
51         0x13010483, /* unit_sw_version: 1155D Rev 4 */
52         0x3800609e, /* command_set_specifier_id: NCITS/T10 */
53         0x390104d8, /* command_set: SPC-2 */
54         0x3b000000, /* command_set_revision: 0 */
55         0x3c000001, /* firmware_revision: 1 */
56 };
57
58 #define SESSION_MAINTENANCE_INTERVAL HZ
59
60 static atomic_t login_id = ATOMIC_INIT(0);
61
62 static void session_maintenance_work(struct work_struct *);
63 static int sbp_run_transaction(struct fw_card *, int, int, int, int,
64                 unsigned long long, void *, size_t);
65
66 static int read_peer_guid(u64 *guid, const struct sbp_management_request *req)
67 {
68         int ret;
69         __be32 high, low;
70
71         ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST,
72                         req->node_addr, req->generation, req->speed,
73                         (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + 3 * 4,
74                         &high, sizeof(high));
75         if (ret != RCODE_COMPLETE)
76                 return ret;
77
78         ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST,
79                         req->node_addr, req->generation, req->speed,
80                         (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + 4 * 4,
81                         &low, sizeof(low));
82         if (ret != RCODE_COMPLETE)
83                 return ret;
84
85         *guid = (u64)be32_to_cpu(high) << 32 | be32_to_cpu(low);
86
87         return RCODE_COMPLETE;
88 }
89
90 static struct sbp_session *sbp_session_find_by_guid(
91         struct sbp_tpg *tpg, u64 guid)
92 {
93         struct se_session *se_sess;
94         struct sbp_session *sess, *found = NULL;
95
96         spin_lock_bh(&tpg->se_tpg.session_lock);
97         list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
98                 sess = se_sess->fabric_sess_ptr;
99                 if (sess->guid == guid)
100                         found = sess;
101         }
102         spin_unlock_bh(&tpg->se_tpg.session_lock);
103
104         return found;
105 }
106
107 static struct sbp_login_descriptor *sbp_login_find_by_lun(
108                 struct sbp_session *session, u32 unpacked_lun)
109 {
110         struct sbp_login_descriptor *login, *found = NULL;
111
112         spin_lock_bh(&session->lock);
113         list_for_each_entry(login, &session->login_list, link) {
114                 if (login->login_lun == unpacked_lun)
115                         found = login;
116         }
117         spin_unlock_bh(&session->lock);
118
119         return found;
120 }
121
122 static int sbp_login_count_all_by_lun(
123                 struct sbp_tpg *tpg,
124                 u32 unpacked_lun,
125                 int exclusive)
126 {
127         struct se_session *se_sess;
128         struct sbp_session *sess;
129         struct sbp_login_descriptor *login;
130         int count = 0;
131
132         spin_lock_bh(&tpg->se_tpg.session_lock);
133         list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
134                 sess = se_sess->fabric_sess_ptr;
135
136                 spin_lock_bh(&sess->lock);
137                 list_for_each_entry(login, &sess->login_list, link) {
138                         if (login->login_lun != unpacked_lun)
139                                 continue;
140
141                         if (!exclusive || login->exclusive)
142                                 count++;
143                 }
144                 spin_unlock_bh(&sess->lock);
145         }
146         spin_unlock_bh(&tpg->se_tpg.session_lock);
147
148         return count;
149 }
150
151 static struct sbp_login_descriptor *sbp_login_find_by_id(
152         struct sbp_tpg *tpg, int login_id)
153 {
154         struct se_session *se_sess;
155         struct sbp_session *sess;
156         struct sbp_login_descriptor *login, *found = NULL;
157
158         spin_lock_bh(&tpg->se_tpg.session_lock);
159         list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
160                 sess = se_sess->fabric_sess_ptr;
161
162                 spin_lock_bh(&sess->lock);
163                 list_for_each_entry(login, &sess->login_list, link) {
164                         if (login->login_id == login_id)
165                                 found = login;
166                 }
167                 spin_unlock_bh(&sess->lock);
168         }
169         spin_unlock_bh(&tpg->se_tpg.session_lock);
170
171         return found;
172 }
173
174 static u32 sbp_get_lun_from_tpg(struct sbp_tpg *tpg, u32 login_lun, int *err)
175 {
176         struct se_portal_group *se_tpg = &tpg->se_tpg;
177         struct se_lun *se_lun;
178
179         rcu_read_lock();
180         hlist_for_each_entry_rcu(se_lun, &se_tpg->tpg_lun_hlist, link) {
181                 if (se_lun->unpacked_lun == login_lun) {
182                         rcu_read_unlock();
183                         *err = 0;
184                         return login_lun;
185                 }
186         }
187         rcu_read_unlock();
188
189         *err = -ENODEV;
190         return login_lun;
191 }
192
193 static struct sbp_session *sbp_session_create(
194                 struct sbp_tpg *tpg,
195                 u64 guid)
196 {
197         struct sbp_session *sess;
198         int ret;
199         char guid_str[17];
200
201         snprintf(guid_str, sizeof(guid_str), "%016llx", guid);
202
203         sess = kmalloc(sizeof(*sess), GFP_KERNEL);
204         if (!sess)
205                 return ERR_PTR(-ENOMEM);
206
207         spin_lock_init(&sess->lock);
208         INIT_LIST_HEAD(&sess->login_list);
209         INIT_DELAYED_WORK(&sess->maint_work, session_maintenance_work);
210         sess->guid = guid;
211
212         sess->se_sess = target_setup_session(&tpg->se_tpg, 128,
213                                              sizeof(struct sbp_target_request),
214                                              TARGET_PROT_NORMAL, guid_str,
215                                              sess, NULL);
216         if (IS_ERR(sess->se_sess)) {
217                 pr_err("failed to init se_session\n");
218                 ret = PTR_ERR(sess->se_sess);
219                 kfree(sess);
220                 return ERR_PTR(ret);
221         }
222
223         return sess;
224 }
225
226 static void sbp_session_release(struct sbp_session *sess, bool cancel_work)
227 {
228         spin_lock_bh(&sess->lock);
229         if (!list_empty(&sess->login_list)) {
230                 spin_unlock_bh(&sess->lock);
231                 return;
232         }
233         spin_unlock_bh(&sess->lock);
234
235         if (cancel_work)
236                 cancel_delayed_work_sync(&sess->maint_work);
237
238         target_remove_session(sess->se_sess);
239
240         if (sess->card)
241                 fw_card_put(sess->card);
242
243         kfree(sess);
244 }
245
246 static void sbp_target_agent_unregister(struct sbp_target_agent *);
247
248 static void sbp_login_release(struct sbp_login_descriptor *login,
249         bool cancel_work)
250 {
251         struct sbp_session *sess = login->sess;
252
253         /* FIXME: abort/wait on tasks */
254
255         sbp_target_agent_unregister(login->tgt_agt);
256
257         if (sess) {
258                 spin_lock_bh(&sess->lock);
259                 list_del(&login->link);
260                 spin_unlock_bh(&sess->lock);
261
262                 sbp_session_release(sess, cancel_work);
263         }
264
265         kfree(login);
266 }
267
268 static struct sbp_target_agent *sbp_target_agent_register(
269         struct sbp_login_descriptor *);
270
271 static void sbp_management_request_login(
272         struct sbp_management_agent *agent, struct sbp_management_request *req,
273         int *status_data_size)
274 {
275         struct sbp_tport *tport = agent->tport;
276         struct sbp_tpg *tpg = tport->tpg;
277         struct sbp_session *sess;
278         struct sbp_login_descriptor *login;
279         struct sbp_login_response_block *response;
280         u64 guid;
281         u32 unpacked_lun;
282         int login_response_len, ret;
283
284         unpacked_lun = sbp_get_lun_from_tpg(tpg,
285                         LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)), &ret);
286         if (ret) {
287                 pr_notice("login to unknown LUN: %d\n",
288                         LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)));
289
290                 req->status.status = cpu_to_be32(
291                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
292                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_LUN_NOTSUPP));
293                 return;
294         }
295
296         ret = read_peer_guid(&guid, req);
297         if (ret != RCODE_COMPLETE) {
298                 pr_warn("failed to read peer GUID: %d\n", ret);
299
300                 req->status.status = cpu_to_be32(
301                         STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
302                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
303                 return;
304         }
305
306         pr_notice("mgt_agent LOGIN to LUN %d from %016llx\n",
307                 unpacked_lun, guid);
308
309         sess = sbp_session_find_by_guid(tpg, guid);
310         if (sess) {
311                 login = sbp_login_find_by_lun(sess, unpacked_lun);
312                 if (login) {
313                         pr_notice("initiator already logged-in\n");
314
315                         /*
316                          * SBP-2 R4 says we should return access denied, but
317                          * that can confuse initiators. Instead we need to
318                          * treat this like a reconnect, but send the login
319                          * response block like a fresh login.
320                          *
321                          * This is required particularly in the case of Apple
322                          * devices booting off the FireWire target, where
323                          * the firmware has an active login to the target. When
324                          * the OS takes control of the session it issues its own
325                          * LOGIN rather than a RECONNECT. To avoid the machine
326                          * waiting until the reconnect_hold expires, we can skip
327                          * the ACCESS_DENIED errors to speed things up.
328                          */
329
330                         goto already_logged_in;
331                 }
332         }
333
334         /*
335          * check exclusive bit in login request
336          * reject with access_denied if any logins present
337          */
338         if (LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc)) &&
339                         sbp_login_count_all_by_lun(tpg, unpacked_lun, 0)) {
340                 pr_warn("refusing exclusive login with other active logins\n");
341
342                 req->status.status = cpu_to_be32(
343                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
344                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
345                 return;
346         }
347
348         /*
349          * check exclusive bit in any existing login descriptor
350          * reject with access_denied if any exclusive logins present
351          */
352         if (sbp_login_count_all_by_lun(tpg, unpacked_lun, 1)) {
353                 pr_warn("refusing login while another exclusive login present\n");
354
355                 req->status.status = cpu_to_be32(
356                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
357                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
358                 return;
359         }
360
361         /*
362          * check we haven't exceeded the number of allowed logins
363          * reject with resources_unavailable if we have
364          */
365         if (sbp_login_count_all_by_lun(tpg, unpacked_lun, 0) >=
366                         tport->max_logins_per_lun) {
367                 pr_warn("max number of logins reached\n");
368
369                 req->status.status = cpu_to_be32(
370                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
371                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
372                 return;
373         }
374
375         if (!sess) {
376                 sess = sbp_session_create(tpg, guid);
377                 if (IS_ERR(sess)) {
378                         switch (PTR_ERR(sess)) {
379                         case -EPERM:
380                                 ret = SBP_STATUS_ACCESS_DENIED;
381                                 break;
382                         default:
383                                 ret = SBP_STATUS_RESOURCES_UNAVAIL;
384                                 break;
385                         }
386
387                         req->status.status = cpu_to_be32(
388                                 STATUS_BLOCK_RESP(
389                                         STATUS_RESP_REQUEST_COMPLETE) |
390                                 STATUS_BLOCK_SBP_STATUS(ret));
391                         return;
392                 }
393
394                 sess->node_id = req->node_addr;
395                 sess->card = fw_card_get(req->card);
396                 sess->generation = req->generation;
397                 sess->speed = req->speed;
398
399                 schedule_delayed_work(&sess->maint_work,
400                                 SESSION_MAINTENANCE_INTERVAL);
401         }
402
403         /* only take the latest reconnect_hold into account */
404         sess->reconnect_hold = min(
405                 1 << LOGIN_ORB_RECONNECT(be32_to_cpu(req->orb.misc)),
406                 tport->max_reconnect_timeout) - 1;
407
408         login = kmalloc(sizeof(*login), GFP_KERNEL);
409         if (!login) {
410                 pr_err("failed to allocate login descriptor\n");
411
412                 sbp_session_release(sess, true);
413
414                 req->status.status = cpu_to_be32(
415                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
416                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
417                 return;
418         }
419
420         login->sess = sess;
421         login->login_lun = unpacked_lun;
422         login->status_fifo_addr = sbp2_pointer_to_addr(&req->orb.status_fifo);
423         login->exclusive = LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc));
424         login->login_id = atomic_inc_return(&login_id);
425
426         login->tgt_agt = sbp_target_agent_register(login);
427         if (IS_ERR(login->tgt_agt)) {
428                 ret = PTR_ERR(login->tgt_agt);
429                 pr_err("failed to map command block handler: %d\n", ret);
430
431                 sbp_session_release(sess, true);
432                 kfree(login);
433
434                 req->status.status = cpu_to_be32(
435                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
436                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
437                 return;
438         }
439
440         spin_lock_bh(&sess->lock);
441         list_add_tail(&login->link, &sess->login_list);
442         spin_unlock_bh(&sess->lock);
443
444 already_logged_in:
445         response = kzalloc(sizeof(*response), GFP_KERNEL);
446         if (!response) {
447                 pr_err("failed to allocate login response block\n");
448
449                 sbp_login_release(login, true);
450
451                 req->status.status = cpu_to_be32(
452                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
453                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
454                 return;
455         }
456
457         login_response_len = clamp_val(
458                         LOGIN_ORB_RESPONSE_LENGTH(be32_to_cpu(req->orb.length)),
459                         12, sizeof(*response));
460         response->misc = cpu_to_be32(
461                 ((login_response_len & 0xffff) << 16) |
462                 (login->login_id & 0xffff));
463         response->reconnect_hold = cpu_to_be32(sess->reconnect_hold & 0xffff);
464         addr_to_sbp2_pointer(login->tgt_agt->handler.offset,
465                 &response->command_block_agent);
466
467         ret = sbp_run_transaction(sess->card, TCODE_WRITE_BLOCK_REQUEST,
468                 sess->node_id, sess->generation, sess->speed,
469                 sbp2_pointer_to_addr(&req->orb.ptr2), response,
470                 login_response_len);
471         if (ret != RCODE_COMPLETE) {
472                 pr_debug("failed to write login response block: %x\n", ret);
473
474                 kfree(response);
475                 sbp_login_release(login, true);
476
477                 req->status.status = cpu_to_be32(
478                         STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
479                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
480                 return;
481         }
482
483         kfree(response);
484
485         req->status.status = cpu_to_be32(
486                 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
487                 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
488 }
489
490 static void sbp_management_request_query_logins(
491         struct sbp_management_agent *agent, struct sbp_management_request *req,
492         int *status_data_size)
493 {
494         pr_notice("QUERY LOGINS not implemented\n");
495         /* FIXME: implement */
496
497         req->status.status = cpu_to_be32(
498                 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
499                 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
500 }
501
502 static void sbp_management_request_reconnect(
503         struct sbp_management_agent *agent, struct sbp_management_request *req,
504         int *status_data_size)
505 {
506         struct sbp_tport *tport = agent->tport;
507         struct sbp_tpg *tpg = tport->tpg;
508         int ret;
509         u64 guid;
510         struct sbp_login_descriptor *login;
511
512         ret = read_peer_guid(&guid, req);
513         if (ret != RCODE_COMPLETE) {
514                 pr_warn("failed to read peer GUID: %d\n", ret);
515
516                 req->status.status = cpu_to_be32(
517                         STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
518                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
519                 return;
520         }
521
522         pr_notice("mgt_agent RECONNECT from %016llx\n", guid);
523
524         login = sbp_login_find_by_id(tpg,
525                 RECONNECT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc)));
526
527         if (!login) {
528                 pr_err("mgt_agent RECONNECT unknown login ID\n");
529
530                 req->status.status = cpu_to_be32(
531                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
532                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
533                 return;
534         }
535
536         if (login->sess->guid != guid) {
537                 pr_err("mgt_agent RECONNECT login GUID doesn't match\n");
538
539                 req->status.status = cpu_to_be32(
540                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
541                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
542                 return;
543         }
544
545         spin_lock_bh(&login->sess->lock);
546         if (login->sess->card)
547                 fw_card_put(login->sess->card);
548
549         /* update the node details */
550         login->sess->generation = req->generation;
551         login->sess->node_id = req->node_addr;
552         login->sess->card = fw_card_get(req->card);
553         login->sess->speed = req->speed;
554         spin_unlock_bh(&login->sess->lock);
555
556         req->status.status = cpu_to_be32(
557                 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
558                 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
559 }
560
561 static void sbp_management_request_logout(
562         struct sbp_management_agent *agent, struct sbp_management_request *req,
563         int *status_data_size)
564 {
565         struct sbp_tport *tport = agent->tport;
566         struct sbp_tpg *tpg = tport->tpg;
567         int id;
568         struct sbp_login_descriptor *login;
569
570         id = LOGOUT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc));
571
572         login = sbp_login_find_by_id(tpg, id);
573         if (!login) {
574                 pr_warn("cannot find login: %d\n", id);
575
576                 req->status.status = cpu_to_be32(
577                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
578                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_LOGIN_ID_UNKNOWN));
579                 return;
580         }
581
582         pr_info("mgt_agent LOGOUT from LUN %d session %d\n",
583                 login->login_lun, login->login_id);
584
585         if (req->node_addr != login->sess->node_id) {
586                 pr_warn("logout from different node ID\n");
587
588                 req->status.status = cpu_to_be32(
589                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
590                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
591                 return;
592         }
593
594         sbp_login_release(login, true);
595
596         req->status.status = cpu_to_be32(
597                 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
598                 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
599 }
600
601 static void session_check_for_reset(struct sbp_session *sess)
602 {
603         bool card_valid = false;
604
605         spin_lock_bh(&sess->lock);
606
607         if (sess->card) {
608                 spin_lock_irq(&sess->card->lock);
609                 card_valid = (sess->card->local_node != NULL);
610                 spin_unlock_irq(&sess->card->lock);
611
612                 if (!card_valid) {
613                         fw_card_put(sess->card);
614                         sess->card = NULL;
615                 }
616         }
617
618         if (!card_valid || (sess->generation != sess->card->generation)) {
619                 pr_info("Waiting for reconnect from node: %016llx\n",
620                                 sess->guid);
621
622                 sess->node_id = -1;
623                 sess->reconnect_expires = get_jiffies_64() +
624                         ((sess->reconnect_hold + 1) * HZ);
625         }
626
627         spin_unlock_bh(&sess->lock);
628 }
629
630 static void session_reconnect_expired(struct sbp_session *sess)
631 {
632         struct sbp_login_descriptor *login, *temp;
633         LIST_HEAD(login_list);
634
635         pr_info("Reconnect timer expired for node: %016llx\n", sess->guid);
636
637         spin_lock_bh(&sess->lock);
638         list_for_each_entry_safe(login, temp, &sess->login_list, link) {
639                 login->sess = NULL;
640                 list_move_tail(&login->link, &login_list);
641         }
642         spin_unlock_bh(&sess->lock);
643
644         list_for_each_entry_safe(login, temp, &login_list, link) {
645                 list_del(&login->link);
646                 sbp_login_release(login, false);
647         }
648
649         sbp_session_release(sess, false);
650 }
651
652 static void session_maintenance_work(struct work_struct *work)
653 {
654         struct sbp_session *sess = container_of(work, struct sbp_session,
655                         maint_work.work);
656
657         /* could be called while tearing down the session */
658         spin_lock_bh(&sess->lock);
659         if (list_empty(&sess->login_list)) {
660                 spin_unlock_bh(&sess->lock);
661                 return;
662         }
663         spin_unlock_bh(&sess->lock);
664
665         if (sess->node_id != -1) {
666                 /* check for bus reset and make node_id invalid */
667                 session_check_for_reset(sess);
668
669                 schedule_delayed_work(&sess->maint_work,
670                                 SESSION_MAINTENANCE_INTERVAL);
671         } else if (!time_after64(get_jiffies_64(), sess->reconnect_expires)) {
672                 /* still waiting for reconnect */
673                 schedule_delayed_work(&sess->maint_work,
674                                 SESSION_MAINTENANCE_INTERVAL);
675         } else {
676                 /* reconnect timeout has expired */
677                 session_reconnect_expired(sess);
678         }
679 }
680
681 static int tgt_agent_rw_agent_state(struct fw_card *card, int tcode, void *data,
682                 struct sbp_target_agent *agent)
683 {
684         int state;
685
686         switch (tcode) {
687         case TCODE_READ_QUADLET_REQUEST:
688                 pr_debug("tgt_agent AGENT_STATE READ\n");
689
690                 spin_lock_bh(&agent->lock);
691                 state = agent->state;
692                 spin_unlock_bh(&agent->lock);
693
694                 *(__be32 *)data = cpu_to_be32(state);
695
696                 return RCODE_COMPLETE;
697
698         case TCODE_WRITE_QUADLET_REQUEST:
699                 /* ignored */
700                 return RCODE_COMPLETE;
701
702         default:
703                 return RCODE_TYPE_ERROR;
704         }
705 }
706
707 static int tgt_agent_rw_agent_reset(struct fw_card *card, int tcode, void *data,
708                 struct sbp_target_agent *agent)
709 {
710         switch (tcode) {
711         case TCODE_WRITE_QUADLET_REQUEST:
712                 pr_debug("tgt_agent AGENT_RESET\n");
713                 spin_lock_bh(&agent->lock);
714                 agent->state = AGENT_STATE_RESET;
715                 spin_unlock_bh(&agent->lock);
716                 return RCODE_COMPLETE;
717
718         default:
719                 return RCODE_TYPE_ERROR;
720         }
721 }
722
723 static int tgt_agent_rw_orb_pointer(struct fw_card *card, int tcode, void *data,
724                 struct sbp_target_agent *agent)
725 {
726         struct sbp2_pointer *ptr = data;
727
728         switch (tcode) {
729         case TCODE_WRITE_BLOCK_REQUEST:
730                 spin_lock_bh(&agent->lock);
731                 if (agent->state != AGENT_STATE_SUSPENDED &&
732                                 agent->state != AGENT_STATE_RESET) {
733                         spin_unlock_bh(&agent->lock);
734                         pr_notice("Ignoring ORB_POINTER write while active.\n");
735                         return RCODE_CONFLICT_ERROR;
736                 }
737                 agent->state = AGENT_STATE_ACTIVE;
738                 spin_unlock_bh(&agent->lock);
739
740                 agent->orb_pointer = sbp2_pointer_to_addr(ptr);
741                 agent->doorbell = false;
742
743                 pr_debug("tgt_agent ORB_POINTER write: 0x%llx\n",
744                                 agent->orb_pointer);
745
746                 queue_work(system_unbound_wq, &agent->work);
747
748                 return RCODE_COMPLETE;
749
750         case TCODE_READ_BLOCK_REQUEST:
751                 pr_debug("tgt_agent ORB_POINTER READ\n");
752                 spin_lock_bh(&agent->lock);
753                 addr_to_sbp2_pointer(agent->orb_pointer, ptr);
754                 spin_unlock_bh(&agent->lock);
755                 return RCODE_COMPLETE;
756
757         default:
758                 return RCODE_TYPE_ERROR;
759         }
760 }
761
762 static int tgt_agent_rw_doorbell(struct fw_card *card, int tcode, void *data,
763                 struct sbp_target_agent *agent)
764 {
765         switch (tcode) {
766         case TCODE_WRITE_QUADLET_REQUEST:
767                 spin_lock_bh(&agent->lock);
768                 if (agent->state != AGENT_STATE_SUSPENDED) {
769                         spin_unlock_bh(&agent->lock);
770                         pr_debug("Ignoring DOORBELL while active.\n");
771                         return RCODE_CONFLICT_ERROR;
772                 }
773                 agent->state = AGENT_STATE_ACTIVE;
774                 spin_unlock_bh(&agent->lock);
775
776                 agent->doorbell = true;
777
778                 pr_debug("tgt_agent DOORBELL\n");
779
780                 queue_work(system_unbound_wq, &agent->work);
781
782                 return RCODE_COMPLETE;
783
784         case TCODE_READ_QUADLET_REQUEST:
785                 return RCODE_COMPLETE;
786
787         default:
788                 return RCODE_TYPE_ERROR;
789         }
790 }
791
792 static int tgt_agent_rw_unsolicited_status_enable(struct fw_card *card,
793                 int tcode, void *data, struct sbp_target_agent *agent)
794 {
795         switch (tcode) {
796         case TCODE_WRITE_QUADLET_REQUEST:
797                 pr_debug("tgt_agent UNSOLICITED_STATUS_ENABLE\n");
798                 /* ignored as we don't send unsolicited status */
799                 return RCODE_COMPLETE;
800
801         case TCODE_READ_QUADLET_REQUEST:
802                 return RCODE_COMPLETE;
803
804         default:
805                 return RCODE_TYPE_ERROR;
806         }
807 }
808
809 static void tgt_agent_rw(struct fw_card *card, struct fw_request *request,
810                 int tcode, int destination, int source, int generation,
811                 unsigned long long offset, void *data, size_t length,
812                 void *callback_data)
813 {
814         struct sbp_target_agent *agent = callback_data;
815         struct sbp_session *sess = agent->login->sess;
816         int sess_gen, sess_node, rcode;
817
818         spin_lock_bh(&sess->lock);
819         sess_gen = sess->generation;
820         sess_node = sess->node_id;
821         spin_unlock_bh(&sess->lock);
822
823         if (generation != sess_gen) {
824                 pr_notice("ignoring request with wrong generation\n");
825                 rcode = RCODE_TYPE_ERROR;
826                 goto out;
827         }
828
829         if (source != sess_node) {
830                 pr_notice("ignoring request from foreign node (%x != %x)\n",
831                                 source, sess_node);
832                 rcode = RCODE_TYPE_ERROR;
833                 goto out;
834         }
835
836         /* turn offset into the offset from the start of the block */
837         offset -= agent->handler.offset;
838
839         if (offset == 0x00 && length == 4) {
840                 /* AGENT_STATE */
841                 rcode = tgt_agent_rw_agent_state(card, tcode, data, agent);
842         } else if (offset == 0x04 && length == 4) {
843                 /* AGENT_RESET */
844                 rcode = tgt_agent_rw_agent_reset(card, tcode, data, agent);
845         } else if (offset == 0x08 && length == 8) {
846                 /* ORB_POINTER */
847                 rcode = tgt_agent_rw_orb_pointer(card, tcode, data, agent);
848         } else if (offset == 0x10 && length == 4) {
849                 /* DOORBELL */
850                 rcode = tgt_agent_rw_doorbell(card, tcode, data, agent);
851         } else if (offset == 0x14 && length == 4) {
852                 /* UNSOLICITED_STATUS_ENABLE */
853                 rcode = tgt_agent_rw_unsolicited_status_enable(card, tcode,
854                                 data, agent);
855         } else {
856                 rcode = RCODE_ADDRESS_ERROR;
857         }
858
859 out:
860         fw_send_response(card, request, rcode);
861 }
862
863 static void sbp_handle_command(struct sbp_target_request *);
864 static int sbp_send_status(struct sbp_target_request *);
865 static void sbp_free_request(struct sbp_target_request *);
866
867 static void tgt_agent_process_work(struct work_struct *work)
868 {
869         struct sbp_target_request *req =
870                 container_of(work, struct sbp_target_request, work);
871
872         pr_debug("tgt_orb ptr:0x%llx next_ORB:0x%llx data_descriptor:0x%llx misc:0x%x\n",
873                         req->orb_pointer,
874                         sbp2_pointer_to_addr(&req->orb.next_orb),
875                         sbp2_pointer_to_addr(&req->orb.data_descriptor),
876                         be32_to_cpu(req->orb.misc));
877
878         if (req->orb_pointer >> 32)
879                 pr_debug("ORB with high bits set\n");
880
881         switch (ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc))) {
882                 case 0:/* Format specified by this standard */
883                         sbp_handle_command(req);
884                         return;
885                 case 1: /* Reserved for future standardization */
886                 case 2: /* Vendor-dependent */
887                         req->status.status |= cpu_to_be32(
888                                         STATUS_BLOCK_RESP(
889                                                 STATUS_RESP_REQUEST_COMPLETE) |
890                                         STATUS_BLOCK_DEAD(0) |
891                                         STATUS_BLOCK_LEN(1) |
892                                         STATUS_BLOCK_SBP_STATUS(
893                                                 SBP_STATUS_REQ_TYPE_NOTSUPP));
894                         sbp_send_status(req);
895                         return;
896                 case 3: /* Dummy ORB */
897                         req->status.status |= cpu_to_be32(
898                                         STATUS_BLOCK_RESP(
899                                                 STATUS_RESP_REQUEST_COMPLETE) |
900                                         STATUS_BLOCK_DEAD(0) |
901                                         STATUS_BLOCK_LEN(1) |
902                                         STATUS_BLOCK_SBP_STATUS(
903                                                 SBP_STATUS_DUMMY_ORB_COMPLETE));
904                         sbp_send_status(req);
905                         return;
906                 default:
907                         BUG();
908         }
909 }
910
911 /* used to double-check we haven't been issued an AGENT_RESET */
912 static inline bool tgt_agent_check_active(struct sbp_target_agent *agent)
913 {
914         bool active;
915
916         spin_lock_bh(&agent->lock);
917         active = (agent->state == AGENT_STATE_ACTIVE);
918         spin_unlock_bh(&agent->lock);
919
920         return active;
921 }
922
923 static struct sbp_target_request *sbp_mgt_get_req(struct sbp_session *sess,
924         struct fw_card *card, u64 next_orb)
925 {
926         struct se_session *se_sess = sess->se_sess;
927         struct sbp_target_request *req;
928         int tag, cpu;
929
930         tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu);
931         if (tag < 0)
932                 return ERR_PTR(-ENOMEM);
933
934         req = &((struct sbp_target_request *)se_sess->sess_cmd_map)[tag];
935         memset(req, 0, sizeof(*req));
936         req->se_cmd.map_tag = tag;
937         req->se_cmd.map_cpu = cpu;
938         req->se_cmd.tag = next_orb;
939
940         return req;
941 }
942
943 static void tgt_agent_fetch_work(struct work_struct *work)
944 {
945         struct sbp_target_agent *agent =
946                 container_of(work, struct sbp_target_agent, work);
947         struct sbp_session *sess = agent->login->sess;
948         struct sbp_target_request *req;
949         int ret;
950         bool doorbell = agent->doorbell;
951         u64 next_orb = agent->orb_pointer;
952
953         while (next_orb && tgt_agent_check_active(agent)) {
954                 req = sbp_mgt_get_req(sess, sess->card, next_orb);
955                 if (IS_ERR(req)) {
956                         spin_lock_bh(&agent->lock);
957                         agent->state = AGENT_STATE_DEAD;
958                         spin_unlock_bh(&agent->lock);
959                         return;
960                 }
961
962                 req->login = agent->login;
963                 req->orb_pointer = next_orb;
964
965                 req->status.status = cpu_to_be32(STATUS_BLOCK_ORB_OFFSET_HIGH(
966                                         req->orb_pointer >> 32));
967                 req->status.orb_low = cpu_to_be32(
968                                 req->orb_pointer & 0xfffffffc);
969
970                 /* read in the ORB */
971                 ret = sbp_run_transaction(sess->card, TCODE_READ_BLOCK_REQUEST,
972                                 sess->node_id, sess->generation, sess->speed,
973                                 req->orb_pointer, &req->orb, sizeof(req->orb));
974                 if (ret != RCODE_COMPLETE) {
975                         pr_debug("tgt_orb fetch failed: %x\n", ret);
976                         req->status.status |= cpu_to_be32(
977                                         STATUS_BLOCK_SRC(
978                                                 STATUS_SRC_ORB_FINISHED) |
979                                         STATUS_BLOCK_RESP(
980                                                 STATUS_RESP_TRANSPORT_FAILURE) |
981                                         STATUS_BLOCK_DEAD(1) |
982                                         STATUS_BLOCK_LEN(1) |
983                                         STATUS_BLOCK_SBP_STATUS(
984                                                 SBP_STATUS_UNSPECIFIED_ERROR));
985                         spin_lock_bh(&agent->lock);
986                         agent->state = AGENT_STATE_DEAD;
987                         spin_unlock_bh(&agent->lock);
988
989                         sbp_send_status(req);
990                         return;
991                 }
992
993                 /* check the next_ORB field */
994                 if (be32_to_cpu(req->orb.next_orb.high) & 0x80000000) {
995                         next_orb = 0;
996                         req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC(
997                                                 STATUS_SRC_ORB_FINISHED));
998                 } else {
999                         next_orb = sbp2_pointer_to_addr(&req->orb.next_orb);
1000                         req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC(
1001                                                 STATUS_SRC_ORB_CONTINUING));
1002                 }
1003
1004                 if (tgt_agent_check_active(agent) && !doorbell) {
1005                         INIT_WORK(&req->work, tgt_agent_process_work);
1006                         queue_work(system_unbound_wq, &req->work);
1007                 } else {
1008                         /* don't process this request, just check next_ORB */
1009                         sbp_free_request(req);
1010                 }
1011
1012                 spin_lock_bh(&agent->lock);
1013                 doorbell = agent->doorbell = false;
1014
1015                 /* check if we should carry on processing */
1016                 if (next_orb)
1017                         agent->orb_pointer = next_orb;
1018                 else
1019                         agent->state = AGENT_STATE_SUSPENDED;
1020
1021                 spin_unlock_bh(&agent->lock);
1022         };
1023 }
1024
1025 static struct sbp_target_agent *sbp_target_agent_register(
1026                 struct sbp_login_descriptor *login)
1027 {
1028         struct sbp_target_agent *agent;
1029         int ret;
1030
1031         agent = kmalloc(sizeof(*agent), GFP_KERNEL);
1032         if (!agent)
1033                 return ERR_PTR(-ENOMEM);
1034
1035         spin_lock_init(&agent->lock);
1036
1037         agent->handler.length = 0x20;
1038         agent->handler.address_callback = tgt_agent_rw;
1039         agent->handler.callback_data = agent;
1040
1041         agent->login = login;
1042         agent->state = AGENT_STATE_RESET;
1043         INIT_WORK(&agent->work, tgt_agent_fetch_work);
1044         agent->orb_pointer = 0;
1045         agent->doorbell = false;
1046
1047         ret = fw_core_add_address_handler(&agent->handler,
1048                         &sbp_register_region);
1049         if (ret < 0) {
1050                 kfree(agent);
1051                 return ERR_PTR(ret);
1052         }
1053
1054         return agent;
1055 }
1056
1057 static void sbp_target_agent_unregister(struct sbp_target_agent *agent)
1058 {
1059         fw_core_remove_address_handler(&agent->handler);
1060         cancel_work_sync(&agent->work);
1061         kfree(agent);
1062 }
1063
1064 /*
1065  * Simple wrapper around fw_run_transaction that retries the transaction several
1066  * times in case of failure, with an exponential backoff.
1067  */
1068 static int sbp_run_transaction(struct fw_card *card, int tcode, int destination_id,
1069                 int generation, int speed, unsigned long long offset,
1070                 void *payload, size_t length)
1071 {
1072         int attempt, ret, delay;
1073
1074         for (attempt = 1; attempt <= 5; attempt++) {
1075                 ret = fw_run_transaction(card, tcode, destination_id,
1076                                 generation, speed, offset, payload, length);
1077
1078                 switch (ret) {
1079                 case RCODE_COMPLETE:
1080                 case RCODE_TYPE_ERROR:
1081                 case RCODE_ADDRESS_ERROR:
1082                 case RCODE_GENERATION:
1083                         return ret;
1084
1085                 default:
1086                         delay = 5 * attempt * attempt;
1087                         usleep_range(delay, delay * 2);
1088                 }
1089         }
1090
1091         return ret;
1092 }
1093
1094 /*
1095  * Wrapper around sbp_run_transaction that gets the card, destination,
1096  * generation and speed out of the request's session.
1097  */
1098 static int sbp_run_request_transaction(struct sbp_target_request *req,
1099                 int tcode, unsigned long long offset, void *payload,
1100                 size_t length)
1101 {
1102         struct sbp_login_descriptor *login = req->login;
1103         struct sbp_session *sess = login->sess;
1104         struct fw_card *card;
1105         int node_id, generation, speed, ret;
1106
1107         spin_lock_bh(&sess->lock);
1108         card = fw_card_get(sess->card);
1109         node_id = sess->node_id;
1110         generation = sess->generation;
1111         speed = sess->speed;
1112         spin_unlock_bh(&sess->lock);
1113
1114         ret = sbp_run_transaction(card, tcode, node_id, generation, speed,
1115                         offset, payload, length);
1116
1117         fw_card_put(card);
1118
1119         return ret;
1120 }
1121
1122 static int sbp_fetch_command(struct sbp_target_request *req)
1123 {
1124         int ret, cmd_len, copy_len;
1125
1126         cmd_len = scsi_command_size(req->orb.command_block);
1127
1128         req->cmd_buf = kmalloc(cmd_len, GFP_KERNEL);
1129         if (!req->cmd_buf)
1130                 return -ENOMEM;
1131
1132         memcpy(req->cmd_buf, req->orb.command_block,
1133                 min_t(int, cmd_len, sizeof(req->orb.command_block)));
1134
1135         if (cmd_len > sizeof(req->orb.command_block)) {
1136                 pr_debug("sbp_fetch_command: filling in long command\n");
1137                 copy_len = cmd_len - sizeof(req->orb.command_block);
1138
1139                 ret = sbp_run_request_transaction(req,
1140                                 TCODE_READ_BLOCK_REQUEST,
1141                                 req->orb_pointer + sizeof(req->orb),
1142                                 req->cmd_buf + sizeof(req->orb.command_block),
1143                                 copy_len);
1144                 if (ret != RCODE_COMPLETE)
1145                         return -EIO;
1146         }
1147
1148         return 0;
1149 }
1150
1151 static int sbp_fetch_page_table(struct sbp_target_request *req)
1152 {
1153         int pg_tbl_sz, ret;
1154         struct sbp_page_table_entry *pg_tbl;
1155
1156         if (!CMDBLK_ORB_PG_TBL_PRESENT(be32_to_cpu(req->orb.misc)))
1157                 return 0;
1158
1159         pg_tbl_sz = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc)) *
1160                 sizeof(struct sbp_page_table_entry);
1161
1162         pg_tbl = kmalloc(pg_tbl_sz, GFP_KERNEL);
1163         if (!pg_tbl)
1164                 return -ENOMEM;
1165
1166         ret = sbp_run_request_transaction(req, TCODE_READ_BLOCK_REQUEST,
1167                         sbp2_pointer_to_addr(&req->orb.data_descriptor),
1168                         pg_tbl, pg_tbl_sz);
1169         if (ret != RCODE_COMPLETE) {
1170                 kfree(pg_tbl);
1171                 return -EIO;
1172         }
1173
1174         req->pg_tbl = pg_tbl;
1175         return 0;
1176 }
1177
1178 static void sbp_calc_data_length_direction(struct sbp_target_request *req,
1179         u32 *data_len, enum dma_data_direction *data_dir)
1180 {
1181         int data_size, direction, idx;
1182
1183         data_size = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc));
1184         direction = CMDBLK_ORB_DIRECTION(be32_to_cpu(req->orb.misc));
1185
1186         if (!data_size) {
1187                 *data_len = 0;
1188                 *data_dir = DMA_NONE;
1189                 return;
1190         }
1191
1192         *data_dir = direction ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
1193
1194         if (req->pg_tbl) {
1195                 *data_len = 0;
1196                 for (idx = 0; idx < data_size; idx++) {
1197                         *data_len += be16_to_cpu(
1198                                         req->pg_tbl[idx].segment_length);
1199                 }
1200         } else {
1201                 *data_len = data_size;
1202         }
1203 }
1204
1205 static void sbp_handle_command(struct sbp_target_request *req)
1206 {
1207         struct sbp_login_descriptor *login = req->login;
1208         struct sbp_session *sess = login->sess;
1209         int ret, unpacked_lun;
1210         u32 data_length;
1211         enum dma_data_direction data_dir;
1212
1213         ret = sbp_fetch_command(req);
1214         if (ret) {
1215                 pr_debug("sbp_handle_command: fetch command failed: %d\n", ret);
1216                 goto err;
1217         }
1218
1219         ret = sbp_fetch_page_table(req);
1220         if (ret) {
1221                 pr_debug("sbp_handle_command: fetch page table failed: %d\n",
1222                         ret);
1223                 goto err;
1224         }
1225
1226         unpacked_lun = req->login->login_lun;
1227         sbp_calc_data_length_direction(req, &data_length, &data_dir);
1228
1229         pr_debug("sbp_handle_command ORB:0x%llx unpacked_lun:%d data_len:%d data_dir:%d\n",
1230                         req->orb_pointer, unpacked_lun, data_length, data_dir);
1231
1232         /* only used for printk until we do TMRs */
1233         req->se_cmd.tag = req->orb_pointer;
1234         if (target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf,
1235                               req->sense_buf, unpacked_lun, data_length,
1236                               TCM_SIMPLE_TAG, data_dir, TARGET_SCF_ACK_KREF))
1237                 goto err;
1238
1239         return;
1240
1241 err:
1242         req->status.status |= cpu_to_be32(
1243                 STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
1244                 STATUS_BLOCK_DEAD(0) |
1245                 STATUS_BLOCK_LEN(1) |
1246                 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
1247         sbp_send_status(req);
1248 }
1249
1250 /*
1251  * DMA_TO_DEVICE = read from initiator (SCSI WRITE)
1252  * DMA_FROM_DEVICE = write to initiator (SCSI READ)
1253  */
1254 static int sbp_rw_data(struct sbp_target_request *req)
1255 {
1256         struct sbp_session *sess = req->login->sess;
1257         int tcode, sg_miter_flags, max_payload, pg_size, speed, node_id,
1258                 generation, num_pte, length, tfr_length,
1259                 rcode = RCODE_COMPLETE;
1260         struct sbp_page_table_entry *pte;
1261         unsigned long long offset;
1262         struct fw_card *card;
1263         struct sg_mapping_iter iter;
1264
1265         if (req->se_cmd.data_direction == DMA_FROM_DEVICE) {
1266                 tcode = TCODE_WRITE_BLOCK_REQUEST;
1267                 sg_miter_flags = SG_MITER_FROM_SG;
1268         } else {
1269                 tcode = TCODE_READ_BLOCK_REQUEST;
1270                 sg_miter_flags = SG_MITER_TO_SG;
1271         }
1272
1273         max_payload = 4 << CMDBLK_ORB_MAX_PAYLOAD(be32_to_cpu(req->orb.misc));
1274         speed = CMDBLK_ORB_SPEED(be32_to_cpu(req->orb.misc));
1275
1276         pg_size = CMDBLK_ORB_PG_SIZE(be32_to_cpu(req->orb.misc));
1277         if (pg_size) {
1278                 pr_err("sbp_run_transaction: page size ignored\n");
1279                 pg_size = 0x100 << pg_size;
1280         }
1281
1282         spin_lock_bh(&sess->lock);
1283         card = fw_card_get(sess->card);
1284         node_id = sess->node_id;
1285         generation = sess->generation;
1286         spin_unlock_bh(&sess->lock);
1287
1288         if (req->pg_tbl) {
1289                 pte = req->pg_tbl;
1290                 num_pte = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc));
1291
1292                 offset = 0;
1293                 length = 0;
1294         } else {
1295                 pte = NULL;
1296                 num_pte = 0;
1297
1298                 offset = sbp2_pointer_to_addr(&req->orb.data_descriptor);
1299                 length = req->se_cmd.data_length;
1300         }
1301
1302         sg_miter_start(&iter, req->se_cmd.t_data_sg, req->se_cmd.t_data_nents,
1303                 sg_miter_flags);
1304
1305         while (length || num_pte) {
1306                 if (!length) {
1307                         offset = (u64)be16_to_cpu(pte->segment_base_hi) << 32 |
1308                                 be32_to_cpu(pte->segment_base_lo);
1309                         length = be16_to_cpu(pte->segment_length);
1310
1311                         pte++;
1312                         num_pte--;
1313                 }
1314
1315                 sg_miter_next(&iter);
1316
1317                 tfr_length = min3(length, max_payload, (int)iter.length);
1318
1319                 /* FIXME: take page_size into account */
1320
1321                 rcode = sbp_run_transaction(card, tcode, node_id,
1322                                 generation, speed,
1323                                 offset, iter.addr, tfr_length);
1324
1325                 if (rcode != RCODE_COMPLETE)
1326                         break;
1327
1328                 length -= tfr_length;
1329                 offset += tfr_length;
1330                 iter.consumed = tfr_length;
1331         }
1332
1333         sg_miter_stop(&iter);
1334         fw_card_put(card);
1335
1336         if (rcode == RCODE_COMPLETE) {
1337                 WARN_ON(length != 0);
1338                 return 0;
1339         } else {
1340                 return -EIO;
1341         }
1342 }
1343
1344 static int sbp_send_status(struct sbp_target_request *req)
1345 {
1346         int rc, ret = 0, length;
1347         struct sbp_login_descriptor *login = req->login;
1348
1349         length = (((be32_to_cpu(req->status.status) >> 24) & 0x07) + 1) * 4;
1350
1351         rc = sbp_run_request_transaction(req, TCODE_WRITE_BLOCK_REQUEST,
1352                         login->status_fifo_addr, &req->status, length);
1353         if (rc != RCODE_COMPLETE) {
1354                 pr_debug("sbp_send_status: write failed: 0x%x\n", rc);
1355                 ret = -EIO;
1356                 goto put_ref;
1357         }
1358
1359         pr_debug("sbp_send_status: status write complete for ORB: 0x%llx\n",
1360                         req->orb_pointer);
1361         /*
1362          * Drop the extra ACK_KREF reference taken by target_submit_cmd()
1363          * ahead of sbp_check_stop_free() -> transport_generic_free_cmd()
1364          * final se_cmd->cmd_kref put.
1365          */
1366 put_ref:
1367         target_put_sess_cmd(&req->se_cmd);
1368         return ret;
1369 }
1370
1371 static void sbp_sense_mangle(struct sbp_target_request *req)
1372 {
1373         struct se_cmd *se_cmd = &req->se_cmd;
1374         u8 *sense = req->sense_buf;
1375         u8 *status = req->status.data;
1376
1377         WARN_ON(se_cmd->scsi_sense_length < 18);
1378
1379         switch (sense[0] & 0x7f) {              /* sfmt */
1380         case 0x70: /* current, fixed */
1381                 status[0] = 0 << 6;
1382                 break;
1383         case 0x71: /* deferred, fixed */
1384                 status[0] = 1 << 6;
1385                 break;
1386         case 0x72: /* current, descriptor */
1387         case 0x73: /* deferred, descriptor */
1388         default:
1389                 /*
1390                  * TODO: SBP-3 specifies what we should do with descriptor
1391                  * format sense data
1392                  */
1393                 pr_err("sbp_send_sense: unknown sense format: 0x%x\n",
1394                         sense[0]);
1395                 req->status.status |= cpu_to_be32(
1396                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1397                         STATUS_BLOCK_DEAD(0) |
1398                         STATUS_BLOCK_LEN(1) |
1399                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQUEST_ABORTED));
1400                 return;
1401         }
1402
1403         status[0] |= se_cmd->scsi_status & 0x3f;/* status */
1404         status[1] =
1405                 (sense[0] & 0x80) |             /* valid */
1406                 ((sense[2] & 0xe0) >> 1) |      /* mark, eom, ili */
1407                 (sense[2] & 0x0f);              /* sense_key */
1408         status[2] = se_cmd->scsi_asc;           /* sense_code */
1409         status[3] = se_cmd->scsi_ascq;          /* sense_qualifier */
1410
1411         /* information */
1412         status[4] = sense[3];
1413         status[5] = sense[4];
1414         status[6] = sense[5];
1415         status[7] = sense[6];
1416
1417         /* CDB-dependent */
1418         status[8] = sense[8];
1419         status[9] = sense[9];
1420         status[10] = sense[10];
1421         status[11] = sense[11];
1422
1423         /* fru */
1424         status[12] = sense[14];
1425
1426         /* sense_key-dependent */
1427         status[13] = sense[15];
1428         status[14] = sense[16];
1429         status[15] = sense[17];
1430
1431         req->status.status |= cpu_to_be32(
1432                 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1433                 STATUS_BLOCK_DEAD(0) |
1434                 STATUS_BLOCK_LEN(5) |
1435                 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
1436 }
1437
1438 static int sbp_send_sense(struct sbp_target_request *req)
1439 {
1440         struct se_cmd *se_cmd = &req->se_cmd;
1441
1442         if (se_cmd->scsi_sense_length) {
1443                 sbp_sense_mangle(req);
1444         } else {
1445                 req->status.status |= cpu_to_be32(
1446                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1447                         STATUS_BLOCK_DEAD(0) |
1448                         STATUS_BLOCK_LEN(1) |
1449                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
1450         }
1451
1452         return sbp_send_status(req);
1453 }
1454
1455 static void sbp_free_request(struct sbp_target_request *req)
1456 {
1457         struct se_cmd *se_cmd = &req->se_cmd;
1458         struct se_session *se_sess = se_cmd->se_sess;
1459
1460         kfree(req->pg_tbl);
1461         kfree(req->cmd_buf);
1462
1463         target_free_tag(se_sess, se_cmd);
1464 }
1465
1466 static void sbp_mgt_agent_process(struct work_struct *work)
1467 {
1468         struct sbp_management_agent *agent =
1469                 container_of(work, struct sbp_management_agent, work);
1470         struct sbp_management_request *req = agent->request;
1471         int ret;
1472         int status_data_len = 0;
1473
1474         /* fetch the ORB from the initiator */
1475         ret = sbp_run_transaction(req->card, TCODE_READ_BLOCK_REQUEST,
1476                 req->node_addr, req->generation, req->speed,
1477                 agent->orb_offset, &req->orb, sizeof(req->orb));
1478         if (ret != RCODE_COMPLETE) {
1479                 pr_debug("mgt_orb fetch failed: %x\n", ret);
1480                 goto out;
1481         }
1482
1483         pr_debug("mgt_orb ptr1:0x%llx ptr2:0x%llx misc:0x%x len:0x%x status_fifo:0x%llx\n",
1484                 sbp2_pointer_to_addr(&req->orb.ptr1),
1485                 sbp2_pointer_to_addr(&req->orb.ptr2),
1486                 be32_to_cpu(req->orb.misc), be32_to_cpu(req->orb.length),
1487                 sbp2_pointer_to_addr(&req->orb.status_fifo));
1488
1489         if (!ORB_NOTIFY(be32_to_cpu(req->orb.misc)) ||
1490                 ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc)) != 0) {
1491                 pr_err("mgt_orb bad request\n");
1492                 goto out;
1493         }
1494
1495         switch (MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc))) {
1496         case MANAGEMENT_ORB_FUNCTION_LOGIN:
1497                 sbp_management_request_login(agent, req, &status_data_len);
1498                 break;
1499
1500         case MANAGEMENT_ORB_FUNCTION_QUERY_LOGINS:
1501                 sbp_management_request_query_logins(agent, req,
1502                                 &status_data_len);
1503                 break;
1504
1505         case MANAGEMENT_ORB_FUNCTION_RECONNECT:
1506                 sbp_management_request_reconnect(agent, req, &status_data_len);
1507                 break;
1508
1509         case MANAGEMENT_ORB_FUNCTION_SET_PASSWORD:
1510                 pr_notice("SET PASSWORD not implemented\n");
1511
1512                 req->status.status = cpu_to_be32(
1513                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1514                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
1515
1516                 break;
1517
1518         case MANAGEMENT_ORB_FUNCTION_LOGOUT:
1519                 sbp_management_request_logout(agent, req, &status_data_len);
1520                 break;
1521
1522         case MANAGEMENT_ORB_FUNCTION_ABORT_TASK:
1523                 pr_notice("ABORT TASK not implemented\n");
1524
1525                 req->status.status = cpu_to_be32(
1526                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1527                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
1528
1529                 break;
1530
1531         case MANAGEMENT_ORB_FUNCTION_ABORT_TASK_SET:
1532                 pr_notice("ABORT TASK SET not implemented\n");
1533
1534                 req->status.status = cpu_to_be32(
1535                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1536                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
1537
1538                 break;
1539
1540         case MANAGEMENT_ORB_FUNCTION_LOGICAL_UNIT_RESET:
1541                 pr_notice("LOGICAL UNIT RESET not implemented\n");
1542
1543                 req->status.status = cpu_to_be32(
1544                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1545                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
1546
1547                 break;
1548
1549         case MANAGEMENT_ORB_FUNCTION_TARGET_RESET:
1550                 pr_notice("TARGET RESET not implemented\n");
1551
1552                 req->status.status = cpu_to_be32(
1553                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1554                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
1555
1556                 break;
1557
1558         default:
1559                 pr_notice("unknown management function 0x%x\n",
1560                         MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc)));
1561
1562                 req->status.status = cpu_to_be32(
1563                         STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
1564                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
1565
1566                 break;
1567         }
1568
1569         req->status.status |= cpu_to_be32(
1570                 STATUS_BLOCK_SRC(1) | /* Response to ORB, next_ORB absent */
1571                 STATUS_BLOCK_LEN(DIV_ROUND_UP(status_data_len, 4) + 1) |
1572                 STATUS_BLOCK_ORB_OFFSET_HIGH(agent->orb_offset >> 32));
1573         req->status.orb_low = cpu_to_be32(agent->orb_offset);
1574
1575         /* write the status block back to the initiator */
1576         ret = sbp_run_transaction(req->card, TCODE_WRITE_BLOCK_REQUEST,
1577                 req->node_addr, req->generation, req->speed,
1578                 sbp2_pointer_to_addr(&req->orb.status_fifo),
1579                 &req->status, 8 + status_data_len);
1580         if (ret != RCODE_COMPLETE) {
1581                 pr_debug("mgt_orb status write failed: %x\n", ret);
1582                 goto out;
1583         }
1584
1585 out:
1586         fw_card_put(req->card);
1587         kfree(req);
1588
1589         spin_lock_bh(&agent->lock);
1590         agent->state = MANAGEMENT_AGENT_STATE_IDLE;
1591         spin_unlock_bh(&agent->lock);
1592 }
1593
1594 static void sbp_mgt_agent_rw(struct fw_card *card,
1595         struct fw_request *request, int tcode, int destination, int source,
1596         int generation, unsigned long long offset, void *data, size_t length,
1597         void *callback_data)
1598 {
1599         struct sbp_management_agent *agent = callback_data;
1600         struct sbp2_pointer *ptr = data;
1601         int rcode = RCODE_ADDRESS_ERROR;
1602
1603         if (!agent->tport->enable)
1604                 goto out;
1605
1606         if ((offset != agent->handler.offset) || (length != 8))
1607                 goto out;
1608
1609         if (tcode == TCODE_WRITE_BLOCK_REQUEST) {
1610                 struct sbp_management_request *req;
1611                 int prev_state;
1612
1613                 spin_lock_bh(&agent->lock);
1614                 prev_state = agent->state;
1615                 agent->state = MANAGEMENT_AGENT_STATE_BUSY;
1616                 spin_unlock_bh(&agent->lock);
1617
1618                 if (prev_state == MANAGEMENT_AGENT_STATE_BUSY) {
1619                         pr_notice("ignoring management request while busy\n");
1620                         rcode = RCODE_CONFLICT_ERROR;
1621                         goto out;
1622                 }
1623                 req = kzalloc(sizeof(*req), GFP_ATOMIC);
1624                 if (!req) {
1625                         rcode = RCODE_CONFLICT_ERROR;
1626                         goto out;
1627                 }
1628
1629                 req->card = fw_card_get(card);
1630                 req->generation = generation;
1631                 req->node_addr = source;
1632                 req->speed = fw_get_request_speed(request);
1633
1634                 agent->orb_offset = sbp2_pointer_to_addr(ptr);
1635                 agent->request = req;
1636
1637                 queue_work(system_unbound_wq, &agent->work);
1638                 rcode = RCODE_COMPLETE;
1639         } else if (tcode == TCODE_READ_BLOCK_REQUEST) {
1640                 addr_to_sbp2_pointer(agent->orb_offset, ptr);
1641                 rcode = RCODE_COMPLETE;
1642         } else {
1643                 rcode = RCODE_TYPE_ERROR;
1644         }
1645
1646 out:
1647         fw_send_response(card, request, rcode);
1648 }
1649
1650 static struct sbp_management_agent *sbp_management_agent_register(
1651                 struct sbp_tport *tport)
1652 {
1653         int ret;
1654         struct sbp_management_agent *agent;
1655
1656         agent = kmalloc(sizeof(*agent), GFP_KERNEL);
1657         if (!agent)
1658                 return ERR_PTR(-ENOMEM);
1659
1660         spin_lock_init(&agent->lock);
1661         agent->tport = tport;
1662         agent->handler.length = 0x08;
1663         agent->handler.address_callback = sbp_mgt_agent_rw;
1664         agent->handler.callback_data = agent;
1665         agent->state = MANAGEMENT_AGENT_STATE_IDLE;
1666         INIT_WORK(&agent->work, sbp_mgt_agent_process);
1667         agent->orb_offset = 0;
1668         agent->request = NULL;
1669
1670         ret = fw_core_add_address_handler(&agent->handler,
1671                         &sbp_register_region);
1672         if (ret < 0) {
1673                 kfree(agent);
1674                 return ERR_PTR(ret);
1675         }
1676
1677         return agent;
1678 }
1679
1680 static void sbp_management_agent_unregister(struct sbp_management_agent *agent)
1681 {
1682         fw_core_remove_address_handler(&agent->handler);
1683         cancel_work_sync(&agent->work);
1684         kfree(agent);
1685 }
1686
1687 static int sbp_check_true(struct se_portal_group *se_tpg)
1688 {
1689         return 1;
1690 }
1691
1692 static int sbp_check_false(struct se_portal_group *se_tpg)
1693 {
1694         return 0;
1695 }
1696
1697 static char *sbp_get_fabric_name(void)
1698 {
1699         return "sbp";
1700 }
1701
1702 static char *sbp_get_fabric_wwn(struct se_portal_group *se_tpg)
1703 {
1704         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
1705         struct sbp_tport *tport = tpg->tport;
1706
1707         return &tport->tport_name[0];
1708 }
1709
1710 static u16 sbp_get_tag(struct se_portal_group *se_tpg)
1711 {
1712         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
1713         return tpg->tport_tpgt;
1714 }
1715
1716 static u32 sbp_tpg_get_inst_index(struct se_portal_group *se_tpg)
1717 {
1718         return 1;
1719 }
1720
1721 static void sbp_release_cmd(struct se_cmd *se_cmd)
1722 {
1723         struct sbp_target_request *req = container_of(se_cmd,
1724                         struct sbp_target_request, se_cmd);
1725
1726         sbp_free_request(req);
1727 }
1728
1729 static u32 sbp_sess_get_index(struct se_session *se_sess)
1730 {
1731         return 0;
1732 }
1733
1734 static int sbp_write_pending(struct se_cmd *se_cmd)
1735 {
1736         struct sbp_target_request *req = container_of(se_cmd,
1737                         struct sbp_target_request, se_cmd);
1738         int ret;
1739
1740         ret = sbp_rw_data(req);
1741         if (ret) {
1742                 req->status.status |= cpu_to_be32(
1743                         STATUS_BLOCK_RESP(
1744                                 STATUS_RESP_TRANSPORT_FAILURE) |
1745                         STATUS_BLOCK_DEAD(0) |
1746                         STATUS_BLOCK_LEN(1) |
1747                         STATUS_BLOCK_SBP_STATUS(
1748                                 SBP_STATUS_UNSPECIFIED_ERROR));
1749                 sbp_send_status(req);
1750                 return ret;
1751         }
1752
1753         target_execute_cmd(se_cmd);
1754         return 0;
1755 }
1756
1757 static int sbp_write_pending_status(struct se_cmd *se_cmd)
1758 {
1759         return 0;
1760 }
1761
1762 static void sbp_set_default_node_attrs(struct se_node_acl *nacl)
1763 {
1764         return;
1765 }
1766
1767 static int sbp_get_cmd_state(struct se_cmd *se_cmd)
1768 {
1769         return 0;
1770 }
1771
1772 static int sbp_queue_data_in(struct se_cmd *se_cmd)
1773 {
1774         struct sbp_target_request *req = container_of(se_cmd,
1775                         struct sbp_target_request, se_cmd);
1776         int ret;
1777
1778         ret = sbp_rw_data(req);
1779         if (ret) {
1780                 req->status.status |= cpu_to_be32(
1781                         STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
1782                         STATUS_BLOCK_DEAD(0) |
1783                         STATUS_BLOCK_LEN(1) |
1784                         STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
1785                 sbp_send_status(req);
1786                 return ret;
1787         }
1788
1789         return sbp_send_sense(req);
1790 }
1791
1792 /*
1793  * Called after command (no data transfer) or after the write (to device)
1794  * operation is completed
1795  */
1796 static int sbp_queue_status(struct se_cmd *se_cmd)
1797 {
1798         struct sbp_target_request *req = container_of(se_cmd,
1799                         struct sbp_target_request, se_cmd);
1800
1801         return sbp_send_sense(req);
1802 }
1803
1804 static void sbp_queue_tm_rsp(struct se_cmd *se_cmd)
1805 {
1806 }
1807
1808 static void sbp_aborted_task(struct se_cmd *se_cmd)
1809 {
1810         return;
1811 }
1812
1813 static int sbp_check_stop_free(struct se_cmd *se_cmd)
1814 {
1815         struct sbp_target_request *req = container_of(se_cmd,
1816                         struct sbp_target_request, se_cmd);
1817
1818         return transport_generic_free_cmd(&req->se_cmd, 0);
1819 }
1820
1821 static int sbp_count_se_tpg_luns(struct se_portal_group *tpg)
1822 {
1823         struct se_lun *lun;
1824         int count = 0;
1825
1826         rcu_read_lock();
1827         hlist_for_each_entry_rcu(lun, &tpg->tpg_lun_hlist, link)
1828                 count++;
1829         rcu_read_unlock();
1830
1831         return count;
1832 }
1833
1834 static int sbp_update_unit_directory(struct sbp_tport *tport)
1835 {
1836         struct se_lun *lun;
1837         int num_luns, num_entries, idx = 0, mgt_agt_addr, ret;
1838         u32 *data;
1839
1840         if (tport->unit_directory.data) {
1841                 fw_core_remove_descriptor(&tport->unit_directory);
1842                 kfree(tport->unit_directory.data);
1843                 tport->unit_directory.data = NULL;
1844         }
1845
1846         if (!tport->enable || !tport->tpg)
1847                 return 0;
1848
1849         num_luns = sbp_count_se_tpg_luns(&tport->tpg->se_tpg);
1850
1851         /*
1852          * Number of entries in the final unit directory:
1853          *  - all of those in the template
1854          *  - management_agent
1855          *  - unit_characteristics
1856          *  - reconnect_timeout
1857          *  - unit unique ID
1858          *  - one for each LUN
1859          *
1860          *  MUST NOT include leaf or sub-directory entries
1861          */
1862         num_entries = ARRAY_SIZE(sbp_unit_directory_template) + 4 + num_luns;
1863
1864         if (tport->directory_id != -1)
1865                 num_entries++;
1866
1867         /* allocate num_entries + 4 for the header and unique ID leaf */
1868         data = kcalloc((num_entries + 4), sizeof(u32), GFP_KERNEL);
1869         if (!data)
1870                 return -ENOMEM;
1871
1872         /* directory_length */
1873         data[idx++] = num_entries << 16;
1874
1875         /* directory_id */
1876         if (tport->directory_id != -1)
1877                 data[idx++] = (CSR_DIRECTORY_ID << 24) | tport->directory_id;
1878
1879         /* unit directory template */
1880         memcpy(&data[idx], sbp_unit_directory_template,
1881                         sizeof(sbp_unit_directory_template));
1882         idx += ARRAY_SIZE(sbp_unit_directory_template);
1883
1884         /* management_agent */
1885         mgt_agt_addr = (tport->mgt_agt->handler.offset - CSR_REGISTER_BASE) / 4;
1886         data[idx++] = 0x54000000 | (mgt_agt_addr & 0x00ffffff);
1887
1888         /* unit_characteristics */
1889         data[idx++] = 0x3a000000 |
1890                 (((tport->mgt_orb_timeout * 2) << 8) & 0xff00) |
1891                 SBP_ORB_FETCH_SIZE;
1892
1893         /* reconnect_timeout */
1894         data[idx++] = 0x3d000000 | (tport->max_reconnect_timeout & 0xffff);
1895
1896         /* unit unique ID (leaf is just after LUNs) */
1897         data[idx++] = 0x8d000000 | (num_luns + 1);
1898
1899         rcu_read_lock();
1900         hlist_for_each_entry_rcu(lun, &tport->tpg->se_tpg.tpg_lun_hlist, link) {
1901                 struct se_device *dev;
1902                 int type;
1903                 /*
1904                  * rcu_dereference_raw protected by se_lun->lun_group symlink
1905                  * reference to se_device->dev_group.
1906                  */
1907                 dev = rcu_dereference_raw(lun->lun_se_dev);
1908                 type = dev->transport->get_device_type(dev);
1909
1910                 /* logical_unit_number */
1911                 data[idx++] = 0x14000000 |
1912                         ((type << 16) & 0x1f0000) |
1913                         (lun->unpacked_lun & 0xffff);
1914         }
1915         rcu_read_unlock();
1916
1917         /* unit unique ID leaf */
1918         data[idx++] = 2 << 16;
1919         data[idx++] = tport->guid >> 32;
1920         data[idx++] = tport->guid;
1921
1922         tport->unit_directory.length = idx;
1923         tport->unit_directory.key = (CSR_DIRECTORY | CSR_UNIT) << 24;
1924         tport->unit_directory.data = data;
1925
1926         ret = fw_core_add_descriptor(&tport->unit_directory);
1927         if (ret < 0) {
1928                 kfree(tport->unit_directory.data);
1929                 tport->unit_directory.data = NULL;
1930         }
1931
1932         return ret;
1933 }
1934
1935 static ssize_t sbp_parse_wwn(const char *name, u64 *wwn)
1936 {
1937         const char *cp;
1938         char c, nibble;
1939         int pos = 0, err;
1940
1941         *wwn = 0;
1942         for (cp = name; cp < &name[SBP_NAMELEN - 1]; cp++) {
1943                 c = *cp;
1944                 if (c == '\n' && cp[1] == '\0')
1945                         continue;
1946                 if (c == '\0') {
1947                         err = 2;
1948                         if (pos != 16)
1949                                 goto fail;
1950                         return cp - name;
1951                 }
1952                 err = 3;
1953                 if (isdigit(c))
1954                         nibble = c - '0';
1955                 else if (isxdigit(c))
1956                         nibble = tolower(c) - 'a' + 10;
1957                 else
1958                         goto fail;
1959                 *wwn = (*wwn << 4) | nibble;
1960                 pos++;
1961         }
1962         err = 4;
1963 fail:
1964         printk(KERN_INFO "err %u len %zu pos %u\n",
1965                         err, cp - name, pos);
1966         return -1;
1967 }
1968
1969 static ssize_t sbp_format_wwn(char *buf, size_t len, u64 wwn)
1970 {
1971         return snprintf(buf, len, "%016llx", wwn);
1972 }
1973
1974 static int sbp_init_nodeacl(struct se_node_acl *se_nacl, const char *name)
1975 {
1976         u64 guid = 0;
1977
1978         if (sbp_parse_wwn(name, &guid) < 0)
1979                 return -EINVAL;
1980         return 0;
1981 }
1982
1983 static int sbp_post_link_lun(
1984                 struct se_portal_group *se_tpg,
1985                 struct se_lun *se_lun)
1986 {
1987         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
1988
1989         return sbp_update_unit_directory(tpg->tport);
1990 }
1991
1992 static void sbp_pre_unlink_lun(
1993                 struct se_portal_group *se_tpg,
1994                 struct se_lun *se_lun)
1995 {
1996         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
1997         struct sbp_tport *tport = tpg->tport;
1998         int ret;
1999
2000         if (sbp_count_se_tpg_luns(&tpg->se_tpg) == 0)
2001                 tport->enable = 0;
2002
2003         ret = sbp_update_unit_directory(tport);
2004         if (ret < 0)
2005                 pr_err("unlink LUN: failed to update unit directory\n");
2006 }
2007
2008 static struct se_portal_group *sbp_make_tpg(struct se_wwn *wwn,
2009                                             const char *name)
2010 {
2011         struct sbp_tport *tport =
2012                 container_of(wwn, struct sbp_tport, tport_wwn);
2013
2014         struct sbp_tpg *tpg;
2015         unsigned long tpgt;
2016         int ret;
2017
2018         if (strstr(name, "tpgt_") != name)
2019                 return ERR_PTR(-EINVAL);
2020         if (kstrtoul(name + 5, 10, &tpgt) || tpgt > UINT_MAX)
2021                 return ERR_PTR(-EINVAL);
2022
2023         if (tport->tpg) {
2024                 pr_err("Only one TPG per Unit is possible.\n");
2025                 return ERR_PTR(-EBUSY);
2026         }
2027
2028         tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);
2029         if (!tpg)
2030                 return ERR_PTR(-ENOMEM);
2031
2032         tpg->tport = tport;
2033         tpg->tport_tpgt = tpgt;
2034         tport->tpg = tpg;
2035
2036         /* default attribute values */
2037         tport->enable = 0;
2038         tport->directory_id = -1;
2039         tport->mgt_orb_timeout = 15;
2040         tport->max_reconnect_timeout = 5;
2041         tport->max_logins_per_lun = 1;
2042
2043         tport->mgt_agt = sbp_management_agent_register(tport);
2044         if (IS_ERR(tport->mgt_agt)) {
2045                 ret = PTR_ERR(tport->mgt_agt);
2046                 goto out_free_tpg;
2047         }
2048
2049         ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_SBP);
2050         if (ret < 0)
2051                 goto out_unreg_mgt_agt;
2052
2053         return &tpg->se_tpg;
2054
2055 out_unreg_mgt_agt:
2056         sbp_management_agent_unregister(tport->mgt_agt);
2057 out_free_tpg:
2058         tport->tpg = NULL;
2059         kfree(tpg);
2060         return ERR_PTR(ret);
2061 }
2062
2063 static void sbp_drop_tpg(struct se_portal_group *se_tpg)
2064 {
2065         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2066         struct sbp_tport *tport = tpg->tport;
2067
2068         core_tpg_deregister(se_tpg);
2069         sbp_management_agent_unregister(tport->mgt_agt);
2070         tport->tpg = NULL;
2071         kfree(tpg);
2072 }
2073
2074 static struct se_wwn *sbp_make_tport(
2075                 struct target_fabric_configfs *tf,
2076                 struct config_group *group,
2077                 const char *name)
2078 {
2079         struct sbp_tport *tport;
2080         u64 guid = 0;
2081
2082         if (sbp_parse_wwn(name, &guid) < 0)
2083                 return ERR_PTR(-EINVAL);
2084
2085         tport = kzalloc(sizeof(*tport), GFP_KERNEL);
2086         if (!tport)
2087                 return ERR_PTR(-ENOMEM);
2088
2089         tport->guid = guid;
2090         sbp_format_wwn(tport->tport_name, SBP_NAMELEN, guid);
2091
2092         return &tport->tport_wwn;
2093 }
2094
2095 static void sbp_drop_tport(struct se_wwn *wwn)
2096 {
2097         struct sbp_tport *tport =
2098                 container_of(wwn, struct sbp_tport, tport_wwn);
2099
2100         kfree(tport);
2101 }
2102
2103 static ssize_t sbp_wwn_version_show(struct config_item *item, char *page)
2104 {
2105         return sprintf(page, "FireWire SBP fabric module %s\n", SBP_VERSION);
2106 }
2107
2108 CONFIGFS_ATTR_RO(sbp_wwn_, version);
2109
2110 static struct configfs_attribute *sbp_wwn_attrs[] = {
2111         &sbp_wwn_attr_version,
2112         NULL,
2113 };
2114
2115 static ssize_t sbp_tpg_directory_id_show(struct config_item *item, char *page)
2116 {
2117         struct se_portal_group *se_tpg = to_tpg(item);
2118         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2119         struct sbp_tport *tport = tpg->tport;
2120
2121         if (tport->directory_id == -1)
2122                 return sprintf(page, "implicit\n");
2123         else
2124                 return sprintf(page, "%06x\n", tport->directory_id);
2125 }
2126
2127 static ssize_t sbp_tpg_directory_id_store(struct config_item *item,
2128                 const char *page, size_t count)
2129 {
2130         struct se_portal_group *se_tpg = to_tpg(item);
2131         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2132         struct sbp_tport *tport = tpg->tport;
2133         unsigned long val;
2134
2135         if (tport->enable) {
2136                 pr_err("Cannot change the directory_id on an active target.\n");
2137                 return -EBUSY;
2138         }
2139
2140         if (strstr(page, "implicit") == page) {
2141                 tport->directory_id = -1;
2142         } else {
2143                 if (kstrtoul(page, 16, &val) < 0)
2144                         return -EINVAL;
2145                 if (val > 0xffffff)
2146                         return -EINVAL;
2147
2148                 tport->directory_id = val;
2149         }
2150
2151         return count;
2152 }
2153
2154 static ssize_t sbp_tpg_enable_show(struct config_item *item, char *page)
2155 {
2156         struct se_portal_group *se_tpg = to_tpg(item);
2157         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2158         struct sbp_tport *tport = tpg->tport;
2159         return sprintf(page, "%d\n", tport->enable);
2160 }
2161
2162 static ssize_t sbp_tpg_enable_store(struct config_item *item,
2163                 const char *page, size_t count)
2164 {
2165         struct se_portal_group *se_tpg = to_tpg(item);
2166         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2167         struct sbp_tport *tport = tpg->tport;
2168         unsigned long val;
2169         int ret;
2170
2171         if (kstrtoul(page, 0, &val) < 0)
2172                 return -EINVAL;
2173         if ((val != 0) && (val != 1))
2174                 return -EINVAL;
2175
2176         if (tport->enable == val)
2177                 return count;
2178
2179         if (val) {
2180                 if (sbp_count_se_tpg_luns(&tpg->se_tpg) == 0) {
2181                         pr_err("Cannot enable a target with no LUNs!\n");
2182                         return -EINVAL;
2183                 }
2184         } else {
2185                 /* XXX: force-shutdown sessions instead? */
2186                 spin_lock_bh(&se_tpg->session_lock);
2187                 if (!list_empty(&se_tpg->tpg_sess_list)) {
2188                         spin_unlock_bh(&se_tpg->session_lock);
2189                         return -EBUSY;
2190                 }
2191                 spin_unlock_bh(&se_tpg->session_lock);
2192         }
2193
2194         tport->enable = val;
2195
2196         ret = sbp_update_unit_directory(tport);
2197         if (ret < 0) {
2198                 pr_err("Could not update Config ROM\n");
2199                 return ret;
2200         }
2201
2202         return count;
2203 }
2204
2205 CONFIGFS_ATTR(sbp_tpg_, directory_id);
2206 CONFIGFS_ATTR(sbp_tpg_, enable);
2207
2208 static struct configfs_attribute *sbp_tpg_base_attrs[] = {
2209         &sbp_tpg_attr_directory_id,
2210         &sbp_tpg_attr_enable,
2211         NULL,
2212 };
2213
2214 static ssize_t sbp_tpg_attrib_mgt_orb_timeout_show(struct config_item *item,
2215                 char *page)
2216 {
2217         struct se_portal_group *se_tpg = attrib_to_tpg(item);
2218         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2219         struct sbp_tport *tport = tpg->tport;
2220         return sprintf(page, "%d\n", tport->mgt_orb_timeout);
2221 }
2222
2223 static ssize_t sbp_tpg_attrib_mgt_orb_timeout_store(struct config_item *item,
2224                 const char *page, size_t count)
2225 {
2226         struct se_portal_group *se_tpg = attrib_to_tpg(item);
2227         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2228         struct sbp_tport *tport = tpg->tport;
2229         unsigned long val;
2230         int ret;
2231
2232         if (kstrtoul(page, 0, &val) < 0)
2233                 return -EINVAL;
2234         if ((val < 1) || (val > 127))
2235                 return -EINVAL;
2236
2237         if (tport->mgt_orb_timeout == val)
2238                 return count;
2239
2240         tport->mgt_orb_timeout = val;
2241
2242         ret = sbp_update_unit_directory(tport);
2243         if (ret < 0)
2244                 return ret;
2245
2246         return count;
2247 }
2248
2249 static ssize_t sbp_tpg_attrib_max_reconnect_timeout_show(struct config_item *item,
2250                 char *page)
2251 {
2252         struct se_portal_group *se_tpg = attrib_to_tpg(item);
2253         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2254         struct sbp_tport *tport = tpg->tport;
2255         return sprintf(page, "%d\n", tport->max_reconnect_timeout);
2256 }
2257
2258 static ssize_t sbp_tpg_attrib_max_reconnect_timeout_store(struct config_item *item,
2259                 const char *page, size_t count)
2260 {
2261         struct se_portal_group *se_tpg = attrib_to_tpg(item);
2262         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2263         struct sbp_tport *tport = tpg->tport;
2264         unsigned long val;
2265         int ret;
2266
2267         if (kstrtoul(page, 0, &val) < 0)
2268                 return -EINVAL;
2269         if ((val < 1) || (val > 32767))
2270                 return -EINVAL;
2271
2272         if (tport->max_reconnect_timeout == val)
2273                 return count;
2274
2275         tport->max_reconnect_timeout = val;
2276
2277         ret = sbp_update_unit_directory(tport);
2278         if (ret < 0)
2279                 return ret;
2280
2281         return count;
2282 }
2283
2284 static ssize_t sbp_tpg_attrib_max_logins_per_lun_show(struct config_item *item,
2285                 char *page)
2286 {
2287         struct se_portal_group *se_tpg = attrib_to_tpg(item);
2288         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2289         struct sbp_tport *tport = tpg->tport;
2290         return sprintf(page, "%d\n", tport->max_logins_per_lun);
2291 }
2292
2293 static ssize_t sbp_tpg_attrib_max_logins_per_lun_store(struct config_item *item,
2294                 const char *page, size_t count)
2295 {
2296         struct se_portal_group *se_tpg = attrib_to_tpg(item);
2297         struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
2298         struct sbp_tport *tport = tpg->tport;
2299         unsigned long val;
2300
2301         if (kstrtoul(page, 0, &val) < 0)
2302                 return -EINVAL;
2303         if ((val < 1) || (val > 127))
2304                 return -EINVAL;
2305
2306         /* XXX: also check against current count? */
2307
2308         tport->max_logins_per_lun = val;
2309
2310         return count;
2311 }
2312
2313 CONFIGFS_ATTR(sbp_tpg_attrib_, mgt_orb_timeout);
2314 CONFIGFS_ATTR(sbp_tpg_attrib_, max_reconnect_timeout);
2315 CONFIGFS_ATTR(sbp_tpg_attrib_, max_logins_per_lun);
2316
2317 static struct configfs_attribute *sbp_tpg_attrib_attrs[] = {
2318         &sbp_tpg_attrib_attr_mgt_orb_timeout,
2319         &sbp_tpg_attrib_attr_max_reconnect_timeout,
2320         &sbp_tpg_attrib_attr_max_logins_per_lun,
2321         NULL,
2322 };
2323
2324 static const struct target_core_fabric_ops sbp_ops = {
2325         .module                         = THIS_MODULE,
2326         .name                           = "sbp",
2327         .get_fabric_name                = sbp_get_fabric_name,
2328         .tpg_get_wwn                    = sbp_get_fabric_wwn,
2329         .tpg_get_tag                    = sbp_get_tag,
2330         .tpg_check_demo_mode            = sbp_check_true,
2331         .tpg_check_demo_mode_cache      = sbp_check_true,
2332         .tpg_check_demo_mode_write_protect = sbp_check_false,
2333         .tpg_check_prod_mode_write_protect = sbp_check_false,
2334         .tpg_get_inst_index             = sbp_tpg_get_inst_index,
2335         .release_cmd                    = sbp_release_cmd,
2336         .sess_get_index                 = sbp_sess_get_index,
2337         .write_pending                  = sbp_write_pending,
2338         .write_pending_status           = sbp_write_pending_status,
2339         .set_default_node_attributes    = sbp_set_default_node_attrs,
2340         .get_cmd_state                  = sbp_get_cmd_state,
2341         .queue_data_in                  = sbp_queue_data_in,
2342         .queue_status                   = sbp_queue_status,
2343         .queue_tm_rsp                   = sbp_queue_tm_rsp,
2344         .aborted_task                   = sbp_aborted_task,
2345         .check_stop_free                = sbp_check_stop_free,
2346
2347         .fabric_make_wwn                = sbp_make_tport,
2348         .fabric_drop_wwn                = sbp_drop_tport,
2349         .fabric_make_tpg                = sbp_make_tpg,
2350         .fabric_drop_tpg                = sbp_drop_tpg,
2351         .fabric_post_link               = sbp_post_link_lun,
2352         .fabric_pre_unlink              = sbp_pre_unlink_lun,
2353         .fabric_make_np                 = NULL,
2354         .fabric_drop_np                 = NULL,
2355         .fabric_init_nodeacl            = sbp_init_nodeacl,
2356
2357         .tfc_wwn_attrs                  = sbp_wwn_attrs,
2358         .tfc_tpg_base_attrs             = sbp_tpg_base_attrs,
2359         .tfc_tpg_attrib_attrs           = sbp_tpg_attrib_attrs,
2360 };
2361
2362 static int __init sbp_init(void)
2363 {
2364         return target_register_template(&sbp_ops);
2365 };
2366
2367 static void __exit sbp_exit(void)
2368 {
2369         target_unregister_template(&sbp_ops);
2370 };
2371
2372 MODULE_DESCRIPTION("FireWire SBP fabric driver");
2373 MODULE_LICENSE("GPL");
2374 module_init(sbp_init);
2375 module_exit(sbp_exit);