Adds __dev_addr_delete() and __dev_addr_add() for 2.6.22
[~emulex/for-vlad/old/compat.git] / compat / compat-2.6.28.c
1 /*
2  * Copyright 2007       Luis R. Rodriguez <mcgrof@winlab.rutgers.edu>
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 as
6  * published by the Free Software Foundation.
7  *
8  * Compatibility file for Linux wireless for kernels 2.6.28.
9  */
10
11 #include <linux/compat.h>
12
13 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28))
14
15 #include <linux/usb.h>
16
17 /* 2.6.28 compat code goes here */
18
19 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23))
20 /*
21  * Compat-wireless notes for USB backport stuff:
22  *
23  * urb->reject exists on 2.6.27, the poison/unpoison helpers
24  * did not though. The anchor poison does not exist so we cannot use them.
25  *
26  * USB anchor poising seems to exist to prevent future driver sumbissions
27  * of usb_anchor_urb() to an anchor marked as poisoned. For older kernels
28  * we cannot use that, so new usb_anchor_urb()s will be anchored. The down
29  * side to this should be submission of URBs will continue being anchored
30  * on an anchor instead of having them being rejected immediately when the
31  * driver realized we needed to stop. For ar9170 we poison URBs upon the
32  * ar9170 mac80211 stop callback(), don't think this should be so bad.
33  * It mean there is period of time in older kernels for which we continue
34  * to anchor new URBs to a known stopped anchor. We have two anchors
35  * (TX, and RX)
36  */
37
38 #if 0
39 /**
40  * usb_poison_urb - reliably kill a transfer and prevent further use of an URB
41  * @urb: pointer to URB describing a previously submitted request,
42  *      may be NULL
43  *
44  * This routine cancels an in-progress request.  It is guaranteed that
45  * upon return all completion handlers will have finished and the URB
46  * will be totally idle and cannot be reused.  These features make
47  * this an ideal way to stop I/O in a disconnect() callback.
48  * If the request has not already finished or been unlinked
49  * the completion handler will see urb->status == -ENOENT.
50  *
51  * After and while the routine runs, attempts to resubmit the URB will fail
52  * with error -EPERM.  Thus even if the URB's completion handler always
53  * tries to resubmit, it will not succeed and the URB will become idle.
54  *
55  * This routine may not be used in an interrupt context (such as a bottom
56  * half or a completion handler), or when holding a spinlock, or in other
57  * situations where the caller can't schedule().
58  *
59  * This routine should not be called by a driver after its disconnect
60  * method has returned.
61  */
62 void usb_poison_urb(struct urb *urb)
63 {
64         might_sleep();
65         if (!(urb && urb->dev && urb->ep))
66                 return;
67 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
68         spin_lock_irq(&usb_reject_lock);
69 #endif
70         ++urb->reject;
71 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
72         spin_unlock_irq(&usb_reject_lock);
73 #endif
74         /*
75          * XXX: usb_hcd_unlink_urb() needs backporting... this is defined
76          * on usb hcd.c but urb.c gets access to it. That is, older kernels
77          * have usb_hcd_unlink_urb() but its not exported, nor can we
78          * re-implement it exactly. This essentially dequeues the urb from
79          * hw, we need to figure out a way to backport this.
80          */
81         //usb_hcd_unlink_urb(urb, -ENOENT);
82
83         wait_event(usb_kill_urb_queue, atomic_read(&urb->use_count) == 0);
84 }
85 EXPORT_SYMBOL_GPL(usb_poison_urb);
86 #endif
87
88 #include <pcmcia/ds.h>
89 struct pcmcia_cfg_mem {
90         tuple_t tuple;
91         cisparse_t parse;
92         u8 buf[256];
93         cistpl_cftable_entry_t dflt;
94 };
95 /**
96  * pcmcia_loop_config() - loop over configuration options
97  * @p_dev:      the struct pcmcia_device which we need to loop for.
98  * @conf_check: function to call for each configuration option.
99  *              It gets passed the struct pcmcia_device, the CIS data
100  *              describing the configuration option, and private data
101  *              being passed to pcmcia_loop_config()
102  * @priv_data:  private data to be passed to the conf_check function.
103  *
104  * pcmcia_loop_config() loops over all configuration options, and calls
105  * the driver-specific conf_check() for each one, checking whether
106  * it is a valid one. Returns 0 on success or errorcode otherwise.
107  */
108 int pcmcia_loop_config(struct pcmcia_device *p_dev,
109                        int      (*conf_check)   (struct pcmcia_device *p_dev,
110                                                  cistpl_cftable_entry_t *cfg,
111                                                  cistpl_cftable_entry_t *dflt,
112                                                  unsigned int vcc,
113                                                  void *priv_data),
114                        void *priv_data)
115 {
116         struct pcmcia_cfg_mem *cfg_mem;
117
118         tuple_t *tuple;
119         int ret;
120         unsigned int vcc;
121
122         cfg_mem = kzalloc(sizeof(struct pcmcia_cfg_mem), GFP_KERNEL);
123         if (cfg_mem == NULL)
124                 return -ENOMEM;
125
126         /* get the current Vcc setting */
127         vcc = p_dev->socket->socket.Vcc;
128
129         tuple = &cfg_mem->tuple;
130         tuple->TupleData = cfg_mem->buf;
131         tuple->TupleDataMax = 255;
132         tuple->TupleOffset = 0;
133         tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
134         tuple->Attributes = 0;
135
136         ret = pcmcia_get_first_tuple(p_dev, tuple);
137         while (!ret) {
138                 cistpl_cftable_entry_t *cfg = &cfg_mem->parse.cftable_entry;
139
140                 if (pcmcia_get_tuple_data(p_dev, tuple))
141                         goto next_entry;
142
143                 if (pcmcia_parse_tuple(tuple, &cfg_mem->parse))
144                         goto next_entry;
145
146                 /* default values */
147                 p_dev->conf.ConfigIndex = cfg->index;
148                 if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
149                         cfg_mem->dflt = *cfg;
150
151                 ret = conf_check(p_dev, cfg, &cfg_mem->dflt, vcc, priv_data);
152                 if (!ret)
153                         break;
154
155 next_entry:
156                 ret = pcmcia_get_next_tuple(p_dev, tuple);
157         }
158
159         return ret;
160 }
161 EXPORT_SYMBOL(pcmcia_loop_config);
162
163 void usb_unpoison_urb(struct urb *urb)
164 {
165 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
166         unsigned long flags;
167 #endif
168
169         if (!urb)
170                 return;
171
172 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
173         spin_lock_irqsave(&usb_reject_lock, flags);
174 #endif
175         --urb->reject;
176 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
177         spin_unlock_irqrestore(&usb_reject_lock, flags);
178 #endif
179 }
180 EXPORT_SYMBOL_GPL(usb_unpoison_urb);
181
182
183 #if 0
184 /**
185  * usb_poison_anchored_urbs - cease all traffic from an anchor
186  * @anchor: anchor the requests are bound to
187  *
188  * this allows all outstanding URBs to be poisoned starting
189  * from the back of the queue. Newly added URBs will also be
190  * poisoned
191  *
192  * This routine should not be called by a driver after its disconnect
193  * method has returned.
194  */
195 void usb_poison_anchored_urbs(struct usb_anchor *anchor)
196 {
197         struct urb *victim;
198
199         spin_lock_irq(&anchor->lock);
200         // anchor->poisoned = 1; /* XXX: Cannot backport */
201         while (!list_empty(&anchor->urb_list)) {
202                 victim = list_entry(anchor->urb_list.prev, struct urb,
203                                     anchor_list);
204                 /* we must make sure the URB isn't freed before we kill it*/
205                 usb_get_urb(victim);
206                 spin_unlock_irq(&anchor->lock);
207                 /* this will unanchor the URB */
208                 usb_poison_urb(victim);
209                 usb_put_urb(victim);
210                 spin_lock_irq(&anchor->lock);
211         }
212         spin_unlock_irq(&anchor->lock);
213 }
214 EXPORT_SYMBOL_GPL(usb_poison_anchored_urbs);
215 #endif
216
217 /**
218  * usb_get_from_anchor - get an anchor's oldest urb
219  * @anchor: the anchor whose urb you want
220  *
221  * this will take the oldest urb from an anchor,
222  * unanchor and return it
223  */
224 struct urb *usb_get_from_anchor(struct usb_anchor *anchor)
225 {
226         struct urb *victim;
227         unsigned long flags;
228
229         spin_lock_irqsave(&anchor->lock, flags);
230         if (!list_empty(&anchor->urb_list)) {
231                 victim = list_entry(anchor->urb_list.next, struct urb,
232                                     anchor_list);
233                 usb_get_urb(victim);
234                 spin_unlock_irqrestore(&anchor->lock, flags);
235                 usb_unanchor_urb(victim);
236         } else {
237                 spin_unlock_irqrestore(&anchor->lock, flags);
238                 victim = NULL;
239         }
240
241         return victim;
242 }
243
244 EXPORT_SYMBOL_GPL(usb_get_from_anchor);
245
246 /**
247  * usb_scuttle_anchored_urbs - unanchor all an anchor's urbs
248  * @anchor: the anchor whose urbs you want to unanchor
249  *
250  * use this to get rid of all an anchor's urbs
251  */
252 void usb_scuttle_anchored_urbs(struct usb_anchor *anchor)
253 {
254         struct urb *victim;
255         unsigned long flags;
256
257         spin_lock_irqsave(&anchor->lock, flags);
258         while (!list_empty(&anchor->urb_list)) {
259                 victim = list_entry(anchor->urb_list.prev, struct urb,
260                                     anchor_list);
261                 usb_get_urb(victim);
262                 spin_unlock_irqrestore(&anchor->lock, flags);
263                 /* this may free the URB */
264                 usb_unanchor_urb(victim);
265                 usb_put_urb(victim);
266                 spin_lock_irqsave(&anchor->lock, flags);
267         }
268         spin_unlock_irqrestore(&anchor->lock, flags);
269 }
270
271 EXPORT_SYMBOL_GPL(usb_scuttle_anchored_urbs);
272
273 /**
274  * usb_anchor_empty - is an anchor empty
275  * @anchor: the anchor you want to query
276  *
277  * returns 1 if the anchor has no urbs associated with it
278  */
279 int usb_anchor_empty(struct usb_anchor *anchor)
280 {
281         return list_empty(&anchor->urb_list);
282 }
283
284 EXPORT_SYMBOL_GPL(usb_anchor_empty);
285 #endif
286
287
288 void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar)
289 {
290         /*
291          * Make sure the BAR is actually a memory resource, not an IO resource
292          */
293         if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) {
294                 WARN_ON(1);
295                 return NULL;
296         }
297         return ioremap_nocache(pci_resource_start(pdev, bar),
298                                      pci_resource_len(pdev, bar));
299 }
300 EXPORT_SYMBOL_GPL(pci_ioremap_bar);
301
302 static unsigned long round_jiffies_common(unsigned long j, int cpu,
303                 bool force_up)
304 {
305         int rem;
306         unsigned long original = j;
307
308         /*
309          * We don't want all cpus firing their timers at once hitting the
310          * same lock or cachelines, so we skew each extra cpu with an extra
311          * 3 jiffies. This 3 jiffies came originally from the mm/ code which
312          * already did this.
313          * The skew is done by adding 3*cpunr, then round, then subtract this
314          * extra offset again.
315          */
316         j += cpu * 3;
317
318         rem = j % HZ;
319
320         /*
321          * If the target jiffie is just after a whole second (which can happen
322          * due to delays of the timer irq, long irq off times etc etc) then
323          * we should round down to the whole second, not up. Use 1/4th second
324          * as cutoff for this rounding as an extreme upper bound for this.
325          * But never round down if @force_up is set.
326          */
327         if (rem < HZ/4 && !force_up) /* round down */
328                 j = j - rem;
329         else /* round up */
330                 j = j - rem + HZ;
331
332         /* now that we have rounded, subtract the extra skew again */
333         j -= cpu * 3;
334
335         if (j <= jiffies) /* rounding ate our timeout entirely; */
336                 return original;
337         return j;
338 }
339
340 /**
341  * round_jiffies_up - function to round jiffies up to a full second
342  * @j: the time in (absolute) jiffies that should be rounded
343  *
344  * This is the same as round_jiffies() except that it will never
345  * round down.  This is useful for timeouts for which the exact time
346  * of firing does not matter too much, as long as they don't fire too
347  * early.
348  */
349 unsigned long round_jiffies_up(unsigned long j)
350 {
351         return round_jiffies_common(j, raw_smp_processor_id(), true);
352 }
353 EXPORT_SYMBOL_GPL(round_jiffies_up);
354
355 void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, int off,
356                 int size)
357 {
358         skb_fill_page_desc(skb, i, page, off, size);
359         skb->len += size;
360         skb->data_len += size;
361         skb->truesize += size;
362 }
363 EXPORT_SYMBOL(skb_add_rx_frag);
364
365 #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28) */