diff --git a/kern/drivers/dma/dmaengine.c b/kern/drivers/dma/dmaengine.c
index 3a11b10..e1ebca3 100644
--- a/kern/drivers/dma/dmaengine.c
+++ b/kern/drivers/dma/dmaengine.c
@@ -94,7 +94,7 @@
 	int i;
 	int err;
 
-	mutex_lock(&dma_list_mutex);
+	qlock(&dma_list_mutex);
 	chan = dev_to_dma_chan(dev);
 	if (chan) {
 		for_each_possible_cpu(i)
@@ -102,7 +102,7 @@
 		err = sprintf(buf, "%lu\n", count);
 	} else
 		err = -ENODEV;
-	mutex_unlock(&dma_list_mutex);
+	qunlock(&dma_list_mutex);
 
 	return err;
 }
@@ -116,7 +116,7 @@
 	int i;
 	int err;
 
-	mutex_lock(&dma_list_mutex);
+	qlock(&dma_list_mutex);
 	chan = dev_to_dma_chan(dev);
 	if (chan) {
 		for_each_possible_cpu(i)
@@ -124,7 +124,7 @@
 		err = sprintf(buf, "%lu\n", count);
 	} else
 		err = -ENODEV;
-	mutex_unlock(&dma_list_mutex);
+	qunlock(&dma_list_mutex);
 
 	return err;
 }
@@ -136,13 +136,13 @@
 	struct dma_chan *chan;
 	int err;
 
-	mutex_lock(&dma_list_mutex);
+	qlock(&dma_list_mutex);
 	chan = dev_to_dma_chan(dev);
 	if (chan)
 		err = sprintf(buf, "%d\n", chan->client_count);
 	else
 		err = -ENODEV;
-	mutex_unlock(&dma_list_mutex);
+	qunlock(&dma_list_mutex);
 
 	return err;
 }
@@ -161,7 +161,7 @@
 	struct dma_chan_dev *chan_dev;
 
 	chan_dev = container_of(dev, typeof(*chan_dev), device);
-	if (atomic_dec_and_test(chan_dev->idr_ref)) {
+	if (atomic_sub_and_test(chan_dev->idr_ref, 1)) {
 		ida_free(&dma_ida, chan_dev->dev_id);
 		kfree(chan_dev->idr_ref);
 	}
@@ -591,7 +591,7 @@
 	int err = -EBUSY;
 
 	/* lock against __dma_request_channel */
-	mutex_lock(&dma_list_mutex);
+	qlock(&dma_list_mutex);
 
 	if (chan->client_count == 0) {
 		struct dma_device *device = chan->device;
@@ -610,7 +610,7 @@
 	} else
 		chan = NULL;
 
-	mutex_unlock(&dma_list_mutex);
+	qunlock(&dma_list_mutex);
 
 
 	return chan;
@@ -626,11 +626,11 @@
 	dma_cap_set(DMA_SLAVE, mask);
 
 	/* lock against __dma_request_channel */
-	mutex_lock(&dma_list_mutex);
+	qlock(&dma_list_mutex);
 
 	chan = find_candidate(device, &mask, NULL, NULL);
 
-	mutex_unlock(&dma_list_mutex);
+	qunlock(&dma_list_mutex);
 
 	return IS_ERR(chan) ? NULL : chan;
 }
@@ -651,7 +651,7 @@
 	struct dma_chan *chan = NULL;
 
 	/* Find a channel */
-	mutex_lock(&dma_list_mutex);
+	qlock(&dma_list_mutex);
 	list_for_each_entry_safe(device, _d, &dma_device_list, global_node) {
 		chan = find_candidate(device, mask, fn, fn_param);
 		if (!IS_ERR(chan))
@@ -659,7 +659,7 @@
 
 		chan = NULL;
 	}
-	mutex_unlock(&dma_list_mutex);
+	qunlock(&dma_list_mutex);
 
 	pr_debug("%s: %s (%s)\n",
 		 __func__,
@@ -717,7 +717,7 @@
 	}
 
 	/* Try to find the channel via the DMA filter map(s) */
-	mutex_lock(&dma_list_mutex);
+	qlock(&dma_list_mutex);
 	list_for_each_entry_safe(d, _d, &dma_device_list, global_node) {
 		dma_cap_mask_t mask;
 		const struct dma_slave_map *map = dma_filter_match(d, name, dev);
@@ -732,7 +732,7 @@
 		if (!IS_ERR(chan))
 			break;
 	}
