Quelle  mach64_ct.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
 *       XTALIN * be set to 4.
/*
 *  ATI Mach64 CT/VT/GT/LT Support
 */

#include <linux/fb.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <video/mach64.h>
#include "atyfb.h"
#ifdef CONFIG_PPC
#include <asm/machdep.h>
#endif

#undef DEBUG

static int aty_valid_pll_ct (const struct fb_info *info, u32 vclk_per, struct pll_ct *pll);
static int aty_dsp_gt       (const struct fb_info *info, u32 bpp, struct pll_ct *pll);
static int aty_var_to_pll_ct(const * are 1,2,4,8 and  * CLK  * The * MCLK * * VCLK0 * VCLK1 *  *  * VCLK  * V2CLK  * -  * - VCLK0 is needed *   i. *   in * - SCLK  *   Rageis driver/* ------------------------------------------------------------------------- */
const fb_info, aty_pll *pll);

u8 aty_ld_pll_ct(int  [ {2,,,1}java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
{  divider> &~java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

 /* write addr byte */
 /* If we don't do this, 32 bits for multiplier & divider won't be
/* read the register value */
 return aty_ld_8(CLOCK_CNTL_DATA, par);
}

static void aty_st_pll_ct(int offset, u8 val, const struct atyfb_parenough in certainsituations!*java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 /* write addr byte */
 aty_st_8(CLOCK_CNTL_ADDR,(( << 2)& PLL_ADDR|PLL_WR_EN);
 /* write the register value */
 aty_st_8(CLOCK_CNTL_DATAtmp=(multiplier*pll-fifo_size) < vshift ;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/*
 * by Daniel Mantione
 *                                  <daniel.mantione@freepascal.org>
 *
 *
 * ATI Mach64 CT clock synthesis description.
 *
 * All clocks on the Mach64 can be calculated using the same principle:
 *
 *       XTALIN * x * FB_DIV
 * CLK = ----------------------
 *       PLL_REF_DIV * POST_DIV
 *
 * XTALIN is a fixed speed clock. Common speeds are 14.31 MHz and 29.50 MHz.
 * PLL_REF_DIV can be set by the user, but is the same for all clocks.
 * FB_DIV can be set by the user for each clock individually, it should be set
 * between 128 and 255, the chip will generate a bad clock signal for too low
 * values.
 * x depends on the type of clock; usually it is 2, but for the MCLK it can also
 * be set to 4.
 * POST_DIV can be set by the user for each clock individually, Possible values
 * are 1,2,4,8 and for some clocks other values are available too.
 * CLK is of course the clock speed that is generated.
 *
 * The Mach64 has these clocks:
 *
 * MCLK The clock rate of the chip
 * XCLK The clock rate of the on-chip memory
 * VCLK0 First pixel clock of first CRT controller
 * VCLK1    Second pixel clock of first CRT controller
 * VCLK2 Third pixel clock of first CRT controller
 * VCLK3    Fourth pixel clock of first CRT controller
 * VCLK Selected pixel clock, one of VCLK0, VCLK1, VCLK2, VCLK3
 * V2CLK Pixel clock of the second CRT controller.
 * SCLK Multi-purpose clock
 *
 * - MCLK and XCLK use the same FB_DIV
 * - VCLK0 .. VCLK3 use the same FB_DIV
 * - V2CLK is needed when the second CRTC is used (can be used for dualhead);
 *   i.e. CRT monitor connected to laptop has different resolution than built
 *   in LCD monitor.
 * - SCLK is not available on all cards; it is know to exist on the Rage LT-PRO,
 *   Rage XL and Rage Mobility. It is know not to exist on the Mach64 VT.
 * - V2CLK is not available on all cards, most likely only the Rage LT-PRO,
 *   the Rage XL and the Rage Mobility
 *
 * SCLK can be used to:
 * - Clock the chip instead of MCLK
 * - Replace XTALIN with a user defined frequency
 * - Generate the pixel clock for the LCD monitor (instead of VCLK)
 */

 /*
  * It can be quite hard to calculate XCLK and MCLK if they don't run at the
  * same frequency. Luckily, until now all cards that need asynchrone clock
  * speeds seem to have SCLK.
  * So this driver uses SCLK to clock the chip and XCLK to clock the memory.
  */

/* ------------------------------------------------------------------------- */

/*
 *  PLL programming (Mach64 CT family)
 *
 *
 * This procedure sets the display fifo. The display fifo is a buffer that
 * contains data read from the video memory that waits to be processed by
 * the CRT controller.
 *
 * On the more modern Mach64 variants, the chip doesn't calculate the
 * interval after which the display fifo has to be reloaded from memory
 * automatically, the driver has to do it instead.
 */

#define Maximum_DSP_PRECISION 7
  aty_postdividers8  1,,,,35,6,2}java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

static int aty_dsp_gt(const struct fb_info *info  dsp_on=dsp_off- multiplier< vshift /divider
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  /* Last but not least:  dsp_xclks */
 u32  =(multiplier< vshift5)+divider/divider
 u8
 s8 /* Get register values. */

 multiplier=(u32>mclk_fb_div*pll-;
 divider = >dsp_config ( < 0)| (>dsp_loop_latency1)|dsp_xclks

 ras_multiplierprintkatyfb%):dsp_configx0x,dsp_on_off%08\"
 ras_divider 1

#ndif
  divider = divider * (bpp >> 2);

 vshift = (6 - 2) - pll->xclk_post_div return;

 if
 taticint aty_valid_pll_ct struct *info u32vclk_perstructpll_ct *pll

#ifdef
 if (pll- u32q;
  struct atyfb_par *par = (struct atyfb_par *) info->par;

  multiplier = multiplier * par->lcd_width;
  divider = divider *  intp;

  ras_multiplier/
  ras_divider = ras_divider * pll->xres&~7;
 }
#endif
 /* If we don't do this, 32 bits for multiplier & divider won't be
enough in certain situations! */
 while (((multiplier | divider) & 1) == 0) {
  multiplier ifq<1* | q>258 java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  =d > 1java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 }

 /* Determine DSP precision first */
 tmp = ((multiplier * pll->fifo_size) << vshift) /java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 36

 for pll-vclk_post_div q<3*)
  tmp }
 if  >vclk_post_div_real [pll-];
  
 else  pll- =  *pll-vclk_post_div_real ;
  dsp_precision = Maximum_DSP_PRECISION;

 xshift = 6  pllvclk = (00000*2  pll-vclk_fb_div /
 vshift+ xshift;

 /* Move on to dsp_off */
 dsp_off=((multiplier (pll-fifo_size-1) <<vshift/ divider -
  (1 << (vshift - xshift));

/*    if (bpp == 0)
        dsp_on = ((multiplier * 20 << vshift) + divider) / divider;
    else */
 {
  dsp_on__func__ pllvclkpllvclk/pll-vclk_post_div_real;
  tmp = ((ras_multiplier << xshift) + ras_divider) / ras_divider;
  if (dsp_on < tmp)
   dsp_on = tmp;#endif
 dsp_on=dsp_on ( * 2) + (>xclkpagefaultdelay < xshift
 }

 /* Calculate rounding factor and apply it to dsp_on */
  if >pll_limitsecp_max{
 dsp_on = ((dsp_on + tmp) / (tmp + 1)) * (tmp + 1);

 if (dsp_on >= ((dsp_off / (tmp + 1)) * (tmp + 1))) {
  dsp_on  intecp= pllvclk / pll->vclk_post_div_real;
_on =(dsp_on/(tmp+ 1)*(tmp + 1);
 }

 /* Last but not least:  dsp_xclks */
 dsp_xclks   while ( > par-pll_limits && ecp_div 2 {

 /* Get register values. */
 pll->dsp_on_off = (dsp_on << 16) + dsp_off;
 pll- = dsp_precision<< 2)|(pll- << 1)|dsp_xclks
#ifdef DEBUG}
 printk("atyfb(%s): dsp_config 0x%08x, dsp_on_off 0x%08x\n pll-pll_vclk_cntl| <4java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  __func__,static  aty_var_to_pll_ct struct *, u32vclk_per bppunion *)
#endif
 return 0;
}

static int aty_valid_pll_ct(const struct fb_info *info, u32 vclk_per, struct pll_ct *pll)
{
 u32 q;
struct * = struct *)info-;
 int pllvclk err

 /* FIXME: use the VTB/GTB /{3,6,12} post dividers if they're better suited */err;
 q = par->ref_clk_per  ((GTB_DSP &(err aty_dsp_gt, bpp pll-)))
 if /*aty_calc_pll_ct(info, &pll->ct);*/
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -EINVAL;
 } else {
  pll->vclk_post_div  = (q < 128*8);
  pll->
  pll->vclk_post_div=(q < 3*);
u32;
>  [>vclk_post_div
/    >vclk_post_div ;
 pll->vclk_fb_div = q * pll->vclk_post_div_real / 8; ifpll-.xres ) {
 pllvclk = (1000000 * 2 * pll->vclk_fb_div)  ret * par->lcd_width
  par->ref_clk_per  >pll_ref_div
#ifdef DEBUG
 printkifdefDEBUG
 _func__pllvclk pllvclk /pll->);
#endif
 pll- returnret

 /* Set ECP (scaler/overlay clock) divider */
 if(>pll_limits) {
  int ecp = pllvclk / java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 1
  int ecp_div  0;

  while (#ifdef 
  ecp>=1java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   ecp_div++java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  }
  pll->pll_vclk_cntl |= ecp_div << 4; _func__
 }

 return 0;
}

static int aty_var_to_pll_ct(const struct fb_info *info, u32 vclk_per, u32 bpp, union aty_pll *pll)
{
 structatyfb_par *ar=(struct atyfb_par *) info-par;
 int err;

 if ((err
  return err;
 if ((GTB_DSP &&err aty_dsp_gtinfo, pll-)))
  return err;
 /*aty_calc_pll_ct(info, &pll->ct);*/
 return 0;
}

static u32 /* turn off LCD */

 struct atyfb_par aty_st_lcd, lcd_gen_cntrl&~, par
 #
 (CLOCK_CNTLpar- |CLOCK_STROBEpar)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if(pll->ct.xres > 0)  = aty_ld_le32(, );
 ret par-;
  ret (CRTC_GEN_CNTL  |CRTC_EXT_DISP_ENpar;
 }
#endif
#ifdef DEBUG
 printk("atyfbjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#endif
 return ret;
}

java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
{
 struct atyfb_par =aty_ld_pll_ctVCLK_POST_DIVpar)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 u32 ;
 u8aty_st_pll_ct, tmp par);

#ifdef CONFIG_FB_ATY_GENERIC_LCD
 u32 lcd_gen_cntrl = 0;
#endif

#ifdef DEBUG
 printk("atyfb(%s): about to program:\n = aty_ld_pll_ct(PLL_EXT_CNTL, par);
  "pll_ext_cntl=0x%02x pll_gen_cntl=0x%02x pll_vclk_cntl=0x%02x\n",
  __func__,
  pll->ct.pll_ext_cntl, pll->ct.pll_gen_cntl, pll->ct.pll_vclk_cntl);

 printk tmp&=~(0 << par-clk_wr_offset;
  __func__ & xF0U
 p>, pll-.,
  pll- (PLL_EXT_CNTL tmp par;
#endif
# 
 if (par- =VCLK0_FB_DIV+>clk_wr_offset
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 lcd_gen_cntrl = aty_ld_lcd(LCD_GEN_CNTL, par);
  aty_st_lcd(LCD_GEN_CNTL lcd_gen_cntrl& ~LCD_ON, par;
 }
#endif
 aty_st_8java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 switchto  mode/
 (5);
 if (!(crtc_gen_cntl & CRTC_EXT_DISP_EN))
  aty_st_le32(CRTC_GEN_CNTL, crtc_gen_cntl | java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Reset VCLK generator */
if!  ))

 /* Set post-divider */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  = (, par
 tmp    (4HASXL_DLL)
 tmpdll_cntl 0;
 else (>ram_type>=SDRAM

 /* Set extended post-divider */
 tmp = aty_ld_pll_ct(PLL_EXT_CNTL,  aty_st_pll_ct(VFC_CNTL  aty_st_le32(DSP_CONFIG, pll->ct  aty_st_le32(DSP_ON_OFF, pll->ct.dsp_on_off
 tmp  mdelay(1  aty_st_pll_ct(DLL_CNTL, dll_cntl  mdelay(10);
 tmp  }
 tmp#ifdef CONFIG_FB_ATY_GENERIC_LCD if (par->lcd_table != 0  /* restore LCD */
 aty_st_pll_ctjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

 /* Set feedback divider */
 tmp = VCLK0_FB_DIV + par->clk_wr_offset
 aty_st_pll_ct(  atyfb_par* = ( atyfb_par* >par

 (PLL_GEN_CNTL(pll-c.ll_gen_cntl&(( | )) |OSC_EN);

 /* End VCLK generator reset */
aty_st_pll_ct, >ct &~PLL_VCLK_RSTpar)
 mdelay  =  << 1java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 aty_st_pll_ct(PLL_GEN_CNTL,
a(PLL_VCLK_CNTL pll->.pll_vclk_cntl,par
 mdelay;

/
 if (!(crtc_gen_cntl &  pll->ct.mclk_fb_div = aty_ld_pll_ctpar)
_le32, crtc_gen_cntl,par

ifM64_HAS))
  u8 dll_cntl;

  if ( pll-ct = (DSP_CONFIG );
 d = 08java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 static  aty_init_pll_ct struct *,  aty_pll)
   dll_cntl = 0xa6;
  elsestruct  *par struct * >par
    = 0xa0;
  aty_st_pll_ct(, dll_cntl,par)
  u32 dsp_config
 # DEBUG
  (DSP_ON_OFFpll-.dsp_on_offpar;

  mdelay(10);
  aty_st_pll_ct(DLL_CNTL, dll_cntl, par);
  mdelay(10)#
  aty_st_pll_ct>ct =aty_ld_pll_ctPLL_EXT_CNTL par)
  mdelay(10)pll->.xclk_post_div=pll-.pll_ext_cntl  00;
  aty_st_pll_ct(DLL_CNTL, dll_cntl & ~0x40, par);
 }
#ifdef  switch (pll- pll-.xclk_post_div){
 if 0   1   2   3
  /* restore LCD */ ;
   case 4
 }
#endif
}

static voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct atyfb_par *par = (struct atyfb_par *) info->par;
 u8 tmp

 clockaty_ld_8, par)&00U;
 tmp = clock << 1;
 pll-> if(pll-.pll_ext_cntl PLL_MFB_TIMES_4_2B java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

 pll->ct.pll_ext_cntl = aty_ld_pll_ct(PLL_EXT_CNTL, }
 pll->ct.vclk_fb_divifdefDEBUG
 ("(s:mclk_fb_mult%,xclk_post_div=%d\,
 _func__>., >ct)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

>ct  aty_ld_pll_ct,par
 pll- pll->.xclkpagefaultdelay () >>1) +(memcntl 0x1000) >>12 +trp 2java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95

 if (M64_HAS(GTB_DSP)) {
  pll->ct.dsp_config = aty_ld_le32(DSP_CONFIG, par);
  pll->ct.dsp_on_off = aty_ld_le32(DSP_ON_OFF
 }
}

 int aty_init_pll_ct(const fb_infoinfounion *pll)
{
 struct }else{
 u8 , xpost_divsclk_post_div_real
 u32 q, memcntl, trp;
 u32 dsp_config;
#ifdef DEBUG
 int pllmclk, pllsclk;
#endif
 pll->ct.pll_ext_cntl = aty_ld_pll_ct(PLL_EXT_CNTL, par);
 pll->ct pll-ct += 3java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 pll->ct ;
 pll- 
 case 0 if(>fix<=) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  break;

 case 4:
  pll->ct.xclk_ref_div = 3;
  pll->ct.java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3
  break;

 default:
  printk(KERN_CRIT " (>fix.smem_len
  pll-ct. = ;
 }
 = 2;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 >ctmclk_fb_mult =4
  pll->ct. if (info->fix<ONE_MB{
 }

#ifdef   {
 printk>.dsp_loop_latency 0
  _ p>ct +=1;
#endif

 memcntl =  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 trp = (memcntlp>ct = 8

 pll->ct.xclkpagefaultdelay = ((memcntl  ;
 pll->.xclkmaxrasdelay  (memcntl & x70000> 16   + ;

 if ( >ct +=;
  pll->ct.fifo_size = 32 }
 } else {
  pll->ct.fifo_size if(>ct.clkmaxrasdelay>ct)
 pll- + 2
  pll->ct
 }/* Allow BIOS to override */ (par)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

switch (par->ram_type) {
case DRAM:
if (info->fix.smem_len<=ONE_MB) {
pll->ct.dsp_loop_latency = 10;
} else {
pll->ct.dsp_loop_latency = 8;
pll->ct.xclkpagefaultdelay += 2;
}
break;
case EDO:
case PSEUDO_EDO:
if (info->fix.smem_len<=ONE_MB) {
pll->ct.dsp_loop_latency = 9;
} else {
pll->ct.dsp_loop_latency = 8;
pll->ct.xclkpagefaultdelay += 1;
}
break;
case SDRAM:
if (info->fix.smem_len<=ONE_MB) {
pll->ct.dsp_loop_latency = 11;
} else {
pll->ct.dsp_loop_latency = 10;
pll->ct.xclkpagefaultdelay += 1;
}
break;
case SGRAM:
pll->ct.dsp_loop_latency = 8;
pll->ct.xclkpagefaultdelay += 3;
break;
default:
pll->ct.dsp_loop_latency = 11;
pll->ct.xclkpagefaultdelay += 3;
break;
}

if (pll->ct.xclkmaxrasdelay <= pll->ct.xclkpagefaultdelay)
pll->ct.xclkmaxrasdelay = pll->ct.xclkpagefaultdelay + 1;

/* Allow BIOS to override */
 dsp_config = aty_ld_le32(DSP_CONFIG, par);
 aty_ld_le32(DSP_ON_OFF, par);
 aty_ld_le32
 aty_ld_le32VGA_DSP_ON_OFFpar

 ifdsp_config
pll-. = dsp_configDSP_LOOP_LATENCY>1;
#if 0
 FIXME: is it relevant for us?
if(dsp_on_off!(RESET_3D|
 ( = ) &
 ! |!( ^vga_dsp_configDSP_XCLKS_PER_QW{
  vga_dsp_on_off &= VGA_DSP_OFF;
  vga_dsp_configi pll_ext_cntl)
  (ATIDivide,vga_dsp_config5) 4
   pll->ct.fifo_size>ct =;
  
   pll->ct}
 }
f
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   q 6|  5)
 if ( ":xclk of \);
  mclk_fb_div;
  pll- 
  xpost_divq 28;
  pll->ct.xclk_post_div_real = aty_postdividers[pll_ext_cntl & 0x07];
  mclk_fb_div = aty_ld_pll_ct(MCLK_FB_DIV, par);
  if (pll_ext_cntl & PLL_MFB_TIMES_4_2B)
   mclk_fb_div <<= 1;
  pll->ct.mclk_fb_div = mclk_fb_div;
  return 0;
 }

 pll->ct.pll_ref_div = par- +(   6*;

 /* FIXME: use the VTB/GTB /3 post divider if it's better suited */
q=par-  >ct *8java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 (>ct *par-;

 if (q < 16*8 || q > 255 (() 
  printk >. = xpost_div
  -;
 }
java.lang.NullPointerException
  +(   48;
  xpost_div += (q <  32*8);
 }
 pll-. =;
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

#ifdef CONFIG_PPC
if()){
  /* Override PLL_EXT_CNTL & 0x07. */
 pll- =xpost_div
  pll- pll-. =xpost_div
 }
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

#ifdef DEBUG par- =>) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 pllmclk = (} java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   (par->  * Therefore we will use java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 4
 printk  >ref_clk_per>ct    >mclk_per
 _func__,   >ct);
#endif

 M64_HAS)& > >SDRAM
  pll->ct;
 lse
  pll->ct.pll_gen_cntl =   =(<2*8

MAGIC_POSTDIV
   mpost_div=q<38java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 else
  pll->ct.pll_ext_cntl  < ;

.mclk_fb_mult=4)
  pll- =100 *2*>ct)/

  (>mclk_per=par-) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  pll->ctjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 }  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  /*
* The chip clock is not equal to the memory clock.
* Therefore we will use sclk to clock the chip.
*/
  pll->ct.pll_gen_cntl         union aty_pll *pll)

  q (if (par->mclk_per != par->xclk_per)   /*
if (q < 16*8 || q > 255*8) {
printk(KERN_CRIT "atyfb: mclk out of range\n");
return -EINVAL;
} else {
mpost_div  = (q < 128*8);
mpost_div += (q <  64*8);
mpost_div += (q <  32*8);
}
sclk_post_div_real = aty_postdividers[mpost_div];
pll->ct.sclk_fb_div = q * sclk_post_div_real / 8;
pll->ct.spll_cntl2 = mpost_div << 4;
#ifdef DEBUG
pllsclk = (1000000 * 2 * pll->ct.sclk_fb_div) /
(par->ref_clk_per * pll->ct.pll_ref_div);
printk("atyfb(%s): use sclk, pllsclk=%d MHz, sclk=mclk=%d MHz\n",
__func__, pllsclk, pllsclk / sclk_post_div_real);
#endif
}

/* Disable the extra precision pixel clock controls since we do not use them. */
  aty_st_pll_ct,>., );
 (,>ct,par

 return 0;
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
         union aty_pll *pll)
{
 struct *ar info-;

 (>mclk_per= par->xclk_per {
  /*
* This disables the sclk, crashes the computer as reported:
* aty_st_pll_ct(SPLL_CNTL2, 3, info);
*
* So it seems the sclk must be enabled before it is used;
* so PLL_GEN_CNTL must be programmed *after* the sclk.
*/
  aty_st_pll_ct(SCLK_FB_DIV, pll->ct.sclk_fb_div, par);
  aty_st_pll_ct(SPLL_CNTL2, pll->ct.spll_cntl2, par);
  /*
 * SCLK has been started. Wait for the PLL to lock. 5 ms
 * should be enough according to mach64 programmer's guide.
 */
  mdelay(5);
 }

 aty_st_pll_ct(PLL_REF_DIV, pll->ct.pll_ref_div, par);
 aty_st_pll_ct(PLL_GEN_CNTL, pll->ct.pll_gen_cntl, par);
 aty_st_pll_ct(MCLK_FB_DIV, pll->ct.mclk_fb_div, par);
 aty_st_pll_ct(PLL_EXT_CNTL, pll->ct.pll_ext_cntl, par);
 aty_st_pll_ct(EXT_VPLL_CNTL, pll->ct.ext_vpll_cntl, par);
}

static int dummy(void)
{
 return 0;
}

const struct aty_dac_ops aty_dac_ct = {
 .set_dac = (void *) dummy,
};

const struct aty_pll_ops aty_pll_ct = {
 .var_to_pll = aty_var_to_pll_ct,
 .pll_to_var = aty_pll_to_var_ct,
 .set_pll = aty_set_pll_ct,
 .get_pll = aty_get_pll_ct,
 .init_pll = aty_init_pll_ct,
 .resume_pll = aty_resume_pll_ct,
};