]> git.karo-electronics.de Git - mv-sheeva.git/blob - drivers/scsi/cxgb3i/cxgb3i_iscsi.c
x86_64: fix incorrect comments
[mv-sheeva.git] / drivers / scsi / cxgb3i / cxgb3i_iscsi.c
1 /* cxgb3i_iscsi.c: Chelsio S3xx iSCSI driver.
2  *
3  * Copyright (c) 2008 Chelsio Communications, Inc.
4  * Copyright (c) 2008 Mike Christie
5  * Copyright (c) 2008 Red Hat, Inc.  All rights reserved.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation.
10  *
11  * Written by: Karen Xie (kxie@chelsio.com)
12  */
13
14 #include <linux/inet.h>
15 #include <linux/crypto.h>
16 #include <net/tcp.h>
17 #include <scsi/scsi_cmnd.h>
18 #include <scsi/scsi_device.h>
19 #include <scsi/scsi_eh.h>
20 #include <scsi/scsi_host.h>
21 #include <scsi/scsi.h>
22 #include <scsi/iscsi_proto.h>
23 #include <scsi/libiscsi.h>
24 #include <scsi/scsi_transport_iscsi.h>
25
26 #include "cxgb3i.h"
27 #include "cxgb3i_pdu.h"
28
29 #ifdef __DEBUG_CXGB3I_TAG__
30 #define cxgb3i_tag_debug        cxgb3i_log_debug
31 #else
32 #define cxgb3i_tag_debug(fmt...)
33 #endif
34
35 #ifdef __DEBUG_CXGB3I_API__
36 #define cxgb3i_api_debug        cxgb3i_log_debug
37 #else
38 #define cxgb3i_api_debug(fmt...)
39 #endif
40
41 /*
42  * align pdu size to multiple of 512 for better performance
43  */
44 #define align_pdu_size(n) do { n = (n) & (~511); } while (0)
45
46 static struct scsi_transport_template *cxgb3i_scsi_transport;
47 static struct scsi_host_template cxgb3i_host_template;
48 static struct iscsi_transport cxgb3i_iscsi_transport;
49 static unsigned char sw_tag_idx_bits;
50 static unsigned char sw_tag_age_bits;
51
52 static LIST_HEAD(cxgb3i_snic_list);
53 static DEFINE_RWLOCK(cxgb3i_snic_rwlock);
54
55 /**
56  * cxgb3i_adpater_find_by_tdev - find the cxgb3i_adapter structure via t3cdev
57  * @tdev: t3cdev pointer
58  */
59 struct cxgb3i_adapter *cxgb3i_adapter_find_by_tdev(struct t3cdev *tdev)
60 {
61         struct cxgb3i_adapter *snic;
62
63         read_lock(&cxgb3i_snic_rwlock);
64         list_for_each_entry(snic, &cxgb3i_snic_list, list_head) {
65                 if (snic->tdev == tdev) {
66                         read_unlock(&cxgb3i_snic_rwlock);
67                         return snic;
68                 }
69         }
70         read_unlock(&cxgb3i_snic_rwlock);
71         return NULL;
72 }
73
74 static inline int adapter_update(struct cxgb3i_adapter *snic)
75 {
76         cxgb3i_log_info("snic 0x%p, t3dev 0x%p, updating.\n",
77                         snic, snic->tdev);
78         return cxgb3i_adapter_ddp_info(snic->tdev, &snic->tag_format,
79                                         &snic->tx_max_size,
80                                         &snic->rx_max_size);
81 }
82
83 static int adapter_add(struct cxgb3i_adapter *snic)
84 {
85         struct t3cdev *t3dev = snic->tdev;
86         struct adapter *adapter = tdev2adap(t3dev);
87         int i, err;
88
89         snic->pdev = adapter->pdev;
90         snic->tag_format.sw_bits = sw_tag_idx_bits + sw_tag_age_bits;
91
92         err = cxgb3i_adapter_ddp_info(t3dev, &snic->tag_format,
93                                     &snic->tx_max_size,
94                                     &snic->rx_max_size);
95         if (err < 0)
96                 return err;
97
98         for_each_port(adapter, i) {
99                 snic->hba[i] = cxgb3i_hba_host_add(snic, adapter->port[i]);
100                 if (!snic->hba[i])
101                         return -EINVAL;
102         }
103         snic->hba_cnt = adapter->params.nports;
104
105         /* add to the list */
106         write_lock(&cxgb3i_snic_rwlock);
107         list_add_tail(&snic->list_head, &cxgb3i_snic_list);
108         write_unlock(&cxgb3i_snic_rwlock);
109
110         cxgb3i_log_info("t3dev 0x%p open, snic 0x%p, %u scsi hosts added.\n",
111                         t3dev, snic, snic->hba_cnt);
112         return 0;
113 }
114
115 /**
116  * cxgb3i_adapter_open - init a s3 adapter structure and any h/w settings
117  * @t3dev: t3cdev adapter
118  */
119 void cxgb3i_adapter_open(struct t3cdev *t3dev)
120 {
121         struct cxgb3i_adapter *snic = cxgb3i_adapter_find_by_tdev(t3dev);
122         int err;
123
124         if (snic)
125                 err = adapter_update(snic);
126         else {
127                 snic = kzalloc(sizeof(*snic), GFP_KERNEL);
128                 if (snic) {
129                         spin_lock_init(&snic->lock);
130                         snic->tdev = t3dev;
131                         err = adapter_add(snic);
132                 } else
133                         err = -ENOMEM;
134         }
135
136         if (err < 0) {
137                 cxgb3i_log_info("snic 0x%p, f 0x%x, t3dev 0x%p open, err %d.\n",
138                                 snic, snic ? snic->flags : 0, t3dev, err);
139                 if (snic) {
140                         snic->flags &= ~CXGB3I_ADAPTER_FLAG_RESET;
141                         cxgb3i_adapter_close(t3dev);
142                 }
143         }
144 }
145
146 /**
147  * cxgb3i_adapter_close - release the resources held and cleanup h/w settings
148  * @t3dev: t3cdev adapter
149  */
150 void cxgb3i_adapter_close(struct t3cdev *t3dev)
151 {
152         struct cxgb3i_adapter *snic = cxgb3i_adapter_find_by_tdev(t3dev);
153         int i;
154
155         if (!snic || snic->flags & CXGB3I_ADAPTER_FLAG_RESET) {
156                 cxgb3i_log_info("t3dev 0x%p close, snic 0x%p, f 0x%x.\n",
157                                 t3dev, snic, snic ? snic->flags : 0);
158                 return;
159         }
160
161         /* remove from the list */
162         write_lock(&cxgb3i_snic_rwlock);
163         list_del(&snic->list_head);
164         write_unlock(&cxgb3i_snic_rwlock);
165
166         for (i = 0; i < snic->hba_cnt; i++) {
167                 if (snic->hba[i]) {
168                         cxgb3i_hba_host_remove(snic->hba[i]);
169                         snic->hba[i] = NULL;
170                 }
171         }
172         cxgb3i_log_info("t3dev 0x%p close, snic 0x%p, %u scsi hosts removed.\n",
173                         t3dev, snic, snic->hba_cnt);
174         kfree(snic);
175 }
176
177 /**
178  * cxgb3i_hba_find_by_netdev - find the cxgb3i_hba structure via net_device
179  * @t3dev: t3cdev adapter
180  */
181 struct cxgb3i_hba *cxgb3i_hba_find_by_netdev(struct net_device *ndev)
182 {
183         struct cxgb3i_adapter *snic;
184         int i;
185
186         read_lock(&cxgb3i_snic_rwlock);
187         list_for_each_entry(snic, &cxgb3i_snic_list, list_head) {
188                 for (i = 0; i < snic->hba_cnt; i++) {
189                         if (snic->hba[i]->ndev == ndev) {
190                                 read_unlock(&cxgb3i_snic_rwlock);
191                                 return snic->hba[i];
192                         }
193                 }
194         }
195         read_unlock(&cxgb3i_snic_rwlock);
196         return NULL;
197 }
198
199 /**
200  * cxgb3i_hba_host_add - register a new host with scsi/iscsi
201  * @snic: the cxgb3i adapter
202  * @ndev: associated net_device
203  */
204 struct cxgb3i_hba *cxgb3i_hba_host_add(struct cxgb3i_adapter *snic,
205                                        struct net_device *ndev)
206 {
207         struct cxgb3i_hba *hba;
208         struct Scsi_Host *shost;
209         int err;
210
211         shost = iscsi_host_alloc(&cxgb3i_host_template,
212                                  sizeof(struct cxgb3i_hba), 1);
213         if (!shost) {
214                 cxgb3i_log_info("snic 0x%p, ndev 0x%p, host_alloc failed.\n",
215                                 snic, ndev);
216                 return NULL;
217         }
218
219         shost->transportt = cxgb3i_scsi_transport;
220         shost->max_lun = CXGB3I_MAX_LUN;
221         shost->max_id = CXGB3I_MAX_TARGET;
222         shost->max_channel = 0;
223         shost->max_cmd_len = 16;
224
225         hba = iscsi_host_priv(shost);
226         hba->snic = snic;
227         hba->ndev = ndev;
228         hba->shost = shost;
229
230         pci_dev_get(snic->pdev);
231         err = iscsi_host_add(shost, &snic->pdev->dev);
232         if (err) {
233                 cxgb3i_log_info("snic 0x%p, ndev 0x%p, host_add failed.\n",
234                                 snic, ndev);
235                 goto pci_dev_put;
236         }
237
238         cxgb3i_api_debug("shost 0x%p, hba 0x%p, no %u.\n",
239                          shost, hba, shost->host_no);
240
241         return hba;
242
243 pci_dev_put:
244         pci_dev_put(snic->pdev);
245         scsi_host_put(shost);
246         return NULL;
247 }
248
249 /**
250  * cxgb3i_hba_host_remove - de-register the host with scsi/iscsi
251  * @hba: the cxgb3i hba
252  */
253 void cxgb3i_hba_host_remove(struct cxgb3i_hba *hba)
254 {
255         cxgb3i_api_debug("shost 0x%p, hba 0x%p, no %u.\n",
256                          hba->shost, hba, hba->shost->host_no);
257         iscsi_host_remove(hba->shost);
258         pci_dev_put(hba->snic->pdev);
259         iscsi_host_free(hba->shost);
260 }
261
262 /**
263  * cxgb3i_ep_connect - establish TCP connection to target portal
264  * @dst_addr:           target IP address
265  * @non_blocking:       blocking or non-blocking call
266  *
267  * Initiates a TCP/IP connection to the dst_addr
268  */
269 static struct iscsi_endpoint *cxgb3i_ep_connect(struct sockaddr *dst_addr,
270                                                 int non_blocking)
271 {
272         struct iscsi_endpoint *ep;
273         struct cxgb3i_endpoint *cep;
274         struct cxgb3i_hba *hba;
275         struct s3_conn *c3cn = NULL;
276         int err = 0;
277
278         c3cn = cxgb3i_c3cn_create();
279         if (!c3cn) {
280                 cxgb3i_log_info("ep connect OOM.\n");
281                 err = -ENOMEM;
282                 goto release_conn;
283         }
284
285         err = cxgb3i_c3cn_connect(c3cn, (struct sockaddr_in *)dst_addr);
286         if (err < 0) {
287                 cxgb3i_log_info("ep connect failed.\n");
288                 goto release_conn;
289         }
290         hba = cxgb3i_hba_find_by_netdev(c3cn->dst_cache->dev);
291         if (!hba) {
292                 err = -ENOSPC;
293                 cxgb3i_log_info("NOT going through cxgbi device.\n");
294                 goto release_conn;
295         }
296         if (c3cn_is_closing(c3cn)) {
297                 err = -ENOSPC;
298                 cxgb3i_log_info("ep connect unable to connect.\n");
299                 goto release_conn;
300         }
301
302         ep = iscsi_create_endpoint(sizeof(*cep));
303         if (!ep) {
304                 err = -ENOMEM;
305                 cxgb3i_log_info("iscsi alloc ep, OOM.\n");
306                 goto release_conn;
307         }
308         cep = ep->dd_data;
309         cep->c3cn = c3cn;
310         cep->hba = hba;
311
312         cxgb3i_api_debug("ep 0x%p, 0x%p, c3cn 0x%p, hba 0x%p.\n",
313                           ep, cep, c3cn, hba);
314         return ep;
315
316 release_conn:
317         cxgb3i_api_debug("conn 0x%p failed, release.\n", c3cn);
318         if (c3cn)
319                 cxgb3i_c3cn_release(c3cn);
320         return ERR_PTR(err);
321 }
322
323 /**
324  * cxgb3i_ep_poll - polls for TCP connection establishement
325  * @ep:         TCP connection (endpoint) handle
326  * @timeout_ms: timeout value in milli secs
327  *
328  * polls for TCP connect request to complete
329  */
330 static int cxgb3i_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
331 {
332         struct cxgb3i_endpoint *cep = ep->dd_data;
333         struct s3_conn *c3cn = cep->c3cn;
334
335         if (!c3cn_is_established(c3cn))
336                 return 0;
337         cxgb3i_api_debug("ep 0x%p, c3cn 0x%p established.\n", ep, c3cn);
338         return 1;
339 }
340
341 /**
342  * cxgb3i_ep_disconnect - teardown TCP connection
343  * @ep:         TCP connection (endpoint) handle
344  *
345  * teardown TCP connection
346  */
347 static void cxgb3i_ep_disconnect(struct iscsi_endpoint *ep)
348 {
349         struct cxgb3i_endpoint *cep = ep->dd_data;
350         struct cxgb3i_conn *cconn = cep->cconn;
351
352         cxgb3i_api_debug("ep 0x%p, cep 0x%p.\n", ep, cep);
353
354         if (cconn && cconn->conn) {
355                 /*
356                  * stop the xmit path so the xmit_pdu function is
357                  * not being called
358                  */
359                 iscsi_suspend_tx(cconn->conn);
360
361                 write_lock_bh(&cep->c3cn->callback_lock);
362                 cep->c3cn->user_data = NULL;
363                 cconn->cep = NULL;
364                 write_unlock_bh(&cep->c3cn->callback_lock);
365         }
366
367         cxgb3i_api_debug("ep 0x%p, cep 0x%p, release c3cn 0x%p.\n",
368                          ep, cep, cep->c3cn);
369         cxgb3i_c3cn_release(cep->c3cn);
370         iscsi_destroy_endpoint(ep);
371 }
372
373 /**
374  * cxgb3i_session_create - create a new iscsi session
375  * @cmds_max:           max # of commands
376  * @qdepth:             scsi queue depth
377  * @initial_cmdsn:      initial iscsi CMDSN for this session
378  *
379  * Creates a new iSCSI session
380  */
381 static struct iscsi_cls_session *
382 cxgb3i_session_create(struct iscsi_endpoint *ep, u16 cmds_max, u16 qdepth,
383                       u32 initial_cmdsn)
384 {
385         struct cxgb3i_endpoint *cep;
386         struct cxgb3i_hba *hba;
387         struct Scsi_Host *shost;
388         struct iscsi_cls_session *cls_session;
389         struct iscsi_session *session;
390
391         if (!ep) {
392                 cxgb3i_log_error("%s, missing endpoint.\n", __func__);
393                 return NULL;
394         }
395
396         cep = ep->dd_data;
397         hba = cep->hba;
398         shost = hba->shost;
399         cxgb3i_api_debug("ep 0x%p, cep 0x%p, hba 0x%p.\n", ep, cep, hba);
400         BUG_ON(hba != iscsi_host_priv(shost));
401
402         cls_session = iscsi_session_setup(&cxgb3i_iscsi_transport, shost,
403                                           cmds_max,
404                                           sizeof(struct iscsi_tcp_task) +
405                                           sizeof(struct cxgb3i_task_data),
406                                           initial_cmdsn, ISCSI_MAX_TARGET);
407         if (!cls_session)
408                 return NULL;
409         session = cls_session->dd_data;
410         if (iscsi_tcp_r2tpool_alloc(session))
411                 goto remove_session;
412
413         return cls_session;
414
415 remove_session:
416         iscsi_session_teardown(cls_session);
417         return NULL;
418 }
419
420 /**
421  * cxgb3i_session_destroy - destroys iscsi session
422  * @cls_session:        pointer to iscsi cls session
423  *
424  * Destroys an iSCSI session instance and releases its all resources held
425  */
426 static void cxgb3i_session_destroy(struct iscsi_cls_session *cls_session)
427 {
428         cxgb3i_api_debug("sess 0x%p.\n", cls_session);
429         iscsi_tcp_r2tpool_free(cls_session->dd_data);
430         iscsi_session_teardown(cls_session);
431 }
432
433 /**
434  * cxgb3i_conn_max_xmit_dlength -- calc the max. xmit pdu segment size
435  * @conn: iscsi connection
436  * check the max. xmit pdu payload, reduce it if needed
437  */
438 static inline int cxgb3i_conn_max_xmit_dlength(struct iscsi_conn *conn)
439
440 {
441         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
442         struct cxgb3i_conn *cconn = tcp_conn->dd_data;
443         unsigned int max = max(512 * MAX_SKB_FRAGS, SKB_TX_HEADROOM);
444
445         max = min(cconn->hba->snic->tx_max_size, max);
446         if (conn->max_xmit_dlength)
447                 conn->max_xmit_dlength = min(conn->max_xmit_dlength, max);
448         else
449                 conn->max_xmit_dlength = max;
450         align_pdu_size(conn->max_xmit_dlength);
451         cxgb3i_api_debug("conn 0x%p, max xmit %u.\n",
452                          conn, conn->max_xmit_dlength);
453         return 0;
454 }
455
456 /**
457  * cxgb3i_conn_max_recv_dlength -- check the max. recv pdu segment size
458  * @conn: iscsi connection
459  * return 0 if the value is valid, < 0 otherwise.
460  */
461 static inline int cxgb3i_conn_max_recv_dlength(struct iscsi_conn *conn)
462 {
463         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
464         struct cxgb3i_conn *cconn = tcp_conn->dd_data;
465         unsigned int max = cconn->hba->snic->rx_max_size;
466
467         align_pdu_size(max);
468         if (conn->max_recv_dlength) {
469                 if (conn->max_recv_dlength > max) {
470                         cxgb3i_log_error("MaxRecvDataSegmentLength %u too big."
471                                          " Need to be <= %u.\n",
472                                          conn->max_recv_dlength, max);
473                         return -EINVAL;
474                 }
475                 conn->max_recv_dlength = min(conn->max_recv_dlength, max);
476                 align_pdu_size(conn->max_recv_dlength);
477         } else
478                 conn->max_recv_dlength = max;
479         cxgb3i_api_debug("conn 0x%p, max recv %u.\n",
480                          conn, conn->max_recv_dlength);
481         return 0;
482 }
483
484 /**
485  * cxgb3i_conn_create - create iscsi connection instance
486  * @cls_session:        pointer to iscsi cls session
487  * @cid:                iscsi cid
488  *
489  * Creates a new iSCSI connection instance for a given session
490  */
491 static struct iscsi_cls_conn *cxgb3i_conn_create(struct iscsi_cls_session
492                                                  *cls_session, u32 cid)
493 {
494         struct iscsi_cls_conn *cls_conn;
495         struct iscsi_conn *conn;
496         struct iscsi_tcp_conn *tcp_conn;
497         struct cxgb3i_conn *cconn;
498
499         cxgb3i_api_debug("sess 0x%p, cid %u.\n", cls_session, cid);
500
501         cls_conn = iscsi_tcp_conn_setup(cls_session, sizeof(*cconn), cid);
502         if (!cls_conn)
503                 return NULL;
504         conn = cls_conn->dd_data;
505         tcp_conn = conn->dd_data;
506         cconn = tcp_conn->dd_data;
507
508         cconn->conn = conn;
509         return cls_conn;
510 }
511
512 /**
513  * cxgb3i_conn_bind - binds iscsi sess, conn and endpoint together
514  * @cls_session:        pointer to iscsi cls session
515  * @cls_conn:           pointer to iscsi cls conn
516  * @transport_eph:      64-bit EP handle
517  * @is_leading:         leading connection on this session?
518  *
519  * Binds together an iSCSI session, an iSCSI connection and a
520  *      TCP connection. This routine returns error code if the TCP
521  *      connection does not belong on the device iSCSI sess/conn is bound
522  */
523
524 static int cxgb3i_conn_bind(struct iscsi_cls_session *cls_session,
525                             struct iscsi_cls_conn *cls_conn,
526                             u64 transport_eph, int is_leading)
527 {
528         struct iscsi_conn *conn = cls_conn->dd_data;
529         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
530         struct cxgb3i_conn *cconn = tcp_conn->dd_data;
531         struct cxgb3i_adapter *snic;
532         struct iscsi_endpoint *ep;
533         struct cxgb3i_endpoint *cep;
534         struct s3_conn *c3cn;
535         int err;
536
537         ep = iscsi_lookup_endpoint(transport_eph);
538         if (!ep)
539                 return -EINVAL;
540
541         /* setup ddp pagesize */
542         cep = ep->dd_data;
543         c3cn = cep->c3cn;
544         snic = cep->hba->snic;
545         err = cxgb3i_setup_conn_host_pagesize(snic->tdev, c3cn->tid, 0);
546         if (err < 0)
547                 return err;
548
549         cxgb3i_api_debug("ep 0x%p, cls sess 0x%p, cls conn 0x%p.\n",
550                          ep, cls_session, cls_conn);
551
552         err = iscsi_conn_bind(cls_session, cls_conn, is_leading);
553         if (err)
554                 return -EINVAL;
555
556         /* calculate the tag idx bits needed for this conn based on cmds_max */
557         cconn->task_idx_bits = (__ilog2_u32(conn->session->cmds_max - 1)) + 1;
558         cxgb3i_api_debug("session cmds_max 0x%x, bits %u.\n",
559                          conn->session->cmds_max, cconn->task_idx_bits);
560
561         read_lock(&c3cn->callback_lock);
562         c3cn->user_data = conn;
563         cconn->hba = cep->hba;
564         cconn->cep = cep;
565         cep->cconn = cconn;
566         read_unlock(&c3cn->callback_lock);
567
568         cxgb3i_conn_max_xmit_dlength(conn);
569         cxgb3i_conn_max_recv_dlength(conn);
570
571         spin_lock_bh(&conn->session->lock);
572         sprintf(conn->portal_address, NIPQUAD_FMT,
573                 NIPQUAD(c3cn->daddr.sin_addr.s_addr));
574         conn->portal_port = ntohs(c3cn->daddr.sin_port);
575         spin_unlock_bh(&conn->session->lock);
576
577         /* init recv engine */
578         iscsi_tcp_hdr_recv_prep(tcp_conn);
579
580         return 0;
581 }
582
583 /**
584  * cxgb3i_conn_get_param - return iscsi connection parameter to caller
585  * @cls_conn:   pointer to iscsi cls conn
586  * @param:      parameter type identifier
587  * @buf:        buffer pointer
588  *
589  * returns iSCSI connection parameters
590  */
591 static int cxgb3i_conn_get_param(struct iscsi_cls_conn *cls_conn,
592                                  enum iscsi_param param, char *buf)
593 {
594         struct iscsi_conn *conn = cls_conn->dd_data;
595         int len;
596
597         cxgb3i_api_debug("cls_conn 0x%p, param %d.\n", cls_conn, param);
598
599         switch (param) {
600         case ISCSI_PARAM_CONN_PORT:
601                 spin_lock_bh(&conn->session->lock);
602                 len = sprintf(buf, "%hu\n", conn->portal_port);
603                 spin_unlock_bh(&conn->session->lock);
604                 break;
605         case ISCSI_PARAM_CONN_ADDRESS:
606                 spin_lock_bh(&conn->session->lock);
607                 len = sprintf(buf, "%s\n", conn->portal_address);
608                 spin_unlock_bh(&conn->session->lock);
609                 break;
610         default:
611                 return iscsi_conn_get_param(cls_conn, param, buf);
612         }
613
614         return len;
615 }
616
617 /**
618  * cxgb3i_conn_set_param - set iscsi connection parameter
619  * @cls_conn:   pointer to iscsi cls conn
620  * @param:      parameter type identifier
621  * @buf:        buffer pointer
622  * @buflen:     buffer length
623  *
624  * set iSCSI connection parameters
625  */
626 static int cxgb3i_conn_set_param(struct iscsi_cls_conn *cls_conn,
627                                  enum iscsi_param param, char *buf, int buflen)
628 {
629         struct iscsi_conn *conn = cls_conn->dd_data;
630         struct iscsi_session *session = conn->session;
631         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
632         struct cxgb3i_conn *cconn = tcp_conn->dd_data;
633         struct cxgb3i_adapter *snic = cconn->hba->snic;
634         struct s3_conn *c3cn = cconn->cep->c3cn;
635         int value, err = 0;
636
637         switch (param) {
638         case ISCSI_PARAM_HDRDGST_EN:
639                 err = iscsi_set_param(cls_conn, param, buf, buflen);
640                 if (!err && conn->hdrdgst_en)
641                         err = cxgb3i_setup_conn_digest(snic->tdev, c3cn->tid,
642                                                         conn->hdrdgst_en,
643                                                         conn->datadgst_en, 0);
644                 break;
645         case ISCSI_PARAM_DATADGST_EN:
646                 err = iscsi_set_param(cls_conn, param, buf, buflen);
647                 if (!err && conn->datadgst_en)
648                         err = cxgb3i_setup_conn_digest(snic->tdev, c3cn->tid,
649                                                         conn->hdrdgst_en,
650                                                         conn->datadgst_en, 0);
651                 break;
652         case ISCSI_PARAM_MAX_R2T:
653                 sscanf(buf, "%d", &value);
654                 if (value <= 0 || !is_power_of_2(value))
655                         return -EINVAL;
656                 if (session->max_r2t == value)
657                         break;
658                 iscsi_tcp_r2tpool_free(session);
659                 err = iscsi_set_param(cls_conn, param, buf, buflen);
660                 if (!err && iscsi_tcp_r2tpool_alloc(session))
661                         return -ENOMEM;
662         case ISCSI_PARAM_MAX_RECV_DLENGTH:
663                 err = iscsi_set_param(cls_conn, param, buf, buflen);
664                 if (!err)
665                         err = cxgb3i_conn_max_recv_dlength(conn);
666                 break;
667         case ISCSI_PARAM_MAX_XMIT_DLENGTH:
668                 err = iscsi_set_param(cls_conn, param, buf, buflen);
669                 if (!err)
670                         err = cxgb3i_conn_max_xmit_dlength(conn);
671                 break;
672         default:
673                 return iscsi_set_param(cls_conn, param, buf, buflen);
674         }
675         return err;
676 }
677
678 /**
679  * cxgb3i_host_set_param - configure host (adapter) related parameters
680  * @shost:      scsi host pointer
681  * @param:      parameter type identifier
682  * @buf:        buffer pointer
683  */
684 static int cxgb3i_host_set_param(struct Scsi_Host *shost,
685                                  enum iscsi_host_param param,
686                                  char *buf, int buflen)
687 {
688         struct cxgb3i_hba *hba = iscsi_host_priv(shost);
689
690         cxgb3i_api_debug("param %d, buf %s.\n", param, buf);
691
692         switch (param) {
693         case ISCSI_HOST_PARAM_IPADDRESS:
694         {
695                 __be32 addr = in_aton(buf);
696                 cxgb3i_set_private_ipv4addr(hba->ndev, addr);
697                 return 0;
698         }
699         case ISCSI_HOST_PARAM_HWADDRESS:
700         case ISCSI_HOST_PARAM_NETDEV_NAME:
701                 /* ignore */
702                 return 0;
703         default:
704                 return iscsi_host_set_param(shost, param, buf, buflen);
705         }
706 }
707
708 /**
709  * cxgb3i_host_get_param - returns host (adapter) related parameters
710  * @shost:      scsi host pointer
711  * @param:      parameter type identifier
712  * @buf:        buffer pointer
713  */
714 static int cxgb3i_host_get_param(struct Scsi_Host *shost,
715                                  enum iscsi_host_param param, char *buf)
716 {
717         struct cxgb3i_hba *hba = iscsi_host_priv(shost);
718         int len = 0;
719
720         cxgb3i_api_debug("hba %s, param %d.\n", hba->ndev->name, param);
721
722         switch (param) {
723         case ISCSI_HOST_PARAM_HWADDRESS:
724                 len = sysfs_format_mac(buf, hba->ndev->dev_addr, 6);
725                 break;
726         case ISCSI_HOST_PARAM_NETDEV_NAME:
727                 len = sprintf(buf, "%s\n", hba->ndev->name);
728                 break;
729         case ISCSI_HOST_PARAM_IPADDRESS:
730         {
731                 __be32 addr;
732
733                 addr = cxgb3i_get_private_ipv4addr(hba->ndev);
734                 len = sprintf(buf, NIPQUAD_FMT, NIPQUAD(addr));
735                 break;
736         }
737         default:
738                 return iscsi_host_get_param(shost, param, buf);
739         }
740         return len;
741 }
742
743 /**
744  * cxgb3i_conn_get_stats - returns iSCSI stats
745  * @cls_conn:   pointer to iscsi cls conn
746  * @stats:      pointer to iscsi statistic struct
747  */
748 static void cxgb3i_conn_get_stats(struct iscsi_cls_conn *cls_conn,
749                                   struct iscsi_stats *stats)
750 {
751         struct iscsi_conn *conn = cls_conn->dd_data;
752
753         stats->txdata_octets = conn->txdata_octets;
754         stats->rxdata_octets = conn->rxdata_octets;
755         stats->scsicmd_pdus = conn->scsicmd_pdus_cnt;
756         stats->dataout_pdus = conn->dataout_pdus_cnt;
757         stats->scsirsp_pdus = conn->scsirsp_pdus_cnt;
758         stats->datain_pdus = conn->datain_pdus_cnt;
759         stats->r2t_pdus = conn->r2t_pdus_cnt;
760         stats->tmfcmd_pdus = conn->tmfcmd_pdus_cnt;
761         stats->tmfrsp_pdus = conn->tmfrsp_pdus_cnt;
762         stats->digest_err = 0;
763         stats->timeout_err = 0;
764         stats->custom_length = 1;
765         strcpy(stats->custom[0].desc, "eh_abort_cnt");
766         stats->custom[0].value = conn->eh_abort_cnt;
767 }
768
769 /**
770  * cxgb3i_parse_itt - get the idx and age bits from a given tag
771  * @conn:       iscsi connection
772  * @itt:        itt tag
773  * @idx:        task index, filled in by this function
774  * @age:        session age, filled in by this function
775  */
776 static void cxgb3i_parse_itt(struct iscsi_conn *conn, itt_t itt,
777                              int *idx, int *age)
778 {
779         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
780         struct cxgb3i_conn *cconn = tcp_conn->dd_data;
781         struct cxgb3i_adapter *snic = cconn->hba->snic;
782         u32 tag = ntohl((__force u32) itt);
783         u32 sw_bits;
784
785         sw_bits = cxgb3i_tag_nonrsvd_bits(&snic->tag_format, tag);
786         if (idx)
787                 *idx = sw_bits & ((1 << cconn->task_idx_bits) - 1);
788         if (age)
789                 *age = (sw_bits >> cconn->task_idx_bits) & ISCSI_AGE_MASK;
790
791         cxgb3i_tag_debug("parse tag 0x%x/0x%x, sw 0x%x, itt 0x%x, age 0x%x.\n",
792                          tag, itt, sw_bits, idx ? *idx : 0xFFFFF,
793                          age ? *age : 0xFF);
794 }
795
796 /**
797  * cxgb3i_reserve_itt - generate tag for a give task
798  * @task: iscsi task
799  * @hdr_itt: tag, filled in by this function
800  * Set up ddp for scsi read tasks if possible.
801  */
802 int cxgb3i_reserve_itt(struct iscsi_task *task, itt_t *hdr_itt)
803 {
804         struct scsi_cmnd *sc = task->sc;
805         struct iscsi_conn *conn = task->conn;
806         struct iscsi_session *sess = conn->session;
807         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
808         struct cxgb3i_conn *cconn = tcp_conn->dd_data;
809         struct cxgb3i_adapter *snic = cconn->hba->snic;
810         struct cxgb3i_tag_format *tformat = &snic->tag_format;
811         u32 sw_tag = (sess->age << cconn->task_idx_bits) | task->itt;
812         u32 tag;
813         int err = -EINVAL;
814
815         if (sc &&
816             (scsi_bidi_cmnd(sc) || sc->sc_data_direction == DMA_FROM_DEVICE) &&
817             cxgb3i_sw_tag_usable(tformat, sw_tag)) {
818                 struct s3_conn *c3cn = cconn->cep->c3cn;
819                 struct cxgb3i_gather_list *gl;
820
821                 gl = cxgb3i_ddp_make_gl(scsi_in(sc)->length,
822                                         scsi_in(sc)->table.sgl,
823                                         scsi_in(sc)->table.nents,
824                                         snic->pdev,
825                                         GFP_ATOMIC);
826                 if (gl) {
827                         tag = sw_tag;
828                         err = cxgb3i_ddp_tag_reserve(snic->tdev, c3cn->tid,
829                                                      tformat, &tag,
830                                                      gl, GFP_ATOMIC);
831                         if (err < 0)
832                                 cxgb3i_ddp_release_gl(gl, snic->pdev);
833                 }
834         }
835
836         if (err < 0)
837                 tag = cxgb3i_set_non_ddp_tag(tformat, sw_tag);
838         /* the itt need to sent in big-endian order */
839         *hdr_itt = (__force itt_t)htonl(tag);
840
841         cxgb3i_tag_debug("new tag 0x%x/0x%x (itt 0x%x, age 0x%x).\n",
842                          tag, *hdr_itt, task->itt, sess->age);
843         return 0;
844 }
845
846 /**
847  * cxgb3i_release_itt - release the tag for a given task
848  * @task:       iscsi task
849  * @hdr_itt:    tag
850  * If the tag is a ddp tag, release the ddp setup
851  */
852 void cxgb3i_release_itt(struct iscsi_task *task, itt_t hdr_itt)
853 {
854         struct scsi_cmnd *sc = task->sc;
855         struct iscsi_tcp_conn *tcp_conn = task->conn->dd_data;
856         struct cxgb3i_conn *cconn = tcp_conn->dd_data;
857         struct cxgb3i_adapter *snic = cconn->hba->snic;
858         struct cxgb3i_tag_format *tformat = &snic->tag_format;
859         u32 tag = ntohl((__force u32)hdr_itt);
860
861         cxgb3i_tag_debug("release tag 0x%x.\n", tag);
862
863         if (sc &&
864             (scsi_bidi_cmnd(sc) || sc->sc_data_direction == DMA_FROM_DEVICE) &&
865             cxgb3i_is_ddp_tag(tformat, tag))
866                 cxgb3i_ddp_tag_release(snic->tdev, tag);
867 }
868
869 /**
870  * cxgb3i_host_template -- Scsi_Host_Template structure
871  *      used when registering with the scsi mid layer
872  */
873 static struct scsi_host_template cxgb3i_host_template = {
874         .module                 = THIS_MODULE,
875         .name                   = "Chelsio S3xx iSCSI Initiator",
876         .proc_name              = "cxgb3i",
877         .queuecommand           = iscsi_queuecommand,
878         .change_queue_depth     = iscsi_change_queue_depth,
879         .can_queue              = CXGB3I_SCSI_QDEPTH_DFLT - 1,
880         .sg_tablesize           = SG_ALL,
881         .max_sectors            = 0xFFFF,
882         .cmd_per_lun            = CXGB3I_SCSI_QDEPTH_DFLT,
883         .eh_abort_handler       = iscsi_eh_abort,
884         .eh_device_reset_handler = iscsi_eh_device_reset,
885         .eh_target_reset_handler = iscsi_eh_target_reset,
886         .use_clustering         = DISABLE_CLUSTERING,
887         .this_id                = -1,
888 };
889
890 static struct iscsi_transport cxgb3i_iscsi_transport = {
891         .owner                  = THIS_MODULE,
892         .name                   = "cxgb3i",
893         .caps                   = CAP_RECOVERY_L0 | CAP_MULTI_R2T | CAP_HDRDGST
894                                 | CAP_DATADGST | CAP_DIGEST_OFFLOAD |
895                                 CAP_PADDING_OFFLOAD,
896         .param_mask             = ISCSI_MAX_RECV_DLENGTH |
897                                 ISCSI_MAX_XMIT_DLENGTH |
898                                 ISCSI_HDRDGST_EN |
899                                 ISCSI_DATADGST_EN |
900                                 ISCSI_INITIAL_R2T_EN |
901                                 ISCSI_MAX_R2T |
902                                 ISCSI_IMM_DATA_EN |
903                                 ISCSI_FIRST_BURST |
904                                 ISCSI_MAX_BURST |
905                                 ISCSI_PDU_INORDER_EN |
906                                 ISCSI_DATASEQ_INORDER_EN |
907                                 ISCSI_ERL |
908                                 ISCSI_CONN_PORT |
909                                 ISCSI_CONN_ADDRESS |
910                                 ISCSI_EXP_STATSN |
911                                 ISCSI_PERSISTENT_PORT |
912                                 ISCSI_PERSISTENT_ADDRESS |
913                                 ISCSI_TARGET_NAME | ISCSI_TPGT |
914                                 ISCSI_USERNAME | ISCSI_PASSWORD |
915                                 ISCSI_USERNAME_IN | ISCSI_PASSWORD_IN |
916                                 ISCSI_FAST_ABORT | ISCSI_ABORT_TMO |
917                                 ISCSI_LU_RESET_TMO |
918                                 ISCSI_PING_TMO | ISCSI_RECV_TMO |
919                                 ISCSI_IFACE_NAME | ISCSI_INITIATOR_NAME,
920         .host_param_mask        = ISCSI_HOST_HWADDRESS | ISCSI_HOST_IPADDRESS |
921                         ISCSI_HOST_INITIATOR_NAME | ISCSI_HOST_NETDEV_NAME,
922         .get_host_param         = cxgb3i_host_get_param,
923         .set_host_param         = cxgb3i_host_set_param,
924         /* session management */
925         .create_session         = cxgb3i_session_create,
926         .destroy_session        = cxgb3i_session_destroy,
927         .get_session_param      = iscsi_session_get_param,
928         /* connection management */
929         .create_conn            = cxgb3i_conn_create,
930         .bind_conn              = cxgb3i_conn_bind,
931         .destroy_conn           = iscsi_tcp_conn_teardown,
932         .start_conn             = iscsi_conn_start,
933         .stop_conn              = iscsi_conn_stop,
934         .get_conn_param         = cxgb3i_conn_get_param,
935         .set_param              = cxgb3i_conn_set_param,
936         .get_stats              = cxgb3i_conn_get_stats,
937         /* pdu xmit req. from user space */
938         .send_pdu               = iscsi_conn_send_pdu,
939         /* task */
940         .init_task              = iscsi_tcp_task_init,
941         .xmit_task              = iscsi_tcp_task_xmit,
942         .cleanup_task           = cxgb3i_conn_cleanup_task,
943
944         /* pdu */
945         .alloc_pdu              = cxgb3i_conn_alloc_pdu,
946         .init_pdu               = cxgb3i_conn_init_pdu,
947         .xmit_pdu               = cxgb3i_conn_xmit_pdu,
948         .parse_pdu_itt          = cxgb3i_parse_itt,
949
950         /* TCP connect/disconnect */
951         .ep_connect             = cxgb3i_ep_connect,
952         .ep_poll                = cxgb3i_ep_poll,
953         .ep_disconnect          = cxgb3i_ep_disconnect,
954         /* Error recovery timeout call */
955         .session_recovery_timedout = iscsi_session_recovery_timedout,
956 };
957
958 int cxgb3i_iscsi_init(void)
959 {
960         sw_tag_idx_bits = (__ilog2_u32(ISCSI_ITT_MASK)) + 1;
961         sw_tag_age_bits = (__ilog2_u32(ISCSI_AGE_MASK)) + 1;
962         cxgb3i_log_info("tag itt 0x%x, %u bits, age 0x%x, %u bits.\n",
963                         ISCSI_ITT_MASK, sw_tag_idx_bits,
964                         ISCSI_AGE_MASK, sw_tag_age_bits);
965
966         cxgb3i_scsi_transport =
967             iscsi_register_transport(&cxgb3i_iscsi_transport);
968         if (!cxgb3i_scsi_transport) {
969                 cxgb3i_log_error("Could not register cxgb3i transport.\n");
970                 return -ENODEV;
971         }
972         cxgb3i_api_debug("cxgb3i transport 0x%p.\n", cxgb3i_scsi_transport);
973         return 0;
974 }
975
976 void cxgb3i_iscsi_cleanup(void)
977 {
978         if (cxgb3i_scsi_transport) {
979                 cxgb3i_api_debug("cxgb3i transport 0x%p.\n",
980                                  cxgb3i_scsi_transport);
981                 iscsi_unregister_transport(&cxgb3i_iscsi_transport);
982         }
983 }