-	mutex_unlock(&dma_list_mutex);
+	qunlock(&dma_list_mutex);
 
 	return chan ? chan : ERR_PTR(-EPROBE_DEFER);
 }
@@ -771,12 +771,12 @@
 
 	chan = __dma_request_channel(mask, NULL, NULL);
 	if (!chan) {
-		mutex_lock(&dma_list_mutex);
+		qlock(&dma_list_mutex);
 		if (list_empty(&dma_device_list))
 			chan = ERR_PTR(-EPROBE_DEFER);
 		else
 			chan = ERR_PTR(-ENODEV);
-		mutex_unlock(&dma_list_mutex);
+		qunlock(&dma_list_mutex);
 	}
 
 	return chan;
@@ -785,14 +785,14 @@
 
 void dma_release_channel(struct dma_chan *chan)
 {
-	mutex_lock(&dma_list_mutex);
+	qlock(&dma_list_mutex);
 	WARN_ONCE(chan->client_count != 1,
 		  "chan reference count %d != 1\n", chan->client_count);
 	dma_chan_put(chan);
 	/* drop PRIVATE cap enabled by __dma_request_channel() */
 	if (--chan->device->privatecnt == 0)
 		dma_cap_clear(DMA_PRIVATE, chan->device->cap_mask);
-	mutex_unlock(&dma_list_mutex);
+	qunlock(&dma_list_mutex);
 }
 EXPORT_SYMBOL_GPL(dma_release_channel);
 
@@ -805,7 +805,7 @@
 	struct dma_chan *chan;
 	int err;
 
-	mutex_lock(&dma_list_mutex);
+	qlock(&dma_list_mutex);
 	dmaengine_ref_count++;
 
 	/* try to grab channels */
@@ -831,7 +831,7 @@
 	 */
 	if (dmaengine_ref_count == 1)
 		dma_channel_rebalance();
-	mutex_unlock(&dma_list_mutex);
+	qunlock(&dma_list_mutex);
 }
 EXPORT_SYMBOL(dmaengine_get);
 
@@ -843,9 +843,9 @@
 	struct dma_device *device;
 	struct dma_chan *chan;
 
-	mutex_lock(&dma_list_mutex);
+	qlock(&dma_list_mutex);
 	dmaengine_ref_count--;
-	BUG_ON(dmaengine_ref_count < 0);
+	assert(!(dmaengine_ref_count < 0));
 	/* drop channel references */
 	list_for_each_entry(device, &dma_device_list, global_node) {
 		if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
@@ -853,7 +853,7 @@
 		list_for_each_entry(chan, &device->channels, device_node)
 			dma_chan_put(chan);
 	}
-	mutex_unlock(&dma_list_mutex);
+	qunlock(&dma_list_mutex);
 }
 EXPORT_SYMBOL(dmaengine_put);
 
