Riferimenti:

http://ww1.microchip.com/downloads/en/DeviceDoc/ATWILC1000-ATWILC3000-ATWILC-Devices-Linux-Porting-Guide-User-Guide-DS70005329C.pdf

Alcuni tentativi qui:

https://github.com/linux4wilc/driver/issues/41

Compilazione sul dispositivo

Utilizzo del driver di staging

Per prima cosa proviamo il driver di staging presente nel kernel Linux mantenuto dalla Raspberry Pi Foundation. Seguiamo la configurazione descritta nel capitolo 2.3, “Kernel Configuration”, della guida al porting di ATWILC3000.

È necessario eseguire ulteriori passaggi? Molto probabilmente dobbiamo abilitare il supplicant WPA e il server DHCP, ecc., come mostrato nel capitolo 3.

Quindi abbiamo ricompilato il kernel secondo la guida ufficiale e ora vediamo:

pi@raspberrypi:~ $ cat /lib/modules/4.19.
4.19.66+/    4.19.66-v7+/ 4.19.80-v7+/

È comparsa una nuova versione (4.19.80): è un errore significativo. Avevamo scritto sulla scheda microSD il kernel 4.19.66, ma poi scaricato dal repository Git la revisione più recente, che nel frattempo era avanzata. Rischiamo così di avere moduli e framework, per esempio Qt, compilati per una versione del kernel diversa da quella installata. I moduli personalizzati potrebbero non caricarsi più.

Per risolvere il problema avremmo dovuto fare alcuni passi prima di ricompilare il kernel con la nuova configurazione. I passaggi corretti sono illustrati nel capitolo successivo.

Ottenere le sorgenti del kernel corrette

La procedura abituale

Ottenere il sorgente corretto per compilare il kernel è più complicato di quanto si possa immaginare. Come spiegato su kernelnewbies.org è necessaria la versione esatta degli header del kernel per cui sono stati creati i moduli.

Di norma installeresti il pacchetto degli header corrispondente alla versione restituita da uname -r. Raspbian distribuisce pacchetti di header, ma la Raspberry Pi Foundation, che modifica il kernel, non lo faceva per queste versioni: se ne parla anche nel forum Raspberry Pi.

La procedura Raspberry Pi

La Raspberry Pi Foundation mantiene invece i sorgenti completi nel proprio repository Linux su GitHub. Quando crea un firmware Raspberry Pi, proprietario e closed source, i binari vengono inseriti nel repository del firmware, insieme a un file con l'hash del commit del kernel usato per compilarli.

Quindi, fortunatamente per noi, c'è un collegamento che puoi seguire per ottenere il codice sorgente esatto e i passaggi sono i seguenti:

  1. Ricava l'hash del firmware dal Raspberry Pi.
  2. Ricava l'hash del kernel Linux dal repository GitHub “firmware”.
  3. Recupera i sorgenti del kernel Linux dal repository GitHub “linux”.
# Get the Firmware Hash from the Raspberry Pi
FIRMWARE_HASH=$(zgrep "* firmware as of" /usr/share/doc/raspberrypi-bootloader/changelog.Debian.gz | head -1 | awk '{ print $5 }')

