Package decoupling in go

We all know dependency injection makes packages decoupled. But I'm a little confused about best practices of dependency injection in go.
Lets assume package User needs to access Config package.
We can pass a Config object to User methods. In this way I can change the Config package functionality as long as the new code resolves the interfaces. Another approach is call Config package methods directly , In these scenario I can change Config code too as long as the methods names remains the same. Like so

Update :

What is different between these two approaches :

package User

func foo(config ConfigObject) {
   config.Foo()
}

And this one :

package User

import Config

func foo() {
   config.Foo()
}

Calling config.Foo on the config argument to a method means that you receive an instance of some structure (possibly implementing interface Config) and call the method Foo on that instance/interface. Think of this as of calling a method of an object in OO terms:

package user

func foo(cfg config.Config) {
   cfg.Foo()
}

Calling config.Foo having imported the config package means you are calling the function Foo of package config, not of any object/struct/interface. Think of this as pure procedural programming without any objects:

package user

import config

func foo() {
   config.Foo()
}

The latter has nothing to do with dependency injection, the former may constitute a part of it if Config is an interface.

Dependency injection, on the other hand, follows generally the same rules in Go as in other languages:

accept interfaces, supply implementations

Because in Go structs satisfy interfaces implicitly rather than explicitly (as it is the case in Java)

the code accepting the value only needs to know about the interface and import it;
the code implementing it does not even need to know about the interface (it can just happen that it satisfies it);
the code that supplies the impl into a method accepting an interface, obviously, needs to know both.

For your example this means:

package config

type Config interface {
    Foo() string
}

package foo

type Foo struct{}

func (f *Foo) Foo() string {
    return "foo"
}

package boo

type Boo struct{}

func (b *Boo) Foo() string {
    return "boo" 
}

package main

func foo(cfg config.Config) string{
    return cfg.Foo()
}

func main() {
    // here you inject an instance of Foo into foo(Config)

    log.Print(foo(&foo.Foo{}))

    // here you inject an instance of Boo into foo(Config)
    log.Print(foo(&boo.Boo{})
}

Prints