@@ -898,7 +898,7 @@
 
 static int get_dma_id(struct dma_device *device)
 {
-	int rc = ida_alloc(&dma_ida, GFP_KERNEL);
+	int rc = ida_alloc(&dma_ida, MEM_WAIT);
 
 	if (rc < 0)
 		return rc;
@@ -1006,7 +1006,7 @@
 	if (device_has_all_tx_types(device))
 		dma_cap_set(DMA_ASYNC_TX, device->cap_mask);
 
-	idr_ref = kmalloc(sizeof(*idr_ref), GFP_KERNEL);
+	idr_ref = kmalloc(sizeof(*idr_ref), MEM_WAIT);
 	if (!idr_ref)
 		return -ENOMEM;
 	rc = get_dma_id(device);
@@ -1023,7 +1023,7 @@
 		chan->local = alloc_percpu(typeof(*chan->local));
 		if (chan->local == NULL)
 			goto err_out;
-		chan->dev = kzalloc(sizeof(*chan->dev), GFP_KERNEL);
+		chan->dev = kzmalloc(sizeof(*chan->dev), MEM_WAIT);
 		if (chan->dev == NULL) {
 			free_percpu(chan->local);
 			chan->local = NULL;
@@ -1059,7 +1059,7 @@
 
 	device->chancnt = chancnt;
 
-	mutex_lock(&dma_list_mutex);
+	qlock(&dma_list_mutex);
 	/* take references on public channels */
 	if (dmaengine_ref_count && !dma_has_cap(DMA_PRIVATE, device->cap_mask))
 		list_for_each_entry(chan, &device->channels, device_node) {
@@ -1072,7 +1072,7 @@
 				 * guaranteed to get a reference
 				 */
 				rc = -ENODEV;
-				mutex_unlock(&dma_list_mutex);
+				qunlock(&dma_list_mutex);
 				goto err_out;
 			}
 		}
@@ -1080,7 +1080,7 @@
 	if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
 		device->privatecnt++;	/* Always private */
 	dma_channel_rebalance();
-	mutex_unlock(&dma_list_mutex);
+	qunlock(&dma_list_mutex);
 
 	return 0;
 
@@ -1095,9 +1095,9 @@
 	list_for_each_entry(chan, &device->channels, device_node) {
 		if (chan->local == NULL)
 			continue;
-		mutex_lock(&dma_list_mutex);
+		qlock(&dma_list_mutex);
 		chan->dev->chan = NULL;
-		mutex_unlock(&dma_list_mutex);
+		qunlock(&dma_list_mutex);
 		device_unregister(&chan->dev->device);
 		free_percpu(chan->local);
 	}
@@ -1116,18 +1116,18 @@
 {
 	struct dma_chan *chan;
 
-	mutex_lock(&dma_list_mutex);
+	qlock(&dma_list_mutex);
 	list_del_rcu(&device->global_node);
 	dma_channel_rebalance();
-	mutex_unlock(&dma_list_mutex);
+	qunlock(&dma_list_mutex);
 
 	list_for_each_entry(chan, &device->channels, device_node) {
 		WARN_ONCE(chan->client_count,
 			  "%s called while %d clients hold a reference\n",
 			  __func__, chan->client_count);
-		mutex_lock(&dma_list_mutex);
+		qlock(&dma_list_mutex);
 		chan->dev->chan = NULL;
-		mutex_unlock(&dma_list_mutex);
+		qunlock(&dma_list_mutex);
 		device_unregister(&chan->dev->device);
 		free_percpu(chan->local);
 	}
@@ -1153,7 +1153,7 @@
 	void *p;
 	int ret;
 
-	p = devres_alloc(dmam_device_release, sizeof(void *), GFP_KERNEL);
+	p = devres_alloc(dmam_device_release, sizeof(void *), MEM_WAIT);
 	if (!p)
 		return -ENOMEM;
 
@@ -1202,7 +1202,7 @@
 		return &unmap_pool[3];
 #endif
 	default:
-		BUG();
+		panic("BUG");
 		return NULL;
 	}
 }
@@ -1303,7 +1303,7 @@
 {
 	tx->chan = chan;
 	#ifdef CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH
-	spin_lock_init(&tx->lock);
+	spinlock_init_irqsave(&tx->lock);
 	#endif
 }
 EXPORT_SYMBOL(dma_async_tx_descriptor_init);
diff --git a/kern/drivers/dma/dmaengine.h b/kern/drivers/dma/dmaengine.h
index 501c0b0..fcd6cd5 100644
--- a/kern/drivers/dma/dmaengine.h
+++ b/kern/drivers/dma/dmaengine.h
@@ -51,7 +51,7 @@
  */
 static inline void dma_cookie_complete(struct dma_async_tx_descriptor *tx)
 {
-	BUG_ON(tx->cookie < DMA_MIN_COOKIE);
+	assert(!(tx->cookie < DMA_MIN_COOKIE));
 	tx->chan->completed_cookie = tx->cookie;
 	tx->cookie = 0;
 }
@@ -72,7 +72,7 @@
 
 	used = chan->cookie;
 	complete = chan->completed_cookie;
-	barrier();
+	cmb();
 	if (state) {
 		state->last = complete;
 		state->used = used;
@@ -81,7 +81,8 @@
 	return dma_async_is_complete(cookie, complete, used);
 }
 
-static inline void dma_set_residue(struct dma_tx_state *state, u32 residue)
+static inline void dma_set_residue(struct dma_tx_state *state,
+				   uint32_t residue)
 {
 	if (state)
 		state->residue = residue;
diff --git a/kern/include/linux/dmaengine.h b/kern/include/linux/dmaengine.h
index d49ec5c..d5c07e6 100644
--- a/kern/include/linux/dmaengine.h
+++ b/kern/include/linux/dmaengine.h
@@ -31,7 +31,7 @@
  *
  * if dma_cookie_t is >0 it's a DMA request cookie, <0 it's an error code
  */
-typedef s32 dma_cookie_t;
+typedef int32_t dma_cookie_t;
 #define DMA_MIN_COOKIE	1
 
 static inline int dma_submit_error(dma_cookie_t cookie)
@@ -370,10 +370,10 @@
 	phys_addr_t dst_addr;
 	enum dma_slave_buswidth src_addr_width;
 	enum dma_slave_buswidth dst_addr_width;
-	u32 src_maxburst;
-	u32 dst_maxburst;
-	u32 src_port_window_size;
-	u32 dst_port_window_size;
+	uint32_t src_maxburst;
+	uint32_t dst_maxburst;
+	uint32_t src_port_window_size;
+	uint32_t dst_port_window_size;
 	bool device_fc;
 	unsigned int slave_id;
 };
