[SCSI] cxgb3i: Add cxgb3i iSCSI driver.
[linux-2.6.git] / drivers / scsi / cxgb3i / cxgb3i_pdu.c
1 /*
2  * cxgb3i_pdu.c: Chelsio S3xx iSCSI driver.
3  *
4  * Copyright (c) 2008 Chelsio Communications, Inc.
5  * Copyright (c) 2008 Mike Christie
6  * Copyright (c) 2008 Red Hat, Inc.  All rights reserved.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation.
11  *
12  * Written by: Karen Xie (kxie@chelsio.com)
13  */
14
15 #include <linux/skbuff.h>
16 #include <linux/crypto.h>
17 #include <scsi/scsi_cmnd.h>
18 #include <scsi/scsi_host.h>
19
20 #include "cxgb3i.h"
21 #include "cxgb3i_pdu.h"
22
23 #ifdef __DEBUG_CXGB3I_RX__
24 #define cxgb3i_rx_debug         cxgb3i_log_debug
25 #else
26 #define cxgb3i_rx_debug(fmt...)
27 #endif
28
29 #ifdef __DEBUG_CXGB3I_TX__
30 #define cxgb3i_tx_debug         cxgb3i_log_debug
31 #else
32 #define cxgb3i_tx_debug(fmt...)
33 #endif
34
35 static struct page *pad_page;
36
37 /*
38  * pdu receive, interact with libiscsi_tcp
39  */
40 static inline int read_pdu_skb(struct iscsi_conn *conn, struct sk_buff *skb,
41                                unsigned int offset, int offloaded)
42 {
43         int status = 0;
44         int bytes_read;
45
46         bytes_read = iscsi_tcp_recv_skb(conn, skb, offset, offloaded, &status);
47         switch (status) {
48         case ISCSI_TCP_CONN_ERR:
49                 return -EIO;
50         case ISCSI_TCP_SUSPENDED:
51                 /* no transfer - just have caller flush queue */
52                 return bytes_read;
53         case ISCSI_TCP_SKB_DONE:
54                 /*
55                  * pdus should always fit in the skb and we should get
56                  * segment done notifcation.
57                  */
58                 iscsi_conn_printk(KERN_ERR, conn, "Invalid pdu or skb.");
59                 return -EFAULT;
60         case ISCSI_TCP_SEGMENT_DONE:
61                 return bytes_read;
62         default:
63                 iscsi_conn_printk(KERN_ERR, conn, "Invalid iscsi_tcp_recv_skb "
64                                   "status %d\n", status);
65                 return -EINVAL;
66         }
67 }
68
69 static int cxgb3i_conn_read_pdu_skb(struct iscsi_conn *conn,
70                                     struct sk_buff *skb)
71 {
72         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
73         bool offloaded = 0;
74         unsigned int offset;
75         int rc;
76
77         cxgb3i_rx_debug("conn 0x%p, skb 0x%p, len %u, flag 0x%x.\n",
78                         conn, skb, skb->len, skb_ulp_mode(skb));
79
80         if (!iscsi_tcp_recv_segment_is_hdr(tcp_conn)) {
81                 iscsi_conn_failure(conn, ISCSI_ERR_PROTO);
82                 return -EIO;
83         }
84
85         if (conn->hdrdgst_en && (skb_ulp_mode(skb) & ULP2_FLAG_HCRC_ERROR)) {
86                 iscsi_conn_failure(conn, ISCSI_ERR_HDR_DGST);
87                 return -EIO;
88         }
89
90         if (conn->datadgst_en && (skb_ulp_mode(skb) & ULP2_FLAG_DCRC_ERROR)) {
91                 iscsi_conn_failure(conn, ISCSI_ERR_DATA_DGST);
92                 return -EIO;
93         }
94
95         /* iscsi hdr */
96         rc = read_pdu_skb(conn, skb, 0, 0);
97         if (rc <= 0)
98                 return rc;
99
100         if (iscsi_tcp_recv_segment_is_hdr(tcp_conn))
101                 return 0;
102
103         offset = rc;
104         if (conn->hdrdgst_en)
105                 offset += ISCSI_DIGEST_SIZE;
106
107         /* iscsi data */
108         if (skb_ulp_mode(skb) & ULP2_FLAG_DATA_DDPED) {
109                 cxgb3i_rx_debug("skb 0x%p, opcode 0x%x, data %u, ddp'ed, "
110                                 "itt 0x%x.\n",
111                                 skb,
112                                 tcp_conn->in.hdr->opcode & ISCSI_OPCODE_MASK,
113                                 tcp_conn->in.datalen,
114                                 ntohl(tcp_conn->in.hdr->itt));
115                 offloaded = 1;
116         } else {
117                 cxgb3i_rx_debug("skb 0x%p, opcode 0x%x, data %u, NOT ddp'ed, "
118                                 "itt 0x%x.\n",
119                                 skb,
120                                 tcp_conn->in.hdr->opcode & ISCSI_OPCODE_MASK,
121                                 tcp_conn->in.datalen,
122                                 ntohl(tcp_conn->in.hdr->itt));
123                 offset += sizeof(struct cpl_iscsi_hdr_norss);
124         }
125
126         rc = read_pdu_skb(conn, skb, offset, offloaded);
127         if (rc < 0)
128                 return rc;
129         else
130                 return 0;
131 }
132
133 /*
134  * pdu transmit, interact with libiscsi_tcp
135  */
136 static inline void tx_skb_setmode(struct sk_buff *skb, int hcrc, int dcrc)
137 {
138         u8 submode = 0;
139
140         if (hcrc)
141                 submode |= 1;
142         if (dcrc)
143                 submode |= 2;
144         skb_ulp_mode(skb) = (ULP_MODE_ISCSI << 4) | submode;
145 }
146
147 void cxgb3i_conn_cleanup_task(struct iscsi_task *task)
148 {
149         struct iscsi_tcp_task *tcp_task = task->dd_data;
150
151         /* never reached the xmit task callout */
152         if (tcp_task->dd_data)
153                 kfree_skb(tcp_task->dd_data);
154         tcp_task->dd_data = NULL;
155
156         /* MNC - Do we need a check in case this is called but
157          * cxgb3i_conn_alloc_pdu has never been called on the task */
158         cxgb3i_release_itt(task, task->hdr_itt);
159         iscsi_tcp_cleanup_task(task);
160 }
161
162 /*
163  * We do not support ahs yet
164  */
165 int cxgb3i_conn_alloc_pdu(struct iscsi_task *task, u8 opcode)
166 {
167         struct iscsi_tcp_task *tcp_task = task->dd_data;
168         struct sk_buff *skb;
169
170         task->hdr = NULL;
171         /* always allocate rooms for AHS */
172         skb = alloc_skb(sizeof(struct iscsi_hdr) + ISCSI_MAX_AHS_SIZE +
173                         TX_HEADER_LEN,  GFP_ATOMIC);
174         if (!skb)
175                 return -ENOMEM;
176
177         cxgb3i_tx_debug("task 0x%p, opcode 0x%x, skb 0x%p.\n",
178                         task, opcode, skb);
179
180         tcp_task->dd_data = skb;
181         skb_reserve(skb, TX_HEADER_LEN);
182         task->hdr = (struct iscsi_hdr *)skb->data;
183         task->hdr_max = sizeof(struct iscsi_hdr);
184
185         /* data_out uses scsi_cmd's itt */
186         if (opcode != ISCSI_OP_SCSI_DATA_OUT)
187                 cxgb3i_reserve_itt(task, &task->hdr->itt);
188
189         return 0;
190 }
191
192 int cxgb3i_conn_init_pdu(struct iscsi_task *task, unsigned int offset,
193                               unsigned int count)
194 {
195         struct iscsi_tcp_task *tcp_task = task->dd_data;
196         struct sk_buff *skb = tcp_task->dd_data;
197         struct iscsi_conn *conn = task->conn;
198         struct page *pg;
199         unsigned int datalen = count;
200         int i, padlen = iscsi_padding(count);
201         skb_frag_t *frag;
202
203         cxgb3i_tx_debug("task 0x%p,0x%p, offset %u, count %u, skb 0x%p.\n",
204                         task, task->sc, offset, count, skb);
205
206         skb_put(skb, task->hdr_len);
207         tx_skb_setmode(skb, conn->hdrdgst_en, datalen ? conn->datadgst_en : 0);
208         if (!count)
209                 return 0;
210
211         if (task->sc) {
212                 struct scatterlist *sg;
213                 struct scsi_data_buffer *sdb;
214                 unsigned int sgoffset = offset;
215                 struct page *sgpg;
216                 unsigned int sglen;
217
218                 sdb = scsi_out(task->sc);
219                 sg = sdb->table.sgl;
220
221                 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, i) {
222                         cxgb3i_tx_debug("sg %d, page 0x%p, len %u offset %u\n",
223                                         i, sg_page(sg), sg->length, sg->offset);
224
225                         if (sgoffset < sg->length)
226                                 break;
227                         sgoffset -= sg->length;
228                 }
229                 sgpg = sg_page(sg);
230                 sglen = sg->length - sgoffset;
231
232                 do {
233                         int j = skb_shinfo(skb)->nr_frags;
234                         unsigned int copy;
235
236                         if (!sglen) {
237                                 sg = sg_next(sg);
238                                 sgpg = sg_page(sg);
239                                 sgoffset = 0;
240                                 sglen = sg->length;
241                                 ++i;
242                         }
243                         copy = min(sglen, datalen);
244                         if (j && skb_can_coalesce(skb, j, sgpg,
245                                                   sg->offset + sgoffset)) {
246                                 skb_shinfo(skb)->frags[j - 1].size += copy;
247                         } else {
248                                 get_page(sgpg);
249                                 skb_fill_page_desc(skb, j, sgpg,
250                                                    sg->offset + sgoffset, copy);
251                         }
252                         sgoffset += copy;
253                         sglen -= copy;
254                         datalen -= copy;
255                 } while (datalen);
256         } else {
257                 pg = virt_to_page(task->data);
258
259                 while (datalen) {
260                         i = skb_shinfo(skb)->nr_frags;
261                         frag = &skb_shinfo(skb)->frags[i];
262
263                         get_page(pg);
264                         frag->page = pg;
265                         frag->page_offset = 0;
266                         frag->size = min((unsigned int)PAGE_SIZE, datalen);
267
268                         skb_shinfo(skb)->nr_frags++;
269                         datalen -= frag->size;
270                         pg++;
271                 }
272         }
273
274         if (padlen) {
275                 i = skb_shinfo(skb)->nr_frags;
276                 frag = &skb_shinfo(skb)->frags[i];
277                 frag->page = pad_page;
278                 frag->page_offset = 0;
279                 frag->size = padlen;
280                 skb_shinfo(skb)->nr_frags++;
281         }
282
283         datalen = count + padlen;
284         skb->data_len += datalen;
285         skb->truesize += datalen;
286         skb->len += datalen;
287         return 0;
288 }
289
290 int cxgb3i_conn_xmit_pdu(struct iscsi_task *task)
291 {
292         struct iscsi_tcp_task *tcp_task = task->dd_data;
293         struct sk_buff *skb = tcp_task->dd_data;
294         struct iscsi_tcp_conn *tcp_conn = task->conn->dd_data;
295         struct cxgb3i_conn *cconn = tcp_conn->dd_data;
296         unsigned int datalen;
297         int err;
298
299         if (!skb)
300                 return 0;
301
302         datalen = skb->data_len;
303         tcp_task->dd_data = NULL;
304         err = cxgb3i_c3cn_send_pdus(cconn->cep->c3cn, skb);
305         cxgb3i_tx_debug("task 0x%p, skb 0x%p, len %u/%u, rv %d.\n",
306                         task, skb, skb->len, skb->data_len, err);
307         if (err > 0) {
308                 int pdulen = err;
309
310                 if (task->conn->hdrdgst_en)
311                         pdulen += ISCSI_DIGEST_SIZE;
312                 if (datalen && task->conn->datadgst_en)
313                         pdulen += ISCSI_DIGEST_SIZE;
314
315                 task->conn->txdata_octets += pdulen;
316                 return 0;
317         }
318
319         if (err < 0 && err != -EAGAIN) {
320                 kfree_skb(skb);
321                 cxgb3i_tx_debug("itt 0x%x, skb 0x%p, len %u/%u, xmit err %d.\n",
322                                 task->itt, skb, skb->len, skb->data_len, err);
323                 iscsi_conn_printk(KERN_ERR, task->conn, "xmit err %d.\n", err);
324                 iscsi_conn_failure(task->conn, ISCSI_ERR_XMIT_FAILED);
325                 return err;
326         }
327         /* reset skb to send when we are called again */
328         tcp_task->dd_data = skb;
329         return -EAGAIN;
330 }
331
332 int cxgb3i_pdu_init(void)
333 {
334         pad_page = alloc_page(GFP_KERNEL);
335         if (!pad_page)
336                 return -ENOMEM;
337         memset(page_address(pad_page), 0, PAGE_SIZE);
338         return 0;
339 }
340
341 void cxgb3i_pdu_cleanup(void)
342 {
343         if (pad_page) {
344                 __free_page(pad_page);
345                 pad_page = NULL;
346         }
347 }
348
349 void cxgb3i_conn_pdu_ready(struct s3_conn *c3cn)
350 {
351         struct sk_buff *skb;
352         unsigned int read = 0;
353         struct iscsi_conn *conn = c3cn->user_data;
354         int err = 0;
355
356         cxgb3i_rx_debug("cn 0x%p.\n", c3cn);
357
358         read_lock(&c3cn->callback_lock);
359         if (unlikely(!conn || conn->suspend_rx)) {
360                 cxgb3i_rx_debug("conn 0x%p, id %d, suspend_rx %lu!\n",
361                                 conn, conn ? conn->id : 0xFF,
362                                 conn ? conn->suspend_rx : 0xFF);
363                 read_unlock(&c3cn->callback_lock);
364                 return;
365         }
366         skb = skb_peek(&c3cn->receive_queue);
367         while (!err && skb) {
368                 __skb_unlink(skb, &c3cn->receive_queue);
369                 read += skb_ulp_pdulen(skb);
370                 err = cxgb3i_conn_read_pdu_skb(conn, skb);
371                 __kfree_skb(skb);
372                 skb = skb_peek(&c3cn->receive_queue);
373         }
374         read_unlock(&c3cn->callback_lock);
375         if (c3cn) {
376                 c3cn->copied_seq += read;
377                 cxgb3i_c3cn_rx_credits(c3cn, read);
378         }
379         conn->rxdata_octets += read;
380 }
381
382 void cxgb3i_conn_tx_open(struct s3_conn *c3cn)
383 {
384         struct iscsi_conn *conn = c3cn->user_data;
385
386         cxgb3i_tx_debug("cn 0x%p.\n", c3cn);
387         if (conn) {
388                 cxgb3i_tx_debug("cn 0x%p, cid %d.\n", c3cn, conn->id);
389                 scsi_queue_work(conn->session->host, &conn->xmitwork);
390         }
391 }
392
393 void cxgb3i_conn_closing(struct s3_conn *c3cn)
394 {
395         struct iscsi_conn *conn;
396
397         read_lock(&c3cn->callback_lock);
398         conn = c3cn->user_data;
399         if (conn && c3cn->state != C3CN_STATE_ESTABLISHED)
400                 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
401         read_unlock(&c3cn->callback_lock);
402 }