Ignore:
Timestamp:
2010-05-19T19:07:40+02:00 (7 years ago)
Author:
nico
Message:

target/generic-2.6: add missing bits for 2.6.30 ssb update

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/generic-2.6/patches-2.6.30/941-ssb_update.patch

    r21269 r21507  
    129129--- a/drivers/ssb/main.c 
    130130+++ b/drivers/ssb/main.c 
    131 @@ -472,6 +472,8 @@ static int ssb_devices_register(struct s 
     131@@ -120,6 +120,19 @@ static void ssb_device_put(struct ssb_de 
     132                put_device(dev->dev); 
     133 } 
     134  
     135+static inline struct ssb_driver *ssb_driver_get(struct ssb_driver *drv) 
     136+{ 
     137+       if (drv) 
     138+               get_driver(&drv->drv); 
     139+       return drv; 
     140+} 
     141+ 
     142+static inline void ssb_driver_put(struct ssb_driver *drv) 
     143+{ 
     144+       if (drv) 
     145+               put_driver(&drv->drv); 
     146+} 
     147+ 
     148 static int ssb_device_resume(struct device *dev) 
     149 { 
     150        struct ssb_device *ssb_dev = dev_to_ssb_dev(dev); 
     151@@ -190,90 +203,81 @@ int ssb_bus_suspend(struct ssb_bus *bus) 
     152 EXPORT_SYMBOL(ssb_bus_suspend); 
     153  
     154 #ifdef CONFIG_SSB_SPROM 
     155-int ssb_devices_freeze(struct ssb_bus *bus) 
     156+/** ssb_devices_freeze - Freeze all devices on the bus. 
     157+ * 
     158+ * After freezing no device driver will be handling a device 
     159+ * on this bus anymore. ssb_devices_thaw() must be called after 
     160+ * a successful freeze to reactivate the devices. 
     161+ * 
     162+ * @bus: The bus. 
     163+ * @ctx: Context structure. Pass this to ssb_devices_thaw(). 
     164+ */ 
     165+int ssb_devices_freeze(struct ssb_bus *bus, struct ssb_freeze_context *ctx) 
     166 { 
     167-       struct ssb_device *dev; 
     168-       struct ssb_driver *drv; 
     169-       int err = 0; 
     170-       int i; 
     171-       pm_message_t state = PMSG_FREEZE; 
     172+       struct ssb_device *sdev; 
     173+       struct ssb_driver *sdrv; 
     174+       unsigned int i; 
     175+ 
     176+       memset(ctx, 0, sizeof(*ctx)); 
     177+       ctx->bus = bus; 
     178+       SSB_WARN_ON(bus->nr_devices > ARRAY_SIZE(ctx->device_frozen)); 
     179  
     180-       /* First check that we are capable to freeze all devices. */ 
     181        for (i = 0; i < bus->nr_devices; i++) { 
     182-               dev = &(bus->devices[i]); 
     183-               if (!dev->dev || 
     184-                   !dev->dev->driver || 
     185-                   !device_is_registered(dev->dev)) 
     186-                       continue; 
     187-               drv = drv_to_ssb_drv(dev->dev->driver); 
     188-               if (!drv) 
     189+               sdev = ssb_device_get(&bus->devices[i]); 
     190+ 
     191+               if (!sdev->dev || !sdev->dev->driver || 
     192+                   !device_is_registered(sdev->dev)) { 
     193+                       ssb_device_put(sdev); 
     194                        continue; 
     195-               if (!drv->suspend) { 
     196-                       /* Nope, can't suspend this one. */ 
     197-                       return -EOPNOTSUPP; 
     198                } 
     199-       } 
     200-       /* Now suspend all devices */ 
     201-       for (i = 0; i < bus->nr_devices; i++) { 
     202-               dev = &(bus->devices[i]); 
     203-               if (!dev->dev || 
     204-                   !dev->dev->driver || 
     205-                   !device_is_registered(dev->dev)) 
     206-                       continue; 
     207-               drv = drv_to_ssb_drv(dev->dev->driver); 
     208-               if (!drv) 
     209+               sdrv = ssb_driver_get(drv_to_ssb_drv(sdev->dev->driver)); 
     210+               if (!sdrv || SSB_WARN_ON(!sdrv->remove)) { 
     211+                       ssb_device_put(sdev); 
     212                        continue; 
     213-               err = drv->suspend(dev, state); 
     214-               if (err) { 
     215-                       ssb_printk(KERN_ERR PFX "Failed to freeze device %s\n", 
     216-                                  dev_name(dev->dev)); 
     217-                       goto err_unwind; 
     218                } 
     219+               sdrv->remove(sdev); 
     220+               ctx->device_frozen[i] = 1; 
     221        } 
     222  
     223        return 0; 
     224-err_unwind: 
     225-       for (i--; i >= 0; i--) { 
     226-               dev = &(bus->devices[i]); 
     227-               if (!dev->dev || 
     228-                   !dev->dev->driver || 
     229-                   !device_is_registered(dev->dev)) 
     230-                       continue; 
     231-               drv = drv_to_ssb_drv(dev->dev->driver); 
     232-               if (!drv) 
     233-                       continue; 
     234-               if (drv->resume) 
     235-                       drv->resume(dev); 
     236-       } 
     237-       return err; 
     238 } 
     239  
     240-int ssb_devices_thaw(struct ssb_bus *bus) 
     241+/** ssb_devices_thaw - Unfreeze all devices on the bus. 
     242+ * 
     243+ * This will re-attach the device drivers and re-init the devices. 
     244+ * 
     245+ * @ctx: The context structure from ssb_devices_freeze() 
     246+ */ 
     247+int ssb_devices_thaw(struct ssb_freeze_context *ctx) 
     248 { 
     249-       struct ssb_device *dev; 
     250-       struct ssb_driver *drv; 
     251-       int err; 
     252-       int i; 
     253+       struct ssb_bus *bus = ctx->bus; 
     254+       struct ssb_device *sdev; 
     255+       struct ssb_driver *sdrv; 
     256+       unsigned int i; 
     257+       int err, result = 0; 
     258  
     259        for (i = 0; i < bus->nr_devices; i++) { 
     260-               dev = &(bus->devices[i]); 
     261-               if (!dev->dev || 
     262-                   !dev->dev->driver || 
     263-                   !device_is_registered(dev->dev)) 
     264+               if (!ctx->device_frozen[i]) 
     265                        continue; 
     266-               drv = drv_to_ssb_drv(dev->dev->driver); 
     267-               if (!drv) 
     268+               sdev = &bus->devices[i]; 
     269+ 
     270+               if (SSB_WARN_ON(!sdev->dev || !sdev->dev->driver)) 
     271                        continue; 
     272-               if (SSB_WARN_ON(!drv->resume)) 
     273+               sdrv = drv_to_ssb_drv(sdev->dev->driver); 
     274+               if (SSB_WARN_ON(!sdrv || !sdrv->probe)) 
     275                        continue; 
     276-               err = drv->resume(dev); 
     277+ 
     278+               err = sdrv->probe(sdev, &sdev->id); 
     279                if (err) { 
     280                        ssb_printk(KERN_ERR PFX "Failed to thaw device %s\n", 
     281-                                  dev_name(dev->dev)); 
     282+                                  dev_name(sdev->dev)); 
     283+                       result = err; 
     284                } 
     285+               ssb_driver_put(sdrv); 
     286+               ssb_device_put(sdev); 
     287        } 
     288  
     289-       return 0; 
     290+       return result; 
     291 } 
     292 #endif /* CONFIG_SSB_SPROM */ 
     293  
     294@@ -472,6 +476,8 @@ static int ssb_devices_register(struct s 
    132295                case SSB_BUSTYPE_SSB: 
    133296                        dev->dma_mask = &dev->coherent_dma_mask; 
     
    138301  
    139302                sdev->dev = dev; 
    140 @@ -1358,8 +1360,10 @@ static int __init ssb_modinit(void) 
     303@@ -1358,8 +1364,10 @@ static int __init ssb_modinit(void) 
    141304        ssb_buses_lock(); 
    142305        err = ssb_attach_queued_buses(); 
     
    150313        err = b43_pci_ssb_bridge_init(); 
    151314        if (err) { 
    152 @@ -1375,7 +1379,7 @@ static int __init ssb_modinit(void) 
     315@@ -1375,7 +1383,7 @@ static int __init ssb_modinit(void) 
    153316                /* don't fail SSB init because of this */ 
    154317                err = 0; 
Note: See TracChangeset for help on using the changeset viewer.