@@ -424,10 +424,10 @@
  * resubmitted multiple times
  */
 struct dma_slave_caps {
-	u32 src_addr_widths;
-	u32 dst_addr_widths;
-	u32 directions;
-	u32 max_burst;
+	uint32_t src_addr_widths;
+	uint32_t dst_addr_widths;
+	uint32_t directions;
+	uint32_t max_burst;
 	bool cmd_pause;
 	bool cmd_resume;
 	bool cmd_terminate;
@@ -466,7 +466,7 @@
 
 struct dmaengine_result {
 	enum dmaengine_tx_result result;
-	u32 residue;
+	uint32_t residue;
 };
 
 typedef void (*dma_async_tx_callback_result)(void *dma_async_param,
@@ -474,13 +474,13 @@
 
 struct dmaengine_unmap_data {
 #if IS_ENABLED(CONFIG_DMA_ENGINE_RAID)
-	u16 map_cnt;
+	uint16_t map_cnt;
 #else
-	u8 map_cnt;
+	uint8_t map_cnt;
 #endif
-	u8 to_cnt;
-	u8 from_cnt;
-	u8 bidi_cnt;
+	uint8_t to_cnt;
+	uint8_t from_cnt;
+	uint8_t bidi_cnt;
 	struct device *dev;
 	struct kref kref;
 	size_t len;
@@ -566,7 +566,7 @@
 }
 static inline void txd_chain(struct dma_async_tx_descriptor *txd, struct dma_async_tx_descriptor *next)
 {
-	BUG();
+	panic("BUG");
 }
 static inline void txd_clear_parent(struct dma_async_tx_descriptor *txd)
 {
@@ -586,11 +586,11 @@
 #else
 static inline void txd_lock(struct dma_async_tx_descriptor *txd)
 {
-	spin_lock_bh(&txd->lock);
+	spin_lock(&txd->lock);
 }
 static inline void txd_unlock(struct dma_async_tx_descriptor *txd)
 {
-	spin_unlock_bh(&txd->lock);
+	spin_unlock(&txd->lock);
 }
 static inline void txd_chain(struct dma_async_tx_descriptor *txd, struct dma_async_tx_descriptor *next)
 {
@@ -627,7 +627,7 @@
 struct dma_tx_state {
 	dma_cookie_t last;
 	dma_cookie_t used;
-	u32 residue;
+	uint32_t residue;
 };
 
 /**
@@ -750,10 +750,10 @@
 	int dev_id;
 	struct device *dev;
 
-	u32 src_addr_widths;
-	u32 dst_addr_widths;
-	u32 directions;
-	u32 max_burst;
+	uint32_t src_addr_widths;
+	uint32_t dst_addr_widths;
+	uint32_t directions;
+	uint32_t max_burst;
 	bool descriptor_reuse;
 	enum dma_residue_granularity residue_granularity;
 
@@ -798,7 +798,7 @@
 		struct dma_chan *chan, struct dma_interleaved_template *xt,
 		unsigned long flags);
 	struct dma_async_tx_descriptor *(*device_prep_dma_imm_data)(
-		struct dma_chan *chan, dma_addr_t dst, u64 data,
+		struct dma_chan *chan, dma_addr_t dst, uint64_t data,
 		unsigned long flags);
 
 	int (*device_config)(struct dma_chan *chan,
@@ -1126,7 +1126,7 @@
 		return dma_dev_to_maxpq(dma) - 1;
 	else if (dmaf_continue(flags))
 		return dma_dev_to_maxpq(dma) - 3;
-	BUG();
+	panic("BUG");
 }
 
 static inline size_t dmaengine_get_icg(bool inc, bool sgl, size_t icg,
@@ -1299,7 +1299,8 @@
 }
 
 static inline void
-dma_set_tx_state(struct dma_tx_state *st, dma_cookie_t last, dma_cookie_t used, u32 residue)
+dma_set_tx_state(struct dma_tx_state *st, dma_cookie_t last, dma_cookie_t used,
+		 uint32_t residue)
 {
 	if (st) {
 		st->last = last;