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