# Get the git hash for this kernel
KERNEL_HASH=$(wget https://raw.github.com/raspberrypi/firmware/$FIRMWARE_HASH/extra/git_hash -O -)

# Checkout the files on ubuntu
git checkout $KERNEL_HASH

In questo modo le sorgenti corrispondono a quelle attualmente installate. Le compilazioni già eseguite restano valide!

Qualche dubbio dopo la compilazione...

Ora abbiamo compilato e installato un kernel personalizzato con il driver wilc. Potrebbero sorgere alcune domande:

  1. Il modulo espone due interfacce, SDIO e SPI. Quale viene usata? Il kernel riconosce l'interfaccia presente e associa il driver; due driver in competizione per la stessa interfaccia non possono essere caricati entrambi.
  2. Se è il kernel a scegliere l'interfaccia, come gli passiamo i pin da utilizzare? Possiamo modificare l'assegnazione predefinita, magari tramite parametri a insmod?
  3. È davvero necessario ricompilare l'intero kernel per abilitare i driver di staging?

Ed ecco le risposte dopo le verifiche:

  1. L'interfaccia è definita nell'overlay indicato da /boot/config.txt.
  2. L'overlay è configurabile e il driver può supportare parametri: possiamo indicare interfaccia e pin specifici del modulo. In questo caso i pin non erano usati correttamente, quindi abbiamo modificato il driver.
  3. Una volta compilato il kernel, le modifiche successive al driver richiedono di ricompilare solo i file interessati, non l'intero kernel.

Un piccolo script per compilare il modulo è questo:

#!/bin/sh -e
cd ./arch/arm/boot/dts/overlays/
gedit atwilc3000.dts
dtc -I dts -O dtb -o atwilc3000.dtb atwilc3000.dts
sudo cp atwilc3000.dtb /boot/overlays/atwilc3000.dtb

Un altro script per compilare tutto il kernel con i moduli (una volta eseguite le istruzioni per configurare i sorgenti – vedere la guida mhcp):

#!/bin/sh -e
KERNEL=kernel7
make bcm2709_defconfig
make -j4 zImage modules dtbs
sudo make modules_install
sudo cp arch/arm/boot/dts/*.dtb /boot/
sudo cp arch/arm/boot/dts/overlays/*.dtb* /boot/overlays/
sudo cp arch/arm/boot/dts/overlays/README /boot/overlays/
sudo cp arch/arm/boot/zImage /boot/$KERNEL.img
echo "Finished building kernel. Moving to device tree"
cd ./arch/arm/boot/dts/overlays/
gedit atwilc3000.dts
dtc -I dts -O dtb -o atwilc3000.dtb atwilc3000.dts
sudo cp atwilc3000.dtb /boot/overlays/atwilc3000.dtb

Ricaricamento del modulo

sudo insmod /lib/modules/4.19.75-v7+/kernel/drivers/net/wireless/mchp/wilc-spi.ko

Utilizzare SPI0

Il primo tentativo è provare a utilizzare SPI0

Abbiamo utilizzato questi pin:

  • 3,3 V, massa
  • MOSI (rpi19 – gpio10)
  • MISO (rpi21 – gpio9)
  • CLOCK (rpi 23 – gpio 11)
  • CS (rpi 24 – gpio 8)
  • INT (shield 7 – gpio 17)
  • ENABLE (5 – gpio 22)
  • RESET_N (32 – gpio 27)

Non succede nulla. Proviamo anche con i sorgenti ufficiali del driver, ancora senza risultato. Il modulo sembra non caricarsi perché non trova dispositivi compatibili. Proviamo a modificare il device tree.

Il file bcm2710-rpi-cm3.dts mostra le seguenti righe:

&spi0 {
        pinctrl-names = "default";
        pinctrl-0 = <&spi0_pins &spi0_cs_pins>;
        cs-gpios = <&gpio 8 1>, <&gpio 7 1>;

        spidev0: spidev@0{
                compatible = "spidev";
                reg = <0>;      /* CE0 */
                #address-cells = <1>;
                #size-cells = <0>;
                spi-max-frequency = <125000000>;
        };

        spidev1: spidev@1{
                compatible = "spidev";
                reg = <1>;      /* CE1 */
                #address-cells = <1>;
                #size-cells = <0>;
                spi-max-frequency = <125000000>;
        };
};

Cosa succede se aggiungiamo “wilc1000” al nodo spi0 del device tree? Cerchiamo un esempio di overlay che utilizzi SPI.

https://github.com/raspberrypi/firmware/blob/master/boot/overlays/README

Per esempio enc28j60 utilizza SPI0: 

// Overlay for the Microchip ENC28J60 Ethernet Controller
/dts-v1/;
/plugin/;

