blob: 9ebc98ade3c5226a75542b4915da432f892c5157 [file] [log] [blame]
Ed L. Cashin26114642006-09-20 14:36:48 -04001/* Copyright (c) 2006 Coraid, Inc. See COPYING for GPL terms. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * aoecmd.c
4 * Filesystem request handling methods
5 */
6
7#include <linux/hdreg.h>
8#include <linux/blkdev.h>
9#include <linux/skbuff.h>
10#include <linux/netdevice.h>
Ed L. Cashin3ae1c242006-01-19 13:46:19 -050011#include <linux/genhd.h>
Ed L. Cashin475172f2005-09-29 12:47:40 -040012#include <asm/unaligned.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include "aoe.h"
14
15#define TIMERTICK (HZ / 10)
16#define MINTIMER (2 * TIMERTICK)
17#define MAXTIMER (HZ << 1)
18#define MAXWAIT (60 * 3) /* After MAXWAIT seconds, give up and fail dev */
19
Ed L. Cashine407a7f2006-09-20 14:36:49 -040020struct sk_buff *
21new_skb(ulong len)
Linus Torvalds1da177e2005-04-16 15:20:36 -070022{
23 struct sk_buff *skb;
24
25 skb = alloc_skb(len, GFP_ATOMIC);
26 if (skb) {
27 skb->nh.raw = skb->mac.raw = skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 skb->protocol = __constant_htons(ETH_P_AOE);
29 skb->priority = 0;
30 skb_put(skb, len);
Ed L. Cashin50bba752006-01-19 12:37:24 -050031 memset(skb->head, 0, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 skb->next = skb->prev = NULL;
33
34 /* tell the network layer not to perform IP checksums
35 * or to get the NIC to do it
36 */
37 skb->ip_summed = CHECKSUM_NONE;
38 }
39 return skb;
40}
41
Linus Torvalds1da177e2005-04-16 15:20:36 -070042static struct frame *
43getframe(struct aoedev *d, int tag)
44{
45 struct frame *f, *e;
46
47 f = d->frames;
48 e = f + d->nframes;
49 for (; f<e; f++)
50 if (f->tag == tag)
51 return f;
52 return NULL;
53}
54
55/*
56 * Leave the top bit clear so we have tagspace for userland.
57 * The bottom 16 bits are the xmit tick for rexmit/rttavg processing.
58 * This driver reserves tag -1 to mean "unused frame."
59 */
60static int
61newtag(struct aoedev *d)
62{
63 register ulong n;
64
65 n = jiffies & 0xffff;
66 return n |= (++d->lasttag & 0x7fff) << 16;
67}
68
69static int
70aoehdr_atainit(struct aoedev *d, struct aoe_hdr *h)
71{
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 u32 host_tag = newtag(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
74 memcpy(h->src, d->ifp->dev_addr, sizeof h->src);
75 memcpy(h->dst, d->addr, sizeof h->dst);
ecashin@coraid.com63e9cc52005-04-18 22:00:20 -070076 h->type = __constant_cpu_to_be16(ETH_P_AOE);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 h->verfl = AOE_HVER;
ecashin@coraid.com63e9cc52005-04-18 22:00:20 -070078 h->major = cpu_to_be16(d->aoemajor);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 h->minor = d->aoeminor;
80 h->cmd = AOECMD_ATA;
ecashin@coraid.com63e9cc52005-04-18 22:00:20 -070081 h->tag = cpu_to_be32(host_tag);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83 return host_tag;
84}
85
Ed L. Cashin19bf2632006-09-20 14:36:49 -040086static inline void
87put_lba(struct aoe_atahdr *ah, sector_t lba)
88{
89 ah->lba0 = lba;
90 ah->lba1 = lba >>= 8;
91 ah->lba2 = lba >>= 8;
92 ah->lba3 = lba >>= 8;
93 ah->lba4 = lba >>= 8;
94 ah->lba5 = lba >>= 8;
95}
96
Linus Torvalds1da177e2005-04-16 15:20:36 -070097static void
98aoecmd_ata_rw(struct aoedev *d, struct frame *f)
99{
100 struct aoe_hdr *h;
101 struct aoe_atahdr *ah;
102 struct buf *buf;
103 struct sk_buff *skb;
104 ulong bcnt;
105 register sector_t sector;
106 char writebit, extbit;
107
108 writebit = 0x10;
109 extbit = 0x4;
110
111 buf = d->inprocess;
112
113 sector = buf->sector;
114 bcnt = buf->bv_resid;
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400115 if (bcnt > d->maxbcnt)
116 bcnt = d->maxbcnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118 /* initialize the headers & frame */
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400119 skb = f->skb;
120 h = (struct aoe_hdr *) skb->mac.raw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 ah = (struct aoe_atahdr *) (h+1);
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400122 skb->len = sizeof *h + sizeof *ah;
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400123 memset(h, 0, ETH_ZLEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 f->tag = aoehdr_atainit(d, h);
125 f->waited = 0;
126 f->buf = buf;
127 f->bufaddr = buf->bufaddr;
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400128 f->bcnt = bcnt;
129 f->lba = sector;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
131 /* set up ata header */
132 ah->scnt = bcnt >> 9;
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400133 put_lba(ah, sector);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 if (d->flags & DEVFL_EXT) {
135 ah->aflags |= AOEAFL_EXT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 } else {
137 extbit = 0;
138 ah->lba3 &= 0x0f;
139 ah->lba3 |= 0xe0; /* LBA bit + obsolete 0xa0 */
140 }
141
142 if (bio_data_dir(buf->bio) == WRITE) {
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400143 skb_fill_page_desc(skb, 0, virt_to_page(f->bufaddr),
144 offset_in_page(f->bufaddr), bcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 ah->aflags |= AOEAFL_WRITE;
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400146 skb->len += bcnt;
147 skb->data_len = bcnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 } else {
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400149 skb->len = ETH_ZLEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 writebit = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 }
152
153 ah->cmdstat = WIN_READ | writebit | extbit;
154
155 /* mark all tracking fields and load out */
156 buf->nframesout += 1;
157 buf->bufaddr += bcnt;
158 buf->bv_resid -= bcnt;
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400159/* dprintk("bv_resid=%ld\n", buf->bv_resid); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 buf->resid -= bcnt;
161 buf->sector += bcnt >> 9;
162 if (buf->resid == 0) {
163 d->inprocess = NULL;
164 } else if (buf->bv_resid == 0) {
165 buf->bv++;
166 buf->bv_resid = buf->bv->bv_len;
167 buf->bufaddr = page_address(buf->bv->bv_page) + buf->bv->bv_offset;
168 }
169
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400170 skb->dev = d->ifp;
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400171 skb = skb_clone(skb, GFP_ATOMIC);
172 if (skb == NULL)
173 return;
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400174 if (d->sendq_hd)
175 d->sendq_tl->next = skb;
176 else
177 d->sendq_hd = skb;
178 d->sendq_tl = skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179}
180
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500181/* some callers cannot sleep, and they can call this function,
182 * transmitting the packets later, when interrupts are on
183 */
184static struct sk_buff *
185aoecmd_cfg_pkts(ushort aoemajor, unsigned char aoeminor, struct sk_buff **tail)
186{
187 struct aoe_hdr *h;
188 struct aoe_cfghdr *ch;
189 struct sk_buff *skb, *sl, *sl_tail;
190 struct net_device *ifp;
191
192 sl = sl_tail = NULL;
193
194 read_lock(&dev_base_lock);
195 for (ifp = dev_base; ifp; dev_put(ifp), ifp = ifp->next) {
196 dev_hold(ifp);
197 if (!is_aoe_netif(ifp))
198 continue;
199
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400200 skb = new_skb(sizeof *h + sizeof *ch);
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500201 if (skb == NULL) {
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400202 iprintk("skb alloc failure\n");
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500203 continue;
204 }
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400205 skb->dev = ifp;
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500206 if (sl_tail == NULL)
207 sl_tail = skb;
208 h = (struct aoe_hdr *) skb->mac.raw;
209 memset(h, 0, sizeof *h + sizeof *ch);
210
211 memset(h->dst, 0xff, sizeof h->dst);
212 memcpy(h->src, ifp->dev_addr, sizeof h->src);
213 h->type = __constant_cpu_to_be16(ETH_P_AOE);
214 h->verfl = AOE_HVER;
215 h->major = cpu_to_be16(aoemajor);
216 h->minor = aoeminor;
217 h->cmd = AOECMD_CFG;
218
219 skb->next = sl;
220 sl = skb;
221 }
222 read_unlock(&dev_base_lock);
223
224 if (tail != NULL)
225 *tail = sl_tail;
226 return sl;
227}
228
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400229static struct frame *
230freeframe(struct aoedev *d)
231{
232 struct frame *f, *e;
233 int n = 0;
234
235 f = d->frames;
236 e = f + d->nframes;
237 for (; f<e; f++) {
238 if (f->tag != FREETAG)
239 continue;
240 if (atomic_read(&skb_shinfo(f->skb)->dataref) == 1) {
241 skb_shinfo(f->skb)->nr_frags = f->skb->data_len = 0;
242 return f;
243 }
244 n++;
245 }
246 if (n == d->nframes) /* wait for network layer */
247 d->flags |= DEVFL_KICKME;
248
249 return NULL;
250}
251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252/* enters with d->lock held */
253void
254aoecmd_work(struct aoedev *d)
255{
256 struct frame *f;
257 struct buf *buf;
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500258
259 if (d->flags & DEVFL_PAUSE) {
260 if (!aoedev_isbusy(d))
261 d->sendq_hd = aoecmd_cfg_pkts(d->aoemajor,
262 d->aoeminor, &d->sendq_tl);
263 return;
264 }
265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266loop:
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400267 f = freeframe(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 if (f == NULL)
269 return;
270 if (d->inprocess == NULL) {
271 if (list_empty(&d->bufq))
272 return;
273 buf = container_of(d->bufq.next, struct buf, bufs);
274 list_del(d->bufq.next);
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400275/*dprintk("bi_size=%ld\n", buf->bio->bi_size); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 d->inprocess = buf;
277 }
278 aoecmd_ata_rw(d, f);
279 goto loop;
280}
281
282static void
283rexmit(struct aoedev *d, struct frame *f)
284{
285 struct sk_buff *skb;
286 struct aoe_hdr *h;
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400287 struct aoe_atahdr *ah;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 char buf[128];
289 u32 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
291 n = newtag(d);
292
293 snprintf(buf, sizeof buf,
294 "%15s e%ld.%ld oldtag=%08x@%08lx newtag=%08x\n",
295 "retransmit",
296 d->aoemajor, d->aoeminor, f->tag, jiffies, n);
297 aoechr_error(buf);
298
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400299 skb = f->skb;
300 h = (struct aoe_hdr *) skb->mac.raw;
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400301 ah = (struct aoe_atahdr *) (h+1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 f->tag = n;
ecashin@coraid.com63e9cc52005-04-18 22:00:20 -0700303 h->tag = cpu_to_be32(n);
Ed L. Cashin2dd5e422006-01-19 13:46:25 -0500304 memcpy(h->dst, d->addr, sizeof h->dst);
305 memcpy(h->src, d->ifp->dev_addr, sizeof h->src);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400307 n = DEFAULTBCNT / 512;
308 if (ah->scnt > n) {
309 ah->scnt = n;
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400310 if (ah->aflags & AOEAFL_WRITE) {
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400311 skb_fill_page_desc(skb, 0, virt_to_page(f->bufaddr),
312 offset_in_page(f->bufaddr), DEFAULTBCNT);
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400313 skb->len = sizeof *h + sizeof *ah + DEFAULTBCNT;
314 skb->data_len = DEFAULTBCNT;
315 }
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400316 if (++d->lostjumbo > (d->nframes << 1))
317 if (d->maxbcnt != DEFAULTBCNT) {
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400318 iprintk("e%ld.%ld: too many lost jumbo on %s - using 1KB frames.\n",
319 d->aoemajor, d->aoeminor, d->ifp->name);
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400320 d->maxbcnt = DEFAULTBCNT;
321 d->flags |= DEVFL_MAXBCNT;
322 }
323 }
324
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400325 skb->dev = d->ifp;
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400326 skb = skb_clone(skb, GFP_ATOMIC);
327 if (skb == NULL)
328 return;
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400329 if (d->sendq_hd)
330 d->sendq_tl->next = skb;
331 else
332 d->sendq_hd = skb;
333 d->sendq_tl = skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334}
335
336static int
337tsince(int tag)
338{
339 int n;
340
341 n = jiffies & 0xffff;
342 n -= tag & 0xffff;
343 if (n < 0)
344 n += 1<<16;
345 return n;
346}
347
348static void
349rexmit_timer(ulong vp)
350{
351 struct aoedev *d;
352 struct frame *f, *e;
353 struct sk_buff *sl;
354 register long timeout;
355 ulong flags, n;
356
357 d = (struct aoedev *) vp;
358 sl = NULL;
359
360 /* timeout is always ~150% of the moving average */
361 timeout = d->rttavg;
362 timeout += timeout >> 1;
363
364 spin_lock_irqsave(&d->lock, flags);
365
366 if (d->flags & DEVFL_TKILL) {
Ed L. Cashin1c6f3fc2006-01-25 13:54:44 -0500367 spin_unlock_irqrestore(&d->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 return;
369 }
370 f = d->frames;
371 e = f + d->nframes;
372 for (; f<e; f++) {
373 if (f->tag != FREETAG && tsince(f->tag) >= timeout) {
374 n = f->waited += timeout;
375 n /= HZ;
376 if (n > MAXWAIT) { /* waited too long. device failure. */
377 aoedev_downdev(d);
Ed L. Cashin1c6f3fc2006-01-25 13:54:44 -0500378 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 }
380 rexmit(d, f);
381 }
382 }
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400383 if (d->flags & DEVFL_KICKME) {
384 d->flags &= ~DEVFL_KICKME;
385 aoecmd_work(d);
386 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
ecashin@coraid.coma4b38362005-04-18 22:00:22 -0700388 sl = d->sendq_hd;
389 d->sendq_hd = d->sendq_tl = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 if (sl) {
391 n = d->rttavg <<= 1;
392 if (n > MAXTIMER)
393 d->rttavg = MAXTIMER;
394 }
395
396 d->timer.expires = jiffies + TIMERTICK;
397 add_timer(&d->timer);
398
399 spin_unlock_irqrestore(&d->lock, flags);
400
401 aoenet_xmit(sl);
402}
403
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500404/* this function performs work that has been deferred until sleeping is OK
405 */
406void
407aoecmd_sleepwork(void *vp)
408{
409 struct aoedev *d = (struct aoedev *) vp;
410
411 if (d->flags & DEVFL_GDALLOC)
412 aoeblk_gdalloc(d);
413
414 if (d->flags & DEVFL_NEWSIZE) {
415 struct block_device *bd;
416 unsigned long flags;
417 u64 ssize;
418
419 ssize = d->gd->capacity;
420 bd = bdget_disk(d->gd, 0);
421
422 if (bd) {
423 mutex_lock(&bd->bd_inode->i_mutex);
424 i_size_write(bd->bd_inode, (loff_t)ssize<<9);
425 mutex_unlock(&bd->bd_inode->i_mutex);
426 bdput(bd);
427 }
428 spin_lock_irqsave(&d->lock, flags);
429 d->flags |= DEVFL_UP;
430 d->flags &= ~DEVFL_NEWSIZE;
431 spin_unlock_irqrestore(&d->lock, flags);
432 }
433}
434
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435static void
436ataid_complete(struct aoedev *d, unsigned char *id)
437{
438 u64 ssize;
439 u16 n;
440
441 /* word 83: command set supported */
Ed L. Cashin475172f2005-09-29 12:47:40 -0400442 n = le16_to_cpu(get_unaligned((__le16 *) &id[83<<1]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
444 /* word 86: command set/feature enabled */
Ed L. Cashin475172f2005-09-29 12:47:40 -0400445 n |= le16_to_cpu(get_unaligned((__le16 *) &id[86<<1]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
447 if (n & (1<<10)) { /* bit 10: LBA 48 */
448 d->flags |= DEVFL_EXT;
449
450 /* word 100: number lba48 sectors */
Ed L. Cashin475172f2005-09-29 12:47:40 -0400451 ssize = le64_to_cpu(get_unaligned((__le64 *) &id[100<<1]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
453 /* set as in ide-disk.c:init_idedisk_capacity */
454 d->geo.cylinders = ssize;
455 d->geo.cylinders /= (255 * 63);
456 d->geo.heads = 255;
457 d->geo.sectors = 63;
458 } else {
459 d->flags &= ~DEVFL_EXT;
460
461 /* number lba28 sectors */
Ed L. Cashin475172f2005-09-29 12:47:40 -0400462 ssize = le32_to_cpu(get_unaligned((__le32 *) &id[60<<1]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
464 /* NOTE: obsolete in ATA 6 */
Ed L. Cashin475172f2005-09-29 12:47:40 -0400465 d->geo.cylinders = le16_to_cpu(get_unaligned((__le16 *) &id[54<<1]));
466 d->geo.heads = le16_to_cpu(get_unaligned((__le16 *) &id[55<<1]));
467 d->geo.sectors = le16_to_cpu(get_unaligned((__le16 *) &id[56<<1]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 }
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500469
470 if (d->ssize != ssize)
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400471 iprintk("%012llx e%lu.%lu v%04x has %llu sectors\n",
472 (unsigned long long)mac_addr(d->addr),
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500473 d->aoemajor, d->aoeminor,
474 d->fw_ver, (long long)ssize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 d->ssize = ssize;
476 d->geo.start = 0;
477 if (d->gd != NULL) {
478 d->gd->capacity = ssize;
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500479 d->flags |= DEVFL_NEWSIZE;
480 } else {
481 if (d->flags & DEVFL_GDALLOC) {
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400482 eprintk("can't schedule work for e%lu.%lu, %s\n",
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500483 d->aoemajor, d->aoeminor,
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400484 "it's already on! This shouldn't happen.\n");
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500485 return;
486 }
487 d->flags |= DEVFL_GDALLOC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 schedule_work(&d->work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490}
491
492static void
493calc_rttavg(struct aoedev *d, int rtt)
494{
495 register long n;
496
497 n = rtt;
Ed L. Cashindced3a02006-09-20 14:36:49 -0400498 if (n < 0) {
499 n = -rtt;
500 if (n < MINTIMER)
501 n = MINTIMER;
502 else if (n > MAXTIMER)
503 n = MAXTIMER;
504 d->mintimer += (n - d->mintimer) >> 1;
505 } else if (n < d->mintimer)
506 n = d->mintimer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 else if (n > MAXTIMER)
508 n = MAXTIMER;
509
510 /* g == .25; cf. Congestion Avoidance and Control, Jacobson & Karels; 1988 */
511 n -= d->rttavg;
512 d->rttavg += n >> 2;
513}
514
515void
516aoecmd_ata_rsp(struct sk_buff *skb)
517{
518 struct aoedev *d;
Ed L. Cashinddec63e2006-09-20 14:36:49 -0400519 struct aoe_hdr *hin, *hout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 struct aoe_atahdr *ahin, *ahout;
521 struct frame *f;
522 struct buf *buf;
523 struct sk_buff *sl;
524 register long n;
525 ulong flags;
526 char ebuf[128];
ecashin@coraid.com32465c62005-04-18 22:00:18 -0700527 u16 aoemajor;
528
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 hin = (struct aoe_hdr *) skb->mac.raw;
ecashin@coraid.com63e9cc52005-04-18 22:00:20 -0700530 aoemajor = be16_to_cpu(hin->major);
ecashin@coraid.com32465c62005-04-18 22:00:18 -0700531 d = aoedev_by_aoeaddr(aoemajor, hin->minor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 if (d == NULL) {
533 snprintf(ebuf, sizeof ebuf, "aoecmd_ata_rsp: ata response "
534 "for unknown device %d.%d\n",
ecashin@coraid.com32465c62005-04-18 22:00:18 -0700535 aoemajor, hin->minor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 aoechr_error(ebuf);
537 return;
538 }
539
540 spin_lock_irqsave(&d->lock, flags);
541
Ed L. Cashindced3a02006-09-20 14:36:49 -0400542 n = be32_to_cpu(hin->tag);
543 f = getframe(d, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 if (f == NULL) {
Ed L. Cashindced3a02006-09-20 14:36:49 -0400545 calc_rttavg(d, -tsince(n));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 spin_unlock_irqrestore(&d->lock, flags);
547 snprintf(ebuf, sizeof ebuf,
548 "%15s e%d.%d tag=%08x@%08lx\n",
549 "unexpected rsp",
ecashin@coraid.com63e9cc52005-04-18 22:00:20 -0700550 be16_to_cpu(hin->major),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 hin->minor,
ecashin@coraid.com63e9cc52005-04-18 22:00:20 -0700552 be32_to_cpu(hin->tag),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 jiffies);
554 aoechr_error(ebuf);
555 return;
556 }
557
558 calc_rttavg(d, tsince(f->tag));
559
560 ahin = (struct aoe_atahdr *) (hin+1);
Ed L. Cashinddec63e2006-09-20 14:36:49 -0400561 hout = (struct aoe_hdr *) f->skb->mac.raw;
562 ahout = (struct aoe_atahdr *) (hout+1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 buf = f->buf;
564
Ed L. Cashin9d419652006-02-07 11:37:24 -0500565 if (ahout->cmdstat == WIN_IDENTIFY)
566 d->flags &= ~DEVFL_PAUSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 if (ahin->cmdstat & 0xa9) { /* these bits cleared on success */
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400568 eprintk("ata error cmd=%2.2Xh stat=%2.2Xh from e%ld.%ld\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 ahout->cmdstat, ahin->cmdstat,
570 d->aoemajor, d->aoeminor);
571 if (buf)
572 buf->flags |= BUFFL_FAIL;
573 } else {
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400574 n = ahout->scnt << 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 switch (ahout->cmdstat) {
576 case WIN_READ:
577 case WIN_READ_EXT:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 if (skb->len - sizeof *hin - sizeof *ahin < n) {
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400579 eprintk("runt data size in read. skb->len=%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 skb->len);
581 /* fail frame f? just returning will rexmit. */
582 spin_unlock_irqrestore(&d->lock, flags);
583 return;
584 }
585 memcpy(f->bufaddr, ahin+1, n);
586 case WIN_WRITE:
587 case WIN_WRITE_EXT:
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400588 if (f->bcnt -= n) {
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400589 skb = f->skb;
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400590 f->bufaddr += n;
591 put_lba(ahout, f->lba += ahout->scnt);
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400592 n = f->bcnt;
593 if (n > DEFAULTBCNT)
594 n = DEFAULTBCNT;
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400595 ahout->scnt = n >> 9;
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400596 if (ahout->aflags & AOEAFL_WRITE) {
597 skb_fill_page_desc(skb, 0,
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400598 virt_to_page(f->bufaddr),
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400599 offset_in_page(f->bufaddr), n);
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400600 skb->len = sizeof *hout + sizeof *ahout + n;
601 skb->data_len = n;
602 }
Ed L. Cashinddec63e2006-09-20 14:36:49 -0400603 f->tag = newtag(d);
604 hout->tag = cpu_to_be32(f->tag);
605 skb->dev = d->ifp;
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400606 skb = skb_clone(skb, GFP_ATOMIC);
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400607 spin_unlock_irqrestore(&d->lock, flags);
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400608 if (skb)
609 aoenet_xmit(skb);
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400610 return;
611 }
612 if (n > DEFAULTBCNT)
613 d->lostjumbo = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 break;
615 case WIN_IDENTIFY:
616 if (skb->len - sizeof *hin - sizeof *ahin < 512) {
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400617 iprintk("runt data size in ataid. skb->len=%d\n",
618 skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 spin_unlock_irqrestore(&d->lock, flags);
620 return;
621 }
622 ataid_complete(d, (char *) (ahin+1));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 break;
624 default:
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400625 iprintk("unrecognized ata command %2.2Xh for %d.%d\n",
626 ahout->cmdstat,
627 be16_to_cpu(hin->major),
628 hin->minor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 }
630 }
631
632 if (buf) {
633 buf->nframesout -= 1;
634 if (buf->nframesout == 0 && buf->resid == 0) {
ecashin@coraid.com0c6f0e72005-04-18 22:00:22 -0700635 unsigned long duration = jiffies - buf->start_time;
636 unsigned long n_sect = buf->bio->bi_size >> 9;
637 struct gendisk *disk = d->gd;
Jens Axboe496456c2005-11-01 09:54:23 +0100638 const int rw = bio_data_dir(buf->bio);
ecashin@coraid.com0c6f0e72005-04-18 22:00:22 -0700639
Jens Axboe496456c2005-11-01 09:54:23 +0100640 disk_stat_inc(disk, ios[rw]);
641 disk_stat_add(disk, ticks[rw], duration);
642 disk_stat_add(disk, sectors[rw], n_sect);
ecashin@coraid.com0c6f0e72005-04-18 22:00:22 -0700643 disk_stat_add(disk, io_ticks, duration);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 n = (buf->flags & BUFFL_FAIL) ? -EIO : 0;
645 bio_endio(buf->bio, buf->bio->bi_size, n);
646 mempool_free(buf, d->bufpool);
647 }
648 }
649
650 f->buf = NULL;
651 f->tag = FREETAG;
652
653 aoecmd_work(d);
ecashin@coraid.coma4b38362005-04-18 22:00:22 -0700654 sl = d->sendq_hd;
655 d->sendq_hd = d->sendq_tl = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
657 spin_unlock_irqrestore(&d->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 aoenet_xmit(sl);
659}
660
661void
662aoecmd_cfg(ushort aoemajor, unsigned char aoeminor)
663{
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500664 struct sk_buff *sl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500666 sl = aoecmd_cfg_pkts(aoemajor, aoeminor, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
668 aoenet_xmit(sl);
669}
670
671/*
672 * Since we only call this in one place (and it only prepares one frame)
ecashin@coraid.coma4b38362005-04-18 22:00:22 -0700673 * we just return the skb. Usually we'd chain it up to the aoedev sendq.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 */
675static struct sk_buff *
676aoecmd_ata_id(struct aoedev *d)
677{
678 struct aoe_hdr *h;
679 struct aoe_atahdr *ah;
680 struct frame *f;
681 struct sk_buff *skb;
682
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400683 f = freeframe(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 if (f == NULL) {
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400685 eprintk("can't get a frame. This shouldn't happen.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 return NULL;
687 }
688
689 /* initialize the headers & frame */
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400690 skb = f->skb;
691 h = (struct aoe_hdr *) skb->mac.raw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 ah = (struct aoe_atahdr *) (h+1);
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400693 skb->len = ETH_ZLEN;
694 memset(h, 0, ETH_ZLEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 f->tag = aoehdr_atainit(d, h);
696 f->waited = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 /* set up ata header */
699 ah->scnt = 1;
700 ah->cmdstat = WIN_IDENTIFY;
701 ah->lba3 = 0xa0;
702
Ed L. Cashine407a7f2006-09-20 14:36:49 -0400703 skb->dev = d->ifp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500705 d->rttavg = MAXTIMER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 d->timer.function = rexmit_timer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400708 return skb_clone(skb, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709}
710
711void
712aoecmd_cfg_rsp(struct sk_buff *skb)
713{
714 struct aoedev *d;
715 struct aoe_hdr *h;
716 struct aoe_cfghdr *ch;
ecashin@coraid.com63e9cc52005-04-18 22:00:20 -0700717 ulong flags, sysminor, aoemajor;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 struct sk_buff *sl;
Ed L. Cashineaf0a3c2006-01-19 13:46:20 -0500719 enum { MAXFRAMES = 16 };
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400720 u16 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
722 h = (struct aoe_hdr *) skb->mac.raw;
723 ch = (struct aoe_cfghdr *) (h+1);
724
725 /*
726 * Enough people have their dip switches set backwards to
727 * warrant a loud message for this special case.
728 */
ecashin@coraid.com63e9cc52005-04-18 22:00:20 -0700729 aoemajor = be16_to_cpu(h->major);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 if (aoemajor == 0xfff) {
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400731 eprintk("Warning: shelf address is all ones. "
732 "Check shelf dip switches.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 return;
734 }
735
736 sysminor = SYSMINOR(aoemajor, h->minor);
ecashin@coraid.comfc458dc2005-04-18 22:00:17 -0700737 if (sysminor * AOE_PARTITIONS + AOE_PARTITIONS > MINORMASK) {
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400738 iprintk("e%ld.%d: minor number too large\n",
ecashin@coraid.comfc458dc2005-04-18 22:00:17 -0700739 aoemajor, (int) h->minor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 return;
741 }
742
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400743 n = be16_to_cpu(ch->bufcnt);
744 if (n > MAXFRAMES) /* keep it reasonable */
745 n = MAXFRAMES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400747 d = aoedev_by_sysminor_m(sysminor, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 if (d == NULL) {
Ed L. Cashin6bb6285f2006-09-20 14:36:49 -0400749 iprintk("device sysminor_m failure\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 return;
751 }
752
753 spin_lock_irqsave(&d->lock, flags);
754
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500755 /* permit device to migrate mac and network interface */
756 d->ifp = skb->dev;
757 memcpy(d->addr, h->src, sizeof d->addr);
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400758 if (!(d->flags & DEVFL_MAXBCNT)) {
759 n = d->ifp->mtu;
760 n -= sizeof (struct aoe_hdr) + sizeof (struct aoe_atahdr);
761 n /= 512;
762 if (n > ch->scnt)
763 n = ch->scnt;
Ed L. Cashin4f51dc52006-09-20 14:36:49 -0400764 n = n ? n * 512 : DEFAULTBCNT;
765 if (n != d->maxbcnt) {
766 iprintk("e%ld.%ld: setting %d byte data frames on %s\n",
767 d->aoemajor, d->aoeminor, n, d->ifp->name);
768 d->maxbcnt = n;
769 }
Ed L. Cashin19bf2632006-09-20 14:36:49 -0400770 }
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500771
772 /* don't change users' perspective */
773 if (d->nopen && !(d->flags & DEVFL_PAUSE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 spin_unlock_irqrestore(&d->lock, flags);
775 return;
776 }
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500777 d->flags |= DEVFL_PAUSE; /* force pause */
Ed L. Cashindced3a02006-09-20 14:36:49 -0400778 d->mintimer = MINTIMER;
ecashin@coraid.com63e9cc52005-04-18 22:00:20 -0700779 d->fw_ver = be16_to_cpu(ch->fwver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Ed L. Cashin3ae1c242006-01-19 13:46:19 -0500781 /* check for already outstanding ataid */
782 sl = aoedev_isbusy(d) == 0 ? aoecmd_ata_id(d) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
784 spin_unlock_irqrestore(&d->lock, flags);
785
786 aoenet_xmit(sl);
787}
788