← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to drivers/net/benet/be_cmds.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno
  • Date: 2011-06-07 12:14:05 UTC
  • mfrom: (43.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20110607121405-i3h1rd7nrnd2b73h
Tags: 2.6.39-2
http://bugs.debian.org/627492
http://bugs.debian.org/596626
http://bugs.debian.org/628932
http://bugs.debian.org/628191
http://bugs.debian.org/627837
http://bugs.debian.org/622997
http://bugs.debian.org/622745
http://bugs.debian.org/619827
http://bugs.debian.org/629401
[ Ben Hutchings ]
* [x86] Enable BACKLIGHT_APPLE, replacing BACKLIGHT_MBP_NVIDIA
  (Closes: #627492)
* cgroups: Disable memory resource controller by default. Allow it
  to be enabled using kernel parameter 'cgroup_enable=memory'.
* rt2800usb: Enable support for more USB devices including
  Linksys WUSB600N (Closes: #596626) (this change was accidentally
  omitted from 2.6.39-1)
* [x86] Remove Celeron from list of processors supporting PAE. Most
  'Celeron M' models do not.
* Update debconf template translations:
  - Swedish (Martin Bagge) (Closes: #628932)
  - French (David Prévot) (Closes: #628191)
* aufs: Update for 2.6.39 (Closes: #627837)
* Add stable 2.6.39.1, including:
  - ext4: dont set PageUptodate in ext4_end_bio()
  - pata_cmd64x: fix boot crash on parisc (Closes: #622997, #622745)
  - ext3: Fix fs corruption when make_indexed_dir() fails
  - netfilter: nf_ct_sip: validate Content-Length in TCP SIP messages
  - sctp: fix race between sctp_bind_addr_free() and
    sctp_bind_addr_conflict()
  - sctp: fix memory leak of the ASCONF queue when free asoc
  - md/bitmap: fix saving of events_cleared and other state
  - cdc_acm: Fix oops when Droids MuIn LCD is connected
  - cx88: Fix conversion from BKL to fine-grained locks (Closes: #619827)
  - keys: Set cred->user_ns in key_replace_session_keyring (CVE-2011-2184)
  - tmpfs: fix race between truncate and writepage
  - nfs41: Correct offset for LAYOUTCOMMIT
  - xen/mmu: fix a race window causing leave_mm BUG()
  - ext4: fix possible use-after-free in ext4_remove_li_request()
  For the complete list of changes, see:
   http://www.kernel.org/pub/linux/kernel/v2.6/ChangeLog-2.6.39.1
* Bump ABI to 2
* netfilter: Enable IP_SET, IP_SET_BITMAP_IP, IP_SET_BITMAP_IPMAC,
  IP_SET_BITMAP_PORT, IP_SET_HASH_IP, IP_SET_HASH_IPPORT,
  IP_SET_HASH_IPPORTIP, IP_SET_HASH_IPPORTNET, IP_SET_HASH_NET,
  IP_SET_HASH_NETPORT, IP_SET_LIST_SET, NETFILTER_XT_SET as modules
  (Closes: #629401)

[ Aurelien Jarno ]
* [mipsel/loongson-2f] Disable_SCSI_LPFC to workaround GCC ICE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/benet/be_cmds.c
1
1
/*
2
 
 * Copyright (C) 2005 - 2010 ServerEngines
 
2
 * Copyright (C) 2005 - 2011 Emulex
3
3
 * All rights reserved.
4
4
 *
5
5
 * This program is free software; you can redistribute it and/or
8
8
 * Public License is included in this distribution in the file called COPYING.
9
9
 *
10
10
 * Contact Information:
11
 
 * linux-drivers@serverengines.com
 
11
 * linux-drivers@emulex.com
12
12
 *
13
 
 * ServerEngines
14
 
 * 209 N. Fair Oaks Ave
15
 
 * Sunnyvale, CA 94085
 
13
 * Emulex
 
14
 * 3333 Susan Street
 
15
 * Costa Mesa, CA 92626
16
16
 */
17
17
 
18
18
#include "be.h"
19
19
#include "be_cmds.h"
20
20
 
 
21
/* Must be a power of 2 or else MODULO will BUG_ON */
 
22
static int be_get_temp_freq = 32;
 
23
 
21
24
static void be_mcc_notify(struct be_adapter *adapter)
22
25
{
23
26
        struct be_queue_info *mccq = &adapter->mcc_obj.q;
24
27
        u32 val = 0;
25
28
 
 
29
        if (adapter->eeh_err) {
 
30
                dev_info(&adapter->pdev->dev,
 
31
                        "Error in Card Detected! Cannot issue commands\n");
 
32
                return;
 
33
        }
 
34
 
26
35
        val |= mccq->id & DB_MCCQ_RING_ID_MASK;
27
36
        val |= 1 << DB_MCCQ_NUM_POSTED_SHIFT;
28
37
 
75
84
                        be_dws_le_to_cpu(&resp->hw_stats,
76
85
                                                sizeof(resp->hw_stats));
77
86
                        netdev_stats_update(adapter);
78
 
                        adapter->stats_ioctl_sent = false;
 
87
                        adapter->stats_cmd_sent = false;
79
88
                }
80
89
        } else if ((compl_status != MCC_STATUS_NOT_SUPPORTED) &&
81
90
                   (compl->tag0 != OPCODE_COMMON_NTWK_MAC_QUERY)) {
102
111
{
103
112
        if (evt->valid) {
104
113
                adapter->vlan_prio_bmap = evt->available_priority_bmap;
 
114
                adapter->recommended_prio &= ~VLAN_PRIO_MASK;
105
115
                adapter->recommended_prio =
106
116
                        evt->reco_default_priority << VLAN_PRIO_SHIFT;
107
117
        }
117
127
        }
118
128
}
119
129
 
 
130
/*Grp5 PVID evt*/
 
131
static void be_async_grp5_pvid_state_process(struct be_adapter *adapter,
 
132
                struct be_async_event_grp5_pvid_state *evt)
 
133
{
 
134
        if (evt->enabled)
 
135
                adapter->pvid = le16_to_cpu(evt->tag);
 
136
        else
 
137
                adapter->pvid = 0;
 
138
}
 
139
 
120
140
static void be_async_grp5_evt_process(struct be_adapter *adapter,
121
141
                u32 trailer, struct be_mcc_compl *evt)
122
142
{
134
154
                be_async_grp5_qos_speed_process(adapter,
135
155
                (struct be_async_event_grp5_qos_link_speed *)evt);
136
156
        break;
 
157
        case ASYNC_EVENT_PVID_STATE:
 
158
                be_async_grp5_pvid_state_process(adapter,
 
159
                (struct be_async_event_grp5_pvid_state *)evt);
 
160
        break;
137
161
        default:
138
162
                dev_warn(&adapter->pdev->dev, "Unknown grp5 event!\n");
139
163
                break;
216
240
        int i, num, status = 0;
217
241
        struct be_mcc_obj *mcc_obj = &adapter->mcc_obj;
218
242
 
 
243
        if (adapter->eeh_err)
 
244
                return -EIO;
 
245
 
219
246
        for (i = 0; i < mcc_timeout; i++) {
220
247
                num = be_process_mcc(adapter, &status);
221
248
                if (num)
245
272
        int msecs = 0;
246
273
        u32 ready;
247
274
 
 
275
        if (adapter->eeh_err) {
 
276
                dev_err(&adapter->pdev->dev,
 
277
                        "Error detected in card.Cannot issue commands\n");
 
278
                return -EIO;
 
279
        }
 
280
 
248
281
        do {
249
282
                ready = ioread32(db);
250
283
                if (ready == 0xffffffff) {
598
631
 
599
632
/* Uses synchronous MCCQ */
600
633
int be_cmd_pmac_add(struct be_adapter *adapter, u8 *mac_addr,
601
 
                u32 if_id, u32 *pmac_id)
 
634
                u32 if_id, u32 *pmac_id, u32 domain)
602
635
{
603
636
        struct be_mcc_wrb *wrb;
604
637
        struct be_cmd_req_pmac_add *req;
619
652
        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
620
653
                OPCODE_COMMON_NTWK_PMAC_ADD, sizeof(*req));
621
654
 
 
655
        req->hdr.domain = domain;
622
656
        req->if_id = cpu_to_le32(if_id);
623
657
        memcpy(req->mac_address, mac_addr, ETH_ALEN);
624
658
 
634
668
}
635
669
 
636
670
/* Uses synchronous MCCQ */
637
 
int be_cmd_pmac_del(struct be_adapter *adapter, u32 if_id, u32 pmac_id)
 
671
int be_cmd_pmac_del(struct be_adapter *adapter, u32 if_id, u32 pmac_id, u32 dom)
638
672
{
639
673
        struct be_mcc_wrb *wrb;
640
674
        struct be_cmd_req_pmac_del *req;
655
689
        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
656
690
                OPCODE_COMMON_NTWK_PMAC_DEL, sizeof(*req));
657
691
 
 
692
        req->hdr.domain = dom;
658
693
        req->if_id = cpu_to_le32(if_id);
659
694
        req->pmac_id = cpu_to_le32(pmac_id);
660
695
 
691
726
 
692
727
        req->num_pages =  cpu_to_le16(PAGES_4K_SPANNED(q_mem->va, q_mem->size));
693
728
        if (lancer_chip(adapter)) {
694
 
                req->hdr.version = 1;
 
729
                req->hdr.version = 2;
695
730
                req->page_size = 1; /* 1 for 4K */
696
731
                AMAP_SET_BITS(struct amap_cq_context_lancer, coalescwm, ctxt,
697
732
                                                                coalesce_wm);
827
862
        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ETH, OPCODE_ETH_TX_CREATE,
828
863
                sizeof(*req));
829
864
 
 
865
        if (lancer_chip(adapter)) {
 
866
                req->hdr.version = 1;
 
867
                AMAP_SET_BITS(struct amap_tx_context, if_id, ctxt,
 
868
                                        adapter->if_handle);
 
869
        }
 
870
 
830
871
        req->num_pages = PAGES_4K_SPANNED(q_mem->va, q_mem->size);
831
872
        req->ulp_num = BE_ULP1_NUM;
832
873
        req->type = BE_ETH_TX_RING_TYPE_STANDARD;
995
1036
}
996
1037
 
997
1038
/* Uses mbox */
998
 
int be_cmd_if_destroy(struct be_adapter *adapter, u32 interface_id)
 
1039
int be_cmd_if_destroy(struct be_adapter *adapter, u32 interface_id, u32 domain)
999
1040
{
1000
1041
        struct be_mcc_wrb *wrb;
1001
1042
        struct be_cmd_req_if_destroy *req;
1016
1057
        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
1017
1058
                OPCODE_COMMON_NTWK_INTERFACE_DESTROY, sizeof(*req));
1018
1059
 
 
1060
        req->hdr.domain = domain;
1019
1061
        req->interface_id = cpu_to_le32(interface_id);
1020
1062
 
1021
1063
        status = be_mbox_notify_wait(adapter);
1036
1078
        struct be_sge *sge;
1037
1079
        int status = 0;
1038
1080
 
 
1081
        if (MODULO(adapter->work_counter, be_get_temp_freq) == 0)
 
1082
                be_cmd_get_die_temperature(adapter);
 
1083
 
1039
1084
        spin_lock_bh(&adapter->mcc_lock);
1040
1085
 
1041
1086
        wrb = wrb_from_mccq(adapter);
1056
1101
        sge->len = cpu_to_le32(nonemb_cmd->size);
1057
1102
 
1058
1103
        be_mcc_notify(adapter);
1059
 
        adapter->stats_ioctl_sent = true;
 
1104
        adapter->stats_cmd_sent = true;
1060
1105
 
1061
1106
err:
1062
1107
        spin_unlock_bh(&adapter->mcc_lock);
1103
1148
        return status;
1104
1149
}
1105
1150
 
 
1151
/* Uses synchronous mcc */
 
1152
int be_cmd_get_die_temperature(struct be_adapter *adapter)
 
1153
{
 
1154
        struct be_mcc_wrb *wrb;
 
1155
        struct be_cmd_req_get_cntl_addnl_attribs *req;
 
1156
        int status;
 
1157
 
 
1158
        spin_lock_bh(&adapter->mcc_lock);
 
1159
 
 
1160
        wrb = wrb_from_mccq(adapter);
 
1161
        if (!wrb) {
 
1162
                status = -EBUSY;
 
1163
                goto err;
 
1164
        }
 
1165
        req = embedded_payload(wrb);
 
1166
 
 
1167
        be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0,
 
1168
                        OPCODE_COMMON_GET_CNTL_ADDITIONAL_ATTRIBUTES);
 
1169
 
 
1170
        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
 
1171
                OPCODE_COMMON_GET_CNTL_ADDITIONAL_ATTRIBUTES, sizeof(*req));
 
1172
 
 
1173
        status = be_mcc_notify_wait(adapter);
 
1174
        if (!status) {
 
1175
                struct be_cmd_resp_get_cntl_addnl_attribs *resp =
 
1176
                                                embedded_payload(wrb);
 
1177
                adapter->drv_stats.be_on_die_temperature =
 
1178
                                                resp->on_die_temperature;
 
1179
        }
 
1180
        /* If IOCTL fails once, do not bother issuing it again */
 
1181
        else
 
1182
                be_get_temp_freq = 0;
 
1183
 
 
1184
err:
 
1185
        spin_unlock_bh(&adapter->mcc_lock);
 
1186
        return status;
 
1187
}
 
1188
 
1106
1189
/* Uses Mbox */
1107
1190
int be_cmd_get_fw_ver(struct be_adapter *adapter, char *fw_ver)
1108
1191
{
1248
1331
 
1249
1332
/*
1250
1333
 * Uses MCC for this command as it may be called in BH context
1251
 
 * (mc == NULL) => multicast promiscous
 
1334
 * (mc == NULL) => multicast promiscuous
1252
1335
 */
1253
1336
int be_cmd_multicast_set(struct be_adapter *adapter, u32 if_id,
1254
1337
                struct net_device *netdev, struct be_dma_mem *mem)
1868
1951
                        OPCODE_COMMON_SET_QOS, sizeof(*req));
1869
1952
 
1870
1953
        req->hdr.domain = domain;
1871
 
        req->valid_bits = BE_QOS_BITS_NIC;
1872
 
        req->max_bps_nic = bps;
 
1954
        req->valid_bits = cpu_to_le32(BE_QOS_BITS_NIC);
 
1955
        req->max_bps_nic = cpu_to_le32(bps);
1873
1956
 
1874
1957
        status = be_mcc_notify_wait(adapter);
1875
1958
 
1877
1960
        spin_unlock_bh(&adapter->mcc_lock);
1878
1961
        return status;
1879
1962
}
 
1963
 
 
1964
int be_cmd_get_cntl_attributes(struct be_adapter *adapter)
 
1965
{
 
1966
        struct be_mcc_wrb *wrb;
 
1967
        struct be_cmd_req_cntl_attribs *req;
 
1968
        struct be_cmd_resp_cntl_attribs *resp;
 
1969
        struct be_sge *sge;
 
1970
        int status;
 
1971
        int payload_len = max(sizeof(*req), sizeof(*resp));
 
1972
        struct mgmt_controller_attrib *attribs;
 
1973
        struct be_dma_mem attribs_cmd;
 
1974
 
 
1975
        memset(&attribs_cmd, 0, sizeof(struct be_dma_mem));
 
1976
        attribs_cmd.size = sizeof(struct be_cmd_resp_cntl_attribs);
 
1977
        attribs_cmd.va = pci_alloc_consistent(adapter->pdev, attribs_cmd.size,
 
1978
                                                &attribs_cmd.dma);
 
1979
        if (!attribs_cmd.va) {
 
1980
                dev_err(&adapter->pdev->dev,
 
1981
                                "Memory allocation failure\n");
 
1982
                return -ENOMEM;
 
1983
        }
 
1984
 
 
1985
        if (mutex_lock_interruptible(&adapter->mbox_lock))
 
1986
                return -1;
 
1987
 
 
1988
        wrb = wrb_from_mbox(adapter);
 
1989
        if (!wrb) {
 
1990
                status = -EBUSY;
 
1991
                goto err;
 
1992
        }
 
1993
        req = attribs_cmd.va;
 
1994
        sge = nonembedded_sgl(wrb);
 
1995
 
 
1996
        be_wrb_hdr_prepare(wrb, payload_len, false, 1,
 
1997
                        OPCODE_COMMON_GET_CNTL_ATTRIBUTES);
 
1998
        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
 
1999
                         OPCODE_COMMON_GET_CNTL_ATTRIBUTES, payload_len);
 
2000
        sge->pa_hi = cpu_to_le32(upper_32_bits(attribs_cmd.dma));
 
2001
        sge->pa_lo = cpu_to_le32(attribs_cmd.dma & 0xFFFFFFFF);
 
2002
        sge->len = cpu_to_le32(attribs_cmd.size);
 
2003
 
 
2004
        status = be_mbox_notify_wait(adapter);
 
2005
        if (!status) {
 
2006
                attribs = (struct mgmt_controller_attrib *)( attribs_cmd.va +
 
2007
                                        sizeof(struct be_cmd_resp_hdr));
 
2008
                adapter->hba_port_num = attribs->hba_attribs.phy_port;
 
2009
        }
 
2010
 
 
2011
err:
 
2012
        mutex_unlock(&adapter->mbox_lock);
 
2013
        pci_free_consistent(adapter->pdev, attribs_cmd.size, attribs_cmd.va,
 
2014
                                        attribs_cmd.dma);
 
2015
        return status;
 
2016
}
 
2017
 
 
2018
/* Uses mbox */
 
2019
int be_cmd_check_native_mode(struct be_adapter *adapter)
 
2020
{
 
2021
        struct be_mcc_wrb *wrb;
 
2022
        struct be_cmd_req_set_func_cap *req;
 
2023
        int status;
 
2024
 
 
2025
        if (mutex_lock_interruptible(&adapter->mbox_lock))
 
2026
                return -1;
 
2027
 
 
2028
        wrb = wrb_from_mbox(adapter);
 
2029
        if (!wrb) {
 
2030
                status = -EBUSY;
 
2031
                goto err;
 
2032
        }
 
2033
 
 
2034
        req = embedded_payload(wrb);
 
2035
 
 
2036
        be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0,
 
2037
                OPCODE_COMMON_SET_DRIVER_FUNCTION_CAP);
 
2038
 
 
2039
        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
 
2040
                OPCODE_COMMON_SET_DRIVER_FUNCTION_CAP, sizeof(*req));
 
2041
 
 
2042
        req->valid_cap_flags = cpu_to_le32(CAPABILITY_SW_TIMESTAMPS |
 
2043
                                CAPABILITY_BE3_NATIVE_ERX_API);
 
2044
        req->cap_flags = cpu_to_le32(CAPABILITY_BE3_NATIVE_ERX_API);
 
2045
 
 
2046
        status = be_mbox_notify_wait(adapter);
 
2047
        if (!status) {
 
2048
                struct be_cmd_resp_set_func_cap *resp = embedded_payload(wrb);
 
2049
                adapter->be3_native = le32_to_cpu(resp->cap_flags) &
 
2050
                                        CAPABILITY_BE3_NATIVE_ERX_API;
 
2051
        }
 
2052
err:
 
2053
        mutex_unlock(&adapter->mbox_lock);
 
2054
        return status;
 
2055
}