/ {
	compatible = "brcm,bcm2835";

	fragment@0 {
		target = <&spi0>;
		__overlay__ {
			/* needed to avoid dtc warning */
			#address-cells = <1>;
			#size-cells = <0>;

			status = "okay";

			eth1: enc28j60@0{
				compatible = "microchip,enc28j60";
				reg = <0>; /* CE0 */
				pinctrl-names = "default";
				pinctrl-0 = <&eth1_pins>;
				interrupt-parent = <&gpio>;
				interrupts = <25 0x2>; /* falling edge */
				spi-max-frequency = <12000000>;
				status = "okay";
			};
		};
	};

	fragment@1 {
		target = <&spidev0>;
		__overlay__ {
			status = "disabled";
		};
	};

	fragment@2 {
		target = <&gpio>;
		__overlay__ {
			eth1_pins: eth1_pins {
				brcm,pins = <25>;
				brcm,function = <0>; /* in */
				brcm,pull = <0>; /* none */
			};
		};
	};

	__overrides__ {
		int_pin = <&eth1>, "interrupts:0",
		          <&eth1_pins>, "brcm,pins:0";
		speed   = <&eth1>, "spi-max-frequency:0";
	};
};

Proviamo prima ad aggiungere qualcosa su spi0 (aumentando il numero di dispositivi compatibili):

&spi0 {
        pinctrl-names = "default";
        pinctrl-0 = <&spi0_pins &spi0_cs_pins>;
        cs-gpios = <&gpio 8 1>, <&gpio 7 1>;

        spidev0: spidev@0{
                compatible = "spidev", "microchip,wilc1000", "microchip,wilc3000";
                reg = <0>;      /* CE0 */
                #address-cells = <1>;
                #size-cells = <0>;
                spi-max-frequency = <125000000>;
        };

        spidev1: spidev@1{
                compatible = "spidev";
                reg = <1>;      /* CE1 */
                #address-cells = <1>;
                #size-cells = <0>;
                spi-max-frequency = <125000000>;
        };
};

Dobbiamo ricompilare il DTB:

dtc -I dts -O dtb -o bcm2710-rpi-cm3.dtb bcm2710-rpi-cm3.dts

Se la compilazione fallisce con un errore fatale, occorre una versione diversa del compilatore DTC, disponibile qui:

https://github.com/beagleboard/bb.org-overlays/blob/master/dtc-overlay.sh

Lo script installerà una nuova versione di DTC per te.

Allora qual è il risultato della modifica?

Error: bcm2710-rpi-cm3.dts:3.1-9 syntax error
FATAL ERROR: Unable to parse input tree

Sembra che ci siano dipendenze difficili da gestire direttamente. Un approccio migliore è usare make dtbs. Prima rimuoviamo il file .stb, poi eseguiamo il comando. Per controllare che le modifiche siano presenti, riconvertiamo il file .dtb:

dtc -I dts -O dtb -o bcm2710-rpi-cm3.dtb bcm2710-rpi-cm3.dts

Le stringhe compatibili sono a posto, quindi copiamo nuovamente il .dtb per vedere cosa succede.

Anche questa volta dmesg non mostra messaggi di debug relativi a WILC, né compaiono segnali sull'oscilloscopio. Per qualche motivo il modulo del kernel non viene caricato. Passiamo quindi a un overlay: adattiamo quello di enc28j60 e finalmente il driver si carica, anche se restano alcuni errori.

Per prima cosa controlliamo i pin. Stiamo utilizzando la scheda di valutazione ATWILC3000

https://www.microchip.com/DevelopmentTools/ProductDetails/PartNO/ATWILC3000-SHLD

Ok, abbiamo trovato i pin da modificare, sono definiti in wilc_wlan.h:

#define GPIO_NUM		0x5B
#define GPIO_NUM_CHIP_EN	94
#define GPIO_NUM_RESET		60

Mentre l'attività gpio è principalmente confinata in wilc_netdev.c:

