Lines Matching +full:48 +full:- +full:bit
1 // SPDX-License-Identifier: GPL-2.0-or-later
23 * use the non-standard "short data" template so the decompressor can correctly
54 { I2, I2, D4, N0, 0x0f }, /* 48 */
55 { I2, D2, I2, D2, 0x0c }, /* 48 */
56 { I2, D4, I2, N0, 0x0b }, /* 48 */
57 { D2, I2, I2, D2, 0x07 }, /* 48 */
58 { D2, I2, D2, I2, 0x06 }, /* 48 */
59 { D4, I2, I2, N0, 0x03 }, /* 48 */
85 #define INDEX_NOT_FOUND (-1)
86 #define INDEX_NOT_CHECKED (-2)
94 u8 bit;
110 be##b##_to_cpu(get_unaligned((__be##b *)((p)->in + (o))))
114 hash_init((p)->htable##b); \
115 for (_i = 0; _i < ARRAY_SIZE((p)->node##b); _i++) { \
116 (p)->node##b[_i].index = _i; \
117 (p)->node##b[_i].data = 0; \
118 INIT_HLIST_NODE(&(p)->node##b[_i].node); \
124 p->index##b[n] = INDEX_NOT_FOUND; \
125 hash_for_each_possible(p->htable##b, _n, node, p->data##b[n]) { \
126 if (p->data##b[n] == _n->data) { \
127 p->index##b[n] = _n->index; \
131 p->index##b[n] >= 0; \
135 ((p)->index##b[n] == INDEX_NOT_CHECKED \
137 : (p)->index##b[n] >= 0)
140 struct sw842_hlist_node##b *_n = &(p)->node##b[(i)+(d)]; \
141 hash_del(&_n->node); \
142 _n->data = (p)->data##b[d]; \
144 (unsigned int)_n->index, \
145 (unsigned int)((p)->in - (p)->instart), \
146 (unsigned long)_n->data); \
147 hash_add((p)->htable##b, &_n->node, _n->data); \
159 return -EINVAL;
161 ret = add_bits(p, d >> s, n - s);
164 return add_bits(p, d & GENMASK_ULL(s - 1, 0), s);
169 int b = p->bit, bits = b + n, s = round_up(bits, 8) - bits;
171 u8 *out = p->out;
176 return -EINVAL;
178 /* split this up if writing to > 8 bytes (i.e. n == 64 && p->bit > 0),
183 else if (p->olen < 8 && bits > 32 && bits <= 56)
185 else if (p->olen < 4 && bits > 16 && bits <= 24)
188 if (DIV_ROUND_UP(bits, 8) > p->olen)
189 return -ENOSPC;
204 else if (bits <= 48)
211 p->bit += n;
213 if (p->bit > 7) {
214 p->out += p->bit / 8;
215 p->olen -= p->bit / 8;
216 p->bit %= 8;
229 return -EINVAL;
245 ret = add_bits(p, p->index8[0], I8_BITS);
247 ret = add_bits(p, p->data8[0], 64);
257 ret = add_bits(p, p->index4[b >> 2], I4_BITS);
259 ret = add_bits(p, p->data4[b >> 2], 32);
267 ret = add_bits(p, p->index2[b >> 1], I2_BITS);
269 ret = add_bits(p, p->data2[b >> 1], 16);
287 return -EINVAL;
296 return -EINVAL;
309 /* repeat param is 0-based */
310 if (!r || --r > REPEAT_BITS_MAX)
311 return -EINVAL;
332 return -EINVAL;
343 ret = add_bits(p, p->in[i], 8);
410 p->data8[0] = get_input_data(p, 0, 64);
411 p->data4[0] = get_input_data(p, 0, 32);
412 p->data4[1] = get_input_data(p, 4, 32);
413 p->data2[0] = get_input_data(p, 0, 16);
414 p->data2[1] = get_input_data(p, 2, 16);
415 p->data2[2] = get_input_data(p, 4, 16);
416 p->data2[3] = get_input_data(p, 6, 16);
425 u64 pos = p->in - p->instart;
440 * the p->dataN fields must already be set for the current 8 byte block
446 p->index8[0] = INDEX_NOT_CHECKED;
447 p->index4[0] = INDEX_NOT_CHECKED;
448 p->index4[1] = INDEX_NOT_CHECKED;
449 p->index2[0] = INDEX_NOT_CHECKED;
450 p->index2[1] = INDEX_NOT_CHECKED;
451 p->index2[2] = INDEX_NOT_CHECKED;
452 p->index2[3] = INDEX_NOT_CHECKED;
454 /* check up to OPS_MAX - 1; last op is our fallback */
455 for (i = 0; i < OPS_MAX - 1; i++) {
492 p->in = (u8 *)in;
493 p->instart = p->in;
494 p->ilen = ilen;
495 p->out = out;
496 p->olen = *olen;
497 p->bit = 0;
499 total = p->olen;
506 return -EINVAL;
514 last = ~get_unaligned((u64 *)p->in);
516 while (p->ilen > 7) {
517 next = get_unaligned((u64 *)p->in);
529 /* repeat count bits are 0-based, so we stop at +1 */
553 p->in += 8;
554 p->ilen -= 8;
564 if (p->ilen > 0) {
565 ret = add_short_data_template(p, p->ilen);
569 p->in += p->ilen;
570 p->ilen = 0;
579 * bit after End of stream template.
580 * nx842 calculates CRC for data in big-endian format. So doing
589 if (p->bit) {
590 p->out++;
591 p->olen--;
592 p->bit = 0;
596 pad = (8 - ((total - p->olen) % 8)) % 8;
598 if (pad > p->olen) /* we were so close! */
599 return -ENOSPC;
600 memset(p->out, 0, pad);
601 p->out += pad;
602 p->olen -= pad;
605 if (unlikely((total - p->olen) > UINT_MAX))
606 return -ENOSPC;
608 *olen = total - p->olen;