← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/net/enic/enic_dev.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/enic/enic_dev.c
 
1
/*
 
2
 * Copyright 2011 Cisco Systems, Inc.  All rights reserved.
 
3
 *
 
4
 * This program is free software; you may redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License as published by
 
6
 * the Free Software Foundation; version 2 of the License.
 
7
 *
 
8
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
9
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
10
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
11
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 
12
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 
13
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 
14
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 
15
 * SOFTWARE.
 
16
 *
 
17
 */
 
18
 
 
19
#include <linux/pci.h>
 
20
#include <linux/etherdevice.h>
 
21
 
 
22
#include "vnic_dev.h"
 
23
#include "vnic_vic.h"
 
24
#include "enic_res.h"
 
25
#include "enic.h"
 
26
#include "enic_dev.h"
 
27
 
 
28
int enic_dev_fw_info(struct enic *enic, struct vnic_devcmd_fw_info **fw_info)
 
29
{
 
30
        int err;
 
31
 
 
32
        spin_lock(&enic->devcmd_lock);
 
33
        err = vnic_dev_fw_info(enic->vdev, fw_info);
 
34
        spin_unlock(&enic->devcmd_lock);
 
35
 
 
36
        return err;
 
37
}
 
38
 
 
39
int enic_dev_stats_dump(struct enic *enic, struct vnic_stats **vstats)
 
40
{
 
41
        int err;
 
42
 
 
43
        spin_lock(&enic->devcmd_lock);
 
44
        err = vnic_dev_stats_dump(enic->vdev, vstats);
 
45
        spin_unlock(&enic->devcmd_lock);
 
46
 
 
47
        return err;
 
48
}
 
49
 
 
50
int enic_dev_add_station_addr(struct enic *enic)
 
51
{
 
52
        int err;
 
53
 
 
54
        if (!is_valid_ether_addr(enic->netdev->dev_addr))
 
55
                return -EADDRNOTAVAIL;
 
56
 
 
57
        spin_lock(&enic->devcmd_lock);
 
58
        err = vnic_dev_add_addr(enic->vdev, enic->netdev->dev_addr);
 
59
        spin_unlock(&enic->devcmd_lock);
 
60
 
 
61
        return err;
 
62
}
 
63
 
 
64
int enic_dev_del_station_addr(struct enic *enic)
 
65
{
 
66
        int err;
 
67
 
 
68
        if (!is_valid_ether_addr(enic->netdev->dev_addr))
 
69
                return -EADDRNOTAVAIL;
 
70
 
 
71
        spin_lock(&enic->devcmd_lock);
 
72
        err = vnic_dev_del_addr(enic->vdev, enic->netdev->dev_addr);
 
73
        spin_unlock(&enic->devcmd_lock);
 
74
 
 
75
        return err;
 
76
}
 
77
 
 
78
int enic_dev_packet_filter(struct enic *enic, int directed, int multicast,
 
79
        int broadcast, int promisc, int allmulti)
 
80
{
 
81
        int err;
 
82
 
 
83
        spin_lock(&enic->devcmd_lock);
 
84
        err = vnic_dev_packet_filter(enic->vdev, directed,
 
85
                multicast, broadcast, promisc, allmulti);
 
86
        spin_unlock(&enic->devcmd_lock);
 
87
 
 
88
        return err;
 
89
}
 
90
 
 
91
int enic_dev_add_addr(struct enic *enic, u8 *addr)
 
92
{
 
93
        int err;
 
94
 
 
95
        spin_lock(&enic->devcmd_lock);
 
96
        err = vnic_dev_add_addr(enic->vdev, addr);
 
97
        spin_unlock(&enic->devcmd_lock);
 
98
 
 
99
        return err;
 
100
}
 
101
 
 
102
int enic_dev_del_addr(struct enic *enic, u8 *addr)
 
103
{
 
104
        int err;
 
105
 
 
106
        spin_lock(&enic->devcmd_lock);
 
107
        err = vnic_dev_del_addr(enic->vdev, addr);
 
108
        spin_unlock(&enic->devcmd_lock);
 
109
 
 
110
        return err;
 
111
}
 
112
 
 
113
int enic_dev_notify_unset(struct enic *enic)
 
114
{
 
115
        int err;
 
116
 
 
117
        spin_lock(&enic->devcmd_lock);
 
118
        err = vnic_dev_notify_unset(enic->vdev);
 
119
        spin_unlock(&enic->devcmd_lock);
 
120
 
 
121
        return err;
 
122
}
 
123
 
 
124
int enic_dev_hang_notify(struct enic *enic)
 
125
{
 
126
        int err;
 
127
 
 
128
        spin_lock(&enic->devcmd_lock);
 
129
        err = vnic_dev_hang_notify(enic->vdev);
 
130
        spin_unlock(&enic->devcmd_lock);
 
131
 
 
132
        return err;
 
133
}
 
134
 
 
135
int enic_dev_set_ig_vlan_rewrite_mode(struct enic *enic)
 
