list_for_each_entry(pl, &dev->proc_list, list_head) {
                /* need to lock tasklist_lock before calling
                 * find_task_by_pid_type. */
-               if (find_task_by_pid_type(PIDTYPE_PID, pl->pid) != NULL)
+               if (find_task_by_pid(pl->pid) != NULL)
                        len += sprintf(buf + len, "%d\n", pl->pid);
                read_unlock(&tasklist_lock);
        }
 
        return 0;
 }
 
-static void sti_netlink_receive(struct sock *sk, int len)
+static void sti_netlink_receive(struct sk_buff *skb)
 {
-       struct sk_buff *skb;
-
        if (!mutex_trylock(&sti_netlink_mutex))
                return;
 
-       while ((skb = skb_dequeue(&sk->sk_receive_queue)))
-               if (sti_netlink_receive_skb(skb) && skb->len)
-                       skb_queue_head(&sk->sk_receive_queue, skb);
-               else
-                       kfree_skb(skb);
-
+       sti_netlink_receive_skb(skb);
        mutex_unlock(&sti_netlink_mutex);
 }
 
 static int __init sti_netlink_init(void)
 {
-       sti_sock = netlink_kernel_create(NETLINK_USERSOCK, 0,
+       sti_sock = netlink_kernel_create(&init_net, NETLINK_USERSOCK, 0,
                                         sti_netlink_receive, NULL,
                                         THIS_MODULE);
        if (!sti_sock) {
 
 #include <linux/input.h>
 #include <linux/timer.h>
 #include <linux/jiffies.h>
+#include <linux/bitops.h>
 
 #include "retu.h"
 
        if (!pwrbtn_dev)
                return -ENOMEM;
 
-       pwrbtn_dev->evbit[0] = BIT(EV_KEY);
-       pwrbtn_dev->keybit[LONG(KEY_POWER)] = BIT(KEY_POWER);
+       pwrbtn_dev->evbit[0] = BIT_MASK(EV_KEY);
+       pwrbtn_dev->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
        pwrbtn_dev->name = "retu-pwrbutton";
 
        input_register_device(pwrbtn_dev);
 
 config FB_OMAP
        tristate "OMAP frame buffer support (EXPERIMENTAL)"
         depends on FB
+       select FB_CFB_FILLRECT
+       select FB_CFB_COPYAREA
+       select FB_CFB_IMAGEBLIT
         help
           Frame buffer driver for OMAP based boards.
 
 
        struct utimer_t *timer = container_of(work, struct utimer_t, work);
        struct net_device *netdev;
 
-       netdev = dev_get_by_name(timer->name);
+       netdev = dev_get_by_name(&init_net, timer->name);
 
        if (netdev != NULL) {
                sysfs_notify(&netdev->dev.kobj, NULL,
                                unsigned long event, void *ptr)
 {
        struct net_device *dev = ptr;
+       int ret = NOTIFY_DONE;
 
        switch (event) {
        case NETDEV_UP:
                DEBUGP("NETDEV_UP: %s\n", dev->name);
-               device_create_file(&dev->dev,
+               ret = device_create_file(&dev->dev,
                                         &dev_attr_idletimer);
                break;
        case NETDEV_DOWN:
                break;
        }
 
-       return NOTIFY_DONE;
+       return ret;
 }
 
 static struct notifier_block utimer_notifier_block = {
 
        rtnl_lock();
        unregister_netdevice_notifier(&utimer_notifier_block);
-       for_each_netdev(dev)
+       for_each_netdev(&init_net, dev)
                utimer_notifier_call(&utimer_notifier_block,
                                     NETDEV_DOWN, dev);
        rtnl_unlock();
 /*
  * The actual iptables plugin.
  */
-static unsigned int ipt_idletimer_target(struct sk_buff **pskb,
+static unsigned int ipt_idletimer_target(struct sk_buff *pskb,
                                         const struct net_device *in,
                                         const struct net_device *out,
                                         unsigned int hooknum,
        return XT_CONTINUE;
 }
 
-static int ipt_idletimer_checkentry(const char *tablename,
+static bool ipt_idletimer_checkentry(const char *tablename,
                                    const void *e,
                                    const struct xt_target *target,
                                    void *targinfo,
                return 0;
        }
 
-       return 1;
+       return true;
 }
 
 static struct xt_target ipt_idletimer = {