Remove now unused scrypt files.

SCRYPT-README

@@ -1,242 +0,0 @@
-While BTC donations are preferred, if you wish to donate to the author, Con
-Kolivas, in LTC, please submit your donations to:
-
-Lc8TWMiKM7gRUrG8VB8pPNP1Yvt1SGZnoH
-
-Otherwise, please donate in BTC as per the main README.
-
----
-
-Scrypt mining, AKA litecoin mining, for GPU is completely different to sha256
-used for bitcoin mining. The algorithm was originally developed in a manner
-that it was anticipated would make it suitable for mining on CPU but NOT GPU.
-Thanks to some innovative work by Artforz and mtrlt, this was proven to be
-wrong. However, it has very different requirements to bitcoin mining and is a
-lot more complicated to get working well. Note that it is a ram dependent
-workload, and requires you to have enough system ram as well as fast enough
-GPU ram. If you have less system ram than your GPU has, it may not be possible
-to mine at any reasonable rate.
-
-There are 5 main parameters to tuning scrypt, all of which are optional for
-further fine tuning. When you start scrypt mining with the --scrypt option,
-cgminer will fail IN RANDOM WAYS. They are all due to parameters being outside
-what the GPU can cope with.
-
-NOTE that if it does not fail at startup, the presence of hardware errors (HW)
-are a sure sign that you have set the parameters too high.
-
-
-DRIVERS AND OPENCL SDK
-
-The choice of driver version for your GPU is critical, as some are known to
-break scrypt mining entirely while others give poor hashrates. As for the
-OpenCL SDK installed, for AMD it must be version 2.6 or later.
-
-
-Step 1 on linux:
-export GPU_MAX_ALLOC_PERCENT=100
-If you do not do this, you may find it impossible to scrypt mine. You may find
-a value of 40 is enough and increasing this further has little effect.
-
-export GPU_USE_SYNC_OBJECTS=1
-may help CPU usage a little as well.
-
-On windows the same commands can be passed via a batch file if the following
-lines are in the .bat before starting cgminer:
-setx GPU_MAX_ALLOC_PERCENT 100
-setx GPU_USE_SYNC_OBJECTS 1
-
---intensity XX (-I XX)
-
-Just like in bitcoin mining, scrypt mining takes an intensity, however the
-scale goes from 0 to 20 to mimic the "Aggression" used in mtrlt's reaper. The
-reason this is crucial is that too high an intensity can actually be
-disastrous with scrypt because it CAN run out of ram. High intensities
-start writing over the same ram and it is highly dependent on the GPU, but they
-can start actually DECREASING your hashrate, or even worse, start producing
-garbage with HW errors skyrocketing. Note that if you do NOT specify an
-intensity, cgminer uses dynamic mode which is designed to minimise the harm
-to a running desktop and performance WILL be poor. The lower limit to intensity
-with scrypt is usually 8 and cgminer will prevent it going too low.
-SUMMARY: Setting this for reasonable hashrates is mandatory.
-
---shaders XXX
-
-is a new option where you tell cgminer how many shaders your GPU has. This
-helps cgminer try to choose some meaningful baseline parameters. Use this table
-below to determine how many shaders your GPU has, and note that there are some
-variants of these cards, and nvidia shaders are much much lower and virtually
-pointless trying to mine on. If this is not set, cgminer will query the
-device for how much memory it supports and will try to set a value based on
-that.
-SUMMARY: This will get you started but fine tuning for optimal performance is
-required.
-
-GPU  Shaders
-7750 512
-7770 640
-7850 1024
-7870 1280
-7950 1792
-7970 2048
-
-6850 960
-6870 1120
-6950 1408
-6970 1536
-6990 (6970x2)
-
-6570 480
-6670 480
-6790 800
-
-6450 160
-
-5670 400
-5750 720
-5770 800
-5830 1120
-5850 1440
-5870 1600
-5970 (5870x2)
-
-These are only used as a rough guide for cgminer, and it is rare that this is
-all you will need to set.
-
-
-Optional parameters to tune:
--g, --thread-concurrency, --lookup-gap
-
---thread-concurrency:
-This tunes the optimal size of work that scrypt can do. It is internally tuned
-by cgminer to be the highest reasonable multiple of shaders that it can
-allocate on your GPU. Ideally it should be a multiple of your shader count.
-vliw5 architecture (R5XXX) would be best at 5x shaders, while VLIW4 (R6xxx and
-R7xxx) are best at 4x. Setting thread concurrency overrides anything you put
-into --shaders and is ultimately a BETTER way to tune performance.
-SUMMARY: Spend lots of time finding the highest value that your device likes
-and increases hashrate.
-
--g:
-Once you have found the optimal shaders and intensity, you can start increasing
-the -g value till cgminer fails to start. This is really only of value if you
-want to run low intensities as you will be unable to run more than 1.
-SUMMARY: Don't touch this.
-
---lookup-gap
-This tunes a compromise between ram usage and performance. Performance peaks
-at a gap of 2, but increasing the gap can save you some GPU ram, but almost
-always at the cost of significant loss of hashrate. Setting lookup gap
-overrides the default of 2, but cgminer will use the --shaders value to choose
-a thread-concurrency if you haven't chosen one.
-SUMMARY: Don't touch this.
-
-
-Related parameters:
---worksize XX (-w XX)
-Has a minor effect, should be a multiple of 64 up to 256 maximum.
-SUMMARY: Worth playing with once everything else has been tried but will
-probably do nothing.
-
---vectors XX (-v XX)
-Vectors are NOT used by the scrypt mining kernel.
-SUMMARY: Does nothing.
-
-
-Overclocking for scrypt mining:
-First of all, do not underclock your memory initially. Scrypt mining requires
-memory speed and on most, but not all, GPUs, lowering memory speed lowers
-mining performance.
-
-Second, absolute engine clock speeds do NOT correlate with hashrate. The ratio
-of engine clock speed to memory matters, so if you set your memory to the
-default value, and then start overclocking as you are running it, you should
-find a sweet spot where the hashrate peaks and then it might actually drop if
-you increase the engine clock speed further.
-
-Third, the combination of motherboard, CPU and system ram ALSO makes a
-difference, so values that work for a GPU on one system may not work for the
-same GPU on a different system. A decent amount of system ram is actually
-required for scrypt mining, and 4GB is suggested.
-
-Finally, the power consumption while mining at high engine clocks, very high
-memory clocks can be far in excess of what you might imagine.
-For example, a 7970 running with the following settings:
---thread-concurrency 22392 --gpu-engine 1135 --gpu-memclock 1890
-was using 305W!
-
----
-TUNING AN AMD RADEON 7970
-Example tuning a 7970 for Scrypt mining:
-
-On linux run this command:
-export GPU_MAX_ALLOC_PERCENT=100
-or on windows this:
-setx GPU_MAX_ALLOC_PERCENT 100
-in the same console/bash/dos prompt/bat file/whatever you want to call it,
-before running cgminer.
-
-First, find the highest thread concurrency that you can start it at. They should
-all start at 8192 but some will go up to 3 times that. Don't go too high on the
-intensity while testing and don't change gpu threads. If you cannot go above
-8192, don't fret as you can still get a high hashrate.
-
-Delete any .bin files so you're starting from scratch and see what bins get
-generated.
-
-First try without any thread concurrency or even shaders, as cgminer will try to
-find an optimal value
-cgminer -I 13
-
-If that starts mining, see what bin was generated, it is likely the largest
-meaningful TC you can set.
-Starting it on mine I get:
-scrypt130302Tahitiglg2tc22392w64l8.bin
-
-See tc22392 that's telling you what thread concurrency it was. It should start
-without TC parameters, but you never know. So if it doesn't, start with
---thread-concurrency 8192 and add 2048 to it at a time till you find the highest
-value it will start successfully at.
-
-Then start overclocking the eyeballs off your memory, as 7970s are exquisitely
-sensitive to memory speed and amazingly overclockable but please make sure it
-keeps adequately cooled with --auto-fan! Do it while it's running from the GPU
-menu. Go up by 25 at a time every 30 seconds or so until your GPU crashes. Then
-reboot and start it 25 lower as a rough start. Mine runs stable at 1900 memory
-without overvolting. Overvolting is the only thing that can actually damage your
-GPU so I wouldn't recommend it at all.
-
-Then once you find the maximum memory clock speed, you need to find the sweet
-spot engine clock speed that matches it. It's a fine line where one more MHz
-will make the hashrate drop by 20%. It's somewhere in the .57 - 0.6 ratio range.
-Start your engine clock speed at half your memory clock speed and then increase
-it by 5 at a time. The hashrate should climb a little each rise in engine speed
-and then suddenly drop above a certain value. Decrease it by 1 then until you
-find it climbs dramatically. If your engine clock speed cannot get that high
-without crashing the GPU, you will have to use a lower memclock.
-
-Then, and only then, bother trying to increase intensity further.
-
-My final settings were:
---gpu-engine 1141  --gpu-memclock 1875 -I 20
-for a hashrate of 745kH.
-
-Note I did not bother setting a thread concurrency. Once you have the magic
-endpoint, look at what tc was chosen by the bin file generated and then hard
-code that in next time (eg --thread-concurrency 22392) as slight changes in
-thread concurrency will happen every time if you don't specify one, and the tc
-to clock ratios are critical!
-
-Good luck, and if this doesn't work for you, well same old magic discussion
-applies, I cannot debug every hardware combo out there.
-
-Your numbers will be your numbers depending on your hardware combination and OS,
-so don't expect to get exactly the same results!
-
----
-While BTC donations are preferred, if you wish to donate to the author, Con
-Kolivas, in LTC, please submit your donations to:
-
-Lc8TWMiKM7gRUrG8VB8pPNP1Yvt1SGZnoH
-
-Otherwise, please donate in BTC as per the main README.

