Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/kyle/parisc-2.6 (a110d514) · Commits · e / devices / android_kernel_oneplus_sm8150

arch/parisc/kernel/syscall_table.S

+2 −2

Original line number	Diff line number	Diff line
		@@ -377,8 +377,8 @@
		ENTRY_SAME(inotify_init)
		ENTRY_SAME(inotify_add_watch) /* 270 */
		ENTRY_SAME(inotify_rm_watch)
		ENTRY_COMP(pselect6)
		ENTRY_COMP(ppoll)
		ENTRY_SAME(ni_syscall) /* 271 ENTRY_COMP(pselect6) */
		ENTRY_SAME(ni_syscall) /* 272 ENTRY_COMP(ppoll) */
		ENTRY_SAME(migrate_pages)
		ENTRY_COMP(openat) /* 275 */
		ENTRY_SAME(mkdirat)

drivers/parisc/ccio-dma.c

+74 −86

Original line number	Diff line number	Diff line
		@@ -40,6 +40,8 @@
		#include <linux/string.h>
		#include <linux/pci.h>
		#include <linux/reboot.h>
		#include <linux/proc_fs.h>
		#include <linux/seq_file.h>

		#include <asm/byteorder.h>
		#include <asm/cache.h> /* for L1_CACHE_BYTES */
		@@ -1019,62 +1021,33 @@ static struct hppa_dma_ops ccio_ops = {
		};

		#ifdef CONFIG_PROC_FS
		static int proc_append(char src, int len, char dst, off_t offset, int *max)
		{
		if (len < *offset) {
		*offset -= len;
		return 0;
		}
		if (*offset > 0) {
		src += *offset;
		len -= *offset;
		*offset = 0;
		}
		if (len > *max) {
		len = *max;
		}
		memcpy(*dst, src, len);
		*dst += len;
		*max -= len;
		return (*max == 0);
		}

		static int ccio_proc_info(char buf, char *start, off_t offset, int count,
		int eof, void data)
		static int ccio_proc_info(struct seq_file m, void p)
		{
		int max = count;
		char tmp[80]; /* width of an ANSI-standard terminal */
		int len = 0;
		struct ioc *ioc = ioc_list;

		while (ioc != NULL) {
		unsigned int total_pages = ioc->res_size << 3;
		unsigned long avg = 0, min, max;
		int j, len;
		int j;

		len = sprintf(tmp, "%s\n", ioc->name);
		if (proc_append(tmp, len, &buf, &offset, &count))
		break;
		len += seq_printf(m, "%s\n", ioc->name);

		len = sprintf(tmp, "Cujo 2.0 bug : %s\n",
		len += seq_printf(m, "Cujo 2.0 bug : %s\n",
		(ioc->cujo20_bug ? "yes" : "no"));
		if (proc_append(tmp, len, &buf, &offset, &count))
		break;

		len = sprintf(tmp, "IO PDIR size : %d bytes (%d entries)\n",
		len += seq_printf(m, "IO PDIR size : %d bytes (%d entries)\n",
		total_pages * 8, total_pages);
		if (proc_append(tmp, len, &buf, &offset, &count))
		break;

		#ifdef CCIO_MAP_STATS
		len = sprintf(tmp, "IO PDIR entries : %ld free %ld used (%d%%)\n",
		len += seq_printf(m, "IO PDIR entries : %ld free %ld used (%d%%)\n",
		total_pages - ioc->used_pages, ioc->used_pages,
		(int)(ioc->used_pages * 100 / total_pages));
		if (proc_append(tmp, len, &buf, &offset, &count))
		break;
		#endif
		len = sprintf(tmp, "Resource bitmap : %d bytes (%d pages)\n",

		len += seq_printf(m, "Resource bitmap : %d bytes (%d pages)\n",
		ioc->res_size, total_pages);
		if (proc_append(tmp, len, &buf, &offset, &count))
		break;

		#ifdef CCIO_SEARCH_TIME
		min = max = ioc->avg_search[0];
		for(j = 0; j < CCIO_SEARCH_SAMPLE; ++j) {
		@@ -1085,70 +1058,83 @@ static int ccio_proc_info(char buf, char *start, off_t offset, int count,
		min = ioc->avg_search[j];
		}
		avg /= CCIO_SEARCH_SAMPLE;
		len = sprintf(tmp, " Bitmap search : %ld/%ld/%ld (min/avg/max CPU Cycles)\n",
		len += seq_printf(m, " Bitmap search : %ld/%ld/%ld (min/avg/max CPU Cycles)\n",
		min, avg, max);
		if (proc_append(tmp, len, &buf, &offset, &count))
		break;
		#endif
		#ifdef CCIO_MAP_STATS
		len = sprintf(tmp, "pci_map_single(): %8ld calls %8ld pages (avg %d/1000)\n",
		len += seq_printf(m, "pci_map_single(): %8ld calls %8ld pages (avg %d/1000)\n",
		ioc->msingle_calls, ioc->msingle_pages,
		(int)((ioc->msingle_pages * 1000)/ioc->msingle_calls));
		if (proc_append(tmp, len, &buf, &offset, &count))
		break;


		/* KLUGE - unmap_sg calls unmap_single for each mapped page */
		min = ioc->usingle_calls - ioc->usg_calls;
		max = ioc->usingle_pages - ioc->usg_pages;
		len = sprintf(tmp, "pci_unmap_single: %8ld calls %8ld pages (avg %d/1000)\n",
		len += seq_printf(m, "pci_unmap_single: %8ld calls %8ld pages (avg %d/1000)\n",
		min, max, (int)((max * 1000)/min));
		if (proc_append(tmp, len, &buf, &offset, &count))
		break;

		len = sprintf(tmp, "pci_map_sg() : %8ld calls %8ld pages (avg %d/1000)\n",
		len += seq_printf(m, "pci_map_sg() : %8ld calls %8ld pages (avg %d/1000)\n",
		ioc->msg_calls, ioc->msg_pages,
		(int)((ioc->msg_pages * 1000)/ioc->msg_calls));
		if (proc_append(tmp, len, &buf, &offset, &count))
		break;
		len = sprintf(tmp, "pci_unmap_sg() : %8ld calls %8ld pages (avg %d/1000)\n\n\n",

		len += seq_printf(m, "pci_unmap_sg() : %8ld calls %8ld pages (avg %d/1000)\n\n\n",
		ioc->usg_calls, ioc->usg_pages,
		(int)((ioc->usg_pages * 1000)/ioc->usg_calls));
		if (proc_append(tmp, len, &buf, &offset, &count))
		break;
		#endif /* CCIO_MAP_STATS */

		ioc = ioc->next;
		}

		if (count == 0) {
		*eof = 1;
		return 0;
		}
		return (max - count);

		static int ccio_proc_info_open(struct inode inode, struct file file)
		{
		return single_open(file, &ccio_proc_info, NULL);
		}

		static int ccio_resource_map(char buf, char *start, off_t offset, int len,
		int eof, void data)
		static struct file_operations ccio_proc_info_fops = {
		.owner = THIS_MODULE,
		.open = ccio_proc_info_open,
		.read = seq_read,
		.llseek = seq_lseek,
		.release = single_release,
		};

		static int ccio_proc_bitmap_info(struct seq_file m, void p)
		{
		int len = 0;
		struct ioc *ioc = ioc_list;

		buf[0] = '\0';
		while (ioc != NULL) {
		u32 res_ptr = (u32 )ioc->res_map;
		int j;

		for (j = 0; j < (ioc->res_size / sizeof(u32)); j++) {
		if ((j & 7) == 0)
		strcat(buf,"\n ");
		sprintf(buf, "%s %08x", buf, *res_ptr);
		len += seq_puts(m, "\n ");
		len += seq_printf(m, "%08x", *res_ptr);
		res_ptr++;
		}
		strcat(buf, "\n\n");
		len += seq_puts(m, "\n\n");
		ioc = ioc->next;
		break; /* XXX - remove me */
		}

		return strlen(buf);
		return 0;
		}

		static int ccio_proc_bitmap_open(struct inode inode, struct file file)
		{
		return single_open(file, &ccio_proc_bitmap_info, NULL);
		}

		static struct file_operations ccio_proc_bitmap_fops = {
		.owner = THIS_MODULE,
		.open = ccio_proc_bitmap_open,
		.read = seq_read,
		.llseek = seq_lseek,
		.release = single_release,
		};
		#endif

		/**
		@@ -1556,6 +1542,7 @@ static int ccio_probe(struct parisc_device *dev)
		{
		int i;
		struct ioc ioc, *ioc_p = &ioc_list;
		struct proc_dir_entry info_entry, bitmap_entry;

		ioc = kzalloc(sizeof(struct ioc), GFP_KERNEL);
		if (ioc == NULL) {
		@@ -1583,13 +1570,14 @@ static int ccio_probe(struct parisc_device *dev)
		BUG_ON(dev->dev.platform_data == NULL);
		HBA_DATA(dev->dev.platform_data)->iommu = ioc;


		if (ioc_count == 0) {
		/* FIXME: Create separate entries for each ioc */
		create_proc_read_entry(MODULE_NAME, S_IRWXU, proc_runway_root,
		ccio_proc_info, NULL);
		create_proc_read_entry(MODULE_NAME"-bitmap", S_IRWXU,
		proc_runway_root, ccio_resource_map, NULL);
		info_entry = create_proc_entry(MODULE_NAME, 0, proc_runway_root);
		if (info_entry)
		info_entry->proc_fops = &ccio_proc_info_fops;

		bitmap_entry = create_proc_entry(MODULE_NAME"-bitmap", 0, proc_runway_root);
		if (bitmap_entry)
		bitmap_entry->proc_fops = &ccio_proc_bitmap_fops;
		}

		ioc_count++;

drivers/parisc/sba_iommu.c

+78 −47

Original line number	Diff line number	Diff line
		@@ -37,6 +37,8 @@
		#include <asm/hardware.h> /* for register_parisc_driver() stuff */

		#include <linux/proc_fs.h>
		#include <linux/seq_file.h>

		#include <asm/runway.h> /* for proc_runway_root */
		#include <asm/pdc.h> /* for PDC_MODEL_* */
		#include <asm/pdcpat.h> /* for is_pdc_pat() */
		@@ -1892,46 +1894,43 @@ sba_common_init(struct sba_device *sba_dev)
		}

		#ifdef CONFIG_PROC_FS
		static int sba_proc_info(char buf, char *start, off_t offset, int len)
		static int sba_proc_info(struct seq_file m, void p)
		{
		struct sba_device *sba_dev = sba_list;
		struct ioc ioc = &sba_dev->ioc[0]; / FIXME: Multi-IOC support! */
		int total_pages = (int) (ioc->res_size << 3); /* 8 bits per byte */
		unsigned long i;
		#ifdef SBA_COLLECT_STATS
		unsigned long avg = 0, min, max;
		#endif
		int i, len = 0;

		sprintf(buf, "%s rev %d.%d\n",
		len += seq_printf(m, "%s rev %d.%d\n",
		sba_dev->name,
		(sba_dev->hw_rev & 0x7) + 1,
		(sba_dev->hw_rev & 0x18) >> 3
		);
		sprintf(buf, "%sIO PDIR size : %d bytes (%d entries)\n",
		buf,
		len += seq_printf(m, "IO PDIR size : %d bytes (%d entries)\n",
		(int) ((ioc->res_size << 3) * sizeof(u64)), /* 8 bits/byte */
		total_pages);

		sprintf(buf, "%sResource bitmap : %d bytes (%d pages)\n",
		buf, ioc->res_size, ioc->res_size << 3); /* 8 bits per byte */
		len += seq_printf(m, "Resource bitmap : %d bytes (%d pages)\n",
		ioc->res_size, ioc->res_size << 3); /* 8 bits per byte */

		sprintf(buf, "%sLMMIO_BASE/MASK/ROUTE %08x %08x %08x\n",
		buf,
		len += seq_printf(m, "LMMIO_BASE/MASK/ROUTE %08x %08x %08x\n",
		READ_REG32(sba_dev->sba_hpa + LMMIO_DIST_BASE),
		READ_REG32(sba_dev->sba_hpa + LMMIO_DIST_MASK),
		READ_REG32(sba_dev->sba_hpa + LMMIO_DIST_ROUTE)
		);

		for (i=0; i<4; i++)
		sprintf(buf, "%sDIR%ld_BASE/MASK/ROUTE %08x %08x %08x\n",
		buf, i,
		len += seq_printf(m, "DIR%d_BASE/MASK/ROUTE %08x %08x %08x\n", i,
		READ_REG32(sba_dev->sba_hpa + LMMIO_DIRECT0_BASE + i*0x18),
		READ_REG32(sba_dev->sba_hpa + LMMIO_DIRECT0_MASK + i*0x18),
		READ_REG32(sba_dev->sba_hpa + LMMIO_DIRECT0_ROUTE + i*0x18)
		);

		#ifdef SBA_COLLECT_STATS
		sprintf(buf, "%sIO PDIR entries : %ld free %ld used (%d%%)\n", buf,
		len += seq_printf(m, "IO PDIR entries : %ld free %ld used (%d%%)\n",
		total_pages - ioc->used_pages, ioc->used_pages,
		(int) (ioc->used_pages * 100 / total_pages));

		@@ -1942,53 +1941,76 @@ static int sba_proc_info(char buf, char *start, off_t offset, int len)
		if (ioc->avg_search[i] < min) min = ioc->avg_search[i];
		}
		avg /= SBA_SEARCH_SAMPLE;
		sprintf(buf, "%s Bitmap search : %ld/%ld/%ld (min/avg/max CPU Cycles)\n",
		buf, min, avg, max);
		len += seq_printf(m, " Bitmap search : %ld/%ld/%ld (min/avg/max CPU Cycles)\n",
		min, avg, max);

		sprintf(buf, "%spci_map_single(): %12ld calls %12ld pages (avg %d/1000)\n",
		buf, ioc->msingle_calls, ioc->msingle_pages,
		len += seq_printf(m, "pci_map_single(): %12ld calls %12ld pages (avg %d/1000)\n",
		ioc->msingle_calls, ioc->msingle_pages,
		(int) ((ioc->msingle_pages * 1000)/ioc->msingle_calls));

		/* KLUGE - unmap_sg calls unmap_single for each mapped page */
		min = ioc->usingle_calls;
		max = ioc->usingle_pages - ioc->usg_pages;
		sprintf(buf, "%spci_unmap_single: %12ld calls %12ld pages (avg %d/1000)\n",
		buf, min, max,
		(int) ((max * 1000)/min));
		len += seq_printf(m, "pci_unmap_single: %12ld calls %12ld pages (avg %d/1000)\n",
		min, max, (int) ((max * 1000)/min));

		sprintf(buf, "%spci_map_sg() : %12ld calls %12ld pages (avg %d/1000)\n",
		buf, ioc->msg_calls, ioc->msg_pages,
		len += seq_printf(m, "pci_map_sg() : %12ld calls %12ld pages (avg %d/1000)\n",
		ioc->msg_calls, ioc->msg_pages,
		(int) ((ioc->msg_pages * 1000)/ioc->msg_calls));

		sprintf(buf, "%spci_unmap_sg() : %12ld calls %12ld pages (avg %d/1000)\n",
		buf, ioc->usg_calls, ioc->usg_pages,
		len += seq_printf(m, "pci_unmap_sg() : %12ld calls %12ld pages (avg %d/1000)\n",
		ioc->usg_calls, ioc->usg_pages,
		(int) ((ioc->usg_pages * 1000)/ioc->usg_calls));
		#endif

		return strlen(buf);
		return 0;
		}

		#if 0
		/* XXX too much output - exceeds 4k limit and needs to be re-written */
		static int
		sba_resource_map(char buf, char *start, off_t offset, int len)
		sba_proc_open(struct inode i, struct file f)
		{
		return single_open(f, &sba_proc_info, NULL);
		}

		static struct file_operations sba_proc_fops = {
		.owner = THIS_MODULE,
		.open = sba_proc_open,
		.read = seq_read,
		.llseek = seq_lseek,
		.release = single_release,
		};

		static int
		sba_proc_bitmap_info(struct seq_file m, void p)
		{
		struct sba_device *sba_dev = sba_list;
		struct ioc ioc = &sba_dev->ioc[0]; / FIXME: Mutli-IOC suppoer! */
		struct ioc ioc = &sba_dev->ioc[0]; / FIXME: Multi-IOC support! */
		unsigned int res_ptr = (unsigned int )ioc->res_map;
		int i;
		int i, len = 0;

		buf[0] = '\0';
		for (i = 0; i < (ioc->res_size/sizeof(unsigned int)); ++i, ++res_ptr) {
		if ((i & 7) == 0)
		strcat(buf,"\n ");
		sprintf(buf, "%s %08x", buf, *res_ptr);
		len += seq_printf(m, "\n ");
		len += seq_printf(m, " %08x", *res_ptr);
		}
		strcat(buf, "\n");
		len += seq_printf(m, "\n");

		return strlen(buf);
		return 0;
		}
		#endif /* 0 */

		static int
		sba_proc_bitmap_open(struct inode i, struct file f)
		{
		return single_open(f, &sba_proc_bitmap_info, NULL);
		}

		static struct file_operations sba_proc_bitmap_fops = {
		.owner = THIS_MODULE,
		.open = sba_proc_bitmap_open,
		.read = seq_read,
		.llseek = seq_lseek,
		.release = single_release,
		};
		#endif /* CONFIG_PROC_FS */

		static struct parisc_device_id sba_tbl[] = {
		@@ -2021,6 +2043,7 @@ sba_driver_callback(struct parisc_device *dev)
		int i;
		char *version;
		void __iomem *sba_addr = ioremap(dev->hpa.start, SBA_FUNC_SIZE);
		struct proc_dir_entry info_entry, bitmap_entry, *root;

		sba_dump_ranges(sba_addr);

		@@ -2088,19 +2111,27 @@ sba_driver_callback(struct parisc_device *dev)
		hppa_dma_ops = &sba_ops;

		#ifdef CONFIG_PROC_FS
		if (IS_ASTRO(&dev->id)) {
		create_proc_info_entry("Astro", 0, proc_runway_root, sba_proc_info);
		} else if (IS_IKE(&dev->id)) {
		create_proc_info_entry("Ike", 0, proc_runway_root, sba_proc_info);
		} else if (IS_PLUTO(&dev->id)) {
		create_proc_info_entry("Pluto", 0, proc_mckinley_root, sba_proc_info);
		} else {
		create_proc_info_entry("Reo", 0, proc_runway_root, sba_proc_info);
		switch (dev->id.hversion) {
		case PLUTO_MCKINLEY_PORT:
		root = proc_mckinley_root;
		break;
		case ASTRO_RUNWAY_PORT:
		case IKE_MERCED_PORT:
		default:
		root = proc_runway_root;
		break;
		}
		#if 0
		create_proc_info_entry("bitmap", 0, proc_runway_root, sba_resource_map);
		#endif

		info_entry = create_proc_entry("sba_iommu", 0, root);
		bitmap_entry = create_proc_entry("sba_iommu-bitmap", 0, root);

		if (info_entry)
		info_entry->proc_fops = &sba_proc_fops;

		if (bitmap_entry)
		bitmap_entry->proc_fops = &sba_proc_bitmap_fops;
		#endif

		parisc_vmerge_boundary = IOVP_SIZE;
		parisc_vmerge_max_size = IOVP_SIZE * BITS_PER_LONG;
		parisc_has_iommu();