1 files changed, 0 insertions, 199 deletions
diff --git a/drivers/scsi/isci/pool.h b/drivers/scsi/isci/pool.h
deleted file mode 100644
index 016ec832f74f..000000000000
--- a/drivers/scsi/isci/pool.h
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- * This file is provided under a dual BSD/GPLv2 license.  When using or
- * redistributing this file, you may do so under either license.
- *
- * GPL LICENSE SUMMARY
- *
- * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- * The full GNU General Public License is included in this distribution
- * in the file called LICENSE.GPL.
- *
- * BSD LICENSE
- *
- * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in
- *     the documentation and/or other materials provided with the
- *     distribution.
- *   * Neither the name of Intel Corporation nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-/**
- * This file contains the interface to the pool class. This class allows two
- *    different two different priority tasks to insert and remove items from
- *    the free pool. The user of the pool is expected to evaluate the pool
- *    condition empty before a get operation and pool condition full before a
- *    put operation. Methods Provided: - sci_pool_create() -
- *    sci_pool_initialize() - sci_pool_empty() - sci_pool_full() -
- *    sci_pool_get() - sci_pool_put()
- *
- *
- */
-#ifndef _SCI_POOL_H_
-#define _SCI_POOL_H_
-/**
- * SCI_POOL_INCREMENT() -
- *
- * Private operation for the pool
- */
-#define SCI_POOL_INCREMENT(pool, index) \
-        (((index) + 1) == (pool).size ? 0 : (index) + 1)
-/**
- * SCI_POOL_CREATE() -
- *
- * This creates a pool structure of pool_name. The members in the pool are of
- * type with number of elements equal to size.
- */
-#define SCI_POOL_CREATE(pool_name, type, pool_size) \
-        struct \
-        { \
-                u32 size; \
-                u32 get; \
-                u32 put; \
-                type array[(pool_size) + 1]; \
-        } pool_name
-/**
- * sci_pool_empty() -
- *
- * This macro evaluates the pool and returns true if the pool is empty. If the
- * pool is empty the user should not perform any get operation on the pool.
- */
-#define sci_pool_empty(pool) \
-        ((pool).get == (pool).put)
-/**
- * sci_pool_full() -
- *
- * This macro evaluates the pool and returns true if the pool is full.  If the
- * pool is full the user should not perform any put operation.
- */
-#define sci_pool_full(pool) \
-        (SCI_POOL_INCREMENT(pool, (pool).put) == (pool).get)
-/**
- * sci_pool_size() -
- *
- * This macro returns the size of the pool created.  The internal size of the
- * pool is actually 1 larger then necessary in order to ensure get and put
- * pointers can be written simultaneously by different users.  As a result,
- * this macro subtracts 1 from the internal size
- */
-#define sci_pool_size(pool) \
-        ((pool).size - 1)
-/**
- * sci_pool_count() -
- *
- * This macro indicates the number of elements currently contained in the pool.
- */
-#define sci_pool_count(pool) \
-        (\
-                sci_pool_empty((pool)) \
-                ? 0 \
-                : (\
-                        sci_pool_full((pool)) \
-                        ? sci_pool_size((pool)) \
-                        : (\
-                                (pool).get > (pool).put \
-                                ? ((pool).size - (pool).get + (pool).put) \
-                                : ((pool).put - (pool).get) \
-                                ) \
-                        ) \
-        )
-/**
- * sci_pool_initialize() -
- *
- * This macro initializes the pool to an empty condition.
- */
-#define sci_pool_initialize(pool) \
-        { \
-                (pool).size = (sizeof((pool).array) / sizeof((pool).array[0])); \
-                (pool).get = 0; \
-                (pool).put = 0; \
-        }
-/**
- * sci_pool_get() -
- *
- * This macro will get the next free element from the pool. This should only be
- * called if the pool is not empty.
- */
-#define sci_pool_get(pool, my_value) \
-        { \
-                (my_value) = (pool).array[(pool).get]; \
-                (pool).get = SCI_POOL_INCREMENT((pool), (pool).get); \
-        }
-/**
- * sci_pool_put() -
- *
- * This macro will put the value into the pool. This should only be called if
- * the pool is not full.
- */
-#define sci_pool_put(pool, value) \
-        { \
-                (pool).array[(pool).put] = (value); \
-                (pool).put = SCI_POOL_INCREMENT((pool), (pool).put); \
-        }
-/**
- * sci_pool_erase() -
- *
- * This macro will search the pool and remove any elements in the pool matching
- * the supplied value. This method can only be utilized on pools
- */
-#define sci_pool_erase(pool, type, value) \
-        { \
-                type tmp_value; \
-                u32 index; \
-                u32 element_count = sci_pool_count((pool)); \
- \
-                for (index = 0; index < element_count; index++) {       \
-                        sci_pool_get((pool), tmp_value); \
-                        if (tmp_value != (value)) \
-                                sci_pool_put((pool), tmp_value); \
-                } \
-        }
-#endif /* _SCI_POOL_H_ */

