Add a couple #defines to stdint
[akaros.git] / kern / include / linux_compat.h
index 4aff8af..f8c5067 100644 (file)
@@ -1,15 +1,18 @@
 /* Copyright (c) 2015 Google Inc.
+ * Copyright (C) 1991-2017, the Linux Kernel authors
  *
  * Dumping ground for converting between Akaros and Linux. */
 
-#ifndef ROS_KERN_LINUX_COMPAT_H
+#pragma once
+
 #define ROS_KERN_LINUX_COMPAT_H
 
 /* Common headers that most driver files will need */
 
+#include <ros/common.h>
 #include <assert.h>
 #include <error.h>
-#include <ip.h>
+#include <net/ip.h>
 #include <kmalloc.h>
 #include <kref.h>
 #include <pmap.h>
@@ -23,6 +26,7 @@
 #include <taskqueue.h>
 #include <zlib.h>
 #include <list.h>
+#include <refd_pages.h>
 #include <linux/errno.h>
 /* temporary dumping ground */
 #include "compat_todo.h"
 #define rcu_read_unlock()
 #define rcu_dereference(x) (x)
 #define rcu_dereference_protected(x, y) (x)
+#ifndef rcu_assign_pointer
 #define rcu_assign_pointer(dst, src) (dst) = (src)
+#endif
 #define RCU_INIT_POINTER(dst, src) rcu_assign_pointer(dst, src)
 #define synchronize_rcu()
+#define synchronize_sched()
 
 #define atomic_cmpxchg(_addr, _old, _new)                                      \
 ({                                                                             \
@@ -52,8 +59,6 @@
        _ret;                                                                      \
 })
 
-#define unlikely(x) (x)
-#define likely(x) (x)
 #define UINT_MAX UINT64_MAX
 #define L1_CACHE_SHIFT (LOG2_UP(ARCH_CL_SIZE))
 #define __stringify(x...) STRINGIFY(x)
@@ -75,6 +80,8 @@ typedef int gfp_t;
 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL)  do { } while (0)
 #define dma_unmap_len(PTR, LEN_NAME)             (0)
 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)    do { } while (0)
