Web lists-archives.com

[PATCH 03/10] staging/irda/net: Adjust 385 checks for null pointers




From: Markus Elfring <elfring@xxxxxxxxxxxxxxxxxxxxx>
Date: Wed, 11 Oct 2017 22:10:26 +0200
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The script “checkpatch.pl” pointed information out like the following.

Comparison to NULL could be written …

Thus fix the affected source code places.


Use space characters at some places according to the Linux coding
style convention.

Signed-off-by: Markus Elfring <elfring@xxxxxxxxxxxxxxxxxxxxx>
---
 drivers/staging/irda/net/af_irda.c      |  56 ++++++-------
 drivers/staging/irda/net/discovery.c    |  31 ++++---
 drivers/staging/irda/net/irda_device.c  |   2 +-
 drivers/staging/irda/net/iriap.c        |  61 +++++++-------
 drivers/staging/irda/net/iriap_event.c  |  34 ++++----
 drivers/staging/irda/net/irias_object.c |  62 +++++++-------
 drivers/staging/irda/net/irlap.c        |  73 ++++++++--------
 drivers/staging/irda/net/irlap_event.c  |  77 +++++++++--------
 drivers/staging/irda/net/irlap_frame.c  |  51 +++++------
 drivers/staging/irda/net/irlmp.c        | 144 +++++++++++++++-----------------
 drivers/staging/irda/net/irlmp_event.c  |  50 ++++++-----
 drivers/staging/irda/net/irlmp_frame.c  |  24 +++---
 drivers/staging/irda/net/irnetlink.c    |   2 +-
 drivers/staging/irda/net/irproc.c       |   2 +-
 drivers/staging/irda/net/irqueue.c      |  32 +++----
 drivers/staging/irda/net/irsysctl.c     |   4 +-
 drivers/staging/irda/net/irttp.c        |  68 +++++++--------
 drivers/staging/irda/net/parameters.c   |  12 +--
 drivers/staging/irda/net/qos.c          |  20 ++---
 drivers/staging/irda/net/timer.c        |  12 +--
 drivers/staging/irda/net/wrapper.c      |   3 +-
 21 files changed, 396 insertions(+), 424 deletions(-)