static int init_irq(struct net_device *dev)
{
	int ret = 0;
	struct wilc_vif *vif = netdev_priv(dev);
	struct wilc *wl = vif->wilc;

#if KERNEL_VERSION(3, 13, 0) < LINUX_VERSION_CODE

	wl->gpio_irq = gpiod_get(wl->dt_dev, "irq", GPIOD_IN);
	if (IS_ERR(wl->gpio_irq)) {
		dev_warn(wl->dev, "failed to get IRQ GPIO, load default\r\n");
		wl->gpio_irq = gpio_to_desc(GPIO_NUM);
		if (!wl->gpio_irq) {
			dev_warn(wl->dev, "failed to load default irq\r\n");
			return -1;
		}
	} else {
		dev_info(wl->dev, "got gpio_irq successfully\r\n");
	}

	ret = gpiod_direction_input(wl->gpio_irq);
	if (ret) {
		PRINT_ER(dev, "could not obtain gpio for WILC_INTR\n");
		return ret;
	}

	wl->dev_irq_num = gpiod_to_irq(wl->gpio_irq);
	if (wl->dev_irq_num < 0) {
		PRINT_ER(dev, "could not the IRQ\n");
		goto free_gpio;
	}
#else
	wl->gpio_irq = of_get_named_gpio_flags(wl->dt_dev->of_node,
					       "irq-gpios", 0, NULL);
	if (wl->gpio_irq < 0) {
		wl->gpio_irq = GPIO_NUM;
		dev_warn(wl->dev, "failed to get IRQ GPIO, load default\r\n");
	}

	if ((gpio_request(wl->gpio_irq, "WILC_INTR") == 0) &&
	    (gpio_direction_input(wl->gpio_irq) == 0)) {
		wl->dev_irq_num = gpio_to_irq(wl->gpio_irq);
	} else {
		dev_err(wl->dev, "could not obtain gpio for WILC_INTR\n");
		wl->gpio_irq = 0;
		return -1;
	}

#endif

	if (wl->io_type == WILC_HIF_SPI ||
		wl->io_type == WILC_HIF_SDIO_GPIO_IRQ) {
		if (request_threaded_irq(wl->dev_irq_num, isr_uh_routine,
					 isr_bh_routine, IRQF_TRIGGER_LOW |
							IRQF_ONESHOT |
							IRQF_NO_SUSPEND,
					 "WILC_IRQ", wl) < 0) {
			PRINT_ER(dev, "Failed to request IRQ\n");
			goto free_gpio;
		}
	} else {
		if (request_irq(wl->dev_irq_num, host_wakeup_isr,
					     IRQF_TRIGGER_FALLING |
					     IRQF_NO_SUSPEND,
					     "WILC_IRQ", wl) < 0) {
			PRINT_ER(dev, "Failed to request IRQ\n");
			goto free_gpio;
		}
	}

	PRINT_INFO(dev, GENERIC_DBG, "IRQ request succeeded IRQ-NUM= %d\n",
		   wl->dev_irq_num);
	enable_irq_wake(wl->dev_irq_num);
	return ret;

free_gpio:
#if KERNEL_VERSION(3, 13, 0) < LINUX_VERSION_CODE
	gpiod_put(wl->gpio_irq);
	wl->gpio_irq = NULL;
#else
	gpio_free(wl->gpio_irq);
	wl->gpio_irq = 0;
#endif
	return -1;
}

Quali pin dovremmo usare esattamente? Osservando l'albero dei dispositivi spi0, vediamo:

	spi0_pins: spi0_pins {
		brcm,pins = <9 10 11>;
		brcm,function = <4>; /* alt0 */
	};

	spi0_cs_pins: spi0_cs_pins {
		brcm,pins = <8 7>;
		brcm,function = <1>; /* output */
	};

9,10,11 si riferiscono ai pin BCM, così come 8,7 (CE0 e CE1). Se modifichiamo i GPIO per adattarli alla nostra scheda, avremo:

#define GPIO_NUM		17
#define GPIO_NUM_CHIP_EN	22
#define GPIO_NUM_RESET		27

Per ricavare la corrispondenza fra numeri dei pin BCM e GPIO possiamo usare lo strumento pinout:

Controllo del numero di revisione Raspberry Pi e della versione della scheda

Dall'oscilloscopio vediamo che i segnali sono ok, ad eccezione dell'IRQ. Si verificano ancora molti errori:

