PLL выдает не ту частоту, что требуется (STM32F103C8T6)

#include "stm32f10x.h"
 
 
void init_HS_Ext(void)              //настройка тактирования от внешнего кварца
{
    FLASH->ACR |= FLASH_ACR_LATENCY;
    RCC->CR|=RCC_CR_HSEON;
    while (!(RCC->CR & RCC_CR_HSERDY));
    //RCC->CFGR |= RCC_CFGR_PLLXTPRE_HSE;                       //Пределитель PLL на 1, то есть без изменений.
    //RCC->CFGR |= RCC_CFGR_PLLMULL10;                          //PLL умножаем на 10
    //RCC->CR|=RCC_CR_PLLON;                                                //Включить PLL 
    //while (!(RCC->CR & RCC_CR_PLLRDY));                       //и подождать, пока она стабилизируется
    RCC->CFGR &=~RCC_CFGR_SW;                                           //сброс переключателя SW, на всякий случай.
    RCC->CFGR |= RCC_CFGR_SW_HSE;                                   //Переключить на HSE (pll)
    RCC->CFGR |= RCC_CFGR_HPRE_DIV1;                            //AHB prescaler
    RCC->CFGR |= RCC_CFGR_PPRE1_DIV2;                           //APB1 prescaler
    RCC->CFGR |= RCC_CFGR_PPRE2_DIV1;                           //APB2 prescaler 
}
 
 void UART1_Init(void)
{
            RCC->APB2ENR    |= RCC_APB2ENR_USART1EN;    //Включаем тактирование на USART1
            USART1->BRR = 480;                                      //устанавливаем битрейт для 9600 //1920
            RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;         //подаем тактирование на порт А, при инициализации UART2 этого делать уже не надо
            GPIOA->CRH |= GPIO_CRH_MODE9;                       //Выход с максимальной частотой 50Мгц*/
    GPIOA->CRH |= GPIO_CRH_CNF9_1;         // Tx CNF - 10: Альтернативная фукция, выход, подтяжка
     /*Rx,Tx setup GPIOA->CRH = 0x000004B0*/
            GPIOA->CRH &= ~(GPIO_CRH_CNF9_0);
 
            GPIOA->CRH &= ~(GPIO_CRH_MODE10);  // Rx Mode 00 Вход (reset state)
            GPIOA->CRH |= GPIO_CRH_CNF10_0;    // Rx CNF  01 Висит в воздухе (reset state)
     
            USART1->CR1  |= USART_CR1_UE | USART_CR1_TE | USART_CR1_RE | USART_CR1_RXNEIE | USART_CR1_IDLEIE; // TX ON, RX ON
            USART1->CR2 = 0;
            USART1->CR3 = 0;
            NVIC_EnableIRQ (USART1_IRQn);                       //разрешить прерывания от USART1
            __enable_irq ();                                                //разрешить глобальные прерывания
}
 
void GPIO_Init (void)
{
    RCC->APB2ENR |= RCC_APB2ENR_IOPCEN;
    GPIOC->CRH |= GPIO_CRH_MODE15_1;
    GPIOC->CRH &=~(GPIO_CRH_CNF15_0 | GPIO_CRH_CNF15_1);        //CNF[01]
}   
 
 
 
int main(void)
{
    
    init_HS_Ext();
    GPIO_Init();
    UART1_Init();
    int i;
    while(1)
    {
    GPIOC->BSRR |= GPIO_BSRR_BS15;
    USART1->DR = 'M';
    for(i=0; i<0x40000; i++);
    GPIOC->BRR |= GPIO_BRR_BR15;
    for(i=0; i<0x40000; i++);
    }
    
}

RCC->CR |= RCC_CR_HSION;                            // Включить генератор HSI
RCC->CFGR &= ~RCC_CFGR_SW_PLL | RCC_CFGR_SW_HSE;    // сброс регистров SW_PLL && SW_HSE
RCC->CR &= ~RCC_CR_PLLON;                           // сброс PLL
RCC->CR &= ~RCC_CR_HSEON;                           // сброс HSE
    
RCC->CR |= RCC_CR_HSEON;                            // Включить генератор HSE
while (!(RCC->CR & RCC_CR_HSERDY)){}                         // Ожидание готовности HSE
 
RCC->CFGR |= RCC_CFGR_HPRE_DIV1;                    // HCLK = SYSCLK
RCC->CFGR |= RCC_CFGR_PPRE2_DIV1;                   // PCLK2 = HCLK
RCC->CFGR |= RCC_CFGR_PPRE1_DIV1;                   // PCLK1 = HCLK
 
RCC->CFGR |= RCC_CFGR_ADCPRE;                       
 
RCC->CFGR2 &= ~RCC_CFGR2_PREDIV;                    // Предочистка
RCC->CFGR &= ~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMUL); // Предочистка 
RCC->CFGR2 |= RCC_CFGR2_PREDIV_DIV4;                // Делить частоту HSE на 4     
RCC->CFGR |= RCC_CFGR_PLLSRC_HSE_PREDIV;            // Тактировать PLL от HSE/PREDIV1
RCC->CFGR |= RCC_CFGR_PLLMUL12;                     // Умножать частоту на 12
 
RCC->CR |= RCC_CR_PLLON;                            // Запустить PLL
while((RCC->CR & RCC_CR_PLLRDY)==0){}               // Ожидание готовности PLL
RCC->CFGR &=~RCC_CFGR_SW;                           // Очистить биты SW0, SW1
 
RCC->CFGR |= RCC_CFGR_SW_PLL;                       // Тактирование с выхода PLL
while ((RCC->CFGR&RCC_CFGR_SWS)!=0x08);             // Ожидание переключения на PLL

for(i=0;i<0x0FFF;i++){
  if((RCC->CFGR & RCC_CFGR_SWS)==RCC_CFGR_SWS_PLL){i=0x1FFF; break;}
}