Forum: Mikrocontroller und Digitale Elektronik microchip user space api wie nutzen für phi ?

Hmm also es muss in diese Richtung gehen denke ich:

https://microchipsupport.force.com/s/article/Software-Availability-for-VSC-PHY-s

1

The PHY API is a software package that is compiled with or linked to the Application.  The API uses accessor functions (MDIO/SPI) to control and configure the PHY registers.

2

3

There are 2 flavors of API:

4

5

-          VSC6803 ETH API (also referred to as MESA - Microsemi Ethernet Switch API)

6

7

-          VSC6802 PHY API (ONLY applicable for certain LEGACY designs)

8

9

VSC6803 ETH API is recommended for all designs with one (rare) exception.

___

Angang.
Habe MESA jetzt mal geöffnet. Was muss man damit machen?

Genau was ich brauche:

"The User Space API is OS agnostic and may be used with any OS.  The 
User Space API comprises standard ‘C’ code functions for the specified 
VSC PHYs."
"Die User Space API ist betriebssystemunabhängig und kann mit jedem 
Betriebssystem verwendet werden. Die User Space API umfasst 
Standard-C-Code-Funktionen für die angegebenen VSC PHYs

Ok jetzt würde ich gerne mit meinem externen controller, mit dem ich 
bereits I2C Zugriff auf meinem PHY habe, diese API verwenden.

https://github.com/microchip-ung/mesa

Dort gibt es auch eine Datei die ich compiliert habe damit eine 
weiterführende Readme erstellt wird, habe diese hier hochgeladen:
https://file.io/Dlni3PFH2uLu

Muss man da einfach nur die Befehle für MDIO oder SPI austauschen gegen 
meine I2C Befehle?
Danke

pgold schrieb:
> Muss man da einfach nur die Befehle für MDIO oder SPI austauschen gegen
> meine I2C Befehle?
> Danke
Also diese PDF ist interessant, weil dort wird etwas ähnliches 
beschrieben denke ich...
https://ww1.microchip.com/downloads/en/Appnotes/ENT-AN1007-4.3_VPPD-04303.pdf

Also diese besagte PDF scheint älter zu sein und mit der Bibliothek von 
Vitess zu arbeiten. Aber ich nehme an, dass das Prinzip ähnlich sein 
muss..

Ok vielleicht geht es so?:

Man übergibt normalerweise der Board-Beschreibungs-Structure (C-Code) 
die Funktion die per SPI auf den PHY zugreifen soll.

Allerdings möchte ich ja I2C verwenden.

Ich würde also Meine_I2C_Zugriffsfunktion_aufPHY() verwenden, mit den 
gleichen Paramatern.

1

vtss_rc Meine_I2C_Zugriffsfunktion_aufPHY (

2

3

const vtss_inst_t inst,

4

vtss_port_no_t port_no,

5

BOOL read,

6

u8 dev,

7

u16 reg_num,

8

u32 *const data) {

9

10

// lese 32 bit register vom phy via i2c entsprechend den parametern und gebe vtss_rc zurück 

11

12

13

}

14

// bei der initialisierung:

15

board->init.init_conf->spi_32bit_read_write =*Meine_I2C_Zugriffsfunktion_aufPHY;

Ah ok,
habe gerade ein Beispiel gesehen...


In der vtss_appl_board_venice.c

//Zuerst deklarieren sie ein Board:
--

1

vtss_appl_board_t *board;

2

// Hier kommt noch etwas unverständliches:

3

// In this case we only have one board. Assign point to the board definition

4

board = &board_table[0];

5

memset (&board_table[0], 0, (sizeof(vtss_appl_board_t) * MAX_BOARD_INSTANCES));

// Sie initialisieren das Board:
---

1

vtss_board_phy_init(board);

2

//sie kreieren ein Board:

3

// "Create" the board

4

vtss_inst_get(board->target, &create);

5

vtss_inst_create(&create, &board->inst);

6

vtss_init_conf_get(board->inst, &init_conf);

//Die Funktion vtss_board_phy_init() enthält:
---

1

2

board->board_init = venice_board_init;

3

//Diese Funktion(venice_board_init) befindet sich in phy_demo_appl/appl/vtss_appl_board_venice.c

4

// Sie enthält zwei mögliche Funktionen:

5

#if defined(RPI_MIIM)

6

rpi_venice_board_init(argc, argv, board); // Use init function for Raspberry PI MIIM.

7

#else

8

venice_char_board_init(argc, argv, board); // Use init function for Rabbit MIIM.

9

#endif /* RPI_MIIM */

Beide würden ein anderes Board definieren. Einer bezeichnet einen 
RaspberryPI, ein anderer ein Rabbit-Board.
Ich glaube, das rpi-Board wird hier nicht beschrieben -
Letztlich gibt es dann die Zeile, in der es explizit heißt:

1

board->init.init_conf->spi_32bit_read_write = *spi_32bit_read_write_rbt; // Set pointer to the SPI read function for this board.

Die Funktion spi_32bit_read_write_rbt; ist nur einige Zeilen zuvor 
definiert:

1

////////////////////////////////////////////////////////////////////////////////

2

// MMD_Read and MMD_Write Code for Rabbit

3

// ---Unfinished because the rabbit code is optimized for neumonic values not straight port/mmd/addr hex values

4

////////////////////////////////////////////////////////////////////////////////

5

vtss_rc mmd_read_rbt(const vtss_inst_t inst,

6

       const vtss_port_no_t port_no,

7

                     const u8 mmd,

8

                           u16 addr,

9

                           u16 *const value)

10

{

11

  char buffer[255];

12

  int v;

13

14

  sprintf(buffer, "mdio_rd %x %x %x", port_no, mmd, addr);

15

  printf ("%s\n", buffer);

16

  T_N("mmd_read_rbt: %s", buffer);

17

  socket_write(&buffer[0]);

18

  memset(buffer, 0, sizeof(buffer));

19

  socket_read(&buffer[0]);

(Aber es ist seltsam, da dieses Beispiel einen Socket für SPI verwendet.
Vielleicht hat jemand eine Idee dazu)

Ich sollte also meine eigene Board-Definition verwenden, denke ich ....
Und vielleicht den SPI-Zugang durch meine Board-spezifische I2C-Funktion 
ersetzen? Ich meine ich habe keine andere Verbindung zu dem PHY..

hmm microchip selber sagt zwar für gewisse handshakes ist die API zu 
empfehlen. Allerdings gibt es dort sehr viel overhead in den 
Beispielen... Außerdem meinte Microchip gerade, I2c sei nicht wirklich 
unterstützt und es könnte nicht klappen!

ok würde jetzt schauen ob man die vorgefertigten Funktionen eben für die 
eigene Anwendung verwenden kann. Zumindest prinzipiell.

sieht sehr viel aus. kennt sich da jemand aus?

jetzt läuft das ganze schon besser mit dem ganzen Code.
Er wird durchlaufen. Mein I2C Befehl wird zum Lesen/ Schreiben 
verwendet. Makros und Strukturen kann ich verwenden.

Kennt sich jemand aus worauf man jetzt achten muss, damit der phy-chip 
startet?

Vielen Dank :)

ok es scheint der richtige Weg zu sein, aber trotzdem muss man auf den 
Programmfluss in der API achten, damit alle nötigen Registerzugriffe 
gemacht werden!
Man muss da schon wachsam sein!