diff --git a/drivers/scsi/isci/pool.h b/drivers/scsi/isci/pool.h deleted file mode 100644 index 016ec832f74f..000000000000 --- a/drivers/scsi/isci/pool.h +++ /dev/null
@@ -1,199 +0,0 @@
1	/*
2	* This file is provided under a dual BSD/GPLv2 license. When using or
3	* redistributing this file, you may do so under either license.
4	*
5	* GPL LICENSE SUMMARY
6	*
7	* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
8	*
9	* This program is free software; you can redistribute it and/or modify
10	* it under the terms of version 2 of the GNU General Public License as
11	* published by the Free Software Foundation.
12	*
13	* This program is distributed in the hope that it will be useful, but
14	* WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16	* General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21	* The full GNU General Public License is included in this distribution
22	* in the file called LICENSE.GPL.
23	*
24	* BSD LICENSE
25	*
26	* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27	* All rights reserved.
28	*
29	* Redistribution and use in source and binary forms, with or without
30	* modification, are permitted provided that the following conditions
31	* are met:
32	*
33	* * Redistributions of source code must retain the above copyright
34	* notice, this list of conditions and the following disclaimer.
35	* * Redistributions in binary form must reproduce the above copyright
36	* notice, this list of conditions and the following disclaimer in
37	* the documentation and/or other materials provided with the
38	* distribution.
39	* * Neither the name of Intel Corporation nor the names of its
40	* contributors may be used to endorse or promote products derived
41	* from this software without specific prior written permission.
42	*
43	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
44	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
45	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
46	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
47	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
53	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54	*/
55
56	/**
57	* This file contains the interface to the pool class. This class allows two
58	* different two different priority tasks to insert and remove items from
59	* the free pool. The user of the pool is expected to evaluate the pool
60	* condition empty before a get operation and pool condition full before a
61	* put operation. Methods Provided: - sci_pool_create() -
62	* sci_pool_initialize() - sci_pool_empty() - sci_pool_full() -
63	* sci_pool_get() - sci_pool_put()
64	*
65	*
66	*/
67
68	#ifndef _SCI_POOL_H_
69	#define _SCI_POOL_H_
70
71	/**
72	* SCI_POOL_INCREMENT() -
73	*
74	* Private operation for the pool
75	*/
76	#define SCI_POOL_INCREMENT(pool, index) \
77	(((index) + 1) == (pool).size ? 0 : (index) + 1)
78
79	/**
80	* SCI_POOL_CREATE() -
81	*
82	* This creates a pool structure of pool_name. The members in the pool are of
83	* type with number of elements equal to size.
84	*/
85	#define SCI_POOL_CREATE(pool_name, type, pool_size) \
86	struct \
87	{ \
88	u32 size; \
89	u32 get; \
90	u32 put; \
91	type array[(pool_size) + 1]; \
92	} pool_name
93
94
95	/**
96	* sci_pool_empty() -
97	*
98	* This macro evaluates the pool and returns true if the pool is empty. If the
99	* pool is empty the user should not perform any get operation on the pool.
100	*/
101	#define sci_pool_empty(pool) \
102	((pool).get == (pool).put)
103
104	/**
105	* sci_pool_full() -
106	*
107	* This macro evaluates the pool and returns true if the pool is full. If the
108	* pool is full the user should not perform any put operation.
109	*/
110	#define sci_pool_full(pool) \
111	(SCI_POOL_INCREMENT(pool, (pool).put) == (pool).get)
112
113	/**
114	* sci_pool_size() -
115	*
116	* This macro returns the size of the pool created. The internal size of the
117	* pool is actually 1 larger then necessary in order to ensure get and put
118	* pointers can be written simultaneously by different users. As a result,
119	* this macro subtracts 1 from the internal size
120	*/
121	#define sci_pool_size(pool) \
122	((pool).size - 1)
123
124	/**
125	* sci_pool_count() -
126	*
127	* This macro indicates the number of elements currently contained in the pool.
128	*/
129	#define sci_pool_count(pool) \
130	(\
131	sci_pool_empty((pool)) \
132	? 0 \
133	: (\
134	sci_pool_full((pool)) \
135	? sci_pool_size((pool)) \
136	: (\
137	(pool).get > (pool).put \
138	? ((pool).size - (pool).get + (pool).put) \
139	: ((pool).put - (pool).get) \
140	) \
141	) \
142	)
143
144	/**
145	* sci_pool_initialize() -
146	*
147	* This macro initializes the pool to an empty condition.
148	*/
149	#define sci_pool_initialize(pool) \
150	{ \
151	(pool).size = (sizeof((pool).array) / sizeof((pool).array[0])); \
152	(pool).get = 0; \
153	(pool).put = 0; \
154	}
155
156	/**
157	* sci_pool_get() -
158	*
159	* This macro will get the next free element from the pool. This should only be
160	* called if the pool is not empty.
161	*/
162	#define sci_pool_get(pool, my_value) \
163	{ \
164	(my_value) = (pool).array[(pool).get]; \
165	(pool).get = SCI_POOL_INCREMENT((pool), (pool).get); \
166	}
167
168	/**
169	* sci_pool_put() -
170	*
171	* This macro will put the value into the pool. This should only be called if
172	* the pool is not full.
173	*/
174	#define sci_pool_put(pool, value) \
175	{ \
176	(pool).array[(pool).put] = (value); \
177	(pool).put = SCI_POOL_INCREMENT((pool), (pool).put); \
178	}
179
180	/**
181	* sci_pool_erase() -
182	*
183	* This macro will search the pool and remove any elements in the pool matching
184	* the supplied value. This method can only be utilized on pools
185	*/
186	#define sci_pool_erase(pool, type, value) \
187	{ \
188	type tmp_value; \
189	u32 index; \
190	u32 element_count = sci_pool_count((pool)); \
191	\
192	for (index = 0; index < element_count; index++) { \
193	sci_pool_get((pool), tmp_value); \
194	if (tmp_value != (value)) \
195	sci_pool_put((pool), tmp_value); \
196	} \
197	}
198
199	#endif /* _SCI_POOL_H_ */