2 * linux/drivers/s390/net/qeth_main.c
4 * Linux on zSeries OSA Express and HiperSockets support
6 * Copyright 2000,2003 IBM Corporation
8 * Author(s): Original Code written by
9 * Utz Bacher (utz.bacher@de.ibm.com)
11 * Frank Pavlic (fpavlic@de.ibm.com) and
12 * Thomas Spatzier <tspat@de.ibm.com>
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2, or (at your option)
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
30 #include <linux/module.h>
31 #include <linux/moduleparam.h>
32 #include <linux/string.h>
33 #include <linux/errno.h>
36 #include <linux/inetdevice.h>
37 #include <linux/netdevice.h>
38 #include <linux/sched.h>
39 #include <linux/workqueue.h>
40 #include <linux/kernel.h>
41 #include <linux/slab.h>
42 #include <linux/interrupt.h>
43 #include <linux/tcp.h>
44 #include <linux/icmp.h>
45 #include <linux/skbuff.h>
47 #include <linux/igmp.h>
48 #include <linux/init.h>
49 #include <linux/reboot.h>
50 #include <linux/mii.h>
51 #include <linux/rcupdate.h>
52 #include <linux/ethtool.h>
56 #include <net/route.h>
58 #include <asm/ebcdic.h>
61 #include <asm/timex.h>
62 #include <asm/semaphore.h>
63 #include <asm/uaccess.h>
64 #include <asm/s390_rdev.h>
69 #include "qeth_eddp.h"
72 static const char *version
= "qeth S/390 OSA-Express driver";
75 * Debug Facility Stuff
77 static debug_info_t
*qeth_dbf_setup
= NULL
;
78 static debug_info_t
*qeth_dbf_data
= NULL
;
79 static debug_info_t
*qeth_dbf_misc
= NULL
;
80 static debug_info_t
*qeth_dbf_control
= NULL
;
81 debug_info_t
*qeth_dbf_trace
= NULL
;
82 static debug_info_t
*qeth_dbf_sense
= NULL
;
83 static debug_info_t
*qeth_dbf_qerr
= NULL
;
85 DEFINE_PER_CPU(char[256], qeth_dbf_txt_buf
);
87 static struct lock_class_key qdio_out_skb_queue_key
;
90 * some more definitions and declarations
92 static unsigned int known_devices
[][10] = QETH_MODELLIST_ARRAY
;
94 /* list of our cards */
95 struct qeth_card_list_struct qeth_card_list
;
96 /*process list want to be notified*/
97 spinlock_t qeth_notify_lock
;
98 struct list_head qeth_notify_list
;
100 static void qeth_send_control_data_cb(struct qeth_channel
*,
101 struct qeth_cmd_buffer
*);
104 * here we go with function implementation
107 qeth_init_qdio_info(struct qeth_card
*card
);
110 qeth_init_qdio_queues(struct qeth_card
*card
);
113 qeth_alloc_qdio_buffers(struct qeth_card
*card
);
116 qeth_free_qdio_buffers(struct qeth_card
*);
119 qeth_clear_qdio_buffers(struct qeth_card
*);
122 qeth_clear_ip_list(struct qeth_card
*, int, int);
125 qeth_clear_ipacmd_list(struct qeth_card
*);
128 qeth_qdio_clear_card(struct qeth_card
*, int);
131 qeth_clear_working_pool_list(struct qeth_card
*);
134 qeth_clear_cmd_buffers(struct qeth_channel
*);
137 qeth_stop(struct net_device
*);
140 qeth_clear_ipato_list(struct qeth_card
*);
143 qeth_is_addr_covered_by_ipato(struct qeth_card
*, struct qeth_ipaddr
*);
146 qeth_irq_tasklet(unsigned long);
149 qeth_set_online(struct ccwgroup_device
*);
152 __qeth_set_online(struct ccwgroup_device
*gdev
, int recovery_mode
);
154 static struct qeth_ipaddr
*
155 qeth_get_addr_buffer(enum qeth_prot_versions
);
158 qeth_set_multicast_list(struct net_device
*);
161 qeth_setadp_promisc_mode(struct qeth_card
*);
164 qeth_notify_processes(void)
166 /*notify all registered processes */
167 struct qeth_notify_list_struct
*n_entry
;
169 QETH_DBF_TEXT(trace
,3,"procnoti");
170 spin_lock(&qeth_notify_lock
);
171 list_for_each_entry(n_entry
, &qeth_notify_list
, list
) {
172 send_sig(n_entry
->signum
, n_entry
->task
, 1);
174 spin_unlock(&qeth_notify_lock
);
178 qeth_notifier_unregister(struct task_struct
*p
)
180 struct qeth_notify_list_struct
*n_entry
, *tmp
;
182 QETH_DBF_TEXT(trace
, 2, "notunreg");
183 spin_lock(&qeth_notify_lock
);
184 list_for_each_entry_safe(n_entry
, tmp
, &qeth_notify_list
, list
) {
185 if (n_entry
->task
== p
) {
186 list_del(&n_entry
->list
);
192 spin_unlock(&qeth_notify_lock
);
196 qeth_notifier_register(struct task_struct
*p
, int signum
)
198 struct qeth_notify_list_struct
*n_entry
;
200 /*check first if entry already exists*/
201 spin_lock(&qeth_notify_lock
);
202 list_for_each_entry(n_entry
, &qeth_notify_list
, list
) {
203 if (n_entry
->task
== p
) {
204 n_entry
->signum
= signum
;
205 spin_unlock(&qeth_notify_lock
);
209 spin_unlock(&qeth_notify_lock
);
211 n_entry
= (struct qeth_notify_list_struct
*)
212 kmalloc(sizeof(struct qeth_notify_list_struct
),GFP_KERNEL
);
216 n_entry
->signum
= signum
;
217 spin_lock(&qeth_notify_lock
);
218 list_add(&n_entry
->list
,&qeth_notify_list
);
219 spin_unlock(&qeth_notify_lock
);
225 * free channel command buffers
228 qeth_clean_channel(struct qeth_channel
*channel
)
232 QETH_DBF_TEXT(setup
, 2, "freech");
233 for (cnt
= 0; cnt
< QETH_CMD_BUFFER_NO
; cnt
++)
234 kfree(channel
->iob
[cnt
].data
);
241 qeth_free_card(struct qeth_card
*card
)
244 QETH_DBF_TEXT(setup
, 2, "freecrd");
245 QETH_DBF_HEX(setup
, 2, &card
, sizeof(void *));
246 qeth_clean_channel(&card
->read
);
247 qeth_clean_channel(&card
->write
);
249 free_netdev(card
->dev
);
250 qeth_clear_ip_list(card
, 0, 0);
251 qeth_clear_ipato_list(card
);
252 kfree(card
->ip_tbd_list
);
253 qeth_free_qdio_buffers(card
);
258 * alloc memory for command buffer per channel
261 qeth_setup_channel(struct qeth_channel
*channel
)
265 QETH_DBF_TEXT(setup
, 2, "setupch");
266 for (cnt
=0; cnt
< QETH_CMD_BUFFER_NO
; cnt
++) {
267 channel
->iob
[cnt
].data
= (char *)
268 kmalloc(QETH_BUFSIZE
, GFP_DMA
|GFP_KERNEL
);
269 if (channel
->iob
[cnt
].data
== NULL
)
271 channel
->iob
[cnt
].state
= BUF_STATE_FREE
;
272 channel
->iob
[cnt
].channel
= channel
;
273 channel
->iob
[cnt
].callback
= qeth_send_control_data_cb
;
274 channel
->iob
[cnt
].rc
= 0;
276 if (cnt
< QETH_CMD_BUFFER_NO
) {
278 kfree(channel
->iob
[cnt
].data
);
282 channel
->io_buf_no
= 0;
283 atomic_set(&channel
->irq_pending
, 0);
284 spin_lock_init(&channel
->iob_lock
);
286 init_waitqueue_head(&channel
->wait_q
);
287 channel
->irq_tasklet
.data
= (unsigned long) channel
;
288 channel
->irq_tasklet
.func
= qeth_irq_tasklet
;
293 * alloc memory for card structure
295 static struct qeth_card
*
296 qeth_alloc_card(void)
298 struct qeth_card
*card
;
300 QETH_DBF_TEXT(setup
, 2, "alloccrd");
301 card
= kzalloc(sizeof(struct qeth_card
), GFP_DMA
|GFP_KERNEL
);
304 QETH_DBF_HEX(setup
, 2, &card
, sizeof(void *));
305 if (qeth_setup_channel(&card
->read
)) {
309 if (qeth_setup_channel(&card
->write
)) {
310 qeth_clean_channel(&card
->read
);
318 __qeth_check_irb_error(struct ccw_device
*cdev
, unsigned long intparm
,
324 switch (PTR_ERR(irb
)) {
326 PRINT_WARN("i/o-error on device %s\n", cdev
->dev
.bus_id
);
327 QETH_DBF_TEXT(trace
, 2, "ckirberr");
328 QETH_DBF_TEXT_(trace
, 2, " rc%d", -EIO
);
331 PRINT_WARN("timeout on device %s\n", cdev
->dev
.bus_id
);
332 QETH_DBF_TEXT(trace
, 2, "ckirberr");
333 QETH_DBF_TEXT_(trace
, 2, " rc%d", -ETIMEDOUT
);
334 if (intparm
== QETH_RCD_PARM
) {
335 struct qeth_card
*card
= CARD_FROM_CDEV(cdev
);
337 if (card
&& (card
->data
.ccwdev
== cdev
)) {
338 card
->data
.state
= CH_STATE_DOWN
;
339 wake_up(&card
->wait_q
);
344 PRINT_WARN("unknown error %ld on device %s\n", PTR_ERR(irb
),
346 QETH_DBF_TEXT(trace
, 2, "ckirberr");
347 QETH_DBF_TEXT(trace
, 2, " rc???");
353 qeth_get_problem(struct ccw_device
*cdev
, struct irb
*irb
)
358 sense
= (char *) irb
->ecw
;
359 cstat
= irb
->scsw
.cstat
;
360 dstat
= irb
->scsw
.dstat
;
362 if (cstat
& (SCHN_STAT_CHN_CTRL_CHK
| SCHN_STAT_INTF_CTRL_CHK
|
363 SCHN_STAT_CHN_DATA_CHK
| SCHN_STAT_CHAIN_CHECK
|
364 SCHN_STAT_PROT_CHECK
| SCHN_STAT_PROG_CHECK
)) {
365 QETH_DBF_TEXT(trace
,2, "CGENCHK");
366 PRINT_WARN("check on device %s, dstat=x%x, cstat=x%x ",
367 cdev
->dev
.bus_id
, dstat
, cstat
);
368 HEXDUMP16(WARN
, "irb: ", irb
);
369 HEXDUMP16(WARN
, "irb: ", ((char *) irb
) + 32);
373 if (dstat
& DEV_STAT_UNIT_CHECK
) {
374 if (sense
[SENSE_RESETTING_EVENT_BYTE
] &
375 SENSE_RESETTING_EVENT_FLAG
) {
376 QETH_DBF_TEXT(trace
,2,"REVIND");
379 if (sense
[SENSE_COMMAND_REJECT_BYTE
] &
380 SENSE_COMMAND_REJECT_FLAG
) {
381 QETH_DBF_TEXT(trace
,2,"CMDREJi");
384 if ((sense
[2] == 0xaf) && (sense
[3] == 0xfe)) {
385 QETH_DBF_TEXT(trace
,2,"AFFE");
388 if ((!sense
[0]) && (!sense
[1]) && (!sense
[2]) && (!sense
[3])) {
389 QETH_DBF_TEXT(trace
,2,"ZEROSEN");
392 QETH_DBF_TEXT(trace
,2,"DGENCHK");
397 static int qeth_issue_next_read(struct qeth_card
*);
403 qeth_irq(struct ccw_device
*cdev
, unsigned long intparm
, struct irb
*irb
)
407 struct qeth_cmd_buffer
*buffer
;
408 struct qeth_channel
*channel
;
409 struct qeth_card
*card
;
411 QETH_DBF_TEXT(trace
,5,"irq");
413 if (__qeth_check_irb_error(cdev
, intparm
, irb
))
415 cstat
= irb
->scsw
.cstat
;
416 dstat
= irb
->scsw
.dstat
;
418 card
= CARD_FROM_CDEV(cdev
);
422 if (card
->read
.ccwdev
== cdev
){
423 channel
= &card
->read
;
424 QETH_DBF_TEXT(trace
,5,"read");
425 } else if (card
->write
.ccwdev
== cdev
) {
426 channel
= &card
->write
;
427 QETH_DBF_TEXT(trace
,5,"write");
429 channel
= &card
->data
;
430 QETH_DBF_TEXT(trace
,5,"data");
432 atomic_set(&channel
->irq_pending
, 0);
434 if (irb
->scsw
.fctl
& (SCSW_FCTL_CLEAR_FUNC
))
435 channel
->state
= CH_STATE_STOPPED
;
437 if (irb
->scsw
.fctl
& (SCSW_FCTL_HALT_FUNC
))
438 channel
->state
= CH_STATE_HALTED
;
440 /*let's wake up immediately on data channel*/
441 if ((channel
== &card
->data
) && (intparm
!= 0) &&
442 (intparm
!= QETH_RCD_PARM
))
445 if (intparm
== QETH_CLEAR_CHANNEL_PARM
) {
446 QETH_DBF_TEXT(trace
, 6, "clrchpar");
447 /* we don't have to handle this further */
450 if (intparm
== QETH_HALT_CHANNEL_PARM
) {
451 QETH_DBF_TEXT(trace
, 6, "hltchpar");
452 /* we don't have to handle this further */
455 if ((dstat
& DEV_STAT_UNIT_EXCEP
) ||
456 (dstat
& DEV_STAT_UNIT_CHECK
) ||
458 if (irb
->esw
.esw0
.erw
.cons
) {
459 /* TODO: we should make this s390dbf */
460 PRINT_WARN("sense data available on channel %s.\n",
461 CHANNEL_ID(channel
));
462 PRINT_WARN(" cstat 0x%X\n dstat 0x%X\n", cstat
, dstat
);
463 HEXDUMP16(WARN
,"irb: ",irb
);
464 HEXDUMP16(WARN
,"sense data: ",irb
->ecw
);
466 if (intparm
== QETH_RCD_PARM
) {
467 channel
->state
= CH_STATE_DOWN
;
470 rc
= qeth_get_problem(cdev
,irb
);
472 qeth_schedule_recovery(card
);
477 if (intparm
== QETH_RCD_PARM
) {
478 channel
->state
= CH_STATE_RCD_DONE
;
482 buffer
= (struct qeth_cmd_buffer
*) __va((addr_t
)intparm
);
483 buffer
->state
= BUF_STATE_PROCESSED
;
485 if (channel
== &card
->data
)
488 if (channel
== &card
->read
&&
489 channel
->state
== CH_STATE_UP
)
490 qeth_issue_next_read(card
);
492 qeth_irq_tasklet((unsigned long)channel
);
495 wake_up(&card
->wait_q
);
499 * tasklet function scheduled from irq handler
502 qeth_irq_tasklet(unsigned long data
)
504 struct qeth_card
*card
;
505 struct qeth_channel
*channel
;
506 struct qeth_cmd_buffer
*iob
;
509 QETH_DBF_TEXT(trace
,5,"irqtlet");
510 channel
= (struct qeth_channel
*) data
;
512 index
= channel
->buf_no
;
513 card
= CARD_FROM_CDEV(channel
->ccwdev
);
514 while (iob
[index
].state
== BUF_STATE_PROCESSED
) {
515 if (iob
[index
].callback
!=NULL
) {
516 iob
[index
].callback(channel
,iob
+ index
);
518 index
= (index
+ 1) % QETH_CMD_BUFFER_NO
;
520 channel
->buf_no
= index
;
521 wake_up(&card
->wait_q
);
524 static int qeth_stop_card(struct qeth_card
*, int);
527 __qeth_set_offline(struct ccwgroup_device
*cgdev
, int recovery_mode
)
529 struct qeth_card
*card
= (struct qeth_card
*) cgdev
->dev
.driver_data
;
530 int rc
= 0, rc2
= 0, rc3
= 0;
531 enum qeth_card_states recover_flag
;
533 QETH_DBF_TEXT(setup
, 3, "setoffl");
534 QETH_DBF_HEX(setup
, 3, &card
, sizeof(void *));
536 if (card
->dev
&& netif_carrier_ok(card
->dev
))
537 netif_carrier_off(card
->dev
);
538 recover_flag
= card
->state
;
539 if (qeth_stop_card(card
, recovery_mode
) == -ERESTARTSYS
){
540 PRINT_WARN("Stopping card %s interrupted by user!\n",
544 rc
= ccw_device_set_offline(CARD_DDEV(card
));
545 rc2
= ccw_device_set_offline(CARD_WDEV(card
));
546 rc3
= ccw_device_set_offline(CARD_RDEV(card
));
548 rc
= (rc2
) ? rc2
: rc3
;
550 QETH_DBF_TEXT_(setup
, 2, "1err%d", rc
);
551 if (recover_flag
== CARD_STATE_UP
)
552 card
->state
= CARD_STATE_RECOVER
;
553 qeth_notify_processes();
558 qeth_set_offline(struct ccwgroup_device
*cgdev
)
560 return __qeth_set_offline(cgdev
, 0);
564 qeth_wait_for_threads(struct qeth_card
*card
, unsigned long threads
);
568 qeth_remove_device(struct ccwgroup_device
*cgdev
)
570 struct qeth_card
*card
= (struct qeth_card
*) cgdev
->dev
.driver_data
;
573 QETH_DBF_TEXT(setup
, 3, "rmdev");
574 QETH_DBF_HEX(setup
, 3, &card
, sizeof(void *));
579 if (qeth_wait_for_threads(card
, 0xffffffff))
582 if (cgdev
->state
== CCWGROUP_ONLINE
){
583 card
->use_hard_stop
= 1;
584 qeth_set_offline(cgdev
);
586 /* remove form our internal list */
587 write_lock_irqsave(&qeth_card_list
.rwlock
, flags
);
588 list_del(&card
->list
);
589 write_unlock_irqrestore(&qeth_card_list
.rwlock
, flags
);
591 unregister_netdev(card
->dev
);
592 qeth_remove_device_attributes(&cgdev
->dev
);
593 qeth_free_card(card
);
594 cgdev
->dev
.driver_data
= NULL
;
595 put_device(&cgdev
->dev
);
599 qeth_register_addr_entry(struct qeth_card
*, struct qeth_ipaddr
*);
601 qeth_deregister_addr_entry(struct qeth_card
*, struct qeth_ipaddr
*);
604 * Add/remove address to/from card's ip list, i.e. try to add or remove
605 * reference to/from an IP address that is already registered on the card.
607 * 0 address was on card and its reference count has been adjusted,
608 * but is still > 0, so nothing has to be done
609 * also returns 0 if card was not on card and the todo was to delete
610 * the address -> there is also nothing to be done
611 * 1 address was not on card and the todo is to add it to the card's ip
613 * -1 address was on card and its reference count has been decremented
614 * to <= 0 by the todo -> address must be removed from card
617 __qeth_ref_ip_on_card(struct qeth_card
*card
, struct qeth_ipaddr
*todo
,
618 struct qeth_ipaddr
**__addr
)
620 struct qeth_ipaddr
*addr
;
623 list_for_each_entry(addr
, &card
->ip_list
, entry
) {
624 if (card
->options
.layer2
) {
625 if ((addr
->type
== todo
->type
) &&
626 (memcmp(&addr
->mac
, &todo
->mac
,
627 OSA_ADDR_LEN
) == 0)) {
633 if ((addr
->proto
== QETH_PROT_IPV4
) &&
634 (todo
->proto
== QETH_PROT_IPV4
) &&
635 (addr
->type
== todo
->type
) &&
636 (addr
->u
.a4
.addr
== todo
->u
.a4
.addr
) &&
637 (addr
->u
.a4
.mask
== todo
->u
.a4
.mask
)) {
641 if ((addr
->proto
== QETH_PROT_IPV6
) &&
642 (todo
->proto
== QETH_PROT_IPV6
) &&
643 (addr
->type
== todo
->type
) &&
644 (addr
->u
.a6
.pfxlen
== todo
->u
.a6
.pfxlen
) &&
645 (memcmp(&addr
->u
.a6
.addr
, &todo
->u
.a6
.addr
,
646 sizeof(struct in6_addr
)) == 0)) {
652 addr
->users
+= todo
->users
;
653 if (addr
->users
<= 0){
657 /* for VIPA and RXIP limit refcount to 1 */
658 if (addr
->type
!= QETH_IP_TYPE_NORMAL
)
663 if (todo
->users
> 0) {
664 /* for VIPA and RXIP limit refcount to 1 */
665 if (todo
->type
!= QETH_IP_TYPE_NORMAL
)
673 __qeth_address_exists_in_list(struct list_head
*list
, struct qeth_ipaddr
*addr
,
676 struct qeth_ipaddr
*tmp
;
678 list_for_each_entry(tmp
, list
, entry
) {
679 if ((tmp
->proto
== QETH_PROT_IPV4
) &&
680 (addr
->proto
== QETH_PROT_IPV4
) &&
681 ((same_type
&& (tmp
->type
== addr
->type
)) ||
682 (!same_type
&& (tmp
->type
!= addr
->type
)) ) &&
683 (tmp
->u
.a4
.addr
== addr
->u
.a4
.addr
) ){
686 if ((tmp
->proto
== QETH_PROT_IPV6
) &&
687 (addr
->proto
== QETH_PROT_IPV6
) &&
688 ((same_type
&& (tmp
->type
== addr
->type
)) ||
689 (!same_type
&& (tmp
->type
!= addr
->type
)) ) &&
690 (memcmp(&tmp
->u
.a6
.addr
, &addr
->u
.a6
.addr
,
691 sizeof(struct in6_addr
)) == 0) ) {
699 * Add IP to be added to todo list. If there is already an "add todo"
700 * in this list we just incremenent the reference count.
701 * Returns 0 if we just incremented reference count.
704 __qeth_insert_ip_todo(struct qeth_card
*card
, struct qeth_ipaddr
*addr
, int add
)
706 struct qeth_ipaddr
*tmp
, *t
;
709 list_for_each_entry_safe(tmp
, t
, card
->ip_tbd_list
, entry
) {
710 if ((addr
->type
== QETH_IP_TYPE_DEL_ALL_MC
) &&
711 (tmp
->type
== QETH_IP_TYPE_DEL_ALL_MC
))
713 if (card
->options
.layer2
) {
714 if ((tmp
->type
== addr
->type
) &&
715 (tmp
->is_multicast
== addr
->is_multicast
) &&
716 (memcmp(&tmp
->mac
, &addr
->mac
,
717 OSA_ADDR_LEN
) == 0)) {
723 if ((tmp
->proto
== QETH_PROT_IPV4
) &&
724 (addr
->proto
== QETH_PROT_IPV4
) &&
725 (tmp
->type
== addr
->type
) &&
726 (tmp
->is_multicast
== addr
->is_multicast
) &&
727 (tmp
->u
.a4
.addr
== addr
->u
.a4
.addr
) &&
728 (tmp
->u
.a4
.mask
== addr
->u
.a4
.mask
)) {
732 if ((tmp
->proto
== QETH_PROT_IPV6
) &&
733 (addr
->proto
== QETH_PROT_IPV6
) &&
734 (tmp
->type
== addr
->type
) &&
735 (tmp
->is_multicast
== addr
->is_multicast
) &&
736 (tmp
->u
.a6
.pfxlen
== addr
->u
.a6
.pfxlen
) &&
737 (memcmp(&tmp
->u
.a6
.addr
, &addr
->u
.a6
.addr
,
738 sizeof(struct in6_addr
)) == 0)) {
744 if (addr
->users
!= 0)
745 tmp
->users
+= addr
->users
;
747 tmp
->users
+= add
? 1:-1;
748 if (tmp
->users
== 0) {
749 list_del(&tmp
->entry
);
754 if (addr
->type
== QETH_IP_TYPE_DEL_ALL_MC
)
755 list_add(&addr
->entry
, card
->ip_tbd_list
);
757 if (addr
->users
== 0)
758 addr
->users
+= add
? 1:-1;
759 if (add
&& (addr
->type
== QETH_IP_TYPE_NORMAL
) &&
760 qeth_is_addr_covered_by_ipato(card
, addr
)){
761 QETH_DBF_TEXT(trace
, 2, "tkovaddr");
762 addr
->set_flags
|= QETH_IPA_SETIP_TAKEOVER_FLAG
;
764 list_add_tail(&addr
->entry
, card
->ip_tbd_list
);
771 * Remove IP address from list
774 qeth_delete_ip(struct qeth_card
*card
, struct qeth_ipaddr
*addr
)
779 QETH_DBF_TEXT(trace
, 4, "delip");
781 if (card
->options
.layer2
)
782 QETH_DBF_HEX(trace
, 4, &addr
->mac
, 6);
783 else if (addr
->proto
== QETH_PROT_IPV4
)
784 QETH_DBF_HEX(trace
, 4, &addr
->u
.a4
.addr
, 4);
786 QETH_DBF_HEX(trace
, 4, &addr
->u
.a6
.addr
, 8);
787 QETH_DBF_HEX(trace
, 4, ((char *)&addr
->u
.a6
.addr
) + 8, 8);
789 spin_lock_irqsave(&card
->ip_lock
, flags
);
790 rc
= __qeth_insert_ip_todo(card
, addr
, 0);
791 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
796 qeth_add_ip(struct qeth_card
*card
, struct qeth_ipaddr
*addr
)
801 QETH_DBF_TEXT(trace
, 4, "addip");
802 if (card
->options
.layer2
)
803 QETH_DBF_HEX(trace
, 4, &addr
->mac
, 6);
804 else if (addr
->proto
== QETH_PROT_IPV4
)
805 QETH_DBF_HEX(trace
, 4, &addr
->u
.a4
.addr
, 4);
807 QETH_DBF_HEX(trace
, 4, &addr
->u
.a6
.addr
, 8);
808 QETH_DBF_HEX(trace
, 4, ((char *)&addr
->u
.a6
.addr
) + 8, 8);
810 spin_lock_irqsave(&card
->ip_lock
, flags
);
811 rc
= __qeth_insert_ip_todo(card
, addr
, 1);
812 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
817 __qeth_delete_all_mc(struct qeth_card
*card
, unsigned long *flags
)
819 struct qeth_ipaddr
*addr
, *tmp
;
822 list_for_each_entry_safe(addr
, tmp
, &card
->ip_list
, entry
) {
823 if (addr
->is_multicast
) {
824 spin_unlock_irqrestore(&card
->ip_lock
, *flags
);
825 rc
= qeth_deregister_addr_entry(card
, addr
);
826 spin_lock_irqsave(&card
->ip_lock
, *flags
);
828 list_del(&addr
->entry
);
837 qeth_set_ip_addr_list(struct qeth_card
*card
)
839 struct list_head
*tbd_list
;
840 struct qeth_ipaddr
*todo
, *addr
;
844 QETH_DBF_TEXT(trace
, 2, "sdiplist");
845 QETH_DBF_HEX(trace
, 2, &card
, sizeof(void *));
847 spin_lock_irqsave(&card
->ip_lock
, flags
);
848 tbd_list
= card
->ip_tbd_list
;
849 card
->ip_tbd_list
= kmalloc(sizeof(struct list_head
), GFP_ATOMIC
);
850 if (!card
->ip_tbd_list
) {
851 QETH_DBF_TEXT(trace
, 0, "silnomem");
852 card
->ip_tbd_list
= tbd_list
;
853 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
856 INIT_LIST_HEAD(card
->ip_tbd_list
);
858 while (!list_empty(tbd_list
)){
859 todo
= list_entry(tbd_list
->next
, struct qeth_ipaddr
, entry
);
860 list_del(&todo
->entry
);
861 if (todo
->type
== QETH_IP_TYPE_DEL_ALL_MC
){
862 __qeth_delete_all_mc(card
, &flags
);
866 rc
= __qeth_ref_ip_on_card(card
, todo
, &addr
);
868 /* nothing to be done; only adjusted refcount */
870 } else if (rc
== 1) {
871 /* new entry to be added to on-card list */
872 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
873 rc
= qeth_register_addr_entry(card
, todo
);
874 spin_lock_irqsave(&card
->ip_lock
, flags
);
876 list_add_tail(&todo
->entry
, &card
->ip_list
);
879 } else if (rc
== -1) {
880 /* on-card entry to be removed */
881 list_del_init(&addr
->entry
);
882 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
883 rc
= qeth_deregister_addr_entry(card
, addr
);
884 spin_lock_irqsave(&card
->ip_lock
, flags
);
888 list_add_tail(&addr
->entry
, &card
->ip_list
);
892 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
896 static void qeth_delete_mc_addresses(struct qeth_card
*);
897 static void qeth_add_multicast_ipv4(struct qeth_card
*);
898 static void qeth_layer2_add_multicast(struct qeth_card
*);
899 #ifdef CONFIG_QETH_IPV6
900 static void qeth_add_multicast_ipv6(struct qeth_card
*);
904 qeth_set_thread_start_bit(struct qeth_card
*card
, unsigned long thread
)
908 spin_lock_irqsave(&card
->thread_mask_lock
, flags
);
909 if ( !(card
->thread_allowed_mask
& thread
) ||
910 (card
->thread_start_mask
& thread
) ) {
911 spin_unlock_irqrestore(&card
->thread_mask_lock
, flags
);
914 card
->thread_start_mask
|= thread
;
915 spin_unlock_irqrestore(&card
->thread_mask_lock
, flags
);
920 qeth_clear_thread_start_bit(struct qeth_card
*card
, unsigned long thread
)
924 spin_lock_irqsave(&card
->thread_mask_lock
, flags
);
925 card
->thread_start_mask
&= ~thread
;
926 spin_unlock_irqrestore(&card
->thread_mask_lock
, flags
);
927 wake_up(&card
->wait_q
);
931 qeth_clear_thread_running_bit(struct qeth_card
*card
, unsigned long thread
)
935 spin_lock_irqsave(&card
->thread_mask_lock
, flags
);
936 card
->thread_running_mask
&= ~thread
;
937 spin_unlock_irqrestore(&card
->thread_mask_lock
, flags
);
938 wake_up(&card
->wait_q
);
942 __qeth_do_run_thread(struct qeth_card
*card
, unsigned long thread
)
947 spin_lock_irqsave(&card
->thread_mask_lock
, flags
);
948 if (card
->thread_start_mask
& thread
){
949 if ((card
->thread_allowed_mask
& thread
) &&
950 !(card
->thread_running_mask
& thread
)){
952 card
->thread_start_mask
&= ~thread
;
953 card
->thread_running_mask
|= thread
;
957 spin_unlock_irqrestore(&card
->thread_mask_lock
, flags
);
962 qeth_do_run_thread(struct qeth_card
*card
, unsigned long thread
)
966 wait_event(card
->wait_q
,
967 (rc
= __qeth_do_run_thread(card
, thread
)) >= 0);
972 qeth_recover(void *ptr
)
974 struct qeth_card
*card
;
977 card
= (struct qeth_card
*) ptr
;
978 daemonize("qeth_recover");
979 QETH_DBF_TEXT(trace
,2,"recover1");
980 QETH_DBF_HEX(trace
, 2, &card
, sizeof(void *));
981 if (!qeth_do_run_thread(card
, QETH_RECOVER_THREAD
))
983 QETH_DBF_TEXT(trace
,2,"recover2");
984 PRINT_WARN("Recovery of device %s started ...\n",
986 card
->use_hard_stop
= 1;
987 __qeth_set_offline(card
->gdev
,1);
988 rc
= __qeth_set_online(card
->gdev
,1);
990 PRINT_INFO("Device %s successfully recovered!\n",
993 PRINT_INFO("Device %s could not be recovered!\n",
995 /* don't run another scheduled recovery */
996 qeth_clear_thread_start_bit(card
, QETH_RECOVER_THREAD
);
997 qeth_clear_thread_running_bit(card
, QETH_RECOVER_THREAD
);
1002 qeth_schedule_recovery(struct qeth_card
*card
)
1004 QETH_DBF_TEXT(trace
,2,"startrec");
1005 if (qeth_set_thread_start_bit(card
, QETH_RECOVER_THREAD
) == 0)
1006 schedule_work(&card
->kernel_thread_starter
);
1010 qeth_do_start_thread(struct qeth_card
*card
, unsigned long thread
)
1012 unsigned long flags
;
1015 spin_lock_irqsave(&card
->thread_mask_lock
, flags
);
1016 QETH_DBF_TEXT_(trace
, 4, " %02x%02x%02x",
1017 (u8
) card
->thread_start_mask
,
1018 (u8
) card
->thread_allowed_mask
,
1019 (u8
) card
->thread_running_mask
);
1020 rc
= (card
->thread_start_mask
& thread
);
1021 spin_unlock_irqrestore(&card
->thread_mask_lock
, flags
);
1026 qeth_start_kernel_thread(struct work_struct
*work
)
1028 struct qeth_card
*card
= container_of(work
, struct qeth_card
, kernel_thread_starter
);
1029 QETH_DBF_TEXT(trace
, 2, "strthrd");
1031 if (card
->read
.state
!= CH_STATE_UP
&&
1032 card
->write
.state
!= CH_STATE_UP
)
1034 if (qeth_do_start_thread(card
, QETH_RECOVER_THREAD
))
1035 kernel_thread(qeth_recover
, (void *) card
, SIGCHLD
);
1040 qeth_set_intial_options(struct qeth_card
*card
)
1042 card
->options
.route4
.type
= NO_ROUTER
;
1043 #ifdef CONFIG_QETH_IPV6
1044 card
->options
.route6
.type
= NO_ROUTER
;
1045 #endif /* QETH_IPV6 */
1046 card
->options
.checksum_type
= QETH_CHECKSUM_DEFAULT
;
1047 card
->options
.broadcast_mode
= QETH_TR_BROADCAST_ALLRINGS
;
1048 card
->options
.macaddr_mode
= QETH_TR_MACADDR_NONCANONICAL
;
1049 card
->options
.fake_broadcast
= 0;
1050 card
->options
.add_hhlen
= DEFAULT_ADD_HHLEN
;
1051 card
->options
.fake_ll
= 0;
1052 if (card
->info
.type
== QETH_CARD_TYPE_OSN
)
1053 card
->options
.layer2
= 1;
1055 card
->options
.layer2
= 0;
1056 card
->options
.performance_stats
= 0;
1060 * initialize channels ,card and all state machines
1063 qeth_setup_card(struct qeth_card
*card
)
1066 QETH_DBF_TEXT(setup
, 2, "setupcrd");
1067 QETH_DBF_HEX(setup
, 2, &card
, sizeof(void *));
1069 card
->read
.state
= CH_STATE_DOWN
;
1070 card
->write
.state
= CH_STATE_DOWN
;
1071 card
->data
.state
= CH_STATE_DOWN
;
1072 card
->state
= CARD_STATE_DOWN
;
1073 card
->lan_online
= 0;
1074 card
->use_hard_stop
= 0;
1076 #ifdef CONFIG_QETH_VLAN
1077 spin_lock_init(&card
->vlanlock
);
1078 card
->vlangrp
= NULL
;
1080 spin_lock_init(&card
->lock
);
1081 spin_lock_init(&card
->ip_lock
);
1082 spin_lock_init(&card
->thread_mask_lock
);
1083 card
->thread_start_mask
= 0;
1084 card
->thread_allowed_mask
= 0;
1085 card
->thread_running_mask
= 0;
1086 INIT_WORK(&card
->kernel_thread_starter
, qeth_start_kernel_thread
);
1087 INIT_LIST_HEAD(&card
->ip_list
);
1088 card
->ip_tbd_list
= kmalloc(sizeof(struct list_head
), GFP_KERNEL
);
1089 if (!card
->ip_tbd_list
) {
1090 QETH_DBF_TEXT(setup
, 0, "iptbdnom");
1093 INIT_LIST_HEAD(card
->ip_tbd_list
);
1094 INIT_LIST_HEAD(&card
->cmd_waiter_list
);
1095 init_waitqueue_head(&card
->wait_q
);
1096 /* intial options */
1097 qeth_set_intial_options(card
);
1098 /* IP address takeover */
1099 INIT_LIST_HEAD(&card
->ipato
.entries
);
1100 card
->ipato
.enabled
= 0;
1101 card
->ipato
.invert4
= 0;
1102 card
->ipato
.invert6
= 0;
1103 /* init QDIO stuff */
1104 qeth_init_qdio_info(card
);
1109 is_1920_device (struct qeth_card
*card
)
1111 int single_queue
= 0;
1112 struct ccw_device
*ccwdev
;
1113 struct channelPath_dsc
{
1124 QETH_DBF_TEXT(setup
, 2, "chk_1920");
1126 ccwdev
= card
->data
.ccwdev
;
1127 chp_dsc
= (struct channelPath_dsc
*)ccw_device_get_chp_desc(ccwdev
, 0);
1128 if (chp_dsc
!= NULL
) {
1129 /* CHPP field bit 6 == 1 -> single queue */
1130 single_queue
= ((chp_dsc
->chpp
& 0x02) == 0x02);
1133 QETH_DBF_TEXT_(setup
, 2, "rc:%x", single_queue
);
1134 return single_queue
;
1138 qeth_determine_card_type(struct qeth_card
*card
)
1142 QETH_DBF_TEXT(setup
, 2, "detcdtyp");
1144 card
->qdio
.do_prio_queueing
= QETH_PRIOQ_DEFAULT
;
1145 card
->qdio
.default_out_queue
= QETH_DEFAULT_QUEUE
;
1146 while (known_devices
[i
][4]) {
1147 if ((CARD_RDEV(card
)->id
.dev_type
== known_devices
[i
][2]) &&
1148 (CARD_RDEV(card
)->id
.dev_model
== known_devices
[i
][3])) {
1149 card
->info
.type
= known_devices
[i
][4];
1150 card
->qdio
.no_out_queues
= known_devices
[i
][8];
1151 card
->info
.is_multicast_different
= known_devices
[i
][9];
1152 if (is_1920_device(card
)) {
1153 PRINT_INFO("Priority Queueing not able "
1154 "due to hardware limitations!\n");
1155 card
->qdio
.no_out_queues
= 1;
1156 card
->qdio
.default_out_queue
= 0;
1162 card
->info
.type
= QETH_CARD_TYPE_UNKNOWN
;
1163 PRINT_ERR("unknown card type on device %s\n", CARD_BUS_ID(card
));
1168 qeth_probe_device(struct ccwgroup_device
*gdev
)
1170 struct qeth_card
*card
;
1172 unsigned long flags
;
1175 QETH_DBF_TEXT(setup
, 2, "probedev");
1178 if (!get_device(dev
))
1181 QETH_DBF_TEXT_(setup
, 2, "%s", gdev
->dev
.bus_id
);
1183 card
= qeth_alloc_card();
1186 QETH_DBF_TEXT_(setup
, 2, "1err%d", -ENOMEM
);
1189 card
->read
.ccwdev
= gdev
->cdev
[0];
1190 card
->write
.ccwdev
= gdev
->cdev
[1];
1191 card
->data
.ccwdev
= gdev
->cdev
[2];
1192 gdev
->dev
.driver_data
= card
;
1194 gdev
->cdev
[0]->handler
= qeth_irq
;
1195 gdev
->cdev
[1]->handler
= qeth_irq
;
1196 gdev
->cdev
[2]->handler
= qeth_irq
;
1198 if ((rc
= qeth_determine_card_type(card
))){
1199 PRINT_WARN("%s: not a valid card type\n", __func__
);
1200 QETH_DBF_TEXT_(setup
, 2, "3err%d", rc
);
1202 qeth_free_card(card
);
1205 if ((rc
= qeth_setup_card(card
))){
1206 QETH_DBF_TEXT_(setup
, 2, "2err%d", rc
);
1208 qeth_free_card(card
);
1211 rc
= qeth_create_device_attributes(dev
);
1214 qeth_free_card(card
);
1217 /* insert into our internal list */
1218 write_lock_irqsave(&qeth_card_list
.rwlock
, flags
);
1219 list_add_tail(&card
->list
, &qeth_card_list
.list
);
1220 write_unlock_irqrestore(&qeth_card_list
.rwlock
, flags
);
1225 static int qeth_read_conf_data(struct qeth_card
*card
, void **buffer
,
1231 struct qeth_channel
*channel
= &card
->data
;
1232 unsigned long flags
;
1235 * scan for RCD command in extended SenseID data
1237 ciw
= ccw_device_get_ciw(channel
->ccwdev
, CIW_TYPE_RCD
);
1238 if (!ciw
|| ciw
->cmd
== 0)
1240 rcd_buf
= kzalloc(ciw
->count
, GFP_KERNEL
| GFP_DMA
);
1244 channel
->ccw
.cmd_code
= ciw
->cmd
;
1245 channel
->ccw
.cda
= (__u32
) __pa (rcd_buf
);
1246 channel
->ccw
.count
= ciw
->count
;
1247 channel
->ccw
.flags
= CCW_FLAG_SLI
;
1248 channel
->state
= CH_STATE_RCD
;
1249 spin_lock_irqsave(get_ccwdev_lock(channel
->ccwdev
), flags
);
1250 ret
= ccw_device_start_timeout(channel
->ccwdev
, &channel
->ccw
,
1251 QETH_RCD_PARM
, LPM_ANYPATH
, 0,
1253 spin_unlock_irqrestore(get_ccwdev_lock(channel
->ccwdev
), flags
);
1255 wait_event(card
->wait_q
,
1256 (channel
->state
== CH_STATE_RCD_DONE
||
1257 channel
->state
== CH_STATE_DOWN
));
1258 if (channel
->state
== CH_STATE_DOWN
)
1261 channel
->state
= CH_STATE_DOWN
;
1267 *length
= ciw
->count
;
1274 qeth_get_unitaddr(struct qeth_card
*card
)
1280 QETH_DBF_TEXT(setup
, 2, "getunit");
1281 rc
= qeth_read_conf_data(card
, (void **) &prcd
, &length
);
1283 PRINT_ERR("qeth_read_conf_data for device %s returned %i\n",
1284 CARD_DDEV_ID(card
), rc
);
1287 card
->info
.chpid
= prcd
[30];
1288 card
->info
.unit_addr2
= prcd
[31];
1289 card
->info
.cula
= prcd
[63];
1290 card
->info
.guestlan
= ((prcd
[0x10] == _ascebc
['V']) &&
1291 (prcd
[0x11] == _ascebc
['M']));
1297 qeth_init_tokens(struct qeth_card
*card
)
1299 card
->token
.issuer_rm_w
= 0x00010103UL
;
1300 card
->token
.cm_filter_w
= 0x00010108UL
;
1301 card
->token
.cm_connection_w
= 0x0001010aUL
;
1302 card
->token
.ulp_filter_w
= 0x0001010bUL
;
1303 card
->token
.ulp_connection_w
= 0x0001010dUL
;
1307 raw_devno_from_bus_id(char *id
)
1309 id
+= (strlen(id
) - 4);
1310 return (__u16
) simple_strtoul(id
, &id
, 16);
1316 qeth_setup_ccw(struct qeth_channel
*channel
,unsigned char *iob
, __u32 len
)
1318 struct qeth_card
*card
;
1320 QETH_DBF_TEXT(trace
, 4, "setupccw");
1321 card
= CARD_FROM_CDEV(channel
->ccwdev
);
1322 if (channel
== &card
->read
)
1323 memcpy(&channel
->ccw
, READ_CCW
, sizeof(struct ccw1
));
1325 memcpy(&channel
->ccw
, WRITE_CCW
, sizeof(struct ccw1
));
1326 channel
->ccw
.count
= len
;
1327 channel
->ccw
.cda
= (__u32
) __pa(iob
);
1331 * get free buffer for ccws (IDX activation, lancmds,ipassists...)
1333 static struct qeth_cmd_buffer
*
1334 __qeth_get_buffer(struct qeth_channel
*channel
)
1338 QETH_DBF_TEXT(trace
, 6, "getbuff");
1339 index
= channel
->io_buf_no
;
1341 if (channel
->iob
[index
].state
== BUF_STATE_FREE
) {
1342 channel
->iob
[index
].state
= BUF_STATE_LOCKED
;
1343 channel
->io_buf_no
= (channel
->io_buf_no
+ 1) %
1345 memset(channel
->iob
[index
].data
, 0, QETH_BUFSIZE
);
1346 return channel
->iob
+ index
;
1348 index
= (index
+ 1) % QETH_CMD_BUFFER_NO
;
1349 } while(index
!= channel
->io_buf_no
);
1355 * release command buffer
1358 qeth_release_buffer(struct qeth_channel
*channel
, struct qeth_cmd_buffer
*iob
)
1360 unsigned long flags
;
1362 QETH_DBF_TEXT(trace
, 6, "relbuff");
1363 spin_lock_irqsave(&channel
->iob_lock
, flags
);
1364 memset(iob
->data
, 0, QETH_BUFSIZE
);
1365 iob
->state
= BUF_STATE_FREE
;
1366 iob
->callback
= qeth_send_control_data_cb
;
1368 spin_unlock_irqrestore(&channel
->iob_lock
, flags
);
1371 static struct qeth_cmd_buffer
*
1372 qeth_get_buffer(struct qeth_channel
*channel
)
1374 struct qeth_cmd_buffer
*buffer
= NULL
;
1375 unsigned long flags
;
1377 spin_lock_irqsave(&channel
->iob_lock
, flags
);
1378 buffer
= __qeth_get_buffer(channel
);
1379 spin_unlock_irqrestore(&channel
->iob_lock
, flags
);
1383 static struct qeth_cmd_buffer
*
1384 qeth_wait_for_buffer(struct qeth_channel
*channel
)
1386 struct qeth_cmd_buffer
*buffer
;
1387 wait_event(channel
->wait_q
,
1388 ((buffer
= qeth_get_buffer(channel
)) != NULL
));
1393 qeth_clear_cmd_buffers(struct qeth_channel
*channel
)
1397 for (cnt
=0; cnt
< QETH_CMD_BUFFER_NO
; cnt
++)
1398 qeth_release_buffer(channel
,&channel
->iob
[cnt
]);
1399 channel
->buf_no
= 0;
1400 channel
->io_buf_no
= 0;
1404 * start IDX for read and write channel
1407 qeth_idx_activate_get_answer(struct qeth_channel
*channel
,
1408 void (*idx_reply_cb
)(struct qeth_channel
*,
1409 struct qeth_cmd_buffer
*))
1411 struct qeth_cmd_buffer
*iob
;
1412 unsigned long flags
;
1414 struct qeth_card
*card
;
1416 QETH_DBF_TEXT(setup
, 2, "idxanswr");
1417 card
= CARD_FROM_CDEV(channel
->ccwdev
);
1418 iob
= qeth_get_buffer(channel
);
1419 iob
->callback
= idx_reply_cb
;
1420 memcpy(&channel
->ccw
, READ_CCW
, sizeof(struct ccw1
));
1421 channel
->ccw
.count
= QETH_BUFSIZE
;
1422 channel
->ccw
.cda
= (__u32
) __pa(iob
->data
);
1424 wait_event(card
->wait_q
,
1425 atomic_cmpxchg(&channel
->irq_pending
, 0, 1) == 0);
1426 QETH_DBF_TEXT(setup
, 6, "noirqpnd");
1427 spin_lock_irqsave(get_ccwdev_lock(channel
->ccwdev
), flags
);
1428 rc
= ccw_device_start(channel
->ccwdev
,
1429 &channel
->ccw
,(addr_t
) iob
, 0, 0);
1430 spin_unlock_irqrestore(get_ccwdev_lock(channel
->ccwdev
), flags
);
1433 PRINT_ERR("qeth: Error2 in activating channel rc=%d\n",rc
);
1434 QETH_DBF_TEXT_(setup
, 2, "2err%d", rc
);
1435 atomic_set(&channel
->irq_pending
, 0);
1436 wake_up(&card
->wait_q
);
1439 rc
= wait_event_interruptible_timeout(card
->wait_q
,
1440 channel
->state
== CH_STATE_UP
, QETH_TIMEOUT
);
1441 if (rc
== -ERESTARTSYS
)
1443 if (channel
->state
!= CH_STATE_UP
){
1445 QETH_DBF_TEXT_(setup
, 2, "3err%d", rc
);
1446 qeth_clear_cmd_buffers(channel
);
1453 qeth_idx_activate_channel(struct qeth_channel
*channel
,
1454 void (*idx_reply_cb
)(struct qeth_channel
*,
1455 struct qeth_cmd_buffer
*))
1457 struct qeth_card
*card
;
1458 struct qeth_cmd_buffer
*iob
;
1459 unsigned long flags
;
1463 card
= CARD_FROM_CDEV(channel
->ccwdev
);
1465 QETH_DBF_TEXT(setup
, 2, "idxactch");
1467 iob
= qeth_get_buffer(channel
);
1468 iob
->callback
= idx_reply_cb
;
1469 memcpy(&channel
->ccw
, WRITE_CCW
, sizeof(struct ccw1
));
1470 channel
->ccw
.count
= IDX_ACTIVATE_SIZE
;
1471 channel
->ccw
.cda
= (__u32
) __pa(iob
->data
);
1472 if (channel
== &card
->write
) {
1473 memcpy(iob
->data
, IDX_ACTIVATE_WRITE
, IDX_ACTIVATE_SIZE
);
1474 memcpy(QETH_TRANSPORT_HEADER_SEQ_NO(iob
->data
),
1475 &card
->seqno
.trans_hdr
, QETH_SEQ_NO_LENGTH
);
1476 card
->seqno
.trans_hdr
++;
1478 memcpy(iob
->data
, IDX_ACTIVATE_READ
, IDX_ACTIVATE_SIZE
);
1479 memcpy(QETH_TRANSPORT_HEADER_SEQ_NO(iob
->data
),
1480 &card
->seqno
.trans_hdr
, QETH_SEQ_NO_LENGTH
);
1482 memcpy(QETH_IDX_ACT_ISSUER_RM_TOKEN(iob
->data
),
1483 &card
->token
.issuer_rm_w
,QETH_MPC_TOKEN_LENGTH
);
1484 memcpy(QETH_IDX_ACT_FUNC_LEVEL(iob
->data
),
1485 &card
->info
.func_level
,sizeof(__u16
));
1486 temp
= raw_devno_from_bus_id(CARD_DDEV_ID(card
));
1487 memcpy(QETH_IDX_ACT_QDIO_DEV_CUA(iob
->data
), &temp
, 2);
1488 temp
= (card
->info
.cula
<< 8) + card
->info
.unit_addr2
;
1489 memcpy(QETH_IDX_ACT_QDIO_DEV_REALADDR(iob
->data
), &temp
, 2);
1491 wait_event(card
->wait_q
,
1492 atomic_cmpxchg(&channel
->irq_pending
, 0, 1) == 0);
1493 QETH_DBF_TEXT(setup
, 6, "noirqpnd");
1494 spin_lock_irqsave(get_ccwdev_lock(channel
->ccwdev
), flags
);
1495 rc
= ccw_device_start(channel
->ccwdev
,
1496 &channel
->ccw
,(addr_t
) iob
, 0, 0);
1497 spin_unlock_irqrestore(get_ccwdev_lock(channel
->ccwdev
), flags
);
1500 PRINT_ERR("qeth: Error1 in activating channel. rc=%d\n",rc
);
1501 QETH_DBF_TEXT_(setup
, 2, "1err%d", rc
);
1502 atomic_set(&channel
->irq_pending
, 0);
1503 wake_up(&card
->wait_q
);
1506 rc
= wait_event_interruptible_timeout(card
->wait_q
,
1507 channel
->state
== CH_STATE_ACTIVATING
, QETH_TIMEOUT
);
1508 if (rc
== -ERESTARTSYS
)
1510 if (channel
->state
!= CH_STATE_ACTIVATING
) {
1511 PRINT_WARN("qeth: IDX activate timed out!\n");
1512 QETH_DBF_TEXT_(setup
, 2, "2err%d", -ETIME
);
1513 qeth_clear_cmd_buffers(channel
);
1516 return qeth_idx_activate_get_answer(channel
,idx_reply_cb
);
1520 qeth_peer_func_level(int level
)
1522 if ((level
& 0xff) == 8)
1523 return (level
& 0xff) + 0x400;
1524 if (((level
>> 8) & 3) == 1)
1525 return (level
& 0xff) + 0x200;
1530 qeth_idx_write_cb(struct qeth_channel
*channel
, struct qeth_cmd_buffer
*iob
)
1532 struct qeth_card
*card
;
1535 QETH_DBF_TEXT(setup
,2, "idxwrcb");
1537 if (channel
->state
== CH_STATE_DOWN
) {
1538 channel
->state
= CH_STATE_ACTIVATING
;
1541 card
= CARD_FROM_CDEV(channel
->ccwdev
);
1543 if (!(QETH_IS_IDX_ACT_POS_REPLY(iob
->data
))) {
1544 PRINT_ERR("IDX_ACTIVATE on write channel device %s: negative "
1545 "reply\n", CARD_WDEV_ID(card
));
1548 memcpy(&temp
, QETH_IDX_ACT_FUNC_LEVEL(iob
->data
), 2);
1549 if ((temp
& ~0x0100) != qeth_peer_func_level(card
->info
.func_level
)) {
1550 PRINT_WARN("IDX_ACTIVATE on write channel device %s: "
1551 "function level mismatch "
1552 "(sent: 0x%x, received: 0x%x)\n",
1553 CARD_WDEV_ID(card
), card
->info
.func_level
, temp
);
1556 channel
->state
= CH_STATE_UP
;
1558 qeth_release_buffer(channel
, iob
);
1562 qeth_check_idx_response(unsigned char *buffer
)
1567 QETH_DBF_HEX(control
, 2, buffer
, QETH_DBF_CONTROL_LEN
);
1568 if ((buffer
[2] & 0xc0) == 0xc0) {
1569 PRINT_WARN("received an IDX TERMINATE "
1570 "with cause code 0x%02x%s\n",
1572 ((buffer
[4] == 0x22) ?
1573 " -- try another portname" : ""));
1574 QETH_DBF_TEXT(trace
, 2, "ckidxres");
1575 QETH_DBF_TEXT(trace
, 2, " idxterm");
1576 QETH_DBF_TEXT_(trace
, 2, " rc%d", -EIO
);
1583 qeth_idx_read_cb(struct qeth_channel
*channel
, struct qeth_cmd_buffer
*iob
)
1585 struct qeth_card
*card
;
1588 QETH_DBF_TEXT(setup
, 2, "idxrdcb");
1589 if (channel
->state
== CH_STATE_DOWN
) {
1590 channel
->state
= CH_STATE_ACTIVATING
;
1594 card
= CARD_FROM_CDEV(channel
->ccwdev
);
1595 if (qeth_check_idx_response(iob
->data
)) {
1598 if (!(QETH_IS_IDX_ACT_POS_REPLY(iob
->data
))) {
1599 PRINT_ERR("IDX_ACTIVATE on read channel device %s: negative "
1600 "reply\n", CARD_RDEV_ID(card
));
1605 * temporary fix for microcode bug
1606 * to revert it,replace OR by AND
1608 if ( (!QETH_IDX_NO_PORTNAME_REQUIRED(iob
->data
)) ||
1609 (card
->info
.type
== QETH_CARD_TYPE_OSAE
) )
1610 card
->info
.portname_required
= 1;
1612 memcpy(&temp
, QETH_IDX_ACT_FUNC_LEVEL(iob
->data
), 2);
1613 if (temp
!= qeth_peer_func_level(card
->info
.func_level
)) {
1614 PRINT_WARN("IDX_ACTIVATE on read channel device %s: function "
1615 "level mismatch (sent: 0x%x, received: 0x%x)\n",
1616 CARD_RDEV_ID(card
), card
->info
.func_level
, temp
);
1619 memcpy(&card
->token
.issuer_rm_r
,
1620 QETH_IDX_ACT_ISSUER_RM_TOKEN(iob
->data
),
1621 QETH_MPC_TOKEN_LENGTH
);
1622 memcpy(&card
->info
.mcl_level
[0],
1623 QETH_IDX_REPLY_LEVEL(iob
->data
), QETH_MCL_LENGTH
);
1624 channel
->state
= CH_STATE_UP
;
1626 qeth_release_buffer(channel
,iob
);
1630 qeth_issue_next_read(struct qeth_card
*card
)
1633 struct qeth_cmd_buffer
*iob
;
1635 QETH_DBF_TEXT(trace
,5,"issnxrd");
1636 if (card
->read
.state
!= CH_STATE_UP
)
1638 iob
= qeth_get_buffer(&card
->read
);
1640 PRINT_WARN("issue_next_read failed: no iob available!\n");
1643 qeth_setup_ccw(&card
->read
, iob
->data
, QETH_BUFSIZE
);
1644 QETH_DBF_TEXT(trace
, 6, "noirqpnd");
1645 rc
= ccw_device_start(card
->read
.ccwdev
, &card
->read
.ccw
,
1646 (addr_t
) iob
, 0, 0);
1648 PRINT_ERR("Error in starting next read ccw! rc=%i\n", rc
);
1649 atomic_set(&card
->read
.irq_pending
, 0);
1650 qeth_schedule_recovery(card
);
1651 wake_up(&card
->wait_q
);
1656 static struct qeth_reply
*
1657 qeth_alloc_reply(struct qeth_card
*card
)
1659 struct qeth_reply
*reply
;
1661 reply
= kzalloc(sizeof(struct qeth_reply
), GFP_ATOMIC
);
1663 atomic_set(&reply
->refcnt
, 1);
1664 atomic_set(&reply
->received
, 0);
1671 qeth_get_reply(struct qeth_reply
*reply
)
1673 WARN_ON(atomic_read(&reply
->refcnt
) <= 0);
1674 atomic_inc(&reply
->refcnt
);
1678 qeth_put_reply(struct qeth_reply
*reply
)
1680 WARN_ON(atomic_read(&reply
->refcnt
) <= 0);
1681 if (atomic_dec_and_test(&reply
->refcnt
))
1685 static struct qeth_ipa_cmd
*
1686 qeth_check_ipa_data(struct qeth_card
*card
, struct qeth_cmd_buffer
*iob
)
1688 struct qeth_ipa_cmd
*cmd
= NULL
;
1690 QETH_DBF_TEXT(trace
,5,"chkipad");
1691 if (IS_IPA(iob
->data
)){
1692 cmd
= (struct qeth_ipa_cmd
*) PDU_ENCAPSULATION(iob
->data
);
1693 if (IS_IPA_REPLY(cmd
))
1696 switch (cmd
->hdr
.command
) {
1697 case IPA_CMD_STOPLAN
:
1698 PRINT_WARN("Link failure on %s (CHPID 0x%X) - "
1699 "there is a network problem or "
1700 "someone pulled the cable or "
1701 "disabled the port.\n",
1702 QETH_CARD_IFNAME(card
),
1704 card
->lan_online
= 0;
1705 if (card
->dev
&& netif_carrier_ok(card
->dev
))
1706 netif_carrier_off(card
->dev
);
1708 case IPA_CMD_STARTLAN
:
1709 PRINT_INFO("Link reestablished on %s "
1710 "(CHPID 0x%X). Scheduling "
1711 "IP address reset.\n",
1712 QETH_CARD_IFNAME(card
),
1714 netif_carrier_on(card
->dev
);
1715 qeth_schedule_recovery(card
);
1717 case IPA_CMD_MODCCID
:
1719 case IPA_CMD_REGISTER_LOCAL_ADDR
:
1720 QETH_DBF_TEXT(trace
,3, "irla");
1722 case IPA_CMD_UNREGISTER_LOCAL_ADDR
:
1723 QETH_DBF_TEXT(trace
,3, "urla");
1726 PRINT_WARN("Received data is IPA "
1727 "but not a reply!\n");
1736 * wake all waiting ipa commands
1739 qeth_clear_ipacmd_list(struct qeth_card
*card
)
1741 struct qeth_reply
*reply
, *r
;
1742 unsigned long flags
;
1744 QETH_DBF_TEXT(trace
, 4, "clipalst");
1746 spin_lock_irqsave(&card
->lock
, flags
);
1747 list_for_each_entry_safe(reply
, r
, &card
->cmd_waiter_list
, list
) {
1748 qeth_get_reply(reply
);
1750 atomic_inc(&reply
->received
);
1751 list_del_init(&reply
->list
);
1752 wake_up(&reply
->wait_q
);
1753 qeth_put_reply(reply
);
1755 spin_unlock_irqrestore(&card
->lock
, flags
);
1759 qeth_send_control_data_cb(struct qeth_channel
*channel
,
1760 struct qeth_cmd_buffer
*iob
)
1762 struct qeth_card
*card
;
1763 struct qeth_reply
*reply
, *r
;
1764 struct qeth_ipa_cmd
*cmd
;
1765 unsigned long flags
;
1768 QETH_DBF_TEXT(trace
,4,"sndctlcb");
1770 card
= CARD_FROM_CDEV(channel
->ccwdev
);
1771 if (qeth_check_idx_response(iob
->data
)) {
1772 qeth_clear_ipacmd_list(card
);
1773 qeth_schedule_recovery(card
);
1777 cmd
= qeth_check_ipa_data(card
, iob
);
1778 if ((cmd
== NULL
) && (card
->state
!= CARD_STATE_DOWN
))
1780 /*in case of OSN : check if cmd is set */
1781 if (card
->info
.type
== QETH_CARD_TYPE_OSN
&&
1783 cmd
->hdr
.command
!= IPA_CMD_STARTLAN
&&
1784 card
->osn_info
.assist_cb
!= NULL
) {
1785 card
->osn_info
.assist_cb(card
->dev
, cmd
);
1789 spin_lock_irqsave(&card
->lock
, flags
);
1790 list_for_each_entry_safe(reply
, r
, &card
->cmd_waiter_list
, list
) {
1791 if ((reply
->seqno
== QETH_IDX_COMMAND_SEQNO
) ||
1792 ((cmd
) && (reply
->seqno
== cmd
->hdr
.seqno
))) {
1793 qeth_get_reply(reply
);
1794 list_del_init(&reply
->list
);
1795 spin_unlock_irqrestore(&card
->lock
, flags
);
1797 if (reply
->callback
!= NULL
) {
1799 reply
->offset
= (__u16
)((char*)cmd
-
1801 keep_reply
= reply
->callback(card
,
1803 (unsigned long)cmd
);
1805 keep_reply
= reply
->callback(card
,
1807 (unsigned long)iob
);
1810 reply
->rc
= (u16
) cmd
->hdr
.return_code
;
1812 reply
->rc
= iob
->rc
;
1814 spin_lock_irqsave(&card
->lock
, flags
);
1815 list_add_tail(&reply
->list
,
1816 &card
->cmd_waiter_list
);
1817 spin_unlock_irqrestore(&card
->lock
, flags
);
1819 atomic_inc(&reply
->received
);
1820 wake_up(&reply
->wait_q
);
1822 qeth_put_reply(reply
);
1826 spin_unlock_irqrestore(&card
->lock
, flags
);
1828 memcpy(&card
->seqno
.pdu_hdr_ack
,
1829 QETH_PDU_HEADER_SEQ_NO(iob
->data
),
1830 QETH_SEQ_NO_LENGTH
);
1831 qeth_release_buffer(channel
,iob
);
1835 qeth_prepare_control_data(struct qeth_card
*card
, int len
,
1836 struct qeth_cmd_buffer
*iob
)
1838 qeth_setup_ccw(&card
->write
,iob
->data
,len
);
1839 iob
->callback
= qeth_release_buffer
;
1841 memcpy(QETH_TRANSPORT_HEADER_SEQ_NO(iob
->data
),
1842 &card
->seqno
.trans_hdr
, QETH_SEQ_NO_LENGTH
);
1843 card
->seqno
.trans_hdr
++;
1844 memcpy(QETH_PDU_HEADER_SEQ_NO(iob
->data
),
1845 &card
->seqno
.pdu_hdr
, QETH_SEQ_NO_LENGTH
);
1846 card
->seqno
.pdu_hdr
++;
1847 memcpy(QETH_PDU_HEADER_ACK_SEQ_NO(iob
->data
),
1848 &card
->seqno
.pdu_hdr_ack
, QETH_SEQ_NO_LENGTH
);
1849 QETH_DBF_HEX(control
, 2, iob
->data
, QETH_DBF_CONTROL_LEN
);
1853 qeth_send_control_data(struct qeth_card
*card
, int len
,
1854 struct qeth_cmd_buffer
*iob
,
1856 (struct qeth_card
*, struct qeth_reply
*, unsigned long),
1861 unsigned long flags
;
1862 struct qeth_reply
*reply
= NULL
;
1863 unsigned long timeout
;
1865 QETH_DBF_TEXT(trace
, 2, "sendctl");
1867 reply
= qeth_alloc_reply(card
);
1869 PRINT_WARN("Could no alloc qeth_reply!\n");
1872 reply
->callback
= reply_cb
;
1873 reply
->param
= reply_param
;
1874 if (card
->state
== CARD_STATE_DOWN
)
1875 reply
->seqno
= QETH_IDX_COMMAND_SEQNO
;
1877 reply
->seqno
= card
->seqno
.ipa
++;
1878 init_waitqueue_head(&reply
->wait_q
);
1879 spin_lock_irqsave(&card
->lock
, flags
);
1880 list_add_tail(&reply
->list
, &card
->cmd_waiter_list
);
1881 spin_unlock_irqrestore(&card
->lock
, flags
);
1882 QETH_DBF_HEX(control
, 2, iob
->data
, QETH_DBF_CONTROL_LEN
);
1884 while (atomic_cmpxchg(&card
->write
.irq_pending
, 0, 1)) ;
1885 qeth_prepare_control_data(card
, len
, iob
);
1887 if (IS_IPA(iob
->data
))
1888 timeout
= jiffies
+ QETH_IPA_TIMEOUT
;
1890 timeout
= jiffies
+ QETH_TIMEOUT
;
1892 QETH_DBF_TEXT(trace
, 6, "noirqpnd");
1893 spin_lock_irqsave(get_ccwdev_lock(card
->write
.ccwdev
), flags
);
1894 rc
= ccw_device_start(card
->write
.ccwdev
, &card
->write
.ccw
,
1895 (addr_t
) iob
, 0, 0);
1896 spin_unlock_irqrestore(get_ccwdev_lock(card
->write
.ccwdev
), flags
);
1898 PRINT_WARN("qeth_send_control_data: "
1899 "ccw_device_start rc = %i\n", rc
);
1900 QETH_DBF_TEXT_(trace
, 2, " err%d", rc
);
1901 spin_lock_irqsave(&card
->lock
, flags
);
1902 list_del_init(&reply
->list
);
1903 qeth_put_reply(reply
);
1904 spin_unlock_irqrestore(&card
->lock
, flags
);
1905 qeth_release_buffer(iob
->channel
, iob
);
1906 atomic_set(&card
->write
.irq_pending
, 0);
1907 wake_up(&card
->wait_q
);
1910 while (!atomic_read(&reply
->received
)) {
1911 if (time_after(jiffies
, timeout
)) {
1912 spin_lock_irqsave(&reply
->card
->lock
, flags
);
1913 list_del_init(&reply
->list
);
1914 spin_unlock_irqrestore(&reply
->card
->lock
, flags
);
1916 atomic_inc(&reply
->received
);
1917 wake_up(&reply
->wait_q
);
1921 qeth_put_reply(reply
);
1926 qeth_osn_send_control_data(struct qeth_card
*card
, int len
,
1927 struct qeth_cmd_buffer
*iob
)
1929 unsigned long flags
;
1932 QETH_DBF_TEXT(trace
, 5, "osndctrd");
1934 wait_event(card
->wait_q
,
1935 atomic_cmpxchg(&card
->write
.irq_pending
, 0, 1) == 0);
1936 qeth_prepare_control_data(card
, len
, iob
);
1937 QETH_DBF_TEXT(trace
, 6, "osnoirqp");
1938 spin_lock_irqsave(get_ccwdev_lock(card
->write
.ccwdev
), flags
);
1939 rc
= ccw_device_start(card
->write
.ccwdev
, &card
->write
.ccw
,
1940 (addr_t
) iob
, 0, 0);
1941 spin_unlock_irqrestore(get_ccwdev_lock(card
->write
.ccwdev
), flags
);
1943 PRINT_WARN("qeth_osn_send_control_data: "
1944 "ccw_device_start rc = %i\n", rc
);
1945 QETH_DBF_TEXT_(trace
, 2, " err%d", rc
);
1946 qeth_release_buffer(iob
->channel
, iob
);
1947 atomic_set(&card
->write
.irq_pending
, 0);
1948 wake_up(&card
->wait_q
);
1954 qeth_prepare_ipa_cmd(struct qeth_card
*card
, struct qeth_cmd_buffer
*iob
,
1957 memcpy(iob
->data
, IPA_PDU_HEADER
, IPA_PDU_HEADER_SIZE
);
1958 memcpy(QETH_IPA_CMD_PROT_TYPE(iob
->data
),&prot_type
,1);
1959 memcpy(QETH_IPA_CMD_DEST_ADDR(iob
->data
),
1960 &card
->token
.ulp_connection_r
, QETH_MPC_TOKEN_LENGTH
);
1964 qeth_osn_send_ipa_cmd(struct qeth_card
*card
, struct qeth_cmd_buffer
*iob
,
1969 QETH_DBF_TEXT(trace
,4,"osndipa");
1971 qeth_prepare_ipa_cmd(card
, iob
, QETH_PROT_OSN2
);
1972 s1
= (u16
)(IPA_PDU_HEADER_SIZE
+ data_len
);
1974 memcpy(QETH_IPA_PDU_LEN_TOTAL(iob
->data
), &s1
, 2);
1975 memcpy(QETH_IPA_PDU_LEN_PDU1(iob
->data
), &s2
, 2);
1976 memcpy(QETH_IPA_PDU_LEN_PDU2(iob
->data
), &s2
, 2);
1977 memcpy(QETH_IPA_PDU_LEN_PDU3(iob
->data
), &s2
, 2);
1978 return qeth_osn_send_control_data(card
, s1
, iob
);
1982 qeth_send_ipa_cmd(struct qeth_card
*card
, struct qeth_cmd_buffer
*iob
,
1984 (struct qeth_card
*,struct qeth_reply
*, unsigned long),
1990 QETH_DBF_TEXT(trace
,4,"sendipa");
1992 if (card
->options
.layer2
)
1993 if (card
->info
.type
== QETH_CARD_TYPE_OSN
)
1994 prot_type
= QETH_PROT_OSN2
;
1996 prot_type
= QETH_PROT_LAYER2
;
1998 prot_type
= QETH_PROT_TCPIP
;
1999 qeth_prepare_ipa_cmd(card
,iob
,prot_type
);
2000 rc
= qeth_send_control_data(card
, IPA_CMD_LENGTH
, iob
,
2001 reply_cb
, reply_param
);
2007 qeth_cm_enable_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
2010 struct qeth_cmd_buffer
*iob
;
2012 QETH_DBF_TEXT(setup
, 2, "cmenblcb");
2014 iob
= (struct qeth_cmd_buffer
*) data
;
2015 memcpy(&card
->token
.cm_filter_r
,
2016 QETH_CM_ENABLE_RESP_FILTER_TOKEN(iob
->data
),
2017 QETH_MPC_TOKEN_LENGTH
);
2018 QETH_DBF_TEXT_(setup
, 2, " rc%d", iob
->rc
);
2023 qeth_cm_enable(struct qeth_card
*card
)
2026 struct qeth_cmd_buffer
*iob
;
2028 QETH_DBF_TEXT(setup
,2,"cmenable");
2030 iob
= qeth_wait_for_buffer(&card
->write
);
2031 memcpy(iob
->data
, CM_ENABLE
, CM_ENABLE_SIZE
);
2032 memcpy(QETH_CM_ENABLE_ISSUER_RM_TOKEN(iob
->data
),
2033 &card
->token
.issuer_rm_r
, QETH_MPC_TOKEN_LENGTH
);
2034 memcpy(QETH_CM_ENABLE_FILTER_TOKEN(iob
->data
),
2035 &card
->token
.cm_filter_w
, QETH_MPC_TOKEN_LENGTH
);
2037 rc
= qeth_send_control_data(card
, CM_ENABLE_SIZE
, iob
,
2038 qeth_cm_enable_cb
, NULL
);
2043 qeth_cm_setup_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
2047 struct qeth_cmd_buffer
*iob
;
2049 QETH_DBF_TEXT(setup
, 2, "cmsetpcb");
2051 iob
= (struct qeth_cmd_buffer
*) data
;
2052 memcpy(&card
->token
.cm_connection_r
,
2053 QETH_CM_SETUP_RESP_DEST_ADDR(iob
->data
),
2054 QETH_MPC_TOKEN_LENGTH
);
2055 QETH_DBF_TEXT_(setup
, 2, " rc%d", iob
->rc
);
2060 qeth_cm_setup(struct qeth_card
*card
)
2063 struct qeth_cmd_buffer
*iob
;
2065 QETH_DBF_TEXT(setup
,2,"cmsetup");
2067 iob
= qeth_wait_for_buffer(&card
->write
);
2068 memcpy(iob
->data
, CM_SETUP
, CM_SETUP_SIZE
);
2069 memcpy(QETH_CM_SETUP_DEST_ADDR(iob
->data
),
2070 &card
->token
.issuer_rm_r
, QETH_MPC_TOKEN_LENGTH
);
2071 memcpy(QETH_CM_SETUP_CONNECTION_TOKEN(iob
->data
),
2072 &card
->token
.cm_connection_w
, QETH_MPC_TOKEN_LENGTH
);
2073 memcpy(QETH_CM_SETUP_FILTER_TOKEN(iob
->data
),
2074 &card
->token
.cm_filter_r
, QETH_MPC_TOKEN_LENGTH
);
2075 rc
= qeth_send_control_data(card
, CM_SETUP_SIZE
, iob
,
2076 qeth_cm_setup_cb
, NULL
);
2082 qeth_ulp_enable_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
2086 __u16 mtu
, framesize
;
2089 struct qeth_cmd_buffer
*iob
;
2091 QETH_DBF_TEXT(setup
, 2, "ulpenacb");
2093 iob
= (struct qeth_cmd_buffer
*) data
;
2094 memcpy(&card
->token
.ulp_filter_r
,
2095 QETH_ULP_ENABLE_RESP_FILTER_TOKEN(iob
->data
),
2096 QETH_MPC_TOKEN_LENGTH
);
2097 if (qeth_get_mtu_out_of_mpc(card
->info
.type
)) {
2098 memcpy(&framesize
, QETH_ULP_ENABLE_RESP_MAX_MTU(iob
->data
), 2);
2099 mtu
= qeth_get_mtu_outof_framesize(framesize
);
2102 QETH_DBF_TEXT_(setup
, 2, " rc%d", iob
->rc
);
2105 card
->info
.max_mtu
= mtu
;
2106 card
->info
.initial_mtu
= mtu
;
2107 card
->qdio
.in_buf_size
= mtu
+ 2 * PAGE_SIZE
;
2109 card
->info
.initial_mtu
= qeth_get_initial_mtu_for_card(card
);
2110 card
->info
.max_mtu
= qeth_get_max_mtu_for_card(card
->info
.type
);
2111 card
->qdio
.in_buf_size
= QETH_IN_BUF_SIZE_DEFAULT
;
2114 memcpy(&len
, QETH_ULP_ENABLE_RESP_DIFINFO_LEN(iob
->data
), 2);
2115 if (len
>= QETH_MPC_DIFINFO_LEN_INDICATES_LINK_TYPE
) {
2117 QETH_ULP_ENABLE_RESP_LINK_TYPE(iob
->data
), 1);
2118 card
->info
.link_type
= link_type
;
2120 card
->info
.link_type
= 0;
2121 QETH_DBF_TEXT_(setup
, 2, " rc%d", iob
->rc
);
2126 qeth_ulp_enable(struct qeth_card
*card
)
2130 struct qeth_cmd_buffer
*iob
;
2132 /*FIXME: trace view callbacks*/
2133 QETH_DBF_TEXT(setup
,2,"ulpenabl");
2135 iob
= qeth_wait_for_buffer(&card
->write
);
2136 memcpy(iob
->data
, ULP_ENABLE
, ULP_ENABLE_SIZE
);
2138 *(QETH_ULP_ENABLE_LINKNUM(iob
->data
)) =
2139 (__u8
) card
->info
.portno
;
2140 if (card
->options
.layer2
)
2141 if (card
->info
.type
== QETH_CARD_TYPE_OSN
)
2142 prot_type
= QETH_PROT_OSN2
;
2144 prot_type
= QETH_PROT_LAYER2
;
2146 prot_type
= QETH_PROT_TCPIP
;
2148 memcpy(QETH_ULP_ENABLE_PROT_TYPE(iob
->data
),&prot_type
,1);
2149 memcpy(QETH_ULP_ENABLE_DEST_ADDR(iob
->data
),
2150 &card
->token
.cm_connection_r
, QETH_MPC_TOKEN_LENGTH
);
2151 memcpy(QETH_ULP_ENABLE_FILTER_TOKEN(iob
->data
),
2152 &card
->token
.ulp_filter_w
, QETH_MPC_TOKEN_LENGTH
);
2153 memcpy(QETH_ULP_ENABLE_PORTNAME_AND_LL(iob
->data
),
2154 card
->info
.portname
, 9);
2155 rc
= qeth_send_control_data(card
, ULP_ENABLE_SIZE
, iob
,
2156 qeth_ulp_enable_cb
, NULL
);
2162 __raw_devno_from_bus_id(char *id
)
2164 id
+= (strlen(id
) - 4);
2165 return (__u16
) simple_strtoul(id
, &id
, 16);
2169 qeth_ulp_setup_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
2172 struct qeth_cmd_buffer
*iob
;
2174 QETH_DBF_TEXT(setup
, 2, "ulpstpcb");
2176 iob
= (struct qeth_cmd_buffer
*) data
;
2177 memcpy(&card
->token
.ulp_connection_r
,
2178 QETH_ULP_SETUP_RESP_CONNECTION_TOKEN(iob
->data
),
2179 QETH_MPC_TOKEN_LENGTH
);
2180 QETH_DBF_TEXT_(setup
, 2, " rc%d", iob
->rc
);
2185 qeth_ulp_setup(struct qeth_card
*card
)
2189 struct qeth_cmd_buffer
*iob
;
2191 QETH_DBF_TEXT(setup
,2,"ulpsetup");
2193 iob
= qeth_wait_for_buffer(&card
->write
);
2194 memcpy(iob
->data
, ULP_SETUP
, ULP_SETUP_SIZE
);
2196 memcpy(QETH_ULP_SETUP_DEST_ADDR(iob
->data
),
2197 &card
->token
.cm_connection_r
, QETH_MPC_TOKEN_LENGTH
);
2198 memcpy(QETH_ULP_SETUP_CONNECTION_TOKEN(iob
->data
),
2199 &card
->token
.ulp_connection_w
, QETH_MPC_TOKEN_LENGTH
);
2200 memcpy(QETH_ULP_SETUP_FILTER_TOKEN(iob
->data
),
2201 &card
->token
.ulp_filter_r
, QETH_MPC_TOKEN_LENGTH
);
2203 temp
= __raw_devno_from_bus_id(CARD_DDEV_ID(card
));
2204 memcpy(QETH_ULP_SETUP_CUA(iob
->data
), &temp
, 2);
2205 temp
= (card
->info
.cula
<< 8) + card
->info
.unit_addr2
;
2206 memcpy(QETH_ULP_SETUP_REAL_DEVADDR(iob
->data
), &temp
, 2);
2207 rc
= qeth_send_control_data(card
, ULP_SETUP_SIZE
, iob
,
2208 qeth_ulp_setup_cb
, NULL
);
2213 qeth_check_qdio_errors(struct qdio_buffer
*buf
, unsigned int qdio_error
,
2214 unsigned int siga_error
, const char *dbftext
)
2216 if (qdio_error
|| siga_error
) {
2217 QETH_DBF_TEXT(trace
, 2, dbftext
);
2218 QETH_DBF_TEXT(qerr
, 2, dbftext
);
2219 QETH_DBF_TEXT_(qerr
, 2, " F15=%02X",
2220 buf
->element
[15].flags
& 0xff);
2221 QETH_DBF_TEXT_(qerr
, 2, " F14=%02X",
2222 buf
->element
[14].flags
& 0xff);
2223 QETH_DBF_TEXT_(qerr
, 2, " qerr=%X", qdio_error
);
2224 QETH_DBF_TEXT_(qerr
, 2, " serr=%X", siga_error
);
2230 static struct sk_buff
*
2231 qeth_get_skb(unsigned int length
, struct qeth_hdr
*hdr
)
2233 struct sk_buff
* skb
;
2237 if (hdr
->hdr
.osn
.id
== QETH_HEADER_TYPE_OSN
)
2238 add_len
= sizeof(struct qeth_hdr
);
2239 #ifdef CONFIG_QETH_VLAN
2241 add_len
= VLAN_HLEN
;
2243 skb
= dev_alloc_skb(length
+ add_len
);
2245 skb_reserve(skb
, add_len
);
2249 static struct sk_buff
*
2250 qeth_get_next_skb(struct qeth_card
*card
, struct qdio_buffer
*buffer
,
2251 struct qdio_buffer_element
**__element
, int *__offset
,
2252 struct qeth_hdr
**hdr
)
2254 struct qdio_buffer_element
*element
= *__element
;
2255 int offset
= *__offset
;
2256 struct sk_buff
*skb
= NULL
;
2261 QETH_DBF_TEXT(trace
,6,"nextskb");
2262 /* qeth_hdr must not cross element boundaries */
2263 if (element
->length
< offset
+ sizeof(struct qeth_hdr
)){
2264 if (qeth_is_last_sbale(element
))
2268 if (element
->length
< sizeof(struct qeth_hdr
))
2271 *hdr
= element
->addr
+ offset
;
2273 offset
+= sizeof(struct qeth_hdr
);
2274 if (card
->options
.layer2
)
2275 if (card
->info
.type
== QETH_CARD_TYPE_OSN
)
2276 skb_len
= (*hdr
)->hdr
.osn
.pdu_length
;
2278 skb_len
= (*hdr
)->hdr
.l2
.pkt_length
;
2280 skb_len
= (*hdr
)->hdr
.l3
.length
;
2284 if (card
->options
.fake_ll
){
2285 if(card
->dev
->type
== ARPHRD_IEEE802_TR
){
2286 if (!(skb
= qeth_get_skb(skb_len
+QETH_FAKE_LL_LEN_TR
, *hdr
)))
2288 skb_reserve(skb
,QETH_FAKE_LL_LEN_TR
);
2290 if (!(skb
= qeth_get_skb(skb_len
+QETH_FAKE_LL_LEN_ETH
, *hdr
)))
2292 skb_reserve(skb
,QETH_FAKE_LL_LEN_ETH
);
2294 } else if (!(skb
= qeth_get_skb(skb_len
, *hdr
)))
2296 data_ptr
= element
->addr
+ offset
;
2298 data_len
= min(skb_len
, (int)(element
->length
- offset
));
2300 memcpy(skb_put(skb
, data_len
), data_ptr
, data_len
);
2301 skb_len
-= data_len
;
2303 if (qeth_is_last_sbale(element
)){
2304 QETH_DBF_TEXT(trace
,4,"unexeob");
2305 QETH_DBF_TEXT_(trace
,4,"%s",CARD_BUS_ID(card
));
2306 QETH_DBF_TEXT(qerr
,2,"unexeob");
2307 QETH_DBF_TEXT_(qerr
,2,"%s",CARD_BUS_ID(card
));
2308 QETH_DBF_HEX(misc
,4,buffer
,sizeof(*buffer
));
2309 dev_kfree_skb_any(skb
);
2310 card
->stats
.rx_errors
++;
2315 data_ptr
= element
->addr
;
2320 *__element
= element
;
2324 if (net_ratelimit()){
2325 PRINT_WARN("No memory for packet received on %s.\n",
2326 QETH_CARD_IFNAME(card
));
2327 QETH_DBF_TEXT(trace
,2,"noskbmem");
2328 QETH_DBF_TEXT_(trace
,2,"%s",CARD_BUS_ID(card
));
2330 card
->stats
.rx_dropped
++;
2335 qeth_type_trans(struct sk_buff
*skb
, struct net_device
*dev
)
2337 struct qeth_card
*card
;
2340 QETH_DBF_TEXT(trace
,6,"typtrans");
2342 card
= (struct qeth_card
*)dev
->priv
;
2344 if ((card
->info
.link_type
== QETH_LINK_TYPE_HSTR
) ||
2345 (card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
))
2346 return tr_type_trans(skb
,dev
);
2347 #endif /* CONFIG_TR */
2348 skb_reset_mac_header(skb
);
2349 skb_pull(skb
, ETH_HLEN
);
2352 if (*eth
->h_dest
& 1) {
2353 if (memcmp(eth
->h_dest
, dev
->broadcast
, ETH_ALEN
) == 0)
2354 skb
->pkt_type
= PACKET_BROADCAST
;
2356 skb
->pkt_type
= PACKET_MULTICAST
;
2357 } else if (memcmp(eth
->h_dest
, dev
->dev_addr
, ETH_ALEN
))
2358 skb
->pkt_type
= PACKET_OTHERHOST
;
2360 if (ntohs(eth
->h_proto
) >= 1536)
2361 return eth
->h_proto
;
2362 if (*(unsigned short *) (skb
->data
) == 0xFFFF)
2363 return htons(ETH_P_802_3
);
2364 return htons(ETH_P_802_2
);
2368 qeth_rebuild_skb_fake_ll_tr(struct qeth_card
*card
, struct sk_buff
*skb
,
2369 struct qeth_hdr
*hdr
)
2371 struct trh_hdr
*fake_hdr
;
2372 struct trllc
*fake_llc
;
2373 struct iphdr
*ip_hdr
;
2375 QETH_DBF_TEXT(trace
,5,"skbfktr");
2376 skb_set_mac_header(skb
, -QETH_FAKE_LL_LEN_TR
);
2377 /* this is a fake ethernet header */
2378 fake_hdr
= tr_hdr(skb
);
2380 /* the destination MAC address */
2381 switch (skb
->pkt_type
){
2382 case PACKET_MULTICAST
:
2383 switch (skb
->protocol
){
2384 #ifdef CONFIG_QETH_IPV6
2385 case __constant_htons(ETH_P_IPV6
):
2386 ndisc_mc_map((struct in6_addr
*)
2387 skb
->data
+ QETH_FAKE_LL_V6_ADDR_POS
,
2388 fake_hdr
->daddr
, card
->dev
, 0);
2390 #endif /* CONFIG_QETH_IPV6 */
2391 case __constant_htons(ETH_P_IP
):
2392 ip_hdr
= (struct iphdr
*)skb
->data
;
2393 ip_tr_mc_map(ip_hdr
->daddr
, fake_hdr
->daddr
);
2396 memcpy(fake_hdr
->daddr
, card
->dev
->dev_addr
, TR_ALEN
);
2399 case PACKET_BROADCAST
:
2400 memset(fake_hdr
->daddr
, 0xff, TR_ALEN
);
2403 memcpy(fake_hdr
->daddr
, card
->dev
->dev_addr
, TR_ALEN
);
2405 /* the source MAC address */
2406 if (hdr
->hdr
.l3
.ext_flags
& QETH_HDR_EXT_SRC_MAC_ADDR
)
2407 memcpy(fake_hdr
->saddr
, &hdr
->hdr
.l3
.dest_addr
[2], TR_ALEN
);
2409 memset(fake_hdr
->saddr
, 0, TR_ALEN
);
2411 fake_llc
= (struct trllc
*)&(fake_hdr
->rcf
);
2412 fake_llc
->dsap
= EXTENDED_SAP
;
2413 fake_llc
->ssap
= EXTENDED_SAP
;
2414 fake_llc
->llc
= UI_CMD
;
2415 fake_llc
->protid
[0] = 0;
2416 fake_llc
->protid
[1] = 0;
2417 fake_llc
->protid
[2] = 0;
2418 fake_llc
->ethertype
= ETH_P_IP
;
2422 qeth_rebuild_skb_fake_ll_eth(struct qeth_card
*card
, struct sk_buff
*skb
,
2423 struct qeth_hdr
*hdr
)
2425 struct ethhdr
*fake_hdr
;
2426 struct iphdr
*ip_hdr
;
2428 QETH_DBF_TEXT(trace
,5,"skbfketh");
2429 skb_set_mac_header(skb
, -QETH_FAKE_LL_LEN_ETH
);
2430 /* this is a fake ethernet header */
2431 fake_hdr
= eth_hdr(skb
);
2433 /* the destination MAC address */
2434 switch (skb
->pkt_type
){
2435 case PACKET_MULTICAST
:
2436 switch (skb
->protocol
){
2437 #ifdef CONFIG_QETH_IPV6
2438 case __constant_htons(ETH_P_IPV6
):
2439 ndisc_mc_map((struct in6_addr
*)
2440 skb
->data
+ QETH_FAKE_LL_V6_ADDR_POS
,
2441 fake_hdr
->h_dest
, card
->dev
, 0);
2443 #endif /* CONFIG_QETH_IPV6 */
2444 case __constant_htons(ETH_P_IP
):
2445 ip_hdr
= (struct iphdr
*)skb
->data
;
2446 ip_eth_mc_map(ip_hdr
->daddr
, fake_hdr
->h_dest
);
2449 memcpy(fake_hdr
->h_dest
, card
->dev
->dev_addr
, ETH_ALEN
);
2452 case PACKET_BROADCAST
:
2453 memset(fake_hdr
->h_dest
, 0xff, ETH_ALEN
);
2456 memcpy(fake_hdr
->h_dest
, card
->dev
->dev_addr
, ETH_ALEN
);
2458 /* the source MAC address */
2459 if (hdr
->hdr
.l3
.ext_flags
& QETH_HDR_EXT_SRC_MAC_ADDR
)
2460 memcpy(fake_hdr
->h_source
, &hdr
->hdr
.l3
.dest_addr
[2], ETH_ALEN
);
2462 memset(fake_hdr
->h_source
, 0, ETH_ALEN
);
2464 fake_hdr
->h_proto
= skb
->protocol
;
2468 qeth_rebuild_skb_fake_ll(struct qeth_card
*card
, struct sk_buff
*skb
,
2469 struct qeth_hdr
*hdr
)
2471 if (card
->dev
->type
== ARPHRD_IEEE802_TR
)
2472 qeth_rebuild_skb_fake_ll_tr(card
, skb
, hdr
);
2474 qeth_rebuild_skb_fake_ll_eth(card
, skb
, hdr
);
2478 qeth_layer2_rebuild_skb(struct qeth_card
*card
, struct sk_buff
*skb
,
2479 struct qeth_hdr
*hdr
)
2481 skb
->pkt_type
= PACKET_HOST
;
2482 skb
->protocol
= qeth_type_trans(skb
, skb
->dev
);
2483 if (card
->options
.checksum_type
== NO_CHECKSUMMING
)
2484 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
2486 skb
->ip_summed
= CHECKSUM_NONE
;
2487 *((__u32
*)skb
->cb
) = ++card
->seqno
.pkt_seqno
;
2491 qeth_rebuild_skb(struct qeth_card
*card
, struct sk_buff
*skb
,
2492 struct qeth_hdr
*hdr
)
2494 unsigned short vlan_id
= 0;
2495 #ifdef CONFIG_QETH_IPV6
2496 if (hdr
->hdr
.l3
.flags
& QETH_HDR_PASSTHRU
) {
2497 skb
->pkt_type
= PACKET_HOST
;
2498 skb
->protocol
= qeth_type_trans(skb
, card
->dev
);
2501 #endif /* CONFIG_QETH_IPV6 */
2502 skb
->protocol
= htons((hdr
->hdr
.l3
.flags
& QETH_HDR_IPV6
)? ETH_P_IPV6
:
2504 switch (hdr
->hdr
.l3
.flags
& QETH_HDR_CAST_MASK
){
2505 case QETH_CAST_UNICAST
:
2506 skb
->pkt_type
= PACKET_HOST
;
2508 case QETH_CAST_MULTICAST
:
2509 skb
->pkt_type
= PACKET_MULTICAST
;
2510 card
->stats
.multicast
++;
2512 case QETH_CAST_BROADCAST
:
2513 skb
->pkt_type
= PACKET_BROADCAST
;
2514 card
->stats
.multicast
++;
2516 case QETH_CAST_ANYCAST
:
2517 case QETH_CAST_NOCAST
:
2519 skb
->pkt_type
= PACKET_HOST
;
2522 if (hdr
->hdr
.l3
.ext_flags
&
2523 (QETH_HDR_EXT_VLAN_FRAME
| QETH_HDR_EXT_INCLUDE_VLAN_TAG
)) {
2524 vlan_id
= (hdr
->hdr
.l3
.ext_flags
& QETH_HDR_EXT_VLAN_FRAME
)?
2525 hdr
->hdr
.l3
.vlan_id
: *((u16
*)&hdr
->hdr
.l3
.dest_addr
[12]);
2528 if (card
->options
.fake_ll
)
2529 qeth_rebuild_skb_fake_ll(card
, skb
, hdr
);
2531 skb_reset_mac_header(skb
);
2532 skb
->ip_summed
= card
->options
.checksum_type
;
2533 if (card
->options
.checksum_type
== HW_CHECKSUMMING
){
2534 if ( (hdr
->hdr
.l3
.ext_flags
&
2535 (QETH_HDR_EXT_CSUM_HDR_REQ
|
2536 QETH_HDR_EXT_CSUM_TRANSP_REQ
)) ==
2537 (QETH_HDR_EXT_CSUM_HDR_REQ
|
2538 QETH_HDR_EXT_CSUM_TRANSP_REQ
) )
2539 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
2541 skb
->ip_summed
= SW_CHECKSUMMING
;
2547 qeth_process_inbound_buffer(struct qeth_card
*card
,
2548 struct qeth_qdio_buffer
*buf
, int index
)
2550 struct qdio_buffer_element
*element
;
2551 struct sk_buff
*skb
;
2552 struct qeth_hdr
*hdr
;
2557 /* get first element of current buffer */
2558 element
= (struct qdio_buffer_element
*)&buf
->buffer
->element
[0];
2560 if (card
->options
.performance_stats
)
2561 card
->perf_stats
.bufs_rec
++;
2562 while((skb
= qeth_get_next_skb(card
, buf
->buffer
, &element
,
2564 skb
->dev
= card
->dev
;
2565 if (hdr
->hdr
.l2
.id
== QETH_HEADER_TYPE_LAYER2
)
2566 qeth_layer2_rebuild_skb(card
, skb
, hdr
);
2567 else if (hdr
->hdr
.l3
.id
== QETH_HEADER_TYPE_LAYER3
)
2568 vlan_tag
= qeth_rebuild_skb(card
, skb
, hdr
);
2569 else { /*in case of OSN*/
2570 skb_push(skb
, sizeof(struct qeth_hdr
));
2571 skb_copy_to_linear_data(skb
, hdr
,
2572 sizeof(struct qeth_hdr
));
2574 /* is device UP ? */
2575 if (!(card
->dev
->flags
& IFF_UP
)){
2576 dev_kfree_skb_any(skb
);
2579 if (card
->info
.type
== QETH_CARD_TYPE_OSN
)
2580 rxrc
= card
->osn_info
.data_cb(skb
);
2582 #ifdef CONFIG_QETH_VLAN
2585 vlan_hwaccel_rx(skb
, card
->vlangrp
, vlan_tag
);
2587 dev_kfree_skb_any(skb
);
2592 rxrc
= netif_rx(skb
);
2593 card
->dev
->last_rx
= jiffies
;
2594 card
->stats
.rx_packets
++;
2595 card
->stats
.rx_bytes
+= skb
->len
;
2599 static struct qeth_buffer_pool_entry
*
2600 qeth_get_buffer_pool_entry(struct qeth_card
*card
)
2602 struct qeth_buffer_pool_entry
*entry
;
2604 QETH_DBF_TEXT(trace
, 6, "gtbfplen");
2605 if (!list_empty(&card
->qdio
.in_buf_pool
.entry_list
)) {
2606 entry
= list_entry(card
->qdio
.in_buf_pool
.entry_list
.next
,
2607 struct qeth_buffer_pool_entry
, list
);
2608 list_del_init(&entry
->list
);
2615 qeth_init_input_buffer(struct qeth_card
*card
, struct qeth_qdio_buffer
*buf
)
2617 struct qeth_buffer_pool_entry
*pool_entry
;
2620 pool_entry
= qeth_get_buffer_pool_entry(card
);
2622 * since the buffer is accessed only from the input_tasklet
2623 * there shouldn't be a need to synchronize; also, since we use
2624 * the QETH_IN_BUF_REQUEUE_THRESHOLD we should never run out off
2627 BUG_ON(!pool_entry
);
2629 buf
->pool_entry
= pool_entry
;
2630 for(i
= 0; i
< QETH_MAX_BUFFER_ELEMENTS(card
); ++i
){
2631 buf
->buffer
->element
[i
].length
= PAGE_SIZE
;
2632 buf
->buffer
->element
[i
].addr
= pool_entry
->elements
[i
];
2633 if (i
== QETH_MAX_BUFFER_ELEMENTS(card
) - 1)
2634 buf
->buffer
->element
[i
].flags
= SBAL_FLAGS_LAST_ENTRY
;
2636 buf
->buffer
->element
[i
].flags
= 0;
2638 buf
->state
= QETH_QDIO_BUF_EMPTY
;
2642 qeth_clear_output_buffer(struct qeth_qdio_out_q
*queue
,
2643 struct qeth_qdio_out_buffer
*buf
)
2646 struct sk_buff
*skb
;
2648 /* is PCI flag set on buffer? */
2649 if (buf
->buffer
->element
[0].flags
& 0x40)
2650 atomic_dec(&queue
->set_pci_flags_count
);
2652 while ((skb
= skb_dequeue(&buf
->skb_list
))){
2653 atomic_dec(&skb
->users
);
2654 dev_kfree_skb_any(skb
);
2656 qeth_eddp_buf_release_contexts(buf
);
2657 for(i
= 0; i
< QETH_MAX_BUFFER_ELEMENTS(queue
->card
); ++i
){
2658 buf
->buffer
->element
[i
].length
= 0;
2659 buf
->buffer
->element
[i
].addr
= NULL
;
2660 buf
->buffer
->element
[i
].flags
= 0;
2662 buf
->next_element_to_fill
= 0;
2663 atomic_set(&buf
->state
, QETH_QDIO_BUF_EMPTY
);
2667 qeth_queue_input_buffer(struct qeth_card
*card
, int index
)
2669 struct qeth_qdio_q
*queue
= card
->qdio
.in_q
;
2674 QETH_DBF_TEXT(trace
,6,"queinbuf");
2675 count
= (index
< queue
->next_buf_to_init
)?
2676 card
->qdio
.in_buf_pool
.buf_count
-
2677 (queue
->next_buf_to_init
- index
) :
2678 card
->qdio
.in_buf_pool
.buf_count
-
2679 (queue
->next_buf_to_init
+ QDIO_MAX_BUFFERS_PER_Q
- index
);
2680 /* only requeue at a certain threshold to avoid SIGAs */
2681 if (count
>= QETH_IN_BUF_REQUEUE_THRESHOLD(card
)){
2682 for (i
= queue
->next_buf_to_init
;
2683 i
< queue
->next_buf_to_init
+ count
; ++i
)
2684 qeth_init_input_buffer(card
,
2685 &queue
->bufs
[i
% QDIO_MAX_BUFFERS_PER_Q
]);
2687 * according to old code it should be avoided to requeue all
2688 * 128 buffers in order to benefit from PCI avoidance.
2689 * this function keeps at least one buffer (the buffer at
2690 * 'index') un-requeued -> this buffer is the first buffer that
2691 * will be requeued the next time
2693 if (card
->options
.performance_stats
) {
2694 card
->perf_stats
.inbound_do_qdio_cnt
++;
2695 card
->perf_stats
.inbound_do_qdio_start_time
=
2698 rc
= do_QDIO(CARD_DDEV(card
),
2699 QDIO_FLAG_SYNC_INPUT
| QDIO_FLAG_UNDER_INTERRUPT
,
2700 0, queue
->next_buf_to_init
, count
, NULL
);
2701 if (card
->options
.performance_stats
)
2702 card
->perf_stats
.inbound_do_qdio_time
+=
2704 card
->perf_stats
.inbound_do_qdio_start_time
;
2706 PRINT_WARN("qeth_queue_input_buffer's do_QDIO "
2707 "return %i (device %s).\n",
2708 rc
, CARD_DDEV_ID(card
));
2709 QETH_DBF_TEXT(trace
,2,"qinberr");
2710 QETH_DBF_TEXT_(trace
,2,"%s",CARD_BUS_ID(card
));
2712 queue
->next_buf_to_init
= (queue
->next_buf_to_init
+ count
) %
2713 QDIO_MAX_BUFFERS_PER_Q
;
2718 qeth_put_buffer_pool_entry(struct qeth_card
*card
,
2719 struct qeth_buffer_pool_entry
*entry
)
2721 QETH_DBF_TEXT(trace
, 6, "ptbfplen");
2722 list_add_tail(&entry
->list
, &card
->qdio
.in_buf_pool
.entry_list
);
2726 qeth_qdio_input_handler(struct ccw_device
* ccwdev
, unsigned int status
,
2727 unsigned int qdio_err
, unsigned int siga_err
,
2728 unsigned int queue
, int first_element
, int count
,
2729 unsigned long card_ptr
)
2731 struct net_device
*net_dev
;
2732 struct qeth_card
*card
;
2733 struct qeth_qdio_buffer
*buffer
;
2737 QETH_DBF_TEXT(trace
, 6, "qdinput");
2738 card
= (struct qeth_card
*) card_ptr
;
2739 net_dev
= card
->dev
;
2740 if (card
->options
.performance_stats
) {
2741 card
->perf_stats
.inbound_cnt
++;
2742 card
->perf_stats
.inbound_start_time
= qeth_get_micros();
2744 if (status
& QDIO_STATUS_LOOK_FOR_ERROR
) {
2745 if (status
& QDIO_STATUS_ACTIVATE_CHECK_CONDITION
){
2746 QETH_DBF_TEXT(trace
, 1,"qdinchk");
2747 QETH_DBF_TEXT_(trace
,1,"%s",CARD_BUS_ID(card
));
2748 QETH_DBF_TEXT_(trace
,1,"%04X%04X",first_element
,count
);
2749 QETH_DBF_TEXT_(trace
,1,"%04X%04X", queue
, status
);
2750 qeth_schedule_recovery(card
);
2754 for (i
= first_element
; i
< (first_element
+ count
); ++i
) {
2755 index
= i
% QDIO_MAX_BUFFERS_PER_Q
;
2756 buffer
= &card
->qdio
.in_q
->bufs
[index
];
2757 if (!((status
& QDIO_STATUS_LOOK_FOR_ERROR
) &&
2758 qeth_check_qdio_errors(buffer
->buffer
,
2759 qdio_err
, siga_err
,"qinerr")))
2760 qeth_process_inbound_buffer(card
, buffer
, index
);
2761 /* clear buffer and give back to hardware */
2762 qeth_put_buffer_pool_entry(card
, buffer
->pool_entry
);
2763 qeth_queue_input_buffer(card
, index
);
2765 if (card
->options
.performance_stats
)
2766 card
->perf_stats
.inbound_time
+= qeth_get_micros() -
2767 card
->perf_stats
.inbound_start_time
;
2771 qeth_handle_send_error(struct qeth_card
*card
,
2772 struct qeth_qdio_out_buffer
*buffer
,
2773 unsigned int qdio_err
, unsigned int siga_err
)
2775 int sbalf15
= buffer
->buffer
->element
[15].flags
& 0xff;
2776 int cc
= siga_err
& 3;
2778 QETH_DBF_TEXT(trace
, 6, "hdsnderr");
2779 qeth_check_qdio_errors(buffer
->buffer
, qdio_err
, siga_err
, "qouterr");
2783 QETH_DBF_TEXT(trace
, 1,"lnkfail");
2784 QETH_DBF_TEXT_(trace
,1,"%s",CARD_BUS_ID(card
));
2785 QETH_DBF_TEXT_(trace
,1,"%04x %02x",
2786 (u16
)qdio_err
, (u8
)sbalf15
);
2787 return QETH_SEND_ERROR_LINK_FAILURE
;
2789 return QETH_SEND_ERROR_NONE
;
2791 if (siga_err
& QDIO_SIGA_ERROR_B_BIT_SET
) {
2792 QETH_DBF_TEXT(trace
, 1, "SIGAcc2B");
2793 QETH_DBF_TEXT_(trace
,1,"%s",CARD_BUS_ID(card
));
2794 return QETH_SEND_ERROR_KICK_IT
;
2796 if ((sbalf15
>= 15) && (sbalf15
<= 31))
2797 return QETH_SEND_ERROR_RETRY
;
2798 return QETH_SEND_ERROR_LINK_FAILURE
;
2799 /* look at qdio_error and sbalf 15 */
2801 QETH_DBF_TEXT(trace
, 1, "SIGAcc1");
2802 QETH_DBF_TEXT_(trace
,1,"%s",CARD_BUS_ID(card
));
2803 return QETH_SEND_ERROR_LINK_FAILURE
;
2806 QETH_DBF_TEXT(trace
, 1, "SIGAcc3");
2807 QETH_DBF_TEXT_(trace
,1,"%s",CARD_BUS_ID(card
));
2808 return QETH_SEND_ERROR_KICK_IT
;
2813 qeth_flush_buffers(struct qeth_qdio_out_q
*queue
, int under_int
,
2814 int index
, int count
)
2816 struct qeth_qdio_out_buffer
*buf
;
2820 QETH_DBF_TEXT(trace
, 6, "flushbuf");
2822 for (i
= index
; i
< index
+ count
; ++i
) {
2823 buf
= &queue
->bufs
[i
% QDIO_MAX_BUFFERS_PER_Q
];
2824 buf
->buffer
->element
[buf
->next_element_to_fill
- 1].flags
|=
2825 SBAL_FLAGS_LAST_ENTRY
;
2827 if (queue
->card
->info
.type
== QETH_CARD_TYPE_IQD
)
2830 if (!queue
->do_pack
){
2831 if ((atomic_read(&queue
->used_buffers
) >=
2832 (QETH_HIGH_WATERMARK_PACK
-
2833 QETH_WATERMARK_PACK_FUZZ
)) &&
2834 !atomic_read(&queue
->set_pci_flags_count
)){
2835 /* it's likely that we'll go to packing
2837 atomic_inc(&queue
->set_pci_flags_count
);
2838 buf
->buffer
->element
[0].flags
|= 0x40;
2841 if (!atomic_read(&queue
->set_pci_flags_count
)){
2843 * there's no outstanding PCI any more, so we
2844 * have to request a PCI to be sure the the PCI
2845 * will wake at some time in the future then we
2846 * can flush packed buffers that might still be
2847 * hanging around, which can happen if no
2848 * further send was requested by the stack
2850 atomic_inc(&queue
->set_pci_flags_count
);
2851 buf
->buffer
->element
[0].flags
|= 0x40;
2856 queue
->card
->dev
->trans_start
= jiffies
;
2857 if (queue
->card
->options
.performance_stats
) {
2858 queue
->card
->perf_stats
.outbound_do_qdio_cnt
++;
2859 queue
->card
->perf_stats
.outbound_do_qdio_start_time
=
2863 rc
= do_QDIO(CARD_DDEV(queue
->card
),
2864 QDIO_FLAG_SYNC_OUTPUT
| QDIO_FLAG_UNDER_INTERRUPT
,
2865 queue
->queue_no
, index
, count
, NULL
);
2867 rc
= do_QDIO(CARD_DDEV(queue
->card
), QDIO_FLAG_SYNC_OUTPUT
,
2868 queue
->queue_no
, index
, count
, NULL
);
2869 if (queue
->card
->options
.performance_stats
)
2870 queue
->card
->perf_stats
.outbound_do_qdio_time
+=
2872 queue
->card
->perf_stats
.outbound_do_qdio_start_time
;
2874 QETH_DBF_TEXT(trace
, 2, "flushbuf");
2875 QETH_DBF_TEXT_(trace
, 2, " err%d", rc
);
2876 QETH_DBF_TEXT_(trace
, 2, "%s", CARD_DDEV_ID(queue
->card
));
2877 queue
->card
->stats
.tx_errors
+= count
;
2878 /* this must not happen under normal circumstances. if it
2879 * happens something is really wrong -> recover */
2880 qeth_schedule_recovery(queue
->card
);
2883 atomic_add(count
, &queue
->used_buffers
);
2884 if (queue
->card
->options
.performance_stats
)
2885 queue
->card
->perf_stats
.bufs_sent
+= count
;
2889 * Switched to packing state if the number of used buffers on a queue
2890 * reaches a certain limit.
2893 qeth_switch_to_packing_if_needed(struct qeth_qdio_out_q
*queue
)
2895 if (!queue
->do_pack
) {
2896 if (atomic_read(&queue
->used_buffers
)
2897 >= QETH_HIGH_WATERMARK_PACK
){
2898 /* switch non-PACKING -> PACKING */
2899 QETH_DBF_TEXT(trace
, 6, "np->pack");
2900 if (queue
->card
->options
.performance_stats
)
2901 queue
->card
->perf_stats
.sc_dp_p
++;
2908 * Switches from packing to non-packing mode. If there is a packing
2909 * buffer on the queue this buffer will be prepared to be flushed.
2910 * In that case 1 is returned to inform the caller. If no buffer
2911 * has to be flushed, zero is returned.
2914 qeth_switch_to_nonpacking_if_needed(struct qeth_qdio_out_q
*queue
)
2916 struct qeth_qdio_out_buffer
*buffer
;
2917 int flush_count
= 0;
2919 if (queue
->do_pack
) {
2920 if (atomic_read(&queue
->used_buffers
)
2921 <= QETH_LOW_WATERMARK_PACK
) {
2922 /* switch PACKING -> non-PACKING */
2923 QETH_DBF_TEXT(trace
, 6, "pack->np");
2924 if (queue
->card
->options
.performance_stats
)
2925 queue
->card
->perf_stats
.sc_p_dp
++;
2927 /* flush packing buffers */
2928 buffer
= &queue
->bufs
[queue
->next_buf_to_fill
];
2929 if ((atomic_read(&buffer
->state
) ==
2930 QETH_QDIO_BUF_EMPTY
) &&
2931 (buffer
->next_element_to_fill
> 0)) {
2932 atomic_set(&buffer
->state
,QETH_QDIO_BUF_PRIMED
);
2934 queue
->next_buf_to_fill
=
2935 (queue
->next_buf_to_fill
+ 1) %
2936 QDIO_MAX_BUFFERS_PER_Q
;
2944 * Called to flush a packing buffer if no more pci flags are on the queue.
2945 * Checks if there is a packing buffer and prepares it to be flushed.
2946 * In that case returns 1, otherwise zero.
2949 qeth_flush_buffers_on_no_pci(struct qeth_qdio_out_q
*queue
)
2951 struct qeth_qdio_out_buffer
*buffer
;
2953 buffer
= &queue
->bufs
[queue
->next_buf_to_fill
];
2954 if((atomic_read(&buffer
->state
) == QETH_QDIO_BUF_EMPTY
) &&
2955 (buffer
->next_element_to_fill
> 0)){
2956 /* it's a packing buffer */
2957 atomic_set(&buffer
->state
, QETH_QDIO_BUF_PRIMED
);
2958 queue
->next_buf_to_fill
=
2959 (queue
->next_buf_to_fill
+ 1) % QDIO_MAX_BUFFERS_PER_Q
;
2966 qeth_check_outbound_queue(struct qeth_qdio_out_q
*queue
)
2970 int q_was_packing
= 0;
2973 * check if weed have to switch to non-packing mode or if
2974 * we have to get a pci flag out on the queue
2976 if ((atomic_read(&queue
->used_buffers
) <= QETH_LOW_WATERMARK_PACK
) ||
2977 !atomic_read(&queue
->set_pci_flags_count
)){
2978 if (atomic_xchg(&queue
->state
, QETH_OUT_Q_LOCKED_FLUSH
) ==
2979 QETH_OUT_Q_UNLOCKED
) {
2981 * If we get in here, there was no action in
2982 * do_send_packet. So, we check if there is a
2983 * packing buffer to be flushed here.
2985 netif_stop_queue(queue
->card
->dev
);
2986 index
= queue
->next_buf_to_fill
;
2987 q_was_packing
= queue
->do_pack
;
2988 flush_cnt
+= qeth_switch_to_nonpacking_if_needed(queue
);
2990 !atomic_read(&queue
->set_pci_flags_count
))
2992 qeth_flush_buffers_on_no_pci(queue
);
2993 if (queue
->card
->options
.performance_stats
&&
2995 queue
->card
->perf_stats
.bufs_sent_pack
+=
2998 qeth_flush_buffers(queue
, 1, index
, flush_cnt
);
2999 atomic_set(&queue
->state
, QETH_OUT_Q_UNLOCKED
);
3005 qeth_qdio_output_handler(struct ccw_device
* ccwdev
, unsigned int status
,
3006 unsigned int qdio_error
, unsigned int siga_error
,
3007 unsigned int __queue
, int first_element
, int count
,
3008 unsigned long card_ptr
)
3010 struct qeth_card
*card
= (struct qeth_card
*) card_ptr
;
3011 struct qeth_qdio_out_q
*queue
= card
->qdio
.out_qs
[__queue
];
3012 struct qeth_qdio_out_buffer
*buffer
;
3015 QETH_DBF_TEXT(trace
, 6, "qdouhdl");
3016 if (status
& QDIO_STATUS_LOOK_FOR_ERROR
) {
3017 if (status
& QDIO_STATUS_ACTIVATE_CHECK_CONDITION
){
3018 QETH_DBF_TEXT(trace
, 2, "achkcond");
3019 QETH_DBF_TEXT_(trace
, 2, "%s", CARD_BUS_ID(card
));
3020 QETH_DBF_TEXT_(trace
, 2, "%08x", status
);
3021 netif_stop_queue(card
->dev
);
3022 qeth_schedule_recovery(card
);
3026 if (card
->options
.performance_stats
) {
3027 card
->perf_stats
.outbound_handler_cnt
++;
3028 card
->perf_stats
.outbound_handler_start_time
=
3031 for(i
= first_element
; i
< (first_element
+ count
); ++i
){
3032 buffer
= &queue
->bufs
[i
% QDIO_MAX_BUFFERS_PER_Q
];
3033 /*we only handle the KICK_IT error by doing a recovery */
3034 if (qeth_handle_send_error(card
, buffer
,
3035 qdio_error
, siga_error
)
3036 == QETH_SEND_ERROR_KICK_IT
){
3037 netif_stop_queue(card
->dev
);
3038 qeth_schedule_recovery(card
);
3041 qeth_clear_output_buffer(queue
, buffer
);
3043 atomic_sub(count
, &queue
->used_buffers
);
3044 /* check if we need to do something on this outbound queue */
3045 if (card
->info
.type
!= QETH_CARD_TYPE_IQD
)
3046 qeth_check_outbound_queue(queue
);
3048 netif_wake_queue(queue
->card
->dev
);
3049 if (card
->options
.performance_stats
)
3050 card
->perf_stats
.outbound_handler_time
+= qeth_get_micros() -
3051 card
->perf_stats
.outbound_handler_start_time
;
3055 qeth_create_qib_param_field(struct qeth_card
*card
, char *param_field
)
3058 param_field
[0] = _ascebc
['P'];
3059 param_field
[1] = _ascebc
['C'];
3060 param_field
[2] = _ascebc
['I'];
3061 param_field
[3] = _ascebc
['T'];
3062 *((unsigned int *) (¶m_field
[4])) = QETH_PCI_THRESHOLD_A(card
);
3063 *((unsigned int *) (¶m_field
[8])) = QETH_PCI_THRESHOLD_B(card
);
3064 *((unsigned int *) (¶m_field
[12])) = QETH_PCI_TIMER_VALUE(card
);
3068 qeth_create_qib_param_field_blkt(struct qeth_card
*card
, char *param_field
)
3070 param_field
[16] = _ascebc
['B'];
3071 param_field
[17] = _ascebc
['L'];
3072 param_field
[18] = _ascebc
['K'];
3073 param_field
[19] = _ascebc
['T'];
3074 *((unsigned int *) (¶m_field
[20])) = card
->info
.blkt
.time_total
;
3075 *((unsigned int *) (¶m_field
[24])) = card
->info
.blkt
.inter_packet
;
3076 *((unsigned int *) (¶m_field
[28])) = card
->info
.blkt
.inter_packet_jumbo
;
3080 qeth_initialize_working_pool_list(struct qeth_card
*card
)
3082 struct qeth_buffer_pool_entry
*entry
;
3084 QETH_DBF_TEXT(trace
,5,"inwrklst");
3086 list_for_each_entry(entry
,
3087 &card
->qdio
.init_pool
.entry_list
, init_list
) {
3088 qeth_put_buffer_pool_entry(card
,entry
);
3093 qeth_clear_working_pool_list(struct qeth_card
*card
)
3095 struct qeth_buffer_pool_entry
*pool_entry
, *tmp
;
3097 QETH_DBF_TEXT(trace
,5,"clwrklst");
3098 list_for_each_entry_safe(pool_entry
, tmp
,
3099 &card
->qdio
.in_buf_pool
.entry_list
, list
){
3100 list_del(&pool_entry
->list
);
3105 qeth_free_buffer_pool(struct qeth_card
*card
)
3107 struct qeth_buffer_pool_entry
*pool_entry
, *tmp
;
3109 QETH_DBF_TEXT(trace
,5,"freepool");
3110 list_for_each_entry_safe(pool_entry
, tmp
,
3111 &card
->qdio
.init_pool
.entry_list
, init_list
){
3112 for (i
= 0; i
< QETH_MAX_BUFFER_ELEMENTS(card
); ++i
)
3113 free_page((unsigned long)pool_entry
->elements
[i
]);
3114 list_del(&pool_entry
->init_list
);
3120 qeth_alloc_buffer_pool(struct qeth_card
*card
)
3122 struct qeth_buffer_pool_entry
*pool_entry
;
3126 QETH_DBF_TEXT(trace
,5,"alocpool");
3127 for (i
= 0; i
< card
->qdio
.init_pool
.buf_count
; ++i
){
3128 pool_entry
= kmalloc(sizeof(*pool_entry
), GFP_KERNEL
);
3130 qeth_free_buffer_pool(card
);
3133 for(j
= 0; j
< QETH_MAX_BUFFER_ELEMENTS(card
); ++j
){
3134 ptr
= (void *) __get_free_page(GFP_KERNEL
|GFP_DMA
);
3137 free_page((unsigned long)
3138 pool_entry
->elements
[--j
]);
3140 qeth_free_buffer_pool(card
);
3143 pool_entry
->elements
[j
] = ptr
;
3145 list_add(&pool_entry
->init_list
,
3146 &card
->qdio
.init_pool
.entry_list
);
3152 qeth_realloc_buffer_pool(struct qeth_card
*card
, int bufcnt
)
3154 QETH_DBF_TEXT(trace
, 2, "realcbp");
3156 if ((card
->state
!= CARD_STATE_DOWN
) &&
3157 (card
->state
!= CARD_STATE_RECOVER
))
3160 /* TODO: steel/add buffers from/to a running card's buffer pool (?) */
3161 qeth_clear_working_pool_list(card
);
3162 qeth_free_buffer_pool(card
);
3163 card
->qdio
.in_buf_pool
.buf_count
= bufcnt
;
3164 card
->qdio
.init_pool
.buf_count
= bufcnt
;
3165 return qeth_alloc_buffer_pool(card
);
3169 qeth_alloc_qdio_buffers(struct qeth_card
*card
)
3173 QETH_DBF_TEXT(setup
, 2, "allcqdbf");
3175 if (atomic_cmpxchg(&card
->qdio
.state
, QETH_QDIO_UNINITIALIZED
,
3176 QETH_QDIO_ALLOCATED
) != QETH_QDIO_UNINITIALIZED
)
3179 card
->qdio
.in_q
= kmalloc(sizeof(struct qeth_qdio_q
),
3180 GFP_KERNEL
|GFP_DMA
);
3181 if (!card
->qdio
.in_q
)
3183 QETH_DBF_TEXT(setup
, 2, "inq");
3184 QETH_DBF_HEX(setup
, 2, &card
->qdio
.in_q
, sizeof(void *));
3185 memset(card
->qdio
.in_q
, 0, sizeof(struct qeth_qdio_q
));
3186 /* give inbound qeth_qdio_buffers their qdio_buffers */
3187 for (i
= 0; i
< QDIO_MAX_BUFFERS_PER_Q
; ++i
)
3188 card
->qdio
.in_q
->bufs
[i
].buffer
=
3189 &card
->qdio
.in_q
->qdio_bufs
[i
];
3190 /* inbound buffer pool */
3191 if (qeth_alloc_buffer_pool(card
))
3195 kmalloc(card
->qdio
.no_out_queues
*
3196 sizeof(struct qeth_qdio_out_q
*), GFP_KERNEL
);
3197 if (!card
->qdio
.out_qs
)
3199 for (i
= 0; i
< card
->qdio
.no_out_queues
; ++i
) {
3200 card
->qdio
.out_qs
[i
] = kmalloc(sizeof(struct qeth_qdio_out_q
),
3201 GFP_KERNEL
|GFP_DMA
);
3202 if (!card
->qdio
.out_qs
[i
])
3204 QETH_DBF_TEXT_(setup
, 2, "outq %i", i
);
3205 QETH_DBF_HEX(setup
, 2, &card
->qdio
.out_qs
[i
], sizeof(void *));
3206 memset(card
->qdio
.out_qs
[i
], 0, sizeof(struct qeth_qdio_out_q
));
3207 card
->qdio
.out_qs
[i
]->queue_no
= i
;
3208 /* give outbound qeth_qdio_buffers their qdio_buffers */
3209 for (j
= 0; j
< QDIO_MAX_BUFFERS_PER_Q
; ++j
){
3210 card
->qdio
.out_qs
[i
]->bufs
[j
].buffer
=
3211 &card
->qdio
.out_qs
[i
]->qdio_bufs
[j
];
3212 skb_queue_head_init(&card
->qdio
.out_qs
[i
]->bufs
[j
].
3215 &card
->qdio
.out_qs
[i
]->bufs
[j
].skb_list
.lock
,
3216 &qdio_out_skb_queue_key
);
3217 INIT_LIST_HEAD(&card
->qdio
.out_qs
[i
]->bufs
[j
].ctx_list
);
3224 kfree(card
->qdio
.out_qs
[--i
]);
3225 kfree(card
->qdio
.out_qs
);
3227 qeth_free_buffer_pool(card
);
3229 kfree(card
->qdio
.in_q
);
3231 atomic_set(&card
->qdio
.state
, QETH_QDIO_UNINITIALIZED
);
3236 qeth_free_qdio_buffers(struct qeth_card
*card
)
3240 QETH_DBF_TEXT(trace
, 2, "freeqdbf");
3241 if (atomic_xchg(&card
->qdio
.state
, QETH_QDIO_UNINITIALIZED
) ==
3242 QETH_QDIO_UNINITIALIZED
)
3244 kfree(card
->qdio
.in_q
);
3245 /* inbound buffer pool */
3246 qeth_free_buffer_pool(card
);
3247 /* free outbound qdio_qs */
3248 for (i
= 0; i
< card
->qdio
.no_out_queues
; ++i
){
3249 for (j
= 0; j
< QDIO_MAX_BUFFERS_PER_Q
; ++j
)
3250 qeth_clear_output_buffer(card
->qdio
.out_qs
[i
],
3251 &card
->qdio
.out_qs
[i
]->bufs
[j
]);
3252 kfree(card
->qdio
.out_qs
[i
]);
3254 kfree(card
->qdio
.out_qs
);
3258 qeth_clear_qdio_buffers(struct qeth_card
*card
)
3262 QETH_DBF_TEXT(trace
, 2, "clearqdbf");
3263 /* clear outbound buffers to free skbs */
3264 for (i
= 0; i
< card
->qdio
.no_out_queues
; ++i
)
3265 if (card
->qdio
.out_qs
[i
]){
3266 for (j
= 0; j
< QDIO_MAX_BUFFERS_PER_Q
; ++j
)
3267 qeth_clear_output_buffer(card
->qdio
.out_qs
[i
],
3268 &card
->qdio
.out_qs
[i
]->bufs
[j
]);
3273 qeth_init_qdio_info(struct qeth_card
*card
)
3275 QETH_DBF_TEXT(setup
, 4, "intqdinf");
3276 atomic_set(&card
->qdio
.state
, QETH_QDIO_UNINITIALIZED
);
3278 card
->qdio
.in_buf_size
= QETH_IN_BUF_SIZE_DEFAULT
;
3279 card
->qdio
.init_pool
.buf_count
= QETH_IN_BUF_COUNT_DEFAULT
;
3280 card
->qdio
.in_buf_pool
.buf_count
= card
->qdio
.init_pool
.buf_count
;
3281 INIT_LIST_HEAD(&card
->qdio
.in_buf_pool
.entry_list
);
3282 INIT_LIST_HEAD(&card
->qdio
.init_pool
.entry_list
);
3286 qeth_init_qdio_queues(struct qeth_card
*card
)
3291 QETH_DBF_TEXT(setup
, 2, "initqdqs");
3294 memset(card
->qdio
.in_q
->qdio_bufs
, 0,
3295 QDIO_MAX_BUFFERS_PER_Q
* sizeof(struct qdio_buffer
));
3296 qeth_initialize_working_pool_list(card
);
3297 /*give only as many buffers to hardware as we have buffer pool entries*/
3298 for (i
= 0; i
< card
->qdio
.in_buf_pool
.buf_count
- 1; ++i
)
3299 qeth_init_input_buffer(card
, &card
->qdio
.in_q
->bufs
[i
]);
3300 card
->qdio
.in_q
->next_buf_to_init
= card
->qdio
.in_buf_pool
.buf_count
- 1;
3301 rc
= do_QDIO(CARD_DDEV(card
), QDIO_FLAG_SYNC_INPUT
, 0, 0,
3302 card
->qdio
.in_buf_pool
.buf_count
- 1, NULL
);
3304 QETH_DBF_TEXT_(setup
, 2, "1err%d", rc
);
3307 rc
= qdio_synchronize(CARD_DDEV(card
), QDIO_FLAG_SYNC_INPUT
, 0);
3309 QETH_DBF_TEXT_(setup
, 2, "2err%d", rc
);
3312 /* outbound queue */
3313 for (i
= 0; i
< card
->qdio
.no_out_queues
; ++i
){
3314 memset(card
->qdio
.out_qs
[i
]->qdio_bufs
, 0,
3315 QDIO_MAX_BUFFERS_PER_Q
* sizeof(struct qdio_buffer
));
3316 for (j
= 0; j
< QDIO_MAX_BUFFERS_PER_Q
; ++j
){
3317 qeth_clear_output_buffer(card
->qdio
.out_qs
[i
],
3318 &card
->qdio
.out_qs
[i
]->bufs
[j
]);
3320 card
->qdio
.out_qs
[i
]->card
= card
;
3321 card
->qdio
.out_qs
[i
]->next_buf_to_fill
= 0;
3322 card
->qdio
.out_qs
[i
]->do_pack
= 0;
3323 atomic_set(&card
->qdio
.out_qs
[i
]->used_buffers
,0);
3324 atomic_set(&card
->qdio
.out_qs
[i
]->set_pci_flags_count
, 0);
3325 atomic_set(&card
->qdio
.out_qs
[i
]->state
,
3326 QETH_OUT_Q_UNLOCKED
);
3332 qeth_qdio_establish(struct qeth_card
*card
)
3334 struct qdio_initialize init_data
;
3335 char *qib_param_field
;
3336 struct qdio_buffer
**in_sbal_ptrs
;
3337 struct qdio_buffer
**out_sbal_ptrs
;
3341 QETH_DBF_TEXT(setup
, 2, "qdioest");
3343 qib_param_field
= kzalloc(QDIO_MAX_BUFFERS_PER_Q
* sizeof(char),
3345 if (!qib_param_field
)
3348 qeth_create_qib_param_field(card
, qib_param_field
);
3349 qeth_create_qib_param_field_blkt(card
, qib_param_field
);
3351 in_sbal_ptrs
= kmalloc(QDIO_MAX_BUFFERS_PER_Q
* sizeof(void *),
3353 if (!in_sbal_ptrs
) {
3354 kfree(qib_param_field
);
3357 for(i
= 0; i
< QDIO_MAX_BUFFERS_PER_Q
; ++i
)
3358 in_sbal_ptrs
[i
] = (struct qdio_buffer
*)
3359 virt_to_phys(card
->qdio
.in_q
->bufs
[i
].buffer
);
3362 kmalloc(card
->qdio
.no_out_queues
* QDIO_MAX_BUFFERS_PER_Q
*
3363 sizeof(void *), GFP_KERNEL
);
3364 if (!out_sbal_ptrs
) {
3365 kfree(in_sbal_ptrs
);
3366 kfree(qib_param_field
);
3369 for(i
= 0, k
= 0; i
< card
->qdio
.no_out_queues
; ++i
)
3370 for(j
= 0; j
< QDIO_MAX_BUFFERS_PER_Q
; ++j
, ++k
){
3371 out_sbal_ptrs
[k
] = (struct qdio_buffer
*)
3372 virt_to_phys(card
->qdio
.out_qs
[i
]->
3376 memset(&init_data
, 0, sizeof(struct qdio_initialize
));
3377 init_data
.cdev
= CARD_DDEV(card
);
3378 init_data
.q_format
= qeth_get_qdio_q_format(card
);
3379 init_data
.qib_param_field_format
= 0;
3380 init_data
.qib_param_field
= qib_param_field
;
3381 init_data
.min_input_threshold
= QETH_MIN_INPUT_THRESHOLD
;
3382 init_data
.max_input_threshold
= QETH_MAX_INPUT_THRESHOLD
;
3383 init_data
.min_output_threshold
= QETH_MIN_OUTPUT_THRESHOLD
;
3384 init_data
.max_output_threshold
= QETH_MAX_OUTPUT_THRESHOLD
;
3385 init_data
.no_input_qs
= 1;
3386 init_data
.no_output_qs
= card
->qdio
.no_out_queues
;
3387 init_data
.input_handler
= (qdio_handler_t
*)
3388 qeth_qdio_input_handler
;
3389 init_data
.output_handler
= (qdio_handler_t
*)
3390 qeth_qdio_output_handler
;
3391 init_data
.int_parm
= (unsigned long) card
;
3392 init_data
.flags
= QDIO_INBOUND_0COPY_SBALS
|
3393 QDIO_OUTBOUND_0COPY_SBALS
|
3394 QDIO_USE_OUTBOUND_PCIS
;
3395 init_data
.input_sbal_addr_array
= (void **) in_sbal_ptrs
;
3396 init_data
.output_sbal_addr_array
= (void **) out_sbal_ptrs
;
3398 if (atomic_cmpxchg(&card
->qdio
.state
, QETH_QDIO_ALLOCATED
,
3399 QETH_QDIO_ESTABLISHED
) == QETH_QDIO_ALLOCATED
)
3400 if ((rc
= qdio_initialize(&init_data
)))
3401 atomic_set(&card
->qdio
.state
, QETH_QDIO_ALLOCATED
);
3403 kfree(out_sbal_ptrs
);
3404 kfree(in_sbal_ptrs
);
3405 kfree(qib_param_field
);
3410 qeth_qdio_activate(struct qeth_card
*card
)
3412 QETH_DBF_TEXT(setup
,3,"qdioact");
3413 return qdio_activate(CARD_DDEV(card
), 0);
3417 qeth_clear_channel(struct qeth_channel
*channel
)
3419 unsigned long flags
;
3420 struct qeth_card
*card
;
3423 QETH_DBF_TEXT(trace
,3,"clearch");
3424 card
= CARD_FROM_CDEV(channel
->ccwdev
);
3425 spin_lock_irqsave(get_ccwdev_lock(channel
->ccwdev
), flags
);
3426 rc
= ccw_device_clear(channel
->ccwdev
, QETH_CLEAR_CHANNEL_PARM
);
3427 spin_unlock_irqrestore(get_ccwdev_lock(channel
->ccwdev
), flags
);
3431 rc
= wait_event_interruptible_timeout(card
->wait_q
,
3432 channel
->state
==CH_STATE_STOPPED
, QETH_TIMEOUT
);
3433 if (rc
== -ERESTARTSYS
)
3435 if (channel
->state
!= CH_STATE_STOPPED
)
3437 channel
->state
= CH_STATE_DOWN
;
3442 qeth_halt_channel(struct qeth_channel
*channel
)
3444 unsigned long flags
;
3445 struct qeth_card
*card
;
3448 QETH_DBF_TEXT(trace
,3,"haltch");
3449 card
= CARD_FROM_CDEV(channel
->ccwdev
);
3450 spin_lock_irqsave(get_ccwdev_lock(channel
->ccwdev
), flags
);
3451 rc
= ccw_device_halt(channel
->ccwdev
, QETH_HALT_CHANNEL_PARM
);
3452 spin_unlock_irqrestore(get_ccwdev_lock(channel
->ccwdev
), flags
);
3456 rc
= wait_event_interruptible_timeout(card
->wait_q
,
3457 channel
->state
==CH_STATE_HALTED
, QETH_TIMEOUT
);
3458 if (rc
== -ERESTARTSYS
)
3460 if (channel
->state
!= CH_STATE_HALTED
)
3466 qeth_halt_channels(struct qeth_card
*card
)
3468 int rc1
= 0, rc2
=0, rc3
= 0;
3470 QETH_DBF_TEXT(trace
,3,"haltchs");
3471 rc1
= qeth_halt_channel(&card
->read
);
3472 rc2
= qeth_halt_channel(&card
->write
);
3473 rc3
= qeth_halt_channel(&card
->data
);
3481 qeth_clear_channels(struct qeth_card
*card
)
3483 int rc1
= 0, rc2
=0, rc3
= 0;
3485 QETH_DBF_TEXT(trace
,3,"clearchs");
3486 rc1
= qeth_clear_channel(&card
->read
);
3487 rc2
= qeth_clear_channel(&card
->write
);
3488 rc3
= qeth_clear_channel(&card
->data
);
3497 qeth_clear_halt_card(struct qeth_card
*card
, int halt
)
3501 QETH_DBF_TEXT(trace
,3,"clhacrd");
3502 QETH_DBF_HEX(trace
, 3, &card
, sizeof(void *));
3505 rc
= qeth_halt_channels(card
);
3508 return qeth_clear_channels(card
);
3512 qeth_qdio_clear_card(struct qeth_card
*card
, int use_halt
)
3516 QETH_DBF_TEXT(trace
,3,"qdioclr");
3517 switch (atomic_cmpxchg(&card
->qdio
.state
, QETH_QDIO_ESTABLISHED
,
3518 QETH_QDIO_CLEANING
)) {
3519 case QETH_QDIO_ESTABLISHED
:
3520 if ((rc
= qdio_cleanup(CARD_DDEV(card
),
3521 (card
->info
.type
== QETH_CARD_TYPE_IQD
) ?
3522 QDIO_FLAG_CLEANUP_USING_HALT
:
3523 QDIO_FLAG_CLEANUP_USING_CLEAR
)))
3524 QETH_DBF_TEXT_(trace
, 3, "1err%d", rc
);
3525 atomic_set(&card
->qdio
.state
, QETH_QDIO_ALLOCATED
);
3527 case QETH_QDIO_CLEANING
:
3532 if ((rc
= qeth_clear_halt_card(card
, use_halt
)))
3533 QETH_DBF_TEXT_(trace
, 3, "2err%d", rc
);
3534 card
->state
= CARD_STATE_DOWN
;
3539 qeth_dm_act(struct qeth_card
*card
)
3542 struct qeth_cmd_buffer
*iob
;
3544 QETH_DBF_TEXT(setup
,2,"dmact");
3546 iob
= qeth_wait_for_buffer(&card
->write
);
3547 memcpy(iob
->data
, DM_ACT
, DM_ACT_SIZE
);
3549 memcpy(QETH_DM_ACT_DEST_ADDR(iob
->data
),
3550 &card
->token
.cm_connection_r
, QETH_MPC_TOKEN_LENGTH
);
3551 memcpy(QETH_DM_ACT_CONNECTION_TOKEN(iob
->data
),
3552 &card
->token
.ulp_connection_r
, QETH_MPC_TOKEN_LENGTH
);
3553 rc
= qeth_send_control_data(card
, DM_ACT_SIZE
, iob
, NULL
, NULL
);
3558 qeth_mpc_initialize(struct qeth_card
*card
)
3562 QETH_DBF_TEXT(setup
,2,"mpcinit");
3564 if ((rc
= qeth_issue_next_read(card
))){
3565 QETH_DBF_TEXT_(setup
, 2, "1err%d", rc
);
3568 if ((rc
= qeth_cm_enable(card
))){
3569 QETH_DBF_TEXT_(setup
, 2, "2err%d", rc
);
3572 if ((rc
= qeth_cm_setup(card
))){
3573 QETH_DBF_TEXT_(setup
, 2, "3err%d", rc
);
3576 if ((rc
= qeth_ulp_enable(card
))){
3577 QETH_DBF_TEXT_(setup
, 2, "4err%d", rc
);
3580 if ((rc
= qeth_ulp_setup(card
))){
3581 QETH_DBF_TEXT_(setup
, 2, "5err%d", rc
);
3584 if ((rc
= qeth_alloc_qdio_buffers(card
))){
3585 QETH_DBF_TEXT_(setup
, 2, "5err%d", rc
);
3588 if ((rc
= qeth_qdio_establish(card
))){
3589 QETH_DBF_TEXT_(setup
, 2, "6err%d", rc
);
3590 qeth_free_qdio_buffers(card
);
3593 if ((rc
= qeth_qdio_activate(card
))){
3594 QETH_DBF_TEXT_(setup
, 2, "7err%d", rc
);
3597 if ((rc
= qeth_dm_act(card
))){
3598 QETH_DBF_TEXT_(setup
, 2, "8err%d", rc
);
3604 qeth_qdio_clear_card(card
, card
->info
.type
!=QETH_CARD_TYPE_IQD
);
3608 static struct net_device
*
3609 qeth_get_netdevice(enum qeth_card_types type
, enum qeth_link_types linktype
)
3611 struct net_device
*dev
= NULL
;
3614 case QETH_CARD_TYPE_OSAE
:
3616 case QETH_LINK_TYPE_LANE_TR
:
3617 case QETH_LINK_TYPE_HSTR
:
3619 dev
= alloc_trdev(0);
3620 #endif /* CONFIG_TR */
3623 dev
= alloc_etherdev(0);
3626 case QETH_CARD_TYPE_IQD
:
3627 dev
= alloc_netdev(0, "hsi%d", ether_setup
);
3629 case QETH_CARD_TYPE_OSN
:
3630 dev
= alloc_netdev(0, "osn%d", ether_setup
);
3633 dev
= alloc_etherdev(0);
3638 /*hard_header fake function; used in case fake_ll is set */
3640 qeth_fake_header(struct sk_buff
*skb
, struct net_device
*dev
,
3641 unsigned short type
, void *daddr
, void *saddr
,
3644 if(dev
->type
== ARPHRD_IEEE802_TR
){
3645 struct trh_hdr
*hdr
;
3646 hdr
= (struct trh_hdr
*)skb_push(skb
, QETH_FAKE_LL_LEN_TR
);
3647 memcpy(hdr
->saddr
, dev
->dev_addr
, TR_ALEN
);
3648 memcpy(hdr
->daddr
, "FAKELL", TR_ALEN
);
3649 return QETH_FAKE_LL_LEN_TR
;
3653 hdr
= (struct ethhdr
*)skb_push(skb
, QETH_FAKE_LL_LEN_ETH
);
3654 memcpy(hdr
->h_source
, dev
->dev_addr
, ETH_ALEN
);
3655 memcpy(hdr
->h_dest
, "FAKELL", ETH_ALEN
);
3656 if (type
!= ETH_P_802_3
)
3657 hdr
->h_proto
= htons(type
);
3659 hdr
->h_proto
= htons(len
);
3660 return QETH_FAKE_LL_LEN_ETH
;
3666 qeth_send_packet(struct qeth_card
*, struct sk_buff
*);
3669 qeth_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
3672 struct qeth_card
*card
;
3674 QETH_DBF_TEXT(trace
, 6, "hrdstxmi");
3675 card
= (struct qeth_card
*)dev
->priv
;
3677 card
->stats
.tx_dropped
++;
3678 card
->stats
.tx_errors
++;
3679 /* return OK; otherwise ksoftirqd goes to 100% */
3680 return NETDEV_TX_OK
;
3682 if ((card
->state
!= CARD_STATE_UP
) || !card
->lan_online
) {
3683 card
->stats
.tx_dropped
++;
3684 card
->stats
.tx_errors
++;
3685 card
->stats
.tx_carrier_errors
++;
3686 dev_kfree_skb_any(skb
);
3687 /* return OK; otherwise ksoftirqd goes to 100% */
3688 return NETDEV_TX_OK
;
3690 if (card
->options
.performance_stats
) {
3691 card
->perf_stats
.outbound_cnt
++;
3692 card
->perf_stats
.outbound_start_time
= qeth_get_micros();
3694 netif_stop_queue(dev
);
3695 if ((rc
= qeth_send_packet(card
, skb
))) {
3697 return NETDEV_TX_BUSY
;
3699 card
->stats
.tx_errors
++;
3700 card
->stats
.tx_dropped
++;
3701 dev_kfree_skb_any(skb
);
3702 /*set to OK; otherwise ksoftirqd goes to 100% */
3706 netif_wake_queue(dev
);
3707 if (card
->options
.performance_stats
)
3708 card
->perf_stats
.outbound_time
+= qeth_get_micros() -
3709 card
->perf_stats
.outbound_start_time
;
3714 qeth_verify_vlan_dev(struct net_device
*dev
, struct qeth_card
*card
)
3717 #ifdef CONFIG_QETH_VLAN
3718 struct vlan_group
*vg
;
3721 if (!(vg
= card
->vlangrp
))
3724 for (i
= 0; i
< VLAN_GROUP_ARRAY_LEN
; i
++){
3725 if (vlan_group_get_device(vg
, i
) == dev
){
3726 rc
= QETH_VLAN_CARD
;
3730 if (rc
&& !(VLAN_DEV_INFO(dev
)->real_dev
->priv
== (void *)card
))
3738 qeth_verify_dev(struct net_device
*dev
)
3740 struct qeth_card
*card
;
3741 unsigned long flags
;
3744 read_lock_irqsave(&qeth_card_list
.rwlock
, flags
);
3745 list_for_each_entry(card
, &qeth_card_list
.list
, list
){
3746 if (card
->dev
== dev
){
3747 rc
= QETH_REAL_CARD
;
3750 rc
= qeth_verify_vlan_dev(dev
, card
);
3754 read_unlock_irqrestore(&qeth_card_list
.rwlock
, flags
);
3759 static struct qeth_card
*
3760 qeth_get_card_from_dev(struct net_device
*dev
)
3762 struct qeth_card
*card
= NULL
;
3765 rc
= qeth_verify_dev(dev
);
3766 if (rc
== QETH_REAL_CARD
)
3767 card
= (struct qeth_card
*)dev
->priv
;
3768 else if (rc
== QETH_VLAN_CARD
)
3769 card
= (struct qeth_card
*)
3770 VLAN_DEV_INFO(dev
)->real_dev
->priv
;
3772 QETH_DBF_TEXT_(trace
, 4, "%d", rc
);
3777 qeth_tx_timeout(struct net_device
*dev
)
3779 struct qeth_card
*card
;
3781 card
= (struct qeth_card
*) dev
->priv
;
3782 card
->stats
.tx_errors
++;
3783 qeth_schedule_recovery(card
);
3787 qeth_open(struct net_device
*dev
)
3789 struct qeth_card
*card
;
3791 QETH_DBF_TEXT(trace
, 4, "qethopen");
3793 card
= (struct qeth_card
*) dev
->priv
;
3795 if (card
->state
!= CARD_STATE_SOFTSETUP
)
3798 if ( (card
->info
.type
!= QETH_CARD_TYPE_OSN
) &&
3799 (card
->options
.layer2
) &&
3800 (!(card
->info
.mac_bits
& QETH_LAYER2_MAC_REGISTERED
))) {
3801 QETH_DBF_TEXT(trace
,4,"nomacadr");
3804 card
->data
.state
= CH_STATE_UP
;
3805 card
->state
= CARD_STATE_UP
;
3806 card
->dev
->flags
|= IFF_UP
;
3807 netif_start_queue(dev
);
3809 if (!card
->lan_online
&& netif_carrier_ok(dev
))
3810 netif_carrier_off(dev
);
3815 qeth_stop(struct net_device
*dev
)
3817 struct qeth_card
*card
;
3819 QETH_DBF_TEXT(trace
, 4, "qethstop");
3821 card
= (struct qeth_card
*) dev
->priv
;
3823 netif_tx_disable(dev
);
3824 card
->dev
->flags
&= ~IFF_UP
;
3825 if (card
->state
== CARD_STATE_UP
)
3826 card
->state
= CARD_STATE_SOFTSETUP
;
3831 qeth_get_cast_type(struct qeth_card
*card
, struct sk_buff
*skb
)
3833 int cast_type
= RTN_UNSPEC
;
3835 if (card
->info
.type
== QETH_CARD_TYPE_OSN
)
3838 if (skb
->dst
&& skb
->dst
->neighbour
){
3839 cast_type
= skb
->dst
->neighbour
->type
;
3840 if ((cast_type
== RTN_BROADCAST
) ||
3841 (cast_type
== RTN_MULTICAST
) ||
3842 (cast_type
== RTN_ANYCAST
))
3847 /* try something else */
3848 if (skb
->protocol
== ETH_P_IPV6
)
3849 return (skb_network_header(skb
)[24] == 0xff) ?
3851 else if (skb
->protocol
== ETH_P_IP
)
3852 return ((skb_network_header(skb
)[16] & 0xf0) == 0xe0) ?
3855 if (!memcmp(skb
->data
, skb
->dev
->broadcast
, 6))
3856 return RTN_BROADCAST
;
3860 hdr_mac
= *((u16
*)skb
->data
);
3862 switch (card
->info
.link_type
) {
3863 case QETH_LINK_TYPE_HSTR
:
3864 case QETH_LINK_TYPE_LANE_TR
:
3865 if ((hdr_mac
== QETH_TR_MAC_NC
) ||
3866 (hdr_mac
== QETH_TR_MAC_C
))
3867 return RTN_MULTICAST
;
3869 /* eth or so multicast? */
3871 if ((hdr_mac
== QETH_ETH_MAC_V4
) ||
3872 (hdr_mac
== QETH_ETH_MAC_V6
))
3873 return RTN_MULTICAST
;
3880 qeth_get_priority_queue(struct qeth_card
*card
, struct sk_buff
*skb
,
3881 int ipv
, int cast_type
)
3883 if (!ipv
&& (card
->info
.type
== QETH_CARD_TYPE_OSAE
))
3884 return card
->qdio
.default_out_queue
;
3885 switch (card
->qdio
.no_out_queues
) {
3887 if (cast_type
&& card
->info
.is_multicast_different
)
3888 return card
->info
.is_multicast_different
&
3889 (card
->qdio
.no_out_queues
- 1);
3890 if (card
->qdio
.do_prio_queueing
&& (ipv
== 4)) {
3891 const u8 tos
= ip_hdr(skb
)->tos
;
3893 if (card
->qdio
.do_prio_queueing
==QETH_PRIO_Q_ING_TOS
){
3894 if (tos
& IP_TOS_NOTIMPORTANT
)
3896 if (tos
& IP_TOS_HIGHRELIABILITY
)
3898 if (tos
& IP_TOS_HIGHTHROUGHPUT
)
3900 if (tos
& IP_TOS_LOWDELAY
)
3903 if (card
->qdio
.do_prio_queueing
==QETH_PRIO_Q_ING_PREC
)
3904 return 3 - (tos
>> 6);
3905 } else if (card
->qdio
.do_prio_queueing
&& (ipv
== 6)) {
3908 return card
->qdio
.default_out_queue
;
3909 case 1: /* fallthrough for single-out-queue 1920-device */
3911 return card
->qdio
.default_out_queue
;
3916 qeth_get_ip_version(struct sk_buff
*skb
)
3918 switch (skb
->protocol
) {
3928 static struct qeth_hdr
*
3929 __qeth_prepare_skb(struct qeth_card
*card
, struct sk_buff
*skb
, int ipv
)
3931 #ifdef CONFIG_QETH_VLAN
3933 if (card
->vlangrp
&& vlan_tx_tag_present(skb
) &&
3934 ((ipv
== 6) || card
->options
.layer2
) ) {
3936 * Move the mac addresses (6 bytes src, 6 bytes dest)
3937 * to the beginning of the new header. We are using three
3938 * memcpys instead of one memmove to save cycles.
3940 skb_push(skb
, VLAN_HLEN
);
3941 skb_copy_to_linear_data(skb
, skb
->data
+ 4, 4);
3942 skb_copy_to_linear_data_offset(skb
, 4, skb
->data
+ 8, 4);
3943 skb_copy_to_linear_data_offset(skb
, 8, skb
->data
+ 12, 4);
3944 tag
= (u16
*)(skb
->data
+ 12);
3946 * first two bytes = ETH_P_8021Q (0x8100)
3947 * second two bytes = VLANID
3949 *tag
= __constant_htons(ETH_P_8021Q
);
3950 *(tag
+ 1) = htons(vlan_tx_tag_get(skb
));
3953 return ((struct qeth_hdr
*)
3954 qeth_push_skb(card
, skb
, sizeof(struct qeth_hdr
)));
3958 __qeth_free_new_skb(struct sk_buff
*orig_skb
, struct sk_buff
*new_skb
)
3960 if (orig_skb
!= new_skb
)
3961 dev_kfree_skb_any(new_skb
);
3964 static struct sk_buff
*
3965 qeth_prepare_skb(struct qeth_card
*card
, struct sk_buff
*skb
,
3966 struct qeth_hdr
**hdr
, int ipv
)
3968 struct sk_buff
*new_skb
, *new_skb2
;
3970 QETH_DBF_TEXT(trace
, 6, "prepskb");
3972 new_skb
= qeth_pskb_unshare(skb
, GFP_ATOMIC
);
3975 new_skb2
= qeth_realloc_headroom(card
, new_skb
,
3976 sizeof(struct qeth_hdr
));
3978 __qeth_free_new_skb(skb
, new_skb
);
3982 __qeth_free_new_skb(new_skb2
, new_skb
);
3984 *hdr
= __qeth_prepare_skb(card
, new_skb
, ipv
);
3986 __qeth_free_new_skb(skb
, new_skb
);
3993 qeth_get_qeth_hdr_flags4(int cast_type
)
3995 if (cast_type
== RTN_MULTICAST
)
3996 return QETH_CAST_MULTICAST
;
3997 if (cast_type
== RTN_BROADCAST
)
3998 return QETH_CAST_BROADCAST
;
3999 return QETH_CAST_UNICAST
;
4003 qeth_get_qeth_hdr_flags6(int cast_type
)
4005 u8 ct
= QETH_HDR_PASSTHRU
| QETH_HDR_IPV6
;
4006 if (cast_type
== RTN_MULTICAST
)
4007 return ct
| QETH_CAST_MULTICAST
;
4008 if (cast_type
== RTN_ANYCAST
)
4009 return ct
| QETH_CAST_ANYCAST
;
4010 if (cast_type
== RTN_BROADCAST
)
4011 return ct
| QETH_CAST_BROADCAST
;
4012 return ct
| QETH_CAST_UNICAST
;
4016 qeth_layer2_get_packet_type(struct qeth_card
*card
, struct qeth_hdr
*hdr
,
4017 struct sk_buff
*skb
)
4021 if (!memcmp(skb
->data
+QETH_HEADER_SIZE
,
4022 skb
->dev
->broadcast
,6)) { /* broadcast? */
4023 *(__u32
*)hdr
->hdr
.l2
.flags
|=
4024 QETH_LAYER2_FLAG_BROADCAST
<< 8;
4027 hdr_mac
=*((__u16
*)skb
->data
);
4029 switch (card
->info
.link_type
) {
4030 case QETH_LINK_TYPE_HSTR
:
4031 case QETH_LINK_TYPE_LANE_TR
:
4032 if ((hdr_mac
== QETH_TR_MAC_NC
) ||
4033 (hdr_mac
== QETH_TR_MAC_C
) )
4034 *(__u32
*)hdr
->hdr
.l2
.flags
|=
4035 QETH_LAYER2_FLAG_MULTICAST
<< 8;
4037 *(__u32
*)hdr
->hdr
.l2
.flags
|=
4038 QETH_LAYER2_FLAG_UNICAST
<< 8;
4040 /* eth or so multicast? */
4042 if ( (hdr_mac
==QETH_ETH_MAC_V4
) ||
4043 (hdr_mac
==QETH_ETH_MAC_V6
) )
4044 *(__u32
*)hdr
->hdr
.l2
.flags
|=
4045 QETH_LAYER2_FLAG_MULTICAST
<< 8;
4047 *(__u32
*)hdr
->hdr
.l2
.flags
|=
4048 QETH_LAYER2_FLAG_UNICAST
<< 8;
4053 qeth_layer2_fill_header(struct qeth_card
*card
, struct qeth_hdr
*hdr
,
4054 struct sk_buff
*skb
, int cast_type
)
4056 memset(hdr
, 0, sizeof(struct qeth_hdr
));
4057 hdr
->hdr
.l2
.id
= QETH_HEADER_TYPE_LAYER2
;
4059 /* set byte 0 to "0x02" and byte 3 to casting flags */
4060 if (cast_type
==RTN_MULTICAST
)
4061 *(__u32
*)hdr
->hdr
.l2
.flags
|= QETH_LAYER2_FLAG_MULTICAST
<< 8;
4062 else if (cast_type
==RTN_BROADCAST
)
4063 *(__u32
*)hdr
->hdr
.l2
.flags
|= QETH_LAYER2_FLAG_BROADCAST
<< 8;
4065 qeth_layer2_get_packet_type(card
, hdr
, skb
);
4067 hdr
->hdr
.l2
.pkt_length
= skb
->len
-QETH_HEADER_SIZE
;
4068 #ifdef CONFIG_QETH_VLAN
4069 /* VSWITCH relies on the VLAN
4070 * information to be present in
4071 * the QDIO header */
4072 if ((card
->vlangrp
!= NULL
) &&
4073 vlan_tx_tag_present(skb
)) {
4074 *(__u32
*)hdr
->hdr
.l2
.flags
|= QETH_LAYER2_FLAG_VLAN
<< 8;
4075 hdr
->hdr
.l2
.vlan_id
= vlan_tx_tag_get(skb
);
4081 qeth_fill_header(struct qeth_card
*card
, struct qeth_hdr
*hdr
,
4082 struct sk_buff
*skb
, int ipv
, int cast_type
)
4084 QETH_DBF_TEXT(trace
, 6, "fillhdr");
4086 memset(hdr
, 0, sizeof(struct qeth_hdr
));
4087 if (card
->options
.layer2
) {
4088 qeth_layer2_fill_header(card
, hdr
, skb
, cast_type
);
4091 hdr
->hdr
.l3
.id
= QETH_HEADER_TYPE_LAYER3
;
4092 hdr
->hdr
.l3
.ext_flags
= 0;
4093 #ifdef CONFIG_QETH_VLAN
4095 * before we're going to overwrite this location with next hop ip.
4096 * v6 uses passthrough, v4 sets the tag in the QDIO header.
4098 if (card
->vlangrp
&& vlan_tx_tag_present(skb
)) {
4099 hdr
->hdr
.l3
.ext_flags
= (ipv
== 4) ?
4100 QETH_HDR_EXT_VLAN_FRAME
:
4101 QETH_HDR_EXT_INCLUDE_VLAN_TAG
;
4102 hdr
->hdr
.l3
.vlan_id
= vlan_tx_tag_get(skb
);
4104 #endif /* CONFIG_QETH_VLAN */
4105 hdr
->hdr
.l3
.length
= skb
->len
- sizeof(struct qeth_hdr
);
4106 if (ipv
== 4) { /* IPv4 */
4107 hdr
->hdr
.l3
.flags
= qeth_get_qeth_hdr_flags4(cast_type
);
4108 memset(hdr
->hdr
.l3
.dest_addr
, 0, 12);
4109 if ((skb
->dst
) && (skb
->dst
->neighbour
)) {
4110 *((u32
*) (&hdr
->hdr
.l3
.dest_addr
[12])) =
4111 *((u32
*) skb
->dst
->neighbour
->primary_key
);
4113 /* fill in destination address used in ip header */
4114 *((u32
*)(&hdr
->hdr
.l3
.dest_addr
[12])) =
4117 } else if (ipv
== 6) { /* IPv6 or passthru */
4118 hdr
->hdr
.l3
.flags
= qeth_get_qeth_hdr_flags6(cast_type
);
4119 if ((skb
->dst
) && (skb
->dst
->neighbour
)) {
4120 memcpy(hdr
->hdr
.l3
.dest_addr
,
4121 skb
->dst
->neighbour
->primary_key
, 16);
4123 /* fill in destination address used in ip header */
4124 memcpy(hdr
->hdr
.l3
.dest_addr
,
4125 &ipv6_hdr(skb
)->daddr
, 16);
4127 } else { /* passthrough */
4128 if((skb
->dev
->type
== ARPHRD_IEEE802_TR
) &&
4129 !memcmp(skb
->data
+ sizeof(struct qeth_hdr
) +
4130 sizeof(__u16
), skb
->dev
->broadcast
, 6)) {
4131 hdr
->hdr
.l3
.flags
= QETH_CAST_BROADCAST
|
4133 } else if (!memcmp(skb
->data
+ sizeof(struct qeth_hdr
),
4134 skb
->dev
->broadcast
, 6)) { /* broadcast? */
4135 hdr
->hdr
.l3
.flags
= QETH_CAST_BROADCAST
|
4138 hdr
->hdr
.l3
.flags
= (cast_type
== RTN_MULTICAST
) ?
4139 QETH_CAST_MULTICAST
| QETH_HDR_PASSTHRU
:
4140 QETH_CAST_UNICAST
| QETH_HDR_PASSTHRU
;
4146 __qeth_fill_buffer(struct sk_buff
*skb
, struct qdio_buffer
*buffer
,
4147 int is_tso
, int *next_element_to_fill
)
4149 int length
= skb
->len
;
4155 element
= *next_element_to_fill
;
4157 first_lap
= (is_tso
== 0 ? 1 : 0);
4159 while (length
> 0) {
4160 /* length_here is the remaining amount of data in this page */
4161 length_here
= PAGE_SIZE
- ((unsigned long) data
% PAGE_SIZE
);
4162 if (length
< length_here
)
4163 length_here
= length
;
4165 buffer
->element
[element
].addr
= data
;
4166 buffer
->element
[element
].length
= length_here
;
4167 length
-= length_here
;
4170 buffer
->element
[element
].flags
= 0;
4172 buffer
->element
[element
].flags
=
4173 SBAL_FLAGS_LAST_FRAG
;
4176 buffer
->element
[element
].flags
=
4177 SBAL_FLAGS_FIRST_FRAG
;
4179 buffer
->element
[element
].flags
=
4180 SBAL_FLAGS_MIDDLE_FRAG
;
4182 data
+= length_here
;
4186 *next_element_to_fill
= element
;
4190 qeth_fill_buffer(struct qeth_qdio_out_q
*queue
,
4191 struct qeth_qdio_out_buffer
*buf
,
4192 struct sk_buff
*skb
)
4194 struct qdio_buffer
*buffer
;
4195 struct qeth_hdr_tso
*hdr
;
4196 int flush_cnt
= 0, hdr_len
, large_send
= 0;
4198 QETH_DBF_TEXT(trace
, 6, "qdfillbf");
4200 buffer
= buf
->buffer
;
4201 atomic_inc(&skb
->users
);
4202 skb_queue_tail(&buf
->skb_list
, skb
);
4204 hdr
= (struct qeth_hdr_tso
*) skb
->data
;
4205 /*check first on TSO ....*/
4206 if (hdr
->hdr
.hdr
.l3
.id
== QETH_HEADER_TYPE_TSO
) {
4207 int element
= buf
->next_element_to_fill
;
4209 hdr_len
= sizeof(struct qeth_hdr_tso
) + hdr
->ext
.dg_hdr_len
;
4210 /*fill first buffer entry only with header information */
4211 buffer
->element
[element
].addr
= skb
->data
;
4212 buffer
->element
[element
].length
= hdr_len
;
4213 buffer
->element
[element
].flags
= SBAL_FLAGS_FIRST_FRAG
;
4214 buf
->next_element_to_fill
++;
4215 skb
->data
+= hdr_len
;
4216 skb
->len
-= hdr_len
;
4219 if (skb_shinfo(skb
)->nr_frags
== 0)
4220 __qeth_fill_buffer(skb
, buffer
, large_send
,
4221 (int *)&buf
->next_element_to_fill
);
4223 __qeth_fill_buffer_frag(skb
, buffer
, large_send
,
4224 (int *)&buf
->next_element_to_fill
);
4226 if (!queue
->do_pack
) {
4227 QETH_DBF_TEXT(trace
, 6, "fillbfnp");
4228 /* set state to PRIMED -> will be flushed */
4229 atomic_set(&buf
->state
, QETH_QDIO_BUF_PRIMED
);
4232 QETH_DBF_TEXT(trace
, 6, "fillbfpa");
4233 if (queue
->card
->options
.performance_stats
)
4234 queue
->card
->perf_stats
.skbs_sent_pack
++;
4235 if (buf
->next_element_to_fill
>=
4236 QETH_MAX_BUFFER_ELEMENTS(queue
->card
)) {
4238 * packed buffer if full -> set state PRIMED
4239 * -> will be flushed
4241 atomic_set(&buf
->state
, QETH_QDIO_BUF_PRIMED
);
4249 qeth_do_send_packet_fast(struct qeth_card
*card
, struct qeth_qdio_out_q
*queue
,
4250 struct sk_buff
*skb
, struct qeth_hdr
*hdr
,
4251 int elements_needed
,
4252 struct qeth_eddp_context
*ctx
)
4254 struct qeth_qdio_out_buffer
*buffer
;
4255 int buffers_needed
= 0;
4259 QETH_DBF_TEXT(trace
, 6, "dosndpfa");
4261 /* spin until we get the queue ... */
4262 while (atomic_cmpxchg(&queue
->state
, QETH_OUT_Q_UNLOCKED
,
4263 QETH_OUT_Q_LOCKED
) != QETH_OUT_Q_UNLOCKED
);
4264 /* ... now we've got the queue */
4265 index
= queue
->next_buf_to_fill
;
4266 buffer
= &queue
->bufs
[queue
->next_buf_to_fill
];
4268 * check if buffer is empty to make sure that we do not 'overtake'
4269 * ourselves and try to fill a buffer that is already primed
4271 if (atomic_read(&buffer
->state
) != QETH_QDIO_BUF_EMPTY
)
4274 queue
->next_buf_to_fill
= (queue
->next_buf_to_fill
+ 1) %
4275 QDIO_MAX_BUFFERS_PER_Q
;
4277 buffers_needed
= qeth_eddp_check_buffers_for_context(queue
,ctx
);
4278 if (buffers_needed
< 0)
4280 queue
->next_buf_to_fill
=
4281 (queue
->next_buf_to_fill
+ buffers_needed
) %
4282 QDIO_MAX_BUFFERS_PER_Q
;
4284 atomic_set(&queue
->state
, QETH_OUT_Q_UNLOCKED
);
4286 qeth_fill_buffer(queue
, buffer
, skb
);
4287 qeth_flush_buffers(queue
, 0, index
, 1);
4289 flush_cnt
= qeth_eddp_fill_buffer(queue
, ctx
, index
);
4290 WARN_ON(buffers_needed
!= flush_cnt
);
4291 qeth_flush_buffers(queue
, 0, index
, flush_cnt
);
4295 atomic_set(&queue
->state
, QETH_OUT_Q_UNLOCKED
);
4300 qeth_do_send_packet(struct qeth_card
*card
, struct qeth_qdio_out_q
*queue
,
4301 struct sk_buff
*skb
, struct qeth_hdr
*hdr
,
4302 int elements_needed
, struct qeth_eddp_context
*ctx
)
4304 struct qeth_qdio_out_buffer
*buffer
;
4306 int flush_count
= 0;
4311 QETH_DBF_TEXT(trace
, 6, "dosndpkt");
4313 /* spin until we get the queue ... */
4314 while (atomic_cmpxchg(&queue
->state
, QETH_OUT_Q_UNLOCKED
,
4315 QETH_OUT_Q_LOCKED
) != QETH_OUT_Q_UNLOCKED
);
4316 start_index
= queue
->next_buf_to_fill
;
4317 buffer
= &queue
->bufs
[queue
->next_buf_to_fill
];
4319 * check if buffer is empty to make sure that we do not 'overtake'
4320 * ourselves and try to fill a buffer that is already primed
4322 if (atomic_read(&buffer
->state
) != QETH_QDIO_BUF_EMPTY
) {
4323 atomic_set(&queue
->state
, QETH_OUT_Q_UNLOCKED
);
4326 /* check if we need to switch packing state of this queue */
4327 qeth_switch_to_packing_if_needed(queue
);
4328 if (queue
->do_pack
){
4331 /* does packet fit in current buffer? */
4332 if((QETH_MAX_BUFFER_ELEMENTS(card
) -
4333 buffer
->next_element_to_fill
) < elements_needed
){
4334 /* ... no -> set state PRIMED */
4335 atomic_set(&buffer
->state
,QETH_QDIO_BUF_PRIMED
);
4337 queue
->next_buf_to_fill
=
4338 (queue
->next_buf_to_fill
+ 1) %
4339 QDIO_MAX_BUFFERS_PER_Q
;
4340 buffer
= &queue
->bufs
[queue
->next_buf_to_fill
];
4341 /* we did a step forward, so check buffer state
4343 if (atomic_read(&buffer
->state
) !=
4344 QETH_QDIO_BUF_EMPTY
){
4345 qeth_flush_buffers(queue
, 0, start_index
, flush_count
);
4346 atomic_set(&queue
->state
, QETH_OUT_Q_UNLOCKED
);
4351 /* check if we have enough elements (including following
4352 * free buffers) to handle eddp context */
4353 if (qeth_eddp_check_buffers_for_context(queue
,ctx
) < 0){
4354 printk("eddp tx_dropped 1\n");
4361 tmp
= qeth_fill_buffer(queue
, buffer
, skb
);
4363 tmp
= qeth_eddp_fill_buffer(queue
,ctx
,queue
->next_buf_to_fill
);
4365 printk("eddp tx_dropped 2\n");
4370 queue
->next_buf_to_fill
= (queue
->next_buf_to_fill
+ tmp
) %
4371 QDIO_MAX_BUFFERS_PER_Q
;
4375 qeth_flush_buffers(queue
, 0, start_index
, flush_count
);
4376 else if (!atomic_read(&queue
->set_pci_flags_count
))
4377 atomic_xchg(&queue
->state
, QETH_OUT_Q_LOCKED_FLUSH
);
4379 * queue->state will go from LOCKED -> UNLOCKED or from
4380 * LOCKED_FLUSH -> LOCKED if output_handler wanted to 'notify' us
4381 * (switch packing state or flush buffer to get another pci flag out).
4382 * In that case we will enter this loop
4384 while (atomic_dec_return(&queue
->state
)){
4386 start_index
= queue
->next_buf_to_fill
;
4387 /* check if we can go back to non-packing state */
4388 flush_count
+= qeth_switch_to_nonpacking_if_needed(queue
);
4390 * check if we need to flush a packing buffer to get a pci
4391 * flag out on the queue
4393 if (!flush_count
&& !atomic_read(&queue
->set_pci_flags_count
))
4394 flush_count
+= qeth_flush_buffers_on_no_pci(queue
);
4396 qeth_flush_buffers(queue
, 0, start_index
, flush_count
);
4398 /* at this point the queue is UNLOCKED again */
4399 if (queue
->card
->options
.performance_stats
&& do_pack
)
4400 queue
->card
->perf_stats
.bufs_sent_pack
+= flush_count
;
4406 qeth_get_elements_no(struct qeth_card
*card
, void *hdr
,
4407 struct sk_buff
*skb
, int elems
)
4409 int elements_needed
= 0;
4411 if (skb_shinfo(skb
)->nr_frags
> 0)
4412 elements_needed
= (skb_shinfo(skb
)->nr_frags
+ 1);
4413 if (elements_needed
== 0)
4414 elements_needed
= 1 + (((((unsigned long) hdr
) % PAGE_SIZE
)
4415 + skb
->len
) >> PAGE_SHIFT
);
4416 if ((elements_needed
+ elems
) > QETH_MAX_BUFFER_ELEMENTS(card
)){
4417 PRINT_ERR("Invalid size of IP packet "
4418 "(Number=%d / Length=%d). Discarded.\n",
4419 (elements_needed
+elems
), skb
->len
);
4422 return elements_needed
;
4427 qeth_send_packet(struct qeth_card
*card
, struct sk_buff
*skb
)
4431 struct qeth_qdio_out_q
*queue
;
4432 struct qeth_hdr
*hdr
= NULL
;
4433 int elements_needed
= 0;
4434 enum qeth_large_send_types large_send
= QETH_LARGE_SEND_NO
;
4435 struct qeth_eddp_context
*ctx
= NULL
;
4436 int tx_bytes
= skb
->len
;
4437 unsigned short nr_frags
= skb_shinfo(skb
)->nr_frags
;
4438 unsigned short tso_size
= skb_shinfo(skb
)->gso_size
;
4439 struct sk_buff
*new_skb
, *new_skb2
;
4442 QETH_DBF_TEXT(trace
, 6, "sendpkt");
4445 if ((card
->info
.type
== QETH_CARD_TYPE_OSN
) &&
4446 (skb
->protocol
== htons(ETH_P_IPV6
)))
4448 cast_type
= qeth_get_cast_type(card
, skb
);
4449 if ((cast_type
== RTN_BROADCAST
) &&
4450 (card
->info
.broadcast_capable
== 0))
4452 queue
= card
->qdio
.out_qs
4453 [qeth_get_priority_queue(card
, skb
, ipv
, cast_type
)];
4454 if (!card
->options
.layer2
) {
4455 ipv
= qeth_get_ip_version(skb
);
4456 if ((card
->dev
->hard_header
== qeth_fake_header
) && ipv
) {
4457 new_skb
= qeth_pskb_unshare(skb
, GFP_ATOMIC
);
4460 if(card
->dev
->type
== ARPHRD_IEEE802_TR
){
4461 skb_pull(new_skb
, QETH_FAKE_LL_LEN_TR
);
4463 skb_pull(new_skb
, QETH_FAKE_LL_LEN_ETH
);
4467 if (skb_is_gso(skb
))
4468 large_send
= card
->options
.large_send
;
4469 /* check on OSN device*/
4470 if (card
->info
.type
== QETH_CARD_TYPE_OSN
)
4471 hdr
= (struct qeth_hdr
*)new_skb
->data
;
4472 /*are we able to do TSO ? */
4473 if ((large_send
== QETH_LARGE_SEND_TSO
) &&
4474 (cast_type
== RTN_UNSPEC
)) {
4475 rc
= qeth_tso_prepare_packet(card
, new_skb
, ipv
, cast_type
);
4477 __qeth_free_new_skb(skb
, new_skb
);
4481 } else if (card
->info
.type
!= QETH_CARD_TYPE_OSN
) {
4482 new_skb2
= qeth_prepare_skb(card
, new_skb
, &hdr
, ipv
);
4484 __qeth_free_new_skb(skb
, new_skb
);
4488 __qeth_free_new_skb(new_skb2
, new_skb
);
4490 qeth_fill_header(card
, hdr
, new_skb
, ipv
, cast_type
);
4492 if (large_send
== QETH_LARGE_SEND_EDDP
) {
4493 ctx
= qeth_eddp_create_context(card
, new_skb
, hdr
);
4495 __qeth_free_new_skb(skb
, new_skb
);
4496 PRINT_WARN("could not create eddp context\n");
4500 int elems
= qeth_get_elements_no(card
,(void*) hdr
, new_skb
,
4503 __qeth_free_new_skb(skb
, new_skb
);
4506 elements_needed
+= elems
;
4509 if (card
->info
.type
!= QETH_CARD_TYPE_IQD
)
4510 rc
= qeth_do_send_packet(card
, queue
, new_skb
, hdr
,
4511 elements_needed
, ctx
);
4513 rc
= qeth_do_send_packet_fast(card
, queue
, new_skb
, hdr
,
4514 elements_needed
, ctx
);
4516 card
->stats
.tx_packets
++;
4517 card
->stats
.tx_bytes
+= tx_bytes
;
4519 dev_kfree_skb_any(skb
);
4520 if (card
->options
.performance_stats
) {
4522 !(large_send
== QETH_LARGE_SEND_NO
)) {
4523 card
->perf_stats
.large_send_bytes
+= tx_bytes
;
4524 card
->perf_stats
.large_send_cnt
++;
4527 card
->perf_stats
.sg_skbs_sent
++;
4528 /* nr_frags + skb->data */
4529 card
->perf_stats
.sg_frags_sent
+=
4534 card
->stats
.tx_dropped
++;
4535 __qeth_free_new_skb(skb
, new_skb
);
4538 /* drop creator's reference */
4539 qeth_eddp_put_context(ctx
);
4540 /* free skb; it's not referenced by a buffer */
4542 dev_kfree_skb_any(new_skb
);
4548 qeth_mdio_read(struct net_device
*dev
, int phy_id
, int regnum
)
4550 struct qeth_card
*card
= (struct qeth_card
*) dev
->priv
;
4554 case MII_BMCR
: /* Basic mode control register */
4556 if ((card
->info
.link_type
!= QETH_LINK_TYPE_GBIT_ETH
)&&
4557 (card
->info
.link_type
!= QETH_LINK_TYPE_OSN
) &&
4558 (card
->info
.link_type
!= QETH_LINK_TYPE_10GBIT_ETH
))
4559 rc
|= BMCR_SPEED100
;
4561 case MII_BMSR
: /* Basic mode status register */
4562 rc
= BMSR_ERCAP
| BMSR_ANEGCOMPLETE
| BMSR_LSTATUS
|
4563 BMSR_10HALF
| BMSR_10FULL
| BMSR_100HALF
| BMSR_100FULL
|
4566 case MII_PHYSID1
: /* PHYS ID 1 */
4567 rc
= (dev
->dev_addr
[0] << 16) | (dev
->dev_addr
[1] << 8) |
4569 rc
= (rc
>> 5) & 0xFFFF;
4571 case MII_PHYSID2
: /* PHYS ID 2 */
4572 rc
= (dev
->dev_addr
[2] << 10) & 0xFFFF;
4574 case MII_ADVERTISE
: /* Advertisement control reg */
4577 case MII_LPA
: /* Link partner ability reg */
4578 rc
= LPA_10HALF
| LPA_10FULL
| LPA_100HALF
| LPA_100FULL
|
4579 LPA_100BASE4
| LPA_LPACK
;
4581 case MII_EXPANSION
: /* Expansion register */
4583 case MII_DCOUNTER
: /* disconnect counter */
4585 case MII_FCSCOUNTER
: /* false carrier counter */
4587 case MII_NWAYTEST
: /* N-way auto-neg test register */
4589 case MII_RERRCOUNTER
: /* rx error counter */
4590 rc
= card
->stats
.rx_errors
;
4592 case MII_SREVISION
: /* silicon revision */
4594 case MII_RESV1
: /* reserved 1 */
4596 case MII_LBRERROR
: /* loopback, rx, bypass error */
4598 case MII_PHYADDR
: /* physical address */
4600 case MII_RESV2
: /* reserved 2 */
4602 case MII_TPISTATUS
: /* TPI status for 10mbps */
4604 case MII_NCONFIG
: /* network interface config */
4614 qeth_arp_get_error_cause(int *rc
)
4617 case QETH_IPA_ARP_RC_FAILED
:
4619 return "operation failed";
4620 case QETH_IPA_ARP_RC_NOTSUPP
:
4622 return "operation not supported";
4623 case QETH_IPA_ARP_RC_OUT_OF_RANGE
:
4625 return "argument out of range";
4626 case QETH_IPA_ARP_RC_Q_NOTSUPP
:
4628 return "query operation not supported";
4629 case QETH_IPA_ARP_RC_Q_NO_DATA
:
4631 return "no query data available";
4633 return "unknown error";
4638 qeth_send_simple_setassparms(struct qeth_card
*, enum qeth_ipa_funcs
,
4642 qeth_arp_set_no_entries(struct qeth_card
*card
, int no_entries
)
4647 QETH_DBF_TEXT(trace
,3,"arpstnoe");
4650 * currently GuestLAN only supports the ARP assist function
4651 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
4652 * thus we say EOPNOTSUPP for this ARP function
4654 if (card
->info
.guestlan
)
4656 if (!qeth_is_supported(card
,IPA_ARP_PROCESSING
)) {
4657 PRINT_WARN("ARP processing not supported "
4658 "on %s!\n", QETH_CARD_IFNAME(card
));
4661 rc
= qeth_send_simple_setassparms(card
, IPA_ARP_PROCESSING
,
4662 IPA_CMD_ASS_ARP_SET_NO_ENTRIES
,
4666 PRINT_WARN("Could not set number of ARP entries on %s: "
4668 QETH_CARD_IFNAME(card
), qeth_arp_get_error_cause(&rc
),
4675 qeth_copy_arp_entries_stripped(struct qeth_arp_query_info
*qinfo
,
4676 struct qeth_arp_query_data
*qdata
,
4677 int entry_size
, int uentry_size
)
4683 entry_ptr
= (char *)&qdata
->data
;
4684 uentry_ptr
= (char *)(qinfo
->udata
+ qinfo
->udata_offset
);
4685 for (i
= 0; i
< qdata
->no_entries
; ++i
){
4686 /* strip off 32 bytes "media specific information" */
4687 memcpy(uentry_ptr
, (entry_ptr
+ 32), entry_size
- 32);
4688 entry_ptr
+= entry_size
;
4689 uentry_ptr
+= uentry_size
;
4694 qeth_arp_query_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
4697 struct qeth_ipa_cmd
*cmd
;
4698 struct qeth_arp_query_data
*qdata
;
4699 struct qeth_arp_query_info
*qinfo
;
4704 QETH_DBF_TEXT(trace
,4,"arpquecb");
4706 qinfo
= (struct qeth_arp_query_info
*) reply
->param
;
4707 cmd
= (struct qeth_ipa_cmd
*) data
;
4708 if (cmd
->hdr
.return_code
) {
4709 QETH_DBF_TEXT_(trace
,4,"qaer1%i", cmd
->hdr
.return_code
);
4712 if (cmd
->data
.setassparms
.hdr
.return_code
) {
4713 cmd
->hdr
.return_code
= cmd
->data
.setassparms
.hdr
.return_code
;
4714 QETH_DBF_TEXT_(trace
,4,"qaer2%i", cmd
->hdr
.return_code
);
4717 qdata
= &cmd
->data
.setassparms
.data
.query_arp
;
4718 switch(qdata
->reply_bits
){
4720 uentry_size
= entry_size
= sizeof(struct qeth_arp_qi_entry5
);
4721 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
)
4722 uentry_size
= sizeof(struct qeth_arp_qi_entry5_short
);
4725 /* fall through to default */
4727 /* tr is the same as eth -> entry7 */
4728 uentry_size
= entry_size
= sizeof(struct qeth_arp_qi_entry7
);
4729 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
)
4730 uentry_size
= sizeof(struct qeth_arp_qi_entry7_short
);
4733 /* check if there is enough room in userspace */
4734 if ((qinfo
->udata_len
- qinfo
->udata_offset
) <
4735 qdata
->no_entries
* uentry_size
){
4736 QETH_DBF_TEXT_(trace
, 4, "qaer3%i", -ENOMEM
);
4737 cmd
->hdr
.return_code
= -ENOMEM
;
4738 PRINT_WARN("query ARP user space buffer is too small for "
4739 "the returned number of ARP entries. "
4740 "Aborting query!\n");
4743 QETH_DBF_TEXT_(trace
, 4, "anore%i",
4744 cmd
->data
.setassparms
.hdr
.number_of_replies
);
4745 QETH_DBF_TEXT_(trace
, 4, "aseqn%i", cmd
->data
.setassparms
.hdr
.seq_no
);
4746 QETH_DBF_TEXT_(trace
, 4, "anoen%i", qdata
->no_entries
);
4748 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
) {
4749 /* strip off "media specific information" */
4750 qeth_copy_arp_entries_stripped(qinfo
, qdata
, entry_size
,
4753 /*copy entries to user buffer*/
4754 memcpy(qinfo
->udata
+ qinfo
->udata_offset
,
4755 (char *)&qdata
->data
, qdata
->no_entries
*uentry_size
);
4757 qinfo
->no_entries
+= qdata
->no_entries
;
4758 qinfo
->udata_offset
+= (qdata
->no_entries
*uentry_size
);
4759 /* check if all replies received ... */
4760 if (cmd
->data
.setassparms
.hdr
.seq_no
<
4761 cmd
->data
.setassparms
.hdr
.number_of_replies
)
4763 memcpy(qinfo
->udata
, &qinfo
->no_entries
, 4);
4764 /* keep STRIP_ENTRIES flag so the user program can distinguish
4765 * stripped entries from normal ones */
4766 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
)
4767 qdata
->reply_bits
|= QETH_QARP_STRIP_ENTRIES
;
4768 memcpy(qinfo
->udata
+ QETH_QARP_MASK_OFFSET
,&qdata
->reply_bits
,2);
4772 memcpy(qinfo
->udata
, &i
, 4);
4777 qeth_send_ipa_arp_cmd(struct qeth_card
*card
, struct qeth_cmd_buffer
*iob
,
4778 int len
, int (*reply_cb
)(struct qeth_card
*,
4779 struct qeth_reply
*,
4783 QETH_DBF_TEXT(trace
,4,"sendarp");
4785 memcpy(iob
->data
, IPA_PDU_HEADER
, IPA_PDU_HEADER_SIZE
);
4786 memcpy(QETH_IPA_CMD_DEST_ADDR(iob
->data
),
4787 &card
->token
.ulp_connection_r
, QETH_MPC_TOKEN_LENGTH
);
4788 return qeth_send_control_data(card
, IPA_PDU_HEADER_SIZE
+ len
, iob
,
4789 reply_cb
, reply_param
);
4793 qeth_send_ipa_snmp_cmd(struct qeth_card
*card
, struct qeth_cmd_buffer
*iob
,
4794 int len
, int (*reply_cb
)(struct qeth_card
*,
4795 struct qeth_reply
*,
4801 QETH_DBF_TEXT(trace
,4,"sendsnmp");
4803 memcpy(iob
->data
, IPA_PDU_HEADER
, IPA_PDU_HEADER_SIZE
);
4804 memcpy(QETH_IPA_CMD_DEST_ADDR(iob
->data
),
4805 &card
->token
.ulp_connection_r
, QETH_MPC_TOKEN_LENGTH
);
4806 /* adjust PDU length fields in IPA_PDU_HEADER */
4807 s1
= (u32
) IPA_PDU_HEADER_SIZE
+ len
;
4809 memcpy(QETH_IPA_PDU_LEN_TOTAL(iob
->data
), &s1
, 2);
4810 memcpy(QETH_IPA_PDU_LEN_PDU1(iob
->data
), &s2
, 2);
4811 memcpy(QETH_IPA_PDU_LEN_PDU2(iob
->data
), &s2
, 2);
4812 memcpy(QETH_IPA_PDU_LEN_PDU3(iob
->data
), &s2
, 2);
4813 return qeth_send_control_data(card
, IPA_PDU_HEADER_SIZE
+ len
, iob
,
4814 reply_cb
, reply_param
);
4817 static struct qeth_cmd_buffer
*
4818 qeth_get_setassparms_cmd(struct qeth_card
*, enum qeth_ipa_funcs
,
4819 __u16
, __u16
, enum qeth_prot_versions
);
4821 qeth_arp_query(struct qeth_card
*card
, char __user
*udata
)
4823 struct qeth_cmd_buffer
*iob
;
4824 struct qeth_arp_query_info qinfo
= {0, };
4828 QETH_DBF_TEXT(trace
,3,"arpquery");
4830 if (!qeth_is_supported(card
,/*IPA_QUERY_ARP_ADDR_INFO*/
4831 IPA_ARP_PROCESSING
)) {
4832 PRINT_WARN("ARP processing not supported "
4833 "on %s!\n", QETH_CARD_IFNAME(card
));
4836 /* get size of userspace buffer and mask_bits -> 6 bytes */
4837 if (copy_from_user(&qinfo
, udata
, 6))
4839 if (!(qinfo
.udata
= kzalloc(qinfo
.udata_len
, GFP_KERNEL
)))
4841 qinfo
.udata_offset
= QETH_QARP_ENTRIES_OFFSET
;
4842 iob
= qeth_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
,
4843 IPA_CMD_ASS_ARP_QUERY_INFO
,
4844 sizeof(int),QETH_PROT_IPV4
);
4846 rc
= qeth_send_ipa_arp_cmd(card
, iob
,
4847 QETH_SETASS_BASE_LEN
+QETH_ARP_CMD_LEN
,
4848 qeth_arp_query_cb
, (void *)&qinfo
);
4851 PRINT_WARN("Error while querying ARP cache on %s: %s "
4853 QETH_CARD_IFNAME(card
), qeth_arp_get_error_cause(&rc
),
4855 if (copy_to_user(udata
, qinfo
.udata
, 4))
4858 if (copy_to_user(udata
, qinfo
.udata
, qinfo
.udata_len
))
4866 * SNMP command callback
4869 qeth_snmp_command_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
4870 unsigned long sdata
)
4872 struct qeth_ipa_cmd
*cmd
;
4873 struct qeth_arp_query_info
*qinfo
;
4874 struct qeth_snmp_cmd
*snmp
;
4875 unsigned char *data
;
4878 QETH_DBF_TEXT(trace
,3,"snpcmdcb");
4880 cmd
= (struct qeth_ipa_cmd
*) sdata
;
4881 data
= (unsigned char *)((char *)cmd
- reply
->offset
);
4882 qinfo
= (struct qeth_arp_query_info
*) reply
->param
;
4883 snmp
= &cmd
->data
.setadapterparms
.data
.snmp
;
4885 if (cmd
->hdr
.return_code
) {
4886 QETH_DBF_TEXT_(trace
,4,"scer1%i", cmd
->hdr
.return_code
);
4889 if (cmd
->data
.setadapterparms
.hdr
.return_code
) {
4890 cmd
->hdr
.return_code
= cmd
->data
.setadapterparms
.hdr
.return_code
;
4891 QETH_DBF_TEXT_(trace
,4,"scer2%i", cmd
->hdr
.return_code
);
4894 data_len
= *((__u16
*)QETH_IPA_PDU_LEN_PDU1(data
));
4895 if (cmd
->data
.setadapterparms
.hdr
.seq_no
== 1)
4896 data_len
-= (__u16
)((char *)&snmp
->data
- (char *)cmd
);
4898 data_len
-= (__u16
)((char*)&snmp
->request
- (char *)cmd
);
4900 /* check if there is enough room in userspace */
4901 if ((qinfo
->udata_len
- qinfo
->udata_offset
) < data_len
) {
4902 QETH_DBF_TEXT_(trace
, 4, "scer3%i", -ENOMEM
);
4903 cmd
->hdr
.return_code
= -ENOMEM
;
4906 QETH_DBF_TEXT_(trace
, 4, "snore%i",
4907 cmd
->data
.setadapterparms
.hdr
.used_total
);
4908 QETH_DBF_TEXT_(trace
, 4, "sseqn%i", cmd
->data
.setadapterparms
.hdr
.seq_no
);
4909 /*copy entries to user buffer*/
4910 if (cmd
->data
.setadapterparms
.hdr
.seq_no
== 1) {
4911 memcpy(qinfo
->udata
+ qinfo
->udata_offset
,
4913 data_len
+ offsetof(struct qeth_snmp_cmd
,data
));
4914 qinfo
->udata_offset
+= offsetof(struct qeth_snmp_cmd
, data
);
4916 memcpy(qinfo
->udata
+ qinfo
->udata_offset
,
4917 (char *)&snmp
->request
, data_len
);
4919 qinfo
->udata_offset
+= data_len
;
4920 /* check if all replies received ... */
4921 QETH_DBF_TEXT_(trace
, 4, "srtot%i",
4922 cmd
->data
.setadapterparms
.hdr
.used_total
);
4923 QETH_DBF_TEXT_(trace
, 4, "srseq%i",
4924 cmd
->data
.setadapterparms
.hdr
.seq_no
);
4925 if (cmd
->data
.setadapterparms
.hdr
.seq_no
<
4926 cmd
->data
.setadapterparms
.hdr
.used_total
)
4931 static struct qeth_cmd_buffer
*
4932 qeth_get_ipacmd_buffer(struct qeth_card
*, enum qeth_ipa_cmds
,
4933 enum qeth_prot_versions
);
4935 static struct qeth_cmd_buffer
*
4936 qeth_get_adapter_cmd(struct qeth_card
*card
, __u32 command
, __u32 cmdlen
)
4938 struct qeth_cmd_buffer
*iob
;
4939 struct qeth_ipa_cmd
*cmd
;
4941 iob
= qeth_get_ipacmd_buffer(card
,IPA_CMD_SETADAPTERPARMS
,
4943 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
4944 cmd
->data
.setadapterparms
.hdr
.cmdlength
= cmdlen
;
4945 cmd
->data
.setadapterparms
.hdr
.command_code
= command
;
4946 cmd
->data
.setadapterparms
.hdr
.used_total
= 1;
4947 cmd
->data
.setadapterparms
.hdr
.seq_no
= 1;
4953 * function to send SNMP commands to OSA-E card
4956 qeth_snmp_command(struct qeth_card
*card
, char __user
*udata
)
4958 struct qeth_cmd_buffer
*iob
;
4959 struct qeth_ipa_cmd
*cmd
;
4960 struct qeth_snmp_ureq
*ureq
;
4962 struct qeth_arp_query_info qinfo
= {0, };
4965 QETH_DBF_TEXT(trace
,3,"snmpcmd");
4967 if (card
->info
.guestlan
)
4970 if ((!qeth_adp_supported(card
,IPA_SETADP_SET_SNMP_CONTROL
)) &&
4971 (!card
->options
.layer2
) ) {
4972 PRINT_WARN("SNMP Query MIBS not supported "
4973 "on %s!\n", QETH_CARD_IFNAME(card
));
4976 /* skip 4 bytes (data_len struct member) to get req_len */
4977 if (copy_from_user(&req_len
, udata
+ sizeof(int), sizeof(int)))
4979 ureq
= kmalloc(req_len
+sizeof(struct qeth_snmp_ureq_hdr
), GFP_KERNEL
);
4981 QETH_DBF_TEXT(trace
, 2, "snmpnome");
4984 if (copy_from_user(ureq
, udata
,
4985 req_len
+sizeof(struct qeth_snmp_ureq_hdr
))){
4989 qinfo
.udata_len
= ureq
->hdr
.data_len
;
4990 if (!(qinfo
.udata
= kzalloc(qinfo
.udata_len
, GFP_KERNEL
))){
4994 qinfo
.udata_offset
= sizeof(struct qeth_snmp_ureq_hdr
);
4996 iob
= qeth_get_adapter_cmd(card
, IPA_SETADP_SET_SNMP_CONTROL
,
4997 QETH_SNMP_SETADP_CMDLENGTH
+ req_len
);
4998 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
4999 memcpy(&cmd
->data
.setadapterparms
.data
.snmp
, &ureq
->cmd
, req_len
);
5000 rc
= qeth_send_ipa_snmp_cmd(card
, iob
, QETH_SETADP_BASE_LEN
+ req_len
,
5001 qeth_snmp_command_cb
, (void *)&qinfo
);
5003 PRINT_WARN("SNMP command failed on %s: (0x%x)\n",
5004 QETH_CARD_IFNAME(card
), rc
);
5006 if (copy_to_user(udata
, qinfo
.udata
, qinfo
.udata_len
))
5016 qeth_default_setassparms_cb(struct qeth_card
*, struct qeth_reply
*,
5020 qeth_default_setadapterparms_cb(struct qeth_card
*card
,
5021 struct qeth_reply
*reply
,
5022 unsigned long data
);
5024 qeth_send_setassparms(struct qeth_card
*, struct qeth_cmd_buffer
*,
5027 (struct qeth_card
*, struct qeth_reply
*, unsigned long),
5031 qeth_arp_add_entry(struct qeth_card
*card
, struct qeth_arp_cache_entry
*entry
)
5033 struct qeth_cmd_buffer
*iob
;
5038 QETH_DBF_TEXT(trace
,3,"arpadent");
5041 * currently GuestLAN only supports the ARP assist function
5042 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
5043 * thus we say EOPNOTSUPP for this ARP function
5045 if (card
->info
.guestlan
)
5047 if (!qeth_is_supported(card
,IPA_ARP_PROCESSING
)) {
5048 PRINT_WARN("ARP processing not supported "
5049 "on %s!\n", QETH_CARD_IFNAME(card
));
5053 iob
= qeth_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
,
5054 IPA_CMD_ASS_ARP_ADD_ENTRY
,
5055 sizeof(struct qeth_arp_cache_entry
),
5057 rc
= qeth_send_setassparms(card
, iob
,
5058 sizeof(struct qeth_arp_cache_entry
),
5059 (unsigned long) entry
,
5060 qeth_default_setassparms_cb
, NULL
);
5063 qeth_ipaddr4_to_string((u8
*)entry
->ipaddr
, buf
);
5064 PRINT_WARN("Could not add ARP entry for address %s on %s: "
5066 buf
, QETH_CARD_IFNAME(card
),
5067 qeth_arp_get_error_cause(&rc
), tmp
, tmp
);
5073 qeth_arp_remove_entry(struct qeth_card
*card
, struct qeth_arp_cache_entry
*entry
)
5075 struct qeth_cmd_buffer
*iob
;
5076 char buf
[16] = {0, };
5080 QETH_DBF_TEXT(trace
,3,"arprment");
5083 * currently GuestLAN only supports the ARP assist function
5084 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_REMOVE_ENTRY;
5085 * thus we say EOPNOTSUPP for this ARP function
5087 if (card
->info
.guestlan
)
5089 if (!qeth_is_supported(card
,IPA_ARP_PROCESSING
)) {
5090 PRINT_WARN("ARP processing not supported "
5091 "on %s!\n", QETH_CARD_IFNAME(card
));
5094 memcpy(buf
, entry
, 12);
5095 iob
= qeth_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
,
5096 IPA_CMD_ASS_ARP_REMOVE_ENTRY
,
5099 rc
= qeth_send_setassparms(card
, iob
,
5100 12, (unsigned long)buf
,
5101 qeth_default_setassparms_cb
, NULL
);
5105 qeth_ipaddr4_to_string((u8
*)entry
->ipaddr
, buf
);
5106 PRINT_WARN("Could not delete ARP entry for address %s on %s: "
5108 buf
, QETH_CARD_IFNAME(card
),
5109 qeth_arp_get_error_cause(&rc
), tmp
, tmp
);
5115 qeth_arp_flush_cache(struct qeth_card
*card
)
5120 QETH_DBF_TEXT(trace
,3,"arpflush");
5123 * currently GuestLAN only supports the ARP assist function
5124 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
5125 * thus we say EOPNOTSUPP for this ARP function
5127 if (card
->info
.guestlan
|| (card
->info
.type
== QETH_CARD_TYPE_IQD
))
5129 if (!qeth_is_supported(card
,IPA_ARP_PROCESSING
)) {
5130 PRINT_WARN("ARP processing not supported "
5131 "on %s!\n", QETH_CARD_IFNAME(card
));
5134 rc
= qeth_send_simple_setassparms(card
, IPA_ARP_PROCESSING
,
5135 IPA_CMD_ASS_ARP_FLUSH_CACHE
, 0);
5138 PRINT_WARN("Could not flush ARP cache on %s: %s (0x%x/%d)\n",
5139 QETH_CARD_IFNAME(card
), qeth_arp_get_error_cause(&rc
),
5146 qeth_do_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
5148 struct qeth_card
*card
= (struct qeth_card
*)dev
->priv
;
5149 struct qeth_arp_cache_entry arp_entry
;
5150 struct mii_ioctl_data
*mii_data
;
5156 if ((card
->state
!= CARD_STATE_UP
) &&
5157 (card
->state
!= CARD_STATE_SOFTSETUP
))
5160 if (card
->info
.type
== QETH_CARD_TYPE_OSN
)
5164 case SIOC_QETH_ARP_SET_NO_ENTRIES
:
5165 if ( !capable(CAP_NET_ADMIN
) ||
5166 (card
->options
.layer2
) ) {
5170 rc
= qeth_arp_set_no_entries(card
, rq
->ifr_ifru
.ifru_ivalue
);
5172 case SIOC_QETH_ARP_QUERY_INFO
:
5173 if ( !capable(CAP_NET_ADMIN
) ||
5174 (card
->options
.layer2
) ) {
5178 rc
= qeth_arp_query(card
, rq
->ifr_ifru
.ifru_data
);
5180 case SIOC_QETH_ARP_ADD_ENTRY
:
5181 if ( !capable(CAP_NET_ADMIN
) ||
5182 (card
->options
.layer2
) ) {
5186 if (copy_from_user(&arp_entry
, rq
->ifr_ifru
.ifru_data
,
5187 sizeof(struct qeth_arp_cache_entry
)))
5190 rc
= qeth_arp_add_entry(card
, &arp_entry
);
5192 case SIOC_QETH_ARP_REMOVE_ENTRY
:
5193 if ( !capable(CAP_NET_ADMIN
) ||
5194 (card
->options
.layer2
) ) {
5198 if (copy_from_user(&arp_entry
, rq
->ifr_ifru
.ifru_data
,
5199 sizeof(struct qeth_arp_cache_entry
)))
5202 rc
= qeth_arp_remove_entry(card
, &arp_entry
);
5204 case SIOC_QETH_ARP_FLUSH_CACHE
:
5205 if ( !capable(CAP_NET_ADMIN
) ||
5206 (card
->options
.layer2
) ) {
5210 rc
= qeth_arp_flush_cache(card
);
5212 case SIOC_QETH_ADP_SET_SNMP_CONTROL
:
5213 rc
= qeth_snmp_command(card
, rq
->ifr_ifru
.ifru_data
);
5215 case SIOC_QETH_GET_CARD_TYPE
:
5216 if ((card
->info
.type
== QETH_CARD_TYPE_OSAE
) &&
5217 !card
->info
.guestlan
)
5222 mii_data
= if_mii(rq
);
5223 mii_data
->phy_id
= 0;
5226 mii_data
= if_mii(rq
);
5227 if (mii_data
->phy_id
!= 0)
5230 mii_data
->val_out
= qeth_mdio_read(dev
,mii_data
->phy_id
,
5237 QETH_DBF_TEXT_(trace
, 2, "ioce%d", rc
);
5241 static struct net_device_stats
*
5242 qeth_get_stats(struct net_device
*dev
)
5244 struct qeth_card
*card
;
5246 card
= (struct qeth_card
*) (dev
->priv
);
5248 QETH_DBF_TEXT(trace
,5,"getstat");
5250 return &card
->stats
;
5254 qeth_change_mtu(struct net_device
*dev
, int new_mtu
)
5256 struct qeth_card
*card
;
5259 card
= (struct qeth_card
*) (dev
->priv
);
5261 QETH_DBF_TEXT(trace
,4,"chgmtu");
5262 sprintf(dbf_text
, "%8x", new_mtu
);
5263 QETH_DBF_TEXT(trace
,4,dbf_text
);
5267 if (new_mtu
> 65535)
5269 if ((!qeth_is_supported(card
,IPA_IP_FRAGMENTATION
)) &&
5270 (!qeth_mtu_is_valid(card
, new_mtu
)))
5276 #ifdef CONFIG_QETH_VLAN
5278 qeth_vlan_rx_register(struct net_device
*dev
, struct vlan_group
*grp
)
5280 struct qeth_card
*card
;
5281 unsigned long flags
;
5283 QETH_DBF_TEXT(trace
,4,"vlanreg");
5285 card
= (struct qeth_card
*) dev
->priv
;
5286 spin_lock_irqsave(&card
->vlanlock
, flags
);
5287 card
->vlangrp
= grp
;
5288 spin_unlock_irqrestore(&card
->vlanlock
, flags
);
5292 qeth_free_vlan_buffer(struct qeth_card
*card
, struct qeth_qdio_out_buffer
*buf
,
5296 struct sk_buff
*skb
;
5297 struct sk_buff_head tmp_list
;
5299 skb_queue_head_init(&tmp_list
);
5300 lockdep_set_class(&tmp_list
.lock
, &qdio_out_skb_queue_key
);
5301 for(i
= 0; i
< QETH_MAX_BUFFER_ELEMENTS(card
); ++i
){
5302 while ((skb
= skb_dequeue(&buf
->skb_list
))){
5303 if (vlan_tx_tag_present(skb
) &&
5304 (vlan_tx_tag_get(skb
) == vid
)) {
5305 atomic_dec(&skb
->users
);
5308 skb_queue_tail(&tmp_list
, skb
);
5311 while ((skb
= skb_dequeue(&tmp_list
)))
5312 skb_queue_tail(&buf
->skb_list
, skb
);
5316 qeth_free_vlan_skbs(struct qeth_card
*card
, unsigned short vid
)
5320 QETH_DBF_TEXT(trace
, 4, "frvlskbs");
5321 for (i
= 0; i
< card
->qdio
.no_out_queues
; ++i
){
5322 for (j
= 0; j
< QDIO_MAX_BUFFERS_PER_Q
; ++j
)
5323 qeth_free_vlan_buffer(card
, &card
->qdio
.
5324 out_qs
[i
]->bufs
[j
], vid
);
5329 qeth_free_vlan_addresses4(struct qeth_card
*card
, unsigned short vid
)
5331 struct in_device
*in_dev
;
5332 struct in_ifaddr
*ifa
;
5333 struct qeth_ipaddr
*addr
;
5335 QETH_DBF_TEXT(trace
, 4, "frvaddr4");
5338 in_dev
= __in_dev_get_rcu(vlan_group_get_device(card
->vlangrp
, vid
));
5341 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
5342 addr
= qeth_get_addr_buffer(QETH_PROT_IPV4
);
5344 addr
->u
.a4
.addr
= ifa
->ifa_address
;
5345 addr
->u
.a4
.mask
= ifa
->ifa_mask
;
5346 addr
->type
= QETH_IP_TYPE_NORMAL
;
5347 if (!qeth_delete_ip(card
, addr
))
5356 qeth_free_vlan_addresses6(struct qeth_card
*card
, unsigned short vid
)
5358 #ifdef CONFIG_QETH_IPV6
5359 struct inet6_dev
*in6_dev
;
5360 struct inet6_ifaddr
*ifa
;
5361 struct qeth_ipaddr
*addr
;
5363 QETH_DBF_TEXT(trace
, 4, "frvaddr6");
5365 in6_dev
= in6_dev_get(vlan_group_get_device(card
->vlangrp
, vid
));
5368 for (ifa
= in6_dev
->addr_list
; ifa
; ifa
= ifa
->lst_next
){
5369 addr
= qeth_get_addr_buffer(QETH_PROT_IPV6
);
5371 memcpy(&addr
->u
.a6
.addr
, &ifa
->addr
,
5372 sizeof(struct in6_addr
));
5373 addr
->u
.a6
.pfxlen
= ifa
->prefix_len
;
5374 addr
->type
= QETH_IP_TYPE_NORMAL
;
5375 if (!qeth_delete_ip(card
, addr
))
5379 in6_dev_put(in6_dev
);
5380 #endif /* CONFIG_QETH_IPV6 */
5384 qeth_free_vlan_addresses(struct qeth_card
*card
, unsigned short vid
)
5386 if (card
->options
.layer2
|| !card
->vlangrp
)
5388 qeth_free_vlan_addresses4(card
, vid
);
5389 qeth_free_vlan_addresses6(card
, vid
);
5393 qeth_layer2_send_setdelvlan_cb(struct qeth_card
*card
,
5394 struct qeth_reply
*reply
,
5397 struct qeth_ipa_cmd
*cmd
;
5399 QETH_DBF_TEXT(trace
, 2, "L2sdvcb");
5400 cmd
= (struct qeth_ipa_cmd
*) data
;
5401 if (cmd
->hdr
.return_code
) {
5402 PRINT_ERR("Error in processing VLAN %i on %s: 0x%x. "
5403 "Continuing\n",cmd
->data
.setdelvlan
.vlan_id
,
5404 QETH_CARD_IFNAME(card
), cmd
->hdr
.return_code
);
5405 QETH_DBF_TEXT_(trace
, 2, "L2VL%4x", cmd
->hdr
.command
);
5406 QETH_DBF_TEXT_(trace
, 2, "L2%s", CARD_BUS_ID(card
));
5407 QETH_DBF_TEXT_(trace
, 2, "err%d", cmd
->hdr
.return_code
);
5413 qeth_layer2_send_setdelvlan(struct qeth_card
*card
, __u16 i
,
5414 enum qeth_ipa_cmds ipacmd
)
5416 struct qeth_ipa_cmd
*cmd
;
5417 struct qeth_cmd_buffer
*iob
;
5419 QETH_DBF_TEXT_(trace
, 4, "L2sdv%x",ipacmd
);
5420 iob
= qeth_get_ipacmd_buffer(card
, ipacmd
, QETH_PROT_IPV4
);
5421 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
5422 cmd
->data
.setdelvlan
.vlan_id
= i
;
5423 return qeth_send_ipa_cmd(card
, iob
,
5424 qeth_layer2_send_setdelvlan_cb
, NULL
);
5428 qeth_layer2_process_vlans(struct qeth_card
*card
, int clear
)
5432 QETH_DBF_TEXT(trace
, 3, "L2prcvln");
5436 for (i
= 0; i
< VLAN_GROUP_ARRAY_LEN
; i
++) {
5437 if (vlan_group_get_device(card
->vlangrp
, i
) == NULL
)
5440 qeth_layer2_send_setdelvlan(card
, i
, IPA_CMD_DELVLAN
);
5442 qeth_layer2_send_setdelvlan(card
, i
, IPA_CMD_SETVLAN
);
5446 /*add_vid is layer 2 used only ....*/
5448 qeth_vlan_rx_add_vid(struct net_device
*dev
, unsigned short vid
)
5450 struct qeth_card
*card
;
5452 QETH_DBF_TEXT_(trace
, 4, "aid:%d", vid
);
5454 card
= (struct qeth_card
*) dev
->priv
;
5455 if (!card
->options
.layer2
)
5457 qeth_layer2_send_setdelvlan(card
, vid
, IPA_CMD_SETVLAN
);
5460 /*... kill_vid used for both modes*/
5462 qeth_vlan_rx_kill_vid(struct net_device
*dev
, unsigned short vid
)
5464 struct qeth_card
*card
;
5465 unsigned long flags
;
5467 QETH_DBF_TEXT_(trace
, 4, "kid:%d", vid
);
5469 card
= (struct qeth_card
*) dev
->priv
;
5470 /* free all skbs for the vlan device */
5471 qeth_free_vlan_skbs(card
, vid
);
5472 spin_lock_irqsave(&card
->vlanlock
, flags
);
5473 /* unregister IP addresses of vlan device */
5474 qeth_free_vlan_addresses(card
, vid
);
5475 vlan_group_set_device(card
->vlangrp
, vid
, NULL
);
5476 spin_unlock_irqrestore(&card
->vlanlock
, flags
);
5477 if (card
->options
.layer2
)
5478 qeth_layer2_send_setdelvlan(card
, vid
, IPA_CMD_DELVLAN
);
5479 qeth_set_multicast_list(card
->dev
);
5483 * Examine hardware response to SET_PROMISC_MODE
5486 qeth_setadp_promisc_mode_cb(struct qeth_card
*card
,
5487 struct qeth_reply
*reply
,
5490 struct qeth_ipa_cmd
*cmd
;
5491 struct qeth_ipacmd_setadpparms
*setparms
;
5493 QETH_DBF_TEXT(trace
,4,"prmadpcb");
5495 cmd
= (struct qeth_ipa_cmd
*) data
;
5496 setparms
= &(cmd
->data
.setadapterparms
);
5498 qeth_default_setadapterparms_cb(card
, reply
, (unsigned long)cmd
);
5499 if (cmd
->hdr
.return_code
) {
5500 QETH_DBF_TEXT_(trace
,4,"prmrc%2.2x",cmd
->hdr
.return_code
);
5501 setparms
->data
.mode
= SET_PROMISC_MODE_OFF
;
5503 card
->info
.promisc_mode
= setparms
->data
.mode
;
5507 * Set promiscuous mode (on or off) (SET_PROMISC_MODE command)
5510 qeth_setadp_promisc_mode(struct qeth_card
*card
)
5512 enum qeth_ipa_promisc_modes mode
;
5513 struct net_device
*dev
= card
->dev
;
5514 struct qeth_cmd_buffer
*iob
;
5515 struct qeth_ipa_cmd
*cmd
;
5517 QETH_DBF_TEXT(trace
, 4, "setprom");
5519 if (((dev
->flags
& IFF_PROMISC
) &&
5520 (card
->info
.promisc_mode
== SET_PROMISC_MODE_ON
)) ||
5521 (!(dev
->flags
& IFF_PROMISC
) &&
5522 (card
->info
.promisc_mode
== SET_PROMISC_MODE_OFF
)))
5524 mode
= SET_PROMISC_MODE_OFF
;
5525 if (dev
->flags
& IFF_PROMISC
)
5526 mode
= SET_PROMISC_MODE_ON
;
5527 QETH_DBF_TEXT_(trace
, 4, "mode:%x", mode
);
5529 iob
= qeth_get_adapter_cmd(card
, IPA_SETADP_SET_PROMISC_MODE
,
5530 sizeof(struct qeth_ipacmd_setadpparms
));
5531 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+ IPA_PDU_HEADER_SIZE
);
5532 cmd
->data
.setadapterparms
.data
.mode
= mode
;
5533 qeth_send_ipa_cmd(card
, iob
, qeth_setadp_promisc_mode_cb
, NULL
);
5537 * set multicast address on card
5540 qeth_set_multicast_list(struct net_device
*dev
)
5542 struct qeth_card
*card
= (struct qeth_card
*) dev
->priv
;
5544 if (card
->info
.type
== QETH_CARD_TYPE_OSN
)
5547 QETH_DBF_TEXT(trace
, 3, "setmulti");
5548 qeth_delete_mc_addresses(card
);
5549 if (card
->options
.layer2
) {
5550 qeth_layer2_add_multicast(card
);
5553 qeth_add_multicast_ipv4(card
);
5554 #ifdef CONFIG_QETH_IPV6
5555 qeth_add_multicast_ipv6(card
);
5558 qeth_set_ip_addr_list(card
);
5559 if (!qeth_adp_supported(card
, IPA_SETADP_SET_PROMISC_MODE
))
5561 qeth_setadp_promisc_mode(card
);
5565 qeth_neigh_setup(struct net_device
*dev
, struct neigh_parms
*np
)
5571 qeth_get_mac_for_ipm(__u32 ipm
, char *mac
, struct net_device
*dev
)
5573 if (dev
->type
== ARPHRD_IEEE802_TR
)
5574 ip_tr_mc_map(ipm
, mac
);
5576 ip_eth_mc_map(ipm
, mac
);
5579 static struct qeth_ipaddr
*
5580 qeth_get_addr_buffer(enum qeth_prot_versions prot
)
5582 struct qeth_ipaddr
*addr
;
5584 addr
= kzalloc(sizeof(struct qeth_ipaddr
), GFP_ATOMIC
);
5586 PRINT_WARN("Not enough memory to add address\n");
5589 addr
->type
= QETH_IP_TYPE_NORMAL
;
5595 qeth_osn_assist(struct net_device
*dev
,
5599 struct qeth_cmd_buffer
*iob
;
5600 struct qeth_card
*card
;
5603 QETH_DBF_TEXT(trace
, 2, "osnsdmc");
5606 card
= (struct qeth_card
*)dev
->priv
;
5609 if ((card
->state
!= CARD_STATE_UP
) &&
5610 (card
->state
!= CARD_STATE_SOFTSETUP
))
5612 iob
= qeth_wait_for_buffer(&card
->write
);
5613 memcpy(iob
->data
+IPA_PDU_HEADER_SIZE
, data
, data_len
);
5614 rc
= qeth_osn_send_ipa_cmd(card
, iob
, data_len
);
5618 static struct net_device
*
5619 qeth_netdev_by_devno(unsigned char *read_dev_no
)
5621 struct qeth_card
*card
;
5622 struct net_device
*ndev
;
5623 unsigned char *readno
;
5624 __u16 temp_dev_no
, card_dev_no
;
5626 unsigned long flags
;
5629 memcpy(&temp_dev_no
, read_dev_no
, 2);
5630 read_lock_irqsave(&qeth_card_list
.rwlock
, flags
);
5631 list_for_each_entry(card
, &qeth_card_list
.list
, list
) {
5632 readno
= CARD_RDEV_ID(card
);
5633 readno
+= (strlen(readno
) - 4);
5634 card_dev_no
= simple_strtoul(readno
, &endp
, 16);
5635 if (card_dev_no
== temp_dev_no
) {
5640 read_unlock_irqrestore(&qeth_card_list
.rwlock
, flags
);
5645 qeth_osn_register(unsigned char *read_dev_no
,
5646 struct net_device
**dev
,
5647 int (*assist_cb
)(struct net_device
*, void *),
5648 int (*data_cb
)(struct sk_buff
*))
5650 struct qeth_card
* card
;
5652 QETH_DBF_TEXT(trace
, 2, "osnreg");
5653 *dev
= qeth_netdev_by_devno(read_dev_no
);
5656 card
= (struct qeth_card
*)(*dev
)->priv
;
5659 if ((assist_cb
== NULL
) || (data_cb
== NULL
))
5661 card
->osn_info
.assist_cb
= assist_cb
;
5662 card
->osn_info
.data_cb
= data_cb
;
5667 qeth_osn_deregister(struct net_device
* dev
)
5669 struct qeth_card
*card
;
5671 QETH_DBF_TEXT(trace
, 2, "osndereg");
5674 card
= (struct qeth_card
*)dev
->priv
;
5677 card
->osn_info
.assist_cb
= NULL
;
5678 card
->osn_info
.data_cb
= NULL
;
5683 qeth_delete_mc_addresses(struct qeth_card
*card
)
5685 struct qeth_ipaddr
*iptodo
;
5686 unsigned long flags
;
5688 QETH_DBF_TEXT(trace
,4,"delmc");
5689 iptodo
= qeth_get_addr_buffer(QETH_PROT_IPV4
);
5691 QETH_DBF_TEXT(trace
, 2, "dmcnomem");
5694 iptodo
->type
= QETH_IP_TYPE_DEL_ALL_MC
;
5695 spin_lock_irqsave(&card
->ip_lock
, flags
);
5696 if (!__qeth_insert_ip_todo(card
, iptodo
, 0))
5698 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
5702 qeth_add_mc(struct qeth_card
*card
, struct in_device
*in4_dev
)
5704 struct qeth_ipaddr
*ipm
;
5705 struct ip_mc_list
*im4
;
5706 char buf
[MAX_ADDR_LEN
];
5708 QETH_DBF_TEXT(trace
,4,"addmc");
5709 for (im4
= in4_dev
->mc_list
; im4
; im4
= im4
->next
) {
5710 qeth_get_mac_for_ipm(im4
->multiaddr
, buf
, in4_dev
->dev
);
5711 ipm
= qeth_get_addr_buffer(QETH_PROT_IPV4
);
5714 ipm
->u
.a4
.addr
= im4
->multiaddr
;
5715 memcpy(ipm
->mac
,buf
,OSA_ADDR_LEN
);
5716 ipm
->is_multicast
= 1;
5717 if (!qeth_add_ip(card
,ipm
))
5723 qeth_add_vlan_mc(struct qeth_card
*card
)
5725 #ifdef CONFIG_QETH_VLAN
5726 struct in_device
*in_dev
;
5727 struct vlan_group
*vg
;
5730 QETH_DBF_TEXT(trace
,4,"addmcvl");
5731 if ( ((card
->options
.layer2
== 0) &&
5732 (!qeth_is_supported(card
,IPA_FULL_VLAN
))) ||
5733 (card
->vlangrp
== NULL
) )
5737 for (i
= 0; i
< VLAN_GROUP_ARRAY_LEN
; i
++) {
5738 struct net_device
*netdev
= vlan_group_get_device(vg
, i
);
5739 if (netdev
== NULL
||
5740 !(netdev
->flags
& IFF_UP
))
5742 in_dev
= in_dev_get(netdev
);
5745 read_lock(&in_dev
->mc_list_lock
);
5746 qeth_add_mc(card
,in_dev
);
5747 read_unlock(&in_dev
->mc_list_lock
);
5754 qeth_add_multicast_ipv4(struct qeth_card
*card
)
5756 struct in_device
*in4_dev
;
5758 QETH_DBF_TEXT(trace
,4,"chkmcv4");
5759 in4_dev
= in_dev_get(card
->dev
);
5760 if (in4_dev
== NULL
)
5762 read_lock(&in4_dev
->mc_list_lock
);
5763 qeth_add_mc(card
, in4_dev
);
5764 qeth_add_vlan_mc(card
);
5765 read_unlock(&in4_dev
->mc_list_lock
);
5766 in_dev_put(in4_dev
);
5770 qeth_layer2_add_multicast(struct qeth_card
*card
)
5772 struct qeth_ipaddr
*ipm
;
5773 struct dev_mc_list
*dm
;
5775 QETH_DBF_TEXT(trace
,4,"L2addmc");
5776 for (dm
= card
->dev
->mc_list
; dm
; dm
= dm
->next
) {
5777 ipm
= qeth_get_addr_buffer(QETH_PROT_IPV4
);
5780 memcpy(ipm
->mac
,dm
->dmi_addr
,MAX_ADDR_LEN
);
5781 ipm
->is_multicast
= 1;
5782 if (!qeth_add_ip(card
, ipm
))
5787 #ifdef CONFIG_QETH_IPV6
5789 qeth_add_mc6(struct qeth_card
*card
, struct inet6_dev
*in6_dev
)
5791 struct qeth_ipaddr
*ipm
;
5792 struct ifmcaddr6
*im6
;
5793 char buf
[MAX_ADDR_LEN
];
5795 QETH_DBF_TEXT(trace
,4,"addmc6");
5796 for (im6
= in6_dev
->mc_list
; im6
!= NULL
; im6
= im6
->next
) {
5797 ndisc_mc_map(&im6
->mca_addr
, buf
, in6_dev
->dev
, 0);
5798 ipm
= qeth_get_addr_buffer(QETH_PROT_IPV6
);
5801 ipm
->is_multicast
= 1;
5802 memcpy(ipm
->mac
,buf
,OSA_ADDR_LEN
);
5803 memcpy(&ipm
->u
.a6
.addr
,&im6
->mca_addr
.s6_addr
,
5804 sizeof(struct in6_addr
));
5805 if (!qeth_add_ip(card
,ipm
))
5811 qeth_add_vlan_mc6(struct qeth_card
*card
)
5813 #ifdef CONFIG_QETH_VLAN
5814 struct inet6_dev
*in_dev
;
5815 struct vlan_group
*vg
;
5818 QETH_DBF_TEXT(trace
,4,"admc6vl");
5819 if ( ((card
->options
.layer2
== 0) &&
5820 (!qeth_is_supported(card
,IPA_FULL_VLAN
))) ||
5821 (card
->vlangrp
== NULL
))
5825 for (i
= 0; i
< VLAN_GROUP_ARRAY_LEN
; i
++) {
5826 struct net_device
*netdev
= vlan_group_get_device(vg
, i
);
5827 if (netdev
== NULL
||
5828 !(netdev
->flags
& IFF_UP
))
5830 in_dev
= in6_dev_get(netdev
);
5833 read_lock(&in_dev
->lock
);
5834 qeth_add_mc6(card
,in_dev
);
5835 read_unlock(&in_dev
->lock
);
5836 in6_dev_put(in_dev
);
5838 #endif /* CONFIG_QETH_VLAN */
5842 qeth_add_multicast_ipv6(struct qeth_card
*card
)
5844 struct inet6_dev
*in6_dev
;
5846 QETH_DBF_TEXT(trace
,4,"chkmcv6");
5847 if (!qeth_is_supported(card
, IPA_IPV6
))
5849 in6_dev
= in6_dev_get(card
->dev
);
5850 if (in6_dev
== NULL
)
5852 read_lock(&in6_dev
->lock
);
5853 qeth_add_mc6(card
, in6_dev
);
5854 qeth_add_vlan_mc6(card
);
5855 read_unlock(&in6_dev
->lock
);
5856 in6_dev_put(in6_dev
);
5858 #endif /* CONFIG_QETH_IPV6 */
5861 qeth_layer2_send_setdelmac(struct qeth_card
*card
, __u8
*mac
,
5862 enum qeth_ipa_cmds ipacmd
,
5863 int (*reply_cb
) (struct qeth_card
*,
5867 struct qeth_ipa_cmd
*cmd
;
5868 struct qeth_cmd_buffer
*iob
;
5870 QETH_DBF_TEXT(trace
, 2, "L2sdmac");
5871 iob
= qeth_get_ipacmd_buffer(card
, ipacmd
, QETH_PROT_IPV4
);
5872 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
5873 cmd
->data
.setdelmac
.mac_length
= OSA_ADDR_LEN
;
5874 memcpy(&cmd
->data
.setdelmac
.mac
, mac
, OSA_ADDR_LEN
);
5875 return qeth_send_ipa_cmd(card
, iob
, reply_cb
, NULL
);
5879 qeth_layer2_send_setgroupmac_cb(struct qeth_card
*card
,
5880 struct qeth_reply
*reply
,
5883 struct qeth_ipa_cmd
*cmd
;
5886 QETH_DBF_TEXT(trace
, 2, "L2Sgmacb");
5887 cmd
= (struct qeth_ipa_cmd
*) data
;
5888 mac
= &cmd
->data
.setdelmac
.mac
[0];
5889 /* MAC already registered, needed in couple/uncouple case */
5890 if (cmd
->hdr
.return_code
== 0x2005) {
5891 PRINT_WARN("Group MAC %02x:%02x:%02x:%02x:%02x:%02x " \
5892 "already existing on %s \n",
5893 mac
[0], mac
[1], mac
[2], mac
[3], mac
[4], mac
[5],
5894 QETH_CARD_IFNAME(card
));
5895 cmd
->hdr
.return_code
= 0;
5897 if (cmd
->hdr
.return_code
)
5898 PRINT_ERR("Could not set group MAC " \
5899 "%02x:%02x:%02x:%02x:%02x:%02x on %s: %x\n",
5900 mac
[0], mac
[1], mac
[2], mac
[3], mac
[4], mac
[5],
5901 QETH_CARD_IFNAME(card
),cmd
->hdr
.return_code
);
5906 qeth_layer2_send_setgroupmac(struct qeth_card
*card
, __u8
*mac
)
5908 QETH_DBF_TEXT(trace
, 2, "L2Sgmac");
5909 return qeth_layer2_send_setdelmac(card
, mac
, IPA_CMD_SETGMAC
,
5910 qeth_layer2_send_setgroupmac_cb
);
5914 qeth_layer2_send_delgroupmac_cb(struct qeth_card
*card
,
5915 struct qeth_reply
*reply
,
5918 struct qeth_ipa_cmd
*cmd
;
5921 QETH_DBF_TEXT(trace
, 2, "L2Dgmacb");
5922 cmd
= (struct qeth_ipa_cmd
*) data
;
5923 mac
= &cmd
->data
.setdelmac
.mac
[0];
5924 if (cmd
->hdr
.return_code
)
5925 PRINT_ERR("Could not delete group MAC " \
5926 "%02x:%02x:%02x:%02x:%02x:%02x on %s: %x\n",
5927 mac
[0], mac
[1], mac
[2], mac
[3], mac
[4], mac
[5],
5928 QETH_CARD_IFNAME(card
), cmd
->hdr
.return_code
);
5933 qeth_layer2_send_delgroupmac(struct qeth_card
*card
, __u8
*mac
)
5935 QETH_DBF_TEXT(trace
, 2, "L2Dgmac");
5936 return qeth_layer2_send_setdelmac(card
, mac
, IPA_CMD_DELGMAC
,
5937 qeth_layer2_send_delgroupmac_cb
);
5941 qeth_layer2_send_setmac_cb(struct qeth_card
*card
,
5942 struct qeth_reply
*reply
,
5945 struct qeth_ipa_cmd
*cmd
;
5947 QETH_DBF_TEXT(trace
, 2, "L2Smaccb");
5948 cmd
= (struct qeth_ipa_cmd
*) data
;
5949 if (cmd
->hdr
.return_code
) {
5950 QETH_DBF_TEXT_(trace
, 2, "L2er%x", cmd
->hdr
.return_code
);
5951 PRINT_WARN("Error in registering MAC address on " \
5952 "device %s: x%x\n", CARD_BUS_ID(card
),
5953 cmd
->hdr
.return_code
);
5954 card
->info
.mac_bits
&= ~QETH_LAYER2_MAC_REGISTERED
;
5955 cmd
->hdr
.return_code
= -EIO
;
5957 card
->info
.mac_bits
|= QETH_LAYER2_MAC_REGISTERED
;
5958 memcpy(card
->dev
->dev_addr
,cmd
->data
.setdelmac
.mac
,
5960 PRINT_INFO("MAC address %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x "
5961 "successfully registered on device %s\n",
5962 card
->dev
->dev_addr
[0], card
->dev
->dev_addr
[1],
5963 card
->dev
->dev_addr
[2], card
->dev
->dev_addr
[3],
5964 card
->dev
->dev_addr
[4], card
->dev
->dev_addr
[5],
5971 qeth_layer2_send_setmac(struct qeth_card
*card
, __u8
*mac
)
5973 QETH_DBF_TEXT(trace
, 2, "L2Setmac");
5974 return qeth_layer2_send_setdelmac(card
, mac
, IPA_CMD_SETVMAC
,
5975 qeth_layer2_send_setmac_cb
);
5979 qeth_layer2_send_delmac_cb(struct qeth_card
*card
,
5980 struct qeth_reply
*reply
,
5983 struct qeth_ipa_cmd
*cmd
;
5985 QETH_DBF_TEXT(trace
, 2, "L2Dmaccb");
5986 cmd
= (struct qeth_ipa_cmd
*) data
;
5987 if (cmd
->hdr
.return_code
) {
5988 PRINT_WARN("Error in deregistering MAC address on " \
5989 "device %s: x%x\n", CARD_BUS_ID(card
),
5990 cmd
->hdr
.return_code
);
5991 QETH_DBF_TEXT_(trace
, 2, "err%d", cmd
->hdr
.return_code
);
5992 cmd
->hdr
.return_code
= -EIO
;
5995 card
->info
.mac_bits
&= ~QETH_LAYER2_MAC_REGISTERED
;
6000 qeth_layer2_send_delmac(struct qeth_card
*card
, __u8
*mac
)
6002 QETH_DBF_TEXT(trace
, 2, "L2Delmac");
6003 if (!(card
->info
.mac_bits
& QETH_LAYER2_MAC_REGISTERED
))
6005 return qeth_layer2_send_setdelmac(card
, mac
, IPA_CMD_DELVMAC
,
6006 qeth_layer2_send_delmac_cb
);
6010 qeth_layer2_set_mac_address(struct net_device
*dev
, void *p
)
6012 struct sockaddr
*addr
= p
;
6013 struct qeth_card
*card
;
6016 QETH_DBF_TEXT(trace
, 3, "setmac");
6018 if (qeth_verify_dev(dev
) != QETH_REAL_CARD
) {
6019 QETH_DBF_TEXT(trace
, 3, "setmcINV");
6022 card
= (struct qeth_card
*) dev
->priv
;
6024 if (!card
->options
.layer2
) {
6025 PRINT_WARN("Setting MAC address on %s is not supported "
6026 "in Layer 3 mode.\n", dev
->name
);
6027 QETH_DBF_TEXT(trace
, 3, "setmcLY3");
6030 if (card
->info
.type
== QETH_CARD_TYPE_OSN
) {
6031 PRINT_WARN("Setting MAC address on %s is not supported.\n",
6033 QETH_DBF_TEXT(trace
, 3, "setmcOSN");
6036 QETH_DBF_TEXT_(trace
, 3, "%s", CARD_BUS_ID(card
));
6037 QETH_DBF_HEX(trace
, 3, addr
->sa_data
, OSA_ADDR_LEN
);
6038 rc
= qeth_layer2_send_delmac(card
, &card
->dev
->dev_addr
[0]);
6040 rc
= qeth_layer2_send_setmac(card
, addr
->sa_data
);
6045 qeth_fill_ipacmd_header(struct qeth_card
*card
, struct qeth_ipa_cmd
*cmd
,
6046 __u8 command
, enum qeth_prot_versions prot
)
6048 memset(cmd
, 0, sizeof (struct qeth_ipa_cmd
));
6049 cmd
->hdr
.command
= command
;
6050 cmd
->hdr
.initiator
= IPA_CMD_INITIATOR_HOST
;
6051 cmd
->hdr
.seqno
= card
->seqno
.ipa
;
6052 cmd
->hdr
.adapter_type
= qeth_get_ipa_adp_type(card
->info
.link_type
);
6053 cmd
->hdr
.rel_adapter_no
= (__u8
) card
->info
.portno
;
6054 if (card
->options
.layer2
)
6055 cmd
->hdr
.prim_version_no
= 2;
6057 cmd
->hdr
.prim_version_no
= 1;
6058 cmd
->hdr
.param_count
= 1;
6059 cmd
->hdr
.prot_version
= prot
;
6060 cmd
->hdr
.ipa_supported
= 0;
6061 cmd
->hdr
.ipa_enabled
= 0;
6064 static struct qeth_cmd_buffer
*
6065 qeth_get_ipacmd_buffer(struct qeth_card
*card
, enum qeth_ipa_cmds ipacmd
,
6066 enum qeth_prot_versions prot
)
6068 struct qeth_cmd_buffer
*iob
;
6069 struct qeth_ipa_cmd
*cmd
;
6071 iob
= qeth_wait_for_buffer(&card
->write
);
6072 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
6073 qeth_fill_ipacmd_header(card
, cmd
, ipacmd
, prot
);
6079 qeth_send_setdelmc(struct qeth_card
*card
, struct qeth_ipaddr
*addr
, int ipacmd
)
6082 struct qeth_cmd_buffer
*iob
;
6083 struct qeth_ipa_cmd
*cmd
;
6085 QETH_DBF_TEXT(trace
,4,"setdelmc");
6087 iob
= qeth_get_ipacmd_buffer(card
, ipacmd
, addr
->proto
);
6088 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
6089 memcpy(&cmd
->data
.setdelipm
.mac
,addr
->mac
, OSA_ADDR_LEN
);
6090 if (addr
->proto
== QETH_PROT_IPV6
)
6091 memcpy(cmd
->data
.setdelipm
.ip6
, &addr
->u
.a6
.addr
,
6092 sizeof(struct in6_addr
));
6094 memcpy(&cmd
->data
.setdelipm
.ip4
, &addr
->u
.a4
.addr
,4);
6096 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
6101 qeth_fill_netmask(u8
*netmask
, unsigned int len
)
6104 for (i
=0;i
<16;i
++) {
6109 netmask
[i
] = (u8
)(0xFF00>>j
);
6116 qeth_send_setdelip(struct qeth_card
*card
, struct qeth_ipaddr
*addr
,
6117 int ipacmd
, unsigned int flags
)
6120 struct qeth_cmd_buffer
*iob
;
6121 struct qeth_ipa_cmd
*cmd
;
6124 QETH_DBF_TEXT(trace
,4,"setdelip");
6125 QETH_DBF_TEXT_(trace
,4,"flags%02X", flags
);
6127 iob
= qeth_get_ipacmd_buffer(card
, ipacmd
, addr
->proto
);
6128 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
6129 if (addr
->proto
== QETH_PROT_IPV6
) {
6130 memcpy(cmd
->data
.setdelip6
.ip_addr
, &addr
->u
.a6
.addr
,
6131 sizeof(struct in6_addr
));
6132 qeth_fill_netmask(netmask
,addr
->u
.a6
.pfxlen
);
6133 memcpy(cmd
->data
.setdelip6
.mask
, netmask
,
6134 sizeof(struct in6_addr
));
6135 cmd
->data
.setdelip6
.flags
= flags
;
6137 memcpy(cmd
->data
.setdelip4
.ip_addr
, &addr
->u
.a4
.addr
, 4);
6138 memcpy(cmd
->data
.setdelip4
.mask
, &addr
->u
.a4
.mask
, 4);
6139 cmd
->data
.setdelip4
.flags
= flags
;
6142 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
6148 qeth_layer2_register_addr_entry(struct qeth_card
*card
,
6149 struct qeth_ipaddr
*addr
)
6151 if (!addr
->is_multicast
)
6153 QETH_DBF_TEXT(trace
, 2, "setgmac");
6154 QETH_DBF_HEX(trace
,3,&addr
->mac
[0],OSA_ADDR_LEN
);
6155 return qeth_layer2_send_setgroupmac(card
, &addr
->mac
[0]);
6159 qeth_layer2_deregister_addr_entry(struct qeth_card
*card
,
6160 struct qeth_ipaddr
*addr
)
6162 if (!addr
->is_multicast
)
6164 QETH_DBF_TEXT(trace
, 2, "delgmac");
6165 QETH_DBF_HEX(trace
,3,&addr
->mac
[0],OSA_ADDR_LEN
);
6166 return qeth_layer2_send_delgroupmac(card
, &addr
->mac
[0]);
6170 qeth_layer3_register_addr_entry(struct qeth_card
*card
,
6171 struct qeth_ipaddr
*addr
)
6177 if (addr
->proto
== QETH_PROT_IPV4
) {
6178 QETH_DBF_TEXT(trace
, 2,"setaddr4");
6179 QETH_DBF_HEX(trace
, 3, &addr
->u
.a4
.addr
, sizeof(int));
6180 } else if (addr
->proto
== QETH_PROT_IPV6
) {
6181 QETH_DBF_TEXT(trace
, 2, "setaddr6");
6182 QETH_DBF_HEX(trace
,3,&addr
->u
.a6
.addr
,8);
6183 QETH_DBF_HEX(trace
,3,((char *)&addr
->u
.a6
.addr
)+8,8);
6185 QETH_DBF_TEXT(trace
, 2, "setaddr?");
6186 QETH_DBF_HEX(trace
, 3, addr
, sizeof(struct qeth_ipaddr
));
6189 if (addr
->is_multicast
)
6190 rc
= qeth_send_setdelmc(card
, addr
, IPA_CMD_SETIPM
);
6192 rc
= qeth_send_setdelip(card
, addr
, IPA_CMD_SETIP
,
6195 QETH_DBF_TEXT(trace
, 2, "failed");
6196 } while ((--cnt
> 0) && rc
);
6198 QETH_DBF_TEXT(trace
, 2, "FAILED");
6199 qeth_ipaddr_to_string(addr
->proto
, (u8
*)&addr
->u
, buf
);
6200 PRINT_WARN("Could not register IP address %s (rc=0x%x/%d)\n",
6207 qeth_layer3_deregister_addr_entry(struct qeth_card
*card
,
6208 struct qeth_ipaddr
*addr
)
6213 if (addr
->proto
== QETH_PROT_IPV4
) {
6214 QETH_DBF_TEXT(trace
, 2,"deladdr4");
6215 QETH_DBF_HEX(trace
, 3, &addr
->u
.a4
.addr
, sizeof(int));
6216 } else if (addr
->proto
== QETH_PROT_IPV6
) {
6217 QETH_DBF_TEXT(trace
, 2, "deladdr6");
6218 QETH_DBF_HEX(trace
,3,&addr
->u
.a6
.addr
,8);
6219 QETH_DBF_HEX(trace
,3,((char *)&addr
->u
.a6
.addr
)+8,8);
6221 QETH_DBF_TEXT(trace
, 2, "deladdr?");
6222 QETH_DBF_HEX(trace
, 3, addr
, sizeof(struct qeth_ipaddr
));
6224 if (addr
->is_multicast
)
6225 rc
= qeth_send_setdelmc(card
, addr
, IPA_CMD_DELIPM
);
6227 rc
= qeth_send_setdelip(card
, addr
, IPA_CMD_DELIP
,
6230 QETH_DBF_TEXT(trace
, 2, "failed");
6231 /* TODO: re-activate this warning as soon as we have a
6233 qeth_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
6234 PRINT_WARN("Could not deregister IP address %s (rc=%x)\n",
6242 qeth_register_addr_entry(struct qeth_card
*card
, struct qeth_ipaddr
*addr
)
6244 if (card
->options
.layer2
)
6245 return qeth_layer2_register_addr_entry(card
, addr
);
6247 return qeth_layer3_register_addr_entry(card
, addr
);
6251 qeth_deregister_addr_entry(struct qeth_card
*card
, struct qeth_ipaddr
*addr
)
6253 if (card
->options
.layer2
)
6254 return qeth_layer2_deregister_addr_entry(card
, addr
);
6256 return qeth_layer3_deregister_addr_entry(card
, addr
);
6260 qeth_ethtool_get_tx_csum(struct net_device
*dev
)
6262 /* We may need to say that we support tx csum offload if
6263 * we do EDDP or TSO. There are discussions going on to
6264 * enforce rules in the stack and in ethtool that make
6265 * SG and TSO depend on HW_CSUM. At the moment there are
6267 * If we say yes here, we have to checksum outbound packets
6273 qeth_ethtool_set_tx_csum(struct net_device
*dev
, u32 data
)
6279 qeth_ethtool_get_rx_csum(struct net_device
*dev
)
6281 struct qeth_card
*card
= (struct qeth_card
*)dev
->priv
;
6283 return (card
->options
.checksum_type
== HW_CHECKSUMMING
);
6287 qeth_ethtool_set_rx_csum(struct net_device
*dev
, u32 data
)
6289 struct qeth_card
*card
= (struct qeth_card
*)dev
->priv
;
6291 if ((card
->state
!= CARD_STATE_DOWN
) &&
6292 (card
->state
!= CARD_STATE_RECOVER
))
6295 card
->options
.checksum_type
= HW_CHECKSUMMING
;
6297 card
->options
.checksum_type
= SW_CHECKSUMMING
;
6302 qeth_ethtool_get_sg(struct net_device
*dev
)
6304 struct qeth_card
*card
= (struct qeth_card
*)dev
->priv
;
6306 return ((card
->options
.large_send
!= QETH_LARGE_SEND_NO
) &&
6307 (dev
->features
& NETIF_F_SG
));
6311 qeth_ethtool_set_sg(struct net_device
*dev
, u32 data
)
6313 struct qeth_card
*card
= (struct qeth_card
*)dev
->priv
;
6316 if (card
->options
.large_send
!= QETH_LARGE_SEND_NO
)
6317 dev
->features
|= NETIF_F_SG
;
6319 dev
->features
&= ~NETIF_F_SG
;
6323 dev
->features
&= ~NETIF_F_SG
;
6328 qeth_ethtool_get_tso(struct net_device
*dev
)
6330 struct qeth_card
*card
= (struct qeth_card
*)dev
->priv
;
6332 return ((card
->options
.large_send
!= QETH_LARGE_SEND_NO
) &&
6333 (dev
->features
& NETIF_F_TSO
));
6337 qeth_ethtool_set_tso(struct net_device
*dev
, u32 data
)
6339 struct qeth_card
*card
= (struct qeth_card
*)dev
->priv
;
6342 if (card
->options
.large_send
!= QETH_LARGE_SEND_NO
)
6343 dev
->features
|= NETIF_F_TSO
;
6345 dev
->features
&= ~NETIF_F_TSO
;
6349 dev
->features
&= ~NETIF_F_TSO
;
6353 static struct ethtool_ops qeth_ethtool_ops
= {
6354 .get_tx_csum
= qeth_ethtool_get_tx_csum
,
6355 .set_tx_csum
= qeth_ethtool_set_tx_csum
,
6356 .get_rx_csum
= qeth_ethtool_get_rx_csum
,
6357 .set_rx_csum
= qeth_ethtool_set_rx_csum
,
6358 .get_sg
= qeth_ethtool_get_sg
,
6359 .set_sg
= qeth_ethtool_set_sg
,
6360 .get_tso
= qeth_ethtool_get_tso
,
6361 .set_tso
= qeth_ethtool_set_tso
,
6365 qeth_hard_header_parse(struct sk_buff
*skb
, unsigned char *haddr
)
6367 struct qeth_card
*card
;
6370 card
= qeth_get_card_from_dev(skb
->dev
);
6371 if (card
->options
.layer2
)
6373 #ifdef CONFIG_QETH_IPV6
6374 /* cause of the manipulated arp constructor and the ARP
6375 flag for OSAE devices we have some nasty exceptions */
6376 if (card
->info
.type
== QETH_CARD_TYPE_OSAE
) {
6377 if (!card
->options
.fake_ll
) {
6378 if ((skb
->pkt_type
==PACKET_OUTGOING
) &&
6379 (skb
->protocol
==ETH_P_IPV6
))
6384 if ((skb
->pkt_type
==PACKET_OUTGOING
) &&
6385 (skb
->protocol
==ETH_P_IP
))
6392 if (!card
->options
.fake_ll
)
6396 memcpy(haddr
, eth
->h_source
, ETH_ALEN
);
6401 qeth_netdev_init(struct net_device
*dev
)
6403 struct qeth_card
*card
;
6405 card
= (struct qeth_card
*) dev
->priv
;
6407 QETH_DBF_TEXT(trace
,3,"initdev");
6409 dev
->tx_timeout
= &qeth_tx_timeout
;
6410 dev
->watchdog_timeo
= QETH_TX_TIMEOUT
;
6411 dev
->open
= qeth_open
;
6412 dev
->stop
= qeth_stop
;
6413 dev
->hard_start_xmit
= qeth_hard_start_xmit
;
6414 dev
->do_ioctl
= qeth_do_ioctl
;
6415 dev
->get_stats
= qeth_get_stats
;
6416 dev
->change_mtu
= qeth_change_mtu
;
6417 dev
->neigh_setup
= qeth_neigh_setup
;
6418 dev
->set_multicast_list
= qeth_set_multicast_list
;
6419 #ifdef CONFIG_QETH_VLAN
6420 dev
->vlan_rx_register
= qeth_vlan_rx_register
;
6421 dev
->vlan_rx_kill_vid
= qeth_vlan_rx_kill_vid
;
6422 dev
->vlan_rx_add_vid
= qeth_vlan_rx_add_vid
;
6424 if (qeth_get_netdev_flags(card
) & IFF_NOARP
) {
6425 dev
->rebuild_header
= NULL
;
6426 dev
->hard_header
= NULL
;
6427 dev
->header_cache_update
= NULL
;
6428 dev
->hard_header_cache
= NULL
;
6430 #ifdef CONFIG_QETH_IPV6
6431 /*IPv6 address autoconfiguration stuff*/
6432 if (!(card
->info
.unique_id
& UNIQUE_ID_NOT_BY_CARD
))
6433 card
->dev
->dev_id
= card
->info
.unique_id
& 0xffff;
6435 if (card
->options
.fake_ll
&&
6436 (qeth_get_netdev_flags(card
) & IFF_NOARP
))
6437 dev
->hard_header
= qeth_fake_header
;
6438 if (dev
->type
== ARPHRD_IEEE802_TR
)
6439 dev
->hard_header_parse
= NULL
;
6441 dev
->hard_header_parse
= qeth_hard_header_parse
;
6442 dev
->set_mac_address
= qeth_layer2_set_mac_address
;
6443 dev
->flags
|= qeth_get_netdev_flags(card
);
6444 if ((card
->options
.fake_broadcast
) ||
6445 (card
->info
.broadcast_capable
))
6446 dev
->flags
|= IFF_BROADCAST
;
6447 dev
->hard_header_len
=
6448 qeth_get_hlen(card
->info
.link_type
) + card
->options
.add_hhlen
;
6449 dev
->addr_len
= OSA_ADDR_LEN
;
6450 dev
->mtu
= card
->info
.initial_mtu
;
6451 if (card
->info
.type
!= QETH_CARD_TYPE_OSN
)
6452 SET_ETHTOOL_OPS(dev
, &qeth_ethtool_ops
);
6453 SET_MODULE_OWNER(dev
);
6458 qeth_init_func_level(struct qeth_card
*card
)
6460 if (card
->ipato
.enabled
) {
6461 if (card
->info
.type
== QETH_CARD_TYPE_IQD
)
6462 card
->info
.func_level
=
6463 QETH_IDX_FUNC_LEVEL_IQD_ENA_IPAT
;
6465 card
->info
.func_level
=
6466 QETH_IDX_FUNC_LEVEL_OSAE_ENA_IPAT
;
6468 if (card
->info
.type
== QETH_CARD_TYPE_IQD
)
6469 /*FIXME:why do we have same values for dis and ena for osae??? */
6470 card
->info
.func_level
=
6471 QETH_IDX_FUNC_LEVEL_IQD_DIS_IPAT
;
6473 card
->info
.func_level
=
6474 QETH_IDX_FUNC_LEVEL_OSAE_DIS_IPAT
;
6479 * hardsetup card, initialize MPC and QDIO stuff
6482 qeth_hardsetup_card(struct qeth_card
*card
)
6487 QETH_DBF_TEXT(setup
, 2, "hrdsetup");
6491 PRINT_WARN("Retrying to do IDX activates.\n");
6492 ccw_device_set_offline(CARD_DDEV(card
));
6493 ccw_device_set_offline(CARD_WDEV(card
));
6494 ccw_device_set_offline(CARD_RDEV(card
));
6495 ccw_device_set_online(CARD_RDEV(card
));
6496 ccw_device_set_online(CARD_WDEV(card
));
6497 ccw_device_set_online(CARD_DDEV(card
));
6499 rc
= qeth_qdio_clear_card(card
,card
->info
.type
!=QETH_CARD_TYPE_IQD
);
6500 if (rc
== -ERESTARTSYS
) {
6501 QETH_DBF_TEXT(setup
, 2, "break1");
6504 QETH_DBF_TEXT_(setup
, 2, "1err%d", rc
);
6510 if ((rc
= qeth_get_unitaddr(card
))){
6511 QETH_DBF_TEXT_(setup
, 2, "2err%d", rc
);
6514 qeth_init_tokens(card
);
6515 qeth_init_func_level(card
);
6516 rc
= qeth_idx_activate_channel(&card
->read
, qeth_idx_read_cb
);
6517 if (rc
== -ERESTARTSYS
) {
6518 QETH_DBF_TEXT(setup
, 2, "break2");
6521 QETH_DBF_TEXT_(setup
, 2, "3err%d", rc
);
6527 rc
= qeth_idx_activate_channel(&card
->write
, qeth_idx_write_cb
);
6528 if (rc
== -ERESTARTSYS
) {
6529 QETH_DBF_TEXT(setup
, 2, "break3");
6532 QETH_DBF_TEXT_(setup
, 2, "4err%d", rc
);
6538 if ((rc
= qeth_mpc_initialize(card
))){
6539 QETH_DBF_TEXT_(setup
, 2, "5err%d", rc
);
6542 /*network device will be recovered*/
6544 card
->dev
->hard_header
= card
->orig_hard_header
;
6545 if (card
->options
.fake_ll
&&
6546 (qeth_get_netdev_flags(card
) & IFF_NOARP
))
6547 card
->dev
->hard_header
= qeth_fake_header
;
6550 /* at first set_online allocate netdev */
6551 card
->dev
= qeth_get_netdevice(card
->info
.type
,
6552 card
->info
.link_type
);
6554 qeth_qdio_clear_card(card
, card
->info
.type
!=
6555 QETH_CARD_TYPE_IQD
);
6557 QETH_DBF_TEXT_(setup
, 2, "6err%d", rc
);
6560 card
->dev
->priv
= card
;
6561 card
->orig_hard_header
= card
->dev
->hard_header
;
6562 card
->dev
->type
= qeth_get_arphdr_type(card
->info
.type
,
6563 card
->info
.link_type
);
6564 card
->dev
->init
= qeth_netdev_init
;
6567 PRINT_ERR("Initialization in hardsetup failed! rc=%d\n", rc
);
6572 qeth_default_setassparms_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
6575 struct qeth_ipa_cmd
*cmd
;
6577 QETH_DBF_TEXT(trace
,4,"defadpcb");
6579 cmd
= (struct qeth_ipa_cmd
*) data
;
6580 if (cmd
->hdr
.return_code
== 0){
6581 cmd
->hdr
.return_code
= cmd
->data
.setassparms
.hdr
.return_code
;
6582 if (cmd
->hdr
.prot_version
== QETH_PROT_IPV4
)
6583 card
->options
.ipa4
.enabled_funcs
= cmd
->hdr
.ipa_enabled
;
6584 #ifdef CONFIG_QETH_IPV6
6585 if (cmd
->hdr
.prot_version
== QETH_PROT_IPV6
)
6586 card
->options
.ipa6
.enabled_funcs
= cmd
->hdr
.ipa_enabled
;
6589 if (cmd
->data
.setassparms
.hdr
.assist_no
== IPA_INBOUND_CHECKSUM
&&
6590 cmd
->data
.setassparms
.hdr
.command_code
== IPA_CMD_ASS_START
) {
6591 card
->info
.csum_mask
= cmd
->data
.setassparms
.data
.flags_32bit
;
6592 QETH_DBF_TEXT_(trace
, 3, "csum:%d", card
->info
.csum_mask
);
6598 qeth_default_setadapterparms_cb(struct qeth_card
*card
,
6599 struct qeth_reply
*reply
,
6602 struct qeth_ipa_cmd
*cmd
;
6604 QETH_DBF_TEXT(trace
,4,"defadpcb");
6606 cmd
= (struct qeth_ipa_cmd
*) data
;
6607 if (cmd
->hdr
.return_code
== 0)
6608 cmd
->hdr
.return_code
= cmd
->data
.setadapterparms
.hdr
.return_code
;
6615 qeth_query_setadapterparms_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
6618 struct qeth_ipa_cmd
*cmd
;
6620 QETH_DBF_TEXT(trace
,3,"quyadpcb");
6622 cmd
= (struct qeth_ipa_cmd
*) data
;
6623 if (cmd
->data
.setadapterparms
.data
.query_cmds_supp
.lan_type
& 0x7f)
6624 card
->info
.link_type
=
6625 cmd
->data
.setadapterparms
.data
.query_cmds_supp
.lan_type
;
6626 card
->options
.adp
.supported_funcs
=
6627 cmd
->data
.setadapterparms
.data
.query_cmds_supp
.supported_cmds
;
6628 return qeth_default_setadapterparms_cb(card
, reply
, (unsigned long)cmd
);
6632 qeth_query_setadapterparms(struct qeth_card
*card
)
6635 struct qeth_cmd_buffer
*iob
;
6637 QETH_DBF_TEXT(trace
,3,"queryadp");
6638 iob
= qeth_get_adapter_cmd(card
, IPA_SETADP_QUERY_COMMANDS_SUPPORTED
,
6639 sizeof(struct qeth_ipacmd_setadpparms
));
6640 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_query_setadapterparms_cb
, NULL
);
6645 qeth_setadpparms_change_macaddr_cb(struct qeth_card
*card
,
6646 struct qeth_reply
*reply
,
6649 struct qeth_ipa_cmd
*cmd
;
6651 QETH_DBF_TEXT(trace
,4,"chgmaccb");
6653 cmd
= (struct qeth_ipa_cmd
*) data
;
6654 if (!card
->options
.layer2
|| card
->info
.guestlan
||
6655 !(card
->info
.mac_bits
& QETH_LAYER2_MAC_READ
)) {
6656 memcpy(card
->dev
->dev_addr
,
6657 &cmd
->data
.setadapterparms
.data
.change_addr
.addr
,
6659 card
->info
.mac_bits
|= QETH_LAYER2_MAC_READ
;
6661 qeth_default_setadapterparms_cb(card
, reply
, (unsigned long) cmd
);
6666 qeth_setadpparms_change_macaddr(struct qeth_card
*card
)
6669 struct qeth_cmd_buffer
*iob
;
6670 struct qeth_ipa_cmd
*cmd
;
6672 QETH_DBF_TEXT(trace
,4,"chgmac");
6674 iob
= qeth_get_adapter_cmd(card
,IPA_SETADP_ALTER_MAC_ADDRESS
,
6675 sizeof(struct qeth_ipacmd_setadpparms
));
6676 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
6677 cmd
->data
.setadapterparms
.data
.change_addr
.cmd
= CHANGE_ADDR_READ_MAC
;
6678 cmd
->data
.setadapterparms
.data
.change_addr
.addr_size
= OSA_ADDR_LEN
;
6679 memcpy(&cmd
->data
.setadapterparms
.data
.change_addr
.addr
,
6680 card
->dev
->dev_addr
, OSA_ADDR_LEN
);
6681 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_setadpparms_change_macaddr_cb
,
6687 qeth_send_setadp_mode(struct qeth_card
*card
, __u32 command
, __u32 mode
)
6690 struct qeth_cmd_buffer
*iob
;
6691 struct qeth_ipa_cmd
*cmd
;
6693 QETH_DBF_TEXT(trace
,4,"adpmode");
6695 iob
= qeth_get_adapter_cmd(card
, command
,
6696 sizeof(struct qeth_ipacmd_setadpparms
));
6697 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
6698 cmd
->data
.setadapterparms
.data
.mode
= mode
;
6699 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_default_setadapterparms_cb
,
6705 qeth_setadapter_hstr(struct qeth_card
*card
)
6709 QETH_DBF_TEXT(trace
,4,"adphstr");
6711 if (qeth_adp_supported(card
,IPA_SETADP_SET_BROADCAST_MODE
)) {
6712 rc
= qeth_send_setadp_mode(card
, IPA_SETADP_SET_BROADCAST_MODE
,
6713 card
->options
.broadcast_mode
);
6715 PRINT_WARN("couldn't set broadcast mode on "
6717 CARD_BUS_ID(card
), rc
);
6718 rc
= qeth_send_setadp_mode(card
, IPA_SETADP_ALTER_MAC_ADDRESS
,
6719 card
->options
.macaddr_mode
);
6721 PRINT_WARN("couldn't set macaddr mode on "
6722 "device %s: x%x\n", CARD_BUS_ID(card
), rc
);
6725 if (card
->options
.broadcast_mode
== QETH_TR_BROADCAST_LOCAL
)
6726 PRINT_WARN("set adapter parameters not available "
6727 "to set broadcast mode, using ALLRINGS "
6728 "on device %s:\n", CARD_BUS_ID(card
));
6729 if (card
->options
.macaddr_mode
== QETH_TR_MACADDR_CANONICAL
)
6730 PRINT_WARN("set adapter parameters not available "
6731 "to set macaddr mode, using NONCANONICAL "
6732 "on device %s:\n", CARD_BUS_ID(card
));
6737 qeth_setadapter_parms(struct qeth_card
*card
)
6741 QETH_DBF_TEXT(setup
, 2, "setadprm");
6743 if (!qeth_is_supported(card
, IPA_SETADAPTERPARMS
)){
6744 PRINT_WARN("set adapter parameters not supported "
6747 QETH_DBF_TEXT(setup
, 2, " notsupp");
6750 rc
= qeth_query_setadapterparms(card
);
6752 PRINT_WARN("couldn't set adapter parameters on device %s: "
6753 "x%x\n", CARD_BUS_ID(card
), rc
);
6756 if (qeth_adp_supported(card
,IPA_SETADP_ALTER_MAC_ADDRESS
)) {
6757 rc
= qeth_setadpparms_change_macaddr(card
);
6759 PRINT_WARN("couldn't get MAC address on "
6761 CARD_BUS_ID(card
), rc
);
6764 if ((card
->info
.link_type
== QETH_LINK_TYPE_HSTR
) ||
6765 (card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
))
6766 rc
= qeth_setadapter_hstr(card
);
6772 qeth_layer2_initialize(struct qeth_card
*card
)
6777 QETH_DBF_TEXT(setup
, 2, "doL2init");
6778 QETH_DBF_TEXT_(setup
, 2, "doL2%s", CARD_BUS_ID(card
));
6780 rc
= qeth_query_setadapterparms(card
);
6782 PRINT_WARN("could not query adapter parameters on device %s: "
6783 "x%x\n", CARD_BUS_ID(card
), rc
);
6786 rc
= qeth_setadpparms_change_macaddr(card
);
6788 PRINT_WARN("couldn't get MAC address on "
6790 CARD_BUS_ID(card
), rc
);
6791 QETH_DBF_TEXT_(setup
, 2,"1err%d",rc
);
6794 QETH_DBF_HEX(setup
,2, card
->dev
->dev_addr
, OSA_ADDR_LEN
);
6796 rc
= qeth_layer2_send_setmac(card
, &card
->dev
->dev_addr
[0]);
6798 QETH_DBF_TEXT_(setup
, 2,"2err%d",rc
);
6804 qeth_send_startstoplan(struct qeth_card
*card
, enum qeth_ipa_cmds ipacmd
,
6805 enum qeth_prot_versions prot
)
6808 struct qeth_cmd_buffer
*iob
;
6810 iob
= qeth_get_ipacmd_buffer(card
,ipacmd
,prot
);
6811 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
6817 qeth_send_startlan(struct qeth_card
*card
, enum qeth_prot_versions prot
)
6821 QETH_DBF_TEXT_(setup
, 2, "strtlan%i", prot
);
6823 rc
= qeth_send_startstoplan(card
, IPA_CMD_STARTLAN
, prot
);
6828 qeth_send_stoplan(struct qeth_card
*card
)
6833 * TODO: according to the IPA format document page 14,
6834 * TCP/IP (we!) never issue a STOPLAN
6837 QETH_DBF_TEXT(trace
, 2, "stoplan");
6839 rc
= qeth_send_startstoplan(card
, IPA_CMD_STOPLAN
, QETH_PROT_IPV4
);
6844 qeth_query_ipassists_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
6847 struct qeth_ipa_cmd
*cmd
;
6849 QETH_DBF_TEXT(setup
, 2, "qipasscb");
6851 cmd
= (struct qeth_ipa_cmd
*) data
;
6852 if (cmd
->hdr
.prot_version
== QETH_PROT_IPV4
) {
6853 card
->options
.ipa4
.supported_funcs
= cmd
->hdr
.ipa_supported
;
6854 card
->options
.ipa4
.enabled_funcs
= cmd
->hdr
.ipa_enabled
;
6855 /* Disable IPV6 support hard coded for Hipersockets */
6856 if(card
->info
.type
== QETH_CARD_TYPE_IQD
)
6857 card
->options
.ipa4
.supported_funcs
&= ~IPA_IPV6
;
6859 #ifdef CONFIG_QETH_IPV6
6860 card
->options
.ipa6
.supported_funcs
= cmd
->hdr
.ipa_supported
;
6861 card
->options
.ipa6
.enabled_funcs
= cmd
->hdr
.ipa_enabled
;
6864 QETH_DBF_TEXT(setup
, 2, "suppenbl");
6865 QETH_DBF_TEXT_(setup
, 2, "%x",cmd
->hdr
.ipa_supported
);
6866 QETH_DBF_TEXT_(setup
, 2, "%x",cmd
->hdr
.ipa_enabled
);
6871 qeth_query_ipassists(struct qeth_card
*card
, enum qeth_prot_versions prot
)
6874 struct qeth_cmd_buffer
*iob
;
6876 QETH_DBF_TEXT_(setup
, 2, "qipassi%i", prot
);
6877 if (card
->options
.layer2
) {
6878 QETH_DBF_TEXT(setup
, 2, "noprmly2");
6882 iob
= qeth_get_ipacmd_buffer(card
,IPA_CMD_QIPASSIST
,prot
);
6883 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_query_ipassists_cb
, NULL
);
6887 static struct qeth_cmd_buffer
*
6888 qeth_get_setassparms_cmd(struct qeth_card
*card
, enum qeth_ipa_funcs ipa_func
,
6889 __u16 cmd_code
, __u16 len
,
6890 enum qeth_prot_versions prot
)
6892 struct qeth_cmd_buffer
*iob
;
6893 struct qeth_ipa_cmd
*cmd
;
6895 QETH_DBF_TEXT(trace
,4,"getasscm");
6896 iob
= qeth_get_ipacmd_buffer(card
,IPA_CMD_SETASSPARMS
,prot
);
6898 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
6899 cmd
->data
.setassparms
.hdr
.assist_no
= ipa_func
;
6900 cmd
->data
.setassparms
.hdr
.length
= 8 + len
;
6901 cmd
->data
.setassparms
.hdr
.command_code
= cmd_code
;
6902 cmd
->data
.setassparms
.hdr
.return_code
= 0;
6903 cmd
->data
.setassparms
.hdr
.seq_no
= 0;
6909 qeth_send_setassparms(struct qeth_card
*card
, struct qeth_cmd_buffer
*iob
,
6910 __u16 len
, long data
,
6912 (struct qeth_card
*,struct qeth_reply
*,unsigned long),
6916 struct qeth_ipa_cmd
*cmd
;
6918 QETH_DBF_TEXT(trace
,4,"sendassp");
6920 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
6921 if (len
<= sizeof(__u32
))
6922 cmd
->data
.setassparms
.data
.flags_32bit
= (__u32
) data
;
6923 else /* (len > sizeof(__u32)) */
6924 memcpy(&cmd
->data
.setassparms
.data
, (void *) data
, len
);
6926 rc
= qeth_send_ipa_cmd(card
, iob
, reply_cb
, reply_param
);
6930 #ifdef CONFIG_QETH_IPV6
6932 qeth_send_simple_setassparms_ipv6(struct qeth_card
*card
,
6933 enum qeth_ipa_funcs ipa_func
, __u16 cmd_code
)
6937 struct qeth_cmd_buffer
*iob
;
6939 QETH_DBF_TEXT(trace
,4,"simassp6");
6940 iob
= qeth_get_setassparms_cmd(card
, ipa_func
, cmd_code
,
6942 rc
= qeth_send_setassparms(card
, iob
, 0, 0,
6943 qeth_default_setassparms_cb
, NULL
);
6949 qeth_send_simple_setassparms(struct qeth_card
*card
,
6950 enum qeth_ipa_funcs ipa_func
,
6951 __u16 cmd_code
, long data
)
6955 struct qeth_cmd_buffer
*iob
;
6957 QETH_DBF_TEXT(trace
,4,"simassp4");
6959 length
= sizeof(__u32
);
6960 iob
= qeth_get_setassparms_cmd(card
, ipa_func
, cmd_code
,
6961 length
, QETH_PROT_IPV4
);
6962 rc
= qeth_send_setassparms(card
, iob
, length
, data
,
6963 qeth_default_setassparms_cb
, NULL
);
6968 qeth_start_ipa_arp_processing(struct qeth_card
*card
)
6972 QETH_DBF_TEXT(trace
,3,"ipaarp");
6974 if (!qeth_is_supported(card
,IPA_ARP_PROCESSING
)) {
6975 PRINT_WARN("ARP processing not supported "
6976 "on %s!\n", QETH_CARD_IFNAME(card
));
6979 rc
= qeth_send_simple_setassparms(card
,IPA_ARP_PROCESSING
,
6980 IPA_CMD_ASS_START
, 0);
6982 PRINT_WARN("Could not start ARP processing "
6983 "assist on %s: 0x%x\n",
6984 QETH_CARD_IFNAME(card
), rc
);
6990 qeth_start_ipa_ip_fragmentation(struct qeth_card
*card
)
6994 QETH_DBF_TEXT(trace
,3,"ipaipfrg");
6996 if (!qeth_is_supported(card
, IPA_IP_FRAGMENTATION
)) {
6997 PRINT_INFO("Hardware IP fragmentation not supported on %s\n",
6998 QETH_CARD_IFNAME(card
));
7002 rc
= qeth_send_simple_setassparms(card
, IPA_IP_FRAGMENTATION
,
7003 IPA_CMD_ASS_START
, 0);
7005 PRINT_WARN("Could not start Hardware IP fragmentation "
7006 "assist on %s: 0x%x\n",
7007 QETH_CARD_IFNAME(card
), rc
);
7009 PRINT_INFO("Hardware IP fragmentation enabled \n");
7014 qeth_start_ipa_source_mac(struct qeth_card
*card
)
7018 QETH_DBF_TEXT(trace
,3,"stsrcmac");
7020 if (!card
->options
.fake_ll
)
7023 if (!qeth_is_supported(card
, IPA_SOURCE_MAC
)) {
7024 PRINT_INFO("Inbound source address not "
7025 "supported on %s\n", QETH_CARD_IFNAME(card
));
7029 rc
= qeth_send_simple_setassparms(card
, IPA_SOURCE_MAC
,
7030 IPA_CMD_ASS_START
, 0);
7032 PRINT_WARN("Could not start inbound source "
7033 "assist on %s: 0x%x\n",
7034 QETH_CARD_IFNAME(card
), rc
);
7039 qeth_start_ipa_vlan(struct qeth_card
*card
)
7043 QETH_DBF_TEXT(trace
,3,"strtvlan");
7045 #ifdef CONFIG_QETH_VLAN
7046 if (!qeth_is_supported(card
, IPA_FULL_VLAN
)) {
7047 PRINT_WARN("VLAN not supported on %s\n", QETH_CARD_IFNAME(card
));
7051 rc
= qeth_send_simple_setassparms(card
, IPA_VLAN_PRIO
,
7052 IPA_CMD_ASS_START
,0);
7054 PRINT_WARN("Could not start vlan "
7055 "assist on %s: 0x%x\n",
7056 QETH_CARD_IFNAME(card
), rc
);
7058 PRINT_INFO("VLAN enabled \n");
7059 card
->dev
->features
|=
7060 NETIF_F_HW_VLAN_FILTER
|
7061 NETIF_F_HW_VLAN_TX
|
7064 #endif /* QETH_VLAN */
7069 qeth_start_ipa_multicast(struct qeth_card
*card
)
7073 QETH_DBF_TEXT(trace
,3,"stmcast");
7075 if (!qeth_is_supported(card
, IPA_MULTICASTING
)) {
7076 PRINT_WARN("Multicast not supported on %s\n",
7077 QETH_CARD_IFNAME(card
));
7081 rc
= qeth_send_simple_setassparms(card
, IPA_MULTICASTING
,
7082 IPA_CMD_ASS_START
,0);
7084 PRINT_WARN("Could not start multicast "
7085 "assist on %s: rc=%i\n",
7086 QETH_CARD_IFNAME(card
), rc
);
7088 PRINT_INFO("Multicast enabled\n");
7089 card
->dev
->flags
|= IFF_MULTICAST
;
7094 #ifdef CONFIG_QETH_IPV6
7096 qeth_softsetup_ipv6(struct qeth_card
*card
)
7100 QETH_DBF_TEXT(trace
,3,"softipv6");
7102 rc
= qeth_send_startlan(card
, QETH_PROT_IPV6
);
7104 PRINT_ERR("IPv6 startlan failed on %s\n",
7105 QETH_CARD_IFNAME(card
));
7108 rc
= qeth_query_ipassists(card
,QETH_PROT_IPV6
);
7110 PRINT_ERR("IPv6 query ipassist failed on %s\n",
7111 QETH_CARD_IFNAME(card
));
7114 rc
= qeth_send_simple_setassparms(card
, IPA_IPV6
,
7115 IPA_CMD_ASS_START
, 3);
7117 PRINT_WARN("IPv6 start assist (version 4) failed "
7119 QETH_CARD_IFNAME(card
), rc
);
7122 rc
= qeth_send_simple_setassparms_ipv6(card
, IPA_IPV6
,
7125 PRINT_WARN("IPV6 start assist (version 6) failed "
7127 QETH_CARD_IFNAME(card
), rc
);
7130 rc
= qeth_send_simple_setassparms_ipv6(card
, IPA_PASSTHRU
,
7133 PRINT_WARN("Could not enable passthrough "
7135 QETH_CARD_IFNAME(card
), rc
);
7138 PRINT_INFO("IPV6 enabled \n");
7145 qeth_start_ipa_ipv6(struct qeth_card
*card
)
7148 #ifdef CONFIG_QETH_IPV6
7149 QETH_DBF_TEXT(trace
,3,"strtipv6");
7151 if (!qeth_is_supported(card
, IPA_IPV6
)) {
7152 PRINT_WARN("IPv6 not supported on %s\n",
7153 QETH_CARD_IFNAME(card
));
7156 rc
= qeth_softsetup_ipv6(card
);
7162 qeth_start_ipa_broadcast(struct qeth_card
*card
)
7166 QETH_DBF_TEXT(trace
,3,"stbrdcst");
7167 card
->info
.broadcast_capable
= 0;
7168 if (!qeth_is_supported(card
, IPA_FILTERING
)) {
7169 PRINT_WARN("Broadcast not supported on %s\n",
7170 QETH_CARD_IFNAME(card
));
7174 rc
= qeth_send_simple_setassparms(card
, IPA_FILTERING
,
7175 IPA_CMD_ASS_START
, 0);
7177 PRINT_WARN("Could not enable broadcasting filtering "
7179 QETH_CARD_IFNAME(card
), rc
);
7183 rc
= qeth_send_simple_setassparms(card
, IPA_FILTERING
,
7184 IPA_CMD_ASS_CONFIGURE
, 1);
7186 PRINT_WARN("Could not set up broadcast filtering on %s: 0x%x\n",
7187 QETH_CARD_IFNAME(card
), rc
);
7190 card
->info
.broadcast_capable
= QETH_BROADCAST_WITH_ECHO
;
7191 PRINT_INFO("Broadcast enabled \n");
7192 rc
= qeth_send_simple_setassparms(card
, IPA_FILTERING
,
7193 IPA_CMD_ASS_ENABLE
, 1);
7195 PRINT_WARN("Could not set up broadcast echo filtering on "
7196 "%s: 0x%x\n", QETH_CARD_IFNAME(card
), rc
);
7199 card
->info
.broadcast_capable
= QETH_BROADCAST_WITHOUT_ECHO
;
7201 if (card
->info
.broadcast_capable
)
7202 card
->dev
->flags
|= IFF_BROADCAST
;
7204 card
->dev
->flags
&= ~IFF_BROADCAST
;
7209 qeth_send_checksum_command(struct qeth_card
*card
)
7213 rc
= qeth_send_simple_setassparms(card
, IPA_INBOUND_CHECKSUM
,
7214 IPA_CMD_ASS_START
, 0);
7216 PRINT_WARN("Starting Inbound HW Checksumming failed on %s: "
7217 "0x%x,\ncontinuing using Inbound SW Checksumming\n",
7218 QETH_CARD_IFNAME(card
), rc
);
7221 rc
= qeth_send_simple_setassparms(card
, IPA_INBOUND_CHECKSUM
,
7223 card
->info
.csum_mask
);
7225 PRINT_WARN("Enabling Inbound HW Checksumming failed on %s: "
7226 "0x%x,\ncontinuing using Inbound SW Checksumming\n",
7227 QETH_CARD_IFNAME(card
), rc
);
7234 qeth_start_ipa_checksum(struct qeth_card
*card
)
7238 QETH_DBF_TEXT(trace
,3,"strtcsum");
7240 if (card
->options
.checksum_type
== NO_CHECKSUMMING
) {
7241 PRINT_WARN("Using no checksumming on %s.\n",
7242 QETH_CARD_IFNAME(card
));
7245 if (card
->options
.checksum_type
== SW_CHECKSUMMING
) {
7246 PRINT_WARN("Using SW checksumming on %s.\n",
7247 QETH_CARD_IFNAME(card
));
7250 if (!qeth_is_supported(card
, IPA_INBOUND_CHECKSUM
)) {
7251 PRINT_WARN("Inbound HW Checksumming not "
7252 "supported on %s,\ncontinuing "
7253 "using Inbound SW Checksumming\n",
7254 QETH_CARD_IFNAME(card
));
7255 card
->options
.checksum_type
= SW_CHECKSUMMING
;
7258 rc
= qeth_send_checksum_command(card
);
7260 PRINT_INFO("HW Checksumming (inbound) enabled \n");
7266 qeth_start_ipa_tso(struct qeth_card
*card
)
7270 QETH_DBF_TEXT(trace
,3,"sttso");
7272 if (!qeth_is_supported(card
, IPA_OUTBOUND_TSO
)) {
7273 PRINT_WARN("Outbound TSO not supported on %s\n",
7274 QETH_CARD_IFNAME(card
));
7277 rc
= qeth_send_simple_setassparms(card
, IPA_OUTBOUND_TSO
,
7278 IPA_CMD_ASS_START
,0);
7280 PRINT_WARN("Could not start outbound TSO "
7281 "assist on %s: rc=%i\n",
7282 QETH_CARD_IFNAME(card
), rc
);
7284 PRINT_INFO("Outbound TSO enabled\n");
7286 if (rc
&& (card
->options
.large_send
== QETH_LARGE_SEND_TSO
)){
7287 card
->options
.large_send
= QETH_LARGE_SEND_NO
;
7288 card
->dev
->features
&= ~ (NETIF_F_TSO
| NETIF_F_SG
);
7294 qeth_start_ipassists(struct qeth_card
*card
)
7296 QETH_DBF_TEXT(trace
,3,"strtipas");
7297 qeth_start_ipa_arp_processing(card
); /* go on*/
7298 qeth_start_ipa_ip_fragmentation(card
); /* go on*/
7299 qeth_start_ipa_source_mac(card
); /* go on*/
7300 qeth_start_ipa_vlan(card
); /* go on*/
7301 qeth_start_ipa_multicast(card
); /* go on*/
7302 qeth_start_ipa_ipv6(card
); /* go on*/
7303 qeth_start_ipa_broadcast(card
); /* go on*/
7304 qeth_start_ipa_checksum(card
); /* go on*/
7305 qeth_start_ipa_tso(card
); /* go on*/
7310 qeth_send_setrouting(struct qeth_card
*card
, enum qeth_routing_types type
,
7311 enum qeth_prot_versions prot
)
7314 struct qeth_ipa_cmd
*cmd
;
7315 struct qeth_cmd_buffer
*iob
;
7317 QETH_DBF_TEXT(trace
,4,"setroutg");
7318 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_SETRTG
, prot
);
7319 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
7320 cmd
->data
.setrtg
.type
= (type
);
7321 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
7328 qeth_correct_routing_type(struct qeth_card
*card
, enum qeth_routing_types
*type
,
7329 enum qeth_prot_versions prot
)
7331 if (card
->info
.type
== QETH_CARD_TYPE_IQD
) {
7334 case PRIMARY_CONNECTOR
:
7335 case SECONDARY_CONNECTOR
:
7336 case MULTICAST_ROUTER
:
7344 case PRIMARY_ROUTER
:
7345 case SECONDARY_ROUTER
:
7347 case MULTICAST_ROUTER
:
7348 if (qeth_is_ipafunc_supported(card
, prot
,
7356 PRINT_WARN("Routing type '%s' not supported for interface %s.\n"
7357 "Router status set to 'no router'.\n",
7358 ((*type
== PRIMARY_ROUTER
)? "primary router" :
7359 (*type
== SECONDARY_ROUTER
)? "secondary router" :
7360 (*type
== PRIMARY_CONNECTOR
)? "primary connector" :
7361 (*type
== SECONDARY_CONNECTOR
)? "secondary connector" :
7362 (*type
== MULTICAST_ROUTER
)? "multicast router" :
7369 qeth_setrouting_v4(struct qeth_card
*card
)
7373 QETH_DBF_TEXT(trace
,3,"setrtg4");
7375 qeth_correct_routing_type(card
, &card
->options
.route4
.type
,
7378 rc
= qeth_send_setrouting(card
, card
->options
.route4
.type
,
7381 card
->options
.route4
.type
= NO_ROUTER
;
7382 PRINT_WARN("Error (0x%04x) while setting routing type on %s. "
7383 "Type set to 'no router'.\n",
7384 rc
, QETH_CARD_IFNAME(card
));
7390 qeth_setrouting_v6(struct qeth_card
*card
)
7394 QETH_DBF_TEXT(trace
,3,"setrtg6");
7395 #ifdef CONFIG_QETH_IPV6
7397 if (!qeth_is_supported(card
, IPA_IPV6
))
7399 qeth_correct_routing_type(card
, &card
->options
.route6
.type
,
7402 rc
= qeth_send_setrouting(card
, card
->options
.route6
.type
,
7405 card
->options
.route6
.type
= NO_ROUTER
;
7406 PRINT_WARN("Error (0x%04x) while setting routing type on %s. "
7407 "Type set to 'no router'.\n",
7408 rc
, QETH_CARD_IFNAME(card
));
7415 qeth_set_large_send(struct qeth_card
*card
, enum qeth_large_send_types type
)
7419 if (card
->dev
== NULL
) {
7420 card
->options
.large_send
= type
;
7423 if (card
->state
== CARD_STATE_UP
)
7424 netif_tx_disable(card
->dev
);
7425 card
->options
.large_send
= type
;
7426 switch (card
->options
.large_send
) {
7427 case QETH_LARGE_SEND_EDDP
:
7428 card
->dev
->features
|= NETIF_F_TSO
| NETIF_F_SG
;
7430 case QETH_LARGE_SEND_TSO
:
7431 if (qeth_is_supported(card
, IPA_OUTBOUND_TSO
)){
7432 card
->dev
->features
|= NETIF_F_TSO
| NETIF_F_SG
;
7434 PRINT_WARN("TSO not supported on %s. "
7435 "large_send set to 'no'.\n",
7437 card
->dev
->features
&= ~(NETIF_F_TSO
| NETIF_F_SG
);
7438 card
->options
.large_send
= QETH_LARGE_SEND_NO
;
7442 default: /* includes QETH_LARGE_SEND_NO */
7443 card
->dev
->features
&= ~(NETIF_F_TSO
| NETIF_F_SG
);
7446 if (card
->state
== CARD_STATE_UP
)
7447 netif_wake_queue(card
->dev
);
7452 * softsetup card: init IPA stuff
7455 qeth_softsetup_card(struct qeth_card
*card
)
7459 QETH_DBF_TEXT(setup
, 2, "softsetp");
7461 if ((rc
= qeth_send_startlan(card
, QETH_PROT_IPV4
))){
7462 QETH_DBF_TEXT_(setup
, 2, "1err%d", rc
);
7464 PRINT_WARN("LAN on card %s if offline! "
7465 "Continuing softsetup.\n",
7467 card
->lan_online
= 0;
7471 card
->lan_online
= 1;
7472 if (card
->info
.type
==QETH_CARD_TYPE_OSN
)
7474 qeth_set_large_send(card
, card
->options
.large_send
);
7475 if (card
->options
.layer2
) {
7476 card
->dev
->features
|=
7477 NETIF_F_HW_VLAN_FILTER
|
7478 NETIF_F_HW_VLAN_TX
|
7480 card
->dev
->flags
|=IFF_MULTICAST
|IFF_BROADCAST
;
7481 card
->info
.broadcast_capable
=1;
7482 if ((rc
= qeth_layer2_initialize(card
))) {
7483 QETH_DBF_TEXT_(setup
, 2, "L2err%d", rc
);
7486 #ifdef CONFIG_QETH_VLAN
7487 qeth_layer2_process_vlans(card
, 0);
7491 if ((rc
= qeth_setadapter_parms(card
)))
7492 QETH_DBF_TEXT_(setup
, 2, "2err%d", rc
);
7493 if ((rc
= qeth_start_ipassists(card
)))
7494 QETH_DBF_TEXT_(setup
, 2, "3err%d", rc
);
7495 if ((rc
= qeth_setrouting_v4(card
)))
7496 QETH_DBF_TEXT_(setup
, 2, "4err%d", rc
);
7497 if ((rc
= qeth_setrouting_v6(card
)))
7498 QETH_DBF_TEXT_(setup
, 2, "5err%d", rc
);
7500 netif_tx_disable(card
->dev
);
7504 #ifdef CONFIG_QETH_IPV6
7506 qeth_get_unique_id_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
7509 struct qeth_ipa_cmd
*cmd
;
7511 cmd
= (struct qeth_ipa_cmd
*) data
;
7512 if (cmd
->hdr
.return_code
== 0)
7513 card
->info
.unique_id
= *((__u16
*)
7514 &cmd
->data
.create_destroy_addr
.unique_id
[6]);
7516 card
->info
.unique_id
= UNIQUE_ID_IF_CREATE_ADDR_FAILED
|
7517 UNIQUE_ID_NOT_BY_CARD
;
7518 PRINT_WARN("couldn't get a unique id from the card on device "
7519 "%s (result=x%x), using default id. ipv6 "
7520 "autoconfig on other lpars may lead to duplicate "
7521 "ip addresses. please use manually "
7522 "configured ones.\n",
7523 CARD_BUS_ID(card
), cmd
->hdr
.return_code
);
7530 qeth_put_unique_id(struct qeth_card
*card
)
7534 #ifdef CONFIG_QETH_IPV6
7535 struct qeth_cmd_buffer
*iob
;
7536 struct qeth_ipa_cmd
*cmd
;
7538 QETH_DBF_TEXT(trace
,2,"puniqeid");
7540 if ((card
->info
.unique_id
& UNIQUE_ID_NOT_BY_CARD
) ==
7541 UNIQUE_ID_NOT_BY_CARD
)
7543 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_DESTROY_ADDR
,
7545 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
7546 *((__u16
*) &cmd
->data
.create_destroy_addr
.unique_id
[6]) =
7547 card
->info
.unique_id
;
7548 memcpy(&cmd
->data
.create_destroy_addr
.unique_id
[0],
7549 card
->dev
->dev_addr
, OSA_ADDR_LEN
);
7550 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
7552 card
->info
.unique_id
= UNIQUE_ID_IF_CREATE_ADDR_FAILED
|
7553 UNIQUE_ID_NOT_BY_CARD
;
7562 qeth_clear_ip_list(struct qeth_card
*card
, int clean
, int recover
)
7564 struct qeth_ipaddr
*addr
, *tmp
;
7565 unsigned long flags
;
7567 QETH_DBF_TEXT(trace
,4,"clearip");
7568 spin_lock_irqsave(&card
->ip_lock
, flags
);
7569 /* clear todo list */
7570 list_for_each_entry_safe(addr
, tmp
, card
->ip_tbd_list
, entry
){
7571 list_del(&addr
->entry
);
7575 while (!list_empty(&card
->ip_list
)) {
7576 addr
= list_entry(card
->ip_list
.next
,
7577 struct qeth_ipaddr
, entry
);
7578 list_del_init(&addr
->entry
);
7580 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
7581 qeth_deregister_addr_entry(card
, addr
);
7582 spin_lock_irqsave(&card
->ip_lock
, flags
);
7584 if (!recover
|| addr
->is_multicast
) {
7588 list_add_tail(&addr
->entry
, card
->ip_tbd_list
);
7590 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
7594 qeth_set_allowed_threads(struct qeth_card
*card
, unsigned long threads
,
7595 int clear_start_mask
)
7597 unsigned long flags
;
7599 spin_lock_irqsave(&card
->thread_mask_lock
, flags
);
7600 card
->thread_allowed_mask
= threads
;
7601 if (clear_start_mask
)
7602 card
->thread_start_mask
&= threads
;
7603 spin_unlock_irqrestore(&card
->thread_mask_lock
, flags
);
7604 wake_up(&card
->wait_q
);
7608 qeth_threads_running(struct qeth_card
*card
, unsigned long threads
)
7610 unsigned long flags
;
7613 spin_lock_irqsave(&card
->thread_mask_lock
, flags
);
7614 rc
= (card
->thread_running_mask
& threads
);
7615 spin_unlock_irqrestore(&card
->thread_mask_lock
, flags
);
7620 qeth_wait_for_threads(struct qeth_card
*card
, unsigned long threads
)
7622 return wait_event_interruptible(card
->wait_q
,
7623 qeth_threads_running(card
, threads
) == 0);
7627 qeth_stop_card(struct qeth_card
*card
, int recovery_mode
)
7631 QETH_DBF_TEXT(setup
,2,"stopcard");
7632 QETH_DBF_HEX(setup
, 2, &card
, sizeof(void *));
7634 qeth_set_allowed_threads(card
, 0, 1);
7635 if (qeth_wait_for_threads(card
, ~QETH_RECOVER_THREAD
))
7636 return -ERESTARTSYS
;
7637 if (card
->read
.state
== CH_STATE_UP
&&
7638 card
->write
.state
== CH_STATE_UP
&&
7639 (card
->state
== CARD_STATE_UP
)) {
7640 if (recovery_mode
&&
7641 card
->info
.type
!= QETH_CARD_TYPE_OSN
) {
7642 qeth_stop(card
->dev
);
7645 dev_close(card
->dev
);
7648 if (!card
->use_hard_stop
) {
7649 __u8
*mac
= &card
->dev
->dev_addr
[0];
7650 rc
= qeth_layer2_send_delmac(card
, mac
);
7651 QETH_DBF_TEXT_(setup
, 2, "Lerr%d", rc
);
7652 if ((rc
= qeth_send_stoplan(card
)))
7653 QETH_DBF_TEXT_(setup
, 2, "1err%d", rc
);
7655 card
->state
= CARD_STATE_SOFTSETUP
;
7657 if (card
->state
== CARD_STATE_SOFTSETUP
) {
7658 #ifdef CONFIG_QETH_VLAN
7659 if (card
->options
.layer2
)
7660 qeth_layer2_process_vlans(card
, 1);
7662 qeth_clear_ip_list(card
, !card
->use_hard_stop
, 1);
7663 qeth_clear_ipacmd_list(card
);
7664 card
->state
= CARD_STATE_HARDSETUP
;
7666 if (card
->state
== CARD_STATE_HARDSETUP
) {
7667 if ((!card
->use_hard_stop
) &&
7668 (!card
->options
.layer2
))
7669 if ((rc
= qeth_put_unique_id(card
)))
7670 QETH_DBF_TEXT_(setup
, 2, "2err%d", rc
);
7671 qeth_qdio_clear_card(card
, 0);
7672 qeth_clear_qdio_buffers(card
);
7673 qeth_clear_working_pool_list(card
);
7674 card
->state
= CARD_STATE_DOWN
;
7676 if (card
->state
== CARD_STATE_DOWN
) {
7677 qeth_clear_cmd_buffers(&card
->read
);
7678 qeth_clear_cmd_buffers(&card
->write
);
7680 card
->use_hard_stop
= 0;
7686 qeth_get_unique_id(struct qeth_card
*card
)
7689 #ifdef CONFIG_QETH_IPV6
7690 struct qeth_cmd_buffer
*iob
;
7691 struct qeth_ipa_cmd
*cmd
;
7693 QETH_DBF_TEXT(setup
, 2, "guniqeid");
7695 if (!qeth_is_supported(card
,IPA_IPV6
)) {
7696 card
->info
.unique_id
= UNIQUE_ID_IF_CREATE_ADDR_FAILED
|
7697 UNIQUE_ID_NOT_BY_CARD
;
7701 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_CREATE_ADDR
,
7703 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
7704 *((__u16
*) &cmd
->data
.create_destroy_addr
.unique_id
[6]) =
7705 card
->info
.unique_id
;
7707 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_get_unique_id_cb
, NULL
);
7709 card
->info
.unique_id
= UNIQUE_ID_IF_CREATE_ADDR_FAILED
|
7710 UNIQUE_ID_NOT_BY_CARD
;
7715 qeth_print_status_with_portname(struct qeth_card
*card
)
7720 sprintf(dbf_text
, "%s", card
->info
.portname
+ 1);
7721 for (i
= 0; i
< 8; i
++)
7723 (char) _ebcasc
[(__u8
) dbf_text
[i
]];
7725 printk("qeth: Device %s/%s/%s is a%s card%s%s%s\n"
7726 "with link type %s (portname: %s)\n",
7730 qeth_get_cardname(card
),
7731 (card
->info
.mcl_level
[0]) ? " (level: " : "",
7732 (card
->info
.mcl_level
[0]) ? card
->info
.mcl_level
: "",
7733 (card
->info
.mcl_level
[0]) ? ")" : "",
7734 qeth_get_cardname_short(card
),
7740 qeth_print_status_no_portname(struct qeth_card
*card
)
7742 if (card
->info
.portname
[0])
7743 printk("qeth: Device %s/%s/%s is a%s "
7744 "card%s%s%s\nwith link type %s "
7745 "(no portname needed by interface).\n",
7749 qeth_get_cardname(card
),
7750 (card
->info
.mcl_level
[0]) ? " (level: " : "",
7751 (card
->info
.mcl_level
[0]) ? card
->info
.mcl_level
: "",
7752 (card
->info
.mcl_level
[0]) ? ")" : "",
7753 qeth_get_cardname_short(card
));
7755 printk("qeth: Device %s/%s/%s is a%s "
7756 "card%s%s%s\nwith link type %s.\n",
7760 qeth_get_cardname(card
),
7761 (card
->info
.mcl_level
[0]) ? " (level: " : "",
7762 (card
->info
.mcl_level
[0]) ? card
->info
.mcl_level
: "",
7763 (card
->info
.mcl_level
[0]) ? ")" : "",
7764 qeth_get_cardname_short(card
));
7768 qeth_print_status_message(struct qeth_card
*card
)
7770 switch (card
->info
.type
) {
7771 case QETH_CARD_TYPE_OSAE
:
7772 /* VM will use a non-zero first character
7773 * to indicate a HiperSockets like reporting
7774 * of the level OSA sets the first character to zero
7776 if (!card
->info
.mcl_level
[0]) {
7777 sprintf(card
->info
.mcl_level
,"%02x%02x",
7778 card
->info
.mcl_level
[2],
7779 card
->info
.mcl_level
[3]);
7781 card
->info
.mcl_level
[QETH_MCL_LENGTH
] = 0;
7785 case QETH_CARD_TYPE_IQD
:
7786 card
->info
.mcl_level
[0] = (char) _ebcasc
[(__u8
)
7787 card
->info
.mcl_level
[0]];
7788 card
->info
.mcl_level
[1] = (char) _ebcasc
[(__u8
)
7789 card
->info
.mcl_level
[1]];
7790 card
->info
.mcl_level
[2] = (char) _ebcasc
[(__u8
)
7791 card
->info
.mcl_level
[2]];
7792 card
->info
.mcl_level
[3] = (char) _ebcasc
[(__u8
)
7793 card
->info
.mcl_level
[3]];
7794 card
->info
.mcl_level
[QETH_MCL_LENGTH
] = 0;
7797 memset(&card
->info
.mcl_level
[0], 0, QETH_MCL_LENGTH
+ 1);
7799 if (card
->info
.portname_required
)
7800 qeth_print_status_with_portname(card
);
7802 qeth_print_status_no_portname(card
);
7806 qeth_register_netdev(struct qeth_card
*card
)
7808 QETH_DBF_TEXT(setup
, 3, "regnetd");
7809 if (card
->dev
->reg_state
!= NETREG_UNINITIALIZED
)
7812 SET_NETDEV_DEV(card
->dev
, &card
->gdev
->dev
);
7813 return register_netdev(card
->dev
);
7817 qeth_start_again(struct qeth_card
*card
, int recovery_mode
)
7819 QETH_DBF_TEXT(setup
,2, "startag");
7821 if (recovery_mode
&&
7822 card
->info
.type
!= QETH_CARD_TYPE_OSN
) {
7823 qeth_open(card
->dev
);
7826 dev_open(card
->dev
);
7829 /* this also sets saved unicast addresses */
7830 qeth_set_multicast_list(card
->dev
);
7834 /* Layer 2 specific stuff */
7835 #define IGNORE_PARAM_EQ(option,value,reset_value,msg) \
7836 if (card->options.option == value) { \
7837 PRINT_ERR("%s not supported with layer 2 " \
7838 "functionality, ignoring option on read" \
7839 "channel device %s .\n",msg,CARD_RDEV_ID(card)); \
7840 card->options.option = reset_value; \
7842 #define IGNORE_PARAM_NEQ(option,value,reset_value,msg) \
7843 if (card->options.option != value) { \
7844 PRINT_ERR("%s not supported with layer 2 " \
7845 "functionality, ignoring option on read" \
7846 "channel device %s .\n",msg,CARD_RDEV_ID(card)); \
7847 card->options.option = reset_value; \
7851 static void qeth_make_parameters_consistent(struct qeth_card
*card
)
7854 if (card
->options
.layer2
== 0)
7856 if (card
->info
.type
== QETH_CARD_TYPE_OSN
)
7858 if (card
->info
.type
== QETH_CARD_TYPE_IQD
) {
7859 PRINT_ERR("Device %s does not support layer 2 functionality." \
7860 " Ignoring layer2 option.\n",CARD_BUS_ID(card
));
7861 card
->options
.layer2
= 0;
7864 IGNORE_PARAM_NEQ(route4
.type
, NO_ROUTER
, NO_ROUTER
,
7865 "Routing options are");
7866 #ifdef CONFIG_QETH_IPV6
7867 IGNORE_PARAM_NEQ(route6
.type
, NO_ROUTER
, NO_ROUTER
,
7868 "Routing options are");
7870 IGNORE_PARAM_EQ(checksum_type
, HW_CHECKSUMMING
,
7871 QETH_CHECKSUM_DEFAULT
,
7872 "Checksumming options are");
7873 IGNORE_PARAM_NEQ(broadcast_mode
, QETH_TR_BROADCAST_ALLRINGS
,
7874 QETH_TR_BROADCAST_ALLRINGS
,
7875 "Broadcast mode options are");
7876 IGNORE_PARAM_NEQ(macaddr_mode
, QETH_TR_MACADDR_NONCANONICAL
,
7877 QETH_TR_MACADDR_NONCANONICAL
,
7878 "Canonical MAC addr options are");
7879 IGNORE_PARAM_NEQ(fake_broadcast
, 0, 0,
7880 "Broadcast faking options are");
7881 IGNORE_PARAM_NEQ(add_hhlen
, DEFAULT_ADD_HHLEN
,
7882 DEFAULT_ADD_HHLEN
,"Option add_hhlen is");
7883 IGNORE_PARAM_NEQ(fake_ll
, 0, 0,"Option fake_ll is");
7888 __qeth_set_online(struct ccwgroup_device
*gdev
, int recovery_mode
)
7890 struct qeth_card
*card
= gdev
->dev
.driver_data
;
7892 enum qeth_card_states recover_flag
;
7895 QETH_DBF_TEXT(setup
,2, "setonlin");
7896 QETH_DBF_HEX(setup
, 2, &card
, sizeof(void *));
7898 qeth_set_allowed_threads(card
, QETH_RECOVER_THREAD
, 1);
7899 if (qeth_wait_for_threads(card
, ~QETH_RECOVER_THREAD
)){
7900 PRINT_WARN("set_online of card %s interrupted by user!\n",
7902 return -ERESTARTSYS
;
7905 recover_flag
= card
->state
;
7906 if ((rc
= ccw_device_set_online(CARD_RDEV(card
))) ||
7907 (rc
= ccw_device_set_online(CARD_WDEV(card
))) ||
7908 (rc
= ccw_device_set_online(CARD_DDEV(card
)))){
7909 QETH_DBF_TEXT_(setup
, 2, "1err%d", rc
);
7913 qeth_make_parameters_consistent(card
);
7915 if ((rc
= qeth_hardsetup_card(card
))){
7916 QETH_DBF_TEXT_(setup
, 2, "2err%d", rc
);
7919 card
->state
= CARD_STATE_HARDSETUP
;
7921 if (!(rc
= qeth_query_ipassists(card
,QETH_PROT_IPV4
)))
7922 rc
= qeth_get_unique_id(card
);
7924 if (rc
&& card
->options
.layer2
== 0) {
7925 QETH_DBF_TEXT_(setup
, 2, "3err%d", rc
);
7928 qeth_print_status_message(card
);
7929 if ((rc
= qeth_register_netdev(card
))){
7930 QETH_DBF_TEXT_(setup
, 2, "4err%d", rc
);
7933 if ((rc
= qeth_softsetup_card(card
))){
7934 QETH_DBF_TEXT_(setup
, 2, "5err%d", rc
);
7938 if ((rc
= qeth_init_qdio_queues(card
))){
7939 QETH_DBF_TEXT_(setup
, 2, "6err%d", rc
);
7942 card
->state
= CARD_STATE_SOFTSETUP
;
7943 netif_carrier_on(card
->dev
);
7945 qeth_set_allowed_threads(card
, 0xffffffff, 0);
7946 if (recover_flag
== CARD_STATE_RECOVER
)
7947 qeth_start_again(card
, recovery_mode
);
7948 qeth_notify_processes();
7951 card
->use_hard_stop
= 1;
7952 qeth_stop_card(card
, 0);
7953 ccw_device_set_offline(CARD_DDEV(card
));
7954 ccw_device_set_offline(CARD_WDEV(card
));
7955 ccw_device_set_offline(CARD_RDEV(card
));
7956 if (recover_flag
== CARD_STATE_RECOVER
)
7957 card
->state
= CARD_STATE_RECOVER
;
7959 card
->state
= CARD_STATE_DOWN
;
7964 qeth_set_online(struct ccwgroup_device
*gdev
)
7966 return __qeth_set_online(gdev
, 0);
7969 static struct ccw_device_id qeth_ids
[] = {
7970 {CCW_DEVICE(0x1731, 0x01), .driver_info
= QETH_CARD_TYPE_OSAE
},
7971 {CCW_DEVICE(0x1731, 0x05), .driver_info
= QETH_CARD_TYPE_IQD
},
7972 {CCW_DEVICE(0x1731, 0x06), .driver_info
= QETH_CARD_TYPE_OSN
},
7975 MODULE_DEVICE_TABLE(ccw
, qeth_ids
);
7977 struct device
*qeth_root_dev
= NULL
;
7979 struct ccwgroup_driver qeth_ccwgroup_driver
= {
7980 .owner
= THIS_MODULE
,
7982 .driver_id
= 0xD8C5E3C8,
7983 .probe
= qeth_probe_device
,
7984 .remove
= qeth_remove_device
,
7985 .set_online
= qeth_set_online
,
7986 .set_offline
= qeth_set_offline
,
7989 struct ccw_driver qeth_ccw_driver
= {
7992 .probe
= ccwgroup_probe_ccwdev
,
7993 .remove
= ccwgroup_remove_ccwdev
,
7998 qeth_unregister_dbf_views(void)
8001 debug_unregister(qeth_dbf_setup
);
8003 debug_unregister(qeth_dbf_qerr
);
8005 debug_unregister(qeth_dbf_sense
);
8007 debug_unregister(qeth_dbf_misc
);
8009 debug_unregister(qeth_dbf_data
);
8010 if (qeth_dbf_control
)
8011 debug_unregister(qeth_dbf_control
);
8013 debug_unregister(qeth_dbf_trace
);
8016 qeth_register_dbf_views(void)
8018 qeth_dbf_setup
= debug_register(QETH_DBF_SETUP_NAME
,
8019 QETH_DBF_SETUP_PAGES
,
8020 QETH_DBF_SETUP_NR_AREAS
,
8021 QETH_DBF_SETUP_LEN
);
8022 qeth_dbf_misc
= debug_register(QETH_DBF_MISC_NAME
,
8023 QETH_DBF_MISC_PAGES
,
8024 QETH_DBF_MISC_NR_AREAS
,
8026 qeth_dbf_data
= debug_register(QETH_DBF_DATA_NAME
,
8027 QETH_DBF_DATA_PAGES
,
8028 QETH_DBF_DATA_NR_AREAS
,
8030 qeth_dbf_control
= debug_register(QETH_DBF_CONTROL_NAME
,
8031 QETH_DBF_CONTROL_PAGES
,
8032 QETH_DBF_CONTROL_NR_AREAS
,
8033 QETH_DBF_CONTROL_LEN
);
8034 qeth_dbf_sense
= debug_register(QETH_DBF_SENSE_NAME
,
8035 QETH_DBF_SENSE_PAGES
,
8036 QETH_DBF_SENSE_NR_AREAS
,
8037 QETH_DBF_SENSE_LEN
);
8038 qeth_dbf_qerr
= debug_register(QETH_DBF_QERR_NAME
,
8039 QETH_DBF_QERR_PAGES
,
8040 QETH_DBF_QERR_NR_AREAS
,
8042 qeth_dbf_trace
= debug_register(QETH_DBF_TRACE_NAME
,
8043 QETH_DBF_TRACE_PAGES
,
8044 QETH_DBF_TRACE_NR_AREAS
,
8045 QETH_DBF_TRACE_LEN
);
8047 if ((qeth_dbf_setup
== NULL
) || (qeth_dbf_misc
== NULL
) ||
8048 (qeth_dbf_data
== NULL
) || (qeth_dbf_control
== NULL
) ||
8049 (qeth_dbf_sense
== NULL
) || (qeth_dbf_qerr
== NULL
) ||
8050 (qeth_dbf_trace
== NULL
)) {
8051 qeth_unregister_dbf_views();
8054 debug_register_view(qeth_dbf_setup
, &debug_hex_ascii_view
);
8055 debug_set_level(qeth_dbf_setup
, QETH_DBF_SETUP_LEVEL
);
8057 debug_register_view(qeth_dbf_misc
, &debug_hex_ascii_view
);
8058 debug_set_level(qeth_dbf_misc
, QETH_DBF_MISC_LEVEL
);
8060 debug_register_view(qeth_dbf_data
, &debug_hex_ascii_view
);
8061 debug_set_level(qeth_dbf_data
, QETH_DBF_DATA_LEVEL
);
8063 debug_register_view(qeth_dbf_control
, &debug_hex_ascii_view
);
8064 debug_set_level(qeth_dbf_control
, QETH_DBF_CONTROL_LEVEL
);
8066 debug_register_view(qeth_dbf_sense
, &debug_hex_ascii_view
);
8067 debug_set_level(qeth_dbf_sense
, QETH_DBF_SENSE_LEVEL
);
8069 debug_register_view(qeth_dbf_qerr
, &debug_hex_ascii_view
);
8070 debug_set_level(qeth_dbf_qerr
, QETH_DBF_QERR_LEVEL
);
8072 debug_register_view(qeth_dbf_trace
, &debug_hex_ascii_view
);
8073 debug_set_level(qeth_dbf_trace
, QETH_DBF_TRACE_LEVEL
);
8078 #ifdef CONFIG_QETH_IPV6
8079 extern struct neigh_table arp_tbl
;
8080 static struct neigh_ops
*arp_direct_ops
;
8081 static int (*qeth_old_arp_constructor
) (struct neighbour
*);
8083 static struct neigh_ops arp_direct_ops_template
= {
8086 .error_report
= NULL
,
8087 .output
= dev_queue_xmit
,
8088 .connected_output
= dev_queue_xmit
,
8089 .hh_output
= dev_queue_xmit
,
8090 .queue_xmit
= dev_queue_xmit
8094 qeth_arp_constructor(struct neighbour
*neigh
)
8096 struct net_device
*dev
= neigh
->dev
;
8097 struct in_device
*in_dev
;
8098 struct neigh_parms
*parms
;
8099 struct qeth_card
*card
;
8101 card
= qeth_get_card_from_dev(dev
);
8104 if((card
->options
.layer2
) ||
8105 (card
->dev
->hard_header
== qeth_fake_header
))
8109 in_dev
= __in_dev_get_rcu(dev
);
8110 if (in_dev
== NULL
) {
8115 parms
= in_dev
->arp_parms
;
8116 __neigh_parms_put(neigh
->parms
);
8117 neigh
->parms
= neigh_parms_clone(parms
);
8120 neigh
->type
= inet_addr_type(*(__be32
*) neigh
->primary_key
);
8121 neigh
->nud_state
= NUD_NOARP
;
8122 neigh
->ops
= arp_direct_ops
;
8123 neigh
->output
= neigh
->ops
->queue_xmit
;
8126 return qeth_old_arp_constructor(neigh
);
8128 #endif /*CONFIG_QETH_IPV6*/
8131 * IP address takeover related functions
8134 qeth_clear_ipato_list(struct qeth_card
*card
)
8136 struct qeth_ipato_entry
*ipatoe
, *tmp
;
8137 unsigned long flags
;
8139 spin_lock_irqsave(&card
->ip_lock
, flags
);
8140 list_for_each_entry_safe(ipatoe
, tmp
, &card
->ipato
.entries
, entry
) {
8141 list_del(&ipatoe
->entry
);
8144 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
8148 qeth_add_ipato_entry(struct qeth_card
*card
, struct qeth_ipato_entry
*new)
8150 struct qeth_ipato_entry
*ipatoe
;
8151 unsigned long flags
;
8154 QETH_DBF_TEXT(trace
, 2, "addipato");
8155 spin_lock_irqsave(&card
->ip_lock
, flags
);
8156 list_for_each_entry(ipatoe
, &card
->ipato
.entries
, entry
){
8157 if (ipatoe
->proto
!= new->proto
)
8159 if (!memcmp(ipatoe
->addr
, new->addr
,
8160 (ipatoe
->proto
== QETH_PROT_IPV4
)? 4:16) &&
8161 (ipatoe
->mask_bits
== new->mask_bits
)){
8162 PRINT_WARN("ipato entry already exists!\n");
8168 list_add_tail(&new->entry
, &card
->ipato
.entries
);
8170 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
8175 qeth_del_ipato_entry(struct qeth_card
*card
, enum qeth_prot_versions proto
,
8176 u8
*addr
, int mask_bits
)
8178 struct qeth_ipato_entry
*ipatoe
, *tmp
;
8179 unsigned long flags
;
8181 QETH_DBF_TEXT(trace
, 2, "delipato");
8182 spin_lock_irqsave(&card
->ip_lock
, flags
);
8183 list_for_each_entry_safe(ipatoe
, tmp
, &card
->ipato
.entries
, entry
){
8184 if (ipatoe
->proto
!= proto
)
8186 if (!memcmp(ipatoe
->addr
, addr
,
8187 (proto
== QETH_PROT_IPV4
)? 4:16) &&
8188 (ipatoe
->mask_bits
== mask_bits
)){
8189 list_del(&ipatoe
->entry
);
8193 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
8197 qeth_convert_addr_to_bits(u8
*addr
, u8
*bits
, int len
)
8202 for (i
= 0; i
< len
; ++i
){
8204 for (j
= 7; j
>= 0; --j
){
8205 bits
[i
*8 + j
] = octet
& 1;
8212 qeth_is_addr_covered_by_ipato(struct qeth_card
*card
, struct qeth_ipaddr
*addr
)
8214 struct qeth_ipato_entry
*ipatoe
;
8215 u8 addr_bits
[128] = {0, };
8216 u8 ipatoe_bits
[128] = {0, };
8219 if (!card
->ipato
.enabled
)
8222 qeth_convert_addr_to_bits((u8
*) &addr
->u
, addr_bits
,
8223 (addr
->proto
== QETH_PROT_IPV4
)? 4:16);
8224 list_for_each_entry(ipatoe
, &card
->ipato
.entries
, entry
){
8225 if (addr
->proto
!= ipatoe
->proto
)
8227 qeth_convert_addr_to_bits(ipatoe
->addr
, ipatoe_bits
,
8228 (ipatoe
->proto
==QETH_PROT_IPV4
) ?
8230 if (addr
->proto
== QETH_PROT_IPV4
)
8231 rc
= !memcmp(addr_bits
, ipatoe_bits
,
8232 min(32, ipatoe
->mask_bits
));
8234 rc
= !memcmp(addr_bits
, ipatoe_bits
,
8235 min(128, ipatoe
->mask_bits
));
8240 if ((addr
->proto
== QETH_PROT_IPV4
) && card
->ipato
.invert4
)
8242 else if ((addr
->proto
== QETH_PROT_IPV6
) && card
->ipato
.invert6
)
8249 * VIPA related functions
8252 qeth_add_vipa(struct qeth_card
*card
, enum qeth_prot_versions proto
,
8255 struct qeth_ipaddr
*ipaddr
;
8256 unsigned long flags
;
8259 ipaddr
= qeth_get_addr_buffer(proto
);
8261 if (proto
== QETH_PROT_IPV4
){
8262 QETH_DBF_TEXT(trace
, 2, "addvipa4");
8263 memcpy(&ipaddr
->u
.a4
.addr
, addr
, 4);
8264 ipaddr
->u
.a4
.mask
= 0;
8265 #ifdef CONFIG_QETH_IPV6
8266 } else if (proto
== QETH_PROT_IPV6
){
8267 QETH_DBF_TEXT(trace
, 2, "addvipa6");
8268 memcpy(&ipaddr
->u
.a6
.addr
, addr
, 16);
8269 ipaddr
->u
.a6
.pfxlen
= 0;
8272 ipaddr
->type
= QETH_IP_TYPE_VIPA
;
8273 ipaddr
->set_flags
= QETH_IPA_SETIP_VIPA_FLAG
;
8274 ipaddr
->del_flags
= QETH_IPA_DELIP_VIPA_FLAG
;
8277 spin_lock_irqsave(&card
->ip_lock
, flags
);
8278 if (__qeth_address_exists_in_list(&card
->ip_list
, ipaddr
, 0) ||
8279 __qeth_address_exists_in_list(card
->ip_tbd_list
, ipaddr
, 0))
8281 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
8283 PRINT_WARN("Cannot add VIPA. Address already exists!\n");
8286 if (!qeth_add_ip(card
, ipaddr
))
8288 qeth_set_ip_addr_list(card
);
8293 qeth_del_vipa(struct qeth_card
*card
, enum qeth_prot_versions proto
,
8296 struct qeth_ipaddr
*ipaddr
;
8298 ipaddr
= qeth_get_addr_buffer(proto
);
8300 if (proto
== QETH_PROT_IPV4
){
8301 QETH_DBF_TEXT(trace
, 2, "delvipa4");
8302 memcpy(&ipaddr
->u
.a4
.addr
, addr
, 4);
8303 ipaddr
->u
.a4
.mask
= 0;
8304 #ifdef CONFIG_QETH_IPV6
8305 } else if (proto
== QETH_PROT_IPV6
){
8306 QETH_DBF_TEXT(trace
, 2, "delvipa6");
8307 memcpy(&ipaddr
->u
.a6
.addr
, addr
, 16);
8308 ipaddr
->u
.a6
.pfxlen
= 0;
8311 ipaddr
->type
= QETH_IP_TYPE_VIPA
;
8314 if (!qeth_delete_ip(card
, ipaddr
))
8316 qeth_set_ip_addr_list(card
);
8320 * proxy ARP related functions
8323 qeth_add_rxip(struct qeth_card
*card
, enum qeth_prot_versions proto
,
8326 struct qeth_ipaddr
*ipaddr
;
8327 unsigned long flags
;
8330 ipaddr
= qeth_get_addr_buffer(proto
);
8332 if (proto
== QETH_PROT_IPV4
){
8333 QETH_DBF_TEXT(trace
, 2, "addrxip4");
8334 memcpy(&ipaddr
->u
.a4
.addr
, addr
, 4);
8335 ipaddr
->u
.a4
.mask
= 0;
8336 #ifdef CONFIG_QETH_IPV6
8337 } else if (proto
== QETH_PROT_IPV6
){
8338 QETH_DBF_TEXT(trace
, 2, "addrxip6");
8339 memcpy(&ipaddr
->u
.a6
.addr
, addr
, 16);
8340 ipaddr
->u
.a6
.pfxlen
= 0;
8343 ipaddr
->type
= QETH_IP_TYPE_RXIP
;
8344 ipaddr
->set_flags
= QETH_IPA_SETIP_TAKEOVER_FLAG
;
8345 ipaddr
->del_flags
= 0;
8348 spin_lock_irqsave(&card
->ip_lock
, flags
);
8349 if (__qeth_address_exists_in_list(&card
->ip_list
, ipaddr
, 0) ||
8350 __qeth_address_exists_in_list(card
->ip_tbd_list
, ipaddr
, 0))
8352 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
8354 PRINT_WARN("Cannot add RXIP. Address already exists!\n");
8357 if (!qeth_add_ip(card
, ipaddr
))
8359 qeth_set_ip_addr_list(card
);
8364 qeth_del_rxip(struct qeth_card
*card
, enum qeth_prot_versions proto
,
8367 struct qeth_ipaddr
*ipaddr
;
8369 ipaddr
= qeth_get_addr_buffer(proto
);
8371 if (proto
== QETH_PROT_IPV4
){
8372 QETH_DBF_TEXT(trace
, 2, "addrxip4");
8373 memcpy(&ipaddr
->u
.a4
.addr
, addr
, 4);
8374 ipaddr
->u
.a4
.mask
= 0;
8375 #ifdef CONFIG_QETH_IPV6
8376 } else if (proto
== QETH_PROT_IPV6
){
8377 QETH_DBF_TEXT(trace
, 2, "addrxip6");
8378 memcpy(&ipaddr
->u
.a6
.addr
, addr
, 16);
8379 ipaddr
->u
.a6
.pfxlen
= 0;
8382 ipaddr
->type
= QETH_IP_TYPE_RXIP
;
8385 if (!qeth_delete_ip(card
, ipaddr
))
8387 qeth_set_ip_addr_list(card
);
8394 qeth_ip_event(struct notifier_block
*this,
8395 unsigned long event
,void *ptr
)
8397 struct in_ifaddr
*ifa
= (struct in_ifaddr
*)ptr
;
8398 struct net_device
*dev
=(struct net_device
*) ifa
->ifa_dev
->dev
;
8399 struct qeth_ipaddr
*addr
;
8400 struct qeth_card
*card
;
8402 QETH_DBF_TEXT(trace
,3,"ipevent");
8403 card
= qeth_get_card_from_dev(dev
);
8406 if (card
->options
.layer2
)
8409 addr
= qeth_get_addr_buffer(QETH_PROT_IPV4
);
8411 addr
->u
.a4
.addr
= ifa
->ifa_address
;
8412 addr
->u
.a4
.mask
= ifa
->ifa_mask
;
8413 addr
->type
= QETH_IP_TYPE_NORMAL
;
8419 if (!qeth_add_ip(card
, addr
))
8423 if (!qeth_delete_ip(card
, addr
))
8429 qeth_set_ip_addr_list(card
);
8434 static struct notifier_block qeth_ip_notifier
= {
8439 #ifdef CONFIG_QETH_IPV6
8441 * IPv6 event handler
8444 qeth_ip6_event(struct notifier_block
*this,
8445 unsigned long event
,void *ptr
)
8448 struct inet6_ifaddr
*ifa
= (struct inet6_ifaddr
*)ptr
;
8449 struct net_device
*dev
= (struct net_device
*)ifa
->idev
->dev
;
8450 struct qeth_ipaddr
*addr
;
8451 struct qeth_card
*card
;
8453 QETH_DBF_TEXT(trace
,3,"ip6event");
8455 card
= qeth_get_card_from_dev(dev
);
8458 if (!qeth_is_supported(card
, IPA_IPV6
))
8461 addr
= qeth_get_addr_buffer(QETH_PROT_IPV6
);
8463 memcpy(&addr
->u
.a6
.addr
, &ifa
->addr
, sizeof(struct in6_addr
));
8464 addr
->u
.a6
.pfxlen
= ifa
->prefix_len
;
8465 addr
->type
= QETH_IP_TYPE_NORMAL
;
8471 if (!qeth_add_ip(card
, addr
))
8475 if (!qeth_delete_ip(card
, addr
))
8481 qeth_set_ip_addr_list(card
);
8486 static struct notifier_block qeth_ip6_notifier
= {
8493 __qeth_reboot_event_card(struct device
*dev
, void *data
)
8495 struct qeth_card
*card
;
8497 card
= (struct qeth_card
*) dev
->driver_data
;
8498 qeth_clear_ip_list(card
, 0, 0);
8499 qeth_qdio_clear_card(card
, 0);
8504 qeth_reboot_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
8508 ret
= driver_for_each_device(&qeth_ccwgroup_driver
.driver
, NULL
, NULL
,
8509 __qeth_reboot_event_card
);
8510 return ret
? NOTIFY_BAD
: NOTIFY_DONE
;
8514 static struct notifier_block qeth_reboot_notifier
= {
8520 qeth_register_notifiers(void)
8524 QETH_DBF_TEXT(trace
,5,"regnotif");
8525 if ((r
= register_reboot_notifier(&qeth_reboot_notifier
)))
8527 if ((r
= register_inetaddr_notifier(&qeth_ip_notifier
)))
8529 #ifdef CONFIG_QETH_IPV6
8530 if ((r
= register_inet6addr_notifier(&qeth_ip6_notifier
)))
8535 #ifdef CONFIG_QETH_IPV6
8537 unregister_inetaddr_notifier(&qeth_ip_notifier
);
8540 unregister_reboot_notifier(&qeth_reboot_notifier
);
8545 * unregister all event notifiers
8548 qeth_unregister_notifiers(void)
8551 QETH_DBF_TEXT(trace
,5,"unregnot");
8552 BUG_ON(unregister_reboot_notifier(&qeth_reboot_notifier
));
8553 BUG_ON(unregister_inetaddr_notifier(&qeth_ip_notifier
));
8554 #ifdef CONFIG_QETH_IPV6
8555 BUG_ON(unregister_inet6addr_notifier(&qeth_ip6_notifier
));
8556 #endif /* QETH_IPV6 */
8560 #ifdef CONFIG_QETH_IPV6
8562 qeth_ipv6_init(void)
8564 qeth_old_arp_constructor
= arp_tbl
.constructor
;
8565 write_lock_bh(&arp_tbl
.lock
);
8566 arp_tbl
.constructor
= qeth_arp_constructor
;
8567 write_unlock_bh(&arp_tbl
.lock
);
8569 arp_direct_ops
= (struct neigh_ops
*)
8570 kmalloc(sizeof(struct neigh_ops
), GFP_KERNEL
);
8571 if (!arp_direct_ops
)
8574 memcpy(arp_direct_ops
, &arp_direct_ops_template
,
8575 sizeof(struct neigh_ops
));
8581 qeth_ipv6_uninit(void)
8583 write_lock_bh(&arp_tbl
.lock
);
8584 arp_tbl
.constructor
= qeth_old_arp_constructor
;
8585 write_unlock_bh(&arp_tbl
.lock
);
8586 kfree(arp_direct_ops
);
8588 #endif /* CONFIG_QETH_IPV6 */
8591 qeth_sysfs_unregister(void)
8593 s390_root_dev_unregister(qeth_root_dev
);
8594 qeth_remove_driver_attributes();
8595 ccw_driver_unregister(&qeth_ccw_driver
);
8596 ccwgroup_driver_unregister(&qeth_ccwgroup_driver
);
8600 * register qeth at sysfs
8603 qeth_sysfs_register(void)
8607 rc
= ccwgroup_driver_register(&qeth_ccwgroup_driver
);
8611 rc
= ccw_driver_register(&qeth_ccw_driver
);
8613 goto out_ccw_driver
;
8615 rc
= qeth_create_driver_attributes();
8619 qeth_root_dev
= s390_root_dev_register("qeth");
8620 rc
= IS_ERR(qeth_root_dev
) ? PTR_ERR(qeth_root_dev
) : 0;
8624 qeth_remove_driver_attributes();
8626 ccw_driver_unregister(&qeth_ccw_driver
);
8628 ccwgroup_driver_unregister(&qeth_ccwgroup_driver
);
8641 PRINT_INFO("loading %s\n", version
);
8643 INIT_LIST_HEAD(&qeth_card_list
.list
);
8644 INIT_LIST_HEAD(&qeth_notify_list
);
8645 spin_lock_init(&qeth_notify_lock
);
8646 rwlock_init(&qeth_card_list
.rwlock
);
8648 rc
= qeth_register_dbf_views();
8652 rc
= qeth_sysfs_register();
8656 #ifdef CONFIG_QETH_IPV6
8657 rc
= qeth_ipv6_init();
8659 PRINT_ERR("Out of memory during ipv6 init code = %d\n", rc
);
8662 #endif /* QETH_IPV6 */
8663 rc
= qeth_register_notifiers();
8666 rc
= qeth_create_procfs_entries();
8673 qeth_unregister_notifiers();
8675 #ifdef CONFIG_QETH_IPV6
8678 #endif /* QETH_IPV6 */
8679 qeth_sysfs_unregister();
8681 qeth_unregister_dbf_views();
8683 PRINT_ERR("Initialization failed with code %d\n", rc
);
8688 __exit
qeth_exit(void)
8690 struct qeth_card
*card
, *tmp
;
8691 unsigned long flags
;
8693 QETH_DBF_TEXT(trace
,1, "cleanup.");
8696 * Weed would not need to clean up our devices here, because the
8697 * common device layer calls qeth_remove_device for each device
8698 * as soon as we unregister our driver (done in qeth_sysfs_unregister).
8699 * But we do cleanup here so we can do a "soft" shutdown of our cards.
8700 * qeth_remove_device called by the common device layer would otherwise
8701 * do a "hard" shutdown (card->use_hard_stop is set to one in
8702 * qeth_remove_device).
8705 read_lock_irqsave(&qeth_card_list
.rwlock
, flags
);
8706 list_for_each_entry_safe(card
, tmp
, &qeth_card_list
.list
, list
){
8707 read_unlock_irqrestore(&qeth_card_list
.rwlock
, flags
);
8708 qeth_set_offline(card
->gdev
);
8709 qeth_remove_device(card
->gdev
);
8712 read_unlock_irqrestore(&qeth_card_list
.rwlock
, flags
);
8713 #ifdef CONFIG_QETH_IPV6
8716 qeth_unregister_notifiers();
8717 qeth_remove_procfs_entries();
8718 qeth_sysfs_unregister();
8719 qeth_unregister_dbf_views();
8720 printk("qeth: removed\n");
8723 EXPORT_SYMBOL(qeth_osn_register
);
8724 EXPORT_SYMBOL(qeth_osn_deregister
);
8725 EXPORT_SYMBOL(qeth_osn_assist
);
8726 module_init(qeth_init
);
8727 module_exit(qeth_exit
);
8728 MODULE_AUTHOR("Frank Pavlic <fpavlic@de.ibm.com>");
8729 MODULE_DESCRIPTION("Linux on zSeries OSA Express and HiperSockets support\n" \
8730 "Copyright 2000,2003 IBM Corporation\n");
8732 MODULE_LICENSE("GPL");