[  190.332404] WILC_SPI spi0.0 wlan0: INFO [wilc_mgmt_frame_register]Frame registering Frame Type: d0: Boolean: 0
[  190.332409] WILC_SPI spi0.0 wlan0: INFO [wilc_mgmt_frame_register]Return since mac is closed
[  190.332418] WILC_SPI spi0.0 wlan0: INFO [wilc_mgmt_frame_register]Frame registering Frame Type: d0: Boolean: 0
[  190.332423] WILC_SPI spi0.0 wlan0: INFO [wilc_mgmt_frame_register]Return since mac is closed
[  190.332429] WILC_SPI spi0.0 wlan0: INFO [wilc_mgmt_frame_register]Frame registering Frame Type: d0: Boolean: 0
[  190.332434] WILC_SPI spi0.0 wlan0: INFO [wilc_mgmt_frame_register]Return since mac is closed
[  190.333258] WILC_SPI spi0.0 wlan0: INFO [wilc_mac_open]MAC OPEN[5bbe9abd] wlan0
[  190.333277] WILC_SPI spi0.0 wlan0: INFO [wilc_init_host_int]Host[5bbe9abd][d3bbf768]
[  190.333288] WILC_SPI spi0.0 wlan0: INFO [wilc_mac_open]*** re-init ***
[  190.333296] WILC_SPI spi0.0 wlan0: INFO [wilc_wlan_init]Initializing WILC_Wlan
[  190.380069] WILC_SPI spi0.0 wlan0: ERR [wilc_wlan_initialize:914] Initializing WILC_Wlan FAILED
[  190.380075] WILC_SPI spi0.0 wlan0: ERR [wilc_mac_open:1038] Failed to initialize wilc
[  190.422027] WILC_SPI spi0.0 wlan0: INFO [wilc_mac_open]MAC OPEN[5bbe9abd] wlan0
[  190.422049] WILC_SPI spi0.0 wlan0: INFO [wilc_init_host_int]Host[5bbe9abd][d3bbf768]
[  190.422063] WILC_SPI spi0.0 wlan0: INFO [wilc_mac_open]*** re-init ***
[  190.422069] WILC_SPI spi0.0 wlan0: INFO [wilc_wlan_init]Initializing WILC_Wlan
[  190.468858] WILC_SPI spi0.0 wlan0: ERR [wilc_wlan_initialize:914] Initializing WILC_Wlan FAILED
[  190.468865] WILC_SPI spi0.0 wlan0: ERR [wilc_mac_open:1038] Failed to initialize wilc

