1 | /***********************license start************************************ |
2 | * Copyright (c) 2003-2017 Cavium, Inc. |
3 | * All rights reserved. |
4 | * |
5 | * License: one of 'Cavium License' or 'GNU General Public License Version 2' |
6 | * |
7 | * This file is provided under the terms of the Cavium License (see below) |
8 | * or under the terms of GNU General Public License, Version 2, as |
9 | * published by the Free Software Foundation. When using or redistributing |
10 | * this file, you may do so under either license. |
11 | * |
12 | * Cavium License: Redistribution and use in source and binary forms, with |
13 | * or without modification, are permitted provided that the following |
14 | * conditions are met: |
15 | * |
16 | * * Redistributions of source code must retain the above copyright |
17 | * notice, this list of conditions and the following disclaimer. |
18 | * |
19 | * * Redistributions in binary form must reproduce the above |
20 | * copyright notice, this list of conditions and the following |
21 | * disclaimer in the documentation and/or other materials provided |
22 | * with the distribution. |
23 | * |
24 | * * Neither the name of Cavium Inc. nor the names of its contributors may be |
25 | * used to endorse or promote products derived from this software without |
26 | * specific prior written permission. |
27 | * |
28 | * This Software, including technical data, may be subject to U.S. export |
29 | * control laws, including the U.S. Export Administration Act and its |
30 | * associated regulations, and may be subject to export or import |
31 | * regulations in other countries. |
32 | * |
33 | * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS" |
34 | * AND WITH ALL FAULTS AND CAVIUM INC. MAKES NO PROMISES, REPRESENTATIONS |
35 | * OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH |
36 | * RESPECT TO THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY |
37 | * REPRESENTATION OR DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT |
38 | * DEFECTS, AND CAVIUM SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY) |
39 | * WARRANTIES OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A |
40 | * PARTICULAR PURPOSE, LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET |
41 | * ENJOYMENT, QUIET POSSESSION OR CORRESPONDENCE TO DESCRIPTION. THE |
42 | * ENTIRE RISK ARISING OUT OF USE OR PERFORMANCE OF THE SOFTWARE LIES |
43 | * WITH YOU. |
44 | ***********************license end**************************************/ |
45 | |
46 | #include <linux/delay.h> |
47 | #include <linux/sched.h> |
48 | |
49 | #include "common.h" |
50 | #include "zip_inflate.h" |
51 | |
52 | static int prepare_inflate_zcmd(struct zip_operation *zip_ops, |
53 | struct zip_state *s, union zip_inst_s *zip_cmd) |
54 | { |
55 | union zip_zres_s *result_ptr = &s->result; |
56 | |
57 | memset(zip_cmd, 0, sizeof(s->zip_cmd)); |
58 | memset(result_ptr, 0, sizeof(s->result)); |
59 | |
60 | /* IWORD#0 */ |
61 | |
62 | /* Decompression History Gather list - no gather list */ |
63 | zip_cmd->s.hg = 0; |
64 | /* For decompression, CE must be 0x0. */ |
65 | zip_cmd->s.ce = 0; |
66 | /* For decompression, SS must be 0x0. */ |
67 | zip_cmd->s.ss = 0; |
68 | /* For decompression, SF should always be set. */ |
69 | zip_cmd->s.sf = 1; |
70 | |
71 | /* Begin File */ |
72 | if (zip_ops->begin_file == 0) |
73 | zip_cmd->s.bf = 0; |
74 | else |
75 | zip_cmd->s.bf = 1; |
76 | |
77 | zip_cmd->s.ef = 1; |
78 | /* 0: for Deflate decompression, 3: for LZS decompression */ |
79 | zip_cmd->s.cc = zip_ops->ccode; |
80 | |
81 | /* IWORD #1*/ |
82 | |
83 | /* adler checksum */ |
84 | zip_cmd->s.adlercrc32 = zip_ops->csum; |
85 | |
86 | /* |
87 | * HISTORYLENGTH must be 0x0 for any ZIP decompress operation. |
88 | * History data is added to a decompression operation via IWORD3. |
89 | */ |
90 | zip_cmd->s.historylength = 0; |
91 | zip_cmd->s.ds = 0; |
92 | |
93 | /* IWORD # 8 and 9 - Output pointer */ |
94 | zip_cmd->s.out_ptr_addr.s.addr = __pa(zip_ops->output); |
95 | zip_cmd->s.out_ptr_ctl.s.length = zip_ops->output_len; |
96 | |
97 | /* Maximum number of output-stream bytes that can be written */ |
98 | zip_cmd->s.totaloutputlength = zip_ops->output_len; |
99 | |
100 | zip_dbg("Data Direct Input case " ); |
101 | |
102 | /* IWORD # 6 and 7 - input pointer */ |
103 | zip_cmd->s.dg = 0; |
104 | zip_cmd->s.inp_ptr_addr.s.addr = __pa((u8 *)zip_ops->input); |
105 | zip_cmd->s.inp_ptr_ctl.s.length = zip_ops->input_len; |
106 | |
107 | /* IWORD # 10 and 11 - Result pointer */ |
108 | zip_cmd->s.res_ptr_addr.s.addr = __pa(result_ptr); |
109 | |
110 | /* Clearing completion code */ |
111 | result_ptr->s.compcode = 0; |
112 | |
113 | /* Returning 0 for time being.*/ |
114 | return 0; |
115 | } |
116 | |
117 | /** |
118 | * zip_inflate - API to offload inflate operation to hardware |
119 | * @zip_ops: Pointer to zip operation structure |
120 | * @s: Pointer to the structure representing zip state |
121 | * @zip_dev: Pointer to zip device structure |
122 | * |
123 | * This function prepares the zip inflate command and submits it to the zip |
124 | * engine for processing. |
125 | * |
126 | * Return: 0 if successful or error code |
127 | */ |
128 | int zip_inflate(struct zip_operation *zip_ops, struct zip_state *s, |
129 | struct zip_device *zip_dev) |
130 | { |
131 | union zip_inst_s *zip_cmd = &s->zip_cmd; |
132 | union zip_zres_s *result_ptr = &s->result; |
133 | u32 queue; |
134 | |
135 | /* Prepare inflate zip command */ |
136 | prepare_inflate_zcmd(zip_ops, s, zip_cmd); |
137 | |
138 | atomic64_add(i: zip_ops->input_len, v: &zip_dev->stats.decomp_in_bytes); |
139 | |
140 | /* Load inflate command to zip queue and ring the doorbell */ |
141 | queue = zip_load_instr(instr: zip_cmd, zip_dev); |
142 | |
143 | /* Decompression requests submitted stats update */ |
144 | atomic64_inc(v: &zip_dev->stats.decomp_req_submit); |
145 | |
146 | /* Wait for completion or error */ |
147 | zip_poll_result(result: result_ptr); |
148 | |
149 | /* Decompression requests completed stats update */ |
150 | atomic64_inc(v: &zip_dev->stats.decomp_req_complete); |
151 | |
152 | zip_ops->compcode = result_ptr->s.compcode; |
153 | switch (zip_ops->compcode) { |
154 | case ZIP_CMD_NOTDONE: |
155 | zip_dbg("Zip Instruction not yet completed\n" ); |
156 | return ZIP_ERROR; |
157 | |
158 | case ZIP_CMD_SUCCESS: |
159 | zip_dbg("Zip Instruction completed successfully\n" ); |
160 | break; |
161 | |
162 | case ZIP_CMD_DYNAMIC_STOP: |
163 | zip_dbg(" Dynamic stop Initiated\n" ); |
164 | break; |
165 | |
166 | default: |
167 | zip_dbg("Instruction failed. Code = %d\n" , zip_ops->compcode); |
168 | atomic64_inc(v: &zip_dev->stats.decomp_bad_reqs); |
169 | zip_update_cmd_bufs(zip_dev, queue); |
170 | return ZIP_ERROR; |
171 | } |
172 | |
173 | zip_update_cmd_bufs(zip_dev, queue); |
174 | |
175 | if ((zip_ops->ccode == 3) && (zip_ops->flush == 4) && |
176 | (zip_ops->compcode != ZIP_CMD_DYNAMIC_STOP)) |
177 | result_ptr->s.ef = 1; |
178 | |
179 | zip_ops->csum = result_ptr->s.adler32; |
180 | |
181 | atomic64_add(i: result_ptr->s.totalbyteswritten, |
182 | v: &zip_dev->stats.decomp_out_bytes); |
183 | |
184 | if (zip_ops->output_len < result_ptr->s.totalbyteswritten) { |
185 | zip_err("output_len (%d) < total bytes written (%d)\n" , |
186 | zip_ops->output_len, result_ptr->s.totalbyteswritten); |
187 | zip_ops->output_len = 0; |
188 | } else { |
189 | zip_ops->output_len = result_ptr->s.totalbyteswritten; |
190 | } |
191 | |
192 | zip_ops->bytes_read = result_ptr->s.totalbytesread; |
193 | zip_ops->bits_processed = result_ptr->s.totalbitsprocessed; |
194 | zip_ops->end_file = result_ptr->s.ef; |
195 | if (zip_ops->end_file) { |
196 | switch (zip_ops->format) { |
197 | case RAW_FORMAT: |
198 | zip_dbg("RAW Format: %d " , zip_ops->format); |
199 | /* Get checksum from engine */ |
200 | zip_ops->csum = result_ptr->s.adler32; |
201 | break; |
202 | |
203 | case ZLIB_FORMAT: |
204 | zip_dbg("ZLIB Format: %d " , zip_ops->format); |
205 | zip_ops->csum = result_ptr->s.adler32; |
206 | break; |
207 | |
208 | case GZIP_FORMAT: |
209 | zip_dbg("GZIP Format: %d " , zip_ops->format); |
210 | zip_ops->csum = result_ptr->s.crc32; |
211 | break; |
212 | |
213 | case LZS_FORMAT: |
214 | zip_dbg("LZS Format: %d " , zip_ops->format); |
215 | break; |
216 | |
217 | default: |
218 | zip_err("Format error:%d\n" , zip_ops->format); |
219 | } |
220 | } |
221 | |
222 | return 0; |
223 | } |
224 | |