Release 4.7 drivers/staging/sm750fb/ddk750_chip.c
#include <linux/kernel.h>
#include <linux/sizes.h>
#include "ddk750_help.h"
#include "ddk750_reg.h"
#include "ddk750_chip.h"
#include "ddk750_power.h"
/* n / d + 1 / 2 = (2n + d) / 2d */
#define roundedDiv(num, denom) ((2 * (num) + (denom)) / (2 * (denom)))
#define MHz(x) ((x) * 1000000)
logical_chip_type_t getChipType(void)
{
unsigned short physicalID;
char physicalRev;
logical_chip_type_t chip;
physicalID = devId750; /* either 0x718 or 0x750 */
physicalRev = revId750;
if (physicalID == 0x718)
chip = SM718;
else if (physicalID == 0x750) {
chip = SM750;
/* SM750 and SM750LE are different in their revision ID only. */
if (physicalRev == SM750LE_REVISION_ID)
chip = SM750LE;
} else
chip = SM_UNKNOWN;
return chip;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| sudip mukherjee | sudip mukherjee | 64 | 94.12% | 1 | 33.33% |
| supriya karanth | supriya karanth | 3 | 4.41% | 1 | 33.33% |
| juston li | juston li | 1 | 1.47% | 1 | 33.33% |
| Total | 68 | 100.00% | 3 | 100.00% |
static unsigned int get_mxclk_freq(void)
{
unsigned int pll_reg;
unsigned int M, N, OD, POD;
if (getChipType() == SM750LE)
return MHz(130);
pll_reg = PEEK32(MXCLK_PLL_CTRL);
M = (pll_reg & PLL_CTRL_M_MASK) >> PLL_CTRL_M_SHIFT;
N = (pll_reg & PLL_CTRL_N_MASK) >> PLL_CTRL_M_SHIFT;
OD = (pll_reg & PLL_CTRL_OD_MASK) >> PLL_CTRL_OD_SHIFT;
POD = (pll_reg & PLL_CTRL_POD_MASK) >> PLL_CTRL_POD_SHIFT;
return DEFAULT_INPUT_CLOCK * M / N / (1 << OD) / (1 << POD);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| mike rapoport | mike rapoport | 67 | 65.69% | 4 | 80.00% |
| sudip mukherjee | sudip mukherjee | 35 | 34.31% | 1 | 20.00% |
| Total | 102 | 100.00% | 5 | 100.00% |
/*
* This function set up the main chip clock.
*
* Input: Frequency to be set.
*/
static void setChipClock(unsigned int frequency)
{
pll_value_t pll;
unsigned int ulActualMxClk;
/* Cheok_0509: For SM750LE, the chip clock is fixed. Nothing to set. */
if (getChipType() == SM750LE)
return;
if (frequency) {
/*
* Set up PLL, a structure to hold the value to be set in clocks.
*/
pll.inputFreq = DEFAULT_INPUT_CLOCK; /* Defined in CLOCK.H */
pll.clockType = MXCLK_PLL;
/*
* Call calcPllValue() to fill up the other fields for PLL structure.
* Sometime, the chip cannot set up the exact clock required by User.
* Return value from calcPllValue() gives the actual possible clock.
*/
ulActualMxClk = calcPllValue(frequency, &pll);
/* Master Clock Control: MXCLK_PLL */
POKE32(MXCLK_PLL_CTRL, formatPllReg(&pll));
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| sudip mukherjee | sudip mukherjee | 66 | 95.65% | 1 | 33.33% |
| ragavendra nagraj | ragavendra nagraj | 2 | 2.90% | 1 | 33.33% |
| mike rapoport | mike rapoport | 1 | 1.45% | 1 | 33.33% |
| Total | 69 | 100.00% | 3 | 100.00% |
static void setMemoryClock(unsigned int frequency)
{
unsigned int reg, divisor;
/* Cheok_0509: For SM750LE, the memory clock is fixed. Nothing to set. */
if (getChipType() == SM750LE)
return;
if (frequency) {
/* Set the frequency to the maximum frequency that the DDR Memory can take
which is 336MHz. */
if (frequency > MHz(336))
frequency = MHz(336);
/* Calculate the divisor */
divisor = roundedDiv(get_mxclk_freq(), frequency);
/* Set the corresponding divisor in the register. */
reg = PEEK32(CURRENT_GATE) & ~CURRENT_GATE_M2XCLK_MASK;
switch (divisor) {
default:
case 1:
reg |= CURRENT_GATE_M2XCLK_DIV_1;
break;
case 2:
reg |= CURRENT_GATE_M2XCLK_DIV_2;
break;
case 3:
reg |= CURRENT_GATE_M2XCLK_DIV_3;
break;
case 4:
reg |= CURRENT_GATE_M2XCLK_DIV_4;
break;
}
setCurrentGate(reg);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| sudip mukherjee | sudip mukherjee | 93 | 81.58% | 1 | 16.67% |
| mike rapoport | mike rapoport | 20 | 17.54% | 4 | 66.67% |
| ragavendra nagraj | ragavendra nagraj | 1 | 0.88% | 1 | 16.67% |
| Total | 114 | 100.00% | 6 | 100.00% |
/*
* This function set up the master clock (MCLK).
*
* Input: Frequency to be set.
*
* NOTE:
* The maximum frequency the engine can run is 168MHz.
*/
static void setMasterClock(unsigned int frequency)
{
unsigned int reg, divisor;
/* Cheok_0509: For SM750LE, the memory clock is fixed. Nothing to set. */
if (getChipType() == SM750LE)
return;
if (frequency) {
/* Set the frequency to the maximum frequency that the SM750 engine can
run, which is about 190 MHz. */
if (frequency > MHz(190))
frequency = MHz(190);
/* Calculate the divisor */
divisor = roundedDiv(get_mxclk_freq(), frequency);
/* Set the corresponding divisor in the register. */
reg = PEEK32(CURRENT_GATE) & ~CURRENT_GATE_MCLK_MASK;
switch (divisor) {
default:
case 3:
reg |= CURRENT_GATE_MCLK_DIV_3;
break;
case 4:
reg |= CURRENT_GATE_MCLK_DIV_4;
break;
case 6:
reg |= CURRENT_GATE_MCLK_DIV_6;
break;
case 8:
reg |= CURRENT_GATE_MCLK_DIV_8;
break;
}
setCurrentGate(reg);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| sudip mukherjee | sudip mukherjee | 93 | 81.58% | 1 | 16.67% |
| mike rapoport | mike rapoport | 20 | 17.54% | 4 | 66.67% |
| ragavendra nagraj | ragavendra nagraj | 1 | 0.88% | 1 | 16.67% |
| Total | 114 | 100.00% | 6 | 100.00% |
unsigned int ddk750_getVMSize(void)
{
unsigned int reg;
unsigned int data;
/* sm750le only use 64 mb memory*/
if (getChipType() == SM750LE)
return SZ_64M;
/* for 750,always use power mode0*/
reg = PEEK32(MODE0_GATE);
reg |= MODE0_GATE_GPIO;
POKE32(MODE0_GATE, reg);
/* get frame buffer size from GPIO */
reg = PEEK32(MISC_CTRL) & MISC_CTRL_LOCALMEM_SIZE_MASK;
switch (reg) {
case MISC_CTRL_LOCALMEM_SIZE_8M:
data = SZ_8M; break; /* 8 Mega byte */
case MISC_CTRL_LOCALMEM_SIZE_16M:
data = SZ_16M; break; /* 16 Mega byte */
case MISC_CTRL_LOCALMEM_SIZE_32M:
data = SZ_32M; break; /* 32 Mega byte */
case MISC_CTRL_LOCALMEM_SIZE_64M:
data = SZ_64M; break; /* 64 Mega byte */
default:
data = 0;
break;
}
return data;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| sudip mukherjee | sudip mukherjee | 95 | 88.79% | 1 | 20.00% |
| mike rapoport | mike rapoport | 9 | 8.41% | 3 | 60.00% |
| supriya karanth | supriya karanth | 3 | 2.80% | 1 | 20.00% |
| Total | 107 | 100.00% | 5 | 100.00% |
int ddk750_initHw(initchip_param_t *pInitParam)
{
unsigned int reg;
if (pInitParam->powerMode != 0)
pInitParam->powerMode = 0;
setPowerMode(pInitParam->powerMode);
/* Enable display power gate & LOCALMEM power gate*/
reg = PEEK32(CURRENT_GATE);
reg |= (CURRENT_GATE_DISPLAY | CURRENT_GATE_LOCALMEM);
setCurrentGate(reg);
if (getChipType() != SM750LE) {
/* set panel pll and graphic mode via mmio_88 */
reg = PEEK32(VGA_CONFIGURATION);
reg |= (VGA_CONFIGURATION_PLL | VGA_CONFIGURATION_MODE);
POKE32(VGA_CONFIGURATION, reg);
} else {
#if defined(__i386__) || defined(__x86_64__)
/* set graphic mode via IO method */
outb_p(0x88, 0x3d4);
outb_p(0x06, 0x3d5);
#endif
}
/* Set the Main Chip Clock */
setChipClock(MHz((unsigned int)pInitParam->chipClock));
/* Set up memory clock. */
setMemoryClock(MHz(pInitParam->memClock));
/* Set up master clock */
setMasterClock(MHz(pInitParam->masterClock));
/* Reset the memory controller. If the memory controller is not reset in SM750,
the system might hang when sw accesses the memory.
The memory should be resetted after changing the MXCLK.
*/
if (pInitParam->resetMemory == 1) {
reg = PEEK32(MISC_CTRL);
reg &= ~MISC_CTRL_LOCALMEM_RESET;
POKE32(MISC_CTRL, reg);
reg |= MISC_CTRL_LOCALMEM_RESET;
POKE32(MISC_CTRL, reg);
}
if (pInitParam->setAllEngOff == 1) {
enable2DEngine(0);
/* Disable Overlay, if a former application left it on */
reg = PEEK32(VIDEO_DISPLAY_CTRL);
reg &= ~DISPLAY_CTRL_PLANE;
POKE32(VIDEO_DISPLAY_CTRL, reg);
/* Disable video alpha, if a former application left it on */
reg = PEEK32(VIDEO_ALPHA_DISPLAY_CTRL);
reg &= ~DISPLAY_CTRL_PLANE;
POKE32(VIDEO_ALPHA_DISPLAY_CTRL, reg);
/* Disable alpha plane, if a former application left it on */
reg = PEEK32(ALPHA_DISPLAY_CTRL);
reg &= ~DISPLAY_CTRL_PLANE;
POKE32(ALPHA_DISPLAY_CTRL, reg);
/* Disable DMA Channel, if a former application left it on */
reg = PEEK32(DMA_ABORT_INTERRUPT);
reg |= DMA_ABORT_INTERRUPT_ABORT_1;
POKE32(DMA_ABORT_INTERRUPT, reg);
/* Disable DMA Power, if a former application left it on */
enableDMA(0);
}
/* We can add more initialization as needed. */
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| sudip mukherjee | sudip mukherjee | 248 | 82.67% | 1 | 14.29% |
| mike rapoport | mike rapoport | 52 | 17.33% | 6 | 85.71% |
| Total | 300 | 100.00% | 7 | 100.00% |
/*
monk liu @ 4/6/2011:
re-write the calculatePLL function of ddk750.
the original version function does not use some mathematics tricks and shortcut
when it doing the calculation of the best N,M,D combination
I think this version gives a little upgrade in speed
750 pll clock formular:
Request Clock = (Input Clock * M )/(N * X)
Input Clock = 14318181 hz
X = 2 power D
D ={0,1,2,3,4,5,6}
M = {1,...,255}
N = {2,...,15}
*/
unsigned int calcPllValue(unsigned int request_orig, pll_value_t *pll)
{
/* as sm750 register definition, N located in 2,15 and M located in 1,255 */
int N, M, X, d;
int mini_diff;
unsigned int RN, quo, rem, fl_quo;
unsigned int input, request;
unsigned int tmpClock, ret;
const int max_OD = 3;
int max_d = 6;
if (getChipType() == SM750LE) {
/* SM750LE don't have prgrammable PLL and M/N values to work on.
Just return the requested clock. */
return request_orig;
}
ret = 0;
mini_diff = ~0;
request = request_orig / 1000;
input = pll->inputFreq / 1000;
/* for MXCLK register , no POD provided, so need be treated differently */
if (pll->clockType == MXCLK_PLL)
max_d = 3;
for (N = 15; N > 1; N--) {
/* RN will not exceed maximum long if @request <= 285 MHZ (for 32bit cpu) */
RN = N * request;
quo = RN / input;
rem = RN % input;/* rem always small than 14318181 */
fl_quo = (rem * 10000 / input);
for (d = max_d; d >= 0; d--) {
X = (1 << d);
M = quo * X;
M += fl_quo * X / 10000;
/* round step */
M += (fl_quo * X % 10000) > 5000 ? 1 : 0;
if (M < 256 && M > 0) {
unsigned int diff;
tmpClock = pll->inputFreq * M / N / X;
diff = abs(tmpClock - request_orig);
if (diff < mini_diff) {
pll->M = M;
pll->N = N;
pll->POD = 0;
if (d > max_OD)
pll->POD = d - max_OD;
pll->OD = d - pll->POD;
mini_diff = diff;
ret = tmpClock;
}
}
}
}
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| sudip mukherjee | sudip mukherjee | 260 | 84.97% | 1 | 16.67% |
| mike rapoport | mike rapoport | 38 | 12.42% | 2 | 33.33% |
| amitoj kaur chawla | amitoj kaur chawla | 4 | 1.31% | 1 | 16.67% |
| colin king | colin king | 2 | 0.65% | 1 | 16.67% |
| ragavendra nagraj | ragavendra nagraj | 2 | 0.65% | 1 | 16.67% |
| Total | 306 | 100.00% | 6 | 100.00% |
unsigned int formatPllReg(pll_value_t *pPLL)
{
#ifndef VALIDATION_CHIP
unsigned int POD = pPLL->POD;
#endif
unsigned int OD = pPLL->OD;
unsigned int M = pPLL->M;
unsigned int N = pPLL->N;
unsigned int reg = 0;
/*
* Note that all PLL's have the same format. Here, we just use
* Panel PLL parameter to work out the bit fields in the
* register. On returning a 32 bit number, the value can be
* applied to any PLL in the calling function.
*/
reg = PLL_CTRL_POWER |
#ifndef VALIDATION_CHIP
((POD << PLL_CTRL_POD_SHIFT) & PLL_CTRL_POD_MASK) |
#endif
((OD << PLL_CTRL_OD_SHIFT) & PLL_CTRL_OD_MASK) |
((N << PLL_CTRL_N_SHIFT) & PLL_CTRL_N_MASK) |
((M << PLL_CTRL_M_SHIFT) & PLL_CTRL_M_MASK);
return reg;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| mike rapoport | mike rapoport | 76 | 71.70% | 4 | 80.00% |
| sudip mukherjee | sudip mukherjee | 30 | 28.30% | 1 | 20.00% |
| Total | 106 | 100.00% | 5 | 100.00% |
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| sudip mukherjee | sudip mukherjee | 999 | 75.45% | 1 | 3.70% |
| mike rapoport | mike rapoport | 306 | 23.11% | 21 | 77.78% |
| ragavendra nagraj | ragavendra nagraj | 6 | 0.45% | 1 | 3.70% |
| supriya karanth | supriya karanth | 6 | 0.45% | 1 | 3.70% |
| amitoj kaur chawla | amitoj kaur chawla | 4 | 0.30% | 1 | 3.70% |
| colin king | colin king | 2 | 0.15% | 1 | 3.70% |
| juston li | juston li | 1 | 0.08% | 1 | 3.70% |
| Total | 1324 | 100.00% | 27 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.