Su MOSI i segnali sono regolari, con un periodo di circa 83 ns (l'originale indica 120 MHz, ma 83 ns corrispondono a circa 12 MHz). Proviamo comunque a limitare la frequenza massima a circa 12 MHz. MISO continua a non commutare: il problema era il pin Chip Select collegato male, quindi la scheda non riceveva alcun dato. Ora i log sono diversi:

[   31.033292] WILC_SPI spi0.0 wlan1: INFO [wilc_mgmt_frame_register]Frame registering Frame Type: d0: Boolean: 0
[   31.033302] WILC_SPI spi0.0 wlan1: INFO [wilc_mgmt_frame_register]Return since mac is closed
[   31.034900] WILC_SPI spi0.0 wlan1: INFO [wilc_mac_open]MAC OPEN[44438583] wlan1
[   31.034929] WILC_SPI spi0.0 wlan1: INFO [wilc_init_host_int]Host[44438583][f099fcee]
[   31.034946] WILC_SPI spi0.0 wlan1: INFO [wilc_mac_open]*** re-init ***
[   31.034957] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_init]Initializing WILC_Wlan
[   31.037212] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_initialize]WILC Initialization done
[   31.037798] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_get_firmware]Detect chip WILC3000
[   31.037810] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_get_firmware]loading firmware mchp/wilc3000_wifi_firmware.bin
[   31.037821] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_get_firmware]WLAN firmware: mchp/wilc3000_wifi_firmware.bin
[   31.037884] WILC_SPI spi0.0: Direct firmware load for mchp/wilc3000_wifi_firmware.bin failed with error -2
[   31.037901] WILC_SPI spi0.0 wlan1: ERR [wilc_wlan_get_firmware:554] mchp/wilc3000_wifi_firmware.bin - firmware not available
[   31.037912] WILC_SPI spi0.0 wlan1: ERR [wilc_wlan_initialize:940] Can't get firmware
[   31.038600] wilc_handle_isr,>> UNKNOWN_INTERRUPT - 0x00000000
[   32.072216] WILC_SPI spi0.0 wlan1: ERR [wilc_wlan_initialize:994] WLAN initialization FAILED
[   32.072229] WILC_SPI spi0.0 wlan1: ERR [wilc_mac_open:1038] Failed to initialize wilc
[   32.146622] WILC_SPI spi0.0 wlan1: INFO [wilc_mac_open]MAC OPEN[44438583] wlan1
[   32.146659] WILC_SPI spi0.0 wlan1: INFO [wilc_init_host_int]Host[44438583][f099fcee]
[   32.146682] WILC_SPI spi0.0 wlan1: INFO [wilc_mac_open]*** re-init ***
[   32.146693] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_init]Initializing WILC_Wlan
[   32.149139] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_initialize]WILC Initialization done
[   32.149699] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_get_firmware]Detect chip WILC3000
[   32.149710] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_get_firmware]loading firmware mchp/wilc3000_wifi_firmware.bin
[   32.149722] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_get_firmware]WLAN firmware: mchp/wilc3000_wifi_firmware.bin
[   32.149791] WILC_SPI spi0.0: Direct firmware load for mchp/wilc3000_wifi_firmware.bin failed with error -2
[   32.149808] WILC_SPI spi0.0 wlan1: ERR [wilc_wlan_get_firmware:554] mchp/wilc3000_wifi_firmware.bin - firmware not available
[   32.149818] WILC_SPI spi0.0 wlan1: ERR [wilc_wlan_initialize:940] Can't get firmware
[   32.150500] wilc_handle_isr,>> UNKNOWN_INTERRUPT - 0x00000000
[   33.192157] WILC_SPI spi0.0 wlan1: ERR [wilc_wlan_initialize:994] WLAN initialization FAILED
[   33.192170] WILC_SPI spi0.0 wlan1: ERR [wilc_mac_open:1038] Failed to initialize wilc

Il log è piuttosto chiaro:

[   32.149808] WILC_SPI spi0.0 wlan1: ERR [wilc_wlan_get_firmware:554] mchp/wilc3000_wifi_firmware.bin - firmware not available

Abbiamo aggiunto la cartella /lib/firmware/mchp e poi abbiamo copiato tutti i file .bin. Il firmware ora sembra essere caricato correttamente:

[  591.904853] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_init]Initializing WILC_Wlan
[  591.906736] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_initialize]WILC Initialization done
[  591.907229] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_get_firmware]Detect chip WILC3000
[  591.907239] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_get_firmware]loading firmware mchp/wilc3000_wifi_firmware.bin
[  591.907250] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_get_firmware]WLAN firmware: mchp/wilc3000_wifi_firmware.bin
[  591.907583] WILC_SPI spi0.0 wlan1: INFO [wilc_firmware_download]Downloading Firmware ...
[  591.907590] wilc_wlan_firmware_downloadDownloading firmware size = 135992
[  591.907815] wilc_handle_isr,>> UNKNOWN_INTERRUPT - 0x00000000
[  592.904440] wilc_wlan_firmware_download Offset = 119232
[  592.905271] wilc_handle_isr,>> UNKNOWN_INTERRUPT - 0x00000000
[  593.087863] wilc_wlan_firmware_download Offset = 135992
[  593.087890] WILC_SPI spi0.0 wlan1: INFO [wilc_firmware_download]Download Succeeded
[  593.087955] WILC_SPI spi0.0 wlan1: INFO [wilc_start_firmware]Starting Firmware ...
[  593.088708] wilc_handle_isr,>> UNKNOWN_INTERRUPT - 0x00000000
[  593.092393] WILC_SPI spi0.0 wlan1: INFO [wilc_start_firmware]Waiting for FW to get ready ...
[  593.093242] wilc_handle_isr,>> UNKNOWN_INTERRUPT - 0x00000000
[  593.184044] WILC_SPI spi0.0 wlan1: INFO [wilc_start_firmware]Firmware successfully started
[  593.198425] WILC_SPI spi0.0 wlan1: INFO [wilc_wlan_initialize]WILC Firmware Ver = WILC_WIFI_FW_REL_15_2_1 Build: 11257
[  593.198440] WILC_SPI spi0.0 wlan1: INFO [wilc_init_fw_config]Start configuring Firmware
[  593.310793] WILC_SPI spi0.0 wlan1: INFO [wilc_mac_open]Mac address: fa:f0:05:c0:26:90

