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 #include <linux/usb.h>
  13 #include <linux/tty.h>
  14 #include <asm/poll.h>
  15
  16 /* 2.6.28 compat code goes here */
  17
  18 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23))
  19 #if defined(CONFIG_USB) || defined(CONFIG_USB_MODULE)
  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 #endif /* CONFIG_USB */
  88
  89 #if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE)
  90
  91 #include <pcmcia/ds.h>
  92 struct pcmcia_cfg_mem {
  93         tuple_t tuple;
  94         cisparse_t parse;
  95         u8 buf[256];
  96         cistpl_cftable_entry_t dflt;
  97 };
  98 /**
  99  * pcmcia_loop_config() - loop over configuration options
 100  * @p_dev:      the struct pcmcia_device which we need to loop for.
 101  * @conf_check: function to call for each configuration option.
 102  *              It gets passed the struct pcmcia_device, the CIS data
 103  *              describing the configuration option, and private data
 104  *              being passed to pcmcia_loop_config()
 105  * @priv_data:  private data to be passed to the conf_check function.
 106  *
 107  * pcmcia_loop_config() loops over all configuration options, and calls
 108  * the driver-specific conf_check() for each one, checking whether
 109  * it is a valid one. Returns 0 on success or errorcode otherwise.
 110  */
 111 int pcmcia_loop_config(struct pcmcia_device *p_dev,
 112                        int      (*conf_check)   (struct pcmcia_device *p_dev,
 113                                                  cistpl_cftable_entry_t *cfg,
 114                                                  cistpl_cftable_entry_t *dflt,
 115                                                  unsigned int vcc,
 116                                                  void *priv_data),
 117                        void *priv_data)
 118 {
 119         struct pcmcia_cfg_mem *cfg_mem;
 120
 121         tuple_t *tuple;
 122         int ret;
 123         unsigned int vcc;
 124
 125         cfg_mem = kzalloc(sizeof(struct pcmcia_cfg_mem), GFP_KERNEL);
 126         if (cfg_mem == NULL)
 127                 return -ENOMEM;
 128
 129         /* get the current Vcc setting */
 130         vcc = p_dev->socket->socket.Vcc;
 131
 132         tuple = &cfg_mem->tuple;
 133         tuple->TupleData = cfg_mem->buf;
 134         tuple->TupleDataMax = 255;
 135         tuple->TupleOffset = 0;
 136         tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 137         tuple->Attributes = 0;
 138
 139         ret = pcmcia_get_first_tuple(p_dev, tuple);
 140         while (!ret) {
 141                 cistpl_cftable_entry_t *cfg = &cfg_mem->parse.cftable_entry;
 142
 143                 if (pcmcia_get_tuple_data(p_dev, tuple))
 144                         goto next_entry;
 145
 146                 if (pcmcia_parse_tuple(tuple, &cfg_mem->parse))
 147                         goto next_entry;
 148
 149                 /* default values */
 150                 p_dev->conf.ConfigIndex = cfg->index;
 151                 if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
 152                         cfg_mem->dflt = *cfg;
 153
 154                 ret = conf_check(p_dev, cfg, &cfg_mem->dflt, vcc, priv_data);
 155                 if (!ret)
 156                         break;
 157
 158 next_entry:
 159                 ret = pcmcia_get_next_tuple(p_dev, tuple);
 160         }
 161
 162         return ret;
 163 }
 164 EXPORT_SYMBOL_GPL(pcmcia_loop_config);
 165
 166 #endif /* CONFIG_PCMCIA */
 167
 168 #if defined(CONFIG_USB) || defined(CONFIG_USB_MODULE)
 169
 170 void usb_unpoison_urb(struct urb *urb)
 171 {
 172 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
 173         unsigned long flags;
 174 #endif
 175
 176         if (!urb)
 177                 return;
 178
 179 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
 180         spin_lock_irqsave(&usb_reject_lock, flags);
 181 #endif
 182         --urb->reject;
 183 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
 184         spin_unlock_irqrestore(&usb_reject_lock, flags);
 185 #endif
 186 }
 187 EXPORT_SYMBOL_GPL(usb_unpoison_urb);
 188
 189
 190 #if 0
 191 /**
 192  * usb_poison_anchored_urbs - cease all traffic from an anchor
 193  * @anchor: anchor the requests are bound to
 194  *
 195  * this allows all outstanding URBs to be poisoned starting
 196  * from the back of the queue. Newly added URBs will also be
 197  * poisoned
 198  *
 199  * This routine should not be called by a driver after its disconnect
 200  * method has returned.
 201  */
 202 void usb_poison_anchored_urbs(struct usb_anchor *anchor)
 203 {
 204         struct urb *victim;
 205
 206         spin_lock_irq(&anchor->lock);
 207         // anchor->poisoned = 1; /* XXX: Cannot backport */
 208         while (!list_empty(&anchor->urb_list)) {
 209                 victim = list_entry(anchor->urb_list.prev, struct urb,
 210                                     anchor_list);
 211                 /* we must make sure the URB isn't freed before we kill it*/
 212                 usb_get_urb(victim);
 213                 spin_unlock_irq(&anchor->lock);
 214                 /* this will unanchor the URB */
 215                 usb_poison_urb(victim);
 216                 usb_put_urb(victim);
 217                 spin_lock_irq(&anchor->lock);
 218         }
 219         spin_unlock_irq(&anchor->lock);
 220 }
 221 EXPORT_SYMBOL_GPL(usb_poison_anchored_urbs);
 222 #endif
 223
 224 /**
 225  * usb_anchor_empty - is an anchor empty
 226  * @anchor: the anchor you want to query
 227  *
 228  * returns 1 if the anchor has no urbs associated with it
 229  */
 230 int usb_anchor_empty(struct usb_anchor *anchor)
 231 {
 232         return list_empty(&anchor->urb_list);
 233 }
 234
 235 EXPORT_SYMBOL_GPL(usb_anchor_empty);
 236 #endif /* CONFIG_USB */
 237 #endif
 238
 239 void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar)
 240 {
 241         /*
 242          * Make sure the BAR is actually a memory resource, not an IO resource
 243          */
 244         if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) {
 245                 WARN_ON(1);
 246                 return NULL;
 247         }
 248         return ioremap_nocache(pci_resource_start(pdev, bar),
 249                                      pci_resource_len(pdev, bar));
 250 }
 251 EXPORT_SYMBOL_GPL(pci_ioremap_bar);
 252
 253 static unsigned long round_jiffies_common(unsigned long j, int cpu,
 254                 bool force_up)
 255 {
 256         int rem;
 257         unsigned long original = j;
 258
 259         /*
 260          * We don't want all cpus firing their timers at once hitting the
 261          * same lock or cachelines, so we skew each extra cpu with an extra
 262          * 3 jiffies. This 3 jiffies came originally from the mm/ code which
 263          * already did this.
 264          * The skew is done by adding 3*cpunr, then round, then subtract this
 265          * extra offset again.
 266          */
 267         j += cpu * 3;
 268
 269         rem = j % HZ;
 270
 271         /*
 272          * If the target jiffie is just after a whole second (which can happen
 273          * due to delays of the timer irq, long irq off times etc etc) then
 274          * we should round down to the whole second, not up. Use 1/4th second
 275          * as cutoff for this rounding as an extreme upper bound for this.
 276          * But never round down if @force_up is set.
 277          */
 278         if (rem < HZ/4 && !force_up) /* round down */
 279                 j = j - rem;
 280         else /* round up */
 281                 j = j - rem + HZ;
 282
 283         /* now that we have rounded, subtract the extra skew again */
 284         j -= cpu * 3;
 285
 286         if (j <= jiffies) /* rounding ate our timeout entirely; */
 287                 return original;
 288         return j;
 289 }
 290
 291 /**
 292  * round_jiffies_up - function to round jiffies up to a full second
 293  * @j: the time in (absolute) jiffies that should be rounded
 294  *
 295  * This is the same as round_jiffies() except that it will never
 296  * round down.  This is useful for timeouts for which the exact time
 297  * of firing does not matter too much, as long as they don't fire too
 298  * early.
 299  */
 300 unsigned long round_jiffies_up(unsigned long j)
 301 {
 302         return round_jiffies_common(j, raw_smp_processor_id(), true);
 303 }
 304 EXPORT_SYMBOL_GPL(round_jiffies_up);
 305
 306 void v2_6_28_skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, int off,
 307                 int size)
 308 {
 309         skb_fill_page_desc(skb, i, page, off, size);
 310         skb->len += size;
 311         skb->data_len += size;
 312         skb->truesize += size;
 313 }
 314 EXPORT_SYMBOL_GPL(v2_6_28_skb_add_rx_frag);
 315
 316 void tty_write_unlock(struct tty_struct *tty)
 317 {
 318         mutex_unlock(&tty->atomic_write_lock);
 319         wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
 320 }
 321
 322 int tty_write_lock(struct tty_struct *tty, int ndelay)
 323 {
 324         if (!mutex_trylock(&tty->atomic_write_lock)) {
 325                 if (ndelay)
 326                         return -EAGAIN;
 327                 if (mutex_lock_interruptible(&tty->atomic_write_lock))
 328                         return -ERESTARTSYS;
 329         }
 330         return 0;
 331 }
 332
 333 /**
 334  *      send_prio_char          -       send priority character
 335  *
 336  *      Send a high priority character to the tty even if stopped
 337  *
 338  *      Locking: none for xchar method, write ordering for write method.
 339  */
 340
 341 static int send_prio_char(struct tty_struct *tty, char ch)
 342 {
 343         int     was_stopped = tty->stopped;
 344
 345 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
 346         if (tty->ops->send_xchar) {
 347                 tty->ops->send_xchar(tty, ch);
 348 #else
 349         if (tty->driver->send_xchar) {
 350                 tty->driver->send_xchar(tty, ch);
 351 #endif
 352                 return 0;
 353         }
 354
 355         if (tty_write_lock(tty, 0) < 0)
 356                 return -ERESTARTSYS;
 357
 358         if (was_stopped)
 359                 start_tty(tty);
 360 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
 361         tty->ops->write(tty, &ch, 1);
 362 #else
 363         tty->driver->write(tty, &ch, 1);
 364 #endif
 365         if (was_stopped)
 366                 stop_tty(tty);
 367         tty_write_unlock(tty);
 368         return 0;
 369 }
 370
 371 int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
 372                        unsigned int cmd, unsigned long arg)
 373 {
 374 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
 375         unsigned long flags;
 376 #endif
 377         int retval;
 378
 379         switch (cmd) {
 380         case TCXONC:
 381                 retval = tty_check_change(tty);
 382                 if (retval)
 383                         return retval;
 384                 switch (arg) {
 385                 case TCOOFF:
 386                         if (!tty->flow_stopped) {
 387                                 tty->flow_stopped = 1;
 388                                 stop_tty(tty);
 389                         }
 390                         break;
 391                 case TCOON:
 392                         if (tty->flow_stopped) {
 393                                 tty->flow_stopped = 0;
 394                                 start_tty(tty);
 395                         }
 396                         break;
 397                 case TCIOFF:
 398                         if (STOP_CHAR(tty) != __DISABLED_CHAR)
 399                                 return send_prio_char(tty, STOP_CHAR(tty));
 400                         break;
 401                 case TCION:
 402                         if (START_CHAR(tty) != __DISABLED_CHAR)
 403                                 return send_prio_char(tty, START_CHAR(tty));
 404                         break;
 405                 default:
 406                         return -EINVAL;
 407                 }
 408                 return 0;
 409         case TCFLSH:
 410                 return tty_perform_flush(tty, arg);
 411         case TIOCPKT:
 412         {
 413                 int pktmode;
 414
 415                 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
 416                     tty->driver->subtype != PTY_TYPE_MASTER)
 417                         return -ENOTTY;
 418                 if (get_user(pktmode, (int __user *) arg))
 419                         return -EFAULT;
 420 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
 421                 spin_lock_irqsave(&tty->ctrl_lock, flags);
 422 #endif
 423                 if (pktmode) {
 424                         if (!tty->packet) {
 425                                 tty->packet = 1;
 426                                 tty->link->ctrl_status = 0;
 427                         }
 428                 } else
 429                         tty->packet = 0;
 430 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
 431                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 432 #endif
 433                 return 0;
 434         }
 435         default:
 436                 /* Try the mode commands */
 437                 return tty_mode_ioctl(tty, file, cmd, arg);
 438         }
 439 }
 440 EXPORT_SYMBOL_GPL(n_tty_ioctl_helper);
 441
 442 /**
 443  * pci_wake_from_d3 - enable/disable device to wake up from D3_hot or D3_cold
 444  * @dev: PCI device to prepare
 445  * @enable: True to enable wake-up event generation; false to disable
 446  *
 447  * Many drivers want the device to wake up the system from D3_hot or D3_cold
 448  * and this function allows them to set that up cleanly - pci_enable_wake()
 449  * should not be called twice in a row to enable wake-up due to PCI PM vs ACPI
 450  * ordering constraints.
 451  *
 452  * This function only returns error code if the device is not capable of
 453  * generating PME# from both D3_hot and D3_cold, and the platform is unable to
 454  * enable wake-up power for it.
 455  */
 456 int pci_wake_from_d3(struct pci_dev *dev, bool enable)
 457 {
 458         return pci_pme_capable(dev, PCI_D3cold) ?
 459                         pci_enable_wake(dev, PCI_D3cold, enable) :
 460                         pci_enable_wake(dev, PCI_D3hot, enable);
 461 }
 462 EXPORT_SYMBOL_GPL(pci_wake_from_d3);
 463