Ticket #3353: qemu_powerpc_prep_ide_driver.diff

File qemu_powerpc_prep_ide_driver.diff, 18.7 KB (added by Eric Tremblay, on Mar 16, 2018 at 5:26:31 PM)

qemuppc IDE driver

  • c/src/lib/libbsp/powerpc/motorola_powerpc/Makefile.am

     .../libbsp/powerpc/motorola_powerpc/Makefile.am    |   6 +
     c/src/lib/libbsp/powerpc/qemuppc/ide/ide.c         | 372 +++++++++++++++++++++
     c/src/lib/libbsp/powerpc/qemuppc/ide/idecfg.c      |  59 ++++
     3 files changed, 437 insertions(+)
    
    diff --git a/c/src/lib/libbsp/powerpc/motorola_powerpc/Makefile.am b/c/src/lib/libbsp/powerpc/motorola_powerpc/Makefile.am
    index 1cf3671233..3304037d51 100644
    a b libbsp_a_SOURCES += ../../shared/vmeUniverse/VME.h 
    108108libbsp_a_SOURCES += ../../powerpc/shared/vme/vmeconfig.c
    109109libbsp_a_SOURCES += ../../powerpc/shared/vme/vme_universe.c
    110110
     111if QEMU
     112# ide
     113libbsp_a_SOURCES += ../qemuppc/ide/idecfg.c
     114libbsp_a_SOURCES += ../qemuppc/ide/ide.c
     115endif
     116
    111117if QEMU
    112118if HAS_NETWORKING
    113119libbsp_a_SOURCES += ../../i386/pc386/ne2000/ne2000.c
  • new file c/src/lib/libbsp/powerpc/qemuppc/ide/ide.c

    diff --git a/c/src/lib/libbsp/powerpc/qemuppc/ide/ide.c b/c/src/lib/libbsp/powerpc/qemuppc/ide/ide.c
    new file mode 100644
    index 0000000000..7fbcf7c1b4
    - +  
     1/*===============================================================*\
     2| Project: RTEMS qemuprep IDE harddisc driver                     |
     3+-----------------------------------------------------------------+
     4| File: ide.c                                                     |
     5+-----------------------------------------------------------------+
     6|                                                                 |
     7+-----------------------------------------------------------------+
     8| this file contains the BSP layer for qemuprep IDE access        |
     9| below the libchip IDE harddisc driver                           |
     10| based on a board specific driver from                           |
     11| Eugeny S. Mints, Oktet                                          |
     12|                                                                 |
     13|  The license and distribution terms for this file may be        |
     14|  found in the file LICENSE in this distribution or at           |
     15|  http://www.rtems.org/license/LICENSE.                          |
     16|                                                                 |
     17+-----------------------------------------------------------------+
     18|   date                      history                        ID   |
     19| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
     20| 03.09.18  creation          Inspired from PC386 version    et   |
     21\*===============================================================*/
     22
     23#include <rtems.h>
     24#include <bsp.h>
     25#include <libchip/ide_ctrl.h>
     26#include <libchip/ide_ctrl_cfg.h>
     27#include <libchip/ide_ctrl_io.h>
     28#include <sys/endian.h>
     29
     30
     31/*
     32#define QEMUPPC_IDE_DEBUG
     33#define QEMUPPC_IDE_DEBUG_OUT
     34*/
     35
     36#define ATA_SECTOR_SIZE (512)
     37
     38
     39/*
     40 * support functions for PCMCIA IDE IF
     41 */
     42/*=========================================================================*\
     43| Function:                                                                 |
     44\*-------------------------------------------------------------------------*/
     45static bool qemuppc_ide_probe
     46(
     47/*-------------------------------------------------------------------------*\
     48| Purpose:                                                                  |
     49|  This function should probe, whether a disk is available                  |
     50+---------------------------------------------------------------------------+
     51| Input Parameters:                                                         |
     52\*-------------------------------------------------------------------------*/
     53 int minor
     54 )
     55/*-------------------------------------------------------------------------*\
     56| Return Value:                                                             |
     57|    true, when disk available                                              |
     58\*=========================================================================*/
     59{
     60  const bool ide_card_plugged = true; /* assume: we have a card plugged in */
     61
     62#if defined(QEMUPPC_IDE_DEBUG)
     63  printk(">>>>>  qemuppc_ide_probe()\n");
     64#endif
     65
     66  return ide_card_plugged;
     67}
     68
     69/*=========================================================================*\
     70| Function:                                                                 |
     71\*-------------------------------------------------------------------------*/
     72static void qemuppc_ide_initialize
     73(
     74/*-------------------------------------------------------------------------*\
     75| Purpose:                                                                  |
     76|  initialize IDE disk access                                               |
     77+---------------------------------------------------------------------------+
     78| Input Parameters:                                                         |
     79\*-------------------------------------------------------------------------*/
     80 int  minor                              /* controller minor number       */
     81 )
     82/*-------------------------------------------------------------------------*\
     83| Return Value:                                                             |
     84|    <none>                                                                 |
     85\*=========================================================================*/
     86{
     87#if defined(QEMUPPC_IDE_DEBUG)
     88   printk(">>>>>> qemuppc_ide_initialize()\n");
     89#endif
     90}
     91
     92/*=========================================================================*\
     93| Function:                                                                 |
     94\*-------------------------------------------------------------------------*/
     95static void qemuppc_ide_read_reg
     96(
     97/*-------------------------------------------------------------------------*\
     98| Purpose:                                                                  |
     99|  read a IDE controller register                                           |
     100+---------------------------------------------------------------------------+
     101| Input Parameters:                                                         |
     102\*-------------------------------------------------------------------------*/
     103 int                        minor,  /* controller minor number       */
     104 int                        reg,    /* register index to access      */
     105 uint16_t                  *value   /* ptr to return value location  */
     106 )
     107/*-------------------------------------------------------------------------*\
     108| Return Value:                                                             |
     109|    <none>                                                                 |
     110\*=========================================================================*/
     111{
     112  uint32_t  port = IDE_Controller_Table[minor].port1;
     113  uint8_t   bval1,bval2;
     114
     115  if (reg == IDE_REGISTER_DATA_WORD) {
     116    inport_byte(port+reg, bval1);
     117    inport_byte(port+reg+1, bval2);
     118    *value = bval1 + (bval2 << 8);
     119  }
     120  else {
     121    inport_byte(port+reg, bval1);
     122    *value = bval1;
     123  }
     124
     125#if defined(QEMUPPC_IDE_DEBUG)
     126  printk(">>>>>> qemuppc_ide_read_reg() (minor = %d, reg = 0x%x, val=0x%x)\n", minor, reg, *value);
     127#endif
     128}
     129
     130/*=========================================================================*\
     131| Function:                                                                 |
     132\*-------------------------------------------------------------------------*/
     133static void qemuppc_ide_write_reg
     134(
     135/*-------------------------------------------------------------------------*\
     136| Purpose:                                                                  |
     137|  write a IDE controller register                                          |
     138+---------------------------------------------------------------------------+
     139| Input Parameters:                                                         |
     140\*-------------------------------------------------------------------------*/
     141 int                        minor,  /* controller minor number       */
     142 int                        reg,    /* register index to access      */
     143 uint16_t                   value   /* value to write                */
     144 )
     145/*-------------------------------------------------------------------------*\
     146| Return Value:                                                             |
     147|    <none>                                                                 |
     148\*=========================================================================*/
     149{
     150  uint32_t    port = IDE_Controller_Table[minor].port1;
     151
     152#if defined(QEMUPPC_IDE_DEBUG)
     153  printk(">>>>>> qemuppc_ide_write_reg(minor=%d,reg=0x%x,val=0x%x)\n", minor,reg,value);
     154#endif
     155 
     156  if (reg == IDE_REGISTER_DATA_WORD) {
     157    outport_word(port+reg,value);
     158  }
     159  else {
     160    outport_byte(port+reg,value);
     161  }
     162}
     163
     164/*=========================================================================*\
     165| Function:                                                                 |
     166\*-------------------------------------------------------------------------*/
     167static void qemuppc_ide_read_block
     168(
     169/*-------------------------------------------------------------------------*\
     170| Purpose:                                                                  |
     171|  read a IDE controller register                                           |
     172+---------------------------------------------------------------------------+
     173| Input Parameters:                                                         |
     174\*-------------------------------------------------------------------------*/
     175 int minor,
     176 uint32_t   block_size,
     177 rtems_blkdev_sg_buffer *bufs,
     178 uint32_t   *cbuf,
     179 uint32_t   *pos
     180 )
     181/*-------------------------------------------------------------------------*\
     182| Return Value:                                                             |
     183|    <none>                                                                 |
     184\*=========================================================================*/
     185{
     186#if defined(QEMUPPC_IDE_DEBUG_OUT)
     187  int       i32 = 0;
     188  const int perLineCnt = 8;
     189#endif
     190
     191  uint32_t port = IDE_Controller_Table[minor].port1;
     192  uint32_t cnt = 0;
     193 
     194#if defined(QEMUPPC_IDE_DEBUG_OUT)
     195  printk(">>>>>>  qemuppc_ide_read_block(bs=%u,bn=%u,cb=%d,p=%d)\n",
     196             block_size, bufs[(*cbuf)].block, *cbuf, *pos);
     197#endif
     198
     199  while (cnt < block_size)
     200  {
     201    uint16_t *lbuf;
     202    const int sizeToRead = (ATA_SECTOR_SIZE / 2);
     203    int       b;
     204
     205    lbuf = (uint16_t*)((uint8_t*)(bufs[(*cbuf)].buffer) + (*pos));
     206
     207    for (b = 0; b < sizeToRead; b++)
     208    {
     209      inport_word(port+IDE_REGISTER_DATA,*lbuf);
     210     
     211#if defined(__BIG_ENDIAN__)
     212      *lbuf = bswap16(*lbuf);
     213#endif
     214
     215#if defined(QEMUPPC_IDE_DEBUG_OUT)
     216      printk(" %04x ",*lbuf);
     217      i32++;
     218      if (i32 >= perLineCnt)
     219      {
     220        printk("\n");
     221        i32 = 0;
     222      }
     223#endif
     224      lbuf++;
     225    }
     226    cnt    += ATA_SECTOR_SIZE;
     227    (*pos) += ATA_SECTOR_SIZE;
     228    if ((*pos) == bufs[(*cbuf)].length) {
     229      (*pos) = 0;
     230      (*cbuf)++;
     231      lbuf = bufs[(*cbuf)].buffer;
     232    }
     233  }
     234}
     235
     236/*=========================================================================*\
     237| Function:                                                                 |
     238\*-------------------------------------------------------------------------*/
     239static void qemuppc_ide_write_block
     240(
     241/*-------------------------------------------------------------------------*\
     242| Purpose:                                                                  |
     243|  write a IDE controller register                                          |
     244+---------------------------------------------------------------------------+
     245| Input Parameters:                                                         |
     246\*-------------------------------------------------------------------------*/
     247 int minor,
     248 uint32_t   block_size,
     249 rtems_blkdev_sg_buffer *bufs,
     250 uint32_t   *cbuf,
     251 uint32_t   *pos
     252 )
     253/*-------------------------------------------------------------------------*\
     254| Return Value:                                                             |
     255|    <none>                                                                 |
     256\*=========================================================================*/
     257{
     258  uint32_t port = IDE_Controller_Table[minor].port1;
     259  uint32_t cnt = 0;
     260
     261#if defined(QEMUPPC_IDE_DEBUG_OUT)
     262  int i32 = 0;
     263#endif
     264
     265#if defined(QEMUPPC_IDE_DEBUG)
     266  printk(">>>>>>  qemuppc_ide_write_block(bs=%u,bn=%u,cb=%d,p=%d)\n",
     267         block_size, bufs[(*cbuf)].block, *cbuf, *pos);
     268#endif
     269
     270  while (cnt < block_size)
     271  {
     272    uint16_t *lbuf;
     273    int      b;
     274
     275    lbuf = (uint16_t*)(((uint8_t*)bufs[*cbuf].buffer) + (*pos));
     276
     277    for (b = 0; b < (ATA_SECTOR_SIZE / 2); b++)
     278    {
     279#if defined(QEMUPPC_IDE_DEBUG_OUT)
     280      printk("%04x ",*lbuf);
     281      i32++;
     282      if (i32 >= 16)
     283      {
     284        printk("\n");
     285        i32 = 0;
     286      }
     287#endif
     288
     289#if defined(__BIG_ENDIAN__)
     290      *lbuf = bswap16(*lbuf);
     291#endif
     292
     293      outport_word(port+IDE_REGISTER_DATA,*lbuf);
     294      lbuf++;
     295    }
     296    cnt    += ATA_SECTOR_SIZE;
     297    (*pos) += ATA_SECTOR_SIZE;
     298    if ((*pos) == bufs[(*cbuf)].length) {
     299      (*pos) = 0;
     300      (*cbuf)++;
     301      lbuf = bufs[(*cbuf)].buffer;
     302    }
     303  }
     304}
     305
     306/*=========================================================================*\
     307| Function:                                                                 |
     308\*-------------------------------------------------------------------------*/
     309static int qemuppc_ide_control
     310(
     311/*-------------------------------------------------------------------------*\
     312| Purpose:                                                                  |
     313|  control interface for controller                                         |
     314+---------------------------------------------------------------------------+
     315| Input Parameters:                                                         |
     316\*-------------------------------------------------------------------------*/
     317 int  minor,                        /* controller minor number       */
     318 uint32_t   cmd,                    /* command to send               */
     319 void * arg                         /* optional argument             */
     320 )
     321/*-------------------------------------------------------------------------*\
     322| Return Value:                                                             |
     323|    <none>                                                                 |
     324\*=========================================================================*/
     325{
     326#if defined(QEMUPPC_IDE_DEBUG)
     327  printk(">>>>>> qemuppc_ide_control()\n");
     328#endif
     329  return 0;
     330}
     331
     332/*=========================================================================*\
     333| Function:                                                                 |
     334\*-------------------------------------------------------------------------*/
     335static rtems_status_code qemuppc_ide_config_io_speed
     336(
     337/*-------------------------------------------------------------------------*\
     338| Purpose:                                                                  |
     339|  set up transfer speed, if possible                                       |
     340+---------------------------------------------------------------------------+
     341| Input Parameters:                                                         |
     342\*-------------------------------------------------------------------------*/
     343 int        minor,                   /* controller minor number       */
     344 uint16_t   modes_avail              /* optional argument             */
     345 )
     346/*-------------------------------------------------------------------------*\
     347| Return Value:                                                             |
     348|    rtems_status_code                                                      |
     349\*=========================================================================*/
     350{
     351#if defined(QEMUPPC_IDE_DEBUG)
     352  printk(">>>>>> qemuppc_ide_config_io_speed()\n");
     353#endif
     354  return RTEMS_SUCCESSFUL;
     355}
     356
     357/*
     358 * The following table configures the functions used for IDE drivers
     359 * in this BSP.
     360 */
     361
     362ide_ctrl_fns_t qemuppc_ide_ctrl_fns = {
     363  qemuppc_ide_probe,
     364  qemuppc_ide_initialize,
     365  qemuppc_ide_control,
     366  qemuppc_ide_read_reg,
     367  qemuppc_ide_write_reg,
     368  qemuppc_ide_read_block,
     369  qemuppc_ide_write_block,
     370  qemuppc_ide_config_io_speed
     371};
     372
  • new file c/src/lib/libbsp/powerpc/qemuppc/ide/idecfg.c

    diff --git a/c/src/lib/libbsp/powerpc/qemuppc/ide/idecfg.c b/c/src/lib/libbsp/powerpc/qemuppc/ide/idecfg.c
    new file mode 100644
    index 0000000000..a78623a7d6
    - +  
     1/*===============================================================*\
     2| Project: RTEMS qemuprep IDE harddisc driver                     |
     3+-----------------------------------------------------------------+
     4| File: idecfg.c                                                  |
     5+-----------------------------------------------------------------+
     6|                                                                 |
     7+-----------------------------------------------------------------+
     8| this file contains the BSP layer for qemuprep IDE access        |
     9| below the libchip IDE harddisc driver                           |
     10| based on a board specific driver from                           |
     11| Eugeny S. Mints, Oktet                                          |
     12|                                                                 |
     13|  The license and distribution terms for this file may be        |
     14|  found in the file LICENSE in this distribution or at           |
     15|  http://www.rtems.org/license/LICENSE.                          |
     16|                                                                 |
     17+-----------------------------------------------------------------+
     18|   date                      history                        ID   |
     19| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
     20| 03.09.18  creation          Inspired from PC386 version    et   |
     21\*===============================================================*/
     22#include <rtems.h>
     23#include <bsp.h>
     24
     25#include <libchip/ide_ctrl.h>
     26#include <libchip/ide_ctrl_cfg.h>
     27#include <libchip/ide_ctrl_io.h>
     28
     29/*
     30 * The following table configures the IDE driver used in this BSP.
     31 */
     32extern ide_ctrl_fns_t qemuppc_ide_ctrl_fns;
     33
     34/* IDE controllers Table */
     35ide_controller_bsp_table_t IDE_Controller_Table[] = {
     36  {"/dev/ide0",
     37   IDE_STD,
     38   &qemuppc_ide_ctrl_fns,
     39   NULL,  /* no BSP dependent probe needed */
     40   FALSE, /* not (yet) initialized */
     41   0x1f0, /* access address for register set (ref. Qemu hw/ppc/prep.c) */
     42   FALSE,0, /* not (yet) interrupt driven */
     43   NULL
     44  },
     45  {"/dev/ide1",
     46   IDE_STD,
     47   &qemuppc_ide_ctrl_fns,
     48   NULL,  /* no BSP dependent probe needed */
     49   FALSE, /* not (yet) initialized */
     50   0x170, /* access address for register set (ref. Qemu hw/ppc/prep.c) */
     51   FALSE,0, /* not (yet) interrupt driven */
     52   NULL
     53  }
     54};
     55
     56/* Number of rows in IDE_Controller_Table */
     57unsigned long IDE_Controller_Count =
     58       sizeof(IDE_Controller_Table)/sizeof(IDE_Controller_Table[0]);
     59