/*
* linux/drivers/mmc/host/mshci-s3c-dma.c
* Mobile Storage Host Controller Interface driver
*
* Copyright (c) 2011 Samsung Electronics Co., Ltd.
* http://www.samsung.com
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
*/
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/gfp.h>
#include <linux/errno.h>
#include <linux/list.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/highmem.h>
#include <asm/memory.h>
#include <asm/highmem.h>
#include <asm/cacheflush.h>
#include <asm/tlbflush.h>
#include <asm/sizes.h>
#include <linux/mmc/host.h>
#include "mshci.h"
static void mshci_s3c_dma_cache_maint_page(struct page *page,
unsigned long offset, size_t size, enum dma_data_direction dir,
void (*op)(const void *, size_t, int), int flush_type, int enable)
{
/*
* A single sg entry may refer to multiple physically contiguous
* pages. But we still need to process highmem pages individually.
* If highmem is not configured then the bulk of this loop gets
* optimized out.
*/
size_t left = size;
do {
size_t len = left;
void *vaddr;
if (PageHighMem(page)) {
if (len + offset > PAGE_SIZE) {
if (offset >= PAGE_SIZE) {
page += offset / PAGE_SIZE;
offset %= PAGE_SIZE;
}
len = PAGE_SIZE - offset;
}
vaddr = kmap_high_get(page);
if (vaddr) {
vaddr += offset;
if (flush_type == 0 && enable)
op(vaddr, len, dir);
kunmap_high(page);
} else if (cache_is_vipt()) {
/* unmapped pages might still be cached */
vaddr = kmap_atomic(page);
op(vaddr + offset, len, dir);
kunmap_atomic(vaddr);
}
} else {
vaddr = page_address(page) + offset;
if (flush_type == 0 && enable)
op(vaddr, len, dir);
}
offset = 0;
page++;
left -= len;
} while (left);
}
void mshci_s3c_dma_page_cpu_to_dev(struct page *page, unsigned long off,
size_t size, enum dma_data_direction dir, int flush_type)
{
unsigned long paddr;
if (dir != DMA_FROM_DEVICE) {
mshci_s3c_dma_cache_maint_page(page, off, size, dir,
dmac_map_area,
flush_type, 1);
paddr = page_to_phys(page) + off;
if (flush_type != 2) {
outer_clean_range(paddr, paddr + size);
}
/* FIXME: non-speculating: flush on bidirectional mappings? */
} else {
paddr = page_to_phys(page) + off;
/* if flush all L1 cache,
L2 cache dose not neet to be clean.
because, all buffer dose not have split space */
if (flush_type != 2) {
outer_clean_range(paddr, paddr + size);
outer_inv_range(paddr, paddr + size);
}
/* FIXME: non-speculating: flush on bidirectional mappings? */
mshci_s3c_dma_cache_maint_page(page, off, size, dir,
dmac_unmap_area,
flush_type, 1);
}
}
static inline dma_addr_t mshci_s3c_dma_map_page(struct device *dev,
struct page *page, unsigned long offset, size_t size,
enum dma_data_direction dir, int flush_type)
{
BUG_ON(!valid_dma_direction(dir));
mshci_s3c_dma_page_cpu_to_dev(page, offset, size, dir, flush_type);
return pfn_to_dma(dev, page_to_pfn(page)) + offset;
}
int mshci_s3c_dma_map_sg(struct mshci_host *host, struct device *dev,
struct scatterlist *sg, int nents, enum dma_data_direction dir,
int flush_type)
{
struct scatterlist *s;
int i, j;
BUG_ON(!valid_dma_direction(dir));
if (flush_type == 2) {
spin_unlock_irqrestore(&host->lock, host->sl_flags);
flush_all_cpu_caches();
outer_flush_all();
spin_lock_irqsave(&host->lock, host->sl_flags);
} else if(flush_type == 1) {
spin_unlock_irqrestore(&host->lock, host->sl_flags);
flush_all_cpu_caches();
spin_lock_irqsave(&host->lock, host->sl_flags);
}
for_each_sg(sg, s, nents, i) {
s->dma_address = mshci_s3c_dma_map_page(dev, sg_page(s),
s->offset, s->length, dir, flush_type);
if (dma_mapping_error(dev, s->dma_address)) {
goto bad_mapping;
}
}
debug_dma_map_sg(dev, sg, nents, nents, dir);
/* in case of invaldating cache, invaldating L2 cache
must be done prior to invaldating L1 cache */
#if 0
if (dir == DMA_FROM_DEVICE) {
if (flush_type == 1) {
spin_unlock_irqrestore(&host->lock, host->sl_flags);
flush_all_cpu_caches();
spin_lock_irqsave(&host->lock, host->sl_flags);
}
}
#endif
return nents;
bad_mapping:
for_each_sg(sg, s, i, j)
dma_unmap_page(dev, sg_dma_address(s), sg_dma_len(s), dir);
return 0;
}
void mshci_s3c_dma_page_dev_to_cpu(struct page *page, unsigned long off,
size_t size, enum dma_data_direction dir, int flush_type)
{
unsigned long paddr = page_to_phys(page) + off;
/* FIXME: non-speculating: not required */
/* don't bother invalidating if DMA to device */
mshci_s3c_dma_cache_maint_page(page, off, size, dir, dmac_unmap_area,
flush_type, 0);
}
static inline void mshci_s3c_dma_unmap_page(struct device *dev,
dma_addr_t handle, size_t size,
enum dma_data_direction dir, int flush_type)
{
mshci_s3c_dma_page_dev_to_cpu(pfn_to_page(dma_to_pfn(dev, handle)), \
handle & ~PAGE_MASK, size, dir, flush_type);
}
void mshci_s3c_dma_unmap_sg(struct mshci_host *host,
struct device *dev, struct scatterlist *sg,
int nents, enum dma_data_direction dir, int flush_type)
{
#if 1
struct scatterlist *s;
int i;
if (dir == DMA_TO_DEVICE)
for_each_sg(sg, s, nents, i)
mshci_s3c_dma_unmap_page(dev, sg_dma_address(s),
sg_dma_len(s),dir, flush_type);
#endif
}
MODULE_DESCRIPTION("Samsung MSHCI (HSMMC) own dma map functions");
MODULE_AUTHOR("Hyunsung Jang, <hs79.jang@samsung.com>");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:s3c-mshci");
