?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Complete the renaming to TuxOnIce with function names, vars etc.
[linux-2.6/suspend2-head.git] / drivers / block / aoe / aoecmd.c
blob01fbdd38e3be21979027538b64b5cd56dc516f0c
1 /* Copyright (c) 2006 Coraid, Inc. See COPYING for GPL terms. */
2 /*
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>
11 #include <linux/genhd.h>
12 #include <asm/unaligned.h>
13 #include "aoe.h"
14
15 #define TIMERTICK (HZ / 10)
16 #define MINTIMER (2 * TIMERTICK)
17 #define MAXTIMER (HZ << 1)
18
19 static int aoe_deadsecs = 60 * 3;
20 module_param(aoe_deadsecs, int, 0644);
21 MODULE_PARM_DESC(aoe_deadsecs, "After aoe_deadsecs seconds, give up and fail dev.");
22
23 struct sk_buff *
24 new_skb(ulong len)
25 {
26 struct sk_buff *skb;
27
28 skb = alloc_skb(len, GFP_ATOMIC);
29 if (skb) {
30 skb_reset_mac_header(skb);
31 skb_reset_network_header(skb);
32 skb->protocol = __constant_htons(ETH_P_AOE);
33 skb->priority = 0;
34 skb->next = skb->prev = NULL;
35
36 /* tell the network layer not to perform IP checksums
37 * or to get the NIC to do it
38 */
39 skb->ip_summed = CHECKSUM_NONE;
40 }
41 return skb;
42 }
43
44 static struct frame *
45 getframe(struct aoedev *d, int tag)
46 {
47 struct frame *f, *e;
48
49 f = d->frames;
50 e = f + d->nframes;
51 for (; f<e; f++)
52 if (f->tag == tag)
53 return f;
54 return NULL;
55 }
56
57 /*
58 * Leave the top bit clear so we have tagspace for userland.
59 * The bottom 16 bits are the xmit tick for rexmit/rttavg processing.
60 * This driver reserves tag -1 to mean "unused frame."
61 */
62 static int
63 newtag(struct aoedev *d)
64 {
65 register ulong n;
66
67 n = jiffies & 0xffff;
68 return n |= (++d->lasttag & 0x7fff) << 16;
69 }
70
71 static int
72 aoehdr_atainit(struct aoedev *d, struct aoe_hdr *h)
73 {
74 u32 host_tag = newtag(d);
75
76 memcpy(h->src, d->ifp->dev_addr, sizeof h->src);
77 memcpy(h->dst, d->addr, sizeof h->dst);
78 h->type = __constant_cpu_to_be16(ETH_P_AOE);
79 h->verfl = AOE_HVER;
80 h->major = cpu_to_be16(d->aoemajor);
81 h->minor = d->aoeminor;
82 h->cmd = AOECMD_ATA;
83 h->tag = cpu_to_be32(host_tag);
84
85 return host_tag;
86 }
87
88 static inline void
89 put_lba(struct aoe_atahdr *ah, sector_t lba)
90 {
91 ah->lba0 = lba;
92 ah->lba1 = lba >>= 8;
93 ah->lba2 = lba >>= 8;
94 ah->lba3 = lba >>= 8;
95 ah->lba4 = lba >>= 8;
96 ah->lba5 = lba >>= 8;
97 }
98
99 static void
100 aoecmd_ata_rw(struct aoedev *d, struct frame *f)
101 {
102 struct aoe_hdr *h;
103 struct aoe_atahdr *ah;
104 struct buf *buf;
105 struct sk_buff *skb;
106 ulong bcnt;
107 register sector_t sector;
108 char writebit, extbit;
109
110 writebit = 0x10;
111 extbit = 0x4;
112
113 buf = d->inprocess;
114
115 sector = buf->sector;
116 bcnt = buf->bv_resid;
117 if (bcnt > d->maxbcnt)
118 bcnt = d->maxbcnt;
119
120 /* initialize the headers & frame */
121 skb = f->skb;
122 h = aoe_hdr(skb);
123 ah = (struct aoe_atahdr *) (h+1);
124 skb_put(skb, sizeof *h + sizeof *ah);
125 memset(h, 0, skb->len);
126 f->tag = aoehdr_atainit(d, h);
127 f->waited = 0;
128 f->buf = buf;
129 f->bufaddr = buf->bufaddr;
130 f->bcnt = bcnt;
131 f->lba = sector;
132
133 /* set up ata header */
134 ah->scnt = bcnt >> 9;
135 put_lba(ah, sector);
136 if (d->flags & DEVFL_EXT) {
137 ah->aflags |= AOEAFL_EXT;
138 } else {
139 extbit = 0;
140 ah->lba3 &= 0x0f;
141 ah->lba3 |= 0xe0; /* LBA bit + obsolete 0xa0 */
142 }
143
144 if (bio_data_dir(buf->bio) == WRITE) {
145 skb_fill_page_desc(skb, 0, virt_to_page(f->bufaddr),
146 offset_in_page(f->bufaddr), bcnt);
147 ah->aflags |= AOEAFL_WRITE;
148 skb->len += bcnt;
149 skb->data_len = bcnt;
150 } else {
151 writebit = 0;
152 }
153
154 ah->cmdstat = WIN_READ | writebit | extbit;
155
156 /* mark all tracking fields and load out */
157 buf->nframesout += 1;
158 buf->bufaddr += bcnt;
159 buf->bv_resid -= bcnt;
160 /* printk(KERN_DEBUG "aoe: bv_resid=%ld\n", buf->bv_resid); */
161 buf->resid -= bcnt;
162 buf->sector += bcnt >> 9;
163 if (buf->resid == 0) {
164 d->inprocess = NULL;
165 } else if (buf->bv_resid == 0) {
166 buf->bv++;
167 WARN_ON(buf->bv->bv_len == 0);
168 buf->bv_resid = buf->bv->bv_len;
169 buf->bufaddr = page_address(buf->bv->bv_page) + buf->bv->bv_offset;
170 }
171
172 skb->dev = d->ifp;
173 skb = skb_clone(skb, GFP_ATOMIC);
174 if (skb == NULL)
175 return;
176 if (d->sendq_hd)
177 d->sendq_tl->next = skb;
178 else
179 d->sendq_hd = skb;
180 d->sendq_tl = skb;
181 }
182
183 /* some callers cannot sleep, and they can call this function,
184 * transmitting the packets later, when interrupts are on
185 */
186 static struct sk_buff *
187 aoecmd_cfg_pkts(ushort aoemajor, unsigned char aoeminor, struct sk_buff **tail)
188 {
189 struct aoe_hdr *h;
190 struct aoe_cfghdr *ch;
191 struct sk_buff *skb, *sl, *sl_tail;
192 struct net_device *ifp;
193
194 sl = sl_tail = NULL;
195
196 read_lock(&dev_base_lock);
197 for_each_netdev(ifp) {
198 dev_hold(ifp);
199 if (!is_aoe_netif(ifp))
200 goto cont;
201
202 skb = new_skb(sizeof *h + sizeof *ch);
203 if (skb == NULL) {
204 printk(KERN_INFO "aoe: skb alloc failure\n");
205 goto cont;
206 }
207 skb_put(skb, sizeof *h + sizeof *ch);
208 skb->dev = ifp;
209 if (sl_tail == NULL)
210 sl_tail = skb;
211 h = aoe_hdr(skb);
212 memset(h, 0, sizeof *h + sizeof *ch);
213
214 memset(h->dst, 0xff, sizeof h->dst);
215 memcpy(h->src, ifp->dev_addr, sizeof h->src);
216 h->type = __constant_cpu_to_be16(ETH_P_AOE);
217 h->verfl = AOE_HVER;
218 h->major = cpu_to_be16(aoemajor);
219 h->minor = aoeminor;
220 h->cmd = AOECMD_CFG;
221
222 skb->next = sl;
223 sl = skb;
224 cont:
225 dev_put(ifp);
226 }
227 read_unlock(&dev_base_lock);
228
229 if (tail != NULL)
230 *tail = sl_tail;
231 return sl;
232 }
233
234 static struct frame *
235 freeframe(struct aoedev *d)
236 {
237 struct frame *f, *e;
238 int n = 0;
239
240 f = d->frames;
241 e = f + d->nframes;
242 for (; f<e; f++) {
243 if (f->tag != FREETAG)
244 continue;
245 if (atomic_read(&skb_shinfo(f->skb)->dataref) == 1) {
246 skb_shinfo(f->skb)->nr_frags = f->skb->data_len = 0;
247 skb_trim(f->skb, 0);
248 return f;
249 }
250 n++;
251 }
252 if (n == d->nframes) /* wait for network layer */
253 d->flags |= DEVFL_KICKME;
254
255 return NULL;
256 }
257
258 /* enters with d->lock held */
259 void
260 aoecmd_work(struct aoedev *d)
261 {
262 struct frame *f;
263 struct buf *buf;
264
265 if (d->flags & DEVFL_PAUSE) {
266 if (!aoedev_isbusy(d))
267 d->sendq_hd = aoecmd_cfg_pkts(d->aoemajor,
268 d->aoeminor, &d->sendq_tl);
269 return;
270 }
271
272 loop:
273 f = freeframe(d);
274 if (f == NULL)
275 return;
276 if (d->inprocess == NULL) {
277 if (list_empty(&d->bufq))
278 return;
279 buf = container_of(d->bufq.next, struct buf, bufs);
280 list_del(d->bufq.next);
281 /*printk(KERN_DEBUG "aoe: bi_size=%ld\n", buf->bio->bi_size); */
282 d->inprocess = buf;
283 }
284 aoecmd_ata_rw(d, f);
285 goto loop;
286 }
287
288 static void
289 rexmit(struct aoedev *d, struct frame *f)
290 {
291 struct sk_buff *skb;
292 struct aoe_hdr *h;
293 struct aoe_atahdr *ah;
294 char buf[128];
295 u32 n;
296
297 n = newtag(d);
298
299 snprintf(buf, sizeof buf,
300 "%15s e%ld.%ld oldtag=%08x@%08lx newtag=%08x\n",
301 "retransmit",
302 d->aoemajor, d->aoeminor, f->tag, jiffies, n);
303 aoechr_error(buf);
304
305 skb = f->skb;
306 h = aoe_hdr(skb);
307 ah = (struct aoe_atahdr *) (h+1);
308 f->tag = n;
309 h->tag = cpu_to_be32(n);
310 memcpy(h->dst, d->addr, sizeof h->dst);
311 memcpy(h->src, d->ifp->dev_addr, sizeof h->src);
312
313 n = DEFAULTBCNT / 512;
314 if (ah->scnt > n) {
315 ah->scnt = n;
316 if (ah->aflags & AOEAFL_WRITE) {
317 skb_fill_page_desc(skb, 0, virt_to_page(f->bufaddr),
318 offset_in_page(f->bufaddr), DEFAULTBCNT);
319 skb->len = sizeof *h + sizeof *ah + DEFAULTBCNT;
320 skb->data_len = DEFAULTBCNT;
321 }
322 if (++d->lostjumbo > (d->nframes << 1))
323 if (d->maxbcnt != DEFAULTBCNT) {
324 printk(KERN_INFO "aoe: e%ld.%ld: too many lost jumbo on %s - using 1KB frames.\n",
325 d->aoemajor, d->aoeminor, d->ifp->name);
326 d->maxbcnt = DEFAULTBCNT;
327 d->flags |= DEVFL_MAXBCNT;
328 }
329 }
330
331 skb->dev = d->ifp;
332 skb = skb_clone(skb, GFP_ATOMIC);
333 if (skb == NULL)
334 return;
335 if (d->sendq_hd)
336 d->sendq_tl->next = skb;
337 else
338 d->sendq_hd = skb;
339 d->sendq_tl = skb;
340 }
341
342 static int
343 tsince(int tag)
344 {
345 int n;
346
347 n = jiffies & 0xffff;
348 n -= tag & 0xffff;
349 if (n < 0)
350 n += 1<<16;
351 return n;
352 }
353
354 static void
355 rexmit_timer(ulong vp)
356 {
357 struct aoedev *d;
358 struct frame *f, *e;
359 struct sk_buff *sl;
360 register long timeout;
361 ulong flags, n;
362
363 d = (struct aoedev *) vp;
364 sl = NULL;
365
366 /* timeout is always ~150% of the moving average */
367 timeout = d->rttavg;
368 timeout += timeout >> 1;
369
370 spin_lock_irqsave(&d->lock, flags);
371
372 if (d->flags & DEVFL_TKILL) {
373 spin_unlock_irqrestore(&d->lock, flags);
374 return;
375 }
376 f = d->frames;
377 e = f + d->nframes;
378 for (; f<e; f++) {
379 if (f->tag != FREETAG && tsince(f->tag) >= timeout) {
380 n = f->waited += timeout;
381 n /= HZ;
382 if (n > aoe_deadsecs) { /* waited too long for response */
383 aoedev_downdev(d);
384 break;
385 }
386 rexmit(d, f);
387 }
388 }
389 if (d->flags & DEVFL_KICKME) {
390 d->flags &= ~DEVFL_KICKME;
391 aoecmd_work(d);
392 }
393
394 sl = d->sendq_hd;
395 d->sendq_hd = d->sendq_tl = NULL;
396 if (sl) {
397 n = d->rttavg <<= 1;
398 if (n > MAXTIMER)
399 d->rttavg = MAXTIMER;
400 }
401
402 d->timer.expires = jiffies + TIMERTICK;
403 add_timer(&d->timer);
404
405 spin_unlock_irqrestore(&d->lock, flags);
406
407 aoenet_xmit(sl);
408 }
409
410 /* this function performs work that has been deferred until sleeping is OK
411 */
412 void
413 aoecmd_sleepwork(struct work_struct *work)
414 {
415 struct aoedev *d = container_of(work, struct aoedev, work);
416
417 if (d->flags & DEVFL_GDALLOC)
418 aoeblk_gdalloc(d);
419
420 if (d->flags & DEVFL_NEWSIZE) {
421 struct block_device *bd;
422 unsigned long flags;
423 u64 ssize;
424
425 ssize = d->gd->capacity;
426 bd = bdget_disk(d->gd, 0);
427
428 if (bd) {
429 mutex_lock(&bd->bd_inode->i_mutex);
430 i_size_write(bd->bd_inode, (loff_t)ssize<<9);
431 mutex_unlock(&bd->bd_inode->i_mutex);
432 bdput(bd);
433 }
434 spin_lock_irqsave(&d->lock, flags);
435 d->flags |= DEVFL_UP;
436 d->flags &= ~DEVFL_NEWSIZE;
437 spin_unlock_irqrestore(&d->lock, flags);
438 }
439 }
440
441 static void
442 ataid_complete(struct aoedev *d, unsigned char *id)
443 {
444 u64 ssize;
445 u16 n;
446
447 /* word 83: command set supported */
448 n = le16_to_cpu(get_unaligned((__le16 *) &id[83<<1]));
449
450 /* word 86: command set/feature enabled */
451 n |= le16_to_cpu(get_unaligned((__le16 *) &id[86<<1]));
452
453 if (n & (1<<10)) { /* bit 10: LBA 48 */
454 d->flags |= DEVFL_EXT;
455
456 /* word 100: number lba48 sectors */
457 ssize = le64_to_cpu(get_unaligned((__le64 *) &id[100<<1]));
458
459 /* set as in ide-disk.c:init_idedisk_capacity */
460 d->geo.cylinders = ssize;
461 d->geo.cylinders /= (255 * 63);
462 d->geo.heads = 255;
463 d->geo.sectors = 63;
464 } else {
465 d->flags &= ~DEVFL_EXT;
466
467 /* number lba28 sectors */
468 ssize = le32_to_cpu(get_unaligned((__le32 *) &id[60<<1]));
469
470 /* NOTE: obsolete in ATA 6 */
471 d->geo.cylinders = le16_to_cpu(get_unaligned((__le16 *) &id[54<<1]));
472 d->geo.heads = le16_to_cpu(get_unaligned((__le16 *) &id[55<<1]));
473 d->geo.sectors = le16_to_cpu(get_unaligned((__le16 *) &id[56<<1]));
474 }
475
476 if (d->ssize != ssize)
477 printk(KERN_INFO "aoe: %012llx e%lu.%lu v%04x has %llu sectors\n",
478 (unsigned long long)mac_addr(d->addr),
479 d->aoemajor, d->aoeminor,
480 d->fw_ver, (long long)ssize);
481 d->ssize = ssize;
482 d->geo.start = 0;
483 if (d->gd != NULL) {
484 d->gd->capacity = ssize;
485 d->flags |= DEVFL_NEWSIZE;
486 } else {
487 if (d->flags & DEVFL_GDALLOC) {
488 printk(KERN_ERR "aoe: can't schedule work for e%lu.%lu, %s\n",
489 d->aoemajor, d->aoeminor,
490 "it's already on! This shouldn't happen.\n");
491 return;
492 }
493 d->flags |= DEVFL_GDALLOC;
494 }
495 schedule_work(&d->work);
496 }
497
498 static void
499 calc_rttavg(struct aoedev *d, int rtt)
500 {
501 register long n;
502
503 n = rtt;
504 if (n < 0) {
505 n = -rtt;
506 if (n < MINTIMER)
507 n = MINTIMER;
508 else if (n > MAXTIMER)
509 n = MAXTIMER;
510 d->mintimer += (n - d->mintimer) >> 1;
511 } else if (n < d->mintimer)
512 n = d->mintimer;
513 else if (n > MAXTIMER)
514 n = MAXTIMER;
515
516 /* g == .25; cf. Congestion Avoidance and Control, Jacobson & Karels; 1988 */
517 n -= d->rttavg;
518 d->rttavg += n >> 2;
519 }
520
521 void
522 aoecmd_ata_rsp(struct sk_buff *skb)
523 {
524 struct aoedev *d;
525 struct aoe_hdr *hin, *hout;
526 struct aoe_atahdr *ahin, *ahout;
527 struct frame *f;
528 struct buf *buf;
529 struct sk_buff *sl;
530 register long n;
531 ulong flags;
532 char ebuf[128];
533 u16 aoemajor;
534
535 hin = aoe_hdr(skb);
536 aoemajor = be16_to_cpu(get_unaligned(&hin->major));
537 d = aoedev_by_aoeaddr(aoemajor, hin->minor);
538 if (d == NULL) {
539 snprintf(ebuf, sizeof ebuf, "aoecmd_ata_rsp: ata response "
540 "for unknown device %d.%d\n",
541 aoemajor, hin->minor);
542 aoechr_error(ebuf);
543 return;
544 }
545
546 spin_lock_irqsave(&d->lock, flags);
547
548 n = be32_to_cpu(get_unaligned(&hin->tag));
549 f = getframe(d, n);
550 if (f == NULL) {
551 calc_rttavg(d, -tsince(n));
552 spin_unlock_irqrestore(&d->lock, flags);
553 snprintf(ebuf, sizeof ebuf,
554 "%15s e%d.%d tag=%08x@%08lx\n",
555 "unexpected rsp",
556 be16_to_cpu(get_unaligned(&hin->major)),
557 hin->minor,
558 be32_to_cpu(get_unaligned(&hin->tag)),
559 jiffies);
560 aoechr_error(ebuf);
561 return;
562 }
563
564 calc_rttavg(d, tsince(f->tag));
565
566 ahin = (struct aoe_atahdr *) (hin+1);
567 hout = aoe_hdr(f->skb);
568 ahout = (struct aoe_atahdr *) (hout+1);
569 buf = f->buf;
570
571 if (ahout->cmdstat == WIN_IDENTIFY)
572 d->flags &= ~DEVFL_PAUSE;
573 if (ahin->cmdstat & 0xa9) { /* these bits cleared on success */
574 printk(KERN_ERR
575 "aoe: ata error cmd=%2.2Xh stat=%2.2Xh from e%ld.%ld\n",
576 ahout->cmdstat, ahin->cmdstat,
577 d->aoemajor, d->aoeminor);
578 if (buf)
579 buf->flags |= BUFFL_FAIL;
580 } else {
581 n = ahout->scnt << 9;
582 switch (ahout->cmdstat) {
583 case WIN_READ:
584 case WIN_READ_EXT:
585 if (skb->len - sizeof *hin - sizeof *ahin < n) {
586 printk(KERN_ERR
587 "aoe: runt data size in read. skb->len=%d\n",
588 skb->len);
589 /* fail frame f? just returning will rexmit. */
590 spin_unlock_irqrestore(&d->lock, flags);
591 return;
592 }
593 memcpy(f->bufaddr, ahin+1, n);
594 case WIN_WRITE:
595 case WIN_WRITE_EXT:
596 if (f->bcnt -= n) {
597 skb = f->skb;
598 f->bufaddr += n;
599 put_lba(ahout, f->lba += ahout->scnt);
600 n = f->bcnt;
601 if (n > DEFAULTBCNT)
602 n = DEFAULTBCNT;
603 ahout->scnt = n >> 9;
604 if (ahout->aflags & AOEAFL_WRITE) {
605 skb_fill_page_desc(skb, 0,
606 virt_to_page(f->bufaddr),
607 offset_in_page(f->bufaddr), n);
608 skb->len = sizeof *hout + sizeof *ahout + n;
609 skb->data_len = n;
610 }
611 f->tag = newtag(d);
612 hout->tag = cpu_to_be32(f->tag);
613 skb->dev = d->ifp;
614 skb = skb_clone(skb, GFP_ATOMIC);
615 spin_unlock_irqrestore(&d->lock, flags);
616 if (skb)
617 aoenet_xmit(skb);
618 return;
619 }
620 if (n > DEFAULTBCNT)
621 d->lostjumbo = 0;
622 break;
623 case WIN_IDENTIFY:
624 if (skb->len - sizeof *hin - sizeof *ahin < 512) {
625 printk(KERN_INFO
626 "aoe: runt data size in ataid. skb->len=%d\n",
627 skb->len);
628 spin_unlock_irqrestore(&d->lock, flags);
629 return;
630 }
631 ataid_complete(d, (char *) (ahin+1));
632 break;
633 default:
634 printk(KERN_INFO
635 "aoe: unrecognized ata command %2.2Xh for %d.%d\n",
636 ahout->cmdstat,
637 be16_to_cpu(get_unaligned(&hin->major)),
638 hin->minor);
639 }
640 }
641
642 if (buf) {
643 buf->nframesout -= 1;
644 if (buf->nframesout == 0 && buf->resid == 0) {
645 unsigned long duration = jiffies - buf->start_time;
646 unsigned long n_sect = buf->bio->bi_size >> 9;
647 struct gendisk *disk = d->gd;
648 const int rw = bio_data_dir(buf->bio);
649
650 disk_stat_inc(disk, ios[rw]);
651 disk_stat_add(disk, ticks[rw], duration);
652 disk_stat_add(disk, sectors[rw], n_sect);
653 disk_stat_add(disk, io_ticks, duration);
654 n = (buf->flags & BUFFL_FAIL) ? -EIO : 0;
655 bio_endio(buf->bio, buf->bio->bi_size, n);
656 mempool_free(buf, d->bufpool);
657 }
658 }
659
660 f->buf = NULL;
661 f->tag = FREETAG;
662
663 aoecmd_work(d);
664 sl = d->sendq_hd;
665 d->sendq_hd = d->sendq_tl = NULL;
666
667 spin_unlock_irqrestore(&d->lock, flags);
668 aoenet_xmit(sl);
669 }
670
671 void
672 aoecmd_cfg(ushort aoemajor, unsigned char aoeminor)
673 {
674 struct sk_buff *sl;
675
676 sl = aoecmd_cfg_pkts(aoemajor, aoeminor, NULL);
677
678 aoenet_xmit(sl);
679 }
680
681 /*
682 * Since we only call this in one place (and it only prepares one frame)
683 * we just return the skb. Usually we'd chain it up to the aoedev sendq.
684 */
685 static struct sk_buff *
686 aoecmd_ata_id(struct aoedev *d)
687 {
688 struct aoe_hdr *h;
689 struct aoe_atahdr *ah;
690 struct frame *f;
691 struct sk_buff *skb;
692
693 f = freeframe(d);
694 if (f == NULL) {
695 printk(KERN_ERR "aoe: can't get a frame. This shouldn't happen.\n");
696 return NULL;
697 }
698
699 /* initialize the headers & frame */
700 skb = f->skb;
701 h = aoe_hdr(skb);
702 ah = (struct aoe_atahdr *) (h+1);
703 skb_put(skb, sizeof *h + sizeof *ah);
704 memset(h, 0, skb->len);
705 f->tag = aoehdr_atainit(d, h);
706 f->waited = 0;
707
708 /* set up ata header */
709 ah->scnt = 1;
710 ah->cmdstat = WIN_IDENTIFY;
711 ah->lba3 = 0xa0;
712
713 skb->dev = d->ifp;
714
715 d->rttavg = MAXTIMER;
716 d->timer.function = rexmit_timer;
717
718 return skb_clone(skb, GFP_ATOMIC);
719 }
720
721 void
722 aoecmd_cfg_rsp(struct sk_buff *skb)
723 {
724 struct aoedev *d;
725 struct aoe_hdr *h;
726 struct aoe_cfghdr *ch;
727 ulong flags, sysminor, aoemajor;
728 struct sk_buff *sl;
729 enum { MAXFRAMES = 16 };
730 u16 n;
731
732 h = aoe_hdr(skb);
733 ch = (struct aoe_cfghdr *) (h+1);
734
735 /*
736 * Enough people have their dip switches set backwards to
737 * warrant a loud message for this special case.
738 */
739 aoemajor = be16_to_cpu(get_unaligned(&h->major));
740 if (aoemajor == 0xfff) {
741 printk(KERN_ERR "aoe: Warning: shelf address is all ones. "
742 "Check shelf dip switches.\n");
743 return;
744 }
745
746 sysminor = SYSMINOR(aoemajor, h->minor);
747 if (sysminor * AOE_PARTITIONS + AOE_PARTITIONS > MINORMASK) {
748 printk(KERN_INFO "aoe: e%ld.%d: minor number too large\n",
749 aoemajor, (int) h->minor);
750 return;
751 }
752
753 n = be16_to_cpu(ch->bufcnt);
754 if (n > MAXFRAMES) /* keep it reasonable */
755 n = MAXFRAMES;
756
757 d = aoedev_by_sysminor_m(sysminor, n);
758 if (d == NULL) {
759 printk(KERN_INFO "aoe: device sysminor_m failure\n");
760 return;
761 }
762
763 spin_lock_irqsave(&d->lock, flags);
764
765 /* permit device to migrate mac and network interface */
766 d->ifp = skb->dev;
767 memcpy(d->addr, h->src, sizeof d->addr);
768 if (!(d->flags & DEVFL_MAXBCNT)) {
769 n = d->ifp->mtu;
770 n -= sizeof (struct aoe_hdr) + sizeof (struct aoe_atahdr);
771 n /= 512;
772 if (n > ch->scnt)
773 n = ch->scnt;
774 n = n ? n * 512 : DEFAULTBCNT;
775 if (n != d->maxbcnt) {
776 printk(KERN_INFO
777 "aoe: e%ld.%ld: setting %d byte data frames on %s\n",
778 d->aoemajor, d->aoeminor, n, d->ifp->name);
779 d->maxbcnt = n;
780 }
781 }
782
783 /* don't change users' perspective */
784 if (d->nopen && !(d->flags & DEVFL_PAUSE)) {
785 spin_unlock_irqrestore(&d->lock, flags);
786 return;
787 }
788 d->flags |= DEVFL_PAUSE; /* force pause */
789 d->mintimer = MINTIMER;
790 d->fw_ver = be16_to_cpu(ch->fwver);
791
792 /* check for already outstanding ataid */
793 sl = aoedev_isbusy(d) == 0 ? aoecmd_ata_id(d) : NULL;
794
795 spin_unlock_irqrestore(&d->lock, flags);
796
797 aoenet_xmit(sl);
798 }
799
Software Suspend 2 for Linus's 2.6 head (mirror)