diff --git a/drivers/staging/irda/net/af_irda.c b/drivers/staging/irda/net/af_irda.c
index 23fa7c8b09a5..cb60b89053dd 100644
--- a/drivers/staging/irda/net/af_irda.c
+++ b/drivers/staging/irda/net/af_irda.c
@@ -121,7 +121,7 @@ static void irda_disconnect_indication(void *instance, void *sap,
 		dev_kfree_skb(skb);
 
 	sk = instance;
-	if (sk == NULL) {
+	if (!sk) {
 		pr_debug("%s(%p) : BUG : sk is NULL\n",
 			 __func__, self);
 		return;
@@ -182,7 +182,7 @@ static void irda_connect_confirm(void *instance, void *sap,
 	pr_debug("%s(%p)\n", __func__, self);
 
 	sk = instance;
-	if (sk == NULL) {
+	if (!sk) {
 		dev_kfree_skb(skb);
 		return;
 	}
@@ -246,7 +246,7 @@ static void irda_connect_indication(void *instance, void *sap,
 	pr_debug("%s(%p)\n", __func__, self);
 
 	sk = instance;
-	if (sk == NULL) {
+	if (!sk) {
 		dev_kfree_skb(skb);
 		return;
 	}
@@ -301,7 +301,7 @@ static void irda_connect_response(struct irda_sock *self)
 	struct sk_buff *skb;
 
 	skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER, GFP_KERNEL);
-	if (skb == NULL) {
+	if (!skb) {
 		pr_debug("%s() Unable to allocate sk_buff!\n",
 			 __func__);
 		return;
@@ -326,7 +326,7 @@ static void irda_flow_indication(void *instance, void *sap, LOCAL_FLOW flow)
 
 	self = instance;
 	sk = instance;
-	BUG_ON(sk == NULL);
+	BUG_ON(!sk);
 
 	switch (flow) {
 	case FLOW_STOP:
@@ -434,7 +434,7 @@ static void irda_discovery_timeout(u_long priv)
 	struct irda_sock *self;
 
 	self = (struct irda_sock *) priv;
-	BUG_ON(self == NULL);
+	BUG_ON(!self);
 
 	/* Nothing for the caller */
 	self->cachelog = NULL;
@@ -473,7 +473,7 @@ static int irda_open_tsap(struct irda_sock *self, __u8 tsap_sel, char *name)
 
 	self->tsap = irttp_open_tsap(tsap_sel, DEFAULT_INITIAL_CREDIT,
 				     &notify);
-	if (self->tsap == NULL) {
+	if (!self->tsap) {
 		pr_debug("%s(), Unable to allocate TSAP!\n",
 			 __func__);
 		return -ENOMEM;
@@ -507,7 +507,7 @@ static int irda_open_lsap(struct irda_sock *self, int pid)
 	strncpy(notify.name, "Ultra", NOTIFY_MAX_NAME);
 
 	self->lsap = irlmp_open_lsap(LSAP_CONNLESS, &notify, pid);
-	if (self->lsap == NULL) {
+	if (!self->lsap) {
 		pr_debug("%s(), Unable to allocate LSAP!\n", __func__);
 		return -ENOMEM;
 	}
@@ -539,7 +539,7 @@ static int irda_find_lsap_sel(struct irda_sock *self, char *name)
 
 	self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
 				 irda_getvalue_confirm);
-	if(self->iriap == NULL)
+	if (!self->iriap)
 		return -ENOMEM;
 
 	/* Treat unexpected wakeup as disconnect */
@@ -625,7 +625,7 @@ static int irda_discover_daddr_and_lsap_sel(struct irda_sock *self, char *name)
 	discoveries = irlmp_get_discoveries(&number, self->mask.word,
 					    self->nslots);
 	/* Check if the we got some results */
-	if (discoveries == NULL)
+	if (!discoveries)
 		return -ENETUNREACH;	/* No nodes discovered */
 
 	/*
@@ -801,7 +801,7 @@ static int irda_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 
 	self->ias_obj = irias_new_object(addr->sir_name, jiffies);
 	err = -ENOMEM;
-	if (self->ias_obj == NULL)
+	if (!self->ias_obj)
 		goto out;
 
 	err = irda_open_tsap(self, addr->sir_lsap_sel, addr->sir_name);
@@ -887,7 +887,7 @@ static int irda_accept(struct socket *sock, struct socket *newsock, int flags,
 
 	newsk = newsock->sk;
 	err = -EIO;
-	if (newsk == NULL)
+	if (!newsk)
 		goto out;
 
 	newsk->sk_state = TCP_ESTABLISHED;
@@ -1105,7 +1105,7 @@ static int irda_create(struct net *net, struct socket *sock, int protocol,
 
 	/* Allocate networking socket */
 	sk = sk_alloc(net, PF_IRDA, GFP_KERNEL, &irda_proto, kern);
-	if (sk == NULL)
+	if (!sk)
 		return -ENOMEM;
 
 	self = irda_sk(sk);
@@ -1208,7 +1208,7 @@ static int irda_release(struct socket *sock)
 {
 	struct sock *sk = sock->sk;
 
-	if (sk == NULL)
+	if (!sk)
 		return 0;
 
 	lock_sock(sk);
@@ -1431,7 +1431,7 @@ static int irda_recvmsg_stream(struct socket *sock, struct msghdr *msg,
 		int chunk;
 		struct sk_buff *skb = skb_dequeue(&sk->sk_receive_queue);
 
-		if (skb == NULL) {
+		if (!skb) {
 			DEFINE_WAIT(wait);
 			err = 0;
 
@@ -1454,7 +1454,7 @@ static int irda_recvmsg_stream(struct socket *sock, struct msghdr *msg,
 				err = sock_intr_errno(timeo);
 			else if (sk->sk_state != TCP_ESTABLISHED)
 				err = -ENOTCONN;
-			else if (skb_peek(&sk->sk_receive_queue) == NULL)
+			else if (!skb_peek(&sk->sk_receive_queue))
 				/* Wait process until data arrives */
 				schedule();
 
@@ -1649,8 +1649,7 @@ static int irda_sendmsg_ultra(struct socket *sock, struct msghdr *msg,
 	} else {
 		/* Check that the socket is properly bound to an Ultra
 		 * port. Jean II */
-		if ((self->lsap == NULL) ||
-		    (sk->sk_state != TCP_ESTABLISHED)) {
+		if (!self->lsap || sk->sk_state != TCP_ESTABLISHED) {
 			pr_debug("%s(), socket not bound to Ultra PID.\n",
 				 __func__);
 			err = -ENOTCONN;
@@ -1828,7 +1827,7 @@ static int irda_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 	}
 
 	case SIOCGSTAMP:
-		if (sk != NULL)
+		if (sk)
 			err = sock_get_timestamp(sk, (struct timeval __user *)arg);
 		break;
 
@@ -1913,7 +1912,7 @@ static int irda_setsockopt(struct socket *sock, int level, int optname,
 		 * associated with this socket. This will workaround
 		 * duplicated class name - Jean II */
 		if(ias_opt->irda_class_name[0] == '\0') {
-			if(self->ias_obj == NULL) {
+			if (!self->ias_obj) {
 				kfree(ias_opt);
 				err = -EINVAL;
 				goto out;
@@ -1925,19 +1924,19 @@ static int irda_setsockopt(struct socket *sock, int level, int optname,
 		/* Only ROOT can mess with the global IAS database.
 		 * Users can only add attributes to the object associated
 		 * with the socket they own - Jean II */
-		if((!capable(CAP_NET_ADMIN)) &&
-		   ((ias_obj == NULL) || (ias_obj != self->ias_obj))) {
+		if (!capable(CAP_NET_ADMIN) &&
+		    (!ias_obj || ias_obj != self->ias_obj)) {
 			kfree(ias_opt);
 			err = -EPERM;
 			goto out;
 		}
 
 		/* If the object doesn't exist, create it */
-		if(ias_obj == (struct ias_object *) NULL) {
+		if (!ias_obj) {
 			/* Create a new object */
 			ias_obj = irias_new_object(ias_opt->irda_class_name,
 						   jiffies);
-			if (ias_obj == NULL) {
+			if (!ias_obj) {
 				kfree(ias_opt);
 				err = -ENOMEM;
 				goto out;
@@ -2050,8 +2049,8 @@ static int irda_setsockopt(struct socket *sock, int level, int optname,
 		/* Only ROOT can mess with the global IAS database.
 		 * Users can only del attributes from the object associated
 		 * with the socket they own - Jean II */
-		if((!capable(CAP_NET_ADMIN)) &&
-		   ((ias_obj == NULL) || (ias_obj != self->ias_obj))) {
+		if (!capable(CAP_NET_ADMIN) &&
+		    (!ias_obj || ias_obj != self->ias_obj)) {
 			kfree(ias_opt);
 			err = -EPERM;
 			goto out;
@@ -2253,7 +2252,7 @@ static int irda_getsockopt(struct socket *sock, int level, int optname,
 		discoveries = irlmp_get_discoveries(&list.len, self->mask.word,
 						    self->nslots);
 		/* Check if the we got some results */
-		if (discoveries == NULL) {
+		if (!discoveries) {
 			err = -EAGAIN;
 			goto out;		/* Didn't find any devices */
 		}
@@ -2404,8 +2403,7 @@ static int irda_getsockopt(struct socket *sock, int level, int optname,
 
 		self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
 					 irda_getvalue_confirm);
-
-		if (self->iriap == NULL) {
+		if (!self->iriap) {
 			kfree(ias_opt);
 			err = -ENOMEM;
 			goto out;
diff --git a/drivers/staging/irda/net/discovery.c b/drivers/staging/irda/net/discovery.c
index 1e54954a4081..7469d7c537a8 100644
--- a/drivers/staging/irda/net/discovery.c
+++ b/drivers/staging/irda/net/discovery.c
@@ -74,7 +74,7 @@ void irlmp_add_discovery(hashbin_t *cachelog, discovery_t *new)
 	 * their device address between every discovery.
 	 */
 	discovery = (discovery_t *) hashbin_get_first(cachelog);
-	while (discovery != NULL ) {
+	while (discovery) {
 		node = discovery;
 
 		/* Be sure to stay one item ahead */
@@ -118,7 +118,7 @@ void irlmp_add_discovery_log(hashbin_t *cachelog, hashbin_t *log)
 	 *  of the normal one.
 	 */
 	/* Well... It means that there was nobody out there - Jean II */
-	if (log == NULL) {
+	if (!log) {
 		/* irlmp_start_discovery_timer(irlmp, 150); */
 		return;
 	}
@@ -129,7 +129,7 @@ void irlmp_add_discovery_log(hashbin_t *cachelog, hashbin_t *log)
 	 * We just need to lock the global log in irlmp_add_discovery().
 	 */
 	discovery = (discovery_t *) hashbin_remove_first(log);
-	while (discovery != NULL) {
+	while (discovery) {
 		irlmp_add_discovery(cachelog, discovery);
 
 		discovery = (discovery_t *) hashbin_remove_first(log);
@@ -156,11 +156,11 @@ void irlmp_expire_discoveries(hashbin_t *log, __u32 saddr, int force)
 	int			n;		/* Size of the full log */
 	int			i = 0;		/* How many we expired */
 
-	IRDA_ASSERT(log != NULL, return;);
+	IRDA_ASSERT(log, return;);
 	spin_lock_irqsave(&log->hb_spinlock, flags);
 
 	discovery = (discovery_t *) hashbin_get_first(log);
-	while (discovery != NULL) {
+	while (discovery) {
 		/* Be sure to be one item ahead */
 		curr = discovery;
 		discovery = (discovery_t *) hashbin_get_next(log);
@@ -175,7 +175,7 @@ void irlmp_expire_discoveries(hashbin_t *log, __u32 saddr, int force)
 			 * we don't have anything to put in the log (we are
 			 * quite picky), we can save a lot of overhead
 			 * by not calling kmalloc. Jean II */
-			if(buffer == NULL) {
+			if (!buffer) {
 				/* Create the client specific buffer */
 				n = HASHBIN_GET_SIZE(log);
 				buffer = kmalloc(n * sizeof(struct irda_device_info), GFP_ATOMIC);
@@ -203,7 +203,7 @@ void irlmp_expire_discoveries(hashbin_t *log, __u32 saddr, int force)
 	 * don't care to be interrupted. - Jean II */
 	spin_unlock_irqrestore(&log->hb_spinlock, flags);
 
-	if(buffer == NULL)
+	if (!buffer)
 		return;
 
 	/* Tell IrLMP and registered clients about it */
@@ -224,10 +224,10 @@ void irlmp_dump_discoveries(hashbin_t *log)
 {
 	discovery_t *discovery;
 
-	IRDA_ASSERT(log != NULL, return;);
+	IRDA_ASSERT(log, return;);
 
 	discovery = (discovery_t *) hashbin_get_first(log);
-	while (discovery != NULL) {
+	while (discovery) {
 		pr_debug("Discovery:\n");
 		pr_debug("  daddr=%08x\n", discovery->data.daddr);
 		pr_debug("  saddr=%08x\n", discovery->data.saddr);
@@ -268,14 +268,14 @@ struct irda_device_info *irlmp_copy_discoveries(hashbin_t *log, int *pn,
 	int			n;		/* Size of the full log */
 	int			i = 0;		/* How many we picked */
 
-	IRDA_ASSERT(pn != NULL, return NULL;);
-	IRDA_ASSERT(log != NULL, return NULL;);
+	IRDA_ASSERT(pn, return NULL;);
+	IRDA_ASSERT(log, return NULL;);
 
 	/* Save spin lock */
 	spin_lock_irqsave(&log->hb_spinlock, flags);
 
 	discovery = (discovery_t *) hashbin_get_first(log);
-	while (discovery != NULL) {
+	while (discovery) {
 		/* Mask out the ones we don't want :
 		 * We want to match the discovery mask, and to get only
 		 * the most recent one (unless we want old ones) */
@@ -287,7 +287,7 @@ struct irda_device_info *irlmp_copy_discoveries(hashbin_t *log, int *pn,
 			 * we don't have anything to put in the log (we are
 			 * quite picky), we can save a lot of overhead
 			 * by not calling kmalloc. Jean II */
-			if(buffer == NULL) {
+			if (!buffer) {
 				/* Create the client specific buffer */
 				n = HASHBIN_GET_SIZE(log);
 				buffer = kmalloc(n * sizeof(struct irda_device_info), GFP_ATOMIC);
@@ -320,7 +320,7 @@ static inline discovery_t *discovery_seq_idx(loff_t pos)
 	discovery_t *discovery;
 
 	for (discovery = (discovery_t *) hashbin_get_first(irlmp->cachelog);
-	     discovery != NULL;
+	     discovery;
 	     discovery = (discovery_t *) hashbin_get_next(irlmp->cachelog)) {
 		if (pos-- == 0)
 			break;
@@ -402,8 +402,7 @@ static const struct seq_operations discovery_seq_ops = {
 
 static int discovery_seq_open(struct inode *inode, struct file *file)
 {
-	IRDA_ASSERT(irlmp != NULL, return -EINVAL;);
-
+	IRDA_ASSERT(irlmp, return -EINVAL;);
 	return seq_open(file, &discovery_seq_ops);
 }
 
diff --git a/drivers/staging/irda/net/irda_device.c b/drivers/staging/irda/net/irda_device.c
index d33de8a8762a..f06bf24341f9 100644
--- a/drivers/staging/irda/net/irda_device.c
+++ b/drivers/staging/irda/net/irda_device.c
@@ -190,7 +190,7 @@ static int irda_task_kick(struct irda_task *task)
 	int count = 0;
 	int timeout;
 
-	IRDA_ASSERT(task != NULL, return -1;);
+	IRDA_ASSERT(task, return -1;);
 	IRDA_ASSERT(task->magic == IRDA_TASK_MAGIC, return -1;);
 
 	/* Execute task until it's finished, or askes for a timeout */
diff --git a/drivers/staging/irda/net/iriap.c b/drivers/staging/irda/net/iriap.c
index 1138eaf5c682..2a6ffb468128 100644
--- a/drivers/staging/irda/net/iriap.c
+++ b/drivers/staging/irda/net/iriap.c
@@ -221,7 +221,7 @@ EXPORT_SYMBOL(iriap_open);
  */
 static void __iriap_close(struct iriap_cb *self)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	del_timer(&self->watchdog_timer);
@@ -243,7 +243,7 @@ void iriap_close(struct iriap_cb *self)
 {
 	struct iriap_cb *entry;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	if (self->lsap) {
@@ -274,7 +274,7 @@ static int iriap_register_lsap(struct iriap_cb *self, __u8 slsap_sel, int mode)
 		strcpy(notify.name, "IrIAS srv");
 
 	self->lsap = irlmp_open_lsap(slsap_sel, &notify, 0);
-	if (self->lsap == NULL) {
+	if (!self->lsap) {
 		net_err_ratelimited("%s: Unable to allocated LSAP!\n",
 				    __func__);
 		return -1;
@@ -301,10 +301,9 @@ static void iriap_disconnect_indication(void *instance, void *sap,
 
 	self = instance;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
-
-	IRDA_ASSERT(iriap != NULL, return;);
+	IRDA_ASSERT(iriap, return;);
 
 	del_timer(&self->watchdog_timer);
 
@@ -340,11 +339,11 @@ static void iriap_disconnect_request(struct iriap_cb *self)
 {
 	struct sk_buff *tx_skb;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
-	if (tx_skb == NULL) {
+	if (!tx_skb) {
 		pr_debug("%s(), Could not allocate an sk_buff of length %d\n",
 			 __func__, LMP_MAX_HEADER);
 		return;
@@ -372,7 +371,7 @@ int iriap_getvaluebyclass_request(struct iriap_cb *self,
 	int name_len, attr_len, skb_len;
 	__u8 *frame;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return -1;);
 
 	/* Client must supply the destination device address */
@@ -439,9 +438,9 @@ static void iriap_getvaluebyclass_confirm(struct iriap_cb *self,
 	__u8 *fp;
 	int n;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	/* Initialize variables */
 	fp = skb->data;
@@ -551,9 +550,9 @@ static void iriap_getvaluebyclass_response(struct iriap_cb *self,
 	__be16 tmp_be16;
 	__u8 *fp;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
-	IRDA_ASSERT(value != NULL, return;);
+	IRDA_ASSERT(value, return;);
 	IRDA_ASSERT(value->len <= 1024, return;);
 
 	/* Initialize variables */
@@ -643,9 +642,9 @@ static void iriap_getvaluebyclass_indication(struct iriap_cb *self,
 	__u8 *fp;
 	int n;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	fp = skb->data;
 	n = 1;
@@ -666,8 +665,7 @@ static void iriap_getvaluebyclass_indication(struct iriap_cb *self,
 
 	pr_debug("LM-IAS: Looking up %s: %s\n", name, attr);
 	obj = irias_find_object(name);
-
-	if (obj == NULL) {
+	if (!obj) {
 		pr_debug("LM-IAS: Object %s not found\n", name);
 		iriap_getvaluebyclass_response(self, 0x1235, IAS_CLASS_UNKNOWN,
 					       &irias_missing);
@@ -676,7 +674,7 @@ static void iriap_getvaluebyclass_indication(struct iriap_cb *self,
 	pr_debug("LM-IAS: found %s, id=%d\n", obj->name, obj->id);
 
 	attrib = irias_find_attrib(obj, attr);
-	if (attrib == NULL) {
+	if (!attrib) {
 		pr_debug("LM-IAS: Attribute %s not found\n", attr);
 		iriap_getvaluebyclass_response(self, obj->id,
 					       IAS_ATTRIB_UNKNOWN,
@@ -700,7 +698,7 @@ void iriap_send_ack(struct iriap_cb *self)
 	struct sk_buff *tx_skb;
 	__u8 *frame;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	tx_skb = alloc_skb(LMP_MAX_HEADER + 1, GFP_ATOMIC);
@@ -722,7 +720,7 @@ void iriap_connect_request(struct iriap_cb *self)
 {
 	int ret;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	ret = irlmp_connect_request(self->lsap, LSAP_IAS,
@@ -749,9 +747,9 @@ static void iriap_connect_confirm(void *instance, void *sap,
 
 	self = instance;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	self->max_data_size = max_seg_size;
 	self->max_header_size = max_header_size;
@@ -779,8 +777,8 @@ static void iriap_connect_indication(void *instance, void *sap,
 
 	self = instance;
 
-	IRDA_ASSERT(skb != NULL, return;);
-	IRDA_ASSERT(self != NULL, goto out;);
+	IRDA_ASSERT(skb, return;);
+	IRDA_ASSERT(self, goto out;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, goto out;);
 
 	/* Start new server */
@@ -825,8 +823,8 @@ static int iriap_data_indication(void *instance, void *sap,
 
 	self = instance;
 
-	IRDA_ASSERT(skb != NULL, return 0;);
-	IRDA_ASSERT(self != NULL, goto out;);
+	IRDA_ASSERT(skb, return 0;);
+	IRDA_ASSERT(self, goto out;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, goto out;);
 
 	frame = skb->data;
@@ -914,9 +912,9 @@ void iriap_call_indication(struct iriap_cb *self, struct sk_buff *skb)
 	__u8 *fp;
 	__u8 opcode;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	fp = skb->data;
 
@@ -950,7 +948,7 @@ static void iriap_watchdog_timer_expired(void *data)
 {
 	struct iriap_cb *self = (struct iriap_cb *) data;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	/* iriap_close(self); */
@@ -1019,7 +1017,7 @@ static int irias_seq_show(struct seq_file *seq, void *v)
 
 		/* List all attributes for this object */
 		for (attrib = (struct ias_attrib *) hashbin_get_first(obj->attribs);
-		     attrib != NULL;
+		     attrib;
 		     attrib = (struct ias_attrib *) hashbin_get_next(obj->attribs)) {
 
 			IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC,
@@ -1069,8 +1067,7 @@ static const struct seq_operations irias_seq_ops = {
 
 static int irias_seq_open(struct inode *inode, struct file *file)
 {
-	IRDA_ASSERT( irias_objects != NULL, return -EINVAL;);
-
+	IRDA_ASSERT(irias_objects, return -EINVAL;);
 	return seq_open(file, &irias_seq_ops);
 }
 
diff --git a/drivers/staging/irda/net/iriap_event.c b/drivers/staging/irda/net/iriap_event.c
index e6098b2e048a..468e30172702 100644
--- a/drivers/staging/irda/net/iriap_event.c
+++ b/drivers/staging/irda/net/iriap_event.c
@@ -95,7 +95,7 @@ static void (*iriap_state[])(struct iriap_cb *self, IRIAP_EVENT event,
 
 void iriap_next_client_state(struct iriap_cb *self, IRIAP_STATE state)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	self->client_state = state;
@@ -103,7 +103,7 @@ void iriap_next_client_state(struct iriap_cb *self, IRIAP_STATE state)
 
 void iriap_next_call_state(struct iriap_cb *self, IRIAP_STATE state)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	self->call_state = state;
@@ -111,7 +111,7 @@ void iriap_next_call_state(struct iriap_cb *self, IRIAP_STATE state)
 
 void iriap_next_server_state(struct iriap_cb *self, IRIAP_STATE state)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	self->server_state = state;
@@ -119,7 +119,7 @@ void iriap_next_server_state(struct iriap_cb *self, IRIAP_STATE state)
 
 void iriap_next_r_connect_state(struct iriap_cb *self, IRIAP_STATE state)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	self->r_connect_state = state;
@@ -128,7 +128,7 @@ void iriap_next_r_connect_state(struct iriap_cb *self, IRIAP_STATE state)
 void iriap_do_client_event(struct iriap_cb *self, IRIAP_EVENT event,
 			   struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	(*iriap_state[ self->client_state]) (self, event, skb);
@@ -137,7 +137,7 @@ void iriap_do_client_event(struct iriap_cb *self, IRIAP_EVENT event,
 void iriap_do_call_event(struct iriap_cb *self, IRIAP_EVENT event,
 			 struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	(*iriap_state[ self->call_state]) (self, event, skb);
@@ -146,7 +146,7 @@ void iriap_do_call_event(struct iriap_cb *self, IRIAP_EVENT event,
 void iriap_do_server_event(struct iriap_cb *self, IRIAP_EVENT event,
 			   struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	(*iriap_state[ self->server_state]) (self, event, skb);
@@ -155,7 +155,7 @@ void iriap_do_server_event(struct iriap_cb *self, IRIAP_EVENT event,
 void iriap_do_r_connect_event(struct iriap_cb *self, IRIAP_EVENT event,
 			      struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	(*iriap_state[ self->r_connect_state]) (self, event, skb);
@@ -171,13 +171,13 @@ void iriap_do_r_connect_event(struct iriap_cb *self, IRIAP_EVENT event,
 static void state_s_disconnect(struct iriap_cb *self, IRIAP_EVENT event,
 			       struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	switch (event) {
 	case IAP_CALL_REQUEST_GVBC:
 		iriap_next_client_state(self, S_CONNECTING);
-		IRDA_ASSERT(self->request_skb == NULL, return;);
+		IRDA_ASSERT(!self->request_skb, return;);
 		/* Don't forget to refcount it -
 		 * see iriap_getvaluebyclass_request(). */
 		skb_get(skb);
@@ -201,7 +201,7 @@ static void state_s_disconnect(struct iriap_cb *self, IRIAP_EVENT event,
 static void state_s_connecting(struct iriap_cb *self, IRIAP_EVENT event,
 			       struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	switch (event) {
@@ -234,7 +234,7 @@ static void state_s_connecting(struct iriap_cb *self, IRIAP_EVENT event,
 static void state_s_call(struct iriap_cb *self, IRIAP_EVENT event,
 			 struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 
 	switch (event) {
 	case IAP_LM_DISCONNECT_INDICATION:
@@ -259,7 +259,7 @@ static void state_s_make_call(struct iriap_cb *self, IRIAP_EVENT event,
 {
 	struct sk_buff *tx_skb;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 
 	switch (event) {
 	case IAP_CALL_REQUEST:
@@ -297,7 +297,7 @@ static void state_s_calling(struct iriap_cb *self, IRIAP_EVENT event,
 static void state_s_outstanding(struct iriap_cb *self, IRIAP_EVENT event,
 				struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 
 	switch (event) {
 	case IAP_RECV_F_LST:
@@ -368,7 +368,7 @@ static void state_r_disconnect(struct iriap_cb *self, IRIAP_EVENT event,
 	switch (event) {
 	case IAP_LM_CONNECT_INDICATION:
 		tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
-		if (tx_skb == NULL)
+		if (!tx_skb)
 			return;
 
 		/* Reserve space for MUX_CONTROL and LAP header */
@@ -458,8 +458,8 @@ static void state_r_receiving(struct iriap_cb *self, IRIAP_EVENT event,
 static void state_r_execute(struct iriap_cb *self, IRIAP_EVENT event,
 			    struct sk_buff *skb)
 {
-	IRDA_ASSERT(skb != NULL, return;);
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(skb, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
 
 	switch (event) {
diff --git a/drivers/staging/irda/net/irias_object.c b/drivers/staging/irda/net/irias_object.c
index 4db986b9d756..4c2c65e28836 100644
--- a/drivers/staging/irda/net/irias_object.c
+++ b/drivers/staging/irda/net/irias_object.c
@@ -64,8 +64,7 @@ struct ias_object *irias_new_object( char *name, int id)
 	 * than the objects spinlock. Never grap the objects spinlock
 	 * while holding any attrib spinlock (risk of deadlock). Jean II */
 	obj->attribs = hashbin_new(HB_LOCK);
-
-	if (obj->attribs == NULL) {
+	if (!obj->attribs) {
 		net_warn_ratelimited("%s(), Unable to allocate attribs!\n",
 				     __func__);
 		kfree(obj->name);
@@ -85,7 +84,7 @@ EXPORT_SYMBOL(irias_new_object);
  */
 static void __irias_delete_attrib(struct ias_attrib *attrib)
 {
-	IRDA_ASSERT(attrib != NULL, return;);
+	IRDA_ASSERT(attrib, return;);
 	IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
 
 	kfree(attrib->name);
@@ -98,7 +97,7 @@ static void __irias_delete_attrib(struct ias_attrib *attrib)
 
 void __irias_delete_object(struct ias_object *obj)
 {
-	IRDA_ASSERT(obj != NULL, return;);
+	IRDA_ASSERT(obj, return;);
 	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 
 	kfree(obj->name);
@@ -121,7 +120,7 @@ int irias_delete_object(struct ias_object *obj)
 {
 	struct ias_object *node;
 
-	IRDA_ASSERT(obj != NULL, return -1;);
+	IRDA_ASSERT(obj, return -1;);
 	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
 
 	/* Remove from list */
@@ -149,9 +148,9 @@ int irias_delete_attrib(struct ias_object *obj, struct ias_attrib *attrib,
 {
 	struct ias_attrib *node;
 
-	IRDA_ASSERT(obj != NULL, return -1;);
+	IRDA_ASSERT(obj, return -1;);
 	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
-	IRDA_ASSERT(attrib != NULL, return -1;);
+	IRDA_ASSERT(attrib, return -1;);
 
 	/* Remove attribute from object */
 	node = hashbin_remove_this(obj->attribs, (irda_queue_t *) attrib);
@@ -181,7 +180,7 @@ int irias_delete_attrib(struct ias_object *obj, struct ias_attrib *attrib,
  */
 void irias_insert_object(struct ias_object *obj)
 {
-	IRDA_ASSERT(obj != NULL, return;);
+	IRDA_ASSERT(obj, return;);
 	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 
 	hashbin_insert(irias_objects, (irda_queue_t *) obj, 0, obj->name);
@@ -196,7 +195,7 @@ EXPORT_SYMBOL(irias_insert_object);
  */
 struct ias_object *irias_find_object(char *name)
 {
-	IRDA_ASSERT(name != NULL, return NULL;);
+	IRDA_ASSERT(name, return NULL;);
 
 	/* Unsafe (locking), object might change */
 	return hashbin_lock_find(irias_objects, 0, name);
@@ -213,12 +212,12 @@ struct ias_attrib *irias_find_attrib(struct ias_object *obj, char *name)
 {
 	struct ias_attrib *attrib;
 
-	IRDA_ASSERT(obj != NULL, return NULL;);
+	IRDA_ASSERT(obj, return NULL;);
 	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return NULL;);
-	IRDA_ASSERT(name != NULL, return NULL;);
+	IRDA_ASSERT(name, return NULL;);
 
 	attrib = hashbin_lock_find(obj->attribs, 0, name);
-	if (attrib == NULL)
+	if (!attrib)
 		return NULL;
 
 	/* Unsafe (locking), attrib might change */
@@ -234,10 +233,9 @@ struct ias_attrib *irias_find_attrib(struct ias_object *obj, char *name)
 static void irias_add_attrib(struct ias_object *obj, struct ias_attrib *attrib,
 			     int owner)
 {
-	IRDA_ASSERT(obj != NULL, return;);
+	IRDA_ASSERT(obj, return;);
 	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
-
-	IRDA_ASSERT(attrib != NULL, return;);
+	IRDA_ASSERT(attrib, return;);
 	IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
 
 	/* Set if attrib is owned by kernel or user space */
@@ -261,7 +259,7 @@ int irias_object_change_attribute(char *obj_name, char *attrib_name,
 
 	/* Find object */
 	obj = hashbin_lock_find(irias_objects, 0, obj_name);
-	if (obj == NULL) {
+	if (!obj) {
 		net_warn_ratelimited("%s: Unable to find object: %s\n",
 				     __func__, obj_name);
 		return -1;
@@ -272,7 +270,7 @@ int irias_object_change_attribute(char *obj_name, char *attrib_name,
 
 	/* Find attribute */
 	attrib = hashbin_find(obj->attribs, 0, attrib_name);
-	if (attrib == NULL) {
+	if (!attrib) {
 		net_warn_ratelimited("%s: Unable to find attribute: %s\n",
 				     __func__, attrib_name);
 		spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
@@ -309,9 +307,9 @@ void irias_add_integer_attrib(struct ias_object *obj, char *name, int value,
 {
 	struct ias_attrib *attrib;
 
-	IRDA_ASSERT(obj != NULL, return;);
+	IRDA_ASSERT(obj, return;);
 	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
-	IRDA_ASSERT(name != NULL, return;);
+	IRDA_ASSERT(name, return;);
 
 	attrib = kzalloc(sizeof(*attrib), GFP_ATOMIC);
 	if (!attrib)
@@ -348,11 +346,10 @@ void irias_add_octseq_attrib(struct ias_object *obj, char *name, __u8 *octets,
 {
 	struct ias_attrib *attrib;
 
-	IRDA_ASSERT(obj != NULL, return;);
+	IRDA_ASSERT(obj, return;);
 	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
-
-	IRDA_ASSERT(name != NULL, return;);
-	IRDA_ASSERT(octets != NULL, return;);
+	IRDA_ASSERT(name, return;);
+	IRDA_ASSERT(octets, return;);
 
 	attrib = kzalloc(sizeof(*attrib), GFP_ATOMIC);
 	if (!attrib)
@@ -387,11 +384,10 @@ void irias_add_string_attrib(struct ias_object *obj, char *name, char *value,
 {
 	struct ias_attrib *attrib;
 
-	IRDA_ASSERT(obj != NULL, return;);
+	IRDA_ASSERT(obj, return;);
 	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
-
-	IRDA_ASSERT(name != NULL, return;);
-	IRDA_ASSERT(value != NULL, return;);
+	IRDA_ASSERT(name, return;);
+	IRDA_ASSERT(value, return;);
 
 	attrib = kzalloc(sizeof(*attrib), GFP_ATOMIC);
 	if (!attrib)
@@ -426,7 +422,7 @@ struct ias_value *irias_new_integer_value(int integer)
 	struct ias_value *value;
 
 	value = kzalloc(sizeof(*value), GFP_ATOMIC);
-	if (value == NULL)
+	if (!value)
 		return NULL;
 
 	value->type = IAS_INTEGER;
@@ -449,7 +445,7 @@ struct ias_value *irias_new_string_value(char *string)
 	struct ias_value *value;
 
 	value = kzalloc(sizeof(*value), GFP_ATOMIC);
-	if (value == NULL)
+	if (!value)
 		return NULL;
 
 	value->type = IAS_STRING;
@@ -477,7 +473,7 @@ struct ias_value *irias_new_octseq_value(__u8 *octseq , int len)
 	struct ias_value *value;
 
 	value = kzalloc(sizeof(*value), GFP_ATOMIC);
-	if (value == NULL)
+	if (!value)
 		return NULL;
 
 	value->type = IAS_OCT_SEQ;
@@ -487,7 +483,7 @@ struct ias_value *irias_new_octseq_value(__u8 *octseq , int len)
 	value->len = len;
 
 	value->t.oct_seq = kmemdup(octseq, len, GFP_ATOMIC);
-	if (value->t.oct_seq == NULL){
+	if (!value->t.oct_seq) {
 		kfree(value);
 		return NULL;
 	}
@@ -499,7 +495,7 @@ struct ias_value *irias_new_missing_value(void)
 	struct ias_value *value;
 
 	value = kzalloc(sizeof(*value), GFP_ATOMIC);
-	if (value == NULL)
+	if (!value)
 		return NULL;
 
 	value->type = IAS_MISSING;
@@ -515,7 +511,7 @@ struct ias_value *irias_new_missing_value(void)
  */
 void irias_delete_value(struct ias_value *value)
 {
-	IRDA_ASSERT(value != NULL, return;);
+	IRDA_ASSERT(value, return;);
 
 	switch (value->type) {
 	case IAS_INTEGER: /* Fallthrough */
diff --git a/drivers/staging/irda/net/irlap.c b/drivers/staging/irda/net/irlap.c
index 5dea721f44ac..715cedab2f41 100644
--- a/drivers/staging/irda/net/irlap.c
+++ b/drivers/staging/irda/net/irlap.c
@@ -82,7 +82,7 @@ int __init irlap_init(void)
 
 	/* Allocate master array */
 	irlap = hashbin_new(HB_LOCK);
-	if (irlap == NULL) {
+	if (!irlap) {
 		net_err_ratelimited("%s: can't allocate irlap hashbin!\n",
 				    __func__);
 		return -ENOMEM;
@@ -93,7 +93,7 @@ int __init irlap_init(void)
 
 void irlap_cleanup(void)
 {
-	IRDA_ASSERT(irlap != NULL, return;);
+	IRDA_ASSERT(irlap, return;);
 
 	hashbin_delete(irlap, (FREE_FUNC) __irlap_close);
 }
@@ -111,7 +111,7 @@ struct irlap_cb *irlap_open(struct net_device *dev, struct qos_info *qos,
 
 	/* Initialize the irlap structure. */
 	self = kzalloc(sizeof(*self), GFP_KERNEL);
-	if (self == NULL)
+	if (!self)
 		return NULL;
 
 	self->magic = LAP_MAGIC;
@@ -120,11 +120,10 @@ struct irlap_cb *irlap_open(struct net_device *dev, struct qos_info *qos,
 	self->netdev = dev;
 	self->qos_dev = qos;
 	/* Copy hardware name */
-	if(hw_name != NULL) {
+	if (hw_name)
 		strlcpy(self->hw_name, hw_name, sizeof(self->hw_name));
-	} else {
+	else
 		self->hw_name[0] = '\0';
-	}
 
 	/* FIXME: should we get our own field? */
 	dev->atalk_ptr = self;
@@ -179,7 +178,7 @@ EXPORT_SYMBOL(irlap_open);
  */
 static void __irlap_close(struct irlap_cb *self)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	/* Stop timers */
@@ -209,7 +208,7 @@ void irlap_close(struct irlap_cb *self)
 {
 	struct irlap_cb *lap;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	/* We used to send a LAP_DISC_INDICATION here, but this was
@@ -238,7 +237,7 @@ EXPORT_SYMBOL(irlap_close);
  */
 void irlap_connect_indication(struct irlap_cb *self, struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	irlap_init_qos_capabilities(self, NULL); /* No user QoS! */
@@ -270,7 +269,7 @@ void irlap_connect_request(struct irlap_cb *self, __u32 daddr,
 {
 	pr_debug("%s(), daddr=0x%08x\n", __func__, daddr);
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	self->daddr = daddr;
@@ -295,7 +294,7 @@ void irlap_connect_request(struct irlap_cb *self, __u32 daddr,
  */
 void irlap_connect_confirm(struct irlap_cb *self, struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	irlmp_link_connect_confirm(self->notify.instance, &self->qos_tx, skb);
@@ -327,7 +326,7 @@ void irlap_data_indication(struct irlap_cb *self, struct sk_buff *skb,
 void irlap_data_request(struct irlap_cb *self, struct sk_buff *skb,
 			int unreliable)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	IRDA_ASSERT(skb_headroom(skb) >= (LAP_ADDR_HEADER+LAP_CTRL_HEADER),
@@ -372,7 +371,7 @@ void irlap_data_request(struct irlap_cb *self, struct sk_buff *skb,
 #ifdef CONFIG_IRDA_ULTRA
 void irlap_unitdata_request(struct irlap_cb *self, struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	IRDA_ASSERT(skb_headroom(skb) >= (LAP_ADDR_HEADER+LAP_CTRL_HEADER),
@@ -399,9 +398,9 @@ void irlap_unitdata_request(struct irlap_cb *self, struct sk_buff *skb)
 #ifdef CONFIG_IRDA_ULTRA
 void irlap_unitdata_indication(struct irlap_cb *self, struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	/* Hide LAP header from IrLMP layer */
 	skb_pull(skb, LAP_ADDR_HEADER+LAP_CTRL_HEADER);
@@ -417,7 +416,7 @@ void irlap_unitdata_indication(struct irlap_cb *self, struct sk_buff *skb)
  */
 void irlap_disconnect_request(struct irlap_cb *self)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	/* Don't disconnect until all data frames are successfully sent */
@@ -452,7 +451,7 @@ void irlap_disconnect_indication(struct irlap_cb *self, LAP_REASON reason)
 {
 	pr_debug("%s(), reason=%s\n", __func__, lap_reasons[reason]);
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	/* Flush queues */
@@ -486,9 +485,9 @@ void irlap_discovery_request(struct irlap_cb *self, discovery_t *discovery)
 {
 	struct irlap_info info;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
-	IRDA_ASSERT(discovery != NULL, return;);
+	IRDA_ASSERT(discovery, return;);
 
 	pr_debug("%s(), nslots = %d\n", __func__, discovery->nslots);
 
@@ -512,15 +511,14 @@ void irlap_discovery_request(struct irlap_cb *self, discovery_t *discovery)
 
 	/* Check if last discovery request finished in time, or if
 	 * it was aborted due to the media busy flag. */
-	if (self->discovery_log != NULL) {
+	if (self->discovery_log) {
 		hashbin_delete(self->discovery_log, (FREE_FUNC) kfree);
 		self->discovery_log = NULL;
 	}
 
 	/* All operations will occur at predictable time, no need to lock */
 	self->discovery_log = hashbin_new(HB_NOLOCK);
-
-	if (self->discovery_log == NULL) {
+	if (!self->discovery_log) {
 		net_warn_ratelimited("%s(), Unable to allocate discovery log!\n",
 				     __func__);
 		return;
@@ -546,10 +544,10 @@ void irlap_discovery_request(struct irlap_cb *self, discovery_t *discovery)
  */
 void irlap_discovery_confirm(struct irlap_cb *self, hashbin_t *discovery_log)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
-	IRDA_ASSERT(self->notify.instance != NULL, return;);
+	IRDA_ASSERT(self->notify.instance, return;);
 
 	/*
 	 * Check for successful discovery, since we are then allowed to clear
@@ -577,11 +575,11 @@ void irlap_discovery_confirm(struct irlap_cb *self, hashbin_t *discovery_log)
  */
 void irlap_discovery_indication(struct irlap_cb *self, discovery_t *discovery)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
-	IRDA_ASSERT(discovery != NULL, return;);
+	IRDA_ASSERT(discovery, return;);
 
-	IRDA_ASSERT(self->notify.instance != NULL, return;);
+	IRDA_ASSERT(self->notify.instance, return;);
 
 	/* A device is very likely to connect immediately after it performs
 	 * a successful discovery. This means that in our case, we are much
@@ -621,7 +619,7 @@ void irlap_status_indication(struct irlap_cb *self, int quality_of_link)
  */
 void irlap_reset_indication(struct irlap_cb *self)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	if (self->state == LAP_RESET_WAIT)
@@ -691,8 +689,7 @@ void irlap_update_nr_received(struct irlap_cb *self, int nr)
 		self->va = nr - 1;
 	} else {
 		/* Remove all acknowledged frames in current window */
-		while ((skb_peek(&self->wx_list) != NULL) &&
-		       (((self->va+1) % 8) != nr))
+		while (skb_peek(&self->wx_list) && (((self->va + 1) % 8) != nr))
 		{
 			skb = skb_dequeue(&self->wx_list);
 			dev_kfree_skb(skb);
@@ -762,7 +759,7 @@ int irlap_validate_nr_received(struct irlap_cb *self, int nr)
  */
 void irlap_initiate_connection_state(struct irlap_cb *self)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	/* Next to send and next to receive */
@@ -818,7 +815,7 @@ void irlap_flush_all_queues(struct irlap_cb *self)
 {
 	struct sk_buff* skb;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	/* Free transmission queue */
@@ -845,7 +842,7 @@ static void irlap_change_speed(struct irlap_cb *self, __u32 speed, int now)
 
 	pr_debug("%s(), setting speed to %d\n", __func__, speed);
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	self->speed = speed;
@@ -870,9 +867,9 @@ static void irlap_change_speed(struct irlap_cb *self, __u32 speed, int now)
 static void irlap_init_qos_capabilities(struct irlap_cb *self,
 					struct qos_info *qos_user)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
-	IRDA_ASSERT(self->netdev != NULL, return;);
+	IRDA_ASSERT(self->netdev, return;);
 
 	/* Start out with the maximum QoS support possible */
 	irda_init_max_qos_capabilies(&self->qos_rx);
@@ -916,7 +913,7 @@ static void irlap_init_qos_capabilities(struct irlap_cb *self,
  */
 void irlap_apply_default_connection_parameters(struct irlap_cb *self)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	/* xbofs : Default value in NDM */
@@ -977,7 +974,7 @@ void irlap_apply_default_connection_parameters(struct irlap_cb *self)
  */
 void irlap_apply_connection_parameters(struct irlap_cb *self, int now)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	/* Set the negotiated xbofs value */
@@ -1189,7 +1186,7 @@ static const struct seq_operations irlap_seq_ops = {
 
 static int irlap_seq_open(struct inode *inode, struct file *file)
 {
-	if (irlap == NULL)
+	if (!irlap)
 		return -EINVAL;
 
 	return seq_open_private(file, &irlap_seq_ops,
diff --git a/drivers/staging/irda/net/irlap_event.c b/drivers/staging/irda/net/irlap_event.c
index 0e1b4d79f745..22c44b010976 100644
--- a/drivers/staging/irda/net/irlap_event.c
+++ b/drivers/staging/irda/net/irlap_event.c
@@ -167,7 +167,7 @@ static void irlap_poll_timer_expired(void *data)
 {
 	struct irlap_cb *self = (struct irlap_cb *) data;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	irlap_do_event(self, POLL_TIMER_EXPIRED, NULL, NULL);
@@ -181,7 +181,7 @@ static void irlap_poll_timer_expired(void *data)
  */
 static void irlap_start_poll_timer(struct irlap_cb *self, int timeout)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 #ifdef CONFIG_IRDA_FAST_RR
@@ -327,12 +327,12 @@ static int irlap_state_ndm(struct irlap_cb *self, IRLAP_EVENT event,
 	discovery_t *discovery_rsp;
 	int ret = 0;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	switch (event) {
 	case CONNECT_REQUEST:
-		IRDA_ASSERT(self->netdev != NULL, return -1;);
+		IRDA_ASSERT(self->netdev, return -1;);
 
 		if (self->media_busy) {
 			/* Note : this will never happen, because we test
@@ -370,7 +370,7 @@ static int irlap_state_ndm(struct irlap_cb *self, IRLAP_EVENT event,
 		}
 		break;
 	case DISCOVERY_REQUEST:
-		IRDA_ASSERT(info != NULL, return -1;);
+		IRDA_ASSERT(info, return -1;);
 
 		if (self->media_busy) {
 			pr_debug("%s(), DISCOVERY_REQUEST: media busy!\n",
@@ -396,7 +396,7 @@ static int irlap_state_ndm(struct irlap_cb *self, IRLAP_EVENT event,
 		irlap_next_state(self, LAP_QUERY);
 		break;
 	case RECV_DISCOVERY_XID_CMD:
-		IRDA_ASSERT(info != NULL, return -1;);
+		IRDA_ASSERT(info, return -1;);
 
 		/* Assert that this is not the final slot */
 		if (info->s <= info->S) {
@@ -559,13 +559,13 @@ static int irlap_state_query(struct irlap_cb *self, IRLAP_EVENT event,
 {
 	int ret = 0;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	switch (event) {
 	case RECV_DISCOVERY_XID_RSP:
-		IRDA_ASSERT(info != NULL, return -1;);
-		IRDA_ASSERT(info->discovery != NULL, return -1;);
+		IRDA_ASSERT(info, return -1;);
+		IRDA_ASSERT(info->discovery, return -1;);
 
 		pr_debug("%s(), daddr=%08x\n", __func__,
 			 info->discovery->data.daddr);
@@ -595,7 +595,7 @@ static int irlap_state_query(struct irlap_cb *self, IRLAP_EVENT event,
 		 * Jean II
 		 */
 
-		IRDA_ASSERT(info != NULL, return -1;);
+		IRDA_ASSERT(info, return -1;);
 
 		pr_debug("%s(), Receiving discovery request (s = %d) while performing discovery :-(\n",
 			 __func__, info->s);
@@ -671,7 +671,7 @@ static int irlap_state_reply(struct irlap_cb *self, IRLAP_EVENT event,
 	discovery_t *discovery_rsp;
 	int ret=0;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	switch (event) {
@@ -681,7 +681,7 @@ static int irlap_state_reply(struct irlap_cb *self, IRLAP_EVENT event,
 		irlap_next_state(self, LAP_NDM);
 		break;
 	case RECV_DISCOVERY_XID_CMD:
-		IRDA_ASSERT(info != NULL, return -1;);
+		IRDA_ASSERT(info, return -1;);
 		/* Last frame? */
 		if (info->s == 0xff) {
 			del_timer(&self->query_timer);
@@ -738,14 +738,14 @@ static int irlap_state_conn(struct irlap_cb *self, IRLAP_EVENT event,
 
 	pr_debug("%s(), event=%s\n", __func__, irlap_event[event]);
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	switch (event) {
 	case CONNECT_RESPONSE:
 		skb_pull(skb, sizeof(struct snrm_frame));
 
-		IRDA_ASSERT(self->netdev != NULL, return -1;);
+		IRDA_ASSERT(self->netdev, return -1;);
 
 		irlap_qos_negotiate(self, skb);
 
@@ -830,7 +830,7 @@ static int irlap_state_setup(struct irlap_cb *self, IRLAP_EVENT event,
 {
 	int ret = 0;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	switch (event) {
@@ -859,8 +859,8 @@ static int irlap_state_setup(struct irlap_cb *self, IRLAP_EVENT event,
 	case RECV_SNRM_CMD:
 		pr_debug("%s(), SNRM battle!\n", __func__);
 
-		IRDA_ASSERT(skb != NULL, return 0;);
-		IRDA_ASSERT(info != NULL, return 0;);
+		IRDA_ASSERT(skb, return 0;);
+		IRDA_ASSERT(info, return 0;);
 
 		/*
 		 *  The device with the largest device address wins the battle
@@ -870,7 +870,7 @@ static int irlap_state_setup(struct irlap_cb *self, IRLAP_EVENT event,
 			del_timer(&self->final_timer);
 			irlap_initiate_connection_state(self);
 
-			IRDA_ASSERT(self->netdev != NULL, return -1;);
+			IRDA_ASSERT(self->netdev, return -1;);
 
 			skb_pull(skb, sizeof(struct snrm_frame));
 
@@ -906,7 +906,7 @@ static int irlap_state_setup(struct irlap_cb *self, IRLAP_EVENT event,
 
 		skb_pull(skb, sizeof(struct ua_frame));
 
-		IRDA_ASSERT(self->netdev != NULL, return -1;);
+		IRDA_ASSERT(self->netdev, return -1;);
 
 		irlap_qos_negotiate(self, skb);
 
@@ -1013,9 +1013,9 @@ static int irlap_state_xmit_p(struct irlap_cb *self, IRLAP_EVENT event,
 			 * end of the window and sending a extra RR.
 			 * Note : (skb_next != NULL) <=> (skb_queue_len() > 0)
 			 * Jean II */
-			nextfit = ((skb_next != NULL) &&
-				   ((skb_next->len + skb->len) <=
-				    self->bytes_left));
+			nextfit = skb_next &&
+				  (skb_next->len + skb->len)
+				  <= self->bytes_left;
 
 			/*
 			 * The current packet may not fit ! Because of test
@@ -1134,7 +1134,7 @@ static int irlap_state_pclose(struct irlap_cb *self, IRLAP_EVENT event,
 {
 	int ret = 0;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	switch (event) {
@@ -1215,8 +1215,7 @@ static int irlap_state_nrm_p(struct irlap_cb *self, IRLAP_EVENT event,
 		 */
 		self->fast_RR = FALSE;
 #endif /* CONFIG_IRDA_FAST_RR */
-		IRDA_ASSERT( info != NULL, return -1;);
-
+		IRDA_ASSERT(info, return -1;);
 		ns_status = irlap_validate_ns_received(self, info->ns);
 		nr_status = irlap_validate_nr_received(self, info->nr);
 
@@ -1449,7 +1448,7 @@ static int irlap_state_nrm_p(struct irlap_cb *self, IRLAP_EVENT event,
 			/* Start poll timer */
 			irlap_start_poll_timer(self, self->poll_timeout);
 		} else if (ret == NR_UNEXPECTED) {
-			IRDA_ASSERT(info != NULL, return -1;);
+			IRDA_ASSERT(info, return -1;);
 			/*
 			 *  Unexpected nr!
 			 */
@@ -1477,7 +1476,7 @@ static int irlap_state_nrm_p(struct irlap_cb *self, IRLAP_EVENT event,
 		}
 		break;
 	case RECV_RNR_RSP:
-		IRDA_ASSERT(info != NULL, return -1;);
+		IRDA_ASSERT(info, return -1;);
 
 		/* Stop final timer */
 		del_timer(&self->final_timer);
@@ -1519,7 +1518,7 @@ static int irlap_state_nrm_p(struct irlap_cb *self, IRLAP_EVENT event,
 
 		/* N2 is the disconnect timer. Until we reach it, we retry */
 		if (self->retry_count < self->N2) {
-			if (skb_peek(&self->wx_list) == NULL) {
+			if (!skb_peek(&self->wx_list)) {
 				/* Retry sending the pf bit to the secondary */
 				pr_debug("nrm_p: resending rr");
 				irlap_wait_min_turn_around(self, &self->qos_tx);
@@ -1603,7 +1602,7 @@ static int irlap_state_reset_wait(struct irlap_cb *self, IRLAP_EVENT event,
 
 	pr_debug("%s(), event = %s\n", __func__, irlap_event[event]);
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	switch (event) {
@@ -1650,7 +1649,7 @@ static int irlap_state_reset(struct irlap_cb *self, IRLAP_EVENT event,
 
 	pr_debug("%s(), event = %s\n", __func__, irlap_event[event]);
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	switch (event) {
@@ -1684,7 +1683,7 @@ static int irlap_state_reset(struct irlap_cb *self, IRLAP_EVENT event,
 		if (self->retry_count < 3) {
 			irlap_wait_min_turn_around(self, &self->qos_tx);
 
-			IRDA_ASSERT(self->netdev != NULL, return -1;);
+			IRDA_ASSERT(self->netdev, return -1;);
 			irlap_send_snrm_frame(self, self->qos_dev);
 
 			self->retry_count++; /* Experimental!! */
@@ -1742,7 +1741,7 @@ static int irlap_state_xmit_s(struct irlap_cb *self, IRLAP_EVENT event,
 
 	pr_debug("%s(), event=%s\n", __func__, irlap_event[event]);
 
-	IRDA_ASSERT(self != NULL, return -ENODEV;);
+	IRDA_ASSERT(self, return -ENODEV;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -EBADR;);
 
 	switch (event) {
@@ -1766,9 +1765,9 @@ static int irlap_state_xmit_s(struct irlap_cb *self, IRLAP_EVENT event,
 			 * the current window (with respect to turnaround
 			 * time). - Jean II */
 			skb_next = skb_peek(&self->txq);
-			nextfit = ((skb_next != NULL) &&
-				   ((skb_next->len + skb->len) <=
-				    self->bytes_left));
+			nextfit = skb_next &&
+				  (skb_next->len + skb->len)
+				  <= self->bytes_left;
 
 			/*
 			 *  Test if we have transmitted more bytes over the
@@ -1864,7 +1863,7 @@ static int irlap_state_nrm_s(struct irlap_cb *self, IRLAP_EVENT event,
 
 	pr_debug("%s(), event=%s\n", __func__, irlap_event[event]);
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	switch (event) {
@@ -2215,7 +2214,7 @@ static int irlap_state_nrm_s(struct irlap_cb *self, IRLAP_EVENT event,
 static int irlap_state_sclose(struct irlap_cb *self, IRLAP_EVENT event,
 			      struct sk_buff *skb, struct irlap_info *info)
 {
-	IRDA_ASSERT(self != NULL, return -ENODEV;);
+	IRDA_ASSERT(self, return -ENODEV;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -EBADR;);
 
 	switch (event) {
@@ -2262,7 +2261,7 @@ static int irlap_state_sclose(struct irlap_cb *self, IRLAP_EVENT event,
 		/* IrLAP-1.1 p.82: in SCLOSE, basically any received frame
 		 * with pf=1 shall restart the wd-timer and resend the rd:rsp
 		 */
-		if (info != NULL  &&  info->pf) {
+		if (info && info->pf) {
 			del_timer(&self->wd_timer);
 			irlap_wait_min_turn_around(self, &self->qos_tx);
 			irlap_send_rd_frame(self);
@@ -2287,7 +2286,7 @@ static int irlap_state_reset_check( struct irlap_cb *self, IRLAP_EVENT event,
 
 	pr_debug("%s(), event=%s\n", __func__, irlap_event[event]);
 
-	IRDA_ASSERT(self != NULL, return -ENODEV;);
+	IRDA_ASSERT(self, return -ENODEV;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -EBADR;);
 
 	switch (event) {
diff --git a/drivers/staging/irda/net/irlap_frame.c b/drivers/staging/irda/net/irlap_frame.c
index d4d88a5d2976..94972db87951 100644
--- a/drivers/staging/irda/net/irlap_frame.c
+++ b/drivers/staging/irda/net/irlap_frame.c
@@ -123,7 +123,7 @@ void irlap_send_snrm_frame(struct irlap_cb *self, struct qos_info *qos)
 	struct snrm_frame *frame;
 	int ret;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	/* Allocate frame */
@@ -218,7 +218,7 @@ void irlap_send_ua_response_frame(struct irlap_cb *self, struct qos_info *qos)
 
 	pr_debug("%s() <%ld>\n", __func__, jiffies);
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	/* Allocate frame */
@@ -261,7 +261,7 @@ void irlap_send_dm_frame( struct irlap_cb *self)
 	struct sk_buff *tx_skb = NULL;
 	struct dm_frame *frame;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	tx_skb = alloc_skb(sizeof(struct dm_frame), GFP_ATOMIC);
@@ -291,7 +291,7 @@ void irlap_send_disc_frame(struct irlap_cb *self)
 	struct sk_buff *tx_skb = NULL;
 	struct disc_frame *frame;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	tx_skb = alloc_skb(sizeof(struct disc_frame), GFP_ATOMIC);
@@ -323,9 +323,9 @@ void irlap_send_discovery_xid_frame(struct irlap_cb *self, int S, __u8 s,
 	pr_debug("%s(), s=%d, S=%d, command=%d\n", __func__,
 		 s, S, command);
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
-	IRDA_ASSERT(discovery != NULL, return;);
+	IRDA_ASSERT(discovery, return;);
 
 	tx_skb = alloc_skb(sizeof(struct xid_frame) + IRLAP_DISCOVERY_INFO_LEN,
 			   GFP_ATOMIC);
@@ -412,7 +412,7 @@ static void irlap_recv_discovery_xid_rsp(struct irlap_cb *self,
 	__u8 *discovery_info;
 	char *text;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	if (!pskb_may_pull(skb, sizeof(struct xid_frame))) {
@@ -528,8 +528,7 @@ static void irlap_recv_discovery_xid_cmd(struct irlap_cb *self,
 	 */
 	if (info->s == 0xff) {
 		/* Check if things are sane at this point... */
-		if((discovery_info == NULL) ||
-		   !pskb_may_pull(skb, 3)) {
+		if (!discovery_info || !pskb_may_pull(skb, 3)) {
 			net_err_ratelimited("%s: discovery frame too short!\n",
 					    __func__);
 			return;
@@ -732,9 +731,8 @@ void irlap_send_data_primary(struct irlap_cb *self, struct sk_buff *skb)
 
 		/* Copy buffer */
 		tx_skb = skb_clone(skb, GFP_ATOMIC);
-		if (tx_skb == NULL) {
+		if (!tx_skb)
 			return;
-		}
 
 		self->vs = (self->vs + 1) % 8;
 		self->ack_required = FALSE;
@@ -778,9 +776,8 @@ void irlap_send_data_primary_poll(struct irlap_cb *self, struct sk_buff *skb)
 
 		/* Copy buffer */
 		tx_skb = skb_clone(skb, GFP_ATOMIC);
-		if (tx_skb == NULL) {
+		if (!tx_skb)
 			return;
-		}
 
 		/*
 		 *  Set poll bit if necessary. We do this to the copied
@@ -867,9 +864,9 @@ void irlap_send_data_secondary_final(struct irlap_cb *self,
 {
 	struct sk_buff *tx_skb = NULL;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	/* Is this reliable or unreliable data? */
 	if (skb->data[1] == I_FRAME) {
@@ -888,9 +885,8 @@ void irlap_send_data_secondary_final(struct irlap_cb *self,
 		skb_queue_tail(&self->wx_list, skb);
 
 		tx_skb = skb_clone(skb, GFP_ATOMIC);
-		if (tx_skb == NULL) {
+		if (!tx_skb)
 			return;
-		}
 
 		tx_skb->data[1] |= PF_BIT;
 
@@ -945,9 +941,8 @@ void irlap_send_data_secondary(struct irlap_cb *self, struct sk_buff *skb)
 		skb_queue_tail(&self->wx_list, skb);
 
 		tx_skb = skb_clone(skb, GFP_ATOMIC);
-		if (tx_skb == NULL) {
+		if (!tx_skb)
 			return;
-		}
 
 		self->vs = (self->vs + 1) % 8;
 		self->ack_required = FALSE;
@@ -972,7 +967,7 @@ void irlap_resend_rejected_frames(struct irlap_cb *self, int command)
 	struct sk_buff *tx_skb;
 	struct sk_buff *skb;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	/*  Resend unacknowledged frame(s) */
@@ -1011,7 +1006,7 @@ void irlap_resend_rejected_frames(struct irlap_cb *self, int command)
 		pr_debug("%s(), sending additional frames!\n", __func__);
 		if (self->window > 0) {
 			skb = skb_dequeue( &self->txq);
-			IRDA_ASSERT(skb != NULL, return;);
+			IRDA_ASSERT(skb, return;);
 
 			/*
 			 *  If send window > 1 then send frame with pf
@@ -1034,12 +1029,12 @@ void irlap_resend_rejected_frame(struct irlap_cb *self, int command)
 	struct sk_buff *tx_skb;
 	struct sk_buff *skb;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	/*  Resend unacknowledged frame(s) */
 	skb = skb_peek(&self->wx_list);
-	if (skb != NULL) {
+	if (skb) {
 		irlap_wait_min_turn_around(self, &self->qos_tx);
 
 		/* We copy the skb to be retransmitted since we will have to
@@ -1071,9 +1066,9 @@ void irlap_resend_rejected_frame(struct irlap_cb *self, int command)
 void irlap_send_ui_frame(struct irlap_cb *self, struct sk_buff *skb,
 			 __u8 caddr, int command)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	/* Insert connection address */
 	skb->data[0] = caddr | ((command) ? CMD_FRAME : 0);
@@ -1146,10 +1141,10 @@ static void irlap_recv_frmr_frame(struct irlap_cb *self, struct sk_buff *skb,
 	__u8 *frame;
 	int w, x, y, z;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
-	IRDA_ASSERT(info != NULL, return;);
+	IRDA_ASSERT(skb, return;);
+	IRDA_ASSERT(info, return;);
 
 	if (!pskb_may_pull(skb, 4)) {
 		net_err_ratelimited("%s: frame too short!\n", __func__);
diff --git a/drivers/staging/irda/net/irlmp.c b/drivers/staging/irda/net/irlmp.c
index f075735e4b9b..318660fbc094 100644
--- a/drivers/staging/irda/net/irlmp.c
+++ b/drivers/staging/irda/net/irlmp.c
@@ -85,7 +85,7 @@ int __init irlmp_init(void)
 {
 	/* Initialize the irlmp structure. */
 	irlmp = kzalloc( sizeof(struct irlmp_cb), GFP_KERNEL);
-	if (irlmp == NULL)
+	if (!irlmp)
 		return -ENOMEM;
 
 	irlmp->magic = LMP_MAGIC;
@@ -95,14 +95,12 @@ int __init irlmp_init(void)
 	irlmp->links = hashbin_new(HB_LOCK);
 	irlmp->unconnected_lsaps = hashbin_new(HB_LOCK);
 	irlmp->cachelog = hashbin_new(HB_NOLOCK);
-
-	if ((irlmp->clients == NULL) ||
-	    (irlmp->services == NULL) ||
-	    (irlmp->links == NULL) ||
-	    (irlmp->unconnected_lsaps == NULL) ||
-	    (irlmp->cachelog == NULL)) {
+	if (!irlmp->clients ||
+	    !irlmp->services ||
+	    !irlmp->links ||
+	    !irlmp->unconnected_lsaps ||
+	    !irlmp->cachelog)
 		return -ENOMEM;
-	}
 
 	spin_lock_init(&irlmp->cachelog->hb_spinlock);
 
@@ -128,7 +126,7 @@ int __init irlmp_init(void)
 void irlmp_cleanup(void)
 {
 	/* Check for main structure */
-	IRDA_ASSERT(irlmp != NULL, return;);
+	IRDA_ASSERT(irlmp, return;);
 	IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return;);
 
 	del_timer(&irlmp->discovery_timer);
@@ -154,10 +152,10 @@ struct lsap_cb *irlmp_open_lsap(__u8 slsap_sel, notify_t *notify, __u8 pid)
 {
 	struct lsap_cb *self;
 
-	IRDA_ASSERT(notify != NULL, return NULL;);
-	IRDA_ASSERT(irlmp != NULL, return NULL;);
+	IRDA_ASSERT(notify, return NULL;);
+	IRDA_ASSERT(irlmp, return NULL;);
 	IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return NULL;);
-	IRDA_ASSERT(notify->instance != NULL, return NULL;);
+	IRDA_ASSERT(notify->instance, return NULL;);
 
 	/*  Does the client care which Source LSAP selector it gets?  */
 	if (slsap_sel == LSAP_ANY) {
@@ -169,7 +167,7 @@ struct lsap_cb *irlmp_open_lsap(__u8 slsap_sel, notify_t *notify, __u8 pid)
 
 	/* Allocate new instance of a LSAP connection */
 	self = kzalloc(sizeof(*self), GFP_ATOMIC);
-	if (self == NULL)
+	if (!self)
 		return NULL;
 
 	self->magic = LMP_LSAP_MAGIC;
@@ -206,7 +204,7 @@ EXPORT_SYMBOL(irlmp_open_lsap);
  */
 static void __irlmp_close_lsap(struct lsap_cb *self)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 
 	/*
@@ -232,7 +230,7 @@ void irlmp_close_lsap(struct lsap_cb *self)
 	struct lap_cb *lap;
 	struct lsap_cb *lsap = NULL;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 
 	/*
@@ -283,15 +281,15 @@ void irlmp_register_link(struct irlap_cb *irlap, __u32 saddr, notify_t *notify)
 {
 	struct lap_cb *lap;
 
-	IRDA_ASSERT(irlmp != NULL, return;);
+	IRDA_ASSERT(irlmp, return;);
 	IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return;);
-	IRDA_ASSERT(notify != NULL, return;);
+	IRDA_ASSERT(notify, return;);
 
 	/*
 	 *  Allocate new instance of a LSAP connection
 	 */
 	lap = kzalloc(sizeof(*lap), GFP_KERNEL);
-	if (lap == NULL)
+	if (!lap)
 		return;
 
 	lap->irlap = irlap;
@@ -302,7 +300,7 @@ void irlmp_register_link(struct irlap_cb *irlap, __u32 saddr, notify_t *notify)
 	lap->cache.valid = FALSE;
 #endif
 	lap->lsaps = hashbin_new(HB_LOCK);
-	if (lap->lsaps == NULL) {
+	if (!lap->lsaps) {
 		net_warn_ratelimited("%s(), unable to kmalloc lsaps\n",
 				     __func__);
 		kfree(lap);
@@ -374,7 +372,7 @@ int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel,
 	struct lsap_cb *lsap;
 	int ret;
 
-	IRDA_ASSERT(self != NULL, return -EBADR;);
+	IRDA_ASSERT(self, return -EBADR;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -EBADR;);
 
 	pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x, saddr=%08x, daddr=%08x\n",
@@ -392,7 +390,7 @@ int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel,
 	}
 
 	/* Any userdata? */
-	if (tx_skb == NULL) {
+	if (!tx_skb) {
 		tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
 		if (!tx_skb)
 			return -ENOMEM;
@@ -434,7 +432,7 @@ int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel,
 		spin_unlock_irqrestore(&irlmp->cachelog->hb_spinlock, flags);
 	}
 	lap = hashbin_lock_find(irlmp->links, saddr, NULL);
-	if (lap == NULL) {
+	if (!lap) {
 		pr_debug("%s(), Unable to find a usable link!\n", __func__);
 		ret = -EHOSTUNREACH;
 		goto err;
@@ -471,9 +469,9 @@ int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel,
 	 */
 	lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self, NULL);
 
-	IRDA_ASSERT(lsap != NULL, return -1;);
+	IRDA_ASSERT(lsap, return -1;);
 	IRDA_ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
-	IRDA_ASSERT(lsap->lap != NULL, return -1;);
+	IRDA_ASSERT(lsap->lap, return -1;);
 	IRDA_ASSERT(lsap->lap->magic == LMP_LAP_MAGIC, return -1;);
 
 	hashbin_insert(self->lap->lsaps, (irda_queue_t *) self, (long) self,
@@ -514,10 +512,10 @@ void irlmp_connect_indication(struct lsap_cb *self, struct sk_buff *skb)
 	int lap_header_size;
 	int max_header_size;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
-	IRDA_ASSERT(self->lap != NULL, return;);
+	IRDA_ASSERT(skb, return;);
+	IRDA_ASSERT(self->lap, return;);
 
 	pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x\n",
 		 __func__, self->slsap_sel, self->dlsap_sel);
@@ -553,9 +551,9 @@ void irlmp_connect_indication(struct lsap_cb *self, struct sk_buff *skb)
  */
 int irlmp_connect_response(struct lsap_cb *self, struct sk_buff *userdata)
 {
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
-	IRDA_ASSERT(userdata != NULL, return -1;);
+	IRDA_ASSERT(userdata, return -1;);
 
 	/* We set the connected bit and move the lsap to the connected list
 	 * in the state machine itself. Jean II */
@@ -587,10 +585,10 @@ void irlmp_connect_confirm(struct lsap_cb *self, struct sk_buff *skb)
 	int lap_header_size;
 	int max_seg_size;
 
-	IRDA_ASSERT(skb != NULL, return;);
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(skb, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
-	IRDA_ASSERT(self->lap != NULL, return;);
+	IRDA_ASSERT(self->lap, return;);
 
 	self->qos = *self->lap->qos;
 
@@ -630,7 +628,7 @@ struct lsap_cb *irlmp_dup(struct lsap_cb *orig, void *instance)
 	/* Only allowed to duplicate unconnected LSAP's, and only LSAPs
 	 * that have received a connect indication. Jean II */
 	if ((!hashbin_find(irlmp->unconnected_lsaps, (long) orig, NULL)) ||
-	    (orig->lap == NULL)) {
+	    (!orig->lap)) {
 		pr_debug("%s(), invalid LSAP (wrong state)\n",
 			 __func__);
 		spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock,
@@ -677,9 +675,9 @@ int irlmp_disconnect_request(struct lsap_cb *self, struct sk_buff *userdata)
 {
 	struct lsap_cb *lsap;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
-	IRDA_ASSERT(userdata != NULL, return -1;);
+	IRDA_ASSERT(userdata, return -1;);
 
 	/* Already disconnected ?
 	 * There is a race condition between irlmp_disconnect_indication()
@@ -706,16 +704,16 @@ int irlmp_disconnect_request(struct lsap_cb *self, struct sk_buff *userdata)
 	 *  Remove LSAP from list of connected LSAPs for the particular link
 	 *  and insert it into the list of unconnected LSAPs
 	 */
-	IRDA_ASSERT(self->lap != NULL, return -1;);
+	IRDA_ASSERT(self->lap, return -1;);
 	IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
-	IRDA_ASSERT(self->lap->lsaps != NULL, return -1;);
+	IRDA_ASSERT(self->lap->lsaps, return -1;);
 
 	lsap = hashbin_remove(self->lap->lsaps, (long) self, NULL);
 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
 	self->lap->cache.valid = FALSE;
 #endif
 
-	IRDA_ASSERT(lsap != NULL, return -1;);
+	IRDA_ASSERT(lsap, return -1;);
 	IRDA_ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
 	IRDA_ASSERT(lsap == self, return -1;);
 
@@ -742,7 +740,7 @@ void irlmp_disconnect_indication(struct lsap_cb *self, LM_REASON reason,
 
 	pr_debug("%s(), reason=%s [%d]\n", __func__,
 		 irlmp_reason_str(reason), reason);
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 
 	pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x\n",
@@ -760,15 +758,15 @@ void irlmp_disconnect_indication(struct lsap_cb *self, LM_REASON reason,
 	/*
 	 *  Remove association between this LSAP and the link it used
 	 */
-	IRDA_ASSERT(self->lap != NULL, return;);
-	IRDA_ASSERT(self->lap->lsaps != NULL, return;);
+	IRDA_ASSERT(self->lap, return;);
+	IRDA_ASSERT(self->lap->lsaps, return;);
 
 	lsap = hashbin_remove(self->lap->lsaps, (long) self, NULL);
 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
 	self->lap->cache.valid = FALSE;
 #endif
 
-	IRDA_ASSERT(lsap != NULL, return;);
+	IRDA_ASSERT(lsap, return;);
 	IRDA_ASSERT(lsap == self, return;);
 	hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) lsap,
 		       (long) lsap, NULL);
@@ -812,7 +810,7 @@ void irlmp_do_expiry(void)
 	 * to work properly. - Jean II
 	 */
 	lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
-	while (lap != NULL) {
+	while (lap) {
 		IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
 
 		if (lap->lap_state == LAP_STANDBY) {
@@ -862,7 +860,7 @@ void irlmp_do_discovery(int nslots)
 	 * Try to send discovery packets on all links
 	 */
 	lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
-	while (lap != NULL) {
+	while (lap) {
 		IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
 
 		if (lap->lap_state == LAP_STANDBY) {
@@ -983,7 +981,7 @@ irlmp_notify_client(irlmp_client_t *client,
 					     client->hint_mask.word,
 					     (mode == DISCOVERY_LOG));
 	/* Check if the we got some results */
-	if (discoveries == NULL)
+	if (!discoveries)
 		return;	/* No nodes discovered */
 
 	/* Pass all entries to the listener */
@@ -1006,7 +1004,7 @@ void irlmp_discovery_confirm(hashbin_t *log, DISCOVERY_MODE mode)
 	irlmp_client_t *client;
 	irlmp_client_t *client_next;
 
-	IRDA_ASSERT(log != NULL, return;);
+	IRDA_ASSERT(log, return;);
 
 	if (!(HASHBIN_GET_SIZE(log)))
 		return;
@@ -1039,7 +1037,7 @@ void irlmp_discovery_expiry(discinfo_t *expiries, int number)
 	irlmp_client_t *client_next;
 	int		i;
 
-	IRDA_ASSERT(expiries != NULL, return;);
+	IRDA_ASSERT(expiries, return;);
 
 	/* For each client - notify callback may touch client list */
 	client = (irlmp_client_t *) hashbin_get_first(irlmp->clients);
@@ -1071,7 +1069,7 @@ void irlmp_discovery_expiry(discinfo_t *expiries, int number)
  */
 discovery_t *irlmp_get_discovery_response(void)
 {
-	IRDA_ASSERT(irlmp != NULL, return NULL;);
+	IRDA_ASSERT(irlmp, return NULL;);
 
 	put_unaligned(irlmp->hints.word, (__u16 *)irlmp->discovery_rsp.data.hints);
 
@@ -1106,7 +1104,7 @@ int irlmp_data_request(struct lsap_cb *self, struct sk_buff *userdata)
 {
 	int	ret;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
 
 	/* Make room for MUX header */
@@ -1147,7 +1145,7 @@ int irlmp_udata_request(struct lsap_cb *self, struct sk_buff *userdata)
 {
 	int	ret;
 
-	IRDA_ASSERT(userdata != NULL, return -1;);
+	IRDA_ASSERT(userdata, return -1;);
 
 	/* Make room for MUX header */
 	IRDA_ASSERT(skb_headroom(userdata) >= LMP_HEADER, return -1;);
@@ -1169,9 +1167,9 @@ int irlmp_udata_request(struct lsap_cb *self, struct sk_buff *userdata)
  */
 void irlmp_udata_indication(struct lsap_cb *self, struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	/* Hide LMP header from layer above */
 	skb_pull(skb, LMP_HEADER);
@@ -1194,7 +1192,7 @@ int irlmp_connless_data_request(struct lsap_cb *self, struct sk_buff *userdata,
 	struct sk_buff *clone_skb;
 	struct lap_cb *lap;
 
-	IRDA_ASSERT(userdata != NULL, return -1;);
+	IRDA_ASSERT(userdata, return -1;);
 
 	/* Make room for MUX and PID header */
 	IRDA_ASSERT(skb_headroom(userdata) >= LMP_HEADER+LMP_PID_HEADER,
@@ -1202,10 +1200,7 @@ int irlmp_connless_data_request(struct lsap_cb *self, struct sk_buff *userdata,
 
 	/* Insert protocol identifier */
 	skb_push(userdata, LMP_PID_HEADER);
-	if(self != NULL)
-	  userdata->data[0] = self->pid;
-	else
-	  userdata->data[0] = pid;
+	userdata->data[0] = self ? self->pid : pid;
 
 	/* Connectionless sockets must use 0x70 */
 	skb_push(userdata, LMP_HEADER);
@@ -1213,7 +1208,7 @@ int irlmp_connless_data_request(struct lsap_cb *self, struct sk_buff *userdata,
 
 	/* Try to send Connectionless  packets out on all links */
 	lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
-	while (lap != NULL) {
+	while (lap) {
 		IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return -1;);
 
 		clone_skb = skb_clone(userdata, GFP_ATOMIC);
@@ -1243,9 +1238,9 @@ int irlmp_connless_data_request(struct lsap_cb *self, struct sk_buff *userdata,
 #ifdef CONFIG_IRDA_ULTRA
 void irlmp_connless_data_indication(struct lsap_cb *self, struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	/* Hide LMP and PID header from layer above */
 	skb_pull(skb, LMP_HEADER+LMP_PID_HEADER);
@@ -1280,7 +1275,7 @@ void irlmp_status_indication(struct lap_cb *self,
 		/*
 		 *  Inform service user if he has requested it
 		 */
-		if (curr->notify.status_indication != NULL)
+		if (curr->notify.status_indication)
 			curr->notify.status_indication(curr->notify.instance,
 						       link, lock);
 		else
@@ -1323,20 +1318,20 @@ void irlmp_flow_indication(struct lap_cb *self, LOCAL_FLOW flow)
 		/* Try to find the next lsap we should poll. */
 		next = self->flow_next;
 		/* If we have no lsap, restart from first one */
-		if(next == NULL)
+		if (!next)
 			next = (struct lsap_cb *) hashbin_get_first(self->lsaps);
 		/* Verify current one and find the next one */
 		curr = hashbin_find_next(self->lsaps, (long) next, NULL,
 					 (void *) &self->flow_next);
 		/* Uh-oh... Paranoia */
-		if(curr == NULL)
+		if (!curr)
 			break;
 		pr_debug("%s() : curr is %p, next was %p and is now %p, still %d to go - queue len = %d\n",
 			 __func__, curr, next, self->flow_next, lsap_todo,
 			 IRLAP_GET_TX_QUEUE_LEN(self->irlap));
 
 		/* Inform lsap user that it can send one more packet. */
-		if (curr->notify.flow_indication != NULL)
+		if (curr->notify.flow_indication)
 			curr->notify.flow_indication(curr->notify.instance,
 						     curr, flow);
 		else
@@ -1534,7 +1529,7 @@ void *irlmp_register_client(__u16 hint_mask, DISCOVERY_CALLBACK1 disco_clb,
 {
 	irlmp_client_t *client;
 
-	IRDA_ASSERT(irlmp != NULL, return NULL;);
+	IRDA_ASSERT(irlmp, return NULL;);
 
 	/* Make a new registration */
 	client = kmalloc(sizeof(*client), GFP_ATOMIC);
@@ -1631,7 +1626,7 @@ static int irlmp_slsap_inuse(__u8 slsap_sel)
 	struct lap_cb *lap;
 	unsigned long flags;
 
-	IRDA_ASSERT(irlmp != NULL, return TRUE;);
+	IRDA_ASSERT(irlmp, return TRUE;);
 	IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return TRUE;);
 	IRDA_ASSERT(slsap_sel != LSAP_ANY, return TRUE;);
 
@@ -1653,7 +1648,7 @@ static int irlmp_slsap_inuse(__u8 slsap_sel)
 	spin_lock_irqsave_nested(&irlmp->links->hb_spinlock, flags,
 			SINGLE_DEPTH_NESTING);
 	lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
-	while (lap != NULL) {
+	while (lap) {
 		IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, goto errlap;);
 
 		/* Careful for priority inversions here !
@@ -1663,7 +1658,7 @@ static int irlmp_slsap_inuse(__u8 slsap_sel)
 
 		/* For this IrLAP, check all the LSAPs */
 		self = (struct lsap_cb *) hashbin_get_first(lap->lsaps);
-		while (self != NULL) {
+		while (self) {
 			IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC,
 				    goto errlsap;);
 
@@ -1690,7 +1685,7 @@ static int irlmp_slsap_inuse(__u8 slsap_sel)
 	spin_lock_irqsave(&irlmp->unconnected_lsaps->hb_spinlock, flags);
 
 	self = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps);
-	while (self != NULL) {
+	while (self) {
 		IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, goto erruncon;);
 		if ((self->slsap_sel == slsap_sel)) {
 			pr_debug("Source LSAP selector=%02x in use (unconnected)\n",
@@ -1730,7 +1725,7 @@ static __u8 irlmp_find_free_slsap(void)
 	__u8 lsap_sel;
 	int wrapped = 0;
 
-	IRDA_ASSERT(irlmp != NULL, return -1;);
+	IRDA_ASSERT(irlmp, return -1;);
 	IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return -1;);
 
 	/* Most users don't really care which LSAPs they are given,
@@ -1836,7 +1831,7 @@ static void *irlmp_seq_hb_idx(struct irlmp_iter_state *iter, loff_t *off)
 
 	spin_lock_irq(&iter->hashbin->hb_spinlock);
 	for (element = hashbin_get_first(iter->hashbin);
-	     element != NULL;
+	     element;
 	     element = hashbin_get_next(iter->hashbin)) {
 		if (!off || (*off)-- == 0) {
 			/* NB: hashbin left locked */
@@ -1889,8 +1884,7 @@ static void *irlmp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 	}
 
 	v = hashbin_get_next(iter->hashbin);
-
-	if (v == NULL) {			/* no more in this hash bin */
+	if (!v) {			/* no more in this hash bin */
 		spin_unlock_irq(&iter->hashbin->hb_spinlock);
 
 		if (iter->hashbin == irlmp->unconnected_lsaps)
@@ -1947,7 +1941,7 @@ static int irlmp_seq_show(struct seq_file *seq, void *v)
 
 		seq_printf(seq, "\n  Connected LSAPs:\n");
 		for (self = (struct lsap_cb *) hashbin_get_first(lap->lsaps);
-		     self != NULL;
+		     self;
 		     self = (struct lsap_cb *)hashbin_get_next(lap->lsaps)) {
 			IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC,
 				    goto outloop;);
@@ -1978,7 +1972,7 @@ static const struct seq_operations irlmp_seq_ops = {
 
 static int irlmp_seq_open(struct inode *inode, struct file *file)
 {
-	IRDA_ASSERT(irlmp != NULL, return -EINVAL;);
+	IRDA_ASSERT(irlmp, return -EINVAL;);
 
 	return seq_open_private(file, &irlmp_seq_ops,
 			sizeof(struct irlmp_iter_state));
diff --git a/drivers/staging/irda/net/irlmp_event.c b/drivers/staging/irda/net/irlmp_event.c
index e306cf2c1e04..5856c8ed7dea 100644
--- a/drivers/staging/irda/net/irlmp_event.c
+++ b/drivers/staging/irda/net/irlmp_event.c
@@ -137,7 +137,7 @@ static inline void irlmp_next_lsap_state(struct lsap_cb *self,
 int irlmp_do_lsap_event(struct lsap_cb *self, IRLMP_EVENT event,
 			struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
 
 	pr_debug("%s(), EVENT = %s, STATE = %s\n",
@@ -155,7 +155,7 @@ int irlmp_do_lsap_event(struct lsap_cb *self, IRLMP_EVENT event,
 void irlmp_do_lap_event(struct lap_cb *self, IRLMP_EVENT event,
 			struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
 
 	pr_debug("%s(), EVENT = %s, STATE = %s\n", __func__,
@@ -180,7 +180,7 @@ void irlmp_watchdog_timer_expired(void *data)
 {
 	struct lsap_cb *self = (struct lsap_cb *) data;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 
 	irlmp_do_lsap_event(self, LM_WATCHDOG_TIMEOUT, NULL);
@@ -190,7 +190,7 @@ void irlmp_idle_timer_expired(void *data)
 {
 	struct lap_cb *self = (struct lap_cb *) data;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
 
 	irlmp_do_lap_event(self, LM_LAP_IDLE_TIMEOUT, NULL);
@@ -248,7 +248,7 @@ irlmp_do_all_lsap_event(hashbin_t *	lsap_hashbin,
 static void irlmp_state_standby(struct lap_cb *self, IRLMP_EVENT event,
 				struct sk_buff *skb)
 {
-	IRDA_ASSERT(self->irlap != NULL, return;);
+	IRDA_ASSERT(self->irlap, return;);
 
 	switch (event) {
 	case LM_LAP_DISCOVERY_REQUEST:
@@ -479,7 +479,7 @@ static int irlmp_state_disconnected(struct lsap_cb *self, IRLMP_EVENT event,
 {
 	int ret = 0;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
 
 	switch (event) {
@@ -557,7 +557,7 @@ static int irlmp_state_connect(struct lsap_cb *self, IRLMP_EVENT event,
 	struct lsap_cb *lsap;
 	int ret = 0;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
 
 	switch (event) {
@@ -570,8 +570,8 @@ static int irlmp_state_connect(struct lsap_cb *self, IRLMP_EVENT event,
 				      NULL);
 
 		IRDA_ASSERT(lsap == self, return -1;);
-		IRDA_ASSERT(self->lap != NULL, return -1;);
-		IRDA_ASSERT(self->lap->lsaps != NULL, return -1;);
+		IRDA_ASSERT(self->lap, return -1;);
+		IRDA_ASSERT(self->lap->lsaps, return -1;);
 
 		hashbin_insert(self->lap->lsaps, (irda_queue_t *) self,
 			       (long) self, NULL);
@@ -617,7 +617,7 @@ static int irlmp_state_connect_pend(struct lsap_cb *self, IRLMP_EVENT event,
 	struct sk_buff *tx_skb;
 	int ret = 0;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
 
 	switch (event) {
@@ -681,9 +681,9 @@ static int irlmp_state_dtr(struct lsap_cb *self, IRLMP_EVENT event,
 	LM_REASON reason;
 	int ret = 0;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
-	IRDA_ASSERT(self->lap != NULL, return -1;);
+	IRDA_ASSERT(self->lap, return -1;);
 
 	switch (event) {
 	case LM_DATA_REQUEST: /* Optimize for the common case */
@@ -694,7 +694,7 @@ static int irlmp_state_dtr(struct lsap_cb *self, IRLMP_EVENT event,
 		irlmp_data_indication(self, skb);
 		break;
 	case LM_UDATA_REQUEST:
-		IRDA_ASSERT(skb != NULL, return -1;);
+		IRDA_ASSERT(skb, return -1;);
 		irlmp_send_data_pdu(self->lap, self->dlsap_sel,
 				    self->slsap_sel, TRUE, skb);
 		break;
@@ -737,10 +737,9 @@ static int irlmp_state_dtr(struct lsap_cb *self, IRLMP_EVENT event,
 	case LM_DISCONNECT_INDICATION:
 		irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
 
-		IRDA_ASSERT(self->lap != NULL, return -1;);
+		IRDA_ASSERT(self->lap, return -1;);
 		IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
-
-		IRDA_ASSERT(skb != NULL, return -1;);
+		IRDA_ASSERT(skb, return -1;);
 		IRDA_ASSERT(skb->len > 3, return -1;);
 		reason = skb->data[3];
 
@@ -771,7 +770,7 @@ static int irlmp_state_setup(struct lsap_cb *self, IRLMP_EVENT event,
 	LM_REASON reason;
 	int ret = 0;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
 
 	switch (event) {
@@ -785,10 +784,9 @@ static int irlmp_state_setup(struct lsap_cb *self, IRLMP_EVENT event,
 	case LM_DISCONNECT_INDICATION:
 		irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
 
-		IRDA_ASSERT(self->lap != NULL, return -1;);
+		IRDA_ASSERT(self->lap, return -1;);
 		IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
-
-		IRDA_ASSERT(skb != NULL, return -1;);
+		IRDA_ASSERT(skb, return -1;);
 		IRDA_ASSERT(skb->len > 3, return -1;);
 		reason = skb->data[3];
 
@@ -803,7 +801,7 @@ static int irlmp_state_setup(struct lsap_cb *self, IRLMP_EVENT event,
 
 		del_timer(&self->watchdog_timer);
 
-		IRDA_ASSERT(self->lap != NULL, return -1;);
+		IRDA_ASSERT(self->lap, return -1;);
 		IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
 
 		reason = irlmp_convert_lap_reason(self->lap->reason);
@@ -813,7 +811,7 @@ static int irlmp_state_setup(struct lsap_cb *self, IRLMP_EVENT event,
 	case LM_WATCHDOG_TIMEOUT:
 		pr_debug("%s() WATCHDOG_TIMEOUT!\n", __func__);
 
-		IRDA_ASSERT(self->lap != NULL, return -1;);
+		IRDA_ASSERT(self->lap, return -1;);
 		irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL);
 		irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
 
@@ -842,12 +840,12 @@ static int irlmp_state_setup_pend(struct lsap_cb *self, IRLMP_EVENT event,
 	LM_REASON reason;
 	int ret = 0;
 
-	IRDA_ASSERT(self != NULL, return -1;);
-	IRDA_ASSERT(irlmp != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
+	IRDA_ASSERT(irlmp, return -1;);
 
 	switch (event) {
 	case LM_LAP_CONNECT_CONFIRM:
-		IRDA_ASSERT(self->conn_skb != NULL, return -1;);
+		IRDA_ASSERT(self->conn_skb, return -1;);
 
 		tx_skb = self->conn_skb;
 		self->conn_skb = NULL;
@@ -862,7 +860,7 @@ static int irlmp_state_setup_pend(struct lsap_cb *self, IRLMP_EVENT event,
 	case LM_WATCHDOG_TIMEOUT:
 		pr_debug("%s() : WATCHDOG_TIMEOUT !\n",  __func__);
 
-		IRDA_ASSERT(self->lap != NULL, return -1;);
+		IRDA_ASSERT(self->lap, return -1;);
 		irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL);
 		irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
 
diff --git a/drivers/staging/irda/net/irlmp_frame.c b/drivers/staging/irda/net/irlmp_frame.c
index 38b0f994bc7b..abcbcc8c7a4c 100644
--- a/drivers/staging/irda/net/irlmp_frame.c
+++ b/drivers/staging/irda/net/irlmp_frame.c
@@ -60,9 +60,9 @@ void irlmp_send_lcf_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap,
 {
 	__u8 *frame;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	frame = skb->data;
 
@@ -93,7 +93,7 @@ void irlmp_link_data_indication(struct lap_cb *self, struct sk_buff *skb,
 	__u8   dlsap_sel;   /* Destination LSAP address */
 	__u8   *fp;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
 	IRDA_ASSERT(skb->len > 2, return;);
 
@@ -129,7 +129,7 @@ void irlmp_link_data_indication(struct lap_cb *self, struct sk_buff *skb,
 		lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0,
 				       self->lsaps);
 
-	if (lsap == NULL) {
+	if (!lsap) {
 		pr_debug("IrLMP, Sorry, no LSAP for received frame!\n");
 		pr_debug("%s(), slsap_sel = %02x, dlsap_sel = %02x\n",
 			 __func__, slsap_sel, dlsap_sel);
@@ -202,7 +202,7 @@ void irlmp_link_unitdata_indication(struct lap_cb *self, struct sk_buff *skb)
 	__u8   *fp;
 	unsigned long flags;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
 	IRDA_ASSERT(skb->len > 2, return;);
 
@@ -231,7 +231,7 @@ void irlmp_link_unitdata_indication(struct lap_cb *self, struct sk_buff *skb)
 	/* Search the connectionless LSAP */
 	spin_lock_irqsave(&irlmp->unconnected_lsaps->hb_spinlock, flags);
 	lsap = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps);
-	while (lsap != NULL) {
+	while (lsap) {
 		/*
 		 *  Check if source LSAP and dest LSAP selectors and PID match.
 		 */
@@ -264,7 +264,7 @@ void irlmp_link_disconnect_indication(struct lap_cb *lap,
 				      LAP_REASON reason,
 				      struct sk_buff *skb)
 {
-	IRDA_ASSERT(lap != NULL, return;);
+	IRDA_ASSERT(lap, return;);
 	IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
 
 	lap->reason = reason;
@@ -307,9 +307,9 @@ void irlmp_link_connect_indication(struct lap_cb *self, __u32 saddr,
 void irlmp_link_connect_confirm(struct lap_cb *self, struct qos_info *qos,
 				struct sk_buff *skb)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
-	IRDA_ASSERT(qos != NULL, return;);
+	IRDA_ASSERT(qos, return;);
 
 	/* Don't need use the skb for now */
 
@@ -350,7 +350,7 @@ void irlmp_link_connect_confirm(struct lap_cb *self, struct qos_info *qos,
 void irlmp_link_discovery_indication(struct lap_cb *self,
 				     discovery_t *discovery)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
 
 	/* Add to main log, cleanup */
@@ -371,7 +371,7 @@ void irlmp_link_discovery_indication(struct lap_cb *self,
  */
 void irlmp_link_discovery_confirm(struct lap_cb *self, hashbin_t *log)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
 
 	/* Add to main log, cleanup */
@@ -441,7 +441,7 @@ static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap_sel,
 	spin_lock_irqsave(&queue->hb_spinlock, flags);
 
 	lsap = (struct lsap_cb *) hashbin_get_first(queue);
-	while (lsap != NULL) {
+	while (lsap) {
 		/*
 		 *  If this is an incoming connection, then the destination
 		 *  LSAP selector may have been specified as LM_ANY so that
diff --git a/drivers/staging/irda/net/irnetlink.c b/drivers/staging/irda/net/irnetlink.c
index 7fc340e574cf..300cf57317d9 100644
--- a/drivers/staging/irda/net/irnetlink.c
+++ b/drivers/staging/irda/net/irnetlink.c
@@ -96,7 +96,7 @@ static int irda_nl_get_mode(struct sk_buff *skb, struct genl_info *info)
 
 	hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq,
 			  &irda_nl_family, 0,  IRDA_NL_CMD_GET_MODE);
-	if (hdr == NULL) {
+	if (!hdr) {
 		ret = -EMSGSIZE;
 		goto err_out;
 	}
diff --git a/drivers/staging/irda/net/irproc.c b/drivers/staging/irda/net/irproc.c
index 77cfdde9d82f..2ddac9f15e6c 100644
--- a/drivers/staging/irda/net/irproc.c
+++ b/drivers/staging/irda/net/irproc.c
@@ -66,7 +66,7 @@ void __init irda_proc_register(void)
 	int i;
 
 	proc_irda = proc_mkdir("irda", init_net.proc_net);
-	if (proc_irda == NULL)
+	if (!proc_irda)
 		return;
 
 	for (i = 0; i < ARRAY_SIZE(irda_dirs); i++)
diff --git a/drivers/staging/irda/net/irqueue.c b/drivers/staging/irda/net/irqueue.c
index 14291cbc4097..ee9d30536a9a 100644
--- a/drivers/staging/irda/net/irqueue.c
+++ b/drivers/staging/irda/net/irqueue.c
@@ -237,7 +237,7 @@ static void enqueue_first(irda_queue_t **queue, irda_queue_t* element)
 	/*
 	 * Check if queue is empty.
 	 */
-	if ( *queue == NULL ) {
+	if (!*queue) {
 		/*
 		 * Queue is empty.  Insert one element into the queue.
 		 */
@@ -273,7 +273,7 @@ static irda_queue_t *dequeue_first(irda_queue_t **queue)
 	 */
 	ret =  *queue;
 
-	if ( *queue == NULL ) {
+	if (!*queue) {
 		/*
 		 * Queue was empty.
 		 */
@@ -314,7 +314,7 @@ static irda_queue_t *dequeue_general(irda_queue_t **queue, irda_queue_t* element
 	 */
 	ret =  *queue;
 
-	if ( *queue == NULL ) {
+	if (!*queue) {
 		/*
 		 * Queue was empty.
 		 */
@@ -390,7 +390,7 @@ int hashbin_delete( hashbin_t* hashbin, FREE_FUNC free_func)
 	unsigned long flags = 0;
 	int i;
 
-	IRDA_ASSERT(hashbin != NULL, return -1;);
+	IRDA_ASSERT(hashbin, return -1;);
 	IRDA_ASSERT(hashbin->magic == HB_MAGIC, return -1;);
 
 	/* Synchronize */
@@ -449,7 +449,7 @@ void hashbin_insert(hashbin_t* hashbin, irda_queue_t* entry, long hashv,
 	unsigned long flags = 0;
 	int bin;
 
-	IRDA_ASSERT( hashbin != NULL, return;);
+	IRDA_ASSERT(hashbin, return;);
 	IRDA_ASSERT( hashbin->magic == HB_MAGIC, return;);
 
 	/*
@@ -505,7 +505,7 @@ void *hashbin_remove_first( hashbin_t *hashbin)
 	} /* Default is no-lock  */
 
 	entry = hashbin_get_first( hashbin);
-	if ( entry != NULL) {
+	if (entry) {
 		int	bin;
 		long	hashv;
 		/*
@@ -560,7 +560,7 @@ void* hashbin_remove( hashbin_t* hashbin, long hashv, const char* name)
 	unsigned long flags = 0;
 	irda_queue_t* entry;
 
-	IRDA_ASSERT( hashbin != NULL, return NULL;);
+	IRDA_ASSERT(hashbin, return NULL;);
 	IRDA_ASSERT( hashbin->magic == HB_MAGIC, return NULL;);
 
 	/*
@@ -651,9 +651,9 @@ void* hashbin_remove_this( hashbin_t* hashbin, irda_queue_t* entry)
 	int	bin;
 	long	hashv;
 
-	IRDA_ASSERT( hashbin != NULL, return NULL;);
+	IRDA_ASSERT(hashbin, return NULL;);
 	IRDA_ASSERT( hashbin->magic == HB_MAGIC, return NULL;);
-	IRDA_ASSERT( entry != NULL, return NULL;);
+	IRDA_ASSERT(entry, return NULL;);
 
 	/* Synchronize */
 	if ( hashbin->hb_type & HB_LOCK ) {
@@ -661,7 +661,7 @@ void* hashbin_remove_this( hashbin_t* hashbin, irda_queue_t* entry)
 	} /* Default is no-lock  */
 
 	/* Check if valid and not already removed... */
-	if((entry->q_next == NULL) || (entry->q_prev == NULL)) {
+	if (!entry->q_next || !entry->q_prev) {
 		entry = NULL;
 		goto out;
 	}
@@ -712,7 +712,7 @@ void* hashbin_find( hashbin_t* hashbin, long hashv, const char* name )
 
 	pr_debug("hashbin_find()\n");
 
-	IRDA_ASSERT( hashbin != NULL, return NULL;);
+	IRDA_ASSERT(hashbin, return NULL;);
 	IRDA_ASSERT( hashbin->magic == HB_MAGIC, return NULL;);
 
 	/*
@@ -833,10 +833,10 @@ irda_queue_t *hashbin_get_first( hashbin_t* hashbin)
 	irda_queue_t *entry;
 	int i;
 
-	IRDA_ASSERT( hashbin != NULL, return NULL;);
+	IRDA_ASSERT(hashbin, return NULL;);
 	IRDA_ASSERT( hashbin->magic == HB_MAGIC, return NULL;);
 
-	if ( hashbin == NULL)
+	if (!hashbin)
 		return NULL;
 
 	for ( i = 0; i < HASHBIN_SIZE; i ++ ) {
@@ -869,11 +869,11 @@ irda_queue_t *hashbin_get_next( hashbin_t *hashbin)
 	int bin;
 	int i;
 
-	IRDA_ASSERT( hashbin != NULL, return NULL;);
+	IRDA_ASSERT(hashbin, return NULL;);
 	IRDA_ASSERT( hashbin->magic == HB_MAGIC, return NULL;);
 
-	if ( hashbin->hb_current == NULL) {
-		IRDA_ASSERT( hashbin->hb_current != NULL, return NULL;);
+	if (!hashbin->hb_current) {
+		IRDA_ASSERT(hashbin->hb_current, return NULL;);
 		return NULL;
 	}
 	entry = hashbin->hb_current->q_next;
diff --git a/drivers/staging/irda/net/irsysctl.c b/drivers/staging/irda/net/irsysctl.c
index 873da5e7d428..70b8d39b5c1c 100644
--- a/drivers/staging/irda/net/irsysctl.c
+++ b/drivers/staging/irda/net/irsysctl.c
@@ -99,8 +99,8 @@ static int do_discovery(struct ctl_table *table, int write,
        if (ret)
 	       return ret;
 
-       if (irlmp == NULL)
-	       return -ENODEV;
+	if (!irlmp)
+		return -ENODEV;
 
        if (sysctl_discovery)
 	       irlmp_start_discovery_timer(irlmp, sysctl_discovery_timeout*HZ);
diff --git a/drivers/staging/irda/net/irttp.c b/drivers/staging/irda/net/irttp.c
index bcab5a60cd47..2adba87aeb68 100644
--- a/drivers/staging/irda/net/irttp.c
+++ b/drivers/staging/irda/net/irttp.c
@@ -91,7 +91,7 @@ static pi_param_info_t param_info = { pi_major_call_table, 1, 0x0f, 4 };
 int __init irttp_init(void)
 {
 	irttp = kzalloc(sizeof(struct irttp_cb), GFP_KERNEL);
-	if (irttp == NULL)
+	if (!irttp)
 		return -ENOMEM;
 
 	irttp->magic = TTP_MAGIC;
@@ -209,7 +209,7 @@ static void irttp_flush_queues(struct tsap_cb *self)
 {
 	struct sk_buff *skb;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
 	/* Deallocate frames waiting to be sent */
@@ -237,7 +237,7 @@ static struct sk_buff *irttp_reassemble_skb(struct tsap_cb *self)
 	struct sk_buff *skb, *frag;
 	int n = 0;  /* Fragment index */
 
-	IRDA_ASSERT(self != NULL, return NULL;);
+	IRDA_ASSERT(self, return NULL;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return NULL;);
 
 	pr_debug("%s(), self->rx_sdu_size=%d\n", __func__,
@@ -294,9 +294,9 @@ static inline void irttp_fragment_skb(struct tsap_cb *self,
 	struct sk_buff *frag;
 	__u8 *frame;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	/*
 	 *  Split frame into a number of segments
@@ -350,7 +350,7 @@ static int irttp_param_max_sdu_size(void *instance, irda_param_t *param,
 
 	self = instance;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
 
 	if (get)
@@ -404,7 +404,7 @@ struct tsap_cb *irttp_open_tsap(__u8 stsap_sel, int credit, notify_t *notify)
 	}
 
 	self = kzalloc(sizeof(*self), GFP_ATOMIC);
-	if (self == NULL)
+	if (!self)
 		return NULL;
 
 	/* Initialize internal objects */
@@ -422,7 +422,7 @@ struct tsap_cb *irttp_open_tsap(__u8 stsap_sel, int credit, notify_t *notify)
 	ttp_notify.data_indication = irttp_data_indication;
 	ttp_notify.udata_indication = irttp_udata_indication;
 	ttp_notify.flow_indication = irttp_flow_indication;
-	if (notify->status_indication != NULL)
+	if (notify->status_indication)
 		ttp_notify.status_indication = irttp_status_indication;
 	ttp_notify.instance = self;
 	strncpy(ttp_notify.name, notify->name, NOTIFY_MAX_NAME);
@@ -434,7 +434,7 @@ struct tsap_cb *irttp_open_tsap(__u8 stsap_sel, int credit, notify_t *notify)
 	 *  Create LSAP at IrLMP layer
 	 */
 	lsap = irlmp_open_lsap(stsap_sel, &ttp_notify, 0);
-	if (lsap == NULL) {
+	if (!lsap) {
 		pr_debug("%s: unable to allocate LSAP!!\n", __func__);
 		__irttp_close_tsap(self);
 		return NULL;
@@ -472,7 +472,7 @@ EXPORT_SYMBOL(irttp_open_tsap);
 static void __irttp_close_tsap(struct tsap_cb *self)
 {
 	/* First make sure we're connected. */
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
 	irttp_flush_queues(self);
@@ -504,7 +504,7 @@ int irttp_close_tsap(struct tsap_cb *self)
 {
 	struct tsap_cb *tsap;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
 
 	/* Make sure tsap has been disconnected */
@@ -547,9 +547,9 @@ int irttp_udata_request(struct tsap_cb *self, struct sk_buff *skb)
 {
 	int ret;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
-	IRDA_ASSERT(skb != NULL, return -1;);
+	IRDA_ASSERT(skb, return -1;);
 
 	/* Take shortcut on zero byte packets */
 	if (skb->len == 0) {
@@ -594,9 +594,9 @@ int irttp_data_request(struct tsap_cb *self, struct sk_buff *skb)
 	__u8 *frame;
 	int ret;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
-	IRDA_ASSERT(skb != NULL, return -1;);
+	IRDA_ASSERT(skb, return -1;);
 
 	pr_debug("%s() : queue len = %d\n", __func__,
 		 skb_queue_len(&self->tx_queue));
@@ -769,7 +769,7 @@ static void irttp_run_tx_queue(struct tsap_cb *self)
 		 * remains in IrLAP (retry on the link or else) after we
 		 * close the socket, we are dead !
 		 * Jean II */
-		if (skb->sk != NULL) {
+		if (skb->sk) {
 			/* IrSOCK application, IrOBEX, ... */
 			skb_orphan(skb);
 		}
@@ -815,7 +815,7 @@ static inline void irttp_give_credit(struct tsap_cb *self)
 	unsigned long flags;
 	int n;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
 	pr_debug("%s() send=%d,avail=%d,remote=%d\n",
@@ -870,9 +870,9 @@ static int irttp_udata_indication(void *instance, void *sap,
 
 	self = instance;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
-	IRDA_ASSERT(skb != NULL, return -1;);
+	IRDA_ASSERT(skb, return -1;);
 
 	self->stats.rx_packets++;
 
@@ -985,7 +985,7 @@ static void irttp_status_indication(void *instance,
 
 	self = instance;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
 	/* Check if client has already closed the TSAP and gone away */
@@ -995,7 +995,7 @@ static void irttp_status_indication(void *instance,
 	/*
 	 *  Inform service user if he has requested it
 	 */
-	if (self->notify.status_indication != NULL)
+	if (self->notify.status_indication)
 		self->notify.status_indication(self->notify.instance,
 					       link, lock);
 	else
@@ -1014,7 +1014,7 @@ static void irttp_flow_indication(void *instance, void *sap, LOCAL_FLOW flow)
 
 	self = instance;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
 	pr_debug("%s(instance=%p)\n", __func__, self);
@@ -1055,7 +1055,7 @@ static void irttp_flow_indication(void *instance, void *sap, LOCAL_FLOW flow)
  */
 void irttp_flow_request(struct tsap_cb *self, LOCAL_FLOW flow)
 {
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
 	switch (flow) {
@@ -1095,7 +1095,7 @@ int irttp_connect_request(struct tsap_cb *self, __u8 dtsap_sel,
 
 	pr_debug("%s(), max_sdu_size=%d\n", __func__, max_sdu_size);
 
-	IRDA_ASSERT(self != NULL, return -EBADR;);
+	IRDA_ASSERT(self, return -EBADR;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -EBADR;);
 
 	if (self->connected) {
@@ -1105,7 +1105,7 @@ int irttp_connect_request(struct tsap_cb *self, __u8 dtsap_sel,
 	}
 
 	/* Any userdata supplied? */
-	if (userdata == NULL) {
+	if (!userdata) {
 		tx_skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER,
 				   GFP_ATOMIC);
 		if (!tx_skb)
@@ -1193,9 +1193,9 @@ static void irttp_connect_confirm(void *instance, void *sap,
 
 	self = instance;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	self->max_seg_size = max_seg_size - TTP_HEADER;
 	self->max_header_size = max_header_size + TTP_HEADER;
@@ -1277,9 +1277,9 @@ static void irttp_connect_indication(void *instance, void *sap,
 
 	self = instance;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
-	IRDA_ASSERT(skb != NULL, return;);
+	IRDA_ASSERT(skb, return;);
 
 	lsap = sap;
 
@@ -1345,14 +1345,14 @@ int irttp_connect_response(struct tsap_cb *self, __u32 max_sdu_size,
 	int ret;
 	__u8 n;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
 
 	pr_debug("%s(), Source TSAP selector=%02x\n", __func__,
 		 self->stsap_sel);
 
 	/* Any userdata supplied? */
-	if (userdata == NULL) {
+	if (!userdata) {
 		tx_skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER,
 				   GFP_ATOMIC);
 		if (!tx_skb)
@@ -1484,7 +1484,7 @@ int irttp_disconnect_request(struct tsap_cb *self, struct sk_buff *userdata,
 {
 	int ret;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
 
 	/* Already disconnected? */
@@ -1580,7 +1580,7 @@ static void irttp_disconnect_indication(void *instance, void *sap,
 
 	self = instance;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
 	/* Prevent higher layer to send more data */
@@ -1800,7 +1800,7 @@ static void *irttp_seq_start(struct seq_file *seq, loff_t *pos)
 	iter->id = 0;
 
 	for (self = (struct tsap_cb *) hashbin_get_first(irttp->tsaps);
-	     self != NULL;
+	     self;
 	     self = (struct tsap_cb *) hashbin_get_next(irttp->tsaps)) {
 		if (iter->id == *pos)
 			break;
diff --git a/drivers/staging/irda/net/parameters.c b/drivers/staging/irda/net/parameters.c
index 16ce32ffe004..2d891729815d 100644
--- a/drivers/staging/irda/net/parameters.c
+++ b/drivers/staging/irda/net/parameters.c
@@ -456,8 +456,8 @@ int irda_param_insert(void *self, __u8 pi, __u8 *buf, int len,
 	int ret = -1;
 	int n = 0;
 
-	IRDA_ASSERT(buf != NULL, return ret;);
-	IRDA_ASSERT(info != NULL, return ret;);
+	IRDA_ASSERT(buf, return ret;);
+	IRDA_ASSERT(info, return ret;);
 
 	pi_minor = pi & info->pi_mask;
 	pi_major = pi >> info->pi_major_offset;
@@ -511,8 +511,8 @@ static int irda_param_extract(void *self, __u8 *buf, int len,
 	int ret = -1;
 	int n = 0;
 
-	IRDA_ASSERT(buf != NULL, return ret;);
-	IRDA_ASSERT(info != NULL, return ret;);
+	IRDA_ASSERT(buf, return ret;);
+	IRDA_ASSERT(info, return ret;);
 
 	pi_minor = buf[n] & info->pi_mask;
 	pi_major = buf[n] >> info->pi_major_offset;
@@ -564,8 +564,8 @@ int irda_param_extract_all(void *self, __u8 *buf, int len,
 	int ret = -1;
 	int n = 0;
 
-	IRDA_ASSERT(buf != NULL, return ret;);
-	IRDA_ASSERT(info != NULL, return ret;);
+	IRDA_ASSERT(buf, return ret;);
+	IRDA_ASSERT(info, return ret;);
 
 	/*
 	 * Parse all parameters. Each parameter must be at least two bytes
diff --git a/drivers/staging/irda/net/qos.c b/drivers/staging/irda/net/qos.c
index 25ba8509ad3e..b3816b90ff2c 100644
--- a/drivers/staging/irda/net/qos.c
+++ b/drivers/staging/irda/net/qos.c
@@ -278,8 +278,8 @@ static inline int value_highest_bit(__u32 value, __u32 *array, int size, __u16 *
  */
 void irda_qos_compute_intersection(struct qos_info *qos, struct qos_info *new)
 {
-	IRDA_ASSERT(qos != NULL, return;);
-	IRDA_ASSERT(new != NULL, return;);
+	IRDA_ASSERT(qos, return;);
+	IRDA_ASSERT(new, return;);
 
 	/* Apply */
 	qos->baud_rate.bits       &= new->baud_rate.bits;
@@ -529,7 +529,7 @@ static int irlap_param_baud_rate(void *instance, irda_param_t *param, int get)
 
 	struct irlap_cb *self = (struct irlap_cb *) instance;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	if (get) {
@@ -565,7 +565,7 @@ static int irlap_param_link_disconnect(void *instance, irda_param_t *param,
 
 	struct irlap_cb *self = (struct irlap_cb *) instance;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	if (get)
@@ -597,7 +597,7 @@ static int irlap_param_max_turn_time(void *instance, irda_param_t *param,
 {
 	struct irlap_cb *self = (struct irlap_cb *) instance;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	if (get)
@@ -619,7 +619,7 @@ static int irlap_param_data_size(void *instance, irda_param_t *param, int get)
 {
 	struct irlap_cb *self = (struct irlap_cb *) instance;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	if (get)
@@ -642,7 +642,7 @@ static int irlap_param_window_size(void *instance, irda_param_t *param,
 {
 	struct irlap_cb *self = (struct irlap_cb *) instance;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	if (get)
@@ -663,7 +663,7 @@ static int irlap_param_additional_bofs(void *instance, irda_param_t *param, int
 {
 	struct irlap_cb *self = (struct irlap_cb *) instance;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	if (get)
@@ -685,7 +685,7 @@ static int irlap_param_min_turn_time(void *instance, irda_param_t *param,
 {
 	struct irlap_cb *self = (struct irlap_cb *) instance;
 
-	IRDA_ASSERT(self != NULL, return -1;);
+	IRDA_ASSERT(self, return -1;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
 
 	if (get)
@@ -745,7 +745,7 @@ void irda_qos_bits_to_value(struct qos_info *qos)
 {
 	int index;
 
-	IRDA_ASSERT(qos != NULL, return;);
+	IRDA_ASSERT(qos, return;);
 
 	index = msb_index(qos->baud_rate.bits);
 	qos->baud_rate.value = baud_rates[index];
diff --git a/drivers/staging/irda/net/timer.c b/drivers/staging/irda/net/timer.c
index f2280f73b057..3d47ac9df2fe 100644
--- a/drivers/staging/irda/net/timer.c
+++ b/drivers/staging/irda/net/timer.c
@@ -142,7 +142,7 @@ static void irlap_slot_timer_expired(void *data)
 {
 	struct irlap_cb *self = (struct irlap_cb *) data;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	irlap_do_event(self, SLOT_TIMER_EXPIRED, NULL, NULL);
@@ -158,7 +158,7 @@ static void irlap_query_timer_expired(void *data)
 {
 	struct irlap_cb *self = (struct irlap_cb *) data;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	irlap_do_event(self, QUERY_TIMER_EXPIRED, NULL, NULL);
@@ -174,7 +174,7 @@ static void irlap_final_timer_expired(void *data)
 {
 	struct irlap_cb *self = (struct irlap_cb *) data;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	irlap_do_event(self, FINAL_TIMER_EXPIRED, NULL, NULL);
@@ -190,7 +190,7 @@ static void irlap_wd_timer_expired(void *data)
 {
 	struct irlap_cb *self = (struct irlap_cb *) data;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	irlap_do_event(self, WD_TIMER_EXPIRED, NULL, NULL);
@@ -206,7 +206,7 @@ static void irlap_backoff_timer_expired(void *data)
 {
 	struct irlap_cb *self = (struct irlap_cb *) data;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
 	irlap_do_event(self, BACKOFF_TIMER_EXPIRED, NULL, NULL);
@@ -222,7 +222,7 @@ static void irlap_media_busy_expired(void *data)
 {
 	struct irlap_cb *self = (struct irlap_cb *) data;
 
-	IRDA_ASSERT(self != NULL, return;);
+	IRDA_ASSERT(self, return;);
 
 	irda_device_set_media_busy(self->netdev, FALSE);
 	/* Note : the LAP event will be send in irlap_stop_mbusy_timer(),
diff --git a/drivers/staging/irda/net/wrapper.c b/drivers/staging/irda/net/wrapper.c
index 40a0f993bf13..526f86d27268 100644
--- a/drivers/staging/irda/net/wrapper.c
+++ b/drivers/staging/irda/net/wrapper.c
@@ -219,8 +219,7 @@ async_bump(struct net_device *dev,
 	 * skb. But, if the frame is small, it is more efficient to
 	 * copy it to save memory (copy will be fast anyway - that's
 	 * called Rx-copy-break). Jean II */
-	docopy = ((rx_buff->skb == NULL) ||
-		  (rx_buff->len < IRDA_RX_COPY_THRESHOLD));
+	docopy = !rx_buff->skb || rx_buff->len < IRDA_RX_COPY_THRESHOLD;
 
 	/* Allocate a new skb */
 	newskb = dev_alloc_skb(docopy ? rx_buff->len + 1 : rx_buff->truesize);
-- 
2.14.2