aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/megaraid.c
diff options
context:
space:
mode:
authorDavid Howells <dhowells@redhat.com>2013-04-10 08:33:21 -0400
committerAl Viro <viro@zeniv.linux.org.uk>2013-04-29 15:41:57 -0400
commitc7f079ca30bc719f6f09524fb2119980c4b45d8f (patch)
tree5d657da7b6943b48bed2bce241673a94b9c57293 /drivers/scsi/megaraid.c
parent6bbefe86796c07fb8a6d28114f1e3f770586ba05 (diff)
megaraid: Don't use create_proc_read_entry()
Don't use create_proc_read_entry() as that is deprecated, but rather use proc_create_data() and seq_file instead. Signed-off-by: David Howells <dhowells@redhat.com> cc: Neela Syam Kolli <megaraidlinux@lsi.com> cc: James E.J. Bottomley <JBottomley@parallels.com> cc: linux-scsi@vger.kernel.org Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Diffstat (limited to 'drivers/scsi/megaraid.c')
-rw-r--r--drivers/scsi/megaraid.c1040
1 files changed, 382 insertions, 658 deletions
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index 9504ec0ec682..a1c90bd34e78 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -39,6 +39,7 @@
39#include <linux/completion.h> 39#include <linux/completion.h>
40#include <linux/delay.h> 40#include <linux/delay.h>
41#include <linux/proc_fs.h> 41#include <linux/proc_fs.h>
42#include <linux/seq_file.h>
42#include <linux/reboot.h> 43#include <linux/reboot.h>
43#include <linux/module.h> 44#include <linux/module.h>
44#include <linux/list.h> 45#include <linux/list.h>
@@ -2069,385 +2070,201 @@ mega_free_inquiry(void *inquiry, dma_addr_t dma_handle, struct pci_dev *pdev)
2069#ifdef CONFIG_PROC_FS 2070#ifdef CONFIG_PROC_FS
2070/* Following code handles /proc fs */ 2071/* Following code handles /proc fs */
2071 2072
2072#define CREATE_READ_PROC(string, func) create_proc_read_entry(string, \
2073 S_IRUSR | S_IFREG, \
2074 controller_proc_dir_entry, \
2075 func, adapter)
2076
2077/**
2078 * mega_create_proc_entry()
2079 * @index - index in soft state array
2080 * @parent - parent node for this /proc entry
2081 *
2082 * Creates /proc entries for our controllers.
2083 */
2084static void
2085mega_create_proc_entry(int index, struct proc_dir_entry *parent)
2086{
2087 struct proc_dir_entry *controller_proc_dir_entry = NULL;
2088 u8 string[64] = { 0 };
2089 adapter_t *adapter = hba_soft_state[index];
2090
2091 sprintf(string, "hba%d", adapter->host->host_no);
2092
2093 controller_proc_dir_entry =
2094 adapter->controller_proc_dir_entry = proc_mkdir(string, parent);
2095
2096 if(!controller_proc_dir_entry) {
2097 printk(KERN_WARNING "\nmegaraid: proc_mkdir failed\n");
2098 return;
2099 }
2100 adapter->proc_read = CREATE_READ_PROC("config", proc_read_config);
2101 adapter->proc_stat = CREATE_READ_PROC("stat", proc_read_stat);
2102 adapter->proc_mbox = CREATE_READ_PROC("mailbox", proc_read_mbox);
2103#if MEGA_HAVE_ENH_PROC
2104 adapter->proc_rr = CREATE_READ_PROC("rebuild-rate", proc_rebuild_rate);
2105 adapter->proc_battery = CREATE_READ_PROC("battery-status",
2106 proc_battery);
2107
2108 /*
2109 * Display each physical drive on its channel
2110 */
2111 adapter->proc_pdrvstat[0] = CREATE_READ_PROC("diskdrives-ch0",
2112 proc_pdrv_ch0);
2113 adapter->proc_pdrvstat[1] = CREATE_READ_PROC("diskdrives-ch1",
2114 proc_pdrv_ch1);
2115 adapter->proc_pdrvstat[2] = CREATE_READ_PROC("diskdrives-ch2",
2116 proc_pdrv_ch2);
2117 adapter->proc_pdrvstat[3] = CREATE_READ_PROC("diskdrives-ch3",
2118 proc_pdrv_ch3);
2119
2120 /*
2121 * Display a set of up to 10 logical drive through each of following
2122 * /proc entries
2123 */
2124 adapter->proc_rdrvstat[0] = CREATE_READ_PROC("raiddrives-0-9",
2125 proc_rdrv_10);
2126 adapter->proc_rdrvstat[1] = CREATE_READ_PROC("raiddrives-10-19",
2127 proc_rdrv_20);
2128 adapter->proc_rdrvstat[2] = CREATE_READ_PROC("raiddrives-20-29",
2129 proc_rdrv_30);
2130 adapter->proc_rdrvstat[3] = CREATE_READ_PROC("raiddrives-30-39",
2131 proc_rdrv_40);
2132#endif
2133}
2134
2135
2136/** 2073/**
2137 * proc_read_config() 2074 * proc_show_config()
2138 * @page - buffer to write the data in 2075 * @m - Synthetic file construction data
2139 * @start - where the actual data has been written in page 2076 * @v - File iterator
2140 * @offset - same meaning as the read system call
2141 * @count - same meaning as the read system call
2142 * @eof - set if no more data needs to be returned
2143 * @data - pointer to our soft state
2144 * 2077 *
2145 * Display configuration information about the controller. 2078 * Display configuration information about the controller.
2146 */ 2079 */
2147static int 2080static int
2148proc_read_config(char *page, char **start, off_t offset, int count, int *eof, 2081proc_show_config(struct seq_file *m, void *v)
2149 void *data)
2150{ 2082{
2151 2083
2152 adapter_t *adapter = (adapter_t *)data; 2084 adapter_t *adapter = m->private;
2153 int len = 0;
2154
2155 len += sprintf(page+len, "%s", MEGARAID_VERSION);
2156 2085
2086 seq_puts(m, MEGARAID_VERSION);
2157 if(adapter->product_info.product_name[0]) 2087 if(adapter->product_info.product_name[0])
2158 len += sprintf(page+len, "%s\n", 2088 seq_printf(m, "%s\n", adapter->product_info.product_name);
2159 adapter->product_info.product_name);
2160
2161 len += sprintf(page+len, "Controller Type: ");
2162 2089
2163 if( adapter->flag & BOARD_MEMMAP ) { 2090 seq_puts(m, "Controller Type: ");
2164 len += sprintf(page+len,
2165 "438/466/467/471/493/518/520/531/532\n");
2166 }
2167 else {
2168 len += sprintf(page+len,
2169 "418/428/434\n");
2170 }
2171 2091
2172 if(adapter->flag & BOARD_40LD) { 2092 if( adapter->flag & BOARD_MEMMAP )
2173 len += sprintf(page+len, 2093 seq_puts(m, "438/466/467/471/493/518/520/531/532\n");
2174 "Controller Supports 40 Logical Drives\n"); 2094 else
2175 } 2095 seq_puts(m, "418/428/434\n");
2176 2096
2177 if(adapter->flag & BOARD_64BIT) { 2097 if(adapter->flag & BOARD_40LD)
2178 len += sprintf(page+len, 2098 seq_puts(m, "Controller Supports 40 Logical Drives\n");
2179 "Controller capable of 64-bit memory addressing\n");
2180 }
2181 if( adapter->has_64bit_addr ) {
2182 len += sprintf(page+len,
2183 "Controller using 64-bit memory addressing\n");
2184 }
2185 else {
2186 len += sprintf(page+len,
2187 "Controller is not using 64-bit memory addressing\n");
2188 }
2189 2099
2190 len += sprintf(page+len, "Base = %08lx, Irq = %d, ", adapter->base, 2100 if(adapter->flag & BOARD_64BIT)
2191 adapter->host->irq); 2101 seq_puts(m, "Controller capable of 64-bit memory addressing\n");
2192 2102 if( adapter->has_64bit_addr )
2193 len += sprintf(page+len, "Logical Drives = %d, Channels = %d\n", 2103 seq_puts(m, "Controller using 64-bit memory addressing\n");
2194 adapter->numldrv, adapter->product_info.nchannels); 2104 else
2195 2105 seq_puts(m, "Controller is not using 64-bit memory addressing\n");
2196 len += sprintf(page+len, "Version =%s:%s, DRAM = %dMb\n", 2106
2197 adapter->fw_version, adapter->bios_version, 2107 seq_printf(m, "Base = %08lx, Irq = %d, ",
2198 adapter->product_info.dram_size); 2108 adapter->base, adapter->host->irq);
2199 2109
2200 len += sprintf(page+len, 2110 seq_printf(m, "Logical Drives = %d, Channels = %d\n",
2201 "Controller Queue Depth = %d, Driver Queue Depth = %d\n", 2111 adapter->numldrv, adapter->product_info.nchannels);
2202 adapter->product_info.max_commands, adapter->max_cmds); 2112
2203 2113 seq_printf(m, "Version =%s:%s, DRAM = %dMb\n",
2204 len += sprintf(page+len, "support_ext_cdb = %d\n", 2114 adapter->fw_version, adapter->bios_version,
2205 adapter->support_ext_cdb); 2115 adapter->product_info.dram_size);
2206 len += sprintf(page+len, "support_random_del = %d\n", 2116
2207 adapter->support_random_del); 2117 seq_printf(m, "Controller Queue Depth = %d, Driver Queue Depth = %d\n",
2208 len += sprintf(page+len, "boot_ldrv_enabled = %d\n", 2118 adapter->product_info.max_commands, adapter->max_cmds);
2209 adapter->boot_ldrv_enabled); 2119
2210 len += sprintf(page+len, "boot_ldrv = %d\n", 2120 seq_printf(m, "support_ext_cdb = %d\n", adapter->support_ext_cdb);
2211 adapter->boot_ldrv); 2121 seq_printf(m, "support_random_del = %d\n", adapter->support_random_del);
2212 len += sprintf(page+len, "boot_pdrv_enabled = %d\n", 2122 seq_printf(m, "boot_ldrv_enabled = %d\n", adapter->boot_ldrv_enabled);
2213 adapter->boot_pdrv_enabled); 2123 seq_printf(m, "boot_ldrv = %d\n", adapter->boot_ldrv);
2214 len += sprintf(page+len, "boot_pdrv_ch = %d\n", 2124 seq_printf(m, "boot_pdrv_enabled = %d\n", adapter->boot_pdrv_enabled);
2215 adapter->boot_pdrv_ch); 2125 seq_printf(m, "boot_pdrv_ch = %d\n", adapter->boot_pdrv_ch);
2216 len += sprintf(page+len, "boot_pdrv_tgt = %d\n", 2126 seq_printf(m, "boot_pdrv_tgt = %d\n", adapter->boot_pdrv_tgt);
2217 adapter->boot_pdrv_tgt); 2127 seq_printf(m, "quiescent = %d\n",
2218 len += sprintf(page+len, "quiescent = %d\n", 2128 atomic_read(&adapter->quiescent));
2219 atomic_read(&adapter->quiescent)); 2129 seq_printf(m, "has_cluster = %d\n", adapter->has_cluster);
2220 len += sprintf(page+len, "has_cluster = %d\n", 2130
2221 adapter->has_cluster); 2131 seq_puts(m, "\nModule Parameters:\n");
2222 2132 seq_printf(m, "max_cmd_per_lun = %d\n", max_cmd_per_lun);
2223 len += sprintf(page+len, "\nModule Parameters:\n"); 2133 seq_printf(m, "max_sectors_per_io = %d\n", max_sectors_per_io);
2224 len += sprintf(page+len, "max_cmd_per_lun = %d\n", 2134 return 0;
2225 max_cmd_per_lun);
2226 len += sprintf(page+len, "max_sectors_per_io = %d\n",
2227 max_sectors_per_io);
2228
2229 *eof = 1;
2230
2231 return len;
2232} 2135}
2233 2136
2234
2235
2236/** 2137/**
2237 * proc_read_stat() 2138 * proc_show_stat()
2238 * @page - buffer to write the data in 2139 * @m - Synthetic file construction data
2239 * @start - where the actual data has been written in page 2140 * @v - File iterator
2240 * @offset - same meaning as the read system call
2241 * @count - same meaning as the read system call
2242 * @eof - set if no more data needs to be returned
2243 * @data - pointer to our soft state
2244 * 2141 *
2245 * Diaplay statistical information about the I/O activity. 2142 * Display statistical information about the I/O activity.
2246 */ 2143 */
2247static int 2144static int
2248proc_read_stat(char *page, char **start, off_t offset, int count, int *eof, 2145proc_show_stat(struct seq_file *m, void *v)
2249 void *data)
2250{ 2146{
2251 adapter_t *adapter; 2147 adapter_t *adapter = m->private;
2252 int len; 2148#if MEGA_HAVE_STATS
2253 int i; 2149 int i;
2150#endif
2254 2151
2255 i = 0; /* avoid compilation warnings */ 2152 seq_puts(m, "Statistical Information for this controller\n");
2256 len = 0; 2153 seq_printf(m, "pend_cmds = %d\n", atomic_read(&adapter->pend_cmds));
2257 adapter = (adapter_t *)data;
2258
2259 len = sprintf(page, "Statistical Information for this controller\n");
2260 len += sprintf(page+len, "pend_cmds = %d\n",
2261 atomic_read(&adapter->pend_cmds));
2262#if MEGA_HAVE_STATS 2154#if MEGA_HAVE_STATS
2263 for(i = 0; i < adapter->numldrv; i++) { 2155 for(i = 0; i < adapter->numldrv; i++) {
2264 len += sprintf(page+len, "Logical Drive %d:\n", i); 2156 seq_printf(m, "Logical Drive %d:\n", i);
2265 2157 seq_printf(m, "\tReads Issued = %lu, Writes Issued = %lu\n",
2266 len += sprintf(page+len, 2158 adapter->nreads[i], adapter->nwrites[i]);
2267 "\tReads Issued = %lu, Writes Issued = %lu\n", 2159 seq_printf(m, "\tSectors Read = %lu, Sectors Written = %lu\n",
2268 adapter->nreads[i], adapter->nwrites[i]); 2160 adapter->nreadblocks[i], adapter->nwriteblocks[i]);
2269 2161 seq_printf(m, "\tRead errors = %lu, Write errors = %lu\n\n",
2270 len += sprintf(page+len, 2162 adapter->rd_errors[i], adapter->wr_errors[i]);
2271 "\tSectors Read = %lu, Sectors Written = %lu\n",
2272 adapter->nreadblocks[i], adapter->nwriteblocks[i]);
2273
2274 len += sprintf(page+len,
2275 "\tRead errors = %lu, Write errors = %lu\n\n",
2276 adapter->rd_errors[i], adapter->wr_errors[i]);
2277 } 2163 }
2278#else 2164#else
2279 len += sprintf(page+len, 2165 seq_puts(m, "IO and error counters not compiled in driver.\n");
2280 "IO and error counters not compiled in driver.\n");
2281#endif 2166#endif
2282 2167 return 0;
2283 *eof = 1;
2284
2285 return len;
2286} 2168}
2287 2169
2288 2170
2289/** 2171/**
2290 * proc_read_mbox() 2172 * proc_show_mbox()
2291 * @page - buffer to write the data in 2173 * @m - Synthetic file construction data
2292 * @start - where the actual data has been written in page 2174 * @v - File iterator
2293 * @offset - same meaning as the read system call
2294 * @count - same meaning as the read system call
2295 * @eof - set if no more data needs to be returned
2296 * @data - pointer to our soft state
2297 * 2175 *
2298 * Display mailbox information for the last command issued. This information 2176 * Display mailbox information for the last command issued. This information
2299 * is good for debugging. 2177 * is good for debugging.
2300 */ 2178 */
2301static int 2179static int
2302proc_read_mbox(char *page, char **start, off_t offset, int count, int *eof, 2180proc_show_mbox(struct seq_file *m, void *v)
2303 void *data)
2304{ 2181{
2305 2182 adapter_t *adapter = m->private;
2306 adapter_t *adapter = (adapter_t *)data;
2307 volatile mbox_t *mbox = adapter->mbox; 2183 volatile mbox_t *mbox = adapter->mbox;
2308 int len = 0; 2184
2309 2185 seq_puts(m, "Contents of Mail Box Structure\n");
2310 len = sprintf(page, "Contents of Mail Box Structure\n"); 2186 seq_printf(m, " Fw Command = 0x%02x\n", mbox->m_out.cmd);
2311 len += sprintf(page+len, " Fw Command = 0x%02x\n", 2187 seq_printf(m, " Cmd Sequence = 0x%02x\n", mbox->m_out.cmdid);
2312 mbox->m_out.cmd); 2188 seq_printf(m, " No of Sectors= %04d\n", mbox->m_out.numsectors);
2313 len += sprintf(page+len, " Cmd Sequence = 0x%02x\n", 2189 seq_printf(m, " LBA = 0x%02x\n", mbox->m_out.lba);
2314 mbox->m_out.cmdid); 2190 seq_printf(m, " DTA = 0x%08x\n", mbox->m_out.xferaddr);
2315 len += sprintf(page+len, " No of Sectors= %04d\n", 2191 seq_printf(m, " Logical Drive= 0x%02x\n", mbox->m_out.logdrv);
2316 mbox->m_out.numsectors); 2192 seq_printf(m, " No of SG Elmt= 0x%02x\n", mbox->m_out.numsgelements);
2317 len += sprintf(page+len, " LBA = 0x%02x\n", 2193 seq_printf(m, " Busy = %01x\n", mbox->m_in.busy);
2318 mbox->m_out.lba); 2194 seq_printf(m, " Status = 0x%02x\n", mbox->m_in.status);
2319 len += sprintf(page+len, " DTA = 0x%08x\n", 2195 return 0;
2320 mbox->m_out.xferaddr);
2321 len += sprintf(page+len, " Logical Drive= 0x%02x\n",
2322 mbox->m_out.logdrv);
2323 len += sprintf(page+len, " No of SG Elmt= 0x%02x\n",
2324 mbox->m_out.numsgelements);
2325 len += sprintf(page+len, " Busy = %01x\n",
2326 mbox->m_in.busy);
2327 len += sprintf(page+len, " Status = 0x%02x\n",
2328 mbox->m_in.status);
2329
2330 *eof = 1;
2331
2332 return len;
2333} 2196}
2334 2197
2335 2198
2336/** 2199/**
2337 * proc_rebuild_rate() 2200 * proc_show_rebuild_rate()
2338 * @page - buffer to write the data in 2201 * @m - Synthetic file construction data
2339 * @start - where the actual data has been written in page 2202 * @v - File iterator
2340 * @offset - same meaning as the read system call
2341 * @count - same meaning as the read system call
2342 * @eof - set if no more data needs to be returned
2343 * @data - pointer to our soft state
2344 * 2203 *
2345 * Display current rebuild rate 2204 * Display current rebuild rate
2346 */ 2205 */
2347static int 2206static int
2348proc_rebuild_rate(char *page, char **start, off_t offset, int count, int *eof, 2207proc_show_rebuild_rate(struct seq_file *m, void *v)
2349 void *data)
2350{ 2208{
2351 adapter_t *adapter = (adapter_t *)data; 2209 adapter_t *adapter = m->private;
2352 dma_addr_t dma_handle; 2210 dma_addr_t dma_handle;
2353 caddr_t inquiry; 2211 caddr_t inquiry;
2354 struct pci_dev *pdev; 2212 struct pci_dev *pdev;
2355 int len = 0;
2356 2213
2357 if( make_local_pdev(adapter, &pdev) != 0 ) { 2214 if( make_local_pdev(adapter, &pdev) != 0 )
2358 *eof = 1; 2215 return 0;
2359 return len;
2360 }
2361 2216
2362 if( (inquiry = mega_allocate_inquiry(&dma_handle, pdev)) == NULL ) { 2217 if( (inquiry = mega_allocate_inquiry(&dma_handle, pdev)) == NULL )
2363 free_local_pdev(pdev); 2218 goto free_pdev;
2364 *eof = 1;
2365 return len;
2366 }
2367 2219
2368 if( mega_adapinq(adapter, dma_handle) != 0 ) { 2220 if( mega_adapinq(adapter, dma_handle) != 0 ) {
2369 2221 seq_puts(m, "Adapter inquiry failed.\n");
2370 len = sprintf(page, "Adapter inquiry failed.\n");
2371
2372 printk(KERN_WARNING "megaraid: inquiry failed.\n"); 2222 printk(KERN_WARNING "megaraid: inquiry failed.\n");
2373 2223 goto free_inquiry;
2374 mega_free_inquiry(inquiry, dma_handle, pdev);
2375
2376 free_local_pdev(pdev);
2377
2378 *eof = 1;
2379
2380 return len;
2381 } 2224 }
2382 2225
2383 if( adapter->flag & BOARD_40LD ) { 2226 if( adapter->flag & BOARD_40LD )
2384 len = sprintf(page, "Rebuild Rate: [%d%%]\n", 2227 seq_printf(m, "Rebuild Rate: [%d%%]\n",
2385 ((mega_inquiry3 *)inquiry)->rebuild_rate); 2228 ((mega_inquiry3 *)inquiry)->rebuild_rate);
2386 } 2229 else
2387 else { 2230 seq_printf(m, "Rebuild Rate: [%d%%]\n",
2388 len = sprintf(page, "Rebuild Rate: [%d%%]\n",
2389 ((mraid_ext_inquiry *) 2231 ((mraid_ext_inquiry *)
2390 inquiry)->raid_inq.adapter_info.rebuild_rate); 2232 inquiry)->raid_inq.adapter_info.rebuild_rate);
2391 }
2392
2393 2233
2234free_inquiry:
2394 mega_free_inquiry(inquiry, dma_handle, pdev); 2235 mega_free_inquiry(inquiry, dma_handle, pdev);
2395 2236free_pdev:
2396 free_local_pdev(pdev); 2237 free_local_pdev(pdev);
2397 2238 return 0;
2398 *eof = 1;
2399
2400 return len;
2401} 2239}
2402 2240
2403 2241
2404/** 2242/**
2405 * proc_battery() 2243 * proc_show_battery()
2406 * @page - buffer to write the data in 2244 * @m - Synthetic file construction data
2407 * @start - where the actual data has been written in page 2245 * @v - File iterator
2408 * @offset - same meaning as the read system call
2409 * @count - same meaning as the read system call
2410 * @eof - set if no more data needs to be returned
2411 * @data - pointer to our soft state
2412 * 2246 *
2413 * Display information about the battery module on the controller. 2247 * Display information about the battery module on the controller.
2414 */ 2248 */
2415static int 2249static int
2416proc_battery(char *page, char **start, off_t offset, int count, int *eof, 2250proc_show_battery(struct seq_file *m, void *v)
2417 void *data)
2418{ 2251{
2419 adapter_t *adapter = (adapter_t *)data; 2252 adapter_t *adapter = m->private;
2420 dma_addr_t dma_handle; 2253 dma_addr_t dma_handle;
2421 caddr_t inquiry; 2254 caddr_t inquiry;
2422 struct pci_dev *pdev; 2255 struct pci_dev *pdev;
2423 u8 battery_status = 0; 2256 u8 battery_status;
2424 char str[256];
2425 int len = 0;
2426 2257
2427 if( make_local_pdev(adapter, &pdev) != 0 ) { 2258 if( make_local_pdev(adapter, &pdev) != 0 )
2428 *eof = 1; 2259 return 0;
2429 return len;
2430 }
2431 2260
2432 if( (inquiry = mega_allocate_inquiry(&dma_handle, pdev)) == NULL ) { 2261 if( (inquiry = mega_allocate_inquiry(&dma_handle, pdev)) == NULL )
2433 free_local_pdev(pdev); 2262 goto free_pdev;
2434 *eof = 1;
2435 return len;
2436 }
2437 2263
2438 if( mega_adapinq(adapter, dma_handle) != 0 ) { 2264 if( mega_adapinq(adapter, dma_handle) != 0 ) {
2439 2265 seq_printf(m, "Adapter inquiry failed.\n");
2440 len = sprintf(page, "Adapter inquiry failed.\n");
2441
2442 printk(KERN_WARNING "megaraid: inquiry failed.\n"); 2266 printk(KERN_WARNING "megaraid: inquiry failed.\n");
2443 2267 goto free_inquiry;
2444 mega_free_inquiry(inquiry, dma_handle, pdev);
2445
2446 free_local_pdev(pdev);
2447
2448 *eof = 1;
2449
2450 return len;
2451 } 2268 }
2452 2269
2453 if( adapter->flag & BOARD_40LD ) { 2270 if( adapter->flag & BOARD_40LD ) {
@@ -2461,146 +2278,80 @@ proc_battery(char *page, char **start, off_t offset, int count, int *eof,
2461 /* 2278 /*
2462 * Decode the battery status 2279 * Decode the battery status
2463 */ 2280 */
2464 sprintf(str, "Battery Status:[%d]", battery_status); 2281 seq_printf(m, "Battery Status:[%d]", battery_status);
2465 2282
2466 if(battery_status == MEGA_BATT_CHARGE_DONE) 2283 if(battery_status == MEGA_BATT_CHARGE_DONE)
2467 strcat(str, " Charge Done"); 2284 seq_puts(m, " Charge Done");
2468 2285
2469 if(battery_status & MEGA_BATT_MODULE_MISSING) 2286 if(battery_status & MEGA_BATT_MODULE_MISSING)
2470 strcat(str, " Module Missing"); 2287 seq_puts(m, " Module Missing");
2471 2288
2472 if(battery_status & MEGA_BATT_LOW_VOLTAGE) 2289 if(battery_status & MEGA_BATT_LOW_VOLTAGE)
2473 strcat(str, " Low Voltage"); 2290 seq_puts(m, " Low Voltage");
2474 2291
2475 if(battery_status & MEGA_BATT_TEMP_HIGH) 2292 if(battery_status & MEGA_BATT_TEMP_HIGH)
2476 strcat(str, " Temperature High"); 2293 seq_puts(m, " Temperature High");
2477 2294
2478 if(battery_status & MEGA_BATT_PACK_MISSING) 2295 if(battery_status & MEGA_BATT_PACK_MISSING)
2479 strcat(str, " Pack Missing"); 2296 seq_puts(m, " Pack Missing");
2480 2297
2481 if(battery_status & MEGA_BATT_CHARGE_INPROG) 2298 if(battery_status & MEGA_BATT_CHARGE_INPROG)
2482 strcat(str, " Charge In-progress"); 2299 seq_puts(m, " Charge In-progress");
2483 2300
2484 if(battery_status & MEGA_BATT_CHARGE_FAIL) 2301 if(battery_status & MEGA_BATT_CHARGE_FAIL)
2485 strcat(str, " Charge Fail"); 2302 seq_puts(m, " Charge Fail");
2486 2303
2487 if(battery_status & MEGA_BATT_CYCLES_EXCEEDED) 2304 if(battery_status & MEGA_BATT_CYCLES_EXCEEDED)
2488 strcat(str, " Cycles Exceeded"); 2305 seq_puts(m, " Cycles Exceeded");
2489
2490 len = sprintf(page, "%s\n", str);
2491 2306
2307 seq_putc(m, '\n');
2492 2308
2309free_inquiry:
2493 mega_free_inquiry(inquiry, dma_handle, pdev); 2310 mega_free_inquiry(inquiry, dma_handle, pdev);
2494 2311free_pdev:
2495 free_local_pdev(pdev); 2312 free_local_pdev(pdev);
2496 2313 return 0;
2497 *eof = 1;
2498
2499 return len;
2500}
2501
2502
2503/**
2504 * proc_pdrv_ch0()
2505 * @page - buffer to write the data in
2506 * @start - where the actual data has been written in page
2507 * @offset - same meaning as the read system call
2508 * @count - same meaning as the read system call
2509 * @eof - set if no more data needs to be returned
2510 * @data - pointer to our soft state
2511 *
2512 * Display information about the physical drives on physical channel 0.
2513 */
2514static int
2515proc_pdrv_ch0(char *page, char **start, off_t offset, int count, int *eof,
2516 void *data)
2517{
2518 adapter_t *adapter = (adapter_t *)data;
2519
2520 *eof = 1;
2521
2522 return (proc_pdrv(adapter, page, 0));
2523}
2524
2525
2526/**
2527 * proc_pdrv_ch1()
2528 * @page - buffer to write the data in
2529 * @start - where the actual data has been written in page
2530 * @offset - same meaning as the read system call
2531 * @count - same meaning as the read system call
2532 * @eof - set if no more data needs to be returned
2533 * @data - pointer to our soft state
2534 *
2535 * Display information about the physical drives on physical channel 1.
2536 */
2537static int
2538proc_pdrv_ch1(char *page, char **start, off_t offset, int count, int *eof,
2539 void *data)
2540{
2541 adapter_t *adapter = (adapter_t *)data;
2542
2543 *eof = 1;
2544
2545 return (proc_pdrv(adapter, page, 1));
2546} 2314}
2547 2315
2548 2316
2549/** 2317/*
2550 * proc_pdrv_ch2() 2318 * Display scsi inquiry
2551 * @page - buffer to write the data in
2552 * @start - where the actual data has been written in page
2553 * @offset - same meaning as the read system call
2554 * @count - same meaning as the read system call
2555 * @eof - set if no more data needs to be returned
2556 * @data - pointer to our soft state
2557 *
2558 * Display information about the physical drives on physical channel 2.
2559 */ 2319 */
2560static int 2320static void
2561proc_pdrv_ch2(char *page, char **start, off_t offset, int count, int *eof, 2321mega_print_inquiry(struct seq_file *m, char *scsi_inq)
2562 void *data)
2563{ 2322{
2564 adapter_t *adapter = (adapter_t *)data; 2323 int i;
2565
2566 *eof = 1;
2567
2568 return (proc_pdrv(adapter, page, 2));
2569}
2570 2324
2325 seq_puts(m, " Vendor: ");
2326 seq_write(m, scsi_inq + 8, 8);
2327 seq_puts(m, " Model: ");
2328 seq_write(m, scsi_inq + 16, 16);
2329 seq_puts(m, " Rev: ");
2330 seq_write(m, scsi_inq + 32, 4);
2331 seq_putc(m, '\n');
2571 2332
2572/** 2333 i = scsi_inq[0] & 0x1f;
2573 * proc_pdrv_ch3() 2334 seq_printf(m, " Type: %s ", scsi_device_type(i));
2574 * @page - buffer to write the data in
2575 * @start - where the actual data has been written in page
2576 * @offset - same meaning as the read system call
2577 * @count - same meaning as the read system call
2578 * @eof - set if no more data needs to be returned
2579 * @data - pointer to our soft state
2580 *
2581 * Display information about the physical drives on physical channel 3.
2582 */
2583static int
2584proc_pdrv_ch3(char *page, char **start, off_t offset, int count, int *eof,
2585 void *data)
2586{
2587 adapter_t *adapter = (adapter_t *)data;
2588 2335
2589 *eof = 1; 2336 seq_printf(m, " ANSI SCSI revision: %02x",
2337 scsi_inq[2] & 0x07);
2590 2338
2591 return (proc_pdrv(adapter, page, 3)); 2339 if( (scsi_inq[2] & 0x07) == 1 && (scsi_inq[3] & 0x0f) == 1 )
2340 seq_puts(m, " CCS\n");
2341 else
2342 seq_putc(m, '\n');
2592} 2343}
2593 2344
2594
2595/** 2345/**
2596 * proc_pdrv() 2346 * proc_show_pdrv()
2347 * @m - Synthetic file construction data
2597 * @page - buffer to write the data in 2348 * @page - buffer to write the data in
2598 * @adapter - pointer to our soft state 2349 * @adapter - pointer to our soft state
2599 * 2350 *
2600 * Display information about the physical drives. 2351 * Display information about the physical drives.
2601 */ 2352 */
2602static int 2353static int
2603proc_pdrv(adapter_t *adapter, char *page, int channel) 2354proc_show_pdrv(struct seq_file *m, adapter_t *adapter, int channel)
2604{ 2355{
2605 dma_addr_t dma_handle; 2356 dma_addr_t dma_handle;
2606 char *scsi_inq; 2357 char *scsi_inq;
@@ -2611,32 +2362,24 @@ proc_pdrv(adapter_t *adapter, char *page, int channel)
2611 u8 state; 2362 u8 state;
2612 int tgt; 2363 int tgt;
2613 int max_channels; 2364 int max_channels;
2614 int len = 0;
2615 char str[80];
2616 int i; 2365 int i;
2617 2366
2618 if( make_local_pdev(adapter, &pdev) != 0 ) { 2367 if( make_local_pdev(adapter, &pdev) != 0 )
2619 return len; 2368 return 0;
2620 }
2621 2369
2622 if( (inquiry = mega_allocate_inquiry(&dma_handle, pdev)) == NULL ) { 2370 if( (inquiry = mega_allocate_inquiry(&dma_handle, pdev)) == NULL )
2623 goto free_pdev; 2371 goto free_pdev;
2624 }
2625 2372
2626 if( mega_adapinq(adapter, dma_handle) != 0 ) { 2373 if( mega_adapinq(adapter, dma_handle) != 0 ) {
2627 len = sprintf(page, "Adapter inquiry failed.\n"); 2374 seq_puts(m, "Adapter inquiry failed.\n");
2628
2629 printk(KERN_WARNING "megaraid: inquiry failed.\n"); 2375 printk(KERN_WARNING "megaraid: inquiry failed.\n");
2630
2631 goto free_inquiry; 2376 goto free_inquiry;
2632 } 2377 }
2633 2378
2634 2379
2635 scsi_inq = pci_alloc_consistent(pdev, 256, &scsi_inq_dma_handle); 2380 scsi_inq = pci_alloc_consistent(pdev, 256, &scsi_inq_dma_handle);
2636
2637 if( scsi_inq == NULL ) { 2381 if( scsi_inq == NULL ) {
2638 len = sprintf(page, "memory not available for scsi inq.\n"); 2382 seq_puts(m, "memory not available for scsi inq.\n");
2639
2640 goto free_inquiry; 2383 goto free_inquiry;
2641 } 2384 }
2642 2385
@@ -2659,39 +2402,31 @@ proc_pdrv(adapter_t *adapter, char *page, int channel)
2659 i = channel*16 + tgt; 2402 i = channel*16 + tgt;
2660 2403
2661 state = *(pdrv_state + i); 2404 state = *(pdrv_state + i);
2662
2663 switch( state & 0x0F ) { 2405 switch( state & 0x0F ) {
2664
2665 case PDRV_ONLINE: 2406 case PDRV_ONLINE:
2666 sprintf(str, 2407 seq_printf(m, "Channel:%2d Id:%2d State: Online",
2667 "Channel:%2d Id:%2d State: Online", 2408 channel, tgt);
2668 channel, tgt);
2669 break; 2409 break;
2670 2410
2671 case PDRV_FAILED: 2411 case PDRV_FAILED:
2672 sprintf(str, 2412 seq_printf(m, "Channel:%2d Id:%2d State: Failed",
2673 "Channel:%2d Id:%2d State: Failed", 2413 channel, tgt);
2674 channel, tgt);
2675 break; 2414 break;
2676 2415
2677 case PDRV_RBLD: 2416 case PDRV_RBLD:
2678 sprintf(str, 2417 seq_printf(m, "Channel:%2d Id:%2d State: Rebuild",
2679 "Channel:%2d Id:%2d State: Rebuild", 2418 channel, tgt);
2680 channel, tgt);
2681 break; 2419 break;
2682 2420
2683 case PDRV_HOTSPARE: 2421 case PDRV_HOTSPARE:
2684 sprintf(str, 2422 seq_printf(m, "Channel:%2d Id:%2d State: Hot spare",
2685 "Channel:%2d Id:%2d State: Hot spare", 2423 channel, tgt);
2686 channel, tgt);
2687 break; 2424 break;
2688 2425
2689 default: 2426 default:
2690 sprintf(str, 2427 seq_printf(m, "Channel:%2d Id:%2d State: Un-configured",
2691 "Channel:%2d Id:%2d State: Un-configured", 2428 channel, tgt);
2692 channel, tgt);
2693 break; 2429 break;
2694
2695 } 2430 }
2696 2431
2697 /* 2432 /*
@@ -2710,11 +2445,8 @@ proc_pdrv(adapter_t *adapter, char *page, int channel)
2710 * Check for overflow. We print less than 240 2445 * Check for overflow. We print less than 240
2711 * characters for inquiry 2446 * characters for inquiry
2712 */ 2447 */
2713 if( (len + 240) >= PAGE_SIZE ) break; 2448 seq_puts(m, ".\n");
2714 2449 mega_print_inquiry(m, scsi_inq);
2715 len += sprintf(page+len, "%s.\n", str);
2716
2717 len += mega_print_inquiry(page+len, scsi_inq);
2718 } 2450 }
2719 2451
2720free_pci: 2452free_pci:
@@ -2723,150 +2455,68 @@ free_inquiry:
2723 mega_free_inquiry(inquiry, dma_handle, pdev); 2455 mega_free_inquiry(inquiry, dma_handle, pdev);
2724free_pdev: 2456free_pdev:
2725 free_local_pdev(pdev); 2457 free_local_pdev(pdev);
2726 2458 return 0;
2727 return len;
2728}
2729
2730
2731/*
2732 * Display scsi inquiry
2733 */
2734static int
2735mega_print_inquiry(char *page, char *scsi_inq)
2736{
2737 int len = 0;
2738 int i;
2739
2740 len = sprintf(page, " Vendor: ");
2741 for( i = 8; i < 16; i++ ) {
2742 len += sprintf(page+len, "%c", scsi_inq[i]);
2743 }
2744
2745 len += sprintf(page+len, " Model: ");
2746
2747 for( i = 16; i < 32; i++ ) {
2748 len += sprintf(page+len, "%c", scsi_inq[i]);
2749 }
2750
2751 len += sprintf(page+len, " Rev: ");
2752
2753 for( i = 32; i < 36; i++ ) {
2754 len += sprintf(page+len, "%c", scsi_inq[i]);
2755 }
2756
2757 len += sprintf(page+len, "\n");
2758
2759 i = scsi_inq[0] & 0x1f;
2760
2761 len += sprintf(page+len, " Type: %s ", scsi_device_type(i));
2762
2763 len += sprintf(page+len,
2764 " ANSI SCSI revision: %02x", scsi_inq[2] & 0x07);
2765
2766 if( (scsi_inq[2] & 0x07) == 1 && (scsi_inq[3] & 0x0f) == 1 )
2767 len += sprintf(page+len, " CCS\n");
2768 else
2769 len += sprintf(page+len, "\n");
2770
2771 return len;
2772} 2459}
2773 2460
2774
2775/** 2461/**
2776 * proc_rdrv_10() 2462 * proc_show_pdrv_ch0()
2777 * @page - buffer to write the data in 2463 * @m - Synthetic file construction data
2778 * @start - where the actual data has been written in page 2464 * @v - File iterator
2779 * @offset - same meaning as the read system call
2780 * @count - same meaning as the read system call
2781 * @eof - set if no more data needs to be returned
2782 * @data - pointer to our soft state
2783 * 2465 *
2784 * Display real time information about the logical drives 0 through 9. 2466 * Display information about the physical drives on physical channel 0.
2785 */ 2467 */
2786static int 2468static int
2787proc_rdrv_10(char *page, char **start, off_t offset, int count, int *eof, 2469proc_show_pdrv_ch0(struct seq_file *m, void *v)
2788 void *data)
2789{ 2470{
2790 adapter_t *adapter = (adapter_t *)data; 2471 return proc_show_pdrv(m, m->private, 0);
2791
2792 *eof = 1;
2793
2794 return (proc_rdrv(adapter, page, 0, 9));
2795} 2472}
2796 2473
2797 2474
2798/** 2475/**
2799 * proc_rdrv_20() 2476 * proc_show_pdrv_ch1()
2800 * @page - buffer to write the data in 2477 * @m - Synthetic file construction data
2801 * @start - where the actual data has been written in page 2478 * @v - File iterator
2802 * @offset - same meaning as the read system call
2803 * @count - same meaning as the read system call
2804 * @eof - set if no more data needs to be returned
2805 * @data - pointer to our soft state
2806 * 2479 *
2807 * Display real time information about the logical drives 0 through 9. 2480 * Display information about the physical drives on physical channel 1.
2808 */ 2481 */
2809static int 2482static int
2810proc_rdrv_20(char *page, char **start, off_t offset, int count, int *eof, 2483proc_show_pdrv_ch1(struct seq_file *m, void *v)
2811 void *data)
2812{ 2484{
2813 adapter_t *adapter = (adapter_t *)data; 2485 return proc_show_pdrv(m, m->private, 1);
2814
2815 *eof = 1;
2816
2817 return (proc_rdrv(adapter, page, 10, 19));
2818} 2486}
2819 2487
2820 2488
2821/** 2489/**
2822 * proc_rdrv_30() 2490 * proc_show_pdrv_ch2()
2823 * @page - buffer to write the data in 2491 * @m - Synthetic file construction data
2824 * @start - where the actual data has been written in page 2492 * @v - File iterator
2825 * @offset - same meaning as the read system call
2826 * @count - same meaning as the read system call
2827 * @eof - set if no more data needs to be returned
2828 * @data - pointer to our soft state
2829 * 2493 *
2830 * Display real time information about the logical drives 0 through 9. 2494 * Display information about the physical drives on physical channel 2.
2831 */ 2495 */
2832static int 2496static int
2833proc_rdrv_30(char *page, char **start, off_t offset, int count, int *eof, 2497proc_show_pdrv_ch2(struct seq_file *m, void *v)
2834 void *data)
2835{ 2498{
2836 adapter_t *adapter = (adapter_t *)data; 2499 return proc_show_pdrv(m, m->private, 2);
2837
2838 *eof = 1;
2839
2840 return (proc_rdrv(adapter, page, 20, 29));
2841} 2500}
2842 2501
2843 2502
2844/** 2503/**
2845 * proc_rdrv_40() 2504 * proc_show_pdrv_ch3()
2846 * @page - buffer to write the data in 2505 * @m - Synthetic file construction data
2847 * @start - where the actual data has been written in page 2506 * @v - File iterator
2848 * @offset - same meaning as the read system call
2849 * @count - same meaning as the read system call
2850 * @eof - set if no more data needs to be returned
2851 * @data - pointer to our soft state
2852 * 2507 *
2853 * Display real time information about the logical drives 0 through 9. 2508 * Display information about the physical drives on physical channel 3.
2854 */ 2509 */
2855static int 2510static int
2856proc_rdrv_40(char *page, char **start, off_t offset, int count, int *eof, 2511proc_show_pdrv_ch3(struct seq_file *m, void *v)
2857 void *data)
2858{ 2512{
2859 adapter_t *adapter = (adapter_t *)data; 2513 return proc_show_pdrv(m, m->private, 3);
2860
2861 *eof = 1;
2862
2863 return (proc_rdrv(adapter, page, 30, 39));
2864} 2514}
2865 2515
2866 2516
2867/** 2517/**
2868 * proc_rdrv() 2518 * proc_show_rdrv()
2869 * @page - buffer to write the data in 2519 * @m - Synthetic file construction data
2870 * @adapter - pointer to our soft state 2520 * @adapter - pointer to our soft state
2871 * @start - starting logical drive to display 2521 * @start - starting logical drive to display
2872 * @end - ending logical drive to display 2522 * @end - ending logical drive to display
@@ -2875,7 +2525,7 @@ proc_rdrv_40(char *page, char **start, off_t offset, int count, int *eof,
2875 * /proc/scsi/scsi interface 2525 * /proc/scsi/scsi interface
2876 */ 2526 */
2877static int 2527static int
2878proc_rdrv(adapter_t *adapter, char *page, int start, int end ) 2528proc_show_rdrv(struct seq_file *m, adapter_t *adapter, int start, int end )
2879{ 2529{
2880 dma_addr_t dma_handle; 2530 dma_addr_t dma_handle;
2881 logdrv_param *lparam; 2531 logdrv_param *lparam;
@@ -2887,29 +2537,18 @@ proc_rdrv(adapter_t *adapter, char *page, int start, int end )
2887 u8 *rdrv_state; 2537 u8 *rdrv_state;
2888 int num_ldrv; 2538 int num_ldrv;
2889 u32 array_sz; 2539 u32 array_sz;
2890 int len = 0;
2891 int i; 2540 int i;
2892 2541
2893 if( make_local_pdev(adapter, &pdev) != 0 ) { 2542 if( make_local_pdev(adapter, &pdev) != 0 )
2894 return len; 2543 return 0;
2895 }
2896 2544
2897 if( (inquiry = mega_allocate_inquiry(&dma_handle, pdev)) == NULL ) { 2545 if( (inquiry = mega_allocate_inquiry(&dma_handle, pdev)) == NULL )
2898 free_local_pdev(pdev); 2546 goto free_pdev;
2899 return len;
2900 }
2901 2547
2902 if( mega_adapinq(adapter, dma_handle) != 0 ) { 2548 if( mega_adapinq(adapter, dma_handle) != 0 ) {
2903 2549 seq_puts(m, "Adapter inquiry failed.\n");
2904 len = sprintf(page, "Adapter inquiry failed.\n");
2905
2906 printk(KERN_WARNING "megaraid: inquiry failed.\n"); 2550 printk(KERN_WARNING "megaraid: inquiry failed.\n");
2907 2551 goto free_inquiry;
2908 mega_free_inquiry(inquiry, dma_handle, pdev);
2909
2910 free_local_pdev(pdev);
2911
2912 return len;
2913 } 2552 }
2914 2553
2915 memset(&mc, 0, sizeof(megacmd_t)); 2554 memset(&mc, 0, sizeof(megacmd_t));
@@ -2935,13 +2574,8 @@ proc_rdrv(adapter_t *adapter, char *page, int start, int end )
2935 &disk_array_dma_handle); 2574 &disk_array_dma_handle);
2936 2575
2937 if( disk_array == NULL ) { 2576 if( disk_array == NULL ) {
2938 len = sprintf(page, "memory not available.\n"); 2577 seq_puts(m, "memory not available.\n");
2939 2578 goto free_inquiry;
2940 mega_free_inquiry(inquiry, dma_handle, pdev);
2941
2942 free_local_pdev(pdev);
2943
2944 return len;
2945 } 2579 }
2946 2580
2947 mc.xferaddr = (u32)disk_array_dma_handle; 2581 mc.xferaddr = (u32)disk_array_dma_handle;
@@ -2951,17 +2585,8 @@ proc_rdrv(adapter_t *adapter, char *page, int start, int end )
2951 mc.opcode = OP_DCMD_READ_CONFIG; 2585 mc.opcode = OP_DCMD_READ_CONFIG;
2952 2586
2953 if( mega_internal_command(adapter, &mc, NULL) ) { 2587 if( mega_internal_command(adapter, &mc, NULL) ) {
2954 2588 seq_puts(m, "40LD read config failed.\n");
2955 len = sprintf(page, "40LD read config failed.\n"); 2589 goto free_pci;
2956
2957 mega_free_inquiry(inquiry, dma_handle, pdev);
2958
2959 pci_free_consistent(pdev, array_sz, disk_array,
2960 disk_array_dma_handle);
2961
2962 free_local_pdev(pdev);
2963
2964 return len;
2965 } 2590 }
2966 2591
2967 } 2592 }
@@ -2969,24 +2594,10 @@ proc_rdrv(adapter_t *adapter, char *page, int start, int end )
2969 mc.cmd = NEW_READ_CONFIG_8LD; 2594 mc.cmd = NEW_READ_CONFIG_8LD;
2970 2595
2971 if( mega_internal_command(adapter, &mc, NULL) ) { 2596 if( mega_internal_command(adapter, &mc, NULL) ) {
2972
2973 mc.cmd = READ_CONFIG_8LD; 2597 mc.cmd = READ_CONFIG_8LD;
2974 2598 if( mega_internal_command(adapter, &mc, NULL) ) {
2975 if( mega_internal_command(adapter, &mc, 2599 seq_puts(m, "8LD read config failed.\n");
2976 NULL) ){ 2600 goto free_pci;
2977
2978 len = sprintf(page,
2979 "8LD read config failed.\n");
2980
2981 mega_free_inquiry(inquiry, dma_handle, pdev);
2982
2983 pci_free_consistent(pdev, array_sz,
2984 disk_array,
2985 disk_array_dma_handle);
2986
2987 free_local_pdev(pdev);
2988
2989 return len;
2990 } 2601 }
2991 } 2602 }
2992 } 2603 }
@@ -3006,29 +2617,23 @@ proc_rdrv(adapter_t *adapter, char *page, int start, int end )
3006 * Check for overflow. We print less than 240 characters for 2617 * Check for overflow. We print less than 240 characters for
3007 * information about each logical drive. 2618 * information about each logical drive.
3008 */ 2619 */
3009 if( (len + 240) >= PAGE_SIZE ) break; 2620 seq_printf(m, "Logical drive:%2d:, ", i);
3010
3011 len += sprintf(page+len, "Logical drive:%2d:, ", i);
3012 2621
3013 switch( rdrv_state[i] & 0x0F ) { 2622 switch( rdrv_state[i] & 0x0F ) {
3014 case RDRV_OFFLINE: 2623 case RDRV_OFFLINE:
3015 len += sprintf(page+len, "state: offline"); 2624 seq_puts(m, "state: offline");
3016 break; 2625 break;
3017
3018 case RDRV_DEGRADED: 2626 case RDRV_DEGRADED:
3019 len += sprintf(page+len, "state: degraded"); 2627 seq_puts(m, "state: degraded");
3020 break; 2628 break;
3021
3022 case RDRV_OPTIMAL: 2629 case RDRV_OPTIMAL:
3023 len += sprintf(page+len, "state: optimal"); 2630 seq_puts(m, "state: optimal");
3024 break; 2631 break;
3025
3026 case RDRV_DELETED: 2632 case RDRV_DELETED:
3027 len += sprintf(page+len, "state: deleted"); 2633 seq_puts(m, "state: deleted");
3028 break; 2634 break;
3029
3030 default: 2635 default:
3031 len += sprintf(page+len, "state: unknown"); 2636 seq_puts(m, "state: unknown");
3032 break; 2637 break;
3033 } 2638 }
3034 2639
@@ -3036,84 +2641,203 @@ proc_rdrv(adapter_t *adapter, char *page, int start, int end )
3036 * Check if check consistency or initialization is going on 2641 * Check if check consistency or initialization is going on
3037 * for this logical drive. 2642 * for this logical drive.
3038 */ 2643 */
3039 if( (rdrv_state[i] & 0xF0) == 0x20 ) { 2644 if( (rdrv_state[i] & 0xF0) == 0x20 )
3040 len += sprintf(page+len, 2645 seq_puts(m, ", check-consistency in progress");
3041 ", check-consistency in progress"); 2646 else if( (rdrv_state[i] & 0xF0) == 0x10 )
3042 } 2647 seq_puts(m, ", initialization in progress");
3043 else if( (rdrv_state[i] & 0xF0) == 0x10 ) {
3044 len += sprintf(page+len,
3045 ", initialization in progress");
3046 }
3047 2648
3048 len += sprintf(page+len, "\n"); 2649 seq_putc(m, '\n');
3049
3050 len += sprintf(page+len, "Span depth:%3d, ",
3051 lparam->span_depth);
3052
3053 len += sprintf(page+len, "RAID level:%3d, ",
3054 lparam->level);
3055
3056 len += sprintf(page+len, "Stripe size:%3d, ",
3057 lparam->stripe_sz ? lparam->stripe_sz/2: 128);
3058
3059 len += sprintf(page+len, "Row size:%3d\n",
3060 lparam->row_size);
3061 2650
2651 seq_printf(m, "Span depth:%3d, ", lparam->span_depth);
2652 seq_printf(m, "RAID level:%3d, ", lparam->level);
2653 seq_printf(m, "Stripe size:%3d, ",
2654 lparam->stripe_sz ? lparam->stripe_sz/2: 128);
2655 seq_printf(m, "Row size:%3d\n", lparam->row_size);
3062 2656
3063 len += sprintf(page+len, "Read Policy: "); 2657 seq_puts(m, "Read Policy: ");
3064
3065 switch(lparam->read_ahead) { 2658 switch(lparam->read_ahead) {
3066
3067 case NO_READ_AHEAD: 2659 case NO_READ_AHEAD:
3068 len += sprintf(page+len, "No read ahead, "); 2660 seq_puts(m, "No read ahead, ");
3069 break; 2661 break;
3070
3071 case READ_AHEAD: 2662 case READ_AHEAD:
3072 len += sprintf(page+len, "Read ahead, "); 2663 seq_puts(m, "Read ahead, ");
3073 break; 2664 break;
3074
3075 case ADAP_READ_AHEAD: 2665 case ADAP_READ_AHEAD:
3076 len += sprintf(page+len, "Adaptive, "); 2666 seq_puts(m, "Adaptive, ");
3077 break; 2667 break;
3078 2668
3079 } 2669 }
3080 2670
3081 len += sprintf(page+len, "Write Policy: "); 2671 seq_puts(m, "Write Policy: ");
3082
3083 switch(lparam->write_mode) { 2672 switch(lparam->write_mode) {
3084
3085 case WRMODE_WRITE_THRU: 2673 case WRMODE_WRITE_THRU:
3086 len += sprintf(page+len, "Write thru, "); 2674 seq_puts(m, "Write thru, ");
3087 break; 2675 break;
3088
3089 case WRMODE_WRITE_BACK: 2676 case WRMODE_WRITE_BACK:
3090 len += sprintf(page+len, "Write back, "); 2677 seq_puts(m, "Write back, ");
3091 break; 2678 break;
3092 } 2679 }
3093 2680
3094 len += sprintf(page+len, "Cache Policy: "); 2681 seq_puts(m, "Cache Policy: ");
3095
3096 switch(lparam->direct_io) { 2682 switch(lparam->direct_io) {
3097
3098 case CACHED_IO: 2683 case CACHED_IO:
3099 len += sprintf(page+len, "Cached IO\n\n"); 2684 seq_puts(m, "Cached IO\n\n");
3100 break; 2685 break;
3101
3102 case DIRECT_IO: 2686 case DIRECT_IO:
3103 len += sprintf(page+len, "Direct IO\n\n"); 2687 seq_puts(m, "Direct IO\n\n");
3104 break; 2688 break;
3105 } 2689 }
3106 } 2690 }
3107 2691
3108 mega_free_inquiry(inquiry, dma_handle, pdev); 2692free_pci:
3109
3110 pci_free_consistent(pdev, array_sz, disk_array, 2693 pci_free_consistent(pdev, array_sz, disk_array,
3111 disk_array_dma_handle); 2694 disk_array_dma_handle);
3112 2695free_inquiry:
2696 mega_free_inquiry(inquiry, dma_handle, pdev);
2697free_pdev:
3113 free_local_pdev(pdev); 2698 free_local_pdev(pdev);
2699 return 0;
2700}
2701
2702/**
2703 * proc_show_rdrv_10()
2704 * @m - Synthetic file construction data
2705 * @v - File iterator
2706 *
2707 * Display real time information about the logical drives 0 through 9.
2708 */
2709static int
2710proc_show_rdrv_10(struct seq_file *m, void *v)
2711{
2712 return proc_show_rdrv(m, m->private, 0, 9);
2713}
3114 2714
3115 return len; 2715
2716/**
2717 * proc_show_rdrv_20()
2718 * @m - Synthetic file construction data
2719 * @v - File iterator
2720 *
2721 * Display real time information about the logical drives 0 through 9.
2722 */
2723static int
2724proc_show_rdrv_20(struct seq_file *m, void *v)
2725{
2726 return proc_show_rdrv(m, m->private, 10, 19);
2727}
2728
2729
2730/**
2731 * proc_show_rdrv_30()
2732 * @m - Synthetic file construction data
2733 * @v - File iterator
2734 *
2735 * Display real time information about the logical drives 0 through 9.
2736 */
2737static int
2738proc_show_rdrv_30(struct seq_file *m, void *v)
2739{
2740 return proc_show_rdrv(m, m->private, 20, 29);
3116} 2741}
2742
2743
2744/**
2745 * proc_show_rdrv_40()
2746 * @m - Synthetic file construction data
2747 * @v - File iterator
2748 *
2749 * Display real time information about the logical drives 0 through 9.
2750 */
2751static int
2752proc_show_rdrv_40(struct seq_file *m, void *v)
2753{
2754 return proc_show_rdrv(m, m->private, 30, 39);
2755}
2756
2757
2758/*
2759 * seq_file wrappers for procfile show routines.
2760 */
2761static int mega_proc_open(struct inode *inode, struct file *file)
2762{
2763 adapter_t *adapter = PDE(inode)->parent->data;
2764 int (*show)(struct seq_file *, void *) = PDE_DATA(inode);
2765
2766 return single_open(file, show, adapter);
2767}
2768
2769static const struct file_operations mega_proc_fops = {
2770 .open = mega_proc_open,
2771 .read = seq_read,
2772 .llseek = seq_lseek,
2773 .release = seq_release,
2774};
2775
2776/*
2777 * Table of proc files we need to create.
2778 */
2779struct mega_proc_file {
2780 const char *name;
2781 unsigned short ptr_offset;
2782 int (*show) (struct seq_file *m, void *v);
2783};
2784
2785static const struct mega_proc_file mega_proc_files[] = {
2786 { "config", offsetof(adapter_t, proc_read), proc_show_config },
2787 { "stat", offsetof(adapter_t, proc_stat), proc_show_stat },
2788 { "mailbox", offsetof(adapter_t, proc_mbox), proc_show_mbox },
2789#if MEGA_HAVE_ENH_PROC
2790 { "rebuild-rate", offsetof(adapter_t, proc_rr), proc_show_rebuild_rate },
2791 { "battery-status", offsetof(adapter_t, proc_battery), proc_show_battery },
2792 { "diskdrives-ch0", offsetof(adapter_t, proc_pdrvstat[0]), proc_show_pdrv_ch0 },
2793 { "diskdrives-ch1", offsetof(adapter_t, proc_pdrvstat[1]), proc_show_pdrv_ch1 },
2794 { "diskdrives-ch2", offsetof(adapter_t, proc_pdrvstat[2]), proc_show_pdrv_ch2 },
2795 { "diskdrives-ch3", offsetof(adapter_t, proc_pdrvstat[3]), proc_show_pdrv_ch3 },
2796 { "raiddrives-0-9", offsetof(adapter_t, proc_rdrvstat[0]), proc_show_rdrv_10 },
2797 { "raiddrives-10-19", offsetof(adapter_t, proc_rdrvstat[1]), proc_show_rdrv_20 },
2798 { "raiddrives-20-29", offsetof(adapter_t, proc_rdrvstat[2]), proc_show_rdrv_30 },
2799 { "raiddrives-30-39", offsetof(adapter_t, proc_rdrvstat[3]), proc_show_rdrv_40 },
2800#endif
2801 { NULL }
2802};
2803
2804/**
2805 * mega_create_proc_entry()
2806 * @index - index in soft state array
2807 * @parent - parent node for this /proc entry
2808 *
2809 * Creates /proc entries for our controllers.
2810 */
2811static void
2812mega_create_proc_entry(int index, struct proc_dir_entry *parent)
2813{
2814 const struct mega_proc_file *f;
2815 adapter_t *adapter = hba_soft_state[index];
2816 struct proc_dir_entry *dir, *de, **ppde;
2817 u8 string[16];
2818
2819 sprintf(string, "hba%d", adapter->host->host_no);
2820
2821 dir = adapter->controller_proc_dir_entry = proc_mkdir(string, parent);
2822 if(!dir) {
2823 printk(KERN_WARNING "\nmegaraid: proc_mkdir failed\n");
2824 return;
2825 }
2826 dir->data = adapter;
2827
2828 for (f = mega_proc_files; f->name; f++) {
2829 de = proc_create_data(f->name, S_IRUSR, dir, &mega_proc_fops,
2830 f->show);
2831 if (!de) {
2832 printk(KERN_WARNING "\nmegaraid: proc_create failed\n");
2833 return;
2834 }
2835
2836 ppde = (void *)adapter + f->ptr_offset;
2837 *ppde = de;
2838 }
2839}
2840
3117#else 2841#else
3118static inline void mega_create_proc_entry(int index, struct proc_dir_entry *parent) 2842static inline void mega_create_proc_entry(int index, struct proc_dir_entry *parent)
3119{ 2843{
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-24 10:17:44 -0500