E automaticamente abbiamo anche una nuova interfaccia Wi-Fi:

wlan1: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet6 fe80::f427:78e5:4143:2a15  prefixlen 64  scopeid 0x20<link>
        ether fa:f0:05:c0:26:90  txqueuelen 1000  (Ethernet)
        RX packets 5  bytes 718 (718.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 31  bytes 3295 (3.2 KiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

Purtroppo l'interfaccia non ottiene un indirizzo IP. La guida suggerisce questi comandi:

http://ww1.microchip.com/downloads/en/DeviceDoc/ATWILC1000-ATWILC3000-Wi-Fi-Link-Controller-Linux-User-Guide-DS70005328B.pdf

Comandi utili

Durante lo sviluppo puoi usare un adattatore Wi-Fi USB, per esempio uno supportato dal Raspberry Pi, e verificare quale dispositivo fisico corrisponde a una specifica interfaccia WLAN. Puoi farlo con:

ls -l /sys/class/net/

Inoltre, puoi eseguire uno script di ripristino all'avvio tramite il file /etc/init.rc (aggiungi l’avvio dello script dove serve). Un esempio di script è il seguente:

#!/bin/sh

LOGF=/home/pi/log_init_iface_wlan_spi.txt
TMPF=/home/pi/log_init_iface_wlan_spi.txt

ls -l /sys/class/net/ | grep -n wlan0 > $TMPF
IFACEID=`head -c 1 $TMPF`

echo "LDC - rc.local - reset spi wlan" > $LOGF
date >> $LOGF
echo IFACEID is $IFACEID >> $LOGF

WLANID="$(($IFACEID-3))"
WLANSTR="wlan"$WLANID
echo WLANSTR is $WLANSTR >> $LOGF

echo LDC: resetting ATWILC3000 on $WLANSTR
sleep 5
echo LDC: putting down $WLANSTR
sudo ip link set $WLANSTR down
echo LDC: pause
sleep 5
echo LDC: putting up $WLANSTR
sudo ip link set $WLANSTR up
echo LDC: wlan init finished

Questo viene richiamato in rc.local:

pi@raspberrypi:~ $ cat /etc/rc.local 
#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

# Print the IP address
_IP=$(hostname -I) || true
if [ "$_IP" ]; then
  printf "My IP address is %s\n" "$_IP"
fi

/home/pi/script_init_iface_wlan_spi.sh

exit 0

Una volta attivata l'interfaccia, l'applicazione deve attendere che venga assegnato un indirizzo IP, se è presente un server DHCP e le credenziali dell'access point sono configurate correttamente.

Aggiornamenti

Microchip ha fornito aggiornamenti per risolvere alcuni problemi sul driver utilizzato:

https://ww1.microchip.com/downloads/en/DeviceDoc/Wi-Fi_Link_Controller_Linux_Release_Notes_15.4.1.pdf

Sembra che ci sia qualcosa di cui abbiamo bisogno:

Estratto delle note di rilascio ATWILC Linux 15.4.1

Quindi eseguiamo il backup dei sorgenti correnti e compiliamo i nuovi:

https://github.com/linux4sam/linux-at91/tree/master/drivers/staging/wilc1000

Prima la connessione SSH si bloccava di tanto in tanto. Ora la situazione sembra molto migliorata.