Changeset 37087


Ignore:
Timestamp:
2013-06-29T18:33:46+02:00 (5 years ago)
Author:
blogic
Message:

lantiq: Add support for loading athxk eeproms through mtd

This patch enables retrieving the wifi calibration data from an MTD partition.
Try to copy mac address from ethernet before generating a random one.
This fixes DGN3500 ath9k support.

Signed-off-by: Daniel Gimpelevich <daniel@…>
Signed-off-by: Álvaro Fernández Rojas <noltari@…>

Location:
trunk/target/linux/lantiq
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/lantiq/dts/DGN3500.dtsi

    r36882 r37087  
    117117                ath,eep-flash = <&ath9k_cal 0xf000>; 
    118118                ath,pci-slot = <14>; 
     119                ath,eep-endian; 
    119120                ath,eep-swap; 
    120121        }; 
  • trunk/target/linux/lantiq/patches-3.8/0037-owrt-lantiq-wifi-and-ethernet-eeprom-handling.patch

    r36901 r37087  
    5151--- /dev/null 
    5252+++ b/arch/mips/lantiq/xway/ath_eep.c 
    53 @@ -0,0 +1,195 @@ 
     53@@ -0,0 +1,248 @@ 
    5454+/* 
    5555+ *  Copyright (C) 2011 Luca Olivetti <luca@ventoso.org> 
     
    5757+ *  Copyright (C) 2011 Andrej VlaÅ¡ić <andrej.vlasic0@gmail.com> 
    5858+ *  Copyright (C) 2013 Álvaro Fernández Rojas <noltari@gmail.com> 
     59+ *  Copyright (C) 2013 Daniel Gimpelevich <daniel@gimpelevich.san-francisco.ca.us> 
    5960+ * 
    6061+ *  This program is free software; you can redistribute it and/or modify it 
     
    7071+#include <linux/ath9k_platform.h> 
    7172+#include <linux/pci.h> 
     73+#include <linux/err.h> 
     74+#include <linux/mtd/mtd.h> 
    7275+#include <pci-ath-fixup.h> 
     76+#include <lantiq_soc.h> 
    7377+ 
    7478+extern int (*ltq_pci_plat_dev_init)(struct pci_dev *dev); 
     
    8791+int __init of_ath9k_eeprom_probe(struct platform_device *pdev) 
    8892+{ 
    89 +       struct device_node *np = pdev->dev.of_node; 
    90 +       struct resource *eep_res, *mac_res; 
     93+       struct device_node *np = pdev->dev.of_node, *mtd_np; 
     94+       struct resource *eep_res, *mac_res = NULL; 
    9195+       void __iomem *eep, *mac; 
    9296+       int mac_offset; 
    9397+       u32 mac_inc = 0, pci_slot = 0; 
    9498+       int i; 
    95 + 
    96 +       eep_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
    97 +       mac_res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 
    98 + 
    99 +       if (!eep_res) { 
    100 +               dev_err(&pdev->dev, "failed to load eeprom address\n"); 
    101 +               return -ENODEV; 
    102 +       } 
    103 +       if (resource_size(eep_res) != ATH9K_PLAT_EEP_MAX_WORDS << 1) { 
    104 +               dev_err(&pdev->dev, "eeprom has an invalid size\n"); 
    105 +               return -EINVAL; 
    106 +       } 
    107 + 
    108 +       eep = ioremap(eep_res->start, resource_size(eep_res)); 
    109 +       memcpy_fromio(ath9k_pdata.eeprom_data, eep, ATH9K_PLAT_EEP_MAX_WORDS << 1); 
     99+       struct mtd_info *the_mtd; 
     100+       size_t flash_readlen; 
     101+       const __be32 *list; 
     102+       const char *part; 
     103+       phandle phandle; 
     104+ 
     105+       if ((list = of_get_property(np, "ath,eep-flash", &i)) && i == 2 * 
     106+                       sizeof(*list) && (phandle = be32_to_cpup(list++)) && 
     107+                       (mtd_np = of_find_node_by_phandle(phandle)) && ((part = 
     108+                       of_get_property(mtd_np, "label", NULL)) || (part = 
     109+                       mtd_np->name)) && (the_mtd = get_mtd_device_nm(part)) 
     110+                       != ERR_PTR(-ENODEV)) { 
     111+               i = mtd_read(the_mtd, be32_to_cpup(list), 
     112+                               ATH9K_PLAT_EEP_MAX_WORDS << 1, &flash_readlen, 
     113+                               (void *) ath9k_pdata.eeprom_data); 
     114+               put_mtd_device(the_mtd); 
     115+               if ((sizeof(ath9k_pdata.eeprom_data) != flash_readlen) || i) { 
     116+                       dev_err(&pdev->dev, "failed to load eeprom from mtd\n"); 
     117+                       return -ENODEV; 
     118+               } 
     119+       } else { 
     120+               eep_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
     121+               mac_res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 
     122+ 
     123+               if (!eep_res) { 
     124+                       dev_err(&pdev->dev, "failed to load eeprom address\n"); 
     125+                       return -ENODEV; 
     126+               } 
     127+               if (resource_size(eep_res) != ATH9K_PLAT_EEP_MAX_WORDS << 1) { 
     128+                       dev_err(&pdev->dev, "eeprom has an invalid size\n"); 
     129+                       return -EINVAL; 
     130+               } 
     131+ 
     132+               eep = ioremap(eep_res->start, resource_size(eep_res)); 
     133+               memcpy_fromio(ath9k_pdata.eeprom_data, eep, 
     134+                               ATH9K_PLAT_EEP_MAX_WORDS << 1); 
     135+       } 
    110136+ 
    111137+       if (of_find_property(np, "ath,eep-swap", NULL)) 
     
    128154+               mac = ioremap(mac_res->start, resource_size(mac_res)); 
    129155+               memcpy_fromio(athxk_eeprom_mac, mac, 6); 
    130 +       } else { 
     156+       } else if (ltq_get_eth_mac()) 
     157+               memcpy(athxk_eeprom_mac, ltq_get_eth_mac(), 6); 
     158+       else { 
    131159+               dev_warn(&pdev->dev, "using random mac\n"); 
    132160+               random_ether_addr(athxk_eeprom_mac); 
     
    178206+int __init of_ath5k_eeprom_probe(struct platform_device *pdev) 
    179207+{ 
    180 +       struct device_node *np = pdev->dev.of_node; 
    181 +       struct resource *eep_res, *mac_res; 
     208+       struct device_node *np = pdev->dev.of_node, *mtd_np; 
     209+       struct resource *eep_res, *mac_res = NULL; 
    182210+       void __iomem *eep, *mac; 
    183211+       int mac_offset; 
    184212+       u32 mac_inc = 0; 
    185213+       int i; 
    186 + 
    187 +       eep_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
    188 +       mac_res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 
    189 + 
    190 +       if (!eep_res) { 
    191 +               dev_err(&pdev->dev, "failed to load eeprom address\n"); 
    192 +               return -ENODEV; 
    193 +       } 
    194 +       if (resource_size(eep_res) != ATH5K_PLAT_EEP_MAX_WORDS << 1) { 
    195 +               dev_err(&pdev->dev, "eeprom has an invalid size\n"); 
    196 +               return -EINVAL; 
    197 +       } 
    198 + 
    199 +       eep = ioremap(eep_res->start, resource_size(eep_res)); 
    200 +       memcpy_fromio(ath5k_pdata.eeprom_data, eep, ATH5K_PLAT_EEP_MAX_WORDS << 1); 
     214+       struct mtd_info *the_mtd; 
     215+       size_t flash_readlen; 
     216+       const __be32 *list; 
     217+       const char *part; 
     218+       phandle phandle; 
     219+ 
     220+       if ((list = of_get_property(np, "ath,eep-flash", &i)) && i == 2 * 
     221+                       sizeof(*list) && (phandle = be32_to_cpup(list++)) && 
     222+                       (mtd_np = of_find_node_by_phandle(phandle)) && ((part = 
     223+                       of_get_property(mtd_np, "label", NULL)) || (part = 
     224+                       mtd_np->name)) && (the_mtd = get_mtd_device_nm(part)) 
     225+                       != ERR_PTR(-ENODEV)) { 
     226+               i = mtd_read(the_mtd, be32_to_cpup(list), 
     227+                               ATH5K_PLAT_EEP_MAX_WORDS << 1, &flash_readlen, 
     228+                               (void *) ath5k_pdata.eeprom_data); 
     229+               put_mtd_device(the_mtd); 
     230+               if ((sizeof(ATH5K_PLAT_EEP_MAX_WORDS << 1) != flash_readlen) 
     231+                               || i) { 
     232+                       dev_err(&pdev->dev, "failed to load eeprom from mtd\n"); 
     233+                       return -ENODEV; 
     234+               } 
     235+       } else { 
     236+               eep_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
     237+               mac_res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 
     238+ 
     239+               if (!eep_res) { 
     240+                       dev_err(&pdev->dev, "failed to load eeprom address\n"); 
     241+                       return -ENODEV; 
     242+               } 
     243+               if (resource_size(eep_res) != ATH5K_PLAT_EEP_MAX_WORDS << 1) { 
     244+                       dev_err(&pdev->dev, "eeprom has an invalid size\n"); 
     245+                       return -EINVAL; 
     246+               } 
     247+ 
     248+               eep = ioremap(eep_res->start, resource_size(eep_res)); 
     249+               memcpy_fromio(ath5k_pdata.eeprom_data, eep, 
     250+                               ATH5K_PLAT_EEP_MAX_WORDS << 1); 
     251+       } 
    201252+ 
    202253+       if (of_find_property(np, "ath,eep-swap", NULL)) 
     
    213264+               mac = ioremap(mac_res->start, resource_size(mac_res)); 
    214265+               memcpy_fromio(athxk_eeprom_mac, mac, 6); 
    215 +       } else { 
     266+       } else if (ltq_get_eth_mac()) 
     267+               memcpy(athxk_eeprom_mac, ltq_get_eth_mac(), 6); 
     268+       else { 
    216269+               dev_warn(&pdev->dev, "using random mac\n"); 
    217270+               random_ether_addr(athxk_eeprom_mac); 
Note: See TracChangeset for help on using the changeset viewer.