+#define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL << (n)) - 1))
+#define DMA_MASK_NONE 0x0ULL
 
 enum dma_data_direction {
        DMA_BIDIRECTIONAL = 0,
@@ -86,18 +93,12 @@ enum dma_data_direction {
 static inline void *__dma_alloc_coherent(size_t size, dma_addr_t *dma_handle,
                                          gfp_t flags)
 {
-       size_t order = LOG2_UP(nr_pages(size));
-       /* our shitty allocator doesn't align the higher order allocations, so we
-        * go 2x, and align manually.  we don't save the original pointer, so we
-        * can't free them later. */
-       void *vaddr = get_cont_pages(order > 0 ?  order + 1 : order,
-                                    flags);
+       void *vaddr = get_cont_pages(LOG2_UP(nr_pages(size)), flags);
+
        if (!vaddr) {
                *dma_handle = 0;
                return 0;
        }
-       /* manual alignment.  order 0 allocs are already page aligned */
-       vaddr = ALIGN(vaddr, PGSIZE << order);
        *dma_handle = PADDR(vaddr);
        return vaddr;
 }
@@ -114,12 +115,7 @@ static inline void *__dma_zalloc_coherent(size_t size, dma_addr_t *dma_handle,
 static inline void __dma_free_coherent(size_t size, void *cpu_addr,
                                        dma_addr_t dma_handle)
 {
-       size_t order = LOG2_UP(nr_pages(size));
-       if (order > 0) {
-               warn("Not freeing high order alloc!  Fix the allocator!");
-               return;
-       }
-       free_cont_pages(cpu_addr, order);
+       free_cont_pages(cpu_addr, LOG2_UP(nr_pages(size)));
 }
 
 static inline dma_addr_t __dma_map_single(void *cpu_addr, size_t size,
@@ -147,9 +143,13 @@ static inline int __dma_mapping_error(dma_addr_t dma_addr)
 #define dma_sync_single_for_cpu(...)
 #define dma_sync_single_for_device(...)
 
-/* Wrappers to avoid struct device.  Might want that one of these days */
+/* Wrappers to avoid struct device.  Might want that one of these days.
+ *
+ * Note dma_alloc_coherent() does a zalloc.  Some Linux drivers (r8169)
+ * accidentally assume the memory is zeroed, which may be what Linux allocators
+ * often do. */
 #define dma_alloc_coherent(dev, size, dma_handlep, flag)                       \
-       __dma_alloc_coherent(size, dma_handlep, flag)
+       __dma_zalloc_coherent(size, dma_handlep, flag)
 
 #define dma_zalloc_coherent(dev, size, dma_handlep, flag)                      \
        __dma_zalloc_coherent(size, dma_handlep, flag)
@@ -168,7 +168,7 @@ static inline int __dma_mapping_error(dma_addr_t dma_addr)
 
 static void *vmalloc(size_t size)
 {
-       void *vaddr = get_cont_pages(LOG2_UP(nr_pages(size)), KMALLOC_WAIT);
+       void *vaddr = get_cont_pages(LOG2_UP(nr_pages(size)), MEM_WAIT);
        /* zalloc, to be safe */
        if (vaddr)
                memset(vaddr, 0, size);
@@ -195,12 +195,19 @@ typedef int pm_message_t;
 #define down_interruptible(sem) ({sem_down(sem); 0;})
 #define down_timeout(sem, timeout) ({sem_down(sem); 0;})
 
+static void msleep(unsigned int msecs)
+{
+       kthread_usleep(msecs * 1000);
+}
+
+#define mdelay(x) udelay((x) * 1000)
+
 #define local_bh_disable() cmb()
 #define local_bh_enable() cmb()
 
 /* Linux printk front ends */
 #ifndef pr_fmt
-#define pr_fmt(fmt) "bnx2x:" fmt
+#define pr_fmt(fmt) fmt
 #endif
 
 #define KERN_EMERG ""
@@ -236,14 +243,28 @@ typedef int pm_message_t;
        printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_cont(fmt, ...) \
        printk(KERN_CONT pr_fmt(fmt), ##__VA_ARGS__)
+
+#define __print_netif_name(dev) (dev)->drv_name[0] ? (dev)->drv_name : "netdev"
+
 #define netdev_printk(lvl, dev, fmt, ...) \
-       printk("[netdev]: " fmt, ##__VA_ARGS__)
+       printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
 #define netdev_err(dev, fmt, ...) \
-       printk("[netdev]: " fmt, ##__VA_ARGS__)
+       printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
 #define netdev_info(dev, fmt, ...) \
-       printk("[netdev]: " fmt, ##__VA_ARGS__)
+       printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
 #define netdev_dbg(dev, fmt, ...) \
-       printk("[netdev]: " fmt, ##__VA_ARGS__)
+       printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
+#define netif_err(priv, type, dev, fmt, ...) \
+       printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
+#define netif_warn(priv, type, dev, fmt, ...) \
+       printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
+#define netif_notice(priv, type, dev, fmt, ...) \
+       printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
+#define netif_info(priv, type, dev, fmt, ...) \
+       printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
+#define netif_dbg(priv, type, dev, fmt, ...) \
+       printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
+
 #define dev_err(dev, fmt, ...) \
        printk("[dev]: " fmt, ##__VA_ARGS__)
 #define dev_info(dev, fmt, ...) \
@@ -384,6 +405,19 @@ enum {
 #define ADVERTISED_56000baseSR4_Full    (1 << 29)
 #define ADVERTISED_56000baseLR4_Full    (1 << 30)
 
+/* Wake-On-Lan options. */
+#define WAKE_PHY        (1 << 0)
+#define WAKE_UCAST      (1 << 1)
+#define WAKE_MCAST      (1 << 2)
+#define WAKE_BCAST      (1 << 3)
+#define WAKE_ARP        (1 << 4)
+#define WAKE_MAGIC      (1 << 5)
+#define WAKE_MAGICSECURE    (1 << 6) /* only meaningful if WAKE_MAGIC */
+
+/* Enable or disable autonegotiation. */
+#define AUTONEG_DISABLE     0x00
+#define AUTONEG_ENABLE      0x01
+
 enum ethtool_test_flags {
        ETH_TEST_FL_OFFLINE = (1 << 0),
        ETH_TEST_FL_FAILED  = (1 << 1),
@@ -472,21 +506,31 @@ static inline void *netdev_priv(struct ether *dev)
        return dev->ctlr;
 }
 
+/* We do our linker table magic and other nonsense.  Keeping these around to
+ * show the code's intent. */
+static int register_netdev(struct ether *dev)
+{
+       return 0;
+}
+
+static void unregister_netdev(struct ether *dev)
+{
+}
+
+static void free_netdev(struct ether *dev)
+{
+}
+
 /* u64 on linux, but a u32 on plan 9.  the typedef is probably a good idea */
 typedef unsigned int netdev_features_t;
 
-/* Linux has features, hw_features, and a couple others.  Plan 9 just has
- * features.  This #define should work for merging hw and regular features.  We
- * spatched away the hw_enc and vlan feats. */
-#define hw_features feat
-
 /* Attempted conversions for plan 9 features.  For some things, like rx
  * checksums, the driver flags the block (e.g. Budpck) to say if a receive
  * checksum was already done.  There is no flag for saying the device can do
  * it.  For transmits, the stack needs to know in advance if the device can
  * handle the checksum or not. */
 #define NETIF_F_RXHASH                         0
-#define NETIF_F_RXCSUM                         0
+#define NETIF_F_RXCSUM                         NETF_RXCSUM
 #define NETIF_F_LRO                                    NETF_LRO
 #define NETIF_F_GRO                                    0
 #define NETIF_F_LOOPBACK                       0
@@ -503,6 +547,8 @@ typedef unsigned int netdev_features_t;
 #define NETIF_F_HW_VLAN_CTAG_TX                0
 #define NETIF_F_HIGHDMA                                0
 #define NETIF_F_HW_VLAN_CTAG_RX                0
+#define NETIF_F_TSO_MANGLEID           0
+#define NETIF_F_ALL_TSO (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN | NETIF_F_TSO_MANGLEID)
 
 #define netif_msg_drv(p)               ((p)->msg_enable & NETIF_MSG_DRV)
 #define netif_msg_probe(p)             ((p)->msg_enable & NETIF_MSG_PROBE)
@@ -520,6 +566,18 @@ typedef unsigned int netdev_features_t;
 #define netif_msg_hw(p)                        ((p)->msg_enable & NETIF_MSG_HW)
 #define netif_msg_wol(p)               ((p)->msg_enable & NETIF_MSG_WOL)
 
+static inline uint32_t netif_msg_init(int debug_value,
+                                      int default_msg_enable_bits)
+{
+       /* use default */
+       if (debug_value < 0 || debug_value >= (sizeof(uint32_t) * 8))
+               return default_msg_enable_bits;
+       if (debug_value == 0)   /* no output */
+               return 0;
+       /* set low N bits */
+       return (1 << debug_value) - 1;
+}
+
 enum netdev_state_t {
        __LINK_STATE_START,
        __LINK_STATE_PRESENT,
@@ -543,7 +601,7 @@ typedef enum netdev_tx netdev_tx_t;
 #define ASSERT_RTNL(...)
 
 #define synchronize_irq(x) warn_once("Asked to sync IRQ %d, unsupported", x)
-#define HZ 100
+#define HZ 1000
 
 /* Linux has a PCI device id struct.  Drivers make tables of their supported
  * devices, and this table is handled by higher level systems.  We don't have
@@ -555,15 +613,38 @@ struct pci_device_id {
        unsigned long driver_data;              /* Data private to the driver */
 };
 
+static const struct pci_device_id *
+srch_linux_pci_tbl(const struct pci_device_id *tbl, struct pci_device *needle)
+{
+       const struct pci_device_id *i;
+
+       for (i = tbl; i->vendor; i++) {
+               if ((needle->ven_id == i->vendor) && (needle->dev_id == i->device))
+                       break;
+       }
+       if (i->vendor)
+               return i;
+       return 0;
+}
+
 #define PCI_ANY_ID (~0)
 /* This macro is used in setting device_id entries */
 #define PCI_VDEVICE(vend, dev) \
     .vendor = PCI_VENDOR_ID_##vend, .device = (dev), \
     .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0
 
+#define PCI_DEVICE(vend, dev) \
+    .vendor = (vend), .device = (dev), \
+    .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
+
 /* Linux also has its own table of vendor ids.  We have the pci_defs table, but
  * this is a bootstrap issue. */
 #define PCI_VENDOR_ID_BROADCOM      0x14e4
+#define PCI_VENDOR_ID_REALTEK       0x10ec
+#define PCI_VENDOR_ID_DLINK         0x1186
+#define PCI_VENDOR_ID_AT            0x1259
+#define PCI_VENDOR_ID_LINKSYS       0x1737
+#define PCI_VENDOR_ID_GIGABYTE      0x1458
 
 /* I'd like to spatch all of the pci methods, but I don't know how to do the
  * reads.  Since we're not doing the reads, then no sense doing the writes. */
@@ -635,12 +716,28 @@ static inline void *pci_resource_end(struct pci_device *dev, int bir)
        return (void*)(pci_get_membar(dev, bir) + pci_resource_len(dev, bir));
 }
 
+#define IORESOURCE_TYPE_BITS    0x00001f00  /* Resource type */
+#define IORESOURCE_IO       0x00000100  /* PCI/ISA I/O ports */
+#define IORESOURCE_MEM      0x00000200
+
+static inline int pci_resource_flags(struct pci_device *pdev, int bir)
+{
+       return pci_get_membar(pdev, bir) ? IORESOURCE_MEM : IORESOURCE_IO;
+}
+
+/* Linux stores this in the device to avoid lookups, which we can consider. */
+static bool pci_is_pcie(struct pci_device *dev)
+{
+       return pci_find_cap(dev, PCI_CAP_ID_EXP, NULL) == 0 ? TRUE : FALSE;
+}
+
 /* Hacked up version of Linux's.  Assuming reg's are implemented and
  * read_config never fails. */
 static int pcie_capability_read_word(struct pci_device *dev, int pos,
                                      uint16_t *val)
 {
        uint32_t pcie_cap;
+
        *val = 0;
        if (pos & 1)
                return -EINVAL;
@@ -650,31 +747,93 @@ static int pcie_capability_read_word(struct pci_device *dev, int pos,
        return 0;
 }
 
+static int pcie_capability_write_word(struct pci_device *dev, int pos,
+                                      uint16_t val)
+{
+       uint32_t pcie_cap;
+
+       if (pos & 3)
+               return -EINVAL;
+       if (pci_find_cap(dev, PCI_CAP_ID_EXP, &pcie_cap))
+               return -EINVAL;
+       pci_write_config_word(dev, pcie_cap + pos, val);
+       return 0;
+}
+
+static int pcie_capability_clear_and_set_word(struct pci_device *dev, int pos,
+                                              uint16_t clear, uint16_t set)
+{
+       int ret;
+       uint16_t val;
+
+       ret = pcie_capability_read_word(dev, pos, &val);
+       if (ret)
+               return ret;
+       val &= ~clear;
+       val |= set;
+       return pcie_capability_write_word(dev, pos, val);
+}
+
+static int pcie_capability_clear_word(struct pci_device *dev, int pos,
+                                      uint16_t clear)
+{
+       return pcie_capability_clear_and_set_word(dev, pos, clear, 0);
+}
+
+static int pcie_capability_set_word(struct pci_device *dev, int pos,
+                                    uint16_t set)
+{
+       return pcie_capability_clear_and_set_word(dev, pos, 0, set);
+}
+
+/* Faking it */
+static int pci_request_regions(struct pci_device *pdev, const char *res_name)
+{
+       return 0;
+}
+
+static void pci_release_regions(struct pci_device *pdev)
+{
+}
+
+static bool pci_dev_run_wake(struct pci_device *dev)
+{
+       return FALSE;
+}
+
 #define ioremap_nocache(paddr, sz) \
         (void*)vmap_pmem_nocache((uintptr_t)paddr, sz)
 #define ioremap(paddr, sz) (void*)vmap_pmem((uintptr_t)paddr, sz)
 #define pci_ioremap_bar(dev, bir) (void*)pci_map_membar(dev, bir)
-#define pci_set_master(x) pci_set_bus_master(x)
+#define pci_disable_link_state(...)
 
 #define dev_addr_add(dev, addr, type) ({memcpy((dev)->ea, addr, Eaddrlen); 0;})
 #define dev_addr_del(...)
 
+/* Some of these might be important.  Mostly we need to rewrite whatever is
+ * using them, but we can leave the functions around to remind us what the code
+ * is supposed to do, especially for things we don't support yet. */
 #define SET_NETDEV_DEV(...)
-#define netif_carrier_off(...)
-#define netif_carrier_on(...)
 /* May need to do something with edev's queues or flags. */
 #define netif_tx_wake_all_queues(...)
 #define netif_tx_wake_queue(...)
 #define netif_tx_start_all_queues(...)
 #define netif_tx_start_queue(...)
 #define netif_tx_stop_queue(...)
+#define netif_start_queue(...)
+#define netif_stop_queue(...)
+#define netif_wake_queue(...)
+#define netif_device_detach(...)
+#define netif_queue_stopped(...) (FALSE)
 #define netif_napi_add(...)
+#define netif_napi_del(...)
 #define napi_hash_add(...)
 #define napi_enable(...)
 #define napi_disable(...)
 #define napi_schedule(...)
 #define napi_schedule_irqoff(...)
 #define napi_complete(...)
+#define free_irq(...)  /* We don't free yet! */
 /* picks a random, valid mac addr for dev */
 #define eth_hw_addr_random(...)
 /* checks if the MAC is not 0 and not multicast (all 1s) */
@@ -682,7 +841,9 @@ static int pcie_capability_read_word(struct pci_device *dev, int pos,
 /* The flag this checks is set on before open.  Turned off on failure, etc. */
 #define netif_running(dev) (TRUE)
 #define netdev_tx_sent_queue(...)
+#define netdev_update_features(...)
 #define skb_tx_timestamp(...)
+#define net_ratelimit() (TRUE)
 
 #define NET_SKB_PAD 0          /* padding for SKBs.  Ignoring it for now */
 #define MAX_SKB_FRAGS 16       /* we'll probably delete code using this */
@@ -703,10 +864,9 @@ struct firmware {
        size_t size;
 };
 
-/* the ignored param is a &pcidev->dev in linux, which is a struct dev.  our
- * pcidev->dev is the "slot" */
 static inline int request_firmware(const struct firmware **fwp,
-                                   const char *file_name, uint8_t *ignored)
+                                   const char *file_name,
+                                                                  struct device *ignored)
 {
        struct firmware *ret_fw;
        struct file *fw_file;
@@ -716,7 +876,7 @@ static inline int request_firmware(const struct firmware **fwp,
        char fullpath[sizeof(dirname) + strlen(file_name) + 1];
 
        snprintf(fullpath, sizeof(fullpath), "%s%s", dirname, file_name);
-       fw_file = do_file_open(fullpath, 0, 0);
+       fw_file = do_file_open(fullpath, O_READ, 0);
        if (!fw_file) {
                printk("Unable to find firmware file %s!\n", fullpath);
                return -1;
@@ -727,7 +887,7 @@ static inline int request_firmware(const struct firmware **fwp,
                kref_put(&fw_file->f_kref);
                return -1;
        }
-       ret_fw = kmalloc(sizeof(struct firmware), KMALLOC_WAIT);
+       ret_fw = kmalloc(sizeof(struct firmware), MEM_WAIT);
        ret_fw->data = fw_data;
        ret_fw->size = fw_file->f_dentry->d_inode->i_size;
        *fwp = ret_fw;
@@ -766,6 +926,74 @@ static inline bool ether_addr_equal(const uint8_t *addr1, const uint8_t *addr2)
 #endif
 }
 
-#include <linux/compat_todo.h>
+/* Linux uses this interface for 64 bit stats on 32 bit machines.  We're 64 bit
+ * only, so we can ignore the 32 bit versions. */
+struct u64_stats_sync {
+};
+
+static inline void u64_stats_init(struct u64_stats_sync *syncp)
+{
+}
+
+static inline void u64_stats_update_begin(struct u64_stats_sync *syncp)
+{
+}
+
+static inline void u64_stats_update_end(struct u64_stats_sync *syncp)
+{
+}
 
-#endif /* ROS_KERN_LINUX_COMPAT_H */
+static inline void u64_stats_update_begin_raw(struct u64_stats_sync *syncp)
+{
+}
+
+static inline void u64_stats_update_end_raw(struct u64_stats_sync *syncp)
+{
+}
+
+static inline unsigned int
+__u64_stats_fetch_begin(const struct u64_stats_sync *syncp)
+{
+       return 0;
+}
+
+static inline unsigned int
+u64_stats_fetch_begin(const struct u64_stats_sync *syncp)
+{
+       return __u64_stats_fetch_begin(syncp);
+}
+
+static inline bool __u64_stats_fetch_retry(const struct u64_stats_sync *syncp,
+                                           unsigned int start)
+{
+       return false;
+}
+
+static inline bool u64_stats_fetch_retry(const struct u64_stats_sync *syncp,
+                                        unsigned int start)
+{
+       return __u64_stats_fetch_retry(syncp, start);
+}
+
+static inline unsigned int
+u64_stats_fetch_begin_irq(const struct u64_stats_sync *syncp)
+{
+       return __u64_stats_fetch_begin(syncp);
+}
+
+static inline bool u64_stats_fetch_retry_irq(const struct u64_stats_sync *syncp,
+                                             unsigned int start)
+{
+       return __u64_stats_fetch_retry(syncp, start);
+}
+
+#define pm_request_resume(...) (1)
+#define pm_schedule_suspend(...) (-ENOSYS)
+#define pm_runtime_get_noresume(...)
+#define pm_runtime_active(...) (true)
+#define pm_runtime_put_noidle(...)
+#define pm_runtime_get_sync(...) (1)
+#define pm_runtime_put_sync(...) (-ENOSYS)
+#define device_set_wakeup_enable(...) (-EINVAL)
+
+#include <linux/compat_todo.h>