net: remove unnecessary return's
[firefly-linux-kernel-4.4.55.git] / net / mac802154 / mib.c
1 /*
2  * Copyright 2007-2012 Siemens AG
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2
6  * as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License along
14  * with this program; if not, write to the Free Software Foundation, Inc.,
15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16  *
17  * Written by:
18  * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
19  * Sergey Lapin <slapin@ossfans.org>
20  * Maxim Gorbachyov <maxim.gorbachev@siemens.com>
21  * Alexander Smirnov <alex.bluesman.smirnov@gmail.com>
22  */
23
24 #include <linux/if_arp.h>
25
26 #include <net/mac802154.h>
27 #include <net/wpan-phy.h>
28
29 #include "mac802154.h"
30
31 struct phy_chan_notify_work {
32         struct work_struct work;
33         struct net_device *dev;
34 };
35
36 struct hw_addr_filt_notify_work {
37         struct work_struct work;
38         struct net_device *dev;
39         unsigned long changed;
40 };
41
42 static struct mac802154_priv *mac802154_slave_get_priv(struct net_device *dev)
43 {
44         struct mac802154_sub_if_data *priv = netdev_priv(dev);
45
46         BUG_ON(dev->type != ARPHRD_IEEE802154);
47
48         return priv->hw;
49 }
50
51 static void hw_addr_notify(struct work_struct *work)
52 {
53         struct hw_addr_filt_notify_work *nw = container_of(work,
54                         struct hw_addr_filt_notify_work, work);
55         struct mac802154_priv *hw = mac802154_slave_get_priv(nw->dev);
56         int res;
57
58         res = hw->ops->set_hw_addr_filt(&hw->hw,
59                                         &hw->hw.hw_filt,
60                                         nw->changed);
61         if (res)
62                 pr_debug("failed changed mask %lx\n", nw->changed);
63
64         kfree(nw);
65 }
66
67 static void set_hw_addr_filt(struct net_device *dev, unsigned long changed)
68 {
69         struct mac802154_sub_if_data *priv = netdev_priv(dev);
70         struct hw_addr_filt_notify_work *work;
71
72         work = kzalloc(sizeof(*work), GFP_ATOMIC);
73         if (!work)
74                 return;
75
76         INIT_WORK(&work->work, hw_addr_notify);
77         work->dev = dev;
78         work->changed = changed;
79         queue_work(priv->hw->dev_workqueue, &work->work);
80 }
81
82 void mac802154_dev_set_short_addr(struct net_device *dev, u16 val)
83 {
84         struct mac802154_sub_if_data *priv = netdev_priv(dev);
85
86         BUG_ON(dev->type != ARPHRD_IEEE802154);
87
88         spin_lock_bh(&priv->mib_lock);
89         priv->short_addr = val;
90         spin_unlock_bh(&priv->mib_lock);
91
92         if ((priv->hw->ops->set_hw_addr_filt) &&
93             (priv->hw->hw.hw_filt.short_addr != priv->short_addr)) {
94                 priv->hw->hw.hw_filt.short_addr = priv->short_addr;
95                 set_hw_addr_filt(dev, IEEE802515_AFILT_SADDR_CHANGED);
96         }
97 }
98
99 u16 mac802154_dev_get_short_addr(const struct net_device *dev)
100 {
101         struct mac802154_sub_if_data *priv = netdev_priv(dev);
102         u16 ret;
103
104         BUG_ON(dev->type != ARPHRD_IEEE802154);
105
106         spin_lock_bh(&priv->mib_lock);
107         ret = priv->short_addr;
108         spin_unlock_bh(&priv->mib_lock);
109
110         return ret;
111 }
112
113 void mac802154_dev_set_ieee_addr(struct net_device *dev)
114 {
115         struct mac802154_sub_if_data *priv = netdev_priv(dev);
116         struct mac802154_priv *mac = priv->hw;
117
118         if (mac->ops->set_hw_addr_filt &&
119             memcmp(mac->hw.hw_filt.ieee_addr,
120                    dev->dev_addr, IEEE802154_ADDR_LEN)) {
121                 memcpy(mac->hw.hw_filt.ieee_addr,
122                        dev->dev_addr, IEEE802154_ADDR_LEN);
123                 set_hw_addr_filt(dev, IEEE802515_AFILT_IEEEADDR_CHANGED);
124         }
125 }
126
127 u16 mac802154_dev_get_pan_id(const struct net_device *dev)
128 {
129         struct mac802154_sub_if_data *priv = netdev_priv(dev);
130         u16 ret;
131
132         BUG_ON(dev->type != ARPHRD_IEEE802154);
133
134         spin_lock_bh(&priv->mib_lock);
135         ret = priv->pan_id;
136         spin_unlock_bh(&priv->mib_lock);
137
138         return ret;
139 }
140
141 void mac802154_dev_set_pan_id(struct net_device *dev, u16 val)
142 {
143         struct mac802154_sub_if_data *priv = netdev_priv(dev);
144
145         BUG_ON(dev->type != ARPHRD_IEEE802154);
146
147         spin_lock_bh(&priv->mib_lock);
148         priv->pan_id = val;
149         spin_unlock_bh(&priv->mib_lock);
150
151         if ((priv->hw->ops->set_hw_addr_filt) &&
152             (priv->hw->hw.hw_filt.pan_id != priv->pan_id)) {
153                 priv->hw->hw.hw_filt.pan_id = priv->pan_id;
154                 set_hw_addr_filt(dev, IEEE802515_AFILT_PANID_CHANGED);
155         }
156 }
157
158 u8 mac802154_dev_get_dsn(const struct net_device *dev)
159 {
160         struct mac802154_sub_if_data *priv = netdev_priv(dev);
161
162         BUG_ON(dev->type != ARPHRD_IEEE802154);
163
164         return priv->dsn++;
165 }
166
167 static void phy_chan_notify(struct work_struct *work)
168 {
169         struct phy_chan_notify_work *nw = container_of(work,
170                                           struct phy_chan_notify_work, work);
171         struct mac802154_priv *hw = mac802154_slave_get_priv(nw->dev);
172         struct mac802154_sub_if_data *priv = netdev_priv(nw->dev);
173         int res;
174
175         mutex_lock(&priv->hw->phy->pib_lock);
176         res = hw->ops->set_channel(&hw->hw, priv->page, priv->chan);
177         if (res)
178                 pr_debug("set_channel failed\n");
179         else {
180                 priv->hw->phy->current_channel = priv->chan;
181                 priv->hw->phy->current_page = priv->page;
182         }
183         mutex_unlock(&priv->hw->phy->pib_lock);
184
185         kfree(nw);
186 }
187
188 void mac802154_dev_set_page_channel(struct net_device *dev, u8 page, u8 chan)
189 {
190         struct mac802154_sub_if_data *priv = netdev_priv(dev);
191         struct phy_chan_notify_work *work;
192
193         BUG_ON(dev->type != ARPHRD_IEEE802154);
194
195         spin_lock_bh(&priv->mib_lock);
196         priv->page = page;
197         priv->chan = chan;
198         spin_unlock_bh(&priv->mib_lock);
199
200         mutex_lock(&priv->hw->phy->pib_lock);
201         if (priv->hw->phy->current_channel != priv->chan ||
202             priv->hw->phy->current_page != priv->page) {
203                 mutex_unlock(&priv->hw->phy->pib_lock);
204
205                 work = kzalloc(sizeof(*work), GFP_ATOMIC);
206                 if (!work)
207                         return;
208
209                 INIT_WORK(&work->work, phy_chan_notify);
210                 work->dev = dev;
211                 queue_work(priv->hw->dev_workqueue, &work->work);
212         } else
213                 mutex_unlock(&priv->hw->phy->pib_lock);
214 }