scrypt.c

@@ -1,491 +0,0 @@
-/*-
- * Copyright 2009 Colin Percival, 2011 ArtForz
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 was originally written by Colin Percival as part of the Tarsnap
- * online backup system.
- */
-
-#include "config.h"
-#include "miner.h"
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-
-typedef struct SHA256Context {
-	uint32_t state[8];
-	uint32_t buf[16];
-} SHA256_CTX;
-
-/*
- * Encode a length len/4 vector of (uint32_t) into a length len vector of
- * (unsigned char) in big-endian form.  Assumes len is a multiple of 4.
- */
-static inline void
-be32enc_vect(uint32_t *dst, const uint32_t *src, uint32_t len)
-{
-	uint32_t i;
-
-	for (i = 0; i < len; i++)
-		dst[i] = htobe32(src[i]);
-}
-
-/* Elementary functions used by SHA256 */
-#define Ch(x, y, z)	((x & (y ^ z)) ^ z)
-#define Maj(x, y, z)	((x & (y | z)) | (y & z))
-#define SHR(x, n)	(x >> n)
-#define ROTR(x, n)	((x >> n) | (x << (32 - n)))
-#define S0(x)		(ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
-#define S1(x)		(ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
-#define s0(x)		(ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3))
-#define s1(x)		(ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10))
-
-/* SHA256 round function */
-#define RND(a, b, c, d, e, f, g, h, k)			\
-	t0 = h + S1(e) + Ch(e, f, g) + k;		\
-	t1 = S0(a) + Maj(a, b, c);			\
-	d += t0;					\
-	h  = t0 + t1;
-
-/* Adjusted round function for rotating state */
-#define RNDr(S, W, i, k)			\
-	RND(S[(64 - i) % 8], S[(65 - i) % 8],	\
-	    S[(66 - i) % 8], S[(67 - i) % 8],	\
-	    S[(68 - i) % 8], S[(69 - i) % 8],	\
-	    S[(70 - i) % 8], S[(71 - i) % 8],	\
-	    W[i] + k)
-
-/*
- * SHA256 block compression function.  The 256-bit state is transformed via
- * the 512-bit input block to produce a new state.
- */
-static void
-SHA256_Transform(uint32_t * state, const uint32_t block[16], int swap)
-{
-	uint32_t W[64];
-	uint32_t S[8];
-	uint32_t t0, t1;
-	int i;
-
-	/* 1. Prepare message schedule W. */
-	if(swap)
-		for (i = 0; i < 16; i++)
-			W[i] = htobe32(block[i]);
-	else
-		memcpy(W, block, 64);
-	for (i = 16; i < 64; i += 2) {
-		W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16];
-		W[i+1] = s1(W[i - 1]) + W[i - 6] + s0(W[i - 14]) + W[i - 15];
-	}
-
-	/* 2. Initialize working variables. */
-	memcpy(S, state, 32);
-
-	/* 3. Mix. */
-	RNDr(S, W, 0, 0x428a2f98);
-	RNDr(S, W, 1, 0x71374491);
-	RNDr(S, W, 2, 0xb5c0fbcf);
-	RNDr(S, W, 3, 0xe9b5dba5);
-	RNDr(S, W, 4, 0x3956c25b);
-	RNDr(S, W, 5, 0x59f111f1);
-	RNDr(S, W, 6, 0x923f82a4);
-	RNDr(S, W, 7, 0xab1c5ed5);
-	RNDr(S, W, 8, 0xd807aa98);
-	RNDr(S, W, 9, 0x12835b01);
-	RNDr(S, W, 10, 0x243185be);
-	RNDr(S, W, 11, 0x550c7dc3);
-	RNDr(S, W, 12, 0x72be5d74);
-	RNDr(S, W, 13, 0x80deb1fe);
-	RNDr(S, W, 14, 0x9bdc06a7);
-	RNDr(S, W, 15, 0xc19bf174);
-	RNDr(S, W, 16, 0xe49b69c1);
-	RNDr(S, W, 17, 0xefbe4786);
-	RNDr(S, W, 18, 0x0fc19dc6);
-	RNDr(S, W, 19, 0x240ca1cc);
-	RNDr(S, W, 20, 0x2de92c6f);
-	RNDr(S, W, 21, 0x4a7484aa);
-	RNDr(S, W, 22, 0x5cb0a9dc);
-	RNDr(S, W, 23, 0x76f988da);
-	RNDr(S, W, 24, 0x983e5152);
-	RNDr(S, W, 25, 0xa831c66d);
-	RNDr(S, W, 26, 0xb00327c8);
-	RNDr(S, W, 27, 0xbf597fc7);
-	RNDr(S, W, 28, 0xc6e00bf3);
-	RNDr(S, W, 29, 0xd5a79147);
-	RNDr(S, W, 30, 0x06ca6351);
-	RNDr(S, W, 31, 0x14292967);
-	RNDr(S, W, 32, 0x27b70a85);
-	RNDr(S, W, 33, 0x2e1b2138);
-	RNDr(S, W, 34, 0x4d2c6dfc);
-	RNDr(S, W, 35, 0x53380d13);
-	RNDr(S, W, 36, 0x650a7354);
-	RNDr(S, W, 37, 0x766a0abb);
-	RNDr(S, W, 38, 0x81c2c92e);
-	RNDr(S, W, 39, 0x92722c85);
-	RNDr(S, W, 40, 0xa2bfe8a1);
-	RNDr(S, W, 41, 0xa81a664b);
-	RNDr(S, W, 42, 0xc24b8b70);
-	RNDr(S, W, 43, 0xc76c51a3);
-	RNDr(S, W, 44, 0xd192e819);
-	RNDr(S, W, 45, 0xd6990624);
-	RNDr(S, W, 46, 0xf40e3585);
-	RNDr(S, W, 47, 0x106aa070);
-	RNDr(S, W, 48, 0x19a4c116);
-	RNDr(S, W, 49, 0x1e376c08);
-	RNDr(S, W, 50, 0x2748774c);
-	RNDr(S, W, 51, 0x34b0bcb5);
-	RNDr(S, W, 52, 0x391c0cb3);
-	RNDr(S, W, 53, 0x4ed8aa4a);
-	RNDr(S, W, 54, 0x5b9cca4f);
-	RNDr(S, W, 55, 0x682e6ff3);
-	RNDr(S, W, 56, 0x748f82ee);
-	RNDr(S, W, 57, 0x78a5636f);
-	RNDr(S, W, 58, 0x84c87814);
-	RNDr(S, W, 59, 0x8cc70208);
-	RNDr(S, W, 60, 0x90befffa);
-	RNDr(S, W, 61, 0xa4506ceb);
-	RNDr(S, W, 62, 0xbef9a3f7);
-	RNDr(S, W, 63, 0xc67178f2);
-
-	/* 4. Mix local working variables into global state */
-	for (i = 0; i < 8; i++)
-		state[i] += S[i];
-}
-
-static inline void
-SHA256_InitState(uint32_t * state)
-{
-	/* Magic initialization constants */
-	state[0] = 0x6A09E667;
-	state[1] = 0xBB67AE85;
-	state[2] = 0x3C6EF372;
-	state[3] = 0xA54FF53A;
-	state[4] = 0x510E527F;
-	state[5] = 0x9B05688C;
-	state[6] = 0x1F83D9AB;
-	state[7] = 0x5BE0CD19;
-}
-
-static const uint32_t passwdpad[12] = {0x00000080, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x80020000};
-static const uint32_t outerpad[8] = {0x80000000, 0, 0, 0, 0, 0, 0, 0x00000300};
-
-/**
- * PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, c, buf, dkLen):
- * Compute PBKDF2(passwd, salt, c, dkLen) using HMAC-SHA256 as the PRF, and
- * write the output to buf.  The value dkLen must be at most 32 * (2^32 - 1).
- */
-static inline void
-PBKDF2_SHA256_80_128(const uint32_t * passwd, uint32_t * buf)
-{
-	SHA256_CTX PShictx, PShoctx;
-	uint32_t tstate[8];
-	uint32_t ihash[8];
-	uint32_t i;
-	uint32_t pad[16];
-	
-	static const uint32_t innerpad[11] = {0x00000080, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xa0040000};
-
-	/* If Klen > 64, the key is really SHA256(K). */
-	SHA256_InitState(tstate);
-	SHA256_Transform(tstate, passwd, 1);
-	memcpy(pad, passwd+16, 16);
-	memcpy(pad+4, passwdpad, 48);
-	SHA256_Transform(tstate, pad, 1);
-	memcpy(ihash, tstate, 32);
-
-	SHA256_InitState(PShictx.state);
-	for (i = 0; i < 8; i++)
-		pad[i] = ihash[i] ^ 0x36363636;
-	for (; i < 16; i++)
-		pad[i] = 0x36363636;
-	SHA256_Transform(PShictx.state, pad, 0);
-	SHA256_Transform(PShictx.state, passwd, 1);
-	be32enc_vect(PShictx.buf, passwd+16, 4);
-	be32enc_vect(PShictx.buf+5, innerpad, 11);
-
-	SHA256_InitState(PShoctx.state);
-	for (i = 0; i < 8; i++)
-		pad[i] = ihash[i] ^ 0x5c5c5c5c;
-	for (; i < 16; i++)
-		pad[i] = 0x5c5c5c5c;
-	SHA256_Transform(PShoctx.state, pad, 0);
-	memcpy(PShoctx.buf+8, outerpad, 32);
-
-	/* Iterate through the blocks. */
-	for (i = 0; i < 4; i++) {
-		uint32_t istate[8];
-		uint32_t ostate[8];
-		
-		memcpy(istate, PShictx.state, 32);
-		PShictx.buf[4] = i + 1;
-		SHA256_Transform(istate, PShictx.buf, 0);
-		memcpy(PShoctx.buf, istate, 32);
-
-		memcpy(ostate, PShoctx.state, 32);
-		SHA256_Transform(ostate, PShoctx.buf, 0);
-		be32enc_vect(buf+i*8, ostate, 8);
-	}
-}
-
-
-static inline void
-PBKDF2_SHA256_80_128_32(const uint32_t * passwd, const uint32_t * salt, uint32_t *ostate)
-{
-	uint32_t tstate[8];
-	uint32_t ihash[8];
-	uint32_t i;
-
-	/* Compute HMAC state after processing P and S. */
-	uint32_t pad[16];
-	
-	static const uint32_t ihash_finalblk[16] = {0x00000001,0x80000000,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0x00000620};
-
-	/* If Klen > 64, the key is really SHA256(K). */
-	SHA256_InitState(tstate);
-	SHA256_Transform(tstate, passwd, 1);
-	memcpy(pad, passwd+16, 16);
-	memcpy(pad+4, passwdpad, 48);
-	SHA256_Transform(tstate, pad, 1);
-	memcpy(ihash, tstate, 32);
-
-	SHA256_InitState(ostate);
-	for (i = 0; i < 8; i++)
-		pad[i] = ihash[i] ^ 0x5c5c5c5c;
-	for (; i < 16; i++)
-		pad[i] = 0x5c5c5c5c;
-	SHA256_Transform(ostate, pad, 0);
-
-	SHA256_InitState(tstate);
-	for (i = 0; i < 8; i++)
-		pad[i] = ihash[i] ^ 0x36363636;
-	for (; i < 16; i++)
-		pad[i] = 0x36363636;
-	SHA256_Transform(tstate, pad, 0);
-	SHA256_Transform(tstate, salt, 1);
-	SHA256_Transform(tstate, salt+16, 1);
-	SHA256_Transform(tstate, ihash_finalblk, 0);
-	memcpy(pad, tstate, 32);
-	memcpy(pad+8, outerpad, 32);
-
-	/* Feed the inner hash to the outer SHA256 operation. */
-	SHA256_Transform(ostate, pad, 0);
-}
-
-
-/**
- * salsa20_8(B):
- * Apply the salsa20/8 core to the provided block.
- */
-static inline void
-salsa20_8(uint32_t B[16], const uint32_t Bx[16])
-{
-	uint32_t x00,x01,x02,x03,x04,x05,x06,x07,x08,x09,x10,x11,x12,x13,x14,x15;
-	size_t i;
-
-	x00 = (B[ 0] ^= Bx[ 0]);
-	x01 = (B[ 1] ^= Bx[ 1]);
-	x02 = (B[ 2] ^= Bx[ 2]);
-	x03 = (B[ 3] ^= Bx[ 3]);
-	x04 = (B[ 4] ^= Bx[ 4]);
-	x05 = (B[ 5] ^= Bx[ 5]);
-	x06 = (B[ 6] ^= Bx[ 6]);
-	x07 = (B[ 7] ^= Bx[ 7]);
-	x08 = (B[ 8] ^= Bx[ 8]);
-	x09 = (B[ 9] ^= Bx[ 9]);
-	x10 = (B[10] ^= Bx[10]);
-	x11 = (B[11] ^= Bx[11]);
-	x12 = (B[12] ^= Bx[12]);
-	x13 = (B[13] ^= Bx[13]);
-	x14 = (B[14] ^= Bx[14]);
-	x15 = (B[15] ^= Bx[15]);
-	for (i = 0; i < 8; i += 2) {
-#define R(a,b) (((a) << (b)) | ((a) >> (32 - (b))))
-		/* Operate on columns. */
-		x04 ^= R(x00+x12, 7);	x09 ^= R(x05+x01, 7);	x14 ^= R(x10+x06, 7);	x03 ^= R(x15+x11, 7);
-		x08 ^= R(x04+x00, 9);	x13 ^= R(x09+x05, 9);	x02 ^= R(x14+x10, 9);	x07 ^= R(x03+x15, 9);
-		x12 ^= R(x08+x04,13);	x01 ^= R(x13+x09,13);	x06 ^= R(x02+x14,13);	x11 ^= R(x07+x03,13);
-		x00 ^= R(x12+x08,18);	x05 ^= R(x01+x13,18);	x10 ^= R(x06+x02,18);	x15 ^= R(x11+x07,18);
-
-		/* Operate on rows. */
-		x01 ^= R(x00+x03, 7);	x06 ^= R(x05+x04, 7);	x11 ^= R(x10+x09, 7);	x12 ^= R(x15+x14, 7);
-		x02 ^= R(x01+x00, 9);	x07 ^= R(x06+x05, 9);	x08 ^= R(x11+x10, 9);	x13 ^= R(x12+x15, 9);
-		x03 ^= R(x02+x01,13);	x04 ^= R(x07+x06,13);	x09 ^= R(x08+x11,13);	x14 ^= R(x13+x12,13);
-		x00 ^= R(x03+x02,18);	x05 ^= R(x04+x07,18);	x10 ^= R(x09+x08,18);	x15 ^= R(x14+x13,18);
-#undef R
-	}
-	B[ 0] += x00;
-	B[ 1] += x01;
-	B[ 2] += x02;
-	B[ 3] += x03;
-	B[ 4] += x04;
-	B[ 5] += x05;
-	B[ 6] += x06;
-	B[ 7] += x07;
-	B[ 8] += x08;
-	B[ 9] += x09;
-	B[10] += x10;
-	B[11] += x11;
-	B[12] += x12;
-	B[13] += x13;
-	B[14] += x14;
-	B[15] += x15;
-}
-
-/* cpu and memory intensive function to transform a 80 byte buffer into a 32 byte output
-   scratchpad size needs to be at least 63 + (128 * r * p) + (256 * r + 64) + (128 * r * N) bytes
- */
-static void scrypt_1024_1_1_256_sp(const uint32_t* input, char* scratchpad, uint32_t *ostate)
-{
-	uint32_t * V;
-	uint32_t X[32];
-	uint32_t i;
-	uint32_t j;
-	uint32_t k;
-	uint64_t *p1, *p2;
-
-	p1 = (uint64_t *)X;
-	V = (uint32_t *)(((uintptr_t)(scratchpad) + 63) & ~ (uintptr_t)(63));
-
-	PBKDF2_SHA256_80_128(input, X);
-
-	for (i = 0; i < 1024; i += 2) {
-		memcpy(&V[i * 32], X, 128);
-
-		salsa20_8(&X[0], &X[16]);
-		salsa20_8(&X[16], &X[0]);
-
-		memcpy(&V[(i + 1) * 32], X, 128);
-
-		salsa20_8(&X[0], &X[16]);
-		salsa20_8(&X[16], &X[0]);
-	}
-	for (i = 0; i < 1024; i += 2) {
-		j = X[16] & 1023;
-		p2 = (uint64_t *)(&V[j * 32]);
-		for(k = 0; k < 16; k++)
-			p1[k] ^= p2[k];
-
-		salsa20_8(&X[0], &X[16]);
-		salsa20_8(&X[16], &X[0]);
-
-		j = X[16] & 1023;
-		p2 = (uint64_t *)(&V[j * 32]);
-		for(k = 0; k < 16; k++)
-			p1[k] ^= p2[k];
-
-		salsa20_8(&X[0], &X[16]);
-		salsa20_8(&X[16], &X[0]);
-	}
-
-	PBKDF2_SHA256_80_128_32(input, X, ostate);
-}
-
-/* 131583 rounded up to 4 byte alignment */
-#define SCRATCHBUF_SIZE	(131584)
-
-void scrypt_regenhash(struct work *work)
-{
-	uint32_t data[20];
-	char *scratchbuf;
-	uint32_t *nonce = (uint32_t *)(work->data + 76);
-	uint32_t *ohash = (uint32_t *)(work->hash);
-
-	be32enc_vect(data, (const uint32_t *)work->data, 19);
-	data[19] = htobe32(*nonce);
-	scratchbuf = alloca(SCRATCHBUF_SIZE);
-	scrypt_1024_1_1_256_sp(data, scratchbuf, ohash);
-	flip32(ohash, ohash);
-}
-
-static const uint32_t diff1targ = 0x0000ffff;
-
-/* Used externally as confirmation of correct OCL code */
-int scrypt_test(unsigned char *pdata, const unsigned char *ptarget, uint32_t nonce)
-{
-	uint32_t tmp_hash7, Htarg = le32toh(((const uint32_t *)ptarget)[7]);
-	uint32_t data[20], ohash[8];
-	char *scratchbuf;
-
-	be32enc_vect(data, (const uint32_t *)pdata, 19);
-	data[19] = htobe32(nonce);
-	scratchbuf = alloca(SCRATCHBUF_SIZE);
-	scrypt_1024_1_1_256_sp(data, scratchbuf, ohash);
-	tmp_hash7 = be32toh(ohash[7]);
-
-	applog(LOG_DEBUG, "htarget %08lx diff1 %08lx hash %08lx",
-				(long unsigned int)Htarg,
-				(long unsigned int)diff1targ,
-				(long unsigned int)tmp_hash7);
-	if (tmp_hash7 > diff1targ)
-		return -1;
-	if (tmp_hash7 > Htarg)
-		return 0;
-	return 1;
-}
-
-bool scanhash_scrypt(struct thr_info *thr, const unsigned char __maybe_unused *pmidstate,
-		     unsigned char *pdata, unsigned char __maybe_unused *phash1,
-		     unsigned char __maybe_unused *phash, const unsigned char *ptarget,
-		     uint32_t max_nonce, uint32_t *last_nonce, uint32_t n)
-{
-	uint32_t *nonce = (uint32_t *)(pdata + 76);
-	char *scratchbuf;
-	uint32_t data[20];
-	uint32_t tmp_hash7;
-	uint32_t Htarg = le32toh(((const uint32_t *)ptarget)[7]);
-	bool ret = false;
-
-	be32enc_vect(data, (const uint32_t *)pdata, 19);
-
-	scratchbuf = malloc(SCRATCHBUF_SIZE);
-	if (unlikely(!scratchbuf)) {
-		applog(LOG_ERR, "Failed to malloc scratchbuf in scanhash_scrypt");
-		return ret;
-	}
-
-	while(1) {
-		uint32_t ostate[8];
-
-		*nonce = ++n;
-		data[19] = htobe32(n);
-		scrypt_1024_1_1_256_sp(data, scratchbuf, ostate);
-		tmp_hash7 = be32toh(ostate[7]);
-
-		if (unlikely(tmp_hash7 <= Htarg)) {
-			((uint32_t *)pdata)[19] = htobe32(n);
-			*last_nonce = n;
-			ret = true;
-			break;
-		}
-
-		if (unlikely((n >= max_nonce) || thr->work_restart)) {
-			*last_nonce = n;
-			break;
-		}
-	}
-
-	free(scratchbuf);;
-	return ret;
-}

scrypt.h

@@ -1,24 +0,0 @@
-#ifndef SCRYPT_H
-#define SCRYPT_H
-
-#include "miner.h"
-
-#ifdef USE_SCRYPT
-extern int scrypt_test(unsigned char *pdata, const unsigned char *ptarget,
-			uint32_t nonce);
-extern void scrypt_regenhash(struct work *work);
-
-#else /* USE_SCRYPT */
-static inline int scrypt_test(__maybe_unused unsigned char *pdata,
-			       __maybe_unused const unsigned char *ptarget,
-			       __maybe_unused uint32_t nonce)
-{
-	return 0;
-}
-
-static inline void scrypt_regenhash(__maybe_unused struct work *work)
-{
-}
-#endif /* USE_SCRYPT */
-
-#endif /* SCRYPT_H */