136
{
 
137
        int err;
 
138
 
 
139
        spin_lock(&enic->devcmd_lock);
 
140
        err = vnic_dev_set_ig_vlan_rewrite_mode(enic->vdev,
 
141
                IG_VLAN_REWRITE_MODE_PRIORITY_TAG_DEFAULT_VLAN);
 
142
        spin_unlock(&enic->devcmd_lock);
 
143
 
 
144
        return err;
 
145
}
 
146
 
 
147
int enic_dev_enable(struct enic *enic)
 
148
{
 
149
        int err;
 
150
 
 
151
        spin_lock(&enic->devcmd_lock);
 
152
        err = vnic_dev_enable_wait(enic->vdev);
 
153
        spin_unlock(&enic->devcmd_lock);
 
154
 
 
155
        return err;
 
156
}
 
157
 
 
158
int enic_dev_disable(struct enic *enic)
 
159
{
 
160
        int err;
 
161
 
 
162
        spin_lock(&enic->devcmd_lock);
 
163
        err = vnic_dev_disable(enic->vdev);
 
164
        spin_unlock(&enic->devcmd_lock);
 
165
 
 
166
        return err;
 
167
}
 
168
 
 
169
int enic_vnic_dev_deinit(struct enic *enic)
 
170
{
 
171
        int err;
 
172
 
 
173
        spin_lock(&enic->devcmd_lock);
 
174
        err = vnic_dev_deinit(enic->vdev);
 
175
        spin_unlock(&enic->devcmd_lock);
 
176
 
 
177
        return err;
 
178
}
 
179
 
 
180
int enic_dev_init_prov2(struct enic *enic, struct vic_provinfo *vp)
 
181
{
 
182
        int err;
 
183
 
 
184
        spin_lock(&enic->devcmd_lock);
 
185
        err = vnic_dev_init_prov2(enic->vdev,
 
186
                (u8 *)vp, vic_provinfo_size(vp));
 
187
        spin_unlock(&enic->devcmd_lock);
 
188
 
 
189
        return err;
 
190
}
 
191
 
 
192
int enic_dev_deinit_done(struct enic *enic, int *status)
 
193
{
 
194
        int err;
 
195
 
 
196
        spin_lock(&enic->devcmd_lock);
 
197
        err = vnic_dev_deinit_done(enic->vdev, status);
 
198
        spin_unlock(&enic->devcmd_lock);
 
199
 
 
200
        return err;
 
201
}
 
202
 
 
203
/* rtnl lock is held */
 
204
void enic_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
 
205
{
 
206
        struct enic *enic = netdev_priv(netdev);
 
207
 
 
208
        spin_lock(&enic->devcmd_lock);
 
209
        enic_add_vlan(enic, vid);
 
210
        spin_unlock(&enic->devcmd_lock);
 
211
}
 
212
 
 
213
/* rtnl lock is held */
 
214
void enic_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
 
215
{
 
216
        struct enic *enic = netdev_priv(netdev);
 
217
 
 
218
        spin_lock(&enic->devcmd_lock);
 
219
        enic_del_vlan(enic, vid);
 
220
        spin_unlock(&enic->devcmd_lock);
 
221
}
 
222
 
 
223
int enic_dev_enable2(struct enic *enic, int active)
 
224
{
 
225
        int err;
 
226
 
 
227
        spin_lock(&enic->devcmd_lock);
 
228
        err = vnic_dev_enable2(enic->vdev, active);
 
229
        spin_unlock(&enic->devcmd_lock);
 
230
 
 
231
        return err;
 
232
}
 
233
 
 
234
int enic_dev_enable2_done(struct enic *enic, int *status)
 
235
{
 
236
        int err;
 
237
 
 
238
        spin_lock(&enic->devcmd_lock);
 
239
        err = vnic_dev_enable2_done(enic->vdev, status);
 
240
        spin_unlock(&enic->devcmd_lock);
 
241
 
 
242
        return err;
 
243
}
 
244
 
 
245
int enic_dev_status_to_errno(int devcmd_status)
 
246
{
 
247
        switch (devcmd_status) {
 
248
        case ERR_SUCCESS:
 
249
                return 0;
 
250
        case ERR_EINVAL:
 
251
                return -EINVAL;
 
252
        case ERR_EFAULT:
 
253
                return -EFAULT;
 
254
        case ERR_EPERM:
 
255
                return -EPERM;
 
256
        case ERR_EBUSY:
 
257
                return -EBUSY;
 
258
        case ERR_ECMDUNKNOWN:
 
259
        case ERR_ENOTSUPPORTED:
 
260
                return -EOPNOTSUPP;
 
261
        case ERR_EBADSTATE:
 
262
                return -EINVAL;
 
263
        case ERR_ENOMEM:
 
264
                return -ENOMEM;
 
265
        case ERR_ETIMEDOUT:
 
266
                return -ETIMEDOUT;
 
267
        case ERR_ELINKDOWN:
 
268
                return -ENETDOWN;
 
269
        case ERR_EINPROGRESS:
 
270
                return -EINPROGRESS;
 
271
        case ERR_EMAXRES:
 
272
        default:
 
273
                return (devcmd_status < 0) ? devcmd_status : -1;
 
274
        }
 
275
}